diff --git a/Eigen/AccelerateSupport b/Eigen/AccelerateSupport
index 533be68..155c24a 100644
--- a/Eigen/AccelerateSupport
+++ b/Eigen/AccelerateSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ACCELERATESUPPORT_MODULE_H
 #define EIGEN_ACCELERATESUPPORT_MODULE_H
diff --git a/Eigen/Cholesky b/Eigen/Cholesky
index b05ed82..e7cc0d9 100644
--- a/Eigen/Cholesky
+++ b/Eigen/Cholesky
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CHOLESKY_MODULE_H
 #define EIGEN_CHOLESKY_MODULE_H
@@ -15,14 +17,16 @@
 
 /** \defgroup Cholesky_Module Cholesky module
  *
- *
- *
- * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
- * Those decompositions are also accessible via the following methods:
+ * This module provides three variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
+ * LLT and LDLT are restricted to (semi)definite matrices, while the Bunch-Kaufman factorization handles
+ * general symmetric / Hermitian indefinite matrices. Those decompositions are also accessible via the
+ * following methods:
  *  - MatrixBase::llt()
  *  - MatrixBase::ldlt()
+ *  - MatrixBase::bunchKaufman()
  *  - SelfAdjointView::llt()
  *  - SelfAdjointView::ldlt()
+ *  - SelfAdjointView::bunchKaufman()
  *
  * \code
  * #include <Eigen/Cholesky>
@@ -32,8 +36,9 @@
 // IWYU pragma: begin_exports
 #include "src/Cholesky/LLT.h"
 #include "src/Cholesky/LDLT.h"
+#include "src/Cholesky/BunchKaufman.h"
 #ifdef EIGEN_USE_LAPACKE
-#include "src/misc/lapacke_helpers.h"
+#include "src/LAPACKESupport/lapacke_helpers.h"
 #include "src/Cholesky/LLT_LAPACKE.h"
 #endif
 // IWYU pragma: end_exports
diff --git a/Eigen/CholmodSupport b/Eigen/CholmodSupport
index adc5f8d..02f1314 100644
--- a/Eigen/CholmodSupport
+++ b/Eigen/CholmodSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
 #define EIGEN_CHOLMODSUPPORT_MODULE_H
@@ -26,7 +28,7 @@
  * For the sake of completeness, this module also propose the two following classes:
  * - class CholmodSimplicialLLT
  * - class CholmodSimplicialLDLT
- * Note that these classes does not bring any particular advantage compared to the built-in
+ * Note that these classes do not bring any particular advantage compared to the built-in
  * SimplicialLLT and SimplicialLDLT factorization classes.
  *
  * \code
diff --git a/Eigen/Core b/Eigen/Core
index 47d599c..50d1f5f 100644
--- a/Eigen/Core
+++ b/Eigen/Core
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CORE_MODULE_H
 #define EIGEN_CORE_MODULE_H
@@ -32,16 +33,10 @@
 #include <hip/hip_runtime.h>
 #endif
 
-#ifdef EIGEN_EXCEPTIONS
+#if defined(EIGEN_EXCEPTIONS) || defined(EIGEN_GPU_COMPILE_PHASE)
 #include <new>
 #endif
 
-// Disable the ipa-cp-clone optimization flag with MinGW 6.x or older (enabled by default with -O3)
-// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
-#if EIGEN_COMP_MINGW && EIGEN_GNUC_STRICT_LESS_THAN(6, 0, 0)
-#pragma GCC optimize("-fno-ipa-cp-clone")
-#endif
-
 // Prevent ICC from specializing std::complex operators that silently fail
 // on device. This allows us to use our own device-compatible specializations
 // instead.
@@ -53,12 +48,10 @@
 // this include file manages BLAS and MKL related macros
 // and inclusion of their respective header files
 #include "src/Core/util/MKL_support.h"
-#include "src/Core/util/AOCL_Support.h"    // ← ADD THIS
+#include "src/Core/util/AOCL_Support.h"
 
-
-#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
-#define EIGEN_HAS_GPU_FP16
-#endif
+// EIGEN_HAS_GPU_FP16 is defined in Macros.h when compiling with CUDA or HIP (excluding SPIR-V).
+// TODO: Remove EIGEN_HAS_GPU_BF16 similarly once HIP bf16 guards are cleaned up.
 
 #if defined(EIGEN_HAS_CUDA_BF16) || defined(EIGEN_HAS_HIP_BF16)
 #define EIGEN_HAS_GPU_BF16
@@ -73,8 +66,7 @@
 #include <omp.h>
 #endif
 
-// MSVC for windows mobile does not have the errno.h file
-#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
+#if !EIGEN_COMP_ARM
 #define EIGEN_HAS_ERRNO
 #endif
 
@@ -103,6 +95,9 @@
 // for std::is_nothrow_move_assignable
 #include <type_traits>
 
+// for std::move, std::forward, std::declval
+#include <utility>
+
 // for std::this_thread::yield().
 #if !defined(EIGEN_USE_BLAS) && (defined(EIGEN_HAS_OPENMP) || defined(EIGEN_GEMM_THREADPOOL))
 #include <thread>
@@ -125,12 +120,17 @@
 
 // required for __cpuid, needs to be included after cmath
 // also required for _BitScanReverse on Windows on ARM
-#if EIGEN_COMP_MSVC && (EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM64) && !EIGEN_OS_WINCE
+#if EIGEN_COMP_MSVC && (EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM64)
 #include <intrin.h>
 #endif
 
 // Required for querying cache sizes on Linux and macOS.
 #if EIGEN_OS_LINUX
+#if !defined(EIGEN_NO_CPU_CACHE_SYSFS)
+#include <cstdio>
+#include <fcntl.h>
+#include <sched.h>
+#endif
 #include <unistd.h>
 #elif EIGEN_OS_MAC
 #include <sys/types.h>
@@ -146,7 +146,6 @@
 #include <CL/sycl.hpp>
 #include <map>
 #include <thread>
-#include <utility>
 #ifndef EIGEN_SYCL_LOCAL_THREAD_DIM0
 #define EIGEN_SYCL_LOCAL_THREAD_DIM0 16
 #endif
@@ -155,20 +154,10 @@
 #endif
 #endif
 
-#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || \
-    defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API ||  \
-    defined EIGEN2_SUPPORT
-// This will generate an error message:
-#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
-#endif
-
 namespace Eigen {
 
-// we use size_t frequently and we'll never remember to prepend it with std:: every time just to
-// ensure QNX/QCC support
-using std::size_t;
-// gcc 4.6.0 wants std:: for ptrdiff_t
 using std::ptrdiff_t;
+using std::size_t;
 
 }  // namespace Eigen
 
@@ -185,12 +174,19 @@
 #ifdef EIGEN_USE_LAPACKE
 #ifdef EIGEN_USE_MKL
 #include "mkl_lapacke.h"
+#elif defined(EIGEN_LAPACKE_SYSTEM)
+#include <lapacke.h>
 #else
-#include "src/misc/lapacke.h"
+#include "src/LAPACKESupport/lapacke.h"
 #endif
 #endif
 
 // IWYU pragma: begin_exports
+// Device overloads of the std::complex operators. They must precede every template that applies an operator to a
+// dependent Scalar; see the header.
+#ifdef EIGEN_GPUCC
+#include "src/Core/arch/GPU/Complex.h"
+#endif
 #include "src/Core/util/Constants.h"
 #include "src/Core/util/Meta.h"
 #include "src/Core/util/Assert.h"
@@ -203,6 +199,7 @@
 #include "src/Core/util/SymbolicIndex.h"
 #include "src/Core/util/EmulateArray.h"
 #include "src/Core/util/MoreMeta.h"
+#include "src/Core/util/LruCache.h"
 
 #include "src/Core/NumTraits.h"
 #include "src/Core/MathFunctions.h"
@@ -278,6 +275,12 @@
 #include "src/Core/arch/NEON/TypeCasting.h"
 #include "src/Core/arch/NEON/MathFunctions.h"
 #include "src/Core/arch/NEON/Complex.h"
+#elif defined EIGEN_VECTORIZE_SME
+// Utilize NEON for non-GEMM kernels.
+#include "src/Core/arch/NEON/PacketMath.h"
+#include "src/Core/arch/NEON/TypeCasting.h"
+#include "src/Core/arch/NEON/MathFunctions.h"
+#include "src/Core/arch/NEON/Complex.h"
 #elif defined EIGEN_VECTORIZE_LSX
 #include "src/Core/arch/LSX/PacketMath.h"
 #include "src/Core/arch/LSX/TypeCasting.h"
@@ -287,10 +290,12 @@
 #include "src/Core/arch/SVE/PacketMath.h"
 #include "src/Core/arch/SVE/TypeCasting.h"
 #include "src/Core/arch/SVE/MathFunctions.h"
+#include "src/Core/arch/SVE/Complex.h"
 #elif defined EIGEN_VECTORIZE_RVV10
+#include "src/Core/arch/RVV10/PacketMathDecl.h"
 #include "src/Core/arch/RVV10/PacketMath.h"
-#include "src/Core/arch/RVV10/PacketMath4.h"
 #include "src/Core/arch/RVV10/PacketMath2.h"
+#include "src/Core/arch/RVV10/PacketMath4.h"
 #include "src/Core/arch/RVV10/TypeCasting.h"
 #include "src/Core/arch/RVV10/MathFunctions.h"
 #if defined EIGEN_VECTORIZE_RVV10FP16
@@ -299,6 +304,10 @@
 #if defined EIGEN_VECTORIZE_RVV10BF16
 #include "src/Core/arch/RVV10/PacketMathBF16.h"
 #endif
+#if EIGEN_RISCV64_DEFAULT_LMUL == 1
+#include "src/Core/arch/RVV10/Complex.h"
+#include "src/Core/arch/RVV10/Complex2.h"
+#endif
 #elif defined EIGEN_VECTORIZE_ZVECTOR
 #include "src/Core/arch/ZVector/PacketMath.h"
 #include "src/Core/arch/ZVector/MathFunctions.h"
@@ -339,11 +348,6 @@
 #include "src/Core/functors/StlFunctors.h"
 #include "src/Core/functors/AssignmentFunctors.h"
 
-// Specialized functors for GPU.
-#ifdef EIGEN_GPUCC
-#include "src/Core/arch/GPU/Complex.h"
-#endif
-
 // Specializations of vectorized activation functions for NEON.
 #ifdef EIGEN_VECTORIZE_NEON
 #include "src/Core/arch/NEON/UnaryFunctors.h"
@@ -371,13 +375,12 @@
 #include "src/Core/DenseStorage.h"
 #include "src/Core/NestByValue.h"
 
-// #include "src/Core/ForceAlignedAccess.h"
-
 #include "src/Core/ReturnByValue.h"
 #include "src/Core/NoAlias.h"
 #include "src/Core/PlainObjectBase.h"
 #include "src/Core/Matrix.h"
 #include "src/Core/Array.h"
+#include "src/Core/StructuredBindings.h"
 #include "src/Core/Fill.h"
 #include "src/Core/CwiseTernaryOp.h"
 #include "src/Core/CwiseBinaryOp.h"
@@ -386,6 +389,7 @@
 #include "src/Core/CwiseUnaryView.h"
 #include "src/Core/SelfCwiseBinaryOp.h"
 #include "src/Core/InnerProduct.h"
+#include "src/Core/SafeScaling.h"
 #include "src/Core/Dot.h"
 #include "src/Core/StableNorm.h"
 #include "src/Core/Stride.h"
@@ -414,6 +418,7 @@
 #include "src/Core/PermutationMatrix.h"
 #include "src/Core/Transpositions.h"
 #include "src/Core/TriangularMatrix.h"
+#include "src/Core/MatrixNorms.h"
 #include "src/Core/SelfAdjointView.h"
 #include "src/Core/products/GeneralBlockPanelKernel.h"
 #include "src/Core/DeviceWrapper.h"
@@ -422,6 +427,7 @@
 #endif
 #include "src/Core/products/Parallelizer.h"
 #include "src/Core/ProductEvaluators.h"
+#include "src/Core/ScaledPermutationMatrix.h"
 #include "src/Core/products/GeneralMatrixVector.h"
 #include "src/Core/products/GeneralMatrixMatrix.h"
 #include "src/Core/SolveTriangular.h"
@@ -434,6 +440,7 @@
 #include "src/Core/products/TriangularMatrixMatrix.h"
 #include "src/Core/products/TriangularSolverMatrix.h"
 #include "src/Core/products/TriangularSolverVector.h"
+#include "src/Core/TriangularInPlace.h"
 #include "src/Core/BandMatrix.h"
 #include "src/Core/CoreIterators.h"
 #include "src/Core/ConditionEstimator.h"
@@ -443,6 +450,10 @@
 #include "src/Core/arch/AltiVec/MatrixProduct.h"
 #elif defined EIGEN_VECTORIZE_NEON
 #include "src/Core/arch/NEON/GeneralBlockPanelKernel.h"
+#elif defined EIGEN_VECTORIZE_SVE
+#include "src/Core/arch/SVE/GeneralBlockPanelKernel.h"
+#elif defined EIGEN_VECTORIZE_SME
+#include "src/Core/arch/SME/GeneralBlockPanelKernel.h"
 #elif defined EIGEN_VECTORIZE_LSX
 #include "src/Core/arch/LSX/GeneralBlockPanelKernel.h"
 #elif defined EIGEN_VECTORIZE_RVV10
@@ -459,6 +470,7 @@
 #include "src/Core/PartialReduxEvaluator.h"
 #include "src/Core/Random.h"
 #include "src/Core/Replicate.h"
+#include "src/Core/ConcatOp.h"
 #include "src/Core/Reverse.h"
 #include "src/Core/ArrayWrapper.h"
 #include "src/Core/StlIterators.h"
diff --git a/Eigen/Dense b/Eigen/Dense
index 5768910..02131c9 100644
--- a/Eigen/Dense
+++ b/Eigen/Dense
@@ -1,3 +1,15 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_DENSE_MODULE_H
+#define EIGEN_DENSE_MODULE_H
+
 #include "Core"
 #include "LU"
 #include "Cholesky"
@@ -5,3 +17,5 @@
 #include "SVD"
 #include "Geometry"
 #include "Eigenvalues"
+
+#endif  // EIGEN_DENSE_MODULE_H
diff --git a/Eigen/Eigen b/Eigen/Eigen
index 654c8dc..06e0495 100644
--- a/Eigen/Eigen
+++ b/Eigen/Eigen
@@ -1,2 +1,16 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_EIGEN_MODULE_H
+#define EIGEN_EIGEN_MODULE_H
+
 #include "Dense"
 #include "Sparse"
+
+#endif  // EIGEN_EIGEN_MODULE_H
diff --git a/Eigen/Eigenvalues b/Eigen/Eigenvalues
index 8039000..50e8091 100644
--- a/Eigen/Eigenvalues
+++ b/Eigen/Eigenvalues
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_EIGENVALUES_MODULE_H
 #define EIGEN_EIGENVALUES_MODULE_H
@@ -11,18 +13,16 @@
 #include "Core"
 
 #include "Cholesky"
-#include "Jacobi"
-#include "Householder"
 #include "LU"
 #include "Geometry"
-#include "Sparse"  // Needed by ComplexQZ.
+// ComplexQZ only needs SparseQR. Include it directly rather than the broad Sparse umbrella to avoid a
+// cyclic dependency: Eigenvalues -> Sparse -> IterativeLinearSolvers -> DGMRES -> Eigenvalues.
+#include "SparseQR"
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
 /** \defgroup Eigenvalues_Module Eigenvalues module
  *
- *
- *
  * This module mainly provides various eigenvalue solvers.
  * This module also provides some MatrixBase methods, including:
  *  - MatrixBase::eigenvalues(),
@@ -38,6 +38,9 @@
 #include "src/Eigenvalues/RealSchur.h"
 #include "src/Eigenvalues/EigenSolver.h"
 #include "src/Eigenvalues/SelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/TridiagonalBisection.h"
+#include "src/Eigenvalues/TridiagonalInverseIteration.h"
+#include "src/Eigenvalues/TridiagonalEigenSolver.h"
 #include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
 #include "src/Eigenvalues/HessenbergDecomposition.h"
 #include "src/Eigenvalues/ComplexSchur.h"
@@ -49,8 +52,10 @@
 #ifdef EIGEN_USE_LAPACKE
 #ifdef EIGEN_USE_MKL
 #include "mkl_lapacke.h"
+#elif defined(EIGEN_LAPACKE_SYSTEM)
+#include <lapacke.h>
 #else
-#include "src/misc/lapacke.h"
+#include "src/LAPACKESupport/lapacke.h"
 #endif
 #include "src/Eigenvalues/RealSchur_LAPACKE.h"
 #include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
diff --git a/Eigen/Geometry b/Eigen/Geometry
index fd81ae2..322261d 100644
--- a/Eigen/Geometry
+++ b/Eigen/Geometry
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GEOMETRY_MODULE_H
 #define EIGEN_GEOMETRY_MODULE_H
@@ -12,7 +14,6 @@
 
 #include "SVD"
 #include "LU"
-#include <limits>
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
@@ -24,7 +25,8 @@
  *  - \link Quaternion quaternions \endlink
  *  - cross products (\ref MatrixBase::cross(), \ref MatrixBase::cross3())
  *  - orthogonal vector generation (MatrixBase::unitOrthogonal)
- *  - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink
+ *  - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes
+ * \endlink
  *  - \link AlignedBox axis aligned bounding boxes \endlink
  *  - \link umeyama() least-square transformation fitting \endlink
  * \code
diff --git a/Eigen/Householder b/Eigen/Householder
index 5070e07..a1c8a42 100644
--- a/Eigen/Householder
+++ b/Eigen/Householder
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HOUSEHOLDER_MODULE_H
 #define EIGEN_HOUSEHOLDER_MODULE_H
@@ -22,8 +24,8 @@
 
 // IWYU pragma: begin_exports
 #include "src/Householder/Householder.h"
-#include "src/Householder/HouseholderSequence.h"
 #include "src/Householder/BlockHouseholder.h"
+#include "src/Householder/HouseholderSequence.h"
 // IWYU pragma: end_exports
 
 #include "src/Core/util/ReenableStupidWarnings.h"
diff --git a/Eigen/IterativeLinearSolvers b/Eigen/IterativeLinearSolvers
index fe5159e..15631ef 100644
--- a/Eigen/IterativeLinearSolvers
+++ b/Eigen/IterativeLinearSolvers
@@ -4,29 +4,91 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
 #define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
 
 #include "SparseCore"
 #include "OrderingMethods"
+#include "Jacobi"
+#include "Householder"
+#include "QR"
+#include "LU"
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
 /**
   * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
   *
-  * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a
+  * This module provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a
   squared matrix, usually very large and sparse.
   * Those solvers are accessible via the following classes:
   *  - ConjugateGradient for selfadjoint (hermitian) matrices,
   *  - LeastSquaresConjugateGradient for rectangular least-square problems,
-  *  - BiCGSTAB for general square matrices.
+  *  - LSMR for rectangular least-square problems (Golub-Kahan bidiagonalization, optionally damped),
+  *  - BiCGSTAB for general square matrices,
+  *  - GMRES - a Householder GMRES implementation,
+  *  - DGMRES - a deflated GMRES implementation,
+  *  - MINRES for symmetric indefinite matrices,
+  *  - IDRS - an IDR(s) implementation,
+  *  - BiCGSTABL - a BiCGSTAB(L) implementation,
+  *  - IDRSTABL - an IDR(s)STAB(L) implementation.
   *
   * These iterative solvers are associated with some preconditioners:
   *  - IdentityPreconditioner - not really useful
   *  - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
   *  - IncompleteLUT - incomplete LU factorization with dual thresholding
+  *  - IncompleteLU - incomplete LU factorization without fill-in
+  *
+  * The IterScaling class can be used as a preprocessing step to equilibrate the row and column norms of a matrix.
+  *
+  * Choosing the best solver for solving \c A \c x = \c b depends a lot on the preconditioner chosen as well as the
+  * properties of \c A. The following flowchart might help you.
+  * \dot width=50%
+  * digraph g {
+  *   node [ fontname=Arial, fontsize=11];
+  *   edge [ fontname=Helvetica, fontsize=10 ];
+  *   A1[label="hermitian", shape="box"];
+  *   A2[label="positive definite", shape="box"];
+  *   CG[shape="plaintext"];
+  *   A3[label="ill conditioned", shape="box"];
+  *   A4[label="good preconditioner", shape="box"];
+  *   A5[label="flexible preconditioner", shape="box"];
+  *   A6[label="strongly indefinite", shape="box"];
+  *   A8[label="large imaginary eigenvalue", shape="box"];
+  *   A7[label="large imaginary eigenvalue",shape="box"];
+  *
+  *   SYMMLQ[shape="plaintext"];
+  *   MINRES[shape="plaintext"];
+  *   GCR[shape="plaintext"];
+  *   GMRES[shape="plaintext"];
+  *   IDRSTABL[shape="plaintext"];
+  *   IDRS[shape="plaintext"];
+  *   BICGSTABL[shape="plaintext"];
+  *   BICGSTAB[shape="plaintext"];
+  *
+  *   A1 -> A2 [label="yes"];
+  *   A2 -> CG [label="yes"];
+  *   A2 -> A3 [label="no"];
+  *   A3 -> SYMMLQ [label="yes"];
+  *   A3 -> MINRES [label="no"];
+  *
+  *   A1 -> A4 [label="no"];
+  *   A4 -> A5 [label="yes"];
+  *   A5 -> GCR [label="yes"];
+  *   A5 -> GMRES [label="no"];
+  *
+  *   A4 -> A6 [label="no"];
+  *   A6 -> A8 [label="yes"];
+  *   A6 -> A7 [label="no"];
+  *   A7 -> BICGSTABL [label="yes"];
+  *   A7 -> BICGSTAB [label="no"];
+  *   A8 -> IDRSTABL [label="yes"];
+  *   A8 -> IDRS [label="no"];
+  * }
+  * \enddot
   *
   * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport,
   UmfPackSupport, SuperLUSupport, AccelerateSupport.
@@ -42,9 +104,18 @@
 #include "src/IterativeLinearSolvers/BasicPreconditioners.h"
 #include "src/IterativeLinearSolvers/ConjugateGradient.h"
 #include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
+#include "src/IterativeLinearSolvers/LSMR.h"
 #include "src/IterativeLinearSolvers/BiCGSTAB.h"
 #include "src/IterativeLinearSolvers/IncompleteLUT.h"
 #include "src/IterativeLinearSolvers/IncompleteCholesky.h"
+#include "src/IterativeLinearSolvers/Scaling.h"
+#include "src/IterativeLinearSolvers/IncompleteLU.h"
+#include "src/IterativeLinearSolvers/GMRES.h"
+#include "src/IterativeLinearSolvers/DGMRES.h"
+#include "src/IterativeLinearSolvers/MINRES.h"
+#include "src/IterativeLinearSolvers/IDRS.h"
+#include "src/IterativeLinearSolvers/BiCGSTABL.h"
+#include "src/IterativeLinearSolvers/IDRSTABL.h"
 // IWYU pragma: end_exports
 
 #include "src/Core/util/ReenableStupidWarnings.h"
diff --git a/Eigen/Jacobi b/Eigen/Jacobi
index 31eb36a..b03ba45 100644
--- a/Eigen/Jacobi
+++ b/Eigen/Jacobi
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_JACOBI_MODULE_H
 #define EIGEN_JACOBI_MODULE_H
diff --git a/Eigen/KLUSupport b/Eigen/KLUSupport
index 13959a3..d48fe23 100644
--- a/Eigen/KLUSupport
+++ b/Eigen/KLUSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_KLUSUPPORT_MODULE_H
 #define EIGEN_KLUSUPPORT_MODULE_H
@@ -29,7 +31,7 @@
  * \endcode
  *
  * In order to use this module, the klu and btf headers must be accessible from the include paths, and your binary must
- * be linked to the klu library and its dependencies. The dependencies depend on how umfpack has been compiled. For a
+ * be linked to the klu library and its dependencies. The dependencies depend on how KLU has been compiled. For a
  * cmake based project, you can use our FindKLU.cmake module to help you in this task.
  *
  */
diff --git a/Eigen/LU b/Eigen/LU
index 64dcdee..b52bd2c 100644
--- a/Eigen/LU
+++ b/Eigen/LU
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_LU_MODULE_H
 #define EIGEN_LU_MODULE_H
@@ -23,14 +25,12 @@
  * \endcode
  */
 
-#include "src/misc/Kernel.h"
-#include "src/misc/Image.h"
-
 // IWYU pragma: begin_exports
+#include "src/Core/RankRevealingBase.h"
 #include "src/LU/FullPivLU.h"
 #include "src/LU/PartialPivLU.h"
 #ifdef EIGEN_USE_LAPACKE
-#include "src/misc/lapacke_helpers.h"
+#include "src/LAPACKESupport/lapacke_helpers.h"
 #include "src/LU/PartialPivLU_LAPACKE.h"
 #endif
 #include "src/LU/Determinant.h"
diff --git a/Eigen/MetisSupport b/Eigen/MetisSupport
index 3636d3a..ec682fa 100644
--- a/Eigen/MetisSupport
+++ b/Eigen/MetisSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_METISSUPPORT_MODULE_H
 #define EIGEN_METISSUPPORT_MODULE_H
diff --git a/Eigen/OrderingMethods b/Eigen/OrderingMethods
index 0167419..e008079 100644
--- a/Eigen/OrderingMethods
+++ b/Eigen/OrderingMethods
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ORDERINGMETHODS_MODULE_H
 #define EIGEN_ORDERINGMETHODS_MODULE_H
@@ -53,7 +55,7 @@
  *
  * \note Some of these methods (like AMD or METIS), need the sparsity pattern
  * of the input matrix to be symmetric. When the matrix is structurally unsymmetric,
- * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method.
+ * Eigen computes internally the pattern of \f$A^T+A\f$ before calling the method.
  * If your matrix is already symmetric (at least in structure), you can avoid that
  * by calling the method with a SelfAdjointView type.
  *
diff --git a/Eigen/PaStiXSupport b/Eigen/PaStiXSupport
index dd1cfcb..0f3aa66 100644
--- a/Eigen/PaStiXSupport
+++ b/Eigen/PaStiXSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PASTIXSUPPORT_MODULE_H
 #define EIGEN_PASTIXSUPPORT_MODULE_H
@@ -36,7 +38,7 @@
  * \endcode
  *
  * In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be
- * linked to the PaSTiX library and its dependencies. This wrapper resuires PaStiX version 5.x compiled without MPI
+ * linked to the PaSTiX library and its dependencies. This wrapper requires PaStiX version 5.x compiled without MPI
  * support. The dependencies depend on how PaSTiX has been compiled. For a cmake based project, you can use our
  * FindPaSTiX.cmake module to help you in this task.
  *
diff --git a/Eigen/PardisoSupport b/Eigen/PardisoSupport
index 4aef5fb..9b49dd5 100644
--- a/Eigen/PardisoSupport
+++ b/Eigen/PardisoSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARDISOSUPPORT_MODULE_H
 #define EIGEN_PARDISOSUPPORT_MODULE_H
diff --git a/Eigen/QR b/Eigen/QR
index c38b453..2f1044e 100644
--- a/Eigen/QR
+++ b/Eigen/QR
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_QR_MODULE_H
 #define EIGEN_QR_MODULE_H
@@ -11,33 +13,37 @@
 #include "Core"
 
 #include "Cholesky"
-#include "Jacobi"
 #include "Householder"
+#include "LU"  // for internal::partial_lu_inplace, used by RandColPivHouseholderQR
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
 /** \defgroup QR_Module QR module
  *
- *
- *
  * This module provides various QR decompositions
  * This module also provides some MatrixBase methods, including:
  *  - MatrixBase::householderQr()
  *  - MatrixBase::colPivHouseholderQr()
  *  - MatrixBase::fullPivHouseholderQr()
+ *  - MatrixBase::randColPivHouseholderQr()
+ *  - MatrixBase::completeOrthogonalDecomposition()
+ *  - MatrixBase::randCompleteOrthogonalDecomposition()
  *
  * \code
  * #include <Eigen/QR>
  * \endcode
  */
 
+#include "src/Core/RankRevealingBase.h"
+
 // IWYU pragma: begin_exports
 #include "src/QR/HouseholderQR.h"
 #include "src/QR/FullPivHouseholderQR.h"
 #include "src/QR/ColPivHouseholderQR.h"
+#include "src/QR/RandColPivHouseholderQR.h"
 #include "src/QR/CompleteOrthogonalDecomposition.h"
 #ifdef EIGEN_USE_LAPACKE
-#include "src/misc/lapacke_helpers.h"
+#include "src/LAPACKESupport/lapacke_helpers.h"
 #include "src/QR/HouseholderQR_LAPACKE.h"
 #include "src/QR/ColPivHouseholderQR_LAPACKE.h"
 #endif
diff --git a/Eigen/QtAlignedMalloc b/Eigen/QtAlignedMalloc
index 585f8e8..cb34bfa 100644
--- a/Eigen/QtAlignedMalloc
+++ b/Eigen/QtAlignedMalloc
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_QTMALLOC_MODULE_H
 #define EIGEN_QTMALLOC_MODULE_H
@@ -14,11 +16,11 @@
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
-void *qMalloc(std::size_t size) { return Eigen::internal::aligned_malloc(size); }
+inline void *qMalloc(std::size_t size) { return Eigen::internal::aligned_malloc(size); }
 
-void qFree(void *ptr) { Eigen::internal::aligned_free(ptr); }
+inline void qFree(void *ptr) { Eigen::internal::aligned_free(ptr); }
 
-void *qRealloc(void *ptr, std::size_t size) {
+inline void *qRealloc(void *ptr, std::size_t size) {
   void *newPtr = Eigen::internal::aligned_malloc(size);
   std::memcpy(newPtr, ptr, size);
   Eigen::internal::aligned_free(ptr);
diff --git a/Eigen/SPQRSupport b/Eigen/SPQRSupport
index c01dbe0..1c06333 100644
--- a/Eigen/SPQRSupport
+++ b/Eigen/SPQRSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPQRSUPPORT_MODULE_H
 #define EIGEN_SPQRSUPPORT_MODULE_H
@@ -38,4 +40,4 @@
 
 #include "src/Core/util/ReenableStupidWarnings.h"
 
-#endif
+#endif  // EIGEN_SPQRSUPPORT_MODULE_H
diff --git a/Eigen/SVD b/Eigen/SVD
index b616a6a..b5635d1 100644
--- a/Eigen/SVD
+++ b/Eigen/SVD
@@ -4,20 +4,18 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SVD_MODULE_H
 #define EIGEN_SVD_MODULE_H
 
 #include "QR"
-#include "Householder"
-#include "Jacobi"
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
 /** \defgroup SVD_Module SVD module
  *
- *
- *
  * This module provides SVD decomposition for matrices (both real and complex).
  * Two decomposition algorithms are provided:
  *  - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very
@@ -40,8 +38,10 @@
 #ifdef EIGEN_USE_LAPACKE
 #ifdef EIGEN_USE_MKL
 #include "mkl_lapacke.h"
+#elif defined(EIGEN_LAPACKE_SYSTEM)
+#include <lapacke.h>
 #else
-#include "src/misc/lapacke.h"
+#include "src/LAPACKESupport/lapacke.h"
 #endif
 #ifndef EIGEN_USE_LAPACKE_STRICT
 #include "src/SVD/JacobiSVD_LAPACKE.h"
diff --git a/Eigen/Sparse b/Eigen/Sparse
index 4d0ee8b..741fb41 100644
--- a/Eigen/Sparse
+++ b/Eigen/Sparse
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_MODULE_H
 #define EIGEN_SPARSE_MODULE_H
diff --git a/Eigen/SparseCholesky b/Eigen/SparseCholesky
index 6abdcd6..e3e7f23 100644
--- a/Eigen/SparseCholesky
+++ b/Eigen/SparseCholesky
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSECHOLESKY_MODULE_H
 #define EIGEN_SPARSECHOLESKY_MODULE_H
@@ -19,9 +20,10 @@
  * \defgroup SparseCholesky_Module SparseCholesky module
  *
  * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian)
- * matrices. Those decompositions are accessible via the following classes:
- *  - SimplicialLLt,
- *  - SimplicialLDLt
+ * positive definite matrices. They are not intended for general selfadjoint or positive semidefinite matrices.
+ * Those decompositions are accessible via the following classes:
+ *  - SimplicialLLT,
+ *  - SimplicialLDLT
  *
  * Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module.
  *
diff --git a/Eigen/SparseCore b/Eigen/SparseCore
index 56a9401..a3fd7a9 100644
--- a/Eigen/SparseCore
+++ b/Eigen/SparseCore
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSECORE_MODULE_H
 #define EIGEN_SPARSECORE_MODULE_H
@@ -12,11 +14,7 @@
 
 #include "src/Core/util/DisableStupidWarnings.h"
 
-#include <vector>
 #include <map>
-#include <cstdlib>
-#include <cstring>
-#include <algorithm>
 #include <numeric>
 
 /**
@@ -36,12 +34,14 @@
 
 // IWYU pragma: begin_exports
 #include "src/SparseCore/SparseUtil.h"
+#include "src/SparseCore/SparseScatter.h"
 #include "src/SparseCore/SparseMatrixBase.h"
 #include "src/SparseCore/SparseAssign.h"
 #include "src/SparseCore/CompressedStorage.h"
 #include "src/SparseCore/AmbiVector.h"
 #include "src/SparseCore/SparseCompressedBase.h"
 #include "src/SparseCore/SparseMatrix.h"
+#include "src/SparseCore/BlockSparseMatrix.h"
 #include "src/SparseCore/SparseMap.h"
 #include "src/SparseCore/SparseVector.h"
 #include "src/SparseCore/SparseRef.h"
@@ -59,10 +59,20 @@
 #include "src/SparseCore/SparseDenseProduct.h"
 #include "src/SparseCore/SparseSelfAdjointView.h"
 #include "src/SparseCore/SparseTriangularView.h"
+#include "src/SparseCore/TriangularReachSolver.h"
 #include "src/SparseCore/TriangularSolver.h"
 #include "src/SparseCore/SparsePermutation.h"
 #include "src/SparseCore/SparseFuzzy.h"
 #include "src/SparseCore/SparseSolverBase.h"
+#include "src/SparseCore/SparsityPatternRef.h"
+
+// Thread-pool-based threaded SpMV with a cached, nnz-balanced row partition
+// for repeated multiplication by the same sparse matrix. Pulls in
+// Eigen::ThreadPool, so it is opt-in via EIGEN_USE_THREADS.
+#ifdef EIGEN_USE_THREADS
+#include "ThreadPool"
+#include "src/SparseCore/ThreadedSparseProduct.h"
+#endif
 // IWYU pragma: end_exports
 
 #include "src/Core/util/ReenableStupidWarnings.h"
diff --git a/Eigen/SparseLU b/Eigen/SparseLU
index 6faf130..05fb83f 100644
--- a/Eigen/SparseLU
+++ b/Eigen/SparseLU
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSELU_MODULE_H
 #define EIGEN_SPARSELU_MODULE_H
diff --git a/Eigen/SparseQR b/Eigen/SparseQR
index b4f1cad..d752cff 100644
--- a/Eigen/SparseQR
+++ b/Eigen/SparseQR
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEQR_MODULE_H
 #define EIGEN_SPARSEQR_MODULE_H
@@ -35,4 +37,4 @@
 
 #include "src/Core/util/ReenableStupidWarnings.h"
 
-#endif
+#endif  // EIGEN_SPARSEQR_MODULE_H
diff --git a/Eigen/StdDeque b/Eigen/StdDeque
index 01e1d76..3281d87 100644
--- a/Eigen/StdDeque
+++ b/Eigen/StdDeque
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STDDEQUE_MODULE_H
 #define EIGEN_STDDEQUE_MODULE_H
diff --git a/Eigen/StdList b/Eigen/StdList
index 1453c9f..7094efa 100644
--- a/Eigen/StdList
+++ b/Eigen/StdList
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STDLIST_MODULE_H
 #define EIGEN_STDLIST_MODULE_H
diff --git a/Eigen/StdVector b/Eigen/StdVector
index 711a654..425d295 100644
--- a/Eigen/StdVector
+++ b/Eigen/StdVector
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STDVECTOR_MODULE_H
 #define EIGEN_STDVECTOR_MODULE_H
diff --git a/Eigen/SuperLUSupport b/Eigen/SuperLUSupport
index 79e2222..a6fad83 100644
--- a/Eigen/SuperLUSupport
+++ b/Eigen/SuperLUSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
 #define EIGEN_SUPERLUSUPPORT_MODULE_H
@@ -16,6 +18,7 @@
 #define EIGEN_EMPTY_WAS_ALREADY_DEFINED
 #endif
 
+// Required by SuperLU headers, which expect int_t to be defined as a global typedef.
 typedef int int_t;
 #include <slu_Cnames.h>
 #include <supermatrix.h>
diff --git a/Eigen/ThreadPool b/Eigen/ThreadPool
index 3e3484a..f59449f 100644
--- a/Eigen/ThreadPool
+++ b/Eigen/ThreadPool
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_THREADPOOL_MODULE_H
 #define EIGEN_THREADPOOL_MODULE_H
@@ -16,9 +17,8 @@
 
 /** \defgroup ThreadPool_Module ThreadPool Module
  *
- * This module provides 2 threadpool implementations
- *  - a simple reference implementation
- *  - a faster non blocking implementation
+ * This module provides a non blocking threadpool implementation, Eigen::ThreadPoolTempl, together with the
+ * Eigen::ThreadPool alias for its default thread environment.
  *
  * \code
  * #include <Eigen/ThreadPool>
@@ -27,7 +27,7 @@
 
 #include <cstddef>
 #include <cstring>
-#include <time.h>
+#include <ctime>
 
 #include <vector>
 #include <atomic>
@@ -102,7 +102,6 @@
 // IWYU pragma: begin_exports
 #include "src/ThreadPool/ThreadLocal.h"
 #include "src/ThreadPool/ThreadYield.h"
-#include "src/ThreadPool/ThreadCancel.h"
 #include "src/ThreadPool/EventCount.h"
 #include "src/ThreadPool/RunQueue.h"
 #include "src/ThreadPool/ThreadPoolInterface.h"
@@ -115,4 +114,4 @@
 
 #include "src/Core/util/ReenableStupidWarnings.h"
 
-#endif  // EIGEN_CXX11_THREADPOOL_MODULE_H
+#endif  // EIGEN_THREADPOOL_MODULE_H
diff --git a/Eigen/UmfPackSupport b/Eigen/UmfPackSupport
index 126344c..b6ccba5 100644
--- a/Eigen/UmfPackSupport
+++ b/Eigen/UmfPackSupport
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_UMFPACKSUPPORT_MODULE_H
 #define EIGEN_UMFPACKSUPPORT_MODULE_H
@@ -35,7 +37,7 @@
 
 // IWYU pragma: begin_exports
 #include "src/UmfPackSupport/UmfPackSupport.h"
-// IWYU pragma: endexports
+// IWYU pragma: end_exports
 
 #include "src/Core/util/ReenableStupidWarnings.h"
 
diff --git a/Eigen/Version b/Eigen/Version
index 164c87f..c9a5eba 100644
--- a/Eigen/Version
+++ b/Eigen/Version
@@ -1,3 +1,12 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_VERSION_H
 #define EIGEN_VERSION_H
 
diff --git a/Eigen/src/AccelerateSupport/AccelerateSupport.h b/Eigen/src/AccelerateSupport/AccelerateSupport.h
index c944aea..96d57bb 100644
--- a/Eigen/src/AccelerateSupport/AccelerateSupport.h
+++ b/Eigen/src/AccelerateSupport/AccelerateSupport.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_ACCELERATESUPPORT_H
 #define EIGEN_ACCELERATESUPPORT_H
 
@@ -173,27 +176,25 @@
   AccelerateImpl() {
     m_isInitialized = false;
 
-    auto check_flag_set = [](int value, int flag) { return ((value & flag) == flag); };
-
-    if (check_flag_set(UpLo_, Symmetric)) {
+    EIGEN_IF_CONSTEXPR ((UpLo_ & Symmetric) == Symmetric) {
       m_sparseKind = SparseSymmetric;
       m_triType = (UpLo_ & Lower) ? SparseLowerTriangle : SparseUpperTriangle;
-    } else if (check_flag_set(UpLo_, UnitLower)) {
+    } else EIGEN_IF_CONSTEXPR ((UpLo_ & UnitLower) == UnitLower) {
       m_sparseKind = SparseUnitTriangular;
       m_triType = SparseLowerTriangle;
-    } else if (check_flag_set(UpLo_, UnitUpper)) {
+    } else EIGEN_IF_CONSTEXPR ((UpLo_ & UnitUpper) == UnitUpper) {
       m_sparseKind = SparseUnitTriangular;
       m_triType = SparseUpperTriangle;
-    } else if (check_flag_set(UpLo_, StrictlyLower)) {
+    } else EIGEN_IF_CONSTEXPR ((UpLo_ & StrictlyLower) == StrictlyLower) {
       m_sparseKind = SparseTriangular;
       m_triType = SparseLowerTriangle;
-    } else if (check_flag_set(UpLo_, StrictlyUpper)) {
+    } else EIGEN_IF_CONSTEXPR ((UpLo_ & StrictlyUpper) == StrictlyUpper) {
       m_sparseKind = SparseTriangular;
       m_triType = SparseUpperTriangle;
-    } else if (check_flag_set(UpLo_, Lower)) {
+    } else EIGEN_IF_CONSTEXPR ((UpLo_ & Lower) == Lower) {
       m_sparseKind = SparseTriangular;
       m_triType = SparseLowerTriangle;
-    } else if (check_flag_set(UpLo_, Upper)) {
+    } else EIGEN_IF_CONSTEXPR ((UpLo_ & Upper) == Upper) {
       m_sparseKind = SparseTriangular;
       m_triType = SparseUpperTriangle;
     } else {
@@ -206,8 +207,6 @@
 
   explicit AccelerateImpl(const MatrixType& matrix) : AccelerateImpl() { compute(matrix); }
 
-  ~AccelerateImpl() {}
-
   inline Index cols() const { return m_nCols; }
   inline Index rows() const { return m_nRows; }
 
@@ -255,7 +254,7 @@
   }
 
   void doAnalysis(AccelSparseMatrix& A) {
-    m_numericFactorization.reset(nullptr);
+    m_numericFactorization.reset();
 
     SparseSymbolicFactorOptions opts{};
     opts.control = SparseDefaultControl;
@@ -272,7 +271,7 @@
 
     updateInfoStatus(status);
 
-    if (status != SparseStatusOK) m_symbolicFactorization.reset(nullptr);
+    if (status != SparseStatusOK) m_symbolicFactorization.reset();
   }
 
   void doFactorization(AccelSparseMatrix& A) {
@@ -283,7 +282,7 @@
 
       status = m_numericFactorization->status;
 
-      if (status != SparseStatusOK) m_numericFactorization.reset(nullptr);
+      if (status != SparseStatusOK) m_numericFactorization.reset();
     }
 
     updateInfoStatus(status);
@@ -320,7 +319,7 @@
 /** Computes the symbolic and numeric decomposition of matrix \a a */
 template <typename MatrixType_, int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>
 void AccelerateImpl<MatrixType_, UpLo_, Solver_, EnforceSquare_>::compute(const MatrixType& a) {
-  if (EnforceSquare_) eigen_assert(a.rows() == a.cols());
+  EIGEN_IF_CONSTEXPR (EnforceSquare_) eigen_assert(a.rows() == a.cols());
 
   m_nRows = a.rows();
   m_nCols = a.cols();
@@ -345,7 +344,7 @@
  */
 template <typename MatrixType_, int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>
 void AccelerateImpl<MatrixType_, UpLo_, Solver_, EnforceSquare_>::analyzePattern(const MatrixType& a) {
-  if (EnforceSquare_) eigen_assert(a.rows() == a.cols());
+  EIGEN_IF_CONSTEXPR (EnforceSquare_) eigen_assert(a.rows() == a.cols());
 
   m_nRows = a.rows();
   m_nCols = a.cols();
@@ -372,7 +371,7 @@
   eigen_assert(m_symbolicFactorization && "You must first call analyzePattern()");
   eigen_assert(m_nRows == a.rows() && m_nCols == a.cols());
 
-  if (EnforceSquare_) eigen_assert(a.rows() == a.cols());
+  EIGEN_IF_CONSTEXPR (EnforceSquare_) eigen_assert(a.rows() == a.cols());
 
   AccelSparseMatrix A{};
   std::vector<long> columnStarts;
diff --git a/Eigen/src/AccelerateSupport/InternalHeaderCheck.h b/Eigen/src/AccelerateSupport/InternalHeaderCheck.h
index 69bcff5..d441dbb 100644
--- a/Eigen/src/AccelerateSupport/InternalHeaderCheck.h
+++ b/Eigen/src/AccelerateSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_ACCELERATESUPPORT_MODULE_H
 #error "Please include Eigen/AccelerateSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Cholesky/BunchKaufman.h b/Eigen/src/Cholesky/BunchKaufman.h
new file mode 100644
index 0000000..dd451f4
--- /dev/null
+++ b/Eigen/src/Cholesky/BunchKaufman.h
@@ -0,0 +1,1123 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BUNCHKAUFMAN_H
+#define EIGEN_BUNCHKAUFMAN_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename MatrixType_, int UpLo_>
+struct traits<BunchKaufman<MatrixType_, UpLo_> > : traits<MatrixType_> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
+  enum { Flags = 0 };
+};
+
+template <typename MatrixType, int UpLo>
+struct BunchKaufman_Traits;
+
+// Panel width for the blocked factorization (defined below); forward-declared so the size
+// constructor can pre-allocate the panel workspace.
+template <typename Scalar>
+inline Index bunch_kaufman_blocksize();
+}  // namespace internal
+
+/** \ingroup Cholesky_Module
+ *
+ * \class BunchKaufman
+ *
+ * \brief Bunch-Kaufman factorization of a symmetric / Hermitian indefinite matrix
+ *
+ * \tparam MatrixType_ the type of the matrix of which to compute the Bunch-Kaufman factorization
+ * \tparam UpLo_ the triangular part that will be used for the decomposition: Lower (default) or Upper.
+ *             The other triangular part won't be read.
+ *
+ * Perform a symmetric-indefinite factorization of a real symmetric or complex Hermitian matrix
+ * \f$ A \f$ using the Bunch-Kaufman diagonal pivoting method, such that
+ * \f$ P A P^T = L D L^* \f$ (or \f$ P A P^T = U^* D U \f$ for the upper variant), where \f$ P \f$ is a
+ * permutation matrix, \f$ L \f$ is unit lower triangular and \f$ D \f$ is block diagonal with
+ * 1x1 and 2x2 diagonal blocks.
+ *
+ * Unlike LLT and LDLT, this factorization is numerically stable (backward stable, with a bounded
+ * element-growth factor) for \em indefinite symmetric / Hermitian matrices. It is the dense analog of
+ * LAPACK's xSYTRF / xHETRF routines. For positive- or negative-(semi)definite matrices LLT / LDLT are
+ * cheaper and should be preferred.
+ *
+ * The diagonal-pivoting threshold \f$ \alpha = (1+\sqrt{17})/8 \f$ and the pivot-selection logic follow:
+ *  - J. R. Bunch and L. Kaufman, "Some stable methods for calculating inertia and solving symmetric
+ *    linear systems", Math. Comp. 31 (1977), pp. 163-179.
+ *  - G. H. Golub and C. F. Van Loan, "Matrix Computations", 4th ed., section 4.4.
+ *  - N. J. Higham, "Accuracy and Stability of Numerical Algorithms", 2nd ed., chapter 11.
+ *
+ * The blocked (level-3 BLAS) variant follows the panel/trailing-update structure of LAPACK's
+ * xSYTRF / xLASYF.
+ *
+ * This factorization also reveals the \em inertia of \f$ A \f$ (the number of positive, negative and
+ * zero eigenvalues) by Sylvester's law of inertia, accessible through isPositive() / isNegative().
+ *
+ * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+ *
+ * \sa MatrixBase::bunchKaufman(), SelfAdjointView::bunchKaufman(), class LDLT, class LLT
+ */
+template <typename MatrixType_, int UpLo_>
+class BunchKaufman : public SolverBase<BunchKaufman<MatrixType_, UpLo_> > {
+ public:
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<BunchKaufman>;
+  friend class SolverBase<BunchKaufman>;
+
+  EIGEN_GENERIC_PUBLIC_INTERFACE(BunchKaufman)
+  enum {
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
+    UpLo = UpLo_
+  };
+
+  using TmpVectorType = Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1>;
+  // Panel workspace for the blocked algorithm (only allocated for large dynamic-sized problems).
+  using WorkspaceType = Matrix<Scalar, Dynamic, Dynamic>;
+  using TranspositionType = Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime>;
+  using PermutationType = PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime>;
+
+  using Traits = internal::BunchKaufman_Traits<MatrixType, UpLo>;
+
+  /** \brief Default Constructor.
+   *
+   * The default constructor is useful in cases in which the user intends to
+   * perform decompositions via BunchKaufman::compute(const MatrixType&).
+   */
+  BunchKaufman()
+      : m_matrix(),
+        m_l1_norm(0),
+        m_transpositions(),
+        m_subdiag(),
+        m_n_pos(0),
+        m_n_neg(0),
+        m_n_zero(0),
+        m_isInitialized(false),
+        m_info(InvalidInput) {}
+
+  /** \brief Default Constructor with memory preallocation
+   *
+   * Like the default constructor but with preallocation of the internal data
+   * according to the specified problem \a size.
+   * \sa BunchKaufman()
+   */
+  explicit BunchKaufman(Index size)
+      : m_matrix(size, size),
+        m_l1_norm(0),
+        m_transpositions(size),
+        m_subdiag(size),
+        // Pre-allocate the panel workspace to the exact shape compute() needs, so that a subsequent
+        // compute() on a problem of this size performs no heap allocation (the blocked factorization
+        // resizes it to n x (nb+1); resizing to the same shape is a no-op).
+        m_workspace(size, internal::bunch_kaufman_blocksize<Scalar>() + 1),
+        m_n_pos(0),
+        m_n_neg(0),
+        m_n_zero(0),
+        m_isInitialized(false),
+        m_info(InvalidInput) {}
+
+  /** \brief Constructor with decomposition
+   *
+   * This calculates the decomposition for the input \a matrix.
+   *
+   * \sa BunchKaufman(Index size)
+   */
+  template <typename InputType>
+  explicit BunchKaufman(const EigenBase<InputType>& matrix)
+      : m_matrix(matrix.rows(), matrix.cols()),
+        m_l1_norm(0),
+        m_transpositions(matrix.rows()),
+        m_subdiag(matrix.rows()),
+        m_n_pos(0),
+        m_n_neg(0),
+        m_n_zero(0),
+        m_isInitialized(false),
+        m_info(InvalidInput) {
+    compute(matrix.derived());
+  }
+
+  /** \brief Constructs a Bunch-Kaufman factorization from a given matrix
+   *
+   * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c
+   * MatrixType is a Eigen::Ref.
+   *
+   * \sa BunchKaufman(const EigenBase&)
+   */
+  template <typename InputType>
+  explicit BunchKaufman(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()),
+        m_l1_norm(0),
+        m_transpositions(matrix.rows()),
+        m_subdiag(matrix.rows()),
+        m_n_pos(0),
+        m_n_neg(0),
+        m_n_zero(0),
+        m_isInitialized(false),
+        m_info(InvalidInput) {
+    computeInPlace();
+  }
+
+  /** \returns a view of the unit upper triangular matrix U */
+  inline typename Traits::MatrixU matrixU() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return Traits::getU(m_matrix);
+  }
+
+  /** \returns a view of the unit lower triangular matrix L */
+  inline typename Traits::MatrixL matrixL() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return Traits::getL(m_matrix);
+  }
+
+  /** \returns the permutation matrix P as a transposition sequence.
+   */
+  inline const TranspositionType& transpositionsP() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_transpositions;
+  }
+
+  /** \returns the main diagonal of the block-diagonal matrix D.
+   *
+   * The block-diagonal matrix D is fully described by vectorD() (its main diagonal) together with
+   * subDiagonal() (the sub-diagonal entries of its 2x2 blocks).
+   */
+  inline Diagonal<const MatrixType> vectorD() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_matrix.diagonal();
+  }
+
+  /** \returns the sub-diagonal of the block-diagonal matrix D.
+   *
+   * Entry \c k is non-zero if and only if a 2x2 diagonal block of D occupies rows/columns \c k and
+   * \c k+1; it then holds \f$ D_{k+1,k} \f$. All other entries are zero. \sa vectorD()
+   */
+  inline const TmpVectorType& subDiagonal() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_subdiag;
+  }
+
+  /** \returns true if the matrix is positive semidefinite (has no strictly negative eigenvalues). */
+  inline bool isPositive() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_n_neg == 0;
+  }
+
+  /** \returns true if the matrix is negative semidefinite (has no strictly positive eigenvalues). */
+  inline bool isNegative() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_n_pos == 0;
+  }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A.
+   *
+   * This function also supports in-place solves using the syntax <tt>x = decompositionObject.solve(x)</tt> .
+   *
+   * \note_about_checking_solutions
+   *
+   * \sa MatrixBase::bunchKaufman(), SelfAdjointView::bunchKaufman()
+   */
+  template <typename Rhs>
+  inline Solve<BunchKaufman, Rhs> solve(const MatrixBase<Rhs>& b) const;
+#endif
+
+  template <typename Derived>
+  bool solveInPlace(MatrixBase<Derived>& bAndX) const;
+
+  template <typename InputType>
+  BunchKaufman& compute(const EigenBase<InputType>& matrix);
+
+  /** \returns an estimate of the reciprocal condition number of the matrix of
+   *  which \c *this is the Bunch-Kaufman decomposition.
+   */
+  RealScalar rcond() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return internal::rcond_estimate_helper(m_l1_norm, *this);
+  }
+
+  /** \returns the internal Bunch-Kaufman decomposition matrix
+   *
+   * The strictly lower (resp. upper) triangular part holds the unit triangular factor L (resp. U); the
+   * diagonal holds the main diagonal of D. The sub/super-diagonal entries of the 2x2 blocks of D are
+   * stored separately, in subDiagonal().
+   */
+  inline const MatrixType& matrixLDLT() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_matrix;
+  }
+
+  MatrixType reconstructedMatrix() const;
+
+  /** \returns the determinant of the matrix of which *this is the Bunch-Kaufman decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the decomposition has already been computed.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() and signDeterminant() instead.
+   * Also, do not rely on the determinant being exactly zero for testing
+   * singularity or rank-deficiency.
+   *
+   * \sa absDeterminant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  Scalar determinant() const;
+
+  /** \returns the absolute value of the determinant of the matrix of which *this is the Bunch-Kaufman
+   * decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the decomposition has already been computed.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \sa determinant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the matrix of which *this is the
+   * Bunch-Kaufman decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the decomposition has already been computed.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation. The 2x2 blocks of D are scaled by their off-diagonal entry before their
+   * determinant is formed, so a block whose own determinant is out of range still contributes a
+   * finite term.
+   *
+   * \sa determinant(), absDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar logAbsDeterminant() const;
+
+  /** \returns the sign of the determinant of the matrix of which *this is the Bunch-Kaufman decomposition,
+   * that is, \c 1, \c -1, or \c 0 if the matrix is singular.
+   *
+   * The sign is read off the inertia rather than computed from a product, so it is exact and cannot
+   * overflow: \f$ \mathrm{sign}(\det A) = (-1)^{n_-} \f$, with \f$ n_- \f$ the number of negative
+   * eigenvalues, which congruence leaves invariant (Sylvester's law of inertia).
+   *
+   * \sa determinant(), absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
+   */
+  Scalar signDeterminant() const;
+
+  /** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix
+   * is self-adjoint.
+   *
+   * This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
+   * \code x = decomposition.adjoint().solve(b) \endcode
+   */
+  const BunchKaufman& adjoint() const { return *this; }
+
+  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return m_matrix.rows(); }
+  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return m_matrix.cols(); }
+
+  /** \brief Reports whether previous computation was successful.
+   *
+   * \returns \c Success if computation was successful,
+   *          \c NumericalIssue if the factorization failed because of a zero pivot (the matrix is singular)
+   *          or because a 2x2 pivot block has no representable inverse (a NaN entry, or an off-diagonal
+   *          so much smaller than the diagonal that the scaled inverse overflows).
+   */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+    return m_info;
+  }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const;
+
+  template <bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType& rhs, DstType& dst) const;
+#endif
+
+ protected:
+  EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+
+  /** \internal Apply the block-diagonal matrix D in place: \c x <- D x. */
+  template <typename Derived>
+  void applyD(MatrixBase<Derived>& x) const;
+
+  /** \internal Apply the inverse of the block-diagonal matrix D in place: \c x <- D^{-1} x.
+   * For \c Conjugate == false the transpose of D is used instead (relevant for the complex case). */
+  template <bool Conjugate, typename Derived>
+  void solveInPlaceD(MatrixBase<Derived>& x) const;
+
+  BunchKaufman& computeInPlace();
+
+  /** \internal Compute the inertia (counts of positive / negative / zero eigenvalues) from D. */
+  void computeInertia();
+
+  /** \internal \returns \f$ \det(D_k)/|d_{21}|^2 \f$ for a 2x2 block of D, which is real and shares the
+   * sign of \f$ \det(D_k) \f$ since \f$ |d_{21}| > 0 \f$ there. */
+  static RealScalar scaledBlockDeterminant(const RealScalar& d11, const RealScalar& d22, const RealScalar& d21);
+
+  /** \internal \returns \f$ \det(D) \f$, the product over the 1x1 and 2x2 diagonal blocks of D. D is
+   * Hermitian, so a block determinant is real: \f$ d_{11} \f$ for a 1x1 block and
+   * \f$ d_{11} d_{22} - |d_{21}|^2 \f$ for a 2x2 one. Accumulated as a mantissa and a power of two,
+   * so that only the result has to be representable. */
+  RealScalar determinantD() const;
+
+  MatrixType m_matrix;
+  RealScalar m_l1_norm;
+  TranspositionType m_transpositions;
+  TmpVectorType m_subdiag;
+  WorkspaceType m_workspace;
+  Index m_n_pos;
+  Index m_n_neg;
+  Index m_n_zero;
+  bool m_isInitialized;
+  ComputationInfo m_info;
+};
+
+namespace internal {
+
+/** \internal The Bunch-Kaufman diagonal-pivoting threshold \f$ \alpha = (1+\sqrt{17})/8 \approx 0.6404 \f$.
+ * It minimizes the bound on element growth across a 1x1 followed by a 1x1 step versus a single 2x2 step
+ * (Bunch & Kaufman, 1977). */
+template <typename RealScalar>
+EIGEN_DEVICE_FUNC inline RealScalar bunch_kaufman_alpha() {
+  using std::sqrt;
+  return (RealScalar(1) + sqrt(RealScalar(17))) / RealScalar(8);
+}
+
+/** \internal Panel width for the blocked (level-3) Bunch-Kaufman factorization. Can be overridden (mainly
+ * for testing the panel logic at small sizes) by defining EIGEN_BUNCHKAUFMAN_BLOCKSIZE. */
+template <typename Scalar>
+inline Index bunch_kaufman_blocksize() {
+#ifdef EIGEN_BUNCHKAUFMAN_BLOCKSIZE
+  return Index(EIGEN_BUNCHKAUFMAN_BLOCKSIZE);
+#else
+  return 64;
+#endif
+}
+
+template <int UpLo>
+struct bunch_kaufman;
+
+template <>
+struct bunch_kaufman<Lower> {
+  // Interchange rows and columns kk and kp (kp >= kk) in the lower triangle of the Hermitian matrix
+  // `mat`, including the already-computed factor columns to the left of column `kfirst` (so that the
+  // stored unit triangular factor stays consistent with a single up-front permutation P). `kfirst` is
+  // the first column of the pivot block (== kk for a 1x1 pivot, == kk-1 for a 2x2 pivot).
+  template <typename MatrixType>
+  static void apply_symmetric_pivot(MatrixType& mat, Index kfirst, Index kk, Index kp, Index kstep) {
+    using Scalar = typename MatrixType::Scalar;
+    const Index n = mat.rows();
+    const Index s = n - kp - 1;
+    if (s > 0) mat.col(kk).tail(s).swap(mat.col(kp).tail(s));
+    for (Index i = kk + 1; i < kp; ++i) {
+      Scalar tmp = mat.coeff(i, kk);
+      mat.coeffRef(i, kk) = numext::conj(mat.coeff(kp, i));
+      mat.coeffRef(kp, i) = numext::conj(tmp);
+    }
+    numext::swap(mat.coeffRef(kk, kk), mat.coeffRef(kp, kp));
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+      mat.coeffRef(kp, kk) = numext::conj(mat.coeff(kp, kk));
+    }
+    if (kfirst > 0) mat.row(kk).head(kfirst).swap(mat.row(kp).head(kfirst));
+    if (kstep == 2) {
+      numext::swap(mat.coeffRef(kfirst + 1, kfirst), mat.coeffRef(kp, kfirst));
+    }
+  }
+
+  // Unblocked (level-2 BLAS) Bunch-Kaufman factorization of the lower triangle of `mat`, in place.
+  // Columns [k0, n) are factorized. On output:
+  //   - the strictly-lower triangle holds the unit lower factor L (with explicit zeros at the
+  //     sub-diagonal positions of 2x2 blocks),
+  //   - the diagonal holds the main diagonal of D,
+  //   - subdiag(k) holds D(k+1,k) for each 2x2 block starting at column k (and 0 elsewhere),
+  //   - transpositions encodes the symmetric permutation P (applied in increasing index order).
+  // Returns 0 on success, or the (1-based) index of the first exactly-zero pivot encountered.
+  template <typename MatrixType, typename TranspositionType, typename SubDiagType>
+  static Index unblocked(MatrixType& mat, TranspositionType& transpositions, SubDiagType& subdiag, Index k0 = 0) {
+    using numext::abs;
+    using Scalar = typename MatrixType::Scalar;
+    using RealScalar = typename MatrixType::RealScalar;
+    using StorageIndex = typename TranspositionType::StorageIndex;
+    const Index n = mat.rows();
+    const RealScalar alpha = bunch_kaufman_alpha<RealScalar>();
+    Index info = 0;
+
+    Index k = k0;
+    while (k < n) {
+      Index kstep = 1;
+      Index kp = k;
+      const RealScalar absakk = abs(numext::real(mat.coeff(k, k)));
+
+      // colmax = max_{i>k} |mat(i,k)|, attained at row imax.
+      Index imax = k;
+      RealScalar colmax(0);
+      if (k + 1 < n) {
+        Index rel = 0;
+        colmax = mat.col(k).tail(n - k - 1).cwiseAbs().maxCoeff(&rel);
+        imax = k + 1 + rel;
+      }
+
+      if (numext::is_exactly_zero((numext::maxi)(absakk, colmax)) || (numext::isnan)(absakk)) {
+        // The whole remaining column is zero: 1x1 zero pivot, matrix is singular.
+        kp = k;
+        if (info == 0) info = k + 1;
+        mat.coeffRef(k, k) = Scalar(numext::real(mat.coeff(k, k)));
+      } else if (absakk >= alpha * colmax) {
+        // 1x1 pivot at k, no interchange.
+        kp = k;
+      } else {
+        // rowmax = largest off-diagonal magnitude in row/column imax.
+        RealScalar rowmax = mat.row(imax).segment(k, imax - k).cwiseAbs().maxCoeff();
+        if (imax + 1 < n) {
+          RealScalar rowmax2 = mat.col(imax).tail(n - imax - 1).cwiseAbs().maxCoeff();
+          rowmax = (numext::maxi)(rowmax, rowmax2);
+        }
+        if (absakk >= alpha * colmax * (colmax / rowmax)) {
+          // 1x1 pivot at k.
+          kp = k;
+        } else if (abs(numext::real(mat.coeff(imax, imax))) >= alpha * rowmax) {
+          // 1x1 pivot at imax: interchange rows/columns k and imax.
+          kp = imax;
+        } else {
+          // 2x2 pivot at (k, imax): interchange rows/columns k+1 and imax.
+          kp = imax;
+          kstep = 2;
+        }
+      }
+
+      const Index kk = k + kstep - 1;  // column of the pivot block to interchange with kp
+      if (kp != kk) apply_symmetric_pivot(mat, k, kk, kp, kstep);
+
+      if (kstep == 1) {
+        transpositions.coeffRef(k) = StorageIndex(kp);
+        subdiag.coeffRef(k) = Scalar(0);
+
+        const RealScalar dkk = numext::real(mat.coeff(k, k));
+        mat.coeffRef(k, k) = Scalar(dkk);
+        const Index rs = n - k - 1;
+        if (rs > 0) {
+          if (!numext::is_exactly_zero(dkk)) {
+            // A22 <- A22 - (1/dkk) w w^*, with w = mat(k+1:n, k); then L column = w / dkk.
+            auto w = mat.col(k).tail(rs);
+            mat.block(k + 1, k + 1, rs, rs).template selfadjointView<Lower>().rankUpdate(w, RealScalar(-1) / dkk);
+            w /= dkk;
+          } else if (info == 0) {
+            info = k + 1;
+          }
+        }
+        k += 1;
+      } else {
+        transpositions.coeffRef(k) = StorageIndex(k);
+        transpositions.coeffRef(k + 1) = StorageIndex(kp);
+
+        const RealScalar d11 = numext::real(mat.coeff(k, k));
+        const RealScalar d22 = numext::real(mat.coeff(k + 1, k + 1));
+        const Scalar d21 = mat.coeff(k + 1, k);
+        mat.coeffRef(k, k) = Scalar(d11);
+        mat.coeffRef(k + 1, k + 1) = Scalar(d22);
+        // Scaled 2x2 inverse (LAPACK xSYTF2/xHETF2 strategy). NEVER form det = d11*d22 - |d21|^2 or
+        // abs2(d21) directly: those over/underflow for well-conditioned but extreme-scaled blocks
+        // (e.g. [[0,s],[s,0]], s=1e200, where det = -s^2 overflows/underflows). Instead divide
+        // through by the off-diagonal d21, so the scaled determinant
+        //   denom = real(ak*akm1) - 1 = det / |d21|^2     (with ak = d22/d21, akm1 = d11/conj(d21))
+        // stays O(1). Divide by d21 itself, never by a hoisted reciprocal: 1/d21 overflows once |d21|
+        // is subnormal, where these quotients are still finite (issue #3142).
+        const Scalar cjd = numext::conj(d21);
+        const Scalar ak = numext::divide(d22, d21);
+        const Scalar akm1 = numext::divide(d11, cjd);
+        const RealScalar denom = numext::real(ak * akm1) - RealScalar(1);
+        // The pivot criterion gives |d11 d22| <= alpha^2 |d21|^2 with alpha < 1, so in exact arithmetic
+        // -1 - alpha^2 < denom < alpha^2 - 1. Outside that range ak overflowed -- the criterion bounds
+        // |d22| only against the largest entry of its own row -- or a NaN entry was pulled into the
+        // block. Either way the block's inverse is not representable: report it rather than silently
+        // propagate it.
+        if (info == 0 && !(denom < RealScalar(0) && denom > RealScalar(-2))) info = k + 1;
+
+        const Index rs = n - k - 2;
+        if (rs > 0) {
+          // Fused factor-column computation and trailing update, in a single pass over the lower
+          // triangle of A22 (the xSYTF2/xHETF2 strategy). For each trailing column j, first form the
+          // two unit lower factor entries of row j (the rows of U D^{-1}, in the scaled form above),
+          //   l0_j = t*((ak*u0_j - u1_j)/conj(d21)),   l1_j = t*((akm1*u1_j - u0_j)/d21),
+          // dividing before scaling by t: the quotient is denom*l_j, within a factor 1 + alpha^2 of the
+          // result, whereas t*(ak*u0_j - u1_j) can overflow (|t| < 1/(1 - alpha^2)) where l_j is finite.
+          // Then update column j against the ORIGINAL pivot columns u = [u0 u1] (they carry the D
+          // scale, U = L*D, so no 1/det factor appears):
+          //   A22(i,j) -= u0_i*conj(l0_j) + u1_i*conj(l1_j),   i >= j.
+          // Rows < j of the pivot columns already hold L, rows >= j still hold U -- exactly the
+          // entries each column update needs, so no workspace is required. Compared with composing
+          // self-adjoint rank-1/rank-2 updates (syr + syr + syr2) this halves the flops and touches
+          // the trailing triangle once instead of three times.
+          const RealScalar t = RealScalar(1) / denom;
+          auto c0 = mat.col(k).tail(rs);
+          auto c1 = mat.col(k + 1).tail(rs);
+          for (Index j = 0; j < rs; ++j) {
+            const Scalar u0 = c0.coeff(j);
+            const Scalar u1 = c1.coeff(j);
+            const Scalar l0 = t * numext::divide(ak * u0 - u1, cjd);
+            const Scalar l1 = t * numext::divide(akm1 * u1 - u0, d21);
+            const Index len = rs - j;
+            mat.col(k + 2 + j).tail(len) -= numext::conj(l0) * c0.tail(len) + numext::conj(l1) * c1.tail(len);
+            c0.coeffRef(j) = l0;
+            c1.coeffRef(j) = l1;
+            // Keep the updated diagonal exactly real (the correction is Hermitian; roundoff would
+            // otherwise leave a tiny imaginary part).
+            EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+              mat.coeffRef(k + 2 + j, k + 2 + j) = Scalar(numext::real(mat.coeff(k + 2 + j, k + 2 + j)));
+            }
+          }
+        }
+        // Move the 2x2 off-diagonal of D out of the L storage.
+        subdiag.coeffRef(k) = d21;
+        subdiag.coeffRef(k + 1) = Scalar(0);
+        mat.coeffRef(k + 1, k) = Scalar(0);
+        k += 2;
+      }
+    }
+    return info;
+  }
+
+  // Partial factorization of a panel of at most `nb` columns of the lower triangle of `mat`, starting
+  // at column k0, using the Bunch-Kaufman method (level-2 within the panel). Follows the panel/workspace
+  // structure of LAPACK's xLASYF. The trailing sub-matrix mat(k0+kb:n, k0+kb:n) is left untouched; the
+  // workspace `W` (n x nb) returns, in its first kb columns, the product L21*D restricted to the panel
+  // columns, so that the caller can apply the deferred trailing update A22 <- A22 - L21 * (L21*D)^* with
+  // a single level-3 (triangular) matrix product. Returns the number kb (<= nb) of columns factorized.
+  template <typename MatrixType, typename WorkspaceType, typename TranspositionType, typename SubDiagType>
+  static Index partial_factor(MatrixType& mat, Index k0, Index nb, WorkspaceType& W, TranspositionType& transpositions,
+                              SubDiagType& subdiag, Index& info) {
+    using numext::abs;
+    using Scalar = typename MatrixType::Scalar;
+    using RealScalar = typename MatrixType::RealScalar;
+    using StorageIndex = typename TranspositionType::StorageIndex;
+    const Index n = mat.rows();
+    const RealScalar alpha = bunch_kaufman_alpha<RealScalar>();
+    constexpr bool is_complex = NumTraits<Scalar>::IsComplex;
+
+    Index j = 0;
+    while (j < nb) {
+      const Index jc = k0 + j;
+      const Index h = n - jc;
+
+      // W(jc:n, j) <- updated column jc = (column jc of A) minus the contributions of the panel columns
+      // [k0, jc) already factorized (those are stored as L in mat, and L*D in W).
+      W.col(j).segment(jc, h) = mat.col(jc).segment(jc, h);
+      EIGEN_IF_CONSTEXPR (is_complex) W.coeffRef(jc, j) = Scalar(numext::real(W.coeff(jc, j)));
+      if (j > 0) {
+        W.col(j).segment(jc, h).noalias() -= mat.block(jc, k0, h, j) * W.row(jc).head(j).adjoint();
+        EIGEN_IF_CONSTEXPR (is_complex) W.coeffRef(jc, j) = Scalar(numext::real(W.coeff(jc, j)));
+      }
+
+      Index kstep = 1;
+      Index kp = jc;
+      const RealScalar absakk = abs(numext::real(W.coeff(jc, j)));
+      Index imax = jc;
+      RealScalar colmax(0);
+      if (jc + 1 < n) {
+        Index rel = 0;
+        colmax = W.col(j).segment(jc + 1, n - jc - 1).cwiseAbs().maxCoeff(&rel);
+        imax = jc + 1 + rel;
+      }
+
+      if (numext::is_exactly_zero((numext::maxi)(absakk, colmax)) || (numext::isnan)(absakk)) {
+        kp = jc;
+        if (info == 0) info = jc + 1;
+      } else if (absakk >= alpha * colmax) {
+        kp = jc;
+      } else {
+        // W(jc:n, j+1) <- updated column imax (its leading row part is read from row imax of mat and
+        // conjugated, the trailing part from column imax).
+        const Index hr = imax - jc;
+        if (hr > 0) W.col(j + 1).segment(jc, hr) = mat.row(imax).segment(jc, hr).adjoint();
+        W.col(j + 1).segment(imax, n - imax) = mat.col(imax).segment(imax, n - imax);
+        EIGEN_IF_CONSTEXPR (is_complex) W.coeffRef(imax, j + 1) = Scalar(numext::real(W.coeff(imax, j + 1)));
+        if (j > 0) {
+          W.col(j + 1).segment(jc, n - jc).noalias() -= mat.block(jc, k0, n - jc, j) * W.row(imax).head(j).adjoint();
+          EIGEN_IF_CONSTEXPR (is_complex) W.coeffRef(imax, j + 1) = Scalar(numext::real(W.coeff(imax, j + 1)));
+        }
+
+        RealScalar rowmax(0);
+        if (imax > jc) rowmax = W.col(j + 1).segment(jc, imax - jc).cwiseAbs().maxCoeff();
+        if (imax + 1 < n) {
+          RealScalar rowmax2 = W.col(j + 1).segment(imax + 1, n - imax - 1).cwiseAbs().maxCoeff();
+          rowmax = (numext::maxi)(rowmax, rowmax2);
+        }
+        if (absakk >= alpha * colmax * (colmax / rowmax)) {
+          kp = jc;
+        } else if (abs(numext::real(W.coeff(imax, j + 1))) >= alpha * rowmax) {
+          kp = imax;
+          // imax becomes the 1x1 pivot column: its updated column (in W(:,j+1)) replaces W(:,j).
+          W.col(j).segment(jc, n - jc) = W.col(j + 1).segment(jc, n - jc);
+        } else {
+          kp = imax;
+          kstep = 2;
+        }
+      }
+
+      // A 2x2 block must fit in the panel; otherwise defer this column to the next panel.
+      if (kstep == 2 && j + 1 >= nb) break;
+
+      const Index kk = jc + kstep - 1;
+      if (kp != kk) {
+        apply_symmetric_pivot(mat, jc, kk, kp, kstep);
+        const Index nwc = j + kstep;  // number of populated W columns
+        W.row(kk).head(nwc).swap(W.row(kp).head(nwc));
+      }
+
+      if (kstep == 1) {
+        transpositions.coeffRef(jc) = StorageIndex(kp);
+        subdiag.coeffRef(jc) = Scalar(0);
+        const RealScalar dval = numext::real(W.coeff(jc, j));
+        mat.coeffRef(jc, jc) = Scalar(dval);
+        const Index rs = n - jc - 1;
+        if (rs > 0) {
+          if (!numext::is_exactly_zero(dval)) {
+            mat.col(jc).tail(rs) = W.col(j).segment(jc + 1, rs) / dval;
+          } else {
+            // Zero pivot (singular): the Schur column is zero too. Store an explicit zero L column so
+            // that matrixL() is well formed, matching the unblocked path (which leaves the already
+            // zeroed Schur column in place).
+            mat.col(jc).tail(rs).setZero();
+            if (info == 0) info = jc + 1;
+          }
+        }
+        j += 1;
+      } else {
+        transpositions.coeffRef(jc) = StorageIndex(jc);
+        transpositions.coeffRef(jc + 1) = StorageIndex(kp);
+        const RealScalar d11 = numext::real(W.coeff(jc, j));
+        const Scalar d21 = W.coeff(jc + 1, j);
+        const RealScalar d22 = numext::real(W.coeff(jc + 1, j + 1));
+        mat.coeffRef(jc, jc) = Scalar(d11);
+        mat.coeffRef(jc + 1, jc + 1) = Scalar(d22);
+        // Scaled 2x2 inverse (see unblocked()): divide through by d21 so the scaled determinant
+        // denom = det/|d21|^2 stays O(1); det = d11*d22 - |d21|^2 and abs2(d21) are never formed (they
+        // over/underflow on extreme-scaled blocks). The deferred level-3 trailing update below uses W
+        // (= L*D, original scale), so it carries no 1/det factor either.
+        const Scalar cjd = numext::conj(d21);
+        const Scalar ak = numext::divide(d22, d21);
+        const Scalar akm1 = numext::divide(d11, cjd);
+        const RealScalar denom = numext::real(ak * akm1) - RealScalar(1);
+        if (info == 0 && !(denom < RealScalar(0) && denom > RealScalar(-2))) info = jc + 1;
+        const Index rs = n - jc - 2;
+        if (rs > 0) {
+          // L(jc+2:n, jc:jc+1) = W(jc+2:n, j:j+1) * D^{-1}, as vectorized column expressions, divided
+          // before being scaled by t for the reason given in unblocked():
+          //   L_k = t*((ak*w0 - w1)/conj(d21)),  L_{k+1} = t*((akm1*w1 - w0)/d21).
+          const RealScalar t = RealScalar(1) / denom;
+          auto w0 = W.col(j).segment(jc + 2, rs);
+          auto w1 = W.col(j + 1).segment(jc + 2, rs);
+          mat.col(jc).tail(rs) = t * ((ak * w0 - w1) / cjd);
+          mat.col(jc + 1).tail(rs) = t * ((akm1 * w1 - w0) / d21);
+        }
+        subdiag.coeffRef(jc) = d21;
+        subdiag.coeffRef(jc + 1) = Scalar(0);
+        mat.coeffRef(jc + 1, jc) = Scalar(0);
+        j += 2;
+      }
+    }
+    return j;
+  }
+
+  // Blocked (level-3 BLAS) Bunch-Kaufman factorization of the lower triangle of `mat`, in place.
+  template <typename MatrixType, typename TranspositionType, typename SubDiagType, typename WorkspaceType>
+  static Index blocked(MatrixType& mat, TranspositionType& transpositions, SubDiagType& subdiag,
+                       WorkspaceType& workspace) {
+    const Index n = mat.rows();
+    const Index nb = bunch_kaufman_blocksize<typename MatrixType::Scalar>();
+    if (nb < 2 || n <= nb) return unblocked(mat, transpositions, subdiag, 0);
+
+    // One extra workspace column holds the candidate ("imax") column examined during pivot selection.
+    workspace.resize(n, nb + 1);
+    Index info = 0;
+    Index k = 0;
+    while (k < n) {
+      if (n - k > nb) {
+        const Index kb = partial_factor(mat, k, nb, workspace, transpositions, subdiag, info);
+        const Index rs = n - k - kb;
+        if (rs > 0) {
+          // Deferred trailing update of the lower triangle: A22 <- A22 - L21 * (L21*D)^*.
+          mat.block(k + kb, k + kb, rs, rs).template triangularView<Lower>() -=
+              mat.block(k + kb, k, rs, kb) * workspace.block(k + kb, 0, rs, kb).adjoint();
+        }
+        if (kb == 0) {  // defensive: avoid an infinite loop (should not happen for nb >= 2)
+          info = (info == 0) ? unblocked(mat, transpositions, subdiag, k) : info;
+          break;
+        }
+        k += kb;
+      } else {
+        const Index info2 = unblocked(mat, transpositions, subdiag, k);
+        if (info == 0) info = info2;
+        break;
+      }
+    }
+    return info;
+  }
+};
+
+template <>
+struct bunch_kaufman<Upper> {
+  template <typename MatrixType, typename TranspositionType, typename SubDiagType>
+  static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat, TranspositionType& transpositions, SubDiagType& subdiag,
+                                             Index k0 = 0) {
+    Transpose<MatrixType> matt(mat);
+    return bunch_kaufman<Lower>::unblocked(matt, transpositions, subdiag, k0);
+  }
+
+  template <typename MatrixType, typename TranspositionType, typename SubDiagType, typename WorkspaceType>
+  static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat, TranspositionType& transpositions, SubDiagType& subdiag,
+                                           WorkspaceType& workspace) {
+    Transpose<MatrixType> matt(mat);
+    return bunch_kaufman<Lower>::blocked(matt, transpositions, subdiag, workspace);
+  }
+};
+
+template <typename MatrixType>
+struct BunchKaufman_Traits<MatrixType, Lower> {
+  using MatrixL = const TriangularView<const MatrixType, UnitLower>;
+  using MatrixU = const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper>;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
+};
+
+template <typename MatrixType>
+struct BunchKaufman_Traits<MatrixType, Upper> {
+  using MatrixL = const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower>;
+  using MatrixU = const TriangularView<const MatrixType, UnitUpper>;
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
+};
+
+}  // end namespace internal
+
+template <typename MatrixType, int UpLo_>
+template <typename Derived>
+void BunchKaufman<MatrixType, UpLo_>::applyD(MatrixBase<Derived>& x) const {
+  const Index n = m_matrix.rows();
+  Index k = 0;
+  while (k < n) {
+    if (k + 1 < n && !numext::is_exactly_zero(m_subdiag.coeff(k))) {
+      const RealScalar d11 = numext::real(m_matrix.coeff(k, k));
+      const RealScalar d22 = numext::real(m_matrix.coeff(k + 1, k + 1));
+      const Scalar d21 = m_subdiag.coeff(k);
+      for (Index j = 0; j < x.cols(); ++j) {
+        const Scalar x0 = x.coeff(k, j);
+        const Scalar x1 = x.coeff(k + 1, j);
+        x.coeffRef(k, j) = d11 * x0 + numext::conj(d21) * x1;
+        x.coeffRef(k + 1, j) = d21 * x0 + d22 * x1;
+      }
+      k += 2;
+    } else {
+      x.row(k) *= numext::real(m_matrix.coeff(k, k));
+      k += 1;
+    }
+  }
+}
+
+template <typename MatrixType, int UpLo_>
+template <bool Conjugate, typename Derived>
+void BunchKaufman<MatrixType, UpLo_>::solveInPlaceD(MatrixBase<Derived>& x) const {
+  using numext::abs;
+  const Index n = m_matrix.rows();
+  // Use the pseudo-inverse of singular 1x1 blocks (see Eigen bug 241 for LDLT). The 2x2 blocks
+  // produced by Bunch-Kaufman pivoting are non-singular by construction.
+  const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+  Index k = 0;
+  while (k < n) {
+    if (k + 1 < n && !numext::is_exactly_zero(m_subdiag.coeff(k))) {
+      const RealScalar d11 = numext::real(m_matrix.coeff(k, k));
+      const RealScalar d22 = numext::real(m_matrix.coeff(k + 1, k + 1));
+      // D = [ d11  conj(d21) ; d21  d22 ]; for the transpose solve use conj(d21) instead of d21.
+      const Scalar d21 = Conjugate ? m_subdiag.coeff(k) : numext::conj(m_subdiag.coeff(k));
+      // Scaled 2x2 solve (LAPACK xSYTRS/xHETRS): divide through by d21 so the scaled determinant
+      // denom = det/|d21|^2 is O(1); det = d11*d22 - |d21|^2 is never formed (it over/underflows on
+      // extreme-scaled blocks, e.g. [[0,s],[s,0]], s=1e+-200). Every quotient divides by d21 itself:
+      // a hoisted 1/d21 overflows once |d21| is subnormal (issue #3142).
+      const Scalar cjd = numext::conj(d21);
+      const Scalar ak = numext::divide(d22, d21);
+      const Scalar akm1 = numext::divide(d11, cjd);
+      const RealScalar t = RealScalar(1) / (numext::real(ak * akm1) - RealScalar(1));
+      for (Index j = 0; j < x.cols(); ++j) {
+        const Scalar bk = numext::divide(x.coeff(k + 1, j), d21);
+        const Scalar bkm1 = numext::divide(x.coeff(k, j), cjd);
+        x.coeffRef(k, j) = t * (ak * bkm1 - bk);
+        x.coeffRef(k + 1, j) = t * (akm1 * bk - bkm1);
+      }
+      k += 2;
+    } else {
+      const RealScalar dk = numext::real(m_matrix.coeff(k, k));
+      if (abs(dk) > tol)
+        x.row(k) /= dk;
+      else
+        x.row(k).setZero();
+      k += 1;
+    }
+  }
+}
+
+// det(D_k) itself over- or underflows on an extreme-scaled 2x2 block, so it is only ever formed scaled by
+// |d21|^2. Divide by |d21| twice rather than multiply by its reciprocal, which overflows once |d21| is
+// subnormal. The pivot criterion bounds |q| by a^2 < 1 with a = (1+sqrt(17))/8, so |q| >= 1 or NaN is an
+// artifact of d22/d21 overflowing -- the criterion bounds |d22| only against its own row -- and
+// det(D_k) = -|d21|^2 to within that same bound there.
+template <typename MatrixType, int UpLo_>
+typename BunchKaufman<MatrixType, UpLo_>::RealScalar BunchKaufman<MatrixType, UpLo_>::scaledBlockDeterminant(
+    const RealScalar& d11, const RealScalar& d22, const RealScalar& d21) {
+  const RealScalar q = (d11 / d21) * (d22 / d21);
+  return (q > RealScalar(-1) && q < RealScalar(1)) ? q - RealScalar(1) : RealScalar(-1);
+}
+
+template <typename MatrixType, int UpLo_>
+void BunchKaufman<MatrixType, UpLo_>::computeInertia() {
+  const Index n = m_matrix.rows();
+  m_n_pos = m_n_neg = m_n_zero = 0;
+  Index k = 0;
+  while (k < n) {
+    if (k + 1 < n && !numext::is_exactly_zero(m_subdiag.coeff(k))) {
+      const RealScalar d11 = numext::real(m_matrix.coeff(k, k));
+      const RealScalar d22 = numext::real(m_matrix.coeff(k + 1, k + 1));
+      const RealScalar d21 = numext::abs(m_subdiag.coeff(k));
+      const RealScalar denom = scaledBlockDeterminant(d11, d22, d21);
+      if (denom < RealScalar(0)) {
+        // Indefinite 2x2 block: one positive and one negative eigenvalue.
+        ++m_n_pos;
+        ++m_n_neg;
+      } else if (numext::is_exactly_zero(denom)) {
+        const RealScalar tr = d11 + d22;
+        if (tr > RealScalar(0))
+          ++m_n_pos;
+        else if (tr < RealScalar(0))
+          ++m_n_neg;
+        else
+          ++m_n_zero;
+        ++m_n_zero;
+      } else {
+        // denom > 0: both eigenvalues share the sign of the trace.
+        if (d11 + d22 > RealScalar(0))
+          m_n_pos += 2;
+        else
+          m_n_neg += 2;
+      }
+      k += 2;
+    } else {
+      const RealScalar dk = numext::real(m_matrix.coeff(k, k));
+      if (dk > RealScalar(0))
+        ++m_n_pos;
+      else if (dk < RealScalar(0))
+        ++m_n_neg;
+      else
+        ++m_n_zero;
+      k += 1;
+    }
+  }
+}
+
+/** Compute / recompute the Bunch-Kaufman factorization \f$ P A P^T = L D L^* \f$ (or \f$ U^* D U \f$ for the
+ * upper variant) of \a a. */
+template <typename MatrixType, int UpLo_>
+template <typename InputType>
+BunchKaufman<MatrixType, UpLo_>& BunchKaufman<MatrixType, UpLo_>::compute(const EigenBase<InputType>& a) {
+  eigen_assert(a.rows() == a.cols());
+  m_matrix = a.derived();
+  return computeInPlace();
+}
+
+/** \internal Factorizes the matrix held in m_matrix, which is overwritten by the packed factors. */
+template <typename MatrixType, int UpLo_>
+BunchKaufman<MatrixType, UpLo_>& BunchKaufman<MatrixType, UpLo_>::computeInPlace() {
+  eigen_assert(m_matrix.rows() == m_matrix.cols());
+  const Index size = m_matrix.rows();
+
+  // L1 norm of the implicit self-adjoint matrix, for rcond().
+  m_l1_norm = m_matrix.template selfadjointView<UpLo_>().l1Norm();
+
+  m_transpositions.resize(size);
+  m_subdiag.resize(size);
+  m_isInitialized = false;
+
+  Index info = internal::bunch_kaufman<UpLo>::blocked(m_matrix, m_transpositions, m_subdiag, m_workspace);
+  m_info = (info == 0) ? Success : NumericalIssue;
+
+  // The upper variant factorizes the transpose of the (Hermitian) matrix, i.e. its complex conjugate,
+  // so the recorded 2x2 off-diagonals of D come out conjugated; undo that so that m_subdiag holds the
+  // true sub-diagonal D(k+1,k) consumed by applyD()/solveInPlaceD()/computeInertia(). (No-op when real.)
+  EIGEN_IF_CONSTEXPR (int(UpLo) == int(Upper) && NumTraits<Scalar>::IsComplex) {
+    m_subdiag = m_subdiag.conjugate();
+  }
+
+  computeInertia();
+
+  m_isInitialized = true;
+  return *this;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename MatrixType_, int UpLo_>
+template <typename RhsType, typename DstType>
+void BunchKaufman<MatrixType_, UpLo_>::_solve_impl(const RhsType& rhs, DstType& dst) const {
+  _solve_impl_transposed<true>(rhs, dst);
+}
+
+template <typename MatrixType_, int UpLo_>
+template <bool Conjugate, typename RhsType, typename DstType>
+void BunchKaufman<MatrixType_, UpLo_>::_solve_impl_transposed(const RhsType& rhs, DstType& dst) const {
+  // A^{-1} b = P^T L^{-*} D^{-1} L^{-1} P b   (and the conjugated variants for transpose / adjoint solves).
+  dst = m_transpositions * rhs;
+  matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
+  solveInPlaceD<Conjugate>(dst);
+  matrixL().transpose().template conjugateIf<Conjugate>().solveInPlace(dst);
+  dst = m_transpositions.transpose() * dst;
+}
+#endif
+
+/** \internal use x = bunchKaufman_object.solve(x);
+ *
+ * This is the \em in-place version of solve().
+ *
+ * \returns true always.
+ */
+template <typename MatrixType, int UpLo_>
+template <typename Derived>
+bool BunchKaufman<MatrixType, UpLo_>::solveInPlace(MatrixBase<Derived>& bAndX) const {
+  eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+  eigen_assert(m_matrix.rows() == bAndX.rows());
+  bAndX = this->solve(bAndX);
+  return true;
+}
+
+template <typename MatrixType, int UpLo_>
+typename BunchKaufman<MatrixType, UpLo_>::RealScalar BunchKaufman<MatrixType, UpLo_>::determinantD() const {
+  const Index n = m_matrix.rows();
+  // det(D) is accumulated as mantissa * 2^exponent, the mantissa renormalized to [1/2, 1) after each
+  // block. Both a single 2x2 block determinant and the running product can leave the representable range
+  // while det(D) itself stays in it, and an overflowed block meeting an underflowed one gives NaN.
+  RealScalar mantissa(1);
+  Index exponent = 0;
+  Index k = 0;
+  while (k < n) {
+    RealScalar blockM, blockE;
+    if (k + 1 < n && !numext::is_exactly_zero(m_subdiag.coeff(k))) {
+      const RealScalar d11 = numext::real(m_matrix.coeff(k, k));
+      const RealScalar d22 = numext::real(m_matrix.coeff(k + 1, k + 1));
+      const RealScalar d21 = numext::abs(m_subdiag.coeff(k));
+      RealScalar e21;
+      const RealScalar m21 = internal::pfrexp<RealScalar>(d21, e21);
+      blockM = m21 * m21 * scaledBlockDeterminant(d11, d22, d21);
+      blockE = RealScalar(2) * e21;
+      k += 2;
+    } else {
+      blockM = internal::pfrexp<RealScalar>(numext::real(m_matrix.coeff(k, k)), blockE);
+      k += 1;
+    }
+    // |blockM| < 2 and, unless the block is singular, above 1/16, so the product below stays normal and
+    // its rounding is the only error this step adds.
+    RealScalar renorm;
+    mantissa = internal::pfrexp<RealScalar>(mantissa * blockM, renorm);
+    exponent += Index(blockE) + Index(renorm);
+  }
+  // ldexp() saturates to zero or infinity but takes an int exponent; past this magnitude it has already
+  // saturated, so clamping first cannot change the result.
+  const Index limit = Index(NumTraits<RealScalar>::max_exponent()) - Index(NumTraits<RealScalar>::min_exponent()) +
+                      Index(NumTraits<RealScalar>::digits());
+  return numext::ldexp(mantissa, int(numext::mini(numext::maxi(exponent, -limit), limit)));
+}
+
+// A = P^T L D L^* P with L unit triangular, so det(A) = det(D) = prod over the 1x1 and 2x2 blocks of D.
+
+template <typename MatrixType, int UpLo_>
+typename BunchKaufman<MatrixType, UpLo_>::Scalar BunchKaufman<MatrixType, UpLo_>::determinant() const {
+  eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+  return Scalar(determinantD());
+}
+
+template <typename MatrixType, int UpLo_>
+typename BunchKaufman<MatrixType, UpLo_>::RealScalar BunchKaufman<MatrixType, UpLo_>::absDeterminant() const {
+  eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+  return numext::abs(determinantD());
+}
+
+template <typename MatrixType, int UpLo_>
+typename BunchKaufman<MatrixType, UpLo_>::RealScalar BunchKaufman<MatrixType, UpLo_>::logAbsDeterminant() const {
+  eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+  const Index n = m_matrix.rows();
+  RealScalar result(0);
+  Index k = 0;
+  while (k < n) {
+    if (k + 1 < n && !numext::is_exactly_zero(m_subdiag.coeff(k))) {
+      // log|det(D_k)| = 2 log|d21| + log|det(D_k)/|d21|^2|.
+      const RealScalar d11 = numext::real(m_matrix.coeff(k, k));
+      const RealScalar d22 = numext::real(m_matrix.coeff(k + 1, k + 1));
+      const RealScalar d21 = numext::abs(m_subdiag.coeff(k));
+      const RealScalar scaled = scaledBlockDeterminant(d11, d22, d21);
+      result += RealScalar(2) * numext::log(d21) + numext::log(numext::abs(scaled));
+      k += 2;
+    } else {
+      result += numext::log(numext::abs(numext::real(m_matrix.coeff(k, k))));
+      k += 1;
+    }
+  }
+  return result;
+}
+
+template <typename MatrixType, int UpLo_>
+typename BunchKaufman<MatrixType, UpLo_>::Scalar BunchKaufman<MatrixType, UpLo_>::signDeterminant() const {
+  eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+  if (m_n_zero > 0) return Scalar(0);
+  return Scalar((m_n_neg % 2 == 0) ? 1 : -1);
+}
+
+/** \returns the matrix represented by the decomposition, i.e., the product \f$ P^T L D L^* P \f$.
+ * This function is provided for debug purposes. */
+template <typename MatrixType, int UpLo_>
+MatrixType BunchKaufman<MatrixType, UpLo_>::reconstructedMatrix() const {
+  eigen_assert(m_isInitialized && "BunchKaufman is not initialized.");
+  const Index size = m_matrix.rows();
+  MatrixType res(size, size);
+
+  res.setIdentity();
+  res = transpositionsP() * res;              // P
+  res = matrixU() * res;                      // U P = L^* P
+  applyD(res);                                // D L^* P
+  res = matrixL() * res;                      // L D L^* P
+  res = transpositionsP().transpose() * res;  // P^T L D L^* P
+
+  return res;
+}
+
+/** \cholesky_module
+ * \returns the Bunch-Kaufman factorization of \c *this
+ * \sa SelfAdjointView::bunchKaufman()
+ */
+template <typename MatrixType, unsigned int UpLo>
+inline BunchKaufman<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
+SelfAdjointView<MatrixType, UpLo>::bunchKaufman() const {
+  return BunchKaufman<PlainObject, UpLo>(m_matrix);
+}
+
+/** \cholesky_module
+ * \returns the Bunch-Kaufman factorization of \c *this
+ * \sa SelfAdjointView::bunchKaufman()
+ */
+template <typename Derived>
+inline BunchKaufman<typename MatrixBase<Derived>::PlainObject> MatrixBase<Derived>::bunchKaufman() const {
+  return BunchKaufman<PlainObject>(derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BUNCHKAUFMAN_H
diff --git a/Eigen/src/Cholesky/InternalHeaderCheck.h b/Eigen/src/Cholesky/InternalHeaderCheck.h
index 5de2b21..fcd579c 100644
--- a/Eigen/src/Cholesky/InternalHeaderCheck.h
+++ b/Eigen/src/Cholesky/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_CHOLESKY_MODULE_H
 #error "Please include Eigen/Cholesky instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Cholesky/LDLT.h b/Eigen/src/Cholesky/LDLT.h
index 45912a2..5ecbda8 100644
--- a/Eigen/src/Cholesky/LDLT.h
+++ b/Eigen/src/Cholesky/LDLT.h
@@ -9,6 +9,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_LDLT_H
 #define EIGEN_LDLT_H
@@ -21,9 +22,9 @@
 namespace internal {
 template <typename MatrixType_, int UpLo_>
 struct traits<LDLT<MatrixType_, UpLo_> > : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef int StorageIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
   enum { Flags = 0 };
 };
 
@@ -57,13 +58,16 @@
  *
  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
  *
- * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
+ * D is purely diagonal, so this class cannot factor an indefinite matrix. For a self-adjoint matrix
+ * that is indefinite, use BunchKaufman, which produces a block-diagonal D.
+ *
+ * \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT, class BunchKaufman
  */
 template <typename MatrixType_, int UpLo_>
 class LDLT : public SolverBase<LDLT<MatrixType_, UpLo_> > {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<LDLT> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<LDLT>;
   friend class SolverBase<LDLT>;
 
   EIGEN_GENERIC_PUBLIC_INTERFACE(LDLT)
@@ -72,12 +76,12 @@
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
     UpLo = UpLo_
   };
-  typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> TmpMatrixType;
+  using TmpMatrixType = Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1>;
 
-  typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
-  typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
+  using TranspositionType = Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime>;
+  using PermutationType = PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime>;
 
-  typedef internal::LDLT_Traits<MatrixType, UpLo> Traits;
+  using Traits = internal::LDLT_Traits<MatrixType, UpLo>;
 
   /** \brief Default Constructor.
    *
@@ -223,6 +227,65 @@
   template <typename Derived>
   LDLT& rankUpdate(const MatrixBase<Derived>& w, const RealScalar& alpha = 1);
 
+  /** \returns the determinant of the matrix of which *this is the Cholesky decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() and signDeterminant() instead.
+   * Also, do not rely on the determinant being exactly zero for testing
+   * singularity or rank-deficiency.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa absDeterminant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  Scalar determinant() const;
+
+  /** \returns the absolute value of the determinant of the matrix of which *this is the Cholesky decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa determinant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the matrix of which *this is the Cholesky
+   * decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa determinant(), absDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar logAbsDeterminant() const;
+
+  /** \returns the sign of the determinant of the matrix of which *this is the Cholesky decomposition,
+   * that is, \c 1, \c -1, or \c 0 if the matrix is singular.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa determinant(), absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
+   */
+  Scalar signDeterminant() const;
+
   /** \returns the internal LDLT decomposition matrix
    *
    * TODO: document the storage layout.
@@ -291,9 +354,9 @@
   template <typename MatrixType, typename TranspositionType, typename Workspace>
   static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign) {
     using std::abs;
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename MatrixType::RealScalar RealScalar;
-    typedef typename TranspositionType::StorageIndex IndexType;
+    using Scalar = typename MatrixType::Scalar;
+    using RealScalar = typename MatrixType::RealScalar;
+    using IndexType = typename TranspositionType::StorageIndex;
     eigen_assert(mat.rows() == mat.cols());
     const Index size = mat.rows();
     bool found_zero_pivot = false;
@@ -331,7 +394,7 @@
           mat.coeffRef(i, k) = numext::conj(mat.coeffRef(index_of_biggest_in_corner, i));
           mat.coeffRef(index_of_biggest_in_corner, i) = numext::conj(tmp);
         }
-        if (NumTraits<Scalar>::IsComplex)
+        EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex)
           mat.coeffRef(index_of_biggest_in_corner, k) = numext::conj(mat.coeff(index_of_biggest_in_corner, k));
       }
 
@@ -404,8 +467,8 @@
   static bool updateInPlace(MatrixType& mat, MatrixBase<WDerived>& w,
                             const typename MatrixType::RealScalar& sigma = 1) {
     using numext::isfinite;
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename MatrixType::RealScalar RealScalar;
+    using Scalar = typename MatrixType::Scalar;
+    using RealScalar = typename MatrixType::RealScalar;
 
     const Index size = mat.rows();
     eigen_assert(mat.cols() == size && w.size() == size);
@@ -423,8 +486,15 @@
       RealScalar swj2 = sigma * numext::abs2(wj);
       RealScalar gamma = dj * alpha + swj2;
 
-      mat.coeffRef(j, j) += swj2 / alpha;
-      alpha += swj2 / dj;
+      // A zero contribution leaves both quantities unchanged, but spelling that out as an addition of swj2/alpha and
+      // swj2/dj evaluates 0/0 when alpha or the pivot is zero. The resulting NaN reaches the termination test above
+      // on the next iteration, which reads it as a low-rank signal and abandons the remainder of the update. Skip the
+      // no-op instead. A zero pivot with a nonzero contribution still yields an infinite alpha, so genuine low-rank
+      // termination is unaffected.
+      if (!numext::is_exactly_zero(swj2)) {
+        mat.coeffRef(j, j) += swj2 / alpha;
+        alpha += swj2 / dj;
+      }
 
       // Update the terms of L
       Index rs = size - j - 1;
@@ -463,16 +533,16 @@
 
 template <typename MatrixType>
 struct LDLT_Traits<MatrixType, Lower> {
-  typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
-  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
+  using MatrixL = const TriangularView<const MatrixType, UnitLower>;
+  using MatrixU = const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper>;
   static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
   static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
 };
 
 template <typename MatrixType>
 struct LDLT_Traits<MatrixType, Upper> {
-  typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
-  typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
+  using MatrixL = const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower>;
+  using MatrixU = const TriangularView<const MatrixType, UnitUpper>;
   static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
   static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
 };
@@ -489,19 +559,8 @@
 
   m_matrix = a.derived();
 
-  // Compute matrix L1 norm = max abs column sum.
-  m_l1_norm = RealScalar(0);
-  // TODO: move this code to SelfAdjointView
-  for (Index col = 0; col < size; ++col) {
-    RealScalar abs_col_sum;
-    if (UpLo_ == Lower)
-      abs_col_sum =
-          m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
-    else
-      abs_col_sum =
-          m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
-    if (abs_col_sum > m_l1_norm) m_l1_norm = abs_col_sum;
-  }
+  // Compute matrix L1 norm = max abs column sum over the implicit self-adjoint matrix.
+  m_l1_norm = m_matrix.template selfadjointView<UpLo_>().l1Norm();
 
   m_transpositions.resize(size);
   m_isInitialized = false;
@@ -515,16 +574,30 @@
   return *this;
 }
 
-/** Update the LDLT decomposition:  given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.
+/** Update the LDLT decomposition: given a decomposition of \f$ A = P^TLDL^*P \f$, efficiently compute the
+ * decomposition of \f$ A + \sigma w w^* \f$.
+ *
+ * If \c *this holds no factorization yet, A is taken to be zero and the decomposition is built from scratch; info()
+ * then reports \c Success. An update applied to an existing factorization leaves info() unchanged, so a
+ * \c NumericalIssue already reported for that factorization stands until compute() replaces it or setZero() discards
+ * it. LLT::rankUpdate() differs on both counts: it requires an existing factorization and re-reports the status on
+ * every call.
+ *
+ * \note rcond(), isPositive() and isNegative() are not maintained across rank updates. rcond() keeps using the L1
+ * norm recorded by the last compute(), which is zero when there was none, and the definiteness flags are assigned
+ * only where this function builds a factorization from scratch, from the sign of \a sigma alone.
+ *
  * \param w a vector to be incorporated into the decomposition.
  * \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column
- * vectors. Optional; default value is +1. \sa setZero()
+ * vectors. Optional; default value is +1.
+ *
+ * \sa setZero()
  */
 template <typename MatrixType, int UpLo_>
 template <typename Derived>
 LDLT<MatrixType, UpLo_>& LDLT<MatrixType, UpLo_>::rankUpdate(
     const MatrixBase<Derived>& w, const typename LDLT<MatrixType, UpLo_>::RealScalar& sigma) {
-  typedef typename TranspositionType::StorageIndex IndexType;
+  using IndexType = typename TranspositionType::StorageIndex;
   const Index size = w.rows();
   if (m_isInitialized) {
     eigen_assert(m_matrix.rows() == size);
@@ -536,6 +609,8 @@
     m_temporary.resize(size);
     m_sign = sigma >= 0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
     m_isInitialized = true;
+    // Assigned here rather than after the branch: updating an existing factorization keeps the status it already has.
+    m_info = Success;
   }
 
   internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
@@ -543,6 +618,36 @@
   return *this;
 }
 
+// A = P^T L D L^* P with L unit lower triangular and D real diagonal, so det(A) = prod(D_ii).
+
+template <typename MatrixType_, int UpLo_>
+typename LDLT<MatrixType_, UpLo_>::Scalar LDLT<MatrixType_, UpLo_>::determinant() const {
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_info == Success && "LDLT failed because of a zero pivot.");
+  return Scalar(vectorD().real().prod());
+}
+
+template <typename MatrixType_, int UpLo_>
+typename LDLT<MatrixType_, UpLo_>::RealScalar LDLT<MatrixType_, UpLo_>::absDeterminant() const {
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_info == Success && "LDLT failed because of a zero pivot.");
+  return numext::abs(vectorD().real().prod());
+}
+
+template <typename MatrixType_, int UpLo_>
+typename LDLT<MatrixType_, UpLo_>::RealScalar LDLT<MatrixType_, UpLo_>::logAbsDeterminant() const {
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_info == Success && "LDLT failed because of a zero pivot.");
+  return vectorD().real().cwiseAbs().array().log().sum();
+}
+
+template <typename MatrixType_, int UpLo_>
+typename LDLT<MatrixType_, UpLo_>::Scalar LDLT<MatrixType_, UpLo_>::signDeterminant() const {
+  eigen_assert(m_isInitialized && "LDLT is not initialized.");
+  eigen_assert(m_info == Success && "LDLT failed because of a zero pivot.");
+  return Scalar(vectorD().real().array().sign().prod());
+}
+
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 template <typename MatrixType_, int UpLo_>
 template <typename RhsType, typename DstType>
diff --git a/Eigen/src/Cholesky/LLT.h b/Eigen/src/Cholesky/LLT.h
index 7066cd0..64340d4 100644
--- a/Eigen/src/Cholesky/LLT.h
+++ b/Eigen/src/Cholesky/LLT.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_LLT_H
 #define EIGEN_LLT_H
@@ -13,15 +14,28 @@
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
 
+// Smallest n at which LLT::inverse() runs the POTRI sequence on a real scalar rather than solving
+// against an explicit identity. POTRI's n^3/3 runs in the unblocked TRTRI and LAUUM kernels at small
+// n, the solve's 3x at the blocked TRSM rate, so a wider ISA helps the competitor more and moves the
+// crossover right: on Zen 4 it is n = 32 under SSE2 and AVX2, 128 (double) to 256 (float) under
+// AVX-512. Complex is not thresholded: POTRI leads from n = 8 in all twelve configurations measured.
+#ifndef EIGEN_LLT_INVERSE_POTRI_THRESHOLD
+#if defined(EIGEN_VECTORIZE_AVX512)
+#define EIGEN_LLT_INVERSE_POTRI_THRESHOLD 256
+#else
+#define EIGEN_LLT_INVERSE_POTRI_THRESHOLD 32
+#endif
+#endif
+
 namespace Eigen {
 
 namespace internal {
 
 template <typename MatrixType_, int UpLo_>
 struct traits<LLT<MatrixType_, UpLo_> > : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef int StorageIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
   enum { Flags = 0 };
 };
 
@@ -62,15 +76,16 @@
  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
  *
  * Note that during the decomposition, only the lower (or upper, as defined by UpLo_) triangular part of A is
- * considered. Therefore, the strict lower part does not have to store correct values.
+ * considered. Therefore, the strict upper part (or the strict lower part when UpLo_ is Upper) does not have to
+ * store correct values.
  *
  * \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
  */
 template <typename MatrixType_, int UpLo_>
 class LLT : public SolverBase<LLT<MatrixType_, UpLo_> > {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<LLT> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<LLT>;
   friend class SolverBase<LLT>;
 
   EIGEN_GENERIC_PUBLIC_INTERFACE(LLT)
@@ -78,7 +93,8 @@
 
   enum { PacketSize = internal::packet_traits<Scalar>::size, AlignmentMask = int(PacketSize) - 1, UpLo = UpLo_ };
 
-  typedef internal::LLT_Traits<MatrixType, UpLo> Traits;
+  using Traits = internal::LLT_Traits<MatrixType, UpLo>;
+  using PlainObject = typename MatrixType::PlainObject;
 
   /**
    * \brief Default Constructor.
@@ -166,12 +182,38 @@
     return m_matrix;
   }
 
+  /** \returns the inverse of the matrix of which \c *this is the Cholesky decomposition.
+   *
+   * The result is computed as \f$ A^{-1} = L^{-*} L^{-1} \f$ by inverting the stored factor in place and
+   * squaring it, the LAPACK \c *POTRI sequence, for 2n^3/3 flops against the 2n^3 of solving with an
+   * explicit identity right hand side. Beyond the destination, only a block-sized scratch panel of at most
+   * 128x128 coefficients is used, whatever the matrix size.
+   *
+   * Fewer flops is not fewer seconds at every size: for a real scalar below
+   * \c EIGEN_LLT_INVERSE_POTRI_THRESHOLD (32, or 256 where AVX-512 is enabled) the POTRI sequence runs in
+   * its unblocked kernels while the solve against an identity runs its 3x at the blocked TRSM rate, so that
+   * is what this method does there. Complex scalars always take the POTRI path. The result is exactly
+   * self-adjoint either way: one triangle is computed and mirrored onto the other.
+   *
+   * An in-place decomposition (see the class documentation) may overwrite its own factor with the result,
+   * as in <tt>storage = llt.inverse()</tt>; like any other write to the referenced matrix, that leaves the
+   * decomposition unusable afterwards.
+   *
+   * The matrix must be positive definite, that is, info() must be \c Success.
+   *
+   * \sa solve(), MatrixBase::inverse()
+   */
+  inline Inverse<LLT> inverse() const {
+    eigen_assert(m_isInitialized && "LLT is not initialized.");
+    return Inverse<LLT>(*this);
+  }
+
   MatrixType reconstructedMatrix() const;
 
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears not to be positive definite.
+   *          \c NumericalIssue if the matrix appears not to be positive definite.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "LLT is not initialized.");
@@ -192,6 +234,64 @@
   template <typename VectorType>
   LLT& rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
 
+  /** \returns the determinant of the matrix of which *this is the Cholesky decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa absDeterminant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  Scalar determinant() const;
+
+  /** \returns the absolute value of the determinant of the matrix of which *this is the Cholesky decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \note The decomposed matrix is positive definite, so this is the determinant itself.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa determinant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the matrix of which *this is the Cholesky
+   * decomposition.
+   *
+   * It has only linear complexity (that is, O(n) where n is the dimension of the square matrix)
+   * as the Cholesky decomposition has already been computed.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa determinant(), absDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar logAbsDeterminant() const;
+
+  /** \returns the sign of the determinant of the matrix of which *this is the Cholesky decomposition,
+   * which is \c 1 since that matrix is positive definite.
+   *
+   * This method is provided for compatibility with the other decompositions, thus enabling generic code.
+   *
+   * \pre info() returns \c Success. A failed factorization does not represent the input matrix.
+   *
+   * \sa determinant(), absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
+   */
+  Scalar signDeterminant() const;
+
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   template <typename RhsType, typename DstType>
   void _solve_impl(const RhsType& rhs, DstType& dst) const;
@@ -204,8 +304,8 @@
   EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
 
   /** \internal
-   * Used to compute and store L
-   * The strict upper part is not used and even not initialized.
+   * Used to compute and store L, or U when UpLo_ is Upper.
+   * The strict part of the other triangle is not used and even not initialized.
    */
   MatrixType m_matrix;
   RealScalar m_l1_norm;
@@ -222,13 +322,13 @@
 static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec,
                                    const typename MatrixType::RealScalar& sigma) {
   using std::sqrt;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::ColXpr ColXpr;
-  typedef internal::remove_all_t<ColXpr> ColXprCleaned;
-  typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
-  typedef Matrix<Scalar, Dynamic, 1> TempVectorType;
-  typedef typename TempVectorType::SegmentReturnType TempVecSegment;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using ColXpr = typename MatrixType::ColXpr;
+  using ColXprCleaned = internal::remove_all_t<ColXpr>;
+  using ColXprSegment = typename ColXprCleaned::SegmentReturnType;
+  using TempVectorType = Matrix<Scalar, MatrixType::RowsAtCompileTime, 1, 0, MatrixType::MaxRowsAtCompileTime, 1>;
+  using TempVecSegment = typename TempVectorType::SegmentReturnType;
 
   Index n = mat.cols();
   eigen_assert(mat.rows() == n && vec.size() == n);
@@ -283,7 +383,7 @@
 
 template <typename Scalar>
 struct llt_inplace<Scalar, Lower> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   template <typename MatrixType>
   static Index unblocked(MatrixType& mat) {
     using std::sqrt;
@@ -346,7 +446,7 @@
 
 template <typename Scalar>
 struct llt_inplace<Scalar, Upper> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   template <typename MatrixType>
   static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat) {
@@ -367,8 +467,8 @@
 
 template <typename MatrixType>
 struct LLT_Traits<MatrixType, Lower> {
-  typedef const TriangularView<const MatrixType, Lower> MatrixL;
-  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
+  using MatrixL = const TriangularView<const MatrixType, Lower>;
+  using MatrixU = const TriangularView<const typename MatrixType::AdjointReturnType, Upper>;
   static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
   static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
   static bool inplace_decomposition(MatrixType& m) {
@@ -378,8 +478,8 @@
 
 template <typename MatrixType>
 struct LLT_Traits<MatrixType, Upper> {
-  typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
-  typedef const TriangularView<const MatrixType, Upper> MatrixU;
+  using MatrixL = const TriangularView<const typename MatrixType::AdjointReturnType, Lower>;
+  using MatrixU = const TriangularView<const MatrixType, Upper>;
   static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
   static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
   static bool inplace_decomposition(MatrixType& m) {
@@ -404,19 +504,8 @@
   m_matrix.resize(size, size);
   if (!internal::is_same_dense(m_matrix, a.derived())) m_matrix = a.derived();
 
-  // Compute matrix L1 norm = max abs column sum.
-  m_l1_norm = RealScalar(0);
-  // TODO: move this code to SelfAdjointView
-  for (Index col = 0; col < size; ++col) {
-    RealScalar abs_col_sum;
-    if (UpLo_ == Lower)
-      abs_col_sum =
-          m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
-    else
-      abs_col_sum =
-          m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
-    if (abs_col_sum > m_l1_norm) m_l1_norm = abs_col_sum;
-  }
+  // Compute matrix L1 norm = max abs column sum over the implicit self-adjoint matrix.
+  m_l1_norm = m_matrix.template selfadjointView<UpLo_>().l1Norm();
 
   m_isInitialized = true;
   bool ok = Traits::inplace_decomposition(m_matrix);
@@ -425,7 +514,7 @@
   return *this;
 }
 
-/** Performs a rank one update (or dowdate) of the current decomposition.
+/** Performs a rank one update (or downdate) of the current decomposition.
  * If A = LL^* before the rank one update,
  * then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
  * of same dimension.
@@ -444,6 +533,34 @@
   return *this;
 }
 
+// A = L L^*, with L real and positive on the diagonal, so det(A) = prod(L_ii)^2 > 0.
+
+template <typename MatrixType_, int UpLo_>
+typename LLT<MatrixType_, UpLo_>::Scalar LLT<MatrixType_, UpLo_>::determinant() const {
+  return Scalar(absDeterminant());
+}
+
+template <typename MatrixType_, int UpLo_>
+typename LLT<MatrixType_, UpLo_>::RealScalar LLT<MatrixType_, UpLo_>::absDeterminant() const {
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
+  return numext::abs2(m_matrix.diagonal().real().prod());
+}
+
+template <typename MatrixType_, int UpLo_>
+typename LLT<MatrixType_, UpLo_>::RealScalar LLT<MatrixType_, UpLo_>::logAbsDeterminant() const {
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
+  return RealScalar(2) * m_matrix.diagonal().real().array().log().sum();
+}
+
+template <typename MatrixType_, int UpLo_>
+typename LLT<MatrixType_, UpLo_>::Scalar LLT<MatrixType_, UpLo_>::signDeterminant() const {
+  eigen_assert(m_isInitialized && "LLT is not initialized.");
+  eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
+  return Scalar(1);
+}
+
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 template <typename MatrixType_, int UpLo_>
 template <typename RhsType, typename DstType>
@@ -483,6 +600,50 @@
   matrixU().solveInPlace(bAndX);
 }
 
+namespace internal {
+
+/***** Implementation of inverse() *****************************************************/
+template <typename DstXprType, typename MatrixType, int UpLo_>
+struct Assignment<DstXprType, Inverse<LLT<MatrixType, UpLo_> >,
+                  internal::assign_op<typename DstXprType::Scalar, typename LLT<MatrixType, UpLo_>::Scalar>,
+                  Dense2Dense> {
+  using LltType = LLT<MatrixType, UpLo_>;
+  using SrcXprType = Inverse<LltType>;
+  static constexpr unsigned int kMirrorMode = UpLo_ == Lower ? StrictlyUpper : StrictlyLower;
+  static void run(DstXprType& dst, const SrcXprType& src,
+                  const internal::assign_op<typename DstXprType::Scalar, typename LltType::Scalar>&) {
+    const LltType& llt = src.nestedExpression();
+    eigen_assert(llt.info() == Success && "LLT::inverse(): the factorization failed.");
+    const Index size = llt.rows();
+    if ((dst.rows() != size) || (dst.cols() != size)) dst.resize(size, size);
+
+    // Complex is never thresholded; see EIGEN_LLT_INVERSE_POTRI_THRESHOLD.
+    constexpr Index kPotriThreshold =
+        NumTraits<typename LltType::Scalar>::IsComplex ? Index(0) : Index(EIGEN_LLT_INVERSE_POTRI_THRESHOLD);
+    // An in-place LLT<Ref<...>> may be asked to overwrite its own factor. The POTRI sequence does exactly
+    // that, so it takes the alias at every size; the solve fallback would read a factor that setIdentity()
+    // had already destroyed. extract_data() is null for a destination whose inner stride is not known to
+    // be 1 at compile time, which leaves the alias unknown rather than excluded, so that goes the same way.
+    const typename DstXprType::Scalar* dst_data = extract_data(dst);
+    const bool overwrites_factor = dst_data == nullptr || dst_data == llt.matrixLLT().data();
+    if (overwrites_factor || size >= kPotriThreshold) {
+      // A = L L^*, hence A^-1 = L^-* L^-1: invert the factor (xTRTRI), then square it (xLAUUM).
+      dst.template triangularView<UpLo_>() = llt.matrixLLT().template triangularView<UpLo_>();
+      dst.template triangularView<UpLo_>().inverseInPlace();
+      internal::triangular_adjoint_square_in_place<UpLo_>(dst);
+    } else {
+      dst.setIdentity();
+      llt.solveInPlace(dst);
+    }
+    // Mirror; (i, j) reads (j, i), which lies in the computed triangle and is never written here, so
+    // the aliasing is benign. LAUUM makes the computed diagonal exactly real, as does the real-scalar
+    // solve below the threshold, so the result is exactly self-adjoint.
+    dst.template triangularView<kMirrorMode>() = dst.adjoint();
+  }
+};
+
+}  // end namespace internal
+
 /** \returns the matrix represented by the decomposition,
  * i.e., it returns the product: L L^*.
  * This function is provided for debug purpose. */
diff --git a/Eigen/src/Cholesky/LLT_LAPACKE.h b/Eigen/src/Cholesky/LLT_LAPACKE.h
index cb55b15..2a14eb3 100644
--- a/Eigen/src/Cholesky/LLT_LAPACKE.h
+++ b/Eigen/src/Cholesky/LLT_LAPACKE.h
@@ -29,6 +29,7 @@
  *     LLt decomposition based on LAPACKE_?potrf function.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_LLT_LAPACKE_H
 #define EIGEN_LLT_LAPACKE_H
@@ -82,7 +83,7 @@
     lapack_int size = to_lapack(m.rows());
     lapack_int matrix_order = lapack_storage_of(m);
     constexpr char uplo = Mode == Upper ? 'U' : 'L';
-    Scalar *a = &(m.coeffRef(0, 0));
+    Scalar *a = &m.coeffRef(0, 0);
     lapack_int lda = to_lapack(m.outerStride());
 
     lapack_int info = potrf(matrix_order, uplo, size, to_lapack(a), lda);
@@ -96,7 +97,6 @@
   }
 };
 }  // namespace lapacke_helpers
-// end namespace lapacke_helpers
 
 /*
  * Here, we just put the generic implementation from lapacke_llt into a full specialization of the llt_inplace
diff --git a/Eigen/src/CholmodSupport/CholmodSupport.h b/Eigen/src/CholmodSupport/CholmodSupport.h
index dc3d6a3..eb0877d 100644
--- a/Eigen/src/CholmodSupport/CholmodSupport.h
+++ b/Eigen/src/CholmodSupport/CholmodSupport.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CHOLMODSUPPORT_H
 #define EIGEN_CHOLMODSUPPORT_H
@@ -82,9 +83,9 @@
   res.dtype = 0;
   res.stype = -1;
 
-  if (internal::is_same<StorageIndex_, int>::value) {
+  EIGEN_IF_CONSTEXPR ((std::is_same<StorageIndex_, int>::value)) {
     res.itype = CHOLMOD_INT;
-  } else if (internal::is_same<StorageIndex_, SuiteSparse_long>::value) {
+  } else EIGEN_IF_CONSTEXPR ((std::is_same<StorageIndex_, SuiteSparse_long>::value)) {
     res.itype = CHOLMOD_LONG;
   } else {
     eigen_assert(false && "Index type not supported yet");
@@ -116,12 +117,12 @@
 cholmod_sparse viewAsCholmod(const SparseSelfAdjointView<const SparseMatrix<Scalar_, Options_, Index_>, UpLo>& mat) {
   cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_, Options_, Index_> >(mat.matrix().const_cast_derived()));
 
-  if (UpLo == Upper) res.stype = 1;
-  if (UpLo == Lower) res.stype = -1;
+  EIGEN_IF_CONSTEXPR (UpLo == Upper) res.stype = 1;
+  EIGEN_IF_CONSTEXPR (UpLo == Lower) res.stype = -1;
   // swap stype for rowmajor matrices (only works for real matrices)
   EIGEN_STATIC_ASSERT((Options_ & RowMajorBit) == 0 || NumTraits<Scalar_>::IsComplex == 0,
                       THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
-  if (Options_ & RowMajorBit) res.stype *= -1;
+  EIGEN_IF_CONSTEXPR (Options_ & RowMajorBit) res.stype *= -1;
 
   return res;
 }
@@ -259,14 +260,14 @@
 
  public:
   CholmodBase() : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false) {
-    EIGEN_STATIC_ASSERT((internal::is_same<double, RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+    EIGEN_STATIC_ASSERT((std::is_same<double, RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
     m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
     internal::cm_start<StorageIndex>(m_cholmod);
   }
 
   explicit CholmodBase(const MatrixType& matrix)
       : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false) {
-    EIGEN_STATIC_ASSERT((internal::is_same<double, RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
+    EIGEN_STATIC_ASSERT((std::is_same<double, RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
     m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
     internal::cm_start<StorageIndex>(m_cholmod);
     compute(matrix);
@@ -283,7 +284,7 @@
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears to be negative.
+   *          \c NumericalIssue if the matrix appears to be negative.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
@@ -428,7 +429,7 @@
       // Supernodal factorization stored as a packed list of dense column-major blocks,
       // as described by the following structure:
 
-      // super[k] == index of the first column of the j-th super node
+      // super[k] == index of the first column of the k-th super node
       StorageIndex* super = static_cast<StorageIndex*>(m_cholmodFactor->super);
       // pi[k] == offset to the description of row indices
       StorageIndex* pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
@@ -482,7 +483,7 @@
  * \implsparsesolverconcept
  *
  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non
- * compressed.
+ * compressed, except row-major matrices with complex scalars.
  *
  * \warning Only double precision real and complex scalar types are supported by Cholmod.
  *
@@ -508,8 +509,6 @@
     this->compute(matrix);
   }
 
-  ~CholmodSimplicialLLT() {}
-
   /** \returns an expression of the factor L */
   inline MatrixL matrixL() const { return viewAsEigen<Scalar, StorageIndex>(*Base::m_cholmodFactor); }
 
@@ -541,7 +540,7 @@
  * \implsparsesolverconcept
  *
  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non
- * compressed.
+ * compressed, except row-major matrices with complex scalars.
  *
  * \warning Only double precision real and complex scalar types are supported by Cholmod.
  *
@@ -568,8 +567,6 @@
     this->compute(matrix);
   }
 
-  ~CholmodSimplicialLDLT() {}
-
   /** \returns a vector expression of the diagonal D */
   inline VectorType vectorD() const {
     auto cholmodL = viewAsEigen<Scalar, StorageIndex>(*Base::m_cholmodFactor);
@@ -614,7 +611,7 @@
  * \implsparsesolverconcept
  *
  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non
- * compressed.
+ * compressed, except row-major matrices with complex scalars.
  *
  * \warning Only double precision real and complex scalar types are supported by Cholmod.
  *
@@ -638,8 +635,6 @@
     this->compute(matrix);
   }
 
-  ~CholmodSupernodalLLT() {}
-
   /** \returns an expression of the factor L */
   inline MatrixType matrixL() const {
     // Convert Cholmod factor's supernodal storage format to Eigen's CSC storage format
@@ -679,7 +674,7 @@
  * \implsparsesolverconcept
  *
  * This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non
- * compressed.
+ * compressed, except row-major matrices with complex scalars.
  *
  * \warning Only double precision real and complex scalar types are supported by Cholmod.
  *
@@ -700,8 +695,6 @@
     this->compute(matrix);
   }
 
-  ~CholmodDecomposition() {}
-
   void setMode(CholmodMode mode) {
     switch (mode) {
       case CholmodAuto:
diff --git a/Eigen/src/CholmodSupport/InternalHeaderCheck.h b/Eigen/src/CholmodSupport/InternalHeaderCheck.h
index 0fb3abc..8578448 100644
--- a/Eigen/src/CholmodSupport/InternalHeaderCheck.h
+++ b/Eigen/src/CholmodSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
 #error "Please include Eigen/CholmodSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Core/ArithmeticSequence.h b/Eigen/src/Core/ArithmeticSequence.h
index 4161771..17562aa 100644
--- a/Eigen/src/Core/ArithmeticSequence.h
+++ b/Eigen/src/Core/ArithmeticSequence.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARITHMETIC_SEQUENCE_H
 #define EIGEN_ARITHMETIC_SEQUENCE_H
@@ -20,7 +21,7 @@
 // Helper to cleanup the type of the increment:
 template <typename T>
 struct cleanup_seq_incr {
-  typedef typename cleanup_index_type<T, DynamicIndex>::type type;
+  using type = typename cleanup_index_type<T, DynamicIndex>::type;
 };
 
 }  // namespace internal
@@ -90,9 +91,7 @@
   IncrType m_incr;
 
  public:
-  constexpr auto reverse() const -> decltype(Eigen::seqN(m_first + (m_size + fix<-1>()) * m_incr, m_size, -m_incr)) {
-    return seqN(m_first + (m_size + fix<-1>()) * m_incr, m_size, -m_incr);
-  }
+  constexpr auto reverse() const { return seqN(m_first + (m_size + fix<-1>()) * m_incr, m_size, -m_incr); }
 };
 
 /** \returns an ArithmeticSequence starting at \a first, of length \a size, and increment \a incr
@@ -149,24 +148,15 @@
 #else  // EIGEN_PARSED_BY_DOXYGEN
 
 template <typename FirstType, typename LastType>
-auto seq(FirstType f, LastType l)
-    -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
-                     (typename internal::cleanup_index_type<LastType>::type(l) -
-                      typename internal::cleanup_index_type<FirstType>::type(f) + fix<1>()))) {
+auto seq(FirstType f, LastType l) {
   return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
               (typename internal::cleanup_index_type<LastType>::type(l) -
                typename internal::cleanup_index_type<FirstType>::type(f) + fix<1>()));
 }
 
 template <typename FirstType, typename LastType, typename IncrType>
-auto seq(FirstType f, LastType l, IncrType incr)
-    -> decltype(seqN(typename internal::cleanup_index_type<FirstType>::type(f),
-                     (typename internal::cleanup_index_type<LastType>::type(l) -
-                      typename internal::cleanup_index_type<FirstType>::type(f) +
-                      typename internal::cleanup_seq_incr<IncrType>::type(incr)) /
-                         typename internal::cleanup_seq_incr<IncrType>::type(incr),
-                     typename internal::cleanup_seq_incr<IncrType>::type(incr))) {
-  typedef typename internal::cleanup_seq_incr<IncrType>::type CleanedIncrType;
+auto seq(FirstType f, LastType l, IncrType incr) {
+  using CleanedIncrType = typename internal::cleanup_seq_incr<IncrType>::type;
   return seqN(typename internal::cleanup_index_type<FirstType>::type(f),
               (typename internal::cleanup_index_type<LastType>::type(l) -
                typename internal::cleanup_index_type<FirstType>::type(f) + CleanedIncrType(incr)) /
@@ -178,26 +168,23 @@
 
 namespace placeholders {
 
-/** \cpp11
- * \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr.
+/** \returns a symbolic ArithmeticSequence representing the last \a size elements with increment \a incr.
  *
  * It is a shortcut for: \code seqN(last-(size-fix<1>)*incr, size, incr) \endcode
  * \anchor Eigen_placeholders_lastN
  * \sa lastN(SizeType), seqN(FirstType,SizeType), seq(FirstType,LastType,IncrType) */
 template <typename SizeType, typename IncrType>
-auto lastN(SizeType size, IncrType incr)
-    -> decltype(seqN(Eigen::placeholders::last - (size - fix<1>()) * incr, size, incr)) {
+auto lastN(SizeType size, IncrType incr) {
   return seqN(Eigen::placeholders::last - (size - fix<1>()) * incr, size, incr);
 }
 
-/** \cpp11
- * \returns a symbolic ArithmeticSequence representing the last \a size elements with a unit increment.
+/** \returns a symbolic ArithmeticSequence representing the last \a size elements with a unit increment.
  *
  *  It is a shortcut for: \code seq(last+fix<1>-size, last) \endcode
  *
- * \sa lastN(SizeType,IncrType, seqN(FirstType,SizeType), seq(FirstType,LastType) */
+ * \sa lastN(SizeType,IncrType), seqN(FirstType,SizeType), seq(FirstType,LastType) */
 template <typename SizeType>
-auto lastN(SizeType size) -> decltype(seqN(Eigen::placeholders::last + fix<1>() - size, size)) {
+auto lastN(SizeType size) {
   return seqN(Eigen::placeholders::last + fix<1>() - size, size);
 }
 
@@ -220,7 +207,7 @@
   using Eigen::seqN;
   using Eigen::placeholders::all;
   using Eigen::placeholders::last;
-  using Eigen::placeholders::lastN;  // c++11 only
+  using Eigen::placeholders::lastN;
   using Eigen::placeholders::lastp1;
   \endcode
   */
diff --git a/Eigen/src/Core/Array.h b/Eigen/src/Core/Array.h
index b6b4637..9ed22e3 100644
--- a/Eigen/src/Core/Array.h
+++ b/Eigen/src/Core/Array.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARRAY_H
 #define EIGEN_ARRAY_H
@@ -16,11 +17,17 @@
 namespace Eigen {
 
 namespace internal {
+// Preserve Array's scalar-conversion gate for non-dense expressions such as permutations.
+template <typename Scalar, typename OtherDerived>
+using is_valid_array_conversion = std::conditional_t<std::is_base_of<DenseBase<OtherDerived>, OtherDerived>::value,
+                                                     is_valid_dense_conversion<Scalar, OtherDerived>,
+                                                     std::is_convertible<typename OtherDerived::Scalar, Scalar>>;
+
 template <typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
 struct traits<Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>>
     : traits<Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>> {
-  typedef ArrayXpr XprKind;
-  typedef ArrayBase<Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>> XprBase;
+  using XprKind = ArrayXpr;
+  using XprBase = ArrayBase<Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>>;
 };
 }  // namespace internal
 
@@ -47,11 +54,11 @@
 template <typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
 class Array : public PlainObjectBase<Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>> {
  public:
-  typedef PlainObjectBase<Array> Base;
+  using Base = PlainObjectBase<Array>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Array)
 
   enum { Options = Options_ };
-  typedef typename Base::PlainObject PlainObject;
+  using PlainObject = typename Base::PlainObject;
 
  protected:
   template <typename Derived, typename OtherDerived, bool IsVector>
@@ -64,30 +71,6 @@
   using Base::coeff;
   using Base::coeffRef;
 
-  /**
-   * The usage of
-   *   using Base::operator=;
-   * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
-   * the usage of 'using'. This should be done only for operator=.
-   */
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived>& other) {
-    return Base::operator=(other);
-  }
-
-  /** Set all the entries to \a value.
-   * \sa DenseBase::setConstant(), DenseBase::fill()
-   */
-  /* This overload is needed because the usage of
-   *   using Base::operator=;
-   * fails on MSVC. Since the code below is working with GCC and MSVC, we skipped
-   * the usage of 'using'. This should be done only for operator=.
-   */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const Scalar& value) {
-    Base::setConstant(value);
-    return *this;
-  }
-
   /** Copies the value of the expression \a other into \c *this with automatic resizing.
    *
    * *this might be resized to match the dimensions of \a other. If *this was a null matrix (not already initialized),
@@ -102,6 +85,14 @@
     return Base::_set(other);
   }
 
+  /** Set all the entries to \a value.
+   * \sa DenseBase::setConstant(), DenseBase::fill()
+   */
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const Scalar& value) {
+    Base::setConstant(value);
+    return *this;
+  }
+
   /**
    * \brief Assigns arrays to each other.
    *
@@ -110,15 +101,14 @@
    *
    * \callgraph
    */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const Array& other) { return Base::_set(other); }
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Array& operator=(const Array& other) { return Base::_set(other); }
 
   /** Default constructor.
    *
    * For fixed-size matrices, does nothing.
    *
    * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
-   * is called a null matrix. This constructor is the unique way to create null matrices: resizing
-   * a matrix to 0 is not supported.
+   * is called a null matrix. An existing matrix can also be turned into a null matrix by resizing it to 0.
    *
    * \sa resize(Index,Index)
    */
@@ -129,12 +119,12 @@
 #endif
   /** \brief Move constructor */
   EIGEN_DEVICE_FUNC constexpr Array(Array&&) = default;
-  EIGEN_DEVICE_FUNC Array& operator=(Array&& other) noexcept(std::is_nothrow_move_assignable<Scalar>::value) {
-    Base::operator=(std::move(other));
+  EIGEN_DEVICE_FUNC constexpr Array& operator=(Array&& other) noexcept(std::is_nothrow_move_assignable<Scalar>::value) {
+    this->m_storage = std::move(other.m_storage);
     return *this;
   }
 
-  /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients.
+  /** \brief Construct a row or column vector with fixed size from an arbitrary number of coefficients.
    *
    * \only_for_vectors
    *
@@ -144,8 +134,8 @@
    * constructor must match the fixed number of rows (resp. columns) of \c *this.
    *
    *
-   * Example: \include Array_variadic_ctor_cxx11.cpp
-   * Output: \verbinclude Array_variadic_ctor_cxx11.out
+   * Example: \include Array_variadic_ctor.cpp
+   * Output: \verbinclude Array_variadic_ctor.out
    *
    * \sa Array(const std::initializer_list<std::initializer_list<Scalar>>&)
    * \sa Array(const Scalar&), Array(const Scalar&,const Scalar&)
@@ -156,12 +146,11 @@
       : Base(a0, a1, a2, a3, args...) {}
 
   /** \brief Constructs an array and initializes it from the coefficients given as initializer-lists grouped by row.
-   * \cpp11
    *
    * In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
    *
-   * Example: \include Array_initializer_list_23_cxx11.cpp
-   * Output: \verbinclude Array_initializer_list_23_cxx11.out
+   * Example: \include Array_initializer_list_23.cpp
+   * Output: \verbinclude Array_initializer_list_23.out
    *
    * Each of the inner initializer lists must contain the exact same number of elements, otherwise an assertion is
    * triggered.
@@ -170,8 +159,8 @@
    * Therefore <code> Array<int,Dynamic,1>{{1,2,3,4,5}}</code> is legal and the more verbose syntax
    * <code>Array<int,Dynamic,1>{{1},{2},{3},{4},{5}}</code> can be avoided:
    *
-   * Example: \include Array_initializer_list_vector_cxx11.cpp
-   * Output: \verbinclude Array_initializer_list_vector_cxx11.out
+   * Example: \include Array_initializer_list_vector.cpp
+   * Output: \verbinclude Array_initializer_list_vector.out
    *
    * In the case of fixed-sized arrays, the initializer list sizes must exactly match the array sizes,
    * and implicit transposition is allowed for compile-time 1D arrays only.
@@ -202,7 +191,7 @@
    */
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit Array(Index dim);
   /** constructs an initialized 1x1 Array with the given coefficient
-   * \sa const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args */
+   * \sa Array(const Scalar& a0, const Scalar& a1, const Scalar& a2, const Scalar& a3, const ArgTypes&... args) */
   Array(const Scalar& value);
   /** constructs an uninitialized array with \a rows rows and \a cols columns.
    *
@@ -243,13 +232,20 @@
   struct PrivateType {};
 
  public:
-  /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
+  /** Constructs an array from an expression with compatible scalar types.
+   * Use \c .cast<NewScalar>() to convert between scalar types.
+   * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
+   */
+  template <typename OtherDerived,
+            std::enable_if_t<internal::is_valid_array_conversion<Scalar, OtherDerived>::value, int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived>& other) : Base(other.derived()) {}
+
   template <typename OtherDerived>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only second argument.")
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Array(
       const EigenBase<OtherDerived>& other,
-      std::enable_if_t<internal::is_convertible<typename OtherDerived::Scalar, Scalar>::value, PrivateType> =
-          PrivateType())
-      : Base(other.derived()) {}
+      std::enable_if_t<internal::is_valid_array_conversion<Scalar, OtherDerived>::value, PrivateType>)
+      : Array(other) {}
 
   EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept { return 1; }
   EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return this->innerSize(); }
@@ -257,6 +253,15 @@
 #ifdef EIGEN_ARRAY_PLUGIN
 #include EIGEN_ARRAY_PLUGIN
 #endif
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived>& other) {
+    return Base::operator=(other);
+  }
+
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Array& operator=(const ReturnByValue<OtherDerived>& func) {
+    return Base::operator=(func);
+  }
 
  private:
   template <typename MatrixType, typename OtherDerived, bool SwapPointers>
@@ -280,7 +285,7 @@
  * There are also \c ArraySizeType which are self-explanatory. For example, \c Array4cf is
  * a fixed-size 1D array of 4 complex floats.
  *
- * With \cpp11, template alias are also defined for common sizes.
+ * Template alias are also defined for common sizes.
  * They follow the same pattern as above except that the scalar type suffix is replaced by a
  * template parameter, i.e.:
  *   - `ArrayRowsCols<Type>` where `Rows` and `Cols` can be \c 2,\c 3,\c 4, or \c X for fixed or dynamic size.
@@ -322,21 +327,17 @@
 
 #define EIGEN_MAKE_ARRAY_TYPEDEFS(Size, SizeSuffix)              \
   /** \ingroup arraytypedefs */                                  \
-  /** \brief \cpp11 */                                           \
   template <typename Type>                                       \
   using Array##SizeSuffix##SizeSuffix = Array<Type, Size, Size>; \
   /** \ingroup arraytypedefs */                                  \
-  /** \brief \cpp11 */                                           \
   template <typename Type>                                       \
   using Array##SizeSuffix = Array<Type, Size, 1>;
 
 #define EIGEN_MAKE_ARRAY_FIXED_TYPEDEFS(Size)        \
   /** \ingroup arraytypedefs */                      \
-  /** \brief \cpp11 */                               \
   template <typename Type>                           \
   using Array##Size##X = Array<Type, Size, Dynamic>; \
   /** \ingroup arraytypedefs */                      \
-  /** \brief \cpp11 */                               \
   template <typename Type>                           \
   using Array##X##Size = Array<Type, Dynamic, Size>;
 
diff --git a/Eigen/src/Core/ArrayBase.h b/Eigen/src/Core/ArrayBase.h
index dacc239..afff9c7 100644
--- a/Eigen/src/Core/ArrayBase.h
+++ b/Eigen/src/Core/ArrayBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARRAYBASE_H
 #define EIGEN_ARRAYBASE_H
@@ -45,16 +46,16 @@
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   /** The base class for a given storage type. */
-  typedef ArrayBase StorageBaseType;
+  using StorageBaseType = ArrayBase;
 
-  typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
+  using Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl = ArrayBase;
 
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
-  typedef DenseBase<Derived> Base;
+  using Base = DenseBase<Derived>;
   using Base::ColsAtCompileTime;
   using Base::Flags;
   using Base::IsVectorAtCompileTime;
@@ -79,12 +80,12 @@
   using Base::operator*=;
   using Base::operator/=;
 
-  typedef typename Base::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename Base::CoeffReturnType;
 
-  typedef typename Base::PlainObject PlainObject;
+  using PlainObject = typename Base::PlainObject;
 
   /** \internal Represents a matrix with all coefficients equal to one another*/
-  typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> ConstantReturnType;
+  using ConstantReturnType = CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>;
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
diff --git a/Eigen/src/Core/ArrayWrapper.h b/Eigen/src/Core/ArrayWrapper.h
index fb05ab5..76e2b3e 100644
--- a/Eigen/src/Core/ArrayWrapper.h
+++ b/Eigen/src/Core/ArrayWrapper.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARRAYWRAPPER_H
 #define EIGEN_ARRAYWRAPPER_H
@@ -29,7 +30,7 @@
 namespace internal {
 template <typename ExpressionType>
 struct traits<ArrayWrapper<ExpressionType> > : public traits<remove_all_t<typename ExpressionType::Nested> > {
-  typedef ArrayXpr XprKind;
+  using XprKind = ArrayXpr;
   // Let's remove NestByRefBit
   enum {
     Flags0 = traits<remove_all_t<typename ExpressionType::Nested> >::Flags,
@@ -42,15 +43,15 @@
 template <typename ExpressionType>
 class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> > {
  public:
-  typedef ArrayBase<ArrayWrapper> Base;
+  using Base = ArrayBase<ArrayWrapper>;
   EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper)
-  typedef internal::remove_all_t<ExpressionType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<ExpressionType>;
 
-  typedef std::conditional_t<internal::is_lvalue<ExpressionType>::value, Scalar, const Scalar>
-      ScalarWithConstIfNotLvalue;
+  using ScalarWithConstIfNotLvalue =
+      std::conditional_t<internal::is_lvalue<ExpressionType>::value, Scalar, const Scalar>;
 
-  typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+  using NestedExpressionType = typename internal::ref_selector<ExpressionType>::non_const_type;
 
   using Base::coeffRef;
 
@@ -105,7 +106,7 @@
 namespace internal {
 template <typename ExpressionType>
 struct traits<MatrixWrapper<ExpressionType> > : public traits<remove_all_t<typename ExpressionType::Nested> > {
-  typedef MatrixXpr XprKind;
+  using XprKind = MatrixXpr;
   // Let's remove NestByRefBit
   enum {
     Flags0 = traits<remove_all_t<typename ExpressionType::Nested> >::Flags,
@@ -118,15 +119,15 @@
 template <typename ExpressionType>
 class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> > {
  public:
-  typedef MatrixBase<MatrixWrapper<ExpressionType> > Base;
+  using Base = MatrixBase<MatrixWrapper<ExpressionType>>;
   EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper)
-  typedef internal::remove_all_t<ExpressionType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<ExpressionType>;
 
-  typedef std::conditional_t<internal::is_lvalue<ExpressionType>::value, Scalar, const Scalar>
-      ScalarWithConstIfNotLvalue;
+  using ScalarWithConstIfNotLvalue =
+      std::conditional_t<internal::is_lvalue<ExpressionType>::value, Scalar, const Scalar>;
 
-  typedef typename internal::ref_selector<ExpressionType>::non_const_type NestedExpressionType;
+  using NestedExpressionType = typename internal::ref_selector<ExpressionType>::non_const_type;
 
   using Base::coeffRef;
 
diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h
index 3d30d86..baec68b 100644
--- a/Eigen/src/Core/Assign.h
+++ b/Eigen/src/Core/Assign.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ASSIGN_H
 #define EIGEN_ASSIGN_H
@@ -21,7 +22,7 @@
 template <typename OtherDerived>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::lazyAssign(
     const DenseBase<OtherDerived>& other) {
-  enum { SameType = internal::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value };
+  enum { SameType = std::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value };
 
   EIGEN_STATIC_ASSERT_LVALUE(Derived)
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived, OtherDerived)
diff --git a/Eigen/src/Core/AssignEvaluator.h b/Eigen/src/Core/AssignEvaluator.h
index abaa429..0008a94 100644
--- a/Eigen/src/Core/AssignEvaluator.h
+++ b/Eigen/src/Core/AssignEvaluator.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ASSIGN_EVALUATOR_H
 #define EIGEN_ASSIGN_EVALUATOR_H
@@ -61,14 +62,29 @@
                                                                          : MaxRowsAtCompileTime;
   static constexpr int RestrictedInnerSize = min_size_prefer_fixed(MaxInnerSizeAtCompileTime, MaxPacketSize);
   static constexpr int RestrictedLinearSize = min_size_prefer_fixed(MaxSizeAtCompileTime, MaxPacketSize);
-  static constexpr int OuterStride = outer_stride_at_compile_time<Dst>::ret;
+  static constexpr int OuterStride = outer_stride_at_compile_time<Dst>::value;
 
-  // TODO: distinguish between linear traversal and inner-traversal packet types.
-  using LinearPacketType = typename find_best_packet<DstScalar, RestrictedLinearSize>::type;
+  // LinearVectorizedTraversal handles a partial-packet tail (scalar emits under
+  // complete unrolling, packet_segment under no-unrolling), so we can prefer a
+  // wider packet than find_best_packet's exact-divisor pick when that strictly
+  // reduces total op count -- e.g. N=9 float on AVX2 gets 1*Packet8f + 1 scalar
+  // instead of 2*Packet4f + 1 scalar. find_assign_linear_packet stays on the
+  // exact-divisor choice when the wider alternative is no better
+  // (e.g. N=6 double on AVX-512: 3*Packet2d ties with 1*Packet4d + 2 scalars,
+  // so Packet2d is kept and LLT/LDLT sub-vector kernels are not disturbed).
+  // InnerVectorizedTraversal still requires Size % PacketSize == 0, so its
+  // packet type continues to use find_best_packet.
+  using LinearPacketType = typename find_assign_linear_packet<DstScalar, RestrictedLinearSize>::type;
   using InnerPacketType = typename find_best_packet<DstScalar, RestrictedInnerSize>::type;
 
   static constexpr int LinearPacketSize = unpacket_traits<LinearPacketType>::size;
   static constexpr int InnerPacketSize = unpacket_traits<InnerPacketType>::size;
+  // Use the exact-divisor packet size for the Inner-vs-Linear choice below, so
+  // find_assign_linear_packet's widening only changes the packet *within*
+  // LinearVectorizedTraversal and never flips an inner-vectorizable assignment
+  // onto the linear path (e.g. vectorization_logic Matrix57 on NEON int).
+  static constexpr int LinearTraversalPacketSize =
+      unpacket_traits<typename find_best_packet<DstScalar, RestrictedLinearSize>::type>::size;
 
  public:
   static constexpr int LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment;
@@ -78,10 +94,12 @@
   static constexpr bool StorageOrdersAgree = DstIsRowMajor == SrcIsRowMajor;
   static constexpr bool MightVectorize = StorageOrdersAgree && bool(DstFlags & SrcFlags & ActualPacketAccessBit) &&
                                          bool(functor_traits<AssignFunc>::PacketAccess);
-  static constexpr bool MayInnerVectorize = MightVectorize && (InnerSizeAtCompileTime != Dynamic) &&
-                                            (InnerSizeAtCompileTime % InnerPacketSize == 0) &&
-                                            (OuterStride != Dynamic) && (OuterStride % InnerPacketSize == 0) &&
-                                            (EIGEN_UNALIGNED_VECTORIZE || JointAlignment >= InnerRequiredAlignment);
+  // Generic packet assignment stores forward from coeffRef(); the swap kernel uses writePacket().
+  static constexpr bool MayInnerVectorize =
+      MightVectorize && (DstHasDirectAccess || std::is_same<AssignFunc, swap_assign_op<DstScalar>>::value) &&
+      (InnerSizeAtCompileTime != Dynamic) && (InnerSizeAtCompileTime % InnerPacketSize == 0) &&
+      (OuterStride != Dynamic) && (OuterStride % InnerPacketSize == 0) &&
+      (EIGEN_UNALIGNED_VECTORIZE || JointAlignment >= InnerRequiredAlignment);
   static constexpr bool MayLinearize = StorageOrdersAgree && (DstFlags & SrcFlags & LinearAccessBit);
   static constexpr bool MayLinearVectorize =
       MightVectorize && MayLinearize && DstHasDirectAccess &&
@@ -100,7 +118,7 @@
 
  public:
   static constexpr int Traversal = SizeAtCompileTime == 0 ? AllAtOnceTraversal
-                                   : (MayLinearVectorize && (LinearPacketSize > InnerPacketSize))
+                                   : (MayLinearVectorize && (LinearTraversalPacketSize > InnerPacketSize))
                                        ? LinearVectorizedTraversal
                                    : MayInnerVectorize  ? InnerVectorizedTraversal
                                    : MayLinearVectorize ? LinearVectorizedTraversal
@@ -116,12 +134,14 @@
   static constexpr int ActualPacketSize = Vectorized ? unpacket_traits<PacketType>::size : 1;
   static constexpr int UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize;
   static constexpr int CoeffReadCost = int(DstEvaluator::CoeffReadCost) + int(SrcEvaluator::CoeffReadCost);
-  static constexpr bool MayUnrollCompletely =
-      (SizeAtCompileTime != Dynamic) && (SizeAtCompileTime * CoeffReadCost <= UnrollingLimit);
   static constexpr bool MayUnrollInner =
       (InnerSizeAtCompileTime != Dynamic) && (InnerSizeAtCompileTime * CoeffReadCost <= UnrollingLimit);
 
  public:
+  // True when the whole assignment is a fixed-size kernel cheap enough to emit as straight-line
+  // code. Selects CompleteUnrolling, and gates the scalar tail in the SliceVectorized loop below.
+  static constexpr bool MayUnrollCompletely =
+      (SizeAtCompileTime != Dynamic) && (SizeAtCompileTime * CoeffReadCost <= UnrollingLimit);
   static constexpr int Unrolling =
       (Traversal == InnerVectorizedTraversal || Traversal == DefaultTraversal)
           ? (MayUnrollCompletely ? CompleteUnrolling
@@ -189,31 +209,33 @@
 
 template <typename Kernel, int Index_, int Stop>
 struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling {
-  static constexpr int Outer = Index_ / Kernel::AssignmentTraits::InnerSizeAtCompileTime;
-  static constexpr int Inner = Index_ % Kernel::AssignmentTraits::InnerSizeAtCompileTime;
+  template <int... Offsets>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run_impl(Kernel& kernel,
+                                                                       std::integer_sequence<int, Offsets...>) {
+    int unused[] = {
+        0, (kernel.assignCoeffByOuterInner((Index_ + Offsets) / Kernel::AssignmentTraits::InnerSizeAtCompileTime,
+                                           (Index_ + Offsets) % Kernel::AssignmentTraits::InnerSizeAtCompileTime),
+            0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel) {
-    kernel.assignCoeffByOuterInner(Outer, Inner);
-    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index_ + 1, Stop>::run(kernel);
+    run_impl(kernel, std::make_integer_sequence<int, Stop - Index_>{});
   }
 };
 
-template <typename Kernel, int Stop>
-struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop, Stop> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel&) {}
-};
-
 template <typename Kernel, int Index_, int Stop>
 struct copy_using_evaluator_DefaultTraversal_InnerUnrolling {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel, Index outer) {
-    kernel.assignCoeffByOuterInner(outer, Index_);
-    copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Index_ + 1, Stop>::run(kernel, outer);
+  template <int... Offsets>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run_impl(Kernel& kernel, Index outer,
+                                                                       std::integer_sequence<int, Offsets...>) {
+    int unused[] = {0, (kernel.assignCoeffByOuterInner(outer, Index_ + Offsets), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
-};
 
-template <typename Kernel, int Stop>
-struct copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, Stop, Stop> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel&, Index) {}
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel, Index outer) {
+    run_impl(kernel, outer, std::make_integer_sequence<int, Stop - Index_>{});
+  }
 };
 
 /***********************
@@ -222,15 +244,16 @@
 
 template <typename Kernel, int Index_, int Stop>
 struct copy_using_evaluator_LinearTraversal_CompleteUnrolling {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel) {
-    kernel.assignCoeff(Index_);
-    copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Index_ + 1, Stop>::run(kernel);
+  template <int... Offsets>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run_impl(Kernel& kernel,
+                                                                       std::integer_sequence<int, Offsets...>) {
+    int unused[] = {0, (kernel.assignCoeff(Index_ + Offsets), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
-};
 
-template <typename Kernel, int Stop>
-struct copy_using_evaluator_LinearTraversal_CompleteUnrolling<Kernel, Stop, Stop> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel&) {}
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel) {
+    run_impl(kernel, std::make_integer_sequence<int, Stop - Index_>{});
+  }
 };
 
 /**************************
@@ -240,40 +263,46 @@
 template <typename Kernel, int Index_, int Stop>
 struct copy_using_evaluator_innervec_CompleteUnrolling {
   using PacketType = typename Kernel::PacketType;
-  static constexpr int Outer = Index_ / Kernel::AssignmentTraits::InnerSizeAtCompileTime;
-  static constexpr int Inner = Index_ % Kernel::AssignmentTraits::InnerSizeAtCompileTime;
-  static constexpr int NextIndex = Index_ + unpacket_traits<PacketType>::size;
+  static constexpr int PacketSize = unpacket_traits<PacketType>::size;
   static constexpr int SrcAlignment = Kernel::AssignmentTraits::SrcAlignment;
   static constexpr int DstAlignment = Kernel::AssignmentTraits::DstAlignment;
+  static_assert((Stop - Index_) % PacketSize == 0, "Packet unrolling range must be divisible by packet size.");
+
+  template <int... Offsets>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run_impl(Kernel& kernel, std::integer_sequence<int, Offsets...>) {
+    int unused[] = {0, (kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(
+                            (Index_ + Offsets * PacketSize) / Kernel::AssignmentTraits::InnerSizeAtCompileTime,
+                            (Index_ + Offsets * PacketSize) % Kernel::AssignmentTraits::InnerSizeAtCompileTime),
+                        0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel) {
-    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(Outer, Inner);
-    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
+    run_impl(kernel, std::make_integer_sequence<int, (Stop - Index_) / PacketSize>{});
   }
 };
 
-template <typename Kernel, int Stop>
-struct copy_using_evaluator_innervec_CompleteUnrolling<Kernel, Stop, Stop> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel&) {}
-};
-
 template <typename Kernel, int Index_, int Stop, int SrcAlignment, int DstAlignment>
 struct copy_using_evaluator_innervec_InnerUnrolling {
   using PacketType = typename Kernel::PacketType;
-  static constexpr int NextIndex = Index_ + unpacket_traits<PacketType>::size;
+  static constexpr int PacketSize = unpacket_traits<PacketType>::size;
+  static_assert((Stop - Index_) % PacketSize == 0, "Packet unrolling range must be divisible by packet size.");
+
+  template <int... Offsets>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run_impl(Kernel& kernel, Index outer,
+                                                             std::integer_sequence<int, Offsets...>) {
+    int unused[] = {0, (kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(
+                            outer, Index_ + Offsets * PacketSize),
+                        0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+    EIGEN_UNUSED_VARIABLE(outer);
+  }
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel, Index outer) {
-    kernel.template assignPacketByOuterInner<DstAlignment, SrcAlignment, PacketType>(outer, Index_);
-    copy_using_evaluator_innervec_InnerUnrolling<Kernel, NextIndex, Stop, SrcAlignment, DstAlignment>::run(kernel,
-                                                                                                           outer);
+    run_impl(kernel, outer, std::make_integer_sequence<int, (Stop - Index_) / PacketSize>{});
   }
 };
 
-template <typename Kernel, int Stop, int SrcAlignment, int DstAlignment>
-struct copy_using_evaluator_innervec_InnerUnrolling<Kernel, Stop, Stop, SrcAlignment, DstAlignment> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel&, Index) {}
-};
-
 template <typename Kernel, int Start, int Stop, int SrcAlignment, int DstAlignment, bool UsePacketSegment>
 struct copy_using_evaluator_innervec_segment {
   using PacketType = typename Kernel::PacketType;
@@ -426,21 +455,23 @@
 template <typename Kernel, int Index_, int Stop>
 struct copy_using_evaluator_linearvec_CompleteUnrolling {
   using PacketType = typename Kernel::PacketType;
+  static constexpr int PacketSize = unpacket_traits<PacketType>::size;
   static constexpr int SrcAlignment = Kernel::AssignmentTraits::SrcAlignment;
   static constexpr int DstAlignment = Kernel::AssignmentTraits::DstAlignment;
-  static constexpr int NextIndex = Index_ + unpacket_traits<PacketType>::size;
+  static_assert((Stop - Index_) % PacketSize == 0, "Packet unrolling range must be divisible by packet size.");
+
+  template <int... Offsets>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run_impl(Kernel& kernel, std::integer_sequence<int, Offsets...>) {
+    int unused[] = {
+        0, (kernel.template assignPacket<DstAlignment, SrcAlignment, PacketType>(Index_ + Offsets * PacketSize), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel& kernel) {
-    kernel.template assignPacket<DstAlignment, SrcAlignment, PacketType>(Index_);
-    copy_using_evaluator_linearvec_CompleteUnrolling<Kernel, NextIndex, Stop>::run(kernel);
+    run_impl(kernel, std::make_integer_sequence<int, (Stop - Index_) / PacketSize>{});
   }
 };
 
-template <typename Kernel, int Stop>
-struct copy_using_evaluator_linearvec_CompleteUnrolling<Kernel, Stop, Stop> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel&) {}
-};
-
 template <typename Kernel, int Index_, int Stop, bool UsePacketSegment>
 struct copy_using_evaluator_linearvec_segment {
   using PacketType = typename Kernel::PacketType;
@@ -474,8 +505,8 @@
   static constexpr int SrcAlignment = Kernel::AssignmentTraits::JointAlignment;
   static constexpr int DstAlignment = plain_enum_max(Kernel::AssignmentTraits::DstAlignment, alignof(Scalar));
   static constexpr int RequestedAlignment = unpacket_traits<PacketType>::alignment;
-  static constexpr bool Alignable =
-      (DstAlignment >= RequestedAlignment) || ((RequestedAlignment - DstAlignment) % sizeof(Scalar) == 0);
+  static constexpr bool Alignable = (DstAlignment >= RequestedAlignment) ||
+                                    (static_cast<std::size_t>(RequestedAlignment - DstAlignment) % sizeof(Scalar) == 0);
   static constexpr int Alignment = Alignable ? RequestedAlignment : DstAlignment;
   static constexpr bool DstIsAligned = DstAlignment >= Alignment;
   static constexpr bool UsePacketSegment = Kernel::AssignmentTraits::UsePacketSegment;
@@ -487,13 +518,14 @@
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel) {
     const Index size = kernel.size();
     const Index alignedStart = DstIsAligned ? 0 : first_aligned<Alignment>(kernel.dstDataPtr(), size);
-    const Index alignedEnd = alignedStart + numext::round_down(size - alignedStart, PacketSize);
 
     head_loop::run(kernel, 0, alignedStart);
 
-    for (Index index = alignedStart; index < alignedEnd; index += PacketSize)
+    for (Index index = alignedStart; index <= size - PacketSize; index += PacketSize)
       kernel.template assignPacket<Alignment, SrcAlignment, PacketType>(index);
 
+    // Derive the tail bound directly; GCC can lose its range when it comes from the packet-loop induction variable.
+    const Index alignedEnd = size - (size - alignedStart) % PacketSize;
     tail_loop::run(kernel, alignedEnd, size);
   }
 };
@@ -504,11 +536,19 @@
   static constexpr int PacketSize = unpacket_traits<PacketType>::size;
   static constexpr int Size = Kernel::AssignmentTraits::SizeAtCompileTime;
   static constexpr int AlignedSize = numext::round_down(Size, PacketSize);
-  static constexpr bool UsePacketSegment = Kernel::AssignmentTraits::UsePacketSegment;
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel) {
     copy_using_evaluator_linearvec_CompleteUnrolling<Kernel, 0, AlignedSize>::run(kernel);
-    copy_using_evaluator_linearvec_segment<Kernel, AlignedSize, Size, UsePacketSegment>::run(kernel);
+    // Partial-packet tail. Unlike the NoUnrolling case above, here the size is a
+    // compile-time constant and the loop is fully unrolled, so the tail is a
+    // fixed handful (fewer than PacketSize) of scalar assignments. Emit those
+    // directly by forcing UsePacketSegment = false: a masked packet segment
+    // buys nothing when there is no runtime-variable trip count to collapse,
+    // and on the AVX backend it lowers to a masked store (vmaskmovps/vmaskmovpd)
+    // that is slow on current hardware and forwards poorly to later loads. The
+    // NoUnrolling loop keeps UsePacketSegment because there the tail length is a
+    // runtime value, where a single masked op does beat a scalar remainder loop.
+    copy_using_evaluator_linearvec_segment<Kernel, AlignedSize, Size, /*UsePacketSegment=*/false>::run(kernel);
   }
 };
 
@@ -587,8 +627,8 @@
   static constexpr int SrcAlignment = Kernel::AssignmentTraits::JointAlignment;
   static constexpr int DstAlignment = plain_enum_max(Kernel::AssignmentTraits::DstAlignment, alignof(Scalar));
   static constexpr int RequestedAlignment = unpacket_traits<PacketType>::alignment;
-  static constexpr bool Alignable =
-      (DstAlignment >= RequestedAlignment) || ((RequestedAlignment - DstAlignment) % sizeof(Scalar) == 0);
+  static constexpr bool Alignable = (DstAlignment >= RequestedAlignment) ||
+                                    (static_cast<std::size_t>(RequestedAlignment - DstAlignment) % sizeof(Scalar) == 0);
   static constexpr int Alignment = Alignable ? RequestedAlignment : DstAlignment;
   static constexpr bool DstIsAligned = DstAlignment >= Alignment;
   static constexpr bool UsePacketSegment = Kernel::AssignmentTraits::UsePacketSegment;
@@ -596,6 +636,41 @@
   using head_loop = unaligned_dense_assignment_loop<PacketType, DstAlignment, Unaligned, UsePacketSegment, !Alignable>;
   using tail_loop = unaligned_dense_assignment_loop<PacketType, Alignment, Unaligned, UsePacketSegment, false>;
 
+  // All inner slices share one alignment offset: the loop bounds are outer-invariant and stay
+  // hoisted out of the outer loop. Keeping that loop free of per-slice bookkeeping is what makes
+  // slice vectorization competitive with compiler-vectorized scalar code when slices are short.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void runInvariant(Kernel& kernel, Index alignedStart,
+                                                                           Index innerSize, Index outerSize) {
+    const Index alignedEnd = alignedStart + numext::round_down(innerSize - alignedStart, PacketSize);
+    for (Index outer = 0; outer < outerSize; ++outer) {
+      head_loop::run(kernel, outer, 0, alignedStart);
+
+      // do the vectorizable part of the assignment
+      for (Index inner = alignedStart; inner < alignedEnd; inner += PacketSize)
+        kernel.template assignPacketByOuterInner<Alignment, Unaligned, PacketType>(outer, inner);
+
+      tail_loop::run(kernel, outer, alignedEnd, innerSize);
+    }
+  }
+
+#if EIGEN_UNALIGNED_VECTORIZE
+  // The slice alignment offset varies from one outer index to the next. Unaligned stores with
+  // outer-invariant bounds beat chasing the aligned position of every slice.
+  using unaligned_tail_loop =
+      unaligned_dense_assignment_loop<PacketType, Unaligned, Unaligned, UsePacketSegment, false>;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void runUnaligned(Kernel& kernel, Index innerSize,
+                                                                           Index outerSize) {
+    const Index packetEnd = numext::round_down(innerSize, PacketSize);
+    for (Index outer = 0; outer < outerSize; ++outer) {
+      for (Index inner = 0; inner < packetEnd; inner += PacketSize)
+        kernel.template assignPacketByOuterInner<Unaligned, Unaligned, PacketType>(outer, inner);
+
+      unaligned_tail_loop::run(kernel, outer, packetEnd, innerSize);
+    }
+  }
+#endif
+
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr void run(Kernel& kernel) {
     const Scalar* dst_ptr = kernel.dstDataPtr();
     const Index innerSize = kernel.innerSize();
@@ -603,6 +678,13 @@
     const Index alignedStep = Alignable ? (PacketSize - kernel.outerStride() % PacketSize) % PacketSize : 0;
     Index alignedStart = ((!Alignable) || DstIsAligned) ? 0 : internal::first_aligned<Alignment>(dst_ptr, innerSize);
 
+    if (alignedStep == 0) {
+      runInvariant(kernel, alignedStart, innerSize, outerSize);
+      return;
+    }
+#if EIGEN_UNALIGNED_VECTORIZE
+    runUnaligned(kernel, innerSize, outerSize);
+#else
     for (Index outer = 0; outer < outerSize; ++outer) {
       const Index alignedEnd = alignedStart + numext::round_down(innerSize - alignedStart, PacketSize);
 
@@ -616,6 +698,7 @@
 
       alignedStart = numext::mini((alignedStart + alignedStep) % PacketSize, innerSize);
     }
+#endif
   }
 };
 
@@ -626,7 +709,14 @@
   static constexpr int PacketSize = unpacket_traits<PacketType>::size;
   static constexpr int InnerSize = Kernel::AssignmentTraits::InnerSizeAtCompileTime;
   static constexpr int VectorizableSize = numext::round_down(InnerSize, PacketSize);
-  static constexpr bool UsePacketSegment = Kernel::AssignmentTraits::UsePacketSegment;
+
+  // The tail length is a compile-time constant here, so it can be emitted as a masked packet
+  // segment or as scalars. Scalars win for the same fixed-size kernels LinearVectorizedTraversal
+  // already emits them for: their destination is a temporary the enclosing expression reloads by
+  // packet, and on AVX a masked store forwards poorly to those loads. Everything else keeps the
+  // segment, where one packet evaluation replaces up to PacketSize - 1 scalar ones.
+  static constexpr bool UsePacketSegment =
+      Kernel::AssignmentTraits::UsePacketSegment && !Kernel::AssignmentTraits::MayUnrollCompletely;
 
   using packet_loop = copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, VectorizableSize, Unaligned, Unaligned>;
   using packet_segment_loop = copy_using_evaluator_innervec_segment<Kernel, VectorizableSize, InnerSize, Unaligned,
@@ -654,15 +744,15 @@
 template <typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version = Specialized>
 class generic_dense_assignment_kernel {
  protected:
-  typedef typename DstEvaluatorTypeT::XprType DstXprType;
-  typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
+  using DstXprType = typename DstEvaluatorTypeT::XprType;
+  using SrcXprType = typename SrcEvaluatorTypeT::XprType;
 
  public:
-  typedef DstEvaluatorTypeT DstEvaluatorType;
-  typedef SrcEvaluatorTypeT SrcEvaluatorType;
-  typedef typename DstEvaluatorType::Scalar Scalar;
-  typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor> AssignmentTraits;
-  typedef typename AssignmentTraits::PacketType PacketType;
+  using DstEvaluatorType = DstEvaluatorTypeT;
+  using SrcEvaluatorType = SrcEvaluatorTypeT;
+  using Scalar = typename DstEvaluatorType::Scalar;
+  using AssignmentTraits = copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor>;
+  using PacketType = typename AssignmentTraits::PacketType;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr generic_dense_assignment_kernel(DstEvaluatorType& dst,
                                                                                   const SrcEvaluatorType& src,
@@ -741,7 +831,7 @@
   }
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr Index rowIndexByOuterInner(Index outer, Index inner) {
-    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    using Traits = typename DstEvaluatorType::ExpressionTraits;
     return int(Traits::RowsAtCompileTime) == 1          ? 0
            : int(Traits::ColsAtCompileTime) == 1        ? inner
            : int(DstEvaluatorType::Flags) & RowMajorBit ? outer
@@ -749,7 +839,7 @@
   }
 
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE constexpr Index colIndexByOuterInner(Index outer, Index inner) {
-    typedef typename DstEvaluatorType::ExpressionTraits Traits;
+    using Traits = typename DstEvaluatorType::ExpressionTraits;
     return int(Traits::ColsAtCompileTime) == 1          ? 0
            : int(Traits::RowsAtCompileTime) == 1        ? inner
            : int(DstEvaluatorType::Flags) & RowMajorBit ? inner
@@ -774,13 +864,13 @@
 class restricted_packet_dense_assignment_kernel
     : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn> {
  protected:
-  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn> Base;
+  using Base = generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, BuiltIn>;
 
  public:
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::DstXprType DstXprType;
-  typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, 4> AssignmentTraits;
-  typedef typename AssignmentTraits::PacketType PacketType;
+  using Scalar = typename Base::Scalar;
+  using DstXprType = typename Base::DstXprType;
+  using AssignmentTraits = copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, 4>;
+  using PacketType = typename AssignmentTraits::PacketType;
 
   EIGEN_DEVICE_FUNC restricted_packet_dense_assignment_kernel(DstEvaluatorTypeT& dst, const SrcEvaluatorTypeT& src,
                                                               const Functor& func, DstXprType& dstExpr)
@@ -823,8 +913,8 @@
 template <typename DstXprType, typename SrcXprType, typename Functor>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src,
                                                                                 const Functor& func) {
-  typedef evaluator<DstXprType> DstEvaluatorType;
-  typedef evaluator<SrcXprType> SrcEvaluatorType;
+  using DstEvaluatorType = evaluator<DstXprType>;
+  using SrcEvaluatorType = evaluator<SrcXprType>;
 
   SrcEvaluatorType srcEvaluator(src);
 
@@ -834,7 +924,7 @@
 
   DstEvaluatorType dstEvaluator(dst);
 
-  typedef generic_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType, Functor> Kernel;
+  using Kernel = generic_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType, Functor>;
   Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
 
   dense_assignment_loop<Kernel>::run(kernel);
@@ -861,11 +951,11 @@
 
 template <typename, typename>
 struct AssignmentKind {
-  typedef EigenBase2EigenBase Kind;
+  using Kind = EigenBase2EigenBase;
 };
 template <>
 struct AssignmentKind<DenseShape, DenseShape> {
-  typedef Dense2Dense Kind;
+  using Kind = Dense2Dense;
 };
 
 // This is the main assignment class
@@ -890,16 +980,14 @@
 }
 
 // Deal with "assume-aliasing"
-template <typename Dst, typename Src, typename Func>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void call_assignment(
-    Dst& dst, const Src& src, const Func& func, std::enable_if_t<evaluator_assume_aliasing<Src>::value, void*> = 0) {
+template <typename Dst, typename Src, typename Func, std::enable_if_t<evaluator_assume_aliasing<Src>::value, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void call_assignment(Dst& dst, const Src& src, const Func& func) {
   typename plain_matrix_type<Src>::type tmp(src);
   call_assignment_no_alias(dst, tmp, func);
 }
 
-template <typename Dst, typename Src, typename Func>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void call_assignment(
-    Dst& dst, const Src& src, const Func& func, std::enable_if_t<!evaluator_assume_aliasing<Src>::value, void*> = 0) {
+template <typename Dst, typename Src, typename Func, std::enable_if_t<!evaluator_assume_aliasing<Src>::value, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr void call_assignment(Dst& dst, const Src& src, const Func& func) {
   call_assignment_no_alias(dst, src, func);
 }
 
@@ -920,14 +1008,14 @@
                       int(Dst::SizeAtCompileTime) != 1
   };
 
-  typedef std::conditional_t<NeedToTranspose, Transpose<Dst>, Dst> ActualDstTypeCleaned;
-  typedef std::conditional_t<NeedToTranspose, Transpose<Dst>, Dst&> ActualDstType;
+  using ActualDstTypeCleaned = std::conditional_t<NeedToTranspose, Transpose<Dst>, Dst>;
+  using ActualDstType = std::conditional_t<NeedToTranspose, Transpose<Dst>, Dst&>;
   ActualDstType actualDst(dst);
 
   // TODO: check whether this is the right place to perform these checks:
   EIGEN_STATIC_ASSERT_LVALUE(Dst)
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned, Src)
-  EIGEN_CHECK_BINARY_COMPATIBILIY(Func, typename ActualDstTypeCleaned::Scalar, typename Src::Scalar);
+  EIGEN_CHECK_BINARY_COMPATIBILITY(Func, typename ActualDstTypeCleaned::Scalar, typename Src::Scalar);
 
   Assignment<ActualDstTypeCleaned, Src, Func>::run(actualDst, src, func);
 }
@@ -935,12 +1023,12 @@
 template <typename Dst, typename Src, typename Func>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_restricted_packet_assignment_no_alias(Dst& dst, const Src& src,
                                                                                       const Func& func) {
-  typedef evaluator<Dst> DstEvaluatorType;
-  typedef evaluator<Src> SrcEvaluatorType;
-  typedef restricted_packet_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType, Func> Kernel;
+  using DstEvaluatorType = evaluator<Dst>;
+  using SrcEvaluatorType = evaluator<Src>;
+  using Kernel = restricted_packet_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType, Func>;
 
   EIGEN_STATIC_ASSERT_LVALUE(Dst)
-  EIGEN_CHECK_BINARY_COMPATIBILIY(Func, typename Dst::Scalar, typename Src::Scalar);
+  EIGEN_CHECK_BINARY_COMPATIBILITY(Func, typename Dst::Scalar, typename Src::Scalar);
 
   SrcEvaluatorType srcEvaluator(src);
   resize_if_allowed(dst, src, func);
@@ -962,7 +1050,7 @@
   // TODO: check whether this is the right place to perform these checks:
   EIGEN_STATIC_ASSERT_LVALUE(Dst)
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst, Src)
-  EIGEN_CHECK_BINARY_COMPATIBILIY(Func, typename Dst::Scalar, typename Src::Scalar);
+  EIGEN_CHECK_BINARY_COMPATIBILITY(Func, typename Dst::Scalar, typename Src::Scalar);
 
   Assignment<Dst, Src, Func>::run(dst, src, func);
 }
diff --git a/Eigen/src/Core/Assign_AOCL.h b/Eigen/src/Core/Assign_AOCL.h
index da3ef7c..5350e93 100644
--- a/Eigen/src/Core/Assign_AOCL.h
+++ b/Eigen/src/Core/Assign_AOCL.h
@@ -40,10 +40,10 @@
  * Supported Operations:
  * ---------------------
  * UNARY OPERATIONS (vector → vector):
- * - Transcendental: exp(), sin(), cos(), sqrt(), log(), log10(), log2()
+ * - exp(), exp2(), sin(), cos(), sqrt(), cbrt(), abs(), log(), log10(), log2()
  *
  * BINARY OPERATIONS (vector op vector → vector):
- * - Arithmetic: +, *, pow()
+ * - +, pow(), max(), min()
  *
  * Template Specialization Mechanism:
  * -----------------------------------
@@ -110,7 +110,7 @@
  * Email: shbhaska@amd.com
  * Organization: Advanced Micro Devices, Inc.
  */
-
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ASSIGN_AOCL_H
 #define EIGEN_ASSIGN_AOCL_H
@@ -119,8 +119,9 @@
 namespace internal {
 
 // Traits for unary operations.
-template <typename Dst, typename Src> class aocl_assign_traits {
-private:
+template <typename Dst, typename Src>
+class aocl_assign_traits {
+ private:
   enum {
     DstHasDirectAccess = !!(Dst::Flags & DirectAccessBit),
     SrcHasDirectAccess = !!(Src::Flags & DirectAccessBit),
@@ -128,14 +129,12 @@
     InnerSize = Dst::IsVectorAtCompileTime   ? int(Dst::SizeAtCompileTime)
                 : (Dst::Flags & RowMajorBit) ? int(Dst::ColsAtCompileTime)
                                              : int(Dst::RowsAtCompileTime),
-    LargeEnough =
-        (InnerSize == Dynamic) || (InnerSize >= EIGEN_AOCL_VML_THRESHOLD)
+    LargeEnough = (InnerSize == Dynamic) || (InnerSize >= EIGEN_AOCL_VML_THRESHOLD)
   };
 
-public:
+ public:
   enum {
-    EnableAoclVML = DstHasDirectAccess && SrcHasDirectAccess &&
-                    StorageOrdersAgree && LargeEnough,
+    EnableAoclVML = DstHasDirectAccess && SrcHasDirectAccess && StorageOrdersAgree && LargeEnough,
     Traversal = LinearTraversal
   };
 };
@@ -143,75 +142,59 @@
 // Traits for binary operations (e.g., add, pow).
 template <typename Dst, typename Lhs, typename Rhs>
 class aocl_assign_binary_traits {
-private:
+ private:
   enum {
     DstHasDirectAccess = !!(Dst::Flags & DirectAccessBit),
     LhsHasDirectAccess = !!(Lhs::Flags & DirectAccessBit),
     RhsHasDirectAccess = !!(Rhs::Flags & DirectAccessBit),
-    StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Lhs::IsRowMajor)) &&
-                         (int(Dst::IsRowMajor) == int(Rhs::IsRowMajor)),
+    StorageOrdersAgree =
+        (int(Dst::IsRowMajor) == int(Lhs::IsRowMajor)) && (int(Dst::IsRowMajor) == int(Rhs::IsRowMajor)),
     InnerSize = Dst::IsVectorAtCompileTime   ? int(Dst::SizeAtCompileTime)
                 : (Dst::Flags & RowMajorBit) ? int(Dst::ColsAtCompileTime)
                                              : int(Dst::RowsAtCompileTime),
-    LargeEnough =
-        (InnerSize == Dynamic) || (InnerSize >= EIGEN_AOCL_VML_THRESHOLD)
+    LargeEnough = (InnerSize == Dynamic) || (InnerSize >= EIGEN_AOCL_VML_THRESHOLD)
   };
 
-public:
+ public:
   enum {
-    EnableAoclVML = DstHasDirectAccess && LhsHasDirectAccess &&
-                    RhsHasDirectAccess && StorageOrdersAgree && LargeEnough
+    EnableAoclVML = DstHasDirectAccess && LhsHasDirectAccess && RhsHasDirectAccess && StorageOrdersAgree && LargeEnough
   };
 };
 
 // Unary operation dispatch for float (scalar fallback).
-#define EIGEN_AOCL_VML_UNARY_CALL_FLOAT(EIGENOP)                               \
-  template <typename DstXprType, typename SrcXprNested>                        \
-  struct Assignment<                                                           \
-      DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<float>, SrcXprNested>,    \
-      assign_op<float, float>, Dense2Dense,                                    \
-      std::enable_if_t<                                                        \
-          aocl_assign_traits<DstXprType, SrcXprNested>::EnableAoclVML>> {      \
-    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<float>, SrcXprNested>           \
-        SrcXprType;                                                            \
-    static void run(DstXprType &dst, const SrcXprType &src,                    \
-                    const assign_op<float, float> &) {                         \
-      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());      \
-      Eigen::Index n = dst.size();                                             \
-      if (n <= 0)                                                              \
-        return;                                                                \
-      const float *input =                                                     \
-          reinterpret_cast<const float *>(src.nestedExpression().data());      \
-      float *output = reinterpret_cast<float *>(dst.data());                   \
-      for (Eigen::Index i = 0; i < n; ++i) {                                   \
-        output[i] = std::EIGENOP(input[i]);                                    \
-      }                                                                        \
-    }                                                                          \
+#define EIGEN_AOCL_VML_UNARY_CALL_FLOAT(EIGENOP)                                                                   \
+  template <typename DstXprType, typename SrcXprNested>                                                            \
+  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<float>, SrcXprNested>, assign_op<float, float>, \
+                    Dense2Dense, std::enable_if_t<aocl_assign_traits<DstXprType, SrcXprNested>::EnableAoclVML>> {  \
+    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<float>, SrcXprNested> SrcXprType;                                   \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<float, float> &) {                     \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                          \
+      Eigen::Index n = dst.size();                                                                                 \
+      if (n <= 0) return;                                                                                          \
+      const float *input = reinterpret_cast<const float *>(src.nestedExpression().data());                         \
+      float *output = reinterpret_cast<float *>(dst.data());                                                       \
+      for (Eigen::Index i = 0; i < n; ++i) {                                                                       \
+        output[i] = std::EIGENOP(input[i]);                                                                        \
+      }                                                                                                            \
+    }                                                                                                              \
   };
 
 // Unary operation dispatch for double (AOCL vectorized).
-#define EIGEN_AOCL_VML_UNARY_CALL_DOUBLE(EIGENOP, AOCLOP)                      \
-  template <typename DstXprType, typename SrcXprNested>                        \
-  struct Assignment<                                                           \
-      DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<double>, SrcXprNested>,   \
-      assign_op<double, double>, Dense2Dense,                                  \
-      std::enable_if_t<                                                        \
-          aocl_assign_traits<DstXprType, SrcXprNested>::EnableAoclVML>> {      \
-    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<double>, SrcXprNested>          \
-        SrcXprType;                                                            \
-    static void run(DstXprType &dst, const SrcXprType &src,                    \
-                    const assign_op<double, double> &) {                       \
-      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());      \
-      Eigen::Index n = dst.size();                                             \
-      eigen_assert(n <= INT_MAX && "AOCL does not support arrays larger than INT_MAX"); \
-      if (n <= 0)                                                              \
-        return;                                                                \
-      const double *input =                                                    \
-          reinterpret_cast<const double *>(src.nestedExpression().data());     \
-      double *output = reinterpret_cast<double *>(dst.data());                 \
-      int aocl_n = internal::convert_index<int>(n);                            \
-      AOCLOP(aocl_n, const_cast<double *>(input), output);                     \
-    }                                                                          \
+#define EIGEN_AOCL_VML_UNARY_CALL_DOUBLE(EIGENOP, AOCLOP)                                                             \
+  template <typename DstXprType, typename SrcXprNested>                                                               \
+  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<double>, SrcXprNested>, assign_op<double, double>, \
+                    Dense2Dense, std::enable_if_t<aocl_assign_traits<DstXprType, SrcXprNested>::EnableAoclVML>> {     \
+    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<double>, SrcXprNested> SrcXprType;                                     \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<double, double> &) {                      \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                             \
+      Eigen::Index n = dst.size();                                                                                    \
+      eigen_assert(n <= INT_MAX && "AOCL does not support arrays larger than INT_MAX");                               \
+      if (n <= 0) return;                                                                                             \
+      const double *input = reinterpret_cast<const double *>(src.nestedExpression().data());                          \
+      double *output = reinterpret_cast<double *>(dst.data());                                                        \
+      int aocl_n = internal::convert_index<int>(n);                                                                   \
+      AOCLOP(aocl_n, const_cast<double *>(input), output);                                                            \
+    }                                                                                                                 \
   };
 
 // Instantiate unary calls for float (scalar).
@@ -230,72 +213,58 @@
 EIGEN_AOCL_VML_UNARY_CALL_DOUBLE(log2, amd_vrda_log2)
 
 // Binary operation dispatch for float (scalar fallback).
-#define EIGEN_AOCL_VML_BINARY_CALL_FLOAT(EIGENOP, STDFUNC)                     \
-  template <typename DstXprType, typename LhsXprNested, typename RhsXprNested> \
-  struct Assignment<                                                           \
-      DstXprType,                                                              \
-      CwiseBinaryOp<scalar_##EIGENOP##_op<float, float>, LhsXprNested,         \
-                    RhsXprNested>,                                             \
-      assign_op<float, float>, Dense2Dense,                                    \
-      std::enable_if_t<aocl_assign_binary_traits<                              \
-          DstXprType, LhsXprNested, RhsXprNested>::EnableAoclVML>> {           \
-    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<float, float>, LhsXprNested,   \
-                          RhsXprNested>                                        \
-        SrcXprType;                                                            \
-    static void run(DstXprType &dst, const SrcXprType &src,                    \
-                    const assign_op<float, float> &) {                         \
-      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());      \
-      Eigen::Index n = dst.size();                                             \
-      if (n <= 0)                                                              \
-        return;                                                                \
-      const float *lhs = reinterpret_cast<const float *>(src.lhs().data());    \
-      const float *rhs = reinterpret_cast<const float *>(src.rhs().data());    \
-      float *output = reinterpret_cast<float *>(dst.data());                   \
-      for (Eigen::Index i = 0; i < n; ++i) {                                   \
-        output[i] = STDFUNC(lhs[i], rhs[i]);                                   \
-      }                                                                        \
-    }                                                                          \
+#define EIGEN_AOCL_VML_BINARY_CALL_FLOAT(EIGENOP, STDFUNC)                                                  \
+  template <typename DstXprType, typename LhsXprNested, typename RhsXprNested>                              \
+  struct Assignment<                                                                                        \
+      DstXprType, CwiseBinaryOp<scalar_##EIGENOP##_op<float, float>, LhsXprNested, RhsXprNested>,           \
+      assign_op<float, float>, Dense2Dense,                                                                 \
+      std::enable_if_t<aocl_assign_binary_traits<DstXprType, LhsXprNested, RhsXprNested>::EnableAoclVML>> { \
+    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<float, float>, LhsXprNested, RhsXprNested> SrcXprType;      \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<float, float> &) {              \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                   \
+      Eigen::Index n = dst.size();                                                                          \
+      if (n <= 0) return;                                                                                   \
+      const float *lhs = reinterpret_cast<const float *>(src.lhs().data());                                 \
+      const float *rhs = reinterpret_cast<const float *>(src.rhs().data());                                 \
+      float *output = reinterpret_cast<float *>(dst.data());                                                \
+      for (Eigen::Index i = 0; i < n; ++i) {                                                                \
+        output[i] = STDFUNC(lhs[i], rhs[i]);                                                                \
+      }                                                                                                     \
+    }                                                                                                       \
   };
 
 // Binary operation dispatch for double (AOCL vectorized).
-#define EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(EIGENOP, AOCLOP)                     \
-  template <typename DstXprType, typename LhsXprNested, typename RhsXprNested> \
-  struct Assignment<                                                           \
-      DstXprType,                                                              \
-      CwiseBinaryOp<scalar_##EIGENOP##_op<double, double>, LhsXprNested,       \
-                    RhsXprNested>,                                             \
-      assign_op<double, double>, Dense2Dense,                                  \
-      std::enable_if_t<aocl_assign_binary_traits<                              \
-          DstXprType, LhsXprNested, RhsXprNested>::EnableAoclVML>> {           \
-    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<double, double>, LhsXprNested, \
-                          RhsXprNested>                                        \
-        SrcXprType;                                                            \
-    static void run(DstXprType &dst, const SrcXprType &src,                    \
-                    const assign_op<double, double> &) {                       \
-      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());      \
-      Eigen::Index n = dst.size();                                             \
-      eigen_assert(n <= INT_MAX && "AOCL does not support arrays larger than INT_MAX"); \
-      if (n <= 0)                                                              \
-        return;                                                                \
-      const double *lhs = reinterpret_cast<const double *>(src.lhs().data());  \
-      const double *rhs = reinterpret_cast<const double *>(src.rhs().data());  \
-      double *output = reinterpret_cast<double *>(dst.data());                 \
-      int aocl_n = internal::convert_index<int>(n);                            \
-      AOCLOP(aocl_n, const_cast<double *>(lhs), const_cast<double *>(rhs), output); \
-    }                                                                          \
+#define EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(EIGENOP, AOCLOP)                                                  \
+  template <typename DstXprType, typename LhsXprNested, typename RhsXprNested>                              \
+  struct Assignment<                                                                                        \
+      DstXprType, CwiseBinaryOp<scalar_##EIGENOP##_op<double, double>, LhsXprNested, RhsXprNested>,         \
+      assign_op<double, double>, Dense2Dense,                                                               \
+      std::enable_if_t<aocl_assign_binary_traits<DstXprType, LhsXprNested, RhsXprNested>::EnableAoclVML>> { \
+    typedef CwiseBinaryOp<scalar_##EIGENOP##_op<double, double>, LhsXprNested, RhsXprNested> SrcXprType;    \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<double, double> &) {            \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                   \
+      Eigen::Index n = dst.size();                                                                          \
+      eigen_assert(n <= INT_MAX && "AOCL does not support arrays larger than INT_MAX");                     \
+      if (n <= 0) return;                                                                                   \
+      const double *lhs = reinterpret_cast<const double *>(src.lhs().data());                               \
+      const double *rhs = reinterpret_cast<const double *>(src.rhs().data());                               \
+      double *output = reinterpret_cast<double *>(dst.data());                                              \
+      int aocl_n = internal::convert_index<int>(n);                                                         \
+      AOCLOP(aocl_n, const_cast<double *>(lhs), const_cast<double *>(rhs), output);                         \
+    }                                                                                                       \
   };
 
 // Instantiate binary calls for float (scalar).
-// EIGEN_AOCL_VML_BINARY_CALL_FLOAT(sum, std::plus<float>)  // Using
-// scalar_sum_op for addition EIGEN_AOCL_VML_BINARY_CALL_FLOAT(pow, std::pow)
+// EIGEN_AOCL_VML_BINARY_CALL_FLOAT(sum, std::plus<float>)  // Using scalar_sum_op for addition
+// EIGEN_AOCL_VML_BINARY_CALL_FLOAT(pow, std::pow)
 
 // Instantiate binary calls for double (AOCL vectorized).
-EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(sum, amd_vrda_add) // Using scalar_sum_op for addition
+EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(sum, amd_vrda_add)  // Using scalar_sum_op for addition
 EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(pow, amd_vrda_pow)
 EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(max, amd_vrda_fmax)
 EIGEN_AOCL_VML_BINARY_CALL_DOUBLE(min, amd_vrda_fmin)
 
-} // namespace internal
-} // namespace Eigen
+}  // namespace internal
+}  // namespace Eigen
 
-#endif // EIGEN_ASSIGN_AOCL_H
+#endif  // EIGEN_ASSIGN_AOCL_H
diff --git a/Eigen/src/Core/Assign_MKL.h b/Eigen/src/Core/Assign_MKL.h
index 7636445..652beb5 100644
--- a/Eigen/src/Core/Assign_MKL.h
+++ b/Eigen/src/Core/Assign_MKL.h
@@ -30,6 +30,7 @@
  *   MKL VML support for coefficient-wise unary Eigen expressions like a=b.sin()
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_ASSIGN_VML_H
 #define EIGEN_ASSIGN_VML_H
@@ -48,9 +49,6 @@
     DstHasDirectAccess = Dst::Flags & DirectAccessBit,
     SrcHasDirectAccess = Src::Flags & DirectAccessBit,
     StorageOrdersAgree = (int(Dst::IsRowMajor) == int(Src::IsRowMajor)),
-    InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
-                : int(Dst::Flags) & RowMajorBit ? int(Dst::ColsAtCompileTime)
-                                                : int(Dst::RowsAtCompileTime),
     InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
                    : int(Dst::Flags) & RowMajorBit ? int(Dst::MaxColsAtCompileTime)
                                                    : int(Dst::MaxRowsAtCompileTime),
@@ -80,29 +78,29 @@
 #define EIGEN_VMLMODE_PREFIX_x_ v
 #define EIGEN_VMLMODE_PREFIX(VMLMODE) EIGEN_CAT(EIGEN_VMLMODE_PREFIX_x, VMLMODE)
 
-#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                      \
-  template <typename DstXprType, typename SrcXprNested>                                                    \
-  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested>,              \
-                    assign_op<EIGENTYPE, EIGENTYPE>, Dense2Dense,                                          \
-                    std::enable_if_t<vml_assign_traits<DstXprType, SrcXprNested>::EnableVml>> {            \
-    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested> SrcXprType;                       \
-    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE, EIGENTYPE> &func) { \
-      resize_if_allowed(dst, src, func);                                                                   \
-      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                  \
-      if (vml_assign_traits<DstXprType, SrcXprNested>::Traversal == (int)LinearTraversal) {                \
-        VMLOP(dst.size(), (const VMLTYPE *)src.nestedExpression().data(),                                  \
-              (VMLTYPE *)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                     \
-      } else {                                                                                             \
-        const Index outerSize = dst.outerSize();                                                           \
-        for (Index outer = 0; outer < outerSize; ++outer) {                                                \
-          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer, 0))         \
-                                                    : &(src.nestedExpression().coeffRef(0, outer));        \
-          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer, 0)) : &(dst.coeffRef(0, outer));     \
-          VMLOP(dst.innerSize(), (const VMLTYPE *)src_ptr,                                                 \
-                (VMLTYPE *)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                      \
-        }                                                                                                  \
-      }                                                                                                    \
-    }                                                                                                      \
+#define EIGEN_MKL_VML_DECLARE_UNARY_CALL(EIGENOP, VMLOP, EIGENTYPE, VMLTYPE, VMLMODE)                       \
+  template <typename DstXprType, typename SrcXprNested>                                                     \
+  struct Assignment<DstXprType, CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested>,               \
+                    assign_op<EIGENTYPE, EIGENTYPE>, Dense2Dense,                                           \
+                    std::enable_if_t<vml_assign_traits<DstXprType, SrcXprNested>::EnableVml>> {             \
+    typedef CwiseUnaryOp<scalar_##EIGENOP##_op<EIGENTYPE>, SrcXprNested> SrcXprType;                        \
+    static void run(DstXprType &dst, const SrcXprType &src, const assign_op<EIGENTYPE, EIGENTYPE> &func) {  \
+      resize_if_allowed(dst, src, func);                                                                    \
+      eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                   \
+      EIGEN_IF_CONSTEXPR (vml_assign_traits<DstXprType, SrcXprNested>::Traversal == (int)LinearTraversal) { \
+        VMLOP(dst.size(), (const VMLTYPE *)src.nestedExpression().data(),                                   \
+              (VMLTYPE *)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                      \
+      } else {                                                                                              \
+        const Index outerSize = dst.outerSize();                                                            \
+        for (Index outer = 0; outer < outerSize; ++outer) {                                                 \
+          const EIGENTYPE *src_ptr = src.IsRowMajor ? &(src.nestedExpression().coeffRef(outer, 0))          \
+                                                    : &(src.nestedExpression().coeffRef(0, outer));         \
+          EIGENTYPE *dst_ptr = dst.IsRowMajor ? &(dst.coeffRef(outer, 0)) : &(dst.coeffRef(0, outer));      \
+          VMLOP(dst.innerSize(), (const VMLTYPE *)src_ptr,                                                  \
+                (VMLTYPE *)dst_ptr EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                       \
+        }                                                                                                   \
+      }                                                                                                     \
+    }                                                                                                       \
   };
 
 #define EIGEN_MKL_VML_DECLARE_UNARY_CALLS_REAL(EIGENOP, VMLOP, VMLMODE)                                                \
@@ -155,7 +153,7 @@
       resize_if_allowed(dst, src, func);                                                                   \
       eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());                                  \
       VMLTYPE exponent = reinterpret_cast<const VMLTYPE &>(src.rhs().functor().m_other);                   \
-      if (vml_assign_traits<DstXprType, SrcXprNested>::Traversal == LinearTraversal) {                     \
+      EIGEN_IF_CONSTEXPR (vml_assign_traits<DstXprType, SrcXprNested>::Traversal == LinearTraversal) {     \
         VMLOP(dst.size(), (const VMLTYPE *)src.lhs().data(), exponent,                                     \
               (VMLTYPE *)dst.data() EIGEN_PP_EXPAND(EIGEN_VMLMODE_EXPAND_x##VMLMODE));                     \
       } else {                                                                                             \
diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h
index 57b0322..77bf0f2 100644
--- a/Eigen/src/Core/BandMatrix.h
+++ b/Eigen/src/Core/BandMatrix.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BANDMATRIX_H
 #define EIGEN_BANDMATRIX_H
@@ -31,11 +32,11 @@
     Subs = internal::traits<Derived>::Subs,
     Options = internal::traits<Derived>::Options
   };
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> DenseMatrixType;
-  typedef typename DenseMatrixType::StorageIndex StorageIndex;
-  typedef typename internal::traits<Derived>::CoefficientsType CoefficientsType;
-  typedef EigenBase<Derived> Base;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using DenseMatrixType = Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime>;
+  using StorageIndex = typename DenseMatrixType::StorageIndex;
+  using CoefficientsType = typename internal::traits<Derived>::CoefficientsType;
+  using Base = EigenBase<Derived>;
 
  protected:
   enum {
@@ -98,9 +99,9 @@
               : (ActualIndex < 0 ? min_size_prefer_dynamic(ColsAtCompileTime, RowsAtCompileTime + ActualIndex)
                                  : min_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime - ActualIndex))
     };
-    typedef Block<CoefficientsType, 1, DiagonalSize> BuildType;
-    typedef std::conditional_t<Conjugate, CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, BuildType>, BuildType>
-        Type;
+    using BuildType = Block<CoefficientsType, 1, DiagonalSize>;
+    using Type =
+        std::conditional_t<Conjugate, CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, BuildType>, BuildType>;
   };
 
   /** \returns a vector expression of the \a N -th sub or super diagonal */
@@ -170,9 +171,9 @@
 
 template <typename Scalar_, int Rows_, int Cols_, int Supers_, int Subs_, int Options_>
 struct traits<BandMatrix<Scalar_, Rows_, Cols_, Supers_, Subs_, Options_> > {
-  typedef Scalar_ Scalar;
-  typedef Dense StorageKind;
-  typedef Eigen::Index StorageIndex;
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using StorageIndex = Eigen::Index;
   enum {
     CoeffReadCost = NumTraits<Scalar>::ReadCost,
     RowsAtCompileTime = Rows_,
@@ -185,24 +186,24 @@
     Options = Options_,
     DataRowsAtCompileTime = ((Supers != Dynamic) && (Subs != Dynamic)) ? 1 + Supers + Subs : Dynamic
   };
-  typedef Matrix<Scalar, DataRowsAtCompileTime, ColsAtCompileTime, int(Options) & int(RowMajor) ? RowMajor : ColMajor>
-      CoefficientsType;
+  using CoefficientsType =
+      Matrix<Scalar, DataRowsAtCompileTime, ColsAtCompileTime, int(Options) & int(RowMajor) ? RowMajor : ColMajor>;
 };
 
 template <typename Scalar_, int Rows, int Cols, int Supers, int Subs, int Options>
 class BandMatrix : public BandMatrixBase<BandMatrix<Scalar_, Rows, Cols, Supers, Subs, Options> > {
  public:
-  typedef typename internal::traits<BandMatrix>::Scalar Scalar;
-  typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
-  typedef typename internal::traits<BandMatrix>::CoefficientsType CoefficientsType;
+  using Scalar = typename internal::traits<BandMatrix>::Scalar;
+  using StorageIndex = typename internal::traits<BandMatrix>::StorageIndex;
+  using CoefficientsType = typename internal::traits<BandMatrix>::CoefficientsType;
 
   explicit inline BandMatrix(Index rows = Rows, Index cols = Cols, Index supers = Supers, Index subs = Subs)
       : m_coeffs(1 + supers + subs, cols), m_rows(rows), m_supers(supers), m_subs(subs) {}
 
-  /** \returns the number of columns */
+  /** \returns the number of rows */
   constexpr Index rows() const { return m_rows.value(); }
 
-  /** \returns the number of rows */
+  /** \returns the number of columns */
   constexpr Index cols() const { return m_coeffs.cols(); }
 
   /** \returns the number of super diagonals */
@@ -226,9 +227,9 @@
 
 template <typename CoefficientsType_, int Rows_, int Cols_, int Supers_, int Subs_, int Options_>
 struct traits<BandMatrixWrapper<CoefficientsType_, Rows_, Cols_, Supers_, Subs_, Options_> > {
-  typedef typename CoefficientsType_::Scalar Scalar;
-  typedef typename CoefficientsType_::StorageKind StorageKind;
-  typedef typename CoefficientsType_::StorageIndex StorageIndex;
+  using Scalar = typename CoefficientsType_::Scalar;
+  using StorageKind = typename CoefficientsType_::StorageKind;
+  using StorageIndex = typename CoefficientsType_::StorageIndex;
   enum {
     CoeffReadCost = internal::traits<CoefficientsType_>::CoeffReadCost,
     RowsAtCompileTime = Rows_,
@@ -241,16 +242,16 @@
     Options = Options_,
     DataRowsAtCompileTime = ((Supers != Dynamic) && (Subs != Dynamic)) ? 1 + Supers + Subs : Dynamic
   };
-  typedef CoefficientsType_ CoefficientsType;
+  using CoefficientsType = CoefficientsType_;
 };
 
 template <typename CoefficientsType_, int Rows_, int Cols_, int Supers_, int Subs_, int Options_>
 class BandMatrixWrapper
     : public BandMatrixBase<BandMatrixWrapper<CoefficientsType_, Rows_, Cols_, Supers_, Subs_, Options_> > {
  public:
-  typedef typename internal::traits<BandMatrixWrapper>::Scalar Scalar;
-  typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType CoefficientsType;
-  typedef typename internal::traits<BandMatrixWrapper>::StorageIndex StorageIndex;
+  using Scalar = typename internal::traits<BandMatrixWrapper>::Scalar;
+  using CoefficientsType = typename internal::traits<BandMatrixWrapper>::CoefficientsType;
+  using StorageIndex = typename internal::traits<BandMatrixWrapper>::StorageIndex;
 
   explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows = Rows_, Index cols = Cols_,
                                     Index supers = Supers_, Index subs = Subs_)
@@ -259,10 +260,10 @@
     // eigen_assert(coeffs.cols()==cols() && (supers()+subs()+1)==coeffs.rows());
   }
 
-  /** \returns the number of columns */
+  /** \returns the number of rows */
   constexpr Index rows() const { return m_rows.value(); }
 
-  /** \returns the number of rows */
+  /** \returns the number of columns */
   constexpr Index cols() const { return m_coeffs.cols(); }
 
   /** \returns the number of super diagonals */
@@ -294,8 +295,8 @@
  */
 template <typename Scalar, int Size, int Options>
 class TridiagonalMatrix : public BandMatrix<Scalar, Size, Size, Options & SelfAdjoint ? 0 : 1, 1, Options | RowMajor> {
-  typedef BandMatrix<Scalar, Size, Size, Options & SelfAdjoint ? 0 : 1, 1, Options | RowMajor> Base;
-  typedef typename Base::StorageIndex StorageIndex;
+  using Base = BandMatrix<Scalar, Size, Size, Options & SelfAdjoint ? 0 : 1, 1, Options | RowMajor>;
+  using StorageIndex = typename Base::StorageIndex;
 
  public:
   explicit TridiagonalMatrix(Index size = Size) : Base(size, size, Options & SelfAdjoint ? 0 : 1, 1) {}
@@ -308,27 +309,23 @@
   inline const typename Base::template DiagonalIntReturnType<-1>::Type sub() const {
     return Base::template diagonal<-1>();
   }
-
- protected:
 };
 
-struct BandShape {};
-
 template <typename Scalar_, int Rows_, int Cols_, int Supers_, int Subs_, int Options_>
 struct evaluator_traits<BandMatrix<Scalar_, Rows_, Cols_, Supers_, Subs_, Options_> >
     : public evaluator_traits_base<BandMatrix<Scalar_, Rows_, Cols_, Supers_, Subs_, Options_> > {
-  typedef BandShape Shape;
+  using Shape = BandShape;
 };
 
 template <typename CoefficientsType_, int Rows_, int Cols_, int Supers_, int Subs_, int Options_>
 struct evaluator_traits<BandMatrixWrapper<CoefficientsType_, Rows_, Cols_, Supers_, Subs_, Options_> >
     : public evaluator_traits_base<BandMatrixWrapper<CoefficientsType_, Rows_, Cols_, Supers_, Subs_, Options_> > {
-  typedef BandShape Shape;
+  using Shape = BandShape;
 };
 
 template <>
 struct AssignmentKind<DenseShape, BandShape> {
-  typedef EigenBase2EigenBase Kind;
+  using Kind = EigenBase2EigenBase;
 };
 
 }  // end namespace internal
diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h
index c2d8bea..a160cbe 100644
--- a/Eigen/src/Core/Block.h
+++ b/Eigen/src/Core/Block.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BLOCK_H
 #define EIGEN_BLOCK_H
@@ -19,11 +20,11 @@
 namespace internal {
 template <typename XprType_, int BlockRows, int BlockCols, bool InnerPanel_>
 struct traits<Block<XprType_, BlockRows, BlockCols, InnerPanel_>> : traits<XprType_> {
-  typedef typename traits<XprType_>::Scalar Scalar;
-  typedef typename traits<XprType_>::StorageKind StorageKind;
-  typedef typename traits<XprType_>::XprKind XprKind;
-  typedef typename ref_selector<XprType_>::type XprTypeNested;
-  typedef std::remove_reference_t<XprTypeNested> XprTypeNested_;
+  using Scalar = typename traits<XprType_>::Scalar;
+  using StorageKind = typename traits<XprType_>::StorageKind;
+  using XprKind = typename traits<XprType_>::XprKind;
+  using XprTypeNested = typename ref_selector<XprType_>::type;
+  using XprTypeNested_ = std::remove_reference_t<XprTypeNested>;
   enum {
     MatrixRows = traits<XprType_>::RowsAtCompileTime,
     MatrixCols = traits<XprType_>::ColsAtCompileTime,
@@ -42,10 +43,10 @@
                                                                             : XprTypeIsRowMajor,
     HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
     InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
-    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType_>::ret)
-                                                            : int(outer_stride_at_compile_time<XprType_>::ret),
-    OuterStrideAtCompileTime = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType_>::ret)
-                                                            : int(inner_stride_at_compile_time<XprType_>::ret),
+    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType_>::value)
+                                                            : int(outer_stride_at_compile_time<XprType_>::value),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType_>::value)
+                                                            : int(inner_stride_at_compile_time<XprType_>::value),
 
     // FIXME, this traits is rather specialized for dense object and it needs to be cleaned further
     FlagsLvalueBit = is_lvalue<XprType_>::value ? LvalueBit : 0,
@@ -55,7 +56,7 @@
     // FIXME DirectAccessBit should not be handled by expressions
     //
     // Alignment is needed by MapBase's assertions
-    // We can sefely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the
+    // We can safely set it to false here. Internal alignment errors will be detected by an eigen_internal_assert in the
     // respective evaluator
     Alignment = 0,
     InnerPanel = InnerPanel_ ? 1 : 0
@@ -63,7 +64,7 @@
 };
 
 template <typename XprType, int BlockRows = Dynamic, int BlockCols = Dynamic, bool InnerPanel = false,
-          bool HasDirectAccess = internal::has_direct_access<XprType>::ret>
+          bool HasDirectAccess = internal::has_direct_access<XprType>::value>
 class BlockImpl_dense;
 
 }  // end namespace internal
@@ -108,16 +109,16 @@
 template <typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
 class Block
     : public BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> {
-  typedef BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind> Impl;
+  using Impl = BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, typename internal::traits<XprType>::StorageKind>;
   using BlockHelper = internal::block_xpr_helper<Block>;
 
  public:
   // typedef typename Impl::Base Base;
-  typedef Impl Base;
+  using Base = Impl;
   EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
 
-  typedef internal::remove_all_t<XprType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<XprType>;
 
   /** Column or Row constructor
    */
@@ -149,8 +150,9 @@
 
   // convert nested blocks (e.g. Block<Block<MatrixType>>) to a simple block expression (Block<MatrixType>)
 
-  using ConstUnwindReturnType = Block<const typename BlockHelper::BaseType, BlockRows, BlockCols, InnerPanel>;
-  using UnwindReturnType = Block<typename BlockHelper::BaseType, BlockRows, BlockCols, InnerPanel>;
+  static constexpr bool UnwoundInnerPanel = BlockHelper::is_inner_panel(true);
+  using ConstUnwindReturnType = Block<const typename BlockHelper::BaseType, BlockRows, BlockCols, UnwoundInnerPanel>;
+  using UnwindReturnType = Block<typename BlockHelper::BaseType, BlockRows, BlockCols, UnwoundInnerPanel>;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ConstUnwindReturnType unwind() const {
     return ConstUnwindReturnType(BlockHelper::base(*this), BlockHelper::row(*this, 0), BlockHelper::col(*this, 0),
@@ -169,11 +171,11 @@
 template <typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
 class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
     : public internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> {
-  typedef internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel> Impl;
-  typedef typename XprType::StorageIndex StorageIndex;
+  using Impl = internal::BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel>;
+  using StorageIndex = typename XprType::StorageIndex;
 
  public:
-  typedef Impl Base;
+  using Base = Impl;
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index i) : Impl(xpr, i) {}
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index startRow, Index startCol)
@@ -188,11 +190,11 @@
 /** \internal Internal implementation of dense Blocks in the general case. */
 template <typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess>
 class BlockImpl_dense : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel>>::type {
-  typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
-  typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  using BlockType = Block<XprType, BlockRows, BlockCols, InnerPanel>;
+  using XprTypeNested = typename internal::ref_selector<XprType>::non_const_type;
 
  public:
-  typedef typename internal::dense_xpr_base<BlockType>::type Base;
+  using Base = typename internal::dense_xpr_base<BlockType>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
 
@@ -305,8 +307,8 @@
 template <typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
 class BlockImpl_dense<XprType, BlockRows, BlockCols, InnerPanel, true>
     : public MapBase<Block<XprType, BlockRows, BlockCols, InnerPanel>> {
-  typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
-  typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  using BlockType = Block<XprType, BlockRows, BlockCols, InnerPanel>;
+  using XprTypeNested = typename internal::ref_selector<XprType>::non_const_type;
   enum { XprTypeIsRowMajor = (int(traits<XprType>::Flags) & RowMajorBit) != 0 };
 
   /** \internal Returns base+offset (unless base is null, in which case returns null).
@@ -318,7 +320,7 @@
   }
 
  public:
-  typedef MapBase<BlockType> Base;
+  using Base = MapBase<BlockType>;
   EIGEN_DENSE_PUBLIC_INTERFACE(BlockType)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl_dense)
 
@@ -391,21 +393,6 @@
 
   EIGEN_DEVICE_FUNC constexpr StorageIndex startCol() const noexcept { return m_startCol.value(); }
 
-#ifndef __SUNPRO_CC
-  // FIXME sunstudio is not friendly with the above friend...
-  // META-FIXME there is no 'friend' keyword around here. Is this obsolete?
- protected:
-#endif
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-  /** \internal used by allowAligned() */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows,
-                                                        Index blockCols)
-      : Base(data, blockRows, blockCols), m_xpr(xpr) {
-    init();
-  }
-#endif
-
  protected:
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void init() {
     m_outerStride =
diff --git a/Eigen/src/Core/CommaInitializer.h b/Eigen/src/Core/CommaInitializer.h
index 4541f47..fe67f78 100644
--- a/Eigen/src/Core/CommaInitializer.h
+++ b/Eigen/src/Core/CommaInitializer.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMMAINITIALIZER_H
 #define EIGEN_COMMAINITIALIZER_H
@@ -29,7 +30,7 @@
  */
 template <typename XprType>
 struct CommaInitializer {
-  typedef typename XprType::Scalar Scalar;
+  using Scalar = typename XprType::Scalar;
 
   EIGEN_DEVICE_FUNC constexpr CommaInitializer(XprType& xpr, const Scalar& s)
       : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1) {
diff --git a/Eigen/src/Core/ConcatOp.h b/Eigen/src/Core/ConcatOp.h
new file mode 100644
index 0000000..4ba1cc6
--- /dev/null
+++ b/Eigen/src/Core/ConcatOp.h
@@ -0,0 +1,356 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Pavel Guzenfeld
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_CONCAT_OP_H
+#define EIGEN_CONCAT_OP_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <int Direction, typename LhsType, typename RhsType>
+struct traits<Concat<Direction, LhsType, RhsType>> : traits<LhsType> {
+  using Scalar = typename LhsType::Scalar;
+  using StorageKind = typename traits<LhsType>::StorageKind;
+  using XprKind = typename traits<LhsType>::XprKind;
+  using LhsTypeNested = typename ref_selector<LhsType>::type;
+  using RhsTypeNested = typename ref_selector<RhsType>::type;
+  using LhsTypeNested_ = std::remove_reference_t<LhsTypeNested>;
+  using RhsTypeNested_ = std::remove_reference_t<RhsTypeNested>;
+  enum {
+    // For vertical concat (stacking rows): rows add up, cols must match
+    // For horizontal concat (stacking cols): cols add up, rows must match
+    LhsRows = int(LhsType::RowsAtCompileTime),
+    RhsRows = int(RhsType::RowsAtCompileTime),
+    LhsCols = int(LhsType::ColsAtCompileTime),
+    RhsCols = int(RhsType::ColsAtCompileTime),
+
+    RowsAtCompileTime = Direction == Vertical
+                            ? (LhsRows == Dynamic || RhsRows == Dynamic ? int(Dynamic) : LhsRows + RhsRows)
+                            : size_prefer_fixed(LhsRows, RhsRows),
+    ColsAtCompileTime = Direction == Horizontal
+                            ? (LhsCols == Dynamic || RhsCols == Dynamic ? int(Dynamic) : LhsCols + RhsCols)
+                            : size_prefer_fixed(LhsCols, RhsCols),
+
+    LhsMaxRows = int(LhsType::MaxRowsAtCompileTime),
+    RhsMaxRows = int(RhsType::MaxRowsAtCompileTime),
+    LhsMaxCols = int(LhsType::MaxColsAtCompileTime),
+    RhsMaxCols = int(RhsType::MaxColsAtCompileTime),
+
+    MaxRowsAtCompileTime =
+        Direction == Vertical
+            ? (LhsMaxRows == Dynamic || RhsMaxRows == Dynamic ? int(Dynamic) : LhsMaxRows + RhsMaxRows)
+            : max_size_prefer_dynamic(LhsMaxRows, RhsMaxRows),
+    MaxColsAtCompileTime =
+        Direction == Horizontal
+            ? (LhsMaxCols == Dynamic || RhsMaxCols == Dynamic ? int(Dynamic) : LhsMaxCols + RhsMaxCols)
+            : max_size_prefer_dynamic(LhsMaxCols, RhsMaxCols),
+
+    IsRowMajor = MaxRowsAtCompileTime == 1 && MaxColsAtCompileTime != 1   ? 1
+                 : MaxColsAtCompileTime == 1 && MaxRowsAtCompileTime != 1 ? 0
+                 : (int(LhsType::Flags) & RowMajorBit)                    ? 1
+                                                                          : 0,
+    Flags = IsRowMajor ? RowMajorBit : 0
+  };
+};
+
+}  // namespace internal
+
+/**
+ * \class Concat
+ * \ingroup Core_Module
+ *
+ * \brief Expression of the concatenation of two dense expressions
+ *
+ * \tparam Direction either \c Vertical or \c Horizontal
+ * \tparam LhsType the type of the left-hand side expression
+ * \tparam RhsType the type of the right-hand side expression
+ *
+ * This class represents an expression of the concatenation of two dense expressions,
+ * either vertically (stacking rows) or horizontally (stacking columns).
+ *
+ * It is the return type of hcat() and vcat() and typically this is the only way it is used.
+ *
+ * \sa hcat(), vcat()
+ */
+template <int Direction, typename LhsType, typename RhsType>
+class Concat : public internal::dense_xpr_base<Concat<Direction, LhsType, RhsType>>::type {
+  using LhsTypeNested = typename internal::traits<Concat>::LhsTypeNested;
+  using RhsTypeNested = typename internal::traits<Concat>::RhsTypeNested;
+  using LhsTypeNested_ = typename internal::traits<Concat>::LhsTypeNested_;
+  using RhsTypeNested_ = typename internal::traits<Concat>::RhsTypeNested_;
+
+ public:
+  using Base = typename internal::dense_xpr_base<Concat>::type;
+  EIGEN_DENSE_PUBLIC_INTERFACE(Concat)
+  using LhsNestedExpression = internal::remove_all_t<LhsType>;
+  using RhsNestedExpression = internal::remove_all_t<RhsType>;
+
+  template <typename OriginalLhsType, typename OriginalRhsType>
+  EIGEN_DEVICE_FUNC constexpr inline Concat(const OriginalLhsType& lhs, const OriginalRhsType& rhs)
+      : m_lhs(lhs), m_rhs(rhs) {
+    EIGEN_STATIC_ASSERT((std::is_same<std::remove_const_t<LhsType>, OriginalLhsType>::value),
+                        THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+    EIGEN_STATIC_ASSERT((std::is_same<std::remove_const_t<RhsType>, OriginalRhsType>::value),
+                        THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<typename LhsType::Scalar, typename RhsType::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    EIGEN_STATIC_ASSERT_SAME_XPR_KIND(LhsType, RhsType)
+    EIGEN_STATIC_ASSERT(Direction != Horizontal || int(LhsType::RowsAtCompileTime) == Dynamic ||
+                            int(RhsType::RowsAtCompileTime) == Dynamic ||
+                            int(LhsType::RowsAtCompileTime) == int(RhsType::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    EIGEN_STATIC_ASSERT(Direction != Vertical || int(LhsType::ColsAtCompileTime) == Dynamic ||
+                            int(RhsType::ColsAtCompileTime) == Dynamic ||
+                            int(LhsType::ColsAtCompileTime) == int(RhsType::ColsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    EIGEN_IF_CONSTEXPR (Direction == Vertical) {
+      eigen_assert(lhs.cols() == rhs.cols() && "vcat: number of columns must match");
+    } else {
+      eigen_assert(lhs.rows() == rhs.rows() && "hcat: number of rows must match");
+    }
+  }
+
+  EIGEN_DEVICE_FUNC constexpr Index rows() const {
+    return Direction == Vertical ? m_lhs.rows() + m_rhs.rows() : m_lhs.rows();
+  }
+  EIGEN_DEVICE_FUNC constexpr Index cols() const {
+    return Direction == Horizontal ? m_lhs.cols() + m_rhs.cols() : m_lhs.cols();
+  }
+
+  EIGEN_DEVICE_FUNC constexpr const LhsTypeNested_& lhs() const { return m_lhs; }
+  EIGEN_DEVICE_FUNC constexpr const RhsTypeNested_& rhs() const { return m_rhs; }
+
+ protected:
+  LhsTypeNested m_lhs;
+  RhsTypeNested m_rhs;
+};
+
+// Evaluator for Concat
+namespace internal {
+
+template <int Direction, typename LhsType, typename RhsType>
+struct evaluator<Concat<Direction, LhsType, RhsType>> : evaluator_base<Concat<Direction, LhsType, RhsType>> {
+  using XprType = Concat<Direction, LhsType, RhsType>;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
+
+  using LhsNested = typename nested_eval<LhsType, 1>::type;
+  using RhsNested = typename nested_eval<RhsType, 1>::type;
+  using LhsNestedCleaned = remove_all_t<LhsNested>;
+  using RhsNestedCleaned = remove_all_t<RhsNested>;
+
+  enum {
+    CoeffReadCost = plain_enum_max(evaluator<LhsNestedCleaned>::CoeffReadCost,
+                                   evaluator<RhsNestedCleaned>::CoeffReadCost) +
+                    NumTraits<typename XprType::Scalar>::AddCost,  // cost of the branch
+    LhsFlags = evaluator<LhsNestedCleaned>::Flags,
+    RhsFlags = evaluator<RhsNestedCleaned>::Flags,
+    IsRowMajor = int(traits<XprType>::Flags) & RowMajorBit,
+    IsVectorAtCompileTime = XprType::IsVectorAtCompileTime,
+    // Packets are loaded along the Concat's inner direction, so each operand must store its
+    // coefficients in that same order. Compile-time vectors are exempt: a vector evaluator with
+    // packet access is contiguous along its single extent, and requests along the other
+    // direction can only be single-lane.
+    LhsOrderAgrees = (bool(int(LhsFlags) & RowMajorBit) == bool(IsRowMajor)) || LhsNestedCleaned::IsVectorAtCompileTime,
+    RhsOrderAgrees = (bool(int(RhsFlags) & RowMajorBit) == bool(IsRowMajor)) || RhsNestedCleaned::IsVectorAtCompileTime,
+    BothHavePacketAccess = (int(LhsFlags) & int(RhsFlags) & PacketAccessBit) && LhsOrderAgrees && RhsOrderAgrees,
+    BothHaveLinearAccess = bool(int(LhsFlags) & int(RhsFlags) & LinearAccessBit),
+    Flags = (traits<XprType>::Flags & RowMajorBit) | (BothHavePacketAccess ? PacketAccessBit : 0) |
+            (IsVectorAtCompileTime && BothHaveLinearAccess ? LinearAccessBit : 0),
+    Alignment = 0  // conservative: no alignment guarantees across boundary
+  };
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
+      : m_lhs(xpr.lhs()),
+        m_rhs(xpr.rhs()),
+        m_lhsImpl(m_lhs),
+        m_rhsImpl(m_rhs),
+        m_lhsRows(xpr.lhs().rows()),
+        m_lhsCols(xpr.lhs().cols()) {}
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
+    EIGEN_IF_CONSTEXPR (Direction == Vertical) {
+      if (row < m_lhsRows.value())
+        return m_lhsImpl.coeff(row, col);
+      else
+        return m_rhsImpl.coeff(row - m_lhsRows.value(), col);
+    } else {
+      if (col < m_lhsCols.value())
+        return m_lhsImpl.coeff(row, col);
+      else
+        return m_rhsImpl.coeff(row, col - m_lhsCols.value());
+    }
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    const Index boundary = Direction == Vertical ? m_lhsRows.value() : m_lhsCols.value();
+    if (index < boundary)
+      return m_lhsImpl.coeff(index);
+    else
+      return m_rhsImpl.coeff(index - boundary);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+    constexpr int packetSize = unpacket_traits<PacketType>::size;
+    EIGEN_IF_CONSTEXPR (Direction == Vertical) {
+      const Index boundary = m_lhsRows.value();
+      if (row >= boundary) return m_rhsImpl.template packet<LoadMode, PacketType>(row - boundary, col);
+      // Column-major: inner=rows, packet extends along rows and may straddle the row boundary.
+      // Row-major: inner=cols, packet extends along cols — never crosses the row boundary.
+      EIGEN_IF_CONSTEXPR (!IsRowMajor) {
+        if (row + packetSize > boundary) return packetBoundary<LoadMode, PacketType>(row, col);
+      }
+      return m_lhsImpl.template packet<LoadMode, PacketType>(row, col);
+    } else {
+      const Index boundary = m_lhsCols.value();
+      if (col >= boundary) return m_rhsImpl.template packet<LoadMode, PacketType>(row, col - boundary);
+      // Row-major: inner=cols, packet extends along cols and may straddle the col boundary.
+      // Column-major: inner=rows, packet extends along rows — never crosses the col boundary.
+      EIGEN_IF_CONSTEXPR (IsRowMajor) {
+        if (col + packetSize > boundary) return packetBoundary<LoadMode, PacketType>(row, col);
+      }
+      return m_lhsImpl.template packet<LoadMode, PacketType>(row, col);
+    }
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+    constexpr int packetSize = unpacket_traits<PacketType>::size;
+    const Index boundary = Direction == Vertical ? m_lhsRows.value() : m_lhsCols.value();
+    if (index >= boundary) return m_rhsImpl.template packet<LoadMode, PacketType>(index - boundary);
+    if (index + packetSize > boundary) return packetBoundaryLinear<LoadMode, PacketType>(index);
+    return m_lhsImpl.template packet<LoadMode, PacketType>(index);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index row, Index col, Index begin, Index count) const {
+    EIGEN_IF_CONSTEXPR (Direction == Vertical) {
+      const Index boundary = m_lhsRows.value();
+      if (row >= boundary)
+        return m_rhsImpl.template packetSegment<LoadMode, PacketType>(row - boundary, col, begin, count);
+      EIGEN_IF_CONSTEXPR (!IsRowMajor) {
+        if (row + begin + count > boundary) return packetSegmentBoundary<LoadMode, PacketType>(row, col, begin, count);
+      }
+      return m_lhsImpl.template packetSegment<LoadMode, PacketType>(row, col, begin, count);
+    } else {
+      const Index boundary = m_lhsCols.value();
+      if (col >= boundary)
+        return m_rhsImpl.template packetSegment<LoadMode, PacketType>(row, col - boundary, begin, count);
+      EIGEN_IF_CONSTEXPR (IsRowMajor) {
+        if (col + begin + count > boundary) return packetSegmentBoundary<LoadMode, PacketType>(row, col, begin, count);
+      }
+      return m_lhsImpl.template packetSegment<LoadMode, PacketType>(row, col, begin, count);
+    }
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index index, Index begin, Index count) const {
+    const Index boundary = Direction == Vertical ? m_lhsRows.value() : m_lhsCols.value();
+    if (index >= boundary)
+      return m_rhsImpl.template packetSegment<LoadMode, PacketType>(index - boundary, begin, count);
+    if (index + begin + count > boundary) return packetSegmentBoundaryLinear<LoadMode, PacketType>(index, begin, count);
+    return m_lhsImpl.template packetSegment<LoadMode, PacketType>(index, begin, count);
+  }
+
+ protected:
+  using Scalar = typename XprType::Scalar;
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetBoundary(Index row, Index col) const {
+    constexpr int packetSize = unpacket_traits<PacketType>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketType>::alignment) Scalar tmp[packetSize];
+    for (int i = 0; i < packetSize; ++i)
+      tmp[i] = coeff(row + (Direction == Vertical ? i : 0), col + (Direction == Horizontal ? i : 0));
+    return pload<PacketType>(tmp);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetBoundaryLinear(Index index) const {
+    constexpr int packetSize = unpacket_traits<PacketType>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketType>::alignment) Scalar tmp[packetSize];
+    for (int i = 0; i < packetSize; ++i) tmp[i] = coeff(index + i);
+    return pload<PacketType>(tmp);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegmentBoundary(Index row, Index col, Index begin,
+                                                                         Index count) const {
+    constexpr int packetSize = unpacket_traits<PacketType>::size;
+    EIGEN_ALIGN_MAX Scalar tmp[packetSize];
+    for (Index i = begin; i < begin + count; ++i)
+      tmp[i] = coeff(row + (Direction == Vertical ? i : 0), col + (Direction == Horizontal ? i : 0));
+    return ploadSegment<PacketType>(tmp, begin, count);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegmentBoundaryLinear(Index index, Index begin,
+                                                                               Index count) const {
+    constexpr int packetSize = unpacket_traits<PacketType>::size;
+    EIGEN_ALIGN_MAX Scalar tmp[packetSize];
+    for (Index i = begin; i < begin + count; ++i) tmp[i] = coeff(index + i);
+    return ploadSegment<PacketType>(tmp, begin, count);
+  }
+
+  LhsNested m_lhs;
+  RhsNested m_rhs;
+  evaluator<LhsNestedCleaned> m_lhsImpl;
+  evaluator<RhsNestedCleaned> m_rhsImpl;
+  const variable_if_dynamic<Index, LhsType::RowsAtCompileTime> m_lhsRows;
+  const variable_if_dynamic<Index, LhsType::ColsAtCompileTime> m_lhsCols;
+};
+
+}  // namespace internal
+
+/**
+ * \relates Concat
+ * \returns an expression of \a lhs and \a rhs concatenated horizontally (side by side).
+ *
+ * Both arguments must have the same number of rows.
+ * To concatenate more than two expressions, chain calls: \c hcat(hcat(a, b), c).
+ *
+ * Example: \code
+ * Matrix2d A, B;
+ * auto C = hcat(A, B);  // C is 2x4
+ * \endcode
+ *
+ * \sa vcat(), Concat
+ */
+template <typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC inline const Concat<Horizontal, Lhs, Rhs> hcat(const DenseBase<Lhs>& lhs, const DenseBase<Rhs>& rhs) {
+  return Concat<Horizontal, Lhs, Rhs>(lhs.derived(), rhs.derived());
+}
+
+/**
+ * \relates Concat
+ * \returns an expression of \a lhs and \a rhs concatenated vertically (stacked on top of each other).
+ *
+ * Both arguments must have the same number of columns.
+ * To concatenate more than two expressions, chain calls: \c vcat(vcat(a, b), c).
+ *
+ * Example: \code
+ * Matrix2d A, B;
+ * auto C = vcat(A, B);  // C is 4x2
+ * \endcode
+ *
+ * \sa hcat(), Concat
+ */
+template <typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC inline const Concat<Vertical, Lhs, Rhs> vcat(const DenseBase<Lhs>& lhs, const DenseBase<Rhs>& rhs) {
+  return Concat<Vertical, Lhs, Rhs>(lhs.derived(), rhs.derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_CONCAT_OP_H
diff --git a/Eigen/src/Core/ConditionEstimator.h b/Eigen/src/Core/ConditionEstimator.h
index df27be3..41e2d87 100644
--- a/Eigen/src/Core/ConditionEstimator.h
+++ b/Eigen/src/Core/ConditionEstimator.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CONDITIONESTIMATOR_H
 #define EIGEN_CONDITIONESTIMATOR_H
@@ -56,11 +57,11 @@
  */
 template <typename Decomposition>
 typename Decomposition::RealScalar rcond_invmatrix_L1_norm_estimate(const Decomposition& dec) {
-  typedef typename Decomposition::MatrixType MatrixType;
-  typedef typename Decomposition::Scalar Scalar;
-  typedef typename Decomposition::RealScalar RealScalar;
-  typedef typename internal::plain_col_type<MatrixType>::type Vector;
-  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVector;
+  using MatrixType = typename Decomposition::MatrixType;
+  using Scalar = typename Decomposition::Scalar;
+  using RealScalar = typename Decomposition::RealScalar;
+  using Vector = typename internal::plain_col_type<MatrixType>::type;
+  using RealVector = typename internal::plain_col_type<MatrixType, RealScalar>::type;
   const bool is_complex = (NumTraits<Scalar>::IsComplex != 0);
 
   eigen_assert(dec.rows() == dec.cols());
@@ -147,7 +148,7 @@
 template <typename Decomposition>
 typename Decomposition::RealScalar rcond_estimate_helper(typename Decomposition::RealScalar matrix_norm,
                                                          const Decomposition& dec) {
-  typedef typename Decomposition::RealScalar RealScalar;
+  using RealScalar = typename Decomposition::RealScalar;
   eigen_assert(dec.rows() == dec.cols());
   if (dec.rows() == 0) return NumTraits<RealScalar>::infinity();
   if (numext::is_exactly_zero(matrix_norm)) return RealScalar(0);
diff --git a/Eigen/src/Core/CoreEvaluators.h b/Eigen/src/Core/CoreEvaluators.h
index 9df0c96..67fe5df 100644
--- a/Eigen/src/Core/CoreEvaluators.h
+++ b/Eigen/src/Core/CoreEvaluators.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COREEVALUATORS_H
 #define EIGEN_COREEVALUATORS_H
@@ -23,7 +24,7 @@
 // Default assumes index based accessors
 template <typename StorageKind>
 struct storage_kind_to_evaluator_kind {
-  typedef IndexBased Kind;
+  using Kind = IndexBased;
 };
 
 // This class returns the evaluator shape from the expression storage kind.
@@ -33,19 +34,19 @@
 
 template <>
 struct storage_kind_to_shape<Dense> {
-  typedef DenseShape Shape;
+  using Shape = DenseShape;
 };
 template <>
 struct storage_kind_to_shape<SolverStorage> {
-  typedef SolverShape Shape;
+  using Shape = SolverShape;
 };
 template <>
 struct storage_kind_to_shape<PermutationStorage> {
-  typedef PermutationShape Shape;
+  using Shape = PermutationShape;
 };
 template <>
 struct storage_kind_to_shape<TranspositionsStorage> {
-  typedef TranspositionsShape Shape;
+  using Shape = TranspositionsShape;
 };
 
 // Evaluators have to be specialized with respect to various criteria such as:
@@ -54,7 +55,7 @@
 //  - etc.
 // Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
 // We currently distinguish the following kind of evaluators:
-// - unary_evaluator    for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose,
+// - unary_evaluator    for expressions taking only one argument (CwiseUnaryOp, CwiseUnaryView, Transpose,
 // MatrixWrapper, ArrayWrapper, Reverse, Replicate)
 // - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
 // - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
@@ -86,8 +87,8 @@
 template <typename T>
 struct evaluator_traits_base {
   // by default, get evaluator kind and shape from storage
-  typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
-  typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
+  using Kind = typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind;
+  using Shape = typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape;
 };
 
 // Default evaluator traits
@@ -95,14 +96,12 @@
 struct evaluator_traits : public evaluator_traits_base<T> {};
 
 template <typename T, typename Shape = typename evaluator_traits<T>::Shape>
-struct evaluator_assume_aliasing {
-  static const bool value = false;
-};
+struct evaluator_assume_aliasing : std::false_type {};
 
 // By default, we assume a unary expression:
 template <typename T>
 struct evaluator : public unary_evaluator<T> {
-  typedef unary_evaluator<T> Base;
+  using Base = unary_evaluator<T>;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const T& xpr) : Base(xpr) {}
 };
 
@@ -118,17 +117,15 @@
 struct evaluator_base {
   // TODO: find a way to avoid propagating all these traits. They are currently only needed to handle
   // outer,inner indices.
-  typedef traits<ExpressionType> ExpressionTraits;
+  using ExpressionTraits = traits<ExpressionType>;
 
   enum { Alignment = 0 };
-  // noncopyable:
-  // Don't make this class inherit noncopyable as this kills EBO (Empty Base Optimization)
-  // and make complex evaluator much larger than then should do.
+  // Spell out deleted copy operations instead of inheriting from an empty helper:
+  // an extra base can kill EBO and make complex evaluators larger than they should be.
   EIGEN_DEVICE_FUNC constexpr evaluator_base() = default;
 
- private:
-  EIGEN_DEVICE_FUNC evaluator_base(const evaluator_base&);
-  EIGEN_DEVICE_FUNC const evaluator_base& operator=(const evaluator_base&);
+  evaluator_base(const evaluator_base&) = delete;
+  evaluator_base& operator=(const evaluator_base&) = delete;
 };
 
 // -------------------- Matrix and Array --------------------
@@ -143,9 +140,7 @@
 class plainobjectbase_evaluator_data {
  public:
   EIGEN_DEVICE_FUNC constexpr plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr) {
-#ifndef EIGEN_INTERNAL_DEBUGGING
     EIGEN_UNUSED_VARIABLE(outerStride);
-#endif
     eigen_internal_assert(outerStride == OuterStride);
   }
   EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return OuterStride; }
@@ -166,9 +161,9 @@
 
 template <typename Derived>
 struct evaluator<PlainObjectBase<Derived>> : evaluator_base<Derived> {
-  typedef PlainObjectBase<Derived> PlainObjectType;
-  typedef typename PlainObjectType::Scalar Scalar;
-  typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;
+  using PlainObjectType = PlainObjectBase<Derived>;
+  using Scalar = typename PlainObjectType::Scalar;
+  using CoeffReturnType = typename PlainObjectType::CoeffReturnType;
 
   enum {
     IsRowMajor = PlainObjectType::IsRowMajor,
@@ -264,7 +259,7 @@
 template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
 struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
     : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>> {
-  typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+  using XprType = Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>;
 
   EIGEN_DEVICE_FUNC constexpr evaluator() = default;
 
@@ -274,7 +269,7 @@
 template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
 struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
     : evaluator<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>> {
-  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;
+  using XprType = Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>;
 
   EIGEN_DEVICE_FUNC constexpr evaluator() = default;
 
@@ -285,7 +280,7 @@
 
 template <typename ArgType>
 struct unary_evaluator<Transpose<ArgType>, IndexBased> : evaluator_base<Transpose<ArgType>> {
-  typedef Transpose<ArgType> XprType;
+  using XprType = Transpose<ArgType>;
 
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
@@ -296,8 +291,8 @@
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& t)
       : m_argImpl(t.nestedExpression()) {}
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     return m_argImpl.coeff(col, row);
@@ -363,7 +358,7 @@
 
 // -------------------- CwiseNullaryOp --------------------
 // Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
-// Likewise, there is not need to more sophisticated dispatching here.
+// Likewise, there is no need for more sophisticated dispatching here.
 
 template <typename Scalar, typename NullaryOp, bool has_nullary = has_nullary_operator<NullaryOp>::value,
           bool has_unary = has_unary_operator<NullaryOp>::value,
@@ -448,14 +443,14 @@
 template <typename NullaryOp, typename PlainObjectType>
 struct evaluator<CwiseNullaryOp<NullaryOp, PlainObjectType>>
     : evaluator_base<CwiseNullaryOp<NullaryOp, PlainObjectType>> {
-  typedef CwiseNullaryOp<NullaryOp, PlainObjectType> XprType;
-  typedef remove_all_t<PlainObjectType> PlainObjectTypeCleaned;
+  using XprType = CwiseNullaryOp<NullaryOp, PlainObjectType>;
+  using PlainObjectTypeCleaned = remove_all_t<PlainObjectType>;
 
   enum {
     CoeffReadCost = functor_traits<NullaryOp>::Cost,
 
     Flags = (evaluator<PlainObjectTypeCleaned>::Flags &
-             (HereditaryBits | (functor_has_linear_access<NullaryOp>::ret ? LinearAccessBit : 0) |
+             (HereditaryBits | (functor_has_linear_access<NullaryOp>::value ? LinearAccessBit : 0) |
               (functor_traits<NullaryOp>::PacketAccess ? PacketAccessBit : 0))) |
             (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
     Alignment = AlignedMax
@@ -465,7 +460,7 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   template <typename IndexType>
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(IndexType row, IndexType col) const {
@@ -508,7 +503,7 @@
 
 template <typename UnaryOp, typename ArgType>
 struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased> : evaluator_base<CwiseUnaryOp<UnaryOp, ArgType>> {
-  typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+  using XprType = CwiseUnaryOp<UnaryOp, ArgType>;
 
   enum {
     CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
@@ -523,7 +518,7 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     return m_d.func()(m_d.argImpl.coeff(row, col));
@@ -906,8 +901,8 @@
 template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
 struct evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>
     : public ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>> {
-  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
-  typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>> Base;
+  using XprType = CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>;
+  using Base = ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>;
 
   EIGEN_DEVICE_FUNC constexpr explicit evaluator(const XprType& xpr) : Base(xpr) {}
 };
@@ -915,7 +910,7 @@
 template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
 struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased, IndexBased>
     : evaluator_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>> {
-  typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
+  using XprType = CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>;
 
   enum {
     CoeffReadCost = int(evaluator<Arg1>::CoeffReadCost) + int(evaluator<Arg2>::CoeffReadCost) +
@@ -924,8 +919,8 @@
     Arg1Flags = evaluator<Arg1>::Flags,
     Arg2Flags = evaluator<Arg2>::Flags,
     Arg3Flags = evaluator<Arg3>::Flags,
-    SameType = is_same<typename Arg1::Scalar, typename Arg2::Scalar>::value &&
-               is_same<typename Arg1::Scalar, typename Arg3::Scalar>::value,
+    SameType = std::is_same<typename Arg1::Scalar, typename Arg2::Scalar>::value &&
+               std::is_same<typename Arg1::Scalar, typename Arg3::Scalar>::value,
     StorageOrdersAgree = (int(Arg1Flags) & RowMajorBit) == (int(Arg2Flags) & RowMajorBit) &&
                          (int(Arg1Flags) & RowMajorBit) == (int(Arg3Flags) & RowMajorBit),
     Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) &
@@ -943,7 +938,7 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     return m_d.func()(m_d.arg1Impl.coeff(row, col), m_d.arg2Impl.coeff(row, col), m_d.arg3Impl.coeff(row, col));
@@ -1002,15 +997,25 @@
   using DummyArg3 = CwiseBinaryOp<scalar_cmp_op<Scalar, Scalar, cmp, false>, CmpLhsType, CmpRhsType>;
   using DummyXprType = CwiseTernaryOp<DummyTernaryOp, Arg1, Arg2, DummyArg3>;
 
-  // only use the typed comparison if it is vectorized
-  static constexpr bool UseTyped = functor_traits<scalar_cmp_op<Scalar, Scalar, cmp, true>>::PacketAccess;
-  using CondScalar = std::conditional_t<UseTyped, Scalar, bool>;
+  using PacketTernaryOp = scalar_boolean_select_op<Scalar, Scalar, Scalar>;
+  using PacketArg3 = CwiseBinaryOp<scalar_cmp_op<Scalar, Scalar, cmp, true>, CmpLhsType, CmpRhsType>;
+  using PacketXprType = CwiseTernaryOp<PacketTernaryOp, Arg1, Arg2, PacketArg3>;
 
-  using TernaryOp = scalar_boolean_select_op<Scalar, Scalar, CondScalar>;
-  using Arg3 = CwiseBinaryOp<scalar_cmp_op<Scalar, Scalar, cmp, UseTyped>, CmpLhsType, CmpRhsType>;
-  using XprType = CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>;
+  // Rebuild the comparison with a typed result only when the entire select expression can use packets. Otherwise,
+  // evaluate the original expression so indirect evaluators do not retain references into a temporary rewrite.
+  static constexpr bool UseTyped = (ternary_evaluator<PacketXprType>::Flags & PacketAccessBit) != 0;
+  using Arg3 = std::conditional_t<UseTyped, PacketArg3, DummyArg3>;
+  using XprType = std::conditional_t<UseTyped, PacketXprType, DummyXprType>;
 
   using Base = ternary_evaluator<XprType>;
+
+  EIGEN_DEVICE_FUNC constexpr static const DummyXprType& expression(const DummyXprType& xpr, std::false_type) {
+    return xpr;
+  }
+
+  EIGEN_DEVICE_FUNC constexpr static XprType expression(const DummyXprType& xpr, std::true_type) {
+    return XprType(xpr.arg1(), xpr.arg2(), Arg3(xpr.arg3().lhs(), xpr.arg3().rhs()));
+  }
 };
 
 // specialization for expressions like (a < b).select(c, d) to enable full vectorization
@@ -1021,11 +1026,9 @@
   using Helper = scalar_boolean_select_spec<Arg1, Arg2, Scalar, CmpLhsType, CmpRhsType, cmp>;
   using Base = typename Helper::Base;
   using DummyXprType = typename Helper::DummyXprType;
-  using Arg3 = typename Helper::Arg3;
-  using XprType = typename Helper::XprType;
 
   EIGEN_DEVICE_FUNC constexpr explicit evaluator(const DummyXprType& xpr)
-      : Base(XprType(xpr.arg1(), xpr.arg2(), Arg3(xpr.arg3().lhs(), xpr.arg3().rhs()))) {}
+      : Base(Helper::expression(xpr, bool_constant<Helper::UseTyped>())) {}
 };
 
 // -------------------- CwiseBinaryOp --------------------
@@ -1033,8 +1036,8 @@
 // this is a binary expression
 template <typename BinaryOp, typename Lhs, typename Rhs>
 struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> : public binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
-  typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> Base;
+  using XprType = CwiseBinaryOp<BinaryOp, Lhs, Rhs>;
+  using Base = binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
 };
@@ -1042,7 +1045,7 @@
 template <typename BinaryOp, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
     : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  using XprType = CwiseBinaryOp<BinaryOp, Lhs, Rhs>;
 
   enum {
     CoeffReadCost =
@@ -1050,7 +1053,7 @@
 
     LhsFlags = evaluator<Lhs>::Flags,
     RhsFlags = evaluator<Rhs>::Flags,
-    SameType = is_same<typename Lhs::Scalar, typename Rhs::Scalar>::value,
+    SameType = std::is_same<typename Lhs::Scalar, typename Rhs::Scalar>::value,
     StorageOrdersAgree = (int(LhsFlags) & RowMajorBit) == (int(RhsFlags) & RowMajorBit),
     Flags0 = (int(LhsFlags) | int(RhsFlags)) &
              (HereditaryBits |
@@ -1066,7 +1069,7 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     return m_d.func()(m_d.lhsImpl.coeff(row, col), m_d.rhsImpl.coeff(row, col));
@@ -1119,7 +1122,7 @@
 template <typename UnaryOp, typename ArgType, typename StrideType>
 struct unary_evaluator<CwiseUnaryView<UnaryOp, ArgType, StrideType>, IndexBased>
     : evaluator_base<CwiseUnaryView<UnaryOp, ArgType, StrideType>> {
-  typedef CwiseUnaryView<UnaryOp, ArgType, StrideType> XprType;
+  using XprType = CwiseUnaryView<UnaryOp, ArgType, StrideType>;
 
   enum {
     CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),
@@ -1134,8 +1137,8 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     return m_d.func()(m_d.argImpl.coeff(row, col));
@@ -1166,6 +1169,102 @@
   Data m_d;
 };
 
+// Read-only component evaluators can gather from contiguous std::complex storage. In particular,
+// PacketAccessBit on a custom expression does not imply array-oriented component access.
+template <typename XprType, int Component,
+          bool Vectorizable = bool(traits<typename XprType::NestedExpression>::Flags & DirectAccessBit) &&
+                              inner_stride_at_compile_time<typename XprType::NestedExpression>::value == 1 &&
+                              (std::is_same<typename XprType::Scalar, float>::value ||
+                               std::is_same<typename XprType::Scalar, double>::value) &&
+                              packet_traits<typename XprType::Scalar>::Vectorizable &&
+                              std::is_same<typename XprType::Scalar, typename unpacket_traits<typename packet_traits<
+                                                                         typename XprType::Scalar>::type>::type>::value>
+struct complex_component_evaluator : unary_evaluator<XprType> {
+  using Base = unary_evaluator<XprType>;
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit complex_component_evaluator(const XprType& xpr)
+      : Base(xpr) {}
+};
+
+template <typename XprType, int Component>
+struct complex_component_evaluator<XprType, Component, true> : unary_evaluator<XprType> {
+  using Base = unary_evaluator<XprType>;
+  using Scalar = typename XprType::Scalar;
+  // Not named ArgType: MSVC 19.29 resolves the derived evaluator specializations' ArgType template
+  // parameter to this member through the dependent base, and it drops the nested expression's const.
+  using NestedXpr = typename XprType::NestedExpression;
+  // Blocks must delegate packet reads here rather than reinterpret this stride-2 view as a contiguous Map.
+  static constexpr unsigned int Flags = (Base::Flags & ~DirectAccessBit) | PacketAccessBit;
+  static constexpr int Alignment = 0;
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit complex_component_evaluator(const XprType& xpr)
+      : Base(xpr),
+        m_data(reinterpret_cast<const Scalar*>(xpr.nestedExpression().data())),
+        m_outerStride(xpr.nestedExpression().outerStride()) {}
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+    return pgather<Scalar, PacketType>(m_data + 2 * index + Component, 2);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+    const Index index = XprType::IsRowMajor ? row * m_outerStride.value() + col : col * m_outerStride.value() + row;
+    return packet<LoadMode, PacketType>(index);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index index, Index begin, Index count) const {
+    Scalar values[unpacket_traits<PacketType>::size] = {};
+    for (Index i = begin; i < begin + count; ++i) values[i] = Base::coeff(index + i);
+    return ploadu<PacketType>(values);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index row, Index col, Index begin, Index count) const {
+    Scalar values[unpacket_traits<PacketType>::size] = {};
+    for (Index i = begin; i < begin + count; ++i)
+      values[i] = Base::coeff(row + (XprType::IsRowMajor ? 0 : i), col + (XprType::IsRowMajor ? i : 0));
+    return ploadu<PacketType>(values);
+  }
+
+ private:
+  const Scalar* m_data;
+  const variable_if_dynamic<Index, outer_stride_at_compile_time<NestedXpr>::value> m_outerStride;
+};
+
+template <typename Real, typename ArgType>
+struct evaluator<CwiseUnaryOp<scalar_real_op<std::complex<Real>>, ArgType>>
+    : complex_component_evaluator<CwiseUnaryOp<scalar_real_op<std::complex<Real>>, ArgType>, 0> {
+  using XprType = CwiseUnaryOp<scalar_real_op<std::complex<Real>>, ArgType>;
+  using Base = complex_component_evaluator<XprType, 0>;
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+// Writable views keep scalar stores: assignment functors require contiguous destination packets.
+template <typename Real, typename ArgType>
+struct evaluator<const CwiseUnaryView<scalar_real_ref_op<std::complex<Real>>, ArgType, Stride<0, 0>>>
+    : complex_component_evaluator<CwiseUnaryView<scalar_real_ref_op<std::complex<Real>>, ArgType, Stride<0, 0>>, 0> {
+  using XprType = CwiseUnaryView<scalar_real_ref_op<std::complex<Real>>, ArgType, Stride<0, 0>>;
+  using Base = complex_component_evaluator<XprType, 0>;
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template <typename Real, typename ArgType>
+struct evaluator<CwiseUnaryOp<scalar_imag_op<std::complex<Real>>, ArgType>>
+    : complex_component_evaluator<CwiseUnaryOp<scalar_imag_op<std::complex<Real>>, ArgType>, 1> {
+  using XprType = CwiseUnaryOp<scalar_imag_op<std::complex<Real>>, ArgType>;
+  using Base = complex_component_evaluator<XprType, 1>;
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
+template <typename Real, typename ArgType>
+struct evaluator<const CwiseUnaryView<scalar_imag_ref_op<std::complex<Real>>, ArgType, Stride<0, 0>>>
+    : complex_component_evaluator<CwiseUnaryView<scalar_imag_ref_op<std::complex<Real>>, ArgType, Stride<0, 0>>, 1> {
+  using XprType = CwiseUnaryView<scalar_imag_ref_op<std::complex<Real>>, ArgType, Stride<0, 0>>;
+  using Base = complex_component_evaluator<XprType, 1>;
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
+};
+
 // -------------------- Map --------------------
 
 // FIXME: consider using Derived::PlainObject for PlainObjectType.
@@ -1175,13 +1274,13 @@
 
 template <typename Derived, typename PlainObjectType>
 struct mapbase_evaluator : evaluator_base<Derived> {
-  typedef Derived XprType;
-  typedef typename XprType::PointerType PointerType;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using XprType = Derived;
+  using PointerType = typename XprType::PointerType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   enum {
-    IsRowMajor = XprType::RowsAtCompileTime,
+    IsRowMajor = XprType::IsRowMajor,
     ColsAtCompileTime = XprType::ColsAtCompileTime,
     CoeffReadCost = NumTraits<Scalar>::ReadCost
   };
@@ -1191,7 +1290,7 @@
         m_innerStride(map.innerStride()),
         m_outerStride(map.outerStride()) {
     EIGEN_STATIC_ASSERT(check_implication((evaluator<Derived>::Flags & PacketAccessBit) != 0,
-                                          inner_stride_at_compile_time<Derived>::ret == 1),
+                                          inner_stride_at_compile_time<Derived>::value == 1),
                         PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
@@ -1274,10 +1373,10 @@
 template <typename PlainObjectType, int MapOptions, typename StrideType>
 struct evaluator<Map<PlainObjectType, MapOptions, StrideType>>
     : public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType> {
-  typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = Map<PlainObjectType, MapOptions, StrideType>;
+  using Scalar = typename XprType::Scalar;
   // TODO: should check for smaller packet types once we can handle multi-sized packet types
-  typedef typename packet_traits<Scalar>::type PacketScalar;
+  using PacketScalar = typename packet_traits<Scalar>::type;
 
   enum {
     InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
@@ -1308,7 +1407,7 @@
 template <typename PlainObjectType, int RefOptions, typename StrideType>
 struct evaluator<Ref<PlainObjectType, RefOptions, StrideType>>
     : public mapbase_evaluator<Ref<PlainObjectType, RefOptions, StrideType>, PlainObjectType> {
-  typedef Ref<PlainObjectType, RefOptions, StrideType> XprType;
+  using XprType = Ref<PlainObjectType, RefOptions, StrideType>;
 
   enum {
     Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType>>::Flags,
@@ -1322,16 +1421,16 @@
 // -------------------- Block --------------------
 
 template <typename ArgType, int BlockRows, int BlockCols, bool InnerPanel,
-          bool HasDirectAccess = has_direct_access<ArgType>::ret>
+          bool HasDirectAccess = has_direct_access<ArgType>::value && bool(evaluator<ArgType>::Flags & DirectAccessBit)>
 struct block_evaluator;
 
 template <typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
 struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>>
     : block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> {
-  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = Block<ArgType, BlockRows, BlockCols, InnerPanel>;
+  using Scalar = typename XprType::Scalar;
   // TODO: should check for smaller packet types once we can handle multi-sized packet types
-  typedef typename packet_traits<Scalar>::type PacketScalar;
+  using PacketScalar = typename packet_traits<Scalar>::type;
 
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
@@ -1347,11 +1446,15 @@
                                                                             : ArgTypeIsRowMajor,
     HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor),
     InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
-    InnerStrideAtCompileTime = HasSameStorageOrderAsArgType ? int(inner_stride_at_compile_time<ArgType>::ret)
-                                                            : int(outer_stride_at_compile_time<ArgType>::ret),
-    OuterStrideAtCompileTime = HasSameStorageOrderAsArgType ? int(outer_stride_at_compile_time<ArgType>::ret)
-                                                            : int(inner_stride_at_compile_time<ArgType>::ret),
-    MaskPacketAccessBit = (InnerStrideAtCompileTime == 1 || HasSameStorageOrderAsArgType) ? PacketAccessBit : 0,
+    InnerStrideAtCompileTime = HasSameStorageOrderAsArgType ? int(inner_stride_at_compile_time<ArgType>::value)
+                                                            : int(outer_stride_at_compile_time<ArgType>::value),
+    OuterStrideAtCompileTime = HasSameStorageOrderAsArgType ? int(outer_stride_at_compile_time<ArgType>::value)
+                                                            : int(inner_stride_at_compile_time<ArgType>::value),
+    // Direct-access blocks use mapbase_evaluator's contiguous loads, not the parent's packet method.
+    MaskPacketAccessBit = (InnerStrideAtCompileTime == 1 ||
+                           (!(evaluator<ArgType>::Flags & DirectAccessBit) && HasSameStorageOrderAsArgType))
+                              ? PacketAccessBit
+                              : 0,
 
     FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 ||
                             (InnerPanel && (evaluator<ArgType>::Flags & LinearAccessBit)))
@@ -1368,7 +1471,7 @@
                      : 0,
     Alignment = plain_enum_min(evaluator<ArgType>::Alignment, Alignment0)
   };
-  typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type;
+  using block_evaluator_type = block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& block)
       : block_evaluator_type(block) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
@@ -1379,7 +1482,7 @@
 template <typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
 struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAccess*/ false>
     : unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>> {
-  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  using XprType = Block<ArgType, BlockRows, BlockCols, InnerPanel>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit block_evaluator(const XprType& block)
       : unary_evaluator<XprType>(block) {}
@@ -1388,7 +1491,7 @@
 template <typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
 struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBased>
     : evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel>> {
-  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
+  using XprType = Block<ArgType, BlockRows, BlockCols, InnerPanel>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& block)
       : m_argImpl(block.nestedExpression()),
@@ -1400,8 +1503,8 @@
                                    : block.startCol() * block.nestedExpression().rows() + block.startRow())
                             : 0) {}
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   enum {
     RowsAtCompileTime = XprType::RowsAtCompileTime,
@@ -1432,7 +1535,7 @@
 
   template <int LoadMode, typename PacketType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
-    if (ForwardLinearAccess)
+    EIGEN_IF_CONSTEXPR (ForwardLinearAccess)
       return m_argImpl.template packet<LoadMode, PacketType>(m_linear_offset.value() + index);
     else
       return packet<LoadMode, PacketType>(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
@@ -1445,7 +1548,7 @@
 
   template <int StoreMode, typename PacketType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
-    if (ForwardLinearAccess)
+    EIGEN_IF_CONSTEXPR (ForwardLinearAccess)
       return m_argImpl.template writePacket<StoreMode, PacketType>(m_linear_offset.value() + index, x);
     else
       return writePacket<StoreMode, PacketType>(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0,
@@ -1460,7 +1563,7 @@
 
   template <int LoadMode, typename PacketType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index index, Index begin, Index count) const {
-    if (ForwardLinearAccess)
+    EIGEN_IF_CONSTEXPR (ForwardLinearAccess)
       return m_argImpl.template packetSegment<LoadMode, PacketType>(m_linear_offset.value() + index, begin, count);
     else
       return packetSegment<LoadMode, PacketType>(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0,
@@ -1477,7 +1580,7 @@
   template <int StoreMode, typename PacketType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacketSegment(Index index, const PacketType& x, Index begin,
                                                                 Index count) {
-    if (ForwardLinearAccess)
+    EIGEN_IF_CONSTEXPR (ForwardLinearAccess)
       return m_argImpl.template writePacketSegment<StoreMode, PacketType>(m_linear_offset.value() + index, x, begin,
                                                                           count);
     else
@@ -1487,20 +1590,20 @@
 
  protected:
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType
-  linear_coeff_impl(Index index, internal::true_type /* ForwardLinearAccess */) const {
+  linear_coeff_impl(Index index, std::true_type /* ForwardLinearAccess */) const {
     return m_argImpl.coeff(m_linear_offset.value() + index);
   }
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType
-  linear_coeff_impl(Index index, internal::false_type /* not ForwardLinearAccess */) const {
+  linear_coeff_impl(Index index, std::false_type /* not ForwardLinearAccess */) const {
     return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
   }
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar& linear_coeffRef_impl(
-      Index index, internal::true_type /* ForwardLinearAccess */) {
+      Index index, std::true_type /* ForwardLinearAccess */) {
     return m_argImpl.coeffRef(m_linear_offset.value() + index);
   }
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar& linear_coeffRef_impl(
-      Index index, internal::false_type /* not ForwardLinearAccess */) {
+      Index index, std::false_type /* not ForwardLinearAccess */) {
     return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
   }
 
@@ -1517,8 +1620,8 @@
 struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true>
     : mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
                         typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject> {
-  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = Block<ArgType, BlockRows, BlockCols, InnerPanel>;
+  using Scalar = typename XprType::Scalar;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit block_evaluator(const XprType& block)
       : mapbase_evaluator<XprType, typename XprType::PlainObject>(block) {
@@ -1533,16 +1636,24 @@
 template <typename ArgType, int RowFactor, int ColFactor>
 struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor>>
     : evaluator_base<Replicate<ArgType, RowFactor, ColFactor>> {
-  typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using XprType = Replicate<ArgType, RowFactor, ColFactor>;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
   enum { Factor = (RowFactor == Dynamic || ColFactor == Dynamic) ? Dynamic : RowFactor * ColFactor };
-  typedef typename nested_eval<ArgType, Factor>::type ArgTypeNested;
-  typedef remove_all_t<ArgTypeNested> ArgTypeNestedCleaned;
+  using ArgTypeNested = typename nested_eval<ArgType, Factor>::type;
+  using ArgTypeNestedCleaned = remove_all_t<ArgTypeNested>;
 
   enum {
     CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
     LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
-    Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits | LinearAccessMask) & ~RowMajorBit) |
+    // The packet paths below load from a single copy of the nested expression, so they are valid
+    // exactly when a packet cannot cross a replication boundary: the inner (storage-order)
+    // direction must not be replicated. The outer coordinate's modulo then maps any packet into
+    // the nested expression unchanged. When the inner direction is replicated, serving a packet
+    // would need a broadcast (or a wrap-around load) the methods below do not perform.
+    InnerFactor = traits<XprType>::IsRowMajor ? ColFactor : RowFactor,
+    MaskPacketAccessBit = InnerFactor == 1 ? PacketAccessBit : 0,
+    Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits | LinearAccessMask | MaskPacketAccessBit) &
+             ~RowMajorBit) |
             (traits<XprType>::Flags & RowMajorBit),
 
     Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
@@ -1606,7 +1717,7 @@
   }
 
  protected:
-  const ArgTypeNested m_arg;
+  ArgTypeNested m_arg;
   evaluator<ArgTypeNestedCleaned> m_argImpl;
   const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> m_rows;
   const variable_if_dynamic<Index, ArgType::ColsAtCompileTime> m_cols;
@@ -1619,7 +1730,7 @@
 
 template <typename XprType>
 struct evaluator_wrapper_base : evaluator_base<XprType> {
-  typedef remove_all_t<typename XprType::NestedExpressionType> ArgType;
+  using ArgType = remove_all_t<typename XprType::NestedExpressionType>;
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
     Flags = evaluator<ArgType>::Flags,
@@ -1628,8 +1739,8 @@
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
 
-  typedef typename ArgType::Scalar Scalar;
-  typedef typename ArgType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename ArgType::Scalar;
+  using CoeffReturnType = typename ArgType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     return m_argImpl.coeff(row, col);
@@ -1693,7 +1804,7 @@
 
 template <typename TArgType>
 struct unary_evaluator<MatrixWrapper<TArgType>> : evaluator_wrapper_base<MatrixWrapper<TArgType>> {
-  typedef MatrixWrapper<TArgType> XprType;
+  using XprType = MatrixWrapper<TArgType>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& wrapper)
       : evaluator_wrapper_base<MatrixWrapper<TArgType>>(wrapper.nestedExpression()) {}
@@ -1701,7 +1812,7 @@
 
 template <typename TArgType>
 struct unary_evaluator<ArrayWrapper<TArgType>> : evaluator_wrapper_base<ArrayWrapper<TArgType>> {
-  typedef ArrayWrapper<TArgType> XprType;
+  using XprType = ArrayWrapper<TArgType>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& wrapper)
       : evaluator_wrapper_base<ArrayWrapper<TArgType>>(wrapper.nestedExpression()) {}
@@ -1715,9 +1826,9 @@
 
 template <typename ArgType, int Direction>
 struct unary_evaluator<Reverse<ArgType, Direction>> : evaluator_base<Reverse<ArgType, Direction>> {
-  typedef Reverse<ArgType, Direction> XprType;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using XprType = Reverse<ArgType, Direction>;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   enum {
     IsRowMajor = XprType::IsRowMajor,
@@ -1872,13 +1983,13 @@
 
 template <typename ArgType, int DiagIndex>
 struct evaluator<Diagonal<ArgType, DiagIndex>> : evaluator_base<Diagonal<ArgType, DiagIndex>> {
-  typedef Diagonal<ArgType, DiagIndex> XprType;
+  using XprType = Diagonal<ArgType, DiagIndex>;
 
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
 
-    Flags =
-        (unsigned int)(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) | LinearAccessBit,
+    Flags = static_cast<unsigned int>(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) |
+            LinearAccessBit,
 
     Alignment = 0
   };
@@ -1886,8 +1997,8 @@
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& diagonal)
       : m_argImpl(diagonal.nestedExpression()), m_index(diagonal.index()) {}
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index) const {
     return m_argImpl.coeff(row + rowOffset(), row + colOffset());
@@ -1931,7 +2042,7 @@
 template <typename ArgType>
 class EvalToTemp : public dense_xpr_base<EvalToTemp<ArgType>>::type {
  public:
-  typedef typename dense_xpr_base<EvalToTemp>::type Base;
+  using Base = typename dense_xpr_base<EvalToTemp>::type;
   EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
 
   explicit EvalToTemp(const ArgType& arg) : m_arg(arg) {}
@@ -1948,9 +2059,9 @@
 
 template <typename ArgType>
 struct evaluator<EvalToTemp<ArgType>> : public evaluator<typename ArgType::PlainObject> {
-  typedef EvalToTemp<ArgType> XprType;
-  typedef typename ArgType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = EvalToTemp<ArgType>;
+  using PlainObject = typename ArgType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   EIGEN_DEVICE_FUNC constexpr explicit evaluator(const XprType& xpr) : m_result(xpr.arg()) {
     internal::construct_at<Base>(this, m_result);
diff --git a/Eigen/src/Core/CoreIterators.h b/Eigen/src/Core/CoreIterators.h
index 3143726..d348de2 100644
--- a/Eigen/src/Core/CoreIterators.h
+++ b/Eigen/src/Core/CoreIterators.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COREITERATORS_H
 #define EIGEN_COREITERATORS_H
@@ -36,9 +37,9 @@
 template <typename XprType>
 class InnerIterator {
  protected:
-  typedef internal::inner_iterator_selector<XprType, typename internal::evaluator_traits<XprType>::Kind> IteratorType;
-  typedef internal::evaluator<XprType> EvaluatorType;
-  typedef typename internal::traits<XprType>::Scalar Scalar;
+  using IteratorType = internal::inner_iterator_selector<XprType, typename internal::evaluator_traits<XprType>::Kind>;
+  using EvaluatorType = internal::evaluator<XprType>;
+  using Scalar = typename internal::traits<XprType>::Scalar;
 
  public:
   /** Construct an iterator over the \a outerId -th row or column of \a xpr */
@@ -90,8 +91,8 @@
 template <typename XprType>
 class inner_iterator_selector<XprType, IndexBased> {
  protected:
-  typedef evaluator<XprType> EvaluatorType;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using EvaluatorType = evaluator<XprType>;
+  using Scalar = typename traits<XprType>::Scalar;
   enum { IsRowMajor = (XprType::Flags & RowMajorBit) == RowMajorBit };
 
  public:
@@ -125,8 +126,8 @@
 template <typename XprType>
 class inner_iterator_selector<XprType, IteratorBased> : public evaluator<XprType>::InnerIterator {
  protected:
-  typedef typename evaluator<XprType>::InnerIterator Base;
-  typedef evaluator<XprType> EvaluatorType;
+  using Base = typename evaluator<XprType>::InnerIterator;
+  using EvaluatorType = evaluator<XprType>;
 
  public:
   EIGEN_STRONG_INLINE inner_iterator_selector(const EvaluatorType &eval, const Index &outerId,
diff --git a/Eigen/src/Core/CwiseBinaryOp.h b/Eigen/src/Core/CwiseBinaryOp.h
index 27fd434..82625d0 100644
--- a/Eigen/src/Core/CwiseBinaryOp.h
+++ b/Eigen/src/Core/CwiseBinaryOp.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CWISE_BINARY_OP_H
 #define EIGEN_CWISE_BINARY_OP_H
@@ -21,8 +22,8 @@
 struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
   // we must not inherit from traits<Lhs> since it has
   // the potential to cause problems with MSVC
-  typedef remove_all_t<Lhs> Ancestor;
-  typedef typename traits<Ancestor>::XprKind XprKind;
+  using Ancestor = remove_all_t<Lhs>;
+  using XprKind = typename traits<Ancestor>::XprKind;
   enum {
     RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
     ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
@@ -32,15 +33,15 @@
 
   // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
   // we still want to handle the case when the result type is different.
-  typedef typename result_of<BinaryOp(const typename Lhs::Scalar&, const typename Rhs::Scalar&)>::type Scalar;
-  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind, typename traits<Rhs>::StorageKind,
-                                              BinaryOp>::ret StorageKind;
-  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex, typename traits<Rhs>::StorageIndex>::type
-      StorageIndex;
-  typedef typename Lhs::Nested LhsNested;
-  typedef typename Rhs::Nested RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
+  using Scalar = typename result_of<BinaryOp(const typename Lhs::Scalar&, const typename Rhs::Scalar&)>::type;
+  using StorageKind = typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind,
+                                                          typename traits<Rhs>::StorageKind, BinaryOp>::ret;
+  using StorageIndex =
+      typename promote_index_type<typename traits<Lhs>::StorageIndex, typename traits<Rhs>::StorageIndex>::type;
+  using LhsNested = typename Lhs::Nested;
+  using RhsNested = typename Rhs::Nested;
+  using LhsNested_ = std::remove_reference_t<LhsNested>;
+  using RhsNested_ = std::remove_reference_t<RhsNested>;
   enum {
     Flags = cwise_promote_storage_order<typename traits<Lhs>::StorageKind, typename traits<Rhs>::StorageKind,
                                         LhsNested_::Flags & RowMajorBit, RhsNested_::Flags & RowMajorBit>::value
@@ -60,7 +61,7 @@
  * \tparam LhsType the type of the left-hand side
  * \tparam RhsType the type of the right-hand side
  *
- * This class represents an expression  where a coefficient-wise binary operator is applied to two expressions.
+ * This class represents an expression where a coefficient-wise binary operator is applied to two expressions.
  * It is the return type of binary operators, by which we mean only those binary operators where
  * both the left-hand side and the right-hand side are Eigen expressions.
  * For example, the return type of matrix1+matrix2 is a CwiseBinaryOp.
@@ -78,29 +79,23 @@
                                                    typename internal::traits<RhsType>::StorageKind, BinaryOp>::ret>,
                       internal::no_assignment_operator {
  public:
-  typedef internal::remove_all_t<BinaryOp> Functor;
-  typedef internal::remove_all_t<LhsType> Lhs;
-  typedef internal::remove_all_t<RhsType> Rhs;
+  using Functor = internal::remove_all_t<BinaryOp>;
+  using Lhs = internal::remove_all_t<LhsType>;
+  using Rhs = internal::remove_all_t<RhsType>;
 
-  typedef typename CwiseBinaryOpImpl<
+  using Base = typename CwiseBinaryOpImpl<
       BinaryOp, LhsType, RhsType,
       typename internal::cwise_promote_storage_type<typename internal::traits<LhsType>::StorageKind,
-                                                    typename internal::traits<Rhs>::StorageKind, BinaryOp>::ret>::Base
-      Base;
+                                                    typename internal::traits<Rhs>::StorageKind, BinaryOp>::ret>::Base;
   EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
 
-  EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp, typename Lhs::Scalar, typename Rhs::Scalar)
+  EIGEN_CHECK_BINARY_COMPATIBILITY(BinaryOp, typename Lhs::Scalar, typename Rhs::Scalar)
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
 
-  typedef typename internal::ref_selector<LhsType>::type LhsNested;
-  typedef typename internal::ref_selector<RhsType>::type RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
-
-#if EIGEN_COMP_MSVC
-  // Required for Visual Studio, which may fail to inline the copy constructor otherwise.
-  EIGEN_STRONG_INLINE CwiseBinaryOp(const CwiseBinaryOp<BinaryOp, LhsType, RhsType>&) = default;
-#endif
+  using LhsNested = typename internal::ref_selector<LhsType>::type;
+  using RhsNested = typename internal::ref_selector<RhsType>::type;
+  using LhsNested_ = std::remove_reference_t<LhsNested>;
+  using RhsNested_ = std::remove_reference_t<RhsNested>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs,
                                                                 const BinaryOp& func = BinaryOp())
@@ -136,7 +131,7 @@
 template <typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
 class CwiseBinaryOpImpl : public internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>::type {
  public:
-  typedef typename internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>::type Base;
+  using Base = typename internal::generic_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>::type;
 };
 
 /** replaces \c *this by \c *this - \a other.
diff --git a/Eigen/src/Core/CwiseNullaryOp.h b/Eigen/src/Core/CwiseNullaryOp.h
index 7e117b6..218fac9 100644
--- a/Eigen/src/Core/CwiseNullaryOp.h
+++ b/Eigen/src/Core/CwiseNullaryOp.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CWISE_NULLARY_OP_H
 #define EIGEN_CWISE_NULLARY_OP_H
@@ -50,7 +51,7 @@
   for vectors.
   *
   * See DenseBase::NullaryExpr(Index,const CustomNullaryOp&) for an example binding
-  * C++11 random number generators.
+  * std random number generators.
   *
   * A nullary expression can also be used to implement custom sophisticated matrix manipulations
   * that cannot be covered by the existing set of natively supported matrix manipulations.
@@ -63,7 +64,7 @@
 class CwiseNullaryOp : public internal::dense_xpr_base<CwiseNullaryOp<NullaryOp, PlainObjectType> >::type,
                        internal::no_assignment_operator {
  public:
-  typedef typename internal::dense_xpr_base<CwiseNullaryOp>::type Base;
+  using Base = typename internal::dense_xpr_base<CwiseNullaryOp>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp)
 
   EIGEN_DEVICE_FUNC constexpr CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp())
@@ -126,8 +127,8 @@
  *
  * The template parameter \a CustomNullaryOp is the type of the functor.
  *
- * Here is an example with C++11 random generators: \include random_cpp11.cpp
- * Output: \verbinclude random_cpp11.out
+ * Here is an example with std random generators: \include random_generators.cpp
+ * Output: \verbinclude random_generators.out
  *
  * \sa class CwiseNullaryOp
  */
@@ -141,10 +142,11 @@
 #endif
     DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& func) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  if (RowsAtCompileTime == 1)
+  EIGEN_IF_CONSTEXPR (RowsAtCompileTime == 1) {
     return CwiseNullaryOp<CustomNullaryOp, PlainObject>(1, size, func);
-  else
+  } else {
     return CwiseNullaryOp<CustomNullaryOp, PlainObject>(size, 1, func);
+  }
 }
 
 /** \returns an expression of a matrix defined by a custom functor \a func
@@ -177,8 +179,6 @@
  * it is redundant to pass \a rows and \a cols as arguments, so Constant(const Scalar&) should be used
  * instead.
  *
- * The template parameter \a CustomNullaryOp is the type of the functor.
- *
  * \sa class CwiseNullaryOp
  */
 template <typename Derived>
@@ -198,8 +198,6 @@
  * it is redundant to pass \a size as argument, so Constant(const Scalar&) should be used
  * instead.
  *
- * The template parameter \a CustomNullaryOp is the type of the functor.
- *
  * \sa class CwiseNullaryOp
  */
 template <typename Derived>
@@ -213,8 +211,6 @@
  * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
  * need to use the variants taking size arguments.
  *
- * The template parameter \a CustomNullaryOp is the type of the functor.
- *
  * \sa class CwiseNullaryOp
  */
 template <typename Derived>
@@ -267,8 +263,8 @@
  *
  * For integer scalar types, an even spacing is possible if and only if the length of the range,
  * i.e., \c high-low is a scalar multiple of \c size-1, or if \c size is a scalar multiple of the
- * number of values \c high-low+1 (meaning each value can be repeated the same number of time).
- * If one of these two considions is not satisfied, then \c high is lowered to the largest value
+ * number of values \c high-low+1 (meaning each value can be repeated the same number of times).
+ * If one of these two conditions is not satisfied, then \c high is lowered to the largest value
  * satisfying one of this constraint.
  * Here are some examples:
  *
diff --git a/Eigen/src/Core/CwiseTernaryOp.h b/Eigen/src/Core/CwiseTernaryOp.h
index 8737791..8672c63 100644
--- a/Eigen/src/Core/CwiseTernaryOp.h
+++ b/Eigen/src/Core/CwiseTernaryOp.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CWISE_TERNARY_OP_H
 #define EIGEN_CWISE_TERNARY_OP_H
@@ -22,8 +23,8 @@
 struct traits<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>> {
   // we must not inherit from traits<Arg1> since it has
   // the potential to cause problems with MSVC
-  typedef remove_all_t<Arg1> Ancestor;
-  typedef typename traits<Ancestor>::XprKind XprKind;
+  using Ancestor = remove_all_t<Arg1>;
+  using XprKind = typename traits<Ancestor>::XprKind;
   enum {
     RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime,
     ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime,
@@ -34,18 +35,18 @@
   // even though we require Arg1, Arg2, and Arg3 to have the same scalar type
   // (see CwiseTernaryOp constructor),
   // we still want to handle the case when the result type is different.
-  typedef typename result_of<TernaryOp(const typename Arg1::Scalar&, const typename Arg2::Scalar&,
-                                       const typename Arg3::Scalar&)>::type Scalar;
+  using Scalar = typename result_of<TernaryOp(const typename Arg1::Scalar&, const typename Arg2::Scalar&,
+                                              const typename Arg3::Scalar&)>::type;
 
-  typedef typename internal::traits<Arg1>::StorageKind StorageKind;
-  typedef typename internal::traits<Arg1>::StorageIndex StorageIndex;
+  using StorageKind = typename internal::traits<Arg1>::StorageKind;
+  using StorageIndex = typename internal::traits<Arg1>::StorageIndex;
 
-  typedef typename Arg1::Nested Arg1Nested;
-  typedef typename Arg2::Nested Arg2Nested;
-  typedef typename Arg3::Nested Arg3Nested;
-  typedef std::remove_reference_t<Arg1Nested> Arg1Nested_;
-  typedef std::remove_reference_t<Arg2Nested> Arg2Nested_;
-  typedef std::remove_reference_t<Arg3Nested> Arg3Nested_;
+  using Arg1Nested = typename Arg1::Nested;
+  using Arg2Nested = typename Arg2::Nested;
+  using Arg3Nested = typename Arg3::Nested;
+  using Arg1Nested_ = std::remove_reference_t<Arg1Nested>;
+  using Arg2Nested_ = std::remove_reference_t<Arg2Nested>;
+  using Arg3Nested_ = std::remove_reference_t<Arg3Nested>;
   enum { Flags = Arg1Nested_::Flags & RowMajorBit };
 };
 }  // end namespace internal
@@ -57,7 +58,7 @@
  * \ingroup Core_Module
  *
  * \brief Generic expression where a coefficient-wise ternary operator is
- * applied to two expressions
+ * applied to three expressions
  *
  * \tparam TernaryOp template functor implementing the operator
  * \tparam Arg1Type the type of the first argument
@@ -85,32 +86,32 @@
                                                  typename internal::traits<Arg1Type>::StorageKind>,
                        internal::no_assignment_operator {
  public:
-  typedef internal::remove_all_t<Arg1Type> Arg1;
-  typedef internal::remove_all_t<Arg2Type> Arg2;
-  typedef internal::remove_all_t<Arg3Type> Arg3;
+  using Arg1 = internal::remove_all_t<Arg1Type>;
+  using Arg2 = internal::remove_all_t<Arg2Type>;
+  using Arg3 = internal::remove_all_t<Arg3Type>;
 
   // require the sizes to match
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg2)
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Arg1, Arg3)
 
   // The index types should match
-  EIGEN_STATIC_ASSERT((internal::is_same<typename internal::traits<Arg1Type>::StorageKind,
-                                         typename internal::traits<Arg2Type>::StorageKind>::value),
+  EIGEN_STATIC_ASSERT((std::is_same<typename internal::traits<Arg1Type>::StorageKind,
+                                    typename internal::traits<Arg2Type>::StorageKind>::value),
                       STORAGE_KIND_MUST_MATCH)
-  EIGEN_STATIC_ASSERT((internal::is_same<typename internal::traits<Arg1Type>::StorageKind,
-                                         typename internal::traits<Arg3Type>::StorageKind>::value),
+  EIGEN_STATIC_ASSERT((std::is_same<typename internal::traits<Arg1Type>::StorageKind,
+                                    typename internal::traits<Arg3Type>::StorageKind>::value),
                       STORAGE_KIND_MUST_MATCH)
 
-  typedef typename CwiseTernaryOpImpl<TernaryOp, Arg1Type, Arg2Type, Arg3Type,
-                                      typename internal::traits<Arg1Type>::StorageKind>::Base Base;
+  using Base = typename CwiseTernaryOpImpl<TernaryOp, Arg1Type, Arg2Type, Arg3Type,
+                                           typename internal::traits<Arg1Type>::StorageKind>::Base;
   EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseTernaryOp)
 
-  typedef typename internal::ref_selector<Arg1Type>::type Arg1Nested;
-  typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
-  typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
-  typedef std::remove_reference_t<Arg1Nested> Arg1Nested_;
-  typedef std::remove_reference_t<Arg2Nested> Arg2Nested_;
-  typedef std::remove_reference_t<Arg3Nested> Arg3Nested_;
+  using Arg1Nested = typename internal::ref_selector<Arg1Type>::type;
+  using Arg2Nested = typename internal::ref_selector<Arg2Type>::type;
+  using Arg3Nested = typename internal::ref_selector<Arg3Type>::type;
+  using Arg1Nested_ = std::remove_reference_t<Arg1Nested>;
+  using Arg2Nested_ = std::remove_reference_t<Arg2Nested>;
+  using Arg3Nested_ = std::remove_reference_t<Arg3Nested>;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CwiseTernaryOp(const Arg1& a1, const Arg2& a2, const Arg3& a3,
                                                        const TernaryOp& func = TernaryOp())
@@ -121,31 +122,33 @@
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Index rows() const {
     // return the fixed size type if available to enable compile time
     // optimizations
-    if (internal::traits<internal::remove_all_t<Arg1Nested>>::RowsAtCompileTime == Dynamic &&
-        internal::traits<internal::remove_all_t<Arg2Nested>>::RowsAtCompileTime == Dynamic)
+    EIGEN_IF_CONSTEXPR (internal::traits<internal::remove_all_t<Arg1Nested>>::RowsAtCompileTime == Dynamic &&
+                        internal::traits<internal::remove_all_t<Arg2Nested>>::RowsAtCompileTime == Dynamic) {
       return m_arg3.rows();
-    else if (internal::traits<internal::remove_all_t<Arg1Nested>>::RowsAtCompileTime == Dynamic &&
-             internal::traits<internal::remove_all_t<Arg3Nested>>::RowsAtCompileTime == Dynamic)
+    } else EIGEN_IF_CONSTEXPR (internal::traits<internal::remove_all_t<Arg1Nested>>::RowsAtCompileTime == Dynamic &&
+                               internal::traits<internal::remove_all_t<Arg3Nested>>::RowsAtCompileTime == Dynamic) {
       return m_arg2.rows();
-    else
+    } else {
       return m_arg1.rows();
+    }
   }
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Index cols() const {
     // return the fixed size type if available to enable compile time
     // optimizations
-    if (internal::traits<internal::remove_all_t<Arg1Nested>>::ColsAtCompileTime == Dynamic &&
-        internal::traits<internal::remove_all_t<Arg2Nested>>::ColsAtCompileTime == Dynamic)
+    EIGEN_IF_CONSTEXPR (internal::traits<internal::remove_all_t<Arg1Nested>>::ColsAtCompileTime == Dynamic &&
+                        internal::traits<internal::remove_all_t<Arg2Nested>>::ColsAtCompileTime == Dynamic) {
       return m_arg3.cols();
-    else if (internal::traits<internal::remove_all_t<Arg1Nested>>::ColsAtCompileTime == Dynamic &&
-             internal::traits<internal::remove_all_t<Arg3Nested>>::ColsAtCompileTime == Dynamic)
+    } else EIGEN_IF_CONSTEXPR (internal::traits<internal::remove_all_t<Arg1Nested>>::ColsAtCompileTime == Dynamic &&
+                               internal::traits<internal::remove_all_t<Arg3Nested>>::ColsAtCompileTime == Dynamic) {
       return m_arg2.cols();
-    else
+    } else {
       return m_arg1.cols();
+    }
   }
 
   /** \returns the first argument nested expression */
   EIGEN_DEVICE_FUNC constexpr const Arg1Nested_& arg1() const { return m_arg1; }
-  /** \returns the first argument nested expression */
+  /** \returns the second argument nested expression */
   EIGEN_DEVICE_FUNC constexpr const Arg2Nested_& arg2() const { return m_arg2; }
   /** \returns the third argument nested expression */
   EIGEN_DEVICE_FUNC constexpr const Arg3Nested_& arg3() const { return m_arg3; }
@@ -163,7 +166,7 @@
 template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3, typename StorageKind>
 class CwiseTernaryOpImpl : public internal::generic_xpr_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>::type {
  public:
-  typedef typename internal::generic_xpr_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>::type Base;
+  using Base = typename internal::generic_xpr_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>::type;
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/CwiseUnaryOp.h b/Eigen/src/Core/CwiseUnaryOp.h
index fabf4fc..bc095c8 100644
--- a/Eigen/src/Core/CwiseUnaryOp.h
+++ b/Eigen/src/Core/CwiseUnaryOp.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CWISE_UNARY_OP_H
 #define EIGEN_CWISE_UNARY_OP_H
@@ -19,9 +20,9 @@
 namespace internal {
 template <typename UnaryOp, typename XprType>
 struct traits<CwiseUnaryOp<UnaryOp, XprType> > : traits<XprType> {
-  typedef typename result_of<UnaryOp(const typename XprType::Scalar&)>::type Scalar;
-  typedef typename XprType::Nested XprTypeNested;
-  typedef std::remove_reference_t<XprTypeNested> XprTypeNested_;
+  using Scalar = typename result_of<UnaryOp(const typename XprType::Scalar&)>::type;
+  using XprTypeNested = typename XprType::Nested;
+  using XprTypeNested_ = std::remove_reference_t<XprTypeNested>;
   enum { Flags = XprTypeNested_::Flags & RowMajorBit };
 };
 }  // namespace internal
@@ -38,10 +39,11 @@
  * \tparam XprType the type of the expression to which we are applying the unary operator
  *
  * This class represents an expression where a unary operator is applied to an expression.
- * It is the return type of all operations taking exactly 1 input expression, regardless of the
- * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
- * is considered unary, because only the right-hand side is an expression, and its
- * return type is a specialization of CwiseUnaryOp.
+ * It is the return type of coefficient-wise operations taking a single input expression, such as unary negation
+ * or MatrixBase::unaryExpr(). Operators mixing an expression and a scalar, such as the operator* in the expression
+ * 3*matrix, are binary: the scalar is nested as a CwiseNullaryOp, so the return type is a specialization of
+ * CwiseBinaryOp. A scalar carried inside the functor does not make the expression binary; ArrayBase::pow(const
+ * ScalarExponent&) stores its exponent in the functor and still returns a CwiseUnaryOp.
  *
  * Most of the time, this is the only way that it is used, so you typically don't have to name
  * CwiseUnaryOp types explicitly.
@@ -52,10 +54,10 @@
 class CwiseUnaryOp : public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>,
                      internal::no_assignment_operator {
  public:
-  typedef typename CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>::Base Base;
+  using Base = typename CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>::Base;
   EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
-  typedef typename internal::ref_selector<XprType>::type XprTypeNested;
-  typedef internal::remove_all_t<XprType> NestedExpression;
+  using XprTypeNested = typename internal::ref_selector<XprType>::type;
+  using NestedExpression = internal::remove_all_t<XprType>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit CwiseUnaryOp(const XprType& xpr,
                                                                         const UnaryOp& func = UnaryOp())
@@ -87,7 +89,7 @@
 template <typename UnaryOp, typename XprType, typename StorageKind>
 class CwiseUnaryOpImpl : public internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type {
  public:
-  typedef typename internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
+  using Base = typename internal::generic_xpr_base<CwiseUnaryOp<UnaryOp, XprType>>::type;
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/CwiseUnaryView.h b/Eigen/src/Core/CwiseUnaryView.h
index 34546e8..e9b3848 100644
--- a/Eigen/src/Core/CwiseUnaryView.h
+++ b/Eigen/src/Core/CwiseUnaryView.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CWISE_UNARY_VIEW_H
 #define EIGEN_CWISE_UNARY_VIEW_H
@@ -18,17 +19,17 @@
 namespace internal {
 template <typename ViewOp, typename MatrixType, typename StrideType>
 struct traits<CwiseUnaryView<ViewOp, MatrixType, StrideType> > : traits<MatrixType> {
-  typedef typename result_of<ViewOp(typename traits<MatrixType>::Scalar&)>::type1 ScalarRef;
+  using ScalarRef = typename result_of<ViewOp(typename traits<MatrixType>::Scalar&)>::type1;
   static_assert(std::is_reference<ScalarRef>::value, "Views must return a reference type.");
-  typedef remove_all_t<ScalarRef> Scalar;
-  typedef typename MatrixType::Nested MatrixTypeNested;
-  typedef remove_all_t<MatrixTypeNested> MatrixTypeNested_;
+  using Scalar = remove_cvref_t<ScalarRef>;
+  using MatrixTypeNested = typename MatrixType::Nested;
+  using MatrixTypeNested_ = remove_all_t<MatrixTypeNested>;
   enum {
     FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
     Flags =
         traits<MatrixTypeNested_>::Flags &
         (RowMajorBit | FlagsLvalueBit | DirectAccessBit),  // FIXME DirectAccessBit should not be handled by expressions
-    MatrixTypeInnerStride = inner_stride_at_compile_time<MatrixType>::ret,
+    MatrixTypeInnerStride = inner_stride_at_compile_time<MatrixType>::value,
     // need to cast the sizeof's from size_t to int explicitly, otherwise:
     // "error: no integral type can represent all of the enumerator values
     InnerStrideAtCompileTime =
@@ -39,9 +40,9 @@
             : int(StrideType::InnerStrideAtCompileTime),
 
     OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
-                                   ? (outer_stride_at_compile_time<MatrixType>::ret == Dynamic
+                                   ? (outer_stride_at_compile_time<MatrixType>::value == Dynamic
                                           ? int(Dynamic)
-                                          : outer_stride_at_compile_time<MatrixType>::ret *
+                                          : outer_stride_at_compile_time<MatrixType>::value *
                                                 int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar)))
                                    : int(StrideType::OuterStrideAtCompileTime)
   };
@@ -52,15 +53,15 @@
           bool Mutable = !std::is_const<XprType>::value>
 class CwiseUnaryViewImpl : public generic_xpr_base<CwiseUnaryView<ViewOp, XprType, StrideType> >::type {
  public:
-  typedef typename generic_xpr_base<CwiseUnaryView<ViewOp, XprType, StrideType> >::type Base;
+  using Base = typename generic_xpr_base<CwiseUnaryView<ViewOp, XprType, StrideType>>::type;
 };
 
 template <typename ViewOp, typename MatrixType, typename StrideType>
 class CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType, Dense, false>
     : public dense_xpr_base<CwiseUnaryView<ViewOp, MatrixType, StrideType> >::type {
  public:
-  typedef CwiseUnaryView<ViewOp, MatrixType, StrideType> Derived;
-  typedef typename dense_xpr_base<CwiseUnaryView<ViewOp, MatrixType, StrideType> >::type Base;
+  using Derived = CwiseUnaryView<ViewOp, MatrixType, StrideType>;
+  using Base = typename dense_xpr_base<CwiseUnaryView<ViewOp, MatrixType, StrideType>>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryViewImpl)
 
@@ -95,11 +96,12 @@
 class CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType, Dense, true>
     : public CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType, Dense, false> {
  public:
-  typedef CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType, Dense, false> Base;
-  typedef CwiseUnaryView<ViewOp, MatrixType, StrideType> Derived;
+  using Base = CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType, Dense, false>;
+  using Derived = CwiseUnaryView<ViewOp, MatrixType, StrideType>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryViewImpl)
 
+  using Base::coeffRef;
   using Base::data;
   EIGEN_DEVICE_FUNC inline Scalar* data() { return &(this->coeffRef(0)); }
 
@@ -134,11 +136,11 @@
 class CwiseUnaryView : public internal::CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType,
                                                            typename internal::traits<MatrixType>::StorageKind> {
  public:
-  typedef typename internal::CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType,
-                                                typename internal::traits<MatrixType>::StorageKind>::Base Base;
+  using Base = typename internal::CwiseUnaryViewImpl<ViewOp, MatrixType, StrideType,
+                                                     typename internal::traits<MatrixType>::StorageKind>::Base;
   EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView)
-  typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
-  typedef internal::remove_all_t<MatrixType> NestedExpression;
+  using MatrixTypeNested = typename internal::ref_selector<MatrixType>::non_const_type;
+  using NestedExpression = internal::remove_all_t<MatrixType>;
 
   explicit EIGEN_DEVICE_FUNC constexpr inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = ViewOp())
       : m_matrix(mat), m_functor(func) {}
diff --git a/Eigen/src/Core/DenseBase.h b/Eigen/src/Core/DenseBase.h
index 4331a72..97703fb 100644
--- a/Eigen/src/Core/DenseBase.h
+++ b/Eigen/src/Core/DenseBase.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DENSEBASE_H
 #define EIGEN_DENSEBASE_H
@@ -46,9 +47,9 @@
   /** Inner iterator type to iterate over the coefficients of a row or column.
    * \sa class InnerIterator
    */
-  typedef Eigen::InnerIterator<Derived> InnerIterator;
+  using InnerIterator = Eigen::InnerIterator<Derived>;
 
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
 
   /**
    * \brief The type used to store indices
@@ -56,18 +57,18 @@
    *          PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index
    * \sa \blank \ref TopicPreprocessorDirectives, Eigen::Index, SparseMatrixBase.
    */
-  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+  using StorageIndex = typename internal::traits<Derived>::StorageIndex;
 
-  /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc. */
-  typedef typename internal::traits<Derived>::Scalar Scalar;
+  /** The numeric type of the expression's coefficients, e.g. float, double, int or std::complex<float>, etc. */
+  using Scalar = typename internal::traits<Derived>::Scalar;
 
-  /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+  /** The numeric type of the expression's coefficients, e.g. float, double, int or std::complex<float>, etc.
    *
    * It is an alias for the Scalar type */
-  typedef Scalar value_type;
+  using value_type = Scalar;
 
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value> Base;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Base = DenseCoeffsBase<Derived, internal::accessors_level<Derived>::value>;
 
   using Base::coeff;
   using Base::coeffByOuterInner;
@@ -89,7 +90,7 @@
   using Base::x;
   using Base::y;
   using Base::z;
-  typedef typename Base::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename Base::CoeffReturnType;
 
   enum {
 
@@ -105,7 +106,7 @@
      * it is set to the \a Dynamic constant.
      * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
 
-    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::ret),
+    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::value),
     /**< This is equal to the number of coefficients, i.e. the number of
      * rows times the number of columns, or to \a Dynamic if this is not
      * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
@@ -169,29 +170,29 @@
                              : int(IsRowMajor)          ? int(ColsAtCompileTime)
                                                         : int(RowsAtCompileTime),
 
-    InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret,
-    OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret
+    InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::value,
+    OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::value
   };
 
-  typedef typename internal::find_best_packet<Scalar, SizeAtCompileTime>::type PacketScalar;
+  using PacketScalar = typename internal::find_best_packet<Scalar, SizeAtCompileTime>::type;
 
   enum { IsPlainObjectBase = 0 };
 
   /** The plain matrix type corresponding to this expression.
    * \sa PlainObject */
-  typedef Matrix<typename internal::traits<Derived>::Scalar, internal::traits<Derived>::RowsAtCompileTime,
-                 internal::traits<Derived>::ColsAtCompileTime,
-                 AutoAlign | (internal::traits<Derived>::Flags & RowMajorBit ? RowMajor : ColMajor),
-                 internal::traits<Derived>::MaxRowsAtCompileTime, internal::traits<Derived>::MaxColsAtCompileTime>
-      PlainMatrix;
+  using PlainMatrix =
+      Matrix<typename internal::traits<Derived>::Scalar, internal::traits<Derived>::RowsAtCompileTime,
+             internal::traits<Derived>::ColsAtCompileTime,
+             AutoAlign | (internal::traits<Derived>::Flags & RowMajorBit ? RowMajor : ColMajor),
+             internal::traits<Derived>::MaxRowsAtCompileTime, internal::traits<Derived>::MaxColsAtCompileTime>;
 
   /** The plain array type corresponding to this expression.
    * \sa PlainObject */
-  typedef Array<typename internal::traits<Derived>::Scalar, internal::traits<Derived>::RowsAtCompileTime,
-                internal::traits<Derived>::ColsAtCompileTime,
-                AutoAlign | (internal::traits<Derived>::Flags & RowMajorBit ? RowMajor : ColMajor),
-                internal::traits<Derived>::MaxRowsAtCompileTime, internal::traits<Derived>::MaxColsAtCompileTime>
-      PlainArray;
+  using PlainArray =
+      Array<typename internal::traits<Derived>::Scalar, internal::traits<Derived>::RowsAtCompileTime,
+            internal::traits<Derived>::ColsAtCompileTime,
+            AutoAlign | (internal::traits<Derived>::Flags & RowMajorBit ? RowMajor : ColMajor),
+            internal::traits<Derived>::MaxRowsAtCompileTime, internal::traits<Derived>::MaxColsAtCompileTime>;
 
   /** \brief The plain matrix or array type corresponding to this expression.
    *
@@ -199,9 +200,8 @@
    * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed
    * that the return type of eval() is either PlainObject or const PlainObject&.
    */
-  typedef std::conditional_t<internal::is_same<typename internal::traits<Derived>::XprKind, MatrixXpr>::value,
-                             PlainMatrix, PlainArray>
-      PlainObject;
+  using PlainObject = std::conditional_t<std::is_same<typename internal::traits<Derived>::XprKind, MatrixXpr>::value,
+                                         PlainMatrix, PlainArray>;
 
   /** \returns the outer size.
    *
@@ -242,19 +242,18 @@
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   /** \internal Represents a matrix with all coefficients equal to one another*/
-  typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> ConstantReturnType;
+  using ConstantReturnType = CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>;
   /** \internal Represents a matrix with all coefficients equal to zero*/
-  typedef CwiseNullaryOp<internal::scalar_zero_op<Scalar>, PlainObject> ZeroReturnType;
+  using ZeroReturnType = CwiseNullaryOp<internal::scalar_zero_op<Scalar>, PlainObject>;
   /** \internal \deprecated Represents a vector with linearly spaced coefficients that allows sequential access only. */
   EIGEN_DEPRECATED typedef CwiseNullaryOp<internal::linspaced_op<Scalar>, PlainObject> SequentialLinSpacedReturnType;
   /** \internal Represents a vector with linearly spaced coefficients that allows random access. */
-  typedef CwiseNullaryOp<internal::linspaced_op<Scalar>, PlainObject> RandomAccessLinSpacedReturnType;
+  using RandomAccessLinSpacedReturnType = CwiseNullaryOp<internal::linspaced_op<Scalar>, PlainObject>;
   /** \internal Represents a vector with equally spaced coefficients that allows random access. */
-  typedef CwiseNullaryOp<internal::equalspaced_op<Scalar>, PlainObject> RandomAccessEqualSpacedReturnType;
+  using RandomAccessEqualSpacedReturnType = CwiseNullaryOp<internal::equalspaced_op<Scalar>, PlainObject>;
   /** \internal the return type of MatrixBase::eigenvalues() */
-  typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real,
-                 internal::traits<Derived>::ColsAtCompileTime, 1>
-      EigenvaluesReturnType;
+  using EigenvaluesReturnType = Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real,
+                                       internal::traits<Derived>::ColsAtCompileTime, 1>;
 
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
@@ -296,9 +295,9 @@
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC CommaInitializer<Derived> operator<<(const DenseBase<OtherDerived>& other);
 
-  typedef Transpose<Derived> TransposeReturnType;
+  using TransposeReturnType = Transpose<Derived>;
   EIGEN_DEVICE_FUNC TransposeReturnType transpose();
-  typedef Transpose<const Derived> ConstTransposeReturnType;
+  using ConstTransposeReturnType = Transpose<const Derived>;
   EIGEN_DEVICE_FUNC const ConstTransposeReturnType transpose() const;
   EIGEN_DEVICE_FUNC void transposeInPlace();
 
@@ -374,7 +373,7 @@
   template <bool Enable = internal::complex_array_access<Scalar>::value, typename = std::enable_if_t<Enable>>
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Derived& operator/=(const RealScalar& other);
 
-  typedef internal::add_const_on_value_type_t<typename internal::eval<Derived>::type> EvalReturnType;
+  using EvalReturnType = internal::add_const_on_value_type_t<typename internal::eval<Derived>::type>;
   /** \returns the matrix or vector obtained by evaluating this expression.
    *
    * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
@@ -410,13 +409,6 @@
   }
 
   EIGEN_DEVICE_FUNC constexpr inline const NestByValue<Derived> nestByValue() const;
-  EIGEN_DEVICE_FUNC inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
-  EIGEN_DEVICE_FUNC inline ForceAlignedAccess<Derived> forceAlignedAccess();
-  template <bool Enable>
-  EIGEN_DEVICE_FUNC inline const std::conditional_t<Enable, ForceAlignedAccess<Derived>, Derived&>
-  forceAlignedAccessIf() const;
-  template <bool Enable>
-  EIGEN_DEVICE_FUNC inline std::conditional_t<Enable, ForceAlignedAccess<Derived>, Derived&> forceAlignedAccessIf();
 
   EIGEN_DEVICE_FUNC Scalar sum() const;
   EIGEN_DEVICE_FUNC Scalar mean() const;
@@ -424,48 +416,21 @@
 
   EIGEN_DEVICE_FUNC Scalar prod() const;
 
-  template <int NaNPropagation>
+  // The default PropagateFast gives undefined behavior on NaN inputs but the fastest code.
+  template <int NaNPropagation = PropagateFast>
   EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
-  template <int NaNPropagation>
+  template <int NaNPropagation = PropagateFast>
   EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;
 
-  // By default, the fastest version with undefined NaN propagation semantics is
-  // used.
-  // TODO(rmlarsen): Replace with default template argument (C++14 is now the minimum standard).
-  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff() const {
-    return minCoeff<PropagateFast>();
-  }
-  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff() const {
-    return maxCoeff<PropagateFast>();
-  }
-
-  template <int NaNPropagation, typename IndexType>
+  template <int NaNPropagation = PropagateFast, typename IndexType>
   EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
-  template <int NaNPropagation, typename IndexType>
+  template <int NaNPropagation = PropagateFast, typename IndexType>
   EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const;
-  template <int NaNPropagation, typename IndexType>
+  template <int NaNPropagation = PropagateFast, typename IndexType>
   EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const;
-  template <int NaNPropagation, typename IndexType>
+  template <int NaNPropagation = PropagateFast, typename IndexType>
   EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
 
-  // TODO(rmlarsen): Replace these methods with a default template argument (C++14 is now the minimum standard).
-  template <typename IndexType>
-  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const {
-    return minCoeff<PropagateFast>(row, col);
-  }
-  template <typename IndexType>
-  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff(IndexType* row, IndexType* col) const {
-    return maxCoeff<PropagateFast>(row, col);
-  }
-  template <typename IndexType>
-  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar minCoeff(IndexType* index) const {
-    return minCoeff<PropagateFast>(index);
-  }
-  template <typename IndexType>
-  EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const {
-    return maxCoeff<PropagateFast>(index);
-  }
-
   template <typename BinaryOp>
   EIGEN_DEVICE_FUNC Scalar redux(const BinaryOp& func) const;
 
@@ -491,10 +456,10 @@
   EIGEN_DEVICE_FUNC bool any() const;
   EIGEN_DEVICE_FUNC Index count() const;
 
-  typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
-  typedef const VectorwiseOp<const Derived, Horizontal> ConstRowwiseReturnType;
-  typedef VectorwiseOp<Derived, Vertical> ColwiseReturnType;
-  typedef const VectorwiseOp<const Derived, Vertical> ConstColwiseReturnType;
+  using RowwiseReturnType = VectorwiseOp<Derived, Horizontal>;
+  using ConstRowwiseReturnType = const VectorwiseOp<const Derived, Horizontal>;
+  using ColwiseReturnType = VectorwiseOp<Derived, Vertical>;
+  using ConstColwiseReturnType = const VectorwiseOp<const Derived, Vertical>;
 
   /** \returns a VectorwiseOp wrapper of *this for broadcasting and partial reductions
    *
@@ -517,7 +482,7 @@
   EIGEN_DEVICE_FUNC inline ConstColwiseReturnType colwise() const { return ConstColwiseReturnType(derived()); }
   EIGEN_DEVICE_FUNC ColwiseReturnType colwise();
 
-  typedef CwiseNullaryOp<internal::scalar_random_op<Scalar>, PlainObject> RandomReturnType;
+  using RandomReturnType = CwiseNullaryOp<internal::scalar_random_op<Scalar>, PlainObject>;
   static const RandomReturnType Random(Index rows, Index cols);
   static const RandomReturnType Random(Index size);
   static const RandomReturnType Random();
@@ -561,8 +526,8 @@
     return Replicate<Derived, Dynamic, Dynamic>(derived(), rowFactor, colFactor);
   }
 
-  typedef Reverse<Derived, BothDirections> ReverseReturnType;
-  typedef const Reverse<const Derived, BothDirections> ConstReverseReturnType;
+  using ReverseReturnType = Reverse<Derived, BothDirections>;
+  using ConstReverseReturnType = const Reverse<const Derived, BothDirections>;
   EIGEN_DEVICE_FUNC ReverseReturnType reverse();
   /** This is the const version of reverse(). */
   // Code moved here due to a CUDA compiler bug
@@ -577,21 +542,19 @@
   /** This is the const version of iterator (aka read-only) */
   typedef random_access_iterator_type const_iterator;
 #else
-  typedef std::conditional_t<(Flags & DirectAccessBit) == DirectAccessBit,
-                             internal::pointer_based_stl_iterator<Derived>,
-                             internal::generic_randaccess_stl_iterator<Derived>>
-      iterator_type;
+  using iterator_type =
+      std::conditional_t<(Flags & DirectAccessBit) == DirectAccessBit, internal::pointer_based_stl_iterator<Derived>,
+                         internal::generic_randaccess_stl_iterator<Derived>>;
 
-  typedef std::conditional_t<(Flags & DirectAccessBit) == DirectAccessBit,
-                             internal::pointer_based_stl_iterator<const Derived>,
-                             internal::generic_randaccess_stl_iterator<const Derived>>
-      const_iterator_type;
+  using const_iterator_type = std::conditional_t<(Flags & DirectAccessBit) == DirectAccessBit,
+                                                 internal::pointer_based_stl_iterator<const Derived>,
+                                                 internal::generic_randaccess_stl_iterator<const Derived>>;
 
   // Stl-style iterators are supported only for vectors.
 
-  typedef std::conditional_t<IsVectorAtCompileTime, iterator_type, void> iterator;
+  using iterator = std::conditional_t<IsVectorAtCompileTime, iterator_type, void>;
 
-  typedef std::conditional_t<IsVectorAtCompileTime, const_iterator_type, void> const_iterator;
+  using const_iterator = std::conditional_t<IsVectorAtCompileTime, const_iterator_type, void>;
 #endif
 
   inline iterator begin();
@@ -605,7 +568,25 @@
   using ConstRealViewReturnType =
       std::conditional_t<NumTraits<Scalar>::IsComplex, RealView<const Derived>, const Derived&>;
 
+  /// \returns an expression of the real and imaginary parts of \c *this as a real expression,
+  /// twice as large along the inner dimension, holding the components interleaved in storage
+  /// order. For a real \c *this it is the identity and returns \c *this itself, so everything
+  /// below concerns a complex \c *this.
+  ///
+  /// real() and imag() build a view that is not packet accessible, so a reduction over either
+  /// runs coefficient by coefficient. This view instead keeps whichever of linear access,
+  /// packet access and writability \c *this itself provides, so where \c *this supplies them
+  /// an operation that treats the components alike should prefer it:
+  /// \code m.realView().cwiseAbs().maxCoeff() \endcode
+  /// covers both components in a single vectorized pass. Operations that must distinguish the
+  /// components, or that need only one of them, still require real()/imag().
+  ///
+  /// Writing through the returned expression additionally requires the scalar type to be
+  /// std::complex, whose storage the standard fixes as its two components interleaved.
+  ///
+  /// \sa real(), imag()
   EIGEN_DEVICE_FUNC RealViewReturnType realView();
+  /// This is the const version of realView().
   EIGEN_DEVICE_FUNC ConstRealViewReturnType realView() const;
 
 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase
@@ -614,6 +595,7 @@
 #define EIGEN_DOC_UNARY_ADDONS(X, Y)
 #include "../plugins/CommonCwiseUnaryOps.inc"
 #include "../plugins/BlockMethods.inc"
+// Defines operator()(const RowIndices&, const ColIndices&) and other indexed view methods.
 #include "../plugins/IndexedViewMethods.inc"
 #include "../plugins/ReshapedMethods.inc"
 #ifdef EIGEN_DENSEBASE_PLUGIN
@@ -627,7 +609,7 @@
   // disable the use of evalTo for dense objects with a nice compilation error
   template <typename Dest>
   EIGEN_DEVICE_FUNC inline void evalTo(Dest&) const {
-    EIGEN_STATIC_ASSERT((internal::is_same<Dest, void>::value),
+    EIGEN_STATIC_ASSERT((std::is_same<Dest, void>::value),
                         THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
   }
 
diff --git a/Eigen/src/Core/DenseCoeffsBase.h b/Eigen/src/Core/DenseCoeffsBase.h
index c528416..e78c423 100644
--- a/Eigen/src/Core/DenseCoeffsBase.h
+++ b/Eigen/src/Core/DenseCoeffsBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DENSECOEFFSBASE_H
 #define EIGEN_DENSECOEFFSBASE_H
@@ -15,13 +16,6 @@
 
 namespace Eigen {
 
-namespace internal {
-template <typename T>
-struct add_const_on_value_type_if_arithmetic {
-  typedef std::conditional_t<is_arithmetic<T>::value, T, add_const_on_value_type_t<T>> type;
-};
-}  // namespace internal
-
 /** \brief Base class providing read-only coefficient access to matrices and arrays.
  * \ingroup Core_Module
  * \tparam Derived Type of the derived class
@@ -37,9 +31,9 @@
 template <typename Derived>
 class DenseCoeffsBase<Derived, ReadOnlyAccessors> : public EigenBase<Derived> {
  public:
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
 
   // Explanation for this CoeffReturnType typedef.
   // - This is the return type of the coeff() method.
@@ -54,14 +48,14 @@
   // - The is_arithmetic check is required since "const int", "const double", etc. will cause warnings on some systems
   // while the declaration of "const T", where T is a non arithmetic type does not. Always returning "const Scalar&" is
   // not possible, since the underlying expressions might not offer a valid address the reference could be referring to.
-  typedef std::conditional_t<bool(internal::traits<Derived>::Flags&(LvalueBit | DirectAccessBit)), const Scalar&,
-                             std::conditional_t<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>>
-      CoeffReturnType;
+  using CoeffReturnType =
+      std::conditional_t<bool(internal::traits<Derived>::Flags&(LvalueBit | DirectAccessBit)), const Scalar&,
+                         std::conditional_t<internal::is_arithmetic<Scalar>::value, Scalar, const Scalar>>;
 
-  typedef typename internal::add_const_on_value_type_if_arithmetic<typename internal::packet_traits<Scalar>::type>::type
-      PacketReturnType;
+  using PacketReturnType = std::conditional_t<internal::is_arithmetic<PacketScalar>::value, PacketScalar,
+                                              internal::add_const_on_value_type_t<PacketScalar>>;
 
-  typedef EigenBase<Derived> Base;
+  using Base = EigenBase<Derived>;
   using Base::cols;
   using Base::derived;
   using Base::rows;
@@ -104,7 +98,7 @@
     return coeff(rowIndexByOuterInner(outer, inner), colIndexByOuterInner(outer, inner));
   }
 
-  /** \returns the coefficient at given the given row and column.
+  /** \returns the coefficient at the given row and column.
    *
    * \sa operator()(Index,Index), operator[](Index)
    */
@@ -114,7 +108,7 @@
   }
 
 #ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
-  /** \returns the coefficient at given the given row and column.
+  /** \returns the coefficient at the given row and column.
    *
    * \sa operator[](Index,Index), operator[](Index)
    */
@@ -145,7 +139,8 @@
 
   /** \returns the coefficient at given index.
    *
-   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+   * This method is allowed only for expressions that are vectors at compile time. For matrix expressions having the
+   * LinearAccessBit, use operator()(Index) instead.
    *
    * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
    * z() const, w() const
@@ -160,9 +155,9 @@
 
   /** \returns the coefficient at given index.
    *
-   * This is synonymous to operator[](Index) const.
+   * For expressions that are vectors at compile time, this is synonymous to operator[](Index) const.
    *
-   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+   * This method is allowed only for expressions having the LinearAccessBit.
    *
    * \sa operator[](Index), operator()(Index,Index) const, x() const, y() const,
    * z() const, w() const
@@ -210,7 +205,7 @@
 
   template <int LoadMode>
   EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const {
-    typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+    using DefaultPacketType = typename internal::packet_traits<Scalar>::type;
     eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
     return internal::evaluator<Derived>(derived()).template packet<LoadMode, DefaultPacketType>(row, col);
   }
@@ -235,7 +230,7 @@
   EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
     EIGEN_STATIC_ASSERT(internal::evaluator<Derived>::Flags & LinearAccessBit,
                         THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS)
-    typedef typename internal::packet_traits<Scalar>::type DefaultPacketType;
+    using DefaultPacketType = typename internal::packet_traits<Scalar>::type;
     eigen_internal_assert(index >= 0 && index < size());
     return internal::evaluator<Derived>(derived()).template packet<LoadMode, DefaultPacketType>(index);
   }
@@ -276,12 +271,12 @@
 template <typename Derived>
 class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors> {
  public:
-  typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
+  using Base = DenseCoeffsBase<Derived, ReadOnlyAccessors>;
 
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   using Base::coeff;
   using Base::colIndexByOuterInner;
@@ -320,7 +315,7 @@
     return coeffRef(rowIndexByOuterInner(outer, inner), colIndexByOuterInner(outer, inner));
   }
 
-  /** \returns a reference to the coefficient at given the given row and column.
+  /** \returns a reference to the coefficient at the given row and column.
    *
    * \sa operator[](Index)
    */
@@ -330,7 +325,7 @@
   }
 
 #ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
-  /** \returns a reference to the coefficient at given the given row and column.
+  /** \returns a reference to the coefficient at the given row and column.
    *
    * \sa operator[](Index)
    */
@@ -361,7 +356,8 @@
 
   /** \returns a reference to the coefficient at given index.
    *
-   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+   * This method is allowed only for expressions that are vectors at compile time. For matrix expressions having the
+   * LinearAccessBit, use operator()(Index) instead.
    *
    * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
    */
@@ -375,9 +371,9 @@
 
   /** \returns a reference to the coefficient at given index.
    *
-   * This is synonymous to operator[](Index).
+   * For expressions that are vectors at compile time, this is synonymous to operator[](Index).
    *
-   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
+   * This method is allowed only for expressions having the LinearAccessBit.
    *
    * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
    */
@@ -428,9 +424,9 @@
 template <typename Derived>
 class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived, ReadOnlyAccessors> {
  public:
-  typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using Base = DenseCoeffsBase<Derived, ReadOnlyAccessors>;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   using Base::cols;
   using Base::derived;
@@ -481,9 +477,9 @@
 template <typename Derived>
 class DenseCoeffsBase<Derived, DirectWriteAccessors> : public DenseCoeffsBase<Derived, WriteAccessors> {
  public:
-  typedef DenseCoeffsBase<Derived, WriteAccessors> Base;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using Base = DenseCoeffsBase<Derived, WriteAccessors>;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   using Base::cols;
   using Base::derived;
@@ -551,30 +547,22 @@
 
 template <typename Derived>
 static inline Index first_default_aligned(const DenseBase<Derived>& m) {
-  typedef typename Derived::Scalar Scalar;
-  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  using Scalar = typename Derived::Scalar;
+  using DefaultPacketType = typename packet_traits<Scalar>::type;
   return internal::first_aligned<int(unpacket_traits<DefaultPacketType>::alignment), Derived>(m);
 }
 
-template <typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
-struct inner_stride_at_compile_time {
-  enum { ret = traits<Derived>::InnerStrideAtCompileTime };
-};
+template <typename Derived, bool HasDirectAccess = has_direct_access<Derived>::value>
+struct inner_stride_at_compile_time : std::integral_constant<int, traits<Derived>::InnerStrideAtCompileTime> {};
 
 template <typename Derived>
-struct inner_stride_at_compile_time<Derived, false> {
-  enum { ret = 0 };
-};
+struct inner_stride_at_compile_time<Derived, false> : std::integral_constant<int, 0> {};
 
-template <typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret>
-struct outer_stride_at_compile_time {
-  enum { ret = traits<Derived>::OuterStrideAtCompileTime };
-};
+template <typename Derived, bool HasDirectAccess = has_direct_access<Derived>::value>
+struct outer_stride_at_compile_time : std::integral_constant<int, traits<Derived>::OuterStrideAtCompileTime> {};
 
 template <typename Derived>
-struct outer_stride_at_compile_time<Derived, false> {
-  enum { ret = 0 };
-};
+struct outer_stride_at_compile_time<Derived, false> : std::integral_constant<int, 0> {};
 
 }  // end namespace internal
 
diff --git a/Eigen/src/Core/DenseStorage.h b/Eigen/src/Core/DenseStorage.h
index 2892127..9438158 100644
--- a/Eigen/src/Core/DenseStorage.h
+++ b/Eigen/src/Core/DenseStorage.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIXSTORAGE_H
 #define EIGEN_MATRIXSTORAGE_H
@@ -131,7 +132,7 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage_impl(Index size, Index rows, Index /*cols*/)
       : m_rows(rows) {
     EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
-    EIGEN_UNUSED_VARIABLE(size)
+    EIGEN_UNUSED_VARIABLE(size);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage_impl& operator=(const DenseStorage_impl& other) {
     smart_copy(other.m_data.array, other.m_data.array + other.size(), m_data.array);
@@ -165,7 +166,7 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage_impl(Index size, Index /*rows*/, Index cols)
       : m_cols(cols) {
     EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
-    EIGEN_UNUSED_VARIABLE(size)
+    EIGEN_UNUSED_VARIABLE(size);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage_impl& operator=(const DenseStorage_impl& other) {
     smart_copy(other.m_data.array, other.m_data.array + other.size(), m_data.array);
@@ -200,7 +201,7 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage_impl(Index size, Index rows, Index cols)
       : m_rows(rows), m_cols(cols) {
     EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
-    EIGEN_UNUSED_VARIABLE(size)
+    EIGEN_UNUSED_VARIABLE(size);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr DenseStorage_impl& operator=(const DenseStorage_impl& other) {
     smart_copy(other.m_data.array, other.m_data.array + other.size(), m_data.array);
@@ -496,7 +497,7 @@
 
 /** \internal
  *
- * \class DenseStorage_impl
+ * \class DenseStorage
  * \ingroup Core_Module
  *
  * \brief Stores the data of a matrix
@@ -543,4 +544,4 @@
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_MATRIX_H
+#endif  // EIGEN_MATRIXSTORAGE_H
diff --git a/Eigen/src/Core/DeviceWrapper.h b/Eigen/src/Core/DeviceWrapper.h
index 1a326ae..8219b6d 100644
--- a/Eigen/src/Core/DeviceWrapper.h
+++ b/Eigen/src/Core/DeviceWrapper.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DEVICEWRAPPER_H
 #define EIGEN_DEVICEWRAPPER_H
@@ -69,7 +70,7 @@
   }
 };
 
-// specialization for coeffcient-wise assignment
+// specialization for coefficient-wise assignment
 template <typename DstXprType, typename SrcXprType, typename Functor, typename Device, typename Weak>
 struct AssignmentWithDevice<DstXprType, SrcXprType, Functor, Device, Dense2Dense, Weak> {
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src, const Functor& func,
@@ -107,7 +108,7 @@
   // TODO: check whether this is the right place to perform these checks:
   EIGEN_STATIC_ASSERT_LVALUE(Dst)
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(ActualDstTypeCleaned, Src)
-  EIGEN_CHECK_BINARY_COMPATIBILIY(Func, typename ActualDstTypeCleaned::Scalar, typename Src::Scalar);
+  EIGEN_CHECK_BINARY_COMPATIBILITY(Func, typename ActualDstTypeCleaned::Scalar, typename Src::Scalar);
 
   // this provides a mechanism for specializing simple assignments, matrix products, etc
   AssignmentWithDevice<ActualDstTypeCleaned, Src, Func, Device>::run(actualDst, src, func, dst.device());
diff --git a/Eigen/src/Core/Diagonal.h b/Eigen/src/Core/Diagonal.h
index 61a4784..2d35569 100644
--- a/Eigen/src/Core/Diagonal.h
+++ b/Eigen/src/Core/Diagonal.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DIAGONAL_H
 #define EIGEN_DIAGONAL_H
@@ -38,9 +39,9 @@
 namespace internal {
 template <typename MatrixType, int DiagIndex>
 struct traits<Diagonal<MatrixType, DiagIndex> > : traits<MatrixType> {
-  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNested_;
-  typedef typename MatrixType::StorageKind StorageKind;
+  using MatrixTypeNested = typename ref_selector<MatrixType>::type;
+  using MatrixTypeNested_ = std::remove_reference_t<MatrixTypeNested>;
+  using StorageKind = typename MatrixType::StorageKind;
   enum {
     RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic)
                             ? Dynamic
@@ -55,20 +56,29 @@
                               MatrixType::MaxColsAtCompileTime - plain_enum_max(DiagIndex, 0))),
     MaxColsAtCompileTime = 1,
     MaskLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
-    Flags = (unsigned int)MatrixTypeNested_::Flags & (RowMajorBit | MaskLvalueBit | DirectAccessBit) &
-            ~RowMajorBit,  // FIXME DirectAccessBit should not be handled by expressions
-    MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::ret,
-    InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride + 1,
+    Flags = (unsigned int)MatrixTypeNested_::Flags &
+            (MaskLvalueBit | DirectAccessBit),  // FIXME DirectAccessBit should not be handled by expressions
+    MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::value,
     OuterStrideAtCompileTime = 0
   };
+  static constexpr int MatrixTypeInnerStride = inner_stride_at_compile_time<MatrixType>::value;
+  static constexpr int InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic || MatrixTypeInnerStride == Dynamic
+                                                      ? Dynamic
+                                                      : MatrixTypeOuterStride + MatrixTypeInnerStride;
 };
+
+template <typename MatrixType, int DiagIndex>
+constexpr int traits<Diagonal<MatrixType, DiagIndex>>::MatrixTypeInnerStride;
+
+template <typename MatrixType, int DiagIndex>
+constexpr int traits<Diagonal<MatrixType, DiagIndex>>::InnerStrideAtCompileTime;
 }  // namespace internal
 
 template <typename MatrixType, int DiagIndex_>
 class Diagonal : public internal::dense_xpr_base<Diagonal<MatrixType, DiagIndex_> >::type {
  public:
   enum { DiagIndex = DiagIndex_ };
-  typedef typename internal::dense_xpr_base<Diagonal>::type Base;
+  using Base = typename internal::dense_xpr_base<Diagonal>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal)
 
   EIGEN_DEVICE_FUNC constexpr explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex)
@@ -85,11 +95,13 @@
 
   EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return 1; }
 
-  EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept { return m_matrix.outerStride() + 1; }
+  EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept {
+    return m_matrix.outerStride() + m_matrix.innerStride();
+  }
 
   EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return 0; }
 
-  typedef std::conditional_t<internal::is_lvalue<MatrixType>::value, Scalar, const Scalar> ScalarWithConstIfNotLvalue;
+  using ScalarWithConstIfNotLvalue = std::conditional_t<internal::is_lvalue<MatrixType>::value, Scalar, const Scalar>;
 
   EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() {
     return rows() > 0 ? &(m_matrix.coeffRef(rowOffset(), colOffset())) : nullptr;
@@ -137,9 +149,6 @@
 
  private:
   // some compilers may fail to optimize std::max etc in case of compile-time constants...
-  EIGEN_DEVICE_FUNC constexpr Index absDiagIndex() const noexcept {
-    return m_index.value() > 0 ? m_index.value() : -m_index.value();
-  }
   EIGEN_DEVICE_FUNC constexpr Index rowOffset() const noexcept { return m_index.value() > 0 ? 0 : -m_index.value(); }
   EIGEN_DEVICE_FUNC constexpr Index colOffset() const noexcept { return m_index.value() > 0 ? m_index.value() : 0; }
   // trigger a compile-time error if someone try to call packet
diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h
index c14d081..989cbba 100644
--- a/Eigen/src/Core/DiagonalMatrix.h
+++ b/Eigen/src/Core/DiagonalMatrix.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DIAGONALMATRIX_H
 #define EIGEN_DIAGONALMATRIX_H
@@ -32,11 +33,11 @@
 template <typename Derived>
 class DiagonalBase : public EigenBase<Derived> {
  public:
-  typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType;
-  typedef typename DiagonalVectorType::Scalar Scalar;
-  typedef typename DiagonalVectorType::RealScalar RealScalar;
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+  using DiagonalVectorType = typename internal::traits<Derived>::DiagonalVectorType;
+  using Scalar = typename DiagonalVectorType::Scalar;
+  using RealScalar = typename DiagonalVectorType::RealScalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using StorageIndex = typename internal::traits<Derived>::StorageIndex;
 
   enum {
     RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
@@ -47,15 +48,15 @@
     Flags = NoPreferredStorageOrderBit
   };
 
-  typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>
-      DenseMatrixType;
-  typedef DenseMatrixType DenseType;
-  typedef DiagonalMatrix<Scalar, DiagonalVectorType::SizeAtCompileTime, DiagonalVectorType::MaxSizeAtCompileTime>
-      PlainObject;
+  using DenseMatrixType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+  using DenseType = DenseMatrixType;
+  using PlainObject =
+      DiagonalMatrix<Scalar, DiagonalVectorType::SizeAtCompileTime, DiagonalVectorType::MaxSizeAtCompileTime>;
 
-  /** \returns a reference to the derived object. */
-  EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
   /** \returns a const reference to the derived object. */
+  EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+  /** \returns a reference to the derived object. */
   EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
 
   /**
@@ -64,14 +65,14 @@
    * \returns A dense matrix, with its diagonal entries set from the derived object. */
   EIGEN_DEVICE_FUNC DenseMatrixType toDenseMatrix() const { return derived(); }
 
-  /** \returns a reference to the derived object's vector of diagonal coefficients. */
-  EIGEN_DEVICE_FUNC inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
   /** \returns a const reference to the derived object's vector of diagonal coefficients. */
+  EIGEN_DEVICE_FUNC inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
+  /** \returns a reference to the derived object's vector of diagonal coefficients. */
   EIGEN_DEVICE_FUNC inline DiagonalVectorType& diagonal() { return derived().diagonal(); }
 
   /** \returns the value of the coefficient as if \c *this was a dense matrix. */
   EIGEN_DEVICE_FUNC inline Scalar coeff(Index row, Index col) const {
-    eigen_assert(row >= 0 && col >= 0 && row < rows() && col <= cols());
+    eigen_assert(row >= 0 && col >= 0 && row < rows() && col < cols());
     return row == col ? diagonal().coeff(row) : Scalar(0);
   }
 
@@ -89,7 +90,7 @@
 
   template <typename OtherDerived>
   using DiagonalProductReturnType = DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(
-      DiagonalVectorType, typename OtherDerived::DiagonalVectorType, product)>;
+      DiagonalVectorType, typename OtherDerived::DiagonalVectorType, internal::scalar_product_op)>;
 
   /** \returns the diagonal matrix product of \c *this by the diagonal matrix \a other */
   template <typename OtherDerived>
@@ -101,21 +102,21 @@
   using DiagonalInverseReturnType =
       DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType>>;
 
-  /** \returns the inverse \c *this. Computed as the coefficient-wise inverse of the diagonal. */
+  /** \returns the inverse of \c *this. Computed as the coefficient-wise inverse of the diagonal. */
   EIGEN_DEVICE_FUNC inline const DiagonalInverseReturnType inverse() const {
     return diagonal().cwiseInverse().asDiagonal();
   }
 
-  using DiagonalScaleReturnType =
-      DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType, Scalar, product)>;
+  using DiagonalScaleReturnType = DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(
+      DiagonalVectorType, Scalar, internal::scalar_product_op)>;
 
   /** \returns the product of \c *this by the scalar \a scalar */
   EIGEN_DEVICE_FUNC inline const DiagonalScaleReturnType operator*(const Scalar& scalar) const {
     return (diagonal() * scalar).asDiagonal();
   }
 
-  using ScaleDiagonalReturnType =
-      DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar, DiagonalVectorType, product)>;
+  using ScaleDiagonalReturnType = DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(
+      Scalar, DiagonalVectorType, internal::scalar_product_op)>;
 
   /** \returns the product of a scalar and the diagonal matrix \a other */
   EIGEN_DEVICE_FUNC friend inline const ScaleDiagonalReturnType operator*(const Scalar& scalar,
@@ -125,7 +126,7 @@
 
   template <typename OtherDerived>
   using DiagonalSumReturnType = DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(
-      DiagonalVectorType, typename OtherDerived::DiagonalVectorType, sum)>;
+      DiagonalVectorType, typename OtherDerived::DiagonalVectorType, internal::scalar_sum_op)>;
 
   /** \returns the sum of \c *this and the diagonal matrix \a other */
   template <typename OtherDerived>
@@ -136,7 +137,7 @@
 
   template <typename OtherDerived>
   using DiagonalDifferenceReturnType = DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(
-      DiagonalVectorType, typename OtherDerived::DiagonalVectorType, difference)>;
+      DiagonalVectorType, typename OtherDerived::DiagonalVectorType, internal::scalar_difference_op)>;
 
   /** \returns the difference of \c *this and the diagonal matrix \a other */
   template <typename OtherDerived>
@@ -163,8 +164,8 @@
 template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime>
 struct traits<DiagonalMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime>>
     : traits<Matrix<Scalar_, SizeAtCompileTime, SizeAtCompileTime, 0, MaxSizeAtCompileTime, MaxSizeAtCompileTime>> {
-  typedef Matrix<Scalar_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> DiagonalVectorType;
-  typedef DiagonalShape StorageKind;
+  using DiagonalVectorType = Matrix<Scalar_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>;
+  using StorageKind = DiagonalShape;
   enum { Flags = LvalueBit | NoPreferredStorageOrderBit | NestByRefBit };
 };
 }  // namespace internal
@@ -172,11 +173,11 @@
 class DiagonalMatrix : public DiagonalBase<DiagonalMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime>> {
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType;
-  typedef const DiagonalMatrix& Nested;
-  typedef Scalar_ Scalar;
-  typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind;
-  typedef typename internal::traits<DiagonalMatrix>::StorageIndex StorageIndex;
+  using DiagonalVectorType = typename internal::traits<DiagonalMatrix>::DiagonalVectorType;
+  using Nested = const DiagonalMatrix&;
+  using Scalar = Scalar_;
+  using StorageKind = typename internal::traits<DiagonalMatrix>::StorageKind;
+  using StorageIndex = typename internal::traits<DiagonalMatrix>::StorageIndex;
 #endif
 
  protected:
@@ -215,7 +216,7 @@
       : m_diagonal(a0, a1, a2, args...) {}
 
   /** \brief Constructs a DiagonalMatrix and initializes it by elements given by an initializer list of initializer
-   * lists \cpp11
+   * lists
    */
   EIGEN_DEVICE_FUNC explicit EIGEN_STRONG_INLINE DiagonalMatrix(
       const std::initializer_list<std::initializer_list<Scalar>>& list)
@@ -234,6 +235,9 @@
   inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {}
 #endif
 
+  /** Move constructor. Moves the stored diagonal vector. */
+  EIGEN_DEVICE_FUNC constexpr DiagonalMatrix(DiagonalMatrix&&) = default;
+
   /** generic constructor from expression of the diagonal coefficients */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC constexpr explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other)
@@ -256,11 +260,24 @@
   }
 #endif
 
-  typedef DiagonalWrapper<const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, DiagonalVectorType>>
-      InitializeReturnType;
+  /** Move assignment operator. Transfers dynamic storage and copies inline storage. */
+  EIGEN_DEVICE_FUNC constexpr DiagonalMatrix& operator=(DiagonalMatrix&& other) noexcept(
+      DiagonalVectorType::MaxSizeAtCompileTime == Dynamic &&
+      std::is_nothrow_move_assignable<DiagonalVectorType>::value) {
+    EIGEN_IF_CONSTEXPR (DiagonalVectorType::MaxSizeAtCompileTime == Dynamic) {
+      m_diagonal = std::move(other.m_diagonal);
+    } else {
+      // Preserve the vectorized assignment path for inline storage.
+      m_diagonal = other.m_diagonal;
+    }
+    return *this;
+  }
 
-  typedef DiagonalWrapper<const CwiseNullaryOp<internal::scalar_zero_op<Scalar>, DiagonalVectorType>>
-      ZeroInitializeReturnType;
+  using InitializeReturnType =
+      DiagonalWrapper<const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, DiagonalVectorType>>;
+
+  using ZeroInitializeReturnType =
+      DiagonalWrapper<const CwiseNullaryOp<internal::scalar_zero_op<Scalar>, DiagonalVectorType>>;
 
   /** Initializes a diagonal matrix of size SizeAtCompileTime with coefficients set to zero */
   EIGEN_DEVICE_FUNC static const ZeroInitializeReturnType Zero() { return DiagonalVectorType::Zero().asDiagonal(); }
@@ -268,9 +285,9 @@
   EIGEN_DEVICE_FUNC static const ZeroInitializeReturnType Zero(Index size) {
     return DiagonalVectorType::Zero(size).asDiagonal();
   }
-  /** Initializes a identity matrix of size SizeAtCompileTime */
+  /** Initializes an identity matrix of size SizeAtCompileTime */
   EIGEN_DEVICE_FUNC static const InitializeReturnType Identity() { return DiagonalVectorType::Ones().asDiagonal(); }
-  /** Initializes a identity matrix of size dim */
+  /** Initializes an identity matrix of size dim */
   EIGEN_DEVICE_FUNC static const InitializeReturnType Identity(Index size) {
     return DiagonalVectorType::Ones(size).asDiagonal();
   }
@@ -304,11 +321,11 @@
 namespace internal {
 template <typename DiagonalVectorType_>
 struct traits<DiagonalWrapper<DiagonalVectorType_>> {
-  typedef DiagonalVectorType_ DiagonalVectorType;
-  typedef typename DiagonalVectorType::Scalar Scalar;
-  typedef typename DiagonalVectorType::StorageIndex StorageIndex;
-  typedef DiagonalShape StorageKind;
-  typedef typename traits<DiagonalVectorType>::XprKind XprKind;
+  using DiagonalVectorType = DiagonalVectorType_;
+  using Scalar = typename DiagonalVectorType::Scalar;
+  using StorageIndex = typename DiagonalVectorType::StorageIndex;
+  using StorageKind = DiagonalShape;
+  using XprKind = typename traits<DiagonalVectorType>::XprKind;
   enum {
     RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
     ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
@@ -323,8 +340,8 @@
 class DiagonalWrapper : public DiagonalBase<DiagonalWrapper<DiagonalVectorType_>>, internal::no_assignment_operator {
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef DiagonalVectorType_ DiagonalVectorType;
-  typedef DiagonalWrapper Nested;
+  using DiagonalVectorType = DiagonalVectorType_;
+  using Nested = DiagonalWrapper;
 #endif
 
   /** Constructor from expression of diagonal coefficients to wrap. */
@@ -388,8 +405,8 @@
 template <typename Derived>
 template <int DiagIndex_>
 EIGEN_DEVICE_FUNC constexpr DiagonalWrapper<Diagonal<Derived, DiagIndex_>> MatrixBase<Derived>::diagonalView() {
-  typedef Diagonal<Derived, DiagIndex_> DiagType;
-  typedef DiagonalWrapper<DiagType> ReturnType;
+  using DiagType = Diagonal<Derived, DiagIndex_>;
+  using ReturnType = DiagonalWrapper<DiagType>;
   DiagType diag(this->derived());
   return ReturnType(diag);
 }
@@ -399,8 +416,8 @@
 template <int DiagIndex_>
 EIGEN_DEVICE_FUNC constexpr DiagonalWrapper<Diagonal<const Derived, DiagIndex_>> MatrixBase<Derived>::diagonalView()
     const {
-  typedef Diagonal<const Derived, DiagIndex_> DiagType;
-  typedef DiagonalWrapper<DiagType> ReturnType;
+  using DiagType = Diagonal<const Derived, DiagIndex_>;
+  using ReturnType = DiagonalWrapper<DiagType>;
   DiagType diag(this->derived());
   return ReturnType(diag);
 }
@@ -409,8 +426,8 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC constexpr DiagonalWrapper<Diagonal<Derived, DynamicIndex>> MatrixBase<Derived>::diagonalView(
     Index index) {
-  typedef Diagonal<Derived, DynamicIndex> DiagType;
-  typedef DiagonalWrapper<DiagType> ReturnType;
+  using DiagType = Diagonal<Derived, DynamicIndex>;
+  using ReturnType = DiagonalWrapper<DiagType>;
   DiagType diag(this->derived(), index);
   return ReturnType(diag);
 }
@@ -419,8 +436,8 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC constexpr DiagonalWrapper<Diagonal<const Derived, DynamicIndex>> MatrixBase<Derived>::diagonalView(
     Index index) const {
-  typedef Diagonal<const Derived, DynamicIndex> DiagType;
-  typedef DiagonalWrapper<DiagType> ReturnType;
+  using DiagType = Diagonal<const Derived, DynamicIndex>;
+  using ReturnType = DiagonalWrapper<DiagType>;
   DiagType diag(this->derived(), index);
   return ReturnType(diag);
 }
@@ -429,14 +446,14 @@
 
 template <>
 struct storage_kind_to_shape<DiagonalShape> {
-  typedef DiagonalShape Shape;
+  using Shape = DiagonalShape;
 };
 
 struct Diagonal2Dense {};
 
 template <>
 struct AssignmentKind<DenseShape, DiagonalShape> {
-  typedef Diagonal2Dense Kind;
+  using Kind = Diagonal2Dense;
 };
 
 // Diagonal matrix to Dense assignment
diff --git a/Eigen/src/Core/DiagonalProduct.h b/Eigen/src/Core/DiagonalProduct.h
index bd0feea..292820c 100644
--- a/Eigen/src/Core/DiagonalProduct.h
+++ b/Eigen/src/Core/DiagonalProduct.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DIAGONALPRODUCT_H
 #define EIGEN_DIAGONALPRODUCT_H
diff --git a/Eigen/src/Core/Dot.h b/Eigen/src/Core/Dot.h
index d0a30dd..ea2c729 100644
--- a/Eigen/src/Core/Dot.h
+++ b/Eigen/src/Core/Dot.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DOT_H
 #define EIGEN_DOT_H
@@ -17,7 +18,238 @@
 
 namespace internal {
 
-template <typename Derived, typename Scalar = typename traits<Derived>::Scalar>
+// Accumulate low-precision norms in float without changing the public result type.
+template <typename RealScalar>
+struct stable_norm_accumulator {
+  using type = RealScalar;
+};
+
+template <>
+struct stable_norm_accumulator<half> {
+  using type = float;
+};
+
+template <>
+struct stable_norm_accumulator<bfloat16> {
+  using type = float;
+};
+
+template <typename RealScalar, typename Accumulator>
+struct stable_normalization_normal_min {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator run() {
+    return static_cast<Accumulator>((numext::numeric_limits<RealScalar>::min)());
+  }
+};
+
+// The half and bfloat16 numeric_limits functions are not device functions.
+template <typename Accumulator>
+struct stable_normalization_normal_min<half, Accumulator> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator run() { return Accumulator(1) / Accumulator(16384); }
+};
+
+template <typename Accumulator>
+struct stable_normalization_normal_min<bfloat16, Accumulator> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator run() {
+    return static_cast<Accumulator>((numext::numeric_limits<float>::min)());
+  }
+};
+
+template <typename RealScalar, typename Accumulator>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool stable_normalization_inv_scale(const Accumulator& value,
+                                                                          Accumulator& invScale) {
+  safe_scaling_factors<Accumulator> factors;
+  const Accumulator normalMin = stable_normalization_normal_min<RealScalar, Accumulator>::run();
+  if (!safe_scaling<Accumulator>::try_compute_ceiling_factors_with_normal_reciprocal(value, normalMin, factors))
+    return false;
+  invScale = factors.invScale;
+  return true;
+}
+
+template <typename Accumulator>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool stable_normalization_combined_factor(const Accumulator& invScale,
+                                                                                const Accumulator& sqrtNorm,
+                                                                                Accumulator& factor) {
+  // Check before dividing: an overflowing reciprocal can raise FE_OVERFLOW even if the two-step fallback is used.
+  if (sqrtNorm < Accumulator(1) && invScale > Accumulator(NumTraits<Accumulator>::highest()) * sqrtNorm) return false;
+  Accumulator localSqrtNorm = sqrtNorm;
+  EIGEN_OPTIMIZATION_BARRIER(localSqrtNorm)
+  factor = invScale / localSqrtNorm;
+  return factor >= stable_normalization_normal_min<Accumulator, Accumulator>::run();
+}
+
+template <typename VectorType, typename Accumulator,
+          bool = bool(traits<VectorType>::Flags & DirectAccessBit) &&
+                 (int(inner_stride_at_compile_time<VectorType>::value) != 1)>
+struct stable_normalization_dispatch {
+  using Scalar = typename traits<VectorType>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  // Only complex_array_access scalars have a writable component view.
+  using HasWritableRealView = bool_constant<!NumTraits<Scalar>::IsComplex || complex_array_access<Scalar>::value>;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator max_abs(const VectorType& vec) {
+    return vec.realView().template cast<Accumulator>().cwiseAbs().template maxCoeff<PropagateNaN>();
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator scaled_squared_norm(const VectorType& vec,
+                                                                               const Accumulator& factor) {
+    return (vec.realView().template cast<Accumulator>() * factor).squaredNorm();
+  }
+
+  template <typename ResultType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void assign_scaled(ResultType& result, const VectorType& vec,
+                                                                  const Accumulator& factor) {
+    assign_scaled_impl(result, vec, factor, HasWritableRealView());
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scale_in_place(VectorType& vec, const Accumulator& factor) {
+    assign_scaled_impl(vec, vec, factor, HasWritableRealView());
+  }
+
+ private:
+  template <typename ResultType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void assign_scaled_impl(ResultType& result, const VectorType& vec,
+                                                                       const Accumulator& factor, std::true_type) {
+    result.realView() = (vec.realView().template cast<Accumulator>() * factor).template cast<RealScalar>();
+  }
+
+  template <typename ResultType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void assign_scaled_impl(ResultType& result, const VectorType& vec,
+                                                                       const Accumulator& factor, std::false_type) {
+    result = vec * static_cast<RealScalar>(factor);
+  }
+};
+
+// Runtime-contiguous expressions can still use packet traversal.
+template <typename VectorType, typename Accumulator>
+struct stable_normalization_dispatch<VectorType, Accumulator, true> {
+  using Scalar = typename traits<VectorType>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  // A dynamic map avoids over-unrolling fixed-size normalization paths.
+  using PlainVector = Matrix<Scalar, Dynamic, 1>;
+  using ConstContiguousMap = Map<const PlainVector, evaluator<VectorType>::Alignment>;
+  using ContiguousMap = Map<PlainVector, evaluator<VectorType>::Alignment>;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool is_contiguous(const VectorType& vec) {
+    return vec.innerStride() == 1 && (vec.outerSize() == 1 || vec.outerStride() == vec.innerSize());
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator max_abs(const VectorType& vec) {
+    if (is_contiguous(vec)) {
+      const ConstContiguousMap contiguous(vec.data(), vec.size());
+      return stable_normalization_dispatch<ConstContiguousMap, Accumulator, false>::max_abs(contiguous);
+    }
+    return stable_normalization_dispatch<VectorType, Accumulator, false>::max_abs(vec);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Accumulator scaled_squared_norm(const VectorType& vec,
+                                                                               const Accumulator& factor) {
+    if (is_contiguous(vec)) {
+      const ConstContiguousMap contiguous(vec.data(), vec.size());
+      return stable_normalization_dispatch<ConstContiguousMap, Accumulator, false>::scaled_squared_norm(contiguous,
+                                                                                                        factor);
+    }
+    return stable_normalization_dispatch<VectorType, Accumulator, false>::scaled_squared_norm(vec, factor);
+  }
+
+  template <typename ResultType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void assign_scaled(ResultType& result, const VectorType& vec,
+                                                                  const Accumulator& factor) {
+    if (is_contiguous(vec)) {
+      const ConstContiguousMap contiguous(vec.data(), vec.size());
+      Map<PlainVector> output(result.data(), result.size());
+      stable_normalization_dispatch<ConstContiguousMap, Accumulator, false>::assign_scaled(output, contiguous, factor);
+      return;
+    }
+    stable_normalization_dispatch<VectorType, Accumulator, false>::assign_scaled(result, vec, factor);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scale_in_place(VectorType& vec, const Accumulator& factor) {
+    if (is_contiguous(vec)) {
+      ContiguousMap contiguous(vec.data(), vec.size());
+      stable_normalization_dispatch<ContiguousMap, Accumulator, false>::scale_in_place(contiguous, factor);
+      return;
+    }
+    stable_normalization_dispatch<VectorType, Accumulator, false>::scale_in_place(vec, factor);
+  }
+};
+
+// Prevent fast-math from merging normal scale factors into a subnormal factor.
+template <typename VectorType, typename Accumulator>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void stable_normalization_scale_in_place(VectorType& vec,
+                                                                             const Accumulator& factor) {
+  stable_normalization_dispatch<VectorType, Accumulator>::scale_in_place(vec, factor);
+}
+
+template <typename VectorType, typename Divisor>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void stable_normalization_divide_in_place(VectorType& vec, const Divisor& divisor) {
+  vec /= divisor;
+}
+
+template <typename VectorType, typename Accumulator>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void stable_normalization_with_division(VectorType& vec,
+                                                                              const Accumulator& maxCoeff) {
+  using RealScalar = typename NumTraits<typename traits<VectorType>::Scalar>::Real;
+  // Two normal divisors avoid an exceptional reciprocal and fast-math
+  // reassociation into multiplication by 1 / maxCoeff.
+  const Accumulator sqrtMax = numext::sqrt(maxCoeff);
+  const RealScalar scale1 = static_cast<RealScalar>(sqrtMax);
+  const RealScalar scale2 = static_cast<RealScalar>(maxCoeff / sqrtMax);
+  stable_normalization_divide_in_place(vec, scale1);
+  stable_normalization_divide_in_place(vec, scale2);
+  const Accumulator z = vec.realView().template cast<Accumulator>().squaredNorm();
+  if (z > Accumulator(0)) {
+    stable_normalization_scale_in_place(vec, Accumulator(1) / numext::sqrt(z));
+  }
+}
+
+template <typename VectorType, typename Accumulator,
+          bool = use_subnormal_preserving_scaling<Accumulator, typename traits<VectorType>::Scalar>::value>
+struct stable_normalization_subnormal_recovery {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(VectorType&) {}
+};
+
+template <typename VectorType, typename Accumulator>
+struct stable_normalization_subnormal_recovery<VectorType, Accumulator, true> {
+  using RealScalar = typename NumTraits<typename traits<VectorType>::Scalar>::Real;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(VectorType& vec) {
+    using Binary = binary_floating_point_traits<RealScalar>;
+    using Bits = typename Binary::Bits;
+    decltype(auto) components = vec.realView();
+    Bits maxBits = 0;
+    for (Index col = 0; col < components.cols(); ++col) {
+      for (Index row = 0; row < components.rows(); ++row) {
+        const Bits bits = Binary::magnitude(components.coeff(row, col));
+        if (bits > maxBits) maxBits = bits;
+      }
+    }
+    if (maxBits == 0 || maxBits >= Binary::kExponentUnit) return;
+
+    const Accumulator maxAbs = numext::bit_cast<RealScalar>(maxBits);
+    const auto factors = safe_scaling<Accumulator>::compute_ceiling_factors(maxAbs);
+    safe_scaling<Accumulator>::scale_in_place(vec, maxAbs, factors);
+    const Accumulator squaredNorm = components.template cast<Accumulator>().squaredNorm();
+    if (squaredNorm > Accumulator(0)) {
+      stable_normalization_divide_in_place(vec, numext::sqrt(squaredNorm));
+    }
+  }
+};
+
+// squaredNorm() reduces realView().cwiseAbs2(), a cwise expression with no direct access, so when
+// the underlying expression has an inner stride that is not statically 1 (a dynamic-inner-stride
+// Map/Ref, a row of a 1xN matrix, ...) the reduction falls back to a scalar traversal even though
+// the data is frequently contiguous at runtime. This trait flags the cases where a runtime
+// contiguity check is worthwhile; it mirrors the reduction fast path in Redux.h (redux_dispatch).
+// bool is excluded: its squared norm is any(), handled by a dedicated specialization below.
+template <typename Xpr>
+struct squared_norm_runtime_unit_stride {
+  using Scalar = typename traits<Xpr>::Scalar;
+  static constexpr bool value =
+      bool(traits<Xpr>::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::Vectorizable) &&
+      !bool(internal::is_same<Scalar, bool>::value) && (int(inner_stride_at_compile_time<Xpr>::value) != 1);
+};
+
+template <typename Derived, typename Scalar = typename traits<Derived>::Scalar, typename Enable = void>
 struct squared_norm_impl {
   using Real = typename NumTraits<Scalar>::Real;
   static EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Real run(const Derived& a) {
@@ -26,10 +258,26 @@
 };
 
 template <typename Derived>
-struct squared_norm_impl<Derived, bool> {
+struct squared_norm_impl<Derived, bool, void> {
   static EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE bool run(const Derived& a) { return a.any(); }
 };
 
+// Runtime contiguity fast path: when the data is contiguous at runtime (inner stride 1, and a
+// single inner panel or no gap between inner panels), reduce the underlying buffer as a contiguous
+// vector, recovering vectorization of the abs2 reduction.
+template <typename Derived, typename Scalar>
+struct squared_norm_impl<Derived, Scalar, std::enable_if_t<squared_norm_runtime_unit_stride<Derived>::value>> {
+  using Real = typename NumTraits<Scalar>::Real;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real run(const Derived& a) {
+    if (a.innerStride() == 1 && (a.outerSize() == 1 || a.outerStride() == a.innerSize())) {
+      using PlainVector = Matrix<Scalar, Dynamic, 1>;
+      Map<const PlainVector, evaluator<Derived>::Alignment> contiguous(a.data(), a.size());
+      return contiguous.realView().cwiseAbs2().sum();
+    }
+    return a.realView().cwiseAbs2().sum();
+  }
+};
+
 }  // end namespace internal
 
 /** \fn MatrixBase::dot
@@ -49,7 +297,7 @@
     typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,
                                   typename internal::traits<OtherDerived>::Scalar>::ReturnType
     MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const {
-  return internal::dot_impl<Derived, OtherDerived>::run(derived(), other.derived());
+  return internal::inner_product_dispatch<Derived, OtherDerived, true>::run(derived(), other.derived());
 }
 
 //---------- implementation of L2 norm and related functions ----------
@@ -90,7 +338,7 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject MatrixBase<Derived>::normalized()
     const {
-  typedef typename internal::nested_eval<Derived, 2>::type Nested_;
+  using Nested_ = typename internal::nested_eval<Derived, 2>::type;
   Nested_ n(derived());
   RealScalar z = n.squaredNorm();
   // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
@@ -130,14 +378,49 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
 MatrixBase<Derived>::stableNormalized() const {
-  typedef typename internal::nested_eval<Derived, 3>::type Nested_;
-  Nested_ n(derived());
-  RealScalar w = n.cwiseAbs().maxCoeff();
-  RealScalar z = (n / w).squaredNorm();
-  if (z > RealScalar(0))
-    return n / (numext::sqrt(z) * w);
-  else
-    return n;
+  using Nested_ = typename internal::nested_eval<Derived, 3>::type;
+  using NestedClean = internal::remove_all_t<Nested_>;
+  using Accumulator = typename internal::stable_norm_accumulator<RealScalar>::type;
+  using Dispatch = internal::stable_normalization_dispatch<NestedClean, Accumulator>;
+  Nested_ vec(derived());
+  if (EIGEN_PREDICT_FALSE(vec.size() == 0)) return vec;
+
+  // Component-wise scaling stays finite when a finite complex value has an
+  // overflowing magnitude, and avoids a hypot per coefficient.
+  const Accumulator w = Dispatch::max_abs(vec);
+  const Accumulator highest = static_cast<Accumulator>(NumTraits<RealScalar>::highest());
+  if (EIGEN_PREDICT_FALSE(!(w > Accumulator(0)))) {
+    PlainObject normalized(vec);
+    internal::stable_normalization_subnormal_recovery<PlainObject, Accumulator>::run(normalized);
+    return normalized;
+  }
+  if (EIGEN_PREDICT_FALSE(!(w <= highest))) return vec;
+
+  Accumulator invScale;
+  if (EIGEN_PREDICT_TRUE((internal::stable_normalization_inv_scale<RealScalar>(w, invScale)))) {
+    const Accumulator z = Dispatch::scaled_squared_norm(vec, invScale);
+    if (z > Accumulator(0)) {
+      const Accumulator sqrt_z = numext::sqrt(z);
+      Accumulator factor;
+      PlainObject normalized(rows(), cols());
+      if (EIGEN_PREDICT_TRUE(internal::stable_normalization_combined_factor(invScale, sqrt_z, factor))) {
+        Dispatch::assign_scaled(normalized, vec, factor);
+      } else {
+        // invScale and sqrt_z are normal even though their quotient is not.
+        Dispatch::assign_scaled(normalized, vec, invScale);
+        internal::stable_normalization_divide_in_place(normalized, static_cast<RealScalar>(sqrt_z));
+      }
+      return normalized;
+    }
+    // Packet arithmetic may flush subnormal inputs even when the maximum reduction preserves them (ARMv7 NEON).
+    PlainObject normalized(vec);
+    internal::stable_normalization_subnormal_recovery<PlainObject, Accumulator>::run(normalized);
+    return normalized;
+  }
+
+  PlainObject normalized = vec;
+  internal::stable_normalization_with_division(normalized, w);
+  return normalized;
 }
 
 /** Normalizes the vector while avoid underflow and overflow
@@ -153,9 +436,37 @@
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void MatrixBase<Derived>::stableNormalize() {
-  RealScalar w = cwiseAbs().maxCoeff();
-  RealScalar z = (derived() / w).squaredNorm();
-  if (z > RealScalar(0)) derived() /= numext::sqrt(z) * w;
+  using Accumulator = typename internal::stable_norm_accumulator<RealScalar>::type;
+  using Dispatch = internal::stable_normalization_dispatch<Derived, Accumulator>;
+  if (EIGEN_PREDICT_FALSE(size() == 0)) return;
+
+  const Accumulator w = Dispatch::max_abs(derived());
+  const Accumulator highest = static_cast<Accumulator>(NumTraits<RealScalar>::highest());
+  if (EIGEN_PREDICT_FALSE(!(w > Accumulator(0)))) {
+    internal::stable_normalization_subnormal_recovery<Derived, Accumulator>::run(derived());
+    return;
+  }
+  if (EIGEN_PREDICT_FALSE(!(w <= highest))) return;
+
+  Accumulator invScale;
+  if (EIGEN_PREDICT_TRUE((internal::stable_normalization_inv_scale<RealScalar>(w, invScale)))) {
+    const Accumulator z = Dispatch::scaled_squared_norm(derived(), invScale);
+    if (z > Accumulator(0)) {
+      const Accumulator sqrt_z = numext::sqrt(z);
+      Accumulator factor;
+      if (EIGEN_PREDICT_TRUE(internal::stable_normalization_combined_factor(invScale, sqrt_z, factor))) {
+        Dispatch::scale_in_place(derived(), factor);
+      } else {
+        internal::stable_normalization_scale_in_place(derived(), invScale);
+        internal::stable_normalization_divide_in_place(derived(), static_cast<RealScalar>(sqrt_z));
+      }
+    } else {
+      internal::stable_normalization_subnormal_recovery<Derived, Accumulator>::run(derived());
+    }
+    return;
+  }
+
+  internal::stable_normalization_with_division(derived(), w);
 }
 
 //---------- implementation of other norms ----------
@@ -164,7 +475,7 @@
 
 template <typename Derived, int p>
 struct lpNorm_selector {
-  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<typename traits<Derived>::Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const MatrixBase<Derived>& m) {
     EIGEN_USING_STD(pow)
     return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1) / p);
@@ -189,7 +500,7 @@
 
 template <typename Derived>
 struct lpNorm_selector<Derived, Infinity> {
-  typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<typename traits<Derived>::Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const MatrixBase<Derived>& m) {
     if (Derived::SizeAtCompileTime == 0 || (Derived::SizeAtCompileTime == Dynamic && m.size() == 0))
       return RealScalar(0);
diff --git a/Eigen/src/Core/EigenBase.h b/Eigen/src/Core/EigenBase.h
index dfe4a64..2a28666 100644
--- a/Eigen/src/Core/EigenBase.h
+++ b/Eigen/src/Core/EigenBase.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_EIGENBASE_H
 #define EIGEN_EIGENBASE_H
@@ -40,10 +41,10 @@
    * Deprecation is not marked with a doxygen comment because there are too many existing usages to add the deprecation
    * attribute.
    */
-  typedef Eigen::Index Index;
+  using Index = Eigen::Index;
 
   // FIXME is it needed?
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
 
   /** \returns a reference to the derived object */
   EIGEN_DEVICE_FUNC constexpr Derived& derived() { return *static_cast<Derived*>(this); }
diff --git a/Eigen/src/Core/Fill.h b/Eigen/src/Core/Fill.h
index cacf921..d6776d8 100644
--- a/Eigen/src/Core/Fill.h
+++ b/Eigen/src/Core/Fill.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_FILL_H
 #define EIGEN_FILL_H
@@ -20,27 +21,28 @@
 template <typename Xpr>
 struct eigen_fill_helper : std::false_type {};
 
+// Only enable std::fill_n for trivially copyable scalars.  GCC's libstdc++
+// fill_n pessimizes non-trivially-copyable types (extra moves per iteration),
+// causing measurable regressions for types like AutoDiffScalar (issue #2956).
 template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
-struct eigen_fill_helper<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> : std::true_type {};
+struct eigen_fill_helper<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> : std::is_trivially_copyable<Scalar> {};
 
 template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
-struct eigen_fill_helper<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> : std::true_type {};
+struct eigen_fill_helper<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> : std::is_trivially_copyable<Scalar> {};
 
 template <typename Xpr, int BlockRows, int BlockCols>
 struct eigen_fill_helper<Block<Xpr, BlockRows, BlockCols, /*InnerPanel*/ true>> : eigen_fill_helper<Xpr> {};
 
 template <typename Xpr, int BlockRows, int BlockCols>
 struct eigen_fill_helper<Block<Xpr, BlockRows, BlockCols, /*InnerPanel*/ false>>
-    : std::integral_constant<bool, eigen_fill_helper<Xpr>::value &&
-                                       (Xpr::IsRowMajor ? (BlockRows == 1) : (BlockCols == 1))> {};
+    : bool_constant<eigen_fill_helper<Xpr>::value && (Xpr::IsRowMajor ? (BlockRows == 1) : (BlockCols == 1))> {};
 
 template <typename Xpr, int Options>
 struct eigen_fill_helper<Map<Xpr, Options, Stride<0, 0>>> : eigen_fill_helper<Xpr> {};
 
 template <typename Xpr, int Options, int OuterStride_>
 struct eigen_fill_helper<Map<Xpr, Options, Stride<OuterStride_, 0>>>
-    : std::integral_constant<bool, eigen_fill_helper<Xpr>::value &&
-                                       enum_eq_not_dynamic(OuterStride_, Xpr::InnerSizeAtCompileTime)> {};
+    : bool_constant<eigen_fill_helper<Xpr>::value && enum_eq_not_dynamic(OuterStride_, Xpr::InnerSizeAtCompileTime)> {};
 
 template <typename Xpr, int Options, int OuterStride_>
 struct eigen_fill_helper<Map<Xpr, Options, Stride<OuterStride_, 1>>>
@@ -57,7 +59,6 @@
 template <typename Xpr>
 struct eigen_fill_impl<Xpr, /*use_fill*/ false> {
   using Scalar = typename Xpr::Scalar;
-  using Func = scalar_constant_op<Scalar>;
   using PlainObject = typename Xpr::PlainObject;
   using Constant = typename PlainObject::ConstantReturnType;
   static EIGEN_DEVICE_FUNC constexpr void run(Xpr& dst, const Scalar& val) {
@@ -118,7 +119,14 @@
 struct eigen_zero_impl<Xpr, /*use_memset*/ true> {
   using Scalar = typename Xpr::Scalar;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Xpr& dst) {
-    const std::ptrdiff_t num_bytes = dst.size() * static_cast<std::ptrdiff_t>(sizeof(Scalar));
+    Index size = dst.size();
+    EIGEN_IF_CONSTEXPR (Xpr::MaxSizeAtCompileTime != Dynamic) {
+      if (size > Xpr::MaxSizeAtCompileTime) {
+        eigen_internal_assert(false && "invalid dense object size");
+        return;
+      }
+    }
+    const std::ptrdiff_t num_bytes = size * static_cast<std::ptrdiff_t>(sizeof(Scalar));
     if (num_bytes <= 0) return;
     void* dst_ptr = static_cast<void*>(dst.data());
 #ifndef EIGEN_NO_DEBUG
diff --git a/Eigen/src/Core/FindCoeff.h b/Eigen/src/Core/FindCoeff.h
index 1c07260..5802ed9 100644
--- a/Eigen/src/Core/FindCoeff.h
+++ b/Eigen/src/Core/FindCoeff.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_FIND_COEFF_H
 #define EIGEN_FIND_COEFF_H
@@ -34,7 +35,7 @@
 
 template <typename Scalar>
 struct max_coeff_functor<Scalar, PropagateNaN, false> {
-  EIGEN_DEVICE_FUNC inline Scalar compareCoeff(const Scalar& incumbent, const Scalar& candidate) const {
+  EIGEN_DEVICE_FUNC inline bool compareCoeff(const Scalar& incumbent, const Scalar& candidate) const {
     return (candidate > incumbent) || ((candidate != candidate) && (incumbent == incumbent));
   }
   template <typename Packet>
@@ -79,7 +80,7 @@
 
 template <typename Scalar>
 struct min_coeff_functor<Scalar, PropagateNaN, false> {
-  EIGEN_DEVICE_FUNC inline Scalar compareCoeff(const Scalar& incumbent, const Scalar& candidate) const {
+  EIGEN_DEVICE_FUNC inline bool compareCoeff(const Scalar& incumbent, const Scalar& candidate) const {
     return (candidate < incumbent) || ((candidate != candidate) && (incumbent == incumbent));
   }
   template <typename Packet>
@@ -133,8 +134,7 @@
     for (Index j = 0; j < outerSize; j++) {
       for (Index i = 0; i < innerSize; i++) {
         Scalar xprCoeff = eval.coeffByOuterInner(j, i);
-        bool newRes = func.compareCoeff(res, xprCoeff);
-        if (newRes) {
+        if (func.compareCoeff(res, xprCoeff)) {
           outer = j;
           inner = i;
           res = xprCoeff;
@@ -155,8 +155,7 @@
 
     for (Index k = 0; k < size; k++) {
       Scalar xprCoeff = eval.coeff(k);
-      bool newRes = func.compareCoeff(res, xprCoeff);
-      if (newRes) {
+      if (func.compareCoeff(res, xprCoeff)) {
         index = k;
         res = xprCoeff;
       }
@@ -173,6 +172,10 @@
                                            Index& inner) {
     Index outerSize = eval.outerSize();
     Index innerSize = eval.innerSize();
+    if (innerSize < PacketSize) {
+      ScalarImpl::run(eval, func, result, outer, inner);
+      return;
+    }
     Index packetEnd = numext::round_down(innerSize, PacketSize);
 
     /* initialization performed in calling function */
@@ -229,6 +232,10 @@
 
   static EIGEN_DEVICE_FUNC inline void run(const Evaluator& eval, Func& func, Scalar& result, Index& index) {
     Index size = eval.size();
+    if (size < PacketSize) {
+      ScalarImpl::run(eval, func, result, index);
+      return;
+    }
     Index packetEnd = numext::round_down(size, PacketSize);
 
     /* initialization performed in calling function */
@@ -303,7 +310,6 @@
 struct find_coeff_impl {
   using Evaluator = find_coeff_evaluator<Derived>;
   static constexpr int Flags = Evaluator::Flags;
-  static constexpr int Alignment = Evaluator::Alignment;
   static constexpr bool IsRowMajor = Derived::IsRowMajor;
   static constexpr int MaxInnerSizeAtCompileTime =
       IsRowMajor ? Derived::MaxColsAtCompileTime : Derived::MaxRowsAtCompileTime;
@@ -381,7 +387,7 @@
  * In case \c *this contains NaN, NaNPropagation determines the behavior:
  *   NaNPropagation == PropagateFast : undefined
  *   NaNPropagation == PropagateNaN : result is NaN
- *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+ *   NaNPropagation == PropagateNumbers : result is minimum of elements that are not NaN
  * \warning the matrix must be not empty, otherwise an assertion is triggered.
  *
  * \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()
@@ -402,7 +408,7 @@
  * In case \c *this contains NaN, NaNPropagation determines the behavior:
  *   NaNPropagation == PropagateFast : undefined
  *   NaNPropagation == PropagateNaN : result is NaN
- *   NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
+ *   NaNPropagation == PropagateNumbers : result is minimum of elements that are not NaN
  * \warning the matrix must be not empty, otherwise an assertion is triggered.
  *
  * \sa DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(),
diff --git a/Eigen/src/Core/ForceAlignedAccess.h b/Eigen/src/Core/ForceAlignedAccess.h
deleted file mode 100644
index 4f69c20..0000000
--- a/Eigen/src/Core/ForceAlignedAccess.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_FORCEALIGNEDACCESS_H
-#define EIGEN_FORCEALIGNEDACCESS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \class ForceAlignedAccess
- * \ingroup Core_Module
- *
- * \brief Enforce aligned packet loads and stores regardless of what is requested
- *
- * \param ExpressionType the type of the object of which we are forcing aligned packet access
- *
- * This class is the return type of MatrixBase::forceAlignedAccess()
- * and most of the time this is the only way it is used.
- *
- * \sa MatrixBase::forceAlignedAccess()
- */
-
-namespace internal {
-template <typename ExpressionType>
-struct traits<ForceAlignedAccess<ExpressionType>> : public traits<ExpressionType> {};
-}  // namespace internal
-
-template <typename ExpressionType>
-class ForceAlignedAccess : public internal::dense_xpr_base<ForceAlignedAccess<ExpressionType>>::type {
- public:
-  typedef typename internal::dense_xpr_base<ForceAlignedAccess>::type Base;
-  EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess)
-
-  EIGEN_DEVICE_FUNC explicit constexpr ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {}
-
-  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return m_expression.rows(); }
-  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return m_expression.cols(); }
-  EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return m_expression.outerStride(); }
-  EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept { return m_expression.innerStride(); }
-
-  EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index row, Index col) const {
-    return m_expression.coeff(row, col);
-  }
-
-  EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) {
-    return m_expression.const_cast_derived().coeffRef(row, col);
-  }
-
-  EIGEN_DEVICE_FUNC inline const CoeffReturnType coeff(Index index) const { return m_expression.coeff(index); }
-
-  EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index index) { return m_expression.const_cast_derived().coeffRef(index); }
-
-  template <int LoadMode>
-  inline const PacketScalar packet(Index row, Index col) const {
-    return m_expression.template packet<Aligned>(row, col);
-  }
-
-  template <int LoadMode>
-  inline void writePacket(Index row, Index col, const PacketScalar& x) {
-    m_expression.const_cast_derived().template writePacket<Aligned>(row, col, x);
-  }
-
-  template <int LoadMode>
-  inline const PacketScalar packet(Index index) const {
-    return m_expression.template packet<Aligned>(index);
-  }
-
-  template <int LoadMode>
-  inline void writePacket(Index index, const PacketScalar& x) {
-    m_expression.const_cast_derived().template writePacket<Aligned>(index, x);
-  }
-
-  EIGEN_DEVICE_FUNC operator const ExpressionType&() const { return m_expression; }
-
- protected:
-  const ExpressionType& m_expression;
-
- private:
-  ForceAlignedAccess& operator=(const ForceAlignedAccess&);
-};
-
-/** \returns an expression of *this with forced aligned access
- * \sa forceAlignedAccessIf(),class ForceAlignedAccess
- */
-template <typename Derived>
-inline const ForceAlignedAccess<Derived> MatrixBase<Derived>::forceAlignedAccess() const {
-  return ForceAlignedAccess<Derived>(derived());
-}
-
-/** \returns an expression of *this with forced aligned access
- * \sa forceAlignedAccessIf(), class ForceAlignedAccess
- */
-template <typename Derived>
-inline ForceAlignedAccess<Derived> MatrixBase<Derived>::forceAlignedAccess() {
-  return ForceAlignedAccess<Derived>(derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_FORCEALIGNEDACCESS_H
diff --git a/Eigen/src/Core/Fuzzy.h b/Eigen/src/Core/Fuzzy.h
index eaa553c..a802b9c 100644
--- a/Eigen/src/Core/Fuzzy.h
+++ b/Eigen/src/Core/Fuzzy.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_FUZZY_H
 #define EIGEN_FUZZY_H
diff --git a/Eigen/src/Core/GeneralProduct.h b/Eigen/src/Core/GeneralProduct.h
index 707611a..cc3a0ed 100644
--- a/Eigen/src/Core/GeneralProduct.h
+++ b/Eigen/src/Core/GeneralProduct.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERAL_PRODUCT_H
 #define EIGEN_GENERAL_PRODUCT_H
@@ -18,18 +19,100 @@
 
 enum { Large = 2, Small = 3 };
 
-// Define the threshold value to fallback from the generic matrix-matrix product
-// implementation (heavy) to the lightweight coeff-based product one.
-// See generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct>
-// in products/GeneralMatrixMatrix.h for more details.
-// TODO This threshold should also be used in the compile-time selector below.
+// Runtime-size threshold for falling back from the generic matrix-matrix product
+// implementation (heavy) to the lightweight coeff-based product one. See
+// generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,GemmProduct> in
+// products/GeneralMatrixMatrix.h for more details.
+// The crossover belongs to the kernel the GEMM path would select, not to the
+// build: a scalar type that falls back to the generic gebp kernel keeps this
+// value even in an SME build. The SME kernels have their own, larger crossovers
+// -- sme_gemm_to_coeffbased_threshold and
+// EIGEN_SME_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD below.
 #ifndef EIGEN_GEMM_TO_COEFFBASED_THRESHOLD
 // This default value has been obtained on a Haswell architecture.
 #define EIGEN_GEMM_TO_COEFFBASED_THRESHOLD 20
 #endif
 
+// Fixed-size products can reach the GEMM product path even when the
+// coeff-based evaluator is still faster. Keep this threshold separate so
+// runtime-size dispatch preserves the historical heuristic above. This default
+// was tuned on the same Haswell system as the runtime threshold, and deliberately
+// tracks EIGEN_GEMM_TO_COEFFBASED_THRESHOLD unless specialized independently.
+#ifndef EIGEN_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD
+#define EIGEN_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD (2 * EIGEN_GEMM_TO_COEFFBASED_THRESHOLD)
+#endif
+
+#ifdef EIGEN_VECTORIZE_SME
+// Kept as a separate knob for the scalar pairs the SME kernel claims. With the
+// NEON small-block path those products run NEON packers and kernel below the
+// crossover, so the generic fixed-size value applies; int, half, bfloat16,
+// mixed real x complex, and double / complex<double> without FEAT_SME_F64F64
+// run the generic kernel and never read this one.
+#ifndef EIGEN_SME_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD
+#define EIGEN_SME_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD EIGEN_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD
+#endif
+#endif
+
+// The dimension-sum bound in sme_gemm_to_coeffbased_threshold below grows with
+// the depth, so it cannot reach a small output over a long depth: a 2x2 result
+// at k=1024 sums to 1028 and takes the SME path with nearly the whole ZA grid
+// predicated off. The crossover for that shape family is an output *area* rather
+// than a dimension sum, and it tracks the scalar width.
+//
+// Measured on Apple M4 at SVL=512, every m x n with m,n in [2,12] against the
+// coeff-based path: the largest area at which *no* shape loses is 27, 14, 15 and
+// 6 for float, complex<float>, double and complex<double>. 96/sizeof (24, 12,
+// 12, 6) sits just inside all four, and holds out to k=32768 -- the worst cell
+// there is float 4x6 at 1.03x, i.e. neutral, while 2x2 is 13x and 3x3 2.0x.
+// A flat constant does not work: the value that is safe for complex<double>
+// admits only 2x2 for float, and float's would cost complex<double> up to 2x.
+#ifndef EIGEN_SME_GEMM_TO_COEFFBASED_OUTPUT_AREA_THRESHOLD
+#define EIGEN_SME_GEMM_TO_COEFFBASED_OUTPUT_AREA_THRESHOLD(Scalar) (96 / int(sizeof(Scalar)))
+#endif
+
 namespace internal {
 
+#ifdef EIGEN_VECTORIZE_SME
+// Defined in products/GeneralBlockPanelKernel.h, which Core includes after this
+// header; only the declaration is needed to form the dependent type below.
+template <typename LhsScalar, typename RhsScalar>
+struct sme_has_gebp_kernel;
+// Dimension sum below which the coeff-based product beats the SME GEMM kernel.
+// mr x nr is sized in ZA tiles, so a product too small to fill the grid wastes
+// most of the outer products the kernel issues, and the block holds fewer
+// scalars as the scalar widens: the crossover sits well above the Haswell-tuned
+// EIGEN_GEMM_TO_COEFFBASED_THRESHOLD, and it moves with the scalar type.
+//
+// First cube (m=n=k) at which the SME kernel wins, from two sweeps that each
+// built the same source twice with only this threshold changed, so that the real
+// dispatch selected the path in both:
+//
+//   scalar            M4   M4 Pro   M4 Pro, result 64-byte aligned
+//   complex<double>   14   14       15
+//   double            16   18       16
+//   complex<float>    20   19       19
+//   float             26   22       23
+//
+// The entries below are 3n for the largest of each row, so neither host loses at
+// the crossover it gets. Over the sizes where the two disagree the paths are
+// within 1.2x on both, while at n=14 a too-low bound costs 1.7x to 2.9x.
+//
+// Defining EIGEN_SME_GEMM_TO_COEFFBASED_THRESHOLD replaces every entry with one
+// value, which is what such a sweep wants. The primary template answers with the
+// generic threshold: sme_has_gebp_kernel gates the dispatch, so a scalar pair
+// without an SME kernel never reads the table.
+// With the NEON small-block path (arch/SME/GeneralBlockPanelKernel.h) the SME
+// kernels take the generic crossover: below it the small products run the NEON
+// packers and kernel, so the SME build matches a NEON build there.
+#ifdef EIGEN_SME_GEMM_TO_COEFFBASED_THRESHOLD
+template <typename Scalar>
+struct sme_gemm_to_coeffbased_threshold : std::integral_constant<int, EIGEN_SME_GEMM_TO_COEFFBASED_THRESHOLD> {};
+#else
+template <typename Scalar>
+struct sme_gemm_to_coeffbased_threshold : std::integral_constant<int, EIGEN_GEMM_TO_COEFFBASED_THRESHOLD> {};
+#endif
+#endif
+
 template <int Rows, int Cols, int Depth>
 struct product_type_selector;
 
@@ -50,8 +133,8 @@
 
 template <typename Lhs, typename Rhs>
 struct product_type {
-  typedef remove_all_t<Lhs> Lhs_;
-  typedef remove_all_t<Rhs> Rhs_;
+  using Lhs_ = remove_all_t<Lhs>;
+  using Rhs_ = remove_all_t<Rhs>;
   enum {
     MaxRows = traits<Lhs_>::MaxRowsAtCompileTime,
     Rows = traits<Lhs_>::RowsAtCompileTime,
@@ -61,26 +144,39 @@
     Depth = min_size_prefer_fixed(traits<Lhs_>::ColsAtCompileTime, traits<Rhs_>::RowsAtCompileTime)
   };
 
-  // the splitting into different lines of code here, introducing the _select enums and the typedef below,
-  // is to work around an internal compiler error with gcc 4.1 and 4.2.
- private:
-  enum {
-    rows_select = product_size_category<Rows, MaxRows>::value,
-    cols_select = product_size_category<Cols, MaxCols>::value,
-    depth_select = product_size_category<Depth, MaxDepth>::value
-  };
-  typedef product_type_selector<rows_select, cols_select, depth_select> selector;
+  static constexpr int ProductType =
+      product_type_selector<product_size_category<Rows, MaxRows>::value, product_size_category<Cols, MaxCols>::value,
+                            product_size_category<Depth, MaxDepth>::value>::value;
 
- public:
-  enum { value = selector::ret, ret = selector::ret };
+  // Same rule as the runtime dispatch in products/GeneralMatrixMatrix.h: the
+  // threshold follows the kernel the GEMM path would select, so a scalar pair
+  // without an SME kernel keeps the generic crossover in an SME build.
+  static constexpr int FixedSizeThreshold =
+#ifdef EIGEN_VECTORIZE_SME
+      sme_has_gebp_kernel<typename traits<Lhs_>::Scalar, typename traits<Rhs_>::Scalar>::value
+          ? EIGEN_SME_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD
+          :
+#endif
+          EIGEN_FIXED_SIZE_GEMM_TO_COEFFBASED_THRESHOLD;
+
+  static constexpr bool FixedSizeCoeffBasedProduct = ProductType == GemmProduct && Rows != Dynamic && Cols != Dynamic &&
+                                                     Depth != Dynamic &&
+                                                     (int(Rows) + int(Cols) + int(Depth) < FixedSizeThreshold);
+
+  static constexpr int value = FixedSizeCoeffBasedProduct ? CoeffBasedProductMode : ProductType;
 #ifdef EIGEN_DEBUG_PRODUCT
   static void debug() {
+    const int rows_select = product_size_category<Rows, MaxRows>::value;
+    const int cols_select = product_size_category<Cols, MaxCols>::value;
+    const int depth_select = product_size_category<Depth, MaxDepth>::value;
     EIGEN_DEBUG_VAR(Rows);
     EIGEN_DEBUG_VAR(Cols);
     EIGEN_DEBUG_VAR(Depth);
     EIGEN_DEBUG_VAR(rows_select);
     EIGEN_DEBUG_VAR(cols_select);
     EIGEN_DEBUG_VAR(depth_select);
+    EIGEN_DEBUG_VAR(ProductType);
+    EIGEN_DEBUG_VAR(FixedSizeCoeffBasedProduct);
     EIGEN_DEBUG_VAR(value);
   }
 #endif
@@ -91,101 +187,53 @@
  * This is a compile time mapping from {1,Small,Large}^3 -> {product types} */
 // FIXME: the current compile-time product-type mapping may not be optimal.
 template <int M, int N>
-struct product_type_selector<M, N, 1> {
-  enum { ret = OuterProduct };
-};
+struct product_type_selector<M, N, 1> : std::integral_constant<int, OuterProduct> {};
 template <int M>
-struct product_type_selector<M, 1, 1> {
-  enum { ret = LazyCoeffBasedProductMode };
-};
+struct product_type_selector<M, 1, 1> : std::integral_constant<int, LazyCoeffBasedProductMode> {};
 template <int N>
-struct product_type_selector<1, N, 1> {
-  enum { ret = LazyCoeffBasedProductMode };
-};
+struct product_type_selector<1, N, 1> : std::integral_constant<int, LazyCoeffBasedProductMode> {};
 template <int Depth>
-struct product_type_selector<1, 1, Depth> {
-  enum { ret = InnerProduct };
-};
+struct product_type_selector<1, 1, Depth> : std::integral_constant<int, InnerProduct> {};
 template <>
-struct product_type_selector<1, 1, 1> {
-  enum { ret = InnerProduct };
-};
+struct product_type_selector<1, 1, 1> : std::integral_constant<int, InnerProduct> {};
 template <>
-struct product_type_selector<Small, 1, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<Small, 1, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<1, Small, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<1, Small, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Small, Small, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<Small, Small, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Small, Small, 1> {
-  enum { ret = LazyCoeffBasedProductMode };
-};
+struct product_type_selector<Small, Small, 1> : std::integral_constant<int, LazyCoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Small, Large, 1> {
-  enum { ret = LazyCoeffBasedProductMode };
-};
+struct product_type_selector<Small, Large, 1> : std::integral_constant<int, LazyCoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Large, Small, 1> {
-  enum { ret = LazyCoeffBasedProductMode };
-};
+struct product_type_selector<Large, Small, 1> : std::integral_constant<int, LazyCoeffBasedProductMode> {};
 template <>
-struct product_type_selector<1, Large, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<1, Large, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<1, Large, Large> {
-  enum { ret = GemvProduct };
-};
+struct product_type_selector<1, Large, Large> : std::integral_constant<int, GemvProduct> {};
 template <>
-struct product_type_selector<1, Small, Large> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<1, Small, Large> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Large, 1, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<Large, 1, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Large, 1, Large> {
-  enum { ret = GemvProduct };
-};
+struct product_type_selector<Large, 1, Large> : std::integral_constant<int, GemvProduct> {};
 template <>
-struct product_type_selector<Small, 1, Large> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<Small, 1, Large> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Small, Small, Large> {
-  enum { ret = GemmProduct };
-};
+struct product_type_selector<Small, Small, Large> : std::integral_constant<int, GemmProduct> {};
 template <>
-struct product_type_selector<Large, Small, Large> {
-  enum { ret = GemmProduct };
-};
+struct product_type_selector<Large, Small, Large> : std::integral_constant<int, GemmProduct> {};
 template <>
-struct product_type_selector<Small, Large, Large> {
-  enum { ret = GemmProduct };
-};
+struct product_type_selector<Small, Large, Large> : std::integral_constant<int, GemmProduct> {};
 template <>
-struct product_type_selector<Large, Large, Large> {
-  enum { ret = GemmProduct };
-};
+struct product_type_selector<Large, Large, Large> : std::integral_constant<int, GemmProduct> {};
 template <>
-struct product_type_selector<Large, Small, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<Large, Small, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Small, Large, Small> {
-  enum { ret = CoeffBasedProductMode };
-};
+struct product_type_selector<Small, Large, Small> : std::integral_constant<int, CoeffBasedProductMode> {};
 template <>
-struct product_type_selector<Large, Large, Small> {
-  enum { ret = GemmProduct };
-};
+struct product_type_selector<Large, Large, Small> : std::integral_constant<int, GemmProduct> {};
 
 }  // end namespace internal
 
@@ -255,6 +303,97 @@
 #endif
 };
 
+template <typename ResScalar>
+using gemv_mapped_destination =
+    Map<Matrix<ResScalar, Dynamic, 1>, plain_enum_min(AlignedMax, internal::packet_traits<ResScalar>::size)>;
+
+template <typename Dest>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE gemv_mapped_destination<typename Dest::Scalar> gemv_construct_mapped_destination(
+    Dest& dest, typename Dest::Scalar* actual_dest_ptr) {
+#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+  constexpr int Size = Dest::SizeAtCompileTime;
+  Index size = dest.size();
+  EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+#endif
+  return gemv_mapped_destination<typename Dest::Scalar>(actual_dest_ptr, dest.size());
+}
+
+// Prepares the temporary destination shared by general, triangular, and selfadjoint GEMV kernels.
+template <bool EvalToDest, typename Dest>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void gemv_prepare_destination(Dest& dest,
+                                                                    typename Dest::Scalar* actual_dest_ptr) {
+  EIGEN_IF_CONSTEXPR (!EvalToDest) gemv_construct_mapped_destination(dest, actual_dest_ptr) = dest;
+}
+
+template <bool EvalToDest, typename Dest>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void gemv_prepare_destination(Dest& dest, typename Dest::Scalar* actual_dest_ptr,
+                                                                    bool initialize_to_zero) {
+  if (initialize_to_zero) {
+    gemv_construct_mapped_destination(dest, actual_dest_ptr).setZero();
+  } else {
+    gemv_prepare_destination<EvalToDest>(dest, actual_dest_ptr);
+  }
+}
+
+template <bool EvalToDest, typename Dest>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void gemv_copy_destination(Dest& dest, typename Dest::Scalar* actual_dest_ptr) {
+  EIGEN_IF_CONSTEXPR (!EvalToDest) {
+    dest = gemv_mapped_destination<typename Dest::Scalar>(actual_dest_ptr, dest.size());
+  }
+}
+
+// Adds complex-by-real scalar adaptation to the shared destination handling when necessary.
+template <typename RhsScalar, typename ResScalar, bool EvalToDestAtCompileTime, bool ComplexByReal>
+class gemv_destination_policy {
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit gemv_destination_policy(const ResScalar& alpha) : alpha_(alpha) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool eval_to_dest() const {
+    return EvalToDestAtCompileTime && alpha_is_compatible();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RhsScalar compatible_alpha() const {
+    return alpha_is_compatible() ? get_factor<ResScalar, RhsScalar>::run(alpha_) : RhsScalar(1);
+  }
+
+  template <typename Dest>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void prepare(Dest& dest, ResScalar* actual_dest_ptr) const {
+    gemv_prepare_destination<EvalToDestAtCompileTime>(dest, actual_dest_ptr, !alpha_is_compatible());
+  }
+
+  template <typename Dest>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void copy_back(Dest& dest, ResScalar* actual_dest_ptr) const {
+    if (!alpha_is_compatible()) {
+      dest.matrix() += alpha_ * gemv_mapped_destination<ResScalar>(actual_dest_ptr, dest.size());
+    } else {
+      gemv_copy_destination<EvalToDestAtCompileTime>(dest, actual_dest_ptr);
+    }
+  }
+
+ private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool alpha_is_compatible() const {
+    return !ComplexByReal || numext::is_exactly_zero(numext::imag(alpha_));
+  }
+
+  ResScalar alpha_;
+};
+
+// Copies a non-contiguous GEMV right-hand side into the aligned buffer allocated by the caller.
+template <bool DirectlyUseRhs, typename ActualRhsType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void gemv_prepare_rhs(
+    const ActualRhsType& rhs, typename remove_all_t<ActualRhsType>::Scalar* actual_rhs_ptr) {
+  using ActualRhsTypeCleaned = remove_all_t<ActualRhsType>;
+  EIGEN_IF_CONSTEXPR (!DirectlyUseRhs) {
+#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+    constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
+    Index size = rhs.size();
+    EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+#endif
+    // The caller obtains this temporary from ei_declare_aligned_stack_constructed_variable.
+    Map<typename ActualRhsTypeCleaned::PlainObject, AlignedMax>(actual_rhs_ptr, rhs.size()) = rhs;
+  }
+}
+
 // The vector is on the left => transposition
 template <int StorageOrder, bool BlasCompatible>
 struct gemv_dense_selector<OnTheLeft, StorageOrder, BlasCompatible> {
@@ -271,17 +410,14 @@
 struct gemv_dense_selector<OnTheRight, ColMajor, true> {
   template <typename Lhs, typename Rhs, typename Dest>
   static inline void run(const Lhs& lhs, const Rhs& rhs, Dest& dest, const typename Dest::Scalar& alpha) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Rhs::Scalar RhsScalar;
-    typedef typename Dest::Scalar ResScalar;
+    using LhsScalar = typename Lhs::Scalar;
+    using RhsScalar = typename Rhs::Scalar;
+    using ResScalar = typename Dest::Scalar;
 
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-
-    typedef Map<Matrix<ResScalar, Dynamic, 1>, plain_enum_min(AlignedMax, internal::packet_traits<ResScalar>::size)>
-        MappedDest;
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
 
     ActualLhsType actualLhs = LhsBlasTraits::extract(lhs);
     ActualRhsType actualRhs = RhsBlasTraits::extract(rhs);
@@ -289,53 +425,38 @@
     ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
 
     // make sure Dest is a compile-time vector type (bug 1166)
-    typedef std::conditional_t<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr> ActualDest;
+    using ActualDest = std::conditional_t<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr>;
 
     enum {
       // FIXME: find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
-      // on, the other hand it is good for the cache to pack the vector anyways...
+      // on the other hand it is good for the cache to pack the vector anyways...
       EvalToDestAtCompileTime = (ActualDest::InnerStrideAtCompileTime == 1),
       ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex),
       MightCannotUseDest = ((!EvalToDestAtCompileTime) || ComplexByReal) && (ActualDest::MaxSizeAtCompileTime != 0)
     };
 
-    typedef const_blas_data_mapper<LhsScalar, Index, ColMajor> LhsMapper;
-    typedef const_blas_data_mapper<RhsScalar, Index, RowMajor> RhsMapper;
-    RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
-
-    if (!MightCannotUseDest) {
+    using LhsMapper = const_blas_data_mapper<LhsScalar, Index, ColMajor>;
+    using RhsMapper = const_blas_data_mapper<RhsScalar, Index, RowMajor>;
+    EIGEN_IF_CONSTEXPR (!MightCannotUseDest) {
       // shortcut if we are sure to be able to use dest directly,
-      // this ease the compiler to generate cleaner and more optimzized code for most common cases
-      general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, LhsBlasTraits::NeedToConjugate, RhsScalar,
-                                    RhsMapper, RhsBlasTraits::NeedToConjugate>::run(actualLhs.rows(), actualLhs.cols(),
-                                                                                    LhsMapper(actualLhs.data(),
-                                                                                              actualLhs.outerStride()),
-                                                                                    RhsMapper(actualRhs.data(),
-                                                                                              actualRhs.innerStride()),
-                                                                                    dest.data(), 1, compatibleAlpha);
+      // this eases the compiler to generate cleaner and more optimized code for most common cases
+      general_matrix_vector_product<
+          Index, LhsScalar, LhsMapper, ColMajor, LhsBlasTraits::NeedToConjugate, RhsScalar, RhsMapper,
+          RhsBlasTraits::NeedToConjugate>::run(actualLhs.rows(), actualLhs.cols(),
+                                               LhsMapper(actualLhs.data(), actualLhs.outerStride()),
+                                               RhsMapper(actualRhs.data(), actualRhs.innerStride()), dest.data(), 1,
+                                               get_factor<ResScalar, RhsScalar>::run(actualAlpha));
     } else {
       gemv_static_vector_if<ResScalar, ActualDest::SizeAtCompileTime, ActualDest::MaxSizeAtCompileTime,
                             MightCannotUseDest>
           static_dest;
 
-      const bool alphaIsCompatible = (!ComplexByReal) || (numext::is_exactly_zero(numext::imag(actualAlpha)));
-      const bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
+      gemv_destination_policy<RhsScalar, ResScalar, EvalToDestAtCompileTime, ComplexByReal> destPolicy(actualAlpha);
 
       ei_declare_aligned_stack_constructed_variable(ResScalar, actualDestPtr, dest.size(),
-                                                    evalToDest ? dest.data() : static_dest.data());
+                                                    destPolicy.eval_to_dest() ? dest.data() : static_dest.data());
 
-      if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-        constexpr int Size = Dest::SizeAtCompileTime;
-        Index size = dest.size();
-        EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
-        if (!alphaIsCompatible) {
-          MappedDest(actualDestPtr, dest.size()).setZero();
-          compatibleAlpha = RhsScalar(1);
-        } else
-          MappedDest(actualDestPtr, dest.size()) = dest;
-      }
+      destPolicy.prepare(dest, actualDestPtr);
 
       general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, LhsBlasTraits::NeedToConjugate, RhsScalar,
                                     RhsMapper, RhsBlasTraits::NeedToConjugate>::run(actualLhs.rows(), actualLhs.cols(),
@@ -343,14 +464,10 @@
                                                                                               actualLhs.outerStride()),
                                                                                     RhsMapper(actualRhs.data(),
                                                                                               actualRhs.innerStride()),
-                                                                                    actualDestPtr, 1, compatibleAlpha);
+                                                                                    actualDestPtr, 1,
+                                                                                    destPolicy.compatible_alpha());
 
-      if (!evalToDest) {
-        if (!alphaIsCompatible)
-          dest.matrix() += actualAlpha * MappedDest(actualDestPtr, dest.size());
-        else
-          dest = MappedDest(actualDestPtr, dest.size());
-      }
+      destPolicy.copy_back(dest, actualDestPtr);
     }
   }
 };
@@ -359,15 +476,15 @@
 struct gemv_dense_selector<OnTheRight, RowMajor, true> {
   template <typename Lhs, typename Rhs, typename Dest>
   static void run(const Lhs& lhs, const Rhs& rhs, Dest& dest, const typename Dest::Scalar& alpha) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Rhs::Scalar RhsScalar;
-    typedef typename Dest::Scalar ResScalar;
+    using LhsScalar = typename Lhs::Scalar;
+    using RhsScalar = typename Rhs::Scalar;
+    using ResScalar = typename Dest::Scalar;
 
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-    typedef internal::remove_all_t<ActualRhsType> ActualRhsTypeCleaned;
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
+    using ActualRhsTypeCleaned = internal::remove_all_t<ActualRhsType>;
 
     std::add_const_t<ActualLhsType> actualLhs = LhsBlasTraits::extract(lhs);
     std::add_const_t<ActualRhsType> actualRhs = RhsBlasTraits::extract(rhs);
@@ -376,7 +493,7 @@
 
     enum {
       // FIXME: find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
-      // on, the other hand it is good for the cache to pack the vector anyways...
+      // on the other hand it is good for the cache to pack the vector anyways...
       DirectlyUseRhs =
           ActualRhsTypeCleaned::InnerStrideAtCompileTime == 1 || ActualRhsTypeCleaned::MaxSizeAtCompileTime == 0
     };
@@ -389,17 +506,10 @@
         RhsScalar, actualRhsPtr, actualRhs.size(),
         DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
 
-    if (!DirectlyUseRhs) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-      constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
-      Index size = actualRhs.size();
-      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
-      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
-    }
+    gemv_prepare_rhs<DirectlyUseRhs>(actualRhs, actualRhsPtr);
 
-    typedef const_blas_data_mapper<LhsScalar, Index, RowMajor> LhsMapper;
-    typedef const_blas_data_mapper<RhsScalar, Index, ColMajor> RhsMapper;
+    using LhsMapper = const_blas_data_mapper<LhsScalar, Index, RowMajor>;
+    using RhsMapper = const_blas_data_mapper<RhsScalar, Index, ColMajor>;
     general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, LhsBlasTraits::NeedToConjugate, RhsScalar,
                                   RhsMapper, RhsBlasTraits::NeedToConjugate>::
         run(actualLhs.rows(), actualLhs.cols(), LhsMapper(actualLhs.data(), actualLhs.outerStride()),
@@ -515,4 +625,4 @@
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_PRODUCT_H
+#endif  // EIGEN_GENERAL_PRODUCT_H
diff --git a/Eigen/src/Core/GenericPacketMath.h b/Eigen/src/Core/GenericPacketMath.h
index 10c798a..f4e4e6d 100644
--- a/Eigen/src/Core/GenericPacketMath.h
+++ b/Eigen/src/Core/GenericPacketMath.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERIC_PACKET_MATH_H
 #define EIGEN_GENERIC_PACKET_MATH_H
@@ -87,6 +88,8 @@
     HasATanh = 0,
     HasSinh = 0,
     HasCosh = 0,
+    HasASinh = 0,
+    HasACosh = 0,
     HasTanh = 0,
     HasLGamma = 0,
     HasDiGamma = 0,
@@ -106,8 +109,8 @@
 
 template <typename T>
 struct packet_traits : default_packet_traits {
-  typedef T type;
-  typedef T half;
+  using type = T;
+  using half = T;
   enum {
     Vectorizable = 0,
     size = 1,
@@ -137,9 +140,9 @@
 
 template <typename T>
 struct unpacket_traits : default_unpacket_traits {
-  typedef T type;
-  typedef T half;
-  typedef typename numext::get_integer_by_size<sizeof(T)>::signed_type integer_packet;
+  using type = T;
+  using half = T;
+  using integer_packet = typename numext::get_integer_by_size<sizeof(T)>::signed_type;
   enum {
     size = 1,
     alignment = alignof(T),
@@ -153,10 +156,7 @@
  * This is used to enable some generic packet implementations.
  */
 template <typename Packet>
-struct is_scalar {
-  using Scalar = typename unpacket_traits<Packet>::type;
-  enum { value = internal::is_same<Packet, Scalar>::value };
-};
+struct is_scalar : std::is_same<Packet, typename unpacket_traits<Packet>::type> {};
 
 // automatically and succinctly define combinations of pcast<SrcPacket,TgtPacket> when
 // 1) the packets are the same type, or
@@ -164,7 +164,7 @@
 // In both of these cases, preinterpret (bit_cast) is equivalent to pcast (static_cast)
 template <typename SrcPacket, typename TgtPacket,
           bool Scalar = is_scalar<SrcPacket>::value && is_scalar<TgtPacket>::value>
-struct is_degenerate_helper : is_same<SrcPacket, TgtPacket> {};
+struct is_degenerate_helper : std::is_same<SrcPacket, TgtPacket> {};
 template <>
 struct is_degenerate_helper<int8_t, uint8_t, true> : std::true_type {};
 template <>
@@ -222,7 +222,7 @@
 };
 
 /** \internal Wrapper to ensure that multiple packet types can map to the same
-    same underlying vector type. */
+    underlying vector type. */
 template <typename T, int unique_id = 0>
 struct eigen_packet_wrapper {
   EIGEN_ALWAYS_INLINE operator T&() { return m_val; }
@@ -237,7 +237,7 @@
   T m_val;
 };
 
-template <typename Target, typename Packet, bool IsSame = is_same<Target, Packet>::value>
+template <typename Target, typename Packet, bool IsSame = std::is_same<Target, Packet>::value>
 struct preinterpret_generic;
 
 template <typename Target, typename Packet>
@@ -326,10 +326,11 @@
 EIGEN_DEVICE_FUNC inline Packet padd(const Packet& a, const Packet& b) {
   return a + b;
 }
-// Avoid compiler warning for boolean algebra.
+// Bool arithmetic is specialized to avoid compiler warnings. Bitwise operations are intentional to keep scalar
+// evaluator loops branch-free.
 template <>
 EIGEN_DEVICE_FUNC inline bool padd(const bool& a, const bool& b) {
-  return a || b;
+  return a | b;
 }
 
 /** \internal \returns a packet version of \a *from, (un-aligned masked add)
@@ -349,26 +350,29 @@
 /** \internal \returns -a (coeff-wise) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pnegate(const Packet& a) {
-  EIGEN_STATIC_ASSERT((!is_same<typename unpacket_traits<Packet>::type, bool>::value),
+  EIGEN_STATIC_ASSERT((!std::is_same<typename unpacket_traits<Packet>::type, bool>::value),
                       NEGATE IS NOT DEFINED FOR BOOLEAN TYPES)
   return numext::negate(a);
 }
 
 /** \internal \returns conj(a) (coeff-wise) */
 template <typename Packet>
-EIGEN_DEVICE_FUNC inline Packet pconj(const Packet& a) {
-  return numext::conj(a);
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pconj(const Packet& a) {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex)
+    return numext::conj(a);
+  else
+    return a;
 }
 
 /** \internal \returns a * b (coeff-wise) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pmul(const Packet& a, const Packet& b) {
-  return a * b;
+  return internal::mul(a, b);
 }
-// Avoid compiler warning for boolean algebra.
 template <>
 EIGEN_DEVICE_FUNC inline bool pmul(const bool& a, const bool& b) {
-  return a && b;
+  return a & b;
 }
 
 /** \internal \returns a / b (coeff-wise) */
@@ -376,10 +380,9 @@
 EIGEN_DEVICE_FUNC inline Packet pdiv(const Packet& a, const Packet& b) {
   return a / b;
 }
-// Avoid compiler warning for boolean algebra.
 template <>
 EIGEN_DEVICE_FUNC inline bool pdiv(const bool& a, const bool& b) {
-  return a && b;
+  return a & b;
 }
 
 // In the generic packet case, memset to all one bits.
@@ -404,10 +407,21 @@
   static EIGEN_DEVICE_FUNC inline bool run(const bool&) { return true; }
 };
 
+// The all-ones value of a floating-point packet is a NaN bit pattern, which fast-math builds
+// may fold to poison; see EIGEN_FAST_MATH_CONSTANT_BARRIER in Macros.h. The same applies to
+// peven_mask, pinf and pnan below.
 /** \internal \returns one bits. */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet ptrue(const Packet& a) {
-  return ptrue_impl<Packet>::run(a);
+  if (is_scalar<Packet>::value || std::is_same<Packet, bool>::value) {
+    // Scalar and boolean "masks" hold the value one, which is a legal value class; delegating
+    // to ptrue_impl (and its specializations) is safe here.
+    return ptrue_impl<Packet>::run(a);
+  }
+  Packet b;
+  memset(static_cast<void*>(&b), 0xff, sizeof(Packet));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(b);
+  return b;
 }
 
 // In the general packet case, memset to zero.
@@ -455,12 +469,12 @@
 
 template <>
 struct bit_and<bool> {
-  EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE bool operator()(const bool& a, const bool& b) const { return a && b; }
+  EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE bool operator()(const bool& a, const bool& b) const { return a & b; }
 };
 
 template <>
 struct bit_or<bool> {
-  EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE bool operator()(const bool& a, const bool& b) const { return a || b; }
+  EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE bool operator()(const bool& a, const bool& b) const { return a | b; }
 };
 
 template <>
@@ -525,8 +539,8 @@
 
 // For integers or non-trivial scalars, use binary operators.
 template <typename T>
-struct bitwise_helper<T, typename std::enable_if_t<is_scalar<T>::value &&
-                                                   (NumTraits<T>::IsInteger || NumTraits<T>::RequireInitialization)>>
+struct bitwise_helper<
+    T, std::enable_if_t<is_scalar<T>::value && (NumTraits<T>::IsInteger || NumTraits<T>::RequireInitialization)>>
     : public operator_bitwise_helper<T> {};
 
 /** \internal \returns the bitwise and of \a a and \a b */
@@ -610,9 +624,15 @@
   return cond ? a : b;
 }
 
+/** \internal Whether plain pmin/pmax already propagate NaN for \a Packet. */
+template <typename Packet>
+struct pminmax_propagates_nan : bool_constant<false> {};
+
 /** \internal \returns the min or max of \a a and \a b (coeff-wise)
-    If either \a a or \a b are NaN, the result is implementation defined. */
-template <int NaNPropagation, bool IsInteger>
+    If either \a a or \a b are NaN, the result is implementation defined, except that a
+    PropagateNaN request on a packet whose plain pmin/pmax already propagates NaN
+    (\a NativePropagatesNaN) returns NaN. */
+template <int NaNPropagation, bool IsInteger, bool NativePropagatesNaN = false>
 struct pminmax_impl {
   template <typename Packet, typename Op>
   static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
@@ -623,9 +643,13 @@
 /** \internal \returns the min or max of \a a and \a b (coeff-wise)
     If either \a a or \a b are NaN, NaN is returned. */
 template <>
-struct pminmax_impl<PropagateNaN, false> {
+struct pminmax_impl<PropagateNaN, false, false> {
   template <typename Packet, typename Op>
   static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
+    // pselect is an ordinary call, so op(a, b) is evaluated even where an operand is NaN;
+    // only its result is discarded there. op therefore need not propagate NaN, but must
+    // still be well-defined on NaN input. Operands stay in the caller's order so that op
+    // selects the same one on a signed-zero tie as plain pmin/pmax does for this Packet.
     Packet not_nan_mask_a = pcmp_eq(a, a);
     Packet not_nan_mask_b = pcmp_eq(b, b);
     return pselect(not_nan_mask_a, pselect(not_nan_mask_b, op(a, b), b), a);
@@ -635,8 +659,8 @@
 /** \internal \returns the min or max of \a a and \a b (coeff-wise)
     If both \a a and \a b are NaN, NaN is returned.
     Equivalent to std::fmin(a, b).  */
-template <>
-struct pminmax_impl<PropagateNumbers, false> {
+template <bool NativePropagatesNaN>
+struct pminmax_impl<PropagateNumbers, false, NativePropagatesNaN> {
   template <typename Packet, typename Op>
   static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a, const Packet& b, Op op) {
     Packet not_nan_mask_a = pcmp_eq(a, a);
@@ -659,7 +683,9 @@
 template <int NaNPropagation, typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pmin(const Packet& a, const Packet& b) {
   constexpr bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger;
-  return pminmax_impl<NaNPropagation, IsInteger>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmin<Packet>)));
+  constexpr bool NativePropagatesNaN = pminmax_propagates_nan<Packet>::value;
+  return pminmax_impl<NaNPropagation, IsInteger, NativePropagatesNaN>::run(
+      a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmin<Packet>)));
 }
 
 /** \internal \returns the max of \a a and \a b  (coeff-wise)
@@ -674,24 +700,23 @@
 template <int NaNPropagation, typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pmax(const Packet& a, const Packet& b) {
   constexpr bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger;
-  return pminmax_impl<NaNPropagation, IsInteger>::run(a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmax<Packet>)));
+  constexpr bool NativePropagatesNaN = pminmax_propagates_nan<Packet>::value;
+  return pminmax_impl<NaNPropagation, IsInteger, NativePropagatesNaN>::run(
+      a, b, EIGEN_BINARY_OP_NAN_PROPAGATION(Packet, (pmax<Packet>)));
 }
 
 /** \internal \returns the absolute value of \a a */
-template <typename Packet>
+template <typename Packet, std::enable_if_t<!(NumTraits<typename unpacket_traits<Packet>::type>::IsInteger &&
+                                              !NumTraits<typename unpacket_traits<Packet>::type>::IsSigned),
+                                            int> = 0>
 EIGEN_DEVICE_FUNC inline Packet pabs(const Packet& a) {
   return numext::abs(a);
 }
-template <>
-EIGEN_DEVICE_FUNC inline unsigned int pabs(const unsigned int& a) {
-  return a;
-}
-template <>
-EIGEN_DEVICE_FUNC inline unsigned long pabs(const unsigned long& a) {
-  return a;
-}
-template <>
-EIGEN_DEVICE_FUNC inline unsigned long long pabs(const unsigned long long& a) {
+
+template <typename Packet, std::enable_if_t<NumTraits<typename unpacket_traits<Packet>::type>::IsInteger &&
+                                                !NumTraits<typename unpacket_traits<Packet>::type>::IsSigned,
+                                            int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pabs(const Packet& a) {
   return a;
 }
 
@@ -747,7 +772,7 @@
   return static_cast<Packet>(ldexp(a, static_cast<int>(exponent)));
 }
 
-/** \internal \returns the min of \a a and \a b  (coeff-wise) */
+/** \internal \returns the absolute difference of \a a and \a b  (coeff-wise) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline std::enable_if_t<NumTraits<typename unpacket_traits<Packet>::type>::IsInteger, Packet>
 pabsdiff(const Packet& a, const Packet& b) {
@@ -774,8 +799,8 @@
                                               const Index offset = 0) {
   const Index packet_size = unpacket_traits<Packet>::size;
   eigen_assert(n + offset <= packet_size && "number of elements plus offset will read past end of packet");
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  EIGEN_ALIGN_MAX Scalar elements[packet_size] = {Scalar(0)};
+  using Scalar = typename unpacket_traits<Packet>::type;
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[packet_size] = {Scalar(0)};
   for (Index i = offset; i < numext::mini(n + offset, packet_size); i++) {
     elements[i] = from[i - offset];
   }
@@ -795,8 +820,8 @@
                                                const Index offset = 0) {
   const Index packet_size = unpacket_traits<Packet>::size;
   eigen_assert(n + offset <= packet_size && "number of elements plus offset will read past end of packet");
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  EIGEN_ALIGN_MAX Scalar elements[packet_size] = {Scalar(0)};
+  using Scalar = typename unpacket_traits<Packet>::type;
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[packet_size] = {Scalar(0)};
   for (Index i = offset; i < numext::mini(n + offset, packet_size); i++) {
     elements[i] = from[i - offset];
   }
@@ -819,12 +844,148 @@
 
 /** \internal \returns a packet with constant coefficients set from bits */
 template <typename Packet, typename BitsType>
-EIGEN_DEVICE_FUNC inline Packet pset1frombits(BitsType a);
+EIGEN_DEVICE_FUNC inline Packet pset1frombits(BitsType a) {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  return pset1<Packet>(numext::bit_cast<Scalar>(a));
+}
+
+template <typename Packet>
+struct packet_bit_pattern_traits {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  enum { HasIntegerBits = !std::is_void<Bits>::value };
+};
+
+// Widening an opaque IEEE binary32 bit pattern produces the target's native extended-scalar representation without
+// exposing a floating-point special-value literal to fast-math optimizers.
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar pscalar_from_float_bits(numext::uint32_t bits) {
+#if EIGEN_COMP_GNUC_STRICT && defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__ && \
+    !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
+  // GCC also needs the integer pattern hidden before bit_cast and widening. Use a memory operand so this works on
+  // targets where EIGEN_OPTIMIZATION_BARRIER is intentionally unavailable.
+  __asm__("" : "+m"(bits));
+#endif
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(bits);
+  return static_cast<Scalar>(numext::bit_cast<float>(bits));
+}
+
+template <typename Packet, bool HasIntegerBits = packet_bit_pattern_traits<Packet>::HasIntegerBits,
+          bool IsScalar = is_scalar<Packet>::value>
+struct psignmask_impl;
+
+template <typename Packet, bool IsScalar>
+struct psignmask_impl<Packet, true, IsScalar> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet run() {
+    using Scalar = typename packet_bit_pattern_traits<Packet>::Scalar;
+    using Bits = typename packet_bit_pattern_traits<Packet>::Bits;
+    constexpr Bits kSignBit = static_cast<Bits>(Bits(1) << (CHAR_BIT * sizeof(Scalar) - 1));
+    return pset1frombits<Packet, Bits>(kSignBit);
+  }
+};
+
+template <typename Scalar>
+struct psignmask_impl<Scalar, false, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar run() { return pscalar_from_float_bits<Scalar>(0x80000000u); }
+};
+
+/** \internal \returns a packet with all coefficients set to -0.0, i.e. with only the sign bit set.
+ *
+ * When the lane type has a same-size integer type, the mask is deliberately constructed from the integer sign-bit
+ * pattern via pset1frombits instead of the floating-point literal -Scalar(0): under fast-math flags (-ffast-math
+ * implies -fno-signed-zeros) compilers may treat -0.0 and +0.0 as interchangeable, and e.g. GCC's value numbering
+ * substitutes a splat of -0.0 with a nearby splat of +0.0, silently zeroing the mask and corrupting sign manipulation
+ * of non-zero values. Architectures that specialize pset1frombits keep the constant in the integer domain, where no
+ * floating-point simplification applies. Extended scalar types without a same-size integer use their native -0.0
+ * representation instead. See https://gitlab.com/libeigen/eigen/-/merge_requests/2698.
+ */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet psignmask() {
+  return psignmask_impl<Packet>::run();
+}
+
+/** \internal \returns a packet with all coefficients set to +infinity.
+ *
+ * When the lane type has a same-size integer type, the constant is constructed from its integer bit pattern via
+ * pset1frombits rather than from a floating-point infinity literal: under fast-math flags (-ffast-math implies
+ * -ffinite-math-only) an infinity or NaN literal is undefined behavior, and clang turns it into a poison value that
+ * deletes the surrounding special-case handling — or the entire containing expression — at compile time. The bit
+ * pattern is inert: comparisons against it simply fold to false when the compiler assumes finite math, and selects
+ * using it as an arm keep or drop the special case as appropriate. Extended scalar types without a same-size integer
+ * widen an opaque IEEE binary32 bit pattern instead.
+ */
+template <typename Packet, bool HasIntegerBits = packet_bit_pattern_traits<Packet>::HasIntegerBits,
+          bool IsScalar = is_scalar<Packet>::value>
+struct pinf_impl;
+
+template <typename Packet, bool IsScalar>
+struct pinf_impl<Packet, true, IsScalar> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet run() {
+    using Scalar = typename packet_bit_pattern_traits<Packet>::Scalar;
+    using Bits = typename packet_bit_pattern_traits<Packet>::Bits;
+    constexpr int kMantissaBits = std::numeric_limits<Scalar>::digits - 1;
+    constexpr int kExponentBits = static_cast<int>(CHAR_BIT * sizeof(Scalar)) - 1 - kMantissaBits;
+    constexpr Bits kInf = static_cast<Bits>(((Bits(1) << kExponentBits) - 1) << kMantissaBits);
+    return pset1frombits<Packet, Bits>(kInf);
+  }
+};
+
+template <typename Scalar>
+struct pinf_impl<Scalar, false, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar run() { return pscalar_from_float_bits<Scalar>(0x7f800000u); }
+};
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet pinf() {
+  return pinf_impl<Packet>::run();
+}
+
+/** \internal \returns a packet with all coefficients set to a quiet NaN, using the same construction as pinf(). */
+template <typename Packet, bool HasIntegerBits = packet_bit_pattern_traits<Packet>::HasIntegerBits,
+          bool IsScalar = is_scalar<Packet>::value>
+struct pnan_impl;
+
+template <typename Packet, bool IsScalar>
+struct pnan_impl<Packet, true, IsScalar> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet run() {
+    using Scalar = typename packet_bit_pattern_traits<Packet>::Scalar;
+    using Bits = typename packet_bit_pattern_traits<Packet>::Bits;
+    constexpr int kMantissaBits = std::numeric_limits<Scalar>::digits - 1;
+    constexpr int kExponentBits = static_cast<int>(CHAR_BIT * sizeof(Scalar)) - 1 - kMantissaBits;
+    constexpr Bits kInf = static_cast<Bits>(((Bits(1) << kExponentBits) - 1) << kMantissaBits);
+    constexpr Bits kNaN = static_cast<Bits>(kInf | (Bits(1) << (kMantissaBits - 1)));
+    return pset1frombits<Packet, Bits>(kNaN);
+  }
+};
+
+template <typename Scalar>
+struct pnan_impl<Scalar, false, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar run() { return pscalar_from_float_bits<Scalar>(0x7fc00000u); }
+};
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet pnan() {
+  return pnan_impl<Packet>::run();
+}
+
+template <typename Scalar, std::enable_if_t<std::is_trivially_copyable<Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC inline Scalar pload1_scalar(const Scalar* a) {
+  Scalar scalar;
+  EIGEN_USING_STD(memcpy)
+  memcpy(&scalar, a, sizeof(Scalar));
+  return scalar;
+}
+
+template <typename Scalar, std::enable_if_t<!std::is_trivially_copyable<Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC inline Scalar pload1_scalar(const Scalar* a) {
+  return Scalar(*a);
+}
 
 /** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pload1(const typename unpacket_traits<Packet>::type* a) {
-  return pset1<Packet>(*a);
+  using Scalar = typename unpacket_traits<Packet>::type;
+  return pset1<Packet>(pload1_scalar<Scalar>(a));
 }
 
 /** \internal \returns a packet with elements of \a *from duplicated.
@@ -834,7 +995,7 @@
  */
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet ploaddup(const typename unpacket_traits<Packet>::type* from) {
-  return *from;
+  return pload1<Packet>(from);
 }
 
 /** \internal \returns a packet with elements of \a *from quadrupled.
@@ -885,29 +1046,23 @@
   return a;
 }
 
-template <typename Packet, typename EnableIf = void>
-struct peven_mask_impl {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet&) {
-    typedef typename unpacket_traits<Packet>::type Scalar;
-    const size_t n = unpacket_traits<Packet>::size;
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar elements[n];
-    for (size_t i = 0; i < n; ++i) {
-      memset(elements + i, ((i & 1) == 0 ? 0xff : 0), sizeof(Scalar));
-    }
-    return ploadu<Packet>(elements);
-  }
-};
-
-template <typename Scalar>
-struct peven_mask_impl<Scalar, std::enable_if_t<is_scalar<Scalar>::value>> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar run(const Scalar&) { return Scalar(1); }
-};
-
 /** \internal \returns a packet with constant coefficients \a a, e.g.: (x, 0, x, 0),
      where x is the value of all 1-bits. */
 template <typename Packet>
-EIGEN_DEVICE_FUNC inline Packet peven_mask(const Packet& a) {
-  return peven_mask_impl<Packet>::run(a);
+EIGEN_DEVICE_FUNC inline Packet peven_mask(const Packet& /*a*/) {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  if (is_scalar<Packet>::value) {
+    // The scalar "mask" is numeric: true is represented by the value one.
+    return pset1<Packet>(Scalar(1));
+  }
+  const size_t n = unpacket_traits<Packet>::size;
+  Packet b;
+  char* bytes = reinterpret_cast<char*>(&b);
+  for (size_t i = 0; i < n; ++i) {
+    memset(bytes + i * sizeof(Scalar), ((i & 1) == 0 ? 0xff : 0), sizeof(Scalar));
+  }
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(b);
+  return b;
 }
 
 /** \internal copy the packet \a from to \a *to, \a to must be properly aligned */
@@ -923,7 +1078,7 @@
 EIGEN_DEVICE_FUNC inline void pstore_partial(Scalar* to, const Packet& from, const Index n, const Index offset = 0) {
   const Index packet_size = unpacket_traits<Packet>::size;
   eigen_assert(n + offset <= packet_size && "number of elements plus offset will write past end of packet");
-  EIGEN_ALIGN_MAX Scalar elements[packet_size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[packet_size];
   pstore<Scalar>(elements, from);
   for (Index i = 0; i < numext::mini(n, packet_size - offset); i++) {
     to[i] = elements[i + offset];
@@ -941,7 +1096,7 @@
 EIGEN_DEVICE_FUNC inline void pstoreu_partial(Scalar* to, const Packet& from, const Index n, const Index offset = 0) {
   const Index packet_size = unpacket_traits<Packet>::size;
   eigen_assert(n + offset <= packet_size && "number of elements plus offset will write past end of packet");
-  EIGEN_ALIGN_MAX Scalar elements[packet_size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[packet_size];
   pstore<Scalar>(elements, from);
   for (Index i = 0; i < numext::mini(n, packet_size - offset); i++) {
     to[i] = elements[i + offset];
@@ -964,7 +1119,7 @@
 template <typename Scalar, typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pgather_partial(const Scalar* from, Index stride, const Index n) {
   const Index packet_size = unpacket_traits<Packet>::size;
-  EIGEN_ALIGN_MAX Scalar elements[packet_size] = {Scalar(0)};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[packet_size] = {Scalar(0)};
   for (Index i = 0; i < numext::mini(n, packet_size); i++) {
     elements[i] = from[i * stride];
   }
@@ -979,7 +1134,7 @@
 template <typename Scalar, typename Packet>
 EIGEN_DEVICE_FUNC inline void pscatter_partial(Scalar* to, const Packet& from, Index stride, const Index n) {
   const Index packet_size = unpacket_traits<Packet>::size;
-  EIGEN_ALIGN_MAX Scalar elements[packet_size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[packet_size];
   pstore<Scalar>(elements, from);
   for (Index i = 0; i < numext::mini(n, packet_size); i++) {
     to[i * stride] = elements[i];
@@ -1006,7 +1161,7 @@
 
 /** \internal \returns the reversed elements of \a a*/
 template <typename Packet>
-EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a) {
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet preverse(const Packet& a) {
   return a;
 }
 
@@ -1034,18 +1189,89 @@
  * Special math functions
  ***************************/
 
+// Implemented without ptrue: an all-ones float packet is a NaN bit pattern, which under
+// fast-math flags clang turns into a poison constant that deletes any expression it flows
+// into.
+template <typename Packet, bool IsComplex = NumTraits<typename unpacket_traits<Packet>::type>::IsComplex,
+          bool IsScalar = is_scalar<Packet>::value,
+          bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>
+struct pisnan_impl {
+  // Equivalent to !(a == a).
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) { return pcmp_lt_or_nan(a, a); }
+};
+
+// Integer scalars have no NaN; the answer is the all-false mask. The generic path is unusable
+// here: pcmp_lt_or_nan has no meaningful integer semantics (and its generic form does not even
+// compile for integer SIMD packets).
+template <typename Packet, bool IsScalar>
+struct pisnan_impl<Packet, false, IsScalar, true> {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) { return pzero(a); }
+};
+
+template <typename Packet, bool IsInteger>
+struct pisnan_impl<Packet, true, false, IsInteger> {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) {
+    using RealPacket = typename unpacket_traits<Packet>::as_real;
+    // A NaN in either the real or the imaginary lane marks the whole complex element.
+    Packet nan_lanes = Packet(pcmp_lt_or_nan<RealPacket>(a.v, a.v));
+    return por(nan_lanes, pcplxflip(nan_lanes));
+  }
+};
+
+// Scalar complex arguments have no wrapped real packet; combine the per-component results in the
+// value domain, where the scalar mask convention is Scalar(1)/Scalar(0).
+template <typename Scalar, bool IsInteger>
+struct pisnan_impl<Scalar, true, true, IsInteger> {
+  static EIGEN_DEVICE_FUNC inline Scalar run(const Scalar& a) {
+    using RealScalar = typename NumTraits<Scalar>::Real;
+    const RealScalar nan_mask =
+        por(pisnan_impl<RealScalar>::run(numext::real(a)), pisnan_impl<RealScalar>::run(numext::imag(a)));
+    return Scalar(nan_mask);
+  }
+};
+
 /** \internal \returns isnan(a) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pisnan(const Packet& a) {
-  return pandnot(ptrue(a), pcmp_eq(a, a));
+  return pisnan_impl<Packet>::run(a);
 }
 
+template <typename Packet, bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>
+struct pisinf_impl {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) { return pcmp_eq(pabs(a), pinf<Packet>()); }
+};
+
+// Integer scalars have no infinity; the answer is the all-false mask. The generic path is wrong
+// for them: pinf() synthesizes its bit pattern from numeric_limits digits, which for int32 yields
+// 2^30, so |a| == 2^30 would read as "inf".
+template <typename Packet>
+struct pisinf_impl<Packet, true> {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) { return pzero(a); }
+};
+
 /** \internal \returns isinf(a) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pisinf(const Packet& a) {
-  using Scalar = typename unpacket_traits<Packet>::type;
-  constexpr Scalar inf = NumTraits<Scalar>::infinity();
-  return pcmp_eq(pabs(a), pset1<Packet>(inf));
+  return pisinf_impl<Packet>::run(a);
+}
+
+template <typename Packet, bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>
+struct pisfinite_impl {
+  // |a| < inf is a single comparison that is false for both NaN and infinities.
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) { return pcmp_lt(pabs(a), pinf<Packet>()); }
+};
+
+// Integer scalars are always finite; the answer is the all-true mask (safe for integer packets,
+// where all-ones is not a NaN bit pattern).
+template <typename Packet>
+struct pisfinite_impl<Packet, true> {
+  static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) { return ptrue(a); }
+};
+
+/** \internal \returns isfinite(a) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC inline Packet pisfinite(const Packet& a) {
+  return pisfinite_impl<Packet>::run(a);
 }
 
 /** \internal \returns the sine of \a a (coeff-wise) */
@@ -1118,6 +1344,20 @@
   return atanh(a);
 }
 
+/** \internal \returns the inverse hyperbolic sine of \a a (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasinh(const Packet& a) {
+  EIGEN_USING_STD(asinh);
+  return asinh(a);
+}
+
+/** \internal \returns the inverse hyperbolic cosine of \a a (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacosh(const Packet& a) {
+  EIGEN_USING_STD(acosh);
+  return acosh(a);
+}
+
 /** \internal \returns the exp of \a a (coeff-wise) */
 template <typename Packet>
 EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp(const Packet& a) {
@@ -1253,9 +1493,9 @@
 // Slow generic implementation of Packet reduction.
 template <typename Packet, typename Op>
 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_helper(const Packet& a, Op op) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   const size_t n = unpacket_traits<Packet>::size;
-  EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Scalar elements[n];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar elements[n];
   pstoreu<Scalar>(elements, a);
   for (size_t k = n / 2; k > 0; k /= 2) {
     for (size_t i = 0; i < k; ++i) {
@@ -1265,30 +1505,35 @@
   return elements[0];
 }
 
+template <typename Packet, std::enable_if_t<unpacket_traits<Packet>::size == 1, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename unpacket_traits<Packet>::type predux_one_element(const Packet& a) {
+  return pfirst(a);
+}
+
 /** \internal \returns the sum of the elements of \a a*/
 template <typename Packet>
-EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux(const Packet& a) {
-  return a;
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename unpacket_traits<Packet>::type predux(const Packet& a) {
+  return predux_one_element(a);
 }
 
 /** \internal \returns the product of the elements of \a a */
 template <typename Packet>
-EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_mul(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename unpacket_traits<Packet>::type predux_mul(const Packet& a) {
+  using Scalar = typename unpacket_traits<Packet>::type;
   return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmul<Scalar>)));
 }
 
 /** \internal \returns the min of the elements of \a a */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmin<Scalar>)));
 }
 
 /** \internal \returns the max of the elements of \a a */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   return predux_helper(a, EIGEN_BINARY_OP_NAN_PROPAGATION(Scalar, (pmax<Scalar>)));
 }
 
@@ -1326,10 +1571,33 @@
 
 #undef EIGEN_BINARY_OP_NAN_PROPAGATION
 
-/** \internal \returns true if all coeffs of \a a means "true"
- * It is supposed to be called on values returned by pcmp_*.
- */
-// TODO: implement predux_all when needed.
+template <typename Packet, bool IsBoolean = std::is_same<typename unpacket_traits<Packet>::type, bool>::value>
+struct predux_count_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(const Packet& a) {
+    using Scalar = typename unpacket_traits<Packet>::type;
+    const Packet true_values = pandnot(pset1<Packet>(Scalar(1)), pcmp_eq(a, pzero(a)));
+    return static_cast<Index>(numext::real(predux(true_values)));
+  }
+};
+
+template <typename Packet>
+struct predux_count_impl<Packet, true> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(const Packet& a) {
+    using Scalar = typename unpacket_traits<Packet>::type;
+    constexpr int PacketSize = unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar values[PacketSize];
+    pstoreu<Scalar>(values, a);
+    Index result = 0;
+    for (int i = 0; i < PacketSize; ++i) result += values[i] ? 1 : 0;
+    return result;
+  }
+};
+
+/** \internal \returns the number of nonzero coefficients in \a a. */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index predux_count(const Packet& a) {
+  return predux_count_impl<Packet>::run(a);
+}
 
 /** \internal \returns true if any coeffs of \a a means "true"
  * It is supposed to be called on values returned by pcmp_*.
@@ -1341,11 +1609,28 @@
   //  - Scalar(1)
   //  - bits full of ones (NaN for floats),
   //  - or first bit equals to 1 (1 for ints, smallest denormal for floats).
-  // For all these cases, taking the sum is just fine, and this boils down to a no-op for scalars.
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  // This arithmetic fallback boils down to a no-op for scalars. Vector backends whose masks use floating-point bit
+  // patterns must specialize this with an integer-bit reduction because fast-math or FTZ can discard those values.
+  using Scalar = typename unpacket_traits<Packet>::type;
   return numext::not_equal_strict(predux(a), Scalar(0));
 }
 
+template <typename Packet, bool IsBoolean = std::is_same<typename unpacket_traits<Packet>::type, bool>::value>
+struct predux_all_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool run(const Packet& a) { return !predux_any(pcmp_eq(a, pzero(a))); }
+};
+
+template <typename Packet>
+struct predux_all_impl<Packet, true> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool run(const Packet& a) { return predux_mul(a); }
+};
+
+/** \internal \returns true if every coefficient in \a a is nonzero. */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_all(const Packet& a) {
+  return predux_all_impl<Packet>::run(a);
+}
+
 /***************************************************************************
  * The following functions might not have to be overwritten for vectorized types
  ***************************************************************************/
@@ -1401,7 +1686,7 @@
   return pmadd_impl<Packet>::pnmadd(a, b, c);
 }
 
-/** \internal \returns -((a * b + c) (coeff-wise) */
+/** \internal \returns -(a * b + c) (coeff-wise) */
 template <typename Packet>
 EIGEN_DEVICE_FUNC inline Packet pnmsub(const Packet& a, const Packet& b, const Packet& c) {
   return pmadd_impl<Packet>::pnmsub(a, b, c);
@@ -1420,10 +1705,11 @@
  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
 template <typename Packet, int Alignment>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>::type* from) {
-  if (Alignment >= unpacket_traits<Packet>::alignment)
+  EIGEN_IF_CONSTEXPR (Alignment >= unpacket_traits<Packet>::alignment) {
     return pload<Packet>(from);
-  else
+  } else {
     return ploadu<Packet>(from);
+  }
 }
 
 /** \internal \returns n elements of a packet version of \a *from.
@@ -1431,20 +1717,22 @@
 template <typename Packet, int Alignment>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_partial(const typename unpacket_traits<Packet>::type* from,
                                                             const Index n, const Index offset = 0) {
-  if (Alignment >= unpacket_traits<Packet>::alignment)
+  EIGEN_IF_CONSTEXPR (Alignment >= unpacket_traits<Packet>::alignment) {
     return pload_partial<Packet>(from, n, offset);
-  else
+  } else {
     return ploadu_partial<Packet>(from, n, offset);
+  }
 }
 
 /** \internal copy the packet \a from to \a *to.
  * The pointer \a from must be aligned on a \a Alignment bytes boundary. */
 template <typename Scalar, typename Packet, int Alignment>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from) {
-  if (Alignment >= unpacket_traits<Packet>::alignment)
+  EIGEN_IF_CONSTEXPR (Alignment >= unpacket_traits<Packet>::alignment) {
     pstore(to, from);
-  else
+  } else {
     pstoreu(to, from);
+  }
 }
 
 /** \internal copy n elements of the packet \a from to \a *to.
@@ -1452,10 +1740,11 @@
 template <typename Scalar, typename Packet, int Alignment>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret_partial(Scalar* to, const Packet& from, const Index n,
                                                            const Index offset = 0) {
-  if (Alignment >= unpacket_traits<Packet>::alignment)
+  EIGEN_IF_CONSTEXPR (Alignment >= unpacket_traits<Packet>::alignment) {
     pstore_partial(to, from, n, offset);
-  else
+  } else {
     pstoreu_partial(to, from, n, offset);
+  }
 }
 
 /** \internal \returns a packet version of \a *from.
@@ -1515,17 +1804,18 @@
 }
 
 template <typename Packet, bool IsScalar = is_scalar<Packet>::value,
-          bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>
+          bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger,
+          bool IsUnsigned = IsInteger && !NumTraits<typename unpacket_traits<Packet>::type>::IsSigned>
 struct psignbit_impl;
-template <typename Packet, bool IsInteger>
-struct psignbit_impl<Packet, true, IsInteger> {
+template <typename Packet, bool IsInteger, bool IsUnsigned>
+struct psignbit_impl<Packet, true, IsInteger, IsUnsigned> {
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static constexpr Packet run(const Packet& a) { return numext::signbit(a); }
 };
 template <typename Packet>
-struct psignbit_impl<Packet, false, false> {
+struct psignbit_impl<Packet, false, false, false> {
   // generic implementation if not specialized in PacketMath.h
   // slower than arithmetic shift
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static Packet run(const Packet& a) {
     const Packet cst_pos_one = pset1<Packet>(Scalar(1));
     const Packet cst_neg_one = pset1<Packet>(Scalar(-1));
@@ -1533,10 +1823,14 @@
   }
 };
 template <typename Packet>
-struct psignbit_impl<Packet, false, true> {
-  // generic implementation for integer packets
+struct psignbit_impl<Packet, false, true, false> {
+  // generic implementation for signed integer packets
   EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static constexpr Packet run(const Packet& a) { return pcmp_lt(a, pzero(a)); }
 };
+template <typename Packet>
+struct psignbit_impl<Packet, false, true, true> {
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static constexpr Packet run(const Packet& a) { return pzero(a); }
+};
 /** \internal \returns the sign bit of \a a as a bitmask*/
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr Packet psignbit(const Packet& a) {
@@ -1552,12 +1846,12 @@
 /** \internal \returns the 2-argument arc tangent of \a y and \a x (coeff-wise) */
 template <typename Packet, std::enable_if_t<!is_scalar<Packet>::value, int> = 0>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet patan2(const Packet& y, const Packet& x) {
-  typedef typename internal::unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename internal::unpacket_traits<Packet>::type;
 
   // See https://en.cppreference.com/w/cpp/numeric/math/atan2
   // for how corner cases are supposed to be handled according to the
   // IEEE floating-point standard (IEC 60559).
-  const Packet kSignMask = pset1<Packet>(-Scalar(0));
+  const Packet kSignMask = psignmask<Packet>();
   const Packet kZero = pzero(x);
   const Packet kOne = pset1<Packet>(Scalar(1));
   const Packet kPi = pset1<Packet>(Scalar(EIGEN_PI));
@@ -1649,7 +1943,7 @@
 EIGEN_DEVICE_FUNC inline Packet ploadtSegment(const typename unpacket_traits<Packet>::type* from, Index begin,
                                               Index count) {
   constexpr int RequiredAlignment = unpacket_traits<Packet>::alignment;
-  if (Alignment >= RequiredAlignment) {
+  EIGEN_IF_CONSTEXPR (Alignment >= RequiredAlignment) {
     return ploadSegment<Packet>(from, begin, count);
   } else {
     return ploaduSegment<Packet>(from, begin, count);
@@ -1661,7 +1955,7 @@
 template <typename Scalar, typename Packet, int Alignment>
 EIGEN_DEVICE_FUNC inline void pstoretSegment(Scalar* to, const Packet& from, Index begin, Index count) {
   constexpr int RequiredAlignment = unpacket_traits<Packet>::alignment;
-  if (Alignment >= RequiredAlignment) {
+  EIGEN_IF_CONSTEXPR (Alignment >= RequiredAlignment) {
     pstoreSegment<Scalar, Packet>(to, from, begin, count);
   } else {
     pstoreuSegment<Scalar, Packet>(to, from, begin, count);
diff --git a/Eigen/src/Core/GlobalFunctions.h b/Eigen/src/Core/GlobalFunctions.h
index c32aac9..f464c2b 100644
--- a/Eigen/src/Core/GlobalFunctions.h
+++ b/Eigen/src/Core/GlobalFunctions.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GLOBAL_FUNCTIONS_H
 #define EIGEN_GLOBAL_FUNCTIONS_H
@@ -36,16 +37,10 @@
 #endif  // EIGEN_PARSED_BY_DOXYGEN
 
 #define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME, FUNCTOR)                                                  \
-                                                                                                               \
-  template <typename Derived>                                                                                  \
-  struct NAME##_retval<ArrayBase<Derived> > {                                                                  \
-    typedef const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> type; \
-  };                                                                                                           \
   template <typename Derived>                                                                                  \
   struct NAME##_impl<ArrayBase<Derived> > {                                                                    \
-    static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) {  \
-      return typename NAME##_retval<ArrayBase<Derived> >::type(x.derived());                                   \
-    }                                                                                                          \
+    using ReturnType = Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived>; \
+    static inline const ReturnType run(const Eigen::ArrayBase<Derived>& x) { return ReturnType(x.derived()); } \
   };
 
 // IWYU pragma: private
@@ -61,7 +56,7 @@
 EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tan, scalar_tan_op, tangent,\sa ArrayBase::tan)
 EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(atan, scalar_atan_op, arc - tangent,\sa ArrayBase::atan)
 EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(asin, scalar_asin_op, arc - sine,\sa ArrayBase::asin)
-EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos, scalar_acos_op, arc - consine,\sa ArrayBase::acos)
+EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(acos, scalar_acos_op, arc - cosine,\sa ArrayBase::acos)
 EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(sinh, scalar_sinh_op, hyperbolic sine,\sa ArrayBase::sinh)
 EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(cosh, scalar_cosh_op, hyperbolic cosine,\sa ArrayBase::cosh)
 EIGEN_ARRAY_DECLARE_GLOBAL_UNARY(tanh, scalar_tanh_op, hyperbolic tangent,\sa ArrayBase::tanh)
@@ -179,25 +174,43 @@
 #ifdef EIGEN_PARSED_BY_DOXYGEN
 template <typename Scalar, typename Derived>
 inline const CwiseBinaryOp<internal::scalar_pow_op<Scalar, Derived::Scalar>, Constant<Scalar>, Derived> pow(
-    const Scalar& x, const Eigen::ArrayBase<Derived>& x);
+    const Scalar& x, const Eigen::ArrayBase<Derived>& exponents);
 #else
 template <typename Scalar, typename Derived>
 EIGEN_DEVICE_FUNC inline const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(
     typename internal::promote_scalar_arg<typename Derived::Scalar EIGEN_COMMA Scalar EIGEN_COMMA
-                                              EIGEN_SCALAR_BINARY_SUPPORTED(pow, Scalar,
+                                              EIGEN_SCALAR_BINARY_SUPPORTED(internal::scalar_pow_op, Scalar,
                                                                             typename Derived::Scalar)>::type,
-    Derived, pow) pow(const Scalar& x, const Eigen::ArrayBase<Derived>& exponents) {
-  typedef
+    Derived, internal::scalar_pow_op) pow(const Scalar& x, const Eigen::ArrayBase<Derived>& exponents) {
+  using PromotedScalar =
       typename internal::promote_scalar_arg<typename Derived::Scalar, Scalar,
-                                            EIGEN_SCALAR_BINARY_SUPPORTED(pow, Scalar, typename Derived::Scalar)>::type
-          PromotedScalar;
-  return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedScalar, Derived, pow)(
+                                            EIGEN_SCALAR_BINARY_SUPPORTED(internal::scalar_pow_op, Scalar,
+                                                                          typename Derived::Scalar)>::type;
+  return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedScalar, Derived, internal::scalar_pow_op)(
       typename internal::plain_constant_type<Derived, PromotedScalar>::type(
           exponents.derived().rows(), exponents.derived().cols(), internal::scalar_constant_op<PromotedScalar>(x)),
       exponents.derived());
 }
 #endif
 
+/** \returns an expression of the coefficients of \a x multiplied by \f$ 2^{exponent} \f$.
+ *
+ * The scaling is exact: it directly adjusts the floating-point exponent, so it produces
+ * correct results (including denormals) even when \f$ 2^{exponent} \f$ itself is not
+ * representable as a scalar.
+ *
+ * \sa ArrayBase::ldexp()
+ *
+ * \relates ArrayBase
+ */
+template <typename Derived>
+EIGEN_DEVICE_FUNC constexpr inline const CwiseUnaryOp<internal::scalar_ldexp_op<typename Derived::Scalar>,
+                                                      const Derived>
+ldexp(const Eigen::ArrayBase<Derived>& x, int exponent) {
+  return CwiseUnaryOp<internal::scalar_ldexp_op<typename Derived::Scalar>, const Derived>(
+      x.derived(), internal::scalar_ldexp_op<typename Derived::Scalar>(exponent));
+}
+
 /** \returns an expression of the coefficient-wise atan2(\a x, \a y). \a x and \a y must be of the same type.
  *
  * This function computes the coefficient-wise atan2().
diff --git a/Eigen/src/Core/IO.h b/Eigen/src/Core/IO.h
index e2362fc..3f1223a 100644
--- a/Eigen/src/Core/IO.h
+++ b/Eigen/src/Core/IO.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_IO_H
 #define EIGEN_IO_H
@@ -125,24 +126,23 @@
  * print the matrix \a _m to the output stream \a s using the output format \a fmt */
 template <typename Derived>
 std::ostream& print_matrix(std::ostream& s, const Derived& _m, const IOFormat& fmt) {
-  using internal::is_same;
-
   if (_m.size() == 0) {
     s << fmt.matPrefix << fmt.matSuffix;
     return s;
   }
 
   typename Derived::Nested m = _m;
-  typedef typename Derived::Scalar Scalar;
-  typedef std::conditional_t<is_same<Scalar, char>::value || is_same<Scalar, unsigned char>::value ||
-                                 is_same<Scalar, numext::int8_t>::value || is_same<Scalar, numext::uint8_t>::value,
-                             int,
-                             std::conditional_t<is_same<Scalar, std::complex<char> >::value ||
-                                                    is_same<Scalar, std::complex<unsigned char> >::value ||
-                                                    is_same<Scalar, std::complex<numext::int8_t> >::value ||
-                                                    is_same<Scalar, std::complex<numext::uint8_t> >::value,
-                                                std::complex<int>, const Scalar&> >
-      PrintType;
+  using Scalar = typename Derived::Scalar;
+  using PrintType =
+      std::conditional_t<std::is_same<Scalar, char>::value || std::is_same<Scalar, unsigned char>::value ||
+                             std::is_same<Scalar, numext::int8_t>::value ||
+                             std::is_same<Scalar, numext::uint8_t>::value,
+                         int,
+                         std::conditional_t<std::is_same<Scalar, std::complex<char> >::value ||
+                                                std::is_same<Scalar, std::complex<unsigned char> >::value ||
+                                                std::is_same<Scalar, std::complex<numext::int8_t> >::value ||
+                                                std::is_same<Scalar, std::complex<numext::uint8_t> >::value,
+                                            std::complex<int>, const Scalar&> >;
 
   Index width = 0;
 
@@ -150,7 +150,7 @@
   if (fmt.precision == StreamPrecision) {
     explicit_precision = 0;
   } else if (fmt.precision == FullPrecision) {
-    if (NumTraits<Scalar>::IsInteger) {
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsInteger) {
       explicit_precision = 0;
     } else {
       explicit_precision = significant_decimals_impl<Scalar>::run();
diff --git a/Eigen/src/Core/IndexedView.h b/Eigen/src/Core/IndexedView.h
index 44d5c02..0c71556 100644
--- a/Eigen/src/Core/IndexedView.h
+++ b/Eigen/src/Core/IndexedView.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INDEXED_VIEW_H
 #define EIGEN_INDEXED_VIEW_H
@@ -36,15 +37,16 @@
     OuterIncr = IsRowMajor ? RowIncr : ColIncr,
 
     HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor),
-    XprInnerStride = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType>::ret)
-                                                  : int(outer_stride_at_compile_time<XprType>::ret),
-    XprOuterstride = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType>::ret)
-                                                  : int(inner_stride_at_compile_time<XprType>::ret),
+    XprInnerStride = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType>::value)
+                                                  : int(outer_stride_at_compile_time<XprType>::value),
+    XprOuterstride = HasSameStorageOrderAsXprType ? int(outer_stride_at_compile_time<XprType>::value)
+                                                  : int(inner_stride_at_compile_time<XprType>::value),
 
     InnerSize = XprTypeIsRowMajor ? ColsAtCompileTime : RowsAtCompileTime,
     IsBlockAlike = InnerIncr == 1 && OuterIncr == 1,
-    IsInnerPannel = HasSameStorageOrderAsXprType &&
-                    is_same<AllRange<InnerSize>, std::conditional_t<XprTypeIsRowMajor, ColIndices, RowIndices>>::value,
+    IsInnerPannel =
+        HasSameStorageOrderAsXprType &&
+        std::is_same<AllRange<InnerSize>, std::conditional_t<XprTypeIsRowMajor, ColIndices, RowIndices>>::value,
 
     InnerStrideAtCompileTime =
         InnerIncr < 0 || InnerIncr == DynamicIndex || XprInnerStride == Dynamic || InnerIncr == Undefined
@@ -67,11 +69,13 @@
     FlagsRowMajorBit = IsRowMajor ? RowMajorBit : 0,
     FlagsLvalueBit = is_lvalue<XprType>::value ? LvalueBit : 0,
     FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
-    Flags = (traits<XprType>::Flags & (HereditaryBits | DirectAccessMask)) | FlagsLvalueBit | FlagsRowMajorBit |
-            FlagsLinearAccessBit
+    // IsRowMajor above pins a single-column view to column-major and a single-row view to
+    // row-major, so the nested expression's RowMajorBit must not be inherited on top of it.
+    Flags = (traits<XprType>::Flags & ((HereditaryBits & ~RowMajorBit) | DirectAccessMask)) | FlagsLvalueBit |
+            FlagsRowMajorBit | FlagsLinearAccessBit
   };
 
-  typedef Block<XprType, RowsAtCompileTime, ColsAtCompileTime, IsInnerPannel> BlockType;
+  using BlockType = Block<XprType, RowsAtCompileTime, ColsAtCompileTime, IsInnerPannel>;
 };
 
 template <typename XprType, typename RowIndices, typename ColIndices, typename StorageKind, bool DirectAccess>
@@ -89,7 +93,7 @@
  * \tparam ColIndices the type of the object defining the sequence of column indices
  *
  * This class represents an expression of a sub-matrix (or sub-vector) defined as the intersection
- * of sub-sets of rows and columns, that are themself defined by generic sequences of row indices \f$
+ * of sub-sets of rows and columns, that are themselves defined by generic sequences of row indices \f$
  * \{r_0,r_1,..r_{m-1}\} \f$ and column indices \f$ \{c_0,c_1,..c_{n-1} \}\f$. Let \f$ A \f$  be the nested matrix, then
  * the resulting matrix \f$ B \f$ has \c m rows and \c n columns, and its entries are given by: \f$ B(i,j) = A(r_i,c_j)
  * \f$.
@@ -123,10 +127,9 @@
                                        (internal::traits<IndexedView<XprType, RowIndices, ColIndices>>::Flags &
                                         DirectAccessBit) != 0> {
  public:
-  typedef typename internal::IndexedViewImpl<
+  using Base = typename internal::IndexedViewImpl<
       XprType, RowIndices, ColIndices, typename internal::traits<XprType>::StorageKind,
-      (internal::traits<IndexedView<XprType, RowIndices, ColIndices>>::Flags & DirectAccessBit) != 0>
-      Base;
+      (internal::traits<IndexedView<XprType, RowIndices, ColIndices>>::Flags & DirectAccessBit) != 0>;
   EIGEN_GENERIC_PUBLIC_INTERFACE(IndexedView)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(IndexedView)
 
@@ -140,10 +143,10 @@
 template <typename XprType, typename RowIndices, typename ColIndices, typename StorageKind, bool DirectAccess>
 class IndexedViewImpl : public internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices>>::type {
  public:
-  typedef typename internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices>>::type Base;
-  typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
-  typedef internal::remove_all_t<XprType> NestedExpression;
-  typedef typename XprType::Scalar Scalar;
+  using Base = typename internal::generic_xpr_base<IndexedView<XprType, RowIndices, ColIndices>>::type;
+  using MatrixTypeNested = typename internal::ref_selector<XprType>::non_const_type;
+  using NestedExpression = internal::remove_all_t<XprType>;
+  using Scalar = typename XprType::Scalar;
 
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(IndexedViewImpl)
 
@@ -197,13 +200,13 @@
   IndexedViewImpl(XprType& xpr, const T0& rowIndices, const T1& colIndices) : Base(xpr, rowIndices, colIndices) {}
 
   Index rowIncrement() const {
-    if (traits<Derived>::RowIncr != DynamicIndex && traits<Derived>::RowIncr != Undefined) {
+    EIGEN_IF_CONSTEXPR (traits<Derived>::RowIncr != DynamicIndex && traits<Derived>::RowIncr != Undefined) {
       return traits<Derived>::RowIncr;
     }
     return IndexedViewHelper<RowIndices>::incr(this->rowIndices());
   }
   Index colIncrement() const {
-    if (traits<Derived>::ColIncr != DynamicIndex && traits<Derived>::ColIncr != Undefined) {
+    EIGEN_IF_CONSTEXPR (traits<Derived>::ColIncr != DynamicIndex && traits<Derived>::ColIncr != Undefined) {
       return traits<Derived>::ColIncr;
     }
     return IndexedViewHelper<ColIndices>::incr(this->colIndices());
@@ -226,14 +229,14 @@
   }
 
   EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept {
-    if (traits<Derived>::InnerStrideAtCompileTime != Dynamic) {
+    EIGEN_IF_CONSTEXPR (traits<Derived>::InnerStrideAtCompileTime != Dynamic) {
       return traits<Derived>::InnerStrideAtCompileTime;
     }
     return innerIncrement() * this->nestedExpression().innerStride();
   }
 
   EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept {
-    if (traits<Derived>::OuterStrideAtCompileTime != Dynamic) {
+    EIGEN_IF_CONSTEXPR (traits<Derived>::OuterStrideAtCompileTime != Dynamic) {
       return traits<Derived>::OuterStrideAtCompileTime;
     }
     return outerIncrement() * this->nestedExpression().outerStride();
@@ -243,7 +246,7 @@
 template <typename ArgType, typename RowIndices, typename ColIndices>
 struct unary_evaluator<IndexedView<ArgType, RowIndices, ColIndices>, IndexBased>
     : evaluator_base<IndexedView<ArgType, RowIndices, ColIndices>> {
-  typedef IndexedView<ArgType, RowIndices, ColIndices> XprType;
+  using XprType = IndexedView<ArgType, RowIndices, ColIndices>;
 
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of row/col index */,
@@ -264,8 +267,8 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
     eigen_assert(m_xpr.rowIndices()[row] >= 0 && m_xpr.rowIndices()[row] < m_xpr.nestedExpression().rows() &&
@@ -311,9 +314,7 @@
 
 // Catch assignments to an IndexedView.
 template <typename ArgType, typename RowIndices, typename ColIndices>
-struct evaluator_assume_aliasing<IndexedView<ArgType, RowIndices, ColIndices>> {
-  static const bool value = true;
-};
+struct evaluator_assume_aliasing<IndexedView<ArgType, RowIndices, ColIndices>> : std::true_type {};
 
 }  // end namespace internal
 
diff --git a/Eigen/src/Core/InnerProduct.h b/Eigen/src/Core/InnerProduct.h
index ad9844d..6ce1edb 100644
--- a/Eigen/src/Core/InnerProduct.h
+++ b/Eigen/src/Core/InnerProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INNER_PRODUCT_EVAL_H
 #define EIGEN_INNER_PRODUCT_EVAL_H
@@ -17,30 +18,7 @@
 
 namespace internal {
 
-// recursively searches for the largest simd type that does not exceed Size, or the smallest if no such type exists
-template <typename Scalar, int Size, typename Packet = typename packet_traits<Scalar>::type,
-          bool Stop =
-              (unpacket_traits<Packet>::size <= Size) || is_same<Packet, typename unpacket_traits<Packet>::half>::value>
-struct find_inner_product_packet_helper;
-
-template <typename Scalar, int Size, typename Packet>
-struct find_inner_product_packet_helper<Scalar, Size, Packet, false> {
-  using type = typename find_inner_product_packet_helper<Scalar, Size, typename unpacket_traits<Packet>::half>::type;
-};
-
-template <typename Scalar, int Size, typename Packet>
-struct find_inner_product_packet_helper<Scalar, Size, Packet, true> {
-  using type = Packet;
-};
-
-template <typename Scalar, int Size>
-struct find_inner_product_packet : find_inner_product_packet_helper<Scalar, Size> {};
-
-template <typename Scalar>
-struct find_inner_product_packet<Scalar, Dynamic> {
-  using type = typename packet_traits<Scalar>::type;
-};
-
+// Shared accumulation kernel for dot() (Conj = true) and vector products (Conj = false).
 template <typename Lhs, typename Rhs>
 struct inner_product_assert {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Lhs)
@@ -66,7 +44,7 @@
   static constexpr int RhsAlignment = evaluator<Rhs>::Alignment;
 
   using Scalar = typename Func::result_type;
-  using Packet = typename find_inner_product_packet<Scalar, SizeAtCompileTime>::type;
+  using Packet = typename find_largest_packet<Scalar, SizeAtCompileTime>::type;
 
   static constexpr bool Vectorize =
       bool(LhsFlags & RhsFlags & PacketAccessBit) && Func::PacketAccess &&
@@ -133,6 +111,7 @@
   using Scalar = typename Evaluator::Scalar;
   using Packet = typename Evaluator::Packet;
   static constexpr int PacketSize = unpacket_traits<Packet>::size;
+  static constexpr int MaxSize = Evaluator::MaxSizeAtCompileTime;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval) {
     const UnsignedIndex size = static_cast<UnsignedIndex>(eval.size());
     if (size < PacketSize) return inner_product_impl<Evaluator, false>::run(eval);
@@ -142,31 +121,49 @@
     const UnsignedIndex numPackets = size / PacketSize;
     const UnsignedIndex numRemPackets = (packetEnd - quadEnd) / PacketSize;
 
-    Packet presult0, presult1, presult2, presult3;
+    Packet presult0 = eval.template packet<Packet>(0 * PacketSize);
+    // Exclude unreachable packet loads for bounded vectors (also avoids GCC bounds warnings).
+    EIGEN_IF_CONSTEXPR (MaxSize == Dynamic || MaxSize / PacketSize >= 2) {
+      if (numPackets >= 2) {
+        Packet presult1 = eval.template packet<Packet>(1 * PacketSize);
+        EIGEN_IF_CONSTEXPR (MaxSize == Dynamic || MaxSize / PacketSize >= 3) {
+          if (numPackets >= 3) {
+            Packet presult2 = eval.template packet<Packet>(2 * PacketSize);
+            EIGEN_IF_CONSTEXPR (MaxSize == Dynamic || MaxSize / PacketSize >= 4) {
+              if (numPackets >= 4) {
+                Packet presult3 = eval.template packet<Packet>(3 * PacketSize);
 
-    presult0 = eval.template packet<Packet>(0 * PacketSize);
-    if (numPackets >= 2) presult1 = eval.template packet<Packet>(1 * PacketSize);
-    if (numPackets >= 3) presult2 = eval.template packet<Packet>(2 * PacketSize);
-    if (numPackets >= 4) {
-      presult3 = eval.template packet<Packet>(3 * PacketSize);
+                for (UnsignedIndex k = 4 * PacketSize; k < quadEnd; k += 4 * PacketSize) {
+                  presult0 = eval.packet(presult0, k + 0 * PacketSize);
+                  presult1 = eval.packet(presult1, k + 1 * PacketSize);
+                  presult2 = eval.packet(presult2, k + 2 * PacketSize);
+                  presult3 = eval.packet(presult3, k + 3 * PacketSize);
+                }
 
-      for (UnsignedIndex k = 4 * PacketSize; k < quadEnd; k += 4 * PacketSize) {
-        presult0 = eval.packet(presult0, k + 0 * PacketSize);
-        presult1 = eval.packet(presult1, k + 1 * PacketSize);
-        presult2 = eval.packet(presult2, k + 2 * PacketSize);
-        presult3 = eval.packet(presult3, k + 3 * PacketSize);
+                EIGEN_IF_CONSTEXPR (MaxSize == Dynamic || MaxSize / PacketSize >= 5) {
+                  if (numRemPackets >= 1) {
+                    presult0 = eval.packet(presult0, quadEnd + 0 * PacketSize);
+                    EIGEN_IF_CONSTEXPR (MaxSize == Dynamic || MaxSize / PacketSize >= 6) {
+                      if (numRemPackets >= 2) {
+                        presult1 = eval.packet(presult1, quadEnd + 1 * PacketSize);
+                        EIGEN_IF_CONSTEXPR (MaxSize == Dynamic || MaxSize / PacketSize >= 7) {
+                          if (numRemPackets == 3) presult2 = eval.packet(presult2, quadEnd + 2 * PacketSize);
+                        }
+                      }
+                    }
+                  }
+                }
+
+                presult2 = padd(presult2, presult3);
+              }
+            }
+            presult1 = padd(presult1, presult2);
+          }
+        }
+        presult0 = padd(presult0, presult1);
       }
-
-      if (numRemPackets >= 1) presult0 = eval.packet(presult0, quadEnd + 0 * PacketSize);
-      if (numRemPackets >= 2) presult1 = eval.packet(presult1, quadEnd + 1 * PacketSize);
-      if (numRemPackets == 3) presult2 = eval.packet(presult2, quadEnd + 2 * PacketSize);
-
-      presult2 = padd(presult2, presult3);
     }
 
-    if (numPackets >= 3) presult1 = padd(presult1, presult2);
-    if (numPackets >= 2) presult0 = padd(presult0, presult1);
-
     Scalar result = predux(presult0);
     for (UnsignedIndex k = packetEnd; k < size; k++) {
       result = eval.coeff(result, k);
@@ -176,37 +173,15 @@
   }
 };
 
-template <typename Scalar, bool Conj>
-struct conditional_conj;
-
-template <typename Scalar>
-struct conditional_conj<Scalar, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(const Scalar& a) { return numext::conj(a); }
-  template <typename Packet>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(const Packet& a) {
-    return pconj(a);
-  }
-};
-
-template <typename Scalar>
-struct conditional_conj<Scalar, false> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(const Scalar& a) { return a; }
-  template <typename Packet>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(const Packet& a) {
-    return a;
-  }
-};
-
 template <typename LhsScalar, typename RhsScalar, bool Conj>
 struct scalar_inner_product_op {
   using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
-  using conj_helper = conditional_conj<LhsScalar, Conj>;
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type coeff(const LhsScalar& a, const RhsScalar& b) const {
-    return (conj_helper::coeff(a) * b);
+    return (conj_if<Conj>()(a) * b);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type coeff(const result_type& accum, const LhsScalar& a,
                                                           const RhsScalar& b) const {
-    return (conj_helper::coeff(a) * b) + accum;
+    return (conj_if<Conj>()(a) * b) + accum;
   }
   static constexpr bool PacketAccess = false;
 };
@@ -216,24 +191,22 @@
 template <typename Scalar, bool Conj>
 struct scalar_inner_product_op<
     Scalar,
-    std::enable_if_t<internal::is_same<typename ScalarBinaryOpTraits<Scalar, Scalar>::ReturnType, Scalar>::value,
-                     Scalar>,
+    std::enable_if_t<std::is_same<typename ScalarBinaryOpTraits<Scalar, Scalar>::ReturnType, Scalar>::value, Scalar>,
     Conj> {
   using result_type = Scalar;
-  using conj_helper = conditional_conj<Scalar, Conj>;
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(const Scalar& a, const Scalar& b) const {
-    return pmul(conj_helper::coeff(a), b);
+    return pmul(conj_if<Conj>()(a), b);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(const Scalar& accum, const Scalar& a, const Scalar& b) const {
-    return pmadd(conj_helper::coeff(a), b, accum);
+    return pmadd(conj_if<Conj>()(a), b, accum);
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(const Packet& a, const Packet& b) const {
-    return pmul(conj_helper::packet(a), b);
+    return pmul(conj_if<Conj>().pconj(a), b);
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packet(const Packet& accum, const Packet& a, const Packet& b) const {
-    return pmadd(conj_helper::packet(a), b, accum);
+    return pmadd(conj_if<Conj>().pconj(a), b, accum);
   }
   static constexpr bool PacketAccess = packet_traits<Scalar>::HasMul && packet_traits<Scalar>::HasAdd;
 };
@@ -251,8 +224,113 @@
   }
 };
 
-template <typename Lhs, typename Rhs>
-struct dot_impl : default_inner_product_impl<Lhs, Rhs, true> {};
+template <typename T>
+struct unwrap_unary {
+  using type = T;
+  static constexpr bool HasDirectAccess = bool(traits<type>::Flags & DirectAccessBit);
+
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr T const& get(T const& xpr) { return xpr; }
+};
+
+template <typename T>
+struct unwrap_unary<T const> : unwrap_unary<T> {};
+
+template <typename Op, typename Xpr>
+struct unwrap_unary<CwiseUnaryOp<Op, Xpr>> : unwrap_unary<Xpr> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr typename unwrap_unary<Xpr>::type const& get(
+      CwiseUnaryOp<Op, Xpr> const& xpr) {
+    return unwrap_unary<Xpr>::get(xpr.nestedExpression());
+  }
+};
+
+template <typename T, typename Target>
+struct rewrap_unary {
+  using type = Target;
+
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr Target const& apply(T const&, Target const& target) {
+    return target;
+  }
+};
+
+template <typename T, typename Target>
+struct rewrap_unary<T const, Target> : rewrap_unary<T, Target const> {};
+
+template <typename Op, typename Xpr, typename Target>
+struct rewrap_unary<CwiseUnaryOp<Op, Xpr>, Target> {
+  // unaryExpr() nests its operand as const; Xpr itself need not be (adjoint() nests a non-const Transpose).
+  using type = CwiseUnaryOp<Op, std::add_const_t<typename rewrap_unary<Xpr, Target>::type>>;
+
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr type apply(CwiseUnaryOp<Op, Xpr> const& base,
+                                                                    Target const& target) {
+    return rewrap_unary<Xpr, Target>::apply(base.nestedExpression(), target).unaryExpr(base.functor());
+  }
+};
+
+// Rewrap coefficient-wise unary operations around contiguous maps only when both
+// operands expose storage and at least one lacks a compile-time unit inner stride.
+template <typename Lhs, typename Rhs, bool Conj,
+          bool MayMap = unwrap_unary<Lhs>::HasDirectAccess && unwrap_unary<Rhs>::HasDirectAccess &&
+                        (inner_stride_at_compile_time<typename unwrap_unary<Lhs>::type>::value != 1 ||
+                         inner_stride_at_compile_time<typename unwrap_unary<Rhs>::type>::value != 1)>
+struct inner_product_dispatch : default_inner_product_impl<Lhs, Rhs, Conj> {};
+
+template <typename Lhs, typename Rhs, bool Conj>
+struct inner_product_dispatch<Lhs, Rhs, Conj, true> {
+  using Impl = default_inner_product_impl<Lhs, Rhs, Conj>;
+  using result_type = typename Impl::result_type;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type run(const MatrixBase<Lhs>& a, const MatrixBase<Rhs>& b) {
+    EIGEN_IF_CONSTEXPR (Conj) {
+      return run_general(a, b);
+    }
+    // Keep tiny products inlined without the remapping and packet-loop setup.
+    if (a.size() <= 4) {
+      typename Impl::Evaluator eval(a.derived(), b.derived());
+      if (eval.size() == 0) return result_type(0);
+      result_type result = eval.coeff(0);
+      if (eval.size() > 1) result = eval.coeff(result, 1);
+      if (eval.size() > 2) result = eval.coeff(result, 2);
+      if (eval.size() > 3) result = eval.coeff(result, 3);
+      return result;
+    }
+    return run_large_product(a, b);
+  }
+
+  // Keep the larger product kernel out of tiny callers, while dot() retains its existing inlining.
+  static EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE result_type run_large_product(const MatrixBase<Lhs>& a,
+                                                                           const MatrixBase<Rhs>& b) {
+    return run_general(a, b);
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type run_general(const MatrixBase<Lhs>& a,
+                                                                       const MatrixBase<Rhs>& b) {
+    using LhsUnwrapper = unwrap_unary<Lhs>;
+    using RhsUnwrapper = unwrap_unary<Rhs>;
+    using LhsInner = typename LhsUnwrapper::type;
+    using RhsInner = typename RhsUnwrapper::type;
+
+    LhsInner const& lhs_inner = LhsUnwrapper::get(a.derived());
+    RhsInner const& rhs_inner = RhsUnwrapper::get(b.derived());
+
+    if (lhs_inner.innerStride() == 1 && rhs_inner.innerStride() == 1) {
+      using LhsMap = Map<Vector<typename LhsInner::Scalar, size_of_xpr_at_compile_time<LhsInner>::value> const,
+                         evaluator<LhsInner>::Alignment>;
+      using RhsMap = Map<Vector<typename RhsInner::Scalar, size_of_xpr_at_compile_time<RhsInner>::value> const,
+                         evaluator<RhsInner>::Alignment>;
+
+      LhsMap const lhs_map(lhs_inner.data(), lhs_inner.size());
+      RhsMap const rhs_map(rhs_inner.data(), rhs_inner.size());
+
+      using LhsRewrap = rewrap_unary<Lhs, LhsMap>;
+      using RhsRewrap = rewrap_unary<Rhs, RhsMap>;
+
+      return default_inner_product_impl<typename LhsRewrap::type, typename RhsRewrap::type, Conj>::run(
+          LhsRewrap::apply(a.derived(), lhs_map), RhsRewrap::apply(b.derived(), rhs_map));
+    }
+
+    return Impl::run(a, b);
+  }
+};
 
 }  // namespace internal
 }  // namespace Eigen
diff --git a/Eigen/src/Core/InternalHeaderCheck.h b/Eigen/src/Core/InternalHeaderCheck.h
index 1cea572..875d2ec 100644
--- a/Eigen/src/Core/InternalHeaderCheck.h
+++ b/Eigen/src/Core/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_CORE_MODULE_H
 #error "Please include Eigen/Core instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Core/Inverse.h b/Eigen/src/Core/Inverse.h
index 855e3b3..91accd6 100644
--- a/Eigen/src/Core/Inverse.h
+++ b/Eigen/src/Core/Inverse.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INVERSE_H
 #define EIGEN_INVERSE_H
@@ -22,8 +23,8 @@
 
 template <typename XprType>
 struct traits<Inverse<XprType> > : traits<typename XprType::PlainObject> {
-  typedef typename XprType::PlainObject PlainObject;
-  typedef traits<PlainObject> BaseTraits;
+  using PlainObject = typename XprType::PlainObject;
+  using BaseTraits = traits<PlainObject>;
   enum { Flags = BaseTraits::Flags & RowMajorBit };
 };
 
@@ -42,12 +43,12 @@
 template <typename XprType>
 class Inverse : public InverseImpl<XprType, typename internal::traits<XprType>::StorageKind> {
  public:
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename internal::ref_selector<XprType>::type XprTypeNested;
-  typedef internal::remove_all_t<XprTypeNested> XprTypeNestedCleaned;
-  typedef typename internal::ref_selector<Inverse>::type Nested;
-  typedef internal::remove_all_t<XprType> NestedExpression;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename XprType::Scalar;
+  using XprTypeNested = typename internal::ref_selector<XprType>::type;
+  using XprTypeNestedCleaned = internal::remove_all_t<XprTypeNested>;
+  using Nested = typename internal::ref_selector<Inverse>::type;
+  using NestedExpression = internal::remove_all_t<XprType>;
 
   explicit EIGEN_DEVICE_FUNC constexpr Inverse(const XprType& xpr) : m_xpr(xpr) {}
 
@@ -64,8 +65,8 @@
 template <typename XprType, typename StorageKind>
 class InverseImpl : public internal::generic_xpr_base<Inverse<XprType> >::type {
  public:
-  typedef typename internal::generic_xpr_base<Inverse<XprType> >::type Base;
-  typedef typename XprType::Scalar Scalar;
+  using Base = typename internal::generic_xpr_base<Inverse<XprType>>::type;
+  using Scalar = typename XprType::Scalar;
 
  private:
   Scalar coeff(Index row, Index col) const;
@@ -77,18 +78,18 @@
 /** \internal
  * \brief Default evaluator for Inverse expression.
  *
- * This default evaluator for Inverse expression simply evaluate the inverse into a temporary
+ * This default evaluator for Inverse expression simply evaluates the inverse into a temporary
  * by a call to internal::call_assignment_no_alias.
  * Therefore, inverse implementers only have to specialize Assignment<Dst,Inverse<...>, ...> for
- * there own nested expression.
+ * their own nested expression.
  *
  * \sa class Inverse
  */
 template <typename ArgType>
 struct unary_evaluator<Inverse<ArgType> > : public evaluator<typename Inverse<ArgType>::PlainObject> {
-  typedef Inverse<ArgType> InverseType;
-  typedef typename InverseType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using InverseType = Inverse<ArgType>;
+  using PlainObject = typename InverseType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
 
diff --git a/Eigen/src/Core/Map.h b/Eigen/src/Core/Map.h
index 33b62c2..8b633b1 100644
--- a/Eigen/src/Core/Map.h
+++ b/Eigen/src/Core/Map.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MAP_H
 #define EIGEN_MAP_H
@@ -19,7 +20,7 @@
 namespace internal {
 template <typename PlainObjectType, int MapOptions, typename StrideType>
 struct traits<Map<PlainObjectType, MapOptions, StrideType> > : public traits<PlainObjectType> {
-  typedef traits<PlainObjectType> TraitsBase;
+  using TraitsBase = traits<PlainObjectType>;
   enum {
     PlainObjectTypeInnerSize = ((traits<PlainObjectType>::Flags & RowMajorBit) == RowMajorBit)
                                    ? PlainObjectType::ColsAtCompileTime
@@ -95,11 +96,11 @@
 template <typename PlainObjectType, int MapOptions, typename StrideType>
 class Map : public MapBase<Map<PlainObjectType, MapOptions, StrideType> > {
  public:
-  typedef MapBase<Map> Base;
+  using Base = MapBase<Map>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Map)
 
-  typedef typename Base::PointerType PointerType;
-  typedef PointerType PointerArgType;
+  using PointerType = typename Base::PointerType;
+  using PointerArgType = PointerType;
   EIGEN_DEVICE_FUNC constexpr inline PointerType cast_to_pointer_type(PointerArgType ptr) const { return ptr; }
 
   EIGEN_DEVICE_FUNC constexpr Index innerStride() const {
diff --git a/Eigen/src/Core/MapBase.h b/Eigen/src/Core/MapBase.h
index 3e11725..38f8aa1 100644
--- a/Eigen/src/Core/MapBase.h
+++ b/Eigen/src/Core/MapBase.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MAPBASE_H
 #define EIGEN_MAPBASE_H
@@ -28,7 +29,7 @@
  * Map and Block objects with direct access.
  * Typical users do not have to directly deal with this class.
  *
- * This class can be extended by through the macro plugin \c EIGEN_MAPBASE_PLUGIN.
+ * This class can be extended through the macro plugin \c EIGEN_MAPBASE_PLUGIN.
  * See \link TopicCustomizing_Plugins customizing Eigen \endlink for details.
  *
  * The \c Derived class has to provide the following two methods describing the memory layout:
@@ -40,7 +41,7 @@
 template <typename Derived>
 class MapBase<Derived, ReadOnlyAccessors> : public internal::dense_xpr_base<Derived>::type {
  public:
-  typedef typename internal::dense_xpr_base<Derived>::type Base;
+  using Base = typename internal::dense_xpr_base<Derived>::type;
   enum {
     RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
     ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
@@ -48,11 +49,11 @@
     SizeAtCompileTime = Base::SizeAtCompileTime
   };
 
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef std::conditional_t<bool(internal::is_lvalue<Derived>::value), Scalar*, const Scalar*> PointerType;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PointerType = std::conditional_t<bool(internal::is_lvalue<Derived>::value), Scalar*, const Scalar*>;
 
   using Base::derived;
   //    using Base::RowsAtCompileTime;
@@ -81,7 +82,7 @@
   // bug 217 - compile error on ICC 11.1
   using Base::operator=;
 
-  typedef typename Base::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename Base::CoeffReturnType;
 
   /** \copydoc DenseBase::rows() */
   EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return m_rows.value(); }
@@ -165,8 +166,8 @@
   EIGEN_DEFAULT_COPY_CONSTRUCTOR(MapBase)
   EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(MapBase)
 
-  template <typename T>
-  EIGEN_DEVICE_FUNC void checkSanity(std::enable_if_t<(internal::traits<T>::Alignment > 0), void*> = 0) const {
+  template <typename T, std::enable_if_t<(internal::traits<T>::Alignment > 0), int> = 0>
+  EIGEN_DEVICE_FUNC void checkSanity() const {
 // Temporary macro to allow scalars to not be properly aligned.  This is while we sort out failures
 // in TensorFlow Lite that are currently relying on this UB.
 #ifndef EIGEN_ALLOW_UNALIGNED_SCALARS
@@ -176,7 +177,7 @@
 #if EIGEN_MAX_ALIGN_BYTES > 0
     // innerStride() is not set yet when this function is called, so we optimistically assume the lowest plausible
     // value:
-    const Index minInnerStride = InnerStrideAtCompileTime == Dynamic ? 1 : Index(InnerStrideAtCompileTime);
+    constexpr Index minInnerStride = InnerStrideAtCompileTime == Dynamic ? 1 : Index(InnerStrideAtCompileTime);
     EIGEN_ONLY_USED_FOR_DEBUG(minInnerStride);
     eigen_assert((((std::uintptr_t(m_data) % internal::traits<Derived>::Alignment) == 0) ||
                   (cols() * rows() * minInnerStride * sizeof(Scalar)) < internal::traits<Derived>::Alignment) &&
@@ -184,8 +185,8 @@
 #endif
   }
 
-  template <typename T>
-  EIGEN_DEVICE_FUNC void checkSanity(std::enable_if_t<internal::traits<T>::Alignment == 0, void*> = 0) const {
+  template <typename T, std::enable_if_t<internal::traits<T>::Alignment == 0, int> = 0>
+  EIGEN_DEVICE_FUNC void checkSanity() const {
 #ifndef EIGEN_ALLOW_UNALIGNED_SCALARS
     // Pointer must be aligned to the Scalar type, otherwise we get UB.
     eigen_assert((std::uintptr_t(m_data) % alignof(Scalar) == 0) && "data is not scalar-aligned");
@@ -209,15 +210,15 @@
  */
 template <typename Derived>
 class MapBase<Derived, WriteAccessors> : public MapBase<Derived, ReadOnlyAccessors> {
-  typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
+  using ReadOnlyMapBase = MapBase<Derived, ReadOnlyAccessors>;
 
  public:
-  typedef MapBase<Derived, ReadOnlyAccessors> Base;
+  using Base = MapBase<Derived, ReadOnlyAccessors>;
 
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::PacketScalar PacketScalar;
-  typedef typename Base::StorageIndex StorageIndex;
-  typedef typename Base::PointerType PointerType;
+  using Scalar = typename Base::Scalar;
+  using PacketScalar = typename Base::PacketScalar;
+  using StorageIndex = typename Base::StorageIndex;
+  using PointerType = typename Base::PointerType;
 
   using Base::coeff;
   using Base::coeffRef;
@@ -231,7 +232,7 @@
   using Base::outerStride;
   using Base::rowStride;
 
-  typedef std::conditional_t<internal::is_lvalue<Derived>::value, Scalar, const Scalar> ScalarWithConstIfNotLvalue;
+  using ScalarWithConstIfNotLvalue = std::conditional_t<internal::is_lvalue<Derived>::value, Scalar, const Scalar>;
 
   EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return this->m_data; }
   EIGEN_DEVICE_FUNC constexpr ScalarWithConstIfNotLvalue* data() {
diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h
index 54da17c..879dff2 100644
--- a/Eigen/src/Core/MathFunctions.h
+++ b/Eigen/src/Core/MathFunctions.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATHFUNCTIONS_H
 #define EIGEN_MATHFUNCTIONS_H
@@ -47,25 +48,17 @@
 
 template <typename T, typename dummy = void>
 struct global_math_functions_filtering_base {
-  typedef T type;
+  using type = T;
 };
 
 template <typename T>
-struct always_void {
-  typedef void type;
-};
-
-template <typename T>
-struct global_math_functions_filtering_base<
-    T, typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type> {
-  typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
+struct global_math_functions_filtering_base<T,
+                                            void_t<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>> {
+  using type = typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl;
 };
 
 #define EIGEN_MATHFUNC_IMPL(func, scalar) \
   Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>
-#define EIGEN_MATHFUNC_RETVAL(func, scalar) \
-  typename Eigen::internal::func##_retval<  \
-      typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type
 
 /****************************************************************************
  * Implementation of real                                                 *
@@ -73,13 +66,13 @@
 
 template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
 struct real_default_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static constexpr RealScalar run(const Scalar& x) { return x; }
 };
 
 template <typename Scalar>
 struct real_default_impl<Scalar, true> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     using std::real;
     return real(x);
@@ -92,29 +85,24 @@
 #if defined(EIGEN_GPU_COMPILE_PHASE)
 template <typename T>
 struct real_impl<std::complex<T>> {
-  typedef T RealScalar;
+  using RealScalar = T;
   EIGEN_DEVICE_FUNC static inline T run(const std::complex<T>& x) { return x.real(); }
 };
 #endif
 
-template <typename Scalar>
-struct real_retval {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 /****************************************************************************
  * Implementation of imag                                                 *
  ****************************************************************************/
 
 template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
 struct imag_default_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar&) { return RealScalar(0); }
 };
 
 template <typename Scalar>
 struct imag_default_impl<Scalar, true> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     using std::imag;
     return imag(x);
@@ -127,41 +115,31 @@
 #if defined(EIGEN_GPU_COMPILE_PHASE)
 template <typename T>
 struct imag_impl<std::complex<T>> {
-  typedef T RealScalar;
+  using RealScalar = T;
   EIGEN_DEVICE_FUNC static inline T run(const std::complex<T>& x) { return x.imag(); }
 };
 #endif
 
-template <typename Scalar>
-struct imag_retval {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 /****************************************************************************
  * Implementation of real_ref                                             *
  ****************************************************************************/
 
 template <typename Scalar>
 struct real_ref_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar& run(Scalar& x) { return reinterpret_cast<RealScalar*>(&x)[0]; }
   EIGEN_DEVICE_FUNC static inline const RealScalar& run(const Scalar& x) {
     return reinterpret_cast<const RealScalar*>(&x)[0];
   }
 };
 
-template <typename Scalar>
-struct real_ref_retval {
-  typedef typename NumTraits<Scalar>::Real& type;
-};
-
 /****************************************************************************
  * Implementation of imag_ref                                             *
  ****************************************************************************/
 
 template <typename Scalar, bool IsComplex>
 struct imag_ref_default_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar& run(Scalar& x) { return reinterpret_cast<RealScalar*>(&x)[1]; }
   EIGEN_DEVICE_FUNC static inline const RealScalar& run(const Scalar& x) {
     return reinterpret_cast<const RealScalar*>(&x)[1];
@@ -170,7 +148,7 @@
 
 template <typename Scalar>
 struct imag_ref_default_impl<Scalar, false> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr static inline RealScalar run(Scalar&) { return RealScalar(0); }
   EIGEN_DEVICE_FUNC constexpr static inline RealScalar run(const Scalar&) { return RealScalar(0); }
 };
@@ -178,38 +156,29 @@
 template <typename Scalar>
 struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
 
-template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
-struct imag_ref_retval {
-  typedef typename NumTraits<Scalar>::Real& type;
-};
-
-template <typename Scalar>
-struct imag_ref_retval<Scalar, false> {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 }  // namespace internal
 
 namespace numext {
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline decltype(auto) real(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline internal::add_const_on_value_type_t<EIGEN_MATHFUNC_RETVAL(real_ref, Scalar)> real_ref(
-    const Scalar& x) {
+EIGEN_DEVICE_FUNC inline auto real_ref(const Scalar& x)
+    -> internal::add_const_on_value_type_t<decltype(internal::real_ref_impl<Scalar>::run(x))> {
   return internal::real_ref_impl<Scalar>::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
+EIGEN_DEVICE_FUNC inline auto real_ref(Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(real_ref, std::remove_const_t<Scalar>)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(real_ref, std::remove_const_t<Scalar>)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline decltype(auto) imag(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
 }
 
@@ -242,25 +211,49 @@
 template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
 struct conj_impl : conj_default_impl<Scalar, IsComplex> {};
 
-template <typename Scalar>
-struct conj_retval {
-  typedef Scalar type;
+/****************************************************************************
+ * Implementation of mul                                                  *
+ ****************************************************************************/
+
+// Unsigned operands narrower than int promote to int, where a product whose wrapped value is representable
+// can still overflow: (unsigned short)0xffff squared is 0xfffe0001 > INT_MAX. Multiplying in unsigned int,
+// wider than every such operand, wraps instead. Mixed operand types, signed types, and bool keep operator*.
+template <typename Lhs, typename Rhs,
+          bool NarrowUnsigned = std::is_same<Lhs, Rhs>::value && std::is_unsigned<Lhs>::value &&
+                                !std::is_same<Lhs, bool>::value && (sizeof(Lhs) < sizeof(int))>
+struct mul_impl {
+  EIGEN_DEVICE_FUNC static constexpr EIGEN_ALWAYS_INLINE auto run(const Lhs& a, const Rhs& b) { return a * b; }
 };
 
+template <typename Scalar>
+struct mul_impl<Scalar, Scalar, true> {
+  EIGEN_DEVICE_FUNC static constexpr EIGEN_ALWAYS_INLINE Scalar run(const Scalar& a, const Scalar& b) {
+    return static_cast<Scalar>(static_cast<unsigned int>(a) * static_cast<unsigned int>(b));
+  }
+};
+
+/** \internal \returns a * b, wrapping rather than overflowing the signed type that integral promotion
+ * would give narrow unsigned operands. The result keeps operator*'s type, which for an expression-template
+ * Scalar is a lazy expression: consume it rather than binding it to auto. */
+template <typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE auto mul(const Lhs& a, const Rhs& b) {
+  return mul_impl<Lhs, Rhs>::run(a, b);
+}
+
 /****************************************************************************
  * Implementation of abs2                                                 *
  ****************************************************************************/
 
 template <typename Scalar, bool IsComplex>
 struct abs2_impl_default {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) { return x * x; }
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) { return internal::mul(x, x); }
 };
 
 template <typename Scalar>
 struct abs2_impl_default<Scalar, true>  // IsComplex
 {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     return numext::real(x) * numext::real(x) + numext::imag(x) * numext::imag(x);
   }
@@ -268,17 +261,12 @@
 
 template <typename Scalar>
 struct abs2_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     return abs2_impl_default<Scalar, NumTraits<Scalar>::IsComplex>::run(x);
   }
 };
 
-template <typename Scalar>
-struct abs2_retval {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 /****************************************************************************
  * Implementation of sqrt/rsqrt                                             *
  ****************************************************************************/
@@ -302,11 +290,6 @@
   EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE std::complex<T> run(const std::complex<T>& x) { return complex_sqrt(x); }
 };
 
-template <typename Scalar>
-struct sqrt_retval {
-  typedef Scalar type;
-};
-
 // Default implementation relies on numext::sqrt, at bottom of file.
 template <typename T>
 struct rsqrt_impl;
@@ -322,11 +305,6 @@
   }
 };
 
-template <typename Scalar>
-struct rsqrt_retval {
-  typedef Scalar type;
-};
-
 /****************************************************************************
  * Implementation of norm1                                                *
  ****************************************************************************/
@@ -336,7 +314,7 @@
 
 template <typename Scalar>
 struct norm1_default_impl<Scalar, true> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     EIGEN_USING_STD(abs);
     return abs(numext::real(x)) + abs(numext::imag(x));
@@ -345,7 +323,8 @@
 
 template <typename Scalar>
 struct norm1_default_impl<Scalar, false> {
-  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& x) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     EIGEN_USING_STD(abs);
     return abs(x);
   }
@@ -354,11 +333,6 @@
 template <typename Scalar>
 struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
 
-template <typename Scalar>
-struct norm1_retval {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 /****************************************************************************
  * Implementation of hypot                                                *
  ****************************************************************************/
@@ -366,11 +340,6 @@
 template <typename Scalar>
 struct hypot_impl;
 
-template <typename Scalar>
-struct hypot_retval {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 /****************************************************************************
  * Implementation of cast                                                 *
  ****************************************************************************/
@@ -388,10 +357,9 @@
 // Casting from S -> Complex<T> leads to an implicit conversion from S to T,
 // generating warnings on clang.  Here we explicitly cast the real component.
 template <typename OldType, typename NewType>
-struct cast_impl<OldType, NewType,
-                 typename std::enable_if_t<!NumTraits<OldType>::IsComplex && NumTraits<NewType>::IsComplex>> {
+struct cast_impl<OldType, NewType, std::enable_if_t<!NumTraits<OldType>::IsComplex && NumTraits<NewType>::IsComplex>> {
   EIGEN_DEVICE_FUNC static inline NewType run(const OldType& x) {
-    typedef typename NumTraits<NewType>::Real NewReal;
+    using NewReal = typename NumTraits<NewType>::Real;
     return static_cast<NewType>(static_cast<NewReal>(x));
   }
 };
@@ -411,14 +379,15 @@
 // This seems to be fixed in VS 2019.
 #if (!EIGEN_COMP_MSVC || EIGEN_COMP_MSVC >= 1920)
 // std::arg is only defined for types of std::complex, or integer types or float/double/long double
-template <typename Scalar, bool HasStdImpl = NumTraits<Scalar>::IsComplex || is_integral<Scalar>::value ||
-                                             is_same<Scalar, float>::value || is_same<Scalar, double>::value ||
-                                             is_same<Scalar, long double>::value>
+template <typename Scalar, bool HasStdImpl = NumTraits<Scalar>::IsComplex || std::is_integral<Scalar>::value ||
+                                             std::is_same<Scalar, float>::value ||
+                                             std::is_same<Scalar, double>::value ||
+                                             std::is_same<Scalar, long double>::value>
 struct arg_default_impl;
 
 template <typename Scalar>
 struct arg_default_impl<Scalar, true> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     // There is no official ::arg on device in CUDA/HIP, so we always need to use std::arg.
     using std::arg;
@@ -429,7 +398,7 @@
 // Must be non-complex floating-point type (e.g. half/bfloat16).
 template <typename Scalar>
 struct arg_default_impl<Scalar, false> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     return (x < Scalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
   }
@@ -437,7 +406,7 @@
 #else
 template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
 struct arg_default_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     return (x < RealScalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
   }
@@ -445,7 +414,7 @@
 
 template <typename Scalar>
 struct arg_default_impl<Scalar, true> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) {
     EIGEN_USING_STD(arg);
     return arg(x);
@@ -455,11 +424,6 @@
 template <typename Scalar>
 struct arg_impl : arg_default_impl<Scalar> {};
 
-template <typename Scalar>
-struct arg_retval {
-  typedef typename NumTraits<Scalar>::Real type;
-};
-
 /****************************************************************************
  * Implementation of expm1                                                   *
  ****************************************************************************/
@@ -472,7 +436,7 @@
 template <typename Scalar>
 EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) {
   EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   EIGEN_USING_STD(exp);
   Scalar u = exp(x);
@@ -499,11 +463,6 @@
   }
 };
 
-template <typename Scalar>
-struct expm1_retval {
-  typedef Scalar type;
-};
-
 /****************************************************************************
  * Implementation of log                                                     *
  ****************************************************************************/
@@ -535,7 +494,7 @@
 template <typename Scalar>
 EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
   EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_USING_STD(log);
   Scalar x1p = RealScalar(1) + x;
   Scalar log_1p = log_impl<Scalar>::run(x1p);
@@ -565,11 +524,6 @@
   }
 };
 
-template <typename Scalar>
-struct log1p_retval {
-  typedef Scalar type;
-};
-
 /****************************************************************************
  * Implementation of pow                                                  *
  ****************************************************************************/
@@ -577,9 +531,8 @@
 template <typename ScalarX, typename ScalarY,
           bool IsInteger = NumTraits<ScalarX>::IsInteger && NumTraits<ScalarY>::IsInteger>
 struct pow_impl {
-  // typedef Scalar retval;
-  typedef typename ScalarBinaryOpTraits<ScalarX, ScalarY, internal::scalar_pow_op<ScalarX, ScalarY>>::ReturnType
-      result_type;
+  using result_type =
+      typename ScalarBinaryOpTraits<ScalarX, ScalarY, internal::scalar_pow_op<ScalarX, ScalarY>>::ReturnType;
   static EIGEN_DEVICE_FUNC inline result_type run(const ScalarX& x, const ScalarY& y) {
     EIGEN_USING_STD(pow);
     return pow(x, y);
@@ -588,57 +541,29 @@
 
 template <typename ScalarX, typename ScalarY>
 struct pow_impl<ScalarX, ScalarY, true> {
-  typedef ScalarX result_type;
+  using result_type = ScalarX;
   static EIGEN_DEVICE_FUNC inline ScalarX run(ScalarX x, ScalarY y) {
     ScalarX res(1);
     eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
-    if (y & 1) res *= x;
+    if (y & 1) res = internal::mul(res, x);
     y >>= 1;
     while (y) {
-      x *= x;
-      if (y & 1) res *= x;
+      x = internal::mul(x, x);
+      if (y & 1) res = internal::mul(res, x);
       y >>= 1;
     }
     return res;
   }
 };
 
-enum { meta_floor_log2_terminate, meta_floor_log2_move_up, meta_floor_log2_move_down, meta_floor_log2_bogus };
-
-template <unsigned int n, int lower, int upper>
-struct meta_floor_log2_selector {
-  enum {
-    middle = (lower + upper) / 2,
-    value = (upper <= lower + 1)  ? int(meta_floor_log2_terminate)
-            : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
-            : (n == 0)            ? int(meta_floor_log2_bogus)
-                                  : int(meta_floor_log2_move_up)
-  };
-};
-
-template <unsigned int n, int lower = 0, int upper = sizeof(unsigned int) * CHAR_BIT - 1,
-          int selector = meta_floor_log2_selector<n, lower, upper>::value>
-struct meta_floor_log2 {};
-
-template <unsigned int n, int lower, int upper>
-struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down> {
-  enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
-};
-
-template <unsigned int n, int lower, int upper>
-struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up> {
-  enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
-};
-
-template <unsigned int n, int lower, int upper>
-struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate> {
-  enum { value = (n >= ((unsigned int)(1) << (lower + 1))) ? lower + 1 : lower };
-};
-
-template <unsigned int n, int lower, int upper>
-struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus> {
-  // no value, error at compile time
-};
+constexpr int floor_log2(unsigned int value) {
+  int result = 0;
+  while (value > 1) {
+    value >>= 1;
+    ++result;
+  }
+  return result;
+}
 
 template <typename BitsType, typename EnableIf = void>
 struct count_bits_impl {
@@ -677,6 +602,15 @@
     }
     return n;
   }
+
+  static EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+    int n = 0;
+    while (bits) {
+      bits &= bits - 1;
+      ++n;
+    }
+    return n;
+  }
 };
 
 // Count leading zeros.
@@ -691,6 +625,12 @@
   return count_bits_impl<BitsType>::ctz(bits);
 }
 
+// Count set bits (population count).
+template <typename BitsType>
+EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+  return count_bits_impl<BitsType>::popcount(bits);
+}
+
 #if EIGEN_COMP_GNUC || EIGEN_COMP_CLANG
 
 template <typename BitsType>
@@ -705,6 +645,10 @@
   static EIGEN_DEVICE_FUNC inline int ctz(BitsType bits) {
     return bits == 0 ? kNumBits : __builtin_ctz(static_cast<unsigned int>(bits));
   }
+
+  static EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+    return __builtin_popcount(static_cast<unsigned int>(bits));
+  }
 };
 
 template <typename BitsType>
@@ -720,6 +664,10 @@
   static EIGEN_DEVICE_FUNC inline int ctz(BitsType bits) {
     return bits == 0 ? kNumBits : __builtin_ctzl(static_cast<unsigned long>(bits));
   }
+
+  static EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+    return __builtin_popcountl(static_cast<unsigned long>(bits));
+  }
 };
 
 template <typename BitsType>
@@ -735,10 +683,28 @@
   static EIGEN_DEVICE_FUNC inline int ctz(BitsType bits) {
     return bits == 0 ? kNumBits : __builtin_ctzll(static_cast<unsigned long long>(bits));
   }
+
+  static EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+    return __builtin_popcountll(static_cast<unsigned long long>(bits));
+  }
 };
 
 #elif EIGEN_COMP_MSVC
 
+// `__popcnt`/`__popcnt64` require `POPCNT` hardware support, which MSVC cannot guarantee
+// at its default baseline (unlike `_BitScanReverse`/`_BitScanForward`, which lower to
+// baseline `bsr`/`bsf`).  Fall back to a portable count when building without SSE4.2
+// enabled.
+template <typename BitsType>
+EIGEN_DEVICE_FUNC inline int popcount_fallback(BitsType bits) {
+  int n = 0;
+  while (bits) {
+    bits &= bits - 1;
+    ++n;
+  }
+  return n;
+}
+
 template <typename BitsType>
 struct count_bits_impl<
     BitsType, std::enable_if_t<std::is_integral<BitsType>::value && sizeof(BitsType) <= sizeof(unsigned long)>> {
@@ -754,6 +720,14 @@
     _BitScanForward(&out, static_cast<unsigned long>(bits));
     return bits == 0 ? kNumBits : static_cast<int>(out);
   }
+
+  static EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+#if defined(EIGEN_VECTORIZE_SSE4_2)
+    return static_cast<int>(__popcnt(static_cast<unsigned int>(bits)));
+#else
+    return popcount_fallback(bits);
+#endif
+  }
 };
 
 #ifdef _WIN64
@@ -774,6 +748,14 @@
     _BitScanForward64(&out, static_cast<unsigned __int64>(bits));
     return bits == 0 ? kNumBits : static_cast<int>(out);
   }
+
+  static EIGEN_DEVICE_FUNC inline int popcount(BitsType bits) {
+#if defined(EIGEN_VECTORIZE_SSE4_2)
+    return static_cast<int>(__popcnt64(static_cast<unsigned __int64>(bits)));
+#else
+    return popcount_fallback(bits);
+#endif
+  }
 };
 
 #endif  // _WIN64
@@ -885,8 +867,10 @@
     EIGEN_USING_STD(abs);
     real_type aa = abs(a);
     if (aa == real_type(0)) return Scalar(0);
-    aa = real_type(1) / aa;
-    return Scalar(numext::real(a) * aa, numext::imag(a) * aa);
+    // Divide rather than multiply by 1/aa: the reciprocal overflows for subnormal aa and is itself
+    // subnormal, hence inexact, for aa near the top of the range. psign_impl for complex packets
+    // divides for the same reason.
+    return Scalar(numext::real(a) / aa, numext::imag(a) / aa);
   }
 };
 
@@ -896,9 +880,35 @@
   EIGEN_DEVICE_FUNC static inline bool run(const bool& a) { return a; }
 };
 
+template <typename Scalar, bool IsComplex = (NumTraits<Scalar>::IsComplex != 0),
+          bool IsInteger = (NumTraits<Scalar>::IsInteger != 0)>
+struct copysign_impl {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& a, const Scalar& b) {
+    EIGEN_USING_STD(copysign);
+    return Scalar(copysign(a, b));
+  }
+};
+
+template <typename Scalar, bool IsInteger>
+struct copysign_impl<Scalar, true, IsInteger> {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& a, const Scalar& b) {
+    EIGEN_USING_STD(copysign);
+    return Scalar(copysign(numext::real(a), numext::real(b)), copysign(numext::imag(a), numext::imag(b)));
+  }
+};
+
 template <typename Scalar>
-struct sign_retval {
-  typedef Scalar type;
+struct copysign_impl<Scalar, false, true> {
+  EIGEN_DEVICE_FUNC static inline Scalar run(const Scalar& a, const Scalar& b) {
+    EIGEN_IF_CONSTEXPR (!NumTraits<Scalar>::IsSigned) return a;
+    const Scalar abs_a = a < Scalar(0) ? -a : a;
+    return b < Scalar(0) ? -abs_a : abs_a;
+  }
+};
+
+template <>
+struct copysign_impl<bool, false, true> {
+  EIGEN_DEVICE_FUNC static inline bool run(const bool& a, const bool&) { return a; }
 };
 
 // suppress "unary minus operator applied to unsigned type, result still unsigned" warnings on MSVC
@@ -911,15 +921,10 @@
 
 template <typename Scalar>
 struct negate_impl<Scalar, true> {
-  EIGEN_STATIC_ASSERT((!is_same<Scalar, bool>::value), NEGATE IS NOT DEFINED FOR BOOLEAN TYPES)
+  EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), NEGATE IS NOT DEFINED FOR BOOLEAN TYPES)
   static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar run(const Scalar& a) { return Scalar(0) - a; }
 };
 
-template <typename Scalar>
-struct negate_retval {
-  typedef Scalar type;
-};
-
 template <typename Scalar, bool IsInteger = NumTraits<typename unpacket_traits<Scalar>::type>::IsInteger>
 struct nearest_integer_impl {
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar run_floor(const Scalar& x) {
@@ -982,7 +987,7 @@
 
 #if defined(EIGEN_GPUCC)
 template <>
-struct has_fma<float> : public true_type {};
+struct has_fma<float> : public std::true_type {};
 
 template <>
 struct fma_impl<float, void> {
@@ -992,7 +997,7 @@
 };
 
 template <>
-struct has_fma<double> : public true_type {};
+struct has_fma<double> : public std::true_type {};
 
 template <>
 struct fma_impl<double, void> {
@@ -1019,6 +1024,42 @@
 };
 #endif
 
+// Representation properties shared by operations that inspect an IEEE-style binary floating-point value.
+template <typename Scalar>
+struct binary_floating_point_traits {
+  using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  static constexpr int kFractionBits = std::numeric_limits<Scalar>::digits - 1;
+  static constexpr int kExponentBits = int(sizeof(Scalar) * CHAR_BIT) - std::numeric_limits<Scalar>::digits;
+  static constexpr int kExponentBias = std::numeric_limits<Scalar>::max_exponent - 1;
+  static constexpr Bits kSignBit = Bits(1) << (sizeof(Scalar) * CHAR_BIT - 1);
+  static constexpr Bits kExponentUnit = Bits(1) << kFractionBits;
+  static constexpr Bits kFractionMask = kExponentUnit - 1;
+  static constexpr Bits kExponentMask = ((Bits(1) << kExponentBits) - 1) << kFractionBits;
+  static constexpr Bits kMaxFiniteExponentBits = kExponentMask - kExponentUnit;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Bits bits(const Scalar& value) { return numext::bit_cast<Bits>(value); }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Bits magnitude(const Scalar& value) { return bits(value) & ~kSignBit; }
+};
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool is_exactly_zero_no_flush_impl(const Scalar& value, false_type) {
+  return numext::is_exactly_zero(value);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE bool is_zero_magnitude_bits(
+    typename binary_floating_point_traits<Scalar>::Bits magnitude) {
+  // Keep the integer comparison out of line: Clang can otherwise fold it into a
+  // floating-point comparison that treats subnormals as zero under DAZ/FZ.
+  return magnitude == 0;
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool is_exactly_zero_no_flush_impl(const Scalar& value, true_type) {
+  return is_zero_magnitude_bits<Scalar>(binary_floating_point_traits<Scalar>::magnitude(value));
+}
+
 }  // end namespace internal
 
 /****************************************************************************
@@ -1027,7 +1068,15 @@
 
 namespace numext {
 
-#if (!defined(EIGEN_GPUCC) || defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
+template <typename X>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool is_exactly_zero_no_flush(const X& x) {
+  constexpr bool HasBinaryEncoding = (std::is_same<X, float>::value || std::is_same<X, double>::value) &&
+                                     std::numeric_limits<X>::is_iec559 && std::numeric_limits<X>::radix == 2 &&
+                                     (sizeof(X) == sizeof(uint32_t) || sizeof(X) == sizeof(uint64_t));
+  return internal::is_exactly_zero_no_flush_impl(x, internal::bool_constant<HasBinaryEncoding>());
+}
+
+#if !defined(EIGEN_GPUCC)
 template <typename T>
 EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) {
   EIGEN_USING_STD(min)
@@ -1041,9 +1090,13 @@
 }
 #else
 template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) {
+EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) {
   return y < x ? y : x;
 }
+#if !defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC)
+// Without relaxed constexpr, numeric GPU scalars keep fmin/fmax's number-preferring
+// NaN behavior. With relaxed constexpr, they use the constexpr ternary overloads,
+// matching std::min/std::max behavior and supporting custom less-comparable scalars.
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y) {
   return fminf(x, y);
@@ -1064,11 +1117,13 @@
 #endif
 }
 #endif
+#endif
 
 template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y) {
+EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y) {
   return x < y ? y : x;
 }
+#if !defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC)
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y) {
   return fmaxf(x, y);
@@ -1089,6 +1144,7 @@
 }
 #endif
 #endif
+#endif
 
 #if defined(SYCL_DEVICE_ONLY)
 
@@ -1155,38 +1211,44 @@
 #endif
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline typename NumTraits<Scalar>::Real arg(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline internal::add_const_on_value_type_t<EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar)> imag_ref(
-    const Scalar& x) {
+EIGEN_DEVICE_FUNC inline auto imag_ref(const Scalar& x)
+    -> internal::add_const_on_value_type_t<decltype(internal::imag_ref_impl<Scalar>::run(x))> {
   return internal::imag_ref_impl<Scalar>::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
+EIGEN_DEVICE_FUNC inline auto imag_ref(Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(imag_ref, std::remove_const_t<Scalar>)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(imag_ref, std::remove_const_t<Scalar>)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline Scalar conj(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(sign, Scalar) sign(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline Scalar sign(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(sign, Scalar)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(negate, Scalar) negate(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline Scalar copysign(const Scalar& x, const Scalar& y) {
+  return EIGEN_MATHFUNC_IMPL(copysign, Scalar)::run(x, y);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline Scalar negate(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(negate, Scalar)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline decltype(auto) abs2(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
 }
 
@@ -1214,12 +1276,12 @@
 #endif
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline typename NumTraits<Scalar>::Real norm1(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
 }
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y) {
+EIGEN_DEVICE_FUNC inline typename NumTraits<Scalar>::Real hypot(const Scalar& x, const Scalar& y) {
   return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
 }
 
@@ -1228,7 +1290,7 @@
 #endif
 
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
 }
 
@@ -1340,7 +1402,7 @@
 // T is assumed to be an integer type with a>=0, and b>0
 template <typename T>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr T div_ceil(T a, T b) {
-  using UnsignedT = typename internal::make_unsigned<T>::type;
+  using UnsignedT = std::make_unsigned_t<T>;
   EIGEN_STATIC_ASSERT((NumTraits<T>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
   // Note: explicitly declaring a and b as non-negative values allows the compiler to use better optimizations
   const UnsignedT ua = UnsignedT(a);
@@ -1353,8 +1415,8 @@
 // T is assumed to be an integer type with a>=0, and b>0
 template <typename T, typename U>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr T round_down(T a, U b) {
-  using UnsignedT = typename internal::make_unsigned<T>::type;
-  using UnsignedU = typename internal::make_unsigned<U>::type;
+  using UnsignedT = std::make_unsigned_t<T>;
+  using UnsignedU = std::make_unsigned_t<U>;
   EIGEN_STATIC_ASSERT((NumTraits<T>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
   EIGEN_STATIC_ASSERT((NumTraits<U>::IsInteger), THIS FUNCTION IS FOR INTEGER TYPES)
   // Note: explicitly declaring a and b as non-negative values allows the compiler to use better optimizations
@@ -1390,10 +1452,10 @@
  * but slightly faster for float/double and some compilers (e.g., gcc), thanks to
  * specializations when SSE is enabled.
  *
- * It's usage is justified in performance critical functions, like norm/normalize.
+ * Its usage is justified in performance critical functions, like norm/normalize.
  */
 template <typename Scalar>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x) {
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar sqrt(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
 }
 
@@ -1449,15 +1511,21 @@
 
 template <typename T>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
-    std::enable_if_t<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex, typename NumTraits<T>::Real>
+    std::enable_if_t<NumTraits<T>::IsSigned && !NumTraits<T>::IsComplex, typename NumTraits<T>::Real>
     abs(const T& x) {
   EIGEN_USING_STD(abs);
   return abs(x);
 }
 
 template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<NumTraits<T>::IsComplex, typename NumTraits<T>::Real> abs(
+    const T& x) {
+  return numext::hypot(numext::real(x), numext::imag(x));
+}
+
+template <typename T>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
-    std::enable_if_t<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex), typename NumTraits<T>::Real>
+    std::enable_if_t<!NumTraits<T>::IsSigned && !NumTraits<T>::IsComplex, typename NumTraits<T>::Real>
     abs(const T& x) {
   return x;
 }
@@ -1524,22 +1592,26 @@
   return exp(x);
 }
 
-// MSVC screws up some edge-cases for std::exp(complex).
-#ifdef EIGEN_COMP_MSVC
+// MSVC through at least 19.51 mishandles some finite-real, non-finite-imaginary inputs to std::exp(complex).
+#if EIGEN_COMP_MSVC
 template <typename RealScalar>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::complex<RealScalar> exp(const std::complex<RealScalar>& x) {
-  EIGEN_USING_STD(exp);
+  // Evaluate eagerly to preserve the floating-point exceptions raised by std::exp before correcting its result.
+  const std::complex<RealScalar> result = std::exp(x);
   // If z is (x,±∞) (for any finite x), the result is (NaN,NaN) and FE_INVALID is raised.
   // If z is (x,NaN) (for any finite x), the result is (NaN,NaN) and FE_INVALID may be raised.
   if ((isfinite)(real_ref(x)) && !(isfinite)(imag_ref(x))) {
     return std::complex<RealScalar>(NumTraits<RealScalar>::quiet_NaN(), NumTraits<RealScalar>::quiet_NaN());
   }
+#if EIGEN_COMP_MSVC < 1931
+  // Before 19.31, MSVC also mishandles a positive-infinite real part with a non-finite imaginary part.
   // If z is (+∞,±∞), the result is (±∞,NaN) and FE_INVALID is raised (the sign of the real part is unspecified)
   // If z is (+∞,NaN), the result is (±∞,NaN) (the sign of the real part is unspecified)
   if ((real_ref(x) == NumTraits<RealScalar>::infinity() && !(isfinite)(imag_ref(x)))) {
     return std::complex<RealScalar>(NumTraits<RealScalar>::infinity(), NumTraits<RealScalar>::quiet_NaN());
   }
-  return exp(x);
+#endif
+  return result;
 }
 #endif
 
@@ -1632,8 +1704,39 @@
 }
 #endif
 
+// Exact scaling by 2^exponent, including denormals and unrepresentable scale factors.
+// Results outside the finite range saturate to zero or infinity.
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T ldexp(const T& x, int exponent) {
+  EIGEN_USING_STD(ldexp);
+  return static_cast<T>(ldexp(x, exponent));
+}
+
+#if defined(SYCL_DEVICE_ONLY)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_float ldexp(const cl::sycl::cl_float& x, int exponent) {
+  return cl::sycl::ldexp(x, exponent);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE cl::sycl::cl_double ldexp(const cl::sycl::cl_double& x, int exponent) {
+  return cl::sycl::ldexp(x, exponent);
+}
+#endif
+
+#if defined(EIGEN_GPUCC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float ldexp(const float& x, int exponent) {
+  return ::ldexpf(x, exponent);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double ldexp(const double& x, int exponent) {
+  return ::ldexp(x, exponent);
+}
+#endif
+
 template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(expm1, Scalar) expm1(const Scalar& x) {
+EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) {
   return EIGEN_MATHFUNC_IMPL(expm1, Scalar)::run(x);
 }
 
@@ -1904,13 +2007,70 @@
 }
 #endif
 
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T nextafter(const T& from, const T& to) {
+  EIGEN_USING_STD(nextafter);
+  return nextafter(from, to);
+}
+
+/** Returns the smallest normal power of two greater than or equal to \a value.
+ *
+ * \pre \a value is finite and nonnegative.
+ * Zero is preserved. A value larger than the greatest finite power of two maps to infinity.
+ */
+template <typename Scalar,
+          std::enable_if_t<!std::is_same<Scalar, long double>::value && std::numeric_limits<Scalar>::is_iec559 &&
+                               std::numeric_limits<Scalar>::radix == 2 &&
+                               (sizeof(Scalar) == sizeof(uint16_t) || sizeof(Scalar) == sizeof(uint32_t) ||
+                                sizeof(Scalar) == sizeof(uint64_t)),
+                           int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar ceil_power_of_two(const Scalar& value) {
+  using Binary = internal::binary_floating_point_traits<Scalar>;
+  using Bits = typename Binary::Bits;
+  const Bits valueBits = Binary::bits(value);
+  const Bits resultBits = Bits((valueBits + Binary::kFractionMask) & Binary::kExponentMask);
+  return bit_cast<Scalar>(resultBits);
+}
+
+// long double has no portable object representation: depending on the ABI it can be binary64, padded x87 extended
+// precision, IEEE binary128, or IBM double-double. Construct the result arithmetically instead of inspecting its bits.
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+EIGEN_STRONG_INLINE long double ceil_power_of_two(const long double& value) {
+  EIGEN_USING_STD(frexp);
+  EIGEN_USING_STD(ldexp);
+  int exponent = 0;
+  const long double fraction = frexp(value, &exponent);
+  if (numext::is_exactly_zero(fraction)) return 0.0L;
+  if (numext::equal_strict(fraction, 0.5L)) --exponent;
+  if (exponent < std::numeric_limits<long double>::min_exponent - 1)
+    exponent = std::numeric_limits<long double>::min_exponent - 1;
+  return ldexp(1.0L, exponent);
+}
+#endif
+
+#if defined(SYCL_DEVICE_ONLY)
+SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(nextafter, nextafter)
+#endif
+
+#if defined(EIGEN_GPUCC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float nextafter(const float& from, const float& to) {
+  return ::nextafterf(from, to);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double nextafter(const double& from, const double& to) {
+  return ::nextafter(from, to);
+}
+#endif
+
 #if defined(SYCL_DEVICE_ONLY)
 #undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY
 #undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY
 #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY
 #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY
 #undef SYCL_SPECIALIZE_INTEGER_TYPES_BINARY
-#undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY
+#undef SYCL_SPECIALIZE_INTEGER_TYPES_UNARY
 #undef SYCL_SPECIALIZE_FLOATING_TYPES_BINARY
 #undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY
 #undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE
@@ -1921,21 +2081,31 @@
 #undef SYCL_SPECIALIZE_BINARY_FUNC
 #endif
 
+// A logical shift is a shift of the bit pattern, so it goes through the unsigned type of the same
+// width whatever Scalar's signedness. A Scalar narrower than int promotes to int for the shift
+// itself, which the explicit truncation undoes: for the left shift the promoted value can carry set
+// bits above Scalar's width, and dropping them is the operation rather than an accident of the cast.
 template <typename Scalar, typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar logical_shift_left(const Scalar& a, int n) {
-  return a << n;
+  using UnsignedScalar = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  return bit_cast<Scalar, UnsignedScalar>(static_cast<UnsignedScalar>(bit_cast<UnsignedScalar, Scalar>(a) << n));
 }
 
 template <typename Scalar, typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar logical_shift_right(const Scalar& a, int n) {
   using UnsignedScalar = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
-  return bit_cast<Scalar, UnsignedScalar>(bit_cast<UnsignedScalar, Scalar>(a) >> n);
+  return bit_cast<Scalar, UnsignedScalar>(static_cast<UnsignedScalar>(bit_cast<UnsignedScalar, Scalar>(a) >> n));
 }
 
+// An arithmetic shift propagates the sign bit, so it coincides with the logical shift when Scalar is
+// unsigned and has none. Shifting through the signed type unconditionally would sign-extend an
+// ordinary value bit, which is what every backend's parithmetic_shift_right on unsigned packets
+// avoids, leaving the scalar and vectorized paths of one expression disagreeing. Scalar's own
+// operator>> already selects on its signedness, so no reinterpretation is needed; the cast only
+// undoes the integral promotion a Scalar narrower than int is subject to.
 template <typename Scalar, typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar arithmetic_shift_right(const Scalar& a, int n) {
-  using SignedScalar = typename numext::get_integer_by_size<sizeof(Scalar)>::signed_type;
-  return bit_cast<Scalar, SignedScalar>(bit_cast<SignedScalar, Scalar>(a) >> n);
+  return static_cast<Scalar>(a >> n);
 }
 
 template <typename Scalar>
@@ -1955,17 +2125,32 @@
 
 template <typename T>
 EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x) {
-  return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
+  EIGEN_IF_CONSTEXPR ((std::is_floating_point<T>::value)) {
+    // Eager classification lets coefficient-wise loops remain branch-free.
+    return static_cast<unsigned int>((numext::isfinite)(numext::real(x))) & (numext::isfinite)(numext::imag(x));
+  } else {
+    return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
+  }
 }
 
 template <typename T>
 EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x) {
-  return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
+  EIGEN_IF_CONSTEXPR ((std::is_floating_point<T>::value)) {
+    return static_cast<unsigned int>((numext::isnan)(numext::real(x))) | (numext::isnan)(numext::imag(x));
+  } else {
+    return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
+  }
 }
 
 template <typename T>
 EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x) {
-  return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
+  EIGEN_IF_CONSTEXPR ((std::is_floating_point<T>::value)) {
+    const bool has_inf = static_cast<unsigned int>((numext::isinf)(numext::real(x))) | (numext::isinf)(numext::imag(x));
+    const bool has_nan = (numext::isnan)(x);
+    return has_inf & !has_nan;
+  } else {
+    return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
+  }
 }
 
 /****************************************************************************
@@ -1977,7 +2162,7 @@
 
 template <typename Scalar>
 struct scalar_fuzzy_default_impl<Scalar, false, false> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   template <typename OtherScalar>
   EIGEN_DEVICE_FUNC static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
                                                          const RealScalar& prec) {
@@ -1993,7 +2178,7 @@
 
 template <typename Scalar>
 struct scalar_fuzzy_default_impl<Scalar, false, true> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   template <typename OtherScalar>
   EIGEN_DEVICE_FUNC static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, const RealScalar&) {
     return x == Scalar(0);
@@ -2006,7 +2191,7 @@
 
 template <typename Scalar>
 struct scalar_fuzzy_default_impl<Scalar, true, false> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   template <typename OtherScalar>
   EIGEN_DEVICE_FUNC static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
                                                          const RealScalar& prec) {
@@ -2048,7 +2233,7 @@
 
 template <>
 struct scalar_fuzzy_impl<bool> {
-  typedef bool RealScalar;
+  using RealScalar = bool;
 
   template <typename OtherScalar>
   EIGEN_DEVICE_FUNC static inline bool isMuchSmallerThan(const bool& x, const bool&, const bool&) {
@@ -2096,7 +2281,15 @@
 
 template <typename T>
 struct rsqrt_impl {
+// C4804: unsafe use of type 'bool' in operation. Unavoidable when instantiated with T=bool.
+#if EIGEN_COMP_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4804)
+#endif
   EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE T run(const T& x) { return T(1) / numext::sqrt(x); }
+#if EIGEN_COMP_MSVC
+#pragma warning(pop)
+#endif
 };
 
 #if defined(EIGEN_GPU_COMPILE_PHASE)
@@ -2161,6 +2354,38 @@
 
 }  // end namespace internal
 
+namespace numext {
+
+/** \internal
+ * \brief Scalar division that guards against intermediate overflow for complex types.
+ *
+ * For real types, this evaluates a / b.
+ * For complex types, this evaluates a / b using Smith's method to prevent intermediate
+ * overflow (c^2 + d^2) when b is near the boundary of the representable range, consistent
+ * with the vectorized complex division path in GenericPacketMathComplex.h.
+ */
+template <typename LhsScalar, typename RhsScalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto divide(const LhsScalar& a, const RhsScalar& b) -> decltype(a / b) {
+  return a / b;
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> divide(const std::complex<T>& a, const std::complex<T>& b) {
+  return internal::complex_divide_smith(a, b);
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> divide(const T& a, const std::complex<T>& b) {
+  return internal::complex_divide_smith(std::complex<T>(a, T(0)), b);
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> divide(const std::complex<T>& a, const T& b) {
+  return a / b;
+}
+
+}  // end namespace numext
+
 }  // end namespace Eigen
 
 #endif  // EIGEN_MATHFUNCTIONS_H
diff --git a/Eigen/src/Core/MathFunctionsImpl.h b/Eigen/src/Core/MathFunctionsImpl.h
index 2433187..6296aff 100644
--- a/Eigen/src/Core/MathFunctionsImpl.h
+++ b/Eigen/src/Core/MathFunctionsImpl.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATHFUNCTIONSIMPL_H
 #define EIGEN_MATHFUNCTIONSIMPL_H
@@ -92,7 +93,7 @@
       inv_sqrt = pmadd(half_r, h_n, inv_sqrt);
     }
 
-    // If x is NaN, then either:
+    // If inv_sqrt is NaN, then either:
     // 1) the input is NaN
     // 2) zero and infinity were multiplied
     // In either of these cases, return approx_rsqrt
@@ -150,7 +151,7 @@
 template <typename RealScalar>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE RealScalar positive_real_hypot(const RealScalar& x,
                                                                                const RealScalar& y) {
-  // IEEE IEC 6059 special cases.
+  // IEEE IEC 60559 special cases.
   if ((numext::isinf)(x) || (numext::isinf)(y)) return NumTraits<RealScalar>::infinity();
   if ((numext::isnan)(x) || (numext::isnan)(y)) return NumTraits<RealScalar>::quiet_NaN();
 
@@ -163,88 +164,105 @@
 
 template <typename Scalar>
 struct hypot_impl {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   static EIGEN_DEVICE_FUNC inline RealScalar run(const Scalar& x, const Scalar& y) {
-    EIGEN_USING_STD(abs);
-    return positive_real_hypot<RealScalar>(abs(x), abs(y));
+    return positive_real_hypot<RealScalar>(numext::abs(x), numext::abs(y));
   }
 };
 
-// Generic complex sqrt implementation that correctly handles corner cases
-// according to https://en.cppreference.com/w/cpp/numeric/complex/sqrt
-template <typename ComplexT>
-EIGEN_DEVICE_FUNC constexpr ComplexT complex_sqrt(const ComplexT& z) {
-  // Computes the principal sqrt of the input.
-  //
-  // For a complex square root of the number x + i*y. We want to find real
-  // numbers u and v such that
-  //    (u + i*v)^2 = x + i*y  <=>
-  //    u^2 - v^2 + i*2*u*v = x + i*v.
-  // By equating the real and imaginary parts we get:
-  //    u^2 - v^2 = x
-  //    2*u*v = y.
-  //
-  // For x >= 0, this has the numerically stable solution
-  //    u = sqrt(0.5 * (x + sqrt(x^2 + y^2)))
-  //    v = y / (2 * u)
-  // and for x < 0,
-  //    v = sign(y) * sqrt(0.5 * (-x + sqrt(x^2 + y^2)))
-  //    u = y / (2 * v)
-  //
-  // Letting w = sqrt(0.5 * (|x| + |z|)),
-  //   if x == 0: u = w, v = sign(y) * w
-  //   if x > 0:  u = w, v = y / (2 * w)
-  //   if x < 0:  u = |y| / (2 * w), v = sign(y) * w
+template <typename ComplexT, bool Reciprocal>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE constexpr ComplexT complex_sqrt_extreme(const ComplexT& z) {
   using T = typename NumTraits<ComplexT>::Real;
   const T x = numext::real(z);
   const T y = numext::imag(z);
   const T zero = T(0);
-  const T w = numext::sqrt(T(0.5) * (numext::abs(x) + numext::hypot(x, y)));
+  const T inf = NumTraits<T>::infinity();
+  EIGEN_IF_CONSTEXPR (Reciprocal) {
+    if ((numext::isinf)(x) || (numext::isinf)(y)) return ComplexT(zero, numext::copysign(zero, -y));
+  } else {
+    if ((numext::isinf)(y)) return ComplexT(inf, y);
+    if ((numext::isinf)(x)) {
+      const T other = (numext::isnan)(y) ? y : zero;
+      return x > zero ? ComplexT(inf, numext::copysign(other, y))
+                      : ComplexT(numext::abs(other), numext::copysign(inf, y));
+    }
+  }
+  if ((numext::isnan)(x) || (numext::isnan)(y)) {
+    return ComplexT(NumTraits<T>::quiet_NaN(), NumTraits<T>::quiet_NaN());
+  }
+  if (numext::is_exactly_zero(x) && numext::is_exactly_zero(y)) {
+    return Reciprocal ? ComplexT(inf, NumTraits<T>::quiet_NaN()) : ComplexT(zero, y);
+  }
 
-  return (numext::isinf)(y)           ? ComplexT(NumTraits<T>::infinity(), y)
-         : numext::is_exactly_zero(x) ? ComplexT(w, y < zero ? -w : w)
-         : x > zero                   ? ComplexT(w, y / (2 * w))
-                                      : ComplexT(numext::abs(y) / (2 * w), y < zero ? -w : w);
+  T ax = numext::abs(x);
+  T ay = numext::abs(y);
+  const T p = numext::maxi(ax, ay);
+  const T r = numext::mini(ax, ay) / p;
+  const T h = numext::sqrt(T(1) + r * r);
+  // Evaluate at z/p, restoring sqrt(p) only after taking the square root.
+  ax /= p;
+  ay /= p;
+  const T scale = numext::sqrt(p);
+  const T sum = ax + h;
+  const T w = numext::sqrt(T(0.5) * sum);
+  T major = w * scale;
+  T minor = zero;
+  EIGEN_IF_CONSTEXPR (Reciprocal) {
+    major = (w / h) / scale;
+    minor = (ay / sum) * major;
+  } else {
+    // Use the original y: normalizing z/p can underflow its smaller component.
+    minor = numext::abs(y) / (T(2) * major);
+  }
+  if (numext::is_exactly_zero(x)) minor = major;
+  const T imag_sign = Reciprocal ? -y : y;
+  return x < zero ? ComplexT(minor, numext::copysign(major, imag_sign))
+                  : ComplexT(major, numext::copysign(minor, imag_sign));
 }
 
-// Generic complex rsqrt implementation.
-template <typename ComplexT>
-EIGEN_DEVICE_FUNC constexpr ComplexT complex_rsqrt(const ComplexT& z) {
-  // Computes the principal reciprocal sqrt of the input.
-  //
-  // For a complex reciprocal square root of the number z = x + i*y. We want to
-  // find real numbers u and v such that
-  //    (u + i*v)^2 = 1 / (x + i*y)  <=>
-  //    u^2 - v^2 + i*2*u*v = x/|z|^2 - i*v/|z|^2.
-  // By equating the real and imaginary parts we get:
-  //    u^2 - v^2 = x/|z|^2
-  //    2*u*v = y/|z|^2.
-  //
-  // For x >= 0, this has the numerically stable solution
-  //    u = sqrt(0.5 * (x + |z|)) / |z|
-  //    v = -y / (2 * u * |z|)
-  // and for x < 0,
-  //    v = -sign(y) * sqrt(0.5 * (-x + |z|)) / |z|
-  //    u = -y / (2 * v * |z|)
-  //
-  // Letting w = sqrt(0.5 * (|x| + |z|)),
-  //   if x == 0: u = w / |z|, v = -sign(y) * w / |z|
-  //   if x > 0:  u = w / |z|, v = -y / (2 * w * |z|)
-  //   if x < 0:  u = |y| / (2 * w * |z|), v = -sign(y) * w / |z|
+template <typename ComplexT, bool Reciprocal>
+EIGEN_DEVICE_FUNC constexpr ComplexT complex_sqrt_impl(const ComplexT& z) {
   using T = typename NumTraits<ComplexT>::Real;
   const T x = numext::real(z);
   const T y = numext::imag(z);
-  const T zero = T(0);
+  const T ax = numext::abs(x);
+  const T ay = numext::abs(y);
+  const bool real_larger = ax > ay;
+  const T p = real_larger ? ax : ay;
+  const T q = real_larger ? ay : ax;
+  // These bounds keep (|x| + |z|)/2 normal and finite. Using the same comparison
+  // for p and q preserves a NaN in either component.
+  if (EIGEN_PREDICT_FALSE(!(p > T(2) * (numext::numeric_limits<T>::min)() && p <= NumTraits<T>::highest() / T(4)))) {
+    return complex_sqrt_extreme<ComplexT, Reciprocal>(z);
+  }
+  const T r = q / p;
+  const T abs_z = p * numext::sqrt(T(1) + r * r);
+  const T sum = ax + abs_z;
+  const T w = numext::sqrt(T(0.5) * sum);
+  T major = w;
+  T minor = T(0);
+  EIGEN_IF_CONSTEXPR (Reciprocal) {
+    major = w / abs_z;
+    // |y|/(2*w*|z|) = (|y|/(|x| + |z|)) * (w/|z|), without a cubic-scale denominator.
+    minor = (ay / sum) * major;
+  } else {
+    minor = ay / (T(2) * w);
+  }
+  if (numext::is_exactly_zero(x)) minor = major;
+  const T imag_sign = Reciprocal ? -y : y;
+  return x < T(0) ? ComplexT(minor, numext::copysign(major, imag_sign))
+                  : ComplexT(major, numext::copysign(minor, imag_sign));
+}
 
-  const T abs_z = numext::hypot(x, y);
-  const T w = numext::sqrt(T(0.5) * (numext::abs(x) + abs_z));
-  const T woz = w / abs_z;
-  // Corner cases consistent with 1/sqrt(z) on gcc/clang.
-  return numext::is_exactly_zero(abs_z)               ? ComplexT(NumTraits<T>::infinity(), NumTraits<T>::quiet_NaN())
-         : ((numext::isinf)(x) || (numext::isinf)(y)) ? ComplexT(zero, zero)
-         : numext::is_exactly_zero(x)                 ? ComplexT(woz, y < zero ? woz : -woz)
-         : x > zero                                   ? ComplexT(woz, -y / (2 * w * abs_z))
-                    : ComplexT(numext::abs(y) / (2 * w * abs_z), y < zero ? woz : -woz);
+// Principal square root, with the branch cut selected by the sign of the imaginary part.
+template <typename ComplexT>
+EIGEN_DEVICE_FUNC constexpr ComplexT complex_sqrt(const ComplexT& z) {
+  return complex_sqrt_impl<ComplexT, false>(z);
+}
+
+template <typename ComplexT>
+EIGEN_DEVICE_FUNC constexpr ComplexT complex_rsqrt(const ComplexT& z) {
+  return complex_sqrt_impl<ComplexT, true>(z);
 }
 
 template <typename ComplexT>
diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h
index ca8f622..b4a51fc 100644
--- a/Eigen/src/Core/Matrix.h
+++ b/Eigen/src/Core/Matrix.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIX_H
 #define EIGEN_MATRIX_H
@@ -21,7 +22,7 @@
 struct traits<Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>> {
  private:
   constexpr static int size = internal::size_at_compile_time(Rows_, Cols_);
-  typedef typename find_best_packet<Scalar_, size>::type PacketScalar;
+  using PacketScalar = typename find_best_packet<Scalar_, size>::type;
   enum {
     row_major_bit = Options_ & RowMajor ? RowMajorBit : 0,
     is_dynamic_size_storage = MaxRows_ == Dynamic || MaxCols_ == Dynamic,
@@ -36,10 +37,10 @@
   };
 
  public:
-  typedef Scalar_ Scalar;
-  typedef Dense StorageKind;
-  typedef Eigen::Index StorageIndex;
-  typedef MatrixXpr XprKind;
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using StorageIndex = Eigen::Index;
+  using XprKind = MatrixXpr;
   enum {
     RowsAtCompileTime = Rows_,
     ColsAtCompileTime = Cols_,
@@ -146,7 +147,8 @@
  *
  * <i><b>ABI and storage layout</b></i>
  *
- * The table below summarizes the ABI of some possible Matrix instances which is fixed thorough the lifetime of Eigen 3.
+ * The table below summarizes the ABI of some possible Matrix instances which is fixed throughout the lifetime of Eigen
+ * 3.
  * <table  class="manual">
  * <tr><th>Matrix type</th><th>Equivalent C structure</th></tr>
  * <tr><td>\code Matrix<T,Dynamic,Dynamic> \endcode</td><td>\code
@@ -188,13 +190,13 @@
   /** \brief Base class typedef.
    * \sa PlainObjectBase
    */
-  typedef PlainObjectBase<Matrix> Base;
+  using Base = PlainObjectBase<Matrix>;
 
   enum { Options = Options_ };
 
   EIGEN_DENSE_PUBLIC_INTERFACE(Matrix)
 
-  typedef typename Base::PlainObject PlainObject;
+  using PlainObject = typename Base::PlainObject;
 
   using Base::base;
   using Base::coeffRef;
@@ -243,8 +245,7 @@
    * For fixed-size matrices, does nothing.
    *
    * For dynamic-size matrices, creates an empty matrix of size 0. Does not allocate any array. Such a matrix
-   * is called a null matrix. This constructor is the unique way to create null matrices: resizing
-   * a matrix to 0 is not supported.
+   * is called a null matrix. An existing matrix can also be turned into a null matrix by resizing it to 0.
    *
    * \sa resize(Index,Index)
    */
@@ -260,11 +261,11 @@
    */
   EIGEN_DEVICE_FUNC constexpr Matrix& operator=(Matrix&& other) noexcept(
       std::is_nothrow_move_assignable<Scalar>::value) {
-    Base::operator=(std::move(other));
+    this->m_storage = std::move(other.m_storage);
     return *this;
   }
 
-  /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients.
+  /** \brief Construct a row or column vector with fixed size from an arbitrary number of coefficients.
    *
    * \only_for_vectors
    *
@@ -274,8 +275,8 @@
    * constructor must match the fixed number of rows (resp. columns) of \c *this.
    *
    *
-   * Example: \include Matrix_variadic_ctor_cxx11.cpp
-   * Output: \verbinclude Matrix_variadic_ctor_cxx11.out
+   * Example: \include Matrix_variadic_ctor.cpp
+   * Output: \verbinclude Matrix_variadic_ctor.out
    *
    * \sa Matrix(const std::initializer_list<std::initializer_list<Scalar>>&)
    */
@@ -285,13 +286,12 @@
       : Base(a0, a1, a2, a3, args...) {}
 
   /** \brief Constructs a Matrix and initializes it from the coefficients given as initializer-lists grouped by row.
-   * \cpp11
    * \anchor matrix_initializer_list
    *
    * In the general case, the constructor takes a list of rows, each row being represented as a list of coefficients:
    *
-   * Example: \include Matrix_initializer_list_23_cxx11.cpp
-   * Output: \verbinclude Matrix_initializer_list_23_cxx11.out
+   * Example: \include Matrix_initializer_list_23.cpp
+   * Output: \verbinclude Matrix_initializer_list_23.out
    *
    * Each of the inner initializer lists must contain the exact same number of elements, otherwise an assertion is
    * triggered.
@@ -300,8 +300,8 @@
    * Therefore <code>VectorXd{{1,2,3,4,5}}</code> is legal and the more verbose syntax
    * <code>RowVectorXd{{1},{2},{3},{4},{5}}</code> can be avoided:
    *
-   * Example: \include Matrix_initializer_list_vector_cxx11.cpp
-   * Output: \verbinclude Matrix_initializer_list_vector_cxx11.out
+   * Example: \include Matrix_initializer_list_vector.cpp
+   * Output: \verbinclude Matrix_initializer_list_vector.out
    *
    * In the case of fixed-sized matrices, the initializer list sizes must exactly match the matrix sizes,
    * and implicit transposition is allowed for compile-time vectors only.
@@ -389,9 +389,12 @@
   EIGEN_DEVICE_FUNC constexpr Matrix(const Matrix&) = default;
 
   /** \brief Copy constructor for generic expressions.
+   * For coefficient-wise dense expressions, implicit conversion requires compatible scalar types.
+   * Use \c .cast<NewScalar>() to convert between scalar types.
    * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
    */
-  template <typename OtherDerived>
+  template <typename OtherDerived,
+            std::enable_if_t<internal::is_valid_dense_conversion<Scalar, OtherDerived>::value, int> = 0>
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived>& other)
       : Base(other.derived()) {}
 
@@ -435,14 +438,14 @@
  * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is
  * a fixed-size vector of 4 complex floats.
  *
- * With \cpp11, template alias are also defined for common sizes.
+ * Template alias are also defined for common sizes.
  * They follow the same pattern as above except that the scalar type suffix is replaced by a
  * template parameter, i.e.:
  *   - `MatrixSize<Type>` where `Size` can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size.
  *   - `MatrixXSize<Type>` and `MatrixSizeX<Type>` where `Size` can be \c 2,\c 3,\c 4 for hybrid dynamic/fixed matrices.
  *   - `VectorSize<Type>` and `RowVectorSize<Type>` for column and row vectors.
  *
- * With \cpp11, you can also use fully generic column and row vector types: `Vector<Type,Size>` and
+ * You can also use fully generic column and row vector types: `Vector<Type,Size>` and
  * `RowVector<Type,Size>`.
  *
  * \sa class Matrix
@@ -486,28 +489,28 @@
 #undef EIGEN_MAKE_TYPEDEFS
 #undef EIGEN_MAKE_FIXED_TYPEDEFS
 
-#define EIGEN_MAKE_TYPEDEFS(Size, SizeSuffix)                    \
-  /** \ingroup matrixtypedefs */                                 \
-  /** \brief \cpp11 `Size`&times;`Size` matrix of type `Type`.*/ \
-  template <typename Type>                                       \
-  using Matrix##SizeSuffix = Matrix<Type, Size, Size>;           \
-  /** \ingroup matrixtypedefs */                                 \
-  /** \brief \cpp11 `Size`&times;`1` vector of type `Type`.*/    \
-  template <typename Type>                                       \
-  using Vector##SizeSuffix = Matrix<Type, Size, 1>;              \
-  /** \ingroup matrixtypedefs */                                 \
-  /** \brief \cpp11 `1`&times;`Size` vector of type `Type`.*/    \
-  template <typename Type>                                       \
+#define EIGEN_MAKE_TYPEDEFS(Size, SizeSuffix)             \
+  /** \ingroup matrixtypedefs */                          \
+  /** \brief `Size`&times;`Size` matrix of type `Type`.*/ \
+  template <typename Type>                                \
+  using Matrix##SizeSuffix = Matrix<Type, Size, Size>;    \
+  /** \ingroup matrixtypedefs */                          \
+  /** \brief `Size`&times;`1` vector of type `Type`.*/    \
+  template <typename Type>                                \
+  using Vector##SizeSuffix = Matrix<Type, Size, 1>;       \
+  /** \ingroup matrixtypedefs */                          \
+  /** \brief `1`&times;`Size` vector of type `Type`.*/    \
+  template <typename Type>                                \
   using RowVector##SizeSuffix = Matrix<Type, 1, Size>;
 
-#define EIGEN_MAKE_FIXED_TYPEDEFS(Size)                              \
-  /** \ingroup matrixtypedefs */                                     \
-  /** \brief \cpp11 `Size`&times;`Dynamic` matrix of type `Type` */  \
-  template <typename Type>                                           \
-  using Matrix##Size##X = Matrix<Type, Size, Dynamic>;               \
-  /** \ingroup matrixtypedefs */                                     \
-  /** \brief \cpp11 `Dynamic`&times;`Size` matrix of type `Type`. */ \
-  template <typename Type>                                           \
+#define EIGEN_MAKE_FIXED_TYPEDEFS(Size)                       \
+  /** \ingroup matrixtypedefs */                              \
+  /** \brief `Size`&times;`Dynamic` matrix of type `Type` */  \
+  template <typename Type>                                    \
+  using Matrix##Size##X = Matrix<Type, Size, Dynamic>;        \
+  /** \ingroup matrixtypedefs */                              \
+  /** \brief `Dynamic`&times;`Size` matrix of type `Type`. */ \
+  template <typename Type>                                    \
   using Matrix##X##Size = Matrix<Type, Dynamic, Size>;
 
 EIGEN_MAKE_TYPEDEFS(2, 2)
@@ -519,12 +522,12 @@
 EIGEN_MAKE_FIXED_TYPEDEFS(4)
 
 /** \ingroup matrixtypedefs
- * \brief \cpp11 `Size`&times;`1` vector of type `Type`. */
+ * \brief `Size`&times;`1` vector of type `Type`. */
 template <typename Type, int Size>
 using Vector = Matrix<Type, Size, 1>;
 
 /** \ingroup matrixtypedefs
- * \brief \cpp11 `1`&times;`Size` vector of type `Type`. */
+ * \brief `1`&times;`Size` vector of type `Type`. */
 template <typename Type, int Size>
 using RowVector = Matrix<Type, 1, Size>;
 
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index ff1a2c2..8135342 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIXBASE_H
 #define EIGEN_MATRIXBASE_H
@@ -52,14 +53,14 @@
 class MatrixBase : public DenseBase<Derived> {
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef MatrixBase StorageBaseType;
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using StorageBaseType = MatrixBase;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using StorageIndex = typename internal::traits<Derived>::StorageIndex;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
-  typedef DenseBase<Derived> Base;
+  using Base = DenseBase<Derived>;
   using Base::ColsAtCompileTime;
   using Base::Flags;
   using Base::IsVectorAtCompileTime;
@@ -84,42 +85,41 @@
   using Base::operator*=;
   using Base::operator/=;
 
-  typedef typename Base::CoeffReturnType CoeffReturnType;
-  typedef typename Base::ConstTransposeReturnType ConstTransposeReturnType;
-  typedef typename Base::RowXpr RowXpr;
-  typedef typename Base::ColXpr ColXpr;
+  using CoeffReturnType = typename Base::CoeffReturnType;
+  using ConstTransposeReturnType = typename Base::ConstTransposeReturnType;
+  using RowXpr = typename Base::RowXpr;
+  using ColXpr = typename Base::ColXpr;
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   /** type of the equivalent square matrix */
-  typedef Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime),
-                 internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)>
-      SquareMatrixType;
+  using SquareMatrixType = Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime),
+                                  internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)>;
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
   /** \returns the size of the main diagonal, which is min(rows(),cols()).
    * \sa rows(), cols(), SizeAtCompileTime. */
   EIGEN_DEVICE_FUNC constexpr Index diagonalSize() const { return (numext::mini)(rows(), cols()); }
 
-  typedef typename Base::PlainObject PlainObject;
+  using PlainObject = typename Base::PlainObject;
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   /** \internal Represents a matrix with all coefficients equal to one another*/
-  typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject> ConstantReturnType;
+  using ConstantReturnType = CwiseNullaryOp<internal::scalar_constant_op<Scalar>, PlainObject>;
   /** \internal the return type of MatrixBase::adjoint() */
-  typedef std::conditional_t<NumTraits<Scalar>::IsComplex,
-                             CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
-                             ConstTransposeReturnType>
-      AdjointReturnType;
+  using AdjointReturnType =
+      std::conditional_t<NumTraits<Scalar>::IsComplex,
+                         CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, ConstTransposeReturnType>,
+                         ConstTransposeReturnType>;
   /** \internal Return type of eigenvalues() */
-  typedef Matrix<internal::make_complex_t<Scalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor>
-      EigenvaluesReturnType;
+  using EigenvaluesReturnType =
+      Matrix<internal::make_complex_t<Scalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor>;
   /** \internal the return type of identity */
-  typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>, PlainObject> IdentityReturnType;
+  using IdentityReturnType = CwiseNullaryOp<internal::scalar_identity_op<Scalar>, PlainObject>;
   /** \internal the return type of unit vectors */
-  typedef Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
-                internal::traits<Derived>::RowsAtCompileTime, internal::traits<Derived>::ColsAtCompileTime>
-      BasisReturnType;
+  using BasisReturnType =
+      Block<const CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>,
+            internal::traits<Derived>::RowsAtCompileTime, internal::traits<Derived>::ColsAtCompileTime>;
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
 #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
@@ -197,10 +197,10 @@
   EIGEN_DEVICE_FUNC constexpr const AdjointReturnType adjoint() const;
   EIGEN_DEVICE_FUNC void adjointInPlace();
 
-  typedef Diagonal<Derived> DiagonalReturnType;
+  using DiagonalReturnType = Diagonal<Derived>;
   EIGEN_DEVICE_FUNC constexpr DiagonalReturnType diagonal();
 
-  typedef Diagonal<const Derived> ConstDiagonalReturnType;
+  using ConstDiagonalReturnType = Diagonal<const Derived>;
   EIGEN_DEVICE_FUNC constexpr const ConstDiagonalReturnType diagonal() const;
 
   template <int Index>
@@ -214,11 +214,11 @@
 
   template <unsigned int Mode>
   struct TriangularViewReturnType {
-    typedef TriangularView<Derived, Mode> Type;
+    using Type = TriangularView<Derived, Mode>;
   };
   template <unsigned int Mode>
   struct ConstTriangularViewReturnType {
-    typedef const TriangularView<const Derived, Mode> Type;
+    using Type = const TriangularView<const Derived, Mode>;
   };
 
   template <unsigned int Mode>
@@ -228,11 +228,11 @@
 
   template <unsigned int UpLo>
   struct SelfAdjointViewReturnType {
-    typedef SelfAdjointView<Derived, UpLo> Type;
+    using Type = SelfAdjointView<Derived, UpLo>;
   };
   template <unsigned int UpLo>
   struct ConstSelfAdjointViewReturnType {
-    typedef const SelfAdjointView<const Derived, UpLo> Type;
+    using Type = const SelfAdjointView<const Derived, UpLo>;
   };
 
   template <unsigned int UpLo>
@@ -365,6 +365,7 @@
 
   inline LLT<PlainObject> llt() const;
   inline LDLT<PlainObject> ldlt() const;
+  inline BunchKaufman<PlainObject> bunchKaufman() const;
 
   /////////// QR module ///////////
 
@@ -374,7 +375,11 @@
   template <typename PermutationIndex = DefaultPermutationIndex>
   inline FullPivHouseholderQR<PlainObject, PermutationIndex> fullPivHouseholderQr() const;
   template <typename PermutationIndex = DefaultPermutationIndex>
+  inline RandColPivHouseholderQR<PlainObject, PermutationIndex> randColPivHouseholderQr() const;
+  template <typename PermutationIndex = DefaultPermutationIndex>
   inline CompleteOrthogonalDecomposition<PlainObject, PermutationIndex> completeOrthogonalDecomposition() const;
+  template <typename PermutationIndex = DefaultPermutationIndex>
+  inline RandCompleteOrthogonalDecomposition<PlainObject, PermutationIndex> randCompleteOrthogonalDecomposition() const;
 
   /////////// Eigenvalues module ///////////
 
@@ -418,14 +423,14 @@
         : ColsAtCompileTime == 1 ? Vertical
                                  : Horizontal
   };
-  typedef Homogeneous<Derived, HomogeneousReturnTypeDirection> HomogeneousReturnType;
+  using HomogeneousReturnType = Homogeneous<Derived, HomogeneousReturnTypeDirection>;
   EIGEN_DEVICE_FUNC inline HomogeneousReturnType homogeneous() const;
 
   enum { SizeMinusOne = SizeAtCompileTime == Dynamic ? Dynamic : SizeAtCompileTime - 1 };
-  typedef Block<const Derived, internal::traits<Derived>::ColsAtCompileTime == 1 ? SizeMinusOne : 1,
-                internal::traits<Derived>::ColsAtCompileTime == 1 ? 1 : SizeMinusOne>
-      ConstStartMinusOne;
-  typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne, Scalar, quotient) HNormalizedReturnType;
+  using ConstStartMinusOne = Block<const Derived, internal::traits<Derived>::ColsAtCompileTime == 1 ? SizeMinusOne : 1,
+                                   internal::traits<Derived>::ColsAtCompileTime == 1 ? 1 : SizeMinusOne>;
+  using HNormalizedReturnType = EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(ConstStartMinusOne, Scalar,
+                                                                       internal::scalar_quotient_op);
   EIGEN_DEVICE_FUNC inline const HNormalizedReturnType hnormalized() const;
 
   ////////// Householder module ///////////
@@ -457,25 +462,25 @@
 
   ///////// MatrixFunctions module /////////
 
-  typedef typename internal::stem_function<Scalar>::type StemFunction;
-#define EIGEN_MATRIX_FUNCTION(ReturnType, Name, Description)                                                        \
-  /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a            \
-   * href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the \
-   * coefficient-wise Description use ArrayBase::##Name . */                                                        \
+  using StemFunction = typename internal::stem_function<Scalar>::type;
+#define EIGEN_MATRIX_FUNCTION(ReturnType, Name, Description)                                                \
+  /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a    \
+   * href="contrib/group__MatrixFunctions__Module.html"> contrib MatrixFunctions module</a>. To compute the \
+   * coefficient-wise Description use ArrayBase::##Name . */                                                \
   const ReturnType<Derived> Name() const;
-#define EIGEN_MATRIX_FUNCTION_1(ReturnType, Name, Description, Argument)                                            \
-  /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a            \
-   * href="unsupported/group__MatrixFunctions__Module.html"> unsupported MatrixFunctions module</a>. To compute the \
-   * coefficient-wise Description use ArrayBase::##Name . */                                                        \
+#define EIGEN_MATRIX_FUNCTION_1(ReturnType, Name, Description, Argument)                                    \
+  /** \returns an expression of the matrix Description of \c *this. \brief This function requires the <a    \
+   * href="contrib/group__MatrixFunctions__Module.html"> contrib MatrixFunctions module</a>. To compute the \
+   * coefficient-wise Description use ArrayBase::##Name . */                                                \
   const ReturnType<Derived> Name(Argument) const;
 
   EIGEN_MATRIX_FUNCTION(MatrixExponentialReturnValue, exp, exponential)
-  /** \brief Helper function for the <a href="unsupported/group__MatrixFunctions__Module.html"> unsupported
+  /** \brief Helper function for the <a href="contrib/group__MatrixFunctions__Module.html"> contrib
    * MatrixFunctions module</a>.*/
   const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const;
   EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cosh, hyperbolic cosine)
   EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, sinh, hyperbolic sine)
-  EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, atanh, inverse hyperbolic cosine)
+  EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, atanh, inverse hyperbolic tangent)
   EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, acosh, inverse hyperbolic cosine)
   EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, asinh, inverse hyperbolic sine)
   EIGEN_MATRIX_FUNCTION(MatrixFunctionReturnValue, cos, cosine)
@@ -530,7 +535,8 @@
   return derived();
 }
 
-/** replaces \c *this by \c *this * \a other. It is equivalent to MatrixBase::operator*=().
+/** Calling \c A.applyOnTheRight(B) replaces \c A by the matrix product \f$ A B \f$.
+ * It is equivalent to MatrixBase::operator*=().
  *
  * Example: \include MatrixBase_applyOnTheRight.cpp
  * Output: \verbinclude MatrixBase_applyOnTheRight.out
@@ -541,7 +547,7 @@
   other.derived().applyThisOnTheRight(derived());
 }
 
-/** replaces \c *this by \a other * \c *this.
+/** Calling \c A.applyOnTheLeft(B) replaces \c A by the matrix product \f$ B A \f$.
  *
  * Example: \include MatrixBase_applyOnTheLeft.cpp
  * Output: \verbinclude MatrixBase_applyOnTheLeft.out
diff --git a/Eigen/src/Core/MatrixNorms.h b/Eigen/src/Core/MatrixNorms.h
new file mode 100644
index 0000000..b68a75c
--- /dev/null
+++ b/Eigen/src/Core/MatrixNorms.h
@@ -0,0 +1,372 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_NORMS_H
+#define EIGEN_MATRIX_NORMS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+// *_abs_sum sums magnitudes of stored coefficients; *_l1_norm takes the maximum
+// absolute column sum of the represented matrix, including any implicit entries.
+
+// Sum |a_ij| over i <= j + ExtraDiagonals (Upper), or j <= i + ExtraDiagonals (Lower).
+template <unsigned int UpLo, int ExtraDiagonals, typename Derived>
+EIGEN_DEVICE_FUNC typename Derived::RealScalar triangular_band_abs_sum(const MatrixBase<Derived>& matrix) {
+  static_assert(UpLo == Upper || UpLo == Lower, "UpLo must be Upper or Lower");
+  static_assert(ExtraDiagonals == 0 || ExtraDiagonals == 1, "Expected a triangular or Hessenberg envelope");
+  using RealScalar = typename Derived::RealScalar;
+  RealScalar result(0);
+  if (matrix.rows() == 0 || matrix.cols() == 0) return result;
+
+  constexpr bool Leading = (UpLo == Upper) != bool(Derived::IsRowMajor);
+  const Index inner = matrix.innerSize();
+  // Inner-vector slices preserve packet access for contiguous storage and also work for strided expressions.
+  for (Index j = 0; j < matrix.outerSize(); ++j) {
+    const Index start = Leading ? Index(0) : numext::mini(inner, numext::maxi(Index(0), j - ExtraDiagonals));
+    const Index end = Leading ? numext::mini(inner, j + ExtraDiagonals + 1) : inner;
+    result += matrix.derived().innerVector(j).segment(start, end - start).template lpNorm<1>();
+  }
+  return result;
+}
+
+// Coefficient-wise l1 norm of the stored upper/lower triangle, including the diagonal.
+// Entries outside the selected triangle are never read; rectangular and empty expressions are supported.
+template <unsigned int UpLo, typename Derived>
+EIGEN_DEVICE_FUNC typename Derived::RealScalar triangular_abs_sum(const MatrixBase<Derived>& matrix) {
+  return triangular_band_abs_sum<UpLo, 0>(matrix);
+}
+
+// Coefficient-wise l1 norm of the upper/lower Hessenberg envelope, including its one extra off-diagonal.
+template <unsigned int UpLo, typename Derived>
+EIGEN_DEVICE_FUNC typename Derived::RealScalar hessenberg_abs_sum(const MatrixBase<Derived>& matrix) {
+  return triangular_band_abs_sum<UpLo, 1>(matrix);
+}
+
+// Column step of the self-adjoint 1-norm, on two columns sharing a range of rows: sums[i] +=
+// |m(i, j0)| + |m(i, j1)|, and each column's own sum of those rows goes to sums[j0] and sums[j1].
+// Walking two columns at once halves the traffic on sums, and one packet pass does everything, so
+// short columns pay no per-expression setup.
+//
+// Real scalars use pabs. Complex ones have no packet abs, so |z| = sqrt(re^2 + im^2) is computed
+// on the real lanes of the complex packet. That leaves |z|^2 in both lanes of each slot, so one
+// square root serves both columns: even lanes from j0 and odd lanes from j1 give |u0| |v0| |u1|
+// |v1| ..., whose sum with its flip is the update of sums, and whose reduction as a complex packet
+// is (sum |u|, sum |v|). The accumulator has the matrix's scalar type and only its real parts are
+// read, so what lands in the imaginary lanes is harmless. Squaring overflows above sqrt(max) and
+// loses precision below sqrt(min), so the pass also records the largest component it has seen and
+// the caller recomputes the norm through numext::abs when that is out of range. The record is
+// exact and the range test finite, so neither depends on infinities surviving fast-math.
+template <typename Scalar_>
+struct selfadjoint_l1norm_real_lanes {
+  using Scalar = Scalar_;
+  using Real = Scalar_;
+  using Packet = typename packet_traits<Scalar>::type;
+  using RPacket = Packet;
+  static constexpr Index PacketSize = unpacket_traits<Packet>::size;
+  // Up to this size the per-column form (mirrored term read as a row) beats the column pass, whose
+  // accumulator costs more to set up than these columns cost to read.
+  static constexpr Index PerColumnUpTo = 4;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RPacket lanes(const Packet& p) { return p; }
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real abs(const Scalar& x) { return numext::abs(x); }
+  // Nothing to record: pabs is exact.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real component(const Scalar&) { return Real(0); }
+  static EIGEN_DEVICE_FUNC bool inRange(Real, Index) { return true; }
+
+  // The running sums of a pass over two columns.
+  struct Pass {
+    RPacket acc0 = pzero(RPacket());
+    RPacket acc1 = pzero(RPacket());
+    template <typename SumsEvaluator>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void step(const RPacket& u, const RPacket& v, SumsEvaluator& s, Index i) {
+      RPacket a = pabs(u);
+      RPacket b = pabs(v);
+      acc0 = padd(acc0, a);
+      acc1 = padd(acc1, b);
+      s.template writePacket<Unaligned>(i, padd(s.template packet<Unaligned, Packet>(i), padd(a, b)));
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real sum0() const { return predux(acc0); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real sum1() const { return predux(acc1); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real peak() const { return Real(0); }
+  };
+};
+
+template <typename T>
+struct selfadjoint_l1norm_complex_lanes {
+  using Scalar = std::complex<T>;
+  using Real = T;
+  using Packet = typename packet_traits<Scalar>::type;
+  using RPacket = typename unpacket_traits<Packet>::as_real;
+  static constexpr Index PacketSize = unpacket_traits<Packet>::size;
+  static constexpr Index PerColumnUpTo = 0;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RPacket lanes(const Packet& p) { return p.v; }
+  // Same formula as the packets, for the diagonal and the tails: hypot costs more than the packets
+  // spend on the rest of a short column.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real abs(const Scalar& z) { return numext::sqrt(numext::abs2(z)); }
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real component(const Scalar& z) {
+    return numext::maxi(numext::abs(numext::real(z)), numext::abs(numext::imag(z)));
+  }
+  // Components this large overflow when squared, and below the lower bound the squares lose
+  // precision the sum of n of them cannot hide.
+  static EIGEN_DEVICE_FUNC bool inRange(Real peak, Index n) {
+    Real tiny = Real(n) * numext::sqrt((std::numeric_limits<Real>::min)()) / NumTraits<Real>::epsilon();
+    Real huge = numext::sqrt(NumTraits<Real>::highest()) / Real(2);
+    return peak > tiny && peak < huge;
+  }
+
+  struct Pass {
+    RPacket acc = pzero(RPacket());    // |u| in the even lanes, |v| in the odd ones
+    RPacket peak_ = pzero(RPacket());  // the largest component seen
+    template <typename SumsEvaluator>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void step(const RPacket& u, const RPacket& v, SumsEvaluator& s, Index i) {
+      peak_ = pmax(peak_, pmax(pabs(u), pabs(v)));
+      RPacket r = psqrt(pselect(peven_mask(u), abs2(u), abs2(v)));  // |u0| |v0| |u1| |v1| ...
+      acc = padd(acc, r);
+      s.template writePacket<Unaligned>(i,
+                                        Packet(padd(lanes(s.template packet<Unaligned, Packet>(i)), padd(r, flip(r)))));
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real sum0() const { return numext::real(predux(Packet(acc))); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real sum1() const { return numext::imag(predux(Packet(acc))); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real peak() const { return predux_max(peak_); }
+  };
+
+ private:
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RPacket flip(const RPacket& r) { return pcplxflip(Packet(r)).v; }
+  // |z|^2 in both lanes of its slot.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RPacket abs2(const RPacket& v) {
+    RPacket s = pmul(v, v);
+    return padd(s, flip(s));
+  }
+};
+
+// The pass over two columns: packets over the shared rows, coefficients for the tail. An instance
+// remembers the largest component it has seen, for inRange().
+template <typename Lanes>
+struct selfadjoint_l1norm_packet_impl : Lanes {
+  using Lanes::PacketSize;
+  using typename Lanes::Packet;
+  using typename Lanes::Real;
+  using typename Lanes::RPacket;
+  using typename Lanes::Scalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real abs(const Scalar& x) {
+    m_peak = numext::maxi(m_peak, Lanes::component(x));
+    return Lanes::abs(x);
+  }
+  EIGEN_DEVICE_FUNC bool inRange(Index n) const { return Lanes::inRange(m_peak, n); }
+
+  template <typename SumsDerived, typename Derived>
+  EIGEN_DEVICE_FUNC void accumulate(DenseBase<SumsDerived>& sums, const DenseBase<Derived>& m, Index j0, Index j1,
+                                    Index begin, Index end) {
+    accumulateCast(sums, j0, j1, begin, m.col(j0).segment(begin, end - begin).template cast<Scalar>(),
+                   m.col(j1).segment(begin, end - begin).template cast<Scalar>());
+  }
+
+ private:
+  Real m_peak = Real(0);
+
+  template <typename SumsDerived, typename Derived0, typename Derived1>
+  EIGEN_DEVICE_FUNC void accumulateCast(DenseBase<SumsDerived>& sums, Index j0, Index j1, Index begin,
+                                        const DenseBase<Derived0>& x0, const DenseBase<Derived1>& x1) {
+    using SumsEvaluator = evaluator<SumsDerived>;
+    using Evaluator0 = evaluator<Derived0>;
+    using Evaluator1 = evaluator<Derived1>;
+    constexpr int Needed = PacketAccessBit | LinearAccessBit;
+    constexpr bool Vectorize = (SumsEvaluator::Flags & Needed) == Needed && (Evaluator0::Flags & Needed) == Needed &&
+                               (Evaluator1::Flags & Needed) == Needed;
+    SumsEvaluator s(sums.derived());
+    accumulate(s, j0, j1, begin, Evaluator0(x0.derived()), Evaluator1(x1.derived()), x0.size(),
+               bool_constant<Vectorize>());
+  }
+  template <typename Evaluator>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RPacket load(const Evaluator& x, Index i) {
+    return Lanes::lanes(x.template packet<Unaligned, Packet>(i));
+  }
+  template <typename SumsEvaluator, typename Evaluator0, typename Evaluator1>
+  EIGEN_DEVICE_FUNC void accumulate(SumsEvaluator& s, Index j0, Index j1, Index begin, const Evaluator0& x0,
+                                    const Evaluator1& x1, Index from, Index to) {
+    Real sum0 = Real(0);
+    Real sum1 = Real(0);
+    for (Index i = from; i < to; ++i) {
+      Real a = abs(x0.coeff(i));
+      Real b = abs(x1.coeff(i));
+      s.coeffRef(begin + i) += a + b;
+      sum0 += a;
+      sum1 += b;
+    }
+    s.coeffRef(j0) += sum0;
+    s.coeffRef(j1) += sum1;
+  }
+  template <typename SumsEvaluator, typename Evaluator0, typename Evaluator1>
+  EIGEN_DEVICE_FUNC void accumulate(SumsEvaluator& s, Index j0, Index j1, Index begin, const Evaluator0& x0,
+                                    const Evaluator1& x1, Index n, std::false_type) {
+    accumulate(s, j0, j1, begin, x0, x1, Index(0), n);
+  }
+  template <typename SumsEvaluator, typename Evaluator0, typename Evaluator1>
+  EIGEN_DEVICE_FUNC void accumulate(SumsEvaluator& s, Index j0, Index j1, Index begin, const Evaluator0& x0,
+                                    const Evaluator1& x1, Index n, std::true_type) {
+    if (n < PacketSize) return accumulate(s, j0, j1, begin, x0, x1, Index(0), n);
+    typename Lanes::Pass pass;
+    Index i = 0;
+    for (; i + PacketSize <= n; i += PacketSize) pass.step(load(x0, i), load(x1, i), s, begin + i);
+    accumulate(s, j0, j1, begin, x0, x1, i, n);
+    s.coeffRef(j0) += pass.sum0();
+    s.coeffRef(j1) += pass.sum1();
+    m_peak = numext::maxi(m_peak, pass.peak());
+  }
+};
+
+// Coefficient fallback: custom complex types, or complex packets without a plain real view.
+template <typename Scalar_, typename Enable = void>
+struct selfadjoint_l1norm_impl {
+  using Scalar = Scalar_;
+  using Real = typename NumTraits<Scalar>::Real;
+  static constexpr Index PerColumnUpTo = 16;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Real abs(const Scalar& x) const { return numext::abs(x); }
+  EIGEN_DEVICE_FUNC bool inRange(Index) const { return true; }
+  template <typename SumsDerived, typename Derived>
+  EIGEN_DEVICE_FUNC void accumulate(DenseBase<SumsDerived>& sums, const DenseBase<Derived>& m, Index j0, Index j1,
+                                    Index begin, Index end) const {
+    Real sum0 = Real(0);
+    Real sum1 = Real(0);
+    for (Index i = begin; i < end; ++i) {
+      Real a = numext::abs(m.coeff(i, j0));
+      Real b = numext::abs(m.coeff(i, j1));
+      sums.coeffRef(i) += Scalar(a + b);
+      sum0 += a;
+      sum1 += b;
+    }
+    sums.coeffRef(j0) += Scalar(sum0);
+    sums.coeffRef(j1) += Scalar(sum1);
+  }
+};
+// half and bfloat16 accumulate in float, as stableNorm does.
+template <typename Scalar>
+struct selfadjoint_l1norm_impl<Scalar, std::enable_if_t<!NumTraits<Scalar>::IsComplex>>
+    : selfadjoint_l1norm_packet_impl<selfadjoint_l1norm_real_lanes<typename stable_norm_accumulator<Scalar>::type>> {};
+// The real view must lay the components out one per lane: Z13 stores four floats in two double
+// packets, which the lane masks do not describe.
+template <typename Packet, typename Enable = void>
+struct selfadjoint_l1norm_plain_real_view : std::false_type {};
+template <typename Packet>
+struct selfadjoint_l1norm_plain_real_view<Packet, void_t<typename unpacket_traits<Packet>::as_real>>
+    : bool_constant<sizeof(typename unpacket_traits<Packet>::as_real) ==
+                    unpacket_traits<Packet>::size * sizeof(typename unpacket_traits<Packet>::type)> {};
+template <typename T>
+struct selfadjoint_l1norm_impl<
+    std::complex<T>,
+    std::enable_if_t<selfadjoint_l1norm_plain_real_view<typename packet_traits<std::complex<T>>::type>::value>>
+    : selfadjoint_l1norm_packet_impl<selfadjoint_l1norm_complex_lanes<T>> {};
+
+template <typename MatrixType, unsigned int UpLo>
+class selfadjoint_l1norm {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+
+ public:
+  EIGEN_DEVICE_FUNC explicit selfadjoint_l1norm(const MatrixType& matrix) : m_matrix(matrix) {}
+
+  EIGEN_DEVICE_FUNC RealScalar run() const {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+    // No per-thread accumulator on a device.
+    return l1NormPerColumn();
+#else
+    if (m_matrix.rows() <= L1NormImpl::PerColumnUpTo) return l1NormPerColumn();
+    // The stored triangle of a row-major matrix is the complementary triangle of its column-major
+    // transpose, which has the same norm.
+    EIGEN_IF_CONSTEXPR (bool(MatrixType::IsRowMajor)) {
+      return l1NormStreaming<(UpLo == Lower ? Upper : Lower)>(m_matrix.transpose());
+    } else {
+      return l1NormStreaming<UpLo>(m_matrix);
+    }
+#endif
+  }
+
+ private:
+  using L1NormImpl = internal::selfadjoint_l1norm_impl<Scalar>;
+  // float for half and bfloat16, Scalar otherwise.
+  using L1NormScalar = typename L1NormImpl::Scalar;
+  using L1NormAccumulator = typename L1NormImpl::Real;
+
+  // Each column is read once, top to bottom, two at a time: |a_ij| goes to column j's sum and, as
+  // the mirrored a_ji, to sums[i]. Lower walks the columns forward and Upper backward so that
+  // sums[j] is complete when column j is reached. Of a pair (j0, j1) only j0's element in row j1
+  // lies outside the rows the two share.
+  template <int Mode, typename Mat>
+  RealScalar l1NormStreaming(const Mat& m) const {
+    const Index n = m.rows();
+    // The accumulator lives in the object for bounded sizes and on the stack otherwise, so that
+    // neither fixed-size nor preallocated dynamic-size decompositions allocate.
+    internal::gemv_static_vector_if<L1NormScalar, Mat::RowsAtCompileTime, Mat::MaxRowsAtCompileTime, true> static_sums;
+    ei_declare_aligned_stack_constructed_variable(L1NormScalar, sums_data, n, static_sums.data());
+    Map<Matrix<L1NormScalar, Dynamic, 1>> sums(sums_data, n);
+    sums.setZero();
+    L1NormImpl impl;
+    L1NormAccumulator norm = L1NormAccumulator(0);
+    Index k = 0;
+    for (; k + 1 < n; k += 2) {
+      Index j0 = Mode == Lower ? k : n - 1 - k;
+      Index j1 = Mode == Lower ? j0 + 1 : j0 - 1;
+      Index rowBegin = Mode == Lower ? j1 + 1 : 0;
+      Index rowEnd = Mode == Lower ? n : j1;
+      impl.accumulate(sums, m, j0, j1, rowBegin, rowEnd);
+      // The element of j0 in row j1 lies outside the shared rows: it counts for both columns.
+      L1NormAccumulator boundary = impl.abs(m.coeff(j1, j0));
+      // Totals are materialized so that maxi compares two accumulators (an integer sum promotes,
+      // an autodiff sum is an expression).
+      L1NormAccumulator col0 = numext::real(sums.coeff(j0)) + impl.abs(m.coeff(j0, j0)) + boundary;
+      L1NormAccumulator col1 = numext::real(sums.coeff(j1)) + impl.abs(m.coeff(j1, j1)) + boundary;
+      norm = numext::maxi(norm, col0);
+      norm = numext::maxi(norm, col1);
+    }
+    if (k < n) {
+      Index j = Mode == Lower ? k : 0;
+      L1NormAccumulator col = numext::real(sums.coeff(j)) + impl.abs(m.coeff(j, j));
+      norm = numext::maxi(norm, col);
+    }
+    return impl.inRange(n) ? RealScalar(norm) : l1NormPerColumn();
+  }
+
+  // One column at a time, the mirrored term read as a row; no workspace.
+  EIGEN_DEVICE_FUNC RealScalar l1NormPerColumn() const {
+    L1NormAccumulator norm = L1NormAccumulator(0);
+    const Index n = m_matrix.rows();
+    for (Index col = 0; col < n; ++col) {
+      L1NormAccumulator abs_col_sum;
+      EIGEN_IF_CONSTEXPR (UpLo == Lower) {
+        abs_col_sum = m_matrix.col(col).tail(n - col).template cast<L1NormScalar>().template lpNorm<1>() +
+                      m_matrix.row(col).head(col).template cast<L1NormScalar>().template lpNorm<1>();
+      } else {
+        abs_col_sum = m_matrix.col(col).head(col).template cast<L1NormScalar>().template lpNorm<1>() +
+                      m_matrix.row(col).tail(n - col).template cast<L1NormScalar>().template lpNorm<1>();
+      }
+      norm = numext::maxi(norm, abs_col_sum);
+    }
+    return RealScalar(norm);
+  }
+
+  const MatrixType& m_matrix;
+};
+
+// Matrix 1-norm of the implicit full self-adjoint matrix; only the stored triangle is read.
+template <unsigned int UpLo, typename Derived>
+EIGEN_DEVICE_FUNC typename Derived::RealScalar selfadjoint_l1_norm(const MatrixBase<Derived>& matrix) {
+  static_assert(UpLo == Upper || UpLo == Lower, "UpLo must be Upper or Lower");
+  eigen_assert(matrix.rows() == matrix.cols());
+  return selfadjoint_l1norm<Derived, UpLo>(matrix.derived()).run();
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_MATRIX_NORMS_H
diff --git a/Eigen/src/Core/NestByValue.h b/Eigen/src/Core/NestByValue.h
index f18559b..0dd1af6 100644
--- a/Eigen/src/Core/NestByValue.h
+++ b/Eigen/src/Core/NestByValue.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_NESTBYVALUE_H
 #define EIGEN_NESTBYVALUE_H
@@ -38,8 +39,8 @@
 template <typename ExpressionType>
 class NestByValue : public internal::dense_xpr_base<NestByValue<ExpressionType> >::type {
  public:
-  typedef typename internal::dense_xpr_base<NestByValue>::type Base;
-  static constexpr bool HasDirectAccess = internal::has_direct_access<ExpressionType>::ret;
+  using Base = typename internal::dense_xpr_base<NestByValue>::type;
+  static constexpr bool HasDirectAccess = internal::has_direct_access<ExpressionType>::value;
 
   EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue)
 
@@ -77,10 +78,10 @@
 
 namespace internal {
 
-// Evaluator of Solve -> eval into a temporary
+// Evaluator of NestByValue<> -> forwards to the evaluator of the nested expression
 template <typename ArgType>
 struct evaluator<NestByValue<ArgType> > : public evaluator<ArgType> {
-  typedef evaluator<ArgType> Base;
+  using Base = evaluator<ArgType>;
 
   EIGEN_DEVICE_FUNC constexpr explicit evaluator(const NestByValue<ArgType>& xpr) : Base(xpr.nestedExpression()) {}
 };
diff --git a/Eigen/src/Core/NoAlias.h b/Eigen/src/Core/NoAlias.h
index 6a88201..da0ea45 100644
--- a/Eigen/src/Core/NoAlias.h
+++ b/Eigen/src/Core/NoAlias.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_NOALIAS_H
 #define EIGEN_NOALIAS_H
@@ -24,7 +25,7 @@
  *
  * This class represents an expression with special assignment operators
  * assuming no aliasing between the target expression and the source expression.
- * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression.
+ * More precisely it allows to bypass the EvalBeforeAssignBit flag of the source expression.
  * It is the return type of MatrixBase::noalias()
  * and most of the time this is the only way it is used.
  *
@@ -33,7 +34,7 @@
 template <typename ExpressionType, template <typename> class StorageBase>
 class NoAlias {
  public:
-  typedef typename ExpressionType::Scalar Scalar;
+  using Scalar = typename ExpressionType::Scalar;
 
   EIGEN_DEVICE_FUNC constexpr explicit NoAlias(ExpressionType& expression) : m_expression(expression) {}
 
diff --git a/Eigen/src/Core/NumTraits.h b/Eigen/src/Core/NumTraits.h
index 2bb1eed..158e4f2 100644
--- a/Eigen/src/Core/NumTraits.h
+++ b/Eigen/src/Core/NumTraits.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_NUMTRAITS_H
 #define EIGEN_NUMTRAITS_H
@@ -31,7 +32,7 @@
   EIGEN_DEVICE_FUNC constexpr static int run() {
     using std::ceil;
     using std::log2;
-    typedef typename NumTraits<T>::Real Real;
+    using Real = typename NumTraits<T>::Real;
     return int(ceil(-log2(NumTraits<Real>::epsilon())));
   }
 };
@@ -56,7 +57,7 @@
   EIGEN_DEVICE_FUNC constexpr static int run() {
     using std::floor;
     using std::log10;
-    typedef typename NumTraits<T>::Real Real;
+    using Real = typename NumTraits<T>::Real;
     return int(floor((internal::default_digits_impl<Real>::run() - 1) * log10(2)));
   }
 };
@@ -81,7 +82,7 @@
   EIGEN_DEVICE_FUNC constexpr static int run() {
     using std::ceil;
     using std::log10;
-    typedef typename NumTraits<T>::Real Real;
+    using Real = typename NumTraits<T>::Real;
     return int(ceil(internal::default_digits_impl<Real>::run() * log10(2) + 1));
   }
 };
@@ -155,7 +156,7 @@
  *     this means, just use \a T here.
  * \li An enum value \c IsComplex. It is equal to 1 if \a T is a \c std::complex type, and to 0 otherwise.
  * \li An enum value \c IsInteger. It is equal to \c 1 if \a T is an integer type such as \c int, and to \c 0 otherwise.
- * \li Enum values \c ReadCost, \c AddCost and \c MulCost representing a rough estimate of the number of CPU cycles needed to by
+ * \li Enum values \c ReadCost, \c AddCost and \c MulCost representing a rough estimate of the number of CPU cycles needed by
  *     move / add / mul instructions respectively, assuming the data is already stored in CPU registers. Stay vague here.
  *     No need to do architecture-specific stuff. If you don't know what this means, just use \c Eigen::HugeCost.
  * \li An enum value \c IsSigned. It is equal to \c 1 if \a T is a signed type and to 0 if \a T is unsigned.
@@ -197,10 +198,10 @@
     MulCost = 1
   };
 
-  typedef T Real;
-  typedef std::conditional_t<IsInteger, std::conditional_t<sizeof(T) <= 2, float, double>, T> NonInteger;
-  typedef T Nested;
-  typedef T Literal;
+  using Real = T;
+  using NonInteger = std::conditional_t<IsInteger, std::conditional_t<sizeof(T) <= 2, float, double>, T>;
+  using Nested = T;
+  using Literal = T;
 
   EIGEN_DEVICE_FUNC constexpr static Real epsilon() { return numext::numeric_limits<T>::epsilon(); }
 
@@ -259,8 +260,8 @@
 
 template <typename Real_>
 struct NumTraits<std::complex<Real_> > : GenericNumTraits<std::complex<Real_> > {
-  typedef Real_ Real;
-  typedef typename NumTraits<Real_>::Literal Literal;
+  using Real = Real_;
+  using Literal = typename NumTraits<Real_>::Literal;
   enum {
     IsComplex = 1,
     IsSigned = NumTraits<Real_>::IsSigned,
@@ -278,13 +279,13 @@
 
 template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
 struct NumTraits<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > {
-  typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> ArrayType;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
-  typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
-  typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> NonInteger;
-  typedef ArrayType& Nested;
-  typedef typename NumTraits<Scalar>::Literal Literal;
+  using ArrayType = Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Real = Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols>;
+  using NonIntegerScalar = typename NumTraits<Scalar>::NonInteger;
+  using NonInteger = Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols>;
+  using Nested = ArrayType&;
+  using Literal = typename NumTraits<Scalar>::Literal;
 
   enum {
     IsComplex = NumTraits<Scalar>::IsComplex,
diff --git a/Eigen/src/Core/PartialReduxEvaluator.h b/Eigen/src/Core/PartialReduxEvaluator.h
index 1f638f9..a056a21 100644
--- a/Eigen/src/Core/PartialReduxEvaluator.h
+++ b/Eigen/src/Core/PartialReduxEvaluator.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARTIALREDUX_H
 #define EIGEN_PARTIALREDUX_H
@@ -35,19 +36,19 @@
  * on the inner unrolling.
  *
  * For the unrolling, we can reuse "internal::redux_vec_unroller" from Redux.h,
- * but be need to be careful to specify correct increment.
+ * but we need to be careful to specify correct increment.
  *
  ***************************************************************************/
 
 /* logic deciding a strategy for unrolling of vectorized paths */
 template <typename Func, typename Evaluator>
 struct packetwise_redux_traits {
-  enum {
-    OuterSize = int(Evaluator::IsRowMajor) ? Evaluator::RowsAtCompileTime : Evaluator::ColsAtCompileTime,
-    Cost = OuterSize == Dynamic ? HugeCost
-                                : OuterSize * Evaluator::CoeffReadCost + (OuterSize - 1) * functor_traits<Func>::Cost,
-    Unrolling = Cost <= EIGEN_UNROLLING_LIMIT ? CompleteUnrolling : NoUnrolling
-  };
+  static constexpr int OuterSize =
+      int(Evaluator::IsRowMajor) ? Evaluator::RowsAtCompileTime : Evaluator::ColsAtCompileTime;
+  static constexpr int Cost = OuterSize == Dynamic
+                                  ? HugeCost
+                                  : OuterSize * Evaluator::CoeffReadCost + (OuterSize - 1) * functor_traits<Func>::Cost;
+  static constexpr int Unrolling = Cost <= EIGEN_UNROLLING_LIMIT ? CompleteUnrolling : NoUnrolling;
 };
 
 /* Value to be returned when size==0 , by default let's return 0 */
@@ -70,8 +71,8 @@
 /* Perform the actual reduction with unrolling */
 template <typename Func, typename Evaluator>
 struct packetwise_redux_impl<Func, Evaluator, CompleteUnrolling> {
-  typedef redux_novec_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
-  typedef typename Evaluator::Scalar Scalar;
+  using Base = redux_novec_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime>;
+  using Scalar = typename Evaluator::Scalar;
 
   template <typename PacketType>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE PacketType run(const Evaluator& eval, const Func& func, Index /*size*/) {
@@ -96,8 +97,8 @@
 /* Perform the actual reduction for dynamic sizes */
 template <typename Func, typename Evaluator>
 struct packetwise_redux_impl<Func, Evaluator, NoUnrolling> {
-  typedef typename Evaluator::Scalar Scalar;
-  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+  using Scalar = typename Evaluator::Scalar;
+  using PacketScalar = typename redux_traits<Func, Evaluator>::PacketType;
 
   template <typename PacketType>
   EIGEN_DEVICE_FUNC static PacketType run(const Evaluator& eval, const Func& func, Index size) {
@@ -122,16 +123,26 @@
 
 template <typename Func, typename Evaluator>
 struct packetwise_segment_redux_impl {
-  typedef typename Evaluator::Scalar Scalar;
-  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+  using Scalar = typename Evaluator::Scalar;
+  using PacketScalar = typename redux_traits<Func, Evaluator>::PacketType;
 
   template <typename PacketType>
   EIGEN_DEVICE_FUNC static PacketType run(const Evaluator& eval, const Func& func, Index size, Index begin,
                                           Index count) {
     if (size == 0) return packetwise_redux_empty_value<PacketType>(func);
 
+    const Index size4 = 1 + numext::round_down(size - 1, 4);
     PacketType p = eval.template packetSegmentByOuterInner<Unaligned, PacketType>(0, 0, begin, count);
-    for (Index i = 1; i < size; ++i)
+    // Grouping exposes independent packet ops and shortens the dependency chain.
+    for (Index i = 1; i < size4; i += 4)
+      p = func.packetOp(
+          p,
+          func.packetOp(
+              func.packetOp(eval.template packetSegmentByOuterInner<Unaligned, PacketType>(i + 0, 0, begin, count),
+                            eval.template packetSegmentByOuterInner<Unaligned, PacketType>(i + 1, 0, begin, count)),
+              func.packetOp(eval.template packetSegmentByOuterInner<Unaligned, PacketType>(i + 2, 0, begin, count),
+                            eval.template packetSegmentByOuterInner<Unaligned, PacketType>(i + 3, 0, begin, count))));
+    for (Index i = size4; i < size; ++i)
       p = func.packetOp(p, eval.template packetSegmentByOuterInner<Unaligned, PacketType>(i, 0, begin, count));
     return p;
   }
@@ -140,16 +151,16 @@
 template <typename ArgType, typename MemberOp, int Direction>
 struct evaluator<PartialReduxExpr<ArgType, MemberOp, Direction> >
     : evaluator_base<PartialReduxExpr<ArgType, MemberOp, Direction> > {
-  typedef PartialReduxExpr<ArgType, MemberOp, Direction> XprType;
-  typedef typename internal::nested_eval<ArgType, 1>::type ArgTypeNested;
-  typedef add_const_on_value_type_t<ArgTypeNested> ConstArgTypeNested;
-  typedef internal::remove_all_t<ArgTypeNested> ArgTypeNestedCleaned;
-  typedef typename ArgType::Scalar InputScalar;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = PartialReduxExpr<ArgType, MemberOp, Direction>;
+  using ArgTypeNested = typename internal::nested_eval<ArgType, 1>::type;
+  using ConstArgTypeNested = add_const_on_value_type_t<ArgTypeNested>;
+  using ArgTypeNestedCleaned = internal::remove_all_t<ArgTypeNested>;
+  using InputScalar = typename ArgType::Scalar;
+  using Scalar = typename XprType::Scalar;
   enum {
     TraversalSize = Direction == int(Vertical) ? int(ArgType::RowsAtCompileTime) : int(ArgType::ColsAtCompileTime)
   };
-  typedef typename MemberOp::template Cost<int(TraversalSize)> CostOpType;
+  using CostOpType = typename MemberOp::template Cost<int(TraversalSize)>;
   enum {
     CoeffReadCost = TraversalSize == Dynamic ? HugeCost
                     : TraversalSize == 0
@@ -168,13 +179,13 @@
     Alignment = 0  // FIXME this will need to be improved once PartialReduxExpr is vectorized
   };
 
-  EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr) : m_arg(xpr.nestedExpression()), m_functor(xpr.functor()) {
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : m_arg(xpr.nestedExpression()), m_functor(xpr.functor()) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(TraversalSize == Dynamic ? HugeCost
                                                              : (TraversalSize == 0 ? 1 : int(CostOpType::value)));
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index i, Index j) const {
     return coeff(Direction == Vertical ? j : i);
@@ -199,11 +210,10 @@
     using BinaryOp = typename MemberOp::BinaryOp;
     using Impl = internal::packetwise_redux_impl<BinaryOp, PanelEvaluator>;
 
-    // FIXME
-    // See bug 1612, currently if PacketSize==1 (i.e. complex<double> with 128bits registers) then the storage-order of
-    // panel get reversed and methods like packetByOuterInner do not make sense anymore in this context. So let's just
-    // by pass "vectorization" in this case:
-    if (PacketSize == 1) return internal::pset1<PacketType>(coeff(idx));
+    // Workaround for issue 1612 (closed): when PacketSize==1 (i.e. complex<double> with 128bits registers) the
+    // storage-order of panel gets reversed and methods like packetByOuterInner do not make sense in this context, so
+    // bypass "vectorization":
+    EIGEN_IF_CONSTEXPR (PacketSize == 1) return internal::pset1<PacketType>(coeff(idx));
 
     Index startRow = Direction == Vertical ? 0 : idx;
     Index startCol = Direction == Vertical ? idx : 0;
diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h
index 7713354..eff2cc2 100644
--- a/Eigen/src/Core/PermutationMatrix.h
+++ b/Eigen/src/Core/PermutationMatrix.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PERMUTATIONMATRIX_H
 #define EIGEN_PERMUTATIONMATRIX_H
@@ -41,18 +42,19 @@
  *
  * Notice that in addition to the member functions and operators listed here, there also are non-member
  * operator* to multiply any kind of permutation object with any kind of matrix expression (MatrixBase)
- * on either side.
+ * on either side, and with a diagonal matrix (DiagonalBase) on either side, which yields a
+ * ScaledPermutationMatrix.
  *
  * \sa class PermutationMatrix, class PermutationWrapper
  */
 template <typename Derived>
 class PermutationBase : public EigenBase<Derived> {
-  typedef internal::traits<Derived> Traits;
-  typedef EigenBase<Derived> Base;
+  using Traits = internal::traits<Derived>;
+  using Base = EigenBase<Derived>;
 
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename Traits::IndicesType IndicesType;
+  using IndicesType = typename Traits::IndicesType;
   enum {
     Flags = Traits::Flags,
     RowsAtCompileTime = Traits::RowsAtCompileTime,
@@ -60,15 +62,15 @@
     MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = Traits::MaxColsAtCompileTime
   };
-  typedef typename Traits::StorageIndex StorageIndex;
-  typedef Matrix<StorageIndex, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>
-      DenseMatrixType;
-  typedef PermutationMatrix<IndicesType::SizeAtCompileTime, IndicesType::MaxSizeAtCompileTime, StorageIndex>
-      PlainPermutationType;
-  typedef PlainPermutationType PlainObject;
+  using StorageIndex = typename Traits::StorageIndex;
+  using DenseMatrixType =
+      Matrix<StorageIndex, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+  using PlainPermutationType =
+      PermutationMatrix<IndicesType::SizeAtCompileTime, IndicesType::MaxSizeAtCompileTime, StorageIndex>;
+  using PlainObject = PlainPermutationType;
   using Base::derived;
-  typedef Inverse<Derived> InverseReturnType;
-  typedef void Scalar;
+  using InverseReturnType = Inverse<Derived>;
+  using Scalar = void;
 #endif
 
   /** Copies the other permutation into *this */
@@ -113,23 +115,23 @@
   DenseMatrixType eval() const { return toDenseMatrix(); }
 
   /** const version of indices(). */
-  const IndicesType& indices() const { return derived().indices(); }
+  EIGEN_DEVICE_FUNC constexpr const IndicesType& indices() const { return derived().indices(); }
   /** \returns a reference to the stored array representing the permutation. */
-  IndicesType& indices() { return derived().indices(); }
+  EIGEN_DEVICE_FUNC constexpr IndicesType& indices() { return derived().indices(); }
 
   /** Resizes to given size.
    */
-  inline void resize(Index newSize) { indices().resize(newSize); }
+  EIGEN_DEVICE_FUNC void resize(Index newSize) { indices().resize(newSize); }
 
   /** Sets *this to be the identity permutation matrix */
-  void setIdentity() {
+  EIGEN_DEVICE_FUNC void setIdentity() {
     StorageIndex n = StorageIndex(size());
     for (StorageIndex i = 0; i < n; ++i) indices().coeffRef(i) = i;
   }
 
   /** Sets *this to be the identity permutation matrix of given size.
    */
-  void setIdentity(Index newSize) {
+  EIGEN_DEVICE_FUNC void setIdentity(Index newSize) {
     resize(newSize);
     setIdentity();
   }
@@ -139,12 +141,23 @@
    * \returns a reference to *this.
    *
    * \warning This is much slower than applyTranspositionOnTheRight(Index,Index):
-   * this has linear complexity and requires a lot of branching.
+   * this has linear complexity.
    *
    * \sa applyTranspositionOnTheRight(Index,Index)
    */
   Derived& applyTranspositionOnTheLeft(Index i, Index j) {
     eigen_assert(i >= 0 && j >= 0 && i < size() && j < size());
+    if (i == j) return derived();
+    EIGEN_IF_CONSTEXPR ((internal::evaluator<IndicesType>::Flags & PacketAccessBit) &&
+                        internal::packet_traits<StorageIndex>::HasCmp) {
+      // Amortize packet setup over at least two packets.
+      if (size() >= 2 * internal::packet_traits<StorageIndex>::size) {
+        const StorageIndex first = StorageIndex(i), second = StorageIndex(j);
+        indices() =
+            indices().cwiseTypedEqual(first).select(second, indices().cwiseTypedEqual(second).select(first, indices()));
+        return derived();
+      }
+    }
     for (Index k = 0; k < size(); ++k) {
       if (indices().coeff(k) == i)
         indices().coeffRef(k) = StorageIndex(j);
@@ -185,7 +198,7 @@
  protected:
   template <typename OtherDerived>
   void assignTranspose(const PermutationBase<OtherDerived>& other) {
-    for (Index i = 0; i < rows(); ++i) indices().coeffRef(other.indices().coeff(i)) = i;
+    for (Index i = 0; i < rows(); ++i) indices().coeffRef(other.indices().coeff(i)) = StorageIndex(i);
   }
   template <typename Lhs, typename Rhs>
   void assignProduct(const Lhs& lhs, const Rhs& rhs) {
@@ -210,7 +223,12 @@
    */
   template <typename Other>
   inline PlainPermutationType operator*(const InverseImpl<Other, PermutationStorage>& other) const {
-    return PlainPermutationType(internal::PermPermProduct, *this, other.eval());
+    const auto& rhs = other.derived().nestedExpression();
+    eigen_assert(size() == rhs.size());
+    PlainPermutationType result(size());
+    // (P * Q.inverse())(Q(i)) = P(i).
+    for (Index i = 0; i < size(); ++i) result.indices().coeffRef(rhs.indices().coeff(i)) = indices().coeff(i);
+    return result;
   }
 
   /** \returns the product of an inverse permutation with another permutation.
@@ -248,8 +266,6 @@
     }
     return res;
   }
-
- protected:
 };
 
 namespace internal {
@@ -257,10 +273,10 @@
 struct traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_> >
     : traits<
           Matrix<StorageIndex_, SizeAtCompileTime, SizeAtCompileTime, 0, MaxSizeAtCompileTime, MaxSizeAtCompileTime> > {
-  typedef PermutationStorage StorageKind;
-  typedef Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
-  typedef StorageIndex_ StorageIndex;
-  typedef void Scalar;
+  using StorageKind = PermutationStorage;
+  using IndicesType = Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>;
+  using StorageIndex = StorageIndex_;
+  using Scalar = void;
 };
 }  // namespace internal
 
@@ -281,28 +297,28 @@
 template <int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
 class PermutationMatrix
     : public PermutationBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_> > {
-  typedef PermutationBase<PermutationMatrix> Base;
-  typedef internal::traits<PermutationMatrix> Traits;
+  using Base = PermutationBase<PermutationMatrix>;
+  using Traits = internal::traits<PermutationMatrix>;
 
  public:
-  typedef const PermutationMatrix& Nested;
+  using Nested = const PermutationMatrix&;
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename Traits::IndicesType IndicesType;
-  typedef typename Traits::StorageIndex StorageIndex;
+  using IndicesType = typename Traits::IndicesType;
+  using StorageIndex = typename Traits::StorageIndex;
 #endif
 
-  inline PermutationMatrix() {}
+  EIGEN_DEVICE_FUNC PermutationMatrix() = default;
 
   /** Constructs an uninitialized permutation matrix of given size.
    */
-  explicit inline PermutationMatrix(Index size) : m_indices(size) {
+  EIGEN_DEVICE_FUNC explicit PermutationMatrix(Index size) : m_indices(size) {
     eigen_internal_assert(size <= NumTraits<StorageIndex>::highest());
   }
 
   /** Copy constructor. */
   template <typename OtherDerived>
-  inline PermutationMatrix(const PermutationBase<OtherDerived>& other) : m_indices(other.indices()) {}
+  EIGEN_DEVICE_FUNC PermutationMatrix(const PermutationBase<OtherDerived>& other) : m_indices(other.indices()) {}
 
   /** Generic constructor from expression of the indices. The indices
    * array has the meaning that the permutations sends each integer i to indices[i].
@@ -312,7 +328,7 @@
    * array's size.
    */
   template <typename Other>
-  explicit inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(indices) {}
+  EIGEN_DEVICE_FUNC explicit PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(indices) {}
 
   /** Convert the Transpositions \a tr to a permutation matrix */
   template <typename Other>
@@ -322,7 +338,7 @@
 
   /** Copies the other permutation into *this */
   template <typename Other>
-  PermutationMatrix& operator=(const PermutationBase<Other>& other) {
+  EIGEN_DEVICE_FUNC PermutationMatrix& operator=(const PermutationBase<Other>& other) {
     m_indices = other.indices();
     return *this;
   }
@@ -334,9 +350,9 @@
   }
 
   /** const version of indices(). */
-  const IndicesType& indices() const { return m_indices; }
+  EIGEN_DEVICE_FUNC constexpr const IndicesType& indices() const { return m_indices; }
   /** \returns a reference to the stored array representing the permutation. */
-  IndicesType& indices() { return m_indices; }
+  EIGEN_DEVICE_FUNC constexpr IndicesType& indices() { return m_indices; }
 
   /**** multiplication helpers to hopefully get RVO ****/
 
@@ -345,9 +361,7 @@
   PermutationMatrix(const InverseImpl<Other, PermutationStorage>& other)
       : m_indices(other.derived().nestedExpression().size()) {
     eigen_internal_assert(m_indices.size() <= NumTraits<StorageIndex>::highest());
-    StorageIndex end = StorageIndex(m_indices.size());
-    for (StorageIndex i = 0; i < end; ++i)
-      m_indices.coeffRef(other.derived().nestedExpression().indices().coeff(i)) = i;
+    Base::assignTranspose(other.derived().nestedExpression());
   }
   template <typename Lhs, typename Rhs>
   PermutationMatrix(internal::PermPermProduct_t, const Lhs& lhs, const Rhs& rhs) : m_indices(lhs.indices().size()) {
@@ -364,10 +378,10 @@
 struct traits<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>, PacketAccess_> >
     : traits<
           Matrix<StorageIndex_, SizeAtCompileTime, SizeAtCompileTime, 0, MaxSizeAtCompileTime, MaxSizeAtCompileTime> > {
-  typedef PermutationStorage StorageKind;
-  typedef Map<const Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, PacketAccess_> IndicesType;
-  typedef StorageIndex_ StorageIndex;
-  typedef void Scalar;
+  using StorageKind = PermutationStorage;
+  using IndicesType = Map<const Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, PacketAccess_>;
+  using StorageIndex = StorageIndex_;
+  using Scalar = void;
 };
 }  // namespace internal
 
@@ -375,13 +389,13 @@
 class Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>, PacketAccess_>
     : public PermutationBase<
           Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>, PacketAccess_> > {
-  typedef PermutationBase<Map> Base;
-  typedef internal::traits<Map> Traits;
+  using Base = PermutationBase<Map>;
+  using Traits = internal::traits<Map>;
 
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename Traits::IndicesType IndicesType;
-  typedef typename IndicesType::Scalar StorageIndex;
+  using IndicesType = typename Traits::IndicesType;
+  using StorageIndex = typename IndicesType::Scalar;
 #endif
 
   inline Map(const StorageIndex* indicesPtr) : m_indices(indicesPtr) {}
@@ -419,15 +433,13 @@
   IndicesType m_indices;
 };
 
-template <typename IndicesType_>
-class TranspositionsWrapper;
 namespace internal {
 template <typename IndicesType_>
 struct traits<PermutationWrapper<IndicesType_> > {
-  typedef PermutationStorage StorageKind;
-  typedef void Scalar;
-  typedef typename IndicesType_::Scalar StorageIndex;
-  typedef IndicesType_ IndicesType;
+  using StorageKind = PermutationStorage;
+  using Scalar = void;
+  using StorageIndex = typename IndicesType_::Scalar;
+  using IndicesType = IndicesType_;
   enum {
     RowsAtCompileTime = IndicesType_::SizeAtCompileTime,
     ColsAtCompileTime = IndicesType_::SizeAtCompileTime,
@@ -451,12 +463,12 @@
  */
 template <typename IndicesType_>
 class PermutationWrapper : public PermutationBase<PermutationWrapper<IndicesType_> > {
-  typedef PermutationBase<PermutationWrapper> Base;
-  typedef internal::traits<PermutationWrapper> Traits;
+  using Base = PermutationBase<PermutationWrapper>;
+  using Traits = internal::traits<PermutationWrapper>;
 
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename Traits::IndicesType IndicesType;
+  using IndicesType = typename Traits::IndicesType;
 #endif
 
   inline PermutationWrapper(const IndicesType& indices) : m_indices(indices) {}
@@ -486,18 +498,18 @@
 
 template <typename PermutationType>
 class InverseImpl<PermutationType, PermutationStorage> : public EigenBase<Inverse<PermutationType> > {
-  typedef typename PermutationType::PlainPermutationType PlainPermutationType;
-  typedef internal::traits<PermutationType> PermTraits;
+  using PlainPermutationType = typename PermutationType::PlainPermutationType;
+  using PermTraits = internal::traits<PermutationType>;
 
  protected:
-  InverseImpl() {}
+  InverseImpl() = default;
 
  public:
-  typedef Inverse<PermutationType> InverseType;
+  using InverseType = Inverse<PermutationType>;
   using EigenBase<Inverse<PermutationType> >::derived;
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename PermutationType::DenseMatrixType DenseMatrixType;
+  using DenseMatrixType = typename PermutationType::DenseMatrixType;
   enum {
     RowsAtCompileTime = PermTraits::RowsAtCompileTime,
     ColsAtCompileTime = PermTraits::ColsAtCompileTime,
@@ -545,7 +557,7 @@
 
 template <>
 struct AssignmentKind<DenseShape, PermutationShape> {
-  typedef EigenBase2EigenBase Kind;
+  using Kind = EigenBase2EigenBase;
 };
 
 }  // end namespace internal
diff --git a/Eigen/src/Core/PlainObjectBase.h b/Eigen/src/Core/PlainObjectBase.h
index 2f4c357..a255d3e 100644
--- a/Eigen/src/Core/PlainObjectBase.h
+++ b/Eigen/src/Core/PlainObjectBase.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DENSESTORAGEBASE_H
 #define EIGEN_DENSESTORAGEBASE_H
@@ -31,6 +32,20 @@
 
 namespace internal {
 
+// Dense coefficient assignment requires scalar compatibility; evalTo expressions may
+// implement their own conversion instead.
+template <typename Scalar, typename OtherDerived, bool = std::is_base_of<DenseBase<OtherDerived>, OtherDerived>::value>
+struct is_valid_dense_conversion : std::true_type {};
+
+template <typename Scalar, typename OtherDerived>
+struct is_valid_dense_conversion<Scalar, OtherDerived, true>
+    : bool_constant<has_ReturnType<ScalarBinaryOpTraits<Scalar, typename OtherDerived::Scalar,
+                                                        assign_op<Scalar, typename OtherDerived::Scalar>>>::value &&
+                    std::is_assignable<Scalar&, const typename OtherDerived::Scalar&>::value> {};
+
+template <typename Scalar, typename OtherDerived>
+struct is_valid_dense_conversion<Scalar, ReturnByValue<OtherDerived>, true> : std::true_type {};
+
 #ifndef EIGEN_NO_DEBUG
 template <int MaxSizeAtCompileTime, int MaxRowsAtCompileTime, int MaxColsAtCompileTime>
 struct check_rows_cols_for_overflow {
@@ -95,14 +110,14 @@
 class PlainObjectBase : public internal::dense_xpr_base<Derived>::type {
  public:
   enum { Options = internal::traits<Derived>::Options };
-  typedef typename internal::dense_xpr_base<Derived>::type Base;
+  using Base = typename internal::dense_xpr_base<Derived>::type;
 
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using Scalar = typename internal::traits<Derived>::Scalar;
 
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Derived DenseType;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using DenseType = Derived;
 
   using Base::ColsAtCompileTime;
   using Base::Flags;
@@ -113,25 +128,25 @@
   using Base::RowsAtCompileTime;
   using Base::SizeAtCompileTime;
 
-  typedef Eigen::Map<Derived, Unaligned> MapType;
-  typedef const Eigen::Map<const Derived, Unaligned> ConstMapType;
-  typedef Eigen::Map<Derived, AlignedMax> AlignedMapType;
-  typedef const Eigen::Map<const Derived, AlignedMax> ConstAlignedMapType;
+  using MapType = Eigen::Map<Derived, Unaligned>;
+  using ConstMapType = const Eigen::Map<const Derived, Unaligned>;
+  using AlignedMapType = Eigen::Map<Derived, AlignedMax>;
+  using ConstAlignedMapType = const Eigen::Map<const Derived, AlignedMax>;
   template <typename StrideType>
   struct StridedMapType {
-    typedef Eigen::Map<Derived, Unaligned, StrideType> type;
+    using type = Eigen::Map<Derived, Unaligned, StrideType>;
   };
   template <typename StrideType>
   struct StridedConstMapType {
-    typedef Eigen::Map<const Derived, Unaligned, StrideType> type;
+    using type = Eigen::Map<const Derived, Unaligned, StrideType>;
   };
   template <typename StrideType>
   struct StridedAlignedMapType {
-    typedef Eigen::Map<Derived, AlignedMax, StrideType> type;
+    using type = Eigen::Map<Derived, AlignedMax, StrideType>;
   };
   template <typename StrideType>
   struct StridedConstAlignedMapType {
-    typedef Eigen::Map<const Derived, AlignedMax, StrideType> type;
+    using type = Eigen::Map<const Derived, AlignedMax, StrideType>;
   };
 
  protected:
@@ -170,10 +185,11 @@
    *
    * See DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const for details. */
   EIGEN_DEVICE_FUNC constexpr const Scalar& coeff(Index rowId, Index colId) const {
-    if (Flags & RowMajorBit)
+    EIGEN_IF_CONSTEXPR (Flags & RowMajorBit) {
       return m_storage.data()[colId + rowId * m_storage.cols()];
-    else  // column-major
+    } else {  // column-major
       return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
   }
 
   /** This is an overloaded version of DenseCoeffsBase<Derived,ReadOnlyAccessors>::coeff(Index) const
@@ -187,10 +203,11 @@
    *
    * See DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index,Index) const for details. */
   EIGEN_DEVICE_FUNC constexpr Scalar& coeffRef(Index rowId, Index colId) {
-    if (Flags & RowMajorBit)
+    EIGEN_IF_CONSTEXPR (Flags & RowMajorBit) {
       return m_storage.data()[colId + rowId * m_storage.cols()];
-    else  // column-major
+    } else {  // column-major
       return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
   }
 
   /** This is an overloaded version of DenseCoeffsBase<Derived,WriteAccessors>::coeffRef(Index) const
@@ -202,10 +219,11 @@
   /** This is the const version of coeffRef(Index,Index) which is thus synonym of coeff(Index,Index).
    * It is provided for convenience. */
   EIGEN_DEVICE_FUNC constexpr const Scalar& coeffRef(Index rowId, Index colId) const {
-    if (Flags & RowMajorBit)
+    EIGEN_IF_CONSTEXPR (Flags & RowMajorBit) {
       return m_storage.data()[colId + rowId * m_storage.cols()];
-    else  // column-major
+    } else {  // column-major
       return m_storage.data()[rowId + colId * m_storage.rows()];
+    }
   }
 
   /** This is the const version of coeffRef(Index) which is thus synonym of coeff(Index).
@@ -302,10 +320,11 @@
 #ifdef EIGEN_INITIALIZE_COEFFS
     bool size_changed = size != this->size();
 #endif
-    if (RowsAtCompileTime == 1)
+    EIGEN_IF_CONSTEXPR (RowsAtCompileTime == 1) {
       m_storage.resize(size, 1, size);
-    else
+    } else {
       m_storage.resize(size, size, 1);
+    }
 #ifdef EIGEN_INITIALIZE_COEFFS
     if (size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
 #endif
@@ -346,14 +365,15 @@
         other.rows(), other.cols());
 #endif
     const Index othersize = other.rows() * other.cols();
-    if (RowsAtCompileTime == 1) {
+    EIGEN_IF_CONSTEXPR (RowsAtCompileTime == 1) {
       eigen_assert(other.rows() == 1 || other.cols() == 1);
       resize(1, othersize);
-    } else if (ColsAtCompileTime == 1) {
+    } else EIGEN_IF_CONSTEXPR (ColsAtCompileTime == 1) {
       eigen_assert(other.rows() == 1 || other.cols() == 1);
       resize(othersize, 1);
-    } else
+    } else {
       resize(other.rows(), other.cols());
+    }
   }
 
   /** Resizes the matrix to \a rows x \a cols while leaving old values untouched.
@@ -412,7 +432,7 @@
    * conservativeResize(Index, NoChange_t).
    *
    * Matrices are resized relative to the top-left element. In case values need to be
-   * appended to the matrix they will copied from \c other.
+   * appended to the matrix they will be copied from \c other.
    */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other) {
@@ -438,7 +458,7 @@
   }
 
   // Prevent user from trying to instantiate PlainObjectBase objects
-  // by making all its constructor protected. See bug 1074.
+  // by making all its constructors protected. See bug 1074.
  protected:
   EIGEN_DEVICE_FUNC constexpr PlainObjectBase() = default;
   /** \brief Move constructor */
@@ -454,7 +474,7 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
       : m_storage(size, rows, cols) {}
 
-  /** \brief Construct a row of column vector with fixed size from an arbitrary number of coefficients.
+  /** \brief Construct a row or column vector with fixed size from an arbitrary number of coefficients.
    *
    * \only_for_vectors
    *
@@ -489,30 +509,33 @@
     }
 
     // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
-    if (ColsAtCompileTime == 1 && list.size() == 1) {
-      eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
-      resize(list_size, ColsAtCompileTime);
-      if (list.begin()->begin() != nullptr) {
-        Index index = 0;
-        for (const Scalar& e : *list.begin()) {
-          coeffRef(index++) = e;
+    EIGEN_IF_CONSTEXPR (ColsAtCompileTime == 1) {
+      if (list.size() == 1) {
+        eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        resize(list_size, ColsAtCompileTime);
+        if (list.begin()->begin() != nullptr) {
+          Index index = 0;
+          for (const Scalar& e : *list.begin()) {
+            coeffRef(index++) = e;
+          }
         }
+        return;
       }
-    } else {
-      eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
-      eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
-      resize(list.size(), list_size);
+    }
 
-      Index row_index = 0;
-      for (const std::initializer_list<Scalar>& row : list) {
-        eigen_assert(list_size == row.size());
-        Index col_index = 0;
-        for (const Scalar& e : row) {
-          coeffRef(row_index, col_index) = e;
-          ++col_index;
-        }
-        ++row_index;
+    eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+    eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
+    resize(list.size(), list_size);
+
+    Index row_index = 0;
+    for (const std::initializer_list<Scalar>& row : list) {
+      eigen_assert(list_size == row.size());
+      Index col_index = 0;
+      for (const Scalar& e : row) {
+        coeffRef(row_index, col_index) = e;
+        ++col_index;
       }
+      ++row_index;
     }
   }
 
@@ -550,8 +573,8 @@
 
   /** \name Map
    * These are convenience functions returning Map objects. The Map() static functions return unaligned Map objects,
-   * while the AlignedMap() functions return aligned Map objects and thus should be called only with 16-byte-aligned
-   * \a data pointers.
+   * while the MapAligned() functions return Map objects with \c AlignedMax alignment and thus should be called only
+   * with \a data pointers aligned on an \c EIGEN_MAX_ALIGN_BYTES boundary.
    *
    * Here is an example using strides:
    * \include Matrix_Map_stride.cpp
@@ -707,7 +730,7 @@
    * \internal
    */
   // aliasing is dealt once in internal::call_assignment
-  // so at this stage we have to assume aliasing... and resising has to be done later.
+  // so at this stage we have to assume aliasing... and resizing has to be done later.
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC constexpr Derived& _set(const DenseBase<OtherDerived>& other) {
     internal::call_assignment(this->derived(), other.derived());
@@ -731,28 +754,25 @@
     return this->derived();
   }
 
-  template <typename T0, typename T1>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init2(Index rows, Index cols,
-                                                              std::enable_if_t<Base::SizeAtCompileTime != 2, T0>* = 0) {
+  template <typename T0, typename T1, std::enable_if_t<Base::SizeAtCompileTime != 2, T0>* = nullptr>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init2(Index rows, Index cols) {
     EIGEN_STATIC_ASSERT(internal::is_valid_index_type<T0>::value && internal::is_valid_index_type<T1>::value,
                         T0 AND T1 MUST BE INTEGER TYPES)
     resize(rows, cols);
   }
 
-  template <typename T0, typename T1>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1,
-                                                              std::enable_if_t<Base::SizeAtCompileTime == 2, T0>* = 0) {
+  template <typename T0, typename T1, std::enable_if_t<Base::SizeAtCompileTime == 2, T0>* = nullptr>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init2(const T0& val0, const T1& val1) {
     EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
     m_storage.data()[0] = Scalar(val0);
     m_storage.data()[1] = Scalar(val1);
   }
 
-  template <typename T0, typename T1>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init2(
-      const Index& val0, const Index& val1,
-      std::enable_if_t<(!internal::is_same<Index, Scalar>::value) && (internal::is_same<T0, Index>::value) &&
-                           (internal::is_same<T1, Index>::value) && Base::SizeAtCompileTime == 2,
-                       T1>* = 0) {
+  template <typename T0, typename T1,
+            std::enable_if_t<(!std::is_same<Index, Scalar>::value) && (std::is_same<T0, Index>::value) &&
+                                 (std::is_same<T1, Index>::value) && Base::SizeAtCompileTime == 2,
+                             int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init2(const Index& val0, const Index& val1) {
     EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
     m_storage.data()[0] = Scalar(val0);
     m_storage.data()[1] = Scalar(val1);
@@ -760,38 +780,31 @@
 
   // The argument is convertible to the Index type and we either have a non 1x1 Matrix, or a dynamic-sized Array,
   // then the argument is meant to be the size of the object.
-  template <typename T>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(
-      Index size,
-      std::enable_if_t<(Base::SizeAtCompileTime != 1 || !internal::is_convertible<T, Scalar>::value) &&
-                           ((!internal::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value ||
-                             Base::SizeAtCompileTime == Dynamic)),
-                       T>* = 0) {
-    // NOTE MSVC 2008 complains if we directly put bool(NumTraits<T>::IsInteger) as the EIGEN_STATIC_ASSERT argument.
-    const bool is_integer_alike = internal::is_valid_index_type<T>::value;
-    EIGEN_UNUSED_VARIABLE(is_integer_alike);
-    EIGEN_STATIC_ASSERT(is_integer_alike, FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
+  template <typename T,
+            std::enable_if_t<(Base::SizeAtCompileTime != 1 || !std::is_convertible<T, Scalar>::value) &&
+                                 ((!std::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value ||
+                                   Base::SizeAtCompileTime == Dynamic)),
+                             int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(Index size) {
+    EIGEN_STATIC_ASSERT(internal::is_valid_index_type<T>::value, FLOATING_POINT_ARGUMENT_PASSED__INTEGER_WAS_EXPECTED)
     resize(size);
   }
 
   // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar
   // type can be implicitly converted)
-  template <typename T>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(
-      const Scalar& val0,
-      std::enable_if_t<Base::SizeAtCompileTime == 1 && internal::is_convertible<T, Scalar>::value, T>* = 0) {
+  template <typename T,
+            std::enable_if_t<Base::SizeAtCompileTime == 1 && std::is_convertible<T, Scalar>::value, int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(const Scalar& val0) {
     EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
     m_storage.data()[0] = val0;
   }
 
   // We have a 1x1 matrix/array => the argument is interpreted as the value of the unique coefficient (case where scalar
   // type match the index type)
-  template <typename T>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(
-      const Index& val0,
-      std::enable_if_t<(!internal::is_same<Index, Scalar>::value) && (internal::is_same<Index, T>::value) &&
-                           Base::SizeAtCompileTime == 1 && internal::is_convertible<T, Scalar>::value,
-                       T*>* = 0) {
+  template <typename T, std::enable_if_t<(!std::is_same<Index, Scalar>::value) && (std::is_same<Index, T>::value) &&
+                                             Base::SizeAtCompileTime == 1 && std::is_convertible<T, Scalar>::value,
+                                         int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(const Index& val0) {
     EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 1)
     m_storage.data()[0] = Scalar(val0);
   }
@@ -832,25 +845,21 @@
   }
 
   // For fixed-size Array<Scalar,...>
-  template <typename T>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(
-      const Scalar& val0,
-      std::enable_if_t<Base::SizeAtCompileTime != Dynamic && Base::SizeAtCompileTime != 1 &&
-                           internal::is_convertible<T, Scalar>::value &&
-                           internal::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value,
-                       T>* = 0) {
+  template <typename T, std::enable_if_t<Base::SizeAtCompileTime != Dynamic && Base::SizeAtCompileTime != 1 &&
+                                             std::is_convertible<T, Scalar>::value &&
+                                             std::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value,
+                                         int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(const Scalar& val0) {
     Base::setConstant(val0);
   }
 
   // For fixed-size Array<Index,...>
-  template <typename T>
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(
-      const Index& val0,
-      std::enable_if_t<(!internal::is_same<Index, Scalar>::value) && (internal::is_same<Index, T>::value) &&
-                           Base::SizeAtCompileTime != Dynamic && Base::SizeAtCompileTime != 1 &&
-                           internal::is_convertible<T, Scalar>::value &&
-                           internal::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value,
-                       T*>* = 0) {
+  template <typename T, std::enable_if_t<(!std::is_same<Index, Scalar>::value) && (std::is_same<Index, T>::value) &&
+                                             Base::SizeAtCompileTime != Dynamic && Base::SizeAtCompileTime != 1 &&
+                                             std::is_convertible<T, Scalar>::value &&
+                                             std::is_same<typename internal::traits<Derived>::XprKind, ArrayXpr>::value,
+                                         int> = 0>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void _init1(const Index& val0) {
     Base::setConstant(val0);
   }
 
@@ -865,7 +874,7 @@
    */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(DenseBase<OtherDerived>& other) {
-    enum {SwapPointers = internal::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime == Dynamic};
+    enum {SwapPointers = std::is_same<Derived, OtherDerived>::value && Base::SizeAtCompileTime == Dynamic};
     internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.derived());
   }
 
@@ -903,23 +912,25 @@
     if (_this.rows() == rows && _this.cols() == cols) return;
     EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
 
-    if (IsRelocatable &&
-        ((Derived::IsRowMajor && _this.cols() == cols) ||  // row-major and we change only the number of rows
-         (!Derived::IsRowMajor && _this.rows() == rows)))  // column-major and we change only the number of columns
-    {
+    EIGEN_IF_CONSTEXPR (IsRelocatable) {
+      if ((Derived::IsRowMajor && _this.cols() == cols) ||  // row-major and we change only the number of rows
+          (!Derived::IsRowMajor && _this.rows() == rows))   // column-major and we change only the number of columns
+      {
 #ifndef EIGEN_NO_DEBUG
-      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime, Derived::MaxRowsAtCompileTime,
-                                             Derived::MaxColsAtCompileTime>::run(rows, cols);
+        internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime, Derived::MaxRowsAtCompileTime,
+                                               Derived::MaxColsAtCompileTime>::run(rows, cols);
 #endif
-      _this.derived().m_storage.conservativeResize(rows * cols, rows, cols);
-    } else {
-      // The storage order does not allow us to use reallocation.
-      Derived tmp(rows, cols);
-      const Index common_rows = numext::mini(rows, _this.rows());
-      const Index common_cols = numext::mini(cols, _this.cols());
-      tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
-      _this.derived().swap(tmp);
+        _this.derived().m_storage.conservativeResize(rows * cols, rows, cols);
+        return;
+      }
     }
+
+    // The storage order does not allow us to use reallocation.
+    Derived tmp(rows, cols);
+    const Index common_rows = numext::mini(rows, _this.rows());
+    const Index common_cols = numext::mini(cols, _this.cols());
+    tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
+    _this.derived().swap(tmp);
   }
 
   static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other) {
@@ -933,26 +944,28 @@
     EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)
     EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(OtherDerived)
 
-    if (IsRelocatable &&
-        ((Derived::IsRowMajor && _this.cols() == other.cols()) ||  // row-major and we change only the number of rows
-         (!Derived::IsRowMajor &&
-          _this.rows() == other.rows())))  // column-major and we change only the number of columns
-    {
-      const Index new_rows = other.rows() - _this.rows();
-      const Index new_cols = other.cols() - _this.cols();
-      _this.derived().m_storage.conservativeResize(other.size(), other.rows(), other.cols());
-      if (new_rows > 0)
-        _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
-      else if (new_cols > 0)
-        _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
-    } else {
-      // The storage order does not allow us to use reallocation.
-      Derived tmp(other);
-      const Index common_rows = numext::mini(tmp.rows(), _this.rows());
-      const Index common_cols = numext::mini(tmp.cols(), _this.cols());
-      tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
-      _this.derived().swap(tmp);
+    EIGEN_IF_CONSTEXPR (IsRelocatable) {
+      if ((Derived::IsRowMajor && _this.cols() == other.cols()) ||  // row-major and we change only the number of rows
+          (!Derived::IsRowMajor &&
+           _this.rows() == other.rows()))  // column-major and we change only the number of columns
+      {
+        const Index new_rows = other.rows() - _this.rows();
+        const Index new_cols = other.cols() - _this.cols();
+        _this.derived().m_storage.conservativeResize(other.size(), other.rows(), other.cols());
+        if (new_rows > 0)
+          _this.bottomRightCorner(new_rows, other.cols()) = other.bottomRows(new_rows);
+        else if (new_cols > 0)
+          _this.bottomRightCorner(other.rows(), new_cols) = other.rightCols(new_cols);
+        return;
+      }
     }
+
+    // The storage order does not allow us to use reallocation.
+    Derived tmp(other);
+    const Index common_rows = numext::mini(tmp.rows(), _this.rows());
+    const Index common_cols = numext::mini(tmp.cols(), _this.cols());
+    tmp.block(0, 0, common_rows, common_cols) = _this.block(0, 0, common_rows, common_cols);
+    _this.derived().swap(tmp);
   }
 };
 
@@ -961,14 +974,14 @@
 template <typename Derived, typename OtherDerived>
 struct conservative_resize_like_impl<Derived, OtherDerived, true>
     : conservative_resize_like_impl<Derived, OtherDerived, false> {
-  typedef conservative_resize_like_impl<Derived, OtherDerived, false> Base;
+  using Base = conservative_resize_like_impl<Derived, OtherDerived, false>;
   using Base::IsRelocatable;
   using Base::run;
 
   static void run(DenseBase<Derived>& _this, Index size) {
     const Index new_rows = Derived::RowsAtCompileTime == 1 ? 1 : size;
     const Index new_cols = Derived::RowsAtCompileTime == 1 ? size : 1;
-    if (IsRelocatable)
+    EIGEN_IF_CONSTEXPR (IsRelocatable)
       _this.derived().m_storage.conservativeResize(size, new_rows, new_cols);
     else
       Base::run(_this.derived(), new_rows, new_cols);
@@ -981,7 +994,7 @@
 
     const Index new_rows = Derived::RowsAtCompileTime == 1 ? 1 : other.rows();
     const Index new_cols = Derived::RowsAtCompileTime == 1 ? other.cols() : 1;
-    if (IsRelocatable)
+    EIGEN_IF_CONSTEXPR (IsRelocatable)
       _this.derived().m_storage.conservativeResize(other.size(), new_rows, new_cols);
     else
       Base::run(_this.derived(), new_rows, new_cols);
diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h
index bc8b9da..8c56014 100644
--- a/Eigen/src/Core/Product.h
+++ b/Eigen/src/Core/Product.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PRODUCT_H
 #define EIGEN_PRODUCT_H
@@ -22,19 +23,19 @@
 
 template <typename Lhs, typename Rhs, int Option>
 struct traits<Product<Lhs, Rhs, Option>> {
-  typedef remove_all_t<Lhs> LhsCleaned;
-  typedef remove_all_t<Rhs> RhsCleaned;
-  typedef traits<LhsCleaned> LhsTraits;
-  typedef traits<RhsCleaned> RhsTraits;
+  using LhsCleaned = remove_all_t<Lhs>;
+  using RhsCleaned = remove_all_t<Rhs>;
+  using LhsTraits = traits<LhsCleaned>;
+  using RhsTraits = traits<RhsCleaned>;
 
-  typedef MatrixXpr XprKind;
+  using XprKind = MatrixXpr;
 
-  typedef typename ScalarBinaryOpTraits<typename traits<LhsCleaned>::Scalar,
-                                        typename traits<RhsCleaned>::Scalar>::ReturnType Scalar;
-  typedef typename product_promote_storage_type<typename LhsTraits::StorageKind, typename RhsTraits::StorageKind,
-                                                internal::product_type<Lhs, Rhs>::ret>::ret StorageKind;
-  typedef typename promote_index_type<typename LhsTraits::StorageIndex, typename RhsTraits::StorageIndex>::type
-      StorageIndex;
+  using Scalar = typename ScalarBinaryOpTraits<typename LhsTraits::Scalar, typename RhsTraits::Scalar>::ReturnType;
+  using StorageKind =
+      typename product_promote_storage_type<typename LhsTraits::StorageKind, typename RhsTraits::StorageKind,
+                                            internal::product_type<Lhs, Rhs>::value>::ret;
+  using StorageIndex =
+      typename promote_index_type<typename LhsTraits::StorageIndex, typename RhsTraits::StorageIndex>::type;
 
   enum {
     RowsAtCompileTime = LhsTraits::RowsAtCompileTime,
@@ -199,22 +200,22 @@
     : public ProductImpl<Lhs_, Rhs_, Option,
                          typename internal::product_promote_storage_type<
                              typename internal::traits<Lhs_>::StorageKind, typename internal::traits<Rhs_>::StorageKind,
-                             internal::product_type<Lhs_, Rhs_>::ret>::ret> {
+                             internal::product_type<Lhs_, Rhs_>::value>::ret> {
  public:
-  typedef Lhs_ Lhs;
-  typedef Rhs_ Rhs;
+  using Lhs = Lhs_;
+  using Rhs = Rhs_;
 
-  typedef
+  using Base =
       typename ProductImpl<Lhs, Rhs, Option,
                            typename internal::product_promote_storage_type<
                                typename internal::traits<Lhs>::StorageKind, typename internal::traits<Rhs>::StorageKind,
-                               internal::product_type<Lhs, Rhs>::ret>::ret>::Base Base;
+                               internal::product_type<Lhs, Rhs>::value>::ret>::Base;
   EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
 
-  typedef typename internal::ref_selector<Lhs>::type LhsNested;
-  typedef typename internal::ref_selector<Rhs>::type RhsNested;
-  typedef internal::remove_all_t<LhsNested> LhsNestedCleaned;
-  typedef internal::remove_all_t<RhsNested> RhsNestedCleaned;
+  using LhsNested = typename internal::ref_selector<Lhs>::type;
+  using RhsNested = typename internal::ref_selector<Rhs>::type;
+  using LhsNestedCleaned = internal::remove_all_t<LhsNested>;
+  using RhsNestedCleaned = internal::remove_all_t<RhsNested>;
 
   using TransposeReturnType = typename internal::product_transpose_helper<Lhs, Rhs, Option>::TransposeType;
   using AdjointReturnType = typename internal::product_transpose_helper<Lhs, Rhs, Option>::AdjointType;
@@ -244,19 +245,19 @@
 
 namespace internal {
 
-template <typename Lhs, typename Rhs, int Option, int ProductTag = internal::product_type<Lhs, Rhs>::ret>
+template <typename Lhs, typename Rhs, int Option, int ProductTag = internal::product_type<Lhs, Rhs>::value>
 class dense_product_base : public internal::dense_xpr_base<Product<Lhs, Rhs, Option>>::type {};
 
 /** Conversion to scalar for inner-products */
 template <typename Lhs, typename Rhs, int Option>
 class dense_product_base<Lhs, Rhs, Option, InnerProduct>
     : public internal::dense_xpr_base<Product<Lhs, Rhs, Option>>::type {
-  typedef Product<Lhs, Rhs, Option> ProductXpr;
-  typedef typename internal::dense_xpr_base<ProductXpr>::type Base;
+  using ProductXpr = Product<Lhs, Rhs, Option>;
+  using Base = typename internal::dense_xpr_base<ProductXpr>::type;
 
  public:
   using Base::derived;
-  typedef typename Base::Scalar Scalar;
+  using Scalar = typename Base::Scalar;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE operator const Scalar() const {
     return internal::evaluator<ProductXpr>(derived()).coeff(0, 0);
@@ -269,15 +270,15 @@
 template <typename Lhs, typename Rhs, int Option, typename StorageKind>
 class ProductImpl : public internal::generic_xpr_base<Product<Lhs, Rhs, Option>, MatrixXpr, StorageKind>::type {
  public:
-  typedef typename internal::generic_xpr_base<Product<Lhs, Rhs, Option>, MatrixXpr, StorageKind>::type Base;
+  using Base = typename internal::generic_xpr_base<Product<Lhs, Rhs, Option>, MatrixXpr, StorageKind>::type;
 };
 
 template <typename Lhs, typename Rhs, int Option>
 class ProductImpl<Lhs, Rhs, Option, Dense> : public internal::dense_product_base<Lhs, Rhs, Option> {
-  typedef Product<Lhs, Rhs, Option> Derived;
+  using Derived = Product<Lhs, Rhs, Option>;
 
  public:
-  typedef typename internal::dense_product_base<Lhs, Rhs, Option> Base;
+  using Base = typename internal::dense_product_base<Lhs, Rhs, Option>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
  protected:
   enum {
diff --git a/Eigen/src/Core/ProductEvaluators.h b/Eigen/src/Core/ProductEvaluators.h
index ae860e2..bc32109 100644
--- a/Eigen/src/Core/ProductEvaluators.h
+++ b/Eigen/src/Core/ProductEvaluators.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PRODUCTEVALUATORS_H
 #define EIGEN_PRODUCTEVALUATORS_H
@@ -15,6 +16,13 @@
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
 
+// C4804: unsafe use of type 'bool' in operation. Unavoidable in generic code
+// instantiated with bool scalars (e.g. += and * on bool).
+#if EIGEN_COMP_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4804)
+#endif
+
 namespace Eigen {
 
 namespace internal {
@@ -29,40 +37,74 @@
  */
 template <typename Lhs, typename Rhs, int Options>
 struct evaluator<Product<Lhs, Rhs, Options>> : public product_evaluator<Product<Lhs, Rhs, Options>> {
-  typedef Product<Lhs, Rhs, Options> XprType;
-  typedef product_evaluator<XprType> Base;
+  using XprType = Product<Lhs, Rhs, Options>;
+  using Base = product_evaluator<XprType>;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
-// Catch "scalar * ( A * B )" and transform it to "(A*scalar) * B"
+// A scalar factor cannot be folded into a unit diagonal or a permutation.
+template <typename Lhs, typename Shape = typename evaluator_traits<Lhs>::Shape>
+struct product_can_fold_scalar
+    : bool_constant<std::is_same<Shape, DenseShape>::value || std::is_same<Shape, SparseShape>::value ||
+                    std::is_same<Shape, DiagonalShape>::value || std::is_same<Shape, SelfAdjointShape>::value> {};
+
+template <typename Lhs>
+struct product_can_fold_scalar<Lhs, TriangularShape> : bool_constant<(int(Lhs::Mode) & int(UnitDiag)) == 0> {};
+
+// The lazy selfadjoint/diagonal evaluator would conjugate a folded complex factor.
+template <typename Lhs, typename Rhs>
+struct product_evaluator_can_fold_scalar
+    : bool_constant<product_can_fold_scalar<Lhs>::value &&
+                    !(std::is_same<typename evaluator_traits<Lhs>::Shape, SelfAdjointShape>::value &&
+                      std::is_same<typename evaluator_traits<Rhs>::Shape, DiagonalShape>::value)> {};
+
+template <typename Xpr,
+          bool Fold = product_evaluator_can_fold_scalar<typename Xpr::Rhs::Lhs, typename Xpr::Rhs::Rhs>::value>
+struct scaled_product_evaluator_type {
+  // The assignment kernel extracts selfadjoint factors; materializing also protects nested aliases.
+  using type = std::conditional_t<product_can_fold_scalar<typename Xpr::Rhs::Lhs>::value, evaluator<EvalToTemp<Xpr>>,
+                                  binary_evaluator<Xpr>>;
+};
+
+template <typename Xpr>
+struct scaled_product_evaluator_type<Xpr, true> {
+  using type =
+      evaluator<remove_all_t<decltype((std::declval<Xpr>().lhs().functor().m_other * std::declval<Xpr>().rhs().lhs()) *
+                                      std::declval<Xpr>().rhs().rhs())>>;
+};
+
+// Catch "scalar * ( A * B )" and transform it to "(scalar*A) * B"
 // TODO: we should apply that rule only if that's really helpful
 template <typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
 struct evaluator_assume_aliasing<CwiseBinaryOp<internal::scalar_product_op<Scalar1, Scalar2>,
                                                const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
-                                               const Product<Lhs, Rhs, DefaultProduct>>> {
-  static const bool value = true;
-};
+                                               const Product<Lhs, Rhs, DefaultProduct>>> : std::true_type {};
 template <typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
 struct evaluator<CwiseBinaryOp<internal::scalar_product_op<Scalar1, Scalar2>,
                                const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
                                const Product<Lhs, Rhs, DefaultProduct>>>
-    : public evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1, Lhs, product), Rhs, DefaultProduct>> {
-  typedef CwiseBinaryOp<internal::scalar_product_op<Scalar1, Scalar2>,
-                        const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
-                        const Product<Lhs, Rhs, DefaultProduct>>
-      XprType;
-  typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1, Lhs, product), Rhs, DefaultProduct>> Base;
+    : scaled_product_evaluator_type<CwiseBinaryOp<internal::scalar_product_op<Scalar1, Scalar2>,
+                                                  const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                                                  const Product<Lhs, Rhs, DefaultProduct>>>::type {
+  using XprType = CwiseBinaryOp<internal::scalar_product_op<Scalar1, Scalar2>,
+                                const CwiseNullaryOp<internal::scalar_constant_op<Scalar1>, Plain1>,
+                                const Product<Lhs, Rhs, DefaultProduct>>;
+  using Base = typename scaled_product_evaluator_type<XprType>::type;
 
+  template <bool Fold = product_evaluator_can_fold_scalar<Lhs, Rhs>::value, std::enable_if_t<Fold, int> = 0>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
       : Base(xpr.lhs().functor().m_other * xpr.rhs().lhs() * xpr.rhs().rhs()) {}
+
+  template <bool Fold = product_evaluator_can_fold_scalar<Lhs, Rhs>::value, std::enable_if_t<!Fold, int> = 0>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
 template <typename Lhs, typename Rhs, int DiagIndex>
 struct evaluator<Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex>>
     : public evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>> {
-  typedef Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> XprType;
-  typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>> Base;
+  using XprType = Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex>;
+  using Base = evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>>;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
       : Base(Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>(
@@ -78,18 +120,16 @@
 struct generic_product_impl;
 
 template <typename Lhs, typename Rhs>
-struct evaluator_assume_aliasing<Product<Lhs, Rhs, DefaultProduct>> {
-  static const bool value = true;
-};
+struct evaluator_assume_aliasing<Product<Lhs, Rhs, DefaultProduct>> : std::true_type {};
 
 // This is the default evaluator implementation for products:
 // It creates a temporary and call generic_product_impl
 template <typename Lhs, typename Rhs, int Options, int ProductTag, typename LhsShape, typename RhsShape>
 struct product_evaluator<Product<Lhs, Rhs, Options>, ProductTag, LhsShape, RhsShape>
     : public evaluator<typename Product<Lhs, Rhs, Options>::PlainObject> {
-  typedef Product<Lhs, Rhs, Options> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = Product<Lhs, Rhs, Options>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit product_evaluator(const XprType& xpr)
@@ -123,7 +163,7 @@
 template <typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
 struct Assignment<DstXprType, Product<Lhs, Rhs, Options>, internal::assign_op<Scalar, Scalar>, Dense2Dense,
                   std::enable_if_t<(Options == DefaultProduct || Options == AliasFreeProduct)>> {
-  typedef Product<Lhs, Rhs, Options> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, Options>;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src,
                                                         const internal::assign_op<Scalar, Scalar>&) {
     Index dstRows = src.rows();
@@ -138,7 +178,7 @@
 template <typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
 struct Assignment<DstXprType, Product<Lhs, Rhs, Options>, internal::add_assign_op<Scalar, Scalar>, Dense2Dense,
                   std::enable_if_t<(Options == DefaultProduct || Options == AliasFreeProduct)>> {
-  typedef Product<Lhs, Rhs, Options> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, Options>;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src,
                                                         const internal::add_assign_op<Scalar, Scalar>&) {
     eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
@@ -151,7 +191,7 @@
 template <typename DstXprType, typename Lhs, typename Rhs, int Options, typename Scalar>
 struct Assignment<DstXprType, Product<Lhs, Rhs, Options>, internal::sub_assign_op<Scalar, Scalar>, Dense2Dense,
                   std::enable_if_t<(Options == DefaultProduct || Options == AliasFreeProduct)>> {
-  typedef Product<Lhs, Rhs, Options> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, Options>;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src,
                                                         const internal::sub_assign_op<Scalar, Scalar>&) {
     eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
@@ -169,11 +209,10 @@
                   CwiseBinaryOp<internal::scalar_product_op<ScalarBis, Scalar>,
                                 const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>, Plain>,
                                 const Product<Lhs, Rhs, DefaultProduct>>,
-                  AssignFunc, Dense2Dense> {
-  typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis, Scalar>,
-                        const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>, Plain>,
-                        const Product<Lhs, Rhs, DefaultProduct>>
-      SrcXprType;
+                  AssignFunc, Dense2Dense, std::enable_if_t<product_can_fold_scalar<Lhs>::value>> {
+  using SrcXprType = CwiseBinaryOp<internal::scalar_product_op<ScalarBis, Scalar>,
+                                   const CwiseNullaryOp<internal::scalar_constant_op<ScalarBis>, Plain>,
+                                   const Product<Lhs, Rhs, DefaultProduct>>;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src,
                                                         const AssignFunc& func) {
     call_assignment_no_alias(dst, (src.lhs().functor().m_other * src.rhs().lhs()) * src.rhs().rhs(), func);
@@ -189,18 +228,14 @@
     CwiseBinaryOp<
         internal::scalar_sum_op<typename OtherXpr::Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>,
         const OtherXpr, const Product<Lhs, Rhs, DefaultProduct>>,
-    DenseShape> {
-  static const bool value = true;
-};
+    DenseShape> : std::true_type {};
 
 template <typename OtherXpr, typename Lhs, typename Rhs>
 struct evaluator_assume_aliasing<
     CwiseBinaryOp<
         internal::scalar_difference_op<typename OtherXpr::Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>,
         const OtherXpr, const Product<Lhs, Rhs, DefaultProduct>>,
-    DenseShape> {
-  static const bool value = true;
-};
+    DenseShape> : std::true_type {};
 
 template <typename DstXprType, typename OtherXpr, typename ProductType, typename Func1, typename Func2>
 struct assignment_from_xpr_op_product {
@@ -235,7 +270,7 @@
 
 template <typename Lhs, typename Rhs>
 struct generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, InnerProduct> {
-  using impl = default_inner_product_impl<Lhs, Rhs, false>;
+  using impl = inner_product_dispatch<Lhs, Rhs, false>;
   template <typename Dst>
   static EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
     dst.coeffRef(0, 0) = impl::run(lhs, rhs);
@@ -259,7 +294,7 @@
 // Column major result
 template <typename Dst, typename Lhs, typename Rhs, typename Func>
 void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Func& func,
-                                                  const false_type&) {
+                                                  const std::false_type&) {
   evaluator<Rhs> rhsEval(rhs);
   ei_declare_local_nested_eval(Lhs, lhs, Rhs::SizeAtCompileTime, actual_lhs);
   // FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored
@@ -271,7 +306,7 @@
 // Row major result
 template <typename Dst, typename Lhs, typename Rhs, typename Func>
 void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Func& func,
-                                                  const true_type&) {
+                                                  const std::true_type&) {
   evaluator<Lhs> lhsEval(lhs);
   ei_declare_local_nested_eval(Rhs, rhs, Lhs::SizeAtCompileTime, actual_rhs);
   // FIXME if rows is large enough, then it might be useful to make sure that rhs is sequentially stored
@@ -280,11 +315,46 @@
   for (Index i = 0; i < rows; ++i) func(dst.row(i), lhsEval.coeff(i, Index(0)) * actual_rhs);
 }
 
+template <typename Dst>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool outer_product_use_small_assignment(const Dst& dst) {
+  return dst.rows() <= 16 && dst.cols() <= 16;
+}
+
+template <typename Dst, typename Lhs, typename Rhs, typename Func, typename Scalar>
+void EIGEN_DEVICE_FUNC outer_product_selector_run_small(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Func& func,
+                                                        const Scalar& alpha, const std::false_type&) {
+  evaluator<Rhs> rhsEval(rhs);
+  ei_declare_local_nested_eval(Lhs, lhs, Rhs::SizeAtCompileTime, actual_lhs);
+  const Index rows = dst.rows();
+  const Index cols = dst.cols();
+  for (Index j = 0; j < cols; ++j) {
+    const Scalar rhs_j = rhsEval.coeff(Index(0), j);
+    for (Index i = 0; i < rows; ++i) {
+      func.assignCoeff(dst.coeffRef(i, j), alpha * (rhs_j * actual_lhs.coeff(i, Index(0))));
+    }
+  }
+}
+
+template <typename Dst, typename Lhs, typename Rhs, typename Func, typename Scalar>
+void EIGEN_DEVICE_FUNC outer_product_selector_run_small(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Func& func,
+                                                        const Scalar& alpha, const std::true_type&) {
+  evaluator<Lhs> lhsEval(lhs);
+  ei_declare_local_nested_eval(Rhs, rhs, Lhs::SizeAtCompileTime, actual_rhs);
+  const Index rows = dst.rows();
+  const Index cols = dst.cols();
+  for (Index i = 0; i < rows; ++i) {
+    const Scalar lhs_i = lhsEval.coeff(i, Index(0));
+    for (Index j = 0; j < cols; ++j) {
+      func.assignCoeff(dst.coeffRef(i, j), alpha * (lhs_i * actual_rhs.coeff(Index(0), j)));
+    }
+  }
+}
+
 template <typename Lhs, typename Rhs>
 struct generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, OuterProduct> {
   template <typename T>
   struct is_row_major : bool_constant<(int(T::Flags) & RowMajorBit)> {};
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   // TODO: it would be nice to be able to exploit our *_assign_op functors for that purpose
   struct set {
@@ -310,7 +380,7 @@
   struct adds {
     Scalar m_scale;
     /** Constructor */
-    explicit adds(const Scalar& s) : m_scale(s) {}
+    EIGEN_DEVICE_FUNC explicit adds(const Scalar& s) : m_scale(s) {}
     /** Scaled add to dst. */
     template <typename Dst, typename Src>
     void EIGEN_DEVICE_FUNC operator()(const Dst& dst, const Src& src) const {
@@ -320,30 +390,50 @@
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
-    internal::outer_product_selector_run(dst, lhs, rhs, set(), is_row_major<Dst>());
+    if (internal::outer_product_use_small_assignment(dst)) {
+      internal::outer_product_selector_run_small(dst, lhs, rhs, internal::assign_op<typename Dst::Scalar, Scalar>(),
+                                                 Scalar(1), is_row_major<Dst>());
+    } else {
+      internal::outer_product_selector_run(dst, lhs, rhs, set(), is_row_major<Dst>());
+    }
   }
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
-    internal::outer_product_selector_run(dst, lhs, rhs, add(), is_row_major<Dst>());
+    if (internal::outer_product_use_small_assignment(dst)) {
+      internal::outer_product_selector_run_small(dst, lhs, rhs, internal::add_assign_op<typename Dst::Scalar, Scalar>(),
+                                                 Scalar(1), is_row_major<Dst>());
+    } else {
+      internal::outer_product_selector_run(dst, lhs, rhs, add(), is_row_major<Dst>());
+    }
   }
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
-    internal::outer_product_selector_run(dst, lhs, rhs, sub(), is_row_major<Dst>());
+    if (internal::outer_product_use_small_assignment(dst)) {
+      internal::outer_product_selector_run_small(dst, lhs, rhs, internal::sub_assign_op<typename Dst::Scalar, Scalar>(),
+                                                 Scalar(1), is_row_major<Dst>());
+    } else {
+      internal::outer_product_selector_run(dst, lhs, rhs, sub(), is_row_major<Dst>());
+    }
   }
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs,
                                                                   const Scalar& alpha) {
-    internal::outer_product_selector_run(dst, lhs, rhs, adds(alpha), is_row_major<Dst>());
+    if (internal::outer_product_use_small_assignment(dst)) {
+      internal::outer_product_selector_run_small(dst, lhs, rhs, internal::add_assign_op<typename Dst::Scalar, Scalar>(),
+                                                 alpha, is_row_major<Dst>());
+    } else {
+      internal::outer_product_selector_run(dst, lhs, rhs, adds(alpha), is_row_major<Dst>());
+    }
   }
 };
 
 // This base class provides default implementations for evalTo, addTo, subTo, in terms of scaleAndAddTo
 template <typename Lhs, typename Rhs, typename Derived>
 struct generic_product_impl_base {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
@@ -371,11 +461,11 @@
 template <typename Lhs, typename Rhs>
 struct generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, GemvProduct>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, GemvProduct>> {
-  typedef typename nested_eval<Lhs, 1>::type LhsNested;
-  typedef typename nested_eval<Rhs, 1>::type RhsNested;
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using LhsNested = typename nested_eval<Lhs, 1>::type;
+  using RhsNested = typename nested_eval<Rhs, 1>::type;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
   enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight };
-  typedef internal::remove_all_t<std::conditional_t<int(Side) == OnTheRight, LhsNested, RhsNested>> MatrixType;
+  using MatrixType = internal::remove_all_t<std::conditional_t<int(Side) == OnTheRight, LhsNested, RhsNested>>;
 
   template <typename Dest>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs,
@@ -394,27 +484,192 @@
   }
 };
 
+// Packet-cascade assignment for small fixed-size coefficient-based products
+// (dst = / += / -= lhs * rhs). The generic assignment path types the product's
+// packet via find_best_packet -- the widest packet that *exactly divides* the
+// vectorized extent, leaving no tail. For odd/non-power-of-two extents that
+// overshoots: with no exact divisor it falls back to a narrow packet, or all
+// the way to scalars (e.g. 3x3 double becomes scalar, ~3x slower than it needs
+// to be). find_largest_packet instead picks the widest packet that *fits*
+// (size <= extent) and we emit an explicit cascade -- full packet(s), then the
+// half packet, ... then a scalar tail -- so e.g. 3x3 double does one Packet2d
+// plus one scalar per column, and 6x6 double does one Packet4d plus one Packet2d
+// instead of three Packet2d. See find_largest_packet in XprHelper.h.
+
+// Emit the inner segment [begin, end) for a single outer index, cascading from
+// `Packet` down through its half packets to a scalar tail. `ColMajor` selects
+// whether the contiguous inner index is the row (true) or the column (false).
+// The bool `Terminal` partial specialization stops the recursion at the
+// narrowest packet without requiring C++17 `if constexpr`.
+template <typename Packet, bool ColMajor,
+          bool Terminal = std::is_same<typename unpacket_traits<Packet>::half, Packet>::value>
+struct product_packet_cascade {
+  template <typename Func, typename Dst, typename ProdEval>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Func& func, Dst& dst, const ProdEval& prod, Index outer,
+                                                        Index begin, Index end) {
+    constexpr int PacketSize = unpacket_traits<Packet>::size;
+    Index pktEnd = begin + numext::round_down(end - begin, PacketSize);
+    Index i = begin;
+    for (; i < pktEnd; i += PacketSize) {
+      Index r = ColMajor ? i : outer, c = ColMajor ? outer : i;
+      func.template assignPacket<Unaligned, Packet>(&dst.coeffRef(r, c), prod.template packet<Unaligned, Packet>(r, c));
+    }
+    // Fall back to the half packet for the remainder [i, end).
+    product_packet_cascade<typename unpacket_traits<Packet>::half, ColMajor>::run(func, dst, prod, outer, i, end);
+  }
+};
+
+// Narrowest packet in the chain: lay down its full packets, then a scalar tail.
+template <typename Packet, bool ColMajor>
+struct product_packet_cascade<Packet, ColMajor, /*Terminal=*/true> {
+  template <typename Func, typename Dst, typename ProdEval>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Func& func, Dst& dst, const ProdEval& prod, Index outer,
+                                                        Index begin, Index end) {
+    constexpr int PacketSize = unpacket_traits<Packet>::size;
+    Index pktEnd = begin + numext::round_down(end - begin, PacketSize);
+    Index i = begin;
+    for (; i < pktEnd; i += PacketSize) {
+      Index r = ColMajor ? i : outer, c = ColMajor ? outer : i;
+      func.template assignPacket<Unaligned, Packet>(&dst.coeffRef(r, c), prod.template packet<Unaligned, Packet>(r, c));
+    }
+    for (; i < end; ++i) {
+      Index r = ColMajor ? i : outer, c = ColMajor ? outer : i;
+      func.assignCoeff(dst.coeffRef(r, c), prod.coeff(r, c));
+    }
+  }
+};
+
+// Largest packet size in the (halving) chain that *exactly divides* Size, or 1
+// if none does. This is what the generic InnerVectorized assignment path can
+// actually use -- unlike find_best_packet, whose stop condition returns the
+// terminal (non-dividing) packet when the chain bottoms out above size 1 (on
+// x86 the chain ends at Packet2d / Packet4f, not a size-1 packet), so e.g.
+// find_best_packet<double,3> reports Packet2d even though 3 % 2 != 0.
+template <typename Packet, int Size,
+          bool Terminal = std::is_same<typename unpacket_traits<Packet>::half, Packet>::value>
+struct largest_exact_divisor_size {  // recurse into the narrower half packet
+  static constexpr int s = unpacket_traits<Packet>::size;
+  static constexpr int value =
+      (Size % s == 0) ? s : largest_exact_divisor_size<typename unpacket_traits<Packet>::half, Size>::value;
+};
+template <typename Packet, int Size>
+struct largest_exact_divisor_size<Packet, Size, /*Terminal=*/true> {  // narrowest packet in the chain
+  static constexpr int s = unpacket_traits<Packet>::size;
+  static constexpr int value = (Size % s == 0) ? s : 1;
+};
+
+// When is the cascade worth diverging from the generic assignment path, and
+// along which axis? Only for fixed-size products where the widest packet that
+// fits the vectorized extent (find_largest_packet) is strictly wider than the
+// widest that exactly divides it -- i.e. the extent is not a clean packet
+// multiple, so the generic path is forced down to a narrower packet or scalars.
+// Exact-fit sizes (2, 4, 8, ...) keep the proven generic path, as do dynamic
+// sizes (GEMM / generic kernels) and extents too small to hold even one packet
+// (e.g. 3-row float). Complex is included: the generic path scalarizes odd
+// extents (find_best<complex<double>,3> == Packet1cd), so the cascade's
+// Packet2cd/Packet4cf tail is a sizeable win there too.
+//
+// The destination must also store the vectorized axis contiguously
+// (InnerStrideAtCompileTime == 1): the cascade writes whole packets with a
+// single contiguous store, so a strided destination such as `m.row(i)` of a
+// column-major matrix would clobber neighbouring coefficients. The generic
+// assignment path makes this same packet-access check on the destination; here
+// we must replicate it since we bypass that path.
+template <typename ProdEval, typename Dst>
+struct product_packet_cascade_traits {
+  using Scalar = typename ProdEval::Scalar;
+  static constexpr int Rows = ProdEval::RowsAtCompileTime;
+  static constexpr int Cols = ProdEval::ColsAtCompileTime;
+  static constexpr bool DstRowMajor = bool(Dst::IsRowMajor);
+  static constexpr bool DstContiguous = int(Dst::InnerStrideAtCompileTime) == 1;
+  // Orientation of the packets the product evaluator natively produces. When a
+  // product can vectorize *both* the lhs (columns) and the rhs (rows), its
+  // packet() returns column packets (EvalToRowMajor == 0). The cascade axis must
+  // match this orientation -- and the destination's storage order must match it
+  // too, so the contiguous packet store lands on contiguous coefficients.
+  static constexpr bool ProdRowMajor = (int(ProdEval::Flags) & RowMajorBit) != 0;
+  static constexpr bool VecLhs =  // column-major product & dst: vectorize down each column
+      bool(ProdEval::CanVectorizeLhs) && !ProdRowMajor && !DstRowMajor && Rows != Dynamic;
+  static constexpr bool VecRhs =  // row-major product & dst: vectorize along each row
+      bool(ProdEval::CanVectorizeRhs) && ProdRowMajor && DstRowMajor && Cols != Dynamic;
+  static constexpr int Extent = VecLhs ? Rows : VecRhs ? Cols : 1;
+  using Packet = typename find_largest_packet<Scalar, Extent>::type;
+  static constexpr int LargestSize = unpacket_traits<Packet>::size;
+  static constexpr int GenericSize = largest_exact_divisor_size<typename packet_traits<Scalar>::type, Extent>::value;
+  // SameType mirrors the product's own PacketAccessBit (SameType && (CanVectorizeLhs ||
+  // CanVectorizeRhs)): CanVectorizeLhs/Rhs alone test only the operand's packet access, so a
+  // mixed-scalar product (e.g. double * complex) would otherwise enable the cascade and try to
+  // read the wrong-width packet out of an operand. Mixed types keep the generic (scalar) path.
+  static constexpr bool Enable = bool(ProdEval::SameType) && (VecLhs || VecRhs) && DstContiguous &&
+                                 (LargestSize <= Extent) && (LargestSize > GenericSize);
+};
+
+// Run the cascade over every outer index of dst. Traits::VecLhs is a compile-time
+// constant, so it folds the bounds away and selects the cascade's ColMajor axis,
+// instantiating only the active orientation (no dead branch on either axis).
+template <typename Traits, typename Func, typename Dst, typename ProdEval>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void product_run_packet_cascade(const Func& func, Dst& dst,
+                                                                      const ProdEval& prod) {
+  using Packet = typename Traits::Packet;
+  Index rows = dst.rows(), cols = dst.cols();
+  Index outerCount = Traits::VecLhs ? cols : rows;
+  Index innerEnd = Traits::VecLhs ? rows : cols;
+  for (Index outer = 0; outer < outerCount; ++outer)
+    product_packet_cascade<Packet, Traits::VecLhs>::run(func, dst, prod, outer, 0, innerEnd);
+}
+
+// Compound product assignment: take the packet cascade when the traits enable
+// it, otherwise the generic assignment path. Dispatch on a bool tag (rather than
+// a plain `if`) so the cascade is only *instantiated* for the vectorizable
+// fixed-size case -- a runtime branch would instantiate it for every product,
+// including scalar types with no packet support.
+template <typename Func, typename Dst, typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void product_packet_assign(std::true_type, const Func& func, Dst& dst,
+                                                                 const Lhs& lhs, const Rhs& rhs) {
+  using ProdEval = product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape>;
+  using Traits = product_packet_cascade_traits<ProdEval, Dst>;
+  const ProdEval prodEval(lhs, rhs);
+  product_run_packet_cascade<Traits>(func, dst, prodEval);
+}
+template <typename Func, typename Dst, typename Lhs, typename Rhs>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void product_packet_assign(std::false_type, const Func& func, Dst& dst,
+                                                                 const Lhs& lhs, const Rhs& rhs) {
+  call_assignment_no_alias(dst, lhs.lazyProduct(rhs), func);
+}
+
 template <typename Lhs, typename Rhs>
 struct generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
     // Same as: dst.noalias() = lhs.lazyProduct(rhs);
-    // but easier on the compiler side
+    // but easier on the compiler side.
+    // NB: unlike addTo/subTo below, plain assignment stays on the generic path.
+    // The packet cascade is a measured win for the compound (+=, -=) case, but
+    // for plain assignment the generic InnerVectorized path is already well
+    // tuned -- the cascade was at best neutral there and could regress float
+    // (whose packet half-chain bottoms out at Packet4f, so odd-size tails fall
+    // to scalars). See product_packet_cascade_traits.
     call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::assign_op<typename Dst::Scalar, Scalar>());
   }
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
     // dst.noalias() += lhs.lazyProduct(rhs);
-    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::add_assign_op<typename Dst::Scalar, Scalar>());
+    using ProdEval = product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape>;
+    using Traits = product_packet_cascade_traits<ProdEval, Dst>;
+    product_packet_assign(bool_constant<Traits::Enable>(), internal::add_assign_op<typename Dst::Scalar, Scalar>(), dst,
+                          lhs, rhs);
   }
 
   template <typename Dst>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
     // dst.noalias() -= lhs.lazyProduct(rhs);
-    call_assignment_no_alias(dst, lhs.lazyProduct(rhs), internal::sub_assign_op<typename Dst::Scalar, Scalar>());
+    using ProdEval = product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape>;
+    using Traits = product_packet_cascade_traits<ProdEval, Dst>;
+    product_packet_assign(bool_constant<Traits::Enable>(), internal::sub_assign_op<typename Dst::Scalar, Scalar>(), dst,
+                          lhs, rhs);
   }
 
   // This is a special evaluation path called from generic_product_impl<...,GemmProduct> in file GeneralMatrixMatrix.h
@@ -439,7 +694,7 @@
       ConjLhs = blas_traits<Lhs>::NeedToConjugate,
       ConjRhs = blas_traits<Rhs>::NeedToConjugate
     };
-    // FIXME: in c++11 this should be auto, and extractScalarFactor should also return auto
+    // FIXME: this should be auto, and extractScalarFactor should also return auto
     //        this is important for real*complex_mat
     Scalar actualAlpha = combine_scalar_factors<Scalar>(lhs, rhs);
 
@@ -452,7 +707,7 @@
   template <typename Dst, typename LhsT, typename RhsT, typename Func, typename Scalar>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void eval_dynamic_impl(Dst& dst, const LhsT& lhs, const RhsT& rhs,
                                                                       const Func& func, const Scalar& s /* == 1 */,
-                                                                      false_type) {
+                                                                      std::false_type) {
     EIGEN_UNUSED_VARIABLE(s);
     eigen_internal_assert(numext::is_exactly_one(s));
     call_restricted_packet_assignment_no_alias(dst, lhs.lazyProduct(rhs), func);
@@ -460,7 +715,8 @@
 
   template <typename Dst, typename LhsT, typename RhsT, typename Func, typename Scalar>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void eval_dynamic_impl(Dst& dst, const LhsT& lhs, const RhsT& rhs,
-                                                                      const Func& func, const Scalar& s, true_type) {
+                                                                      const Func& func, const Scalar& s,
+                                                                      std::true_type) {
     call_restricted_packet_assignment_no_alias(dst, s * lhs.lazyProduct(rhs), func);
   }
 };
@@ -470,33 +726,32 @@
 struct generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, LazyCoeffBasedProductMode>
     : generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode> {};
 
-// Case 2: Evaluate coeff by coeff
-//
-// This is mostly taken from CoeffBasedProduct.h
-// The main difference is that we add an extra argument to the etor_product_*_impl::run() function
-// for the inner dimension of the product, because evaluator object do not know their size.
-
-template <int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
-struct etor_product_coeff_impl;
-
 template <int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
 struct etor_product_packet_impl;
 
+struct product_empty_packet_evaluator {
+  template <typename Xpr>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit product_empty_packet_evaluator(const Xpr&) {}
+};
+
 template <typename Lhs, typename Rhs, int ProductTag>
 struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, DenseShape>
     : evaluator_base<Product<Lhs, Rhs, LazyProduct>> {
-  typedef Product<Lhs, Rhs, LazyProduct> XprType;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using XprType = Product<Lhs, Rhs, LazyProduct>;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit product_evaluator(const XprType& xpr)
-      : m_lhs(xpr.lhs()),
-        m_rhs(xpr.rhs()),
-        m_lhsImpl(m_lhs),  // FIXME the creation of the evaluator objects should result in a no-op, but check that!
-        m_rhsImpl(m_rhs),  //       Moreover, they are only useful for the packet path, so we could completely disable
-                           //       them when not needed, or perhaps declare them on the fly on the packet method... We
-                           //       have experiment to check what's best.
-        m_innerDim(xpr.lhs().cols()) {
+      : product_evaluator(xpr.lhs(), xpr.rhs()) {}
+
+  // Also construct directly from the product operands so packet-cascade callers
+  // do not have to materialize a temporary Product expression first.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE product_evaluator(const Lhs& lhs, const Rhs& rhs)
+      : m_lhs(lhs),
+        m_rhs(rhs),
+        m_lhsImpl(m_lhs),  // Real evaluator objects for packet products; empty placeholders for scalar-only products.
+        m_rhsImpl(m_rhs),
+        m_innerDim(lhs.cols()) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
     EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::AddCost);
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
@@ -504,14 +759,17 @@
 
   // Everything below here is taken from CoeffBasedProduct.h
 
-  typedef typename internal::nested_eval<Lhs, Rhs::ColsAtCompileTime>::type LhsNested;
-  typedef typename internal::nested_eval<Rhs, Lhs::RowsAtCompileTime>::type RhsNested;
+  using LhsNested = typename internal::nested_eval<Lhs, Rhs::ColsAtCompileTime>::type;
+  using RhsNested = typename internal::nested_eval<Rhs, Lhs::RowsAtCompileTime>::type;
 
-  typedef internal::remove_all_t<LhsNested> LhsNestedCleaned;
-  typedef internal::remove_all_t<RhsNested> RhsNestedCleaned;
+  using LhsNestedCleaned = internal::remove_all_t<LhsNested>;
+  using RhsNestedCleaned = internal::remove_all_t<RhsNested>;
 
-  typedef evaluator<LhsNestedCleaned> LhsEtorType;
-  typedef evaluator<RhsNestedCleaned> RhsEtorType;
+  using LhsScalar = typename LhsNestedCleaned::Scalar;
+  using RhsScalar = typename RhsNestedCleaned::Scalar;
+
+  using LhsEtorType = evaluator<LhsNestedCleaned>;
+  using RhsEtorType = evaluator<RhsNestedCleaned>;
 
   enum {
     RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime,
@@ -521,79 +779,86 @@
     MaxColsAtCompileTime = RhsNestedCleaned::MaxColsAtCompileTime
   };
 
-  typedef typename find_best_packet<Scalar, RowsAtCompileTime>::type LhsVecPacketType;
-  typedef typename find_best_packet<Scalar, ColsAtCompileTime>::type RhsVecPacketType;
+  using LhsVecPacketType = typename find_best_packet<Scalar, RowsAtCompileTime>::type;
+  using RhsVecPacketType = typename find_best_packet<Scalar, ColsAtCompileTime>::type;
 
-  enum {
+  static constexpr int LhsCoeffReadCost = LhsEtorType::CoeffReadCost;
+  static constexpr int RhsCoeffReadCost = RhsEtorType::CoeffReadCost;
+  static constexpr int CoeffReadCost =
+      InnerSize == 0 ? NumTraits<Scalar>::ReadCost
+      : InnerSize == Dynamic
+          ? HugeCost
+          : InnerSize * (NumTraits<Scalar>::MulCost + int(LhsCoeffReadCost) + int(RhsCoeffReadCost)) +
+                (InnerSize - 1) * NumTraits<Scalar>::AddCost;
 
-    LhsCoeffReadCost = LhsEtorType::CoeffReadCost,
-    RhsCoeffReadCost = RhsEtorType::CoeffReadCost,
-    CoeffReadCost = InnerSize == 0 ? NumTraits<Scalar>::ReadCost
-                    : InnerSize == Dynamic
-                        ? HugeCost
-                        : InnerSize * (NumTraits<Scalar>::MulCost + int(LhsCoeffReadCost) + int(RhsCoeffReadCost)) +
-                              (InnerSize - 1) * NumTraits<Scalar>::AddCost,
+  static constexpr bool Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT;
 
-    Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT,
+  static constexpr int LhsFlags = LhsEtorType::Flags;
+  static constexpr int RhsFlags = RhsEtorType::Flags;
 
-    LhsFlags = LhsEtorType::Flags,
-    RhsFlags = RhsEtorType::Flags,
+  static constexpr int LhsRowMajor = LhsFlags & RowMajorBit;
+  static constexpr int RhsRowMajor = RhsFlags & RowMajorBit;
 
-    LhsRowMajor = LhsFlags & RowMajorBit,
-    RhsRowMajor = RhsFlags & RowMajorBit,
+  static constexpr int LhsVecPacketSize = unpacket_traits<LhsVecPacketType>::size;
+  static constexpr int RhsVecPacketSize = unpacket_traits<RhsVecPacketType>::size;
 
-    LhsVecPacketSize = unpacket_traits<LhsVecPacketType>::size,
-    RhsVecPacketSize = unpacket_traits<RhsVecPacketType>::size,
+  // Here, we don't care about alignment larger than the usable packet size.
+  static constexpr int LhsAlignment =
+      plain_enum_min(LhsEtorType::Alignment, LhsVecPacketSize* int(sizeof(typename LhsNestedCleaned::Scalar)));
+  static constexpr int RhsAlignment =
+      plain_enum_min(RhsEtorType::Alignment, RhsVecPacketSize* int(sizeof(typename RhsNestedCleaned::Scalar)));
 
-    // Here, we don't care about alignment larger than the usable packet size.
-    LhsAlignment =
-        plain_enum_min(LhsEtorType::Alignment, LhsVecPacketSize* int(sizeof(typename LhsNestedCleaned::Scalar))),
-    RhsAlignment =
-        plain_enum_min(RhsEtorType::Alignment, RhsVecPacketSize* int(sizeof(typename RhsNestedCleaned::Scalar))),
+  static constexpr bool SameType =
+      std::is_same<typename LhsNestedCleaned::Scalar, typename RhsNestedCleaned::Scalar>::value;
 
-    SameType = is_same<typename LhsNestedCleaned::Scalar, typename RhsNestedCleaned::Scalar>::value,
+  static constexpr bool CanVectorizeRhs = bool(RhsRowMajor) && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime != 1);
+  static constexpr bool CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime != 1);
 
-    CanVectorizeRhs = bool(RhsRowMajor) && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime != 1),
-    CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime != 1),
+  static constexpr int EvalToRowMajor = (MaxRowsAtCompileTime == 1 && MaxColsAtCompileTime != 1) ? 1
+                                        : (MaxColsAtCompileTime == 1 && MaxRowsAtCompileTime != 1)
+                                            ? 0
+                                            : (bool(RhsRowMajor) && !CanVectorizeLhs);
 
-    EvalToRowMajor = (MaxRowsAtCompileTime == 1 && MaxColsAtCompileTime != 1) ? 1
-                     : (MaxColsAtCompileTime == 1 && MaxRowsAtCompileTime != 1)
-                         ? 0
-                         : (bool(RhsRowMajor) && !CanVectorizeLhs),
+  static constexpr int Flags = ((int(LhsFlags) | int(RhsFlags)) & HereditaryBits & ~RowMajorBit) |
+                               (EvalToRowMajor ? RowMajorBit : 0)
+                               // TODO: enable vectorization for mixed types
+                               | (SameType && (CanVectorizeLhs || CanVectorizeRhs) ? PacketAccessBit : 0) |
+                               (XprType::IsVectorAtCompileTime ? LinearAccessBit : 0);
+  using LhsPacketEtorType =
+      std::conditional_t<bool(int(Flags) & PacketAccessBit), LhsEtorType, product_empty_packet_evaluator>;
+  using RhsPacketEtorType =
+      std::conditional_t<bool(int(Flags) & PacketAccessBit), RhsEtorType, product_empty_packet_evaluator>;
 
-    Flags = ((int(LhsFlags) | int(RhsFlags)) & HereditaryBits & ~RowMajorBit) |
-            (EvalToRowMajor ? RowMajorBit : 0)
-            // TODO: enable vectorization for mixed types
-            | (SameType && (CanVectorizeLhs || CanVectorizeRhs) ? PacketAccessBit : 0) |
-            (XprType::IsVectorAtCompileTime ? LinearAccessBit : 0),
+  static constexpr int LhsOuterStrideBytes =
+      int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar));
+  static constexpr int RhsOuterStrideBytes =
+      int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar));
 
-    LhsOuterStrideBytes =
-        int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar)),
-    RhsOuterStrideBytes =
-        int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar)),
+  static constexpr int Alignment =
+      bool(CanVectorizeLhs)
+          ? (LhsOuterStrideBytes <= 0 || (int(LhsOuterStrideBytes) % plain_enum_max(1, LhsAlignment)) != 0
+                 ? 0
+                 : LhsAlignment)
+      : bool(CanVectorizeRhs)
+          ? (RhsOuterStrideBytes <= 0 || (int(RhsOuterStrideBytes) % plain_enum_max(1, RhsAlignment)) != 0
+                 ? 0
+                 : RhsAlignment)
+          : 0;
 
-    Alignment = bool(CanVectorizeLhs)
-                    ? (LhsOuterStrideBytes <= 0 || (int(LhsOuterStrideBytes) % plain_enum_max(1, LhsAlignment)) != 0
-                           ? 0
-                           : LhsAlignment)
-                : bool(CanVectorizeRhs)
-                    ? (RhsOuterStrideBytes <= 0 || (int(RhsOuterStrideBytes) % plain_enum_max(1, RhsAlignment)) != 0
-                           ? 0
-                           : RhsAlignment)
-                    : 0,
-
-    /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside
-     * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner
-     * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect
-     * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI.
-     */
-    CanVectorizeInner = SameType && LhsRowMajor && (!RhsRowMajor) &&
-                        (int(LhsFlags) & int(RhsFlags) & ActualPacketAccessBit) &&
-                        (int(InnerSize) % packet_traits<Scalar>::size == 0)
-  };
+  /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside
+   * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner
+   * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect
+   * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI.
+   */
+  static constexpr bool CanVectorizeInner = SameType && LhsRowMajor && (!RhsRowMajor) &&
+                                            (int(LhsFlags) & int(RhsFlags) & ActualPacketAccessBit) &&
+                                            (int(InnerSize) % packet_traits<Scalar>::size == 0);
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index row, Index col) const {
-    return (m_lhs.row(row).transpose().cwiseProduct(m_rhs.col(col))).sum();
+    // fast_mult_op is cwiseProduct's scalar_product_op with a pmul-based scalar path, so the
+    // reduction (and its precision) is unchanged but complex scalars avoid std::complex::operator*
+    // (the slow libgcc __mul?c3). See fast_mult_op.
+    return m_lhs.row(row).transpose().binaryExpr(m_rhs.col(col), fast_mult_op<LhsScalar, RhsScalar>()).sum();
   }
 
   /* Allow index-based non-packet access. It is impossible though to allow index-based packed access,
@@ -603,15 +868,15 @@
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index index) const {
     const Index row = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime == 1) ? 0 : index;
     const Index col = (RowsAtCompileTime == 1 || MaxRowsAtCompileTime == 1) ? index : 0;
-    return (m_lhs.row(row).transpose().cwiseProduct(m_rhs.col(col))).sum();
+    return m_lhs.row(row).transpose().binaryExpr(m_rhs.col(col), fast_mult_op<LhsScalar, RhsScalar>()).sum();
   }
 
   template <int LoadMode, typename PacketType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packet(Index row, Index col) const {
     PacketType res;
-    typedef etor_product_packet_impl<bool(int(Flags) & RowMajorBit) ? RowMajor : ColMajor,
-                                     Unroll ? int(InnerSize) : Dynamic, LhsEtorType, RhsEtorType, PacketType, LoadMode>
-        PacketImpl;
+    using PacketImpl =
+        etor_product_packet_impl<bool(int(Flags) & RowMajorBit) ? RowMajor : ColMajor,
+                                 Unroll ? int(InnerSize) : Dynamic, LhsEtorType, RhsEtorType, PacketType, LoadMode>;
     PacketImpl::run(row, col, m_lhsImpl, m_rhsImpl, m_innerDim, res);
     return res;
   }
@@ -627,9 +892,9 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packetSegment(Index row, Index col, Index begin,
                                                                        Index count) const {
     PacketType res;
-    typedef etor_product_packet_impl<bool(int(Flags) & RowMajorBit) ? RowMajor : ColMajor,
-                                     Unroll ? int(InnerSize) : Dynamic, LhsEtorType, RhsEtorType, PacketType, LoadMode>
-        PacketImpl;
+    using PacketImpl =
+        etor_product_packet_impl<bool(int(Flags) & RowMajorBit) ? RowMajor : ColMajor,
+                                 Unroll ? int(InnerSize) : Dynamic, LhsEtorType, RhsEtorType, PacketType, LoadMode>;
     PacketImpl::run_segment(row, col, m_lhsImpl, m_rhsImpl, m_innerDim, res, begin, count);
     return res;
   }
@@ -645,19 +910,18 @@
   add_const_on_value_type_t<LhsNested> m_lhs;
   add_const_on_value_type_t<RhsNested> m_rhs;
 
-  LhsEtorType m_lhsImpl;
-  RhsEtorType m_rhsImpl;
+  LhsPacketEtorType m_lhsImpl;
+  RhsPacketEtorType m_rhsImpl;
 
-  // TODO: Get rid of m_innerDim if known at compile time
-  Index m_innerDim;
+  variable_if_dynamic<Index, InnerSize> m_innerDim;
 };
 
 template <typename Lhs, typename Rhs>
 struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, LazyCoeffBasedProductMode, DenseShape, DenseShape>
     : product_evaluator<Product<Lhs, Rhs, LazyProduct>, CoeffBasedProductMode, DenseShape, DenseShape> {
-  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
-  typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
-  typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape, DenseShape> Base;
+  using XprType = Product<Lhs, Rhs, DefaultProduct>;
+  using BaseProduct = Product<Lhs, Rhs, LazyProduct>;
+  using Base = product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape, DenseShape>;
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit product_evaluator(const XprType& xpr)
       : Base(BaseProduct(xpr.lhs(), xpr.rhs())) {}
@@ -797,10 +1061,95 @@
 template <int Mode, bool LhsIsTriangular, typename Lhs, bool LhsIsVector, typename Rhs, bool RhsIsVector>
 struct triangular_product_impl;
 
+template <int ProductOrder>
+struct diagonal_product_segment_impl;
+
+template <>
+struct diagonal_product_segment_impl<OnTheLeft> {
+  template <typename DstSegment, typename Coeffs, typename DiagonalType, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstSegment& dst, const Coeffs& coeffs,
+                                                        const DiagonalType& diagonal, Index begin, Index /*col*/,
+                                                        const Alpha& alpha) {
+    dst += alpha * diagonal.segment(begin, dst.size()).cwiseProduct(coeffs);
+  }
+  template <typename DstSegment, typename Coeffs, typename DiagonalType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void runOverwrite(DstSegment& dst, const Coeffs& coeffs,
+                                                                 const DiagonalType& diagonal, Index begin,
+                                                                 Index /*col*/) {
+    dst = diagonal.segment(begin, dst.size()).cwiseProduct(coeffs);
+  }
+};
+
+template <>
+struct diagonal_product_segment_impl<OnTheRight> {
+  template <typename DstSegment, typename Coeffs, typename DiagonalType, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstSegment& dst, const Coeffs& coeffs,
+                                                        const DiagonalType& diagonal, Index /*begin*/, Index col,
+                                                        const Alpha& alpha) {
+    dst += alpha * (coeffs * diagonal.coeff(col));
+  }
+  template <typename DstSegment, typename Coeffs, typename DiagonalType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void runOverwrite(DstSegment& dst, const Coeffs& coeffs,
+                                                                 const DiagonalType& diagonal, Index /*begin*/,
+                                                                 Index col) {
+    dst = coeffs * diagonal.coeff(col);
+  }
+};
+
+template <int Mode, int ProductOrder, typename MatrixType, typename DiagonalType>
+struct triangular_diagonal_product_impl {
+  using MatrixScalar = typename MatrixType::Scalar;
+
+  template <typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const MatrixType& matrix,
+                                                        const DiagonalType& diagonal, const Alpha& alpha) {
+    eigen_assert(((ProductOrder == OnTheLeft && diagonal.size() == matrix.rows()) ||
+                  (ProductOrder == OnTheRight && diagonal.size() == matrix.cols())) &&
+                 "invalid matrix product");
+
+    const Index rows = matrix.rows();
+    const Index cols = matrix.cols();
+    for (Index col = 0; col < cols; ++col) {
+      EIGEN_IF_CONSTEXPR ((Mode & Upper) == Upper) {
+        const Index end = (std::min)(rows, ((Mode & (UnitDiag | ZeroDiag)) ? col : col + 1));
+        addStoredSegment(dst, matrix, diagonal, 0, end, col, alpha);
+      } else {
+        const Index begin = ((Mode & (UnitDiag | ZeroDiag)) ? col + 1 : col);
+        addStoredSegment(dst, matrix, diagonal, begin, rows - begin, col, alpha);
+      }
+
+      EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == UnitDiag) {
+        if (col < rows) addUnitCoeff(dst, diagonal, col, alpha);
+      }
+    }
+  }
+
+ private:
+  template <typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addStoredSegment(Dest& dst, const MatrixType& matrix,
+                                                                     const DiagonalType& diagonal, Index begin,
+                                                                     Index size, Index col, const Alpha& alpha) {
+    if (size <= 0) return;
+    auto dstSegment = dst.col(col).segment(begin, size);
+    diagonal_product_segment_impl<ProductOrder>::run(dstSegment, matrix.col(col).segment(begin, size), diagonal, begin,
+                                                     col, alpha);
+  }
+
+  template <typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void addUnitCoeff(Dest& dst, const DiagonalType& diagonal, Index index,
+                                                                 const Alpha& alpha) {
+    EIGEN_IF_CONSTEXPR (ProductOrder == OnTheLeft) {
+      dst.coeffRef(index, index) += alpha * (diagonal.coeff(index) * MatrixScalar(1));
+    } else {
+      dst.coeffRef(index, index) += alpha * (MatrixScalar(1) * diagonal.coeff(index));
+    }
+  }
+};
+
 template <typename Lhs, typename Rhs, int ProductTag>
 struct generic_product_impl<Lhs, Rhs, TriangularShape, DenseShape, ProductTag>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, TriangularShape, DenseShape, ProductTag>> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
@@ -812,7 +1161,7 @@
 template <typename Lhs, typename Rhs, int ProductTag>
 struct generic_product_impl<Lhs, Rhs, DenseShape, TriangularShape, ProductTag>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DenseShape, TriangularShape, ProductTag>> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
@@ -821,16 +1170,178 @@
   }
 };
 
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, TriangularShape, DiagonalShape, ProductTag>
+    : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, TriangularShape, DiagonalShape, ProductTag>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs,
+                                                                  const Scalar& alpha) {
+    triangular_diagonal_product_impl<Lhs::Mode, OnTheRight, typename Lhs::MatrixType,
+                                     typename Rhs::DiagonalVectorType>::run(dst, lhs.nestedExpression(), rhs.diagonal(),
+                                                                            alpha);
+  }
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, DiagonalShape, TriangularShape, ProductTag>
+    : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DiagonalShape, TriangularShape, ProductTag>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs,
+                                                                  const Scalar& alpha) {
+    triangular_diagonal_product_impl<Rhs::Mode, OnTheLeft, typename Rhs::MatrixType,
+                                     typename Lhs::DiagonalVectorType>::run(dst, rhs.nestedExpression(), lhs.diagonal(),
+                                                                            alpha);
+  }
+};
+
 /***************************************************************************
  * SelfAdjoint products
  ***************************************************************************/
 template <typename Lhs, int LhsMode, bool LhsIsVector, typename Rhs, int RhsMode, bool RhsIsVector>
 struct selfadjoint_product_impl;
 
+template <int Mode, int ProductOrder, typename MatrixType, typename DiagonalType>
+struct selfadjoint_diagonal_product_impl {
+  // Accumulating: dst += alpha * (matrix.selfadjointView<Mode>() * diagonal[asDiagonal])
+  // (with the diagonal on the right or left as ProductOrder dictates).
+  template <typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const MatrixType& matrix,
+                                                        const DiagonalType& diagonal, const Alpha& alpha) {
+    runImpl<true>(dst, matrix, diagonal, alpha);
+  }
+
+  // Overwriting: dst = matrix.selfadjointView<Mode>() * diagonal[asDiagonal].
+  // Each output entry is written exactly once, so the caller can skip the
+  // dst.setZero() pass that generic_product_impl_base::evalTo would do.
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void runOverwrite(Dest& dst, const MatrixType& matrix,
+                                                                 const DiagonalType& diagonal) {
+    using Scalar = typename traits<MatrixType>::Scalar;
+    runImpl<false>(dst, matrix, diagonal, Scalar(1));
+  }
+
+ private:
+  // Tile size for the blocked mirror pass. Tuned so that one BlockSize x
+  // BlockSize source tile fits comfortably in L1 across common scalar / SIMD
+  // combinations: 32x32 of double = 8 KB, of complex<double> = 16 KB, both
+  // well under typical 32 KB L1. Smaller tiles leave SIMD work on the table
+  // for AVX/AVX-512; larger tiles spill out of L1 on machines with smaller
+  // caches.
+  static constexpr Index BlockSize = 32;
+
+  // The mirror half writes the strict-other-triangle of dst. The naive
+  // per-column form reads matrix.row(col).segment(...) which has stride =
+  // leading dimension, so on an N x N source it streams cold cache lines.
+  // We walk the mirror in BlockSize x BlockSize tiles instead: off-diagonal
+  // tiles use a blocked conjugate-transpose, and the small diagonal tile
+  // falls back to the per-column row-strided loop where the working set is
+  // L1-hot.
+  template <bool Accumulate, typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void runImpl(Dest& dst, const MatrixType& matrix,
+                                                            const DiagonalType& diagonal, const Alpha& alpha) {
+    eigen_assert(matrix.rows() == matrix.cols() && "SelfAdjointView is only for squared matrices");
+    eigen_assert(diagonal.size() == matrix.rows() && "invalid matrix product");
+
+    const Index size = matrix.rows();
+
+    // Stored half: one column-strided segment per output column.
+    for (Index col = 0; col < size; ++col) {
+      EIGEN_IF_CONSTEXPR ((Mode & Upper) == Upper) {
+        storedSegment<Accumulate>(dst, matrix, diagonal, 0, col + 1, col, alpha);
+      } else {
+        storedSegment<Accumulate>(dst, matrix, diagonal, col, size - col, col, alpha);
+      }
+    }
+
+    // Mirror half.
+    for (Index ib = 0; ib < size; ib += BlockSize) {
+      const Index ib_end = numext::mini(size, ib + BlockSize);
+      const Index br = ib_end - ib;
+      EIGEN_IF_CONSTEXPR ((Mode & Upper) == Upper) {
+        // Off-diagonal: write strict-lower of dst from strict-upper of source.
+        for (Index jb = 0; jb < ib; jb += BlockSize) {
+          const Index bc = numext::mini(jb + BlockSize, ib) - jb;
+          mirrorBlock<Accumulate>(dst, matrix, diagonal, ib, jb, br, bc, alpha);
+        }
+        // Diagonal tile: in-tile strict-lower mirror.
+        for (Index col = ib; col < ib_end; ++col)
+          conjugateSegment<Accumulate>(dst, matrix, diagonal, col + 1, ib_end - col - 1, col, alpha);
+      } else {
+        // Off-diagonal: write strict-upper of dst from strict-lower of source.
+        for (Index jb = ib_end; jb < size; jb += BlockSize) {
+          const Index bc = numext::mini(size, jb + BlockSize) - jb;
+          mirrorBlock<Accumulate>(dst, matrix, diagonal, ib, jb, br, bc, alpha);
+        }
+        // Diagonal tile: in-tile strict-upper mirror.
+        for (Index col = ib; col < ib_end; ++col)
+          conjugateSegment<Accumulate>(dst, matrix, diagonal, ib, col - ib, col, alpha);
+      }
+    }
+  }
+
+  template <bool Accumulate, typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void storedSegment(Dest& dst, const MatrixType& matrix,
+                                                                  const DiagonalType& diagonal, Index begin, Index size,
+                                                                  Index col, const Alpha& alpha) {
+    if (size <= 0) return;
+    auto dstSegment = dst.col(col).segment(begin, size);
+    auto srcSegment = matrix.col(col).segment(begin, size);
+    EIGEN_IF_CONSTEXPR (Accumulate) {
+      diagonal_product_segment_impl<ProductOrder>::run(dstSegment, srcSegment, diagonal, begin, col, alpha);
+    } else {
+      diagonal_product_segment_impl<ProductOrder>::runOverwrite(dstSegment, srcSegment, diagonal, begin, col);
+    }
+  }
+
+  template <bool Accumulate, typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void conjugateSegment(Dest& dst, const MatrixType& matrix,
+                                                                     const DiagonalType& diagonal, Index begin,
+                                                                     Index size, Index col, const Alpha& alpha) {
+    if (size <= 0) return;
+    auto dstSegment = dst.col(col).segment(begin, size);
+    auto srcSegment = matrix.row(col).segment(begin, size).conjugate().transpose();
+    EIGEN_IF_CONSTEXPR (Accumulate) {
+      diagonal_product_segment_impl<ProductOrder>::run(dstSegment, srcSegment, diagonal, begin, col, alpha);
+    } else {
+      diagonal_product_segment_impl<ProductOrder>::runOverwrite(dstSegment, srcSegment, diagonal, begin, col);
+    }
+  }
+
+  // dst.block(ib, jb, br, bc) [+= alpha *] matrix.block(jb, ib, bc, br).adjoint() * <diag>,
+  // where <diag> scales each output column (OnTheRight) or row (OnTheLeft).
+  // Loop bounds in runImpl guarantee br > 0 && bc > 0.
+  template <bool Accumulate, typename Dest, typename Alpha>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void mirrorBlock(Dest& dst, const MatrixType& matrix,
+                                                                const DiagonalType& diagonal, Index ib, Index jb,
+                                                                Index br, Index bc, const Alpha& alpha) {
+    auto dstBlock = dst.block(ib, jb, br, bc);
+    auto srcAdjoint = matrix.block(jb, ib, bc, br).adjoint();
+    EIGEN_IF_CONSTEXPR (ProductOrder == OnTheRight) {
+      auto scaled = srcAdjoint * diagonal.segment(jb, bc).asDiagonal();
+      EIGEN_IF_CONSTEXPR (Accumulate) {
+        dstBlock += alpha * scaled;
+      } else {
+        dstBlock = scaled;
+      }
+    } else {
+      auto scaled = diagonal.segment(ib, br).asDiagonal() * srcAdjoint;
+      EIGEN_IF_CONSTEXPR (Accumulate) {
+        dstBlock += alpha * scaled;
+      } else {
+        dstBlock = scaled;
+      }
+    }
+  }
+};
+
 template <typename Lhs, typename Rhs, int ProductTag>
 struct generic_product_impl<Lhs, Rhs, SelfAdjointShape, DenseShape, ProductTag>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, SelfAdjointShape, DenseShape, ProductTag>> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dest>
   static EIGEN_DEVICE_FUNC void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
@@ -842,7 +1353,7 @@
 template <typename Lhs, typename Rhs, int ProductTag>
 struct generic_product_impl<Lhs, Rhs, DenseShape, SelfAdjointShape, ProductTag>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DenseShape, SelfAdjointShape, ProductTag>> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
@@ -851,13 +1362,183 @@
   }
 };
 
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, SelfAdjointShape, DiagonalShape, ProductTag>
+    : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, SelfAdjointShape, DiagonalShape, ProductTag>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  // The "Dense ?= scalar * Product" rewriting rule folds an outer alpha into the
+  // SelfAdjointView via SelfAdjointView::operator*(scalar), whose nested
+  // expression becomes (matrix * alpha). For complex alpha this is no longer
+  // Hermitian — the mirror half of our kernel would produce conj(alpha) on the
+  // off-triangle. Strip the scalar factor with blas_traits and re-fold it into
+  // the kernel's alpha so the same scalar multiplies every output entry.
+  using LhsBlasTraits = blas_traits<typename Lhs::MatrixType>;
+  using ActualLhsMatrix = decltype(LhsBlasTraits::extract(std::declval<const typename Lhs::MatrixType&>())
+                                       .template conjugateIf<bool(LhsBlasTraits::NeedToConjugate)>());
+  using ActualLhsMatrixType = remove_all_t<ActualLhsMatrix>;
+  using Kernel =
+      selfadjoint_diagonal_product_impl<Lhs::Mode, OnTheRight, ActualLhsMatrixType, typename Rhs::DiagonalVectorType>;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ActualLhsMatrix actualLhsMatrix(const typename Lhs::MatrixType& matrix) {
+    return LhsBlasTraits::extract(matrix).template conjugateIf<bool(LhsBlasTraits::NeedToConjugate)>();
+  }
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
+    EIGEN_IF_CONSTEXPR (LhsBlasTraits::HasScalarFactor) {
+      // Folded scalar factor present: zero dst then accumulate at the extracted alpha.
+      Scalar factor = LhsBlasTraits::extractScalarFactor(lhs.nestedExpression());
+      dst.setZero();
+      Kernel::run(dst, actualLhsMatrix(lhs.nestedExpression()), rhs.diagonal(), factor);
+    } else {
+      // No scalar factor: kernel writes every entry exactly once, skip setZero.
+      Kernel::runOverwrite(dst, actualLhsMatrix(lhs.nestedExpression()), rhs.diagonal());
+    }
+  }
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs,
+                                                                  const Scalar& alpha) {
+    Scalar combinedAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs.nestedExpression());
+    Kernel::run(dst, actualLhsMatrix(lhs.nestedExpression()), rhs.diagonal(), combinedAlpha);
+  }
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, DiagonalShape, SelfAdjointShape, ProductTag>
+    : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DiagonalShape, SelfAdjointShape, ProductTag>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  // See note on the SelfAdjointShape, DiagonalShape specialization above for why
+  // we extract the scalar factor with blas_traits.
+  using RhsBlasTraits = blas_traits<typename Rhs::MatrixType>;
+  using ActualRhsMatrix = decltype(RhsBlasTraits::extract(std::declval<const typename Rhs::MatrixType&>())
+                                       .template conjugateIf<bool(RhsBlasTraits::NeedToConjugate)>());
+  using ActualRhsMatrixType = remove_all_t<ActualRhsMatrix>;
+  using Kernel =
+      selfadjoint_diagonal_product_impl<Rhs::Mode, OnTheLeft, ActualRhsMatrixType, typename Lhs::DiagonalVectorType>;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ActualRhsMatrix actualRhsMatrix(const typename Rhs::MatrixType& matrix) {
+    return RhsBlasTraits::extract(matrix).template conjugateIf<bool(RhsBlasTraits::NeedToConjugate)>();
+  }
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
+    EIGEN_IF_CONSTEXPR (RhsBlasTraits::HasScalarFactor) {
+      Scalar factor = RhsBlasTraits::extractScalarFactor(rhs.nestedExpression());
+      dst.setZero();
+      Kernel::run(dst, actualRhsMatrix(rhs.nestedExpression()), lhs.diagonal(), factor);
+    } else {
+      Kernel::runOverwrite(dst, actualRhsMatrix(rhs.nestedExpression()), lhs.diagonal());
+    }
+  }
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs,
+                                                                  const Scalar& alpha) {
+    Scalar combinedAlpha = alpha * RhsBlasTraits::extractScalarFactor(rhs.nestedExpression());
+    Kernel::run(dst, actualRhsMatrix(rhs.nestedExpression()), lhs.diagonal(), combinedAlpha);
+  }
+};
+
+/***************************************************************************
+ * Products of two triangular or self-adjoint views
+ ***************************************************************************/
+
+/** \internal
+ * Evaluates a triangular or self-adjoint view into a plain matrix as the product kernels read it, and returns
+ * the scalar factor to apply. A factor folded into a self-adjoint view, as in (alpha * A).selfadjointView<Lower>(),
+ * would be conjugated on the mirrored triangle by evalTo, so it is extracted first with blas_traits, exactly as
+ * the SYMM kernel does. A triangular view densifies exactly and returns 1.
+ */
+template <typename View, typename Shape = typename evaluator_traits<View>::Shape>
+struct densified_view_operand {
+  using Scalar = typename View::Scalar;
+  template <typename Dense>
+  static Scalar run(Dense& dense, const View& view) {
+    dense = view;
+    return Scalar(1);
+  }
+};
+
+template <typename View>
+struct densified_view_operand<View, SelfAdjointShape> {
+  using Scalar = typename View::Scalar;
+  using BlasTraits = blas_traits<typename View::MatrixType>;
+  static constexpr unsigned int UpLo = unsigned(int(View::Mode) & int(Upper | Lower));
+  template <typename Dense>
+  static Scalar run(Dense& dense, const View& view) {
+    dense = BlasTraits::extract(view.nestedExpression())
+                .template conjugateIf<bool(BlasTraits::NeedToConjugate)>()
+                .template selfadjointView<UpLo>();
+    return BlasTraits::extractScalarFactor(view.nestedExpression());
+  }
+};
+
+/** \internal
+ * Products of two views: one factor is evaluated into a plain dense matrix and the product is re-dispatched to
+ * the kernel that keeps the other one structured. The triangular factor is the one kept whenever there is one
+ * (TRMM is n^3/2 where SYMM is n^3), so a self-adjoint view is densified when it meets a triangular one, and
+ * the right factor is densified otherwise. The structure of the result (Upper * Upper is upper triangular) is
+ * not tracked.
+ */
+template <typename Lhs, typename Rhs, typename LhsShape, typename RhsShape, int ProductTag, bool DensifyRhs>
+struct structured_view_product_impl;
+
+template <typename Lhs, typename Rhs, typename LhsShape, typename RhsShape, int ProductTag>
+struct structured_view_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag, true>
+    : generic_product_impl_base<Lhs, Rhs,
+                                structured_view_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag, true>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  using RhsDenseType = typename Rhs::DenseMatrixType;
+
+  template <typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    RhsDenseType rhsDense(rhs.rows(), rhs.cols());
+    const Scalar factor = densified_view_operand<Rhs>::run(rhsDense, rhs);
+    generic_product_impl<Lhs, RhsDenseType, LhsShape, DenseShape, ProductTag>::scaleAndAddTo(dst, lhs, rhsDense,
+                                                                                             alpha * factor);
+  }
+};
+
+template <typename Lhs, typename Rhs, typename LhsShape, typename RhsShape, int ProductTag>
+struct structured_view_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag, false>
+    : generic_product_impl_base<Lhs, Rhs,
+                                structured_view_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag, false>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  using LhsDenseType = typename Lhs::DenseMatrixType;
+
+  template <typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    LhsDenseType lhsDense(lhs.rows(), lhs.cols());
+    const Scalar factor = densified_view_operand<Lhs>::run(lhsDense, lhs);
+    generic_product_impl<LhsDenseType, Rhs, DenseShape, RhsShape, ProductTag>::scaleAndAddTo(dst, lhsDense, rhs,
+                                                                                             alpha * factor);
+  }
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, TriangularShape, TriangularShape, ProductTag>
+    : structured_view_product_impl<Lhs, Rhs, TriangularShape, TriangularShape, ProductTag, true> {};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, TriangularShape, SelfAdjointShape, ProductTag>
+    : structured_view_product_impl<Lhs, Rhs, TriangularShape, SelfAdjointShape, ProductTag, true> {};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, SelfAdjointShape, TriangularShape, ProductTag>
+    : structured_view_product_impl<Lhs, Rhs, SelfAdjointShape, TriangularShape, ProductTag, false> {};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, SelfAdjointShape, SelfAdjointShape, ProductTag>
+    : structured_view_product_impl<Lhs, Rhs, SelfAdjointShape, SelfAdjointShape, ProductTag, true> {};
+
 /***************************************************************************
  * Diagonal products
  ***************************************************************************/
 
 template <typename MatrixType, typename DiagonalType, typename Derived, int ProductOrder>
 struct diagonal_product_evaluator_base : evaluator_base<Derived> {
-  typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar;
+  using Scalar = typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType;
 
  public:
   enum {
@@ -875,7 +1556,7 @@
 
     ScalarAccessOnDiag_ = !((int(StorageOrder_) == ColMajor && int(ProductOrder) == OnTheLeft) ||
                             (int(StorageOrder_) == RowMajor && int(ProductOrder) == OnTheRight)),
-    SameTypes_ = is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value,
+    SameTypes_ = std::is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value,
     // FIXME currently we need same types, but in the future the next rule should be the one
     // Vectorizable_ = bool(int(MatrixFlags)&PacketAccessBit) && ((!_PacketOnDiag) || (SameTypes_ &&
     // bool(int(DiagFlags)&PacketAccessBit))),
@@ -884,8 +1565,8 @@
                     (ScalarAccessOnDiag_ || (bool(int(DiagFlags) & PacketAccessBit))),
     LinearAccessMask_ =
         (MatrixType::RowsAtCompileTime == 1 || MatrixType::ColsAtCompileTime == 1) ? LinearAccessBit : 0,
-    Flags =
-        ((HereditaryBits | LinearAccessMask_) & (unsigned int)(MatrixFlags)) | (Vectorizable_ ? PacketAccessBit : 0),
+    Flags = ((HereditaryBits | LinearAccessMask_) & static_cast<unsigned int>(MatrixFlags)) |
+            (Vectorizable_ ? PacketAccessBit : 0),
     Alignment = evaluator<MatrixType>::Alignment,
 
     AsScalarProduct =
@@ -902,7 +1583,7 @@
   }
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Scalar coeff(Index idx) const {
-    if (AsScalarProduct)
+    EIGEN_IF_CONSTEXPR (AsScalarProduct)
       return m_diagImpl.coeff(0) * m_matImpl.coeff(idx);
     else
       return m_diagImpl.coeff(idx) * m_matImpl.coeff(idx);
@@ -910,18 +1591,19 @@
 
  protected:
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::true_type) const {
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, std::true_type) const {
     return internal::pmul(m_matImpl.template packet<LoadMode, PacketType>(row, col),
                           internal::pset1<PacketType>(m_diagImpl.coeff(id)));
   }
 
   template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::false_type) const {
+  EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, std::false_type) const {
     enum {
       InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
       DiagonalPacketLoadMode = plain_enum_min(
-          LoadMode,
-          ((InnerSize % 16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment))  // FIXME hardcoded 16!!
+          LoadMode, ((InnerSize * int(sizeof(Scalar))) % int(unpacket_traits<PacketType>::alignment) == 0)
+                        ? int(unpacket_traits<PacketType>::alignment)
+                        : int(evaluator<DiagonalType>::Alignment))
     };
     return internal::pmul(m_matImpl.template packet<LoadMode, PacketType>(row, col),
                           m_diagImpl.template packet<DiagonalPacketLoadMode, PacketType>(id));
@@ -929,19 +1611,20 @@
 
   template <int LoadMode, typename PacketType>
   EIGEN_STRONG_INLINE PacketType packet_segment_impl(Index row, Index col, Index id, Index begin, Index count,
-                                                     internal::true_type) const {
+                                                     std::true_type) const {
     return internal::pmul(m_matImpl.template packetSegment<LoadMode, PacketType>(row, col, begin, count),
                           internal::pset1<PacketType>(m_diagImpl.coeff(id)));
   }
 
   template <int LoadMode, typename PacketType>
   EIGEN_STRONG_INLINE PacketType packet_segment_impl(Index row, Index col, Index id, Index begin, Index count,
-                                                     internal::false_type) const {
+                                                     std::false_type) const {
     enum {
       InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
       DiagonalPacketLoadMode = plain_enum_min(
-          LoadMode,
-          ((InnerSize % 16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment))  // FIXME hardcoded 16!!
+          LoadMode, ((InnerSize * int(sizeof(Scalar))) % int(unpacket_traits<PacketType>::alignment) == 0)
+                        ? int(unpacket_traits<PacketType>::alignment)
+                        : int(evaluator<DiagonalType>::Alignment))
     };
     return internal::pmul(m_matImpl.template packetSegment<LoadMode, PacketType>(row, col, begin, count),
                           m_diagImpl.template packetSegment<DiagonalPacketLoadMode, PacketType>(id, begin, count));
@@ -956,17 +1639,15 @@
 struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, DenseShape>
     : diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>,
                                       OnTheLeft> {
-  typedef diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>,
-                                          OnTheLeft>
-      Base;
+  using Base =
+      diagonal_product_evaluator_base<Rhs, typename Lhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>, OnTheLeft>;
   using Base::coeff;
   using Base::m_diagImpl;
   using Base::m_matImpl;
-  typedef typename Base::Scalar Scalar;
+  using Scalar = typename Base::Scalar;
 
-  typedef Product<Lhs, Rhs, ProductKind> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef typename Lhs::DiagonalVectorType DiagonalType;
+  using XprType = Product<Lhs, Rhs, ProductKind>;
+  using PlainObject = typename XprType::PlainObject;
 
   static constexpr int StorageOrder = Base::StorageOrder_;
   using IsRowMajor_t = bool_constant<StorageOrder == RowMajor>;
@@ -1011,16 +1692,15 @@
 struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DenseShape, DiagonalShape>
     : diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>,
                                       OnTheRight> {
-  typedef diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>,
-                                          OnTheRight>
-      Base;
+  using Base = diagonal_product_evaluator_base<Lhs, typename Rhs::DiagonalVectorType, Product<Lhs, Rhs, LazyProduct>,
+                                               OnTheRight>;
   using Base::coeff;
   using Base::m_diagImpl;
   using Base::m_matImpl;
-  typedef typename Base::Scalar Scalar;
+  using Scalar = typename Base::Scalar;
 
-  typedef Product<Lhs, Rhs, ProductKind> XprType;
-  typedef typename XprType::PlainObject PlainObject;
+  using XprType = Product<Lhs, Rhs, ProductKind>;
+  using PlainObject = typename XprType::PlainObject;
 
   static constexpr int StorageOrder = Base::StorageOrder_;
   using IsColMajor_t = bool_constant<StorageOrder == ColMajor>;
@@ -1055,6 +1735,140 @@
 #endif
 };
 
+// Lazy evaluators for triangular/selfadjoint × diagonal products.
+//
+// The triangular-assignment dispatcher in TriangularMatrix.h routes
+// `triangularView() ?= structured * diagonal` through call_triangular_assignment_loop,
+// which constructs an evaluator over the Product expression. Without these
+// specializations, evaluator<Product<TriangularView, Diagonal>> falls back to the
+// default product_evaluator that materializes a full PlainObject — defeating the
+// triangular-aware dispatcher. The kernel reads only the destination's active
+// triangle one coefficient at a time, so a coeff()-only evaluator avoids the
+// temporary at no loss in functionality.
+
+template <int Mode, int ProductOrder, typename MatrixType, typename DiagonalType, typename Derived>
+struct triangular_diagonal_product_lazy_evaluator_base : evaluator_base<Derived> {
+  using Scalar = typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType;
+  using MatrixScalar = typename MatrixType::Scalar;
+
+  enum {
+    CoeffReadCost = int(NumTraits<Scalar>::MulCost) + int(evaluator<MatrixType>::CoeffReadCost) +
+                    int(evaluator<DiagonalType>::CoeffReadCost),
+    Flags = HereditaryBits & static_cast<unsigned int>(evaluator<MatrixType>::Flags),
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC triangular_diagonal_product_lazy_evaluator_base(const MatrixType& mat, const DiagonalType& diag)
+      : m_diagImpl(diag), m_matImpl(mat) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index row, Index col) const {
+    const bool inActive = ((Mode & Upper) == Upper) ? (row <= col) : (row >= col);
+    if (!inActive) return Scalar(0);
+    if (row == col) {
+      EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == UnitDiag) {
+        return ProductOrder == OnTheLeft ? Scalar(m_diagImpl.coeff(row) * MatrixScalar(1))
+                                         : Scalar(MatrixScalar(1) * m_diagImpl.coeff(col));
+      }
+      EIGEN_IF_CONSTEXPR ((Mode & ZeroDiag) == ZeroDiag) return Scalar(0);
+    }
+    return ProductOrder == OnTheLeft ? Scalar(m_diagImpl.coeff(row) * m_matImpl.coeff(row, col))
+                                     : Scalar(m_matImpl.coeff(row, col) * m_diagImpl.coeff(col));
+  }
+
+ protected:
+  evaluator<DiagonalType> m_diagImpl;
+  evaluator<MatrixType> m_matImpl;
+};
+
+// Triangular × Diagonal
+template <typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, TriangularShape, DiagonalShape>
+    : triangular_diagonal_product_lazy_evaluator_base<
+          Lhs::Mode, OnTheRight, typename Lhs::MatrixType, typename Rhs::DiagonalVectorType,
+          product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, TriangularShape, DiagonalShape>> {
+  using XprType = Product<Lhs, Rhs, ProductKind>;
+  using Base = triangular_diagonal_product_lazy_evaluator_base<
+      Lhs::Mode, OnTheRight, typename Lhs::MatrixType, typename Rhs::DiagonalVectorType,
+      product_evaluator<XprType, ProductTag, TriangularShape, DiagonalShape>>;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+      : Base(xpr.lhs().nestedExpression(), xpr.rhs().diagonal()) {}
+};
+
+// Diagonal × Triangular
+template <typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, TriangularShape>
+    : triangular_diagonal_product_lazy_evaluator_base<
+          Rhs::Mode, OnTheLeft, typename Rhs::MatrixType, typename Lhs::DiagonalVectorType,
+          product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, TriangularShape>> {
+  using XprType = Product<Lhs, Rhs, ProductKind>;
+  using Base = triangular_diagonal_product_lazy_evaluator_base<
+      Rhs::Mode, OnTheLeft, typename Rhs::MatrixType, typename Lhs::DiagonalVectorType,
+      product_evaluator<XprType, ProductTag, DiagonalShape, TriangularShape>>;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+      : Base(xpr.rhs().nestedExpression(), xpr.lhs().diagonal()) {}
+};
+
+// Dense SelfAdjointView statically rejects the Upper|Lower mode (only one half is stored), so the
+// off-stored coefficient is always reconstructed by conjugating its mirror.
+template <int Mode, int ProductOrder, typename MatrixType, typename DiagonalType, typename Derived>
+struct selfadjoint_diagonal_product_lazy_evaluator_base : evaluator_base<Derived> {
+  using Scalar = typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType;
+
+  enum {
+    CoeffReadCost = int(NumTraits<Scalar>::MulCost) + int(evaluator<MatrixType>::CoeffReadCost) +
+                    int(evaluator<DiagonalType>::CoeffReadCost),
+    Flags = HereditaryBits & static_cast<unsigned int>(evaluator<MatrixType>::Flags),
+    Alignment = 0
+  };
+
+  EIGEN_DEVICE_FUNC selfadjoint_diagonal_product_lazy_evaluator_base(const MatrixType& mat, const DiagonalType& diag)
+      : m_diagImpl(diag), m_matImpl(mat) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index row, Index col) const {
+    const bool storedHere = ((Mode & Upper) == Upper) ? (row <= col) : (row >= col);
+    const Scalar matCoeff =
+        storedHere ? Scalar(m_matImpl.coeff(row, col)) : Scalar(numext::conj(m_matImpl.coeff(col, row)));
+    return ProductOrder == OnTheLeft ? Scalar(m_diagImpl.coeff(row) * matCoeff)
+                                     : Scalar(matCoeff * m_diagImpl.coeff(col));
+  }
+
+ protected:
+  evaluator<DiagonalType> m_diagImpl;
+  evaluator<MatrixType> m_matImpl;
+};
+
+// SelfAdjoint × Diagonal
+template <typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, SelfAdjointShape, DiagonalShape>
+    : selfadjoint_diagonal_product_lazy_evaluator_base<
+          Lhs::Mode, OnTheRight, typename Lhs::MatrixType, typename Rhs::DiagonalVectorType,
+          product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, SelfAdjointShape, DiagonalShape>> {
+  using XprType = Product<Lhs, Rhs, ProductKind>;
+  using Base = selfadjoint_diagonal_product_lazy_evaluator_base<
+      Lhs::Mode, OnTheRight, typename Lhs::MatrixType, typename Rhs::DiagonalVectorType,
+      product_evaluator<XprType, ProductTag, SelfAdjointShape, DiagonalShape>>;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+      : Base(xpr.lhs().nestedExpression(), xpr.rhs().diagonal()) {}
+};
+
+// Diagonal × SelfAdjoint
+template <typename Lhs, typename Rhs, int ProductKind, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, SelfAdjointShape>
+    : selfadjoint_diagonal_product_lazy_evaluator_base<
+          Rhs::Mode, OnTheLeft, typename Rhs::MatrixType, typename Lhs::DiagonalVectorType,
+          product_evaluator<Product<Lhs, Rhs, ProductKind>, ProductTag, DiagonalShape, SelfAdjointShape>> {
+  using XprType = Product<Lhs, Rhs, ProductKind>;
+  using Base = selfadjoint_diagonal_product_lazy_evaluator_base<
+      Rhs::Mode, OnTheLeft, typename Rhs::MatrixType, typename Lhs::DiagonalVectorType,
+      product_evaluator<XprType, ProductTag, DiagonalShape, SelfAdjointShape>>;
+
+  EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
+      : Base(xpr.rhs().nestedExpression(), xpr.lhs().diagonal()) {}
+};
+
 /***************************************************************************
  * Products with permutation matrices
  ***************************************************************************/
@@ -1062,15 +1876,23 @@
 /** \internal
  * \class permutation_matrix_product
  * Internal helper class implementing the product between a permutation matrix and a matrix.
- * This class is specialized for DenseShape below and for SparseShape in SparseCore/SparsePermutation.h
+ * This class is specialized for DenseShape below and for SparseShape in SparseCore/SparsePermutation.h.
+ * The generic_product_impl cells for PermutationShape accept any operand shape, so the primary template
+ * turns a missing specialization into a static assertion instead of an incomplete-type error.
  */
 template <typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
-struct permutation_matrix_product;
+struct permutation_matrix_product {
+  template <typename Dest, typename PermutationType>
+  static EIGEN_DEVICE_FUNC void run(Dest&, const PermutationType&, const ExpressionType&) {
+    static_assert(std::is_same<ExpressionShape, DenseShape>::value,
+                  "PERMUTATION_PRODUCTS_ARE_NOT_IMPLEMENTED_FOR_THIS_OPERAND_SHAPE");
+  }
+};
 
 template <typename ExpressionType, int Side, bool Transposed>
 struct permutation_matrix_product<ExpressionType, Side, Transposed, DenseShape> {
-  typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
-  typedef remove_all_t<MatrixType> MatrixTypeCleaned;
+  using MatrixType = typename nested_eval<ExpressionType, 1>::type;
+  using MatrixTypeCleaned = remove_all_t<MatrixType>;
 
   template <typename Dest, typename PermutationType>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const PermutationType& perm,
@@ -1079,7 +1901,7 @@
     const Index n = Side == OnTheLeft ? mat.rows() : mat.cols();
     // FIXME we need an is_same for expression that is not sensitive to constness. For instance
     // is_same_xpr<Block<const Matrix>, Block<Matrix> >::value should be true.
-    // if(is_same<MatrixTypeCleaned,Dest>::value && extract_data(dst) == extract_data(mat))
+    // if(std::is_same<MatrixTypeCleaned,Dest>::value && extract_data(dst) == extract_data(mat))
     if (is_same_dense(dst, mat)) {
       // apply the permutation inplace
       Matrix<bool, PermutationType::RowsAtCompileTime, 1, 0, PermutationType::MaxRowsAtCompileTime> mask(perm.size());
@@ -1162,18 +1984,21 @@
 
 /** \internal
  * \class transposition_matrix_product
- * Internal helper class implementing the product between a permutation matrix and a matrix.
+ * Internal helper class implementing the product between a transposition matrix and a matrix.
  */
 template <typename ExpressionType, int Side, bool Transposed, typename ExpressionShape>
 struct transposition_matrix_product {
-  typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
-  typedef remove_all_t<MatrixType> MatrixTypeCleaned;
+  using MatrixType = typename nested_eval<ExpressionType, 1>::type;
+  using MatrixTypeCleaned = remove_all_t<MatrixType>;
 
   template <typename Dest, typename TranspositionType>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(Dest& dst, const TranspositionType& tr,
                                                         const ExpressionType& xpr) {
+    // The in-place row/column swaps below need a dense operand.
+    static_assert(std::is_same<ExpressionShape, DenseShape>::value,
+                  "TRANSPOSITIONS_PRODUCTS_ARE_ONLY_IMPLEMENTED_FOR_DENSE_OPERANDS");
     MatrixType mat(xpr);
-    typedef typename TranspositionType::StorageIndex StorageIndex;
+    using StorageIndex = typename TranspositionType::StorageIndex;
     const Index size = tr.size();
     StorageIndex j = 0;
 
@@ -1181,10 +2006,11 @@
 
     for (Index k = (Transposed ? size - 1 : 0); Transposed ? k >= 0 : k < size; Transposed ? --k : ++k)
       if (Index(j = tr.coeff(k)) != k) {
-        if (Side == OnTheLeft)
+        EIGEN_IF_CONSTEXPR (Side == OnTheLeft) {
           dst.row(k).swap(dst.row(j));
-        else if (Side == OnTheRight)
+        } else EIGEN_IF_CONSTEXPR (Side == OnTheRight) {
           dst.col(k).swap(dst.col(j));
+        }
       }
   }
 };
@@ -1223,14 +2049,15 @@
 
 /***************************************************************************
  * skew symmetric products
- * for now we just call the generic implementation
+ * The 3x3 skew-symmetric operand is densified and the product is re-dispatched on the other
+ * operand's shape, so shapes whose products with a dense matrix are evaluator-only (DiagonalShape)
+ * resolve too.
  ***************************************************************************/
 template <typename Lhs, typename Rhs, int ProductTag, typename MatrixShape>
 struct generic_product_impl<Lhs, Rhs, SkewSymmetricShape, MatrixShape, ProductTag> {
   template <typename Dest>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
-    generic_product_impl<typename Lhs::DenseMatrixType, Rhs, DenseShape, MatrixShape, ProductTag>::evalTo(dst, lhs,
-                                                                                                          rhs);
+    call_assignment_no_alias(dst, typename Lhs::DenseMatrixType(lhs) * rhs);
   }
 };
 
@@ -1238,8 +2065,7 @@
 struct generic_product_impl<Lhs, Rhs, MatrixShape, SkewSymmetricShape, ProductTag> {
   template <typename Dest>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
-    generic_product_impl<Lhs, typename Rhs::DenseMatrixType, MatrixShape, DenseShape, ProductTag>::evalTo(dst, lhs,
-                                                                                                          rhs);
+    call_assignment_no_alias(dst, lhs * typename Rhs::DenseMatrixType(rhs));
   }
 };
 
@@ -1272,4 +2098,8 @@
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_PRODUCT_EVALUATORS_H
+#if EIGEN_COMP_MSVC
+#pragma warning(pop)
+#endif
+
+#endif  // EIGEN_PRODUCTEVALUATORS_H
diff --git a/Eigen/src/Core/Random.h b/Eigen/src/Core/Random.h
index 532ca0e..179be0b 100644
--- a/Eigen/src/Core/Random.h
+++ b/Eigen/src/Core/Random.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RANDOM_H
 #define EIGEN_RANDOM_H
@@ -51,7 +52,7 @@
  * a temporary matrix whenever it is nested in a larger expression. This prevents unexpected
  * behavior with expressions involving random matrices.
  *
- * See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using C++11 random generators.
+ * See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using std random generators.
  *
  * \sa DenseBase::setRandom(), DenseBase::Random(Index), DenseBase::Random()
  */
diff --git a/Eigen/src/Core/RandomImpl.h b/Eigen/src/Core/RandomImpl.h
index 4a622fc..b6c4944 100644
--- a/Eigen/src/Core/RandomImpl.h
+++ b/Eigen/src/Core/RandomImpl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RANDOM_IMPL_H
 #define EIGEN_RANDOM_IMPL_H
@@ -21,6 +22,16 @@
  * Implementation of random                                               *
  ****************************************************************************/
 
+// The SplitMix64 finalizer (Steele, Lea and Flood, "Fast splittable pseudorandom number generators", OOPSLA
+// 2014): a bijection on 64-bit words with full avalanche, Stafford's "Mix13" variant of the MurmurHash3 finalizer.
+// Applied to a Weyl sequence (state += 0x9E3779B97F4A7C15) it is the SplitMix64 generator; applied to a seed plus
+// an index it seeds independent per-index streams.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE numext::uint64_t splitmix64_mix(numext::uint64_t z) {
+  z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;
+  z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;
+  return z ^ (z >> 31);
+}
+
 template <typename Scalar, bool IsComplex, bool IsInteger>
 struct random_default_impl {};
 
@@ -28,24 +39,19 @@
 struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
 
 template <typename Scalar>
-struct random_retval {
-  typedef Scalar type;
-};
-
-template <typename Scalar>
-inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y) {
+inline Scalar random(const Scalar& x, const Scalar& y) {
   return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
 }
 
 template <typename Scalar>
-inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random() {
+inline Scalar random() {
   return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
 }
 
 // TODO: replace or provide alternatives to this, e.g. std::random_device
 struct eigen_random_device {
   using ReturnType = int;
-  static constexpr int Entropy = meta_floor_log2<(unsigned int)(RAND_MAX) + 1>::value;
+  static constexpr int Entropy = floor_log2((unsigned int)(RAND_MAX) + 1);
   static constexpr ReturnType Highest = RAND_MAX;
   static EIGEN_DEVICE_FUNC inline ReturnType run() { return std::rand(); }
 };
@@ -193,7 +199,7 @@
     Scalar randomBits;
     do {
       randomBits = getRandomBits<Scalar>(numRandomBits);
-      // if the random draw is outside [0, range), try again (rejection sampling)
+      // if the random draw is outside [0, range], try again (rejection sampling)
       // in the worst-case scenario, the probability of rejection is: 1/2 - 1/2^numRandomBits < 50%
     } while (randomBits >= count);
     Scalar result = x + randomBits;
@@ -240,12 +246,12 @@
     if (y <= x) return x;
     return run();
   }
-  static EIGEN_DEVICE_FUNC inline bool run() { return getRandomBits<unsigned>(1) ? true : false; }
+  static EIGEN_DEVICE_FUNC inline bool run() { return getRandomBits<unsigned>(1) != 0; }
 };
 
 template <typename Scalar>
 struct random_default_impl<Scalar, true, false> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   using Impl = random_impl<RealScalar>;
   static EIGEN_DEVICE_FUNC inline Scalar run(const Scalar& x, const Scalar& y, int numRandomBits) {
     return Scalar(Impl::run(x.real(), y.real(), numRandomBits), Impl::run(x.imag(), y.imag(), numRandomBits));
diff --git a/Eigen/src/Core/RankRevealingBase.h b/Eigen/src/Core/RankRevealingBase.h
new file mode 100644
index 0000000..45d1393
--- /dev/null
+++ b/Eigen/src/Core/RankRevealingBase.h
@@ -0,0 +1,180 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_RANK_REVEALING_BASE_H
+#define EIGEN_RANK_REVEALING_BASE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \brief CRTP mixin providing threshold management, rank computation, and rank-derived queries
+ *         for rank-revealing decompositions (FullPivLU, ColPivHouseholderQR, FullPivHouseholderQR).
+ *
+ * \tparam Derived the concrete decomposition class (CRTP parameter)
+ *
+ * The derived class must provide:
+ *   - rows(), cols() (inherited from SolverBase)
+ *   - m_isInitialized (bool member, also used by SolverBase)
+ *   - pivotCoeff(Index i) returning the absolute value of the i-th pivot
+ */
+template <typename Derived>
+class RankRevealingBase {
+ public:
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  RankRevealingBase()
+      : m_usePrescribedThreshold(false),
+        m_prescribedThreshold(RealScalar(0)),
+        m_maxpivot(RealScalar(0)),
+        m_nonzero_pivots(0) {}
+
+  /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
+   * which need to determine when pivots are to be considered nonzero. This is not used for the
+   * decomposition itself.
+   *
+   * When it needs to get the threshold value, Eigen calls threshold(). By default, this
+   * uses a formula to automatically determine a reasonable threshold.
+   * Once you have called the present method setThreshold(const RealScalar&),
+   * your value is used instead.
+   *
+   * \param threshold The new value to use as the threshold.
+   *
+   * A pivot will be considered nonzero if its absolute value is strictly greater than
+   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
+   * where maxpivot is the biggest pivot.
+   *
+   * If you want to come back to the default behavior, call setThreshold(Default_t)
+   */
+  Derived& setThreshold(const RealScalar& threshold) {
+    m_usePrescribedThreshold = true;
+    m_prescribedThreshold = threshold;
+    return self();
+  }
+
+  /** Allows to come back to the default behavior, letting Eigen use its default formula for
+   * determining the threshold.
+   *
+   * You should pass the special object Eigen::Default as parameter here.
+   * \code dec.setThreshold(Eigen::Default); \endcode
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  Derived& setThreshold(Default_t) {
+    m_usePrescribedThreshold = false;
+    return self();
+  }
+
+  /** Returns the threshold that will be used by certain methods such as rank().
+   *
+   * See the documentation of setThreshold(const RealScalar&).
+   */
+  RealScalar threshold() const {
+    eigen_assert(self().m_isInitialized || m_usePrescribedThreshold);
+    // Higham's backward error bound: ||ΔA||₂ ≤ c·min(m,n)·u·||A||₂.
+    // The factor of 4 covers the constant c.
+    return m_usePrescribedThreshold
+               ? m_prescribedThreshold
+               : NumTraits<Scalar>::epsilon() * RealScalar(4 * (std::min)(self().rows(), self().cols()));
+  }
+
+  /** \returns the rank of the matrix of which *this is the decomposition.
+   *
+   * \note This method has to determine which pivots should be considered nonzero.
+   *       For that, it uses the threshold value that you can control by calling
+   *       setThreshold(const RealScalar&).
+   */
+  inline Index rank() const {
+    using std::abs;
+    eigen_assert(self().m_isInitialized && "Decomposition is not initialized.");
+    RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
+    Index result = 0;
+    for (Index i = 0; i < m_nonzero_pivots; ++i) result += (self().pivotCoeff(i) > premultiplied_threshold);
+    return result;
+  }
+
+  /** \returns the dimension of the kernel of the matrix of which *this is the decomposition.
+   *
+   * \note This method has to determine which pivots should be considered nonzero.
+   *       For that, it uses the threshold value that you can control by calling
+   *       setThreshold(const RealScalar&).
+   */
+  inline Index dimensionOfKernel() const {
+    eigen_assert(self().m_isInitialized && "Decomposition is not initialized.");
+    return self().cols() - rank();
+  }
+
+  /** \returns true if the matrix of which *this is the decomposition represents an injective
+   *          linear map, i.e. has trivial kernel; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered nonzero.
+   *       For that, it uses the threshold value that you can control by calling
+   *       setThreshold(const RealScalar&).
+   */
+  inline bool isInjective() const {
+    eigen_assert(self().m_isInitialized && "Decomposition is not initialized.");
+    return rank() == self().cols();
+  }
+
+  /** \returns true if the matrix of which *this is the decomposition represents a surjective
+   *          linear map; false otherwise.
+   *
+   * \note This method has to determine which pivots should be considered nonzero.
+   *       For that, it uses the threshold value that you can control by calling
+   *       setThreshold(const RealScalar&).
+   */
+  inline bool isSurjective() const {
+    eigen_assert(self().m_isInitialized && "Decomposition is not initialized.");
+    return rank() == self().rows();
+  }
+
+  /** \returns true if the matrix of which *this is the decomposition is invertible.
+   *
+   * \note This method has to determine which pivots should be considered nonzero.
+   *       For that, it uses the threshold value that you can control by calling
+   *       setThreshold(const RealScalar&).
+   */
+  inline bool isInvertible() const {
+    eigen_assert(self().m_isInitialized && "Decomposition is not initialized.");
+    return isInjective() && isSurjective();
+  }
+
+  /** \returns the number of nonzero pivots in the decomposition.
+   * Here nonzero is meant in the exact sense, not in a fuzzy sense.
+   * So that notion isn't really intrinsically interesting, but it is
+   * still useful when implementing algorithms.
+   *
+   * \sa rank()
+   */
+  inline Index nonzeroPivots() const {
+    eigen_assert(self().m_isInitialized && "Decomposition is not initialized.");
+    return m_nonzero_pivots;
+  }
+
+  /** \returns the absolute value of the biggest pivot, i.e. the biggest
+   *          diagonal coefficient of U (or R).
+   */
+  RealScalar maxPivot() const { return m_maxpivot; }
+
+ protected:
+  bool m_usePrescribedThreshold;
+  RealScalar m_prescribedThreshold;
+  RealScalar m_maxpivot;
+  Index m_nonzero_pivots;
+
+ private:
+  Derived& self() { return static_cast<Derived&>(*this); }
+  const Derived& self() const { return static_cast<const Derived&>(*this); }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_RANK_REVEALING_BASE_H
diff --git a/Eigen/src/Core/RealView.h b/Eigen/src/Core/RealView.h
index 3be5556..f0005e1 100644
--- a/Eigen/src/Core/RealView.h
+++ b/Eigen/src/Core/RealView.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REALVIEW_H
 #define EIGEN_REALVIEW_H
@@ -43,10 +44,10 @@
 
   static constexpr bool ArrayAccess = complex_array_access<ComplexScalar>::value;
   static constexpr int ActualDirectAccessBit = ArrayAccess ? DirectAccessBit : 0;
-  static constexpr int ActualLvaluebit = !std::is_const<Xpr>::value && ArrayAccess ? LvalueBit : 0;
+  static constexpr int ActualLvalueBit = !std::is_const<Xpr>::value && ArrayAccess ? LvalueBit : 0;
   static constexpr int ActualPacketAccessBit = packet_traits<Scalar>::Vectorizable ? PacketAccessBit : 0;
   static constexpr int FlagMask =
-      ActualDirectAccessBit | ActualLvaluebit | ActualPacketAccessBit | HereditaryBits | LinearAccessBit;
+      ActualDirectAccessBit | ActualLvalueBit | ActualPacketAccessBit | HereditaryBits | LinearAccessBit;
   static constexpr int BaseFlags = int(evaluator<Xpr>::Flags) | int(Base::Flags);
   static constexpr int Flags = BaseFlags & FlagMask;
   static constexpr bool IsRowMajor = Flags & RowMajorBit;
@@ -56,8 +57,8 @@
   static constexpr int MaxRowsAtCompileTime = double_size(Base::MaxRowsAtCompileTime, !IsRowMajor);
   static constexpr int MaxColsAtCompileTime = double_size(Base::MaxColsAtCompileTime, IsRowMajor);
   static constexpr int MaxSizeAtCompileTime = size_at_compile_time(MaxRowsAtCompileTime, MaxColsAtCompileTime);
-  static constexpr int OuterStrideAtCompileTime = double_size(outer_stride_at_compile_time<Xpr>::ret, true);
-  static constexpr int InnerStrideAtCompileTime = inner_stride_at_compile_time<Xpr>::ret;
+  static constexpr int OuterStrideAtCompileTime = double_size(outer_stride_at_compile_time<Xpr>::value, true);
+  static constexpr int InnerStrideAtCompileTime = inner_stride_at_compile_time<Xpr>::value;
 };
 
 template <typename Xpr>
@@ -72,7 +73,7 @@
   static constexpr int CoeffReadCost = BaseEvaluator::CoeffReadCost;
   static constexpr int Alignment = BaseEvaluator::Alignment;
   static constexpr bool IsRowMajor = ExpressionTraits::IsRowMajor;
-  static constexpr bool DirectAccess = Flags & DirectAccessBit;
+  static constexpr bool DirectAccess = (Flags & DirectAccessBit) != 0;
 
   using ComplexCoeffReturnType = std::conditional_t<DirectAccess, const ComplexScalar&, ComplexScalar>;
   using CoeffReturnType = std::conditional_t<DirectAccess, const Scalar&, Scalar>;
diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h
index fefb4c9..241ef1f 100644
--- a/Eigen/src/Core/Redux.h
+++ b/Eigen/src/Core/Redux.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REDUX_H
 #define EIGEN_REDUX_H
@@ -26,10 +27,41 @@
  * Part 1 : the logic deciding a strategy for vectorization and unrolling
  ***************************************************************************/
 
+// Bounds used only to exclude unreachable reduction paths. Combining expression
+// storage bounds instead would change PlainObject types and can create oversized inline storage.
+template <typename Xpr>
+struct redux_max_size {
+  static constexpr int Rows = Xpr::MaxRowsAtCompileTime;
+  static constexpr int Cols = Xpr::MaxColsAtCompileTime;
+  static constexpr int Size = Xpr::MaxSizeAtCompileTime;
+};
+
+template <typename Op, typename Lhs, typename Rhs>
+struct redux_max_size<CwiseBinaryOp<Op, Lhs, Rhs>> {
+  using Left = redux_max_size<remove_all_t<Lhs>>;
+  using Right = redux_max_size<remove_all_t<Rhs>>;
+  static constexpr int Rows = min_size_prefer_fixed(Left::Rows, Right::Rows);
+  static constexpr int Cols = min_size_prefer_fixed(Left::Cols, Right::Cols);
+  static constexpr int Size =
+      min_size_prefer_fixed(min_size_prefer_fixed(Left::Size, Right::Size), size_at_compile_time(Rows, Cols));
+};
+
+template <typename Op, typename Arg1, typename Arg2, typename Arg3>
+struct redux_max_size<CwiseTernaryOp<Op, Arg1, Arg2, Arg3>> {
+  using First = redux_max_size<remove_all_t<Arg1>>;
+  using Second = redux_max_size<remove_all_t<Arg2>>;
+  using Third = redux_max_size<remove_all_t<Arg3>>;
+  static constexpr int Rows = min_size_prefer_fixed(First::Rows, min_size_prefer_fixed(Second::Rows, Third::Rows));
+  static constexpr int Cols = min_size_prefer_fixed(First::Cols, min_size_prefer_fixed(Second::Cols, Third::Cols));
+  static constexpr int Size =
+      min_size_prefer_fixed(min_size_prefer_fixed(First::Size, min_size_prefer_fixed(Second::Size, Third::Size)),
+                            size_at_compile_time(Rows, Cols));
+};
+
 template <typename Func, typename Evaluator>
 struct redux_traits {
  public:
-  typedef typename find_best_packet<typename Evaluator::Scalar, Evaluator::SizeAtCompileTime>::type PacketType;
+  using PacketType = typename find_best_packet<typename Evaluator::Scalar, Evaluator::SizeAtCompileTime>::type;
   enum {
     PacketSize = unpacket_traits<PacketType>::size,
     InnerMaxSize = int(Evaluator::IsRowMajor) ? Evaluator::MaxColsAtCompileTime : Evaluator::MaxRowsAtCompileTime,
@@ -99,7 +131,7 @@
 struct redux_novec_unroller {
   static constexpr Index HalfLength = Length / 2;
 
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
   EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func) {
     return func(redux_novec_unroller<Func, Evaluator, Start, HalfLength>::run(eval, func),
@@ -112,7 +144,7 @@
   static constexpr Index outer = Start / Evaluator::InnerSizeAtCompileTime;
   static constexpr Index inner = Start % Evaluator::InnerSizeAtCompileTime;
 
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
   EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func&) {
     return eval.coeffByOuterInner(outer, inner);
@@ -124,7 +156,7 @@
 // for 0 length run() will never be called at all.
 template <typename Func, typename Evaluator, Index Start>
 struct redux_novec_unroller<Func, Evaluator, Start, 0> {
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
   EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Scalar run(const Evaluator&, const Func&) { return Scalar(); }
 };
 
@@ -132,7 +164,7 @@
 struct redux_novec_linear_unroller {
   static constexpr Index HalfLength = Length / 2;
 
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
   EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func) {
     return func(redux_novec_linear_unroller<Func, Evaluator, Start, HalfLength>::run(eval, func),
@@ -142,7 +174,7 @@
 
 template <typename Func, typename Evaluator, Index Start>
 struct redux_novec_linear_unroller<Func, Evaluator, Start, 1> {
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
   EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func&) {
     return eval.coeff(Start);
@@ -154,7 +186,7 @@
 // for 0 length run() will never be called at all.
 template <typename Func, typename Evaluator, Index Start>
 struct redux_novec_linear_unroller<Func, Evaluator, Start, 0> {
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
   EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Scalar run(const Evaluator&, const Func&) { return Scalar(); }
 };
 
@@ -219,30 +251,153 @@
           int Unrolling = redux_traits<Func, Evaluator>::Unrolling>
 struct redux_impl;
 
+// Cutoffs below which the plain serial loop beats the wider unrolled bodies, measured on x86-64
+// with GCC 13 and Clang 18. The linear path serves both contiguous data (vectorizes, profits
+// from ~24) and strided data (loads dominate, profits only from ~64); 32 is where neither side
+// loses measurably.
+constexpr Index kReduxCommutativeCutoff = 32;       // independent accumulators, linear traversal
+constexpr Index kReduxCommutativeInnerCutoff = 16;  // independent accumulators, outer/inner traversal
+// GCC auto-vectorizes the ordered tree through a shuffle network whose setup only amortizes on
+// long runs; Clang keeps it scalar, where the shorter dependency chain pays from small sizes.
+constexpr Index kReduxOrderedTreeCutoff = EIGEN_COMP_GNUC_STRICT ? 192 : 16;
+
 template <typename Func, typename Evaluator>
 struct redux_impl<Func, Evaluator, DefaultTraversal, NoUnrolling> {
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
   template <typename XprType>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func, const XprType& xpr) {
     eigen_assert(xpr.rows() > 0 && xpr.cols() > 0 && "you are using an empty matrix");
+    const Index innerSize = xpr.innerSize();
+    const Index outerSize = xpr.outerSize();
+    using Bounds = redux_max_size<XprType>;
+    constexpr int MaxInnerSize = XprType::IsVectorAtCompileTime ? Bounds::Size
+                                 : XprType::IsRowMajor          ? Bounds::Cols
+                                                                : Bounds::Rows;
+    EIGEN_IF_CONSTEXPR (functor_is_commutative<Func>::value) {
+      EIGEN_IF_CONSTEXPR (MaxInnerSize == Dynamic || MaxInnerSize >= kReduxCommutativeInnerCutoff) {
+        if (innerSize >= kReduxCommutativeInnerCutoff) return runCommutative(eval, func, innerSize, outerSize);
+      }
+    } else {
+      EIGEN_IF_CONSTEXPR (MaxInnerSize == Dynamic || MaxInnerSize >= kReduxOrderedTreeCutoff) {
+        if (innerSize >= kReduxOrderedTreeCutoff) return runOrderedTree(eval, func, innerSize, outerSize);
+      }
+    }
     Scalar res = eval.coeffByOuterInner(0, 0);
-    for (Index i = 1; i < xpr.innerSize(); ++i) res = func(res, eval.coeffByOuterInner(0, i));
-    for (Index i = 1; i < xpr.outerSize(); ++i)
-      for (Index j = 0; j < xpr.innerSize(); ++j) res = func(res, eval.coeffByOuterInner(i, j));
+    for (Index j = 1; j < innerSize; ++j) res = func(res, eval.coeffByOuterInner(0, j));
+    for (Index i = 1; i < outerSize; ++i)
+      for (Index j = 0; j < innerSize; ++j) res = func(res, eval.coeffByOuterInner(i, j));
     return res;
   }
+
+  // Commutativity lets coefficients split across eight independent accumulators: the dependency
+  // chain drops to size/8 and each stride-8 stream vectorizes without cross-lane shuffles. The
+  // accumulators persist across outer slices; only the ragged inner tail of each slice joins a0.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar runCommutative(const Evaluator& eval, const Func& func,
+                                                                     Index innerSize, Index outerSize) {
+    Scalar a0 = eval.coeffByOuterInner(0, 0), a1 = eval.coeffByOuterInner(0, 1);
+    Scalar a2 = eval.coeffByOuterInner(0, 2), a3 = eval.coeffByOuterInner(0, 3);
+    Scalar a4 = eval.coeffByOuterInner(0, 4), a5 = eval.coeffByOuterInner(0, 5);
+    Scalar a6 = eval.coeffByOuterInner(0, 6), a7 = eval.coeffByOuterInner(0, 7);
+    const Index unrolledEnd = innerSize - innerSize % 8;
+    for (Index i = 0; i < outerSize; ++i) {
+      Index j = (i == 0) ? 8 : 0;
+      for (; j < unrolledEnd; j += 8) {
+        a0 = func(a0, eval.coeffByOuterInner(i, j + 0));
+        a1 = func(a1, eval.coeffByOuterInner(i, j + 1));
+        a2 = func(a2, eval.coeffByOuterInner(i, j + 2));
+        a3 = func(a3, eval.coeffByOuterInner(i, j + 3));
+        a4 = func(a4, eval.coeffByOuterInner(i, j + 4));
+        a5 = func(a5, eval.coeffByOuterInner(i, j + 5));
+        a6 = func(a6, eval.coeffByOuterInner(i, j + 6));
+        a7 = func(a7, eval.coeffByOuterInner(i, j + 7));
+      }
+      for (; j < innerSize; ++j) a0 = func(a0, eval.coeffByOuterInner(i, j));
+    }
+    return func(func(func(a0, a1), func(a2, a3)), func(func(a4, a5), func(a6, a7)));
+  }
+
+  // Associativity alone: contiguous groups of four combine in traversal order through a pairwise
+  // tree, shortening the dependency chain to size/4 without reordering any operands.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar runOrderedTree(const Evaluator& eval, const Func& func,
+                                                                     Index innerSize, Index outerSize) {
+    const Index unrolledEnd = innerSize - innerSize % 4;
+    Scalar res = reduce4(eval, func, 0, 0);
+    for (Index i = 0; i < outerSize; ++i) {
+      Index j = (i == 0) ? 4 : 0;
+      for (; j < unrolledEnd; j += 4) res = func(res, reduce4(eval, func, i, j));
+      for (; j < innerSize; ++j) res = func(res, eval.coeffByOuterInner(i, j));
+    }
+    return res;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar reduce4(const Evaluator& eval, const Func& func, Index outer,
+                                                              Index inner) {
+    return func(func(eval.coeffByOuterInner(outer, inner + 0), eval.coeffByOuterInner(outer, inner + 1)),
+                func(eval.coeffByOuterInner(outer, inner + 2), eval.coeffByOuterInner(outer, inner + 3)));
+  }
 };
 
 template <typename Func, typename Evaluator>
 struct redux_impl<Func, Evaluator, LinearTraversal, NoUnrolling> {
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
   template <typename XprType>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func, const XprType& xpr) {
-    eigen_assert(xpr.size() > 0 && "you are using an empty matrix");
+    const Index size = xpr.size();
+    eigen_assert(size > 0 && "you are using an empty matrix");
+    // Do not generate wide reduction bodies for bounded expressions that cannot
+    // reach their cutoff (GCC can otherwise diagnose their unreachable loads).
+    EIGEN_IF_CONSTEXPR (functor_is_commutative<Func>::value) {
+      EIGEN_IF_CONSTEXPR (redux_max_size<XprType>::Size == Dynamic ||
+                          redux_max_size<XprType>::Size >= kReduxCommutativeCutoff) {
+        if (size >= kReduxCommutativeCutoff) return runCommutative(eval, func, size);
+      }
+    } else {
+      EIGEN_IF_CONSTEXPR (redux_max_size<XprType>::Size == Dynamic ||
+                          redux_max_size<XprType>::Size >= kReduxOrderedTreeCutoff) {
+        if (size >= kReduxOrderedTreeCutoff) return runOrderedTree(eval, func, size);
+      }
+    }
     Scalar res = eval.coeff(0);
-    for (Index k = 1; k < xpr.size(); ++k) res = func(res, eval.coeff(k));
+    for (Index k = 1; k < size; ++k) res = func(res, eval.coeff(k));
+    return res;
+  }
+
+  // Commutativity lets coefficients split across eight independent accumulators: the dependency
+  // chain drops to size/8 and each stride-8 stream vectorizes without cross-lane shuffles.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar runCommutative(const Evaluator& eval, const Func& func,
+                                                                     Index size) {
+    Scalar a0 = eval.coeff(0), a1 = eval.coeff(1), a2 = eval.coeff(2), a3 = eval.coeff(3);
+    Scalar a4 = eval.coeff(4), a5 = eval.coeff(5), a6 = eval.coeff(6), a7 = eval.coeff(7);
+    const Index unrolledEnd = size - size % 8;
+    Index k = 8;
+    for (; k < unrolledEnd; k += 8) {
+      a0 = func(a0, eval.coeff(k + 0));
+      a1 = func(a1, eval.coeff(k + 1));
+      a2 = func(a2, eval.coeff(k + 2));
+      a3 = func(a3, eval.coeff(k + 3));
+      a4 = func(a4, eval.coeff(k + 4));
+      a5 = func(a5, eval.coeff(k + 5));
+      a6 = func(a6, eval.coeff(k + 6));
+      a7 = func(a7, eval.coeff(k + 7));
+    }
+    Scalar res = func(func(func(a0, a1), func(a2, a3)), func(func(a4, a5), func(a6, a7)));
+    for (; k < size; ++k) res = func(res, eval.coeff(k));
+    return res;
+  }
+
+  // Associativity alone: contiguous groups of four combine in traversal order through a pairwise
+  // tree, shortening the dependency chain to size/4 without reordering any operands.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar runOrderedTree(const Evaluator& eval, const Func& func,
+                                                                     Index size) {
+    Scalar res = func(func(eval.coeff(0), eval.coeff(1)), func(eval.coeff(2), eval.coeff(3)));
+    const Index unrolledEnd = size - size % 4;
+    Index k = 4;
+    for (; k < unrolledEnd; k += 4) {
+      res = func(res, func(func(eval.coeff(k), eval.coeff(k + 1)), func(eval.coeff(k + 2), eval.coeff(k + 3))));
+    }
+    for (; k < size; ++k) res = func(res, eval.coeff(k));
     return res;
   }
 };
@@ -250,8 +405,8 @@
 template <typename Func, typename Evaluator>
 struct redux_impl<Func, Evaluator, DefaultTraversal, CompleteUnrolling>
     : redux_novec_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime> {
-  typedef redux_novec_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
-  typedef typename Evaluator::Scalar Scalar;
+  using Base = redux_novec_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime>;
+  using Scalar = typename Evaluator::Scalar;
   template <typename XprType>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func,
                                                           const XprType& /*xpr*/) {
@@ -262,8 +417,8 @@
 template <typename Func, typename Evaluator>
 struct redux_impl<Func, Evaluator, LinearTraversal, CompleteUnrolling>
     : redux_novec_linear_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime> {
-  typedef redux_novec_linear_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime> Base;
-  typedef typename Evaluator::Scalar Scalar;
+  using Base = redux_novec_linear_unroller<Func, Evaluator, 0, Evaluator::SizeAtCompileTime>;
+  using Scalar = typename Evaluator::Scalar;
   template <typename XprType>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func,
                                                           const XprType& /*xpr*/) {
@@ -273,8 +428,8 @@
 
 template <typename Func, typename Evaluator>
 struct redux_impl<Func, Evaluator, LinearVectorizedTraversal, NoUnrolling> {
-  typedef typename Evaluator::Scalar Scalar;
-  typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
+  using Scalar = typename Evaluator::Scalar;
+  using PacketScalar = typename redux_traits<Func, Evaluator>::PacketType;
 
   template <typename XprType>
   static Scalar run(const Evaluator& eval, const Func& func, const XprType& xpr) {
@@ -288,37 +443,74 @@
             : int(Unaligned);
     constexpr int alignment = plain_enum_max(alignment0, Evaluator::Alignment);
     const Index alignedStart = internal::first_default_aligned(xpr);
-    const Index alignedSize2 = ((size - alignedStart) / (2 * packetSize)) * (2 * packetSize);
-    const Index alignedSize = ((size - alignedStart) / (packetSize)) * (packetSize);
-    const Index alignedEnd2 = alignedStart + alignedSize2;
+    const Index alignedSize4 = numext::round_down(size - alignedStart, 4 * packetSize);
+    const Index alignedSize = numext::round_down(size - alignedStart, packetSize);
+    const Index alignedEnd4 = alignedStart + alignedSize4;
     const Index alignedEnd = alignedStart + alignedSize;
     Scalar res;
-    if (alignedSize) {
-      PacketScalar packet_res0 = eval.template packet<alignment, PacketScalar>(alignedStart);
-      if (alignedSize > packetSize)  // we have at least two packets to partly unroll the loop
-      {
-        PacketScalar packet_res1 = eval.template packet<alignment, PacketScalar>(alignedStart + packetSize);
-        for (Index index = alignedStart + 2 * packetSize; index < alignedEnd2; index += 2 * packetSize) {
-          packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment, PacketScalar>(index));
-          packet_res1 = func.packetOp(packet_res1, eval.template packet<alignment, PacketScalar>(index + packetSize));
+    constexpr Index maxSize = redux_max_size<XprType>::Size;
+    EIGEN_IF_CONSTEXPR (maxSize == Dynamic || maxSize >= packetSize) {
+      if (alignedSize) {
+        PacketScalar packet_res0 = eval.template packet<alignment, PacketScalar>(alignedStart);
+        EIGEN_IF_CONSTEXPR (maxSize == Dynamic || maxSize >= 4 * packetSize) {
+          if (alignedSize4)  // four independent accumulators keep the loop off the packetOp latency chain
+          {
+            PacketScalar packet_res1 = eval.template packet<alignment, PacketScalar>(alignedStart + packetSize);
+            PacketScalar packet_res2 = eval.template packet<alignment, PacketScalar>(alignedStart + 2 * packetSize);
+            PacketScalar packet_res3 = eval.template packet<alignment, PacketScalar>(alignedStart + 3 * packetSize);
+            for (Index index = alignedStart + 4 * packetSize; index < alignedEnd4; index += 4 * packetSize) {
+              packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment, PacketScalar>(index));
+              packet_res1 =
+                  func.packetOp(packet_res1, eval.template packet<alignment, PacketScalar>(index + packetSize));
+              packet_res2 =
+                  func.packetOp(packet_res2, eval.template packet<alignment, PacketScalar>(index + 2 * packetSize));
+              packet_res3 =
+                  func.packetOp(packet_res3, eval.template packet<alignment, PacketScalar>(index + 3 * packetSize));
+            }
+
+            // The one to three leftover packets go into accumulators that are still independent, so they
+            // cost a packetOp each rather than extending the merge below.
+            const Index remSize = alignedSize - alignedSize4;
+            if (remSize >= packetSize) {
+              packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment, PacketScalar>(alignedEnd4));
+              if (remSize >= 2 * packetSize) {
+                packet_res1 =
+                    func.packetOp(packet_res1, eval.template packet<alignment, PacketScalar>(alignedEnd4 + packetSize));
+                if (remSize == 3 * packetSize)
+                  packet_res2 = func.packetOp(
+                      packet_res2, eval.template packet<alignment, PacketScalar>(alignedEnd4 + 2 * packetSize));
+              }
+            }
+
+            // Merge as (res0 + res1) + (res2 + res3): two packetOp latencies deep instead of three.
+            packet_res0 = func.packetOp(packet_res0, packet_res1);
+            packet_res2 = func.packetOp(packet_res2, packet_res3);
+            packet_res0 = func.packetOp(packet_res0, packet_res2);
+          }
         }
+        EIGEN_IF_CONSTEXPR (maxSize == Dynamic || maxSize >= 2 * packetSize) {
+          if (!alignedSize4 && alignedSize > packetSize) {
+            // Two or three packets: straight-line, with none of the trip-count setup a loop would need.
+            packet_res0 =
+                func.packetOp(packet_res0, eval.template packet<alignment, PacketScalar>(alignedStart + packetSize));
+            EIGEN_IF_CONSTEXPR (maxSize == Dynamic || maxSize >= 3 * packetSize) {
+              if (alignedSize > 2 * packetSize)
+                packet_res0 = func.packetOp(
+                    packet_res0, eval.template packet<alignment, PacketScalar>(alignedStart + 2 * packetSize));
+            }
+          }
+        }
+        res = func.predux(packet_res0);
 
-        packet_res0 = func.packetOp(packet_res0, packet_res1);
-        if (alignedEnd > alignedEnd2)
-          packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment, PacketScalar>(alignedEnd2));
+        for (Index index = 0; index < alignedStart; ++index) res = func(res, eval.coeff(index));
+
+        for (Index index = alignedEnd; index < size; ++index) res = func(res, eval.coeff(index));
+        return res;
       }
-      res = func.predux(packet_res0);
-
-      for (Index index = 0; index < alignedStart; ++index) res = func(res, eval.coeff(index));
-
-      for (Index index = alignedEnd; index < size; ++index) res = func(res, eval.coeff(index));
-    } else  // too small to vectorize anything.
-            // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
-    {
-      res = eval.coeff(0);
-      for (Index index = 1; index < size; ++index) res = func(res, eval.coeff(index));
     }
-
+    // Too small to vectorize anything.
+    res = eval.coeff(0);
+    for (Index index = 1; index < size; ++index) res = func(res, eval.coeff(index));
     return res;
   }
 };
@@ -326,24 +518,92 @@
 // NOTE: for SliceVectorizedTraversal we simply bypass unrolling
 template <typename Func, typename Evaluator, int Unrolling>
 struct redux_impl<Func, Evaluator, SliceVectorizedTraversal, Unrolling> {
-  typedef typename Evaluator::Scalar Scalar;
-  typedef typename redux_traits<Func, Evaluator>::PacketType PacketType;
+  using Scalar = typename Evaluator::Scalar;
+  using PacketType = typename redux_traits<Func, Evaluator>::PacketType;
+
+  static constexpr Index PacketSize = redux_traits<Func, Evaluator>::PacketSize;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE PacketType packetAt(const Evaluator& eval, Index j, Index i) {
+    return eval.template packetByOuterInner<Unaligned, PacketType>(j, i);
+  }
 
   template <typename XprType>
   EIGEN_DEVICE_FUNC static Scalar run(const Evaluator& eval, const Func& func, const XprType& xpr) {
     eigen_assert(xpr.rows() > 0 && xpr.cols() > 0 && "you are using an empty matrix");
-    constexpr Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
     const Index innerSize = xpr.innerSize();
     const Index outerSize = xpr.outerSize();
-    const Index packetedInnerSize = ((innerSize) / packetSize) * packetSize;
+    const Index packetedInnerSize = numext::round_down(innerSize, PacketSize);
+    const Index quadInnerSize = numext::round_down(innerSize, 4 * PacketSize);
     Scalar res;
     if (packetedInnerSize) {
-      PacketType packet_res = eval.template packet<Unaligned, PacketType>(0, 0);
-      for (Index j = 0; j < outerSize; ++j)
-        for (Index i = (j == 0 ? packetSize : 0); i < packetedInnerSize; i += Index(packetSize))
-          packet_res = func.packetOp(packet_res, eval.template packetByOuterInner<Unaligned, PacketType>(j, i));
+      // A single accumulator leaves one packetOp latency between consecutive iterations, so carry
+      // four of them across the whole (j, i) traversal and merge them once.
+      PacketType packet_res0 = packetAt(eval, 0, 0);
+      if (quadInnerSize) {
+        // Four packets or more per panel: each accumulator takes one packet of every group of four.
+        PacketType packet_res1 = packetAt(eval, 0, PacketSize);
+        PacketType packet_res2 = packetAt(eval, 0, 2 * PacketSize);
+        PacketType packet_res3 = packetAt(eval, 0, 3 * PacketSize);
+        // Every panel has the same number of packets left over, so this is loop-invariant and the
+        // branches on it do not wait on the packet loop below.
+        const Index remSize = packetedInnerSize - quadInnerSize;
+        for (Index j = 0; j < outerSize; ++j) {
+          for (Index i = (j == 0) ? 4 * PacketSize : 0; i < quadInnerSize; i += 4 * PacketSize) {
+            packet_res0 = func.packetOp(packet_res0, packetAt(eval, j, i));
+            packet_res1 = func.packetOp(packet_res1, packetAt(eval, j, i + PacketSize));
+            packet_res2 = func.packetOp(packet_res2, packetAt(eval, j, i + 2 * PacketSize));
+            packet_res3 = func.packetOp(packet_res3, packetAt(eval, j, i + 3 * PacketSize));
+          }
+          // This panel's one to three leftover packets, into accumulators that are still
+          // independent of each other.
+          if (remSize >= PacketSize) {
+            packet_res0 = func.packetOp(packet_res0, packetAt(eval, j, quadInnerSize));
+            if (remSize >= 2 * PacketSize) {
+              packet_res1 = func.packetOp(packet_res1, packetAt(eval, j, quadInnerSize + PacketSize));
+              if (remSize == 3 * PacketSize)
+                packet_res2 = func.packetOp(packet_res2, packetAt(eval, j, quadInnerSize + 2 * PacketSize));
+            }
+          }
+        }
+        // Merge as (res0 + res1) + (res2 + res3): two packetOp latencies deep instead of three.
+        packet_res0 = func.packetOp(packet_res0, packet_res1);
+        packet_res2 = func.packetOp(packet_res2, packet_res3);
+        packet_res0 = func.packetOp(packet_res0, packet_res2);
+      } else if (outerSize >= 4) {
+        // Panels of one to three packets cannot supply four independent packets, so the
+        // independence comes from the outer dimension: each accumulator takes its own panel.
+        PacketType packet_res1 = packetAt(eval, 1, 0);
+        PacketType packet_res2 = packetAt(eval, 2, 0);
+        PacketType packet_res3 = packetAt(eval, 3, 0);
+        for (Index i = PacketSize; i < packetedInnerSize; i += PacketSize) {
+          packet_res0 = func.packetOp(packet_res0, packetAt(eval, 0, i));
+          packet_res1 = func.packetOp(packet_res1, packetAt(eval, 1, i));
+          packet_res2 = func.packetOp(packet_res2, packetAt(eval, 2, i));
+          packet_res3 = func.packetOp(packet_res3, packetAt(eval, 3, i));
+        }
+        Index j = 4;
+        for (; j + 4 <= outerSize; j += 4)
+          for (Index i = 0; i < packetedInnerSize; i += PacketSize) {
+            packet_res0 = func.packetOp(packet_res0, packetAt(eval, j, i));
+            packet_res1 = func.packetOp(packet_res1, packetAt(eval, j + 1, i));
+            packet_res2 = func.packetOp(packet_res2, packetAt(eval, j + 2, i));
+            packet_res3 = func.packetOp(packet_res3, packetAt(eval, j + 3, i));
+          }
+        for (; j < outerSize; ++j)
+          for (Index i = 0; i < packetedInnerSize; i += PacketSize)
+            packet_res0 = func.packetOp(packet_res0, packetAt(eval, j, i));
 
-      res = func.predux(packet_res);
+        packet_res0 = func.packetOp(packet_res0, packet_res1);
+        packet_res2 = func.packetOp(packet_res2, packet_res3);
+        packet_res0 = func.packetOp(packet_res0, packet_res2);
+      } else {
+        // Fewer than four narrow panels: at most nine packets in total, not worth a merge.
+        for (Index j = 0; j < outerSize; ++j)
+          for (Index i = (j == 0 ? PacketSize : 0); i < packetedInnerSize; i += PacketSize)
+            packet_res0 = func.packetOp(packet_res0, packetAt(eval, j, i));
+      }
+
+      res = func.predux(packet_res0);
       for (Index j = 0; j < outerSize; ++j)
         for (Index i = packetedInnerSize; i < innerSize; ++i) res = func(res, eval.coeffByOuterInner(j, i));
     } else  // too small to vectorize anything.
@@ -358,16 +618,16 @@
 
 template <typename Func, typename Evaluator>
 struct redux_impl<Func, Evaluator, LinearVectorizedTraversal, CompleteUnrolling> {
-  typedef typename Evaluator::Scalar Scalar;
+  using Scalar = typename Evaluator::Scalar;
 
-  typedef typename redux_traits<Func, Evaluator>::PacketType PacketType;
+  using PacketType = typename redux_traits<Func, Evaluator>::PacketType;
   static constexpr Index PacketSize = redux_traits<Func, Evaluator>::PacketSize;
   static constexpr Index Size = Evaluator::SizeAtCompileTime;
   static constexpr Index VectorizedSize = (int(Size) / int(PacketSize)) * int(PacketSize);
 
   template <typename XprType>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Evaluator& eval, const Func& func, const XprType& xpr) {
-    EIGEN_ONLY_USED_FOR_DEBUG(xpr)
+    EIGEN_ONLY_USED_FOR_DEBUG(xpr);
     eigen_assert(xpr.rows() > 0 && xpr.cols() > 0 && "you are using an empty matrix");
     if (VectorizedSize > 0) {
       Scalar res = func.predux(
@@ -384,16 +644,16 @@
 
 // evaluator adaptor
 template <typename XprType_>
-class redux_evaluator : public internal::evaluator<XprType_> {
-  typedef internal::evaluator<XprType_> Base;
+class redux_evaluator : public internal::evaluator<const XprType_> {
+  using Base = internal::evaluator<const XprType_>;
 
  public:
-  typedef XprType_ XprType;
+  using XprType = XprType_;
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit redux_evaluator(const XprType& xpr) : Base(xpr) {}
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename XprType::PacketScalar PacketScalar;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
+  using PacketScalar = typename XprType::PacketScalar;
 
   enum {
     MaxRowsAtCompileTime = XprType::MaxRowsAtCompileTime,
@@ -423,6 +683,52 @@
   }
 };
 
+// A reduction over an expression whose inner stride is not statically 1 (e.g. a dynamic-inner-stride
+// Map/Ref, or a row of a dynamic matrix) falls back to a scalar traversal, because the evaluator
+// drops PacketAccessBit when the inner stride is unknown at compile time. Yet such expressions are
+// very often contiguous at runtime. This trait flags the cases where it is worth checking at runtime
+// whether the data is contiguous and, if so, reducing it as a contiguous vector to recover full
+// vectorization. We only bother when the expression has direct access, the functor and scalar are
+// vectorizable, and the inner stride is not already statically 1 (otherwise it is handled directly).
+template <typename Func, typename Evaluator>
+struct redux_has_runtime_unit_stride_path {
+  using XprType = typename Evaluator::XprType;
+  using Scalar = typename Evaluator::Scalar;
+  static constexpr bool value = bool(traits<XprType>::Flags & DirectAccessBit) &&
+                                bool(functor_traits<Func>::PacketAccess) && bool(packet_traits<Scalar>::Vectorizable) &&
+                                (int(inner_stride_at_compile_time<XprType>::value) != 1);
+};
+
+template <typename Func, typename Evaluator, typename XprType,
+          bool = redux_has_runtime_unit_stride_path<Func, Evaluator>::value>
+struct redux_dispatch {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Evaluator::Scalar run(const Evaluator& thisEval,
+                                                                              const Func& func, const XprType& xpr) {
+    return redux_impl<Func, Evaluator>::run(thisEval, func, xpr);
+  }
+};
+
+// Runtime contiguity fast path: when the inner stride is 1 and the data is fully packed
+// (a single inner panel, or no gap between inner panels), reduce the underlying buffer as a
+// contiguous vector. The reduction is over all coefficients with an associative functor, so
+// reducing in storage order yields the same result (up to the usual floating-point reassociation
+// already inherent to vectorized reductions).
+template <typename Func, typename Evaluator, typename XprType>
+struct redux_dispatch<Func, Evaluator, XprType, true> {
+  using Scalar = typename Evaluator::Scalar;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar run(const Evaluator& thisEval, const Func& func,
+                                                          const XprType& xpr) {
+    if (xpr.innerStride() == 1 && (xpr.outerSize() == 1 || xpr.outerStride() == xpr.innerSize())) {
+      using PlainVector = Matrix<Scalar, Dynamic, 1>;
+      using MapType = Map<const PlainVector, Evaluator::Alignment>;
+      MapType contiguous(xpr.data(), xpr.size());
+      redux_evaluator<MapType> mapEval(contiguous);
+      return redux_impl<Func, redux_evaluator<MapType>>::run(mapEval, func, contiguous);
+    }
+    return redux_impl<Func, Evaluator>::run(thisEval, func, xpr);
+  }
+};
+
 }  // end namespace internal
 
 /***************************************************************************
@@ -432,7 +738,10 @@
 /** \returns the result of a full redux operation on the whole matrix or vector using \a func
  *
  * The template parameter \a BinaryOp is the type of the functor \a func which must be
- * an associative operator. Both current C++98 and C++11 functor styles are handled.
+ * an associative operator. Coefficients are combined in traversal order, though possibly
+ * re-associated into groups. If \c Eigen::internal::functor_is_commutative<BinaryOp> is
+ * specialized to derive from \c std::true_type, the implementation may also reorder operands,
+ * which enables a faster reduction; Eigen's own sum, product, min and max functors opt in.
  *
  * \warning the matrix must be not empty, otherwise an assertion is triggered.
  *
@@ -444,12 +753,14 @@
     const Func& func) const {
   eigen_assert(this->rows() > 0 && this->cols() > 0 && "you are using an empty matrix");
 
-  typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
+  using ThisEvaluator = typename internal::redux_evaluator<Derived>;
   ThisEvaluator thisEval(derived());
 
   // The initial expression is passed to the reducer as an additional argument instead of
-  // passing it as a member of redux_evaluator to help
-  return internal::redux_impl<Func, ThisEvaluator>::run(thisEval, func, derived());
+  // passing it as a member of redux_evaluator. redux_dispatch additionally takes a runtime
+  // contiguity fast path for expressions that lose compile-time vectorization to a dynamic
+  // inner stride but are contiguous at runtime (see redux_dispatch).
+  return internal::redux_dispatch<Func, ThisEvaluator, Derived>::run(thisEval, func, derived());
 }
 
 /** \returns the minimum of all coefficients of \c *this.
@@ -486,8 +797,14 @@
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::sum() const {
-  if (SizeAtCompileTime == 0 || (SizeAtCompileTime == Dynamic && size() == 0)) return Scalar(0);
-  return derived().redux(Eigen::internal::scalar_sum_op<Scalar, Scalar>());
+  EIGEN_IF_CONSTEXPR (MaxSizeAtCompileTime == 0 || SizeAtCompileTime == 0) {
+    return Scalar(0);
+  } else {
+    EIGEN_IF_CONSTEXPR (SizeAtCompileTime == Dynamic) {
+      if (size() == 0) return Scalar(0);
+    }
+    return derived().redux(Eigen::internal::scalar_sum_op<Scalar, Scalar>());
+  }
 }
 
 /** \returns the mean of all coefficients of *this
@@ -515,8 +832,14 @@
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::prod() const {
-  if (SizeAtCompileTime == 0 || (SizeAtCompileTime == Dynamic && size() == 0)) return Scalar(1);
-  return derived().redux(Eigen::internal::scalar_product_op<Scalar>());
+  EIGEN_IF_CONSTEXPR (MaxSizeAtCompileTime == 0 || SizeAtCompileTime == 0) {
+    return Scalar(1);
+  } else {
+    EIGEN_IF_CONSTEXPR (SizeAtCompileTime == Dynamic) {
+      if (size() == 0) return Scalar(1);
+    }
+    return derived().redux(Eigen::internal::scalar_product_op<Scalar>());
+  }
 }
 
 /** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal.
diff --git a/Eigen/src/Core/Ref.h b/Eigen/src/Core/Ref.h
index c845462..39e618c 100644
--- a/Eigen/src/Core/Ref.h
+++ b/Eigen/src/Core/Ref.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REF_H
 #define EIGEN_REF_H
@@ -20,8 +21,8 @@
 template <typename PlainObjectType_, int Options_, typename StrideType_>
 struct traits<Ref<PlainObjectType_, Options_, StrideType_> >
     : public traits<Map<PlainObjectType_, Options_, StrideType_> > {
-  typedef PlainObjectType_ PlainObjectType;
-  typedef StrideType_ StrideType;
+  using PlainObjectType = PlainObjectType_;
+  using StrideType = StrideType_;
   enum {
     Options = Options_,
     Flags = traits<Map<PlainObjectType_, Options_, StrideType_> >::Flags | NestByRefBit,
@@ -34,7 +35,7 @@
   struct match {
     enum {
       IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime,
-      HasDirectAccess = internal::has_direct_access<Derived>::ret,
+      HasDirectAccess = internal::has_direct_access<Derived>::value,
       StorageOrderMatch =
           IsVectorAtCompileTime || ((PlainObjectType::Flags & RowMajorBit) == (Derived::Flags & RowMajorBit)),
       InnerStrideMatch = int(InnerStrideAtCompileTime) == int(Dynamic) ||
@@ -42,20 +43,12 @@
                          (int(InnerStrideAtCompileTime) == 0 && int(Derived::InnerStrideAtCompileTime) == 1),
       OuterStrideMatch = IsVectorAtCompileTime || int(OuterStrideAtCompileTime) == int(Dynamic) ||
                          int(OuterStrideAtCompileTime) == int(Derived::OuterStrideAtCompileTime),
-      // NOTE, this indirection of evaluator<Derived>::Alignment is needed
-      // to work around an MSVC bug related to the instantiation
-      // of has_*ary_operator in evaluator<CwiseNullaryOp>.
-      // This line is surprisingly very sensitive. For instance, simply adding parenthesis
-      // as "DerivedAlignment = (int(evaluator<Derived>::Alignment))," will make MSVC fail...
-      DerivedAlignment = int(evaluator<Derived>::Alignment),
-      AlignmentMatch = (int(traits<PlainObjectType>::Alignment) == int(Unaligned)) ||
-                       (DerivedAlignment >= int(Alignment)),  // FIXME the first condition is not very clear, it should
-                                                              // be replaced by the required alignment
-      ScalarTypeMatch = internal::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
+      AlignmentMatch = int(evaluator<Derived>::Alignment) >= int(Alignment),
+      ScalarTypeMatch = std::is_same<typename PlainObjectType::Scalar, typename Derived::Scalar>::value,
       MatchAtCompileTime = HasDirectAccess && StorageOrderMatch && InnerStrideMatch && OuterStrideMatch &&
                            AlignmentMatch && ScalarTypeMatch
     };
-    typedef std::conditional_t<MatchAtCompileTime, internal::true_type, internal::false_type> type;
+    using type = bool_constant<MatchAtCompileTime>;
   };
 };
 
@@ -66,11 +59,11 @@
 
 template <typename Derived>
 class RefBase : public MapBase<Derived> {
-  typedef typename internal::traits<Derived>::PlainObjectType PlainObjectType;
-  typedef typename internal::traits<Derived>::StrideType StrideType;
+  using PlainObjectType = typename internal::traits<Derived>::PlainObjectType;
+  using StrideType = typename internal::traits<Derived>::StrideType;
 
  public:
-  typedef MapBase<Derived> Base;
+  using Base = MapBase<Derived>;
   EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)
 
   EIGEN_DEVICE_FUNC constexpr Index innerStride() const {
@@ -94,7 +87,7 @@
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)
 
  protected:
-  typedef Stride<StrideType::OuterStrideAtCompileTime, StrideType::InnerStrideAtCompileTime> StrideBase;
+  using StrideBase = Stride<StrideType::OuterStrideAtCompileTime, StrideType::InnerStrideAtCompileTime>;
 
   // Resolves inner stride if default 0.
   static EIGEN_DEVICE_FUNC constexpr Index resolveInnerStride(Index inner) { return inner == 0 ? 1 : inner; }
@@ -125,11 +118,11 @@
     // Determine runtime rows and columns.
     Index rows = expr.rows();
     Index cols = expr.cols();
-    if (PlainObjectType::RowsAtCompileTime == 1) {
+    EIGEN_IF_CONSTEXPR (PlainObjectType::RowsAtCompileTime == 1) {
       eigen_assert(expr.rows() == 1 || expr.cols() == 1);
       rows = 1;
       cols = expr.size();
-    } else if (PlainObjectType::ColsAtCompileTime == 1) {
+    } else EIGEN_IF_CONSTEXPR (PlainObjectType::ColsAtCompileTime == 1) {
       eigen_assert(expr.rows() == 1 || expr.cols() == 1);
       rows = expr.size();
       cols = 1;
@@ -201,7 +194,7 @@
  * \brief A matrix or vector expression mapping an existing expression
  *
  * \tparam PlainObjectType the equivalent matrix type of the mapped data
- * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, , \c #Aligned64, \c #Aligned32,
+ * \tparam Options specifies the pointer alignment in bytes. It can be: \c #Aligned128, \c #Aligned64, \c #Aligned32,
  * \c #Aligned16, \c #Aligned8 or \c #Unaligned. The default is \c #Unaligned. \tparam StrideType optionally specifies
  * strides. By default, Ref implies a contiguous storage along the inner dimension (inner stride==1), but accepts a
  * variable outer stride (leading dimension). This can be overridden by specifying strides. The type passed here must be
@@ -224,9 +217,14 @@
  * of rows.
  *
  * In the const case, if the input expression does not match the above requirement, then it is evaluated into a
- * temporary before being passed to the function. Here are some examples: \code MatrixXf A; VectorXf a; foo1(a.head());
- * // OK foo1(A.col());              // OK foo1(A.row());              // Compilation error because here innerstride!=1
- * foo2(A.row());              // Compilation error because A.row() is a 1xN object while foo2 is expecting a Nx1 object
+ * temporary before being passed to the function. Here are some examples:
+ * \code
+ * MatrixXf A;
+ * VectorXf a;
+ * foo1(a.head());             // OK
+ * foo1(A.col());              // OK
+ * foo1(A.row());              // Compilation error because here innerstride!=1
+ * foo2(A.row());              // The 1xN row is accepted as a Nx1 vector, but copied into a temporary
  * foo2(A.row().transpose());  // The row is copied into a contiguous temporary
  * foo2(2*a);                  // The expression is evaluated into a temporary
  * foo2(A.col().segment(2,4)); // No temporary
@@ -263,31 +261,33 @@
 template <typename PlainObjectType, int Options, typename StrideType>
 class Ref : public RefBase<Ref<PlainObjectType, Options, StrideType> > {
  private:
-  typedef internal::traits<Ref> Traits;
-  template <typename Derived>
-  EIGEN_DEVICE_FUNC constexpr inline Ref(
-      const PlainObjectBase<Derived>& expr,
-      std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0);
+  using Traits = internal::traits<Ref>;
+  template <typename Derived, std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), int> = 0>
+  EIGEN_DEVICE_FUNC constexpr inline Ref(const PlainObjectBase<Derived>& expr);
 
  public:
-  typedef RefBase<Ref> Base;
+  using Base = RefBase<Ref>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  template <typename Derived>
-  EIGEN_DEVICE_FUNC constexpr inline Ref(
-      PlainObjectBase<Derived>& expr,
-      std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0) {
+  template <typename Derived, std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), int> = 0>
+  EIGEN_DEVICE_FUNC constexpr inline Ref(PlainObjectBase<Derived>& expr) {
     EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
     // Construction must pass since we will not create temporary storage in the non-const case.
     const bool success = Base::construct(expr.derived());
-    EIGEN_UNUSED_VARIABLE(success)
+    EIGEN_UNUSED_VARIABLE(success);
     eigen_assert(success);
   }
+
   template <typename Derived>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only second argument.")
   EIGEN_DEVICE_FUNC constexpr inline Ref(
-      const DenseBase<Derived>& expr,
-      std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>* = 0)
+      PlainObjectBase<Derived>& expr,
+      std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>*)
+      : Ref(expr) {}
+
+  template <typename Derived, std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), int> = 0>
+  EIGEN_DEVICE_FUNC constexpr inline Ref(const DenseBase<Derived>& expr)
 #else
   /** Implicit constructor from any dense expression */
   template <typename Derived>
@@ -299,10 +299,19 @@
     EIGEN_STATIC_ASSERT(!Derived::IsPlainObjectBase, THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
     // Construction must pass since we will not create temporary storage in the non-const case.
     const bool success = Base::construct(expr.const_cast_derived());
-    EIGEN_UNUSED_VARIABLE(success)
+    EIGEN_UNUSED_VARIABLE(success);
     eigen_assert(success);
   }
 
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename Derived>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only second argument.")
+  EIGEN_DEVICE_FUNC constexpr inline Ref(
+      const DenseBase<Derived>& expr,
+      std::enable_if_t<bool(Traits::template match<Derived>::MatchAtCompileTime), Derived>*)
+      : Ref(expr) {}
+#endif
+
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Ref)
 };
 
@@ -310,7 +319,7 @@
 template <typename TPlainObjectType, int Options, typename StrideType>
 class Ref<const TPlainObjectType, Options, StrideType>
     : public RefBase<Ref<const TPlainObjectType, Options, StrideType> > {
-  typedef internal::traits<Ref> Traits;
+  using Traits = internal::traits<Ref>;
 
   static constexpr bool may_map_m_object_successfully =
       (static_cast<int>(StrideType::InnerStrideAtCompileTime) == 0 ||
@@ -323,13 +332,11 @@
        static_cast<int>(TPlainObjectType::InnerSizeAtCompileTime) == Dynamic);
 
  public:
-  typedef RefBase<Ref> Base;
+  using Base = RefBase<Ref>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Ref)
 
-  template <typename Derived>
-  EIGEN_DEVICE_FUNC constexpr inline Ref(
-      const DenseBase<Derived>& expr,
-      std::enable_if_t<bool(Traits::template match<Derived>::ScalarTypeMatch), Derived>* = 0) {
+  template <typename Derived, std::enable_if_t<bool(Traits::template match<Derived>::ScalarTypeMatch), int> = 0>
+  EIGEN_DEVICE_FUNC constexpr inline Ref(const DenseBase<Derived>& expr) {
     //      std::cout << match_helper<Derived>::HasDirectAccess << "," << match_helper<Derived>::OuterStrideMatch << ","
     //      << match_helper<Derived>::InnerStrideMatch << "\n"; std::cout << int(StrideType::OuterStrideAtCompileTime)
     //      << " - " << int(Derived::OuterStrideAtCompileTime) << "\n"; std::cout <<
@@ -339,6 +346,13 @@
     construct(expr.derived(), typename Traits::template match<Derived>::type());
   }
 
+  template <typename Derived>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only second argument.")
+  EIGEN_DEVICE_FUNC constexpr inline Ref(
+      const DenseBase<Derived>& expr,
+      std::enable_if_t<bool(Traits::template match<Derived>::ScalarTypeMatch), Derived>*)
+      : Ref(expr) {}
+
   EIGEN_DEVICE_FUNC constexpr inline Ref(const Ref& other) : Base(other) {
     // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy
   }
@@ -360,18 +374,18 @@
 
  protected:
   template <typename Expression>
-  EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::true_type) {
+  EIGEN_DEVICE_FUNC void construct(const Expression& expr, std::true_type) {
     // Check if we can use the underlying expr's storage directly, otherwise call the copy version.
     if (!Base::construct(expr)) {
-      construct(expr, internal::false_type());
+      construct(expr, std::false_type());
     }
   }
 
   template <typename Expression>
-  EIGEN_DEVICE_FUNC void construct(const Expression& expr, internal::false_type) {
+  EIGEN_DEVICE_FUNC void construct(const Expression& expr, std::false_type) {
     internal::call_assignment_no_alias(m_object, expr, internal::assign_op<Scalar, Scalar>());
     const bool success = Base::construct(m_object);
-    EIGEN_ONLY_USED_FOR_DEBUG(success)
+    EIGEN_ONLY_USED_FOR_DEBUG(success);
     eigen_assert(success);
   }
 
diff --git a/Eigen/src/Core/Replicate.h b/Eigen/src/Core/Replicate.h
index 9bdc725..322b067 100644
--- a/Eigen/src/Core/Replicate.h
+++ b/Eigen/src/Core/Replicate.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REPLICATE_H
 #define EIGEN_REPLICATE_H
@@ -18,11 +19,11 @@
 namespace internal {
 template <typename MatrixType, int RowFactor, int ColFactor>
 struct traits<Replicate<MatrixType, RowFactor, ColFactor> > : traits<MatrixType> {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename traits<MatrixType>::StorageKind StorageKind;
-  typedef typename traits<MatrixType>::XprKind XprKind;
-  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNested_;
+  using Scalar = typename MatrixType::Scalar;
+  using StorageKind = typename traits<MatrixType>::StorageKind;
+  using XprKind = typename traits<MatrixType>::XprKind;
+  using MatrixTypeNested = typename ref_selector<MatrixType>::type;
+  using MatrixTypeNested_ = std::remove_reference_t<MatrixTypeNested>;
   enum {
     RowsAtCompileTime = RowFactor == Dynamic || int(MatrixType::RowsAtCompileTime) == Dynamic
                             ? Dynamic
@@ -62,18 +63,18 @@
  */
 template <typename MatrixType, int RowFactor, int ColFactor>
 class Replicate : public internal::dense_xpr_base<Replicate<MatrixType, RowFactor, ColFactor> >::type {
-  typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTypeNested;
-  typedef typename internal::traits<Replicate>::MatrixTypeNested_ MatrixTypeNested_;
+  using MatrixTypeNested = typename internal::traits<Replicate>::MatrixTypeNested;
+  using MatrixTypeNested_ = typename internal::traits<Replicate>::MatrixTypeNested_;
 
  public:
-  typedef typename internal::dense_xpr_base<Replicate>::type Base;
+  using Base = typename internal::dense_xpr_base<Replicate>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(Replicate)
-  typedef internal::remove_all_t<MatrixType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<MatrixType>;
 
   template <typename OriginalMatrixType>
   EIGEN_DEVICE_FUNC constexpr inline explicit Replicate(const OriginalMatrixType& matrix)
       : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor) {
-    EIGEN_STATIC_ASSERT((internal::is_same<std::remove_const_t<MatrixType>, OriginalMatrixType>::value),
+    EIGEN_STATIC_ASSERT((std::is_same<std::remove_const_t<MatrixType>, OriginalMatrixType>::value),
                         THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
     eigen_assert(RowFactor != Dynamic && ColFactor != Dynamic);
   }
@@ -81,7 +82,7 @@
   template <typename OriginalMatrixType>
   EIGEN_DEVICE_FUNC constexpr inline Replicate(const OriginalMatrixType& matrix, Index rowFactor, Index colFactor)
       : m_matrix(matrix), m_rowFactor(rowFactor), m_colFactor(colFactor) {
-    EIGEN_STATIC_ASSERT((internal::is_same<std::remove_const_t<MatrixType>, OriginalMatrixType>::value),
+    EIGEN_STATIC_ASSERT((std::is_same<std::remove_const_t<MatrixType>, OriginalMatrixType>::value),
                         THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE)
   }
 
diff --git a/Eigen/src/Core/Reshaped.h b/Eigen/src/Core/Reshaped.h
index 5763d6a..4a94cd1 100644
--- a/Eigen/src/Core/Reshaped.h
+++ b/Eigen/src/Core/Reshaped.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RESHAPED_H
 #define EIGEN_RESHAPED_H
@@ -49,9 +50,9 @@
 
 template <typename XprType, int Rows, int Cols, int Order>
 struct traits<Reshaped<XprType, Rows, Cols, Order> > : traits<XprType> {
-  typedef typename traits<XprType>::Scalar Scalar;
-  typedef typename traits<XprType>::StorageKind StorageKind;
-  typedef typename traits<XprType>::XprKind XprKind;
+  using Scalar = typename traits<XprType>::Scalar;
+  using StorageKind = typename traits<XprType>::StorageKind;
+  using XprKind = typename traits<XprType>::XprKind;
   enum {
     MatrixRows = traits<XprType>::RowsAtCompileTime,
     MatrixCols = traits<XprType>::ColsAtCompileTime,
@@ -59,16 +60,20 @@
     ColsAtCompileTime = Cols,
     MaxRowsAtCompileTime = Rows,
     MaxColsAtCompileTime = Cols,
-    XpxStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor,
+    XprStorageOrder = ((int(traits<XprType>::Flags) & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor,
     ReshapedStorageOrder = (RowsAtCompileTime == 1 && ColsAtCompileTime != 1)   ? RowMajor
                            : (ColsAtCompileTime == 1 && RowsAtCompileTime != 1) ? ColMajor
-                                                                                : XpxStorageOrder,
-    HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XpxStorageOrder),
+                                                                                : XprStorageOrder,
+    HasSameStorageOrderAsXprType = (ReshapedStorageOrder == XprStorageOrder),
     InnerSize = (ReshapedStorageOrder == int(RowMajor)) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
-    InnerStrideAtCompileTime = HasSameStorageOrderAsXprType ? int(inner_stride_at_compile_time<XprType>::ret) : Dynamic,
+    // A mismatched ReshapedStorageOrder only happens for vector shapes, where the storage order is
+    // immaterial: the runtime innerStride() is the nested expression's in all cases (see below).
+    InnerStrideAtCompileTime = (HasSameStorageOrderAsXprType || RowsAtCompileTime == 1 || ColsAtCompileTime == 1)
+                                   ? int(inner_stride_at_compile_time<XprType>::value)
+                                   : Dynamic,
     OuterStrideAtCompileTime = Dynamic,
 
-    HasDirectAccess = internal::has_direct_access<XprType>::ret && (Order == int(XpxStorageOrder)) &&
+    HasDirectAccess = internal::has_direct_access<XprType>::value && (Order == int(XprStorageOrder)) &&
                       ((evaluator<XprType>::Flags & LinearAccessBit) == LinearAccessBit),
 
     MaskPacketAccessBit =
@@ -97,11 +102,11 @@
 
 template <typename XprType, int Rows, int Cols, int Order>
 class Reshaped : public ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> {
-  typedef ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind> Impl;
+  using Impl = ReshapedImpl<XprType, Rows, Cols, Order, typename internal::traits<XprType>::StorageKind>;
 
  public:
   // typedef typename Impl::Base Base;
-  typedef Impl Base;
+  using Base = Impl;
   EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reshaped)
 
@@ -129,12 +134,11 @@
 class ReshapedImpl<XprType, Rows, Cols, Order, Dense>
     : public internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,
                                           internal::traits<Reshaped<XprType, Rows, Cols, Order> >::HasDirectAccess> {
-  typedef internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,
-                                       internal::traits<Reshaped<XprType, Rows, Cols, Order> >::HasDirectAccess>
-      Impl;
+  using Impl = internal::ReshapedImpl_dense<XprType, Rows, Cols, Order,
+                                            internal::traits<Reshaped<XprType, Rows, Cols, Order>>::HasDirectAccess>;
 
  public:
-  typedef Impl Base;
+  using Base = Impl;
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl)
   EIGEN_DEVICE_FUNC constexpr inline ReshapedImpl(XprType& xpr) : Impl(xpr) {}
   EIGEN_DEVICE_FUNC constexpr inline ReshapedImpl(XprType& xpr, Index reshapeRows, Index reshapeCols)
@@ -147,15 +151,15 @@
 template <typename XprType, int Rows, int Cols, int Order>
 class ReshapedImpl_dense<XprType, Rows, Cols, Order, false>
     : public internal::dense_xpr_base<Reshaped<XprType, Rows, Cols, Order> >::type {
-  typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
+  using ReshapedType = Reshaped<XprType, Rows, Cols, Order>;
 
  public:
-  typedef typename internal::dense_xpr_base<ReshapedType>::type Base;
+  using Base = typename internal::dense_xpr_base<ReshapedType>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)
 
-  typedef typename internal::ref_selector<XprType>::non_const_type MatrixTypeNested;
-  typedef internal::remove_all_t<XprType> NestedExpression;
+  using MatrixTypeNested = typename internal::ref_selector<XprType>::non_const_type;
+  using NestedExpression = internal::remove_all_t<XprType>;
 
   class InnerIterator;
 
@@ -193,11 +197,11 @@
 /** \internal Internal implementation of dense Reshaped in the direct access case. */
 template <typename XprType, int Rows, int Cols, int Order>
 class ReshapedImpl_dense<XprType, Rows, Cols, Order, true> : public MapBase<Reshaped<XprType, Rows, Cols, Order> > {
-  typedef Reshaped<XprType, Rows, Cols, Order> ReshapedType;
-  typedef typename internal::ref_selector<XprType>::non_const_type XprTypeNested;
+  using ReshapedType = Reshaped<XprType, Rows, Cols, Order>;
+  using XprTypeNested = typename internal::ref_selector<XprType>::non_const_type;
 
  public:
-  typedef MapBase<ReshapedType> Base;
+  using Base = MapBase<ReshapedType>;
   EIGEN_DENSE_PUBLIC_INTERFACE(ReshapedType)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ReshapedImpl_dense)
 
@@ -233,10 +237,10 @@
 template <typename ArgType, int Rows, int Cols, int Order>
 struct evaluator<Reshaped<ArgType, Rows, Cols, Order> >
     : reshaped_evaluator<ArgType, Rows, Cols, Order, traits<Reshaped<ArgType, Rows, Cols, Order> >::HasDirectAccess> {
-  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = Reshaped<ArgType, Rows, Cols, Order>;
+  using Scalar = typename XprType::Scalar;
   // TODO: should check for smaller packet types
-  typedef typename packet_traits<Scalar>::type PacketScalar;
+  using PacketScalar = typename packet_traits<Scalar>::type;
 
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
@@ -248,23 +252,35 @@
     //     MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,
     //
     //     InnerStrideAtCompileTime = traits<XprType>::HasSameStorageOrderAsXprType
-    //                              ? int(inner_stride_at_compile_time<ArgType>::ret)
+    //                              ? int(inner_stride_at_compile_time<ArgType>::value)
     //                              : Dynamic,
     //     OuterStrideAtCompileTime = Dynamic,
 
-    FlagsLinearAccessBit =
-        (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1 || HasDirectAccess)
-            ? LinearAccessBit
-            : 0,
+    // Whether the coeff-based specialization below serves all accesses by forwarding the nested
+    // evaluator's own linear accesses; always false for the direct-access specialization.
+    ForwardLinearAccess = reshaped_evaluator<ArgType, Rows, Cols, Order, bool(HasDirectAccess)>::ForwardLinearAccess,
+
+    FlagsLinearAccessBit = (traits<XprType>::RowsAtCompileTime == 1 || traits<XprType>::ColsAtCompileTime == 1 ||
+                            HasDirectAccess || ForwardLinearAccess)
+                               ? LinearAccessBit
+                               : 0,
     FlagsRowMajorBit = (traits<XprType>::ReshapedStorageOrder == int(RowMajor)) ? RowMajorBit : 0,
     FlagsDirectAccessBit = HasDirectAccess ? DirectAccessBit : 0,
-    Flags0 = evaluator<ArgType>::Flags & (HereditaryBits & ~RowMajorBit),
+    // A direct-access reshape with unit inner stride is the nested expression's buffer, contiguous
+    // from data(), so the mapbase_evaluator packet paths apply whenever the nested evaluator's do.
+    // A forwarding coeff-based reshape serves the nested evaluator's own packets directly.
+    MaskPacketAccessBit = (HasDirectAccess && (traits<XprType>::InnerStrideAtCompileTime == 1)) || ForwardLinearAccess
+                              ? PacketAccessBit
+                              : 0,
+    Flags0 = evaluator<ArgType>::Flags & ((HereditaryBits & ~RowMajorBit) | MaskPacketAccessBit),
     Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit | FlagsDirectAccessBit,
 
     PacketAlignment = unpacket_traits<PacketScalar>::alignment,
+    // The view starts at the nested data() with no offset (direct access) or forwards the nested
+    // evaluator's accesses element-for-element, so its alignment carries over.
     Alignment = evaluator<ArgType>::Alignment
   };
-  typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> reshaped_evaluator_type;
+  using reshaped_evaluator_type = reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess>;
   EIGEN_DEVICE_FUNC constexpr explicit evaluator(const XprType& xpr) : reshaped_evaluator_type(xpr) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
@@ -273,14 +289,21 @@
 template <typename ArgType, int Rows, int Cols, int Order>
 struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ false>
     : evaluator_base<Reshaped<ArgType, Rows, Cols, Order> > {
-  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
+  using XprType = Reshaped<ArgType, Rows, Cols, Order>;
 
   enum {
     CoeffReadCost = evaluator<ArgType>::CoeffReadCost /* TODO + cost of index computations */,
 
-    Flags = (evaluator<ArgType>::Flags & (HereditaryBits /*| LinearAccessBit | DirectAccessBit*/)),
+    // The reshape enumerates the nested expression's elements in `Order`. When the nested
+    // evaluator and the reshape's storage both enumerate in that order, linear accesses and
+    // packets can forward unchanged. A vector shape makes only its own storage order immaterial.
+    NestedRowMajor = (int(evaluator<ArgType>::Flags) & RowMajorBit) != 0,
+    OrderMatchesNested = (Order == int(ColMajor)) != NestedRowMajor,
+    ForwardLinearAccess = (OrderMatchesNested || ArgType::RowsAtCompileTime == 1 || ArgType::ColsAtCompileTime == 1) &&
+                          (Order == int(traits<XprType>::ReshapedStorageOrder) || Rows == 1 || Cols == 1) &&
+                          ((int(evaluator<ArgType>::Flags) & LinearAccessBit) != 0)
 
-    Alignment = 0
+    // Flags and Alignment are defined by evaluator<Reshaped>, which derives from this evaluator.
   };
 
   EIGEN_DEVICE_FUNC constexpr explicit reshaped_evaluator(const XprType& xpr)
@@ -288,54 +311,170 @@
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }
 
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  using Scalar = typename XprType::Scalar;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
 
-  typedef std::pair<Index, Index> RowCol;
+  using RowCol = std::pair<Index, Index>;
+
+  // The n-th element of the reshape in `Order` enumeration; under ForwardLinearAccess this is also
+  // the nested evaluator's linear index of that element.
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Index linear_index(Index rowId, Index colId) const {
+    EIGEN_IF_CONSTEXPR (Order == ColMajor) {
+      return colId * m_xpr.rows() + rowId;
+    } else {
+      return colId + rowId * m_xpr.cols();
+    }
+  }
 
   EIGEN_DEVICE_FUNC constexpr inline RowCol index_remap(Index rowId, Index colId) const {
-    if (Order == ColMajor) {
-      const Index nth_elem_idx = colId * m_xpr.rows() + rowId;
+    const Index nth_elem_idx = linear_index(rowId, colId);
+    EIGEN_IF_CONSTEXPR (Order == ColMajor) {
       return RowCol(nth_elem_idx % m_xpr.nestedExpression().rows(), nth_elem_idx / m_xpr.nestedExpression().rows());
     } else {
-      const Index nth_elem_idx = colId + rowId * m_xpr.cols();
       return RowCol(nth_elem_idx / m_xpr.nestedExpression().cols(), nth_elem_idx % m_xpr.nestedExpression().cols());
     }
   }
 
   EIGEN_DEVICE_FUNC constexpr inline Scalar& coeffRef(Index rowId, Index colId) {
     EIGEN_STATIC_ASSERT_LVALUE(XprType)
-    const RowCol row_col = index_remap(rowId, colId);
-    return m_argImpl.coeffRef(row_col.first, row_col.second);
+    return coeffRef_impl(rowId, colId, bool_constant<ForwardLinearAccess>());
   }
 
   EIGEN_DEVICE_FUNC constexpr inline const Scalar& coeffRef(Index rowId, Index colId) const {
-    const RowCol row_col = index_remap(rowId, colId);
-    return m_argImpl.coeffRef(row_col.first, row_col.second);
+    return coeffRef_impl(rowId, colId, bool_constant<ForwardLinearAccess>());
   }
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const {
-    const RowCol row_col = index_remap(rowId, colId);
-    return m_argImpl.coeff(row_col.first, row_col.second);
+    return coeff_impl(rowId, colId, bool_constant<ForwardLinearAccess>());
   }
 
   EIGEN_DEVICE_FUNC constexpr inline Scalar& coeffRef(Index index) {
     EIGEN_STATIC_ASSERT_LVALUE(XprType)
-    const RowCol row_col = index_remap(Rows == 1 ? 0 : index, Rows == 1 ? index : 0);
-    return m_argImpl.coeffRef(row_col.first, row_col.second);
+    return coeffRef_impl(index, bool_constant<ForwardLinearAccess>());
   }
 
   EIGEN_DEVICE_FUNC constexpr inline const Scalar& coeffRef(Index index) const {
-    const RowCol row_col = index_remap(Rows == 1 ? 0 : index, Rows == 1 ? index : 0);
-    return m_argImpl.coeffRef(row_col.first, row_col.second);
+    return coeffRef_impl(index, bool_constant<ForwardLinearAccess>());
   }
 
   EIGEN_DEVICE_FUNC constexpr inline const CoeffReturnType coeff(Index index) const {
-    const RowCol row_col = index_remap(Rows == 1 ? 0 : index, Rows == 1 ? index : 0);
-    return m_argImpl.coeff(row_col.first, row_col.second);
+    return coeff_impl(index, bool_constant<ForwardLinearAccess>());
+  }
+
+  // The packet paths are advertised only under ForwardLinearAccess (see evaluator<Reshaped>), so
+  // they forward the nested evaluator's linear packets without index remapping.
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index rowId, Index colId) const {
+    return m_argImpl.template packet<LoadMode, PacketType>(linear_index(rowId, colId));
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+    return m_argImpl.template packet<LoadMode, PacketType>(index);
+  }
+
+  template <int StoreMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketType& x) {
+    m_argImpl.template writePacket<StoreMode, PacketType>(linear_index(rowId, colId), x);
+  }
+
+  template <int StoreMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x) {
+    m_argImpl.template writePacket<StoreMode, PacketType>(index, x);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index rowId, Index colId, Index begin,
+                                                                 Index count) const {
+    return m_argImpl.template packetSegment<LoadMode, PacketType>(linear_index(rowId, colId), begin, count);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketType packetSegment(Index index, Index begin, Index count) const {
+    return m_argImpl.template packetSegment<LoadMode, PacketType>(index, begin, count);
+  }
+
+  template <int StoreMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacketSegment(Index rowId, Index colId, const PacketType& x,
+                                                                Index begin, Index count) {
+    m_argImpl.template writePacketSegment<StoreMode, PacketType>(linear_index(rowId, colId), x, begin, count);
+  }
+
+  template <int StoreMode, typename PacketType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacketSegment(Index index, const PacketType& x, Index begin,
+                                                                Index count) {
+    m_argImpl.template writePacketSegment<StoreMode, PacketType>(index, x, begin, count);
   }
 
  protected:
+  // Linear-access members map an index onto the vector shape's single row or column.
+  EIGEN_DEVICE_FUNC static constexpr Index vector_row(Index index) { return Rows == 1 ? 0 : index; }
+  EIGEN_DEVICE_FUNC static constexpr Index vector_col(Index index) { return Rows == 1 ? index : 0; }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType
+  coeff_impl(Index index, std::true_type /* ForwardLinearAccess */) const {
+    // The one-dimensional index already follows the nested evaluator's linear enumeration.
+    return m_argImpl.coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType
+  coeff_impl(Index index, std::false_type /* not ForwardLinearAccess */) const {
+    return coeff_impl(vector_row(index), vector_col(index), std::false_type());
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType
+  coeff_impl(Index rowId, Index colId, std::true_type /* ForwardLinearAccess */) const {
+    return m_argImpl.coeff(linear_index(rowId, colId));
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CoeffReturnType
+  coeff_impl(Index rowId, Index colId, std::false_type /* not ForwardLinearAccess */) const {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeff(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar& coeffRef_impl(Index index,
+                                                                        std::true_type /* ForwardLinearAccess */) {
+    return m_argImpl.coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar& coeffRef_impl(Index index,
+                                                                        std::false_type /* not ForwardLinearAccess */) {
+    return coeffRef_impl(vector_row(index), vector_col(index), std::false_type());
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar& coeffRef_impl(Index rowId, Index colId,
+                                                                        std::true_type /* ForwardLinearAccess */) {
+    return m_argImpl.coeffRef(linear_index(rowId, colId));
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar& coeffRef_impl(Index rowId, Index colId,
+                                                                        std::false_type /* not ForwardLinearAccess */) {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Scalar& coeffRef_impl(
+      Index index, std::true_type /* ForwardLinearAccess */) const {
+    return m_argImpl.coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Scalar& coeffRef_impl(
+      Index index, std::false_type /* not ForwardLinearAccess */) const {
+    return coeffRef_impl(vector_row(index), vector_col(index), std::false_type());
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Scalar& coeffRef_impl(
+      Index rowId, Index colId, std::true_type /* ForwardLinearAccess */) const {
+    return m_argImpl.coeffRef(linear_index(rowId, colId));
+  }
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Scalar& coeffRef_impl(
+      Index rowId, Index colId, std::false_type /* not ForwardLinearAccess */) const {
+    const RowCol row_col = index_remap(rowId, colId);
+    return m_argImpl.coeffRef(row_col.first, row_col.second);
+  }
+
   evaluator<ArgType> m_argImpl;
   const XprType& m_xpr;
 };
@@ -344,13 +483,14 @@
 struct reshaped_evaluator<ArgType, Rows, Cols, Order, /* HasDirectAccess */ true>
     : mapbase_evaluator<Reshaped<ArgType, Rows, Cols, Order>,
                         typename Reshaped<ArgType, Rows, Cols, Order>::PlainObject> {
-  typedef Reshaped<ArgType, Rows, Cols, Order> XprType;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = Reshaped<ArgType, Rows, Cols, Order>;
+  using Scalar = typename XprType::Scalar;
+
+  // Packets come from the mapbase_evaluator machinery, not from linear forwarding.
+  enum { ForwardLinearAccess = false };
 
   EIGEN_DEVICE_FUNC constexpr explicit reshaped_evaluator(const XprType& xpr)
       : mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr) {
-    // TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta
-    // lifetime
     eigen_assert(((std::uintptr_t(xpr.data()) % plain_enum_max(1, evaluator<XprType>::Alignment)) == 0) &&
                  "data is not aligned");
   }
diff --git a/Eigen/src/Core/ReturnByValue.h b/Eigen/src/Core/ReturnByValue.h
index 410b77d..40d9636 100644
--- a/Eigen/src/Core/ReturnByValue.h
+++ b/Eigen/src/Core/ReturnByValue.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RETURNBYVALUE_H
 #define EIGEN_RETURNBYVALUE_H
@@ -37,7 +38,7 @@
  */
 template <typename Derived, int n, typename PlainObject>
 struct nested_eval<ReturnByValue<Derived>, n, PlainObject> {
-  typedef typename traits<Derived>::ReturnType type;
+  using type = typename traits<Derived>::ReturnType;
 };
 
 }  // end namespace internal
@@ -49,9 +50,9 @@
 template <typename Derived>
 class ReturnByValue : public internal::dense_xpr_base<ReturnByValue<Derived> >::type, internal::no_assignment_operator {
  public:
-  typedef typename internal::traits<Derived>::ReturnType ReturnType;
+  using ReturnType = typename internal::traits<Derived>::ReturnType;
 
-  typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
+  using Base = typename internal::dense_xpr_base<ReturnByValue>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue)
 
   template <typename Dest>
@@ -91,9 +92,9 @@
 
 template <typename Derived>
 struct evaluator<ReturnByValue<Derived> > : public evaluator<typename internal::traits<Derived>::ReturnType> {
-  typedef ReturnByValue<Derived> XprType;
-  typedef typename internal::traits<Derived>::ReturnType PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = ReturnByValue<Derived>;
+  using PlainObject = typename internal::traits<Derived>::ReturnType;
+  using Base = evaluator<PlainObject>;
 
   EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) {
     internal::construct_at<Base>(this, m_result);
diff --git a/Eigen/src/Core/Reverse.h b/Eigen/src/Core/Reverse.h
index a4af8d1..70a57f5 100644
--- a/Eigen/src/Core/Reverse.h
+++ b/Eigen/src/Core/Reverse.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REVERSE_H
 #define EIGEN_REVERSE_H
@@ -21,11 +22,11 @@
 
 template <typename MatrixType, int Direction>
 struct traits<Reverse<MatrixType, Direction> > : traits<MatrixType> {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename traits<MatrixType>::StorageKind StorageKind;
-  typedef typename traits<MatrixType>::XprKind XprKind;
-  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNested_;
+  using Scalar = typename MatrixType::Scalar;
+  using StorageKind = typename traits<MatrixType>::StorageKind;
+  using XprKind = typename traits<MatrixType>::XprKind;
+  using MatrixTypeNested = typename ref_selector<MatrixType>::type;
+  using MatrixTypeNested_ = std::remove_reference_t<MatrixTypeNested>;
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
@@ -64,9 +65,9 @@
 template <typename MatrixType, int Direction>
 class Reverse : public internal::dense_xpr_base<Reverse<MatrixType, Direction> >::type {
  public:
-  typedef typename internal::dense_xpr_base<Reverse>::type Base;
+  using Base = typename internal::dense_xpr_base<Reverse>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(Reverse)
-  typedef internal::remove_all_t<MatrixType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<MatrixType>;
   using Base::IsRowMajor;
 
  protected:
@@ -80,7 +81,7 @@
     ReversePacket = (Direction == BothDirections) || ((Direction == Vertical) && IsColMajor) ||
                     ((Direction == Horizontal) && IsRowMajor)
   };
-  typedef internal::reverse_packet_cond<PacketScalar, ReversePacket> reverse_packet;
+  using reverse_packet = internal::reverse_packet_cond<PacketScalar, ReversePacket>;
 
  public:
   EIGEN_DEVICE_FUNC constexpr explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) {}
@@ -111,7 +112,7 @@
   return ReverseReturnType(derived());
 }
 
-// reverse const overload moved DenseBase.h due to a CUDA compiler bug
+// reverse const overload moved to DenseBase.h due to a CUDA compiler bug
 
 /** This is the "in place" version of reverse: it reverses \c *this.
  *
diff --git a/Eigen/src/Core/SafeScaling.h b/Eigen/src/Core/SafeScaling.h
new file mode 100644
index 0000000..8849776
--- /dev/null
+++ b/Eigen/src/Core/SafeScaling.h
@@ -0,0 +1,428 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SAFE_SCALING_H
+#define EIGEN_SAFE_SCALING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+// Select factors for a positive finite scale. Supported binary floating-point scalars use normal powers of two;
+// other scalar types use division for matrix scaling and can request a clamped reciprocal for stableNorm(). General
+// scaling rounds down so it does not discard a representable tail that division by the original value would preserve.
+// Stable reductions separately round up to keep scaled magnitudes at most one. At the upper exponent boundary, the
+// scale is clamped to keep its reciprocal normal; for the standard binary formats this leaves magnitudes below four.
+template <typename Scalar>
+struct supports_power_of_two_scaling
+    : bool_constant<(std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value) &&
+                    std::numeric_limits<Scalar>::is_iec559 && std::numeric_limits<Scalar>::radix == 2 &&
+                    (sizeof(Scalar) == sizeof(numext::uint32_t) || sizeof(Scalar) == sizeof(numext::uint64_t))> {};
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+template <>
+struct supports_power_of_two_scaling<long double> : bool_constant<std::numeric_limits<long double>::radix == 2> {};
+#endif
+
+template <>
+struct supports_power_of_two_scaling<half> : true_type {};
+
+template <>
+struct supports_power_of_two_scaling<bfloat16> : true_type {};
+
+template <typename Scalar, bool = supports_power_of_two_scaling<Scalar>::value>
+struct safe_scaling;
+
+template <typename Scalar>
+struct safe_scaling_factors {
+  Scalar scale = Scalar(1);
+  // Division-only arithmetic scaling leaves this unused reciprocal at one.
+  Scalar invScale = Scalar(1);
+};
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE typename binary_floating_point_traits<Scalar>::Bits
+scale_binary_bits_by_power_of_two(const typename binary_floating_point_traits<Scalar>::Bits valueBits,
+                                  const typename binary_floating_point_traits<Scalar>::Bits factorExponentBits) {
+  using Binary = binary_floating_point_traits<Scalar>;
+  using Bits = typename Binary::Bits;
+
+  const Bits valueExponentBits = valueBits & Binary::kExponentMask;
+  const Bits fraction = valueBits & Binary::kFractionMask;
+  if (valueExponentBits == Binary::kExponentMask || (valueExponentBits == 0 && fraction == 0)) return valueBits;
+
+  Bits significand = fraction;
+  int exponent = int(valueExponentBits >> Binary::kFractionBits);
+  if (exponent == 0) {
+    exponent = 1;
+    while (significand < Binary::kExponentUnit) {
+      significand <<= 1;
+      --exponent;
+    }
+  }
+  exponent += int(factorExponentBits >> Binary::kFractionBits) - Binary::kExponentBias;
+  eigen_internal_assert(exponent < int(Binary::kExponentMask >> Binary::kFractionBits));
+  const Bits sign = valueBits & Binary::kSignBit;
+  if (exponent > 0) return sign | (Bits(exponent) << Binary::kFractionBits) | (significand & Binary::kFractionMask);
+
+  // Subnormal result m * 2^(exponent - 1) denorm_min, m = significand | kExponentUnit < 2 * kExponentUnit: round to
+  // nearest, ties to even, as IEEE 754 multiplication does. A carry into kExponentUnit encodes the smallest normal; for
+  // shift > kFractionBits + 1 the result is below denorm_min / 2 and rounds to a signed zero.
+  const int shift = 1 - exponent;
+  if (shift > Binary::kFractionBits + 1) return sign;
+  const Bits mantissa = significand | Binary::kExponentUnit;
+  const Bits halfway = Bits(1) << (shift - 1);
+  const Bits remainder = mantissa & ((halfway << 1) - 1);
+  Bits rounded = mantissa >> shift;
+  if (remainder > halfway || (remainder == halfway && (rounded & Bits(1)) != 0)) ++rounded;
+  return sign | rounded;
+}
+
+// Multiplication by a positive normal power of two through integer significands, so FTZ/DAZ cannot flush a subnormal
+// input or result; a subnormal result rounds as IEEE 754 multiplication does, and no result may overflow. Keep the
+// integer-only ABI so compilers cannot replace reconstruction with FTZ/DAZ-sensitive floating-point arithmetic.
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar scale_binary_by_power_of_two(const Scalar& value, const Scalar& factor) {
+  using Binary = binary_floating_point_traits<Scalar>;
+  using Bits = typename Binary::Bits;
+  const Bits factorExponentBits = Binary::bits(factor);
+  eigen_internal_assert(factorExponentBits != 0 && factorExponentBits < Binary::kExponentMask &&
+                        (factorExponentBits & ~Binary::kExponentMask) == 0);
+  return numext::bit_cast<Scalar>(scale_binary_bits_by_power_of_two<Scalar>(Binary::bits(value), factorExponentBits));
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<Scalar> scale_binary_by_power_of_two(
+    const std::complex<Scalar>& value, const Scalar& factor) {
+  return std::complex<Scalar>(scale_binary_by_power_of_two(value.real(), factor),
+                              scale_binary_by_power_of_two(value.imag(), factor));
+}
+
+template <typename FactorScalar>
+struct scale_by_power_of_two_op {
+  EIGEN_DEVICE_FUNC explicit scale_by_power_of_two_op(const FactorScalar& factor) : m_factor(factor) {}
+
+  template <typename CoeffScalar>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffScalar operator()(const CoeffScalar& value) const {
+    return scale_binary_by_power_of_two(value, m_factor);
+  }
+
+  FactorScalar m_factor;
+};
+
+template <typename FactorScalar>
+struct functor_traits<scale_by_power_of_two_op<FactorScalar>> {
+  // Integer significand scaling is scalar and calls an out-of-line helper.
+  static constexpr int Cost = 10 * NumTraits<FactorScalar>::MulCost;
+  static constexpr bool PacketAccess = false;
+  static constexpr bool IsRepeatable = true;
+};
+
+template <typename FactorScalar, typename CoeffScalar>
+struct use_subnormal_preserving_scaling
+    : bool_constant<
+          (std::is_same<FactorScalar, float>::value &&
+           (std::is_same<CoeffScalar, float>::value || std::is_same<CoeffScalar, std::complex<float>>::value)) ||
+          (std::is_same<FactorScalar, double>::value &&
+           (std::is_same<CoeffScalar, double>::value || std::is_same<CoeffScalar, std::complex<double>>::value))> {};
+
+template <typename Scalar, bool IsPowerOfTwo_>
+struct safe_scaling_operations {
+ private:
+  using Factors = safe_scaling_factors<Scalar>;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool needs_subnormal_recovery(const Scalar& value) {
+    using Binary = binary_floating_point_traits<Scalar>;
+    using Bits = typename Binary::Bits;
+    constexpr int kDirectScaleExponent = std::numeric_limits<Scalar>::min_exponent + Binary::kFractionBits - 1;
+    constexpr Bits kThreshold = Bits(kDirectScaleExponent + Binary::kExponentBias) << Binary::kFractionBits;
+    return Binary::magnitude(value) - Bits(1) < kThreshold - Bits(1);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool is_identity(const Factors& factors) {
+    return factors.scale == Scalar(1) && factors.invScale == Scalar(1);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool has_normal_reciprocal(const Scalar&, const Scalar&, false_type) {
+    return false;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool has_normal_reciprocal(const Scalar& value, const Scalar& normalMin,
+                                                                          true_type) {
+    return value >= normalMin && value <= Scalar(1) / normalMin;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool is_positive_finite(const Scalar& value, false_type) {
+    return value > Scalar(0) && value <= NumTraits<Scalar>::highest();
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool is_positive_finite(const Scalar& value, true_type) {
+    using Binary = binary_floating_point_traits<Scalar>;
+    const typename Binary::Bits bits = Binary::bits(value);
+    return bits > 0 && bits < Binary::kExponentMask;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Factors select_factors(const Scalar& maxCoeff) {
+    using IsIeeeBinary = bool_constant<std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value>;
+    if (!is_positive_finite(maxCoeff, IsIeeeBinary())) return Factors{};
+    return safe_scaling<Scalar, IsPowerOfTwo_>::compute_floor_factors(maxCoeff);
+  }
+
+  template <typename Src, typename Func>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void with_scaled_impl(const Src& src, const Scalar&,
+                                                                     const Factors& factors, const Func& func,
+                                                                     false_type) {
+    if (is_identity(factors)) {
+      // Keep the copy distinct from multiplication by one, which flushes subnormals under FTZ.
+      const Src* unscaled = &src;
+      EIGEN_OPTIMIZATION_BARRIER(unscaled);
+      func(*unscaled);
+    } else EIGEN_IF_CONSTEXPR (IsPowerOfTwo_)
+      func(src * factors.invScale);
+    else
+      func(src / factors.scale);
+  }
+
+  template <typename Src, typename Func>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void with_scaled_impl(const Src& src, const Scalar& maxCoeff,
+                                                                     const Factors& factors, const Func& func,
+                                                                     true_type) {
+    if (!is_identity(factors) && needs_subnormal_recovery(maxCoeff))
+      func(src.unaryExpr(scale_by_power_of_two_op<Scalar>(factors.invScale)));
+    else
+      with_scaled_impl(src, maxCoeff, factors, func, false_type());
+  }
+
+  template <typename Dest, typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void unscale_to_impl(Dest& dest, const Src& src, const Scalar&,
+                                                                    const Factors& factors, false_type) {
+    unscale_to(dest, src, factors);
+  }
+
+  // Below the recovery threshold, unscaling rounds coefficients that are significant relative to maxCoeff into the
+  // subnormal range, where FTZ/DAZ arithmetic would zero them.
+  template <typename Dest, typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void unscale_to_impl(Dest& dest, const Src& src, const Scalar& maxCoeff,
+                                                                    const Factors& factors, true_type) {
+    if (!is_identity(factors) && needs_subnormal_recovery(maxCoeff))
+      dest = src.unaryExpr(scale_by_power_of_two_op<Scalar>(factors.scale));
+    else
+      unscale_to_impl(dest, src, maxCoeff, factors, false_type());
+  }
+
+  template <typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar recover_flushed_max_coeff_impl(const Src&, const Scalar& maxCoeff,
+                                                                                     false_type) {
+    return maxCoeff;
+  }
+
+  template <typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar recover_flushed_max_coeff_impl(const Src& src,
+                                                                                     const Scalar& maxCoeff,
+                                                                                     true_type) {
+    using Binary = binary_floating_point_traits<Scalar>;
+    using Bits = typename Binary::Bits;
+    if (Binary::magnitude(maxCoeff) != 0) return maxCoeff;
+    // A product expression has no coefficient access; its evaluator materializes it.
+    const evaluator<Src> coeffs(src);
+    Bits maxBits = 0;
+    for (Index col = 0; col < src.cols(); ++col) {
+      for (Index row = 0; row < src.rows(); ++row) {
+        const typename Src::Scalar coeff = coeffs.coeff(row, col);
+        maxBits = numext::maxi(
+            maxBits, numext::maxi(Binary::magnitude(numext::real(coeff)), Binary::magnitude(numext::imag(coeff))));
+      }
+    }
+    return numext::bit_cast<Scalar>(maxBits);
+  }
+
+ public:
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Factors
+  compute_ceiling_factors_with_normal_reciprocal(const Scalar& value) {
+    Factors factors = safe_scaling<Scalar, IsPowerOfTwo_>::compute_ceiling_factors(value);
+    EIGEN_IF_CONSTEXPR (!IsPowerOfTwo_) {
+      if (factors.invScale > NumTraits<Scalar>::highest()) {
+        factors.invScale = NumTraits<Scalar>::highest();
+        factors.scale = Scalar(1) / factors.invScale;
+      }
+    }
+    return factors;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool try_compute_ceiling_factors_with_normal_reciprocal(
+      const Scalar& value, const Scalar& normalMin, Factors& factors) {
+    if (!IsPowerOfTwo_ &&
+        !has_normal_reciprocal(value, normalMin, bool_constant<std::is_floating_point<Scalar>::value>()))
+      return false;
+    factors = compute_ceiling_factors_with_normal_reciprocal(value);
+    return true;
+  }
+
+  // Dispatch once per expression; ordinary scaling retains packet access. The callback consumes the lazy
+  // expression before its operands expire, without requiring a common C++ type for the different paths.
+  template <typename Src, typename Func>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Factors with_scaled(const Src& src, const Scalar& maxCoeff,
+                                                                   const Func& func) {
+    const Factors factors = select_factors(maxCoeff);
+    constexpr bool kPreserveSubnormalInputs =
+        IsPowerOfTwo_ && use_subnormal_preserving_scaling<Scalar, typename Src::Scalar>::value;
+    with_scaled_impl(src, maxCoeff, factors, func, bool_constant<kPreserveSubnormalInputs>());
+    return factors;
+  }
+
+  template <typename Dest, typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void unscale_to(Dest&& dest, const Src& src, const Factors& factors) {
+    if (factors.scale == Scalar(1)) {
+      const Src* unscaled = &src;
+      EIGEN_OPTIMIZATION_BARRIER(unscaled);
+      dest = *unscaled;
+      return;
+    }
+    dest = src * factors.scale;
+  }
+
+  template <typename ValueType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void unscale_in_place(ValueType& value, const Factors& factors) {
+    if (factors.scale == Scalar(1)) return;
+    value *= factors.scale;
+  }
+
+  template <typename MatrixType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void unscale_in_place(MatrixType& matrix, const Scalar& maxCoeff,
+                                                                     const Factors& factors) {
+    if (factors.scale == Scalar(1)) return;
+    unscale_to(matrix, matrix, maxCoeff, factors);
+  }
+
+  template <typename Dest, typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void unscale_to(Dest&& dest, const Src& src, const Scalar& maxCoeff,
+                                                               const Factors& factors) {
+    constexpr bool kPreserveSubnormalOutputs =
+        IsPowerOfTwo_ && use_subnormal_preserving_scaling<Scalar, typename Src::Scalar>::value;
+    unscale_to_impl(dest, src, maxCoeff, factors, bool_constant<kPreserveSubnormalOutputs>());
+  }
+
+  // A SIMD unit that flushes subnormal inputs (ARMv7 NEON, Arm FZ, DAZ) reduces an all-subnormal matrix to a zero
+  // maximum, so rescan a zero maxCoeff from the representation. Any subnormal maximum, including the largest real or
+  // imaginary magnitude of a complex matrix, selects the same factors as the true one.
+  template <typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar recover_flushed_max_coeff(const Src& src,
+                                                                                const Scalar& maxCoeff) {
+    constexpr bool kPreserveSubnormalInputs =
+        IsPowerOfTwo_ && use_subnormal_preserving_scaling<Scalar, typename Src::Scalar>::value;
+    return recover_flushed_max_coeff_impl(src, maxCoeff, bool_constant<kPreserveSubnormalInputs>());
+  }
+
+  template <typename MatrixType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Factors scale_in_place(MatrixType& matrix, const Scalar& maxCoeff) {
+    const Factors factors = select_factors(maxCoeff);
+    scale_in_place(matrix, maxCoeff, factors);
+    return factors;
+  }
+
+  template <typename MatrixType>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scale_in_place(MatrixType& matrix, const Scalar& maxCoeff,
+                                                                   const Factors& factors) {
+    if (!is_identity(factors)) scale_to(matrix, matrix, maxCoeff, factors);
+  }
+
+  template <typename Dest, typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scale_to(Dest& dest, const Src& src, const Scalar& maxCoeff,
+                                                             const Factors& factors) {
+    constexpr bool kPreserveSubnormalInputs =
+        IsPowerOfTwo_ && use_subnormal_preserving_scaling<Scalar, typename Src::Scalar>::value;
+    with_scaled_impl(
+        src, maxCoeff, factors, [&](const auto& scaled) { dest = scaled; }, bool_constant<kPreserveSubnormalInputs>());
+  }
+
+  template <typename Dest, typename Src>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Factors scale_to(Dest& dest, const Src& src, const Scalar& maxCoeff) {
+    const Factors factors = select_factors(maxCoeff);
+    scale_to(dest, src, maxCoeff, factors);
+    return factors;
+  }
+};
+
+template <typename Scalar, bool>
+struct safe_scaling : safe_scaling_operations<Scalar, false> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE safe_scaling_factors<Scalar> compute_floor_factors(const Scalar& value) {
+    return {value, Scalar(1)};
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE safe_scaling_factors<Scalar> compute_ceiling_factors(
+      const Scalar& value) {
+    return {value, Scalar(1) / value};
+  }
+};
+
+template <typename Scalar>
+struct safe_scaling<Scalar, true> : safe_scaling_operations<Scalar, true> {
+ private:
+  using Binary = binary_floating_point_traits<Scalar>;
+  using Bits = typename Binary::Bits;
+
+  template <bool RoundUp>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE safe_scaling_factors<Scalar> compute_power_of_two_factors(
+      const Scalar& value) {
+    constexpr Bits kMaxScale = Binary::kMaxFiniteExponentBits - Binary::kExponentUnit;
+    Bits scaleBits = RoundUp ? numext::bit_cast<Bits>(numext::ceil_power_of_two(value))
+                             : Binary::bits(value) & Binary::kExponentMask;
+    if (scaleBits < Binary::kExponentUnit) scaleBits = Binary::kExponentUnit;
+    if (scaleBits > kMaxScale) scaleBits = kMaxScale;
+    const Bits invScaleBits = Bits(Binary::kMaxFiniteExponentBits - scaleBits);
+    return {numext::bit_cast<Scalar>(scaleBits), numext::bit_cast<Scalar>(invScaleBits)};
+  }
+
+ public:
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE safe_scaling_factors<Scalar> compute_floor_factors(const Scalar& value) {
+    return compute_power_of_two_factors<false>(value);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE safe_scaling_factors<Scalar> compute_ceiling_factors(
+      const Scalar& value) {
+    return compute_power_of_two_factors<true>(value);
+  }
+};
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+template <>
+struct safe_scaling<long double, true> : safe_scaling_operations<long double, true> {
+  static EIGEN_STRONG_INLINE safe_scaling_factors<long double> compute_floor_factors(const long double& value) {
+    EIGEN_USING_STD(frexp);
+    int exponent = 0;
+    frexp(value, &exponent);
+    return compute_factors_from_exponent(exponent - 1);
+  }
+
+  static EIGEN_STRONG_INLINE safe_scaling_factors<long double> compute_ceiling_factors(const long double& value) {
+    EIGEN_USING_STD(frexp);
+    int exponent = 0;
+    const long double fraction = frexp(value, &exponent);
+    if (numext::equal_strict(fraction, 0.5L)) --exponent;
+    return compute_factors_from_exponent(exponent);
+  }
+
+ private:
+  static EIGEN_STRONG_INLINE safe_scaling_factors<long double> compute_factors_from_exponent(int exponent) {
+    constexpr int kMinNormalExponent = std::numeric_limits<long double>::min_exponent - 1;
+    constexpr int kMaxNormalExponent = std::numeric_limits<long double>::max_exponent - 1;
+    constexpr int kMinScaleExponent =
+        kMinNormalExponent > -kMaxNormalExponent ? kMinNormalExponent : -kMaxNormalExponent;
+    constexpr int kMaxScaleExponent =
+        kMaxNormalExponent < -kMinNormalExponent ? kMaxNormalExponent : -kMinNormalExponent;
+    if (exponent < kMinScaleExponent) exponent = kMinScaleExponent;
+    if (exponent > kMaxScaleExponent) exponent = kMaxScaleExponent;
+
+    EIGEN_USING_STD(ldexp);
+    const long double scale = ldexp(1.0L, exponent);
+    return {scale, 1.0L / scale};
+  }
+};
+#endif
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_SAFE_SCALING_H
diff --git a/Eigen/src/Core/ScaledPermutationMatrix.h b/Eigen/src/Core/ScaledPermutationMatrix.h
new file mode 100644
index 0000000..1d7dc38
--- /dev/null
+++ b/Eigen/src/Core/ScaledPermutationMatrix.h
@@ -0,0 +1,708 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SCALEDPERMUTATIONMATRIX_H
+#define EIGEN_SCALEDPERMUTATIONMATRIX_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
+struct traits<ScaledPermutationMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>> {
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  // Dense, so that products and sums with dense operands promote with the existing rules; the O(n) kernels are
+  // selected by the shape (ScaledPermutationShape), as for TriangularView.
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using PermutationType = PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>;
+  using ScalesType = Matrix<Scalar_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>;
+  static constexpr int RowsAtCompileTime = SizeAtCompileTime;
+  static constexpr int ColsAtCompileTime = SizeAtCompileTime;
+  static constexpr int MaxRowsAtCompileTime = MaxSizeAtCompileTime;
+  static constexpr int MaxColsAtCompileTime = MaxSizeAtCompileTime;
+  static constexpr unsigned int Flags = NestByRefBit;
+};
+
+/** \internal The scaled permutation produced by a permutation-like and a diagonal-like operand. */
+template <typename Scalar, typename Lhs, typename Rhs, typename StorageIndex>
+struct scaled_permutation_result {
+  static constexpr int Size = size_prefer_fixed(traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime);
+  static constexpr int MaxSize =
+      min_size_prefer_fixed(traits<Lhs>::MaxRowsAtCompileTime, traits<Rhs>::MaxRowsAtCompileTime);
+  using type = ScaledPermutationMatrix<Scalar, Size, MaxSize, StorageIndex>;
+};
+
+template <typename Lhs, typename Rhs, typename StorageIndex>
+struct scaled_permutation_product_result {
+  using LhsScalar = typename traits<Lhs>::Scalar;
+  using RhsScalar = typename traits<Rhs>::Scalar;
+  using Scalar =
+      typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_product_op<LhsScalar, RhsScalar>>::ReturnType;
+  using type = typename scaled_permutation_result<Scalar, Lhs, Rhs, StorageIndex>::type;
+};
+
+/** \internal indices of the inverse permutation: result(indices(k)) = k. */
+template <typename IndicesType, typename Result>
+EIGEN_DEVICE_FUNC void invert_permutation_indices(const IndicesType& indices, Result& result) {
+  using StorageIndex = typename Result::Scalar;
+  for (Index k = 0; k < indices.size(); ++k) result.coeffRef(indices.coeff(k)) = StorageIndex(k);
+}
+
+}  // namespace internal
+
+/** \class ScaledPermutationBase
+ * \ingroup Core_Module
+ *
+ * \brief Base class for scaled permutation matrices
+ *
+ * A scaled permutation is the product \f$P D\f$ of a permutation matrix and a diagonal matrix: a square matrix with
+ * exactly one nonzero per row and per column. It is stored as the permutation's indices and one scale per
+ * column, so that coefficient (indices()(k), k) equals scales()(k).
+ *
+ * The set is closed under products with permutations, diagonal matrices, scalars and other scaled permutations,
+ * and under inversion and transposition; all of these cost \f$O(n)\f$ and return a plain ScaledPermutationMatrix.
+ * Products with a dense matrix scale and permute its rows or columns in \f$O(nm)\f$, and assigning to a dense matrix
+ * scatters the scales, so writing `P * D * x` or `P * D * P.inverse()` never forms an \f$n \times n\f$ intermediate.
+ * Sums with a dense matrix are lazy expressions.
+ *
+ * \sa class ScaledPermutationMatrix, class PermutationBase, class DiagonalBase
+ */
+template <typename Derived>
+class ScaledPermutationBase : public EigenBase<Derived> {
+  using Traits = internal::traits<Derived>;
+  using Base = EigenBase<Derived>;
+
+ public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  using Scalar = typename Traits::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = typename Traits::StorageIndex;
+  using StorageKind = typename Traits::StorageKind;
+  using PermutationType = typename Traits::PermutationType;
+  using ScalesType = typename Traits::ScalesType;
+  using IndicesType = typename PermutationType::IndicesType;
+  static constexpr int RowsAtCompileTime = Traits::RowsAtCompileTime;
+  static constexpr int ColsAtCompileTime = Traits::ColsAtCompileTime;
+  static constexpr int MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime;
+  static constexpr int MaxColsAtCompileTime = Traits::MaxColsAtCompileTime;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(RowsAtCompileTime, ColsAtCompileTime);
+  static constexpr int MaxSizeAtCompileTime =
+      internal::size_at_compile_time(MaxRowsAtCompileTime, MaxColsAtCompileTime);
+  static constexpr bool IsVectorAtCompileTime = false;
+  static constexpr unsigned int Flags = Traits::Flags;
+  using DenseMatrixType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+  using PlainObject = ScaledPermutationMatrix<Scalar, RowsAtCompileTime, MaxRowsAtCompileTime, StorageIndex>;
+  using Nested = const Derived&;
+  using Base::derived;
+#endif
+
+  /** \returns the number of rows */
+  EIGEN_DEVICE_FUNC constexpr Index rows() const { return indices().size(); }
+  /** \returns the number of columns */
+  EIGEN_DEVICE_FUNC constexpr Index cols() const { return indices().size(); }
+
+  /** \returns the permutation factor \f$P\f$ */
+  EIGEN_DEVICE_FUNC const PermutationType& permutation() const { return derived().permutation(); }
+  /** \returns the permutation's indices: column \c k has its nonzero in row `indices()(k)` */
+  EIGEN_DEVICE_FUNC constexpr const IndicesType& indices() const { return derived().indices(); }
+  /** \returns the scales: column \c k's nonzero equals `scales()(k)` */
+  EIGEN_DEVICE_FUNC const ScalesType& scales() const { return derived().scales(); }
+
+  /** \returns the coefficient at (\a row, \a col) of the represented matrix */
+  EIGEN_DEVICE_FUNC Scalar coeff(Index row, Index col) const {
+    eigen_assert(row >= 0 && col >= 0 && row < rows() && col < cols());
+    return Index(indices().coeff(col)) == row ? scales().coeff(col) : Scalar(0);
+  }
+
+  /** \returns the represented matrix as a plain dense matrix */
+  EIGEN_DEVICE_FUNC DenseMatrixType toDenseMatrix() const { return derived(); }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename DenseDerived>
+  EIGEN_DEVICE_FUNC void evalTo(MatrixBase<DenseDerived>& other) const {
+    other.setZero();
+    for (Index k = 0; k < rows(); ++k) other.coeffRef(indices().coeff(k), k) = scales().coeff(k);
+  }
+#endif
+
+  /** \returns the inverse, \f$(PD)^{-1} = D^{-1} P^{-1}\f$, which has \f$1 / \text{scales}(k)\f$ at
+   * (\c k, `indices()(k)`). The scales must be nonzero. */
+  PlainObject inverse() const {
+    PlainObject result(rows());
+    for (Index k = 0; k < rows(); ++k) {
+      const Index image = indices().coeff(k);
+      result.indices().coeffRef(image) = StorageIndex(k);
+      result.scales().coeffRef(image) = Scalar(1) / scales().coeff(k);
+    }
+    return result;
+  }
+
+  /** \returns the transpose, which has `scales()(k)` at (\c k, `indices()(k)`) */
+  PlainObject transpose() const {
+    PlainObject result(rows());
+    for (Index k = 0; k < rows(); ++k) {
+      const Index image = indices().coeff(k);
+      result.indices().coeffRef(image) = StorageIndex(k);
+      result.scales().coeffRef(image) = scales().coeff(k);
+    }
+    return result;
+  }
+
+  /** \returns the adjoint, the transpose with conjugated scales */
+  PlainObject adjoint() const {
+    PlainObject result = transpose();
+    result.scales() = result.scales().conjugate();
+    return result;
+  }
+
+  /** \returns the determinant, the permutation's sign times the product of the scales */
+  Scalar determinant() const { return Scalar(RealScalar(permutation().determinant())) * scales().prod(); }
+
+  /** \returns the dense matrix product of \c *this by the dense matrix \a other: rows of \a other are scaled and
+   * permuted. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC const Product<Derived, OtherDerived, DefaultProduct> operator*(
+      const MatrixBase<OtherDerived>& other) const {
+    return Product<Derived, OtherDerived, DefaultProduct>(derived(), other.derived());
+  }
+
+  /** \returns the dense matrix product of the dense matrix \a other by \a scaled: columns of \a other are scaled
+   * and permuted. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend const Product<OtherDerived, Derived, DefaultProduct> operator*(
+      const MatrixBase<OtherDerived>& other, const ScaledPermutationBase& scaled) {
+    return Product<OtherDerived, Derived, DefaultProduct>(other.derived(), scaled.derived());
+  }
+
+  /** \returns the dense matrix product of \c *this by the triangular or self-adjoint view \a other */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC const Product<Derived, OtherDerived, DefaultProduct> operator*(
+      const TriangularBase<OtherDerived>& other) const {
+    return Product<Derived, OtherDerived, DefaultProduct>(derived(), other.derived());
+  }
+
+  /** \returns the dense matrix product of the triangular or self-adjoint view \a other by \a scaled */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend const Product<OtherDerived, Derived, DefaultProduct> operator*(
+      const TriangularBase<OtherDerived>& other, const ScaledPermutationBase& scaled) {
+    return Product<OtherDerived, Derived, DefaultProduct>(other.derived(), scaled.derived());
+  }
+
+  // Closed-form products, all O(n). With S e_c = v_c e_{tau(c)} the rules are:
+  //   S D: scale v_c d_c            D S: scale d_{tau(c)} v_c
+  //   S P: (tau(sigma(c)), v_{sigma(c)})   P S: (sigma(tau(c)), v_c)
+  //   S T: (tau(tau2(c)), v_{tau2(c)} v2_c)
+
+  /** \returns the scaled permutation \c *this times the diagonal matrix \a other */
+  template <typename OtherDerived>
+  typename internal::scaled_permutation_product_result<Derived, OtherDerived, StorageIndex>::type operator*(
+      const DiagonalBase<OtherDerived>& other) const {
+    using Result = typename internal::scaled_permutation_product_result<Derived, OtherDerived, StorageIndex>::type;
+    eigen_assert(rows() == other.rows());
+    return Result(indices(), scales().cwiseProduct(other.diagonal()));
+  }
+
+  /** \returns the scaled permutation diagonal matrix \a other times \a scaled */
+  template <typename OtherDerived>
+  friend typename internal::scaled_permutation_product_result<OtherDerived, Derived, StorageIndex>::type operator*(
+      const DiagonalBase<OtherDerived>& other, const ScaledPermutationBase& scaled) {
+    using Result = typename internal::scaled_permutation_product_result<OtherDerived, Derived, StorageIndex>::type;
+    eigen_assert(other.rows() == scaled.rows());
+    Result result(scaled.rows());
+    result.indices() = scaled.indices();
+    for (Index k = 0; k < scaled.rows(); ++k)
+      result.scales().coeffRef(k) = other.diagonal().coeff(scaled.indices().coeff(k)) * scaled.scales().coeff(k);
+    return result;
+  }
+
+  /** \returns the scaled permutation \c *this times the permutation \a other */
+  template <typename OtherDerived>
+  PlainObject operator*(const PermutationBase<OtherDerived>& other) const {
+    eigen_assert(rows() == other.rows());
+    PlainObject result(rows());
+    for (Index k = 0; k < rows(); ++k) {
+      const Index source = other.indices().coeff(k);
+      result.indices().coeffRef(k) = indices().coeff(source);
+      result.scales().coeffRef(k) = scales().coeff(source);
+    }
+    return result;
+  }
+
+  /** \returns the scaled permutation permutation \a other times \a scaled */
+  template <typename OtherDerived>
+  friend PlainObject operator*(const PermutationBase<OtherDerived>& other, const ScaledPermutationBase& scaled) {
+    eigen_assert(other.rows() == scaled.rows());
+    PlainObject result(scaled.rows());
+    for (Index k = 0; k < scaled.rows(); ++k)
+      result.indices().coeffRef(k) = StorageIndex(other.indices().coeff(scaled.indices().coeff(k)));
+    result.scales() = scaled.scales();
+    return result;
+  }
+
+  /** \returns the scaled permutation \c *this times the inverse permutation \a other */
+  template <typename OtherDerived>
+  PlainObject operator*(const InverseImpl<OtherDerived, PermutationStorage>& other) const {
+    eigen_assert(rows() == other.rows());
+    IndicesType inverse(rows());
+    internal::invert_permutation_indices(other.derived().nestedExpression().indices(), inverse);
+    PlainObject result(rows());
+    for (Index k = 0; k < rows(); ++k) {
+      const Index source = inverse.coeff(k);
+      result.indices().coeffRef(k) = indices().coeff(source);
+      result.scales().coeffRef(k) = scales().coeff(source);
+    }
+    return result;
+  }
+
+  /** \returns the scaled permutation inverse permutation \a other times \a scaled */
+  template <typename OtherDerived>
+  friend PlainObject operator*(const InverseImpl<OtherDerived, PermutationStorage>& other,
+                               const ScaledPermutationBase& scaled) {
+    eigen_assert(other.rows() == scaled.rows());
+    IndicesType inverse(scaled.rows());
+    internal::invert_permutation_indices(other.derived().nestedExpression().indices(), inverse);
+    PlainObject result(scaled.rows());
+    for (Index k = 0; k < scaled.rows(); ++k) result.indices().coeffRef(k) = inverse.coeff(scaled.indices().coeff(k));
+    result.scales() = scaled.scales();
+    return result;
+  }
+
+  /** \returns the scaled permutation \c *this times the scaled permutation \a other */
+  template <typename OtherDerived>
+  typename internal::scaled_permutation_product_result<Derived, OtherDerived, StorageIndex>::type operator*(
+      const ScaledPermutationBase<OtherDerived>& other) const {
+    using Result = typename internal::scaled_permutation_product_result<Derived, OtherDerived, StorageIndex>::type;
+    eigen_assert(rows() == other.rows());
+    Result result(rows());
+    for (Index k = 0; k < rows(); ++k) {
+      const Index source = other.indices().coeff(k);
+      result.indices().coeffRef(k) = indices().coeff(source);
+      result.scales().coeffRef(k) = scales().coeff(source) * other.scales().coeff(k);
+    }
+    return result;
+  }
+
+  /** \returns \c *this with its scales multiplied by \a alpha */
+  PlainObject operator*(const Scalar& alpha) const { return PlainObject(indices(), scales() * alpha); }
+
+  /** \returns \a scaled with its scales multiplied by \a alpha */
+  friend PlainObject operator*(const Scalar& alpha, const ScaledPermutationBase& scaled) {
+    return PlainObject(scaled.indices(), alpha * scaled.scales());
+  }
+
+  /** \returns \c *this with its scales negated */
+  PlainObject operator-() const { return PlainObject(indices(), -scales()); }
+
+  // Sums with a dense matrix are lazy: the scaled permutation is read through its index-based evaluator.
+
+  /** \returns the lazy sum of the dense matrix \a lhs and the scaled permutation \a rhs */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend const EIGEN_CWISE_BINARY_RETURN_TYPE(OtherDerived, Derived, internal::scalar_sum_op)
+  operator+(const MatrixBase<OtherDerived>& lhs, const ScaledPermutationBase & rhs) {
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(OtherDerived, Derived, internal::scalar_sum_op)(lhs.derived(), rhs.derived());
+  }
+
+  /** \returns the lazy sum of the scaled permutation \a lhs and the dense matrix \a rhs */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, internal::scalar_sum_op)
+  operator+(const ScaledPermutationBase & lhs, const MatrixBase<OtherDerived>& rhs) {
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, internal::scalar_sum_op)(lhs.derived(), rhs.derived());
+  }
+
+  /** \returns the lazy difference of the dense matrix \a lhs and the scaled permutation \a rhs */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend const EIGEN_CWISE_BINARY_RETURN_TYPE(OtherDerived, Derived, internal::scalar_difference_op)
+  operator-(const MatrixBase<OtherDerived>& lhs, const ScaledPermutationBase & rhs) {
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(OtherDerived, Derived, internal::scalar_difference_op)(lhs.derived(),
+                                                                                                 rhs.derived());
+  }
+
+  /** \returns the lazy difference of the scaled permutation \a lhs and the dense matrix \a rhs */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, internal::scalar_difference_op)
+  operator-(const ScaledPermutationBase & lhs, const MatrixBase<OtherDerived>& rhs) {
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, internal::scalar_difference_op)(lhs.derived(),
+                                                                                                 rhs.derived());
+  }
+};
+
+/** \class ScaledPermutationMatrix
+ * \ingroup Core_Module
+ *
+ * \brief Scaled permutation matrix \f$P D\f$ with its storage
+ *
+ * \tparam Scalar_ the type of the scales
+ * \tparam SizeAtCompileTime the number of rows/cols, or Dynamic
+ * \tparam MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic; defaults to SizeAtCompileTime
+ * \tparam StorageIndex_ the integer type of the permutation's indices
+ *
+ * This is the type returned by the products of a permutation (or its inverse) and a diagonal matrix, in either
+ * order. See ScaledPermutationBase for the operations.
+ *
+ * \sa class ScaledPermutationBase, class PermutationMatrix, class DiagonalMatrix
+ */
+template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
+class ScaledPermutationMatrix
+    : public ScaledPermutationBase<
+          ScaledPermutationMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>> {
+  using Base = ScaledPermutationBase<ScaledPermutationMatrix>;
+  using Traits = internal::traits<ScaledPermutationMatrix>;
+
+ public:
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using PermutationType = typename Traits::PermutationType;
+  using ScalesType = typename Traits::ScalesType;
+  using IndicesType = typename PermutationType::IndicesType;
+#endif
+
+  /** Default constructor; the matrix is uninitialized. */
+  EIGEN_DEVICE_FUNC ScaledPermutationMatrix() = default;
+
+  /** Constructs an uninitialized scaled permutation of the given size. */
+  EIGEN_DEVICE_FUNC explicit ScaledPermutationMatrix(Index size) : m_permutation(size), m_scales(size) {}
+
+  /** Constructs the product \a permutation times \a diagonal. */
+  template <typename PermutationDerived, typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC ScaledPermutationMatrix(const PermutationBase<PermutationDerived>& permutation,
+                                            const DiagonalBase<DiagonalDerived>& diagonal)
+      : m_permutation(permutation), m_scales(diagonal.diagonal()) {
+    eigen_assert(permutation.rows() == diagonal.rows());
+  }
+
+  /** Constructs the scaled permutation with the given \a indices and \a scales. */
+  template <typename IndicesDerived, typename ScalesDerived>
+  EIGEN_DEVICE_FUNC ScaledPermutationMatrix(const MatrixBase<IndicesDerived>& indices,
+                                            const MatrixBase<ScalesDerived>& scales)
+      : m_permutation(indices), m_scales(scales) {
+    eigen_assert(indices.size() == scales.size());
+  }
+
+  /** Converts the permutation \a permutation, all scales being one. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC explicit ScaledPermutationMatrix(const PermutationBase<OtherDerived>& permutation)
+      : m_permutation(permutation), m_scales(ScalesType::Ones(permutation.rows())) {}
+
+  /** Converts the diagonal matrix \a diagonal, the permutation being the identity. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC explicit ScaledPermutationMatrix(const DiagonalBase<OtherDerived>& diagonal)
+      : m_permutation(diagonal.rows()), m_scales(diagonal.diagonal()) {
+    m_permutation.setIdentity();
+  }
+
+  /** Copies the scaled permutation \a other. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC ScaledPermutationMatrix(const ScaledPermutationBase<OtherDerived>& other)
+      : m_permutation(other.permutation()), m_scales(other.scales()) {}
+
+  /** Copies the scaled permutation \a other. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC ScaledPermutationMatrix& operator=(const ScaledPermutationBase<OtherDerived>& other) {
+    m_permutation = other.permutation();
+    m_scales = other.scales();
+    return *this;
+  }
+
+  /** \returns the permutation factor */
+  EIGEN_DEVICE_FUNC const PermutationType& permutation() const { return m_permutation; }
+  /** \returns a reference to the permutation factor */
+  EIGEN_DEVICE_FUNC PermutationType& permutation() { return m_permutation; }
+  /** \returns the permutation's indices */
+  EIGEN_DEVICE_FUNC constexpr const IndicesType& indices() const { return m_permutation.indices(); }
+  /** \returns a reference to the permutation's indices */
+  EIGEN_DEVICE_FUNC constexpr IndicesType& indices() { return m_permutation.indices(); }
+  /** \returns the scales */
+  EIGEN_DEVICE_FUNC const ScalesType& scales() const { return m_scales; }
+  /** \returns a reference to the scales */
+  EIGEN_DEVICE_FUNC ScalesType& scales() { return m_scales; }
+
+  /** Resizes to the given size, leaving the coefficients uninitialized. */
+  EIGEN_DEVICE_FUNC void resize(Index size) {
+    m_permutation.resize(size);
+    m_scales.resize(size);
+  }
+
+  /** Sets \c *this to the identity matrix. */
+  EIGEN_DEVICE_FUNC void setIdentity() {
+    m_permutation.setIdentity();
+    m_scales.setOnes();
+  }
+
+  /** Sets \c *this to the identity matrix of the given size. */
+  EIGEN_DEVICE_FUNC void setIdentity(Index size) {
+    resize(size);
+    setIdentity();
+  }
+
+ protected:
+  PermutationType m_permutation;
+  ScalesType m_scales;
+};
+
+// The products of a permutation (or its inverse) and a diagonal matrix. With P e_c = e_{sigma(c)}:
+//   P D:   (sigma(c), d_c)          D P:   (sigma(c), d_{sigma(c)})
+//   P^-1 D: (sigma^-1(c), d_c)      D P^-1: (sigma^-1(c), d_{sigma^-1(c)})
+
+/** \returns the scaled permutation \a permutation times \a diagonal
+ * \relates ScaledPermutationMatrix */
+template <typename PermutationDerived, typename DiagonalDerived>
+typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationDerived, DiagonalDerived,
+                                             typename PermutationDerived::StorageIndex>::type
+operator*(const PermutationBase<PermutationDerived>& permutation, const DiagonalBase<DiagonalDerived>& diagonal) {
+  using Result =
+      typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationDerived,
+                                                   DiagonalDerived, typename PermutationDerived::StorageIndex>::type;
+  eigen_assert(permutation.rows() == diagonal.rows());
+  return Result(permutation.indices(), diagonal.diagonal());
+}
+
+/** \returns the scaled permutation \a diagonal times \a permutation
+ * \relates ScaledPermutationMatrix */
+template <typename DiagonalDerived, typename PermutationDerived>
+typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationDerived, DiagonalDerived,
+                                             typename PermutationDerived::StorageIndex>::type
+operator*(const DiagonalBase<DiagonalDerived>& diagonal, const PermutationBase<PermutationDerived>& permutation) {
+  using Result =
+      typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationDerived,
+                                                   DiagonalDerived, typename PermutationDerived::StorageIndex>::type;
+  eigen_assert(permutation.rows() == diagonal.rows());
+  Result result(permutation.rows());
+  result.indices() = permutation.indices();
+  for (Index k = 0; k < permutation.rows(); ++k)
+    result.scales().coeffRef(k) = diagonal.diagonal().coeff(permutation.indices().coeff(k));
+  return result;
+}
+
+/** \returns the scaled permutation \a inverse (an inverse permutation) times \a diagonal
+ * \relates ScaledPermutationMatrix */
+template <typename PermutationType, typename DiagonalDerived>
+typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationType, DiagonalDerived,
+                                             typename PermutationType::StorageIndex>::type
+operator*(const InverseImpl<PermutationType, PermutationStorage>& inverse,
+          const DiagonalBase<DiagonalDerived>& diagonal) {
+  using Result =
+      typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationType, DiagonalDerived,
+                                                   typename PermutationType::StorageIndex>::type;
+  eigen_assert(inverse.rows() == diagonal.rows());
+  Result result(inverse.rows());
+  internal::invert_permutation_indices(inverse.derived().nestedExpression().indices(), result.indices());
+  result.scales() = diagonal.diagonal();
+  return result;
+}
+
+/** \returns the scaled permutation \a diagonal times \a inverse (an inverse permutation)
+ * \relates ScaledPermutationMatrix */
+template <typename DiagonalDerived, typename PermutationType>
+typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationType, DiagonalDerived,
+                                             typename PermutationType::StorageIndex>::type
+operator*(const DiagonalBase<DiagonalDerived>& diagonal,
+          const InverseImpl<PermutationType, PermutationStorage>& inverse) {
+  using Result =
+      typename internal::scaled_permutation_result<typename DiagonalDerived::Scalar, PermutationType, DiagonalDerived,
+                                                   typename PermutationType::StorageIndex>::type;
+  eigen_assert(inverse.rows() == diagonal.rows());
+  Result result(inverse.rows());
+  internal::invert_permutation_indices(inverse.derived().nestedExpression().indices(), result.indices());
+  for (Index k = 0; k < inverse.rows(); ++k)
+    result.scales().coeffRef(k) = diagonal.diagonal().coeff(result.indices().coeff(k));
+  return result;
+}
+
+namespace internal {
+
+template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
+struct evaluator_traits<ScaledPermutationMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>> {
+  using Kind = IndexBased;
+  using Shape = ScaledPermutationShape;
+};
+
+/** \internal Index-based evaluator, for the lazy sums with a dense matrix. Every coefficient is synthesized, so there
+ * is no linear, packet or direct access. */
+template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
+struct evaluator<ScaledPermutationMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>>
+    : evaluator_base<ScaledPermutationMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>> {
+  using XprType = ScaledPermutationMatrix<Scalar_, SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>;
+  using Scalar = Scalar_;
+  using CoeffReturnType = Scalar;
+
+  static constexpr int CoeffReadCost =
+      int(NumTraits<StorageIndex_>::ReadCost) + int(NumTraits<Scalar>::ReadCost) + int(NumTraits<Scalar>::AddCost);
+  static constexpr unsigned int Flags = 0;
+  static constexpr int Alignment = 0;
+
+  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : m_indices(xpr.indices()), m_scales(xpr.scales()) {}
+
+  EIGEN_DEVICE_FUNC Scalar coeff(Index row, Index col) const {
+    return Index(m_indices.coeff(col)) == row ? m_scales.coeff(col) : Scalar(0);
+  }
+
+  // Linear access is requested only for vector-shaped operands (inner products), i.e. a 1x1 matrix.
+  EIGEN_DEVICE_FUNC Scalar coeff(Index index) const {
+    eigen_assert(index == 0);
+    return m_scales.coeff(index);
+  }
+
+ protected:
+  evaluator<typename XprType::IndicesType> m_indices;
+  evaluator<typename XprType::ScalesType> m_scales;
+};
+
+struct ScaledPermutation2Dense {};
+
+template <>
+struct AssignmentKind<DenseShape, ScaledPermutationShape> {
+  using Kind = ScaledPermutation2Dense;
+};
+
+// Scaled permutation to dense assignment: zero fill plus one scatter of n coefficients.
+template <typename DstXprType, typename SrcXprType, typename Functor>
+struct Assignment<DstXprType, SrcXprType, Functor, ScaledPermutation2Dense> {
+  static EIGEN_DEVICE_FUNC void run(
+      DstXprType& dst, const SrcXprType& src,
+      const internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>&) {
+    if (dst.rows() != src.rows() || dst.cols() != src.cols()) dst.resize(src.rows(), src.cols());
+    dst.setZero();
+    for (Index k = 0; k < src.rows(); ++k) dst.coeffRef(src.indices().coeff(k), k) = src.scales().coeff(k);
+  }
+
+  static EIGEN_DEVICE_FUNC void run(
+      DstXprType& dst, const SrcXprType& src,
+      const internal::add_assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>&) {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    for (Index k = 0; k < src.rows(); ++k) dst.coeffRef(src.indices().coeff(k), k) += src.scales().coeff(k);
+  }
+
+  static EIGEN_DEVICE_FUNC void run(
+      DstXprType& dst, const SrcXprType& src,
+      const internal::sub_assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>&) {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    for (Index k = 0; k < src.rows(); ++k) dst.coeffRef(src.indices().coeff(k), k) -= src.scales().coeff(k);
+  }
+};
+
+/***************************************************************************
+ * Products with a dense matrix: rows (S * X) or columns (X * S) are scaled and permuted, O(n m).
+ * evalTo reuses the dense permutation kernel, which handles X aliasing dst, and scales in place afterwards;
+ * the accumulating form works on the nested (evaluated once) operand.
+ * scaleAndAddTo evaluates dst += alpha * (lhs * rhs) with alpha a left factor of the product. Scalar
+ * multiplication need not commute, so both kernels keep that operand order: S * X regroups it as
+ * (alpha * v_c) * X(c, j) by associativity; X * S keeps alpha * (X(i, tau(c)) * v_c), as folding alpha into
+ * v_c would move it past the dense coefficient.
+ ***************************************************************************/
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, ScaledPermutationShape, DenseShape, ProductTag>
+    : generic_product_impl_base<Lhs, Rhs,
+                                generic_product_impl<Lhs, Rhs, ScaledPermutationShape, DenseShape, ProductTag>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
+    permutation_matrix_product<Rhs, OnTheLeft, false, DenseShape>::run(dst, lhs.permutation(), rhs);
+    for (Index k = 0; k < lhs.rows(); ++k) {
+      auto row = dst.row(lhs.indices().coeff(k));
+      row = lhs.scales().coeff(k) * row;
+    }
+  }
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    typename nested_eval<Rhs, 1>::type rhsNested(rhs);
+    for (Index k = 0; k < lhs.rows(); ++k)
+      dst.row(lhs.indices().coeff(k)) += (alpha * lhs.scales().coeff(k)) * rhsNested.row(k);
+  }
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, DenseShape, ScaledPermutationShape, ProductTag>
+    : generic_product_impl_base<Lhs, Rhs,
+                                generic_product_impl<Lhs, Rhs, DenseShape, ScaledPermutationShape, ProductTag>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
+    permutation_matrix_product<Lhs, OnTheRight, false, DenseShape>::run(dst, rhs.permutation(), lhs);
+    for (Index k = 0; k < rhs.rows(); ++k) dst.col(k) *= rhs.scales().coeff(k);
+  }
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    typename nested_eval<Lhs, 1>::type lhsNested(lhs);
+    for (Index k = 0; k < rhs.rows(); ++k)
+      dst.col(k) += alpha * (lhsNested.col(rhs.indices().coeff(k)) * rhs.scales().coeff(k));
+  }
+};
+
+// A triangular or self-adjoint operand is evaluated into a plain matrix first, as toDenseMatrix() does.
+template <typename Lhs, typename Rhs, int ProductTag, bool ViewOnTheRight>
+struct scaled_permutation_view_product_impl;
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, true>
+    : generic_product_impl_base<Lhs, Rhs, scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, true>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  using DenseType = typename Rhs::DenseMatrixType;
+  using DenseImpl = generic_product_impl<Lhs, DenseType, ScaledPermutationShape, DenseShape, ProductTag>;
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
+    const DenseType dense(rhs);
+    DenseImpl::evalTo(dst, lhs, dense);
+  }
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    const DenseType dense(rhs);
+    DenseImpl::scaleAndAddTo(dst, lhs, dense, alpha);
+  }
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, false>
+    : generic_product_impl_base<Lhs, Rhs, scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, false>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  using DenseType = typename Lhs::DenseMatrixType;
+  using DenseImpl = generic_product_impl<DenseType, Rhs, DenseShape, ScaledPermutationShape, ProductTag>;
+
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
+    const DenseType dense(lhs);
+    DenseImpl::evalTo(dst, dense, rhs);
+  }
+  template <typename Dest>
+  static EIGEN_DEVICE_FUNC void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    const DenseType dense(lhs);
+    DenseImpl::scaleAndAddTo(dst, dense, rhs, alpha);
+  }
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, ScaledPermutationShape, TriangularShape, ProductTag>
+    : scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, true> {};
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, ScaledPermutationShape, SelfAdjointShape, ProductTag>
+    : scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, true> {};
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, TriangularShape, ScaledPermutationShape, ProductTag>
+    : scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, false> {};
+template <typename Lhs, typename Rhs, int ProductTag>
+struct generic_product_impl<Lhs, Rhs, SelfAdjointShape, ScaledPermutationShape, ProductTag>
+    : scaled_permutation_view_product_impl<Lhs, Rhs, ProductTag, false> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_SCALEDPERMUTATIONMATRIX_H
diff --git a/Eigen/src/Core/Select.h b/Eigen/src/Core/Select.h
index 6ad290f..0b9c6b2 100644
--- a/Eigen/src/Core/Select.h
+++ b/Eigen/src/Core/Select.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELECT_H
 #define EIGEN_SELECT_H
diff --git a/Eigen/src/Core/SelfAdjointView.h b/Eigen/src/Core/SelfAdjointView.h
index 62d0729..401b68c 100644
--- a/Eigen/src/Core/SelfAdjointView.h
+++ b/Eigen/src/Core/SelfAdjointView.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFADJOINTMATRIX_H
 #define EIGEN_SELFADJOINTMATRIX_H
@@ -24,7 +25,7 @@
  * \tparam MatrixType the type of the dense matrix storing the coefficients
  * \tparam TriangularPart can be either \c #Lower or \c #Upper
  *
- * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+ * This class is an expression of a selfadjoint matrix from a triangular part of a matrix
  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
  * and most of the time this is the only way that it is used.
  *
@@ -32,12 +33,13 @@
  */
 
 namespace internal {
+
 template <typename MatrixType, unsigned int UpLo>
-struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType> {
-  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
-  typedef remove_all_t<MatrixTypeNested> MatrixTypeNestedCleaned;
-  typedef MatrixType ExpressionType;
-  typedef typename MatrixType::PlainObject FullMatrixType;
+struct traits<SelfAdjointView<MatrixType, UpLo>> : traits<MatrixType> {
+  using MatrixTypeNested = typename ref_selector<MatrixType>::non_const_type;
+  using MatrixTypeNestedCleaned = remove_all_t<MatrixTypeNested>;
+  using ExpressionType = MatrixType;
+  using FullMatrixType = typename MatrixType::PlainObject;
   enum {
     Mode = UpLo | SelfAdjoint,
     FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
@@ -45,6 +47,7 @@
             (~(PacketAccessBit | DirectAccessBit | LinearAccessBit))  // FIXME these flags should be preserved
   };
 };
+
 }  // namespace internal
 
 template <typename MatrixType_, unsigned int UpLo>
@@ -52,71 +55,96 @@
  public:
   EIGEN_STATIC_ASSERT(UpLo == Lower || UpLo == Upper, SELFADJOINTVIEW_ACCEPTS_UPPER_AND_LOWER_MODE_ONLY)
 
-  typedef MatrixType_ MatrixType;
-  typedef TriangularBase<SelfAdjointView> Base;
-  typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested MatrixTypeNested;
-  typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
-  typedef MatrixTypeNestedCleaned NestedExpression;
+  using MatrixType = MatrixType_;
+  using Base = TriangularBase<SelfAdjointView>;
+  using MatrixTypeNested = typename internal::traits<SelfAdjointView>::MatrixTypeNested;
+  using MatrixTypeNestedCleaned = typename internal::traits<SelfAdjointView>::MatrixTypeNestedCleaned;
+  using NestedExpression = MatrixTypeNestedCleaned;
 
   /** \brief The type of coefficients in this matrix */
-  typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef internal::remove_all_t<typename MatrixType::ConjugateReturnType> MatrixConjugateReturnType;
-  typedef SelfAdjointView<std::add_const_t<MatrixType>, UpLo> ConstSelfAdjointView;
+  using Scalar = typename internal::traits<SelfAdjointView>::Scalar;
+  /** Real part of #Scalar */
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = typename MatrixType::StorageIndex;
 
   enum {
     Mode = internal::traits<SelfAdjointView>::Mode,
     Flags = internal::traits<SelfAdjointView>::Flags,
     TransposeMode = ((int(Mode) & int(Upper)) ? Lower : 0) | ((int(Mode) & int(Lower)) ? Upper : 0)
   };
-  typedef typename MatrixType::PlainObject PlainObject;
+  using PlainObject = typename MatrixType::PlainObject;
 
   EIGEN_DEVICE_FUNC explicit inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix) {}
+  using Base::operator*;
+  EIGEN_DEFAULT_COPY_CONSTRUCTOR(SelfAdjointView)
 
-  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return m_matrix.rows(); }
-  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return m_matrix.cols(); }
-  EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return m_matrix.outerStride(); }
-  EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept { return m_matrix.innerStride(); }
-
-  /** \sa MatrixBase::coeff()
-   * \warning the coordinates must fit into the referenced triangular part
-   */
-  EIGEN_DEVICE_FUNC inline Scalar coeff(Index row, Index col) const {
-    Base::check_coordinates_internal(row, col);
-    return m_matrix.coeff(row, col);
+  /** Assigns a matrix expression to the referenced triangular part of the selfadjoint matrix. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator=(const MatrixBase<OtherDerived>& other) {
+    m_matrix.template triangularView<UpLo>() = other;
+    return *this;
   }
 
-  /** \sa MatrixBase::coeffRef()
-   * \warning the coordinates must fit into the referenced triangular part
-   */
-  EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) {
-    EIGEN_STATIC_ASSERT_LVALUE(SelfAdjointView);
-    Base::check_coordinates_internal(row, col);
-    return m_matrix.coeffRef(row, col);
+  /** Assigns a triangular or selfadjoint expression without materializing a dense temporary. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator=(const TriangularBase<OtherDerived>& other) {
+    other.evalToLazy(m_matrix);
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator=(const SelfAdjointView& other) {
+    return *this = static_cast<const Base&>(other);
+  }
+
+  /** \sa MatrixBase::operator+=() */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator+=(const DenseBase<OtherDerived>& other) {
+    m_matrix.template triangularView<UpLo>() += other;
+    return *this;
+  }
+
+  /** \sa MatrixBase::operator-=() */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator-=(const DenseBase<OtherDerived>& other) {
+    m_matrix.template triangularView<UpLo>() -= other;
+    return *this;
+  }
+
+  /** \sa MatrixBase::operator*=() */
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator*=(const Scalar& other) {
+    eigen_assert(numext::imag(other) == typename NumTraits<Scalar>::Real(0) &&
+                 "SelfAdjointView in-place scaling requires a real scalar; "
+                 "scaling only the stored triangle by a non-real scalar would "
+                 "leave conj(other) on the unstored half.");
+    m_matrix.template triangularView<UpLo>() *= other;
+    return *this;
+  }
+
+  /** \sa DenseBase::operator/=() */
+  EIGEN_DEVICE_FUNC SelfAdjointView& operator/=(const Scalar& other) {
+    eigen_assert(numext::imag(other) == typename NumTraits<Scalar>::Real(0) &&
+                 "SelfAdjointView in-place division requires a real scalar; "
+                 "dividing only the stored triangle by a non-real scalar would "
+                 "leave conj(other) on the unstored half.");
+    m_matrix.template triangularView<UpLo>() /= other;
+    return *this;
   }
 
   /** \internal */
-  EIGEN_DEVICE_FUNC const MatrixTypeNestedCleaned& _expression() const { return m_matrix; }
+  EIGEN_DEVICE_FUNC constexpr const MatrixTypeNestedCleaned& _expression() const noexcept { return m_matrix; }
 
-  EIGEN_DEVICE_FUNC const MatrixTypeNestedCleaned& nestedExpression() const { return m_matrix; }
-  EIGEN_DEVICE_FUNC MatrixTypeNestedCleaned& nestedExpression() { return m_matrix; }
+  EIGEN_DEVICE_FUNC constexpr const MatrixTypeNestedCleaned& nestedExpression() const noexcept { return m_matrix; }
+  EIGEN_DEVICE_FUNC constexpr MatrixTypeNestedCleaned& nestedExpression() noexcept { return m_matrix; }
 
-  /** Efficient triangular matrix times vector/matrix product */
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC const Product<SelfAdjointView, OtherDerived> operator*(const MatrixBase<OtherDerived>& rhs) const {
-    return Product<SelfAdjointView, OtherDerived>(*this, rhs.derived());
+  EIGEN_DEVICE_FUNC const SelfAdjointView<
+      const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(MatrixType, Scalar, internal::scalar_product_op), UpLo>
+  operator*(const Scalar& s) const {
+    return (nestedExpression() * s).template selfadjointView<UpLo>();
   }
 
-  /** Efficient vector/matrix times triangular matrix product */
-  template <typename OtherDerived>
-  friend EIGEN_DEVICE_FUNC const Product<OtherDerived, SelfAdjointView> operator*(const MatrixBase<OtherDerived>& lhs,
-                                                                                  const SelfAdjointView& rhs) {
-    return Product<OtherDerived, SelfAdjointView>(lhs.derived(), rhs);
-  }
-
-  friend EIGEN_DEVICE_FUNC const
-      SelfAdjointView<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar, MatrixType, product), UpLo>
-      operator*(const Scalar& s, const SelfAdjointView& mat) {
+  friend EIGEN_DEVICE_FUNC const SelfAdjointView<
+      const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar, MatrixType, internal::scalar_product_op), UpLo>
+  operator*(const Scalar& s, const SelfAdjointView& mat) {
     return (s * mat.nestedExpression()).template selfadjointView<UpLo>();
   }
 
@@ -125,7 +153,7 @@
    * \returns a reference to \c *this
    *
    * The vectors \a u and \c v \b must be column vectors, however they can be
-   * a adjoint expression without any overhead. Only the meaningful triangular
+   * an adjoint expression without any overhead. Only the meaningful triangular
    * part of the matrix is updated, the rest is left unchanged.
    *
    * \sa rankUpdate(const MatrixBase<DerivedU>&, Scalar)
@@ -174,40 +202,6 @@
                               TriangularView<typename MatrixType::AdjointReturnType, TriMode> >(tmp2);
   }
 
-  typedef SelfAdjointView<const MatrixConjugateReturnType, UpLo> ConjugateReturnType;
-  /** \sa MatrixBase::conjugate() const */
-  EIGEN_DEVICE_FUNC inline const ConjugateReturnType conjugate() const {
-    return ConjugateReturnType(m_matrix.conjugate());
-  }
-
-  /** \returns an expression of the complex conjugate of \c *this if Cond==true,
-   *           returns \c *this otherwise.
-   */
-  template <bool Cond>
-  EIGEN_DEVICE_FUNC inline std::conditional_t<Cond, ConjugateReturnType, ConstSelfAdjointView> conjugateIf() const {
-    typedef std::conditional_t<Cond, ConjugateReturnType, ConstSelfAdjointView> ReturnType;
-    return ReturnType(m_matrix.template conjugateIf<Cond>());
-  }
-
-  typedef SelfAdjointView<const typename MatrixType::AdjointReturnType, TransposeMode> AdjointReturnType;
-  /** \sa MatrixBase::adjoint() const */
-  EIGEN_DEVICE_FUNC inline const AdjointReturnType adjoint() const { return AdjointReturnType(m_matrix.adjoint()); }
-
-  typedef SelfAdjointView<typename MatrixType::TransposeReturnType, TransposeMode> TransposeReturnType;
-  /** \sa MatrixBase::transpose() */
-  template <class Dummy = int>
-  EIGEN_DEVICE_FUNC inline TransposeReturnType transpose(
-      std::enable_if_t<Eigen::internal::is_lvalue<MatrixType>::value, Dummy*> = nullptr) {
-    typename MatrixType::TransposeReturnType tmp(m_matrix);
-    return TransposeReturnType(tmp);
-  }
-
-  typedef SelfAdjointView<const typename MatrixType::ConstTransposeReturnType, TransposeMode> ConstTransposeReturnType;
-  /** \sa MatrixBase::transpose() const */
-  EIGEN_DEVICE_FUNC inline const ConstTransposeReturnType transpose() const {
-    return ConstTransposeReturnType(m_matrix.transpose());
-  }
-
   /** \returns a const expression of the main diagonal of the matrix \c *this
    *
    * This method simply returns the diagonal of the nested expression, thus by-passing the SelfAdjointView decorator.
@@ -217,17 +211,23 @@
     return typename MatrixType::ConstDiagonalReturnType(m_matrix);
   }
 
+  /** \returns the matrix 1-norm (maximum absolute column sum) of the implicit
+   * full self-adjoint matrix, reading only the stored triangle. For Hermitian
+   * (complex) scalars the unstored entries are conjugates of stored ones, and
+   * since |conj(x)| = |x| the result matches the L1 norm of the full matrix.
+   */
+  EIGEN_DEVICE_FUNC RealScalar l1Norm() const { return internal::selfadjoint_l1_norm<UpLo>(m_matrix); }
+
   /////////// Cholesky module ///////////
 
   LLT<PlainObject, UpLo> llt() const;
   LDLT<PlainObject, UpLo> ldlt() const;
+  BunchKaufman<PlainObject, UpLo> bunchKaufman() const;
 
   /////////// Eigenvalue module ///////////
 
-  /** Real part of #Scalar */
-  typedef typename NumTraits<Scalar>::Real RealScalar;
   /** Return type of eigenvalues() */
-  typedef Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTime, 1> EigenvaluesReturnType;
+  using EigenvaluesReturnType = Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTime, 1>;
 
   EIGEN_DEVICE_FUNC EigenvaluesReturnType eigenvalues() const;
   EIGEN_DEVICE_FUNC RealScalar operatorNorm() const;
@@ -246,8 +246,8 @@
 //      make it work)
 template <typename MatrixType, unsigned int Mode>
 struct evaluator_traits<SelfAdjointView<MatrixType, Mode> > {
-  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
-  typedef SelfAdjointShape Shape;
+  using Kind = typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind;
+  using Shape = SelfAdjointShape;
 };
 
 template <int UpLo, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor,
@@ -256,18 +256,18 @@
                                          Version>
     : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> {
  protected:
-  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
-  typedef typename Base::DstXprType DstXprType;
-  typedef typename Base::SrcXprType SrcXprType;
+  using Base = generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>;
+  using DstXprType = typename Base::DstXprType;
+  using SrcXprType = typename Base::SrcXprType;
   using Base::m_dst;
   using Base::m_functor;
   using Base::m_src;
 
  public:
-  typedef typename Base::DstEvaluatorType DstEvaluatorType;
-  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::AssignmentTraits AssignmentTraits;
+  using DstEvaluatorType = typename Base::DstEvaluatorType;
+  using SrcEvaluatorType = typename Base::SrcEvaluatorType;
+  using Scalar = typename Base::Scalar;
+  using AssignmentTraits = typename Base::AssignmentTraits;
 
   EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType& dst, const SrcEvaluatorType& src,
                                                        const Functor& func, DstXprType& dstExpr)
diff --git a/Eigen/src/Core/SelfCwiseBinaryOp.h b/Eigen/src/Core/SelfCwiseBinaryOp.h
index a887ad2..5fc7727 100644
--- a/Eigen/src/Core/SelfCwiseBinaryOp.h
+++ b/Eigen/src/Core/SelfCwiseBinaryOp.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFCWISEBINARYOP_H
 #define EIGEN_SELFCWISEBINARYOP_H
diff --git a/Eigen/src/Core/SkewSymmetricMatrix3.h b/Eigen/src/Core/SkewSymmetricMatrix3.h
index a6ad143..df6a5e0 100644
--- a/Eigen/src/Core/SkewSymmetricMatrix3.h
+++ b/Eigen/src/Core/SkewSymmetricMatrix3.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SKEWSYMMETRICMATRIX3_H
 #define EIGEN_SKEWSYMMETRICMATRIX3_H
@@ -34,11 +35,11 @@
 template <typename Derived>
 class SkewSymmetricBase : public EigenBase<Derived> {
  public:
-  typedef typename internal::traits<Derived>::SkewSymmetricVectorType SkewSymmetricVectorType;
-  typedef typename SkewSymmetricVectorType::Scalar Scalar;
-  typedef typename SkewSymmetricVectorType::RealScalar RealScalar;
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+  using SkewSymmetricVectorType = typename internal::traits<Derived>::SkewSymmetricVectorType;
+  using Scalar = typename SkewSymmetricVectorType::Scalar;
+  using RealScalar = typename SkewSymmetricVectorType::RealScalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using StorageIndex = typename internal::traits<Derived>::StorageIndex;
 
   enum {
     RowsAtCompileTime = SkewSymmetricVectorType::SizeAtCompileTime,
@@ -49,14 +50,14 @@
     Flags = NoPreferredStorageOrderBit
   };
 
-  typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>
-      DenseMatrixType;
-  typedef DenseMatrixType DenseType;
-  typedef SkewSymmetricMatrix3<Scalar> PlainObject;
+  using DenseMatrixType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+  using DenseType = DenseMatrixType;
+  using PlainObject = SkewSymmetricMatrix3<Scalar>;
 
-  /** \returns a reference to the derived object. */
-  EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
   /** \returns a const reference to the derived object. */
+  EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
+  /** \returns a reference to the derived object. */
   EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
 
   /**
@@ -85,9 +86,9 @@
     return retVal;
   }
 
-  /** \returns a reference to the derived object's vector of coefficients. */
-  EIGEN_DEVICE_FUNC inline const SkewSymmetricVectorType& vector() const { return derived().vector(); }
   /** \returns a const reference to the derived object's vector of coefficients. */
+  EIGEN_DEVICE_FUNC inline const SkewSymmetricVectorType& vector() const { return derived().vector(); }
+  /** \returns a reference to the derived object's vector of coefficients. */
   EIGEN_DEVICE_FUNC inline SkewSymmetricVectorType& vector() { return derived().vector(); }
 
   /** \returns the number of rows. */
@@ -109,9 +110,23 @@
     return Product<Derived, MatrixDerived, LazyProduct>(derived(), matrix.derived());
   }
 
+  /** \returns the dense matrix product of \c *this by the diagonal matrix \a diagonal */
+  template <typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC Product<Derived, DiagonalDerived, LazyProduct> operator*(
+      const DiagonalBase<DiagonalDerived>& diagonal) const {
+    return Product<Derived, DiagonalDerived, LazyProduct>(derived(), diagonal.derived());
+  }
+
+  /** \returns the dense matrix product of the diagonal matrix \a diagonal by the skew symmetric matrix \a skew */
+  template <typename DiagonalDerived>
+  EIGEN_DEVICE_FUNC friend Product<DiagonalDerived, Derived, LazyProduct> operator*(
+      const DiagonalBase<DiagonalDerived>& diagonal, const SkewSymmetricBase& skew) {
+    return Product<DiagonalDerived, Derived, LazyProduct>(diagonal.derived(), skew.derived());
+  }
+
   template <typename OtherDerived>
   using SkewSymmetricProductReturnType = SkewSymmetricWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(
-      SkewSymmetricVectorType, typename OtherDerived::SkewSymmetricVectorType, product)>;
+      SkewSymmetricVectorType, typename OtherDerived::SkewSymmetricVectorType, internal::scalar_product_op)>;
 
   /** \returns the wedge product of \c *this by the skew symmetric matrix \a other
    *  A wedge B = AB - BA */
@@ -121,16 +136,16 @@
     return vector().cross(other.vector()).asSkewSymmetric();
   }
 
-  using SkewSymmetricScaleReturnType =
-      SkewSymmetricWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(SkewSymmetricVectorType, Scalar, product)>;
+  using SkewSymmetricScaleReturnType = SkewSymmetricWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(
+      SkewSymmetricVectorType, Scalar, internal::scalar_product_op)>;
 
   /** \returns the product of \c *this by the scalar \a scalar */
   EIGEN_DEVICE_FUNC inline SkewSymmetricScaleReturnType operator*(const Scalar& scalar) const {
     return (vector() * scalar).asSkewSymmetric();
   }
 
-  using ScaleSkewSymmetricReturnType =
-      SkewSymmetricWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar, SkewSymmetricVectorType, product)>;
+  using ScaleSkewSymmetricReturnType = SkewSymmetricWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(
+      Scalar, SkewSymmetricVectorType, internal::scalar_product_op)>;
 
   /** \returns the product of a scalar and the skew symmetric matrix \a other */
   EIGEN_DEVICE_FUNC friend inline ScaleSkewSymmetricReturnType operator*(const Scalar& scalar,
@@ -140,7 +155,7 @@
 
   template <typename OtherDerived>
   using SkewSymmetricSumReturnType = SkewSymmetricWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(
-      SkewSymmetricVectorType, typename OtherDerived::SkewSymmetricVectorType, sum)>;
+      SkewSymmetricVectorType, typename OtherDerived::SkewSymmetricVectorType, internal::scalar_sum_op)>;
 
   /** \returns the sum of \c *this and the skew symmetric matrix \a other */
   template <typename OtherDerived>
@@ -151,7 +166,7 @@
 
   template <typename OtherDerived>
   using SkewSymmetricDifferenceReturnType = SkewSymmetricWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(
-      SkewSymmetricVectorType, typename OtherDerived::SkewSymmetricVectorType, difference)>;
+      SkewSymmetricVectorType, typename OtherDerived::SkewSymmetricVectorType, internal::scalar_difference_op)>;
 
   /** \returns the difference of \c *this and the skew symmetric matrix \a other */
   template <typename OtherDerived>
@@ -159,6 +174,61 @@
       const SkewSymmetricBase<OtherDerived>& other) const {
     return (vector() - other.vector()).asSkewSymmetric();
   }
+
+  // Return type of dense +/- skew. Scalar follows ScalarBinaryOpTraits, so
+  // mixed-scalar cases go through the same promotion machinery as the rest of
+  // Eigen (and are rejected at compile time unless a user-provided
+  // specialization makes them valid). Shape is always 3x3.
+  template <typename OtherDerived, typename BinaryOp>
+  using DenseSkewBinaryReturnType = Matrix<
+      typename ScalarBinaryOpTraits<typename internal::traits<OtherDerived>::Scalar, Scalar, BinaryOp>::ReturnType, 3,
+      3>;
+
+  template <typename OtherDerived>
+  using DenseSkewSumReturnType =
+      DenseSkewBinaryReturnType<OtherDerived,
+                                internal::scalar_sum_op<typename internal::traits<OtherDerived>::Scalar, Scalar>>;
+
+  template <typename OtherDerived>
+  using DenseSkewDifferenceReturnType = DenseSkewBinaryReturnType<
+      OtherDerived, internal::scalar_difference_op<typename internal::traits<OtherDerived>::Scalar, Scalar>>;
+
+  /** \returns the sum of a dense matrix \a lhs and the skew symmetric matrix \a rhs as a dense matrix.
+   *
+   * The LHS must be 3x3 at compile time (or Dynamic, which is checked at runtime by the conversion).
+   * Only the skew side is materialized via \c toDenseMatrix(); the LHS remains a lazy expression
+   * until the enclosing assignment. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE DenseSkewSumReturnType<OtherDerived> operator+(
+      const MatrixBase<OtherDerived>& lhs, const SkewSymmetricBase& rhs) {
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(OtherDerived, DenseMatrixType);
+    return lhs.derived() + rhs.toDenseMatrix();
+  }
+
+  /** \returns the sum of the skew symmetric matrix \a lhs and a dense matrix \a rhs as a dense matrix.
+   *
+   * Sum is commutative, so this forwards to the \c dense+skew overload. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE DenseSkewSumReturnType<OtherDerived> operator+(
+      const SkewSymmetricBase& lhs, const MatrixBase<OtherDerived>& rhs) {
+    return rhs + lhs;
+  }
+
+  /** \returns the difference of a dense matrix \a lhs and the skew symmetric matrix \a rhs as a dense matrix. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE DenseSkewDifferenceReturnType<OtherDerived> operator-(
+      const MatrixBase<OtherDerived>& lhs, const SkewSymmetricBase& rhs) {
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(OtherDerived, DenseMatrixType);
+    return lhs.derived() - rhs.toDenseMatrix();
+  }
+
+  /** \returns the difference of the skew symmetric matrix \a lhs and a dense matrix \a rhs as a dense matrix. */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC friend EIGEN_STRONG_INLINE DenseSkewDifferenceReturnType<OtherDerived> operator-(
+      const SkewSymmetricBase& lhs, const MatrixBase<OtherDerived>& rhs) {
+    EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(OtherDerived, DenseMatrixType);
+    return lhs.toDenseMatrix() - rhs.derived();
+  }
 };
 
 /** \class SkewSymmetricMatrix3
@@ -174,8 +244,8 @@
 namespace internal {
 template <typename Scalar_>
 struct traits<SkewSymmetricMatrix3<Scalar_>> : traits<Matrix<Scalar_, 3, 3, 0, 3, 3>> {
-  typedef Matrix<Scalar_, 3, 1, 0, 3, 1> SkewSymmetricVectorType;
-  typedef SkewSymmetricShape StorageKind;
+  using SkewSymmetricVectorType = Matrix<Scalar_, 3, 1, 0, 3, 1>;
+  using StorageKind = SkewSymmetricShape;
   enum { Flags = LvalueBit | NoPreferredStorageOrderBit | NestByRefBit };
 };
 }  // namespace internal
@@ -183,11 +253,11 @@
 class SkewSymmetricMatrix3 : public SkewSymmetricBase<SkewSymmetricMatrix3<Scalar_>> {
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef typename internal::traits<SkewSymmetricMatrix3>::SkewSymmetricVectorType SkewSymmetricVectorType;
-  typedef const SkewSymmetricMatrix3& Nested;
-  typedef Scalar_ Scalar;
-  typedef typename internal::traits<SkewSymmetricMatrix3>::StorageKind StorageKind;
-  typedef typename internal::traits<SkewSymmetricMatrix3>::StorageIndex StorageIndex;
+  using SkewSymmetricVectorType = typename internal::traits<SkewSymmetricMatrix3>::SkewSymmetricVectorType;
+  using Nested = const SkewSymmetricMatrix3&;
+  using Scalar = Scalar_;
+  using StorageKind = typename internal::traits<SkewSymmetricMatrix3>::StorageKind;
+  using StorageIndex = typename internal::traits<SkewSymmetricMatrix3>::StorageIndex;
 #endif
 
  protected:
@@ -240,8 +310,8 @@
   }
 #endif
 
-  typedef SkewSymmetricWrapper<const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, SkewSymmetricVectorType>>
-      InitializeReturnType;
+  using InitializeReturnType =
+      SkewSymmetricWrapper<const CwiseNullaryOp<internal::scalar_constant_op<Scalar>, SkewSymmetricVectorType>>;
 
   /** Initializes a skew symmetric matrix with coefficients set to zero */
   EIGEN_DEVICE_FUNC static InitializeReturnType Zero() { return SkewSymmetricVectorType::Zero().asSkewSymmetric(); }
@@ -267,11 +337,11 @@
 namespace internal {
 template <typename SkewSymmetricVectorType_>
 struct traits<SkewSymmetricWrapper<SkewSymmetricVectorType_>> {
-  typedef SkewSymmetricVectorType_ SkewSymmetricVectorType;
-  typedef typename SkewSymmetricVectorType::Scalar Scalar;
-  typedef typename SkewSymmetricVectorType::StorageIndex StorageIndex;
-  typedef SkewSymmetricShape StorageKind;
-  typedef typename traits<SkewSymmetricVectorType>::XprKind XprKind;
+  using SkewSymmetricVectorType = SkewSymmetricVectorType_;
+  using Scalar = typename SkewSymmetricVectorType::Scalar;
+  using StorageIndex = typename SkewSymmetricVectorType::StorageIndex;
+  using StorageKind = SkewSymmetricShape;
+  using XprKind = typename traits<SkewSymmetricVectorType>::XprKind;
   enum {
     RowsAtCompileTime = SkewSymmetricVectorType::SizeAtCompileTime,
     ColsAtCompileTime = SkewSymmetricVectorType::SizeAtCompileTime,
@@ -287,8 +357,8 @@
                              internal::no_assignment_operator {
  public:
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  typedef SkewSymmetricVectorType_ SkewSymmetricVectorType;
-  typedef SkewSymmetricWrapper Nested;
+  using SkewSymmetricVectorType = SkewSymmetricVectorType_;
+  using Nested = SkewSymmetricWrapper;
 #endif
 
   /** Constructor from expression of coefficients to wrap. */
@@ -334,14 +404,14 @@
 
 template <>
 struct storage_kind_to_shape<SkewSymmetricShape> {
-  typedef SkewSymmetricShape Shape;
+  using Shape = SkewSymmetricShape;
 };
 
 struct SkewSymmetric2Dense {};
 
 template <>
 struct AssignmentKind<DenseShape, SkewSymmetricShape> {
-  typedef SkewSymmetric2Dense Kind;
+  using Kind = SkewSymmetric2Dense;
 };
 
 // SkewSymmetric matrix to Dense assignment
diff --git a/Eigen/src/Core/Solve.h b/Eigen/src/Core/Solve.h
index 030b934..f875bd9 100644
--- a/Eigen/src/Core/Solve.h
+++ b/Eigen/src/Core/Solve.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SOLVE_H
 #define EIGEN_SOLVE_H
@@ -24,7 +25,7 @@
  * \brief Pseudo expression representing a solving operation
  *
  * \tparam Decomposition the type of the matrix or decomposition object
- * \tparam Rhstype the type of the right-hand side
+ * \tparam RhsType the type of the right-hand side
  *
  * This class represents an expression of A.solve(B)
  * and most of the time this is the only way it is used.
@@ -38,21 +39,21 @@
 
 template <typename Decomposition, typename RhsType>
 struct solve_traits<Decomposition, RhsType, Dense> {
-  typedef typename make_proper_matrix_type<typename RhsType::Scalar, Decomposition::ColsAtCompileTime,
-                                           RhsType::ColsAtCompileTime, RhsType::PlainObject::Options,
-                                           Decomposition::MaxColsAtCompileTime, RhsType::MaxColsAtCompileTime>::type
-      PlainObject;
+  using PlainObject =
+      typename make_proper_matrix_type<typename RhsType::Scalar, Decomposition::ColsAtCompileTime,
+                                       RhsType::ColsAtCompileTime, RhsType::PlainObject::Options,
+                                       Decomposition::MaxColsAtCompileTime, RhsType::MaxColsAtCompileTime>::type;
 };
 
 template <typename Decomposition, typename RhsType>
 struct traits<Solve<Decomposition, RhsType> >
     : traits<
           typename solve_traits<Decomposition, RhsType, typename internal::traits<RhsType>::StorageKind>::PlainObject> {
-  typedef typename solve_traits<Decomposition, RhsType, typename internal::traits<RhsType>::StorageKind>::PlainObject
-      PlainObject;
-  typedef typename promote_index_type<typename Decomposition::StorageIndex, typename RhsType::StorageIndex>::type
-      StorageIndex;
-  typedef traits<PlainObject> BaseTraits;
+  using PlainObject =
+      typename solve_traits<Decomposition, RhsType, typename internal::traits<RhsType>::StorageKind>::PlainObject;
+  using StorageIndex =
+      typename promote_index_type<typename Decomposition::StorageIndex, typename RhsType::StorageIndex>::type;
+  using BaseTraits = traits<PlainObject>;
   enum { Flags = BaseTraits::Flags & RowMajorBit, CoeffReadCost = HugeCost };
 };
 
@@ -61,8 +62,8 @@
 template <typename Decomposition, typename RhsType>
 class Solve : public SolveImpl<Decomposition, RhsType, typename internal::traits<RhsType>::StorageKind> {
  public:
-  typedef typename internal::traits<Solve>::PlainObject PlainObject;
-  typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
+  using PlainObject = typename internal::traits<Solve>::PlainObject;
+  using StorageIndex = typename internal::traits<Solve>::StorageIndex;
 
   Solve(const Decomposition &dec, const RhsType &rhs) : m_dec(dec), m_rhs(rhs) {}
 
@@ -80,10 +81,10 @@
 // Specialization of the Solve expression for dense results
 template <typename Decomposition, typename RhsType>
 class SolveImpl<Decomposition, RhsType, Dense> : public MatrixBase<Solve<Decomposition, RhsType> > {
-  typedef Solve<Decomposition, RhsType> Derived;
+  using Derived = Solve<Decomposition, RhsType>;
 
  public:
-  typedef MatrixBase<Solve<Decomposition, RhsType> > Base;
+  using Base = MatrixBase<Solve<Decomposition, RhsType>>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
 
  private:
@@ -95,7 +96,7 @@
 template <typename Decomposition, typename RhsType, typename StorageKind>
 class SolveImpl : public internal::generic_xpr_base<Solve<Decomposition, RhsType>, MatrixXpr, StorageKind>::type {
  public:
-  typedef typename internal::generic_xpr_base<Solve<Decomposition, RhsType>, MatrixXpr, StorageKind>::type Base;
+  using Base = typename internal::generic_xpr_base<Solve<Decomposition, RhsType>, MatrixXpr, StorageKind>::type;
 };
 
 namespace internal {
@@ -104,9 +105,9 @@
 template <typename Decomposition, typename RhsType>
 struct evaluator<Solve<Decomposition, RhsType> >
     : public evaluator<typename Solve<Decomposition, RhsType>::PlainObject> {
-  typedef Solve<Decomposition, RhsType> SolveType;
-  typedef typename SolveType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using SolveType = Solve<Decomposition, RhsType>;
+  using PlainObject = typename SolveType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
 
@@ -124,7 +125,7 @@
 // specialization must exist somewhere
 template <typename DstXprType, typename DecType, typename RhsType, typename Scalar>
 struct Assignment<DstXprType, Solve<DecType, RhsType>, internal::assign_op<Scalar, Scalar>, Dense2Dense> {
-  typedef Solve<DecType, RhsType> SrcXprType;
+  using SrcXprType = Solve<DecType, RhsType>;
   static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar, Scalar> &) {
     Index dstRows = src.rows();
     Index dstCols = src.cols();
@@ -138,7 +139,7 @@
 template <typename DstXprType, typename DecType, typename RhsType, typename Scalar>
 struct Assignment<DstXprType, Solve<Transpose<const DecType>, RhsType>, internal::assign_op<Scalar, Scalar>,
                   Dense2Dense> {
-  typedef Solve<Transpose<const DecType>, RhsType> SrcXprType;
+  using SrcXprType = Solve<Transpose<const DecType>, RhsType>;
   static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar, Scalar> &) {
     Index dstRows = src.rows();
     Index dstCols = src.cols();
@@ -155,9 +156,9 @@
     Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,
           RhsType>,
     internal::assign_op<Scalar, Scalar>, Dense2Dense> {
-  typedef Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType> >,
-                RhsType>
-      SrcXprType;
+  using SrcXprType =
+      Solve<CwiseUnaryOp<internal::scalar_conjugate_op<typename DecType::Scalar>, const Transpose<const DecType>>,
+            RhsType>;
   static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar, Scalar> &) {
     Index dstRows = src.rows();
     Index dstCols = src.cols();
diff --git a/Eigen/src/Core/SolveTriangular.h b/Eigen/src/Core/SolveTriangular.h
index 9d31874..04553e9 100644
--- a/Eigen/src/Core/SolveTriangular.h
+++ b/Eigen/src/Core/SolveTriangular.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SOLVETRIANGULAR_H
 #define EIGEN_SOLVETRIANGULAR_H
@@ -50,13 +51,14 @@
 
 template <typename Lhs, typename Rhs, int Side, int Mode>
 struct triangular_solver_selector<Lhs, Rhs, Side, Mode, NoUnrolling, 1> {
-  typedef typename Lhs::Scalar LhsScalar;
-  typedef typename Rhs::Scalar RhsScalar;
-  typedef blas_traits<Lhs> LhsProductTraits;
-  typedef typename LhsProductTraits::ExtractType ActualLhsType;
-  typedef Map<Matrix<RhsScalar, Dynamic, 1>, Aligned> MappedRhs;
+  using LhsScalar = typename Lhs::Scalar;
+  using RhsScalar = typename Rhs::Scalar;
+  using LhsProductTraits = blas_traits<Lhs>;
+  using ActualLhsType = typename LhsProductTraits::DirectLinearAccessType;
+  using ActualLhsTypeCleaned = remove_all_t<ActualLhsType>;
+  using MappedRhs = Map<Matrix<RhsScalar, Dynamic, 1>, Aligned>;
   static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs) {
-    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);
+    add_const_on_value_type_t<ActualLhsType> actualLhs = LhsProductTraits::extract(lhs);
 
     // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1
 
@@ -67,10 +69,11 @@
     if (!useRhsDirectly) MappedRhs(actualRhs, rhs.size()) = rhs;
 
     triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
-                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>::run(actualLhs.cols(),
-                                                                                        actualLhs.data(),
-                                                                                        actualLhs.outerStride(),
-                                                                                        actualRhs);
+                            (int(ActualLhsTypeCleaned::Flags) & RowMajorBit) ? RowMajor
+                                                                             : ColMajor>::run(actualLhs.cols(),
+                                                                                              actualLhs.data(),
+                                                                                              actualLhs.outerStride(),
+                                                                                              actualRhs);
 
     if (!useRhsDirectly) rhs = MappedRhs(actualRhs, rhs.size());
   }
@@ -79,9 +82,9 @@
 // the rhs is a matrix
 template <typename Lhs, typename Rhs, int Side, int Mode>
 struct triangular_solver_selector<Lhs, Rhs, Side, Mode, NoUnrolling, Dynamic> {
-  typedef typename Rhs::Scalar Scalar;
-  typedef blas_traits<Lhs> LhsProductTraits;
-  typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType;
+  using Scalar = typename Rhs::Scalar;
+  using LhsProductTraits = blas_traits<Lhs>;
+  using ActualLhsType = typename LhsProductTraits::DirectLinearAccessType;
 
   static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs) {
     add_const_on_value_type_t<ActualLhsType> actualLhs = LhsProductTraits::extract(lhs);
@@ -89,10 +92,9 @@
     const Index size = lhs.rows();
     const Index othersize = Side == OnTheLeft ? rhs.cols() : rhs.rows();
 
-    typedef internal::gemm_blocking_space<(Rhs::Flags & RowMajorBit) ? RowMajor : ColMajor, Scalar, Scalar,
-                                          Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime,
-                                          Lhs::MaxRowsAtCompileTime, 4>
-        BlockingType;
+    using BlockingType = internal::gemm_blocking_space<(Rhs::Flags & RowMajorBit) ? RowMajor : ColMajor, Scalar, Scalar,
+                                                       Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime,
+                                                       Lhs::MaxRowsAtCompileTime, 4>;
 
     // Nothing to solve.
     if (actualLhs.size() == 0 || rhs.size() == 0) {
@@ -132,7 +134,7 @@
                                      .cwiseProduct(rhs.template segment<LoopIndex>(StartIndex))
                                      .sum();
 
-    if (!(Mode & UnitDiag)) rhs.coeffRef(DiagIndex) /= lhs.coeff(DiagIndex, DiagIndex);
+    EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) rhs.coeffRef(DiagIndex) /= lhs.coeff(DiagIndex, DiagIndex);
 
     triangular_solver_unroller<Lhs, Rhs, Mode, LoopIndex + 1, Size>::run(lhs, rhs);
   }
@@ -181,11 +183,15 @@
   if (derived().cols() == 0) return;
 
   enum {
-    copy = (internal::traits<OtherDerived>::Flags & RowMajorBit) && OtherDerived::IsVectorAtCompileTime &&
-           OtherDerived::SizeAtCompileTime != 1
+    OtherFlags = internal::traits<OtherDerived>::Flags,
+    IsRowMajorVector =
+        (OtherFlags & RowMajorBit) && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime != 1,
+    copy = IsRowMajorVector || ((OtherFlags & DirectAccessBit) == 0)
   };
-  typedef std::conditional_t<copy, typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>
-      OtherCopy;
+  using OtherPlainObject =
+      std::conditional_t<IsRowMajorVector, typename internal::plain_matrix_type_column_major<OtherDerived>::type,
+                         typename internal::plain_matrix_type<OtherDerived>::type>;
+  using OtherCopy = std::conditional_t<copy, OtherPlainObject, OtherDerived&>;
   OtherCopy otherCopy(other);
 
   internal::triangular_solver_selector<MatrixType, std::remove_reference_t<OtherCopy>, Side, Mode>::run(
@@ -206,13 +212,12 @@
 
 template <int Side, typename TriangularType, typename Rhs>
 struct traits<triangular_solve_retval<Side, TriangularType, Rhs> > {
-  typedef typename internal::plain_matrix_type_column_major<Rhs>::type ReturnType;
+  using ReturnType = typename internal::plain_matrix_type_column_major<Rhs>::type;
 };
 
 template <int Side, typename TriangularType, typename Rhs>
 struct triangular_solve_retval : public ReturnByValue<triangular_solve_retval<Side, TriangularType, Rhs> > {
-  typedef remove_all_t<typename Rhs::Nested> RhsNestedCleaned;
-  typedef ReturnByValue<triangular_solve_retval> Base;
+  using Base = ReturnByValue<triangular_solve_retval>;
 
   triangular_solve_retval(const TriangularType& tri, const Rhs& rhs) : m_triangularMatrix(tri), m_rhs(rhs) {}
 
diff --git a/Eigen/src/Core/SolverBase.h b/Eigen/src/Core/SolverBase.h
index a6ecbc9..87e176b 100644
--- a/Eigen/src/Core/SolverBase.h
+++ b/Eigen/src/Core/SolverBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SOLVERBASE_H
 #define EIGEN_SOLVERBASE_H
@@ -27,7 +28,7 @@
 
 template <typename Derived>
 struct solve_assertion<Transpose<Derived>> {
-  typedef Transpose<Derived> type;
+  using type = Transpose<Derived>;
 
   template <bool Transpose_, typename Rhs>
   static void run(const type& transpose, const Rhs& b) {
@@ -37,7 +38,7 @@
 
 template <typename Scalar, typename Derived>
 struct solve_assertion<CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived>>> {
-  typedef CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived>> type;
+  using type = CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<Scalar>, const Transpose<Derived>>;
 
   template <bool Transpose_, typename Rhs>
   static void run(const type& adjoint, const Rhs& b) {
@@ -71,9 +72,9 @@
 template <typename Derived>
 class SolverBase : public EigenBase<Derived> {
  public:
-  typedef EigenBase<Derived> Base;
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef Scalar CoeffReturnType;
+  using Base = EigenBase<Derived>;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using CoeffReturnType = Scalar;
 
   template <typename Derived_>
   friend struct internal::solve_assertion;
@@ -89,7 +90,7 @@
   enum {
     RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
     ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
-    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::ret),
+    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::value),
     MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
     MaxSizeAtCompileTime = internal::size_at_compile_time(internal::traits<Derived>::MaxRowsAtCompileTime,
@@ -102,9 +103,7 @@
   };
 
   /** Default constructor */
-  SolverBase() {}
-
-  ~SolverBase() {}
+  SolverBase() = default;
 
   using Base::derived;
 
@@ -117,7 +116,7 @@
   }
 
   /** \internal the return type of transpose() */
-  typedef Transpose<const Derived> ConstTransposeReturnType;
+  using ConstTransposeReturnType = Transpose<const Derived>;
   /** \returns an expression of the transposed of the factored matrix.
    *
    * A typical usage is to solve for the transposed problem A^T x = b:
@@ -128,10 +127,10 @@
   inline const ConstTransposeReturnType transpose() const { return ConstTransposeReturnType(derived()); }
 
   /** \internal the return type of adjoint() */
-  typedef std::conditional_t<NumTraits<Scalar>::IsComplex,
-                             CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const ConstTransposeReturnType>,
-                             const ConstTransposeReturnType>
-      AdjointReturnType;
+  using AdjointReturnType =
+      std::conditional_t<NumTraits<Scalar>::IsComplex,
+                         CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const ConstTransposeReturnType>,
+                         const ConstTransposeReturnType>;
   /** \returns an expression of the adjoint of the factored matrix
    *
    * A typical usage is to solve for the adjoint problem A' x = b:
@@ -157,7 +156,7 @@
 
 template <typename Derived>
 struct generic_xpr_base<Derived, MatrixXpr, SolverStorage> {
-  typedef SolverBase<Derived> type;
+  using type = SolverBase<Derived>;
 };
 
 }  // end namespace internal
diff --git a/Eigen/src/Core/StableNorm.h b/Eigen/src/Core/StableNorm.h
index 11abb77..2a43961 100644
--- a/Eigen/src/Core/StableNorm.h
+++ b/Eigen/src/Core/StableNorm.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STABLENORM_H
 #define EIGEN_STABLENORM_H
@@ -17,23 +18,51 @@
 
 namespace internal {
 
-template <typename ExpressionType, typename Scalar>
-inline void stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale) {
-  Scalar maxCoeff = bl.cwiseAbs().maxCoeff();
+template <typename Accumulator, bool = std::is_floating_point<Accumulator>::value>
+struct stable_norm_unscaled_predicate {
+  static inline bool run(const Accumulator&, const Accumulator&) { return false; }
+};
+
+template <typename Accumulator>
+struct stable_norm_unscaled_predicate<Accumulator, true> {
+  static inline bool run(const Accumulator& maxCoeff, const Accumulator& invScale) {
+    using std::sqrt;
+    // A block has at most 8192 real components. These bounds keep the error
+    // from flushed component squares below one epsilon.
+    static const Accumulator kSqrtMin =
+        sqrt((numext::numeric_limits<Accumulator>::min)() * (Accumulator(16384) / NumTraits<Accumulator>::epsilon()));
+    static const Accumulator kSqrtMax = sqrt(NumTraits<Accumulator>::highest() / Accumulator(16384));
+    // A normal invScale avoids fast-math flushing invScale^2.
+    static const Accumulator kSqrtNormalMin = sqrt((numext::numeric_limits<Accumulator>::min)());
+    return maxCoeff >= kSqrtMin && maxCoeff <= kSqrtMax && invScale >= kSqrtNormalMin;
+  }
+};
+
+template <typename ExpressionType, typename Accumulator>
+inline Accumulator stable_norm_squared_norm(const ExpressionType& block, const Accumulator& invScale,
+                                            const Accumulator& maxCoeff) {
+  if (stable_norm_unscaled_predicate<Accumulator>::run(maxCoeff, invScale)) {
+    return block.realView().template cast<Accumulator>().squaredNorm() * numext::abs2(invScale);
+  }
+  return (block.realView().template cast<Accumulator>() * invScale).squaredNorm();
+}
+
+template <typename ExpressionType, typename Accumulator>
+inline void stable_norm_kernel(const ExpressionType& block, Accumulator& ssq, Accumulator& scale,
+                               Accumulator& invScale) {
+  // Component-wise maxima give the required scale without complex hypot calls.
+  Accumulator maxCoeff = block.realView().template cast<Accumulator>().cwiseAbs().template maxCoeff<PropagateNaN>();
 
   if (maxCoeff > scale) {
-    ssq = ssq * numext::abs2(scale / maxCoeff);
-    Scalar tmp = Scalar(1) / maxCoeff;
-    if (tmp > NumTraits<Scalar>::highest()) {
-      invScale = NumTraits<Scalar>::highest();
-      scale = Scalar(1) / invScale;
-    } else if (maxCoeff > NumTraits<Scalar>::highest())  // we got a INF
+    if (maxCoeff > NumTraits<Accumulator>::highest())  // we got an INF
     {
-      invScale = Scalar(1);
+      invScale = Accumulator(1);
       scale = maxCoeff;
     } else {
-      scale = maxCoeff;
-      invScale = tmp;
+      const auto factors = safe_scaling<Accumulator>::compute_ceiling_factors_with_normal_reciprocal(maxCoeff);
+      if (scale > Accumulator(0)) ssq = ssq * numext::abs2(scale * factors.invScale);
+      scale = factors.scale;
+      invScale = factors.invScale;
     }
   } else if (maxCoeff != maxCoeff)  // we got a NaN
   {
@@ -41,12 +70,12 @@
   }
 
   // TODO: skip sub-vector when maxCoeff << current scale.
-  if (scale > Scalar(0))  // if scale==0, then bl is 0
-    ssq += (bl * invScale).squaredNorm();
+  if (scale > Accumulator(0))  // if scale==0, then block is 0
+    ssq += stable_norm_squared_norm(block, invScale, maxCoeff);
 }
 
-template <typename VectorType, typename RealScalar>
-void stable_norm_impl_inner_step(const VectorType& vec, RealScalar& ssq, RealScalar& scale, RealScalar& invScale) {
+template <typename VectorType, typename Accumulator>
+void stable_norm_impl_inner_step(const VectorType& vec, Accumulator& ssq, Accumulator& scale, Accumulator& invScale) {
   const Index blockSize = 4096;
 
   Index n = vec.size();
@@ -59,119 +88,210 @@
   }
 }
 
-template <typename VectorType>
-typename VectorType::RealScalar stable_norm_impl(const VectorType& vec,
-                                                 std::enable_if_t<VectorType::IsVectorAtCompileTime>* = 0) {
-  using std::abs;
+template <typename VectorType, typename Accumulator,
+          bool = bool(traits<VectorType>::Flags & DirectAccessBit) &&
+                 (int(inner_stride_at_compile_time<VectorType>::value) != 1)>
+struct stable_norm_vector_dispatch {
+  static inline void run(const VectorType& vec, Accumulator& ssq, Accumulator& scale, Accumulator& invScale) {
+    stable_norm_impl_inner_step(vec, ssq, scale, invScale);
+  }
+};
+
+template <typename VectorType, typename Accumulator>
+struct stable_norm_vector_dispatch<VectorType, Accumulator, true> {
+  static inline void run(const VectorType& vec, Accumulator& ssq, Accumulator& scale, Accumulator& invScale) {
+    if (vec.innerStride() == 1) {
+      using Scalar = typename traits<VectorType>::Scalar;
+      using PlainVector = Matrix<Scalar, VectorType::SizeAtCompileTime, 1, 0, VectorType::MaxSizeAtCompileTime, 1>;
+      using ContiguousMap = Map<const PlainVector, evaluator<VectorType>::Alignment>;
+      const ContiguousMap contiguous(vec.data(), vec.size());
+      stable_norm_impl_inner_step(contiguous, ssq, scale, invScale);
+      return;
+    }
+    stable_norm_impl_inner_step(vec, ssq, scale, invScale);
+  }
+};
+
+template <typename VectorType, typename Accumulator>
+inline void stable_norm_impl_inner_dispatch(const VectorType& vec, Accumulator& ssq, Accumulator& scale,
+                                            Accumulator& invScale) {
+  stable_norm_vector_dispatch<VectorType, Accumulator>::run(vec, ssq, scale, invScale);
+}
+
+template <typename MatrixType, typename Accumulator>
+inline void stable_norm_impl_outer_steps(const MatrixType& mat, Accumulator& ssq, Accumulator& scale,
+                                         Accumulator& invScale) {
+  for (Index j = 0; j < mat.outerSize(); ++j) {
+    stable_norm_impl_inner_dispatch(mat.innerVector(j), ssq, scale, invScale);
+  }
+}
+
+template <typename MatrixType, typename Accumulator, bool = bool(traits<MatrixType>::Flags & DirectAccessBit)>
+struct stable_norm_matrix_dispatch {
+  static inline void run(const MatrixType& mat, Accumulator& ssq, Accumulator& scale, Accumulator& invScale) {
+    stable_norm_impl_outer_steps(mat, ssq, scale, invScale);
+  }
+};
+
+template <typename MatrixType, typename Accumulator>
+struct stable_norm_matrix_dispatch<MatrixType, Accumulator, true> {
+  static inline void run(const MatrixType& mat, Accumulator& ssq, Accumulator& scale, Accumulator& invScale) {
+    if (mat.innerStride() == 1 && (mat.outerSize() == 1 || mat.outerStride() == mat.innerSize())) {
+      using Scalar = typename traits<MatrixType>::Scalar;
+      using PlainVector = Matrix<Scalar, MatrixType::SizeAtCompileTime, 1, 0, MatrixType::MaxSizeAtCompileTime, 1>;
+      using ContiguousMap = Map<const PlainVector, evaluator<MatrixType>::Alignment>;
+      const ContiguousMap contiguous(mat.data(), mat.size());
+      stable_norm_impl_inner_step(contiguous, ssq, scale, invScale);
+      return;
+    }
+    stable_norm_impl_outer_steps(mat, ssq, scale, invScale);
+  }
+};
+
+template <typename VectorType, std::enable_if_t<VectorType::IsVectorAtCompileTime, int> = 0>
+typename VectorType::RealScalar stable_norm_impl(const VectorType& vec) {
   using std::sqrt;
 
   Index n = vec.size();
-  if (EIGEN_PREDICT_FALSE(n == 1)) return abs(vec.coeff(0));
+  if (EIGEN_PREDICT_FALSE(n == 1)) return numext::abs(vec.coeff(0));
 
-  typedef typename VectorType::RealScalar RealScalar;
-  RealScalar scale(0);
-  RealScalar invScale(1);
-  RealScalar ssq(0);  // sum of squares
+  using RealScalar = typename VectorType::RealScalar;
+  using Accumulator = typename stable_norm_accumulator<RealScalar>::type;
+  Accumulator scale(0);
+  Accumulator invScale(1);
+  Accumulator ssq(0);  // sum of squares
 
-  stable_norm_impl_inner_step(vec, ssq, scale, invScale);
+  stable_norm_vector_dispatch<VectorType, Accumulator>::run(vec, ssq, scale, invScale);
 
-  return scale * sqrt(ssq);
+  return RealScalar(scale * sqrt(ssq));
 }
 
-template <typename MatrixType>
-typename MatrixType::RealScalar stable_norm_impl(const MatrixType& mat,
-                                                 std::enable_if_t<!MatrixType::IsVectorAtCompileTime>* = 0) {
+template <typename MatrixType, std::enable_if_t<!MatrixType::IsVectorAtCompileTime, int> = 0>
+typename MatrixType::RealScalar stable_norm_impl(const MatrixType& mat) {
   using std::sqrt;
 
-  typedef typename MatrixType::RealScalar RealScalar;
-  RealScalar scale(0);
-  RealScalar invScale(1);
-  RealScalar ssq(0);  // sum of squares
+  using RealScalar = typename MatrixType::RealScalar;
+  using Accumulator = typename stable_norm_accumulator<RealScalar>::type;
+  Accumulator scale(0);
+  Accumulator invScale(1);
+  Accumulator ssq(0);  // sum of squares
 
-  for (Index j = 0; j < mat.outerSize(); ++j) stable_norm_impl_inner_step(mat.innerVector(j), ssq, scale, invScale);
-  return scale * sqrt(ssq);
+  stable_norm_matrix_dispatch<MatrixType, Accumulator>::run(mat, ssq, scale, invScale);
+  return RealScalar(scale * sqrt(ssq));
 }
 
+inline int stable_norm_floor_div2(int value) { return value / 2 - ((value < 0 && value % 2 != 0) ? 1 : 0); }
+
+inline int stable_norm_ceil_div2(int value) { return value / 2 + ((value > 0 && value % 2 != 0) ? 1 : 0); }
+
+template <typename Accumulator>
+inline void blue_norm_accumulate_component(const Accumulator& ax, const Accumulator& tsml, const Accumulator& tbig,
+                                           const Accumulator& ssml, const Accumulator& sbig, bool& notBig,
+                                           Accumulator& asml, Accumulator& amed, Accumulator& abig) {
+  if (ax > tbig) {
+    abig += numext::abs2(ax * sbig);
+    notBig = false;
+  } else if (ax < tsml) {
+    if (notBig) asml += numext::abs2(ax * ssml);
+  } else {
+    amed += numext::abs2(ax);
+  }
+}
+
+template <typename Scalar, typename Accumulator, bool = NumTraits<Scalar>::IsComplex>
+struct blue_norm_accumulate_scalar {
+  static inline void run(const Scalar& value, const Accumulator& tsml, const Accumulator& tbig, const Accumulator& ssml,
+                         const Accumulator& sbig, bool& notBig, Accumulator& asml, Accumulator& amed,
+                         Accumulator& abig) {
+    const Accumulator ax = numext::abs(Accumulator(value));
+    blue_norm_accumulate_component(ax, tsml, tbig, ssml, sbig, notBig, asml, amed, abig);
+  }
+};
+
+template <typename Scalar, typename Accumulator>
+struct blue_norm_accumulate_scalar<Scalar, Accumulator, true> {
+  static inline void run(const Scalar& value, const Accumulator& tsml, const Accumulator& tbig, const Accumulator& ssml,
+                         const Accumulator& sbig, bool& notBig, Accumulator& asml, Accumulator& amed,
+                         Accumulator& abig) {
+    const Accumulator real = numext::abs(Accumulator(numext::real(value)));
+    const Accumulator imag = numext::abs(Accumulator(numext::imag(value)));
+    blue_norm_accumulate_component(real, tsml, tbig, ssml, sbig, notBig, asml, amed, abig);
+    blue_norm_accumulate_component(imag, tsml, tbig, ssml, sbig, notBig, asml, amed, abig);
+  }
+};
+
 template <typename Derived>
 inline typename NumTraits<typename traits<Derived>::Scalar>::Real blueNorm_impl(const EigenBase<Derived>& _vec) {
-  typedef typename Derived::RealScalar RealScalar;
-  using std::abs;
+  using RealScalar = typename Derived::RealScalar;
+  using Accumulator = typename stable_norm_accumulator<RealScalar>::type;
+  using Scalar = typename traits<Derived>::Scalar;
   using std::pow;
   using std::sqrt;
 
-  // This program calculates the machine-dependent constants
-  // bl, b2, slm, s2m, relerr overfl
-  // from the "basic" machine-dependent numbers
-  // nbig, ibeta, it, iemin, iemax, rbig.
-  // The following define the basic machine-dependent constants.
-  // For portability, the PORT subprograms "ilmaeh" and "rlmach"
-  // are used. For any specific computer, each of the assignment
-  // statements can be replaced
-  static const int ibeta = std::numeric_limits<RealScalar>::radix;  // base for floating-point numbers
-  static const int it = NumTraits<RealScalar>::digits();            // number of base-beta digits in mantissa
-  static const int iemin = NumTraits<RealScalar>::min_exponent();   // minimum exponent
-  static const int iemax = NumTraits<RealScalar>::max_exponent();   // maximum exponent
-  static const RealScalar rbig = NumTraits<RealScalar>::highest();  // largest floating-point number
-  static const RealScalar b1 =
-      RealScalar(pow(RealScalar(ibeta), RealScalar(-((1 - iemin) / 2))));  // lower boundary of midrange
-  static const RealScalar b2 =
-      RealScalar(pow(RealScalar(ibeta), RealScalar((iemax + 1 - it) / 2)));  // upper boundary of midrange
-  static const RealScalar s1m =
-      RealScalar(pow(RealScalar(ibeta), RealScalar((2 - iemin) / 2)));  // scaling factor for lower range
-  static const RealScalar s2m =
-      RealScalar(pow(RealScalar(ibeta), RealScalar(-((iemax + it) / 2))));  // scaling factor for upper range
-  static const RealScalar eps = RealScalar(pow(double(ibeta), 1 - it));
-  static const RealScalar relerr = sqrt(eps);  // tolerance for neglecting asml
-
   const Derived& vec(_vec.derived());
-  Index n = vec.size();
-  RealScalar ab2 = b2 / RealScalar(n);
-  RealScalar asml = RealScalar(0);
-  RealScalar amed = RealScalar(0);
-  RealScalar abig = RealScalar(0);
+  if (vec.size() == 0) return RealScalar(0);
+
+  // Blue, ACM TOMS 4(1), 1978, https://doi.org/10.1145/355769.355771.
+  // The small-value multiplier includes Anderson's denormal correction from
+  // Algorithm 978, ACM TOMS 44(1), 2017, https://doi.org/10.1145/3061665.
+  // These thresholds and the three-accumulator merge follow Reference BLAS
+  // xNRM2 (LAPACK 3.12.1), expressed independently for Eigen scalar types.
+  static const int ibeta = std::numeric_limits<Accumulator>::radix;
+  static const int it = NumTraits<Accumulator>::digits();
+  static const int iemin = NumTraits<Accumulator>::min_exponent();
+  static const int iemax = NumTraits<Accumulator>::max_exponent();
+  static const Accumulator tsml = Accumulator(pow(Accumulator(ibeta), Accumulator(stable_norm_ceil_div2(iemin - 1))));
+  static const Accumulator tbig =
+      Accumulator(pow(Accumulator(ibeta), Accumulator(stable_norm_floor_div2(iemax - it + 1))));
+  static const Accumulator ssml =
+      Accumulator(pow(Accumulator(ibeta), Accumulator(-stable_norm_floor_div2(iemin - it))));
+  static const Accumulator sbig =
+      Accumulator(pow(Accumulator(ibeta), Accumulator(-stable_norm_ceil_div2(iemax + it - 1))));
+
+  bool notBig = true;
+  Accumulator asml(0);
+  Accumulator amed(0);
+  Accumulator abig(0);
 
   for (Index j = 0; j < vec.outerSize(); ++j) {
     for (typename Derived::InnerIterator iter(vec, j); iter; ++iter) {
-      RealScalar ax = abs(iter.value());
-      if (ax > ab2)
-        abig += numext::abs2(ax * s2m);
-      else if (ax < b1)
-        asml += numext::abs2(ax * s1m);
-      else
-        amed += numext::abs2(ax);
+      blue_norm_accumulate_scalar<Scalar, Accumulator>::run(iter.value(), tsml, tbig, ssml, sbig, notBig, asml, amed,
+                                                            abig);
     }
   }
-  if (amed != amed) return amed;  // we got a NaN
-  if (abig > RealScalar(0)) {
-    abig = sqrt(abig);
-    if (abig > rbig)  // overflow, or *this contains INF values
-      return abig;    // return INF
-    if (amed > RealScalar(0)) {
-      abig = abig / s2m;
+
+  Accumulator scale(1);
+  Accumulator sumsq(0);
+  if (abig > Accumulator(0)) {
+    if (amed > Accumulator(0) || amed > NumTraits<Accumulator>::highest() || amed != amed) abig += (amed * sbig) * sbig;
+    scale = Accumulator(1) / sbig;
+    sumsq = abig;
+  } else if (asml > Accumulator(0)) {
+    if (amed > Accumulator(0) || amed > NumTraits<Accumulator>::highest() || amed != amed) {
       amed = sqrt(amed);
-    } else
-      return abig / s2m;
-  } else if (asml > RealScalar(0)) {
-    if (amed > RealScalar(0)) {
-      abig = sqrt(amed);
-      amed = sqrt(asml) / s1m;
-    } else
-      return sqrt(asml) / s1m;
-  } else
-    return sqrt(amed);
-  asml = numext::mini(abig, amed);
-  abig = numext::maxi(abig, amed);
-  if (asml <= abig * relerr)
-    return abig;
-  else
-    return abig * sqrt(RealScalar(1) + numext::abs2(asml / abig));
+      asml = sqrt(asml) / ssml;
+      // Spell this as in xNRM2 rather than with min/max: when amed is NaN,
+      // it must become ymax so that the final result remains NaN.
+      const bool smallIsLarger = asml > amed;
+      const Accumulator ymin = smallIsLarger ? amed : asml;
+      const Accumulator ymax = smallIsLarger ? asml : amed;
+      sumsq = numext::abs2(ymax) * (Accumulator(1) + numext::abs2(ymin / ymax));
+    } else {
+      scale = Accumulator(1) / ssml;
+      sumsq = asml;
+    }
+  } else {
+    sumsq = amed;
+  }
+  return RealScalar(scale * sqrt(sumsq));
 }
 
 }  // end namespace internal
 
 /** \returns the \em l2 norm of \c *this avoiding underflow and overflow.
- * This version use a blockwise two passes algorithm:
- *  1 - find the absolute largest coefficient \c s
+ * This version uses a blockwise two-pass algorithm:
+ *  1 - find the absolute largest coefficient and choose a scale \c s (a nearby normal power of two for supported
+ *      binary floating-point accumulators)
  *  2 - compute \f$ s \Vert \frac{*this}{s} \Vert \f$ in a standard way
  *
  * For architecture/scalar types supporting vectorization, this version
@@ -181,12 +301,15 @@
  */
 template <typename Derived>
 inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::stableNorm() const {
-  return internal::stable_norm_impl(derived());
+  using Nested = typename internal::nested_eval<Derived, 2>::type;
+  Nested nested(derived());
+  return internal::stable_norm_impl(nested);
 }
 
-/** \returns the \em l2 norm of \c *this using the Blue's algorithm.
- * A Portable Fortran Program to Find the Euclidean Norm of a Vector,
- * ACM TOMS, Vol 4, Issue 1, 1978.
+/** \returns the \em l2 norm of \c *this using Blue's algorithm, with
+ * Anderson's Algorithm 978 correction for denormalized values.
+ * Blue, A Portable Fortran Program to Find the Euclidean Norm of a Vector,
+ * ACM TOMS, Vol 4, Issue 1, 1978; Anderson, ACM TOMS, Vol 44, Issue 1, 2017.
  *
  * For architecture/scalar types without vectorization, this version
  * is much faster than stableNorm(). Otherwise the stableNorm() is faster.
@@ -205,10 +328,11 @@
  */
 template <typename Derived>
 inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::hypotNorm() const {
-  if (size() == 1)
-    return numext::abs(coeff(0, 0));
-  else
-    return this->cwiseAbs().redux(internal::scalar_hypot_op<RealScalar>());
+  using Accumulator = typename internal::stable_norm_accumulator<RealScalar>::type;
+  if (size() == 0) return RealScalar(0);
+  // Component reduction avoids rounded complex magnitudes and permits promoted accumulation.
+  return RealScalar(
+      derived().realView().template cast<Accumulator>().cwiseAbs().redux(internal::scalar_hypot_op<Accumulator>()));
 }
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/StlIterators.h b/Eigen/src/Core/StlIterators.h
index afa2ecb..e8179a0 100644
--- a/Eigen/src/Core/StlIterators.h
+++ b/Eigen/src/Core/StlIterators.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STLITERATORS_H
 #define EIGEN_STLITERATORS_H
@@ -23,20 +24,20 @@
 template <typename Derived>
 class indexed_based_stl_iterator_base {
  protected:
-  typedef indexed_based_stl_iterator_traits<Derived> traits;
-  typedef typename traits::XprType XprType;
-  typedef indexed_based_stl_iterator_base<typename traits::non_const_iterator> non_const_iterator;
-  typedef indexed_based_stl_iterator_base<typename traits::const_iterator> const_iterator;
-  typedef std::conditional_t<internal::is_const<XprType>::value, non_const_iterator, const_iterator> other_iterator;
+  using traits = indexed_based_stl_iterator_traits<Derived>;
+  using XprType = typename traits::XprType;
+  using non_const_iterator = indexed_based_stl_iterator_base<typename traits::non_const_iterator>;
+  using const_iterator = indexed_based_stl_iterator_base<typename traits::const_iterator>;
+  using other_iterator = std::conditional_t<std::is_const<XprType>::value, non_const_iterator, const_iterator>;
 
   friend class indexed_based_stl_iterator_base<typename traits::const_iterator>;
   friend class indexed_based_stl_iterator_base<typename traits::non_const_iterator>;
 
  public:
-  typedef Index difference_type;
-  typedef std::random_access_iterator_tag iterator_category;
+  using difference_type = Index;
+  using iterator_category = std::random_access_iterator_tag;
 
-  indexed_based_stl_iterator_base() noexcept : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_iterator_base() noexcept = default;
   indexed_based_stl_iterator_base(XprType& xpr, Index index) noexcept : mp_xpr(&xpr), m_index(index) {}
 
   indexed_based_stl_iterator_base(const non_const_iterator& other) noexcept
@@ -162,27 +163,27 @@
   Derived& derived() { return static_cast<Derived&>(*this); }
   const Derived& derived() const { return static_cast<const Derived&>(*this); }
 
-  XprType* mp_xpr;
-  Index m_index;
+  XprType* mp_xpr = nullptr;
+  Index m_index = 0;
 };
 
 template <typename Derived>
 class indexed_based_stl_reverse_iterator_base {
  protected:
-  typedef indexed_based_stl_iterator_traits<Derived> traits;
-  typedef typename traits::XprType XprType;
-  typedef indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator> non_const_iterator;
-  typedef indexed_based_stl_reverse_iterator_base<typename traits::const_iterator> const_iterator;
-  typedef std::conditional_t<internal::is_const<XprType>::value, non_const_iterator, const_iterator> other_iterator;
+  using traits = indexed_based_stl_iterator_traits<Derived>;
+  using XprType = typename traits::XprType;
+  using non_const_iterator = indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator>;
+  using const_iterator = indexed_based_stl_reverse_iterator_base<typename traits::const_iterator>;
+  using other_iterator = std::conditional_t<std::is_const<XprType>::value, non_const_iterator, const_iterator>;
 
   friend class indexed_based_stl_reverse_iterator_base<typename traits::const_iterator>;
   friend class indexed_based_stl_reverse_iterator_base<typename traits::non_const_iterator>;
 
  public:
-  typedef Index difference_type;
-  typedef std::random_access_iterator_tag iterator_category;
+  using difference_type = Index;
+  using iterator_category = std::random_access_iterator_tag;
 
-  indexed_based_stl_reverse_iterator_base() : mp_xpr(0), m_index(0) {}
+  indexed_based_stl_reverse_iterator_base() = default;
   indexed_based_stl_reverse_iterator_base(XprType& xpr, Index index) : mp_xpr(&xpr), m_index(index) {}
 
   indexed_based_stl_reverse_iterator_base(const non_const_iterator& other)
@@ -308,34 +309,33 @@
   Derived& derived() { return static_cast<Derived&>(*this); }
   const Derived& derived() const { return static_cast<const Derived&>(*this); }
 
-  XprType* mp_xpr;
-  Index m_index;
+  XprType* mp_xpr = nullptr;
+  Index m_index = 0;
 };
 
 template <typename XprType>
 class pointer_based_stl_iterator {
   enum { is_lvalue = internal::is_lvalue<XprType>::value };
-  typedef pointer_based_stl_iterator<std::remove_const_t<XprType>> non_const_iterator;
-  typedef pointer_based_stl_iterator<std::add_const_t<XprType>> const_iterator;
-  typedef std::conditional_t<internal::is_const<XprType>::value, non_const_iterator, const_iterator> other_iterator;
+  using non_const_iterator = pointer_based_stl_iterator<std::remove_const_t<XprType>>;
+  using const_iterator = pointer_based_stl_iterator<std::add_const_t<XprType>>;
+  using other_iterator = std::conditional_t<std::is_const<XprType>::value, non_const_iterator, const_iterator>;
 
   friend class pointer_based_stl_iterator<std::add_const_t<XprType>>;
   friend class pointer_based_stl_iterator<std::remove_const_t<XprType>>;
 
  public:
-  typedef Index difference_type;
-  typedef typename XprType::Scalar value_type;
+  using difference_type = Index;
+  using value_type = typename XprType::Scalar;
 #if EIGEN_COMP_CXXVER >= 20 && defined(__cpp_lib_concepts) && __cpp_lib_concepts >= 202002L
-  typedef std::conditional_t<XprType::InnerStrideAtCompileTime == 1, std::contiguous_iterator_tag,
-                             std::random_access_iterator_tag>
-      iterator_category;
+  using iterator_category = std::conditional_t<XprType::InnerStrideAtCompileTime == 1, std::contiguous_iterator_tag,
+                                               std::random_access_iterator_tag>;
 #else
-  typedef std::random_access_iterator_tag iterator_category;
+  using iterator_category = std::random_access_iterator_tag;
 #endif
-  typedef std::conditional_t<bool(is_lvalue), value_type*, const value_type*> pointer;
-  typedef std::conditional_t<bool(is_lvalue), value_type&, const value_type&> reference;
+  using pointer = std::conditional_t<bool(is_lvalue), value_type*, const value_type*>;
+  using reference = std::conditional_t<bool(is_lvalue), value_type&, const value_type&>;
 
-  pointer_based_stl_iterator() noexcept : m_ptr(0), m_incr(XprType::InnerStrideAtCompileTime) {}
+  pointer_based_stl_iterator() noexcept = default;
   pointer_based_stl_iterator(XprType& xpr, Index index) noexcept
       : m_ptr(xpr.data() + index * xpr.innerStride()), m_incr(xpr.innerStride()) {}
 
@@ -409,35 +409,40 @@
 
   bool operator==(const pointer_based_stl_iterator& other) const { return m_ptr == other.m_ptr; }
   bool operator!=(const pointer_based_stl_iterator& other) const { return m_ptr != other.m_ptr; }
-  bool operator<(const pointer_based_stl_iterator& other) const { return m_ptr < other.m_ptr; }
-  bool operator<=(const pointer_based_stl_iterator& other) const { return m_ptr <= other.m_ptr; }
-  bool operator>(const pointer_based_stl_iterator& other) const { return m_ptr > other.m_ptr; }
-  bool operator>=(const pointer_based_stl_iterator& other) const { return m_ptr >= other.m_ptr; }
+  bool operator<(const pointer_based_stl_iterator& other) const {
+    // Iterator order follows the stride, not necessarily increasing addresses.
+    return m_incr.value() < 0 ? m_ptr > other.m_ptr : m_ptr < other.m_ptr;
+  }
+  bool operator<=(const pointer_based_stl_iterator& other) const { return !(other < *this); }
+  bool operator>(const pointer_based_stl_iterator& other) const { return other < *this; }
+  bool operator>=(const pointer_based_stl_iterator& other) const { return !(*this < other); }
 
   bool operator==(const other_iterator& other) const { return m_ptr == other.m_ptr; }
   bool operator!=(const other_iterator& other) const { return m_ptr != other.m_ptr; }
-  bool operator<(const other_iterator& other) const { return m_ptr < other.m_ptr; }
-  bool operator<=(const other_iterator& other) const { return m_ptr <= other.m_ptr; }
-  bool operator>(const other_iterator& other) const { return m_ptr > other.m_ptr; }
-  bool operator>=(const other_iterator& other) const { return m_ptr >= other.m_ptr; }
+  bool operator<(const other_iterator& other) const {
+    return m_incr.value() < 0 ? m_ptr > other.m_ptr : m_ptr < other.m_ptr;
+  }
+  bool operator<=(const other_iterator& other) const { return !(other < *this); }
+  bool operator>(const other_iterator& other) const { return other < *this; }
+  bool operator>=(const other_iterator& other) const { return !(*this < other); }
 
  protected:
-  pointer m_ptr;
-  internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_incr;
+  pointer m_ptr = nullptr;
+  internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_incr{XprType::InnerStrideAtCompileTime};
 };
 
 template <typename XprType_>
 struct indexed_based_stl_iterator_traits<generic_randaccess_stl_iterator<XprType_>> {
-  typedef XprType_ XprType;
-  typedef generic_randaccess_stl_iterator<std::remove_const_t<XprType>> non_const_iterator;
-  typedef generic_randaccess_stl_iterator<std::add_const_t<XprType>> const_iterator;
+  using XprType = XprType_;
+  using non_const_iterator = generic_randaccess_stl_iterator<std::remove_const_t<XprType>>;
+  using const_iterator = generic_randaccess_stl_iterator<std::add_const_t<XprType>>;
 };
 
 template <typename XprType>
 class generic_randaccess_stl_iterator
     : public indexed_based_stl_iterator_base<generic_randaccess_stl_iterator<XprType>> {
  public:
-  typedef typename XprType::Scalar value_type;
+  using value_type = typename XprType::Scalar;
 
  protected:
   enum {
@@ -445,20 +450,20 @@
     is_lvalue = internal::is_lvalue<XprType>::value
   };
 
-  typedef indexed_based_stl_iterator_base<generic_randaccess_stl_iterator> Base;
+  using Base = indexed_based_stl_iterator_base<generic_randaccess_stl_iterator>;
   using Base::m_index;
   using Base::mp_xpr;
 
   // TODO: currently const Transpose/Reshape expressions never returns const references,
   // so lets return by value too.
   // typedef std::conditional_t<bool(has_direct_access), const value_type&, const value_type> read_only_ref_t;
-  typedef const value_type read_only_ref_t;
+  using read_only_ref_t = const value_type;
 
  public:
-  typedef std::conditional_t<bool(is_lvalue), value_type*, const value_type*> pointer;
-  typedef std::conditional_t<bool(is_lvalue), value_type&, read_only_ref_t> reference;
+  using pointer = std::conditional_t<bool(is_lvalue), value_type*, const value_type*>;
+  using reference = std::conditional_t<bool(is_lvalue), value_type&, read_only_ref_t>;
 
-  generic_randaccess_stl_iterator() : Base() {}
+  generic_randaccess_stl_iterator() = default;
   generic_randaccess_stl_iterator(XprType& xpr, Index index) : Base(xpr, index) {}
   generic_randaccess_stl_iterator(const typename Base::non_const_iterator& other) : Base(other) {}
   using Base::operator=;
@@ -470,9 +475,9 @@
 
 template <typename XprType_, DirectionType Direction>
 struct indexed_based_stl_iterator_traits<subvector_stl_iterator<XprType_, Direction>> {
-  typedef XprType_ XprType;
-  typedef subvector_stl_iterator<std::remove_const_t<XprType>, Direction> non_const_iterator;
-  typedef subvector_stl_iterator<std::add_const_t<XprType>, Direction> const_iterator;
+  using XprType = XprType_;
+  using non_const_iterator = subvector_stl_iterator<std::remove_const_t<XprType>, Direction>;
+  using const_iterator = subvector_stl_iterator<std::add_const_t<XprType>, Direction>;
 };
 
 template <typename XprType, DirectionType Direction>
@@ -480,17 +485,17 @@
  protected:
   enum { is_lvalue = internal::is_lvalue<XprType>::value };
 
-  typedef indexed_based_stl_iterator_base<subvector_stl_iterator> Base;
+  using Base = indexed_based_stl_iterator_base<subvector_stl_iterator>;
   using Base::m_index;
   using Base::mp_xpr;
 
-  typedef std::conditional_t<Direction == Vertical, typename XprType::ColXpr, typename XprType::RowXpr> SubVectorType;
-  typedef std::conditional_t<Direction == Vertical, typename XprType::ConstColXpr, typename XprType::ConstRowXpr>
-      ConstSubVectorType;
+  using SubVectorType = std::conditional_t<Direction == Vertical, typename XprType::ColXpr, typename XprType::RowXpr>;
+  using ConstSubVectorType =
+      std::conditional_t<Direction == Vertical, typename XprType::ConstColXpr, typename XprType::ConstRowXpr>;
 
  public:
-  typedef std::conditional_t<bool(is_lvalue), SubVectorType, ConstSubVectorType> reference;
-  typedef typename reference::PlainObject value_type;
+  using reference = std::conditional_t<bool(is_lvalue), SubVectorType, ConstSubVectorType>;
+  using value_type = typename reference::PlainObject;
 
  private:
   class subvector_stl_iterator_ptr {
@@ -503,10 +508,11 @@
   };
 
  public:
-  typedef subvector_stl_iterator_ptr pointer;
+  using pointer = subvector_stl_iterator_ptr;
 
-  subvector_stl_iterator() : Base() {}
+  subvector_stl_iterator() = default;
   subvector_stl_iterator(XprType& xpr, Index index) : Base(xpr, index) {}
+  subvector_stl_iterator(const typename Base::non_const_iterator& other) : Base(other) {}
 
   reference operator*() const { return (*mp_xpr).template subVector<Direction>(m_index); }
   reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index + i); }
@@ -515,9 +521,9 @@
 
 template <typename XprType_, DirectionType Direction>
 struct indexed_based_stl_iterator_traits<subvector_stl_reverse_iterator<XprType_, Direction>> {
-  typedef XprType_ XprType;
-  typedef subvector_stl_reverse_iterator<std::remove_const_t<XprType>, Direction> non_const_iterator;
-  typedef subvector_stl_reverse_iterator<std::add_const_t<XprType>, Direction> const_iterator;
+  using XprType = XprType_;
+  using non_const_iterator = subvector_stl_reverse_iterator<std::remove_const_t<XprType>, Direction>;
+  using const_iterator = subvector_stl_reverse_iterator<std::add_const_t<XprType>, Direction>;
 };
 
 template <typename XprType, DirectionType Direction>
@@ -526,17 +532,17 @@
  protected:
   enum { is_lvalue = internal::is_lvalue<XprType>::value };
 
-  typedef indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator> Base;
+  using Base = indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_iterator>;
   using Base::m_index;
   using Base::mp_xpr;
 
-  typedef std::conditional_t<Direction == Vertical, typename XprType::ColXpr, typename XprType::RowXpr> SubVectorType;
-  typedef std::conditional_t<Direction == Vertical, typename XprType::ConstColXpr, typename XprType::ConstRowXpr>
-      ConstSubVectorType;
+  using SubVectorType = std::conditional_t<Direction == Vertical, typename XprType::ColXpr, typename XprType::RowXpr>;
+  using ConstSubVectorType =
+      std::conditional_t<Direction == Vertical, typename XprType::ConstColXpr, typename XprType::ConstRowXpr>;
 
  public:
-  typedef std::conditional_t<bool(is_lvalue), SubVectorType, ConstSubVectorType> reference;
-  typedef typename reference::PlainObject value_type;
+  using reference = std::conditional_t<bool(is_lvalue), SubVectorType, ConstSubVectorType>;
+  using value_type = typename reference::PlainObject;
 
  private:
   class subvector_stl_reverse_iterator_ptr {
@@ -549,13 +555,14 @@
   };
 
  public:
-  typedef subvector_stl_reverse_iterator_ptr pointer;
+  using pointer = subvector_stl_reverse_iterator_ptr;
 
-  subvector_stl_reverse_iterator() : Base() {}
+  subvector_stl_reverse_iterator() = default;
   subvector_stl_reverse_iterator(XprType& xpr, Index index) : Base(xpr, index) {}
+  subvector_stl_reverse_iterator(const typename Base::non_const_iterator& other) : Base(other) {}
 
   reference operator*() const { return (*mp_xpr).template subVector<Direction>(m_index); }
-  reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index + i); }
+  reference operator[](Index i) const { return (*mp_xpr).template subVector<Direction>(m_index - i); }
   pointer operator->() const { return (*mp_xpr).template subVector<Direction>(m_index); }
 };
 
@@ -605,7 +612,7 @@
 
 /** returns a read-only const_iterator to the element following the last element of the 1D vector or array
  * \only_for_vectors
- * \sa begin(), cend()
+ * \sa cbegin(), end()
  */
 template <typename Derived>
 inline typename DenseBase<Derived>::const_iterator DenseBase<Derived>::cend() const {
diff --git a/Eigen/src/Core/Stride.h b/Eigen/src/Core/Stride.h
index 8957aa9..7068388 100644
--- a/Eigen/src/Core/Stride.h
+++ b/Eigen/src/Core/Stride.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STRIDE_H
 #define EIGEN_STRIDE_H
@@ -45,7 +46,7 @@
  * because of the ambiguity with Dynamic which is defined to -1 (historically, negative strides were
  * not allowed).
  *
- * Note that for compile-time vectors (ColsAtCompileTime==1 or RowsAtCompile==1),
+ * Note that for compile-time vectors (ColsAtCompileTime==1 or RowsAtCompileTime==1),
  * the inner stride is the pointer increment between two consecutive elements,
  * regardless of storage layout.
  *
@@ -54,13 +55,11 @@
 template <int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
 class Stride {
  public:
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
   enum { InnerStrideAtCompileTime = InnerStrideAtCompileTime_, OuterStrideAtCompileTime = OuterStrideAtCompileTime_ };
 
   /** Default constructor, for use when strides are fixed at compile time */
   EIGEN_DEVICE_FUNC constexpr Stride() : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime) {
-    // FIXME: for Eigen 4 we should use DynamicIndex instead of Dynamic.
-    // FIXME: for Eigen 4 we should also unify this API with fix<>
     eigen_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic);
   }
 
@@ -69,7 +68,7 @@
       : m_outer(outerStride), m_inner(innerStride) {}
 
   /** Copy constructor */
-  EIGEN_DEVICE_FUNC constexpr Stride(const Stride& other) : m_outer(other.outer()), m_inner(other.inner()) {}
+  EIGEN_DEVICE_FUNC constexpr Stride(const Stride& other) = default;
 
   /** Copy assignment operator */
   EIGEN_DEVICE_FUNC constexpr Stride& operator=(const Stride& other) {
@@ -92,10 +91,10 @@
  * See class Map for some examples */
 template <int Value>
 class InnerStride : public Stride<0, Value> {
-  typedef Stride<0, Value> Base;
+  using Base = Stride<0, Value>;
 
  public:
-  EIGEN_DEVICE_FUNC constexpr InnerStride() : Base() {}
+  EIGEN_DEVICE_FUNC constexpr InnerStride() = default;
   EIGEN_DEVICE_FUNC constexpr InnerStride(Index v) : Base(0, v) {}  // FIXME making this explicit could break valid code
 };
 
@@ -103,10 +102,10 @@
  * See class Map for some examples */
 template <int Value>
 class OuterStride : public Stride<Value, 0> {
-  typedef Stride<Value, 0> Base;
+  using Base = Stride<Value, 0>;
 
  public:
-  EIGEN_DEVICE_FUNC constexpr OuterStride() : Base() {}
+  EIGEN_DEVICE_FUNC constexpr OuterStride() = default;
   EIGEN_DEVICE_FUNC constexpr OuterStride(Index v) : Base(v, 0) {}  // FIXME making this explicit could break valid code
 };
 
diff --git a/Eigen/src/Core/StructuredBindings.h b/Eigen/src/Core/StructuredBindings.h
new file mode 100644
index 0000000..6761360
--- /dev/null
+++ b/Eigen/src/Core/StructuredBindings.h
@@ -0,0 +1,161 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Pavel Guzenfeld
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_STRUCTURED_BINDINGS_H
+#define EIGEN_STRUCTURED_BINDINGS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#if EIGEN_MAX_CPP_VER >= 17 && EIGEN_COMP_CXXVER >= 17
+
+#include <tuple>
+#include <type_traits>
+
+// Structured bindings support for fixed-size Eigen vectors and matrices.
+//
+// Enables:
+//   Eigen::Vector3d v(1, 2, 3);
+//   auto [x, y, z] = v;
+//
+//   Eigen::Array3i a(4, 5, 6);
+//   auto& [a0, a1, a2] = a;
+//
+// Decomposition order follows storage order: column-major by default,
+// so Matrix2d decomposes as (0,0), (1,0), (0,1), (1,1). Only fixed-size
+// column-major Matrix and Array are tuple-like; Map, Ref, and fixed-size
+// Block intentionally do not participate.
+
+namespace Eigen {
+namespace internal {
+
+// Bases supplying value/type only for fixed-size shapes, leaving the std
+// specializations below memberless for dynamic sizes: generic tuple-like
+// detection probes std::tuple_size<T>::value in a SFINAE context (fmt's range
+// formatter, issue #3103) and needs a substitution failure, not a hard error.
+// An enable_if_t base-clause cannot replace this: base-class-specifier
+// substitution is not a SFINAE context.
+template <int Rows_, int Cols_, bool IsFixedSize_ = (Rows_ != Dynamic && Cols_ != Dynamic)>
+struct structured_binding_size {};
+
+template <int Rows_, int Cols_>
+struct structured_binding_size<Rows_, Cols_, true>
+    : std::integral_constant<size_t, static_cast<size_t>(Rows_) * static_cast<size_t>(Cols_)> {};
+
+// Note: uses Idx_ instead of I to avoid conflict with Eigen's test framework macro.
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_,
+          bool IsFixedSize_ = (Rows_ != Dynamic && Cols_ != Dynamic)>
+struct structured_binding_element {};
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_>
+struct structured_binding_element<Idx_, Scalar_, Rows_, Cols_, true> {
+  static_assert(Idx_ < static_cast<size_t>(Rows_) * static_cast<size_t>(Cols_), "Index out of range.");
+  using type = Scalar_;
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+namespace std {
+
+// std::tuple_size / std::tuple_element for Matrix.
+template <typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+struct tuple_size<Eigen::Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>>
+    : Eigen::internal::structured_binding_size<Rows_, Cols_> {};
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+struct tuple_element<Idx_, Eigen::Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>>
+    : Eigen::internal::structured_binding_element<Idx_, Scalar_, Rows_, Cols_> {};
+
+// std::tuple_size / std::tuple_element for Array.
+template <typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+struct tuple_size<Eigen::Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>>
+    : Eigen::internal::structured_binding_size<Rows_, Cols_> {};
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+struct tuple_element<Idx_, Eigen::Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>>
+    : Eigen::internal::structured_binding_element<Idx_, Scalar_, Rows_, Cols_> {};
+
+}  // namespace std
+
+namespace Eigen {
+
+// Until the decomposition order for genuinely 2D RowMajor storage is agreed
+// upon, reject row-major matrices at the get<I> level. coeffRef(Index) is
+// linear in storage order, so permitting both orientations for 2D types would
+// silently flip the binding order between Matrix<T,R,C> and Matrix<T,R,C,RowMajor>.
+// Vector types (Rows==1 or Cols==1) are unaffected because storage order
+// does not change element order for a 1×N or N×1 shape — and Eigen forces
+// row-major on 1×N regardless, so we must allow it for row vectors.
+#define EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(ROWS, COLS, OPTIONS)  \
+  static_assert((ROWS <= 1 || COLS <= 1) || ((OPTIONS & RowMajor) == 0), \
+                "Structured bindings on 2D RowMajor Eigen matrices are disabled to prevent storage-order confusion.");
+
+// get<Idx_> free functions for Matrix.
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar_& get(
+    Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>& m) noexcept {
+  static_assert(Rows_ != Dynamic && Cols_ != Dynamic, "Structured bindings require fixed-size Eigen types.");
+  static_assert(Idx_ < static_cast<size_t>(Rows_ * Cols_), "Index out of range.");
+  EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(Rows_, Cols_, Options_);
+  return m.coeffRef(static_cast<Index>(Idx_));
+}
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar_& get(
+    const Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>& m) noexcept {
+  static_assert(Rows_ != Dynamic && Cols_ != Dynamic, "Structured bindings require fixed-size Eigen types.");
+  static_assert(Idx_ < static_cast<size_t>(Rows_ * Cols_), "Index out of range.");
+  EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(Rows_, Cols_, Options_);
+  return m.coeffRef(static_cast<Index>(Idx_));
+}
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar_&& get(
+    Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>&& m) noexcept {
+  static_assert(Rows_ != Dynamic && Cols_ != Dynamic, "Structured bindings require fixed-size Eigen types.");
+  static_assert(Idx_ < static_cast<size_t>(Rows_ * Cols_), "Index out of range.");
+  EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(Rows_, Cols_, Options_);
+  return std::move(m.coeffRef(static_cast<Index>(Idx_)));
+}
+
+// get<Idx_> free functions for Array.
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar_& get(
+    Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>& a) noexcept {
+  static_assert(Rows_ != Dynamic && Cols_ != Dynamic, "Structured bindings require fixed-size Eigen types.");
+  static_assert(Idx_ < static_cast<size_t>(Rows_ * Cols_), "Index out of range.");
+  EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(Rows_, Cols_, Options_);
+  return a.coeffRef(static_cast<Index>(Idx_));
+}
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar_& get(
+    const Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>& a) noexcept {
+  static_assert(Rows_ != Dynamic && Cols_ != Dynamic, "Structured bindings require fixed-size Eigen types.");
+  static_assert(Idx_ < static_cast<size_t>(Rows_ * Cols_), "Index out of range.");
+  EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(Rows_, Cols_, Options_);
+  return a.coeffRef(static_cast<Index>(Idx_));
+}
+
+template <size_t Idx_, typename Scalar_, int Rows_, int Cols_, int Options_, int MaxRows_, int MaxCols_>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar_&& get(
+    Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>&& a) noexcept {
+  static_assert(Rows_ != Dynamic && Cols_ != Dynamic, "Structured bindings require fixed-size Eigen types.");
+  static_assert(Idx_ < static_cast<size_t>(Rows_ * Cols_), "Index out of range.");
+  EIGEN_STRUCTURED_BINDINGS_ASSERT_COL_MAJOR(Rows_, Cols_, Options_);
+  return std::move(a.coeffRef(static_cast<Index>(Idx_)));
+}
+
+}  // namespace Eigen
+
+#endif  // C++17
+
+#endif  // EIGEN_STRUCTURED_BINDINGS_H
diff --git a/Eigen/src/Core/Swap.h b/Eigen/src/Core/Swap.h
index 6dc571e..6190eea 100644
--- a/Eigen/src/Core/Swap.h
+++ b/Eigen/src/Core/Swap.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SWAP_H
 #define EIGEN_SWAP_H
@@ -24,17 +25,15 @@
     : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT,
                                              swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn> {
  protected:
-  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT,
-                                          swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn>
-      Base;
+  using Base = generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT,
+                                               swap_assign_op<typename DstEvaluatorTypeT::Scalar>, BuiltIn>;
   using Base::m_dst;
-  using Base::m_functor;
   using Base::m_src;
 
  public:
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::DstXprType DstXprType;
-  typedef swap_assign_op<Scalar> Functor;
+  using Scalar = typename Base::Scalar;
+  using DstXprType = typename Base::DstXprType;
+  using Functor = swap_assign_op<Scalar>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE generic_dense_assignment_kernel(DstEvaluatorTypeT &dst,
                                                                                   const SrcEvaluatorTypeT &src,
@@ -58,8 +57,6 @@
     m_dst.template writePacket<StoreMode>(index, tmp);
   }
 
-  // TODO: find a simple way not to have to copy/paste this function from generic_dense_assignment_kernel, by simple I
-  // mean no CRTP (Gael)
   template <int StoreMode, int LoadMode, typename PacketType>
   EIGEN_STRONG_INLINE void assignPacketByOuterInner(Index outer, Index inner) {
     Index row = Base::rowIndexByOuterInner(outer, inner);
@@ -83,8 +80,6 @@
     m_dst.template writePacketSegment<StoreMode>(index, tmp, begin, count);
   }
 
-  // TODO: find a simple way not to have to copy/paste this function from generic_dense_assignment_kernel, by simple I
-  // mean no CRTP (Gael)
   template <int StoreMode, int LoadMode, typename PacketType>
   EIGEN_STRONG_INLINE void assignPacketSegmentByOuterInner(Index outer, Index inner, Index begin, Index count) {
     Index row = Base::rowIndexByOuterInner(outer, inner);
diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h
index 2077c92..700dba6 100644
--- a/Eigen/src/Core/Transpose.h
+++ b/Eigen/src/Core/Transpose.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRANSPOSE_H
 #define EIGEN_TRANSPOSE_H
@@ -18,9 +19,9 @@
 
 namespace internal {
 template <typename MatrixType>
-struct traits<Transpose<MatrixType> > : public traits<MatrixType> {
-  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNestedPlain;
+struct traits<Transpose<MatrixType>> : public traits<MatrixType> {
+  using MatrixTypeNested = typename ref_selector<MatrixType>::type;
+  using MatrixTypeNestedPlain = std::remove_reference_t<MatrixTypeNested>;
   enum {
     RowsAtCompileTime = MatrixType::ColsAtCompileTime,
     ColsAtCompileTime = MatrixType::RowsAtCompileTime,
@@ -30,8 +31,8 @@
     Flags0 = traits<MatrixTypeNestedPlain>::Flags & ~(LvalueBit | NestByRefBit),
     Flags1 = Flags0 | FlagsLvalueBit,
     Flags = Flags1 ^ RowMajorBit,
-    InnerStrideAtCompileTime = inner_stride_at_compile_time<MatrixType>::ret,
-    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret
+    InnerStrideAtCompileTime = inner_stride_at_compile_time<MatrixType>::value,
+    OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::value
   };
 };
 }  // namespace internal
@@ -55,11 +56,11 @@
 template <typename MatrixType>
 class Transpose : public TransposeImpl<MatrixType, typename internal::traits<MatrixType>::StorageKind> {
  public:
-  typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
+  using MatrixTypeNested = typename internal::ref_selector<MatrixType>::non_const_type;
 
-  typedef typename TransposeImpl<MatrixType, typename internal::traits<MatrixType>::StorageKind>::Base Base;
+  using Base = typename TransposeImpl<MatrixType, typename internal::traits<MatrixType>::StorageKind>::Base;
   EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
-  typedef internal::remove_all_t<MatrixType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<MatrixType>;
 
   EIGEN_DEVICE_FUNC constexpr explicit EIGEN_STRONG_INLINE Transpose(MatrixType& matrix) : m_matrix(matrix) {}
 
@@ -88,29 +89,24 @@
 
 namespace internal {
 
-template <typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret>
-struct TransposeImpl_base {
-  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
-};
-
 template <typename MatrixType>
-struct TransposeImpl_base<MatrixType, false> {
-  typedef typename dense_xpr_base<Transpose<MatrixType> >::type type;
+struct TransposeImpl_base {
+  using type = typename dense_xpr_base<Transpose<MatrixType>>::type;
 };
 
 }  // end namespace internal
 
 // Generic API dispatcher
 template <typename XprType, typename StorageKind>
-class TransposeImpl : public internal::generic_xpr_base<Transpose<XprType> >::type {
+class TransposeImpl : public internal::generic_xpr_base<Transpose<XprType>>::type {
  public:
-  typedef typename internal::generic_xpr_base<Transpose<XprType> >::type Base;
+  using Base = typename internal::generic_xpr_base<Transpose<XprType>>::type;
 };
 
 template <typename MatrixType>
 class TransposeImpl<MatrixType, Dense> : public internal::TransposeImpl_base<MatrixType>::type {
  public:
-  typedef typename internal::TransposeImpl_base<MatrixType>::type Base;
+  using Base = typename internal::TransposeImpl_base<MatrixType>::type;
   using Base::coeffRef;
   EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TransposeImpl)
@@ -122,10 +118,16 @@
     return derived().nestedExpression().outerStride();
   }
 
-  typedef std::conditional_t<internal::is_lvalue<MatrixType>::value, Scalar, const Scalar> ScalarWithConstIfNotLvalue;
+  using ScalarWithConstIfNotLvalue = std::conditional_t<internal::is_lvalue<MatrixType>::value, Scalar, const Scalar>;
 
-  EIGEN_DEVICE_FUNC constexpr ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression().data(); }
-  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const { return derived().nestedExpression().data(); }
+  template <typename T = MatrixType, typename = internal::void_t<decltype(std::declval<T&>().data())>>
+  EIGEN_DEVICE_FUNC constexpr ScalarWithConstIfNotLvalue* data() {
+    return derived().nestedExpression().data();
+  }
+  template <typename T = MatrixType, typename = internal::void_t<decltype(std::declval<const T&>().data())>>
+  EIGEN_DEVICE_FUNC constexpr const Scalar* data() const {
+    return derived().nestedExpression().data();
+  }
 
   // FIXME: shall we keep the const version of coeffRef?
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const {
@@ -224,8 +226,8 @@
 template <typename MatrixType>
 struct inplace_transpose_selector<MatrixType, true, true> {  // PacketSize x PacketSize
   static void run(MatrixType& m) {
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+    using Scalar = typename MatrixType::Scalar;
+    using Packet = typename internal::packet_traits<typename MatrixType::Scalar>::type;
     const Index PacketSize = internal::packet_traits<Scalar>::size;
     const Index Alignment = internal::evaluator<MatrixType>::Alignment;
     PacketBlock<Packet> A;
@@ -238,8 +240,8 @@
 
 template <typename MatrixType, Index Alignment>
 void BlockedInPlaceTranspose(MatrixType& m) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename internal::packet_traits<typename MatrixType::Scalar>::type Packet;
+  using Scalar = typename MatrixType::Scalar;
+  using Packet = typename internal::packet_traits<typename MatrixType::Scalar>::type;
   const Index PacketSize = internal::packet_traits<Scalar>::size;
   eigen_assert(m.rows() == m.cols());
   int row_start = 0;
@@ -278,18 +280,20 @@
 template <typename MatrixType, bool MatchPacketSize>
 struct inplace_transpose_selector<MatrixType, false, MatchPacketSize> {  // non square or dynamic matrix
   static void run(MatrixType& m) {
-    typedef typename MatrixType::Scalar Scalar;
+    using Scalar = typename MatrixType::Scalar;
     if (m.rows() == m.cols()) {
       const Index PacketSize = internal::packet_traits<Scalar>::size;
-      if (!NumTraits<Scalar>::IsComplex && m.rows() >= PacketSize) {
-        if ((m.rows() % PacketSize) == 0)
-          BlockedInPlaceTranspose<MatrixType, internal::evaluator<MatrixType>::Alignment>(m);
-        else
-          BlockedInPlaceTranspose<MatrixType, Unaligned>(m);
-      } else {
-        m.matrix().template triangularView<StrictlyUpper>().swap(
-            m.matrix().transpose().template triangularView<StrictlyUpper>());
+      EIGEN_IF_CONSTEXPR (!NumTraits<Scalar>::IsComplex && (internal::evaluator<MatrixType>::Flags & PacketAccessBit)) {
+        if (m.rows() >= PacketSize) {
+          if ((m.rows() % PacketSize) == 0)
+            BlockedInPlaceTranspose<MatrixType, internal::evaluator<MatrixType>::Alignment>(m);
+          else
+            BlockedInPlaceTranspose<MatrixType, Unaligned>(m);
+          return;
+        }
       }
+      m.matrix().template triangularView<StrictlyUpper>().swap(
+          m.matrix().transpose().template triangularView<StrictlyUpper>());
     } else {
       m = m.transpose().eval();
     }
@@ -359,17 +363,13 @@
 namespace internal {
 
 template <bool DestIsTransposed, typename OtherDerived>
-struct check_transpose_aliasing_compile_time_selector {
-  enum { ret = bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed };
-};
+struct check_transpose_aliasing_compile_time_selector
+    : bool_constant<bool(blas_traits<OtherDerived>::IsTransposed) != DestIsTransposed> {};
 
 template <bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
-struct check_transpose_aliasing_compile_time_selector<DestIsTransposed, CwiseBinaryOp<BinOp, DerivedA, DerivedB> > {
-  enum {
-    ret = bool(blas_traits<DerivedA>::IsTransposed) != DestIsTransposed ||
-          bool(blas_traits<DerivedB>::IsTransposed) != DestIsTransposed
-  };
-};
+struct check_transpose_aliasing_compile_time_selector<DestIsTransposed, CwiseBinaryOp<BinOp, DerivedA, DerivedB>>
+    : bool_constant<bool(blas_traits<DerivedA>::IsTransposed) != DestIsTransposed ||
+                    bool(blas_traits<DerivedB>::IsTransposed) != DestIsTransposed> {};
 
 template <typename Scalar, bool DestIsTransposed, typename OtherDerived>
 struct check_transpose_aliasing_run_time_selector {
@@ -380,7 +380,7 @@
 };
 
 template <typename Scalar, bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB>
-struct check_transpose_aliasing_run_time_selector<Scalar, DestIsTransposed, CwiseBinaryOp<BinOp, DerivedA, DerivedB> > {
+struct check_transpose_aliasing_run_time_selector<Scalar, DestIsTransposed, CwiseBinaryOp<BinOp, DerivedA, DerivedB>> {
   EIGEN_DEVICE_FUNC static bool run(const Scalar* dest, const CwiseBinaryOp<BinOp, DerivedA, DerivedB>& src) {
     return ((blas_traits<DerivedA>::IsTransposed != DestIsTransposed) &&
             (dest != 0 && dest == (const Scalar*)extract_data(src.lhs()))) ||
@@ -397,7 +397,7 @@
 
 template <typename Derived, typename OtherDerived,
           bool MightHaveTransposeAliasing =
-              check_transpose_aliasing_compile_time_selector<blas_traits<Derived>::IsTransposed, OtherDerived>::ret>
+              check_transpose_aliasing_compile_time_selector<blas_traits<Derived>::IsTransposed, OtherDerived>::value>
 struct checkTransposeAliasing_impl {
   EIGEN_DEVICE_FUNC static void run(const Derived& dst, const OtherDerived& other) {
     eigen_assert(
@@ -415,8 +415,9 @@
 
 template <typename Dst, typename Src>
 EIGEN_DEVICE_FUNC inline void check_for_aliasing(const Dst& dst, const Src& src) {
-  if ((!Dst::IsVectorAtCompileTime) && dst.rows() > 1 && dst.cols() > 1)
-    internal::checkTransposeAliasing_impl<Dst, Src>::run(dst, src);
+  EIGEN_IF_CONSTEXPR (!Dst::IsVectorAtCompileTime) {
+    if (dst.rows() > 1 && dst.cols() > 1) internal::checkTransposeAliasing_impl<Dst, Src>::run(dst, src);
+  }
 }
 
 }  // end namespace internal
diff --git a/Eigen/src/Core/Transpositions.h b/Eigen/src/Core/Transpositions.h
index f6dd258..cf8a384 100644
--- a/Eigen/src/Core/Transpositions.h
+++ b/Eigen/src/Core/Transpositions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRANSPOSITIONS_H
 #define EIGEN_TRANSPOSITIONS_H
@@ -17,12 +18,12 @@
 
 template <typename Derived>
 class TranspositionsBase {
-  typedef internal::traits<Derived> Traits;
+  using Traits = internal::traits<Derived>;
 
  public:
-  typedef typename Traits::IndicesType IndicesType;
-  typedef typename IndicesType::Scalar StorageIndex;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using IndicesType = typename Traits::IndicesType;
+  using StorageIndex = typename IndicesType::Scalar;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
   EIGEN_DEVICE_FUNC Derived& derived() { return *static_cast<Derived*>(this); }
   EIGEN_DEVICE_FUNC const Derived& derived() const { return *static_cast<const Derived*>(this); }
@@ -93,16 +94,14 @@
 
   /** \returns the transpose transformation */
   inline Transpose<TranspositionsBase> transpose() const { return Transpose<TranspositionsBase>(derived()); }
-
- protected:
 };
 
 namespace internal {
 template <int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
 struct traits<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_> >
     : traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_> > {
-  typedef Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType;
-  typedef TranspositionsStorage StorageKind;
+  using IndicesType = Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>;
+  using StorageKind = TranspositionsStorage;
 };
 }  // namespace internal
 
@@ -139,12 +138,12 @@
 template <int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_>
 class Transpositions
     : public TranspositionsBase<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_> > {
-  typedef internal::traits<Transpositions> Traits;
+  using Traits = internal::traits<Transpositions>;
 
  public:
-  typedef TranspositionsBase<Transpositions> Base;
-  typedef typename Traits::IndicesType IndicesType;
-  typedef typename IndicesType::Scalar StorageIndex;
+  using Base = TranspositionsBase<Transpositions>;
+  using IndicesType = typename Traits::IndicesType;
+  using StorageIndex = typename IndicesType::Scalar;
 
   inline Transpositions() {}
 
@@ -179,9 +178,9 @@
 template <int SizeAtCompileTime, int MaxSizeAtCompileTime, typename StorageIndex_, int PacketAccess_>
 struct traits<Map<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>, PacketAccess_> >
     : traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_> > {
-  typedef Map<const Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, PacketAccess_> IndicesType;
-  typedef StorageIndex_ StorageIndex;
-  typedef TranspositionsStorage StorageKind;
+  using IndicesType = Map<const Matrix<StorageIndex_, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, PacketAccess_>;
+  using StorageIndex = StorageIndex_;
+  using StorageKind = TranspositionsStorage;
 };
 }  // namespace internal
 
@@ -189,12 +188,12 @@
 class Map<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>, PacketAccess>
     : public TranspositionsBase<
           Map<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_>, PacketAccess> > {
-  typedef internal::traits<Map> Traits;
+  using Traits = internal::traits<Map>;
 
  public:
-  typedef TranspositionsBase<Map> Base;
-  typedef typename Traits::IndicesType IndicesType;
-  typedef typename IndicesType::Scalar StorageIndex;
+  using Base = TranspositionsBase<Map>;
+  using IndicesType = typename Traits::IndicesType;
+  using StorageIndex = typename IndicesType::Scalar;
 
   explicit inline Map(const StorageIndex* indicesPtr) : m_indices(indicesPtr) {}
 
@@ -229,18 +228,18 @@
 namespace internal {
 template <typename IndicesType_>
 struct traits<TranspositionsWrapper<IndicesType_> > : traits<PermutationWrapper<IndicesType_> > {
-  typedef TranspositionsStorage StorageKind;
+  using StorageKind = TranspositionsStorage;
 };
 }  // namespace internal
 
 template <typename IndicesType_>
 class TranspositionsWrapper : public TranspositionsBase<TranspositionsWrapper<IndicesType_> > {
-  typedef internal::traits<TranspositionsWrapper> Traits;
+  using Traits = internal::traits<TranspositionsWrapper>;
 
  public:
-  typedef TranspositionsBase<TranspositionsWrapper> Base;
-  typedef typename Traits::IndicesType IndicesType;
-  typedef typename IndicesType::Scalar StorageIndex;
+  using Base = TranspositionsBase<TranspositionsWrapper>;
+  using IndicesType = typename Traits::IndicesType;
+  using StorageIndex = typename IndicesType::Scalar;
 
   explicit inline TranspositionsWrapper(IndicesType& indices) : m_indices(indices) {}
 
@@ -287,8 +286,8 @@
 
 template <typename TranspositionsDerived>
 class Transpose<TranspositionsBase<TranspositionsDerived> > {
-  typedef TranspositionsDerived TranspositionType;
-  typedef typename TranspositionType::IndicesType IndicesType;
+  using TranspositionType = TranspositionsDerived;
+  using IndicesType = typename TranspositionType::IndicesType;
 
  public:
   explicit Transpose(const TranspositionType& t) : m_transpositions(t) {}
diff --git a/Eigen/src/Core/TriangularInPlace.h b/Eigen/src/Core/TriangularInPlace.h
new file mode 100644
index 0000000..69499ba
--- /dev/null
+++ b/Eigen/src/Core/TriangularInPlace.h
@@ -0,0 +1,228 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TRIANGULARINPLACE_H
+#define EIGEN_TRIANGULARINPLACE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// In-place counterparts of LAPACK xTRTRI and xLAUUM. Each overwrites its operand; the only scratch is
+// one block-sized panel, at most 128x128 elements whatever the matrix size, through which the in-place
+// TRMM steps run Eigen's blocked kernel, the same way optimized BLAS implement xTRMM.
+
+// Only the lower forms exist. An upper U runs the lower kernel on Transpose<MatrixType>: with
+// V = U^T, V^-1 = (U^-1)^T and V^* V = conj(U U^*) = (U U^*)^T since U U^* is self-adjoint, so the
+// lower triangle of the transposed view is the upper triangle of the original in both cases.
+
+// Both kernels have the panel-times-trailing-block shape of the Cholesky factorization, so the block
+// size tracks llt_inplace::blocked(), but each has its own floor and its own size below which the
+// unblocked form still wins: TRTRI's blocked step is a TRMM plus a TRSM against a bs-wide panel, and
+// its unblocked form is already a sequence of TRMVs, while LAUUM's is a TRMM plus a HERK and its
+// unblocked form is a sequence of GEMVs against a strided row. Measured on Zen 4 at n = 32..512.
+constexpr Index kTriangularInverseMinBlocked = 64;
+constexpr Index kTriangularInverseMinBlockSize = 24;
+constexpr Index kAdjointSquareMinBlocked = 128;
+constexpr Index kAdjointSquareMinBlockSize = 48;
+
+EIGEN_DEVICE_FUNC inline Index triangular_in_place_block_size(Index size, Index min_block_size) {
+  const Index block_size = ((size / 8) / 8) * 8;
+  return numext::mini(numext::maxi(block_size, min_block_size), Index(128));
+}
+
+template <typename MatrixType>
+struct triangular_in_place_workspace {
+  using type = Matrix<typename MatrixType::Scalar, Dynamic, Dynamic,
+                      (int(traits<MatrixType>::Flags) & RowMajorBit) ? RowMajor : ColMajor>;
+};
+
+// Unblocked lower triangular inverse, columns bottom-up so that the trailing block already holds
+// X22 = L22^-1 when column j is reached: then X(j+1:, j) = -X22 L(j+1:, j) / L(j, j), one TRMV per
+// column rather than the chain of AXPYs a forward substitution per column would run. \a tmp is
+// scratch of at least n - 1 entries, since the TRMV's destination is its own operand.
+template <unsigned int Mode, typename MatrixType, typename VectorType>
+EIGEN_DEVICE_FUNC void triangular_inverse_unblocked(MatrixType& mat, VectorType& tmp) {
+  using Scalar = typename MatrixType::Scalar;
+  constexpr bool kUnitDiag = (Mode & UnitDiag) != 0;
+  const Index n = mat.rows();
+  eigen_internal_assert(n < 2 || tmp.size() >= n - 1);
+  for (Index j = n - 1; j >= 0; --j) {
+    Scalar xj = Scalar(1);
+    EIGEN_IF_CONSTEXPR (!kUnitDiag) {
+      xj = Scalar(1) / mat.coeff(j, j);
+      mat.coeffRef(j, j) = xj;
+    }
+    const Index rs = n - j - 1;
+    if (rs == 0) continue;
+    tmp.head(rs).noalias() = mat.block(j + 1, j + 1, rs, rs).template triangularView<Mode>() * mat.col(j).tail(rs);
+    mat.col(j).tail(rs) = -xj * tmp.head(rs);
+  }
+}
+
+// Blocked lower triangular inverse, block columns bottom-up as in LAPACK xTRTRI. With
+// L = [[L11, 0], [L21, L22]] the inverse is [[L11^-1, 0], [-L22^-1 L21 L11^-1, L22^-1]]; walking upwards
+// makes X22 = L22^-1 available first, so the large operation is the TRMM X22 L21 rather than a solve
+// against L22, and Eigen's TRMM runs closer to GEMM rate than its TRSM does on a 128-column operand.
+template <unsigned int Mode, typename MatrixType>
+EIGEN_DEVICE_FUNC void triangular_inverse_lower(MatrixType& mat) {
+  eigen_assert(mat.rows() == mat.cols());
+  const Index n = mat.rows();
+  if (n < kTriangularInverseMinBlocked) {
+    using Scalar = typename MatrixType::Scalar;
+    ei_declare_aligned_stack_constructed_variable(Scalar, tmp_data, numext::maxi(n, Index(1)), 0);
+    Map<Matrix<Scalar, Dynamic, 1> > tmp(tmp_data, n);
+    triangular_inverse_unblocked<Mode>(mat, tmp);
+    return;
+  }
+  const Index block_size = triangular_in_place_block_size(n, kTriangularInverseMinBlockSize);
+  // One block-sized panel, whose first column doubles as the TRMV scratch of the unblocked kernel:
+  // that kernel runs on L11 only after the panel's other uses in the same iteration are finished.
+  typename triangular_in_place_workspace<MatrixType>::type work(block_size, block_size);
+  for (Index k = ((n - 1) / block_size) * block_size; k >= 0; k -= block_size) {
+    const Index bs = numext::mini(block_size, n - k);
+    const Index rs = n - k - bs;
+    Block<MatrixType, Dynamic, Dynamic> L11(mat, k, k, bs, bs);
+    if (rs > 0) {
+      Block<MatrixType, Dynamic, Dynamic> L21(mat, k + bs, k, rs, bs);
+      Block<MatrixType, Dynamic, Dynamic> X22(mat, k + bs, k + bs, rs, rs);
+      // L21 <- X22 L21. Row panel r of the product reads only rows <= r of L21, so going upwards
+      // leaves every row a later panel still needs untouched.
+      for (Index r_end = rs; r_end > 0; r_end -= block_size) {
+        const Index r = numext::maxi(Index(0), r_end - block_size);
+        const Index h = r_end - r;
+        work.topLeftCorner(h, bs) = L21.middleRows(r, h);
+        L21.middleRows(r, h).noalias() =
+            X22.block(r, r, h, h).template triangularView<Mode>() * work.topLeftCorner(h, bs);
+        if (r > 0) L21.middleRows(r, h).noalias() += X22.block(r, 0, h, r) * L21.topRows(r);
+      }
+      L11.template triangularView<Mode>().template solveInPlace<OnTheRight>(L21);
+      L21 = -L21;
+    }
+    auto tmp = work.col(0);
+    triangular_inverse_unblocked<Mode>(L11, tmp);
+  }
+}
+
+template <unsigned int Mode, bool IsLower = (int(Mode) & int(Lower)) != 0>
+struct triangular_inverse_selector {
+  template <typename MatrixType>
+  EIGEN_DEVICE_FUNC static void run(MatrixType& mat) {
+    triangular_inverse_lower<Mode>(mat);
+  }
+};
+
+template <unsigned int Mode>
+struct triangular_inverse_selector<Mode, false> {
+  template <typename MatrixType>
+  EIGEN_DEVICE_FUNC static void run(MatrixType& mat) {
+    Transpose<MatrixType> matt(mat);
+    triangular_inverse_lower<(int(Mode) & int(UnitDiag)) | int(Lower)>(matt);
+  }
+};
+
+// Unblocked lower self-adjoint square: mat <- lower(L^* L). Row i of the result reads column i of L
+// below the diagonal and rows > i of the columns left of it, none of which row i's own update writes.
+template <typename MatrixType>
+void triangular_adjoint_square_unblocked(MatrixType& mat) {
+  using Scalar = typename MatrixType::Scalar;
+  const Index n = mat.rows();
+  for (Index i = 0; i < n; ++i) {
+    const Scalar lii = mat.coeff(i, i);
+    const Index rs = n - i - 1;
+    mat.coeffRef(i, i) = Scalar(mat.col(i).tail(n - i).squaredNorm());
+    if (i > 0) {
+      mat.row(i).head(i) *= numext::conj(lii);
+      if (rs > 0) mat.row(i).head(i).noalias() += mat.col(i).tail(rs).adjoint() * mat.bottomLeftCorner(rs, i);
+    }
+  }
+}
+
+// Blocked lower self-adjoint square, left-looking as in LAPACK xLAUUM: block row k of the result is
+// completed against the columns to its left before the trailing block rows consume the factor.
+template <typename MatrixType>
+void triangular_adjoint_square_lower(MatrixType& mat) {
+  eigen_assert(mat.rows() == mat.cols());
+  const Index n = mat.rows();
+  if (n < kAdjointSquareMinBlocked) {
+    triangular_adjoint_square_unblocked(mat);
+    return;
+  }
+  const Index block_size = triangular_in_place_block_size(n, kAdjointSquareMinBlockSize);
+  typename triangular_in_place_workspace<MatrixType>::type work(block_size, block_size);
+  for (Index k = 0; k < n; k += block_size) {
+    const Index bs = numext::mini(block_size, n - k);
+    const Index rs = n - k - bs;
+    Block<MatrixType, Dynamic, Dynamic> L11(mat, k, k, bs, bs);
+    if (k > 0) {
+      // A(k:k+bs, 0:k) = sum over rows m >= k of L(m, k:k+bs)^* L(m, 0:k), split at m = k+bs. The
+      // first part is the TRMM L11^* B in place, done by column panels through the workspace.
+      Block<MatrixType, Dynamic, Dynamic> B(mat, k, 0, bs, k);
+      for (Index c = 0; c < k; c += block_size) {
+        const Index w = numext::mini(block_size, k - c);
+        work.topLeftCorner(bs, w) = B.middleCols(c, w);
+        B.middleCols(c, w).noalias() = L11.adjoint().template triangularView<Upper>() * work.topLeftCorner(bs, w);
+      }
+      if (rs > 0) B.noalias() += mat.block(k + bs, k, rs, bs).adjoint() * mat.block(k + bs, 0, rs, k);
+    }
+    triangular_adjoint_square_unblocked(L11);
+    if (rs > 0) {
+      L11.template selfadjointView<Lower>().rankUpdate(mat.block(k + bs, k, rs, bs).adjoint());
+      // Fused complex products can leave a rounding residual in the imaginary diagonal.
+      EIGEN_IF_CONSTEXPR (NumTraits<typename MatrixType::Scalar>::IsComplex) {
+        L11.diagonal() = L11.diagonal().real().template cast<typename MatrixType::Scalar>();
+      }
+    }
+  }
+}
+
+template <int UpLo, bool IsLower = (int(UpLo) & int(Lower)) != 0>
+struct triangular_adjoint_square_selector {
+  template <typename MatrixType>
+  static void run(MatrixType& mat) {
+    triangular_adjoint_square_lower(mat);
+  }
+};
+
+template <int UpLo>
+struct triangular_adjoint_square_selector<UpLo, false> {
+  template <typename MatrixType>
+  static void run(MatrixType& mat) {
+    Transpose<MatrixType> matt(mat);
+    triangular_adjoint_square_lower(matt);
+  }
+};
+
+/** \internal Replaces the \a UpLo triangle of \a mat, holding a triangular factor T, by the same
+ * triangle of the self-adjoint product T^* T (\c Lower) or T T^* (\c Upper). The opposite triangle is
+ * neither read nor written. This is LAPACK's xLAUUM. */
+template <int UpLo, typename MatrixType>
+void triangular_adjoint_square_in_place(MatrixType& mat) {
+  triangular_adjoint_square_selector<UpLo>::run(mat);
+}
+
+}  // end namespace internal
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename MatrixType, unsigned int Mode>
+EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType, Mode, Dense>::inverseInPlace() {
+  EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
+  EIGEN_STATIC_ASSERT((int(Mode) & int(Upper | Lower)) != 0 && (int(Mode) & int(ZeroDiag)) == 0, PROGRAMMING_ERROR)
+  eigen_assert(derived().rows() == derived().cols());
+  internal::triangular_inverse_selector<Mode>::run(derived().nestedExpression());
+}
+#endif
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TRIANGULARINPLACE_H
diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index e219e51..01bb45f 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRIANGULARMATRIX_H
 #define EIGEN_TRIANGULARMATRIX_H
@@ -21,8 +22,43 @@
 template <int Side, typename TriangularType, typename Rhs>
 struct triangular_solve_retval;
 
+template <typename MatrixType, unsigned int Mode, bool IsSelfAdjoint = (int(Mode) & int(SelfAdjoint)) != 0>
+struct triangular_base_return_types {
+  using MatrixConjugateReturnType = internal::remove_all_t<typename MatrixType::ConjugateReturnType>;
+  enum {
+    TransposeMode = (int(Mode) & int(Upper) ? Lower : 0) | (int(Mode) & int(Lower) ? Upper : 0) |
+                    (int(Mode) & int(UnitDiag)) | (int(Mode) & int(ZeroDiag))
+  };
+  using ConstView = TriangularView<std::add_const_t<MatrixType>, Mode>;
+  using ConjugateReturnType = TriangularView<const MatrixConjugateReturnType, Mode>;
+  using AdjointReturnType = TriangularView<const typename MatrixType::AdjointReturnType, TransposeMode>;
+  using TransposeReturnType = TriangularView<typename MatrixType::TransposeReturnType, TransposeMode>;
+  using ConstTransposeReturnType = TriangularView<const typename MatrixType::ConstTransposeReturnType, TransposeMode>;
+};
+
+template <typename MatrixType, unsigned int Mode>
+struct triangular_base_return_types<MatrixType, Mode, true> {
+  using MatrixConjugateReturnType = internal::remove_all_t<typename MatrixType::ConjugateReturnType>;
+  enum {
+    TriangularPart = int(Mode) & int(Upper | Lower),
+    TransposeMode = (int(Mode) & int(Upper) ? Lower : 0) | (int(Mode) & int(Lower) ? Upper : 0)
+  };
+  using ConstView = SelfAdjointView<std::add_const_t<MatrixType>, TriangularPart>;
+  using ConjugateReturnType = SelfAdjointView<const MatrixConjugateReturnType, TriangularPart>;
+  using AdjointReturnType = SelfAdjointView<const typename MatrixType::AdjointReturnType, TransposeMode>;
+  using TransposeReturnType = SelfAdjointView<typename MatrixType::TransposeReturnType, TransposeMode>;
+  using ConstTransposeReturnType = SelfAdjointView<const typename MatrixType::ConstTransposeReturnType, TransposeMode>;
+};
+
+template <unsigned int Mode, typename Expression>
+EIGEN_DEVICE_FUNC inline typename triangular_base_return_types<Expression, Mode>::ConstView
+make_triangular_base_cwise_view(const Expression& expression) {
+  using ReturnType = typename triangular_base_return_types<Expression, Mode>::ConstView;
+  return ReturnType(expression);
 }
 
+}  // namespace internal
+
 /** \class TriangularBase
  * \ingroup Core_Module
  *
@@ -33,12 +69,14 @@
  public:
   enum {
     Mode = internal::traits<Derived>::Mode,
+    TransposeMode = (int(Mode) & int(Upper) ? Lower : 0) | (int(Mode) & int(Lower) ? Upper : 0) |
+                    (int(Mode) & int(UnitDiag)) | (int(Mode) & int(ZeroDiag)),
     RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
     ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
     MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime,
 
-    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::ret),
+    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::value),
     /**< This is equal to the number of coefficients, i.e. the number of
      * rows times the number of columns, or to \a Dynamic if this is not
      * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
@@ -47,21 +85,29 @@
                                                           internal::traits<Derived>::MaxColsAtCompileTime)
 
   };
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
-  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
-  typedef typename internal::traits<Derived>::FullMatrixType DenseMatrixType;
-  typedef DenseMatrixType DenseType;
-  typedef Derived const& Nested;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
+  using StorageIndex = typename internal::traits<Derived>::StorageIndex;
+  using DenseMatrixType = typename internal::traits<Derived>::FullMatrixType;
+  using ExpressionType = typename internal::traits<Derived>::ExpressionType;
+  using DenseType = DenseMatrixType;
+  using Nested = const Derived&;
+  using ReturnTypes = internal::triangular_base_return_types<ExpressionType, Mode>;
+  using ConstView = typename ReturnTypes::ConstView;
+  using ConjugateReturnType = typename ReturnTypes::ConjugateReturnType;
+  using AdjointReturnType = typename ReturnTypes::AdjointReturnType;
+  using TransposeReturnType = typename ReturnTypes::TransposeReturnType;
+  using ConstTransposeReturnType = typename ReturnTypes::ConstTransposeReturnType;
 
   EIGEN_DEVICE_FUNC inline TriangularBase() {
     eigen_assert(!((int(Mode) & int(UnitDiag)) && (int(Mode) & int(ZeroDiag))));
   }
 
-  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return derived().rows(); }
-  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return derived().cols(); }
-  EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return derived().outerStride(); }
-  EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept { return derived().innerStride(); }
+  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return derived().nestedExpression().rows(); }
+  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return derived().nestedExpression().cols(); }
+  EIGEN_DEVICE_FUNC constexpr Index size() const noexcept { return rows() * cols(); }
+  EIGEN_DEVICE_FUNC constexpr Index outerStride() const noexcept { return derived().nestedExpression().outerStride(); }
+  EIGEN_DEVICE_FUNC constexpr Index innerStride() const noexcept { return derived().nestedExpression().innerStride(); }
 
   // dummy resize function
   EIGEN_DEVICE_FUNC void resize(Index rows, Index cols) {
@@ -70,20 +116,72 @@
     eigen_assert(rows == this->rows() && cols == this->cols());
   }
 
-  EIGEN_DEVICE_FUNC inline Scalar coeff(Index row, Index col) const { return derived().coeff(row, col); }
-  EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) { return derived().coeffRef(row, col); }
+  /** \sa MatrixBase::fill() */
+  EIGEN_DEVICE_FUNC void fill(const Scalar& value) { setConstant(value); }
+
+  /** \sa MatrixBase::setConstant() */
+  EIGEN_DEVICE_FUNC Derived& setConstant(const Scalar& value) {
+    EIGEN_STATIC_ASSERT_LVALUE(Derived);
+    return derived() = DenseMatrixType::Constant(rows(), cols(), value);
+  }
+
+  /** \sa MatrixBase::setZero() */
+  EIGEN_DEVICE_FUNC Derived& setZero() { return setConstant(Scalar(0)); }
+
+  /** \sa MatrixBase::setOnes() */
+  EIGEN_DEVICE_FUNC Derived& setOnes() { return setConstant(Scalar(1)); }
+
+  /** \sa MatrixBase::setRandom() */
+  EIGEN_DEVICE_FUNC Derived& setRandom() {
+    EIGEN_STATIC_ASSERT_LVALUE(Derived);
+    return derived() = DenseMatrixType::Random(rows(), cols());
+  }
+
+  /** \sa MatrixBase::setIdentity() */
+  EIGEN_DEVICE_FUNC Derived& setIdentity() {
+    EIGEN_STATIC_ASSERT_LVALUE(Derived);
+    return derived() = DenseMatrixType::Identity(rows(), cols());
+  }
+
+  /** \returns the coefficient of the \em underlying expression at position (\a row, \a col).
+   *
+   * \warning This is raw storage access: the unit diagonal of \c UnitLower / \c UnitUpper and the
+   * structural zeros of the view are \em not synthesized, so for coordinates outside the part
+   * referenced by \c Mode the stored value is returned as-is. Only evaluation of the view — for
+   * example assigning it to a dense matrix or calling toDenseMatrix() — produces the mathematical
+   * coefficients implied by \c Mode.
+   */
+  EIGEN_DEVICE_FUNC inline Scalar coeff(Index row, Index col) const {
+    check_coordinates_internal(row, col);
+    return derived().nestedExpression().coeff(row, col);
+  }
+  /** \returns a reference to the coefficient of the underlying expression at position (\a row, \a col).
+   *
+   * \warning See the warning of coeff(Index,Index): the unit diagonal and structural zeros of the
+   * view are not represented in storage and cannot be referenced.
+   */
+  EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) {
+    EIGEN_STATIC_ASSERT_LVALUE(Derived);
+    check_coordinates_internal(row, col);
+    return derived().nestedExpression().coeffRef(row, col);
+  }
 
   /** \see MatrixBase::copyCoeff(row,col)
    */
   template <typename Other>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, Other& other) {
-    derived().coeffRef(row, col) = other.coeff(row, col);
+    coeffRef(row, col) = other.coeff(row, col);
   }
 
+  /** Like coeff(Index,Index), but asserts (in debug builds) that (\a row, \a col) lies inside the
+   * part referenced by \c Mode; for \c UnitLower / \c UnitUpper and the strictly triangular modes
+   * that excludes the diagonal, whose implicit values are not stored. */
   EIGEN_DEVICE_FUNC inline Scalar operator()(Index row, Index col) const {
     check_coordinates(row, col);
     return coeff(row, col);
   }
+  /** Like coeffRef(Index,Index), but asserts (in debug builds) that (\a row, \a col) lies inside
+   * the part referenced by \c Mode. */
   EIGEN_DEVICE_FUNC inline Scalar& operator()(Index row, Index col) {
     check_coordinates(row, col);
     return coeffRef(row, col);
@@ -95,8 +193,10 @@
 #endif
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
-  EIGEN_DEVICE_FUNC inline Derived& derived() { return *static_cast<Derived*>(this); }
+  EIGEN_DEVICE_FUNC constexpr inline const Derived& derived() const noexcept {
+    return *static_cast<const Derived*>(this);
+  }
+  EIGEN_DEVICE_FUNC constexpr inline Derived& derived() noexcept { return *static_cast<Derived*>(this); }
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
   template <typename DenseDerived>
@@ -104,6 +204,91 @@
   template <typename DenseDerived>
   EIGEN_DEVICE_FUNC void evalToLazy(MatrixBase<DenseDerived>& other) const;
 
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC const Product<Derived, OtherDerived> operator*(const MatrixBase<OtherDerived>& rhs) const {
+    return Product<Derived, OtherDerived>(derived(), rhs.derived());
+  }
+
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC const Product<Derived, OtherDerived> operator*(const DiagonalBase<OtherDerived>& rhs) const {
+    return Product<Derived, OtherDerived>(derived(), rhs.derived());
+  }
+
+  /** \returns the dense matrix product of \c *this by the triangular or self-adjoint view \a rhs.
+   *
+   * The right factor is evaluated into a dense temporary and the product runs the kernel of \c *this times a
+   * dense matrix. The result is a plain dense expression even when the structure would be preserved, as for
+   * two upper triangular factors.
+   */
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC const Product<Derived, OtherDerived> operator*(const TriangularBase<OtherDerived>& rhs) const {
+    return Product<Derived, OtherDerived>(derived(), rhs.derived());
+  }
+
+  template <typename OtherDerived,
+            std::enable_if_t<int(Mode) == int(OtherDerived::Mode) && (int(Mode) & int(UnitDiag)) == 0, int> = 0>
+  EIGEN_DEVICE_FUNC inline auto operator+(const TriangularBase<OtherDerived>& other) const {
+    return internal::make_triangular_base_cwise_view<Mode>(derived().nestedExpression() +
+                                                           other.derived().nestedExpression());
+  }
+
+  template <typename OtherDerived,
+            std::enable_if_t<int(Mode) == int(OtherDerived::Mode) && (int(Mode) & int(UnitDiag)) == 0, int> = 0>
+  EIGEN_DEVICE_FUNC inline auto operator-(const TriangularBase<OtherDerived>& other) const {
+    return internal::make_triangular_base_cwise_view<Mode>(derived().nestedExpression() -
+                                                           other.derived().nestedExpression());
+  }
+
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC const Product<OtherDerived, Derived> operator*(const MatrixBase<OtherDerived>& lhs,
+                                                                          const Derived& rhs) {
+    return Product<OtherDerived, Derived>(lhs.derived(), rhs);
+  }
+
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC const Product<OtherDerived, Derived> operator*(const DiagonalBase<OtherDerived>& lhs,
+                                                                          const Derived& rhs) {
+    return Product<OtherDerived, Derived>(lhs.derived(), rhs);
+  }
+
+  /** \sa MatrixBase::conjugate() const */
+  EIGEN_DEVICE_FUNC inline const ConjugateReturnType conjugate() const {
+    return ConjugateReturnType(derived().nestedExpression().conjugate());
+  }
+
+  /** \returns an expression of the complex conjugate of \c *this if Cond==true,
+   *           returns \c *this otherwise.
+   */
+  template <bool Cond>
+  EIGEN_DEVICE_FUNC inline std::conditional_t<Cond, ConjugateReturnType, ConstView> conjugateIf() const {
+    using ReturnType = std::conditional_t<Cond, ConjugateReturnType, ConstView>;
+    return ReturnType(derived().nestedExpression().template conjugateIf<Cond>());
+  }
+
+  /** \sa MatrixBase::adjoint() const */
+  EIGEN_DEVICE_FUNC inline const AdjointReturnType adjoint() const {
+    return AdjointReturnType(derived().nestedExpression().adjoint());
+  }
+
+  /** \sa MatrixBase::transpose() */
+  template <class Dummy = int, std::enable_if_t<Eigen::internal::is_lvalue<ExpressionType>::value, Dummy*> = nullptr>
+  EIGEN_DEVICE_FUNC inline TransposeReturnType transpose() {
+    typename ExpressionType::TransposeReturnType tmp(derived().nestedExpression());
+    return TransposeReturnType(tmp);
+  }
+
+  template <class Dummy = int>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only argument.")
+  EIGEN_DEVICE_FUNC inline TransposeReturnType
+      transpose(std::enable_if_t<Eigen::internal::is_lvalue<ExpressionType>::value, Dummy*>) {
+    return transpose<Dummy>();
+  }
+
+  /** \sa MatrixBase::transpose() const */
+  EIGEN_DEVICE_FUNC inline const ConstTransposeReturnType transpose() const {
+    return ConstTransposeReturnType(derived().nestedExpression().transpose());
+  }
+
   EIGEN_DEVICE_FUNC DenseMatrixType toDenseMatrix() const {
     DenseMatrixType res(rows(), cols());
     evalToLazy(res);
@@ -150,11 +335,11 @@
 namespace internal {
 template <typename MatrixType, unsigned int Mode_>
 struct traits<TriangularView<MatrixType, Mode_>> : traits<MatrixType> {
-  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNestedNonRef;
-  typedef remove_all_t<MatrixTypeNested> MatrixTypeNestedCleaned;
-  typedef typename MatrixType::PlainObject FullMatrixType;
-  typedef MatrixType ExpressionType;
+  using MatrixTypeNested = typename ref_selector<MatrixType>::non_const_type;
+  using MatrixTypeNestedNonRef = std::remove_reference_t<MatrixTypeNested>;
+  using MatrixTypeNestedCleaned = remove_all_t<MatrixTypeNested>;
+  using FullMatrixType = typename MatrixType::PlainObject;
+  using ExpressionType = MatrixType;
   enum {
     Mode = Mode_,
     FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
@@ -171,20 +356,17 @@
 class TriangularView
     : public TriangularViewImpl<MatrixType_, Mode_, typename internal::traits<MatrixType_>::StorageKind> {
  public:
-  typedef TriangularViewImpl<MatrixType_, Mode_, typename internal::traits<MatrixType_>::StorageKind> Base;
-  typedef typename internal::traits<TriangularView>::Scalar Scalar;
-  typedef MatrixType_ MatrixType;
+  using Base = TriangularViewImpl<MatrixType_, Mode_, typename internal::traits<MatrixType_>::StorageKind>;
+  using Scalar = typename internal::traits<TriangularView>::Scalar;
+  using MatrixType = MatrixType_;
 
  protected:
-  typedef typename internal::traits<TriangularView>::MatrixTypeNested MatrixTypeNested;
-  typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRef MatrixTypeNestedNonRef;
-
-  typedef internal::remove_all_t<typename MatrixType::ConjugateReturnType> MatrixConjugateReturnType;
-  typedef TriangularView<std::add_const_t<MatrixType>, Mode_> ConstTriangularView;
+  using MatrixTypeNested = typename internal::traits<TriangularView>::MatrixTypeNested;
+  using MatrixTypeNestedNonRef = typename internal::traits<TriangularView>::MatrixTypeNestedNonRef;
 
  public:
-  typedef typename internal::traits<TriangularView>::StorageKind StorageKind;
-  typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned NestedExpression;
+  using StorageKind = typename internal::traits<TriangularView>::StorageKind;
+  using NestedExpression = typename internal::traits<TriangularView>::MatrixTypeNestedCleaned;
 
   enum {
     Mode = Mode_,
@@ -198,66 +380,18 @@
 
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TriangularView)
 
-  /** \copydoc EigenBase::rows() */
-  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return m_matrix.rows(); }
-  /** \copydoc EigenBase::cols() */
-  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return m_matrix.cols(); }
-
   /** \returns a const reference to the nested expression */
-  EIGEN_DEVICE_FUNC const NestedExpression& nestedExpression() const { return m_matrix; }
+  EIGEN_DEVICE_FUNC constexpr const NestedExpression& nestedExpression() const noexcept { return m_matrix; }
 
   /** \returns a reference to the nested expression */
-  EIGEN_DEVICE_FUNC NestedExpression& nestedExpression() { return m_matrix; }
-
-  typedef TriangularView<const MatrixConjugateReturnType, Mode> ConjugateReturnType;
-  /** \sa MatrixBase::conjugate() const */
-  EIGEN_DEVICE_FUNC inline const ConjugateReturnType conjugate() const {
-    return ConjugateReturnType(m_matrix.conjugate());
-  }
-
-  /** \returns an expression of the complex conjugate of \c *this if Cond==true,
-   *           returns \c *this otherwise.
-   */
-  template <bool Cond>
-  EIGEN_DEVICE_FUNC inline std::conditional_t<Cond, ConjugateReturnType, ConstTriangularView> conjugateIf() const {
-    typedef std::conditional_t<Cond, ConjugateReturnType, ConstTriangularView> ReturnType;
-    return ReturnType(m_matrix.template conjugateIf<Cond>());
-  }
-
-  typedef TriangularView<const typename MatrixType::AdjointReturnType, TransposeMode> AdjointReturnType;
-  /** \sa MatrixBase::adjoint() const */
-  EIGEN_DEVICE_FUNC inline const AdjointReturnType adjoint() const { return AdjointReturnType(m_matrix.adjoint()); }
-
-  typedef TriangularView<typename MatrixType::TransposeReturnType, TransposeMode> TransposeReturnType;
-  /** \sa MatrixBase::transpose() */
-  template <class Dummy = int>
-  EIGEN_DEVICE_FUNC inline TransposeReturnType transpose(
-      std::enable_if_t<Eigen::internal::is_lvalue<MatrixType>::value, Dummy*> = nullptr) {
-    typename MatrixType::TransposeReturnType tmp(m_matrix);
-    return TransposeReturnType(tmp);
-  }
-
-  typedef TriangularView<const typename MatrixType::ConstTransposeReturnType, TransposeMode> ConstTransposeReturnType;
-  /** \sa MatrixBase::transpose() const */
-  EIGEN_DEVICE_FUNC inline const ConstTransposeReturnType transpose() const {
-    return ConstTransposeReturnType(m_matrix.transpose());
-  }
+  EIGEN_DEVICE_FUNC constexpr NestedExpression& nestedExpression() noexcept { return m_matrix; }
 
   template <typename Other>
   EIGEN_DEVICE_FUNC inline Solve<TriangularView, Other> solve(const MatrixBase<Other>& other) const {
     return Solve<TriangularView, Other>(*this, other.derived());
   }
 
-// workaround MSVC ICE
-#if EIGEN_COMP_MSVC
-  template <int Side, typename Other>
-  EIGEN_DEVICE_FUNC inline const internal::triangular_solve_retval<Side, TriangularView, Other> solve(
-      const MatrixBase<Other>& other) const {
-    return Base::template solve<Side>(other);
-  }
-#else
   using Base::solve;
-#endif
 
   /** \returns a selfadjoint view of the referenced triangular part which must be either \c #Upper or \c #Lower.
    *
@@ -277,12 +411,13 @@
   /** \returns the determinant of the triangular matrix
    * \sa MatrixBase::determinant() */
   EIGEN_DEVICE_FUNC Scalar determinant() const {
-    if (Mode & UnitDiag)
+    EIGEN_IF_CONSTEXPR (Mode & UnitDiag) {
       return 1;
-    else if (Mode & ZeroDiag)
+    } else EIGEN_IF_CONSTEXPR (Mode & ZeroDiag) {
       return 0;
-    else
+    } else {
       return m_matrix.diagonal().prod();
+    }
   }
 
  protected:
@@ -294,37 +429,31 @@
  * \brief Base class for a triangular part in a \b dense matrix
  *
  * This class is an abstract base class of class TriangularView, and objects of type TriangularViewImpl cannot be
- * instantiated. It extends class TriangularView with additional methods which available for dense expressions only.
+ * instantiated. It extends class TriangularView with additional methods which are available for dense expressions only.
  *
  * \sa class TriangularView, MatrixBase::triangularView()
  */
 template <typename MatrixType_, unsigned int Mode_>
 class TriangularViewImpl<MatrixType_, Mode_, Dense> : public TriangularBase<TriangularView<MatrixType_, Mode_>> {
  public:
-  typedef TriangularView<MatrixType_, Mode_> TriangularViewType;
+  using TriangularViewType = TriangularView<MatrixType_, Mode_>;
 
-  typedef TriangularBase<TriangularViewType> Base;
-  typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
+  using Base = TriangularBase<TriangularViewType>;
+  using Scalar = typename internal::traits<TriangularViewType>::Scalar;
 
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::PlainObject DenseMatrixType;
-  typedef DenseMatrixType PlainObject;
+  using MatrixType = MatrixType_;
+  using DenseMatrixType = typename MatrixType::PlainObject;
+  using PlainObject = DenseMatrixType;
 
  public:
   using Base::derived;
   using Base::evalToLazy;
+  using Base::operator*;
 
-  typedef typename internal::traits<TriangularViewType>::StorageKind StorageKind;
+  using StorageKind = typename internal::traits<TriangularViewType>::StorageKind;
 
   enum { Mode = Mode_, Flags = internal::traits<TriangularViewType>::Flags };
 
-  /** \returns the outer-stride of the underlying dense matrix
-   * \sa DenseCoeffsBase::outerStride() */
-  EIGEN_DEVICE_FUNC inline Index outerStride() const { return derived().nestedExpression().outerStride(); }
-  /** \returns the inner-stride of the underlying dense matrix
-   * \sa DenseCoeffsBase::innerStride() */
-  EIGEN_DEVICE_FUNC inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
-
   /** \sa MatrixBase::operator+=() */
   template <typename Other>
   EIGEN_DEVICE_FUNC TriangularViewType& operator+=(const DenseBase<Other>& other) {
@@ -349,39 +478,11 @@
     return *this = derived().nestedExpression() / other;
   }
 
-  /** \sa MatrixBase::fill() */
-  EIGEN_DEVICE_FUNC void fill(const Scalar& value) { setConstant(value); }
-  /** \sa MatrixBase::setConstant() */
-  EIGEN_DEVICE_FUNC TriangularViewType& setConstant(const Scalar& value) {
-    return *this = MatrixType::Constant(derived().rows(), derived().cols(), value);
-  }
-  /** \sa MatrixBase::setZero() */
-  EIGEN_DEVICE_FUNC TriangularViewType& setZero() { return setConstant(Scalar(0)); }
-  /** \sa MatrixBase::setOnes() */
-  EIGEN_DEVICE_FUNC TriangularViewType& setOnes() { return setConstant(Scalar(1)); }
-
-  /** \sa MatrixBase::coeff()
-   * \warning the coordinates must fit into the referenced triangular part
-   */
-  EIGEN_DEVICE_FUNC inline Scalar coeff(Index row, Index col) const {
-    Base::check_coordinates_internal(row, col);
-    return derived().nestedExpression().coeff(row, col);
-  }
-
-  /** \sa MatrixBase::coeffRef()
-   * \warning the coordinates must fit into the referenced triangular part
-   */
-  EIGEN_DEVICE_FUNC inline Scalar& coeffRef(Index row, Index col) {
-    EIGEN_STATIC_ASSERT_LVALUE(TriangularViewType);
-    Base::check_coordinates_internal(row, col);
-    return derived().nestedExpression().coeffRef(row, col);
-  }
-
   /** Assigns a triangular matrix to a triangular part of a dense matrix */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC TriangularViewType& operator=(const TriangularBase<OtherDerived>& other);
 
-  /** Shortcut for\code *this = other.other.triangularView<(*this)::Mode>() \endcode */
+  /** Shortcut for \code *this = other.triangularView<(*this)::Mode>() \endcode */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC TriangularViewType& operator=(const MatrixBase<OtherDerived>& other);
 
@@ -399,18 +500,19 @@
   EIGEN_DEPRECATED EIGEN_DEVICE_FUNC void lazyAssign(const MatrixBase<OtherDerived>& other);
 #endif
 
-  /** Efficient triangular matrix times vector/matrix product */
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC const Product<TriangularViewType, OtherDerived> operator*(
-      const MatrixBase<OtherDerived>& rhs) const {
-    return Product<TriangularViewType, OtherDerived>(derived(), rhs.derived());
+  // Scaling a unit triangular view would break its implicit unit diagonal, so only non-unit modes participate.
+  template <unsigned int M = Mode, std::enable_if_t<(M & UnitDiag) == 0, int> = 0>
+  EIGEN_DEVICE_FUNC const TriangularView<
+      const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(MatrixType, Scalar, internal::scalar_product_op), Mode>
+  operator*(const Scalar& s) const {
+    return (derived().nestedExpression() * s).template triangularView<Mode>();
   }
 
-  /** Efficient vector/matrix times triangular matrix product */
-  template <typename OtherDerived>
-  friend EIGEN_DEVICE_FUNC const Product<OtherDerived, TriangularViewType> operator*(
-      const MatrixBase<OtherDerived>& lhs, const TriangularViewImpl& rhs) {
-    return Product<OtherDerived, TriangularViewType>(lhs.derived(), rhs.derived());
+  template <unsigned int M = Mode, std::enable_if_t<(M & UnitDiag) == 0, int> = 0>
+  friend EIGEN_DEVICE_FUNC const TriangularView<
+      const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar, MatrixType, internal::scalar_product_op), Mode>
+  operator*(const Scalar& s, const TriangularViewImpl& mat) {
+    return (s * mat.derived().nestedExpression()).template triangularView<Mode>();
   }
 
   /** \returns the product of the inverse of \c *this with \a other, \a *this being triangular.
@@ -423,7 +525,7 @@
    *
    * The matrix \c *this must be triangular and invertible (i.e., all the coefficients of the
    * diagonal must be non zero). It works as a forward (resp. backward) substitution if \c *this
-   * is an upper (resp. lower) triangular matrix.
+   * is a lower (resp. upper) triangular matrix.
    *
    * Example: \include Triangular_solve.cpp
    * Output: \verbinclude Triangular_solve.out
@@ -457,6 +559,20 @@
     return solveInPlace<OnTheLeft>(other);
   }
 
+  /** Replaces the referenced triangular part by its inverse.
+   *
+   * \c *this must be square and invertible; as with solveInPlace(), no check is made and a zero on the
+   * diagonal yields a non-finite result. The opposite triangle is neither read nor written, and with a
+   * \c #UnitDiag mode the diagonal itself is left alone as well.
+   *
+   * This is the operation of the \c *TRTRI LAPACK routines. It costs n^3/3 flops, where solving against an
+   * explicit identity right hand side costs n^3, and its only scratch is one block-sized panel of at most
+   * 128x128 coefficients, independent of the matrix size.
+   *
+   * \sa TriangularView::solveInPlace(), MatrixBase::inverse()
+   */
+  EIGEN_DEVICE_FUNC void inverseInPlace();
+
   /** Swaps the coefficients of the common triangular parts of two matrices */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC
@@ -618,7 +734,9 @@
     }
   RealScalar threshold = maxAbsOnLowerPart * prec;
   for (Index j = 1; j < cols(); ++j) {
-    Index maxi = numext::mini(j, rows() - 1);
+    // Rows [0, min(j, rows())) of column j lie strictly above the diagonal. For a column past the diagonal block of a
+    // wide matrix that is the whole column, so the bound is rows(), not rows() - 1.
+    Index maxi = numext::mini(j, rows());
     for (Index i = 0; i < maxi; ++i)
       if (numext::abs(coeff(i, j)) > threshold) return false;
   }
@@ -639,14 +757,14 @@
 //      it work)
 template <typename MatrixType, unsigned int Mode>
 struct evaluator_traits<TriangularView<MatrixType, Mode>> {
-  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
-  typedef typename glue_shapes<typename evaluator_traits<MatrixType>::Shape, TriangularShape>::type Shape;
+  using Kind = typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind;
+  using Shape = typename glue_shapes<typename evaluator_traits<MatrixType>::Shape, TriangularShape>::type;
 };
 
 template <typename MatrixType, unsigned int Mode>
 struct unary_evaluator<TriangularView<MatrixType, Mode>, IndexBased> : evaluator<internal::remove_all_t<MatrixType>> {
-  typedef TriangularView<MatrixType, Mode> XprType;
-  typedef evaluator<internal::remove_all_t<MatrixType>> Base;
+  using XprType = TriangularView<MatrixType, Mode>;
+  using Base = evaluator<internal::remove_all_t<MatrixType>>;
   EIGEN_DEVICE_FUNC unary_evaluator(const XprType& xpr) : Base(xpr.nestedExpression()) {}
 };
 
@@ -655,7 +773,7 @@
 struct Triangular2Dense {};
 struct Dense2Triangular {};
 
-template <typename Kernel, unsigned int Mode, int UnrollCount, bool ClearOpposite>
+template <typename Kernel, unsigned int Mode, int UnrollCount, bool SetOpposite>
 struct triangular_assignment_loop;
 
 /** \internal Specialization of the dense assignment kernel for triangular matrices.
@@ -668,18 +786,18 @@
 class triangular_dense_assignment_kernel
     : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> {
  protected:
-  typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
-  typedef typename Base::DstXprType DstXprType;
-  typedef typename Base::SrcXprType SrcXprType;
+  using Base = generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>;
+  using DstXprType = typename Base::DstXprType;
+  using SrcXprType = typename Base::SrcXprType;
   using Base::m_dst;
   using Base::m_functor;
   using Base::m_src;
 
  public:
-  typedef typename Base::DstEvaluatorType DstEvaluatorType;
-  typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::AssignmentTraits AssignmentTraits;
+  using DstEvaluatorType = typename Base::DstEvaluatorType;
+  using SrcEvaluatorType = typename Base::SrcEvaluatorType;
+  using Scalar = typename Base::Scalar;
+  using AssignmentTraits = typename Base::AssignmentTraits;
 
   EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType& dst, const SrcEvaluatorType& src,
                                                        const Functor& func, DstXprType& dstExpr)
@@ -695,25 +813,28 @@
 #endif
 
   EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id) {
-    if (Mode == UnitDiag && SetOpposite)
+    EIGEN_IF_CONSTEXPR (Mode == UnitDiag && SetOpposite) {
       m_functor.assignCoeff(m_dst.coeffRef(id, id), Scalar(1));
-    else if (Mode == ZeroDiag && SetOpposite)
+    } else EIGEN_IF_CONSTEXPR (Mode == ZeroDiag && SetOpposite) {
       m_functor.assignCoeff(m_dst.coeffRef(id, id), Scalar(0));
-    else if (Mode == 0)
+    } else EIGEN_IF_CONSTEXPR (Mode == 0) {
       Base::assignCoeff(id, id);
+    }
   }
 
   EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col) {
     eigen_internal_assert(row != col);
-    if (SetOpposite) m_functor.assignCoeff(m_dst.coeffRef(row, col), Scalar(0));
+    EIGEN_IF_CONSTEXPR (SetOpposite) {
+      m_functor.assignCoeff(m_dst.coeffRef(row, col), Scalar(0));
+    }
   }
 };
 
 template <int Mode, bool SetOpposite, typename DstXprType, typename SrcXprType, typename Functor>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src,
                                                                            const Functor& func) {
-  typedef evaluator<DstXprType> DstEvaluatorType;
-  typedef evaluator<SrcXprType> SrcEvaluatorType;
+  using DstEvaluatorType = evaluator<DstXprType>;
+  using SrcEvaluatorType = evaluator<SrcXprType>;
 
   SrcEvaluatorType srcEvaluator(src);
 
@@ -722,9 +843,8 @@
   if ((dst.rows() != dstRows) || (dst.cols() != dstCols)) dst.resize(dstRows, dstCols);
   DstEvaluatorType dstEvaluator(dst);
 
-  typedef triangular_dense_assignment_kernel<Mode&(Lower | Upper), Mode&(UnitDiag | ZeroDiag | SelfAdjoint),
-                                             SetOpposite, DstEvaluatorType, SrcEvaluatorType, Functor>
-      Kernel;
+  using Kernel = triangular_dense_assignment_kernel<Mode&(Lower | Upper), Mode&(UnitDiag | ZeroDiag | SelfAdjoint),
+                                                    SetOpposite, DstEvaluatorType, SrcEvaluatorType, Functor>;
   Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
 
   enum {
@@ -746,17 +866,28 @@
 
 template <>
 struct AssignmentKind<TriangularShape, TriangularShape> {
-  typedef Triangular2Triangular Kind;
+  using Kind = Triangular2Triangular;
 };
 template <>
 struct AssignmentKind<DenseShape, TriangularShape> {
-  typedef Triangular2Dense Kind;
+  using Kind = Triangular2Dense;
 };
 template <>
 struct AssignmentKind<TriangularShape, DenseShape> {
-  typedef Dense2Triangular Kind;
+  using Kind = Dense2Triangular;
 };
 
+template <typename Shape>
+struct is_dense_structured_shape
+    : bool_constant<std::is_same<Shape, TriangularShape>::value || std::is_same<Shape, SelfAdjointShape>::value> {};
+
+template <typename Lhs, typename Rhs>
+struct is_dense_structured_diagonal_product
+    : bool_constant<(is_dense_structured_shape<typename evaluator_traits<Lhs>::Shape>::value &&
+                     std::is_same<typename evaluator_traits<Rhs>::Shape, DiagonalShape>::value) ||
+                    (std::is_same<typename evaluator_traits<Lhs>::Shape, DiagonalShape>::value &&
+                     is_dense_structured_shape<typename evaluator_traits<Rhs>::Shape>::value)> {};
+
 template <typename DstXprType, typename SrcXprType, typename Functor>
 struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Triangular> {
   EIGEN_DEVICE_FUNC static void run(DstXprType& dst, const SrcXprType& src, const Functor& func) {
@@ -783,15 +914,15 @@
 template <typename Kernel, unsigned int Mode, int UnrollCount, bool SetOpposite>
 struct triangular_assignment_loop {
   // FIXME: this is not very clean, perhaps this information should be provided by the kernel?
-  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
-  typedef typename DstEvaluatorType::XprType DstXprType;
+  using DstEvaluatorType = typename Kernel::DstEvaluatorType;
+  using DstXprType = typename DstEvaluatorType::XprType;
 
   enum {
     col = (UnrollCount - 1) / DstXprType::RowsAtCompileTime,
     row = (UnrollCount - 1) % DstXprType::RowsAtCompileTime
   };
 
-  typedef typename Kernel::Scalar Scalar;
+  using Scalar = typename Kernel::Scalar;
 
   EIGEN_DEVICE_FUNC static inline void run(Kernel& kernel) {
     triangular_assignment_loop<Kernel, Mode, UnrollCount - 1, SetOpposite>::run(kernel);
@@ -800,8 +931,9 @@
       kernel.assignDiagonalCoeff(row);
     else if (((Mode & Lower) && row > col) || ((Mode & Upper) && row < col))
       kernel.assignCoeff(row, col);
-    else if (SetOpposite)
+    else EIGEN_IF_CONSTEXPR (SetOpposite) {
       kernel.assignOppositeCoeff(row, col);
+    }
   }
 };
 
@@ -816,9 +948,9 @@
 
 template <typename Kernel, unsigned int Mode, bool SetOpposite>
 struct triangular_assignment_loop<Kernel, Mode, Dynamic, SetOpposite> {
-  typedef typename Kernel::Scalar Scalar;
-  typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
-  typedef typename Kernel::AssignmentTraits AssignmentTraits;
+  using Scalar = typename Kernel::Scalar;
+  using DstEvaluatorType = typename Kernel::DstEvaluatorType;
+  using AssignmentTraits = typename Kernel::AssignmentTraits;
 
   enum {
     IsRowMajor = (int(DstEvaluatorType::Flags) & RowMajorBit) != 0,
@@ -848,9 +980,9 @@
       const Index maxi = numext::mini(outer, innerSize);
       Index i = 0;
 
-      if (ActiveBeforeDiag) {
+      EIGEN_IF_CONSTEXPR (ActiveBeforeDiag) {
         for (; i < maxi; ++i) kernel.assignCoeff(row(outer, i), col(outer, i));
-      } else if (SetOpposite) {
+      } else EIGEN_IF_CONSTEXPR (SetOpposite) {
         for (; i < maxi; ++i) kernel.assignOppositeCoeff(row(outer, i), col(outer, i));
       } else {
         i = maxi;
@@ -858,9 +990,9 @@
 
       if (i < innerSize) kernel.assignDiagonalCoeff(i++);
 
-      if (!ActiveBeforeDiag) {
+      EIGEN_IF_CONSTEXPR (!ActiveBeforeDiag) {
         for (; i < innerSize; ++i) kernel.assignCoeff(row(outer, i), col(outer, i));
-      } else if (SetOpposite) {
+      } else EIGEN_IF_CONSTEXPR (SetOpposite) {
         for (; i < innerSize; ++i) kernel.assignOppositeCoeff(row(outer, i), col(outer, i));
       }
     }
@@ -882,18 +1014,81 @@
 
 namespace internal {
 
+template <bool UseTriangularAssignmentLoop>
+struct triangular_product_assignment_dispatcher {
+  template <typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
+  static void run(DstXprType& dst, const SrcXprType& src, const Functor&, const Scalar& alpha, bool beta) {
+    if (!beta) {
+      Index dstRows = src.rows();
+      Index dstCols = src.cols();
+      if ((dst.rows() != dstRows) || (dst.cols() != dstCols)) dst.resize(dstRows, dstCols);
+    }
+
+    dst._assignProduct(src, alpha, beta);
+  }
+};
+
+// Underlying-storage data pointer for the diagonal operand of a structured x diagonal
+// product, or nullptr for non-diagonal operands. The structured (triangular/selfadjoint)
+// operand can safely share storage with dst because the kernel reads each (row, col) cell
+// before writing it; only diagonal/dst overlap can corrupt later reads via the diagonal
+// entries that have already been written.
+template <typename Op>
+EIGEN_DEVICE_FUNC inline const void* diagonal_operand_data(const Op& op, DiagonalShape) {
+  return extract_data(op.diagonal());
+}
+template <typename Op, typename Shape>
+EIGEN_DEVICE_FUNC inline const void* diagonal_operand_data(const Op& /*op*/, Shape) {
+  return nullptr;
+}
+
+template <typename DstXprType, typename SrcXprType>
+EIGEN_DEVICE_FUNC inline bool structured_diagonal_product_aliases(const DstXprType& dst, const SrcXprType& src) {
+  const void* dst_data = dst.nestedExpression().data();
+  if (dst_data == nullptr) return false;
+  const void* lhs_diag_data =
+      diagonal_operand_data(src.lhs(), typename evaluator_traits<typename SrcXprType::Lhs>::Shape{});
+  const void* rhs_diag_data =
+      diagonal_operand_data(src.rhs(), typename evaluator_traits<typename SrcXprType::Rhs>::Shape{});
+  return (lhs_diag_data != nullptr && lhs_diag_data == dst_data) ||
+         (rhs_diag_data != nullptr && rhs_diag_data == dst_data);
+}
+
+template <>
+struct triangular_product_assignment_dispatcher<true> {
+  template <typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(DstXprType& dst, const SrcXprType& src, const Functor& func,
+                                                        const Scalar& alpha, bool beta) {
+    EIGEN_UNUSED_VARIABLE(alpha);
+    EIGEN_UNUSED_VARIABLE(beta);
+    EIGEN_STATIC_ASSERT((int(DstXprType::Mode) & int(UnitDiag)) == 0,
+                        WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
+    // The triangular assignment loop reads src.coeff(row, col) lazily while writing
+    // dst.coeffRef(row, col). When the diagonal operand of the product shares storage with
+    // dst (e.g.
+    //   A.triangularView<Upper>() = A.diagonal().asDiagonal() * A.triangularView<Upper>())
+    // the diagonal entries already written in earlier columns would feed back as modified
+    // values, corrupting later reads. Materialize the source into a temporary first when
+    // overlap is detected at run time. The structured (triangular/selfadjoint) operand may
+    // safely alias dst because the kernel reads each cell before writing it.
+    if (structured_diagonal_product_aliases(dst, src)) {
+      typename SrcXprType::PlainObject tmp(src);
+      call_triangular_assignment_loop<DstXprType::Mode, false>(dst, tmp, func);
+    } else {
+      call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
+    }
+  }
+};
+
 // Triangular = Product
 template <typename DstXprType, typename Lhs, typename Rhs, typename Scalar>
 struct Assignment<DstXprType, Product<Lhs, Rhs, DefaultProduct>,
                   internal::assign_op<Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>, Dense2Triangular> {
-  typedef Product<Lhs, Rhs, DefaultProduct> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, DefaultProduct>;
   static void run(DstXprType& dst, const SrcXprType& src,
-                  const internal::assign_op<Scalar, typename SrcXprType::Scalar>&) {
-    Index dstRows = src.rows();
-    Index dstCols = src.cols();
-    if ((dst.rows() != dstRows) || (dst.cols() != dstCols)) dst.resize(dstRows, dstCols);
-
-    dst._assignProduct(src, Scalar(1), false);
+                  const internal::assign_op<Scalar, typename SrcXprType::Scalar>& func) {
+    enum { UseTriangularAssignmentLoop = is_dense_structured_diagonal_product<Lhs, Rhs>::value };
+    triangular_product_assignment_dispatcher<UseTriangularAssignmentLoop>::run(dst, src, func, Scalar(1), false);
   }
 };
 
@@ -902,10 +1097,11 @@
 struct Assignment<DstXprType, Product<Lhs, Rhs, DefaultProduct>,
                   internal::add_assign_op<Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>,
                   Dense2Triangular> {
-  typedef Product<Lhs, Rhs, DefaultProduct> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, DefaultProduct>;
   static void run(DstXprType& dst, const SrcXprType& src,
-                  const internal::add_assign_op<Scalar, typename SrcXprType::Scalar>&) {
-    dst._assignProduct(src, Scalar(1), true);
+                  const internal::add_assign_op<Scalar, typename SrcXprType::Scalar>& func) {
+    enum { UseTriangularAssignmentLoop = is_dense_structured_diagonal_product<Lhs, Rhs>::value };
+    triangular_product_assignment_dispatcher<UseTriangularAssignmentLoop>::run(dst, src, func, Scalar(1), true);
   }
 };
 
@@ -914,10 +1110,11 @@
 struct Assignment<DstXprType, Product<Lhs, Rhs, DefaultProduct>,
                   internal::sub_assign_op<Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>,
                   Dense2Triangular> {
-  typedef Product<Lhs, Rhs, DefaultProduct> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, DefaultProduct>;
   static void run(DstXprType& dst, const SrcXprType& src,
-                  const internal::sub_assign_op<Scalar, typename SrcXprType::Scalar>&) {
-    dst._assignProduct(src, Scalar(-1), true);
+                  const internal::sub_assign_op<Scalar, typename SrcXprType::Scalar>& func) {
+    enum { UseTriangularAssignmentLoop = is_dense_structured_diagonal_product<Lhs, Rhs>::value };
+    triangular_product_assignment_dispatcher<UseTriangularAssignmentLoop>::run(dst, src, func, Scalar(-1), true);
   }
 };
 
diff --git a/Eigen/src/Core/VectorBlock.h b/Eigen/src/Core/VectorBlock.h
index 1277e26..5bb0ecc 100644
--- a/Eigen/src/Core/VectorBlock.h
+++ b/Eigen/src/Core/VectorBlock.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_VECTORBLOCK_H
 #define EIGEN_VECTORBLOCK_H
@@ -51,14 +52,13 @@
  * \include class_FixedVectorBlock.cpp
  * Output: \verbinclude class_FixedVectorBlock.out
  *
- * \sa class Block, DenseBase::segment(Index,Index,Index,Index), DenseBase::segment(Index,Index)
+ * \sa class Block, DenseBase::segment(Index,Index)
  */
 template <typename VectorType, int Size>
 class VectorBlock : public Block<VectorType, internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
                                  internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1> {
-  typedef Block<VectorType, internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
-                internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1>
-      Base;
+  using Base = Block<VectorType, internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size,
+                     internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1>;
   enum { IsColVector = !(internal::traits<VectorType>::Flags & RowMajorBit) };
 
  public:
diff --git a/Eigen/src/Core/VectorwiseOp.h b/Eigen/src/Core/VectorwiseOp.h
index 9e34d8c..f68f824 100644
--- a/Eigen/src/Core/VectorwiseOp.h
+++ b/Eigen/src/Core/VectorwiseOp.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARTIAL_REDUX_H
 #define EIGEN_PARTIAL_REDUX_H
@@ -38,11 +39,11 @@
 namespace internal {
 
 template <typename MatrixType, typename MemberOp, int Direction>
-struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction> > : traits<MatrixType> {
-  typedef typename MemberOp::result_type Scalar;
-  typedef typename traits<MatrixType>::StorageKind StorageKind;
-  typedef typename traits<MatrixType>::XprKind XprKind;
-  typedef typename MatrixType::Scalar InputScalar;
+struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction>> : traits<MatrixType> {
+  using Scalar = typename MemberOp::result_type;
+  using StorageKind = typename traits<MatrixType>::StorageKind;
+  using XprKind = typename traits<MatrixType>::XprKind;
+  using InputScalar = typename MatrixType::Scalar;
   enum {
     RowsAtCompileTime = Direction == Vertical ? 1 : MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = Direction == Horizontal ? 1 : MatrixType::ColsAtCompileTime,
@@ -55,10 +56,10 @@
 }  // namespace internal
 
 template <typename MatrixType, typename MemberOp, int Direction>
-class PartialReduxExpr : public internal::dense_xpr_base<PartialReduxExpr<MatrixType, MemberOp, Direction> >::type,
+class PartialReduxExpr : public internal::dense_xpr_base<PartialReduxExpr<MatrixType, MemberOp, Direction>>::type,
                          internal::no_assignment_operator {
  public:
-  typedef typename internal::dense_xpr_base<PartialReduxExpr>::type Base;
+  using Base = typename internal::dense_xpr_base<PartialReduxExpr>::type;
   EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr)
 
   EIGEN_DEVICE_FUNC explicit PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
@@ -85,9 +86,7 @@
     typedef ResultType result_type;                                                         \
     typedef BINARYOP<Scalar, Scalar> BinaryOp;                                              \
     template <int Size>                                                                     \
-    struct Cost {                                                                           \
-      enum { value = COST };                                                                \
-    };                                                                                      \
+    struct Cost : std::integral_constant<int, COST> {};                                     \
     enum { Vectorizable = VECTORIZABLE };                                                   \
     template <typename XprType>                                                             \
     EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType operator()(const XprType& mat) const { \
@@ -101,9 +100,17 @@
 namespace internal {
 
 EIGEN_MEMBER_FUNCTOR(norm, (Size + 5) * NumTraits<Scalar>::MulCost + (Size - 1) * NumTraits<Scalar>::AddCost);
-EIGEN_MEMBER_FUNCTOR(stableNorm, (Size + 5) * NumTraits<Scalar>::MulCost + (Size - 1) * NumTraits<Scalar>::AddCost);
-EIGEN_MEMBER_FUNCTOR(blueNorm, (Size + 5) * NumTraits<Scalar>::MulCost + (Size - 1) * NumTraits<Scalar>::AddCost);
-EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size - 1) * functor_traits<scalar_hypot_op<Scalar> >::Cost);
+// These multi-pass reductions must not inherit the cheaper one-pass norm cost,
+// which could suppress materialization of an enclosing expression.
+EIGEN_MEMBER_FUNCTOR(stableNorm, Size* NumTraits<Scalar>::ReadCost + (2 * Size + 5) * NumTraits<Scalar>::MulCost +
+                                     (2 * Size - 1) * NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(blueNorm, Size* NumTraits<Scalar>::ReadCost + (2 * Size + 8) * NumTraits<Scalar>::MulCost +
+                                   (3 * Size - 1) * NumTraits<Scalar>::AddCost);
+EIGEN_MEMBER_FUNCTOR(
+    hypotNorm,
+    ((NumTraits<Scalar>::IsComplex ? 2 * Size : Size) - 1) *
+        functor_traits<
+            scalar_hypot_op<typename stable_norm_accumulator<typename NumTraits<Scalar>::Real>::type>>::Cost);
 EIGEN_MEMBER_FUNCTOR(all, (Size - 1) * NumTraits<Scalar>::AddCost);
 EIGEN_MEMBER_FUNCTOR(any, (Size - 1) * NumTraits<Scalar>::AddCost);
 EIGEN_MEMBER_FUNCTOR(count, (Size - 1) * NumTraits<Scalar>::AddCost);
@@ -113,15 +120,54 @@
 EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(maxCoeff, (Size - 1) * NumTraits<Scalar>::AddCost, 1, internal::scalar_max_op);
 EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR(prod, (Size - 1) * NumTraits<Scalar>::MulCost, 1, internal::scalar_product_op);
 
+template <typename ResultType, typename Scalar>
+struct member_squaredNorm {
+  using result_type = ResultType;
+  static constexpr bool Vectorizable = false;
+  template <int Size>
+  struct Cost : std::integral_constant<int, Size * functor_traits<scalar_abs2_op<Scalar>>::Cost +
+                                                (Size - 1) * NumTraits<ResultType>::AddCost> {};
+  template <typename XprType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType operator()(const XprType& mat) const {
+    return mat.matrix().squaredNorm();
+  }
+};
+
+template <typename ExpressionType, int Direction,
+          bool ComplexInnerReduction =
+              NumTraits<typename ExpressionType::Scalar>::IsComplex &&
+              complex_array_access<typename ExpressionType::Scalar>::value &&
+              (Direction == (ExpressionType::IsRowMajor ? Horizontal : Vertical)) &&
+              ((int(evaluator<ExpressionType>::Flags) & (DirectAccessBit | PacketAccessBit)) != 0)>
+struct partial_squared_norm {
+  using Scalar = typename ExpressionType::Scalar;
+  using RealScalar = typename ExpressionType::RealScalar;
+  using Type = PartialReduxExpr<const CwiseUnaryOp<scalar_abs2_op<Scalar>, const ExpressionType>,
+                                member_sum<RealScalar, RealScalar>, Direction>;
+  EIGEN_DEVICE_FUNC static Type run(const ExpressionType& matrix) { return Type(matrix.cwiseAbs2()); }
+};
+
+// Keep scalars without array-oriented access and scalar-only expressions on abs2(): realView()
+// copies/evaluates their coefficients twice. Packet expressions still evaluate scalar tails
+// and reductions shorter than one packet twice.
+template <typename ExpressionType, int Direction>
+struct partial_squared_norm<ExpressionType, Direction, true> {
+  using Type =
+      PartialReduxExpr<const ExpressionType,
+                       member_squaredNorm<typename ExpressionType::RealScalar, typename ExpressionType::Scalar>,
+                       Direction>;
+  EIGEN_DEVICE_FUNC static Type run(const ExpressionType& matrix) { return Type(matrix); }
+};
+
 template <int p, typename ResultType, typename Scalar>
 struct member_lpnorm {
-  typedef ResultType result_type;
+  using result_type = ResultType;
   enum { Vectorizable = 0 };
   template <int Size>
-  struct Cost {
-    enum { value = (Size + 5) * NumTraits<Scalar>::MulCost + (Size - 1) * NumTraits<Scalar>::AddCost };
+  struct Cost
+      : std::integral_constant<int, (Size + 5) * NumTraits<Scalar>::MulCost + (Size - 1) * NumTraits<Scalar>::AddCost> {
   };
-  EIGEN_DEVICE_FUNC member_lpnorm() {}
+  EIGEN_DEVICE_FUNC member_lpnorm() = default;
   template <typename XprType>
   EIGEN_DEVICE_FUNC inline ResultType operator()(const XprType& mat) const {
     return mat.template lpNorm<p>();
@@ -130,14 +176,12 @@
 
 template <typename BinaryOpT, typename Scalar>
 struct member_redux {
-  typedef BinaryOpT BinaryOp;
-  typedef typename result_of<BinaryOp(const Scalar&, const Scalar&)>::type result_type;
+  using BinaryOp = BinaryOpT;
+  using result_type = typename result_of<BinaryOp(const Scalar&, const Scalar&)>::type;
 
   enum { Vectorizable = functor_traits<BinaryOp>::PacketAccess };
   template <int Size>
-  struct Cost {
-    enum { value = (Size - 1) * functor_traits<BinaryOp>::Cost };
-  };
+  struct Cost : std::integral_constant<int, (Size - 1) * functor_traits<BinaryOp>::Cost> {};
   EIGEN_DEVICE_FUNC explicit member_redux(const BinaryOp func) : m_functor(func) {}
   template <typename Derived>
   EIGEN_DEVICE_FUNC inline result_type operator()(const DenseBase<Derived>& mat) const {
@@ -188,8 +232,8 @@
  * return STL-compatible begin/end iterators to the rows or columns of the nested expression.
  * Typical use cases include for-range-loop and calls to STL algorithms:
  *
- * Example: \include MatrixBase_colwise_iterator_cxx11.cpp
- * Output: \verbinclude MatrixBase_colwise_iterator_cxx11.out
+ * Example: \include MatrixBase_colwise_iterator.cpp
+ * Output: \verbinclude MatrixBase_colwise_iterator.out
  *
  * For a partial reduction on an empty input, some rules apply.
  * For the sake of clarity, let's consider a vertical reduction:
@@ -204,20 +248,20 @@
 template <typename ExpressionType, int Direction>
 class VectorwiseOp {
  public:
-  typedef typename ExpressionType::Scalar Scalar;
-  typedef typename ExpressionType::RealScalar RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
-  typedef typename internal::ref_selector<ExpressionType>::non_const_type ExpressionTypeNested;
-  typedef internal::remove_all_t<ExpressionTypeNested> ExpressionTypeNestedCleaned;
+  using Scalar = typename ExpressionType::Scalar;
+  using RealScalar = typename ExpressionType::RealScalar;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
+  using ExpressionTypeNested = typename internal::ref_selector<ExpressionType>::non_const_type;
+  using ExpressionTypeNestedCleaned = internal::remove_all_t<ExpressionTypeNested>;
 
   template <template <typename OutScalar, typename InputScalar> class Functor, typename ReturnScalar = Scalar>
   struct ReturnType {
-    typedef PartialReduxExpr<ExpressionType, Functor<ReturnScalar, Scalar>, Direction> Type;
+    using Type = PartialReduxExpr<ExpressionType, Functor<ReturnScalar, Scalar>, Direction>;
   };
 
   template <typename BinaryOp>
   struct ReduxReturnType {
-    typedef PartialReduxExpr<ExpressionType, internal::member_redux<BinaryOp, Scalar>, Direction> Type;
+    using Type = PartialReduxExpr<ExpressionType, internal::member_redux<BinaryOp, Scalar>, Direction>;
   };
 
   enum { isVertical = (Direction == Vertical) ? 1 : 0, isHorizontal = (Direction == Horizontal) ? 1 : 0 };
@@ -225,9 +269,8 @@
  protected:
   template <typename OtherDerived>
   struct ExtendedType {
-    typedef Replicate<OtherDerived, isVertical ? 1 : ExpressionType::RowsAtCompileTime,
-                      isHorizontal ? 1 : ExpressionType::ColsAtCompileTime>
-        Type;
+    using Type = Replicate<OtherDerived, isVertical ? 1 : ExpressionType::RowsAtCompileTime,
+                           isHorizontal ? 1 : ExpressionType::ColsAtCompileTime>;
   };
 
   /** \internal
@@ -244,9 +287,8 @@
 
   template <typename OtherDerived>
   struct OppositeExtendedType {
-    typedef Replicate<OtherDerived, isHorizontal ? 1 : ExpressionType::RowsAtCompileTime,
-                      isVertical ? 1 : ExpressionType::ColsAtCompileTime>
-        Type;
+    using Type = Replicate<OtherDerived, isHorizontal ? 1 : ExpressionType::RowsAtCompileTime,
+                           isVertical ? 1 : ExpressionType::ColsAtCompileTime>;
   };
 
   /** \internal
@@ -276,11 +318,11 @@
   /** This is the const version of iterator (aka read-only) */
   random_access_iterator_type const_iterator;
 #else
-  typedef internal::subvector_stl_iterator<ExpressionType, DirectionType(Direction)> iterator;
-  typedef internal::subvector_stl_iterator<const ExpressionType, DirectionType(Direction)> const_iterator;
-  typedef internal::subvector_stl_reverse_iterator<ExpressionType, DirectionType(Direction)> reverse_iterator;
-  typedef internal::subvector_stl_reverse_iterator<const ExpressionType, DirectionType(Direction)>
-      const_reverse_iterator;
+  using iterator = internal::subvector_stl_iterator<ExpressionType, DirectionType(Direction)>;
+  using const_iterator = internal::subvector_stl_iterator<const ExpressionType, DirectionType(Direction)>;
+  using reverse_iterator = internal::subvector_stl_reverse_iterator<ExpressionType, DirectionType(Direction)>;
+  using const_reverse_iterator =
+      internal::subvector_stl_reverse_iterator<const ExpressionType, DirectionType(Direction)>;
 #endif
 
   /** returns an iterator to the first row (rowwise) or column (colwise) of the nested expression.
@@ -345,27 +387,25 @@
     return typename ReduxReturnType<BinaryOp>::Type(_expression(), internal::member_redux<BinaryOp, Scalar>(func));
   }
 
-  typedef typename ReturnType<internal::member_minCoeff>::Type MinCoeffReturnType;
-  typedef typename ReturnType<internal::member_maxCoeff>::Type MaxCoeffReturnType;
-  typedef PartialReduxExpr<const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const ExpressionTypeNestedCleaned>,
-                           internal::member_sum<RealScalar, RealScalar>, Direction>
-      SquaredNormReturnType;
-  typedef CwiseUnaryOp<internal::scalar_sqrt_op<RealScalar>, const SquaredNormReturnType> NormReturnType;
-  typedef typename ReturnType<internal::member_blueNorm, RealScalar>::Type BlueNormReturnType;
-  typedef typename ReturnType<internal::member_stableNorm, RealScalar>::Type StableNormReturnType;
-  typedef typename ReturnType<internal::member_hypotNorm, RealScalar>::Type HypotNormReturnType;
-  typedef typename ReturnType<internal::member_sum>::Type SumReturnType;
-  typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(SumReturnType, Scalar, quotient) MeanReturnType;
-  typedef typename ReturnType<internal::member_all, bool>::Type AllReturnType;
-  typedef typename ReturnType<internal::member_any, bool>::Type AnyReturnType;
-  typedef PartialReduxExpr<ExpressionType, internal::member_count<Index, Scalar>, Direction> CountReturnType;
-  typedef typename ReturnType<internal::member_prod>::Type ProdReturnType;
-  typedef Reverse<const ExpressionType, Direction> ConstReverseReturnType;
-  typedef Reverse<ExpressionType, Direction> ReverseReturnType;
+  using MinCoeffReturnType = typename ReturnType<Eigen::internal::member_minCoeff>::Type;
+  using MaxCoeffReturnType = typename ReturnType<Eigen::internal::member_maxCoeff>::Type;
+  using SquaredNormReturnType = typename internal::partial_squared_norm<ExpressionTypeNestedCleaned, Direction>::Type;
+  using NormReturnType = CwiseUnaryOp<internal::scalar_sqrt_op<RealScalar>, const SquaredNormReturnType>;
+  using BlueNormReturnType = typename ReturnType<Eigen::internal::member_blueNorm, RealScalar>::Type;
+  using StableNormReturnType = typename ReturnType<Eigen::internal::member_stableNorm, RealScalar>::Type;
+  using HypotNormReturnType = typename ReturnType<Eigen::internal::member_hypotNorm, RealScalar>::Type;
+  using SumReturnType = typename ReturnType<Eigen::internal::member_sum>::Type;
+  using MeanReturnType = EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(SumReturnType, Scalar, internal::scalar_quotient_op);
+  using AllReturnType = typename ReturnType<Eigen::internal::member_all, bool>::Type;
+  using AnyReturnType = typename ReturnType<Eigen::internal::member_any, bool>::Type;
+  using CountReturnType = PartialReduxExpr<ExpressionType, internal::member_count<Index, Scalar>, Direction>;
+  using ProdReturnType = typename ReturnType<Eigen::internal::member_prod>::Type;
+  using ConstReverseReturnType = Reverse<const ExpressionType, Direction>;
+  using ReverseReturnType = Reverse<ExpressionType, Direction>;
 
   template <int p>
   struct LpNormReturnType {
-    typedef PartialReduxExpr<ExpressionType, internal::member_lpnorm<p, RealScalar, Scalar>, Direction> Type;
+    using Type = PartialReduxExpr<ExpressionType, internal::member_lpnorm<p, RealScalar, Scalar>, Direction>;
   };
 
   /** \returns a row (or column) vector expression of the smallest coefficient
@@ -411,7 +451,7 @@
    *
    * \sa DenseBase::squaredNorm() */
   EIGEN_DEVICE_FUNC const SquaredNormReturnType squaredNorm() const {
-    return SquaredNormReturnType(m_matrix.cwiseAbs2());
+    return internal::partial_squared_norm<ExpressionTypeNestedCleaned, Direction>::run(m_matrix);
   }
 
   /** \returns a row (or column) vector expression of the norm
@@ -527,7 +567,7 @@
    * \sa reverse() const */
   EIGEN_DEVICE_FUNC ReverseReturnType reverse() { return ReverseReturnType(_expression()); }
 
-  typedef Replicate<ExpressionType, (isVertical ? Dynamic : 1), (isHorizontal ? Dynamic : 1)> ReplicateReturnType;
+  using ReplicateReturnType = Replicate<ExpressionType, (isVertical ? Dynamic : 1), (isHorizontal ? Dynamic : 1)>;
   EIGEN_DEVICE_FUNC const ReplicateReturnType replicate(Index factor) const;
 
   /**
@@ -548,7 +588,12 @@
         _expression(), isVertical ? factor : 1, isHorizontal ? factor : 1);
   }
 
-  /////////// Artithmetic operators ///////////
+  /////////// Arithmetic operators ///////////
+
+  // The broadcast (compound-)assignments below bind the rhs through
+  // `nested_eval<.., Dynamic>` so expressions like `colwise().sum()` are
+  // materialized once; otherwise an aliased reduction would be recomputed
+  // against partially-updated coefficients (issue #1731).
 
   /** Copies the vector \a other to each subvector of \c *this */
   template <typename OtherDerived>
@@ -556,7 +601,8 @@
     EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
     EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
     // eigen_assert((m_matrix.isNull()) == (other.isNull())); FIXME
-    return m_matrix = extendedTo(other.derived());
+    typename internal::nested_eval<OtherDerived, Dynamic>::type other_eval(other.derived());
+    return m_matrix = extendedTo(other_eval);
   }
 
   /** Adds the vector \a other to each subvector of \c *this */
@@ -564,7 +610,8 @@
   EIGEN_DEVICE_FUNC ExpressionType& operator+=(const DenseBase<OtherDerived>& other) {
     EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
     EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
-    return m_matrix += extendedTo(other.derived());
+    typename internal::nested_eval<OtherDerived, Dynamic>::type other_eval(other.derived());
+    return m_matrix += extendedTo(other_eval);
   }
 
   /** Subtracts the vector \a other to each subvector of \c *this */
@@ -572,7 +619,8 @@
   EIGEN_DEVICE_FUNC ExpressionType& operator-=(const DenseBase<OtherDerived>& other) {
     EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
     EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
-    return m_matrix -= extendedTo(other.derived());
+    typename internal::nested_eval<OtherDerived, Dynamic>::type other_eval(other.derived());
+    return m_matrix -= extendedTo(other_eval);
   }
 
   /** Multiplies each subvector of \c *this by the vector \a other */
@@ -581,7 +629,8 @@
     EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
     EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
     EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
-    m_matrix *= extendedTo(other.derived());
+    typename internal::nested_eval<OtherDerived, Dynamic>::type other_eval(other.derived());
+    m_matrix *= extendedTo(other_eval);
     return m_matrix;
   }
 
@@ -591,7 +640,8 @@
     EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
     EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
     EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
-    m_matrix /= extendedTo(other.derived());
+    typename internal::nested_eval<OtherDerived, Dynamic>::type other_eval(other.derived());
+    m_matrix /= extendedTo(other_eval);
     return m_matrix;
   }
 
@@ -606,6 +656,19 @@
     return m_matrix + extendedTo(other.derived());
   }
 
+  /** Returns the expression of the sum of the vector \a other to each subvector of \a xpr */
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      CwiseBinaryOp<internal::scalar_sum_op<typename OtherDerived::Scalar, Scalar>,
+                    const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>
+      operator+(const DenseBase<OtherDerived>& other, const VectorwiseOp& xpr) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+    EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+    return CwiseBinaryOp<internal::scalar_sum_op<typename OtherDerived::Scalar, Scalar>,
+                         const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>(
+        xpr.extendedTo(other.derived()), xpr._expression());
+  }
+
   /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC CwiseBinaryOp<internal::scalar_difference_op<Scalar, typename OtherDerived::Scalar>,
@@ -616,6 +679,19 @@
     return m_matrix - extendedTo(other.derived());
   }
 
+  /** Returns the expression of the difference between the vector \a other and each subvector of \a xpr */
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      CwiseBinaryOp<internal::scalar_difference_op<typename OtherDerived::Scalar, Scalar>,
+                    const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>
+      operator-(const DenseBase<OtherDerived>& other, const VectorwiseOp& xpr) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+    EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+    return CwiseBinaryOp<internal::scalar_difference_op<typename OtherDerived::Scalar, Scalar>,
+                         const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>(
+        xpr.extendedTo(other.derived()), xpr._expression());
+  }
+
   /** Returns the expression where each subvector is the product of the vector \a other
    * by the corresponding subvector of \c *this */
   template <typename OtherDerived>
@@ -628,6 +704,20 @@
     return m_matrix * extendedTo(other.derived());
   }
 
+  /** Returns the expression of the product of the vector \a other with each subvector of \a xpr */
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      CwiseBinaryOp<internal::scalar_product_op<typename OtherDerived::Scalar, Scalar>,
+                    const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>
+      operator*(const DenseBase<OtherDerived>& other, const VectorwiseOp& xpr) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+    EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+    EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+    return CwiseBinaryOp<internal::scalar_product_op<typename OtherDerived::Scalar, Scalar>,
+                         const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>(
+        xpr.extendedTo(other.derived()), xpr._expression());
+  }
+
   /** Returns the expression where each subvector is the quotient of the corresponding
    * subvector of \c *this by the vector \a other */
   template <typename OtherDerived>
@@ -640,6 +730,72 @@
     return m_matrix / extendedTo(other.derived());
   }
 
+  /** Returns the coefficient-wise quotient of vector \a other by each subvector of \a xpr. */
+  template <typename OtherDerived>
+  friend EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      CwiseBinaryOp<internal::scalar_quotient_op<typename OtherDerived::Scalar, Scalar>,
+                    const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>
+      operator/(const DenseBase<OtherDerived>& other, const VectorwiseOp& xpr) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+    EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
+    EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+    return CwiseBinaryOp<internal::scalar_quotient_op<typename OtherDerived::Scalar, Scalar>,
+                         const typename ExtendedType<OtherDerived>::Type, const ExpressionTypeNestedCleaned>(
+        xpr.extendedTo(other.derived()), xpr._expression());
+  }
+
+  /** \returns an expression of a custom coefficient-wise operator of each subvector of \c *this and \a other */
+  template <typename CustomBinaryOp, typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const
+      CwiseBinaryOp<CustomBinaryOp, const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type>
+      binaryExpr(const DenseBase<OtherDerived>& other, const CustomBinaryOp& func = CustomBinaryOp()) const {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+    EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
+    return CwiseBinaryOp<CustomBinaryOp, const ExpressionTypeNestedCleaned,
+                         const typename ExtendedType<OtherDerived>::Type>(_expression(), extendedTo(other.derived()),
+                                                                          func);
+  }
+
+  /** \returns an expression of the coefficient-wise min of each subvector of \c *this and \a other */
+  template <int NaNPropagation = PropagateFast, typename OtherDerived>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const
+      CwiseBinaryOp<internal::scalar_min_op<Scalar, typename OtherDerived::Scalar, NaNPropagation>,
+                    const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type>
+      cwiseMin(const DenseBase<OtherDerived>& other) const {
+    return binaryExpr(other, internal::scalar_min_op<Scalar, typename OtherDerived::Scalar, NaNPropagation>());
+  }
+
+  /** \returns an expression of the coefficient-wise min of each subvector of \c *this and scalar \a other */
+  template <int NaNPropagation = PropagateFast>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const
+      CwiseBinaryOp<internal::scalar_min_op<Scalar, Scalar, NaNPropagation>, const ExpressionTypeNestedCleaned,
+                    const typename ExpressionTypeNestedCleaned::ConstantReturnType>
+      cwiseMin(const Scalar& other) const {
+    return CwiseBinaryOp<internal::scalar_min_op<Scalar, Scalar, NaNPropagation>, const ExpressionTypeNestedCleaned,
+                         const typename ExpressionTypeNestedCleaned::ConstantReturnType>(
+        _expression(), ExpressionTypeNestedCleaned::Constant(m_matrix.rows(), m_matrix.cols(), other));
+  }
+
+  /** \returns an expression of the coefficient-wise max of each subvector of \c *this and \a other */
+  template <int NaNPropagation = PropagateFast, typename OtherDerived>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const
+      CwiseBinaryOp<internal::scalar_max_op<Scalar, typename OtherDerived::Scalar, NaNPropagation>,
+                    const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type>
+      cwiseMax(const DenseBase<OtherDerived>& other) const {
+    return binaryExpr(other, internal::scalar_max_op<Scalar, typename OtherDerived::Scalar, NaNPropagation>());
+  }
+
+  /** \returns an expression of the coefficient-wise max of each subvector of \c *this and scalar \a other */
+  template <int NaNPropagation = PropagateFast>
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const
+      CwiseBinaryOp<internal::scalar_max_op<Scalar, Scalar, NaNPropagation>, const ExpressionTypeNestedCleaned,
+                    const typename ExpressionTypeNestedCleaned::ConstantReturnType>
+      cwiseMax(const Scalar& other) const {
+    return CwiseBinaryOp<internal::scalar_max_op<Scalar, Scalar, NaNPropagation>, const ExpressionTypeNestedCleaned,
+                         const typename ExpressionTypeNestedCleaned::ConstantReturnType>(
+        _expression(), ExpressionTypeNestedCleaned::Constant(m_matrix.rows(), m_matrix.cols(), other));
+  }
+
   using Normalized_NonzeroNormType =
       CwiseUnaryOp<internal::scalar_replace_zero_with_one_op<Scalar>, const NormReturnType>;
   using NormalizedReturnType = CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const ExpressionTypeNestedCleaned,
@@ -669,10 +825,10 @@
 
   /////////// Geometry module ///////////
 
-  typedef Homogeneous<ExpressionType, Direction> HomogeneousReturnType;
+  using HomogeneousReturnType = Homogeneous<ExpressionType, Direction>;
   EIGEN_DEVICE_FUNC HomogeneousReturnType homogeneous() const;
 
-  typedef typename ExpressionType::PlainObject CrossReturnType;
+  using CrossReturnType = typename ExpressionType::PlainObject;
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const;
 
@@ -681,21 +837,19 @@
                                              : internal::traits<ExpressionType>::ColsAtCompileTime,
     HNormalized_SizeMinusOne = HNormalized_Size == Dynamic ? Dynamic : HNormalized_Size - 1
   };
-  typedef Block<const ExpressionType,
-                Direction == Vertical ? int(HNormalized_SizeMinusOne)
-                                      : int(internal::traits<ExpressionType>::RowsAtCompileTime),
-                Direction == Horizontal ? int(HNormalized_SizeMinusOne)
-                                        : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
-      HNormalized_Block;
-  typedef Block<const ExpressionType,
-                Direction == Vertical ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
-                Direction == Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>
-      HNormalized_Factors;
-  typedef CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>,
-                        const HNormalized_Block,
-                        const Replicate<HNormalized_Factors, Direction == Vertical ? HNormalized_SizeMinusOne : 1,
-                                        Direction == Horizontal ? HNormalized_SizeMinusOne : 1> >
-      HNormalizedReturnType;
+  using HNormalized_Block = Block<const ExpressionType,
+                                  Direction == Vertical ? int(HNormalized_SizeMinusOne)
+                                                        : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+                                  Direction == Horizontal ? int(HNormalized_SizeMinusOne)
+                                                          : int(internal::traits<ExpressionType>::ColsAtCompileTime)>;
+  using HNormalized_Factors =
+      Block<const ExpressionType, Direction == Vertical ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime),
+            Direction == Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)>;
+  using HNormalizedReturnType =
+      CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>,
+                    const HNormalized_Block,
+                    const Replicate<HNormalized_Factors, Direction == Vertical ? HNormalized_SizeMinusOne : 1,
+                                    Direction == Horizontal ? HNormalized_SizeMinusOne : 1>>;
 
   EIGEN_DEVICE_FUNC const HNormalizedReturnType hnormalized() const;
 
diff --git a/Eigen/src/Core/Visitor.h b/Eigen/src/Core/Visitor.h
index fa6293f..0c23d98 100644
--- a/Eigen/src/Core/Visitor.h
+++ b/Eigen/src/Core/Visitor.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_VISITOR_H
 #define EIGEN_VISITOR_H
@@ -43,48 +44,62 @@
   static constexpr int RowsAtCompileTime = Derived::RowsAtCompileTime;
   static constexpr int ColsAtCompileTime = Derived::ColsAtCompileTime;
   static constexpr int PacketSize = packet_traits<Scalar>::size;
+  static constexpr int InnerSizeAtCompileTime = RowMajor ? ColsAtCompileTime : RowsAtCompileTime;
+  static constexpr int OuterSizeAtCompileTime = RowMajor ? RowsAtCompileTime : ColsAtCompileTime;
+  static constexpr int PacketOpsPerOuter =
+      Vectorize && InnerSizeAtCompileTime >= PacketSize ? InnerSizeAtCompileTime / PacketSize : 0;
+  static constexpr int FirstScalarInner = PacketOpsPerOuter * PacketSize;
+  static constexpr int ScalarOpsPerOuter = InnerSizeAtCompileTime - FirstScalarInner;
+  static constexpr int OpsPerOuter = PacketOpsPerOuter + ScalarOpsPerOuter;
+  static constexpr int OpCount = UnrollCount == 0 ? 0 : OuterSizeAtCompileTime * OpsPerOuter;
 
-  static constexpr bool CanVectorize(int K) {
-    constexpr int InnerSizeAtCompileTime = RowMajor ? ColsAtCompileTime : RowsAtCompileTime;
-    if (InnerSizeAtCompileTime < PacketSize) return false;
-    return Vectorize && (InnerSizeAtCompileTime - (K % InnerSizeAtCompileTime) >= PacketSize);
+  template <int Op>
+  static constexpr bool IsPacketOp() {
+    return OpsPerOuter != 0 && (Op % OpsPerOuter) < PacketOpsPerOuter;
   }
 
-  template <int K = 0, bool Empty = (K == UnrollCount), std::enable_if_t<Empty, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived&, Visitor&) {}
-
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && Initialize && !DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    visitor.init(mat.coeff(0, 0), 0, 0);
-    run<1>(mat, visitor);
+  template <int Op>
+  static constexpr int CoeffIndex() {
+    return OpsPerOuter == 0 ? 0
+                            : (Op / OpsPerOuter) * InnerSizeAtCompileTime +
+                                  (IsPacketOp<Op>() ? ((Op % OpsPerOuter) * PacketSize)
+                                                    : (FirstScalarInner + (Op % OpsPerOuter) - PacketOpsPerOuter));
   }
 
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && !Initialize && !DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    static constexpr int R = RowMajor ? (K / ColsAtCompileTime) : (K % RowsAtCompileTime);
-    static constexpr int C = RowMajor ? (K % ColsAtCompileTime) : (K / RowsAtCompileTime);
-    visitor(mat.coeff(R, C), R, C);
-    run<K + 1>(mat, visitor);
+  template <int Op, std::enable_if_t<!IsPacketOp<Op>(), bool> = true>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void visit(const Derived& mat, Visitor& visitor) {
+    constexpr int K = CoeffIndex<Op>();
+    constexpr int R = RowMajor ? (K / ColsAtCompileTime) : (K % RowsAtCompileTime);
+    constexpr int C = RowMajor ? (K % ColsAtCompileTime) : (K / RowsAtCompileTime);
+    EIGEN_IF_CONSTEXPR (Op == 0) {
+      visitor.init(mat.coeff(R, C), R, C);
+    } else {
+      visitor(mat.coeff(R, C), R, C);
+    }
   }
 
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && Initialize && DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    Packet P = mat.template packet<Packet>(0, 0);
-    visitor.initpacket(P, 0, 0);
-    run<PacketSize>(mat, visitor);
-  }
-
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && !Initialize && DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    static constexpr int R = RowMajor ? (K / ColsAtCompileTime) : (K % RowsAtCompileTime);
-    static constexpr int C = RowMajor ? (K % ColsAtCompileTime) : (K / RowsAtCompileTime);
+  template <int Op, std::enable_if_t<IsPacketOp<Op>(), bool> = true>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void visit(const Derived& mat, Visitor& visitor) {
+    constexpr int K = CoeffIndex<Op>();
+    constexpr int R = RowMajor ? (K / ColsAtCompileTime) : (K % RowsAtCompileTime);
+    constexpr int C = RowMajor ? (K % ColsAtCompileTime) : (K / RowsAtCompileTime);
     Packet P = mat.template packet<Packet>(R, C);
-    visitor.packet(P, R, C);
-    run<K + PacketSize>(mat, visitor);
+    EIGEN_IF_CONSTEXPR (Op == 0) {
+      visitor.initpacket(P, R, C);
+    } else {
+      visitor.packet(P, R, C);
+    }
+  }
+
+  template <int... Ops>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run_impl(const Derived& mat, Visitor& visitor,
+                                                             std::integer_sequence<int, Ops...>) {
+    int unused[] = {0, (visit<Ops>(mat, visitor), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
+    run_impl(mat, visitor, std::make_integer_sequence<int, OpCount>{});
   }
 };
 
@@ -95,45 +110,51 @@
   using Scalar = typename Derived::Scalar;
   using Packet = typename packet_traits<Scalar>::type;
   static constexpr int PacketSize = packet_traits<Scalar>::size;
+  static constexpr int PacketOps = Vectorize ? UnrollCount / PacketSize : 0;
+  static constexpr int FirstScalar = PacketOps * PacketSize;
+  static constexpr int ScalarOps = UnrollCount - FirstScalar;
+  static constexpr int OpCount = PacketOps + ScalarOps;
 
-  static constexpr bool CanVectorize(int K) { return Vectorize && ((UnrollCount - K) >= PacketSize); }
-
-  // empty
-  template <int K = 0, bool Empty = (K == UnrollCount), std::enable_if_t<Empty, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived&, Visitor&) {}
-
-  // scalar initialization
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && Initialize && !DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    visitor.init(mat.coeff(0), 0);
-    run<1>(mat, visitor);
+  template <int Op>
+  static constexpr bool IsPacketOp() {
+    return Op < PacketOps;
   }
 
-  // scalar iteration
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && !Initialize && !DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    visitor(mat.coeff(K), K);
-    run<K + 1>(mat, visitor);
+  template <int Op>
+  static constexpr int CoeffIndex() {
+    return IsPacketOp<Op>() ? (Op * PacketSize) : (FirstScalar + Op - PacketOps);
   }
 
-  // vector initialization
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && Initialize && DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
-    Packet P = mat.template packet<Packet>(0);
-    visitor.initpacket(P, 0);
-    run<PacketSize>(mat, visitor);
+  template <int Op, std::enable_if_t<!IsPacketOp<Op>(), bool> = true>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void visit(const Derived& mat, Visitor& visitor) {
+    constexpr int K = CoeffIndex<Op>();
+    EIGEN_IF_CONSTEXPR (Op == 0) {
+      visitor.init(mat.coeff(K), K);
+    } else {
+      visitor(mat.coeff(K), K);
+    }
   }
 
-  // vector iteration
-  template <int K = 0, bool Empty = (K == UnrollCount), bool Initialize = (K == 0), bool DoVectorOp = CanVectorize(K),
-            std::enable_if_t<!Empty && !Initialize && DoVectorOp, bool> = true>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
+  template <int Op, std::enable_if_t<IsPacketOp<Op>(), bool> = true>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void visit(const Derived& mat, Visitor& visitor) {
+    constexpr int K = CoeffIndex<Op>();
     Packet P = mat.template packet<Packet>(K);
-    visitor.packet(P, K);
-    run<K + PacketSize>(mat, visitor);
+    EIGEN_IF_CONSTEXPR (Op == 0) {
+      visitor.initpacket(P, K);
+    } else {
+      visitor.packet(P, K);
+    }
+  }
+
+  template <int... Ops>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run_impl(const Derived& mat, Visitor& visitor,
+                                                             std::integer_sequence<int, Ops...>) {
+    int unused[] = {0, (visit<Ops>(mat, visitor), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
+    run_impl(mat, visitor, std::make_integer_sequence<int, OpCount>{});
   }
 };
 
@@ -253,6 +274,7 @@
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const Derived& mat, Visitor& visitor) {
     const Index size = mat.size();
     if (size == 0) return;
+    const Index packetEnd = size - size % PacketSize;
     Index k = 0;
     if (size < PacketSize) {
       visitor.init(mat.coeff(0), 0);
@@ -263,7 +285,7 @@
       k = PacketSize;
     }
     if EIGEN_PREDICT_FALSE (short_circuit::run(visitor)) return;
-    for (; k + PacketSize - 1 < size; k += PacketSize) {
+    for (; k < packetEnd; k += PacketSize) {
       Packet p = mat.template packet<Packet>(k);
       visitor.packet(p, k);
       if EIGEN_PREDICT_FALSE (short_circuit::run(visitor)) return;
@@ -279,10 +301,10 @@
 template <typename XprType>
 class visitor_evaluator {
  public:
-  typedef evaluator<XprType> Evaluator;
-  typedef typename XprType::Scalar Scalar;
+  using Evaluator = evaluator<XprType>;
+  using Scalar = typename XprType::Scalar;
   using Packet = typename packet_traits<Scalar>::type;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  using CoeffReturnType = std::remove_const_t<typename XprType::CoeffReturnType>;
 
   static constexpr bool PacketAccess = static_cast<bool>(Evaluator::Flags & PacketAccessBit);
   static constexpr bool LinearAccess = static_cast<bool>(Evaluator::Flags & LinearAccessBit);
@@ -321,10 +343,10 @@
 struct visitor_has_linear_access : std::false_type {};
 
 template <typename T>
-struct visitor_has_linear_access<T, decltype(functor_traits<T>::LinearAccess)>
-    : std::integral_constant<bool, static_cast<bool>(functor_traits<T>::LinearAccess)> {};
+struct visitor_has_linear_access<T, void_t<decltype(functor_traits<T>::LinearAccess)>>
+    : bool_constant<static_cast<bool>(functor_traits<T>::LinearAccess)> {};
 
-template <typename Derived, typename Visitor, bool ShortCircuitEvaulation>
+template <typename Derived, typename Visitor, bool ShortCircuitEvaluation>
 struct visit_impl {
   using Evaluator = visitor_evaluator<Derived>;
   using Scalar = typename DenseBase<Derived>::Scalar;
@@ -336,7 +358,9 @@
   static constexpr int InnerSizeAtCompileTime = IsRowMajor ? ColsAtCompileTime : RowsAtCompileTime;
   static constexpr int OuterSizeAtCompileTime = IsRowMajor ? RowsAtCompileTime : ColsAtCompileTime;
 
-  static constexpr bool LinearAccess = Evaluator::LinearAccess && visitor_has_linear_access<Visitor>::value;
+  // Linear packets can make an early scalar short-circuit exit more expensive.
+  static constexpr bool LinearAccess =
+      !ShortCircuitEvaluation && Evaluator::LinearAccess && visitor_has_linear_access<Visitor>::value;
   static constexpr bool Vectorize = Evaluator::PacketAccess && static_cast<bool>(functor_traits<Visitor>::PacketAccess);
 
   static constexpr int PacketSize = packet_traits<Scalar>::size;
@@ -352,7 +376,7 @@
   static constexpr bool Unroll = (SizeAtCompileTime != Dynamic) && ((TotalOps * UnrollCost) <= EIGEN_UNROLLING_LIMIT);
   static constexpr int UnrollCount = Unroll ? int(SizeAtCompileTime) : Dynamic;
 
-  using impl = visitor_impl<Visitor, Evaluator, UnrollCount, Vectorize, LinearAccess, ShortCircuitEvaulation>;
+  using impl = visitor_impl<Visitor, Evaluator, UnrollCount, Vectorize, LinearAccess, ShortCircuitEvaluation>;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void run(const DenseBase<Derived>& mat, Visitor& visitor) {
     Evaluator evaluator(mat.derived());
@@ -384,7 +408,7 @@
 template <typename Derived>
 template <typename Visitor>
 EIGEN_DEVICE_FUNC void DenseBase<Derived>::visit(Visitor& visitor) const {
-  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/ false>;
+  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaluation*/ false>;
   impl::run(derived(), visitor);
 }
 
@@ -396,7 +420,7 @@
   using Packet = typename packet_traits<Scalar>::type;
   EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index, Index) { res = (value != Scalar(0)); }
   EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index) { res = (value != Scalar(0)); }
-  EIGEN_DEVICE_FUNC inline bool all_predux(const Packet& p) const { return !predux_any(pcmp_eq(p, pzero(p))); }
+  EIGEN_DEVICE_FUNC inline bool all_predux(const Packet& p) const { return predux_all(p); }
   EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index, Index) { res = all_predux(p); }
   EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index) { res = all_predux(p); }
   EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index, Index) { res = res && (value != Scalar(0)); }
@@ -429,6 +453,10 @@
   EIGEN_DEVICE_FUNC inline bool done() const { return res; }
   bool res = false;
 };
+template <>
+EIGEN_DEVICE_FUNC inline bool any_visitor<bool>::any_predux(const Packet& p) const {
+  return predux(p);
+}
 template <typename Scalar>
 struct functor_traits<any_visitor<Scalar>> {
   enum { Cost = NumTraits<Scalar>::ReadCost, LinearAccess = true, PacketAccess = packet_traits<Scalar>::HasCmp };
@@ -440,12 +468,7 @@
   using Packet = typename packet_traits<Scalar>::type;
   EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index, Index) { res = value != Scalar(0) ? 1 : 0; }
   EIGEN_DEVICE_FUNC inline void init(const Scalar& value, Index) { res = value != Scalar(0) ? 1 : 0; }
-  EIGEN_DEVICE_FUNC inline Index count_redux(const Packet& p) const {
-    const Packet cst_one = pset1<Packet>(Scalar(1));
-    Packet true_vals = pandnot(cst_one, pcmp_eq(p, pzero(p)));
-    Scalar num_true = predux(true_vals);
-    return static_cast<Index>(num_true);
-  }
+  EIGEN_DEVICE_FUNC inline Index count_redux(const Packet& p) const { return predux_count(p); }
   EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index, Index) { res = count_redux(p); }
   EIGEN_DEVICE_FUNC inline void initpacket(const Packet& p, Index) { res = count_redux(p); }
   EIGEN_DEVICE_FUNC inline void operator()(const Scalar& value, Index, Index) {
@@ -464,8 +487,7 @@
   enum {
     Cost = NumTraits<Scalar>::AddCost,
     LinearAccess = true,
-    // predux is problematic for bool
-    PacketAccess = packet_traits<Scalar>::HasCmp && packet_traits<Scalar>::HasAdd && !is_same<Scalar, bool>::value
+    PacketAccess = packet_traits<Scalar>::HasCmp && packet_traits<Scalar>::HasAdd
   };
 };
 
@@ -492,7 +514,7 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::all() const {
   using Visitor = internal::all_visitor<Scalar>;
-  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/ true>;
+  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaluation*/ true>;
   Visitor visitor;
   impl::run(derived(), visitor);
   return visitor.res;
@@ -505,7 +527,7 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::any() const {
   using Visitor = internal::any_visitor<Scalar>;
-  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/ true>;
+  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaluation*/ true>;
   Visitor visitor;
   impl::run(derived(), visitor);
   return visitor.res;
@@ -518,7 +540,7 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC Index DenseBase<Derived>::count() const {
   using Visitor = internal::count_visitor<Scalar>;
-  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaulation*/ false>;
+  using impl = internal::visit_impl<Derived, Visitor, /*ShortCircuitEvaluation*/ false>;
   Visitor visitor;
   impl::run(derived(), visitor);
   return visitor.res;
diff --git a/Eigen/src/Core/arch/AVX/Complex.h b/Eigen/src/Core/arch/AVX/Complex.h
index 3f3046f..a28621b 100644
--- a/Eigen/src/Core/arch/AVX/Complex.h
+++ b/Eigen/src/Core/arch/AVX/Complex.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_AVX_H
 #define EIGEN_COMPLEX_AVX_H
@@ -17,6 +18,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 //---------- float ----------
 struct Packet4cf {
   EIGEN_STRONG_INLINE Packet4cf() {}
@@ -134,17 +137,36 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4cf pset1<Packet4cf>(const std::complex<float>& from) {
-  const float re = std::real(from);
-  const float im = std::imag(from);
-  return Packet4cf(_mm256_set_ps(im, re, im, re, im, re, im, re));
+  // Broadcast one complex<float> (64 bits) to all four 64-bit lanes.
+  // _mm256_set_ps with 8 scalar arguments generates a store-to-load forwarding
+  // sequence (4 × 64-bit stores then a 256-bit load) that causes ~15-cycle stalls
+  // on every call.
+  //
+  // _mm_loadl_epi64 is an 8-byte unaligned load through __m128i* (__may_alias__),
+  // so it is safe regardless of complex<float>'s 4-byte alignment and avoids the
+  // strict-aliasing UB that would arise from casting to double* or int64_t*.
+  const __m128i lo64 = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(&from));
+#ifdef EIGEN_VECTORIZE_AVX2
+  return Packet4cf(_mm256_castsi256_ps(_mm256_broadcastq_epi64(lo64)));
+#else
+  // No vpbroadcastq without AVX2: first duplicate the 64-bit complex across both
+  // halves of the 128-bit lane (movedup_pd: {x,_} -> {x,x}), otherwise the upper
+  // complex of each lane stays zeroed by _mm_loadl_epi64. Then vinsertf128 the
+  // filled lane into the high 256-bit lane.
+  const __m128 lo = _mm_castpd_ps(_mm_movedup_pd(_mm_castsi128_pd(lo64)));
+  return Packet4cf(_mm256_insertf128_ps(_mm256_castps128_ps256(lo), lo, 1));
+#endif
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4cf ploaddup<Packet4cf>(const std::complex<float>* from) {
-  // FIXME The following might be optimized using _mm256_movedup_pd
-  Packet2cf a = ploaddup<Packet2cf>(from);
-  Packet2cf b = ploaddup<Packet2cf>(from + 1);
-  return Packet4cf(_mm256_insertf128_ps(_mm256_castps128_ps256(a.v), b.v, 1));
+  // vbroadcastf128 + vpermilpd, 2 uops: broadcast the 16 bytes holding two
+  // complex<float> into both 128-bit lanes, then duplicate each complex so
+  // the result is {c0, c0, c1, c1}. The load has no alignment requirement;
+  // we cast the source pointer through void* rather than through double*
+  // because alignof(std::complex<float>) == 4 < alignof(double).
+  __m256 bcast = _mm256_broadcast_ps(reinterpret_cast<const __m128*>(static_cast<const void*>(from)));
+  return Packet4cf(_mm256_castpd_ps(_mm256_permute_pd(_mm256_castps_pd(bcast), 3 << 2)));
 }
 
 template <>
@@ -343,6 +365,8 @@
   return Packet2cd(_mm256_broadcast_pd((const __m128d*)(const void*)&from));
 }
 
+// The generic ploaddup broadcasts a copy made by pload1_scalar, which keeps GCC from folding
+// the load into vbroadcastf128's memory operand; binding *from directly does not.
 template <>
 EIGEN_STRONG_INLINE Packet2cd ploaddup<Packet2cd>(const std::complex<double>* from) {
   return pset1<Packet2cd>(*from);
@@ -551,6 +575,8 @@
 
 /*---------------- end load/store segment support ----------------*/
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/AVX/MathFunctions.h b/Eigen/src/Core/arch/AVX/MathFunctions.h
index 5a6cba3..db134f3 100644
--- a/Eigen/src/Core/arch/AVX/MathFunctions.h
+++ b/Eigen/src/Core/arch/AVX/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_AVX_H
 #define EIGEN_MATH_FUNCTIONS_AVX_H
@@ -24,7 +25,12 @@
 EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_FLOAT(Packet8f)
 
 EIGEN_DOUBLE_PACKET_FUNCTION(atanh, Packet4d)
+EIGEN_DOUBLE_PACKET_FUNCTION(sinh, Packet4d)
+EIGEN_DOUBLE_PACKET_FUNCTION(cosh, Packet4d)
+EIGEN_DOUBLE_PACKET_FUNCTION(asinh, Packet4d)
+EIGEN_DOUBLE_PACKET_FUNCTION(acosh, Packet4d)
 EIGEN_DOUBLE_PACKET_FUNCTION(log, Packet4d)
+EIGEN_DOUBLE_PACKET_FUNCTION(log10, Packet4d)
 EIGEN_DOUBLE_PACKET_FUNCTION(exp, Packet4d)
 EIGEN_DOUBLE_PACKET_FUNCTION(log2, Packet4d)
 EIGEN_DOUBLE_PACKET_FUNCTION(tanh, Packet4d)
@@ -55,7 +61,7 @@
 EIGEN_GENERIC_PACKET_FUNCTION(atan, Packet4d)
 EIGEN_GENERIC_PACKET_FUNCTION(exp2, Packet4d)
 EIGEN_GENERIC_PACKET_FUNCTION(expm1, Packet4d)
-EIGEN_GENERIC_PACKET_FUNCTION(log1p, Packet4d)
+EIGEN_DOUBLE_PACKET_FUNCTION(log1p, Packet4d)
 
 // Notice that for newer processors, it is counterproductive to use Newton
 // iteration for square root. In particular, Skylake and Zen2 processors
@@ -105,9 +111,11 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pfrexp(const Packet8bf& a, Packet8bf& exponent) {
+  // Both results are exact: the mantissa keeps the input's significand, and the exponent is a
+  // small integer.
   Packet8f fexponent;
-  const Packet8bf out = F32ToBf16(pfrexp<Packet8f>(Bf16ToF32(a), fexponent));
-  exponent = F32ToBf16(fexponent);
+  const Packet8bf out = F32ToBf16Truncate(pfrexp<Packet8f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16Truncate(fexponent);
   return out;
 }
 
diff --git a/Eigen/src/Core/arch/AVX/PacketMath.h b/Eigen/src/Core/arch/AVX/PacketMath.h
index df94f70..129c8e0 100644
--- a/Eigen/src/Core/arch/AVX/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_AVX_H
 #define EIGEN_PACKET_MATH_AVX_H
@@ -49,50 +50,32 @@
 #define SIGN_MASK_I64 static_cast<int64_t>(0x8000000000000000ULL)
 
 template <>
-struct is_arithmetic<__m256> {
-  enum { value = true };
-};
+struct is_arithmetic<__m256> : std::true_type {};
 template <>
-struct is_arithmetic<__m256i> {
-  enum { value = true };
-};
+struct is_arithmetic<__m256i> : std::true_type {};
 template <>
-struct is_arithmetic<__m256d> {
-  enum { value = true };
-};
+struct is_arithmetic<__m256d> : std::true_type {};
 template <>
-struct is_arithmetic<Packet8i> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet8i> : std::true_type {};
 // Note that `Packet8ui` uses the underlying type `__m256i`, which is
 // interpreted as a vector of _signed_ `int32`s, which breaks some arithmetic
 // operations used in `GenericPacketMath.h`.
 template <>
-struct is_arithmetic<Packet8ui> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet8ui> : std::false_type {};
 #ifndef EIGEN_VECTORIZE_AVX512FP16
 template <>
-struct is_arithmetic<Packet8h> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet8h> : std::true_type {};
 #endif
 template <>
-struct is_arithmetic<Packet8bf> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet8bf> : std::true_type {};
 #ifdef EIGEN_VECTORIZE_AVX2
 template <>
-struct is_arithmetic<Packet4l> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet4l> : std::true_type {};
 // Note that `Packet4ul` uses the underlying type `__m256i`, which is
 // interpreted as a vector of _signed_ `int32`s, which breaks some arithmetic
 // operations used in `GenericPacketMath.h`.
 template <>
-struct is_arithmetic<Packet4ul> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet4ul> : std::false_type {};
 #endif
 
 // Use the packet_traits defined in AVX512/PacketMath.h instead if we're going
@@ -117,7 +100,12 @@
     HasASin = 1,
     HasATan = 1,
     HasATanh = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasLog = 1,
+    HasLog10 = 1,
     HasExp = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
@@ -148,10 +136,15 @@
     HasCos = EIGEN_FAST_MATH,
     HasTan = EIGEN_FAST_MATH,
 #endif
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasTanh = EIGEN_FAST_MATH,
     HasErf = 1,
     HasErfc = 1,
     HasLog = 1,
+    HasLog10 = 1,
     HasExp = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
@@ -292,13 +285,9 @@
 #endif
 
 template <>
-struct scalar_div_cost<float, true> {
-  enum { value = 14 };
-};
+struct scalar_div_cost<float, true> : std::integral_constant<int, 14> {};
 template <>
-struct scalar_div_cost<double, true> {
-  enum { value = 16 };
-};
+struct scalar_div_cost<double, true> : std::integral_constant<int, 16> {};
 
 template <>
 struct unpacket_traits<Packet8f> {
@@ -398,7 +387,7 @@
 
 // Helper function for bit packing snippet of low precision comparison.
 // It packs the flags from 16x16 to 8x16.
-EIGEN_STRONG_INLINE __m128i Pack16To8(Packet8f rf) {
+EIGEN_STRONG_INLINE __m128i Pack16To8(const Packet8f& rf) {
   return _mm_packs_epi32(_mm256_extractf128_si256(_mm256_castps_si256(rf), 0),
                          _mm256_extractf128_si256(_mm256_castps_si256(rf), 1));
 }
@@ -465,10 +454,6 @@
   return psub(pzero(a), a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet4l pconj(const Packet4l& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet4l pcmp_le(const Packet4l& a, const Packet4l& b) {
   return _mm256_xor_si256(_mm256_cmpgt_epi64(a, b), _mm256_set1_epi32(-1));
 }
@@ -523,44 +508,56 @@
   return _mm256_andnot_si256(b, a);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4l plogical_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE Packet4l plogical_shift_right(const Packet4l& a) {
   return _mm256_srli_epi64(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4l plogical_shift_left(Packet4l a) {
+EIGEN_STRONG_INLINE Packet4l plogical_shift_left(const Packet4l& a) {
   return _mm256_slli_epi64(a, N);
 }
 #ifdef EIGEN_VECTORIZE_AVX512FP16
 template <int N>
-EIGEN_STRONG_INLINE Packet4l parithmetic_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE Packet4l parithmetic_shift_right(const Packet4l& a) {
   return _mm256_srai_epi64(a, N);
 }
 #else
 template <int N>
-EIGEN_STRONG_INLINE std::enable_if_t<(N == 0), Packet4l> parithmetic_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE std::enable_if_t<(N == 0), Packet4l> parithmetic_shift_right(const Packet4l& a) {
   return a;
 }
 template <int N>
-EIGEN_STRONG_INLINE std::enable_if_t<(N > 0) && (N < 32), Packet4l> parithmetic_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE std::enable_if_t<(N > 0) && (N < 32), Packet4l> parithmetic_shift_right(const Packet4l& a) {
   __m256i hi_word = _mm256_srai_epi32(a, N);
   __m256i lo_word = _mm256_srli_epi64(a, N);
   return _mm256_blend_epi32(hi_word, lo_word, 0b01010101);
 }
 template <int N>
-EIGEN_STRONG_INLINE std::enable_if_t<(N >= 32) && (N < 63), Packet4l> parithmetic_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE std::enable_if_t<(N >= 32) && (N < 63), Packet4l> parithmetic_shift_right(const Packet4l& a) {
   __m256i hi_word = _mm256_srai_epi32(a, 31);
   __m256i lo_word = _mm256_shuffle_epi32(_mm256_srai_epi32(a, N - 32), (shuffle_mask<1, 1, 3, 3>::mask));
   return _mm256_blend_epi32(hi_word, lo_word, 0b01010101);
 }
 template <int N>
-EIGEN_STRONG_INLINE std::enable_if_t<(N == 63), Packet4l> parithmetic_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE std::enable_if_t<(N == 63), Packet4l> parithmetic_shift_right(const Packet4l& a) {
   return _mm256_cmpgt_epi64(_mm256_setzero_si256(), a);
 }
 template <int N>
-EIGEN_STRONG_INLINE std::enable_if_t<(N < 0) || (N > 63), Packet4l> parithmetic_shift_right(Packet4l a) {
+EIGEN_STRONG_INLINE std::enable_if_t<(N < 0) || (N > 63), Packet4l> parithmetic_shift_right(const Packet4l& a) {
   return parithmetic_shift_right<int(N & 63)>(a);
 }
 #endif
+template <int N>
+EIGEN_STRONG_INLINE Packet4ul parithmetic_shift_right(const Packet4ul& a) {
+  return _mm256_srli_epi64(a, N);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet4ul plogical_shift_right(const Packet4ul& a) {
+  return _mm256_srli_epi64(a, N);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet4ul plogical_shift_left(const Packet4ul& a) {
+  return _mm256_slli_epi64(a, N);
+}
 template <>
 EIGEN_STRONG_INLINE Packet4l pload<Packet4l>(const int64_t* from) {
   EIGEN_DEBUG_ALIGNED_LOAD return _mm256_load_si256(reinterpret_cast<const __m256i*>(from));
@@ -700,10 +697,6 @@
   return psub(cmp, pxor(a, cmp));
 }
 template <>
-EIGEN_STRONG_INLINE Packet4ul pabs<Packet4ul>(const Packet4ul& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet4l pmul<Packet4l>(const Packet4l& a, const Packet4l& b) {
   // 64-bit mul requires avx512, so do this with 32-bit multiplication
   __m256i upper32_a = _mm256_srli_epi64(a, 32);
@@ -769,7 +762,9 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet8f peven_mask(const Packet8f& /*a*/) {
-  return _mm256_castsi256_ps(_mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1));
+  Packet8f r = _mm256_castsi256_ps(_mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 template <>
 EIGEN_STRONG_INLINE Packet8i peven_mask(const Packet8i& /*a*/) {
@@ -781,7 +776,9 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet4d peven_mask(const Packet4d& /*a*/) {
-  return _mm256_castsi256_pd(_mm256_set_epi32(0, 0, -1, -1, 0, 0, -1, -1));
+  Packet4d r = _mm256_castsi256_pd(_mm256_set_epi32(0, 0, -1, -1, 0, 0, -1, -1));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -891,19 +888,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet8f pconj(const Packet8f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4d pconj(const Packet4d& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8i pconj(const Packet8i& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet8f pmul<Packet8f>(const Packet8f& a, const Packet8f& b) {
   return _mm256_mul_ps(a, b);
 }
@@ -1261,9 +1245,13 @@
 #ifdef EIGEN_VECTORIZE_AVX2
   // vpcmpeqd has lower latency than the more general vcmpps
   const __m256i b = _mm256_castps_si256(a);
-  return _mm256_castsi256_ps(_mm256_cmpeq_epi32(b, b));
+  Packet8f r = _mm256_castsi256_ps(_mm256_cmpeq_epi32(b, b));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 #else
-  return _mm256_cmp_ps(a, a, _CMP_TRUE_UQ);
+  Packet8f r = _mm256_cmp_ps(a, a, _CMP_TRUE_UQ);
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 #endif
 }
 
@@ -1272,9 +1260,13 @@
 #ifdef EIGEN_VECTORIZE_AVX2
   // vpcmpeqq has lower latency than the more general vcmppd
   const __m256i b = _mm256_castpd_si256(a);
-  return _mm256_castsi256_pd(_mm256_cmpeq_epi64(b, b));
+  Packet4d r = _mm256_castsi256_pd(_mm256_cmpeq_epi64(b, b));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 #else
-  return _mm256_cmp_pd(a, a, _CMP_TRUE_UQ);
+  Packet4d r = _mm256_cmp_pd(a, a, _CMP_TRUE_UQ);
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 #endif
 }
 
@@ -1421,7 +1413,7 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8i parithmetic_shift_right(Packet8i a) {
+EIGEN_STRONG_INLINE Packet8i parithmetic_shift_right(const Packet8i& a) {
 #ifdef EIGEN_VECTORIZE_AVX2
   return _mm256_srai_epi32(a, N);
 #else
@@ -1432,7 +1424,7 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8i plogical_shift_right(Packet8i a) {
+EIGEN_STRONG_INLINE Packet8i plogical_shift_right(const Packet8i& a) {
 #ifdef EIGEN_VECTORIZE_AVX2
   return _mm256_srli_epi32(a, N);
 #else
@@ -1443,7 +1435,7 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8i plogical_shift_left(Packet8i a) {
+EIGEN_STRONG_INLINE Packet8i plogical_shift_left(const Packet8i& a) {
 #ifdef EIGEN_VECTORIZE_AVX2
   return _mm256_slli_epi32(a, N);
 #else
@@ -1454,15 +1446,15 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8ui parithmetic_shift_right(Packet8ui a) {
+EIGEN_STRONG_INLINE Packet8ui parithmetic_shift_right(const Packet8ui& a) {
   return (Packet8ui)plogical_shift_right<N>((Packet8i)a);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8ui plogical_shift_right(Packet8ui a) {
+EIGEN_STRONG_INLINE Packet8ui plogical_shift_right(const Packet8ui& a) {
   return (Packet8ui)plogical_shift_right<N>((Packet8i)a);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8ui plogical_shift_left(Packet8ui a) {
+EIGEN_STRONG_INLINE Packet8ui plogical_shift_left(const Packet8ui& a) {
   return (Packet8ui)plogical_shift_left<N>((Packet8i)a);
 }
 
@@ -1515,7 +1507,7 @@
 #endif
 }
 
-// Loads 4 floats from memory a returns the packet {a0, a0  a1, a1, a2, a2, a3, a3}
+// Loads 4 floats from memory a returns the packet {a0, a0, a1, a1, a2, a2, a3, a3}
 template <>
 EIGEN_STRONG_INLINE Packet8f ploaddup<Packet8f>(const float* from) {
   // TODO try to find a way to avoid the need of a temporary register
@@ -1568,7 +1560,7 @@
 #endif
 }
 
-// Loads 2 floats from memory a returns the packet {a0, a0  a0, a0, a1, a1, a1, a1}
+// Loads 2 floats from memory a returns the packet {a0, a0, a0, a0, a1, a1, a1, a1}
 template <>
 EIGEN_STRONG_INLINE Packet8f ploadquad<Packet8f>(const float* from) {
   Packet8f tmp = _mm256_castps128_ps256(_mm_broadcast_ss(from));
@@ -1646,11 +1638,32 @@
 // 4);
 template <>
 EIGEN_DEVICE_FUNC inline Packet8f pgather<float, Packet8f>(const float* from, Index stride) {
+  if (stride == 2) {
+#ifdef EIGEN_VECTORIZE_AVX2
+    // Both loads stay within from[0..14], including when from points to an imaginary component.
+    const Packet8f low = _mm256_loadu_ps(from);
+    const Packet8f high = _mm256_loadu_ps(from + 7);
+    const Packet8f interleaved = _mm256_shuffle_ps(low, high, _MM_SHUFFLE(3, 1, 2, 0));
+    return _mm256_castpd_ps(_mm256_permute4x64_pd(_mm256_castps_pd(interleaved), _MM_SHUFFLE(3, 1, 2, 0)));
+#else
+    const Packet4f low = pgather<float, Packet4f>(from, 2);
+    const Packet4f high = pgather<float, Packet4f>(from + 8, 2);
+    return _mm256_insertf128_ps(_mm256_castps128_ps256(low), high, 1);
+#endif
+  }
   return _mm256_set_ps(from[7 * stride], from[6 * stride], from[5 * stride], from[4 * stride], from[3 * stride],
                        from[2 * stride], from[1 * stride], from[0 * stride]);
 }
 template <>
 EIGEN_DEVICE_FUNC inline Packet4d pgather<double, Packet4d>(const double* from, Index stride) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  if (stride == 2) {
+    const Packet4d low = _mm256_loadu_pd(from);
+    const Packet4d high = _mm256_loadu_pd(from + 3);
+    const Packet4d interleaved = _mm256_shuffle_pd(low, high, 0xa);
+    return _mm256_permute4x64_pd(interleaved, _MM_SHUFFLE(3, 1, 2, 0));
+  }
+#endif
   return _mm256_set_pd(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
 }
 template <>
@@ -1808,11 +1821,6 @@
   return _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1);
 #endif
 }
-template <>
-EIGEN_STRONG_INLINE Packet8ui pabs(const Packet8ui& a) {
-  return a;
-}
-
 #ifndef EIGEN_VECTORIZE_AVX512FP16
 template <>
 EIGEN_STRONG_INLINE Packet8h psignbit(const Packet8h& a) {
@@ -1832,19 +1840,11 @@
   return _mm256_castsi256_ps(parithmetic_shift_right<31>(Packet8i(_mm256_castps_si256(a))));
 #endif
 }
-template <>
-EIGEN_STRONG_INLINE Packet8ui psignbit(const Packet8ui& /*unused*/) {
-  return _mm256_setzero_si256();
-}
 #ifdef EIGEN_VECTORIZE_AVX2
 template <>
 EIGEN_STRONG_INLINE Packet4d psignbit(const Packet4d& a) {
   return _mm256_castsi256_pd(_mm256_cmpgt_epi64(_mm256_setzero_si256(), _mm256_castpd_si256(a)));
 }
-template <>
-EIGEN_STRONG_INLINE Packet4ul psignbit(const Packet4ul& /*unused*/) {
-  return _mm256_setzero_si256();
-}
 #endif
 
 template <>
@@ -1884,31 +1884,36 @@
   return pldexp_generic(a, exponent);
 }
 
+// Build 2^k as Packet4d from a Packet4i holding the biased int32 exponent in
+// each lane.  AVX2 has a single-instruction widen+shift path; AVX-only must
+// split the 128-bit input into two halves, widen+shift each separately with
+// SSE intrinsics, and reassemble with vinsertf128.
+EIGEN_STRONG_INLINE Packet4d pldexp_avx_pow2_from_biased(const Packet4i& biased) {
+#ifdef EIGEN_VECTORIZE_AVX2
+  return _mm256_castsi256_pd(_mm256_slli_epi64(_mm256_cvtepi32_epi64(biased), 52));
+#else
+  __m128i lo = _mm_cvtepi32_epi64(biased);                              // SSE4.1: lower 2 int32 -> 2 int64
+  __m128i hi = _mm_cvtepi32_epi64(_mm_unpackhi_epi64(biased, biased));  // upper 2 int32 -> 2 int64
+  lo = _mm_slli_epi64(lo, 52);
+  hi = _mm_slli_epi64(hi, 52);
+  return _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
+#endif
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet4d pldexp<Packet4d>(const Packet4d& a, const Packet4d& exponent) {
   // Clamp exponent to [-2099, 2099]
   const Packet4d max_exponent = pset1<Packet4d>(2099.0);
   const Packet4i e = _mm256_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
 
-  // Split 2^e into four factors and multiply.
+  // Preserve the sequential 4-way split; see pldexp_generic.
   const Packet4i bias = pset1<Packet4i>(1023);
-  Packet4i b = parithmetic_shift_right<2>(e);  // floor(e/4)
+  const Packet4i b = parithmetic_shift_right<2>(e);                          // floor(e/4)
+  const Packet4i b_remainder = psub(psub(e, b), padd(b, b));                 // e - 3b (depth 2)
+  const Packet4d c1 = pldexp_avx_pow2_from_biased(padd(b, bias));            // 2^b
+  const Packet4d c2 = pldexp_avx_pow2_from_biased(padd(b_remainder, bias));  // 2^(e-3b)
 
-  // 2^b
-  Packet4i hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
-  Packet4i lo = _mm_slli_epi64(hi, 52);
-  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
-  Packet4d c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
-  Packet4d out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
-
-  // 2^(e - 3b)
-  b = psub(psub(psub(e, b), b), b);  // e - 3b
-  hi = vec4i_swizzle1(padd(b, bias), 0, 2, 1, 3);
-  lo = _mm_slli_epi64(hi, 52);
-  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
-  c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
-  out = pmul(out, c);  // a * 2^e
-  return out;
+  return pmul(pmul(pmul(pmul(a, c1), c1), c1), c2);  // a * 2^e
 }
 
 template <>
@@ -1919,12 +1924,7 @@
   const Packet4i e = _mm256_cvtpd_epi32(pmin(pmax(exponent, min_exponent), max_exponent));
   const Packet4i bias = pset1<Packet4i>(1023);
 
-  // 2^e
-  Packet4i hi = vec4i_swizzle1(padd(e, bias), 0, 2, 1, 3);
-  const Packet4i lo = _mm_slli_epi64(hi, 52);
-  hi = _mm_slli_epi64(_mm_srli_epi64(hi, 32), 52);
-  const Packet4d c = _mm256_castsi256_pd(_mm256_insertf128_si256(_mm256_castsi128_si256(lo), hi, 1));
-  return pmul(a, c);  // a * 2^e
+  return pmul(a, pldexp_avx_pow2_from_biased(padd(e, bias)));  // a * 2^e
 }
 
 template <>
@@ -2127,7 +2127,7 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet8h pabs(const Packet8h& a) {
-  const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  const __m128i sign_mask = _mm_set1_epi16(static_cast<short>(0x8000u));
   return _mm_andnot_si128(sign_mask, a);
 }
 
@@ -2276,13 +2276,8 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet8h pconj(const Packet8h& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet8h pnegate(const Packet8h& a) {
-  Packet8h sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  Packet8h sign_mask = _mm_set1_epi16(static_cast<short>(0x8000u));
   return _mm_xor_si128(a, sign_mask);
 }
 
@@ -2554,6 +2549,21 @@
   return _mm_set_epi16(b, b, b, b, a, a, a, a);
 }
 
+// Discard the low 16 bits of each float. Only valid when every lane already holds an exact
+// bfloat16 value, in which case this agrees with F32ToBf16 but skips its rounding and NaN
+// canonicalization. pmin/pmax qualify: they return one of their operands bit for bit.
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16Truncate(const Packet8f& a) {
+  __m256i input = _mm256_castps_si256(a);
+#ifdef EIGEN_VECTORIZE_AVX2
+  __m256i t = _mm256_srli_epi32(input, 16);
+  return _mm_packus_epi32(_mm256_extractf128_si256(t, 0), _mm256_extractf128_si256(t, 1));
+#else
+  __m128i lo = _mm_srli_epi32(_mm256_extractf128_si256(input, 0), 16);
+  __m128i hi = _mm_srli_epi32(_mm256_extractf128_si256(input, 1), 16);
+  return _mm_packus_epi32(lo, hi);
+#endif
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet8bf ptrue(const Packet8bf& a) {
   return _mm_cmpeq_epi32(a, a);
@@ -2561,18 +2571,18 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pabs(const Packet8bf& a) {
-  const __m128i sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  const __m128i sign_mask = _mm_set1_epi16(static_cast<short>(0x8000u));
   return _mm_andnot_si128(sign_mask, a);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pmin<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
-  return F32ToBf16(pmin<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmin<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pmax<Packet8bf>(const Packet8bf& a, const Packet8bf& b) {
-  return F32ToBf16(pmax<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmax<Packet8f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
@@ -2604,27 +2614,27 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pround<Packet8bf>(const Packet8bf& a) {
-  return F32ToBf16(pround<Packet8f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pround<Packet8f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf print<Packet8bf>(const Packet8bf& a) {
-  return F32ToBf16(print<Packet8f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(print<Packet8f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pceil<Packet8bf>(const Packet8bf& a) {
-  return F32ToBf16(pceil<Packet8f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pceil<Packet8f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pfloor<Packet8bf>(const Packet8bf& a) {
-  return F32ToBf16(pfloor<Packet8f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pfloor<Packet8f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf ptrunc<Packet8bf>(const Packet8bf& a) {
-  return F32ToBf16(ptrunc<Packet8f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(ptrunc<Packet8f>(Bf16ToF32(a)));
 }
 
 template <>
@@ -2647,14 +2657,31 @@
   return Pack16To8(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
+// Classify on the raw bits, as the scalar isinf/isnan/isfinite do: |a| ==, >, < 0x7f80.
 template <>
-EIGEN_STRONG_INLINE Packet8bf pconj(const Packet8bf& a) {
-  return a;
+EIGEN_STRONG_INLINE Packet8bf pisinf<Packet8bf>(const Packet8bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return _mm_cmpeq_epi16(_mm_and_si128(a, _mm_set1_epi16(kAbsMask)), _mm_set1_epi16(kInf));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pisnan<Packet8bf>(const Packet8bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return _mm_cmpgt_epi16(_mm_and_si128(a, _mm_set1_epi16(kAbsMask)), _mm_set1_epi16(kInf));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet8bf pisfinite<Packet8bf>(const Packet8bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return _mm_cmplt_epi16(_mm_and_si128(a, _mm_set1_epi16(kAbsMask)), _mm_set1_epi16(kInf));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8bf pnegate(const Packet8bf& a) {
-  Packet8bf sign_mask = _mm_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  Packet8bf sign_mask = _mm_set1_epi16(static_cast<short>(0x8000u));
   return _mm_xor_si128(a, sign_mask);
 }
 
diff --git a/Eigen/src/Core/arch/AVX/Reductions.h b/Eigen/src/Core/arch/AVX/Reductions.h
index 237617c..38b7e9b 100644
--- a/Eigen/src/Core/arch/AVX/Reductions.h
+++ b/Eigen/src/Core/arch/AVX/Reductions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REDUCTIONS_AVX_H
 #define EIGEN_REDUCTIONS_AVX_H
@@ -188,6 +189,13 @@
   return _mm256_movemask_ps(a) != 0x0;
 }
 
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet8f& a) {
+  const unsigned int mask =
+      static_cast<unsigned int>(_mm256_movemask_ps(_mm256_cmp_ps(a, _mm256_setzero_ps(), _CMP_NEQ_UQ)));
+  return Index(popcount(mask));
+}
+
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet4d -- -- -- -- -- -- -- -- -- -- -- -- */
 
 template <>
@@ -251,6 +259,13 @@
   return _mm256_movemask_pd(a) != 0x0;
 }
 
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet4d& a) {
+  const unsigned int mask =
+      static_cast<unsigned int>(_mm256_movemask_pd(_mm256_cmp_pd(a, _mm256_setzero_pd(), _CMP_NEQ_UQ)));
+  return Index(popcount(mask));
+}
+
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet8h -- -- -- -- -- -- -- -- -- -- -- -- */
 #ifndef EIGEN_VECTORIZE_AVX512FP16
 
diff --git a/Eigen/src/Core/arch/AVX/TypeCasting.h b/Eigen/src/Core/arch/AVX/TypeCasting.h
index 9feb38f..f93b484 100644
--- a/Eigen/src/Core/arch/AVX/TypeCasting.h
+++ b/Eigen/src/Core/arch/AVX/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_AVX_H
 #define EIGEN_TYPE_CASTING_AVX_H
diff --git a/Eigen/src/Core/arch/AVX512/Complex.h b/Eigen/src/Core/arch/AVX512/Complex.h
index b8483a8..2cb3feb 100644
--- a/Eigen/src/Core/arch/AVX512/Complex.h
+++ b/Eigen/src/Core/arch/AVX512/Complex.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_AVX512_H
 #define EIGEN_COMPLEX_AVX512_H
@@ -17,6 +18,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 //---------- float ----------
 struct Packet8cf {
   EIGEN_STRONG_INLINE Packet8cf() {}
@@ -200,7 +203,7 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet8cf pcplxflip<Packet8cf>(const Packet8cf& x) {
-  return Packet8cf(_mm512_shuffle_ps(x.v, x.v, _MM_SHUFFLE(2, 3, 0, 1)));
+  return Packet8cf(EIGEN_AVX512_SHUFFLE_PS(x.v, x.v, _MM_SHUFFLE(2, 3, 0, 1)));
 }
 
 //---------- double ----------
@@ -446,6 +449,8 @@
 EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS(Packet4cd)
 EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS(Packet8cf)
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 }  // end namespace Eigen
 
diff --git a/Eigen/src/Core/arch/AVX512/GemmKernel.h b/Eigen/src/Core/arch/AVX512/GemmKernel.h
index 556894c..2c039eb 100644
--- a/Eigen/src/Core/arch/AVX512/GemmKernel.h
+++ b/Eigen/src/Core/arch/AVX512/GemmKernel.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CORE_ARCH_AVX512_GEMM_KERNEL_H
 #define EIGEN_CORE_ARCH_AVX512_GEMM_KERNEL_H
@@ -17,6 +18,7 @@
 #endif
 #include <immintrin.h>
 #include <type_traits>
+#include <utility>
 
 // IWYU pragma: private
 #include "../../InternalHeaderCheck.h"
@@ -27,7 +29,7 @@
 
 #define SECOND_FETCH (32)
 #if (EIGEN_COMP_GNUC_STRICT != 0) && !defined(EIGEN_ARCH_AVX512_GEMM_KERNEL_USE_LESS_A_REGS)
-// Use less registers to load A elements to workaround compiler spills. Loose a
+// Use less registers to load A elements to workaround compiler spills. Lose a
 // bit of performance (less than ~2%).
 #define EIGEN_ARCH_AVX512_GEMM_KERNEL_USE_LESS_A_REGS
 #endif
@@ -142,7 +144,7 @@
 
   template <int nelems>
   EIGEN_ALWAYS_INLINE void c_store(Scalar* mem, vec& src) {
-    if (is_unit_inc) {
+    EIGEN_IF_CONSTEXPR (is_unit_inc) {
       switch (nelems * sizeof(*mem) * 8) {
         default:
         case 512 * 3:
@@ -197,7 +199,7 @@
 
   template <int nelems>
   EIGEN_ALWAYS_INLINE void vaddm(vec& dst, const Scalar* mem, vec& src, vec& reg) {
-    if (is_unit_inc) {
+    EIGEN_IF_CONSTEXPR (is_unit_inc) {
       switch (nelems * sizeof(*mem) * 8) {
         default:
         case 512 * 3:
@@ -249,7 +251,7 @@
           dst = preinterpret<vec>(padd(preinterpret<vec_xmm>(src), preinterpret<vec_xmm>(reg)));
           break;
         case 64 * 1:
-          if (is_f32) {
+          EIGEN_IF_CONSTEXPR (is_f32) {
             reg = pgather(reg, mem, inc, mask);
             dst = preinterpret<vec>(padd(preinterpret<vec_xmm>(src), preinterpret<vec_xmm>(reg)));
           } else {
@@ -274,7 +276,7 @@
 
   template <int nelems>
   EIGEN_ALWAYS_INLINE void vfmaddm(vec& dst, const Scalar* mem, vec& src, vec& scale, vec& reg) {
-    if (is_unit_inc) {
+    EIGEN_IF_CONSTEXPR (is_unit_inc) {
       switch (nelems * sizeof(*mem) * 8) {
         default:
         case 512 * 3:
@@ -332,7 +334,7 @@
               pmadd(preinterpret<vec_xmm>(scale), preinterpret<vec_xmm>(src), preinterpret<vec_xmm>(reg)));
           break;
         case 64 * 1:
-          if (is_f32) {
+          EIGEN_IF_CONSTEXPR (is_f32) {
             reg = pgather(reg, mem, inc, mask);
             dst = preinterpret<vec>(
                 pmadd(preinterpret<vec_xmm>(scale), preinterpret<vec_xmm>(src), preinterpret<vec_xmm>(reg)));
@@ -349,31 +351,25 @@
     }
   }
 
-  template <int j, int endX, int i, int endY, int nelems>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(j > endX) || (i > endY)> a_loads(const Scalar* ao) {
-    EIGEN_UNUSED_VARIABLE(ao);
+  template <int index, int endY, int nelems>
+  EIGEN_ALWAYS_INLINE void a_load_one(const Scalar* ao) {
+    constexpr int j = index / endY;
+    constexpr int i = index % endY;
+    auto& a_reg = zmm[a_regs[i + (j % 2) * 3]];
+    const Scalar* a_addr = ao + nelems * j + nelems_in_cache_line * i - a_shift;
+    a_load<nelems>(a_reg, a_addr);
+  }
+
+  template <int endY, int nelems, int... indices>
+  EIGEN_ALWAYS_INLINE void a_loads_impl(std::integer_sequence<int, indices...>, const Scalar* ao) {
+    int unused[] = {0, (a_load_one<indices, endY, nelems>(ao), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <int j, int endX, int i, int endY, int nelems>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(j <= endX) && (i <= endY)> a_loads(const Scalar* ao) {
-    if (j < endX) {
-      if (i < endY) {
-        auto& a_reg = zmm[a_regs[i + (j % 2) * 3]];
-        const Scalar* a_addr = ao + nelems * j + nelems_in_cache_line * i - a_shift;
-        a_load<nelems>(a_reg, a_addr);
-
-        a_loads<j, endX, i + 1, endY, nelems>(ao);
-      } else {
-        a_loads<j + 1, endX, 0, endY, nelems>(ao);
-      }
-    }
-  }
-
-  template <int un, int max_b_unroll, int i, int um_vecs, int a_unroll, int b_unroll>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(un > max_b_unroll) || (i > um_vecs)> prefetch_cs(const Scalar* co1,
-                                                                                         const Scalar* co2) {
-    EIGEN_UNUSED_VARIABLE(co1);
-    EIGEN_UNUSED_VARIABLE(co2);
+  EIGEN_ALWAYS_INLINE void a_loads(const Scalar* ao) {
+    static_assert(j == 0 && i == 0, "a_loads expects to start at zero");
+    a_loads_impl<endY, nelems>(std::make_integer_sequence<int, endX * endY>{}, ao);
   }
 
   /* C prefetch loop structure.
@@ -390,78 +386,90 @@
    * }
    */
 
-  template <int un, int max_b_unroll, int i, int um_vecs, int a_unroll, int b_unroll>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(un <= max_b_unroll) && (i <= um_vecs)> prefetch_cs(Scalar*& co1, Scalar*& co2) {
-    if (un < max_b_unroll) {
-      if (b_unroll >= un + 1) {
-        if (un == 4 && i == 0) co2 = co1 + 4 * ldc;
+  template <int index, int um_vecs, int a_unroll, int b_unroll>
+  EIGEN_ALWAYS_INLINE void prefetch_c_one(Scalar*& co1, Scalar*& co2) {
+    constexpr int un = index / um_vecs;
+    constexpr int i = index % um_vecs;
 
-        if (i < um_vecs) {
-          Scalar* co = (un + 1 <= 4) ? co1 : co2;
-          auto co_off = (un % 4) * ldc + a_unroll - 1 + i * nelems_in_cache_line * sizeof *co;
-          prefetch_c(co + co_off);
-
-          prefetch_cs<un, max_b_unroll, i + 1, um_vecs, a_unroll, b_unroll>(co1, co2);
-        } else {
-          prefetch_cs<un + 1, max_b_unroll, 0, um_vecs, a_unroll, b_unroll>(co1, co2);
-        }
-
-      } else {
-        prefetch_cs<un + 1, max_b_unroll, 0, um_vecs, a_unroll, b_unroll>(co1, co2);
+    EIGEN_IF_CONSTEXPR (b_unroll >= un + 1) {
+      EIGEN_IF_CONSTEXPR (un == 4 && i == 0) {
+        co2 = co1 + 4 * ldc;
       }
+
+      Scalar* co = (un + 1 <= 4) ? co1 : co2;
+      auto co_off = (un % 4) * ldc + a_unroll - 1 + i * nelems_in_cache_line * sizeof *co;
+      prefetch_c(co + co_off);
     }
   }
 
+  template <int um_vecs, int a_unroll, int b_unroll, int... indices>
+  EIGEN_ALWAYS_INLINE void prefetch_cs_impl(std::integer_sequence<int, indices...>, Scalar*& co1, Scalar*& co2) {
+    int unused[] = {0, (prefetch_c_one<indices, um_vecs, a_unroll, b_unroll>(co1, co2), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  template <int un, int max_b_unroll, int i, int um_vecs, int a_unroll, int b_unroll>
+  EIGEN_ALWAYS_INLINE void prefetch_cs(Scalar*& co1, Scalar*& co2) {
+    static_assert(un == 0 && i == 0, "prefetch_cs expects to start at zero");
+    prefetch_cs_impl<um_vecs, a_unroll, b_unroll>(std::make_integer_sequence<int, max_b_unroll * um_vecs>{}, co1, co2);
+  }
+
   // load_c
-  template <int i, int um_vecs, int idx, int nelems>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(i > um_vecs)> scale_load_c(const Scalar* cox, vec& alpha_reg) {
-    EIGEN_UNUSED_VARIABLE(cox);
-    EIGEN_UNUSED_VARIABLE(alpha_reg);
+  template <int i, int idx, int nelems>
+  EIGEN_ALWAYS_INLINE void scale_load_c_one(const Scalar* cox, vec& alpha_reg) {
+    auto& c_reg = zmm[c_regs[i + idx * 3]];
+    auto& c_load_reg = zmm[c_load_regs[i % 3]];
+    auto c_mem = cox;
+    EIGEN_IF_CONSTEXPR (is_unit_inc)
+      c_mem += i * nelems_in_cache_line;
+    else
+      c_mem += i * nelems_in_cache_line * inc;
+
+    if (!is_beta0 && is_alpha1)
+      vaddm<nelems>(c_reg, c_mem, c_reg, c_load_reg);
+    else if (!is_beta0 && !is_alpha1)
+      vfmaddm<nelems>(c_reg, c_mem, c_reg, alpha_reg, c_load_reg);
+    else if (is_beta0 && !is_alpha1)
+      c_reg = pmul(alpha_reg, c_reg);
+  }
+
+  template <int start, int idx, int nelems, int... indices>
+  EIGEN_ALWAYS_INLINE void scale_load_c_impl(std::integer_sequence<int, indices...>, const Scalar* cox,
+                                             vec& alpha_reg) {
+    int unused[] = {0, (scale_load_c_one<start + indices, idx, nelems>(cox, alpha_reg), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <int i, int um_vecs, int idx, int nelems>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(i <= um_vecs)> scale_load_c(const Scalar* cox, vec& alpha_reg) {
-    if (i < um_vecs) {
-      auto& c_reg = zmm[c_regs[i + idx * 3]];
-      auto& c_load_reg = zmm[c_load_regs[i % 3]];
-      auto c_mem = cox;
-      if (is_unit_inc)
-        c_mem += i * nelems_in_cache_line;
-      else
-        c_mem += i * nelems_in_cache_line * inc;
-
-      if (!is_beta0 && is_alpha1)
-        vaddm<nelems>(c_reg, c_mem, c_reg, c_load_reg);
-      else if (!is_beta0 && !is_alpha1)
-        vfmaddm<nelems>(c_reg, c_mem, c_reg, alpha_reg, c_load_reg);
-      else if (is_beta0 && !is_alpha1)
-        c_reg = pmul(alpha_reg, c_reg);
-
-      scale_load_c<i + 1, um_vecs, idx, nelems>(cox, alpha_reg);
-    }
+  EIGEN_ALWAYS_INLINE void scale_load_c(const Scalar* cox, vec& alpha_reg) {
+    static_assert(i <= um_vecs, "invalid C load range");
+    scale_load_c_impl<i, idx, nelems>(std::make_integer_sequence<int, um_vecs - i>{}, cox, alpha_reg);
   }
 
   // store_c
-  template <int i, int um_vecs, int idx, int nelems>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(i > um_vecs)> write_c(Scalar* cox) {
-    EIGEN_UNUSED_VARIABLE(cox);
+  template <int i, int idx, int nelems>
+  EIGEN_ALWAYS_INLINE void write_c_one(Scalar* cox) {
+    auto& c_reg = zmm[c_regs[i + idx * 3]];
+    auto c_mem = cox;
+    EIGEN_IF_CONSTEXPR (is_unit_inc)
+      c_mem += i * nelems_in_cache_line;
+    else
+      c_mem += i * nelems_in_cache_line * inc;
+
+    c_store<nelems>(c_mem, c_reg);
+    c_reg = pzero(c_reg);
+  }
+
+  template <int start, int idx, int nelems, int... indices>
+  EIGEN_ALWAYS_INLINE void write_c_impl(std::integer_sequence<int, indices...>, Scalar* cox) {
+    int unused[] = {0, (write_c_one<start + indices, idx, nelems>(cox), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <int i, int um_vecs, int idx, int nelems>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(i <= um_vecs)> write_c(Scalar* cox) {
-    if (i < um_vecs) {
-      auto& c_reg = zmm[c_regs[i + idx * 3]];
-      auto c_mem = cox;
-      if (is_unit_inc)
-        c_mem += i * nelems_in_cache_line;
-      else
-        c_mem += i * nelems_in_cache_line * inc;
-
-      c_store<nelems>(c_mem, c_reg);
-      c_reg = pzero(c_reg);
-
-      write_c<i + 1, um_vecs, idx, nelems>(cox);
-    }
+  EIGEN_ALWAYS_INLINE void write_c(Scalar* cox) {
+    static_assert(i <= um_vecs, "invalid C store range");
+    write_c_impl<i, idx, nelems>(std::make_integer_sequence<int, um_vecs - i>{}, cox);
   }
 
   /*  C update loop structure.
@@ -496,7 +504,9 @@
 
   template <int pow, int a_unroll, int idx>
   EIGEN_ALWAYS_INLINE void c_update_1count(Scalar*& cox) {
-    if (pow >= 4) cox += ldc;
+    EIGEN_IF_CONSTEXPR (pow >= 4) {
+      cox += ldc;
+    }
 
     const int um_vecs = numext::div_ceil(a_unroll, nelems_in_cache_line);
     auto& alpha_reg = zmm[alpha_load_reg];
@@ -513,10 +523,18 @@
     constexpr int max_count = (pow + 1) / 2;
     static_assert(max_count <= 4, "Unsupported max_count.");
 
-    if (1 <= max_count) c_update_1count<pow, a_unroll, idx + 0>(cox);
-    if (2 <= max_count) c_update_1count<pow, a_unroll, idx + 1>(cox);
-    if (3 <= max_count) c_update_1count<pow, a_unroll, idx + 2>(cox);
-    if (4 <= max_count) c_update_1count<pow, a_unroll, idx + 3>(cox);
+    EIGEN_IF_CONSTEXPR (1 <= max_count) {
+      c_update_1count<pow, a_unroll, idx + 0>(cox);
+    }
+    EIGEN_IF_CONSTEXPR (2 <= max_count) {
+      c_update_1count<pow, a_unroll, idx + 1>(cox);
+    }
+    EIGEN_IF_CONSTEXPR (3 <= max_count) {
+      c_update_1count<pow, a_unroll, idx + 2>(cox);
+    }
+    EIGEN_IF_CONSTEXPR (4 <= max_count) {
+      c_update_1count<pow, a_unroll, idx + 3>(cox);
+    }
   }
 
   template <int max_b_unroll, int a_unroll, int b_unroll>
@@ -524,119 +542,137 @@
     auto& alpha_reg = zmm[alpha_load_reg];
 
     co2 = co1 + ldc;
-    if (!is_alpha1) alpha_reg = pload1<vec>(alpha);
-    if (!is_unit_inc && a_unroll < nelems_in_cache_line) mask = static_cast<umask_t>((1ull << a_unroll) - 1);
+    if (!is_alpha1) {
+      alpha_reg = pload1<vec>(alpha);
+    }
+    EIGEN_IF_CONSTEXPR (!is_unit_inc && a_unroll < nelems_in_cache_line) {
+      mask = static_cast<umask_t>((1ull << a_unroll) - 1);
+    }
 
     static_assert(max_b_unroll <= 8, "Unsupported max_b_unroll");
 
-    if (1 <= max_b_unroll && 1 <= b_unroll) c_update_1pow<1, a_unroll>(co1, co2);
-    if (2 <= max_b_unroll && 2 <= b_unroll) c_update_1pow<2, a_unroll>(co1, co2);
-    if (4 <= max_b_unroll && 4 <= b_unroll) c_update_1pow<4, a_unroll>(co1, co2);
-    if (8 <= max_b_unroll && 8 <= b_unroll) c_update_1pow<8, a_unroll>(co1, co2);
+    EIGEN_IF_CONSTEXPR (1 <= max_b_unroll && 1 <= b_unroll) {
+      c_update_1pow<1, a_unroll>(co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (2 <= max_b_unroll && 2 <= b_unroll) {
+      c_update_1pow<2, a_unroll>(co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (4 <= max_b_unroll && 4 <= b_unroll) {
+      c_update_1pow<4, a_unroll>(co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (8 <= max_b_unroll && 8 <= b_unroll) {
+      c_update_1pow<8, a_unroll>(co1, co2);
+    }
 
-    if (b_unroll == 1)
+    EIGEN_IF_CONSTEXPR (b_unroll == 1)
       co1 += ldc;
     else
       co1 = co2 + ldc;
   }
 
   // compute
-  template <int um, int um_vecs, int idx, int uk, bool fetch_x, bool ktail>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(um > um_vecs)> compute(const Scalar* ao, const Scalar* bo, int& fetchA_idx,
-                                                               int& fetchB_idx, vec& b_reg) {
-    EIGEN_UNUSED_VARIABLE(ao);
-    EIGEN_UNUSED_VARIABLE(bo);
-    EIGEN_UNUSED_VARIABLE(fetchA_idx);
-    EIGEN_UNUSED_VARIABLE(fetchB_idx);
-    EIGEN_UNUSED_VARIABLE(b_reg);
+  template <int um, int idx, int uk, bool fetch_x, bool ktail>
+  EIGEN_ALWAYS_INLINE void compute_one(const Scalar* ao, const Scalar* bo, int& fetchA_idx, int& fetchB_idx,
+                                       vec& b_reg) {
+    auto& c_reg = zmm[c_regs[um + idx * 3]];
+    auto& a_reg = zmm[a_regs[um + (uk % 2) * 3]];
+
+    vfmadd(c_reg, a_reg, b_reg);
+
+    EIGEN_IF_CONSTEXPR (!fetch_x && um == 0 &&
+                        (((idx == 0 || idx == 6) && (uk % 2 == 0 || is_f64 || ktail)) ||
+                         (idx == 3 && (uk % 2 == 1 || is_f64 || ktail)))) {
+      prefetch_a(ao + nelems_in_cache_line * fetchA_idx);
+      fetchA_idx++;
+    }
+
+    EIGEN_IF_CONSTEXPR (um == 0 && idx == 1 && (uk % 2 == 0 || is_f64 || ktail)) {
+      prefetch_b(bo + nelems_in_cache_line * fetchB_idx);
+      fetchB_idx++;
+    }
+  }
+
+  template <int start, int idx, int uk, bool fetch_x, bool ktail, int... indices>
+  EIGEN_ALWAYS_INLINE void compute_impl(std::integer_sequence<int, indices...>, const Scalar* ao, const Scalar* bo,
+                                        int& fetchA_idx, int& fetchB_idx, vec& b_reg) {
+    int unused[] = {
+        0, (compute_one<start + indices, idx, uk, fetch_x, ktail>(ao, bo, fetchA_idx, fetchB_idx, b_reg), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  template <int um, int uk, int nelems, bool ktail>
+  EIGEN_ALWAYS_INLINE void load_a_one(const Scalar* ao) {
+    auto& a_reg = zmm[a_regs[um + (uk % 2) * 3]];
+    const Scalar* a_addr = ao + nelems * (1 + !ktail * !use_less_a_regs + uk) + nelems_in_cache_line * um - a_shift;
+    a_load<nelems>(a_reg, a_addr);
   }
 
   template <int um, int um_vecs, int idx, int uk, bool fetch_x, bool ktail>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(um <= um_vecs)> compute(const Scalar* ao, const Scalar* bo, int& fetchA_idx,
-                                                                int& fetchB_idx, vec& b_reg) {
-    if (um < um_vecs) {
-      auto& c_reg = zmm[c_regs[um + idx * 3]];
-      auto& a_reg = zmm[a_regs[um + (uk % 2) * 3]];
-
-      vfmadd(c_reg, a_reg, b_reg);
-
-      if (!fetch_x && um == 0 &&
-          (((idx == 0 || idx == 6) && (uk % 2 == 0 || is_f64 || ktail)) ||
-           (idx == 3 && (uk % 2 == 1 || is_f64 || ktail)))) {
-        prefetch_a(ao + nelems_in_cache_line * fetchA_idx);
-        fetchA_idx++;
-      }
-
-      if (um == 0 && idx == 1 && (uk % 2 == 0 || is_f64 || ktail)) {
-        prefetch_b(bo + nelems_in_cache_line * fetchB_idx);
-        fetchB_idx++;
-      }
-
-      compute<um + 1, um_vecs, idx, uk, fetch_x, ktail>(ao, bo, fetchA_idx, fetchB_idx, b_reg);
-    }
+  EIGEN_ALWAYS_INLINE void compute(const Scalar* ao, const Scalar* bo, int& fetchA_idx, int& fetchB_idx, vec& b_reg) {
+    static_assert(um <= um_vecs, "invalid compute range");
+    compute_impl<um, idx, uk, fetch_x, ktail>(std::make_integer_sequence<int, um_vecs - um>{}, ao, bo, fetchA_idx,
+                                              fetchB_idx, b_reg);
   }
 
   // load_a
-  template <int um, int um_vecs, int uk, int nelems, bool ktail>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(um > um_vecs)> load_a(const Scalar* ao) {
-    EIGEN_UNUSED_VARIABLE(ao);
+  template <int start, int uk, int nelems, bool ktail, int... indices>
+  EIGEN_ALWAYS_INLINE void load_a_impl(std::integer_sequence<int, indices...>, const Scalar* ao) {
+    int unused[] = {0, (load_a_one<start + indices, uk, nelems, ktail>(ao), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <int um, int um_vecs, int uk, int nelems, bool ktail>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(um <= um_vecs)> load_a(const Scalar* ao) {
-    if (um < um_vecs) {
-      auto& a_reg = zmm[a_regs[um + (uk % 2) * 3]];
-      const Scalar* a_addr = ao + nelems * (1 + !ktail * !use_less_a_regs + uk) + nelems_in_cache_line * um - a_shift;
-      a_load<nelems>(a_reg, a_addr);
-
-      load_a<um + 1, um_vecs, uk, nelems, ktail>(ao);
-    }
-  }
-  template <int uk, int pow, int count, int um_vecs, int b_unroll, bool ktail, bool fetch_x, bool c_fetch>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(count > (pow + 1) / 2)> innerkernel_1pow(const Scalar*& aa,
-                                                                                 const Scalar* const& ao,
-                                                                                 const Scalar* const& bo, Scalar*& co2,
-                                                                                 int& fetchA_idx, int& fetchB_idx) {
-    EIGEN_UNUSED_VARIABLE(aa);
-    EIGEN_UNUSED_VARIABLE(ao);
-    EIGEN_UNUSED_VARIABLE(bo);
-    EIGEN_UNUSED_VARIABLE(co2);
-    EIGEN_UNUSED_VARIABLE(fetchA_idx);
-    EIGEN_UNUSED_VARIABLE(fetchB_idx);
+  EIGEN_ALWAYS_INLINE void load_a(const Scalar* ao) {
+    static_assert(um <= um_vecs, "invalid A load range");
+    load_a_impl<um, uk, nelems, ktail>(std::make_integer_sequence<int, um_vecs - um>{}, ao);
   }
 
-  template <int uk, int pow, int count, int um_vecs, int b_unroll, bool ktail, bool fetch_x, bool c_fetch>
-  EIGEN_ALWAYS_INLINE std::enable_if_t<(count <= (pow + 1) / 2)> innerkernel_1pow(const Scalar*& aa,
-                                                                                  const Scalar* const& ao,
-                                                                                  const Scalar* const& bo, Scalar*& co2,
-                                                                                  int& fetchA_idx, int& fetchB_idx) {
+  template <int uk, int pow, int count, int um_vecs, int b_unroll, bool ktail, bool fetch_x>
+  EIGEN_ALWAYS_INLINE void innerkernel_1pow_one(const Scalar*& aa, const Scalar* const& ao, const Scalar* const& bo,
+                                                int& fetchA_idx, int& fetchB_idx) {
     const int idx = (pow / 2) + count;
 
-    if (count < (pow + 1) / 2) {
-      auto& b_reg = zmm[b_regs[idx % 2]];
+    auto& b_reg = zmm[b_regs[idx % 2]];
 
-      if (fetch_x && uk == 3 && idx == 0) prefetch_x(aa);
-      if (fetch_x && uk == 3 && idx == 4) aa += 8;
+    EIGEN_IF_CONSTEXPR (fetch_x && uk == 3 && idx == 0) {
+      prefetch_x(aa);
+    }
+    EIGEN_IF_CONSTEXPR (fetch_x && uk == 3 && idx == 4) {
+      aa += 8;
+    }
 
-      if (b_unroll >= pow) {
-        compute<0, um_vecs, idx, uk, fetch_x, ktail>(ao, bo, fetchA_idx, fetchB_idx, b_reg);
+    EIGEN_IF_CONSTEXPR (b_unroll >= pow) {
+      compute<0, um_vecs, idx, uk, fetch_x, ktail>(ao, bo, fetchA_idx, fetchB_idx, b_reg);
 
-        const Scalar* b_addr = bo + b_unroll * uk + idx + 1 + (b_unroll > 1) * !use_less_b_regs - b_shift;
-        b_load(b_reg, b_addr);
-      }
+      const Scalar* b_addr = bo + b_unroll * uk + idx + 1 + (b_unroll > 1) * !use_less_b_regs - b_shift;
+      b_load(b_reg, b_addr);
+    }
+  }
 
-      // Go to the next count.
-      innerkernel_1pow<uk, pow, count + 1, um_vecs, b_unroll, ktail, fetch_x, c_fetch>(aa, ao, bo, co2, fetchA_idx,
-                                                                                       fetchB_idx);
+  template <int uk, int pow, int count, int um_vecs, int b_unroll, bool ktail, bool fetch_x, int... indices>
+  EIGEN_ALWAYS_INLINE void innerkernel_1pow_impl(std::integer_sequence<int, indices...>, const Scalar*& aa,
+                                                 const Scalar* const& ao, const Scalar* const& bo, int& fetchA_idx,
+                                                 int& fetchB_idx) {
+    int unused[] = {0, (innerkernel_1pow_one<uk, pow, count + indices, um_vecs, b_unroll, ktail, fetch_x>(
+                            aa, ao, bo, fetchA_idx, fetchB_idx),
+                        0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
 
-    } else {
-      // Maybe prefetch C data after count-loop.
-      if (pow == 2 && c_fetch) {
-        if (uk % 3 == 0 && uk > 0) {
-          co2 += ldc;
-        } else {
-          prefetch_c(co2 + (uk % 3) * nelems_in_cache_line);
-        }
+  template <int uk, int pow, int count, int um_vecs, int b_unroll, bool ktail, bool fetch_x, bool c_fetch>
+  EIGEN_ALWAYS_INLINE void innerkernel_1pow(const Scalar*& aa, const Scalar* const& ao, const Scalar* const& bo,
+                                            Scalar*& co2, int& fetchA_idx, int& fetchB_idx) {
+    constexpr int max_count = (pow + 1) / 2;
+    static_assert(count <= max_count, "invalid B load range");
+    innerkernel_1pow_impl<uk, pow, count, um_vecs, b_unroll, ktail, fetch_x>(
+        std::make_integer_sequence<int, max_count - count>{}, aa, ao, bo, fetchA_idx, fetchB_idx);
+
+    // Maybe prefetch C data after count-loop.
+    EIGEN_IF_CONSTEXPR (pow == 2 && c_fetch) {
+      EIGEN_IF_CONSTEXPR (uk % 3 == 0 && uk > 0) {
+        co2 += ldc;
+      } else {
+        prefetch_c(co2 + (uk % 3) * nelems_in_cache_line);
       }
     }
   }
@@ -647,13 +683,13 @@
                                            Scalar*& co2, int& fetchA_idx, int& fetchB_idx) {
     const int um_vecs = numext::div_ceil(a_unroll, nelems_in_cache_line);
 
-    if (max_b_unroll >= 1)
+    EIGEN_IF_CONSTEXPR (max_b_unroll >= 1)
       innerkernel_1pow<uk, 1, 0, um_vecs, b_unroll, ktail, fetch_x, c_fetch>(aa, ao, bo, co2, fetchA_idx, fetchB_idx);
-    if (max_b_unroll >= 2)
+    EIGEN_IF_CONSTEXPR (max_b_unroll >= 2)
       innerkernel_1pow<uk, 2, 0, um_vecs, b_unroll, ktail, fetch_x, c_fetch>(aa, ao, bo, co2, fetchA_idx, fetchB_idx);
-    if (max_b_unroll >= 4)
+    EIGEN_IF_CONSTEXPR (max_b_unroll >= 4)
       innerkernel_1pow<uk, 4, 0, um_vecs, b_unroll, ktail, fetch_x, c_fetch>(aa, ao, bo, co2, fetchA_idx, fetchB_idx);
-    if (max_b_unroll >= 8)
+    EIGEN_IF_CONSTEXPR (max_b_unroll >= 8)
       innerkernel_1pow<uk, 8, 0, um_vecs, b_unroll, ktail, fetch_x, c_fetch>(aa, ao, bo, co2, fetchA_idx, fetchB_idx);
 
     // Load A after pow-loop. Skip this at the end to prevent running over the buffer
@@ -733,13 +769,19 @@
   template <int a_unroll, int b_unroll, int max_b_unroll>
   EIGEN_ALWAYS_INLINE void kloop(const Scalar*& aa, const Scalar*& ao, const Scalar*& bo, Scalar*& co1, Scalar*& co2) {
     const int um_vecs = numext::div_ceil(a_unroll, nelems_in_cache_line);
-    if (!use_less_a_regs && k > 1)
-      a_loads<0, 2, 0, um_vecs, a_unroll>(ao);
-    else
+    EIGEN_IF_CONSTEXPR (!use_less_a_regs) {
+      if (k > 1)
+        a_loads<0, 2, 0, um_vecs, a_unroll>(ao);
+      else
+        a_loads<0, 1, 0, um_vecs, a_unroll>(ao);
+    } else {
       a_loads<0, 1, 0, um_vecs, a_unroll>(ao);
+    }
 
     b_load(zmm[b_regs[0]], bo - b_shift + 0);
-    if (!use_less_b_regs) b_load(zmm[b_regs[1]], bo - b_shift + 1);
+    EIGEN_IF_CONSTEXPR (!use_less_b_regs) {
+      b_load(zmm[b_regs[1]], bo - b_shift + 1);
+    }
 
 #ifndef SECOND_FETCH
     prefetch_cs<0, max_b_unroll, 0, um_vecs, a_unroll, b_unroll>(co1, co2);
@@ -819,7 +861,7 @@
     // Set C matrix pointers.
     co1 = c;
     if (a_unroll >= max_a_unroll) co2 = c + 2 * ldc;
-    if (is_unit_inc)
+    EIGEN_IF_CONSTEXPR (is_unit_inc)
       c += a_unroll;
     else
       c += a_unroll * inc;
@@ -860,16 +902,29 @@
     for (; m >= max_a_unroll; m -= max_a_unroll) mloop<max_a_unroll, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
 
     // m-remainders.
-    if (m & 32 && max_a_unroll > 32) mloop<32, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
-    if (m & 16 && max_a_unroll > 16) mloop<16, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
-    if (m & 8 && max_a_unroll > 8) mloop<8, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
-    if (m & 4 && max_a_unroll > 4) mloop<4, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
-    if (m & 2 && max_a_unroll > 2 && is_f64) mloop<2, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
-    if (m & 1 && max_a_unroll > 1 && is_f64) mloop<1, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    EIGEN_IF_CONSTEXPR (max_a_unroll > 32 && is_f32) {
+      constexpr int a_unroll32 = is_f32 ? 32 : 24;
+      if (m & 32) mloop<a_unroll32, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (max_a_unroll > 16) {
+      if (m & 16) mloop<16, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (max_a_unroll > 8) {
+      if (m & 8) mloop<8, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (max_a_unroll > 4) {
+      if (m & 4) mloop<4, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (max_a_unroll > 2 && is_f64) {
+      if (m & 2) mloop<2, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    }
+    EIGEN_IF_CONSTEXPR (max_a_unroll > 1 && is_f64) {
+      if (m & 1) mloop<1, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
+    }
 
     // Copy kernels don't support tails of m = 2 for single precision.
     // Loop over ones.
-    if (is_f32) {
+    EIGEN_IF_CONSTEXPR (is_f32) {
       int m_rem = 2 * ((m & 2) != 0) + 1 * ((m & 1) != 0);
       while (m_rem > 0) {
         mloop<1, max_a_unroll, max_b_unroll>(ao, bo, co1, co2);
@@ -993,10 +1048,10 @@
   Index packet_cols4 = nr >= 4 ? (cols / 4) * 4 : 0;
   Index count = 0;
   const Index peeled_k = (depth / PacketSize) * PacketSize;
-  if (nr >= 8) {
+  EIGEN_IF_CONSTEXPR (nr >= 8) {
     for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
       // skip what we have before
-      if (PanelMode) count += 8 * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * offset;
       const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
       const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
       const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
@@ -1006,10 +1061,9 @@
       const LinearMapper dm6 = rhs.getLinearMapper(0, j2 + 6);
       const LinearMapper dm7 = rhs.getLinearMapper(0, j2 + 7);
       Index k = 0;
-      if ((PacketSize % 8) == 0)  // TODO enable vectorized transposition for PacketSize==4
-      {
+      EIGEN_IF_CONSTEXPR ((PacketSize % 8) == 0 || PacketSize == 4) {
         for (; k < peeled_k; k += PacketSize) {
-          PacketBlock<Packet, (PacketSize % 8) == 0 ? 8 : PacketSize> kernel;
+          PacketBlock<Packet, 8> kernel;
 
           kernel.packet[0] = dm0.template loadPacket<Packet>(k);
           kernel.packet[1] = dm1.template loadPacket<Packet>(k);
@@ -1020,16 +1074,42 @@
           kernel.packet[6] = dm6.template loadPacket<Packet>(k);
           kernel.packet[7] = dm7.template loadPacket<Packet>(k);
 
-          ptranspose(kernel);
+          EIGEN_IF_CONSTEXPR (PacketSize == 4) {
+            // For PacketSize==4 we cannot ptranspose 8 packets directly; compose two
+            // 4-packet transposes (cols 0-3 and 4-7) and interleave the halves so
+            // the 8 stores produce 4 rows of 8 packed elements.
+            PacketBlock<Packet, 4> tmp_lo;
+            tmp_lo.packet[0] = kernel.packet[0];
+            tmp_lo.packet[1] = kernel.packet[1];
+            tmp_lo.packet[2] = kernel.packet[2];
+            tmp_lo.packet[3] = kernel.packet[3];
+            ptranspose(tmp_lo);
+            PacketBlock<Packet, 4> tmp_hi;
+            tmp_hi.packet[0] = kernel.packet[4];
+            tmp_hi.packet[1] = kernel.packet[5];
+            tmp_hi.packet[2] = kernel.packet[6];
+            tmp_hi.packet[3] = kernel.packet[7];
+            ptranspose(tmp_hi);
+            kernel.packet[0] = tmp_lo.packet[0];
+            kernel.packet[1] = tmp_hi.packet[0];
+            kernel.packet[2] = tmp_lo.packet[1];
+            kernel.packet[3] = tmp_hi.packet[1];
+            kernel.packet[4] = tmp_lo.packet[2];
+            kernel.packet[5] = tmp_hi.packet[2];
+            kernel.packet[6] = tmp_lo.packet[3];
+            kernel.packet[7] = tmp_hi.packet[3];
+          } else {
+            ptranspose(kernel);
+          }
 
           pstoreu(blockB + count + 0 * PacketSize, cj.pconj(kernel.packet[0]));
-          pstoreu(blockB + count + 1 * PacketSize, cj.pconj(kernel.packet[1 % PacketSize]));
-          pstoreu(blockB + count + 2 * PacketSize, cj.pconj(kernel.packet[2 % PacketSize]));
-          pstoreu(blockB + count + 3 * PacketSize, cj.pconj(kernel.packet[3 % PacketSize]));
-          pstoreu(blockB + count + 4 * PacketSize, cj.pconj(kernel.packet[4 % PacketSize]));
-          pstoreu(blockB + count + 5 * PacketSize, cj.pconj(kernel.packet[5 % PacketSize]));
-          pstoreu(blockB + count + 6 * PacketSize, cj.pconj(kernel.packet[6 % PacketSize]));
-          pstoreu(blockB + count + 7 * PacketSize, cj.pconj(kernel.packet[7 % PacketSize]));
+          pstoreu(blockB + count + 1 * PacketSize, cj.pconj(kernel.packet[1]));
+          pstoreu(blockB + count + 2 * PacketSize, cj.pconj(kernel.packet[2]));
+          pstoreu(blockB + count + 3 * PacketSize, cj.pconj(kernel.packet[3]));
+          pstoreu(blockB + count + 4 * PacketSize, cj.pconj(kernel.packet[4]));
+          pstoreu(blockB + count + 5 * PacketSize, cj.pconj(kernel.packet[5]));
+          pstoreu(blockB + count + 6 * PacketSize, cj.pconj(kernel.packet[6]));
+          pstoreu(blockB + count + 7 * PacketSize, cj.pconj(kernel.packet[7]));
           count += 8 * PacketSize;
         }
       }
@@ -1045,33 +1125,48 @@
         count += 8;
       }
       // skip what we have after
-      if (PanelMode) count += 8 * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * (stride - offset - depth);
     }
   }
 
-  if (nr >= 4) {
+  EIGEN_IF_CONSTEXPR (nr >= 4) {
     for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
       // skip what we have before
-      if (PanelMode) count += 4 * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * offset;
       const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
       const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
       const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
       const LinearMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
 
       Index k = 0;
-      if ((PacketSize % 4) == 0)  // TODO: enable vectorized transposition for PacketSize==2.
-      {
+      EIGEN_IF_CONSTEXPR ((PacketSize % 4) == 0 || PacketSize == 2) {
         for (; k < peeled_k; k += PacketSize) {
-          PacketBlock<Packet, (PacketSize % 4) == 0 ? 4 : PacketSize> kernel;
+          PacketBlock<Packet, 4> kernel;
           kernel.packet[0] = dm0.template loadPacket<Packet>(k);
-          kernel.packet[1 % PacketSize] = dm1.template loadPacket<Packet>(k);
-          kernel.packet[2 % PacketSize] = dm2.template loadPacket<Packet>(k);
-          kernel.packet[3 % PacketSize] = dm3.template loadPacket<Packet>(k);
-          ptranspose(kernel);
+          kernel.packet[1] = dm1.template loadPacket<Packet>(k);
+          kernel.packet[2] = dm2.template loadPacket<Packet>(k);
+          kernel.packet[3] = dm3.template loadPacket<Packet>(k);
+          EIGEN_IF_CONSTEXPR (PacketSize == 2) {
+            // See the matching note in GeneralBlockPanelKernel.h.
+            PacketBlock<Packet, 2> tmp01;
+            tmp01.packet[0] = kernel.packet[0];
+            tmp01.packet[1] = kernel.packet[1];
+            ptranspose(tmp01);
+            PacketBlock<Packet, 2> tmp23;
+            tmp23.packet[0] = kernel.packet[2];
+            tmp23.packet[1] = kernel.packet[3];
+            ptranspose(tmp23);
+            kernel.packet[0] = tmp01.packet[0];
+            kernel.packet[1] = tmp23.packet[0];
+            kernel.packet[2] = tmp01.packet[1];
+            kernel.packet[3] = tmp23.packet[1];
+          } else {
+            ptranspose(kernel);
+          }
           pstoreu(blockB + count + 0 * PacketSize, cj.pconj(kernel.packet[0]));
-          pstoreu(blockB + count + 1 * PacketSize, cj.pconj(kernel.packet[1 % PacketSize]));
-          pstoreu(blockB + count + 2 * PacketSize, cj.pconj(kernel.packet[2 % PacketSize]));
-          pstoreu(blockB + count + 3 * PacketSize, cj.pconj(kernel.packet[3 % PacketSize]));
+          pstoreu(blockB + count + 1 * PacketSize, cj.pconj(kernel.packet[1]));
+          pstoreu(blockB + count + 2 * PacketSize, cj.pconj(kernel.packet[2]));
+          pstoreu(blockB + count + 3 * PacketSize, cj.pconj(kernel.packet[3]));
           count += 4 * PacketSize;
         }
       }
@@ -1083,19 +1178,19 @@
         count += 4;
       }
       // skip what we have after
-      if (PanelMode) count += 4 * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * (stride - offset - depth);
     }
   }
 
   // copy the remaining columns one at a time (nr==1)
   for (Index j2 = packet_cols4; j2 < cols; ++j2) {
-    if (PanelMode) count += offset;
+    EIGEN_IF_CONSTEXPR (PanelMode) count += offset;
     const LinearMapper dm0 = rhs.getLinearMapper(0, j2);
     for (Index k = 0; k < depth; k++) {
       blockB[count] = cj(dm0(k));
       count += 1;
     }
-    if (PanelMode) count += (stride - offset - depth);
+    EIGEN_IF_CONSTEXPR (PanelMode) count += (stride - offset - depth);
   }
 }
 
@@ -1117,29 +1212,29 @@
     EIGEN_UNUSED_VARIABLE(stride);
     EIGEN_UNUSED_VARIABLE(offset);
     eigen_assert(((!PanelMode) && stride == 0 && offset == 0) || (PanelMode && stride >= depth && offset <= stride));
-    const bool HasHalf = (int)HalfPacketSize < (int)PacketSize;
-    const bool HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize;
+    constexpr bool HasHalf = (int)HalfPacketSize < (int)PacketSize;
+    constexpr bool HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize;
     conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
     Index packet_cols8 = nr >= 8 ? (cols / 8) * 8 : 0;
     Index packet_cols4 = nr >= 4 ? (cols / 4) * 4 : 0;
     Index count = 0;
 
-    if (nr >= 8) {
+    EIGEN_IF_CONSTEXPR (nr >= 8) {
       for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
         // skip what we have before
-        if (PanelMode) count += 8 * offset;
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * offset;
         for (Index k = 0; k < depth; k++) {
-          if (PacketSize == 8) {
+          EIGEN_IF_CONSTEXPR (PacketSize == 8) {
             // Packet A = ploadu<Packet>(&rhs.data()[k*rhs.stride() + j2]);
             Packet A = rhs.template loadPacket<Packet>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
-          } else if (HasHalf && HalfPacketSize == 8) {
+          } else EIGEN_IF_CONSTEXPR (HasHalf && HalfPacketSize == 8) {
             HalfPacket A = rhs.template loadPacket<HalfPacket>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
-          } else if (HasQuarter && QuarterPacketSize == 8) {
+          } else EIGEN_IF_CONSTEXPR (HasQuarter && QuarterPacketSize == 8) {
             QuarterPacket A = rhs.template loadPacket<QuarterPacket>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
-          } else if (PacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (PacketSize == 4) {
             // Packet A = ploadu<Packet>(&rhs.data()[k*rhs.stride() + j2]);
             // Packet B = ploadu<Packet>(&rhs.data()[k*rhs.stride() + j2 + PacketSize]);
             Packet A = rhs.template loadPacket<Packet>(k, j2);
@@ -1161,24 +1256,24 @@
           count += 8;
         }
         // skip what we have after
-        if (PanelMode) count += 8 * (stride - offset - depth);
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * (stride - offset - depth);
       }
     }
 
-    if (nr >= 4) {
+    EIGEN_IF_CONSTEXPR (nr >= 4) {
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         // skip what we have before
-        if (PanelMode) count += 4 * offset;
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * offset;
         for (Index k = 0; k < depth; k++) {
-          if (PacketSize == 4) {
+          EIGEN_IF_CONSTEXPR (PacketSize == 4) {
             Packet A = rhs.template loadPacket<Packet>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += PacketSize;
-          } else if (HasHalf && HalfPacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (HasHalf && HalfPacketSize == 4) {
             HalfPacket A = rhs.template loadPacket<HalfPacket>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += HalfPacketSize;
-          } else if (HasQuarter && QuarterPacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (HasQuarter && QuarterPacketSize == 4) {
             QuarterPacket A = rhs.template loadPacket<QuarterPacket>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += QuarterPacketSize;
@@ -1192,17 +1287,17 @@
           }
         }
         // skip what we have after
-        if (PanelMode) count += 4 * (stride - offset - depth);
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * (stride - offset - depth);
       }
     }
     // copy the remaining columns one at a time (nr==1)
     for (Index j2 = packet_cols4; j2 < cols; ++j2) {
-      if (PanelMode) count += offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += offset;
       for (Index k = 0; k < depth; k++) {
         blockB[count] = cj(rhs(k, j2));
         count += 1;
       }
-      if (PanelMode) count += stride - offset - depth;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += stride - offset - depth;
     }
   }
 };
diff --git a/Eigen/src/Core/arch/AVX512/MathFunctions.h b/Eigen/src/Core/arch/AVX512/MathFunctions.h
index 2499019..fc079be 100644
--- a/Eigen/src/Core/arch/AVX512/MathFunctions.h
+++ b/Eigen/src/Core/arch/AVX512/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
 #define THIRD_PARTY_EIGEN3_EIGEN_SRC_CORE_ARCH_AVX512_MATHFUNCTIONS_H_
@@ -34,9 +35,11 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf pfrexp(const Packet16bf& a, Packet16bf& exponent) {
+  // Both results are exact: the mantissa keeps the input's significand, and the exponent is a
+  // small integer.
   Packet16f fexponent;
-  const Packet16bf out = F32ToBf16(pfrexp<Packet16f>(Bf16ToF32(a), fexponent));
-  exponent = F32ToBf16(fexponent);
+  const Packet16bf out = F32ToBf16Truncate(pfrexp<Packet16f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16Truncate(fexponent);
   return out;
 }
 
diff --git a/Eigen/src/Core/arch/AVX512/MathFunctionsFP16.h b/Eigen/src/Core/arch/AVX512/MathFunctionsFP16.h
index 240ade4..48115c5 100644
--- a/Eigen/src/Core/arch/AVX512/MathFunctionsFP16.h
+++ b/Eigen/src/Core/arch/AVX512/MathFunctionsFP16.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_FP16_AVX512_H
 #define EIGEN_MATH_FUNCTIONS_FP16_AVX512_H
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index 22271e1..2596313 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_AVX512_H
 #define EIGEN_PACKET_MATH_AVX512_H
@@ -44,6 +45,12 @@
 typedef eigen_packet_wrapper<__m256i, 6> Packet16s;
 typedef eigen_packet_wrapper<__m128i, 6> Packet8s;
 
+#if EIGEN_COMP_NVHPC
+#define EIGEN_AVX512_SHUFFLE_PS(A, B, M) ((__m512)_mm512_shuffle_ps(A, B, M))
+#else
+#define EIGEN_AVX512_SHUFFLE_PS(A, B, M) _mm512_shuffle_ps(A, B, M)
+#endif
+
 EIGEN_STRONG_INLINE Packet16i _eigen_mm512_loadu_epi32(const int* from) {
 #if EIGEN_COMP_GNUC && (EIGEN_COMP_CLANG < 1000 || EIGEN_COMP_GNUC < 1010)
   return _mm512_loadu_si512(reinterpret_cast<const void*>(from));
@@ -93,27 +100,17 @@
 }
 
 template <>
-struct is_arithmetic<__m512> {
-  enum { value = true };
-};
+struct is_arithmetic<__m512> : std::true_type {};
 template <>
-struct is_arithmetic<__m512i> {
-  enum { value = true };
-};
+struct is_arithmetic<__m512i> : std::true_type {};
 template <>
-struct is_arithmetic<__m512d> {
-  enum { value = true };
-};
+struct is_arithmetic<__m512d> : std::true_type {};
 template <>
-struct is_arithmetic<Packet8l> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet8l> : std::true_type {};
 
 #ifndef EIGEN_VECTORIZE_AVX512FP16
 template <>
-struct is_arithmetic<Packet16h> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet16h> : std::true_type {};
 
 template <>
 struct packet_traits<half> : default_packet_traits {
@@ -172,10 +169,15 @@
     HasASin = 1,
     HasATan = 1,
     HasATanh = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasSqrt = 1,
     HasRsqrt = 1,
     HasCbrt = 1,
     HasLog = 1,
+    HasLog10 = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
     HasNdtri = 1,
@@ -204,7 +206,12 @@
     HasSin = EIGEN_FAST_MATH,
     HasCos = EIGEN_FAST_MATH,
     HasTan = EIGEN_FAST_MATH,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasLog = 1,
+    HasLog10 = 1,
     HasExp = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
@@ -384,7 +391,9 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet16f peven_mask(const Packet16f& /*a*/) {
-  return _mm512_castsi512_ps(_mm512_set_epi32(0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1));
+  Packet16f r = _mm512_castsi512_ps(_mm512_set_epi32(0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 template <>
 EIGEN_STRONG_INLINE Packet16i peven_mask(const Packet16i& /*a*/) {
@@ -392,7 +401,9 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet8d peven_mask(const Packet8d& /*a*/) {
-  return _mm512_castsi512_pd(_mm512_set_epi32(0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1));
+  Packet8d r = _mm512_castsi512_pd(_mm512_set_epi32(0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 0, -1, -1));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 template <>
 EIGEN_STRONG_INLINE Packet8l peven_mask(const Packet8l& /*a*/) {
@@ -512,23 +523,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet16f pconj(const Packet16f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8d pconj(const Packet8d& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet16i pconj(const Packet16i& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8l pconj(const Packet8l& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet16f pmul<Packet16f>(const Packet16f& a, const Packet16f& b) {
   return _mm512_mul_ps(a, b);
 }
@@ -702,44 +696,44 @@
 
 #ifdef EIGEN_VECTORIZE_AVX512DQ
 template <int I_>
-EIGEN_STRONG_INLINE Packet8f extract256(Packet16f x) {
+EIGEN_STRONG_INLINE Packet8f extract256(const Packet16f& x) {
   return _mm512_extractf32x8_ps(x, I_);
 }
 template <int I_>
-EIGEN_STRONG_INLINE Packet2d extract128(Packet8d x) {
+EIGEN_STRONG_INLINE Packet2d extract128(const Packet8d& x) {
   return _mm512_extractf64x2_pd(x, I_);
 }
-EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) {
+EIGEN_STRONG_INLINE Packet16f cat256(const Packet8f& a, const Packet8f& b) {
   return _mm512_insertf32x8(_mm512_castps256_ps512(a), b, 1);
 }
-EIGEN_STRONG_INLINE Packet16i cat256i(Packet8i a, Packet8i b) {
+EIGEN_STRONG_INLINE Packet16i cat256i(const Packet8i& a, const Packet8i& b) {
   return _mm512_inserti32x8(_mm512_castsi256_si512(a), b, 1);
 }
 #else
 // AVX512F does not define _mm512_extractf32x8_ps to extract _m256 from _m512
 template <int I_>
-EIGEN_STRONG_INLINE Packet8f extract256(Packet16f x) {
+EIGEN_STRONG_INLINE Packet8f extract256(const Packet16f& x) {
   return _mm256_castsi256_ps(_mm512_extracti64x4_epi64(_mm512_castps_si512(x), I_));
 }
 
 // AVX512F does not define _mm512_extractf64x2_pd to extract _m128 from _m512
 template <int I_>
-EIGEN_STRONG_INLINE Packet2d extract128(Packet8d x) {
+EIGEN_STRONG_INLINE Packet2d extract128(const Packet8d& x) {
   return _mm_castsi128_pd(_mm512_extracti32x4_epi32(_mm512_castpd_si512(x), I_));
 }
 
-EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) {
+EIGEN_STRONG_INLINE Packet16f cat256(const Packet8f& a, const Packet8f& b) {
   return _mm512_castsi512_ps(
       _mm512_inserti64x4(_mm512_castsi256_si512(_mm256_castps_si256(a)), _mm256_castps_si256(b), 1));
 }
-EIGEN_STRONG_INLINE Packet16i cat256i(Packet8i a, Packet8i b) {
+EIGEN_STRONG_INLINE Packet16i cat256i(const Packet8i& a, const Packet8i& b) {
   return _mm512_inserti64x4(_mm512_castsi256_si512(a), b, 1);
 }
 #endif
 
 // Helper function for bit packing snippet of low precision comparison.
 // It packs the flags from 32x16 to 16x16.
-EIGEN_STRONG_INLINE __m256i Pack32To16(Packet16f rf) {
+EIGEN_STRONG_INLINE __m256i Pack32To16(const Packet16f& rf) {
   // Split data into small pieces and handle with AVX instructions
   // to guarantee internal order of vector.
   // Operation:
@@ -884,12 +878,16 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet16f ptrue<Packet16f>(const Packet16f& a) {
-  return _mm512_castsi512_ps(ptrue<Packet16i>(_mm512_castps_si512(a)));
+  Packet16f r = _mm512_castsi512_ps(ptrue<Packet16i>(_mm512_castps_si512(a)));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8d ptrue<Packet8d>(const Packet8d& a) {
-  return _mm512_castsi512_pd(ptrue<Packet16i>(_mm512_castpd_si512(a)));
+  Packet8d r = _mm512_castsi512_pd(ptrue<Packet16i>(_mm512_castpd_si512(a)));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -1025,32 +1023,32 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet16i parithmetic_shift_right(Packet16i a) {
+EIGEN_STRONG_INLINE Packet16i parithmetic_shift_right(const Packet16i& a) {
   return _mm512_srai_epi32(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet16i plogical_shift_right(Packet16i a) {
+EIGEN_STRONG_INLINE Packet16i plogical_shift_right(const Packet16i& a) {
   return _mm512_srli_epi32(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet16i plogical_shift_left(Packet16i a) {
+EIGEN_STRONG_INLINE Packet16i plogical_shift_left(const Packet16i& a) {
   return _mm512_slli_epi32(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8l parithmetic_shift_right(Packet8l a) {
+EIGEN_STRONG_INLINE Packet8l parithmetic_shift_right(const Packet8l& a) {
   return _mm512_srai_epi64(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8l plogical_shift_right(Packet8l a) {
+EIGEN_STRONG_INLINE Packet8l plogical_shift_right(const Packet8l& a) {
   return _mm512_srli_epi64(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8l plogical_shift_left(Packet8l a) {
+EIGEN_STRONG_INLINE Packet8l plogical_shift_left(const Packet8l& a) {
   return _mm512_slli_epi64(a, N);
 }
 
@@ -1099,7 +1097,7 @@
   EIGEN_DEBUG_UNALIGNED_LOAD return _mm512_maskz_loadu_pd(mask, from);
 }
 
-// Loads 8 floats from memory a returns the packet
+// Loads 8 floats from memory and returns the packet
 // {a0, a0  a1, a1, a2, a2, a3, a3, a4, a4, a5, a5, a6, a6, a7, a7}
 template <>
 EIGEN_STRONG_INLINE Packet16f ploaddup<Packet16f>(const float* from) {
@@ -1111,7 +1109,7 @@
   return pairs;
 }
 
-// Loads 4 doubles from memory a returns the packet {a0, a0,  a1, a1, a2, a2, a3,
+// Loads 4 doubles from memory and returns the packet {a0, a0,  a1, a1, a2, a2, a3,
 // a3}
 template <>
 EIGEN_STRONG_INLINE Packet8d ploaddup<Packet8d>(const double* from) {
@@ -1120,7 +1118,7 @@
   return _mm512_permutexvar_pd(scatter_mask, tmp);
 }
 
-// Loads 4 int64_t from memory a returns the packet {a0, a0,  a1, a1, a2, a2, a3,
+// Loads 4 int64_t from memory and returns the packet {a0, a0,  a1, a1, a2, a2, a3,
 // a3}
 template <>
 EIGEN_STRONG_INLINE Packet8l ploaddup<Packet8l>(const int64_t* from) {
@@ -1139,7 +1137,7 @@
   return _mm512_castps_si512(pairs);
 }
 
-// Loads 4 floats from memory a returns the packet
+// Loads 4 floats from memory and returns the packet
 // {a0, a0  a0, a0, a1, a1, a1, a1, a2, a2, a2, a2, a3, a3, a3, a3}
 template <>
 EIGEN_STRONG_INLINE Packet16f ploadquad<Packet16f>(const float* from) {
@@ -1148,7 +1146,7 @@
   return _mm512_permutexvar_ps(scatter_mask, tmp);
 }
 
-// Loads 2 doubles from memory a returns the packet
+// Loads 2 doubles from memory and returns the packet
 // {a0, a0  a0, a0, a1, a1, a1, a1}
 template <>
 EIGEN_STRONG_INLINE Packet8d ploadquad<Packet8d>(const double* from) {
@@ -1159,7 +1157,7 @@
   return _mm512_insertf64x4(tmp, lane1, 1);
 }
 
-// Loads 2 int64_t from memory a returns the packet
+// Loads 2 int64_t from memory and returns the packet
 // {a0, a0  a0, a0, a1, a1, a1, a1}
 template <>
 EIGEN_STRONG_INLINE Packet8l ploadquad<Packet8l>(const int64_t* from) {
@@ -1249,6 +1247,13 @@
 
 template <>
 EIGEN_DEVICE_FUNC inline Packet16f pgather<float, Packet16f>(const float* from, Index stride) {
+  if (stride == 2) {
+    // The overlapping loads end at from[30], not the unused coefficient from[31].
+    const Packet16f low = _mm512_loadu_ps(from);
+    const Packet16f high = _mm512_loadu_ps(from + 15);
+    const Packet16i indices = _mm512_setr_epi32(0, 2, 4, 6, 8, 10, 12, 14, 17, 19, 21, 23, 25, 27, 29, 31);
+    return _mm512_permutex2var_ps(low, indices, high);
+  }
   Packet16i stride_vector = _mm512_set1_epi32(convert_index<int>(stride));
   Packet16i stride_multiplier = _mm512_set_epi32(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
   Packet16i indices = _mm512_mullo_epi32(stride_vector, stride_multiplier);
@@ -1257,6 +1262,12 @@
 }
 template <>
 EIGEN_DEVICE_FUNC inline Packet8d pgather<double, Packet8d>(const double* from, Index stride) {
+  if (stride == 2) {
+    const Packet8d low = _mm512_loadu_pd(from);
+    const Packet8d high = _mm512_loadu_pd(from + 7);
+    const __m512i indices = _mm512_setr_epi64(0, 2, 4, 6, 9, 11, 13, 15);
+    return _mm512_permutex2var_pd(low, indices, high);
+  }
   Packet8i stride_vector = _mm256_set1_epi32(convert_index<int>(stride));
   Packet8i stride_multiplier = _mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0);
   Packet8i indices = _mm256_mullo_epi32(stride_vector, stride_multiplier);
@@ -1476,26 +1487,17 @@
   const Packet8d max_exponent = pset1<Packet8d>(2099.0);
   const Packet8i e = _mm512_cvtpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
 
-  // Split 2^e into four factors and multiply.
+  // Preserve the sequential 4-way split; see pldexp_generic.
+  // 2^b and 2^(e-3b) are built by widening the biased int32 exponent to int64
+  // with vpmovsxdq and shifting into the double exponent field with vpsllq.
   const Packet8i bias = pset1<Packet8i>(1023);
-  Packet8i b = parithmetic_shift_right<2>(e);  // floor(e/4)
+  const Packet8i b = parithmetic_shift_right<2>(e);           // floor(e/4)
+  const Packet8i b_remainder = psub(psub(e, b), padd(b, b));  // e - 3b (depth 2)
+  const Packet8d c1 = _mm512_castsi512_pd(_mm512_slli_epi64(_mm512_cvtepi32_epi64(padd(b, bias)), 52));  // 2^b
+  const Packet8d c2 =
+      _mm512_castsi512_pd(_mm512_slli_epi64(_mm512_cvtepi32_epi64(padd(b_remainder, bias)), 52));  // 2^(e-3b)
 
-  // 2^b
-  const Packet8i permute_idx = _mm256_setr_epi32(0, 4, 1, 5, 2, 6, 3, 7);
-  Packet8i hi = _mm256_permutevar8x32_epi32(padd(b, bias), permute_idx);
-  Packet8i lo = _mm256_slli_epi64(hi, 52);
-  hi = _mm256_slli_epi64(_mm256_srli_epi64(hi, 32), 52);
-  Packet8d c = _mm512_castsi512_pd(_mm512_inserti64x4(_mm512_castsi256_si512(lo), hi, 1));
-  Packet8d out = pmul(pmul(pmul(a, c), c), c);  // a * 2^(3b)
-
-  // 2^(e - 3b)
-  b = psub(psub(psub(e, b), b), b);  // e - 3b
-  hi = _mm256_permutevar8x32_epi32(padd(b, bias), permute_idx);
-  lo = _mm256_slli_epi64(hi, 52);
-  hi = _mm256_slli_epi64(_mm256_srli_epi64(hi, 32), 52);
-  c = _mm512_castsi512_pd(_mm512_inserti64x4(_mm512_castsi256_si512(lo), hi, 1));
-  out = pmul(out, c);  // a * 2^e
-  return out;
+  return pmul(pmul(pmul(pmul(a, c1), c1), c1), c2);  // a * 2^e
 }
 
 #ifdef EIGEN_VECTORIZE_AVX512DQ
@@ -1610,22 +1612,22 @@
   __m512 T13 = _mm512_unpackhi_ps(kernel.packet[12], kernel.packet[13]);
   __m512 T14 = _mm512_unpacklo_ps(kernel.packet[14], kernel.packet[15]);
   __m512 T15 = _mm512_unpackhi_ps(kernel.packet[14], kernel.packet[15]);
-  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S4 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S5 = _mm512_shuffle_ps(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S6 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S7 = _mm512_shuffle_ps(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S8 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S9 = _mm512_shuffle_ps(T8, T10, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S10 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S11 = _mm512_shuffle_ps(T9, T11, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S12 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S13 = _mm512_shuffle_ps(T12, T14, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S14 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S15 = _mm512_shuffle_ps(T13, T15, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S0 = EIGEN_AVX512_SHUFFLE_PS(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = EIGEN_AVX512_SHUFFLE_PS(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = EIGEN_AVX512_SHUFFLE_PS(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = EIGEN_AVX512_SHUFFLE_PS(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S4 = EIGEN_AVX512_SHUFFLE_PS(T4, T6, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S5 = EIGEN_AVX512_SHUFFLE_PS(T4, T6, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S6 = EIGEN_AVX512_SHUFFLE_PS(T5, T7, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S7 = EIGEN_AVX512_SHUFFLE_PS(T5, T7, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S8 = EIGEN_AVX512_SHUFFLE_PS(T8, T10, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S9 = EIGEN_AVX512_SHUFFLE_PS(T8, T10, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S10 = EIGEN_AVX512_SHUFFLE_PS(T9, T11, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S11 = EIGEN_AVX512_SHUFFLE_PS(T9, T11, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S12 = EIGEN_AVX512_SHUFFLE_PS(T12, T14, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S13 = EIGEN_AVX512_SHUFFLE_PS(T12, T14, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S14 = EIGEN_AVX512_SHUFFLE_PS(T13, T15, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S15 = EIGEN_AVX512_SHUFFLE_PS(T13, T15, _MM_SHUFFLE(3, 2, 3, 2));
 
   EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
   EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
@@ -1751,10 +1753,10 @@
   __m512 T2 = _mm512_unpacklo_ps(kernel.packet[2], kernel.packet[3]);
   __m512 T3 = _mm512_unpackhi_ps(kernel.packet[2], kernel.packet[3]);
 
-  __m512 S0 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S1 = _mm512_shuffle_ps(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
-  __m512 S2 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
-  __m512 S3 = _mm512_shuffle_ps(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S0 = EIGEN_AVX512_SHUFFLE_PS(T0, T2, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S1 = EIGEN_AVX512_SHUFFLE_PS(T0, T2, _MM_SHUFFLE(3, 2, 3, 2));
+  __m512 S2 = EIGEN_AVX512_SHUFFLE_PS(T1, T3, _MM_SHUFFLE(1, 0, 1, 0));
+  __m512 S3 = EIGEN_AVX512_SHUFFLE_PS(T1, T3, _MM_SHUFFLE(3, 2, 3, 2));
 
   EIGEN_EXTRACT_8f_FROM_16f(S0, S0);
   EIGEN_EXTRACT_8f_FROM_16f(S1, S1);
@@ -1957,7 +1959,8 @@
 #define PACK_OUTPUT_I32_2(OUTPUT, INPUT, INDEX, STRIDE) \
   EIGEN_INSERT_8i_INTO_16i(OUTPUT[INDEX], INPUT[2 * INDEX], INPUT[2 * INDEX + STRIDE]);
 
-#define SHUFFLE_EPI32(A, B, M) _mm512_castps_si512(_mm512_shuffle_ps(_mm512_castsi512_ps(A), _mm512_castsi512_ps(B), M))
+#define SHUFFLE_EPI32(A, B, M) \
+  _mm512_castps_si512(EIGEN_AVX512_SHUFFLE_PS(_mm512_castsi512_ps(A), _mm512_castsi512_ps(B), M))
 
 EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet16i, 16>& kernel) {
   __m512i T0 = _mm512_unpacklo_epi32(kernel.packet[0], kernel.packet[1]);
@@ -2178,7 +2181,7 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet16h pabs(const Packet16h& a) {
-  const __m256i sign_mask = _mm256_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  const __m256i sign_mask = _mm256_set1_epi16(static_cast<short>(0x8000u));
   return _mm256_andnot_si256(sign_mask, a);
 }
 
@@ -2269,13 +2272,8 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet16h pconj(const Packet16h& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet16h pnegate(const Packet16h& a) {
-  Packet16h sign_mask = _mm256_set1_epi16(static_cast<unsigned short>(0x8000));
+  Packet16h sign_mask = _mm256_set1_epi16(static_cast<short>(0x8000u));
   return _mm256_xor_si256(a, sign_mask);
 }
 
@@ -2547,9 +2545,7 @@
 #endif  // EIGEN_VECTORIZE_AVX512FP16
 
 template <>
-struct is_arithmetic<Packet16bf> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet16bf> : std::true_type {};
 
 template <>
 struct packet_traits<bfloat16> : default_packet_traits {
@@ -2687,6 +2683,13 @@
   return r;
 }
 
+// Discard the low 16 bits of each float. Only valid when every lane already holds an exact
+// bfloat16 value, in which case this agrees with F32ToBf16 but skips its rounding and NaN
+// canonicalization. pmin/pmax qualify: they return one of their operands bit for bit.
+EIGEN_STRONG_INLINE Packet16bf F32ToBf16Truncate(const Packet16f& a) {
+  return _mm512_cvtepi32_epi16(_mm512_srli_epi32(_mm512_castps_si512(a), 16));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet16bf ptrue(const Packet16bf& a) {
   return Packet16bf(ptrue<Packet8i>(Packet8i(a)));
@@ -2721,27 +2724,27 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf pround<Packet16bf>(const Packet16bf& a) {
-  return F32ToBf16(pround<Packet16f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pround<Packet16f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf print<Packet16bf>(const Packet16bf& a) {
-  return F32ToBf16(print<Packet16f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(print<Packet16f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf pceil<Packet16bf>(const Packet16bf& a) {
-  return F32ToBf16(pceil<Packet16f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pceil<Packet16f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf pfloor<Packet16bf>(const Packet16bf& a) {
-  return F32ToBf16(pfloor<Packet16f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pfloor<Packet16f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf ptrunc<Packet16bf>(const Packet16bf& a) {
-  return F32ToBf16(ptrunc<Packet16f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(ptrunc<Packet16f>(Bf16ToF32(a)));
 }
 
 template <>
@@ -2764,20 +2767,37 @@
   return Pack32To16(pcmp_lt_or_nan(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
+// Classify on the raw bits, as the scalar isinf/isnan/isfinite do: |a| ==, >, < 0x7f80.
+template <>
+EIGEN_STRONG_INLINE Packet16bf pisinf<Packet16bf>(const Packet16bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return _mm256_cmpeq_epi16(_mm256_and_si256(a, _mm256_set1_epi16(kAbsMask)), _mm256_set1_epi16(kInf));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pisnan<Packet16bf>(const Packet16bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return _mm256_cmpgt_epi16(_mm256_and_si256(a, _mm256_set1_epi16(kAbsMask)), _mm256_set1_epi16(kInf));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet16bf pisfinite<Packet16bf>(const Packet16bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return _mm256_cmpgt_epi16(_mm256_set1_epi16(kInf), _mm256_and_si256(a, _mm256_set1_epi16(kAbsMask)));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet16bf pnegate(const Packet16bf& a) {
-  Packet16bf sign_mask = _mm256_set1_epi16(static_cast<unsigned short>(0x8000));
+  Packet16bf sign_mask = _mm256_set1_epi16(static_cast<short>(0x8000u));
   return _mm256_xor_si256(a, sign_mask);
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet16bf pconj(const Packet16bf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet16bf pabs(const Packet16bf& a) {
-  const __m256i sign_mask = _mm256_set1_epi16(static_cast<numext::uint16_t>(0x8000));
+  const __m256i sign_mask = _mm256_set1_epi16(static_cast<short>(0x8000u));
   return _mm256_andnot_si256(sign_mask, a);
 }
 
@@ -2823,12 +2843,12 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf pmin<Packet16bf>(const Packet16bf& a, const Packet16bf& b) {
-  return F32ToBf16(pmin<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmin<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet16bf pmax<Packet16bf>(const Packet16bf& a, const Packet16bf& b) {
-  return F32ToBf16(pmax<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmax<Packet16f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
@@ -3121,47 +3141,47 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet32s parithmetic_shift_right(Packet32s a) {
+EIGEN_STRONG_INLINE Packet32s parithmetic_shift_right(const Packet32s& a) {
   return _mm512_srai_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet16s parithmetic_shift_right(Packet16s a) {
+EIGEN_STRONG_INLINE Packet16s parithmetic_shift_right(const Packet16s& a) {
   return _mm256_srai_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(Packet8s a) {
+EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(const Packet8s& a) {
   return _mm_srai_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet32s plogical_shift_left(Packet32s a) {
+EIGEN_STRONG_INLINE Packet32s plogical_shift_left(const Packet32s& a) {
   return _mm512_slli_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet16s plogical_shift_left(Packet16s a) {
+EIGEN_STRONG_INLINE Packet16s plogical_shift_left(const Packet16s& a) {
   return _mm256_slli_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8s plogical_shift_left(Packet8s a) {
+EIGEN_STRONG_INLINE Packet8s plogical_shift_left(const Packet8s& a) {
   return _mm_slli_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet32s plogical_shift_right(Packet32s a) {
+EIGEN_STRONG_INLINE Packet32s plogical_shift_right(const Packet32s& a) {
   return _mm512_srli_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet16s plogical_shift_right(Packet16s a) {
+EIGEN_STRONG_INLINE Packet16s plogical_shift_right(const Packet16s& a) {
   return _mm256_srli_epi16(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet8s plogical_shift_right(Packet8s a) {
+EIGEN_STRONG_INLINE Packet8s plogical_shift_right(const Packet8s& a) {
   return _mm_srli_epi16(a, N);
 }
 
diff --git a/Eigen/src/Core/arch/AVX512/PacketMathFP16.h b/Eigen/src/Core/arch/AVX512/PacketMathFP16.h
index 370fb83..34b2939 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMathFP16.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMathFP16.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_FP16_AVX512_H
 #define EIGEN_PACKET_MATH_FP16_AVX512_H
@@ -735,6 +736,38 @@
   return half(_mm_reduce_add_ph(a));
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet32h& a) {
+  return avx512_predux_any(_mm512_castph_si512(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet16h& a) {
+  const __m256i bits = _mm256_castph_si256(a);
+  return _mm256_testz_si256(bits, bits) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet8h& a) {
+  const __m128i bits = _mm_castph_si128(a);
+  return _mm_testz_si128(bits, bits) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet32h& a) {
+  return _mm512_cmp_ph_mask(a, _mm512_setzero_ph(), _CMP_EQ_OQ) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet16h& a) {
+  return _mm256_cmp_ph_mask(a, _mm256_setzero_ph(), _CMP_EQ_OQ) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet8h& a) {
+  return _mm_cmp_ph_mask(a, _mm_setzero_ph(), _CMP_EQ_OQ) == 0;
+}
+
 // predux_half
 template <>
 EIGEN_STRONG_INLINE Packet16h predux_half<Packet32h>(const Packet32h& a) {
@@ -878,19 +911,17 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet32h pnegate<Packet32h>(const Packet32h& a) {
-  return _mm512_castsi512_ph(
-      _mm512_xor_si512(_mm512_castph_si512(a), _mm512_set1_epi16(static_cast<std::uint16_t>(0x8000u))));
+  return _mm512_castsi512_ph(_mm512_xor_si512(_mm512_castph_si512(a), _mm512_set1_epi16(static_cast<short>(0x8000u))));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet16h pnegate<Packet16h>(const Packet16h& a) {
-  return _mm256_castsi256_ph(
-      _mm256_xor_si256(_mm256_castph_si256(a), _mm256_set1_epi16(static_cast<std::uint16_t>(0x8000u))));
+  return _mm256_castsi256_ph(_mm256_xor_si256(_mm256_castph_si256(a), _mm256_set1_epi16(static_cast<short>(0x8000u))));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet8h pnegate<Packet8h>(const Packet8h& a) {
-  return _mm_castsi128_ph(_mm_xor_si128(_mm_castph_si128(a), _mm_set1_epi16(static_cast<std::uint16_t>(0x8000u))));
+  return _mm_castsi128_ph(_mm_xor_si128(_mm_castph_si128(a), _mm_set1_epi16(static_cast<short>(0x8000u))));
 }
 
 // pconj
@@ -984,7 +1015,7 @@
     q[8 * i + 7] = _mm512_unpackhi_epi64(p[8 * i + 3], p[8 * i + 7]);
   }
 
-  __m512i f[32];
+  __m512i f[32] = {};
 
 #define PACKET32H_TRANSPOSE_HELPER(X, Y)                                                            \
   do {                                                                                              \
diff --git a/Eigen/src/Core/arch/AVX512/Reductions.h b/Eigen/src/Core/arch/AVX512/Reductions.h
index f59b78e..2e93cce 100644
--- a/Eigen/src/Core/arch/AVX512/Reductions.h
+++ b/Eigen/src/Core/arch/AVX512/Reductions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REDUCTIONS_AVX512_H
 #define EIGEN_REDUCTIONS_AVX512_H
@@ -17,6 +18,9 @@
 
 namespace internal {
 
+// Preserve this backend's any-bit semantics by testing 32-bit chunks for every scalar width.
+EIGEN_STRONG_INLINE bool avx512_predux_any(const Packet16i& bits) { return _mm512_test_epi32_mask(bits, bits) != 0; }
+
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet16i -- -- -- -- -- -- -- -- -- -- -- -- */
 
 template <>
@@ -41,7 +45,12 @@
 
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet16i& a) {
-  return _mm512_reduce_or_epi32(a) != 0;
+  return avx512_predux_any(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet16i& a) {
+  return _mm512_cmp_epi32_mask(a, _mm512_setzero_epi32(), _MM_CMPINT_EQ) == 0;
 }
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet8l -- -- -- -- -- -- -- -- -- -- -- -- */
@@ -82,7 +91,12 @@
 
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet8l& a) {
-  return _mm512_reduce_or_epi64(a) != 0;
+  return avx512_predux_any(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet8l& a) {
+  return _mm512_cmp_epi64_mask(a, _mm512_setzero_si512(), _MM_CMPINT_EQ) == 0;
 }
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet16f -- -- -- -- -- -- -- -- -- -- -- -- */
@@ -137,7 +151,17 @@
 
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet16f& a) {
-  return _mm512_reduce_or_epi32(_mm512_castps_si512(a)) != 0;
+  return avx512_predux_any(_mm512_castps_si512(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet16f& a) {
+  return _mm512_cmp_ps_mask(a, _mm512_setzero_ps(), _CMP_EQ_OQ) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet16f& a) {
+  return Index(popcount(static_cast<unsigned int>(_mm512_cmp_ps_mask(a, _mm512_setzero_ps(), _CMP_NEQ_UQ))));
 }
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet8d -- -- -- -- -- -- -- -- -- -- -- -- */
@@ -192,7 +216,30 @@
 
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet8d& a) {
-  return _mm512_reduce_or_epi64(_mm512_castpd_si512(a)) != 0;
+  return avx512_predux_any(_mm512_castpd_si512(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet8d& a) {
+  return _mm512_cmp_pd_mask(a, _mm512_setzero_pd(), _CMP_EQ_OQ) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet8d& a) {
+  return Index(popcount(static_cast<unsigned int>(_mm512_cmp_pd_mask(a, _mm512_setzero_pd(), _CMP_NEQ_UQ))));
+}
+
+// Count 16-bit floating-point lanes through integer bits so fast-math cannot treat NaN masks as zero.
+EIGEN_STRONG_INLINE Index predux_count_16bit(const __m256i& a) {
+#if defined(EIGEN_VECTORIZE_AVX512VL) && defined(__AVX512BW__)
+  const unsigned int nonzero_lanes = _cvtmask16_u32(_mm256_test_epi16_mask(a, _mm256_set1_epi16(0x7fff)));
+  return Index(popcount(nonzero_lanes));
+#else
+  const __m256i magnitude = _mm256_and_si256(a, _mm256_set1_epi16(0x7fff));
+  const __m256i zeros = _mm256_cmpeq_epi16(magnitude, _mm256_setzero_si256());
+  const unsigned int zero_bytes = static_cast<unsigned int>(_mm256_movemask_epi8(zeros));
+  return Index(16 - popcount(zero_bytes) / 2);
+#endif
 }
 
 #ifndef EIGEN_VECTORIZE_AVX512FP16
@@ -242,6 +289,16 @@
 EIGEN_STRONG_INLINE bool predux_any(const Packet16h& a) {
   return predux_any<Packet8i>(a.m_val);
 }
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet16h& a) {
+  return predux_count_16bit(a.m_val) == 16;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet16h& a) {
+  return predux_count_16bit(a.m_val);
+}
 #endif
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet16bf -- -- -- -- -- -- -- -- -- -- -- -- */
@@ -291,6 +348,16 @@
   return predux_any<Packet8i>(a.m_val);
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet16bf& a) {
+  return predux_count_16bit(a.m_val) == 16;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet16bf& a) {
+  return predux_count_16bit(a.m_val);
+}
+
 }  // end namespace internal
 }  // end namespace Eigen
 
diff --git a/Eigen/src/Core/arch/AVX512/TrsmKernel.h b/Eigen/src/Core/arch/AVX512/TrsmKernel.h
index 11c0bd7..6e6677b 100644
--- a/Eigen/src/Core/arch/AVX512/TrsmKernel.h
+++ b/Eigen/src/Core/arch/AVX512/TrsmKernel.h
@@ -6,12 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CORE_ARCH_AVX512_TRSM_KERNEL_H
 #define EIGEN_CORE_ARCH_AVX512_TRSM_KERNEL_H
 
 // IWYU pragma: private
 #include "../../InternalHeaderCheck.h"
+#include <utility>
 
 #if !defined(EIGEN_USE_AVX512_TRSM_KERNELS)
 #define EIGEN_USE_AVX512_TRSM_KERNELS 1
@@ -66,7 +68,7 @@
  * For smaller problem sizes, and certain compilers, using the optimized kernels trsmKernelL/R directly
  * is faster than the packed versions in TriangularSolverMatrix.h.
  *
- * The current heuristic is based on having having all arrays used in the largest gemm-update
+ * The current heuristic is based on having all arrays used in the largest gemm-update
  * in triSolve fit in roughly L2Cap (percentage) of the L2 cache. These cutoffs are a bit conservative and could be
  * larger for some trsm cases.
  * The formula:
@@ -135,23 +137,22 @@
   static_assert(unrollM == EIGEN_AVX_MAX_NUM_ROW, "unrollM should be equal to EIGEN_AVX_MAX_NUM_ROW");
 
   urolls::template transpose<unrollN, 0>(zmm);
-  EIGEN_IF_CONSTEXPR(unrollN > U2) urolls::template transpose<unrollN, 2>(zmm);
-  EIGEN_IF_CONSTEXPR(unrollN > U1) urolls::template transpose<unrollN, 1>(zmm);
+  EIGEN_IF_CONSTEXPR (unrollN > U2) urolls::template transpose<unrollN, 2>(zmm);
+  EIGEN_IF_CONSTEXPR (unrollN > U1) urolls::template transpose<unrollN, 1>(zmm);
 
   static_assert((remN && unrollN == U1) || !remN, "When handling N remainder set unrollN=U1");
-  EIGEN_IF_CONSTEXPR(!remN) {
+  EIGEN_IF_CONSTEXPR (!remN) {
     urolls::template storeC<std::min(unrollN, U1), unrollN, 0, remM>(C_arr, LDC, zmm, remM_);
-    EIGEN_IF_CONSTEXPR(unrollN > U1) {
+    EIGEN_IF_CONSTEXPR (unrollN > U1) {
       constexpr int64_t unrollN_ = std::min(unrollN - U1, U1);
       urolls::template storeC<unrollN_, unrollN, 1, remM>(C_arr + U1 * LDC, LDC, zmm, remM_);
     }
-    EIGEN_IF_CONSTEXPR(unrollN > U2) {
+    EIGEN_IF_CONSTEXPR (unrollN > U2) {
       constexpr int64_t unrollN_ = std::min(unrollN - U2, U1);
       urolls::template storeC<unrollN_, unrollN, 2, remM>(C_arr + U2 * LDC, LDC, zmm, remM_);
     }
-  }
-  else {
-    EIGEN_IF_CONSTEXPR((std::is_same<Scalar, float>::value)) {
+  } else {
+    EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, float>::value)) {
       // Note: without "if constexpr" this section of code will also be
       // parsed by the compiler so each of the storeC will still be instantiated.
       // We use enable_if in aux_storeC to set it to an empty function for
@@ -186,8 +187,7 @@
         urolls::template storeC<2, unrollN, 0, remM>(C_arr, LDC, zmm, remM_);
       else if (remN_ == 1)
         urolls::template storeC<1, unrollN, 0, remM>(C_arr, LDC, zmm, remM_);
-    }
-    else {
+    } else {
       if (remN_ == 7)
         urolls::template storeC<7, unrollN, 0, remM>(C_arr, LDC, zmm, remM_);
       else if (remN_ == 6)
@@ -227,7 +227,7 @@
   constexpr int64_t U3 = urolls::PacketSize * 3;
   constexpr int64_t U2 = urolls::PacketSize * 2;
   constexpr int64_t U1 = urolls::PacketSize * 1;
-  using vec = typename std::conditional<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>::type;
+  using vec = std::conditional_t<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>;
   int64_t N_ = (N / U3) * U3;
   int64_t M_ = (M / EIGEN_AVX_MAX_NUM_ROW) * EIGEN_AVX_MAX_NUM_ROW;
   int64_t K_ = (K / EIGEN_AVX_MAX_K_UNROL) * EIGEN_AVX_MAX_K_UNROL;
@@ -243,23 +243,26 @@
         urolls::template microKernel<isARowMajor, 3, EIGEN_AVX_MAX_NUM_ROW, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 3, EIGEN_AVX_MAX_NUM_ROW, 1, EIGEN_AVX_B_LOAD_SETS * 3,
                                        EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<3, EIGEN_AVX_MAX_NUM_ROW>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<3, EIGEN_AVX_MAX_NUM_ROW>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U3, false, false>(zmm, &C_arr[i + j * LDC], LDC);
       }
     }
@@ -272,23 +275,26 @@
         urolls::template microKernel<isARowMajor, 3, 4, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_B_LOAD_SETS * 3,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 3, 4, 1, EIGEN_AVX_B_LOAD_SETS * 3, EIGEN_AVX_MAX_A_BCAST>(
               B_t, A_t, LDB, LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<3, 4>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<3, 4>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U3, true, false>(zmm, &C_arr[i + j * LDC], LDC, 4);
       }
       i += 4;
@@ -302,23 +308,26 @@
         urolls::template microKernel<isARowMajor, 3, 2, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_B_LOAD_SETS * 3,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 3, 2, 1, EIGEN_AVX_B_LOAD_SETS * 3, EIGEN_AVX_MAX_A_BCAST>(
               B_t, A_t, LDB, LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<3, 2>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<3, 2>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U3, true, false>(zmm, &C_arr[i + j * LDC], LDC, 2);
       }
       i += 2;
@@ -333,22 +342,25 @@
           urolls::template microKernel<isARowMajor, 3, 1, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_B_LOAD_SETS * 3, 1>(
               B_t, A_t, LDB, LDA, zmm);
           B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-          else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t += EIGEN_AVX_MAX_K_UNROL;
+          else
+            A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
         }
-        EIGEN_IF_CONSTEXPR(handleKRem) {
+        EIGEN_IF_CONSTEXPR (handleKRem) {
           for (int64_t k = K_; k < K; k++) {
             urolls::template microKernel<isARowMajor, 3, 1, 1, EIGEN_AVX_B_LOAD_SETS * 3, 1>(B_t, A_t, LDB, LDA, zmm);
             B_t += LDB;
-            EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-            else A_t += LDA;
+            EIGEN_IF_CONSTEXPR (isARowMajor)
+              A_t++;
+            else
+              A_t += LDA;
           }
         }
-        EIGEN_IF_CONSTEXPR(isCRowMajor) {
+        EIGEN_IF_CONSTEXPR (isCRowMajor) {
           urolls::template updateC<3, 1>(&C_arr[i * LDC + j], LDC, zmm);
           urolls::template storeC<3, 1>(&C_arr[i * LDC + j], LDC, zmm);
-        }
-        else {
+        } else {
           transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U3, true, false>(zmm, &C_arr[i + j * LDC], LDC, 1);
         }
       }
@@ -359,30 +371,33 @@
     int64_t i = 0;
     for (; i < M_; i += EIGEN_AVX_MAX_NUM_ROW) {
       Scalar *A_t = &A_arr[idA<isARowMajor>(i, 0, LDA)], *B_t = &B_arr[0 * LDB + j];
-      EIGEN_IF_CONSTEXPR(isCRowMajor) B_t = &B_arr[0 * LDB + j];
+      EIGEN_IF_CONSTEXPR (isCRowMajor) B_t = &B_arr[0 * LDB + j];
       PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> zmm;
       urolls::template setzero<2, EIGEN_AVX_MAX_NUM_ROW>(zmm);
       for (int64_t k = 0; k < K_; k += EIGEN_AVX_MAX_K_UNROL) {
         urolls::template microKernel<isARowMajor, 2, EIGEN_AVX_MAX_NUM_ROW, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 2, EIGEN_AVX_MAX_NUM_ROW, 1, EIGEN_AVX_MAX_B_LOAD,
                                        EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<2, EIGEN_AVX_MAX_NUM_ROW>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<2, EIGEN_AVX_MAX_NUM_ROW>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U2, false, false>(zmm, &C_arr[i + j * LDC], LDC);
       }
     }
@@ -395,23 +410,26 @@
         urolls::template microKernel<isARowMajor, 2, 4, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 2, 4, 1, EIGEN_AVX_MAX_B_LOAD, EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB,
                                                                                                           LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<2, 4>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<2, 4>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U2, true, false>(zmm, &C_arr[i + j * LDC], LDC, 4);
       }
       i += 4;
@@ -425,23 +443,26 @@
         urolls::template microKernel<isARowMajor, 2, 2, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 2, 2, 1, EIGEN_AVX_MAX_B_LOAD, EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB,
                                                                                                           LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<2, 2>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<2, 2>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U2, true, false>(zmm, &C_arr[i + j * LDC], LDC, 2);
       }
       i += 2;
@@ -455,22 +476,25 @@
         urolls::template microKernel<isARowMajor, 2, 1, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD, 1>(B_t, A_t, LDB,
                                                                                                         LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 2, 1, 1, EIGEN_AVX_MAX_B_LOAD, 1>(B_t, A_t, LDB, LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<2, 1>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<2, 1>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U2, true, false>(zmm, &C_arr[i + j * LDC], LDC, 1);
       }
     }
@@ -487,23 +511,26 @@
         urolls::template microKernel<isARowMajor, 1, EIGEN_AVX_MAX_NUM_ROW, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, EIGEN_AVX_MAX_NUM_ROW, 1, EIGEN_AVX_B_LOAD_SETS * 1,
                                        EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, EIGEN_AVX_MAX_NUM_ROW>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<1, EIGEN_AVX_MAX_NUM_ROW>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, false, false>(zmm, &C_arr[i + j * LDC], LDC);
       }
     }
@@ -516,23 +543,26 @@
         urolls::template microKernel<isARowMajor, 1, 4, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, 4, 1, EIGEN_AVX_MAX_B_LOAD, EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB,
                                                                                                           LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, 4>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<1, 4>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, true, false>(zmm, &C_arr[i + j * LDC], LDC, 4);
       }
       i += 4;
@@ -546,23 +576,26 @@
         urolls::template microKernel<isARowMajor, 1, 2, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB, LDA, zmm);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, 2, 1, EIGEN_AVX_MAX_B_LOAD, EIGEN_AVX_MAX_A_BCAST>(B_t, A_t, LDB,
                                                                                                           LDA, zmm);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, 2>(&C_arr[i * LDC + j], LDC, zmm);
         urolls::template storeC<1, 2>(&C_arr[i * LDC + j], LDC, zmm);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, true, false>(zmm, &C_arr[i + j * LDC], LDC, 2);
       }
       i += 2;
@@ -577,22 +610,25 @@
           urolls::template microKernel<isARowMajor, 1, 1, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD, 1>(B_t, A_t, LDB,
                                                                                                           LDA, zmm);
           B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-          else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t += EIGEN_AVX_MAX_K_UNROL;
+          else
+            A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
         }
-        EIGEN_IF_CONSTEXPR(handleKRem) {
+        EIGEN_IF_CONSTEXPR (handleKRem) {
           for (int64_t k = K_; k < K; k++) {
             urolls::template microKernel<isARowMajor, 1, 1, 1, EIGEN_AVX_B_LOAD_SETS * 1, 1>(B_t, A_t, LDB, LDA, zmm);
             B_t += LDB;
-            EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-            else A_t += LDA;
+            EIGEN_IF_CONSTEXPR (isARowMajor)
+              A_t++;
+            else
+              A_t += LDA;
           }
         }
-        EIGEN_IF_CONSTEXPR(isCRowMajor) {
+        EIGEN_IF_CONSTEXPR (isCRowMajor) {
           urolls::template updateC<1, 1>(&C_arr[i * LDC + j], LDC, zmm);
           urolls::template storeC<1, 1>(&C_arr[i * LDC + j], LDC, zmm);
-        }
-        else {
+        } else {
           transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, true, false>(zmm, &C_arr[i + j * LDC], LDC, 1);
         }
       }
@@ -611,23 +647,26 @@
         urolls::template microKernel<isARowMajor, 1, EIGEN_AVX_MAX_NUM_ROW, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST, true>(B_t, A_t, LDB, LDA, zmm, N - j);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, EIGEN_AVX_MAX_NUM_ROW, 1, EIGEN_AVX_MAX_B_LOAD,
                                        EIGEN_AVX_MAX_A_BCAST, true>(B_t, A_t, LDB, LDA, zmm, N - j);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, EIGEN_AVX_MAX_NUM_ROW, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
         urolls::template storeC<1, EIGEN_AVX_MAX_NUM_ROW, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, false, true>(zmm, &C_arr[i + j * LDC], LDC, 0, N - j);
       }
     }
@@ -640,23 +679,26 @@
         urolls::template microKernel<isARowMajor, 1, 4, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST, true>(B_t, A_t, LDB, LDA, zmm, N - j);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, 4, 1, EIGEN_AVX_MAX_B_LOAD, EIGEN_AVX_MAX_A_BCAST, true>(
               B_t, A_t, LDB, LDA, zmm, N - j);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, 4, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
         urolls::template storeC<1, 4, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, true, true>(zmm, &C_arr[i + j * LDC], LDC, 4, N - j);
       }
       i += 4;
@@ -670,23 +712,26 @@
         urolls::template microKernel<isARowMajor, 1, 2, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD,
                                      EIGEN_AVX_MAX_A_BCAST, true>(B_t, A_t, LDB, LDA, zmm, N - j);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, 2, 1, EIGEN_AVX_MAX_B_LOAD, EIGEN_AVX_MAX_A_BCAST, true>(
               B_t, A_t, LDB, LDA, zmm, N - j);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, 2, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
         urolls::template storeC<1, 2, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, true, true>(zmm, &C_arr[i + j * LDC], LDC, 2, N - j);
       }
       i += 2;
@@ -700,23 +745,26 @@
         urolls::template microKernel<isARowMajor, 1, 1, EIGEN_AVX_MAX_K_UNROL, EIGEN_AVX_MAX_B_LOAD, 1, true>(
             B_t, A_t, LDB, LDA, zmm, N - j);
         B_t += EIGEN_AVX_MAX_K_UNROL * LDB;
-        EIGEN_IF_CONSTEXPR(isARowMajor) A_t += EIGEN_AVX_MAX_K_UNROL;
-        else A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
+        EIGEN_IF_CONSTEXPR (isARowMajor)
+          A_t += EIGEN_AVX_MAX_K_UNROL;
+        else
+          A_t += EIGEN_AVX_MAX_K_UNROL * LDA;
       }
-      EIGEN_IF_CONSTEXPR(handleKRem) {
+      EIGEN_IF_CONSTEXPR (handleKRem) {
         for (int64_t k = K_; k < K; k++) {
           urolls::template microKernel<isARowMajor, 1, 1, 1, EIGEN_AVX_MAX_B_LOAD, 1, true>(B_t, A_t, LDB, LDA, zmm,
                                                                                             N - j);
           B_t += LDB;
-          EIGEN_IF_CONSTEXPR(isARowMajor) A_t++;
-          else A_t += LDA;
+          EIGEN_IF_CONSTEXPR (isARowMajor)
+            A_t++;
+          else
+            A_t += LDA;
         }
       }
-      EIGEN_IF_CONSTEXPR(isCRowMajor) {
+      EIGEN_IF_CONSTEXPR (isCRowMajor) {
         urolls::template updateC<1, 1, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
         urolls::template storeC<1, 1, true>(&C_arr[i * LDC + j], LDC, zmm, N - j);
-      }
-      else {
+      } else {
         transStoreC<Scalar, vec, EIGEN_AVX_MAX_NUM_ROW, U1, true, true>(zmm, &C_arr[i + j * LDC], LDC, 1, N - j);
       }
     }
@@ -785,7 +833,7 @@
 void triSolveKernelLxK(Scalar* A_arr, Scalar* B_arr, int64_t M, int64_t K, int64_t LDA, int64_t LDB) {
   // Note: this assumes EIGEN_AVX_MAX_NUM_ROW = 8. Unrolls should be adjusted
   // accordingly if EIGEN_AVX_MAX_NUM_ROW is smaller.
-  using vec = typename std::conditional<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>::type;
+  using vec = std::conditional_t<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>;
   if (M == 8)
     triSolveKernel<Scalar, vec, 8, isARowMajor, isFWDSolve, isUnitDiag>(A_arr, B_arr, K, LDA, LDB);
   else if (M == 7)
@@ -817,7 +865,7 @@
                                          int64_t remM_ = 0) {
   EIGEN_UNUSED_VARIABLE(remM_);
   using urolls = unrolls::transB<Scalar>;
-  using vecHalf = typename std::conditional<std::is_same<Scalar, float>::value, vecHalfFloat, vecFullDouble>::type;
+  using vecHalf = std::conditional_t<std::is_same<Scalar, float>::value, vecHalfFloat, vecFullDouble>;
   PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> ymm;
   constexpr int64_t U3 = urolls::PacketSize * 3;
   constexpr int64_t U2 = urolls::PacketSize * 2;
@@ -839,7 +887,7 @@
     B_temp += U1;
     k += U1;
   }
-  EIGEN_IF_CONSTEXPR(U1 > 8) {
+  EIGEN_IF_CONSTEXPR (U1 > 8) {
     // Note: without "if constexpr" this section of code will also be
     // parsed by the compiler so there is an additional check in {load/store}BBlock
     // to make sure the counter is not non-negative.
@@ -849,7 +897,7 @@
       k += 8;
     }
   }
-  EIGEN_IF_CONSTEXPR(U1 > 4) {
+  EIGEN_IF_CONSTEXPR (U1 > 4) {
     // Note: without "if constexpr" this section of code will also be
     // parsed by the compiler so there is an additional check in {load/store}BBlock
     // to make sure the counter is not non-negative.
@@ -919,8 +967,8 @@
   constexpr int64_t numM = 8 * EIGEN_AVX_MAX_NUM_ROW;
 
   int64_t sizeBTemp = 0;
-  Scalar* B_temp = NULL;
-  EIGEN_IF_CONSTEXPR(!isBRowMajor) {
+  Scalar* B_temp = nullptr;
+  EIGEN_IF_CONSTEXPR (!isBRowMajor) {
     /**
      * If B is col-major, we copy it to a fixed-size temporary array of size at most ~numM*kB and
      * transpose it to row-major. Call the solve routine, and copy+transpose it back to the original array.
@@ -929,7 +977,7 @@
     sizeBTemp = (((std::min(kB, numRHS) + psize - 1) / psize + 4) * psize) * numM;
   }
 
-  EIGEN_IF_CONSTEXPR(!isBRowMajor) B_temp = (Scalar*)handmade_aligned_malloc(sizeof(Scalar) * sizeBTemp, 64);
+  EIGEN_IF_CONSTEXPR (!isBRowMajor) B_temp = (Scalar*)handmade_aligned_malloc(sizeof(Scalar) * sizeBTemp, 64);
 
   for (int64_t k = 0; k < numRHS; k += kB) {
     int64_t bK = numRHS - k > kB ? kB : numRHS - k;
@@ -943,7 +991,7 @@
     int64_t LDT = ((bkL + (numScalarPerCache - 1)) / numScalarPerCache) * numScalarPerCache;
     int64_t offsetBTemp = 0;
     for (int64_t i = 0; i < M_; i += EIGEN_AVX_MAX_NUM_ROW) {
-      EIGEN_IF_CONSTEXPR(!isBRowMajor) {
+      EIGEN_IF_CONSTEXPR (!isBRowMajor) {
         int64_t indA_i = isFWDSolve ? i : M - 1 - i;
         int64_t indB_i = isFWDSolve ? i : M - (i + EIGEN_AVX_MAX_NUM_ROW);
         int64_t offB_1 = isFWDSolve ? offsetBTemp : sizeBTemp - EIGEN_AVX_MAX_NUM_ROW * LDT - offsetBTemp;
@@ -957,8 +1005,7 @@
         copyBToRowMajor<Scalar, false, false>(B_arr + indB_i + k * LDB, LDB, bK, B_temp + offB_1, LDT);
 
         offsetBTemp += EIGEN_AVX_MAX_NUM_ROW * LDT;
-      }
-      else {
+      } else {
         int64_t ind = isFWDSolve ? i : M - 1 - i;
         triSolveKernelLxK<Scalar, isARowMajor, isFWDSolve, isUnitDiag>(
             &A_arr[idA<isARowMajor>(ind, ind, LDA)], B_arr + k + ind * LDB, EIGEN_AVX_MAX_NUM_ROW, bK, LDA, LDB);
@@ -976,7 +1023,7 @@
          *    |__|__|__|__     |__|
          *    |********|__|    |**|
          */
-        EIGEN_IF_CONSTEXPR(isBRowMajor) {
+        EIGEN_IF_CONSTEXPR (isBRowMajor) {
           int64_t indA_i = isFWDSolve ? i + EIGEN_AVX_MAX_NUM_ROW : M - (i + 2 * EIGEN_AVX_MAX_NUM_ROW);
           int64_t indA_j = isFWDSolve ? 0 : M - (i + EIGEN_AVX_MAX_NUM_ROW);
           int64_t indB_i = isFWDSolve ? 0 : M - (i + EIGEN_AVX_MAX_NUM_ROW);
@@ -984,8 +1031,7 @@
           gemmKernel<Scalar, isARowMajor, isBRowMajor, false, false>(
               &A_arr[idA<isARowMajor>(indA_i, indA_j, LDA)], B_arr + k + indB_i * LDB, B_arr + k + indB_i2 * LDB,
               EIGEN_AVX_MAX_NUM_ROW, bK, i + EIGEN_AVX_MAX_NUM_ROW, LDA, LDB, LDB);
-        }
-        else {
+        } else {
           if (offsetBTemp + EIGEN_AVX_MAX_NUM_ROW * LDT > sizeBTemp) {
             /**
              * Similar idea as mentioned above, but here we are limited by the number of updated values of B
@@ -1023,7 +1069,7 @@
     int64_t bM = M - M_;
     if (bM > 0) {
       if (M_ > 0) {
-        EIGEN_IF_CONSTEXPR(isBRowMajor) {
+        EIGEN_IF_CONSTEXPR (isBRowMajor) {
           int64_t indA_i = isFWDSolve ? M_ : 0;
           int64_t indA_j = isFWDSolve ? 0 : bM;
           int64_t indB_i = isFWDSolve ? 0 : bM;
@@ -1031,8 +1077,7 @@
           gemmKernel<Scalar, isARowMajor, isBRowMajor, false, false>(
               &A_arr[idA<isARowMajor>(indA_i, indA_j, LDA)], B_arr + k + indB_i * LDB, B_arr + k + indB_i2 * LDB, bM,
               bK, M_, LDA, LDB, LDB);
-        }
-        else {
+        } else {
           int64_t indA_i = isFWDSolve ? M_ : 0;
           int64_t indA_j = isFWDSolve ? gemmOff : bM;
           int64_t indB_i = isFWDSolve ? M_ : 0;
@@ -1042,7 +1087,7 @@
                                                                      M_ - gemmOff, LDA, LDT, LDB);
         }
       }
-      EIGEN_IF_CONSTEXPR(!isBRowMajor) {
+      EIGEN_IF_CONSTEXPR (!isBRowMajor) {
         int64_t indA_i = isFWDSolve ? M_ : M - 1 - M_;
         int64_t indB_i = isFWDSolve ? M_ : 0;
         int64_t offB_1 = isFWDSolve ? 0 : (bM - 1) * bkL;
@@ -1050,8 +1095,7 @@
         triSolveKernelLxK<Scalar, isARowMajor, isFWDSolve, isUnitDiag>(&A_arr[idA<isARowMajor>(indA_i, indA_i, LDA)],
                                                                        B_temp + offB_1, bM, bkL, LDA, bkL);
         copyBToRowMajor<Scalar, false, true>(B_arr + indB_i + k * LDB, LDB, bK, B_temp, bkL, bM);
-      }
-      else {
+      } else {
         int64_t ind = isFWDSolve ? M_ : M - 1 - M_;
         triSolveKernelLxK<Scalar, isARowMajor, isFWDSolve, isUnitDiag>(&A_arr[idA<isARowMajor>(ind, ind, LDA)],
                                                                        B_arr + k + ind * LDB, bM, bK, LDA, LDB);
@@ -1059,7 +1103,7 @@
     }
   }
 
-  EIGEN_IF_CONSTEXPR(!isBRowMajor) handmade_aligned_free(B_temp);
+  EIGEN_IF_CONSTEXPR (!isBRowMajor) handmade_aligned_free(B_temp);
 }
 
 // Template specializations of trsmKernelL/R for float/double and inner strides of 1.
@@ -1138,8 +1182,12 @@
   EIGEN_UNUSED_VARIABLE(otherIncr);
 #ifdef EIGEN_RUNTIME_NO_MALLOC
   if (!is_malloc_allowed()) {
+    // The unspecialized kernel takes an upper-triangular panel by its bottom-right element and
+    // indexes it backwards, while triangular_solve_matrix() hands these specializations the
+    // panel's top-left element. Move the origin before delegating.
+    const Index shift = ((Mode & Lower) == Lower) ? Index(0) : size - 1;
     trsmKernelL<float, Index, Mode, false, TriStorageOrder, 1, /*Specialized=*/false>::kernel(
-        size, otherSize, _tri, triStride, _other, otherIncr, otherStride);
+        size, otherSize, _tri + shift + shift * triStride, triStride, _other + shift, otherIncr, otherStride);
     return;
   }
 #endif
@@ -1154,8 +1202,12 @@
   EIGEN_UNUSED_VARIABLE(otherIncr);
 #ifdef EIGEN_RUNTIME_NO_MALLOC
   if (!is_malloc_allowed()) {
+    // The unspecialized kernel takes an upper-triangular panel by its bottom-right element and
+    // indexes it backwards, while triangular_solve_matrix() hands these specializations the
+    // panel's top-left element. Move the origin before delegating.
+    const Index shift = ((Mode & Lower) == Lower) ? Index(0) : size - 1;
     trsmKernelL<double, Index, Mode, false, TriStorageOrder, 1, /*Specialized=*/false>::kernel(
-        size, otherSize, _tri, triStride, _other, otherIncr, otherStride);
+        size, otherSize, _tri + shift + shift * triStride, triStride, _other + shift, otherIncr, otherStride);
     return;
   }
 #endif
diff --git a/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc b/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc
index 3a5f68e..0093051 100644
--- a/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc
+++ b/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc
@@ -6,47 +6,42 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CORE_ARCH_AVX512_TRSM_UNROLLS_H
 #define EIGEN_CORE_ARCH_AVX512_TRSM_UNROLLS_H
 
 template <bool isARowMajor = true>
 EIGEN_ALWAYS_INLINE int64_t idA(int64_t i, int64_t j, int64_t LDA) {
-  EIGEN_IF_CONSTEXPR(isARowMajor) return i * LDA + j;
-  else return i + j * LDA;
+  EIGEN_IF_CONSTEXPR (isARowMajor)
+    return i * LDA + j;
+  else
+    return i + j * LDA;
 }
 
 /**
  * This namespace contains various classes used to generate compile-time unrolls which are
  * used throughout the trsm/gemm kernels. The unrolls are characterized as for-loops (1-D), nested
- * for-loops (2-D), or triple nested for-loops (3-D). Unrolls are generated using template recursion
+ * for-loops (2-D), or triple nested for-loops (3-D). Unrolls are generated using std::integer_sequence
  *
- * Example, the 2-D for-loop is unrolled recursively by first flattening to a 1-D loop.
+ * Example, the 2-D for-loop is unrolled by first flattening to a 1-D loop.
  *
  * for(startI = 0; startI < endI; startI++)             for(startC = 0; startC < endI*endJ; startC++)
  *   for(startJ = 0; startJ < endJ; startJ++)  ---->      startI = (startC)/(endJ)
  *     func(startI,startJ)                                startJ = (startC)%(endJ)
  *                                                        func(...)
  *
- * The 1-D loop can be unrolled recursively by using enable_if and defining an auxiliary function
- * with a template parameter used as a counter.
+ * The 1-D loop can be expanded by using an auxiliary function with a template parameter used as an index.
  *
- * template <endI, endJ, counter>
- * std::enable_if_t<(counter <= 0)>  <---- tail case.
- * aux_func {}
- *
- * template <endI, endJ, counter>
- * std::enable_if_t<(counter > 0)>   <---- actual for-loop
+ * template <endI, endJ, index>
  * aux_func {
- *   startC = endI*endJ - counter
+ *   startC = index
  *   startI = (startC)/(endJ)
  *   startJ = (startC)%(endJ)
  *   func(startI, startJ)
- *   aux_func<endI, endJ, counter-1>()
  * }
  *
- * Note: Additional wrapper functions are provided for aux_func which hides the counter template
- * parameter since counter usually depends on endI, endJ, etc...
+ * Note: Additional wrapper functions are provided for aux_func which build the integer_sequence from endI, endJ, etc.
  *
  * Conventions:
  * 1) endX: specifies the terminal value for the for-loop, (ex: for(startX = 0; startX < endX; startX++))
@@ -58,11 +53,11 @@
 
 template <int64_t N>
 EIGEN_ALWAYS_INLINE auto remMask(int64_t m) {
-  EIGEN_IF_CONSTEXPR(N == 16) { return 0xFFFF >> (16 - m); }
-  else EIGEN_IF_CONSTEXPR(N == 8) {
+  EIGEN_IF_CONSTEXPR (N == 16) {
+    return 0xFFFF >> (16 - m);
+  } else EIGEN_IF_CONSTEXPR (N == 8) {
     return 0xFF >> (8 - m);
-  }
-  else EIGEN_IF_CONSTEXPR(N == 4) {
+  } else EIGEN_IF_CONSTEXPR (N == 4) {
     return 0x0F >> (4 - m);
   }
   return 0;
@@ -129,8 +124,8 @@
 template <typename Scalar>
 class trans {
  public:
-  using vec = typename std::conditional<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>::type;
-  using vecHalf = typename std::conditional<std::is_same<Scalar, float>::value, vecHalfFloat, vecFullDouble>::type;
+  using vec = std::conditional_t<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>;
+  using vecHalf = std::conditional_t<std::is_same<Scalar, float>::value, vecHalfFloat, vecFullDouble>;
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
@@ -148,57 +143,66 @@
    * (endN <= PacketSize) is required to handle the fp32 case, see comments in transStoreC
    *
    **/
-  template <int64_t endN, int64_t counter, int64_t unrollN, int64_t packetIndexOffset, bool remM>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0 && endN <= PacketSize)> aux_storeC(
-      Scalar *C_arr, int64_t LDC, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t remM_ = 0) {
-    constexpr int64_t counterReverse = endN - counter;
-    constexpr int64_t startN = counterReverse;
-
-    EIGEN_IF_CONSTEXPR(startN < EIGEN_AVX_MAX_NUM_ROW) {
-      EIGEN_IF_CONSTEXPR(remM) {
-        pstoreu<Scalar>(
-            C_arr + LDC * startN,
-            padd(ploadu<vecHalf>((const Scalar *)C_arr + LDC * startN, remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_)),
-                 preinterpret<vecHalf>(zmm.packet[packetIndexOffset + (unrollN / PacketSize) * startN]),
-                 remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_)),
-            remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_));
-      }
-      else {
-        pstoreu<Scalar>(C_arr + LDC * startN,
-                        padd(ploadu<vecHalf>((const Scalar *)C_arr + LDC * startN),
-                             preinterpret<vecHalf>(zmm.packet[packetIndexOffset + (unrollN / PacketSize) * startN])));
-      }
-    }
-    else {  // This block is only needed for fp32 case
-      // Reinterpret as __m512 for _mm512_shuffle_f32x4
-      vecFullFloat zmm2vecFullFloat = preinterpret<vecFullFloat>(
-          zmm.packet[packetIndexOffset + (unrollN / PacketSize) * (startN - EIGEN_AVX_MAX_NUM_ROW)]);
-      // Swap lower and upper half of avx register.
-      zmm.packet[packetIndexOffset + (unrollN / PacketSize) * (startN - EIGEN_AVX_MAX_NUM_ROW)] =
-          preinterpret<vec>(_mm512_shuffle_f32x4(zmm2vecFullFloat, zmm2vecFullFloat, 0b01001110));
-
-      EIGEN_IF_CONSTEXPR(remM) {
-        pstoreu<Scalar>(
-            C_arr + LDC * startN,
-            padd(ploadu<vecHalf>((const Scalar *)C_arr + LDC * startN, remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_)),
-                 preinterpret<vecHalf>(
-                     zmm.packet[packetIndexOffset + (unrollN / PacketSize) * (startN - EIGEN_AVX_MAX_NUM_ROW)])),
-            remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_));
-      }
-      else {
-        pstoreu<Scalar>(
-            C_arr + LDC * startN,
-            padd(ploadu<vecHalf>((const Scalar *)C_arr + LDC * startN),
-                 preinterpret<vecHalf>(
-                     zmm.packet[packetIndexOffset + (unrollN / PacketSize) * (startN - EIGEN_AVX_MAX_NUM_ROW)])));
-      }
-    }
-    aux_storeC<endN, counter - 1, unrollN, packetIndexOffset, remM>(C_arr, LDC, zmm, remM_);
+  // Split packet indexing into overloads so C++14 compilers do not diagnose the
+  // unreachable upper-half branch for lower-half stores.
+  template <int64_t startN, int64_t unrollN, int64_t packetIndexOffset>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(startN < EIGEN_AVX_MAX_NUM_ROW), vecHalf> aux_storeC_packet(
+      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
+    return preinterpret<vecHalf>(zmm.packet[packetIndexOffset + (unrollN / PacketSize) * startN]);
   }
 
-  template <int64_t endN, int64_t counter, int64_t unrollN, int64_t packetIndexOffset, bool remM>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<!(counter > 0 && endN <= PacketSize)> aux_storeC(
-      Scalar *C_arr, int64_t LDC, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t remM_ = 0) {
+  template <int64_t startN, int64_t unrollN, int64_t packetIndexOffset>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(startN >= EIGEN_AVX_MAX_NUM_ROW), vecHalf> aux_storeC_packet(
+      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
+    constexpr int64_t packetIndex = packetIndexOffset + (unrollN / PacketSize) * (startN - EIGEN_AVX_MAX_NUM_ROW);
+    // Reinterpret as __m512 for _mm512_shuffle_f32x4.
+    vecFullFloat zmm2vecFullFloat = preinterpret<vecFullFloat>(zmm.packet[packetIndex]);
+    // Swap lower and upper half of avx register.
+    zmm.packet[packetIndex] = preinterpret<vec>(_mm512_shuffle_f32x4(zmm2vecFullFloat, zmm2vecFullFloat, 0b01001110));
+    return preinterpret<vecHalf>(zmm.packet[packetIndex]);
+  }
+
+  template <int64_t startN>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(startN < EIGEN_AVX_MAX_NUM_ROW), vecHalf> aux_storeC_add_rem(
+      const vecHalf &cPacket, const vecHalf &zmmPacket, int64_t remM_) {
+    return padd(cPacket, zmmPacket, remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_));
+  }
+
+  template <int64_t startN>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(startN >= EIGEN_AVX_MAX_NUM_ROW), vecHalf> aux_storeC_add_rem(
+      const vecHalf &cPacket, const vecHalf &zmmPacket, int64_t remM_) {
+    EIGEN_UNUSED_VARIABLE(remM_);
+    return padd(cPacket, zmmPacket);
+  }
+
+  template <int64_t startN, int64_t unrollN, int64_t packetIndexOffset, bool remM>
+  static EIGEN_ALWAYS_INLINE void aux_storeC(Scalar *C_arr, int64_t LDC,
+                                             PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                             int64_t remM_ = 0) {
+    vecHalf zmmPacket = aux_storeC_packet<startN, unrollN, packetIndexOffset>(zmm);
+    EIGEN_IF_CONSTEXPR (remM) {
+      pstoreu<Scalar>(C_arr + LDC * startN,
+                      aux_storeC_add_rem<startN>(
+                          ploadu<vecHalf>((const Scalar *)C_arr + LDC * startN, remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_)),
+                          zmmPacket, remM_),
+                      remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_));
+    } else {
+      pstoreu<Scalar>(C_arr + LDC * startN, padd(ploadu<vecHalf>((const Scalar *)C_arr + LDC * startN), zmmPacket));
+    }
+  }
+
+  template <int64_t endN, int64_t unrollN, int64_t packetIndexOffset, bool remM, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(endN > 0 && endN <= PacketSize)> aux_storeC_impl(
+      std::integer_sequence<int64_t, indices...>, Scalar *C_arr, int64_t LDC,
+      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t remM_ = 0) {
+    int unused[] = {0, (aux_storeC<indices, unrollN, packetIndexOffset, remM>(C_arr, LDC, zmm, remM_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  template <int64_t endN, int64_t unrollN, int64_t packetIndexOffset, bool remM, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<!(endN > 0 && endN <= PacketSize)> aux_storeC_impl(
+      std::integer_sequence<int64_t, indices...>, Scalar *C_arr, int64_t LDC,
+      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t remM_ = 0) {
     EIGEN_UNUSED_VARIABLE(C_arr);
     EIGEN_UNUSED_VARIABLE(LDC);
     EIGEN_UNUSED_VARIABLE(zmm);
@@ -209,7 +213,8 @@
   static EIGEN_ALWAYS_INLINE void storeC(Scalar *C_arr, int64_t LDC,
                                          PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
                                          int64_t remM_ = 0) {
-    aux_storeC<endN, endN, unrollN, packetIndexOffset, remM>(C_arr, LDC, zmm, remM_);
+    aux_storeC_impl<endN, unrollN, packetIndexOffset, remM>(
+        std::make_integer_sequence<int64_t, (endN > 0 ? endN : 0)>{}, C_arr, LDC, zmm, remM_);
   }
 
   /**
@@ -281,8 +286,8 @@
 template <typename Scalar>
 class transB {
  public:
-  using vec = typename std::conditional<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>::type;
-  using vecHalf = typename std::conditional<std::is_same<Scalar, float>::value, vecHalfFloat, vecFullDouble>::type;
+  using vec = std::conditional_t<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>;
+  using vecHalf = std::conditional_t<std::is_same<Scalar, float>::value, vecHalfFloat, vecFullDouble>;
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
@@ -300,36 +305,28 @@
    * 1-D unroll
    *      for(startN = 0; startN < endN; startN++)
    **/
-  template <int64_t endN, int64_t counter, int64_t packetIndexOffset, bool remM, int64_t remN_>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_loadB(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
-      int64_t remM_ = 0) {
-    constexpr int64_t counterReverse = endN - counter;
-    constexpr int64_t startN = counterReverse;
-
-    EIGEN_IF_CONSTEXPR(remM) {
+  template <int64_t startN, int64_t packetIndexOffset, bool remM, int64_t remN_>
+  static EIGEN_ALWAYS_INLINE void aux_loadB(Scalar *B_arr, int64_t LDB,
+                                            PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                            int64_t remM_ = 0) {
+    EIGEN_IF_CONSTEXPR (remM) {
       ymm.packet[packetIndexOffset + startN] =
           ploadu<vecHalf>((const Scalar *)&B_arr[startN * LDB], remMask<EIGEN_AVX_MAX_NUM_ROW>(remM_));
-    }
-    else {
-      EIGEN_IF_CONSTEXPR(remN_ == 0) {
+    } else {
+      EIGEN_IF_CONSTEXPR (remN_ == 0) {
         ymm.packet[packetIndexOffset + startN] = ploadu<vecHalf>((const Scalar *)&B_arr[startN * LDB]);
-      }
-      else ymm.packet[packetIndexOffset + startN] =
-          ploadu<vecHalf>((const Scalar *)&B_arr[startN * LDB], remMask<EIGEN_AVX_MAX_NUM_ROW>(remN_));
+      } else
+        ymm.packet[packetIndexOffset + startN] =
+            ploadu<vecHalf>((const Scalar *)&B_arr[startN * LDB], remMask<EIGEN_AVX_MAX_NUM_ROW>(remN_));
     }
-
-    aux_loadB<endN, counter - 1, packetIndexOffset, remM, remN_>(B_arr, LDB, ymm, remM_);
   }
 
-  template <int64_t endN, int64_t counter, int64_t packetIndexOffset, bool remM, int64_t remN_>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_loadB(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
-      int64_t remM_ = 0) {
-    EIGEN_UNUSED_VARIABLE(B_arr);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(ymm);
-    EIGEN_UNUSED_VARIABLE(remM_);
+  template <int64_t packetIndexOffset, bool remM, int64_t remN_, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_loadB_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_arr, int64_t LDB,
+                                                 PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                                 int64_t remM_ = 0) {
+    int unused[] = {0, (aux_loadB<indices, packetIndexOffset, remM, remN_>(B_arr, LDB, ymm, remM_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -338,30 +335,25 @@
    * 1-D unroll
    *      for(startN = 0; startN < endN; startN++)
    **/
-  template <int64_t endN, int64_t counter, int64_t packetIndexOffset, bool remK, bool remM>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_storeB(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm, int64_t rem_ = 0) {
-    constexpr int64_t counterReverse = endN - counter;
-    constexpr int64_t startN = counterReverse;
-
-    EIGEN_IF_CONSTEXPR(remK || remM) {
+  template <int64_t startN, int64_t packetIndexOffset, bool remK, bool remM>
+  static EIGEN_ALWAYS_INLINE void aux_storeB(Scalar *B_arr, int64_t LDB,
+                                             PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                             int64_t rem_ = 0) {
+    EIGEN_IF_CONSTEXPR (remK || remM) {
       pstoreu<Scalar>(&B_arr[startN * LDB], ymm.packet[packetIndexOffset + startN],
                       remMask<EIGEN_AVX_MAX_NUM_ROW>(rem_));
-    }
-    else {
+    } else {
       pstoreu<Scalar>(&B_arr[startN * LDB], ymm.packet[packetIndexOffset + startN]);
     }
-
-    aux_storeB<endN, counter - 1, packetIndexOffset, remK, remM>(B_arr, LDB, ymm, rem_);
   }
 
-  template <int64_t endN, int64_t counter, int64_t packetIndexOffset, bool remK, bool remM>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_storeB(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm, int64_t rem_ = 0) {
-    EIGEN_UNUSED_VARIABLE(B_arr);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(ymm);
-    EIGEN_UNUSED_VARIABLE(rem_);
+  template <int64_t packetIndexOffset, bool remK, bool remM, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_storeB_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_arr,
+                                                  int64_t LDB,
+                                                  PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                                  int64_t rem_ = 0) {
+    int unused[] = {0, (aux_storeB<indices, packetIndexOffset, remK, remM>(B_arr, LDB, ymm, rem_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -370,26 +362,25 @@
    * 1-D unroll
    *      for(startN = 0; startN < endN; startN += EIGEN_AVX_MAX_NUM_ROW)
    **/
-  template <int64_t endN, int64_t counter, bool toTemp, bool remM, int64_t remN_>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_loadBBlock(
-      Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
-      PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm, int64_t remM_ = 0) {
-    constexpr int64_t counterReverse = endN - counter;
-    constexpr int64_t startN = counterReverse;
-    transB::template loadB<EIGEN_AVX_MAX_NUM_ROW, startN, false, (toTemp ? 0 : remN_)>(&B_temp[startN], LDB_, ymm);
-    aux_loadBBlock<endN, counter - EIGEN_AVX_MAX_NUM_ROW, toTemp, remM, remN_>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
-  }
-
-  template <int64_t endN, int64_t counter, bool toTemp, bool remM, int64_t remN_>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_loadBBlock(
-      Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
-      PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm, int64_t remM_ = 0) {
+  template <int64_t endN, int64_t blockIndex, bool toTemp, bool remM, int64_t remN_>
+  static EIGEN_ALWAYS_INLINE void aux_loadBBlock(Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
+                                                 PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                                 int64_t remM_ = 0) {
     EIGEN_UNUSED_VARIABLE(B_arr);
     EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(B_temp);
-    EIGEN_UNUSED_VARIABLE(LDB_);
-    EIGEN_UNUSED_VARIABLE(ymm);
     EIGEN_UNUSED_VARIABLE(remM_);
+    constexpr int64_t startN = blockIndex * EIGEN_AVX_MAX_NUM_ROW;
+    transB::template loadB<EIGEN_AVX_MAX_NUM_ROW, startN, false, (toTemp ? 0 : remN_)>(&B_temp[startN], LDB_, ymm);
+  }
+
+  template <int64_t endN, bool toTemp, bool remM, int64_t remN_, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_loadBBlock_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_arr,
+                                                      int64_t LDB, Scalar *B_temp, int64_t LDB_,
+                                                      PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                                      int64_t remM_ = 0) {
+    int unused[] = {0,
+                    (aux_loadBBlock<endN, indices, toTemp, remM, remN_>(B_arr, LDB, B_temp, LDB_, ymm, remM_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -398,60 +389,57 @@
    * 1-D unroll
    *      for(startN = 0; startN < endN; startN += EIGEN_AVX_MAX_NUM_ROW)
    **/
-  template <int64_t endN, int64_t counter, bool toTemp, bool remM, int64_t remK_>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_storeBBlock(
-      Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
-      PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm, int64_t remM_ = 0) {
-    constexpr int64_t counterReverse = endN - counter;
-    constexpr int64_t startN = counterReverse;
+  template <int64_t endN, int64_t blockIndex, bool toTemp, bool remM, int64_t remK_>
+  static EIGEN_ALWAYS_INLINE void aux_storeBBlock(Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
+                                                  PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
+                                                  int64_t remM_ = 0) {
+    constexpr int64_t startN = blockIndex * EIGEN_AVX_MAX_NUM_ROW;
 
-    EIGEN_IF_CONSTEXPR(toTemp) {
+    EIGEN_IF_CONSTEXPR (toTemp) {
       transB::template storeB<EIGEN_AVX_MAX_NUM_ROW, startN, remK_ != 0, false>(&B_temp[startN], LDB_, ymm, remK_);
-    }
-    else {
+    } else {
       transB::template storeB<std::min(EIGEN_AVX_MAX_NUM_ROW, endN), startN, false, remM>(&B_arr[0 + startN * LDB], LDB,
                                                                                           ymm, remM_);
     }
-    aux_storeBBlock<endN, counter - EIGEN_AVX_MAX_NUM_ROW, toTemp, remM, remK_>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
   }
 
-  template <int64_t endN, int64_t counter, bool toTemp, bool remM, int64_t remK_>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_storeBBlock(
-      Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
+  template <int64_t endN, bool toTemp, bool remM, int64_t remK_, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_storeBBlock_impl(
+      std::integer_sequence<int64_t, indices...>, Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
       PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm, int64_t remM_ = 0) {
-    EIGEN_UNUSED_VARIABLE(B_arr);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(B_temp);
-    EIGEN_UNUSED_VARIABLE(LDB_);
-    EIGEN_UNUSED_VARIABLE(ymm);
-    EIGEN_UNUSED_VARIABLE(remM_);
+    int unused[] = {0,
+                    (aux_storeBBlock<endN, indices, toTemp, remM, remK_>(B_arr, LDB, B_temp, LDB_, ymm, remM_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /********************************************************
-   * Wrappers for aux_XXXX to hide counter parameter
+   * Wrappers for aux_XXXX to build index sequences
    ********************************************************/
 
   template <int64_t endN, int64_t packetIndexOffset, bool remM, int64_t remN_>
   static EIGEN_ALWAYS_INLINE void loadB(Scalar *B_arr, int64_t LDB,
                                         PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
                                         int64_t remM_ = 0) {
-    aux_loadB<endN, endN, packetIndexOffset, remM, remN_>(B_arr, LDB, ymm, remM_);
+    aux_loadB_impl<packetIndexOffset, remM, remN_>(std::make_integer_sequence<int64_t, endN>{}, B_arr, LDB, ymm, remM_);
   }
 
   template <int64_t endN, int64_t packetIndexOffset, bool remK, bool remM>
   static EIGEN_ALWAYS_INLINE void storeB(Scalar *B_arr, int64_t LDB,
                                          PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
                                          int64_t rem_ = 0) {
-    aux_storeB<endN, endN, packetIndexOffset, remK, remM>(B_arr, LDB, ymm, rem_);
+    aux_storeB_impl<packetIndexOffset, remK, remM>(std::make_integer_sequence<int64_t, endN>{}, B_arr, LDB, ymm, rem_);
   }
 
   template <int64_t unrollN, bool toTemp, bool remM, int64_t remN_ = 0>
   static EIGEN_ALWAYS_INLINE void loadBBlock(Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
                                              PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
                                              int64_t remM_ = 0) {
-    EIGEN_IF_CONSTEXPR(toTemp) { transB::template loadB<unrollN, 0, remM, 0>(&B_arr[0], LDB, ymm, remM_); }
-    else {
-      aux_loadBBlock<unrollN, unrollN, toTemp, remM, remN_>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
+    EIGEN_IF_CONSTEXPR (toTemp) {
+      transB::template loadB<unrollN, 0, remM, 0>(&B_arr[0], LDB, ymm, remM_);
+    } else {
+      aux_loadBBlock_impl<unrollN, toTemp, remM, remN_>(
+          std::make_integer_sequence<int64_t, (unrollN + EIGEN_AVX_MAX_NUM_ROW - 1) / EIGEN_AVX_MAX_NUM_ROW>{}, B_arr,
+          LDB, B_temp, LDB_, ymm, remM_);
     }
   }
 
@@ -459,7 +447,9 @@
   static EIGEN_ALWAYS_INLINE void storeBBlock(Scalar *B_arr, int64_t LDB, Scalar *B_temp, int64_t LDB_,
                                               PacketBlock<vecHalf, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &ymm,
                                               int64_t remM_ = 0) {
-    aux_storeBBlock<unrollN, unrollN, toTemp, remM, remK_>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
+    aux_storeBBlock_impl<unrollN, toTemp, remM, remK_>(
+        std::make_integer_sequence<int64_t, (unrollN + EIGEN_AVX_MAX_NUM_ROW - 1) / EIGEN_AVX_MAX_NUM_ROW>{}, B_arr,
+        LDB, B_temp, LDB_, ymm, remM_);
   }
 
   template <int64_t packetIndexOffset>
@@ -500,7 +490,7 @@
      *
      *  For fp32 L and U1 are 1:2 so for U3/U2 cases the loads/stores need to be split up.
      */
-    EIGEN_IF_CONSTEXPR(unrollN == U3) {
+    EIGEN_IF_CONSTEXPR (unrollN == U3) {
       // load LxU3 B col major, transpose LxU3 row major
       constexpr int64_t maxUBlock = std::min(3 * EIGEN_AVX_MAX_NUM_ROW, U3);
       transB::template loadBBlock<maxUBlock, toTemp, remM>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
@@ -509,7 +499,7 @@
       transB::template transposeLxL<2 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
       transB::template storeBBlock<maxUBlock, toTemp, remM, 0>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
 
-      EIGEN_IF_CONSTEXPR(maxUBlock < U3) {
+      EIGEN_IF_CONSTEXPR (maxUBlock < U3) {
         transB::template loadBBlock<maxUBlock, toTemp, remM>(&B_arr[maxUBlock * LDB], LDB, &B_temp[maxUBlock], LDB_,
                                                              ymm, remM_);
         transB::template transposeLxL<0 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
@@ -518,50 +508,46 @@
         transB::template storeBBlock<maxUBlock, toTemp, remM, 0>(&B_arr[maxUBlock * LDB], LDB, &B_temp[maxUBlock], LDB_,
                                                                  ymm, remM_);
       }
-    }
-    else EIGEN_IF_CONSTEXPR(unrollN == U2) {
+    } else EIGEN_IF_CONSTEXPR (unrollN == U2) {
       // load LxU2 B col major, transpose LxU2 row major
       constexpr int64_t maxUBlock = std::min(3 * EIGEN_AVX_MAX_NUM_ROW, U2);
       transB::template loadBBlock<maxUBlock, toTemp, remM>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
       transB::template transposeLxL<0 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
       transB::template transposeLxL<1 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
-      EIGEN_IF_CONSTEXPR(maxUBlock < U2) transB::template transposeLxL<2 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
+      EIGEN_IF_CONSTEXPR (maxUBlock < U2) transB::template transposeLxL<2 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
       transB::template storeBBlock<maxUBlock, toTemp, remM, 0>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
 
-      EIGEN_IF_CONSTEXPR(maxUBlock < U2) {
+      EIGEN_IF_CONSTEXPR (maxUBlock < U2) {
         transB::template loadBBlock<EIGEN_AVX_MAX_NUM_ROW, toTemp, remM>(&B_arr[maxUBlock * LDB], LDB,
                                                                          &B_temp[maxUBlock], LDB_, ymm, remM_);
         transB::template transposeLxL<0>(ymm);
         transB::template storeBBlock<EIGEN_AVX_MAX_NUM_ROW, toTemp, remM, 0>(&B_arr[maxUBlock * LDB], LDB,
                                                                              &B_temp[maxUBlock], LDB_, ymm, remM_);
       }
-    }
-    else EIGEN_IF_CONSTEXPR(unrollN == U1) {
+    } else EIGEN_IF_CONSTEXPR (unrollN == U1) {
       // load LxU1 B col major, transpose LxU1 row major
       transB::template loadBBlock<U1, toTemp, remM>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
       transB::template transposeLxL<0>(ymm);
-      EIGEN_IF_CONSTEXPR(EIGEN_AVX_MAX_NUM_ROW < U1) { transB::template transposeLxL<1 * EIGEN_AVX_MAX_NUM_ROW>(ymm); }
+      EIGEN_IF_CONSTEXPR (EIGEN_AVX_MAX_NUM_ROW < U1) {
+        transB::template transposeLxL<1 * EIGEN_AVX_MAX_NUM_ROW>(ymm);
+      }
       transB::template storeBBlock<U1, toTemp, remM, 0>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
-    }
-    else EIGEN_IF_CONSTEXPR(unrollN == 8 && U1 > 8) {
+    } else EIGEN_IF_CONSTEXPR (unrollN == 8 && U1 > 8) {
       // load Lx4 B col major, transpose Lx4 row major
       transB::template loadBBlock<8, toTemp, remM>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
       transB::template transposeLxL<0>(ymm);
       transB::template storeBBlock<8, toTemp, remM, 8>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
-    }
-    else EIGEN_IF_CONSTEXPR(unrollN == 4 && U1 > 4) {
+    } else EIGEN_IF_CONSTEXPR (unrollN == 4 && U1 > 4) {
       // load Lx4 B col major, transpose Lx4 row major
       transB::template loadBBlock<4, toTemp, remM>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
       transB::template transposeLxL<0>(ymm);
       transB::template storeBBlock<4, toTemp, remM, 4>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
-    }
-    else EIGEN_IF_CONSTEXPR(unrollN == 2) {
+    } else EIGEN_IF_CONSTEXPR (unrollN == 2) {
       // load Lx2 B col major, transpose Lx2 row major
       transB::template loadBBlock<2, toTemp, remM, 2>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
       transB::template transposeLxL<0>(ymm);
       transB::template storeBBlock<2, toTemp, remM, 2>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
-    }
-    else EIGEN_IF_CONSTEXPR(unrollN == 1) {
+    } else EIGEN_IF_CONSTEXPR (unrollN == 1) {
       // load Lx1 B col major, transpose Lx1 row major
       transB::template loadBBlock<1, toTemp, remM, 1>(B_arr, LDB, B_temp, LDB_, ymm, remM_);
       transB::template transposeLxL<0>(ymm);
@@ -585,7 +571,7 @@
 template <typename Scalar>
 class trsm {
  public:
-  using vec = typename std::conditional<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>::type;
+  using vec = std::conditional_t<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>;
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
@@ -603,32 +589,27 @@
    *      for(startM = 0; startM < endM; startM++)
    *        for(startK = 0; startK < endK; startK++)
    **/
-  template <bool isFWDSolve, int64_t endM, int64_t endK, int64_t counter, bool krem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_loadRHS(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
-    constexpr int64_t counterReverse = endM * endK - counter;
-    constexpr int64_t startM = counterReverse / (endK);
-    constexpr int64_t startK = counterReverse % endK;
-
+  template <bool isFWDSolve, int64_t endK, int64_t index, bool krem>
+  static EIGEN_ALWAYS_INLINE void aux_loadRHS(Scalar *B_arr, int64_t LDB,
+                                              PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
+    constexpr int64_t startM = index / (endK);
+    constexpr int64_t startK = index % endK;
     constexpr int64_t packetIndex = startM * endK + startK;
     constexpr int64_t startM_ = isFWDSolve ? startM : -startM;
     const int64_t rhsIndex = (startK * PacketSize) + startM_ * LDB;
-    EIGEN_IF_CONSTEXPR(krem) {
+    EIGEN_IF_CONSTEXPR (krem) {
       RHSInPacket.packet[packetIndex] = ploadu<vec>(&B_arr[rhsIndex], remMask<PacketSize>(rem));
-    }
-    else {
+    } else {
       RHSInPacket.packet[packetIndex] = ploadu<vec>(&B_arr[rhsIndex]);
     }
-    aux_loadRHS<isFWDSolve, endM, endK, counter - 1, krem>(B_arr, LDB, RHSInPacket, rem);
   }
 
-  template <bool isFWDSolve, int64_t endM, int64_t endK, int64_t counter, bool krem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_loadRHS(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
-    EIGEN_UNUSED_VARIABLE(B_arr);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(RHSInPacket);
-    EIGEN_UNUSED_VARIABLE(rem);
+  template <bool isFWDSolve, int64_t endK, bool krem, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_loadRHS_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_arr,
+                                                   int64_t LDB, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                   int64_t rem = 0) {
+    int unused[] = {0, (aux_loadRHS<isFWDSolve, endK, indices, krem>(B_arr, LDB, RHSInPacket, rem), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -638,32 +619,27 @@
    *      for(startM = 0; startM < endM; startM++)
    *        for(startK = 0; startK < endK; startK++)
    **/
-  template <bool isFWDSolve, int64_t endM, int64_t endK, int64_t counter, bool krem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_storeRHS(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
-    constexpr int64_t counterReverse = endM * endK - counter;
-    constexpr int64_t startM = counterReverse / (endK);
-    constexpr int64_t startK = counterReverse % endK;
-
+  template <bool isFWDSolve, int64_t endK, int64_t index, bool krem>
+  static EIGEN_ALWAYS_INLINE void aux_storeRHS(Scalar *B_arr, int64_t LDB,
+                                               PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
+    constexpr int64_t startM = index / (endK);
+    constexpr int64_t startK = index % endK;
     constexpr int64_t packetIndex = startM * endK + startK;
     constexpr int64_t startM_ = isFWDSolve ? startM : -startM;
     const int64_t rhsIndex = (startK * PacketSize) + startM_ * LDB;
-    EIGEN_IF_CONSTEXPR(krem) {
+    EIGEN_IF_CONSTEXPR (krem) {
       pstoreu<Scalar>(&B_arr[rhsIndex], RHSInPacket.packet[packetIndex], remMask<PacketSize>(rem));
-    }
-    else {
+    } else {
       pstoreu<Scalar>(&B_arr[rhsIndex], RHSInPacket.packet[packetIndex]);
     }
-    aux_storeRHS<isFWDSolve, endM, endK, counter - 1, krem>(B_arr, LDB, RHSInPacket, rem);
   }
 
-  template <bool isFWDSolve, int64_t endM, int64_t endK, int64_t counter, bool krem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_storeRHS(
-      Scalar *B_arr, int64_t LDB, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
-    EIGEN_UNUSED_VARIABLE(B_arr);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(RHSInPacket);
-    EIGEN_UNUSED_VARIABLE(rem);
+  template <bool isFWDSolve, int64_t endK, bool krem, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_storeRHS_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_arr,
+                                                    int64_t LDB, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                    int64_t rem = 0) {
+    int unused[] = {0, (aux_storeRHS<isFWDSolve, endK, indices, krem>(B_arr, LDB, RHSInPacket, rem), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -674,20 +650,26 @@
    * 1-D unroll
    *      for(startK = 0; startK < endK; startK++)
    **/
-  template <int64_t currM, int64_t endK, int64_t counter>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0 && currM >= 0)> aux_divRHSByDiag(
-      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    constexpr int64_t counterReverse = endK - counter;
-    constexpr int64_t startK = counterReverse;
-
+  template <int64_t currM, int64_t endK, int64_t index>
+  static EIGEN_ALWAYS_INLINE void aux_divRHSByDiag(PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                   PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+    constexpr int64_t startK = index;
     constexpr int64_t packetIndex = currM * endK + startK;
     RHSInPacket.packet[packetIndex] = pmul(AInPacket.packet[currM], RHSInPacket.packet[packetIndex]);
-    aux_divRHSByDiag<currM, endK, counter - 1>(RHSInPacket, AInPacket);
   }
 
-  template <int64_t currM, int64_t endK, int64_t counter>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<!(counter > 0 && currM >= 0)> aux_divRHSByDiag(
-      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+  template <int64_t currM, int64_t endK, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(currM >= 0)> aux_divRHSByDiag_impl(
+      std::integer_sequence<int64_t, indices...>, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+    int unused[] = {0, (aux_divRHSByDiag<currM, endK, indices>(RHSInPacket, AInPacket), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  template <int64_t currM, int64_t endK, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE std::enable_if_t<(currM < 0)> aux_divRHSByDiag_impl(
+      std::integer_sequence<int64_t, indices...>, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
     EIGEN_UNUSED_VARIABLE(RHSInPacket);
     EIGEN_UNUSED_VARIABLE(AInPacket);
   }
@@ -699,53 +681,49 @@
    *      for(startM = initM; startM < endM; startM++)
    *        for(startK = 0; startK < endK; startK++)
    **/
-  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t initM, int64_t endM, int64_t endK,
-            int64_t counter, int64_t currentM>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_updateRHS(
-      Scalar *A_arr, int64_t LDA, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
-      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    constexpr int64_t counterReverse = (endM - initM) * endK - counter;
-    constexpr int64_t startM = initM + counterReverse / (endK);
-    constexpr int64_t startK = counterReverse % endK;
-
+  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t initM, int64_t endK, int64_t index,
+            int64_t currentM>
+  static EIGEN_ALWAYS_INLINE void aux_updateRHS(Scalar *A_arr, int64_t LDA,
+                                                PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+    constexpr int64_t startM = initM + index / (endK);
+    constexpr int64_t startK = index % endK;
     // For each row of A, first update all corresponding RHS
     constexpr int64_t packetIndex = startM * endK + startK;
-    EIGEN_IF_CONSTEXPR(currentM > 0) {
-      RHSInPacket.packet[packetIndex] =
-          pnmadd(AInPacket.packet[startM], RHSInPacket.packet[(currentM - 1) * endK + startK],
-                 RHSInPacket.packet[packetIndex]);
+    constexpr int64_t previousM = currentM > 0 ? currentM - 1 : 0;
+    EIGEN_IF_CONSTEXPR (currentM > 0) {
+      RHSInPacket.packet[packetIndex] = pnmadd(AInPacket.packet[startM], RHSInPacket.packet[previousM * endK + startK],
+                                               RHSInPacket.packet[packetIndex]);
     }
 
-    EIGEN_IF_CONSTEXPR(startK == endK - 1) {
+    EIGEN_IF_CONSTEXPR (startK == endK - 1) {
       // Once all RHS for previous row of A is updated, we broadcast the next element in the column A_{i, currentM}.
-      EIGEN_IF_CONSTEXPR(startM == currentM && !isUnitDiag) {
+      EIGEN_IF_CONSTEXPR (startM == currentM && !isUnitDiag) {
         // If diagonal is not unit, we broadcast reciprocals of diagonals AinPacket.packet[currentM].
         // This will be used in divRHSByDiag
-        EIGEN_IF_CONSTEXPR(isFWDSolve)
-        AInPacket.packet[currentM] = pset1<vec>(Scalar(1) / A_arr[idA<isARowMajor>(currentM, currentM, LDA)]);
-        else AInPacket.packet[currentM] = pset1<vec>(Scalar(1) / A_arr[idA<isARowMajor>(-currentM, -currentM, LDA)]);
-      }
-      else {
+        EIGEN_IF_CONSTEXPR (isFWDSolve)
+          AInPacket.packet[currentM] = pset1<vec>(Scalar(1) / A_arr[idA<isARowMajor>(currentM, currentM, LDA)]);
+        else
+          AInPacket.packet[currentM] = pset1<vec>(Scalar(1) / A_arr[idA<isARowMajor>(-currentM, -currentM, LDA)]);
+      } else {
         // Broadcast next off diagonal element of A
-        EIGEN_IF_CONSTEXPR(isFWDSolve)
-        AInPacket.packet[startM] = pset1<vec>(A_arr[idA<isARowMajor>(startM, currentM, LDA)]);
-        else AInPacket.packet[startM] = pset1<vec>(A_arr[idA<isARowMajor>(-startM, -currentM, LDA)]);
+        EIGEN_IF_CONSTEXPR (isFWDSolve)
+          AInPacket.packet[startM] = pset1<vec>(A_arr[idA<isARowMajor>(startM, currentM, LDA)]);
+        else
+          AInPacket.packet[startM] = pset1<vec>(A_arr[idA<isARowMajor>(-startM, -currentM, LDA)]);
       }
     }
-
-    aux_updateRHS<isARowMajor, isFWDSolve, isUnitDiag, initM, endM, endK, counter - 1, currentM>(
-        A_arr, LDA, RHSInPacket, AInPacket);
   }
 
-  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t initM, int64_t endM, int64_t endK,
-            int64_t counter, int64_t currentM>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_updateRHS(
-      Scalar *A_arr, int64_t LDA, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
-      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    EIGEN_UNUSED_VARIABLE(A_arr);
-    EIGEN_UNUSED_VARIABLE(LDA);
-    EIGEN_UNUSED_VARIABLE(RHSInPacket);
-    EIGEN_UNUSED_VARIABLE(AInPacket);
+  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t initM, int64_t endK, int64_t currentM,
+            int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_updateRHS_impl(std::integer_sequence<int64_t, indices...>, Scalar *A_arr,
+                                                     int64_t LDA, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                     PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+    int unused[] = {0, (aux_updateRHS<isARowMajor, isFWDSolve, isUnitDiag, initM, endK, indices, currentM>(
+                            A_arr, LDA, RHSInPacket, AInPacket),
+                        0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -754,13 +732,11 @@
    * 1-D unroll
    *      for(startM = 0; startM < endM; startM++)
    **/
-  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t endM, int64_t counter, int64_t numK>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_triSolveMicroKernel(
-      Scalar *A_arr, int64_t LDA, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
-      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    constexpr int64_t counterReverse = endM - counter;
-    constexpr int64_t startM = counterReverse;
-
+  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t endM, int64_t index, int64_t numK>
+  static EIGEN_ALWAYS_INLINE void aux_triSolveMicroKernel(Scalar *A_arr, int64_t LDA,
+                                                          PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                          PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+    constexpr int64_t startM = index;
     constexpr int64_t currentM = startM;
     // Divides the right-hand side in row startM, by digonal value of A
     // broadcasted to AInPacket.packet[startM-1] in the previous iteration.
@@ -768,8 +744,8 @@
     // Without "if constexpr" the compiler instantiates the case <-1, numK>
     // this is handled with enable_if to prevent out-of-bound warnings
     // from the compiler
-    EIGEN_IF_CONSTEXPR(!isUnitDiag && startM > 0)
-    trsm::template divRHSByDiag<startM - 1, numK>(RHSInPacket, AInPacket);
+    EIGEN_IF_CONSTEXPR (!isUnitDiag && startM > 0)
+      trsm::template divRHSByDiag<startM - 1, numK>(RHSInPacket, AInPacket);
 
     // After division, the rhs corresponding to subsequent rows of A can be partially updated
     // We also broadcast the reciprocal of the next diagonal to AInPacket.packet[currentM] (if needed)
@@ -778,25 +754,23 @@
                                                                                                 AInPacket);
 
     // Handle division for the RHS corresponding to the final row of A.
-    EIGEN_IF_CONSTEXPR(!isUnitDiag && startM == endM - 1)
-    trsm::template divRHSByDiag<startM, numK>(RHSInPacket, AInPacket);
-
-    aux_triSolveMicroKernel<isARowMajor, isFWDSolve, isUnitDiag, endM, counter - 1, numK>(A_arr, LDA, RHSInPacket,
-                                                                                          AInPacket);
+    EIGEN_IF_CONSTEXPR (!isUnitDiag && startM == endM - 1)
+      trsm::template divRHSByDiag<startM, numK>(RHSInPacket, AInPacket);
   }
 
-  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t endM, int64_t counter, int64_t numK>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_triSolveMicroKernel(
-      Scalar *A_arr, int64_t LDA, PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
-      PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    EIGEN_UNUSED_VARIABLE(A_arr);
-    EIGEN_UNUSED_VARIABLE(LDA);
-    EIGEN_UNUSED_VARIABLE(RHSInPacket);
-    EIGEN_UNUSED_VARIABLE(AInPacket);
+  template <bool isARowMajor, bool isFWDSolve, bool isUnitDiag, int64_t endM, int64_t numK, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_triSolveMicroKernel_impl(std::integer_sequence<int64_t, indices...>,
+                                                               Scalar *A_arr, int64_t LDA,
+                                                               PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
+                                                               PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
+    int unused[] = {0, (aux_triSolveMicroKernel<isARowMajor, isFWDSolve, isUnitDiag, endM, indices, numK>(
+                            A_arr, LDA, RHSInPacket, AInPacket),
+                        0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /********************************************************
-   * Wrappers for aux_XXXX to hide counter parameter
+   * Wrappers for aux_XXXX to build index sequences
    ********************************************************/
 
   /**
@@ -806,7 +780,8 @@
   template <bool isFWDSolve, int64_t endM, int64_t endK, bool krem = false>
   static EIGEN_ALWAYS_INLINE void loadRHS(Scalar *B_arr, int64_t LDB,
                                           PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
-    aux_loadRHS<isFWDSolve, endM, endK, endM * endK, krem>(B_arr, LDB, RHSInPacket, rem);
+    aux_loadRHS_impl<isFWDSolve, endK, krem>(std::make_integer_sequence<int64_t, endM * endK>{}, B_arr, LDB,
+                                             RHSInPacket, rem);
   }
 
   /**
@@ -816,7 +791,8 @@
   template <bool isFWDSolve, int64_t endM, int64_t endK, bool krem = false>
   static EIGEN_ALWAYS_INLINE void storeRHS(Scalar *B_arr, int64_t LDB,
                                            PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket, int64_t rem = 0) {
-    aux_storeRHS<isFWDSolve, endM, endK, endM * endK, krem>(B_arr, LDB, RHSInPacket, rem);
+    aux_storeRHS_impl<isFWDSolve, endK, krem>(std::make_integer_sequence<int64_t, endM * endK>{}, B_arr, LDB,
+                                              RHSInPacket, rem);
   }
 
   /**
@@ -825,7 +801,7 @@
   template <int64_t currM, int64_t endK>
   static EIGEN_ALWAYS_INLINE void divRHSByDiag(PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
                                                PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    aux_divRHSByDiag<currM, endK, endK>(RHSInPacket, AInPacket);
+    aux_divRHSByDiag_impl<currM, endK>(std::make_integer_sequence<int64_t, endK>{}, RHSInPacket, AInPacket);
   }
 
   /**
@@ -837,8 +813,8 @@
   static EIGEN_ALWAYS_INLINE void updateRHS(Scalar *A_arr, int64_t LDA,
                                             PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
                                             PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
-    aux_updateRHS<isARowMajor, isFWDSolve, isUnitDiag, startM, endM, endK, (endM - startM) * endK, currentM>(
-        A_arr, LDA, RHSInPacket, AInPacket);
+    aux_updateRHS_impl<isARowMajor, isFWDSolve, isUnitDiag, startM, endK, currentM>(
+        std::make_integer_sequence<int64_t, (endM - startM) * endK>{}, A_arr, LDA, RHSInPacket, AInPacket);
   }
 
   /**
@@ -852,7 +828,8 @@
                                                       PacketBlock<vec, EIGEN_AVX_MAX_NUM_ACC> &RHSInPacket,
                                                       PacketBlock<vec, EIGEN_AVX_MAX_NUM_ROW> &AInPacket) {
     static_assert(numK >= 1 && numK <= 3, "numK out of range");
-    aux_triSolveMicroKernel<isARowMajor, isFWDSolve, isUnitDiag, endM, endM, numK>(A_arr, LDA, RHSInPacket, AInPacket);
+    aux_triSolveMicroKernel_impl<isARowMajor, isFWDSolve, isUnitDiag, endM, numK>(
+        std::make_integer_sequence<int64_t, endM>{}, A_arr, LDA, RHSInPacket, AInPacket);
   }
 };
 
@@ -864,7 +841,7 @@
 template <typename Scalar, bool isAdd>
 class gemm {
  public:
-  using vec = typename std::conditional<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>::type;
+  using vec = std::conditional_t<std::is_same<Scalar, float>::value, vecFullFloat, vecFullDouble>;
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
@@ -883,21 +860,19 @@
    *      for(startM = 0; startM < endM; startM++)
    *        for(startN = 0; startN < endN; startN++)
    **/
-  template <int64_t endM, int64_t endN, int64_t counter>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_setzero(
-      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
-    constexpr int64_t counterReverse = endM * endN - counter;
-    constexpr int64_t startM = counterReverse / (endN);
-    constexpr int64_t startN = counterReverse % endN;
+  template <int64_t endM, int64_t endN, int64_t index>
+  static EIGEN_ALWAYS_INLINE void aux_setzero(PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
+    constexpr int64_t startM = index / (endN);
+    constexpr int64_t startN = index % endN;
 
     zmm.packet[startN * endM + startM] = pzero(zmm.packet[startN * endM + startM]);
-    aux_setzero<endM, endN, counter - 1>(zmm);
   }
 
-  template <int64_t endM, int64_t endN, int64_t counter>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_setzero(
-      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
-    EIGEN_UNUSED_VARIABLE(zmm);
+  template <int64_t endM, int64_t endN, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_setzero_impl(std::integer_sequence<int64_t, indices...>,
+                                                   PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
+    int unused[] = {0, (aux_setzero<endM, endN, indices>(zmm), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -907,30 +882,30 @@
    *      for(startM = 0; startM < endM; startM++)
    *        for(startN = 0; startN < endN; startN++)
    **/
-  template <int64_t endM, int64_t endN, int64_t counter, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_updateC(
-      Scalar *C_arr, int64_t LDC, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
+  template <int64_t endM, int64_t endN, int64_t index, bool rem>
+  static EIGEN_ALWAYS_INLINE void aux_updateC(Scalar *C_arr, int64_t LDC,
+                                              PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                              int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    constexpr int64_t counterReverse = endM * endN - counter;
-    constexpr int64_t startM = counterReverse / (endN);
-    constexpr int64_t startN = counterReverse % endN;
+    constexpr int64_t startM = index / (endN);
+    constexpr int64_t startN = index % endN;
 
-    EIGEN_IF_CONSTEXPR(rem)
-    zmm.packet[startN * endM + startM] =
-        padd(ploadu<vec>(&C_arr[(startN)*LDC + startM * PacketSize], remMask<PacketSize>(rem_)),
-             zmm.packet[startN * endM + startM], remMask<PacketSize>(rem_));
-    else zmm.packet[startN * endM + startM] =
-        padd(ploadu<vec>(&C_arr[(startN)*LDC + startM * PacketSize]), zmm.packet[startN * endM + startM]);
-    aux_updateC<endM, endN, counter - 1, rem>(C_arr, LDC, zmm, rem_);
+    EIGEN_IF_CONSTEXPR (rem)
+      zmm.packet[startN * endM + startM] =
+          padd(ploadu<vec>(&C_arr[(startN)*LDC + startM * PacketSize], remMask<PacketSize>(rem_)),
+               zmm.packet[startN * endM + startM], remMask<PacketSize>(rem_));
+    else
+      zmm.packet[startN * endM + startM] =
+          padd(ploadu<vec>(&C_arr[(startN)*LDC + startM * PacketSize]), zmm.packet[startN * endM + startM]);
   }
 
-  template <int64_t endM, int64_t endN, int64_t counter, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_updateC(
-      Scalar *C_arr, int64_t LDC, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
-    EIGEN_UNUSED_VARIABLE(C_arr);
-    EIGEN_UNUSED_VARIABLE(LDC);
-    EIGEN_UNUSED_VARIABLE(zmm);
-    EIGEN_UNUSED_VARIABLE(rem_);
+  template <int64_t endM, int64_t endN, bool rem, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_updateC_impl(std::integer_sequence<int64_t, indices...>, Scalar *C_arr,
+                                                   int64_t LDC,
+                                                   PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                   int64_t rem_ = 0) {
+    int unused[] = {0, (aux_updateC<endM, endN, indices, rem>(C_arr, LDC, zmm, rem_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -940,28 +915,28 @@
    *      for(startM = 0; startM < endM; startM++)
    *        for(startN = 0; startN < endN; startN++)
    **/
-  template <int64_t endM, int64_t endN, int64_t counter, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_storeC(
-      Scalar *C_arr, int64_t LDC, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
+  template <int64_t endM, int64_t endN, int64_t index, bool rem>
+  static EIGEN_ALWAYS_INLINE void aux_storeC(Scalar *C_arr, int64_t LDC,
+                                             PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                             int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    constexpr int64_t counterReverse = endM * endN - counter;
-    constexpr int64_t startM = counterReverse / (endN);
-    constexpr int64_t startN = counterReverse % endN;
+    constexpr int64_t startM = index / (endN);
+    constexpr int64_t startN = index % endN;
 
-    EIGEN_IF_CONSTEXPR(rem)
-    pstoreu<Scalar>(&C_arr[(startN)*LDC + startM * PacketSize], zmm.packet[startN * endM + startM],
-                    remMask<PacketSize>(rem_));
-    else pstoreu<Scalar>(&C_arr[(startN)*LDC + startM * PacketSize], zmm.packet[startN * endM + startM]);
-    aux_storeC<endM, endN, counter - 1, rem>(C_arr, LDC, zmm, rem_);
+    EIGEN_IF_CONSTEXPR (rem)
+      pstoreu<Scalar>(&C_arr[(startN)*LDC + startM * PacketSize], zmm.packet[startN * endM + startM],
+                      remMask<PacketSize>(rem_));
+    else
+      pstoreu<Scalar>(&C_arr[(startN)*LDC + startM * PacketSize], zmm.packet[startN * endM + startM]);
   }
 
-  template <int64_t endM, int64_t endN, int64_t counter, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_storeC(
-      Scalar *C_arr, int64_t LDC, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
-    EIGEN_UNUSED_VARIABLE(C_arr);
-    EIGEN_UNUSED_VARIABLE(LDC);
-    EIGEN_UNUSED_VARIABLE(zmm);
-    EIGEN_UNUSED_VARIABLE(rem_);
+  template <int64_t endM, int64_t endN, bool rem, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_storeC_impl(std::integer_sequence<int64_t, indices...>, Scalar *C_arr,
+                                                  int64_t LDC,
+                                                  PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                  int64_t rem_ = 0) {
+    int unused[] = {0, (aux_storeC<endM, endN, indices, rem>(C_arr, LDC, zmm, rem_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -970,29 +945,28 @@
    * 1-D unroll
    *      for(startL = 0; startL < endL; startL++)
    **/
-  template <int64_t unrollM, int64_t unrollN, int64_t endL, int64_t counter, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_startLoadB(
-      Scalar *B_t, int64_t LDB, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
+  template <int64_t unrollM, int64_t unrollN, int64_t index, bool rem>
+  static EIGEN_ALWAYS_INLINE void aux_startLoadB(Scalar *B_t, int64_t LDB,
+                                                 PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                 int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    constexpr int64_t counterReverse = endL - counter;
-    constexpr int64_t startL = counterReverse;
+    constexpr int64_t startL = index;
 
-    EIGEN_IF_CONSTEXPR(rem)
-    zmm.packet[unrollM * unrollN + startL] =
-        ploadu<vec>(&B_t[(startL / unrollM) * LDB + (startL % unrollM) * PacketSize], remMask<PacketSize>(rem_));
-    else zmm.packet[unrollM * unrollN + startL] =
-        ploadu<vec>(&B_t[(startL / unrollM) * LDB + (startL % unrollM) * PacketSize]);
-
-    aux_startLoadB<unrollM, unrollN, endL, counter - 1, rem>(B_t, LDB, zmm, rem_);
+    EIGEN_IF_CONSTEXPR (rem)
+      zmm.packet[unrollM * unrollN + startL] =
+          ploadu<vec>(&B_t[(startL / unrollM) * LDB + (startL % unrollM) * PacketSize], remMask<PacketSize>(rem_));
+    else
+      zmm.packet[unrollM * unrollN + startL] =
+          ploadu<vec>(&B_t[(startL / unrollM) * LDB + (startL % unrollM) * PacketSize]);
   }
 
-  template <int64_t unrollM, int64_t unrollN, int64_t endL, int64_t counter, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_startLoadB(
-      Scalar *B_t, int64_t LDB, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
-    EIGEN_UNUSED_VARIABLE(B_t);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(zmm);
-    EIGEN_UNUSED_VARIABLE(rem_);
+  template <int64_t unrollM, int64_t unrollN, bool rem, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_startLoadB_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_t,
+                                                      int64_t LDB,
+                                                      PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                      int64_t rem_ = 0) {
+    int unused[] = {0, (aux_startLoadB<unrollM, unrollN, indices, rem>(B_t, LDB, zmm, rem_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -1001,23 +975,20 @@
    * 1-D unroll
    *      for(startB = 0; startB < endB; startB++)
    **/
-  template <bool isARowMajor, int64_t unrollM, int64_t unrollN, int64_t endB, int64_t counter, int64_t numLoad>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_startBCastA(
-      Scalar *A_t, int64_t LDA, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
-    constexpr int64_t counterReverse = endB - counter;
-    constexpr int64_t startB = counterReverse;
+  template <bool isARowMajor, int64_t unrollM, int64_t unrollN, int64_t index, int64_t numLoad>
+  static EIGEN_ALWAYS_INLINE void aux_startBCastA(Scalar *A_t, int64_t LDA,
+                                                  PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
+    constexpr int64_t startB = index;
 
     zmm.packet[unrollM * unrollN + numLoad + startB] = pload1<vec>(&A_t[idA<isARowMajor>(startB, 0, LDA)]);
-
-    aux_startBCastA<isARowMajor, unrollM, unrollN, endB, counter - 1, numLoad>(A_t, LDA, zmm);
   }
 
-  template <bool isARowMajor, int64_t unrollM, int64_t unrollN, int64_t endB, int64_t counter, int64_t numLoad>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_startBCastA(
-      Scalar *A_t, int64_t LDA, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
-    EIGEN_UNUSED_VARIABLE(A_t);
-    EIGEN_UNUSED_VARIABLE(LDA);
-    EIGEN_UNUSED_VARIABLE(zmm);
+  template <bool isARowMajor, int64_t unrollM, int64_t unrollN, int64_t numLoad, int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_startBCastA_impl(std::integer_sequence<int64_t, indices...>, Scalar *A_t,
+                                                       int64_t LDA,
+                                                       PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
+    int unused[] = {0, (aux_startBCastA<isARowMajor, unrollM, unrollN, indices, numLoad>(A_t, LDA, zmm), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -1027,36 +998,33 @@
    * 1-D unroll
    *      for(startM = 0; startM < endM; startM++)
    **/
-  template <int64_t endM, int64_t counter, int64_t unrollN, int64_t currK, int64_t unrollK, int64_t numLoad,
+  template <int64_t endM, int64_t index, int64_t unrollN, int64_t currK, int64_t unrollK, int64_t numLoad,
             int64_t numBCast, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_loadB(
-      Scalar *B_t, int64_t LDB, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
+  static EIGEN_ALWAYS_INLINE void aux_loadB(Scalar *B_t, int64_t LDB,
+                                            PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                            int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
     if ((numLoad / endM + currK < unrollK)) {
-      constexpr int64_t counterReverse = endM - counter;
-      constexpr int64_t startM = counterReverse;
+      constexpr int64_t startM = index;
 
-      EIGEN_IF_CONSTEXPR(rem) {
+      EIGEN_IF_CONSTEXPR (rem) {
         zmm.packet[endM * unrollN + (startM + currK * endM) % numLoad] =
             ploadu<vec>(&B_t[(numLoad / endM + currK) * LDB + startM * PacketSize], remMask<PacketSize>(rem_));
-      }
-      else {
+      } else {
         zmm.packet[endM * unrollN + (startM + currK * endM) % numLoad] =
             ploadu<vec>(&B_t[(numLoad / endM + currK) * LDB + startM * PacketSize]);
       }
-
-      aux_loadB<endM, counter - 1, unrollN, currK, unrollK, numLoad, numBCast, rem>(B_t, LDB, zmm, rem_);
     }
   }
 
-  template <int64_t endM, int64_t counter, int64_t unrollN, int64_t currK, int64_t unrollK, int64_t numLoad,
-            int64_t numBCast, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_loadB(
-      Scalar *B_t, int64_t LDB, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm, int64_t rem_ = 0) {
-    EIGEN_UNUSED_VARIABLE(B_t);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(zmm);
-    EIGEN_UNUSED_VARIABLE(rem_);
+  template <int64_t endM, int64_t unrollN, int64_t currK, int64_t unrollK, int64_t numLoad, int64_t numBCast, bool rem,
+            int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_loadB_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_t, int64_t LDB,
+                                                 PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                 int64_t rem_ = 0) {
+    int unused[] = {
+        0, (aux_loadB<endM, indices, unrollN, currK, unrollK, numLoad, numBCast, rem>(B_t, LDB, zmm, rem_), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /**
@@ -1067,68 +1035,64 @@
    *        for(startN = 0; startN < endN; startN++)
    *          for(startK = 0; startK < endK; startK++)
    **/
-  template <bool isARowMajor, int64_t endM, int64_t endN, int64_t endK, int64_t counter, int64_t numLoad,
+  template <bool isARowMajor, int64_t endM, int64_t endN, int64_t endK, int64_t index, int64_t numLoad,
             int64_t numBCast, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter > 0)> aux_microKernel(
-      Scalar *B_t, Scalar *A_t, int64_t LDB, int64_t LDA, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
-      int64_t rem_ = 0) {
+  static EIGEN_ALWAYS_INLINE void aux_microKernel(Scalar *B_t, Scalar *A_t, int64_t LDB, int64_t LDA,
+                                                  PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                  int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    constexpr int64_t counterReverse = endM * endN * endK - counter;
-    constexpr int startK = counterReverse / (endM * endN);
-    constexpr int startN = (counterReverse / (endM)) % endN;
-    constexpr int startM = counterReverse % endM;
+    constexpr int startK = index / (endM * endN);
+    constexpr int startN = (index / (endM)) % endN;
+    constexpr int startM = index % endM;
 
-    EIGEN_IF_CONSTEXPR(startK == 0 && startM == 0 && startN == 0) {
+    EIGEN_IF_CONSTEXPR (startK == 0 && startM == 0 && startN == 0) {
       gemm::template startLoadB<endM, endN, numLoad, rem>(B_t, LDB, zmm, rem_);
       gemm::template startBCastA<isARowMajor, endM, endN, numBCast, numLoad>(A_t, LDA, zmm);
     }
 
     {
       // Interleave FMA and Bcast
-      EIGEN_IF_CONSTEXPR(isAdd) {
+      EIGEN_IF_CONSTEXPR (isAdd) {
         zmm.packet[startN * endM + startM] =
             pmadd(zmm.packet[endM * endN + numLoad + (startN + startK * endN) % numBCast],
                   zmm.packet[endM * endN + (startM + startK * endM) % numLoad], zmm.packet[startN * endM + startM]);
-      }
-      else {
+      } else {
         zmm.packet[startN * endM + startM] =
             pnmadd(zmm.packet[endM * endN + numLoad + (startN + startK * endN) % numBCast],
                    zmm.packet[endM * endN + (startM + startK * endM) % numLoad], zmm.packet[startN * endM + startM]);
       }
       // Bcast
-      EIGEN_IF_CONSTEXPR(startM == endM - 1 && (numBCast + startN + startK * endN < endK * endN)) {
+      EIGEN_IF_CONSTEXPR (startM == endM - 1 && (numBCast + startN + startK * endN < endK * endN)) {
         zmm.packet[endM * endN + numLoad + (startN + startK * endN) % numBCast] = pload1<vec>(&A_t[idA<isARowMajor>(
             (numBCast + startN + startK * endN) % endN, (numBCast + startN + startK * endN) / endN, LDA)]);
       }
     }
 
     // We have updated all accumulators, time to load next set of B's
-    EIGEN_IF_CONSTEXPR((startN == endN - 1) && (startM == endM - 1)) {
+    EIGEN_IF_CONSTEXPR ((startN == endN - 1) && (startM == endM - 1)) {
       gemm::template loadB<endM, endN, startK, endK, numLoad, numBCast, rem>(B_t, LDB, zmm, rem_);
     }
-    aux_microKernel<isARowMajor, endM, endN, endK, counter - 1, numLoad, numBCast, rem>(B_t, A_t, LDB, LDA, zmm, rem_);
   }
 
-  template <bool isARowMajor, int64_t endM, int64_t endN, int64_t endK, int64_t counter, int64_t numLoad,
-            int64_t numBCast, bool rem>
-  static EIGEN_ALWAYS_INLINE std::enable_if_t<(counter <= 0)> aux_microKernel(
-      Scalar *B_t, Scalar *A_t, int64_t LDB, int64_t LDA, PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
-      int64_t rem_ = 0) {
-    EIGEN_UNUSED_VARIABLE(B_t);
-    EIGEN_UNUSED_VARIABLE(A_t);
-    EIGEN_UNUSED_VARIABLE(LDB);
-    EIGEN_UNUSED_VARIABLE(LDA);
-    EIGEN_UNUSED_VARIABLE(zmm);
-    EIGEN_UNUSED_VARIABLE(rem_);
+  template <bool isARowMajor, int64_t endM, int64_t endN, int64_t endK, int64_t numLoad, int64_t numBCast, bool rem,
+            int64_t... indices>
+  static EIGEN_ALWAYS_INLINE void aux_microKernel_impl(std::integer_sequence<int64_t, indices...>, Scalar *B_t,
+                                                       Scalar *A_t, int64_t LDB, int64_t LDA,
+                                                       PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
+                                                       int64_t rem_ = 0) {
+    int unused[] = {0, (aux_microKernel<isARowMajor, endM, endN, endK, indices, numLoad, numBCast, rem>(B_t, A_t, LDB,
+                                                                                                        LDA, zmm, rem_),
+                        0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   /********************************************************
-   * Wrappers for aux_XXXX to hide counter parameter
+   * Wrappers for aux_XXXX to build index sequences
    ********************************************************/
 
   template <int64_t endM, int64_t endN>
   static EIGEN_ALWAYS_INLINE void setzero(PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
-    aux_setzero<endM, endN, endM * endN>(zmm);
+    aux_setzero_impl<endM, endN>(std::make_integer_sequence<int64_t, endM * endN>{}, zmm);
   }
 
   /**
@@ -1139,7 +1103,7 @@
                                           PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
                                           int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    aux_updateC<endM, endN, endM * endN, rem>(C_arr, LDC, zmm, rem_);
+    aux_updateC_impl<endM, endN, rem>(std::make_integer_sequence<int64_t, endM * endN>{}, C_arr, LDC, zmm, rem_);
   }
 
   template <int64_t endM, int64_t endN, bool rem = false>
@@ -1147,7 +1111,7 @@
                                          PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
                                          int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    aux_storeC<endM, endN, endM * endN, rem>(C_arr, LDC, zmm, rem_);
+    aux_storeC_impl<endM, endN, rem>(std::make_integer_sequence<int64_t, endM * endN>{}, C_arr, LDC, zmm, rem_);
   }
 
   /**
@@ -1158,7 +1122,7 @@
                                              PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
                                              int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    aux_startLoadB<unrollM, unrollN, endL, endL, rem>(B_t, LDB, zmm, rem_);
+    aux_startLoadB_impl<unrollM, unrollN, rem>(std::make_integer_sequence<int64_t, endL>{}, B_t, LDB, zmm, rem_);
   }
 
   /**
@@ -1167,7 +1131,8 @@
   template <bool isARowMajor, int64_t unrollM, int64_t unrollN, int64_t endB, int64_t numLoad>
   static EIGEN_ALWAYS_INLINE void startBCastA(Scalar *A_t, int64_t LDA,
                                               PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm) {
-    aux_startBCastA<isARowMajor, unrollM, unrollN, endB, endB, numLoad>(A_t, LDA, zmm);
+    aux_startBCastA_impl<isARowMajor, unrollM, unrollN, numLoad>(std::make_integer_sequence<int64_t, endB>{}, A_t, LDA,
+                                                                 zmm);
   }
 
   /**
@@ -1178,7 +1143,8 @@
                                         PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
                                         int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    aux_loadB<endM, endM, unrollN, currK, unrollK, numLoad, numBCast, rem>(B_t, LDB, zmm, rem_);
+    aux_loadB_impl<endM, unrollN, currK, unrollK, numLoad, numBCast, rem>(std::make_integer_sequence<int64_t, endM>{},
+                                                                          B_t, LDB, zmm, rem_);
   }
 
   /**
@@ -1210,8 +1176,8 @@
                                               PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS> &zmm,
                                               int64_t rem_ = 0) {
     EIGEN_UNUSED_VARIABLE(rem_);
-    aux_microKernel<isARowMajor, endM, endN, endK, endM * endN * endK, numLoad, numBCast, rem>(B_t, A_t, LDB, LDA, zmm,
-                                                                                               rem_);
+    aux_microKernel_impl<isARowMajor, endM, endN, endK, numLoad, numBCast, rem>(
+        std::make_integer_sequence<int64_t, endM * endN * endK>{}, B_t, A_t, LDB, LDA, zmm, rem_);
   }
 };
 }  // namespace unrolls
diff --git a/Eigen/src/Core/arch/AVX512/TypeCasting.h b/Eigen/src/Core/arch/AVX512/TypeCasting.h
index 6c42909..eaad29d 100644
--- a/Eigen/src/Core/arch/AVX512/TypeCasting.h
+++ b/Eigen/src/Core/arch/AVX512/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_AVX512_H
 #define EIGEN_TYPE_CASTING_AVX512_H
diff --git a/Eigen/src/Core/arch/AVX512/TypeCastingFP16.h b/Eigen/src/Core/arch/AVX512/TypeCastingFP16.h
index f06f13d..09affca 100644
--- a/Eigen/src/Core/arch/AVX512/TypeCastingFP16.h
+++ b/Eigen/src/Core/arch/AVX512/TypeCastingFP16.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_FP16_AVX512_H
 #define EIGEN_TYPE_CASTING_FP16_AVX512_H
diff --git a/Eigen/src/Core/arch/AltiVec/Complex.h b/Eigen/src/Core/arch/AltiVec/Complex.h
index 12d73ed..b5047d8 100644
--- a/Eigen/src/Core/arch/AltiVec/Complex.h
+++ b/Eigen/src/Core/arch/AltiVec/Complex.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX32_ALTIVEC_H
 #define EIGEN_COMPLEX32_ALTIVEC_H
@@ -18,6 +19,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 inline Packet4ui p4ui_CONJ_XOR() {
   return vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_MZERO);  //{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 };
 }
@@ -546,11 +549,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
-  return pset1<Packet1cd>(*from);
-}
-
-template <>
 EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double>* addr) {
   EIGEN_PPC_PREFETCH(addr);
 }
@@ -563,21 +561,6 @@
   return res[0];
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
 EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
 
 template <>
@@ -611,6 +594,8 @@
 EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS_NO_EXP(Packet1cd)
 
 #endif  // __VSX__
+
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/AltiVec/MathFunctions.h b/Eigen/src/Core/arch/AltiVec/MathFunctions.h
index c95ee38..b7cf140 100644
--- a/Eigen/src/Core/arch/AltiVec/MathFunctions.h
+++ b/Eigen/src/Core/arch/AltiVec/MathFunctions.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_ALTIVEC_H
 #define EIGEN_MATH_FUNCTIONS_ALTIVEC_H
diff --git a/Eigen/src/Core/arch/AltiVec/MatrixProduct.h b/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
index 4725526..697dbb4 100644
--- a/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
+++ b/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIX_PRODUCT_ALTIVEC_H
 #define EIGEN_MATRIX_PRODUCT_ALTIVEC_H
@@ -84,7 +85,7 @@
 };
 
 // MatrixProduct decomposes real/imaginary vectors into a real vector and an imaginary vector, this turned out
-// to be faster than Eigen's usual approach of having real/imaginary pairs on a single vector. This constants then
+// to be faster than Eigen's usual approach of having real/imaginary pairs on a single vector. These constants then
 // are responsible to extract from convert between Eigen's and MatrixProduct approach.
 
 const static Packet16uc p16uc_GETREAL32 = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27};
@@ -367,10 +368,10 @@
   const Index size = 16 / sizeof(Scalar);
   pstore<Scalar>(to + (0 * size), block.packet[0]);
   pstore<Scalar>(to + (1 * size), block.packet[1]);
-  if (N > 2) {
+  EIGEN_IF_CONSTEXPR (N > 2) {
     pstore<Scalar>(to + (2 * size), block.packet[2]);
   }
-  if (N > 3) {
+  EIGEN_IF_CONSTEXPR (N > 3) {
     pstore<Scalar>(to + (3 * size), block.packet[3]);
   }
 }
@@ -381,7 +382,7 @@
 struct dhs_cpack {
   template <bool transpose>
   EIGEN_ALWAYS_INLINE void dhs_cblock(PacketBlock<PacketC, 8>& cblock, PacketBlock<Packet, 4>& block,
-                                      Packet16uc permute) {
+                                      const Packet16uc& permute) {
     if (transpose) {
       block.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, permute);
       block.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, permute);
@@ -423,13 +424,13 @@
     PacketBlock<PacketC, 8> cblock;
 
     for (; i + vectorSize <= depth; i += vectorSize) {
-      if (UseLhs) {
+      EIGEN_IF_CONSTEXPR (UseLhs) {
         bload<DataMapper, PacketC, 2, StorageOrder, true, 4>(cblock, lhs2, 0, i);
       } else {
         bload<DataMapper, PacketC, 2, StorageOrder, true, 4>(cblock, lhs2, i, 0);
       }
 
-      if (((StorageOrder == RowMajor) && UseLhs) || (((StorageOrder == ColMajor) && !UseLhs))) {
+      EIGEN_IF_CONSTEXPR (((StorageOrder == RowMajor) && UseLhs) || (((StorageOrder == ColMajor) && !UseLhs))) {
         dhs_cblock<true>(cblock, blockr, p16uc_GETREAL32b);
         dhs_cblock<true>(cblock, blocki, p16uc_GETIMAG32b);
       } else {
@@ -437,7 +438,7 @@
         dhs_cblock<false>(cblock, blocki, p16uc_GETIMAG32);
       }
 
-      if (Conjugate) {
+      EIGEN_IF_CONSTEXPR (Conjugate) {
         blocki.packet[0] = -blocki.packet[0];
         blocki.packet[1] = -blocki.packet[1];
         blocki.packet[2] = -blocki.packet[2];
@@ -472,8 +473,8 @@
         PacketBlock<Packet, 1> blockr, blocki;
         PacketBlock<PacketC, 2> cblock;
 
-        if (((StorageOrder == ColMajor) && UseLhs) || (((StorageOrder == RowMajor) && !UseLhs))) {
-          if (UseLhs) {
+        EIGEN_IF_CONSTEXPR (((StorageOrder == ColMajor) && UseLhs) || (((StorageOrder == RowMajor) && !UseLhs))) {
+          EIGEN_IF_CONSTEXPR (UseLhs) {
             cblock.packet[0] = lhs2.template loadPacket<PacketC>(0, i);
             cblock.packet[1] = lhs2.template loadPacket<PacketC>(2, i);
           } else {
@@ -481,7 +482,7 @@
             cblock.packet[1] = lhs2.template loadPacket<PacketC>(i, 2);
           }
         } else {
-          if (UseLhs) {
+          EIGEN_IF_CONSTEXPR (UseLhs) {
             cblock.packet[0] = pload2(lhs2(0, i), lhs2(1, i));
             cblock.packet[1] = pload2(lhs2(2, i), lhs2(3, i));
           } else {
@@ -493,7 +494,7 @@
         blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL32);
         blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG32);
 
-        if (Conjugate) {
+        EIGEN_IF_CONSTEXPR (Conjugate) {
           blocki.packet[0] = -blocki.packet[0];
         }
 
@@ -507,8 +508,8 @@
       rir += ((PanelMode) ? (vectorSize * (2 * stride - depth)) : vectorDelta);
     }
 
-    if (!UseLhs) {
-      if (PanelMode) rir -= (offset * (vectorSize - 1));
+    EIGEN_IF_CONSTEXPR (!UseLhs) {
+      EIGEN_IF_CONSTEXPR (PanelMode) rir -= (offset * (vectorSize - 1));
 
       for (; j < rows; j++) {
         const DataMapper lhs2 = lhs.getSubMapper(0, j);
@@ -517,7 +518,7 @@
         for (Index i = 0; i < depth; i++) {
           blockAt[rir] = lhs2(i, 0).real();
 
-          if (Conjugate)
+          EIGEN_IF_CONSTEXPR (Conjugate)
             blockAt[rii] = -lhs2(i, 0).imag();
           else
             blockAt[rii] = lhs2(i, 0).imag();
@@ -530,7 +531,7 @@
       }
     } else {
       if (j < rows) {
-        if (PanelMode) rir += (offset * (rows - j - vectorSize));
+        EIGEN_IF_CONSTEXPR (PanelMode) rir += (offset * (rows - j - vectorSize));
         rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
 
         for (Index i = 0; i < depth; i++) {
@@ -538,7 +539,7 @@
           for (; k < rows; k++) {
             blockAt[rir] = lhs(k, i).real();
 
-            if (Conjugate)
+            EIGEN_IF_CONSTEXPR (Conjugate)
               blockAt[rii] = -lhs(k, i).imag();
             else
               blockAt[rii] = lhs(k, i).imag();
@@ -562,14 +563,14 @@
 
     for (; i + n * vectorSize <= depth; i += n * vectorSize) {
       for (Index k = 0; k < n; k++) {
-        if (UseLhs) {
+        EIGEN_IF_CONSTEXPR (UseLhs) {
           bload<DataMapper, Packet, 4, StorageOrder, false, 4>(block[k], lhs2, 0, i + k * vectorSize);
         } else {
           bload<DataMapper, Packet, 4, StorageOrder, false, 4>(block[k], lhs2, i + k * vectorSize, 0);
         }
       }
 
-      if (((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs)) {
+      EIGEN_IF_CONSTEXPR (((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs)) {
         for (Index k = 0; k < n; k++) {
           ptranspose(block[k]);
         }
@@ -592,15 +593,15 @@
       const DataMapper lhs2 = UseLhs ? lhs.getSubMapper(j, 0) : lhs.getSubMapper(0, j);
       Index i = 0;
 
-      if (PanelMode) ri += vectorSize * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += vectorSize * offset;
 
       dhs_copy<4>(blockA, lhs2, i, ri, depth, vectorSize);
       dhs_copy<2>(blockA, lhs2, i, ri, depth, vectorSize);
       dhs_copy<1>(blockA, lhs2, i, ri, depth, vectorSize);
 
       for (; i < depth; i++) {
-        if (((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs)) {
-          if (UseLhs) {
+        EIGEN_IF_CONSTEXPR (((StorageOrder == RowMajor) && UseLhs) || ((StorageOrder == ColMajor) && !UseLhs)) {
+          EIGEN_IF_CONSTEXPR (UseLhs) {
             blockA[ri + 0] = lhs2(0, i);
             blockA[ri + 1] = lhs2(1, i);
             blockA[ri + 2] = lhs2(2, i);
@@ -613,7 +614,7 @@
           }
         } else {
           Packet lhsV;
-          if (UseLhs) {
+          EIGEN_IF_CONSTEXPR (UseLhs) {
             lhsV = lhs2.template loadPacket<Packet>(0, i);
           } else {
             lhsV = lhs2.template loadPacket<Packet>(i, 0);
@@ -624,11 +625,11 @@
         ri += vectorSize;
       }
 
-      if (PanelMode) ri += vectorSize * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += vectorSize * (stride - offset - depth);
     }
 
-    if (!UseLhs) {
-      if (PanelMode) ri += offset;
+    EIGEN_IF_CONSTEXPR (!UseLhs) {
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += offset;
 
       for (; j < rows; j++) {
         const DataMapper lhs2 = lhs.getSubMapper(0, j);
@@ -637,11 +638,11 @@
           ri += 1;
         }
 
-        if (PanelMode) ri += stride - depth;
+        EIGEN_IF_CONSTEXPR (PanelMode) ri += stride - depth;
       }
     } else {
       if (j < rows) {
-        if (PanelMode) ri += offset * (rows - j);
+        EIGEN_IF_CONSTEXPR (PanelMode) ri += offset * (rows - j);
 
         for (Index i = 0; i < depth; i++) {
           Index k = j;
@@ -665,7 +666,7 @@
 
     for (; i + n * vectorSize <= depth; i += n * vectorSize) {
       for (Index k = 0; k < n; k++) {
-        if (StorageOrder == RowMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == RowMajor) {
           block[k].packet[0] = lhs2.template loadPacket<Packet2d>(0, i + k * vectorSize);
           block[k].packet[1] = lhs2.template loadPacket<Packet2d>(1, i + k * vectorSize);
         } else {
@@ -674,7 +675,7 @@
         }
       }
 
-      if (StorageOrder == RowMajor) {
+      EIGEN_IF_CONSTEXPR (StorageOrder == RowMajor) {
         for (Index k = 0; k < n; k++) {
           ptranspose(block[k]);
         }
@@ -697,14 +698,14 @@
       const DataMapper lhs2 = lhs.getSubMapper(j, 0);
       Index i = 0;
 
-      if (PanelMode) ri += vectorSize * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += vectorSize * offset;
 
       dhs_copy<4>(blockA, lhs2, i, ri, depth, vectorSize);
       dhs_copy<2>(blockA, lhs2, i, ri, depth, vectorSize);
       dhs_copy<1>(blockA, lhs2, i, ri, depth, vectorSize);
 
       for (; i < depth; i++) {
-        if (StorageOrder == RowMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == RowMajor) {
           blockA[ri + 0] = lhs2(0, i);
           blockA[ri + 1] = lhs2(1, i);
         } else {
@@ -715,11 +716,11 @@
         ri += vectorSize;
       }
 
-      if (PanelMode) ri += vectorSize * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += vectorSize * (stride - offset - depth);
     }
 
     if (j < rows) {
-      if (PanelMode) ri += offset * (rows - j);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += offset * (rows - j);
 
       for (Index i = 0; i < depth; i++) {
         Index k = j;
@@ -743,7 +744,7 @@
 
     for (; i + n * vectorSize <= depth; i += n * vectorSize) {
       for (Index k = 0; k < n; k++) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           block1[k].packet[0] = rhs2.template loadPacket<Packet2d>(i + k * vectorSize, 0);
           block1[k].packet[1] = rhs2.template loadPacket<Packet2d>(i + k * vectorSize, 1);
           block2[k].packet[0] = rhs2.template loadPacket<Packet2d>(i + k * vectorSize, 2);
@@ -756,7 +757,7 @@
         }
       }
 
-      if (StorageOrder == ColMajor) {
+      EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
         for (Index k = 0; k < n; k++) {
           ptranspose(block1[k]);
           ptranspose(block2[k]);
@@ -764,7 +765,7 @@
       }
 
       for (Index k = 0; k < n; k++) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           pstore<double>(blockB + ri + k * 4 * vectorSize, block1[k].packet[0]);
           pstore<double>(blockB + ri + k * 4 * vectorSize + 2, block2[k].packet[0]);
           pstore<double>(blockB + ri + k * 4 * vectorSize + 4, block1[k].packet[1]);
@@ -787,14 +788,14 @@
       const DataMapper rhs2 = rhs.getSubMapper(0, j);
       Index i = 0;
 
-      if (PanelMode) ri += offset * (2 * vectorSize);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += offset * (2 * vectorSize);
 
       dhs_copy<4>(blockB, rhs2, i, ri, depth, vectorSize);
       dhs_copy<2>(blockB, rhs2, i, ri, depth, vectorSize);
       dhs_copy<1>(blockB, rhs2, i, ri, depth, vectorSize);
 
       for (; i < depth; i++) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           blockB[ri + 0] = rhs2(i, 0);
           blockB[ri + 1] = rhs2(i, 1);
 
@@ -814,10 +815,10 @@
         ri += vectorSize;
       }
 
-      if (PanelMode) ri += (2 * vectorSize) * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += (2 * vectorSize) * (stride - offset - depth);
     }
 
-    if (PanelMode) ri += offset;
+    EIGEN_IF_CONSTEXPR (PanelMode) ri += offset;
 
     for (; j < cols; j++) {
       const DataMapper rhs2 = rhs.getSubMapper(0, j);
@@ -826,7 +827,7 @@
         ri += 1;
       }
 
-      if (PanelMode) ri += stride - depth;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += stride - depth;
     }
   }
 };
@@ -843,9 +844,9 @@
       const DataMapper lhs2 = lhs.getSubMapper(j, 0);
       Index i = 0;
 
-      if (PanelMode) ri += 2 * vectorSize * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += 2 * vectorSize * offset;
 
-      if (StorageOrder == ColMajor) {
+      EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
         for (; i + 2 <= depth; i += 2) {
           PacketBlock<Packet8bf, 4> block;
 
@@ -995,15 +996,15 @@
         }
       }
 
-      if (PanelMode) ri += 2 * vectorSize * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += 2 * vectorSize * (stride - offset - depth);
     }
     for (; j + vectorSize <= rows; j += vectorSize) {
       const DataMapper lhs2 = lhs.getSubMapper(j, 0);
       Index i = 0;
 
-      if (PanelMode) ri += vectorSize * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += vectorSize * offset;
 
-      if (StorageOrder == ColMajor) {
+      EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
         for (; i + 2 <= depth; i += 2) {
           PacketBlock<Packet8bf, 2> block;
 
@@ -1102,16 +1103,16 @@
         }
       }
 
-      if (PanelMode) ri += vectorSize * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += vectorSize * (stride - offset - depth);
     }
     if (j + 4 <= rows) {
       const DataMapper lhs2 = lhs.getSubMapper(j, 0);
       Index i = 0;
 
-      if (PanelMode) ri += 4 * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += 4 * offset;
 
       for (; i + 2 <= depth; i += 2) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           PacketBlock<Packet8bf, 2> block;
 
           block.packet[0] = lhs2.template loadPacketPartial<Packet8bf>(0, i + 0, 4);
@@ -1134,7 +1135,7 @@
         ri += 2 * 4;
       }
       if (depth & 1) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           Packet8bf lhsV = lhs2.template loadPacketPartial<Packet8bf>(0, i + 0, 4);
 
           pstore_partial<bfloat16>(blockA + ri, lhsV, 4);
@@ -1148,12 +1149,12 @@
         ri += 4;
       }
 
-      if (PanelMode) ri += 4 * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += 4 * (stride - offset - depth);
       j += 4;
     }
 
     if (j < rows) {
-      if (PanelMode) ri += offset * (rows - j);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += offset * (rows - j);
 
       Index i = 0;
       for (; i + 2 <= depth; i += 2) {
@@ -1186,10 +1187,10 @@
       const DataMapper rhs2 = rhs.getSubMapper(0, j);
       Index i = 0;
 
-      if (PanelMode) ri += 4 * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += 4 * offset;
 
       for (; i + vectorSize <= depth; i += vectorSize) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           PacketBlock<Packet8bf, 4> block;
 
           bload<DataMapper, Packet8bf, 4, StorageOrder, false, 4>(block, rhs2, i, 0);
@@ -1244,7 +1245,7 @@
         ri += 4 * vectorSize;
       }
       for (; i + 2 <= depth; i += 2) {
-        if (StorageOrder == ColMajor) {
+        EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
           blockB[ri + 0] = rhs2(i + 0, 0);
           blockB[ri + 1] = rhs2(i + 1, 0);
           blockB[ri + 2] = rhs2(i + 0, 1);
@@ -1276,11 +1277,11 @@
         ri += 4;
       }
 
-      if (PanelMode) ri += 4 * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += 4 * (stride - offset - depth);
     }
 
     if (j < cols) {
-      if (PanelMode) ri += offset * (cols - j);
+      EIGEN_IF_CONSTEXPR (PanelMode) ri += offset * (cols - j);
 
       Index i = 0;
       for (; i + 2 <= depth; i += 2) {
@@ -1310,7 +1311,7 @@
     PacketBlock<PacketC, 4> cblock;
 
     for (; i + vectorSize <= depth; i += vectorSize) {
-      if (StorageOrder == ColMajor) {
+      EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
         cblock.packet[0] = lhs2.template loadPacket<PacketC>(0, i + 0);  //[a1 a1i]
         cblock.packet[1] = lhs2.template loadPacket<PacketC>(0, i + 1);  //[b1 b1i]
 
@@ -1327,7 +1328,7 @@
         cblock.packet[1] = lhs2.template loadPacket<PacketC>(1, i);  //[a2 a2i]
 
         cblock.packet[2] = lhs2.template loadPacket<PacketC>(0, i + 1);  //[b1 b1i]
-        cblock.packet[3] = lhs2.template loadPacket<PacketC>(1, i + 1);  //[b2 b2i
+        cblock.packet[3] = lhs2.template loadPacket<PacketC>(1, i + 1);  //[b2 b2i]
 
         blockr.packet[0] = vec_mergeh(cblock.packet[0].v, cblock.packet[1].v);  //[a1 a2]
         blockr.packet[1] = vec_mergeh(cblock.packet[2].v, cblock.packet[3].v);  //[b1 b2]
@@ -1336,7 +1337,7 @@
         blocki.packet[1] = vec_mergel(cblock.packet[2].v, cblock.packet[3].v);
       }
 
-      if (Conjugate) {
+      EIGEN_IF_CONSTEXPR (Conjugate) {
         blocki.packet[0] = -blocki.packet[0];
         blocki.packet[1] = -blocki.packet[1];
       }
@@ -1375,7 +1376,7 @@
         blockr.packet[0] = vec_mergeh(cblock.packet[0].v, cblock.packet[1].v);
         blocki.packet[0] = vec_mergel(cblock.packet[0].v, cblock.packet[1].v);
 
-        if (Conjugate) {
+        EIGEN_IF_CONSTEXPR (Conjugate) {
           blocki.packet[0] = -blocki.packet[0];
         }
 
@@ -1390,7 +1391,7 @@
     }
 
     if (j < rows) {
-      if (PanelMode) rir += (offset * (rows - j - vectorSize));
+      EIGEN_IF_CONSTEXPR (PanelMode) rir += (offset * (rows - j - vectorSize));
       rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
 
       for (Index i = 0; i < depth; i++) {
@@ -1398,7 +1399,7 @@
         for (; k < rows; k++) {
           blockAt[rir] = lhs(k, i).real();
 
-          if (Conjugate)
+          EIGEN_IF_CONSTEXPR (Conjugate)
             blockAt[rii] = -lhs(k, i).imag();
           else
             blockAt[rii] = lhs(k, i).imag();
@@ -1428,7 +1429,7 @@
       blocki.packet[0] = vec_mergel(cblock.packet[0].v, cblock.packet[1].v);
       blocki.packet[1] = vec_mergel(cblock.packet[2].v, cblock.packet[3].v);
 
-      if (Conjugate) {
+      EIGEN_IF_CONSTEXPR (Conjugate) {
         blocki.packet[0] = -blocki.packet[0];
         blocki.packet[1] = -blocki.packet[1];
       }
@@ -1460,7 +1461,7 @@
       rir += ((PanelMode) ? (2 * vectorSize * (2 * stride - depth)) : vectorDelta);
     }
 
-    if (PanelMode) rir -= (offset * (2 * vectorSize - 1));
+    EIGEN_IF_CONSTEXPR (PanelMode) rir -= (offset * (2 * vectorSize - 1));
 
     for (; j < cols; j++) {
       const DataMapper rhs2 = rhs.getSubMapper(0, j);
@@ -1469,7 +1470,7 @@
       for (Index i = 0; i < depth; i++) {
         blockBt[rir] = rhs2(i, 0).real();
 
-        if (Conjugate)
+        EIGEN_IF_CONSTEXPR (Conjugate)
           blockBt[rii] = -rhs2(i, 0).imag();
         else
           blockBt[rii] = rhs2(i, 0).imag();
@@ -1490,7 +1491,7 @@
 // 512-bits rank1-update of acc. It can either positive or negative accumulate (useful for complex gemm).
 template <typename Packet, bool NegativeAccumulate, int N>
 EIGEN_ALWAYS_INLINE void pger_common(PacketBlock<Packet, N>* acc, const Packet& lhsV, const Packet* rhsV) {
-  if (NegativeAccumulate) {
+  EIGEN_IF_CONSTEXPR (NegativeAccumulate) {
     for (int M = 0; M < N; M++) {
       acc->packet[M] = vec_nmsub(lhsV, rhsV[M], acc->packet[M]);
     }
@@ -1508,17 +1509,17 @@
   pger_common<Packet, NegativeAccumulate, N>(acc, lhsV, rhsV);
 }
 
-// 512-bits rank1-update of complex acc. It takes decoupled accumulators as entries. It also takes cares of mixed types
+// 512-bits rank1-update of complex acc. It takes decoupled accumulators as entries. It also takes care of mixed types
 // real * complex and complex * real.
 template <int N, typename Packet, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
 EIGEN_ALWAYS_INLINE void pgerc_common(PacketBlock<Packet, N>* accReal, PacketBlock<Packet, N>* accImag,
                                       const Packet& lhsV, Packet& lhsVi, const Packet* rhsV, const Packet* rhsVi) {
   pger_common<Packet, false, N>(accReal, lhsV, rhsV);
-  if (LhsIsReal) {
+  EIGEN_IF_CONSTEXPR (LhsIsReal) {
     pger_common<Packet, ConjugateRhs, N>(accImag, lhsV, rhsVi);
     EIGEN_UNUSED_VARIABLE(lhsVi);
   } else {
-    if (!RhsIsReal) {
+    EIGEN_IF_CONSTEXPR (!RhsIsReal) {
       pger_common<Packet, ConjugateLhs == ConjugateRhs, N>(accReal, lhsVi, rhsVi);
       pger_common<Packet, ConjugateRhs, N>(accImag, lhsV, rhsVi);
     } else {
@@ -1533,7 +1534,7 @@
                                const Scalar* lhs_ptr_imag, const Packet* rhsV, const Packet* rhsVi) {
   Packet lhsV = ploadLhs<Packet>(lhs_ptr);
   Packet lhsVi;
-  if (!LhsIsReal)
+  EIGEN_IF_CONSTEXPR (!LhsIsReal)
     lhsVi = ploadLhs<Packet>(lhs_ptr_imag);
   else
     EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
@@ -1574,7 +1575,7 @@
 EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet, N>& aReal, PacketBlock<Packet, N>& aImag, const Packet& bReal,
                                  const Packet& bImag, PacketBlock<Packet, N>& cReal, PacketBlock<Packet, N>& cImag,
                                  const Packet& pMask) {
-  if (mask && (sizeof(__UNPACK_TYPE__(Packet)) == sizeof(float))) {
+  EIGEN_IF_CONSTEXPR (mask && (sizeof(__UNPACK_TYPE__(Packet)) == sizeof(float))) {
     band<Packet, N>(aReal, pMask);
     band<Packet, N>(aImag, pMask);
   } else {
@@ -1596,11 +1597,11 @@
 template <typename DataMapper, typename Packet, const Index accCols, int StorageOrder, bool Complex, int N, bool full>
 EIGEN_ALWAYS_INLINE void bload(PacketBlock<Packet, N*(Complex ? 2 : 1)>& acc, const DataMapper& res, Index row,
                                Index col) {
-  if (StorageOrder == RowMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == RowMajor) {
     for (int M = 0; M < N; M++) {
       acc.packet[M] = res.template loadPacket<Packet>(row + M, col);
     }
-    if (Complex) {
+    EIGEN_IF_CONSTEXPR (Complex) {
       for (int M = 0; M < N; M++) {
         acc.packet[M + N] = res.template loadPacket<Packet>(row + M, col + accCols);
       }
@@ -1609,7 +1610,7 @@
     for (int M = 0; M < N; M++) {
       acc.packet[M] = res.template loadPacket<Packet>(row, col + M);
     }
-    if (Complex && full) {
+    EIGEN_IF_CONSTEXPR (Complex && full) {
       for (int M = 0; M < N; M++) {
         acc.packet[M + N] = res.template loadPacket<Packet>(row + accCols, col + M);
       }
@@ -1631,7 +1632,7 @@
   for (Index M = 0; M < N; M++) {
     acc.packet[M] = res.template loadPacketPartial<Packet>(row, M, elements);
   }
-  if (Complex && full) {
+  EIGEN_IF_CONSTEXPR (Complex && full) {
     for (Index M = 0; M < N; M++) {
       acc.packet[M + N] = res.template loadPacketPartial<Packet>(row + accCols, M, elements);
     }
@@ -1695,7 +1696,7 @@
 template <typename Packet, int N, bool mask>
 EIGEN_ALWAYS_INLINE void bscale(PacketBlock<Packet, N>& acc, PacketBlock<Packet, N>& accZ, const Packet& pAlpha,
                                 const Packet& pMask) {
-  if (mask) {
+  EIGEN_IF_CONSTEXPR (mask) {
     band<Packet, N>(accZ, pMask);
   } else {
     EIGEN_UNUSED_VARIABLE(pMask);
@@ -1709,20 +1710,20 @@
                                      const __UNPACK_TYPE__(Packet) * ap2, Packet& a0, Packet& a1, Packet& a2,
                                      Packet& a3) {
   a0 = pset1<Packet>(ap0[0]);
-  if (N == 4) {
+  EIGEN_IF_CONSTEXPR (N == 4) {
     a1 = pset1<Packet>(ap0[1]);
     a2 = pset1<Packet>(ap0[2]);
     a3 = pset1<Packet>(ap0[3]);
     EIGEN_UNUSED_VARIABLE(ap1);
     EIGEN_UNUSED_VARIABLE(ap2);
   } else {
-    if (N > 1) {
+    EIGEN_IF_CONSTEXPR (N > 1) {
       a1 = pset1<Packet>(ap1[0]);
     } else {
       EIGEN_UNUSED_VARIABLE(a1);
       EIGEN_UNUSED_VARIABLE(ap1);
     }
-    if (N > 2) {
+    EIGEN_IF_CONSTEXPR (N > 2) {
       a2 = pset1<Packet>(ap2[0]);
     } else {
       EIGEN_UNUSED_VARIABLE(a2);
@@ -1762,7 +1763,7 @@
     acc1.packet[M].v = vec_mergeh(taccReal.packet[M], taccImag.packet[M]);
   }
 
-  if (full) {
+  EIGEN_IF_CONSTEXPR (full) {
     for (int M = 0; M < N; M++) {
       acc2.packet[M].v = vec_mergel(taccReal.packet[M], taccImag.packet[M]);
     }
@@ -1779,7 +1780,7 @@
     acc1.packet[M] = padd<Packetc>(tRes.packet[M], acc1.packet[M]);
   }
 
-  if (full) {
+  EIGEN_IF_CONSTEXPR (full) {
     for (int M = 0; M < N; M++) {
       acc2.packet[M] = padd<Packetc>(tRes.packet[M + N], acc2.packet[M]);
     }
@@ -1798,28 +1799,28 @@
 
 #define MICRO_RHS(ptr, N) rhs_##ptr##N
 
-#define MICRO_ZERO_PEEL(peel)                 \
-  if ((PEEL_ROW > peel) && (peel != 0)) {     \
-    bsetzero<Packet, accRows>(accZero##peel); \
-  } else {                                    \
-    EIGEN_UNUSED_VARIABLE(accZero##peel);     \
+#define MICRO_ZERO_PEEL(peel)                             \
+  EIGEN_IF_CONSTEXPR ((PEEL_ROW > peel) && (peel != 0)) { \
+    bsetzero<Packet, accRows>(accZero##peel);             \
+  } else {                                                \
+    EIGEN_UNUSED_VARIABLE(accZero##peel);                 \
   }
 
-#define MICRO_ADD(ptr, N)               \
-  if (MICRO_NORMAL_ROWS) {              \
-    MICRO_RHS(ptr, 0) += (accRows * N); \
-  } else {                              \
-    MICRO_RHS(ptr, 0) += N;             \
-    MICRO_RHS(ptr, 1) += N;             \
-    if (accRows == 3) {                 \
-      MICRO_RHS(ptr, 2) += N;           \
-    }                                   \
+#define MICRO_ADD(ptr, N)                  \
+  EIGEN_IF_CONSTEXPR (MICRO_NORMAL_ROWS) { \
+    MICRO_RHS(ptr, 0) += (accRows * N);    \
+  } else {                                 \
+    MICRO_RHS(ptr, 0) += N;                \
+    MICRO_RHS(ptr, 1) += N;                \
+    EIGEN_IF_CONSTEXPR (accRows == 3) {    \
+      MICRO_RHS(ptr, 2) += N;              \
+    }                                      \
   }
 
 #define MICRO_ADD_ROWS(N) MICRO_ADD(ptr, N)
 
 #define MICRO_BROADCAST1(peel, ptr, rhsV, real)                                                                      \
-  if (MICRO_NORMAL_ROWS) {                                                                                           \
+  EIGEN_IF_CONSTEXPR (MICRO_NORMAL_ROWS) {                                                                           \
     pbroadcastN<Packet, accRows, real>(MICRO_RHS(ptr, 0) + (accRows * peel), MICRO_RHS(ptr, 0), MICRO_RHS(ptr, 0),   \
                                        rhsV##peel[0], rhsV##peel[1], rhsV##peel[2], rhsV##peel[3]);                  \
   } else {                                                                                                           \
@@ -1839,13 +1840,13 @@
   MICRO_ADD_ROWS(1)
 
 #define MICRO_SRC2(ptr, N, M)                   \
-  if (MICRO_NORMAL_ROWS) {                      \
+  EIGEN_IF_CONSTEXPR (MICRO_NORMAL_ROWS) {      \
     EIGEN_UNUSED_VARIABLE(strideB);             \
     EIGEN_UNUSED_VARIABLE(MICRO_RHS(ptr, 1));   \
     EIGEN_UNUSED_VARIABLE(MICRO_RHS(ptr, 2));   \
   } else {                                      \
     MICRO_RHS(ptr, 1) = rhs_base + N + M;       \
-    if (accRows == 3) {                         \
+    EIGEN_IF_CONSTEXPR (accRows == 3) {         \
       MICRO_RHS(ptr, 2) = rhs_base + N * 2 + M; \
     } else {                                    \
       EIGEN_UNUSED_VARIABLE(MICRO_RHS(ptr, 2)); \
@@ -1857,7 +1858,7 @@
 #define MICRO_ZERO_PEEL_ROW MICRO_UNROLL(MICRO_ZERO_PEEL)
 
 #define MICRO_WORK_PEEL(peel)                                                                            \
-  if (PEEL_ROW > peel) {                                                                                 \
+  EIGEN_IF_CONSTEXPR (PEEL_ROW > peel) {                                                                 \
     MICRO_BROADCAST(peel)                                                                                \
     pger<accRows, Scalar, Packet, false>(&accZero##peel, lhs_ptr + (remaining_rows * peel), rhsV##peel); \
   } else {                                                                                               \
@@ -1871,7 +1872,7 @@
   MICRO_ADD_ROWS(PEEL_ROW)
 
 #define MICRO_ADD_PEEL(peel, sum)                        \
-  if (PEEL_ROW > peel) {                                 \
+  EIGEN_IF_CONSTEXPR (PEEL_ROW > peel) {                 \
     for (Index i = 0; i < accRows; i++) {                \
       accZero##sum.packet[i] += accZero##peel.packet[i]; \
     }                                                    \
@@ -1884,19 +1885,19 @@
 
 #define MICRO_PREFETCHN1(ptr, N)               \
   EIGEN_POWER_PREFETCH(MICRO_RHS(ptr, 0));     \
-  if (N == 2 || N == 3) {                      \
+  EIGEN_IF_CONSTEXPR (N == 2 || N == 3) {      \
     EIGEN_POWER_PREFETCH(MICRO_RHS(ptr, 1));   \
-    if (N == 3) {                              \
+    EIGEN_IF_CONSTEXPR (N == 3) {              \
       EIGEN_POWER_PREFETCH(MICRO_RHS(ptr, 2)); \
     }                                          \
   }
 
 #define MICRO_PREFETCHN(N) MICRO_PREFETCHN1(ptr, N)
 
-#define MICRO_COMPLEX_PREFETCHN(N) \
-  MICRO_PREFETCHN1(ptr_real, N);   \
-  if (!RhsIsReal) {                \
-    MICRO_PREFETCHN1(ptr_imag, N); \
+#define MICRO_COMPLEX_PREFETCHN(N)  \
+  MICRO_PREFETCHN1(ptr_real, N);    \
+  EIGEN_IF_CONSTEXPR (!RhsIsReal) { \
+    MICRO_PREFETCHN1(ptr_imag, N);  \
   }
 
 template <typename Scalar, typename Packet, const Index accRows, const Index remaining_rows>
@@ -1913,7 +1914,7 @@
                                                      const Scalar* rhs_base, Index depth, Index strideA, Index offsetA,
                                                      Index strideB, Index row, Index rows, const Packet& pAlpha,
                                                      const Packet& pMask) {
-  const Scalar *rhs_ptr0 = rhs_base, *rhs_ptr1 = NULL, *rhs_ptr2 = NULL;
+  const Scalar *rhs_ptr0 = rhs_base, *rhs_ptr1 = nullptr, *rhs_ptr2 = nullptr;
   const Scalar* lhs_ptr = lhs_base + row * strideA + remaining_rows * offsetA;
   PacketBlock<Packet, accRows> accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7, acc;
 
@@ -1957,21 +1958,21 @@
 #endif
 }
 
-#define MICRO_EXTRA(MICRO_EXTRA_UNROLL, value, is_col)   \
-  switch (value) {                                       \
-    default:                                             \
-      MICRO_EXTRA_UNROLL(1)                              \
-      break;                                             \
-    case 2:                                              \
-      if (is_col || (sizeof(Scalar) == sizeof(float))) { \
-        MICRO_EXTRA_UNROLL(2)                            \
-      }                                                  \
-      break;                                             \
-    case 3:                                              \
-      if (is_col || (sizeof(Scalar) == sizeof(float))) { \
-        MICRO_EXTRA_UNROLL(3)                            \
-      }                                                  \
-      break;                                             \
+#define MICRO_EXTRA(MICRO_EXTRA_UNROLL, value, is_col)                   \
+  switch (value) {                                                       \
+    default:                                                             \
+      MICRO_EXTRA_UNROLL(1)                                              \
+      break;                                                             \
+    case 2:                                                              \
+      EIGEN_IF_CONSTEXPR (is_col || (sizeof(Scalar) == sizeof(float))) { \
+        MICRO_EXTRA_UNROLL(2)                                            \
+      }                                                                  \
+      break;                                                             \
+    case 3:                                                              \
+      EIGEN_IF_CONSTEXPR (is_col || (sizeof(Scalar) == sizeof(float))) { \
+        MICRO_EXTRA_UNROLL(3)                                            \
+      }                                                                  \
+      break;                                                             \
   }
 
 #define MICRO_EXTRA_ROWS(N)                                                     \
@@ -1990,12 +1991,12 @@
   func(0, peel) func(1, peel) func(2, peel) func(3, peel) func(4, peel) func(5, peel) func(6, peel) func(7, peel)
 
 #define MICRO_WORK_ONE(iter, peel)                                               \
-  if (unroll_factor > iter) {                                                    \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) {                                    \
     pger_common<Packet, false, accRows>(&accZero##iter, lhsV##iter, rhsV##peel); \
   }
 
 #define MICRO_TYPE_PEEL4(func, func2, peel)                        \
-  if (PEEL > peel) {                                               \
+  EIGEN_IF_CONSTEXPR (PEEL > peel) {                               \
     Packet lhsV0, lhsV1, lhsV2, lhsV3, lhsV4, lhsV5, lhsV6, lhsV7; \
     MICRO_BROADCAST(peel)                                          \
     MICRO_UNROLL_WORK(func, func2, peel)                           \
@@ -2021,7 +2022,7 @@
 #define MICRO_ONE4 MICRO_UNROLL_TYPE(MICRO_UNROLL_TYPE_ONE, 1)
 
 #define MICRO_DST_PTR_ONE(iter)               \
-  if (unroll_factor > iter) {                 \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) { \
     bsetzero<Packet, accRows>(accZero##iter); \
   } else {                                    \
     EIGEN_UNUSED_VARIABLE(accZero##iter);     \
@@ -2035,8 +2036,8 @@
 
 #ifdef USE_PARTIAL_PACKETS
 #define MICRO_STORE_ONE(iter)                                                                         \
-  if (unroll_factor > iter) {                                                                         \
-    if (MICRO_NORMAL_PARTIAL(iter)) {                                                                 \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) {                                                         \
+    EIGEN_IF_CONSTEXPR (MICRO_NORMAL_PARTIAL(iter)) {                                                 \
       bload<DataMapper, Packet, 0, ColMajor, false, accRows>(acc, res, row + iter * accCols, 0);      \
       bscale<Packet, accRows>(acc, accZero##iter, pAlpha);                                            \
       bstore<DataMapper, Packet, accRows>(acc, res, row + iter * accCols);                            \
@@ -2048,7 +2049,7 @@
   }
 #else
 #define MICRO_STORE_ONE(iter)                                                                  \
-  if (unroll_factor > iter) {                                                                  \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) {                                                  \
     bload<DataMapper, Packet, 0, ColMajor, false, accRows>(acc, res, row + iter * accCols, 0); \
     bscale<Packet, accRows, !(MICRO_NORMAL(iter))>(acc, accZero##iter, pAlpha, pMask);         \
     bstore<DataMapper, Packet, accRows>(acc, res, row + iter * accCols);                       \
@@ -2073,9 +2074,9 @@
                                                  const Packet& pMask
 #endif
 ) {
-  const Scalar *rhs_ptr0 = rhs_base, *rhs_ptr1 = NULL, *rhs_ptr2 = NULL;
-  const Scalar *lhs_ptr0 = NULL, *lhs_ptr1 = NULL, *lhs_ptr2 = NULL, *lhs_ptr3 = NULL, *lhs_ptr4 = NULL,
-               *lhs_ptr5 = NULL, *lhs_ptr6 = NULL, *lhs_ptr7 = NULL;
+  const Scalar *rhs_ptr0 = rhs_base, *rhs_ptr1 = nullptr, *rhs_ptr2 = nullptr;
+  const Scalar *lhs_ptr0 = nullptr, *lhs_ptr1 = nullptr, *lhs_ptr2 = nullptr, *lhs_ptr3 = nullptr, *lhs_ptr4 = nullptr,
+               *lhs_ptr5 = nullptr, *lhs_ptr6 = nullptr, *lhs_ptr7 = nullptr;
   PacketBlock<Packet, accRows> accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
   PacketBlock<Packet, accRows> acc;
 
@@ -2220,18 +2221,18 @@
 
 #define MICRO_COMPLEX_UNROLL(func) func(0) func(1) func(2) func(3)
 
-#define MICRO_COMPLEX_ZERO_PEEL(peel)             \
-  if ((PEEL_COMPLEX_ROW > peel) && (peel != 0)) { \
-    bsetzero<Packet, accRows>(accReal##peel);     \
-    bsetzero<Packet, accRows>(accImag##peel);     \
-  } else {                                        \
-    EIGEN_UNUSED_VARIABLE(accReal##peel);         \
-    EIGEN_UNUSED_VARIABLE(accImag##peel);         \
+#define MICRO_COMPLEX_ZERO_PEEL(peel)                             \
+  EIGEN_IF_CONSTEXPR ((PEEL_COMPLEX_ROW > peel) && (peel != 0)) { \
+    bsetzero<Packet, accRows>(accReal##peel);                     \
+    bsetzero<Packet, accRows>(accImag##peel);                     \
+  } else {                                                        \
+    EIGEN_UNUSED_VARIABLE(accReal##peel);                         \
+    EIGEN_UNUSED_VARIABLE(accImag##peel);                         \
   }
 
 #define MICRO_COMPLEX_ADD_ROWS(N, used)            \
   MICRO_ADD(ptr_real, N)                           \
-  if (!RhsIsReal) {                                \
+  EIGEN_IF_CONSTEXPR (!RhsIsReal) {                \
     MICRO_ADD(ptr_imag, N)                         \
   } else if (used) {                               \
     EIGEN_UNUSED_VARIABLE(MICRO_RHS(ptr_imag, 0)); \
@@ -2241,7 +2242,7 @@
 
 #define MICRO_COMPLEX_BROADCAST(peel)              \
   MICRO_BROADCAST1(peel, ptr_real, rhsV, false)    \
-  if (!RhsIsReal) {                                \
+  EIGEN_IF_CONSTEXPR (!RhsIsReal) {                \
     MICRO_BROADCAST1(peel, ptr_imag, rhsVi, false) \
   } else {                                         \
     EIGEN_UNUSED_VARIABLE(rhsVi##peel);            \
@@ -2250,7 +2251,7 @@
 #define MICRO_COMPLEX_BROADCAST_EXTRA              \
   Packet rhsV[4], rhsVi[4];                        \
   MICRO_BROADCAST_EXTRA1(ptr_real, rhsV, false)    \
-  if (!RhsIsReal) {                                \
+  EIGEN_IF_CONSTEXPR (!RhsIsReal) {                \
     MICRO_BROADCAST_EXTRA1(ptr_imag, rhsVi, false) \
   } else {                                         \
     EIGEN_UNUSED_VARIABLE(rhsVi);                  \
@@ -2259,7 +2260,7 @@
 
 #define MICRO_COMPLEX_SRC2_PTR                                    \
   MICRO_SRC2(ptr_real, strideB* advanceCols, 0)                   \
-  if (!RhsIsReal) {                                               \
+  EIGEN_IF_CONSTEXPR (!RhsIsReal) {                               \
     MICRO_RHS(ptr_imag, 0) = rhs_base + MICRO_NEW_ROWS * strideB; \
     MICRO_SRC2(ptr_imag, strideB* advanceCols, strideB)           \
   } else {                                                        \
@@ -2271,7 +2272,7 @@
 #define MICRO_COMPLEX_ZERO_PEEL_ROW MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_ZERO_PEEL)
 
 #define MICRO_COMPLEX_WORK_PEEL(peel)                                                 \
-  if (PEEL_COMPLEX_ROW > peel) {                                                      \
+  EIGEN_IF_CONSTEXPR (PEEL_COMPLEX_ROW > peel) {                                      \
     MICRO_COMPLEX_BROADCAST(peel)                                                     \
     pgerc<accRows, Scalar, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>( \
         &accReal##peel, &accImag##peel, lhs_ptr_real + (remaining_rows * peel),       \
@@ -2283,7 +2284,7 @@
 
 #define MICRO_COMPLEX_ADD_COLS(size)         \
   lhs_ptr_real += (remaining_rows * size);   \
-  if (!LhsIsReal)                            \
+  EIGEN_IF_CONSTEXPR (!LhsIsReal)            \
     lhs_ptr_imag += (remaining_rows * size); \
   else                                       \
     EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
@@ -2296,7 +2297,7 @@
   MICRO_COMPLEX_ADD_ROWS(PEEL_COMPLEX_ROW, false)
 
 #define MICRO_COMPLEX_ADD_PEEL(peel, sum)                \
-  if (PEEL_COMPLEX_ROW > peel) {                         \
+  EIGEN_IF_CONSTEXPR (PEEL_COMPLEX_ROW > peel) {         \
     for (Index i = 0; i < accRows; i++) {                \
       accReal##sum.packet[i] += accReal##peel.packet[i]; \
       accImag##sum.packet[i] += accImag##peel.packet[i]; \
@@ -2328,11 +2329,11 @@
                                                              Index offsetA, Index strideB, Index row, Index rows,
                                                              const Packet& pAlphaReal, const Packet& pAlphaImag,
                                                              const Packet& pMask) {
-  const Scalar *rhs_ptr_real0 = rhs_base, *rhs_ptr_real1 = NULL, *rhs_ptr_real2 = NULL;
-  const Scalar *rhs_ptr_imag0 = NULL, *rhs_ptr_imag1 = NULL, *rhs_ptr_imag2 = NULL;
+  const Scalar *rhs_ptr_real0 = rhs_base, *rhs_ptr_real1 = nullptr, *rhs_ptr_real2 = nullptr;
+  const Scalar *rhs_ptr_imag0 = nullptr, *rhs_ptr_imag1 = nullptr, *rhs_ptr_imag2 = nullptr;
   const Scalar* lhs_ptr_real = lhs_base + advanceRows * row * strideA + remaining_rows * offsetA;
-  const Scalar* lhs_ptr_imag = NULL;
-  if (!LhsIsReal)
+  const Scalar* lhs_ptr_imag = nullptr;
+  EIGEN_IF_CONSTEXPR (!LhsIsReal)
     lhs_ptr_imag = lhs_ptr_real + remaining_rows * strideA;
   else
     EIGEN_UNUSED_VARIABLE(lhs_ptr_imag);
@@ -2353,7 +2354,7 @@
     do {
       MICRO_COMPLEX_PREFETCHN(accRows)
       EIGEN_POWER_PREFETCH(lhs_ptr_real);
-      if (!LhsIsReal) {
+      EIGEN_IF_CONSTEXPR (!LhsIsReal) {
         EIGEN_POWER_PREFETCH(lhs_ptr_imag);
       }
       MICRO_COMPLEX_WORK_PEEL_ROW
@@ -2372,7 +2373,7 @@
     bscalec<Packet, accRows, true>(accReal0, accImag0, pAlphaReal, pAlphaImag, taccReal, taccImag, pMask);
     bcouple<Packet, Packetc, accRows, full>(taccReal, taccImag, tRes, acc0, acc1);
     bstore<DataMapper, Packetc, accRows>(acc0, res, row + 0);
-    if (full) {
+    EIGEN_IF_CONSTEXPR (full) {
       bstore<DataMapper, Packetc, accRows>(acc1, res, row + accColsC);
     }
   } else {
@@ -2385,7 +2386,7 @@
       }
     } else {
       bstore<DataMapper, Packetc, accRows>(acc0, res, row + 0);
-      if (full) {
+      EIGEN_IF_CONSTEXPR (full) {
         for (Index j = 0; j < accRows; j++) {
           res(row + accColsC, j) = pfirst<Packetc>(acc1.packet[j]);
         }
@@ -2413,13 +2414,13 @@
   func(0, peel) func(1, peel) func(2, peel) func(3, peel)
 
 #define MICRO_COMPLEX_WORK_ONE4(iter, peel)                                                \
-  if (unroll_factor > iter) {                                                              \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) {                                              \
     pgerc_common<accRows, Packet, ConjugateLhs, ConjugateRhs, LhsIsReal, RhsIsReal>(       \
         &accReal##iter, &accImag##iter, lhsV##iter, lhsVi##iter, rhsV##peel, rhsVi##peel); \
   }
 
 #define MICRO_COMPLEX_TYPE_PEEL4(func, func2, peel) \
-  if (PEEL_COMPLEX > peel) {                        \
+  EIGEN_IF_CONSTEXPR (PEEL_COMPLEX > peel) {        \
     Packet lhsV0, lhsV1, lhsV2, lhsV3;              \
     Packet lhsVi0, lhsVi1, lhsVi2, lhsVi3;          \
     MICRO_COMPLEX_BROADCAST(peel)                   \
@@ -2447,7 +2448,7 @@
 #define MICRO_COMPLEX_ONE4 MICRO_COMPLEX_UNROLL_TYPE(MICRO_COMPLEX_UNROLL_TYPE_ONE, 1)
 
 #define MICRO_COMPLEX_DST_PTR_ONE(iter)       \
-  if (unroll_factor > iter) {                 \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) { \
     bsetzero<Packet, accRows>(accReal##iter); \
     bsetzero<Packet, accRows>(accImag##iter); \
   } else {                                    \
@@ -2462,14 +2463,14 @@
 #define MICRO_COMPLEX_PREFETCH MICRO_COMPLEX_UNROLL(MICRO_COMPLEX_PREFETCH_ONE)
 
 #define MICRO_COMPLEX_STORE_ONE(iter)                                                                               \
-  if (unroll_factor > iter) {                                                                                       \
+  EIGEN_IF_CONSTEXPR (unroll_factor > iter) {                                                                       \
     constexpr bool full = ((MICRO_NORMAL(iter)) || (accCols2 > accColsC));                                          \
     bload<DataMapper, Packetc, accColsC, ColMajor, true, accRows, full>(tRes, res, row + iter * accCols, 0);        \
     bscalec<Packet, accRows, !(MICRO_NORMAL(iter))>(accReal##iter, accImag##iter, pAlphaReal, pAlphaImag, taccReal, \
                                                     taccImag, pMask);                                               \
     bcouple<Packet, Packetc, accRows, full>(taccReal, taccImag, tRes, acc0, acc1);                                  \
     bstore<DataMapper, Packetc, accRows>(acc0, res, row + iter * accCols + 0);                                      \
-    if (full) {                                                                                                     \
+    EIGEN_IF_CONSTEXPR (full) {                                                                                     \
       bstore<DataMapper, Packetc, accRows>(acc1, res, row + iter * accCols + accColsC);                             \
     }                                                                                                               \
   }
@@ -2484,12 +2485,12 @@
                                                          Index offsetA, Index strideB, Index& row,
                                                          const Packet& pAlphaReal, const Packet& pAlphaImag,
                                                          const Packet& pMask) {
-  const Scalar *rhs_ptr_real0 = rhs_base, *rhs_ptr_real1 = NULL, *rhs_ptr_real2 = NULL;
-  const Scalar *rhs_ptr_imag0 = NULL, *rhs_ptr_imag1 = NULL, *rhs_ptr_imag2 = NULL;
+  const Scalar *rhs_ptr_real0 = rhs_base, *rhs_ptr_real1 = nullptr, *rhs_ptr_real2 = nullptr;
+  const Scalar *rhs_ptr_imag0 = nullptr, *rhs_ptr_imag1 = nullptr, *rhs_ptr_imag2 = nullptr;
   const Index imag_delta = accCols * strideA;
   const Index imag_delta2 = accCols2 * strideA;
-  const Scalar *lhs_ptr_real0 = NULL, *lhs_ptr_real1 = NULL;
-  const Scalar *lhs_ptr_real2 = NULL, *lhs_ptr_real3 = NULL;
+  const Scalar *lhs_ptr_real0 = nullptr, *lhs_ptr_real1 = nullptr;
+  const Scalar *lhs_ptr_real2 = nullptr, *lhs_ptr_real3 = nullptr;
   PacketBlock<Packet, accRows> accReal0, accImag0, accReal1, accImag1;
   PacketBlock<Packet, accRows> accReal2, accImag2, accReal3, accImag3;
   PacketBlock<Packet, accRows> taccReal, taccImag;
@@ -2630,14 +2631,14 @@
 #endif
 }
 
-EIGEN_ALWAYS_INLINE Packet4f loadAndMultiplyF32(Packet4f acc, const Packet4f pAlpha, float* result) {
+EIGEN_ALWAYS_INLINE Packet4f loadAndMultiplyF32(const Packet4f& acc, const Packet4f& pAlpha, float* result) {
   Packet4f result_block = ploadu<Packet4f>(result);
   return pmadd(acc, pAlpha, result_block);
 }
 
 template <bool lhsExtraRows>
-EIGEN_ALWAYS_INLINE void storeF32(float*& result, Packet4f result_block, Index rows, Index extra_rows) {
-  if (lhsExtraRows) {
+EIGEN_ALWAYS_INLINE void storeF32(float*& result, const Packet4f& result_block, Index rows, Index extra_rows) {
+  EIGEN_IF_CONSTEXPR (lhsExtraRows) {
     pstoreu_partial(result, result_block, extra_rows);
   } else {
     pstoreu(result, result_block);
@@ -2646,10 +2647,10 @@
 }
 
 template <bool rhsExtraCols, bool lhsExtraRows>
-EIGEN_ALWAYS_INLINE void storeResults(Packet4f (&acc)[4], Index rows, const Packet4f pAlpha, float* result,
+EIGEN_ALWAYS_INLINE void storeResults(Packet4f (&acc)[4], Index rows, const Packet4f& pAlpha, float* result,
                                       Index extra_cols, Index extra_rows) {
   Index x = 0;
-  if (rhsExtraCols) {
+  EIGEN_IF_CONSTEXPR (rhsExtraCols) {
     do {
       Packet4f result_block = loadAndMultiplyF32(acc[x], pAlpha, result);
       storeF32<lhsExtraRows>(result, result_block, rows, extra_rows);
@@ -2668,7 +2669,7 @@
   }
 }
 
-EIGEN_ALWAYS_INLINE Packet4f oneConvertBF16Hi(Packet8us data) {
+EIGEN_ALWAYS_INLINE Packet4f oneConvertBF16Hi(const Packet8us& data) {
   Packet8us z = pset1<Packet8us>(0);
 #ifdef _BIG_ENDIAN
   return reinterpret_cast<Packet4f>(vec_mergeh(data, z));
@@ -2677,7 +2678,7 @@
 #endif
 }
 
-EIGEN_ALWAYS_INLINE Packet4f oneConvertBF16Lo(Packet8us data) {
+EIGEN_ALWAYS_INLINE Packet4f oneConvertBF16Lo(const Packet8us& data) {
   Packet8us z = pset1<Packet8us>(0);
 #ifdef _BIG_ENDIAN
   return reinterpret_cast<Packet4f>(vec_mergel(data, z));
@@ -2688,11 +2689,11 @@
 
 template <Index N, Index M>
 EIGEN_ALWAYS_INLINE void storeConvertTwoBF16(float* to, PacketBlock<Packet8bf, (N + 7) / 8>& block, Index extra = 0) {
-  if (N < 4) {
+  EIGEN_IF_CONSTEXPR (N < 4) {
     pstoreu_partial(to + 0, oneConvertBF16Hi(block.packet[0].m_val), extra);
-  } else if (N >= (M * 8 + 4)) {
+  } else EIGEN_IF_CONSTEXPR (N >= (M * 8 + 4)) {
     pstoreu(to + 0, oneConvertBF16Hi(block.packet[M].m_val));
-    if (N >= 8) {
+    EIGEN_IF_CONSTEXPR (N >= 8) {
       pstoreu(to + 4, oneConvertBF16Lo(block.packet[M].m_val));
     }
   }
@@ -2701,10 +2702,10 @@
 template <Index N>
 EIGEN_ALWAYS_INLINE void storeConvertBlockBF16(float* to, PacketBlock<Packet8bf, (N + 7) / 8>& block, Index extra) {
   storeConvertTwoBF16<N, 0>(to + 0, block, extra);
-  if (N >= 16) {
+  EIGEN_IF_CONSTEXPR (N >= 16) {
     storeConvertTwoBF16<N, 1>(to + 8, block);
   }
-  if (N >= 32) {
+  EIGEN_IF_CONSTEXPR (N >= 32) {
     storeConvertTwoBF16<N, 2>(to + 16, block);
     storeConvertTwoBF16<N, 3>(to + 24, block);
   }
@@ -2712,7 +2713,7 @@
 
 template <bool non_unit_stride, Index delta>
 EIGEN_ALWAYS_INLINE Packet8bf loadBF16fromResult(bfloat16* src, Index resInc) {
-  if (non_unit_stride) {
+  EIGEN_IF_CONSTEXPR (non_unit_stride) {
     return pgather<bfloat16, Packet8bf>(src + delta * resInc, resInc);
   } else {
     return ploadu<Packet8bf>(src + delta);
@@ -2729,7 +2730,7 @@
 static Packet16uc p16uc_MERGE16_32_7 = {4, 5, 20, 21, 20, 21, 20, 21, 4, 5, 20, 21, 20, 21, 20, 21};
 static Packet16uc p16uc_MERGE16_32_8 = {6, 7, 22, 23, 22, 23, 22, 23, 6, 7, 22, 23, 22, 23, 22, 23};
 
-EIGEN_ALWAYS_INLINE Packet4f oneConvertBF16Perm(Packet8us data, Packet16uc mask) {
+EIGEN_ALWAYS_INLINE Packet4f oneConvertBF16Perm(const Packet8us& data, const Packet16uc& mask) {
   Packet8us z = pset1<Packet8us>(0);
 #ifdef _BIG_ENDIAN
   return reinterpret_cast<Packet4f>(vec_perm(data, z, mask));
@@ -2756,7 +2757,7 @@
   }
 
   for (Index j = 0; j < 4 * size; j += 4) {
-    if (lhsExtraRows) {
+    EIGEN_IF_CONSTEXPR (lhsExtraRows) {
       Packet4f z = pset1<Packet4f>(float(0));
       Index i = 0;
       do {
@@ -2791,28 +2792,32 @@
 
 template <const Index size, bool non_unit_stride>
 EIGEN_ALWAYS_INLINE void convertPointerBF16toF32(Index& i, float* result, Index rows, bfloat16*& src, Index resInc) {
-  constexpr Index extra = ((size < 4) ? 4 : size);
   while (i + size <= rows) {
+    const Index count = size == 1 ? rows - i : size;
     PacketBlock<Packet8bf, (size + 7) / 8> r32;
-    r32.packet[0] = loadBF16fromResult<non_unit_stride, 0>(src, resInc);
-    if (size >= 16) {
+    EIGEN_IF_CONSTEXPR (size < 8) {
+      r32.packet[0] = pgather_partial<bfloat16, Packet8bf>(src, non_unit_stride ? resInc : 1, count);
+    } else {
+      r32.packet[0] = loadBF16fromResult<non_unit_stride, 0>(src, resInc);
+    }
+    EIGEN_IF_CONSTEXPR (size >= 16) {
       r32.packet[1] = loadBF16fromResult<non_unit_stride, 8>(src, resInc);
     }
-    if (size >= 32) {
+    EIGEN_IF_CONSTEXPR (size >= 32) {
       r32.packet[2] = loadBF16fromResult<non_unit_stride, 16>(src, resInc);
       r32.packet[3] = loadBF16fromResult<non_unit_stride, 24>(src, resInc);
     }
     storeConvertBlockBF16<size>(result + i, r32, rows & 3);
-    i += extra;
-    src += extra * resInc;
-    if (size != 32) break;
+    i += count;
+    if (i < rows) src += count * resInc;
+    EIGEN_IF_CONSTEXPR (size != 32) break;
   }
 }
 
 template <bool non_unit_stride>
 EIGEN_ALWAYS_INLINE void convertArrayPointerBF16toF32(float* result, Index cols, Index rows, bfloat16* src,
                                                       Index resInc) {
-  for (Index col = 0; col < cols; col++, src += (rows * resInc), result += rows) {
+  for (Index col = 0; col < cols; col++, result += rows) {
     Index i = 0;
     bfloat16* src2 = src;
     convertPointerBF16toF32<32, non_unit_stride>(i, result, rows, src2, resInc);
@@ -2820,6 +2825,7 @@
     convertPointerBF16toF32<8, non_unit_stride>(i, result, rows, src2, resInc);
     convertPointerBF16toF32<4, non_unit_stride>(i, result, rows, src2, resInc);
     convertPointerBF16toF32<1, non_unit_stride>(i, result, rows, src2, resInc);
+    if (col + 1 < cols) src += rows * resInc;
   }
 }
 
@@ -2861,8 +2867,8 @@
 }
 
 template <Index num_acc, bool rhsExtraCols, bool lhsExtraRows, Index num_rhs>
-EIGEN_ALWAYS_INLINE void outputResultsVSX(Packet4f (&acc)[num_acc][4], Index rows, const Packet4f pAlpha, float* result,
-                                          const Index extra_cols, Index extra_rows) {
+EIGEN_ALWAYS_INLINE void outputResultsVSX(Packet4f (&acc)[num_acc][4], Index rows, const Packet4f& pAlpha,
+                                          float* result, const Index extra_cols, Index extra_rows) {
   tranposeResults<num_acc>(acc);
   addResults<num_acc>(acc);
 
@@ -2871,7 +2877,7 @@
   for (Index i = 0; i < real_rhs; i++, result += 4 * rows, k++) {
     storeResults<false, lhsExtraRows>(acc[k], rows, pAlpha, result, extra_cols, extra_rows);
   }
-  if (rhsExtraCols) {
+  EIGEN_IF_CONSTEXPR (rhsExtraCols) {
     storeResults<rhsExtraCols, lhsExtraRows>(acc[k], rows, pAlpha, result, extra_cols, extra_rows);
   }
 }
@@ -2879,7 +2885,7 @@
 template <bool zero>
 EIGEN_ALWAYS_INLINE void loadTwoRhsFloat32(const float* block, Index strideB, Index i, Packet4f& dhs0, Packet4f& dhs1) {
   dhs0 = ploadu<Packet4f>(block + strideB * i + 0);
-  if (zero) {
+  EIGEN_IF_CONSTEXPR (zero) {
     Packet4f dhs2 = pset1<Packet4f>(float(0));
     dhs1 = vec_mergel(dhs0, dhs2);
     dhs0 = vec_mergeh(dhs0, dhs2);
@@ -2898,7 +2904,7 @@
   for (Index i = 0; i < real_rhs; i += 2) {
     loadTwoRhsFloat32<zero>(indexB + k * 4, strideB, i, rhs[i + 0], rhs[i + 1]);
   }
-  if (rhsExtraCols) {
+  EIGEN_IF_CONSTEXPR (rhsExtraCols) {
     loadTwoRhsFloat32<zero>(indexB + k * extra_cols - offsetB, strideB, real_rhs, rhs[real_rhs + 0], rhs[real_rhs + 1]);
   }
 
@@ -2915,7 +2921,7 @@
 }
 
 template <const Index num_acc, bool rhsExtraCols, bool lhsExtraRows>
-EIGEN_ALWAYS_INLINE void colVSXLoopBodyIter(Index depth, Index rows, const Packet4f pAlpha, const float* indexA,
+EIGEN_ALWAYS_INLINE void colVSXLoopBodyIter(Index depth, Index rows, const Packet4f& pAlpha, const float* indexA,
                                             const float* indexB, Index strideB, Index offsetB, float* result,
                                             const Index extra_cols, const Index extra_rows) {
   constexpr Index num_rhs = num_acc;
@@ -2939,7 +2945,7 @@
 #define MAX_BFLOAT16_ACC_VSX 4
 
 template <const Index num_acc, bool rhsExtraCols, bool lhsExtraRows>
-void colVSXLoopBody(Index& col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const float* indexA,
+void colVSXLoopBody(Index& col, Index depth, Index cols, Index rows, const Packet4f& pAlpha, const float* indexA,
                     const float* indexB, Index strideB, Index offsetB, float* result) {
   constexpr Index step = (num_acc * 4);  // each accumulator has 4 elements
   const Index extra_cols = (rhsExtraCols) ? (cols & 3) : 0;
@@ -2956,17 +2962,17 @@
 }
 
 template <const Index num_acc, bool rhsExtraCols, bool lhsExtraRows>
-EIGEN_ALWAYS_INLINE void colVSXLoopBodyExtraN(Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void colVSXLoopBodyExtraN(Index col, Index depth, Index cols, Index rows, const Packet4f& pAlpha,
                                               const float* indexA, const float* blockB, Index strideB, Index offsetB,
                                               float* result) {
-  if (MAX_BFLOAT16_ACC_VSX > num_acc) {
+  EIGEN_IF_CONSTEXPR (MAX_BFLOAT16_ACC_VSX > num_acc) {
     colVSXLoopBody<num_acc + (rhsExtraCols ? 1 : 0), rhsExtraCols, lhsExtraRows>(col, depth, cols, rows, pAlpha, indexA,
                                                                                  blockB, strideB, offsetB, result);
   }
 }
 
 template <bool rhsExtraCols, bool lhsExtraRows>
-void colVSXLoopBodyExtra(Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const float* indexA,
+void colVSXLoopBodyExtra(Index col, Index depth, Index cols, Index rows, const Packet4f& pAlpha, const float* indexA,
                          const float* blockB, Index strideB, Index offsetB, float* result) {
   switch ((cols - col) >> 2) {
     case 3:
@@ -2982,7 +2988,7 @@
                                                           offsetB, result);
       break;
     default:
-      if (rhsExtraCols) {
+      EIGEN_IF_CONSTEXPR (rhsExtraCols) {
         colVSXLoopBody<1, true, lhsExtraRows>(col, depth, cols, rows, pAlpha, indexA, blockB, strideB, offsetB, result);
       }
       break;
@@ -2990,9 +2996,9 @@
 }
 
 template <Index size, bool lhsExtraRows = false>
-EIGEN_ALWAYS_INLINE void colVSXLoops(Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16* indexA,
-                                     const float* indexA2, const float* blockB2, Index strideA, Index strideB,
-                                     Index offsetB, float* result2) {
+EIGEN_ALWAYS_INLINE void colVSXLoops(Index depth, Index cols, Index rows, const Packet4f& pAlpha,
+                                     const bfloat16* indexA, const float* indexA2, const float* blockB2, Index strideA,
+                                     Index strideB, Index offsetB, float* result2) {
   Index delta_rows = 2 * (lhsExtraRows ? (rows & 3) : size);
   for (Index row = 0; row < size; row += 4) {
     convertArrayPointerBF16toF32Dup<lhsExtraRows>(const_cast<float*>(indexA2), strideA, delta_rows, indexA, row,
@@ -3019,7 +3025,7 @@
 
 template <Index size>
 EIGEN_ALWAYS_INLINE void calcVSXColLoops(const bfloat16*& indexA, const float* indexA2, Index& row, Index depth,
-                                         Index cols, Index rows, const Packet4f pAlpha, const float* indexB,
+                                         Index cols, Index rows, const Packet4f& pAlpha, const float* indexB,
                                          Index strideA, Index strideB, Index offsetA, Index offsetB, Index bigSuffix,
                                          float* result) {
   if ((size == 16) || (rows & size)) {
@@ -3036,16 +3042,16 @@
   while (i + size <= rows) {
     PacketBlock<Packet8bf, (size + 7) / 8> r32;
     r32.packet[0] = src.template loadPacket<Packet8bf>(i + 0);
-    if (size >= 16) {
+    EIGEN_IF_CONSTEXPR (size >= 16) {
       r32.packet[1] = src.template loadPacket<Packet8bf>(i + 8);
     }
-    if (size >= 32) {
+    EIGEN_IF_CONSTEXPR (size >= 32) {
       r32.packet[2] = src.template loadPacket<Packet8bf>(i + 16);
       r32.packet[3] = src.template loadPacket<Packet8bf>(i + 24);
     }
     storeConvertBlockBF16<size>(result + i, r32, rows & 3);
     i += extra;
-    if (size != 32) break;
+    EIGEN_IF_CONSTEXPR (size != 32) break;
   }
 }
 
@@ -3430,10 +3436,12 @@
 void gebp_kernel<float, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const float* blockA, const float* blockB, Index rows, Index depth, Index cols, float alpha,
     Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  const Index accRows = quad_traits<float>::rows;
-  const Index accCols = quad_traits<float>::size;
-  static void (*gemm_function)(const DataMapper&, const float*, const float*, Index, Index, Index, float, Index, Index,
-                               Index, Index) =
+  const Eigen::Index accRows = quad_traits<float>::rows;
+  const Eigen::Index accCols = quad_traits<float>::size;
+  // The kernels below take Eigen::Index, which need not be the Index this kernel is instantiated with: a Tensor
+  // contraction instantiates gebp_kernel with the tensor's StorageIndex.
+  static void (*gemm_function)(const DataMapper&, const float*, const float*, Eigen::Index, Eigen::Index, Eigen::Index,
+                               float, Eigen::Index, Eigen::Index, Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemmMMA<float, Packet, RhsPacket, DataMapper, accRows, accCols> :
 #endif
@@ -3458,10 +3466,11 @@
                                            const std::complex<float>* blockB, Index rows, Index depth, Index cols,
                                            std::complex<float> alpha, Index strideA, Index strideB, Index offsetA,
                                            Index offsetB) {
-  const Index accRows = quad_traits<float>::rows;
-  const Index accCols = quad_traits<float>::size;
-  static void (*gemm_function)(const DataMapper&, const std::complex<float>*, const std::complex<float>*, Index, Index,
-                               Index, std::complex<float>, Index, Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<float>::rows;
+  const Eigen::Index accCols = quad_traits<float>::size;
+  static void (*gemm_function)(const DataMapper&, const std::complex<float>*, const std::complex<float>*, Eigen::Index,
+                               Eigen::Index, Eigen::Index, std::complex<float>, Eigen::Index, Eigen::Index,
+                               Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemm_complexMMA<std::complex<float>, std::complex<float>, std::complex<float>,
                                                           float, Packet, Packetc, RhsPacket, DataMapper, accRows,
@@ -3489,10 +3498,11 @@
 void gebp_kernel<float, std::complex<float>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const float* blockA, const std::complex<float>* blockB, Index rows, Index depth, Index cols,
     std::complex<float> alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  const Index accRows = quad_traits<float>::rows;
-  const Index accCols = quad_traits<float>::size;
-  static void (*gemm_function)(const DataMapper&, const float*, const std::complex<float>*, Index, Index, Index,
-                               std::complex<float>, Index, Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<float>::rows;
+  const Eigen::Index accCols = quad_traits<float>::size;
+  static void (*gemm_function)(const DataMapper&, const float*, const std::complex<float>*, Eigen::Index, Eigen::Index,
+                               Eigen::Index, std::complex<float>, Eigen::Index, Eigen::Index, Eigen::Index,
+                               Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemm_complexMMA<float, std::complex<float>, std::complex<float>, float,
                                                           Packet, Packetc, RhsPacket, DataMapper, accRows, accCols,
@@ -3520,10 +3530,11 @@
 void gebp_kernel<std::complex<float>, float, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const std::complex<float>* blockA, const float* blockB, Index rows, Index depth, Index cols,
     std::complex<float> alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  const Index accRows = quad_traits<float>::rows;
-  const Index accCols = quad_traits<float>::size;
-  static void (*gemm_function)(const DataMapper&, const std::complex<float>*, const float*, Index, Index, Index,
-                               std::complex<float>, Index, Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<float>::rows;
+  const Eigen::Index accCols = quad_traits<float>::size;
+  static void (*gemm_function)(const DataMapper&, const std::complex<float>*, const float*, Eigen::Index, Eigen::Index,
+                               Eigen::Index, std::complex<float>, Eigen::Index, Eigen::Index, Eigen::Index,
+                               Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemm_complexMMA<std::complex<float>, float, std::complex<float>, float,
                                                           Packet, Packetc, RhsPacket, DataMapper, accRows, accCols,
@@ -3550,10 +3561,10 @@
 void gebp_kernel<double, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const double* blockA, const double* blockB, Index rows, Index depth, Index cols,
     double alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  const Index accRows = quad_traits<double>::rows;
-  const Index accCols = quad_traits<double>::size;
-  static void (*gemm_function)(const DataMapper&, const double*, const double*, Index, Index, Index, double, Index,
-                               Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<double>::rows;
+  const Eigen::Index accCols = quad_traits<double>::size;
+  static void (*gemm_function)(const DataMapper&, const double*, const double*, Eigen::Index, Eigen::Index,
+                               Eigen::Index, double, Eigen::Index, Eigen::Index, Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemmMMA<double, Packet, RhsPacket, DataMapper, accRows, accCols> :
 #endif
@@ -3578,10 +3589,11 @@
                                            const std::complex<double>* blockB, Index rows, Index depth, Index cols,
                                            std::complex<double> alpha, Index strideA, Index strideB, Index offsetA,
                                            Index offsetB) {
-  const Index accRows = quad_traits<double>::rows;
-  const Index accCols = quad_traits<double>::size;
-  static void (*gemm_function)(const DataMapper&, const std::complex<double>*, const std::complex<double>*, Index,
-                               Index, Index, std::complex<double>, Index, Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<double>::rows;
+  const Eigen::Index accCols = quad_traits<double>::size;
+  static void (*gemm_function)(const DataMapper&, const std::complex<double>*, const std::complex<double>*,
+                               Eigen::Index, Eigen::Index, Eigen::Index, std::complex<double>, Eigen::Index,
+                               Eigen::Index, Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA())
           ? &Eigen::internal::gemm_complexMMA<std::complex<double>, std::complex<double>, std::complex<double>, double,
@@ -3610,10 +3622,11 @@
 void gebp_kernel<std::complex<double>, double, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const std::complex<double>* blockA, const double* blockB, Index rows, Index depth,
     Index cols, std::complex<double> alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  const Index accRows = quad_traits<double>::rows;
-  const Index accCols = quad_traits<double>::size;
-  static void (*gemm_function)(const DataMapper&, const std::complex<double>*, const double*, Index, Index, Index,
-                               std::complex<double>, Index, Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<double>::rows;
+  const Eigen::Index accCols = quad_traits<double>::size;
+  static void (*gemm_function)(const DataMapper&, const std::complex<double>*, const double*, Eigen::Index,
+                               Eigen::Index, Eigen::Index, std::complex<double>, Eigen::Index, Eigen::Index,
+                               Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemm_complexMMA<std::complex<double>, double, std::complex<double>, double,
                                                           Packet, Packetc, RhsPacket, DataMapper, accRows, accCols,
@@ -3641,10 +3654,11 @@
 void gebp_kernel<double, std::complex<double>, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const double* blockA, const std::complex<double>* blockB, Index rows, Index depth,
     Index cols, std::complex<double> alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  const Index accRows = quad_traits<double>::rows;
-  const Index accCols = quad_traits<double>::size;
-  static void (*gemm_function)(const DataMapper&, const double*, const std::complex<double>*, Index, Index, Index,
-                               std::complex<double>, Index, Index, Index, Index) =
+  const Eigen::Index accRows = quad_traits<double>::rows;
+  const Eigen::Index accCols = quad_traits<double>::size;
+  static void (*gemm_function)(const DataMapper&, const double*, const std::complex<double>*, Eigen::Index,
+                               Eigen::Index, Eigen::Index, std::complex<double>, Eigen::Index, Eigen::Index,
+                               Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemm_complexMMA<double, std::complex<double>, std::complex<double>, double,
                                                           Packet, Packetc, RhsPacket, DataMapper, accRows, accCols,
@@ -3671,8 +3685,8 @@
 void gebp_kernel<bfloat16, bfloat16, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>::operator()(
     const DataMapper& res, const bfloat16* blockA, const bfloat16* blockB, Index rows, Index depth, Index cols,
     bfloat16 alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
-  static void (*gemm_function)(const DataMapper&, const bfloat16*, const bfloat16*, Index, Index, Index, bfloat16,
-                               Index, Index, Index, Index) =
+  static void (*gemm_function)(const DataMapper&, const bfloat16*, const bfloat16*, Eigen::Index, Eigen::Index,
+                               Eigen::Index, bfloat16, Eigen::Index, Eigen::Index, Eigen::Index, Eigen::Index) =
 #ifdef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
       (supportsMMA()) ? &Eigen::internal::gemmMMAbfloat16<DataMapper> :
 #endif
diff --git a/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h b/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
index e78ca5a..e7b69bf 100644
--- a/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
+++ b/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
@@ -1,4 +1,10 @@
 // #define EIGEN_POWER_USE_PREFETCH  // Use prefetching in gemm routines
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_PRODUCT_COMMON_ALTIVEC_H
+#define EIGEN_MATRIX_PRODUCT_COMMON_ALTIVEC_H
+
 #ifdef EIGEN_POWER_USE_PREFETCH
 #define EIGEN_POWER_PREFETCH(p) prefetch(p)
 #else
@@ -49,22 +55,22 @@
 EIGEN_ALWAYS_INLINE void convertArrayBF16toF32(float* result, Index cols, Index rows, const DataMapper& src);
 
 template <const Index size, bool non_unit_stride, Index delta>
-EIGEN_ALWAYS_INLINE void storeBF16fromResult(bfloat16* dst, Packet8bf data, Index resInc, Index extra = 0);
+EIGEN_ALWAYS_INLINE void storeBF16fromResult(bfloat16* dst, const Packet8bf& data, Index resInc, Index extra = 0);
 
 template <bool non_unit_stride = false>
 EIGEN_ALWAYS_INLINE void convertArrayPointerBF16toF32(float* result, Index cols, Index rows, bfloat16* src,
                                                       Index resInc = 1);
 
 template <bool rhsExtraCols, bool lhsExtraRows>
-EIGEN_ALWAYS_INLINE void storeResults(Packet4f (&acc)[4], Index rows, const Packet4f pAlpha, float* result,
+EIGEN_ALWAYS_INLINE void storeResults(Packet4f (&acc)[4], Index rows, const Packet4f& pAlpha, float* result,
                                       Index extra_cols, Index extra_rows);
 
 template <Index num_acc, bool extraRows, Index size = 4>
-EIGEN_ALWAYS_INLINE void outputVecColResults(Packet4f (&acc)[num_acc][size], float* result, Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void outputVecColResults(Packet4f (&acc)[num_acc][size], float* result, const Packet4f& pAlpha,
                                              Index extra_rows);
 
 template <Index num_acc, Index size = 4>
-EIGEN_ALWAYS_INLINE void outputVecResults(Packet4f (&acc)[num_acc][size], float* result, Packet4f pAlpha);
+EIGEN_ALWAYS_INLINE void outputVecResults(Packet4f (&acc)[num_acc][size], float* result, const Packet4f& pAlpha);
 
 template <typename RhsMapper, bool linear>
 EIGEN_ALWAYS_INLINE Packet8bf loadColData(RhsMapper& rhs, Index j);
@@ -203,3 +209,5 @@
 
 }  // end namespace internal
 }  // end namespace Eigen
+
+#endif  // EIGEN_MATRIX_PRODUCT_COMMON_ALTIVEC_H
diff --git a/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h b/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
index ab02d32..37d5b46 100644
--- a/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
+++ b/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
 #define EIGEN_MATRIX_PRODUCT_MMA_ALTIVEC_H
@@ -101,8 +102,8 @@
 }
 
 template <typename Packet, typename RhsPacket, bool ConjugateLhs, bool ConjugateRhs, bool LhsIsReal, bool RhsIsReal>
-EIGEN_ALWAYS_INLINE void pgercMMA(__vector_quad* accReal, __vector_quad* accImag, const Packet& lhsV, Packet& lhsVi,
-                                  const RhsPacket& rhsV, RhsPacket& rhsVi) {
+EIGEN_ALWAYS_INLINE void pgercMMA(__vector_quad* accReal, __vector_quad* accImag, const Packet& lhsV,
+                                  const Packet& lhsVi, const RhsPacket& rhsV, const RhsPacket& rhsVi) {
   pgerMMA<Packet, RhsPacket, false>(accReal, rhsV, lhsV);
   if (LhsIsReal) {
     pgerMMA<Packet, RhsPacket, ConjugateRhs>(accImag, rhsVi, lhsV);
@@ -335,9 +336,9 @@
                                                      const Scalar* lhs_base, const Scalar* rhs_base, Index depth,
                                                      Index strideA, Index strideB, Index offsetA, Index& row,
                                                      const Packet& pAlpha, Index accCols2) {
-  const Scalar *rhs_ptr0 = rhs_base, *rhs_ptr1 = NULL, *rhs_ptr2 = NULL, *rhs_ptr3 = NULL;
-  const Scalar *lhs_ptr0 = NULL, *lhs_ptr1 = NULL, *lhs_ptr2 = NULL, *lhs_ptr3 = NULL, *lhs_ptr4 = NULL,
-               *lhs_ptr5 = NULL, *lhs_ptr6 = NULL, *lhs_ptr7 = NULL;
+  const Scalar *rhs_ptr0 = rhs_base, *rhs_ptr1 = nullptr, *rhs_ptr2 = nullptr, *rhs_ptr3 = nullptr;
+  const Scalar *lhs_ptr0 = nullptr, *lhs_ptr1 = nullptr, *lhs_ptr2 = nullptr, *lhs_ptr3 = nullptr, *lhs_ptr4 = nullptr,
+               *lhs_ptr5 = nullptr, *lhs_ptr6 = nullptr, *lhs_ptr7 = nullptr;
   __vector_quad accZero0, accZero1, accZero2, accZero3, accZero4, accZero5, accZero6, accZero7;
 
   if (accItr > 1) {
@@ -490,7 +491,7 @@
   const Packet pAlpha = pset1<Packet>(alpha);
   const Packet pMask = bmask<Packet>(remaining_rows);
 
-  typedef typename std::conditional_t<(sizeof(Scalar) == sizeof(float)), RhsPacket, __vector_pair> RhsPacket2;
+  typedef std::conditional_t<(sizeof(Scalar) == sizeof(float)), RhsPacket, __vector_pair> RhsPacket2;
 
   Index col = 0;
 #ifdef GEMM_MULTIPLE_COLS
@@ -702,8 +703,8 @@
                                                              Index depth, Index strideA, Index offsetA, Index strideB,
                                                              Index& row, const Packet& pAlphaReal,
                                                              const Packet& pAlphaImag, const Packet& pMask) {
-  const Scalar *rhs_ptr_real0 = rhs_base, *rhs_ptr_real1 = NULL, *rhs_ptr_real2 = NULL, *rhs_ptr_real3 = NULL;
-  const Scalar *rhs_ptr_imag0 = NULL, *rhs_ptr_imag1 = NULL, *rhs_ptr_imag2 = NULL, *rhs_ptr_imag3 = NULL;
+  const Scalar *rhs_ptr_real0 = rhs_base, *rhs_ptr_real1 = nullptr, *rhs_ptr_real2 = nullptr, *rhs_ptr_real3 = nullptr;
+  const Scalar *rhs_ptr_imag0 = nullptr, *rhs_ptr_imag1 = nullptr, *rhs_ptr_imag2 = nullptr, *rhs_ptr_imag3 = nullptr;
   const Index imag_delta = accCols * strideA;
   const Index imag_delta2 = accCols2 * strideA;
 
@@ -745,8 +746,8 @@
     EIGEN_UNUSED_VARIABLE(res2);
     EIGEN_UNUSED_VARIABLE(res3);
   }
-  const Scalar *lhs_ptr_real0 = NULL, *lhs_ptr_real1 = NULL;
-  const Scalar *lhs_ptr_real2 = NULL, *lhs_ptr_real3 = NULL;
+  const Scalar *lhs_ptr_real0 = nullptr, *lhs_ptr_real1 = nullptr;
+  const Scalar *lhs_ptr_real2 = nullptr, *lhs_ptr_real3 = nullptr;
   __vector_quad accReal0, accImag0, accReal1, accImag1, accReal2, accImag2, accReal3, accImag3;
 
   MICRO_COMPLEX_MMA_SRC_PTR
@@ -869,7 +870,7 @@
   const Scalar* blockA = (Scalar*)blockAc;
   const Scalar* blockB = (Scalar*)blockBc;
 
-  typedef typename std::conditional_t<(sizeof(Scalar) == sizeof(float)), RhsPacket, __vector_pair> RhsPacket2;
+  typedef std::conditional_t<(sizeof(Scalar) == sizeof(float)), RhsPacket, __vector_pair> RhsPacket2;
 
   Index col = 0;
 #ifdef GEMM_MULTIPLE_COLS
diff --git a/Eigen/src/Core/arch/AltiVec/MatrixProductMMAbfloat16.h b/Eigen/src/Core/arch/AltiVec/MatrixProductMMAbfloat16.h
index 6ecec0e..3124a0c 100644
--- a/Eigen/src/Core/arch/AltiVec/MatrixProductMMAbfloat16.h
+++ b/Eigen/src/Core/arch/AltiVec/MatrixProductMMAbfloat16.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_MATRIX_PRODUCT_MMA_BFLOAT16_ALTIVEC_H
 #define EIGEN_MATRIX_PRODUCT_MMA_BFLOAT16_ALTIVEC_H
 
@@ -82,7 +85,7 @@
 }
 
 template <Index num_acc, bool rhsExtraCols, bool lhsExtraRows, Index num_rhs, Index num_lhs>
-EIGEN_ALWAYS_INLINE void outputResults(Packet4f (&acc)[num_acc][4], Index rows, const Packet4f pAlpha, float* result,
+EIGEN_ALWAYS_INLINE void outputResults(Packet4f (&acc)[num_acc][4], Index rows, const Packet4f& pAlpha, float* result,
                                        const Index extra_cols, Index extra_rows) {
   BFLOAT16_UNROLL
   for (Index i = 0, k = 0; i < num_rhs - (rhsExtraCols ? 1 : 0); i++, result += 4 * rows) {
@@ -97,7 +100,7 @@
 }
 
 template <const Index num_acc, const Index num_packets, bool rhsExtraCols, bool lhsExtraRows, bool multiIter = false>
-EIGEN_ALWAYS_INLINE void colLoopBodyIter(Index depth, Index rows, const Packet4f pAlpha, const bfloat16* indexA,
+EIGEN_ALWAYS_INLINE void colLoopBodyIter(Index depth, Index rows, const Packet4f& pAlpha, const bfloat16* indexA,
                                          const bfloat16* indexB, Index strideB, Index offsetB, float* result,
                                          const Index extra_cols, const Index extra_rows) {
   constexpr Index num_lhs = multiIter ? (num_packets / 4) : 1;
@@ -130,7 +133,7 @@
 #define MAX_BFLOAT16_ACC 8
 
 template <const Index num_acc, const Index num_packets, bool rhsExtraCols, bool lhsExtraRows>
-void colLoopBody(Index& col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16* indexA,
+void colLoopBody(Index& col, Index depth, Index cols, Index rows, const Packet4f& pAlpha, const bfloat16* indexA,
                  const bfloat16* indexB, Index strideB, Index offsetB, float* result) {
   constexpr Index step = (num_acc * 4);  // each accumulator has 4 elements
   const Index extra_cols = (rhsExtraCols) ? (cols & 3) : 0;
@@ -148,7 +151,7 @@
 }
 
 template <const Index num_acc, const Index num_packets, bool rhsExtraCols, bool lhsExtraRows>
-EIGEN_ALWAYS_INLINE void colLoopBodyExtraN(Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void colLoopBodyExtraN(Index col, Index depth, Index cols, Index rows, const Packet4f& pAlpha,
                                            const bfloat16* indexA, const bfloat16* blockB, Index strideB, Index offsetB,
                                            float* result) {
   if (MAX_BFLOAT16_ACC > num_acc) {
@@ -158,7 +161,7 @@
 }
 
 template <const Index num_packets, bool rhsExtraCols, bool lhsExtraRows>
-void colLoopBodyExtra(Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16* indexA,
+void colLoopBodyExtra(Index col, Index depth, Index cols, Index rows, const Packet4f& pAlpha, const bfloat16* indexA,
                       const bfloat16* blockB, Index strideB, Index offsetB, float* result) {
   switch ((cols - col) >> 2) {
     case 7:
@@ -199,7 +202,7 @@
 }
 
 template <const Index num_packets, bool lhsExtraRows = false>
-EIGEN_ALWAYS_INLINE void colLoops(Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16* indexA,
+EIGEN_ALWAYS_INLINE void colLoops(Index depth, Index cols, Index rows, const Packet4f& pAlpha, const bfloat16* indexA,
                                   const bfloat16* blockB, Index strideB, Index offsetB, float* result) {
   Index col = 0;
   if (cols >= (MAX_BFLOAT16_ACC * 4)) {
@@ -309,7 +312,7 @@
 
 template <Index size>
 EIGEN_ALWAYS_INLINE void calcColLoops(const bfloat16*& indexA, Index& row, Index depth, Index cols, Index rows,
-                                      const Packet4f pAlpha, const bfloat16* indexB, Index strideB, Index offsetA,
+                                      const Packet4f& pAlpha, const bfloat16* indexB, Index strideB, Index offsetA,
                                       Index offsetB, Index bigSuffix, float* result) {
   if ((size == 16) || (rows & size)) {
     indexA += size * offsetA;
@@ -331,7 +334,7 @@
   if (strideA == -1) strideA = depth;
   if (strideB == -1) strideB = depth;
   // Packing is done in blocks.
-  // There's 4 possible sizes of blocks
+  // There are 4 possible sizes of blocks
   // Blocks of 8 columns with 16 elements (8x16)
   // Blocks of 8 columns with 8 elements (8x8). This happens when there's 16 > rows >= 8
   // Blocks of 8 columns with 4 elements (8x4). This happens when there's 8 > rows >= 4
@@ -377,7 +380,8 @@
 }
 
 template <Index num_acc>
-EIGEN_ALWAYS_INLINE void multVec(__vector_quad (&quad_acc)[num_acc], Packet8bf (&a0)[num_acc], Packet8bf b0) {
+EIGEN_ALWAYS_INLINE void multVec(__vector_quad (&quad_acc)[num_acc], const Packet8bf (&a0)[num_acc],
+                                 const Packet8bf& b0) {
   BFLOAT16_UNROLL
   for (Index k = 0; k < num_acc; k++) {
     __builtin_mma_xvbf16ger2pp(&(quad_acc[k]), reinterpret_cast<Packet16uc>(b0.m_val),
@@ -409,7 +413,7 @@
 #define MAX_BFLOAT16_VEC_ACC 8
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper, bool extraRows, bool linear>
-void colVecColLoopBody(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+void colVecColLoopBody(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                        float* result) {
   constexpr Index step = (num_acc * 4);
   const Index extra_rows = (extraRows) ? (rows & 3) : 0;
@@ -441,7 +445,7 @@
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper, bool extraRows, bool linear>
 EIGEN_ALWAYS_INLINE void colVecColLoopBodyExtraN(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                                 const Packet4f pAlpha, float* result) {
+                                                 const Packet4f& pAlpha, float* result) {
   if (MAX_BFLOAT16_VEC_ACC > num_acc) {
     colVecColLoopBody<num_acc + (extraRows ? 1 : 0), LhsMapper, RhsMapper, extraRows, linear>(row, cend, rows, lhs, rhs,
                                                                                               pAlpha, result);
@@ -450,7 +454,7 @@
 
 template <typename LhsMapper, typename RhsMapper, bool extraRows, bool linear>
 EIGEN_ALWAYS_INLINE void colVecColLoopBodyExtra(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                                const Packet4f pAlpha, float* result) {
+                                                const Packet4f& pAlpha, float* result) {
   switch ((rows - row) >> 2) {
     case 7:
       colVecColLoopBodyExtraN<7, LhsMapper, RhsMapper, extraRows, linear>(row, cend, rows, lhs, rhs, pAlpha, result);
@@ -482,7 +486,7 @@
 }
 
 template <typename LhsMapper, typename RhsMapper, bool linear>
-EIGEN_ALWAYS_INLINE void calcVecColLoops(Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void calcVecColLoops(Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                                          float* result) {
   Index row = 0;
   if (rows >= (MAX_BFLOAT16_VEC_ACC * 4)) {
@@ -499,8 +503,8 @@
 
 template <typename RhsMapper, typename LhsMapper, typename = void>
 struct UseMMAStride : std::false_type {
-  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs, Packet4f pAlpha,
-                                      float* result) {
+  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
+                                      const Packet4f& pAlpha, float* result) {
     using RhsSubMapper = typename RhsMapper::SubMapper;
 
     RhsSubMapper rhs2 = rhs.getSubMapper(j2, 0);
@@ -512,8 +516,8 @@
 struct UseMMAStride<RhsMapper, LhsMapper,
                     std::enable_if_t<std::is_member_function_pointer<decltype(&RhsMapper::stride)>::value>>
     : std::true_type {
-  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs, Packet4f pAlpha,
-                                      float* result) {
+  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
+                                      const Packet4f& pAlpha, float* result) {
     using RhsSubMapper = typename RhsMapper::SubMapper;
 
     RhsSubMapper rhs2 = rhs.getSubMapper(j2, 0);
@@ -633,7 +637,7 @@
 }
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper>
-void colVecLoopBody(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+void colVecLoopBody(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                     float* result) {
   constexpr bool multiIters = (num_acc == MAX_BFLOAT16_VEC_ACC);
   const Index extra_cols = (cols & 7);
@@ -659,7 +663,7 @@
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper>
 EIGEN_ALWAYS_INLINE void colVecLoopBodyExtraN(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                              const Packet4f pAlpha, float* result) {
+                                              const Packet4f& pAlpha, float* result) {
   if (MAX_BFLOAT16_VEC_ACC > num_acc) {
     colVecLoopBody<num_acc, LhsMapper, RhsMapper>(row, cols, rows, lhs, rhs, pAlpha, result);
   }
@@ -667,7 +671,7 @@
 
 template <typename LhsMapper, typename RhsMapper>
 EIGEN_ALWAYS_INLINE void colVecLoopBodyExtra(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                             const Packet4f pAlpha, float* result) {
+                                             const Packet4f& pAlpha, float* result) {
   switch (rows - row) {
     case 7:
       colVecLoopBodyExtraN<7, LhsMapper, RhsMapper>(row, cols, rows, lhs, rhs, pAlpha, result);
@@ -694,7 +698,7 @@
 }
 
 template <typename LhsMapper, typename RhsMapper>
-EIGEN_ALWAYS_INLINE void calcVecLoops(Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void calcVecLoops(Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                                       float* result) {
   Index row = 0;
   if (rows >= MAX_BFLOAT16_VEC_ACC) {
diff --git a/Eigen/src/Core/arch/AltiVec/MatrixVectorProduct.inc b/Eigen/src/Core/arch/AltiVec/MatrixVectorProduct.inc
index 90c0d39..acbd03d 100644
--- a/Eigen/src/Core/arch/AltiVec/MatrixVectorProduct.inc
+++ b/Eigen/src/Core/arch/AltiVec/MatrixVectorProduct.inc
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIX_VECTOR_PRODUCT_ALTIVEC_H
 #define EIGEN_MATRIX_VECTOR_PRODUCT_ALTIVEC_H
@@ -68,7 +69,7 @@
 
 /** \internal multiply and add and store results */
 template <typename ResPacket, typename ResScalar>
-EIGEN_ALWAYS_INLINE void storeMaddData(ResScalar* res, ResPacket& palpha, ResPacket& data) {
+EIGEN_ALWAYS_INLINE void storeMaddData(ResScalar* res, const ResPacket& palpha, const ResPacket& data) {
   pstoreu(res, pmadd(data, palpha, ploadu<ResPacket>(res)));
 }
 
@@ -90,13 +91,13 @@
   func(0, N, which) func(1, N, which) func(2, N, which) func(3, N, which) func(4, N, which) func(5, N, which) \
       func(6, N, which) func(7, N, which)
 
-#define GEMV_UNUSED_VAR(iter, N, which) \
-  if (GEMV_GETN(N) <= iter) {           \
-    EIGEN_UNUSED_VARIABLE(which##iter); \
+#define GEMV_UNUSED_VAR(iter, N, which)       \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) <= iter) { \
+    EIGEN_UNUSED_VARIABLE(which##iter);       \
   }
 
 #define GEMV_UNUSED_EXTRA_VAR(iter, N, which) \
-  if (N <= iter) {                            \
+  EIGEN_IF_CONSTEXPR (N <= iter) {            \
     EIGEN_UNUSED_VARIABLE(which##iter);       \
   }
 
@@ -104,9 +105,9 @@
 
 #define GEMV_UNUSED(N, which) GEMV_UNROLL3(GEMV_UNUSED_VAR, N, which)
 
-#define GEMV_INIT_MMA(iter, N)         \
-  if (GEMV_GETN(N) > iter) {           \
-    __builtin_mma_xxsetaccz(&e##iter); \
+#define GEMV_INIT_MMA(iter, N)               \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) { \
+    __builtin_mma_xxsetaccz(&e##iter);       \
   }
 
 #if EIGEN_COMP_LLVM
@@ -119,8 +120,8 @@
 #endif
 
 #define GEMV_LOAD1A_COL_MMA(iter, N)         \
-  if (GEMV_GETN(N) > iter) {                 \
-    if (GEMV_IS_FLOAT) {                     \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) { \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {     \
       g##iter = GEMV_LOADPACKET_COL(iter);   \
       EIGEN_UNUSED_VARIABLE(b##iter);        \
     } else {                                 \
@@ -133,8 +134,8 @@
   }
 
 #define GEMV_WORK1A_COL_MMA(iter, N)                                      \
-  if (GEMV_GETN(N) > iter) {                                              \
-    if (GEMV_IS_FLOAT) {                                                  \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) {                              \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                                  \
       pger_vecMMA_acc<LhsPacket, RhsPacket, true>(&e##iter, a0, g##iter); \
     } else {                                                              \
       pger_vecMMA_acc<LhsPacket, RhsPacket, true>(&e##iter, b##iter, a0); \
@@ -142,8 +143,8 @@
   }
 
 #define GEMV_LOAD1B_COL_MMA(iter1, iter2, iter3, N) \
-  if (GEMV_GETN(N) > iter1) {                       \
-    if (GEMV_IS_FLOAT) {                            \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter1) {       \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {            \
       GEMV_LOADPAIR_COL_MMA(iter2, iter2)           \
       EIGEN_UNUSED_VARIABLE(b##iter3);              \
     } else {                                        \
@@ -158,8 +159,8 @@
   EIGEN_UNUSED_VARIABLE(g##iter3);
 
 #define GEMV_WORK1B_COL_MMA(iter1, iter2, iter3, N)                          \
-  if (GEMV_GETN(N) > iter1) {                                                \
-    if (GEMV_IS_FLOAT) {                                                     \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter1) {                                \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                                     \
       LhsPacket h[2];                                                        \
       __builtin_vsx_disassemble_pair(reinterpret_cast<void*>(h), &b##iter2); \
       pger_vecMMA_acc<LhsPacket, RhsPacket, true>(&e##iter2, a0, h[0]);      \
@@ -172,14 +173,14 @@
 
 #if EIGEN_COMP_LLVM
 #define GEMV_LOAD_COL_MMA(N)                        \
-  if (GEMV_GETN(N) > 1) {                           \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > 1) {           \
     GEMV_UNROLL_HALF(GEMV_LOAD1B_COL_MMA, (N >> 1)) \
   } else {                                          \
     GEMV_UNROLL(GEMV_LOAD1A_COL_MMA, N)             \
   }
 
 #define GEMV_WORK_COL_MMA(N)                        \
-  if (GEMV_GETN(N) > 1) {                           \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > 1) {           \
     GEMV_UNROLL_HALF(GEMV_WORK1B_COL_MMA, (N >> 1)) \
   } else {                                          \
     GEMV_UNROLL(GEMV_WORK1A_COL_MMA, N)             \
@@ -191,9 +192,9 @@
 #endif
 
 #define GEMV_DISASSEMBLE_MMA(iter, N)                              \
-  if (GEMV_GETN(N) > iter) {                                       \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) {                       \
     __builtin_mma_disassemble_acc(&result##iter.packet, &e##iter); \
-    if (!GEMV_IS_FLOAT) {                                          \
+    EIGEN_IF_CONSTEXPR (!GEMV_IS_FLOAT) {                          \
       result##iter.packet[0][1] = result##iter.packet[1][0];       \
       result##iter.packet[2][1] = result##iter.packet[3][0];       \
     }                                                              \
@@ -203,8 +204,8 @@
   b##iter1 = *reinterpret_cast<__vector_pair*>(res + i + ((iter2) * ResPacketSize));
 
 #define GEMV_LOAD2_COL_MMA(iter1, iter2, iter3, N) \
-  if (GEMV_GETN(N) > iter1) {                      \
-    if (GEMV_IS_FLOAT) {                           \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter1) {      \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {           \
       GEMV_LOADPAIR2_COL_MMA(iter2, iter2);        \
       EIGEN_UNUSED_VARIABLE(b##iter3);             \
     } else {                                       \
@@ -225,7 +226,7 @@
   GEMV_BUILDPAIR_MMA(b##iter2, f##iter2[0], f##iter2[1]);
 #else
 #define GEMV_WORKPAIR2_COL_MMA(iter2, iter3, iter4)                                        \
-  if (GEMV_IS_FLOAT) {                                                                     \
+  EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                                                     \
     __asm__("xvmaddasp %0,%x1,%x3\n\txvmaddasp %L0,%x2,%x3"                                \
             : "+&d"(b##iter2)                                                              \
             : "wa"(result##iter3.packet[0]), "wa"(result##iter2.packet[0]), "wa"(palpha)); \
@@ -237,8 +238,8 @@
 #endif
 
 #define GEMV_WORK2_COL_MMA(iter1, iter2, iter3, N)      \
-  if (GEMV_GETN(N) > iter1) {                           \
-    if (GEMV_IS_FLOAT) {                                \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter1) {           \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                \
       GEMV_WORKPAIR2_COL_MMA(iter2, iter3, iter2);      \
     } else {                                            \
       GEMV_WORKPAIR2_COL_MMA(iter2, iter2, iter2 << 1); \
@@ -250,8 +251,8 @@
   *reinterpret_cast<__vector_pair*>(res + i + ((iter2) * ResPacketSize)) = b##iter1;
 
 #define GEMV_STORE_COL_MMA(iter, N)                                                                          \
-  if (GEMV_GETN(N) > iter) {                                                                                 \
-    if (GEMV_IS_FLOAT) {                                                                                     \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) {                                                                 \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                                                                     \
       storeMaddData<ResPacket, ResScalar>(res + i + (iter * ResPacketSize), palpha, result##iter.packet[0]); \
     } else {                                                                                                 \
       GEMV_LOADPAIR2_COL_MMA(iter, iter << 1)                                                                \
@@ -261,8 +262,8 @@
   }
 
 #define GEMV_STORE2_COL_MMA(iter1, iter2, iter3, N) \
-  if (GEMV_GETN(N) > iter1) {                       \
-    if (GEMV_IS_FLOAT) {                            \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter1) {       \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {            \
       GEMV_STOREPAIR2_COL_MMA(iter2, iter2);        \
     } else {                                        \
       GEMV_STOREPAIR2_COL_MMA(iter2, iter2 << 1)    \
@@ -270,51 +271,50 @@
     }                                               \
   }
 
-#define GEMV_PROCESS_COL_ONE_MMA(N)                 \
-  GEMV_UNROLL(GEMV_INIT_MMA, N)                     \
-  Index j = j2;                                     \
-  __vector_pair b0, b1, b2, b3, b4, b5, b6, b7;     \
-  do {                                              \
-    LhsPacket g0, g1, g2, g3, g4, g5, g6, g7;       \
-    RhsPacket a0 = pset1<RhsPacket>(rhs2(j, 0));    \
-    GEMV_UNROLL(GEMV_PREFETCH, N)                   \
-    GEMV_LOAD_COL_MMA(N)                            \
-    GEMV_WORK_COL_MMA(N)                            \
-  } while (++j < jend);                             \
-  GEMV_UNROLL(GEMV_DISASSEMBLE_MMA, N)              \
-  if (GEMV_GETN(N) <= 1) {                          \
-    GEMV_UNROLL(GEMV_STORE_COL_MMA, N)              \
-  } else {                                          \
-    GEMV_UNROLL_HALF(GEMV_LOAD2_COL_MMA, (N >> 1))  \
-    GEMV_UNROLL_HALF(GEMV_WORK2_COL_MMA, (N >> 1))  \
-    GEMV_UNROLL_HALF(GEMV_STORE2_COL_MMA, (N >> 1)) \
-  }                                                 \
+#define GEMV_PROCESS_COL_ONE_MMA(N)                                                                \
+  GEMV_UNROLL(GEMV_INIT_MMA, N)                                                                    \
+  Index j = j2;                                                                                    \
+  __vector_pair b0, b1, b2, b3, b4, b5, b6, b7;                                                    \
+  do {                                                                                             \
+    LhsPacket g0, g1, g2, g3, g4, g5, g6, g7;                                                      \
+    RhsPacket a0 = pset1<RhsPacket>(rhs2(j, 0));                                                   \
+    GEMV_UNROLL(GEMV_PREFETCH, N)                                                                  \
+    GEMV_LOAD_COL_MMA(N)                                                                           \
+    GEMV_WORK_COL_MMA(N)                                                                           \
+  } while (++j < jend);                                                                            \
+  GEMV_UNROLL(GEMV_DISASSEMBLE_MMA, N)                                                             \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) <= 1) {                                                         \
+    GEMV_UNROLL(GEMV_STORE_COL_MMA, N)                                                             \
+  } else {                                                                                         \
+    GEMV_UNROLL_HALF(GEMV_LOAD2_COL_MMA, (N >> 1))                                                 \
+    GEMV_UNROLL_HALF(GEMV_WORK2_COL_MMA, (N >> 1)) GEMV_UNROLL_HALF(GEMV_STORE2_COL_MMA, (N >> 1)) \
+  }                                                                                                \
   i += (ResPacketSize * N);
 #endif
 
 #define GEMV_INIT(iter, N)                    \
-  if (N > iter) {                             \
+  EIGEN_IF_CONSTEXPR (N > iter) {             \
     c##iter = pset1<ResPacket>(ResScalar(0)); \
   } else {                                    \
     EIGEN_UNUSED_VARIABLE(c##iter);           \
   }
 
 #ifdef EIGEN_POWER_USE_GEMV_PREFETCH
-#define GEMV_PREFETCH(iter, N)                                   \
-  if (GEMV_GETN(N) > ((iter >> 1) + ((N >> 1) * (iter & 1)))) {  \
-    lhs.prefetch(i + (iter * LhsPacketSize) + prefetch_dist, j); \
+#define GEMV_PREFETCH(iter, N)                                                  \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > ((iter >> 1) + ((N >> 1) * (iter & 1)))) { \
+    lhs.prefetch(i + (iter * LhsPacketSize) + prefetch_dist, j);                \
   }
 #else
 #define GEMV_PREFETCH(iter, N)
 #endif
 
 #define GEMV_WORK_COL(iter, N)                                   \
-  if (N > iter) {                                                \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                \
     c##iter = pcj.pmadd(GEMV_LOADPACKET_COL(iter), a0, c##iter); \
   }
 
 #define GEMV_STORE_COL(iter, N)                                                           \
-  if (N > iter) {                                                                         \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                                         \
     pstoreu(res + i + (iter * ResPacketSize),                                             \
             pmadd(c##iter, palpha, ploadu<ResPacket>(res + i + (iter * ResPacketSize)))); \
   }
@@ -380,7 +380,8 @@
   conj_helper<LhsPacket, RhsPacket, false, false> pcj;
 
   const Index lhsStride = lhs.stride();
-  // TODO: for padded aligned inputs, we could enable aligned reads
+  // LhsAlignment stays Unaligned; enabling aligned reads would require
+  // propagating the Mapper's Alignment through the run() template.
   enum {
     LhsAlignment = Unaligned,
     ResPacketSize = Traits::ResPacketSize,
@@ -442,10 +443,10 @@
 }
 
 template <bool extraRows>
-EIGEN_ALWAYS_INLINE void outputVecCol(Packet4f acc, float* result, Packet4f pAlpha, Index extra_rows) {
+EIGEN_ALWAYS_INLINE void outputVecCol(const Packet4f& acc, float* result, const Packet4f& pAlpha, Index extra_rows) {
   Packet4f d0 = ploadu<Packet4f>(result);
   d0 = pmadd(acc, pAlpha, d0);
-  if (extraRows) {
+  EIGEN_IF_CONSTEXPR (extraRows) {
     pstoreu_partial(result, d0, extra_rows);
   } else {
     pstoreu(result, d0);
@@ -453,13 +454,13 @@
 }
 
 template <Index num_acc, bool extraRows, Index size>
-EIGEN_ALWAYS_INLINE void outputVecColResults(Packet4f (&acc)[num_acc][size], float* result, Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void outputVecColResults(Packet4f (&acc)[num_acc][size], float* result, const Packet4f& pAlpha,
                                              Index extra_rows) {
   constexpr Index real_acc = (num_acc - (extraRows ? 1 : 0));
   for (Index k = 0; k < real_acc; k++) {
     outputVecCol<false>(acc[k][0], result + k * 4, pAlpha, extra_rows);
   }
-  if (extraRows) {
+  EIGEN_IF_CONSTEXPR (extraRows) {
     outputVecCol<true>(acc[real_acc][0], result + real_acc * 4, pAlpha, extra_rows);
   }
 }
@@ -471,7 +472,7 @@
 EIGEN_ALWAYS_INLINE void loadVecLoopVSX(Index k, LhsMapper& lhs, Packet4f (&a0)[num_acc][2]) {
   Packet8bf c0 = lhs.template loadPacket<Packet8bf>(k * 4, 0);
   Packet8bf b1;
-  if (!zero) {
+  EIGEN_IF_CONSTEXPR (!zero) {
     b1 = lhs.template loadPacket<Packet8bf>(k * 4, 1);
 
     a0[k + 0][1] = oneConvertBF16Hi(b1.m_val);
@@ -480,7 +481,7 @@
 
   if (num_acc > (k + 1)) {
     a0[k + 1][0] = oneConvertBF16Lo(c0.m_val);
-    if (!zero) {
+    EIGEN_IF_CONSTEXPR (!zero) {
       a0[k + 1][1] = oneConvertBF16Lo(b1.m_val);
     }
   }
@@ -528,7 +529,7 @@
   Packet8bf b2 = loadColData<RhsMapper, linear>(rhs, j);
 
   b0[0] = oneConvertBF16Perm(b2.m_val, p16uc_MERGE16_32_V1);
-  if (!zero) {
+  EIGEN_IF_CONSTEXPR (!zero) {
     b0[1] = oneConvertBF16Perm(b2.m_val, p16uc_MERGE16_32_V2);
   }
 
@@ -553,7 +554,7 @@
 #define MAX_BFLOAT16_VEC_ACC_VSX 8
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper, bool extraRows, bool linear>
-void colVSXVecColLoopBody(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+void colVSXVecColLoopBody(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                           float* result) {
   constexpr Index step = (num_acc * 4);
   const Index extra_rows = (extraRows) ? (rows & 3) : 0;
@@ -584,8 +585,8 @@
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper, bool extraRows, bool linear>
 EIGEN_ALWAYS_INLINE void colVSXVecColLoopBodyExtraN(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                                    const Packet4f pAlpha, float* result) {
-  if (MAX_BFLOAT16_VEC_ACC_VSX > num_acc) {
+                                                    const Packet4f& pAlpha, float* result) {
+  EIGEN_IF_CONSTEXPR (MAX_BFLOAT16_VEC_ACC_VSX > num_acc) {
     colVSXVecColLoopBody<num_acc + (extraRows ? 1 : 0), LhsMapper, RhsMapper, extraRows, linear>(row, cend, rows, lhs,
                                                                                                  rhs, pAlpha, result);
   }
@@ -593,7 +594,7 @@
 
 template <typename LhsMapper, typename RhsMapper, bool extraRows, bool linear>
 EIGEN_ALWAYS_INLINE void colVSXVecColLoopBodyExtra(Index& row, Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                                   const Packet4f pAlpha, float* result) {
+                                                   const Packet4f& pAlpha, float* result) {
   switch ((rows - row) >> 2) {
     case 7:
       colVSXVecColLoopBodyExtraN<7, LhsMapper, RhsMapper, extraRows, linear>(row, cend, rows, lhs, rhs, pAlpha, result);
@@ -617,7 +618,7 @@
       colVSXVecColLoopBodyExtraN<1, LhsMapper, RhsMapper, extraRows, linear>(row, cend, rows, lhs, rhs, pAlpha, result);
       break;
     default:
-      if (extraRows) {
+      EIGEN_IF_CONSTEXPR (extraRows) {
         colVSXVecColLoopBody<1, LhsMapper, RhsMapper, true, linear>(row, cend, rows, lhs, rhs, pAlpha, result);
       }
       break;
@@ -626,7 +627,7 @@
 
 template <typename LhsMapper, typename RhsMapper, bool linear>
 EIGEN_ALWAYS_INLINE void calcVSXVecColLoops(Index cend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                            const Packet4f pAlpha, float* result) {
+                                            const Packet4f& pAlpha, float* result) {
   Index row = 0;
   if (rows >= (MAX_BFLOAT16_VEC_ACC_VSX * 4)) {
     colVSXVecColLoopBody<MAX_BFLOAT16_VEC_ACC_VSX, LhsMapper, RhsMapper, false, linear>(row, cend, rows, lhs, rhs,
@@ -641,15 +642,15 @@
 }
 
 template <const Index size, bool inc, Index delta>
-EIGEN_ALWAYS_INLINE void storeBF16fromResult(bfloat16* dst, Packet8bf data, Index resInc, Index extra) {
+EIGEN_ALWAYS_INLINE void storeBF16fromResult(bfloat16* dst, const Packet8bf& data, Index resInc, Index extra) {
   if (inc) {
-    if (size < 8) {
+    EIGEN_IF_CONSTEXPR (size < 8) {
       pscatter_partial(dst + delta * resInc, data, resInc, extra);
     } else {
       pscatter(dst + delta * resInc, data, resInc);
     }
   } else {
-    if (size < 8) {
+    EIGEN_IF_CONSTEXPR (size < 8) {
       pstoreu_partial(dst + delta, data, extra);
     } else {
       pstoreu(dst + delta, data);
@@ -664,24 +665,24 @@
   while (i + size <= rows) {
     PacketBlock<Packet8bf, (size + 7) / 8> r32;
     r32.packet[0] = convertF32toBF16VSX(result + i + 0);
-    if (size >= 16) {
+    EIGEN_IF_CONSTEXPR (size >= 16) {
       r32.packet[1] = convertF32toBF16VSX(result + i + 8);
     }
-    if (size >= 32) {
+    EIGEN_IF_CONSTEXPR (size >= 32) {
       r32.packet[2] = convertF32toBF16VSX(result + i + 16);
       r32.packet[3] = convertF32toBF16VSX(result + i + 24);
     }
     storeBF16fromResult<size, inc, 0>(dst, r32.packet[0], resInc, rows & 7);
-    if (size >= 16) {
+    EIGEN_IF_CONSTEXPR (size >= 16) {
       storeBF16fromResult<size, inc, 8>(dst, r32.packet[1], resInc);
     }
-    if (size >= 32) {
+    EIGEN_IF_CONSTEXPR (size >= 32) {
       storeBF16fromResult<size, inc, 16>(dst, r32.packet[2], resInc);
       storeBF16fromResult<size, inc, 24>(dst, r32.packet[3], resInc);
     }
     i += extra;
     dst += extra * resInc;
-    if (size != 32) break;
+    EIGEN_IF_CONSTEXPR (size != 32) break;
   }
 }
 
@@ -696,8 +697,8 @@
 
 template <typename RhsMapper, typename LhsMapper, typename = void>
 struct UseStride : std::false_type {
-  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs, Packet4f pAlpha,
-                                      float* result) {
+  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
+                                      const Packet4f& pAlpha, float* result) {
     using RhsSubMapper = typename RhsMapper::SubMapper;
 
     RhsSubMapper rhs2 = rhs.getSubMapper(j2, 0);
@@ -709,8 +710,8 @@
 struct UseStride<RhsMapper, LhsMapper,
                  std::enable_if_t<std::is_member_function_pointer<decltype(&RhsMapper::stride)>::value>>
     : std::true_type {
-  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs, Packet4f pAlpha,
-                                      float* result) {
+  static EIGEN_ALWAYS_INLINE void run(Index j2, Index jend, Index rows, LhsMapper& lhs, RhsMapper& rhs,
+                                      const Packet4f& pAlpha, float* result) {
     using RhsSubMapper = typename RhsMapper::SubMapper;
 
     RhsSubMapper rhs2 = rhs.getSubMapper(j2, 0);
@@ -757,7 +758,7 @@
 }
 
 template <Index num_acc, Index size>
-EIGEN_ALWAYS_INLINE void outputVecResults(Packet4f (&acc)[num_acc][size], float* result, Packet4f pAlpha) {
+EIGEN_ALWAYS_INLINE void outputVecResults(Packet4f (&acc)[num_acc][size], float* result, const Packet4f& pAlpha) {
   constexpr Index extra = num_acc & 3;
 
   for (Index k = 0; k < num_acc; k += 4) {
@@ -810,7 +811,7 @@
 }
 
 #ifndef _ARCH_PWR9
-EIGEN_ALWAYS_INLINE Packet8us loadPacketPartialZero(Packet8us data, Index extra_cols) {
+EIGEN_ALWAYS_INLINE Packet8us loadPacketPartialZero(const Packet8us& data, Index extra_cols) {
   Packet16uc shift = pset1<Packet16uc>(8 * 2 * (8 - extra_cols));
 #ifdef _BIG_ENDIAN
   return reinterpret_cast<Packet8us>(vec_slo(vec_sro(reinterpret_cast<Packet16uc>(data), shift), shift));
@@ -868,7 +869,7 @@
 }
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper>
-void colVSXVecLoopBody(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+void colVSXVecLoopBody(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                        float* result) {
   constexpr bool multiIters = (num_acc == MAX_BFLOAT16_VEC_ACC_VSX);
   const Index extra_cols = (cols & 7);
@@ -893,15 +894,15 @@
 
 template <const Index num_acc, typename LhsMapper, typename RhsMapper>
 EIGEN_ALWAYS_INLINE void colVSXVecLoopBodyExtraN(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                                 const Packet4f pAlpha, float* result) {
-  if (MAX_BFLOAT16_VEC_ACC_VSX > num_acc) {
+                                                 const Packet4f& pAlpha, float* result) {
+  EIGEN_IF_CONSTEXPR (MAX_BFLOAT16_VEC_ACC_VSX > num_acc) {
     colVSXVecLoopBody<num_acc, LhsMapper, RhsMapper>(row, cols, rows, lhs, rhs, pAlpha, result);
   }
 }
 
 template <typename LhsMapper, typename RhsMapper>
 EIGEN_ALWAYS_INLINE void colVSXVecLoopBodyExtra(Index& row, Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs,
-                                                const Packet4f pAlpha, float* result) {
+                                                const Packet4f& pAlpha, float* result) {
   switch (rows - row) {
     case 7:
       colVSXVecLoopBodyExtraN<7, LhsMapper, RhsMapper>(row, cols, rows, lhs, rhs, pAlpha, result);
@@ -928,7 +929,7 @@
 }
 
 template <typename LhsMapper, typename RhsMapper>
-EIGEN_ALWAYS_INLINE void calcVSXVecLoops(Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f pAlpha,
+EIGEN_ALWAYS_INLINE void calcVSXVecLoops(Index cols, Index rows, LhsMapper& lhs, RhsMapper& rhs, const Packet4f& pAlpha,
                                          float* result) {
   Index row = 0;
   if (rows >= MAX_BFLOAT16_VEC_ACC_VSX) {
@@ -1035,7 +1036,7 @@
 #endif
 
 /** \internal flip the real & imaginary results and packet conjugate */
-EIGEN_ALWAYS_INLINE Packet2cf pcplxflipconj(Packet2cf a) {
+EIGEN_ALWAYS_INLINE Packet2cf pcplxflipconj(const Packet2cf& a) {
 #ifdef PERMXOR_GOOD
   return Packet2cf(Packet4f(vec_permxor(Packet16uc(a.v), p16uc_COMPLEX32_CONJ_XOR, p16uc_COMPLEX32_XORFLIP)));
 #else
@@ -1043,7 +1044,7 @@
 #endif
 }
 
-EIGEN_ALWAYS_INLINE Packet1cd pcplxflipconj(Packet1cd a) {
+EIGEN_ALWAYS_INLINE Packet1cd pcplxflipconj(const Packet1cd& a) {
 #ifdef PERMXOR_GOOD
   return Packet1cd(Packet2d(vec_permxor(Packet16uc(a.v), p16uc_COMPLEX64_CONJ_XOR, p16uc_COMPLEX64_XORFLIP)));
 #else
@@ -1052,7 +1053,7 @@
 }
 
 /** \internal packet conjugate and flip the real & imaginary results */
-EIGEN_ALWAYS_INLINE Packet2cf pcplxconjflip(Packet2cf a) {
+EIGEN_ALWAYS_INLINE Packet2cf pcplxconjflip(const Packet2cf& a) {
 #ifdef PERMXOR_GOOD
   return Packet2cf(Packet4f(vec_permxor(Packet16uc(a.v), p16uc_COMPLEX32_CONJ_XOR2, p16uc_COMPLEX32_XORFLIP)));
 #else
@@ -1060,7 +1061,7 @@
 #endif
 }
 
-EIGEN_ALWAYS_INLINE Packet1cd pcplxconjflip(Packet1cd a) {
+EIGEN_ALWAYS_INLINE Packet1cd pcplxconjflip(const Packet1cd& a) {
 #ifdef PERMXOR_GOOD
   return Packet1cd(Packet2d(vec_permxor(Packet16uc(a.v), p16uc_COMPLEX64_CONJ_XOR2, p16uc_COMPLEX64_XORFLIP)));
 #else
@@ -1069,7 +1070,7 @@
 }
 
 /** \internal packet negate */
-EIGEN_ALWAYS_INLINE Packet2cf pnegate2(Packet2cf a) {
+EIGEN_ALWAYS_INLINE Packet2cf pnegate2(const Packet2cf& a) {
 #ifdef __POWER8_VECTOR__
   return Packet2cf(vec_neg(a.v));
 #else
@@ -1077,7 +1078,7 @@
 #endif
 }
 
-EIGEN_ALWAYS_INLINE Packet1cd pnegate2(Packet1cd a) {
+EIGEN_ALWAYS_INLINE Packet1cd pnegate2(const Packet1cd& a) {
 #ifdef __POWER8_VECTOR__
   return Packet1cd(vec_neg(a.v));
 #else
@@ -1086,7 +1087,7 @@
 }
 
 /** \internal flip the real & imaginary results and negate */
-EIGEN_ALWAYS_INLINE Packet2cf pcplxflipnegate(Packet2cf a) {
+EIGEN_ALWAYS_INLINE Packet2cf pcplxflipnegate(const Packet2cf& a) {
 #ifdef PERMXOR_GOOD
   return Packet2cf(Packet4f(vec_permxor(Packet16uc(a.v), p16uc_COMPLEX32_NEGATE, p16uc_COMPLEX32_XORFLIP)));
 #else
@@ -1094,7 +1095,7 @@
 #endif
 }
 
-EIGEN_ALWAYS_INLINE Packet1cd pcplxflipnegate(Packet1cd a) {
+EIGEN_ALWAYS_INLINE Packet1cd pcplxflipnegate(const Packet1cd& a) {
 #ifdef PERMXOR_GOOD
   return Packet1cd(Packet2d(vec_permxor(Packet16uc(a.v), p16uc_COMPLEX64_NEGATE, p16uc_COMPLEX64_XORFLIP)));
 #else
@@ -1103,11 +1104,11 @@
 }
 
 /** \internal flip the real & imaginary results */
-EIGEN_ALWAYS_INLINE Packet2cf pcplxflip2(Packet2cf a) {
+EIGEN_ALWAYS_INLINE Packet2cf pcplxflip2(const Packet2cf& a) {
   return Packet2cf(Packet4f(vec_perm(Packet16uc(a.v), Packet16uc(a.v), p16uc_COMPLEX32_XORFLIP)));
 }
 
-EIGEN_ALWAYS_INLINE Packet1cd pcplxflip2(Packet1cd a) {
+EIGEN_ALWAYS_INLINE Packet1cd pcplxflip2(const Packet1cd& a) {
 #ifdef EIGEN_VECTORIZE_VSX
   return Packet1cd(__builtin_vsx_xxpermdi(a.v, a.v, 2));
 #else
@@ -1199,7 +1200,7 @@
 /** \internal load a scalar or a vector from complex location */
 template <typename ResPacket>
 EIGEN_ALWAYS_INLINE Packet4f pload_complex(std::complex<float>* src) {
-  if (GEMV_IS_SCALAR) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_SCALAR) {
     return pload_complex_half(src);
   } else {
     return ploadu<Packet4f>(reinterpret_cast<float*>(src));
@@ -1239,9 +1240,9 @@
 
 EIGEN_ALWAYS_INLINE Packet2d pload_real(double* src) { return pset1<Packet2d>(*src); }
 
-EIGEN_ALWAYS_INLINE Packet4f pload_real(Packet4f& src) { return src; }
+EIGEN_ALWAYS_INLINE Packet4f pload_real(const Packet4f& src) { return src; }
 
-EIGEN_ALWAYS_INLINE Packet2d pload_real(Packet2d& src) { return src; }
+EIGEN_ALWAYS_INLINE Packet2d pload_real(const Packet2d& src) { return src; }
 
 /** \internal load a vector from a real-only vector location */
 EIGEN_ALWAYS_INLINE Packet4f pload_real_full(float* src) {
@@ -1262,7 +1263,7 @@
 /** \internal load a vector from a real-only scalar location - row-wise */
 template <typename ResPacket>
 EIGEN_ALWAYS_INLINE Packet4f pload_real_row(float* src) {
-  if (GEMV_IS_SCALAR) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_SCALAR) {
     return pload_real_full(src);
   } else {
     return ploadu<Packet4f>(src);
@@ -1274,14 +1275,18 @@
   return pload_real(src);
 }
 
-EIGEN_ALWAYS_INLINE Packet2cf padd(Packet2cf& a, std::complex<float>& b) {
+// Never executed: predux_complex only forms these calls when ResPacket is a
+// scalar, where GEMV_IS_COMPLEX_COMPLEX is false. They exist because under C++14
+// EIGEN_IF_CONSTEXPR is a plain if, so that arm still has to compile, and its
+// scalar operand arrives as a const reference.
+EIGEN_ALWAYS_INLINE Packet2cf padd(const Packet2cf& a, const std::complex<float>& b) {
   EIGEN_UNUSED_VARIABLE(b);
-  return a;  // Just for compilation
+  return a;
 }
 
-EIGEN_ALWAYS_INLINE Packet1cd padd(Packet1cd& a, std::complex<double>& b) {
+EIGEN_ALWAYS_INLINE Packet1cd padd(const Packet1cd& a, const std::complex<double>& b) {
   EIGEN_UNUSED_VARIABLE(b);
-  return a;  // Just for compilation
+  return a;
 }
 
 /** \internal set a scalar from complex location */
@@ -1327,8 +1332,8 @@
 
 /** \internal initialize a vector from another vector */
 template <typename Packet, typename LhsPacket, typename RhsPacket>
-EIGEN_ALWAYS_INLINE Packet pset_init(Packet& c1) {
-  if (GEMV_IS_COMPLEX_COMPLEX) {
+EIGEN_ALWAYS_INLINE Packet pset_init(const Packet& c1) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {
     EIGEN_UNUSED_VARIABLE(c1);
     return pset_zero<Packet>();
   } else {
@@ -1350,16 +1355,17 @@
 
 /** \internal multiply and add for complex math */
 template <typename ScalarPacket, typename AlphaData>
-EIGEN_ALWAYS_INLINE ScalarPacket pmadd_complex(ScalarPacket& c0, ScalarPacket& c2, ScalarPacket& c4, AlphaData& b0) {
+EIGEN_ALWAYS_INLINE ScalarPacket pmadd_complex(const ScalarPacket& c0, const ScalarPacket& c2, const ScalarPacket& c4,
+                                               AlphaData& b0) {
   return pmadd(c2, b0.separate.i.v, pmadd(c0, b0.separate.r.v, c4));
 }
 
 /** \internal store and madd for complex math */
 template <typename Scalar, typename ScalarPacket, typename PResPacket, typename ResPacket, typename ResScalar,
           typename AlphaData>
-EIGEN_ALWAYS_INLINE void pstoreu_pmadd_complex(PResPacket& c0, AlphaData& b0, ResScalar* res) {
+EIGEN_ALWAYS_INLINE void pstoreu_pmadd_complex(const PResPacket& c0, AlphaData& b0, ResScalar* res) {
   PResPacket c2 = pcplxflipconj(c0);
-  if (GEMV_IS_SCALAR) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_SCALAR) {
     ScalarPacket c4 = ploadu<ScalarPacket>(reinterpret_cast<Scalar*>(res));
     ScalarPacket c3 = pmadd_complex<ScalarPacket, AlphaData>(c0.v, c2.v, c4, b0);
     pstoreu(reinterpret_cast<Scalar*>(res), c3);
@@ -1372,7 +1378,8 @@
 
 template <typename ScalarPacket, typename PResPacket, typename ResPacket, typename ResScalar, typename AlphaData,
           Index ResPacketSize, Index iter2>
-EIGEN_ALWAYS_INLINE void pstoreu_pmadd_complex(PResPacket& c0, PResPacket& c1, AlphaData& b0, ResScalar* res) {
+EIGEN_ALWAYS_INLINE void pstoreu_pmadd_complex(const PResPacket& c0, const PResPacket& c1, AlphaData& b0,
+                                               ResScalar* res) {
   PResPacket c2 = pcplxflipconj(c0);
   PResPacket c3 = pcplxflipconj(c1);
 #if !defined(_ARCH_PWR10)
@@ -1391,7 +1398,7 @@
   c6[1] = PResPacket(pmadd_complex<ScalarPacket, AlphaData>(c1.v, c3.v, c6[1].v, b0));
   GEMV_BUILDPAIR_MMA(a, c6[0].v, c6[1].v);
 #else
-  if (GEMV_IS_COMPLEX_FLOAT) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {
     __asm__("xvmaddasp %L0,%x1,%x2\n\txvmaddasp %0,%x1,%x3" : "+&d"(a) : "wa"(b0.separate.r.v), "wa"(c0.v), "wa"(c1.v));
     __asm__("xvmaddasp %L0,%x1,%x2\n\txvmaddasp %0,%x1,%x3" : "+&d"(a) : "wa"(b0.separate.i.v), "wa"(c2.v), "wa"(c3.v));
   } else {
@@ -1406,7 +1413,7 @@
 /** \internal load lhs packet */
 template <typename Scalar, typename LhsScalar, typename LhsMapper, typename LhsPacket>
 EIGEN_ALWAYS_INLINE LhsPacket loadLhsPacket(LhsMapper& lhs, Index i, Index j) {
-  if (sizeof(Scalar) == sizeof(LhsScalar)) {
+  EIGEN_IF_CONSTEXPR (sizeof(Scalar) == sizeof(LhsScalar)) {
     const LhsScalar& src = lhs(i + 0, j);
     return LhsPacket(pload_real_full(const_cast<LhsScalar*>(&src)));
   }
@@ -1415,10 +1422,10 @@
 
 /** \internal madd for complex times complex */
 template <typename ComplexPacket, typename RealPacket, bool ConjugateLhs, bool ConjugateRhs, bool Negate>
-EIGEN_ALWAYS_INLINE RealPacket pmadd_complex_complex(RealPacket& a, RealPacket& b, RealPacket& c) {
-  if (ConjugateLhs && ConjugateRhs) {
+EIGEN_ALWAYS_INLINE RealPacket pmadd_complex_complex(const RealPacket& a, const RealPacket& b, const RealPacket& c) {
+  EIGEN_IF_CONSTEXPR (ConjugateLhs && ConjugateRhs) {
     return vec_madd(a, pconj2(ComplexPacket(b)).v, c);
-  } else if (Negate && !ConjugateLhs && ConjugateRhs) {
+  } else EIGEN_IF_CONSTEXPR (Negate && !ConjugateLhs && ConjugateRhs) {
     return vec_nmsub(a, b, c);
   } else {
     return vec_madd(a, b, c);
@@ -1427,8 +1434,8 @@
 
 /** \internal madd for complex times real */
 template <typename ComplexPacket, typename RealPacket, bool Conjugate>
-EIGEN_ALWAYS_INLINE RealPacket pmadd_complex_real(RealPacket& a, RealPacket& b, RealPacket& c) {
-  if (Conjugate) {
+EIGEN_ALWAYS_INLINE RealPacket pmadd_complex_real(const RealPacket& a, const RealPacket& b, const RealPacket& c) {
+  EIGEN_IF_CONSTEXPR (Conjugate) {
     return vec_madd(a, pconj2(ComplexPacket(b)).v, c);
   } else {
     return vec_madd(a, b, c);
@@ -1437,10 +1444,10 @@
 
 template <typename LhsPacket, typename RhsScalar, typename RhsPacket, typename PResPacket, bool ConjugateLhs,
           bool ConjugateRhs, int StorageOrder>
-EIGEN_ALWAYS_INLINE void gemv_mult_generic(LhsPacket& a0, RhsScalar* b, PResPacket& c0) {
+EIGEN_ALWAYS_INLINE void gemv_mult_generic(const LhsPacket& a0, RhsScalar* b, PResPacket& c0) {
   conj_helper<LhsPacket, RhsPacket, ConjugateLhs, ConjugateRhs> pcj;
   RhsPacket b0;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     b0 = pset1<RhsPacket>(*b);
   } else {
     b0 = ploadu<RhsPacket>(b);
@@ -1453,12 +1460,12 @@
           typename ResPacket, bool ConjugateLhs, bool ConjugateRhs, int StorageOrder>
 EIGEN_ALWAYS_INLINE void gemv_mult_complex_complex(LhsPacket& a0, RhsScalar* b, PResPacket& c0, ResPacket& c1) {
   ScalarPacket br, bi;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     pload_realimag<RhsScalar>(b, br, bi);
   } else {
     pload_realimag_row<RhsScalar>(b, br, bi);
   }
-  if (ConjugateLhs && !ConjugateRhs) a0 = pconj2(a0);
+  EIGEN_IF_CONSTEXPR (ConjugateLhs && !ConjugateRhs) a0 = pconj2(a0);
   LhsPacket a1 = pcplxflipconj(a0);
   ScalarPacket cr = pmadd_complex_complex<LhsPacket, ScalarPacket, ConjugateLhs, ConjugateRhs, false>(a0.v, br, c0.v);
   ScalarPacket ci = pmadd_complex_complex<LhsPacket, ScalarPacket, ConjugateLhs, ConjugateRhs, true>(a1.v, bi, c1.v);
@@ -1469,9 +1476,9 @@
 /** \internal core multiply operation for vectors - real times complex */
 template <typename ScalarPacket, typename LhsPacket, typename RhsScalar, typename RhsPacket, typename PResPacket,
           typename ResPacket, bool ConjugateLhs, bool ConjugateRhs, int StorageOrder>
-EIGEN_ALWAYS_INLINE void gemv_mult_real_complex(LhsPacket& a0, RhsScalar* b, PResPacket& c0) {
+EIGEN_ALWAYS_INLINE void gemv_mult_real_complex(const LhsPacket& a0, RhsScalar* b, PResPacket& c0) {
   ScalarPacket b0;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     b0 = pload_complex_full(b);
   } else {
     b0 = pload_complex_full_row(b);
@@ -1486,7 +1493,7 @@
 EIGEN_ALWAYS_INLINE void gemv_mult_complex_real(LhsPacket& a0, RhsScalar* b, PResPacket& c0) {
   ScalarPacket a1 = pload_complex<ResPacket>(&a0);
   ScalarPacket b0;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     b0 = pload_real(b);
   } else {
     b0 = pload_real_row<ResPacket>(b);
@@ -1539,9 +1546,9 @@
   return a;
 }
 
-EIGEN_ALWAYS_INLINE Packet4f convertReal(Packet2cf a) { return a.v; }
+EIGEN_ALWAYS_INLINE Packet4f convertReal(const Packet2cf& a) { return a.v; }
 
-EIGEN_ALWAYS_INLINE Packet2d convertReal(Packet1cd a) { return a.v; }
+EIGEN_ALWAYS_INLINE Packet2d convertReal(const Packet1cd& a) { return a.v; }
 
 /** \internal convert packet to complex form */
 template <typename T>
@@ -1549,9 +1556,9 @@
   return a;
 }
 
-EIGEN_ALWAYS_INLINE Packet2cf convertComplex(Packet4f a) { return Packet2cf(a); }
+EIGEN_ALWAYS_INLINE Packet2cf convertComplex(const Packet4f& a) { return Packet2cf(a); }
 
-EIGEN_ALWAYS_INLINE Packet1cd convertComplex(Packet2d a) { return Packet1cd(a); }
+EIGEN_ALWAYS_INLINE Packet1cd convertComplex(const Packet2d& a) { return Packet1cd(a); }
 
 /** \internal load a vector from a complex location (for MMA version) */
 template <typename ScalarPacket, typename LhsPacket, typename SLhsPacket, typename ResPacket>
@@ -1566,8 +1573,8 @@
 
 /** \internal perform a matrix multiply and accumulate (positive and negative) of packet a and packet b */
 template <typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
-EIGEN_ALWAYS_INLINE void pger_vecMMA(__vector_quad* acc, RhsPacket& a, LhsPacket& b) {
-  if (NegativeAccumulate) {
+EIGEN_ALWAYS_INLINE void pger_vecMMA(__vector_quad* acc, const RhsPacket& a, const LhsPacket& b) {
+  EIGEN_IF_CONSTEXPR (NegativeAccumulate) {
     __builtin_mma_xvf32gernp(acc, (__vector unsigned char)a, (__vector unsigned char)b);
   } else {
     __builtin_mma_xvf32gerpp(acc, (__vector unsigned char)a, (__vector unsigned char)b);
@@ -1576,8 +1583,8 @@
 
 /** \internal perform a matrix multiply and accumulate (positive and negative) of vector_pair a and packet b */
 template <typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
-EIGEN_ALWAYS_INLINE void pger_vecMMA(__vector_quad* acc, __vector_pair& a, Packet2d& b) {
-  if (NegativeAccumulate) {
+EIGEN_ALWAYS_INLINE void pger_vecMMA(__vector_quad* acc, __vector_pair& a, const Packet2d& b) {
+  EIGEN_IF_CONSTEXPR (NegativeAccumulate) {
     __builtin_mma_xvf64gernp(acc, (__vector_pair)a, (__vector unsigned char)b);
   } else {
     __builtin_mma_xvf64gerpp(acc, (__vector_pair)a, (__vector unsigned char)b);
@@ -1585,17 +1592,17 @@
 }
 
 template <typename LhsPacket, typename RhsPacket, bool NegativeAccumulate>
-EIGEN_ALWAYS_INLINE void pger_vecMMA(__vector_quad*, __vector_pair&, Packet4f&) {
+EIGEN_ALWAYS_INLINE void pger_vecMMA(__vector_quad*, __vector_pair&, const Packet4f&) {
   // Just for compilation
 }
 
 /** \internal madd for complex times complex (MMA version) */
 template <typename RealPacket, typename LhsPacket, bool ConjugateLhs, bool ConjugateRhs, bool Negate>
-EIGEN_ALWAYS_INLINE void pmadd_complex_complex_MMA(LhsPacket& a, RealPacket& b, __vector_quad* c) {
-  if (ConjugateLhs && ConjugateRhs) {
+EIGEN_ALWAYS_INLINE void pmadd_complex_complex_MMA(const LhsPacket& a, const RealPacket& b, __vector_quad* c) {
+  EIGEN_IF_CONSTEXPR (ConjugateLhs && ConjugateRhs) {
     RealPacket b2 = pconj2(convertComplex(b)).v;
     return pger_vecMMA<RealPacket, RealPacket, false>(c, b2, a.v);
-  } else if (Negate && !ConjugateLhs && ConjugateRhs) {
+  } else EIGEN_IF_CONSTEXPR (Negate && !ConjugateLhs && ConjugateRhs) {
     return pger_vecMMA<RealPacket, RealPacket, true>(c, b, a.v);
   } else {
     return pger_vecMMA<RealPacket, RealPacket, false>(c, b, a.v);
@@ -1603,11 +1610,11 @@
 }
 
 template <typename RealPacket, typename LhsPacket, bool ConjugateLhs, bool ConjugateRhs, bool Negate>
-EIGEN_ALWAYS_INLINE void pmadd_complex_complex_MMA(__vector_pair& a, RealPacket& b, __vector_quad* c) {
-  if (ConjugateLhs && ConjugateRhs) {
+EIGEN_ALWAYS_INLINE void pmadd_complex_complex_MMA(__vector_pair& a, const RealPacket& b, __vector_quad* c) {
+  EIGEN_IF_CONSTEXPR (ConjugateLhs && ConjugateRhs) {
     RealPacket b2 = pconj2(convertComplex(b)).v;
     return pger_vecMMA<RealPacket, __vector_pair, false>(c, a, b2);
-  } else if (Negate && !ConjugateLhs && ConjugateRhs) {
+  } else EIGEN_IF_CONSTEXPR (Negate && !ConjugateLhs && ConjugateRhs) {
     return pger_vecMMA<RealPacket, __vector_pair, true>(c, a, b);
   } else {
     return pger_vecMMA<RealPacket, __vector_pair, false>(c, a, b);
@@ -1616,17 +1623,17 @@
 
 /** \internal madd for complex times real (MMA version) */
 template <typename RealPacket, typename LhsPacket, bool Conjugate, int StorageOrder>
-EIGEN_ALWAYS_INLINE void pmadd_complex_real_MMA(LhsPacket& a, RealPacket& b, __vector_quad* c) {
+EIGEN_ALWAYS_INLINE void pmadd_complex_real_MMA(const LhsPacket& a, const RealPacket& b, __vector_quad* c) {
   RealPacket a2 = convertReal(a);
-  if (Conjugate) {
+  EIGEN_IF_CONSTEXPR (Conjugate) {
     RealPacket b2 = pconj2(convertComplex(b)).v;
-    if (StorageOrder == ColMajor) {
+    EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
       return pger_vecMMA<RealPacket, RealPacket, false>(c, b2, a2);
     } else {
       return pger_vecMMA<RealPacket, RealPacket, false>(c, a2, b2);
     }
   } else {
-    if (StorageOrder == ColMajor) {
+    EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
       return pger_vecMMA<RealPacket, RealPacket, false>(c, b, a2);
     } else {
       return pger_vecMMA<RealPacket, RealPacket, false>(c, a2, b);
@@ -1636,8 +1643,8 @@
 
 /** \internal madd for real times complex (MMA version) */
 template <typename RealPacket, typename LhsPacket, bool Conjugate, int StorageOrder>
-EIGEN_ALWAYS_INLINE void pmadd_complex_real_MMA(__vector_pair& a, RealPacket& b, __vector_quad* c) {
-  if (Conjugate) {
+EIGEN_ALWAYS_INLINE void pmadd_complex_real_MMA(__vector_pair& a, const RealPacket& b, __vector_quad* c) {
+  EIGEN_IF_CONSTEXPR (Conjugate) {
     RealPacket b2 = pconj2(convertComplex(b)).v;
     return pger_vecMMA<RealPacket, __vector_pair, false>(c, a, b2);
   } else {
@@ -1650,7 +1657,7 @@
           bool ConjugateLhs, bool ConjugateRhs, int StorageOrder>
 EIGEN_ALWAYS_INLINE void gemv_mult_complex_complex_MMA(SLhsPacket& a0, RhsScalar* b, __vector_quad* c0) {
   ScalarPacket b0;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     b0 = pload_realimag_combine(b);
   } else {
     b0 = pload_realimag_combine_row(b);
@@ -1664,7 +1671,7 @@
 EIGEN_ALWAYS_INLINE void gemv_mult_complex_real_MMA(SLhsPacket& a0, RhsScalar* b, __vector_quad* c0) {
   pload_complex_MMA<ScalarPacket, LhsPacket, SLhsPacket, ResPacket>(a0);
   ScalarPacket b0;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     b0 = pload_real(b);
   } else {
     b0 = pload_real_row<ResPacket>(b);
@@ -1677,7 +1684,7 @@
           bool ConjugateLhs, bool ConjugateRhs, int StorageOrder>
 EIGEN_ALWAYS_INLINE void gemv_mult_real_complex_MMA(SLhsPacket& a0, RhsScalar* b, __vector_quad* c0) {
   ScalarPacket b0;
-  if (StorageOrder == ColMajor) {
+  EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
     b0 = pload_complex_full(b);
   } else {
     b0 = pload_complex_full_row(b);
@@ -1702,7 +1709,7 @@
 template <typename ScalarPacket, typename LhsScalar, typename LhsPacket, typename SLhsPacket, typename RhsScalar,
           typename RhsPacket, typename ResPacket, bool ConjugateLhs, bool ConjugateRhs, int StorageOrder>
 EIGEN_ALWAYS_INLINE void gemv_mult_complex_MMA(__vector_pair& a0, std::complex<double>* b, __vector_quad* c0) {
-  if (sizeof(LhsScalar) == 16) {
+  EIGEN_IF_CONSTEXPR (sizeof(LhsScalar) == 16) {
     gemv_mult_complex_complex_MMA<ScalarPacket, LhsPacket, SLhsPacket, RhsScalar, ResPacket, ConjugateLhs, ConjugateRhs,
                                   StorageOrder>(a0, b, c0);
   } else {
@@ -1740,8 +1747,8 @@
           bool ConjugateRhs>
 EIGEN_ALWAYS_INLINE void disassembleResults2(__vector_quad* c0, PacketBlock<ScalarPacket, 4>& result0) {
   __builtin_mma_disassemble_acc(&result0.packet, c0);
-  if (sizeof(LhsPacket) == 16) {
-    if (sizeof(RhsPacket) == 16) {
+  EIGEN_IF_CONSTEXPR (sizeof(LhsPacket) == 16) {
+    EIGEN_IF_CONSTEXPR (sizeof(RhsPacket) == 16) {
       ScalarPacket tmp0, tmp2;
       tmp2 = vec_mergeh(result0.packet[2], result0.packet[3]);
       tmp0 = vec_mergeh(result0.packet[0], result0.packet[1]);
@@ -1750,10 +1757,10 @@
       result0.packet[2] = tmp2;
       result0.packet[0] = tmp0;
 
-      if (ConjugateLhs) {
+      EIGEN_IF_CONSTEXPR (ConjugateLhs) {
         result0.packet[0] = pconj2(convertComplex(result0.packet[0])).v;
         result0.packet[2] = pconj2(convertComplex(result0.packet[2])).v;
-      } else if (ConjugateRhs) {
+      } else EIGEN_IF_CONSTEXPR (ConjugateRhs) {
         result0.packet[1] = pconj2(convertComplex(result0.packet[1])).v;
         result0.packet[3] = pconj2(convertComplex(result0.packet[3])).v;
       } else {
@@ -1773,20 +1780,20 @@
           bool ConjugateRhs>
 EIGEN_ALWAYS_INLINE void disassembleResults4(__vector_quad* c0, PacketBlock<ScalarPacket, 4>& result0) {
   __builtin_mma_disassemble_acc(&result0.packet, c0);
-  if (GEMV_IS_COMPLEX_COMPLEX) {
-    if (ConjugateLhs) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {
+    EIGEN_IF_CONSTEXPR (ConjugateLhs) {
       result0.packet[0] = pconj2(convertComplex(result0.packet[0])).v;
       result0.packet[1] = pcplxflip2(convertComplex(result0.packet[1])).v;
     } else {
-      if (ConjugateRhs) {
+      EIGEN_IF_CONSTEXPR (ConjugateRhs) {
         result0.packet[1] = pcplxconjflip(convertComplex(result0.packet[1])).v;
       } else {
         result0.packet[1] = pcplxflipconj(convertComplex(result0.packet[1])).v;
       }
     }
     result0.packet[0] = vec_add(result0.packet[0], result0.packet[1]);
-  } else if (sizeof(LhsPacket) == sizeof(std::complex<float>)) {
-    if (ConjugateLhs) {
+  } else EIGEN_IF_CONSTEXPR (sizeof(LhsPacket) == sizeof(std::complex<float>)) {
+    EIGEN_IF_CONSTEXPR (ConjugateLhs) {
       result0.packet[0] = pconj2(convertComplex(result0.packet[0])).v;
     }
   } else {
@@ -1797,7 +1804,7 @@
 template <typename Scalar, typename ScalarPacket, int ResPacketSize, typename LhsPacket, typename RhsPacket,
           bool ConjugateLhs, bool ConjugateRhs>
 EIGEN_ALWAYS_INLINE void disassembleResults(__vector_quad* c0, PacketBlock<ScalarPacket, 4>& result0) {
-  if (!GEMV_IS_COMPLEX_FLOAT) {
+  EIGEN_IF_CONSTEXPR (!GEMV_IS_COMPLEX_FLOAT) {
     disassembleResults2<Scalar, ScalarPacket, LhsPacket, RhsPacket, ConjugateLhs, ConjugateRhs>(c0, result0);
   } else {
     disassembleResults4<Scalar, ScalarPacket, LhsPacket, RhsPacket, ConjugateLhs, ConjugateRhs>(c0, result0);
@@ -1813,9 +1820,9 @@
 #define GEMV_LOADPACKET_COL_COMPLEX_DATA(iter) convertReal(GEMV_LOADPACKET_COL_COMPLEX(iter))
 
 #ifdef USE_GEMV_MMA
-#define GEMV_INIT_COL_COMPLEX_MMA(iter, N) \
-  if (GEMV_GETN_COMPLEX(N) > iter) {       \
-    __builtin_mma_xxsetaccz(&e0##iter);    \
+#define GEMV_INIT_COL_COMPLEX_MMA(iter, N)           \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter) { \
+    __builtin_mma_xxsetaccz(&e0##iter);              \
   }
 
 #if EIGEN_COMP_LLVM
@@ -1825,7 +1832,7 @@
   EIGEN_UNUSED_VARIABLE(f##iter1);
 #else
 #define GEMV_LOADPAIR_COL_COMPLEX_MMA(iter1, iter2)                                                         \
-  if (sizeof(LhsPacket) == 16) {                                                                            \
+  EIGEN_IF_CONSTEXPR (sizeof(LhsPacket) == 16) {                                                            \
     const LhsScalar& src = lhs(i + ((32 * iter1) / sizeof(LhsScalar)), j);                                  \
     a##iter1 = *reinterpret_cast<__vector_pair*>(const_cast<LhsScalar*>(&src));                             \
     EIGEN_UNUSED_VARIABLE(f##iter1);                                                                        \
@@ -1836,8 +1843,8 @@
 #endif
 
 #define GEMV_LOAD1_COL_COMPLEX_MMA(iter, N)          \
-  if (GEMV_GETN_COMPLEX(N) > iter) {                 \
-    if (GEMV_IS_COMPLEX_FLOAT) {                     \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter) { \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {     \
       f##iter = GEMV_LOADPACKET_COL_COMPLEX(iter);   \
       EIGEN_UNUSED_VARIABLE(a##iter);                \
     } else {                                         \
@@ -1849,8 +1856,8 @@
   }
 
 #define GEMV_WORK1_COL_COMPLEX_MMA(iter, N)                                                                      \
-  if (GEMV_GETN_COMPLEX(N) > iter) {                                                                             \
-    if (GEMV_IS_COMPLEX_FLOAT) {                                                                                 \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter) {                                                             \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {                                                                 \
       gemv_mult_complex_MMA<ScalarPacket, LhsScalar, PLhsPacket, PLhsPacket, RhsScalar, RhsPacket, ResPacket,    \
                             ConjugateLhs, ConjugateRhs, ColMajor>(f##iter, b, &e0##iter);                        \
     } else {                                                                                                     \
@@ -1863,10 +1870,10 @@
   GEMV_BUILDPAIR_MMA(a##iter1, GEMV_LOADPACKET_COL_COMPLEX_DATA(iter2), GEMV_LOADPACKET_COL_COMPLEX_DATA((iter2) + 1));
 
 #define GEMV_LOAD2_COL_COMPLEX_MMA(iter1, iter2, iter3, N) \
-  if (GEMV_GETN_COMPLEX(N) > iter1) {                      \
-    if (GEMV_IS_COMPLEX_FLOAT) {                           \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter1) {      \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {           \
       GEMV_LOADPAIR2_COL_COMPLEX_MMA(iter2, iter2);        \
-      EIGEN_UNUSED_VARIABLE(a##iter3)                      \
+      EIGEN_UNUSED_VARIABLE(a##iter3);                     \
     } else {                                               \
       GEMV_LOADPAIR2_COL_COMPLEX_MMA(iter2, iter2 << 1);   \
       GEMV_LOADPAIR2_COL_COMPLEX_MMA(iter3, iter3 << 1);   \
@@ -1879,8 +1886,8 @@
   EIGEN_UNUSED_VARIABLE(f##iter3);
 
 #define GEMV_WORK2_COL_COMPLEX_MMA(iter1, iter2, iter3, N)                                                       \
-  if (GEMV_GETN_COMPLEX(N) > iter1) {                                                                            \
-    if (GEMV_IS_COMPLEX_FLOAT) {                                                                                 \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter1) {                                                            \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {                                                                 \
       PLhsPacket g[2];                                                                                           \
       __builtin_vsx_disassemble_pair(reinterpret_cast<void*>(g), &a##iter2);                                     \
       gemv_mult_complex_MMA<ScalarPacket, LhsScalar, PLhsPacket, PLhsPacket, RhsScalar, RhsPacket, ResPacket,    \
@@ -1897,14 +1904,14 @@
 
 #if EIGEN_COMP_LLVM
 #define GEMV_LOAD_COL_COMPLEX_MMA(N)                       \
-  if (GEMV_GETN_COMPLEX(N) > 1) {                          \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > 1) {          \
     GEMV_UNROLL_HALF(GEMV_LOAD2_COL_COMPLEX_MMA, (N >> 1)) \
   } else {                                                 \
     GEMV_UNROLL(GEMV_LOAD1_COL_COMPLEX_MMA, N)             \
   }
 
 #define GEMV_WORK_COL_COMPLEX_MMA(N)                       \
-  if (GEMV_GETN_COMPLEX(N) > 1) {                          \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > 1) {          \
     GEMV_UNROLL_HALF(GEMV_WORK2_COL_COMPLEX_MMA, (N >> 1)) \
   } else {                                                 \
     GEMV_UNROLL(GEMV_WORK1_COL_COMPLEX_MMA, N)             \
@@ -1920,10 +1927,10 @@
       &e0##iter, result0##iter);
 
 #define GEMV_STORE_COL_COMPLEX_MMA(iter, N)                                                     \
-  if (GEMV_GETN_COMPLEX(N) > iter) {                                                            \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter) {                                            \
     GEMV_DISASSEMBLE_COMPLEX_MMA(iter);                                                         \
     c0##iter = PResPacket(result0##iter.packet[0]);                                             \
-    if (GEMV_IS_COMPLEX_FLOAT) {                                                                \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {                                                \
       pstoreu_pmadd_complex<Scalar, ScalarPacket, PResPacket, ResPacket, ResScalar, AlphaData>( \
           c0##iter, alpha_data, res + i + (iter * ResPacketSize));                              \
     } else {                                                                                    \
@@ -1936,11 +1943,11 @@
   }
 
 #define GEMV_STORE2_COL_COMPLEX_MMA(iter1, iter2, iter3, N)                                                        \
-  if (GEMV_GETN_COMPLEX(N) > iter1) {                                                                              \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter1) {                                                              \
     GEMV_DISASSEMBLE_COMPLEX_MMA(iter2);                                                                           \
     GEMV_DISASSEMBLE_COMPLEX_MMA(iter3);                                                                           \
     c0##iter2 = PResPacket(result0##iter2.packet[0]);                                                              \
-    if (GEMV_IS_COMPLEX_FLOAT) {                                                                                   \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {                                                                   \
       c0##iter3 = PResPacket(result0##iter3.packet[0]);                                                            \
       pstoreu_pmadd_complex<ScalarPacket, PResPacket, ResPacket, ResScalar, AlphaData, ResPacketSize, iter2>(      \
           c0##iter2, c0##iter3, alpha_data, res + i);                                                              \
@@ -1965,7 +1972,7 @@
     GEMV_LOAD_COL_COMPLEX_MMA(N)                            \
     GEMV_WORK_COL_COMPLEX_MMA(N)                            \
   } while (++j < jend);                                     \
-  if (GEMV_GETN(N) <= 2) {                                  \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) <= 2) {                  \
     GEMV_UNROLL(GEMV_STORE_COL_COMPLEX_MMA, N)              \
   } else {                                                  \
     GEMV_UNROLL_HALF(GEMV_STORE2_COL_COMPLEX_MMA, (N >> 1)) \
@@ -1974,7 +1981,7 @@
 #endif
 
 #define GEMV_INIT_COMPLEX(iter, N)                                   \
-  if (N > iter) {                                                    \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                    \
     c0##iter = pset_zero<PResPacket>();                              \
     c1##iter = pset_init<ResPacket, LhsPacket, RhsPacket>(c1##iter); \
   } else {                                                           \
@@ -1983,7 +1990,7 @@
   }
 
 #define GEMV_WORK_COL_COMPLEX(iter, N)                                                                     \
-  if (N > iter) {                                                                                          \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                                                          \
     f##iter = GEMV_LOADPACKET_COL_COMPLEX(iter);                                                           \
     gemv_mult_complex<ScalarPacket, PLhsPacket, RhsScalar, RhsPacket, PResPacket, ResPacket, ConjugateLhs, \
                       ConjugateRhs, ColMajor>(f##iter, b, c0##iter, c1##iter);                             \
@@ -1992,8 +1999,8 @@
   }
 
 #define GEMV_STORE_COL_COMPLEX(iter, N)                                                       \
-  if (N > iter) {                                                                             \
-    if (GEMV_IS_COMPLEX_COMPLEX) {                                                            \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                                             \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {                                            \
       c0##iter = padd(c0##iter, c1##iter);                                                    \
     }                                                                                         \
     pstoreu_pmadd_complex<Scalar, ScalarPacket, PResPacket, ResPacket, ResScalar, AlphaData>( \
@@ -2021,11 +2028,11 @@
 #define GEMV_PROCESS_COL_COMPLEX(N) GEMV_PROCESS_COL_COMPLEX_ONE_MMA(N)
 #else
 #if defined(USE_GEMV_MMA) && (__GNUC__ > 10)
-#define GEMV_PROCESS_COL_COMPLEX(N)          \
-  if (sizeof(Scalar) != sizeof(LhsPacket)) { \
-    GEMV_PROCESS_COL_COMPLEX_ONE_MMA(N)      \
-  } else {                                   \
-    GEMV_PROCESS_COL_COMPLEX_ONE(N)          \
+#define GEMV_PROCESS_COL_COMPLEX(N)                          \
+  EIGEN_IF_CONSTEXPR (sizeof(Scalar) != sizeof(LhsPacket)) { \
+    GEMV_PROCESS_COL_COMPLEX_ONE_MMA(N)                      \
+  } else {                                                   \
+    GEMV_PROCESS_COL_COMPLEX_ONE(N)                          \
   }
 #else
 #define GEMV_PROCESS_COL_COMPLEX(N) GEMV_PROCESS_COL_COMPLEX_ONE(N)
@@ -2058,7 +2065,8 @@
   conj_helper<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs> cj;
 
   const Index lhsStride = lhs.stride();
-  // TODO: for padded aligned inputs, we could enable aligned reads
+  // LhsAlignment stays Unaligned; enabling aligned reads would require
+  // propagating the Mapper's Alignment through the run() template.
   enum {
     LhsAlignment = Unaligned,
     ResPacketSize = PTraits::ResPacketSize,
@@ -2097,7 +2105,7 @@
     GEMV_UNUSED(8, a)
     GEMV_UNUSED(8, f)
 #if !defined(GCC_ONE_VECTORPAIR_BUG) && defined(USE_GEMV_COL_COMPLEX_MMA)
-    if (GEMV_IS_COMPLEX_COMPLEX || !GEMV_IS_COMPLEX_FLOAT)
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX || !GEMV_IS_COMPLEX_FLOAT)
 #endif
 #endif
 #ifndef GCC_ONE_VECTORPAIR_BUG
@@ -2167,30 +2175,30 @@
 /** \internal add complex results together */
 template <typename LhsPacket, typename RhsPacket, bool ConjugateLhs, bool ConjugateRhs>
 EIGEN_ALWAYS_INLINE ScalarBlock<std::complex<float>, 2> addComplexResults(PacketBlock<Packet4f, 4>& result0,
-                                                                          PacketBlock<Packet4f, 4>& result1) {
+                                                                          const PacketBlock<Packet4f, 4>& result1) {
   ScalarBlock<std::complex<float>, 2> cc0;
   result0.packet[0] = reinterpret_cast<Packet4f>(
       vec_mergeh(reinterpret_cast<Packet2d>(result0.packet[0]), reinterpret_cast<Packet2d>(result1.packet[0])));
   result0.packet[2] = reinterpret_cast<Packet4f>(
       vec_mergel(reinterpret_cast<Packet2d>(result0.packet[2]), reinterpret_cast<Packet2d>(result1.packet[2])));
   result0.packet[0] = vec_add(result0.packet[0], result0.packet[2]);
-  if (GEMV_IS_COMPLEX_COMPLEX) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {
     result0.packet[1] = reinterpret_cast<Packet4f>(
         vec_mergeh(reinterpret_cast<Packet2d>(result0.packet[1]), reinterpret_cast<Packet2d>(result1.packet[1])));
     result0.packet[3] = reinterpret_cast<Packet4f>(
         vec_mergel(reinterpret_cast<Packet2d>(result0.packet[3]), reinterpret_cast<Packet2d>(result1.packet[3])));
     result0.packet[1] = vec_add(result0.packet[1], result0.packet[3]);
-    if (ConjugateLhs) {
+    EIGEN_IF_CONSTEXPR (ConjugateLhs) {
       result0.packet[0] = pconj2(convertComplex(result0.packet[0])).v;
       result0.packet[1] = pcplxflip2(convertComplex(result0.packet[1])).v;
-    } else if (ConjugateRhs) {
+    } else EIGEN_IF_CONSTEXPR (ConjugateRhs) {
       result0.packet[1] = pcplxconjflip(convertComplex(result0.packet[1])).v;
     } else {
       result0.packet[1] = pcplxflipconj(convertComplex(result0.packet[1])).v;
     }
     result0.packet[0] = vec_add(result0.packet[0], result0.packet[1]);
   } else {
-    if (ConjugateLhs && (sizeof(LhsPacket) == sizeof(std::complex<float>))) {
+    EIGEN_IF_CONSTEXPR (ConjugateLhs && (sizeof(LhsPacket) == sizeof(std::complex<float>))) {
       result0.packet[0] = pconj2(convertComplex(result0.packet[0])).v;
     }
   }
@@ -2203,7 +2211,7 @@
 
 template <typename LhsPacket, typename RhsPacket, bool ConjugateLhs, bool ConjugateRhs>
 EIGEN_ALWAYS_INLINE ScalarBlock<std::complex<double>, 2> addComplexResults(PacketBlock<Packet2d, 4>&,
-                                                                           PacketBlock<Packet2d, 4>&) {
+                                                                           const PacketBlock<Packet2d, 4>&) {
   ScalarBlock<std::complex<double>, 2> cc0;
   EIGEN_UNUSED_VARIABLE(cc0);
   return cc0;  // Just for compilation
@@ -2234,11 +2242,11 @@
   ScalarBlock<ResScalar, 2> cc0;
   PacketBlock<ResPacket, 4> result0;
   __builtin_mma_disassemble_acc(&result0.packet, acc0);
-  if (GEMV_IS_COMPLEX_COMPLEX) {
-    if (ConjugateLhs) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {
+    EIGEN_IF_CONSTEXPR (ConjugateLhs) {
       result0.packet[1] = pconjinv(convertComplex(result0.packet[1])).v;
       result0.packet[3] = pconjinv(convertComplex(result0.packet[3])).v;
-    } else if (ConjugateRhs) {
+    } else EIGEN_IF_CONSTEXPR (ConjugateRhs) {
       result0.packet[0] = pconj2(convertComplex(result0.packet[0])).v;
       result0.packet[2] = pconj2(convertComplex(result0.packet[2])).v;
     } else {
@@ -2260,7 +2268,7 @@
 #endif
 
 template <typename ResScalar, typename ResPacket>
-EIGEN_ALWAYS_INLINE ScalarBlock<ResScalar, 2> predux_real(ResPacket& a, ResPacket& b) {
+EIGEN_ALWAYS_INLINE ScalarBlock<ResScalar, 2> predux_real(const ResPacket& a, const ResPacket& b) {
   ScalarBlock<ResScalar, 2> cc0;
   cc0.scalar[0] = predux(a);
   cc0.scalar[1] = predux(b);
@@ -2268,7 +2276,7 @@
 }
 
 template <typename ResScalar, typename ResPacket>
-EIGEN_ALWAYS_INLINE ScalarBlock<ResScalar, 2> predux_complex(ResPacket& a, ResPacket& b) {
+EIGEN_ALWAYS_INLINE ScalarBlock<ResScalar, 2> predux_complex(const ResPacket& a, const ResPacket& b) {
   return predux_real<ResScalar, ResPacket>(a, b);
 }
 
@@ -2285,17 +2293,17 @@
 
 #define GEMV_UNUSED_ROW(N, which) GEMV_UNROLL3_ROW(GEMV_UNUSED_VAR, N, which)
 
-#define GEMV_INIT_ROW(iter, N)         \
-  if (GEMV_GETN(N) > iter) {           \
-    __builtin_mma_xxsetaccz(&c##iter); \
+#define GEMV_INIT_ROW(iter, N)               \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) { \
+    __builtin_mma_xxsetaccz(&c##iter);       \
   }
 
 #define GEMV_LOADPAIR_ROW(iter1, iter2) \
   GEMV_BUILDPAIR_MMA(b##iter1, GEMV_LOADPACKET_ROW(iter2), GEMV_LOADPACKET_ROW((iter2) + 1));
 
 #define GEMV_WORK_ROW(iter, N)                                                              \
-  if (GEMV_GETN(N) > iter) {                                                                \
-    if (GEMV_IS_FLOAT) {                                                                    \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN(N) > iter) {                                                \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                                                    \
       pger_vecMMA_acc<LhsPacket, RhsPacket, true>(&c##iter, a0, GEMV_LOADPACKET_ROW(iter)); \
     } else {                                                                                \
       __vector_pair b##iter;                                                                \
@@ -2305,8 +2313,8 @@
   }
 
 #define GEMV_PREDUX2(iter1, iter2, iter3, N)                               \
-  if (N > iter1) {                                                         \
-    if (GEMV_IS_FLOAT) {                                                   \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                                         \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_FLOAT) {                                   \
       cc##iter1 = predux_real<ResScalar, ResPacket>(&c##iter2, &c##iter3); \
     } else {                                                               \
       cc##iter1 = predux_real<ResScalar, ResPacket>(&c##iter1);            \
@@ -2316,19 +2324,19 @@
   }
 #else
 #define GEMV_INIT_ROW(iter, N)                \
-  if (N > iter) {                             \
+  EIGEN_IF_CONSTEXPR (N > iter) {             \
     c##iter = pset1<ResPacket>(ResScalar(0)); \
   } else {                                    \
     EIGEN_UNUSED_VARIABLE(c##iter);           \
   }
 
 #define GEMV_WORK_ROW(iter, N)                                   \
-  if (N > iter) {                                                \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                \
     c##iter = pcj.pmadd(GEMV_LOADPACKET_ROW(iter), a0, c##iter); \
   }
 
 #define GEMV_PREDUX2(iter1, iter2, iter3, N)                           \
-  if (N > iter1) {                                                     \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                                     \
     cc##iter1 = predux_real<ResScalar, ResPacket>(c##iter2, c##iter3); \
   } else {                                                             \
     EIGEN_UNUSED_VARIABLE(cc##iter1);                                  \
@@ -2336,13 +2344,13 @@
 #endif
 
 #define GEMV_MULT(iter1, iter2, iter3, N)                  \
-  if (N > iter1) {                                         \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                         \
     cc##iter1.scalar[0] += cj.pmul(lhs(i + iter2, j), a0); \
     cc##iter1.scalar[1] += cj.pmul(lhs(i + iter3, j), a0); \
   }
 
 #define GEMV_STORE_ROW(iter1, iter2, iter3, N)                                           \
-  if (N > iter1) {                                                                       \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                                                       \
     storeMaddData<ResScalar>(res + ((i + iter2) * resIncr), alpha, cc##iter1.scalar[0]); \
     storeMaddData<ResScalar>(res + ((i + iter3) * resIncr), alpha, cc##iter1.scalar[1]); \
   }
@@ -2390,7 +2398,8 @@
   const Index n2 = rows - 1;
 #endif
 
-  // TODO: for padded aligned inputs, we could enable aligned reads
+  // LhsAlignment stays Unaligned; enabling aligned reads would require
+  // propagating the Mapper's Alignment through the run() template.
   enum {
     LhsAlignment = Unaligned,
     ResPacketSize = Traits::ResPacketSize,
@@ -2436,6 +2445,7 @@
     EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(Index rows, Index cols, const LhsMapper& lhs,                  \
                                                         const RhsMapper& rhs, ResScalar* res, Index resIncr,           \
                                                         ResScalar alpha) {                                             \
+      if (numext::is_exactly_zero(alpha)) return;                                                                      \
       gemv_col<Scalar, LhsMapper, Scalar, RhsMapper, ResScalar>(rows, cols, lhs, rhs, res, resIncr, alpha);            \
     }                                                                                                                  \
   };
@@ -2449,6 +2459,7 @@
     EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(Index rows, Index cols, const LhsMapper& lhs,                  \
                                                         const RhsMapper& rhs, ResScalar* res, Index resIncr,           \
                                                         ResScalar alpha) {                                             \
+      if (numext::is_exactly_zero(alpha)) return;                                                                      \
       gemv_row<Scalar, LhsMapper, Scalar, RhsMapper, ResScalar>(rows, cols, lhs, rhs, res, resIncr, alpha);            \
     }                                                                                                                  \
   };
@@ -2473,6 +2484,7 @@
     EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(Index rows, Index cols, const LhsMapper& lhs,                  \
                                                         const RhsMapper& rhs, bfloat16* res, Index resIncr,            \
                                                         bfloat16 alpha) {                                              \
+      if (numext::is_exactly_zero(alpha)) return;                                                                      \
       gemv_bf16_col<LhsMapper, RhsMapper>(rows, cols, lhs, rhs, res, resIncr, alpha);                                  \
     }                                                                                                                  \
   };
@@ -2484,6 +2496,7 @@
     EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(Index rows, Index cols, const LhsMapper& lhs,                  \
                                                         const RhsMapper& rhs, bfloat16* res, Index resIncr,            \
                                                         bfloat16 alpha) {                                              \
+      if (numext::is_exactly_zero(alpha)) return;                                                                      \
       gemv_bf16_row<LhsMapper, RhsMapper>(rows, cols, lhs, rhs, res, resIncr, alpha);                                  \
     }                                                                                                                  \
   };
@@ -2492,9 +2505,9 @@
 EIGEN_POWER_GEMV_REAL_SPECIALIZE_ROW_BFLOAT16()
 
 template <typename ResScalar, typename PResPacket, typename ResPacket, typename LhsPacket, typename RhsPacket>
-EIGEN_ALWAYS_INLINE ScalarBlock<ResScalar, 2> predux_complex(PResPacket& a0, PResPacket& b0, ResPacket& a1,
-                                                             ResPacket& b1) {
-  if (GEMV_IS_COMPLEX_COMPLEX) {
+EIGEN_ALWAYS_INLINE ScalarBlock<ResScalar, 2> predux_complex(PResPacket& a0, PResPacket& b0, const ResPacket& a1,
+                                                             const ResPacket& b1) {
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {
     a0 = padd(a0, a1);
     b0 = padd(b0, b1);
   }
@@ -2521,17 +2534,17 @@
   GEMV_UNROLL_ROW_HALF(GEMV_STORE_ROW_COMPLEX, (N >> 1))
 
 #ifdef USE_GEMV_MMA
-#define GEMV_INIT_ROW_COMPLEX_MMA(iter, N) \
-  if (GEMV_GETN_COMPLEX(N) > iter) {       \
-    __builtin_mma_xxsetaccz(&e0##iter);    \
+#define GEMV_INIT_ROW_COMPLEX_MMA(iter, N)           \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter) { \
+    __builtin_mma_xxsetaccz(&e0##iter);              \
   }
 
 #define GEMV_LOADPAIR_ROW_COMPLEX_MMA(iter1, iter2) \
   GEMV_BUILDPAIR_MMA(a##iter1, GEMV_LOADPACKET_ROW_COMPLEX_DATA(iter2), GEMV_LOADPACKET_ROW_COMPLEX_DATA((iter2) + 1));
 
 #define GEMV_WORK_ROW_COMPLEX_MMA(iter, N)                                                                       \
-  if (GEMV_GETN_COMPLEX(N) > iter) {                                                                             \
-    if (GEMV_IS_COMPLEX_FLOAT) {                                                                                 \
+  EIGEN_IF_CONSTEXPR (GEMV_GETN_COMPLEX(N) > iter) {                                                             \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {                                                                 \
       PLhsPacket a##iter = GEMV_LOADPACKET_ROW_COMPLEX(iter);                                                    \
       gemv_mult_complex_MMA<ScalarPacket, LhsScalar, PLhsPacket, PLhsPacket, RhsScalar, RhsPacket, ResPacket,    \
                             ConjugateLhs, ConjugateRhs, RowMajor>(a##iter, b, &e0##iter);                        \
@@ -2544,8 +2557,8 @@
   }
 
 #define GEMV_PREDUX4_COMPLEX_MMA(iter1, iter2, iter3, N)                                                         \
-  if (N > iter1) {                                                                                               \
-    if (GEMV_IS_COMPLEX_FLOAT) {                                                                                 \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                                                                               \
+    EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_FLOAT) {                                                                 \
       cc##iter1 = predux_complex<ResScalar, ScalarPacket, LhsPacket, RhsPacket, ConjugateLhs, ConjugateRhs>(     \
           &e0##iter2, &e0##iter3);                                                                               \
     } else {                                                                                                     \
@@ -2569,14 +2582,14 @@
 #endif
 
 #define GEMV_WORK_ROW_COMPLEX(iter, N)                                                                     \
-  if (N > iter) {                                                                                          \
+  EIGEN_IF_CONSTEXPR (N > iter) {                                                                          \
     PLhsPacket a##iter = GEMV_LOADPACKET_ROW_COMPLEX(iter);                                                \
     gemv_mult_complex<ScalarPacket, PLhsPacket, RhsScalar, RhsPacket, PResPacket, ResPacket, ConjugateLhs, \
                       ConjugateRhs, RowMajor>(a##iter, b, c0##iter, c1##iter);                             \
   }
 
 #define GEMV_PREDUX4_COMPLEX(iter1, iter2, iter3, N)                                                          \
-  if (N > iter1) {                                                                                            \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                                                                            \
     cc##iter1 = predux_complex<ResScalar, PResPacket, ResPacket, LhsPacket, RhsPacket>(c0##iter2, c0##iter3,  \
                                                                                        c1##iter2, c1##iter3); \
   } else {                                                                                                    \
@@ -2584,13 +2597,13 @@
   }
 
 #define GEMV_MULT_COMPLEX(iter1, iter2, iter3, N)          \
-  if (N > iter1) {                                         \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                         \
     cc##iter1.scalar[0] += cj.pmul(lhs(i + iter2, j), b0); \
     cc##iter1.scalar[1] += cj.pmul(lhs(i + iter3, j), b0); \
   }
 
 #define GEMV_STORE_ROW_COMPLEX(iter1, iter2, iter3, N)                                   \
-  if (N > iter1) {                                                                       \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                                                       \
     storeMaddData<ResScalar>(res + ((i + iter2) * resIncr), alpha, cc##iter1.scalar[0]); \
     storeMaddData<ResScalar>(res + ((i + iter3) * resIncr), alpha, cc##iter1.scalar[1]); \
   }
@@ -2609,7 +2622,7 @@
   }
 
 #define GEMV_PROCESS_ROW_COMPLEX_PREDUX_NEW(iter) \
-  if (GEMV_IS_COMPLEX_COMPLEX) {                  \
+  EIGEN_IF_CONSTEXPR (GEMV_IS_COMPLEX_COMPLEX) {  \
     c0##iter = padd(c0##iter, c1##iter);          \
   }                                               \
   dd0 = predux(c0##iter);
@@ -2628,20 +2641,20 @@
 
 #define GEMV_INIT_COMPLEX_OLD(iter, N) \
   EIGEN_UNUSED_VARIABLE(c0##iter);     \
-  if (N > iter) {                      \
+  EIGEN_IF_CONSTEXPR (N > iter) {      \
     c1##iter = pset_zero<ResPacket>(); \
   } else {                             \
     EIGEN_UNUSED_VARIABLE(c1##iter);   \
   }
 
 #define GEMV_WORK_ROW_COMPLEX_OLD(iter, N)                     \
-  if (N > iter) {                                              \
+  EIGEN_IF_CONSTEXPR (N > iter) {                              \
     LhsPacket a##iter = GEMV_LOADPACKET_ROW_COMPLEX_OLD(iter); \
     c1##iter = pcj.pmadd(a##iter, b0, c1##iter);               \
   }
 
 #define GEMV_PREDUX4_COMPLEX_OLD(iter1, iter2, iter3, N) \
-  if (N > iter1) {                                       \
+  EIGEN_IF_CONSTEXPR (N > iter1) {                       \
     cc##iter1.scalar[0] = predux(c1##iter2);             \
     cc##iter1.scalar[1] = predux(c1##iter3);             \
   } else {                                               \
@@ -2733,7 +2746,8 @@
   const Index n2 = rows - 1;
 #endif
 
-  // TODO: for padded aligned inputs, we could enable aligned reads
+  // LhsAlignment stays Unaligned; enabling aligned reads would require
+  // propagating the Mapper's Alignment through the run() template.
   enum {
     LhsAlignment = Unaligned,
     ResPacketSize = PTraits::ResPacketSize,
@@ -2754,7 +2768,7 @@
 #ifndef GCC_ONE_VECTORPAIR_BUG
   ScalarBlock<ResScalar, 2> cc0, cc1, cc2, cc3;
 #ifdef USE_GEMV_MMA
-  if (!GEMV_IS_COMPLEX_COMPLEX)
+  EIGEN_IF_CONSTEXPR (!GEMV_IS_COMPLEX_COMPLEX)
 #endif
   {
     GEMV_PROCESS_ROW_COMPLEX(8)
@@ -2781,6 +2795,7 @@
     EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(Index rows, Index cols, const LhsMapper& lhs,                  \
                                                         const RhsMapper& rhs, ResScalar* res, Index resIncr,           \
                                                         ResScalar alpha) {                                             \
+      if (numext::is_exactly_zero(alpha)) return;                                                                      \
       gemv_complex_col<Scalar, LhsScalar, LhsMapper, ConjugateLhs, sizeof(Scalar) == sizeof(LhsScalar), RhsScalar,     \
                        RhsMapper, ConjugateRhs, sizeof(Scalar) == sizeof(RhsScalar), ResScalar>(rows, cols, lhs, rhs,  \
                                                                                                 res, resIncr, alpha);  \
@@ -2796,6 +2811,7 @@
     EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run(Index rows, Index cols, const LhsMapper& lhs,                  \
                                                         const RhsMapper& rhs, ResScalar* res, Index resIncr,           \
                                                         ResScalar alpha) {                                             \
+      if (numext::is_exactly_zero(alpha)) return;                                                                      \
       gemv_complex_row<Scalar, LhsScalar, LhsMapper, ConjugateLhs, sizeof(Scalar) == sizeof(LhsScalar), RhsScalar,     \
                        RhsMapper, ConjugateRhs, sizeof(Scalar) == sizeof(RhsScalar), ResScalar>(rows, cols, lhs, rhs,  \
                                                                                                 res, resIncr, alpha);  \
diff --git a/Eigen/src/Core/arch/AltiVec/PacketMath.h b/Eigen/src/Core/arch/AltiVec/PacketMath.h
index 8d5a351..fbf728c 100644
--- a/Eigen/src/Core/arch/AltiVec/PacketMath.h
+++ b/Eigen/src/Core/arch/AltiVec/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_ALTIVEC_H
 #define EIGEN_PACKET_MATH_ALTIVEC_H
@@ -1100,15 +1101,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) {
   return vec_madd(a, b, p4f_MZERO);
 }
@@ -1181,11 +1173,16 @@
   return vec_madd(a, b, c);
 }
 
-#ifdef EIGEN_VECTORIZE_VSX
 template <>
 EIGEN_STRONG_INLINE Packet4f pmsub(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
+#ifdef EIGEN_VECTORIZE_VSX
   return vec_msub(a, b, c);
+#else
+  return vec_madd(a, b, pnegate(c));
+#endif
 }
+
+#ifdef EIGEN_VECTORIZE_VSX
 template <>
 EIGEN_STRONG_INLINE Packet4f pnmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
   return vec_nmsub(a, b, c);
@@ -1892,18 +1889,10 @@
   return vec_abs(a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet16c pabs(const Packet16c& a) {
   return vec_abs(a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet8bf pabs(const Packet8bf& a) {
   EIGEN_DECLARE_CONST_FAST_Packet8us(abs_mask, 0x7FFF);
   return pand<Packet8us>(p8us_abs_mask, a);
@@ -1931,6 +1920,60 @@
   return vec_sl(a, reinterpret_cast<Packet4ui>(pset1<Packet4i>(N)));
 }
 template <int N>
+EIGEN_STRONG_INLINE Packet16c parithmetic_shift_right(const Packet16c& a) {
+  return vec_sra(a, pset1<Packet16uc>(static_cast<unsigned char>(N)));
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet16c plogical_shift_right(const Packet16c& a) {
+  return vec_sr(a, pset1<Packet16uc>(static_cast<unsigned char>(N)));
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet16c plogical_shift_left(const Packet16c& a) {
+  return vec_sl(a, pset1<Packet16uc>(static_cast<unsigned char>(N)));
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet16uc parithmetic_shift_right(const Packet16uc& a) {
+  return vec_sr(a, pset1<Packet16uc>(static_cast<unsigned char>(N)));
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet16uc plogical_shift_right(const Packet16uc& a) {
+  return vec_sr(a, pset1<Packet16uc>(static_cast<unsigned char>(N)));
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet16uc plogical_shift_left(const Packet16uc& a) {
+  return vec_sl(a, pset1<Packet16uc>(static_cast<unsigned char>(N)));
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(const Packet8s& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sra(a, p8us_mask);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet8s plogical_shift_right(const Packet8s& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sr(a, p8us_mask);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet8s plogical_shift_left(const Packet8s& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sl(a, p8us_mask);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet8us parithmetic_shift_right(const Packet8us& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sr(a, p8us_mask);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet8us plogical_shift_right(const Packet8us& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sr(a, p8us_mask);
+}
+template <int N>
+EIGEN_STRONG_INLINE Packet8us plogical_shift_left(const Packet8us& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
+  return vec_sl(a, p8us_mask);
+}
+template <int N>
 EIGEN_STRONG_INLINE Packet4f plogical_shift_left(const Packet4f& a) {
   const EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
   Packet4ui r = vec_sl(reinterpret_cast<Packet4ui>(a), p4ui_mask);
@@ -1945,6 +1988,12 @@
 }
 
 template <int N>
+EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right(const Packet4ui& a) {
+  const EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
+  return vec_sr(a, p4ui_mask);
+}
+
+template <int N>
 EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(const Packet4ui& a) {
   const EIGEN_DECLARE_CONST_FAST_Packet4ui(mask, N);
   return vec_sr(a, p4ui_mask);
@@ -1956,17 +2005,6 @@
   return vec_sl(a, p4ui_mask);
 }
 
-template <int N>
-EIGEN_STRONG_INLINE Packet8us plogical_shift_left(const Packet8us& a) {
-  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
-  return vec_sl(a, p8us_mask);
-}
-template <int N>
-EIGEN_STRONG_INLINE Packet8us plogical_shift_right(const Packet8us& a) {
-  const EIGEN_DECLARE_CONST_FAST_Packet8us(mask, N);
-  return vec_sr(a, p8us_mask);
-}
-
 EIGEN_STRONG_INLINE Packet4f Bf16ToF32Even(const Packet8bf& bf) {
   return plogical_shift_left<16>(reinterpret_cast<Packet4f>(bf.m_val));
 }
@@ -1976,7 +2014,7 @@
   return pand<Packet4f>(reinterpret_cast<Packet4f>(bf.m_val), reinterpret_cast<Packet4f>(p4ui_high_mask));
 }
 
-EIGEN_ALWAYS_INLINE Packet8us pmerge(Packet4ui even, Packet4ui odd) {
+EIGEN_ALWAYS_INLINE Packet8us pmerge(const Packet4ui& even, const Packet4ui& odd) {
 #ifdef _BIG_ENDIAN
   return vec_perm(reinterpret_cast<Packet8us>(odd), reinterpret_cast<Packet8us>(even), p16uc_MERGEO16);
 #else
@@ -1986,7 +2024,7 @@
 
 // Simple interleaving of bool masks, prevents true values from being
 // converted to NaNs.
-EIGEN_STRONG_INLINE Packet8bf F32ToBf16Bool(Packet4f even, Packet4f odd) {
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16Bool(const Packet4f& even, const Packet4f& odd) {
   return pmerge(reinterpret_cast<Packet4ui>(even), reinterpret_cast<Packet4ui>(odd));
 }
 
@@ -2003,7 +2041,7 @@
 #define __VEC_CLASS_FP_SUBNORMAL (__VEC_CLASS_FP_SUBNORMAL_P | __VEC_CLASS_FP_SUBNORMAL_N)
 #endif
 
-EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f p4f) {
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(const Packet4f& p4f) {
 #ifdef _ARCH_PWR10
   return reinterpret_cast<Packet8us>(__builtin_vsx_xvcvspbf16(reinterpret_cast<Packet16uc>(p4f)));
 #else
@@ -2066,7 +2104,7 @@
  * @tparam lohi to expect either a low & high OR odd & even order
  */
 template <bool lohi>
-EIGEN_ALWAYS_INLINE Packet8bf Bf16PackHigh(Packet4f lo, Packet4f hi) {
+EIGEN_ALWAYS_INLINE Packet8bf Bf16PackHigh(const Packet4f& lo, const Packet4f& hi) {
   if (lohi) {
     return vec_perm(reinterpret_cast<Packet8us>(lo), reinterpret_cast<Packet8us>(hi), p16uc_MERGEH16);
   } else {
@@ -2080,7 +2118,7 @@
  * @param lohi to expect either a low & high OR odd & even order
  */
 template <bool lohi>
-EIGEN_ALWAYS_INLINE Packet8bf Bf16PackLow(Packet4f lo, Packet4f hi) {
+EIGEN_ALWAYS_INLINE Packet8bf Bf16PackLow(const Packet4f& lo, const Packet4f& hi) {
   if (lohi) {
     return vec_pack(reinterpret_cast<Packet4ui>(lo), reinterpret_cast<Packet4ui>(hi));
   } else {
@@ -2089,7 +2127,7 @@
 }
 #else
 template <bool lohi>
-EIGEN_ALWAYS_INLINE Packet8bf Bf16PackLow(Packet4f hi, Packet4f lo) {
+EIGEN_ALWAYS_INLINE Packet8bf Bf16PackLow(const Packet4f& hi, const Packet4f& lo) {
   if (lohi) {
     return vec_pack(reinterpret_cast<Packet4ui>(hi), reinterpret_cast<Packet4ui>(lo));
   } else {
@@ -2098,7 +2136,7 @@
 }
 
 template <bool lohi>
-EIGEN_ALWAYS_INLINE Packet8bf Bf16PackHigh(Packet4f hi, Packet4f lo) {
+EIGEN_ALWAYS_INLINE Packet8bf Bf16PackHigh(const Packet4f& hi, const Packet4f& lo) {
   if (lohi) {
     return vec_perm(reinterpret_cast<Packet8us>(hi), reinterpret_cast<Packet8us>(lo), p16uc_MERGEL16);
   } else {
@@ -2113,7 +2151,7 @@
  * @tparam lohi to expect either a low & high OR odd & even order
  */
 template <bool lohi = true>
-EIGEN_ALWAYS_INLINE Packet8bf F32ToBf16Two(Packet4f lo, Packet4f hi) {
+EIGEN_ALWAYS_INLINE Packet8bf F32ToBf16Two(const Packet4f& lo, const Packet4f& hi) {
   Packet8us p4f = Bf16PackHigh<lohi>(lo, hi);
   Packet8us p4f2 = Bf16PackLow<lohi>(lo, hi);
 
@@ -2181,7 +2219,7 @@
 /**
  * Convert and pack two float Packets into one bfloat16 Packet - low & high order
  */
-EIGEN_STRONG_INLINE Packet8bf F32ToBf16Both(Packet4f lo, Packet4f hi) {
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16Both(const Packet4f& lo, const Packet4f& hi) {
 #ifdef _ARCH_PWR10
   Packet8bf fp16_0 = F32ToBf16(lo);
   Packet8bf fp16_1 = F32ToBf16(hi);
@@ -2194,7 +2232,7 @@
 /**
  * Convert and pack two float Packets into one bfloat16 Packet - odd & even order
  */
-EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f even, Packet4f odd) {
+EIGEN_STRONG_INLINE Packet8bf F32ToBf16(const Packet4f& even, const Packet4f& odd) {
 #ifdef _ARCH_PWR10
   return pmerge(reinterpret_cast<Packet4ui>(F32ToBf16(even).m_val), reinterpret_cast<Packet4ui>(F32ToBf16(odd).m_val));
 #else
@@ -2734,7 +2772,14 @@
 
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x) {
-  return vec_any_ne(x, pzero(x));
+  const Packet4ui zero = {0, 0, 0, 0};
+  return vec_any_ne(reinterpret_cast<Packet4ui>(x), zero);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet8bf& x) {
+  const Packet8us zero = {0, 0, 0, 0, 0, 0, 0, 0};
+  return vec_any_ne(x.m_val, zero);
 }
 
 template <typename T>
@@ -3077,7 +3122,7 @@
 #endif
 
 template <int index>
-Packet2d vec_splat_dbl(Packet2d& a) {
+Packet2d vec_splat_dbl(const Packet2d& a) {
   return vec_splat(a, index);
 }
 
@@ -3261,11 +3306,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) {
   return vec_madd(a, b, p2d_MZERO);
 }
@@ -3471,7 +3511,7 @@
 //
 // Things are more complicated for POWER7. There is actually a
 // vec_xxsxdi intrinsic but it is not supported by some gcc versions.
-// So we need to shift by N % 32 and rearrage bytes.
+// So we need to shift by N % 32 and rearrange bytes.
 #ifdef __POWER8_VECTOR__
 
 template <int N>
@@ -3613,6 +3653,12 @@
   return pfirst<Packet2d>(sum);
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2d& a) {
+  const Packet2ul zero = {0, 0};
+  return vec_any_ne(reinterpret_cast<Packet2ul>(a), zero);
+}
+
 // Other reduction functions:
 // mul
 template <>
diff --git a/Eigen/src/Core/arch/AltiVec/TypeCasting.h b/Eigen/src/Core/arch/AltiVec/TypeCasting.h
index 7be6642..ca640df 100644
--- a/Eigen/src/Core/arch/AltiVec/TypeCasting.h
+++ b/Eigen/src/Core/arch/AltiVec/TypeCasting.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_ALTIVEC_H
 #define EIGEN_TYPE_CASTING_ALTIVEC_H
@@ -131,7 +132,7 @@
 #ifdef EIGEN_VECTORIZE_VSX
 template <>
 inline Packet2l pcast<Packet2d, Packet2l>(const Packet2d& x) {
-  EIGEN_ALIGN_MAX double dtmp[2];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2d>::alignment) double dtmp[2];
   pstore(dtmp, x);
   EIGEN_ALIGN_MAX long long itmp[2] = {static_cast<long long>(dtmp[0]), static_cast<long long>(dtmp[1])};
   return vec_xl(0, itmp);
@@ -141,7 +142,8 @@
 inline Packet2d pcast<Packet2l, Packet2d>(const Packet2l& x) {
   EIGEN_ALIGN_MAX long long itmp[2];
   vec_xst(x, 0, itmp);
-  EIGEN_ALIGN_MAX double dtmp[2] = {static_cast<double>(itmp[0]), static_cast<double>(itmp[1])};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2d>::alignment)
+  double dtmp[2] = {static_cast<double>(itmp[0]), static_cast<double>(itmp[1])};
   return pload<Packet2d>(dtmp);
 }
 #endif
diff --git a/Eigen/src/Core/arch/Default/BFloat16.h b/Eigen/src/Core/arch/Default/BFloat16.h
index 8f1f092..bfa25a6 100644
--- a/Eigen/src/Core/arch/Default/BFloat16.h
+++ b/Eigen/src/Core/arch/Default/BFloat16.h
@@ -12,6 +12,7 @@
 See the License for the specific language governing permissions and
 limitations under the License.
 ==============================================================================*/
+// SPDX-License-Identifier: Apache-2.0
 
 #ifndef EIGEN_BFLOAT16_H
 #define EIGEN_BFLOAT16_H
@@ -41,19 +42,24 @@
 #define EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_BF16(PACKET_F, PACKET_BF16) \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pcos)                      \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, psin)                      \
+  BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, psinh)                     \
+  BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pcosh)                     \
+  BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pasinh)                    \
+  BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pacosh)                    \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pexp)                      \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pexp2)                     \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pexpm1)                    \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, plog)                      \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, plog1p)                    \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, plog2)                     \
+  BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, plog10)                    \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, preciprocal)               \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, prsqrt)                    \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pcbrt)                     \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, psqrt)                     \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, ptanh)
 
-// BF16 wrappers for unsupported/SpecialFunctions.
+// BF16 wrappers for contrib/SpecialFunctions.
 #define EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(PACKET_F, PACKET_BF16) \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, perf)                 \
   BF16_PACKET_FUNCTION(PACKET_F, PACKET_BF16, pndtri)
@@ -133,7 +139,7 @@
 
 // Class definition.
 struct bfloat16 : public bfloat16_impl::bfloat16_base {
-  typedef bfloat16_impl::__bfloat16_raw __bfloat16_raw;
+  using __bfloat16_raw = bfloat16_impl::__bfloat16_raw;
 
   EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16() {}
 
@@ -145,7 +151,7 @@
   template <class T>
   explicit EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR bfloat16(T val)
       : bfloat16_impl::bfloat16_base(
-            bfloat16_impl::float_to_bfloat16_rtne<internal::is_integral<T>::value>(static_cast<float>(val))) {}
+            bfloat16_impl::float_to_bfloat16_rtne<std::is_integral<T>::value>(static_cast<float>(val))) {}
 
   explicit EIGEN_DEVICE_FUNC bfloat16(float f)
       : bfloat16_impl::bfloat16_base(bfloat16_impl::float_to_bfloat16_rtne<false>(f)) {}
@@ -161,7 +167,7 @@
   }
 };
 
-// TODO(majnemer): Get rid of this once we can rely on C++17 inline variables do
+// TODO(majnemer): Get rid of this once we can rely on C++17 inline variables to
 // solve the ODR issue.
 namespace bfloat16_impl {
 template <typename = void>
@@ -210,6 +216,8 @@
   static EIGEN_CONSTEXPR Eigen::bfloat16 denorm_min() { return Eigen::bfloat16_impl::raw_uint16_to_bfloat16(0x0001); }
 };
 
+// Redundant out-of-class definitions are required pre-C++17 but deprecated since.
+#if EIGEN_COMP_CXXVER < 17
 template <typename T>
 EIGEN_CONSTEXPR const bool numeric_limits_bfloat16_impl<T>::is_specialized;
 template <typename T>
@@ -259,6 +267,7 @@
 EIGEN_CONSTEXPR const bool numeric_limits_bfloat16_impl<T>::traps;
 template <typename T>
 EIGEN_CONSTEXPR const bool numeric_limits_bfloat16_impl<T>::tinyness_before;
+#endif
 }  // end namespace bfloat16_impl
 }  // end namespace Eigen
 
@@ -286,7 +295,7 @@
 // of the functions, while the latter can only deal with one of them.
 #if !defined(EIGEN_HAS_NATIVE_BF16) || (EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)  // Emulate support for bfloat16 floats
 
-#if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
+#if EIGEN_COMP_CLANG && defined(EIGEN_GPUCC)
 // We need to provide emulated *host-side* BF16 operators for clang.
 #pragma push_macro("EIGEN_DEVICE_FUNC")
 #undef EIGEN_DEVICE_FUNC
@@ -322,6 +331,15 @@
   numext::uint16_t x = numext::bit_cast<uint16_t>(a) ^ 0x8000;
   return numext::bit_cast<bfloat16>(x);
 }
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC int16_t bfloat16_map_to_signed(numext::uint16_t bits) {
+  constexpr numext::uint16_t kAbsMask = 0x7fff;
+  return (bits >> 15) ? -(bits & kAbsMask) : bits;
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool bfloat16_is_ordered(numext::uint16_t a, numext::uint16_t b) {
+  constexpr numext::uint16_t kAbsMask = 0x7fff;
+  constexpr numext::uint16_t kInf = 0x7f80;
+  return numext::maxi(a & kAbsMask, b & kAbsMask) <= kInf;
+}
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16& operator+=(bfloat16& a, const bfloat16& b) {
   a = bfloat16(float(a) + float(b));
   return a;
@@ -356,23 +374,38 @@
   --a;
   return original_value;
 }
+// Evaluate both predicates to keep comparison loops branch-free. Integer operands avoid Clang's
+// -Wbitwise-instead-of-logical warning.
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator==(const bfloat16& a, const bfloat16& b) {
-  return numext::equal_strict(float(a), float(b));
+  const numext::uint16_t a_bits = numext::bit_cast<numext::uint16_t>(a);
+  const numext::uint16_t b_bits = numext::bit_cast<numext::uint16_t>(b);
+  return static_cast<unsigned int>(bfloat16_map_to_signed(a_bits) == bfloat16_map_to_signed(b_bits)) &
+         static_cast<unsigned int>(bfloat16_is_ordered(a_bits, b_bits));
 }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator!=(const bfloat16& a, const bfloat16& b) {
-  return numext::not_equal_strict(float(a), float(b));
-}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator!=(const bfloat16& a, const bfloat16& b) { return !(a == b); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator<(const bfloat16& a, const bfloat16& b) {
-  return float(a) < float(b);
+  const numext::uint16_t a_bits = numext::bit_cast<numext::uint16_t>(a);
+  const numext::uint16_t b_bits = numext::bit_cast<numext::uint16_t>(b);
+  return static_cast<unsigned int>(bfloat16_map_to_signed(a_bits) < bfloat16_map_to_signed(b_bits)) &
+         static_cast<unsigned int>(bfloat16_is_ordered(a_bits, b_bits));
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator<=(const bfloat16& a, const bfloat16& b) {
-  return float(a) <= float(b);
+  const numext::uint16_t a_bits = numext::bit_cast<numext::uint16_t>(a);
+  const numext::uint16_t b_bits = numext::bit_cast<numext::uint16_t>(b);
+  return static_cast<unsigned int>(bfloat16_map_to_signed(a_bits) <= bfloat16_map_to_signed(b_bits)) &
+         static_cast<unsigned int>(bfloat16_is_ordered(a_bits, b_bits));
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>(const bfloat16& a, const bfloat16& b) {
-  return float(a) > float(b);
+  const numext::uint16_t a_bits = numext::bit_cast<numext::uint16_t>(a);
+  const numext::uint16_t b_bits = numext::bit_cast<numext::uint16_t>(b);
+  return static_cast<unsigned int>(bfloat16_map_to_signed(a_bits) > bfloat16_map_to_signed(b_bits)) &
+         static_cast<unsigned int>(bfloat16_is_ordered(a_bits, b_bits));
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>=(const bfloat16& a, const bfloat16& b) {
-  return float(a) >= float(b);
+  const numext::uint16_t a_bits = numext::bit_cast<numext::uint16_t>(a);
+  const numext::uint16_t b_bits = numext::bit_cast<numext::uint16_t>(b);
+  return static_cast<unsigned int>(bfloat16_map_to_signed(a_bits) >= bfloat16_map_to_signed(b_bits)) &
+         static_cast<unsigned int>(bfloat16_is_ordered(a_bits, b_bits));
 }
 
 #if EIGEN_COMP_CLANG && defined(EIGEN_CUDACC)
@@ -623,23 +656,13 @@
 // --- standard functions ---
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isinf)(const bfloat16& a) {
-  EIGEN_USING_STD(isinf);
-#if defined(EIGEN_USE_HIP_BF16)
-  return (isinf)(a);  // Uses HIP hip_bfloat16 isinf operator
-#else
-  return (isinf)(float(a));
-#endif
+  return (raw_bfloat16_as_uint16(a) & 0x7fff) == 0x7f80;
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isnan)(const bfloat16& a) {
-  EIGEN_USING_STD(isnan);
-#if defined(EIGEN_USE_HIP_BF16)
-  return (isnan)(a);  // Uses HIP hip_bfloat16 isnan operator
-#else
-  return (isnan)(float(a));
-#endif
+  return (raw_bfloat16_as_uint16(a) & 0x7fff) > 0x7f80;
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isfinite)(const bfloat16& a) {
-  return !(isinf EIGEN_NOT_A_MACRO(a)) && !(isnan EIGEN_NOT_A_MACRO(a));
+  return (raw_bfloat16_as_uint16(a) & 0x7fff) < 0x7f80;
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 abs(const bfloat16& a) {
@@ -649,6 +672,10 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp(const bfloat16& a) { return bfloat16(::expf(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exp2(const bfloat16& a) { return bfloat16(::exp2f(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 expm1(const bfloat16& a) { return bfloat16(numext::expm1(float(a))); }
+// float covers the bfloat16 range, so the single conversion back rounds correctly.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 ldexp(const bfloat16& a, int exponent) {
+  return bfloat16(numext::ldexp(float(a), exponent));
+}
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log(const bfloat16& a) { return bfloat16(::logf(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log1p(const bfloat16& a) { return bfloat16(numext::log1p(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 log10(const bfloat16& a) { return bfloat16(::log10f(float(a))); }
@@ -675,13 +702,27 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 asinh(const bfloat16& a) { return bfloat16(::asinhf(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 acosh(const bfloat16& a) { return bfloat16(::acoshf(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 atanh(const bfloat16& a) { return bfloat16(::atanhf(float(a))); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 floor(const bfloat16& a) { return bfloat16(::floorf(float(a))); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 ceil(const bfloat16& a) { return bfloat16(::ceilf(float(a))); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 rint(const bfloat16& a) { return bfloat16(::rintf(float(a))); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 round(const bfloat16& a) { return bfloat16(::roundf(float(a))); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 trunc(const bfloat16& a) { return bfloat16(::truncf(float(a))); }
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 exact_float_to_bfloat16(float f) {
+  return raw_uint16_to_bfloat16(static_cast<numext::uint16_t>(numext::bit_cast<numext::uint32_t>(f) >> 16));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 floor(const bfloat16& a) {
+  return exact_float_to_bfloat16(::floorf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 ceil(const bfloat16& a) {
+  return exact_float_to_bfloat16(::ceilf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 rint(const bfloat16& a) {
+  return exact_float_to_bfloat16(::rintf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 round(const bfloat16& a) {
+  return exact_float_to_bfloat16(::roundf(float(a)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 trunc(const bfloat16& a) {
+  return exact_float_to_bfloat16(::truncf(float(a)));
+}
+// fmod is exact: a - n*b is either a itself or a multiple of the ulp of b that is smaller than |b|.
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmod(const bfloat16& a, const bfloat16& b) {
-  return bfloat16(::fmodf(float(a), float(b)));
+  return exact_float_to_bfloat16(::fmodf(float(a), float(b)));
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16(min)(const bfloat16& a, const bfloat16& b) {
@@ -699,13 +740,13 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmin(const bfloat16& a, const bfloat16& b) {
   const float f1 = static_cast<float>(a);
   const float f2 = static_cast<float>(b);
-  return bfloat16(::fminf(f1, f2));
+  return exact_float_to_bfloat16(::fminf(f1, f2));
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 fmax(const bfloat16& a, const bfloat16& b) {
   const float f1 = static_cast<float>(a);
   const float f2 = static_cast<float>(b);
-  return bfloat16(::fmaxf(f1, f2));
+  return exact_float_to_bfloat16(::fmaxf(f1, f2));
 }
 
 EIGEN_DEVICE_FUNC inline bfloat16 fma(const bfloat16& a, const bfloat16& b, const bfloat16& c) {
@@ -725,9 +766,7 @@
 namespace internal {
 
 template <>
-struct is_arithmetic<bfloat16> {
-  enum { value = true };
-};
+struct is_arithmetic<bfloat16> : std::true_type {};
 
 template <>
 struct random_impl<bfloat16> {
@@ -739,7 +778,7 @@
   }
   static EIGEN_DEVICE_FUNC inline bfloat16 run() {
     float result = Impl::run(MantissaBits);
-    return bfloat16(result);
+    return bfloat16_impl::exact_float_to_bfloat16(result);
   }
 };
 
@@ -815,13 +854,13 @@
   }
   uint16_t from_bits = numext::bit_cast<uint16_t>(from);
   bool from_sign = from_bits >> 15;
-  // Whether we are adjusting toward the infinity with the same sign as from.
-  bool toward_inf = (to > from) == !from_sign;
-  if (toward_inf) {
+  if ((from_bits & 0x7fff) == 0) {
+    // From ±0 toward a nonzero value: the neighbor is the smallest subnormal
+    // carrying the sign of the direction (IEEE-754 nextUp/nextDown of zero).
+    from_bits = (to > from) ? uint16_t(0x0001) : uint16_t(0x8001);
+  } else if ((to > from) != from_sign) {
+    // Toward the infinity with the same sign as from: increase the magnitude.
     ++from_bits;
-  } else if ((from_bits & 0x7fff) == 0) {
-    // Adjusting away from inf, but from is zero, so just toggle the sign.
-    from_bits ^= 0x8000;
   } else {
     --from_bits;
   }
@@ -850,16 +889,8 @@
 }  // namespace std
 #endif
 
-// Add the missing shfl* intrinsics.
-// The __shfl* functions are only valid on HIP or _CUDA_ARCH_ >= 300.
-//   CUDA defines them for (__CUDA_ARCH__ >= 300 || !defined(__CUDA_ARCH__))
-//
-// HIP and CUDA prior to SDK 9.0 define
-//    __shfl, __shfl_up, __shfl_down, __shfl_xor for int and float
-// CUDA since 9.0 deprecates those and instead defines
-//    __shfl_sync, __shfl_up_sync, __shfl_down_sync, __shfl_xor_sync,
-//    with native support for __half and __nv_bfloat16
-//
+// Warp shuffle overloads for Eigen::bfloat16.
+// HIP uses non-sync __shfl variants; CUDA has native __nv_bfloat16 support in __shfl_sync.
 // Note that the following are __device__ - only functions.
 #if defined(EIGEN_HIPCC)
 
diff --git a/Eigen/src/Core/arch/Default/ConjHelper.h b/Eigen/src/Core/arch/Default/ConjHelper.h
index 137e7fb..20b61cc 100644
--- a/Eigen/src/Core/arch/Default/ConjHelper.h
+++ b/Eigen/src/Core/arch/Default/ConjHelper.h
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MPL-2.0
 
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
@@ -75,7 +76,7 @@
 // specialized below.
 template <typename LhsType, typename RhsType, bool ConjLhs, bool ConjRhs>
 struct conj_helper {
-  typedef typename ScalarBinaryOpTraits<LhsType, RhsType>::ReturnType ResultType;
+  using ResultType = typename ScalarBinaryOpTraits<LhsType, RhsType>::ReturnType;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType pmadd(const LhsType& x, const RhsType& y,
                                                          const ResultType& c) const {
@@ -94,14 +95,14 @@
 
 template <typename LhsScalar, typename RhsScalar>
 struct conj_helper<LhsScalar, RhsScalar, true, true> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResultType;
+  using ResultType = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType pmadd(const LhsScalar& x, const RhsScalar& y,
                                                          const ResultType& c) const {
     return this->pmul(x, y) + c;
   }
 
-  // We save a conjuation by using the identity conj(a)*conj(b) = conj(a*b).
+  // We save a conjugation by using the identity conj(a)*conj(b) = conj(a*b).
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType pmul(const LhsScalar& x, const RhsScalar& y) const {
     return numext::conj(x * y);
   }
@@ -110,7 +111,7 @@
 // Implementation with equal type, use packet operations.
 template <typename Packet, bool ConjLhs, bool ConjRhs>
 struct conj_helper<Packet, Packet, ConjLhs, ConjRhs> {
-  typedef Packet ResultType;
+  using ResultType = Packet;
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const {
     return Eigen::internal::pmadd(conj_if<ConjLhs>().pconj(x), conj_if<ConjRhs>().pconj(y), c);
   }
@@ -126,7 +127,7 @@
 
 template <typename Packet>
 struct conj_helper<Packet, Packet, true, true> {
-  typedef Packet ResultType;
+  using ResultType = Packet;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const {
     return Eigen::internal::pmadd(pconj(x), pconj(y), c);
@@ -134,7 +135,7 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmsub(const Packet& x, const Packet& y, const Packet& c) const {
     return Eigen::internal::pmsub(pconj(x), pconj(y), c);
   }
-  // We save a conjuation by using the identity conj(a)*conj(b) = conj(a*b).
+  // We save a conjugation by using the identity conj(a)*conj(b) = conj(a*b).
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pmul(const Packet& x, const Packet& y) const {
     return pconj(Eigen::internal::pmul(x, y));
   }
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathComplex.h b/Eigen/src/Core/arch/Default/GenericPacketMathComplex.h
index 8ceaf96..b58593d 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathComplex.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathComplex.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_COMPLEX_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_COMPLEX_H
@@ -17,14 +18,16 @@
 namespace Eigen {
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 //----------------------------------------------------------------------
 // Complex Arithmetic and Functions
 //----------------------------------------------------------------------
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pdiv_complex(const Packet& x, const Packet& y) {
-  typedef typename unpacket_traits<Packet>::as_real RealPacket;
-  typedef typename unpacket_traits<RealPacket>::type RealScalar;
+  using RealPacket = typename unpacket_traits<Packet>::as_real;
+  using RealScalar = typename unpacket_traits<RealPacket>::type;
   // In the following we annotate the code for the case where the inputs
   // are a pair length-2 SIMD vectors representing a single pair of complex
   // numbers x = a + i*b, y = c + i*d.
@@ -34,7 +37,7 @@
 
   const RealPacket mask = pcmp_lt(abs_y, abs_y_flip);  // |c| < |d|
   RealPacket y_scaled = pselect(mask, pdiv(abs_y, abs_y_flip), one);
-  y_scaled = por(y_scaled, pandnot(y.v, abs_y));    // copy signs in case |c| == |d|
+  y_scaled = por(y_scaled, pandnot(y.v, abs_y));  // copy signs in case |c| == |d|
   RealPacket denom = pmul(y.v, y_scaled);
   denom = padd(denom, pcplxflip(Packet(denom)).v);  // c * c' + d * d'
   Packet num = pmul(x, pconj(Packet(y_scaled)));    // a * c' + b * d', -a * d + b * c
@@ -56,9 +59,7 @@
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_complex(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename Scalar::value_type RealScalar;
-  typedef typename unpacket_traits<Packet>::as_real RealPacket;
+  using RealPacket = typename unpacket_traits<Packet>::as_real;
 
   // Real part
   RealPacket x_flip = pcplxflip(x).v;  // b, a
@@ -68,7 +69,7 @@
   // Imag part
   RealPacket ximg = patan2(x.v, x_flip);  // atan2(a, b), atan2(b, a)
 
-  const RealPacket cst_pos_inf = pset1<RealPacket>(NumTraits<RealScalar>::infinity());
+  const RealPacket cst_pos_inf = pinf<RealPacket>();
   RealPacket x_abs = pabs(x.v);
   RealPacket is_x_pos_inf = pcmp_eq(x_abs, cst_pos_inf);
   RealPacket is_y_pos_inf = pcplxflip(Packet(is_x_pos_inf)).v;
@@ -80,9 +81,9 @@
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp_complex(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::as_real RealPacket;
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename Scalar::value_type RealScalar;
+  using RealPacket = typename unpacket_traits<Packet>::as_real;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using RealScalar = typename Scalar::value_type;
   const RealPacket even_mask = peven_mask(a.v);
   const RealPacket odd_mask = pcplxflip(Packet(even_mask)).v;
 
@@ -100,8 +101,8 @@
   RealPacket cisy = psincos_selector<RealPacket>(y);
   cisy = pcplxflip(Packet(cisy)).v;  // cos(y) + i * sin(y)
 
-  const RealPacket cst_pos_inf = pset1<RealPacket>(NumTraits<RealScalar>::infinity());
-  const RealPacket cst_neg_inf = pset1<RealPacket>(-NumTraits<RealScalar>::infinity());
+  const RealPacket cst_pos_inf = pinf<RealPacket>();
+  const RealPacket cst_neg_inf = por(psignmask<RealPacket>(), pinf<RealPacket>());
 
   // If x is -inf, we know that cossin(y) is bounded,
   //   so the result is (0, +/-0), where the sign of the imaginary part comes
@@ -118,7 +119,7 @@
   // prevent inf * 0 = NaN. The vectorized sincos may compute exact zero
   // for near-zero values like cos(pi/2), and inf * +-1 = +-inf is correct.
   // The y=0 case is handled separately below.
-  RealPacket cisy_sign_one = por(pand(cisy, pset1<RealPacket>(RealScalar(-0.0))), pset1<RealPacket>(RealScalar(1)));
+  RealPacket cisy_sign_one = por(pand(cisy, psignmask<RealPacket>()), pset1<RealPacket>(RealScalar(1)));
   RealPacket expx_inf_y_finite = pand(pcmp_eq(expx, cst_pos_inf), pcmp_lt(pabs(y), cst_pos_inf));
   cisy = pselect(expx_inf_y_finite, cisy_sign_one, cisy);
 
@@ -132,9 +133,9 @@
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psqrt_complex(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename Scalar::value_type RealScalar;
-  typedef typename unpacket_traits<Packet>::as_real RealPacket;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using RealScalar = typename Scalar::value_type;
+  using RealPacket = typename unpacket_traits<Packet>::as_real;
 
   // Computes the principal sqrt of the complex numbers in the input.
   //
@@ -148,7 +149,7 @@
   // a single complex square root of the number x + i*y. We want to find real numbers
   // u and v such that
   //    (u + i*v)^2 = x + i*y  <=>
-  //    u^2 - v^2 + i*2*u*v = x + i*v.
+  //    u^2 - v^2 + i*2*u*v = x + i*y.
   // By equating the real and imaginary parts we get:
   //    u^2 - v^2 = x
   //    2*u*v = y.
@@ -163,7 +164,7 @@
   //  To avoid unnecessary over- and underflow, we compute sqrt(x^2 + y^2) as
   //     l = max(|x|, |y|) * sqrt(1 + (min(|x|, |y|) / max(|x|, |y|))^2) ,
 
-  // In the following, without lack of generality, we have annotated the code, assuming
+  // In the following, without loss of generality, we have annotated the code, assuming
   // that the input is a packet of 2 complex numbers.
   //
   // Step 1. Compute l = [l0, l0, l1, l1], where
@@ -192,8 +193,8 @@
   rho.v = psqrt(pmul(cst_half, padd(a_abs, l)));
 
   // Step 3. Compute [rho0, eta0, rho1, eta1], where
-  // eta0 = (y0 / l0) / 2, and eta1 = (y1 / l1) / 2.
-  // set eta = 0 of input is 0 + i0.
+  // eta0 = (y0 / rho0) / 2, and eta1 = (y1 / rho1) / 2.
+  // set eta = 0 if input is 0 + i0.
   RealPacket eta = pandnot(pmul(cst_half, pdiv(a.v, pcplxflip(rho).v)), a_max_zero_mask);
   RealPacket real_mask = peven_mask(a.v);
   Packet positive_real_result;
@@ -202,7 +203,8 @@
 
   // Step 4. Compute solution for inputs with negative real part:
   //         [|eta0|, sign(y0)*rho0, |eta1|, sign(y1)*rho1]
-  const RealPacket cst_imag_sign_mask = pset1<Packet>(Scalar(RealScalar(0.0), RealScalar(-0.0))).v;
+  // [+0.0, -0.0, ...]: the sign bit of the imaginary (odd) lanes only.
+  const RealPacket cst_imag_sign_mask = pandnot(psignmask<RealPacket>(), real_mask);
   RealPacket imag_signs = pand(a.v, cst_imag_sign_mask);
   Packet negative_real_result;
   // Notice that rho is positive, so taking its absolute value is a noop.
@@ -219,7 +221,7 @@
   // * If z is (x,-∞), the result is (+∞,-∞) even if x is NaN
   // * If z is (-∞,y), the result is (0*|y|,+∞) for finite or NaN y
   // * If z is (+∞,y), the result is (+∞,0*|y|) for finite or NaN y
-  const RealPacket cst_pos_inf = pset1<RealPacket>(NumTraits<RealScalar>::infinity());
+  const RealPacket cst_pos_inf = pinf<RealPacket>();
   Packet is_inf;
   is_inf.v = pcmp_eq(a_abs, cst_pos_inf);
   Packet is_real_inf;
@@ -246,9 +248,9 @@
 // Implemented using the hypot(a,b) algorithm from https://doi.org/10.48550/arXiv.1904.09481
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet phypot_complex(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename Scalar::value_type RealScalar;
-  typedef typename unpacket_traits<Packet>::as_real RealPacket;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using RealScalar = typename Scalar::value_type;
+  using RealPacket = typename unpacket_traits<Packet>::as_real;
 
   const RealPacket cst_zero_rp = pset1<RealPacket>(static_cast<RealScalar>(0.0));
   const RealPacket cst_minus_one_rp = pset1<RealPacket>(static_cast<RealScalar>(-1.0));
@@ -277,6 +279,8 @@
   return Packet(h);        // |sqrt(a^2+b^2), sqrt(a^2+b^2)|
 }
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 }  // end namespace Eigen
 
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathDoubleWord.h b/Eigen/src/Core/arch/Default/GenericPacketMathDoubleWord.h
index 5cb677f..c33616d 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathDoubleWord.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathDoubleWord.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_DOUBLE_WORD_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_DOUBLE_WORD_H
@@ -24,7 +25,7 @@
   r = psub(x, n);
 }
 
-// This function computes the sum {s, r}, such that x + y = s_hi + s_lo
+// This function computes the sum {s_hi, s_lo}, such that x + y = s_hi + s_lo
 // holds exactly, and s_hi = fl(x+y), if |x| >= |y|.
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void fast_twosum(const Packet& x, const Packet& y, Packet& s_hi, Packet& s_lo) {
@@ -34,6 +35,18 @@
 }
 
 #ifdef EIGEN_VECTORIZE_FMA
+// Given x, y, and xy = fl(x*y), return the residual such that x*y = xy + residual exactly.
+template <typename Packet, std::enable_if_t<!is_scalar<Packet>::value, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet twoprod_low(const Packet& x, const Packet& y, const Packet& xy) {
+  return pmsub(x, y, xy);
+}
+
+template <typename Scalar, std::enable_if_t<is_scalar<Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar twoprod_low(const Scalar& x, const Scalar& y, const Scalar& xy) {
+  // Error-free products require FMA even when EIGEN_SCALAR_MADD_USE_FMA disables fusion in scalar madd.
+  return numext::fma(x, y, Scalar(-xy));
+}
+
 // This function implements the extended precision product of
 // a pair of floating point numbers. Given {x, y}, it computes the pair
 // {p_hi, p_lo} such that x * y = p_hi + p_lo holds exactly and
@@ -41,26 +54,48 @@
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void twoprod(const Packet& x, const Packet& y, Packet& p_hi, Packet& p_lo) {
   p_hi = pmul(x, y);
-  p_lo = pmsub(x, y, p_hi);
-}
-
-// A version of twoprod that takes x, y, and fl(x*y) as input and returns the p_lo such that
-// x * y = xy + p_lo holds exactly.
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet twoprod_low(const Packet& x, const Packet& y, const Packet& xy) {
-  return pmsub(x, y, xy);
+  p_lo = twoprod_low(x, y, p_hi);
 }
 
 #else
 
+// Dekker's product requires separately rounded operations. GCC's C++ default -ffp-contract=fast may fuse
+// fl(x*y) into its consumers, so use fma for scalar types that <cmath> advertises as fast.
+// This does not prevent contraction in the remaining scalar or packet fallback paths.
+template <typename Scalar>
+struct has_fast_fma : std::false_type {};
+#ifdef FP_FAST_FMAF
+template <>
+struct has_fast_fma<float> : std::true_type {};
+#endif
+#ifdef FP_FAST_FMA
+template <>
+struct has_fast_fma<double> : std::true_type {};
+#endif
+#ifdef FP_FAST_FMAL
+template <>
+struct has_fast_fma<long double> : std::true_type {};
+#endif
+
+template <typename Scalar, std::enable_if_t<has_fast_fma<Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar twoprod_low(const Scalar& x, const Scalar& y, const Scalar& xy) {
+  return numext::fma(x, y, Scalar(-xy));
+}
+
+template <typename Scalar, std::enable_if_t<has_fast_fma<Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void twoprod(const Scalar& x, const Scalar& y, Scalar& p_hi, Scalar& p_lo) {
+  p_hi = x * y;
+  p_lo = twoprod_low(x, y, p_hi);
+}
+
 // This function implements the Veltkamp splitting. Given a floating point
 // number x it returns the pair {x_hi, x_lo} such that x_hi + x_lo = x holds
-// exactly and that half of the significant of x fits in x_hi.
+// exactly and that half of the significand of x fits in x_hi.
 // This is Algorithm 3 from Jean-Michel Muller, "Elementary Functions",
 // 3rd edition, Birkh\"auser, 2016.
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void veltkamp_splitting(const Packet& x, Packet& x_hi, Packet& x_lo) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   constexpr int shift = (NumTraits<Scalar>::digits() + 1) / 2;
   const Scalar shift_scale = Scalar(uint64_t(1) << shift);  // Scalar constructor not necessarily constexpr.
   const Packet gamma = pmul(pset1<Packet>(shift_scale + Scalar(1)), x);
@@ -73,7 +108,7 @@
 // Given floating point numbers {x, y} computes the pair
 // {p_hi, p_lo} such that x * y = p_hi + p_lo holds exactly and
 // p_hi = fl(x * y).
-template <typename Packet>
+template <typename Packet, std::enable_if_t<!has_fast_fma<Packet>::value, int> = 0>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void twoprod(const Packet& x, const Packet& y, Packet& p_hi, Packet& p_lo) {
   Packet x_hi, x_lo, y_hi, y_lo;
   veltkamp_splitting(x, x_hi, x_lo);
@@ -88,7 +123,7 @@
 
 // A version of twoprod that takes x, y, and fl(x*y) as input and returns the p_lo such that
 // x * y = xy + p_lo holds exactly.
-template <typename Packet>
+template <typename Packet, std::enable_if_t<!has_fast_fma<Packet>::value, int> = 0>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet twoprod_low(const Packet& x, const Packet& y, const Packet& xy) {
   Packet x_hi, x_lo, y_hi, y_lo;
   veltkamp_splitting(x, x_hi, x_lo);
@@ -152,8 +187,8 @@
 // This function implements the multiplication of a double word
 // number represented by {x_hi, x_lo} by a floating point number y.
 // It returns the result as a pair {p_hi, p_lo} such that
-// (x_hi + x_lo) * y = p_hi + p_lo hold with a relative error
-// of less than 2*2^{-2p}, where p is the number of significand bit
+// (x_hi + x_lo) * y = p_hi + p_lo holds with a relative error
+// of less than 2*2^{-2p}, where p is the number of significand bits
 // in the floating point type.
 // This is Algorithm 7 from Jean-Michel Muller, "Elementary Functions",
 // 3rd edition, Birkh\"auser, 2016.
@@ -171,10 +206,15 @@
 
 // This function implements the multiplication of two double word
 // numbers represented by {x_hi, x_lo} and {y_hi, y_lo}.
-// It returns the result as a pair {p_hi, p_lo} such that
-// (x_hi + x_lo) * (y_hi + y_lo) = p_hi + p_lo holds with a relative error
-// of less than 2*2^{-2p}, where p is the number of significand bit
-// in the floating point type.
+// For normalized inputs (x_hi = RN(x_hi + x_lo), likewise for y), the result
+// {p_hi, p_lo} has relative error < 5*u^2 for p-bit significands, u = 2^{-p}, p >= 8.
+// This assumes round-to-nearest, no overflow/underflow, an exact two-product
+// residual, and separately rounded operations outside that residual.
+// Each DW*FP product has relative error <= (3/2 + 4*u)*u^2: Joldes, Muller,
+// and Popescu (2017), "Tight and rigorous error bounds for basic building
+// blocks of double-word arithmetic", Theorem 4.1, https://hal.science/hal-01351529.
+// The final sum adds absolute error <= u^2*((3+3*u+u^2)*abs(p_hi_hi)
+// + (4+3*u+u^2)*abs(p_lo_hi)); using abs(y_lo) <= u*abs(y_hi) gives the bound above.
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void twoprod(const Packet& x_hi, const Packet& x_lo, const Packet& y_hi,
                                                    const Packet& y_lo, Packet& p_hi, Packet& p_lo) {
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h b/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h
index 978818e..5df1be5 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathFrexpLdexp.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FREXP_LDEXP_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_FREXP_LDEXP_H
@@ -22,25 +23,25 @@
 struct make_integer;
 template <>
 struct make_integer<float> {
-  typedef numext::int32_t type;
+  using type = numext::int32_t;
 };
 template <>
 struct make_integer<double> {
-  typedef numext::int64_t type;
+  using type = numext::int64_t;
 };
 template <>
 struct make_integer<half> {
-  typedef numext::int16_t type;
+  using type = numext::int16_t;
 };
 template <>
 struct make_integer<bfloat16> {
-  typedef numext::int16_t type;
+  using type = numext::int16_t;
 };
 
 template <typename Packet>
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pfrexp_generic_get_biased_exponent(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
   static constexpr int mantissa_bits = numext::numeric_limits<Scalar>::digits - 1;
   return pcast<PacketI, Packet>(plogical_shift_right<mantissa_bits>(preinterpret<PacketI>(pabs(a))));
 }
@@ -49,8 +50,8 @@
 // Assumes IEEE floating point format.
 template <typename Packet>
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pfrexp_generic(const Packet& a, Packet& exponent) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename make_unsigned<typename make_integer<Scalar>::type>::type ScalarUI;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using ScalarUI = std::make_unsigned_t<typename make_integer<Scalar>::type>;
   static constexpr int TotalBits = sizeof(Scalar) * CHAR_BIT, MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
                        ExponentBits = TotalBits - MantissaBits - 1;
 
@@ -105,30 +106,35 @@
   // Unfortunately, 2^(278) cannot be represented using either one or two
   // finite normal floats, so we must split the scale factor into at least
   // three parts. It turns out to be faster to split 'exponent' into four
-  // factors, since [exponent>>2] is much faster to compute that [exponent/3].
+  // factors, since [exponent>>2] is much faster to compute than [exponent/3].
   //
   // Set e = min(max(exponent, -278), 278);
   //     b = floor(e/4);
-  //   out = ((((a * 2^(b)) * 2^(b)) * 2^(b)) * 2^(e-3*b))
+  //     c1 = 2^b
+  //     c2 = 2^(e - 3b)
+  //   out = (((a * c1) * c1) * c1) * c2  (= a * 2^e)
   //
-  // This will avoid any intermediate overflows and correctly handle 0, inf,
-  // NaN cases.
-  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  // Every partial product must contain 'a'. Reassociating scale factors can
+  // overflow (for example c1*c1 at e=256 for float), making pldexp(0, 256)
+  // NaN and finite denormal results infinite. Apply c1 before c2 because c2
+  // may exceed one for negative exponents (e.g. c2=4 for e=-1), overflowing
+  // values near max even when the final result is finite.
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using ScalarI = typename unpacket_traits<PacketI>::type;
   static constexpr int TotalBits = sizeof(Scalar) * CHAR_BIT, MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
                        ExponentBits = TotalBits - MantissaBits - 1;
 
-  const Packet max_exponent = pset1<Packet>(Scalar((ScalarI(1) << ExponentBits) + ScalarI(MantissaBits - 1)));  // 278
-  const PacketI bias = pset1<PacketI>((ScalarI(1) << (ExponentBits - 1)) - ScalarI(1));                         // 127
-  const PacketI e = pcast<Packet, PacketI>(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
-  PacketI b = parithmetic_shift_right<2>(e);                                          // floor(e/4);
-  Packet c = preinterpret<Packet>(plogical_shift_left<MantissaBits>(padd(b, bias)));  // 2^b
-  Packet out = pmul(pmul(pmul(a, c), c), c);                                          // a * 2^(3b)
-  b = pnmadd(pset1<PacketI>(3), b, e);                                                // e - 3b
-  c = preinterpret<Packet>(plogical_shift_left<MantissaBits>(padd(b, bias)));         // 2^(e-3*b)
-  out = pmul(out, c);
-  return out;
+  constexpr ScalarI max_exp_value = (ScalarI(1) << ExponentBits) + ScalarI(MantissaBits - 1);  // 278
+  const Packet max_exponent = pset1<Packet>(Scalar(max_exp_value));
+  const Packet neg_max_exponent = pset1<Packet>(Scalar(-max_exp_value));
+  const PacketI bias = pset1<PacketI>((ScalarI(1) << (ExponentBits - 1)) - ScalarI(1));  // 127
+  const PacketI e = pcast<Packet, PacketI>(pmin(pmax(exponent, neg_max_exponent), max_exponent));
+  const PacketI b = parithmetic_shift_right<2>(e);                                                     // floor(e/4);
+  const PacketI b_remainder = pnmadd(pset1<PacketI>(3), b, e);                                         // e - 3b
+  const Packet c1 = preinterpret<Packet>(plogical_shift_left<MantissaBits>(padd(b, bias)));            // 2^b
+  const Packet c2 = preinterpret<Packet>(plogical_shift_left<MantissaBits>(padd(b_remainder, bias)));  // 2^(e-3*b)
+  return pmul(pmul(pmul(pmul(a, c1), c1), c1), c2);                                                    // a * 2^e
 }
 
 // Explicitly multiplies
@@ -142,9 +148,9 @@
 // Assumes IEEE floating point format
 template <typename Packet>
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet pldexp_fast(const Packet& a, const Packet& exponent) {
-  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
+  using Scalar = typename unpacket_traits<Packet>::type;
+  using ScalarI = typename unpacket_traits<PacketI>::type;
   static constexpr int TotalBits = sizeof(Scalar) * CHAR_BIT, MantissaBits = numext::numeric_limits<Scalar>::digits - 1,
                        ExponentBits = TotalBits - MantissaBits - 1;
 
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
index 2ab1847..518695c 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
@@ -9,6 +9,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /* The exp and log functions of this file initially come from
  * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
@@ -30,62 +31,104 @@
 // Exponential and Logarithmic Functions
 //----------------------------------------------------------------------
 
-// Natural or base 2 logarithm.
-// Computes log(x) as log(2^e * m) = C*e + log(m), where the constant C =log(2)
-// and m is in the range [sqrt(1/2),sqrt(2)). In this range, the logarithm can
-// be easily approximated by a polynomial centered on m=1 for stability.
-// TODO(gonnet): Further reduce the interval allowing for lower-degree
-//               polynomial interpolants -> ... -> profit!
+// Core range reduction and polynomial evaluation for float logarithm.
+//
+// Given a positive float value v (may be denormal), decomposes it as
+// v = 2^e * (1+f) with f in [sqrt(0.5)-1, sqrt(2)-1], then evaluates
+// log(1+f) ≈ f + f^2 * P(f) using a degree-7 minimax polynomial.
+//
+// Returns the approximation of log(v_mantissa) in log_mantissa and the
+// integer exponent in e. The caller combines these as appropriate
+// (e.g. e*ln2 + log_mantissa for natural log, or log_mantissa*log2e + e
+// for log2).
+//
+// Range reduction uses integer bit manipulation (musl-inspired) instead of the
+// heavier pfrexp_generic, saving ~12 ops. The minimax polynomial was found via
+// Sollya's fpminimax, giving faithfully-rounded results (max 1 ULP for log).
+template <typename Packet>
+EIGEN_STRONG_INLINE void plog_core_float(const Packet v, Packet& log_mantissa, Packet& e) {
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
+
+  const PacketI cst_min_normal = pset1<PacketI>(0x00800000);
+  const PacketI cst_mant_mask = pset1<PacketI>(0x007fffff);
+  // Adding this offset to the integer representation biases the exponent so
+  // that values near 1 (0x3f800000) map to exponent 0, and values below
+  // sqrt(0.5) get folded into the previous exponent.  The magic constant is
+  // 0x3f800000 - 0x3f3504f3 = 0x004afb0d, where 0x3f3504f3 ≈ sqrt(0.5).
+  const PacketI cst_sqrt_half_offset = pset1<PacketI>(0x004afb0d);
+  const PacketI cst_exp_bias = pset1<PacketI>(0x7f);         // 127
+  const PacketI cst_half_mant = pset1<PacketI>(0x3f3504f3);  // sqrt(0.5)
+
+  // Normalize denormals by multiplying by 2^23.
+  PacketI vi = preinterpret<PacketI>(v);
+  PacketI is_denormal = pcmp_lt(vi, cst_min_normal);
+  Packet v_normalized = pmul(v, pset1<Packet>(8388608.0f));  // 2^23
+  vi = pselect(is_denormal, preinterpret<PacketI>(v_normalized), vi);
+  // Denormal exponent adjustment: subtract 23 from exponent.
+  PacketI denorm_adj = pand(is_denormal, pset1<PacketI>(23));
+
+  // Combined range reduction: bias integer representation so that exponent
+  // extraction automatically shifts mantissa to [sqrt(0.5), sqrt(2)).
+  PacketI vi_biased = padd(vi, cst_sqrt_half_offset);
+  // Extract exponent as integer, subtract bias and denormal adjustment.
+  PacketI e_int = psub(psub(plogical_shift_right<23>(vi_biased), cst_exp_bias), denorm_adj);
+  e = pcast<PacketI, Packet>(e_int);
+  // Reconstruct mantissa in [sqrt(0.5), sqrt(2)). The integer addition of the
+  // masked mantissa with 0x3f3504f3 (sqrt(0.5)) naturally produces carry into
+  // the exponent field, yielding values in [sqrt(0.5), 1) or [1, sqrt(2)).
+  // Then subtract 1 to center on 0 → f in [sqrt(0.5)-1, sqrt(2)-1].
+  Packet f = psub(preinterpret<Packet>(padd(pand(vi_biased, cst_mant_mask), cst_half_mant)), pset1<Packet>(1.0f));
+
+  // Minimax degree-7 polynomial for g(f) = (log(1+f) - f) / f^2 on
+  // [sqrt(0.5)-1, sqrt(2)-1], so log(1+f) ≈ f + f^2 * P(f).
+  // Generated by Sollya: fpminimax(g, 7, [|single...|], [lo;hi])
+  // Mathematical approximation error: max |log(1+f) - (f + f^2*P(f))| < 2.04e-8.
+  // Coefficients stored in reverse order for ppolevl (highest degree first).
+  constexpr float coeffs[] = {
+      8.8758550584316254e-02f,   //  c7 (x^7)
+      -1.4199858903884888e-01f,  //  c6 (x^6)
+      1.4824025332927704e-01f,   //  c5 (x^5)
+      -1.6583317518234253e-01f,  //  c4 (x^4)
+      1.9972395896911621e-01f,   //  c3 (x^3)
+      -2.5001299381256104e-01f,  //  c2 (x^2)
+      3.3333668112754822e-01f,   //  c1 (x^1)
+      -4.9999997019767761e-01f,  //  c0 (x^0)
+  };
+
+  // Evaluate P(f) via Horner's method, then log(1+f) ≈ f + f^2 * P(f).
+  Packet f2 = pmul(f, f);
+  Packet p = ppolevl<Packet, 7>::run(f, coeffs);
+  log_mantissa = pmadd(p, f2, f);
+}
+
+// Natural or base-2 logarithm for float packets.
+//
+// Computes log(x) as e*C + log(m), where x = 2^e * m with m in [sqrt(1/2), sqrt(2))
+// and C = ln(2) for natural log, C = 1 for log2.
 template <typename Packet, bool base2>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_impl_float(const Packet _x) {
-  const Packet cst_1 = pset1<Packet>(1.0f);
-  const Packet cst_minus_inf = pset1frombits<Packet>(static_cast<Eigen::numext::uint32_t>(0xff800000u));
-  const Packet cst_pos_inf = pset1frombits<Packet>(static_cast<Eigen::numext::uint32_t>(0x7f800000u));
+  Packet log_mantissa, e;
+  plog_core_float(_x, log_mantissa, e);
 
-  const Packet cst_cephes_SQRTHF = pset1<Packet>(0.707106781186547524f);
-  Packet e, x;
-  // extract significant in the range [0.5,1) and exponent
-  x = pfrexp(_x, e);
-
-  // part2: Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
-  // and shift by -1. The values are then centered around 0, which improves
-  // the stability of the polynomial evaluation.
-  //   if( x < SQRTHF ) {
-  //     e -= 1;
-  //     x = x + x - 1.0;
-  //   } else { x = x - 1.0; }
-  Packet mask = pcmp_lt(x, cst_cephes_SQRTHF);
-  Packet tmp = pand(x, mask);
-  x = psub(x, cst_1);
-  e = psub(e, pand(cst_1, mask));
-  x = padd(x, tmp);
-
-  // Polynomial coefficients for rational r(x) = p(x)/q(x)
-  // approximating log(1+x) on [sqrt(0.5)-1;sqrt(2)-1].
-  constexpr float alpha[] = {0.18256296349849254f, 1.0000000190281063f, 1.0000000190281136f};
-  constexpr float beta[] = {0.049616247954120038f, 0.59923249590823520f, 1.4999999999999927f, 1.0f};
-
-  Packet p = ppolevl<Packet, 2>::run(x, alpha);
-  p = pmul(x, p);
-  Packet q = ppolevl<Packet, 3>::run(x, beta);
-  x = pdiv(p, q);
-
-  // Add the logarithm of the exponent back to the result of the interpolation.
+  // Add the logarithm of the exponent back to the result.
+  Packet x;
   if (base2) {
     const Packet cst_log2e = pset1<Packet>(static_cast<float>(EIGEN_LOG2E));
-    x = pmadd(x, cst_log2e, e);
+    x = pmadd(log_mantissa, cst_log2e, e);
   } else {
     const Packet cst_ln2 = pset1<Packet>(static_cast<float>(EIGEN_LN2));
-    x = pmadd(e, cst_ln2, x);
+    x = pmadd(e, cst_ln2, log_mantissa);
   }
 
+  // Filter out invalid inputs:
+  //  - negative arg → NAN
+  //  - 0 → -INF
+  //  - +INF → +INF
+  const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
+  const Packet cst_pos_inf = pinf<Packet>();
   Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
   Packet iszero_mask = pcmp_eq(_x, pzero(_x));
   Packet pos_inf_mask = pcmp_eq(_x, cst_pos_inf);
-  // Filter out invalid inputs, i.e.:
-  //  - negative arg will be NAN
-  //  - 0 will be -INF
-  //  - +INF will be +INF
   return pselect(iszero_mask, cst_minus_inf, por(pselect(pos_inf_mask, cst_pos_inf, x), invalid_mask));
 }
 
@@ -99,6 +142,140 @@
   return plog_impl_float<Packet, /* base2 */ true>(_x);
 }
 
+// -----------------------------------------------------------------------
+// Double logarithm: shared polynomial + two range-reduction backends
+// -----------------------------------------------------------------------
+
+// Cephes rational-polynomial approximation of log(1+f) for
+// f in [sqrt(0.5)-1, sqrt(2)-1].
+// Evaluates x - 0.5*x^2 + x^3 * P(x)/Q(x) where P and Q are degree-5.
+// See: http://www.netlib.org/cephes/
+template <typename Packet>
+EIGEN_STRONG_INLINE Packet plog_mantissa_double(const Packet x) {
+  const Packet cst_cephes_log_p0 = pset1<Packet>(1.01875663804580931796E-4);
+  const Packet cst_cephes_log_p1 = pset1<Packet>(4.97494994976747001425E-1);
+  const Packet cst_cephes_log_p2 = pset1<Packet>(4.70579119878881725854E0);
+  const Packet cst_cephes_log_p3 = pset1<Packet>(1.44989225341610930846E1);
+  const Packet cst_cephes_log_p4 = pset1<Packet>(1.79368678507819816313E1);
+  const Packet cst_cephes_log_p5 = pset1<Packet>(7.70838733755885391666E0);
+  // Q0 = 1.0; pmadd(1, x, q1) simplifies to padd(x, q1).
+  const Packet cst_cephes_log_q1 = pset1<Packet>(1.12873587189167450590E1);
+  const Packet cst_cephes_log_q2 = pset1<Packet>(4.52279145837532221105E1);
+  const Packet cst_cephes_log_q3 = pset1<Packet>(8.29875266912776603211E1);
+  const Packet cst_cephes_log_q4 = pset1<Packet>(7.11544750618563894466E1);
+  const Packet cst_cephes_log_q5 = pset1<Packet>(2.31251620126765340583E1);
+
+  Packet x2 = pmul(x, x);
+  Packet x3 = pmul(x2, x);
+
+  // Evaluate P and Q simultaneously for better ILP.
+  Packet y, y1, y_;
+  y = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
+  y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
+  y = pmadd(y, x, cst_cephes_log_p2);
+  y1 = pmadd(y1, x, cst_cephes_log_p5);
+  y_ = pmadd(y, x3, y1);
+
+  y = padd(x, cst_cephes_log_q1);
+  y1 = pmadd(cst_cephes_log_q3, x, cst_cephes_log_q4);
+  y = pmadd(y, x, cst_cephes_log_q2);
+  y1 = pmadd(y1, x, cst_cephes_log_q5);
+  y = pmadd(y, x3, y1);
+
+  y_ = pmul(y_, x3);
+  y = pdiv(y_, y);
+  y = pnmadd(pset1<Packet>(0.5), x2, y);
+  return padd(x, y);
+}
+
+// Detect whether unpacket_traits<Packet>::integer_packet is defined.
+template <typename Packet, typename = void>
+struct packet_has_integer_packet : std::false_type {};
+template <typename Packet>
+struct packet_has_integer_packet<Packet, void_t<typename unpacket_traits<Packet>::integer_packet>> : std::true_type {};
+
+// Dispatch struct for double-precision range reduction.
+// Primary template: pfrexp-based fallback (used when integer_packet is absent).
+template <typename Packet, bool UseIntegerPacket>
+struct plog_range_reduce_double {
+  EIGEN_STRONG_INLINE static void run(const Packet v, Packet& f, Packet& e) {
+    const Packet one = pset1<Packet>(1.0);
+    const Packet cst_cephes_SQRTHF = pset1<Packet>(0.70710678118654752440E0);
+    // pfrexp: f in [0.5, 1), e = unbiased exponent as double.
+    f = pfrexp(v, e);
+    // Shift [0.5,1) -> [sqrt(0.5)-1, sqrt(2)-1] with exponent correction:
+    //   if f < sqrt(0.5): f = f + f - 1, e -= 1   (giving f in [0, sqrt(2)-1))
+    //   else:             f = f - 1                (giving f in [sqrt(0.5)-1, 0))
+    Packet mask = pcmp_lt(f, cst_cephes_SQRTHF);
+    Packet tmp = pand(f, mask);
+    f = psub(f, one);
+    e = psub(e, pand(one, mask));
+    f = padd(f, tmp);
+  }
+};
+
+// Specialisation: fast integer-bit-manipulation path (musl-inspired).
+// Requires unpacket_traits<Packet>::integer_packet to be a 64-bit integer packet.
+template <typename Packet>
+struct plog_range_reduce_double<Packet, true> {
+  EIGEN_STRONG_INLINE static void run(const Packet v, Packet& f, Packet& e) {
+    using PacketI = typename unpacket_traits<Packet>::integer_packet;
+    // 2^-1022: smallest positive normal double.
+    const PacketI cst_min_normal = pset1<PacketI>(static_cast<int64_t>(0x0010000000000000LL));
+    // Lower 52-bit mask (IEEE mantissa field).
+    const PacketI cst_mant_mask = pset1<PacketI>(static_cast<int64_t>(0x000FFFFFFFFFFFFFLL));
+    // Offset = 1.0_bits - sqrt(0.5)_bits.  Adding this to the integer
+    // representation shifts the exponent field so that the [sqrt(0.5), sqrt(2))
+    // half-octave boundary falls on an exact biased-exponent boundary, letting
+    // us extract e with a single right shift.  The constant is:
+    //   0x3FF0000000000000 - 0x3FE6A09E667F3BCD = 0x00095F619980C433
+    const PacketI cst_sqrt_half_offset =
+        pset1<PacketI>(static_cast<int64_t>(0x3FF0000000000000LL - 0x3FE6A09E667F3BCDLL));
+    // IEEE double exponent bias (1023).
+    const PacketI cst_exp_bias = pset1<PacketI>(static_cast<int64_t>(1023));
+    // sqrt(0.5) IEEE bits — used to reconstruct f from biased mantissa.
+    const PacketI cst_half_mant = pset1<PacketI>(static_cast<int64_t>(0x3FE6A09E667F3BCDLL));
+
+    // Reinterpret v as a 64-bit integer vector.
+    PacketI vi = preinterpret<PacketI>(v);
+
+    // Normalise denormals: multiply by 2^52 and correct the exponent by -52.
+    PacketI is_denormal = pcmp_lt(vi, cst_min_normal);
+    // 2^52 via bit pattern: biased exponent = 52 + 1023 = 0x433, mantissa = 0.
+    Packet v_norm = pmul(v, pset1frombits<Packet>(static_cast<uint64_t>(int64_t(52 + 0x3ff) << 52)));
+    vi = pselect(is_denormal, preinterpret<PacketI>(v_norm), vi);
+    PacketI denorm_adj = pand(is_denormal, pset1<PacketI>(static_cast<int64_t>(52)));
+
+    // Bias the integer representation so the exponent field directly encodes
+    // the half-octave index.
+    PacketI vi_biased = padd(vi, cst_sqrt_half_offset);
+    // Extract unbiased exponent: shift out mantissa bits, subtract IEEE bias
+    // and denormal adjustment.
+    PacketI e_int = psub(psub(plogical_shift_right<52>(vi_biased), cst_exp_bias), denorm_adj);
+    // Convert integer exponent to floating-point.
+    e = pcast<PacketI, Packet>(e_int);
+
+    // Reconstruct mantissa in [sqrt(0.5), sqrt(2)) via integer arithmetic.
+    // The integer addition of the masked mantissa bits and the sqrt(0.5) bit
+    // pattern carries into the exponent field, yielding a value in that range.
+    // Then subtract 1 to centre on 0: f in [sqrt(0.5)-1, sqrt(2)-1].
+    f = psub(preinterpret<Packet>(padd(pand(vi_biased, cst_mant_mask), cst_half_mant)), pset1<Packet>(1.0));
+  }
+};
+
+// Core range reduction and polynomial for double logarithm.
+// Input:  v > 0 (zero / negative / inf / nan are handled by the caller).
+// Output: log_mantissa ≈ log(mantissa of v in [sqrt(0.5), sqrt(2))),
+//         e            = unbiased exponent of v as a double.
+// Selects the fast integer path when integer_packet is available, otherwise
+// falls back to pfrexp.
+template <typename Packet>
+EIGEN_STRONG_INLINE void plog_core_double(const Packet v, Packet& log_mantissa, Packet& e) {
+  Packet f;
+  plog_range_reduce_double<Packet, packet_has_integer_packet<Packet>::value>::run(v, f, e);
+  log_mantissa = plog_mantissa_double(f);
+}
+
 /* Returns the base e (2.718...) or base 2 logarithm of x.
  * The argument is separated into its exponent and fractional parts.
  * The logarithm of the fraction in the interval [sqrt(1/2), sqrt(2)],
@@ -110,87 +287,29 @@
  */
 template <typename Packet, bool base2>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_impl_double(const Packet _x) {
-  Packet x = _x;
+  const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
+  const Packet cst_pos_inf = pinf<Packet>();
 
-  const Packet cst_1 = pset1<Packet>(1.0);
-  const Packet cst_neg_half = pset1<Packet>(-0.5);
-  const Packet cst_minus_inf = pset1frombits<Packet>(static_cast<uint64_t>(0xfff0000000000000ull));
-  const Packet cst_pos_inf = pset1frombits<Packet>(static_cast<uint64_t>(0x7ff0000000000000ull));
+  Packet log_mantissa, e;
+  plog_core_double(_x, log_mantissa, e);
 
-  // Polynomial Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
-  //                             1/sqrt(2) <= x < sqrt(2)
-  const Packet cst_cephes_SQRTHF = pset1<Packet>(0.70710678118654752440E0);
-  const Packet cst_cephes_log_p0 = pset1<Packet>(1.01875663804580931796E-4);
-  const Packet cst_cephes_log_p1 = pset1<Packet>(4.97494994976747001425E-1);
-  const Packet cst_cephes_log_p2 = pset1<Packet>(4.70579119878881725854E0);
-  const Packet cst_cephes_log_p3 = pset1<Packet>(1.44989225341610930846E1);
-  const Packet cst_cephes_log_p4 = pset1<Packet>(1.79368678507819816313E1);
-  const Packet cst_cephes_log_p5 = pset1<Packet>(7.70838733755885391666E0);
-
-  const Packet cst_cephes_log_q0 = pset1<Packet>(1.0);
-  const Packet cst_cephes_log_q1 = pset1<Packet>(1.12873587189167450590E1);
-  const Packet cst_cephes_log_q2 = pset1<Packet>(4.52279145837532221105E1);
-  const Packet cst_cephes_log_q3 = pset1<Packet>(8.29875266912776603211E1);
-  const Packet cst_cephes_log_q4 = pset1<Packet>(7.11544750618563894466E1);
-  const Packet cst_cephes_log_q5 = pset1<Packet>(2.31251620126765340583E1);
-
-  Packet e;
-  // extract significant in the range [0.5,1) and exponent
-  x = pfrexp(x, e);
-
-  // Shift the inputs from the range [0.5,1) to [sqrt(1/2),sqrt(2))
-  // and shift by -1. The values are then centered around 0, which improves
-  // the stability of the polynomial evaluation.
-  //   if( x < SQRTHF ) {
-  //     e -= 1;
-  //     x = x + x - 1.0;
-  //   } else { x = x - 1.0; }
-  Packet mask = pcmp_lt(x, cst_cephes_SQRTHF);
-  Packet tmp = pand(x, mask);
-  x = psub(x, cst_1);
-  e = psub(e, pand(cst_1, mask));
-  x = padd(x, tmp);
-
-  Packet x2 = pmul(x, x);
-  Packet x3 = pmul(x2, x);
-
-  // Evaluate the polynomial in factored form for better instruction-level parallelism.
-  // y = x - 0.5*x^2 + x^3 * polevl( x, P, 5 ) / p1evl( x, Q, 5 ) );
-  Packet y, y1, y_;
-  y = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
-  y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
-  y = pmadd(y, x, cst_cephes_log_p2);
-  y1 = pmadd(y1, x, cst_cephes_log_p5);
-  y_ = pmadd(y, x3, y1);
-
-  y = pmadd(cst_cephes_log_q0, x, cst_cephes_log_q1);
-  y1 = pmadd(cst_cephes_log_q3, x, cst_cephes_log_q4);
-  y = pmadd(y, x, cst_cephes_log_q2);
-  y1 = pmadd(y1, x, cst_cephes_log_q5);
-  y = pmadd(y, x3, y1);
-
-  y_ = pmul(y_, x3);
-  y = pdiv(y_, y);
-
-  y = pmadd(cst_neg_half, x2, y);
-  x = padd(x, y);
-
-  // Add the logarithm of the exponent back to the result of the interpolation.
+  // Combine: log(x) = e * ln2 + log(mantissa), or log2(x) = log(mantissa)*log2e + e.
+  Packet x;
   if (base2) {
     const Packet cst_log2e = pset1<Packet>(static_cast<double>(EIGEN_LOG2E));
-    x = pmadd(x, cst_log2e, e);
+    x = pmadd(log_mantissa, cst_log2e, e);
   } else {
     const Packet cst_ln2 = pset1<Packet>(static_cast<double>(EIGEN_LN2));
-    x = pmadd(e, cst_ln2, x);
+    x = pmadd(e, cst_ln2, log_mantissa);
   }
 
   Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
   Packet iszero_mask = pcmp_eq(_x, pzero(_x));
   Packet pos_inf_mask = pcmp_eq(_x, cst_pos_inf);
-  // Filter out invalid inputs, i.e.:
-  //  - negative arg will be NAN
-  //  - 0 will be -INF
-  //  - +INF will be +INF
+  // Filter out invalid inputs:
+  //  - negative arg → NAN
+  //  - 0            → -INF
+  //  - +INF         → +INF
   return pselect(iszero_mask, cst_minus_inf, por(pselect(pos_inf_mask, cst_pos_inf, x), invalid_mask));
 }
 
@@ -204,12 +323,93 @@
   return plog_impl_double<Packet, /* base2 */ true>(_x);
 }
 
+/** \internal \returns log(1 + x) for single precision float.
+    Computes log(1+x) using plog_core_float for the core range reduction
+    and polynomial evaluation. The rounding error from forming u = fl(1+x)
+    is recovered as dx = x - (u - 1), and folded in as a first-order
+    correction dx/u after the polynomial evaluation.
+ */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p_float(const Packet& x) {
+  const Packet one = pset1<Packet>(1.0f);
+  const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
+  const Packet cst_pos_inf = pinf<Packet>();
+
+  // u = 1 + x, with rounding. Recover the lost low bits: dx = x - (u - 1).
+  Packet u = padd(one, x);
+  Packet dx = psub(x, psub(u, one));
+
+  // For |x| tiny enough that u rounds to 1, return x directly.
+  Packet small_mask = pcmp_eq(u, one);
+  // For u = +inf (x very large), return +inf.
+  Packet inf_mask = pcmp_eq(u, cst_pos_inf);
+
+  // Core range reduction and polynomial on u.
+  Packet log_u, e;
+  plog_core_float(u, log_u, e);
+
+  // result = e * ln2 + log(u) + dx/u.
+  // The dx/u term corrects for the rounding error in u = fl(1+x).
+  const Packet cst_ln2 = pset1<Packet>(static_cast<float>(EIGEN_LN2));
+  Packet result = pmadd(e, cst_ln2, padd(log_u, pdiv(dx, u)));
+
+  // Handle special cases.
+  Packet neg_mask = pcmp_lt(u, pzero(u));
+  Packet zero_mask = pcmp_eq(x, pset1<Packet>(-1.0f));
+  result = pselect(small_mask, x, result);
+  result = pselect(inf_mask, cst_pos_inf, result);
+  result = pselect(zero_mask, cst_minus_inf, result);
+  result = por(neg_mask, result);  // NaN for x < -1
+  return result;
+}
+
+/** \internal \returns log(1 + x) for double precision.
+    Computes log(1+x) using plog_core_double for the core range reduction and
+    polynomial evaluation.  The rounding error from forming u = fl(1+x) is
+    recovered as dx = x - (u - 1) and folded in as a first-order correction
+    dx/u after the polynomial evaluation.
+ */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p_double(const Packet& x) {
+  const Packet one = pset1<Packet>(1.0);
+  const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
+  const Packet cst_pos_inf = pinf<Packet>();
+
+  // u = 1 + x, with rounding.  Recover the lost low bits: dx = x - (u - 1).
+  Packet u = padd(one, x);
+  Packet dx = psub(x, psub(u, one));
+
+  // For |x| tiny enough that u rounds to 1, return x directly.
+  Packet small_mask = pcmp_eq(u, one);
+  // For u = +inf (x very large), return +inf.
+  Packet inf_mask = pcmp_eq(u, cst_pos_inf);
+
+  // Core range reduction and polynomial on u.
+  Packet log_u, e;
+  plog_core_double(u, log_u, e);
+
+  // result = e * ln2 + log(u) + dx/u.
+  // The dx/u term corrects for the rounding error in u = fl(1+x).
+  const Packet cst_ln2 = pset1<Packet>(static_cast<double>(EIGEN_LN2));
+  Packet result = pmadd(e, cst_ln2, padd(log_u, pdiv(dx, u)));
+
+  // Handle special cases.
+  Packet neg_mask = pcmp_lt(u, pzero(u));
+  Packet zero_mask = pcmp_eq(x, pset1<Packet>(-1.0));
+  result = pselect(small_mask, x, result);
+  result = pselect(inf_mask, cst_pos_inf, result);
+  result = pselect(zero_mask, cst_minus_inf, result);
+  result = por(neg_mask, result);  // NaN for x < -1
+  return result;
+}
+
 /** \internal \returns log(1 + x) computed using W. Kahan's formula.
     See: http://www.plunk.org/~hatch/rightway.php
+    This is the generic fallback for types without a specialized implementation.
  */
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type ScalarType;
+  using ScalarType = typename unpacket_traits<Packet>::type;
   const Packet one = pset1<Packet>(ScalarType(1));
   Packet xp1 = padd(x, one);
   Packet small_mask = pcmp_eq(xp1, one);
@@ -224,7 +424,7 @@
  */
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_expm1(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type ScalarType;
+  using ScalarType = typename unpacket_traits<Packet>::type;
   const Packet one = pset1<Packet>(ScalarType(1));
   const Packet neg_one = pset1<Packet>(ScalarType(-1));
   Packet u = pexp(x);
@@ -243,17 +443,16 @@
 }
 
 // Exponential function. Works by writing "x = m*log(2) + r" where
-// "m = floor(x/log(2)+1/2)" and "r" is the remainder. The result is then
+// "m = rint(x/log(2))" and "r" is the remainder. The result is then
 // "exp(x) = 2^m*exp(r)" where exp(r) is in the range [-1,1).
 // exp(r) is computed using a 6th order minimax polynomial approximation.
 template <typename Packet, bool IsFinite>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp_float(const Packet _x) {
-  const Packet cst_zero = pset1<Packet>(0.0f);
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
+
   const Packet cst_one = pset1<Packet>(1.0f);
-  const Packet cst_half = pset1<Packet>(0.5f);
   const Packet cst_exp_hi = pset1<Packet>(88.723f);
   const Packet cst_exp_lo = pset1<Packet>(-104.f);
-  const Packet cst_pldexp_threshold = pset1<Packet>(87.0);
 
   const Packet cst_cephes_LOG2EF = pset1<Packet>(1.44269504088896341f);
   const Packet cst_p2 = pset1<Packet>(0.49999988079071044921875f);
@@ -261,23 +460,16 @@
   const Packet cst_p4 = pset1<Packet>(4.166965186595916748046875e-2f);
   const Packet cst_p5 = pset1<Packet>(8.36894474923610687255859375e-3f);
   const Packet cst_p6 = pset1<Packet>(1.37449637986719608306884765625e-3f);
-  Packet zero_mask;
-  Packet x;
-  if (!IsFinite) {
-    // Clamp x.
-    zero_mask = pcmp_lt(_x, cst_exp_lo);
-    x = pmin(_x, cst_exp_hi);
-  } else {
-    x = _x;
-  }
+
+  // Clamp x to prevent overflow/underflow.
+  Packet x = pmin(pmax(_x, cst_exp_lo), cst_exp_hi);
 
   // Express exp(x) as exp(m*ln(2) + r), start by extracting
-  // m = floor(x/ln(2) + 0.5).
-  Packet m = pfloor(pmadd(x, cst_cephes_LOG2EF, cst_half));
+  // m = rint(x/ln(2)).
+  Packet m = print(pmul(x, cst_cephes_LOG2EF));
 
-  // Get r = x - m*ln(2). If no FMA instructions are available, m*ln(2) is
-  // subtracted out in two parts, m*C1+m*C2 = m*ln(2), to avoid accumulating
-  // truncation errors.
+  // Get r = x - m*ln(2). m*ln(2) is subtracted out in two parts,
+  // m*C1+m*C2 = m*ln(2), to avoid accumulating truncation errors.
   const Packet cst_cephes_exp_C1 = pset1<Packet>(-0.693359375f);
   const Packet cst_cephes_exp_C2 = pset1<Packet>(2.12194440e-4f);
   Packet r = pmadd(m, cst_cephes_exp_C1, x);
@@ -292,17 +484,34 @@
   const Packet p_low = padd(r, cst_one);
   Packet y = pmadd(r, p_odd, p_even);
   y = pmadd(r2, y, p_low);
-  if (IsFinite) {
-    return pldexp_fast(y, m);
+
+  // Construct the result y * 2^m via a 2-way exponent split. Writing
+  //   2^m = 2^floor(m/2) * 2^(m - floor(m/2))
+  // keeps each constructed power-of-two within the normal float range (since
+  // |m| <= 150 after the input clamp implies each half lies in [-75, 65]), so
+  // the IEEE-correct rounding of normal*normal handles the subnormal output
+  // range without special-casing.
+  //
+  // To minimize integer ops we fold the bias into the split:
+  //   biased_sum = m + 254                      (always nonnegative)
+  //   biased_hi  = biased_sum >> 1  =  m/2 + 127
+  //   biased_lo  = biased_sum - biased_hi = (m - m/2) + 127
+  // so each <<23 directly yields the float bit pattern for 2^(m/2) and
+  // 2^(m - m/2).
+  const PacketI cst_double_bias = pset1<PacketI>(254);
+  const PacketI mi = pcast<Packet, PacketI>(m);
+  const PacketI biased_sum = padd(mi, cst_double_bias);
+  const PacketI biased_hi = plogical_shift_right<1>(biased_sum);  // m/2 + 127
+  const PacketI biased_lo = psub(biased_sum, biased_hi);          // (m - m/2) + 127
+  const Packet pow2_hi = preinterpret<Packet>(plogical_shift_left<23>(biased_hi));
+  const Packet pow2_lo = preinterpret<Packet>(plogical_shift_left<23>(biased_lo));
+  y = pmul(pmul(y, pow2_hi), pow2_lo);
+
+  EIGEN_IF_CONSTEXPR (!IsFinite) {
+    // Handle NaN: exp(nan) = nan. Use pmax to propagate NaN from input.
+    y = pmax(y, _x);
   }
-  // Return 2^m * exp(r).
-  const Packet fast_pldexp_unsafe = pcmp_lt(cst_pldexp_threshold, pabs(x));
-  if (!predux_any(fast_pldexp_unsafe)) {
-    // For |x| <= 87, we know the result is not zero or inf, and we can safely use
-    // the fast version of pldexp.
-    return pmax(pldexp_fast(y, m), _x);
-  }
-  return pselect(zero_mask, cst_zero, pmax(pldexp(y, m), _x));
+  return y;
 }
 
 template <typename Packet>
@@ -310,7 +519,6 @@
   const Packet cst_zero = pset1<Packet>(0.0);
   const Packet cst_1 = pset1<Packet>(1.0);
   const Packet cst_2 = pset1<Packet>(2.0);
-  const Packet cst_half = pset1<Packet>(0.5);
 
   const Packet cst_exp_hi = pset1<Packet>(709.784);
   const Packet cst_exp_lo = pset1<Packet>(-745.519);
@@ -326,25 +534,19 @@
   const Packet cst_cephes_exp_C1 = pset1<Packet>(0.693145751953125);
   const Packet cst_cephes_exp_C2 = pset1<Packet>(1.42860682030941723212e-6);
 
-  Packet tmp, fx;
-
-  // clamp x
+  // Clamp x.
   Packet zero_mask = pcmp_lt(_x, cst_exp_lo);
   Packet x = pmin(_x, cst_exp_hi);
 
   // Express exp(x) as exp(g + n*log(2)).
-  fx = pmadd(cst_cephes_LOG2EF, x, cst_half);
-
-  // Get the integer modulus of log(2), i.e. the "n" described above.
-  fx = pfloor(fx);
+  // n = rint(x / ln(2)).
+  Packet fx = print(pmul(x, cst_cephes_LOG2EF));
 
   // Get the remainder modulo log(2), i.e. the "g" described above. Subtract
   // n*log(2) out in two steps, i.e. n*C1 + n*C2, C1+C2=log2 to get the last
   // digits right.
-  tmp = pmul(fx, cst_cephes_exp_C1);
-  Packet z = pmul(fx, cst_cephes_exp_C2);
-  x = psub(x, tmp);
-  x = psub(x, z);
+  x = pnmadd(fx, cst_cephes_exp_C1, x);
+  x = pnmadd(fx, cst_cephes_exp_C2, x);
 
   Packet x2 = pmul(x, x);
 
@@ -360,9 +562,7 @@
   qx = pmadd(qx, x2, cst_cephes_exp_q2);
   qx = pmadd(qx, x2, cst_cephes_exp_q3);
 
-  // I don't really get this bit, copied from the SSE2 routines, so...
-  // TODO(gonnet): Figure out what is going on here, perhaps find a better
-  // rational interpolant?
+  // exp(g) = 1 + 2*px/(qx - px).
   x = pdiv(px, psub(qx, px));
   x = pmadd(cst_2, x, cst_1);
 
@@ -381,7 +581,7 @@
 // To improve accuracy, the product ln(2)*x is computed using the twoprod
 // algorithm, such that ln(2) * x = p_hi + p_lo holds exactly. Then exp2(x) is
 // computed as exp2(x) = exp(p_hi) * exp(p_lo) ~= exp(p_hi) * (1 + p_lo). This
-// correction step this reduces the maximum absolute error as follows:
+// correction step reduces the maximum absolute error as follows:
 //
 // type   | max error (simple product) | max error (twoprod) |
 // -----------------------------------------------------------
@@ -390,7 +590,7 @@
 //
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_exp2(const Packet& _x) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   constexpr int max_exponent = std::numeric_limits<Scalar>::max_exponent;
   constexpr int digits = std::numeric_limits<Scalar>::digits;
   constexpr Scalar max_cap = Scalar(max_exponent + 1);
@@ -403,6 +603,36 @@
   return pmul(exp2_hi, exp2_lo);
 }
 
+/** \internal \returns log10(x) for single precision float.
+    Computed as log(x) * log10(e).
+    Simply multiplying by a single float constant loses accuracy because
+    float(log10(e)) has rounding error. We use a hi+lo split instead:
+    log10(x) ~= log(x) * hi + log(x) * lo, computed via fma. */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10_float(const Packet& x) {
+  // log10(e) in higher precision, split into hi+lo so log_x*(hi+lo) is reconstructed via FMA.
+  // hi = round-to-nearest-float of log10(e); lo = float(log10(e) - hi).
+  const Packet cst_log10e_hi = pset1<Packet>(0.4342944920063018f);
+  const Packet cst_log10e_lo = pset1<Packet>(-1.0103049952192578e-08f);
+  const Packet cst_inf = pinf<Packet>();
+  const Packet cst_zero = pzero(x);
+
+  const Packet log_x = plog(x);
+  const Packet finite_mask = pcmp_lt(pabs(log_x), cst_inf);
+  const Packet finite_log_x = pselect(finite_mask, log_x, cst_zero);
+  const Packet split_log10_x = pmadd(finite_log_x, cst_log10e_hi, pmul(finite_log_x, cst_log10e_lo));
+  return pselect(finite_mask, split_log10_x, log_x);
+}
+
+/** \internal \returns log10(x) for double precision float.
+    Computed as log(x) * log10(e). For double, single-constant rounding error
+    is ~1e-17 (sub-ULP), so the simple form is precise enough. */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10_double(const Packet& x) {
+  const Packet cst_log10e = pset1<Packet>(0.43429448190325182);
+  return pmul(plog(x), cst_log10e);
+}
+
 }  // end namespace internal
 }  // end namespace Eigen
 
@@ -477,9 +707,9 @@
                                            NumTraits<typename unpacket_traits<Packet>::type>::IsComplex &&
                                            unpacket_traits<Packet>::vectorizable>> {
   static EIGEN_DEVICE_FUNC inline Packet run(const Packet& a) {
-    typedef typename unpacket_traits<Packet>::type Scalar;
-    typedef typename Scalar::value_type RealScalar;
-    typedef typename unpacket_traits<Packet>::as_real RealPacket;
+    using Scalar = typename unpacket_traits<Packet>::type;
+    using RealScalar = typename Scalar::value_type;
+    using RealPacket = typename unpacket_traits<Packet>::as_real;
 
     // Step 1. Compute (for each element z = x + i*y in a)
     //     l = abs(z) = sqrt(x^2 + y^2).
@@ -546,7 +776,7 @@
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_ceil(const Packet& a) {
   using Scalar = typename unpacket_traits<Packet>::type;
   const Packet cst_1 = pset1<Packet>(Scalar(1));
-  const Packet sign_mask = pset1<Packet>(static_cast<Scalar>(-0.0));
+  const Packet sign_mask = psignmask<Packet>();
   Packet rint_a = generic_rint(a);
   // if rint(a) < a, then rint(a) == floor(a)
   Packet mask = pcmp_lt(rint_a, a);
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
index 3bca1f8..0277fef 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_FWD_H
@@ -82,6 +83,26 @@
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p(const Packet& x);
 
+/** \internal \returns log(1+x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p_float(const Packet& x);
+
+/** \internal \returns log(1+x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p_double(const Packet& x);
+
+/** \internal \returns log(1+x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog1p_float(const Packet& x) {
+  return generic_log1p_float(x);
+}
+
+/** \internal \returns log(1+x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog1p_double(const Packet& x) {
+  return generic_log1p_double(x);
+}
+
 /** \internal \returns exp(x)-1 */
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_expm1(const Packet& x);
@@ -150,6 +171,46 @@
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet patanh_double(const Packet& x);
 
+/** \internal \returns sinh(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psinh_float(const Packet& x);
+
+/** \internal \returns sinh(x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psinh_double(const Packet& x);
+
+/** \internal \returns cosh(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcosh_float(const Packet& x);
+
+/** \internal \returns cosh(x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcosh_double(const Packet& x);
+
+/** \internal \returns asinh(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasinh_float(const Packet& x);
+
+/** \internal \returns asinh(x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasinh_double(const Packet& x);
+
+/** \internal \returns acosh(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacosh_float(const Packet& x);
+
+/** \internal \returns acosh(x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacosh_double(const Packet& x);
+
+/** \internal \returns log10(x) for single precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10_float(const Packet& x);
+
+/** \internal \returns log10(x) for double precision float */
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10_double(const Packet& x);
+
 /** \internal \returns sqrt(x) for complex types */
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psqrt_complex(const Packet& a);
@@ -211,30 +272,40 @@
   EIGEN_FLOAT_PACKET_FUNCTION(tan, PACKET)                 \
   EIGEN_FLOAT_PACKET_FUNCTION(asin, PACKET)                \
   EIGEN_FLOAT_PACKET_FUNCTION(acos, PACKET)                \
+  EIGEN_FLOAT_PACKET_FUNCTION(sinh, PACKET)                \
+  EIGEN_FLOAT_PACKET_FUNCTION(cosh, PACKET)                \
   EIGEN_FLOAT_PACKET_FUNCTION(tanh, PACKET)                \
+  EIGEN_FLOAT_PACKET_FUNCTION(asinh, PACKET)               \
+  EIGEN_FLOAT_PACKET_FUNCTION(acosh, PACKET)               \
   EIGEN_FLOAT_PACKET_FUNCTION(atanh, PACKET)               \
   EIGEN_FLOAT_PACKET_FUNCTION(log, PACKET)                 \
   EIGEN_FLOAT_PACKET_FUNCTION(log2, PACKET)                \
+  EIGEN_FLOAT_PACKET_FUNCTION(log10, PACKET)               \
   EIGEN_FLOAT_PACKET_FUNCTION(exp, PACKET)                 \
   EIGEN_FLOAT_PACKET_FUNCTION(cbrt, PACKET)                \
   EIGEN_GENERIC_PACKET_FUNCTION(expm1, PACKET)             \
   EIGEN_GENERIC_PACKET_FUNCTION(exp2, PACKET)              \
-  EIGEN_GENERIC_PACKET_FUNCTION(log1p, PACKET)             \
+  EIGEN_FLOAT_PACKET_FUNCTION(log1p, PACKET)               \
   EIGEN_GENERIC_PACKET_FUNCTION(atan, PACKET)
 
 #define EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_DOUBLE(PACKET) \
   EIGEN_DOUBLE_PACKET_FUNCTION(sin, PACKET)                 \
   EIGEN_DOUBLE_PACKET_FUNCTION(cos, PACKET)                 \
   EIGEN_DOUBLE_PACKET_FUNCTION(tan, PACKET)                 \
+  EIGEN_DOUBLE_PACKET_FUNCTION(sinh, PACKET)                \
+  EIGEN_DOUBLE_PACKET_FUNCTION(cosh, PACKET)                \
+  EIGEN_DOUBLE_PACKET_FUNCTION(tanh, PACKET)                \
+  EIGEN_DOUBLE_PACKET_FUNCTION(asinh, PACKET)               \
+  EIGEN_DOUBLE_PACKET_FUNCTION(acosh, PACKET)               \
+  EIGEN_DOUBLE_PACKET_FUNCTION(atanh, PACKET)               \
   EIGEN_DOUBLE_PACKET_FUNCTION(log, PACKET)                 \
   EIGEN_DOUBLE_PACKET_FUNCTION(log2, PACKET)                \
+  EIGEN_DOUBLE_PACKET_FUNCTION(log10, PACKET)               \
   EIGEN_DOUBLE_PACKET_FUNCTION(exp, PACKET)                 \
-  EIGEN_DOUBLE_PACKET_FUNCTION(tanh, PACKET)                \
-  EIGEN_DOUBLE_PACKET_FUNCTION(atanh, PACKET)               \
   EIGEN_DOUBLE_PACKET_FUNCTION(cbrt, PACKET)                \
   EIGEN_GENERIC_PACKET_FUNCTION(expm1, PACKET)              \
   EIGEN_GENERIC_PACKET_FUNCTION(exp2, PACKET)               \
-  EIGEN_GENERIC_PACKET_FUNCTION(log1p, PACKET)              \
+  EIGEN_DOUBLE_PACKET_FUNCTION(log1p, PACKET)               \
   EIGEN_GENERIC_PACKET_FUNCTION(atan, PACKET)
 
 // Macro to instantiate complex math function specializations (psqrt, plog, pexp)
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathPolynomials.h b/Eigen/src/Core/arch/Default/GenericPacketMathPolynomials.h
index a8ec6ae..601e3e6 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathPolynomials.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathPolynomials.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_POLYNOMIALS_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_POLYNOMIALS_H
@@ -58,19 +59,20 @@
  */
 template <typename Packet, int N>
 struct ppolevl {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x,
-                                                          const typename unpacket_traits<Packet>::type coeff[]) {
-    EIGEN_STATIC_ASSERT((N > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return pmadd(ppolevl<Packet, N - 1>::run(x, coeff), x, pset1<Packet>(coeff[N]));
+  template <int... Indices>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_impl(const Packet& x,
+                                                               const typename unpacket_traits<Packet>::type coeff[],
+                                                               std::integer_sequence<int, Indices...>) {
+    Packet result = pset1<Packet>(coeff[0]);
+    int unused[] = {0, (result = pmadd(result, x, pset1<Packet>(coeff[Indices + 1])), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+    return result;
   }
-};
 
-template <typename Packet>
-struct ppolevl<Packet, 0> {
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x,
                                                           const typename unpacket_traits<Packet>::type coeff[]) {
-    EIGEN_UNUSED_VARIABLE(x);
-    return pset1<Packet>(coeff[0]);
+    EIGEN_STATIC_ASSERT((N >= 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return run_impl(x, coeff, std::make_integer_sequence<int, (N > 0 ? N : 0)>{});
   }
 };
 
@@ -128,9 +130,9 @@
 
 template <typename Packet, int N>
 struct pchebevl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Packet run(Packet x,
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Packet run(const Packet& x,
                                                           const typename unpacket_traits<Packet>::type coef[]) {
-    typedef typename unpacket_traits<Packet>::type Scalar;
+    using Scalar = typename unpacket_traits<Packet>::type;
     Packet b0 = pset1<Packet>(coef[0]);
     Packet b1 = pset1<Packet>(static_cast<Scalar>(0.f));
     Packet b2;
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathPow.h b/Eigen/src/Core/arch/Default/GenericPacketMathPow.h
index 4ab75b9..06266e9 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathPow.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathPow.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_POW_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_POW_H
@@ -26,7 +27,7 @@
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet cbrt_halley_iteration_step(const Packet& x_k,
                                                                                       const Packet& y) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   Packet x_k_cb = pmul(x_k, pmul(x_k, x_k));
   Packet denom = pmadd(pset1<Packet>(Scalar(2)), x_k_cb, y);
   Packet num = psub(x_k_cb, y);
@@ -38,8 +39,8 @@
 // interval [0.125,1].
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet cbrt_decompose(const Packet& x, Packet& e_div3) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-  // Extract the significant s in the range [0.5,1) and exponent e, such that
+  using Scalar = typename unpacket_traits<Packet>::type;
+  // Extract the significand s in the range [0.5,1) and exponent e, such that
   // x = 2^e * s.
   Packet e, s;
   s = pfrexp(x, e);
@@ -57,10 +58,8 @@
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet cbrt_special_cases_and_sign(const Packet& x,
                                                                                        const Packet& abs_root) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
-
   // Set sign.
-  const Packet sign_mask = pset1<Packet>(Scalar(-0.0));
+  const Packet sign_mask = psignmask<Packet>();
   const Packet x_sign = pand(sign_mask, x);
   Packet root = por(x_sign, abs_root);
 
@@ -74,7 +73,7 @@
 // Generic implementation of cbrt(x) for float.
 //
 // The algorithm computes the cubic root of the input by first
-// decomposing it into a exponent and significant
+// decomposing it into an exponent and significand
 //   x = s * 2^e.
 //
 // We can then write the cube root as
@@ -101,7 +100,7 @@
 // This is accurate to 2 ULP.
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcbrt_float(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static_assert(std::is_same<Scalar, float>::value, "Scalar type must be float");
 
   // Decompose the input such that x^(1/3) = y^(1/3) * 2^e_div3, and y is in the
@@ -132,7 +131,7 @@
 // This is accurate to 1 ULP.
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcbrt_double(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static_assert(std::is_same<Scalar, double>::value, "Scalar type must be double");
 
   // Decompose the input such that x^(1/3) = y^(1/3) * 2^e_div3, and y is in the
@@ -209,7 +208,7 @@
     const Packet one = pset1<Packet>(1.0f);
     const Packet x = psub(z, one);
     Packet p = ppolevl<Packet, 8>::run(x, c);
-    // Evaluate the final two step in Horner's rule using double-word
+    // Evaluate the final two steps in Horner's rule using double-word
     // arithmetic.
     Packet p_hi, p_lo;
     twoprod(x, p, p_hi, p_lo);
@@ -307,7 +306,7 @@
     Packet p3_hi, p3_lo;
     fast_twosum(one, p2_hi, p2_lo, p3_hi, p3_lo);
 
-    // log(z) ~= ((Q(r^2) * r^2 + C) * r^2 + 1) * r
+    // log2(x) ~= ((Q(r^2) * r^2 + C) * r^2 + 1) * r
     twoprod(p3_hi, p3_lo, r_hi, r_lo, log2_x_hi, log2_x_lo);
   }
 };
@@ -319,7 +318,7 @@
 // easier to specialize or turn off for specific types and/or backends.
 template <typename Packet>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_pow_impl(const Packet& x, const Packet& y) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   // Split x into exponent e_x and mantissa m_x.
   Packet e_x;
   Packet m_x = pfrexp(x, e_x);
@@ -376,12 +375,12 @@
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS std::enable_if_t<!is_scalar<Packet>::value, Packet> generic_pow(
     const Packet& x, const Packet& y) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
 
-  const Packet cst_inf = pset1<Packet>(NumTraits<Scalar>::infinity());
+  const Packet cst_inf = pinf<Packet>();
   const Packet cst_zero = pset1<Packet>(Scalar(0));
   const Packet cst_one = pset1<Packet>(Scalar(1));
-  const Packet cst_nan = pset1<Packet>(NumTraits<Scalar>::quiet_NaN());
+  const Packet cst_nan = pnan<Packet>();
 
   const Packet x_abs = pabs(x);
   Packet result = generic_pow_impl(x_abs, y);
@@ -574,8 +573,8 @@
   using Scalar = typename unpacket_traits<Packet>::type;
   const Packet cst_zero = pzero(x);
   const Packet cst_one = pset1<Packet>(Scalar(1));
-  const Packet cst_inf = pset1<Packet>(NumTraits<Scalar>::infinity());
-  const Packet cst_nan = pset1<Packet>(NumTraits<Scalar>::quiet_NaN());
+  const Packet cst_inf = pinf<Packet>();
+  const Packet cst_nan = pnan<Packet>();
 
   const Packet abs_x = pabs(x);
 
@@ -672,7 +671,7 @@
 
 template <typename Packet, typename ScalarExponent, bool ExponentIsSigned>
 struct unary_pow_impl<Packet, ScalarExponent, false, false, ExponentIsSigned> {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const ScalarExponent& exponent) {
     const bool exponent_is_integer = (numext::isfinite)(exponent) && numext::round(exponent) == exponent;
     if (exponent_is_integer) {
@@ -692,7 +691,7 @@
 
 template <typename Packet, typename ScalarExponent, bool ExponentIsSigned>
 struct unary_pow_impl<Packet, ScalarExponent, false, true, ExponentIsSigned> {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const ScalarExponent& exponent) {
     return unary_pow::int_pow(x, exponent);
   }
@@ -700,7 +699,7 @@
 
 template <typename Packet, typename ScalarExponent>
 struct unary_pow_impl<Packet, ScalarExponent, true, true, true> {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const ScalarExponent& exponent) {
     if (exponent < ScalarExponent(0)) {
       return unary_pow::handle_negative_exponent(x, exponent);
@@ -712,7 +711,7 @@
 
 template <typename Packet, typename ScalarExponent>
 struct unary_pow_impl<Packet, ScalarExponent, true, true, false> {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& x, const ScalarExponent& exponent) {
     return unary_pow::int_pow(x, exponent);
   }
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathTrig.h b/Eigen/src/Core/arch/Default/GenericPacketMathTrig.h
index 1d7c594..3949bc8 100644
--- a/Eigen/src/Core/arch/Default/GenericPacketMathTrig.h
+++ b/Eigen/src/Core/arch/Default/GenericPacketMathTrig.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_TRIG_H
 #define EIGEN_ARCH_GENERIC_PACKET_MATH_TRIG_H
@@ -56,7 +57,7 @@
   // Below, -118 = -126 + 8.
   //   -126 is to get the exponent,
   //   +8 is to enable alignment of 2/pi's bits on 8 bits.
-  // This is possible because the fractional part of x as only 24 meaningful bits.
+  // This is possible because the fractional part of x has only 24 meaningful bits.
   uint32_t e = (xi >> 23) - 118;
   // Extract the mantissa and shift it to align it wrt the exponent
   xi = ((xi & 0x007fffffu) | 0x00800000u) << (e & 0x7);
@@ -78,7 +79,7 @@
   // Now it remains to compute "r = x - q*pi/2" with high accuracy,
   // since we have p=x/(pi/2) with high accuracy, we can more efficiently compute r as:
   //   r = (p-q)*pi/2,
-  // where the product can be be carried out with sufficient accuracy using double precision.
+  // where the product can be carried out with sufficient accuracy using double precision.
   p -= q << 62;
   return float(double(int64_t(p)) * pio2_62);
 }
@@ -90,12 +91,12 @@
 #endif
     Packet
     psincos_float(const Packet& _x) {
-  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
 
   const Packet cst_2oPI = pset1<Packet>(0.636619746685028076171875f);  // 2/PI
   const Packet cst_rounding_magic = pset1<Packet>(12582912);           // 2^23 for rounding
   const PacketI csti_1 = pset1<PacketI>(1);
-  const Packet cst_sign_mask = pset1frombits<Packet>(static_cast<Eigen::numext::uint32_t>(0x80000000u));
+  const Packet cst_sign_mask = psignmask<Packet>();
 
   Packet x = pabs(_x);
 
@@ -148,9 +149,9 @@
 
   if (predux_any(pcmp_le(pset1<Packet>(huge_th), pabs(_x)))) {
     const int PacketSize = unpacket_traits<Packet>::size;
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) float vals[PacketSize];
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) float x_cpy[PacketSize];
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) Eigen::numext::int32_t y_int2[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) float vals[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) float x_cpy[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Eigen::numext::int32_t y_int2[PacketSize];
     pstoreu(vals, pabs(_x));
     pstoreu(x_cpy, x);
     pstoreu(y_int2, y_int);
@@ -175,7 +176,7 @@
   y1 = pmadd(y1, x2, pset1<Packet>(-0.5f));
   y1 = pmadd(y1, x2, pset1<Packet>(1.f));
 
-  // Evaluate the sin(x) polynomial. (Pi/4 <= x <= Pi/4)
+  // Evaluate the sin(x) polynomial. (-Pi/4 <= x <= Pi/4)
   // octave/matlab code to compute those coefficients:
   //    x = (0:0.0001:pi/4)';
   //    A = [x.^3 x.^5 x.^7];
@@ -198,7 +199,6 @@
   sign_bit = pand(sign_bit, cst_sign_mask);  // clear all but left most bit
 
   if ((Func == TrigFunction::SinCos) || (Func == TrigFunction::Tan)) {
-    // TODO(rmlarsen): Add single polynomial for tan(x) instead of paying for sin+cos+div.
     Packet peven = peven_mask(x);
     Packet ysin = pselect(poly_mask, y2, y1);
     Packet ycos = pselect(poly_mask, y1, y2);
@@ -230,41 +230,58 @@
   return psincos_float<TrigFunction::Tan>(x);
 }
 
-// Trigonometric argument reduction for double for inputs smaller than 15.
-// Reduces trigonometric arguments for double inputs where x < 15. Given an argument x and its corresponding quadrant
-// count n, the function computes and returns the reduced argument t such that x = n * pi/2 + t.
+// Pi/2 split into 3 double-precision parts (triple-double).
+// c1 + c2 + c3 = pi/2 to ~159 bits. Computed by Sollya.
+// c1 = RD(pi/2), c2 = RD(pi/2 - c1), c3 = RD(pi/2 - c1 - c2).
 template <typename Packet>
-Packet trig_reduce_small_double(const Packet& x, const Packet& q) {
-  // Pi/2 split into 2 values
-  const Packet cst_pio2_a = pset1<Packet>(-1.570796325802803);
-  const Packet cst_pio2_b = pset1<Packet>(-9.920935184482005e-10);
-
-  Packet t;
-  t = pmadd(cst_pio2_a, q, x);
-  t = pmadd(cst_pio2_b, q, t);
-  return t;
+Packet cst_pio2_1() {
+  return pset1<Packet>(-1.5707963267948965579989817342720925807952880859375);  // -0x1.921fb54442d18p0
+}
+template <typename Packet>
+Packet cst_pio2_2() {
+  return pset1<Packet>(-6.12323399573676603586882014729198302312846062338790e-17);  // -0x1.1a62633145c07p-54
+}
+template <typename Packet>
+Packet cst_pio2_3() {
+  return pset1<Packet>(1.4973849048591698329435081771059920083527504761695190e-33);  //  0x1.f1976b7ed8fbcp-110
 }
 
-// Trigonometric argument reduction for double for inputs smaller than 1e14.
-// Reduces trigonometric arguments for double inputs where x < 1e14. Given an argument x and its corresponding quadrant
-// count n, the function computes and returns the reduced argument t such that x = n * pi/2 + t.
+// Trigonometric argument reduction for double.
+// Reduces x to t such that x + q * pi/2 = t, where |t| <= pi/4.
+// Uses a triple-double split of pi/2 (cst_pio2_{1,2,3}).
 template <typename Packet>
-Packet trig_reduce_medium_double(const Packet& x, const Packet& q_high, const Packet& q_low) {
-  // Pi/2 split into 4 values
-  const Packet cst_pio2_a = pset1<Packet>(-1.570796325802803);
-  const Packet cst_pio2_b = pset1<Packet>(-9.920935184482005e-10);
-  const Packet cst_pio2_c = pset1<Packet>(-6.123234014771656e-17);
-  const Packet cst_pio2_d = pset1<Packet>(1.903488962019325e-25);
-
+Packet trig_reduce_small_double(const Packet& x, const Packet& q) {
+#ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+  // With FMA, pmadd(a, b, c) = fl(a*b + c) in a single rounding,
+  // so Cody-Waite reduction is accurate even under catastrophic cancellation.
   Packet t;
-  t = pmadd(cst_pio2_a, q_high, x);
-  t = pmadd(cst_pio2_a, q_low, t);
-  t = pmadd(cst_pio2_b, q_high, t);
-  t = pmadd(cst_pio2_b, q_low, t);
-  t = pmadd(cst_pio2_c, q_high, t);
-  t = pmadd(cst_pio2_c, q_low, t);
-  t = pmadd(cst_pio2_d, padd(q_low, q_high), t);
+  t = pmadd(cst_pio2_1<Packet>(), q, x);
+  t = pmadd(cst_pio2_2<Packet>(), q, t);
+  t = pmadd(cst_pio2_3<Packet>(), q, t);
   return t;
+#else
+  // Without FMA, pmadd is mul + add (two roundings). For large q,
+  // pmul(pio2_1, q) rounds before the cancellation with x, losing
+  // catastrophic amounts of precision (observed: ~10 digits lost).
+  // Use error-free transformations to preserve accuracy.
+
+  // Compute q * pio2_1 exactly as a double-word using Dekker's algorithm.
+  Packet qp_hi, qp_lo;
+  twoprod(cst_pio2_1<Packet>(), q, qp_hi, qp_lo);
+
+  // Error-free addition of x and qp_hi using Knuth's 2sum.
+  // Returns t_hi + t_lo = x + qp_hi exactly, with t_hi = fl(x + qp_hi).
+  Packet t_hi = padd(x, qp_hi);
+  Packet v = psub(t_hi, x);
+  Packet t_lo = padd(psub(x, psub(t_hi, v)), psub(qp_hi, v));
+
+  // Accumulate the low part of the product and the remaining pi/2 terms.
+  t_lo = padd(t_lo, qp_lo);
+  t_lo = pmadd(cst_pio2_2<Packet>(), q, t_lo);
+  t_lo = pmadd(cst_pio2_3<Packet>(), q, t_lo);
+
+  return padd(t_hi, t_lo);
+#endif
 }
 
 template <TrigFunction Func, typename Packet>
@@ -274,21 +291,23 @@
 #endif
     Packet
     psincos_double(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::integer_packet PacketI;
-  typedef typename unpacket_traits<PacketI>::type ScalarI;
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
+  using ScalarI = typename unpacket_traits<PacketI>::type;
 
-  const Packet cst_sign_mask = pset1frombits<Packet>(static_cast<Eigen::numext::uint64_t>(0x8000000000000000u));
+  const Packet cst_sign_mask = psignmask<Packet>();
 
   // If the argument is smaller than this value, use a simpler argument reduction
   const double small_th = 15;
   // If the argument is bigger than this value, use the non-vectorized std version
   const double huge_th = 1e14;
 
-  const Packet cst_2oPI = pset1<Packet>(0.63661977236758134307553505349006);  // 2/PI
+  // 2/PI as a double-word: hi + lo = 2/pi to ~107 bits. Computed by Sollya.
+  const Packet cst_2oPI_hi =
+      pset1<Packet>(0.63661977236758138243288840385503135621547698974609375);  // 0x1.45f306dc9c883p-1
+  const Packet cst_2oPI_lo =
+      pset1<Packet>(-3.9357353350364971763790381828183628368294820823718866e-17);  // -0x1.6b01ec5417056p-55
   // Integer Packet constants
   const PacketI cst_one = pset1<PacketI>(ScalarI(1));
-  // Constant for splitting
-  const Packet cst_split = pset1<Packet>(1 << 24);
 
   Packet x_abs = pabs(x);
 
@@ -296,78 +315,57 @@
   PacketI q_int;
   Packet s;
 
-  // TODO Implement huge angle argument reduction
   if (EIGEN_PREDICT_FALSE(predux_any(pcmp_le(pset1<Packet>(small_th), x_abs)))) {
-    Packet q_high = pmul(pfloor(pmul(x_abs, pdiv(cst_2oPI, cst_split))), cst_split);
-    Packet q_low_noround = psub(pmul(x_abs, cst_2oPI), q_high);
-    q_int = pcast<Packet, PacketI>(padd(q_low_noround, pset1<Packet>(0.5)));
-    Packet q_low = pcast<PacketI, Packet>(q_int);
-    s = trig_reduce_medium_double(x_abs, q_high, q_low);
+    // Medium path: use double-word product x * (2/pi) for precise quadrant computation.
+    Packet prod_hi, prod_lo;
+    twoprod(x_abs, cst_2oPI_hi, prod_hi, prod_lo);
+    // Correction for 2/pi truncation: add x * lo(2/pi)
+    prod_lo = pmadd(x_abs, cst_2oPI_lo, prod_lo);
+
+    // Round the double-word (prod_hi, prod_lo) to the nearest integer.
+    Packet q = pround(prod_hi);
+    // Compute exact fractional part to check if rounding was correct.
+    Packet frac = padd(psub(prod_hi, q), prod_lo);
+    // Correct if fractional part crossed +-0.5 boundary.
+    q = padd(q, pand(pcmp_lt(pset1<Packet>(0.5), frac), pset1<Packet>(1.0)));
+    q = padd(q, pand(pcmp_lt(frac, pset1<Packet>(-0.5)), pset1<Packet>(-1.0)));
+
+    q_int = pcast<Packet, PacketI>(q);
+    s = trig_reduce_small_double(x_abs, q);
   } else {
-    Packet qval_noround = pmul(x_abs, cst_2oPI);
+    // Small path: simple reduction with triple-double pi/2 split.
+    Packet qval_noround = pmul(x_abs, cst_2oPI_hi);
     q_int = pcast<Packet, PacketI>(padd(qval_noround, pset1<Packet>(0.5)));
     Packet q = pcast<PacketI, Packet>(q_int);
     s = trig_reduce_small_double(x_abs, q);
   }
 
-  // All the upcoming approximating polynomials have even exponents
   Packet ss = pmul(s, s);
 
-  // Padé approximant of cos(x)
-  // Assuring < 1 ULP error on the interval [-pi/4, pi/4]
-  // cos(x) ~= (80737373*x^8 - 13853547000*x^6 + 727718024880*x^4 - 11275015752000*x^2 + 23594700729600)/(147173*x^8 +
-  // 39328920*x^6 + 5772800880*x^4 + 522334612800*x^2 + 23594700729600)
-  // MATLAB code to compute those coefficients:
-  //    syms x;
-  //    cosf = @(x) cos(x);
-  //    pade_cosf = pade(cosf(x), x, 0, 'Order', 8)
-  const Packet cn4 = pset1<Packet>(80737373);
-  const Packet cn3 = pset1<Packet>(-13853547000);
-  const Packet cn2 = pset1<Packet>(727718024880);
-  const Packet cn1 = pset1<Packet>(-11275015752000);
-  const Packet cn0 = pset1<Packet>(23594700729600);  // shared with cd0
-  const Packet cd3 = pset1<Packet>(147173);
-  const Packet cd2 = pset1<Packet>(39328920);
-  const Packet cd1 = pset1<Packet>(5772800880);
-  const Packet cd0 = pset1<Packet>(522334612800);
-  Packet sc1_num = pmadd(ss, cn4, cn3);
-  Packet sc2_num = pmadd(sc1_num, ss, cn2);
-  Packet sc3_num = pmadd(sc2_num, ss, cn1);
-  Packet sc4_num = pmadd(sc3_num, ss, cn0);
-  Packet sc1_denum = pmadd(ss, cd3, cd2);
-  Packet sc2_denum = pmadd(sc1_denum, ss, cd1);
-  Packet sc3_denum = pmadd(sc2_denum, ss, cd0);
-  Packet sc4_denum = pmadd(sc3_denum, ss, cn0);
-  Packet scos = pdiv(sc4_num, sc4_denum);
+  // Minimax polynomial approximation of cos(x) on [-pi/4, pi/4].
+  // cos(x) = 1 + u * P(u), where u = x^2 and P is degree 6 (7 FMAs total).
+  // Coefficients computed by Sollya fpminimax. Max polynomial error ~1.3e-19.
+  Packet scos = pset1<Packet>(-1.1368926065317776472832699312119132152576472805094454088248312473297119140625e-11);
+  scos = pmadd(scos, ss, pset1<Packet>(2.0875905481768720039634091158002593413556269297259859740734100341796875e-09));
+  scos = pmadd(scos, ss, pset1<Packet>(-2.7557315712466412785356544880299711763882442028261721134185791015625e-07));
+  scos = pmadd(scos, ss, pset1<Packet>(2.480158729424286522739599714082459058772656135261058807373046875e-05));
+  scos = pmadd(scos, ss, pset1<Packet>(-1.388888888888178789471350427220386336557567119598388671875e-03));
+  scos = pmadd(scos, ss, pset1<Packet>(4.166666666666664353702032030923874117434024810791015625e-02));
+  scos = pmadd(scos, ss, pset1<Packet>(-0.5));
+  scos = pmadd(scos, ss, pset1<Packet>(1.0));
 
-  // Padé approximant of sin(x)
-  // Assuring < 1 ULP error on the interval [-pi/4, pi/4]
-  // sin(x) ~= (x*(4585922449*x^8 - 1066023933480*x^6 + 83284044283440*x^4 - 2303682236856000*x^2 +
-  // 15605159573203200))/(45*(1029037*x^8 + 345207016*x^6 + 61570292784*x^4 + 6603948711360*x^2 + 346781323848960))
-  // MATLAB code to compute those coefficients:
-  //    syms x;
-  //    sinf = @(x) sin(x);
-  //    pade_sinf = pade(sinf(x), x, 0, 'Order', 8, 'OrderMode', 'relative')
-  const Packet sn4 = pset1<Packet>(4585922449);
-  const Packet sn3 = pset1<Packet>(-1066023933480);
-  const Packet sn2 = pset1<Packet>(83284044283440);
-  const Packet sn1 = pset1<Packet>(-2303682236856000);
-  const Packet sn0 = pset1<Packet>(15605159573203200);
-  const Packet sd3 = pset1<Packet>(1029037);
-  const Packet sd2 = pset1<Packet>(345207016);
-  const Packet sd1 = pset1<Packet>(61570292784);
-  const Packet sd0_inner = pset1<Packet>(6603948711360);
-  const Packet sd0 = pset1<Packet>(346781323848960);
-  const Packet cst_45 = pset1<Packet>(45);
-  Packet ss1_num = pmadd(ss, sn4, sn3);
-  Packet ss2_num = pmadd(ss1_num, ss, sn2);
-  Packet ss3_num = pmadd(ss2_num, ss, sn1);
-  Packet ss4_num = pmadd(ss3_num, ss, sn0);
-  Packet ss1_denum = pmadd(ss, sd3, sd2);
-  Packet ss2_denum = pmadd(ss1_denum, ss, sd1);
-  Packet ss3_denum = pmadd(ss2_denum, ss, sd0_inner);
-  Packet ss4_denum = pmadd(ss3_denum, ss, sd0);
-  Packet ssin = pdiv(pmul(s, ss4_num), pmul(cst_45, ss4_denum));
+  // Minimax polynomial approximation of sin(x) on [-pi/4, pi/4].
+  // sin(x) = x * (1 + u * R(u)), where u = x^2 and R is degree 5.
+  // Computed as: x + x * u * R(u) (6 FMAs + 1 mul).
+  // Coefficients computed by Sollya fpminimax. Max polynomial error ~1.0e-17.
+  Packet ssin = pset1<Packet>(1.59193066075142890698150587293845624470289834562208852730691432952880859375e-10);
+  ssin = pmadd(ssin, ss, pset1<Packet>(-2.50511517945670206974594627392927126408039839589037001132965087890625e-08));
+  ssin = pmadd(ssin, ss, pset1<Packet>(2.755731622544328228235042954619160582296899519860744476318359375e-06));
+  ssin = pmadd(ssin, ss, pset1<Packet>(-1.9841269837089632013978068858506276228581555187702178955078125e-04));
+  ssin = pmadd(ssin, ss, pset1<Packet>(8.333333333331312264835588621281203813850879669189453125e-03));
+  ssin = pmadd(ssin, ss, pset1<Packet>(-0.1666666666666666574148081281236954964697360992431640625));
+  ssin = pmul(ssin, ss);
+  ssin = pmadd(ssin, s, s);
 
   Packet poly_mask = preinterpret<Packet>(pcmp_eq(pand(q_int, cst_one), pzero(q_int)));
 
@@ -381,7 +379,6 @@
     sign_bit = sign_cos;
     sFinalRes = pselect(poly_mask, scos, ssin);
   } else if (Func == TrigFunction::Tan) {
-    // TODO(rmlarsen): Add single polynomial for tan(x) instead of paying for sin+cos+div.
     sign_bit = pxor(sign_sin, sign_cos);
     sFinalRes = pdiv(pselect(poly_mask, ssin, scos), pselect(poly_mask, scos, ssin));
   } else if (Func == TrigFunction::SinCos) {
@@ -392,26 +389,26 @@
   sign_bit = pand(sign_bit, cst_sign_mask);  // clear all but left most bit
   sFinalRes = pxor(sFinalRes, sign_bit);
 
-  // If the inputs values are higher than that a value that the argument reduction can currently address, compute them
-  // using the C++ standard library.
-  // TODO Remove it when huge angle argument reduction is implemented
+  // For inputs above huge_th the medium-path reduction loses too much precision. A vectorized
+  // Payne-Hanek reduction was investigated and judged not worthwhile (high implementation cost
+  // for what is in practice a rare path), so these inputs fall back to the scalar libm.
   if (EIGEN_PREDICT_FALSE(predux_any(pcmp_le(pset1<Packet>(huge_th), x_abs)))) {
     const int PacketSize = unpacket_traits<Packet>::size;
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) double sincos_vals[PacketSize];
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(Packet)) double x_cpy[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) double sincos_vals[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) double x_cpy[PacketSize];
     pstoreu(x_cpy, x);
     pstoreu(sincos_vals, sFinalRes);
     for (int k = 0; k < PacketSize; ++k) {
       double val = x_cpy[k];
-      if (std::abs(val) > huge_th && (numext::isfinite)(val)) {
+      if (numext::abs(val) > huge_th && (numext::isfinite)(val)) {
         if (Func == TrigFunction::Sin) {
-          sincos_vals[k] = std::sin(val);
+          sincos_vals[k] = numext::sin(val);
         } else if (Func == TrigFunction::Cos) {
-          sincos_vals[k] = std::cos(val);
+          sincos_vals[k] = numext::cos(val);
         } else if (Func == TrigFunction::Tan) {
-          sincos_vals[k] = std::tan(val);
+          sincos_vals[k] = numext::tan(val);
         } else if (Func == TrigFunction::SinCos) {
-          sincos_vals[k] = k % 2 == 0 ? std::sin(val) : std::cos(val);
+          sincos_vals[k] = k % 2 == 0 ? numext::sin(val) : numext::cos(val);
         }
       }
     }
@@ -456,7 +453,7 @@
 // Generic implementation of acos(x).
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacos_float(const Packet& x_in) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static_assert(std::is_same<Scalar, float>::value, "Scalar type must be float");
 
   const Packet cst_one = pset1<Packet>(Scalar(1));
@@ -499,7 +496,7 @@
 // Generic implementation of asin(x).
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasin_float(const Packet& x_in) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static_assert(std::is_same<Scalar, float>::value, "Scalar type must be float");
 
   constexpr float kPiOverTwo = static_cast<float>(EIGEN_PI / 2);
@@ -578,11 +575,11 @@
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_atan(const Packet& x_in) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
 
   constexpr Scalar kPiOverTwo = static_cast<Scalar>(EIGEN_PI / 2);
 
-  const Packet cst_signmask = pset1<Packet>(Scalar(-0.0));
+  const Packet cst_signmask = psignmask<Packet>();
   const Packet cst_one = pset1<Packet>(Scalar(1));
   const Packet cst_pi_over_two = pset1<Packet>(kPiOverTwo);
 
@@ -682,7 +679,7 @@
   const T q = ppolevl<T, 2>::run(x2, beta);
   const T small_tanh = pmadd(x3, pdiv(p, q), x);
 
-  const T sign_mask = pset1<T>(-0.0f);
+  const T sign_mask = psignmask<T>();
   const T abs_x = pandnot(x, sign_mask);
   constexpr float kSmallThreshold = 1.25f;
   const T large_mask = pcmp_lt(pset1<T>(kSmallThreshold), abs_x);
@@ -767,7 +764,7 @@
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet patanh_float(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static_assert(std::is_same<Scalar, float>::value, "Scalar type must be float");
 
   // For |x| in [0:0.5] we use a polynomial approximation of the form
@@ -779,24 +776,29 @@
   Packet p = ppolevl<Packet, 4>::run(x2, alpha);
   p = pmadd(x3, p, x);
 
-  // For |x| in ]0.5:1.0] we use atanh = 0.5*ln((1+x)/(1-x));
   const Packet half = pset1<Packet>(0.5f);
   const Packet one = pset1<Packet>(1.0f);
+  const Packet x_gt_half = pcmp_le(half, pabs(x));
+  // Fast exit: if all |x| <= 0.5, skip the expensive plog/pdiv branch.
+  if (!predux_any(x_gt_half)) {
+    return p;
+  }
+
+  // For |x| in ]0.5:1.0] we use atanh = 0.5*ln((1+x)/(1-x));
   Packet r = pdiv(padd(one, x), psub(one, x));
   r = pmul(half, plog(r));
 
-  const Packet x_gt_half = pcmp_le(half, pabs(x));
   const Packet x_eq_one = pcmp_eq(one, pabs(x));
   const Packet x_gt_one = pcmp_lt(one, pabs(x));
-  const Packet sign_mask = pset1<Packet>(-0.0f);
+  const Packet sign_mask = psignmask<Packet>();
   const Packet x_sign = pand(sign_mask, x);
-  const Packet inf = pset1<Packet>(std::numeric_limits<float>::infinity());
+  const Packet inf = pinf<Packet>();
   return por(x_gt_one, pselect(x_eq_one, por(x_sign, inf), pselect(x_gt_half, r, p)));
 }
 
 template <typename Packet>
 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet patanh_double(const Packet& x) {
-  typedef typename unpacket_traits<Packet>::type Scalar;
+  using Scalar = typename unpacket_traits<Packet>::type;
   static_assert(std::is_same<Scalar, double>::value, "Scalar type must be double");
   // For x in [-0.5:0.5] we use a rational approximation of the form
   // R(x) = x + x^3*P(x^2)/Q(x^2), where P is or order 4 and Q is of order 5.
@@ -812,21 +814,268 @@
   Packet q = ppolevl<Packet, 5>::run(x2, beta);
   Packet y_small = pmadd(x3, pdiv(p, q), x);
 
-  // For |x| in ]0.5:1.0] we use atanh = 0.5*ln((1+x)/(1-x));
   const Packet half = pset1<Packet>(0.5);
   const Packet one = pset1<Packet>(1.0);
+  const Packet x_gt_half = pcmp_le(half, pabs(x));
+  // Fast exit: if all |x| <= 0.5, skip the expensive plog/pdiv branch.
+  if (!predux_any(x_gt_half)) {
+    return y_small;
+  }
+
+  // For |x| in ]0.5:1.0] we use atanh = 0.5*ln((1+x)/(1-x));
   Packet y_large = pdiv(padd(one, x), psub(one, x));
   y_large = pmul(half, plog(y_large));
 
-  const Packet x_gt_half = pcmp_le(half, pabs(x));
   const Packet x_eq_one = pcmp_eq(one, pabs(x));
   const Packet x_gt_one = pcmp_lt(one, pabs(x));
-  const Packet sign_mask = pset1<Packet>(-0.0);
+  const Packet sign_mask = psignmask<Packet>();
   const Packet x_sign = pand(sign_mask, x);
-  const Packet inf = pset1<Packet>(std::numeric_limits<double>::infinity());
+  const Packet inf = pinf<Packet>();
   return por(x_gt_one, pselect(x_eq_one, por(x_sign, inf), pselect(x_gt_half, y_large, y_small)));
 }
 
+//----------------------------------------------------------------------
+// sinh / cosh
+//----------------------------------------------------------------------
+
+/** \internal \returns the hyperbolic sine of \a x (coeff-wise).
+    Uses sinh(x) = (exp(x) - exp(-x)) / 2.
+    For |x| >= 1, the value h = exp(|x|) / 2 is computed once as exp(|x| - 1) * (E/2), where E is Euler's number,
+    to avoid premature inf, and is shared by both branches: sinh(x) = sign(x) * (h - 1/(4*h)) for |x| <= 20, and
+    sinh(x) = sign(x) * h for |x| > 20.
+    For |x| < 1, uses a direct polynomial to avoid catastrophic cancellation.
+*/
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psinh_float(const Packet& x) {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  static_assert(std::is_same<Scalar, float>::value, "Scalar type must be float");
+
+  const Packet sign_mask = psignmask<Packet>();
+  const Packet abs_x = pandnot(x, sign_mask);
+  const Packet x_sign = pand(x, sign_mask);
+
+  // For |x| < 1, use a polynomial approximation to avoid
+  // cancellation in exp(x) - exp(-x).
+  constexpr float alpha[] = {2.7557314045e-06f, 1.9841270114e-04f, 8.3333335817e-03f, 1.6666666716e-01f};
+  const Packet x2 = pmul(x, x);
+  Packet p_small = ppolevl<Packet, 3>::run(x2, alpha);
+  p_small = pmadd(pmul(x2, x), p_small, x);
+
+  // Compute e = exp(|x|) / 2 = exp(|x| - 1) * (e/2), where e is Euler's number.
+  // Using a single exp avoids a second expensive call, and subtracting 1 (exactly
+  // representable) instead of ln2 avoids rounding error in the argument to exp,
+  // which would be amplified into large relative output error.
+  const Packet half_e = pset1<Packet>(1.3591409142295225f);  // e/2
+  const Packet one = pset1<Packet>(1.0f);
+  const Packet e = pmul(pexp(psub(abs_x, one)), half_e);
+
+  // Medium path (1 <= |x| <= 20):
+  //   sinh(x) = (exp(|x|) - exp(-|x|)) / 2
+  //           = (2*e - 1/(2*e)) / 2 = e - 1/(4*e)
+  const Packet quarter = pset1<Packet>(0.25f);
+  Packet p_medium = psub(e, pdiv(quarter, e));
+
+  // Large path (|x| > 20): exp(-|x|) is negligible, sinh(x) ~ exp(|x|)/2 = e.
+  const Packet large_threshold = pset1<Packet>(20.0f);
+  const Packet large_mask = pcmp_lt(large_threshold, abs_x);
+  Packet p_large = pselect(large_mask, e, p_medium);
+  p_large = por(x_sign, p_large);
+
+  const Packet small_mask = pcmp_lt(abs_x, one);
+  return pselect(small_mask, p_small, p_large);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psinh_double(const Packet& x) {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  static_assert(std::is_same<Scalar, double>::value, "Scalar type must be double");
+
+  const Packet sign_mask = psignmask<Packet>();
+  const Packet abs_x = pandnot(x, sign_mask);
+  const Packet x_sign = pand(x, sign_mask);
+
+  // Taylor series: sinh(x) = x + x^3/3! + x^5/5! + ... + x^19/19!
+  // Polynomial form: sinh(x) = x + x^3 * P(x^2) where P(t) = sum_{k=0}^{8} t^k/(2k+3)!
+  // ppolevl stores highest-degree coefficient first.
+  constexpr double alpha[] = {
+      8.2206352466243297e-18,  // t^8: 1/19!
+      2.8114572543455206e-15,  // t^7: 1/17!
+      7.6471637318198164e-13,  // t^6: 1/15!
+      1.6059043836821613e-10,  // t^5: 1/13!
+      2.5052108385441718e-08,  // t^4: 1/11!
+      2.7557319223985893e-06,  // t^3: 1/9!
+      1.9841269841269841e-04,  // t^2: 1/7!
+      8.3333333333333332e-03,  // t^1: 1/5!
+      1.6666666666666666e-01,  // t^0: 1/3!
+  };
+  const Packet x2 = pmul(x, x);
+  Packet p_small = ppolevl<Packet, 8>::run(x2, alpha);
+  p_small = pmadd(pmul(x2, x), p_small, x);
+
+  // Compute e = exp(|x|) / 2 = exp(|x| - 1) * (e/2), where e is Euler's number.
+  // Subtracting 1 (exactly representable) instead of ln2 avoids rounding error
+  // in the argument to exp, which would be amplified into large relative error.
+  const Packet half_e = pset1<Packet>(1.3591409142295225);  // e/2
+  const Packet one = pset1<Packet>(1.0);
+  const Packet e = pmul(pexp(psub(abs_x, one)), half_e);
+
+  // Medium path (1 <= |x| <= 20):
+  //   sinh(x) = (exp(|x|) - exp(-|x|)) / 2 = e - 1/(4*e)
+  const Packet quarter = pset1<Packet>(0.25);
+  Packet p_medium = psub(e, pdiv(quarter, e));
+
+  // Large path (|x| > 20): exp(-|x|) is negligible, sinh(x) ~ exp(|x|)/2 = e.
+  const Packet large_threshold = pset1<Packet>(20.0);
+  const Packet large_mask = pcmp_lt(large_threshold, abs_x);
+  Packet p_large = pselect(large_mask, e, p_medium);
+  p_large = por(x_sign, p_large);
+  const Packet small_mask = pcmp_lt(abs_x, one);
+  return pselect(small_mask, p_small, p_large);
+}
+
+/** \internal \returns the hyperbolic cosine of \a x (coeff-wise).
+    Uses cosh(x) = (exp(|x|) + exp(-|x|)) / 2.
+    The value h = exp(|x|) / 2 is computed once as exp(|x| - 1) * (E/2), where E is Euler's number, to avoid
+    premature inf, and is shared by both branches: cosh(x) = h + 1/(4*h) for |x| <= 20, and cosh(x) = h for
+    |x| > 20.
+*/
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcosh_float(const Packet& x) {
+  const Packet abs_x = pabs(x);
+
+  // Compute e = exp(|x|) / 2 = exp(|x| - 1) * (e/2), where e is Euler's number.
+  // Using a single exp avoids a second expensive call, and subtracting 1 (exactly
+  // representable) instead of ln2 avoids rounding error in the argument to exp,
+  // which would be amplified into large relative output error.
+  const Packet half_e = pset1<Packet>(1.3591409142295225f);  // e/2
+  const Packet one = pset1<Packet>(1.0f);
+  const Packet e = pmul(pexp(psub(abs_x, one)), half_e);
+
+  // Medium path: cosh(x) = (exp(|x|) + exp(-|x|)) / 2
+  //            = (2*e + 1/(2*e)) / 2 = e + 1/(4*e)
+  const Packet quarter = pset1<Packet>(0.25f);
+  Packet p_medium = padd(e, pdiv(quarter, e));
+
+  // Large path (|x| > 20): exp(-|x|) is negligible, cosh(x) ~ exp(|x|)/2 = e.
+  const Packet large_threshold = pset1<Packet>(20.0f);
+  const Packet large_mask = pcmp_lt(large_threshold, abs_x);
+  return pselect(large_mask, e, p_medium);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcosh_double(const Packet& x) {
+  const Packet abs_x = pabs(x);
+
+  // Compute e = exp(|x|) / 2 = exp(|x| - 1) * (e/2), where e is Euler's number.
+  // Subtracting 1 (exactly representable) instead of ln2 avoids rounding error
+  // in the argument to exp, which would be amplified into large relative error.
+  const Packet half_e = pset1<Packet>(1.3591409142295225);  // e/2
+  const Packet one = pset1<Packet>(1.0);
+  const Packet e = pmul(pexp(psub(abs_x, one)), half_e);
+
+  // Medium path: cosh(x) = (exp(|x|) + exp(-|x|)) / 2 = e + 1/(4*e)
+  const Packet quarter = pset1<Packet>(0.25);
+  Packet p_medium = padd(e, pdiv(quarter, e));
+
+  // Large path (|x| > 20): exp(-|x|) is negligible, cosh(x) ~ exp(|x|)/2 = e.
+  const Packet large_threshold = pset1<Packet>(20.0);
+  const Packet large_mask = pcmp_lt(large_threshold, abs_x);
+  return pselect(large_mask, e, p_medium);
+}
+
+//----------------------------------------------------------------------
+// asinh / acosh
+//----------------------------------------------------------------------
+
+/** \internal \returns the inverse hyperbolic sine of \a x (coeff-wise).
+    Uses a single log1p call by selecting the argument before the transcendental:
+    For moderate |x|: log1p(|x| + x^2 / (1 + sqrt(1 + x^2)))
+    For large |x|:    log1p(|x| - 1) + ln2  (avoids x^2 overflow)
+*/
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasinh_float(const Packet& x) {
+  const Packet sign_mask = psignmask<Packet>();
+  const Packet abs_x = pandnot(x, sign_mask);
+  const Packet x_sign = pand(x, sign_mask);
+  const Packet one = pset1<Packet>(1.0f);
+
+  // For |x| >= 1e10, use log(2|x|) = log1p(|x| - 1) + ln2 to avoid x^2 overflow.
+  const Packet large_mask = pcmp_lt(pset1<Packet>(1e10f), abs_x);
+  // Guard x^2 against overflow in the large case.
+  const Packet x2 = pmul(abs_x, pselect(large_mask, pzero(abs_x), abs_x));
+  // For |x| < 1e10: log1p(|x| + x^2 / (1 + sqrt(1 + x^2))).
+  // Algebraically equivalent to log(|x| + sqrt(x^2 + 1))
+  // but avoids cancellation for small |x|.
+  Packet normal_arg = padd(abs_x, pdiv(x2, padd(one, psqrt(padd(one, x2)))));
+  // For |x| >= 1e10: log1p(|x| - 1), then add ln2 after.
+  Packet large_arg = psub(abs_x, one);
+  // Select argument, then call log1p once.
+  Packet result = generic_log1p(pselect(large_mask, large_arg, normal_arg));
+  // Add ln2 for the large path: log(2|x|) = log(|x|) + ln2 = log1p(|x|-1) + ln2.
+  const Packet ln2 = pset1<Packet>(0.6931471805599453f);
+  result = pselect(large_mask, padd(result, ln2), result);
+  return por(x_sign, result);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasinh_double(const Packet& x) {
+  const Packet sign_mask = psignmask<Packet>();
+  const Packet abs_x = pandnot(x, sign_mask);
+  const Packet x_sign = pand(x, sign_mask);
+  const Packet one = pset1<Packet>(1.0);
+
+  const Packet large_mask = pcmp_lt(pset1<Packet>(1e150), abs_x);
+  const Packet x2 = pmul(abs_x, pselect(large_mask, pzero(abs_x), abs_x));
+  Packet normal_arg = padd(abs_x, pdiv(x2, padd(one, psqrt(padd(one, x2)))));
+  Packet large_arg = psub(abs_x, one);
+  Packet result = generic_log1p(pselect(large_mask, large_arg, normal_arg));
+  const Packet ln2 = pset1<Packet>(0.6931471805599453);
+  result = pselect(large_mask, padd(result, ln2), result);
+  return por(x_sign, result);
+}
+
+/** \internal \returns the inverse hyperbolic cosine of \a x (coeff-wise).
+    Uses a single log1p call by selecting the argument before the transcendental:
+    For moderate x: log1p(t + sqrt(t*(t+2))) where t = x - 1
+    For huge x:     log1p(t) + ln2  (avoids t*(t+2) overflow)
+    Returns NaN for x < 1.
+*/
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacosh_float(const Packet& x) {
+  const Packet one = pset1<Packet>(1.0f);
+  const Packet two = pset1<Packet>(2.0f);
+  const Packet t = psub(x, one);
+  const Packet huge_mask = pcmp_lt(pset1<Packet>(1e10f), x);
+  // Guard t*(t+2) against overflow in the huge case.
+  const Packet t_tp2 = pmul(pselect(huge_mask, pzero(t), t), padd(t, two));
+  Packet normal_arg = padd(t, psqrt(t_tp2));
+  // For huge x: acosh(x) = log(2x) = log1p(x - 1) + ln2.
+  Packet huge_arg = t;
+  // Select argument, then call log1p once.
+  Packet result = generic_log1p(pselect(huge_mask, huge_arg, normal_arg));
+  const Packet ln2 = pset1<Packet>(0.6931471805599453f);
+  result = pselect(huge_mask, padd(result, ln2), result);
+  // Return NaN for x < 1.
+  const Packet invalid_mask = pcmp_lt(x, one);
+  return por(invalid_mask, result);
+}
+
+template <typename Packet>
+EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacosh_double(const Packet& x) {
+  const Packet one = pset1<Packet>(1.0);
+  const Packet two = pset1<Packet>(2.0);
+  const Packet t = psub(x, one);
+  const Packet huge_mask = pcmp_lt(pset1<Packet>(1e150), x);
+  const Packet t_tp2 = pmul(pselect(huge_mask, pzero(t), t), padd(t, two));
+  Packet normal_arg = padd(t, psqrt(t_tp2));
+  Packet huge_arg = t;
+  Packet result = generic_log1p(pselect(huge_mask, huge_arg, normal_arg));
+  const Packet ln2 = pset1<Packet>(0.6931471805599453);
+  result = pselect(huge_mask, padd(result, ln2), result);
+  const Packet invalid_mask = pcmp_lt(x, one);
+  return por(invalid_mask, result);
+}
+
 }  // end namespace internal
 }  // end namespace Eigen
 
diff --git a/Eigen/src/Core/arch/Default/Half.h b/Eigen/src/Core/arch/Default/Half.h
index 671a9dc..a628230 100644
--- a/Eigen/src/Core/arch/Default/Half.h
+++ b/Eigen/src/Core/arch/Default/Half.h
@@ -23,6 +23,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// SPDX-License-Identifier: MPL-2.0
 
 // Standard 16-bit float type, mostly useful for GPUs. Defines a new
 // type Eigen::half (inheriting either from CUDA's or HIP's __half struct) with
@@ -45,7 +46,7 @@
 // Eigen with GPU support.
 // Any functions that require `numext::bit_cast` may also not be constexpr,
 // including any native types when setting via raw bit values.
-#if defined(EIGEN_HAS_GPU_FP16) || defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) || defined(EIGEN_HAS_BUILTIN_FLOAT16)
+#if defined(EIGEN_HAS_GPU_FP16) || EIGEN_HAS_ARM64_FP16 || defined(EIGEN_HAS_BUILTIN_FLOAT16)
 #define _EIGEN_MAYBE_CONSTEXPR
 #else
 #define _EIGEN_MAYBE_CONSTEXPR constexpr
@@ -60,19 +61,24 @@
 #define EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_F16(PACKET_F, PACKET_F16) \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pcos)                      \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, psin)                      \
+  F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, psinh)                     \
+  F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pcosh)                     \
+  F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pasinh)                    \
+  F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pacosh)                    \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pexp)                      \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pexp2)                     \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pexpm1)                    \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, plog)                      \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, plog1p)                    \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, plog2)                     \
+  F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, plog10)                    \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, preciprocal)               \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, prsqrt)                    \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pcbrt)                     \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, psqrt)                     \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, ptanh)
 
-// F16 wrappers for unsupported/SpecialFunctions.
+// F16 wrappers for contrib/SpecialFunctions.
 #define EIGEN_INSTANTIATE_SPECIAL_FUNCS_F16(PACKET_F, PACKET_F16) \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, perf)                 \
   F16_PACKET_FUNCTION(PACKET_F, PACKET_F16, pndtri)
@@ -116,23 +122,23 @@
 //
 // Making the host side compile phase of hipcc use the same Eigen::half impl, as the gcc compile, resolves
 // this error, and hence the following convoluted #if condition
-#if !defined(EIGEN_HAS_GPU_FP16) || !defined(EIGEN_GPU_COMPILE_PHASE)
+#if !defined(EIGEN_GPUCC) || !defined(EIGEN_GPU_COMPILE_PHASE)
 
 // Make our own __half_raw definition that is similar to CUDA's.
 struct __half_raw {
   struct construct_from_rep_tag {};
-#if (defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE))
+#if (defined(EIGEN_GPUCC) && !defined(EIGEN_GPU_COMPILE_PHASE))
   // Eigen::half can be used as the datatype for shared memory declarations (in Eigen and TF)
   // The element type for shared memory cannot have non-trivial constructors
-  // and hence the following special casing (which skips the zero-initilization).
+  // and hence the following special casing (which skips the zero-initialization).
   // Note that this check gets done even in the host compilation phase, and
   // hence the need for this
-  EIGEN_DEVICE_FUNC __half_raw() {}
+  EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR __half_raw() {}
 #else
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR __half_raw() : x(0) {}
 #endif
 
-#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+#if EIGEN_HAS_ARM64_FP16
   explicit EIGEN_DEVICE_FUNC __half_raw(numext::uint16_t raw) : x(numext::bit_cast<__fp16>(raw)) {}
   EIGEN_DEVICE_FUNC constexpr __half_raw(construct_from_rep_tag, __fp16 rep) : x{rep} {}
   __fp16 x;
@@ -147,22 +153,19 @@
 #endif
 };
 
-#elif defined(EIGEN_HAS_HIP_FP16)
+#elif defined(EIGEN_HIPCC)
 // HIP GPU compile phase: nothing to do here.
 // HIP fp16 header file has a definition for __half_raw
-#elif defined(EIGEN_HAS_CUDA_FP16)
+#elif defined(EIGEN_CUDACC)
 
 // CUDA GPU compile phase.
-#if EIGEN_CUDA_SDK_VER < 90000
-// In CUDA < 9.0, __half is the equivalent of CUDA 9's __half_raw
-typedef __half __half_raw;
-#endif  // defined(EIGEN_HAS_CUDA_FP16)
 
 #elif defined(SYCL_DEVICE_ONLY)
-typedef cl::sycl::half __half_raw;
+using __half_raw = cl::sycl::half;
 #endif
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR __half_raw raw_uint16_to_half(numext::uint16_t x);
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC numext::uint16_t raw_half_as_uint16(const __half_raw& h);
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff);
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h);
 
@@ -170,15 +173,19 @@
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half_base() {}
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half_base(const __half_raw& h) : __half_raw(h) {}
 
-#if defined(EIGEN_HAS_GPU_FP16)
-#if defined(EIGEN_HAS_HIP_FP16)
-  EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half_base(const __half& h) { x = __half_as_ushort(h); }
-#elif defined(EIGEN_HAS_CUDA_FP16)
-#if EIGEN_CUDA_SDK_VER >= 90000
+#if defined(EIGEN_GPUCC)
+#if defined(EIGEN_HIPCC)
+  // Delegate to raw_uint16_to_half, which reinterprets the raw bits for every storage type of
+  // __half_raw::x. In the host compile phase on platforms with a native fp16 type (e.g. __fp16 on
+  // arm64), a direct "x = __half_as_ushort(h)" would perform a numeric integer-to-float conversion.
+  // numext::bit_cast is used to extract the bits because hip_fp16.h defines __half_as_ushort for
+  // the device compile phase only (host references fail to link against ROCm 6.3).
+  EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half_base(const __half& h)
+      : __half_raw(raw_uint16_to_half(numext::bit_cast<numext::uint16_t>(h))) {}
+#elif defined(EIGEN_CUDACC)
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half_base(const __half& h) : __half_raw(*(__half_raw*)&h) {}
 #endif
 #endif
-#endif
 };
 
 }  // namespace half_impl
@@ -187,41 +194,36 @@
 struct half : public half_impl::half_base {
   // Writing this out as separate #if-else blocks to make the code easier to follow
   // The same applies to most #if-else blocks in this file
-#if !defined(EIGEN_HAS_GPU_FP16) || !defined(EIGEN_GPU_COMPILE_PHASE)
+#if !defined(EIGEN_GPUCC) || !defined(EIGEN_GPU_COMPILE_PHASE)
   // Use the same base class for the following two scenarios
   // * when compiling without GPU support enabled
   // * during host compile phase when compiling with GPU support enabled
-  typedef half_impl::__half_raw __half_raw;
-#elif defined(EIGEN_HAS_HIP_FP16)
+  using __half_raw = half_impl::__half_raw;
+#elif defined(EIGEN_HIPCC)
   // Nothing to do here
   // HIP fp16 header file has a definition for __half_raw
-#elif defined(EIGEN_HAS_CUDA_FP16)
-// Note that EIGEN_CUDA_SDK_VER is set to 0 even when compiling with HIP, so
-// (EIGEN_CUDA_SDK_VER < 90000) is true even for HIP!  So keeping this within
-// #if defined(EIGEN_HAS_CUDA_FP16) is needed
-#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
-  typedef half_impl::__half_raw __half_raw;
-#endif
+#elif defined(EIGEN_CUDACC)
+  // Nothing to do here.
 #endif
 
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half() {}
 
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half(const __half_raw& h) : half_impl::half_base(h) {}
 
-#if defined(EIGEN_HAS_GPU_FP16)
-#if defined(EIGEN_HAS_HIP_FP16)
+#if defined(EIGEN_GPUCC)
+#if defined(EIGEN_HIPCC)
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half(const __half& h) : half_impl::half_base(h) {}
-#elif defined(EIGEN_HAS_CUDA_FP16)
-#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
+#elif defined(EIGEN_CUDACC)
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half(const __half& h) : half_impl::half_base(h) {}
 #endif
 #endif
-#endif
 
-#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+// In the device compile phase __half_raw is the vendor type, which has no construct_from_rep_tag,
+// so these constructors are restricted to the host compile phase and non-GPU builds.
+#if EIGEN_HAS_ARM64_FP16 && !defined(EIGEN_GPU_COMPILE_PHASE)
   explicit EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half(__fp16 b)
       : half(__half_raw(__half_raw::construct_from_rep_tag(), b)) {}
-#elif defined(EIGEN_HAS_BUILTIN_FLOAT16)
+#elif defined(EIGEN_HAS_BUILTIN_FLOAT16) && !defined(EIGEN_GPU_COMPILE_PHASE)
   explicit EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR half(_Float16 b)
       : half(__half_raw(__half_raw::construct_from_rep_tag(), b)) {}
 #endif
@@ -246,7 +248,10 @@
 #if defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE)
   EIGEN_DEVICE_FUNC operator __half() const {
     ::__half_raw hr;
-    hr.x = x;
+    // raw_half_as_uint16 reinterprets the raw bits for every storage type of __half_raw::x.
+    // A direct "hr.x = x" would perform a numeric float-to-integer conversion when x has a
+    // native fp16 type (e.g. __fp16 on arm64), since the vendor ::__half_raw::x is an integer.
+    hr.x = half_impl::raw_half_as_uint16(*this);
     return __half(hr);
   }
 #endif
@@ -301,6 +306,8 @@
   static _EIGEN_MAYBE_CONSTEXPR Eigen::half denorm_min() { return Eigen::half_impl::raw_uint16_to_half(0x0001); }
 };
 
+// Redundant out-of-class definitions are required pre-C++17 but deprecated since.
+#if EIGEN_COMP_CXXVER < 17
 template <typename T>
 constexpr const bool numeric_limits_half_impl<T>::is_specialized;
 template <typename T>
@@ -350,6 +357,7 @@
 constexpr const bool numeric_limits_half_impl<T>::traps;
 template <typename T>
 constexpr const bool numeric_limits_half_impl<T>::tinyness_before;
+#endif
 }  // end namespace half_impl
 }  // end namespace Eigen
 
@@ -372,8 +380,7 @@
 
 namespace half_impl {
 
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
 // Note: We deliberately do *not* define this to 1 even if we have Arm's native
 // fp16 type since GPU half types are rather different from native CPU half types.
 #define EIGEN_HAS_NATIVE_GPU_FP16
@@ -385,24 +392,10 @@
 // conversion steps back and forth.
 
 #if defined(EIGEN_HAS_NATIVE_GPU_FP16)
-EIGEN_STRONG_INLINE __device__ half operator+(const half& a, const half& b) {
-#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
-  return __hadd(::__half(a), ::__half(b));
-#else
-  return __hadd(a, b);
-#endif
-}
+EIGEN_STRONG_INLINE __device__ half operator+(const half& a, const half& b) { return __hadd(::__half(a), ::__half(b)); }
 EIGEN_STRONG_INLINE __device__ half operator*(const half& a, const half& b) { return __hmul(a, b); }
 EIGEN_STRONG_INLINE __device__ half operator-(const half& a, const half& b) { return __hsub(a, b); }
-EIGEN_STRONG_INLINE __device__ half operator/(const half& a, const half& b) {
-#if defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000
-  return __hdiv(a, b);
-#else
-  float num = __half2float(a);
-  float denom = __half2float(b);
-  return __float2half(num / denom);
-#endif
-}
+EIGEN_STRONG_INLINE __device__ half operator/(const half& a, const half& b) { return __hdiv(a, b); }
 EIGEN_STRONG_INLINE __device__ half operator-(const half& a) { return __hneg(a); }
 EIGEN_STRONG_INLINE __device__ half& operator+=(half& a, const half& b) {
   a = a + b;
@@ -429,26 +422,45 @@
 
 #endif  // EIGEN_HAS_NATIVE_GPU_FP16
 
+#if (EIGEN_HAS_ARM64_FP16 || defined(EIGEN_HAS_BUILTIN_FLOAT16)) && !defined(EIGEN_GPU_COMPILE_PHASE)
+// nvcc's EDG front end does not promote __fp16 arithmetic to float, and it ranks the mandatory
+// __fp16 -> float promotion as an exact match, so constructing a half from a native fp16 expression
+// is an ambiguous tie between half(__fp16) and half(float). Every nvcc arm64 translation unit that
+// includes Eigen then fails to compile. Building __half_raw names one constructor, and is what
+// half(__fp16) and half(_Float16) do internally, so the stored value is unchanged.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half half_from_rep(decltype(__half_raw::x) rep) {
+  return half(__half_raw(__half_raw::construct_from_rep_tag(), rep));
+}
+#endif
+
 #if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) && !defined(EIGEN_GPU_COMPILE_PHASE)
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator+(const half& a, const half& b) { return half(vaddh_f16(a.x, b.x)); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator*(const half& a, const half& b) { return half(vmulh_f16(a.x, b.x)); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a, const half& b) { return half(vsubh_f16(a.x, b.x)); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator/(const half& a, const half& b) { return half(vdivh_f16(a.x, b.x)); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a) { return half(vnegh_f16(a.x)); }
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator+(const half& a, const half& b) {
+  return half_from_rep(vaddh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator*(const half& a, const half& b) {
+  return half_from_rep(vmulh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a, const half& b) {
+  return half_from_rep(vsubh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator/(const half& a, const half& b) {
+  return half_from_rep(vdivh_f16(a.x, b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a) { return half_from_rep(vnegh_f16(a.x)); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator+=(half& a, const half& b) {
-  a = half(vaddh_f16(a.x, b.x));
+  a = half_from_rep(vaddh_f16(a.x, b.x));
   return a;
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator*=(half& a, const half& b) {
-  a = half(vmulh_f16(a.x, b.x));
+  a = half_from_rep(vmulh_f16(a.x, b.x));
   return a;
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator-=(half& a, const half& b) {
-  a = half(vsubh_f16(a.x, b.x));
+  a = half_from_rep(vsubh_f16(a.x, b.x));
   return a;
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator/=(half& a, const half& b) {
-  a = half(vdivh_f16(a.x, b.x));
+  a = half_from_rep(vdivh_f16(a.x, b.x));
   return a;
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator==(const half& a, const half& b) { return vceqh_f16(a.x, b.x); }
@@ -458,13 +470,33 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>(const half& a, const half& b) { return vcgth_f16(a.x, b.x); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>=(const half& a, const half& b) { return vcgeh_f16(a.x, b.x); }
 
-#elif defined(EIGEN_HAS_BUILTIN_FLOAT16) && !defined(EIGEN_GPU_COMPILE_PHASE)
+#elif (EIGEN_HAS_ARM64_FP16 || defined(EIGEN_HAS_BUILTIN_FLOAT16)) && !defined(EIGEN_GPU_COMPILE_PHASE)
 
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator+(const half& a, const half& b) { return half(a.x + b.x); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator*(const half& a, const half& b) { return half(a.x * b.x); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a, const half& b) { return half(a.x - b.x); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator/(const half& a, const half& b) { return half(a.x / b.x); }
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a) { return half(-a.x); }
+// NOTE: While GCC appears to only apply `-Wdouble-promotion` to single-to-double
+// conversions, Clang applies the warning to half-to-single implicit conversion also.  For
+// the operations below, implicit conversion is intentional so that---depending on the
+// target features---the compiler can choose between using native half-precision
+// instructions or converting to single-precision.
+#if EIGEN_COMP_CLANG
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdouble-promotion"
+#endif
+
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator+(const half& a, const half& b) {
+  return half_from_rep(static_cast<decltype(a.x)>(a.x + b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator*(const half& a, const half& b) {
+  return half_from_rep(static_cast<decltype(a.x)>(a.x * b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a, const half& b) {
+  return half_from_rep(static_cast<decltype(a.x)>(a.x - b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator/(const half& a, const half& b) {
+  return half_from_rep(static_cast<decltype(a.x)>(a.x / b.x));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a) {
+  return half_from_rep(static_cast<decltype(a.x)>(-a.x));
+}
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator+=(half& a, const half& b) {
   a = a + b;
   return a;
@@ -488,6 +520,10 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>(const half& a, const half& b) { return a.x > b.x; }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool operator>=(const half& a, const half& b) { return a.x >= b.x; }
 
+#if EIGEN_COMP_CLANG
+#pragma clang diagnostic pop
+#endif
+
 // We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
 // invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
 // of the functions, while the latter can only deal with one of them.
@@ -497,7 +533,7 @@
 // We need to provide emulated *host-side* FP16 operators for clang.
 #pragma push_macro("EIGEN_DEVICE_FUNC")
 #undef EIGEN_DEVICE_FUNC
-#if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_HAS_NATIVE_GPU_FP16)
+#if defined(EIGEN_GPUCC) && defined(EIGEN_HAS_NATIVE_GPU_FP16)
 #define EIGEN_DEVICE_FUNC __host__
 #else  // both host and device need emulated ops.
 #define EIGEN_DEVICE_FUNC __host__ __device__
@@ -511,9 +547,7 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a, const half& b) { return half(float(a) - float(b)); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator/(const half& a, const half& b) { return half(float(a) / float(b)); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator-(const half& a) {
-  half result;
-  result.x = a.x ^ 0x8000;
-  return result;
+  return raw_uint16_to_half(static_cast<numext::uint16_t>(raw_half_as_uint16(a) ^ 0x8000));
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator+=(half& a, const half& b) {
   a = half(float(a) + float(b));
@@ -546,6 +580,10 @@
 
 // convert sign-magnitude representation to two's complement
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC int16_t mapToSigned(uint16_t a) {
+#if EIGEN_COMP_NVHPC
+  // NVHPC through at least 26.5 can miscompile repeated inlined comparisons of the transformed integer representations.
+  EIGEN_OPTIMIZATION_BARRIER(a)
+#endif
   constexpr uint16_t kAbsMask = (1 << 15) - 1;
   // If the sign bit is set, clear the sign bit and return the (integer) negation. Otherwise, return the input.
   return (a >> 15) ? -(a & kAbsMask) : a;
@@ -622,13 +660,17 @@
 // also possible to vectorize directly.
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR __half_raw raw_uint16_to_half(numext::uint16_t x) {
-  // We cannot simply do a "return __half_raw(x)" here, because __half_raw is union type
-  // in the hip_fp16 header file, and that will trigger a compile error
-  // On the other hand, having anything but a return statement also triggers a compile error
-  // because this is constexpr function.
+  // In the device compile phase of a GPU build we cannot simply do a "return __half_raw(x)",
+  // because there __half_raw is the vendor type (a union in the hip_fp16 header file) that has
+  // no uint16 constructor, and that will trigger a compile error. There "h.x = x" assigns the
+  // raw bits, since the vendor member x is an integer.
+  // In the host compile phase (and in non-GPU builds) Eigen's own __half_raw is in effect and its
+  // member x may be a native fp16 type (__fp16 on arm64, _Float16 with AVX512FP16 or riscv-zfh),
+  // so "h.x = x" would perform a numeric integer-to-float conversion that corrupts the raw bits;
+  // the explicit uint16 constructor reinterprets the bits for every storage type instead.
   // Fortunately, since we need to disable EIGEN_CONSTEXPR for GPU anyway, we can get out
-  // of this catch22 by having separate bodies for GPU / non GPU
-#if defined(EIGEN_HAS_GPU_FP16)
+  // of this catch22 by having separate bodies for the GPU device phase / everything else.
+#if defined(EIGEN_GPUCC) && defined(EIGEN_GPU_COMPILE_PHASE)
   __half_raw h;
   h.x = x;
   return h;
@@ -641,7 +683,7 @@
   // HIP/CUDA/Default have a member 'x' of type uint16_t.
   // For ARM64 native half, the member 'x' is of type __fp16, so we need to bit-cast.
   // For SYCL, cl::sycl::half is _Float16, so cast directly.
-#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+#if EIGEN_HAS_ARM64_FP16
   return numext::bit_cast<numext::uint16_t>(h.x);
 #elif defined(EIGEN_HAS_BUILTIN_FLOAT16)
   return numext::bit_cast<numext::uint16_t>(h.x);
@@ -653,12 +695,11 @@
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(float ff) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   __half tmp_ff = __float2half(ff);
   return *(__half_raw*)&tmp_ff;
 
-#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
+#elif EIGEN_HAS_ARM64_FP16
   __half_raw h;
   h.x = static_cast<__fp16>(ff);
   return h;
@@ -670,12 +711,8 @@
 
 #elif defined(EIGEN_HAS_FP16_C)
   __half_raw h;
-#if EIGEN_COMP_MSVC
-  // MSVC does not have scalar instructions.
-  h.x = _mm_extract_epi16(_mm_cvtps_ph(_mm_set_ss(ff), 0), 0);
-#else
-  h.x = _cvtss_sh(ff, 0);
-#endif
+  // Spell out the vector conversion to avoid Clang warning about the C99 compound literal used by _cvtss_sh.
+  h.x = static_cast<numext::uint16_t>(_mm_extract_epi16(_mm_cvtps_ph(_mm_set_ss(ff), 0), 0));
   return h;
 
 #else
@@ -727,10 +764,9 @@
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float half_to_float(__half_raw h) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   return __half2float(h);
-#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) || defined(EIGEN_HAS_BUILTIN_FLOAT16)
+#elif EIGEN_HAS_ARM64_FP16 || defined(EIGEN_HAS_BUILTIN_FLOAT16)
   return static_cast<float>(h.x);
 #elif defined(EIGEN_HAS_FP16_C)
 #if EIGEN_COMP_MSVC
@@ -762,67 +798,47 @@
 
 // --- standard functions ---
 
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isinf)(const half& a) {
-#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) || defined(EIGEN_HAS_BUILTIN_FLOAT16)
-  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) == 0x7c00;
-#else
-  return (a.x & 0x7fff) == 0x7c00;
-#endif
-}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isinf)(const half& a) { return (raw_half_as_uint16(a) & 0x7fff) == 0x7c00; }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isnan)(const half& a) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   return __hisnan(a);
-#elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) || defined(EIGEN_HAS_BUILTIN_FLOAT16)
-  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) > 0x7c00;
 #else
-  return (a.x & 0x7fff) > 0x7c00;
+  return (raw_half_as_uint16(a) & 0x7fff) > 0x7c00;
 #endif
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool(isfinite)(const half& a) {
-#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) || defined(EIGEN_HAS_BUILTIN_FLOAT16)
-  return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) < 0x7c00;
-#else
-  return (a.x & 0x7fff) < 0x7c00;
-#endif
+  return (raw_half_as_uint16(a) & 0x7fff) < 0x7c00;
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half abs(const half& a) {
 #if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
-  return half(vabsh_f16(a.x));
-#elif defined(EIGEN_HAS_BUILTIN_FLOAT16)
-  half result;
-  result.x =
-      numext::bit_cast<_Float16>(static_cast<numext::uint16_t>(numext::bit_cast<numext::uint16_t>(a.x) & 0x7FFF));
-  return result;
+  return half_from_rep(vabsh_f16(a.x));
 #else
-  half result;
-  result.x = a.x & 0x7FFF;
-  return result;
+  return raw_uint16_to_half(static_cast<numext::uint16_t>(raw_half_as_uint16(a) & 0x7FFF));
 #endif
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half exp(const half& a) {
-#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
-    defined(EIGEN_HIP_DEVICE_COMPILE)
-  return half(hexp(a));
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hexp(::__half(a)));
 #else
   return half(::expf(float(a)));
 #endif
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half exp2(const half& a) {
-#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
-    defined(EIGEN_HIP_DEVICE_COMPILE)
-  return half(hexp2(a));
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hexp2(::__half(a)));
 #else
   return half(::exp2f(float(a)));
 #endif
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half expm1(const half& a) { return half(numext::expm1(float(a))); }
+// float covers the half range, so the single conversion back rounds correctly.
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half ldexp(const half& a, int exponent) {
+  return half(numext::ldexp(float(a), exponent));
+}
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log(const half& a) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && \
-     EIGEN_CUDA_ARCH >= 530) ||                                                                 \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
-  return half(hlog(a));
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return half(hlog(::__half(a)));
 #else
   return half(::logf(float(a)));
 #endif
@@ -834,9 +850,8 @@
 }
 
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half sqrt(const half& a) {
-#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
-    defined(EIGEN_HIP_DEVICE_COMPILE)
-  return half(hsqrt(a));
+#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hsqrt(::__half(a)));
 #else
   return half(::sqrtf(float(a)));
 #endif
@@ -856,17 +871,15 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half atan(const half& a) { return half(::atanf(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half atanh(const half& a) { return half(::atanhf(float(a))); }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half floor(const half& a) {
-#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
-    defined(EIGEN_HIP_DEVICE_COMPILE)
-  return half(hfloor(a));
+#if (defined(EIGEN_CUDA_ARCH)) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hfloor(::__half(a)));
 #else
   return half(::floorf(float(a)));
 #endif
 }
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half ceil(const half& a) {
-#if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
-    defined(EIGEN_HIP_DEVICE_COMPILE)
-  return half(hceil(a));
+#if (defined(EIGEN_CUDA_ARCH)) || defined(EIGEN_HIP_DEVICE_COMPILE)
+  return half(hceil(::__half(a)));
 #else
   return half(::ceilf(float(a)));
 #endif
@@ -884,7 +897,7 @@
 
 EIGEN_DEVICE_FUNC inline half fma(const half& a, const half& b, const half& c) {
 #if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
-  return half(vfmah_f16(c.x, a.x, b.x));
+  return half_from_rep(vfmah_f16(c.x, a.x, b.x));
 #elif defined(EIGEN_VECTORIZE_AVX512FP16)
   // Reduces to vfmadd213sh.
   return half(_mm_cvtsh_h(_mm_fmadd_ph(_mm_set_sh(a.x), _mm_set_sh(b.x), _mm_set_sh(c.x))));
@@ -909,9 +922,7 @@
 namespace internal {
 
 template <>
-struct is_arithmetic<half> {
-  enum { value = true };
-};
+struct is_arithmetic<half> : std::true_type {};
 
 template <>
 struct random_impl<half> {
@@ -934,7 +945,8 @@
   enum { IsSigned = true, IsInteger = false, IsComplex = false, RequireInitialization = false };
 
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half epsilon() {
-    return half_impl::raw_uint16_to_half(0x0800);
+    // 0x1400 is 2^-10, the fp16 machine epsilon, matching std::numeric_limits<Eigen::half>::epsilon().
+    return half_impl::raw_uint16_to_half(0x1400);
   }
   EIGEN_DEVICE_FUNC _EIGEN_MAYBE_CONSTEXPR static EIGEN_STRONG_INLINE Eigen::half dummy_precision() {
     return half_impl::raw_uint16_to_half(0x211f);  //  Eigen::half(1e-2f);
@@ -989,6 +1001,31 @@
   return Eigen::half_impl::raw_half_as_uint16(src);
 }
 
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half nextafter(const Eigen::half& from, const Eigen::half& to) {
+  if (numext::isnan EIGEN_NOT_A_MACRO(from)) {
+    return from;
+  }
+  if (numext::isnan EIGEN_NOT_A_MACRO(to)) {
+    return to;
+  }
+  if (from == to) {
+    return to;
+  }
+  uint16_t from_bits = numext::bit_cast<uint16_t>(from);
+  bool from_sign = from_bits >> 15;
+  if ((from_bits & 0x7fff) == 0) {
+    // From ±0 toward a nonzero value: the neighbor is the smallest subnormal
+    // carrying the sign of the direction (IEEE-754 nextUp/nextDown of zero).
+    from_bits = (to > from) ? uint16_t(0x0001) : uint16_t(0x8001);
+  } else if ((to > from) != from_sign) {
+    // Toward the infinity with the same sign as from: increase the magnitude.
+    ++from_bits;
+  } else {
+    --from_bits;
+  }
+  return numext::bit_cast<Eigen::half>(from_bits);
+}
+
 // Specialize multiply-add to match packet operations and reduce conversions to/from float.
 template <>
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half madd<Eigen::half>(const Eigen::half& x, const Eigen::half& y,
@@ -999,20 +1036,12 @@
 }  // namespace numext
 }  // namespace Eigen
 
-// Add the missing shfl* intrinsics.
-// The __shfl* functions are only valid on HIP or _CUDA_ARCH_ >= 300.
-//   CUDA defines them for (__CUDA_ARCH__ >= 300 || !defined(__CUDA_ARCH__))
-//
-// HIP and CUDA prior to SDK 9.0 define
-//    __shfl, __shfl_up, __shfl_down, __shfl_xor for int and float
-// CUDA since 9.0 deprecates those and instead defines
-//    __shfl_sync, __shfl_up_sync, __shfl_down_sync, __shfl_xor_sync,
-//    with native support for __half and __nv_bfloat16
-//
+// Warp shuffle overloads for Eigen::half.
+// CUDA uses __shfl_*_sync (with mask); HIP uses __shfl_* (no mask).
 // Note that the following are __device__ - only functions.
-#if (defined(EIGEN_CUDACC) && (!defined(EIGEN_CUDA_ARCH) || EIGEN_CUDA_ARCH >= 300)) || defined(EIGEN_HIPCC)
+#if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
 
-#if defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 90000
+#if defined(EIGEN_CUDACC)
 
 __device__ EIGEN_STRONG_INLINE Eigen::half __shfl_sync(unsigned mask, Eigen::half var, int srcLane,
                                                        int width = warpSize) {
@@ -1038,7 +1067,7 @@
   return static_cast<Eigen::half>(__shfl_xor_sync(mask, h, laneMask, width));
 }
 
-#else  // HIP or CUDA SDK < 9.0
+#else  // HIP
 
 __device__ EIGEN_STRONG_INLINE Eigen::half __shfl(Eigen::half var, int srcLane, int width = warpSize) {
   const int ivar = static_cast<int>(Eigen::numext::bit_cast<Eigen::numext::uint16_t>(var));
@@ -1064,7 +1093,7 @@
 #endif  // __shfl*
 
 // ldg() has an overload for __half_raw, but we also need one for Eigen::half.
-#if (defined(EIGEN_CUDACC) && (!defined(EIGEN_CUDA_ARCH) || EIGEN_CUDA_ARCH >= 350)) || defined(EIGEN_HIPCC)
+#if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
 EIGEN_STRONG_INLINE __device__ Eigen::half __ldg(const Eigen::half* ptr) {
   return Eigen::half_impl::raw_uint16_to_half(__ldg(reinterpret_cast<const Eigen::numext::uint16_t*>(ptr)));
 }
@@ -1087,8 +1116,7 @@
 template <>
 struct cast_impl<float, half> {
   EIGEN_DEVICE_FUNC static inline half run(const float& a) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
     return __float2half(a);
 #else
     return half(a);
@@ -1099,8 +1127,7 @@
 template <>
 struct cast_impl<int, half> {
   EIGEN_DEVICE_FUNC static inline half run(const int& a) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
     return __float2half(static_cast<float>(a));
 #else
     return half(static_cast<float>(a));
@@ -1111,8 +1138,7 @@
 template <>
 struct cast_impl<half, float> {
   EIGEN_DEVICE_FUNC static inline float run(const half& a) {
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
     return __half2float(a);
 #else
     return static_cast<float>(a);
diff --git a/Eigen/src/Core/arch/Default/Settings.h b/Eigen/src/Core/arch/Default/Settings.h
index 7e3a970..61af103 100644
--- a/Eigen/src/Core/arch/Default/Settings.h
+++ b/Eigen/src/Core/arch/Default/Settings.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /* All the parameters defined in this file can be specialized in the
  * architecture specific files, and/or by the user.
diff --git a/Eigen/src/Core/arch/GPU/Complex.h b/Eigen/src/Core/arch/GPU/Complex.h
index be4c218..d79b569 100644
--- a/Eigen/src/Core/arch/GPU/Complex.h
+++ b/Eigen/src/Core/arch/GPU/Complex.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_GPU_H
 #define EIGEN_COMPLEX_GPU_H
@@ -15,8 +16,16 @@
 // operator/ are not constexpr. Due to this, GCC and older versions of clang do
 // not treat them as device functions and thus Eigen functors making use of
 // these operators fail to compile. Here, we manually specialize these
-// operators and functors for complex types when building for CUDA to enable
-// their use on-device.
+// operators for complex types when building for CUDA to enable their use
+// on-device.
+//
+// Eigen/Core includes this header ahead of the Core headers (Meta.h's
+// equal_strict, MathFunctions.h, GenericPacketMath.h, the functors), which
+// apply these operators to a dependent Scalar: two-phase
+// lookup finds non-ADL candidates in the definition context only, and ADL for
+// std::complex<T> reaches namespace std alone, so an overload declared later
+// leaves those templates bound to the host-only std:: operators. nvcc before
+// CUDA 13.3 resolved them at the instantiation point, which masked the ordering.
 //
 // NOTES:
 //  - Compound assignment operators +=,-=,*=,/=(Scalar) will not work on device,
@@ -29,6 +38,10 @@
 //    failures.
 //  - Compiling with ICC requires defining _USE_COMPLEX_SPECIALIZATION_ prior
 //    to the first inclusion of <complex>.
+//  - Device code outside namespace Eigen that applies these operators to a
+//    dependent Scalar reaches them only through `using namespace Eigen;` or
+//    using-declarations in scope (see test/gpu_basic.cu); ADL alone finds the
+//    host-only std:: operators.
 
 #if defined(EIGEN_GPUCC) && defined(EIGEN_GPU_COMPILE_PHASE)
 
@@ -59,6 +72,16 @@
 
 namespace Eigen {
 
+namespace internal {
+// Defined in MathFunctions.h, which follows this header.
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> complex_multiply(const std::complex<T>& a,
+                                                                       const std::complex<T>& b);
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> complex_divide(const std::complex<T>& a,
+                                                                     const std::complex<T>& b);
+}  // namespace internal
+
 // Specialized std::complex overloads.
 namespace complex_operator_detail {
 
@@ -67,38 +90,42 @@
 //       since they are already specialized for float/double/long double within
 //       the standard <complex> header. We also do not specialize the stream
 //       operators.
+//       numext is not declared yet; the std::complex members used below are
+//       constexpr, hence device-callable under EIGEN_CONSTEXPR_ARE_DEVICE_FUNC
+//       (nvcc: --expt-relaxed-constexpr), as real_impl<std::complex<T>>
+//       already assumes.
 #define EIGEN_CREATE_STD_COMPLEX_OPERATOR_SPECIALIZATIONS(T)                                                        \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator+(const std::complex<T>& a) { return a; }           \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator-(const std::complex<T>& a) {                       \
-    return std::complex<T>(-numext::real(a), -numext::imag(a));                                                     \
+    return std::complex<T>(-a.real(), -a.imag());                                                                   \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator+(const std::complex<T>& a,                         \
                                                                   const std::complex<T>& b) {                       \
-    return std::complex<T>(numext::real(a) + numext::real(b), numext::imag(a) + numext::imag(b));                   \
+    return std::complex<T>(a.real() + b.real(), a.imag() + b.imag());                                               \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator+(const std::complex<T>& a, const T& b) {           \
-    return std::complex<T>(numext::real(a) + b, numext::imag(a));                                                   \
+    return std::complex<T>(a.real() + b, a.imag());                                                                 \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator+(const T& a, const std::complex<T>& b) {           \
-    return std::complex<T>(a + numext::real(b), numext::imag(b));                                                   \
+    return std::complex<T>(a + b.real(), b.imag());                                                                 \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator-(const std::complex<T>& a,                         \
                                                                   const std::complex<T>& b) {                       \
-    return std::complex<T>(numext::real(a) - numext::real(b), numext::imag(a) - numext::imag(b));                   \
+    return std::complex<T>(a.real() - b.real(), a.imag() - b.imag());                                               \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator-(const std::complex<T>& a, const T& b) {           \
-    return std::complex<T>(numext::real(a) - b, numext::imag(a));                                                   \
+    return std::complex<T>(a.real() - b, a.imag());                                                                 \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator-(const T& a, const std::complex<T>& b) {           \
-    return std::complex<T>(a - numext::real(b), -numext::imag(b));                                                  \
+    return std::complex<T>(a - b.real(), -b.imag());                                                                \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator*(const std::complex<T>& a,                         \
@@ -107,11 +134,11 @@
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator*(const std::complex<T>& a, const T& b) {           \
-    return std::complex<T>(numext::real(a) * b, numext::imag(a) * b);                                               \
+    return std::complex<T>(a.real() * b, a.imag() * b);                                                             \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator*(const T& a, const std::complex<T>& b) {           \
-    return std::complex<T>(a * numext::real(b), a * numext::imag(b));                                               \
+    return std::complex<T>(a * b.real(), a * b.imag());                                                             \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator/(const std::complex<T>& a,                         \
@@ -120,7 +147,7 @@
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator/(const std::complex<T>& a, const T& b) {           \
-    return std::complex<T>(numext::real(a) / b, numext::imag(a) / b);                                               \
+    return std::complex<T>(a.real() / b, a.imag() / b);                                                             \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T> operator/(const T& a, const std::complex<T>& b) {           \
@@ -128,14 +155,12 @@
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T>& operator+=(std::complex<T>& a, const std::complex<T>& b) { \
-    numext::real_ref(a) += numext::real(b);                                                                         \
-    numext::imag_ref(a) += numext::imag(b);                                                                         \
+    a = std::complex<T>(a.real() + b.real(), a.imag() + b.imag());                                                  \
     return a;                                                                                                       \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<T>& operator-=(std::complex<T>& a, const std::complex<T>& b) { \
-    numext::real_ref(a) -= numext::real(b);                                                                         \
-    numext::imag_ref(a) -= numext::imag(b);                                                                         \
+    a = std::complex<T>(a.real() - b.real(), a.imag() - b.imag());                                                  \
     return a;                                                                                                       \
   }                                                                                                                 \
                                                                                                                     \
@@ -150,15 +175,15 @@
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const std::complex<T>& a, const std::complex<T>& b) {       \
-    return numext::real(a) == numext::real(b) && numext::imag(a) == numext::imag(b);                                \
+    return a.real() == b.real() && a.imag() == b.imag();                                                            \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const std::complex<T>& a, const T& b) {                     \
-    return numext::real(a) == b && numext::imag(a) == 0;                                                            \
+    return a.real() == b && a.imag() == 0;                                                                          \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const T& a, const std::complex<T>& b) {                     \
-    return a == numext::real(b) && 0 == numext::imag(b);                                                            \
+    return a == b.real() && 0 == b.imag();                                                                          \
   }                                                                                                                 \
                                                                                                                     \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator!=(const std::complex<T>& a, const std::complex<T>& b) {       \
@@ -189,6 +214,8 @@
 }  // namespace internal
 }  // namespace Eigen
 
+#undef EIGEN_USING_STD_COMPLEX_OPERATORS
+
 #endif  // !(EIGEN_COMP_ICC && _USE_COMPLEX_SPECIALIZATION_)
 
 #endif  // EIGEN_GPUCC && EIGEN_GPU_COMPILE_PHASE
diff --git a/Eigen/src/Core/arch/GPU/MathFunctions.h b/Eigen/src/Core/arch/GPU/MathFunctions.h
index 81bc8bb..e94a02f 100644
--- a/Eigen/src/Core/arch/GPU/MathFunctions.h
+++ b/Eigen/src/Core/arch/GPU/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_GPU_H
 #define EIGEN_MATH_FUNCTIONS_GPU_H
@@ -60,7 +61,7 @@
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pexp2<double2>(const double2& a) {
-  using ::exp;
+  using ::exp2;
   return make_double2(exp2(a.x), exp2(a.y));
 }
 
diff --git a/Eigen/src/Core/arch/GPU/PacketMath.h b/Eigen/src/Core/arch/GPU/PacketMath.h
index 7d062f3..12dfd21 100644
--- a/Eigen/src/Core/arch/GPU/PacketMath.h
+++ b/Eigen/src/Core/arch/GPU/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_GPU_H
 #define EIGEN_PACKET_MATH_GPU_H
@@ -17,28 +18,8 @@
 
 namespace internal {
 
-// Read-only data cached load available.
-#if defined(EIGEN_HIP_DEVICE_COMPILE) || (defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350)
-#define EIGEN_GPU_HAS_LDG 1
-#endif
-
-// FP16 math available.
-#if (defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530)
-#define EIGEN_CUDA_HAS_FP16_ARITHMETIC 1
-#endif
-
-#if defined(EIGEN_HIP_DEVICE_COMPILE) || defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
-#define EIGEN_GPU_HAS_FP16_ARITHMETIC 1
-#endif
-
-// We need to distinguish ‘clang as the CUDA compiler’ from ‘clang as the host compiler,
-// invoked by NVCC’ (e.g. on MacOS). The former needs to see both host and device implementation
-// of the functions, while the latter can only deal with one of them.
-#if defined(EIGEN_CUDA_ARCH) || defined(EIGEN_HIPCC) || (defined(EIGEN_CUDACC) && EIGEN_COMP_CLANG && !EIGEN_COMP_NVCC)
-#define EIGEN_HAS_GPU_DEVICE_FUNCTIONS 1
-#else
-#define EIGEN_HAS_GPU_DEVICE_FUNCTIONS 0
-#endif
+// Read-only data cached load (__ldg) and native FP16 arithmetic are available
+// on all supported GPU architectures (sm_60+ for CUDA, GFX906+ for HIP).
 
 // Make sure this is only available when targeting a GPU: we don't want to
 // introduce conflicts between these packet_traits definitions and the ones
@@ -46,102 +27,91 @@
 #if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
 
 template <>
-struct is_arithmetic<float4> {
-  enum { value = true };
-};
+struct is_arithmetic<float4> : std::true_type {};
 template <>
-struct is_arithmetic<double2> {
-  enum { value = true };
-};
+struct is_arithmetic<double2> : std::true_type {};
 
 template <>
 struct packet_traits<float> : default_packet_traits {
-  typedef float4 type;
-  typedef float4 half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = 4,
+  using type = float4;
+  using half = float4;
+  static constexpr int Vectorizable = 1;
+  static constexpr int AlignedOnScalar = 1;
+  static constexpr int size = 4;
 
-    HasDiv = 1,
-    HasSin = 0,
-    HasCos = 0,
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1,
-    HasRsqrt = 1,
-    HasLGamma = 1,
-    HasDiGamma = 1,
-    HasZeta = 1,
-    HasPolygamma = 1,
-    HasErf = 1,
-    HasErfc = 1,
-    HasNdtri = 1,
-    HasBessel = 1,
-    HasIGamma = 1,
-    HasIGammaDerA = 1,
-    HasGammaSampleDerAlpha = 1,
-    HasIGammac = 1,
-    HasBetaInc = 1,
+  static constexpr int HasDiv = 1;
+  static constexpr int HasSin = 0;
+  static constexpr int HasCos = 0;
+  static constexpr int HasLog = 1;
+  static constexpr int HasExp = 1;
+  static constexpr int HasSqrt = 1;
+  static constexpr int HasRsqrt = 1;
+  static constexpr int HasLGamma = 1;
+  static constexpr int HasDiGamma = 1;
+  static constexpr int HasZeta = 1;
+  static constexpr int HasPolygamma = 1;
+  static constexpr int HasErf = 1;
+  static constexpr int HasErfc = 1;
+  static constexpr int HasNdtri = 1;
+  static constexpr int HasBessel = 1;
+  static constexpr int HasIGamma = 1;
+  static constexpr int HasIGammaDerA = 1;
+  static constexpr int HasGammaSampleDerAlpha = 1;
+  static constexpr int HasIGammac = 1;
+  static constexpr int HasBetaInc = 1;
 
-    HasFloor = 1,
-    HasCmp = EIGEN_HAS_GPU_DEVICE_FUNCTIONS
-  };
+  static constexpr int HasCmp = 1;
 };
 
 template <>
 struct packet_traits<double> : default_packet_traits {
-  typedef double2 type;
-  typedef double2 half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = 2,
+  using type = double2;
+  using half = double2;
+  static constexpr int Vectorizable = 1;
+  static constexpr int AlignedOnScalar = 1;
+  static constexpr int size = 2;
 
-    HasDiv = 1,
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1,
-    HasRsqrt = 1,
-    HasLGamma = 1,
-    HasDiGamma = 1,
-    HasZeta = 1,
-    HasPolygamma = 1,
-    HasErf = 1,
-    HasErfc = 1,
-    HasNdtri = 1,
-    HasBessel = 1,
-    HasIGamma = 1,
-    HasIGammaDerA = 1,
-    HasGammaSampleDerAlpha = 1,
-    HasIGammac = 1,
-    HasBetaInc = 1,
-  };
+  static constexpr int HasDiv = 1;
+  static constexpr int HasLog = 1;
+  static constexpr int HasExp = 1;
+  static constexpr int HasSqrt = 1;
+  static constexpr int HasRsqrt = 1;
+  static constexpr int HasLGamma = 1;
+  static constexpr int HasDiGamma = 1;
+  static constexpr int HasZeta = 1;
+  static constexpr int HasPolygamma = 1;
+  static constexpr int HasErf = 1;
+  static constexpr int HasErfc = 1;
+  static constexpr int HasNdtri = 1;
+  static constexpr int HasBessel = 1;
+  static constexpr int HasIGamma = 1;
+  static constexpr int HasIGammaDerA = 1;
+  static constexpr int HasGammaSampleDerAlpha = 1;
+  static constexpr int HasIGammac = 1;
+  static constexpr int HasBetaInc = 1;
+
+  static constexpr int HasCmp = 1;
 };
 
 template <>
 struct unpacket_traits<float4> {
-  typedef float type;
-  enum {
-    size = 4,
-    alignment = Aligned16,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-  typedef float4 half;
+  using type = float;
+  static constexpr int size = 4;
+  static constexpr int alignment = Aligned16;
+  static constexpr bool vectorizable = true;
+  static constexpr bool masked_load_available = false;
+  static constexpr bool masked_store_available = false;
+  using half = float4;
 };
 template <>
 struct unpacket_traits<double2> {
-  typedef double type;
-  enum {
-    size = 2,
-    alignment = Aligned16,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-  typedef double2 half;
+  using type = double;
+  static constexpr int size = 2;
+  static constexpr int alignment = Aligned16;
+  static constexpr bool vectorizable = true;
+  static constexpr bool masked_load_available = false;
+  static constexpr bool masked_store_available = false;
+  using half = double2;
 };
 
 template <>
@@ -153,56 +123,50 @@
   return make_double2(from, from);
 }
 
-#if EIGEN_HAS_GPU_DEVICE_FUNCTIONS
+// Bit-level helpers on the scalar lanes. numext::bit_cast rather than the __int_as_float family, which are device
+// intrinsics: a .cu translation unit that defines EIGEN_USE_GPU instantiates these packet types in the host pass
+// too, and an operation that exists in only one of the two passes makes packet_traits differ between them.
+template <typename T>
+using lane_bits_t = typename numext::get_integer_by_size<sizeof(T)>::unsigned_type;
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_and(const float& a, const float& b) {
-  return __int_as_float(__float_as_int(a) & __float_as_int(b));
-}
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_and(const double& a, const double& b) {
-  return __longlong_as_double(__double_as_longlong(a) & __double_as_longlong(b));
+#define EIGEN_MAKE_BITWISE_BINOP(name, op)                                                                 \
+  template <typename T>                                                                                    \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T bitwise_##name(const T& a, const T& b) {                         \
+    using Bits = lane_bits_t<T>;                                                                           \
+    return numext::bit_cast<T>(static_cast<Bits>(numext::bit_cast<Bits>(a) op numext::bit_cast<Bits>(b))); \
+  }
+
+EIGEN_MAKE_BITWISE_BINOP(and, &)
+EIGEN_MAKE_BITWISE_BINOP(or, |)
+EIGEN_MAKE_BITWISE_BINOP(xor, ^)
+EIGEN_MAKE_BITWISE_BINOP(andnot, &~)
+
+#undef EIGEN_MAKE_BITWISE_BINOP
+
+// A comparison returns an all-ones lane where it holds and an all-zero lane elsewhere, so that the result can be
+// consumed bitwise by pselect, pand and pandnot.
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T mask_from(bool condition) {
+  using Bits = lane_bits_t<T>;
+  return numext::bit_cast<T>(condition ? ~Bits(0) : Bits(0));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_or(const float& a, const float& b) {
-  return __int_as_float(__float_as_int(a) | __float_as_int(b));
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T eq_mask(const T& a, const T& b) {
+  return mask_from<T>(a == b);
 }
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_or(const double& a, const double& b) {
-  return __longlong_as_double(__double_as_longlong(a) | __double_as_longlong(b));
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T lt_mask(const T& a, const T& b) {
+  return mask_from<T>(a < b);
 }
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_xor(const float& a, const float& b) {
-  return __int_as_float(__float_as_int(a) ^ __float_as_int(b));
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T le_mask(const T& a, const T& b) {
+  return mask_from<T>(a <= b);
 }
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_xor(const double& a, const double& b) {
-  return __longlong_as_double(__double_as_longlong(a) ^ __double_as_longlong(b));
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float bitwise_andnot(const float& a, const float& b) {
-  return __int_as_float(__float_as_int(a) & ~__float_as_int(b));
-}
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bitwise_andnot(const double& a, const double& b) {
-  return __longlong_as_double(__double_as_longlong(a) & ~__double_as_longlong(b));
-}
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float eq_mask(const float& a, const float& b) {
-  return __int_as_float(a == b ? 0xffffffffu : 0u);
-}
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double eq_mask(const double& a, const double& b) {
-  return __longlong_as_double(a == b ? 0xffffffffffffffffull : 0ull);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float lt_mask(const float& a, const float& b) {
-  return __int_as_float(a < b ? 0xffffffffu : 0u);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double lt_mask(const double& a, const double& b) {
-  return __longlong_as_double(a < b ? 0xffffffffffffffffull : 0ull);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float le_mask(const float& a, const float& b) {
-  return __int_as_float(a <= b ? 0xffffffffu : 0u);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double le_mask(const double& a, const double& b) {
-  return __longlong_as_double(a <= b ? 0xffffffffffffffffull : 0ull);
+// !(a >= b), so a NaN operand makes the lane true.
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T lt_or_nan_mask(const T& a, const T& b) {
+  return mask_from<T>(!(a >= b));
 }
 
 template <>
@@ -255,6 +219,11 @@
   return make_float4(le_mask(a.x, b.x), le_mask(a.y, b.y), le_mask(a.z, b.z), le_mask(a.w, b.w));
 }
 template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcmp_lt_or_nan<float4>(const float4& a, const float4& b) {
+  return make_float4(lt_or_nan_mask(a.x, b.x), lt_or_nan_mask(a.y, b.y), lt_or_nan_mask(a.z, b.z),
+                     lt_or_nan_mask(a.w, b.w));
+}
+template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pcmp_eq<double2>(const double2& a, const double2& b) {
   return make_double2(eq_mask(a.x, b.x), eq_mask(a.y, b.y));
 }
@@ -266,7 +235,34 @@
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pcmp_le<double2>(const double2& a, const double2& b) {
   return make_double2(le_mask(a.x, b.x), le_mask(a.y, b.y));
 }
-#endif  // EIGEN_HAS_GPU_DEVICE_FUNCTIONS
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pcmp_lt_or_nan<double2>(const double2& a, const double2& b) {
+  return make_double2(lt_or_nan_mask(a.x, b.x), lt_or_nan_mask(a.y, b.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_any(const float4& a) {
+  using Bits = lane_bits_t<float>;
+  return (numext::bit_cast<Bits>(a.x) | numext::bit_cast<Bits>(a.y) | numext::bit_cast<Bits>(a.z) |
+          numext::bit_cast<Bits>(a.w)) != 0;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_any(const double2& a) {
+  using Bits = lane_bits_t<double>;
+  return (numext::bit_cast<Bits>(a.x) | numext::bit_cast<Bits>(a.y)) != 0;
+}
+
+// numext::sign: 0 for either zero, NaN for NaN, +/-1 otherwise. default_packet_traits advertises HasSign, so
+// without these the flag was a promise the backend did not keep (the generic form does not compile for float4).
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 psign<float4>(const float4& a) {
+  return make_float4(numext::sign(a.x), numext::sign(a.y), numext::sign(a.z), numext::sign(a.w));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 psign<double2>(const double2& a) {
+  return make_double2(numext::sign(a.x), numext::sign(a.y));
+}
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 plset<float4>(const float& a) {
@@ -305,15 +301,6 @@
 }
 
 template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pconj(const float4& a) {
-  return a;
-}
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pconj(const double2& a) {
-  return a;
-}
-
-template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pmul<float4>(const float4& a, const float4& b) {
   return make_float4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
 }
@@ -403,7 +390,7 @@
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Aligned>(const float* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   return __ldg(reinterpret_cast<const float4*>(from));
 #else
   return make_float4(from[0], from[1], from[2], from[3]);
@@ -411,7 +398,7 @@
 }
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Aligned>(const double* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   return __ldg(reinterpret_cast<const double2*>(from));
 #else
   return make_double2(from[0], from[1]);
@@ -420,7 +407,7 @@
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float4 ploadt_ro<float4, Unaligned>(const float* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   return make_float4(__ldg(from + 0), __ldg(from + 1), __ldg(from + 2), __ldg(from + 3));
 #else
   return make_float4(from[0], from[1], from[2], from[3]);
@@ -428,7 +415,7 @@
 }
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double2 ploadt_ro<double2, Unaligned>(const double* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
+#if defined(EIGEN_GPU_COMPILE_PHASE)
   return make_double2(__ldg(from + 0), __ldg(from + 1));
 #else
   return make_double2(from[0], from[1]);
@@ -459,6 +446,15 @@
 }
 
 template <>
+EIGEN_DEVICE_FUNC inline float4 preverse(const float4& a) {
+  return make_float4(a.w, a.z, a.y, a.x);
+}
+template <>
+EIGEN_DEVICE_FUNC inline double2 preverse(const double2& a) {
+  return make_double2(a.y, a.x);
+}
+
+template <>
 EIGEN_DEVICE_FUNC inline float pfirst<float4>(const float4& a) {
   return a.x;
 }
@@ -548,6 +544,15 @@
   return make_double2(trunc(a.x), trunc(a.y));
 }
 
+template <>
+EIGEN_DEVICE_FUNC inline float4 pround<float4>(const float4& a) {
+  return make_float4(roundf(a.x), roundf(a.y), roundf(a.z), roundf(a.w));
+}
+template <>
+EIGEN_DEVICE_FUNC inline double2 pround<double2>(const double2& a) {
+  return make_double2(round(a.x), round(a.y));
+}
+
 EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<float4, 4>& kernel) {
   float tmp = kernel.packet[0].y;
   kernel.packet[0].y = kernel.packet[1].x;
@@ -582,488 +587,382 @@
 
 #endif  // defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
 
-// Half-packet functions are not available on the host for CUDA 9.0-9.2, only
-// on device. There is no benefit to using them on the host anyways, since they are
-// emulated.
-#if (defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)) && defined(EIGEN_GPU_COMPILE_PHASE)
+// Half-packet functions are only available in GPU device compilation — they use
+// intrinsics (__half2, etc.) that have no host-side benefit.
+#if defined(EIGEN_GPU_COMPILE_PHASE)
 
-typedef ulonglong2 Packet4h2;
+// Two packets over Eigen::half: the native two-lane half2, and Packet4h2, eight halves in four half2 lanes.
+// Packet4h2 stays an alias of ulonglong2 because the Tensor GPU kernels and TensorFlow name it that way.
+using Packet4h2 = ulonglong2;
 template <>
 struct unpacket_traits<Packet4h2> {
-  typedef Eigen::half type;
-  enum {
-    size = 8,
-    alignment = Aligned16,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-  typedef Packet4h2 half;
+  using type = Eigen::half;
+  static constexpr int size = 8;
+  static constexpr int alignment = Aligned16;
+  static constexpr bool vectorizable = true;
+  static constexpr bool masked_load_available = false;
+  static constexpr bool masked_store_available = false;
+  using half = Packet4h2;
 };
 template <>
-struct is_arithmetic<Packet4h2> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet4h2> : std::true_type {};
 
 template <>
 struct unpacket_traits<half2> {
-  typedef Eigen::half type;
-  enum {
-    size = 2,
-    alignment = Aligned16,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-  typedef half2 half;
+  using type = Eigen::half;
+  static constexpr int size = 2;
+  // half2 needs 4-byte alignment; Aligned8 is the smallest value the enum offers that satisfies it.
+  static constexpr int alignment = Aligned8;
+  static constexpr bool vectorizable = true;
+  static constexpr bool masked_load_available = false;
+  static constexpr bool masked_store_available = false;
+  using half = half2;
 };
 template <>
-struct is_arithmetic<half2> {
-  enum { value = true };
-};
+struct is_arithmetic<half2> : std::true_type {};
 
 template <>
 struct packet_traits<Eigen::half> : default_packet_traits {
-  typedef Packet4h2 type;
-  typedef Packet4h2 half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = 8,
-    HasAdd = 1,
-    HasSub = 1,
-    HasMul = 1,
-    HasDiv = 1,
-    HasSqrt = 1,
-    HasRsqrt = 1,
-    HasExp = 1,
-    HasExpm1 = 1,
-    HasLog = 1,
-    HasLog1p = 1
-  };
+  using type = Packet4h2;
+  using half = Packet4h2;
+  static constexpr int Vectorizable = 1;
+  static constexpr int AlignedOnScalar = 1;
+  static constexpr int size = 8;
+  static constexpr int HasAdd = 1;
+  static constexpr int HasSub = 1;
+  static constexpr int HasMul = 1;
+  static constexpr int HasDiv = 1;
+  static constexpr int HasSqrt = 1;
+  static constexpr int HasRsqrt = 1;
+  static constexpr int HasExp = 1;
+  static constexpr int HasExpm1 = 1;
+  static constexpr int HasLog = 1;
+  static constexpr int HasLog1p = 1;
+  // default_packet_traits turns these on, but there is no pfloor/pceil/print/ptrunc/pround and no psign for the
+  // half packets; advertising them makes the generic fallback the evaluator picks fail to compile.
+  static constexpr int HasRound = 0;
+  static constexpr int HasSign = 0;
 };
 
+// ---------------------------------------------------------------------------------------------------------------
+// half2, the native two-lane packet.
+
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pset1<half2>(const Eigen::half& from) {
   return __half2half2(from);
 }
 
 template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pset1<Packet4h2>(const Eigen::half& from) {
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  p_alias[0] = pset1<half2>(from);
-  p_alias[1] = pset1<half2>(from);
-  p_alias[2] = pset1<half2>(from);
-  p_alias[3] = pset1<half2>(from);
-  return r;
-}
-
-namespace {
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pload(const Eigen::half* from) {
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pload<half2>(const Eigen::half* from) {
   return *reinterpret_cast<const half2*>(from);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploadu(const Eigen::half* from) { return __halves2half2(from[0], from[1]); }
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploadu<half2>(const Eigen::half* from) {
+  return __halves2half2(from[0], from[1]);
+}
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploaddup(const Eigen::half* from) {
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ploaddup<half2>(const Eigen::half* from) {
   return __halves2half2(from[0], from[0]);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore(Eigen::half* to, const half2& from) {
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const half2& from) {
   *reinterpret_cast<half2*>(to) = from;
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu(Eigen::half* to, const half2& from) {
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const half2& from) {
   to[0] = __low2half(from);
   to[1] = __high2half(from);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro_aligned(const Eigen::half* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro<half2, Aligned>(const Eigen::half* from) {
   // Input is guaranteed to be properly aligned.
   return __ldg(reinterpret_cast<const half2*>(from));
-#else
-  return __halves2half2(*(from + 0), *(from + 1));
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro_unaligned(const Eigen::half* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE half2 ploadt_ro<half2, Unaligned>(const Eigen::half* from) {
   return __halves2half2(__ldg(from + 0), __ldg(from + 1));
-#else
-  return __halves2half2(*(from + 0), *(from + 1));
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pgather(const Eigen::half* from, Index stride) {
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pgather<Eigen::half, half2>(const Eigen::half* from, Index stride) {
   return __halves2half2(from[0 * stride], from[1 * stride]);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter(Eigen::half* to, const half2& from, Index stride) {
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, half2>(Eigen::half* to, const half2& from,
+                                                                        Index stride) {
   to[stride * 0] = __low2half(from);
   to[stride * 1] = __high2half(from);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst(const half2& a) { return __low2half(a); }
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pabs(const half2& a) {
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half result1 = half_impl::raw_uint16_to_half(a1.x & 0x7FFF);
-  half result2 = half_impl::raw_uint16_to_half(a2.x & 0x7FFF);
-  return __halves2half2(result1, result2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 preverse(const half2& a) {
+  return __halves2half2(__high2half(a), __low2half(a));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ptrue(const half2& /*a*/) {
-  half true_half = half_impl::raw_uint16_to_half(0xffffu);
-  return pset1<half2>(true_half);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst<half2>(const half2& a) {
+  return __low2half(a);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pzero(const half2& /*a*/) {
-  half false_half = half_impl::raw_uint16_to_half(0x0000u);
-  return pset1<half2>(false_half);
+// __low2half returns the CUDA type; Eigen::half is what carries the accessible raw field.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE numext::uint16_t low_bits(const half2& a) {
+  const Eigen::half low = __low2half(a);
+  return low.x;
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE numext::uint16_t high_bits(const half2& a) {
+  const Eigen::half high = __high2half(a);
+  return high.x;
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 half2_from_bits(numext::uint16_t low, numext::uint16_t high) {
+  return __halves2half2(half_impl::raw_uint16_to_half(low), half_impl::raw_uint16_to_half(high));
+}
+// An all-ones or all-zero lane: the mask form pselect and the bitwise operations consume.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half half_mask_from(bool condition) {
+  return half_impl::raw_uint16_to_half(condition ? 0xffffu : 0x0000u);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pabs<half2>(const half2& a) {
+  return half2_from_bits(low_bits(a) & 0x7FFF, high_bits(a) & 0x7FFF);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 ptrue<half2>(const half2& /*a*/) {
+  return pset1<half2>(half_mask_from(true));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pzero<half2>(const half2& /*a*/) {
+  return pset1<half2>(half_mask_from(false));
 }
 
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<half2, 2>& kernel) {
-  __half a1 = __low2half(kernel.packet[0]);
-  __half a2 = __high2half(kernel.packet[0]);
-  __half b1 = __low2half(kernel.packet[1]);
-  __half b2 = __high2half(kernel.packet[1]);
+  const Eigen::half a1 = __low2half(kernel.packet[0]);
+  const Eigen::half a2 = __high2half(kernel.packet[0]);
+  const Eigen::half b1 = __low2half(kernel.packet[1]);
+  const Eigen::half b2 = __high2half(kernel.packet[1]);
   kernel.packet[0] = __halves2half2(a1, b1);
   kernel.packet[1] = __halves2half2(a2, b2);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plset(const Eigen::half& a) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plset<half2>(const Eigen::half& a) {
   return __halves2half2(a, __hadd(a, __float2half(1.0f)));
-#else
-  float f = __half2float(a) + 1.0f;
-  return __halves2half2(a, __float2half(f));
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pselect(const half2& mask, const half2& a, const half2& b) {
-  half mask_low = __low2half(mask);
-  half mask_high = __high2half(mask);
-  half result_low = mask_low == half(0) ? __low2half(b) : __low2half(a);
-  half result_high = mask_high == half(0) ? __high2half(b) : __high2half(a);
-  return __halves2half2(result_low, result_high);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pselect<half2>(const half2& mask, const half2& a, const half2& b) {
+  const Eigen::half mask_low = __low2half(mask);
+  const Eigen::half mask_high = __high2half(mask);
+  const Eigen::half low = mask_low == Eigen::half(0) ? __low2half(b) : __low2half(a);
+  const Eigen::half high = mask_high == Eigen::half(0) ? __high2half(b) : __high2half(a);
+  return __halves2half2(low, high);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_eq(const half2& a, const half2& b) {
-  half true_half = half_impl::raw_uint16_to_half(0xffffu);
-  half false_half = half_impl::raw_uint16_to_half(0x0000u);
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half eq1 = __half2float(a1) == __half2float(b1) ? true_half : false_half;
-  half eq2 = __half2float(a2) == __half2float(b2) ? true_half : false_half;
-  return __halves2half2(eq1, eq2);
+// Conversion to float is exact for both half operands.
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_eq<half2>(const half2& a, const half2& b) {
+  return __halves2half2(half_mask_from(__low2float(a) == __low2float(b)),
+                        half_mask_from(__high2float(a) == __high2float(b)));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_lt<half2>(const half2& a, const half2& b) {
+  return __halves2half2(half_mask_from(__low2float(a) < __low2float(b)),
+                        half_mask_from(__high2float(a) < __high2float(b)));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_le<half2>(const half2& a, const half2& b) {
+  return __halves2half2(half_mask_from(__low2float(a) <= __low2float(b)),
+                        half_mask_from(__high2float(a) <= __high2float(b)));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_lt(const half2& a, const half2& b) {
-  half true_half = half_impl::raw_uint16_to_half(0xffffu);
-  half false_half = half_impl::raw_uint16_to_half(0x0000u);
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half eq1 = __half2float(a1) < __half2float(b1) ? true_half : false_half;
-  half eq2 = __half2float(a2) < __half2float(b2) ? true_half : false_half;
-  return __halves2half2(eq1, eq2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pand<half2>(const half2& a, const half2& b) {
+  return half2_from_bits(low_bits(a) & low_bits(b), high_bits(a) & high_bits(b));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 por<half2>(const half2& a, const half2& b) {
+  return half2_from_bits(low_bits(a) | low_bits(b), high_bits(a) | high_bits(b));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pxor<half2>(const half2& a, const half2& b) {
+  return half2_from_bits(low_bits(a) ^ low_bits(b), high_bits(a) ^ high_bits(b));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pandnot<half2>(const half2& a, const half2& b) {
+  return half2_from_bits(low_bits(a) & ~low_bits(b), high_bits(a) & ~high_bits(b));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcmp_le(const half2& a, const half2& b) {
-  half true_half = half_impl::raw_uint16_to_half(0xffffu);
-  half false_half = half_impl::raw_uint16_to_half(0x0000u);
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half eq1 = __half2float(a1) <= __half2float(b1) ? true_half : false_half;
-  half eq2 = __half2float(a2) <= __half2float(b2) ? true_half : false_half;
-  return __halves2half2(eq1, eq2);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pand(const half2& a, const half2& b) {
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half result1 = half_impl::raw_uint16_to_half(a1.x & b1.x);
-  half result2 = half_impl::raw_uint16_to_half(a2.x & b2.x);
-  return __halves2half2(result1, result2);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 por(const half2& a, const half2& b) {
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half result1 = half_impl::raw_uint16_to_half(a1.x | b1.x);
-  half result2 = half_impl::raw_uint16_to_half(a2.x | b2.x);
-  return __halves2half2(result1, result2);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pxor(const half2& a, const half2& b) {
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half result1 = half_impl::raw_uint16_to_half(a1.x ^ b1.x);
-  half result2 = half_impl::raw_uint16_to_half(a2.x ^ b2.x);
-  return __halves2half2(result1, result2);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pandnot(const half2& a, const half2& b) {
-  half a1 = __low2half(a);
-  half a2 = __high2half(a);
-  half b1 = __low2half(b);
-  half b2 = __high2half(b);
-  half result1 = half_impl::raw_uint16_to_half(a1.x & ~b1.x);
-  half result2 = half_impl::raw_uint16_to_half(a2.x & ~b2.x);
-  return __halves2half2(result1, result2);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd<half2>(const half2& a, const half2& b) {
   return __hadd2(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 + b1;
-  float r2 = a2 + b2;
-  return __floats2half2_rn(r1, r2);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psub(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psub<half2>(const half2& a, const half2& b) {
   return __hsub2(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 - b1;
-  float r2 = a2 - b2;
-  return __floats2half2_rn(r1, r2);
-#endif
 }
 
+template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pnegate(const half2& a) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
   return __hneg2(a);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  return __floats2half2_rn(-a1, -a2);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pconj(const half2& a) { return a; }
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul<half2>(const half2& a, const half2& b) {
   return __hmul2(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 * b1;
-  float r2 = a2 * b2;
-  return __floats2half2_rn(r1, r2);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmadd(const half2& a, const half2& b, const half2& c) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmadd<half2>(const half2& a, const half2& b, const half2& c) {
   return __hfma2(a, b, c);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float c1 = __low2float(c);
-  float c2 = __high2float(c);
-  float r1 = a1 * b1 + c1;
-  float r2 = a2 * b2 + c2;
-  return __floats2half2_rn(r1, r2);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv<half2>(const half2& a, const half2& b) {
   return __h2div(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 / b1;
-  float r2 = a2 / b2;
-  return __floats2half2_rn(r1, r2);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin(const half2& a, const half2& b) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  __half r1 = a1 < b1 ? __low2half(a) : __low2half(b);
-  __half r2 = a2 < b2 ? __high2half(a) : __high2half(b);
-  return __halves2half2(r1, r2);
+// Compared through float, and every comparison against a NaN is false, so the result is b. This differs from
+// the fminf/fmaxf of the float packets, which return the non-NaN operand: here a NaN in b propagates and a
+// NaN in a does not.
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin<half2>(const half2& a, const half2& b) {
+  const __half low = __low2float(a) < __low2float(b) ? __low2half(a) : __low2half(b);
+  const __half high = __high2float(a) < __high2float(b) ? __high2half(a) : __high2half(b);
+  return __halves2half2(low, high);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax(const half2& a, const half2& b) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  __half r1 = a1 > b1 ? __low2half(a) : __low2half(b);
-  __half r2 = a2 > b2 ? __high2half(a) : __high2half(b);
-  return __halves2half2(r1, r2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax<half2>(const half2& a, const half2& b) {
+  const __half low = __low2float(a) > __low2float(b) ? __low2half(a) : __low2half(b);
+  const __half high = __high2float(a) > __high2float(b) ? __high2half(a) : __high2half(b);
+  return __halves2half2(low, high);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux(const half2& a) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux<half2>(const half2& a) {
   return __hadd(__low2half(a), __high2half(a));
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  return Eigen::half(__float2half(a1 + a2));
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max(const half2& a) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
-  __half first = __low2half(a);
-  __half second = __high2half(a);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_any(const half2& a) {
+  return (low_bits(a) | high_bits(a)) != 0;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max<half2>(const half2& a) {
+  const __half first = __low2half(a);
+  const __half second = __high2half(a);
   return __hgt(first, second) ? first : second;
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  return a1 > a2 ? __low2half(a) : __high2half(a);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min(const half2& a) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
-  __half first = __low2half(a);
-  __half second = __high2half(a);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min<half2>(const half2& a) {
+  const __half first = __low2half(a);
+  const __half second = __high2half(a);
   return __hlt(first, second) ? first : second;
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  return a1 < a2 ? __low2half(a) : __high2half(a);
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul(const half2& a) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul<half2>(const half2& a) {
   return __hmul(__low2half(a), __high2half(a));
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  return Eigen::half(__float2half(a1 * a2));
-#endif
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog1p(const half2& a) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float r1 = log1pf(a1);
-  float r2 = log1pf(a2);
-  return __floats2half2_rn(r1, r2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog<half2>(const half2& a) {
+  return h2log(a);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexpm1(const half2& a) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float r1 = expm1f(a1);
-  float r2 = expm1f(a2);
-  return __floats2half2_rn(r1, r2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexp<half2>(const half2& a) {
+  return h2exp(a);
 }
 
-#if (EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)) || defined(EIGEN_HIP_DEVICE_COMPILE)
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog(const half2& a) { return h2log(a); }
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexp(const half2& a) { return h2exp(a); }
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psqrt(const half2& a) { return h2sqrt(a); }
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 prsqrt(const half2& a) { return h2rsqrt(a); }
-
-#else
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog(const half2& a) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float r1 = logf(a1);
-  float r2 = logf(a2);
-  return __floats2half2_rn(r1, r2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psqrt<half2>(const half2& a) {
+  return h2sqrt(a);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexp(const half2& a) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float r1 = expf(a1);
-  float r2 = expf(a2);
-  return __floats2half2_rn(r1, r2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 prsqrt<half2>(const half2& a) {
+  return h2rsqrt(a);
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 psqrt(const half2& a) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float r1 = sqrtf(a1);
-  float r2 = sqrtf(a2);
-  return __floats2half2_rn(r1, r2);
+// No native h2log1p/h2expm1; both go through float.
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 plog1p<half2>(const half2& a) {
+  return __floats2half2_rn(log1pf(__low2float(a)), log1pf(__high2float(a)));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 prsqrt(const half2& a) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float r1 = rsqrtf(a1);
-  float r2 = rsqrtf(a2);
-  return __floats2half2_rn(r1, r2);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pexpm1<half2>(const half2& a) {
+  return __floats2half2_rn(expm1f(__low2float(a)), expm1f(__high2float(a)));
 }
-#endif
-}  // namespace
+
+// ---------------------------------------------------------------------------------------------------------------
+// Packet4h2 is four half2 lanes in the two words of a ulonglong2, the alias the Tensor GPU kernels expect. Do not
+// replace the cast: reaching the lanes conformingly (shift and reassemble, or __half2_raw) stops the compiler
+// keeping them in registers, costing 168 SASS instructions against 152 for eight mixed half operations and 152
+// against 64 for an 8x8 ptranspose (sm_89, nvcc 13.3).
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 lane_half2(const Packet4h2& p, int i) {
+  return reinterpret_cast<const half2*>(&p)[i];
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 make_packet4h2(const half2& l0, const half2& l1, const half2& l2,
+                                                               const half2& l3) {
+  Packet4h2 r;
+  half2* lanes = reinterpret_cast<half2*>(&r);
+  lanes[0] = l0;
+  lanes[1] = l1;
+  lanes[2] = l2;
+  lanes[3] = l3;
+  return r;
+}
+
+// Every lane-wise operation is its half2 form applied to the four lanes; the macros keep that unroll in one place.
+#define EIGEN_GPU_PACKET4H2_UNARY(NAME)                                                           \
+  template <>                                                                                     \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 NAME<Packet4h2>(const Packet4h2& a) {           \
+    return make_packet4h2(NAME(lane_half2(a, 0)), NAME(lane_half2(a, 1)), NAME(lane_half2(a, 2)), \
+                          NAME(lane_half2(a, 3)));                                                \
+  }
+
+#define EIGEN_GPU_PACKET4H2_BINARY(NAME)                                                                       \
+  template <>                                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 NAME<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {    \
+    return make_packet4h2(NAME(lane_half2(a, 0), lane_half2(b, 0)), NAME(lane_half2(a, 1), lane_half2(b, 1)),  \
+                          NAME(lane_half2(a, 2), lane_half2(b, 2)), NAME(lane_half2(a, 3), lane_half2(b, 3))); \
+  }
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pset1<Packet4h2>(const Eigen::half& from) {
+  const half2 lane = pset1<half2>(from);
+  return make_packet4h2(lane, lane, lane, lane);
+}
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pload<Packet4h2>(const Eigen::half* from) {
   return *reinterpret_cast<const Packet4h2*>(from);
 }
 
-// unaligned load;
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 ploadu<Packet4h2>(const Eigen::half* from) {
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  p_alias[0] = ploadu(from + 0);
-  p_alias[1] = ploadu(from + 2);
-  p_alias[2] = ploadu(from + 4);
-  p_alias[3] = ploadu(from + 6);
-  return r;
+  return make_packet4h2(ploadu<half2>(from + 0), ploadu<half2>(from + 2), ploadu<half2>(from + 4),
+                        ploadu<half2>(from + 6));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 ploaddup<Packet4h2>(const Eigen::half* from) {
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  p_alias[0] = ploaddup(from + 0);
-  p_alias[1] = ploaddup(from + 1);
-  p_alias[2] = ploaddup(from + 2);
-  p_alias[3] = ploaddup(from + 3);
-  return r;
+  return make_packet4h2(ploaddup<half2>(from + 0), ploaddup<half2>(from + 1), ploaddup<half2>(from + 2),
+                        ploaddup<half2>(from + 3));
 }
 
 template <>
@@ -1073,635 +972,166 @@
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4h2& from) {
-  const half2* from_alias = reinterpret_cast<const half2*>(&from);
-  pstoreu(to + 0, from_alias[0]);
-  pstoreu(to + 2, from_alias[1]);
-  pstoreu(to + 4, from_alias[2]);
-  pstoreu(to + 6, from_alias[3]);
+  pstoreu<Eigen::half>(to + 0, lane_half2(from, 0));
+  pstoreu<Eigen::half>(to + 2, lane_half2(from, 1));
+  pstoreu<Eigen::half>(to + 4, lane_half2(from, 2));
+  pstoreu<Eigen::half>(to + 6, lane_half2(from, 3));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4h2 ploadt_ro<Packet4h2, Aligned>(const Eigen::half* from) {
-#if defined(EIGEN_GPU_HAS_LDG)
-  Packet4h2 r;
-  r = __ldg(reinterpret_cast<const Packet4h2*>(from));
-  return r;
-#else
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  r_alias[0] = ploadt_ro_aligned(from + 0);
-  r_alias[1] = ploadt_ro_aligned(from + 2);
-  r_alias[2] = ploadt_ro_aligned(from + 4);
-  r_alias[3] = ploadt_ro_aligned(from + 6);
-  return r;
-#endif
+  return __ldg(reinterpret_cast<const Packet4h2*>(from));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4h2 ploadt_ro<Packet4h2, Unaligned>(const Eigen::half* from) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  r_alias[0] = ploadt_ro_unaligned(from + 0);
-  r_alias[1] = ploadt_ro_unaligned(from + 2);
-  r_alias[2] = ploadt_ro_unaligned(from + 4);
-  r_alias[3] = ploadt_ro_unaligned(from + 6);
-  return r;
+  return make_packet4h2(ploadt_ro<half2, Unaligned>(from + 0), ploadt_ro<half2, Unaligned>(from + 2),
+                        ploadt_ro<half2, Unaligned>(from + 4), ploadt_ro<half2, Unaligned>(from + 6));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pgather<Eigen::half, Packet4h2>(const Eigen::half* from, Index stride) {
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  p_alias[0] = __halves2half2(from[0 * stride], from[1 * stride]);
-  p_alias[1] = __halves2half2(from[2 * stride], from[3 * stride]);
-  p_alias[2] = __halves2half2(from[4 * stride], from[5 * stride]);
-  p_alias[3] = __halves2half2(from[6 * stride], from[7 * stride]);
-  return r;
+  return make_packet4h2(
+      __halves2half2(from[0 * stride], from[1 * stride]), __halves2half2(from[2 * stride], from[3 * stride]),
+      __halves2half2(from[4 * stride], from[5 * stride]), __halves2half2(from[6 * stride], from[7 * stride]));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4h2>(Eigen::half* to, const Packet4h2& from,
                                                                             Index stride) {
-  const half2* from_alias = reinterpret_cast<const half2*>(&from);
-  pscatter(to + stride * 0, from_alias[0], stride);
-  pscatter(to + stride * 2, from_alias[1], stride);
-  pscatter(to + stride * 4, from_alias[2], stride);
-  pscatter(to + stride * 6, from_alias[3], stride);
+  pscatter<Eigen::half, half2>(to + stride * 0, lane_half2(from, 0), stride);
+  pscatter<Eigen::half, half2>(to + stride * 2, lane_half2(from, 1), stride);
+  pscatter<Eigen::half, half2>(to + stride * 4, lane_half2(from, 2), stride);
+  pscatter<Eigen::half, half2>(to + stride * 6, lane_half2(from, 3), stride);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 preverse(const Packet4h2& a) {
+  return make_packet4h2(preverse(lane_half2(a, 3)), preverse(lane_half2(a, 2)), preverse(lane_half2(a, 1)),
+                        preverse(lane_half2(a, 0)));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4h2>(const Packet4h2& a) {
-  return pfirst(*(reinterpret_cast<const half2*>(&a)));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pabs<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  p_alias[0] = pabs(a_alias[0]);
-  p_alias[1] = pabs(a_alias[1]);
-  p_alias[2] = pabs(a_alias[2]);
-  p_alias[3] = pabs(a_alias[3]);
-  return r;
+  return pfirst<half2>(lane_half2(a, 0));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 ptrue<Packet4h2>(const Packet4h2& /*a*/) {
-  half true_half = half_impl::raw_uint16_to_half(0xffffu);
-  return pset1<Packet4h2>(true_half);
+  return pset1<Packet4h2>(half_impl::raw_uint16_to_half(0xffffu));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pzero<Packet4h2>(const Packet4h2& /*a*/) {
-  half false_half = half_impl::raw_uint16_to_half(0x0000u);
-  return pset1<Packet4h2>(false_half);
+  return pset1<Packet4h2>(half_impl::raw_uint16_to_half(0x0000u));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_double(double* d_row0, double* d_row1, double* d_row2,
-                                                             double* d_row3, double* d_row4, double* d_row5,
-                                                             double* d_row6, double* d_row7) {
-  double d_tmp;
-  d_tmp = d_row0[1];
-  d_row0[1] = d_row4[0];
-  d_row4[0] = d_tmp;
-
-  d_tmp = d_row1[1];
-  d_row1[1] = d_row5[0];
-  d_row5[0] = d_tmp;
-
-  d_tmp = d_row2[1];
-  d_row2[1] = d_row6[0];
-  d_row6[0] = d_tmp;
-
-  d_tmp = d_row3[1];
-  d_row3[1] = d_row7[0];
-  d_row7[0] = d_tmp;
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_half2(half2* f_row0, half2* f_row1, half2* f_row2,
-                                                            half2* f_row3) {
-  half2 f_tmp;
-  f_tmp = f_row0[1];
-  f_row0[1] = f_row2[0];
-  f_row2[0] = f_tmp;
-
-  f_tmp = f_row1[1];
-  f_row1[1] = f_row3[0];
-  f_row3[0] = f_tmp;
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose_half(half2& f0, half2& f1) {
-  __half a1 = __low2half(f0);
-  __half a2 = __high2half(f0);
-  __half b1 = __low2half(f1);
-  __half b2 = __high2half(f1);
-  f0 = __halves2half2(a1, b1);
-  f1 = __halves2half2(a2, b2);
-}
-
+// An 8x8 transpose of halves: packet r of the result is column r of the input.
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4h2, 8>& kernel) {
-  double* d_row0 = reinterpret_cast<double*>(&kernel.packet[0]);
-  double* d_row1 = reinterpret_cast<double*>(&kernel.packet[1]);
-  double* d_row2 = reinterpret_cast<double*>(&kernel.packet[2]);
-  double* d_row3 = reinterpret_cast<double*>(&kernel.packet[3]);
-  double* d_row4 = reinterpret_cast<double*>(&kernel.packet[4]);
-  double* d_row5 = reinterpret_cast<double*>(&kernel.packet[5]);
-  double* d_row6 = reinterpret_cast<double*>(&kernel.packet[6]);
-  double* d_row7 = reinterpret_cast<double*>(&kernel.packet[7]);
-  ptranspose_double(d_row0, d_row1, d_row2, d_row3, d_row4, d_row5, d_row6, d_row7);
-
-  half2* f_row0 = reinterpret_cast<half2*>(d_row0);
-  half2* f_row1 = reinterpret_cast<half2*>(d_row1);
-  half2* f_row2 = reinterpret_cast<half2*>(d_row2);
-  half2* f_row3 = reinterpret_cast<half2*>(d_row3);
-  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
-  ptranspose_half(f_row0[0], f_row1[0]);
-  ptranspose_half(f_row0[1], f_row1[1]);
-  ptranspose_half(f_row2[0], f_row3[0]);
-  ptranspose_half(f_row2[1], f_row3[1]);
-
-  f_row0 = reinterpret_cast<half2*>(d_row0 + 1);
-  f_row1 = reinterpret_cast<half2*>(d_row1 + 1);
-  f_row2 = reinterpret_cast<half2*>(d_row2 + 1);
-  f_row3 = reinterpret_cast<half2*>(d_row3 + 1);
-  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
-  ptranspose_half(f_row0[0], f_row1[0]);
-  ptranspose_half(f_row0[1], f_row1[1]);
-  ptranspose_half(f_row2[0], f_row3[0]);
-  ptranspose_half(f_row2[1], f_row3[1]);
-
-  f_row0 = reinterpret_cast<half2*>(d_row4);
-  f_row1 = reinterpret_cast<half2*>(d_row5);
-  f_row2 = reinterpret_cast<half2*>(d_row6);
-  f_row3 = reinterpret_cast<half2*>(d_row7);
-  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
-  ptranspose_half(f_row0[0], f_row1[0]);
-  ptranspose_half(f_row0[1], f_row1[1]);
-  ptranspose_half(f_row2[0], f_row3[0]);
-  ptranspose_half(f_row2[1], f_row3[1]);
-
-  f_row0 = reinterpret_cast<half2*>(d_row4 + 1);
-  f_row1 = reinterpret_cast<half2*>(d_row5 + 1);
-  f_row2 = reinterpret_cast<half2*>(d_row6 + 1);
-  f_row3 = reinterpret_cast<half2*>(d_row7 + 1);
-  ptranspose_half2(f_row0, f_row1, f_row2, f_row3);
-  ptranspose_half(f_row0[0], f_row1[0]);
-  ptranspose_half(f_row0[1], f_row1[1]);
-  ptranspose_half(f_row2[0], f_row3[0]);
-  ptranspose_half(f_row2[1], f_row3[1]);
+  Eigen::half elements[8][8];
+  EIGEN_UNROLL_LOOP
+  for (int row = 0; row < 8; ++row) {
+    EIGEN_UNROLL_LOOP
+    for (int lane = 0; lane < 4; ++lane) {
+      const half2 pair = lane_half2(kernel.packet[row], lane);
+      elements[row][2 * lane] = __low2half(pair);
+      elements[row][2 * lane + 1] = __high2half(pair);
+    }
+  }
+  EIGEN_UNROLL_LOOP
+  for (int row = 0; row < 8; ++row) {
+    kernel.packet[row] = make_packet4h2(
+        __halves2half2(elements[0][row], elements[1][row]), __halves2half2(elements[2][row], elements[3][row]),
+        __halves2half2(elements[4][row], elements[5][row]), __halves2half2(elements[6][row], elements[7][row]));
+  }
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 plset<Packet4h2>(const Eigen::half& a) {
-#if defined(EIGEN_HIP_DEVICE_COMPILE)
-
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  p_alias[0] = __halves2half2(a, __hadd(a, __float2half(1.0f)));
-  p_alias[1] = __halves2half2(__hadd(a, __float2half(2.0f)), __hadd(a, __float2half(3.0f)));
-  p_alias[2] = __halves2half2(__hadd(a, __float2half(4.0f)), __hadd(a, __float2half(5.0f)));
-  p_alias[3] = __halves2half2(__hadd(a, __float2half(6.0f)), __hadd(a, __float2half(7.0f)));
-  return r;
-#elif defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-
-  half2 b = pset1<half2>(a);
-  half2 c;
-  half2 half_offset0 = __halves2half2(__float2half(0.0f), __float2half(2.0f));
-  half2 half_offset1 = __halves2half2(__float2half(4.0f), __float2half(6.0f));
-
-  c = __hadd2(b, half_offset0);
-  r_alias[0] = plset(__low2half(c));
-  r_alias[1] = plset(__high2half(c));
-
-  c = __hadd2(b, half_offset1);
-  r_alias[2] = plset(__low2half(c));
-  r_alias[3] = plset(__high2half(c));
-
-  return r;
-
-#else
-  float f = __half2float(a);
-  Packet4h2 r;
-  half2* p_alias = reinterpret_cast<half2*>(&r);
-  p_alias[0] = __halves2half2(a, __float2half(f + 1.0f));
-  p_alias[1] = __halves2half2(__float2half(f + 2.0f), __float2half(f + 3.0f));
-  p_alias[2] = __halves2half2(__float2half(f + 4.0f), __float2half(f + 5.0f));
-  p_alias[3] = __halves2half2(__float2half(f + 6.0f), __float2half(f + 7.0f));
-  return r;
-#endif
+  // Add each offset once: (a + 2*k) + 1 can round twice. Preserve a's sign in lane zero.
+  const half2 base = pset1<half2>(a);
+  return make_packet4h2(plset<half2>(a), __hadd2(base, __floats2half2_rn(2.0f, 3.0f)),
+                        __hadd2(base, __floats2half2_rn(4.0f, 5.0f)), __hadd2(base, __floats2half2_rn(6.0f, 7.0f)));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pselect<Packet4h2>(const Packet4h2& mask, const Packet4h2& a,
                                                                    const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* mask_alias = reinterpret_cast<const half2*>(&mask);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pselect(mask_alias[0], a_alias[0], b_alias[0]);
-  r_alias[1] = pselect(mask_alias[1], a_alias[1], b_alias[1]);
-  r_alias[2] = pselect(mask_alias[2], a_alias[2], b_alias[2]);
-  r_alias[3] = pselect(mask_alias[3], a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pcmp_eq<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pcmp_eq(a_alias[0], b_alias[0]);
-  r_alias[1] = pcmp_eq(a_alias[1], b_alias[1]);
-  r_alias[2] = pcmp_eq(a_alias[2], b_alias[2]);
-  r_alias[3] = pcmp_eq(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pcmp_lt<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pcmp_lt(a_alias[0], b_alias[0]);
-  r_alias[1] = pcmp_lt(a_alias[1], b_alias[1]);
-  r_alias[2] = pcmp_lt(a_alias[2], b_alias[2]);
-  r_alias[3] = pcmp_lt(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pcmp_le<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pcmp_le(a_alias[0], b_alias[0]);
-  r_alias[1] = pcmp_le(a_alias[1], b_alias[1]);
-  r_alias[2] = pcmp_le(a_alias[2], b_alias[2]);
-  r_alias[3] = pcmp_le(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pand<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pand(a_alias[0], b_alias[0]);
-  r_alias[1] = pand(a_alias[1], b_alias[1]);
-  r_alias[2] = pand(a_alias[2], b_alias[2]);
-  r_alias[3] = pand(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 por<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = por(a_alias[0], b_alias[0]);
-  r_alias[1] = por(a_alias[1], b_alias[1]);
-  r_alias[2] = por(a_alias[2], b_alias[2]);
-  r_alias[3] = por(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pxor<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pxor(a_alias[0], b_alias[0]);
-  r_alias[1] = pxor(a_alias[1], b_alias[1]);
-  r_alias[2] = pxor(a_alias[2], b_alias[2]);
-  r_alias[3] = pxor(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pandnot<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pandnot(a_alias[0], b_alias[0]);
-  r_alias[1] = pandnot(a_alias[1], b_alias[1]);
-  r_alias[2] = pandnot(a_alias[2], b_alias[2]);
-  r_alias[3] = pandnot(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 padd<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = padd(a_alias[0], b_alias[0]);
-  r_alias[1] = padd(a_alias[1], b_alias[1]);
-  r_alias[2] = padd(a_alias[2], b_alias[2]);
-  r_alias[3] = padd(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 psub<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = psub(a_alias[0], b_alias[0]);
-  r_alias[1] = psub(a_alias[1], b_alias[1]);
-  r_alias[2] = psub(a_alias[2], b_alias[2]);
-  r_alias[3] = psub(a_alias[3], b_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pnegate(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = pnegate(a_alias[0]);
-  r_alias[1] = pnegate(a_alias[1]);
-  r_alias[2] = pnegate(a_alias[2]);
-  r_alias[3] = pnegate(a_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pconj(const Packet4h2& a) {
-  return a;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmul<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pmul(a_alias[0], b_alias[0]);
-  r_alias[1] = pmul(a_alias[1], b_alias[1]);
-  r_alias[2] = pmul(a_alias[2], b_alias[2]);
-  r_alias[3] = pmul(a_alias[3], b_alias[3]);
-  return r;
+  return make_packet4h2(pselect<half2>(lane_half2(mask, 0), lane_half2(a, 0), lane_half2(b, 0)),
+                        pselect<half2>(lane_half2(mask, 1), lane_half2(a, 1), lane_half2(b, 1)),
+                        pselect<half2>(lane_half2(mask, 2), lane_half2(a, 2), lane_half2(b, 2)),
+                        pselect<half2>(lane_half2(mask, 3), lane_half2(a, 3), lane_half2(b, 3)));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmadd<Packet4h2>(const Packet4h2& a, const Packet4h2& b,
                                                                  const Packet4h2& c) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  const half2* c_alias = reinterpret_cast<const half2*>(&c);
-  r_alias[0] = pmadd(a_alias[0], b_alias[0], c_alias[0]);
-  r_alias[1] = pmadd(a_alias[1], b_alias[1], c_alias[1]);
-  r_alias[2] = pmadd(a_alias[2], b_alias[2], c_alias[2]);
-  r_alias[3] = pmadd(a_alias[3], b_alias[3], c_alias[3]);
-  return r;
+  return make_packet4h2(pmadd<half2>(lane_half2(a, 0), lane_half2(b, 0), lane_half2(c, 0)),
+                        pmadd<half2>(lane_half2(a, 1), lane_half2(b, 1), lane_half2(c, 1)),
+                        pmadd<half2>(lane_half2(a, 2), lane_half2(b, 2), lane_half2(c, 2)),
+                        pmadd<half2>(lane_half2(a, 3), lane_half2(b, 3), lane_half2(c, 3)));
 }
 
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pdiv<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pdiv(a_alias[0], b_alias[0]);
-  r_alias[1] = pdiv(a_alias[1], b_alias[1]);
-  r_alias[2] = pdiv(a_alias[2], b_alias[2]);
-  r_alias[3] = pdiv(a_alias[3], b_alias[3]);
-  return r;
-}
+EIGEN_GPU_PACKET4H2_UNARY(pabs)
+EIGEN_GPU_PACKET4H2_UNARY(pnegate)
+EIGEN_GPU_PACKET4H2_UNARY(plog)
+EIGEN_GPU_PACKET4H2_UNARY(pexp)
+EIGEN_GPU_PACKET4H2_UNARY(psqrt)
+EIGEN_GPU_PACKET4H2_UNARY(prsqrt)
+EIGEN_GPU_PACKET4H2_UNARY(plog1p)
+EIGEN_GPU_PACKET4H2_UNARY(pexpm1)
 
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmin<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pmin(a_alias[0], b_alias[0]);
-  r_alias[1] = pmin(a_alias[1], b_alias[1]);
-  r_alias[2] = pmin(a_alias[2], b_alias[2]);
-  r_alias[3] = pmin(a_alias[3], b_alias[3]);
-  return r;
-}
+EIGEN_GPU_PACKET4H2_BINARY(padd)
+EIGEN_GPU_PACKET4H2_BINARY(psub)
+EIGEN_GPU_PACKET4H2_BINARY(pmul)
+EIGEN_GPU_PACKET4H2_BINARY(pdiv)
+EIGEN_GPU_PACKET4H2_BINARY(pmin)
+EIGEN_GPU_PACKET4H2_BINARY(pmax)
+EIGEN_GPU_PACKET4H2_BINARY(pand)
+EIGEN_GPU_PACKET4H2_BINARY(por)
+EIGEN_GPU_PACKET4H2_BINARY(pxor)
+EIGEN_GPU_PACKET4H2_BINARY(pandnot)
+EIGEN_GPU_PACKET4H2_BINARY(pcmp_eq)
+EIGEN_GPU_PACKET4H2_BINARY(pcmp_lt)
+EIGEN_GPU_PACKET4H2_BINARY(pcmp_le)
 
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pmax<Packet4h2>(const Packet4h2& a, const Packet4h2& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  const half2* b_alias = reinterpret_cast<const half2*>(&b);
-  r_alias[0] = pmax(a_alias[0], b_alias[0]);
-  r_alias[1] = pmax(a_alias[1], b_alias[1]);
-  r_alias[2] = pmax(a_alias[2], b_alias[2]);
-  r_alias[3] = pmax(a_alias[3], b_alias[3]);
-  return r;
-}
+#undef EIGEN_GPU_PACKET4H2_UNARY
+#undef EIGEN_GPU_PACKET4H2_BINARY
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux<Packet4h2>(const Packet4h2& a) {
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
+  return predux(lane_half2(a, 0)) + predux(lane_half2(a, 1)) + predux(lane_half2(a, 2)) + predux(lane_half2(a, 3));
+}
 
-  return predux(a_alias[0]) + predux(a_alias[1]) + predux(a_alias[2]) + predux(a_alias[3]);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_any(const Packet4h2& a) {
+  return predux_any(lane_half2(a, 0)) | predux_any(lane_half2(a, 1)) | predux_any(lane_half2(a, 2)) |
+         predux_any(lane_half2(a, 3));
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_max<Packet4h2>(const Packet4h2& a) {
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  half2 m0 = __halves2half2(predux_max(a_alias[0]), predux_max(a_alias[1]));
-  half2 m1 = __halves2half2(predux_max(a_alias[2]), predux_max(a_alias[3]));
-  __half first = predux_max(m0);
-  __half second = predux_max(m1);
-#if defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
-  return (__hgt(first, second) ? first : second);
-#else
-  float ffirst = __half2float(first);
-  float fsecond = __half2float(second);
-  return (ffirst > fsecond) ? first : second;
-#endif
+  const half2 m =
+      pmax<half2>(pmax<half2>(lane_half2(a, 0), lane_half2(a, 1)), pmax<half2>(lane_half2(a, 2), lane_half2(a, 3)));
+  return predux_max<half2>(m);
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_min<Packet4h2>(const Packet4h2& a) {
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  half2 m0 = __halves2half2(predux_min(a_alias[0]), predux_min(a_alias[1]));
-  half2 m1 = __halves2half2(predux_min(a_alias[2]), predux_min(a_alias[3]));
-  __half first = predux_min(m0);
-  __half second = predux_min(m1);
-#if defined(EIGEN_CUDA_HAS_FP16_ARITHMETIC)
-  return (__hlt(first, second) ? first : second);
-#else
-  float ffirst = __half2float(first);
-  float fsecond = __half2float(second);
-  return (ffirst < fsecond) ? first : second;
-#endif
+  const half2 m =
+      pmin<half2>(pmin<half2>(lane_half2(a, 0), lane_half2(a, 1)), pmin<half2>(lane_half2(a, 2), lane_half2(a, 3)));
+  return predux_min<half2>(m);
 }
 
-// likely overflow/underflow
+// Likely to overflow or underflow: eight halves multiplied together.
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet4h2>(const Packet4h2& a) {
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  return predux_mul(pmul(pmul(a_alias[0], a_alias[1]), pmul(a_alias[2], a_alias[3])));
+  const half2 product =
+      pmul<half2>(pmul<half2>(lane_half2(a, 0), lane_half2(a, 1)), pmul<half2>(lane_half2(a, 2), lane_half2(a, 3)));
+  return predux_mul<half2>(product);
 }
 
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 plog1p<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = plog1p(a_alias[0]);
-  r_alias[1] = plog1p(a_alias[1]);
-  r_alias[2] = plog1p(a_alias[2]);
-  r_alias[3] = plog1p(a_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pexpm1<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = pexpm1(a_alias[0]);
-  r_alias[1] = pexpm1(a_alias[1]);
-  r_alias[2] = pexpm1(a_alias[2]);
-  r_alias[3] = pexpm1(a_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 plog<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = plog(a_alias[0]);
-  r_alias[1] = plog(a_alias[1]);
-  r_alias[2] = plog(a_alias[2]);
-  r_alias[3] = plog(a_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pexp<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = pexp(a_alias[0]);
-  r_alias[1] = pexp(a_alias[1]);
-  r_alias[2] = pexp(a_alias[2]);
-  r_alias[3] = pexp(a_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 psqrt<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = psqrt(a_alias[0]);
-  r_alias[1] = psqrt(a_alias[1]);
-  r_alias[2] = psqrt(a_alias[2]);
-  r_alias[3] = psqrt(a_alias[3]);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 prsqrt<Packet4h2>(const Packet4h2& a) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  r_alias[0] = prsqrt(a_alias[0]);
-  r_alias[1] = prsqrt(a_alias[1]);
-  r_alias[2] = prsqrt(a_alias[2]);
-  r_alias[3] = prsqrt(a_alias[3]);
-  return r;
-}
-
-// The following specialized padd, pmul, pdiv, pmin, pmax, pset1 are needed for
-// the implementation of GPU half reduction.
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 padd<half2>(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
-  return __hadd2(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 + b1;
-  float r2 = a2 + b2;
-  return __floats2half2_rn(r1, r2);
-#endif
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmul<half2>(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
-  return __hmul2(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 * b1;
-  float r2 = a2 * b2;
-  return __floats2half2_rn(r1, r2);
-#endif
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pdiv<half2>(const half2& a, const half2& b) {
-#if defined(EIGEN_GPU_HAS_FP16_ARITHMETIC)
-  return __h2div(a, b);
-#else
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  float r1 = a1 / b1;
-  float r2 = a2 / b2;
-  return __floats2half2_rn(r1, r2);
-#endif
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmin<half2>(const half2& a, const half2& b) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  __half r1 = a1 < b1 ? __low2half(a) : __low2half(b);
-  __half r2 = a2 < b2 ? __high2half(a) : __high2half(b);
-  return __halves2half2(r1, r2);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pmax<half2>(const half2& a, const half2& b) {
-  float a1 = __low2float(a);
-  float a2 = __high2float(a);
-  float b1 = __low2float(b);
-  float b2 = __high2float(b);
-  __half r1 = a1 > b1 ? __low2half(a) : __low2half(b);
-  __half r2 = a2 > b2 ? __high2half(a) : __high2half(b);
-  return __halves2half2(r1, r2);
-}
-
-#endif  // (defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)) && defined(EIGEN_GPU_COMPILE_PHASE)
-
-#undef EIGEN_GPU_HAS_LDG
-#undef EIGEN_CUDA_HAS_FP16_ARITHMETIC
-#undef EIGEN_GPU_HAS_FP16_ARITHMETIC
+#endif  // defined(EIGEN_GPU_COMPILE_PHASE)
 
 }  // end namespace internal
 
diff --git a/Eigen/src/Core/arch/GPU/Tuple.h b/Eigen/src/Core/arch/GPU/Tuple.h
index 0e74487..4bbb8de 100644
--- a/Eigen/src/Core/arch/GPU/Tuple.h
+++ b/Eigen/src/Core/arch/GPU/Tuple.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TUPLE_GPU
 #define EIGEN_TUPLE_GPU
@@ -187,7 +188,7 @@
 // For use in make_tuple, decays a type and unwraps a reference_wrapper.
 template <typename T>
 struct unwrap_decay {
-  using type = typename unwrap_reference_wrapper<typename std::decay<T>::type>::type;
+  using type = typename unwrap_reference_wrapper<std::decay_t<T>>::type;
 };
 
 /**
@@ -223,12 +224,12 @@
  * \param tuples ... list of tuples.
  * \return concatenated tuple.
  */
-template <typename... Tuples, typename EnableIf = std::enable_if_t<
-                                  internal::reduce_all<is_tuple<typename std::decay<Tuples>::type>::value...>::value>>
+template <typename... Tuples,
+          typename EnableIf = std::enable_if_t<internal::reduce_all<is_tuple<std::decay_t<Tuples>>::value...>::value>>
 constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    typename tuple_cat_impl<sizeof...(Tuples), typename std::decay<Tuples>::type...>::ReturnType
+    typename tuple_cat_impl<sizeof...(Tuples), std::decay_t<Tuples>...>::ReturnType
     tuple_cat(Tuples&&... tuples) {
-  return tuple_cat_impl<sizeof...(Tuples), typename std::decay<Tuples>::type...>::run(std::forward<Tuples>(tuples)...);
+  return tuple_cat_impl<sizeof...(Tuples), std::decay_t<Tuples>...>::run(std::forward<Tuples>(tuples)...);
 }
 
 /**
diff --git a/Eigen/src/Core/arch/GPU/TypeCasting.h b/Eigen/src/Core/arch/GPU/TypeCasting.h
index ae43f8e..2cba5aa 100644
--- a/Eigen/src/Core/arch/GPU/TypeCasting.h
+++ b/Eigen/src/Core/arch/GPU/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_GPU_H
 #define EIGEN_TYPE_CASTING_GPU_H
@@ -17,55 +18,31 @@
 
 namespace internal {
 
-#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
-    (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+
+// Both ratios follow from the packet sizes (8 halves, 4 floats), which is exactly what
+// vectorized_type_casting_traits computes; restating them by hand let them drift from the packets.
+template <>
+struct type_casting_traits<Eigen::half, float> : vectorized_type_casting_traits<Eigen::half, float> {};
 
 template <>
-struct type_casting_traits<Eigen::half, float> {
-  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
-};
+struct type_casting_traits<float, Eigen::half> : vectorized_type_casting_traits<float, Eigen::half> {};
 
+// Widening: one Packet4h2 covers two float4, so the evaluator calls this once per output packet with the same
+// source and takes the first four lanes, then the second four. Narrowing: two float4 make one Packet4h2.
+// CoreEvaluators.h loads a source segment of DstPacketSize elements for TgtCoeffRatio == 2 and TensorConversion.h
+// does the same, so the one-argument form returning the low half is the protocol, not a truncation bug.
 template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<half2, float4>(const half2& a, const half2& b) {
-  float2 r1 = __half22float2(a);
-  float2 r2 = __half22float2(b);
-  return make_float4(r1.x, r1.y, r2.x, r2.y);
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<Packet4h2, float4>(const Packet4h2& a) {
+  const float2 low = __half22float2(lane_half2(a, 0));
+  const float2 high = __half22float2(lane_half2(a, 1));
+  return make_float4(low.x, low.y, high.x, high.y);
 }
 
 template <>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4h2 pcast<float4, Packet4h2>(const float4& a, const float4& b) {
-  Packet4h2 r;
-  half2* r_alias = reinterpret_cast<half2*>(&r);
-  r_alias[0] = __floats2half2_rn(a.x, a.y);
-  r_alias[1] = __floats2half2_rn(a.z, a.w);
-  r_alias[2] = __floats2half2_rn(b.x, b.y);
-  r_alias[3] = __floats2half2_rn(b.z, b.w);
-  return r;
-}
-
-template <>
-struct type_casting_traits<float, Eigen::half> {
-  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
-};
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pcast<Packet4h2, float4>(const Packet4h2& a) {
-  // Simply discard the second half of the input
-  float4 r;
-  const half2* a_alias = reinterpret_cast<const half2*>(&a);
-  float2 r1 = __half22float2(a_alias[0]);
-  float2 r2 = __half22float2(a_alias[1]);
-  r.x = static_cast<float>(r1.x);
-  r.y = static_cast<float>(r1.y);
-  r.z = static_cast<float>(r2.x);
-  r.w = static_cast<float>(r2.y);
-  return r;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half2 pcast<float4, half2>(const float4& a) {
-  // Simply discard the second half of the input
-  return __floats2half2_rn(a.x, a.y);
+  return make_packet4h2(__floats2half2_rn(a.x, a.y), __floats2half2_rn(a.z, a.w), __floats2half2_rn(b.x, b.y),
+                        __floats2half2_rn(b.z, b.w));
 }
 
 #endif
diff --git a/Eigen/src/Core/arch/HIP/hcc/math_constants.h b/Eigen/src/Core/arch/HIP/hcc/math_constants.h
deleted file mode 100644
index 99dd3ae..0000000
--- a/Eigen/src/Core/arch/HIP/hcc/math_constants.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * math_constants.h -
- *  HIP equivalent of the CUDA header of the same name
- */
-
-#ifndef __MATH_CONSTANTS_H__
-#define __MATH_CONSTANTS_H__
-
-/* single precision constants */
-
-#define HIPRT_INF_F __int_as_float(0x7f800000)
-#define HIPRT_NAN_F __int_as_float(0x7fffffff)
-#define HIPRT_MIN_DENORM_F __int_as_float(0x00000001)
-#define HIPRT_MAX_NORMAL_F __int_as_float(0x7f7fffff)
-#define HIPRT_NEG_ZERO_F __int_as_float(0x80000000)
-#define HIPRT_ZERO_F 0.0f
-#define HIPRT_ONE_F 1.0f
-
-/* double precision constants */
-#define HIPRT_INF __hiloint2double(0x7ff00000, 0x00000000)
-#define HIPRT_NAN __hiloint2double(0xfff80000, 0x00000000)
-
-#endif
diff --git a/Eigen/src/Core/arch/HVX/PacketMath.h b/Eigen/src/Core/arch/HVX/PacketMath.h
index 1249426..f2789b9 100644
--- a/Eigen/src/Core/arch/HVX/PacketMath.h
+++ b/Eigen/src/Core/arch/HVX/PacketMath.h
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HVX_PACKET_MATH_H
 #define EIGEN_HVX_PACKET_MATH_H
@@ -25,7 +27,7 @@
   HVX_Vector v;
 #if EIGEN_COMP_CLANG
   // Use inlined assembly for aligned vmem load on unaligned memory.
-  // Use type cast to HVX_Vector* may mess up with compiler data alignment.
+  // Using a type cast to HVX_Vector* may mess up the compiler data alignment.
   __asm__("%0 = vmem(%1+#%2)" : "=v"(v) : "r"(m), "i"(D) : "memory");
 #else
   void* aligned_mem =
@@ -57,11 +59,10 @@
   HVX_Vector v0 = HVX_vmem<0>(mem);
   HVX_Vector v1 = v0;
   uintptr_t mem_addr = reinterpret_cast<uintptr_t>(mem);
-  EIGEN_IF_CONSTEXPR(Size * sizeof(T) <= Alignment) {
+  EIGEN_IF_CONSTEXPR (Size * sizeof(T) <= Alignment) {
     // Data size less than alignment will never cross multiple aligned vectors.
     v1 = v0;
-  }
-  else {
+  } else {
     uintptr_t left_off = mem_addr & (__HVX_LENGTH__ - 1);
     if (left_off + Size * sizeof(T) > __HVX_LENGTH__) {
       v1 = HVX_vmem<1>(mem);
@@ -97,7 +98,7 @@
   HVX_VectorPred ql_not = Q6_Q_vsetq_R(mem_addr);
   HVX_VectorPred qr = Q6_Q_vsetq2_R(right_off);
 
-  EIGEN_IF_CONSTEXPR(Size * sizeof(T) > Alignment) {
+  EIGEN_IF_CONSTEXPR (Size * sizeof(T) > Alignment) {
     if (right_off > __HVX_LENGTH__) {
       Q6_vmem_QRIV(qr, mem + __HVX_LENGTH__ / sizeof(T), value);
       qr = Q6_Q_vcmp_eq_VbVb(value, value);
@@ -194,7 +195,7 @@
   typedef Packet8f half;
   enum {
     size = 16,
-    // Many code assume alignment on packet size instead of following trait
+    // Much code assumes alignment on packet size instead of following the trait
     // So we do not use Aligned128 to optimize aligned load/store,
     alignment = Aligned64,
     vectorizable = true,
@@ -209,7 +210,7 @@
   typedef Packet8f half;
   enum {
     size = 8,
-    // Many code assume alignment on packet size instead of following trait
+    // Much code assumes alignment on packet size instead of following the trait
     // So we do not use Aligned128 to optimize aligned load/store,
     alignment = Aligned32,
     vectorizable = true,
@@ -1006,17 +1007,27 @@
   return predux_generic(a, pmin<Packet8f>);
 }
 
+template <HVXPacketSize T>
+EIGEN_STRONG_INLINE bool predux_any_hvx(const HVXPacket<T>& a) {
+  const Index packet_size = unpacket_traits<HVXPacket<T>>::size;
+  HVX_Vector reduced = a.Get();
+  for (int i = 1; i < packet_size; i <<= 1) {
+    reduced |= Q6_V_vror_VR(reduced, i * sizeof(float));
+  }
+  return Q6_R_vextract_VR(reduced, 0) != 0;
+}
+
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet32f& a) {
-  return predux_generic(a, por<Packet32f>) != 0.0f;
+  return predux_any_hvx(a);
 }
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet16f& a) {
-  return predux_generic(a, por<Packet16f>) != 0.0f;
+  return predux_any_hvx(a);
 }
 template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet8f& a) {
-  return predux_generic(a, por<Packet8f>) != 0.0f;
+  return predux_any_hvx(a);
 }
 
 static const float index_vsf[32]
diff --git a/Eigen/src/Core/arch/LSX/Complex.h b/Eigen/src/Core/arch/LSX/Complex.h
index 8138210..d714c36 100644
--- a/Eigen/src/Core/arch/LSX/Complex.h
+++ b/Eigen/src/Core/arch/LSX/Complex.h
@@ -7,6 +7,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_LSX_H
 #define EIGEN_COMPLEX_LSX_H
@@ -18,6 +20,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 //---------- float ----------
 struct Packet2cf {
   EIGEN_STRONG_INLINE Packet2cf() {}
@@ -354,7 +358,6 @@
   return res;
 }
 
-// FIXME: force unaligned load, this is a temporary fix
 template <>
 EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) {
   EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from));
@@ -369,12 +372,13 @@
   return ploadu<Packet1cd>(&from);
 }
 
+// The generic ploaddup broadcasts a copy made by pload1_scalar, which GCC spills and reloads
+// around __lsx_vld instead of loading *from once; binding *from directly does not.
 template <>
 EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
   return pset1<Packet1cd>(*from);
 }
 
-// FIXME: force unaligned store, this is a temporary fix
 template <>
 EIGEN_STRONG_INLINE void pstore<std::complex<double> >(std::complex<double>* to, const Packet1cd& from) {
   EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, Packet2d(from.v));
@@ -396,21 +400,6 @@
   return std::complex<double>(res[0], res[1]);
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
 EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
 
 template <>
@@ -492,6 +481,8 @@
   kernel.packet[0].v = tmp;
 }
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 }  // end namespace Eigen
 
diff --git a/Eigen/src/Core/arch/LSX/GeneralBlockPanelKernel.h b/Eigen/src/Core/arch/LSX/GeneralBlockPanelKernel.h
index 4b07062..f8322c6 100644
--- a/Eigen/src/Core/arch/LSX/GeneralBlockPanelKernel.h
+++ b/Eigen/src/Core/arch/LSX/GeneralBlockPanelKernel.h
@@ -1,4 +1,6 @@
 // IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 #include "../../InternalHeaderCheck.h"
 
 namespace Eigen {
diff --git a/Eigen/src/Core/arch/LSX/MathFunctions.h b/Eigen/src/Core/arch/LSX/MathFunctions.h
index cead463..972d416 100644
--- a/Eigen/src/Core/arch/LSX/MathFunctions.h
+++ b/Eigen/src/Core/arch/LSX/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_LSX_H
 #define EIGEN_MATH_FUNCTIONS_LSX_H
diff --git a/Eigen/src/Core/arch/LSX/PacketMath.h b/Eigen/src/Core/arch/LSX/PacketMath.h
index 366399f..643c9b6 100644
--- a/Eigen/src/Core/arch/LSX/PacketMath.h
+++ b/Eigen/src/Core/arch/LSX/PacketMath.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_LSX_H
 #define EIGEN_PACKET_MATH_LSX_H
@@ -45,49 +46,27 @@
 typedef eigen_packet_wrapper<__m128i, 7> Packet2ul;
 
 template <>
-struct is_arithmetic<__m128> {
-  enum { value = true };
-};
+struct is_arithmetic<__m128> : std::true_type {};
 template <>
-struct is_arithmetic<__m128i> {
-  enum { value = true };
-};
+struct is_arithmetic<__m128i> : std::true_type {};
 template <>
-struct is_arithmetic<__m128d> {
-  enum { value = true };
-};
+struct is_arithmetic<__m128d> : std::true_type {};
 template <>
-struct is_arithmetic<Packet16c> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet16c> : std::true_type {};
 template <>
-struct is_arithmetic<Packet8s> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet8s> : std::true_type {};
 template <>
-struct is_arithmetic<Packet4i> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet4i> : std::true_type {};
 template <>
-struct is_arithmetic<Packet2l> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet2l> : std::true_type {};
 template <>
-struct is_arithmetic<Packet16uc> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet16uc> : std::false_type {};
 template <>
-struct is_arithmetic<Packet8us> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet8us> : std::false_type {};
 template <>
-struct is_arithmetic<Packet4ui> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet4ui> : std::false_type {};
 template <>
-struct is_arithmetic<Packet2ul> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet2ul> : std::false_type {};
 
 EIGEN_ALWAYS_INLINE Packet4f make_packet4f(float a, float b, float c, float d) {
   float from[4] = {a, b, c, d};
@@ -673,47 +652,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet16c pconj(const Packet16c& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8s pconj(const Packet8s& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2l pconj(const Packet2l& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet16uc pconj(const Packet16uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8us pconj(const Packet8us& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4ui pconj(const Packet4ui& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2ul pconj(const Packet2ul& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) {
   return __lsx_vfmul_s(a, b);
 }
@@ -1363,23 +1301,6 @@
   return __lsx_vabsd_d(a, pzero(a));
 }
 template <>
-EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4ui pabs(const Packet4ui& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2ul pabs(const Packet2ul& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet16c pabsdiff(const Packet16c& a, const Packet16c& b) {
   return __lsx_vabsd_b(a, b);
 }
@@ -1508,10 +1429,6 @@
   return make_packet4f(f0, f0, f1, f1);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) {
-  return pset1<Packet2d>(from[0]);
-}
-template <>
 EIGEN_STRONG_INLINE Packet16c ploaddup<Packet16c>(const int8_t* from) {
   Packet16c tmp = pload<Packet16c>(from);
   return __lsx_vilvl_b(tmp, tmp);
@@ -1527,10 +1444,6 @@
   return __lsx_vilvl_w(tmp, tmp);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2l ploaddup<Packet2l>(const int64_t* from) {
-  return pset1<Packet2l>(from[0]);
-}
-template <>
 EIGEN_STRONG_INLINE Packet16uc ploaddup<Packet16uc>(const uint8_t* from) {
   Packet16uc tmp = pload<Packet16uc>(from);
   return __lsx_vilvl_b(tmp, tmp);
@@ -1546,11 +1459,6 @@
   return __lsx_vilvl_w(tmp, tmp);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2ul ploaddup<Packet2ul>(const uint64_t* from) {
-  return pset1<Packet2ul>(from[0]);
-}
-
-template <>
 EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) {
   EIGEN_DEBUG_ALIGNED_STORE __lsx_vst(from, to, 0);
 }
@@ -1986,6 +1894,62 @@
 EIGEN_STRONG_INLINE double predux<Packet2d>(const Packet2d& a) {
   return pfirst<Packet2d>(__lsx_vfadd_d(a, preverse(a)));
 }
+
+template <typename Packet>
+EIGEN_STRONG_INLINE bool predux_any_lsx(const Packet& a) {
+  return __lsx_bnz_v((__m128i)a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4f& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2d& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet16c& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet8s& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4i& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2l& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet16uc& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet8us& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4ui& a) {
+  return predux_any_lsx(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2ul& a) {
+  return predux_any_lsx(a);
+}
+
 template <>
 EIGEN_STRONG_INLINE int8_t predux<Packet16c>(const Packet16c& a) {
   Packet8s tmp1 = __lsx_vhaddw_h_b(a, a);
@@ -2708,13 +2672,7 @@
   return v;
 }
 template <>
-EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
-  return pmin<Packet4f>(a, b);
-}
-template <>
-EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
-  return pmax<Packet4f>(a, b);
-}
+struct pminmax_propagates_nan<Packet4f> : bool_constant<true> {};
 template <>
 EIGEN_STRONG_INLINE Packet4f ploadquad<Packet4f>(const float* from) {
   return (__m128)__lsx_vldrepl_w(from, 0);
@@ -2742,13 +2700,7 @@
   return v;
 }
 template <>
-EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
-  return pmin<Packet2d>(a, b);
-}
-template <>
-EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
-  return pmax<Packet2d>(a, b);
-}
+struct pminmax_propagates_nan<Packet2d> : bool_constant<true> {};
 template <>
 EIGEN_STRONG_INLINE Packet2d psignbit(const Packet2d& a) {
   return (__m128d)(__lsx_vsrai_d((__m128i)a, 63));
diff --git a/Eigen/src/Core/arch/LSX/TypeCasting.h b/Eigen/src/Core/arch/LSX/TypeCasting.h
index cda8680..d255528 100644
--- a/Eigen/src/Core/arch/LSX/TypeCasting.h
+++ b/Eigen/src/Core/arch/LSX/TypeCasting.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_LSX_H
 #define EIGEN_TYPE_CASTING_LSX_H
@@ -19,6 +20,192 @@
 namespace internal {
 
 //==============================================================================
+// type_casting_traits
+//==============================================================================
+
+// float <-> double
+template <>
+struct type_casting_traits<float, double> : vectorized_type_casting_traits<float, double> {};
+template <>
+struct type_casting_traits<double, float> : vectorized_type_casting_traits<double, float> {};
+
+// float <-> integer types
+template <>
+struct type_casting_traits<float, int8_t> : vectorized_type_casting_traits<float, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, float> : vectorized_type_casting_traits<int8_t, float> {};
+template <>
+struct type_casting_traits<float, uint8_t> : vectorized_type_casting_traits<float, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, float> : vectorized_type_casting_traits<uint8_t, float> {};
+template <>
+struct type_casting_traits<float, int16_t> : vectorized_type_casting_traits<float, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, float> : vectorized_type_casting_traits<int16_t, float> {};
+template <>
+struct type_casting_traits<float, uint16_t> : vectorized_type_casting_traits<float, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, float> : vectorized_type_casting_traits<uint16_t, float> {};
+template <>
+struct type_casting_traits<float, int32_t> : vectorized_type_casting_traits<float, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, float> : vectorized_type_casting_traits<int32_t, float> {};
+template <>
+struct type_casting_traits<float, uint32_t> : vectorized_type_casting_traits<float, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, float> : vectorized_type_casting_traits<uint32_t, float> {};
+template <>
+struct type_casting_traits<float, int64_t> : vectorized_type_casting_traits<float, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, float> : vectorized_type_casting_traits<int64_t, float> {};
+template <>
+struct type_casting_traits<float, uint64_t> : vectorized_type_casting_traits<float, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, float> : vectorized_type_casting_traits<uint64_t, float> {};
+
+// double <-> integer types
+template <>
+struct type_casting_traits<double, int8_t> : vectorized_type_casting_traits<double, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, double> : vectorized_type_casting_traits<int8_t, double> {};
+template <>
+struct type_casting_traits<double, uint8_t> : vectorized_type_casting_traits<double, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, double> : vectorized_type_casting_traits<uint8_t, double> {};
+template <>
+struct type_casting_traits<double, int16_t> : vectorized_type_casting_traits<double, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, double> : vectorized_type_casting_traits<int16_t, double> {};
+template <>
+struct type_casting_traits<double, uint16_t> : vectorized_type_casting_traits<double, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, double> : vectorized_type_casting_traits<uint16_t, double> {};
+template <>
+struct type_casting_traits<double, int32_t> : vectorized_type_casting_traits<double, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, double> : vectorized_type_casting_traits<int32_t, double> {};
+template <>
+struct type_casting_traits<double, uint32_t> : vectorized_type_casting_traits<double, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, double> : vectorized_type_casting_traits<uint32_t, double> {};
+template <>
+struct type_casting_traits<double, int64_t> : vectorized_type_casting_traits<double, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, double> : vectorized_type_casting_traits<int64_t, double> {};
+template <>
+struct type_casting_traits<double, uint64_t> : vectorized_type_casting_traits<double, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, double> : vectorized_type_casting_traits<uint64_t, double> {};
+
+// int8_t <-> other integer types
+template <>
+struct type_casting_traits<int8_t, int16_t> : vectorized_type_casting_traits<int8_t, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, int8_t> : vectorized_type_casting_traits<int16_t, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, uint16_t> : vectorized_type_casting_traits<int8_t, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, int8_t> : vectorized_type_casting_traits<uint16_t, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, int32_t> : vectorized_type_casting_traits<int8_t, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, int8_t> : vectorized_type_casting_traits<int32_t, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, uint32_t> : vectorized_type_casting_traits<int8_t, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, int8_t> : vectorized_type_casting_traits<uint32_t, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, int64_t> : vectorized_type_casting_traits<int8_t, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, int8_t> : vectorized_type_casting_traits<int64_t, int8_t> {};
+template <>
+struct type_casting_traits<int8_t, uint64_t> : vectorized_type_casting_traits<int8_t, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, int8_t> : vectorized_type_casting_traits<uint64_t, int8_t> {};
+
+// uint8_t <-> other integer types
+template <>
+struct type_casting_traits<uint8_t, int16_t> : vectorized_type_casting_traits<uint8_t, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, uint8_t> : vectorized_type_casting_traits<int16_t, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, uint16_t> : vectorized_type_casting_traits<uint8_t, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, uint8_t> : vectorized_type_casting_traits<uint16_t, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, int32_t> : vectorized_type_casting_traits<uint8_t, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, uint8_t> : vectorized_type_casting_traits<int32_t, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, uint32_t> : vectorized_type_casting_traits<uint8_t, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, uint8_t> : vectorized_type_casting_traits<uint32_t, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, int64_t> : vectorized_type_casting_traits<uint8_t, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, uint8_t> : vectorized_type_casting_traits<int64_t, uint8_t> {};
+template <>
+struct type_casting_traits<uint8_t, uint64_t> : vectorized_type_casting_traits<uint8_t, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, uint8_t> : vectorized_type_casting_traits<uint64_t, uint8_t> {};
+
+// int16_t <-> wider integer types
+template <>
+struct type_casting_traits<int16_t, int32_t> : vectorized_type_casting_traits<int16_t, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, int16_t> : vectorized_type_casting_traits<int32_t, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, uint32_t> : vectorized_type_casting_traits<int16_t, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, int16_t> : vectorized_type_casting_traits<uint32_t, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, int64_t> : vectorized_type_casting_traits<int16_t, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, int16_t> : vectorized_type_casting_traits<int64_t, int16_t> {};
+template <>
+struct type_casting_traits<int16_t, uint64_t> : vectorized_type_casting_traits<int16_t, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, int16_t> : vectorized_type_casting_traits<uint64_t, int16_t> {};
+
+// uint16_t <-> wider integer types
+template <>
+struct type_casting_traits<uint16_t, int32_t> : vectorized_type_casting_traits<uint16_t, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, uint16_t> : vectorized_type_casting_traits<int32_t, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, uint32_t> : vectorized_type_casting_traits<uint16_t, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, uint16_t> : vectorized_type_casting_traits<uint32_t, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, int64_t> : vectorized_type_casting_traits<uint16_t, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, uint16_t> : vectorized_type_casting_traits<int64_t, uint16_t> {};
+template <>
+struct type_casting_traits<uint16_t, uint64_t> : vectorized_type_casting_traits<uint16_t, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, uint16_t> : vectorized_type_casting_traits<uint64_t, uint16_t> {};
+
+// int32_t <-> 64-bit integer types
+template <>
+struct type_casting_traits<int32_t, int64_t> : vectorized_type_casting_traits<int32_t, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, int32_t> : vectorized_type_casting_traits<int64_t, int32_t> {};
+template <>
+struct type_casting_traits<int32_t, uint64_t> : vectorized_type_casting_traits<int32_t, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, int32_t> : vectorized_type_casting_traits<uint64_t, int32_t> {};
+
+// uint32_t <-> 64-bit integer types
+template <>
+struct type_casting_traits<uint32_t, int64_t> : vectorized_type_casting_traits<uint32_t, int64_t> {};
+template <>
+struct type_casting_traits<int64_t, uint32_t> : vectorized_type_casting_traits<int64_t, uint32_t> {};
+template <>
+struct type_casting_traits<uint32_t, uint64_t> : vectorized_type_casting_traits<uint32_t, uint64_t> {};
+template <>
+struct type_casting_traits<uint64_t, uint32_t> : vectorized_type_casting_traits<uint64_t, uint32_t> {};
+
+//==============================================================================
 // preinterpret
 //==============================================================================
 template <>
@@ -93,42 +280,42 @@
 template <>
 EIGEN_STRONG_INLINE Packet2l pcast<Packet4f, Packet2l>(const Packet4f& a) {
   Packet2d tmp = __lsx_vfcvtl_d_s(a);
-  return __lsx_vftint_l_d(tmp);
+  return __lsx_vftintrz_l_d(tmp);
 }
 template <>
 EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) {
   Packet2d tmp = __lsx_vfcvtl_d_s(a);
-  return __lsx_vftint_lu_d(tmp);
+  return __lsx_vftintrz_lu_d(tmp);
 }
 template <>
 EIGEN_STRONG_INLINE Packet4i pcast<Packet4f, Packet4i>(const Packet4f& a) {
-  return __lsx_vftint_w_s(a);
+  return __lsx_vftintrz_w_s(a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet4ui pcast<Packet4f, Packet4ui>(const Packet4f& a) {
-  return __lsx_vftint_wu_s(a);
+  return __lsx_vftintrz_wu_s(a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8s pcast<Packet4f, Packet8s>(const Packet4f& a, const Packet4f& b) {
-  return __lsx_vssrlni_h_w(__lsx_vftint_w_s(a), __lsx_vftint_w_s(b), 0);
+  return __lsx_vpickev_h(__lsx_vftintrz_w_s(b), __lsx_vftintrz_w_s(a));
 }
 template <>
 EIGEN_STRONG_INLINE Packet8us pcast<Packet4f, Packet8us>(const Packet4f& a, const Packet4f& b) {
-  return __lsx_vssrlni_hu_w(__lsx_vftint_wu_s(a), __lsx_vftint_wu_s(b), 0);
+  return __lsx_vpickev_h(__lsx_vftintrz_wu_s(b), __lsx_vftintrz_wu_s(a));
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet4f, Packet16c>(const Packet4f& a, const Packet4f& b, const Packet4f& c,
                                                          const Packet4f& d) {
-  Packet8s tmp1 = __lsx_vssrlni_h_w(__lsx_vftint_w_s(a), __lsx_vftint_w_s(b), 0);
-  Packet8s tmp2 = __lsx_vssrlni_h_w(__lsx_vftint_w_s(c), __lsx_vftint_w_s(d), 0);
-  return __lsx_vssrlni_b_h((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet8s tmp1 = __lsx_vpickev_h(__lsx_vftintrz_w_s(b), __lsx_vftintrz_w_s(a));
+  Packet8s tmp2 = __lsx_vpickev_h(__lsx_vftintrz_w_s(d), __lsx_vftintrz_w_s(c));
+  return __lsx_vpickev_b((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet4f, Packet16uc>(const Packet4f& a, const Packet4f& b, const Packet4f& c,
                                                            const Packet4f& d) {
-  Packet8us tmp1 = __lsx_vssrlni_hu_w(__lsx_vftint_wu_s(a), __lsx_vftint_wu_s(b), 0);
-  Packet8us tmp2 = __lsx_vssrlni_hu_w(__lsx_vftint_wu_s(c), __lsx_vftint_wu_s(d), 0);
-  return __lsx_vssrlni_bu_h((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet8us tmp1 = __lsx_vpickev_h(__lsx_vftintrz_wu_s(b), __lsx_vftintrz_wu_s(a));
+  Packet8us tmp2 = __lsx_vpickev_h(__lsx_vftintrz_wu_s(d), __lsx_vftintrz_wu_s(c));
+  return __lsx_vpickev_b((__m128i)tmp2, (__m128i)tmp1);
 }
 
 template <>
@@ -230,11 +417,11 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet8s, Packet16c>(const Packet8s& a, const Packet8s& b) {
-  return __lsx_vssrlni_b_h((__m128i)a, (__m128i)b, 0);
+  return __lsx_vpickev_b((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet8s, Packet16uc>(const Packet8s& a, const Packet8s& b) {
-  return (Packet16uc)__lsx_vssrlni_b_h((__m128i)a, (__m128i)b, 0);
+  return (Packet16uc)__lsx_vpickev_b((__m128i)b, (__m128i)a);
 }
 
 template <>
@@ -262,11 +449,11 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet8us, Packet16uc>(const Packet8us& a, const Packet8us& b) {
-  return __lsx_vssrlni_bu_h((__m128i)a, (__m128i)b, 0);
+  return __lsx_vpickev_b((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet8us, Packet16c>(const Packet8us& a, const Packet8us& b) {
-  return (Packet16c)__lsx_vssrlni_bu_h((__m128i)a, (__m128i)b, 0);
+  return (Packet16c)__lsx_vpickev_b((__m128i)b, (__m128i)a);
 }
 
 template <>
@@ -283,25 +470,25 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet8s pcast<Packet4i, Packet8s>(const Packet4i& a, const Packet4i& b) {
-  return __lsx_vssrlni_h_w((__m128i)a, (__m128i)b, 0);
+  return __lsx_vpickev_h((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8us pcast<Packet4i, Packet8us>(const Packet4i& a, const Packet4i& b) {
-  return (Packet8us)__lsx_vssrlni_h_w((__m128i)a, (__m128i)b, 0);
+  return (Packet8us)__lsx_vpickev_h((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet4i, Packet16c>(const Packet4i& a, const Packet4i& b, const Packet4i& c,
                                                          const Packet4i& d) {
-  Packet8s tmp1 = __lsx_vssrlni_h_w((__m128i)a, (__m128i)b, 0);
-  Packet8s tmp2 = __lsx_vssrlni_h_w((__m128i)c, (__m128i)d, 0);
-  return __lsx_vssrlni_b_h((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet8s tmp1 = __lsx_vpickev_h((__m128i)b, (__m128i)a);
+  Packet8s tmp2 = __lsx_vpickev_h((__m128i)d, (__m128i)c);
+  return __lsx_vpickev_b((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet4i, Packet16uc>(const Packet4i& a, const Packet4i& b, const Packet4i& c,
                                                            const Packet4i& d) {
-  Packet8s tmp1 = __lsx_vssrlni_h_w((__m128i)a, (__m128i)b, 0);
-  Packet8s tmp2 = __lsx_vssrlni_h_w((__m128i)c, (__m128i)d, 0);
-  return (Packet16uc)__lsx_vssrlni_b_h((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet8s tmp1 = __lsx_vpickev_h((__m128i)b, (__m128i)a);
+  Packet8s tmp2 = __lsx_vpickev_h((__m128i)d, (__m128i)c);
+  return (Packet16uc)__lsx_vpickev_b((__m128i)tmp2, (__m128i)tmp1);
 }
 
 template <>
@@ -318,52 +505,52 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet8us pcast<Packet4ui, Packet8us>(const Packet4ui& a, const Packet4ui& b) {
-  return __lsx_vssrlni_hu_w((__m128i)a, (__m128i)b, 0);
+  return __lsx_vpickev_h((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8s pcast<Packet4ui, Packet8s>(const Packet4ui& a, const Packet4ui& b) {
-  return (Packet8s)__lsx_vssrlni_hu_w((__m128i)a, (__m128i)b, 0);
+  return (Packet8s)__lsx_vpickev_h((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet4ui, Packet16uc>(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c,
                                                             const Packet4ui& d) {
-  Packet8us tmp1 = __lsx_vssrlni_hu_w((__m128i)a, (__m128i)b, 0);
-  Packet8us tmp2 = __lsx_vssrlni_hu_w((__m128i)c, (__m128i)d, 0);
-  return __lsx_vssrlni_bu_h((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet8us tmp1 = __lsx_vpickev_h((__m128i)b, (__m128i)a);
+  Packet8us tmp2 = __lsx_vpickev_h((__m128i)d, (__m128i)c);
+  return __lsx_vpickev_b((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet4ui, Packet16c>(const Packet4ui& a, const Packet4ui& b, const Packet4ui& c,
                                                           const Packet4ui& d) {
-  Packet8us tmp1 = __lsx_vssrlni_hu_w((__m128i)a, (__m128i)b, 0);
-  Packet8us tmp2 = __lsx_vssrlni_hu_w((__m128i)c, (__m128i)d, 0);
-  return (Packet16c)__lsx_vssrlni_bu_h((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet8us tmp1 = __lsx_vpickev_h((__m128i)b, (__m128i)a);
+  Packet8us tmp2 = __lsx_vpickev_h((__m128i)d, (__m128i)c);
+  return (Packet16c)__lsx_vpickev_b((__m128i)tmp2, (__m128i)tmp1);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4f pcast<Packet2l, Packet4f>(const Packet2l& a, const Packet2l& b) {
-  return __lsx_vffint_s_w(__lsx_vssrlni_w_d((__m128i)a, (__m128i)b, 0));
+  return __lsx_vfcvt_s_d(__lsx_vffint_d_l(b), __lsx_vffint_d_l(a));
 }
 template <>
 EIGEN_STRONG_INLINE Packet4i pcast<Packet2l, Packet4i>(const Packet2l& a, const Packet2l& b) {
-  return __lsx_vssrlni_w_d((__m128i)a, (__m128i)b, 0);
+  return __lsx_vpickev_w((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet4ui pcast<Packet2l, Packet4ui>(const Packet2l& a, const Packet2l& b) {
-  return (Packet4ui)__lsx_vssrlni_w_d((__m128i)a, (__m128i)b, 0);
+  return (Packet4ui)__lsx_vpickev_w((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8s pcast<Packet2l, Packet8s>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
                                                        const Packet2l& d) {
-  Packet4i tmp1 = __lsx_vssrlni_w_d((__m128i)a, (__m128i)b, 0);
-  Packet4i tmp2 = __lsx_vssrlni_w_d((__m128i)c, (__m128i)d, 0);
-  return __lsx_vssrlni_h_w((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet4i tmp1 = __lsx_vpickev_w((__m128i)b, (__m128i)a);
+  Packet4i tmp2 = __lsx_vpickev_w((__m128i)d, (__m128i)c);
+  return __lsx_vpickev_h((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8us pcast<Packet2l, Packet8us>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
                                                          const Packet2l& d) {
-  Packet4i tmp1 = __lsx_vssrlni_w_d((__m128i)a, (__m128i)b, 0);
-  Packet4i tmp2 = __lsx_vssrlni_w_d((__m128i)c, (__m128i)d, 0);
-  return (Packet8us)__lsx_vssrlni_h_w((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet4i tmp1 = __lsx_vpickev_w((__m128i)b, (__m128i)a);
+  Packet4i tmp2 = __lsx_vpickev_w((__m128i)d, (__m128i)c);
+  return (Packet8us)__lsx_vpickev_h((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet2l, Packet16c>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
@@ -371,7 +558,7 @@
                                                          const Packet2l& g, const Packet2l& h) {
   const Packet8s abcd = pcast<Packet2l, Packet8s>(a, b, c, d);
   const Packet8s efgh = pcast<Packet2l, Packet8s>(e, f, g, h);
-  return __lsx_vssrlni_b_h((__m128i)abcd, (__m128i)efgh, 0);
+  return __lsx_vpickev_b((__m128i)efgh, (__m128i)abcd);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet2l, Packet16uc>(const Packet2l& a, const Packet2l& b, const Packet2l& c,
@@ -379,34 +566,34 @@
                                                            const Packet2l& g, const Packet2l& h) {
   const Packet8us abcd = pcast<Packet2l, Packet8us>(a, b, c, d);
   const Packet8us efgh = pcast<Packet2l, Packet8us>(e, f, g, h);
-  return __lsx_vssrlni_bu_h((__m128i)abcd, (__m128i)efgh, 0);
+  return __lsx_vpickev_b((__m128i)efgh, (__m128i)abcd);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4f pcast<Packet2ul, Packet4f>(const Packet2ul& a, const Packet2ul& b) {
-  return __lsx_vffint_s_wu(__lsx_vssrlni_w_d((__m128i)a, (__m128i)b, 0));
+  return __lsx_vfcvt_s_d(__lsx_vffint_d_lu(b), __lsx_vffint_d_lu(a));
 }
 template <>
 EIGEN_STRONG_INLINE Packet4ui pcast<Packet2ul, Packet4ui>(const Packet2ul& a, const Packet2ul& b) {
-  return __lsx_vssrlni_wu_d((__m128i)a, (__m128i)b, 0);
+  return __lsx_vpickev_w((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet4i pcast<Packet2ul, Packet4i>(const Packet2ul& a, const Packet2ul& b) {
-  return (Packet4i)__lsx_vssrlni_wu_d((__m128i)a, (__m128i)b, 0);
+  return (Packet4i)__lsx_vpickev_w((__m128i)b, (__m128i)a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8us pcast<Packet2ul, Packet8us>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
                                                           const Packet2ul& d) {
-  Packet4ui tmp1 = __lsx_vssrlni_wu_d((__m128i)a, (__m128i)b, 0);
-  Packet4ui tmp2 = __lsx_vssrlni_wu_d((__m128i)c, (__m128i)d, 0);
-  return __lsx_vssrlni_hu_w((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet4ui tmp1 = __lsx_vpickev_w((__m128i)b, (__m128i)a);
+  Packet4ui tmp2 = __lsx_vpickev_w((__m128i)d, (__m128i)c);
+  return __lsx_vpickev_h((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8s pcast<Packet2ul, Packet8s>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
                                                         const Packet2ul& d) {
-  Packet4ui tmp1 = __lsx_vssrlni_wu_d((__m128i)a, (__m128i)b, 0);
-  Packet4ui tmp2 = __lsx_vssrlni_wu_d((__m128i)c, (__m128i)d, 0);
-  return (Packet8s)__lsx_vssrlni_hu_w((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet4ui tmp1 = __lsx_vpickev_w((__m128i)b, (__m128i)a);
+  Packet4ui tmp2 = __lsx_vpickev_w((__m128i)d, (__m128i)c);
+  return (Packet8s)__lsx_vpickev_h((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet2ul, Packet16uc>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
@@ -414,7 +601,7 @@
                                                             const Packet2ul& g, const Packet2ul& h) {
   const Packet8s abcd = pcast<Packet2ul, Packet8s>(a, b, c, d);
   const Packet8s efgh = pcast<Packet2ul, Packet8s>(e, f, g, h);
-  return __lsx_vssrlni_b_h((__m128i)abcd, (__m128i)efgh, 0);
+  return __lsx_vpickev_b((__m128i)efgh, (__m128i)abcd);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet2ul, Packet16c>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c,
@@ -422,7 +609,7 @@
                                                           const Packet2ul& g, const Packet2ul& h) {
   const Packet8us abcd = pcast<Packet2ul, Packet8us>(a, b, c, d);
   const Packet8us efgh = pcast<Packet2ul, Packet8us>(e, f, g, h);
-  return __lsx_vssrlni_bu_h((__m128i)abcd, (__m128i)efgh, 0);
+  return __lsx_vpickev_b((__m128i)efgh, (__m128i)abcd);
 }
 
 template <>
@@ -431,33 +618,33 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet2l pcast<Packet2d, Packet2l>(const Packet2d& a) {
-  return __lsx_vftint_l_d(a);
+  return __lsx_vftintrz_l_d(a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet2ul pcast<Packet2d, Packet2ul>(const Packet2d& a) {
-  return __lsx_vftint_lu_d(a);
+  return __lsx_vftintrz_lu_d(a);
 }
 template <>
 EIGEN_STRONG_INLINE Packet4i pcast<Packet2d, Packet4i>(const Packet2d& a, const Packet2d& b) {
-  return __lsx_vssrlni_w_d(__lsx_vftint_l_d(a), __lsx_vftint_l_d(b), 0);
+  return __lsx_vpickev_w(__lsx_vftintrz_l_d(b), __lsx_vftintrz_l_d(a));
 }
 template <>
 EIGEN_STRONG_INLINE Packet4ui pcast<Packet2d, Packet4ui>(const Packet2d& a, const Packet2d& b) {
-  return __lsx_vssrlni_wu_d(__lsx_vftint_lu_d(a), __lsx_vftint_lu_d(b), 0);
+  return __lsx_vpickev_w(__lsx_vftintrz_lu_d(b), __lsx_vftintrz_lu_d(a));
 }
 template <>
 EIGEN_STRONG_INLINE Packet8s pcast<Packet2d, Packet8s>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
                                                        const Packet2d& d) {
-  Packet4i tmp1 = __lsx_vssrlni_w_d(__lsx_vftint_l_d(a), __lsx_vftint_l_d(b), 0);
-  Packet4i tmp2 = __lsx_vssrlni_w_d(__lsx_vftint_l_d(c), __lsx_vftint_l_d(d), 0);
-  return __lsx_vssrlni_h_w((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet4i tmp1 = __lsx_vpickev_w(__lsx_vftintrz_l_d(b), __lsx_vftintrz_l_d(a));
+  Packet4i tmp2 = __lsx_vpickev_w(__lsx_vftintrz_l_d(d), __lsx_vftintrz_l_d(c));
+  return __lsx_vpickev_h((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet8us pcast<Packet2d, Packet8us>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
                                                          const Packet2d& d) {
-  Packet4ui tmp1 = __lsx_vssrlni_wu_d(__lsx_vftint_lu_d(a), __lsx_vftint_lu_d(b), 0);
-  Packet4ui tmp2 = __lsx_vssrlni_wu_d(__lsx_vftint_lu_d(c), __lsx_vftint_lu_d(d), 0);
-  return __lsx_vssrlni_hu_w((__m128i)tmp1, (__m128i)tmp2, 0);
+  Packet4ui tmp1 = __lsx_vpickev_w(__lsx_vftintrz_lu_d(b), __lsx_vftintrz_lu_d(a));
+  Packet4ui tmp2 = __lsx_vpickev_w(__lsx_vftintrz_lu_d(d), __lsx_vftintrz_lu_d(c));
+  return __lsx_vpickev_h((__m128i)tmp2, (__m128i)tmp1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16c pcast<Packet2d, Packet16c>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
@@ -465,7 +652,7 @@
                                                          const Packet2d& g, const Packet2d& h) {
   const Packet8s abcd = pcast<Packet2d, Packet8s>(a, b, c, d);
   const Packet8s efgh = pcast<Packet2d, Packet8s>(e, f, g, h);
-  return __lsx_vssrlni_b_h((__m128i)abcd, (__m128i)efgh, 0);
+  return __lsx_vpickev_b((__m128i)efgh, (__m128i)abcd);
 }
 template <>
 EIGEN_STRONG_INLINE Packet16uc pcast<Packet2d, Packet16uc>(const Packet2d& a, const Packet2d& b, const Packet2d& c,
@@ -473,7 +660,7 @@
                                                            const Packet2d& g, const Packet2d& h) {
   const Packet8us abcd = pcast<Packet2d, Packet8us>(a, b, c, d);
   const Packet8us efgh = pcast<Packet2d, Packet8us>(e, f, g, h);
-  return __lsx_vssrlni_bu_h((__m128i)abcd, (__m128i)efgh, 0);
+  return __lsx_vpickev_b((__m128i)efgh, (__m128i)abcd);
 }
 
 template <>
diff --git a/Eigen/src/Core/arch/MSA/Complex.h b/Eigen/src/Core/arch/MSA/Complex.h
index fbba642..ea0d76c 100644
--- a/Eigen/src/Core/arch/MSA/Complex.h
+++ b/Eigen/src/Core/arch/MSA/Complex.h
@@ -9,6 +9,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_MSA_H
 #define EIGEN_COMPLEX_MSA_H
@@ -22,6 +23,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 //---------- float ----------
 struct Packet2cf {
   EIGEN_STRONG_INLINE Packet2cf() {}
@@ -100,6 +103,9 @@
     HasMul = 1,
     HasDiv = 1,
     HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
     HasAbs = 0,
     HasAbs2 = 0,
     HasMin = 0,
@@ -393,6 +399,8 @@
     HasMul = 1,
     HasDiv = 1,
     HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
     HasAbs = 0,
     HasAbs2 = 0,
     HasMin = 0,
@@ -552,27 +560,6 @@
   return std::complex<double>(a.v[0], a.v[1]);
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
-  EIGEN_MSA_DEBUG;
-
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
-  EIGEN_MSA_DEBUG;
-
-  return pfirst(a);
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
-  EIGEN_MSA_DEBUG;
-
-  return pfirst(a);
-}
-
 EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
 
 template <>
@@ -606,6 +593,11 @@
   kernel.packet[1].v = v2;
 }
 
+EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS(Packet2cf)
+EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS_NO_EXP(Packet1cd)
+
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/MSA/MathFunctions.h b/Eigen/src/Core/arch/MSA/MathFunctions.h
index f68d254..947453f 100644
--- a/Eigen/src/Core/arch/MSA/MathFunctions.h
+++ b/Eigen/src/Core/arch/MSA/MathFunctions.h
@@ -13,6 +13,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /* The sin, cos, exp, and log functions of this file come from
  * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
diff --git a/Eigen/src/Core/arch/MSA/PacketMath.h b/Eigen/src/Core/arch/MSA/PacketMath.h
index 558893e..cce44b9 100644
--- a/Eigen/src/Core/arch/MSA/PacketMath.h
+++ b/Eigen/src/Core/arch/MSA/PacketMath.h
@@ -9,6 +9,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_MSA_H
 #define EIGEN_PACKET_MATH_MSA_H
@@ -212,20 +213,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
-  EIGEN_MSA_DEBUG;
-
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
-  EIGEN_MSA_DEBUG;
-
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) {
   EIGEN_MSA_DEBUG;
 
@@ -567,6 +554,11 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4f& a) {
+  return __builtin_msa_bnz_v((v16u8)a);
+}
+
+template <>
 EIGEN_STRONG_INLINE int32_t predux<Packet4i>(const Packet4i& a) {
   EIGEN_MSA_DEBUG;
 
@@ -575,6 +567,11 @@
   return s[0];
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4i& a) {
+  return __builtin_msa_bnz_v((v16u8)a);
+}
+
 // Other reduction functions:
 // mul
 template <>
@@ -789,6 +786,39 @@
   return v;
 }
 
+template <>
+EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a) {
+  // frint.w uses the current rounding mode (default: round to nearest, ties to even).
+  Packet4f v = a;
+  asm volatile("frint.w %w[v], %w[v]\n" : [v] "+f"(v));
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f ptrunc<Packet4f>(const Packet4f& a) {
+  Packet4f v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 2\n"  // 1 = round toward zero.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.w %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return (Packet4f)__builtin_msa_fcult_w(a, b);
+}
+
 //---------- double ----------
 
 typedef v2f64 Packet2d;
@@ -881,13 +911,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
-  EIGEN_MSA_DEBUG;
-
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) {
   EIGEN_MSA_DEBUG;
 
@@ -1060,6 +1083,11 @@
   return s[0];
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2d& a) {
+  return __builtin_msa_bnz_v((v16u8)a);
+}
+
 // Other reduction functions:
 // mul
 template <>
@@ -1192,6 +1220,39 @@
   return v;
 }
 
+template <>
+EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a) {
+  // frint.d uses the current rounding mode (default: round to nearest, ties to even).
+  Packet2d v = a;
+  asm volatile("frint.d %w[v], %w[v]\n" : [v] "+f"(v));
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d ptrunc<Packet2d>(const Packet2d& a) {
+  Packet2d v = a;
+  int32_t old_mode, new_mode;
+  asm volatile(
+      "cfcmsa  %[old_mode], $1\n"
+      "ori     %[new_mode], %[old_mode], 3\n"
+      "xori    %[new_mode], %[new_mode], 2\n"  // 1 = round toward zero.
+      "ctcmsa  $1, %[new_mode]\n"
+      "frint.d %w[v], %w[v]\n"
+      "ctcmsa  $1, %[old_mode]\n"
+      :  // outputs
+      [old_mode] "=r"(old_mode), [new_mode] "=r"(new_mode),
+      [v] "+f"(v)
+      :  // inputs
+      :  // clobbers
+  );
+  return v;
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return (Packet2d)__builtin_msa_fcult_d(a, b);
+}
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/NEON/Complex.h b/Eigen/src/Core/arch/NEON/Complex.h
index 48ac0cf..f4a1c13 100644
--- a/Eigen/src/Core/arch/NEON/Complex.h
+++ b/Eigen/src/Core/arch/NEON/Complex.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_NEON_H
 #define EIGEN_COMPLEX_NEON_H
@@ -18,6 +19,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 inline uint32x4_t p4ui_CONJ_XOR() {
 // See bug 1325, clang fails to call vld1q_u64.
 #if EIGEN_COMP_CLANG || EIGEN_COMP_CASTXML
@@ -374,10 +377,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1cf preverse(const Packet1cf& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) {
   return Packet2cf(vcombine_f32(vget_high_f32(a.v), vget_low_f32(a.v)));
 }
@@ -392,12 +391,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE std::complex<float> predux<Packet1cf>(const Packet1cf& a) {
-  std::complex<float> s;
-  vst1_f32((float*)&s, a.v);
-  return s;
-}
-template <>
 EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a) {
   std::complex<float> s;
   vst1_f32(reinterpret_cast<float*>(&s), vadd_f32(vget_low_f32(a.v), vget_high_f32(a.v)));
@@ -405,12 +398,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet1cf>(const Packet1cf& a) {
-  std::complex<float> s;
-  vst1_f32((float*)&s, a.v);
-  return s;
-}
-template <>
 EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a) {
   float32x2_t a1, a2, v1, v2, prod;
   std::complex<float> s;
@@ -419,7 +406,7 @@
   a2 = vget_high_f32(a.v);
   // Get the real values of a | a1_re | a1_re | a2_re | a2_re |
   v1 = vdup_lane_f32(a1, 0);
-  // Get the real values of a | a1_im | a1_im | a2_im | a2_im |
+  // Get the imag values of a | a1_im | a1_im | a2_im | a2_im |
   v2 = vdup_lane_f32(a1, 1);
   // Multiply the real a with b
   v1 = vmul_f32(v1, a2);
@@ -460,7 +447,7 @@
 EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS(Packet2cf)
 
 //---------- double ----------
-#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+#if EIGEN_ARCH_ARM64
 
 inline uint64x2_t p2ul_CONJ_XOR() {
   static const uint64_t p2ul_conj_XOR_DATA[] = {0x0, 0x8000000000000000};
@@ -613,11 +600,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
-  return pset1<Packet1cd>(*from);
-}
-
-template <>
 EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const Packet1cd& from) {
   EIGEN_DEBUG_ALIGNED_STORE pstore(assume_aligned<unpacket_traits<Packet1cd>::alignment>(reinterpret_cast<double*>(to)),
                                    from.v);
@@ -655,21 +637,6 @@
   return res;
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
 EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
 
 template <>
@@ -691,6 +658,8 @@
 
 #endif  // EIGEN_ARCH_ARM64
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h b/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
index 4ecf7d1..11b3c24 100644
--- a/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
+++ b/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
@@ -1,4 +1,6 @@
 // IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 #include "../../InternalHeaderCheck.h"
 
 namespace Eigen {
@@ -176,9 +178,9 @@
 
 // The register at operand 3 of fmla for data type half must be v0~v15, the compiler may not
 // allocate a required register for the '%2' of inline asm 'fmla %0.8h, %1.8h, %2.h[id]',
-// so inline assembly can't be used here to advoid the bug that vfmaq_lane_f16 is implemented
+// so inline assembly can't be used here to avoid the bug that vfmaq_lane_f16 is implemented
 // through a costly dup in gcc compiler.
-#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC && EIGEN_COMP_CLANG
+#if EIGEN_HAS_ARM64_FP16 && EIGEN_COMP_CLANG
 
 template <>
 struct gebp_traits<half, half, false, false, Architecture::NEON>
@@ -190,7 +192,7 @@
 
   EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { dest = *b; }
 
-  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const { dest = vld1_f16((const __fp16*)b); }
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const { dest = vld1_f16(&b->x); }
 
   EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacket& dest) const { dest = *b; }
 
@@ -204,11 +206,20 @@
 
   EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& /*tmp*/,
                                 const FixedInt<0>&) const {
+#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
     c = vfmaq_n_f16(c, a, b);
+#else
+    c = vcombine_f16(vcvt_f16_f32(vfmaq_n_f32(vcvt_f32_f16(vget_low_f16(c)), vcvt_f32_f16(vget_low_f16(a)), b)),
+                     vcvt_f16_f32(vfmaq_n_f32(vcvt_f32_f16(vget_high_f16(c)), vcvt_f32_f16(vget_high_f16(a)), b)));
+#endif
   }
   EIGEN_STRONG_INLINE void madd(const PacketHalf& a, const RhsPacket& b, PacketHalf& c, RhsPacket& /*tmp*/,
                                 const FixedInt<0>&) const {
+#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
     c = vfma_n_f16(c, a, b);
+#else
+    c = vcvt_f16_f32(vfmaq_n_f32(vcvt_f32_f16(c), vcvt_f32_f16(a), b));
+#endif
   }
 
   // NOTE: Template parameter inference failed when compiled with Android NDK:
@@ -233,10 +244,29 @@
  private:
   template <int LaneID>
   EIGEN_STRONG_INLINE void madd_helper(const LhsPacket& a, const RhsPacketx4& b, AccPacket& c) const {
+#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
     c = vfmaq_lane_f16(c, a, b, LaneID);
+#else
+    float32x2_t bf = get_half<LaneID>(vcvt_f32_f16(b));
+    c = vcombine_f16(
+        vcvt_f16_f32(vfmaq_lane_f32(vcvt_f32_f16(vget_low_f16(c)), vcvt_f32_f16(vget_low_f16(a)), bf, LaneID % 2)),
+        vcvt_f16_f32(vfmaq_lane_f32(vcvt_f32_f16(vget_high_f16(c)), vcvt_f32_f16(vget_high_f16(a)), bf, LaneID % 2)));
+#endif
   }
+
+#if !EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+  template <int LaneID>
+  EIGEN_STRONG_INLINE static std::enable_if_t<(LaneID <= 1), float32x2_t> get_half(float32x4_t vec) {
+    return vget_low_f32(vec);
+  }
+
+  template <int LaneID>
+  EIGEN_STRONG_INLINE static std::enable_if_t<(LaneID > 1), float32x2_t> get_half(float32x4_t vec) {
+    return vget_high_f32(vec);
+  }
+#endif
 };
-#endif  // EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC && EIGEN_COMP_CLANG
+#endif  // EIGEN_HAS_ARM64_FP16 && EIGEN_COMP_CLANG
 #endif  // EIGEN_ARCH_ARM64
 
 }  // namespace internal
diff --git a/Eigen/src/Core/arch/NEON/MathFunctions.h b/Eigen/src/Core/arch/NEON/MathFunctions.h
index 5c48db8..9c07f4f 100644
--- a/Eigen/src/Core/arch/NEON/MathFunctions.h
+++ b/Eigen/src/Core/arch/NEON/MathFunctions.h
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_NEON_H
 #define EIGEN_MATH_FUNCTIONS_NEON_H
@@ -18,7 +20,7 @@
 EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_FLOAT(Packet2f)
 EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_FLOAT(Packet4f)
 
-#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
 template <>
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet4hf ptanh<Packet4hf>(const Packet4hf& x) {
   // Convert to float, call the float ptanh, and then convert back.
@@ -29,17 +31,19 @@
 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet8hf ptanh<Packet8hf>(const Packet8hf& x) {
   // Convert each 4 half types to float, call the float ptanh, and then convert back.
   return vcombine_f16(vcvt_f16_f32(ptanh<Packet4f>(vcvt_f32_f16(vget_low_f16(x)))),
-                      vcvt_f16_f32(ptanh<Packet4f>(vcvt_high_f32_f16(x))));
+                      vcvt_f16_f32(ptanh<Packet4f>(vcvt_f32_f16(vget_high_f16(x)))));
 }
-#endif  // EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
 
 EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_BF16(Packet4f, Packet4bf)
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pfrexp(const Packet4bf& a, Packet4bf& exponent) {
+  // Both results are exact: the mantissa keeps the input's significand, and the exponent is a
+  // small integer.
   Packet4f fexponent;
-  const Packet4bf out = F32ToBf16(pfrexp<Packet4f>(Bf16ToF32(a), fexponent));
-  exponent = F32ToBf16(fexponent);
+  const Packet4bf out = F32ToBf16Truncate(pfrexp<Packet4f>(Bf16ToF32(a), fexponent));
+  exponent = F32ToBf16Truncate(fexponent);
   return out;
 }
 
@@ -50,7 +54,7 @@
 
 //---------- double ----------
 
-#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+#if EIGEN_ARCH_ARM64
 
 EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_DOUBLE(Packet2d)
 
diff --git a/Eigen/src/Core/arch/NEON/PacketMath.h b/Eigen/src/Core/arch/NEON/PacketMath.h
index 701ddcb..678d53b 100644
--- a/Eigen/src/Core/arch/NEON/PacketMath.h
+++ b/Eigen/src/Core/arch/NEON/PacketMath.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_NEON_H
 #define EIGEN_PACKET_MATH_NEON_H
@@ -202,7 +203,12 @@
     HasASin = 1,
     HasATan = 1,
     HasATanh = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasLog = 1,
+    HasLog10 = 1,
     HasExp = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
@@ -878,85 +884,18 @@
 EIGEN_STRONG_INLINE Packet2l pnegate(const Packet2l& a) {
 #if EIGEN_ARCH_ARM64
   return vnegq_s64(a);
+#elif !EIGEN_GNUC_STRICT_AT_LEAST(12, 0, 0)
+  return psub(pzero(a), a);
 #else
-  return vcombine_s64(vdup_n_s64(-vgetq_lane_s64(a, 0)), vdup_n_s64(-vgetq_lane_s64(a, 1)));
+  // NOTE: GCC>=12 refuses to emit `vsub.i64` for `0 - x`: <https://godbolt.org/z/bfaz9ao59>.
+  int64x2_t x = a;
+  int64x2_t z = vdupq_n_s64(0);
+  asm("vsub.i64 %q0, %q1, %q0" : "+w"(x) : "w"(z));
+  return x;
 #endif
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2f pconj(const Packet2f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4c pconj(const Packet4c& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8c pconj(const Packet8c& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet16c pconj(const Packet16c& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4uc pconj(const Packet4uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8uc pconj(const Packet8uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet16uc pconj(const Packet16uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4s pconj(const Packet4s& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8s pconj(const Packet8s& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4us pconj(const Packet4us& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8us pconj(const Packet8us& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2i pconj(const Packet2i& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2ui pconj(const Packet2ui& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4ui pconj(const Packet4ui& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2l pconj(const Packet2l& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2ul pconj(const Packet2ul& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2f pmul<Packet2f>(const Packet2f& a, const Packet2f& b) {
   return vmul_f32(a, b);
 }
@@ -1023,14 +962,15 @@
   return vmulq_u32(a, b);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2l pmul<Packet2l>(const Packet2l& a, const Packet2l& b) {
-  return vcombine_s64(vdup_n_s64(vgetq_lane_s64(a, 0) * vgetq_lane_s64(b, 0)),
-                      vdup_n_s64(vgetq_lane_s64(a, 1) * vgetq_lane_s64(b, 1)));
+EIGEN_STRONG_INLINE Packet2ul pmul<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+  const uint32x2_t al = vmovn_u64(a);
+  const uint32x2_t bl = vmovn_u64(b);
+  const uint64x2_t hi = vpaddlq_u32(vmulq_u32(vreinterpretq_u32_u64(a), vrev64q_u32(vreinterpretq_u32_u64(b))));
+  return vmlal_u32(vshlq_n_u64(hi, 32), al, bl);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2ul pmul<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
-  return vcombine_u64(vdup_n_u64(vgetq_lane_u64(a, 0) * vgetq_lane_u64(b, 0)),
-                      vdup_n_u64(vgetq_lane_u64(a, 1) * vgetq_lane_u64(b, 1)));
+EIGEN_STRONG_INLINE Packet2l pmul<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vreinterpretq_s64_u64(pmul(vreinterpretq_u64_s64(a), vreinterpretq_u64_s64(b)));
 }
 
 template <>
@@ -1320,14 +1260,9 @@
 #endif
 
 template <>
-EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
-  return pmin<Packet4f>(a, b);
-}
-
+struct pminmax_propagates_nan<Packet2f> : bool_constant<true> {};
 template <>
-EIGEN_STRONG_INLINE Packet2f pmin<PropagateNaN, Packet2f>(const Packet2f& a, const Packet2f& b) {
-  return pmin<Packet2f>(a, b);
-}
+struct pminmax_propagates_nan<Packet4f> : bool_constant<true> {};
 
 template <>
 EIGEN_STRONG_INLINE Packet4c pmin<Packet4c>(const Packet4c& a, const Packet4c& b) {
@@ -1388,14 +1323,8 @@
   return vminq_u32(a, b);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2l pmin<Packet2l>(const Packet2l& a, const Packet2l& b) {
-  return vcombine_s64(vdup_n_s64((std::min)(vgetq_lane_s64(a, 0), vgetq_lane_s64(b, 0))),
-                      vdup_n_s64((std::min)(vgetq_lane_s64(a, 1), vgetq_lane_s64(b, 1))));
-}
-template <>
 EIGEN_STRONG_INLINE Packet2ul pmin<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
-  return vcombine_u64(vdup_n_u64((std::min)(vgetq_lane_u64(a, 0), vgetq_lane_u64(b, 0))),
-                      vdup_n_u64((std::min)(vgetq_lane_u64(a, 1), vgetq_lane_u64(b, 1))));
+  return vsubq_u64(a, vqsubq_u64(a, b));
 }
 
 template <>
@@ -1421,16 +1350,6 @@
 #endif
 
 template <>
-EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(const Packet4f& a, const Packet4f& b) {
-  return pmax<Packet4f>(a, b);
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet2f pmax<PropagateNaN, Packet2f>(const Packet2f& a, const Packet2f& b) {
-  return pmax<Packet2f>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4c pmax<Packet4c>(const Packet4c& a, const Packet4c& b) {
   return vget_lane_s32(
       vreinterpret_s32_s8(vmax_s8(vreinterpret_s8_s32(vdup_n_s32(a)), vreinterpret_s8_s32(vdup_n_s32(b)))), 0);
@@ -1489,14 +1408,8 @@
   return vmaxq_u32(a, b);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2l pmax<Packet2l>(const Packet2l& a, const Packet2l& b) {
-  return vcombine_s64(vdup_n_s64((std::max)(vgetq_lane_s64(a, 0), vgetq_lane_s64(b, 0))),
-                      vdup_n_s64((std::max)(vgetq_lane_s64(a, 1), vgetq_lane_s64(b, 1))));
-}
-template <>
 EIGEN_STRONG_INLINE Packet2ul pmax<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
-  return vcombine_u64(vdup_n_u64((std::max)(vgetq_lane_u64(a, 0), vgetq_lane_u64(b, 0))),
-                      vdup_n_u64((std::max)(vgetq_lane_u64(a, 1), vgetq_lane_u64(b, 1))));
+  return vaddq_u64(b, vqsubq_u64(a, b));
 }
 
 template <>
@@ -1565,24 +1478,6 @@
 EIGEN_STRONG_INLINE Packet4ui pcmp_le<Packet4ui>(const Packet4ui& a, const Packet4ui& b) {
   return vcleq_u32(a, b);
 }
-template <>
-EIGEN_STRONG_INLINE Packet2l pcmp_le<Packet2l>(const Packet2l& a, const Packet2l& b) {
-#if EIGEN_ARCH_ARM64
-  return vreinterpretq_s64_u64(vcleq_s64(a, b));
-#else
-  return vcombine_s64(vdup_n_s64(vgetq_lane_s64(a, 0) <= vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
-                      vdup_n_s64(vgetq_lane_s64(a, 1) <= vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
-#endif
-}
-template <>
-EIGEN_STRONG_INLINE Packet2ul pcmp_le<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
-#if EIGEN_ARCH_ARM64
-  return vcleq_u64(a, b);
-#else
-  return vcombine_u64(vdup_n_u64(vgetq_lane_u64(a, 0) <= vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
-                      vdup_n_u64(vgetq_lane_u64(a, 1) <= vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
-#endif
-}
 
 template <>
 EIGEN_STRONG_INLINE Packet2f pcmp_lt<Packet2f>(const Packet2f& a, const Packet2f& b) {
@@ -1650,13 +1545,13 @@
 EIGEN_STRONG_INLINE Packet4ui pcmp_lt<Packet4ui>(const Packet4ui& a, const Packet4ui& b) {
   return vcltq_u32(a, b);
 }
+
 template <>
 EIGEN_STRONG_INLINE Packet2l pcmp_lt<Packet2l>(const Packet2l& a, const Packet2l& b) {
 #if EIGEN_ARCH_ARM64
   return vreinterpretq_s64_u64(vcltq_s64(a, b));
 #else
-  return vcombine_s64(vdup_n_s64(vgetq_lane_s64(a, 0) < vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
-                      vdup_n_s64(vgetq_lane_s64(a, 1) < vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
+  return vshrq_n_s64(vqsubq_s64(a, b), 63);
 #endif
 }
 template <>
@@ -1664,10 +1559,35 @@
 #if EIGEN_ARCH_ARM64
   return vcltq_u64(a, b);
 #else
-  return vcombine_u64(vdup_n_u64(vgetq_lane_u64(a, 0) < vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
-                      vdup_n_u64(vgetq_lane_u64(a, 1) < vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+  const uint64x2_t flag = vshrq_n_u64(vreinterpretq_u64_u8(vdupq_n_u8(0xFF)), 1);
+  return vreinterpretq_u64_s64(vshrq_n_s64(vreinterpretq_s64_u64(vqaddq_u64(vqsubq_u64(b, a), flag)), 63));
 #endif
 }
+template <>
+EIGEN_STRONG_INLINE Packet2l pcmp_le<Packet2l>(const Packet2l& a, const Packet2l& b) {
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vcleq_s64(a, b));
+#else
+  return vreinterpretq_s64_u8(vmvnq_u8(vreinterpretq_u8_s64(pcmp_lt(b, a))));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet2ul pcmp_le<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
+#if EIGEN_ARCH_ARM64
+  return vcleq_u64(a, b);
+#else
+  return vreinterpretq_u64_u8(vmvnq_u8(vreinterpretq_u8_u64(pcmp_lt(b, a))));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2l pmin<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vbslq_s64(vreinterpretq_u64_s64(pcmp_lt(a, b)), a, b);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2l pmax<Packet2l>(const Packet2l& a, const Packet2l& b) {
+  return vbslq_s64(vreinterpretq_u64_s64(pcmp_lt(b, a)), a, b);
+}
 
 template <>
 EIGEN_STRONG_INLINE Packet2f pcmp_eq<Packet2f>(const Packet2f& a, const Packet2f& b) {
@@ -1736,21 +1656,20 @@
   return vceqq_u32(a, b);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2l pcmp_eq<Packet2l>(const Packet2l& a, const Packet2l& b) {
-#if EIGEN_ARCH_ARM64
-  return vreinterpretq_s64_u64(vceqq_s64(a, b));
-#else
-  return vcombine_s64(vdup_n_s64(vgetq_lane_s64(a, 0) == vgetq_lane_s64(b, 0) ? numext::int64_t(-1) : 0),
-                      vdup_n_s64(vgetq_lane_s64(a, 1) == vgetq_lane_s64(b, 1) ? numext::int64_t(-1) : 0));
-#endif
-}
-template <>
 EIGEN_STRONG_INLINE Packet2ul pcmp_eq<Packet2ul>(const Packet2ul& a, const Packet2ul& b) {
 #if EIGEN_ARCH_ARM64
   return vceqq_u64(a, b);
 #else
-  return vcombine_u64(vdup_n_u64(vgetq_lane_u64(a, 0) == vgetq_lane_u64(b, 0) ? numext::uint64_t(-1) : 0),
-                      vdup_n_u64(vgetq_lane_u64(a, 1) == vgetq_lane_u64(b, 1) ? numext::uint64_t(-1) : 0));
+  const uint32x4_t eq = vceqq_u32(vreinterpretq_u32_u64(a), vreinterpretq_u32_u64(b));
+  return vreinterpretq_u64_u32(vandq_u32(eq, vrev64q_u32(eq)));
+#endif
+}
+template <>
+EIGEN_STRONG_INLINE Packet2l pcmp_eq<Packet2l>(const Packet2l& a, const Packet2l& b) {
+#if EIGEN_ARCH_ARM64
+  return vreinterpretq_s64_u64(vceqq_s64(a, b));
+#else
+  return vreinterpretq_s64_u64(pcmp_eq(vreinterpretq_u64_s64(a), vreinterpretq_u64_s64(b)));
 #endif
 }
 
@@ -2057,197 +1976,197 @@
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4c parithmetic_shift_right(Packet4c& a) {
+EIGEN_STRONG_INLINE Packet4c parithmetic_shift_right(const Packet4c& a) {
   return vget_lane_s32(vreinterpret_s32_s8(vshr_n_s8(vreinterpret_s8_s32(vdup_n_s32(a)), N)), 0);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8c parithmetic_shift_right(Packet8c a) {
+EIGEN_STRONG_INLINE Packet8c parithmetic_shift_right(const Packet8c& a) {
   return vshr_n_s8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet16c parithmetic_shift_right(Packet16c a) {
+EIGEN_STRONG_INLINE Packet16c parithmetic_shift_right(const Packet16c& a) {
   return vshrq_n_s8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4uc parithmetic_shift_right(Packet4uc& a) {
+EIGEN_STRONG_INLINE Packet4uc parithmetic_shift_right(const Packet4uc& a) {
   return vget_lane_u32(vreinterpret_u32_u8(vshr_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8uc parithmetic_shift_right(Packet8uc a) {
+EIGEN_STRONG_INLINE Packet8uc parithmetic_shift_right(const Packet8uc& a) {
   return vshr_n_u8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet16uc parithmetic_shift_right(Packet16uc a) {
+EIGEN_STRONG_INLINE Packet16uc parithmetic_shift_right(const Packet16uc& a) {
   return vshrq_n_u8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4s parithmetic_shift_right(Packet4s a) {
+EIGEN_STRONG_INLINE Packet4s parithmetic_shift_right(const Packet4s& a) {
   return vshr_n_s16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(Packet8s a) {
+EIGEN_STRONG_INLINE Packet8s parithmetic_shift_right(const Packet8s& a) {
   return vshrq_n_s16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4us parithmetic_shift_right(Packet4us a) {
+EIGEN_STRONG_INLINE Packet4us parithmetic_shift_right(const Packet4us& a) {
   return vshr_n_u16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8us parithmetic_shift_right(Packet8us a) {
+EIGEN_STRONG_INLINE Packet8us parithmetic_shift_right(const Packet8us& a) {
   return vshrq_n_u16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2i parithmetic_shift_right(Packet2i a) {
+EIGEN_STRONG_INLINE Packet2i parithmetic_shift_right(const Packet2i& a) {
   return vshr_n_s32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(Packet4i a) {
+EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(const Packet4i& a) {
   return vshrq_n_s32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2ui parithmetic_shift_right(Packet2ui a) {
+EIGEN_STRONG_INLINE Packet2ui parithmetic_shift_right(const Packet2ui& a) {
   return vshr_n_u32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right(Packet4ui a) {
+EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right(const Packet4ui& a) {
   return vshrq_n_u32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2l parithmetic_shift_right(Packet2l a) {
+EIGEN_STRONG_INLINE Packet2l parithmetic_shift_right(const Packet2l& a) {
   return vshrq_n_s64(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2ul parithmetic_shift_right(Packet2ul a) {
+EIGEN_STRONG_INLINE Packet2ul parithmetic_shift_right(const Packet2ul& a) {
   return vshrq_n_u64(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4c plogical_shift_right(Packet4c& a) {
+EIGEN_STRONG_INLINE Packet4c plogical_shift_right(const Packet4c& a) {
   return vget_lane_s32(vreinterpret_s32_u8(vshr_n_u8(vreinterpret_u8_s32(vdup_n_s32(a)), N)), 0);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8c plogical_shift_right(Packet8c a) {
+EIGEN_STRONG_INLINE Packet8c plogical_shift_right(const Packet8c& a) {
   return vreinterpret_s8_u8(vshr_n_u8(vreinterpret_u8_s8(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet16c plogical_shift_right(Packet16c a) {
+EIGEN_STRONG_INLINE Packet16c plogical_shift_right(const Packet16c& a) {
   return vreinterpretq_s8_u8(vshrq_n_u8(vreinterpretq_u8_s8(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4uc plogical_shift_right(Packet4uc& a) {
-  return vget_lane_u32(vreinterpret_u32_s8(vshr_n_s8(vreinterpret_s8_u32(vdup_n_u32(a)), N)), 0);
+EIGEN_STRONG_INLINE Packet4uc plogical_shift_right(const Packet4uc& a) {
+  return vget_lane_u32(vreinterpret_u32_u8(vshr_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8uc plogical_shift_right(Packet8uc a) {
+EIGEN_STRONG_INLINE Packet8uc plogical_shift_right(const Packet8uc& a) {
   return vshr_n_u8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet16uc plogical_shift_right(Packet16uc a) {
+EIGEN_STRONG_INLINE Packet16uc plogical_shift_right(const Packet16uc& a) {
   return vshrq_n_u8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4s plogical_shift_right(Packet4s a) {
+EIGEN_STRONG_INLINE Packet4s plogical_shift_right(const Packet4s& a) {
   return vreinterpret_s16_u16(vshr_n_u16(vreinterpret_u16_s16(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8s plogical_shift_right(Packet8s a) {
+EIGEN_STRONG_INLINE Packet8s plogical_shift_right(const Packet8s& a) {
   return vreinterpretq_s16_u16(vshrq_n_u16(vreinterpretq_u16_s16(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4us plogical_shift_right(Packet4us a) {
+EIGEN_STRONG_INLINE Packet4us plogical_shift_right(const Packet4us& a) {
   return vshr_n_u16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8us plogical_shift_right(Packet8us a) {
+EIGEN_STRONG_INLINE Packet8us plogical_shift_right(const Packet8us& a) {
   return vshrq_n_u16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2i plogical_shift_right(Packet2i a) {
+EIGEN_STRONG_INLINE Packet2i plogical_shift_right(const Packet2i& a) {
   return vreinterpret_s32_u32(vshr_n_u32(vreinterpret_u32_s32(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4i plogical_shift_right(Packet4i a) {
+EIGEN_STRONG_INLINE Packet4i plogical_shift_right(const Packet4i& a) {
   return vreinterpretq_s32_u32(vshrq_n_u32(vreinterpretq_u32_s32(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2ui plogical_shift_right(Packet2ui a) {
+EIGEN_STRONG_INLINE Packet2ui plogical_shift_right(const Packet2ui& a) {
   return vshr_n_u32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(Packet4ui a) {
+EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(const Packet4ui& a) {
   return vshrq_n_u32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2l plogical_shift_right(Packet2l a) {
+EIGEN_STRONG_INLINE Packet2l plogical_shift_right(const Packet2l& a) {
   return vreinterpretq_s64_u64(vshrq_n_u64(vreinterpretq_u64_s64(a), N));
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2ul plogical_shift_right(Packet2ul a) {
+EIGEN_STRONG_INLINE Packet2ul plogical_shift_right(const Packet2ul& a) {
   return vshrq_n_u64(a, N);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4c plogical_shift_left(Packet4c& a) {
+EIGEN_STRONG_INLINE Packet4c plogical_shift_left(const Packet4c& a) {
   return vget_lane_s32(vreinterpret_s32_s8(vshl_n_s8(vreinterpret_s8_s32(vdup_n_s32(a)), N)), 0);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8c plogical_shift_left(Packet8c a) {
+EIGEN_STRONG_INLINE Packet8c plogical_shift_left(const Packet8c& a) {
   return vshl_n_s8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet16c plogical_shift_left(Packet16c a) {
+EIGEN_STRONG_INLINE Packet16c plogical_shift_left(const Packet16c& a) {
   return vshlq_n_s8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4uc plogical_shift_left(Packet4uc& a) {
+EIGEN_STRONG_INLINE Packet4uc plogical_shift_left(const Packet4uc& a) {
   return vget_lane_u32(vreinterpret_u32_u8(vshl_n_u8(vreinterpret_u8_u32(vdup_n_u32(a)), N)), 0);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8uc plogical_shift_left(Packet8uc a) {
+EIGEN_STRONG_INLINE Packet8uc plogical_shift_left(const Packet8uc& a) {
   return vshl_n_u8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet16uc plogical_shift_left(Packet16uc a) {
+EIGEN_STRONG_INLINE Packet16uc plogical_shift_left(const Packet16uc& a) {
   return vshlq_n_u8(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4s plogical_shift_left(Packet4s a) {
+EIGEN_STRONG_INLINE Packet4s plogical_shift_left(const Packet4s& a) {
   return vshl_n_s16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8s plogical_shift_left(Packet8s a) {
+EIGEN_STRONG_INLINE Packet8s plogical_shift_left(const Packet8s& a) {
   return vshlq_n_s16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4us plogical_shift_left(Packet4us a) {
+EIGEN_STRONG_INLINE Packet4us plogical_shift_left(const Packet4us& a) {
   return vshl_n_u16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet8us plogical_shift_left(Packet8us a) {
+EIGEN_STRONG_INLINE Packet8us plogical_shift_left(const Packet8us& a) {
   return vshlq_n_u16(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2i plogical_shift_left(Packet2i a) {
+EIGEN_STRONG_INLINE Packet2i plogical_shift_left(const Packet2i& a) {
   return vshl_n_s32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4i plogical_shift_left(Packet4i a) {
+EIGEN_STRONG_INLINE Packet4i plogical_shift_left(const Packet4i& a) {
   return vshlq_n_s32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2ui plogical_shift_left(Packet2ui a) {
+EIGEN_STRONG_INLINE Packet2ui plogical_shift_left(const Packet2ui& a) {
   return vshl_n_u32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(Packet4ui a) {
+EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(const Packet4ui& a) {
   return vshlq_n_u32(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2l plogical_shift_left(Packet2l a) {
+EIGEN_STRONG_INLINE Packet2l plogical_shift_left(const Packet2l& a) {
   return vshlq_n_s64(a, N);
 }
 template <int N>
-EIGEN_STRONG_INLINE Packet2ul plogical_shift_left(Packet2ul a) {
+EIGEN_STRONG_INLINE Packet2ul plogical_shift_left(const Packet2ul& a) {
   return vshlq_n_u64(a, N);
 }
 
@@ -3262,18 +3181,6 @@
   return vabsq_s8(a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet4uc pabs(const Packet4uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8uc pabs(const Packet8uc& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet16uc pabs(const Packet16uc& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet4s pabs(const Packet4s& a) {
   return vabs_s16(a);
 }
@@ -3282,14 +3189,6 @@
   return vabsq_s16(a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet4us pabs(const Packet4us& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet8us pabs(const Packet8us& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet2i pabs(const Packet2i& a) {
   return vabs_s32(a);
 }
@@ -3298,27 +3197,19 @@
   return vabsq_s32(a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet2ui pabs(const Packet2ui& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4ui pabs(const Packet4ui& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet2l pabs(const Packet2l& a) {
 #if EIGEN_ARCH_ARM64
   return vabsq_s64(a);
 #else
-  return vcombine_s64(vdup_n_s64((std::abs)(vgetq_lane_s64(a, 0))), vdup_n_s64((std::abs)(vgetq_lane_s64(a, 1))));
+  // NOTE: From <https://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs>. The addition is
+  // done in the unsigned domain: at `a == INT64_MIN`, `mask == -1`, so the signed `a + mask` is UB
+  // (it wraps to INT64_MIN on every real target, which is exactly what's needed here).
+  const int64x2_t mask = vshrq_n_s64(a, 63);
+  const uint64x2_t sum = vaddq_u64(vreinterpretq_u64_s64(a), vreinterpretq_u64_s64(mask));
+  return veorq_s64(vreinterpretq_s64_u64(sum), mask);
 #endif
 }
 template <>
-EIGEN_STRONG_INLINE Packet2ul pabs(const Packet2ul& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2f psignbit(const Packet2f& a) {
   return vreinterpret_f32_s32(vshr_n_s32(vreinterpret_s32_f32(a), 31));
 }
@@ -3354,6 +3245,12 @@
 EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a) {
   return vaddvq_f32(a);
 }
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet4f& a) {
+  const uint32x4_t nonzero = vbicq_u32(vdupq_n_u32(1), vceqq_f32(a, vdupq_n_f32(0.0f)));
+  return static_cast<Index>(vaddvq_u32(nonzero));
+}
 #else
 template <>
 EIGEN_STRONG_INLINE float predux<Packet2f>(const Packet2f& a) {
@@ -3987,6 +3884,11 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2f& x) {
+  return vget_lane_u64(vreinterpret_u64_f32(x), 0) != 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE bool predux_any(const Packet4f& x) {
   uint32x4_t u = vreinterpretq_u32_f32(x);
 #if EIGEN_ARCH_ARM64
@@ -4343,7 +4245,7 @@
   return vbslq_u64(mask, a, b);
 }
 
-// Use armv8 rounding intinsics if available.
+// Use armv8 rounding intrinsics if available.
 #if EIGEN_ARCH_ARMV8
 template <>
 EIGEN_STRONG_INLINE Packet2f print<Packet2f>(const Packet2f& a) {
@@ -4625,9 +4527,7 @@
 typedef eigen_packet_wrapper<uint16x4_t, 19> Packet4bf;
 
 template <>
-struct is_arithmetic<Packet4bf> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet4bf> : std::true_type {};
 
 template <>
 struct packet_traits<bfloat16> : default_packet_traits {
@@ -4702,6 +4602,11 @@
   return vmovn_u32(input);
 }
 
+// Discard the low 16 bits of each float. Only valid when every lane already holds an exact
+// bfloat16 value, in which case this agrees with F32ToBf16 but skips its rounding and NaN
+// canonicalization. pmin/pmax qualify: they return one of their operands bit for bit.
+EIGEN_STRONG_INLINE Packet4bf F32ToBf16Truncate(const Packet4f& p) { return vshrn_n_u32(vreinterpretq_u32_f32(p), 16); }
+
 EIGEN_STRONG_INLINE Packet4f Bf16ToF32(const Packet4bf& p) {
   return Packet4f(vreinterpretq_f32_u32(vshlq_n_u32(vmovl_u16(p), 16)));
 }
@@ -4747,35 +4652,35 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pabs(const Packet4bf& a) {
-  return F32ToBf16(pabs<Packet4f>(Bf16ToF32(a)));
+  return Packet4bf(vand_u16(a, vdup_n_u16(0x7fff)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pmin<PropagateNumbers, Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
-  return F32ToBf16(pmin<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmin<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 template <>
 EIGEN_STRONG_INLINE Packet4bf pmin<PropagateNaN, Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
-  return F32ToBf16(pmin<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmin<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pmin<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
-  return F32ToBf16(pmin<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmin<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pmax<PropagateNumbers, Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
-  return F32ToBf16(pmax<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmax<PropagateNumbers, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 template <>
 EIGEN_STRONG_INLINE Packet4bf pmax<PropagateNaN, Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
-  return F32ToBf16(pmax<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmax<PropagateNaN, Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pmax<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
-  return F32ToBf16(pmax<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
+  return F32ToBf16Truncate(pmax<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
 template <>
@@ -4810,32 +4715,27 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf print<Packet4bf>(const Packet4bf& a) {
-  return F32ToBf16(print<Packet4f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(print<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pfloor<Packet4bf>(const Packet4bf& a) {
-  return F32ToBf16(pfloor<Packet4f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pfloor<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pceil<Packet4bf>(const Packet4bf& a) {
-  return F32ToBf16(pceil<Packet4f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pceil<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf pround<Packet4bf>(const Packet4bf& a) {
-  return F32ToBf16(pround<Packet4f>(Bf16ToF32(a)));
+  return F32ToBf16Truncate(pround<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4bf ptrunc<Packet4bf>(const Packet4bf& a) {
-  return F32ToBf16(ptrunc<Packet4f>(Bf16ToF32(a)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4bf pconj(const Packet4bf& a) {
-  return a;
+  return F32ToBf16Truncate(ptrunc<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
@@ -4895,12 +4795,12 @@
 
 template <>
 EIGEN_STRONG_INLINE bfloat16 predux_max<Packet4bf>(const Packet4bf& a) {
-  return static_cast<bfloat16>(predux_max<Packet4f>(Bf16ToF32(a)));
+  return bfloat16_impl::exact_float_to_bfloat16(predux_max<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
 EIGEN_STRONG_INLINE bfloat16 predux_min<Packet4bf>(const Packet4bf& a) {
-  return static_cast<bfloat16>(predux_min<Packet4f>(Bf16ToF32(a)));
+  return bfloat16_impl::exact_float_to_bfloat16(predux_min<Packet4f>(Bf16ToF32(a)));
 }
 
 template <>
@@ -4909,6 +4809,11 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4bf& a) {
+  return vget_lane_u64(vreinterpret_u64_u16(Packet4us(a)), 0) != 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE Packet4bf preverse<Packet4bf>(const Packet4bf& a) {
   return Packet4bf(preverse<Packet4us>(Packet4us(a)));
 }
@@ -4937,6 +4842,28 @@
   return F32MaskToBf16Mask(pcmp_lt_or_nan<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
+// Classify on the raw bits, as the scalar isinf/isnan/isfinite do: |a| ==, >, < 0x7f80.
+template <>
+EIGEN_STRONG_INLINE Packet4bf pisinf<Packet4bf>(const Packet4bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return vceq_u16(vand_u16(a, vdup_n_u16(kAbsMask)), vdup_n_u16(kInf));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4bf pisnan<Packet4bf>(const Packet4bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return vcgt_u16(vand_u16(a, vdup_n_u16(kAbsMask)), vdup_n_u16(kInf));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4bf pisfinite<Packet4bf>(const Packet4bf& a) {
+  constexpr uint16_t kInf = ((1 << 8) - 1) << 7;
+  constexpr uint16_t kAbsMask = (1 << 15) - 1;
+  return vclt_u16(vand_u16(a, vdup_n_u16(kAbsMask)), vdup_n_u16(kInf));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet4bf pcmp_le<Packet4bf>(const Packet4bf& a, const Packet4bf& b) {
   return F32MaskToBf16Mask(pcmp_le<Packet4f>(Bf16ToF32(a), Bf16ToF32(b)));
@@ -4949,18 +4876,7 @@
 
 //---------- double ----------
 
-// Clang 3.5 in the iOS toolchain has an ICE triggered by NEON intrinsics for double.
-// Confirmed at least with __apple_build_version__ = 6000054.
-#if EIGEN_COMP_CLANGAPPLE
-// Let's hope that by the time __apple_build_version__ hits the 601* range, the bug will be fixed.
-// https://gist.github.com/yamaya/2924292 suggests that the 3 first digits are only updated with
-// major toolchain updates.
-#define EIGEN_APPLE_DOUBLE_NEON_BUG (EIGEN_COMP_CLANGAPPLE < 6010000)
-#else
-#define EIGEN_APPLE_DOUBLE_NEON_BUG 0
-#endif
-
-#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+#if EIGEN_ARCH_ARM64
 
 #if EIGEN_COMP_GNUC
 // Bug 907: workaround missing declarations of the following two functions in the ADK
@@ -5037,14 +4953,19 @@
 
     HasDiv = 1,
 
-#if EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+#if EIGEN_ARCH_ARM64
     HasExp = 1,
     HasLog = 1,
+    HasLog10 = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
     HasPow = 1,
     HasATan = 1,
     HasATanh = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
 #endif
     HasSin = EIGEN_FAST_MATH,
     HasCos = EIGEN_FAST_MATH,
@@ -5103,11 +5024,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) {
   return vmulq_f64(a, b);
 }
@@ -5165,20 +5081,13 @@
 #endif
 
 template <>
-EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
-  return pmin<Packet2d>(a, b);
-}
+struct pminmax_propagates_nan<Packet2d> : bool_constant<true> {};
 
 template <>
 EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) {
   return vmaxq_f64(a, b);
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(const Packet2d& a, const Packet2d& b) {
-  return pmax<Packet2d>(a, b);
-}
-
 // Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics
 template <>
 EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) {
@@ -5289,6 +5198,18 @@
   return vaddvq_f64(a);
 }
 
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet2d& a) {
+  // Each zero lane contributes UINT64_MAX, so unsigned 2 + sum(mask) is the number of nonzero lanes.
+  const uint64_t zeroMaskSum = vaddvq_u64(vceqq_f64(a, vdupq_n_f64(0.0)));
+  return static_cast<Index>(zeroMaskSum + 2);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2d& a) {
+  return vmaxvq_u32(vreinterpretq_u32_f64(a)) != 0;
+}
+
 // Other reduction functions:
 // mul
 #if EIGEN_COMP_CLANGAPPLE
@@ -5379,15 +5300,46 @@
   return vsqrtq_f64(_x);
 }
 
-#endif  // EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG
+#endif  // EIGEN_ARCH_ARM64
 
-// Do we have an fp16 types and supporting Neon intrinsics?
-#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+// Do we have fp16 and support Neon intrinsics?
+// FIXME: This disables vectorization on ARMv7 even though FP16 vector operations should
+// be available with `__ARM_FEATURE_FP16_VECTOR_ARITHMETIC`.  However, since the internal
+// feature test macro `EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC` requires `EIGEN_ARCH_ARM64`
+// in addition to the ISA feature test, the guard here also only checks for ARM64.
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
 typedef float16x4_t Packet4hf;
 typedef float16x8_t Packet8hf;
 
+// Clang <19.1.0 does not provide `f16` intrinsics for pure data movement instructions.
+// Polyfill them with `u16`.
+//
+// See: <https://github.com/llvm/llvm-project/pull/87467>.
+#if EIGEN_CLANG_STRICT_LESS_THAN(19, 1, 0) && !EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+EIGEN_ALWAYS_INLINE float16x4_t vbsl_f16(uint16x4_t a, float16x4_t b, float16x4_t c) {
+  return vreinterpret_f16_u16(vbsl_u16(a, vreinterpret_u16_f16(b), vreinterpret_u16_f16(c)));
+}
+EIGEN_ALWAYS_INLINE float16x8_t vbslq_f16(uint16x8_t a, float16x8_t b, float16x8_t c) {
+  return vreinterpretq_f16_u16(vbslq_u16(a, vreinterpretq_u16_f16(b), vreinterpretq_u16_f16(c)));
+}
+EIGEN_ALWAYS_INLINE float16x4_t vrev64_f16(float16x4_t a) {
+  return vreinterpret_f16_u16(vrev64_u16(vreinterpret_u16_f16(a)));
+}
+EIGEN_ALWAYS_INLINE float16x8_t vrev64q_f16(float16x8_t a) {
+  return vreinterpretq_f16_u16(vrev64q_u16(vreinterpretq_u16_f16(a)));
+}
+EIGEN_ALWAYS_INLINE float16x8x2_t vzipq_f16(float16x8_t a, float16x8_t b) {
+  const uint16x8x2_t r = vzipq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b));
+  return {vreinterpretq_f16_u16(r.val[0]), vreinterpretq_f16_u16(r.val[1])};
+}
+EIGEN_ALWAYS_INLINE float16x8x2_t vuzpq_f16(float16x8_t a, float16x8_t b) {
+  const uint16x8x2_t r = vuzpq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b));
+  return {vreinterpretq_f16_u16(r.val[0]), vreinterpretq_f16_u16(r.val[1])};
+}
+#endif  // EIGEN_CLANG_STRICT_LESS_THAN(19, 1, 0) && !EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+
 template <>
-struct packet_traits<Eigen::half> : default_packet_traits {
+struct packet_traits<half> : default_packet_traits {
   typedef Packet8hf type;
   typedef Packet4hf half;
   enum {
@@ -5433,18 +5385,269 @@
 };
 
 template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf predux_half<Packet8hf>(const Packet8hf& a) {
-  return vadd_f16(vget_low_f16(a), vget_high_f16(a));
-}
+struct pminmax_propagates_nan<Packet4hf> : bool_constant<true> {};
+template <>
+struct pminmax_propagates_nan<Packet8hf> : bool_constant<true> {};
 
 template <>
-EIGEN_STRONG_INLINE Packet8hf pset1<Packet8hf>(const Eigen::half& from) {
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pset1(const half& from) {
   return vdupq_n_f16(from.x);
 }
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pset1(const half& from) {
+  return vdup_n_f16(from.x);
+}
+
+#define EIGEN_MAKE_HALF_BITWISE_BINOP(name, op)                                                     \
+  template <>                                                                                       \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf name(const Packet8hf& a, const Packet8hf& b) {    \
+    return vreinterpretq_f16_u16(v##op##q_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b))); \
+  }                                                                                                 \
+  template <>                                                                                       \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf name(const Packet4hf& a, const Packet4hf& b) {    \
+    return vreinterpret_f16_u16(v##op##_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));     \
+  }                                                                                                 \
+  static_assert(true, "Trailing semicolon required")
+
+EIGEN_MAKE_HALF_BITWISE_BINOP(pand, and);
+EIGEN_MAKE_HALF_BITWISE_BINOP(por, orr);
+EIGEN_MAKE_HALF_BITWISE_BINOP(pxor, eor);
+EIGEN_MAKE_HALF_BITWISE_BINOP(pandnot, bic);
+
+#undef EIGEN_MAKE_HALF_BITWISE_BINOP
 
 template <>
-EIGEN_STRONG_INLINE Packet4hf pset1<Packet4hf>(const Eigen::half& from) {
-  return vdup_n_f16(from.x);
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pload(const half* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f16(assume_aligned<unpacket_traits<Packet8hf>::alignment>(&from->x));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pload(const half* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return vld1_f16(assume_aligned<unpacket_traits<Packet4hf>::alignment>(&from->x));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf ploadu(const half* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f16(&from->x);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf ploadu(const half* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f16(&from->x);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf ploaddup(const half* from) {
+  Packet8hf packet{};
+  packet = vsetq_lane_f16(from[0].x, packet, 0);
+  packet = vsetq_lane_f16(from[0].x, packet, 1);
+  packet = vsetq_lane_f16(from[1].x, packet, 2);
+  packet = vsetq_lane_f16(from[1].x, packet, 3);
+  packet = vsetq_lane_f16(from[2].x, packet, 4);
+  packet = vsetq_lane_f16(from[2].x, packet, 5);
+  packet = vsetq_lane_f16(from[3].x, packet, 6);
+  packet = vsetq_lane_f16(from[3].x, packet, 7);
+  return packet;
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf ploaddup(const half* from) {
+  float16x4_t packet{};
+  packet = vset_lane_f16(from[0].x, packet, 0);
+  packet = vset_lane_f16(from[0].x, packet, 1);
+  packet = vset_lane_f16(from[1].x, packet, 2);
+  packet = vset_lane_f16(from[1].x, packet, 3);
+  return packet;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf ploadquad(const half* from) {
+  Packet4hf lo, hi;
+  lo = vld1_dup_f16(&from[0].x);
+  hi = vld1_dup_f16(&from[1].x);
+  return vcombine_f16(lo, hi);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertfirst(const Packet8hf& a, half b) {
+  return vsetq_lane_f16(b.x, a, 0);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertfirst(const Packet4hf& a, half b) {
+  return vset_lane_f16(b.x, a, 0);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pselect(const Packet8hf& mask, const Packet8hf& a, const Packet8hf& b) {
+  return vbslq_f16(vreinterpretq_u16_f16(mask), a, b);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pselect(const Packet4hf& mask, const Packet4hf& a, const Packet4hf& b) {
+  return vbsl_f16(vreinterpret_u16_f16(mask), a, b);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertlast(const Packet8hf& a, half b) {
+  return vsetq_lane_f16(b.x, a, 7);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertlast(const Packet4hf& a, half b) {
+  return vset_lane_f16(b.x, a, 3);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore(half* to, const Packet8hf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE vst1q_f16(assume_aligned<unpacket_traits<Packet8hf>::alignment>(&to->x), from);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pstore(half* to, const Packet4hf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE vst1_f16(assume_aligned<unpacket_traits<Packet4hf>::alignment>(&to->x), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu(half* to, const Packet8hf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE vst1q_f16(&to->x, from);
+}
+template <>
+EIGEN_STRONG_INLINE void pstoreu(half* to, const Packet4hf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE vst1_f16(&to->x, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pgather(const half* from, Index stride) {
+  Packet8hf res = pset1<Packet8hf>(half(0.f));
+  res = vsetq_lane_f16(from[0 * stride].x, res, 0);
+  res = vsetq_lane_f16(from[1 * stride].x, res, 1);
+  res = vsetq_lane_f16(from[2 * stride].x, res, 2);
+  res = vsetq_lane_f16(from[3 * stride].x, res, 3);
+  res = vsetq_lane_f16(from[4 * stride].x, res, 4);
+  res = vsetq_lane_f16(from[5 * stride].x, res, 5);
+  res = vsetq_lane_f16(from[6 * stride].x, res, 6);
+  res = vsetq_lane_f16(from[7 * stride].x, res, 7);
+  return res;
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pgather(const half* from, Index stride) {
+  Packet4hf res = pset1<Packet4hf>(half(0.f));
+  res = vset_lane_f16(from[0 * stride].x, res, 0);
+  res = vset_lane_f16(from[1 * stride].x, res, 1);
+  res = vset_lane_f16(from[2 * stride].x, res, 2);
+  res = vset_lane_f16(from[3 * stride].x, res, 3);
+  return res;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter(half* to, const Packet8hf& from, Index stride) {
+  to[stride * 0].x = vgetq_lane_f16(from, 0);
+  to[stride * 1].x = vgetq_lane_f16(from, 1);
+  to[stride * 2].x = vgetq_lane_f16(from, 2);
+  to[stride * 3].x = vgetq_lane_f16(from, 3);
+  to[stride * 4].x = vgetq_lane_f16(from, 4);
+  to[stride * 5].x = vgetq_lane_f16(from, 5);
+  to[stride * 6].x = vgetq_lane_f16(from, 6);
+  to[stride * 7].x = vgetq_lane_f16(from, 7);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter(half* to, const Packet4hf& from, Index stride) {
+  to[stride * 0].x = vget_lane_f16(from, 0);
+  to[stride * 1].x = vget_lane_f16(from, 1);
+  to[stride * 2].x = vget_lane_f16(from, 2);
+  to[stride * 3].x = vget_lane_f16(from, 3);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void prefetch(const half* addr) {
+  EIGEN_ARM_PREFETCH(addr);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half pfirst(const Packet8hf& a) {
+  return half(vgetq_lane_f16(a, 0));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half pfirst(const Packet4hf& a) {
+  return half(vget_lane_f16(a, 0));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf preverse(const Packet8hf& a) {
+  float16x8_t r = vrev64q_f16(a);
+  return vcombine_f16(vget_high_f16(r), vget_low_f16(r));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf preverse(const Packet4hf& a) {
+  return vrev64_f16(a);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf psignbit(const Packet8hf& a) {
+  return vreinterpretq_f16_s16(vshrq_n_s16(vreinterpretq_s16_f16(a), 15));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf psignbit(const Packet4hf& a) {
+  return vreinterpret_f16_s16(vshr_n_s16(vreinterpret_s16_f16(a), 15));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_any(const Packet8hf& a) {
+  return vget_lane_u64(vreinterpret_u64_u8(vmovn_u16(vreinterpretq_u16_f16(a))), 0);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool predux_any(const Packet4hf& a) {
+  return vget_lane_u64(vreinterpret_u64_f16(a), 0);
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 4>& kernel) {
+  const float16x8x2_t zip16_1 = vzipq_f16(kernel.packet[0], kernel.packet[1]);
+  const float16x8x2_t zip16_2 = vzipq_f16(kernel.packet[2], kernel.packet[3]);
+
+  const float32x4x2_t zip32_1 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[0]), vreinterpretq_f32_f16(zip16_2.val[0]));
+  const float32x4x2_t zip32_2 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[1]), vreinterpretq_f32_f16(zip16_2.val[1]));
+
+  kernel.packet[0] = vreinterpretq_f16_f32(zip32_1.val[0]);
+  kernel.packet[1] = vreinterpretq_f16_f32(zip32_1.val[1]);
+  kernel.packet[2] = vreinterpretq_f16_f32(zip32_2.val[0]);
+  kernel.packet[3] = vreinterpretq_f16_f32(zip32_2.val[1]);
+}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4hf, 4>& kernel) {
+  EIGEN_ALIGN16 float16x4x4_t tmp_x4;
+  float16_t* tmp = reinterpret_cast<float16_t*>(&kernel);
+  tmp_x4 = vld4_f16(tmp);
+
+  kernel.packet[0] = tmp_x4.val[0];
+  kernel.packet[1] = tmp_x4.val[1];
+  kernel.packet[2] = tmp_x4.val[2];
+  kernel.packet[3] = tmp_x4.val[3];
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 8>& kernel) {
+  float16x8x2_t T_1[4];
+
+  T_1[0] = vuzpq_f16(kernel.packet[0], kernel.packet[1]);
+  T_1[1] = vuzpq_f16(kernel.packet[2], kernel.packet[3]);
+  T_1[2] = vuzpq_f16(kernel.packet[4], kernel.packet[5]);
+  T_1[3] = vuzpq_f16(kernel.packet[6], kernel.packet[7]);
+
+  float16x8x2_t T_2[4];
+  T_2[0] = vuzpq_f16(T_1[0].val[0], T_1[1].val[0]);
+  T_2[1] = vuzpq_f16(T_1[0].val[1], T_1[1].val[1]);
+  T_2[2] = vuzpq_f16(T_1[2].val[0], T_1[3].val[0]);
+  T_2[3] = vuzpq_f16(T_1[2].val[1], T_1[3].val[1]);
+
+  float16x8x2_t T_3[4];
+  T_3[0] = vuzpq_f16(T_2[0].val[0], T_2[2].val[0]);
+  T_3[1] = vuzpq_f16(T_2[0].val[1], T_2[2].val[1]);
+  T_3[2] = vuzpq_f16(T_2[1].val[0], T_2[3].val[0]);
+  T_3[3] = vuzpq_f16(T_2[1].val[1], T_2[3].val[1]);
+
+  kernel.packet[0] = T_3[0].val[0];
+  kernel.packet[1] = T_3[2].val[0];
+  kernel.packet[2] = T_3[1].val[0];
+  kernel.packet[3] = T_3[3].val[0];
+  kernel.packet[4] = T_3[0].val[1];
+  kernel.packet[5] = T_3[2].val[1];
+  kernel.packet[6] = T_3[1].val[1];
+  kernel.packet[7] = T_3[3].val[1];
+}
+
+#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf predux_half<Packet8hf>(const Packet8hf& a) {
+  return vadd_f16(vget_low_f16(a), vget_high_f16(a));
 }
 
 template <>
@@ -5492,16 +5695,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet8hf pconj(const Packet8hf& a) {
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pconj(const Packet4hf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet8hf pmul<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
   return vmulq_f16(a, b);
 }
@@ -5542,26 +5735,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet8hf pmsub(const Packet8hf& a, const Packet8hf& b, const Packet8hf& c) {
-  return pnegate(pnmadd(a, b, c));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pmsub(const Packet4hf& a, const Packet4hf& b, const Packet4hf& c) {
-  return pnegate(pnmadd(a, b, c));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf pnmsub(const Packet8hf& a, const Packet8hf& b, const Packet8hf& c) {
-  return pnegate(pmadd(a, b, c));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pnmsub(const Packet4hf& a, const Packet4hf& b, const Packet4hf& c) {
-  return pnegate(pmadd(a, b, c));
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet8hf pmin<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
   return vminq_f16(a, b);
 }
@@ -5585,16 +5758,6 @@
 #endif
 
 template <>
-EIGEN_STRONG_INLINE Packet4hf pmin<PropagateNaN, Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
-  return pmin<Packet4hf>(a, b);
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf pmin<PropagateNaN, Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
-  return pmin<Packet8hf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet8hf pmax<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
   return vmaxq_f16(a, b);
 }
@@ -5617,16 +5780,6 @@
 }
 #endif
 
-template <>
-EIGEN_STRONG_INLINE Packet4hf pmax<PropagateNaN, Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
-  return pmax<Packet4hf>(a, b);
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf pmax<PropagateNaN, Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
-  return pmax<Packet8hf>(a, b);
-}
-
 #define EIGEN_MAKE_ARM_FP16_CMP_8(name)                                               \
   template <>                                                                         \
   EIGEN_STRONG_INLINE Packet8hf pcmp_##name(const Packet8hf& a, const Packet8hf& b) { \
@@ -5721,255 +5874,16 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet8hf pand<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
-  return vreinterpretq_f16_u16(vandq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pand<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
-  return vreinterpret_f16_u16(vand_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf por<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
-  return vreinterpretq_f16_u16(vorrq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf por<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
-  return vreinterpret_f16_u16(vorr_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf pxor<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
-  return vreinterpretq_f16_u16(veorq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pxor<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
-  return vreinterpret_f16_u16(veor_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf pandnot<Packet8hf>(const Packet8hf& a, const Packet8hf& b) {
-  return vreinterpretq_f16_u16(vbicq_u16(vreinterpretq_u16_f16(a), vreinterpretq_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pandnot<Packet4hf>(const Packet4hf& a, const Packet4hf& b) {
-  return vreinterpret_f16_u16(vbic_u16(vreinterpret_u16_f16(a), vreinterpret_u16_f16(b)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf pload<Packet8hf>(const Eigen::half* from) {
-  EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f16(
-      reinterpret_cast<const float16_t*>(assume_aligned<unpacket_traits<Packet8hf>::alignment>(from)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf pload<Packet4hf>(const Eigen::half* from) {
-  EIGEN_DEBUG_ALIGNED_LOAD return vld1_f16(
-      reinterpret_cast<const float16_t*>(assume_aligned<unpacket_traits<Packet4hf>::alignment>(from)));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf ploadu<Packet8hf>(const Eigen::half* from) {
-  EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f16(reinterpret_cast<const float16_t*>(from));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf ploadu<Packet4hf>(const Eigen::half* from) {
-  EIGEN_DEBUG_UNALIGNED_LOAD return vld1_f16(reinterpret_cast<const float16_t*>(from));
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf ploaddup<Packet8hf>(const Eigen::half* from) {
-  Packet8hf packet;
-  packet[0] = from[0].x;
-  packet[1] = from[0].x;
-  packet[2] = from[1].x;
-  packet[3] = from[1].x;
-  packet[4] = from[2].x;
-  packet[5] = from[2].x;
-  packet[6] = from[3].x;
-  packet[7] = from[3].x;
-  return packet;
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf ploaddup<Packet4hf>(const Eigen::half* from) {
-  float16x4_t packet;
-  float16_t* tmp;
-  tmp = (float16_t*)&packet;
-  tmp[0] = from[0].x;
-  tmp[1] = from[0].x;
-  tmp[2] = from[1].x;
-  tmp[3] = from[1].x;
-  return packet;
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf ploadquad<Packet8hf>(const Eigen::half* from) {
-  Packet4hf lo, hi;
-  lo = vld1_dup_f16(reinterpret_cast<const float16_t*>(from));
-  hi = vld1_dup_f16(reinterpret_cast<const float16_t*>(from + 1));
-  return vcombine_f16(lo, hi);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertfirst(const Packet8hf& a, Eigen::half b) {
-  return vsetq_lane_f16(b.x, a, 0);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertfirst(const Packet4hf& a, Eigen::half b) {
-  return vset_lane_f16(b.x, a, 0);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pselect(const Packet8hf& mask, const Packet8hf& a, const Packet8hf& b) {
-  return vbslq_f16(vreinterpretq_u16_f16(mask), a, b);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pselect(const Packet4hf& mask, const Packet4hf& a, const Packet4hf& b) {
-  return vbsl_f16(vreinterpret_u16_f16(mask), a, b);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pinsertlast(const Packet8hf& a, Eigen::half b) {
-  return vsetq_lane_f16(b.x, a, 7);
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pinsertlast(const Packet4hf& a, Eigen::half b) {
-  return vset_lane_f16(b.x, a, 3);
-}
-
-template <>
-EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet8hf& from) {
-  EIGEN_DEBUG_ALIGNED_STORE vst1q_f16(
-      reinterpret_cast<float16_t*>(assume_aligned<unpacket_traits<Packet8hf>::alignment>(to)), from);
-}
-
-template <>
-EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet4hf& from) {
-  EIGEN_DEBUG_ALIGNED_STORE vst1_f16(
-      reinterpret_cast<float16_t*>(assume_aligned<unpacket_traits<Packet4hf>::alignment>(to)), from);
-}
-
-template <>
-EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet8hf& from) {
-  EIGEN_DEBUG_UNALIGNED_STORE vst1q_f16(reinterpret_cast<float16_t*>(to), from);
-}
-
-template <>
-EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet4hf& from) {
-  EIGEN_DEBUG_UNALIGNED_STORE vst1_f16(reinterpret_cast<float16_t*>(to), from);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pgather<Eigen::half, Packet8hf>(const Eigen::half* from, Index stride) {
-  Packet8hf res = pset1<Packet8hf>(Eigen::half(0.f));
-  res = vsetq_lane_f16(from[0 * stride].x, res, 0);
-  res = vsetq_lane_f16(from[1 * stride].x, res, 1);
-  res = vsetq_lane_f16(from[2 * stride].x, res, 2);
-  res = vsetq_lane_f16(from[3 * stride].x, res, 3);
-  res = vsetq_lane_f16(from[4 * stride].x, res, 4);
-  res = vsetq_lane_f16(from[5 * stride].x, res, 5);
-  res = vsetq_lane_f16(from[6 * stride].x, res, 6);
-  res = vsetq_lane_f16(from[7 * stride].x, res, 7);
-  return res;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pgather<Eigen::half, Packet4hf>(const Eigen::half* from, Index stride) {
-  Packet4hf res = pset1<Packet4hf>(Eigen::half(0.f));
-  res = vset_lane_f16(from[0 * stride].x, res, 0);
-  res = vset_lane_f16(from[1 * stride].x, res, 1);
-  res = vset_lane_f16(from[2 * stride].x, res, 2);
-  res = vset_lane_f16(from[3 * stride].x, res, 3);
-  return res;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet8hf>(Eigen::half* to, const Packet8hf& from,
-                                                                            Index stride) {
-  to[stride * 0].x = vgetq_lane_f16(from, 0);
-  to[stride * 1].x = vgetq_lane_f16(from, 1);
-  to[stride * 2].x = vgetq_lane_f16(from, 2);
-  to[stride * 3].x = vgetq_lane_f16(from, 3);
-  to[stride * 4].x = vgetq_lane_f16(from, 4);
-  to[stride * 5].x = vgetq_lane_f16(from, 5);
-  to[stride * 6].x = vgetq_lane_f16(from, 6);
-  to[stride * 7].x = vgetq_lane_f16(from, 7);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void pscatter<Eigen::half, Packet4hf>(Eigen::half* to, const Packet4hf& from,
-                                                                            Index stride) {
-  to[stride * 0].x = vget_lane_f16(from, 0);
-  to[stride * 1].x = vget_lane_f16(from, 1);
-  to[stride * 2].x = vget_lane_f16(from, 2);
-  to[stride * 3].x = vget_lane_f16(from, 3);
-}
-
-template <>
-EIGEN_STRONG_INLINE void prefetch<Eigen::half>(const Eigen::half* addr) {
-  EIGEN_ARM_PREFETCH(addr);
-}
-
-template <>
-EIGEN_STRONG_INLINE Eigen::half pfirst<Packet8hf>(const Packet8hf& a) {
-  float16_t x[8];
-  vst1q_f16(x, a);
-  Eigen::half h;
-  h.x = x[0];
-  return h;
-}
-
-template <>
-EIGEN_STRONG_INLINE Eigen::half pfirst<Packet4hf>(const Packet4hf& a) {
-  float16_t x[4];
-  vst1_f16(x, a);
-  Eigen::half h;
-  h.x = x[0];
-  return h;
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet8hf preverse(const Packet8hf& a) {
-  float16x4_t a_lo, a_hi;
-  Packet8hf a_r64;
-
-  a_r64 = vrev64q_f16(a);
-  a_lo = vget_low_f16(a_r64);
-  a_hi = vget_high_f16(a_r64);
-  return vcombine_f16(a_hi, a_lo);
-}
-
-template <>
-EIGEN_STRONG_INLINE Packet4hf preverse<Packet4hf>(const Packet4hf& a) {
-  return vrev64_f16(a);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet8hf pabs<Packet8hf>(const Packet8hf& a) {
   return vabsq_f16(a);
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet8hf psignbit(const Packet8hf& a) {
-  return vreinterpretq_f16_s16(vshrq_n_s16(vreinterpretq_s16_f16(a), 15));
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4hf pabs<Packet4hf>(const Packet4hf& a) {
   return vabs_f16(a);
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4hf psignbit(const Packet4hf& a) {
-  return vreinterpret_f16_s16(vshr_n_s16(vreinterpret_s16_f16(a), 15));
-}
-
-template <>
 EIGEN_STRONG_INLINE Eigen::half predux<Packet8hf>(const Packet8hf& a) {
   float16x4_t a_lo, a_hi, sum;
 
@@ -6046,61 +5960,241 @@
   return h;
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 4>& kernel) {
-  const float16x8x2_t zip16_1 = vzipq_f16(kernel.packet[0], kernel.packet[1]);
-  const float16x8x2_t zip16_2 = vzipq_f16(kernel.packet[2], kernel.packet[3]);
+#else
 
-  const float32x4x2_t zip32_1 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[0]), vreinterpretq_f32_f16(zip16_2.val[0]));
-  const float32x4x2_t zip32_2 = vzipq_f32(vreinterpretq_f32_f16(zip16_1.val[1]), vreinterpretq_f32_f16(zip16_2.val[1]));
+// Even if we do not have native vector arithmetic on fp16 types, we can still
+// assume the presence of conversion instructions to/from fp32 on AArch64
+// ([ref]).  As a result, packet arithmetic on AArch64 without `+fp16` is
+// implemented through conversion to fp32.  Beware that this comes at the
+// expense of additional instructions for casting and potential differences in
+// floating-point error accumulation.  The performance is still much better than
+// manual fp16, however.
+//
+// [ref]:
+// <https://developer.arm.com/documentation/101028/0012/13--Advanced-SIMD--Neon--intrinsics#availability-of-16-bit-floating-point-vector-interchange-types>
 
-  kernel.packet[0] = vreinterpretq_f16_f32(zip32_1.val[0]);
-  kernel.packet[1] = vreinterpretq_f16_f32(zip32_1.val[1]);
-  kernel.packet[2] = vreinterpretq_f16_f32(zip32_2.val[0]);
-  kernel.packet[3] = vreinterpretq_f16_f32(zip32_2.val[1]);
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf predux_half(const Packet8hf& a) {
+  return vcvt_f16_f32(vaddq_f32(vcvt_f32_f16(vget_low_f16(a)), vcvt_f32_f16(vget_high_f16(a))));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet4hf, 4>& kernel) {
-  EIGEN_ALIGN16 float16x4x4_t tmp_x4;
-  float16_t* tmp = (float16_t*)&kernel;
-  tmp_x4 = vld4_f16(tmp);
-
-  kernel.packet[0] = tmp_x4.val[0];
-  kernel.packet[1] = tmp_x4.val[1];
-  kernel.packet[2] = tmp_x4.val[2];
-  kernel.packet[3] = tmp_x4.val[3];
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf plset(const half& a) {
+  const float f[] = {0, 1, 2, 3};
+  float32x4_t countdown = vld1q_f32(f);
+  float32x4_t base = vaddq_f32(vcvt_f32_f16(pset1<Packet4hf>(a)), countdown);
+  return vcombine_f16(vcvt_f16_f32(base), vcvt_f16_f32(vaddq_f32(base, vdupq_n_f32(4))));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf plset(const half& a) {
+  const float f[] = {0, 1, 2, 3};
+  Packet4f countdown = vld1q_f32(f);
+  return vcvt_f16_f32(vaddq_f32(pset1<Packet4f>(a), countdown));
 }
 
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet8hf, 8>& kernel) {
-  float16x8x2_t T_1[4];
+#define EIGEN_MAKE_HALF_UNOP(name, op)                                       \
+  template <>                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf name(const Packet4hf& a) { \
+    return vcvt_f16_f32(v##op##q_f32(vcvt_f32_f16(a)));                      \
+  }                                                                          \
+  template <>                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf name(const Packet8hf& a) { \
+    return vcombine_f16(name(vget_low_f16(a)), name(vget_high_f16(a)));      \
+  }                                                                          \
+  static_assert(true, "Trailing semicolon required")
+#define EIGEN_MAKE_HALF_BINOP(name, op)                                                                    \
+  template <>                                                                                              \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf name(const Packet4hf& a, const Packet4hf& b) {           \
+    return vcvt_f16_f32(v##op##q_f32(vcvt_f32_f16(a), vcvt_f32_f16(b)));                                   \
+  }                                                                                                        \
+  template <>                                                                                              \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf name(const Packet8hf& a, const Packet8hf& b) {           \
+    return vcombine_f16(name(vget_low_f16(a), vget_low_f16(b)), name(vget_high_f16(a), vget_high_f16(b))); \
+  }                                                                                                        \
+  static_assert(true, "Trailing semicolon required")
 
-  T_1[0] = vuzpq_f16(kernel.packet[0], kernel.packet[1]);
-  T_1[1] = vuzpq_f16(kernel.packet[2], kernel.packet[3]);
-  T_1[2] = vuzpq_f16(kernel.packet[4], kernel.packet[5]);
-  T_1[3] = vuzpq_f16(kernel.packet[6], kernel.packet[7]);
+EIGEN_MAKE_HALF_BINOP(padd, add);
+EIGEN_MAKE_HALF_BINOP(psub, sub);
 
-  float16x8x2_t T_2[4];
-  T_2[0] = vuzpq_f16(T_1[0].val[0], T_1[1].val[0]);
-  T_2[1] = vuzpq_f16(T_1[0].val[1], T_1[1].val[1]);
-  T_2[2] = vuzpq_f16(T_1[2].val[0], T_1[3].val[0]);
-  T_2[3] = vuzpq_f16(T_1[2].val[1], T_1[3].val[1]);
-
-  float16x8x2_t T_3[4];
-  T_3[0] = vuzpq_f16(T_2[0].val[0], T_2[2].val[0]);
-  T_3[1] = vuzpq_f16(T_2[0].val[1], T_2[2].val[1]);
-  T_3[2] = vuzpq_f16(T_2[1].val[0], T_2[3].val[0]);
-  T_3[3] = vuzpq_f16(T_2[1].val[1], T_2[3].val[1]);
-
-  kernel.packet[0] = T_3[0].val[0];
-  kernel.packet[1] = T_3[2].val[0];
-  kernel.packet[2] = T_3[1].val[0];
-  kernel.packet[3] = T_3[3].val[0];
-  kernel.packet[4] = T_3[0].val[1];
-  kernel.packet[5] = T_3[2].val[1];
-  kernel.packet[6] = T_3[1].val[1];
-  kernel.packet[7] = T_3[3].val[1];
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pnegate(const Packet8hf& a) {
+  return vreinterpretq_f16_u16(veorq_u16(vreinterpretq_u16_f16(a), vdupq_n_u16(0x8000)));
 }
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pnegate(const Packet4hf& a) {
+  return vreinterpret_f16_u16(veor_u16(vreinterpret_u16_f16(a), vdup_n_u16(0x8000)));
+}
+
+EIGEN_MAKE_HALF_BINOP(pmul, mul);
+
+#if EIGEN_ARCH_ARM64
+EIGEN_MAKE_HALF_BINOP(pdiv, div);
+#else
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pdiv(const Packet4hf& a, const Packet4hf& b) {
+  return vcvt_f16_f32(pdiv(vcvt_f32_f16(a), vcvt_f32_f16(b)));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pdiv(const Packet8hf& a, const Packet8hf& b) {
+  return vcombine_f16(pdiv(vget_low_f16(a), vget_low_f16(b)), pdiv(vget_high_f16(a), vget_high_f16(b)));
+}
+#endif
+
+#define EIGEN_MAKE_HALF_FMA(name, op)                                                                                \
+  template <>                                                                                                        \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf name(const Packet4hf& a, const Packet4hf& b, const Packet4hf& c) { \
+    return vcvt_f16_f32(v##op##q_f32(vcvt_f32_f16(c), vcvt_f32_f16(a), vcvt_f32_f16(b)));                            \
+  }                                                                                                                  \
+  template <>                                                                                                        \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf name(const Packet8hf& a, const Packet8hf& b, const Packet8hf& c) { \
+    return vcombine_f16(name(vget_low_f16(a), vget_low_f16(b), vget_low_f16(c)),                                     \
+                        name(vget_high_f16(a), vget_high_f16(b), vget_high_f16(c)));                                 \
+  }                                                                                                                  \
+  static_assert(true, "Trailing semicolon required")
+
+EIGEN_MAKE_HALF_FMA(pmadd, fma);
+EIGEN_MAKE_HALF_FMA(pnmadd, fms);
+
+#undef EIGEN_MAKE_HALF_FMA
+
+EIGEN_MAKE_HALF_BINOP(pmin, min);
+EIGEN_MAKE_HALF_BINOP(pmax, max);
+
+#ifdef __ARM_FEATURE_NUMERIC_MAXMIN
+
+#define EIGEN_MAKE_HALF_NUMERIC_MAXMIN(name)                                                                 \
+  template <>                                                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf p##name<PropagateNumbers, Packet4hf>(const Packet4hf& a,   \
+                                                                                       const Packet4hf& b) { \
+    return vcvt_f16_f32(v##name##nmq_f32(vcvt_f32_f16(a), vcvt_f32_f16(b)));                                 \
+  }                                                                                                          \
+  template <>                                                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf p##name<PropagateNumbers, Packet8hf>(const Packet8hf& a,   \
+                                                                                       const Packet8hf& b) { \
+    return vcombine_f16(p##name<PropagateNumbers, Packet4hf>(vget_low_f16(a), vget_low_f16(b)),              \
+                        p##name<PropagateNumbers, Packet4hf>(vget_high_f16(a), vget_high_f16(b)));           \
+  }                                                                                                          \
+  static_assert(true, "Trailing semicolon required")
+
+EIGEN_MAKE_HALF_NUMERIC_MAXMIN(min);
+EIGEN_MAKE_HALF_NUMERIC_MAXMIN(max);
+
+#undef EIGEN_MAKE_HALF_NUMERIC_MAXMIN
+
+#endif
+
+#define EIGEN_MAKE_HALF_CMP(name)                                                                       \
+  template <>                                                                                           \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pcmp_##name(const Packet4hf& a, const Packet4hf& b) { \
+    return vreinterpret_f16_u16(vmovn_u32(vc##name##q_f32(vcvt_f32_f16(a), vcvt_f32_f16(b))));          \
+  }                                                                                                     \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pcmp_##name(const Packet8hf& a, const Packet8hf& b) { \
+    return vcombine_f16(pcmp_##name(vget_low_f16(a), vget_low_f16(b)),                                  \
+                        pcmp_##name(vget_high_f16(a), vget_high_f16(b)));                               \
+  }                                                                                                     \
+  static_assert(true, "Trailing semicolon required")
+
+EIGEN_MAKE_HALF_CMP(eq);
+EIGEN_MAKE_HALF_CMP(lt);
+EIGEN_MAKE_HALF_CMP(le);
+
+#undef EIGEN_MAKE_HALF_CMP
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pcmp_lt_or_nan(const Packet4hf& a, const Packet4hf& b) {
+  return vreinterpret_f16_u16(vmovn_u32(vmvnq_u32(vcgeq_f32(vcvt_f32_f16(a), vcvt_f32_f16(b)))));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pcmp_lt_or_nan(const Packet8hf& a, const Packet8hf& b) {
+  return vcombine_f16(pcmp_lt_or_nan(vget_low_f16(a), vget_low_f16(b)),
+                      pcmp_lt_or_nan(vget_high_f16(a), vget_high_f16(b)));
+}
+
+EIGEN_MAKE_HALF_UNOP(print, rndn);
+EIGEN_MAKE_HALF_UNOP(pfloor, rndm);
+EIGEN_MAKE_HALF_UNOP(pceil, rndp);
+EIGEN_MAKE_HALF_UNOP(pround, rnda);
+EIGEN_MAKE_HALF_UNOP(ptrunc, rnd);
+
+#if EIGEN_ARCH_ARM64
+EIGEN_MAKE_HALF_UNOP(psqrt, sqrt);
+#else
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf psqrt(const Packet4hf& a) {
+  return vcvt_f16_f32(psqrt(vcvt_f32_f16(a)));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf psqrt(const Packet8hf& a) {
+  return vcombine_f16(psqrt(vget_low_f16(a)), psqrt(vget_high_f16(a)));
+}
+#endif
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf pabs(const Packet8hf& a) {
+  return vreinterpretq_f16_u16(vbicq_u16(vreinterpretq_u16_f16(a), vdupq_n_u16(0x8000)));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf pabs(const Packet4hf& a) {
+  return vreinterpret_f16_u16(vbic_u16(vreinterpret_u16_f16(a), vdup_n_u16(0x8000)));
+}
+
+// NOTE: On AArch64, we can use horizontal vector reductions for `add`, `min`, and `max`.
+// However, the fallback through `predux<Packet${N}f>` is still necessary for `mul`.
+#define EIGEN_HALF_FOLD_REDUX(name, op)                                                      \
+  template <>                                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half name(const Packet4hf& a) {                      \
+    return half(name(vcvt_f32_f16(a)));                                                      \
+  }                                                                                          \
+  template <>                                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half name(const Packet8hf& a) {                      \
+    return half(name(p##op(vcvt_f32_f16(vget_low_f16(a)), vcvt_f32_f16(vget_high_f16(a))))); \
+  }                                                                                          \
+  static_assert(true, "Trailing semicolon required")
+
+#if EIGEN_ARCH_ARM64
+#define EIGEN_HALF_HORIZONTAL_REDUX(name, op)                                                                \
+  template <>                                                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half name(const Packet8hf& a) {                                      \
+    return half(v##op##vq_f32(v##op##q_f32(vcvt_f32_f16(vget_low_f16(a)), vcvt_f32_f16(vget_high_f16(a))))); \
+  }                                                                                                          \
+  template <>                                                                                                \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE half name(const Packet4hf& a) {                                      \
+    return half(v##op##vq_f32(vcvt_f32_f16(a)));                                                             \
+  }                                                                                                          \
+  static_assert(true, "Trailing semicolon required")
+#else
+#define EIGEN_HALF_HORIZONTAL_REDUX(name, op) EIGEN_HALF_FOLD_REDUX(name, op)
+#endif
+
+EIGEN_HALF_HORIZONTAL_REDUX(predux, add);
+EIGEN_HALF_FOLD_REDUX(predux_mul, mul);
+EIGEN_HALF_HORIZONTAL_REDUX(predux_min, min);
+EIGEN_HALF_HORIZONTAL_REDUX(predux_max, max);
+
+#undef EIGEN_HALF_FOLD_REDUX
+#undef EIGEN_HALF_HORIZONTAL_REDUX
+
+#undef EIGEN_MAKE_HALF_UNOP
+#undef EIGEN_MAKE_HALF_BINOP
+
 #endif  // end EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
 
+#define EIGEN_MAKE_HALF_NEG_FMA(name, base, packet)                                                      \
+  template <>                                                                                            \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet name(const packet& a, const packet& b, const packet& c) { \
+    return pnegate(base(a, b, c));                                                                       \
+  }                                                                                                      \
+  static_assert(true, "Trailing semicolon required")
+
+EIGEN_MAKE_HALF_NEG_FMA(pmsub, pnmadd, Packet8hf);
+EIGEN_MAKE_HALF_NEG_FMA(pmsub, pnmadd, Packet4hf);
+EIGEN_MAKE_HALF_NEG_FMA(pnmsub, pmadd, Packet8hf);
+EIGEN_MAKE_HALF_NEG_FMA(pnmsub, pmadd, Packet4hf);
+
+#undef EIGEN_MAKE_HALF_NEG_FMA
+
+#endif  // end EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/NEON/TypeCasting.h b/Eigen/src/Core/arch/NEON/TypeCasting.h
index 748d701..06c5def 100644
--- a/Eigen/src/Core/arch/NEON/TypeCasting.h
+++ b/Eigen/src/Core/arch/NEON/TypeCasting.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_NEON_H
 #define EIGEN_TYPE_CASTING_NEON_H
@@ -178,6 +179,42 @@
   return Packet2ul(vreinterpretq_u64_s64(a));
 }
 
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+template <>
+EIGEN_STRONG_INLINE Packet4hf preinterpret<Packet4hf, Packet4s>(const Packet4s& a) {
+  return Packet4hf(vreinterpret_f16_s16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4hf preinterpret<Packet4hf, Packet4us>(const Packet4us& a) {
+  return Packet4hf(vreinterpret_f16_u16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8hf preinterpret<Packet8hf, Packet8s>(const Packet8s& a) {
+  return Packet8hf(vreinterpretq_f16_s16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8hf preinterpret<Packet8hf, Packet8us>(const Packet8us& a) {
+  return Packet8hf(vreinterpretq_f16_u16(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4s preinterpret<Packet4s, Packet4hf>(const Packet4hf& a) {
+  return Packet4s(vreinterpret_s16_f16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8s preinterpret<Packet8s, Packet8hf>(const Packet8hf& a) {
+  return Packet8s(vreinterpretq_s16_f16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet4us preinterpret<Packet4us, Packet4hf>(const Packet4hf& a) {
+  return Packet4us(vreinterpret_u16_f16(a));
+}
+template <>
+EIGEN_STRONG_INLINE Packet8us preinterpret<Packet8us, Packet8hf>(const Packet8hf& a) {
+  return Packet8us(vreinterpretq_u16_f16(a));
+}
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
 //==============================================================================
 // pcast, SrcType = float
 //==============================================================================
@@ -227,11 +264,32 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet2ul pcast<Packet2f, Packet2ul>(const Packet2f& a) {
-  // Discard second half of input.
   return vmovl_u32(vcvt_u32_f32(a));
 }
 #endif  // EIGEN_ARCH_ARM64
 
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+template <>
+struct type_casting_traits<float, half> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 2, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet8hf pcast<Packet4f, Packet8hf>(const Packet4f& a, const Packet4f& b) {
+  return vcombine_f16(vcvt_f16_f32(a), vcvt_f16_f32(b));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pcast<Packet4f, Packet4hf>(const Packet4f& a) {
+  return vcvt_f16_f32(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4hf pcast<Packet2f, Packet4hf>(const Packet2f& a, const Packet2f& b) {
+  return vcvt_f16_f32(vcombine_f32(a, b));
+}
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
 template <>
 struct type_casting_traits<float, numext::int32_t> {
   enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
@@ -347,6 +405,26 @@
   return static_cast<Packet4uc>(pcast<Packet4f, Packet4c>(a));
 }
 
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+//==============================================================================
+// pcast, SrcType = half
+//==============================================================================
+template <>
+struct type_casting_traits<half, float> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 2 };
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet8hf, Packet4f>(const Packet8hf& a) {
+  return vcvt_f32_f16(vget_low_f16(a));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4f pcast<Packet4hf, Packet4f>(const Packet4hf& a) {
+  return vcvt_f32_f16(a);
+}
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
 //==============================================================================
 // pcast, SrcType = int8_t
 //==============================================================================
@@ -1103,11 +1181,12 @@
 #if EIGEN_ARCH_ARM64
   return vcombine_f32(vcvt_f32_f64(vcvtq_f64_s64(a)), vcvt_f32_f64(vcvtq_f64_s64(b)));
 #else
-  EIGEN_ALIGN_MAX int64_t lvals[4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2l>::alignment) int64_t lvals[4];
   pstore(lvals, a);
   pstore(lvals + 2, b);
-  EIGEN_ALIGN_MAX float fvals[4] = {static_cast<float>(lvals[0]), static_cast<float>(lvals[1]),
-                                    static_cast<float>(lvals[2]), static_cast<float>(lvals[3])};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet4f>::alignment)
+  float fvals[4] = {static_cast<float>(lvals[0]), static_cast<float>(lvals[1]), static_cast<float>(lvals[2]),
+                    static_cast<float>(lvals[3])};
   return pload<Packet4f>(fvals);
 #endif
 }
@@ -1117,9 +1196,10 @@
 #if EIGEN_ARCH_ARM64
   return vcvt_f32_f64(vcvtq_f64_s64(a));
 #else
-  EIGEN_ALIGN_MAX int64_t lvals[2];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2l>::alignment) int64_t lvals[2];
   pstore(lvals, a);
-  EIGEN_ALIGN_MAX float fvals[2] = {static_cast<float>(lvals[0]), static_cast<float>(lvals[1])};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2f>::alignment)
+  float fvals[2] = {static_cast<float>(lvals[0]), static_cast<float>(lvals[1])};
   return pload<Packet2f>(fvals);
 #endif
 }
@@ -1241,11 +1321,12 @@
 #if EIGEN_ARCH_ARM64
   return vcombine_f32(vcvt_f32_f64(vcvtq_f64_u64(a)), vcvt_f32_f64(vcvtq_f64_u64(b)));
 #else
-  EIGEN_ALIGN_MAX uint64_t uvals[4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2ul>::alignment) uint64_t uvals[4];
   pstore(uvals, a);
   pstore(uvals + 2, b);
-  EIGEN_ALIGN_MAX float fvals[4] = {static_cast<float>(uvals[0]), static_cast<float>(uvals[1]),
-                                    static_cast<float>(uvals[2]), static_cast<float>(uvals[3])};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet4f>::alignment)
+  float fvals[4] = {static_cast<float>(uvals[0]), static_cast<float>(uvals[1]), static_cast<float>(uvals[2]),
+                    static_cast<float>(uvals[3])};
   return pload<Packet4f>(fvals);
 #endif
 }
@@ -1254,9 +1335,10 @@
 #if EIGEN_ARCH_ARM64
   return vcvt_f32_f64(vcvtq_f64_u64(a));
 #else
-  EIGEN_ALIGN_MAX uint64_t uvals[2];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2ul>::alignment) uint64_t uvals[2];
   pstore(uvals, a);
-  EIGEN_ALIGN_MAX float fvals[2] = {static_cast<float>(uvals[0]), static_cast<float>(uvals[1])};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2f>::alignment)
+  float fvals[2] = {static_cast<float>(uvals[0]), static_cast<float>(uvals[1])};
   return pload<Packet2f>(fvals);
 #endif
 }
diff --git a/Eigen/src/Core/arch/NEON/UnaryFunctors.h b/Eigen/src/Core/arch/NEON/UnaryFunctors.h
index 8be5bb0..26fca3b 100644
--- a/Eigen/src/Core/arch/NEON/UnaryFunctors.h
+++ b/Eigen/src/Core/arch/NEON/UnaryFunctors.h
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_NEON_UNARY_FUNCTORS_H
 #define EIGEN_NEON_UNARY_FUNCTORS_H
@@ -15,7 +17,7 @@
 
 namespace internal {
 
-#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
 /** \internal
  * \brief Template specialization of the logistic function for Eigen::half.
  */
@@ -37,7 +39,7 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf packetOp(const Packet8hf& x) const {
     const scalar_logistic_op<float> float_op;
     return vcombine_f16(vcvt_f16_f32(float_op.packetOp(vcvt_f32_f16(vget_low_f16(x)))),
-                        vcvt_f16_f32(float_op.packetOp(vcvt_high_f32_f16(x))));
+                        vcvt_f16_f32(float_op.packetOp(vcvt_f32_f16(vget_high_f16(x)))));
   }
 };
 
@@ -48,7 +50,7 @@
     PacketAccess = functor_traits<scalar_logistic_op<float>>::PacketAccess,
   };
 };
-#endif  // EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
 
 }  // end namespace internal
 
diff --git a/Eigen/src/Core/arch/RVV10/Complex.h b/Eigen/src/Core/arch/RVV10/Complex.h
new file mode 100644
index 0000000..b30733c
--- /dev/null
+++ b/Eigen/src/Core/arch/RVV10/Complex.h
@@ -0,0 +1,886 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2025 Kseniya Zaytseva <kseniya.zaytseva@syntacore.com>
+// Copyright (C) 2026 Chip Kerchner <ckerchner@tenstorrent.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_COMPLEX_RVV10_H
+#define EIGEN_COMPLEX_RVV10_H
+
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
+/********************************* float32 ************************************/
+
+#if 0
+#if EIGEN_RISCV64_DEFAULT_LMUL == 4
+#define USE_LMUL4_ONLY
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
+#define USE_LMUL2_ONLY
+#else
+#define USE_LMUL1_ONLY
+#endif
+#endif
+
+template <typename RealPacketT, int N>
+struct complex_packet_wrapper {
+  complex_packet_wrapper() = default;
+  EIGEN_STRONG_INLINE explicit complex_packet_wrapper(const RealPacketT& a) : v(a) {}
+
+  RealPacketT v;
+};
+
+typedef complex_packet_wrapper<Packet2Xf, 29> Packet2Xcf;
+typedef complex_packet_wrapper<Packet4Xf, 30> Packet4Xcf;
+typedef complex_packet_wrapper<Packet1Xf, 31> Packet1Xcf;
+
+#if EIGEN_RISCV64_DEFAULT_LMUL == 1
+typedef Packet1Xcf PacketXcf;
+
+template <>
+struct packet_traits<std::complex<float>> : default_packet_traits {
+  typedef Packet1Xcf type;
+  typedef Packet1Xcf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = rvv_packet_size_selector<std::complex<float>, EIGEN_RISCV64_RVV_VL, 1>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSign = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 1,
+    HasArg = 0,
+    HasSetLinear = 0
+  };
+};
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
+typedef Packet2Xcf PacketXcf;
+
+template <>
+struct packet_traits<std::complex<float>> : default_packet_traits {
+  typedef Packet2Xcf type;
+#ifndef USE_LMUL2_ONLY
+  typedef Packet1Xcf half;
+#else
+  typedef Packet2Xcf half;
+#endif
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = rvv_packet_size_selector<std::complex<float>, EIGEN_RISCV64_RVV_VL, 2>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSign = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 1,
+    HasArg = 0,
+    HasSetLinear = 0
+  };
+};
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
+typedef Packet4Xcf PacketXcf;
+
+template <>
+struct packet_traits<std::complex<float>> : default_packet_traits {
+  typedef Packet4Xcf type;
+#ifndef USE_LMUL4_ONLY
+  typedef Packet2Xcf half;
+#else
+  typedef Packet4Xcf half;
+#endif
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = rvv_packet_size_selector<std::complex<float>, EIGEN_RISCV64_RVV_VL, 4>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSign = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 1,
+    HasArg = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template <>
+struct unpacket_traits<Packet2Xcf> : default_unpacket_traits {
+  typedef std::complex<float> type;
+#ifndef USE_LMUL2_ONLY
+  typedef Packet1Xcf half;
+#else
+  typedef Packet2Xcf half;
+#endif
+  typedef Packet2Xf as_real;
+  enum {
+    size = rvv_packet_size_selector<std::complex<float>, EIGEN_RISCV64_RVV_VL, 2>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<Packet4Xcf> : default_unpacket_traits {
+  typedef std::complex<float> type;
+#ifndef USE_LMUL4_ONLY
+  typedef Packet2Xcf half;
+#else
+  typedef Packet4Xcf half;
+#endif
+  typedef Packet4Xf as_real;
+  enum {
+    size = rvv_packet_size_selector<std::complex<float>, EIGEN_RISCV64_RVV_VL, 4>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<Packet1Xcf> : default_unpacket_traits {
+  typedef std::complex<float> type;
+  typedef Packet1Xcf half;
+  typedef Packet1Xf as_real;
+  enum {
+    size = rvv_packet_size_selector<std::complex<float>, EIGEN_RISCV64_RVV_VL, 1>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pcast<Packet2Xf, Packet2Xcf>(const Packet2Xf& a) {
+  return Packet2Xcf(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xf pcast<Packet2Xcf, Packet2Xf>(const Packet2Xcf& a) {
+  return a.v;
+}
+
+EIGEN_STRONG_INLINE Packet2Xul __riscv_vreinterpret_v_f32m2_u64m2(const Packet2Xf& a) {
+  return __riscv_vreinterpret_v_u32m2_u64m2(__riscv_vreinterpret_v_f32m2_u32m2(a));
+}
+
+EIGEN_STRONG_INLINE Packet2Xl __riscv_vreinterpret_v_f32m2_i64m2(const Packet2Xf& a) {
+  return __riscv_vreinterpret_v_u64m2_i64m2(__riscv_vreinterpret_v_u32m2_u64m2(__riscv_vreinterpret_v_f32m2_u32m2(a)));
+}
+
+EIGEN_STRONG_INLINE Packet2Xf __riscv_vreinterpret_v_i64m2_f32m2(const Packet2Xl& a) {
+  return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vreinterpret_v_u64m2_u32m2(__riscv_vreinterpret_v_i64m2_u64m2(a)));
+}
+
+EIGEN_STRONG_INLINE void prealimag2(const Packet2Xcf& a, Packet2Xf& real, Packet2Xf& imag) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet2Xu res = __riscv_vreinterpret_v_f32m2_u32m2(a.v);
+  real = __riscv_vreinterpret_v_u32m2_f32m2(
+      __riscv_vslide1up_vx_u32m2_tumu(mask, res, res, 0, unpacket_traits<Packet2Xi>::size));
+  imag = __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vslide1down_vx_u32m2_tumu(
+      __riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), res, res, 0, unpacket_traits<Packet2Xi>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pset1<Packet2Xcf>(const std::complex<float>& from) {
+  const numext::int64_t from2 = *reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(&from));
+  Packet2Xf res = __riscv_vreinterpret_v_i64m2_f32m2(pset1<Packet2Xl>(from2));
+  return Packet2Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf padd<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return Packet2Xcf(padd<Packet2Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf psub<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return Packet2Xcf(psub<Packet2Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pnegate(const Packet2Xcf& a) {
+  return Packet2Xcf(pnegate<Packet2Xf>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pconj(const Packet2Xcf& a) {
+  return Packet2Xcf(__riscv_vreinterpret_v_u64m2_f32m2(__riscv_vxor_vx_u64m2(
+      __riscv_vreinterpret_v_f32m2_u64m2(a.v), 0x8000000000000000ull, unpacket_traits<Packet2Xl>::size)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pcplxflip<Packet2Xcf>(const Packet2Xcf& a) {
+#ifndef __riscv_zvbb
+  Packet2Xu res = __riscv_vreinterpret_v_f32m2_u32m2(a.v);
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet2Xu data = __riscv_vslide1down_vx_u32m2(res, 0, unpacket_traits<Packet2Xi>::size);
+  Packet2Xf res2 = __riscv_vreinterpret_v_u32m2_f32m2(
+      __riscv_vslide1up_vx_u32m2_tumu(mask, data, res, 0, unpacket_traits<Packet2Xf>::size));
+  return Packet2Xcf(res2);
+#else
+  Packet2Xf res = __riscv_vreinterpret_v_u64m2_f32m2(
+      __riscv_vror_vx_u64m2(__riscv_vreinterpret_v_f32m2_u64m2(a.v), 32, unpacket_traits<Packet2Xl>::size));
+  return Packet2Xcf(res);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pmul<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  Packet2Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet2Xcf(pmadd<Packet2Xf>(imag, pcplxflip<Packet2Xcf>(pconj<Packet2Xcf>(b)).v, pmul<Packet2Xf>(real, b.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pmadd<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b, const Packet2Xcf& c) {
+  Packet2Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet2Xcf(
+      pmadd<Packet2Xf>(imag, pcplxflip<Packet2Xcf>(pconj<Packet2Xcf>(b)).v, pmadd<Packet2Xf>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pmsub<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b, const Packet2Xcf& c) {
+  Packet2Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet2Xcf(
+      pmadd<Packet2Xf>(imag, pcplxflip<Packet2Xcf>(pconj<Packet2Xcf>(b)).v, pmsub<Packet2Xf>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pcmp_eq(const Packet2Xcf& a, const Packet2Xcf& b) {
+  Packet2Xi c = __riscv_vundefined_i32m2();
+  PacketMask16 mask = __riscv_vmfeq_vv_f32m2_b16(a.v, b.v, unpacket_traits<Packet2Xf>::size);
+  Packet2Xl res = __riscv_vreinterpret_v_i32m2_i64m2(
+      __riscv_vmerge_vvm_i32m2(pzero<Packet2Xi>(c), ptrue<Packet2Xi>(c), mask, unpacket_traits<Packet2Xi>::size));
+  Packet2Xf res2 = __riscv_vreinterpret_v_i64m2_f32m2(
+      __riscv_vsra_vx_i64m2(__riscv_vand_vv_i64m2(__riscv_vsll_vx_i64m2(res, 32, unpacket_traits<Packet2Xl>::size), res,
+                                                  unpacket_traits<Packet2Xl>::size),
+                            32, unpacket_traits<Packet2Xl>::size));
+  return Packet2Xcf(res2);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pand<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return Packet2Xcf(pand<Packet2Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf por<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return Packet2Xcf(por<Packet2Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pxor<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return Packet2Xcf(pxor<Packet2Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pandnot<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return Packet2Xcf(pandnot<Packet2Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pnot<Packet2Xcf>(const Packet2Xcf& a) {
+  return Packet2Xcf(pnot<Packet2Xf>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pload<Packet2Xcf>(const std::complex<float>* from) {
+  Packet2Xf res = pload<Packet2Xf>(reinterpret_cast<const float*>(from));
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet2Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf ploadu<Packet2Xcf>(const std::complex<float>* from) {
+  Packet2Xf res = ploadu<Packet2Xf>(reinterpret_cast<const float*>(from));
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet2Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf ploaddup<Packet2Xcf>(const std::complex<float>* from) {
+  Packet2Xl res = ploaddup<Packet2Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
+  return Packet2Xcf(__riscv_vreinterpret_v_i64m2_f32m2(res));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf ploadquad<Packet2Xcf>(const std::complex<float>* from) {
+  Packet2Xl res = ploadquad<Packet2Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
+  return Packet2Xcf(__riscv_vreinterpret_v_i64m2_f32m2(res));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<float>>(std::complex<float>* to, const Packet2Xcf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE pstore<float>(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<float>>(std::complex<float>* to, const Packet2Xcf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet2Xcf
+pgather<std::complex<float>, Packet2Xcf>(const std::complex<float>* from, Index stride) {
+  return Packet2Xcf(__riscv_vreinterpret_v_i64m2_f32m2(pgather<int64_t, Packet2Xl>(
+      reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)), stride)));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<float>, Packet2Xcf>(std::complex<float>* to,
+                                                                                     const Packet2Xcf& from,
+                                                                                     Index stride) {
+  pscatter<int64_t, Packet2Xl>(reinterpret_cast<numext::int64_t*>(reinterpret_cast<void*>(to)),
+                               __riscv_vreinterpret_v_f32m2_i64m2(from.v), stride);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2Xcf>(const Packet2Xcf& a) {
+  numext::int64_t res = pfirst<Packet2Xl>(__riscv_vreinterpret_v_f32m2_i64m2(a.v));
+  return numext::bit_cast<std::complex<float>>(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf preverse(const Packet2Xcf& a) {
+  return Packet2Xcf(__riscv_vreinterpret_v_i64m2_f32m2(preverse<Packet2Xl>(__riscv_vreinterpret_v_f32m2_i64m2(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux<Packet2Xcf>(const Packet2Xcf& a) {
+  Packet2Xl res = __riscv_vreinterpret_v_f32m2_i64m2(a.v);
+  Packet2Xf real = __riscv_vreinterpret_v_i64m2_f32m2(
+      __riscv_vand_vx_i64m2(res, 0x00000000ffffffffull, unpacket_traits<Packet2Xl>::size));
+  Packet2Xf imag = __riscv_vreinterpret_v_i64m2_f32m2(
+      __riscv_vand_vx_i64m2(res, 0xffffffff00000000ull, unpacket_traits<Packet2Xl>::size));
+  return std::complex<float>(predux<Packet2Xf>(real), predux<Packet2Xf>(imag));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pdiv<Packet2Xcf>(const Packet2Xcf& a, const Packet2Xcf& b) {
+  return pdiv_complex(a, b);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet2Xcf, N>& kernel) {
+  numext::int64_t buffer[unpacket_traits<Packet2Xl>::size * N] = {0};
+  int i = 0;
+
+  for (i = 0; i < N; i++) {
+    __riscv_vsse64(&buffer[i], N * sizeof(numext::int64_t), __riscv_vreinterpret_v_f32m2_i64m2(kernel.packet[i].v),
+                   unpacket_traits<Packet2Xl>::size);
+  }
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = Packet2Xcf(__riscv_vreinterpret_v_i64m2_f32m2(
+        __riscv_vle64_v_i64m2(&buffer[i * unpacket_traits<Packet2Xl>::size], unpacket_traits<Packet2Xl>::size)));
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf psqrt<Packet2Xcf>(const Packet2Xcf& a) {
+  return psqrt_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf plog<Packet2Xcf>(const Packet2Xcf& a) {
+  return plog_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcf pexp<Packet2Xcf>(const Packet2Xcf& a) {
+  return pexp_complex(a);
+}
+
+template <typename Packet = Packet2Xcf>
+EIGEN_STRONG_INLINE Packet1Xcf predux_half(const Packet2Xcf& a) {
+  return Packet1Xcf(__riscv_vfadd_vv_f32m1(__riscv_vget_v_f32m2_f32m1(a.v, 0), __riscv_vget_v_f32m2_f32m1(a.v, 1),
+                                           unpacket_traits<Packet1Xf>::size));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2Xcf, Packet2Xf)
+
+/********************************* double ************************************/
+
+typedef complex_packet_wrapper<Packet2Xd, 32> Packet2Xcd;
+typedef complex_packet_wrapper<Packet4Xd, 33> Packet4Xcd;
+typedef complex_packet_wrapper<Packet1Xd, 34> Packet1Xcd;
+
+#if EIGEN_RISCV64_DEFAULT_LMUL == 1
+typedef Packet1Xcd PacketXcd;
+
+template <>
+struct packet_traits<std::complex<double>> : default_packet_traits {
+  typedef Packet1Xcd type;
+  typedef Packet1Xcd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = rvv_packet_size_selector<std::complex<double>, EIGEN_RISCV64_RVV_VL, 1>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSign = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 1,
+    HasArg = 0,
+    HasSetLinear = 0
+  };
+};
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
+typedef Packet2Xcd PacketXcd;
+
+template <>
+struct packet_traits<std::complex<double>> : default_packet_traits {
+  typedef Packet2Xcd type;
+#ifndef USE_LMUL2_ONLY
+  typedef Packet1Xcd half;
+#else
+  typedef Packet2Xcd half;
+#endif
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = rvv_packet_size_selector<std::complex<double>, EIGEN_RISCV64_RVV_VL, 2>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSign = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 1,
+    HasArg = 0,
+    HasSetLinear = 0
+  };
+};
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
+typedef Packet4Xcd PacketXcd;
+
+template <>
+struct packet_traits<std::complex<double>> : default_packet_traits {
+  typedef Packet4Xcd type;
+#ifndef USE_LMUL4_ONLY
+  typedef Packet2Xcd half;
+#else
+  typedef Packet4Xcd half;
+#endif
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 0,
+    size = rvv_packet_size_selector<std::complex<double>, EIGEN_RISCV64_RVV_VL, 4>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasSqrt = 1,
+    HasLog = 1,
+    HasExp = 1,
+    HasSign = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 1,
+    HasArg = 0,
+    HasSetLinear = 0
+  };
+};
+#endif
+
+template <>
+struct unpacket_traits<Packet2Xcd> : default_unpacket_traits {
+  typedef std::complex<double> type;
+#ifndef USE_LMUL2_ONLY
+  typedef Packet1Xcd half;
+#else
+  typedef Packet2Xcd half;
+#endif
+  typedef Packet2Xd as_real;
+  enum {
+    size = rvv_packet_size_selector<std::complex<double>, EIGEN_RISCV64_RVV_VL, 2>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<Packet4Xcd> : default_unpacket_traits {
+  typedef std::complex<double> type;
+#ifndef USE_LMUL4_ONLY
+  typedef Packet2Xcd half;
+#else
+  typedef Packet4Xcd half;
+#endif
+  typedef Packet4Xd as_real;
+  enum {
+    size = rvv_packet_size_selector<std::complex<double>, EIGEN_RISCV64_RVV_VL, 4>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<Packet1Xcd> : default_unpacket_traits {
+  typedef std::complex<double> type;
+  typedef Packet1Xcd half;
+  typedef Packet1Xd as_real;
+  enum {
+    size = rvv_packet_size_selector<std::complex<double>, EIGEN_RISCV64_RVV_VL, 1>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pcast<Packet2Xd, Packet2Xcd>(const Packet2Xd& a) {
+  return Packet2Xcd(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xd pcast<Packet2Xcd, Packet2Xd>(const Packet2Xcd& a) {
+  return a.v;
+}
+
+EIGEN_STRONG_INLINE void prealimag2(const Packet2Xcd& a, Packet2Xd& real, Packet2Xd& imag) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  real = __riscv_vfslide1up_vf_f64m2_tumu(mask, a.v, a.v, 0.0, unpacket_traits<Packet2Xd>::size);
+  imag = __riscv_vfslide1down_vf_f64m2_tumu(__riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size), a.v, a.v, 0.0,
+                                            unpacket_traits<Packet2Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pset1<Packet2Xcd>(const std::complex<double>& from) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet2Xd res = __riscv_vmerge_vvm_f64m2(pset1<Packet2Xd>(from.real()), pset1<Packet2Xd>(from.imag()), mask,
+                                           unpacket_traits<Packet2Xd>::size);
+  return Packet2Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd padd<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return Packet2Xcd(padd<Packet2Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd psub<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return Packet2Xcd(psub<Packet2Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pnegate(const Packet2Xcd& a) {
+  return Packet2Xcd(pnegate<Packet2Xd>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pconj(const Packet2Xcd& a) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  return Packet2Xcd(__riscv_vfsgnjn_vv_f64m2_tumu(mask, a.v, a.v, a.v, unpacket_traits<Packet2Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pcplxflip<Packet2Xcd>(const Packet2Xcd& a) {
+  Packet2Xul res = __riscv_vreinterpret_v_f64m2_u64m2(a.v);
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet2Xul data = __riscv_vslide1down_vx_u64m2(res, 0, unpacket_traits<Packet2Xl>::size);
+  Packet2Xd res2 = __riscv_vreinterpret_v_u64m2_f64m2(
+      __riscv_vslide1up_vx_u64m2_tumu(mask, data, res, 0, unpacket_traits<Packet2Xl>::size));
+  return Packet2Xcd(res2);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pmul<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  Packet2Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet2Xcd(pmadd<Packet2Xd>(imag, pcplxflip<Packet2Xcd>(pconj<Packet2Xcd>(b)).v, pmul<Packet2Xd>(real, b.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pmadd<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b, const Packet2Xcd& c) {
+  Packet2Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet2Xcd(
+      pmadd<Packet2Xd>(imag, pcplxflip<Packet2Xcd>(pconj<Packet2Xcd>(b)).v, pmadd<Packet2Xd>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pmsub<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b, const Packet2Xcd& c) {
+  Packet2Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet2Xcd(
+      pmadd<Packet2Xd>(imag, pcplxflip<Packet2Xcd>(pconj<Packet2Xcd>(b)).v, pmsub<Packet2Xd>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pcmp_eq(const Packet2Xcd& a, const Packet2Xcd& b) {
+  Packet2Xl c = __riscv_vundefined_i64m2();
+  Packet1Xu mask =
+      __riscv_vreinterpret_v_b32_u32m1(__riscv_vmfeq_vv_f64m2_b32(a.v, b.v, unpacket_traits<Packet2Xd>::size));
+  Packet1Xu mask_r = __riscv_vsrl_vx_u32m1(__riscv_vand_vx_u32m1(mask, 0xaaaaaaaa, unpacket_traits<Packet1Xi>::size), 1,
+                                           unpacket_traits<Packet1Xi>::size);
+  mask = __riscv_vand_vv_u32m1(mask, mask_r, unpacket_traits<Packet1Xi>::size);
+  mask = __riscv_vor_vv_u32m1(__riscv_vsll_vx_u32m1(mask, 1, unpacket_traits<Packet1Xi>::size), mask,
+                              unpacket_traits<Packet1Xi>::size);
+  Packet2Xd res = __riscv_vreinterpret_v_i64m2_f64m2(__riscv_vmerge_vvm_i64m2(pzero<Packet2Xl>(c), ptrue<Packet2Xl>(c),
+                                                                              __riscv_vreinterpret_v_u32m1_b32(mask),
+                                                                              unpacket_traits<Packet2Xl>::size));
+  return Packet2Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pand<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return Packet2Xcd(pand<Packet2Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd por<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return Packet2Xcd(por<Packet2Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pxor<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return Packet2Xcd(pxor<Packet2Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pandnot<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return Packet2Xcd(pandnot<Packet2Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pnot<Packet2Xcd>(const Packet2Xcd& a) {
+  return Packet2Xcd(pnot<Packet2Xd>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pload<Packet2Xcd>(const std::complex<double>* from) {
+  Packet2Xd res = pload<Packet2Xd>(reinterpret_cast<const double*>(from));
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet2Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd ploadu<Packet2Xcd>(const std::complex<double>* from) {
+  Packet2Xd res = ploadu<Packet2Xd>(reinterpret_cast<const double*>(from));
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet2Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd ploaddup<Packet2Xcd>(const std::complex<double>* from) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
+  Packet2Xul idx1 =
+      __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
+  Packet2Xul idx2 = __riscv_vxor_vx_u64m2_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet2Xl>::size);
+  return Packet2Xcd(__riscv_vrgather_vv_f64m2(
+      __riscv_vlmul_ext_v_f64m1_f64m2(pload<Packet1Xd>(reinterpret_cast<const double*>(from))), idx2,
+      unpacket_traits<Packet2Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd ploadquad<Packet2Xcd>(const std::complex<double>* from) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x5a), unpacket_traits<Packet1Xc>::size));
+  Packet2Xul idx1 =
+      __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 2, unpacket_traits<Packet2Xd>::size);
+  Packet2Xul idx2 = __riscv_vxor_vx_u64m2_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet2Xl>::size);
+  return Packet2Xcd(__riscv_vrgather_vv_f64m2(
+      __riscv_vlmul_ext_v_f64m1_f64m2(pload<Packet1Xd>(reinterpret_cast<const double*>(from))), idx2,
+      unpacket_traits<Packet2Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const Packet2Xcd& from) {
+  EIGEN_DEBUG_ALIGNED_STORE pstore<double>(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<double>>(std::complex<double>* to, const Packet2Xcd& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet2Xcd
+pgather<std::complex<double>, Packet2Xcd>(const std::complex<double>* from, Index stride) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+  const double* from2 = reinterpret_cast<const double*>(from);
+  Packet2Xd res = __riscv_vundefined_f64m2();
+  res = __riscv_vlse64_v_f64m2_tumu(mask, res, &from2[0 - (0 * stride)], stride * sizeof(double),
+                                    unpacket_traits<Packet2Xd>::size);
+  res =
+      __riscv_vlse64_v_f64m2_tumu(__riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size), res,
+                                  &from2[1 - (1 * stride)], stride * sizeof(double), unpacket_traits<Packet2Xd>::size);
+  return Packet2Xcd(res);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<double>, Packet2Xcd>(std::complex<double>* to,
+                                                                                      const Packet2Xcd& from,
+                                                                                      Index stride) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+  double* to2 = reinterpret_cast<double*>(to);
+  __riscv_vsse64_v_f64m2_m(mask, &to2[0 - (0 * stride)], stride * sizeof(double), from.v,
+                           unpacket_traits<Packet2Xd>::size);
+  __riscv_vsse64_v_f64m2_m(__riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size), &to2[1 - (1 * stride)],
+                           stride * sizeof(double), from.v, unpacket_traits<Packet2Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet2Xcd>(const Packet2Xcd& a) {
+  double real = pfirst<Packet2Xd>(a.v);
+  double imag = pfirst<Packet2Xd>(__riscv_vfslide1down_vf_f64m2(a.v, 0.0, unpacket_traits<Packet2Xd>::size));
+  return std::complex<double>(real, imag);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd preverse(const Packet2Xcd& a) {
+  Packet2Xul idx = __riscv_vxor_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xl>::size),
+                                         unpacket_traits<Packet2Xl>::size - 2, unpacket_traits<Packet2Xl>::size);
+  Packet2Xd res = __riscv_vrgather_vv_f64m2(a.v, idx, unpacket_traits<Packet2Xd>::size);
+  return Packet2Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux<Packet2Xcd>(const Packet2Xcd& a) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet2Xl res = __riscv_vreinterpret_v_f64m2_i64m2(a.v);
+  Packet2Xd real = __riscv_vreinterpret_v_i64m2_f64m2(
+      __riscv_vand_vx_i64m2_tumu(mask, res, res, 0, unpacket_traits<Packet2Xl>::size));
+  Packet2Xd imag = __riscv_vreinterpret_v_i64m2_f64m2(__riscv_vand_vx_i64m2_tumu(
+      __riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size), res, res, 0, unpacket_traits<Packet2Xl>::size));
+  return std::complex<double>(predux<Packet2Xd>(real), predux<Packet2Xd>(imag));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pdiv<Packet2Xcd>(const Packet2Xcd& a, const Packet2Xcd& b) {
+  return pdiv_complex(a, b);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet2Xcd, N>& kernel) {
+  double buffer[unpacket_traits<Packet2Xd>::size * N];
+  int i = 0;
+
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+
+  for (i = 0; i < N; i++) {
+    __riscv_vsse64_v_f64m2_m(mask, &buffer[(i * 2) - (0 * N) + 0], N * sizeof(double), kernel.packet[i].v,
+                             unpacket_traits<Packet2Xd>::size);
+    __riscv_vsse64_v_f64m2_m(__riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size),
+                             &buffer[(i * 2) - (1 * N) + 1], N * sizeof(double), kernel.packet[i].v,
+                             unpacket_traits<Packet2Xd>::size);
+  }
+
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = Packet2Xcd(
+        __riscv_vle64_v_f64m2(&buffer[i * unpacket_traits<Packet2Xd>::size], unpacket_traits<Packet2Xd>::size));
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd psqrt<Packet2Xcd>(const Packet2Xcd& a) {
+  return psqrt_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd plog<Packet2Xcd>(const Packet2Xcd& a) {
+  return plog_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xcd pexp<Packet2Xcd>(const Packet2Xcd& a) {
+  return pexp_complex(a);
+}
+
+template <typename Packet = Packet2Xcd>
+EIGEN_STRONG_INLINE Packet1Xcd predux_half(const Packet2Xcd& a) {
+  return Packet1Xcd(__riscv_vfadd_vv_f64m1(__riscv_vget_v_f64m2_f64m1(a.v, 0), __riscv_vget_v_f64m2_f64m1(a.v, 1),
+                                           unpacket_traits<Packet1Xd>::size));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet2Xcd, Packet2Xd)
+
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLEX_RVV10_H
diff --git a/Eigen/src/Core/arch/RVV10/Complex2.h b/Eigen/src/Core/arch/RVV10/Complex2.h
new file mode 100644
index 0000000..11692bf
--- /dev/null
+++ b/Eigen/src/Core/arch/RVV10/Complex2.h
@@ -0,0 +1,1121 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Chip Kerchner <ckerchner@tenstorrent.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_COMPLEX2_RVV10_H
+#define EIGEN_COMPLEX2_RVV10_H
+
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/********************************* float32 ************************************/
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pcast<Packet4Xf, Packet4Xcf>(const Packet4Xf& a) {
+  return Packet4Xcf(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xf pcast<Packet4Xcf, Packet4Xf>(const Packet4Xcf& a) {
+  return a.v;
+}
+
+EIGEN_STRONG_INLINE Packet4Xul __riscv_vreinterpret_v_f32m4_u64m4(const Packet4Xf& a) {
+  return __riscv_vreinterpret_v_u32m4_u64m4(__riscv_vreinterpret_v_f32m4_u32m4(a));
+}
+
+EIGEN_STRONG_INLINE Packet4Xl __riscv_vreinterpret_v_f32m4_i64m4(const Packet4Xf& a) {
+  return __riscv_vreinterpret_v_u64m4_i64m4(__riscv_vreinterpret_v_u32m4_u64m4(__riscv_vreinterpret_v_f32m4_u32m4(a)));
+}
+
+EIGEN_STRONG_INLINE Packet4Xf __riscv_vreinterpret_v_i64m4_f32m4(const Packet4Xl& a) {
+  return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vreinterpret_v_u64m4_u32m4(__riscv_vreinterpret_v_i64m4_u64m4(a)));
+}
+
+EIGEN_STRONG_INLINE Packet2Xd __riscv_vreinterpret_v_f32m2_f64m2(const Packet2Xf& a) {
+  return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vreinterpret_v_u32m2_u64m2(__riscv_vreinterpret_v_f32m2_u32m2(a)));
+}
+
+EIGEN_STRONG_INLINE Packet4Xf __riscv_vreinterpret_v_f64m4_f32m4(const Packet4Xd& a) {
+  return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vreinterpret_v_u64m4_u32m4(__riscv_vreinterpret_v_f64m4_u64m4(a)));
+}
+
+EIGEN_STRONG_INLINE void prealimag2(const Packet4Xcf& a, Packet4Xf& real, Packet4Xf& imag) {
+  const PacketMask8 mask =
+      __riscv_vreinterpret_v_i8m1_b8(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet4Xu res = __riscv_vreinterpret_v_f32m4_u32m4(a.v);
+  real = __riscv_vreinterpret_v_u32m4_f32m4(
+      __riscv_vslide1up_vx_u32m4_tumu(mask, res, res, 0, unpacket_traits<Packet4Xi>::size));
+  imag = __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vslide1down_vx_u32m4_tumu(
+      __riscv_vmnot_m_b8(mask, unpacket_traits<Packet1Xc>::size), res, res, 0, unpacket_traits<Packet4Xi>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pset1<Packet4Xcf>(const std::complex<float>& from) {
+  const numext::int64_t from2 = numext::bit_cast<numext::int64_t>(from);
+  Packet4Xf res = __riscv_vreinterpret_v_i64m4_f32m4(pset1<Packet4Xl>(from2));
+  return Packet4Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf padd<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return Packet4Xcf(padd<Packet4Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf psub<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return Packet4Xcf(psub<Packet4Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pnegate(const Packet4Xcf& a) {
+  return Packet4Xcf(pnegate<Packet4Xf>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pconj(const Packet4Xcf& a) {
+  return Packet4Xcf(__riscv_vreinterpret_v_u64m4_f32m4(__riscv_vxor_vx_u64m4(
+      __riscv_vreinterpret_v_f32m4_u64m4(a.v), 0x8000000000000000ull, unpacket_traits<Packet4Xl>::size)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pcplxflip<Packet4Xcf>(const Packet4Xcf& a) {
+#ifndef __riscv_zvbb
+  Packet4Xu res = __riscv_vreinterpret_v_f32m4_u32m4(a.v);
+  const PacketMask8 mask =
+      __riscv_vreinterpret_v_i8m1_b8(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet4Xu data = __riscv_vslide1down_vx_u32m4(res, 0, unpacket_traits<Packet4Xi>::size);
+  Packet4Xf res2 = __riscv_vreinterpret_v_u32m4_f32m4(
+      __riscv_vslide1up_vx_u32m4_tumu(mask, data, res, 0, unpacket_traits<Packet4Xi>::size));
+  return Packet4Xcf(res2);
+#else
+  Packet4Xf res = __riscv_vreinterpret_v_u64m4_f32m4(
+      __riscv_vror_vx_u64m4(__riscv_vreinterpret_v_f32m4_u64m4(a.v), 32, unpacket_traits<Packet4Xl>::size));
+  return Packet4Xcf(res);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pmul<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  Packet4Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet4Xcf(pmadd<Packet4Xf>(imag, pcplxflip<Packet4Xcf>(pconj<Packet4Xcf>(b)).v, pmul<Packet4Xf>(real, b.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pmadd<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b, const Packet4Xcf& c) {
+  Packet4Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet4Xcf(
+      pmadd<Packet4Xf>(imag, pcplxflip<Packet4Xcf>(pconj<Packet4Xcf>(b)).v, pmadd<Packet4Xf>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pmsub<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b, const Packet4Xcf& c) {
+  Packet4Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet4Xcf(
+      pmadd<Packet4Xf>(imag, pcplxflip<Packet4Xcf>(pconj<Packet4Xcf>(b)).v, pmsub<Packet4Xf>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pcmp_eq(const Packet4Xcf& a, const Packet4Xcf& b) {
+  Packet4Xi c = __riscv_vundefined_i32m4();
+  PacketMask8 mask = __riscv_vmfeq_vv_f32m4_b8(a.v, b.v, unpacket_traits<Packet4Xf>::size);
+  Packet4Xl res = __riscv_vreinterpret_v_i32m4_i64m4(
+      __riscv_vmerge_vvm_i32m4(pzero<Packet4Xi>(c), ptrue<Packet4Xi>(c), mask, unpacket_traits<Packet4Xi>::size));
+  Packet4Xf res2 = __riscv_vreinterpret_v_i64m4_f32m4(
+      __riscv_vsra_vx_i64m4(__riscv_vand_vv_i64m4(__riscv_vsll_vx_i64m4(res, 32, unpacket_traits<Packet4Xl>::size), res,
+                                                  unpacket_traits<Packet4Xl>::size),
+                            32, unpacket_traits<Packet4Xl>::size));
+  return Packet4Xcf(res2);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pand<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return Packet4Xcf(pand<Packet4Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf por<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return Packet4Xcf(por<Packet4Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pxor<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return Packet4Xcf(pxor<Packet4Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pandnot<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return Packet4Xcf(pandnot<Packet4Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pnot<Packet4Xcf>(const Packet4Xcf& a) {
+  return Packet4Xcf(pnot<Packet4Xf>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pload<Packet4Xcf>(const std::complex<float>* from) {
+  Packet4Xf res = pload<Packet4Xf>(reinterpret_cast<const float*>(from));
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet4Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf ploadu<Packet4Xcf>(const std::complex<float>* from) {
+  Packet4Xf res = ploadu<Packet4Xf>(reinterpret_cast<const float*>(from));
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet4Xcf(res);
+}
+
+EIGEN_STRONG_INLINE Packet4Xcf pdup(const Packet2Xcf& a) {
+  Packet4Xul idx =
+      __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
+  return Packet4Xcf(__riscv_vreinterpret_v_f64m4_f32m4(
+      __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(__riscv_vreinterpret_v_f32m2_f64m2(a.v)), idx,
+                                unpacket_traits<Packet4Xd>::size)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf ploaddup<Packet4Xcf>(const std::complex<float>* from) {
+  Packet4Xl res = ploaddup<Packet4Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
+  return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(res));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf ploadquad<Packet4Xcf>(const std::complex<float>* from) {
+  Packet4Xl res = ploadquad<Packet4Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
+  return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(res));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<float>>(std::complex<float>* to, const Packet4Xcf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE pstore<float>(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<float>>(std::complex<float>* to, const Packet4Xcf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4Xcf
+pgather<std::complex<float>, Packet4Xcf>(const std::complex<float>* from, Index stride) {
+  return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(pgather<int64_t, Packet4Xl>(
+      reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)), stride)));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<float>, Packet4Xcf>(std::complex<float>* to,
+                                                                                     const Packet4Xcf& from,
+                                                                                     Index stride) {
+  pscatter<int64_t, Packet4Xl>(reinterpret_cast<numext::int64_t*>(reinterpret_cast<void*>(to)),
+                               __riscv_vreinterpret_v_f32m4_i64m4(from.v), stride);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet4Xcf>(const Packet4Xcf& a) {
+  numext::int64_t res = pfirst<Packet4Xl>(__riscv_vreinterpret_v_f32m4_i64m4(a.v));
+  return numext::bit_cast<std::complex<float>>(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf preverse(const Packet4Xcf& a) {
+  return Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(preverse<Packet4Xl>(__riscv_vreinterpret_v_f32m4_i64m4(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux<Packet4Xcf>(const Packet4Xcf& a) {
+  Packet4Xl res = __riscv_vreinterpret_v_f32m4_i64m4(a.v);
+  Packet4Xf real = __riscv_vreinterpret_v_i64m4_f32m4(
+      __riscv_vand_vx_i64m4(res, 0x00000000ffffffffull, unpacket_traits<Packet4Xl>::size));
+  Packet4Xf imag = __riscv_vreinterpret_v_i64m4_f32m4(
+      __riscv_vand_vx_i64m4(res, 0xffffffff00000000ull, unpacket_traits<Packet4Xl>::size));
+  return std::complex<float>(predux<Packet4Xf>(real), predux<Packet4Xf>(imag));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pdiv<Packet4Xcf>(const Packet4Xcf& a, const Packet4Xcf& b) {
+  return pdiv_complex(a, b);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet4Xcf, N>& kernel) {
+  numext::int64_t buffer[unpacket_traits<Packet4Xl>::size * N] = {0};
+  int i = 0;
+
+  for (i = 0; i < N; i++) {
+    __riscv_vsse64(&buffer[i], N * sizeof(numext::int64_t), __riscv_vreinterpret_v_f32m4_i64m4(kernel.packet[i].v),
+                   unpacket_traits<Packet4Xl>::size);
+  }
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = Packet4Xcf(__riscv_vreinterpret_v_i64m4_f32m4(
+        __riscv_vle64_v_i64m4(&buffer[i * unpacket_traits<Packet4Xl>::size], unpacket_traits<Packet4Xl>::size)));
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf psqrt<Packet4Xcf>(const Packet4Xcf& a) {
+  return psqrt_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf plog<Packet4Xcf>(const Packet4Xcf& a) {
+  return plog_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcf pexp<Packet4Xcf>(const Packet4Xcf& a) {
+  return pexp_complex(a);
+}
+
+template <typename Packet = Packet4Xcf>
+EIGEN_STRONG_INLINE Packet2Xcf predux_half(const Packet4Xcf& a) {
+  return Packet2Xcf(__riscv_vfadd_vv_f32m2(__riscv_vget_v_f32m4_f32m2(a.v, 0), __riscv_vget_v_f32m4_f32m2(a.v, 1),
+                                           unpacket_traits<Packet2Xf>::size));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4Xcf, Packet4Xf)
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pcast<Packet1Xf, Packet1Xcf>(const Packet1Xf& a) {
+  return Packet1Xcf(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xf pcast<Packet1Xcf, Packet1Xf>(const Packet1Xcf& a) {
+  return a.v;
+}
+
+EIGEN_STRONG_INLINE Packet1Xul __riscv_vreinterpret_v_f32m1_u64m1(const Packet1Xf& a) {
+  return __riscv_vreinterpret_v_u32m1_u64m1(__riscv_vreinterpret_v_f32m1_u32m1(a));
+}
+
+EIGEN_STRONG_INLINE Packet1Xl __riscv_vreinterpret_v_f32m1_i64m1(const Packet1Xf& a) {
+  return __riscv_vreinterpret_v_u64m1_i64m1(__riscv_vreinterpret_v_u32m1_u64m1(__riscv_vreinterpret_v_f32m1_u32m1(a)));
+}
+
+EIGEN_STRONG_INLINE Packet1Xf __riscv_vreinterpret_v_i64m1_f32m1(const Packet1Xl& a) {
+  return __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vreinterpret_v_u64m1_u32m1(__riscv_vreinterpret_v_i64m1_u64m1(a)));
+}
+
+EIGEN_STRONG_INLINE Packet1Xd __riscv_vreinterpret_v_f32m1_f64m1(const Packet1Xf& a) {
+  return __riscv_vreinterpret_v_u64m1_f64m1(__riscv_vreinterpret_v_u32m1_u64m1(__riscv_vreinterpret_v_f32m1_u32m1(a)));
+}
+
+EIGEN_STRONG_INLINE Packet2Xf __riscv_vreinterpret_v_f64m2_f32m2(const Packet2Xd& a) {
+  return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vreinterpret_v_u64m2_u32m2(__riscv_vreinterpret_v_f64m2_u64m2(a)));
+}
+
+EIGEN_STRONG_INLINE void prealimag2(const Packet1Xcf& a, Packet1Xf& real, Packet1Xf& imag) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet1Xu res = __riscv_vreinterpret_v_f32m1_u32m1(a.v);
+  real = __riscv_vreinterpret_v_u32m1_f32m1(
+      __riscv_vslide1up_vx_u32m1_tumu(mask, res, res, 0, unpacket_traits<Packet1Xi>::size));
+  imag = __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vslide1down_vx_u32m1_tumu(
+      __riscv_vmnot_m_b32(mask, unpacket_traits<Packet1Xi>::size), res, res, 0, unpacket_traits<Packet1Xi>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pset1<Packet1Xcf>(const std::complex<float>& from) {
+  const numext::int64_t from2 = numext::bit_cast<numext::int64_t>(from);
+  Packet1Xf res = __riscv_vreinterpret_v_i64m1_f32m1(pset1<Packet1Xl>(from2));
+  return Packet1Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf padd<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return Packet1Xcf(padd<Packet1Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf psub<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return Packet1Xcf(psub<Packet1Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pnegate(const Packet1Xcf& a) {
+  return Packet1Xcf(pnegate<Packet1Xf>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pconj(const Packet1Xcf& a) {
+  return Packet1Xcf(__riscv_vreinterpret_v_u64m1_f32m1(__riscv_vxor_vx_u64m1(
+      __riscv_vreinterpret_v_f32m1_u64m1(a.v), 0x8000000000000000ull, unpacket_traits<Packet1Xl>::size)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pcplxflip<Packet1Xcf>(const Packet1Xcf& a) {
+#ifndef __riscv_zvbb
+  Packet1Xu res = __riscv_vreinterpret_v_f32m1_u32m1(a.v);
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet1Xu data = __riscv_vslide1down_vx_u32m1(res, 0, unpacket_traits<Packet1Xi>::size);
+  Packet1Xf res2 = __riscv_vreinterpret_v_u32m1_f32m1(
+      __riscv_vslide1up_vx_u32m1_tumu(mask, data, res, 0, unpacket_traits<Packet1Xf>::size));
+  return Packet1Xcf(res2);
+#else
+  Packet1Xf res = __riscv_vreinterpret_v_u64m1_f32m1(
+      __riscv_vror_vx_u64m1(__riscv_vreinterpret_v_f32m1_u64m1(a.v), 32, unpacket_traits<Packet1Xl>::size));
+  return Packet1Xcf(res);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pmul<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  Packet1Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet1Xcf(pmadd<Packet1Xf>(imag, pcplxflip<Packet1Xcf>(pconj<Packet1Xcf>(b)).v, pmul<Packet1Xf>(real, b.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pmadd<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b, const Packet1Xcf& c) {
+  Packet1Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet1Xcf(
+      pmadd<Packet1Xf>(imag, pcplxflip<Packet1Xcf>(pconj<Packet1Xcf>(b)).v, pmadd<Packet1Xf>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pmsub<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b, const Packet1Xcf& c) {
+  Packet1Xf real, imag;
+  prealimag2(a, real, imag);
+  return Packet1Xcf(
+      pmadd<Packet1Xf>(imag, pcplxflip<Packet1Xcf>(pconj<Packet1Xcf>(b)).v, pmsub<Packet1Xf>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pcmp_eq(const Packet1Xcf& a, const Packet1Xcf& b) {
+  Packet1Xi c = __riscv_vundefined_i32m1();
+  PacketMask32 mask = __riscv_vmfeq_vv_f32m1_b32(a.v, b.v, unpacket_traits<Packet1Xf>::size);
+  Packet1Xl res = __riscv_vreinterpret_v_i32m1_i64m1(
+      __riscv_vmerge_vvm_i32m1(pzero<Packet1Xi>(c), ptrue<Packet1Xi>(c), mask, unpacket_traits<Packet1Xi>::size));
+  Packet1Xf res2 = __riscv_vreinterpret_v_i64m1_f32m1(
+      __riscv_vsra_vx_i64m1(__riscv_vand_vv_i64m1(__riscv_vsll_vx_i64m1(res, 32, unpacket_traits<Packet1Xl>::size), res,
+                                                  unpacket_traits<Packet1Xl>::size),
+                            32, unpacket_traits<Packet1Xl>::size));
+  return Packet1Xcf(res2);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pand<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return Packet1Xcf(pand<Packet1Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf por<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return Packet1Xcf(por<Packet1Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pxor<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return Packet1Xcf(pxor<Packet1Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pandnot<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return Packet1Xcf(pandnot<Packet1Xf>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pnot<Packet1Xcf>(const Packet1Xcf& a) {
+  return Packet1Xcf(pnot<Packet1Xf>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pload<Packet1Xcf>(const std::complex<float>* from) {
+  Packet1Xf res = pload<Packet1Xf>(reinterpret_cast<const float*>(from));
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet1Xcf(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf ploadu<Packet1Xcf>(const std::complex<float>* from) {
+  Packet1Xf res = ploadu<Packet1Xf>(reinterpret_cast<const float*>(from));
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet1Xcf(res);
+}
+
+EIGEN_STRONG_INLINE Packet2Xcf pdup(const Packet1Xcf& a) {
+  Packet2Xul idx =
+      __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
+  return Packet2Xcf(__riscv_vreinterpret_v_f64m2_f32m2(
+      __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(__riscv_vreinterpret_v_f32m1_f64m1(a.v)), idx,
+                                unpacket_traits<Packet2Xd>::size)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf ploaddup<Packet1Xcf>(const std::complex<float>* from) {
+  Packet1Xl res = ploaddup<Packet1Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
+  return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(res));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf ploadquad<Packet1Xcf>(const std::complex<float>* from) {
+  Packet1Xl res = ploadquad<Packet1Xl>(reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)));
+  return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(res));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<float>>(std::complex<float>* to, const Packet1Xcf& from) {
+  EIGEN_DEBUG_ALIGNED_STORE pstore<float>(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<float>>(std::complex<float>* to, const Packet1Xcf& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<float>(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet1Xcf
+pgather<std::complex<float>, Packet1Xcf>(const std::complex<float>* from, Index stride) {
+  return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(pgather<int64_t, Packet1Xl>(
+      reinterpret_cast<const numext::int64_t*>(reinterpret_cast<const void*>(from)), stride)));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<float>, Packet1Xcf>(std::complex<float>* to,
+                                                                                     const Packet1Xcf& from,
+                                                                                     Index stride) {
+  pscatter<int64_t, Packet1Xl>(reinterpret_cast<numext::int64_t*>(reinterpret_cast<void*>(to)),
+                               __riscv_vreinterpret_v_f32m1_i64m1(from.v), stride);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet1Xcf>(const Packet1Xcf& a) {
+  numext::int64_t res = pfirst<Packet1Xl>(__riscv_vreinterpret_v_f32m1_i64m1(a.v));
+  return numext::bit_cast<std::complex<float>>(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf preverse(const Packet1Xcf& a) {
+  return Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(preverse<Packet1Xl>(__riscv_vreinterpret_v_f32m1_i64m1(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux<Packet1Xcf>(const Packet1Xcf& a) {
+  Packet1Xl res = __riscv_vreinterpret_v_f32m1_i64m1(a.v);
+  Packet1Xf real = __riscv_vreinterpret_v_i64m1_f32m1(
+      __riscv_vand_vx_i64m1(res, 0x00000000ffffffffull, unpacket_traits<Packet1Xl>::size));
+  Packet1Xf imag = __riscv_vreinterpret_v_i64m1_f32m1(
+      __riscv_vand_vx_i64m1(res, 0xffffffff00000000ull, unpacket_traits<Packet1Xl>::size));
+  return std::complex<float>(predux<Packet1Xf>(real), predux<Packet1Xf>(imag));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pdiv<Packet1Xcf>(const Packet1Xcf& a, const Packet1Xcf& b) {
+  return pdiv_complex(a, b);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet1Xcf, N>& kernel) {
+  numext::int64_t buffer[unpacket_traits<Packet1Xl>::size * N] = {0};
+  int i = 0;
+
+  for (i = 0; i < N; i++) {
+    __riscv_vsse64(&buffer[i], N * sizeof(numext::int64_t), __riscv_vreinterpret_v_f32m1_i64m1(kernel.packet[i].v),
+                   unpacket_traits<Packet1Xl>::size);
+  }
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = Packet1Xcf(__riscv_vreinterpret_v_i64m1_f32m1(
+        __riscv_vle64_v_i64m1(&buffer[i * unpacket_traits<Packet1Xl>::size], unpacket_traits<Packet1Xl>::size)));
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf psqrt<Packet1Xcf>(const Packet1Xcf& a) {
+  return psqrt_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf plog<Packet1Xcf>(const Packet1Xcf& a) {
+  return plog_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcf pexp<Packet1Xcf>(const Packet1Xcf& a) {
+  return pexp_complex(a);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1Xcf, Packet1Xf)
+
+/********************************* double ************************************/
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pcast<Packet4Xd, Packet4Xcd>(const Packet4Xd& a) {
+  return Packet4Xcd(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xd pcast<Packet4Xcd, Packet4Xd>(const Packet4Xcd& a) {
+  return a.v;
+}
+
+EIGEN_STRONG_INLINE void prealimag2(const Packet4Xcd& a, Packet4Xd& real, Packet4Xd& imag) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  real = __riscv_vfslide1up_vf_f64m4_tumu(mask, a.v, a.v, 0.0, unpacket_traits<Packet4Xd>::size);
+  imag = __riscv_vfslide1down_vf_f64m4_tumu(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), a.v, a.v, 0.0,
+                                            unpacket_traits<Packet4Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pset1<Packet4Xcd>(const std::complex<double>& from) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet4Xd res = __riscv_vmerge_vvm_f64m4(pset1<Packet4Xd>(from.real()), pset1<Packet4Xd>(from.imag()), mask,
+                                           unpacket_traits<Packet4Xd>::size);
+  return Packet4Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd padd<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return Packet4Xcd(padd<Packet4Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd psub<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return Packet4Xcd(psub<Packet4Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pnegate(const Packet4Xcd& a) {
+  return Packet4Xcd(pnegate<Packet4Xd>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pconj(const Packet4Xcd& a) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  return Packet4Xcd(__riscv_vfsgnjn_vv_f64m4_tumu(mask, a.v, a.v, a.v, unpacket_traits<Packet4Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pcplxflip<Packet4Xcd>(const Packet4Xcd& a) {
+  Packet4Xul res = __riscv_vreinterpret_v_f64m4_u64m4(a.v);
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet4Xul data = __riscv_vslide1down_vx_u64m4(res, 0, unpacket_traits<Packet4Xl>::size);
+  Packet4Xd res2 = __riscv_vreinterpret_v_u64m4_f64m4(
+      __riscv_vslide1up_vx_u64m4_tumu(mask, data, res, 0, unpacket_traits<Packet4Xl>::size));
+  return Packet4Xcd(res2);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pmul<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  Packet4Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet4Xcd(pmadd<Packet4Xd>(imag, pcplxflip<Packet4Xcd>(pconj<Packet4Xcd>(b)).v, pmul<Packet4Xd>(real, b.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pmadd<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b, const Packet4Xcd& c) {
+  Packet4Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet4Xcd(
+      pmadd<Packet4Xd>(imag, pcplxflip<Packet4Xcd>(pconj<Packet4Xcd>(b)).v, pmadd<Packet4Xd>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pmsub<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b, const Packet4Xcd& c) {
+  Packet4Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet4Xcd(
+      pmadd<Packet4Xd>(imag, pcplxflip<Packet4Xcd>(pconj<Packet4Xcd>(b)).v, pmsub<Packet4Xd>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pcmp_eq(const Packet4Xcd& a, const Packet4Xcd& b) {
+  Packet4Xl c = __riscv_vundefined_i64m4();
+  Packet1Xsu mask =
+      __riscv_vreinterpret_v_b16_u16m1(__riscv_vmfeq_vv_f64m4_b16(a.v, b.v, unpacket_traits<Packet4Xd>::size));
+  Packet1Xsu mask_r =
+      __riscv_vsrl_vx_u16m1(__riscv_vand_vx_u16m1(mask, static_cast<short>(0xaaaa), unpacket_traits<Packet1Xs>::size),
+                            1, unpacket_traits<Packet1Xs>::size);
+  mask = __riscv_vand_vv_u16m1(mask, mask_r, unpacket_traits<Packet1Xs>::size);
+  mask = __riscv_vor_vv_u16m1(__riscv_vsll_vx_u16m1(mask, 1, unpacket_traits<Packet1Xs>::size), mask,
+                              unpacket_traits<Packet1Xs>::size);
+  Packet4Xd res = __riscv_vreinterpret_v_i64m4_f64m4(__riscv_vmerge_vvm_i64m4(pzero<Packet4Xl>(c), ptrue<Packet4Xl>(c),
+                                                                              __riscv_vreinterpret_v_u16m1_b16(mask),
+                                                                              unpacket_traits<Packet4Xl>::size));
+  return Packet4Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pand<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return Packet4Xcd(pand<Packet4Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd por<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return Packet4Xcd(por<Packet4Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pxor<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return Packet4Xcd(pxor<Packet4Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pandnot<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return Packet4Xcd(pandnot<Packet4Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pnot<Packet4Xcd>(const Packet4Xcd& a) {
+  return Packet4Xcd(pnot<Packet4Xd>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pload<Packet4Xcd>(const std::complex<double>* from) {
+  Packet4Xd res = pload<Packet4Xd>(reinterpret_cast<const double*>(from));
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet4Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd ploadu<Packet4Xcd>(const std::complex<double>* from) {
+  Packet4Xd res = ploadu<Packet4Xd>(reinterpret_cast<const double*>(from));
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet4Xcd(res);
+}
+
+EIGEN_STRONG_INLINE Packet4Xcd pdup(const Packet2Xcd& a) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
+  Packet4Xul idx1 =
+      __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
+  Packet4Xul idx2 = __riscv_vxor_vx_u64m4_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet4Xl>::size);
+  return Packet4Xcd(
+      __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(a.v), idx2, unpacket_traits<Packet4Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd ploaddup<Packet4Xcd>(const std::complex<double>* from) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
+  Packet4Xul idx1 =
+      __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
+  Packet4Xul idx2 = __riscv_vxor_vx_u64m4_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet4Xl>::size);
+  return Packet4Xcd(__riscv_vrgather_vv_f64m4(
+      __riscv_vlmul_ext_v_f64m2_f64m4(pload<Packet2Xd>(reinterpret_cast<const double*>(from))), idx2,
+      unpacket_traits<Packet4Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd ploadquad<Packet4Xcd>(const std::complex<double>* from) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x5a), unpacket_traits<Packet1Xc>::size));
+  Packet4Xul idx1 =
+      __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 2, unpacket_traits<Packet4Xd>::size);
+  Packet4Xul idx2 = __riscv_vxor_vx_u64m4_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet4Xl>::size);
+  return Packet4Xcd(__riscv_vrgather_vv_f64m4(
+      __riscv_vlmul_ext_v_f64m1_f64m4(pload<Packet1Xd>(reinterpret_cast<const double*>(from))), idx2,
+      unpacket_traits<Packet4Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const Packet4Xcd& from) {
+  EIGEN_DEBUG_ALIGNED_STORE pstore<double>(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<double>>(std::complex<double>* to, const Packet4Xcd& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet4Xcd
+pgather<std::complex<double>, Packet4Xcd>(const std::complex<double>* from, Index stride) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+  const double* from2 = reinterpret_cast<const double*>(from);
+  Packet4Xd res = __riscv_vundefined_f64m4();
+  res = __riscv_vlse64_v_f64m4_tumu(mask, res, &from2[0 - (0 * stride)], stride * sizeof(double),
+                                    unpacket_traits<Packet4Xd>::size);
+  res =
+      __riscv_vlse64_v_f64m4_tumu(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), res,
+                                  &from2[1 - (1 * stride)], stride * sizeof(double), unpacket_traits<Packet4Xd>::size);
+  return Packet4Xcd(res);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<double>, Packet4Xcd>(std::complex<double>* to,
+                                                                                      const Packet4Xcd& from,
+                                                                                      Index stride) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+  double* to2 = reinterpret_cast<double*>(to);
+  __riscv_vsse64_v_f64m4_m(mask, &to2[0 - (0 * stride)], stride * sizeof(double), from.v,
+                           unpacket_traits<Packet4Xd>::size);
+  __riscv_vsse64_v_f64m4_m(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), &to2[1 - (1 * stride)],
+                           stride * sizeof(double), from.v, unpacket_traits<Packet4Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet4Xcd>(const Packet4Xcd& a) {
+  double real = pfirst<Packet4Xd>(a.v);
+  double imag = pfirst<Packet4Xd>(__riscv_vfslide1down_vf_f64m4(a.v, 0.0, unpacket_traits<Packet4Xd>::size));
+  return std::complex<double>(real, imag);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd preverse(const Packet4Xcd& a) {
+  Packet4Xul idx = __riscv_vxor_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xl>::size),
+                                         unpacket_traits<Packet4Xl>::size - 2, unpacket_traits<Packet4Xl>::size);
+  Packet4Xd res = __riscv_vrgather_vv_f64m4(a.v, idx, unpacket_traits<Packet4Xd>::size);
+  return Packet4Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux<Packet4Xcd>(const Packet4Xcd& a) {
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet4Xl res = __riscv_vreinterpret_v_f64m4_i64m4(a.v);
+  Packet4Xd real = __riscv_vreinterpret_v_i64m4_f64m4(
+      __riscv_vand_vx_i64m4_tumu(mask, res, res, 0, unpacket_traits<Packet4Xl>::size));
+  Packet4Xd imag = __riscv_vreinterpret_v_i64m4_f64m4(__riscv_vand_vx_i64m4_tumu(
+      __riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size), res, res, 0, unpacket_traits<Packet4Xl>::size));
+  return std::complex<double>(predux<Packet4Xd>(real), predux<Packet4Xd>(imag));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pdiv<Packet4Xcd>(const Packet4Xcd& a, const Packet4Xcd& b) {
+  return pdiv_complex(a, b);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet4Xcd, N>& kernel) {
+  double buffer[unpacket_traits<Packet4Xd>::size * N];
+  int i = 0;
+
+  const PacketMask16 mask =
+      __riscv_vreinterpret_v_i8m1_b16(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+
+  for (i = 0; i < N; i++) {
+    __riscv_vsse64_v_f64m4_m(mask, &buffer[(i * 2) - (0 * N) + 0], N * sizeof(double), kernel.packet[i].v,
+                             unpacket_traits<Packet4Xd>::size);
+    __riscv_vsse64_v_f64m4_m(__riscv_vmnot_m_b16(mask, unpacket_traits<Packet1Xs>::size),
+                             &buffer[(i * 2) - (1 * N) + 1], N * sizeof(double), kernel.packet[i].v,
+                             unpacket_traits<Packet4Xd>::size);
+  }
+
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = Packet4Xcd(
+        __riscv_vle64_v_f64m4(&buffer[i * unpacket_traits<Packet4Xd>::size], unpacket_traits<Packet4Xd>::size));
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd psqrt<Packet4Xcd>(const Packet4Xcd& a) {
+  return psqrt_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd plog<Packet4Xcd>(const Packet4Xcd& a) {
+  return plog_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xcd pexp<Packet4Xcd>(const Packet4Xcd& a) {
+  return pexp_complex(a);
+}
+
+template <typename Packet = Packet4Xcd>
+EIGEN_STRONG_INLINE Packet2Xcd predux_half(const Packet4Xcd& a) {
+  return Packet2Xcd(__riscv_vfadd_vv_f64m2(__riscv_vget_v_f64m4_f64m2(a.v, 0), __riscv_vget_v_f64m4_f64m2(a.v, 1),
+                                           unpacket_traits<Packet2Xd>::size));
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet4Xcd, Packet4Xd)
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pcast<Packet1Xd, Packet1Xcd>(const Packet1Xd& a) {
+  return Packet1Xcd(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xd pcast<Packet1Xcd, Packet1Xd>(const Packet1Xcd& a) {
+  return a.v;
+}
+
+EIGEN_STRONG_INLINE void prealimag2(const Packet1Xcd& a, Packet1Xd& real, Packet1Xd& imag) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  real = __riscv_vfslide1up_vf_f64m1_tumu(mask, a.v, a.v, 0.0, unpacket_traits<Packet1Xd>::size);
+  imag = __riscv_vfslide1down_vf_f64m1_tumu(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), a.v, a.v, 0.0,
+                                            unpacket_traits<Packet1Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pset1<Packet1Xcd>(const std::complex<double>& from) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet1Xd res = __riscv_vmerge_vvm_f64m1(pset1<Packet1Xd>(from.real()), pset1<Packet1Xd>(from.imag()), mask,
+                                           unpacket_traits<Packet1Xd>::size);
+  return Packet1Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd padd<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return Packet1Xcd(padd<Packet1Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd psub<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return Packet1Xcd(psub<Packet1Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pnegate(const Packet1Xcd& a) {
+  return Packet1Xcd(pnegate<Packet1Xd>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pconj(const Packet1Xcd& a) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  return Packet1Xcd(__riscv_vfsgnjn_vv_f64m1_tumu(mask, a.v, a.v, a.v, unpacket_traits<Packet1Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pcplxflip<Packet1Xcd>(const Packet1Xcd& a) {
+  Packet1Xul res = __riscv_vreinterpret_v_f64m1_u64m1(a.v);
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet1Xul data = __riscv_vslide1down_vx_u64m1(res, 0, unpacket_traits<Packet1Xl>::size);
+  Packet1Xd res2 = __riscv_vreinterpret_v_u64m1_f64m1(
+      __riscv_vslide1up_vx_u64m1_tumu(mask, data, res, 0, unpacket_traits<Packet1Xl>::size));
+  return Packet1Xcd(res2);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pmul<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  Packet1Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet1Xcd(pmadd<Packet1Xd>(imag, pcplxflip<Packet1Xcd>(pconj<Packet1Xcd>(b)).v, pmul<Packet1Xd>(real, b.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pmadd<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b, const Packet1Xcd& c) {
+  Packet1Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet1Xcd(
+      pmadd<Packet1Xd>(imag, pcplxflip<Packet1Xcd>(pconj<Packet1Xcd>(b)).v, pmadd<Packet1Xd>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pmsub<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b, const Packet1Xcd& c) {
+  Packet1Xd real, imag;
+  prealimag2(a, real, imag);
+  return Packet1Xcd(
+      pmadd<Packet1Xd>(imag, pcplxflip<Packet1Xcd>(pconj<Packet1Xcd>(b)).v, pmsub<Packet1Xd>(real, b.v, c.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pcmp_eq(const Packet1Xcd& a, const Packet1Xcd& b) {
+  Packet1Xl c = __riscv_vundefined_i64m1();
+  Packet1Xul mask =
+      __riscv_vreinterpret_v_b64_u64m1(__riscv_vmfeq_vv_f64m1_b64(a.v, b.v, unpacket_traits<Packet1Xd>::size));
+  Packet1Xul mask_r =
+      __riscv_vsrl_vx_u64m1(__riscv_vand_vx_u64m1(mask, 0xaaaaaaaaaaaaaaaa, unpacket_traits<Packet1Xl>::size), 1,
+                            unpacket_traits<Packet1Xl>::size);
+  mask = __riscv_vand_vv_u64m1(mask, mask_r, unpacket_traits<Packet1Xl>::size);
+  mask = __riscv_vor_vv_u64m1(__riscv_vsll_vx_u64m1(mask, 1, unpacket_traits<Packet1Xl>::size), mask,
+                              unpacket_traits<Packet1Xl>::size);
+  Packet1Xd res = __riscv_vreinterpret_v_i64m1_f64m1(__riscv_vmerge_vvm_i64m1(pzero<Packet1Xl>(c), ptrue<Packet1Xl>(c),
+                                                                              __riscv_vreinterpret_v_u64m1_b64(mask),
+                                                                              unpacket_traits<Packet1Xl>::size));
+  return Packet1Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pand<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return Packet1Xcd(pand<Packet1Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd por<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return Packet1Xcd(por<Packet1Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pxor<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return Packet1Xcd(pxor<Packet1Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pandnot<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return Packet1Xcd(pandnot<Packet1Xd>(a.v, b.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pnot<Packet1Xcd>(const Packet1Xcd& a) {
+  return Packet1Xcd(pnot<Packet1Xd>(a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pload<Packet1Xcd>(const std::complex<double>* from) {
+  Packet1Xd res = pload<Packet1Xd>(reinterpret_cast<const double*>(from));
+  EIGEN_DEBUG_ALIGNED_LOAD return Packet1Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd ploadu<Packet1Xcd>(const std::complex<double>* from) {
+  Packet1Xd res = ploadu<Packet1Xd>(reinterpret_cast<const double*>(from));
+  EIGEN_DEBUG_UNALIGNED_LOAD return Packet1Xcd(res);
+}
+
+EIGEN_STRONG_INLINE Packet2Xcd pdup(const Packet1Xcd& a) {
+  const PacketMask32 mask =
+      __riscv_vreinterpret_v_i8m1_b32(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
+  Packet2Xul idx1 =
+      __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
+  Packet2Xul idx2 = __riscv_vxor_vx_u64m2_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet2Xl>::size);
+  return Packet2Xcd(
+      __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(a.v), idx2, unpacket_traits<Packet2Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd ploaddup<Packet1Xcd>(const std::complex<double>* from) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x66), unpacket_traits<Packet1Xc>::size));
+  Packet1Xul idx1 =
+      __riscv_vsrl_vx_u64m1(__riscv_vid_v_u64m1(unpacket_traits<Packet1Xd>::size), 1, unpacket_traits<Packet1Xd>::size);
+  Packet1Xul idx2 = __riscv_vxor_vx_u64m1_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet1Xl>::size);
+  return Packet1Xcd(__riscv_vrgather_vv_f64m1(pload<Packet1Xd>(reinterpret_cast<const double*>(from)), idx2,
+                                              unpacket_traits<Packet1Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd ploadquad<Packet1Xcd>(const std::complex<double>* from) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x5a), unpacket_traits<Packet1Xc>::size));
+  Packet1Xul idx1 =
+      __riscv_vsrl_vx_u64m1(__riscv_vid_v_u64m1(unpacket_traits<Packet1Xd>::size), 2, unpacket_traits<Packet1Xd>::size);
+  Packet1Xul idx2 = __riscv_vxor_vx_u64m1_tumu(mask, idx1, idx1, 1, unpacket_traits<Packet1Xl>::size);
+  return Packet1Xcd(__riscv_vrgather_vv_f64m1(pload<Packet1Xd>(reinterpret_cast<const double*>(from)), idx2,
+                                              unpacket_traits<Packet1Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const Packet1Xcd& from) {
+  EIGEN_DEBUG_ALIGNED_STORE pstore<double>(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<double>>(std::complex<double>* to, const Packet1Xcd& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE pstoreu<double>(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet1Xcd
+pgather<std::complex<double>, Packet1Xcd>(const std::complex<double>* from, Index stride) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+  const double* from2 = reinterpret_cast<const double*>(from);
+  Packet1Xd res = __riscv_vundefined_f64m1();
+  res = __riscv_vlse64_v_f64m1_tumu(mask, res, &from2[0 - (0 * stride)], stride * sizeof(double),
+                                    unpacket_traits<Packet1Xd>::size);
+  res =
+      __riscv_vlse64_v_f64m1_tumu(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), res,
+                                  &from2[1 - (1 * stride)], stride * sizeof(double), unpacket_traits<Packet1Xd>::size);
+  return Packet1Xcd(res);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pscatter<std::complex<double>, Packet1Xcd>(std::complex<double>* to,
+                                                                                      const Packet1Xcd& from,
+                                                                                      Index stride) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+  double* to2 = reinterpret_cast<double*>(to);
+  __riscv_vsse64_v_f64m1_m(mask, &to2[0 - (0 * stride)], stride * sizeof(double), from.v,
+                           unpacket_traits<Packet1Xd>::size);
+  __riscv_vsse64_v_f64m1_m(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), &to2[1 - (1 * stride)],
+                           stride * sizeof(double), from.v, unpacket_traits<Packet1Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1Xcd>(const Packet1Xcd& a) {
+  double real = pfirst<Packet1Xd>(a.v);
+  double imag = pfirst<Packet1Xd>(__riscv_vfslide1down_vf_f64m1(a.v, 0.0, unpacket_traits<Packet1Xd>::size));
+  return std::complex<double>(real, imag);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd preverse(const Packet1Xcd& a) {
+  Packet1Xul idx = __riscv_vxor_vx_u64m1(__riscv_vid_v_u64m1(unpacket_traits<Packet1Xl>::size),
+                                         unpacket_traits<Packet1Xl>::size - 2, unpacket_traits<Packet1Xl>::size);
+  Packet1Xd res = __riscv_vrgather_vv_f64m1(a.v, idx, unpacket_traits<Packet1Xd>::size);
+  return Packet1Xcd(res);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux<Packet1Xcd>(const Packet1Xcd& a) {
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0xaa), unpacket_traits<Packet1Xc>::size));
+  Packet1Xl res = __riscv_vreinterpret_v_f64m1_i64m1(a.v);
+  Packet1Xd real = __riscv_vreinterpret_v_i64m1_f64m1(
+      __riscv_vand_vx_i64m1_tumu(mask, res, res, 0, unpacket_traits<Packet1Xl>::size));
+  Packet1Xd imag = __riscv_vreinterpret_v_i64m1_f64m1(__riscv_vand_vx_i64m1_tumu(
+      __riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size), res, res, 0, unpacket_traits<Packet1Xl>::size));
+  return std::complex<double>(predux<Packet1Xd>(real), predux<Packet1Xd>(imag));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pdiv<Packet1Xcd>(const Packet1Xcd& a, const Packet1Xcd& b) {
+  return pdiv_complex(a, b);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void ptranspose(PacketBlock<Packet1Xcd, N>& kernel) {
+  double buffer[unpacket_traits<Packet1Xd>::size * N];
+  int i = 0;
+
+  const PacketMask64 mask =
+      __riscv_vreinterpret_v_i8m1_b64(__riscv_vmv_v_x_i8m1(static_cast<char>(0x55), unpacket_traits<Packet1Xc>::size));
+
+  for (i = 0; i < N; i++) {
+    __riscv_vsse64_v_f64m1_m(mask, &buffer[(i * 2) - (0 * N) + 0], N * sizeof(double), kernel.packet[i].v,
+                             unpacket_traits<Packet1Xd>::size);
+    __riscv_vsse64_v_f64m1_m(__riscv_vmnot_m_b64(mask, unpacket_traits<Packet1Xl>::size),
+                             &buffer[(i * 2) - (1 * N) + 1], N * sizeof(double), kernel.packet[i].v,
+                             unpacket_traits<Packet1Xd>::size);
+  }
+
+  for (i = 0; i < N; i++) {
+    kernel.packet[i] = Packet1Xcd(
+        __riscv_vle64_v_f64m1(&buffer[i * unpacket_traits<Packet1Xd>::size], unpacket_traits<Packet1Xd>::size));
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd psqrt<Packet1Xcd>(const Packet1Xcd& a) {
+  return psqrt_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd plog<Packet1Xcd>(const Packet1Xcd& a) {
+  return plog_complex(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xcd pexp<Packet1Xcd>(const Packet1Xcd& a) {
+  return pexp_complex(a);
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1Xcd, Packet1Xd)
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLEX2_RVV10_H
diff --git a/Eigen/src/Core/arch/RVV10/GeneralBlockPanelKernel.h b/Eigen/src/Core/arch/RVV10/GeneralBlockPanelKernel.h
index 026e1db..a6c362b 100644
--- a/Eigen/src/Core/arch/RVV10/GeneralBlockPanelKernel.h
+++ b/Eigen/src/Core/arch/RVV10/GeneralBlockPanelKernel.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RVV10_GENERAL_BLOCK_KERNEL_H
 #define EIGEN_RVV10_GENERAL_BLOCK_KERNEL_H
@@ -230,6 +231,465 @@
 
 #endif
 
+#if EIGEN_RISCV64_DEFAULT_LMUL == 1
+/********************************* complex ************************************/
+
+#define PACKET_DECL_COND_POSTFIX(postfix, name, packet_size)                                               \
+  typedef typename packet_conditional<                                                                     \
+      packet_size, typename packet_traits<name##Scalar>::type, typename packet_traits<name##Scalar>::half, \
+      typename unpacket_traits<typename packet_traits<name##Scalar>::half>::half>::type name##Packet##postfix
+
+#define RISCV_COMPLEX_PACKET_DECL_COND_SCALAR(packet_size)                                     \
+  typedef typename packet_conditional<                                                         \
+      packet_size, typename packet_traits<Scalar>::type, typename packet_traits<Scalar>::half, \
+      typename unpacket_traits<typename packet_traits<Scalar>::half>::half>::type ScalarPacket
+
+template <typename RealScalar, bool ConjLhs_, bool ConjRhs_, int PacketSize_>
+struct gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, ConjLhs_, ConjRhs_, Architecture::RVV10,
+                   PacketSize_> : gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, ConjLhs_, ConjRhs_,
+                                              Architecture::Generic, PacketSize_> {
+  typedef std::complex<RealScalar> Scalar;
+  typedef std::complex<RealScalar> LhsScalar;
+  typedef std::complex<RealScalar> RhsScalar;
+  typedef std::complex<RealScalar> ResScalar;
+  typedef typename packet_traits<std::complex<RealScalar>>::type RealPacket;
+
+  PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Res, PacketSize_);
+  RISCV_COMPLEX_PACKET_DECL_COND_SCALAR(PacketSize_);
+#undef RISCV_COMPLEX_PACKET_DECL_COND_SCALAR
+
+  enum {
+    ConjLhs = ConjLhs_,
+    ConjRhs = ConjRhs_,
+    Vectorizable = unpacket_traits<RealPacket>::vectorizable && unpacket_traits<ScalarPacket>::vectorizable,
+    ResPacketSize = Vectorizable ? unpacket_traits<ResPacket_>::size : 1,
+    LhsPacketSize = Vectorizable ? unpacket_traits<LhsPacket_>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<RhsScalar>::size : 1,
+    RealPacketSize = Vectorizable ? unpacket_traits<RealPacket>::size : 1,
+
+    nr = 4,
+    mr = ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef DoublePacket<RealPacket> DoublePacketType;
+
+  typedef std::conditional_t<Vectorizable, ScalarPacket, Scalar> LhsPacket4Packing;
+  typedef std::conditional_t<Vectorizable, RealPacket, Scalar> LhsPacket;
+  typedef std::conditional_t<Vectorizable, DoublePacket<RealScalar>, Scalar> RhsPacket;
+  typedef std::conditional_t<Vectorizable, ScalarPacket, Scalar> ResPacket;
+  typedef std::conditional_t<Vectorizable, DoublePacketType, Scalar> AccPacket;
+
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+
+  EIGEN_STRONG_INLINE void initAcc(Scalar& p) { p = Scalar(0); }
+
+  EIGEN_STRONG_INLINE void initAcc(DoublePacketType& p) {
+    p.first = pset1<RealPacket>(RealScalar(0));
+    p.second = pset1<RealPacket>(RealScalar(0));
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ScalarPacket& dest) const { dest = pset1<ScalarPacket>(*b); }
+
+  // Vectorized path
+  template <typename RealPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const {
+    dest.first = pset1<RealPacketType>(numext::real(*b));
+    dest.second = pset1<RealPacketType>(numext::imag(*b));
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const {
+    loadRhs(b, dest.B_0);
+    loadRhs(b + 1, dest.B1);
+    loadRhs(b + 2, dest.B2);
+    loadRhs(b + 3, dest.B3);
+  }
+
+  // Scalar path
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, ScalarPacket& dest) const { loadRhs(b, dest); }
+
+  // Vectorized path
+  template <typename RealPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest) const { loadRhs(b, dest); }
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacket<RealScalar>& dest) const {
+    loadQuadToDoublePacket(b, dest);
+  }
+
+  // nothing special here
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const {
+    dest = pload<LhsPacket>((const typename unpacket_traits<LhsPacket>::type*)(a));
+  }
+
+  template <typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const {
+    dest = ploadu<LhsPacketType>((const typename unpacket_traits<LhsPacketType>::type*)(a));
+  }
+
+  EIGEN_STRONG_INLINE Packet1Xcf pmadd_scalar(const Packet1Xcf& a, float b, const Packet1Xcf& c) const {
+    return Packet1Xcf(__riscv_vfmadd_vf_f32m1(a.v, b, c.v, unpacket_traits<Packet1Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet1Xcd pmadd_scalar(const Packet1Xcd& a, double b, const Packet1Xcd& c) const {
+    return Packet1Xcd(__riscv_vfmadd_vf_f64m1(a.v, b, c.v, unpacket_traits<Packet1Xd>::size));
+  }
+
+#if EIGEN_RISCV64_DEFAULT_LMUL >= 2
+  EIGEN_STRONG_INLINE Packet2Xcf pmadd_scalar(const Packet2Xcf& a, float b, const Packet2Xcf& c) const {
+    return Packet2Xcf(__riscv_vfmadd_vf_f32m2(a.v, b, c.v, unpacket_traits<Packet2Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet2Xcd pmadd_scalar(const Packet2Xcd& a, double b, const Packet2Xcd& c) const {
+    return Packet2Xcd(__riscv_vfmadd_vf_f64m2(a.v, b, c.v, unpacket_traits<Packet2Xd>::size));
+  }
+#endif
+
+#if EIGEN_RISCV64_DEFAULT_LMUL == 4
+  EIGEN_STRONG_INLINE Packet4Xcf pmadd_scalar(const Packet4Xcf& a, float b, const Packet4Xcf& c) const {
+    return Packet4Xcf(__riscv_vfmadd_vf_f32m4(a.v, b, c.v, unpacket_traits<Packet4Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet4Xcd pmadd_scalar(const Packet4Xcd& a, double b, const Packet4Xcd& c) const {
+    return Packet4Xcd(__riscv_vfmadd_vf_f64m4(a.v, b, c.v, unpacket_traits<Packet4Xd>::size));
+  }
+#endif
+
+  template <typename LhsPacketType, typename RhsPacketType, typename ResPacketType, typename TmpType,
+            typename LaneIdType>
+  EIGEN_STRONG_INLINE std::enable_if_t<!is_same<RhsPacketType, RhsPacketx4>::value> madd(const LhsPacketType& a,
+                                                                                         const RhsPacketType& b,
+                                                                                         DoublePacket<ResPacketType>& c,
+                                                                                         TmpType& /*tmp*/,
+                                                                                         const LaneIdType&) const {
+    c.first = pmadd_scalar(a, b.first, c.first);
+    c.second = pmadd_scalar(a, b.second, c.second);
+  }
+
+  template <typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp,
+                                const LaneIdType& lane) const {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, ResPacket& c, RhsPacket& /*tmp*/,
+                                const LaneIdType&) const {
+    c = cj.pmadd(a, b, c);
+  }
+
+  template <typename RealPacketType, typename ResPacketType>
+  EIGEN_STRONG_INLINE void acc(const DoublePacket<RealPacketType>& c, const ResPacketType& alpha,
+                               ResPacketType& r) const {
+    // assemble c
+    ResPacketType tmp;
+    EIGEN_IF_CONSTEXPR ((!ConjLhs) && (!ConjRhs)) {
+      tmp = pcplxflip(pconj(ResPacketType(c.second)));
+      tmp = padd(ResPacketType(c.first), tmp);
+    } else EIGEN_IF_CONSTEXPR ((!ConjLhs) && (ConjRhs)) {
+      tmp = pconj(pcplxflip(ResPacketType(c.second)));
+      tmp = padd(ResPacketType(c.first), tmp);
+    } else EIGEN_IF_CONSTEXPR ((ConjLhs) && (!ConjRhs)) {
+      tmp = pcplxflip(ResPacketType(c.second));
+      tmp = padd(pconj(ResPacketType(c.first)), tmp);
+    } else EIGEN_IF_CONSTEXPR ((ConjLhs) && (ConjRhs)) {
+      tmp = pcplxflip(ResPacketType(c.second));
+      tmp = psub(pconj(ResPacketType(c.first)), tmp);
+    }
+
+    r = pmadd(tmp, alpha, r);
+  }
+
+  // madd() already applied the operand conjugations; neither c nor alpha is conjugated here.
+  EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scalar& r) const { r += alpha * c; }
+
+ protected:
+  conj_helper<LhsScalar, RhsScalar, ConjLhs, ConjRhs> cj;
+};
+
+#define PACKET_DECL_COND_SCALAR_POSTFIX(postfix, packet_size)                                  \
+  typedef typename packet_conditional<                                                         \
+      packet_size, typename packet_traits<Scalar>::type, typename packet_traits<Scalar>::half, \
+      typename unpacket_traits<typename packet_traits<Scalar>::half>::half>::type ScalarPacket##postfix
+
+template <typename RealScalar, bool ConjRhs_, int PacketSize_>
+class gebp_traits<RealScalar, std::complex<RealScalar>, false, ConjRhs_, Architecture::RVV10, PacketSize_>
+    : public gebp_traits<RealScalar, std::complex<RealScalar>, false, ConjRhs_, Architecture::Generic, PacketSize_> {
+ public:
+  typedef std::complex<RealScalar> Scalar;
+  typedef RealScalar LhsScalar;
+  typedef Scalar RhsScalar;
+  typedef Scalar ResScalar;
+  PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Res, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Real, PacketSize_);
+  PACKET_DECL_COND_SCALAR_POSTFIX(_, PacketSize_);
+#undef PACKET_DECL_COND_SCALAR_POSTFIX
+
+  enum {
+    ConjLhs = false,
+    ConjRhs = ConjRhs_,
+    Vectorizable = unpacket_traits<RealPacket_>::vectorizable && unpacket_traits<ScalarPacket_>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<LhsPacket_>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<RhsPacket_>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<ResPacket_>::size : 1,
+
+    NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS,
+    // FIXME: should depend on NumberOfRegisters
+    nr = 4,
+    mr = (plain_enum_min(16, NumberOfRegisters) / 2 / nr) * ResPacketSize,
+
+    LhsProgress = ResPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> LhsPacket;
+  typedef RhsScalar RhsPacket;
+  typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p) const { p = pset1<ResPacket>(ResScalar(0)); }
+
+  template <typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template <typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { dest = ploaddup<LhsPacket>(a); }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const { dest = ploadquad<RhsPacket>(b); }
+
+  template <typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const {
+    dest = ploaddup<LhsPacketType>(a);
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp,
+                                const LaneIdType&) const {
+    madd_impl(a, b, c, tmp, std::conditional_t<Vectorizable, std::true_type, std::false_type>());
+  }
+
+  EIGEN_STRONG_INLINE Packet1Xcf pmadd_scalar(const Packet1Xf& a, std::complex<float> b, const Packet1Xcf& c) const {
+    Packet1Xcf bp = pset1<Packet1Xcf>(b);
+    return Packet1Xcf(__riscv_vfmadd_vv_f32m1(a, bp.v, c.v, unpacket_traits<Packet1Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet1Xcd pmadd_scalar(const Packet1Xd& a, std::complex<double> b, const Packet1Xcd& c) const {
+    Packet1Xcd bp = pset1<Packet1Xcd>(b);
+    return Packet1Xcd(__riscv_vfmadd_vv_f64m1(a, bp.v, c.v, unpacket_traits<Packet1Xd>::size));
+  }
+
+#if EIGEN_RISCV64_DEFAULT_LMUL >= 2
+  EIGEN_STRONG_INLINE Packet2Xcf pmadd_scalar(const Packet2Xf& a, std::complex<float> b, const Packet2Xcf& c) const {
+    Packet2Xcf bp = pset1<Packet2Xcf>(b);
+    return Packet2Xcf(__riscv_vfmadd_vv_f32m2(a, bp.v, c.v, unpacket_traits<Packet2Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet2Xcd pmadd_scalar(const Packet2Xd& a, std::complex<double> b, const Packet2Xcd& c) const {
+    Packet2Xcd bp = pset1<Packet2Xcd>(b);
+    return Packet2Xcd(__riscv_vfmadd_vv_f64m2(a, bp.v, c.v, unpacket_traits<Packet2Xd>::size));
+  }
+#endif
+
+#if EIGEN_RISCV64_DEFAULT_LMUL == 4
+  EIGEN_STRONG_INLINE Packet4Xcf pmadd_scalar(const Packet4Xf& a, std::complex<float> b, const Packet4Xcf& c) const {
+    Packet4Xcf bp = pset1<Packet4Xcf>(b);
+    return Packet4Xcf(__riscv_vfmadd_vv_f32m4(a, bp.v, c.v, unpacket_traits<Packet4Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet4Xcd pmadd_scalar(const Packet4Xd& a, std::complex<double> b, const Packet4Xcd& c) const {
+    Packet4Xcd bp = pset1<Packet4Xcd>(b);
+    return Packet4Xcd(__riscv_vfmadd_vv_f64m4(a, bp.v, c.v, unpacket_traits<Packet4Xd>::size));
+  }
+#endif
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c,
+                                     RhsPacketType& tmp, const std::true_type&) const {
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c = pmadd_scalar(a, b, c);
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/,
+                                     const std::false_type&) const {
+    c += a * b;
+  }
+
+  template <typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp,
+                                const LaneIdType& lane) const {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename ResPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketType& r) const {
+    conj_helper<ResPacketType, ResPacketType, false, ConjRhs> cj;
+    r = cj.pmadd(alpha, c, r);
+  }
+};
+
+template <typename RealScalar, bool ConjLhs_, int PacketSize_>
+class gebp_traits<std::complex<RealScalar>, RealScalar, ConjLhs_, false, Architecture::RVV10, PacketSize_>
+    : public gebp_traits<RealScalar, std::complex<RealScalar>, ConjLhs_, false, Architecture::Generic, PacketSize_> {
+ public:
+  typedef std::complex<RealScalar> LhsScalar;
+  typedef RealScalar RhsScalar;
+  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+
+  PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
+  PACKET_DECL_COND_POSTFIX(_, Res, PacketSize_);
+#undef PACKET_DECL_COND_POSTFIX
+
+  enum {
+    ConjLhs = ConjLhs_,
+    ConjRhs = false,
+    Vectorizable = unpacket_traits<LhsPacket_>::vectorizable && unpacket_traits<RhsPacket_>::vectorizable,
+    LhsPacketSize = Vectorizable ? unpacket_traits<LhsPacket_>::size : 1,
+    RhsPacketSize = Vectorizable ? unpacket_traits<RhsPacket_>::size : 1,
+    ResPacketSize = Vectorizable ? unpacket_traits<ResPacket_>::size : 1,
+
+    nr = 4,
+    mr = 3 * LhsPacketSize,
+
+    LhsProgress = LhsPacketSize,
+    RhsProgress = 1
+  };
+
+  typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> LhsPacket;
+  typedef RhsScalar RhsPacket;
+  typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+
+  typedef QuadPacket<RhsPacket> RhsPacketx4;
+
+  typedef ResPacket AccPacket;
+
+  EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { p = pset1<ResPacket>(ResScalar(0)); }
+
+  template <typename RhsPacketType>
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketType& dest) const {
+    dest = pset1<RhsPacketType>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) const {
+    pbroadcast4(b, dest.B_0, dest.B1, dest.B2, dest.B3);
+  }
+
+  template <typename RhsPacketType>
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, RhsPacketType& dest) const {
+    loadRhs(b, dest);
+  }
+
+  EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
+
+  EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const {
+    loadRhsQuad_impl(b, dest, std::conditional_t<RhsPacketSize == 16, std::true_type, std::false_type>());
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const std::true_type&) const {
+    // FIXME we can do better!
+    // what we want here is a ploadheight
+    RhsScalar tmp[4] = {b[0], b[0], b[1], b[1]};
+    dest = ploadquad<RhsPacket>(tmp);
+  }
+
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const std::false_type&) const {
+    eigen_internal_assert(RhsPacketSize <= 8);
+    dest = pset1<RhsPacket>(*b);
+  }
+
+  EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { dest = pload<LhsPacket>(a); }
+
+  template <typename LhsPacketType>
+  EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const {
+    dest = ploadu<LhsPacketType>(a);
+  }
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp,
+                                const LaneIdType&) const {
+    madd_impl(a, b, c, tmp, std::conditional_t<Vectorizable, std::true_type, std::false_type>());
+  }
+
+  EIGEN_STRONG_INLINE Packet1Xcf pmadd_scalar(const Packet1Xcf& a, float b, const Packet1Xcf& c) const {
+    return Packet1Xcf(__riscv_vfmadd_vf_f32m1(a.v, b, c.v, unpacket_traits<Packet1Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet1Xcd pmadd_scalar(const Packet1Xcd& a, double b, const Packet1Xcd& c) const {
+    return Packet1Xcd(__riscv_vfmadd_vf_f64m1(a.v, b, c.v, unpacket_traits<Packet1Xd>::size));
+  }
+
+#if EIGEN_RISCV64_DEFAULT_LMUL >= 2
+  EIGEN_STRONG_INLINE Packet2Xcf pmadd_scalar(const Packet2Xcf& a, float b, const Packet2Xcf& c) const {
+    return Packet2Xcf(__riscv_vfmadd_vf_f32m2(a.v, b, c.v, unpacket_traits<Packet2Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet2Xcd pmadd_scalar(const Packet2Xcd& a, double b, const Packet2Xcd& c) const {
+    return Packet2Xcd(__riscv_vfmadd_vf_f64m2(a.v, b, c.v, unpacket_traits<Packet2Xd>::size));
+  }
+#endif
+
+#if EIGEN_RISCV64_DEFAULT_LMUL == 4
+  EIGEN_STRONG_INLINE Packet4Xcf pmadd_scalar(const Packet4Xcf& a, float b, const Packet4Xcf& c) const {
+    return Packet4Xcf(__riscv_vfmadd_vf_f32m4(a.v, b, c.v, unpacket_traits<Packet4Xf>::size));
+  }
+
+  EIGEN_STRONG_INLINE Packet4Xcd pmadd_scalar(const Packet4Xcd& a, double b, const Packet4Xcd& c) const {
+    return Packet4Xcd(__riscv_vfmadd_vf_f64m4(a.v, b, c.v, unpacket_traits<Packet4Xd>::size));
+  }
+#endif
+
+  template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c,
+                                     RhsPacketType& tmp, const std::true_type&) const {
+    EIGEN_UNUSED_VARIABLE(tmp);
+    c = pmadd_scalar(a, b, c);
+  }
+
+  EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/,
+                                     const std::false_type&) const {
+    c += a * b;
+  }
+
+  template <typename LhsPacketType, typename AccPacketType, typename LaneIdType>
+  EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c, RhsPacket& tmp,
+                                const LaneIdType& lane) const {
+    madd(a, b.get(lane), c, tmp, lane);
+  }
+
+  template <typename ResPacketType, typename AccPacketType>
+  EIGEN_STRONG_INLINE void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketType& r) const {
+    conj_helper<ResPacketType, ResPacketType, ConjLhs, false> cj;
+    r = cj.pmadd(c, alpha, r);
+  }
+};
+#endif
+
 }  // namespace internal
 }  // namespace Eigen
 
diff --git a/Eigen/src/Core/arch/RVV10/MathFunctions.h b/Eigen/src/Core/arch/RVV10/MathFunctions.h
index 10a70c4..be522bb 100644
--- a/Eigen/src/Core/arch/RVV10/MathFunctions.h
+++ b/Eigen/src/Core/arch/RVV10/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_RVV10_H
 #define EIGEN_MATH_FUNCTIONS_RVV10_H
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index 679d5c1..8bbee9e 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_RVV10_H
 #define EIGEN_PACKET_MATH_RVV10_H
@@ -16,190 +17,13 @@
 
 namespace Eigen {
 namespace internal {
-#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
-#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
-#endif
-
-#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
-#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
-#endif
-
-#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
-
-template <typename Scalar, std::size_t VectorLength, std::size_t VectorLMul>
-struct rvv_packet_size_selector {
-  enum { size = VectorLength * VectorLMul / (sizeof(Scalar) * CHAR_BIT) };
-};
-
-template <std::size_t VectorLength, std::size_t VectorLMul>
-struct rvv_packet_alignment_selector {
-  enum {
-    alignment =
-        (VectorLength * VectorLMul) >= 1024
-            ? Aligned128
-            : ((VectorLength * VectorLMul) >= 512 ? Aligned64
-                                                  : ((VectorLength * VectorLMul) >= 256 ? Aligned32 : Aligned16))
-  };
-};
-
-typedef vbool64_t PacketMask64;
-typedef vbool32_t PacketMask32;
-typedef vbool16_t PacketMask16;
-typedef vbool8_t PacketMask8;
-typedef vbool4_t PacketMask4;
-
-/********************************* int32 **************************************/
-typedef eigen_packet_wrapper<vint32m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 0> Packet1Xi;
-typedef eigen_packet_wrapper<vuint32m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 1> Packet1Xu;
-
-typedef eigen_packet_wrapper<vint32m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 2> Packet2Xi;
-typedef eigen_packet_wrapper<vuint32m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 3> Packet2Xu;
-
-typedef eigen_packet_wrapper<vint32m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 4> Packet4Xi;
-typedef eigen_packet_wrapper<vuint32m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 5> Packet4Xu;
-
-#if EIGEN_RISCV64_DEFAULT_LMUL == 1
-typedef Packet1Xi PacketXi;
-typedef Packet1Xu PacketXu;
-
-template <>
-struct packet_traits<numext::int32_t> : default_packet_traits {
-  typedef Packet1Xi type;
-  typedef Packet1Xi half;  // Half not implemented yet
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int32_t, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
-typedef Packet2Xi PacketXi;
-typedef Packet2Xu PacketXu;
-
-template <>
-struct packet_traits<numext::int32_t> : default_packet_traits {
-  typedef Packet2Xi type;
-  typedef Packet1Xi half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int32_t, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
-typedef Packet4Xi PacketXi;
-typedef Packet4Xu PacketXu;
-
-template <>
-struct packet_traits<numext::int32_t> : default_packet_traits {
-  typedef Packet4Xi type;
-  typedef Packet2Xi half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int32_t, EIGEN_RISCV64_RVV_VL, 4>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-#endif
-
-template <>
-struct unpacket_traits<Packet1Xi> {
-  typedef numext::int32_t type;
-  typedef Packet1Xi half;  // Half not yet implemented
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int32_t, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet2Xi> {
-  typedef numext::int32_t type;
-  typedef Packet1Xi half;
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int32_t, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet4Xi> {
-  typedef numext::int32_t type;
-  typedef Packet2Xi half;
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int32_t, EIGEN_RISCV64_RVV_VL, 4>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-EIGEN_STRONG_INLINE void prefetch<numext::int32_t>(const numext::int32_t* addr) {
-#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
-  __builtin_prefetch(addr);
-#endif
-}
 
 /********************************* Packet1Xi ************************************/
 
+EIGEN_STRONG_INLINE Packet1Xi __riscv_vreinterpret_v_u64m1_i32m1(const Packet1Xul& a) {
+  return __riscv_vreinterpret_v_i64m1_i32m1(__riscv_vreinterpret_v_u64m1_i64m1(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet1Xi pset1<Packet1Xi>(const numext::int32_t& from) {
   return __riscv_vmv_v_x_i32m1(from, unpacket_traits<Packet1Xi>::size);
@@ -232,11 +56,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xi pconj(const Packet1Xi& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xi pmul<Packet1Xi>(const Packet1Xi& a, const Packet1Xi& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet1Xi>::size);
 }
@@ -316,23 +135,33 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xi pandnot<Packet1Xi>(const Packet1Xi& a, const Packet1Xi& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i32m1(a, __riscv_vnot_v_i32m1(b, unpacket_traits<Packet1Xi>::size),
                                unpacket_traits<Packet1Xi>::size);
+#else
+  return __riscv_vreinterpret_v_u32m1_i32m1(__riscv_vandn_vv_u32m1(
+      __riscv_vreinterpret_v_i32m1_u32m1(a), __riscv_vreinterpret_v_i32m1_u32m1(b), unpacket_traits<Packet1Xi>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xi pnot<Packet1Xi>(const Packet1Xi& a) {
+  return __riscv_vnot_v_i32m1(a, unpacket_traits<Packet1Xi>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xi parithmetic_shift_right(Packet1Xi a) {
+EIGEN_STRONG_INLINE Packet1Xi parithmetic_shift_right(const Packet1Xi& a) {
   return __riscv_vsra_vx_i32m1(a, N, unpacket_traits<Packet1Xi>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xi plogical_shift_right(Packet1Xi a) {
+EIGEN_STRONG_INLINE Packet1Xi plogical_shift_right(const Packet1Xi& a) {
   return __riscv_vreinterpret_i32m1(
       __riscv_vsrl_vx_u32m1(__riscv_vreinterpret_u32m1(a), N, unpacket_traits<Packet1Xi>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xi plogical_shift_left(Packet1Xi a) {
+EIGEN_STRONG_INLINE Packet1Xi plogical_shift_left(const Packet1Xi& a) {
   return __riscv_vsll_vx_i32m1(a, N, unpacket_traits<Packet1Xi>::size);
 }
 
@@ -348,10 +177,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xi ploaddup<Packet1Xi>(const numext::int32_t* from) {
-  Packet1Xu data = __riscv_vreinterpret_v_i32m1_u32m1(pload<Packet1Xi>(from));
-  return __riscv_vreinterpret_v_i64m1_i32m1(__riscv_vreinterpret_v_u64m1_i64m1(__riscv_vlmul_trunc_v_u64m2_u64m1(
-      __riscv_vwmaccu_vx_u64m2(__riscv_vwaddu_vv_u64m2(data, data, unpacket_traits<Packet1Xi>::size), 0xffffffffu, data,
-                               unpacket_traits<Packet1Xi>::size))));
+  Packet1Xul data = __riscv_vlmul_trunc_v_u64m2_u64m1(__riscv_vwcvtu_x_x_v_u64m2(
+      __riscv_vreinterpret_v_i32m1_u32m1(pload<Packet1Xi>(from)), unpacket_traits<Packet1Xi>::size));
+  return __riscv_vreinterpret_v_u64m1_i32m1(__riscv_vadd_vv_u64m1(
+      __riscv_vsll_vx_u64m1(data, 32, unpacket_traits<Packet1Xl>::size), data, unpacket_traits<Packet1Xl>::size));
 }
 
 template <>
@@ -408,20 +237,26 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xi& a) {
+  const PacketMask32 mask = __riscv_vmseq_vx_i32m1_b32(a, 0, unpacket_traits<Packet1Xi>::size);
+  return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet1Xi>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int32_t predux_mul<Packet1Xi>(const Packet1Xi& a) {
   // Multiply the vector by its reverse
   Packet1Xi prod = __riscv_vmul_vv_i32m1(preverse(a), a, unpacket_traits<Packet1Xi>::size);
   Packet1Xi half_prod;
 
-  if (EIGEN_RISCV64_RVV_VL >= 1024) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
     half_prod = __riscv_vslidedown_vx_i32m1(prod, 8, unpacket_traits<Packet1Xi>::size);
     prod = __riscv_vmul_vv_i32m1(prod, half_prod, unpacket_traits<Packet1Xi>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 512) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
     half_prod = __riscv_vslidedown_vx_i32m1(prod, 4, unpacket_traits<Packet1Xi>::size);
     prod = __riscv_vmul_vv_i32m1(prod, half_prod, unpacket_traits<Packet1Xi>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
     half_prod = __riscv_vslidedown_vx_i32m1(prod, 2, unpacket_traits<Packet1Xi>::size);
     prod = __riscv_vmul_vv_i32m1(prod, half_prod, unpacket_traits<Packet1Xi>::size);
   }
@@ -461,198 +296,21 @@
   }
 }
 
-/********************************* float32 ************************************/
-
-typedef eigen_packet_wrapper<vfloat32m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 6> Packet1Xf;
-typedef eigen_packet_wrapper<vfloat32m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 7>
-    Packet2Xf;
-typedef eigen_packet_wrapper<vfloat32m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 8>
-    Packet4Xf;
-
-#if EIGEN_RISCV64_DEFAULT_LMUL == 1
-typedef Packet1Xf PacketXf;
-
-template <>
-struct packet_traits<float> : default_packet_traits {
-  typedef Packet1Xf type;
-  typedef Packet1Xf half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<float, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasSin = EIGEN_FAST_MATH,
-    HasCos = EIGEN_FAST_MATH,
-    HasTan = EIGEN_FAST_MATH,
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1,
-    HasTanh = EIGEN_FAST_MATH,
-    HasErf = EIGEN_FAST_MATH
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
-typedef Packet2Xf PacketXf;
-
-template <>
-struct packet_traits<float> : default_packet_traits {
-  typedef Packet2Xf type;
-  typedef Packet1Xf half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<float, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasSin = EIGEN_FAST_MATH,
-    HasCos = EIGEN_FAST_MATH,
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1,
-    HasTanh = EIGEN_FAST_MATH,
-    HasErf = EIGEN_FAST_MATH
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
-typedef Packet4Xf PacketXf;
-
-template <>
-struct packet_traits<float> : default_packet_traits {
-  typedef Packet4Xf type;
-  typedef Packet2Xf half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<float, EIGEN_RISCV64_RVV_VL, 4>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasSin = EIGEN_FAST_MATH,
-    HasCos = EIGEN_FAST_MATH,
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1,
-    HasTanh = EIGEN_FAST_MATH,
-    HasErf = EIGEN_FAST_MATH
-  };
-};
-#endif
-
-template <>
-struct unpacket_traits<Packet1Xf> {
-  typedef float type;
-  typedef Packet1Xf half;  // Half not yet implemented
-  typedef Packet1Xi integer_packet;
-  typedef numext::uint8_t mask_t;
-  typedef PacketMask32 packet_mask;
-
-  enum {
-    size = rvv_packet_size_selector<float, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet2Xf> {
-  typedef float type;
-  typedef Packet1Xf half;
-  typedef Packet2Xi integer_packet;
-  typedef numext::uint8_t mask_t;
-  typedef PacketMask16 packet_mask;
-
-  enum {
-    size = rvv_packet_size_selector<float, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet4Xf> {
-  typedef float type;
-  typedef Packet2Xf half;
-  typedef Packet4Xi integer_packet;
-  typedef numext::uint8_t mask_t;
-  typedef PacketMask8 packet_mask;
-
-  enum {
-    size = rvv_packet_size_selector<float, EIGEN_RISCV64_RVV_VL, 4>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
 /********************************* Packet1Xf ************************************/
 
+EIGEN_STRONG_INLINE Packet1Xf __riscv_vreinterpret_v_u64m1_f32m1(const Packet1Xul& a) {
+  return __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vreinterpret_v_u64m1_u32m1(a));
+}
+
+EIGEN_STRONG_INLINE Packet2Xf __riscv_vreinterpret_v_u64m2_f32m2(const Packet2Xul& a) {
+  return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vreinterpret_v_u64m2_u32m2(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet1Xf ptrue<Packet1Xf>(const Packet1Xf& /*a*/) {
-  return __riscv_vreinterpret_f32m1(__riscv_vmv_v_x_u32m1(0xffffffffu, unpacket_traits<Packet1Xf>::size));
+  Packet1Xf r = __riscv_vreinterpret_f32m1(__riscv_vmv_v_x_u32m1(0xffffffffu, unpacket_traits<Packet1Xf>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -692,7 +350,7 @@
 template <>
 EIGEN_STRONG_INLINE void pbroadcast4<Packet1Xf>(const float* a, Packet1Xf& a0, Packet1Xf& a1, Packet1Xf& a2,
                                                 Packet1Xf& a3) {
-  vfloat32m1_t aa = __riscv_vle32_v_f32m1(a, 4);
+  Packet1Xf aa = __riscv_vle32_v_f32m1(a, 4);
   a0 = __riscv_vrgather_vx_f32m1(aa, 0, unpacket_traits<Packet1Xf>::size);
   a1 = __riscv_vrgather_vx_f32m1(aa, 1, unpacket_traits<Packet1Xf>::size);
   a2 = __riscv_vrgather_vx_f32m1(aa, 2, unpacket_traits<Packet1Xf>::size);
@@ -721,11 +379,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xf pconj(const Packet1Xf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xf pmul<Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
   return __riscv_vfmul_vv_f32m1(a, b, unpacket_traits<Packet1Xf>::size);
 }
@@ -756,6 +409,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet1Xf> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet1Xf pmin<Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
   Packet1Xf nans = __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet1Xf>::size);
   PacketMask32 mask = __riscv_vmfeq_vv_f32m1_b32(a, a, unpacket_traits<Packet1Xf>::size);
@@ -766,11 +422,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xf pmin<PropagateNaN, Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
-  return pmin<Packet1Xf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xf pmin<PropagateNumbers, Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
   return __riscv_vfmin_vv_f32m1(a, b, unpacket_traits<Packet1Xf>::size);
 }
@@ -786,11 +437,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xf pmax<PropagateNaN, Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
-  return pmax<Packet1Xf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xf pmax<PropagateNumbers, Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
   return __riscv_vfmax_vv_f32m1(a, b, unpacket_traits<Packet1Xf>::size);
 }
@@ -840,10 +486,21 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xf pandnot<Packet1Xf>(const Packet1Xf& a, const Packet1Xf& b) {
+#ifndef __riscv_zvbb
   return __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vand_vv_u32m1(
       __riscv_vreinterpret_v_f32m1_u32m1(a),
       __riscv_vnot_v_u32m1(__riscv_vreinterpret_v_f32m1_u32m1(b), unpacket_traits<Packet1Xf>::size),
       unpacket_traits<Packet1Xf>::size));
+#else
+  return __riscv_vreinterpret_v_u32m1_f32m1(__riscv_vandn_vv_u32m1(
+      __riscv_vreinterpret_v_f32m1_u32m1(a), __riscv_vreinterpret_v_f32m1_u32m1(b), unpacket_traits<Packet1Xi>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xf pnot<Packet1Xf>(const Packet1Xf& a) {
+  return __riscv_vreinterpret_v_u32m1_f32m1(
+      __riscv_vnot_v_u32m1(__riscv_vreinterpret_v_f32m1_u32m1(a), unpacket_traits<Packet1Xf>::size));
 }
 
 template <>
@@ -856,13 +513,18 @@
   EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle32_v_f32m1(from, unpacket_traits<Packet1Xf>::size);
 }
 
+EIGEN_STRONG_INLINE Packet2Xf pdup(const Packet1Xf& a) {
+  Packet2Xul data = __riscv_vwcvtu_x_x_v_u64m2(__riscv_vreinterpret_v_f32m1_u32m1(a), unpacket_traits<Packet1Xi>::size);
+  return __riscv_vreinterpret_v_u64m2_f32m2(__riscv_vadd_vv_u64m2(
+      __riscv_vsll_vx_u64m2(data, 32, unpacket_traits<Packet2Xl>::size), data, unpacket_traits<Packet2Xl>::size));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet1Xf ploaddup<Packet1Xf>(const float* from) {
-  Packet1Xu data = __riscv_vreinterpret_v_f32m1_u32m1(pload<Packet1Xf>(from));
-  return __riscv_vreinterpret_v_i32m1_f32m1(
-      __riscv_vreinterpret_v_i64m1_i32m1(__riscv_vreinterpret_v_u64m1_i64m1(__riscv_vlmul_trunc_v_u64m2_u64m1(
-          __riscv_vwmaccu_vx_u64m2(__riscv_vwaddu_vv_u64m2(data, data, unpacket_traits<Packet1Xi>::size), 0xffffffffu,
-                                   data, unpacket_traits<Packet1Xi>::size)))));
+  Packet1Xul data = __riscv_vlmul_trunc_v_u64m2_u64m1(__riscv_vwcvtu_x_x_v_u64m2(
+      __riscv_vreinterpret_v_f32m1_u32m1(pload<Packet1Xf>(from)), unpacket_traits<Packet1Xi>::size));
+  return __riscv_vreinterpret_v_u64m1_f32m1(__riscv_vadd_vv_u64m1(
+      __riscv_vsll_vx_u64m1(data, 32, unpacket_traits<Packet1Xl>::size), data, unpacket_traits<Packet1Xl>::size));
 }
 
 template <>
@@ -940,7 +602,26 @@
 template <>
 EIGEN_STRONG_INLINE float predux<Packet1Xf>(const Packet1Xf& a) {
   return __riscv_vfmv_f(__riscv_vfredusum_vs_f32m1_f32m1(
-      a, __riscv_vfmv_v_f_f32m1(0.0, unpacket_traits<Packet1Xf>::size), unpacket_traits<Packet1Xf>::size));
+      a, __riscv_vfmv_v_f_f32m1(0.0f, unpacket_traits<Packet1Xf>::size), unpacket_traits<Packet1Xf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet1Xf& a) {
+  const PacketMask32 mask =
+      __riscv_vmsne_vx_u32m1_b32(__riscv_vreinterpret_v_f32m1_u32m1(a), 0, unpacket_traits<Packet1Xf>::size);
+  return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet1Xf>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xf& a) {
+  const PacketMask32 mask = __riscv_vmfeq_vf_f32m1_b32(a, 0.0f, unpacket_traits<Packet1Xf>::size);
+  return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet1Xf>::size) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet1Xf& a) {
+  const PacketMask32 mask = __riscv_vmfne_vf_f32m1_b32(a, 0.0f, unpacket_traits<Packet1Xf>::size);
+  return static_cast<Index>(__riscv_vcpop_m_b32(mask, unpacket_traits<Packet1Xf>::size));
 }
 
 template <>
@@ -949,15 +630,15 @@
   Packet1Xf prod = __riscv_vfmul_vv_f32m1(preverse(a), a, unpacket_traits<Packet1Xf>::size);
   Packet1Xf half_prod;
 
-  if (EIGEN_RISCV64_RVV_VL >= 1024) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
     half_prod = __riscv_vslidedown_vx_f32m1(prod, 8, unpacket_traits<Packet1Xf>::size);
     prod = __riscv_vfmul_vv_f32m1(prod, half_prod, unpacket_traits<Packet1Xf>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 512) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
     half_prod = __riscv_vslidedown_vx_f32m1(prod, 4, unpacket_traits<Packet1Xf>::size);
     prod = __riscv_vfmul_vv_f32m1(prod, half_prod, unpacket_traits<Packet1Xf>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
     half_prod = __riscv_vslidedown_vx_f32m1(prod, 2, unpacket_traits<Packet1Xf>::size);
     prod = __riscv_vfmul_vv_f32m1(prod, half_prod, unpacket_traits<Packet1Xf>::size);
   }
@@ -969,22 +650,16 @@
   return pfirst(prod);
 }
 
+// Reusing the first lane is exact for an idempotent reduction and avoids a NaN seed that becomes poison under
+// finite fast-math.
 template <>
 EIGEN_STRONG_INLINE float predux_min<Packet1Xf>(const Packet1Xf& a) {
-  return (std::min)(
-      __riscv_vfmv_f(__riscv_vfredmin_vs_f32m1_f32m1(
-          a, __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet1Xf>::size),
-          unpacket_traits<Packet1Xf>::size)),
-      (std::numeric_limits<float>::max)());
+  return __riscv_vfmv_f(__riscv_vfredmin_vs_f32m1_f32m1(a, a, unpacket_traits<Packet1Xf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_max<Packet1Xf>(const Packet1Xf& a) {
-  return (std::max)(
-      __riscv_vfmv_f(__riscv_vfredmax_vs_f32m1_f32m1(
-          a, __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet1Xf>::size),
-          unpacket_traits<Packet1Xf>::size)),
-      -(std::numeric_limits<float>::max)());
+  return __riscv_vfmv_f(__riscv_vfredmax_vs_f32m1_f32m1(a, a, unpacket_traits<Packet1Xf>::size));
 }
 
 template <int N>
@@ -1017,6 +692,21 @@
   return __riscv_vmand_mm_b32(a, b, unpacket_traits<Packet1Xf>::size);
 }
 
+template <>
+EIGEN_STRONG_INLINE PacketMask32 pxor(const PacketMask32& a, const PacketMask32& b) {
+  return __riscv_vmxor_mm_b32(a, b, unpacket_traits<Packet1Xf>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask32 pandnot(const PacketMask32& a, const PacketMask32& b) {
+  return __riscv_vmandn_mm_b32(a, b, unpacket_traits<Packet1Xf>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask32 pnot(const PacketMask32& a) {
+  return __riscv_vmnot_m_b32(a, unpacket_traits<Packet1Xf>::size);
+}
+
 EIGEN_STRONG_INLINE PacketMask32 pcmp_eq_mask(const Packet1Xf& a, const Packet1Xf& b) {
   return __riscv_vmfeq_vv_f32m1_b32(a, b, unpacket_traits<Packet1Xf>::size);
 }
@@ -1035,159 +725,6 @@
   return __riscv_vmerge_vvm_f32m1(b, a, mask2, unpacket_traits<Packet1Xf>::size);
 }
 
-/********************************* int64 **************************************/
-
-typedef eigen_packet_wrapper<vint64m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 9> Packet1Xl;
-typedef eigen_packet_wrapper<vuint64m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 10> Packet1Xul;
-
-typedef eigen_packet_wrapper<vint64m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 11> Packet2Xl;
-typedef eigen_packet_wrapper<vuint64m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 12>
-    Packet2Xul;
-
-typedef eigen_packet_wrapper<vint64m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 13> Packet4Xl;
-typedef eigen_packet_wrapper<vuint64m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 14>
-    Packet4Xul;
-
-#if EIGEN_RISCV64_DEFAULT_LMUL == 1
-typedef Packet1Xl PacketXl;
-typedef Packet1Xul PacketXul;
-
-template <>
-struct packet_traits<numext::int64_t> : default_packet_traits {
-  typedef Packet1Xl type;
-  typedef Packet1Xl half;  // Half not implemented yet
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int64_t, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
-typedef Packet2Xl PacketXl;
-typedef Packet2Xul PacketXul;
-
-template <>
-struct packet_traits<numext::int64_t> : default_packet_traits {
-  typedef Packet2Xl type;
-  typedef Packet1Xl half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int64_t, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
-typedef Packet4Xl PacketXl;
-typedef Packet4Xul PacketXul;
-
-template <>
-struct packet_traits<numext::int64_t> : default_packet_traits {
-  typedef Packet4Xl type;
-  typedef Packet2Xl half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int64_t, EIGEN_RISCV64_RVV_VL, 4>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-#endif
-
-template <>
-struct unpacket_traits<Packet1Xl> {
-  typedef numext::int64_t type;
-  typedef Packet1Xl half;  // Half not yet implemented
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int64_t, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet2Xl> {
-  typedef numext::int64_t type;
-  typedef Packet1Xl half;
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int64_t, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet4Xl> {
-  typedef numext::int64_t type;
-  typedef Packet2Xl half;
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int64_t, EIGEN_RISCV64_RVV_VL, 4>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-EIGEN_STRONG_INLINE void prefetch<numext::int64_t>(const numext::int64_t* addr) {
-#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
-  __builtin_prefetch(addr);
-#endif
-}
-
 /********************************* Packet1Xl ************************************/
 
 template <>
@@ -1222,11 +759,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xl pconj(const Packet1Xl& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xl pmul<Packet1Xl>(const Packet1Xl& a, const Packet1Xl& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet1Xl>::size);
 }
@@ -1300,29 +832,39 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE Packet1Xl pnot<Packet1Xl>(const Packet1Xl& a) {
+  return __riscv_vnot_v_i64m1(a, unpacket_traits<Packet1Xl>::size);
+}
+
+template <>
 EIGEN_STRONG_INLINE Packet1Xl pxor<Packet1Xl>(const Packet1Xl& a, const Packet1Xl& b) {
   return __riscv_vxor_vv_i64m1(a, b, unpacket_traits<Packet1Xl>::size);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xl pandnot<Packet1Xl>(const Packet1Xl& a, const Packet1Xl& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i64m1(a, __riscv_vnot_v_i64m1(b, unpacket_traits<Packet1Xl>::size),
                                unpacket_traits<Packet1Xl>::size);
+#else
+  return __riscv_vreinterpret_v_u64m1_i64m1(__riscv_vandn_vv_u64m1(
+      __riscv_vreinterpret_v_i64m1_u64m1(a), __riscv_vreinterpret_v_i64m1_u64m1(b), unpacket_traits<Packet1Xl>::size));
+#endif
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xl parithmetic_shift_right(Packet1Xl a) {
+EIGEN_STRONG_INLINE Packet1Xl parithmetic_shift_right(const Packet1Xl& a) {
   return __riscv_vsra_vx_i64m1(a, N, unpacket_traits<Packet1Xl>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xl plogical_shift_right(Packet1Xl a) {
+EIGEN_STRONG_INLINE Packet1Xl plogical_shift_right(const Packet1Xl& a) {
   return __riscv_vreinterpret_i64m1(
       __riscv_vsrl_vx_u64m1(__riscv_vreinterpret_u64m1(a), N, unpacket_traits<Packet1Xl>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xl plogical_shift_left(Packet1Xl a) {
+EIGEN_STRONG_INLINE Packet1Xl plogical_shift_left(const Packet1Xl& a) {
   return __riscv_vsll_vx_i64m1(a, N, unpacket_traits<Packet1Xl>::size);
 }
 
@@ -1397,20 +939,26 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xl& a) {
+  const PacketMask64 mask = __riscv_vmseq_vx_i64m1_b64(a, 0, unpacket_traits<Packet1Xl>::size);
+  return __riscv_vcpop_m_b64(mask, unpacket_traits<Packet1Xl>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int64_t predux_mul<Packet1Xl>(const Packet1Xl& a) {
   // Multiply the vector by its reverse
   Packet1Xl prod = __riscv_vmul_vv_i64m1(preverse(a), a, unpacket_traits<Packet1Xl>::size);
   Packet1Xl half_prod;
 
-  if (EIGEN_RISCV64_RVV_VL >= 1024) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
     half_prod = __riscv_vslidedown_vx_i64m1(prod, 4, unpacket_traits<Packet1Xl>::size);
     prod = __riscv_vmul_vv_i64m1(prod, half_prod, unpacket_traits<Packet1Xl>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 512) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
     half_prod = __riscv_vslidedown_vx_i64m1(prod, 2, unpacket_traits<Packet1Xl>::size);
     prod = __riscv_vmul_vv_i64m1(prod, half_prod, unpacket_traits<Packet1Xl>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
     half_prod = __riscv_vslidedown_vx_i64m1(prod, 1, unpacket_traits<Packet1Xl>::size);
     prod = __riscv_vmul_vv_i64m1(prod, half_prod, unpacket_traits<Packet1Xl>::size);
   }
@@ -1447,185 +995,14 @@
   }
 }
 
-/********************************* double ************************************/
-
-typedef eigen_packet_wrapper<vfloat64m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 15> Packet1Xd;
-typedef eigen_packet_wrapper<vfloat64m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 16>
-    Packet2Xd;
-typedef eigen_packet_wrapper<vfloat64m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 17>
-    Packet4Xd;
-
-#if EIGEN_RISCV64_DEFAULT_LMUL == 1
-typedef Packet1Xd PacketXd;
-
-template <>
-struct packet_traits<double> : default_packet_traits {
-  typedef Packet1Xd type;
-  typedef Packet1Xd half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<double, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
-typedef Packet2Xd PacketXd;
-
-template <>
-struct packet_traits<double> : default_packet_traits {
-  typedef Packet2Xd type;
-  typedef Packet1Xd half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<double, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
-typedef Packet4Xd PacketXd;
-
-template <>
-struct packet_traits<double> : default_packet_traits {
-  typedef Packet4Xd type;
-  typedef Packet2Xd half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<double, EIGEN_RISCV64_RVV_VL, 4>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasLog = 1,
-    HasExp = 1,
-    HasSqrt = 1
-  };
-};
-#endif
-
-template <>
-struct unpacket_traits<Packet1Xd> {
-  typedef double type;
-  typedef Packet1Xd half;  // Half not yet implemented
-  typedef Packet1Xl integer_packet;
-  typedef numext::uint8_t mask_t;
-  typedef PacketMask64 packet_mask;
-
-  enum {
-    size = rvv_packet_size_selector<double, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet2Xd> {
-  typedef double type;
-  typedef Packet1Xd half;
-  typedef Packet2Xl integer_packet;
-  typedef numext::uint8_t mask_t;
-  typedef PacketMask32 packet_mask;
-
-  enum {
-    size = rvv_packet_size_selector<double, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet4Xd> {
-  typedef double type;
-  typedef Packet2Xd half;
-  typedef Packet4Xl integer_packet;
-  typedef numext::uint8_t mask_t;
-  typedef PacketMask16 packet_mask;
-
-  enum {
-    size = rvv_packet_size_selector<double, EIGEN_RISCV64_RVV_VL, 4>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
 /********************************* Packet1Xd ************************************/
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xd ptrue<Packet1Xd>(const Packet1Xd& /*a*/) {
-  return __riscv_vreinterpret_f64m1(__riscv_vmv_v_x_u64m1(0xffffffffffffffffu, unpacket_traits<Packet1Xd>::size));
+  Packet1Xd r =
+      __riscv_vreinterpret_f64m1(__riscv_vmv_v_x_u64m1(0xffffffffffffffffu, unpacket_traits<Packet1Xd>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -1665,15 +1042,16 @@
 template <>
 EIGEN_STRONG_INLINE void pbroadcast4<Packet1Xd>(const double* a, Packet1Xd& a0, Packet1Xd& a1, Packet1Xd& a2,
                                                 Packet1Xd& a3) {
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
-    vfloat64m1_t aa = __riscv_vle64_v_f64m1(a, 4);
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
+    Packet1Xd aa = __riscv_vle64_v_f64m1(a, 4);
     a0 = __riscv_vrgather_vx_f64m1(aa, 0, unpacket_traits<Packet1Xd>::size);
     a1 = __riscv_vrgather_vx_f64m1(aa, 1, unpacket_traits<Packet1Xd>::size);
     a2 = __riscv_vrgather_vx_f64m1(aa, 2, unpacket_traits<Packet1Xd>::size);
     a3 = __riscv_vrgather_vx_f64m1(aa, 3, unpacket_traits<Packet1Xd>::size);
   } else {
-    vfloat64m1_t aa0 = __riscv_vle64_v_f64m1(a + 0, 2);
-    vfloat64m1_t aa1 = __riscv_vle64_v_f64m1(a + 2, 2);
+    Packet2Xd aa = __riscv_vle64_v_f64m2(a, 4);
+    Packet1Xd aa0 = __riscv_vget_v_f64m2_f64m1(aa, 0);
+    Packet1Xd aa1 = __riscv_vget_v_f64m2_f64m1(aa, 1);
     a0 = __riscv_vrgather_vx_f64m1(aa0, 0, unpacket_traits<Packet1Xd>::size);
     a1 = __riscv_vrgather_vx_f64m1(aa0, 1, unpacket_traits<Packet1Xd>::size);
     a2 = __riscv_vrgather_vx_f64m1(aa1, 0, unpacket_traits<Packet1Xd>::size);
@@ -1703,11 +1081,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xd pconj(const Packet1Xd& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xd pmul<Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
   return __riscv_vfmul_vv_f64m1(a, b, unpacket_traits<Packet1Xd>::size);
 }
@@ -1738,6 +1111,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet1Xd> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet1Xd pmin<Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
   Packet1Xd nans = __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet1Xd>::size);
   PacketMask64 mask = __riscv_vmfeq_vv_f64m1_b64(a, a, unpacket_traits<Packet1Xd>::size);
@@ -1748,11 +1124,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xd pmin<PropagateNaN, Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
-  return pmin<Packet1Xd>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xd pmin<PropagateNumbers, Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
   return __riscv_vfmin_vv_f64m1(a, b, unpacket_traits<Packet1Xd>::size);
 }
@@ -1768,11 +1139,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xd pmax<PropagateNaN, Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
-  return pmax<Packet1Xd>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xd pmax<PropagateNumbers, Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
   return __riscv_vfmax_vv_f64m1(a, b, unpacket_traits<Packet1Xd>::size);
 }
@@ -1822,10 +1188,21 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xd pandnot<Packet1Xd>(const Packet1Xd& a, const Packet1Xd& b) {
+#ifndef __riscv_zvbb
   return __riscv_vreinterpret_v_u64m1_f64m1(__riscv_vand_vv_u64m1(
       __riscv_vreinterpret_v_f64m1_u64m1(a),
       __riscv_vnot_v_u64m1(__riscv_vreinterpret_v_f64m1_u64m1(b), unpacket_traits<Packet1Xd>::size),
       unpacket_traits<Packet1Xd>::size));
+#else
+  return __riscv_vreinterpret_v_u64m1_f64m1(__riscv_vandn_vv_u64m1(
+      __riscv_vreinterpret_v_f64m1_u64m1(a), __riscv_vreinterpret_v_f64m1_u64m1(b), unpacket_traits<Packet1Xl>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xd pnot<Packet1Xd>(const Packet1Xd& a) {
+  return __riscv_vreinterpret_v_u64m1_f64m1(
+      __riscv_vnot_v_u64m1(__riscv_vreinterpret_v_f64m1_u64m1(a), unpacket_traits<Packet1Xd>::size));
 }
 
 template <>
@@ -1838,6 +1215,12 @@
   EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle64_v_f64m1(from, unpacket_traits<Packet1Xd>::size);
 }
 
+EIGEN_STRONG_INLINE Packet2Xd pdup(const Packet1Xd& a) {
+  Packet2Xul idx =
+      __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
+  return __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(a), idx, unpacket_traits<Packet2Xd>::size);
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet1Xd ploaddup<Packet1Xd>(const double* from) {
   Packet1Xul idx =
@@ -1924,20 +1307,39 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet1Xd& a) {
+  const PacketMask64 mask =
+      __riscv_vmsne_vx_u64m1_b64(__riscv_vreinterpret_v_f64m1_u64m1(a), 0, unpacket_traits<Packet1Xd>::size);
+  return __riscv_vcpop_m_b64(mask, unpacket_traits<Packet1Xd>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xd& a) {
+  const PacketMask64 mask = __riscv_vmfeq_vf_f64m1_b64(a, 0.0, unpacket_traits<Packet1Xd>::size);
+  return __riscv_vcpop_m_b64(mask, unpacket_traits<Packet1Xd>::size) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet1Xd& a) {
+  const PacketMask64 mask = __riscv_vmfne_vf_f64m1_b64(a, 0.0, unpacket_traits<Packet1Xd>::size);
+  return static_cast<Index>(__riscv_vcpop_m_b64(mask, unpacket_traits<Packet1Xd>::size));
+}
+
+template <>
 EIGEN_STRONG_INLINE double predux_mul<Packet1Xd>(const Packet1Xd& a) {
   // Multiply the vector by its reverse
   Packet1Xd prod = __riscv_vfmul_vv_f64m1(preverse(a), a, unpacket_traits<Packet1Xd>::size);
   Packet1Xd half_prod;
 
-  if (EIGEN_RISCV64_RVV_VL >= 1024) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
     half_prod = __riscv_vslidedown_vx_f64m1(prod, 4, unpacket_traits<Packet1Xd>::size);
     prod = __riscv_vfmul_vv_f64m1(prod, half_prod, unpacket_traits<Packet1Xd>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 512) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
     half_prod = __riscv_vslidedown_vx_f64m1(prod, 2, unpacket_traits<Packet1Xd>::size);
     prod = __riscv_vfmul_vv_f64m1(prod, half_prod, unpacket_traits<Packet1Xd>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
     half_prod = __riscv_vslidedown_vx_f64m1(prod, 1, unpacket_traits<Packet1Xd>::size);
     prod = __riscv_vfmul_vv_f64m1(prod, half_prod, unpacket_traits<Packet1Xd>::size);
   }
@@ -1948,20 +1350,12 @@
 
 template <>
 EIGEN_STRONG_INLINE double predux_min<Packet1Xd>(const Packet1Xd& a) {
-  return (std::min)(
-      __riscv_vfmv_f(__riscv_vfredmin_vs_f64m1_f64m1(
-          a, __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet1Xd>::size),
-          unpacket_traits<Packet1Xd>::size)),
-      (std::numeric_limits<double>::max)());
+  return __riscv_vfmv_f(__riscv_vfredmin_vs_f64m1_f64m1(a, a, unpacket_traits<Packet1Xd>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_max<Packet1Xd>(const Packet1Xd& a) {
-  return (std::max)(
-      __riscv_vfmv_f(__riscv_vfredmax_vs_f64m1_f64m1(
-          a, __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet1Xd>::size),
-          unpacket_traits<Packet1Xd>::size)),
-      -(std::numeric_limits<double>::max)());
+  return __riscv_vfmv_f(__riscv_vfredmax_vs_f64m1_f64m1(a, a, unpacket_traits<Packet1Xd>::size));
 }
 
 template <int N>
@@ -1991,7 +1385,7 @@
 
 template <>
 EIGEN_STRONG_INLINE PacketMask64 pandnot(const PacketMask64& a, const PacketMask64& b) {
-  return __riscv_vmor_mm_b64(a, b, unpacket_traits<Packet1Xd>::size);
+  return __riscv_vmnand_mm_b64(a, b, unpacket_traits<Packet1Xd>::size);
 }
 
 template <>
@@ -1999,6 +1393,16 @@
   return __riscv_vmand_mm_b64(a, b, unpacket_traits<Packet1Xd>::size);
 }
 
+template <>
+EIGEN_STRONG_INLINE PacketMask64 pxor(const PacketMask64& a, const PacketMask64& b) {
+  return __riscv_vmxor_mm_b64(a, b, unpacket_traits<Packet1Xd>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask64 pnot(const PacketMask64& a) {
+  return __riscv_vmnot_m_b64(a, unpacket_traits<Packet1Xd>::size);
+}
+
 EIGEN_STRONG_INLINE PacketMask64 pcmp_eq_mask(const Packet1Xd& a, const Packet1Xd& b) {
   return __riscv_vmfeq_vv_f64m1_b64(a, b, unpacket_traits<Packet1Xd>::size);
 }
@@ -2017,161 +1421,12 @@
   return __riscv_vmerge_vvm_f64m1(b, a, mask2, unpacket_traits<Packet1Xd>::size);
 }
 
-/********************************* short **************************************/
-
-typedef eigen_packet_wrapper<vint16m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 18> Packet1Xs;
-typedef eigen_packet_wrapper<vuint16m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 19> Packet1Xsu;
-
-typedef eigen_packet_wrapper<vint16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 20> Packet2Xs;
-typedef eigen_packet_wrapper<vuint16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 21>
-    Packet2Xsu;
-
-typedef eigen_packet_wrapper<vint16m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 22> Packet4Xs;
-typedef eigen_packet_wrapper<vuint16m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 23>
-    Packet4Xsu;
-
-#if EIGEN_RISCV64_DEFAULT_LMUL == 1
-typedef Packet1Xs PacketXs;
-typedef Packet1Xsu PacketXsu;
-
-template <>
-struct packet_traits<numext::int16_t> : default_packet_traits {
-  typedef Packet1Xs type;
-  typedef Packet1Xs half;  // Half not implemented yet
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int16_t, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
-typedef Packet2Xs PacketXs;
-typedef Packet2Xsu PacketXsu;
-
-template <>
-struct packet_traits<numext::int16_t> : default_packet_traits {
-  typedef Packet2Xs type;
-  typedef Packet1Xs half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int16_t, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-
-#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
-typedef Packet4Xs PacketXs;
-typedef Packet4Xsu PacketXsu;
-
-template <>
-struct packet_traits<numext::int16_t> : default_packet_traits {
-  typedef Packet4Xs type;
-  typedef Packet2Xs half;
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<numext::int16_t, EIGEN_RISCV64_RVV_VL, 4>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0
-  };
-};
-#endif
-
-template <>
-struct unpacket_traits<Packet1Xs> {
-  typedef numext::int16_t type;
-  typedef Packet1Xs half;  // Half not yet implemented
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int16_t, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet2Xs> {
-  typedef numext::int16_t type;
-  typedef Packet1Xs half;
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int16_t, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-struct unpacket_traits<Packet4Xs> {
-  typedef numext::int16_t type;
-  typedef Packet2Xs half;
-  typedef numext::uint8_t mask_t;
-  enum {
-    size = rvv_packet_size_selector<numext::int16_t, EIGEN_RISCV64_RVV_VL, 4>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 4>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
-
-template <>
-EIGEN_STRONG_INLINE void prefetch<numext::int16_t>(const numext::int16_t* addr) {
-#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
-  __builtin_prefetch(addr);
-#endif
-}
-
 /********************************* Packet1Xs ************************************/
 
+EIGEN_STRONG_INLINE Packet1Xs __riscv_vreinterpret_v_u32m1_i16m1(const Packet1Xu& a) {
+  return __riscv_vreinterpret_v_i32m1_i16m1(__riscv_vreinterpret_v_u32m1_i32m1(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet1Xs pset1<Packet1Xs>(const numext::int16_t& from) {
   return __riscv_vmv_v_x_i16m1(from, unpacket_traits<Packet1Xs>::size);
@@ -2204,11 +1459,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xs pconj(const Packet1Xs& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xs pmul<Packet1Xs>(const Packet1Xs& a, const Packet1Xs& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet1Xs>::size);
 }
@@ -2287,24 +1537,34 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE Packet1Xs pnot<Packet1Xs>(const Packet1Xs& a) {
+  return __riscv_vnot_v_i16m1(a, unpacket_traits<Packet1Xs>::size);
+}
+
+template <>
 EIGEN_STRONG_INLINE Packet1Xs pandnot<Packet1Xs>(const Packet1Xs& a, const Packet1Xs& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i16m1(a, __riscv_vnot_v_i16m1(b, unpacket_traits<Packet1Xs>::size),
                                unpacket_traits<Packet1Xs>::size);
+#else
+  return __riscv_vreinterpret_v_u16m1_i16m1(__riscv_vandn_vv_u16m1(
+      __riscv_vreinterpret_v_i16m1_u16m1(a), __riscv_vreinterpret_v_i16m1_u16m1(b), unpacket_traits<Packet1Xs>::size));
+#endif
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xs parithmetic_shift_right(Packet1Xs a) {
+EIGEN_STRONG_INLINE Packet1Xs parithmetic_shift_right(const Packet1Xs& a) {
   return __riscv_vsra_vx_i16m1(a, N, unpacket_traits<Packet1Xs>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xs plogical_shift_right(Packet1Xs a) {
+EIGEN_STRONG_INLINE Packet1Xs plogical_shift_right(const Packet1Xs& a) {
   return __riscv_vreinterpret_i16m1(
       __riscv_vsrl_vx_u16m1(__riscv_vreinterpret_u16m1(a), N, unpacket_traits<Packet1Xs>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet1Xs plogical_shift_left(Packet1Xs a) {
+EIGEN_STRONG_INLINE Packet1Xs plogical_shift_left(const Packet1Xs& a) {
   return __riscv_vsll_vx_i16m1(a, N, unpacket_traits<Packet1Xs>::size);
 }
 
@@ -2320,10 +1580,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xs ploaddup<Packet1Xs>(const numext::int16_t* from) {
-  Packet1Xsu data = __riscv_vreinterpret_v_i16m1_u16m1(pload<Packet1Xs>(from));
-  return __riscv_vreinterpret_v_i32m1_i16m1(__riscv_vreinterpret_v_u32m1_i32m1(__riscv_vlmul_trunc_v_u32m2_u32m1(
-      __riscv_vwmaccu_vx_u32m2(__riscv_vwaddu_vv_u32m2(data, data, unpacket_traits<Packet1Xs>::size), 0xffffu, data,
-                               unpacket_traits<Packet1Xs>::size))));
+  Packet1Xu data = __riscv_vlmul_trunc_v_u32m2_u32m1(__riscv_vwcvtu_x_x_v_u32m2(
+      __riscv_vreinterpret_v_i16m1_u16m1(pload<Packet1Xs>(from)), unpacket_traits<Packet1Xs>::size));
+  return __riscv_vreinterpret_v_u32m1_i16m1(__riscv_vadd_vv_u32m1(
+      __riscv_vsll_vx_u32m1(data, 16, unpacket_traits<Packet1Xi>::size), data, unpacket_traits<Packet1Xi>::size));
 }
 
 template <>
@@ -2380,20 +1640,26 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xs& a) {
+  const PacketMask16 mask = __riscv_vmseq_vx_i16m1_b16(a, 0, unpacket_traits<Packet1Xs>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xs>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int16_t predux_mul<Packet1Xs>(const Packet1Xs& a) {
   // Multiply the vector by its reverse
   Packet1Xs prod = __riscv_vmul_vv_i16m1(preverse(a), a, unpacket_traits<Packet1Xs>::size);
   Packet1Xs half_prod;
 
-  if (EIGEN_RISCV64_RVV_VL >= 1024) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
     half_prod = __riscv_vslidedown_vx_i16m1(prod, 16, unpacket_traits<Packet1Xs>::size);
     prod = __riscv_vmul_vv_i16m1(prod, half_prod, unpacket_traits<Packet1Xs>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 512) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
     half_prod = __riscv_vslidedown_vx_i16m1(prod, 8, unpacket_traits<Packet1Xs>::size);
     prod = __riscv_vmul_vv_i16m1(prod, half_prod, unpacket_traits<Packet1Xs>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
     half_prod = __riscv_vslidedown_vx_i16m1(prod, 4, unpacket_traits<Packet1Xs>::size);
     prod = __riscv_vmul_vv_i16m1(prod, half_prod, unpacket_traits<Packet1Xs>::size);
   }
@@ -2436,6 +1702,31 @@
   }
 }
 
+template <>
+EIGEN_STRONG_INLINE PacketMask16 por(const PacketMask16& a, const PacketMask16& b) {
+  return __riscv_vmor_mm_b16(a, b, unpacket_traits<Packet1Xs>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask16 pand(const PacketMask16& a, const PacketMask16& b) {
+  return __riscv_vmand_mm_b16(a, b, unpacket_traits<Packet1Xs>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask16 pxor(const PacketMask16& a, const PacketMask16& b) {
+  return __riscv_vmxor_mm_b16(a, b, unpacket_traits<Packet1Xs>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask16 pandnot(const PacketMask16& a, const PacketMask16& b) {
+  return __riscv_vmandn_mm_b16(a, b, unpacket_traits<Packet1Xs>::size);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketMask16 pnot(const PacketMask16& a) {
+  return __riscv_vmnot_m_b16(a, unpacket_traits<Packet1Xs>::size);
+}
+
 }  // namespace internal
 }  // namespace Eigen
 
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath2.h b/Eigen/src/Core/arch/RVV10/PacketMath2.h
index d99a154..4af0751 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath2.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath2.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET2_MATH_RVV10_H
 #define EIGEN_PACKET2_MATH_RVV10_H
@@ -19,6 +20,10 @@
 
 /********************************* Packet2Xi ************************************/
 
+EIGEN_STRONG_INLINE Packet2Xi __riscv_vreinterpret_v_u64m2_i32m2(const Packet2Xul& a) {
+  return __riscv_vreinterpret_v_i64m2_i32m2(__riscv_vreinterpret_v_u64m2_i64m2(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet2Xi pset1<Packet2Xi>(const numext::int32_t& from) {
   return __riscv_vmv_v_x_i32m2(from, unpacket_traits<Packet2Xi>::size);
@@ -51,11 +56,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xi pconj(const Packet2Xi& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xi pmul<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet2Xi>::size);
 }
@@ -135,23 +135,33 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xi pandnot<Packet2Xi>(const Packet2Xi& a, const Packet2Xi& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i32m2(a, __riscv_vnot_v_i32m2(b, unpacket_traits<Packet2Xi>::size),
                                unpacket_traits<Packet2Xi>::size);
+#else
+  return __riscv_vreinterpret_v_u32m2_i32m2(__riscv_vandn_vv_u32m2(
+      __riscv_vreinterpret_v_i32m2_u32m2(a), __riscv_vreinterpret_v_i32m2_u32m2(b), unpacket_traits<Packet2Xi>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xi pnot<Packet2Xi>(const Packet2Xi& a) {
+  return __riscv_vnot_v_i32m2(a, unpacket_traits<Packet2Xi>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xi parithmetic_shift_right(Packet2Xi a) {
+EIGEN_STRONG_INLINE Packet2Xi parithmetic_shift_right(const Packet2Xi& a) {
   return __riscv_vsra_vx_i32m2(a, N, unpacket_traits<Packet2Xi>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xi plogical_shift_right(Packet2Xi a) {
+EIGEN_STRONG_INLINE Packet2Xi plogical_shift_right(const Packet2Xi& a) {
   return __riscv_vreinterpret_i32m2(
       __riscv_vsrl_vx_u32m2(__riscv_vreinterpret_u32m2(a), N, unpacket_traits<Packet2Xi>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xi plogical_shift_left(Packet2Xi a) {
+EIGEN_STRONG_INLINE Packet2Xi plogical_shift_left(const Packet2Xi& a) {
   return __riscv_vsll_vx_i32m2(a, N, unpacket_traits<Packet2Xi>::size);
 }
 
@@ -167,10 +177,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xi ploaddup<Packet2Xi>(const numext::int32_t* from) {
-  Packet2Xu data = __riscv_vreinterpret_v_i32m2_u32m2(pload<Packet2Xi>(from));
-  return __riscv_vreinterpret_v_i64m2_i32m2(__riscv_vreinterpret_v_u64m2_i64m2(__riscv_vlmul_trunc_v_u64m4_u64m2(
-      __riscv_vwmaccu_vx_u64m4(__riscv_vwaddu_vv_u64m4(data, data, unpacket_traits<Packet2Xi>::size), 0xffffffffu, data,
-                               unpacket_traits<Packet2Xi>::size))));
+  Packet2Xul data = __riscv_vlmul_trunc_v_u64m4_u64m2(__riscv_vwcvtu_x_x_v_u64m4(
+      __riscv_vreinterpret_v_i32m2_u32m2(pload<Packet2Xi>(from)), unpacket_traits<Packet2Xi>::size));
+  return __riscv_vreinterpret_v_u64m2_i32m2(__riscv_vadd_vv_u64m2(
+      __riscv_vsll_vx_u64m2(data, 32, unpacket_traits<Packet2Xl>::size), data, unpacket_traits<Packet2Xl>::size));
 }
 
 template <>
@@ -227,6 +237,12 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xi& a) {
+  const PacketMask16 mask = __riscv_vmseq_vx_i32m2_b16(a, 0, unpacket_traits<Packet2Xi>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xi>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int32_t predux_mul<Packet2Xi>(const Packet2Xi& a) {
   return predux_mul<Packet1Xi>(__riscv_vmul_vv_i32m1(__riscv_vget_v_i32m2_i32m1(a, 0), __riscv_vget_v_i32m2_i32m1(a, 1),
                                                      unpacket_traits<Packet1Xi>::size));
@@ -260,19 +276,9 @@
   }
 }
 
-template <typename Packet = Packet4Xi>
-EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet4Xi>::value && (unpacket_traits<Packet4Xi>::size % 8) == 0,
-                            Packet2Xi>::type
-    predux_half(const Packet4Xi& a) {
-  return __riscv_vadd_vv_i32m2(__riscv_vget_v_i32m4_i32m2(a, 0), __riscv_vget_v_i32m4_i32m2(a, 1),
-                               unpacket_traits<Packet2Xi>::size);
-}
-
 template <typename Packet = Packet2Xi>
 EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xi>::value && (unpacket_traits<Packet2Xi>::size % 8) == 0,
-                            Packet1Xi>::type
+    std::enable_if_t<std::is_same<Packet, Packet2Xi>::value && (unpacket_traits<Packet2Xi>::size % 8) == 0, Packet1Xi>
     predux_half(const Packet2Xi& a) {
   return __riscv_vadd_vv_i32m1(__riscv_vget_v_i32m2_i32m1(a, 0), __riscv_vget_v_i32m2_i32m1(a, 1),
                                unpacket_traits<Packet1Xi>::size);
@@ -280,9 +286,15 @@
 
 /********************************* Packet2Xf ************************************/
 
+EIGEN_STRONG_INLINE Packet4Xf __riscv_vreinterpret_v_u64m4_f32m4(const Packet4Xul& a) {
+  return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vreinterpret_v_u64m4_u32m4(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet2Xf ptrue<Packet2Xf>(const Packet2Xf& /*a*/) {
-  return __riscv_vreinterpret_f32m2(__riscv_vmv_v_x_u32m2(0xffffffffu, unpacket_traits<Packet2Xf>::size));
+  Packet2Xf r = __riscv_vreinterpret_f32m2(__riscv_vmv_v_x_u32m2(0xffffffffu, unpacket_traits<Packet2Xf>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -322,7 +334,7 @@
 template <>
 EIGEN_STRONG_INLINE void pbroadcast4<Packet2Xf>(const float* a, Packet2Xf& a0, Packet2Xf& a1, Packet2Xf& a2,
                                                 Packet2Xf& a3) {
-  vfloat32m2_t aa = __riscv_vle32_v_f32m2(a, 4);
+  Packet2Xf aa = __riscv_vlmul_ext_f32m2(__riscv_vle32_v_f32m1(a, 4));
   a0 = __riscv_vrgather_vx_f32m2(aa, 0, unpacket_traits<Packet2Xf>::size);
   a1 = __riscv_vrgather_vx_f32m2(aa, 1, unpacket_traits<Packet2Xf>::size);
   a2 = __riscv_vrgather_vx_f32m2(aa, 2, unpacket_traits<Packet2Xf>::size);
@@ -351,11 +363,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xf pconj(const Packet2Xf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xf pmul<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
   return __riscv_vfmul_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
 }
@@ -386,6 +393,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet2Xf> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet2Xf pmin<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
   Packet2Xf nans = __riscv_vfmv_v_f_f32m2((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet2Xf>::size);
   PacketMask16 mask = __riscv_vmfeq_vv_f32m2_b16(a, a, unpacket_traits<Packet2Xf>::size);
@@ -396,11 +406,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xf pmin<PropagateNaN, Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
-  return pmin<Packet2Xf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xf pmin<PropagateNumbers, Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
   return __riscv_vfmin_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
 }
@@ -416,11 +421,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xf pmax<PropagateNaN, Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
-  return pmax<Packet2Xf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xf pmax<PropagateNumbers, Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
   return __riscv_vfmax_vv_f32m2(a, b, unpacket_traits<Packet2Xf>::size);
 }
@@ -480,10 +480,21 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xf pandnot<Packet2Xf>(const Packet2Xf& a, const Packet2Xf& b) {
+#ifndef __riscv_zvbb
   return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vand_vv_u32m2(
       __riscv_vreinterpret_v_f32m2_u32m2(a),
       __riscv_vnot_v_u32m2(__riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xf>::size),
       unpacket_traits<Packet2Xf>::size));
+#else
+  return __riscv_vreinterpret_v_u32m2_f32m2(__riscv_vandn_vv_u32m2(
+      __riscv_vreinterpret_v_f32m2_u32m2(a), __riscv_vreinterpret_v_f32m2_u32m2(b), unpacket_traits<Packet2Xi>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xf pnot<Packet2Xf>(const Packet2Xf& a) {
+  return __riscv_vreinterpret_v_u32m2_f32m2(
+      __riscv_vnot_v_u32m2(__riscv_vreinterpret_v_f32m2_u32m2(a), unpacket_traits<Packet2Xf>::size));
 }
 
 template <>
@@ -496,13 +507,18 @@
   EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle32_v_f32m2(from, unpacket_traits<Packet2Xf>::size);
 }
 
+EIGEN_STRONG_INLINE Packet4Xf pdup(const Packet2Xf& a) {
+  Packet4Xul data = __riscv_vwcvtu_x_x_v_u64m4(__riscv_vreinterpret_v_f32m2_u32m2(a), unpacket_traits<Packet2Xi>::size);
+  return __riscv_vreinterpret_v_u64m4_f32m4(__riscv_vadd_vv_u64m4(
+      __riscv_vsll_vx_u64m4(data, 32, unpacket_traits<Packet4Xl>::size), data, unpacket_traits<Packet4Xl>::size));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet2Xf ploaddup<Packet2Xf>(const float* from) {
-  Packet2Xu data = __riscv_vreinterpret_v_f32m2_u32m2(pload<Packet2Xf>(from));
-  return __riscv_vreinterpret_v_i32m2_f32m2(
-      __riscv_vreinterpret_v_i64m2_i32m2(__riscv_vreinterpret_v_u64m2_i64m2(__riscv_vlmul_trunc_v_u64m4_u64m2(
-          __riscv_vwmaccu_vx_u64m4(__riscv_vwaddu_vv_u64m4(data, data, unpacket_traits<Packet2Xi>::size), 0xffffffffu,
-                                   data, unpacket_traits<Packet2Xi>::size)))));
+  Packet2Xul data = __riscv_vlmul_trunc_v_u64m4_u64m2(__riscv_vwcvtu_x_x_v_u64m4(
+      __riscv_vreinterpret_v_f32m2_u32m2(pload<Packet2Xf>(from)), unpacket_traits<Packet2Xi>::size));
+  return __riscv_vreinterpret_v_u64m2_f32m2(__riscv_vadd_vv_u64m2(
+      __riscv_vsll_vx_u64m2(data, 32, unpacket_traits<Packet2Xl>::size), data, unpacket_traits<Packet2Xl>::size));
 }
 
 template <>
@@ -580,7 +596,26 @@
 template <>
 EIGEN_STRONG_INLINE float predux<Packet2Xf>(const Packet2Xf& a) {
   return __riscv_vfmv_f(__riscv_vfredusum_vs_f32m2_f32m1(
-      a, __riscv_vfmv_v_f_f32m1(0.0, unpacket_traits<Packet2Xf>::size / 2), unpacket_traits<Packet2Xf>::size));
+      a, __riscv_vfmv_v_f_f32m1(0.0f, unpacket_traits<Packet2Xf>::size / 2), unpacket_traits<Packet2Xf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2Xf& a) {
+  const PacketMask16 mask =
+      __riscv_vmsne_vx_u32m2_b16(__riscv_vreinterpret_v_f32m2_u32m2(a), 0, unpacket_traits<Packet2Xf>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xf>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xf& a) {
+  const PacketMask16 mask = __riscv_vmfeq_vf_f32m2_b16(a, 0.0f, unpacket_traits<Packet2Xf>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xf>::size) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet2Xf& a) {
+  const PacketMask16 mask = __riscv_vmfne_vf_f32m2_b16(a, 0.0f, unpacket_traits<Packet2Xf>::size);
+  return static_cast<Index>(__riscv_vcpop_m_b16(mask, unpacket_traits<Packet2Xf>::size));
 }
 
 template <>
@@ -589,22 +624,24 @@
       __riscv_vget_v_f32m2_f32m1(a, 0), __riscv_vget_v_f32m2_f32m1(a, 1), unpacket_traits<Packet1Xf>::size));
 }
 
+// Reusing the first lane is exact for an idempotent reduction and avoids a NaN seed that becomes poison under
+// finite fast-math.
 template <>
 EIGEN_STRONG_INLINE float predux_min<Packet2Xf>(const Packet2Xf& a) {
-  return (std::min)(
-      __riscv_vfmv_f(__riscv_vfredmin_vs_f32m2_f32m1(
-          a, __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet2Xf>::size / 2),
-          unpacket_traits<Packet2Xf>::size)),
-      (std::numeric_limits<float>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmin_vs_f32m2_f32m1(a, __riscv_vget_v_f32m2_f32m1(a, 0), unpacket_traits<Packet2Xf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_max<Packet2Xf>(const Packet2Xf& a) {
-  return (std::max)(
-      __riscv_vfmv_f(__riscv_vfredmax_vs_f32m2_f32m1(
-          a, __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet2Xf>::size / 2),
-          unpacket_traits<Packet2Xf>::size)),
-      -(std::numeric_limits<float>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmax_vs_f32m2_f32m1(a, __riscv_vget_v_f32m2_f32m1(a, 0), unpacket_traits<Packet2Xf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xf predux_half(const Packet2Xf& a) {
+  return Packet1Xf(__riscv_vfadd_vv_f32m1(__riscv_vget_v_f32m2_f32m1(a, 0), __riscv_vget_v_f32m2_f32m1(a, 1),
+                                          unpacket_traits<Packet1Xf>::size));
 }
 
 template <int N>
@@ -627,19 +664,9 @@
   return pldexp_generic(a, exponent);
 }
 
-template <typename Packet = Packet4Xf>
-EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet4Xf>::value && (unpacket_traits<Packet4Xf>::size % 8) == 0,
-                            Packet2Xf>::type
-    predux_half(const Packet4Xf& a) {
-  return __riscv_vfadd_vv_f32m2(__riscv_vget_v_f32m4_f32m2(a, 0), __riscv_vget_v_f32m4_f32m2(a, 1),
-                                unpacket_traits<Packet2Xf>::size);
-}
-
 template <typename Packet = Packet2Xf>
 EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xf>::value && (unpacket_traits<Packet2Xf>::size % 8) == 0,
-                            Packet1Xf>::type
+    std::enable_if_t<std::is_same<Packet, Packet2Xf>::value && (unpacket_traits<Packet2Xf>::size % 8) == 0, Packet1Xf>
     predux_half(const Packet2Xf& a) {
   return __riscv_vfadd_vv_f32m1(__riscv_vget_v_f32m2_f32m1(a, 0), __riscv_vget_v_f32m2_f32m1(a, 1),
                                 unpacket_traits<Packet1Xf>::size);
@@ -679,11 +706,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xl pconj(const Packet2Xl& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xl pmul<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet2Xl>::size);
 }
@@ -757,29 +779,39 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE Packet2Xl pnot<Packet2Xl>(const Packet2Xl& a) {
+  return __riscv_vnot_v_i64m2(a, unpacket_traits<Packet2Xl>::size);
+}
+
+template <>
 EIGEN_STRONG_INLINE Packet2Xl pxor<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
   return __riscv_vxor_vv_i64m2(a, b, unpacket_traits<Packet2Xl>::size);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xl pandnot<Packet2Xl>(const Packet2Xl& a, const Packet2Xl& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i64m2(a, __riscv_vnot_v_i64m2(b, unpacket_traits<Packet2Xl>::size),
                                unpacket_traits<Packet2Xl>::size);
+#else
+  return __riscv_vreinterpret_v_u64m2_i64m2(__riscv_vandn_vv_u64m2(
+      __riscv_vreinterpret_v_i64m2_u64m2(a), __riscv_vreinterpret_v_i64m2_u64m2(b), unpacket_traits<Packet2Xl>::size));
+#endif
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xl parithmetic_shift_right(Packet2Xl a) {
+EIGEN_STRONG_INLINE Packet2Xl parithmetic_shift_right(const Packet2Xl& a) {
   return __riscv_vsra_vx_i64m2(a, N, unpacket_traits<Packet2Xl>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xl plogical_shift_right(Packet2Xl a) {
+EIGEN_STRONG_INLINE Packet2Xl plogical_shift_right(const Packet2Xl& a) {
   return __riscv_vreinterpret_i64m2(
       __riscv_vsrl_vx_u64m2(__riscv_vreinterpret_u64m2(a), N, unpacket_traits<Packet2Xl>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xl plogical_shift_left(Packet2Xl a) {
+EIGEN_STRONG_INLINE Packet2Xl plogical_shift_left(const Packet2Xl& a) {
   return __riscv_vsll_vx_i64m2(a, N, unpacket_traits<Packet2Xl>::size);
 }
 
@@ -854,6 +886,12 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xl& a) {
+  const PacketMask32 mask = __riscv_vmseq_vx_i64m2_b32(a, 0, unpacket_traits<Packet2Xl>::size);
+  return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xl>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int64_t predux_mul<Packet2Xl>(const Packet2Xl& a) {
   return predux_mul<Packet1Xl>(__riscv_vmul_vv_i64m1(__riscv_vget_v_i64m2_i64m1(a, 0), __riscv_vget_v_i64m2_i64m1(a, 1),
                                                      unpacket_traits<Packet1Xl>::size));
@@ -887,19 +925,9 @@
   }
 }
 
-template <typename Packet = Packet4Xl>
-EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet4Xl>::value && (unpacket_traits<Packet4Xl>::size % 8) == 0,
-                            Packet2Xl>::type
-    predux_half(const Packet4Xl& a) {
-  return __riscv_vadd_vv_i64m2(__riscv_vget_v_i64m4_i64m2(a, 0), __riscv_vget_v_i64m4_i64m2(a, 1),
-                               unpacket_traits<Packet2Xl>::size);
-}
-
 template <typename Packet = Packet2Xl>
 EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xl>::value && (unpacket_traits<Packet2Xl>::size % 8) == 0,
-                            Packet1Xl>::type
+    std::enable_if_t<std::is_same<Packet, Packet2Xl>::value && (unpacket_traits<Packet2Xl>::size % 8) == 0, Packet1Xl>
     predux_half(const Packet2Xl& a) {
   return __riscv_vadd_vv_i64m1(__riscv_vget_v_i64m2_i64m1(a, 0), __riscv_vget_v_i64m2_i64m1(a, 1),
                                unpacket_traits<Packet1Xl>::size);
@@ -909,7 +937,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xd ptrue<Packet2Xd>(const Packet2Xd& /*a*/) {
-  return __riscv_vreinterpret_f64m2(__riscv_vmv_v_x_u64m2(0xffffffffffffffffu, unpacket_traits<Packet2Xd>::size));
+  Packet2Xd r =
+      __riscv_vreinterpret_f64m2(__riscv_vmv_v_x_u64m2(0xffffffffffffffffu, unpacket_traits<Packet2Xd>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -949,7 +980,12 @@
 template <>
 EIGEN_STRONG_INLINE void pbroadcast4<Packet2Xd>(const double* a, Packet2Xd& a0, Packet2Xd& a1, Packet2Xd& a2,
                                                 Packet2Xd& a3) {
-  vfloat64m2_t aa = __riscv_vle64_v_f64m2(a, 4);
+  Packet2Xd aa;
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
+    aa = __riscv_vlmul_ext_f64m2(__riscv_vle64_v_f64m1(a, 4));
+  } else {
+    aa = __riscv_vle64_v_f64m2(a, 4);
+  }
   a0 = __riscv_vrgather_vx_f64m2(aa, 0, unpacket_traits<Packet2Xd>::size);
   a1 = __riscv_vrgather_vx_f64m2(aa, 1, unpacket_traits<Packet2Xd>::size);
   a2 = __riscv_vrgather_vx_f64m2(aa, 2, unpacket_traits<Packet2Xd>::size);
@@ -978,11 +1014,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xd pconj(const Packet2Xd& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xd pmul<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
   return __riscv_vfmul_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
 }
@@ -1013,6 +1044,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet2Xd> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet2Xd pmin<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
   Packet2Xd nans = __riscv_vfmv_v_f_f64m2((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet2Xd>::size);
   PacketMask32 mask = __riscv_vmfeq_vv_f64m2_b32(a, a, unpacket_traits<Packet2Xd>::size);
@@ -1023,11 +1057,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xd pmin<PropagateNaN, Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
-  return pmin<Packet2Xd>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xd pmin<PropagateNumbers, Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
   return __riscv_vfmin_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
 }
@@ -1043,11 +1072,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xd pmax<PropagateNaN, Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
-  return pmax<Packet2Xd>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xd pmax<PropagateNumbers, Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
   return __riscv_vfmax_vv_f64m2(a, b, unpacket_traits<Packet2Xd>::size);
 }
@@ -1107,10 +1131,21 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xd pandnot<Packet2Xd>(const Packet2Xd& a, const Packet2Xd& b) {
+#ifndef __riscv_zvbb
   return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vand_vv_u64m2(
       __riscv_vreinterpret_v_f64m2_u64m2(a),
       __riscv_vnot_v_u64m2(__riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xd>::size),
       unpacket_traits<Packet2Xd>::size));
+#else
+  return __riscv_vreinterpret_v_u64m2_f64m2(__riscv_vandn_vv_u64m2(
+      __riscv_vreinterpret_v_f64m2_u64m2(a), __riscv_vreinterpret_v_f64m2_u64m2(b), unpacket_traits<Packet2Xl>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xd pnot<Packet2Xd>(const Packet2Xd& a) {
+  return __riscv_vreinterpret_v_u64m2_f64m2(
+      __riscv_vnot_v_u64m2(__riscv_vreinterpret_v_f64m2_u64m2(a), unpacket_traits<Packet2Xd>::size));
 }
 
 template <>
@@ -1123,18 +1158,26 @@
   EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle64_v_f64m2(from, unpacket_traits<Packet2Xd>::size);
 }
 
+EIGEN_STRONG_INLINE Packet4Xd pdup(const Packet2Xd& a) {
+  Packet4Xul idx =
+      __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
+  return __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(a), idx, unpacket_traits<Packet4Xd>::size);
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet2Xd ploaddup<Packet2Xd>(const double* from) {
   Packet2Xul idx =
       __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 1, unpacket_traits<Packet2Xd>::size);
-  return __riscv_vrgather_vv_f64m2(pload<Packet2Xd>(from), idx, unpacket_traits<Packet2Xd>::size);
+  return __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(pload<Packet1Xd>(from)), idx,
+                                   unpacket_traits<Packet2Xd>::size);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xd ploadquad<Packet2Xd>(const double* from) {
   Packet2Xul idx =
       __riscv_vsrl_vx_u64m2(__riscv_vid_v_u64m2(unpacket_traits<Packet2Xd>::size), 2, unpacket_traits<Packet2Xd>::size);
-  return __riscv_vrgather_vv_f64m2(pload<Packet2Xd>(from), idx, unpacket_traits<Packet2Xd>::size);
+  return __riscv_vrgather_vv_f64m2(__riscv_vlmul_ext_v_f64m1_f64m2(pload<Packet1Xd>(from)), idx,
+                                   unpacket_traits<Packet2Xd>::size);
 }
 
 template <>
@@ -1209,6 +1252,25 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2Xd& a) {
+  const PacketMask32 mask =
+      __riscv_vmsne_vx_u64m2_b32(__riscv_vreinterpret_v_f64m2_u64m2(a), 0, unpacket_traits<Packet2Xd>::size);
+  return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xd>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xd& a) {
+  const PacketMask32 mask = __riscv_vmfeq_vf_f64m2_b32(a, 0.0, unpacket_traits<Packet2Xd>::size);
+  return __riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xd>::size) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet2Xd& a) {
+  const PacketMask32 mask = __riscv_vmfne_vf_f64m2_b32(a, 0.0, unpacket_traits<Packet2Xd>::size);
+  return static_cast<Index>(__riscv_vcpop_m_b32(mask, unpacket_traits<Packet2Xd>::size));
+}
+
+template <>
 EIGEN_STRONG_INLINE double predux_mul<Packet2Xd>(const Packet2Xd& a) {
   return predux_mul<Packet1Xd>(__riscv_vfmul_vv_f64m1(
       __riscv_vget_v_f64m2_f64m1(a, 0), __riscv_vget_v_f64m2_f64m1(a, 1), unpacket_traits<Packet1Xd>::size));
@@ -1216,22 +1278,24 @@
 
 template <>
 EIGEN_STRONG_INLINE double predux_min<Packet2Xd>(const Packet2Xd& a) {
-  return (std::min)(
-      __riscv_vfmv_f(__riscv_vfredmin_vs_f64m2_f64m1(
-          a, __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet2Xd>::size / 2),
-          unpacket_traits<Packet2Xd>::size)),
-      (std::numeric_limits<double>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmin_vs_f64m2_f64m1(a, __riscv_vget_v_f64m2_f64m1(a, 0), unpacket_traits<Packet2Xd>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_max<Packet2Xd>(const Packet2Xd& a) {
-  return (std::max)(
-      __riscv_vfmv_f(__riscv_vfredmax_vs_f64m2_f64m1(
-          a, __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet2Xd>::size / 2),
-          unpacket_traits<Packet2Xd>::size)),
-      -(std::numeric_limits<double>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmax_vs_f64m2_f64m1(a, __riscv_vget_v_f64m2_f64m1(a, 0), unpacket_traits<Packet2Xd>::size));
 }
 
+#if __riscv_v_min_vlen >= 256
+template <>
+EIGEN_STRONG_INLINE Packet1Xd predux_half(const Packet2Xd& a) {
+  return Packet1Xd(__riscv_vfadd_vv_f64m1(__riscv_vget_v_f64m2_f64m1(a, 0), __riscv_vget_v_f64m2_f64m1(a, 1),
+                                          unpacket_traits<Packet1Xd>::size));
+}
+#endif
+
 template <int N>
 EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xd, N>& kernel) {
   double buffer[unpacket_traits<Packet2Xd>::size * N];
@@ -1252,19 +1316,9 @@
   return pldexp_generic(a, exponent);
 }
 
-template <typename Packet = Packet4Xd>
-EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet4Xd>::value && (unpacket_traits<Packet4Xd>::size % 8) == 0,
-                            Packet2Xd>::type
-    predux_half(const Packet4Xd& a) {
-  return __riscv_vfadd_vv_f64m2(__riscv_vget_v_f64m4_f64m2(a, 0), __riscv_vget_v_f64m4_f64m2(a, 1),
-                                unpacket_traits<Packet2Xd>::size);
-}
-
 template <typename Packet = Packet2Xd>
 EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xd>::value && (unpacket_traits<Packet2Xd>::size % 8) == 0,
-                            Packet1Xd>::type
+    std::enable_if_t<std::is_same<Packet, Packet2Xd>::value && (unpacket_traits<Packet2Xd>::size % 8) == 0, Packet1Xd>
     predux_half(const Packet2Xd& a) {
   return __riscv_vfadd_vv_f64m1(__riscv_vget_v_f64m2_f64m1(a, 0), __riscv_vget_v_f64m2_f64m1(a, 1),
                                 unpacket_traits<Packet1Xd>::size);
@@ -1272,6 +1326,10 @@
 
 /********************************* Packet2Xs ************************************/
 
+EIGEN_STRONG_INLINE Packet2Xs __riscv_vreinterpret_v_u32m2_i16m2(const Packet2Xu& a) {
+  return __riscv_vreinterpret_v_i32m2_i16m2(__riscv_vreinterpret_v_u32m2_i32m2(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet2Xs pset1<Packet2Xs>(const numext::int16_t& from) {
   return __riscv_vmv_v_x_i16m2(from, unpacket_traits<Packet2Xs>::size);
@@ -1304,11 +1362,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xs pconj(const Packet2Xs& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xs pmul<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet2Xs>::size);
 }
@@ -1388,23 +1441,33 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xs pandnot<Packet2Xs>(const Packet2Xs& a, const Packet2Xs& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i16m2(a, __riscv_vnot_v_i16m2(b, unpacket_traits<Packet2Xs>::size),
                                unpacket_traits<Packet2Xs>::size);
+#else
+  return __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vandn_vv_u16m2(
+      __riscv_vreinterpret_v_i16m2_u16m2(a), __riscv_vreinterpret_v_i16m2_u16m2(b), unpacket_traits<Packet2Xs>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xs pnot<Packet2Xs>(const Packet2Xs& a) {
+  return __riscv_vnot_v_i16m2(a, unpacket_traits<Packet2Xs>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xs parithmetic_shift_right(Packet2Xs a) {
+EIGEN_STRONG_INLINE Packet2Xs parithmetic_shift_right(const Packet2Xs& a) {
   return __riscv_vsra_vx_i16m2(a, N, unpacket_traits<Packet2Xs>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xs plogical_shift_right(Packet2Xs a) {
+EIGEN_STRONG_INLINE Packet2Xs plogical_shift_right(const Packet2Xs& a) {
   return __riscv_vreinterpret_i16m2(
       __riscv_vsrl_vx_u16m2(__riscv_vreinterpret_u16m2(a), N, unpacket_traits<Packet2Xs>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet2Xs plogical_shift_left(Packet2Xs a) {
+EIGEN_STRONG_INLINE Packet2Xs plogical_shift_left(const Packet2Xs& a) {
   return __riscv_vsll_vx_i16m2(a, N, unpacket_traits<Packet2Xs>::size);
 }
 
@@ -1420,10 +1483,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xs ploaddup<Packet2Xs>(const numext::int16_t* from) {
-  Packet2Xsu data = __riscv_vreinterpret_v_i16m2_u16m2(pload<Packet2Xs>(from));
-  return __riscv_vreinterpret_v_i32m2_i16m2(__riscv_vreinterpret_v_u32m2_i32m2(__riscv_vlmul_trunc_v_u32m4_u32m2(
-      __riscv_vwmaccu_vx_u32m4(__riscv_vwaddu_vv_u32m4(data, data, unpacket_traits<Packet2Xs>::size), 0xffffu, data,
-                               unpacket_traits<Packet2Xs>::size))));
+  Packet2Xu data = __riscv_vlmul_trunc_v_u32m4_u32m2(__riscv_vwcvtu_x_x_v_u32m4(
+      __riscv_vreinterpret_v_i16m2_u16m2(pload<Packet2Xs>(from)), unpacket_traits<Packet2Xs>::size));
+  return __riscv_vreinterpret_v_u32m2_i16m2(__riscv_vadd_vv_u32m2(
+      __riscv_vsll_vx_u32m2(data, 16, unpacket_traits<Packet2Xi>::size), data, unpacket_traits<Packet2Xi>::size));
 }
 
 template <>
@@ -1480,6 +1543,12 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xs& a) {
+  const PacketMask8 mask = __riscv_vmseq_vx_i16m2_b8(a, 0, unpacket_traits<Packet2Xs>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xs>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int16_t predux_mul<Packet2Xs>(const Packet2Xs& a) {
   return predux_mul<Packet1Xs>(__riscv_vmul_vv_i16m1(__riscv_vget_v_i16m2_i16m1(a, 0), __riscv_vget_v_i16m2_i16m1(a, 1),
                                                      unpacket_traits<Packet1Xs>::size));
@@ -1513,19 +1582,9 @@
   }
 }
 
-template <typename Packet = Packet4Xs>
-EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet4Xs>::value && (unpacket_traits<Packet4Xs>::size % 8) == 0,
-                            Packet2Xs>::type
-    predux_half(const Packet4Xs& a) {
-  return __riscv_vadd_vv_i16m2(__riscv_vget_v_i16m4_i16m2(a, 0), __riscv_vget_v_i16m4_i16m2(a, 1),
-                               unpacket_traits<Packet2Xs>::size);
-}
-
 template <typename Packet = Packet2Xs>
 EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xs>::value && (unpacket_traits<Packet2Xs>::size % 8) == 0,
-                            Packet1Xs>::type
+    std::enable_if_t<std::is_same<Packet, Packet2Xs>::value && (unpacket_traits<Packet2Xs>::size % 8) == 0, Packet1Xs>
     predux_half(const Packet2Xs& a) {
   return __riscv_vadd_vv_i16m1(__riscv_vget_v_i16m2_i16m1(a, 0), __riscv_vget_v_i16m2_i16m1(a, 1),
                                unpacket_traits<Packet1Xs>::size);
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath4.h b/Eigen/src/Core/arch/RVV10/PacketMath4.h
index 249dadf..0cec0de 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath4.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath4.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET4_MATH_RVV10_H
 #define EIGEN_PACKET4_MATH_RVV10_H
@@ -19,6 +20,10 @@
 
 /********************************* Packet4Xi ************************************/
 
+EIGEN_STRONG_INLINE Packet4Xi __riscv_vreinterpret_v_u64m4_i32m4(const Packet4Xul& a) {
+  return __riscv_vreinterpret_v_i64m4_i32m4(__riscv_vreinterpret_v_u64m4_i64m4(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet4Xi pset1<Packet4Xi>(const numext::int32_t& from) {
   return __riscv_vmv_v_x_i32m4(from, unpacket_traits<Packet4Xi>::size);
@@ -51,11 +56,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xi pconj(const Packet4Xi& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xi pmul<Packet4Xi>(const Packet4Xi& a, const Packet4Xi& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet4Xi>::size);
 }
@@ -135,23 +135,33 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xi pandnot<Packet4Xi>(const Packet4Xi& a, const Packet4Xi& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i32m4(a, __riscv_vnot_v_i32m4(b, unpacket_traits<Packet4Xi>::size),
                                unpacket_traits<Packet4Xi>::size);
+#else
+  return __riscv_vreinterpret_v_u32m4_i32m4(__riscv_vandn_vv_u32m4(
+      __riscv_vreinterpret_v_i32m4_u32m4(a), __riscv_vreinterpret_v_i32m4_u32m4(b), unpacket_traits<Packet4Xi>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xi pnot<Packet4Xi>(const Packet4Xi& a) {
+  return __riscv_vnot_v_i32m4(a, unpacket_traits<Packet4Xi>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xi parithmetic_shift_right(Packet4Xi a) {
+EIGEN_STRONG_INLINE Packet4Xi parithmetic_shift_right(const Packet4Xi& a) {
   return __riscv_vsra_vx_i32m4(a, N, unpacket_traits<Packet4Xi>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xi plogical_shift_right(Packet4Xi a) {
+EIGEN_STRONG_INLINE Packet4Xi plogical_shift_right(const Packet4Xi& a) {
   return __riscv_vreinterpret_i32m4(
       __riscv_vsrl_vx_u32m4(__riscv_vreinterpret_u32m4(a), N, unpacket_traits<Packet4Xi>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xi plogical_shift_left(Packet4Xi a) {
+EIGEN_STRONG_INLINE Packet4Xi plogical_shift_left(const Packet4Xi& a) {
   return __riscv_vsll_vx_i32m4(a, N, unpacket_traits<Packet4Xi>::size);
 }
 
@@ -167,17 +177,18 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xi ploaddup<Packet4Xi>(const numext::int32_t* from) {
-  Packet4Xu data = __riscv_vreinterpret_v_i32m4_u32m4(pload<Packet4Xi>(from));
-  return __riscv_vreinterpret_v_i64m4_i32m4(__riscv_vreinterpret_v_u64m4_i64m4(__riscv_vlmul_trunc_v_u64m8_u64m4(
-      __riscv_vwmaccu_vx_u64m8(__riscv_vwaddu_vv_u64m8(data, data, unpacket_traits<Packet4Xi>::size), 0xffffffffu, data,
-                               unpacket_traits<Packet4Xi>::size))));
+  Packet4Xul data = __riscv_vwcvtu_x_x_v_u64m4(__riscv_vreinterpret_v_i32m2_u32m2(pload<Packet2Xi>(from)),
+                                               unpacket_traits<Packet2Xi>::size);
+  return __riscv_vreinterpret_v_u64m4_i32m4(__riscv_vadd_vv_u64m4(
+      __riscv_vsll_vx_u64m4(data, 32, unpacket_traits<Packet4Xl>::size), data, unpacket_traits<Packet4Xl>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xi ploadquad<Packet4Xi>(const numext::int32_t* from) {
   Packet4Xu idx =
       __riscv_vsrl_vx_u32m4(__riscv_vid_v_u32m4(unpacket_traits<Packet4Xi>::size), 2, unpacket_traits<Packet4Xi>::size);
-  return __riscv_vrgather_vv_i32m4(pload<Packet4Xi>(from), idx, unpacket_traits<Packet4Xi>::size);
+  return __riscv_vrgather_vv_i32m4(__riscv_vlmul_ext_v_i32m1_i32m4(pload<Packet1Xi>(from)), idx,
+                                   unpacket_traits<Packet4Xi>::size);
 }
 
 template <>
@@ -227,6 +238,12 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet4Xi& a) {
+  const PacketMask8 mask = __riscv_vmseq_vx_i32m4_b8(a, 0, unpacket_traits<Packet4Xi>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet4Xi>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int32_t predux_mul<Packet4Xi>(const Packet4Xi& a) {
   Packet1Xi half1 = __riscv_vmul_vv_i32m1(__riscv_vget_v_i32m4_i32m1(a, 0), __riscv_vget_v_i32m4_i32m1(a, 1),
                                           unpacket_traits<Packet1Xi>::size);
@@ -263,11 +280,21 @@
   }
 }
 
+template <typename Packet = Packet4Xi>
+EIGEN_STRONG_INLINE
+    std::enable_if_t<std::is_same<Packet, Packet4Xi>::value && (unpacket_traits<Packet4Xi>::size % 8) == 0, Packet2Xi>
+    predux_half(const Packet4Xi& a) {
+  return __riscv_vadd_vv_i32m2(__riscv_vget_v_i32m4_i32m2(a, 0), __riscv_vget_v_i32m4_i32m2(a, 1),
+                               unpacket_traits<Packet2Xi>::size);
+}
+
 /********************************* Packet4Xf ************************************/
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xf ptrue<Packet4Xf>(const Packet4Xf& /*a*/) {
-  return __riscv_vreinterpret_f32m4(__riscv_vmv_v_x_u32m4(0xffffffffu, unpacket_traits<Packet4Xf>::size));
+  Packet4Xf r = __riscv_vreinterpret_f32m4(__riscv_vmv_v_x_u32m4(0xffffffffu, unpacket_traits<Packet4Xf>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -307,7 +334,7 @@
 template <>
 EIGEN_STRONG_INLINE void pbroadcast4<Packet4Xf>(const float* a, Packet4Xf& a0, Packet4Xf& a1, Packet4Xf& a2,
                                                 Packet4Xf& a3) {
-  vfloat32m4_t aa = __riscv_vle32_v_f32m4(a, 4);
+  Packet4Xf aa = __riscv_vlmul_ext_f32m4(__riscv_vle32_v_f32m1(a, 4));
   a0 = __riscv_vrgather_vx_f32m4(aa, 0, unpacket_traits<Packet4Xf>::size);
   a1 = __riscv_vrgather_vx_f32m4(aa, 1, unpacket_traits<Packet4Xf>::size);
   a2 = __riscv_vrgather_vx_f32m4(aa, 2, unpacket_traits<Packet4Xf>::size);
@@ -336,11 +363,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xf pconj(const Packet4Xf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xf pmul<Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
   return __riscv_vfmul_vv_f32m4(a, b, unpacket_traits<Packet4Xf>::size);
 }
@@ -371,6 +393,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet4Xf> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet4Xf pmin<Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
   Packet4Xf nans = __riscv_vfmv_v_f_f32m4((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet4Xf>::size);
   PacketMask8 mask = __riscv_vmfeq_vv_f32m4_b8(a, a, unpacket_traits<Packet4Xf>::size);
@@ -381,11 +406,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xf pmin<PropagateNaN, Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
-  return pmin<Packet4Xf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xf pmin<PropagateNumbers, Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
   return __riscv_vfmin_vv_f32m4(a, b, unpacket_traits<Packet4Xf>::size);
 }
@@ -401,11 +421,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xf pmax<PropagateNaN, Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
-  return pmax<Packet4Xf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xf pmax<PropagateNumbers, Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
   return __riscv_vfmax_vv_f32m4(a, b, unpacket_traits<Packet4Xf>::size);
 }
@@ -465,10 +480,26 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xf pandnot<Packet4Xf>(const Packet4Xf& a, const Packet4Xf& b) {
+#ifndef __riscv_zvbb
   return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vand_vv_u32m4(
       __riscv_vreinterpret_v_f32m4_u32m4(a),
       __riscv_vnot_v_u32m4(__riscv_vreinterpret_v_f32m4_u32m4(b), unpacket_traits<Packet4Xf>::size),
       unpacket_traits<Packet4Xf>::size));
+#else
+  return __riscv_vreinterpret_v_u32m4_f32m4(__riscv_vandn_vv_u32m4(
+      __riscv_vreinterpret_v_f32m4_u32m4(a), __riscv_vreinterpret_v_f32m4_u32m4(b), unpacket_traits<Packet4Xi>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xf pnot<Packet4Xf>(const Packet4Xf& a) {
+  return __riscv_vreinterpret_v_u32m4_f32m4(
+      __riscv_vnot_v_u32m4(__riscv_vreinterpret_v_f32m4_u32m4(a), unpacket_traits<Packet4Xf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xs pnot<Packet4Xs>(const Packet4Xs& a) {
+  return __riscv_vnot_v_i16m4(a, unpacket_traits<Packet4Xs>::size);
 }
 
 template <>
@@ -483,18 +514,18 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xf ploaddup<Packet4Xf>(const float* from) {
-  Packet4Xu data = __riscv_vreinterpret_v_f32m4_u32m4(pload<Packet4Xf>(from));
-  return __riscv_vreinterpret_v_i32m4_f32m4(
-      __riscv_vreinterpret_v_i64m4_i32m4(__riscv_vreinterpret_v_u64m4_i64m4(__riscv_vlmul_trunc_v_u64m8_u64m4(
-          __riscv_vwmaccu_vx_u64m8(__riscv_vwaddu_vv_u64m8(data, data, unpacket_traits<Packet4Xi>::size), 0xffffffffu,
-                                   data, unpacket_traits<Packet4Xi>::size)))));
+  Packet4Xul data = __riscv_vwcvtu_x_x_v_u64m4(__riscv_vreinterpret_v_f32m2_u32m2(pload<Packet2Xf>(from)),
+                                               unpacket_traits<Packet2Xi>::size);
+  return __riscv_vreinterpret_v_u64m4_f32m4(__riscv_vadd_vv_u64m4(
+      __riscv_vsll_vx_u64m4(data, 32, unpacket_traits<Packet4Xl>::size), data, unpacket_traits<Packet4Xl>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xf ploadquad<Packet4Xf>(const float* from) {
   Packet4Xu idx =
       __riscv_vsrl_vx_u32m4(__riscv_vid_v_u32m4(unpacket_traits<Packet4Xf>::size), 2, unpacket_traits<Packet4Xf>::size);
-  return __riscv_vrgather_vv_f32m4(pload<Packet4Xf>(from), idx, unpacket_traits<Packet4Xf>::size);
+  return __riscv_vrgather_vv_f32m4(__riscv_vlmul_ext_v_f32m1_f32m4(pload<Packet1Xf>(from)), idx,
+                                   unpacket_traits<Packet4Xf>::size);
 }
 
 template <>
@@ -565,7 +596,26 @@
 template <>
 EIGEN_STRONG_INLINE float predux<Packet4Xf>(const Packet4Xf& a) {
   return __riscv_vfmv_f(__riscv_vfredusum_vs_f32m4_f32m1(
-      a, __riscv_vfmv_v_f_f32m1(0.0, unpacket_traits<Packet4Xf>::size / 4), unpacket_traits<Packet4Xf>::size));
+      a, __riscv_vfmv_v_f_f32m1(0.0f, unpacket_traits<Packet4Xf>::size / 4), unpacket_traits<Packet4Xf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4Xf& a) {
+  const PacketMask8 mask =
+      __riscv_vmsne_vx_u32m4_b8(__riscv_vreinterpret_v_f32m4_u32m4(a), 0, unpacket_traits<Packet4Xf>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet4Xf>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet4Xf& a) {
+  const PacketMask8 mask = __riscv_vmfeq_vf_f32m4_b8(a, 0.0f, unpacket_traits<Packet4Xf>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet4Xf>::size) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet4Xf& a) {
+  const PacketMask8 mask = __riscv_vmfne_vf_f32m4_b8(a, 0.0f, unpacket_traits<Packet4Xf>::size);
+  return static_cast<Index>(__riscv_vcpop_m_b8(mask, unpacket_traits<Packet4Xf>::size));
 }
 
 template <>
@@ -577,22 +627,24 @@
   return predux_mul<Packet1Xf>(__riscv_vfmul_vv_f32m1(half1, half2, unpacket_traits<Packet1Xf>::size));
 }
 
+// Reusing the first lane is exact for an idempotent reduction and avoids a NaN seed that becomes poison under
+// finite fast-math.
 template <>
 EIGEN_STRONG_INLINE float predux_min<Packet4Xf>(const Packet4Xf& a) {
-  return (std::min)(
-      __riscv_vfmv_f(__riscv_vfredmin_vs_f32m4_f32m1(
-          a, __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet4Xf>::size / 4),
-          unpacket_traits<Packet4Xf>::size)),
-      (std::numeric_limits<float>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmin_vs_f32m4_f32m1(a, __riscv_vget_v_f32m4_f32m1(a, 0), unpacket_traits<Packet4Xf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_max<Packet4Xf>(const Packet4Xf& a) {
-  return (std::max)(
-      __riscv_vfmv_f(__riscv_vfredmax_vs_f32m4_f32m1(
-          a, __riscv_vfmv_v_f_f32m1((std::numeric_limits<float>::quiet_NaN)(), unpacket_traits<Packet4Xf>::size / 4),
-          unpacket_traits<Packet4Xf>::size)),
-      -(std::numeric_limits<float>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmax_vs_f32m4_f32m1(a, __riscv_vget_v_f32m4_f32m1(a, 0), unpacket_traits<Packet4Xf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xf predux_half(const Packet4Xf& a) {
+  return Packet2Xf(__riscv_vfadd_vv_f32m2(__riscv_vget_v_f32m4_f32m2(a, 0), __riscv_vget_v_f32m4_f32m2(a, 1),
+                                          unpacket_traits<Packet2Xf>::size));
 }
 
 template <int N>
@@ -615,6 +667,14 @@
   return pldexp_generic(a, exponent);
 }
 
+template <typename Packet = Packet4Xf>
+EIGEN_STRONG_INLINE
+    std::enable_if_t<std::is_same<Packet, Packet4Xf>::value && (unpacket_traits<Packet4Xf>::size % 8) == 0, Packet2Xf>
+    predux_half(const Packet4Xf& a) {
+  return __riscv_vfadd_vv_f32m2(__riscv_vget_v_f32m4_f32m2(a, 0), __riscv_vget_v_f32m4_f32m2(a, 1),
+                                unpacket_traits<Packet2Xf>::size);
+}
+
 /********************************* Packet4Xl ************************************/
 
 template <>
@@ -649,11 +709,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xl pconj(const Packet4Xl& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xl pmul<Packet4Xl>(const Packet4Xl& a, const Packet4Xl& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet4Xl>::size);
 }
@@ -727,29 +782,39 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE Packet4Xl pnot<Packet4Xl>(const Packet4Xl& a) {
+  return __riscv_vnot_v_i64m4(a, unpacket_traits<Packet4Xl>::size);
+}
+
+template <>
 EIGEN_STRONG_INLINE Packet4Xl pxor<Packet4Xl>(const Packet4Xl& a, const Packet4Xl& b) {
   return __riscv_vxor_vv_i64m4(a, b, unpacket_traits<Packet4Xl>::size);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xl pandnot<Packet4Xl>(const Packet4Xl& a, const Packet4Xl& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i64m4(a, __riscv_vnot_v_i64m4(b, unpacket_traits<Packet4Xl>::size),
                                unpacket_traits<Packet4Xl>::size);
+#else
+  return __riscv_vreinterpret_v_u64m4_i64m4(__riscv_vandn_vv_u64m4(
+      __riscv_vreinterpret_v_i64m4_u64m4(a), __riscv_vreinterpret_v_i64m4_u64m4(b), unpacket_traits<Packet4Xl>::size));
+#endif
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xl parithmetic_shift_right(Packet4Xl a) {
+EIGEN_STRONG_INLINE Packet4Xl parithmetic_shift_right(const Packet4Xl& a) {
   return __riscv_vsra_vx_i64m4(a, N, unpacket_traits<Packet4Xl>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xl plogical_shift_right(Packet4Xl a) {
+EIGEN_STRONG_INLINE Packet4Xl plogical_shift_right(const Packet4Xl& a) {
   return __riscv_vreinterpret_i64m4(
       __riscv_vsrl_vx_u64m4(__riscv_vreinterpret_u64m4(a), N, unpacket_traits<Packet4Xl>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xl plogical_shift_left(Packet4Xl a) {
+EIGEN_STRONG_INLINE Packet4Xl plogical_shift_left(const Packet4Xl& a) {
   return __riscv_vsll_vx_i64m4(a, N, unpacket_traits<Packet4Xl>::size);
 }
 
@@ -767,14 +832,16 @@
 EIGEN_STRONG_INLINE Packet4Xl ploaddup<Packet4Xl>(const numext::int64_t* from) {
   Packet4Xul idx =
       __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xl>::size), 1, unpacket_traits<Packet4Xl>::size);
-  return __riscv_vrgather_vv_i64m4(pload<Packet4Xl>(from), idx, unpacket_traits<Packet4Xl>::size);
+  return __riscv_vrgather_vv_i64m4(__riscv_vlmul_ext_v_i64m2_i64m4(pload<Packet2Xl>(from)), idx,
+                                   unpacket_traits<Packet4Xl>::size);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xl ploadquad<Packet4Xl>(const numext::int64_t* from) {
   Packet4Xul idx =
       __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xl>::size), 2, unpacket_traits<Packet4Xl>::size);
-  return __riscv_vrgather_vv_i64m4(pload<Packet4Xl>(from), idx, unpacket_traits<Packet4Xl>::size);
+  return __riscv_vrgather_vv_i64m4(__riscv_vlmul_ext_v_i64m1_i64m4(pload<Packet1Xl>(from)), idx,
+                                   unpacket_traits<Packet4Xl>::size);
 }
 
 template <>
@@ -824,6 +891,12 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet4Xl& a) {
+  const PacketMask16 mask = __riscv_vmseq_vx_i64m4_b16(a, 0, unpacket_traits<Packet4Xl>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet4Xl>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int64_t predux_mul<Packet4Xl>(const Packet4Xl& a) {
   Packet1Xl half1 = __riscv_vmul_vv_i64m1(__riscv_vget_v_i64m4_i64m1(a, 0), __riscv_vget_v_i64m4_i64m1(a, 1),
                                           unpacket_traits<Packet1Xl>::size);
@@ -860,11 +933,22 @@
   }
 }
 
+template <typename Packet = Packet4Xl>
+EIGEN_STRONG_INLINE
+    std::enable_if_t<std::is_same<Packet, Packet4Xl>::value && (unpacket_traits<Packet4Xl>::size % 8) == 0, Packet2Xl>
+    predux_half(const Packet4Xl& a) {
+  return __riscv_vadd_vv_i64m2(__riscv_vget_v_i64m4_i64m2(a, 0), __riscv_vget_v_i64m4_i64m2(a, 1),
+                               unpacket_traits<Packet2Xl>::size);
+}
+
 /********************************* Packet4Xd ************************************/
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xd ptrue<Packet4Xd>(const Packet4Xd& /*a*/) {
-  return __riscv_vreinterpret_f64m4(__riscv_vmv_v_x_u64m4(0xffffffffffffffffu, unpacket_traits<Packet4Xd>::size));
+  Packet4Xd r =
+      __riscv_vreinterpret_f64m4(__riscv_vmv_v_x_u64m4(0xffffffffffffffffu, unpacket_traits<Packet4Xd>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -904,7 +988,12 @@
 template <>
 EIGEN_STRONG_INLINE void pbroadcast4<Packet4Xd>(const double* a, Packet4Xd& a0, Packet4Xd& a1, Packet4Xd& a2,
                                                 Packet4Xd& a3) {
-  vfloat64m4_t aa = __riscv_vle64_v_f64m4(a, 4);
+  Packet4Xd aa;
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
+    aa = __riscv_vlmul_ext_f64m4(__riscv_vle64_v_f64m1(a, 4));
+  } else {
+    aa = __riscv_vlmul_ext_f64m4(__riscv_vle64_v_f64m2(a, 4));
+  }
   a0 = __riscv_vrgather_vx_f64m4(aa, 0, unpacket_traits<Packet4Xd>::size);
   a1 = __riscv_vrgather_vx_f64m4(aa, 1, unpacket_traits<Packet4Xd>::size);
   a2 = __riscv_vrgather_vx_f64m4(aa, 2, unpacket_traits<Packet4Xd>::size);
@@ -933,11 +1022,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xd pconj(const Packet4Xd& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xd pmul<Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
   return __riscv_vfmul_vv_f64m4(a, b, unpacket_traits<Packet4Xd>::size);
 }
@@ -968,6 +1052,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet4Xd> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet4Xd pmin<Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
   Packet4Xd nans = __riscv_vfmv_v_f_f64m4((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet4Xd>::size);
   PacketMask16 mask = __riscv_vmfeq_vv_f64m4_b16(a, a, unpacket_traits<Packet4Xd>::size);
@@ -978,11 +1065,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xd pmin<PropagateNaN, Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
-  return pmin<Packet4Xd>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xd pmin<PropagateNumbers, Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
   return __riscv_vfmin_vv_f64m4(a, b, unpacket_traits<Packet4Xd>::size);
 }
@@ -998,11 +1080,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xd pmax<PropagateNaN, Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
-  return pmax<Packet4Xd>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xd pmax<PropagateNumbers, Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
   return __riscv_vfmax_vv_f64m4(a, b, unpacket_traits<Packet4Xd>::size);
 }
@@ -1062,10 +1139,21 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xd pandnot<Packet4Xd>(const Packet4Xd& a, const Packet4Xd& b) {
+#ifndef __riscv_zvbb
   return __riscv_vreinterpret_v_u64m4_f64m4(__riscv_vand_vv_u64m4(
       __riscv_vreinterpret_v_f64m4_u64m4(a),
       __riscv_vnot_v_u64m4(__riscv_vreinterpret_v_f64m4_u64m4(b), unpacket_traits<Packet4Xd>::size),
       unpacket_traits<Packet4Xd>::size));
+#else
+  return __riscv_vreinterpret_v_u64m4_f64m4(__riscv_vandn_vv_u64m4(
+      __riscv_vreinterpret_v_f64m4_u64m4(a), __riscv_vreinterpret_v_f64m4_u64m4(b), unpacket_traits<Packet4Xl>::size));
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet4Xd pnot<Packet4Xd>(const Packet4Xd& a) {
+  return __riscv_vreinterpret_v_u64m4_f64m4(
+      __riscv_vnot_v_u64m4(__riscv_vreinterpret_v_f64m4_u64m4(a), unpacket_traits<Packet4Xd>::size));
 }
 
 template <>
@@ -1082,14 +1170,16 @@
 EIGEN_STRONG_INLINE Packet4Xd ploaddup<Packet4Xd>(const double* from) {
   Packet4Xul idx =
       __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 1, unpacket_traits<Packet4Xd>::size);
-  return __riscv_vrgather_vv_f64m4(pload<Packet4Xd>(from), idx, unpacket_traits<Packet4Xd>::size);
+  return __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m2_f64m4(pload<Packet2Xd>(from)), idx,
+                                   unpacket_traits<Packet4Xd>::size);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xd ploadquad<Packet4Xd>(const double* from) {
   Packet4Xul idx =
       __riscv_vsrl_vx_u64m4(__riscv_vid_v_u64m4(unpacket_traits<Packet4Xd>::size), 2, unpacket_traits<Packet4Xd>::size);
-  return __riscv_vrgather_vv_f64m4(pload<Packet4Xd>(from), idx, unpacket_traits<Packet4Xd>::size);
+  return __riscv_vrgather_vv_f64m4(__riscv_vlmul_ext_v_f64m1_f64m4(pload<Packet1Xd>(from)), idx,
+                                   unpacket_traits<Packet4Xd>::size);
 }
 
 template <>
@@ -1164,6 +1254,25 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4Xd& a) {
+  const PacketMask16 mask =
+      __riscv_vmsne_vx_u64m4_b16(__riscv_vreinterpret_v_f64m4_u64m4(a), 0, unpacket_traits<Packet4Xd>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet4Xd>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet4Xd& a) {
+  const PacketMask16 mask = __riscv_vmfeq_vf_f64m4_b16(a, 0.0, unpacket_traits<Packet4Xd>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet4Xd>::size) == 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet4Xd& a) {
+  const PacketMask16 mask = __riscv_vmfne_vf_f64m4_b16(a, 0.0, unpacket_traits<Packet4Xd>::size);
+  return static_cast<Index>(__riscv_vcpop_m_b16(mask, unpacket_traits<Packet4Xd>::size));
+}
+
+template <>
 EIGEN_STRONG_INLINE double predux_mul<Packet4Xd>(const Packet4Xd& a) {
   Packet1Xd half1 = __riscv_vfmul_vv_f64m1(__riscv_vget_v_f64m4_f64m1(a, 0), __riscv_vget_v_f64m4_f64m1(a, 1),
                                            unpacket_traits<Packet1Xd>::size);
@@ -1174,20 +1283,20 @@
 
 template <>
 EIGEN_STRONG_INLINE double predux_min<Packet4Xd>(const Packet4Xd& a) {
-  return (std::min)(
-      __riscv_vfmv_f(__riscv_vfredmin_vs_f64m4_f64m1(
-          a, __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet4Xd>::size / 4),
-          unpacket_traits<Packet4Xd>::size)),
-      (std::numeric_limits<double>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmin_vs_f64m4_f64m1(a, __riscv_vget_v_f64m4_f64m1(a, 0), unpacket_traits<Packet4Xd>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_max<Packet4Xd>(const Packet4Xd& a) {
-  return (std::max)(
-      __riscv_vfmv_f(__riscv_vfredmax_vs_f64m4_f64m1(
-          a, __riscv_vfmv_v_f_f64m1((std::numeric_limits<double>::quiet_NaN)(), unpacket_traits<Packet4Xd>::size / 4),
-          unpacket_traits<Packet4Xd>::size)),
-      -(std::numeric_limits<double>::max)());
+  return __riscv_vfmv_f(
+      __riscv_vfredmax_vs_f64m4_f64m1(a, __riscv_vget_v_f64m4_f64m1(a, 0), unpacket_traits<Packet4Xd>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xd predux_half(const Packet4Xd& a) {
+  return Packet2Xd(__riscv_vfadd_vv_f64m2(__riscv_vget_v_f64m4_f64m2(a, 0), __riscv_vget_v_f64m4_f64m2(a, 1),
+                                          unpacket_traits<Packet2Xd>::size));
 }
 
 template <int N>
@@ -1210,8 +1319,20 @@
   return pldexp_generic(a, exponent);
 }
 
+template <typename Packet = Packet4Xd>
+EIGEN_STRONG_INLINE
+    std::enable_if_t<std::is_same<Packet, Packet4Xd>::value && (unpacket_traits<Packet4Xd>::size % 8) == 0, Packet2Xd>
+    predux_half(const Packet4Xd& a) {
+  return __riscv_vfadd_vv_f64m2(__riscv_vget_v_f64m4_f64m2(a, 0), __riscv_vget_v_f64m4_f64m2(a, 1),
+                                unpacket_traits<Packet2Xd>::size);
+}
+
 /********************************* Packet4Xs ************************************/
 
+EIGEN_STRONG_INLINE Packet4Xs __riscv_vreinterpret_v_u32m4_i16m4(const Packet4Xu& a) {
+  return __riscv_vreinterpret_v_i32m4_i16m4(__riscv_vreinterpret_v_u32m4_i32m4(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet4Xs pset1<Packet4Xs>(const numext::int16_t& from) {
   return __riscv_vmv_v_x_i16m4(from, unpacket_traits<Packet4Xs>::size);
@@ -1244,11 +1365,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4Xs pconj(const Packet4Xs& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4Xs pmul<Packet4Xs>(const Packet4Xs& a, const Packet4Xs& b) {
   return __riscv_vmul(a, b, unpacket_traits<Packet4Xs>::size);
 }
@@ -1328,23 +1444,28 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xs pandnot<Packet4Xs>(const Packet4Xs& a, const Packet4Xs& b) {
+#ifndef __riscv_zvbb
   return __riscv_vand_vv_i16m4(a, __riscv_vnot_v_i16m4(b, unpacket_traits<Packet4Xs>::size),
                                unpacket_traits<Packet4Xs>::size);
+#else
+  return __riscv_vreinterpret_v_u16m4_i16m4(__riscv_vandn_vv_u16m4(
+      __riscv_vreinterpret_v_i16m4_u16m4(a), __riscv_vreinterpret_v_i16m4_u16m4(b), unpacket_traits<Packet4Xs>::size));
+#endif
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xs parithmetic_shift_right(Packet4Xs a) {
+EIGEN_STRONG_INLINE Packet4Xs parithmetic_shift_right(const Packet4Xs& a) {
   return __riscv_vsra_vx_i16m4(a, N, unpacket_traits<Packet4Xs>::size);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xs plogical_shift_right(Packet4Xs a) {
+EIGEN_STRONG_INLINE Packet4Xs plogical_shift_right(const Packet4Xs& a) {
   return __riscv_vreinterpret_i16m4(
       __riscv_vsrl_vx_u16m4(__riscv_vreinterpret_u16m4(a), N, unpacket_traits<Packet4Xs>::size));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE Packet4Xs plogical_shift_left(Packet4Xs a) {
+EIGEN_STRONG_INLINE Packet4Xs plogical_shift_left(const Packet4Xs& a) {
   return __riscv_vsll_vx_i16m4(a, N, unpacket_traits<Packet4Xs>::size);
 }
 
@@ -1360,17 +1481,18 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xs ploaddup<Packet4Xs>(const numext::int16_t* from) {
-  Packet4Xsu data = __riscv_vreinterpret_v_i16m4_u16m4(pload<Packet4Xs>(from));
-  return __riscv_vreinterpret_v_i32m4_i16m4(__riscv_vreinterpret_v_u32m4_i32m4(__riscv_vlmul_trunc_v_u32m8_u32m4(
-      __riscv_vwmaccu_vx_u32m8(__riscv_vwaddu_vv_u32m8(data, data, unpacket_traits<Packet4Xs>::size), 0xffffu, data,
-                               unpacket_traits<Packet4Xs>::size))));
+  Packet4Xu data = __riscv_vwcvtu_x_x_v_u32m4(__riscv_vreinterpret_v_i16m2_u16m2(pload<Packet2Xs>(from)),
+                                              unpacket_traits<Packet2Xs>::size);
+  return __riscv_vreinterpret_v_u32m4_i16m4(__riscv_vadd_vv_u32m4(
+      __riscv_vsll_vx_u32m4(data, 16, unpacket_traits<Packet4Xi>::size), data, unpacket_traits<Packet4Xi>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xs ploadquad<Packet4Xs>(const numext::int16_t* from) {
   Packet4Xsu idx =
       __riscv_vsrl_vx_u16m4(__riscv_vid_v_u16m4(unpacket_traits<Packet4Xs>::size), 2, unpacket_traits<Packet4Xs>::size);
-  return __riscv_vrgather_vv_i16m4(pload<Packet4Xs>(from), idx, unpacket_traits<Packet4Xs>::size);
+  return __riscv_vrgather_vv_i16m4(__riscv_vlmul_ext_v_i16m1_i16m4(pload<Packet1Xs>(from)), idx,
+                                   unpacket_traits<Packet4Xs>::size);
 }
 
 template <>
@@ -1420,6 +1542,12 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet4Xs& a) {
+  const PacketMask4 mask = __riscv_vmseq_vx_i16m4_b4(a, 0, unpacket_traits<Packet4Xs>::size);
+  return __riscv_vcpop_m_b4(mask, unpacket_traits<Packet4Xs>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int16_t predux_mul<Packet4Xs>(const Packet4Xs& a) {
   Packet1Xs half1 = __riscv_vmul_vv_i16m1(__riscv_vget_v_i16m4_i16m1(a, 0), __riscv_vget_v_i16m4_i16m1(a, 1),
                                           unpacket_traits<Packet1Xs>::size);
@@ -1456,6 +1584,14 @@
   }
 }
 
+template <typename Packet = Packet4Xs>
+EIGEN_STRONG_INLINE
+    std::enable_if_t<std::is_same<Packet, Packet4Xs>::value && (unpacket_traits<Packet4Xs>::size % 8) == 0, Packet2Xs>
+    predux_half(const Packet4Xs& a) {
+  return __riscv_vadd_vv_i16m2(__riscv_vget_v_i16m4_i16m2(a, 0), __riscv_vget_v_i16m4_i16m2(a, 1),
+                               unpacket_traits<Packet2Xs>::size);
+}
+
 }  // namespace internal
 }  // namespace Eigen
 
diff --git a/Eigen/src/Core/arch/RVV10/PacketMathBF16.h b/Eigen/src/Core/arch/RVV10/PacketMathBF16.h
index 2522efd..5228822 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMathBF16.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMathBF16.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_BF16_RVV10_H
 #define EIGEN_PACKET_MATH_BF16_RVV10_H
@@ -20,123 +21,68 @@
 typedef eigen_packet_wrapper<vbfloat16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 27>
     Packet2Xbf;
 
+template <>
+struct rvv_half_packet<Packet2Xbf> {
+  typedef Packet1Xbf type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xbf> : rvv_default_unpacket_traits<bfloat16, Packet1Xbf, 1> {
+  typedef Packet1Xs integer_packet;
+  typedef PacketMask16 packet_mask;
+};
+
+template <>
+struct unpacket_traits<Packet2Xbf> : rvv_default_unpacket_traits<bfloat16, Packet2Xbf, 2> {
+  typedef Packet2Xs integer_packet;
+  typedef PacketMask8 packet_mask;
+};
+
 #if EIGEN_RISCV64_DEFAULT_LMUL == 1
 typedef Packet1Xbf PacketXbf;
-
-template <>
-struct packet_traits<bfloat16> : default_packet_traits {
-  typedef Packet1Xbf type;
-  typedef Packet1Xbf half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<bfloat16, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-    HasSign = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 0,
-
-    HasSin = 0,
-    HasCos = 0,
-    HasLog = 0,
-    HasExp = 0,
-    HasSqrt = 1,
-    HasTanh = 0,
-    HasErf = 0
-  };
-};
-
 #else
 typedef Packet2Xbf PacketXbf;
-
-template <>
-struct packet_traits<bfloat16> : default_packet_traits {
-  typedef Packet2Xbf type;
-  typedef Packet1Xbf half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<bfloat16, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-    HasSign = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 0,
-
-    HasSin = 0,
-    HasCos = 0,
-    HasLog = 0,
-    HasExp = 0,
-    HasSqrt = 1,
-    HasTanh = 0,
-    HasErf = 0
-  };
-};
 #endif
 
 template <>
-struct unpacket_traits<Packet1Xbf> : default_unpacket_traits {
-  typedef bfloat16 type;
-  typedef Packet1Xbf half;  // Half not yet implemented
-  typedef Packet1Xs integer_packet;
-  typedef numext::uint8_t mask_t;
-
+struct packet_traits<bfloat16> : rvv_default_packet_traits<bfloat16, PacketXbf> {
   enum {
-    size = rvv_packet_size_selector<bfloat16, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true
-  };
-};
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasReduxp = 0,
+    HasSign = 0,
 
-template <>
-struct unpacket_traits<Packet2Xbf> : default_unpacket_traits {
-  typedef bfloat16 type;
-  typedef Packet1Xbf half;
-  typedef Packet2Xs integer_packet;
-  typedef numext::uint8_t mask_t;
+    HasCmp = 1,
+    HasDiv = 1,
+    HasRound = 0,
 
-  enum {
-    size = rvv_packet_size_selector<bfloat16, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true
+    HasSin = 0,
+    HasCos = 0,
+    HasLog = 0,
+    HasExp = 0,
+    HasSqrt = 1,
+    HasTanh = 0,
+    HasErf = 0
   };
 };
 
 /********************************* Packet1Xbf ************************************/
 
+EIGEN_STRONG_INLINE Packet1Xbf __riscv_vreinterpret_v_u32m1_bf16m1(const Packet1Xu& a) {
+  return __riscv_vreinterpret_v_u16m1_bf16m1(__riscv_vreinterpret_v_u32m1_u16m1(a));
+}
+
 EIGEN_STRONG_INLINE Packet2Xf Bf16ToF32(const Packet1Xbf& a) {
   return __riscv_vfwcvtbf16_f_f_v_f32m2(a, unpacket_traits<Packet1Xbf>::size);
 }
@@ -147,8 +93,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf ptrue<Packet1Xbf>(const Packet1Xbf& /*a*/) {
-  return __riscv_vreinterpret_bf16m1(
+  Packet1Xbf r = __riscv_vreinterpret_bf16m1(
       __riscv_vmv_v_x_u16m1(static_cast<numext::uint16_t>(0xffffu), unpacket_traits<Packet1Xbf>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -225,11 +173,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xbf pconj(const Packet1Xbf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xbf pmul<Packet1Xbf>(const Packet1Xbf& a, const Packet1Xbf& b) {
   Packet2Xf c;
   return F32ToBf16(__riscv_vfwmaccbf16_vv_f32m2(pzero<Packet2Xf>(c), a, b, unpacket_traits<Packet1Xbf>::size));
@@ -293,24 +236,69 @@
   return F32ToBf16(pmax<PropagateNumbers, Packet2Xf>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
+// Comparisons are performed in float32 and the resulting vbool mask is expanded to all-ones/all-zeros
+// 16-bit lanes with a vmerge.  Narrowing the float32 comparison result with F32ToBf16 instead would go
+// through an arithmetic conversion (vfncvtbf16) that canonicalizes the all-ones (NaN) lanes to 0x7fc0
+// and corrupts the mask.
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf pcmp_le<Packet1Xbf>(const Packet1Xbf& a, const Packet1Xbf& b) {
-  return F32ToBf16(pcmp_le<Packet2Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask16 mask = __riscv_vmfle_vv_f32m2_b16(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_u16m1_bf16m1(__riscv_vmerge_vvm_u16m1(
+      __riscv_vreinterpret_v_bf16m1_u16m1(pzero<Packet1Xbf>(a)),
+      __riscv_vreinterpret_v_bf16m1_u16m1(ptrue<Packet1Xbf>(a)), mask, unpacket_traits<Packet1Xbf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf pcmp_lt<Packet1Xbf>(const Packet1Xbf& a, const Packet1Xbf& b) {
-  return F32ToBf16(pcmp_lt<Packet2Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask16 mask = __riscv_vmflt_vv_f32m2_b16(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_u16m1_bf16m1(__riscv_vmerge_vvm_u16m1(
+      __riscv_vreinterpret_v_bf16m1_u16m1(pzero<Packet1Xbf>(a)),
+      __riscv_vreinterpret_v_bf16m1_u16m1(ptrue<Packet1Xbf>(a)), mask, unpacket_traits<Packet1Xbf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf pcmp_eq<Packet1Xbf>(const Packet1Xbf& a, const Packet1Xbf& b) {
-  return F32ToBf16(pcmp_eq<Packet2Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask16 mask = __riscv_vmfeq_vv_f32m2_b16(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_u16m1_bf16m1(__riscv_vmerge_vvm_u16m1(
+      __riscv_vreinterpret_v_bf16m1_u16m1(pzero<Packet1Xbf>(a)),
+      __riscv_vreinterpret_v_bf16m1_u16m1(ptrue<Packet1Xbf>(a)), mask, unpacket_traits<Packet1Xbf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf pcmp_lt_or_nan<Packet1Xbf>(const Packet1Xbf& a, const Packet1Xbf& b) {
-  return F32ToBf16(pcmp_lt_or_nan<Packet2Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask16 mask = __riscv_vmfge_vv_f32m2_b16(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_u16m1_bf16m1(
+      __riscv_vmerge_vxm_u16m1(__riscv_vreinterpret_v_bf16m1_u16m1(ptrue<Packet1Xbf>(a)),
+                               static_cast<numext::uint16_t>(0), mask, unpacket_traits<Packet1Xbf>::size));
+}
+
+// Classify on the raw bits, as the scalar isinf/isnan/isfinite do: |a| ==, >, < 0x7f80. The generic forms compare
+// the widened floats, and -ffinite-math-only folds the a >= a of pisnan to true.
+template <>
+EIGEN_STRONG_INLINE Packet1Xbf pisinf<Packet1Xbf>(const Packet1Xbf& a) {
+  const vuint16m1_t abs_bits =
+      __riscv_vand_vx_u16m1(__riscv_vreinterpret_v_bf16m1_u16m1(a), 0x7fffu, unpacket_traits<Packet1Xbf>::size);
+  const PacketMask16 mask = __riscv_vmseq_vx_u16m1_b16(abs_bits, 0x7f80u, unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_i16m1_bf16m1(__riscv_vmerge_vxm_i16m1(
+      __riscv_vreinterpret_v_bf16m1_i16m1(pzero<Packet1Xbf>(a)), -1, mask, unpacket_traits<Packet1Xbf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xbf pisnan<Packet1Xbf>(const Packet1Xbf& a) {
+  const vuint16m1_t abs_bits =
+      __riscv_vand_vx_u16m1(__riscv_vreinterpret_v_bf16m1_u16m1(a), 0x7fffu, unpacket_traits<Packet1Xbf>::size);
+  const PacketMask16 mask = __riscv_vmsgtu_vx_u16m1_b16(abs_bits, 0x7f80u, unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_i16m1_bf16m1(__riscv_vmerge_vxm_i16m1(
+      __riscv_vreinterpret_v_bf16m1_i16m1(pzero<Packet1Xbf>(a)), -1, mask, unpacket_traits<Packet1Xbf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xbf pisfinite<Packet1Xbf>(const Packet1Xbf& a) {
+  const vuint16m1_t abs_bits =
+      __riscv_vand_vx_u16m1(__riscv_vreinterpret_v_bf16m1_u16m1(a), 0x7fffu, unpacket_traits<Packet1Xbf>::size);
+  const PacketMask16 mask = __riscv_vmsltu_vx_u16m1_b16(abs_bits, 0x7f80u, unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vreinterpret_v_i16m1_bf16m1(__riscv_vmerge_vxm_i16m1(
+      __riscv_vreinterpret_v_bf16m1_i16m1(pzero<Packet1Xbf>(a)), -1, mask, unpacket_traits<Packet1Xbf>::size));
 }
 
 EIGEN_STRONG_INLINE Packet1Xbf pselect(const PacketMask16& mask, const Packet1Xbf& a, const Packet1Xbf& b) {
@@ -351,10 +339,14 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf pandnot<Packet1Xbf>(const Packet1Xbf& a, const Packet1Xbf& b) {
-  return __riscv_vreinterpret_v_u16m1_bf16m1(__riscv_vand_vv_u16m1(
-      __riscv_vreinterpret_v_bf16m1_u16m1(a),
-      __riscv_vnot_v_u16m1(__riscv_vreinterpret_v_bf16m1_u16m1(b), unpacket_traits<Packet1Xbf>::size),
-      unpacket_traits<Packet1Xbf>::size));
+  return __riscv_vreinterpret_v_i16m1_bf16m1(
+      pandnot<Packet1Xs>(__riscv_vreinterpret_v_bf16m1_i16m1(a), __riscv_vreinterpret_v_bf16m1_i16m1(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet1Xbf pnot<Packet1Xbf>(const Packet1Xbf& a) {
+  return __riscv_vreinterpret_v_u16m1_bf16m1(
+      __riscv_vnot_v_u16m1(__riscv_vreinterpret_v_bf16m1_u16m1(a), unpacket_traits<Packet1Xbf>::size));
 }
 
 template <>
@@ -371,19 +363,12 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf ploaddup<Packet1Xbf>(const bfloat16* from) {
-  Packet1Xsu data = __riscv_vreinterpret_v_bf16m1_u16m1(pload<Packet1Xbf>(from));
-  return __riscv_vreinterpret_v_i16m1_bf16m1(
-      __riscv_vreinterpret_v_i32m1_i16m1(__riscv_vreinterpret_v_u32m1_i32m1(__riscv_vlmul_trunc_v_u32m2_u32m1(
-          __riscv_vwmaccu_vx_u32m2(__riscv_vwaddu_vv_u32m2(data, data, unpacket_traits<Packet1Xs>::size), 0xffffu, data,
-                                   unpacket_traits<Packet1Xs>::size)))));
+  return __riscv_vreinterpret_v_i16m1_bf16m1(ploaddup<Packet1Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xbf ploadquad<Packet1Xbf>(const bfloat16* from) {
-  Packet1Xsu idx = __riscv_vsrl_vx_u16m1(__riscv_vid_v_u16m1(unpacket_traits<Packet1Xbf>::size), 2,
-                                         unpacket_traits<Packet1Xbf>::size);
-  return __riscv_vreinterpret_v_i16m1_bf16m1(__riscv_vrgather_vv_i16m1(
-      pload<Packet1Xs>(reinterpret_cast<const short*>(from)), idx, unpacket_traits<Packet1Xbf>::size));
+  return __riscv_vreinterpret_v_i16m1_bf16m1(ploadquad<Packet1Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
@@ -440,6 +425,19 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet1Xbf& a) {
+  const PacketMask16 mask =
+      __riscv_vmsne_vx_u16m1_b16(__riscv_vreinterpret_v_bf16m1_u16m1(a), 0, unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xbf>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xbf& a) {
+  const PacketMask16 mask = __riscv_vmfeq_vf_f32m2_b16(Bf16ToF32(a), 0.0f, unpacket_traits<Packet1Xbf>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xbf>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet1Xbf>(const Packet1Xbf& a) {
   return static_cast<bfloat16>(predux_mul<Packet2Xf>(Bf16ToF32(a)));
 }
@@ -472,6 +470,10 @@
 
 /********************************* Packet2Xbf ************************************/
 
+EIGEN_STRONG_INLINE Packet2Xbf __riscv_vreinterpret_v_u32m2_bf16m2(const Packet2Xu& a) {
+  return __riscv_vreinterpret_v_u16m2_bf16m2(__riscv_vreinterpret_v_u32m2_u16m2(a));
+}
+
 EIGEN_STRONG_INLINE Packet4Xf Bf16ToF32(const Packet2Xbf& a) {
   return __riscv_vfwcvtbf16_f_f_v_f32m4(a, unpacket_traits<Packet2Xbf>::size);
 }
@@ -482,8 +484,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf ptrue<Packet2Xbf>(const Packet2Xbf& /*a*/) {
-  return __riscv_vreinterpret_bf16m2(
+  Packet2Xbf r = __riscv_vreinterpret_bf16m2(
       __riscv_vmv_v_x_u16m2(static_cast<numext::uint16_t>(0xffffu), unpacket_traits<Packet2Xbf>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -560,11 +564,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xbf pconj(const Packet2Xbf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xbf pmul<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
   Packet4Xf c;
   return F32ToBf16(__riscv_vfwmaccbf16_vv_f32m4(pzero<Packet4Xf>(c), a, b, unpacket_traits<Packet2Xbf>::size));
@@ -628,24 +627,67 @@
   return F32ToBf16(pmax<PropagateNumbers, Packet4Xf>(Bf16ToF32(a), Bf16ToF32(b)));
 }
 
+// See the Packet1Xbf comparisons above: the vbool mask is expanded with a vmerge because an arithmetic
+// narrowing conversion (vfncvtbf16) would canonicalize the all-ones (NaN) lanes to 0x7fc0 and corrupt
+// the mask.
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf pcmp_le<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
-  return F32ToBf16(pcmp_le<Packet4Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask8 mask = __riscv_vmfle_vv_f32m4_b8(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_u16m2_bf16m2(__riscv_vmerge_vvm_u16m2(
+      __riscv_vreinterpret_v_bf16m2_u16m2(pzero<Packet2Xbf>(a)),
+      __riscv_vreinterpret_v_bf16m2_u16m2(ptrue<Packet2Xbf>(a)), mask, unpacket_traits<Packet2Xbf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf pcmp_lt<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
-  return F32ToBf16(pcmp_lt<Packet4Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask8 mask = __riscv_vmflt_vv_f32m4_b8(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_u16m2_bf16m2(__riscv_vmerge_vvm_u16m2(
+      __riscv_vreinterpret_v_bf16m2_u16m2(pzero<Packet2Xbf>(a)),
+      __riscv_vreinterpret_v_bf16m2_u16m2(ptrue<Packet2Xbf>(a)), mask, unpacket_traits<Packet2Xbf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf pcmp_eq<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
-  return F32ToBf16(pcmp_eq<Packet4Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask8 mask = __riscv_vmfeq_vv_f32m4_b8(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_u16m2_bf16m2(__riscv_vmerge_vvm_u16m2(
+      __riscv_vreinterpret_v_bf16m2_u16m2(pzero<Packet2Xbf>(a)),
+      __riscv_vreinterpret_v_bf16m2_u16m2(ptrue<Packet2Xbf>(a)), mask, unpacket_traits<Packet2Xbf>::size));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf pcmp_lt_or_nan<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
-  return F32ToBf16(pcmp_lt_or_nan<Packet4Xf>(Bf16ToF32(a), Bf16ToF32(b)));
+  PacketMask8 mask = __riscv_vmfge_vv_f32m4_b8(Bf16ToF32(a), Bf16ToF32(b), unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_u16m2_bf16m2(
+      __riscv_vmerge_vxm_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(ptrue<Packet2Xbf>(a)),
+                               static_cast<numext::uint16_t>(0), mask, unpacket_traits<Packet2Xbf>::size));
+}
+
+// See the Packet1Xbf classification above.
+template <>
+EIGEN_STRONG_INLINE Packet2Xbf pisinf<Packet2Xbf>(const Packet2Xbf& a) {
+  const vuint16m2_t abs_bits =
+      __riscv_vand_vx_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(a), 0x7fffu, unpacket_traits<Packet2Xbf>::size);
+  const PacketMask8 mask = __riscv_vmseq_vx_u16m2_b8(abs_bits, 0x7f80u, unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_i16m2_bf16m2(__riscv_vmerge_vxm_i16m2(
+      __riscv_vreinterpret_v_bf16m2_i16m2(pzero<Packet2Xbf>(a)), -1, mask, unpacket_traits<Packet2Xbf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xbf pisnan<Packet2Xbf>(const Packet2Xbf& a) {
+  const vuint16m2_t abs_bits =
+      __riscv_vand_vx_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(a), 0x7fffu, unpacket_traits<Packet2Xbf>::size);
+  const PacketMask8 mask = __riscv_vmsgtu_vx_u16m2_b8(abs_bits, 0x7f80u, unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_i16m2_bf16m2(__riscv_vmerge_vxm_i16m2(
+      __riscv_vreinterpret_v_bf16m2_i16m2(pzero<Packet2Xbf>(a)), -1, mask, unpacket_traits<Packet2Xbf>::size));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xbf pisfinite<Packet2Xbf>(const Packet2Xbf& a) {
+  const vuint16m2_t abs_bits =
+      __riscv_vand_vx_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(a), 0x7fffu, unpacket_traits<Packet2Xbf>::size);
+  const PacketMask8 mask = __riscv_vmsltu_vx_u16m2_b8(abs_bits, 0x7f80u, unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vreinterpret_v_i16m2_bf16m2(__riscv_vmerge_vxm_i16m2(
+      __riscv_vreinterpret_v_bf16m2_i16m2(pzero<Packet2Xbf>(a)), -1, mask, unpacket_traits<Packet2Xbf>::size));
 }
 
 EIGEN_STRONG_INLINE Packet2Xbf pselect(const PacketMask8& mask, const Packet2Xbf& a, const Packet2Xbf& b) {
@@ -662,7 +704,7 @@
                                                                       unpacket_traits<Packet2Xbf>::size));
 }
 
-// Logical Operations are not supported for bflaot16, so reinterpret casts
+// Logical Operations are not supported for bfloat16, so reinterpret casts
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf pand<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
   return __riscv_vreinterpret_v_u16m2_bf16m2(__riscv_vand_vv_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(a),
@@ -686,10 +728,14 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf pandnot<Packet2Xbf>(const Packet2Xbf& a, const Packet2Xbf& b) {
-  return __riscv_vreinterpret_v_u16m2_bf16m2(__riscv_vand_vv_u16m2(
-      __riscv_vreinterpret_v_bf16m2_u16m2(a),
-      __riscv_vnot_v_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(b), unpacket_traits<Packet2Xbf>::size),
-      unpacket_traits<Packet2Xbf>::size));
+  return __riscv_vreinterpret_v_i16m2_bf16m2(
+      pandnot<Packet2Xs>(__riscv_vreinterpret_v_bf16m2_i16m2(a), __riscv_vreinterpret_v_bf16m2_i16m2(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xbf pnot<Packet2Xbf>(const Packet2Xbf& a) {
+  return __riscv_vreinterpret_v_u16m2_bf16m2(
+      __riscv_vnot_v_u16m2(__riscv_vreinterpret_v_bf16m2_u16m2(a), unpacket_traits<Packet2Xbf>::size));
 }
 
 template <>
@@ -706,19 +752,12 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf ploaddup<Packet2Xbf>(const bfloat16* from) {
-  Packet2Xsu data = __riscv_vreinterpret_v_bf16m2_u16m2(pload<Packet2Xbf>(from));
-  return __riscv_vreinterpret_v_i16m2_bf16m2(
-      __riscv_vreinterpret_v_i32m2_i16m2(__riscv_vreinterpret_v_u32m2_i32m2(__riscv_vlmul_trunc_v_u32m4_u32m2(
-          __riscv_vwmaccu_vx_u32m4(__riscv_vwaddu_vv_u32m4(data, data, unpacket_traits<Packet2Xs>::size), 0xffffu, data,
-                                   unpacket_traits<Packet2Xs>::size)))));
+  return __riscv_vreinterpret_v_i16m2_bf16m2(ploaddup<Packet2Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xbf ploadquad<Packet2Xbf>(const bfloat16* from) {
-  Packet2Xsu idx = __riscv_vsrl_vx_u16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet2Xbf>::size), 2,
-                                         unpacket_traits<Packet2Xbf>::size);
-  return __riscv_vreinterpret_v_i16m2_bf16m2(__riscv_vrgather_vv_i16m2(
-      pload<Packet2Xs>(reinterpret_cast<const short*>(from)), idx, unpacket_traits<Packet2Xbf>::size));
+  return __riscv_vreinterpret_v_i16m2_bf16m2(ploadquad<Packet2Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
@@ -775,6 +814,19 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2Xbf& a) {
+  const PacketMask8 mask =
+      __riscv_vmsne_vx_u16m2_b8(__riscv_vreinterpret_v_bf16m2_u16m2(a), 0, unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xbf>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xbf& a) {
+  const PacketMask8 mask = __riscv_vmfeq_vf_f32m4_b8(Bf16ToF32(a), 0.0f, unpacket_traits<Packet2Xbf>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xbf>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE bfloat16 predux_mul<Packet2Xbf>(const Packet2Xbf& a) {
   return static_cast<bfloat16>(predux_mul<Packet4Xf>(Bf16ToF32(a)));
 }
@@ -806,10 +858,9 @@
 }
 
 template <typename Packet = Packet2Xbf>
-EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xbf>::value && (unpacket_traits<Packet2Xbf>::size % 8) == 0,
-                            Packet1Xbf>::type
-    predux_half(const Packet2Xbf& a) {
+EIGEN_STRONG_INLINE std::enable_if_t<
+    std::is_same<Packet, Packet2Xbf>::value && (unpacket_traits<Packet2Xbf>::size % 8) == 0, Packet1Xbf>
+predux_half(const Packet2Xbf& a) {
   return padd<Packet1Xbf>(__riscv_vget_v_bf16m2_bf16m1(a, 0), __riscv_vget_v_bf16m2_bf16m1(a, 1));
 }
 
diff --git a/Eigen/src/Core/arch/RVV10/PacketMathDecl.h b/Eigen/src/Core/arch/RVV10/PacketMathDecl.h
new file mode 100644
index 0000000..e17aa76
--- /dev/null
+++ b/Eigen/src/Core/arch/RVV10/PacketMathDecl.h
@@ -0,0 +1,339 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 Kseniya Zaytseva <kseniya.zaytseva@syntacore.com>
+// Copyright (C) 2025 Chip Kerchner <ckerchner@tenstorrent.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_PACKET_MATH_RVV10_DECL_H
+#define EIGEN_PACKET_MATH_RVV10_DECL_H
+
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
+#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
+#endif
+
+#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
+#endif
+
+#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 32
+
+template <typename Scalar, std::size_t VectorLength, std::size_t VectorLMul>
+struct rvv_packet_size_selector {
+  enum { size = VectorLength * VectorLMul / (sizeof(Scalar) * CHAR_BIT) };
+};
+
+template <std::size_t VectorLength, std::size_t VectorLMul>
+struct rvv_packet_alignment_selector {
+  enum {
+    alignment =
+        (VectorLength * VectorLMul) >= 1024
+            ? Aligned128
+            : ((VectorLength * VectorLMul) >= 512 ? Aligned64
+                                                  : ((VectorLength * VectorLMul) >= 256 ? Aligned32 : Aligned16))
+  };
+};
+
+typedef vbool64_t PacketMask64;
+typedef vbool32_t PacketMask32;
+typedef vbool16_t PacketMask16;
+typedef vbool8_t PacketMask8;
+typedef vbool4_t PacketMask4;
+
+template <typename Packet>
+struct rvv_half_packet {
+  typedef Packet type;
+};
+
+template <typename Packet>
+using rvv_half_packet_t = typename rvv_half_packet<Packet>::type;
+
+template <typename Scalar, typename Packet, std::size_t VectorLMul>
+struct rvv_default_unpacket_traits {
+  typedef Scalar type;
+  typedef rvv_half_packet_t<Packet> half;
+  typedef numext::uint8_t mask_t;
+  enum {
+    size = rvv_packet_size_selector<Scalar, EIGEN_RISCV64_RVV_VL, VectorLMul>::size,
+    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, VectorLMul>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+/********************************* short **************************************/
+
+typedef eigen_packet_wrapper<vint16m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 18> Packet1Xs;
+typedef eigen_packet_wrapper<vuint16m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 19> Packet1Xsu;
+
+typedef eigen_packet_wrapper<vint16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 20> Packet2Xs;
+typedef eigen_packet_wrapper<vuint16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 21>
+    Packet2Xsu;
+
+typedef eigen_packet_wrapper<vint16m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 22> Packet4Xs;
+typedef eigen_packet_wrapper<vuint16m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 23>
+    Packet4Xsu;
+
+template <>
+struct rvv_half_packet<Packet2Xs> {
+  typedef Packet1Xs type;
+};
+template <>
+struct rvv_half_packet<Packet4Xs> {
+  typedef Packet2Xs type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xs> : rvv_default_unpacket_traits<numext::int16_t, Packet1Xs, 1> {};
+
+template <>
+struct unpacket_traits<Packet2Xs> : rvv_default_unpacket_traits<numext::int16_t, Packet2Xs, 2> {};
+
+template <>
+struct unpacket_traits<Packet4Xs> : rvv_default_unpacket_traits<numext::int16_t, Packet4Xs, 4> {};
+
+/********************************* int32 **************************************/
+typedef eigen_packet_wrapper<vint32m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 0> Packet1Xi;
+typedef eigen_packet_wrapper<vuint32m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 1> Packet1Xu;
+
+typedef eigen_packet_wrapper<vint32m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 2> Packet2Xi;
+typedef eigen_packet_wrapper<vuint32m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 3> Packet2Xu;
+
+typedef eigen_packet_wrapper<vint32m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 4> Packet4Xi;
+typedef eigen_packet_wrapper<vuint32m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 5> Packet4Xu;
+
+template <>
+struct rvv_half_packet<Packet2Xi> {
+  typedef Packet1Xi type;
+};
+template <>
+struct rvv_half_packet<Packet4Xi> {
+  typedef Packet2Xi type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xi> : rvv_default_unpacket_traits<numext::int32_t, Packet1Xi, 1> {};
+template <>
+struct unpacket_traits<Packet2Xi> : rvv_default_unpacket_traits<numext::int32_t, Packet2Xi, 2> {};
+template <>
+struct unpacket_traits<Packet4Xi> : rvv_default_unpacket_traits<numext::int32_t, Packet4Xi, 4> {};
+
+/********************************* int64 **************************************/
+
+typedef eigen_packet_wrapper<vint64m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 9> Packet1Xl;
+typedef eigen_packet_wrapper<vuint64m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 10> Packet1Xul;
+
+typedef eigen_packet_wrapper<vint64m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 11> Packet2Xl;
+typedef eigen_packet_wrapper<vuint64m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 12>
+    Packet2Xul;
+
+typedef eigen_packet_wrapper<vint64m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 13> Packet4Xl;
+typedef eigen_packet_wrapper<vuint64m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 14>
+    Packet4Xul;
+
+template <>
+struct rvv_half_packet<Packet2Xl> {
+  typedef Packet1Xl type;
+};
+template <>
+struct rvv_half_packet<Packet4Xl> {
+  typedef Packet2Xl type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xl> : rvv_default_unpacket_traits<numext::int64_t, Packet1Xl, 1> {};
+
+template <>
+struct unpacket_traits<Packet2Xl> : rvv_default_unpacket_traits<numext::int64_t, Packet2Xl, 2> {};
+
+template <>
+struct unpacket_traits<Packet4Xl> : rvv_default_unpacket_traits<numext::int64_t, Packet4Xl, 4> {};
+
+/********************************* float32 ************************************/
+
+typedef eigen_packet_wrapper<vfloat32m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 6> Packet1Xf;
+typedef eigen_packet_wrapper<vfloat32m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 7>
+    Packet2Xf;
+typedef eigen_packet_wrapper<vfloat32m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 8>
+    Packet4Xf;
+
+template <>
+struct rvv_half_packet<Packet2Xf> {
+  typedef Packet1Xf type;
+};
+template <>
+struct rvv_half_packet<Packet4Xf> {
+  typedef Packet2Xf type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xf> : rvv_default_unpacket_traits<float, Packet1Xf, 1> {
+  typedef Packet1Xi integer_packet;
+  typedef PacketMask32 packet_mask;
+};
+
+template <>
+struct unpacket_traits<Packet2Xf> : rvv_default_unpacket_traits<float, Packet2Xf, 2> {
+  typedef Packet2Xi integer_packet;
+  typedef PacketMask16 packet_mask;
+};
+
+template <>
+struct unpacket_traits<Packet4Xf> : rvv_default_unpacket_traits<float, Packet4Xf, 4> {
+  typedef Packet4Xi integer_packet;
+  typedef PacketMask8 packet_mask;
+};
+
+/********************************* double ************************************/
+
+typedef eigen_packet_wrapper<vfloat64m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 15> Packet1Xd;
+typedef eigen_packet_wrapper<vfloat64m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 16>
+    Packet2Xd;
+typedef eigen_packet_wrapper<vfloat64m4_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 4))), 17>
+    Packet4Xd;
+
+template <>
+struct rvv_half_packet<Packet2Xd> {
+  typedef Packet1Xd type;
+};
+template <>
+struct rvv_half_packet<Packet4Xd> {
+  typedef Packet2Xd type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xd> : rvv_default_unpacket_traits<double, Packet1Xd, 1> {
+  typedef Packet1Xl integer_packet;
+  typedef PacketMask64 packet_mask;
+};
+
+template <>
+struct unpacket_traits<Packet2Xd> : rvv_default_unpacket_traits<double, Packet2Xd, 2> {
+  typedef Packet2Xl integer_packet;
+  typedef PacketMask32 packet_mask;
+};
+
+template <>
+struct unpacket_traits<Packet4Xd> : rvv_default_unpacket_traits<double, Packet4Xd, 4> {
+  typedef Packet4Xl integer_packet;
+  typedef PacketMask16 packet_mask;
+};
+
+/********************************* char ************************************/
+
+typedef eigen_packet_wrapper<vint8m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 28> Packet1Xc;
+
+template <>
+struct unpacket_traits<Packet1Xc> : rvv_default_unpacket_traits<numext::int8_t, Packet1Xc, 1> {};
+
+/********************************* default **************************************/
+
+#if EIGEN_RISCV64_DEFAULT_LMUL == 1
+typedef Packet1Xs PacketXs;
+typedef Packet1Xsu PacketXsu;
+typedef Packet1Xi PacketXi;
+typedef Packet1Xu PacketXu;
+typedef Packet1Xl PacketXl;
+typedef Packet1Xul PacketXul;
+typedef Packet1Xf PacketXf;
+typedef Packet1Xd PacketXd;
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 2
+typedef Packet2Xs PacketXs;
+typedef Packet2Xsu PacketXsu;
+typedef Packet2Xi PacketXi;
+typedef Packet2Xu PacketXu;
+typedef Packet2Xl PacketXl;
+typedef Packet2Xul PacketXul;
+typedef Packet2Xf PacketXf;
+typedef Packet2Xd PacketXd;
+#elif EIGEN_RISCV64_DEFAULT_LMUL == 4
+typedef Packet4Xs PacketXs;
+typedef Packet4Xsu PacketXsu;
+typedef Packet4Xi PacketXi;
+typedef Packet4Xu PacketXu;
+typedef Packet4Xl PacketXl;
+typedef Packet4Xul PacketXul;
+typedef Packet4Xf PacketXf;
+typedef Packet4Xd PacketXd;
+#endif
+
+template <typename Scalar, typename Packet>
+struct rvv_default_packet_traits : default_packet_traits {
+  typedef Packet type;
+  typedef rvv_half_packet_t<type> half;
+
+  enum {
+    size = unpacket_traits<Packet>::size,
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    HasCmp = 1
+  };
+};
+
+template <typename Scalar, typename Packet>
+struct rvv_default_float_packet_traits : rvv_default_packet_traits<Scalar, Packet> {
+  enum {
+    HasDiv = 1,
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasTan = EIGEN_FAST_MATH,
+    HasLog = 1,
+    HasExp = 1,
+    HasSqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = EIGEN_FAST_MATH
+  };
+};
+
+template <>
+struct packet_traits<numext::int16_t> : rvv_default_packet_traits<numext::int16_t, PacketXs> {};
+
+template <>
+struct packet_traits<numext::int32_t> : rvv_default_packet_traits<numext::int32_t, PacketXi> {};
+
+template <>
+struct packet_traits<numext::int64_t> : rvv_default_packet_traits<numext::int64_t, PacketXl> {};
+
+template <>
+struct packet_traits<float> : rvv_default_float_packet_traits<float, PacketXf> {};
+
+template <>
+struct packet_traits<double> : rvv_default_float_packet_traits<double, PacketXd> {};
+
+/********************************* prefetch **************************************/
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<numext::int16_t>(const numext::int16_t* addr) {
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  __builtin_prefetch(addr);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<numext::int32_t>(const numext::int32_t* addr) {
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  __builtin_prefetch(addr);
+#endif
+}
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<numext::int64_t>(const numext::int64_t* addr) {
+#if EIGEN_HAS_BUILTIN(__builtin_prefetch) || EIGEN_COMP_GNUC
+  __builtin_prefetch(addr);
+#endif
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_PACKET_MATH_RVV10_DECL_H
diff --git a/Eigen/src/Core/arch/RVV10/PacketMathFP16.h b/Eigen/src/Core/arch/RVV10/PacketMathFP16.h
index 73118a3..0b6fdd5 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMathFP16.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMathFP16.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_FP16_RVV10_H
 #define EIGEN_PACKET_MATH_FP16_RVV10_H
@@ -20,128 +21,73 @@
 typedef eigen_packet_wrapper<vfloat16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 25>
     Packet2Xh;
 
+template <>
+struct rvv_half_packet<Packet2Xh> {
+  typedef Packet1Xh type;
+};
+
+template <>
+struct unpacket_traits<Packet1Xh> : rvv_default_unpacket_traits<Eigen::half, Packet1Xh, 1> {
+  typedef Packet1Xs integer_packet;
+  typedef PacketMask16 packet_mask;
+};
+
+template <>
+struct unpacket_traits<Packet2Xh> : rvv_default_unpacket_traits<Eigen::half, Packet2Xh, 2> {
+  typedef Packet2Xs integer_packet;
+  typedef PacketMask8 packet_mask;
+};
+
 #if EIGEN_RISCV64_DEFAULT_LMUL == 1
 typedef Packet1Xh PacketXh;
-
-template <>
-struct packet_traits<Eigen::half> : default_packet_traits {
-  typedef Packet1Xh type;
-  typedef Packet1Xh half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<Eigen::half, EIGEN_RISCV64_RVV_VL, 1>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasSin = EIGEN_FAST_MATH,
-    HasCos = EIGEN_FAST_MATH,
-    HasLog = 0,
-    HasExp = 0,
-    HasSqrt = 1,
-    HasTanh = EIGEN_FAST_MATH,
-    HasErf = 0
-  };
-};
-
 #else
 typedef Packet2Xh PacketXh;
-
-template <>
-struct packet_traits<Eigen::half> : default_packet_traits {
-  typedef Packet2Xh type;
-  typedef Packet1Xh half;
-
-  enum {
-    Vectorizable = 1,
-    AlignedOnScalar = 1,
-    size = rvv_packet_size_selector<Eigen::half, EIGEN_RISCV64_RVV_VL, 2>::size,
-
-    HasAdd = 1,
-    HasSub = 1,
-    HasShift = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 1,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 1,
-    HasSetLinear = 0,
-    HasBlend = 0,
-    HasReduxp = 0,
-
-    HasCmp = 1,
-    HasDiv = 1,
-    HasRound = 1,
-
-    HasSin = EIGEN_FAST_MATH,
-    HasCos = EIGEN_FAST_MATH,
-    HasLog = 0,
-    HasExp = 0,
-    HasSqrt = 1,
-    HasTanh = EIGEN_FAST_MATH,
-    HasErf = 0
-  };
-};
 #endif
 
 template <>
-struct unpacket_traits<Packet1Xh> {
-  typedef Eigen::half type;
-  typedef Packet1Xh half;  // Half not yet implemented
-  typedef Packet1Xs integer_packet;
-  typedef numext::uint8_t mask_t;
-
+struct packet_traits<Eigen::half> : rvv_default_packet_traits<Eigen::half, PacketXh> {
   enum {
-    size = rvv_packet_size_selector<Eigen::half, EIGEN_RISCV64_RVV_VL, 1>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 1>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
-  };
-};
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 1,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasBlend = 0,
+    HasReduxp = 0,
+    HasSign = 0,
 
-template <>
-struct unpacket_traits<Packet2Xh> {
-  typedef Eigen::half type;
-  typedef Packet1Xh half;
-  typedef Packet2Xs integer_packet;
-  typedef numext::uint8_t mask_t;
+    HasCmp = 1,
+    HasDiv = 1,
+    HasRound = 1,
 
-  enum {
-    size = rvv_packet_size_selector<Eigen::half, EIGEN_RISCV64_RVV_VL, 2>::size,
-    alignment = rvv_packet_alignment_selector<EIGEN_RISCV64_RVV_VL, 2>::alignment,
-    vectorizable = true,
-    masked_load_available = false,
-    masked_store_available = false
+    HasSin = EIGEN_FAST_MATH,
+    HasCos = EIGEN_FAST_MATH,
+    HasLog = 0,
+    HasExp = 0,
+    HasSqrt = 1,
+    HasTanh = EIGEN_FAST_MATH,
+    HasErf = 0
   };
 };
 
 /********************************* Packet1Xh ************************************/
 
+EIGEN_STRONG_INLINE Packet1Xh __riscv_vreinterpret_v_u32m1_f16m1(const Packet1Xu& a) {
+  return __riscv_vreinterpret_v_u16m1_f16m1(__riscv_vreinterpret_v_u32m1_u16m1(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet1Xh ptrue<Packet1Xh>(const Packet1Xh& /*a*/) {
-  return __riscv_vreinterpret_f16m1(__riscv_vmv_v_x_u16m1(0xffffu, unpacket_traits<Packet1Xh>::size));
+  Packet1Xh r = __riscv_vreinterpret_f16m1(__riscv_vmv_v_x_u16m1(0xffffu, unpacket_traits<Packet1Xh>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -210,11 +156,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xh pconj(const Packet1Xh& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xh pmul<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
   return __riscv_vfmul_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
 }
@@ -245,6 +186,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet1Xh> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet1Xh pmin<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
   const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
   Packet1Xh nans = __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet1Xh>::size);
@@ -256,11 +200,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xh pmin<PropagateNaN, Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
-  return pmin<Packet1Xh>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xh pmin<PropagateNumbers, Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
   return __riscv_vfmin_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
 }
@@ -277,11 +216,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1Xh pmax<PropagateNaN, Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
-  return pmax<Packet1Xh>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet1Xh pmax<PropagateNumbers, Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
   return __riscv_vfmax_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
 }
@@ -343,11 +277,15 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE Packet1Xh pnot<Packet1Xh>(const Packet1Xh& a) {
+  return __riscv_vreinterpret_v_u16m1_f16m1(
+      __riscv_vnot_v_u16m1(__riscv_vreinterpret_v_f16m1_u16m1(a), unpacket_traits<Packet1Xh>::size));
+}
+
+template <>
 EIGEN_STRONG_INLINE Packet1Xh pandnot<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
-  return __riscv_vreinterpret_v_u16m1_f16m1(__riscv_vand_vv_u16m1(
-      __riscv_vreinterpret_v_f16m1_u16m1(a),
-      __riscv_vnot_v_u16m1(__riscv_vreinterpret_v_f16m1_u16m1(b), unpacket_traits<Packet1Xh>::size),
-      unpacket_traits<Packet1Xh>::size));
+  return __riscv_vreinterpret_v_i16m1_f16m1(
+      pandnot<Packet1Xs>(__riscv_vreinterpret_v_f16m1_i16m1(a), __riscv_vreinterpret_v_f16m1_i16m1(b)));
 }
 
 template <>
@@ -364,18 +302,12 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xh ploaddup<Packet1Xh>(const Eigen::half* from) {
-  Packet1Xsu data = __riscv_vreinterpret_v_f16m1_u16m1(pload<Packet1Xh>(from));
-  return __riscv_vreinterpret_v_i16m1_f16m1(
-      __riscv_vreinterpret_v_i32m1_i16m1(__riscv_vreinterpret_v_u32m1_i32m1(__riscv_vlmul_trunc_v_u32m2_u32m1(
-          __riscv_vwmaccu_vx_u32m2(__riscv_vwaddu_vv_u32m2(data, data, unpacket_traits<Packet1Xs>::size), 0xffffu, data,
-                                   unpacket_traits<Packet1Xs>::size)))));
+  return __riscv_vreinterpret_v_i16m1_f16m1(ploaddup<Packet1Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet1Xh ploadquad<Packet1Xh>(const Eigen::half* from) {
-  Packet1Xsu idx =
-      __riscv_vsrl_vx_u16m1(__riscv_vid_v_u16m1(unpacket_traits<Packet1Xh>::size), 2, unpacket_traits<Packet1Xh>::size);
-  return __riscv_vrgather_vv_f16m1(pload<Packet1Xh>(from), idx, unpacket_traits<Packet1Xh>::size);
+  return __riscv_vreinterpret_v_i16m1_f16m1(ploadquad<Packet1Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
@@ -449,20 +381,33 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet1Xh& a) {
+  const PacketMask16 mask =
+      __riscv_vmsne_vx_u16m1_b16(__riscv_vreinterpret_v_f16m1_u16m1(a), 0, unpacket_traits<Packet1Xh>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xh>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet1Xh& a) {
+  const PacketMask16 mask = __riscv_vmfeq_vf_f16m1_b16(a, static_cast<_Float16>(0.0), unpacket_traits<Packet1Xh>::size);
+  return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xh>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet1Xh>(const Packet1Xh& a) {
   // Multiply the vector by its reverse
   Packet1Xh prod = __riscv_vfmul_vv_f16m1(preverse(a), a, unpacket_traits<Packet1Xh>::size);
   Packet1Xh half_prod;
 
-  if (EIGEN_RISCV64_RVV_VL >= 1024) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
     half_prod = __riscv_vslidedown_vx_f16m1(prod, 16, unpacket_traits<Packet1Xh>::size);
     prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 512) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
     half_prod = __riscv_vslidedown_vx_f16m1(prod, 8, unpacket_traits<Packet1Xh>::size);
     prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
   }
-  if (EIGEN_RISCV64_RVV_VL >= 256) {
+  EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
     half_prod = __riscv_vslidedown_vx_f16m1(prod, 4, unpacket_traits<Packet1Xh>::size);
     prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
   }
@@ -477,24 +422,18 @@
   return pfirst(prod);
 }
 
+// Reusing the first lane is exact for an idempotent reduction and avoids a NaN seed that becomes poison under
+// finite fast-math.
 template <>
 EIGEN_STRONG_INLINE Eigen::half predux_min<Packet1Xh>(const Packet1Xh& a) {
-  const Eigen::half max = (std::numeric_limits<Eigen::half>::max)();
-  const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
-  return (std::min)(static_cast<Eigen::half>(__riscv_vfmv_f(__riscv_vfredmin_vs_f16m1_f16m1(
-                        a, __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet1Xh>::size),
-                        unpacket_traits<Packet1Xh>::size))),
-                    max);
+  return static_cast<Eigen::half>(
+      __riscv_vfmv_f(__riscv_vfredmin_vs_f16m1_f16m1(a, a, unpacket_traits<Packet1Xh>::size)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Eigen::half predux_max<Packet1Xh>(const Packet1Xh& a) {
-  const Eigen::half min = -(std::numeric_limits<Eigen::half>::max)();
-  const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
-  return (std::max)(static_cast<Eigen::half>(__riscv_vfmv_f(__riscv_vfredmax_vs_f16m1_f16m1(
-                        a, __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet1Xh>::size),
-                        unpacket_traits<Packet1Xh>::size))),
-                    min);
+  return static_cast<Eigen::half>(
+      __riscv_vfmv_f(__riscv_vfredmax_vs_f16m1_f16m1(a, a, unpacket_traits<Packet1Xh>::size)));
 }
 
 template <int N>
@@ -523,9 +462,15 @@
 
 /********************************* Packet2Xh ************************************/
 
+EIGEN_STRONG_INLINE Packet2Xh __riscv_vreinterpret_v_u32m2_f16m2(const Packet2Xu& a) {
+  return __riscv_vreinterpret_v_u16m2_f16m2(__riscv_vreinterpret_v_u32m2_u16m2(a));
+}
+
 template <>
 EIGEN_STRONG_INLINE Packet2Xh ptrue<Packet2Xh>(const Packet2Xh& /*a*/) {
-  return __riscv_vreinterpret_f16m2(__riscv_vmv_v_x_u16m2(0xffffu, unpacket_traits<Packet2Xh>::size));
+  Packet2Xh r = __riscv_vreinterpret_f16m2(__riscv_vmv_v_x_u16m2(0xffffu, unpacket_traits<Packet2Xh>::size));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -594,11 +539,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xh pconj(const Packet2Xh& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xh pmul<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
   return __riscv_vfmul_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
 }
@@ -629,6 +569,9 @@
 }
 
 template <>
+struct pminmax_propagates_nan<Packet2Xh> : bool_constant<true> {};
+
+template <>
 EIGEN_STRONG_INLINE Packet2Xh pmin<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
   const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
   Packet2Xh nans = __riscv_vfmv_v_f_f16m2(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet2Xh>::size);
@@ -640,11 +583,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xh pmin<PropagateNaN, Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
-  return pmin<Packet2Xh>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xh pmin<PropagateNumbers, Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
   return __riscv_vfmin_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
 }
@@ -661,11 +599,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet2Xh pmax<PropagateNaN, Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
-  return pmax<Packet2Xh>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet2Xh pmax<PropagateNumbers, Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
   return __riscv_vfmax_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
 }
@@ -728,10 +661,14 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xh pandnot<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
-  return __riscv_vreinterpret_v_u16m2_f16m2(__riscv_vand_vv_u16m2(
-      __riscv_vreinterpret_v_f16m2_u16m2(a),
-      __riscv_vnot_v_u16m2(__riscv_vreinterpret_v_f16m2_u16m2(b), unpacket_traits<Packet2Xh>::size),
-      unpacket_traits<Packet2Xh>::size));
+  return __riscv_vreinterpret_v_i16m2_f16m2(
+      pandnot<Packet2Xs>(__riscv_vreinterpret_v_f16m2_i16m2(a), __riscv_vreinterpret_v_f16m2_i16m2(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE Packet2Xh pnot<Packet2Xh>(const Packet2Xh& a) {
+  return __riscv_vreinterpret_v_u16m2_f16m2(
+      __riscv_vnot_v_u16m2(__riscv_vreinterpret_v_f16m2_u16m2(a), unpacket_traits<Packet2Xh>::size));
 }
 
 template <>
@@ -748,18 +685,12 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xh ploaddup<Packet2Xh>(const Eigen::half* from) {
-  Packet2Xsu data = __riscv_vreinterpret_v_f16m2_u16m2(pload<Packet2Xh>(from));
-  return __riscv_vreinterpret_v_i16m2_f16m2(
-      __riscv_vreinterpret_v_i32m2_i16m2(__riscv_vreinterpret_v_u32m2_i32m2(__riscv_vlmul_trunc_v_u32m4_u32m2(
-          __riscv_vwmaccu_vx_u32m4(__riscv_vwaddu_vv_u32m4(data, data, unpacket_traits<Packet2Xs>::size), 0xffffu, data,
-                                   unpacket_traits<Packet2Xs>::size)))));
+  return __riscv_vreinterpret_v_i16m2_f16m2(ploaddup<Packet2Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet2Xh ploadquad<Packet2Xh>(const Eigen::half* from) {
-  Packet2Xsu idx =
-      __riscv_vsrl_vx_u16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet2Xh>::size), 2, unpacket_traits<Packet2Xh>::size);
-  return __riscv_vrgather_vv_f16m2(pload<Packet2Xh>(from), idx, unpacket_traits<Packet2Xh>::size);
+  return __riscv_vreinterpret_v_i16m2_f16m2(ploadquad<Packet2Xs>(reinterpret_cast<const numext::int16_t*>(from)));
 }
 
 template <>
@@ -833,6 +764,19 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2Xh& a) {
+  const PacketMask8 mask =
+      __riscv_vmsne_vx_u16m2_b8(__riscv_vreinterpret_v_f16m2_u16m2(a), 0, unpacket_traits<Packet2Xh>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xh>::size) != 0;
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const Packet2Xh& a) {
+  const PacketMask8 mask = __riscv_vmfeq_vf_f16m2_b8(a, static_cast<_Float16>(0.0), unpacket_traits<Packet2Xh>::size);
+  return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xh>::size) == 0;
+}
+
+template <>
 EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet2Xh>(const Packet2Xh& a) {
   return predux_mul<Packet1Xh>(__riscv_vfmul_vv_f16m1(
       __riscv_vget_v_f16m2_f16m1(a, 0), __riscv_vget_v_f16m2_f16m1(a, 1), unpacket_traits<Packet1Xh>::size));
@@ -840,24 +784,14 @@
 
 template <>
 EIGEN_STRONG_INLINE Eigen::half predux_min<Packet2Xh>(const Packet2Xh& a) {
-  const Eigen::half max = (std::numeric_limits<Eigen::half>::max)();
-  const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
-  return (std::min)(
-      static_cast<Eigen::half>(__riscv_vfmv_f(__riscv_vfredmin_vs_f16m2_f16m1(
-          a, __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet2Xh>::size / 2),
-          unpacket_traits<Packet2Xh>::size))),
-      max);
+  return static_cast<Eigen::half>(__riscv_vfmv_f(
+      __riscv_vfredmin_vs_f16m2_f16m1(a, __riscv_vget_v_f16m2_f16m1(a, 0), unpacket_traits<Packet2Xh>::size)));
 }
 
 template <>
 EIGEN_STRONG_INLINE Eigen::half predux_max<Packet2Xh>(const Packet2Xh& a) {
-  const Eigen::half min = -(std::numeric_limits<Eigen::half>::max)();
-  const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
-  return (std::max)(
-      static_cast<Eigen::half>(__riscv_vfmv_f(__riscv_vfredmax_vs_f16m2_f16m1(
-          a, __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet2Xh>::size / 2),
-          unpacket_traits<Packet2Xh>::size))),
-      min);
+  return static_cast<Eigen::half>(__riscv_vfmv_f(
+      __riscv_vfredmax_vs_f16m2_f16m1(a, __riscv_vget_v_f16m2_f16m1(a, 0), unpacket_traits<Packet2Xh>::size)));
 }
 
 template <int N>
@@ -886,8 +820,7 @@
 
 template <typename Packet = Packet2Xh>
 EIGEN_STRONG_INLINE
-    typename std::enable_if<std::is_same<Packet, Packet2Xh>::value && (unpacket_traits<Packet2Xh>::size % 8) == 0,
-                            Packet1Xh>::type
+    std::enable_if_t<std::is_same<Packet, Packet2Xh>::value && (unpacket_traits<Packet2Xh>::size % 8) == 0, Packet1Xh>
     predux_half(const Packet2Xh& a) {
   return __riscv_vfadd_vv_f16m1(__riscv_vget_v_f16m2_f16m1(a, 0), __riscv_vget_v_f16m2_f16m1(a, 1),
                                 unpacket_traits<Packet1Xh>::size);
diff --git a/Eigen/src/Core/arch/RVV10/TypeCasting.h b/Eigen/src/Core/arch/RVV10/TypeCasting.h
index 2b0d3db..5c9491e 100644
--- a/Eigen/src/Core/arch/RVV10/TypeCasting.h
+++ b/Eigen/src/Core/arch/RVV10/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_RVV10_H
 #define EIGEN_TYPE_CASTING_RVV10_H
@@ -90,13 +91,13 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xi pcast<Packet1Xi, Packet4Xi>(const Packet1Xi& a, const Packet1Xi& b, const Packet1Xi& c,
-                                                               const Packet1Xi& d) {
+                                                          const Packet1Xi& d) {
   return __riscv_vcreate_v_i32m1_i32m4(a, b, c, d);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xf pcast<Packet1Xi, Packet4Xf>(const Packet1Xi& a, const Packet1Xi& b, const Packet1Xi& c,
-                                                               const Packet1Xi& d) {
+                                                          const Packet1Xi& d) {
   return __riscv_vcreate_v_f32m1_f32m4(__riscv_vfcvt_f_x_v_f32m1(a, unpacket_traits<Packet1Xi>::size),
                                        __riscv_vfcvt_f_x_v_f32m1(b, unpacket_traits<Packet1Xi>::size),
                                        __riscv_vfcvt_f_x_v_f32m1(c, unpacket_traits<Packet1Xi>::size),
@@ -105,13 +106,13 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xf pcast<Packet1Xf, Packet4Xf>(const Packet1Xf& a, const Packet1Xf& b, const Packet1Xf& c,
-                                                               const Packet1Xf& d) {
+                                                          const Packet1Xf& d) {
   return __riscv_vcreate_v_f32m1_f32m4(a, b, c, d);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xi pcast<Packet1Xf, Packet4Xi>(const Packet1Xf& a, const Packet1Xf& b, const Packet1Xf& c,
-                                                               const Packet1Xf& d) {
+                                                          const Packet1Xf& d) {
   return __riscv_vcreate_v_i32m1_i32m4(__riscv_vfcvt_rtz_x_f_v_i32m1(a, unpacket_traits<Packet1Xf>::size),
                                        __riscv_vfcvt_rtz_x_f_v_i32m1(b, unpacket_traits<Packet1Xf>::size),
                                        __riscv_vfcvt_rtz_x_f_v_i32m1(c, unpacket_traits<Packet1Xf>::size),
@@ -214,14 +215,13 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xl pcast<Packet1Xl, Packet4Xl>(const Packet1Xl& a, const Packet1Xl& b, const Packet1Xl& c,
-                                                               const Packet1Xl& d) {
+                                                          const Packet1Xl& d) {
   return __riscv_vcreate_v_i64m1_i64m4(a, b, c, d);
-  ;
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xd pcast<Packet1Xl, Packet4Xd>(const Packet1Xl& a, const Packet1Xl& b, const Packet1Xl& c,
-                                                               const Packet1Xl& d) {
+                                                          const Packet1Xl& d) {
   return __riscv_vcreate_v_f64m1_f64m4(__riscv_vfcvt_f_x_v_f64m1(a, unpacket_traits<Packet1Xl>::size),
                                        __riscv_vfcvt_f_x_v_f64m1(b, unpacket_traits<Packet1Xl>::size),
                                        __riscv_vfcvt_f_x_v_f64m1(c, unpacket_traits<Packet1Xl>::size),
@@ -230,13 +230,13 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xd pcast<Packet1Xd, Packet4Xd>(const Packet1Xd& a, const Packet1Xd& b, const Packet1Xd& c,
-                                                               const Packet1Xd& d) {
+                                                          const Packet1Xd& d) {
   return __riscv_vcreate_v_f64m1_f64m4(a, b, c, d);
 }
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xl pcast<Packet1Xd, Packet4Xl>(const Packet1Xd& a, const Packet1Xd& b, const Packet1Xd& c,
-                                                               const Packet1Xd& d) {
+                                                          const Packet1Xd& d) {
   return __riscv_vcreate_v_i64m1_i64m4(__riscv_vfcvt_rtz_x_f_v_i64m1(a, unpacket_traits<Packet1Xd>::size),
                                        __riscv_vfcvt_rtz_x_f_v_i64m1(b, unpacket_traits<Packet1Xd>::size),
                                        __riscv_vfcvt_rtz_x_f_v_i64m1(c, unpacket_traits<Packet1Xd>::size),
@@ -274,7 +274,7 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4Xs pcast<Packet1Xs, Packet4Xs>(const Packet1Xs& a, const Packet1Xs& b, const Packet1Xs& c,
-                                                               const Packet1Xs& d) {
+                                                          const Packet1Xs& d) {
   return __riscv_vcreate_v_i16m1_i16m4(a, b, c, d);
 }
 
diff --git a/Eigen/src/Core/arch/SME/GeneralBlockPanelKernel.h b/Eigen/src/Core/arch/SME/GeneralBlockPanelKernel.h
new file mode 100644
index 0000000..0e4cd83
--- /dev/null
+++ b/Eigen/src/Core/arch/SME/GeneralBlockPanelKernel.h
@@ -0,0 +1,2529 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SME_GENERALBLOCKPANELKERNEL_H
+#define EIGEN_SME_GENERALBLOCKPANELKERNEL_H
+
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
+#include <arm_sme.h>
+
+namespace Eigen {
+namespace internal {
+
+// ---------------------------------------------------------------------------
+// Streaming vector length and tile geometry.
+//
+// The micro-kernel is organised around a logical mr x nr output block, packed
+// depth-major (mr contiguous scalars per depth step).  Those dimensions are
+// compile-time constants: they feed gebp_traits (cache blocking) and the
+// packers, none of which can depend on a runtime value.
+//
+// The *physical* tiling of that block onto ZA tiles, on the other hand, is
+// driven by the runtime streaming vector length.  A ZA tile of Scalar is
+// svl x svl, where svl is the number of Scalars in a streaming vector
+// (svcntsw() for fp32, svcntsd() for fp64).  The block is covered by up to a
+// 2x2 grid of svl x svl tiles, iterated in sub-block passes when the grid is
+// smaller than the block (and predicated down to it when larger).
+//
+// fp32 uses the 4 ZA.S tiles, so the 2x2 grid is all of ZA.  fp64 uses ZA.D, of
+// which there are 8, and deliberately leaves tiles 4-7 idle: a 2x2 grid loads 2
+// packed vectors per side per depth step to feed 4 FMOPAs, i.e. 64 bytes of
+// packed panel per FMOPA at either element width, and FMOPA issues at the same
+// rate for both.  A 2x4 grid over all eight needs a quarter less panel traffic
+// per FMOPA and still measures 0.92-1.00x of the 2x2 on Apple M4, so the wider
+// block is not worth its L1 footprint.
+//
+// A complex accumulator is a *pair* of tiles holding its real and imaginary
+// halves, since FMOPA only takes real operands, so complex<float> gets a 1x2
+// grid of pairs out of ZA.S and complex<double> a 2x2 grid out of ZA.D.  The
+// packed panels are correspondingly split -- one depth step holds the real
+// parts of the panel width then the imaginary ones -- so the four real outer
+// products a complex one expands to reuse both operands and the panel traffic
+// per FMOPA halves relative to the real kernels.
+//
+// This translation unit must be built without -msve-vector-bits (scalable/VLA
+// mode); see the guard in ConfigureVectorization.h for the rationale.
+// Everything below derives lane counts/predicates from the runtime svl; when a
+// block matches the tile grid exactly, the micro-kernel additionally switches
+// to a hand-scheduled multi-vector-load loop (see sme_process).
+// ---------------------------------------------------------------------------
+
+// The per-element-width half of the ACLE surface: everything the kernel needs
+// that is selected by the element type alone rather than by an argument.
+// Operations that can be overloaded on their arguments are free functions
+// below, and the ones taking a ZA tile number take it as a template parameter
+// because the underlying instructions encode it as an immediate.
+//
+// `whilelt` takes int64_t in both specializations rather than the caller's own
+// integer type: svwhilelt_b* is overloaded on the four fixed-width types only,
+// so an argument of a distinct type of the same width -- `Index` wherever
+// int64_t is `long long` -- matches none of them exactly.  Signed, because
+// every bound the packers pass is a non-negative Index.
+template <typename Scalar>
+struct sme_traits;
+
+// ZA tile count at a given element width: 4 ZA.S tiles, 8 ZA.D tiles.  This is
+// architectural rather than feature-dependent, so it stays outside sme_traits,
+// which has no double specialization without FEAT_SME_F64F64.
+template <typename RealScalar>
+struct sme_tile_count;
+template <>
+struct sme_tile_count<float> {
+  static constexpr int value = 4;
+};
+template <>
+struct sme_tile_count<double> {
+  static constexpr int value = 8;
+};
+
+template <>
+struct sme_traits<float> {
+  using Vec = svfloat32_t;
+  using Vec2 = svfloat32x2_t;
+  using Vec4 = svfloat32x4_t;
+  static EIGEN_ALWAYS_INLINE int svl() __arm_streaming_compatible { return static_cast<int>(svcntsw()); }
+  static EIGEN_ALWAYS_INLINE svbool_t whilelt(int64_t begin, int64_t end) __arm_streaming {
+    return svwhilelt_b32(begin, end);
+  }
+  static EIGEN_ALWAYS_INLINE svbool_t ptrue() __arm_streaming { return svptrue_b32(); }
+  static EIGEN_ALWAYS_INLINE svcount_t ptrue_c() __arm_streaming { return svptrue_c32(); }
+  static EIGEN_ALWAYS_INLINE Vec dup(float x) __arm_streaming { return svdup_f32(x); }
+};
+
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+template <>
+struct sme_traits<double> {
+  using Vec = svfloat64_t;
+  using Vec2 = svfloat64x2_t;
+  using Vec4 = svfloat64x4_t;
+  static EIGEN_ALWAYS_INLINE int svl() __arm_streaming_compatible { return static_cast<int>(svcntsd()); }
+  static EIGEN_ALWAYS_INLINE svbool_t whilelt(int64_t begin, int64_t end) __arm_streaming {
+    return svwhilelt_b64(begin, end);
+  }
+  static EIGEN_ALWAYS_INLINE svbool_t ptrue() __arm_streaming { return svptrue_b64(); }
+  static EIGEN_ALWAYS_INLINE svcount_t ptrue_c() __arm_streaming { return svptrue_c64(); }
+  static EIGEN_ALWAYS_INLINE Vec dup(double x) __arm_streaming { return svdup_f64(x); }
+};
+#endif
+
+// Contiguous predicated load/store, fused multiply-add and multiply.
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_ld1(svbool_t pg, const float* p) __arm_streaming { return svld1_f32(pg, p); }
+static EIGEN_ALWAYS_INLINE void sme_st1(svbool_t pg, float* p, svfloat32_t v) __arm_streaming { svst1_f32(pg, p, v); }
+static EIGEN_ALWAYS_INLINE svfloat32x2_t sme_ld1_x2(svcount_t pn, const float* p) __arm_streaming {
+  return svld1_f32_x2(pn, p);
+}
+static EIGEN_ALWAYS_INLINE svfloat32x4_t sme_ld1_x4(svcount_t pn, const float* p) __arm_streaming {
+  return svld1_f32_x4(pn, p);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_mla(svbool_t pg, svfloat32_t acc, svfloat32_t a,
+                                               svfloat32_t b) __arm_streaming {
+  return svmla_f32_x(pg, acc, a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_mul(svbool_t pg, svfloat32_t a, svfloat32_t b) __arm_streaming {
+  return svmul_f32_x(pg, a, b);
+}
+template <int Lane>
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_get(svfloat32x2_t v) __arm_streaming {
+  return svget2_f32(v, Lane);
+}
+template <int Lane>
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_get(svfloat32x4_t v) __arm_streaming {
+  return svget4_f32(v, Lane);
+}
+
+// ZA tile access. The tile number is an instruction immediate, hence a template
+// parameter; the slice number is a register operand and stays a value.
+template <int Tile>
+static EIGEN_ALWAYS_INLINE void sme_ld1_hor_za(uint32_t slice, svbool_t pg,
+                                               const float* p) __arm_streaming __arm_inout("za") {
+  svld1_hor_za32(Tile, slice, pg, p);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_read_hor_za(svfloat32_t zero, svbool_t pg,
+                                                       uint32_t slice) __arm_streaming __arm_inout("za") {
+  return svread_hor_za32_f32_m(zero, pg, Tile, slice);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_read_ver_za(svfloat32_t zero, svbool_t pg,
+                                                       uint32_t slice) __arm_streaming __arm_inout("za") {
+  return svread_ver_za32_f32_m(zero, pg, Tile, slice);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE void sme_mopa(svbool_t pm, svbool_t pn, svfloat32_t a,
+                                         svfloat32_t b) __arm_streaming __arm_inout("za") {
+  svmopa_za32_f32_m(Tile, pm, pn, a, b);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE void sme_mops(svbool_t pm, svbool_t pn, svfloat32_t a,
+                                         svfloat32_t b) __arm_streaming __arm_inout("za") {
+  svmops_za32_f32_m(Tile, pm, pn, a, b);
+}
+
+// Fused multiply-subtract, negation, and the de-/interleaving permutes the
+// complex kernel needs on top of the real one.
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_mls(svbool_t pg, svfloat32_t acc, svfloat32_t a,
+                                               svfloat32_t b) __arm_streaming {
+  return svmls_f32_x(pg, acc, a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_add(svbool_t pg, svfloat32_t a, svfloat32_t b) __arm_streaming {
+  return svadd_f32_x(pg, a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_neg(svbool_t pg, svfloat32_t v) __arm_streaming {
+  return svneg_f32_x(pg, v);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_uzp1(svfloat32_t a, svfloat32_t b) __arm_streaming {
+  return svuzp1_f32(a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_uzp2(svfloat32_t a, svfloat32_t b) __arm_streaming {
+  return svuzp2_f32(a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_zip1(svfloat32_t a, svfloat32_t b) __arm_streaming {
+  return svzip1_f32(a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat32_t sme_zip2(svfloat32_t a, svfloat32_t b) __arm_streaming {
+  return svzip2_f32(a, b);
+}
+
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_ld1(svbool_t pg, const double* p) __arm_streaming {
+  return svld1_f64(pg, p);
+}
+static EIGEN_ALWAYS_INLINE void sme_st1(svbool_t pg, double* p, svfloat64_t v) __arm_streaming { svst1_f64(pg, p, v); }
+static EIGEN_ALWAYS_INLINE svfloat64x2_t sme_ld1_x2(svcount_t pn, const double* p) __arm_streaming {
+  return svld1_f64_x2(pn, p);
+}
+static EIGEN_ALWAYS_INLINE svfloat64x4_t sme_ld1_x4(svcount_t pn, const double* p) __arm_streaming {
+  return svld1_f64_x4(pn, p);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_mla(svbool_t pg, svfloat64_t acc, svfloat64_t a,
+                                               svfloat64_t b) __arm_streaming {
+  return svmla_f64_x(pg, acc, a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_mul(svbool_t pg, svfloat64_t a, svfloat64_t b) __arm_streaming {
+  return svmul_f64_x(pg, a, b);
+}
+template <int Lane>
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_get(svfloat64x2_t v) __arm_streaming {
+  return svget2_f64(v, Lane);
+}
+template <int Lane>
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_get(svfloat64x4_t v) __arm_streaming {
+  return svget4_f64(v, Lane);
+}
+
+template <int Tile>
+static EIGEN_ALWAYS_INLINE void sme_ld1_hor_za(uint32_t slice, svbool_t pg,
+                                               const double* p) __arm_streaming __arm_inout("za") {
+  svld1_hor_za64(Tile, slice, pg, p);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_read_hor_za(svfloat64_t zero, svbool_t pg,
+                                                       uint32_t slice) __arm_streaming __arm_inout("za") {
+  return svread_hor_za64_f64_m(zero, pg, Tile, slice);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_read_ver_za(svfloat64_t zero, svbool_t pg,
+                                                       uint32_t slice) __arm_streaming __arm_inout("za") {
+  return svread_ver_za64_f64_m(zero, pg, Tile, slice);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE void sme_mopa(svbool_t pm, svbool_t pn, svfloat64_t a,
+                                         svfloat64_t b) __arm_streaming __arm_inout("za") {
+  svmopa_za64_f64_m(Tile, pm, pn, a, b);
+}
+template <int Tile>
+static EIGEN_ALWAYS_INLINE void sme_mops(svbool_t pm, svbool_t pn, svfloat64_t a,
+                                         svfloat64_t b) __arm_streaming __arm_inout("za") {
+  svmops_za64_f64_m(Tile, pm, pn, a, b);
+}
+
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_mls(svbool_t pg, svfloat64_t acc, svfloat64_t a,
+                                               svfloat64_t b) __arm_streaming {
+  return svmls_f64_x(pg, acc, a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_add(svbool_t pg, svfloat64_t a, svfloat64_t b) __arm_streaming {
+  return svadd_f64_x(pg, a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_neg(svbool_t pg, svfloat64_t v) __arm_streaming {
+  return svneg_f64_x(pg, v);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_uzp1(svfloat64_t a, svfloat64_t b) __arm_streaming {
+  return svuzp1_f64(a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_uzp2(svfloat64_t a, svfloat64_t b) __arm_streaming {
+  return svuzp2_f64(a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_zip1(svfloat64_t a, svfloat64_t b) __arm_streaming {
+  return svzip1_f64(a, b);
+}
+static EIGEN_ALWAYS_INLINE svfloat64_t sme_zip2(svfloat64_t a, svfloat64_t b) __arm_streaming {
+  return svzip2_f64(a, b);
+}
+#endif  // EIGEN_VECTORIZE_SME_F64F64
+
+// Outer-product accumulate with a compile-time sign: the complex kernel's four
+// real products differ only in whether they add or subtract into the tile.
+template <int Tile, bool Subtract, typename Vec>
+static EIGEN_ALWAYS_INLINE void sme_mopa_signed(svbool_t pm, svbool_t pn, Vec a,
+                                                Vec b) __arm_streaming __arm_inout("za") {
+  EIGEN_IF_CONSTEXPR (Subtract) {
+    sme_mops<Tile>(pm, pn, a, b);
+  } else {
+    sme_mopa<Tile>(pm, pn, a, b);
+  }
+}
+
+// The streaming vector width the block sizes are chosen at: 512 bits, where a
+// vector holds 64 / sizeof(element) elements.  Other SVLs tile the block at
+// runtime.  If a future SVL ever justifies a larger block, this is the only
+// knob -- but don't grow it speculatively, a doubled block measures slower at
+// SVL=512.
+static constexpr int kSmeDesignVectorBytes = 64;
+
+// Logical micro-kernel block (LHS/RHS panel widths), as a grid of ZA tiles each
+// svl x svl elements of the ZA element width -- Scalar itself for a real
+// scalar, its real part for a complex one, whose halves accumulate into
+// separate tiles -- a full 2x2 grid for real scalars.
+// A complex accumulator takes a tile pair, so complex<float> gets half the grid
+// cells of float; the grid stays two cells wide, which measures 1.2-1.9x a
+// two-cell-tall one below 128 on Apple M4 and matches it above.
+template <typename Scalar>
+struct sme_block {
+  static constexpr int kGridRows = 2;
+  static constexpr int kGridCols = 2;
+  static constexpr int mr = kGridRows * kSmeDesignVectorBytes / int(sizeof(Scalar));
+  static constexpr int nr = kGridCols * kSmeDesignVectorBytes / int(sizeof(Scalar));
+};
+
+template <typename RealScalar>
+struct sme_block<std::complex<RealScalar>> {
+  static constexpr int kGridCols = 2;
+  static constexpr int kGridRows = sme_tile_count<RealScalar>::value / (2 * kGridCols);
+  static constexpr int mr = kGridRows * kSmeDesignVectorBytes / int(sizeof(RealScalar));
+  static constexpr int nr = kGridCols * kSmeDesignVectorBytes / int(sizeof(RealScalar));
+};
+
+static constexpr int kSmeMr = sme_block<float>::mr;
+static constexpr int kSmeNr = sme_block<float>::nr;
+static constexpr int kSmeMrC = sme_block<std::complex<float>>::mr;
+static constexpr int kSmeNrC = sme_block<std::complex<float>>::nr;
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+static constexpr int kSmeMrD = sme_block<double>::mr;
+static constexpr int kSmeNrD = sme_block<double>::nr;
+static constexpr int kSmeMrCD = sme_block<std::complex<double>>::mr;
+static constexpr int kSmeNrCD = sme_block<std::complex<double>>::nr;
+#endif
+
+// min() usable from streaming functions (numext::mini lacks the
+// __arm_streaming_compatible attribute).
+template <typename T>
+static EIGEN_ALWAYS_INLINE T sme_min(T a, T b) __arm_streaming_compatible {
+  return a < b ? a : b;
+}
+
+// Offset a pointer by n elements without forming the pointer value: an access
+// whose predicate is empty makes no memory reference, but computing an address
+// more than one past the end of the object is undefined regardless, so the
+// second-vector accesses below reach their address through uintptr_t.
+template <typename T>
+static EIGEN_ALWAYS_INLINE T* sme_offset(T* p, Index n) __arm_streaming_compatible {
+  return reinterpret_cast<T*>(uintptr_t(p) + ptrdiff_t(n) * sizeof(T));
+}
+
+// ---------------------------------------------------------------------------
+// Packed panel layout and the primitives that produce it.
+//
+// A packed panel is depth-major.  For a real element type one depth step holds
+// `width` contiguous scalars; for a complex one it holds the `width` real parts
+// followed by the `width` imaginary parts, so the micro-kernel feeds a ZA tile
+// pair from two contiguous vector loads and never deinterleaves inside the
+// depth loop.  Either way a width x depth panel occupies width * depth Scalars,
+// which is what the GEMM driver allocates.
+//
+// `Conjugate` negates the imaginary half.  Conjugation is the identity on real
+// scalars, so the real overloads ignore it -- and Conjugate=true instantiations
+// do reach them, from the SYMM above-diagonal transposed pack.
+// ---------------------------------------------------------------------------
+
+// Copy `width` contiguous source columns per depth step into a depth-major
+// packed panel of width `width`, for the depth sub-range [k0, k1).  Both dst and
+// src are indexed by the absolute depth index k (dst[k*width+off],
+// src[k*src_stride+off]); the caller offsets `src` to the region's column base
+// and `dst` to the panel base.  Generalised over the runtime svl: the panel is
+// covered in svl-wide column chunks, each streamed over the depth sub-range.
+// The chunk loop is outermost so each chunk's predicate is computed once instead
+// of per depth step (the runtime chunk count keeps the compiler from hoisting it
+// on its own).  The symm packers reuse this for the diagonal-split direct/
+// transposed regions (a contiguous depth sub-range at a depth offset).
+template <bool Conjugate, typename Scalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sve_copy_panel_range(Scalar* EIGEN_RESTRICT dst, const Scalar* EIGEN_RESTRICT src,
+                                                     Index src_stride, Index k0, Index k1, int width) __arm_streaming {
+  const int svl = sme_traits<Scalar>::svl();
+  for (int off = 0; off < width; off += svl) {
+    const svbool_t pred = sme_traits<Scalar>::whilelt(off, width);
+    for (Index k = k0; k < k1; ++k) {
+      sme_st1(pred, &dst[k * width + off], sme_ld1(pred, &src[k * src_stride + off]));
+    }
+  }
+}
+
+// Complex overload: UZP1/UZP2 split the source's interleaved pairs into the two
+// halves of the packed depth step.  A chunk of w complex elements spans 2*w
+// interleaved reals, hence a pair of source predicates; the upper one is empty
+// whenever 2*w fits in one vector.
+template <bool Conjugate, typename RealScalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sve_copy_panel_range(std::complex<RealScalar>* EIGEN_RESTRICT dst,
+                                                     const std::complex<RealScalar>* EIGEN_RESTRICT src,
+                                                     Index src_stride, Index k0, Index k1, int width) __arm_streaming {
+  using Traits = sme_traits<RealScalar>;
+  using Vec = typename Traits::Vec;
+  RealScalar* EIGEN_RESTRICT rdst = reinterpret_cast<RealScalar*>(dst);
+  const RealScalar* EIGEN_RESTRICT rsrc = reinterpret_cast<const RealScalar*>(src);
+  const int svl = Traits::svl();
+  const Index step = Index(2 * width);
+  for (int off = 0; off < width; off += svl) {
+    const int w = width - off;
+    const int lanes = 2 * w;
+    const svbool_t pg_w = Traits::whilelt(off, width);
+    const svbool_t pg_lo = Traits::whilelt(0, lanes);
+    const svbool_t pg_hi = Traits::whilelt(svl, lanes);
+    for (Index k = k0; k < k1; ++k) {
+      const RealScalar* p = rsrc + Index(2) * (k * src_stride + Index(off));
+      const Vec v_lo = sme_ld1(pg_lo, p);
+      // pg_hi is all-false when 2*w fits in one vector, and an inactive lane
+      // makes no memory access -- but p + svl may still be past the source, so
+      // the address is formed through sme_offset.
+      const Vec v_hi = sme_ld1(pg_hi, sme_offset(p, svl));
+      Vec im = sme_uzp2(v_lo, v_hi);
+      EIGEN_IF_CONSTEXPR (Conjugate) {
+        im = sme_neg(pg_w, im);
+      }
+      sme_st1(pg_w, &rdst[k * step + Index(off)], sme_uzp1(v_lo, v_hi));
+      sme_st1(pg_w, &rdst[k * step + Index(width + off)], im);
+    }
+  }
+}
+
+// Copy the full depth [0, depth): thin wrapper used by the (non-symm) gemm
+// packers, which always pack a whole panel.
+template <bool Conjugate, typename Scalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sve_copy_panel(Scalar* EIGEN_RESTRICT dst, const Scalar* EIGEN_RESTRICT src,
+                                               Index src_stride, Index depth, int width) __arm_streaming {
+  sve_copy_panel_range<Conjugate>(dst, src, src_stride, Index(0), depth, width);
+}
+
+// Transpose-pack `width` source rows into depth-major packed output using ZA's
+// 2D store as a free transpose, for the depth sub-range [k0, k1): a svl x svl
+// block of source (svl rows x svl depth) is loaded as horizontal ZA slices,
+// then read back as vertical slices, which emits it depth-major.  Row-groups of
+// svl rows are processed two at a time through ZA tiles 0 and 1: ZA is not
+// renamed, so a single tile would stall every load pass on the previous read
+// pass (write-after-read); two tiles in flight keep the phases independent.
+// Trailing row-groups (when width is not a multiple of 2*svl) use tile 0 with
+// predicated rows -- which is also what a panel narrower than 2*svl gets in
+// full: complex<float> has mr = svl at SVL=512, so its LHS panels take the
+// single-tile path and do not get the write-after-read overlap described above.
+// Widening the gate would need the pairing to run over depth instead of rows.
+// Both dst and src are indexed by the absolute depth index k:
+//   dst[k*width + r] = src[r*src_stride + k],  k in [k0,k1), r in [0,width).
+// The symm packers reuse this for the diagonal-split transposed/direct regions
+// (a depth sub-range at a depth offset, with a tail-panel width < mr).
+//
+// NegateOddRows negates every odd output depth row.  That is how the complex
+// overload below conjugates: in the real view of a complex panel those rows are
+// exactly the imaginary halves.
+template <bool NegateOddRows, typename RealScalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sme_transpose_pack_real(RealScalar* EIGEN_RESTRICT dst,
+                                                        const RealScalar* EIGEN_RESTRICT src, Index src_stride,
+                                                        Index k0, Index k1,
+                                                        int width) __arm_streaming __arm_inout("za") {
+  using Traits = sme_traits<RealScalar>;
+  using Vec = typename Traits::Vec;
+  const Vec zero = Traits::dup(RealScalar(0));
+  const svbool_t pg_all = Traits::ptrue();
+  const int svl = Traits::svl();
+
+  for (Index k = k0; k < k1; k += svl) {
+    const int dk = static_cast<int>(sme_min(k1 - k, Index(svl)));
+    const svbool_t pg_d = Traits::whilelt(k, k1);
+    int r0 = 0;
+    // Pairs of full row-groups: tiles 0 and 1 in flight.
+    for (; r0 + 2 * svl <= width; r0 += 2 * svl) {
+      for (int r = 0; r < svl; ++r) {
+        sme_ld1_hor_za<0>(uint32_t(r), pg_d, &src[(r0 + r) * src_stride + k]);
+        sme_ld1_hor_za<1>(uint32_t(r), pg_d, &src[(r0 + svl + r) * src_stride + k]);
+      }
+      for (int c = 0; c < dk; ++c) {
+        Vec v0 = sme_read_ver_za<0>(zero, pg_all, uint32_t(c));
+        Vec v1 = sme_read_ver_za<1>(zero, pg_all, uint32_t(c));
+        EIGEN_IF_CONSTEXPR (NegateOddRows) {
+          if (((k + Index(c)) & Index(1)) != Index(0)) {
+            v0 = sme_neg(pg_all, v0);
+            v1 = sme_neg(pg_all, v1);
+          }
+        }
+        sme_st1(pg_all, &dst[(k + c) * width + r0], v0);
+        sme_st1(pg_all, &dst[(k + c) * width + r0 + svl], v1);
+      }
+    }
+    // Trailing row-groups (at most two svl-wide passes remain, since the pair
+    // loop consumed all multiples of 2*svl): predicate down to the remaining
+    // rows.  A single `if` would drop rows when a tail width lands in
+    // (svl, 2*svl); a loop handles any leftover.
+    for (; r0 < width; r0 += svl) {
+      const int rg = sme_min(width - r0, svl);
+      const svbool_t pg_r = Traits::whilelt(r0, width);
+      for (int r = 0; r < rg; ++r) {
+        sme_ld1_hor_za<0>(uint32_t(r), pg_d, &src[(r0 + r) * src_stride + k]);
+      }
+      for (int c = 0; c < dk; ++c) {
+        Vec v0 = sme_read_ver_za<0>(zero, pg_r, uint32_t(c));
+        EIGEN_IF_CONSTEXPR (NegateOddRows) {
+          if (((k + Index(c)) & Index(1)) != Index(0)) v0 = sme_neg(pg_r, v0);
+        }
+        sme_st1(pg_r, &dst[(k + c) * width + r0], v0);
+      }
+    }
+  }
+}
+
+template <bool Conjugate, typename Scalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sme_transpose_pack_range(Scalar* EIGEN_RESTRICT dst, const Scalar* EIGEN_RESTRICT src,
+                                                         Index src_stride, Index k0, Index k1,
+                                                         int width) __arm_streaming __arm_inout("za") {
+  sme_transpose_pack_real<false>(dst, src, src_stride, k0, k1, width);
+}
+
+// Complex overload.  A ColMajor (RowMajor) complex operand is a ColMajor
+// (RowMajor) real one of twice the depth and twice the stride, and transposing
+// that real view already emits the split layout: real-view depth 2k lands at
+// packed offset k*(2*width) and depth 2k+1 at k*(2*width) + width, the real and
+// imaginary halves of packed depth step k.
+template <bool Conjugate, typename RealScalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sme_transpose_pack_range(std::complex<RealScalar>* EIGEN_RESTRICT dst,
+                                                         const std::complex<RealScalar>* EIGEN_RESTRICT src,
+                                                         Index src_stride, Index k0, Index k1,
+                                                         int width) __arm_streaming __arm_inout("za") {
+  sme_transpose_pack_real<Conjugate>(reinterpret_cast<RealScalar*>(dst), reinterpret_cast<const RealScalar*>(src),
+                                     Index(2) * src_stride, Index(2) * k0, Index(2) * k1, width);
+}
+
+// Transpose-pack a whole `width`-wide panel over the full depth [0, depth):
+// thin wrapper used by the (non-symm) gemm packers.
+template <bool Conjugate, typename Scalar, typename Index>
+static EIGEN_ALWAYS_INLINE void sme_transpose_pack(Scalar* EIGEN_RESTRICT dst, const Scalar* EIGEN_RESTRICT src,
+                                                   Index src_stride, Index depth,
+                                                   int width) __arm_streaming __arm_inout("za") {
+  sme_transpose_pack_range<Conjugate>(dst, src, src_stride, Index(0), depth, width);
+}
+
+// Transposing copy for a panel narrower than the pack width:
+//   dst_panel[k*tail + i] = src[i*src_stride + k].
+// Kept outside the caller's __arm_locally_streaming region: it needs neither SVE
+// nor ZA, and streaming mode runs scalar floating-point ~40x slower on Apple M4.
+// Outside it the source rows are contiguous in k, so PacketSize of them
+// transpose in register as in sme_pack_rhs_fallback; a product with cols < nr is
+// packed entirely here.  NegateOddRows is as in sme_transpose_pack_real.
+template <bool NegateOddRows, typename RealScalar, typename Index>
+static void tail_transpose_pack_real(RealScalar* EIGEN_RESTRICT dst_panel, const RealScalar* EIGEN_RESTRICT src,
+                                     Index src_stride, Index depth, Index tail) {
+  using Packet = typename packet_traits<RealScalar>::type;
+  constexpr int PacketSize = int(packet_traits<RealScalar>::size);
+  const Index peeled_tail = (tail / Index(PacketSize)) * Index(PacketSize);
+  const Index peeled_depth = numext::round_down(depth, Index(PacketSize));
+
+  Index i = 0;
+  for (; i < peeled_tail; i += Index(PacketSize)) {
+    Index k = 0;
+    for (; k < peeled_depth; k += Index(PacketSize)) {
+      PacketBlock<Packet, PacketSize> block;
+      for (int p = 0; p < PacketSize; ++p) {
+        block.packet[p] = ploadu<Packet>(src + (i + Index(p)) * src_stride + k);
+      }
+      ptranspose(block);
+      for (int p = 0; p < PacketSize; ++p) {
+        Packet row = block.packet[p];
+        EIGEN_IF_CONSTEXPR (NegateOddRows) {
+          if (((k + Index(p)) & Index(1)) != Index(0)) row = pnegate(row);
+        }
+        pstoreu(dst_panel + (k + Index(p)) * tail + i, row);
+      }
+    }
+    for (; k < depth; ++k) {
+      const bool negate = NegateOddRows && ((k & Index(1)) != Index(0));
+      for (Index p = 0; p < Index(PacketSize); ++p) {
+        const RealScalar v = src[(i + p) * src_stride + k];
+        dst_panel[k * tail + i + p] = negate ? -v : v;
+      }
+    }
+  }
+  for (; i < tail; ++i) {
+    for (Index k = 0; k < depth; ++k) {
+      const bool negate = NegateOddRows && ((k & Index(1)) != Index(0));
+      const RealScalar v = src[i * src_stride + k];
+      dst_panel[k * tail + i] = negate ? -v : v;
+    }
+  }
+}
+
+template <bool Conjugate, typename Scalar, typename Index>
+static void tail_transpose_pack(Scalar* EIGEN_RESTRICT dst_panel, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                Index depth, Index tail) {
+  tail_transpose_pack_real<false>(dst_panel, src, src_stride, depth, tail);
+}
+
+template <bool Conjugate, typename RealScalar, typename Index>
+static void tail_transpose_pack(std::complex<RealScalar>* EIGEN_RESTRICT dst_panel,
+                                const std::complex<RealScalar>* EIGEN_RESTRICT src, Index src_stride, Index depth,
+                                Index tail) {
+  tail_transpose_pack_real<Conjugate>(reinterpret_cast<RealScalar*>(dst_panel),
+                                      reinterpret_cast<const RealScalar*>(src), Index(2) * src_stride, Index(2) * depth,
+                                      tail);
+}
+
+// De-interleaving load and interleaving store of PS complex values.
+static EIGEN_ALWAYS_INLINE void sme_neon_ld2(const float* p, Packet4f& re, Packet4f& im) {
+  const float32x4x2_t v = vld2q_f32(p);
+  re = v.val[0];
+  im = v.val[1];
+}
+static EIGEN_ALWAYS_INLINE void sme_neon_st2(float* p, Packet4f re, Packet4f im) {
+  float32x4x2_t v;
+  v.val[0] = re;
+  v.val[1] = im;
+  vst2q_f32(p, v);
+}
+static EIGEN_ALWAYS_INLINE void sme_neon_ld2(const double* p, Packet2d& re, Packet2d& im) {
+  const float64x2x2_t v = vld2q_f64(p);
+  re = v.val[0];
+  im = v.val[1];
+}
+static EIGEN_ALWAYS_INLINE void sme_neon_st2(double* p, Packet2d re, Packet2d im) {
+  float64x2x2_t v;
+  v.val[0] = re;
+  v.val[1] = im;
+  vst2q_f64(p, v);
+}
+
+// NEON copy packers for the direct-access, unit-stride case: dst[k*w + r] =
+// src[r + k*src_stride], w contiguous scalars per depth step; complex panels
+// split into the depth step's real then imaginary halves, conjugated if asked.
+template <bool Conjugate, typename Scalar, typename Index>
+static void neon_copy_panel(Scalar* EIGEN_RESTRICT dst, const Scalar* EIGEN_RESTRICT src, Index src_stride, Index depth,
+                            Index w) {
+  using Packet = typename packet_traits<Scalar>::type;
+  constexpr Index PS = Index(packet_traits<Scalar>::size);
+  const Index peeled4 = numext::round_down(w, 4 * PS);
+  const Index peeled = numext::round_down(w, PS);
+  for (Index k = 0; k < depth; ++k) {
+    const Scalar* s = src + k * src_stride;
+    Scalar* d = dst + k * w;
+    Index r = 0;
+    for (; r < peeled4; r += 4 * PS) {
+      const Packet p0 = ploadu<Packet>(s + r), p1 = ploadu<Packet>(s + r + PS);
+      const Packet p2 = ploadu<Packet>(s + r + 2 * PS), p3 = ploadu<Packet>(s + r + 3 * PS);
+      pstoreu(d + r, p0);
+      pstoreu(d + r + PS, p1);
+      pstoreu(d + r + 2 * PS, p2);
+      pstoreu(d + r + 3 * PS, p3);
+    }
+    for (; r < peeled; r += PS) pstoreu(d + r, ploadu<Packet>(s + r));
+    for (; r < w; ++r) d[r] = s[r];
+  }
+}
+template <bool Conjugate, typename RealScalar, typename Index>
+static void neon_copy_panel(std::complex<RealScalar>* EIGEN_RESTRICT dst,
+                            const std::complex<RealScalar>* EIGEN_RESTRICT src, Index src_stride, Index depth,
+                            Index w) {
+  using Packet = typename packet_traits<RealScalar>::type;
+  constexpr Index PS = Index(packet_traits<RealScalar>::size);
+  RealScalar* rd = reinterpret_cast<RealScalar*>(dst);
+  const RealScalar* rs = reinterpret_cast<const RealScalar*>(src);
+  const Index peeled = numext::round_down(w, PS);
+  for (Index k = 0; k < depth; ++k) {
+    const RealScalar* s = rs + k * 2 * src_stride;
+    RealScalar* d = rd + k * 2 * w;
+    Index r = 0;
+    for (; r < peeled; r += PS) {
+      Packet re, im;
+      sme_neon_ld2(s + 2 * r, re, im);
+      pstoreu(d + r, re);
+      pstoreu(d + w + r, Conjugate ? pnegate(im) : im);
+    }
+    for (; r < w; ++r) {
+      d[r] = s[2 * r];
+      d[w + r] = Conjugate ? -s[2 * r + 1] : s[2 * r + 1];
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Generic (mapper-based) packing fallback.
+//
+// The streaming pack_lhs_*/pack_rhs_* helpers take &lhs(0,0) once and walk it by
+// raw pointer + lhs.stride(). That breaks for two DataMapper families:
+//   - TensorContractionSubMapper::operator() returns by value, so &lhs(0,0) is
+//     address-of-rvalue (a compile error, not just wrong results);
+//   - blas_data_mapper with Incr != 1 (inner-strided Maps, e.g. from
+//     TriangularSolverMatrix) can't be walked by stride() alone.
+// These fall back to the mapper's packet/element interface, emitting the
+// identical depth-major panel layout so gebp_kernel can't tell the paths apart.
+// ---------------------------------------------------------------------------
+
+// True iff DataMapper exposes .incr() (the blas_data_mapper family); others are
+// unit-inner-stride by construction.
+template <typename DataMapper, typename EnableIf = void>
+struct sme_has_incr : std::false_type {};
+template <typename DataMapper>
+struct sme_has_incr<DataMapper, void_t<decltype(std::declval<const DataMapper&>().incr())>> : std::true_type {};
+
+template <typename Index, typename DataMapper, std::enable_if_t<sme_has_incr<DataMapper>::value, bool> = true>
+EIGEN_ALWAYS_INLINE Index sme_mapper_incr(const DataMapper& m) {
+  return static_cast<Index>(m.incr());
+}
+template <typename Index, typename DataMapper, std::enable_if_t<!sme_has_incr<DataMapper>::value, bool> = true>
+EIGEN_ALWAYS_INLINE Index sme_mapper_incr(const DataMapper&) {
+  return Index(1);
+}
+
+// Whether operator()(i,j) returns an lvalue reference into caller storage (so
+// &m(0,0) + stride walking is valid). False for by-value mappers (Tensor's).
+template <typename DataMapper, typename Index>
+struct sme_mapper_has_direct_access {
+  static constexpr bool value = std::is_lvalue_reference<decltype(std::declval<const DataMapper&>()(
+      std::declval<Index>(), std::declval<Index>()))>::value;
+};
+
+// Store one element of a packed depth step of width w.  Real scalars land at
+// dst_step[r]; complex ones split into the step's real and imaginary halves,
+// which is the same base pointer reinterpreted, since a complex depth step of
+// width w spans 2*w reals.
+template <bool Conjugate, typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_pack_store(Scalar* dst_step, Index w, Index r, const Scalar& v) {
+  EIGEN_UNUSED_VARIABLE(w);
+  dst_step[r] = conj_if<Conjugate>()(v);
+}
+template <bool Conjugate, typename RealScalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_pack_store(std::complex<RealScalar>* dst_step, Index w, Index r,
+                                        const std::complex<RealScalar>& v) {
+  const std::complex<RealScalar> cv = conj_if<Conjugate>()(v);
+  RealScalar* p = reinterpret_cast<RealScalar*>(dst_step);
+  p[r] = numext::real(cv);
+  p[w + r] = numext::imag(cv);
+}
+
+// LHS fallback: pack via the mapper's packet interface, shared by both
+// gemm_pack_lhs specializations. Taken by mappers without direct lvalue access
+// (TensorContractionSubMapper returns by value) or with a non-unit inner
+// stride. Vectorised with NEON packets, exactly like the generic packers drive
+// these same mappers. Tensor sub-mappers (the hot path -- tensor contractions
+// pack through this on both sides) have contiguous packet loads, but their
+// ordinary operator()/loadPacket functions cannot be called from a streaming
+// context. Inner-strided ColMajor blas mappers instead require gathers;
+// streaming-mode gathers need FEAT_SME_FA64 (absent on e.g. Apple M4), while
+// NEON's pgather uses scalar source loads and a contiguous packet store. The
+// packet path assumes the mapper's packets advance the first index; that holds
+// for ColMajor tensor and blas mappers, but not for RowMajor mappers, whose
+// packets run along the storage-inner second index. RowMajor dispatches pass
+// vectorise = false and take the scalar element loop. Complex scalars always
+// take it too: a complex packet store would emit the interleaved layout, not the
+// split one the kernel reads.
+template <typename Scalar, int MR, typename Index, typename DataMapper, bool Conjugate, bool PanelMode>
+void sme_pack_lhs_fallback(Scalar* dst_base, const DataMapper& lhs, Index depth, Index rows, Index dst_stride,
+                           Index dst_offset, bool vectorise) {
+  using Packet = typename packet_traits<Scalar>::type;
+  constexpr Index PacketSize = Index(packet_traits<Scalar>::size);
+  constexpr bool HasPacketPath = !NumTraits<Scalar>::IsComplex;
+
+  for (Index i = 0; i < rows; i += MR) {
+    const Index w = numext::mini(rows - i, Index(MR));
+    Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * w : dst_base + i * depth;
+    const Index peeled_w = (vectorise && HasPacketPath) ? numext::round_down(w, Index(PacketSize)) : Index(0);
+    for (Index k = 0; k < depth; ++k) {
+      Scalar* dst_step = dst_panel + k * w;
+      Index r = 0;
+      for (; r < peeled_w; r += PacketSize) {
+        pstoreu(dst_step + r, lhs.template loadPacket<Packet>(i + r, k));
+      }
+      for (; r < w; ++r) {
+        sme_pack_store<Conjugate>(dst_step, w, r, lhs(i + r, k));
+      }
+    }
+  }
+}
+
+// The PacketSize column sub-mappers one packed column group loads from.
+template <typename DataMapper, typename Index, std::size_t... Is>
+EIGEN_ALWAYS_INLINE std::array<typename DataMapper::LinearMapper, sizeof...(Is)> sme_column_mappers(
+    const DataMapper& rhs, Index col, std::index_sequence<Is...>) {
+  return {{rhs.getLinearMapper(0, col + Index(Is))...}};
+}
+
+// RHS fallback, mirroring sme_pack_lhs_fallback (including the vectorise
+// contract: LinearMapper packets must advance the first (depth) index). The
+// packed layout wants consecutive columns contiguous while the mapper's
+// packets run along the depth k, so PacketSize columns are loaded as packets
+// along k and transposed in-register (the same LinearMapper + ptranspose
+// scheme as the generic gemm_pack_rhs).
+template <typename Scalar, int NR, typename Index, typename DataMapper, bool Conjugate, bool PanelMode>
+void sme_pack_rhs_fallback(Scalar* dst_base, const DataMapper& rhs, Index depth, Index cols, Index dst_stride,
+                           Index dst_offset, bool vectorise) {
+  using Packet = typename packet_traits<Scalar>::type;
+  using LinearMapper = typename DataMapper::LinearMapper;
+  constexpr int PacketSize = int(packet_traits<Scalar>::size);
+  constexpr bool HasPacketPath = !NumTraits<Scalar>::IsComplex;
+  const Index peeled_depth = (depth / Index(PacketSize)) * Index(PacketSize);
+
+  for (Index j = 0; j < cols; j += NR) {
+    const Index w = numext::mini(cols - j, Index(NR));
+    Scalar* dst_panel = PanelMode ? dst_base + j * dst_stride + dst_offset * w : dst_base + j * depth;
+    const Index peeled_w = (vectorise && HasPacketPath) ? numext::round_down(w, Index(PacketSize)) : Index(0);
+    Index c = 0;
+    for (; c < peeled_w; c += Index(PacketSize)) {
+      // Loop-invariant in k, but not hoisted out of the k loop by the compiler
+      // for a mapper that returns its sub-mappers by value -- which is the hot
+      // path here: tensor contractions pack through TensorContractionSubMapper.
+      const std::array<LinearMapper, PacketSize> dm =
+          sme_column_mappers(rhs, j + c, std::make_index_sequence<PacketSize>{});
+      Index k = 0;
+      for (; k < peeled_depth; k += Index(PacketSize)) {
+        PacketBlock<Packet, PacketSize> block;
+        for (int p = 0; p < PacketSize; ++p) {
+          block.packet[p] = dm[p].template loadPacket<Packet>(k);
+        }
+        ptranspose(block);
+        for (int p = 0; p < PacketSize; ++p) {
+          pstoreu(dst_panel + (k + Index(p)) * w + c, block.packet[p]);
+        }
+      }
+      for (; k < depth; ++k) {
+        for (Index p = 0; p < Index(PacketSize); ++p) {
+          sme_pack_store<Conjugate>(dst_panel + k * w, w, c + p, rhs(k, j + c + p));
+        }
+      }
+    }
+    for (; c < w; ++c) {
+      for (Index k = 0; k < depth; ++k) {
+        sme_pack_store<Conjugate>(dst_panel + k * w, w, c, rhs(k, j + c));
+      }
+    }
+  }
+}
+
+// NEON dispatch invariant, constants fitted on Apple M4 (SVL 512). Packers: panel depth (the stride in
+// panel mode) <= sme_neon_max_depth && width <= sme_neon_max_panel. Kernel: both sides pass the packer
+// test with strideA / strideB as the panel depths && (max(rows, cols) <= w(depth) || min <= thin_dim).
+// So a NEON kernel reads NEON-packed panels, and ZA over NEON-packed panels (~40 ns/KB) is bounded by
+// sme_neon_max_panel; the exception is SYRK, which packs B at the full size but runs 32x32 diagonal blocks.
+#ifndef EIGEN_SME_NEON_MAX_DEPTH
+template <typename Scalar>
+struct sme_neon_max_depth : std::integral_constant<int, 16> {};
+template <>
+struct sme_neon_max_depth<float> : std::integral_constant<int, 24> {};
+template <>
+struct sme_neon_max_depth<std::complex<double>> : std::integral_constant<int, 8> {};
+#else
+template <typename Scalar>
+struct sme_neon_max_depth : std::integral_constant<int, EIGEN_SME_NEON_MAX_DEPTH> {};
+#endif
+#ifndef EIGEN_SME_NEON_MAX_WIDTH
+template <typename Scalar>
+struct sme_neon_max_width : std::integral_constant<int, 48> {};
+template <>
+struct sme_neon_max_width<double> : std::integral_constant<int, 40> {};
+template <>
+struct sme_neon_max_width<std::complex<float>> : std::integral_constant<int, 16> {};
+template <>
+struct sme_neon_max_width<std::complex<double>> : std::integral_constant<int, 24> {};
+#else
+template <typename Scalar>
+struct sme_neon_max_width : std::integral_constant<int, EIGEN_SME_NEON_MAX_WIDTH> {};
+#endif
+// Up to sme_neon_shallow_depth the NEON range widens to sme_neon_shallow_width:
+// the blocked decompositions update sub-blocks of that depth in place, at
+// offsets the ZA slice stores handle poorly.
+#ifndef EIGEN_SME_NEON_SHALLOW_DEPTH
+template <typename Scalar>
+struct sme_neon_shallow_depth : std::integral_constant<int, 8> {};
+#else
+template <typename Scalar>
+struct sme_neon_shallow_depth : std::integral_constant<int, EIGEN_SME_NEON_SHALLOW_DEPTH> {};
+#endif
+#ifndef EIGEN_SME_NEON_SHALLOW_WIDTH
+template <typename Scalar>
+struct sme_neon_shallow_width : std::integral_constant<int, 96> {};
+template <>
+struct sme_neon_shallow_width<double> : std::integral_constant<int, 64> {};
+template <>
+struct sme_neon_shallow_width<std::complex<float>> : std::integral_constant<int, 32> {};
+template <>
+struct sme_neon_shallow_width<std::complex<double>> : std::integral_constant<int, 24> {};
+#else
+template <typename Scalar>
+struct sme_neon_shallow_width : std::integral_constant<int, EIGEN_SME_NEON_SHALLOW_WIDTH> {};
+#endif
+// No panel wider than this is packed with NEON at any depth: the triangular solvers slice a tall
+// panel into depth-8 pieces for ZA. The packers cannot mirror the kernel's width rule, or a thin
+// block's wide side would be streaming-packed and read by NEON, the costly direction; the price is
+// a shallow panel in (w, this] read by ZA, 1.4x the streaming-packed time at 128x128x16 float.
+#ifndef EIGEN_SME_NEON_MAX_PANEL
+template <typename Scalar>
+struct sme_neon_max_panel : std::integral_constant<int, 256> {};
+template <typename RealScalar>
+struct sme_neon_max_panel<std::complex<RealScalar>> : std::integral_constant<int, 128> {};
+#else
+template <typename Scalar>
+struct sme_neon_max_panel : std::integral_constant<int, EIGEN_SME_NEON_MAX_PANEL> {};
+#endif
+// A block this narrow on one side runs on NEON whatever its other side: the
+// blocked decompositions update long strips of that width in place.
+#ifndef EIGEN_SME_NEON_THIN_DIM
+template <typename Scalar>
+struct sme_neon_thin_dim : std::integral_constant<int, 32> {};
+template <>
+struct sme_neon_thin_dim<std::complex<float>> : std::integral_constant<int, 8> {};
+template <>
+struct sme_neon_thin_dim<std::complex<double>> : std::integral_constant<int, 4> {};
+#else
+template <typename Scalar>
+struct sme_neon_thin_dim : std::integral_constant<int, EIGEN_SME_NEON_THIN_DIM> {};
+#endif
+
+// `width` is the panel's rows (LHS) or cols (RHS).
+template <typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE bool sme_pack_with_neon(Index depth, Index width) {
+#if defined(EIGEN_SME_NO_NEON_SMALL_BLOCKS)
+  EIGEN_UNUSED_VARIABLE(depth);
+  EIGEN_UNUSED_VARIABLE(width);
+  return false;
+#elif defined(EIGEN_SME_FORCE_NEON_SMALL_BLOCKS)
+  EIGEN_UNUSED_VARIABLE(depth);
+  EIGEN_UNUSED_VARIABLE(width);
+  return true;
+#else
+  return depth <= Index(sme_neon_max_depth<Scalar>::value) && width <= Index(sme_neon_max_panel<Scalar>::value);
+#endif
+}
+
+// strideA / strideB are the packed panels' depths, which exceed `depth` when
+// the caller packed them in panel mode and runs the kernel on a slice.
+template <typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE bool sme_kernel_with_neon(Index rows, Index cols, Index depth, Index strideA, Index strideB) {
+#if defined(EIGEN_SME_NO_NEON_SMALL_BLOCKS) || defined(EIGEN_SME_FORCE_NEON_SMALL_BLOCKS)
+  EIGEN_UNUSED_VARIABLE(depth);
+  return sme_pack_with_neon<Scalar>(strideA, rows) && sme_pack_with_neon<Scalar>(strideB, cols);
+#else
+  const Index wide = numext::maxi(rows, cols);
+  const Index w = depth <= Index(sme_neon_shallow_depth<Scalar>::value) ? Index(sme_neon_shallow_width<Scalar>::value)
+                                                                        : Index(sme_neon_max_width<Scalar>::value);
+  return sme_pack_with_neon<Scalar>(strideA, rows) && sme_pack_with_neon<Scalar>(strideB, cols) &&
+         (wide <= w || numext::mini(rows, cols) <= Index(sme_neon_thin_dim<Scalar>::value));
+#endif
+}
+
+// Shared dispatch for the four gemm_pack specializations: raw-pointer walk
+// when the mapper grants direct unit-inner-stride access, otherwise the
+// packet/element fallback. Tag-dispatched so &m(0,0) is only compiled for
+// lvalue mappers. UsePacketPath records whether the mapper's packets advance
+// the index the fallback needs, independently of its direct-access category.
+// In panel mode the call packs one depth slice of a panel `stride` deep that the
+// kernel consumes whole (the triangular solvers and TRMM), so the mode decision
+// uses the panel's depth, not the slice's.
+template <bool UsePacketPath, bool PanelMode, typename Scalar, typename Index, typename DataMapper, typename DirectFn,
+          typename NeonFn, typename FallbackFn>
+EIGEN_ALWAYS_INLINE void sme_dispatch_pack(DirectFn direct, NeonFn neon, FallbackFn fallback, Scalar* block,
+                                           const DataMapper& m, Index depth, Index n, Index stride, Index offset,
+                                           std::true_type /* direct access */) {
+  if (sme_mapper_incr<Index>(m) == 1) {
+    const Scalar* src = (n > 0 && depth > 0) ? &m(0, 0) : nullptr;
+    if (sme_pack_with_neon<Scalar>(PanelMode ? stride : depth, n)) {
+      neon(block, src, m.stride(), depth, n, stride, offset);
+    } else {
+      direct(block, src, m.stride(), depth, n, stride, offset);
+    }
+  } else {
+    fallback(block, m, depth, n, stride, offset, UsePacketPath);
+  }
+}
+template <bool UsePacketPath, bool PanelMode, typename Scalar, typename Index, typename DataMapper, typename DirectFn,
+          typename NeonFn, typename FallbackFn>
+EIGEN_ALWAYS_INLINE void sme_dispatch_pack(DirectFn, NeonFn, FallbackFn fallback, Scalar* block, const DataMapper& m,
+                                           Index depth, Index n, Index stride, Index offset,
+                                           std::false_type /* no direct access */) {
+  fallback(block, m, depth, n, stride, offset, UsePacketPath);
+}
+
+/*****************************************************************************
+ * gebp_traits specializations for SME  (float x float, double x double)
+ *
+ * Override mr and nr so that:
+ *   - gemm_pack_lhs receives Pack1 = mr, creating uniform LHS panels
+ *   - gemm_pack_rhs receives nr, creating uniform RHS panels
+ *   - mc is rounded to a multiple of mr, nc to a multiple of nr
+ *   - Cache blocking (kc, mc, nc) is recomputed accordingly
+ *
+ * We provide custom gemm_pack_lhs/gemm_pack_rhs specializations for both
+ * scalars, so both ColMajor and RowMajor source matrices produce an identical,
+ * simple packed format that the SME kernel consumes.
+ *
+ * Mixed-scalar products (e.g. MatrixXf * MatrixXcf) also instantiate
+ * gemm_pack_lhs<float, ...>, but with Pack1/nr from the generic
+ * gebp_traits<float, complex<float>> (mr=6, nr=4) and are consumed by the
+ * generic gebp_kernel, not the SME one. So the specializations below pin
+ * Pack1/nr_ to the SME block sizes: only the instantiation that feeds the SME
+ * gebp_kernel matches; mixed-scalar ones fall through to the generic template.
+ * This is load-bearing: it relies on no other consumer of the same scalar
+ * instantiating the packer with mr == the SME block size (holds today --
+ * generic float traits give mr <= 12). The kernel side is self-checking (the
+ * SME gebp_kernel static_asserts mr/nr against the block sizes, so a traits
+ * change breaks the build instead of silently mispairing packer and kernel);
+ * the packer side is enforced by the static_asserts below for the in-tree
+ * mixed-scalar traits (downstream code instantiating the packers with
+ * hand-picked mr/nr remains uncovered).
+ *****************************************************************************/
+
+template <>
+class gebp_traits<float, float, false, false, Architecture::Target, GEBPPacketFull>
+    : public gebp_traits<float, float, false, false, Architecture::Target, GEBPPacketHalf> {
+ public:
+  // The base class provides all the standard typedefs (LhsPacket, etc.)
+  // We only override the register-block sizes.
+  enum {
+    mr = kSmeMr,  // LHS panel width
+    nr = kSmeNr   // RHS panel width
+  };
+};
+
+// The packers do not know the opposite scalar type, so the SME block sizes are
+// effectively SME-format tags. Ensure the in-tree mixed-scalar traits cannot
+// select an SME packer whose output would be consumed by the generic kernel.
+static_assert(int(gebp_traits<float, std::complex<float>>::mr) != kSmeMr,
+              "gebp_traits<float, complex<float>>::mr collides with kSmeMr: the SME gemm_pack_lhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+static_assert(int(gebp_traits<std::complex<float>, float>::nr) != kSmeNr,
+              "gebp_traits<complex<float>, float>::nr collides with kSmeNr: the SME gemm_pack_rhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+template <>
+class gebp_traits<double, double, false, false, Architecture::Target, GEBPPacketFull>
+    : public gebp_traits<double, double, false, false, Architecture::Target, GEBPPacketHalf> {
+ public:
+  // As above, only the register-block sizes are overridden.
+  static constexpr int mr = kSmeMrD;
+  static constexpr int nr = kSmeNrD;
+};
+
+static_assert(int(gebp_traits<double, std::complex<double>>::mr) != kSmeMrD,
+              "gebp_traits<double, complex<double>>::mr collides with kSmeMrD: the SME gemm_pack_lhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+static_assert(int(gebp_traits<std::complex<double>, double>::nr) != kSmeNrD,
+              "gebp_traits<complex<double>, double>::nr collides with kSmeNrD: the SME gemm_pack_rhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+#endif
+
+// Complex block sizes, as above, but left open over the conjugation flags. A
+// complex operand really does reach the kernel conjugated -- from an adjoint or
+// conjugate product -- and the generic complex traits keep mr/nr independent of
+// that, so pinning <false, false> here would hand a conjugated instantiation the
+// generic block sizes while its kernel expects the SME ones.
+template <bool ConjLhs_, bool ConjRhs_>
+class gebp_traits<std::complex<float>, std::complex<float>, ConjLhs_, ConjRhs_, Architecture::Target, GEBPPacketFull>
+    : public gebp_traits<std::complex<float>, std::complex<float>, ConjLhs_, ConjRhs_, Architecture::Target,
+                         GEBPPacketHalf> {
+ public:
+  static constexpr int mr = kSmeMrC;
+  static constexpr int nr = kSmeNrC;
+};
+
+// The mixed-scalar guard, with the roles of the two operands swapped relative
+// to the real case: gemm_pack_lhs is instantiated with the LHS scalar and
+// Traits::mr, gemm_pack_rhs with the RHS scalar and Traits::nr.
+static_assert(int(gebp_traits<std::complex<float>, float>::mr) != kSmeMrC,
+              "gebp_traits<complex<float>, float>::mr collides with kSmeMrC: the SME gemm_pack_lhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+static_assert(int(gebp_traits<float, std::complex<float>>::nr) != kSmeNrC,
+              "gebp_traits<float, complex<float>>::nr collides with kSmeNrC: the SME gemm_pack_rhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+template <bool ConjLhs_, bool ConjRhs_>
+class gebp_traits<std::complex<double>, std::complex<double>, ConjLhs_, ConjRhs_, Architecture::Target, GEBPPacketFull>
+    : public gebp_traits<std::complex<double>, std::complex<double>, ConjLhs_, ConjRhs_, Architecture::Target,
+                         GEBPPacketHalf> {
+ public:
+  static constexpr int mr = kSmeMrCD;
+  static constexpr int nr = kSmeNrCD;
+};
+
+static_assert(int(gebp_traits<std::complex<double>, double>::mr) != kSmeMrCD,
+              "gebp_traits<complex<double>, double>::mr collides with kSmeMrCD: the SME gemm_pack_lhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+static_assert(int(gebp_traits<double, std::complex<double>>::nr) != kSmeNrCD,
+              "gebp_traits<double, complex<double>>::nr collides with kSmeNrCD: the SME gemm_pack_rhs would silently "
+              "emit SME panel layout for the generic gebp_kernel");
+#endif
+
+/*****************************************************************************
+ * gemm_pack_lhs for SME  (ColMajor source)
+ *
+ * Packs the LHS matrix into uniform panels of width mr.
+ * Each depth step k writes exactly MR contiguous scalars.
+ *****************************************************************************/
+
+template <typename Scalar, int MR, typename Index, typename DataMapper, bool Conjugate, bool PanelMode>
+struct sme_pack_lhs_colmajor {
+  // Non-streaming NEON copy of every panel, for the shallow blocks the NEON
+  // kernel consumes.
+  static EIGEN_ALWAYS_INLINE void pack_neon(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                            Index depth, Index rows, Index dst_stride, Index dst_offset) {
+    for (Index i = 0; i < rows; i += MR) {
+      const Index w = numext::mini(Index(MR), rows - i);
+      Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * w : dst_base + i * depth;
+      neon_copy_panel<Conjugate>(dst_panel, src + i, src_stride, depth, w);
+    }
+  }
+
+  __arm_locally_streaming static void pack_direct(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                                  Index depth, Index rows, Index dst_stride, Index dst_offset) {
+    const Index peeled_rows = (rows / MR) * MR;
+
+    // Full panels of width MR, streamed in svl-wide predicated chunks.
+    for (Index i = 0; i < peeled_rows; i += MR) {
+      Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * MR : dst_base + i * depth;
+      sve_copy_panel<Conjugate>(dst_panel, src + i, src_stride, depth, MR);
+    }
+
+    // Tail panel: rows < MR, use predicated SVE.
+    if (peeled_rows < rows) {
+      const Index tail = rows - peeled_rows;
+      Scalar* dst_panel =
+          PanelMode ? dst_base + peeled_rows * dst_stride + dst_offset * tail : dst_base + peeled_rows * depth;
+      sve_copy_panel<Conjugate>(dst_panel, src + peeled_rows, src_stride, depth, static_cast<int>(tail));
+    }
+  }
+
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride = 0,
+                                    Index offset = 0) {
+    if (PanelMode) {
+      eigen_assert(stride >= depth && offset <= stride);
+    }
+    // Inner-strided ColMajor blas mappers' packets advance the row index, so
+    // the fallback may use them.
+    sme_dispatch_pack<true, PanelMode>(
+        &pack_direct, &pack_neon, &sme_pack_lhs_fallback<Scalar, MR, Index, DataMapper, Conjugate, PanelMode>, blockA,
+        lhs, depth, rows, stride, offset, bool_constant<sme_mapper_has_direct_access<DataMapper, Index>::value>{});
+  }
+};
+
+// RowMajor LHS packer -- SME in-ZA transpose.
+//
+// The packed output wants depth-major layout (MR rows contiguous per depth
+// step) but the RowMajor source has rows contiguous (strided by depth per
+// row).  A natural SVE gather would be slow; instead we use ZA's 2D store
+// as a free transpose: load svl rows as horizontal slices of a ZA tile,
+// then read vertical slices to produce depth-major output (see
+// sme_transpose_pack).
+template <typename Scalar, int MR, typename Index, typename DataMapper, bool Conjugate, bool PanelMode>
+struct sme_pack_lhs_rowmajor {
+  // Non-streaming NEON copy of every panel, for the shallow blocks the NEON
+  // kernel consumes.
+  static EIGEN_ALWAYS_INLINE void pack_neon(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                            Index depth, Index rows, Index dst_stride, Index dst_offset) {
+    for (Index i = 0; i < rows; i += MR) {
+      const Index w = numext::mini(Index(MR), rows - i);
+      Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * w : dst_base + i * depth;
+      tail_transpose_pack<Conjugate>(dst_panel, src + i * src_stride, src_stride, depth, w);
+    }
+  }
+
+  __arm_locally_streaming __arm_new("za") static void pack_full_panels(Scalar* dst_base,
+                                                                       const Scalar* EIGEN_RESTRICT src,
+                                                                       Index src_stride, Index depth, Index peeled_rows,
+                                                                       Index dst_stride, Index dst_offset) {
+    for (Index i = 0; i < peeled_rows; i += MR) {
+      Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * MR : dst_base + i * depth;
+      sme_transpose_pack<Conjugate>(dst_panel, src + i * src_stride, src_stride, depth, MR);
+    }
+  }
+
+  static void pack_direct(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride, Index depth, Index rows,
+                          Index dst_stride, Index dst_offset) {
+    const Index peeled_rows = numext::round_down(rows, MR);
+
+    if (peeled_rows > 0) {
+      pack_full_panels(dst_base, src, src_stride, depth, peeled_rows, dst_stride, dst_offset);
+    }
+
+    // Row tail (rows - peeled_rows in [1, MR-1]).  This branch runs at most
+    // once per pack_lhs call with < MR rows and would need a partial-ZA-tile
+    // dance to vectorise; total copies are < MR * depth per call, which is
+    // noise vs the main packer's workload, so scalar is the simple choice --
+    // taken outside the streaming region above (see tail_transpose_pack).
+    if (peeled_rows < rows) {
+      const Index tail = rows - peeled_rows;
+      Scalar* dst_panel =
+          PanelMode ? dst_base + peeled_rows * dst_stride + dst_offset * tail : dst_base + peeled_rows * depth;
+      tail_transpose_pack<Conjugate>(dst_panel, src + peeled_rows * src_stride, src_stride, depth, tail);
+    }
+  }
+
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride = 0,
+                                    Index offset = 0) {
+    if (PanelMode) {
+      eigen_assert(stride >= depth && offset <= stride);
+    }
+    // Inner-strided RowMajor blas mappers' packets advance the depth index, not
+    // the row index, so the fallback must stay scalar (see
+    // sme_pack_lhs_fallback).
+    sme_dispatch_pack<false, PanelMode>(
+        &pack_direct, &pack_neon, &sme_pack_lhs_fallback<Scalar, MR, Index, DataMapper, Conjugate, PanelMode>, blockA,
+        lhs, depth, rows, stride, offset, bool_constant<sme_mapper_has_direct_access<DataMapper, Index>::value>{});
+  }
+};
+
+/*****************************************************************************
+ * gemm_pack_rhs for SME  (ColMajor source) -- SME in-ZA transpose, mirroring
+ * the RowMajor LHS packer.
+ *
+ * Packs the RHS matrix into panels of width nr.  ColMajor source has
+ * columns contiguous; we load NR columns as horizontal ZA slices and then
+ * read verticals to produce depth-major packed output.
+ *****************************************************************************/
+
+template <typename Scalar, int NR, typename Index, typename DataMapper, bool Conjugate, bool PanelMode>
+struct sme_pack_rhs_colmajor {
+  // Non-streaming NEON copy of every panel, for the shallow blocks the NEON
+  // kernel consumes.
+  static EIGEN_ALWAYS_INLINE void pack_neon(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                            Index depth, Index cols, Index dst_stride, Index dst_offset) {
+    for (Index i = 0; i < cols; i += NR) {
+      const Index w = numext::mini(Index(NR), cols - i);
+      Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * w : dst_base + i * depth;
+      tail_transpose_pack<Conjugate>(dst_panel, src + i * src_stride, src_stride, depth, w);
+    }
+  }
+
+  __arm_locally_streaming __arm_new("za") static void pack_full_panels(Scalar* dst_base,
+                                                                       const Scalar* EIGEN_RESTRICT src,
+                                                                       Index src_stride, Index depth, Index peeled_cols,
+                                                                       Index dst_stride, Index dst_offset) {
+    for (Index j = 0; j < peeled_cols; j += NR) {
+      Scalar* dst_panel = PanelMode ? dst_base + j * dst_stride + dst_offset * NR : dst_base + j * depth;
+      sme_transpose_pack<Conjugate>(dst_panel, src + j * src_stride, src_stride, depth, NR);
+    }
+  }
+
+  static void pack_direct(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride, Index depth, Index cols,
+                          Index dst_stride, Index dst_offset) {
+    const Index peeled_cols = numext::round_down(cols, NR);
+
+    if (peeled_cols > 0) {
+      pack_full_panels(dst_base, src, src_stride, depth, peeled_cols, dst_stride, dst_offset);
+    }
+
+    // Col tail (cols - peeled_cols in [1, NR-1]).  Same reasoning as the LHS
+    // RowMajor packer's row tail: runs at most once per call, < NR cols, not
+    // worth the partial-ZA-tile handling, and taken outside the streaming
+    // region above (see tail_transpose_pack).
+    if (peeled_cols < cols) {
+      const Index tail = cols - peeled_cols;
+      Scalar* dst_panel =
+          PanelMode ? dst_base + peeled_cols * dst_stride + dst_offset * tail : dst_base + peeled_cols * depth;
+      tail_transpose_pack<Conjugate>(dst_panel, src + peeled_cols * src_stride, src_stride, depth, tail);
+    }
+  }
+
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride = 0,
+                                    Index offset = 0) {
+    if (PanelMode) {
+      eigen_assert(stride >= depth && offset <= stride);
+    }
+    // Inner-strided ColMajor blas mappers' LinearMapper packets advance the
+    // depth index, which is what the fallback transposes.
+    sme_dispatch_pack<true, PanelMode>(
+        &pack_direct, &pack_neon, &sme_pack_rhs_fallback<Scalar, NR, Index, DataMapper, Conjugate, PanelMode>, blockB,
+        rhs, depth, cols, stride, offset, bool_constant<sme_mapper_has_direct_access<DataMapper, Index>::value>{});
+  }
+};
+
+// RowMajor RHS packer -- streaming SVE copy (mirrors the ColMajor LHS packer).
+// Rows are contiguous in the source, so each depth-step is NR contiguous scalars.
+template <typename Scalar, int NR, typename Index, typename DataMapper, bool Conjugate, bool PanelMode>
+struct sme_pack_rhs_rowmajor {
+  // Non-streaming NEON copy of every panel, for the shallow blocks the NEON
+  // kernel consumes.
+  static EIGEN_ALWAYS_INLINE void pack_neon(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                            Index depth, Index cols, Index dst_stride, Index dst_offset) {
+    for (Index i = 0; i < cols; i += NR) {
+      const Index w = numext::mini(Index(NR), cols - i);
+      Scalar* dst_panel = PanelMode ? dst_base + i * dst_stride + dst_offset * w : dst_base + i * depth;
+      neon_copy_panel<Conjugate>(dst_panel, src + i, src_stride, depth, w);
+    }
+  }
+
+  __arm_locally_streaming static void pack_direct(Scalar* dst_base, const Scalar* EIGEN_RESTRICT src, Index src_stride,
+                                                  Index depth, Index cols, Index dst_stride, Index dst_offset) {
+    const Index peeled_cols = (cols / NR) * NR;
+
+    for (Index j = 0; j < peeled_cols; j += NR) {
+      Scalar* dst_panel = PanelMode ? dst_base + j * dst_stride + dst_offset * NR : dst_base + j * depth;
+      sve_copy_panel<Conjugate>(dst_panel, src + j, src_stride, depth, NR);
+    }
+
+    if (peeled_cols < cols) {
+      const Index tail = cols - peeled_cols;
+      Scalar* dst_panel =
+          PanelMode ? dst_base + peeled_cols * dst_stride + dst_offset * tail : dst_base + peeled_cols * depth;
+      sve_copy_panel<Conjugate>(dst_panel, src + peeled_cols, src_stride, depth, static_cast<int>(tail));
+    }
+  }
+
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride = 0,
+                                    Index offset = 0) {
+    if (PanelMode) {
+      eigen_assert(stride >= depth && offset <= stride);
+    }
+    // Inner-strided RowMajor blas mappers' LinearMapper packets advance the
+    // column index, not depth, so the fallback must stay scalar (see
+    // sme_pack_rhs_fallback).
+    sme_dispatch_pack<false, PanelMode>(
+        &pack_direct, &pack_neon, &sme_pack_rhs_fallback<Scalar, NR, Index, DataMapper, Conjugate, PanelMode>, blockB,
+        rhs, depth, cols, stride, offset, bool_constant<sme_mapper_has_direct_access<DataMapper, Index>::value>{});
+  }
+};
+
+// Pack1/nr_ are pinned to the SME block sizes (rather than left open) so these
+// specializations only match consumers that actually feed the SME gebp_kernel
+// -- see "Mixed-scalar products" in the gebp_traits doc comment above.
+#define EIGEN_SME_DECLARE_GEMM_PACKERS(SCALAR, MR, NR)                                                       \
+  template <typename Index, typename DataMapper, int Pack2, typename Packet, bool Conjugate, bool PanelMode> \
+  struct gemm_pack_lhs<SCALAR, Index, DataMapper, MR, Pack2, Packet, ColMajor, Conjugate, PanelMode>         \
+      : sme_pack_lhs_colmajor<SCALAR, MR, Index, DataMapper, Conjugate, PanelMode> {};                       \
+                                                                                                             \
+  template <typename Index, typename DataMapper, int Pack2, typename Packet, bool Conjugate, bool PanelMode> \
+  struct gemm_pack_lhs<SCALAR, Index, DataMapper, MR, Pack2, Packet, RowMajor, Conjugate, PanelMode>         \
+      : sme_pack_lhs_rowmajor<SCALAR, MR, Index, DataMapper, Conjugate, PanelMode> {};                       \
+                                                                                                             \
+  template <typename Index, typename DataMapper, bool Conjugate, bool PanelMode>                             \
+  struct gemm_pack_rhs<SCALAR, Index, DataMapper, NR, ColMajor, Conjugate, PanelMode>                        \
+      : sme_pack_rhs_colmajor<SCALAR, NR, Index, DataMapper, Conjugate, PanelMode> {};                       \
+                                                                                                             \
+  template <typename Index, typename DataMapper, bool Conjugate, bool PanelMode>                             \
+  struct gemm_pack_rhs<SCALAR, Index, DataMapper, NR, RowMajor, Conjugate, PanelMode>                        \
+      : sme_pack_rhs_rowmajor<SCALAR, NR, Index, DataMapper, Conjugate, PanelMode> {};
+
+EIGEN_SME_DECLARE_GEMM_PACKERS(float, kSmeMr, kSmeNr)
+EIGEN_SME_DECLARE_GEMM_PACKERS(std::complex<float>, kSmeMrC, kSmeNrC)
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+EIGEN_SME_DECLARE_GEMM_PACKERS(double, kSmeMrD, kSmeNrD)
+EIGEN_SME_DECLARE_GEMM_PACKERS(std::complex<double>, kSmeMrCD, kSmeNrCD)
+#endif
+
+#undef EIGEN_SME_DECLARE_GEMM_PACKERS
+
+/*****************************************************************************
+ * sme_store_za_tile -- Store one ZA tile back to C with alpha scaling.
+ *
+ * `pw` is the row-predicate width for this tile, `cw` the col-predicate width
+ * (both <= the runtime svl).
+ *****************************************************************************/
+
+template <typename Scalar, int TileId, typename Index>
+EIGEN_ALWAYS_INLINE void sme_store_za_tile(Scalar* EIGEN_RESTRICT C, Index C_stride_row, Index C_stride_col,
+                                           Scalar alpha, Index row_start, int pw, Index col_start,
+                                           int cw) __arm_streaming __arm_inout("za") {
+  using Traits = sme_traits<Scalar>;
+  using Vec = typename Traits::Vec;
+  const svbool_t pg_m = Traits::whilelt(0, pw);
+  const svbool_t pg_n = Traits::whilelt(0, cw);
+  // FMLA and FADD have equal latency/throughput on ARMv9 cores, and
+  // multiplying by alpha=1.0 is exact in IEEE-754 so the FMLA form is
+  // bit-identical to FADD in that case.  A single unconditional FMLA
+  // keeps the store compact and measures no worse (and a few percent
+  // better on small matrices, where the branch would otherwise disrupt
+  // instruction scheduling).
+  const Vec vzero = Traits::dup(Scalar(0));
+  const Vec valpha = Traits::dup(alpha);
+
+  // Two C slices are loaded before either is stored: a C line the caller wrote
+  // from non-streaming code just before the kernel does not forward across the
+  // mode switch on Apple M4, and a serial load/store pays that latency per slice.
+  // C = A*B meets the condition on every call, since evalTo zeroes the
+  // destination first. SVE vectors are sizeless, hence the spelled-out pair.
+  if (C_stride_row == 1) {
+    // Column-major C: extract vertical slices (columns of the ZA tile)
+    int ci = 0;
+    for (; ci + 2 <= cw; ci += 2) {
+      Scalar* p0 = C + row_start + (col_start + ci) * C_stride_col;
+      Scalar* p1 = p0 + C_stride_col;
+      Vec c0 = sme_ld1(pg_m, p0);
+      Vec c1 = sme_ld1(pg_m, p1);
+      sme_st1(pg_m, p0, sme_mla(pg_m, c0, sme_read_ver_za<TileId>(vzero, pg_m, (uint32_t)ci), valpha));
+      sme_st1(pg_m, p1, sme_mla(pg_m, c1, sme_read_ver_za<TileId>(vzero, pg_m, (uint32_t)(ci + 1)), valpha));
+    }
+    if (ci < cw) {
+      Scalar* pC = C + row_start + (col_start + ci) * C_stride_col;
+      Vec vc = sme_ld1(pg_m, pC);
+      sme_st1(pg_m, pC, sme_mla(pg_m, vc, sme_read_ver_za<TileId>(vzero, pg_m, (uint32_t)ci), valpha));
+    }
+  } else if (C_stride_col == 1) {
+    // Row-major C: extract horizontal slices (rows of the ZA tile)
+    int ri = 0;
+    for (; ri + 2 <= pw; ri += 2) {
+      Scalar* p0 = C + (row_start + ri) * C_stride_row + col_start;
+      Scalar* p1 = p0 + C_stride_row;
+      Vec c0 = sme_ld1(pg_n, p0);
+      Vec c1 = sme_ld1(pg_n, p1);
+      sme_st1(pg_n, p0, sme_mla(pg_n, c0, sme_read_hor_za<TileId>(vzero, pg_n, (uint32_t)ri), valpha));
+      sme_st1(pg_n, p1, sme_mla(pg_n, c1, sme_read_hor_za<TileId>(vzero, pg_n, (uint32_t)(ri + 1)), valpha));
+    }
+    if (ri < pw) {
+      Scalar* pC = C + (row_start + ri) * C_stride_row + col_start;
+      Vec vc = sme_ld1(pg_n, pC);
+      sme_st1(pg_n, pC, sme_mla(pg_n, vc, sme_read_hor_za<TileId>(vzero, pg_n, (uint32_t)ri), valpha));
+    }
+  } else {
+    // General stride: extract rows to temp buffer, scatter to C.  scratch
+    // holds one ZA row; every caller passes cw <= min(svl, nr) (a tile
+    // never spans more than the logical block), so nr is a static
+    // bound independent of the runtime svl.
+    Scalar scratch[sme_block<Scalar>::nr];
+    for (int ri = 0; ri < pw; ++ri) {
+      Vec vres = sme_read_hor_za<TileId>(vzero, pg_n, (uint32_t)ri);
+      vres = sme_mul(pg_n, vres, valpha);
+      sme_st1(pg_n, scratch, vres);
+      for (int ci = 0; ci < cw; ++ci) {
+        C[(row_start + ri) * C_stride_row + (col_start + ci) * C_stride_col] += scratch[ci];
+      }
+    }
+  }
+}
+
+/*****************************************************************************
+ * sme_store_2x2_grid -- store the (up to) 2x2 grid of svl x svl ZA tiles.
+ *
+ * Tile layout:  0 = (row-lo, col-lo)  1 = (row-lo, col-hi)
+ *               2 = (row-hi, col-lo)  3 = (row-hi, col-hi)
+ * The col-hi tiles (1, 3) are stored only when chi > 0 and the row-hi tiles
+ * (2, 3) only when rhi > 0, so a single tile, a 1x2/2x1 pair, or the full grid
+ * all route through here.  Runs once per sub-block pass, after a depth loop
+ * that dwarfs it, so the branches cost nothing and predict perfectly (the
+ * pattern repeats across blocks).
+ *****************************************************************************/
+
+template <typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_store_2x2_grid(Scalar* EIGEN_RESTRICT C, Index C_stride_row, Index C_stride_col,
+                                            Scalar alpha, Index row_start, int rlo, int rhi, Index col_start, int clo,
+                                            int chi) __arm_streaming __arm_inout("za") {
+  const int svl = sme_traits<Scalar>::svl();
+  sme_store_za_tile<Scalar, 0>(C, C_stride_row, C_stride_col, alpha, row_start, rlo, col_start, clo);
+  if (chi > 0) {
+    sme_store_za_tile<Scalar, 1>(C, C_stride_row, C_stride_col, alpha, row_start, rlo, col_start + svl, chi);
+  }
+  if (rhi > 0) {
+    sme_store_za_tile<Scalar, 2>(C, C_stride_row, C_stride_col, alpha, row_start + svl, rhi, col_start, clo);
+    if (chi > 0) {
+      sme_store_za_tile<Scalar, 3>(C, C_stride_row, C_stride_col, alpha, row_start + svl, rhi, col_start + svl, chi);
+    }
+  }
+}
+
+// One depth step's worth of the exact-match grid: the four FMOPAs that take the
+// lo/hi halves of a packed A column and a packed B column and accumulate the
+// 2x2 ZA-tile outer product.  `all` is the all-true predicate because this is
+// only used on the exact-match path, where the block fills the grid, so
+// factoring it out is identical to the inline form.
+template <typename Scalar>
+static EIGEN_ALWAYS_INLINE void outer_product_2x2(
+    typename sme_traits<Scalar>::Vec a_lo, typename sme_traits<Scalar>::Vec a_hi, typename sme_traits<Scalar>::Vec b_lo,
+    typename sme_traits<Scalar>::Vec b_hi) __arm_streaming __arm_inout("za") {
+  const svbool_t all = sme_traits<Scalar>::ptrue();
+  sme_mopa<0>(all, all, a_lo, b_lo);
+  sme_mopa<1>(all, all, a_lo, b_hi);
+  sme_mopa<2>(all, all, a_hi, b_lo);
+  sme_mopa<3>(all, all, a_hi, b_hi);
+}
+
+/*****************************************************************************
+ * Complex accumulator: a pair of ZA tiles holding the real and imaginary
+ * halves of one grid cell.
+ *
+ * With a = ar + i*sa*ai and b = br + i*sb*bi, where sa is -1 when the LHS is
+ * conjugated and sb likewise for the RHS,
+ *
+ *   re(a*b) = ar*br - (sa*sb) * ai*bi,     im(a*b) = sb * ar*bi + sa * ai*br,
+ *
+ * so all four real outer products differ only in whether they accumulate
+ * (FMOPA) or subtract (FMOPS) -- a compile-time choice, with no work in the
+ * depth loop and no separate conjugating packer.
+ *
+ * Slices come back out through sme_read_scaled_slice, which applies the complex
+ * alpha and interleaves the halves with ZIP1/ZIP2 into the two vectors that
+ * cover one slice's worth of contiguous complex results.
+ *
+ * A ZA tile number is an instruction immediate, so cells outside the tile grid
+ * (complex<float> has two tile pairs, hence a single grid row) are dropped by
+ * the InGrid specialization rather than by a runtime guard, which would still
+ * have to name an in-range tile.
+ *****************************************************************************/
+
+// One slice of a tile pair, re-interleaved into the two vectors that cover its
+// complex results: `lo` the first half, `hi` the second.  ScaleByAlpha applies
+// the complex alpha, four predicated FP ops the caller skips when alpha is 1
+// (see sme_store_za_pair) -- streaming-mode FP is de-rated enough on Apple M4
+// that those four cost about as much as the rest of the slice.
+template <typename RealScalar, int TileRe, int TileIm, bool Vertical, bool ScaleByAlpha>
+EIGEN_ALWAYS_INLINE void sme_read_slice(svbool_t pg, typename sme_traits<RealScalar>::Vec valpha_re,
+                                        typename sme_traits<RealScalar>::Vec valpha_im,
+                                        typename sme_traits<RealScalar>::Vec vzero, uint32_t slice,
+                                        typename sme_traits<RealScalar>::Vec& lo,
+                                        typename sme_traits<RealScalar>::Vec& hi) __arm_streaming __arm_inout("za") {
+  using Vec = typename sme_traits<RealScalar>::Vec;
+  Vec re, im;
+  EIGEN_IF_CONSTEXPR (Vertical) {
+    re = sme_read_ver_za<TileRe>(vzero, pg, slice);
+    im = sme_read_ver_za<TileIm>(vzero, pg, slice);
+  } else {
+    re = sme_read_hor_za<TileRe>(vzero, pg, slice);
+    im = sme_read_hor_za<TileIm>(vzero, pg, slice);
+  }
+  EIGEN_IF_CONSTEXPR (ScaleByAlpha) {
+    const Vec out_re = sme_mls(pg, sme_mul(pg, re, valpha_re), im, valpha_im);
+    const Vec out_im = sme_mla(pg, sme_mul(pg, im, valpha_re), re, valpha_im);
+    lo = sme_zip1(out_re, out_im);
+    hi = sme_zip2(out_re, out_im);
+  } else {
+    lo = sme_zip1(re, im);
+    hi = sme_zip2(re, im);
+  }
+}
+
+// Accumulate a tile pair's `slices` slices into C along its contiguous axis,
+// `step` reals apart.  `lanes` is twice a slice's complex count; when it fits
+// one vector the high half's predicate is empty, so its load and store are
+// no-ops even though the destination has nothing at p + svl to point at.
+template <typename RealScalar, int TileRe, int TileIm, bool Vertical, bool ScaleByAlpha, typename Index>
+EIGEN_ALWAYS_INLINE void sme_accumulate_pair_impl(
+    RealScalar* EIGEN_RESTRICT p, Index step, int slices, int lanes, svbool_t pg,
+    typename sme_traits<RealScalar>::Vec valpha_re, typename sme_traits<RealScalar>::Vec valpha_im,
+    typename sme_traits<RealScalar>::Vec vzero) __arm_streaming __arm_inout("za") {
+  using Traits = sme_traits<RealScalar>;
+  using Vec = typename Traits::Vec;
+  const int svl = Traits::svl();
+  const svbool_t pl0 = Traits::whilelt(0, lanes);
+  const svbool_t pl1 = Traits::whilelt(svl, lanes);
+  for (int s = 0; s < slices; ++s, p += step) {
+    Vec lo, hi;
+    sme_read_slice<RealScalar, TileRe, TileIm, Vertical, ScaleByAlpha>(pg, valpha_re, valpha_im, vzero, uint32_t(s), lo,
+                                                                       hi);
+    sme_st1(pl0, p, sme_add(pl0, sme_ld1(pl0, p), lo));
+    // pl1 is all-false when one vector covers the slice, and an inactive lane
+    // neither reads nor writes -- so this needs no `lanes > svl` guard, only an
+    // address the destination is allowed to form.
+    RealScalar* EIGEN_RESTRICT phi = sme_offset(p, Index(svl));
+    sme_st1(pl1, phi, sme_add(pl1, sme_ld1(pl1, phi), hi));
+  }
+}
+
+template <typename RealScalar, int TileRe, int TileIm, bool Vertical, typename Index>
+EIGEN_ALWAYS_INLINE void sme_accumulate_pair(
+    bool scale_by_alpha, RealScalar* EIGEN_RESTRICT p, Index step, int slices, int lanes, svbool_t pg,
+    typename sme_traits<RealScalar>::Vec valpha_re, typename sme_traits<RealScalar>::Vec valpha_im,
+    typename sme_traits<RealScalar>::Vec vzero) __arm_streaming __arm_inout("za") {
+  if (scale_by_alpha) {
+    sme_accumulate_pair_impl<RealScalar, TileRe, TileIm, Vertical, true>(p, step, slices, lanes, pg, valpha_re,
+                                                                         valpha_im, vzero);
+  } else {
+    sme_accumulate_pair_impl<RealScalar, TileRe, TileIm, Vertical, false>(p, step, slices, lanes, pg, valpha_re,
+                                                                          valpha_im, vzero);
+  }
+}
+
+// Store one complex tile pair back to C.  `pw` is the row-predicate width for
+// this cell and `cw` the column one, both <= the runtime svl.
+template <typename RealScalar, int TileRe, int TileIm, typename Index>
+EIGEN_ALWAYS_INLINE void sme_store_za_pair(std::complex<RealScalar>* EIGEN_RESTRICT C, Index C_stride_row,
+                                           Index C_stride_col, std::complex<RealScalar> alpha, Index row_start, int pw,
+                                           Index col_start, int cw) __arm_streaming __arm_inout("za") {
+  using Scalar = std::complex<RealScalar>;
+  using Traits = sme_traits<RealScalar>;
+  using Vec = typename Traits::Vec;
+  const int svl = Traits::svl();
+  const svbool_t pg_m = Traits::whilelt(0, pw);
+  const svbool_t pg_n = Traits::whilelt(0, cw);
+  const Vec vzero = Traits::dup(RealScalar(0));
+  // std::complex's accessors are ordinary functions, which clang cannot inline
+  // into a streaming context; the resulting mode switch would sit in this loop.
+  // A complex is layout-compatible with its two-element real array, so read the
+  // parts through that view instead.
+  const RealScalar* alpha_parts = reinterpret_cast<const RealScalar*>(&alpha);
+  const Vec valpha_re = Traits::dup(alpha_parts[0]);
+  const Vec valpha_im = Traits::dup(alpha_parts[1]);
+  // Scaling by 1 + 0i is exact, so skipping it is bit-identical -- and it is by
+  // far the common case, since a plain product carries alpha = 1.
+  const bool scale = !(alpha_parts[0] == RealScalar(1) && alpha_parts[1] == RealScalar(0));
+  RealScalar* EIGEN_RESTRICT rC = reinterpret_cast<RealScalar*>(C);
+
+  if (C_stride_row == 1) {
+    // Column-major C: vertical slices are the tile pair's columns, and one
+    // slice is pw contiguous complex results, i.e. 2*pw reals.
+    RealScalar* p = rC + Index(2) * (row_start + col_start * C_stride_col);
+    sme_accumulate_pair<RealScalar, TileRe, TileIm, true>(scale, p, Index(2) * C_stride_col, cw, 2 * pw, pg_m,
+                                                          valpha_re, valpha_im, vzero);
+  } else if (C_stride_col == 1) {
+    // Row-major C: horizontal slices are the tile pair's rows.
+    RealScalar* p = rC + Index(2) * (row_start * C_stride_row + col_start);
+    sme_accumulate_pair<RealScalar, TileRe, TileIm, false>(scale, p, Index(2) * C_stride_row, pw, 2 * cw, pg_n,
+                                                           valpha_re, valpha_im, vzero);
+  } else {
+    // General stride: interleave a row into a temp buffer, scatter to C.  Every
+    // caller passes cw <= min(svl, nr), so nr is a static bound on the buffer,
+    // independent of the runtime svl.  This path is scalar anyway, so it always
+    // takes the scaling form.
+    Scalar scratch[sme_block<Scalar>::nr];
+    RealScalar* rscratch = reinterpret_cast<RealScalar*>(scratch);
+    const int lanes = 2 * cw;
+    const svbool_t pl0 = Traits::whilelt(0, lanes);
+    const svbool_t pl1 = Traits::whilelt(svl, lanes);
+    for (int ri = 0; ri < pw; ++ri) {
+      Vec lo, hi;
+      sme_read_slice<RealScalar, TileRe, TileIm, false, true>(pg_n, valpha_re, valpha_im, vzero, uint32_t(ri), lo, hi);
+      sme_st1(pl0, rscratch, lo);
+      // scratch is nr complex, i.e. 2*nr >= 2*svl reals, so rscratch + svl is
+      // always in bounds; pl1 is all-false when one vector already covers cw.
+      sme_st1(pl1, rscratch + svl, hi);
+      for (int ci = 0; ci < cw; ++ci) {
+        C[(row_start + ri) * C_stride_row + (col_start + ci) * C_stride_col] += scratch[ci];
+      }
+    }
+  }
+}
+
+// Grid cell (R, C) of a complex block: its tile pair, the four signed outer
+// products that feed it, and its store.
+template <typename Scalar, int R, int C, bool ConjLhs, bool ConjRhs,
+          bool InGrid = (R < sme_block<Scalar>::kGridRows && C < sme_block<Scalar>::kGridCols)>
+struct sme_complex_cell {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Vec = typename sme_traits<RealScalar>::Vec;
+  static constexpr int kTileRe = 2 * (R * sme_block<Scalar>::kGridCols + C);
+  static constexpr int kTileIm = kTileRe + 1;
+
+  static EIGEN_ALWAYS_INLINE void accumulate(svbool_t pm, svbool_t pn, Vec a_re, Vec a_im, Vec b_re,
+                                             Vec b_im) __arm_streaming __arm_inout("za") {
+    sme_mopa_signed<kTileRe, false>(pm, pn, a_re, b_re);
+    sme_mopa_signed<kTileRe, ConjLhs == ConjRhs>(pm, pn, a_im, b_im);
+    sme_mopa_signed<kTileIm, ConjRhs>(pm, pn, a_re, b_im);
+    sme_mopa_signed<kTileIm, ConjLhs>(pm, pn, a_im, b_re);
+  }
+
+  template <typename Index>
+  static EIGEN_ALWAYS_INLINE void store(Scalar* EIGEN_RESTRICT dst, Index C_stride_row, Index C_stride_col,
+                                        Scalar alpha, Index row_start, int pw, Index col_start,
+                                        int cw) __arm_streaming __arm_inout("za") {
+    sme_store_za_pair<RealScalar, kTileRe, kTileIm>(dst, C_stride_row, C_stride_col, alpha, row_start, pw, col_start,
+                                                    cw);
+  }
+};
+
+template <typename Scalar, int R, int C, bool ConjLhs, bool ConjRhs>
+struct sme_complex_cell<Scalar, R, C, ConjLhs, ConjRhs, false> {
+  using Vec = typename sme_traits<typename NumTraits<Scalar>::Real>::Vec;
+  static EIGEN_ALWAYS_INLINE void accumulate(svbool_t, svbool_t, Vec, Vec, Vec, Vec) __arm_streaming __arm_inout("za") {
+  }
+  template <typename Index>
+  static EIGEN_ALWAYS_INLINE void store(Scalar*, Index, Index, Scalar, Index, int, Index,
+                                        int) __arm_streaming __arm_inout("za") {}
+};
+
+/*****************************************************************************
+ * sme_process -- micro-kernel for one pw x cw output block.
+ *
+ * Tiles the block into svl x svl ZA tiles, processed in passes of up to a 2x2
+ * tile grid: several (2*svl) x (2*svl) sub-block passes when the grid is
+ * smaller than the block, tiles predicated down to the block width when it is
+ * larger.  blA/blB are packed depth-major with depth-strides pw and cw
+ * respectively.
+ *
+ * When the block matches the tile grid exactly (pw == cw == 2 * svl), the
+ * packed rows are also contiguous across depth steps, enabling the
+ * hand-scheduled loop below: per 4 unrolled depth steps, 2 x4 loads per
+ * side (each spanning 2 depth steps) feed 16 FMOPAs -- a 1:1 compute:load
+ * ratio at the vector level.  All other geometries use predicated
+ * per-depth-step loads.
+ *****************************************************************************/
+
+template <bool ConjLhs, bool ConjRhs, typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_process(Scalar* EIGEN_RESTRICT C, Index C_stride_row, Index C_stride_col,
+                                     const Scalar* EIGEN_RESTRICT blA, const Scalar* EIGEN_RESTRICT blB, Index depth,
+                                     Scalar alpha, Index row_start, int pw, Index col_start,
+                                     int cw) __arm_streaming __arm_inout("za") {
+  // Conjugation is the identity on real scalars, so this overload ignores it.
+  using Traits = sme_traits<Scalar>;
+  using Vec = typename Traits::Vec;
+  const int svl = Traits::svl();
+
+  for (int rt = 0; rt < pw; rt += 2 * svl) {
+    const int rpw = sme_min(pw - rt, 2 * svl);
+    const int rlo = sme_min(rpw, svl);
+    const int rhi = rpw - rlo;  // >= 0; > 0 only when rpw > svl, in which case rlo == svl
+    const svbool_t pg_rlo = Traits::whilelt(rt, pw);
+    const svbool_t pg_rhi = Traits::whilelt(rt + svl, pw);
+
+    for (int ct = 0; ct < cw; ct += 2 * svl) {
+      const int cpw = sme_min(cw - ct, 2 * svl);
+      const int clo = sme_min(cpw, svl);
+      const int chi = cpw - clo;
+      const svbool_t pg_clo = Traits::whilelt(ct, cw);
+      const svbool_t pg_chi = Traits::whilelt(ct + svl, cw);
+
+      svzero_za();
+      if (pw == 2 * svl && cw == 2 * svl) {
+        // The block is exactly one full-grid patch (single pass, rt == ct ==
+        // 0, rlo == rhi == clo == chi == svl), so a packed row is the
+        // patch's slice and rows are contiguous across depth steps: x4 loads
+        // each span 2 of them, e.g. va_01 = [d0 lo, d0 hi, d1 lo, d1 hi].
+        const svcount_t pn = Traits::ptrue_c();
+        const Index depth_4 = (depth / 4) * 4;
+        Index k = 0;
+        for (; k < depth_4; k += 4) {
+          typename Traits::Vec4 va_01 = sme_ld1_x4(pn, &blA[k * pw]);
+          typename Traits::Vec4 vb_01 = sme_ld1_x4(pn, &blB[k * cw]);
+
+          // d0
+          outer_product_2x2<Scalar>(sme_get<0>(va_01), sme_get<1>(va_01), sme_get<0>(vb_01), sme_get<1>(vb_01));
+          // d1
+          outer_product_2x2<Scalar>(sme_get<2>(va_01), sme_get<3>(va_01), sme_get<2>(vb_01), sme_get<3>(vb_01));
+
+          typename Traits::Vec4 va_23 = sme_ld1_x4(pn, &blA[(k + 2) * pw]);
+          typename Traits::Vec4 vb_23 = sme_ld1_x4(pn, &blB[(k + 2) * cw]);
+
+          // d2
+          outer_product_2x2<Scalar>(sme_get<0>(va_23), sme_get<1>(va_23), sme_get<0>(vb_23), sme_get<1>(vb_23));
+          // d3
+          outer_product_2x2<Scalar>(sme_get<2>(va_23), sme_get<3>(va_23), sme_get<2>(vb_23), sme_get<3>(vb_23));
+        }
+        // Depth tail: one x2 load per side per step.
+        for (; k < depth; ++k) {
+          typename Traits::Vec2 va = sme_ld1_x2(pn, &blA[k * pw]);
+          typename Traits::Vec2 vb = sme_ld1_x2(pn, &blB[k * cw]);
+          outer_product_2x2<Scalar>(sme_get<0>(va), sme_get<1>(va), sme_get<0>(vb), sme_get<1>(vb));
+        }
+      } else {
+        for (Index k = 0; k < depth; ++k) {
+          Vec a_lo = sme_ld1(pg_rlo, &blA[k * pw + rt]);
+          Vec b_lo = sme_ld1(pg_clo, &blB[k * cw + ct]);
+
+          Vec a_hi = sme_ld1(pg_rhi, sme_offset(blA, k * pw + rt + svl));
+          Vec b_hi = sme_ld1(pg_chi, sme_offset(blB, k * cw + ct + svl));
+
+          sme_mopa<0>(pg_rlo, pg_clo, a_lo, b_lo);
+          if (svptest_any(pg_chi, pg_chi)) sme_mopa<1>(pg_rlo, pg_chi, a_lo, b_hi);
+          if (svptest_any(pg_rhi, pg_rhi)) {
+            sme_mopa<2>(pg_rhi, pg_clo, a_hi, b_lo);
+            if (svptest_any(pg_chi, pg_chi)) sme_mopa<3>(pg_rhi, pg_chi, a_hi, b_hi);
+          }
+        }
+      }
+
+      // Store the (up to) 2x2 grid of tiles for this sub-block pass.
+      sme_store_2x2_grid(C, C_stride_row, C_stride_col, alpha, row_start + rt, rlo, rhi, col_start + ct, clo, chi);
+    }
+  }
+}
+
+/*****************************************************************************
+ * sme_store_complex_grid -- store the (up to) 2x2 grid of tile pairs, exactly
+ * as sme_store_2x2_grid does for single tiles.  Cells outside the grid are
+ * dropped at compile time by sme_complex_cell, so a narrower grid simply never
+ * reaches them (its hi widths are structurally zero).
+ *****************************************************************************/
+template <typename Scalar, bool ConjLhs, bool ConjRhs, typename Index>
+EIGEN_ALWAYS_INLINE void sme_store_complex_grid(Scalar* EIGEN_RESTRICT C, Index C_stride_row, Index C_stride_col,
+                                                Scalar alpha, Index row_start, int rlo, int rhi, Index col_start,
+                                                int clo, int chi) __arm_streaming __arm_inout("za") {
+  const int svl = sme_traits<typename NumTraits<Scalar>::Real>::svl();
+  sme_complex_cell<Scalar, 0, 0, ConjLhs, ConjRhs>::store(C, C_stride_row, C_stride_col, alpha, row_start, rlo,
+                                                          col_start, clo);
+  if (chi > 0) {
+    sme_complex_cell<Scalar, 0, 1, ConjLhs, ConjRhs>::store(C, C_stride_row, C_stride_col, alpha, row_start, rlo,
+                                                            col_start + svl, chi);
+  }
+  if (rhi > 0) {
+    sme_complex_cell<Scalar, 1, 0, ConjLhs, ConjRhs>::store(C, C_stride_row, C_stride_col, alpha, row_start + svl, rhi,
+                                                            col_start, clo);
+    if (chi > 0) {
+      sme_complex_cell<Scalar, 1, 1, ConjLhs, ConjRhs>::store(C, C_stride_row, C_stride_col, alpha, row_start + svl,
+                                                              rhi, col_start + svl, chi);
+    }
+  }
+}
+
+/*****************************************************************************
+ * sme_process, complex overload -- same sub-block structure over a grid of
+ * complex accumulators, each a pair of ZA tiles (see sme_complex_cell).
+ *
+ * The packed panels are read through their real view: one depth step is `pw`
+ * (`cw`) reals followed by as many imaginary ones, so a cell's four operands
+ * are four contiguous predicated loads at a fixed offset apart, and the four
+ * outer products they feed reuse all of them.
+ *****************************************************************************/
+template <bool ConjLhs, bool ConjRhs, typename RealScalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_process(std::complex<RealScalar>* EIGEN_RESTRICT C, Index C_stride_row, Index C_stride_col,
+                                     const std::complex<RealScalar>* EIGEN_RESTRICT blA,
+                                     const std::complex<RealScalar>* EIGEN_RESTRICT blB, Index depth,
+                                     std::complex<RealScalar> alpha, Index row_start, int pw, Index col_start,
+                                     int cw) __arm_streaming __arm_inout("za") {
+  using Scalar = std::complex<RealScalar>;
+  using Traits = sme_traits<RealScalar>;
+  using Vec = typename Traits::Vec;
+  const int svl = Traits::svl();
+  constexpr int GridRows = sme_block<Scalar>::kGridRows;
+  constexpr int GridCols = sme_block<Scalar>::kGridCols;
+  using Cell00 = sme_complex_cell<Scalar, 0, 0, ConjLhs, ConjRhs>;
+  using Cell01 = sme_complex_cell<Scalar, 0, 1, ConjLhs, ConjRhs>;
+  using Cell10 = sme_complex_cell<Scalar, 1, 0, ConjLhs, ConjRhs>;
+  using Cell11 = sme_complex_cell<Scalar, 1, 1, ConjLhs, ConjRhs>;
+
+  const RealScalar* EIGEN_RESTRICT rA = reinterpret_cast<const RealScalar*>(blA);
+  const RealScalar* EIGEN_RESTRICT rB = reinterpret_cast<const RealScalar*>(blB);
+  const Index a_step = Index(2 * pw);
+  const Index b_step = Index(2 * cw);
+
+  for (int rt = 0; rt < pw; rt += GridRows * svl) {
+    const int rpw = sme_min(pw - rt, GridRows * svl);
+    const int r0 = sme_min(rpw, svl);
+    const int r1 = rpw - r0;
+    const svbool_t pg_r0 = Traits::whilelt(0, rpw);
+    const svbool_t pg_r1 = Traits::whilelt(svl, rpw);
+
+    for (int ct = 0; ct < cw; ct += GridCols * svl) {
+      const int cpw = sme_min(cw - ct, GridCols * svl);
+      const int c0 = sme_min(cpw, svl);
+      const int c1 = cpw - c0;
+      const svbool_t pg_c0 = Traits::whilelt(0, cpw);
+      const svbool_t pg_c1 = Traits::whilelt(svl, cpw);
+
+      svzero_za();
+      for (Index k = 0; k < depth; ++k) {
+        const RealScalar* pa = rA + k * a_step + Index(rt);
+        const RealScalar* pb = rB + k * b_step + Index(ct);
+        // The second-tile loads are unconditional: their predicates are empty
+        // when the grid is a single tile wide or tall, so they touch no memory.
+        // Grouping them lets the compiler issue them in parallel, and gating the
+        // outer products on svptest_any keeps the depth loop unswitched without
+        // materialising the r1/c1 counts here.
+        const Vec a0_re = sme_ld1(pg_r0, pa);
+        const Vec a0_im = sme_ld1(pg_r0, pa + pw);
+        const Vec b0_re = sme_ld1(pg_c0, pb);
+        const Vec b0_im = sme_ld1(pg_c0, pb + cw);
+        const Vec a1_re = sme_ld1(pg_r1, sme_offset(pa, Index(svl)));
+        const Vec a1_im = sme_ld1(pg_r1, sme_offset(pa, Index(pw) + Index(svl)));
+        const Vec b1_re = sme_ld1(pg_c1, sme_offset(pb, Index(svl)));
+        const Vec b1_im = sme_ld1(pg_c1, sme_offset(pb, Index(cw) + Index(svl)));
+        Cell00::accumulate(pg_r0, pg_c0, a0_re, a0_im, b0_re, b0_im);
+        if (svptest_any(pg_c1, pg_c1)) {
+          Cell01::accumulate(pg_r0, pg_c1, a0_re, a0_im, b1_re, b1_im);
+        }
+        if (svptest_any(pg_r1, pg_r1)) {
+          Cell10::accumulate(pg_r1, pg_c0, a1_re, a1_im, b0_re, b0_im);
+          if (svptest_any(pg_c1, pg_c1)) {
+            Cell11::accumulate(pg_r1, pg_c1, a1_re, a1_im, b1_re, b1_im);
+          }
+        }
+      }
+
+      sme_store_complex_grid<Scalar, ConjLhs, ConjRhs>(C, C_stride_row, C_stride_col, alpha, row_start + rt, r0, r1,
+                                                       col_start + ct, c0, c1);
+    }
+  }
+}
+
+template <typename Scalar, bool ConjLhs, bool ConjRhs, typename Index>
+EIGEN_DONT_INLINE __arm_locally_streaming __arm_new("za") void sme_gebp_impl(
+    Scalar* C, Index C_stride_row, Index C_stride_col, const Scalar* blockA, const Scalar* blockB, Index rows,
+    Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB) {
+  constexpr int MR = sme_block<Scalar>::mr;
+  constexpr int NR = sme_block<Scalar>::nr;
+
+  // Column-outer, row-inner: keeps blB (one kc × NR panel) hot in L1 while
+  // smaller blA tiles stream from L2.  The outer GOTO loop in
+  // GeneralMatrixMatrix.h ensures blockA fits in L2 via mc-blocking.  Each
+  // packed panel is depth-major with depth-stride equal to its width (MR/NR
+  // for full panels, the tail width otherwise), so that width is passed as
+  // both the logical block size and the load stride to sme_process; partial
+  // blocks are tiled and predicated inside the generic path.
+  for (Index j = 0; j < cols; j += NR) {
+    const int cw = static_cast<int>(sme_min(cols - j, Index(NR)));
+    const Scalar* blB = blockB + j * strideB + offsetB * cw;
+
+    for (Index i = 0; i < rows; i += MR) {
+      const int pw = static_cast<int>(sme_min(rows - i, Index(MR)));
+      const Scalar* blA = blockA + i * strideA + offsetA * pw;
+      sme_process<ConjLhs, ConjRhs>(C, C_stride_row, C_stride_col, blA, blB, depth, alpha, i, pw, j, cw);
+    }
+  }
+}
+
+// NEON path for small blocks: a shallow block pays the ZA enable and a dependent FMOPA chain per
+// tile for little work, so its panels are consumed with NEON in the SME layout (one depth step is
+// pw contiguous scalars, complex ones as pw reals then pw imaginaries).
+// The NCol columns of one depth step, loaded once; each column is then an
+// immediate lane of a fused multiply-add (nmadd: acc - a * b[lane]).
+template <typename Scalar, int NCol>
+struct sme_neon_cols;
+template <>
+struct sme_neon_cols<float, 4> {
+  using Vec = float32x4_t;
+  static EIGEN_ALWAYS_INLINE Vec load(const float* b) { return vld1q_f32(b); }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f madd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmaq_laneq_f32(acc, a, b, C);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f nmadd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmsq_laneq_f32(acc, a, b, C);
+  }
+};
+template <>
+struct sme_neon_cols<float, 2> {
+  using Vec = float32x2_t;
+  static EIGEN_ALWAYS_INLINE Vec load(const float* b) { return vld1_f32(b); }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f madd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmaq_lane_f32(acc, a, b, C);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f nmadd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmsq_lane_f32(acc, a, b, C);
+  }
+};
+template <>
+struct sme_neon_cols<float, 1> {
+  using Vec = float32x4_t;
+  static EIGEN_ALWAYS_INLINE Vec load(const float* b) { return vld1q_dup_f32(b); }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f madd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmaq_f32(acc, a, b);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f nmadd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmsq_f32(acc, a, b);
+  }
+};
+template <>
+struct sme_neon_cols<double, 4> {
+  struct Vec {
+    float64x2_t lo, hi;
+  };
+  static EIGEN_ALWAYS_INLINE Vec load(const double* b) { return {vld1q_f64(b), vld1q_f64(b + 2)}; }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d madd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmaq_laneq_f64(acc, a, C < 2 ? b.lo : b.hi, C & 1);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d nmadd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmsq_laneq_f64(acc, a, C < 2 ? b.lo : b.hi, C & 1);
+  }
+};
+template <>
+struct sme_neon_cols<double, 2> {
+  using Vec = float64x2_t;
+  static EIGEN_ALWAYS_INLINE Vec load(const double* b) { return vld1q_f64(b); }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d madd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmaq_laneq_f64(acc, a, b, C);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d nmadd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmsq_laneq_f64(acc, a, b, C);
+  }
+};
+template <>
+struct sme_neon_cols<double, 1> {
+  using Vec = float64x2_t;
+  static EIGEN_ALWAYS_INLINE Vec load(const double* b) { return vld1q_dup_f64(b); }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d madd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmaq_f64(acc, a, b);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d nmadd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmsq_f64(acc, a, b);
+  }
+};
+
+template <>
+struct sme_neon_cols<float, 8> {
+  struct Vec {
+    float32x4_t lo, hi;
+  };
+  static EIGEN_ALWAYS_INLINE Vec load(const float* b) { return {vld1q_f32(b), vld1q_f32(b + 4)}; }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f madd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmaq_laneq_f32(acc, a, C < 4 ? b.lo : b.hi, C & 3);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet4f nmadd(Packet4f acc, Packet4f a, Vec b) {
+    return vfmsq_laneq_f32(acc, a, C < 4 ? b.lo : b.hi, C & 3);
+  }
+};
+template <>
+struct sme_neon_cols<double, 8> {
+  struct Vec {
+    float64x2_t v[4];
+  };
+  static EIGEN_ALWAYS_INLINE Vec load(const double* b) {
+    return {{vld1q_f64(b), vld1q_f64(b + 2), vld1q_f64(b + 4), vld1q_f64(b + 6)}};
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d madd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmaq_laneq_f64(acc, a, b.v[C >> 1], C & 1);
+  }
+  template <int C>
+  static EIGEN_ALWAYS_INLINE Packet2d nmadd(Packet2d acc, Packet2d a, Vec b) {
+    return vfmsq_laneq_f64(acc, a, b.v[C >> 1], C & 1);
+  }
+};
+
+// Compile-time loop over the columns of a tile (lane numbers are immediates).
+template <int C, int NCol>
+struct sme_neon_col_loop {
+  template <typename Cols, typename Packet, int NPack>
+  static EIGEN_ALWAYS_INLINE void real(Packet (&acc)[NPack][NCol], const Packet (&av)[NPack], typename Cols::Vec b) {
+    for (int p = 0; p < NPack; ++p) acc[p][C] = Cols::template madd<C>(acc[p][C], av[p], b);
+    sme_neon_col_loop<C + 1, NCol>::template real<Cols, Packet, NPack>(acc, av, b);
+  }
+  template <bool ConjLhs, bool ConjRhs, typename Cols, typename Packet, int NPack>
+  static EIGEN_ALWAYS_INLINE void cplx(Packet (&acc_re)[NPack][NCol], Packet (&acc_im)[NPack][NCol],
+                                       const Packet (&are)[NPack], const Packet (&aim)[NPack], typename Cols::Vec bre,
+                                       typename Cols::Vec bim) {
+    for (int p = 0; p < NPack; ++p) {
+      acc_re[p][C] = Cols::template madd<C>(acc_re[p][C], are[p], bre);
+      acc_re[p][C] = (ConjLhs != ConjRhs) ? Cols::template madd<C>(acc_re[p][C], aim[p], bim)
+                                          : Cols::template nmadd<C>(acc_re[p][C], aim[p], bim);
+      acc_im[p][C] = ConjLhs ? Cols::template nmadd<C>(acc_im[p][C], aim[p], bre)
+                             : Cols::template madd<C>(acc_im[p][C], aim[p], bre);
+      acc_im[p][C] = ConjRhs ? Cols::template nmadd<C>(acc_im[p][C], are[p], bim)
+                             : Cols::template madd<C>(acc_im[p][C], are[p], bim);
+    }
+    sme_neon_col_loop<C + 1, NCol>::template cplx<ConjLhs, ConjRhs, Cols, Packet, NPack>(acc_re, acc_im, are, aim, bre,
+                                                                                         bim);
+  }
+};
+template <int NCol>
+struct sme_neon_col_loop<NCol, NCol> {
+  template <typename Cols, typename Packet, int NPack>
+  static EIGEN_ALWAYS_INLINE void real(Packet (&)[NPack][NCol], const Packet (&)[NPack], typename Cols::Vec) {}
+  template <bool ConjLhs, bool ConjRhs, typename Cols, typename Packet, int NPack>
+  static EIGEN_ALWAYS_INLINE void cplx(Packet (&)[NPack][NCol], Packet (&)[NPack][NCol], const Packet (&)[NPack],
+                                       const Packet (&)[NPack], typename Cols::Vec, typename Cols::Vec) {}
+};
+
+// One (NPack * PacketSize) x NCol micro-tile of a real block; NPack == 0 is a
+// single scalar row. Pointers arrive offset to the tile's first row and column.
+template <typename Scalar, typename Index, int NPack, int NCol>
+struct sme_neon_tile {
+  using Packet = typename packet_traits<Scalar>::type;
+  using Cols = sme_neon_cols<Scalar, NCol>;
+  static constexpr int PS = packet_traits<Scalar>::size;
+  // Narrow tiles split the depth over KU accumulator chains to hide FMA latency.
+  static constexpr int KU = (NPack * NCol >= 4) ? 1 : 4 / (NPack * NCol);
+  static EIGEN_ALWAYS_INLINE void step(Packet (&acc)[NPack][NCol], const Scalar* a, const Scalar* b) {
+    Packet av[NPack];
+    for (int p = 0; p < NPack; ++p) av[p] = ploadu<Packet>(a + p * PS);
+    sme_neon_col_loop<0, NCol>::template real<Cols, Packet, NPack>(acc, av, Cols::load(b));
+  }
+  static EIGEN_ALWAYS_INLINE void run(Scalar* C, Index rs, Index cs, const Scalar* blA, const Scalar* blB, Index depth,
+                                      Scalar alpha, Index pw, Index cw) {
+    Packet acc[KU][NPack][NCol];
+    for (int u = 0; u < KU; ++u)
+      for (int p = 0; p < NPack; ++p)
+        for (int c = 0; c < NCol; ++c) acc[u][p][c] = pset1<Packet>(Scalar(0));
+    Index k = 0;
+    for (; k + KU <= depth; k += KU) {
+      for (int u = 0; u < KU; ++u) step(acc[u], blA + (k + u) * pw, blB + (k + u) * cw);
+    }
+    for (; k < depth; ++k) step(acc[0], blA + k * pw, blB + k * cw);
+    for (int u = 1; u < KU; ++u)
+      for (int p = 0; p < NPack; ++p)
+        for (int c = 0; c < NCol; ++c) acc[0][p][c] = padd(acc[0][p][c], acc[u][p][c]);
+    const Packet valpha = pset1<Packet>(alpha);
+    for (int c = 0; c < NCol; ++c) {
+      for (int p = 0; p < NPack; ++p) {
+        Scalar* pc = C + Index(p * PS) * rs + Index(c) * cs;
+        if (rs == 1) {
+          pstoreu(pc, pmadd(acc[0][p][c], valpha, ploadu<Packet>(pc)));
+        } else {
+          pscatter<Scalar, Packet>(pc, pmadd(acc[0][p][c], valpha, pgather<Scalar, Packet>(pc, rs)), rs);
+        }
+      }
+    }
+  }
+};
+
+template <typename Scalar, typename Index, int NCol>
+struct sme_neon_tile<Scalar, Index, 0, NCol> {
+  static EIGEN_ALWAYS_INLINE void run(Scalar* C, Index rs, Index cs, const Scalar* blA, const Scalar* blB, Index depth,
+                                      Scalar alpha, Index pw, Index cw) {
+    EIGEN_UNUSED_VARIABLE(rs);
+    constexpr int KU = (NCol >= 4) ? 1 : 4 / NCol;
+    Scalar acc[KU][NCol];
+    for (int u = 0; u < KU; ++u)
+      for (int c = 0; c < NCol; ++c) acc[u][c] = Scalar(0);
+    Index k = 0;
+    for (; k + KU <= depth; k += KU) {
+      for (int u = 0; u < KU; ++u) {
+        const Scalar a = blA[(k + u) * pw];
+        const Scalar* b = blB + (k + u) * cw;
+        for (int c = 0; c < NCol; ++c) acc[u][c] += a * b[c];
+      }
+    }
+    for (; k < depth; ++k) {
+      const Scalar a = blA[k * pw];
+      const Scalar* b = blB + k * cw;
+      for (int c = 0; c < NCol; ++c) acc[0][c] += a * b[c];
+    }
+    for (int u = 1; u < KU; ++u)
+      for (int c = 0; c < NCol; ++c) acc[0][c] += acc[u][c];
+    for (int c = 0; c < NCol; ++c) C[Index(c) * cs] += alpha * acc[0][c];
+  }
+};
+
+// Complex counterpart over the real view of the panels. Conjugation is folded
+// into the signs of the four real products.
+template <typename RealScalar, typename Index, bool ConjLhs, bool ConjRhs, int NPack, int NCol>
+struct sme_neon_ctile {
+  using Scalar = std::complex<RealScalar>;
+  using Packet = typename packet_traits<RealScalar>::type;
+  using Cols = sme_neon_cols<RealScalar, NCol>;
+  static constexpr int PS = packet_traits<RealScalar>::size;
+  static EIGEN_ALWAYS_INLINE void run(Scalar* C, Index rs, Index cs, const RealScalar* rA, const RealScalar* rB,
+                                      Index depth, Scalar alpha, Index pw, Index cw) {
+    Packet acc_re[NPack][NCol], acc_im[NPack][NCol];
+    for (int p = 0; p < NPack; ++p) {
+      for (int c = 0; c < NCol; ++c) {
+        acc_re[p][c] = pset1<Packet>(RealScalar(0));
+        acc_im[p][c] = pset1<Packet>(RealScalar(0));
+      }
+    }
+    for (Index k = 0; k < depth; ++k) {
+      const RealScalar* a = rA + k * 2 * pw;
+      const RealScalar* b = rB + k * 2 * cw;
+      Packet are[NPack], aim[NPack];
+      for (int p = 0; p < NPack; ++p) {
+        are[p] = ploadu<Packet>(a + p * PS);
+        aim[p] = ploadu<Packet>(a + pw + p * PS);
+      }
+      sme_neon_col_loop<0, NCol>::template cplx<ConjLhs, ConjRhs, Cols, Packet, NPack>(
+          acc_re, acc_im, are, aim, Cols::load(b), Cols::load(b + cw));
+    }
+    const RealScalar ar = numext::real(alpha), ai = numext::imag(alpha);
+    const Packet valpha_re = pset1<Packet>(ar), valpha_im = pset1<Packet>(ai);
+    for (int c = 0; c < NCol; ++c) {
+      for (int p = 0; p < NPack; ++p) {
+        RealScalar* pc = reinterpret_cast<RealScalar*>(C + Index(p * PS) * rs + Index(c) * cs);
+        if (rs == 1) {
+          // Unit row stride: the column is PS interleaved (re, im) pairs.
+          Packet cre, cim;
+          sme_neon_ld2(pc, cre, cim);
+          cre = pnmadd(valpha_im, acc_im[p][c], pmadd(valpha_re, acc_re[p][c], cre));
+          cim = pmadd(valpha_im, acc_re[p][c], pmadd(valpha_re, acc_im[p][c], cim));
+          sme_neon_st2(pc, cre, cim);
+        } else {
+          RealScalar re[PS], im[PS];
+          pstoreu(re, acc_re[p][c]);
+          pstoreu(im, acc_im[p][c]);
+          for (int l = 0; l < PS; ++l) {
+            RealScalar* pl = pc + Index(l) * 2 * rs;
+            pl[0] += ar * re[l] - ai * im[l];
+            pl[1] += ar * im[l] + ai * re[l];
+          }
+        }
+      }
+    }
+  }
+};
+
+template <typename RealScalar, typename Index, bool ConjLhs, bool ConjRhs, int NCol>
+struct sme_neon_ctile<RealScalar, Index, ConjLhs, ConjRhs, 0, NCol> {
+  using Scalar = std::complex<RealScalar>;
+  static EIGEN_ALWAYS_INLINE void run(Scalar* C, Index rs, Index cs, const RealScalar* rA, const RealScalar* rB,
+                                      Index depth, Scalar alpha, Index pw, Index cw) {
+    EIGEN_UNUSED_VARIABLE(rs);
+    constexpr int KU = (NCol >= 4) ? 1 : 4 / NCol;
+    RealScalar acc_re[KU][NCol], acc_im[KU][NCol];
+    for (int u = 0; u < KU; ++u)
+      for (int c = 0; c < NCol; ++c) acc_re[u][c] = acc_im[u][c] = RealScalar(0);
+    for (Index k = 0; k < depth; ++k) {
+      const int u = int(k % KU);
+      const RealScalar* a = rA + k * 2 * pw;
+      const RealScalar* b = rB + k * 2 * cw;
+      const RealScalar are = a[0], aim = ConjLhs ? -a[pw] : a[pw];
+      for (int c = 0; c < NCol; ++c) {
+        const RealScalar bre = b[c], bim = ConjRhs ? -b[cw + c] : b[cw + c];
+        acc_re[u][c] += are * bre - aim * bim;
+        acc_im[u][c] += are * bim + aim * bre;
+      }
+    }
+    for (int u = 1; u < KU; ++u)
+      for (int c = 0; c < NCol; ++c) {
+        acc_re[0][c] += acc_re[u][c];
+        acc_im[0][c] += acc_im[u][c];
+      }
+    const RealScalar ar = numext::real(alpha), ai = numext::imag(alpha);
+    for (int c = 0; c < NCol; ++c) {
+      RealScalar* pc = reinterpret_cast<RealScalar*>(C + Index(c) * cs);
+      pc[0] += ar * acc_re[0][c] - ai * acc_im[0][c];
+      pc[1] += ar * acc_im[0][c] + ai * acc_re[0][c];
+    }
+  }
+};
+
+// Row loop of one column group: 3, 2 and 1 packets of rows, then scalar rows.
+template <bool ConjLhs, bool ConjRhs, int NCol, typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_neon_column_group(Scalar* C, Index rs, Index cs, const Scalar* blA, const Scalar* blB,
+                                               Index depth, Scalar alpha, Index pw, Index cw) {
+  constexpr Index PS = Index(packet_traits<Scalar>::size);
+  Index r = 0;
+  for (; r + 3 * PS <= pw; r += 3 * PS)
+    sme_neon_tile<Scalar, Index, 3, NCol>::run(C + r * rs, rs, cs, blA + r, blB, depth, alpha, pw, cw);
+  for (; r + 2 * PS <= pw; r += 2 * PS)
+    sme_neon_tile<Scalar, Index, 2, NCol>::run(C + r * rs, rs, cs, blA + r, blB, depth, alpha, pw, cw);
+  for (; r + PS <= pw; r += PS)
+    sme_neon_tile<Scalar, Index, 1, NCol>::run(C + r * rs, rs, cs, blA + r, blB, depth, alpha, pw, cw);
+  for (; r < pw; ++r)
+    sme_neon_tile<Scalar, Index, 0, NCol>::run(C + r * rs, rs, cs, blA + r, blB, depth, alpha, pw, cw);
+}
+
+template <bool ConjLhs, bool ConjRhs, int NCol, typename RealScalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_neon_column_group(std::complex<RealScalar>* C, Index rs, Index cs, const RealScalar* rA,
+                                               const RealScalar* rB, Index depth, std::complex<RealScalar> alpha,
+                                               Index pw, Index cw) {
+  // Two accumulators per packet, so the ladder stops at two packets of rows.
+  constexpr Index PS = Index(packet_traits<RealScalar>::size);
+  Index r = 0;
+  for (; r + 2 * PS <= pw; r += 2 * PS)
+    sme_neon_ctile<RealScalar, Index, ConjLhs, ConjRhs, 2, NCol>::run(C + r * rs, rs, cs, rA + r, rB, depth, alpha, pw,
+                                                                      cw);
+  for (; r + PS <= pw; r += PS)
+    sme_neon_ctile<RealScalar, Index, ConjLhs, ConjRhs, 1, NCol>::run(C + r * rs, rs, cs, rA + r, rB, depth, alpha, pw,
+                                                                      cw);
+  for (; r < pw; ++r)
+    sme_neon_ctile<RealScalar, Index, ConjLhs, ConjRhs, 0, NCol>::run(C + r * rs, rs, cs, rA + r, rB, depth, alpha, pw,
+                                                                      cw);
+}
+
+// One pw x cw block: columns in groups of eight, four, two, then single columns.
+template <bool ConjLhs, bool ConjRhs, typename Scalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_neon_block(Scalar* C, Index rs, Index cs, const Scalar* blA, const Scalar* blB,
+                                        Index depth, Scalar alpha, Index pw, Index cw) {
+  Index c = 0;
+  for (; c + 8 <= cw; c += 8)
+    sme_neon_column_group<ConjLhs, ConjRhs, 8>(C + c * cs, rs, cs, blA, blB + c, depth, alpha, pw, cw);
+  for (; c + 4 <= cw; c += 4)
+    sme_neon_column_group<ConjLhs, ConjRhs, 4>(C + c * cs, rs, cs, blA, blB + c, depth, alpha, pw, cw);
+  for (; c + 2 <= cw; c += 2)
+    sme_neon_column_group<ConjLhs, ConjRhs, 2>(C + c * cs, rs, cs, blA, blB + c, depth, alpha, pw, cw);
+  for (; c < cw; ++c)
+    sme_neon_column_group<ConjLhs, ConjRhs, 1>(C + c * cs, rs, cs, blA, blB + c, depth, alpha, pw, cw);
+}
+
+template <bool ConjLhs, bool ConjRhs, typename RealScalar, typename Index>
+EIGEN_ALWAYS_INLINE void sme_neon_block(std::complex<RealScalar>* C, Index rs, Index cs,
+                                        const std::complex<RealScalar>* blA, const std::complex<RealScalar>* blB,
+                                        Index depth, std::complex<RealScalar> alpha, Index pw, Index cw) {
+  const RealScalar* rA = reinterpret_cast<const RealScalar*>(blA);
+  const RealScalar* rB = reinterpret_cast<const RealScalar*>(blB);
+  Index c = 0;
+  for (; c + 4 <= cw; c += 4)
+    sme_neon_column_group<ConjLhs, ConjRhs, 4>(C + c * cs, rs, cs, rA, rB + c, depth, alpha, pw, cw);
+  for (; c + 2 <= cw; c += 2)
+    sme_neon_column_group<ConjLhs, ConjRhs, 2>(C + c * cs, rs, cs, rA, rB + c, depth, alpha, pw, cw);
+  for (; c < cw; ++c) sme_neon_column_group<ConjLhs, ConjRhs, 1>(C + c * cs, rs, cs, rA, rB + c, depth, alpha, pw, cw);
+}
+
+// Same panel walk as sme_gebp_impl, outside any streaming region.
+template <typename Scalar, bool ConjLhs, bool ConjRhs, typename Index>
+EIGEN_ALWAYS_INLINE void sme_gebp_neon(Scalar* C, Index C_stride_row, Index C_stride_col, const Scalar* blockA,
+                                       const Scalar* blockB, Index rows, Index depth, Index cols, Scalar alpha,
+                                       Index strideA, Index strideB, Index offsetA, Index offsetB) {
+  constexpr Index MR = Index(sme_block<Scalar>::mr);
+  constexpr Index NR = Index(sme_block<Scalar>::nr);
+  for (Index j = 0; j < cols; j += NR) {
+    const Index cw = numext::mini(cols - j, NR);
+    const Scalar* blB = blockB + j * strideB + offsetB * cw;
+    for (Index i = 0; i < rows; i += MR) {
+      const Index pw = numext::mini(rows - i, MR);
+      const Scalar* blA = blockA + i * strideA + offsetA * pw;
+      sme_neon_block<ConjLhs, ConjRhs>(C + i * C_stride_row + j * C_stride_col, C_stride_row, C_stride_col, blA, blB,
+                                       depth, alpha, pw, cw);
+    }
+  }
+}
+
+template <typename Scalar, typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs>
+struct sme_gebp_kernel {
+  using ResScalar = Scalar;
+
+  EIGEN_DONT_INLINE void operator()(const DataMapper& res, const Scalar* blockA, const Scalar* blockB, Index rows,
+                                    Index depth, Index cols, ResScalar alpha, Index strideA = -1, Index strideB = -1,
+                                    Index offsetA = 0, Index offsetB = 0) {
+    // Real scalars never reach the kernel conjugated (conj_helper folds it into
+    // the identity long before), so the real path stays free of the flags.
+    static_assert(NumTraits<Scalar>::IsComplex || (!ConjugateLhs && !ConjugateRhs),
+                  "the SME kernel does not support conjugation of real scalars");
+    static_assert(mr == sme_block<Scalar>::mr && nr == sme_block<Scalar>::nr,
+                  "the SME kernel expects packed panels of the SME block width");
+
+    if (strideA == -1) strideA = depth;
+    if (strideB == -1) strideB = depth;
+
+    if (rows <= 0 || cols <= 0 || depth <= 0) return;
+
+    Scalar* C_base = const_cast<Scalar*>(&res(0, 0));
+    const Index C_stride_row = &res(1, 0) - &res(0, 0);
+    const Index C_stride_col = &res(0, 1) - &res(0, 0);
+
+    if (sme_kernel_with_neon<Scalar>(rows, cols, depth, strideA, strideB)) {
+      sme_gebp_neon<Scalar, ConjugateLhs, ConjugateRhs>(C_base, C_stride_row, C_stride_col, blockA, blockB, rows, depth,
+                                                        cols, alpha, strideA, strideB, offsetA, offsetB);
+      return;
+    }
+
+    sme_gebp_impl<Scalar, ConjugateLhs, ConjugateRhs>(C_base, C_stride_row, C_stride_col, blockA, blockB, rows, depth,
+                                                      cols, alpha, strideA, strideB, offsetA, offsetB);
+  }
+};
+
+#define EIGEN_SME_DECLARE_GEBP_KERNEL(SCALAR)                                                          \
+  template <typename Index, typename DataMapper, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs> \
+  struct gebp_kernel<SCALAR, SCALAR, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs>            \
+      : sme_gebp_kernel<SCALAR, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs> {};
+
+EIGEN_SME_DECLARE_GEBP_KERNEL(float)
+EIGEN_SME_DECLARE_GEBP_KERNEL(std::complex<float>)
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+EIGEN_SME_DECLARE_GEBP_KERNEL(double)
+EIGEN_SME_DECLARE_GEBP_KERNEL(std::complex<double>)
+#endif
+
+#undef EIGEN_SME_DECLARE_GEBP_KERNEL
+
+// sme_has_gebp_kernel (products/GeneralBlockPanelKernel.h) drives the cache
+// blocking and the GEMM loop order, and is declared before this header. A pair
+// listed there but not specialized here would be packed and blocked for SME and
+// then handed to the generic kernel.
+static_assert(sme_has_gebp_kernel<float, float>::value, "the SME float kernel is not advertised to the GEMM driver");
+static_assert(sme_has_gebp_kernel<std::complex<float>, std::complex<float>>::value,
+              "the SME complex<float> kernel is not advertised to the GEMM driver");
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+static_assert(sme_has_gebp_kernel<double, double>::value, "the SME double kernel is not advertised to the GEMM driver");
+static_assert(sme_has_gebp_kernel<std::complex<double>, std::complex<double>>::value,
+              "the SME complex<double> kernel is not advertised to the GEMM driver");
+#else
+static_assert(!sme_has_gebp_kernel<double, double>::value,
+              "double is advertised to the GEMM driver without FEAT_SME_F64F64 to implement it");
+static_assert(!sme_has_gebp_kernel<std::complex<double>, std::complex<double>>::value,
+              "complex<double> is advertised to the GEMM driver without FEAT_SME_F64F64 to implement it");
+#endif
+
+// ---------------------------------------------------------------------------
+// Selfadjoint (SYMM) packers.
+//
+// product_selfadjoint_matrix packs the selfadjoint operand (stored as one
+// triangle) through symm_pack_lhs/symm_pack_rhs, which materialize the full
+// matrix as they pack. The generic SYMM packers emit packet-width sub-panels
+// for the generic gebp_kernel, whereas the SME kernel expects uniform
+// mr/nr-wide depth-major panels. These packers perform the same
+// triangle mirroring in the SME layout.
+//
+// The packer receives the operand in an orientation where row >= col is the
+// stored triangle. It reads that half directly and mirrors the other half:
+//   full(row,col) = (row >= col) ? m(row,col) : conj(m(col,row))
+// and a selfadjoint view defines the diagonal's imaginary part as zero, so
+// full(k,k) is real(m(k,k)). Both reduce to the identity on real scalars.
+//
+// Regions wholly below or above the diagonal use the normal dense copy or
+// transpose packers. Only the width-wide part of a panel crossed by the
+// diagonal needs special handling: each depth row is split between the stored
+// triangle and its mirrored half.
+//
+// For a panel at offset j (entries j+c, c in [0,w)) and global row k2+k, the
+// three depth regions are:
+//   transposed k in [0, j-k2)      : k2+k < j+c for all c -> m(j+c, k2+k)
+//   straddle   k in [j-k2, j+w-k2) : diagonal crosses      -> per-k split
+//   direct     k in [j+w-k2, depth): k2+k > j+c for all c  -> m(k2+k, j+c)
+//
+// The RHS packs full(k2+k, j+c) and uses this mapping directly, so its mirrored
+// half is the transposed region. The LHS packs full(j+r, k), which is the
+// conjugate of full(k, j+r), so it reuses the same mapping with k2 == 0
+// relative to its diagonal-anchored base pointer but conjugates the opposite
+// regions -- the direct one and the straddle band's head. IsLhs selects which.
+// ---------------------------------------------------------------------------
+
+// Streaming packer shared by the LHS (k2 == 0) and RHS symm specializations.
+// ColM selects the ColMajor selfadjoint operand.
+// Depth-region boundaries for the panel at outer offset `j`, all clamped to
+// [0, depth]: the diagonal splits it into a transposed head [0, t_end), a
+// straddle band [t_end, s_end) and a direct tail [s_end, depth).
+template <typename Index>
+static EIGEN_ALWAYS_INLINE void sme_symm_panel_regions(Index j, int w, Index depth, Index k2, Index& t_end,
+                                                       Index& s_end) __arm_streaming_compatible {
+  const Index raw_t = j - k2, raw_s = j + Index(w) - k2;
+  t_end = raw_t <= 0 ? Index(0) : sme_min(raw_t, depth);
+  s_end = raw_s <= 0 ? Index(0) : sme_min(raw_s, depth);
+}
+
+// The two dense regions of every panel, which are ordinary copies or ZA
+// transposes of the stored triangle. ColM selects the ColMajor operand.
+template <typename Scalar, int StorageOrder, bool IsLhs, typename Index>
+EIGEN_DONT_INLINE __arm_locally_streaming __arm_new("za") void sme_symm_pack_dense_regions(
+    Scalar* block, const Scalar* EIGEN_RESTRICT base, Index stride, Index depth, Index outer, Index k2) {
+  constexpr int PACK = IsLhs ? sme_block<Scalar>::mr : sme_block<Scalar>::nr;
+  constexpr bool ColM = (StorageOrder == ColMajor);
+  // The transposed region is the RHS's mirrored half and the direct one the
+  // LHS's, so exactly one of the two is conjugated (see above).
+  constexpr bool ConjTransposed = !IsLhs;
+  constexpr bool ConjDirect = IsLhs;
+
+  for (Index j = 0; j < outer; j += PACK) {
+    const int w = static_cast<int>(sme_min(outer - j, Index(PACK)));
+    Scalar* dst = block + j * depth;  // depth-major panel of width w
+    Index t_end, s_end;
+    sme_symm_panel_regions(j, w, depth, k2, t_end, s_end);
+
+    // Transposed region: full(k2+k, j+c) = m(j+c, k2+k).
+    if (t_end > 0) {
+      EIGEN_IF_CONSTEXPR (ColM) {
+        sve_copy_panel_range<ConjTransposed>(dst, base + j + k2 * stride, stride, Index(0), t_end, w);
+      } else {
+        sme_transpose_pack_range<ConjTransposed>(dst, base + j * stride + k2, stride, Index(0), t_end, w);
+      }
+    }
+    // Direct region: full(k2+k, j+c) = m(k2+k, j+c).
+    if (s_end < depth) {
+      EIGEN_IF_CONSTEXPR (ColM) {
+        sme_transpose_pack_range<ConjDirect>(dst, base + k2 + j * stride, stride, s_end, depth, w);
+      } else {
+        sve_copy_panel_range<ConjDirect>(dst, base + k2 * stride + j, stride, s_end, depth, w);
+      }
+    }
+  }
+}
+
+// The diagonal band of every panel: the diagonal crosses at c* = (k2+k) - j
+// (in [0, w) throughout the band), so each depth step splits into a direct head
+// (c < c*: m(k2+k, j+c)) and a mirrored tail (c >= c*: m(j+c, k2+k); at c == c*
+// both name the diagonal element).
+//
+// Kept out of the streaming region above for the reason tail_transpose_pack gives,
+// at the cost of a second pass over the panels: it is scalar floating-point,
+// and fusing it made the float SYMM packers 2-11x slower.
+template <typename Scalar, int StorageOrder, bool IsLhs, typename Index>
+EIGEN_DONT_INLINE void sme_symm_pack_straddle(Scalar* block, const Scalar* EIGEN_RESTRICT base, Index stride,
+                                              Index depth, Index outer, Index k2) {
+  constexpr int PACK = IsLhs ? sme_block<Scalar>::mr : sme_block<Scalar>::nr;
+  constexpr bool ColM = (StorageOrder == ColMajor);
+  // The band's tail is the RHS's mirrored half and its head the LHS's, exactly
+  // as the dense regions above.
+  constexpr bool ConjHead = IsLhs;
+  constexpr bool ConjTail = !IsLhs;
+
+  for (Index j = 0; j < outer; j += PACK) {
+    const int w = static_cast<int>(numext::mini(outer - j, Index(PACK)));
+    Scalar* dst = block + j * depth;
+    Index t_end, s_end;
+    sme_symm_panel_regions(j, w, depth, k2, t_end, s_end);
+
+    for (Index k = t_end; k < s_end; ++k) {
+      const Index row = k2 + k;
+      const int cs = static_cast<int>(row - j);
+      Scalar* dst_row = dst + k * w;
+      const Index wi = Index(w);
+      EIGEN_IF_CONSTEXPR (ColM) {
+        const Scalar* head = base + row + j * stride;  // m(row, j+c): stride-strided
+        for (int c = 0; c < cs; ++c, head += stride) sme_pack_store<ConjHead>(dst_row, wi, Index(c), *head);
+        const Scalar* tail = base + j + row * stride;  // m(j+c, row): contiguous
+        int c = cs;
+        // A selfadjoint view defines the diagonal's imaginary part as zero;
+        // for a real scalar that is already true, so the peel folds away.
+        EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+          sme_pack_store<false>(dst_row, wi, Index(cs), Scalar(numext::real(tail[cs])));
+          ++c;
+        }
+        for (; c < w; ++c) sme_pack_store<ConjTail>(dst_row, wi, Index(c), tail[c]);
+      } else {
+        const Scalar* head = base + row * stride + j;  // m(row, j+c): contiguous
+        for (int c = 0; c < cs; ++c) sme_pack_store<ConjHead>(dst_row, wi, Index(c), head[c]);
+        const Scalar* tail = base + (j + Index(cs)) * stride + row;  // m(j+c, row): stride-strided
+        int c = cs;
+        EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+          sme_pack_store<false>(dst_row, wi, Index(cs), Scalar(numext::real(*tail)));
+          tail += stride;
+          ++c;
+        }
+        for (; c < w; ++c, tail += stride) sme_pack_store<ConjTail>(dst_row, wi, Index(c), *tail);
+      }
+    }
+  }
+}
+
+// Packer shared by the LHS (k2 == 0) and RHS symm specializations.
+template <typename Scalar, int StorageOrder, bool IsLhs, typename Index>
+EIGEN_DONT_INLINE void sme_symm_pack_panels(Scalar* block, const Scalar* EIGEN_RESTRICT base, Index stride, Index depth,
+                                            Index outer, Index k2) {
+  sme_symm_pack_dense_regions<Scalar, StorageOrder, IsLhs, Index>(block, base, stride, depth, outer, k2);
+  sme_symm_pack_straddle<Scalar, StorageOrder, IsLhs, Index>(block, base, stride, depth, outer, k2);
+}
+
+// symm_pack_lhs/rhs SME specializations: emit the uniform mr/nr panels
+// sme_gebp_impl reads. Pack1/nr pinned exactly as gemm_pack_lhs/rhs above.
+template <typename Scalar, int StorageOrder, typename Index>
+struct sme_symm_pack_lhs {
+  // Note: generic symm_pack_lhs's "cols" is the depth extent, and the LHS
+  // block is diagonal-anchored (base = &lhs(k2,k2)), so its depth offset is 0.
+  EIGEN_DONT_INLINE void operator()(Scalar* blockA, const Scalar* lhs_, Index lhsStride, Index cols, Index rows) const {
+    sme_symm_pack_panels<Scalar, StorageOrder, true, Index>(blockA, lhs_, lhsStride, cols, rows, Index(0));
+  }
+};
+
+template <typename Scalar, int StorageOrder, typename Index>
+struct sme_symm_pack_rhs {
+  // Note: generic symm_pack_rhs's "rows" is the depth extent (end_k = k2 + rows), not a row count.
+  EIGEN_DONT_INLINE void operator()(Scalar* blockB, const Scalar* rhs_, Index rhsStride, Index rows, Index cols,
+                                    Index k2) const {
+    sme_symm_pack_panels<Scalar, StorageOrder, false, Index>(blockB, rhs_, rhsStride, rows, cols, k2);
+  }
+};
+
+#define EIGEN_SME_DECLARE_SYMM_PACKERS(SCALAR, MR, NR)               \
+  template <typename Index, int Pack2_dummy, int StorageOrder>       \
+  struct symm_pack_lhs<SCALAR, Index, MR, Pack2_dummy, StorageOrder> \
+      : sme_symm_pack_lhs<SCALAR, StorageOrder, Index> {};           \
+                                                                     \
+  template <typename Index, int StorageOrder>                        \
+  struct symm_pack_rhs<SCALAR, Index, NR, StorageOrder> : sme_symm_pack_rhs<SCALAR, StorageOrder, Index> {};
+
+EIGEN_SME_DECLARE_SYMM_PACKERS(float, kSmeMr, kSmeNr)
+EIGEN_SME_DECLARE_SYMM_PACKERS(std::complex<float>, kSmeMrC, kSmeNrC)
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+EIGEN_SME_DECLARE_SYMM_PACKERS(double, kSmeMrD, kSmeNrD)
+EIGEN_SME_DECLARE_SYMM_PACKERS(std::complex<double>, kSmeMrCD, kSmeNrCD)
+#endif
+
+#undef EIGEN_SME_DECLARE_SYMM_PACKERS
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_SME_GENERALBLOCKPANELKERNEL_H
diff --git a/Eigen/src/Core/arch/SSE/Complex.h b/Eigen/src/Core/arch/SSE/Complex.h
index d04b898..c00d356 100644
--- a/Eigen/src/Core/arch/SSE/Complex.h
+++ b/Eigen/src/Core/arch/SSE/Complex.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_SSE_H
 #define EIGEN_COMPLEX_SSE_H
@@ -17,6 +18,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 //---------- float ----------
 struct Packet2cf {
   EIGEN_STRONG_INLINE Packet2cf() {}
@@ -29,8 +32,8 @@
 #ifndef EIGEN_VECTORIZE_AVX
 template <>
 struct packet_traits<std::complex<float> > : default_packet_traits {
-  typedef Packet2cf type;
-  typedef Packet2cf half;
+  using type = Packet2cf;
+  using half = Packet2cf;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -55,9 +58,9 @@
 
 template <>
 struct unpacket_traits<Packet2cf> {
-  typedef std::complex<float> type;
-  typedef Packet2cf half;
-  typedef Packet4f as_real;
+  using type = std::complex<float>;
+  using half = Packet2cf;
+  using as_real = Packet4f;
   enum {
     size = 2,
     alignment = Aligned16,
@@ -102,7 +105,7 @@
 #ifdef EIGEN_VECTORIZE_SSE3
   __m128 result = _mm_addsub_ps(_mm_mul_ps(tmp2, b.v), tmp1);
 #else
-  const __m128 mask = _mm_setr_ps(-0.0f, 0.0f, -0.0f, 0.0f);
+  const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000, 0x00000000, 0x80000000, 0x00000000));
   __m128 result = _mm_add_ps(_mm_mul_ps(tmp2, b.v), _mm_xor_ps(tmp1, mask));
 #endif
 #endif
@@ -226,8 +229,8 @@
 #ifndef EIGEN_VECTORIZE_AVX
 template <>
 struct packet_traits<std::complex<double> > : default_packet_traits {
-  typedef Packet1cd type;
-  typedef Packet1cd half;
+  using type = Packet1cd;
+  using half = Packet1cd;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 0,
@@ -252,9 +255,9 @@
 
 template <>
 struct unpacket_traits<Packet1cd> {
-  typedef std::complex<double> type;
-  typedef Packet1cd half;
-  typedef Packet2d as_real;
+  using type = std::complex<double>;
+  using half = Packet1cd;
+  using as_real = Packet2d;
   enum {
     size = 1,
     alignment = Aligned16,
@@ -296,7 +299,7 @@
 #ifdef EIGEN_VECTORIZE_SSE3
   __m128d result = _mm_addsub_pd(_mm_mul_pd(tmp2, b.v), tmp1);
 #else
-  const __m128d mask = _mm_setr_pd(-0.0, 0.0);
+  const __m128d mask = _mm_castsi128_pd(_mm_set_epi64x(0x0, 0x8000000000000000ull));
   __m128d result = _mm_add_pd(_mm_mul_pd(tmp2, b.v), _mm_xor_pd(tmp1, mask));
 #endif
 #endif
@@ -324,7 +327,6 @@
   return Packet1cd(_mm_andnot_pd(b.v, a.v));
 }
 
-// FIXME force unaligned load, this is a temporary fix
 template <>
 EIGEN_STRONG_INLINE Packet1cd pload<Packet1cd>(const std::complex<double>* from) {
   EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(_mm_load_pd((const double*)from));
@@ -340,12 +342,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
-  return pset1<Packet1cd>(*from);
-}
-
-// FIXME force unaligned store, this is a temporary fix
-template <>
 EIGEN_STRONG_INLINE void pstore<std::complex<double> >(std::complex<double>* to, const Packet1cd& from) {
   EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd((double*)to, from.v);
 }
@@ -366,21 +362,6 @@
   return std::complex<double>(res[0], res[1]);
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
-  return a;
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-
 EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
 
 template <>
@@ -468,6 +449,8 @@
   return pnegate(pmadd(a, b, c));
 }
 #endif
+
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
 }  // end namespace internal
 }  // end namespace Eigen
 
diff --git a/Eigen/src/Core/arch/SSE/MathFunctions.h b/Eigen/src/Core/arch/SSE/MathFunctions.h
index 30c1f07..ef37710 100644
--- a/Eigen/src/Core/arch/SSE/MathFunctions.h
+++ b/Eigen/src/Core/arch/SSE/MathFunctions.h
@@ -7,8 +7,9 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-/* The sin and cos and functions of this file come from
+/* The sin and cos functions of this file come from
  * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
  */
 
diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h
index e7039d4..ff3d13a 100644
--- a/Eigen/src/Core/arch/SSE/PacketMath.h
+++ b/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_SSE_H
 #define EIGEN_PACKET_MATH_SSE_H
@@ -42,49 +43,35 @@
 // One solution is to increase ABI version using -fabi-version=4 (or greater).
 // Otherwise, we workaround this inconvenience by wrapping 128bit types into the following helper
 // structure:
-typedef eigen_packet_wrapper<__m128> Packet4f;
-typedef eigen_packet_wrapper<__m128d> Packet2d;
+using Packet4f = eigen_packet_wrapper<__m128>;
+using Packet2d = eigen_packet_wrapper<__m128d>;
 #else
-typedef __m128 Packet4f;
-typedef __m128d Packet2d;
+using Packet4f = __m128;
+using Packet2d = __m128d;
 #endif
 
-typedef eigen_packet_wrapper<__m128i, 0> Packet4i;
-typedef eigen_packet_wrapper<__m128i, 1> Packet16b;
-typedef eigen_packet_wrapper<__m128i, 4> Packet4ui;
-typedef eigen_packet_wrapper<__m128i, 5> Packet2l;
+using Packet4i = eigen_packet_wrapper<__m128i, 0>;
+using Packet16b = eigen_packet_wrapper<__m128i, 1>;
+using Packet4ui = eigen_packet_wrapper<__m128i, 4>;
+using Packet2l = eigen_packet_wrapper<__m128i, 5>;
 
 template <>
-struct is_arithmetic<__m128> {
-  enum { value = true };
-};
+struct is_arithmetic<__m128> : std::true_type {};
 template <>
-struct is_arithmetic<__m128i> {
-  enum { value = true };
-};
+struct is_arithmetic<__m128i> : std::true_type {};
 template <>
-struct is_arithmetic<__m128d> {
-  enum { value = true };
-};
+struct is_arithmetic<__m128d> : std::true_type {};
 template <>
-struct is_arithmetic<Packet4i> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet4i> : std::true_type {};
 template <>
-struct is_arithmetic<Packet2l> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet2l> : std::true_type {};
 // Note that `Packet4ui` uses the underlying type `__m128i`, which is
 // interpreted as a vector of _signed_ `int32`s, which breaks some arithmetic
 // operations used in `GenericPacketMath.h`.
 template <>
-struct is_arithmetic<Packet4ui> {
-  enum { value = false };
-};
+struct is_arithmetic<Packet4ui> : std::false_type {};
 template <>
-struct is_arithmetic<Packet16b> {
-  enum { value = true };
-};
+struct is_arithmetic<Packet16b> : std::true_type {};
 
 template <int p, int q, int r, int s>
 struct shuffle_mask {
@@ -173,8 +160,8 @@
 #ifndef EIGEN_VECTORIZE_AVX
 template <>
 struct packet_traits<float> : default_packet_traits {
-  typedef Packet4f type;
-  typedef Packet4f half;
+  using type = Packet4f;
+  using half = Packet4f;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -190,8 +177,13 @@
     HasASin = 1,
     HasATan = 1,
     HasATanh = 1,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasLog = 1,
     HasLog1p = 1,
+    HasLog10 = 1,
     HasExpm1 = 1,
     HasNdtri = 1,
     HasExp = 1,
@@ -208,8 +200,8 @@
 };
 template <>
 struct packet_traits<double> : default_packet_traits {
-  typedef Packet2d type;
-  typedef Packet2d half;
+  using type = Packet2d;
+  using half = Packet2d;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -220,10 +212,15 @@
     HasSin = EIGEN_FAST_MATH,
     HasCos = EIGEN_FAST_MATH,
     HasTan = EIGEN_FAST_MATH,
+    HasSinh = 1,
+    HasCosh = 1,
+    HasASinh = 1,
+    HasACosh = 1,
     HasTanh = EIGEN_FAST_MATH,
     HasErf = EIGEN_FAST_MATH,
     HasErfc = EIGEN_FAST_MATH,
     HasLog = 1,
+    HasLog10 = 1,
     HasExp = 1,
     HasLog1p = 1,
     HasExpm1 = 1,
@@ -237,8 +234,8 @@
 };
 template <>
 struct packet_traits<int> : default_packet_traits {
-  typedef Packet4i type;
-  typedef Packet4i half;
+  using type = Packet4i;
+  using half = Packet4i;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -251,8 +248,8 @@
 };
 template <>
 struct packet_traits<uint32_t> : default_packet_traits {
-  typedef Packet4ui type;
-  typedef Packet4ui half;
+  using type = Packet4ui;
+  using half = Packet4ui;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -265,8 +262,8 @@
 };
 template <>
 struct packet_traits<int64_t> : default_packet_traits {
-  typedef Packet2l type;
-  typedef Packet2l half;
+  using type = Packet2l;
+  using half = Packet2l;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -279,8 +276,8 @@
 #endif
 template <>
 struct packet_traits<bool> : default_packet_traits {
-  typedef Packet16b type;
-  typedef Packet16b half;
+  using type = Packet16b;
+  using half = Packet16b;
   enum {
     Vectorizable = 1,
     AlignedOnScalar = 1,
@@ -300,9 +297,9 @@
 
 template <>
 struct unpacket_traits<Packet4f> {
-  typedef float type;
-  typedef Packet4f half;
-  typedef Packet4i integer_packet;
+  using type = float;
+  using half = Packet4f;
+  using integer_packet = Packet4i;
   enum {
     size = 4,
     alignment = Aligned16,
@@ -313,9 +310,9 @@
 };
 template <>
 struct unpacket_traits<Packet2d> {
-  typedef double type;
-  typedef Packet2d half;
-  typedef Packet2l integer_packet;
+  using type = double;
+  using half = Packet2d;
+  using integer_packet = Packet2l;
   enum {
     size = 2,
     alignment = Aligned16,
@@ -326,8 +323,8 @@
 };
 template <>
 struct unpacket_traits<Packet2l> {
-  typedef int64_t type;
-  typedef Packet2l half;
+  using type = int64_t;
+  using half = Packet2l;
   enum {
     size = 2,
     alignment = Aligned16,
@@ -338,8 +335,8 @@
 };
 template <>
 struct unpacket_traits<Packet4i> {
-  typedef int type;
-  typedef Packet4i half;
+  using type = int;
+  using half = Packet4i;
   enum {
     size = 4,
     alignment = Aligned16,
@@ -350,8 +347,8 @@
 };
 template <>
 struct unpacket_traits<Packet4ui> {
-  typedef uint32_t type;
-  typedef Packet4ui half;
+  using type = uint32_t;
+  using half = Packet4ui;
   enum {
     size = 4,
     alignment = Aligned16,
@@ -362,8 +359,8 @@
 };
 template <>
 struct unpacket_traits<Packet16b> {
-  typedef bool type;
-  typedef Packet16b half;
+  using type = bool;
+  using half = Packet16b;
   enum {
     size = 16,
     alignment = Aligned16,
@@ -375,13 +372,9 @@
 
 #ifndef EIGEN_VECTORIZE_AVX
 template <>
-struct scalar_div_cost<float, true> {
-  enum { value = 7 };
-};
+struct scalar_div_cost<float, true> : std::integral_constant<int, 7> {};
 template <>
-struct scalar_div_cost<double, true> {
-  enum { value = 8 };
-};
+struct scalar_div_cost<double, true> : std::integral_constant<int, 8> {};
 #endif
 
 template <>
@@ -420,7 +413,9 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4f peven_mask(const Packet4f& /*a*/) {
-  return _mm_castsi128_ps(_mm_set_epi32(0, -1, 0, -1));
+  Packet4f r = _mm_castsi128_ps(_mm_set_epi32(0, -1, 0, -1));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 template <>
 EIGEN_STRONG_INLINE Packet2l peven_mask(const Packet2l& /*a*/) {
@@ -436,7 +431,9 @@
 }
 template <>
 EIGEN_STRONG_INLINE Packet2d peven_mask(const Packet2d& /*a*/) {
-  return _mm_castsi128_pd(_mm_set_epi32(0, 0, -1, -1));
+  Packet2d r = _mm_castsi128_pd(_mm_set_epi32(0, 0, -1, -1));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -461,7 +458,7 @@
 }
 
 // GCC generates a shufps instruction for _mm_set1_ps/_mm_load1_ps instead of the more efficient pshufd instruction.
-// However, using inrinsics for pset1 makes gcc to generate crappy code in some cases (see bug 203)
+// However, using intrinsics for pset1 makes gcc to generate crappy code in some cases (see bug 203)
 // Using inline assembly is also not an option because then gcc fails to reorder properly the instructions.
 // Therefore, we introduced the pload1 functions to be used in product kernels for which bug 203 does not apply.
 // Also note that with AVX, we want it to generate a vbroadcastss.
@@ -600,23 +597,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4f pconj(const Packet4f& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2l pconj(const Packet2l& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) {
   return _mm_mul_ps(a, b);
 }
@@ -778,12 +758,16 @@
 template <>
 EIGEN_STRONG_INLINE Packet4f ptrue<Packet4f>(const Packet4f& a) {
   Packet4i b = _mm_castps_si128(a);
-  return _mm_castsi128_ps(_mm_cmpeq_epi32(b, b));
+  Packet4f r = _mm_castsi128_ps(_mm_cmpeq_epi32(b, b));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 template <>
 EIGEN_STRONG_INLINE Packet2d ptrue<Packet2d>(const Packet2d& a) {
   Packet4i b = _mm_castpd_si128(a);
-  return _mm_castsi128_pd(_mm_cmpeq_epi32(b, b));
+  Packet2d r = _mm_castsi128_pd(_mm_cmpeq_epi32(b, b));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 template <>
@@ -945,7 +929,10 @@
 #else
   Packet4i eq = pcmp_eq<Packet4i>(Packet4i(a), Packet4i(b));
   Packet2l hi_eq = Packet2l(_mm_shuffle_epi32(eq, (shuffle_mask<1, 1, 3, 3>::mask)));
-  Packet4i lt = pcmp_lt<Packet4i>(Packet4i(a), Packet4i(b));
+  // The low halves carry magnitude only and must be ordered as unsigned, while the high halves carry
+  // the sign. Biasing just the low lanes by 2^31 makes one signed 32-bit compare serve both.
+  const Packet4i kLowSignFlip = _mm_setr_epi32(SIGN_MASK_I32, 0x0, SIGN_MASK_I32, 0x0);
+  Packet4i lt = pcmp_lt<Packet4i>(pxor(Packet4i(a), kLowSignFlip), pxor(Packet4i(b), kLowSignFlip));
   Packet2l hi_lt = Packet2l(_mm_shuffle_epi32(lt, (shuffle_mask<1, 1, 3, 3>::mask)));
   Packet2l lo_lt = Packet2l(_mm_shuffle_epi32(lt, (shuffle_mask<0, 0, 2, 2>::mask)));
   // return hi(a) < hi(b) || (hi(a) == hi(b) && lo(a) < lo(b))
@@ -1139,10 +1126,11 @@
 template <typename Packet, typename Op>
 EIGEN_STRONG_INLINE Packet pminmax_propagate_nan(const Packet& a, const Packet& b, Op op) {
   // In this implementation, we take advantage of the fact that pmin/pmax for SSE
-  // always return a if either a or b is NaN.
-  Packet not_nan_mask_a = pcmp_eq(a, a);
-  Packet m = op(b, a);
-  return pselect<Packet>(not_nan_mask_a, m, a);
+  // always return a if either a or b is NaN. Testing b rather than a is what supplies the
+  // missing case, and it keeps op's operand order, hence its choice on a signed-zero tie.
+  Packet not_nan_mask_b = pcmp_eq(b, b);
+  Packet m = op(a, b);
+  return pselect<Packet>(not_nan_mask_b, m, b);
 }
 
 // Add specializations for min/max with prescribed NaN propagation.
@@ -1197,10 +1185,6 @@
   return _mm_srai_epi32(a, 31);
 }
 template <>
-EIGEN_STRONG_INLINE Packet4ui psignbit(const Packet4ui& a) {
-  return pzero(a);
-}
-template <>
 EIGEN_STRONG_INLINE Packet2l psignbit(const Packet2l& a) {
   Packet4i tmp = psignbit<Packet4i>(Packet4i(a));
   return Packet2l(_mm_shuffle_epi32(tmp, (shuffle_mask<1, 1, 3, 3>::mask)));
@@ -1268,11 +1252,6 @@
   return _mm_sub_epi32(_mm_xor_si128(a, signbit), signbit);
 #endif
 }
-template <>
-EIGEN_STRONG_INLINE Packet4ui pabs(const Packet4ui& a) {
-  return a;
-}
-
 #ifdef EIGEN_VECTORIZE_SSE4_1
 template <>
 EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(const Packet4f& a) {
@@ -1351,21 +1330,11 @@
   EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const __m128i*>(from));
 }
 
-#if EIGEN_COMP_MSVC
 template <>
 EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) {
   EIGEN_DEBUG_UNALIGNED_LOAD
   return _mm_loadu_ps(from);
 }
-#else
-// NOTE: with the code below, MSVC's compiler crashes!
-
-template <>
-EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) {
-  EIGEN_DEBUG_UNALIGNED_LOAD
-  return _mm_loadu_ps(from);
-}
-#endif
 
 template <>
 EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from) {
@@ -1393,12 +1362,24 @@
   return _mm_loadu_si128(reinterpret_cast<const __m128i*>(from));
 }
 
+EIGEN_STRONG_INLINE __m128i ploadu_si64(const void* from) {
+#if EIGEN_GNUC_STRICT_LESS_THAN(9, 1, 0) || (EIGEN_COMP_MINGW && !EIGEN_COMP_CLANG && EIGEN_COMP_GNUC < 910)
+  // GCC added _mm_loadu_si64 in 9.1. Copy through __m64 to avoid relying on _mm_loadl_epi64's type-punned load.
+  EIGEN_USING_STD(memcpy);
+  __m64 lo;
+  memcpy(&lo, from, sizeof(lo));
+  return _mm_set_epi64((__m64)0LL, lo);
+#else
+  return _mm_loadu_si64(from);
+#endif
+}
+
 // Load lower part of packet zero extending.
 template <typename Packet>
 EIGEN_STRONG_INLINE Packet ploadl(const typename unpacket_traits<Packet>::type* from);
 template <>
 EIGEN_STRONG_INLINE Packet4f ploadl<Packet4f>(const float* from) {
-  EIGEN_DEBUG_UNALIGNED_LOAD return _mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from)));
+  EIGEN_DEBUG_UNALIGNED_LOAD return _mm_castsi128_ps(ploadu_si64(reinterpret_cast<const void*>(from)));
 }
 template <>
 EIGEN_STRONG_INLINE Packet2d ploadl<Packet2d>(const double* from) {
@@ -1419,15 +1400,7 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from) {
-  return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd(reinterpret_cast<const double*>(from))), 0, 0, 1, 1);
-}
-template <>
-EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) {
-  return pset1<Packet2d>(from[0]);
-}
-template <>
-EIGEN_STRONG_INLINE Packet2l ploaddup<Packet2l>(const int64_t* from) {
-  return pset1<Packet2l>(from[0]);
+  return vec4f_swizzle1(_mm_castsi128_ps(ploadu_si64(reinterpret_cast<const void*>(from))), 0, 0, 1, 1);
 }
 template <>
 EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int* from) {
@@ -1446,15 +1419,18 @@
 // {b0, b0, b1, b1, b2, b2, b3, b3, b4, b4, b5, b5, b6, b6, b7, b7}
 template <>
 EIGEN_STRONG_INLINE Packet16b ploaddup<Packet16b>(const bool* from) {
-  __m128i tmp = _mm_castpd_si128(pload1<Packet2d>(reinterpret_cast<const double*>(from)));
+  __m128i tmp = ploadu_si64(reinterpret_cast<const void*>(from));
   return _mm_unpacklo_epi8(tmp, tmp);
 }
 
 // Loads 4 bools from memory and returns the packet
-// {b0, b0  b0, b0, b1, b1, b1, b1, b2, b2, b2, b2, b3, b3, b3, b3}
+// {b0, b0, b0, b0, b1, b1, b1, b1, b2, b2, b2, b2, b3, b3, b3, b3}
 template <>
 EIGEN_STRONG_INLINE Packet16b ploadquad<Packet16b>(const bool* from) {
-  __m128i tmp = _mm_castps_si128(pload1<Packet4f>(reinterpret_cast<const float*>(from)));
+  EIGEN_USING_STD(memcpy);
+  int val;
+  memcpy(&val, from, sizeof(int));
+  __m128i tmp = _mm_cvtsi32_si128(val);
   tmp = _mm_unpacklo_epi8(tmp, tmp);
   return _mm_unpacklo_epi16(tmp, tmp);
 }
@@ -1563,60 +1539,6 @@
 #endif
 }
 
-#if EIGEN_COMP_MSVC_STRICT && EIGEN_OS_WIN64
-// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
-// Direct of the struct members fixed bug #62.
-template <>
-EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) {
-  return a.m128_f32[0];
-}
-template <>
-EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) {
-  return a.m128d_f64[0];
-}
-template <>
-EIGEN_STRONG_INLINE int64_t pfirst<Packet2l>(const Packet2l& a) {
-  int64_t x = _mm_extract_epi64_0(a);
-  return x;
-}
-template <>
-EIGEN_STRONG_INLINE int pfirst<Packet4i>(const Packet4i& a) {
-  int x = _mm_cvtsi128_si32(a);
-  return x;
-}
-template <>
-EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(const Packet4ui& a) {
-  uint32_t x = numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(a));
-  return x;
-}
-#elif EIGEN_COMP_MSVC_STRICT
-// The temporary variable fixes an internal compilation error in vs <= 2008 and a wrong-result bug in vs 2010
-template <>
-EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) {
-  float x = _mm_cvtss_f32(a);
-  return x;
-}
-template <>
-EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) {
-  double x = _mm_cvtsd_f64(a);
-  return x;
-}
-template <>
-EIGEN_STRONG_INLINE int64_t pfirst<Packet2l>(const Packet2l& a) {
-  int64_t x = _mm_extract_epi64_0(a);
-  return x;
-}
-template <>
-EIGEN_STRONG_INLINE int pfirst<Packet4i>(const Packet4i& a) {
-  int x = _mm_cvtsi128_si32(a);
-  return x;
-}
-template <>
-EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(const Packet4ui& a) {
-  uint32_t x = numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(a));
-  return x;
-}
-#else
 template <>
 EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) {
   return _mm_cvtss_f32(a);
@@ -1637,7 +1559,6 @@
 EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(const Packet4ui& a) {
   return numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(a));
 }
-#endif
 template <>
 EIGEN_STRONG_INLINE bool pfirst<Packet16b>(const Packet16b& a) {
   int x = _mm_cvtsi128_si32(a);
@@ -1646,6 +1567,10 @@
 
 template <>
 EIGEN_STRONG_INLINE Packet4f pgather<float, Packet4f>(const float* from, Index stride) {
+  if (stride == 2) {
+    // Overlap the loads so the second ends at the last gathered coefficient, from[6].
+    return _mm_shuffle_ps(_mm_loadu_ps(from), _mm_loadu_ps(from + 3), _MM_SHUFFLE(3, 1, 2, 0));
+  }
   return _mm_set_ps(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
 }
 template <>
@@ -1741,9 +1666,9 @@
 }
 
 #if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
-typedef const void* SsePrefetchPtrType;
+using SsePrefetchPtrType = const void*;
 #else
-typedef const char* SsePrefetchPtrType;
+using SsePrefetchPtrType = const char*;
 #endif
 
 #ifndef EIGEN_VECTORIZE_AVX
@@ -1803,15 +1728,13 @@
   // Convert e to integer and swizzle to low-order bits.
   const Packet4i ei = vec4i_swizzle1(_mm_cvtpd_epi32(e), 0, 3, 1, 3);
 
-  // Split 2^e into four factors and multiply:
+  // Preserve the sequential 4-way split; see pldexp_generic.
   const Packet4i bias = _mm_set_epi32(0, 1023, 0, 1023);
-  Packet4i b = parithmetic_shift_right<2>(ei);                       // floor(e/4)
-  Packet2d c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));  // 2^b
-  Packet2d out = pmul(pmul(pmul(a, c), c), c);                       // a * 2^(3b)
-  b = psub(psub(psub(ei, b), b), b);                                 // e - 3b
-  c = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));           // 2^(e - 3b)
-  out = pmul(out, c);                                                // a * 2^e
-  return out;
+  const Packet4i b = parithmetic_shift_right<2>(ei);                                  // floor(e/4)
+  const Packet4i b_remainder = psub(psub(ei, b), padd(b, b));                         // e - 3b (depth 2)
+  const Packet2d c1 = _mm_castsi128_pd(_mm_slli_epi64(padd(b, bias), 52));            // 2^b
+  const Packet2d c2 = _mm_castsi128_pd(_mm_slli_epi64(padd(b_remainder, bias), 52));  // 2^(e - 3b)
+  return pmul(pmul(pmul(pmul(a, c1), c1), c1), c2);                                   // a * 2^e
 }
 
 // We specialize pldexp here, since the generic implementation uses Packet2l, which is not well
@@ -2000,35 +1923,35 @@
 #if defined(EIGEN_VECTORIZE_FMA)
 template <>
 EIGEN_STRONG_INLINE float pmadd(const float& a, const float& b, const float& c) {
-  return std::fmaf(a, b, c);
+  return numext::fma(a, b, c);
 }
 template <>
 EIGEN_STRONG_INLINE double pmadd(const double& a, const double& b, const double& c) {
-  return std::fma(a, b, c);
+  return numext::fma(a, b, c);
 }
 template <>
 EIGEN_STRONG_INLINE float pmsub(const float& a, const float& b, const float& c) {
-  return std::fmaf(a, b, -c);
+  return numext::fma(a, b, -c);
 }
 template <>
 EIGEN_STRONG_INLINE double pmsub(const double& a, const double& b, const double& c) {
-  return std::fma(a, b, -c);
+  return numext::fma(a, b, -c);
 }
 template <>
 EIGEN_STRONG_INLINE float pnmadd(const float& a, const float& b, const float& c) {
-  return std::fmaf(-a, b, c);
+  return numext::fma(-a, b, c);
 }
 template <>
 EIGEN_STRONG_INLINE double pnmadd(const double& a, const double& b, const double& c) {
-  return std::fma(-a, b, c);
+  return numext::fma(-a, b, c);
 }
 template <>
 EIGEN_STRONG_INLINE float pnmsub(const float& a, const float& b, const float& c) {
-  return std::fmaf(-a, b, -c);
+  return numext::fma(-a, b, -c);
 }
 template <>
 EIGEN_STRONG_INLINE double pnmsub(const double& a, const double& b, const double& c) {
-  return std::fma(-a, b, -c);
+  return numext::fma(-a, b, -c);
 }
 #endif
 
diff --git a/Eigen/src/Core/arch/SSE/Reductions.h b/Eigen/src/Core/arch/SSE/Reductions.h
index f38df4e..e0126de 100644
--- a/Eigen/src/Core/arch/SSE/Reductions.h
+++ b/Eigen/src/Core/arch/SSE/Reductions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REDUCTIONS_SSE_H
 #define EIGEN_REDUCTIONS_SSE_H
@@ -17,73 +18,37 @@
 
 namespace internal {
 
-template <typename Packet>
-struct sse_add_wrapper {
-  static EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) { return padd<Packet>(a, b); }
-};
-
-template <typename Packet>
-struct sse_mul_wrapper {
-  static EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) { return pmul<Packet>(a, b); }
-};
-
-template <typename Packet>
-struct sse_min_wrapper {
-  static EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) { return pmin<Packet>(a, b); }
-};
-
-template <int NaNPropagation, typename Packet>
-struct sse_min_prop_wrapper {
-  static EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) {
-    return pmin<NaNPropagation, Packet>(a, b);
-  }
-};
-
-template <typename Packet>
-struct sse_max_wrapper {
-  static EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) { return pmax<Packet>(a, b); }
-};
-
-template <int NaNPropagation, typename Packet>
-struct sse_max_prop_wrapper {
-  static EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) {
-    return pmax<NaNPropagation, Packet>(a, b);
-  }
-};
-
-template <typename Packet, typename Op>
-struct sse_predux_common;
-
-template <typename Packet>
-struct sse_predux_impl : sse_predux_common<Packet, sse_add_wrapper<Packet>> {};
-
-template <typename Packet>
-struct sse_predux_mul_impl : sse_predux_common<Packet, sse_mul_wrapper<Packet>> {};
-
-template <typename Packet>
-struct sse_predux_min_impl : sse_predux_common<Packet, sse_min_wrapper<Packet>> {};
-
-template <int NaNPropagation, typename Packet>
-struct sse_predux_min_prop_impl : sse_predux_common<Packet, sse_min_prop_wrapper<NaNPropagation, Packet>> {};
-
-template <typename Packet>
-struct sse_predux_max_impl : sse_predux_common<Packet, sse_max_wrapper<Packet>> {};
-
-template <int NaNPropagation, typename Packet>
-struct sse_predux_max_prop_impl : sse_predux_common<Packet, sse_max_prop_wrapper<NaNPropagation, Packet>> {};
+// Lane 0 of the result is lane 1 of a; the other lanes are unspecified. That is all
+// the 4->2->1 reductions below need from it, so take whichever single instruction the
+// target offers.
+EIGEN_STRONG_INLINE Packet4f sse_lane1(const Packet4f& a) {
+#ifdef EIGEN_VECTORIZE_SSE3
+  return _mm_movehdup_ps(a);
+#else
+  return _mm_shuffle_ps(a, a, 1);
+#endif
+}
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet16b -- -- -- -- -- -- -- -- -- -- -- -- */
 
+// Packet16b stores one bool per byte. Reduce the byte-wise zero mask rather than extracting and short-circuiting two
+// scalar halves. This also treats every nonzero byte as true, matching the scalar reduction for non-canonical inputs.
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet16b& a) {
+  const __m128i normalized = _mm_min_epu8(a, _mm_set1_epi8(1));
+  const __m128i sums = _mm_sad_epu8(normalized, _mm_setzero_si128());
+  return static_cast<Index>(_mm_cvtsi128_si32(sums)) +
+         static_cast<Index>(_mm_cvtsi128_si32(_mm_unpackhi_epi64(sums, sums)));
+}
+
 template <>
 EIGEN_STRONG_INLINE bool predux(const Packet16b& a) {
-  Packet4i tmp = _mm_or_si128(a, _mm_unpackhi_epi64(a, a));
-  return (pfirst(tmp) != 0) || (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) != 0);
+  return _mm_movemask_epi8(_mm_cmpeq_epi8(a, _mm_setzero_si128())) != 0xffff;
 }
 
 template <>
 EIGEN_STRONG_INLINE bool predux_mul(const Packet16b& a) {
-  Packet4i tmp = _mm_and_si128(a, _mm_unpackhi_epi64(a, a));
-  return ((pfirst<Packet4i>(tmp) == 0x01010101) && (pfirst<Packet4i>(_mm_shuffle_epi32(tmp, 1)) == 0x01010101));
+  return _mm_movemask_epi8(_mm_cmpeq_epi8(a, _mm_setzero_si128())) == 0;
 }
 
 template <>
@@ -103,35 +68,33 @@
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet4i -- -- -- -- -- -- -- -- -- -- -- -- */
 
-template <typename Op>
-struct sse_predux_common<Packet4i, Op> {
-  static EIGEN_STRONG_INLINE int run(const Packet4i& a) {
-    Packet4i tmp;
-    tmp = Op::packetOp(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
-    tmp = Op::packetOp(tmp, _mm_unpackhi_epi32(tmp, tmp));
-    return _mm_cvtsi128_si32(tmp);
-  }
-};
-
 template <>
 EIGEN_STRONG_INLINE int predux(const Packet4i& a) {
-  return sse_predux_impl<Packet4i>::run(a);
+  Packet4i tmp = _mm_add_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = _mm_add_epi32(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return _mm_cvtsi128_si32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE int predux_mul(const Packet4i& a) {
-  return sse_predux_mul_impl<Packet4i>::run(a);
+  Packet4i tmp = pmul<Packet4i>(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = pmul<Packet4i>(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return _mm_cvtsi128_si32(tmp);
 }
 
 #ifdef EIGEN_VECTORIZE_SSE4_1
 template <>
 EIGEN_STRONG_INLINE int predux_min(const Packet4i& a) {
-  return sse_predux_min_impl<Packet4i>::run(a);
+  Packet4i tmp = pmin<Packet4i>(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = pmin<Packet4i>(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return _mm_cvtsi128_si32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE int predux_max(const Packet4i& a) {
-  return sse_predux_max_impl<Packet4i>::run(a);
+  Packet4i tmp = pmax<Packet4i>(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = pmax<Packet4i>(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return _mm_cvtsi128_si32(tmp);
 }
 #endif
 
@@ -142,35 +105,33 @@
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet4ui -- -- -- -- -- -- -- -- -- -- -- -- */
 
-template <typename Op>
-struct sse_predux_common<Packet4ui, Op> {
-  static EIGEN_STRONG_INLINE uint32_t run(const Packet4ui& a) {
-    Packet4ui tmp;
-    tmp = Op::packetOp(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
-    tmp = Op::packetOp(tmp, _mm_unpackhi_epi32(tmp, tmp));
-    return static_cast<uint32_t>(_mm_cvtsi128_si32(tmp));
-  }
-};
-
 template <>
 EIGEN_STRONG_INLINE uint32_t predux(const Packet4ui& a) {
-  return sse_predux_impl<Packet4ui>::run(a);
+  Packet4ui tmp = _mm_add_epi32(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = _mm_add_epi32(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return static_cast<uint32_t>(_mm_cvtsi128_si32(tmp));
 }
 
 template <>
 EIGEN_STRONG_INLINE uint32_t predux_mul(const Packet4ui& a) {
-  return sse_predux_mul_impl<Packet4ui>::run(a);
+  Packet4ui tmp = pmul<Packet4ui>(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = pmul<Packet4ui>(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return static_cast<uint32_t>(_mm_cvtsi128_si32(tmp));
 }
 
 #ifdef EIGEN_VECTORIZE_SSE4_1
 template <>
 EIGEN_STRONG_INLINE uint32_t predux_min(const Packet4ui& a) {
-  return sse_predux_min_impl<Packet4ui>::run(a);
+  Packet4ui tmp = pmin<Packet4ui>(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = pmin<Packet4ui>(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return static_cast<uint32_t>(_mm_cvtsi128_si32(tmp));
 }
 
 template <>
 EIGEN_STRONG_INLINE uint32_t predux_max(const Packet4ui& a) {
-  return sse_predux_max_impl<Packet4ui>::run(a);
+  Packet4ui tmp = pmax<Packet4ui>(a, _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3)));
+  tmp = pmax<Packet4ui>(tmp, _mm_unpackhi_epi32(tmp, tmp));
+  return static_cast<uint32_t>(_mm_cvtsi128_si32(tmp));
 }
 #endif
 
@@ -181,18 +142,10 @@
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet2l -- -- -- -- -- -- -- -- -- -- -- -- */
 
-template <typename Op>
-struct sse_predux_common<Packet2l, Op> {
-  static EIGEN_STRONG_INLINE int64_t run(const Packet2l& a) {
-    Packet2l tmp;
-    tmp = Op::packetOp(a, _mm_unpackhi_epi64(a, a));
-    return pfirst(tmp);
-  }
-};
-
 template <>
 EIGEN_STRONG_INLINE int64_t predux(const Packet2l& a) {
-  return sse_predux_impl<Packet2l>::run(a);
+  Packet2l tmp = _mm_add_epi64(a, _mm_unpackhi_epi64(a, a));
+  return pfirst(tmp);
 }
 
 template <>
@@ -202,58 +155,62 @@
 
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet4f -- -- -- -- -- -- -- -- -- -- -- -- */
 
-template <typename Op>
-struct sse_predux_common<Packet4f, Op> {
-  static EIGEN_STRONG_INLINE float run(const Packet4f& a) {
-    Packet4f tmp;
-    tmp = Op::packetOp(a, _mm_movehl_ps(a, a));
-#ifdef EIGEN_VECTORIZE_SSE3
-    tmp = Op::packetOp(tmp, _mm_movehdup_ps(tmp));
-#else
-    tmp = Op::packetOp(tmp, _mm_shuffle_ps(tmp, tmp, 1));
-#endif
-    return _mm_cvtss_f32(tmp);
-  }
-};
-
 template <>
 EIGEN_STRONG_INLINE float predux(const Packet4f& a) {
-  return sse_predux_impl<Packet4f>::run(a);
+  // The 2->1 step is the low-lane form, as for Packet2d. It reads an already-reduced
+  // temporary rather than the live packet, so unlike Packet2d it needs no encoding split.
+  Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a, a));
+  tmp = _mm_add_ss(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_mul(const Packet4f& a) {
-  return sse_predux_mul_impl<Packet4f>::run(a);
+  Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a, a));
+  tmp = _mm_mul_ss(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_min(const Packet4f& a) {
-  return sse_predux_min_impl<Packet4f>::run(a);
+  Packet4f tmp = pmin<Packet4f>(a, _mm_movehl_ps(a, a));
+  tmp = pmin<Packet4f>(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_min<PropagateNumbers>(const Packet4f& a) {
-  return sse_predux_min_prop_impl<PropagateNumbers, Packet4f>::run(a);
+  Packet4f tmp = pmin<PropagateNumbers, Packet4f>(a, _mm_movehl_ps(a, a));
+  tmp = pmin<PropagateNumbers, Packet4f>(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_min<PropagateNaN>(const Packet4f& a) {
-  return sse_predux_min_prop_impl<PropagateNaN, Packet4f>::run(a);
+  Packet4f tmp = pmin<PropagateNaN, Packet4f>(a, _mm_movehl_ps(a, a));
+  tmp = pmin<PropagateNaN, Packet4f>(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_max(const Packet4f& a) {
-  return sse_predux_max_impl<Packet4f>::run(a);
+  Packet4f tmp = pmax<Packet4f>(a, _mm_movehl_ps(a, a));
+  tmp = pmax<Packet4f>(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_max<PropagateNumbers>(const Packet4f& a) {
-  return sse_predux_max_prop_impl<PropagateNumbers, Packet4f>::run(a);
+  Packet4f tmp = pmax<PropagateNumbers, Packet4f>(a, _mm_movehl_ps(a, a));
+  tmp = pmax<PropagateNumbers, Packet4f>(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE float predux_max<PropagateNaN>(const Packet4f& a) {
-  return sse_predux_max_prop_impl<PropagateNaN, Packet4f>::run(a);
+  Packet4f tmp = pmax<PropagateNaN, Packet4f>(a, _mm_movehl_ps(a, a));
+  tmp = pmax<PropagateNaN, Packet4f>(tmp, sse_lane1(tmp));
+  return _mm_cvtss_f32(tmp);
 }
 
 template <>
@@ -261,55 +218,87 @@
   return _mm_movemask_ps(a) != 0x0;
 }
 
+#ifdef EIGEN_VECTORIZE_SSE4_2
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet4f& a) {
+  const unsigned int mask = static_cast<unsigned int>(_mm_movemask_ps(_mm_cmpneq_ps(a, _mm_setzero_ps())));
+  return Index(popcount(mask));
+}
+#endif
+
 /* -- -- -- -- -- -- -- -- -- -- -- -- Packet2d -- -- -- -- -- -- -- -- -- -- -- -- */
 
-template <typename Op>
-struct sse_predux_common<Packet2d, Op> {
-  static EIGEN_STRONG_INLINE double run(const Packet2d& a) {
-    Packet2d tmp;
-    tmp = Op::packetOp(a, _mm_unpackhi_pd(a, a));
-    return _mm_cvtsd_f64(tmp);
-  }
-};
-
+// The 2->1 step is not packed: a packed step pins the result in a vector register, so
+// neighbouring reductions -- one per coefficient of a small coeff-based product -- are
+// not re-packed into one store (~16% on clang/AVX2). Take the high lane first: pfirst(a)
+// is a's register, so reading it first keeps a live across the shuffle and gcc copies it
+// out. Without VEX the low-lane form wins when a is an accumulator rather than the data.
 template <>
 EIGEN_STRONG_INLINE double predux(const Packet2d& a) {
-  return sse_predux_impl<Packet2d>::run(a);
+#ifdef EIGEN_VECTORIZE_AVX
+  const double hi = pfirst(preverse(a));
+  return pfirst(a) + hi;
+#else
+  return _mm_cvtsd_f64(_mm_add_sd(a, preverse(a)));
+#endif
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_mul(const Packet2d& a) {
-  return sse_predux_mul_impl<Packet2d>::run(a);
+#ifdef EIGEN_VECTORIZE_AVX
+  const double hi = pfirst(preverse(a));
+  return pfirst(a) * hi;
+#else
+  return _mm_cvtsd_f64(_mm_mul_sd(a, preverse(a)));
+#endif
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_min(const Packet2d& a) {
-  return sse_predux_min_impl<Packet2d>::run(a);
+#ifdef EIGEN_VECTORIZE_AVX
+  const double hi = pfirst(preverse(a));
+  return pmin<double>(pfirst(a), hi);
+#else
+  // _mm_unpackhi_pd, not preverse: clang folds this whole reduction into a scalar
+  // load from lane 1, and only recognises that spelling.
+  return _mm_cvtsd_f64(pmin<Packet2d>(a, _mm_unpackhi_pd(a, a)));
+#endif
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_min<PropagateNumbers>(const Packet2d& a) {
-  return sse_predux_min_prop_impl<PropagateNumbers, Packet2d>::run(a);
+  Packet2d tmp = pmin<PropagateNumbers, Packet2d>(a, _mm_unpackhi_pd(a, a));
+  return _mm_cvtsd_f64(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_min<PropagateNaN>(const Packet2d& a) {
-  return sse_predux_min_prop_impl<PropagateNaN, Packet2d>::run(a);
+  Packet2d tmp = pmin<PropagateNaN, Packet2d>(a, _mm_unpackhi_pd(a, a));
+  return _mm_cvtsd_f64(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_max(const Packet2d& a) {
-  return sse_predux_max_impl<Packet2d>::run(a);
+#ifdef EIGEN_VECTORIZE_AVX
+  const double hi = pfirst(preverse(a));
+  return pmax<double>(pfirst(a), hi);
+#else
+  // _mm_unpackhi_pd, not preverse: clang folds this whole reduction into a scalar
+  // load from lane 1, and only recognises that spelling.
+  return _mm_cvtsd_f64(pmax<Packet2d>(a, _mm_unpackhi_pd(a, a)));
+#endif
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_max<PropagateNumbers>(const Packet2d& a) {
-  return sse_predux_max_prop_impl<PropagateNumbers, Packet2d>::run(a);
+  Packet2d tmp = pmax<PropagateNumbers, Packet2d>(a, _mm_unpackhi_pd(a, a));
+  return _mm_cvtsd_f64(tmp);
 }
 
 template <>
 EIGEN_STRONG_INLINE double predux_max<PropagateNaN>(const Packet2d& a) {
-  return sse_predux_max_prop_impl<PropagateNaN, Packet2d>::run(a);
+  Packet2d tmp = pmax<PropagateNaN, Packet2d>(a, _mm_unpackhi_pd(a, a));
+  return _mm_cvtsd_f64(tmp);
 }
 
 template <>
@@ -317,6 +306,14 @@
   return _mm_movemask_pd(a) != 0x0;
 }
 
+#ifdef EIGEN_VECTORIZE_SSE4_2
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const Packet2d& a) {
+  const unsigned int mask = static_cast<unsigned int>(_mm_movemask_pd(_mm_cmpneq_pd(a, _mm_setzero_pd())));
+  return Index(popcount(mask));
+}
+#endif
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/SSE/TypeCasting.h b/Eigen/src/Core/arch/SSE/TypeCasting.h
index 8eebc02..24a6d9d 100644
--- a/Eigen/src/Core/arch/SSE/TypeCasting.h
+++ b/Eigen/src/Core/arch/SSE/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_SSE_H
 #define EIGEN_TYPE_CASTING_SSE_H
diff --git a/Eigen/src/Core/arch/SVE/Complex.h b/Eigen/src/Core/arch/SVE/Complex.h
new file mode 100644
index 0000000..f9cb5ca
--- /dev/null
+++ b/Eigen/src/Core/arch/SVE/Complex.h
@@ -0,0 +1,492 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_COMPLEX_SVE_H
+#define EIGEN_COMPLEX_SVE_H
+
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+// A complex packet is one real packet holding interleaved {re, im} pairs. That
+// layout is not a choice: GenericPacketMathComplex.h and ConjHelper.h both index
+// the member `v` and construct a complex packet from a real one.
+
+struct PacketXcf {
+  EIGEN_STRONG_INLINE PacketXcf() {}
+  EIGEN_STRONG_INLINE explicit PacketXcf(const PacketXf& a) : v(a) {}
+  PacketXf v;
+};
+
+struct PacketXcd {
+  EIGEN_STRONG_INLINE PacketXcd() {}
+  EIGEN_STRONG_INLINE explicit PacketXcd(const PacketXd& a) : v(a) {}
+  PacketXd v;
+};
+
+template <>
+struct packet_traits<std::complex<float>> : default_packet_traits {
+  typedef PacketXcf type;
+  typedef PacketXcf half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<std::complex<float>, EIGEN_ARM64_SVE_VL>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasArg = 0,
+
+    HasSqrt = 1,
+    HasLog = 1,
+    // pexp_complex evaluates exp(a+bi) as e^a * (cos b + i sin b), and psin for
+    // PacketXf returns |sin| under -ffast-math with GCC (13 through 15): the
+    // magnitude is right but the sign is dropped, so exp of any value with a
+    // negative imaginary part comes out conjugated. clang is unaffected, as is
+    // NEON under either compiler, and every primitive psincos_float uses checks
+    // out in isolation -- a verbatim copy of its body in another translation
+    // unit gives the right answer with the same flags. Until that is resolved,
+    // leave exp to the scalar path. See
+    // https://gitlab.com/libeigen/eigen/-/issues/3132.
+    HasExp = 0
+  };
+};
+
+template <>
+struct packet_traits<std::complex<double>> : default_packet_traits {
+  typedef PacketXcd type;
+  typedef PacketXcd half;
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<std::complex<double>, EIGEN_ARM64_SVE_VL>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasDiv = 1,
+    HasNegate = 1,
+    HasConj = 1,
+    HasSetLinear = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasArg = 0,
+
+    HasSqrt = 1,
+    HasLog = 1,
+    // As for complex<float>: pexp_complex reaches psin, which drops the sign
+    // under -ffast-math with GCC. See
+    // https://gitlab.com/libeigen/eigen/-/issues/3132.
+    HasExp = 0
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXcf> {
+  typedef std::complex<float> type;
+  typedef PacketXcf half;
+  typedef PacketXf as_real;
+  enum {
+    size = sve_packet_size_selector<std::complex<float>, EIGEN_ARM64_SVE_VL>::size,
+    alignment = sve_packet_alignment_selector<EIGEN_ARM64_SVE_VL>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXcd> {
+  typedef std::complex<double> type;
+  typedef PacketXcd half;
+  typedef PacketXd as_real;
+  enum {
+    size = sve_packet_size_selector<std::complex<double>, EIGEN_ARM64_SVE_VL>::size,
+    alignment = sve_packet_alignment_selector<EIGEN_ARM64_SVE_VL>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+/********************************* complex<float> *****************************/
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pset1<PacketXcf>(const std::complex<float>& from) {
+  // {re, im} is one 64-bit lane, so broadcasting the value is a 64-bit dup.
+  return PacketXcf(svreinterpret_f32_u64(svdup_n_u64(numext::bit_cast<numext::uint64_t>(from))));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pload<PacketXcf>(const std::complex<float>* from) {
+  return PacketXcf(pload<PacketXf>(reinterpret_cast<const float*>(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf ploadu<PacketXcf>(const std::complex<float>* from) {
+  return PacketXcf(ploadu<PacketXf>(reinterpret_cast<const float*>(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<float>>(std::complex<float>* to, const PacketXcf& from) {
+  pstore(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<float>>(std::complex<float>* to, const PacketXcf& from) {
+  pstoreu(reinterpret_cast<float*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf ploaddup<PacketXcf>(const std::complex<float>* from) {
+  // Load the size/2 values this reads into the low half and interleave them
+  // with themselves on 64-bit lanes, which moves whole {re, im} pairs. The
+  // predicate is exact rather than svptrue -- a wider one would read past the
+  // end of the input.
+  constexpr uint64_t kHalf = uint64_t(packet_traits<std::complex<float>>::size) / 2;
+  const svuint64_t lo =
+      svreinterpret_u64_f32(svld1_f32(svwhilelt_b32(uint64_t(0), 2 * kHalf), reinterpret_cast<const float*>(from)));
+  return PacketXcf(svreinterpret_f32_u64(svzip1_u64(lo, lo)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf ploadquad<PacketXcf>(const std::complex<float>* from) {
+  // As ploaddup, one zip further: size/4 values, each repeated four times. At
+  // the smallest vector length size/4 rounds to zero, where one value still
+  // has to be read.
+  constexpr uint64_t kQuarter = numext::maxi(uint64_t(packet_traits<std::complex<float>>::size) / 4, uint64_t(1));
+  svuint64_t lo =
+      svreinterpret_u64_f32(svld1_f32(svwhilelt_b32(uint64_t(0), 2 * kQuarter), reinterpret_cast<const float*>(from)));
+  lo = svzip1_u64(lo, lo);
+  return PacketXcf(svreinterpret_f32_u64(svzip1_u64(lo, lo)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pgather<std::complex<float>, PacketXcf>(const std::complex<float>* from, Index stride) {
+  const svuint64_t idx = svindex_u64(0, numext::uint64_t(stride));
+  return PacketXcf(svreinterpret_f32_u64(
+      svld1_gather_u64index_u64(svptrue_b64(), reinterpret_cast<const numext::uint64_t*>(from), idx)));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pscatter<std::complex<float>, PacketXcf>(std::complex<float>* to, const PacketXcf& from,
+                                                                  Index stride) {
+  const svuint64_t idx = svindex_u64(0, numext::uint64_t(stride));
+  svst1_scatter_u64index_u64(svptrue_b64(), reinterpret_cast<numext::uint64_t*>(to), idx,
+                             svreinterpret_u64_f32(from.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> pfirst<PacketXcf>(const PacketXcf& a) {
+  // svlasta with no active lane returns lane 0, which is the whole value.
+  return numext::bit_cast<std::complex<float>>(svlasta_u64(svpfalse_b(), svreinterpret_u64_f32(a.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pconj(const PacketXcf& a) {
+  // {re, im} is one 64-bit lane with im in the high half, so flipping bit 63
+  // negates the imaginary part alone.
+  return PacketXcf(
+      svreinterpret_f32_u64(sveor_n_u64_x(svptrue_b64(), svreinterpret_u64_f32(a.v), numext::uint64_t(1) << 63)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pcplxflip<PacketXcf>(const PacketXcf& a) {
+  // Swap the 32-bit halves of every 64-bit lane: {re, im} -> {im, re}.
+  return PacketXcf(svreinterpret_f32_u64(svrevw_u64_x(svptrue_b64(), svreinterpret_u64_f32(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pdupreal<PacketXcf>(const PacketXcf& a) {
+  return PacketXcf(svtrn1_f32(a.v, a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf pdupimag<PacketXcf>(const PacketXcf& a) {
+  return PacketXcf(svtrn2_f32(a.v, a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcf preverse(const PacketXcf& a) {
+  // Reversing 64-bit lanes moves whole complex values and keeps {re, im} paired.
+  return PacketXcf(svreinterpret_f32_u64(svrev_u64(svreinterpret_u64_f32(a.v))));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<float> predux<PacketXcf>(const PacketXcf& a) {
+  // Read as a 32-bit predicate, an all-true 64-bit one is exactly the even
+  // lanes -- the real parts -- and reversing it gives the odd ones.
+  const svbool_t even = svptrue_b64();
+  const svbool_t odd = svrev_b32(even);
+  return {svaddv_f32(even, a.v), svaddv_f32(odd, a.v)};
+}
+
+/********************************* complex<double> ****************************/
+// A complex<double> spans two 64-bit lanes rather than sitting inside one, so
+// the lane kernels below index components instead of whole values.
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pset1<PacketXcd>(const std::complex<double>& from) {
+  // A complex value is one 128-bit quadword, so broadcasting it is a quadword dup.
+  return PacketXcd(svdupq_n_f64(numext::real(from), numext::imag(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pload<PacketXcd>(const std::complex<double>* from) {
+  return PacketXcd(pload<PacketXd>(reinterpret_cast<const double*>(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd ploadu<PacketXcd>(const std::complex<double>* from) {
+  return PacketXcd(ploadu<PacketXd>(reinterpret_cast<const double*>(from)));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<std::complex<double>>(std::complex<double>* to, const PacketXcd& from) {
+  pstore(reinterpret_cast<double*>(to), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<std::complex<double>>(std::complex<double>* to, const PacketXcd& from) {
+  pstoreu(reinterpret_cast<double*>(to), from.v);
+}
+
+// Gather the components of complex value `value_index[i]`, keeping the
+// component offset of lane i.
+EIGEN_STRONG_INLINE svuint64_t sve_cd_component_index(const svuint64_t& value_index) {
+  const svuint64_t lane = svindex_u64(0, 1);
+  return svadd_u64_x(svptrue_b64(), svlsl_n_u64_x(svptrue_b64(), value_index, 1),
+                     svand_n_u64_x(svptrue_b64(), lane, 1));
+}
+
+// Repeat each of the leading `kValues` complex values `1 << kLog2Repeat` times.
+// Reading them contiguously under an exact predicate and permuting beats a
+// gather, and unlike a 128-bit zip it needs no f64mm: lane j wants component
+// j & 1 of complex value j >> (kLog2Repeat + 1).
+template <int kLog2Repeat>
+EIGEN_STRONG_INLINE PacketXcd sve_cd_loadrepeat(const std::complex<double>* from) {
+  constexpr uint64_t kValues =
+      numext::maxi(uint64_t(packet_traits<std::complex<double>>::size) >> kLog2Repeat, uint64_t(1));
+  const svfloat64_t lo = svld1_f64(svwhilelt_b64(uint64_t(0), 2 * kValues), reinterpret_cast<const double*>(from));
+  const svuint64_t lane = svindex_u64(0, 1);
+  const svuint64_t idx =
+      svorr_u64_x(svptrue_b64(), svlsl_n_u64_x(svptrue_b64(), svlsr_n_u64_x(svptrue_b64(), lane, kLog2Repeat + 1), 1),
+                  svand_n_u64_x(svptrue_b64(), lane, 1));
+  return PacketXcd(svtbl_f64(lo, idx));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd ploaddup<PacketXcd>(const std::complex<double>* from) {
+  return sve_cd_loadrepeat<1>(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd ploadquad<PacketXcd>(const std::complex<double>* from) {
+  return sve_cd_loadrepeat<2>(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pgather<std::complex<double>, PacketXcd>(const std::complex<double>* from, Index stride) {
+  const svuint64_t value =
+      svmul_n_u64_x(svptrue_b64(), svlsr_n_u64_x(svptrue_b64(), svindex_u64(0, 1), 1), numext::uint64_t(stride));
+  return PacketXcd(
+      svld1_gather_u64index_f64(svptrue_b64(), reinterpret_cast<const double*>(from), sve_cd_component_index(value)));
+}
+
+template <>
+EIGEN_STRONG_INLINE void pscatter<std::complex<double>, PacketXcd>(std::complex<double>* to, const PacketXcd& from,
+                                                                   Index stride) {
+  const svuint64_t value =
+      svmul_n_u64_x(svptrue_b64(), svlsr_n_u64_x(svptrue_b64(), svindex_u64(0, 1), 1), numext::uint64_t(stride));
+  svst1_scatter_u64index_f64(svptrue_b64(), reinterpret_cast<double*>(to), sve_cd_component_index(value), from.v);
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> pfirst<PacketXcd>(const PacketXcd& a) {
+  // svlastb with a VL1 predicate reads lane 0, VL2 reads lane 1.
+  return {svlastb_f64(svptrue_pat_b64(SV_VL1), a.v), svlastb_f64(svptrue_pat_b64(SV_VL2), a.v)};
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pconj(const PacketXcd& a) {
+  // Flip the sign bit of every odd lane; the mask repeats every quadword.
+  const svuint64_t mask = svdupq_n_u64(0, numext::uint64_t(1) << 63);
+  return PacketXcd(svreinterpret_f64_u64(sveor_u64_x(svptrue_b64(), svreinterpret_u64_f64(a.v), mask)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pcplxflip<PacketXcd>(const PacketXcd& a) {
+  // Swapping the two lanes of each complex value is an index xor 1.
+  return PacketXcd(svtbl_f64(a.v, sveor_n_u64_x(svptrue_b64(), svindex_u64(0, 1), 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pdupreal<PacketXcd>(const PacketXcd& a) {
+  return PacketXcd(svtrn1_f64(a.v, a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd pdupimag<PacketXcd>(const PacketXcd& a) {
+  return PacketXcd(svtrn2_f64(a.v, a.v));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXcd preverse(const PacketXcd& a) {
+  // Reversing every lane also swaps re and im inside each value; undo that.
+  return pcplxflip<PacketXcd>(PacketXcd(svrev_f64(a.v)));
+}
+
+template <>
+EIGEN_STRONG_INLINE std::complex<double> predux<PacketXcd>(const PacketXcd& a) {
+  const svbool_t even = svdupq_n_b64(true, false);
+  return {svaddv_f64(even, a.v), svaddv_f64(svrev_b64(even), a.v)};
+}
+
+// A complex<double> is one 128-bit quadword, so transposing complex packets is
+// the real backend's zip network run on quadwords. FEAT_F64MM spells that
+// svzip1q_f64/svzip2q_f64, but armv8.2-a+sve has neither those nor SVE2's
+// two-vector svtbl2, so pick each half with svtbl and merge them on a
+// quadword-alternating predicate. Both index vectors and the predicate are
+// loop-invariant, leaving two svtbl and one svsel per output.
+EIGEN_STRONG_INLINE svbool_t sve_cd_quadword_even() {
+  const svuint64_t quadword = svlsr_n_u64_x(svptrue_b64(), svindex_u64(0, 1), 1);
+  return svcmpeq_n_u64(svptrue_b64(), svand_n_u64_x(svptrue_b64(), quadword, 1), 0);
+}
+
+// Lane j of the low zip takes component j & 1 of quadword j >> 2, from a when
+// its own quadword is even and from b when it is odd; the high zip is the same
+// pattern offset by half the packet.
+EIGEN_STRONG_INLINE svuint64_t sve_cd_zip_index(uint64_t offset) {
+  const svuint64_t lane = svindex_u64(0, 1);
+  const svuint64_t pair = svlsl_n_u64_x(svptrue_b64(), svlsr_n_u64_x(svptrue_b64(), lane, 2), 1);
+  return svadd_n_u64_x(svptrue_b64(), svorr_u64_x(svptrue_b64(), pair, svand_n_u64_x(svptrue_b64(), lane, 1)), offset);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXcd, N>& kernel) {
+  EIGEN_STATIC_ASSERT((N & (N - 1)) == 0, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  constexpr uint64_t kLanes = 2 * uint64_t(unpacket_traits<PacketXcd>::size);
+  const svbool_t even = sve_cd_quadword_even();
+  const svuint64_t lo_index = sve_cd_zip_index(0);
+  const svuint64_t hi_index = sve_cd_zip_index(kLanes / 2);
+  for (int stride = N / 2; stride > 0; stride >>= 1) {
+    for (int block = 0; block < N; block += 2 * stride) {
+      for (int k = 0; k < stride; ++k) {
+        const svfloat64_t a = kernel.packet[block + k].v;
+        const svfloat64_t b = kernel.packet[block + k + stride].v;
+        const svfloat64_t lo = svsel_f64(even, svtbl_f64(a, lo_index), svtbl_f64(b, lo_index));
+        const svfloat64_t hi = svsel_f64(even, svtbl_f64(a, hi_index), svtbl_f64(b, hi_index));
+        kernel.packet[block + k] = PacketXcd(lo);
+        kernel.packet[block + k + stride] = PacketXcd(hi);
+      }
+    }
+  }
+}
+
+/********************************* shared *************************************/
+
+// Everything that acts on {re, im} pairs identically forwards to the real packet.
+#define EIGEN_SVE_COMPLEX_DELEGATE(PACKET_CPLX)                                                       \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX padd<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {     \
+    return PACKET_CPLX(padd(a.v, b.v));                                                               \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX psub<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {     \
+    return PACKET_CPLX(psub(a.v, b.v));                                                               \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pnegate(const PACKET_CPLX& a) {                                     \
+    return PACKET_CPLX(pnegate(a.v));                                                                 \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pzero<PACKET_CPLX>(const PACKET_CPLX& a) {                          \
+    return PACKET_CPLX(pzero(a.v));                                                                   \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pand<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {     \
+    return PACKET_CPLX(pand(a.v, b.v));                                                               \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX por<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {      \
+    return PACKET_CPLX(por(a.v, b.v));                                                                \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pxor<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {     \
+    return PACKET_CPLX(pxor(a.v, b.v));                                                               \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pandnot<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {  \
+    return PACKET_CPLX(pandnot(a.v, b.v));                                                            \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pselect<PACKET_CPLX>(const PACKET_CPLX& mask, const PACKET_CPLX& a, \
+                                                       const PACKET_CPLX& b) {                        \
+    return PACKET_CPLX(pselect(mask.v, a.v, b.v));                                                    \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pmul<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {     \
+    return pmul_complex(a, b);                                                                        \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pdiv<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {     \
+    return pdiv_complex(a, b);                                                                        \
+  }                                                                                                   \
+  /* A complex value is equal only if both components are, so fold the two */                         \
+  /* real-lane results together across each pair. */                                                  \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_CPLX pcmp_eq<PACKET_CPLX>(const PACKET_CPLX& a, const PACKET_CPLX& b) {  \
+    const PACKET_CPLX t = PACKET_CPLX(pcmp_eq(a.v, b.v));                                             \
+    return PACKET_CPLX(pand(pdupreal(t).v, pdupimag(t).v));                                           \
+  }
+
+EIGEN_SVE_COMPLEX_DELEGATE(PacketXcf)
+EIGEN_SVE_COMPLEX_DELEGATE(PacketXcd)
+#undef EIGEN_SVE_COMPLEX_DELEGATE
+
+EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS_NO_EXP(PacketXcf)
+EIGEN_INSTANTIATE_COMPLEX_MATH_FUNCS_NO_EXP(PacketXcd)
+
+// A complex value is exactly one 64-bit lane, so transposing complex packets is
+// a zip network run on 64-bit elements.
+template <int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXcf, N>& kernel) {
+  EIGEN_STATIC_ASSERT((N & (N - 1)) == 0, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  for (int stride = N / 2; stride > 0; stride >>= 1) {
+    for (int block = 0; block < N; block += 2 * stride) {
+      for (int k = 0; k < stride; ++k) {
+        const svuint64_t a = svreinterpret_u64_f32(kernel.packet[block + k].v);
+        const svuint64_t b = svreinterpret_u64_f32(kernel.packet[block + k + stride].v);
+        kernel.packet[block + k] = PacketXcf(svreinterpret_f32_u64(svzip1_u64(a, b)));
+        kernel.packet[block + k + stride] = PacketXcf(svreinterpret_f32_u64(svzip2_u64(a, b)));
+      }
+    }
+  }
+}
+
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PacketXcf, PacketXf)
+EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(PacketXcd, PacketXd)
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPLEX_SVE_H
diff --git a/Eigen/src/Core/arch/SVE/GeneralBlockPanelKernel.h b/Eigen/src/Core/arch/SVE/GeneralBlockPanelKernel.h
new file mode 100644
index 0000000..553d7bf
--- /dev/null
+++ b/Eigen/src/Core/arch/SVE/GeneralBlockPanelKernel.h
@@ -0,0 +1,38 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+#include "../../InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+// The generic gebp_traits declares nr = 4, and until this header existed the SVE
+// backend took it: an SVE build measured a 6x4 register block where the NEON
+// build of the same source measured 6x8. Isolated by forcing the NEON build to
+// nr = 4, which cost it about 15% of its double GEMM rate -- the whole of the
+// remaining gap between the two backends once double was vectorized at all.
+//
+// Only nr is overridden. NEON additionally replaces the RHS machinery because
+// vfmaq_laneq_f64 needs an immediate lane index into a real vector; SVE's
+// equivalent selects a lane within each 128-bit segment rather than across the
+// vector, so it is not a drop-in at vector lengths above 128 bits, and the
+// generic QuadPacket path -- pbroadcast4 to svdup, madd to svmla -- already
+// emits what a hand-written version would.
+#ifndef EIGEN_SVE_GEBP_NR
+#define EIGEN_SVE_GEBP_NR 8
+#endif
+
+template <>
+struct gebp_traits<float, float, false, false, Architecture::SVE, GEBPPacketFull>
+    : gebp_traits<float, float, false, false, Architecture::Generic, GEBPPacketFull> {
+  enum { nr = EIGEN_SVE_GEBP_NR };
+};
+
+template <>
+struct gebp_traits<double, double, false, false, Architecture::SVE, GEBPPacketFull>
+    : gebp_traits<double, double, false, false, Architecture::Generic, GEBPPacketFull> {
+  enum { nr = EIGEN_SVE_GEBP_NR };
+};
+
+}  // namespace internal
+}  // namespace Eigen
diff --git a/Eigen/src/Core/arch/SVE/MathFunctions.h b/Eigen/src/Core/arch/SVE/MathFunctions.h
index a547d39..5215537 100644
--- a/Eigen/src/Core/arch/SVE/MathFunctions.h
+++ b/Eigen/src/Core/arch/SVE/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_SVE_H
 #define EIGEN_MATH_FUNCTIONS_SVE_H
@@ -17,6 +18,7 @@
 namespace internal {
 
 EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_FLOAT(PacketXf)
+EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_DOUBLE(PacketXd)
 
 }  // end namespace internal
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/SVE/PacketMath.h b/Eigen/src/Core/arch/SVE/PacketMath.h
index 310a40c..cbdbd20 100644
--- a/Eigen/src/Core/arch/SVE/PacketMath.h
+++ b/Eigen/src/Core/arch/SVE/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_SVE_H
 #define EIGEN_PACKET_MATH_SVE_H
@@ -30,7 +31,18 @@
   enum { size = SVEVectorLength / (sizeof(Scalar) * CHAR_BIT) };
 };
 
+// A fixed-length SVE packet needs exactly its own size in alignment, no more --
+// hard-coding Aligned64 over-constrains every vector length below 512 and, since
+// the requirement then exceeds what a fixed-size object can offer, disables
+// vectorization for those types outright. The Alignment enum tops out at
+// Aligned128 (AlignedMask is 255), so clamp there for VL >= 2048.
+template <int SVEVectorLength>
+struct sve_packet_alignment_selector {
+  enum { alignment = plain_enum_min(SVEVectorLength / CHAR_BIT, Aligned128) };
+};
+
 /********************************* int32 **************************************/
+// Keep typedef: Doxygen 1.13.2 misparses an attributed using declaration.
 typedef svint32_t PacketXi __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
 
 template <>
@@ -52,6 +64,15 @@
     HasMin = 1,
     HasMax = 1,
     HasConj = 1,
+    // HasSetLinear and HasCmp stay 0 even though plset and pcmp_{eq,lt,le} are
+    // implemented below: both flags route work onto a packet path that measures
+    // far slower than the scalar loop GCC autovectorizes. On Neoverse V2 at
+    // VL=128, HasSetLinear costs LinSpaced 20.7 -> 60.6 us for float and
+    // 20.7 -> 121.6 us for double, and HasCmp costs (a < b).select(a, b)
+    // 6.2 -> 50.6 us. Neither is explained by pselect: these numbers are with
+    // the svsel specialization below in place, and it made the LinSpaced case
+    // worse rather than better. The cause is higher up, in how those evaluators
+    // drive the packet path, and should be found before either flag is set.
     HasSetLinear = 0,
     HasReduxp = 0  // Not implemented in SVE
   };
@@ -63,7 +84,7 @@
   typedef PacketXi half;  // Half not yet implemented
   enum {
     size = sve_packet_size_selector<numext::int32_t, EIGEN_ARM64_SVE_VL>::size,
-    alignment = Aligned64,
+    alignment = sve_packet_alignment_selector<EIGEN_ARM64_SVE_VL>::alignment,
     vectorizable = true,
     masked_load_available = false,
     masked_store_available = false
@@ -82,9 +103,7 @@
 
 template <>
 EIGEN_STRONG_INLINE PacketXi plset<PacketXi>(const numext::int32_t& a) {
-  numext::int32_t c[packet_traits<numext::int32_t>::size];
-  for (int i = 0; i < packet_traits<numext::int32_t>::size; i++) c[i] = i;
-  return svadd_s32_x(svptrue_b32(), pset1<PacketXi>(a), svld1_s32(svptrue_b32(), c));
+  return svindex_s32(a, 1);
 }
 
 template <>
@@ -103,11 +122,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE PacketXi pconj(const PacketXi& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE PacketXi pmul<PacketXi>(const PacketXi& a, const PacketXi& b) {
   return svmul_s32_x(svptrue_b32(), a, b);
 }
@@ -177,18 +191,31 @@
   return svbic_s32_x(svptrue_b32(), a, b);
 }
 
-template <int N>
-EIGEN_STRONG_INLINE PacketXi parithmetic_shift_right(PacketXi a) {
-  return svasrd_n_s32_x(svptrue_b32(), a, N);
+// SVE selects on a predicate, so turn Eigen's all-ones/all-zeros value mask back
+// into one and use svsel rather than the generic por(pand, pandnot). Measured on
+// Neoverse V2 at VL=128: latency 3.18 -> 2.55 ns, throughput 0.80 -> 0.64 ns/op.
+// SVE2's single-instruction svbsl is no faster than this, so it is not worth an
+// ISA-conditional path. The mask is compared as an integer: as a float it would
+// be a NaN bit pattern, and relying on NaN != 0 is needlessly subtle.
+template <>
+EIGEN_STRONG_INLINE PacketXi pselect<PacketXi>(const PacketXi& mask, const PacketXi& a, const PacketXi& b) {
+  return svsel_s32(svcmpne_n_s32(svptrue_b32(), mask, 0), a, b);
 }
 
 template <int N>
-EIGEN_STRONG_INLINE PacketXi plogical_shift_right(PacketXi a) {
+EIGEN_STRONG_INLINE PacketXi parithmetic_shift_right(const PacketXi& a) {
+  // ASR, not ASRD: ASRD is the shift-for-divide form, which rounds toward zero,
+  // whereas a C++ arithmetic right shift rounds toward negative infinity.
+  return svasr_n_s32_x(svptrue_b32(), a, N);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXi plogical_shift_right(const PacketXi& a) {
   return svreinterpret_s32_u32(svlsr_n_u32_x(svptrue_b32(), svreinterpret_u32_s32(a), N));
 }
 
 template <int N>
-EIGEN_STRONG_INLINE PacketXi plogical_shift_left(PacketXi a) {
+EIGEN_STRONG_INLINE PacketXi plogical_shift_left(const PacketXi& a) {
   return svlsl_n_s32_x(svptrue_b32(), a, N);
 }
 
@@ -204,17 +231,24 @@
 
 template <>
 EIGEN_STRONG_INLINE PacketXi ploaddup<PacketXi>(const numext::int32_t* from) {
-  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
-  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
-  return svld1_gather_u32index_s32(svptrue_b32(), from, indices);
+  // Load the size/2 values this reads into the low half and interleave them
+  // with themselves: svzip1 only consumes the low halves of its operands.
+  // The predicate is exact rather than svptrue -- ploaddup may only touch
+  // size/2 elements, and a wider one would read past the end of the input.
+  constexpr uint64_t kHalf = uint64_t(packet_traits<numext::int32_t>::size) / 2;
+  svint32_t lo = svld1_s32(svwhilelt_b32(uint64_t(0), kHalf), from);
+  return svzip1_s32(lo, lo);
 }
 
 template <>
 EIGEN_STRONG_INLINE PacketXi ploadquad<PacketXi>(const numext::int32_t* from) {
-  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
-  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
-  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a0, a0, a1, a1, a1, a1, ...}
-  return svld1_gather_u32index_s32(svptrue_b32(), from, indices);
+  // As ploaddup, one zip further: size/4 values, each repeated four times.
+  // At the smallest vector length size/4 rounds to zero, where one element
+  // still has to be read.
+  constexpr uint64_t kQuarter = numext::maxi(uint64_t(packet_traits<numext::int32_t>::size) / 4, uint64_t(1));
+  svint32_t lo = svld1_s32(svwhilelt_b32(uint64_t(0), kQuarter), from);
+  lo = svzip1_s32(lo, lo);
+  return svzip1_s32(lo, lo);
 }
 
 template <>
@@ -229,7 +263,7 @@
 
 template <>
 EIGEN_DEVICE_FUNC inline PacketXi pgather<numext::int32_t, PacketXi>(const numext::int32_t* from, Index stride) {
-  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
   svint32_t indices = svindex_s32(0, stride);
   return svld1_gather_s32index_s32(svptrue_b32(), from, indices);
 }
@@ -237,7 +271,7 @@
 template <>
 EIGEN_DEVICE_FUNC inline void pscatter<numext::int32_t, PacketXi>(numext::int32_t* to, const PacketXi& from,
                                                                   Index stride) {
-  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
   svint32_t indices = svindex_s32(0, stride);
   svst1_scatter_s32index_s32(svptrue_b32(), to, indices, from);
 }
@@ -264,33 +298,19 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const PacketXi& a) {
+  return svptest_any(svptrue_b32(), svcmpne_n_s32(svptrue_b32(), a, 0));
+}
+
+template <>
 EIGEN_STRONG_INLINE numext::int32_t predux_mul<PacketXi>(const PacketXi& a) {
-  EIGEN_STATIC_ASSERT((EIGEN_ARM64_SVE_VL % 128 == 0), EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
-
-  // Multiply the vector by its reverse
+  // Multiply the vector by its reverse.
   svint32_t prod = svmul_s32_x(svptrue_b32(), a, svrev_s32(a));
-  svint32_t half_prod;
 
-  // Extract the high half of the vector. Depending on the VL more reductions need to be done
-  if (EIGEN_ARM64_SVE_VL >= 2048) {
-    half_prod = svtbl_s32(prod, svindex_u32(32, 1));
-    prod = svmul_s32_x(svptrue_b32(), prod, half_prod);
-  }
-  if (EIGEN_ARM64_SVE_VL >= 1024) {
-    half_prod = svtbl_s32(prod, svindex_u32(16, 1));
-    prod = svmul_s32_x(svptrue_b32(), prod, half_prod);
-  }
-  if (EIGEN_ARM64_SVE_VL >= 512) {
-    half_prod = svtbl_s32(prod, svindex_u32(8, 1));
-    prod = svmul_s32_x(svptrue_b32(), prod, half_prod);
-  }
-  if (EIGEN_ARM64_SVE_VL >= 256) {
-    half_prod = svtbl_s32(prod, svindex_u32(4, 1));
-    prod = svmul_s32_x(svptrue_b32(), prod, half_prod);
-  }
-  // Last reduction
-  half_prod = svtbl_s32(prod, svindex_u32(2, 1));
-  prod = svmul_s32_x(svptrue_b32(), prod, half_prod);
+  // Reduce with interleave-and-multiply.
+  // NOTE: Skip the final reduction since it is already handled by `rev` above.
+  for (int n = unpacket_traits<PacketXi>::size; n > 2; n >>= 1)
+    prod = svmul_s32_x(svptrue_b32(), svzip1_s32(prod, prod), svzip2_s32(prod, prod));
 
   // The reduction is done to the first element.
   return pfirst<PacketXi>(prod);
@@ -308,21 +328,303 @@
 
 template <int N>
 EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXi, N>& kernel) {
-  int buffer[packet_traits<numext::int32_t>::size * N] = {0};
-  int i = 0;
-
-  PacketXi stride_index = svindex_s32(0, N);
-
-  for (i = 0; i < N; i++) {
-    svst1_scatter_s32index_s32(svptrue_b32(), buffer + i, stride_index, kernel.packet[i]);
+  EIGEN_STATIC_ASSERT((N & (N - 1)) == 0, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  for (int stride = N / 2; stride > 0; stride >>= 1) {
+    for (int block = 0; block < N; block += 2 * stride) {
+      for (int k = 0; k < stride; ++k) {
+        PacketXi lo = svzip1_s32(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        PacketXi hi = svzip2_s32(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        kernel.packet[block + k] = lo;
+        kernel.packet[block + k + stride] = hi;
+      }
+    }
   }
-  for (i = 0; i < N; i++) {
-    kernel.packet[i] = svld1_s32(svptrue_b32(), buffer + i * packet_traits<numext::int32_t>::size);
+}
+
+/********************************* int64 **************************************/
+// Keep typedef: Doxygen 1.13.2 misparses an attributed using declaration.
+typedef svint64_t PacketXl __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
+
+template <>
+struct packet_traits<numext::int64_t> : default_packet_traits {
+  typedef PacketXl type;
+  typedef PacketXl half;  // Half not implemented yet
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<numext::int64_t, EIGEN_ARM64_SVE_VL>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    // See the int32 traits above for why HasSetLinear stays 0.
+    HasSetLinear = 0,
+    HasReduxp = 0  // Not implemented in SVE
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXl> {
+  typedef numext::int64_t type;
+  typedef PacketXl half;  // Half not yet implemented
+  enum {
+    size = sve_packet_size_selector<numext::int64_t, EIGEN_ARM64_SVE_VL>::size,
+    alignment = sve_packet_alignment_selector<EIGEN_ARM64_SVE_VL>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<numext::int64_t>(const numext::int64_t* addr) {
+  svprfd(svptrue_b64(), addr, SV_PLDL1KEEP);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pset1<PacketXl>(const numext::int64_t& from) {
+  return svdup_n_s64(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl plset<PacketXl>(const numext::int64_t& a) {
+  return svindex_s64(a, 1);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl padd<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svadd_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl psub<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svsub_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pnegate(const PacketXl& a) {
+  return svneg_s64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pmul<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svmul_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pdiv<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svdiv_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pmadd(const PacketXl& a, const PacketXl& b, const PacketXl& c) {
+  return svmla_s64_x(svptrue_b64(), c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pmin<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svmin_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pmax<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svmax_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pcmp_le<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svdup_n_s64_z(svcmple_s64(svptrue_b64(), a, b), numext::int64_t(-1));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pcmp_lt<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svdup_n_s64_z(svcmplt_s64(svptrue_b64(), a, b), numext::int64_t(-1));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pcmp_eq<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svdup_n_s64_z(svcmpeq_s64(svptrue_b64(), a, b), numext::int64_t(-1));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl ptrue<PacketXl>(const PacketXl& /*a*/) {
+  return svdup_n_s64_x(svptrue_b64(), numext::int64_t(-1));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pzero<PacketXl>(const PacketXl& /*a*/) {
+  return svdup_n_s64_x(svptrue_b64(), 0);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pand<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svand_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl por<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svorr_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pxor<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return sveor_s64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pandnot<PacketXl>(const PacketXl& a, const PacketXl& b) {
+  return svbic_s64_x(svptrue_b64(), a, b);
+}
+
+// See pselect<PacketXi>.
+template <>
+EIGEN_STRONG_INLINE PacketXl pselect<PacketXl>(const PacketXl& mask, const PacketXl& a, const PacketXl& b) {
+  return svsel_s64(svcmpne_n_s64(svptrue_b64(), mask, 0), a, b);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXl parithmetic_shift_right(PacketXl a) {
+  // ASR, not ASRD: see parithmetic_shift_right<PacketXi>.
+  return svasr_n_s64_x(svptrue_b64(), a, N);
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXl plogical_shift_right(PacketXl a) {
+  return svreinterpret_s64_u64(svlsr_n_u64_x(svptrue_b64(), svreinterpret_u64_s64(a), N));
+}
+
+template <int N>
+EIGEN_STRONG_INLINE PacketXl plogical_shift_left(PacketXl a) {
+  return svlsl_n_s64_x(svptrue_b64(), a, N);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pload<PacketXl>(const numext::int64_t* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return svld1_s64(svptrue_b64(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl ploadu<PacketXl>(const numext::int64_t* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return svld1_s64(svptrue_b64(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl ploaddup<PacketXl>(const numext::int64_t* from) {
+  // Load the size/2 values this reads into the low half and interleave them
+  // with themselves: svzip1 only consumes the low halves of its operands.
+  // The predicate is exact rather than svptrue -- ploaddup may only touch
+  // size/2 elements, and a wider one would read past the end of the input.
+  constexpr uint64_t kHalf = uint64_t(packet_traits<numext::int64_t>::size) / 2;
+  svint64_t lo = svld1_s64(svwhilelt_b64(uint64_t(0), kHalf), from);
+  return svzip1_s64(lo, lo);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl ploadquad<PacketXl>(const numext::int64_t* from) {
+  // As ploaddup, one zip further: size/4 values, each repeated four times.
+  // At the smallest vector length size/4 rounds to zero, where one element
+  // still has to be read.
+  constexpr uint64_t kQuarter = numext::maxi(uint64_t(packet_traits<numext::int64_t>::size) / 4, uint64_t(1));
+  svint64_t lo = svld1_s64(svwhilelt_b64(uint64_t(0), kQuarter), from);
+  lo = svzip1_s64(lo, lo);
+  return svzip1_s64(lo, lo);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<numext::int64_t>(numext::int64_t* to, const PacketXl& from) {
+  EIGEN_DEBUG_ALIGNED_STORE svst1_s64(svptrue_b64(), to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<numext::int64_t>(numext::int64_t* to, const PacketXl& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE svst1_s64(svptrue_b64(), to, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline PacketXl pgather<numext::int64_t, PacketXl>(const numext::int64_t* from, Index stride) {
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint64_t indices = svindex_s64(0, stride);
+  return svld1_gather_s64index_s64(svptrue_b64(), from, indices);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<numext::int64_t, PacketXl>(numext::int64_t* to, const PacketXl& from,
+                                                                  Index stride) {
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint64_t indices = svindex_s64(0, stride);
+  svst1_scatter_s64index_s64(svptrue_b64(), to, indices, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int64_t pfirst<PacketXl>(const PacketXl& a) {
+  // svlasta returns the first element if all predicate bits are 0
+  return svlasta_s64(svpfalse_b(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl preverse(const PacketXl& a) {
+  return svrev_s64(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pabs(const PacketXl& a) {
+  return svabs_s64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int64_t predux<PacketXl>(const PacketXl& a) {
+  return static_cast<numext::int64_t>(svaddv_s64(svptrue_b64(), a));
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int64_t predux_mul<PacketXl>(const PacketXl& a) {
+  // Multiplying by the reverse pairs lane i with lane n-1-i, so every product of
+  // a pair appears in both halves; interleaving the halves then folds them
+  // together, halving the live span each round. At VL = 128 there are two lanes
+  // and the first multiply has already combined them.
+  PacketXl prod = svmul_s64_x(svptrue_b64(), a, svrev_s64(a));
+  EIGEN_UNROLL_LOOP
+  for (int n = unpacket_traits<PacketXl>::size; n > 2; n >>= 1) {
+    prod = svmul_s64_x(svptrue_b64(), svzip1_s64(prod, prod), svzip2_s64(prod, prod));
+  }
+  return pfirst<PacketXl>(prod);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int64_t predux_min<PacketXl>(const PacketXl& a) {
+  return svminv_s64(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE numext::int64_t predux_max<PacketXl>(const PacketXl& a) {
+  return svmaxv_s64(svptrue_b64(), a);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXl, N>& kernel) {
+  EIGEN_STATIC_ASSERT((N & (N - 1)) == 0, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  for (int stride = N / 2; stride > 0; stride >>= 1) {
+    for (int block = 0; block < N; block += 2 * stride) {
+      for (int k = 0; k < stride; ++k) {
+        PacketXl lo = svzip1_s64(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        PacketXl hi = svzip2_s64(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        kernel.packet[block + k] = lo;
+        kernel.packet[block + k + stride] = hi;
+      }
+    }
   }
 }
 
 /********************************* float32 ************************************/
 
+// Keep typedef: Doxygen 1.13.2 misparses an attributed using declaration.
 typedef svfloat32_t PacketXf __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
 
 template <>
@@ -345,6 +647,7 @@
     HasMin = 1,
     HasMax = 1,
     HasConj = 1,
+    // See the int32 traits above for why HasSetLinear stays 0.
     HasSetLinear = 0,
     HasReduxp = 0,  // Not implemented in SVE
 
@@ -364,6 +667,7 @@
     HasExp = 1,
     HasPow = 1,
     HasSqrt = 1,
+    HasRsqrt = 1,
     HasCbrt = 1,
     HasTanh = EIGEN_FAST_MATH,
     HasErf = EIGEN_FAST_MATH,
@@ -379,7 +683,7 @@
 
   enum {
     size = sve_packet_size_selector<float, EIGEN_ARM64_SVE_VL>::size,
-    alignment = Aligned64,
+    alignment = sve_packet_alignment_selector<EIGEN_ARM64_SVE_VL>::alignment,
     vectorizable = true,
     masked_load_available = false,
     masked_store_available = false
@@ -398,9 +702,8 @@
 
 template <>
 EIGEN_STRONG_INLINE PacketXf plset<PacketXf>(const float& a) {
-  float c[packet_traits<float>::size];
-  for (int i = 0; i < packet_traits<float>::size; i++) c[i] = i;
-  return svadd_f32_x(svptrue_b32(), pset1<PacketXf>(a), svld1_f32(svptrue_b32(), c));
+  // As the double overload: svindex + a convert, no constant array.
+  return svadd_f32_x(svptrue_b32(), pset1<PacketXf>(a), svcvt_f32_s32_x(svptrue_b32(), svindex_s32(0, 1)));
 }
 
 template <>
@@ -419,11 +722,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE PacketXf pconj(const PacketXf& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE PacketXf pmul<PacketXf>(const PacketXf& a, const PacketXf& b) {
   return svmul_f32_x(svptrue_b32(), a, b);
 }
@@ -439,13 +737,16 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE PacketXf pmin<PacketXf>(const PacketXf& a, const PacketXf& b) {
-  return svmin_f32_x(svptrue_b32(), a, b);
+EIGEN_STRONG_INLINE PacketXf pmsub(const PacketXf& a, const PacketXf& b, const PacketXf& c) {
+  return svmla_f32_x(svptrue_b32(), svneg_f32_x(svptrue_b32(), c), a, b);
 }
 
 template <>
-EIGEN_STRONG_INLINE PacketXf pmin<PropagateNaN, PacketXf>(const PacketXf& a, const PacketXf& b) {
-  return pmin<PacketXf>(a, b);
+struct pminmax_propagates_nan<PacketXf> : bool_constant<true> {};
+
+template <>
+EIGEN_STRONG_INLINE PacketXf pmin<PacketXf>(const PacketXf& a, const PacketXf& b) {
+  return svmin_f32_x(svptrue_b32(), a, b);
 }
 
 template <>
@@ -459,11 +760,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE PacketXf pmax<PropagateNaN, PacketXf>(const PacketXf& a, const PacketXf& b) {
-  return pmax<PacketXf>(a, b);
-}
-
-template <>
 EIGEN_STRONG_INLINE PacketXf pmax<PropagateNumbers, PacketXf>(const PacketXf& a, const PacketXf& b) {
   return svmaxnm_f32_x(svptrue_b32(), a, b);
 }
@@ -497,10 +793,28 @@
 EIGEN_STRONG_INLINE PacketXf pfloor<PacketXf>(const PacketXf& a) {
   return svrintm_f32_x(svptrue_b32(), a);
 }
+template <>
+EIGEN_STRONG_INLINE PacketXf pceil<PacketXf>(const PacketXf& a) {
+  return svrintp_f32_x(svptrue_b32(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXf print<PacketXf>(const PacketXf& a) {
+  return svrintn_f32_x(svptrue_b32(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXf ptrunc<PacketXf>(const PacketXf& a) {
+  return svrintz_f32_x(svptrue_b32(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXf pround<PacketXf>(const PacketXf& a) {
+  return svrinta_f32_x(svptrue_b32(), a);
+}
 
 template <>
 EIGEN_STRONG_INLINE PacketXf ptrue<PacketXf>(const PacketXf& /*a*/) {
-  return svreinterpret_f32_u32(svdup_n_u32_x(svptrue_b32(), 0xffffffffu));
+  PacketXf r = svreinterpret_f32_u32(svdup_n_u32_x(svptrue_b32(), 0xffffffffu));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
 // Logical Operations are not supported for float, so reinterpret casts
@@ -524,6 +838,12 @@
   return svreinterpret_f32_u32(svbic_u32_x(svptrue_b32(), svreinterpret_u32_f32(a), svreinterpret_u32_f32(b)));
 }
 
+// See pselect<PacketXi>.
+template <>
+EIGEN_STRONG_INLINE PacketXf pselect<PacketXf>(const PacketXf& mask, const PacketXf& a, const PacketXf& b) {
+  return svsel_f32(svcmpne_n_s32(svptrue_b32(), svreinterpret_s32_f32(mask), 0), a, b);
+}
+
 template <>
 EIGEN_STRONG_INLINE PacketXf pload<PacketXf>(const float* from) {
   EIGEN_DEBUG_ALIGNED_LOAD return svld1_f32(svptrue_b32(), from);
@@ -536,17 +856,24 @@
 
 template <>
 EIGEN_STRONG_INLINE PacketXf ploaddup<PacketXf>(const float* from) {
-  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
-  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
-  return svld1_gather_u32index_f32(svptrue_b32(), from, indices);
+  // Load the size/2 values this reads into the low half and interleave them
+  // with themselves: svzip1 only consumes the low halves of its operands.
+  // The predicate is exact rather than svptrue -- ploaddup may only touch
+  // size/2 elements, and a wider one would read past the end of the input.
+  constexpr uint64_t kHalf = uint64_t(packet_traits<float>::size) / 2;
+  svfloat32_t lo = svld1_f32(svwhilelt_b32(uint64_t(0), kHalf), from);
+  return svzip1_f32(lo, lo);
 }
 
 template <>
 EIGEN_STRONG_INLINE PacketXf ploadquad<PacketXf>(const float* from) {
-  svuint32_t indices = svindex_u32(0, 1);  // index {base=0, base+step=1, base+step*2, ...}
-  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a1, a1, a2, a2, ...}
-  indices = svzip1_u32(indices, indices);  // index in the format {a0, a0, a0, a0, a1, a1, a1, a1, ...}
-  return svld1_gather_u32index_f32(svptrue_b32(), from, indices);
+  // As ploaddup, one zip further: size/4 values, each repeated four times.
+  // At the smallest vector length size/4 rounds to zero, where one element
+  // still has to be read.
+  constexpr uint64_t kQuarter = numext::maxi(uint64_t(packet_traits<float>::size) / 4, uint64_t(1));
+  svfloat32_t lo = svld1_f32(svwhilelt_b32(uint64_t(0), kQuarter), from);
+  lo = svzip1_f32(lo, lo);
+  return svzip1_f32(lo, lo);
 }
 
 template <>
@@ -561,14 +888,14 @@
 
 template <>
 EIGEN_DEVICE_FUNC inline PacketXf pgather<float, PacketXf>(const float* from, Index stride) {
-  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
   svint32_t indices = svindex_s32(0, stride);
   return svld1_gather_s32index_f32(svptrue_b32(), from, indices);
 }
 
 template <>
 EIGEN_DEVICE_FUNC inline void pscatter<float, PacketXf>(float* to, const PacketXf& from, Index stride) {
-  // Indice format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
   svint32_t indices = svindex_s32(0, stride);
   svst1_scatter_s32index_f32(svptrue_b32(), to, indices, from);
 }
@@ -601,36 +928,35 @@
   return svaddv_f32(svptrue_b32(), a);
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const PacketXf& a) {
+  const svuint32_t bits = svreinterpret_u32_f32(a);
+  return svptest_any(svptrue_b32(), svcmpne_n_u32(svptrue_b32(), bits, 0));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const PacketXf& a) {
+  const svbool_t all = svptrue_b32();
+  return !svptest_any(all, svcmpeq_n_f32(all, a, 0.0f));
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const PacketXf& a) {
+  const svbool_t all = svptrue_b32();
+  return static_cast<Index>(svcntp_b32(all, svcmpne_n_f32(all, a, 0.0f)));
+}
+
 // Other reduction functions:
 // mul
-// Only works for SVE Vls multiple of 128
 template <>
 EIGEN_STRONG_INLINE float predux_mul<PacketXf>(const PacketXf& a) {
-  EIGEN_STATIC_ASSERT((EIGEN_ARM64_SVE_VL % 128 == 0), EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
-  // Multiply the vector by its reverse
+  // Multiply the vector by its reverse.
   svfloat32_t prod = svmul_f32_x(svptrue_b32(), a, svrev_f32(a));
-  svfloat32_t half_prod;
 
-  // Extract the high half of the vector. Depending on the VL more reductions need to be done
-  if (EIGEN_ARM64_SVE_VL >= 2048) {
-    half_prod = svtbl_f32(prod, svindex_u32(32, 1));
-    prod = svmul_f32_x(svptrue_b32(), prod, half_prod);
-  }
-  if (EIGEN_ARM64_SVE_VL >= 1024) {
-    half_prod = svtbl_f32(prod, svindex_u32(16, 1));
-    prod = svmul_f32_x(svptrue_b32(), prod, half_prod);
-  }
-  if (EIGEN_ARM64_SVE_VL >= 512) {
-    half_prod = svtbl_f32(prod, svindex_u32(8, 1));
-    prod = svmul_f32_x(svptrue_b32(), prod, half_prod);
-  }
-  if (EIGEN_ARM64_SVE_VL >= 256) {
-    half_prod = svtbl_f32(prod, svindex_u32(4, 1));
-    prod = svmul_f32_x(svptrue_b32(), prod, half_prod);
-  }
-  // Last reduction
-  half_prod = svtbl_f32(prod, svindex_u32(2, 1));
-  prod = svmul_f32_x(svptrue_b32(), prod, half_prod);
+  // Reduce with interleave-and-multiply.
+  // NOTE: Skip the final reduction since it is already handled by `rev` above.
+  for (int n = unpacket_traits<PacketXf>::size; n > 2; n >>= 1)
+    prod = svmul_f32_x(svptrue_b32(), svzip1_f32(prod, prod), svzip2_f32(prod, prod));
 
   // The reduction is done to the first element.
   return pfirst<PacketXf>(prod);
@@ -648,17 +974,16 @@
 
 template <int N>
 EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXf, N>& kernel) {
-  float buffer[packet_traits<float>::size * N] = {0};
-  int i = 0;
-
-  PacketXi stride_index = svindex_s32(0, N);
-
-  for (i = 0; i < N; i++) {
-    svst1_scatter_s32index_f32(svptrue_b32(), buffer + i, stride_index, kernel.packet[i]);
-  }
-
-  for (i = 0; i < N; i++) {
-    kernel.packet[i] = svld1_f32(svptrue_b32(), buffer + i * packet_traits<float>::size);
+  EIGEN_STATIC_ASSERT((N & (N - 1)) == 0, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  for (int stride = N / 2; stride > 0; stride >>= 1) {
+    for (int block = 0; block < N; block += 2 * stride) {
+      for (int k = 0; k < stride; ++k) {
+        PacketXf lo = svzip1_f32(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        PacketXf hi = svzip2_f32(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        kernel.packet[block + k] = lo;
+        kernel.packet[block + k + stride] = hi;
+      }
+    }
   }
 }
 
@@ -672,6 +997,392 @@
   return svsqrt_f32_x(svptrue_b32(), a);
 }
 
+/********************************* float64 ************************************/
+// Double was missing from this backend: packet_traits<double> fell through to
+// default_packet_traits, so every double operation under EIGEN_ARM64_USE_SVE was
+// scalar.
+// Keep typedef: Doxygen 1.13.2 misparses an attributed using declaration.
+typedef svfloat64_t PacketXd __attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)));
+
+template <>
+struct packet_traits<double> : default_packet_traits {
+  typedef PacketXd type;
+  typedef PacketXd half;  // Half not implemented yet
+
+  enum {
+    Vectorizable = 1,
+    AlignedOnScalar = 1,
+    size = sve_packet_size_selector<double, EIGEN_ARM64_SVE_VL>::size,
+
+    HasAdd = 1,
+    HasSub = 1,
+    HasShift = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 1,
+    // See the int32 traits above for why HasSetLinear stays 0.
+    HasSetLinear = 0,
+    HasReduxp = 0,  // Not implemented in SVE
+
+    HasDiv = 1,
+    HasCmp = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    // asin and acos are absent from EIGEN_INSTANTIATE_GENERIC_MATH_FUNCS_DOUBLE,
+    // so they stay scalar.
+    //
+    // sin, cos and tan stay off despite being available: psin, pcos and ptan
+    // return the magnitude with the sign dropped under -ffast-math with GCC.
+    // Turning them on here would extend that to double, where the scalar path
+    // is correct today. tanh, exp, log, atan and cbrt are unaffected -- checked
+    // against the scalar reference under -ffast-math -- so they are on. See
+    // https://gitlab.com/libeigen/eigen/-/issues/3132.
+    HasATan = 1,
+    HasATanh = 1,
+    HasLog = 1,
+    HasLog1p = 1,
+    HasExpm1 = 1,
+    HasExp = 1,
+    HasPow = 1,
+    HasCbrt = 1,
+    HasTanh = EIGEN_FAST_MATH
+  };
+};
+
+template <>
+struct unpacket_traits<PacketXd> {
+  typedef double type;
+  typedef PacketXd half;  // Half not yet implemented
+  typedef PacketXl integer_packet;
+
+  enum {
+    size = sve_packet_size_selector<double, EIGEN_ARM64_SVE_VL>::size,
+    alignment = sve_packet_alignment_selector<EIGEN_ARM64_SVE_VL>::alignment,
+    vectorizable = true,
+    masked_load_available = false,
+    masked_store_available = false
+  };
+};
+
+template <>
+EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) {
+  svprfd(svptrue_b64(), addr, SV_PLDL1KEEP);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pset1<PacketXd>(const double& from) {
+  return svdup_n_f64(from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pset1frombits<PacketXd>(numext::uint64_t from) {
+  return svreinterpret_f64_u64(svdup_n_u64_x(svptrue_b64(), from));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd plset<PacketXd>(const double& a) {
+  // The ramp comes from svindex + a widening convert rather than a constant
+  // array: no static storage, no load, and no alignment question.
+  return svadd_f64_x(svptrue_b64(), pset1<PacketXd>(a), svcvt_f64_s64_x(svptrue_b64(), svindex_s64(0, 1)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd padd<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svadd_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd psub<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svsub_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pnegate(const PacketXd& a) {
+  return svneg_f64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmul<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svmul_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pdiv<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svdiv_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmadd(const PacketXd& a, const PacketXd& b, const PacketXd& c) {
+  return svmla_f64_x(svptrue_b64(), c, a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmsub(const PacketXd& a, const PacketXd& b, const PacketXd& c) {
+  return svmla_f64_x(svptrue_b64(), svneg_f64_x(svptrue_b64(), c), a, b);
+}
+
+template <>
+struct pminmax_propagates_nan<PacketXd> : bool_constant<true> {};
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmin<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svmin_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmin<PropagateNumbers, PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svminnm_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmax<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svmax_f64_x(svptrue_b64(), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pmax<PropagateNumbers, PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svmaxnm_f64_x(svptrue_b64(), a, b);
+}
+
+// Comparisons in SVE return a predicate. Use svdup to set active lanes to all
+// ones and inactive lanes to zero, matching the float path above.
+template <>
+EIGEN_STRONG_INLINE PacketXd pcmp_le<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(svdup_n_u64_z(svcmple_f64(svptrue_b64(), a, b), 0xffffffffffffffffull));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pcmp_lt<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(svdup_n_u64_z(svcmplt_f64(svptrue_b64(), a, b), 0xffffffffffffffffull));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pcmp_eq<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(svdup_n_u64_z(svcmpeq_f64(svptrue_b64(), a, b), 0xffffffffffffffffull));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pcmp_lt_or_nan<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(
+      svdup_n_u64_z(svnot_b_z(svptrue_b64(), svcmpge_f64(svptrue_b64(), a, b)), 0xffffffffffffffffull));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pfloor<PacketXd>(const PacketXd& a) {
+  return svrintm_f64_x(svptrue_b64(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXd pceil<PacketXd>(const PacketXd& a) {
+  return svrintp_f64_x(svptrue_b64(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXd print<PacketXd>(const PacketXd& a) {
+  return svrintn_f64_x(svptrue_b64(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXd ptrunc<PacketXd>(const PacketXd& a) {
+  return svrintz_f64_x(svptrue_b64(), a);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXd pround<PacketXd>(const PacketXd& a) {
+  return svrinta_f64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd ptrue<PacketXd>(const PacketXd& /*a*/) {
+  PacketXd r = svreinterpret_f64_u64(svdup_n_u64_x(svptrue_b64(), 0xffffffffffffffffull));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
+}
+
+// Logical operations are not supported for float64, so reinterpret casts.
+template <>
+EIGEN_STRONG_INLINE PacketXd pand<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(svand_u64_x(svptrue_b64(), svreinterpret_u64_f64(a), svreinterpret_u64_f64(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd por<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(svorr_u64_x(svptrue_b64(), svreinterpret_u64_f64(a), svreinterpret_u64_f64(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pxor<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(sveor_u64_x(svptrue_b64(), svreinterpret_u64_f64(a), svreinterpret_u64_f64(b)));
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pandnot<PacketXd>(const PacketXd& a, const PacketXd& b) {
+  return svreinterpret_f64_u64(svbic_u64_x(svptrue_b64(), svreinterpret_u64_f64(a), svreinterpret_u64_f64(b)));
+}
+
+// See pselect<PacketXi>.
+template <>
+EIGEN_STRONG_INLINE PacketXd pselect<PacketXd>(const PacketXd& mask, const PacketXd& a, const PacketXd& b) {
+  return svsel_f64(svcmpne_n_s64(svptrue_b64(), svreinterpret_s64_f64(mask), 0), a, b);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pload<PacketXd>(const double* from) {
+  EIGEN_DEBUG_ALIGNED_LOAD return svld1_f64(svptrue_b64(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd ploadu<PacketXd>(const double* from) {
+  EIGEN_DEBUG_UNALIGNED_LOAD return svld1_f64(svptrue_b64(), from);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd ploaddup<PacketXd>(const double* from) {
+  // Load the size/2 values this reads into the low half and interleave them
+  // with themselves: svzip1 only consumes the low halves of its operands.
+  // The predicate is exact rather than svptrue -- ploaddup may only touch
+  // size/2 elements, and a wider one would read past the end of the input.
+  constexpr uint64_t kHalf = uint64_t(packet_traits<double>::size) / 2;
+  svfloat64_t lo = svld1_f64(svwhilelt_b64(uint64_t(0), kHalf), from);
+  return svzip1_f64(lo, lo);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd ploadquad<PacketXd>(const double* from) {
+  // As ploaddup, one zip further: size/4 values, each repeated four times.
+  // At the smallest vector length size/4 rounds to zero, where one element
+  // still has to be read.
+  constexpr uint64_t kQuarter = numext::maxi(uint64_t(packet_traits<double>::size) / 4, uint64_t(1));
+  svfloat64_t lo = svld1_f64(svwhilelt_b64(uint64_t(0), kQuarter), from);
+  lo = svzip1_f64(lo, lo);
+  return svzip1_f64(lo, lo);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstore<double>(double* to, const PacketXd& from) {
+  EIGEN_DEBUG_ALIGNED_STORE svst1_f64(svptrue_b64(), to, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE void pstoreu<double>(double* to, const PacketXd& from) {
+  EIGEN_DEBUG_UNALIGNED_STORE svst1_f64(svptrue_b64(), to, from);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline PacketXd pgather<double, PacketXd>(const double* from, Index stride) {
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint64_t indices = svindex_s64(0, stride);
+  return svld1_gather_s64index_f64(svptrue_b64(), from, indices);
+}
+
+template <>
+EIGEN_DEVICE_FUNC inline void pscatter<double, PacketXd>(double* to, const PacketXd& from, Index stride) {
+  // Index format: {base=0, base+stride, base+stride*2, base+stride*3, ...}
+  svint64_t indices = svindex_s64(0, stride);
+  svst1_scatter_s64index_f64(svptrue_b64(), to, indices, from);
+}
+
+template <>
+EIGEN_STRONG_INLINE double pfirst<PacketXd>(const PacketXd& a) {
+  // svlasta returns the first element if all predicate bits are 0
+  return svlasta_f64(svpfalse_b(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd preverse(const PacketXd& a) {
+  return svrev_f64(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pabs(const PacketXd& a) {
+  return svabs_f64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux<PacketXd>(const PacketXd& a) {
+  return svaddv_f64(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const PacketXd& a) {
+  const svuint64_t bits = svreinterpret_u64_f64(a);
+  return svptest_any(svptrue_b64(), svcmpne_n_u64(svptrue_b64(), bits, 0));
+}
+
+template <>
+EIGEN_STRONG_INLINE bool predux_all(const PacketXd& a) {
+  const svbool_t all = svptrue_b64();
+  return !svptest_any(all, svcmpeq_n_f64(all, a, 0.0));
+}
+
+template <>
+EIGEN_STRONG_INLINE Index predux_count(const PacketXd& a) {
+  const svbool_t all = svptrue_b64();
+  return static_cast<Index>(svcntp_b64(all, svcmpne_n_f64(all, a, 0.0)));
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux_mul<PacketXd>(const PacketXd& a) {
+  // Multiply the vector by its reverse.
+  svfloat64_t prod = svmul_f64_x(svptrue_b64(), a, svrev_f64(a));
+
+  // Reduce with interleave-and-multiply.
+  // NOTE: Skip the final reduction since it is already handled by `rev` above.
+  for (int n = unpacket_traits<PacketXd>::size; n > 2; n >>= 1)
+    prod = svmul_f64_x(svptrue_b64(), svzip1_f64(prod, prod), svzip2_f64(prod, prod));
+
+  // The reduction is done to the first element.
+  return pfirst<PacketXd>(prod);
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux_min<PacketXd>(const PacketXd& a) {
+  return svminv_f64(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE double predux_max<PacketXd>(const PacketXd& a) {
+  return svmaxv_f64(svptrue_b64(), a);
+}
+
+template <int N>
+EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<PacketXd, N>& kernel) {
+  EIGEN_STATIC_ASSERT((N & (N - 1)) == 0, EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT);
+  for (int stride = N / 2; stride > 0; stride >>= 1) {
+    for (int block = 0; block < N; block += 2 * stride) {
+      for (int k = 0; k < stride; ++k) {
+        PacketXd lo = svzip1_f64(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        PacketXd hi = svzip2_f64(kernel.packet[block + k], kernel.packet[block + k + stride]);
+        kernel.packet[block + k] = lo;
+        kernel.packet[block + k + stride] = hi;
+      }
+    }
+  }
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pfrexp<PacketXd>(const PacketXd& a, PacketXd& exponent) {
+  return pfrexp_generic(a, exponent);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pldexp<PacketXd>(const PacketXd& a, const PacketXd& exponent) {
+  return pldexp_generic(a, exponent);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd psqrt<PacketXd>(const PacketXd& a) {
+  return svsqrt_f64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd prsqrt<PacketXd>(const PacketXd& a) {
+  // Newton off the FRSQRTE seed, as NEON's Packet2d does. The generic
+  // preciprocal(psqrt(x)) form is correct but pays a double-precision FDIV,
+  // which is slow enough here to lose to the scalar loop.
+  return generic_rsqrt_newton_step<PacketXd, /*Steps=*/3>::run(a, svrsqrte_f64(a));
+}
+
 }  // namespace internal
 }  // namespace Eigen
 
diff --git a/Eigen/src/Core/arch/SVE/TypeCasting.h b/Eigen/src/Core/arch/SVE/TypeCasting.h
index c7027b3..323cb35 100644
--- a/Eigen/src/Core/arch/SVE/TypeCasting.h
+++ b/Eigen/src/Core/arch/SVE/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_SVE_H
 #define EIGEN_TYPE_CASTING_SVE_H
@@ -46,6 +47,36 @@
   return svreinterpret_s32_f32(a);
 }
 
+template <>
+struct type_casting_traits<double, numext::int64_t> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+struct type_casting_traits<numext::int64_t, double> {
+  enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
+};
+
+template <>
+EIGEN_STRONG_INLINE PacketXd pcast<PacketXl, PacketXd>(const PacketXl& a) {
+  return svcvt_f64_s64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl pcast<PacketXd, PacketXl>(const PacketXd& a) {
+  return svcvt_s64_f64_x(svptrue_b64(), a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXd preinterpret<PacketXd, PacketXl>(const PacketXl& a) {
+  return svreinterpret_f64_s64(a);
+}
+
+template <>
+EIGEN_STRONG_INLINE PacketXl preinterpret<PacketXl, PacketXd>(const PacketXd& a) {
+  return svreinterpret_s64_f64(a);
+}
+
 }  // namespace internal
 }  // namespace Eigen
 
diff --git a/Eigen/src/Core/arch/SYCL/InteropHeaders.h b/Eigen/src/Core/arch/SYCL/InteropHeaders.h
index 0bdf825..12c30d4 100644
--- a/Eigen/src/Core/arch/SYCL/InteropHeaders.h
+++ b/Eigen/src/Core/arch/SYCL/InteropHeaders.h
@@ -9,6 +9,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 /*****************************************************************
  * InteropHeaders.h
@@ -95,11 +97,9 @@
 // Make sure this is only available when targeting a GPU: we don't want to
 // introduce conflicts between these packet_traits definitions and the ones
 // we'll use on the host side (SSE, AVX, ...)
-#define SYCL_ARITHMETIC(packet_type)  \
-  template <>                         \
-  struct is_arithmetic<packet_type> { \
-    enum { value = true };            \
-  };
+#define SYCL_ARITHMETIC(packet_type) \
+  template <>                        \
+  struct is_arithmetic<packet_type> : std::true_type {};
 SYCL_ARITHMETIC(cl::sycl::cl_half8)
 SYCL_ARITHMETIC(cl::sycl::cl_float4)
 SYCL_ARITHMETIC(cl::sycl::cl_double2)
@@ -134,15 +134,15 @@
 struct PacketWrapper {
   typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
-  EIGEN_DEVICE_FUNC static Scalar scalarize(Index, PacketReturnType&) {
-    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
+  EIGEN_DEVICE_FUNC static Scalar scalarize(Index, const PacketReturnType&) {
+    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR THE CHOSEN TYPE");
     abort();
   }
   EIGEN_DEVICE_FUNC static PacketReturnType convert_to_packet_type(Scalar in, Scalar) {
     return ::Eigen::internal::template plset<PacketReturnType>(in);
   }
-  EIGEN_DEVICE_FUNC static void set_packet(PacketReturnType, Scalar*) {
-    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
+  EIGEN_DEVICE_FUNC static void set_packet(PacketReturnType&, Scalar*) {
+    eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR THE CHOSEN TYPE");
     abort();
   }
 };
@@ -152,7 +152,7 @@
 struct PacketWrapper<PacketReturnType, 4> {
   typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType& in) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, const PacketReturnType& in) {
     switch (index) {
       case 0:
         return in.x();
@@ -163,7 +163,7 @@
       case 3:
         return in.w();
       default:
-        // INDEX MUST BE BETWEEN 0 and 3.There is no abort function in SYCL kernel. so we cannot use abort here.
+        // INDEX MUST BE BETWEEN 0 and 3. There is no abort function in SYCL kernel. so we cannot use abort here.
         //  The code will never reach here
         __builtin_unreachable();
     }
@@ -182,7 +182,7 @@
 struct PacketWrapper<PacketReturnType, 1> {
   typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index, PacketReturnType& in) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index, const PacketReturnType& in) {
     return in;
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in, Scalar) {
@@ -195,14 +195,14 @@
 struct PacketWrapper<PacketReturnType, 2> {
   typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType& in) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, const PacketReturnType& in) {
     switch (index) {
       case 0:
         return in.x();
       case 1:
         return in.y();
       default:
-        // INDEX MUST BE BETWEEN 0 and 1.There is no abort function in SYCL kernel. so we cannot use abort here.
+        // INDEX MUST BE BETWEEN 0 and 1. There is no abort function in SYCL kernel. so we cannot use abort here.
         // The code will never reach here
         __builtin_unreachable();
     }
diff --git a/Eigen/src/Core/arch/SYCL/MathFunctions.h b/Eigen/src/Core/arch/SYCL/MathFunctions.h
index 90d6066..239aee9 100644
--- a/Eigen/src/Core/arch/SYCL/MathFunctions.h
+++ b/Eigen/src/Core/arch/SYCL/MathFunctions.h
@@ -9,6 +9,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 /*****************************************************************
  * MathFunctions.h
diff --git a/Eigen/src/Core/arch/SYCL/PacketMath.h b/Eigen/src/Core/arch/SYCL/PacketMath.h
index e5dad3c..0c1bba8 100644
--- a/Eigen/src/Core/arch/SYCL/PacketMath.h
+++ b/Eigen/src/Core/arch/SYCL/PacketMath.h
@@ -9,6 +9,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 /*****************************************************************
  * PacketMath.h
@@ -308,6 +310,21 @@
 }
 
 template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool predux_any(const cl::sycl::cl_half8& a) {
+  return cl::sycl::any(a.template as<cl::sycl::cl_short8>() != cl::sycl::cl_short8(0));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool predux_any(const cl::sycl::cl_float4& a) {
+  return cl::sycl::any(a.template as<cl::sycl::cl_int4>() != cl::sycl::cl_int4(0));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool predux_any(const cl::sycl::cl_double2& a) {
+  return cl::sycl::any(a.template as<cl::sycl::cl_long2>() != cl::sycl::cl_long2(0));
+}
+
+template <>
 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Eigen::half predux_max<cl::sycl::cl_half8>(const cl::sycl::cl_half8& a) {
   return Eigen::half(cl::sycl::fmax(cl::sycl::fmax(cl::sycl::fmax(a.s0(), a.s1()), cl::sycl::fmax(a.s2(), a.s3())),
                                     cl::sycl::fmax(cl::sycl::fmax(a.s4(), a.s5()), cl::sycl::fmax(a.s6(), a.s7()))));
diff --git a/Eigen/src/Core/arch/SYCL/TypeCasting.h b/Eigen/src/Core/arch/SYCL/TypeCasting.h
index 6e3fa4f..2c8fd51 100644
--- a/Eigen/src/Core/arch/SYCL/TypeCasting.h
+++ b/Eigen/src/Core/arch/SYCL/TypeCasting.h
@@ -9,6 +9,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 /*****************************************************************
  * TypeCasting.h
diff --git a/Eigen/src/Core/arch/ZVector/Complex.h b/Eigen/src/Core/arch/ZVector/Complex.h
index 048b598..459e052 100644
--- a/Eigen/src/Core/arch/ZVector/Complex.h
+++ b/Eigen/src/Core/arch/ZVector/Complex.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX32_ZVECTOR_H
 #define EIGEN_COMPLEX32_ZVECTOR_H
@@ -18,6 +19,8 @@
 
 namespace internal {
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+
 #if !defined(__ARCH__) || (defined(__ARCH__) && __ARCH__ >= 12)
 inline Packet4ui p4ui_CONJ_XOR() {
   return Packet4ui{0x00000000, 0x80000000, 0x00000000,
@@ -214,10 +217,6 @@
   return Packet1cd(vec_and(a.v, vec_nor(b.v, b.v)));
 }
 template <>
-EIGEN_STRONG_INLINE Packet1cd ploaddup<Packet1cd>(const std::complex<double>* from) {
-  return pset1<Packet1cd>(*from);
-}
-template <>
 EIGEN_STRONG_INLINE Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
   Packet2d eq = vec_cmpeq(a.v, b.v);
   Packet2d tmp = {eq[1], eq[0]};
@@ -237,18 +236,6 @@
   return res;
 }
 
-template <>
-EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) {
-  return pfirst(a);
-}
 EIGEN_MAKE_CONJ_HELPER_CPLX_REAL(Packet1cd, Packet2d)
 
 template <>
@@ -526,6 +513,8 @@
 
 #endif
 
+EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/arch/ZVector/MathFunctions.h b/Eigen/src/Core/arch/ZVector/MathFunctions.h
index 348d643..64cd35f 100644
--- a/Eigen/src/Core/arch/ZVector/MathFunctions.h
+++ b/Eigen/src/Core/arch/ZVector/MathFunctions.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /* The sin, cos, exp, and log functions of this file come from
  * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
diff --git a/Eigen/src/Core/arch/ZVector/PacketMath.h b/Eigen/src/Core/arch/ZVector/PacketMath.h
index 4ccda87..19ece0f 100644
--- a/Eigen/src/Core/arch/ZVector/PacketMath.h
+++ b/Eigen/src/Core/arch/ZVector/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_ZVECTOR_H
 #define EIGEN_PACKET_MATH_ZVECTOR_H
@@ -129,16 +130,8 @@
             8);  //{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 };
 static Packet16uc p16uc_PSET32_WEVEN = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc)vec_splat((Packet4ui)p16uc_FORWARD, 3),
                                                8);  //{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 };
-/*static Packet16uc p16uc_HALF64_0_16 = vec_sld((Packet16uc)p4i_ZERO, vec_splat((Packet16uc) vec_abs(p4i_MINUS16), 3),
-8);      //{ 0,0,0,0, 0,0,0,0, 16,16,16,16, 16,16,16,16};
-
-static Packet16uc p16uc_PSET64_HI = (Packet16uc) vec_mergeh((Packet4ui)p16uc_PSET32_WODD,
-(Packet4ui)p16uc_PSET32_WEVEN);     //{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 };*/
 static Packet16uc p16uc_PSET64_LO = (Packet16uc)vec_mergel(
     (Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN);  //{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 };
-/*static Packet16uc p16uc_TRANSPOSE64_HI = vec_add(p16uc_PSET64_HI, p16uc_HALF64_0_16); //{ 0,1,2,3, 4,5,6,7,
-16,17,18,19, 20,21,22,23}; static Packet16uc p16uc_TRANSPOSE64_LO = vec_add(p16uc_PSET64_LO, p16uc_HALF64_0_16); //{
-8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31};*/
 static Packet16uc p16uc_TRANSPOSE64_HI = {0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23};
 static Packet16uc p16uc_TRANSPOSE64_LO = {8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 31};
 
@@ -456,15 +449,6 @@
 }
 
 template <>
-EIGEN_STRONG_INLINE Packet4i pconj(const Packet4i& a) {
-  return a;
-}
-template <>
-EIGEN_STRONG_INLINE Packet2d pconj(const Packet2d& a) {
-  return a;
-}
-
-template <>
 EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) {
   return padd<Packet4i>(pmul<Packet4i>(a, b), c);
 }
@@ -549,6 +533,18 @@
 EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(const Packet2d& a) {
   return vec_floor(a);
 }
+template <>
+EIGEN_STRONG_INLINE Packet2d print<Packet2d>(const Packet2d& a) {
+  return __builtin_s390_vfidb(a, 4, 5);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2d ptrunc<Packet2d>(const Packet2d& a) {
+  return __builtin_s390_vfidb(a, 4, 4);
+}
+template <>
+EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan<Packet2d>(const Packet2d& a, const Packet2d& b) {
+  return pnot(pcmp_le(b, a));
+}
 
 template <>
 EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from) {
@@ -671,6 +667,12 @@
   return pfirst(sum);
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet2d& a) {
+  const Packet2ul zero = {0, 0};
+  return vec_any_ne(reinterpret_cast<Packet2ul>(a), zero);
+}
+
 // Other reduction functions:
 // mul
 template <>
@@ -939,6 +941,20 @@
   res.v4f[1] = vec_floor(a.v4f[1]);
   return res;
 }
+template <>
+EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a) {
+  Packet4f res;
+  res.v4f[0] = print(a.v4f[0]);
+  res.v4f[1] = print(a.v4f[1]);
+  return res;
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f ptrunc<Packet4f>(const Packet4f& a) {
+  Packet4f res;
+  res.v4f[0] = ptrunc(a.v4f[0]);
+  res.v4f[1] = ptrunc(a.v4f[1]);
+  return res;
+}
 
 template <>
 EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(const float* from) {
@@ -980,6 +996,11 @@
 }
 
 template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4f& a) {
+  return predux_any(a.v4f[0]) | predux_any(a.v4f[1]);
+}
+
+template <>
 EIGEN_STRONG_INLINE float predux_mul<Packet4f>(const Packet4f& a) {
   // Return predux_mul<Packet2d> of the subvectors product
   return static_cast<float>(pfirst(predux_mul(pmul(a.v4f[0], a.v4f[1]))));
@@ -1063,6 +1084,13 @@
   res.v4f[1] = pcmp_eq(a.v4f[1], b.v4f[1]);
   return res;
 }
+template <>
+Packet4f EIGEN_STRONG_INLINE pcmp_lt_or_nan<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  Packet4f res;
+  res.v4f[0] = pcmp_lt_or_nan(a.v4f[0], b.v4f[0]);
+  res.v4f[1] = pcmp_lt_or_nan(a.v4f[1], b.v4f[1]);
+  return res;
+}
 
 #else
 template <>
@@ -1132,10 +1160,6 @@
   return (-a);
 }
 template <>
-EIGEN_STRONG_INLINE Packet4f pconj<Packet4f>(const Packet4f& a) {
-  return a;
-}
-template <>
 EIGEN_STRONG_INLINE Packet4f pmadd<Packet4f>(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
   return vec_madd(a, b, c);
 }
@@ -1177,6 +1201,18 @@
   return vec_floor(a);
 }
 template <>
+EIGEN_STRONG_INLINE Packet4f print<Packet4f>(const Packet4f& a) {
+  return __builtin_s390_vfisb(a, 4, 5);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f ptrunc<Packet4f>(const Packet4f& a) {
+  return __builtin_s390_vfisb(a, 4, 4);
+}
+template <>
+EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan<Packet4f>(const Packet4f& a, const Packet4f& b) {
+  return pnot(pcmp_le(b, a));
+}
+template <>
 EIGEN_STRONG_INLINE Packet4f pabs<Packet4f>(const Packet4f& a) {
   return vec_abs(a);
 }
@@ -1209,6 +1245,12 @@
   return pfirst(sum);
 }
 
+template <>
+EIGEN_STRONG_INLINE bool predux_any(const Packet4f& a) {
+  const Packet4ui zero = {0, 0, 0, 0};
+  return vec_any_ne(reinterpret_cast<Packet4ui>(a), zero);
+}
+
 // Other reduction functions:
 // mul
 template <>
diff --git a/Eigen/src/Core/arch/clang/Complex.h b/Eigen/src/Core/arch/clang/Complex.h
index cfcc229..6ef895a 100644
--- a/Eigen/src/Core/arch/clang/Complex.h
+++ b/Eigen/src/Core/arch/clang/Complex.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_CLANG_H
 #define EIGEN_COMPLEX_CLANG_H
@@ -33,16 +34,6 @@
 using PacketXcf = complex_packet_wrapper<float, kComplexFloatSize>;
 using PacketXcd = complex_packet_wrapper<double, kComplexDoubleSize>;
 
-// Sub-packet types needed for reductions at larger sizes.
-// When PacketXcf IS already a given size, we skip the alias to avoid duplicates.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
-using Packet2cf = complex_packet_wrapper<float, 2>;
-#endif
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-using Packet4cf = complex_packet_wrapper<float, 4>;
-using Packet2cd = complex_packet_wrapper<double, 2>;
-#endif
-
 struct generic_complex_packet_traits : default_packet_traits {
   enum {
     Vectorizable = 1,
@@ -129,53 +120,99 @@
 EIGEN_CLANG_COMPLEX_LOAD_STORE(PacketXcd);
 #undef EIGEN_CLANG_COMPLEX_LOAD_STORE
 
+namespace detail {
+
+// Index sequence over the real components -- two per complex value -- of a
+// complex packet. Index Is names component Is % 2 of complex value Is / 2.
+template <typename ComplexPacket>
+using complex_real_indices = vector_indices<typename ComplexPacket::RealPacketT>;
+
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_pset1_impl(const typename unpacket_traits<ComplexPacket>::type& from,
+                                                     std::index_sequence<Is...>) {
+  using RealPacket = typename ComplexPacket::RealPacketT;
+  using RealScalar = scalar_type_of_vector_t<RealPacket>;
+  const RealScalar re = numext::real(from);
+  const RealScalar im = numext::imag(from);
+  return ComplexPacket(RealPacket{(Is % 2 == 0 ? re : im)...});
+}
+
+// Negates the imaginary parts by flipping their sign bits with one xor; the
+// negate-and-shuffle alternative costs an extra blend.
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_pconj_impl(const ComplexPacket& a, std::index_sequence<Is...>) {
+  using RealScalar = scalar_type_of_vector_t<typename ComplexPacket::RealPacketT>;
+  using IntScalar = std::conditional_t<sizeof(RealScalar) == 4, int32_t, int64_t>;
+  using IntPacket = VectorType<IntScalar, sizeof...(Is)>;
+  const IntPacket sign_mask = {(Is % 2 == 0 ? IntScalar(0) : (std::numeric_limits<IntScalar>::min)())...};
+  return ComplexPacket(
+      reinterpret_cast<typename ComplexPacket::RealPacketT>(reinterpret_cast<IntPacket>(a.v) ^ sign_mask));
+}
+
+// {re, im} -> {im, re}.
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_pcplxflip_impl(const ComplexPacket& a, std::index_sequence<Is...>) {
+  return ComplexPacket(__builtin_shufflevector(a.v, a.v, (2 * (Is / 2) + (1 - Is % 2))...));
+}
+
+// {re, im} -> {re, re}.
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_pdupreal_impl(const ComplexPacket& a, std::index_sequence<Is...>) {
+  return ComplexPacket(__builtin_shufflevector(a.v, a.v, (2 * (Is / 2))...));
+}
+
+// {re, im} -> {im, im}.
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_pdupimag_impl(const ComplexPacket& a, std::index_sequence<Is...>) {
+  return ComplexPacket(__builtin_shufflevector(a.v, a.v, (2 * (Is / 2) + 1)...));
+}
+
+// (a + ib)(c + id) = (ac - bd) + i(ad + bc), as an even/odd merge of the
+// difference and sum vectors. Both products are spelled inside one expression
+// each so fp-contract may fuse them, and the merge of a same-operand sub and
+// add is the pattern LLVM folds into a single fmaddsub-style instruction on
+// targets that have one. This matches the handwritten x86 backends, unlike
+// the conjugate-and-flip formulation of the generic pmul_complex.
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_pmul_impl(const ComplexPacket& x, const ComplexPacket& y,
+                                                    std::index_sequence<Is...> is) {
+  using RealPacket = typename ComplexPacket::RealPacketT;
+  const RealPacket x_re = complex_pdupreal_impl(x, is).v;
+  const RealPacket t = complex_pdupimag_impl(x, is).v * complex_pcplxflip_impl(y, is).v;
+  const RealPacket sub = x_re * y.v - t;
+  const RealPacket add = x_re * y.v + t;
+  return ComplexPacket(__builtin_shufflevector(sub, add, (Is % 2 == 0 ? Is : sizeof...(Is) + Is)...));
+}
+
+// Loads each complex value Repeat times in a row: Repeat == 2 implements
+// ploaddup and Repeat == 4 implements ploadquad.
+template <std::size_t Repeat, typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_loadrepeat_impl(const typename unpacket_traits<ComplexPacket>::type* from,
+                                                          std::index_sequence<Is...>) {
+  using RealPacket = typename ComplexPacket::RealPacketT;
+  return ComplexPacket(
+      RealPacket{(Is % 2 == 0 ? numext::real(from[Is / (2 * Repeat)]) : numext::imag(from[Is / (2 * Repeat)]))...});
+}
+
+// Reverses the complex values, keeping each real/imaginary pair together.
+template <typename ComplexPacket, std::size_t... Is>
+EIGEN_STRONG_INLINE ComplexPacket complex_preverse_impl(const ComplexPacket& a, std::index_sequence<Is...>) {
+  constexpr std::size_t kLastValue = sizeof...(Is) - 2;
+  return ComplexPacket(__builtin_shufflevector(a.v, a.v, (kLastValue - 2 * (Is / 2) + Is % 2)...));
+}
+
+}  // namespace detail
+
 // --- pset1 for complex ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
+#define EIGEN_CLANG_COMPLEX_SET1(PACKET_TYPE)                                                          \
+  template <>                                                                                          \
+  EIGEN_STRONG_INLINE PACKET_TYPE pset1<PACKET_TYPE>(const unpacket_traits<PACKET_TYPE>::type& from) { \
+    return detail::complex_pset1_impl<PACKET_TYPE>(from, detail::complex_real_indices<PACKET_TYPE>{}); \
+  }
 
-template <>
-EIGEN_STRONG_INLINE PacketXcf pset1<PacketXcf>(const std::complex<float>& from) {
-  const float re = numext::real(from);
-  const float im = numext::imag(from);
-  return PacketXcf(PacketXf{re, im, re, im});
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pset1<PacketXcd>(const std::complex<double>& from) {
-  const double re = numext::real(from);
-  const double im = numext::imag(from);
-  return PacketXcd(PacketXd{re, im});
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pset1<PacketXcf>(const std::complex<float>& from) {
-  const float re = numext::real(from);
-  const float im = numext::imag(from);
-  return PacketXcf(PacketXf{re, im, re, im, re, im, re, im});
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pset1<PacketXcd>(const std::complex<double>& from) {
-  const double re = numext::real(from);
-  const double im = numext::imag(from);
-  return PacketXcd(PacketXd{re, im, re, im});
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pset1<PacketXcf>(const std::complex<float>& from) {
-  const float re = numext::real(from);
-  const float im = numext::imag(from);
-  return PacketXcf(PacketXf{re, im, re, im, re, im, re, im, re, im, re, im, re, im, re, im});
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pset1<PacketXcd>(const std::complex<double>& from) {
-  const double re = numext::real(from);
-  const double im = numext::imag(from);
-  return PacketXcd(PacketXd{re, im, re, im, re, im, re, im});
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+EIGEN_CLANG_COMPLEX_SET1(PacketXcf)
+EIGEN_CLANG_COMPLEX_SET1(PacketXcd)
+#undef EIGEN_CLANG_COMPLEX_SET1
 
 // ----------- Unary ops ------------------
 #define DELEGATE_UNARY_TO_REAL_OP(PACKET_TYPE, OP)                        \
@@ -196,345 +233,57 @@
 EIGEN_CLANG_COMPLEX_UNARY_CWISE_OPS(PacketXcf);
 EIGEN_CLANG_COMPLEX_UNARY_CWISE_OPS(PacketXcd);
 
-// --- pconj ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pconj<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, -a.v, 0, 5, 2, 7));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pconj<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, -a.v, 0, 3));
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pconj<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, -a.v, 0, 9, 2, 11, 4, 13, 6, 15));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pconj<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, -a.v, 0, 5, 2, 7));
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pconj<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, -a.v, 0, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 29, 14, 31));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pconj<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, -a.v, 0, 9, 2, 11, 4, 13, 6, 15));
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// Sub-packet pconj specializations needed for reductions.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
-template <>
-EIGEN_STRONG_INLINE Packet2cf pconj<Packet2cf>(const Packet2cf& a) {
-  return Packet2cf(__builtin_shufflevector(a.v, -a.v, 0, 5, 2, 7));
-}
-#endif
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-template <>
-EIGEN_STRONG_INLINE Packet4cf pconj<Packet4cf>(const Packet4cf& a) {
-  return Packet4cf(__builtin_shufflevector(a.v, -a.v, 0, 9, 2, 11, 4, 13, 6, 15));
-}
-template <>
-EIGEN_STRONG_INLINE Packet2cd pconj<Packet2cd>(const Packet2cd& a) {
-  return Packet2cd(__builtin_shufflevector(a.v, -a.v, 0, 5, 2, 7));
-}
-#endif
-
 #undef DELEGATE_UNARY_TO_REAL_OP
 #undef EIGEN_CLANG_COMPLEX_UNARY_CWISE_OPS
 
-// Flip real and imaginary parts, i.e.  {re(a), im(a)} -> {im(a), re(a)}.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
+// --- Operations that rearrange the real and imaginary lanes ---
+#define EIGEN_CLANG_COMPLEX_LANE_OPS(PACKET_TYPE)                                          \
+  template <>                                                                              \
+  EIGEN_STRONG_INLINE PACKET_TYPE pconj<PACKET_TYPE>(const PACKET_TYPE& a) {               \
+    return detail::complex_pconj_impl(a, detail::complex_real_indices<PACKET_TYPE>{});     \
+  }                                                                                        \
+  template <>                                                                              \
+  EIGEN_STRONG_INLINE PACKET_TYPE pcplxflip<PACKET_TYPE>(const PACKET_TYPE& a) {           \
+    return detail::complex_pcplxflip_impl(a, detail::complex_real_indices<PACKET_TYPE>{}); \
+  }                                                                                        \
+  template <>                                                                              \
+  EIGEN_STRONG_INLINE PACKET_TYPE pdupreal<PACKET_TYPE>(const PACKET_TYPE& a) {            \
+    return detail::complex_pdupreal_impl(a, detail::complex_real_indices<PACKET_TYPE>{});  \
+  }                                                                                        \
+  template <>                                                                              \
+  EIGEN_STRONG_INLINE PACKET_TYPE pdupimag<PACKET_TYPE>(const PACKET_TYPE& a) {            \
+    return detail::complex_pdupimag_impl(a, detail::complex_real_indices<PACKET_TYPE>{});  \
+  }
 
-template <>
-EIGEN_STRONG_INLINE PacketXcf pcplxflip<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pcplxflip<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 1, 0));
-}
+EIGEN_CLANG_COMPLEX_LANE_OPS(PacketXcf)
+EIGEN_CLANG_COMPLEX_LANE_OPS(PacketXcd)
+#undef EIGEN_CLANG_COMPLEX_LANE_OPS
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
+// --- ploaddup and ploadquad ---
+#define EIGEN_CLANG_COMPLEX_LOAD_REPEAT(PACKET_TYPE)                                                           \
+  template <>                                                                                                  \
+  EIGEN_STRONG_INLINE PACKET_TYPE ploaddup<PACKET_TYPE>(const unpacket_traits<PACKET_TYPE>::type* from) {      \
+    return detail::complex_loadrepeat_impl<2, PACKET_TYPE>(from, detail::complex_real_indices<PACKET_TYPE>{}); \
+  }                                                                                                            \
+  template <>                                                                                                  \
+  EIGEN_STRONG_INLINE PACKET_TYPE ploadquad<PACKET_TYPE>(const unpacket_traits<PACKET_TYPE>::type* from) {     \
+    return detail::complex_loadrepeat_impl<4, PACKET_TYPE>(from, detail::complex_real_indices<PACKET_TYPE>{}); \
+  }
 
-template <>
-EIGEN_STRONG_INLINE PacketXcf pcplxflip<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2, 5, 4, 7, 6));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pcplxflip<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2));
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pcplxflip<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pcplxflip<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2, 5, 4, 7, 6));
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// Sub-packet pcplxflip specializations needed for reductions.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
-template <>
-EIGEN_STRONG_INLINE Packet2cf pcplxflip<Packet2cf>(const Packet2cf& a) {
-  return Packet2cf(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2));
-}
-#endif
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-template <>
-EIGEN_STRONG_INLINE Packet4cf pcplxflip<Packet4cf>(const Packet4cf& a) {
-  return Packet4cf(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2, 5, 4, 7, 6));
-}
-template <>
-EIGEN_STRONG_INLINE Packet2cd pcplxflip<Packet2cd>(const Packet2cd& a) {
-  return Packet2cd(__builtin_shufflevector(a.v, a.v, 1, 0, 3, 2));
-}
-#endif
-
-// Copy real to imaginary part, i.e. {re(a), im(a)} -> {re(a), re(a)}.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pdupreal<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pdupreal<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 0, 0));
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pdupreal<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2, 4, 4, 6, 6));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pdupreal<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2));
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pdupreal<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pdupreal<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2, 4, 4, 6, 6));
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// Sub-packet pdupreal specializations needed for reductions.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
-template <>
-EIGEN_STRONG_INLINE Packet2cf pdupreal<Packet2cf>(const Packet2cf& a) {
-  return Packet2cf(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2));
-}
-#endif
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-template <>
-EIGEN_STRONG_INLINE Packet4cf pdupreal<Packet4cf>(const Packet4cf& a) {
-  return Packet4cf(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2, 4, 4, 6, 6));
-}
-template <>
-EIGEN_STRONG_INLINE Packet2cd pdupreal<Packet2cd>(const Packet2cd& a) {
-  return Packet2cd(__builtin_shufflevector(a.v, a.v, 0, 0, 2, 2));
-}
-#endif
-
-// Copy imaginary to real part, i.e. {re(a), im(a)} -> {im(a), im(a)}.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pdupimag<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pdupimag<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 1, 1));
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pdupimag<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3, 5, 5, 7, 7));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pdupimag<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3));
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf pdupimag<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd pdupimag<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3, 5, 5, 7, 7));
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// Sub-packet pdupimag specializations needed for reductions.
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
-template <>
-EIGEN_STRONG_INLINE Packet2cf pdupimag<Packet2cf>(const Packet2cf& a) {
-  return Packet2cf(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3));
-}
-#endif
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-template <>
-EIGEN_STRONG_INLINE Packet4cf pdupimag<Packet4cf>(const Packet4cf& a) {
-  return Packet4cf(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3, 5, 5, 7, 7));
-}
-template <>
-EIGEN_STRONG_INLINE Packet2cd pdupimag<Packet2cd>(const Packet2cd& a) {
-  return Packet2cd(__builtin_shufflevector(a.v, a.v, 1, 1, 3, 3));
-}
-#endif
-
-// --- ploaddup ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf ploaddup<PacketXcf>(const std::complex<float>* from) {
-  return pset1<PacketXcf>(*from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd ploaddup<PacketXcd>(const std::complex<double>* from) {
-  return pset1<PacketXcd>(*from);
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf ploaddup<PacketXcf>(const std::complex<float>* from) {
-  return PacketXcf(PacketXf{std::real(from[0]), std::imag(from[0]), std::real(from[0]), std::imag(from[0]),
-                            std::real(from[1]), std::imag(from[1]), std::real(from[1]), std::imag(from[1])});
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd ploaddup<PacketXcd>(const std::complex<double>* from) {
-  return pset1<PacketXcd>(*from);
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf ploaddup<PacketXcf>(const std::complex<float>* from) {
-  return PacketXcf(PacketXf{std::real(from[0]), std::imag(from[0]), std::real(from[0]), std::imag(from[0]),
-                            std::real(from[1]), std::imag(from[1]), std::real(from[1]), std::imag(from[1]),
-                            std::real(from[2]), std::imag(from[2]), std::real(from[2]), std::imag(from[2]),
-                            std::real(from[3]), std::imag(from[3]), std::real(from[3]), std::imag(from[3])});
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd ploaddup<PacketXcd>(const std::complex<double>* from) {
-  return PacketXcd(PacketXd{std::real(from[0]), std::imag(from[0]), std::real(from[0]), std::imag(from[0]),
-                            std::real(from[1]), std::imag(from[1]), std::real(from[1]), std::imag(from[1])});
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// --- ploadquad ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf ploadquad<PacketXcf>(const std::complex<float>* from) {
-  return pset1<PacketXcf>(*from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd ploadquad<PacketXcd>(const std::complex<double>* from) {
-  return pset1<PacketXcd>(*from);
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf ploadquad<PacketXcf>(const std::complex<float>* from) {
-  return pset1<PacketXcf>(*from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd ploadquad<PacketXcd>(const std::complex<double>* from) {
-  return pset1<PacketXcd>(*from);
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf ploadquad<PacketXcf>(const std::complex<float>* from) {
-  return PacketXcf(PacketXf{std::real(from[0]), std::imag(from[0]), std::real(from[0]), std::imag(from[0]),
-                            std::real(from[0]), std::imag(from[0]), std::real(from[0]), std::imag(from[0]),
-                            std::real(from[1]), std::imag(from[1]), std::real(from[1]), std::imag(from[1]),
-                            std::real(from[1]), std::imag(from[1]), std::real(from[1]), std::imag(from[1])});
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd ploadquad<PacketXcd>(const std::complex<double>* from) {
-  return pset1<PacketXcd>(*from);
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+EIGEN_CLANG_COMPLEX_LOAD_REPEAT(PacketXcf)
+EIGEN_CLANG_COMPLEX_LOAD_REPEAT(PacketXcd)
+#undef EIGEN_CLANG_COMPLEX_LOAD_REPEAT
 
 // --- preverse ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
 template <>
 EIGEN_STRONG_INLINE PacketXcf preverse<PacketXcf>(const PacketXcf& a) {
-  // 2 complex floats: swap pairs (0,1) and (2,3)
-  return PacketXcf(__builtin_shufflevector(a.v, a.v, 2, 3, 0, 1));
+  return detail::complex_preverse_impl(a, detail::complex_real_indices<PacketXcf>{});
 }
 template <>
 EIGEN_STRONG_INLINE PacketXcd preverse<PacketXcd>(const PacketXcd& a) {
-  // 1 complex double: identity
-  return a;
+  return detail::complex_preverse_impl(a, detail::complex_real_indices<PacketXcd>{});
 }
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf preverse<PacketXcf>(const PacketXcf& a) {
-  // 4 complex floats: reverse pairs
-  return PacketXcf(reinterpret_cast<PacketXf>(preverse(reinterpret_cast<PacketXd>(a.v))));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd preverse<PacketXcd>(const PacketXcd& a) {
-  // 2 complex doubles: swap pairs
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 2, 3, 0, 1));
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXcf preverse<PacketXcf>(const PacketXcf& a) {
-  return PacketXcf(reinterpret_cast<PacketXf>(preverse(reinterpret_cast<PacketXd>(a.v))));
-}
-template <>
-EIGEN_STRONG_INLINE PacketXcd preverse<PacketXcd>(const PacketXcd& a) {
-  return PacketXcd(__builtin_shufflevector(a.v, a.v, 6, 7, 4, 5, 2, 3, 0, 1));
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
 // ----------- Binary ops ------------------
 #define DELEGATE_BINARY_TO_REAL_OP(PACKET_TYPE, OP)                                             \
   template <>                                                                                   \
@@ -543,6 +292,7 @@
   }
 
 #define EIGEN_CLANG_COMPLEX_BINARY_CWISE_OPS(PACKET_TYPE)                                            \
+  DELEGATE_BINARY_TO_REAL_OP(PACKET_TYPE, padd)                                                      \
   DELEGATE_BINARY_TO_REAL_OP(PACKET_TYPE, psub)                                                      \
   DELEGATE_BINARY_TO_REAL_OP(PACKET_TYPE, pand)                                                      \
   DELEGATE_BINARY_TO_REAL_OP(PACKET_TYPE, por)                                                       \
@@ -561,25 +311,16 @@
 EIGEN_CLANG_COMPLEX_BINARY_CWISE_OPS(PacketXcf);
 EIGEN_CLANG_COMPLEX_BINARY_CWISE_OPS(PacketXcd);
 
-// Binary ops that are needed on sub-packets for predux and predux_mul.
-#define EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS(PACKET_TYPE)                                 \
-  DELEGATE_BINARY_TO_REAL_OP(PACKET_TYPE, padd)                                                   \
+// The sub-packets complex_predux_mul in Reductions.h recurses through call
+// detail::complex_pmul_impl directly, so only the full packets need pmul.
+#define EIGEN_CLANG_COMPLEX_PMUL(PACKET_TYPE)                                                     \
   template <>                                                                                     \
   EIGEN_STRONG_INLINE PACKET_TYPE pmul<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) { \
-    return pmul_complex(a, b);                                                                    \
+    return detail::complex_pmul_impl(a, b, detail::complex_real_indices<PACKET_TYPE>{});          \
   }
 
-EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS(PacketXcf);
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
-EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS(Packet2cf);
-#endif
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS(Packet4cf);
-#endif
-EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS(PacketXcd);
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 64
-EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS(Packet2cd);
-#endif
+EIGEN_CLANG_COMPLEX_PMUL(PacketXcf);
+EIGEN_CLANG_COMPLEX_PMUL(PacketXcd);
 
 #define EIGEN_CLANG_PACKET_SCATTER_GATHER(PACKET_TYPE)                                                               \
   template <>                                                                                                        \
@@ -608,60 +349,37 @@
 
 #undef DELEGATE_BINARY_TO_REAL_OP
 #undef EIGEN_CLANG_COMPLEX_BINARY_CWISE_OPS
-#undef EIGEN_CLANG_COMPLEX_REDUCER_BINARY_CWISE_OPS
+#undef EIGEN_CLANG_COMPLEX_PMUL
 
 // ------------ ternary ops -------------
+// The mask duplicates each complex value's bits across both real lanes, so
+// selecting per real lane is equivalent to selecting whole complex values.
 template <>
 EIGEN_STRONG_INLINE PacketXcf pselect<PacketXcf>(const PacketXcf& mask, const PacketXcf& a, const PacketXcf& b) {
-  return PacketXcf(reinterpret_cast<PacketXf>(
-      pselect(reinterpret_cast<PacketXd>(mask.v), reinterpret_cast<PacketXd>(a.v), reinterpret_cast<PacketXd>(b.v))));
+  return PacketXcf(pselect(mask.v, a.v, b.v));
+}
+template <>
+EIGEN_STRONG_INLINE PacketXcd pselect<PacketXcd>(const PacketXcd& mask, const PacketXcd& a, const PacketXcd& b) {
+  return PacketXcd(pselect(mask.v, a.v, b.v));
 }
 
 // --- zip_in_place for complex ---
 namespace detail {
 
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
+// Complex packets interleave whole complex values, so their real and imaginary
+// components move together.
 template <>
 EIGEN_ALWAYS_INLINE void zip_in_place<PacketXcf>(PacketXcf& p1, PacketXcf& p2) {
-  PacketXf tmp = __builtin_shufflevector(p1.v, p2.v, 0, 1, 4, 5);
-  p2.v = __builtin_shufflevector(p1.v, p2.v, 2, 3, 6, 7);
-  p1.v = tmp;
+  zip_in_place_impl<2>(p1.v, p2.v, complex_real_indices<PacketXcf>{});
 }
-// PacketXcd at 16 bytes has 1 element, no zip_in_place needed.
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXcf>(PacketXcf& p1, PacketXcf& p2) {
-  PacketXf tmp = __builtin_shufflevector(p1.v, p2.v, 0, 1, 8, 9, 2, 3, 10, 11);
-  p2.v = __builtin_shufflevector(p1.v, p2.v, 4, 5, 12, 13, 6, 7, 14, 15);
-  p1.v = tmp;
-}
+#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
+// PacketXcd holds a single complex value at 16 bytes, so there is nothing to interleave.
 template <>
 EIGEN_ALWAYS_INLINE void zip_in_place<PacketXcd>(PacketXcd& p1, PacketXcd& p2) {
-  PacketXd tmp = __builtin_shufflevector(p1.v, p2.v, 0, 1, 4, 5);
-  p2.v = __builtin_shufflevector(p1.v, p2.v, 2, 3, 6, 7);
-  p1.v = tmp;
+  zip_in_place_impl<2>(p1.v, p2.v, complex_real_indices<PacketXcd>{});
 }
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXcf>(PacketXcf& p1, PacketXcf& p2) {
-  PacketXf tmp = __builtin_shufflevector(p1.v, p2.v, 0, 1, 16, 17, 2, 3, 18, 19, 4, 5, 20, 21, 6, 7, 22, 23);
-  p2.v = __builtin_shufflevector(p1.v, p2.v, 8, 9, 24, 25, 10, 11, 26, 27, 12, 13, 28, 29, 14, 15, 30, 31);
-  p1.v = tmp;
-}
-
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXcd>(PacketXcd& p1, PacketXcd& p2) {
-  PacketXd tmp = __builtin_shufflevector(p1.v, p2.v, 0, 1, 8, 9, 2, 3, 10, 11);
-  p2.v = __builtin_shufflevector(p1.v, p2.v, 4, 5, 12, 13, 6, 7, 14, 15);
-  p1.v = tmp;
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+#endif
 
 }  // namespace detail
 
diff --git a/Eigen/src/Core/arch/clang/MathFunctions.h b/Eigen/src/Core/arch/clang/MathFunctions.h
index c2afeda..22dc04f 100644
--- a/Eigen/src/Core/arch/clang/MathFunctions.h
+++ b/Eigen/src/Core/arch/clang/MathFunctions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATH_FUNCTIONS_CLANG_H
 #define EIGEN_MATH_FUNCTIONS_CLANG_H
diff --git a/Eigen/src/Core/arch/clang/PacketMath.h b/Eigen/src/Core/arch/clang/PacketMath.h
index 8412694..caa1ccb 100644
--- a/Eigen/src/Core/arch/clang/PacketMath.h
+++ b/Eigen/src/Core/arch/clang/PacketMath.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKET_MATH_CLANG_H
 #define EIGEN_PACKET_MATH_CLANG_H
@@ -37,8 +38,8 @@
 //
 // The "X" suffix indicates the element count is determined by the macro
 // EIGEN_GENERIC_VECTOR_SIZE_BYTES at compile time. Operations that require
-// compile-time constant indices (e.g. __builtin_shufflevector) use
-// #if EIGEN_GENERIC_VECTOR_SIZE_BYTES == ... blocks.
+// compile-time constant indices (e.g. __builtin_shufflevector) obtain them by
+// expanding detail::vector_indices<Packet>, so they need no per-size code.
 
 static_assert(EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16 || EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32 ||
                   EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64,
@@ -230,10 +231,35 @@
 using unsigned_vector_t = typename UnsignedVectorHelper<VectorT>::type;
 
 template <typename VectorT>
-using HalfPacket = VectorType<typename unpacket_traits<VectorT>::type, unpacket_traits<VectorT>::size / 2>;
+constexpr int vector_elements() {
+  return static_cast<int>(sizeof(VectorT) / sizeof(scalar_type_of_vector_t<VectorT>));
+}
+
+// Signed integer vector with the same lane count and width, for sign-bit
+// tests and bitwise manipulation of floating-point packets.
+template <typename VectorT>
+struct SignedVectorHelper {
+  using SignedScalar = std::conditional_t<sizeof(scalar_type_of_vector_t<VectorT>) == 4, int32_t, int64_t>;
+  using type = VectorType<SignedScalar, vector_elements<VectorT>()>;
+};
 
 template <typename VectorT>
-using QuarterPacket = VectorType<typename unpacket_traits<VectorT>::type, unpacket_traits<VectorT>::size / 4>;
+using signed_vector_t = typename SignedVectorHelper<VectorT>::type;
+
+template <typename VectorT>
+using half_vector_t = VectorType<scalar_type_of_vector_t<VectorT>, vector_elements<VectorT>() / 2>;
+
+template <typename VectorT>
+using quarter_vector_t = VectorType<scalar_type_of_vector_t<VectorT>, vector_elements<VectorT>() / 4>;
+
+template <typename VectorT>
+using scalar_pair_t = std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>>;
+
+// Index sequence covering every element of VectorT. Expanding it inside a
+// __builtin_shufflevector index list or a braced initializer is what keeps the
+// operations below independent of EIGEN_GENERIC_VECTOR_SIZE_BYTES.
+template <typename VectorT>
+using vector_indices = std::make_index_sequence<vector_elements<VectorT>()>;
 
 // load and store helpers.
 template <typename VectorT>
@@ -245,7 +271,8 @@
 
 template <typename VectorT>
 EIGEN_STRONG_INLINE VectorT load_vector_aligned(const scalar_type_of_vector_t<VectorT>* from) {
-  return *reinterpret_cast<const VectorT*>(assume_aligned<EIGEN_GENERIC_VECTOR_SIZE_BYTES>(from));
+  eigen_assert((std::uintptr_t(from) % alignof(VectorT) == 0) && "load_vector_aligned");
+  return *reinterpret_cast<const VectorT*>(assume_aligned<alignof(VectorT)>(from));
 }
 
 template <typename VectorT>
@@ -255,7 +282,8 @@
 
 template <typename VectorT>
 EIGEN_STRONG_INLINE void store_vector_aligned(scalar_type_of_vector_t<VectorT>* to, const VectorT& from) {
-  *reinterpret_cast<VectorT*>(assume_aligned<EIGEN_GENERIC_VECTOR_SIZE_BYTES>(to)) = from;
+  eigen_assert((std::uintptr_t(to) % alignof(VectorT) == 0) && "store_vector_aligned");
+  *reinterpret_cast<VectorT*>(assume_aligned<alignof(VectorT)>(to)) = from;
 }
 
 }  // namespace detail
@@ -398,9 +426,11 @@
     return PACKET_TYPE(Scalar(0));                                                                   \
   }                                                                                                  \
   template <>                                                                                        \
-  constexpr EIGEN_STRONG_INLINE PACKET_TYPE ptrue<PACKET_TYPE>(const PACKET_TYPE& /* unused */) {    \
+  EIGEN_STRONG_INLINE PACKET_TYPE ptrue<PACKET_TYPE>(const PACKET_TYPE& /* unused */) {              \
     using Scalar = detail::scalar_type_of_vector_t<PACKET_TYPE>;                                     \
-    return numext::bit_cast<PACKET_TYPE>(PACKET_TYPE(Scalar(0)) == PACKET_TYPE(Scalar(0)));          \
+    PACKET_TYPE r = numext::bit_cast<PACKET_TYPE>(PACKET_TYPE(Scalar(0)) == PACKET_TYPE(Scalar(0))); \
+    EIGEN_FAST_MATH_CONSTANT_BARRIER(r);                                                             \
+    return r;                                                                                        \
   }                                                                                                  \
   template <>                                                                                        \
   EIGEN_STRONG_INLINE PACKET_TYPE pand<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {    \
@@ -450,53 +480,145 @@
 EIGEN_CLANG_PACKET_CMP(PacketXd, PacketXl)
 #undef EIGEN_CLANG_PACKET_CMP
 
-// --- Min/Max operations ---
-#if EIGEN_HAS_BUILTIN(__builtin_elementwise_min) && EIGEN_HAS_BUILTIN(__builtin_elementwise_max) && \
-    EIGEN_HAS_BUILTIN(__builtin_elementwise_abs)
-#define EIGEN_CLANG_PACKET_ELEMENTWISE(PACKET_TYPE)                                                                 \
-  template <>                                                                                                       \
-  EIGEN_STRONG_INLINE PACKET_TYPE pmin<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {                   \
-    /* Match NaN propagation of std::min. */                                                                        \
-    return a == a ? __builtin_elementwise_min(a, b) : a;                                                            \
-  }                                                                                                                 \
-  template <>                                                                                                       \
-  EIGEN_STRONG_INLINE PACKET_TYPE pmax<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {                   \
-    /* Match NaN propagation of std::max. */                                                                        \
-    return a == a ? __builtin_elementwise_max(a, b) : a;                                                            \
-  }                                                                                                                 \
+// --- Min/Max/select operations ---
+namespace detail {
+// Functors usable at any vector width; the min/max reduction trees in
+// Reductions.h reuse them on progressively narrower vectors. The
+// compare-select forms compile to a single min/max instruction on targets
+// whose min/max returns the second operand when the inputs are unordered
+// (e.g. x86), and they spell out the NaN propagation of std::min/std::max:
+// the first argument is returned if either input is NaN.
+struct pmin_op {
+  template <typename VectorT>
+  EIGEN_STRONG_INLINE VectorT operator()(const VectorT& a, const VectorT& b) const {
+    return b < a ? b : a;
+  }
+};
+struct pmax_op {
+  template <typename VectorT>
+  EIGEN_STRONG_INLINE VectorT operator()(const VectorT& a, const VectorT& b) const {
+    return b > a ? b : a;
+  }
+};
+// IEEE 754-2008 minNum/maxNum semantics: return the other operand if one input
+// is NaN. Floating-point support in __builtin_elementwise_{min,max} is
+// deprecated because the name does not say which of the several IEEE min/max
+// flavors is meant; __builtin_elementwise_{minnum,maxnum} spell out the same
+// semantics the deprecated builtins provided for floats, and additionally pin
+// down +0.0 > -0.0. The elementwise_{min,max} fallback (always available
+// under this backend's clang >= 16 gate) has the same NaN semantics but
+// leaves the zero-sign tie unspecified.
+struct pmin_num_op {
+  template <typename VectorT>
+  EIGEN_STRONG_INLINE VectorT operator()(const VectorT& a, const VectorT& b) const {
+#if EIGEN_HAS_BUILTIN(__builtin_elementwise_minnum)
+    return __builtin_elementwise_minnum(a, b);
+#else
+    return __builtin_elementwise_min(a, b);
+#endif
+  }
+};
+struct pmax_num_op {
+  template <typename VectorT>
+  EIGEN_STRONG_INLINE VectorT operator()(const VectorT& a, const VectorT& b) const {
+#if EIGEN_HAS_BUILTIN(__builtin_elementwise_maxnum)
+    return __builtin_elementwise_maxnum(a, b);
+#else
+    return __builtin_elementwise_max(a, b);
+#endif
+  }
+};
+// Return NaN if either input is NaN, otherwise the min/max. When a is NaN the
+// plain compare-select form already returns a, so only b needs an explicit
+// test.
+struct pmin_nan_op {
+  template <typename VectorT>
+  EIGEN_STRONG_INLINE VectorT operator()(const VectorT& a, const VectorT& b) const {
+    return b != b ? b : pmin_op()(a, b);
+  }
+};
+struct pmax_nan_op {
+  template <typename VectorT>
+  EIGEN_STRONG_INLINE VectorT operator()(const VectorT& a, const VectorT& b) const {
+    return b != b ? b : pmax_op()(a, b);
+  }
+};
+}  // namespace detail
+
+// pmin/pmax/pselect are pure compare-select code and apply to all packet types.
+#define EIGEN_CLANG_PACKET_MINMAX_SELECT(PACKET_TYPE)                                                 \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_TYPE pmin<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {     \
+    return detail::pmin_op()(a, b);                                                                   \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_TYPE pmax<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {     \
+    return detail::pmax_op()(a, b);                                                                   \
+  }                                                                                                   \
+  template <>                                                                                         \
+  EIGEN_STRONG_INLINE PACKET_TYPE pselect<PACKET_TYPE>(const PACKET_TYPE& mask, const PACKET_TYPE& a, \
+                                                       const PACKET_TYPE& b) {                        \
+    /* The mask is all-ones or all-zeros per lane, so testing the sign of the */                      \
+    /* signed integer view suffices and maps to a single blend instruction.   */                      \
+    /* Unlike a floating-point `mask != 0` test it also survives -ffast-math, */                      \
+    /* which may assume the all-ones NaN bit pattern cannot occur in a float. */                      \
+    return reinterpret_cast<detail::signed_vector_t<PACKET_TYPE>>(mask) < 0 ? a : b;                  \
+  }
+
+EIGEN_CLANG_PACKET_MINMAX_SELECT(PacketXf)
+EIGEN_CLANG_PACKET_MINMAX_SELECT(PacketXd)
+EIGEN_CLANG_PACKET_MINMAX_SELECT(PacketXi)
+EIGEN_CLANG_PACKET_MINMAX_SELECT(PacketXl)
+#undef EIGEN_CLANG_PACKET_MINMAX_SELECT
+
+// NaN-propagation variants for the floating-point packets.
+#define EIGEN_CLANG_PACKET_MINMAX_FLOAT(PACKET_TYPE)                                                                \
   template <>                                                                                                       \
   EIGEN_STRONG_INLINE PACKET_TYPE pmin<PropagateNumbers, PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) { \
-    return __builtin_elementwise_min(a, b);                                                                         \
+    return detail::pmin_num_op()(a, b);                                                                             \
   }                                                                                                                 \
   template <>                                                                                                       \
   EIGEN_STRONG_INLINE PACKET_TYPE pmax<PropagateNumbers, PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) { \
-    return __builtin_elementwise_max(a, b);                                                                         \
+    return detail::pmax_num_op()(a, b);                                                                             \
   }                                                                                                                 \
   template <>                                                                                                       \
   EIGEN_STRONG_INLINE PACKET_TYPE pmin<PropagateNaN, PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {     \
-    return a != a ? a : (b != b ? b : __builtin_elementwise_min(a, b));                                             \
+    return detail::pmin_nan_op()(a, b);                                                                             \
   }                                                                                                                 \
   template <>                                                                                                       \
   EIGEN_STRONG_INLINE PACKET_TYPE pmax<PropagateNaN, PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b) {     \
-    return a != a ? a : (b != b ? b : __builtin_elementwise_max(a, b));                                             \
-  }                                                                                                                 \
-  template <>                                                                                                       \
-  EIGEN_STRONG_INLINE PACKET_TYPE pabs<PACKET_TYPE>(const PACKET_TYPE& a) {                                         \
-    return __builtin_elementwise_abs(a);                                                                            \
-  }                                                                                                                 \
-  template <>                                                                                                       \
-  EIGEN_STRONG_INLINE PACKET_TYPE pselect<PACKET_TYPE>(const PACKET_TYPE& mask, const PACKET_TYPE& a,               \
-                                                       const PACKET_TYPE& b) {                                      \
-    return mask != 0 ? a : b;                                                                                       \
+    return detail::pmax_nan_op()(a, b);                                                                             \
   }
 
-EIGEN_CLANG_PACKET_ELEMENTWISE(PacketXf)
-EIGEN_CLANG_PACKET_ELEMENTWISE(PacketXd)
-EIGEN_CLANG_PACKET_ELEMENTWISE(PacketXi)
-EIGEN_CLANG_PACKET_ELEMENTWISE(PacketXl)
-#undef EIGEN_CLANG_PACKET_ELEMENTWISE
+EIGEN_CLANG_PACKET_MINMAX_FLOAT(PacketXf)
+EIGEN_CLANG_PACKET_MINMAX_FLOAT(PacketXd)
+#undef EIGEN_CLANG_PACKET_MINMAX_FLOAT
+
+#if EIGEN_HAS_BUILTIN(__builtin_elementwise_abs)
+#define EIGEN_CLANG_PACKET_ABS(PACKET_TYPE)                                 \
+  template <>                                                               \
+  EIGEN_STRONG_INLINE PACKET_TYPE pabs<PACKET_TYPE>(const PACKET_TYPE& a) { \
+    return __builtin_elementwise_abs(a);                                    \
+  }
+
+EIGEN_CLANG_PACKET_ABS(PacketXf)
+EIGEN_CLANG_PACKET_ABS(PacketXd)
+EIGEN_CLANG_PACKET_ABS(PacketXi)
+EIGEN_CLANG_PACKET_ABS(PacketXl)
+#undef EIGEN_CLANG_PACKET_ABS
 #endif
 
+// psignbit: a signed compare of the integer view is a single instruction,
+// unlike the generic floating-point fallback.
+template <>
+EIGEN_STRONG_INLINE PacketXf psignbit(const PacketXf& a) {
+  return reinterpret_cast<PacketXf>(reinterpret_cast<PacketXi>(a) < 0);
+}
+template <>
+EIGEN_STRONG_INLINE PacketXd psignbit(const PacketXd& a) {
+  return reinterpret_cast<PacketXd>(reinterpret_cast<PacketXl>(a) < 0);
+}
+
 // --- Math functions (float/double only) ---
 
 #if EIGEN_HAS_BUILTIN(__builtin_elementwise_floor) && EIGEN_HAS_BUILTIN(__builtin_elementwise_ceil) &&      \
@@ -534,7 +656,7 @@
 #endif
 
 // --- Fused Multiply-Add (MADD) ---
-#if defined(__FMA__) && EIGEN_HAS_BUILTIN(__builtin_elementwise_fma)
+#if (defined(EIGEN_VECTORIZE_FMA) || defined(__FMA__)) && EIGEN_HAS_BUILTIN(__builtin_elementwise_fma)
 #define EIGEN_CLANG_PACKET_MADD(PACKET_TYPE)                                                      \
   template <>                                                                                     \
   EIGEN_STRONG_INLINE PACKET_TYPE pmadd<PACKET_TYPE>(const PACKET_TYPE& a, const PACKET_TYPE& b,  \
@@ -614,442 +736,180 @@
 // ---- Various operations that depend on __builtin_shufflevector.
 #if EIGEN_HAS_BUILTIN(__builtin_shufflevector)
 namespace detail {
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet preverse_impl_2(const Packet& a) {
-  return __builtin_shufflevector(a, a, 1, 0);
-}
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet preverse_impl_4(const Packet& a) {
-  return __builtin_shufflevector(a, a, 3, 2, 1, 0);
-}
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet preverse_impl_8(const Packet& a) {
-  return __builtin_shufflevector(a, a, 7, 6, 5, 4, 3, 2, 1, 0);
-}
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet preverse_impl_16(const Packet& a) {
-  return __builtin_shufflevector(a, a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
-}
-}  // namespace detail
 
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXf preverse<PacketXf>(const PacketXf& a) {
-  return detail::preverse_impl_4(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd preverse<PacketXd>(const PacketXd& a) {
-  return detail::preverse_impl_2(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi preverse<PacketXi>(const PacketXi& a) {
-  return detail::preverse_impl_4(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl preverse<PacketXl>(const PacketXl& a) {
-  return detail::preverse_impl_2(a);
+// --- Half / whole vector helpers ---
+template <typename VectorT, std::size_t... Is>
+EIGEN_STRONG_INLINE half_vector_t<VectorT> lower_half_impl(const VectorT& a, std::index_sequence<Is...>) {
+  return __builtin_shufflevector(a, a, Is...);
 }
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXf preverse<PacketXf>(const PacketXf& a) {
-  return detail::preverse_impl_8(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd preverse<PacketXd>(const PacketXd& a) {
-  return detail::preverse_impl_4(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi preverse<PacketXi>(const PacketXi& a) {
-  return detail::preverse_impl_8(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl preverse<PacketXl>(const PacketXl& a) {
-  return detail::preverse_impl_4(a);
+template <typename VectorT, std::size_t... Is>
+EIGEN_STRONG_INLINE half_vector_t<VectorT> upper_half_impl(const VectorT& a, std::index_sequence<Is...>) {
+  return __builtin_shufflevector(a, a, (sizeof...(Is) + Is)...);
 }
 
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXf preverse<PacketXf>(const PacketXf& a) {
-  return detail::preverse_impl_16(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd preverse<PacketXd>(const PacketXd& a) {
-  return detail::preverse_impl_8(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi preverse<PacketXi>(const PacketXi& a) {
-  return detail::preverse_impl_16(a);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl preverse<PacketXl>(const PacketXl& a) {
-  return detail::preverse_impl_8(a);
+template <typename VectorT, typename HalfT, std::size_t... Is>
+EIGEN_STRONG_INLINE VectorT concat_halves_impl(const HalfT& lo, const HalfT& hi, std::index_sequence<Is...>) {
+  return __builtin_shufflevector(lo, hi, Is...);
 }
 
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+template <typename VectorT>
+EIGEN_STRONG_INLINE half_vector_t<VectorT> lower_half(const VectorT& a) {
+  return lower_half_impl(a, vector_indices<half_vector_t<VectorT>>{});
+}
 
-namespace detail {
+template <typename VectorT>
+EIGEN_STRONG_INLINE half_vector_t<VectorT> upper_half(const VectorT& a) {
+  return upper_half_impl(a, vector_indices<half_vector_t<VectorT>>{});
+}
 
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploaddup2(const typename unpacket_traits<Packet>::type* from) {
+template <typename VectorT, typename HalfT>
+EIGEN_STRONG_INLINE VectorT concat_halves(const HalfT& lo, const HalfT& hi) {
+  return concat_halves_impl<VectorT>(lo, hi, vector_indices<VectorT>{});
+}
+
+// --- Width-generic bodies for the packet operations below ---
+template <typename Packet, std::size_t... Is>
+EIGEN_STRONG_INLINE Packet preverse_impl(const Packet& a, std::index_sequence<Is...>) {
+  return __builtin_shufflevector(a, a, (sizeof...(Is) - 1 - Is)...);
+}
+
+// Loads half a packet worth of scalars and repeats each of them twice.
+template <typename Packet, std::size_t... Is>
+EIGEN_STRONG_INLINE Packet ploaddup_impl(const typename unpacket_traits<Packet>::type* from,
+                                         std::index_sequence<Is...>) {
   static_assert((unpacket_traits<Packet>::size) % 2 == 0, "Packet size must be a multiple of 2");
-  using HalfPacket = HalfPacket<Packet>;
-  HalfPacket a = load_vector_unaligned<HalfPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0);
+  using HalfT = half_vector_t<Packet>;
+  const HalfT a = load_vector_unaligned<HalfT>(from);
+  return __builtin_shufflevector(a, a, (Is / 2)...);
 }
 
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploaddup4(const typename unpacket_traits<Packet>::type* from) {
-  static_assert((unpacket_traits<Packet>::size) % 2 == 0, "Packet size must be a multiple of 2");
-  using HalfPacket = HalfPacket<Packet>;
-  HalfPacket a = load_vector_unaligned<HalfPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0, 1, 1);
-}
-
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploaddup8(const typename unpacket_traits<Packet>::type* from) {
-  static_assert((unpacket_traits<Packet>::size) % 2 == 0, "Packet size must be a multiple of 2");
-  using HalfPacket = HalfPacket<Packet>;
-  HalfPacket a = load_vector_unaligned<HalfPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0, 1, 1, 2, 2, 3, 3);
-}
-
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploaddup16(const typename unpacket_traits<Packet>::type* from) {
-  static_assert((unpacket_traits<Packet>::size) % 2 == 0, "Packet size must be a multiple of 2");
-  using HalfPacket = HalfPacket<Packet>;
-  HalfPacket a = load_vector_unaligned<HalfPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7);
-}
-
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploadquad4(const typename unpacket_traits<Packet>::type* from) {
+// Loads a quarter of a packet worth of scalars and repeats each of them four times.
+template <typename Packet, std::size_t... Is>
+EIGEN_STRONG_INLINE Packet ploadquad_impl(const typename unpacket_traits<Packet>::type* from,
+                                          std::index_sequence<Is...>) {
   static_assert((unpacket_traits<Packet>::size) % 4 == 0, "Packet size must be a multiple of 4");
-  using QuarterPacket = QuarterPacket<Packet>;
-  QuarterPacket a = load_vector_unaligned<QuarterPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0, 0, 0);
+  using QuarterT = quarter_vector_t<Packet>;
+  const QuarterT a = load_vector_unaligned<QuarterT>(from);
+  return __builtin_shufflevector(a, a, (Is / 4)...);
 }
 
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploadquad8(const typename unpacket_traits<Packet>::type* from) {
-  static_assert((unpacket_traits<Packet>::size) % 4 == 0, "Packet size must be a multiple of 4");
-  using QuarterPacket = QuarterPacket<Packet>;
-  QuarterPacket a = load_vector_unaligned<QuarterPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0, 0, 0, 1, 1, 1, 1);
+template <typename Packet, std::size_t... Is>
+EIGEN_STRONG_INLINE Packet plset_impl(const typename unpacket_traits<Packet>::type& a, std::index_sequence<Is...>) {
+  using Scalar = typename unpacket_traits<Packet>::type;
+  return Packet{(a + Scalar(Is))...};
 }
 
-template <typename Packet>
-EIGEN_STRONG_INLINE Packet ploadquad16(const typename unpacket_traits<Packet>::type* from) {
-  static_assert((unpacket_traits<Packet>::size) % 4 == 0, "Packet size must be a multiple of 4");
-  using QuarterPacket = QuarterPacket<Packet>;
-  QuarterPacket a = load_vector_unaligned<QuarterPacket>(from);
-  return __builtin_shufflevector(a, a, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3);
+// All ones in the even lanes, all zeros in the odd ones. Return the integer representation so finite fast-math cannot
+// make the all-ones lanes poison before the caller applies EIGEN_FAST_MATH_CONSTANT_BARRIER.
+template <typename Packet, std::size_t... Is>
+EIGEN_STRONG_INLINE typename unpacket_traits<Packet>::integer_packet peven_mask_impl(std::index_sequence<Is...>) {
+  using IntegerPacket = typename unpacket_traits<Packet>::integer_packet;
+  using Bits = scalar_type_of_vector_t<IntegerPacket>;
+  return IntegerPacket{(Is % 2 == 0 ? Bits(-1) : Bits(0))...};
 }
 
 }  // namespace detail
 
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
+#define EIGEN_CLANG_PACKET_PREVERSE(PACKET_TYPE)                                \
+  template <>                                                                   \
+  EIGEN_STRONG_INLINE PACKET_TYPE preverse<PACKET_TYPE>(const PACKET_TYPE& a) { \
+    return detail::preverse_impl(a, detail::vector_indices<PACKET_TYPE>{});     \
+  }
 
-template <>
-EIGEN_STRONG_INLINE PacketXf ploaddup<PacketXf>(const float* from) {
-  return detail::ploaddup4<PacketXf>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd ploaddup<PacketXd>(const double* from) {
-  return detail::ploaddup2<PacketXd>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi ploaddup<PacketXi>(const int32_t* from) {
-  return detail::ploaddup4<PacketXi>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl ploaddup<PacketXl>(const int64_t* from) {
-  return detail::ploaddup2<PacketXl>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXf ploadquad<PacketXf>(const float* from) {
-  return detail::ploadquad4<PacketXf>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi ploadquad<PacketXi>(const int32_t* from) {
-  return detail::ploadquad4<PacketXi>(from);
-}
-// No ploadquad for 2-element packets (PacketXd, PacketXl) at 16 bytes.
+EIGEN_CLANG_PACKET_PREVERSE(PacketXf)
+EIGEN_CLANG_PACKET_PREVERSE(PacketXd)
+EIGEN_CLANG_PACKET_PREVERSE(PacketXi)
+EIGEN_CLANG_PACKET_PREVERSE(PacketXl)
+#undef EIGEN_CLANG_PACKET_PREVERSE
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
+#define EIGEN_CLANG_PACKET_LOADDUP(PACKET_TYPE)                                                           \
+  template <>                                                                                             \
+  EIGEN_STRONG_INLINE PACKET_TYPE ploaddup<PACKET_TYPE>(const unpacket_traits<PACKET_TYPE>::type* from) { \
+    return detail::ploaddup_impl<PACKET_TYPE>(from, detail::vector_indices<PACKET_TYPE>{});               \
+  }
 
-template <>
-EIGEN_STRONG_INLINE PacketXf ploaddup<PacketXf>(const float* from) {
-  return detail::ploaddup8<PacketXf>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd ploaddup<PacketXd>(const double* from) {
-  return detail::ploaddup4<PacketXd>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi ploaddup<PacketXi>(const int32_t* from) {
-  return detail::ploaddup8<PacketXi>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl ploaddup<PacketXl>(const int64_t* from) {
-  return detail::ploaddup4<PacketXl>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXf ploadquad<PacketXf>(const float* from) {
-  return detail::ploadquad8<PacketXf>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd ploadquad<PacketXd>(const double* from) {
-  return detail::ploadquad4<PacketXd>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi ploadquad<PacketXi>(const int32_t* from) {
-  return detail::ploadquad8<PacketXi>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl ploadquad<PacketXl>(const int64_t* from) {
-  return detail::ploadquad4<PacketXl>(from);
-}
+EIGEN_CLANG_PACKET_LOADDUP(PacketXf)
+EIGEN_CLANG_PACKET_LOADDUP(PacketXd)
+EIGEN_CLANG_PACKET_LOADDUP(PacketXi)
+EIGEN_CLANG_PACKET_LOADDUP(PacketXl)
+#undef EIGEN_CLANG_PACKET_LOADDUP
 
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
+#define EIGEN_CLANG_PACKET_LOADQUAD(PACKET_TYPE)                                                           \
+  template <>                                                                                              \
+  EIGEN_STRONG_INLINE PACKET_TYPE ploadquad<PACKET_TYPE>(const unpacket_traits<PACKET_TYPE>::type* from) { \
+    return detail::ploadquad_impl<PACKET_TYPE>(from, detail::vector_indices<PACKET_TYPE>{});               \
+  }
 
-template <>
-EIGEN_STRONG_INLINE PacketXf ploaddup<PacketXf>(const float* from) {
-  return detail::ploaddup16<PacketXf>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd ploaddup<PacketXd>(const double* from) {
-  return detail::ploaddup8<PacketXd>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi ploaddup<PacketXi>(const int32_t* from) {
-  return detail::ploaddup16<PacketXi>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl ploaddup<PacketXl>(const int64_t* from) {
-  return detail::ploaddup8<PacketXl>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXf ploadquad<PacketXf>(const float* from) {
-  return detail::ploadquad16<PacketXf>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd ploadquad<PacketXd>(const double* from) {
-  return detail::ploadquad8<PacketXd>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi ploadquad<PacketXi>(const int32_t* from) {
-  return detail::ploadquad16<PacketXi>(from);
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl ploadquad<PacketXl>(const int64_t* from) {
-  return detail::ploadquad8<PacketXl>(from);
-}
+EIGEN_CLANG_PACKET_LOADQUAD(PacketXf)
+EIGEN_CLANG_PACKET_LOADQUAD(PacketXi)
+#if EIGEN_GENERIC_VECTOR_SIZE_BYTES >= 32
+// PacketXd and PacketXl hold only two elements at 16 bytes, so they have no quarter packet to load from.
+EIGEN_CLANG_PACKET_LOADQUAD(PacketXd)
+EIGEN_CLANG_PACKET_LOADQUAD(PacketXl)
+#endif
+#undef EIGEN_CLANG_PACKET_LOADQUAD
 
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+#define EIGEN_CLANG_PACKET_PLSET(PACKET_TYPE)                                                       \
+  template <>                                                                                       \
+  EIGEN_STRONG_INLINE PACKET_TYPE plset<PACKET_TYPE>(const unpacket_traits<PACKET_TYPE>::type& a) { \
+    return detail::plset_impl<PACKET_TYPE>(a, detail::vector_indices<PACKET_TYPE>{});               \
+  }
 
-// --- plset ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE PacketXf plset<PacketXf>(const float& a) {
-  return PacketXf{a + 0.0f, a + 1.0f, a + 2.0f, a + 3.0f};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd plset<PacketXd>(const double& a) {
-  return PacketXd{a + 0.0, a + 1.0};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi plset<PacketXi>(const int32_t& a) {
-  return PacketXi{a + 0, a + 1, a + 2, a + 3};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl plset<PacketXl>(const int64_t& a) {
-  return PacketXl{a + 0, a + 1};
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXf plset<PacketXf>(const float& a) {
-  return PacketXf{a + 0.0f, a + 1.0f, a + 2.0f, a + 3.0f, a + 4.0f, a + 5.0f, a + 6.0f, a + 7.0f};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd plset<PacketXd>(const double& a) {
-  return PacketXd{a + 0.0, a + 1.0, a + 2.0, a + 3.0};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi plset<PacketXi>(const int32_t& a) {
-  return PacketXi{a + 0, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl plset<PacketXl>(const int64_t& a) {
-  return PacketXl{a + 0, a + 1, a + 2, a + 3};
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXf plset<PacketXf>(const float& a) {
-  return PacketXf{a + 0.0f, a + 1.0f, a + 2.0f,  a + 3.0f,  a + 4.0f,  a + 5.0f,  a + 6.0f,  a + 7.0f,
-                  a + 8.0f, a + 9.0f, a + 10.0f, a + 11.0f, a + 12.0f, a + 13.0f, a + 14.0f, a + 15.0f};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd plset<PacketXd>(const double& a) {
-  return PacketXd{a + 0.0, a + 1.0, a + 2.0, a + 3.0, a + 4.0, a + 5.0, a + 6.0, a + 7.0};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXi plset<PacketXi>(const int32_t& a) {
-  return PacketXi{a + 0, a + 1, a + 2,  a + 3,  a + 4,  a + 5,  a + 6,  a + 7,
-                  a + 8, a + 9, a + 10, a + 11, a + 12, a + 13, a + 14, a + 15};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXl plset<PacketXl>(const int64_t& a) {
-  return PacketXl{a + 0, a + 1, a + 2, a + 3, a + 4, a + 5, a + 6, a + 7};
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+EIGEN_CLANG_PACKET_PLSET(PacketXf)
+EIGEN_CLANG_PACKET_PLSET(PacketXd)
+EIGEN_CLANG_PACKET_PLSET(PacketXi)
+EIGEN_CLANG_PACKET_PLSET(PacketXl)
+#undef EIGEN_CLANG_PACKET_PLSET
 
 // --- peven_mask ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
 template <>
 EIGEN_STRONG_INLINE PacketXf peven_mask(const PacketXf& /* unused */) {
-  float kTrue = numext::bit_cast<float>(int32_t(-1));
-  float kFalse = 0.0f;
-  return PacketXf{kTrue, kFalse, kTrue, kFalse};
+  PacketXf r = numext::bit_cast<PacketXf>(detail::peven_mask_impl<PacketXf>(detail::vector_indices<PacketXf>{}));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 template <>
 EIGEN_STRONG_INLINE PacketXd peven_mask(const PacketXd& /* unused */) {
-  double kTrue = numext::bit_cast<double>(int64_t(-1l));
-  double kFalse = 0.0;
-  return PacketXd{kTrue, kFalse};
+  PacketXd r = numext::bit_cast<PacketXd>(detail::peven_mask_impl<PacketXd>(detail::vector_indices<PacketXd>{}));
+  EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
+  return r;
 }
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE PacketXf peven_mask(const PacketXf& /* unused */) {
-  float kTrue = numext::bit_cast<float>(int32_t(-1));
-  float kFalse = 0.0f;
-  return PacketXf{kTrue, kFalse, kTrue, kFalse, kTrue, kFalse, kTrue, kFalse};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd peven_mask(const PacketXd& /* unused */) {
-  double kTrue = numext::bit_cast<double>(int64_t(-1l));
-  double kFalse = 0.0;
-  return PacketXd{kTrue, kFalse, kTrue, kFalse};
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE PacketXf peven_mask(const PacketXf& /* unused */) {
-  float kTrue = numext::bit_cast<float>(int32_t(-1));
-  float kFalse = 0.0f;
-  return PacketXf{kTrue, kFalse, kTrue, kFalse, kTrue, kFalse, kTrue, kFalse,
-                  kTrue, kFalse, kTrue, kFalse, kTrue, kFalse, kTrue, kFalse};
-}
-template <>
-EIGEN_STRONG_INLINE PacketXd peven_mask(const PacketXd& /* unused */) {
-  double kTrue = numext::bit_cast<double>(int64_t(-1l));
-  double kFalse = 0.0;
-  return PacketXd{kTrue, kFalse, kTrue, kFalse, kTrue, kFalse, kTrue, kFalse};
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
 // Helpers for ptranspose.
 namespace detail {
 
-template <typename Packet>
-EIGEN_ALWAYS_INLINE void zip_in_place2(Packet& p1, Packet& p2) {
-  Packet tmp = __builtin_shufflevector(p1, p2, 0, 2);
-  p2 = __builtin_shufflevector(p1, p2, 1, 3);
+// Shuffle index of output element `i` when interleaving two vectors of `Size`
+// elements each. `Group` adjacent elements move together: 1 for scalar packets,
+// 2 for the complex packets in Complex.h, whose real and imaginary parts must
+// stay adjacent. Output groups alternate between the two inputs, taking group
+// `first_group` of each first.
+template <std::size_t Group, std::size_t Size>
+constexpr std::size_t zip_index(std::size_t i, std::size_t first_group) {
+  return Size * ((i / Group) % 2) + Group * (first_group + i / Group / 2) + i % Group;
+}
+
+// Interleaves p1 and p2 in place, leaving the low half of the result in p1 and
+// the high half in p2.
+template <std::size_t Group, typename VectorT, std::size_t... Is>
+EIGEN_ALWAYS_INLINE void zip_in_place_impl(VectorT& p1, VectorT& p2, std::index_sequence<Is...>) {
+  constexpr std::size_t kSize = sizeof...(Is);
+  // With a single lane group per vector both output shuffles would pick group
+  // 0 and silently duplicate p1; such packets must not reach this code.
+  static_assert(kSize >= 2 * Group, "zip_in_place needs at least two lane groups per vector");
+  const VectorT tmp = __builtin_shufflevector(p1, p2, zip_index<Group, kSize>(Is, 0)...);
+  p2 = __builtin_shufflevector(p1, p2, zip_index<Group, kSize>(Is, kSize / (2 * Group))...);
   p1 = tmp;
 }
 
+// Complex.h specializes this for its packet types, which zip whole complex
+// values rather than individual reals.
 template <typename Packet>
-EIGEN_ALWAYS_INLINE void zip_in_place4(Packet& p1, Packet& p2) {
-  Packet tmp = __builtin_shufflevector(p1, p2, 0, 4, 1, 5);
-  p2 = __builtin_shufflevector(p1, p2, 2, 6, 3, 7);
-  p1 = tmp;
+EIGEN_ALWAYS_INLINE void zip_in_place(Packet& p1, Packet& p2) {
+  zip_in_place_impl<1>(p1, p2, vector_indices<Packet>{});
 }
 
 template <typename Packet>
-EIGEN_ALWAYS_INLINE void zip_in_place8(Packet& p1, Packet& p2) {
-  Packet tmp = __builtin_shufflevector(p1, p2, 0, 8, 1, 9, 2, 10, 3, 11);
-  p2 = __builtin_shufflevector(p1, p2, 4, 12, 5, 13, 6, 14, 7, 15);
-  p1 = tmp;
-}
-
-template <typename Packet>
-EIGEN_ALWAYS_INLINE void zip_in_place16(Packet& p1, Packet& p2) {
-  Packet tmp = __builtin_shufflevector(p1, p2, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
-  p2 = __builtin_shufflevector(p1, p2, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
-  p1 = tmp;
-}
-
-template <typename Packet>
-void zip_in_place(Packet& p1, Packet& p2);
-
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXf>(PacketXf& p1, PacketXf& p2) {
-  zip_in_place4(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXd>(PacketXd& p1, PacketXd& p2) {
-  zip_in_place2(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXi>(PacketXi& p1, PacketXi& p2) {
-  zip_in_place4(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXl>(PacketXl& p1, PacketXl& p2) {
-  zip_in_place2(p1, p2);
-}
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXf>(PacketXf& p1, PacketXf& p2) {
-  zip_in_place8(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXd>(PacketXd& p1, PacketXd& p2) {
-  zip_in_place4(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXi>(PacketXi& p1, PacketXi& p2) {
-  zip_in_place8(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXl>(PacketXl& p1, PacketXl& p2) {
-  zip_in_place4(p1, p2);
-}
-#else   // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXf>(PacketXf& p1, PacketXf& p2) {
-  zip_in_place16(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXd>(PacketXd& p1, PacketXd& p2) {
-  zip_in_place8(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXi>(PacketXi& p1, PacketXi& p2) {
-  zip_in_place16(p1, p2);
-}
-template <>
-EIGEN_ALWAYS_INLINE void zip_in_place<PacketXl>(PacketXl& p1, PacketXl& p2) {
-  zip_in_place8(p1, p2);
-}
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-template <typename Packet>
 EIGEN_ALWAYS_INLINE void ptranspose_impl(PacketBlock<Packet, 2>& kernel) {
   zip_in_place(kernel.packet[0], kernel.packet[1]);
 }
diff --git a/Eigen/src/Core/arch/clang/Reductions.h b/Eigen/src/Core/arch/clang/Reductions.h
index 37fc161..04a364e 100644
--- a/Eigen/src/Core/arch/clang/Reductions.h
+++ b/Eigen/src/Core/arch/clang/Reductions.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REDUCTIONS_CLANG_H
 #define EIGEN_REDUCTIONS_CLANG_H
@@ -17,9 +18,11 @@
 namespace internal {
 
 // --- Reductions ---
-#if EIGEN_HAS_BUILTIN(__builtin_reduce_min) && EIGEN_HAS_BUILTIN(__builtin_reduce_max) && \
-    EIGEN_HAS_BUILTIN(__builtin_reduce_or)
-#define EIGEN_CLANG_PACKET_REDUX_MINMAX(PACKET_TYPE)                                        \
+// __builtin_reduce_{min,max} lower well for the integer packets only: for
+// floating point their strict NaN-ordering semantics scalarize into a serial
+// compare-blend chain, so PacketXf/PacketXd use the halving trees below.
+#if EIGEN_HAS_BUILTIN(__builtin_reduce_min) && EIGEN_HAS_BUILTIN(__builtin_reduce_max)
+#define EIGEN_CLANG_PACKET_REDUX_MINMAX_INT(PACKET_TYPE)                                    \
   template <>                                                                               \
   EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_min(const PACKET_TYPE& a) { \
     return __builtin_reduce_min(a);                                                         \
@@ -27,17 +30,27 @@
   template <>                                                                               \
   EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_max(const PACKET_TYPE& a) { \
     return __builtin_reduce_max(a);                                                         \
-  }                                                                                         \
-  template <>                                                                               \
-  EIGEN_STRONG_INLINE bool predux_any(const PACKET_TYPE& a) {                               \
-    return __builtin_reduce_or(a != 0) != 0;                                                \
   }
 
-EIGEN_CLANG_PACKET_REDUX_MINMAX(PacketXf)
-EIGEN_CLANG_PACKET_REDUX_MINMAX(PacketXd)
-EIGEN_CLANG_PACKET_REDUX_MINMAX(PacketXi)
-EIGEN_CLANG_PACKET_REDUX_MINMAX(PacketXl)
-#undef EIGEN_CLANG_PACKET_REDUX_MINMAX
+EIGEN_CLANG_PACKET_REDUX_MINMAX_INT(PacketXi)
+EIGEN_CLANG_PACKET_REDUX_MINMAX_INT(PacketXl)
+#undef EIGEN_CLANG_PACKET_REDUX_MINMAX_INT
+#endif
+
+#if EIGEN_HAS_BUILTIN(__builtin_reduce_or)
+// Test the integer view: comparing an all-ones (NaN bit pattern) float mask
+// against zero is fair game for -ffast-math to fold away, as with pselect.
+#define EIGEN_CLANG_PACKET_REDUX_ANY(PACKET_TYPE)                                                    \
+  template <>                                                                                        \
+  EIGEN_STRONG_INLINE bool predux_any(const PACKET_TYPE& a) {                                        \
+    return __builtin_reduce_or(reinterpret_cast<detail::signed_vector_t<PACKET_TYPE>>(a) != 0) != 0; \
+  }
+
+EIGEN_CLANG_PACKET_REDUX_ANY(PacketXf)
+EIGEN_CLANG_PACKET_REDUX_ANY(PacketXd)
+EIGEN_CLANG_PACKET_REDUX_ANY(PacketXi)
+EIGEN_CLANG_PACKET_REDUX_ANY(PacketXl)
+#undef EIGEN_CLANG_PACKET_REDUX_ANY
 #endif
 
 #if EIGEN_HAS_BUILTIN(__builtin_reduce_add) && EIGEN_HAS_BUILTIN(__builtin_reduce_mul)
@@ -60,292 +73,149 @@
 #if EIGEN_HAS_BUILTIN(__builtin_shufflevector)
 namespace detail {
 
-// Reduction helpers for different vector sizes.
-// Each returns a pair of (even-sum, odd-sum) or (even-product, odd-product).
+// Folds `a` in half with `op` until two elements are left and returns them as
+// (even, odd). Callers combine those two with the same operation; splitting the
+// final step out is what lets the complex reductions read off the accumulated
+// real and imaginary parts separately. The halves are shuffled inline rather
+// than through lower_half/upper_half: an 8-byte half returned by value is
+// ABI-lowered to a scalar double in IR even under forced inlining, and the
+// leftover bitcasts perturb LLVM's canonicalization of the commutative fold,
+// measurably changing the generated code.
+template <int N>
+struct halving_reduce {
+  template <typename VectorT, typename Op, std::size_t... Is>
+  static EIGEN_STRONG_INLINE scalar_pair_t<VectorT> fold(const VectorT& a, Op op, std::index_sequence<Is...>) {
+    return halving_reduce<N / 2>::run(
+        op(__builtin_shufflevector(a, a, Is...), __builtin_shufflevector(a, a, (sizeof...(Is) + Is)...)), op);
+  }
+
+  template <typename VectorT, typename Op>
+  static EIGEN_STRONG_INLINE scalar_pair_t<VectorT> run(const VectorT& a, Op op) {
+    return fold(a, op, std::make_index_sequence<N / 2>{});
+  }
+};
+
+template <>
+struct halving_reduce<2> {
+  template <typename VectorT, typename Op>
+  static EIGEN_STRONG_INLINE scalar_pair_t<VectorT> run(const VectorT& a, Op /*op*/) {
+    return {a[0], a[1]};
+  }
+};
 
 template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceAdd2(
-    const VectorT& a) {
-  return {a[0], a[1]};
+EIGEN_STRONG_INLINE scalar_pair_t<VectorT> reduce_add_pairs(const VectorT& a) {
+  return halving_reduce<vector_elements<VectorT>()>::run(a, [](const auto& x, const auto& y) { return x + y; });
 }
 
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceAdd4(
-    const VectorT& a) {
-  const auto t1 = __builtin_shufflevector(a, a, 0, 1) + __builtin_shufflevector(a, a, 2, 3);
-  return {t1[0], t1[1]};
+// Folds the packet all the way to a scalar with `op`, which must also be
+// applicable to bare scalars for the final step.
+template <typename VectorT, typename Op>
+EIGEN_STRONG_INLINE scalar_type_of_vector_t<VectorT> tree_reduce(const VectorT& a, Op op) {
+  const scalar_pair_t<VectorT> even_odd = halving_reduce<vector_elements<VectorT>()>::run(a, op);
+  return op(even_odd.first, even_odd.second);
 }
 
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceAdd8(
-    const VectorT& a) {
-  const auto t1 = __builtin_shufflevector(a, a, 0, 1, 2, 3) + __builtin_shufflevector(a, a, 4, 5, 6, 7);
-  const auto t2 = __builtin_shufflevector(t1, t1, 0, 1) + __builtin_shufflevector(t1, t1, 2, 3);
-  return {t2[0], t2[1]};
-}
+// Multiplies the two halves of a complex packet until two complex values are
+// left, then multiplies those as scalars. Unlike the reductions above this
+// cannot work on the real vector, because complex multiplication mixes lanes.
+template <int N>
+struct complex_predux_mul {
+  template <typename RealScalar>
+  static EIGEN_STRONG_INLINE std::complex<RealScalar> run(const complex_packet_wrapper<RealScalar, N>& a) {
+    using HalfPacket = complex_packet_wrapper<RealScalar, N / 2>;
+    return complex_predux_mul<N / 2>::run(complex_pmul_impl(HalfPacket(lower_half(a.v)), HalfPacket(upper_half(a.v)),
+                                                            complex_real_indices<HalfPacket>{}));
+  }
+};
 
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceAdd16(
-    const VectorT& a) {
-  const auto t1 = __builtin_shufflevector(a, a, 0, 1, 2, 3, 4, 5, 6, 7) +
-                  __builtin_shufflevector(a, a, 8, 9, 10, 11, 12, 13, 14, 15);
-  const auto t2 = __builtin_shufflevector(t1, t1, 0, 1, 2, 3) + __builtin_shufflevector(t1, t1, 4, 5, 6, 7);
-  const auto t3 = __builtin_shufflevector(t2, t2, 0, 1) + __builtin_shufflevector(t2, t2, 2, 3);
-  return {t3[0], t3[1]};
-}
+template <>
+struct complex_predux_mul<2> {
+  template <typename RealScalar>
+  static EIGEN_STRONG_INLINE std::complex<RealScalar> run(const complex_packet_wrapper<RealScalar, 2>& a) {
+    return a[0] * a[1];
+  }
+};
 
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceMul2(
-    const VectorT& a) {
-  return {a[0], a[1]};
-}
+template <>
+struct complex_predux_mul<1> {
+  template <typename RealScalar>
+  static EIGEN_STRONG_INLINE std::complex<RealScalar> run(const complex_packet_wrapper<RealScalar, 1>& a) {
+    return a[0];
+  }
+};
 
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceMul4(
-    const VectorT& a) {
-  const auto t1 = __builtin_shufflevector(a, a, 0, 1) * __builtin_shufflevector(a, a, 2, 3);
-  return {t1[0], t1[1]};
-}
-
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceMul8(
-    const VectorT& a) {
-  const auto t1 = __builtin_shufflevector(a, a, 0, 1, 2, 3) * __builtin_shufflevector(a, a, 4, 5, 6, 7);
-  const auto t2 = __builtin_shufflevector(t1, t1, 0, 1) * __builtin_shufflevector(t1, t1, 2, 3);
-  return {t2[0], t2[1]};
-}
-
-template <typename VectorT>
-EIGEN_STRONG_INLINE std::pair<scalar_type_of_vector_t<VectorT>, scalar_type_of_vector_t<VectorT>> ReduceMul16(
-    const VectorT& a) {
-  const auto t1 = __builtin_shufflevector(a, a, 0, 1, 2, 3, 4, 5, 6, 7) *
-                  __builtin_shufflevector(a, a, 8, 9, 10, 11, 12, 13, 14, 15);
-  const auto t2 = __builtin_shufflevector(t1, t1, 0, 1, 2, 3) * __builtin_shufflevector(t1, t1, 4, 5, 6, 7);
-  const auto t3 = __builtin_shufflevector(t2, t2, 0, 1) * __builtin_shufflevector(t2, t2, 2, 3);
-  return {t3[0], t3[1]};
-}
 }  // namespace detail
 
-// --- predux and predux_mul for float ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
+// --- predux and predux_mul for float and double ---
+// __builtin_reduce_{add,mul} cover the integer packets above but are not
+// defined for floating point, so these fold the packet by hand.
+#define EIGEN_CLANG_PACKET_REDUX_FLOAT(PACKET_TYPE)                                                      \
+  template <>                                                                                            \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux<PACKET_TYPE>(const PACKET_TYPE& a) {     \
+    return detail::tree_reduce(a, [](const auto& x, const auto& y) { return x + y; });                   \
+  }                                                                                                      \
+  template <>                                                                                            \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_mul<PACKET_TYPE>(const PACKET_TYPE& a) { \
+    return detail::tree_reduce(a, [](const auto& x, const auto& y) { return x * y; });                   \
+  }
 
-template <>
-EIGEN_STRONG_INLINE float predux<PacketXf>(const PacketXf& a) {
-  float even, odd;
-  std::tie(even, odd) = detail::ReduceAdd4(a);
-  return even + odd;
-}
-template <>
-EIGEN_STRONG_INLINE float predux_mul<PacketXf>(const PacketXf& a) {
-  float even, odd;
-  std::tie(even, odd) = detail::ReduceMul4(a);
-  return even * odd;
-}
+EIGEN_CLANG_PACKET_REDUX_FLOAT(PacketXf)
+EIGEN_CLANG_PACKET_REDUX_FLOAT(PacketXd)
+#undef EIGEN_CLANG_PACKET_REDUX_FLOAT
 
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
+// --- predux_min and predux_max for float and double ---
+// Also covers the NaN-propagation variants, whose generic fallback spills the
+// packet to the stack and reduces it with a scalar loop.
+#define EIGEN_CLANG_PACKET_REDUX_MINMAX_FLOAT(PACKET_TYPE)                                                             \
+  template <>                                                                                                          \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_min(const PACKET_TYPE& a) {                            \
+    return detail::tree_reduce(a, detail::pmin_op());                                                                  \
+  }                                                                                                                    \
+  template <>                                                                                                          \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_max(const PACKET_TYPE& a) {                            \
+    return detail::tree_reduce(a, detail::pmax_op());                                                                  \
+  }                                                                                                                    \
+  template <>                                                                                                          \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_min<PropagateNumbers, PACKET_TYPE>(                    \
+      const PACKET_TYPE& a) {                                                                                          \
+    return detail::tree_reduce(a, detail::pmin_num_op());                                                              \
+  }                                                                                                                    \
+  template <>                                                                                                          \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_max<PropagateNumbers, PACKET_TYPE>(                    \
+      const PACKET_TYPE& a) {                                                                                          \
+    return detail::tree_reduce(a, detail::pmax_num_op());                                                              \
+  }                                                                                                                    \
+  template <>                                                                                                          \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_min<PropagateNaN, PACKET_TYPE>(const PACKET_TYPE& a) { \
+    return detail::tree_reduce(a, detail::pmin_nan_op());                                                              \
+  }                                                                                                                    \
+  template <>                                                                                                          \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_max<PropagateNaN, PACKET_TYPE>(const PACKET_TYPE& a) { \
+    return detail::tree_reduce(a, detail::pmax_nan_op());                                                              \
+  }
 
-template <>
-EIGEN_STRONG_INLINE float predux<PacketXf>(const PacketXf& a) {
-  float even, odd;
-  std::tie(even, odd) = detail::ReduceAdd8(a);
-  return even + odd;
-}
-template <>
-EIGEN_STRONG_INLINE float predux_mul<PacketXf>(const PacketXf& a) {
-  float even, odd;
-  std::tie(even, odd) = detail::ReduceMul8(a);
-  return even * odd;
-}
+EIGEN_CLANG_PACKET_REDUX_MINMAX_FLOAT(PacketXf)
+EIGEN_CLANG_PACKET_REDUX_MINMAX_FLOAT(PacketXd)
+#undef EIGEN_CLANG_PACKET_REDUX_MINMAX_FLOAT
 
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
+// --- predux and predux_mul for complex ---
+// The real vector of a complex packet interleaves real and imaginary parts, so
+// summing it into an (even, odd) pair accumulates the two parts separately.
+#define EIGEN_CLANG_COMPLEX_REDUX(PACKET_TYPE)                                                           \
+  template <>                                                                                            \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux<PACKET_TYPE>(const PACKET_TYPE& a) {     \
+    const auto re_im = detail::reduce_add_pairs(a.v);                                                    \
+    return unpacket_traits<PACKET_TYPE>::type(re_im.first, re_im.second);                                \
+  }                                                                                                      \
+  template <>                                                                                            \
+  EIGEN_STRONG_INLINE unpacket_traits<PACKET_TYPE>::type predux_mul<PACKET_TYPE>(const PACKET_TYPE& a) { \
+    return detail::complex_predux_mul<unpacket_traits<PACKET_TYPE>::size>::run(a);                       \
+  }
 
-template <>
-EIGEN_STRONG_INLINE float predux<PacketXf>(const PacketXf& a) {
-  float even, odd;
-  std::tie(even, odd) = detail::ReduceAdd16(a);
-  return even + odd;
-}
-template <>
-EIGEN_STRONG_INLINE float predux_mul<PacketXf>(const PacketXf& a) {
-  float even, odd;
-  std::tie(even, odd) = detail::ReduceMul16(a);
-  return even * odd;
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// --- predux and predux_mul for double ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE double predux<PacketXd>(const PacketXd& a) {
-  double even, odd;
-  std::tie(even, odd) = detail::ReduceAdd2(a);
-  return even + odd;
-}
-template <>
-EIGEN_STRONG_INLINE double predux_mul<PacketXd>(const PacketXd& a) {
-  double even, odd;
-  std::tie(even, odd) = detail::ReduceMul2(a);
-  return even * odd;
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE double predux<PacketXd>(const PacketXd& a) {
-  double even, odd;
-  std::tie(even, odd) = detail::ReduceAdd4(a);
-  return even + odd;
-}
-template <>
-EIGEN_STRONG_INLINE double predux_mul<PacketXd>(const PacketXd& a) {
-  double even, odd;
-  std::tie(even, odd) = detail::ReduceMul4(a);
-  return even * odd;
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE double predux<PacketXd>(const PacketXd& a) {
-  double even, odd;
-  std::tie(even, odd) = detail::ReduceAdd8(a);
-  return even + odd;
-}
-template <>
-EIGEN_STRONG_INLINE double predux_mul<PacketXd>(const PacketXd& a) {
-  double even, odd;
-  std::tie(even, odd) = detail::ReduceMul8(a);
-  return even * odd;
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// --- predux for complex<float> ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE std::complex<float> predux<PacketXcf>(const PacketXcf& a) {
-  float re, im;
-  std::tie(re, im) = detail::ReduceAdd4(a.v);
-  return std::complex<float>(re, im);
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE std::complex<float> predux<PacketXcf>(const PacketXcf& a) {
-  float re, im;
-  std::tie(re, im) = detail::ReduceAdd8(a.v);
-  return std::complex<float>(re, im);
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE std::complex<float> predux<PacketXcf>(const PacketXcf& a) {
-  float re, im;
-  std::tie(re, im) = detail::ReduceAdd16(a.v);
-  return std::complex<float>(re, im);
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// --- predux for complex<double> ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<PacketXcd>(const PacketXcd& a) {
-  // 1 complex double: just return it
-  return a[0];
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<PacketXcd>(const PacketXcd& a) {
-  double re, im;
-  std::tie(re, im) = detail::ReduceAdd4(a.v);
-  return std::complex<double>(re, im);
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux<PacketXcd>(const PacketXcd& a) {
-  double re, im;
-  std::tie(re, im) = detail::ReduceAdd8(a.v);
-  return std::complex<double>(re, im);
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// --- predux_mul for complex<float> ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE std::complex<float> predux_mul<PacketXcf>(const PacketXcf& a) {
-  // 2 complex floats: just multiply them
-  return a[0] * a[1];
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE std::complex<float> predux_mul<PacketXcf>(const PacketXcf& a) {
-  // 4 complex floats: split into 2+2, multiply, then scalar multiply
-  const Packet2cf lower2 = Packet2cf(__builtin_shufflevector(a.v, a.v, 0, 1, 2, 3));
-  const Packet2cf upper2 = Packet2cf(__builtin_shufflevector(a.v, a.v, 4, 5, 6, 7));
-  const Packet2cf prod2 = pmul<Packet2cf>(lower2, upper2);
-  return prod2[0] * prod2[1];
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE std::complex<float> predux_mul<PacketXcf>(const PacketXcf& a) {
-  // 8 complex floats: 8->4->2->scalar
-  const Packet4cf lower4 = Packet4cf(__builtin_shufflevector(a.v, a.v, 0, 1, 2, 3, 4, 5, 6, 7));
-  const Packet4cf upper4 = Packet4cf(__builtin_shufflevector(a.v, a.v, 8, 9, 10, 11, 12, 13, 14, 15));
-  const Packet4cf prod4 = pmul<Packet4cf>(lower4, upper4);
-  const Packet2cf lower2 = Packet2cf(__builtin_shufflevector(prod4.v, prod4.v, 0, 1, 2, 3));
-  const Packet2cf upper2 = Packet2cf(__builtin_shufflevector(prod4.v, prod4.v, 4, 5, 6, 7));
-  const Packet2cf prod2 = pmul<Packet2cf>(lower2, upper2);
-  return prod2[0] * prod2[1];
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
-
-// --- predux_mul for complex<double> ---
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<PacketXcd>(const PacketXcd& a) {
-  // 1 complex double: just return it
-  return a[0];
-}
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<PacketXcd>(const PacketXcd& a) {
-  // 2 complex doubles: just multiply them
-  return a[0] * a[1];
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-template <>
-EIGEN_STRONG_INLINE std::complex<double> predux_mul<PacketXcd>(const PacketXcd& a) {
-  // 4 complex doubles: split into 2+2, multiply, then scalar multiply
-  const Packet2cd lower2 = Packet2cd(__builtin_shufflevector(a.v, a.v, 0, 1, 2, 3));
-  const Packet2cd upper2 = Packet2cd(__builtin_shufflevector(a.v, a.v, 4, 5, 6, 7));
-  const Packet2cd prod2 = pmul<Packet2cd>(lower2, upper2);
-  return prod2[0] * prod2[1];
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
+EIGEN_CLANG_COMPLEX_REDUX(PacketXcf)
+EIGEN_CLANG_COMPLEX_REDUX(PacketXcd)
+#undef EIGEN_CLANG_COMPLEX_REDUX
 
 #endif
 
diff --git a/Eigen/src/Core/arch/clang/TypeCasting.h b/Eigen/src/Core/arch/clang/TypeCasting.h
index 75281b2..f7d6dae 100644
--- a/Eigen/src/Core/arch/clang/TypeCasting.h
+++ b/Eigen/src/Core/arch/clang/TypeCasting.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TYPE_CASTING_CLANG_H
 #define EIGEN_TYPE_CASTING_CLANG_H
@@ -64,120 +65,30 @@
   return __builtin_convertvector(a, PacketXd);
 }
 
-// float -> double: converts lower half of floats to doubles
-// double -> float: converts two PacketXd to one PacketXf
-// int32 -> int64: converts lower half of int32s to int64s
-// int64 -> int32: converts two PacketXl to one PacketXi
-
-#if EIGEN_GENERIC_VECTOR_SIZE_BYTES == 16
-
-// float -> double: converts lower 2 floats to 2 doubles
+// Widening and narrowing conversions run on half-width vectors: a widening cast
+// consumes the lower half of its input, and a narrowing cast joins the halves
+// produced from its two inputs.
 template <>
 EIGEN_STRONG_INLINE PacketXd pcast<PacketXf, PacketXd>(const PacketXf& a) {
-  using HalfFloat = detail::VectorType<float, 2>;
-  HalfFloat lo = __builtin_shufflevector(a, a, 0, 1);
-  return __builtin_convertvector(lo, PacketXd);
+  return __builtin_convertvector(detail::lower_half(a), PacketXd);
 }
 
-// double -> float: converts two PacketXd (2 doubles each) to one PacketXf (4 floats)
 template <>
 EIGEN_STRONG_INLINE PacketXf pcast<PacketXd, PacketXf>(const PacketXd& a, const PacketXd& b) {
-  using HalfFloat = detail::VectorType<float, 2>;
-  HalfFloat lo = __builtin_convertvector(a, HalfFloat);
-  HalfFloat hi = __builtin_convertvector(b, HalfFloat);
-  return __builtin_shufflevector(lo, hi, 0, 1, 2, 3);
+  using HalfFloat = detail::half_vector_t<PacketXf>;
+  return detail::concat_halves<PacketXf>(__builtin_convertvector(a, HalfFloat), __builtin_convertvector(b, HalfFloat));
 }
 
-// int32 -> int64: converts lower 2 int32s to 2 int64s
 template <>
 EIGEN_STRONG_INLINE PacketXl pcast<PacketXi, PacketXl>(const PacketXi& a) {
-  using HalfInt = detail::VectorType<int32_t, 2>;
-  HalfInt lo = __builtin_shufflevector(a, a, 0, 1);
-  return __builtin_convertvector(lo, PacketXl);
+  return __builtin_convertvector(detail::lower_half(a), PacketXl);
 }
 
-// int64 -> int32: converts two PacketXl (2 int64s each) to one PacketXi (4 int32s)
 template <>
 EIGEN_STRONG_INLINE PacketXi pcast<PacketXl, PacketXi>(const PacketXl& a, const PacketXl& b) {
-  using HalfInt = detail::VectorType<int32_t, 2>;
-  HalfInt lo = __builtin_convertvector(a, HalfInt);
-  HalfInt hi = __builtin_convertvector(b, HalfInt);
-  return __builtin_shufflevector(lo, hi, 0, 1, 2, 3);
+  using HalfInt = detail::half_vector_t<PacketXi>;
+  return detail::concat_halves<PacketXi>(__builtin_convertvector(a, HalfInt), __builtin_convertvector(b, HalfInt));
 }
-
-#elif EIGEN_GENERIC_VECTOR_SIZE_BYTES == 32
-
-// float -> double: converts lower 4 floats to 4 doubles
-template <>
-EIGEN_STRONG_INLINE PacketXd pcast<PacketXf, PacketXd>(const PacketXf& a) {
-  using HalfFloat = detail::VectorType<float, 4>;
-  HalfFloat lo = __builtin_shufflevector(a, a, 0, 1, 2, 3);
-  return __builtin_convertvector(lo, PacketXd);
-}
-
-// double -> float: converts two PacketXd (4 doubles each) to one PacketXf (8 floats)
-template <>
-EIGEN_STRONG_INLINE PacketXf pcast<PacketXd, PacketXf>(const PacketXd& a, const PacketXd& b) {
-  using HalfFloat = detail::VectorType<float, 4>;
-  HalfFloat lo = __builtin_convertvector(a, HalfFloat);
-  HalfFloat hi = __builtin_convertvector(b, HalfFloat);
-  return __builtin_shufflevector(lo, hi, 0, 1, 2, 3, 4, 5, 6, 7);
-}
-
-// int32 -> int64: converts lower 4 int32s to 4 int64s
-template <>
-EIGEN_STRONG_INLINE PacketXl pcast<PacketXi, PacketXl>(const PacketXi& a) {
-  using HalfInt = detail::VectorType<int32_t, 4>;
-  HalfInt lo = __builtin_shufflevector(a, a, 0, 1, 2, 3);
-  return __builtin_convertvector(lo, PacketXl);
-}
-
-// int64 -> int32: converts two PacketXl (4 int64s each) to one PacketXi (8 int32s)
-template <>
-EIGEN_STRONG_INLINE PacketXi pcast<PacketXl, PacketXi>(const PacketXl& a, const PacketXl& b) {
-  using HalfInt = detail::VectorType<int32_t, 4>;
-  HalfInt lo = __builtin_convertvector(a, HalfInt);
-  HalfInt hi = __builtin_convertvector(b, HalfInt);
-  return __builtin_shufflevector(lo, hi, 0, 1, 2, 3, 4, 5, 6, 7);
-}
-
-#else  // EIGEN_GENERIC_VECTOR_SIZE_BYTES == 64
-
-// float -> double: converts lower 8 floats to 8 doubles
-template <>
-EIGEN_STRONG_INLINE PacketXd pcast<PacketXf, PacketXd>(const PacketXf& a) {
-  using HalfFloat = detail::VectorType<float, 8>;
-  HalfFloat lo = __builtin_shufflevector(a, a, 0, 1, 2, 3, 4, 5, 6, 7);
-  return __builtin_convertvector(lo, PacketXd);
-}
-
-// double -> float: converts two PacketXd to one PacketXf
-template <>
-EIGEN_STRONG_INLINE PacketXf pcast<PacketXd, PacketXf>(const PacketXd& a, const PacketXd& b) {
-  using HalfFloat = detail::VectorType<float, 8>;
-  HalfFloat lo = __builtin_convertvector(a, HalfFloat);
-  HalfFloat hi = __builtin_convertvector(b, HalfFloat);
-  return __builtin_shufflevector(lo, hi, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-}
-
-// int32 -> int64: converts lower 8 int32s to 8 int64s
-template <>
-EIGEN_STRONG_INLINE PacketXl pcast<PacketXi, PacketXl>(const PacketXi& a) {
-  using HalfInt = detail::VectorType<int32_t, 8>;
-  HalfInt lo = __builtin_shufflevector(a, a, 0, 1, 2, 3, 4, 5, 6, 7);
-  return __builtin_convertvector(lo, PacketXl);
-}
-
-// int64 -> int32: converts two PacketXl to one PacketXi
-template <>
-EIGEN_STRONG_INLINE PacketXi pcast<PacketXl, PacketXi>(const PacketXl& a, const PacketXl& b) {
-  using HalfInt = detail::VectorType<int32_t, 8>;
-  HalfInt lo = __builtin_convertvector(a, HalfInt);
-  HalfInt hi = __builtin_convertvector(b, HalfInt);
-  return __builtin_shufflevector(lo, hi, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-}
-
-#endif  // EIGEN_GENERIC_VECTOR_SIZE_BYTES
 #endif
 
 }  // end namespace internal
diff --git a/Eigen/src/Core/functors/AssignmentFunctors.h b/Eigen/src/Core/functors/AssignmentFunctors.h
index 8f7ad13..01c0c2b 100644
--- a/Eigen/src/Core/functors/AssignmentFunctors.h
+++ b/Eigen/src/Core/functors/AssignmentFunctors.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ASSIGNMENT_FUNCTORS_H
 #define EIGEN_ASSIGNMENT_FUNCTORS_H
@@ -44,7 +45,7 @@
 struct functor_traits<assign_op<DstScalar, SrcScalar>> {
   enum {
     Cost = NumTraits<DstScalar>::ReadCost,
-    PacketAccess = is_same<DstScalar, SrcScalar>::value && packet_traits<DstScalar>::Vectorizable &&
+    PacketAccess = std::is_same<DstScalar, SrcScalar>::value && packet_traits<DstScalar>::Vectorizable &&
                    packet_traits<SrcScalar>::Vectorizable
   };
 };
@@ -96,7 +97,11 @@
  *
  */
 template <typename DstScalar, typename SrcScalar = DstScalar>
-struct sub_assign_op : compound_assign_op<DstScalar, SrcScalar, scalar_difference_op<DstScalar, SrcScalar>> {};
+struct sub_assign_op : compound_assign_op<DstScalar, SrcScalar, scalar_difference_op<DstScalar, SrcScalar>> {
+  // Inner and matrix-vector products can bypass scalar_difference_op.
+  EIGEN_STATIC_ASSERT((!std::is_same<DstScalar, bool>::value || !std::is_same<SrcScalar, bool>::value),
+                      BOOLEAN_SUBTRACTION_IS_NOT_SUPPORTED__CAST_TO_A_SIGNED_INTEGER_TYPE)
+};
 
 template <typename DstScalar, typename SrcScalar>
 struct functor_traits<sub_assign_op<DstScalar, SrcScalar>> : sub_assign_op<DstScalar, SrcScalar>::traits {};
diff --git a/Eigen/src/Core/functors/BinaryFunctors.h b/Eigen/src/Core/functors/BinaryFunctors.h
index bbaab11..baccca9 100644
--- a/Eigen/src/Core/functors/BinaryFunctors.h
+++ b/Eigen/src/Core/functors/BinaryFunctors.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BINARY_FUNCTORS_H
 #define EIGEN_BINARY_FUNCTORS_H
@@ -21,8 +22,8 @@
 
 template <typename Arg1, typename Arg2>
 struct binary_op_base {
-  typedef Arg1 first_argument_type;
-  typedef Arg2 second_argument_type;
+  using first_argument_type = Arg1;
+  using second_argument_type = Arg2;
 };
 
 /** \internal
@@ -32,7 +33,7 @@
  */
 template <typename LhsScalar, typename RhsScalar>
 struct scalar_sum_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_sum_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_sum_op>::ReturnType;
 #ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
   scalar_sum_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
 #endif
@@ -53,16 +54,22 @@
 struct functor_traits<scalar_sum_op<LhsScalar, RhsScalar>> {
   enum {
     Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2,  // rough estimate!
-    PacketAccess =
-        is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasAdd && packet_traits<RhsScalar>::HasAdd
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasAdd &&
+                   packet_traits<RhsScalar>::HasAdd
     // TODO: vectorize mixed sum
   };
 };
 
+// Addition commutes for arithmetic and complex scalars. A user-defined Scalar may define a
+// non-commutative operator+ (e.g. concatenation), so it keeps the order-preserving default.
+template <typename Scalar>
+struct functor_is_commutative<scalar_sum_op<Scalar, Scalar>>
+    : bool_constant<is_arithmetic<Scalar>::value || NumTraits<Scalar>::IsComplex> {};
+
 template <>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE bool scalar_sum_op<bool, bool>::operator()(const bool& a,
                                                                                            const bool& b) const {
-  return a || b;
+  return a | b;
 }
 
 /** \internal
@@ -72,13 +79,13 @@
  */
 template <typename LhsScalar, typename RhsScalar>
 struct scalar_product_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_product_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_product_op>::ReturnType;
 #ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
   scalar_product_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
 #endif
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type
   operator()(const LhsScalar& a, const RhsScalar& b) const {
-    return a * b;
+    return internal::mul(a, b);
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
@@ -93,16 +100,47 @@
 struct functor_traits<scalar_product_op<LhsScalar, RhsScalar>> {
   enum {
     Cost = (int(NumTraits<LhsScalar>::MulCost) + int(NumTraits<RhsScalar>::MulCost)) / 2,  // rough estimate!
-    PacketAccess =
-        is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul &&
+                   packet_traits<RhsScalar>::HasMul
     // TODO: vectorize mixed product
   };
 };
 
+// Multiplication commutes for arithmetic and complex scalars, but not for every user-defined
+// Scalar (e.g. quaternion-like or matrix-like types).
+template <typename Scalar>
+struct functor_is_commutative<scalar_product_op<Scalar, Scalar>>
+    : bool_constant<is_arithmetic<Scalar>::value || NumTraits<Scalar>::IsComplex> {};
+
+// Same as scalar_product_op, but its scalar path uses pmul instead of operator*. For complex scalars
+// pmul is Eigen's explicit (non-Annex-G) complex multiply, so this avoids std::complex::operator*,
+// which GCC lowers to the slow libgcc __mul?c3 call. The packet path (packetOp/predux) is inherited
+// unchanged -- it already uses pmul -- so the vectorized reduction and its precision are identical to
+// scalar_product_op (this only matters for the non-vectorized scalar tail). Used by the coeff-based
+// product's coeff(); pmul requires matching operand types, so mixed types fall back to operator*
+// (which is cheap for real*complex and never hits the complex*complex libcall).
+template <typename LhsScalar, typename RhsScalar>
+struct fast_mult_op : scalar_product_op<LhsScalar, RhsScalar> {
+  using result_type = typename scalar_product_op<LhsScalar, RhsScalar>::result_type;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator()(const LhsScalar& a, const RhsScalar& b) const {
+    return mul(a, b, bool_constant<std::is_same<LhsScalar, RhsScalar>::value>());
+  }
+
+ private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type mul(const LhsScalar& a, const RhsScalar& b, std::true_type) const {
+    return pmul(a, b);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type mul(const LhsScalar& a, const RhsScalar& b, std::false_type) const {
+    return a * b;
+  }
+};
+template <typename LhsScalar, typename RhsScalar>
+struct functor_traits<fast_mult_op<LhsScalar, RhsScalar>> : functor_traits<scalar_product_op<LhsScalar, RhsScalar>> {};
+
 template <>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE bool scalar_product_op<bool, bool>::operator()(const bool& a,
                                                                                                const bool& b) const {
-  return a && b;
+  return a & b;
 }
 
 /** \internal
@@ -115,7 +153,7 @@
 struct scalar_conj_product_op : binary_op_base<LhsScalar, RhsScalar> {
   enum { Conj = NumTraits<LhsScalar>::IsComplex };
 
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_conj_product_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_conj_product_op>::ReturnType;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const LhsScalar& a, const RhsScalar& b) const {
     return conj_helper<LhsScalar, RhsScalar, Conj, false>().pmul(a, b);
@@ -130,7 +168,7 @@
 struct functor_traits<scalar_conj_product_op<LhsScalar, RhsScalar>> {
   enum {
     Cost = NumTraits<LhsScalar>::MulCost,
-    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMul
   };
 };
 
@@ -141,7 +179,7 @@
  */
 template <typename LhsScalar, typename RhsScalar, int NaNPropagation>
 struct scalar_min_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_min_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_min_op>::ReturnType;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const LhsScalar& a, const RhsScalar& b) const {
     return internal::pmin<NaNPropagation>(a, b);
   }
@@ -159,10 +197,19 @@
 struct functor_traits<scalar_min_op<LhsScalar, RhsScalar, NaNPropagation>> {
   enum {
     Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
-    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMin
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMin
   };
 };
 
+// min/max commute for arithmetic scalars only: PropagateNumbers and PropagateNaN treat NaN
+// operands symmetrically, PropagateFast leaves NaN results unspecified, and -0.0/+0.0 ties may
+// already resolve either way in the packet reduction paths. A custom scalar is excluded even
+// though it compares with operator<, because the generic std::min/std::max keep the first
+// operand when values compare equivalent, and equivalent custom values may be observably
+// distinct (e.g. carry a payload the comparison ignores).
+template <typename Scalar, int NaNPropagation>
+struct functor_is_commutative<scalar_min_op<Scalar, Scalar, NaNPropagation>> : is_arithmetic<Scalar> {};
+
 /** \internal
  * \brief Template functor to compute the max of two scalars
  *
@@ -170,7 +217,7 @@
  */
 template <typename LhsScalar, typename RhsScalar, int NaNPropagation>
 struct scalar_max_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_max_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_max_op>::ReturnType;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const LhsScalar& a, const RhsScalar& b) const {
     return internal::pmax<NaNPropagation>(a, b);
   }
@@ -188,10 +235,13 @@
 struct functor_traits<scalar_max_op<LhsScalar, RhsScalar, NaNPropagation>> {
   enum {
     Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
-    PacketAccess = internal::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMax
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasMax
   };
 };
 
+template <typename Scalar, int NaNPropagation>
+struct functor_is_commutative<scalar_max_op<Scalar, Scalar, NaNPropagation>> : is_arithmetic<Scalar> {};
+
 /** \internal
  * \brief Template functors for comparison of two scalars
  * \todo Implement packet-comparisons
@@ -203,8 +253,8 @@
 struct functor_traits<scalar_cmp_op<LhsScalar, RhsScalar, cmp, UseTypedComparators>> {
   enum {
     Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
-    PacketAccess = (UseTypedComparators || is_same<LhsScalar, bool>::value) && is_same<LhsScalar, RhsScalar>::value &&
-                   packet_traits<LhsScalar>::HasCmp
+    PacketAccess = (UseTypedComparators || std::is_same<LhsScalar, bool>::value) &&
+                   std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasCmp
   };
 };
 
@@ -329,11 +379,11 @@
  */
 template <typename Scalar, typename Exponent>
 struct scalar_pow_op : binary_op_base<Scalar, Exponent> {
-  typedef typename ScalarBinaryOpTraits<Scalar, Exponent, scalar_pow_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<Scalar, Exponent, scalar_pow_op>::ReturnType;
 #ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
   scalar_pow_op() {
-    typedef Scalar LhsScalar;
-    typedef Exponent RhsScalar;
+    using LhsScalar = Scalar;
+    using RhsScalar = Exponent;
     EIGEN_SCALAR_BINARY_OP_PLUGIN
   }
 #endif
@@ -365,7 +415,9 @@
  */
 template <typename LhsScalar, typename RhsScalar>
 struct scalar_difference_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_difference_op>::ReturnType result_type;
+  EIGEN_STATIC_ASSERT((!std::is_same<LhsScalar, bool>::value || !std::is_same<RhsScalar, bool>::value),
+                      BOOLEAN_SUBTRACTION_IS_NOT_SUPPORTED__CAST_TO_A_SIGNED_INTEGER_TYPE)
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_difference_op>::ReturnType;
 #ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
   scalar_difference_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
 #endif
@@ -382,8 +434,8 @@
 struct functor_traits<scalar_difference_op<LhsScalar, RhsScalar>> {
   enum {
     Cost = (int(NumTraits<LhsScalar>::AddCost) + int(NumTraits<RhsScalar>::AddCost)) / 2,
-    PacketAccess =
-        is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasSub && packet_traits<RhsScalar>::HasSub
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasSub &&
+                   packet_traits<RhsScalar>::HasSub
   };
 };
 
@@ -414,13 +466,13 @@
  */
 template <typename LhsScalar, typename RhsScalar>
 struct scalar_quotient_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_quotient_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_quotient_op>::ReturnType;
 #ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
   scalar_quotient_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
 #endif
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type
   operator()(const LhsScalar& a, const RhsScalar& b) const {
-    return a / b;
+    return numext::divide(a, b);
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
@@ -429,14 +481,18 @@
 };
 template <typename LhsScalar, typename RhsScalar>
 struct functor_traits<scalar_quotient_op<LhsScalar, RhsScalar>> {
-  typedef typename scalar_quotient_op<LhsScalar, RhsScalar>::result_type result_type;
+  using result_type = typename scalar_quotient_op<LhsScalar, RhsScalar>::result_type;
   enum {
-    PacketAccess =
-        is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasDiv && packet_traits<RhsScalar>::HasDiv,
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasDiv &&
+                   packet_traits<RhsScalar>::HasDiv,
     Cost = scalar_div_cost<result_type, PacketAccess>::value
   };
 };
 
+// Packet16b is currently Eigen's only Boolean packet. Its loads contain valid bool objects, and its casts,
+// comparisons, and Boolean packet operations canonicalize every lane to 0 or 1. The direct bitwise fast paths below
+// rely on this invariant.
+
 /** \internal
  * \brief Template functor to compute the and of two scalars as if they were booleans
  *
@@ -452,14 +508,24 @@
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
-    const Packet cst_one = pset1<Packet>(Scalar(1));
-    // and(a,b) == !or(!a,!b)
-    Packet not_a = pcmp_eq(a, pzero(a));
-    Packet not_b = pcmp_eq(b, pzero(b));
-    Packet a_nand_b = por(not_a, not_b);
-    return pandnot(cst_one, a_nand_b);
+    EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
+      return pand(a, b);
+    } else {
+      const Packet cst_one = pset1<Packet>(Scalar(1));
+      // and(a,b) == !or(!a,!b)
+      Packet not_a = pcmp_eq(a, pzero(a));
+      Packet not_b = pcmp_eq(b, pzero(b));
+      Packet a_nand_b = por(not_a, not_b);
+      return pandnot(cst_one, a_nand_b);
+    }
   }
 };
+// Keep bool logical functors eager so scalar evaluator loops remain branch-free.
+template <>
+EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE bool scalar_boolean_and_op<bool>::operator()(const bool& a,
+                                                                                             const bool& b) const {
+  return a & b;
+}
 template <typename Scalar>
 struct functor_traits<scalar_boolean_and_op<Scalar>> {
   enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
@@ -479,14 +545,23 @@
     return (a != Scalar(0)) || (b != Scalar(0)) ? Scalar(1) : Scalar(0);
   }
   template <typename Packet>
-  EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
-    const Packet cst_one = pset1<Packet>(Scalar(1));
-    // if or(a,b) == 0, then a == 0 and b == 0
-    // or(a,b) == !nor(a,b)
-    Packet a_nor_b = pcmp_eq(por(a, b), pzero(a));
-    return pandnot(cst_one, a_nor_b);
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
+    EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
+      return por(a, b);
+    } else {
+      const Packet cst_one = pset1<Packet>(Scalar(1));
+      // if or(a,b) == 0, then a == 0 and b == 0
+      // or(a,b) == !nor(a,b)
+      Packet a_nor_b = pcmp_eq(por(a, b), pzero(a));
+      return pandnot(cst_one, a_nor_b);
+    }
   }
 };
+template <>
+EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE bool scalar_boolean_or_op<bool>::operator()(const bool& a,
+                                                                                            const bool& b) const {
+  return a | b;
+}
 template <typename Scalar>
 struct functor_traits<scalar_boolean_or_op<Scalar>> {
   enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasCmp };
@@ -506,13 +581,17 @@
     return (a != Scalar(0)) != (b != Scalar(0)) ? Scalar(1) : Scalar(0);
   }
   template <typename Packet>
-  EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
-    const Packet cst_one = pset1<Packet>(Scalar(1));
-    // xor(a,b) == xor(!a,!b)
-    Packet not_a = pcmp_eq(a, pzero(a));
-    Packet not_b = pcmp_eq(b, pzero(b));
-    Packet a_xor_b = pxor(not_a, not_b);
-    return pand(cst_one, a_xor_b);
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const {
+    EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
+      return pxor(a, b);
+    } else {
+      const Packet cst_one = pset1<Packet>(Scalar(1));
+      // xor(a,b) == xor(!a,!b)
+      Packet not_a = pcmp_eq(a, pzero(a));
+      Packet not_b = pcmp_eq(b, pzero(b));
+      Packet a_xor_b = pxor(not_a, not_b);
+      return pand(cst_one, a_xor_b);
+    }
   }
 };
 template <typename Scalar>
@@ -573,7 +652,7 @@
 struct scalar_bitwise_and_op {
   EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
                       BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
-  EIGEN_STATIC_ASSERT((!internal::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
+  EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
   using result_type = Scalar;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const {
     return bitwise_binary_impl<Scalar>::run_and(a, b);
@@ -597,7 +676,7 @@
 struct scalar_bitwise_or_op {
   EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
                       BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
-  EIGEN_STATIC_ASSERT((!internal::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
+  EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
   using result_type = Scalar;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const {
     return bitwise_binary_impl<Scalar>::run_or(a, b);
@@ -621,7 +700,7 @@
 struct scalar_bitwise_xor_op {
   EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
                       BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
-  EIGEN_STATIC_ASSERT((!internal::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
+  EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
   using result_type = Scalar;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const {
     return bitwise_binary_impl<Scalar>::run_xor(a, b);
@@ -643,7 +722,7 @@
  */
 template <typename LhsScalar, typename RhsScalar>
 struct scalar_absolute_difference_op : binary_op_base<LhsScalar, RhsScalar> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_absolute_difference_op>::ReturnType result_type;
+  using result_type = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, scalar_absolute_difference_op>::ReturnType;
 #ifdef EIGEN_SCALAR_BINARY_OP_PLUGIN
   scalar_absolute_difference_op(){EIGEN_SCALAR_BINARY_OP_PLUGIN}
 #endif
@@ -660,7 +739,7 @@
 struct functor_traits<scalar_absolute_difference_op<LhsScalar, RhsScalar>> {
   enum {
     Cost = (NumTraits<LhsScalar>::AddCost + NumTraits<RhsScalar>::AddCost) / 2,
-    PacketAccess = is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasAbsDiff
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<LhsScalar>::HasAbsDiff
   };
 };
 
@@ -669,7 +748,7 @@
   using Scalar = LhsScalar;
 
   static constexpr bool Enable =
-      is_same<LhsScalar, RhsScalar>::value && !NumTraits<Scalar>::IsInteger && !NumTraits<Scalar>::IsComplex;
+      std::is_same<LhsScalar, RhsScalar>::value && !NumTraits<Scalar>::IsInteger && !NumTraits<Scalar>::IsComplex;
   EIGEN_STATIC_ASSERT(Enable, "LhsScalar and RhsScalar must be the same non-integer, non-complex type")
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& y, const Scalar& x) const {
@@ -685,7 +764,7 @@
 struct functor_traits<scalar_atan2_op<LhsScalar, RhsScalar>> {
   using Scalar = LhsScalar;
   enum {
-    PacketAccess = is_same<LhsScalar, RhsScalar>::value && packet_traits<Scalar>::HasATan &&
+    PacketAccess = std::is_same<LhsScalar, RhsScalar>::value && packet_traits<Scalar>::HasATan &&
                    packet_traits<Scalar>::HasDiv && !NumTraits<Scalar>::IsInteger && !NumTraits<Scalar>::IsComplex,
     Cost = int(scalar_div_cost<Scalar, PacketAccess>::value) + int(functor_traits<scalar_atan_op<Scalar>>::Cost)
   };
@@ -694,14 +773,12 @@
 //---------- binary functors bound to a constant, thus appearing as a unary functor ----------
 
 // The following two classes permits to turn any binary functor into a unary one with one argument bound to a constant
-// value. They are analogues to std::binder1st/binder2nd but with the following differences:
-//  - they are compatible with packetOp
-//  - they are portable across C++ versions (the std::binder* are deprecated in C++11)
+// value. They are analogues to the removed std::binder1st/binder2nd and are also compatible with packetOp.
 template <typename BinaryOp>
 struct bind1st_op : BinaryOp {
-  typedef typename BinaryOp::first_argument_type first_argument_type;
-  typedef typename BinaryOp::second_argument_type second_argument_type;
-  typedef typename BinaryOp::result_type result_type;
+  using first_argument_type = typename BinaryOp::first_argument_type;
+  using second_argument_type = typename BinaryOp::second_argument_type;
+  using result_type = typename BinaryOp::result_type;
 
   EIGEN_DEVICE_FUNC constexpr explicit bind1st_op(const first_argument_type& val) : m_value(val) {}
 
@@ -721,9 +798,9 @@
 
 template <typename BinaryOp>
 struct bind2nd_op : BinaryOp {
-  typedef typename BinaryOp::first_argument_type first_argument_type;
-  typedef typename BinaryOp::second_argument_type second_argument_type;
-  typedef typename BinaryOp::result_type result_type;
+  using first_argument_type = typename BinaryOp::first_argument_type;
+  using second_argument_type = typename BinaryOp::second_argument_type;
+  using result_type = typename BinaryOp::result_type;
 
   EIGEN_DEVICE_FUNC constexpr explicit bind2nd_op(const second_argument_type& val) : m_value(val) {}
 
diff --git a/Eigen/src/Core/functors/NullaryFunctors.h b/Eigen/src/Core/functors/NullaryFunctors.h
index d8fc78a..e39355d 100644
--- a/Eigen/src/Core/functors/NullaryFunctors.h
+++ b/Eigen/src/Core/functors/NullaryFunctors.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_NULLARY_FUNCTORS_H
 #define EIGEN_NULLARY_FUNCTORS_H
@@ -65,7 +66,7 @@
 
 template <typename Scalar>
 struct linspaced_op_impl<Scalar, /*IsInteger*/ false> {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   EIGEN_DEVICE_FUNC constexpr linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps)
       : m_low(low),
@@ -171,8 +172,6 @@
 
 template <typename Scalar>
 struct equalspaced_op {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
   EIGEN_DEVICE_FUNC constexpr equalspaced_op(const Scalar& start, const Scalar& step) : m_start(start), m_step(step) {}
   template <typename IndexType>
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(IndexType i) const {
@@ -207,65 +206,7 @@
 // and linear access is not possible. In all other cases, linear access is enabled.
 // Users should not have to deal with this structure.
 template <typename Functor>
-struct functor_has_linear_access {
-  enum { ret = !has_binary_operator<Functor>::value };
-};
-
-// For unreliable compilers, let's specialize the has_*ary_operator
-// helpers so that at least built-in nullary functors work fine.
-#if !(EIGEN_COMP_MSVC || EIGEN_COMP_GNUC || (EIGEN_COMP_ICC >= 1600))
-template <typename Scalar, typename IndexType>
-struct has_nullary_operator<scalar_constant_op<Scalar>, IndexType> {
-  enum { value = 1 };
-};
-template <typename Scalar, typename IndexType>
-struct has_unary_operator<scalar_constant_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-template <typename Scalar, typename IndexType>
-struct has_binary_operator<scalar_constant_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-
-template <typename Scalar, typename IndexType>
-struct has_nullary_operator<scalar_identity_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-template <typename Scalar, typename IndexType>
-struct has_unary_operator<scalar_identity_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-template <typename Scalar, typename IndexType>
-struct has_binary_operator<scalar_identity_op<Scalar>, IndexType> {
-  enum { value = 1 };
-};
-
-template <typename Scalar, typename IndexType>
-struct has_nullary_operator<linspaced_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-template <typename Scalar, typename IndexType>
-struct has_unary_operator<linspaced_op<Scalar>, IndexType> {
-  enum { value = 1 };
-};
-template <typename Scalar, typename IndexType>
-struct has_binary_operator<linspaced_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-
-template <typename Scalar, typename IndexType>
-struct has_nullary_operator<scalar_random_op<Scalar>, IndexType> {
-  enum { value = 1 };
-};
-template <typename Scalar, typename IndexType>
-struct has_unary_operator<scalar_random_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-template <typename Scalar, typename IndexType>
-struct has_binary_operator<scalar_random_op<Scalar>, IndexType> {
-  enum { value = 0 };
-};
-#endif
+using functor_has_linear_access = bool_constant<!has_binary_operator<Functor>::value>;
 
 }  // end namespace internal
 
diff --git a/Eigen/src/Core/functors/StlFunctors.h b/Eigen/src/Core/functors/StlFunctors.h
index 0599ce3..2976b41 100644
--- a/Eigen/src/Core/functors/StlFunctors.h
+++ b/Eigen/src/Core/functors/StlFunctors.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STL_FUNCTORS_H
 #define EIGEN_STL_FUNCTORS_H
diff --git a/Eigen/src/Core/functors/TernaryFunctors.h b/Eigen/src/Core/functors/TernaryFunctors.h
index 9a4ea48..a53eec8 100644
--- a/Eigen/src/Core/functors/TernaryFunctors.h
+++ b/Eigen/src/Core/functors/TernaryFunctors.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TERNARY_FUNCTORS_H
 #define EIGEN_TERNARY_FUNCTORS_H
@@ -22,7 +23,7 @@
 template <typename ThenScalar, typename ElseScalar, typename ConditionScalar>
 struct scalar_boolean_select_op {
   static constexpr bool ThenElseAreSame =
-      is_same<std::remove_const_t<ThenScalar>, std::remove_const_t<ElseScalar>>::value;
+      std::is_same<std::remove_const_t<ThenScalar>, std::remove_const_t<ElseScalar>>::value;
   EIGEN_STATIC_ASSERT(ThenElseAreSame, THEN AND ELSE MUST BE SAME TYPE)
   using Scalar = ThenScalar;
   using result_type = Scalar;
@@ -41,7 +42,7 @@
   using Scalar = ThenScalar;
   enum {
     Cost = 1,
-    PacketAccess = is_same<ThenScalar, ElseScalar>::value && is_same<ConditionScalar, Scalar>::value &&
+    PacketAccess = std::is_same<ThenScalar, ElseScalar>::value && std::is_same<ConditionScalar, Scalar>::value &&
                    packet_traits<Scalar>::HasCmp
   };
 };
diff --git a/Eigen/src/Core/functors/UnaryFunctors.h b/Eigen/src/Core/functors/UnaryFunctors.h
index 99cda3d..7b9f7e9 100644
--- a/Eigen/src/Core/functors/UnaryFunctors.h
+++ b/Eigen/src/Core/functors/UnaryFunctors.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_UNARY_FUNCTORS_H
 #define EIGEN_UNARY_FUNCTORS_H
@@ -24,6 +25,8 @@
  */
 template <typename Scalar>
 struct scalar_opposite_op {
+  EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value),
+                      BOOLEAN_NEGATION_IS_NOT_SUPPORTED__CAST_TO_A_SIGNED_INTEGER_TYPE)
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const { return numext::negate(a); }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
@@ -42,7 +45,7 @@
  */
 template <typename Scalar>
 struct scalar_abs_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
     return numext::abs(a);
   }
@@ -63,7 +66,7 @@
  */
 template <typename Scalar>
 struct scalar_score_coeff_op : scalar_abs_op<Scalar> {
-  typedef void Score_is_abs;
+  using Score_is_abs = void;
 };
 template <typename Scalar>
 struct functor_traits<scalar_score_coeff_op<Scalar>> : functor_traits<scalar_abs_op<Scalar>> {};
@@ -71,7 +74,7 @@
 /* Avoid recomputing abs when we know the score and they are the same. Not a true Eigen functor.  */
 template <typename Scalar, typename = void>
 struct abs_knowing_score {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   template <typename Score>
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a, const Score&) const {
     return numext::abs(a);
@@ -79,7 +82,7 @@
 };
 template <typename Scalar>
 struct abs_knowing_score<Scalar, typename scalar_score_coeff_op<Scalar>::Score_is_abs> {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   template <typename Scal>
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scal&, const result_type& a) const {
     return a;
@@ -93,7 +96,7 @@
  */
 template <typename Scalar>
 struct scalar_abs2_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
     return numext::abs2(a);
   }
@@ -146,7 +149,7 @@
  */
 template <typename Scalar>
 struct scalar_arg_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
     return numext::arg(a);
   }
@@ -182,7 +185,11 @@
 template <typename Scalar>
 struct functor_traits<scalar_carg_op<Scalar>> {
   using RealScalar = typename NumTraits<Scalar>::Real;
-  enum { Cost = functor_traits<scalar_atan2_op<RealScalar>>::Cost, PacketAccess = packet_traits<RealScalar>::HasATan };
+  enum {
+    Cost = functor_traits<scalar_atan2_op<RealScalar>>::Cost,
+    // The generic pcarg lowers to patan2, whose quotient-based reduction needs pdiv.
+    PacketAccess = packet_traits<RealScalar>::HasATan && packet_traits<RealScalar>::HasDiv
+  };
 };
 
 /** \internal
@@ -192,7 +199,7 @@
  */
 template <typename Scalar, typename NewType>
 struct scalar_cast_op {
-  typedef NewType result_type;
+  using result_type = NewType;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE NewType operator()(const Scalar& a) const {
     return cast<Scalar, NewType>(a);
   }
@@ -200,7 +207,7 @@
 
 template <typename Scalar, typename NewType>
 struct functor_traits<scalar_cast_op<Scalar, NewType>> {
-  enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false };
+  enum { Cost = std::is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false };
 };
 
 /** \internal
@@ -216,7 +223,7 @@
 struct functor_traits<core_cast_op<SrcType, DstType>> {
   using CastingTraits = type_casting_traits<SrcType, DstType>;
   enum {
-    Cost = is_same<SrcType, DstType>::value ? 0 : NumTraits<DstType>::AddCost,
+    Cost = std::is_same<SrcType, DstType>::value ? 0 : NumTraits<DstType>::AddCost,
     PacketAccess = CastingTraits::VectorizedCast && (CastingTraits::SrcCoeffRatio <= 8)
   };
 };
@@ -224,12 +231,12 @@
 /** \internal
  * \brief Template functor to arithmetically shift a scalar right by a number of bits
  *
- * \sa class CwiseUnaryOp, MatrixBase::shift_right()
+ * \sa class CwiseUnaryOp, ArrayBase::arithmeticShiftRight()
  */
 template <typename Scalar, int N>
-struct scalar_shift_right_op {
+struct scalar_arithmetic_shift_right_op {
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
-    return numext::arithmetic_shift_right(a);
+    return numext::arithmetic_shift_right(a, N);
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
@@ -237,19 +244,39 @@
   }
 };
 template <typename Scalar, int N>
-struct functor_traits<scalar_shift_right_op<Scalar, N>> {
+struct functor_traits<scalar_arithmetic_shift_right_op<Scalar, N>> {
+  enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift };
+};
+
+/** \internal
+ * \brief Template functor to logically shift a scalar right by a number of bits
+ *
+ * \sa class CwiseUnaryOp, ArrayBase::logicalShiftRight()
+ */
+template <typename Scalar, int N>
+struct scalar_logical_shift_right_op {
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
+    return numext::logical_shift_right(a, N);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
+    return internal::plogical_shift_right<N>(a);
+  }
+};
+template <typename Scalar, int N>
+struct functor_traits<scalar_logical_shift_right_op<Scalar, N>> {
   enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift };
 };
 
 /** \internal
  * \brief Template functor to logically shift a scalar left by a number of bits
  *
- * \sa class CwiseUnaryOp, MatrixBase::shift_left()
+ * \sa class CwiseUnaryOp, ArrayBase::logicalShiftLeft()
  */
 template <typename Scalar, int N>
-struct scalar_shift_left_op {
+struct scalar_logical_shift_left_op {
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
-    return numext::logical_shift_left(a);
+    return numext::logical_shift_left(a, N);
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
@@ -257,7 +284,7 @@
   }
 };
 template <typename Scalar, int N>
-struct functor_traits<scalar_shift_left_op<Scalar, N>> {
+struct functor_traits<scalar_logical_shift_left_op<Scalar, N>> {
   enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasShift };
 };
 
@@ -268,7 +295,7 @@
  */
 template <typename Scalar>
 struct scalar_real_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
     return numext::real(a);
   }
@@ -285,7 +312,7 @@
  */
 template <typename Scalar>
 struct scalar_imag_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
     return numext::imag(a);
   }
@@ -302,7 +329,7 @@
  */
 template <typename Scalar>
 struct scalar_real_ref_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const result_type& operator()(const Scalar& a) const {
     return numext::real_ref(a);
   }
@@ -322,7 +349,12 @@
  */
 template <typename Scalar>
 struct scalar_imag_ref_op {
-  typedef typename NumTraits<Scalar>::Real result_type;
+  // For a real Scalar, numext::imag_ref returns the temporary RealScalar(0) by value; binding it to the
+  // reference return types below would dangle (issue #3096). Real-valued objects get a read-only zero
+  // expression from imag() instead (see NonConstImagReturnType in CommonCwiseUnaryOps.inc).
+  static_assert(NumTraits<Scalar>::IsComplex,
+                "THE IMAGINARY PART OF A REAL-VALUED OBJECT IS NOT AN LVALUE. USE THE READ-ONLY imag() OVERLOAD.");
+  using result_type = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type& operator()(Scalar& a) const {
     return numext::imag_ref(a);
   }
@@ -391,6 +423,38 @@
 
 /** \internal
  *
+ * \brief Multiplies a scalar by 2 raised to a fixed integer exponent.
+ *
+ * \sa class CwiseUnaryOp, ArrayBase::ldexp()
+ */
+template <typename Scalar>
+struct scalar_ldexp_op {
+  static_assert(!NumTraits<Scalar>::IsComplex && !NumTraits<Scalar>::IsInteger,
+                "ldexp is only defined for real floating-point scalar types");
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit scalar_ldexp_op(int exponent) : m_exponent(exponent) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
+    return numext::ldexp(a, m_exponent);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
+    // pldexp clamps exponents, so a saturating conversion to Scalar is safe.
+    return internal::pldexp(a, pset1<Packet>(static_cast<Scalar>(m_exponent)));
+  }
+
+ private:
+  const int m_exponent;
+};
+template <typename Scalar>
+struct functor_traits<scalar_ldexp_op<Scalar>> {
+  enum {
+    // HasExp packets already require a tested pldexp implementation.
+    PacketAccess = packet_traits<Scalar>::HasExp,
+    Cost = 4 * NumTraits<Scalar>::MulCost
+  };
+};
+
+/** \internal
+ *
  * \brief Template functor to compute the exponential of a scalar - 1.
  *
  * \sa class CwiseUnaryOp, ArrayBase::expm1()
@@ -705,7 +769,7 @@
 struct functor_traits<scalar_tanh_op<Scalar>> {
   enum {
     PacketAccess = packet_traits<Scalar>::HasTanh,
-    Cost = ((EIGEN_FAST_MATH && is_same<Scalar, float>::value)
+    Cost = ((EIGEN_FAST_MATH && std::is_same<Scalar, float>::value)
 // The following numbers are based on the AVX implementation,
 #ifdef EIGEN_VECTORIZE_FMA
                 // Haswell can issue 2 add/mul/madd per cycle.
@@ -765,11 +829,15 @@
 template <typename Scalar>
 struct scalar_asinh_op {
   EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const { return numext::asinh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
+    return internal::pasinh(a);
+  }
 };
 
 template <typename Scalar>
 struct functor_traits<scalar_asinh_op<Scalar>> {
-  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasASinh };
 };
 
 /** \internal
@@ -796,11 +864,15 @@
 template <typename Scalar>
 struct scalar_acosh_op {
   EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const { return numext::acosh(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
+    return internal::pacosh(a);
+  }
 };
 
 template <typename Scalar>
 struct functor_traits<scalar_acosh_op<Scalar>> {
-  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false };
+  enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasACosh };
 };
 
 /** \internal
@@ -833,7 +905,7 @@
  */
 template <typename Scalar>
 struct scalar_square_op {
-  EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const { return a * a; }
+  EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const { return internal::mul(a, a); }
   template <typename Packet>
   EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
     return internal::pmul(a, a);
@@ -864,7 +936,9 @@
  */
 template <typename Scalar>
 struct scalar_cube_op {
-  EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const { return a * a * a; }
+  EIGEN_DEVICE_FUNC constexpr inline Scalar operator()(const Scalar& a) const {
+    return internal::mul(a, internal::mul(a, a));
+  }
   template <typename Packet>
   EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
     return internal::pmul(a, pmul(a, a));
@@ -1084,8 +1158,7 @@
   }
   template <typename Packet>
   EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
-    constexpr Scalar inf = NumTraits<Scalar>::infinity();
-    return pcmp_lt(pabs(a), pset1<Packet>(inf));
+    return pisfinite(a);
   }
 };
 template <typename Scalar, bool UseTypedPredicate>
@@ -1107,10 +1180,15 @@
     return a == Scalar(0) ? Scalar(1) : Scalar(0);
   }
   template <typename Packet>
-  EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const {
     const Packet cst_one = pset1<Packet>(Scalar(1));
-    Packet not_a = pcmp_eq(a, pzero(a));
-    return pand(not_a, cst_one);
+    EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, bool>::value)) {
+      // Boolean packet lanes are canonical, so logical NOT is 1 & ~a.
+      return pandnot(cst_one, a);
+    } else {
+      Packet not_a = pcmp_eq(a, pzero(a));
+      return pand(not_a, cst_one);
+    }
   }
 };
 template <typename Scalar>
@@ -1148,7 +1226,7 @@
 struct scalar_bitwise_not_op {
   EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::RequireInitialization,
                       BITWISE OPERATIONS MAY ONLY BE PERFORMED ON PLAIN DATA TYPES)
-  EIGEN_STATIC_ASSERT((!internal::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
+  EIGEN_STATIC_ASSERT((!std::is_same<Scalar, bool>::value), DONT USE BITWISE OPS ON BOOLEAN TYPES)
   using result_type = Scalar;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
     return bitwise_unary_impl<Scalar>::run_not(a);
@@ -1201,7 +1279,7 @@
   }
 };
 
-// Complex-valud implementation.
+// Complex-valued implementation.
 template <typename T>
 struct scalar_logistic_op_impl<T, std::enable_if_t<NumTraits<T>::IsComplex>> {
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE T operator()(const T& x) const {
@@ -1228,7 +1306,7 @@
  * pexp_float. See the individual steps described in the code below.
  * Note that compared to pexp, we use an additional outer multiplicative
  * range reduction step using the identity exp(x) = exp(x/2)^2.
- * This prevert us from having to call ldexp on values that could produce
+ * This prevents us from having to call ldexp on values that could produce
  * a denormal result, which allows us to call the faster implementation in
  * pldexp_fast_impl<Packet>::run(p, m).
  * The final squaring, however, doubles the error bound on the final
@@ -1304,18 +1382,20 @@
     return pselect(zero_mask, cst_zero, pdiv(e, padd(cst_one, e)));
   }
 };
-#endif  // #ifndef EIGEN_GPU_COMPILE_PHASE
+#endif  // #ifndef EIGEN_GPUCC
 
 template <typename T>
 struct functor_traits<scalar_logistic_op<T>> {
   enum {
-    // The cost estimate for float here here is for the common(?) case where
+    // The cost estimate for float here is for the common(?) case where
     // all arguments are greater than -9.
     Cost = scalar_div_cost<T, packet_traits<T>::HasDiv>::value +
-           (internal::is_same<T, float>::value ? NumTraits<T>::AddCost * 15 + NumTraits<T>::MulCost * 11
-                                               : NumTraits<T>::AddCost * 2 + functor_traits<scalar_exp_op<T>>::Cost),
+           (std::is_same<T, float>::value ? NumTraits<T>::AddCost * 15 + NumTraits<T>::MulCost * 11
+                                          : NumTraits<T>::AddCost * 2 + functor_traits<scalar_exp_op<T>>::Cost),
+    // Both packet paths branch with pcmp_*/pselect.
     PacketAccess = !NumTraits<T>::IsComplex && packet_traits<T>::HasAdd && packet_traits<T>::HasDiv &&
-                   (internal::is_same<T, float>::value
+                   packet_traits<T>::HasCmp &&
+                   (std::is_same<T, float>::value
                         ? packet_traits<T>::HasMul && packet_traits<T>::HasMax && packet_traits<T>::HasMin
                         : packet_traits<T>::HasNegate && packet_traits<T>::HasExp)
   };
@@ -1326,11 +1406,10 @@
           bool IsBaseComplex = NumTraits<Scalar>::IsComplex,
           bool IsExponentComplex = NumTraits<ExponentScalar>::IsComplex>
 struct scalar_unary_pow_op {
-  typedef typename internal::promote_scalar_arg<
+  using PromotedExponent = typename internal::promote_scalar_arg<
       Scalar, ExponentScalar,
-      internal::has_ReturnType<ScalarBinaryOpTraits<Scalar, ExponentScalar, scalar_unary_pow_op>>::value>::type
-      PromotedExponent;
-  typedef typename ScalarBinaryOpTraits<Scalar, PromotedExponent, scalar_unary_pow_op>::ReturnType result_type;
+      internal::has_ReturnType<ScalarBinaryOpTraits<Scalar, ExponentScalar, scalar_unary_pow_op>>::value>::type;
+  using result_type = typename ScalarBinaryOpTraits<Scalar, PromotedExponent, scalar_unary_pow_op>::ReturnType;
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE scalar_unary_pow_op(const ExponentScalar& exponent)
       : m_exponent(exponent) {}
   EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
@@ -1418,4 +1497,4 @@
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_FUNCTORS_H
+#endif  // EIGEN_UNARY_FUNCTORS_H
diff --git a/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/Eigen/src/Core/products/GeneralBlockPanelKernel.h
index cc22dc7..358ffc0 100644
--- a/Eigen/src/Core/products/GeneralBlockPanelKernel.h
+++ b/Eigen/src/Core/products/GeneralBlockPanelKernel.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERAL_BLOCK_PANEL_H
 #define EIGEN_GENERAL_BLOCK_PANEL_H
@@ -13,6 +14,13 @@
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
 
+// C4804: unsafe use of type 'bool' in operation. Unavoidable in generic code
+// instantiated with bool scalars (e.g. += and * on bool).
+#if EIGEN_COMP_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4804)
+#endif
+
 namespace Eigen {
 
 namespace internal {
@@ -73,9 +81,9 @@
 
 /** \internal */
 struct CacheSizes {
-  CacheSizes() : m_l1(-1), m_l2(-1), m_l3(-1) {
-    int l1CacheSize, l2CacheSize, l3CacheSize;
-    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
+  CacheSizes() : m_l1(-1), m_l2(-1), m_l3(-1), m_l3_per_cpu(0) {
+    std::ptrdiff_t l1CacheSize, l2CacheSize, l3CacheSize;
+    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize, m_l3_per_cpu);
     m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
     m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
     m_l3 = manage_caching_sizes_helper(l3CacheSize, defaultL3CacheSize);
@@ -84,10 +92,14 @@
   std::ptrdiff_t m_l1;
   std::ptrdiff_t m_l2;
   std::ptrdiff_t m_l3;
+  // Bytes of L3 backing one CPU, or 0 when unknown. Cleared by setCpuCacheSizes so that an
+  // explicit override is never overruled by the detected geometry.
+  std::ptrdiff_t m_l3_per_cpu;
 };
 
 /** \internal */
-inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1, std::ptrdiff_t* l2, std::ptrdiff_t* l3) {
+inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1, std::ptrdiff_t* l2, std::ptrdiff_t* l3,
+                                 std::ptrdiff_t* l3_per_cpu = nullptr) {
   static CacheSizes m_cacheSizes;
 
   if (action == SetAction) {
@@ -96,10 +108,12 @@
     m_cacheSizes.m_l1 = *l1;
     m_cacheSizes.m_l2 = *l2;
     m_cacheSizes.m_l3 = *l3;
+    m_cacheSizes.m_l3_per_cpu = l3_per_cpu != nullptr ? *l3_per_cpu : 0;
   } else if (action == GetAction) {
     eigen_internal_assert(l1 != 0 && l2 != 0);
     *l1 = m_cacheSizes.m_l1;
     *l2 = m_cacheSizes.m_l2;
+    if (l3_per_cpu != nullptr) *l3_per_cpu = m_cacheSizes.m_l3_per_cpu;
     *l3 = m_cacheSizes.m_l3;
   } else {
     eigen_internal_assert(false);
@@ -118,17 +132,94 @@
  *
  * \sa setCpuCacheSizes */
 
+#ifdef EIGEN_VECTORIZE_SME
+// True for the scalar pairs the SME gebp_kernel specializes (see
+// arch/SME/GeneralBlockPanelKernel.h, which static_asserts that it agrees with
+// this list); every other pair keeps Eigen's generic kernel, packers, cache
+// blocking and GEMM loop order.
+template <typename LhsScalar, typename RhsScalar>
+struct sme_has_gebp_kernel : std::false_type {};
+template <>
+struct sme_has_gebp_kernel<float, float> : std::true_type {};
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+template <>
+struct sme_has_gebp_kernel<double, double> : std::true_type {};
+#endif
+// A complex accumulator is a pair of the corresponding real ZA tiles, so the
+// complex kernels exist exactly where the real ones do.
+template <typename RealScalar>
+struct sme_has_gebp_kernel<std::complex<RealScalar>, std::complex<RealScalar>>
+    : sme_has_gebp_kernel<RealScalar, RealScalar> {};
+
+// Overridable SME packed-panel budgets. The defaults are empirically tuned
+// fp32 working-set limits for Apple M4 — heuristic budgets, not generic ARM64
+// cache defaults; redefine them to retune for other SME implementations.
+#ifndef EIGEN_SME_MAX_KC
+#define EIGEN_SME_MAX_KC 2048
+#endif
+#ifndef EIGEN_SME_PACKED_RHS_BUDGET_BYTES
+#define EIGEN_SME_PACKED_RHS_BUDGET_BYTES (32 * 1024 * 1024)
+#endif
+#ifndef EIGEN_SME_LHS_WORKING_SET_BUDGET_BYTES
+#define EIGEN_SME_LHS_WORKING_SET_BUDGET_BYTES (7 * 1024 * 1024)
+#endif
+
+template <typename LhsScalar, typename RhsScalar, typename Index>
+void evaluateProductBlockingSizesHeuristicForSme(Index& k, Index& m, Index& n) {
+  using Traits = gebp_traits<LhsScalar, RhsScalar>;
+
+  const Index mr = static_cast<Index>(Traits::mr);
+  const Index nr = static_cast<Index>(Traits::nr);
+
+#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
+  // Fixed scaled-down budgets so that test-sized products (see
+  // EIGEN_TEST_MAX_SIZE) exercise multi-pass blocking along all three
+  // dimensions. Like the l1/l2/l3 reduction applied to the generic heuristic
+  // below, this intentionally overrides any user-configured budgets.
+  constexpr Index sme_max_kc = static_cast<Index>(128);
+  constexpr Index sme_packed_rhs_budget_bytes = static_cast<Index>(128 * 1024);
+  constexpr Index sme_lhs_working_set_budget_bytes = static_cast<Index>(128 * 1024);
+#else
+  constexpr Index sme_max_kc = static_cast<Index>(EIGEN_SME_MAX_KC);
+  constexpr Index sme_packed_rhs_budget_bytes = static_cast<Index>(EIGEN_SME_PACKED_RHS_BUDGET_BYTES);
+  constexpr Index sme_lhs_working_set_budget_bytes = static_cast<Index>(EIGEN_SME_LHS_WORKING_SET_BUDGET_BYTES);
+#endif
+
+  // Keep kc large enough to amortize SME setup and accumulation, but cap very
+  // deep products to avoid too many result store passes. The cap is a scalar
+  // count tuned for fp32; scale it by the scalar width so every element type
+  // gets the same packed-panel byte budget.
+  const Index max_kc = (numext::maxi)(Index(1), sme_max_kc * Index(sizeof(float)) / Index(sizeof(LhsScalar)));
+  k = (numext::mini)(k, max_kc);
+
+  // Bound the packed RHS strip so very wide matrices do not allocate an
+  // unbounded blockB panel.
+  Index nc = sme_packed_rhs_budget_bytes / (numext::maxi)(Index(1), k * Index(sizeof(RhsScalar)));
+  nc = (nc / nr) * nr;
+  n = (numext::mini)(n, (numext::maxi)(nr, nc));
+
+  const Index block_b_hot_bytes = k * nr * Index(sizeof(RhsScalar));
+  const Index min_lhs_bytes = mr * k * Index(sizeof(LhsScalar));
+  const Index block_a_bytes = sme_lhs_working_set_budget_bytes > block_b_hot_bytes
+                                  ? sme_lhs_working_set_budget_bytes - block_b_hot_bytes
+                                  : min_lhs_bytes;
+  Index mc = block_a_bytes / (k * Index(sizeof(LhsScalar)));
+  mc = (mc / mr) * mr;
+  m = (numext::mini)(m, (numext::maxi)(mr, mc));
+}
+#endif
+
 template <typename LhsScalar, typename RhsScalar, int KcFactor, typename Index>
 void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1) {
-  typedef gebp_traits<LhsScalar, RhsScalar> Traits;
+  using Traits = gebp_traits<LhsScalar, RhsScalar>;
 
   // Explanations:
   // Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
   // kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
   // per mr x kc horizontal small panels where mr is the blocking size along the m dimension
   // at the register level. This small horizontal panel has to stay within L1 cache.
-  std::ptrdiff_t l1, l2, l3;
-  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  std::ptrdiff_t l1, l2, l3, l3_per_cpu;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3, &l3_per_cpu);
 #ifdef EIGEN_VECTORIZE_AVX512
   const std::ptrdiff_t phys_l1 = l1;
   // We need to find a rationale for that, but without this adjustment,
@@ -142,7 +233,7 @@
 #endif
 
   if (num_threads > 1) {
-    typedef typename Traits::ResScalar ResScalar;
+    using ResScalar = typename Traits::ResScalar;
     enum {
       kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
       ksub = Traits::mr * (Traits::nr * sizeof(ResScalar)),
@@ -162,11 +253,15 @@
     }
 
     const Index n_cache = static_cast<Index>((l2 - l1) / (nr * sizeof(RhsScalar) * k));
+    const Index nr_index = static_cast<Index>(nr);
+    // If the cache model says that even one kernel-width RHS panel does not fit,
+    // fall back to the minimum useful panel width instead of producing a zero block.
+    const Index n_cache_aligned = n_cache >= nr_index ? n_cache - (n_cache % nr_index) : nr_index;
     const Index n_per_thread = numext::div_ceil(n, num_threads);
     if (n_cache <= n_per_thread) {
-      // Don't exceed the capacity of the l2 cache.
-      eigen_internal_assert(n_cache >= static_cast<Index>(nr));
-      n = n_cache - (n_cache % nr);
+      // Don't exceed the capacity of the l2 cache unless the minimum panel width
+      // is already larger than the modeled capacity.
+      n = (numext::mini<Index>)(n, n_cache_aligned);
       eigen_internal_assert(n > 0);
     } else {
       n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
@@ -190,6 +285,8 @@
     l1 = 9 * 1024;
     l2 = 32 * 1024;
     l3 = 512 * 1024;
+    // The detected share would otherwise swamp these synthetic sizes and defeat the whole point.
+    l3_per_cpu = 0;
 #endif
 
     // Early return for small problems because the computation below are time consuming for small problems.
@@ -198,7 +295,16 @@
     // because we use the coefficient-based implementation for them.
     if ((numext::maxi)(k, (numext::maxi)(m, n)) < 48) return;
 
-    typedef typename Traits::ResScalar ResScalar;
+#ifdef EIGEN_VECTORIZE_SME
+    // Only the scalar pairs the SME kernel specializes use the SME budgets;
+    // the others run the generic kernel below and would thrash L1/L2 with them.
+    EIGEN_IF_CONSTEXPR ((sme_has_gebp_kernel<LhsScalar, RhsScalar>::value)) {
+      evaluateProductBlockingSizesHeuristicForSme<LhsScalar, RhsScalar>(k, m, n);
+      return;
+    }
+#endif
+
+    using ResScalar = typename Traits::ResScalar;
     enum {
       k_peeling = 8,
       k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
@@ -229,7 +335,7 @@
     // but can overfill the physical L1. Recompute max_kc using 85% of actual L1
     // to leave headroom for RHS streaming, prefetch buffers, and stack.
     {
-      const Index phys_l1_eff = phys_l1 * 85 / 100;
+      const Index phys_l1_eff = convert_index<Index>(phys_l1 * 85 / 100);
       const Index max_kc_phys = numext::maxi<Index>(((phys_l1_eff - k_sub) / k_div) & (~(k_peeling - 1)), k_peeling);
       if (max_kc_phys < k) {
         k = (old_k % max_kc_phys) == 0 ? max_kc_phys
@@ -251,6 +357,15 @@
     const Index actual_l2 = static_cast<Index>(l2 * 3 / 2);
 #endif
 
+    // Budget for the packed rhs panel. The 1.5x above stands in for an L3 whose geometry was
+    // unknown, and was calibrated against a 1MB placeholder L2, so it underestimates the reachable
+    // working set on a core whose real L2 is much smaller. Prefer this CPU's measured share of L3
+    // where the platform reports it -- a share rather than the whole cache, since sizing one CPU's
+    // panel to all of a server's L3 would evict every other CPU's working set. This deliberately
+    // does not feed actual_lm below: that governs the blockA allocation, whose L1/L2 tuning is
+    // separate.
+    const Index rhs_panel_budget = numext::maxi<Index>(actual_l2, static_cast<Index>(l3_per_cpu));
+
     // Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
     // The second half is implicitly reserved to access the result and lhs coefficients.
     // When k<max_kc, then nc can grow without bound. In practice, it seems to be fruitful
@@ -266,10 +381,13 @@
     } else {
       // L2 blocking: use actual kc (k) rather than max_kc so that nc is not
       // unnecessarily squeezed when k < max_kc (e.g. on CPUs with large L1).
-      max_nc = (3 * actual_l2) / (2 * 2 * k * sizeof(RhsScalar));
+      max_nc = (3 * rhs_panel_budget) / (2 * 2 * k * sizeof(RhsScalar));
     }
     // WARNING Below, we assume that Traits::nr is a power of two.
-    Index nc = numext::mini<Index>(actual_l2 / (2 * k * sizeof(RhsScalar)), max_nc) & (~(Traits::nr - 1));
+    Index nc = numext::mini<Index>(rhs_panel_budget / (2 * k * sizeof(RhsScalar)), max_nc) & (~(Traits::nr - 1));
+    // As in the threaded branch, a budget below one kernel-width panel still takes nr columns: a zero
+    // width would divide by zero below.
+    nc = numext::maxi<Index>(nc, Traits::nr);
     if (n > nc) {
       // We are really blocking over the columns:
       // -> reduce blocking size to make sure the last block is as large as possible
@@ -277,10 +395,15 @@
       //    Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
       n = (n % nc) == 0 ? nc : (nc - Traits::nr * ((nc /*-1*/ - (n % nc)) / (Traits::nr * (n / nc + 1))));
     } else if (old_k == k) {
-      // So far, no blocking at all, i.e., kc==k, and nc==n.
-      // In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
-      // TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic
-      // here should be obsolete.
+      // No k- or n-blocking happened yet (kc==depth, nc>=n). gebp already
+      // strip-chunks the packed lhs via its own `actual_panel_rows` budget,
+      // so cache residency is honored whatever mc we pick here. What this
+      // branch actually governs is the size of the `mc * kc` packing buffer
+      // (blockA) that the caller allocates — capping mc keeps it bounded for
+      // tall-m / small-k shapes, where leaving mc=m would allocate up to
+      // `rows * depth * sizeof(LhsScalar)`. A budget-based alternative
+      // (e.g. cap blockA at ~L3/4) is no faster in benchmarks and increases
+      // heap use, so the original L1/L2-residency tuning is kept.
       Index problem_size = k * n * sizeof(LhsScalar);
       Index actual_lm = actual_l2;
       Index max_mc = m;
@@ -288,9 +411,11 @@
         // problem is small enough to keep in L1
         // Let's choose m such that lhs's block fit in 1/3 of L1
         actual_lm = static_cast<Index>(l1);
-      } else if (l3 != 0 && problem_size <= 32768) {
-        // we have both L2 and L3, and problem is small enough to be kept in L2
-        // Let's choose m such that lhs's block fit in 1/3 of L2
+      } else if (l3 != 0 && problem_size <= l1) {
+        // We have both L2 and L3, and the rhs panel still fits in L1. Choose mc so the
+        // lhs block fits in 1/3 of L2 and avoid spilling into the L2+50% fallback band.
+        // The 32768 byte threshold previously used here was a stand-in for typical x86
+        // L1 size; using the runtime-detected l1 generalizes this to current cache sizes.
         actual_lm = static_cast<Index>(l2);
         max_mc = (numext::mini<Index>)(576, max_mc);
       }
@@ -314,9 +439,9 @@
     return true;
   }
 #else
-  EIGEN_UNUSED_VARIABLE(k)
-  EIGEN_UNUSED_VARIABLE(m)
-  EIGEN_UNUSED_VARIABLE(n)
+  EIGEN_UNUSED_VARIABLE(k);
+  EIGEN_UNUSED_VARIABLE(m);
+  EIGEN_UNUSED_VARIABLE(n);
 #endif
   return false;
 }
@@ -358,7 +483,7 @@
       (std::max)(int(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS) - registers_taken, 0);
 
  public:
-  typedef std::conditional_t<remaining_registers >= 4, RhsPacketx4, RhsPacket> type;
+  using type = std::conditional_t<remaining_registers >= 4, RhsPacketx4, RhsPacket>;
 };
 
 template <typename Packet>
@@ -372,17 +497,17 @@
 
 template <int N, typename T1, typename T2, typename T3>
 struct packet_conditional {
-  typedef T3 type;
+  using type = T3;
 };
 
 template <typename T1, typename T2, typename T3>
 struct packet_conditional<GEBPPacketFull, T1, T2, T3> {
-  typedef T1 type;
+  using type = T1;
 };
 
 template <typename T1, typename T2, typename T3>
 struct packet_conditional<GEBPPacketHalf, T1, T2, T3> {
-  typedef T2 type;
+  using type = T2;
 };
 
 #define PACKET_DECL_COND_POSTFIX(postfix, name, packet_size)                                               \
@@ -418,9 +543,9 @@
 template <typename LhsScalar_, typename RhsScalar_, bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>
 class gebp_traits {
  public:
-  typedef LhsScalar_ LhsScalar;
-  typedef RhsScalar_ RhsScalar;
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using LhsScalar = LhsScalar_;
+  using RhsScalar = RhsScalar_;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
 
   PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
   PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
@@ -456,13 +581,13 @@
     RhsProgress = 1
   };
 
-  typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> LhsPacket;
-  typedef std::conditional_t<Vectorizable, RhsPacket_, RhsScalar> RhsPacket;
-  typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> ResPacket;
-  typedef LhsPacket LhsPacket4Packing;
+  using LhsPacket = std::conditional_t<Vectorizable, LhsPacket_, LhsScalar>;
+  using RhsPacket = std::conditional_t<Vectorizable, RhsPacket_, RhsScalar>;
+  using ResPacket = std::conditional_t<Vectorizable, ResPacket_, ResScalar>;
+  using LhsPacket4Packing = LhsPacket;
 
-  typedef QuadPacket<RhsPacket> RhsPacketx4;
-  typedef ResPacket AccPacket;
+  using RhsPacketx4 = QuadPacket<RhsPacket>;
+  using AccPacket = ResPacket;
 
   EIGEN_STRONG_INLINE void initAcc(AccPacket& p) const { p = pset1<ResPacket>(ResScalar(0)); }
 
@@ -531,9 +656,9 @@
 template <typename RealScalar, bool ConjLhs_, int Arch, int PacketSize_>
 class gebp_traits<std::complex<RealScalar>, RealScalar, ConjLhs_, false, Arch, PacketSize_> {
  public:
-  typedef std::complex<RealScalar> LhsScalar;
-  typedef RealScalar RhsScalar;
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using LhsScalar = std::complex<RealScalar>;
+  using RhsScalar = RealScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
 
   PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
   PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
@@ -560,14 +685,14 @@
     RhsProgress = 1
   };
 
-  typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> LhsPacket;
-  typedef std::conditional_t<Vectorizable, RhsPacket_, RhsScalar> RhsPacket;
-  typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> ResPacket;
-  typedef LhsPacket LhsPacket4Packing;
+  using LhsPacket = std::conditional_t<Vectorizable, LhsPacket_, LhsScalar>;
+  using RhsPacket = std::conditional_t<Vectorizable, RhsPacket_, RhsScalar>;
+  using ResPacket = std::conditional_t<Vectorizable, ResPacket_, ResScalar>;
+  using LhsPacket4Packing = LhsPacket;
 
-  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  using RhsPacketx4 = QuadPacket<RhsPacket>;
 
-  typedef ResPacket AccPacket;
+  using AccPacket = ResPacket;
 
   EIGEN_STRONG_INLINE void initAcc(AccPacket& p) const { p = pset1<ResPacket>(ResScalar(0)); }
 
@@ -588,16 +713,16 @@
   EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
 
   EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest) const {
-    loadRhsQuad_impl(b, dest, std::conditional_t<RhsPacketSize == 16, true_type, false_type>());
+    loadRhsQuad_impl(b, dest, bool_constant<RhsPacketSize == 16>());
   }
 
-  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const true_type&) const {
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const std::true_type&) const {
     // FIXME: replace with a dedicated ploadheight operation for more efficient quad loading.
     RhsScalar tmp[4] = {b[0], b[0], b[1], b[1]};
     dest = ploadquad<RhsPacket>(tmp);
   }
 
-  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const false_type&) const {
+  EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket& dest, const std::false_type&) const {
     eigen_internal_assert(RhsPacketSize <= 8);
     dest = pset1<RhsPacket>(*b);
   }
@@ -612,12 +737,12 @@
   template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
   EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp,
                                 const LaneIdType&) const {
-    madd_impl(a, b, c, tmp, std::conditional_t<Vectorizable, true_type, false_type>());
+    madd_impl(a, b, c, tmp, bool_constant<Vectorizable>());
   }
 
   template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
   EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c,
-                                     RhsPacketType& tmp, const true_type&) const {
+                                     RhsPacketType& tmp, const std::true_type&) const {
 #ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
     EIGEN_UNUSED_VARIABLE(tmp);
     c.v = pmadd(a.v, b, c.v);
@@ -629,7 +754,7 @@
   }
 
   EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/,
-                                     const false_type&) const {
+                                     const std::false_type&) const {
     c += a * b;
   }
 
@@ -644,8 +769,6 @@
     conj_helper<ResPacketType, ResPacketType, ConjLhs, false> cj;
     r = cj.pmadd(c, alpha, r);
   }
-
- protected:
 };
 
 template <typename Packet>
@@ -662,66 +785,61 @@
   return res;
 }
 
-template <typename Packet>
-const DoublePacket<Packet>& predux_half(const DoublePacket<Packet>& a,
-                                        std::enable_if_t<unpacket_traits<Packet>::size <= 8>* = 0) {
+template <typename Packet, std::enable_if_t<unpacket_traits<Packet>::size <= 8, int> = 0>
+const DoublePacket<Packet>& predux_half(const DoublePacket<Packet>& a) {
   return a;
 }
 
-template <typename Packet>
-DoublePacket<typename unpacket_traits<Packet>::half> predux_half(
-    const DoublePacket<Packet>& a,
-    std::enable_if_t<unpacket_traits<Packet>::size >= 16 &&
-                     !NumTraits<typename unpacket_traits<Packet>::type>::IsComplex>* = 0) {
+template <typename Packet, std::enable_if_t<unpacket_traits<Packet>::size >= 16 &&
+                                                !NumTraits<typename unpacket_traits<Packet>::type>::IsComplex,
+                                            int> = 0>
+DoublePacket<typename unpacket_traits<Packet>::half> predux_half(const DoublePacket<Packet>& a) {
   // Workaround: reduce real packets to half size by reinterpreting as complex.
   DoublePacket<typename unpacket_traits<Packet>::half> res;
-  typedef std::complex<typename unpacket_traits<Packet>::type> Cplx;
-  typedef typename packet_traits<Cplx>::type CplxPacket;
+  using Cplx = std::complex<typename unpacket_traits<Packet>::type>;
+  using CplxPacket = typename packet_traits<Cplx>::type;
   res.first = predux_half(CplxPacket(a.first)).v;
   res.second = predux_half(CplxPacket(a.second)).v;
   return res;
 }
 
 // same here, "quad" actually means "8" in terms of real coefficients
-template <typename Scalar, typename RealPacket>
-void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest,
-                            std::enable_if_t<unpacket_traits<RealPacket>::size <= 8>* = 0) {
+template <typename Scalar, typename RealPacket, std::enable_if_t<unpacket_traits<RealPacket>::size <= 8, int> = 0>
+void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest) {
   dest.first = pset1<RealPacket>(numext::real(*b));
   dest.second = pset1<RealPacket>(numext::imag(*b));
 }
 
-template <typename Scalar, typename RealPacket>
-void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest,
-                            std::enable_if_t<unpacket_traits<RealPacket>::size == 16>* = 0) {
-  // Workaround: load quad elements by reinterpreting real packets as complex.
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  RealScalar r[4] = {numext::real(b[0]), numext::real(b[0]), numext::real(b[1]), numext::real(b[1])};
-  RealScalar i[4] = {numext::imag(b[0]), numext::imag(b[0]), numext::imag(b[1]), numext::imag(b[1])};
+// A real packet of N lanes carries N/8 complex values, each spread over eight
+// lanes. ploadquad repeats every element four times, so it needs each value
+// listed twice. Sized off N rather than a fixed 16: SVE reaches 32 real lanes
+// at VL=1024 and 64 at VL=2048, which no fixed overload covers.
+template <typename Scalar, typename RealPacket, std::enable_if_t<(unpacket_traits<RealPacket>::size > 8), int> = 0>
+void loadQuadToDoublePacket(const Scalar* b, DoublePacket<RealPacket>& dest) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  constexpr int kQuads = unpacket_traits<RealPacket>::size / 4;
+  RealScalar r[kQuads], i[kQuads];
+  for (int j = 0; j < kQuads; ++j) {
+    r[j] = numext::real(b[j / 2]);
+    i[j] = numext::imag(b[j / 2]);
+  }
   dest.first = ploadquad<RealPacket>(r);
   dest.second = ploadquad<RealPacket>(i);
 }
 
 template <typename Packet>
 struct unpacket_traits<DoublePacket<Packet>> {
-  typedef DoublePacket<typename unpacket_traits<Packet>::half> half;
+  using half = DoublePacket<typename unpacket_traits<Packet>::half>;
   enum { size = 2 * unpacket_traits<Packet>::size };
 };
-// template<typename Packet>
-// DoublePacket<Packet> pmadd(const DoublePacket<Packet> &a, const DoublePacket<Packet> &b)
-// {
-//   DoublePacket<Packet> res;
-//   res.first  = padd(a.first, b.first);
-//   res.second = padd(a.second,b.second);
-//   return res;
-// }
 
 template <typename RealScalar, bool ConjLhs_, bool ConjRhs_, int Arch, int PacketSize_>
 class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, ConjLhs_, ConjRhs_, Arch, PacketSize_> {
  public:
-  typedef std::complex<RealScalar> Scalar;
-  typedef std::complex<RealScalar> LhsScalar;
-  typedef std::complex<RealScalar> RhsScalar;
-  typedef std::complex<RealScalar> ResScalar;
+  using Scalar = std::complex<RealScalar>;
+  using LhsScalar = std::complex<RealScalar>;
+  using RhsScalar = std::complex<RealScalar>;
+  using ResScalar = std::complex<RealScalar>;
 
   PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
   PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
@@ -746,16 +864,16 @@
     RhsProgress = 1
   };
 
-  typedef DoublePacket<RealPacket> DoublePacketType;
+  using DoublePacketType = DoublePacket<RealPacket>;
 
-  typedef std::conditional_t<Vectorizable, ScalarPacket, Scalar> LhsPacket4Packing;
-  typedef std::conditional_t<Vectorizable, RealPacket, Scalar> LhsPacket;
-  typedef std::conditional_t<Vectorizable, DoublePacketType, Scalar> RhsPacket;
-  typedef std::conditional_t<Vectorizable, ScalarPacket, Scalar> ResPacket;
-  typedef std::conditional_t<Vectorizable, DoublePacketType, Scalar> AccPacket;
+  using LhsPacket4Packing = std::conditional_t<Vectorizable, ScalarPacket, Scalar>;
+  using LhsPacket = std::conditional_t<Vectorizable, RealPacket, Scalar>;
+  using RhsPacket = std::conditional_t<Vectorizable, DoublePacketType, Scalar>;
+  using ResPacket = std::conditional_t<Vectorizable, ScalarPacket, Scalar>;
+  using AccPacket = std::conditional_t<Vectorizable, DoublePacketType, Scalar>;
 
   // this actually holds 8 packets!
-  typedef QuadPacket<RhsPacket> RhsPacketx4;
+  using RhsPacketx4 = QuadPacket<RhsPacket>;
 
   EIGEN_STRONG_INLINE void initAcc(Scalar& p) const { p = Scalar(0); }
 
@@ -809,11 +927,9 @@
 
   template <typename LhsPacketType, typename RhsPacketType, typename ResPacketType, typename TmpType,
             typename LaneIdType>
-  EIGEN_STRONG_INLINE std::enable_if_t<!is_same<RhsPacketType, RhsPacketx4>::value> madd(const LhsPacketType& a,
-                                                                                         const RhsPacketType& b,
-                                                                                         DoublePacket<ResPacketType>& c,
-                                                                                         TmpType& /*tmp*/,
-                                                                                         const LaneIdType&) const {
+  EIGEN_STRONG_INLINE std::enable_if_t<!std::is_same<RhsPacketType, RhsPacketx4>::value> madd(
+      const LhsPacketType& a, const RhsPacketType& b, DoublePacket<ResPacketType>& c, TmpType& /*tmp*/,
+      const LaneIdType&) const {
     c.first = pmadd(a, b.first, c.first);
     c.second = pmadd(a, b.second, c.second);
   }
@@ -837,16 +953,16 @@
                                ResPacketType& r) const {
     // assemble c
     ResPacketType tmp;
-    if ((!ConjLhs) && (!ConjRhs)) {
+    EIGEN_IF_CONSTEXPR ((!ConjLhs) && (!ConjRhs)) {
       tmp = pcplxflip(pconj(ResPacketType(c.second)));
       tmp = padd(ResPacketType(c.first), tmp);
-    } else if ((!ConjLhs) && (ConjRhs)) {
+    } else EIGEN_IF_CONSTEXPR ((!ConjLhs) && (ConjRhs)) {
       tmp = pconj(pcplxflip(ResPacketType(c.second)));
       tmp = padd(ResPacketType(c.first), tmp);
-    } else if ((ConjLhs) && (!ConjRhs)) {
+    } else EIGEN_IF_CONSTEXPR ((ConjLhs) && (!ConjRhs)) {
       tmp = pcplxflip(ResPacketType(c.second));
       tmp = padd(pconj(ResPacketType(c.first)), tmp);
-    } else if ((ConjLhs) && (ConjRhs)) {
+    } else {
       tmp = pcplxflip(ResPacketType(c.second));
       tmp = psub(pconj(ResPacketType(c.first)), tmp);
     }
@@ -861,10 +977,10 @@
 template <typename RealScalar, bool ConjRhs_, int Arch, int PacketSize_>
 class gebp_traits<RealScalar, std::complex<RealScalar>, false, ConjRhs_, Arch, PacketSize_> {
  public:
-  typedef std::complex<RealScalar> Scalar;
-  typedef RealScalar LhsScalar;
-  typedef Scalar RhsScalar;
-  typedef Scalar ResScalar;
+  using Scalar = std::complex<RealScalar>;
+  using LhsScalar = RealScalar;
+  using RhsScalar = Scalar;
+  using ResScalar = Scalar;
 
   PACKET_DECL_COND_POSTFIX(_, Lhs, PacketSize_);
   PACKET_DECL_COND_POSTFIX(_, Rhs, PacketSize_);
@@ -894,12 +1010,12 @@
     RhsProgress = 1
   };
 
-  typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> LhsPacket;
-  typedef std::conditional_t<Vectorizable, RhsPacket_, RhsScalar> RhsPacket;
-  typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> ResPacket;
-  typedef LhsPacket LhsPacket4Packing;
-  typedef QuadPacket<RhsPacket> RhsPacketx4;
-  typedef ResPacket AccPacket;
+  using LhsPacket = std::conditional_t<Vectorizable, LhsPacket_, LhsScalar>;
+  using RhsPacket = std::conditional_t<Vectorizable, RhsPacket_, RhsScalar>;
+  using ResPacket = std::conditional_t<Vectorizable, ResPacket_, ResScalar>;
+  using LhsPacket4Packing = LhsPacket;
+  using RhsPacketx4 = QuadPacket<RhsPacket>;
+  using AccPacket = ResPacket;
 
   EIGEN_STRONG_INLINE void initAcc(AccPacket& p) const { p = pset1<ResPacket>(ResScalar(0)); }
 
@@ -931,12 +1047,12 @@
   template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType, typename LaneIdType>
   EIGEN_STRONG_INLINE void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c, RhsPacketType& tmp,
                                 const LaneIdType&) const {
-    madd_impl(a, b, c, tmp, std::conditional_t<Vectorizable, true_type, false_type>());
+    madd_impl(a, b, c, tmp, bool_constant<Vectorizable>());
   }
 
   template <typename LhsPacketType, typename RhsPacketType, typename AccPacketType>
   EIGEN_STRONG_INLINE void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacketType& c,
-                                     RhsPacketType& tmp, const true_type&) const {
+                                     RhsPacketType& tmp, const std::true_type&) const {
 #ifdef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
     EIGEN_UNUSED_VARIABLE(tmp);
     c.v = pmadd(a, b.v, c.v);
@@ -948,7 +1064,7 @@
   }
 
   EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/,
-                                     const false_type&) const {
+                                     const std::false_type&) const {
     c += a * b;
   }
 
@@ -963,8 +1079,6 @@
     conj_helper<ResPacketType, ResPacketType, false, ConjRhs> cj;
     r = cj.pmadd(alpha, c, r);
   }
-
- protected:
 };
 
 /* optimized General packed Block * packed Panel product kernel
@@ -977,41 +1091,37 @@
 template <typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr,
           bool ConjugateLhs, bool ConjugateRhs>
 struct gebp_kernel {
-  typedef gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target> Traits;
-  typedef gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target, GEBPPacketHalf>
-      HalfTraits;
-  typedef gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target, GEBPPacketQuarter>
-      QuarterTraits;
+  using Traits = gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target>;
+  using HalfTraits =
+      gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target, GEBPPacketHalf>;
+  using QuarterTraits =
+      gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target, GEBPPacketQuarter>;
 
-  typedef typename Traits::ResScalar ResScalar;
-  typedef typename Traits::LhsPacket LhsPacket;
-  typedef typename Traits::RhsPacket RhsPacket;
-  typedef typename Traits::ResPacket ResPacket;
-  typedef typename Traits::AccPacket AccPacket;
-  typedef typename Traits::RhsPacketx4 RhsPacketx4;
+  using ResScalar = typename Traits::ResScalar;
+  using LhsPacket = typename Traits::LhsPacket;
+  using RhsPacket = typename Traits::RhsPacket;
+  using ResPacket = typename Traits::ResPacket;
+  using AccPacket = typename Traits::AccPacket;
+  using RhsPacketx4 = typename Traits::RhsPacketx4;
 
-  typedef typename RhsPanelHelper<RhsPacket, RhsPacketx4, 15>::type RhsPanel15;
-  typedef typename RhsPanelHelper<RhsPacket, RhsPacketx4, 27>::type RhsPanel27;
+  using SwappedTraits = gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target>;
 
-  typedef gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target> SwappedTraits;
+  using SLhsPacket = typename SwappedTraits::LhsPacket;
+  using SRhsPacket = typename SwappedTraits::RhsPacket;
+  using SResPacket = typename SwappedTraits::ResPacket;
+  using SAccPacket = typename SwappedTraits::AccPacket;
 
-  typedef typename SwappedTraits::ResScalar SResScalar;
-  typedef typename SwappedTraits::LhsPacket SLhsPacket;
-  typedef typename SwappedTraits::RhsPacket SRhsPacket;
-  typedef typename SwappedTraits::ResPacket SResPacket;
-  typedef typename SwappedTraits::AccPacket SAccPacket;
+  using LhsPacketHalf = typename HalfTraits::LhsPacket;
+  using RhsPacketHalf = typename HalfTraits::RhsPacket;
+  using ResPacketHalf = typename HalfTraits::ResPacket;
+  using AccPacketHalf = typename HalfTraits::AccPacket;
 
-  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
-  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
-  typedef typename HalfTraits::ResPacket ResPacketHalf;
-  typedef typename HalfTraits::AccPacket AccPacketHalf;
+  using LhsPacketQuarter = typename QuarterTraits::LhsPacket;
+  using RhsPacketQuarter = typename QuarterTraits::RhsPacket;
+  using ResPacketQuarter = typename QuarterTraits::ResPacket;
+  using AccPacketQuarter = typename QuarterTraits::AccPacket;
 
-  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
-  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
-  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
-  typedef typename QuarterTraits::AccPacket AccPacketQuarter;
-
-  typedef typename DataMapper::LinearMapper LinearMapper;
+  using LinearMapper = typename DataMapper::LinearMapper;
 
   enum {
     Vectorizable = Traits::Vectorizable,
@@ -1034,14 +1144,14 @@
           int SwappedLhsProgress =
               gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target>::LhsProgress>
 struct last_row_process_16_packets {
-  typedef gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target> Traits;
-  typedef gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target> SwappedTraits;
+  using Traits = gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target>;
+  using SwappedTraits = gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target>;
 
-  typedef typename Traits::ResScalar ResScalar;
-  typedef typename SwappedTraits::LhsPacket SLhsPacket;
-  typedef typename SwappedTraits::RhsPacket SRhsPacket;
-  typedef typename SwappedTraits::ResPacket SResPacket;
-  typedef typename SwappedTraits::AccPacket SAccPacket;
+  using ResScalar = typename Traits::ResScalar;
+  using SLhsPacket = typename SwappedTraits::LhsPacket;
+  using SRhsPacket = typename SwappedTraits::RhsPacket;
+  using SResPacket = typename SwappedTraits::ResPacket;
+  using SAccPacket = typename SwappedTraits::AccPacket;
 
   EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits& straits, const LhsScalar* blA,
                                       const RhsScalar* blB, Index depth, const Index endk, Index i, Index j2,
@@ -1062,22 +1172,22 @@
 template <typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr,
           bool ConjugateLhs, bool ConjugateRhs>
 struct last_row_process_16_packets<LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs, ConjugateRhs, 16> {
-  typedef gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target> Traits;
-  typedef gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target> SwappedTraits;
+  using Traits = gebp_traits<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs, Architecture::Target>;
+  using SwappedTraits = gebp_traits<RhsScalar, LhsScalar, ConjugateRhs, ConjugateLhs, Architecture::Target>;
 
-  typedef typename Traits::ResScalar ResScalar;
-  typedef typename SwappedTraits::LhsPacket SLhsPacket;
-  typedef typename SwappedTraits::RhsPacket SRhsPacket;
-  typedef typename SwappedTraits::ResPacket SResPacket;
-  typedef typename SwappedTraits::AccPacket SAccPacket;
+  using ResScalar = typename Traits::ResScalar;
+  using SLhsPacket = typename SwappedTraits::LhsPacket;
+  using SRhsPacket = typename SwappedTraits::RhsPacket;
+  using SResPacket = typename SwappedTraits::ResPacket;
+  using SAccPacket = typename SwappedTraits::AccPacket;
 
   EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits& straits, const LhsScalar* blA,
                                       const RhsScalar* blB, Index depth, const Index endk, Index i, Index j2,
                                       ResScalar alpha, SAccPacket& C0) const {
-    typedef typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half SResPacketQuarter;
-    typedef typename unpacket_traits<typename unpacket_traits<SLhsPacket>::half>::half SLhsPacketQuarter;
-    typedef typename unpacket_traits<typename unpacket_traits<SRhsPacket>::half>::half SRhsPacketQuarter;
-    typedef typename unpacket_traits<typename unpacket_traits<SAccPacket>::half>::half SAccPacketQuarter;
+    using SResPacketQuarter = typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half;
+    using SLhsPacketQuarter = typename unpacket_traits<typename unpacket_traits<SLhsPacket>::half>::half;
+    using SRhsPacketQuarter = typename unpacket_traits<typename unpacket_traits<SRhsPacket>::half>::half;
+    using SAccPacketQuarter = typename unpacket_traits<typename unpacket_traits<SAccPacket>::half>::half;
 
     SResPacketQuarter R = res.template gatherPacket<SResPacketQuarter>(i, j2);
     SResPacketQuarter alphav = pset1<SResPacketQuarter>(alpha);
@@ -1127,13 +1237,14 @@
   static EIGEN_ALWAYS_INLINE void run(GEBPTraits& traits, const RhsScalar* blB, Index rhs_offset, LhsArray& A,
                                       RhsPanelType& rhs_panel, RhsPacketType& T0, AccArray& C) {
     constexpr int lane = J % 4;
-    EIGEN_IF_CONSTEXPR(lane == 0)
-    traits.loadRhs(blB + (J + rhs_offset) * GEBPTraits::RhsProgress, rhs_panel);
-    else traits.updateRhs(blB + (J + rhs_offset) * GEBPTraits::RhsProgress, rhs_panel);
+    EIGEN_IF_CONSTEXPR (lane == 0)
+      traits.loadRhs(blB + (J + rhs_offset) * GEBPTraits::RhsProgress, rhs_panel);
+    else
+      traits.updateRhs(blB + (J + rhs_offset) * GEBPTraits::RhsProgress, rhs_panel);
 
-    EIGEN_IF_CONSTEXPR(MrPackets >= 1) traits.madd(A[0], rhs_panel, C[J + 0 * NrCols], T0, fix<lane>);
-    EIGEN_IF_CONSTEXPR(MrPackets >= 2) traits.madd(A[1], rhs_panel, C[J + 1 * NrCols], T0, fix<lane>);
-    EIGEN_IF_CONSTEXPR(MrPackets >= 3) traits.madd(A[2], rhs_panel, C[J + 2 * NrCols], T0, fix<lane>);
+    EIGEN_IF_CONSTEXPR (MrPackets >= 1) traits.madd(A[0], rhs_panel, C[J + 0 * NrCols], T0, fix<lane>);
+    EIGEN_IF_CONSTEXPR (MrPackets >= 2) traits.madd(A[1], rhs_panel, C[J + 1 * NrCols], T0, fix<lane>);
+    EIGEN_IF_CONSTEXPR (MrPackets >= 3) traits.madd(A[2], rhs_panel, C[J + 2 * NrCols], T0, fix<lane>);
 
     gebp_rhs_cols<J + 1, MrPackets, NrCols>::run(traits, blB, rhs_offset, A, rhs_panel, T0, C);
   }
@@ -1149,9 +1260,9 @@
                                       RhsPanelType& rhs_panel, RhsPacketType& T0, AccArray& C) {
     constexpr int LhsProg = GEBPTraits::LhsProgress;
 
-    EIGEN_IF_CONSTEXPR(MrPackets >= 1) traits.loadLhs(&blA[(0 + MrPackets * K) * LhsProg], A[0]);
-    EIGEN_IF_CONSTEXPR(MrPackets >= 2) traits.loadLhs(&blA[(1 + MrPackets * K) * LhsProg], A[1]);
-    EIGEN_IF_CONSTEXPR(MrPackets >= 3) traits.loadLhs(&blA[(2 + MrPackets * K) * LhsProg], A[2]);
+    EIGEN_IF_CONSTEXPR (MrPackets >= 1) traits.loadLhs(&blA[(0 + MrPackets * K) * LhsProg], A[0]);
+    EIGEN_IF_CONSTEXPR (MrPackets >= 2) traits.loadLhs(&blA[(1 + MrPackets * K) * LhsProg], A[1]);
+    EIGEN_IF_CONSTEXPR (MrPackets >= 3) traits.loadLhs(&blA[(2 + MrPackets * K) * LhsProg], A[2]);
 
     gebp_rhs_cols<0, MrPackets, NrCols>::run(traits, blB, Index(NrCols * K), A, rhs_panel, T0, C);
   }
@@ -1169,7 +1280,9 @@
 #if EIGEN_ARCH_ARM64 && defined(EIGEN_VECTORIZE_NEON) && EIGEN_GNUC_STRICT_LESS_THAN(9, 0, 0)
   using LhsElement = std::remove_all_extents_t<std::remove_reference_t<LhsArray_>>;
   constexpr bool apply = GEBPTraits_::Vectorizable && MrPackets == 3 && std::is_same<LhsElement, FullLhsPacket_>::value;
-  EIGEN_IF_CONSTEXPR(apply) { __asm__("" : "+w,m"(A[0]), "+w,m"(A[1]), "+w,m"(A[2])); }
+  EIGEN_IF_CONSTEXPR (apply) {
+    __asm__("" : "+w,m"(A[0]), "+w,m"(A[1]), "+w,m"(A[2]));
+  }
 #else
   EIGEN_UNUSED_VARIABLE(A);
 #endif
@@ -1187,7 +1300,7 @@
   using LhsElement = std::remove_all_extents_t<std::remove_reference_t<LhsArray_>>;
   constexpr bool apply =
       GEBPTraits_::Vectorizable && MrPackets <= 2 && NrCols >= 4 && std::is_same<LhsElement, FullLhsPacket_>::value;
-  EIGEN_IF_CONSTEXPR(apply) {
+  EIGEN_IF_CONSTEXPR (apply) {
 #ifdef EIGEN_HAS_CXX17_IFCONSTEXPR
     using AccElement = std::decay_t<decltype(ACC[0])>;
     constexpr bool pin_acc = std::is_same<AccElement, FullLhsPacket_>::value && MrPackets == 2 && NrCols == 4;
@@ -1197,7 +1310,9 @@
                 "+x"(ACC[7]));
     }
 #else
-    EIGEN_IF_CONSTEXPR(MrPackets == 2) { __asm__("" : "+x,m"(A[0]), "+x,m"(A[1])); }
+    EIGEN_IF_CONSTEXPR (MrPackets == 2) {
+      __asm__("" : "+x,m"(A[0]), "+x,m"(A[1]));
+    }
 #endif
   }
 #endif
@@ -1214,7 +1329,9 @@
     constexpr bool use_double_accum = (MrPackets == 1 && NrCols == 4);
 
     // Prefetch for 4-col paths
-    EIGEN_IF_CONSTEXPR(NrCols == 4) { internal::prefetch(blB + (48 + 0)); }
+    EIGEN_IF_CONSTEXPR (NrCols == 4) {
+      internal::prefetch(blB + (48 + 0));
+    }
 
     // Helper to do one step with workarounds
 #define EIGEN_GEBP_DO_STEP(KVAL, ACC)                                                       \
@@ -1223,7 +1340,7 @@
     gebp_neon_3p_workaround<MrPackets, GEBPTraits, FullLhsPacket>(A);                       \
     gebp_sse_spilling_workaround<MrPackets, NrCols, GEBPTraits, FullLhsPacket>(A, ACC);     \
     /* LHS prefetch for 2pX4 and 3pX4 */                                                    \
-    EIGEN_IF_CONSTEXPR((MrPackets == 2 || MrPackets == 3) && NrCols == 4) {                 \
+    EIGEN_IF_CONSTEXPR ((MrPackets == 2 || MrPackets == 3) && NrCols == 4) {                \
       internal::prefetch(blA + (MrPackets * KVAL + 16) * GEBPTraits::LhsProgress);          \
       if (EIGEN_ARCH_ARM || EIGEN_ARCH_MIPS) {                                              \
         internal::prefetch(blB + (NrCols * KVAL + 16) * GEBPTraits::RhsProgress);           \
@@ -1231,23 +1348,26 @@
     }                                                                                       \
   } while (false)
 
-    EIGEN_IF_CONSTEXPR(use_double_accum) {
+    EIGEN_IF_CONSTEXPR (use_double_accum) {
       EIGEN_GEBP_DO_STEP(0, C);
       EIGEN_GEBP_DO_STEP(1, D);
       EIGEN_GEBP_DO_STEP(2, C);
       EIGEN_GEBP_DO_STEP(3, D);
-      EIGEN_IF_CONSTEXPR(NrCols == 4) { internal::prefetch(blB + (48 + 16)); }
+      EIGEN_IF_CONSTEXPR (NrCols == 4) {
+        internal::prefetch(blB + (48 + 16));
+      }
       EIGEN_GEBP_DO_STEP(4, C);
       EIGEN_GEBP_DO_STEP(5, D);
       EIGEN_GEBP_DO_STEP(6, C);
       EIGEN_GEBP_DO_STEP(7, D);
-    }
-    else {
+    } else {
       EIGEN_GEBP_DO_STEP(0, C);
       EIGEN_GEBP_DO_STEP(1, C);
       EIGEN_GEBP_DO_STEP(2, C);
       EIGEN_GEBP_DO_STEP(3, C);
-      EIGEN_IF_CONSTEXPR(NrCols == 4 && MrPackets == 2) { internal::prefetch(blB + (48 + 16)); }
+      EIGEN_IF_CONSTEXPR (NrCols == 4 && MrPackets == 2) {
+        internal::prefetch(blB + (48 + 16));
+      }
       EIGEN_GEBP_DO_STEP(4, C);
       EIGEN_GEBP_DO_STEP(5, C);
       EIGEN_GEBP_DO_STEP(6, C);
@@ -1292,19 +1412,19 @@
 #else
   constexpr int CSize = 3 * NrCols > MrPackets * NrCols ? 3 * NrCols : MrPackets * NrCols;
 #endif
-  AccPacketLocal C[CSize];
+  alignas(AccPacketLocal) AccPacketLocal C[CSize];
   for (int n = 0; n < MrPackets * NrCols; ++n) traits.initAcc(C[n]);
 
   // Double-accumulation trick for 1pX4 path to break FMA dependency chains
   constexpr bool use_double_accum = (MrPackets == 1 && NrCols == 4);
 #ifdef EIGEN_HAS_CXX17_IFCONSTEXPR
-  AccPacketLocal D[use_double_accum ? NrCols : 1];
+  alignas(AccPacketLocal) AccPacketLocal D[use_double_accum ? NrCols : 1];
 #else
   // Without if constexpr, we must allocate a larger array to satisfy the
   // compiler that D[n] is always in bounds for the use_double_accum path.
-  AccPacketLocal D[CSize];
+  alignas(AccPacketLocal) AccPacketLocal D[CSize];
 #endif
-  EIGEN_IF_CONSTEXPR(use_double_accum) {
+  EIGEN_IF_CONSTEXPR (use_double_accum) {
     for (int n = 0; n < NrCols; ++n) traits.initAcc(D[n]);
   }
 
@@ -1317,15 +1437,19 @@
 
   // LHS packet staging area. With if constexpr (C++17) we use exact sizes.
 #ifdef EIGEN_HAS_CXX17_IFCONSTEXPR
-  LhsPacketLocal A[MrPackets];
+  alignas(LhsPacketLocal) LhsPacketLocal A[MrPackets];
 #else
-  LhsPacketLocal A[3];
+  alignas(LhsPacketLocal) LhsPacketLocal A[3];
 #endif
 
   // ---- Peeled k-loop (pk=8 unrolled) ----
+#if defined(EIGEN_VECTORIZE_RVV10) && EIGEN_GNUC_STRICT_AT_LEAST(15, 0, 0) && EIGEN_GNUC_STRICT_LESS_THAN(17, 0, 0)
+  // GCC 15 and 16 miscompile scalar packet instantiations when this manually unrolled loop is vectorized.
+#pragma GCC novector
+#endif
   for (Index_ k = 0; k < peeled_kc; k += pk) {
-    RhsPanelType rhs_panel;
-    RhsPacketLocal T0;
+    alignas(RhsPanelType) RhsPanelType rhs_panel;
+    alignas(RhsPacketLocal) RhsPacketLocal T0;
 
     gebp_peeled_loop<MrPackets, NrCols>::template run<GEBPTraits, LhsScalar_, RhsScalar_, decltype(A), RhsPanelType,
                                                       RhsPacketLocal, decltype(C), decltype(D), FullLhsPacket>(
@@ -1336,14 +1460,14 @@
   }
 
   // Merge double accumulators
-  EIGEN_IF_CONSTEXPR(use_double_accum) {
+  EIGEN_IF_CONSTEXPR (use_double_accum) {
     for (int n = 0; n < NrCols; ++n) C[n] = padd(C[n], D[n]);
   }
 
   // ---- Remainder k-loop ----
   for (Index_ k = peeled_kc; k < depth; k++) {
-    RhsPanelType rhs_panel;
-    RhsPacketLocal T0;
+    alignas(RhsPanelType) RhsPanelType rhs_panel;
+    alignas(RhsPacketLocal) RhsPacketLocal T0;
 
     gebp_micro_step<0, MrPackets, NrCols>::run(traits, blA, blB, A, rhs_panel, T0, C);
 
@@ -1352,17 +1476,29 @@
   }
 
   // ---- Store results: C[j + p * NrCols] -> res(i + p*ResPacketSz, j2 + j) ----
-  ResPacketLocal alphav = pset1<ResPacketLocal>(alpha);
+  alignas(ResPacketLocal) ResPacketLocal alphav = pset1<ResPacketLocal>(alpha);
   for (int j = 0; j < NrCols; ++j) {
     LinearMapper_ r = res.getLinearMapper(i, j2 + j);
     for (int p = 0; p < MrPackets; ++p) {
-      ResPacketLocal R = r.template loadPacket<ResPacketLocal>(p * ResPacketSz);
+      alignas(ResPacketLocal) ResPacketLocal R = r.template loadPacket<ResPacketLocal>(p * ResPacketSz);
       traits.acc(C[j + p * NrCols], alphav, R);
       r.storePacket(p * ResPacketSz, R);
     }
   }
 }
 
+// Workaround a GCC/AArch64 register-allocation issue (through at least GCC 14.3): the float
+// kernel's mr=12 x nr=8 tile holds 24 of the 32 NEON registers, and GCC's pre-RA scheduler
+// (-fschedule-insns, on at -O2/-O3) hoists loads past that limit, spilling ~20 vector regs and
+// ~halving GEMM throughput (~2.1x fp32 on Cortex-X925; spills 20 -> 2 with it off). Clang
+// allocates the same tile spill-free, so we keep nr=8 and just disable that GCC pass here.
+// This is a known bug in GCC: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100697
+// In-order cores can opt out via EIGEN_DONT_DISABLE_GEBP_INSN_SCHEDULING.
+#if EIGEN_COMP_GNUC_STRICT && EIGEN_ARCH_ARM64 && !defined(EIGEN_DONT_DISABLE_GEBP_INSN_SCHEDULING)
+#pragma GCC push_options
+#pragma GCC optimize("no-schedule-insns")
+#define EIGEN_GEBP_DISABLED_INSN_SCHEDULING
+#endif
 template <typename LhsScalar, typename RhsScalar, typename Index, typename DataMapper, int mr, int nr,
           bool ConjugateLhs, bool ConjugateRhs>
 EIGEN_DONT_INLINE void gebp_kernel<LhsScalar, RhsScalar, Index, DataMapper, mr, nr, ConjugateLhs,
@@ -1407,24 +1543,42 @@
                                      offsetB, prefetch_res_offset, peeled_kc, pk);
   };
 
-  //---------- Process 3 * LhsProgress rows at once ----------
-  EIGEN_IF_CONSTEXPR(mr >= 3 * Traits::LhsProgress) {
+  // Budget (in bytes) for co-residency of the RHS block and a strip of the
+  // LHS panel. On most architectures this is L1: the LHS streams sequentially
+  // through L1 and we only need room for one micro-panel strip at a time.
+  // Sub-blocking trades cache misses for extra passes over the RHS columns,
+  // which hurts IPC and loop overhead. On modern x86, L1→L2 traffic is cheap
+  // (~5 cycles) and hardware prefetchers absorb the LHS misses, so we use a
+  // fraction of L2 instead — effectively disabling sub-blocking when the LHS
+  // panel already fits in L2.
+  Index lhs_budget;
+  {
     std::ptrdiff_t l1, l2, l3;
     manage_caching_sizes(GetAction, &l1, &l2, &l3);
-    const Index actual_panel_rows =
-        (3 * LhsProgress) * std::max<Index>(1, ((l1 - sizeof(ResScalar) * mr * nr - depth * nr * sizeof(RhsScalar)) /
-                                                (depth * sizeof(LhsScalar) * 3 * LhsProgress)));
+#if EIGEN_ARCH_i386_OR_x86_64
+    lhs_budget = static_cast<Index>(l2 / 2);
+#else
+    lhs_budget = static_cast<Index>(l1);
+#endif
+  }
+
+  //---------- Process 3 * LhsProgress rows at once ----------
+  EIGEN_IF_CONSTEXPR (mr >= 3 * Traits::LhsProgress) {
+    const Index rhs_block = sizeof(ResScalar) * mr * nr + depth * nr * sizeof(RhsScalar);
+    const Index lhs_strip = depth * sizeof(LhsScalar) * 3 * LhsProgress;
+    const Index lhs_avail = (lhs_budget > rhs_block) ? (lhs_budget - rhs_block) : 0;
+    const Index actual_panel_rows = (lhs_avail >= peeled_mc3 * depth * static_cast<Index>(sizeof(LhsScalar)))
+                                        ? peeled_mc3
+                                        : (3 * LhsProgress) * std::max<Index>(1, lhs_avail / lhs_strip);
     for (Index i1 = 0; i1 < peeled_mc3; i1 += actual_panel_rows) {
       const Index actual_panel_end = (std::min)(i1 + actual_panel_rows, peeled_mc3);
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-      EIGEN_IF_CONSTEXPR(nr >= 8) {
+      EIGEN_IF_CONSTEXPR (nr >= 8) {
         for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
           for (Index i = i1; i < actual_panel_end; i += 3 * LhsProgress) {
             micro_panel(fix<3>, fix<8>, traits, i, j2);
           }
         }
       }
-#endif
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         for (Index i = i1; i < actual_panel_end; i += 3 * LhsProgress) {
           micro_panel(fix<3>, fix<4>, traits, i, j2);
@@ -1439,23 +1593,23 @@
   }
 
   //---------- Process 2 * LhsProgress rows at once ----------
-  EIGEN_IF_CONSTEXPR(mr >= 2 * Traits::LhsProgress) {
-    std::ptrdiff_t l1, l2, l3;
-    manage_caching_sizes(GetAction, &l1, &l2, &l3);
-    Index actual_panel_rows =
-        (2 * LhsProgress) * std::max<Index>(1, ((l1 - sizeof(ResScalar) * mr * nr - depth * nr * sizeof(RhsScalar)) /
-                                                (depth * sizeof(LhsScalar) * 2 * LhsProgress)));
+  EIGEN_IF_CONSTEXPR (mr >= 2 * Traits::LhsProgress) {
+    const Index rhs_block2 = sizeof(ResScalar) * mr * nr + depth * nr * sizeof(RhsScalar);
+    const Index lhs_strip2 = depth * sizeof(LhsScalar) * 2 * LhsProgress;
+    const Index lhs_avail2 = (lhs_budget > rhs_block2) ? (lhs_budget - rhs_block2) : 0;
+    const Index mc2_range = peeled_mc2 - peeled_mc3;
+    Index actual_panel_rows = (lhs_avail2 >= mc2_range * depth * static_cast<Index>(sizeof(LhsScalar)))
+                                  ? mc2_range
+                                  : (2 * LhsProgress) * std::max<Index>(1, lhs_avail2 / lhs_strip2);
     for (Index i1 = peeled_mc3; i1 < peeled_mc2; i1 += actual_panel_rows) {
       Index actual_panel_end = (std::min)(i1 + actual_panel_rows, peeled_mc2);
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-      EIGEN_IF_CONSTEXPR(nr >= 8) {
+      EIGEN_IF_CONSTEXPR (nr >= 8) {
         for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
           for (Index i = i1; i < actual_panel_end; i += 2 * LhsProgress) {
             micro_panel(fix<2>, fix<8>, traits, i, j2);
           }
         }
       }
-#endif
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         for (Index i = i1; i < actual_panel_end; i += 2 * LhsProgress) {
           micro_panel(fix<2>, fix<4>, traits, i, j2);
@@ -1470,15 +1624,13 @@
   }
 
   //---------- Process 1 * LhsProgress rows at once ----------
-  EIGEN_IF_CONSTEXPR(mr >= 1 * Traits::LhsProgress) {
+  EIGEN_IF_CONSTEXPR (mr >= 1 * Traits::LhsProgress) {
     for (Index i = peeled_mc2; i < peeled_mc1; i += LhsProgress) {
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-      EIGEN_IF_CONSTEXPR(nr >= 8) {
+      EIGEN_IF_CONSTEXPR (nr >= 8) {
         for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
           micro_panel(fix<1>, fix<8>, traits, i, j2);
         }
       }
-#endif
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         micro_panel(fix<1>, fix<4>, traits, i, j2);
       }
@@ -1489,18 +1641,16 @@
   }
 
   //---------- Process LhsProgressHalf rows at once ----------
-  EIGEN_IF_CONSTEXPR((LhsProgressHalf < LhsProgress) && mr >= LhsProgressHalf) {
+  EIGEN_IF_CONSTEXPR ((LhsProgressHalf < LhsProgress) && mr >= LhsProgressHalf) {
     HalfTraits half_traits;
     for (Index i = peeled_mc1; i < peeled_mc_half; i += LhsProgressHalf) {
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-      EIGEN_IF_CONSTEXPR(nr >= 8) {
+      EIGEN_IF_CONSTEXPR (nr >= 8) {
         for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
           gebp_micro_panel_impl<1, 8, HalfTraits, LhsScalar, RhsScalar, ResScalar, Index, DataMapper, LinearMapper,
                                 LhsPacket>(half_traits, res, blockA, blockB, alpha, i, j2, depth, strideA, strideB,
                                            offsetA, offsetB, prefetch_res_offset, peeled_kc, pk);
         }
       }
-#endif
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         gebp_micro_panel_impl<1, 4, HalfTraits, LhsScalar, RhsScalar, ResScalar, Index, DataMapper, LinearMapper,
                               LhsPacket>(half_traits, res, blockA, blockB, alpha, i, j2, depth, strideA, strideB,
@@ -1515,18 +1665,16 @@
   }
 
   //---------- Process LhsProgressQuarter rows at once ----------
-  EIGEN_IF_CONSTEXPR((LhsProgressQuarter < LhsProgressHalf) && mr >= LhsProgressQuarter) {
+  EIGEN_IF_CONSTEXPR ((LhsProgressQuarter < LhsProgressHalf) && mr >= LhsProgressQuarter) {
     QuarterTraits quarter_traits;
     for (Index i = peeled_mc_half; i < peeled_mc_quarter; i += LhsProgressQuarter) {
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-      EIGEN_IF_CONSTEXPR(nr >= 8) {
+      EIGEN_IF_CONSTEXPR (nr >= 8) {
         for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
           gebp_micro_panel_impl<1, 8, QuarterTraits, LhsScalar, RhsScalar, ResScalar, Index, DataMapper, LinearMapper,
                                 LhsPacket>(quarter_traits, res, blockA, blockB, alpha, i, j2, depth, strideA, strideB,
                                            offsetA, offsetB, prefetch_res_offset, peeled_kc, pk);
         }
       }
-#endif
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         gebp_micro_panel_impl<1, 4, QuarterTraits, LhsScalar, RhsScalar, ResScalar, Index, DataMapper, LinearMapper,
                               LhsPacket>(quarter_traits, res, blockA, blockB, alpha, i, j2, depth, strideA, strideB,
@@ -1542,8 +1690,7 @@
 
   //---------- Process remaining rows, 1 at once ----------
   if (peeled_mc_quarter < rows) {
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-    EIGEN_IF_CONSTEXPR(nr >= 8) {
+    EIGEN_IF_CONSTEXPR (nr >= 8) {
       // loop on each panel of the rhs
       for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
         // loop on each row of the lhs (1*LhsProgress x depth)
@@ -1594,7 +1741,6 @@
         }
       }
     }
-#endif
 
     for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
       // loop on each row of the lhs (1*LhsProgress x depth)
@@ -1603,11 +1749,11 @@
         prefetch(&blA[0]);
         const RhsScalar* blB = &blockB[j2 * strideB + offsetB * 4];
 
-        // If LhsProgress is 8 or 16, it assumes that there is a
-        // half or quarter packet, respectively, of the same size as
-        // nr (which is currently 4) for the return type.
-        const int SResPacketHalfSize = unpacket_traits<typename unpacket_traits<SResPacket>::half>::size;
-        const int SResPacketQuarterSize =
+        // This loop packs groups of 4 columns, so the sub-packet holding them is 4
+        // lanes wide regardless of nr, which is tunable (EIGEN_SVE_GEBP_NR and
+        // friends) and 8 on several backends.
+        constexpr int SResPacketHalfSize = unpacket_traits<typename unpacket_traits<SResPacket>::half>::size;
+        constexpr int SResPacketQuarterSize =
             unpacket_traits<typename unpacket_traits<typename unpacket_traits<SResPacket>::half>::half>::size;
         // The following code assumes we can load SRhsPacket in such a way that
         // it multiplies blocks of 4 elements in SLhsPacket.  This is not the
@@ -1616,9 +1762,10 @@
         constexpr bool kCanLoadSRhsQuad =
             (unpacket_traits<SLhsPacket>::size < 4) ||
             (unpacket_traits<SRhsPacket>::size % ((std::max<int>)(unpacket_traits<SLhsPacket>::size, 4) / 4)) == 0;
-        if (kCanLoadSRhsQuad && (SwappedTraits::LhsProgress % 4) == 0 && (SwappedTraits::LhsProgress <= 16) &&
-            (SwappedTraits::LhsProgress != 8 || SResPacketHalfSize == nr) &&
-            (SwappedTraits::LhsProgress != 16 || SResPacketQuarterSize == nr)) {
+        EIGEN_IF_CONSTEXPR (kCanLoadSRhsQuad && (SwappedTraits::LhsProgress % 4) == 0 &&
+                            (SwappedTraits::LhsProgress <= 16) &&
+                            (SwappedTraits::LhsProgress != 8 || SResPacketHalfSize == 4) &&
+                            (SwappedTraits::LhsProgress != 16 || SResPacketQuarterSize == 4)) {
           SAccPacket C0, C1, C2, C3;
           straits.initAcc(C0);
           straits.initAcc(C1);
@@ -1757,6 +1904,10 @@
     }
   }
 }
+#ifdef EIGEN_GEBP_DISABLED_INSN_SCHEDULING
+#pragma GCC pop_options
+#undef EIGEN_GEBP_DISABLED_INSN_SCHEDULING
+#endif
 
 // pack a block of the lhs
 // The traversal is as follow (mr==4):
@@ -1771,11 +1922,11 @@
 //  19 23 27 31 ...
 //
 //  32 33 34 35 ...
-//  36 36 38 39 ...
+//  36 37 38 39 ...
 template <typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate,
           bool PanelMode>
 struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate, PanelMode> {
-  typedef typename DataMapper::LinearMapper LinearMapper;
+  using LinearMapper = typename DataMapper::LinearMapper;
   EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride = 0,
                                     Index offset = 0) const;
 };
@@ -1785,8 +1936,8 @@
 EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, ColMajor, Conjugate,
                                      PanelMode>::operator()(Scalar* blockA, const DataMapper& lhs, Index depth,
                                                             Index rows, Index stride, Index offset) const {
-  typedef typename unpacket_traits<Packet>::half HalfPacket;
-  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  using HalfPacket = typename unpacket_traits<Packet>::half;
+  using QuarterPacket = typename unpacket_traits<typename unpacket_traits<Packet>::half>::half;
   enum {
     PacketSize = unpacket_traits<Packet>::size,
     HalfPacketSize = unpacket_traits<HalfPacket>::size,
@@ -1819,9 +1970,9 @@
   Index i = 0;
 
   // Pack 3 packets
-  if (Pack1 >= 3 * PacketSize) {
+  EIGEN_IF_CONSTEXPR (Pack1 >= 3 * PacketSize) {
     for (; i < peeled_mc3; i += 3 * PacketSize) {
-      if (PanelMode) count += (3 * PacketSize) * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (3 * PacketSize) * offset;
 
       for (Index k = 0; k < depth; k++) {
         Packet A, B, C;
@@ -1835,13 +1986,13 @@
         pstore(blockA + count, cj.pconj(C));
         count += PacketSize;
       }
-      if (PanelMode) count += (3 * PacketSize) * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (3 * PacketSize) * (stride - offset - depth);
     }
   }
   // Pack 2 packets
-  if (Pack1 >= 2 * PacketSize) {
+  EIGEN_IF_CONSTEXPR (Pack1 >= 2 * PacketSize) {
     for (; i < peeled_mc2; i += 2 * PacketSize) {
-      if (PanelMode) count += (2 * PacketSize) * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (2 * PacketSize) * offset;
 
       for (Index k = 0; k < depth; k++) {
         Packet A, B;
@@ -1852,13 +2003,13 @@
         pstore(blockA + count, cj.pconj(B));
         count += PacketSize;
       }
-      if (PanelMode) count += (2 * PacketSize) * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (2 * PacketSize) * (stride - offset - depth);
     }
   }
   // Pack 1 packets
-  if (Pack1 >= 1 * PacketSize) {
+  EIGEN_IF_CONSTEXPR (Pack1 >= 1 * PacketSize) {
     for (; i < peeled_mc1; i += 1 * PacketSize) {
-      if (PanelMode) count += (1 * PacketSize) * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (1 * PacketSize) * offset;
 
       for (Index k = 0; k < depth; k++) {
         Packet A;
@@ -1866,13 +2017,13 @@
         pstore(blockA + count, cj.pconj(A));
         count += PacketSize;
       }
-      if (PanelMode) count += (1 * PacketSize) * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (1 * PacketSize) * (stride - offset - depth);
     }
   }
   // Pack half packets
-  if (HasHalf && Pack1 >= HalfPacketSize) {
+  EIGEN_IF_CONSTEXPR (HasHalf && Pack1 >= HalfPacketSize) {
     for (; i < peeled_mc_half; i += HalfPacketSize) {
-      if (PanelMode) count += (HalfPacketSize)*offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (HalfPacketSize)*offset;
 
       for (Index k = 0; k < depth; k++) {
         HalfPacket A;
@@ -1880,13 +2031,13 @@
         pstoreu(blockA + count, cj.pconj(A));
         count += HalfPacketSize;
       }
-      if (PanelMode) count += (HalfPacketSize) * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (HalfPacketSize) * (stride - offset - depth);
     }
   }
   // Pack quarter packets
-  if (HasQuarter && Pack1 >= QuarterPacketSize) {
+  EIGEN_IF_CONSTEXPR (HasQuarter && Pack1 >= QuarterPacketSize) {
     for (; i < peeled_mc_quarter; i += QuarterPacketSize) {
-      if (PanelMode) count += (QuarterPacketSize)*offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (QuarterPacketSize)*offset;
 
       for (Index k = 0; k < depth; k++) {
         QuarterPacket A;
@@ -1894,7 +2045,7 @@
         pstoreu(blockA + count, cj.pconj(A));
         count += QuarterPacketSize;
       }
-      if (PanelMode) count += (QuarterPacketSize) * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += (QuarterPacketSize) * (stride - offset - depth);
     }
   }
   // Pack2 may be *smaller* than PacketSize—that happens for
@@ -1903,28 +2054,37 @@
   // address both real & imaginary parts on the rhs. This portion will
   // pack those half ones until they match the number expected on the
   // last peeling loop at this point (for the rhs).
-  if (Pack2 < PacketSize && Pack2 > 1) {
-    for (; i < peeled_mc0; i += last_lhs_progress) {
-      if (PanelMode) count += last_lhs_progress * offset;
+  //
+  // When there are no half/quarter packet types (HasHalf and HasQuarter
+  // are both false), last_lhs_progress can exceed Pack2, producing
+  // interleaved groups that the GEBP micro-kernel cannot consume.  In
+  // that case we use exactly Pack2 rows per group so the kernel's main
+  // loop (which reads Pack2 = LhsProgress values via ploaddup) can
+  // handle them; remaining rows fall through to the scalar loop below.
+  EIGEN_IF_CONSTEXPR (Pack2 < PacketSize && Pack2 > 1) {
+    const Index pack2_progress = (HasHalf || HasQuarter) ? last_lhs_progress : Pack2;
+    const Index peeled = (HasHalf || HasQuarter) ? peeled_mc0 : (rows / Pack2) * Pack2;
+    for (; i < peeled; i += pack2_progress) {
+      EIGEN_IF_CONSTEXPR (PanelMode) count += pack2_progress * offset;
 
       for (Index k = 0; k < depth; k++)
-        for (Index w = 0; w < last_lhs_progress; w++) blockA[count++] = cj(lhs(i + w, k));
+        for (Index w = 0; w < pack2_progress; w++) blockA[count++] = cj(lhs(i + w, k));
 
-      if (PanelMode) count += last_lhs_progress * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += pack2_progress * (stride - offset - depth);
     }
   }
   // Pack scalars
   for (; i < rows; i++) {
-    if (PanelMode) count += offset;
+    EIGEN_IF_CONSTEXPR (PanelMode) count += offset;
     for (Index k = 0; k < depth; k++) blockA[count++] = cj(lhs(i, k));
-    if (PanelMode) count += (stride - offset - depth);
+    EIGEN_IF_CONSTEXPR (PanelMode) count += (stride - offset - depth);
   }
 }
 
 template <typename Scalar, typename Index, typename DataMapper, int Pack1, int Pack2, typename Packet, bool Conjugate,
           bool PanelMode>
 struct gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate, PanelMode> {
-  typedef typename DataMapper::LinearMapper LinearMapper;
+  using LinearMapper = typename DataMapper::LinearMapper;
   EIGEN_DONT_INLINE void operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride = 0,
                                     Index offset = 0) const;
 };
@@ -1934,8 +2094,8 @@
 EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, Packet, RowMajor, Conjugate,
                                      PanelMode>::operator()(Scalar* blockA, const DataMapper& lhs, Index depth,
                                                             Index rows, Index stride, Index offset) const {
-  typedef typename unpacket_traits<Packet>::half HalfPacket;
-  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
+  using HalfPacket = typename unpacket_traits<Packet>::half;
+  using QuarterPacket = typename unpacket_traits<typename unpacket_traits<Packet>::half>::half;
   enum {
     PacketSize = unpacket_traits<Packet>::size,
     HalfPacketSize = unpacket_traits<HalfPacket>::size,
@@ -1960,7 +2120,7 @@
     Index peeled_mc = gone_last ? Pack2 > 1 ? (rows / pack) * pack : 0 : i + (remaining_rows / pack) * pack;
     Index starting_pos = i;
     for (; i < peeled_mc; i += pack) {
-      if (PanelMode) count += pack * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += pack * offset;
 
       Index k = 0;
       if (pack >= psize && psize >= QuarterPacketSize) {
@@ -2006,7 +2166,7 @@
           for (; w < pack; ++w) blockA[count++] = cj(lhs(i + w, k));
       }
 
-      if (PanelMode) count += pack * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += pack * (stride - offset - depth);
     }
 
     pack -= psize;
@@ -2025,17 +2185,26 @@
       // address both real & imaginary parts on the rhs. This portion will
       // pack those half ones until they match the number expected on the
       // last peeling loop at this point (for the rhs).
-      if (Pack2 < PacketSize && !gone_last) {
-        gone_last = true;
-        psize = pack = left & ~1;
+      //
+      // When there are no half/quarter packet types (HasHalf and HasQuarter
+      // are both false), last_lhs_progress can exceed Pack2, producing
+      // interleaved groups that the GEBP micro-kernel cannot consume.  In
+      // that case we use exactly Pack2 rows per group so the kernel's main
+      // loop (which reads Pack2 = LhsProgress values via ploaddup) can
+      // handle them; remaining rows fall through to the scalar loop below.
+      EIGEN_IF_CONSTEXPR (Pack2 < PacketSize) {
+        if (!gone_last) {
+          gone_last = true;
+          psize = pack = (HasHalf || HasQuarter) ? (left & ~1) : Pack2;
+        }
       }
     }
   }
 
   for (; i < rows; i++) {
-    if (PanelMode) count += offset;
+    EIGEN_IF_CONSTEXPR (PanelMode) count += offset;
     for (Index k = 0; k < depth; k++) blockA[count++] = cj(lhs(i, k));
-    if (PanelMode) count += (stride - offset - depth);
+    EIGEN_IF_CONSTEXPR (PanelMode) count += (stride - offset - depth);
   }
 }
 
@@ -2048,8 +2217,8 @@
 //  .  .  .  .    .  .  .  .    .  .
 template <typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
 struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode> {
-  typedef typename packet_traits<Scalar>::type Packet;
-  typedef typename DataMapper::LinearMapper LinearMapper;
+  using Packet = typename packet_traits<Scalar>::type;
+  using LinearMapper = typename DataMapper::LinearMapper;
   enum { PacketSize = packet_traits<Scalar>::size };
   EIGEN_DONT_INLINE void operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride = 0,
                                     Index offset = 0) const;
@@ -2068,11 +2237,10 @@
   Index count = 0;
   const Index peeled_k = (depth / PacketSize) * PacketSize;
 
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-  EIGEN_IF_CONSTEXPR(nr >= 8) {
+  EIGEN_IF_CONSTEXPR (nr >= 8) {
     for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
       // skip what we have before
-      if (PanelMode) count += 8 * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * offset;
       const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
       const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
       const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
@@ -2082,10 +2250,10 @@
       const LinearMapper dm6 = rhs.getLinearMapper(0, j2 + 6);
       const LinearMapper dm7 = rhs.getLinearMapper(0, j2 + 7);
       Index k = 0;
-      if (PacketSize % 2 == 0 && PacketSize <= 8)  // 2 4 8
+      EIGEN_IF_CONSTEXPR (PacketSize % 2 == 0 && PacketSize <= 8)  // 2 4 8
       {
         for (; k < peeled_k; k += PacketSize) {
-          if (PacketSize == 2) {
+          EIGEN_IF_CONSTEXPR (PacketSize == 2) {
             PacketBlock<Packet, PacketSize == 2 ? 2 : PacketSize> kernel0, kernel1, kernel2, kernel3;
             kernel0.packet[0 % PacketSize] = dm0.template loadPacket<Packet>(k);
             kernel0.packet[1 % PacketSize] = dm1.template loadPacket<Packet>(k);
@@ -2110,7 +2278,7 @@
             pstoreu(blockB + count + 6 * PacketSize, cj.pconj(kernel2.packet[1 % PacketSize]));
             pstoreu(blockB + count + 7 * PacketSize, cj.pconj(kernel3.packet[1 % PacketSize]));
             count += 8 * PacketSize;
-          } else if (PacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (PacketSize == 4) {
             PacketBlock<Packet, PacketSize == 4 ? 4 : PacketSize> kernel0, kernel1;
 
             kernel0.packet[0 % PacketSize] = dm0.template loadPacket<Packet>(k);
@@ -2133,7 +2301,7 @@
             pstoreu(blockB + count + 6 * PacketSize, cj.pconj(kernel0.packet[3 % PacketSize]));
             pstoreu(blockB + count + 7 * PacketSize, cj.pconj(kernel1.packet[3 % PacketSize]));
             count += 8 * PacketSize;
-          } else if (PacketSize == 8) {
+          } else EIGEN_IF_CONSTEXPR (PacketSize == 8) {
             PacketBlock<Packet, PacketSize == 8 ? 8 : PacketSize> kernel0;
 
             kernel0.packet[0 % PacketSize] = dm0.template loadPacket<Packet>(k);
@@ -2171,34 +2339,50 @@
         count += 8;
       }
       // skip what we have after
-      if (PanelMode) count += 8 * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * (stride - offset - depth);
     }
   }
-#endif
 
-  EIGEN_IF_CONSTEXPR(nr >= 4) {
+  EIGEN_IF_CONSTEXPR (nr >= 4) {
     for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
       // skip what we have before
-      if (PanelMode) count += 4 * offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * offset;
       const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
       const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
       const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
       const LinearMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
 
       Index k = 0;
-      if ((PacketSize % 4) == 0)  // TODO: enable vectorized transposition for PacketSize==2.
-      {
+      EIGEN_IF_CONSTEXPR ((PacketSize % 4) == 0 || PacketSize == 2) {
         for (; k < peeled_k; k += PacketSize) {
-          PacketBlock<Packet, (PacketSize % 4) == 0 ? 4 : PacketSize> kernel;
+          PacketBlock<Packet, 4> kernel;
           kernel.packet[0] = dm0.template loadPacket<Packet>(k);
-          kernel.packet[1 % PacketSize] = dm1.template loadPacket<Packet>(k);
-          kernel.packet[2 % PacketSize] = dm2.template loadPacket<Packet>(k);
-          kernel.packet[3 % PacketSize] = dm3.template loadPacket<Packet>(k);
-          ptranspose(kernel);
+          kernel.packet[1] = dm1.template loadPacket<Packet>(k);
+          kernel.packet[2] = dm2.template loadPacket<Packet>(k);
+          kernel.packet[3] = dm3.template loadPacket<Packet>(k);
+          EIGEN_IF_CONSTEXPR (PacketSize == 2) {
+            // For PacketSize==2 we cannot ptranspose 4 packets directly; compose two
+            // 2-packet transposes and re-interleave so the 4 stores produce the
+            // packed-rhs layout (each store writing one half-row of the panel).
+            PacketBlock<Packet, 2> tmp01;
+            tmp01.packet[0] = kernel.packet[0];
+            tmp01.packet[1] = kernel.packet[1];
+            ptranspose(tmp01);
+            PacketBlock<Packet, 2> tmp23;
+            tmp23.packet[0] = kernel.packet[2];
+            tmp23.packet[1] = kernel.packet[3];
+            ptranspose(tmp23);
+            kernel.packet[0] = tmp01.packet[0];
+            kernel.packet[1] = tmp23.packet[0];
+            kernel.packet[2] = tmp01.packet[1];
+            kernel.packet[3] = tmp23.packet[1];
+          } else {
+            ptranspose(kernel);
+          }
           pstoreu(blockB + count + 0 * PacketSize, cj.pconj(kernel.packet[0]));
-          pstoreu(blockB + count + 1 * PacketSize, cj.pconj(kernel.packet[1 % PacketSize]));
-          pstoreu(blockB + count + 2 * PacketSize, cj.pconj(kernel.packet[2 % PacketSize]));
-          pstoreu(blockB + count + 3 * PacketSize, cj.pconj(kernel.packet[3 % PacketSize]));
+          pstoreu(blockB + count + 1 * PacketSize, cj.pconj(kernel.packet[1]));
+          pstoreu(blockB + count + 2 * PacketSize, cj.pconj(kernel.packet[2]));
+          pstoreu(blockB + count + 3 * PacketSize, cj.pconj(kernel.packet[3]));
           count += 4 * PacketSize;
         }
       }
@@ -2210,29 +2394,29 @@
         count += 4;
       }
       // skip what we have after
-      if (PanelMode) count += 4 * (stride - offset - depth);
+      EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * (stride - offset - depth);
     }
   }
 
   // copy the remaining columns one at a time (nr==1)
   for (Index j2 = packet_cols4; j2 < cols; ++j2) {
-    if (PanelMode) count += offset;
+    EIGEN_IF_CONSTEXPR (PanelMode) count += offset;
     const LinearMapper dm0 = rhs.getLinearMapper(0, j2);
     for (Index k = 0; k < depth; k++) {
       blockB[count] = cj(dm0(k));
       count += 1;
     }
-    if (PanelMode) count += (stride - offset - depth);
+    EIGEN_IF_CONSTEXPR (PanelMode) count += (stride - offset - depth);
   }
 }
 
 // this version is optimized for row major matrices
 template <typename Scalar, typename Index, typename DataMapper, int nr, bool Conjugate, bool PanelMode>
 struct gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode> {
-  typedef typename packet_traits<Scalar>::type Packet;
-  typedef typename unpacket_traits<Packet>::half HalfPacket;
-  typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>::half QuarterPacket;
-  typedef typename DataMapper::LinearMapper LinearMapper;
+  using Packet = typename packet_traits<Scalar>::type;
+  using HalfPacket = typename unpacket_traits<Packet>::half;
+  using QuarterPacket = typename unpacket_traits<typename unpacket_traits<Packet>::half>::half;
+  using LinearMapper = typename DataMapper::LinearMapper;
   enum {
     PacketSize = packet_traits<Scalar>::size,
     HalfPacketSize = unpacket_traits<HalfPacket>::size,
@@ -2244,24 +2428,23 @@
     EIGEN_UNUSED_VARIABLE(stride);
     EIGEN_UNUSED_VARIABLE(offset);
     eigen_assert(((!PanelMode) && stride == 0 && offset == 0) || (PanelMode && stride >= depth && offset <= stride));
-    const bool HasHalf = (int)HalfPacketSize < (int)PacketSize;
-    const bool HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize;
+    constexpr bool HasHalf = (int)HalfPacketSize < (int)PacketSize;
+    constexpr bool HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize;
     conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
     Index packet_cols8 = nr >= 8 ? (cols / 8) * 8 : 0;
     Index packet_cols4 = nr >= 4 ? (cols / 4) * 4 : 0;
     Index count = 0;
 
-#if EIGEN_ARCH_ARM64 || EIGEN_ARCH_LOONGARCH64
-    EIGEN_IF_CONSTEXPR(nr >= 8) {
+    EIGEN_IF_CONSTEXPR (nr >= 8) {
       for (Index j2 = 0; j2 < packet_cols8; j2 += 8) {
         // skip what we have before
-        if (PanelMode) count += 8 * offset;
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * offset;
         for (Index k = 0; k < depth; k++) {
-          if (PacketSize == 8) {
+          EIGEN_IF_CONSTEXPR (PacketSize == 8) {
             Packet A = rhs.template loadPacket<Packet>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += PacketSize;
-          } else if (PacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (PacketSize == 4) {
             Packet A = rhs.template loadPacket<Packet>(k, j2);
             Packet B = rhs.template loadPacket<Packet>(k, j2 + 4);
             pstoreu(blockB + count, cj.pconj(A));
@@ -2281,25 +2464,24 @@
           }
         }
         // skip what we have after
-        if (PanelMode) count += 8 * (stride - offset - depth);
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 8 * (stride - offset - depth);
       }
     }
-#endif
 
-    if (nr >= 4) {
+    EIGEN_IF_CONSTEXPR (nr >= 4) {
       for (Index j2 = packet_cols8; j2 < packet_cols4; j2 += 4) {
         // skip what we have before
-        if (PanelMode) count += 4 * offset;
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * offset;
         for (Index k = 0; k < depth; k++) {
-          if (PacketSize == 4) {
+          EIGEN_IF_CONSTEXPR (PacketSize == 4) {
             Packet A = rhs.template loadPacket<Packet>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += PacketSize;
-          } else if (HasHalf && HalfPacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (HasHalf && HalfPacketSize == 4) {
             HalfPacket A = rhs.template loadPacket<HalfPacket>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += HalfPacketSize;
-          } else if (HasQuarter && QuarterPacketSize == 4) {
+          } else EIGEN_IF_CONSTEXPR (HasQuarter && QuarterPacketSize == 4) {
             QuarterPacket A = rhs.template loadPacket<QuarterPacket>(k, j2);
             pstoreu(blockB + count, cj.pconj(A));
             count += QuarterPacketSize;
@@ -2313,17 +2495,17 @@
           }
         }
         // skip what we have after
-        if (PanelMode) count += 4 * (stride - offset - depth);
+        EIGEN_IF_CONSTEXPR (PanelMode) count += 4 * (stride - offset - depth);
       }
     }
     // copy the remaining columns one at a time (nr==1)
     for (Index j2 = packet_cols4; j2 < cols; ++j2) {
-      if (PanelMode) count += offset;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += offset;
       for (Index k = 0; k < depth; k++) {
         blockB[count] = cj(rhs(k, j2));
         count += 1;
       }
-      if (PanelMode) count += stride - offset - depth;
+      EIGEN_IF_CONSTEXPR (PanelMode) count += stride - offset - depth;
     }
   }
 };
@@ -2365,4 +2547,8 @@
 
 }  // end namespace Eigen
 
+#if EIGEN_COMP_MSVC
+#pragma warning(pop)
+#endif
+
 #endif  // EIGEN_GENERAL_BLOCK_PANEL_H
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrix.h b/Eigen/src/Core/products/GeneralMatrixMatrix.h
index 2b45dd2..85091f6 100644
--- a/Eigen/src/Core/products/GeneralMatrixMatrix.h
+++ b/Eigen/src/Core/products/GeneralMatrixMatrix.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERAL_MATRIX_MATRIX_H
 #define EIGEN_GENERAL_MATRIX_MATRIX_H
@@ -20,14 +21,87 @@
 template <typename LhsScalar_, typename RhsScalar_>
 class level3_blocking;
 
+// LHS-first loop order: mc -> kc -> nc. This is Eigen's usual sequential
+// schedule, with a fast path that can pack RHS once for tall skinny blocking.
+struct gemm_pack_lhs_first_loop_policy {
+  template <typename Index, typename LhsScalar, typename RhsScalar, typename ResScalar, typename LhsMapper,
+            typename RhsMapper, typename ResMapper, typename PackLhs, typename PackRhs, typename Gebp>
+  static EIGEN_STRONG_INLINE void run(Index rows, Index cols, Index depth, Index kc, Index mc, Index nc,
+                                      const LhsMapper& lhs, const RhsMapper& rhs, ResMapper& res, PackLhs& pack_lhs,
+                                      PackRhs& pack_rhs, Gebp& gebp, LhsScalar* blockA, RhsScalar* blockB,
+                                      ResScalar alpha) {
+    const bool pack_rhs_once = mc != rows && kc == depth && nc == cols;
+
+    // For each horizontal panel of the rhs, and corresponding panel of the lhs...
+    for (Index i2 = 0; i2 < rows; i2 += mc) {
+      const Index actual_mc = (std::min)(i2 + mc, rows) - i2;
+
+      for (Index k2 = 0; k2 < depth; k2 += kc) {
+        const Index actual_kc = (std::min)(k2 + kc, depth) - k2;
+
+        // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs.
+        // => Pack lhs's panel into a sequential chunk of memory (L2/L3 caching)
+        // Note that this panel will be read as many times as the number of blocks in the rhs's
+        // horizontal panel which is, in practice, a very low number.
+        pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        // For each kc x nc block of the rhs's horizontal panel...
+        for (Index j2 = 0; j2 < cols; j2 += nc) {
+          const Index actual_nc = (std::min)(j2 + nc, cols) - j2;
+
+          // We pack the rhs's block into a sequential chunk of memory (L2 caching)
+          // Note that this block will be read a very high number of times, which is equal to the number of
+          // micro horizontal panel of the large rhs's panel (e.g., rows/12 times).
+          if ((!pack_rhs_once) || i2 == 0) pack_rhs(blockB, rhs.getSubMapper(k2, j2), actual_kc, actual_nc);
+
+          // Everything is packed, we can now call the panel * block kernel:
+          gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
+        }
+      }
+    }
+  }
+};
+
+// RHS-first loop order: nc -> kc -> mc. Used by SME to stream ColMajor result
+// stores through adjacent row panels.
+struct gemm_pack_rhs_first_loop_policy {
+  template <typename Index, typename LhsScalar, typename RhsScalar, typename ResScalar, typename LhsMapper,
+            typename RhsMapper, typename ResMapper, typename PackLhs, typename PackRhs, typename Gebp>
+  static EIGEN_STRONG_INLINE void run(Index rows, Index cols, Index depth, Index kc, Index mc, Index nc,
+                                      const LhsMapper& lhs, const RhsMapper& rhs, ResMapper& res, PackLhs& pack_lhs,
+                                      PackRhs& pack_rhs, Gebp& gebp, LhsScalar* blockA, RhsScalar* blockB,
+                                      ResScalar alpha) {
+    // Mirror of pack_rhs_once: reuse one full LHS panel across column blocks.
+    const bool pack_lhs_once = nc != cols && kc == depth && mc == rows;
+
+    for (Index j2 = 0; j2 < cols; j2 += nc) {
+      const Index actual_nc = (std::min)(j2 + nc, cols) - j2;
+
+      for (Index k2 = 0; k2 < depth; k2 += kc) {
+        const Index actual_kc = (std::min)(k2 + kc, depth) - k2;
+
+        // Pack one nc-strip of RHS and reuse it across all row panels.
+        pack_rhs(blockB, rhs.getSubMapper(k2, j2), actual_kc, actual_nc);
+
+        for (Index i2 = 0; i2 < rows; i2 += mc) {
+          const Index actual_mc = (std::min)(i2 + mc, rows) - i2;
+
+          if ((!pack_lhs_once) || j2 == 0) pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+          gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
+        }
+      }
+    }
+  }
+};
+
 /* Specialization for a row-major destination matrix => simple transposition of the product */
 template <typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar,
           int RhsStorageOrder, bool ConjugateRhs, int ResInnerStride>
 struct general_matrix_matrix_product<Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder,
                                      ConjugateRhs, RowMajor, ResInnerStride> {
-  typedef gebp_traits<RhsScalar, LhsScalar> Traits;
+  using Traits = gebp_traits<RhsScalar, LhsScalar>;
 
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
   static EIGEN_STRONG_INLINE void run(Index rows, Index cols, Index depth, const LhsScalar* lhs, Index lhsStride,
                                       const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resIncr,
                                       Index resStride, ResScalar alpha, level3_blocking<RhsScalar, LhsScalar>& blocking,
@@ -46,15 +120,18 @@
           int RhsStorageOrder, bool ConjugateRhs, int ResInnerStride>
 struct general_matrix_matrix_product<Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder,
                                      ConjugateRhs, ColMajor, ResInnerStride> {
-  typedef gebp_traits<LhsScalar, RhsScalar> Traits;
+  using Traits = gebp_traits<LhsScalar, RhsScalar>;
 
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
   static void run(Index rows, Index cols, Index depth, const LhsScalar* lhs_, Index lhsStride, const RhsScalar* rhs_,
                   Index rhsStride, ResScalar* res_, Index resIncr, Index resStride, ResScalar alpha,
                   level3_blocking<LhsScalar, RhsScalar>& blocking, GemmParallelInfo<Index>* info = 0) {
-    typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
-    typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
-    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    // BLAS contract: if alpha == 0, the result is unchanged (and lhs/rhs need not be read).
+    if (numext::is_exactly_zero(alpha)) return;
+
+    using LhsMapper = const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder>;
+    using RhsMapper = const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder>;
+    using ResMapper = blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
     LhsMapper lhs(lhs_, lhsStride);
     RhsMapper rhs(rhs_, rhsStride);
     ResMapper res(res_, resStride, resIncr);
@@ -140,7 +217,7 @@
         for (Index i = 0; i < threads; ++i) info->task_info[i].users -= 1;
       }
     } else
-#endif  // defined(EIGEN_HAS_OPENMP) || defined(EIGEN_GEMM_THREADPOOL)
+#endif  // !defined(EIGEN_USE_BLAS) && (defined(EIGEN_HAS_OPENMP) || defined(EIGEN_GEMM_THREADPOOL))
     {
       EIGEN_UNUSED_VARIABLE(info);
 
@@ -151,35 +228,19 @@
       ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA());
       ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB());
 
-      const bool pack_rhs_once = mc != rows && kc == depth && nc == cols;
+      // The SME kernel uses RHS-first order so consecutive gebp calls stream
+      // through adjacent row panels of a ColMajor result. Other kernels --
+      // including the scalar pairs SME does not specialize -- keep Eigen's
+      // default LHS-first order.
+#ifdef EIGEN_VECTORIZE_SME
+      using SequentialGemmLoop = std::conditional_t<sme_has_gebp_kernel<LhsScalar, RhsScalar>::value,
+                                                    gemm_pack_rhs_first_loop_policy, gemm_pack_lhs_first_loop_policy>;
+#else
+      using SequentialGemmLoop = gemm_pack_lhs_first_loop_policy;
+#endif
 
-      // For each horizontal panel of the rhs, and corresponding panel of the lhs...
-      for (Index i2 = 0; i2 < rows; i2 += mc) {
-        const Index actual_mc = (std::min)(i2 + mc, rows) - i2;
-
-        for (Index k2 = 0; k2 < depth; k2 += kc) {
-          const Index actual_kc = (std::min)(k2 + kc, depth) - k2;
-
-          // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs.
-          // => Pack lhs's panel into a sequential chunk of memory (L2/L3 caching)
-          // Note that this panel will be read as many times as the number of blocks in the rhs's
-          // horizontal panel which is, in practice, a very low number.
-          pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
-
-          // For each kc x nc block of the rhs's horizontal panel...
-          for (Index j2 = 0; j2 < cols; j2 += nc) {
-            const Index actual_nc = (std::min)(j2 + nc, cols) - j2;
-
-            // We pack the rhs's block into a sequential chunk of memory (L2 caching)
-            // Note that this block will be read a very high number of times, which is equal to the number of
-            // micro horizontal panel of the large rhs's panel (e.g., rows/12 times).
-            if ((!pack_rhs_once) || i2 == 0) pack_rhs(blockB, rhs.getSubMapper(k2, j2), actual_kc, actual_nc);
-
-            // Everything is packed, we can now call the panel * block kernel:
-            gebp(res.getSubMapper(i2, j2), blockA, blockB, actual_mc, actual_kc, actual_nc, alpha);
-          }
-        }
-      }
+      SequentialGemmLoop::run(rows, cols, depth, kc, mc, nc, lhs, rhs, res, pack_lhs, pack_rhs, gebp, blockA, blockB,
+                              alpha);
     }
   }
 };
@@ -208,7 +269,7 @@
               m_actualAlpha, m_blocking, info);
   }
 
-  typedef typename Gemm::Traits Traits;
+  using Traits = typename Gemm::Traits;
 
  protected:
   const Lhs& m_lhs;
@@ -224,19 +285,19 @@
 
 template <typename LhsScalar_, typename RhsScalar_>
 class level3_blocking {
-  typedef LhsScalar_ LhsScalar;
-  typedef RhsScalar_ RhsScalar;
+  using LhsScalar = LhsScalar_;
+  using RhsScalar = RhsScalar_;
 
  protected:
-  LhsScalar* m_blockA;
-  RhsScalar* m_blockB;
+  LhsScalar* m_blockA = nullptr;
+  RhsScalar* m_blockB = nullptr;
 
-  Index m_mc;
-  Index m_nc;
-  Index m_kc;
+  Index m_mc = 0;
+  Index m_nc = 0;
+  Index m_kc = 0;
 
  public:
-  level3_blocking() : m_blockA(0), m_blockB(0), m_mc(0), m_nc(0), m_kc(0) {}
+  level3_blocking() = default;
 
   inline Index mc() const { return m_mc; }
   inline Index nc() const { return m_nc; }
@@ -257,8 +318,8 @@
     ActualRows = Transpose ? MaxCols : MaxRows,
     ActualCols = Transpose ? MaxRows : MaxCols
   };
-  typedef std::conditional_t<Transpose, RhsScalar_, LhsScalar_> LhsScalar;
-  typedef std::conditional_t<Transpose, LhsScalar_, RhsScalar_> RhsScalar;
+  using LhsScalar = std::conditional_t<Transpose, RhsScalar_, LhsScalar_>;
+  using RhsScalar = std::conditional_t<Transpose, LhsScalar_, RhsScalar_>;
   enum { SizeA = ActualRows * MaxDepth, SizeB = ActualCols * MaxDepth };
 
 #if EIGEN_MAX_STATIC_ALIGN_BYTES >= EIGEN_DEFAULT_ALIGN_BYTES
@@ -299,8 +360,8 @@
     : public level3_blocking<std::conditional_t<StorageOrder == RowMajor, RhsScalar_, LhsScalar_>,
                              std::conditional_t<StorageOrder == RowMajor, LhsScalar_, RhsScalar_>> {
   enum { Transpose = StorageOrder == RowMajor };
-  typedef std::conditional_t<Transpose, RhsScalar_, LhsScalar_> LhsScalar;
-  typedef std::conditional_t<Transpose, LhsScalar_, RhsScalar_> RhsScalar;
+  using LhsScalar = std::conditional_t<Transpose, RhsScalar_, LhsScalar_>;
+  using RhsScalar = std::conditional_t<Transpose, LhsScalar_, RhsScalar_>;
 
   Index m_sizeA;
   Index m_sizeB;
@@ -361,31 +422,79 @@
 template <typename Lhs, typename Rhs>
 struct generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, GemmProduct>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, GemmProduct>> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
-  typedef typename Lhs::Scalar LhsScalar;
-  typedef typename Rhs::Scalar RhsScalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+  using LhsScalar = typename Lhs::Scalar;
+  using RhsScalar = typename Rhs::Scalar;
 
-  typedef internal::blas_traits<Lhs> LhsBlasTraits;
-  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-  typedef internal::remove_all_t<ActualLhsType> ActualLhsTypeCleaned;
+  using LhsBlasTraits = internal::blas_traits<Lhs>;
+  using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+  using ActualLhsTypeCleaned = internal::remove_all_t<ActualLhsType>;
 
-  typedef internal::blas_traits<Rhs> RhsBlasTraits;
-  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-  typedef internal::remove_all_t<ActualRhsType> ActualRhsTypeCleaned;
+  using RhsBlasTraits = internal::blas_traits<Rhs>;
+  using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
+  using ActualRhsTypeCleaned = internal::remove_all_t<ActualRhsType>;
 
   enum { MaxDepthAtCompileTime = min_size_prefer_fixed(Lhs::MaxColsAtCompileTime, Rhs::MaxRowsAtCompileTime) };
 
-  typedef generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode> lazyproduct;
+  using lazyproduct = generic_product_impl<Lhs, Rhs, DenseShape, DenseShape, CoeffBasedProductMode>;
+
+  // The runtime-size heuristic comes from bug 404 and was tuned with a
+  // helper program on Haswell. The threshold belongs to the kernel the GEMM
+  // path would select, not to the path itself, and for the SME kernel to the
+  // scalar type as well: it needs a larger product before it beats the
+  // coeff-based one, by an amount that falls as the scalar widens (see
+  // GeneralProduct.h). The rhs.rows() > 0 guard preserves the historical
+  // empty-product path through scaleAndAddTo().
+  static constexpr int kCoeffBasedThreshold =
+#ifdef EIGEN_VECTORIZE_SME
+      sme_has_gebp_kernel<LhsScalar, RhsScalar>::value ? sme_gemm_to_coeffbased_threshold<Scalar>::value :
+#endif
+                                                       EIGEN_GEMM_TO_COEFFBASED_THRESHOLD;
+
+#ifdef EIGEN_VECTORIZE_SME
+  // Second bound for the SME kernel only: a small output over a long depth.
+  // The sum above grows with the depth and so never catches it, while the ZA
+  // grid this kernel fills is sized by the output (see GeneralProduct.h).
+  // Vector shapes are excluded -- scaleAndAddTo() routes those to GEMV, which
+  // is not the path being compared here.
+  static constexpr Index kCoeffBasedOutputArea = sme_has_gebp_kernel<LhsScalar, RhsScalar>::value
+                                                     ? Index(EIGEN_SME_GEMM_TO_COEFFBASED_OUTPUT_AREA_THRESHOLD(Scalar))
+                                                     : Index(0);
+
+  template <typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool outputAreaBelowThreshold(const Dst& dst) {
+    // rows * cols is dst.size(), which fits Index by construction.
+    return dst.rows() > 1 && dst.cols() > 1 && dst.size() <= kCoeffBasedOutputArea;
+  }
+#endif
+
+  template <typename Dst>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool useRuntimeCoeffBasedProduct(const Dst& dst, const Rhs& rhs) {
+    if (rhs.rows() <= 0) return false;
+    if ((rhs.rows() + dst.rows() + dst.cols()) < kCoeffBasedThreshold) return true;
+#ifdef EIGEN_VECTORIZE_SME
+    if (outputAreaBelowThreshold(dst)) return true;
+#endif
+    return false;
+  }
+
+  // BLAS contract: a zero scalar factor leaves the destination unchanged and
+  // neither operand need be read, so that a non-finite coefficient cannot taint
+  // the result through 0 * Inf. general_matrix_matrix_product::run enforces it
+  // for the GEMM path, but the coeff-based path below has no such exit and
+  // would evaluate the product, so the factor is tested before the dispatch
+  // rather than inside either kernel.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool scalarFactorIsZero(const Lhs& lhs, const Rhs& rhs) {
+    return numext::is_exactly_zero(combine_scalar_factors<Scalar>(lhs, rhs));
+  }
 
   template <typename Dst>
   static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
-    // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=404 for a discussion and helper program
-    // to determine the following heuristic.
-    // EIGEN_GEMM_TO_COEFFBASED_THRESHOLD is typically defined to 20 in GeneralProduct.h,
-    // unless it has been specialized by the user or for a given architecture.
-    // Note that the condition rhs.rows()>0 was required because lazy product did not handle empty inputs
-    // correctly. It is unclear whether this guard is still necessary.
-    if ((rhs.rows() + dst.rows() + dst.cols()) < EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows() > 0)
+    if (scalarFactorIsZero(lhs, rhs)) {
+      dst.setZero();
+      return;
+    }
+    if (useRuntimeCoeffBasedProduct(dst, rhs))
       lazyproduct::eval_dynamic(dst, lhs, rhs, internal::assign_op<typename Dst::Scalar, Scalar>());
     else {
       dst.setZero();
@@ -395,7 +504,8 @@
 
   template <typename Dst>
   static void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
-    if ((rhs.rows() + dst.rows() + dst.cols()) < EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows() > 0)
+    if (scalarFactorIsZero(lhs, rhs)) return;
+    if (useRuntimeCoeffBasedProduct(dst, rhs))
       lazyproduct::eval_dynamic(dst, lhs, rhs, internal::add_assign_op<typename Dst::Scalar, Scalar>());
     else
       scaleAndAddTo(dst, lhs, rhs, Scalar(1));
@@ -403,7 +513,8 @@
 
   template <typename Dst>
   static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs) {
-    if ((rhs.rows() + dst.rows() + dst.cols()) < EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows() > 0)
+    if (scalarFactorIsZero(lhs, rhs)) return;
+    if (useRuntimeCoeffBasedProduct(dst, rhs))
       lazyproduct::eval_dynamic(dst, lhs, rhs, internal::sub_assign_op<typename Dst::Scalar, Scalar>());
     else
       scaleAndAddTo(dst, lhs, rhs, Scalar(-1));
@@ -431,19 +542,18 @@
 
     Scalar actualAlpha = combine_scalar_factors(alpha, a_lhs, a_rhs);
 
-    typedef internal::gemm_blocking_space<(Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, LhsScalar, RhsScalar,
-                                          Dest::MaxRowsAtCompileTime, Dest::MaxColsAtCompileTime, MaxDepthAtCompileTime>
-        BlockingType;
+    using BlockingType =
+        internal::gemm_blocking_space<(Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, LhsScalar, RhsScalar,
+                                      Dest::MaxRowsAtCompileTime, Dest::MaxColsAtCompileTime, MaxDepthAtCompileTime>;
 
-    typedef internal::gemm_functor<
+    using GemmFunctor = internal::gemm_functor<
         Scalar, Index,
         internal::general_matrix_matrix_product<
             Index, LhsScalar, (ActualLhsTypeCleaned::Flags & RowMajorBit) ? RowMajor : ColMajor,
             bool(LhsBlasTraits::NeedToConjugate), RhsScalar,
             (ActualRhsTypeCleaned::Flags & RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate),
             (Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, Dest::InnerStrideAtCompileTime>,
-        ActualLhsTypeCleaned, ActualRhsTypeCleaned, Dest, BlockingType>
-        GemmFunctor;
+        ActualLhsTypeCleaned, ActualRhsTypeCleaned, Dest, BlockingType>;
 
     BlockingType blocking(dst.rows(), dst.cols(), lhs.cols(), 1, true);
     internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime > 32 || Dest::MaxRowsAtCompileTime == Dynamic)>(
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
index 5a8599a..3e77e47 100644
--- a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
+++ b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
 #define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_H
@@ -44,7 +45,7 @@
 struct general_matrix_matrix_triangular_product<Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar,
                                                 RhsStorageOrder, ConjugateRhs, RowMajor, ResInnerStride, UpLo,
                                                 Version> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
   static EIGEN_STRONG_INLINE void run(Index size, Index depth, const LhsScalar* lhs, Index lhsStride,
                                       const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resIncr,
                                       Index resStride, const ResScalar& alpha,
@@ -63,7 +64,7 @@
 struct general_matrix_matrix_triangular_product<Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar,
                                                 RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride, UpLo,
                                                 Version> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
   static EIGEN_STRONG_INLINE void run(Index size, Index depth, const LhsScalar* lhs_, Index lhsStride,
                                       const RhsScalar* rhs_, Index rhsStride, ResScalar* res_, Index resIncr,
                                       Index resStride, const ResScalar& alpha,
@@ -72,11 +73,11 @@
       return;
     }
 
-    typedef gebp_traits<LhsScalar, RhsScalar> Traits;
+    using Traits = gebp_traits<LhsScalar, RhsScalar>;
 
-    typedef const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> LhsMapper;
-    typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMapper;
-    typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+    using LhsMapper = const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder>;
+    using RhsMapper = const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder>;
+    using ResMapper = blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
     LhsMapper lhs(lhs_, lhsStride);
     RhsMapper rhs(rhs_, rhsStride);
     ResMapper res(res_, resStride, resIncr);
@@ -116,18 +117,19 @@
 
         pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
 
-        // the selected actual_mc * size panel of res is split into three different part:
+        // the selected actual_mc * size panel of res is split into three different parts:
         //  1 - before the diagonal => processed with gebp or skipped
         //  2 - the actual_mc x actual_mc symmetric block => processed with a special kernel
         //  3 - after the diagonal => processed with gebp or skipped
-        if (UpLo == Lower)
+        EIGEN_IF_CONSTEXPR (UpLo == Lower) {
           gebp(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, (std::min)(size, i2), alpha, -1, -1, 0,
                0);
+        }
 
         sybb(res_ + resStride * i2 + resIncr * i2, resIncr, resStride, blockA, blockB + actual_kc * i2, actual_mc,
              actual_kc, alpha);
 
-        if (UpLo == Upper) {
+        EIGEN_IF_CONSTEXPR (UpLo == Upper) {
           Index j2 = i2 + actual_mc;
           gebp(res.getSubMapper(i2, j2), blockA, blockB + actual_kc * j2, actual_mc, actual_kc,
                (std::max)(Index(0), size - j2), alpha, -1, -1, 0, 0);
@@ -149,14 +151,14 @@
 template <typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs,
           int ResInnerStride, int UpLo>
 struct tribb_kernel {
-  typedef gebp_traits<LhsScalar, RhsScalar, ConjLhs, ConjRhs> Traits;
-  typedef typename Traits::ResScalar ResScalar;
+  using Traits = gebp_traits<LhsScalar, RhsScalar, ConjLhs, ConjRhs>;
+  using ResScalar = typename Traits::ResScalar;
 
-  enum { BlockSize = meta_least_common_multiple<plain_enum_max(mr, nr), plain_enum_min(mr, nr)>::ret };
+  enum { BlockSize = meta_least_common_multiple<plain_enum_max(mr, nr), plain_enum_min(mr, nr)>::value };
   void operator()(ResScalar* res_, Index resIncr, Index resStride, const LhsScalar* blockA, const RhsScalar* blockB,
                   Index size, Index depth, const ResScalar& alpha) const {
-    typedef blas_data_mapper<ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
-    typedef blas_data_mapper<ResScalar, Index, ColMajor, Unaligned> BufferMapper;
+    using ResMapper = blas_data_mapper<ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
+    using BufferMapper = blas_data_mapper<ResScalar, Index, ColMajor, Unaligned>;
     ResMapper res(res_, resStride, resIncr);
     gebp_kernel<LhsScalar, RhsScalar, Index, ResMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel1;
     gebp_kernel<LhsScalar, RhsScalar, Index, BufferMapper, mr, nr, ConjLhs, ConjRhs> gebp_kernel2;
@@ -169,8 +171,9 @@
       Index actualBlockSize = std::min<Index>(BlockSize, size - j);
       const RhsScalar* actual_b = blockB + j * depth;
 
-      if (UpLo == Upper)
+      EIGEN_IF_CONSTEXPR (UpLo == Upper) {
         gebp_kernel1(res.getSubMapper(0, j), blockA, actual_b, j, depth, actualBlockSize, alpha, -1, -1, 0, 0);
+      }
 
       // selfadjoint micro block
       {
@@ -188,7 +191,7 @@
         }
       }
 
-      if (UpLo == Lower) {
+      EIGEN_IF_CONSTEXPR (UpLo == Lower) {
         Index i = j + actualBlockSize;
         gebp_kernel1(res.getSubMapper(i, j), blockA + depth * i, actual_b, size - i, depth, actualBlockSize, alpha, -1,
                      -1, 0, 0);
@@ -207,18 +210,18 @@
 template <typename MatrixType, typename ProductType, int UpLo>
 struct general_product_to_triangular_selector<MatrixType, ProductType, UpLo, true> {
   static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta) {
-    typedef typename MatrixType::Scalar Scalar;
+    using Scalar = typename MatrixType::Scalar;
 
-    typedef internal::remove_all_t<typename ProductType::LhsNested> Lhs;
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
-    typedef internal::remove_all_t<ActualLhs> ActualLhs_;
+    using Lhs = internal::remove_all_t<typename ProductType::LhsNested>;
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhs = typename LhsBlasTraits::DirectLinearAccessType;
+    using ActualLhs_ = internal::remove_all_t<ActualLhs>;
     internal::add_const_on_value_type_t<ActualLhs> actualLhs = LhsBlasTraits::extract(prod.lhs());
 
-    typedef internal::remove_all_t<typename ProductType::RhsNested> Rhs;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
-    typedef internal::remove_all_t<ActualRhs> ActualRhs_;
+    using Rhs = internal::remove_all_t<typename ProductType::RhsNested>;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhs = typename RhsBlasTraits::DirectLinearAccessType;
+    using ActualRhs_ = internal::remove_all_t<ActualRhs>;
     internal::add_const_on_value_type_t<ActualRhs> actualRhs = RhsBlasTraits::extract(prod.rhs());
 
     Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) *
@@ -237,14 +240,18 @@
     ei_declare_aligned_stack_constructed_variable(
         Scalar, actualLhsPtr, actualLhs.size(),
         (UseLhsDirectly ? const_cast<Scalar*>(actualLhs.data()) : static_lhs.data()));
-    if (!UseLhsDirectly) Map<typename ActualLhs_::PlainObject>(actualLhsPtr, actualLhs.size()) = actualLhs;
+    EIGEN_IF_CONSTEXPR (!UseLhsDirectly) {
+      Map<typename ActualLhs_::PlainObject>(actualLhsPtr, actualLhs.size()) = actualLhs;
+    }
 
     internal::gemv_static_vector_if<Scalar, Rhs::SizeAtCompileTime, Rhs::MaxSizeAtCompileTime, !UseRhsDirectly>
         static_rhs;
     ei_declare_aligned_stack_constructed_variable(
         Scalar, actualRhsPtr, actualRhs.size(),
         (UseRhsDirectly ? const_cast<Scalar*>(actualRhs.data()) : static_rhs.data()));
-    if (!UseRhsDirectly) Map<typename ActualRhs_::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    EIGEN_IF_CONSTEXPR (!UseRhsDirectly) {
+      Map<typename ActualRhs_::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
+    }
 
     selfadjoint_rank1_update<
         Scalar, Index, StorageOrder, UpLo, LhsBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex,
@@ -257,16 +264,16 @@
 template <typename MatrixType, typename ProductType, int UpLo>
 struct general_product_to_triangular_selector<MatrixType, ProductType, UpLo, false> {
   static void run(MatrixType& mat, const ProductType& prod, const typename MatrixType::Scalar& alpha, bool beta) {
-    typedef internal::remove_all_t<typename ProductType::LhsNested> Lhs;
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
-    typedef internal::remove_all_t<ActualLhs> ActualLhs_;
+    using Lhs = internal::remove_all_t<typename ProductType::LhsNested>;
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhs = typename LhsBlasTraits::DirectLinearAccessType;
+    using ActualLhs_ = internal::remove_all_t<ActualLhs>;
     internal::add_const_on_value_type_t<ActualLhs> actualLhs = LhsBlasTraits::extract(prod.lhs());
 
-    typedef internal::remove_all_t<typename ProductType::RhsNested> Rhs;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
-    typedef internal::remove_all_t<ActualRhs> ActualRhs_;
+    using Rhs = internal::remove_all_t<typename ProductType::RhsNested>;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhs = typename RhsBlasTraits::DirectLinearAccessType;
+    using ActualRhs_ = internal::remove_all_t<ActualRhs>;
     internal::add_const_on_value_type_t<ActualRhs> actualRhs = RhsBlasTraits::extract(prod.rhs());
 
     typename ProductType::Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs().derived()) *
@@ -282,13 +289,16 @@
     };
 
     Index size = mat.cols();
-    if (SkipDiag) size--;
+    EIGEN_IF_CONSTEXPR (SkipDiag) size--;
     Index depth = actualLhs.cols();
+    eigen_assert(actualLhs.rows() == mat.rows() && actualRhs.cols() == mat.cols() &&
+                 actualLhs.cols() == actualRhs.rows());
+    if (size <= 0 || depth == 0) return;
 
-    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor, typename Lhs::Scalar, typename Rhs::Scalar,
-                                          MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime,
-                                          ActualRhs_::MaxColsAtCompileTime>
-        BlockingType;
+    using BlockingType =
+        internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor, typename Lhs::Scalar, typename Rhs::Scalar,
+                                      MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime,
+                                      ActualRhs_::MaxColsAtCompileTime>;
 
     BlockingType blocking(size, size, depth, 1, false);
 
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
index e14aa61..9f24ace 100644
--- a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
+++ b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
@@ -29,6 +29,7 @@
  *   Level 3 BLAS SYRK/HERK implementation.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
 #define EIGEN_GENERAL_MATRIX_MATRIX_TRIANGULAR_BLAS_H
@@ -46,23 +47,27 @@
                                                ConjugateA, ResStorageOrder, 1, UpLo, BuiltIn> {};
 
 // try to go to BLAS specialization
-#define EIGEN_BLAS_RANKUPDATE_SPECIALIZE(Scalar)                                                                      \
-  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs, int UpLo> \
-  struct general_matrix_matrix_triangular_product<Index, Scalar, LhsStorageOrder, ConjugateLhs, Scalar,               \
-                                                  RhsStorageOrder, ConjugateRhs, ColMajor, 1, UpLo, Specialized> {    \
-    static EIGEN_STRONG_INLINE void run(Index size, Index depth, const Scalar* lhs, Index lhsStride,                  \
-                                        const Scalar* rhs, Index rhsStride, Scalar* res, Index resIncr,               \
-                                        Index resStride, Scalar alpha, level3_blocking<Scalar, Scalar>& blocking) {   \
-      if (lhs == rhs && ((UpLo & (Lower | Upper)) == UpLo)) {                                                         \
-        general_matrix_matrix_rankupdate<Index, Scalar, LhsStorageOrder, ConjugateLhs, ColMajor, UpLo>::run(          \
-            size, depth, lhs, lhsStride, rhs, rhsStride, res, resStride, alpha, blocking);                            \
-      } else {                                                                                                        \
-        general_matrix_matrix_triangular_product<Index, Scalar, LhsStorageOrder, ConjugateLhs, Scalar,                \
-                                                 RhsStorageOrder, ConjugateRhs, ColMajor, 1, UpLo,                    \
-                                                 BuiltIn>::run(size, depth, lhs, lhsStride, rhs, rhsStride, res,      \
-                                                               resIncr, resStride, alpha, blocking);                  \
-      }                                                                                                               \
-    }                                                                                                                 \
+#define EIGEN_BLAS_RANKUPDATE_SPECIALIZE(Scalar)                                                                       \
+  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs, int UpLo>  \
+  struct general_matrix_matrix_triangular_product<Index, Scalar, LhsStorageOrder, ConjugateLhs, Scalar,                \
+                                                  RhsStorageOrder, ConjugateRhs, ColMajor, 1, UpLo, Specialized> {     \
+    static EIGEN_STRONG_INLINE void run(Index size, Index depth, const Scalar* lhs, Index lhsStride,                   \
+                                        const Scalar* rhs, Index rhsStride, Scalar* res, Index resIncr,                \
+                                        Index resStride, Scalar alpha, level3_blocking<Scalar, Scalar>& blocking) {    \
+      EIGEN_IF_CONSTEXPR ((UpLo & (Lower | Upper)) == UpLo) {                                                          \
+        if (lhs == rhs) {                                                                                              \
+          general_matrix_matrix_rankupdate<Index, Scalar, LhsStorageOrder, ConjugateLhs, ColMajor, UpLo>::run(         \
+              size, depth, lhs, lhsStride, rhs, rhsStride, res, resStride, alpha, blocking);                           \
+          return;                                                                                                      \
+        }                                                                                                              \
+      }                                                                                                                \
+      general_matrix_matrix_triangular_product<Index, Scalar, LhsStorageOrder, ConjugateLhs, Scalar, RhsStorageOrder,  \
+                                               ConjugateRhs, ColMajor, 1, UpLo, BuiltIn>::run(size, depth, lhs,        \
+                                                                                              lhsStride, rhs,          \
+                                                                                              rhsStride, res, resIncr, \
+                                                                                              resStride, alpha,        \
+                                                                                              blocking);               \
+    }                                                                                                                  \
   };
 
 EIGEN_BLAS_RANKUPDATE_SPECIALIZE(double)
@@ -83,7 +88,6 @@
     static EIGEN_STRONG_INLINE void run(Index size, Index depth, const EIGTYPE* lhs, Index lhsStride,               \
                                         const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, \
                                         EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {           \
-      /* typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs;*/                                    \
       if (size == 0 || depth == 0) return;                                                                          \
       BlasIndex lda = convert_index<BlasIndex>(lhsStride), ldc = convert_index<BlasIndex>(resStride),               \
                 n = convert_index<BlasIndex>(size), k = convert_index<BlasIndex>(depth);                            \
@@ -94,53 +98,14 @@
     }                                                                                                               \
   };
 
-// HERK for complex data
-#define EIGEN_BLAS_RANKUPDATE_C(EIGTYPE, BLASTYPE, RTYPE, BLASFUNC)                                                 \
-  template <typename Index, int AStorageOrder, bool ConjugateA, int UpLo>                                           \
-  struct general_matrix_matrix_rankupdate<Index, EIGTYPE, AStorageOrder, ConjugateA, ColMajor, UpLo> {              \
-    enum {                                                                                                          \
-      IsLower = (UpLo & Lower) == Lower,                                                                            \
-      LowUp = IsLower ? Lower : Upper,                                                                              \
-      conjA = (((AStorageOrder == ColMajor) && ConjugateA) || ((AStorageOrder == RowMajor) && !ConjugateA)) ? 1 : 0 \
-    };                                                                                                              \
-    static EIGEN_STRONG_INLINE void run(Index size, Index depth, const EIGTYPE* lhs, Index lhsStride,               \
-                                        const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, \
-                                        EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {           \
-      typedef Matrix<EIGTYPE, Dynamic, Dynamic, AStorageOrder> MatrixType;                                          \
-      if (size == 0 || depth == 0) return;                                                                          \
-      BlasIndex lda = convert_index<BlasIndex>(lhsStride), ldc = convert_index<BlasIndex>(resStride),               \
-                n = convert_index<BlasIndex>(size), k = convert_index<BlasIndex>(depth);                            \
-      char uplo = ((IsLower) ? 'L' : 'U'), trans = ((AStorageOrder == RowMajor) ? 'C' : 'N');                       \
-      RTYPE alpha_, beta_;                                                                                          \
-      const EIGTYPE* a_ptr;                                                                                         \
-                                                                                                                    \
-      alpha_ = alpha.real();                                                                                        \
-      beta_ = 1.0;                                                                                                  \
-      /* Copy with conjugation in some cases*/                                                                      \
-      MatrixType a;                                                                                                 \
-      if (conjA) {                                                                                                  \
-        Map<const MatrixType, 0, OuterStride<> > mapA(lhs, n, k, OuterStride<>(lhsStride));                         \
-        a = mapA.conjugate();                                                                                       \
-        lda = a.outerStride();                                                                                      \
-        a_ptr = a.data();                                                                                           \
-      } else                                                                                                        \
-        a_ptr = lhs;                                                                                                \
-      BLASFUNC(&uplo, &trans, &n, &k, &alpha_, (BLASTYPE*)a_ptr, &lda, &beta_, (BLASTYPE*)res, &ldc);               \
-    }                                                                                                               \
-  };
-
 #ifdef EIGEN_USE_MKL
 EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk)
 EIGEN_BLAS_RANKUPDATE_R(float, float, ssyrk)
 #else
-EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk_)
-EIGEN_BLAS_RANKUPDATE_R(float, float, ssyrk_)
+EIGEN_BLAS_RANKUPDATE_R(double, double, EIGEN_BLAS_SYM(dsyrk))
+EIGEN_BLAS_RANKUPDATE_R(float, float, EIGEN_BLAS_SYM(ssyrk))
 #endif
 
-// TODO: handle complex cases
-// EIGEN_BLAS_RANKUPDATE_C(dcomplex, double, double, zherk_)
-// EIGEN_BLAS_RANKUPDATE_C(scomplex, float,  float, cherk_)
-
 #undef EIGEN_BLAS_RANKUPDATE_SPECIALIZE
 #undef EIGEN_BLAS_RANKUPDATE_R
 }  // end namespace internal
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h b/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
index 11c29b6..d2bb687 100644
--- a/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
+++ b/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
@@ -29,6 +29,7 @@
  *   General matrix-matrix product functionality based on ?GEMM.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
 #define EIGEN_GENERAL_MATRIX_MATRIX_BLAS_H
@@ -83,7 +84,7 @@
       ldc = convert_index<BlasIndex>(resStride);                                                                    \
                                                                                                                     \
       /* Set a, b, c */                                                                                             \
-      if ((LhsStorageOrder == ColMajor) && (ConjugateLhs)) {                                                        \
+      EIGEN_IF_CONSTEXPR ((LhsStorageOrder == ColMajor) && (ConjugateLhs)) {                                        \
         Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(lhs_, m, k, OuterStride<>(lhsStride));                 \
         a_tmp = lhs.conjugate();                                                                                    \
         a = a_tmp.data();                                                                                           \
@@ -91,7 +92,7 @@
       } else                                                                                                        \
         a = lhs_;                                                                                                   \
                                                                                                                     \
-      if ((RhsStorageOrder == ColMajor) && (ConjugateRhs)) {                                                        \
+      EIGEN_IF_CONSTEXPR ((RhsStorageOrder == ColMajor) && (ConjugateRhs)) {                                        \
         Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(rhs_, k, n, OuterStride<>(rhsStride));                 \
         b_tmp = rhs.conjugate();                                                                                    \
         b = b_tmp.data();                                                                                           \
@@ -110,10 +111,10 @@
 EIGEN_BLAS_GEMM_SPECIALIZATION(dcomplex, cd, MKL_Complex16, zgemm)
 EIGEN_BLAS_GEMM_SPECIALIZATION(scomplex, cf, MKL_Complex8, cgemm)
 #else
-EIGEN_BLAS_GEMM_SPECIALIZATION(double, d, double, dgemm_)
-EIGEN_BLAS_GEMM_SPECIALIZATION(float, f, float, sgemm_)
-EIGEN_BLAS_GEMM_SPECIALIZATION(dcomplex, cd, double, zgemm_)
-EIGEN_BLAS_GEMM_SPECIALIZATION(scomplex, cf, float, cgemm_)
+EIGEN_BLAS_GEMM_SPECIALIZATION(double, d, double, EIGEN_BLAS_SYM(dgemm))
+EIGEN_BLAS_GEMM_SPECIALIZATION(float, f, float, EIGEN_BLAS_SYM(sgemm))
+EIGEN_BLAS_GEMM_SPECIALIZATION(dcomplex, cd, double, EIGEN_BLAS_SYM(zgemm))
+EIGEN_BLAS_GEMM_SPECIALIZATION(scomplex, cf, float, EIGEN_BLAS_SYM(cgemm))
 #endif
 
 // If OpenBLAS with BUILD_BFLOAT16=1 support is available,
@@ -122,9 +123,10 @@
 
 extern "C" {
 // OpenBLAS prototype.
-void sbgemm_(const char* trans_a, const char* trans_b, const int* M, const int* N, const int* K, const float* alpha,
-             const Eigen::bfloat16* A, const int* lda, const Eigen::bfloat16* B, const int* ldb, const float* beta,
-             float* C, const int* ldc);
+void EIGEN_BLAS_SYM(sbgemm)(const char* trans_a, const char* trans_b, const EIGEN_BLAS_INT* M, const EIGEN_BLAS_INT* N,
+                            const EIGEN_BLAS_INT* K, const float* alpha, const Eigen::bfloat16* A,
+                            const EIGEN_BLAS_INT* lda, const Eigen::bfloat16* B, const EIGEN_BLAS_INT* ldb,
+                            const float* beta, float* C, const EIGEN_BLAS_INT* ldc);
 }  // extern "C"
 
 template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs>
@@ -166,7 +168,7 @@
     ldc = convert_index<BlasIndex>(m);
 
     /* Set a, b, c */
-    if ((LhsStorageOrder == ColMajor) && (ConjugateLhs)) {
+    EIGEN_IF_CONSTEXPR ((LhsStorageOrder == ColMajor) && (ConjugateLhs)) {
       Map<const MatrixXbf16, 0, OuterStride<> > lhs(lhs_, m, k, OuterStride<>(lhsStride));
       a_tmp = lhs.conjugate();
       a = a_tmp.data();
@@ -175,7 +177,7 @@
       a = lhs_;
     }
 
-    if ((RhsStorageOrder == ColMajor) && (ConjugateRhs)) {
+    EIGEN_IF_CONSTEXPR ((RhsStorageOrder == ColMajor) && (ConjugateRhs)) {
       Map<const MatrixXbf16, 0, OuterStride<> > rhs(rhs_, k, n, OuterStride<>(rhsStride));
       b_tmp = rhs.conjugate();
       b = b_tmp.data();
@@ -187,8 +189,9 @@
     // Evaluate to a temporary intermediate array.
     r_tmp.resize(m, n);
 
-    sbgemm_(&transa, &transb, &m, &n, &k, (const float*)&numext::real_ref(falpha), a, &lda, b, &ldb,
-            (const float*)&numext::real_ref(fbeta), r_tmp.data(), &ldc);
+    EIGEN_BLAS_SYM(sbgemm)
+    (&transa, &transb, &m, &n, &k, (const float*)&numext::real_ref(falpha), a, &lda, b, &ldb,
+     (const float*)&numext::real_ref(fbeta), r_tmp.data(), &ldc);
 
     // Cast to the output.
     Map<MatrixXbf16, 0, OuterStride<> > result(res, m, n, OuterStride<>(resStride));
@@ -196,7 +199,7 @@
   }
 };
 
-#endif  // EIGEN_USE_OPENBLAS_SBGEMM
+#endif  // EIGEN_USE_OPENBLAS_BFLOAT16
 
 #undef EIGEN_BLAS_GEMM_SPECIALIZATION
 }  // namespace internal
diff --git a/Eigen/src/Core/products/GeneralMatrixVector.h b/Eigen/src/Core/products/GeneralMatrixVector.h
index 40694f2..ef8bc0f 100644
--- a/Eigen/src/Core/products/GeneralMatrixVector.h
+++ b/Eigen/src/Core/products/GeneralMatrixVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERAL_MATRIX_VECTOR_H
 #define EIGEN_GENERAL_MATRIX_VECTOR_H
@@ -13,33 +14,23 @@
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
 
+// C4804: unsafe use of type 'bool' in operation. Unavoidable in generic code
+// instantiated with bool scalars (e.g. += and * on bool).
+#if EIGEN_COMP_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4804)
+#endif
+
 namespace Eigen {
 
 namespace internal {
 
-enum GEMVPacketSizeType { GEMVPacketFull = 0, GEMVPacketHalf, GEMVPacketQuarter };
-
-template <int N, typename T1, typename T2, typename T3>
-struct gemv_packet_cond {
-  typedef T3 type;
-};
-
-template <typename T1, typename T2, typename T3>
-struct gemv_packet_cond<GEMVPacketFull, T1, T2, T3> {
-  typedef T1 type;
-};
-
-template <typename T1, typename T2, typename T3>
-struct gemv_packet_cond<GEMVPacketHalf, T1, T2, T3> {
-  typedef T2 type;
-};
-
-template <typename LhsScalar, typename RhsScalar, int PacketSize_ = GEMVPacketFull>
+template <typename LhsScalar, typename RhsScalar, int PacketSize_ = GEBPPacketFull>
 class gemv_traits {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
 
 #define PACKET_DECL_COND_POSTFIX(postfix, name, packet_size)                                               \
-  typedef typename gemv_packet_cond<                                                                       \
+  typedef typename packet_conditional<                                                                     \
       packet_size, typename packet_traits<name##Scalar>::type, typename packet_traits<name##Scalar>::half, \
       typename unpacket_traits<typename packet_traits<name##Scalar>::half>::half>::type name##Packet##postfix
 
@@ -57,9 +48,9 @@
     ResPacketSize = Vectorizable ? unpacket_traits<ResPacket_>::size : 1
   };
 
-  typedef std::conditional_t<Vectorizable, LhsPacket_, LhsScalar> LhsPacket;
-  typedef std::conditional_t<Vectorizable, RhsPacket_, RhsScalar> RhsPacket;
-  typedef std::conditional_t<Vectorizable, ResPacket_, ResScalar> ResPacket;
+  using LhsPacket = std::conditional_t<Vectorizable, LhsPacket_, LhsScalar>;
+  using RhsPacket = std::conditional_t<Vectorizable, RhsPacket_, RhsScalar>;
+  using ResPacket = std::conditional_t<Vectorizable, ResPacket_, ResScalar>;
 };
 
 /* Optimized col-major matrix * vector product:
@@ -73,29 +64,29 @@
  *  |cplx |real |cplx | invalid, the caller has to do tmp: = A * B; C += alpha*tmp
  *  |cplx |real |real | optimal case, vectorization possible via real-cplx mul
  *
- * The same reasoning apply for the transposed case.
+ * The same reasoning applies for the transposed case.
  */
 template <typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar,
           typename RhsMapper, bool ConjugateRhs, int Version>
 struct general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLhs, RhsScalar, RhsMapper,
                                      ConjugateRhs, Version> {
-  typedef gemv_traits<LhsScalar, RhsScalar> Traits;
-  typedef gemv_traits<LhsScalar, RhsScalar, GEMVPacketHalf> HalfTraits;
-  typedef gemv_traits<LhsScalar, RhsScalar, GEMVPacketQuarter> QuarterTraits;
+  using Traits = gemv_traits<LhsScalar, RhsScalar>;
+  using HalfTraits = gemv_traits<LhsScalar, RhsScalar, GEBPPacketHalf>;
+  using QuarterTraits = gemv_traits<LhsScalar, RhsScalar, GEBPPacketQuarter>;
 
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
 
-  typedef typename Traits::LhsPacket LhsPacket;
-  typedef typename Traits::RhsPacket RhsPacket;
-  typedef typename Traits::ResPacket ResPacket;
+  using LhsPacket = typename Traits::LhsPacket;
+  using RhsPacket = typename Traits::RhsPacket;
+  using ResPacket = typename Traits::ResPacket;
 
-  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
-  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
-  typedef typename HalfTraits::ResPacket ResPacketHalf;
+  using LhsPacketHalf = typename HalfTraits::LhsPacket;
+  using RhsPacketHalf = typename HalfTraits::RhsPacket;
+  using ResPacketHalf = typename HalfTraits::ResPacket;
 
-  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
-  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
-  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+  using LhsPacketQuarter = typename QuarterTraits::LhsPacket;
+  using RhsPacketQuarter = typename QuarterTraits::RhsPacket;
+  using ResPacketQuarter = typename QuarterTraits::ResPacket;
 
   EIGEN_DEVICE_FUNC inline static void run(Index rows, Index cols, const LhsMapper& lhs, const RhsMapper& rhs,
                                            ResScalar* res, Index resIncr, RhsScalar alpha);
@@ -106,51 +97,55 @@
       const ResPacket& palpha, conj_helper<LhsPacket, RhsPacket, ConjugateLhs, ConjugateRhs>& pcj);
 };
 
-// Recursive template unroller for col-major GEMV full-packet row blocks.
-// Unrolls the packet dimension (K = 0..N-1) at compile time, guaranteeing
-// that each accumulator lives in its own register variable.
-template <int K, int N>
-struct gemv_colmajor_unroller {
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void init_zero(Packet* c) {
-    gemv_colmajor_unroller<K - 1, N>::init_zero(c);
-    c[K] = pzero(Packet{});
-  }
-
-  template <typename LhsPacket, int LhsStride, int Alignment, typename AccPacket, typename RhsPacket,
-            typename ConjHelper, typename LhsMapper, typename Index>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void madd(AccPacket* c, const LhsMapper& lhs, Index i, Index j,
-                                                         const RhsPacket& b0, ConjHelper& pcj) {
-    gemv_colmajor_unroller<K - 1, N>::template madd<LhsPacket, LhsStride, Alignment>(c, lhs, i, j, b0, pcj);
-    c[K] = pcj.pmadd(lhs.template load<LhsPacket, Alignment>(i + LhsStride * K, j), b0, c[K]);
-  }
-
-  template <typename ResPacket, int ResStride, typename ResScalar>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void store(const ResPacket* c, ResScalar* res, Index i,
-                                                          const ResPacket& palpha) {
-    gemv_colmajor_unroller<K - 1, N>::template store<ResPacket, ResStride>(c, res, i, palpha);
-    pstoreu(res + i + ResStride * K, pmadd(c[K], palpha, ploadu<ResPacket>(res + i + ResStride * K)));
-  }
-};
-
+// Integer-sequence helper for col-major GEMV full-packet row blocks.
 template <int N>
-struct gemv_colmajor_unroller<0, N> {
+struct gemv_colmajor_unroller {
+  template <typename Packet, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void init_zero_impl(std::integer_sequence<int, K...>, Packet* c) {
+    int unused[] = {0, ((c[K] = pzero(Packet{})), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
   template <typename Packet>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void init_zero(Packet* c) {
-    c[0] = pzero(Packet{});
+    init_zero_impl(std::make_integer_sequence<int, N>{}, c);
+  }
+
+  template <typename LhsPacket, int LhsStride, int Alignment, typename AccPacket, typename RhsPacket,
+            typename ConjHelper, typename LhsMapper, typename Index, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void madd_impl(std::integer_sequence<int, K...>, AccPacket* c,
+                                                              const LhsMapper& lhs, Index i, Index j,
+                                                              const RhsPacket& b0, ConjHelper& pcj) {
+    int unused[] = {
+        0, ((c[K] = pcj.pmadd(lhs.template load<LhsPacket, Alignment>(i + LhsStride * K, j), b0, c[K])), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <typename LhsPacket, int LhsStride, int Alignment, typename AccPacket, typename RhsPacket,
             typename ConjHelper, typename LhsMapper, typename Index>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void madd(AccPacket* c, const LhsMapper& lhs, Index i, Index j,
                                                          const RhsPacket& b0, ConjHelper& pcj) {
-    c[0] = pcj.pmadd(lhs.template load<LhsPacket, Alignment>(i, j), b0, c[0]);
+    madd_impl<LhsPacket, LhsStride, Alignment>(std::make_integer_sequence<int, N>{}, c, lhs, i, j, b0, pcj);
   }
 
-  template <typename ResPacket, int ResStride, typename ResScalar>
+  template <int K, typename ResPacket, int ResStride, typename ResScalar, typename Index>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void store_one(const ResPacket* c, ResScalar* res, Index i,
+                                                              const ResPacket& palpha) {
+    ResScalar* r = res + i + ResStride * K;
+    pstoreu(r, pmadd(c[K], palpha, ploadu<ResPacket>(r)));
+  }
+
+  template <typename ResPacket, int ResStride, typename ResScalar, typename Index, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void store_impl(std::integer_sequence<int, K...>, const ResPacket* c,
+                                                               ResScalar* res, Index i, const ResPacket& palpha) {
+    int unused[] = {0, (store_one<K, ResPacket, ResStride>(c, res, i, palpha), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
+  }
+
+  template <typename ResPacket, int ResStride, typename ResScalar, typename Index>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void store(const ResPacket* c, ResScalar* res, Index i,
                                                           const ResPacket& palpha) {
-    pstoreu(res + i, pmadd(c[0], palpha, ploadu<ResPacket>(res + i)));
+    store_impl<ResPacket, ResStride>(std::make_integer_sequence<int, N>{}, c, res, i, palpha);
   }
 };
 
@@ -163,7 +158,7 @@
                            const ResPacket& palpha,
                            conj_helper<LhsPacket, RhsPacket, ConjugateLhs, ConjugateRhs>& pcj) {
   enum { LhsAlignment = Unaligned, LhsPacketSize = Traits::LhsPacketSize, ResPacketSize = Traits::ResPacketSize };
-  using Unroller = gemv_colmajor_unroller<N - 1, N>;
+  using Unroller = gemv_colmajor_unroller<N>;
 
   ResPacket c[N];
   Unroller::init_zero(c);
@@ -183,6 +178,9 @@
   EIGEN_UNUSED_VARIABLE(resIncr);
   eigen_internal_assert(resIncr == 1);
 
+  // BLAS contract: if alpha == 0, the result is unchanged (and lhs/rhs need not be read).
+  if (numext::is_exactly_zero(alpha)) return;
+
   // The following copy tells the compiler that lhs's attributes are not modified outside this function
   // This helps GCC to generate proper code.
   LhsMapper lhs(alhs);
@@ -193,7 +191,9 @@
   conj_helper<LhsPacketQuarter, RhsPacketQuarter, ConjugateLhs, ConjugateRhs> pcj_quarter;
 
   const Index lhsStride = lhs.stride();
-  // TODO: for padded aligned inputs, we could enable aligned reads
+  // LhsAlignment stays Unaligned; enabling aligned reads would require
+  // propagating the Mapper's Alignment through the run() template, and on
+  // modern x86 aligned/unaligned packet loads are equivalent anyway.
   enum {
     LhsAlignment = Unaligned,
     ResPacketSize = Traits::ResPacketSize,
@@ -212,8 +212,12 @@
   const Index n_half = rows - 1 * ResPacketSizeHalf + 1;
   const Index n_quarter = rows - 1 * ResPacketSizeQuarter + 1;
 
-  // TODO: improve the following heuristic:
-  const Index block_cols = cols < 128 ? cols : (lhsStride * Index(sizeof(LhsScalar)) < 32000 ? Index(16) : Index(4));
+  // Choose block_cols so that one column slice of the LHS roughly fits in L1.
+  // When it does not, fall back to a smaller batch to keep cache pressure down.
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  const Index block_cols =
+      cols < 128 ? cols : (lhsStride * Index(sizeof(LhsScalar)) < Index(l1) ? Index(16) : Index(4));
   ResPacket palpha = pset1<ResPacket>(alpha);
   ResPacketHalf palpha_half = pset1<ResPacketHalf>(alpha);
   ResPacketQuarter palpha_quarter = pset1<ResPacketQuarter>(alpha);
@@ -238,25 +242,29 @@
       process_rows<1>(i, j2, jend, lhs, rhs, res, palpha, pcj);
       i += ResPacketSize;
     }
-    if (HasHalf && i < n_half) {
-      ResPacketHalf c0 = pzero(ResPacketHalf{});
-      for (Index j = j2; j < jend; j += 1) {
-        RhsPacketHalf b0 = pset1<RhsPacketHalf>(rhs(j, 0));
-        c0 = pcj_half.pmadd(lhs.template load<LhsPacketHalf, LhsAlignment>(i + 0, j), b0, c0);
+    EIGEN_IF_CONSTEXPR (HasHalf) {
+      if (i < n_half) {
+        ResPacketHalf c0 = pzero(ResPacketHalf{});
+        for (Index j = j2; j < jend; j += 1) {
+          RhsPacketHalf b0 = pset1<RhsPacketHalf>(rhs(j, 0));
+          c0 = pcj_half.pmadd(lhs.template load<LhsPacketHalf, LhsAlignment>(i + 0, j), b0, c0);
+        }
+        pstoreu(res + i + ResPacketSizeHalf * 0,
+                pmadd(c0, palpha_half, ploadu<ResPacketHalf>(res + i + ResPacketSizeHalf * 0)));
+        i += ResPacketSizeHalf;
       }
-      pstoreu(res + i + ResPacketSizeHalf * 0,
-              pmadd(c0, palpha_half, ploadu<ResPacketHalf>(res + i + ResPacketSizeHalf * 0)));
-      i += ResPacketSizeHalf;
     }
-    if (HasQuarter && i < n_quarter) {
-      ResPacketQuarter c0 = pzero(ResPacketQuarter{});
-      for (Index j = j2; j < jend; j += 1) {
-        RhsPacketQuarter b0 = pset1<RhsPacketQuarter>(rhs(j, 0));
-        c0 = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter, LhsAlignment>(i + 0, j), b0, c0);
+    EIGEN_IF_CONSTEXPR (HasQuarter) {
+      if (i < n_quarter) {
+        ResPacketQuarter c0 = pzero(ResPacketQuarter{});
+        for (Index j = j2; j < jend; j += 1) {
+          RhsPacketQuarter b0 = pset1<RhsPacketQuarter>(rhs(j, 0));
+          c0 = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter, LhsAlignment>(i + 0, j), b0, c0);
+        }
+        pstoreu(res + i + ResPacketSizeQuarter * 0,
+                pmadd(c0, palpha_quarter, ploadu<ResPacketQuarter>(res + i + ResPacketSizeQuarter * 0)));
+        i += ResPacketSizeQuarter;
       }
-      pstoreu(res + i + ResPacketSizeQuarter * 0,
-              pmadd(c0, palpha_quarter, ploadu<ResPacketQuarter>(res + i + ResPacketSizeQuarter * 0)));
-      i += ResPacketSizeQuarter;
     }
     for (; i < rows; ++i) {
       ResScalar c0(0);
@@ -280,36 +288,34 @@
           typename RhsMapper, bool ConjugateRhs, int Version>
 struct general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLhs, RhsScalar, RhsMapper,
                                      ConjugateRhs, Version> {
-  typedef gemv_traits<LhsScalar, RhsScalar> Traits;
-  typedef gemv_traits<LhsScalar, RhsScalar, GEMVPacketHalf> HalfTraits;
-  typedef gemv_traits<LhsScalar, RhsScalar, GEMVPacketQuarter> QuarterTraits;
+  using Traits = gemv_traits<LhsScalar, RhsScalar>;
+  using HalfTraits = gemv_traits<LhsScalar, RhsScalar, GEBPPacketHalf>;
+  using QuarterTraits = gemv_traits<LhsScalar, RhsScalar, GEBPPacketQuarter>;
 
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
 
-  typedef typename Traits::LhsPacket LhsPacket;
-  typedef typename Traits::RhsPacket RhsPacket;
-  typedef typename Traits::ResPacket ResPacket;
+  using LhsPacket = typename Traits::LhsPacket;
+  using RhsPacket = typename Traits::RhsPacket;
+  using ResPacket = typename Traits::ResPacket;
 
-  typedef typename HalfTraits::LhsPacket LhsPacketHalf;
-  typedef typename HalfTraits::RhsPacket RhsPacketHalf;
-  typedef typename HalfTraits::ResPacket ResPacketHalf;
+  using LhsPacketHalf = typename HalfTraits::LhsPacket;
+  using RhsPacketHalf = typename HalfTraits::RhsPacket;
+  using ResPacketHalf = typename HalfTraits::ResPacket;
 
-  typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
-  typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
-  typedef typename QuarterTraits::ResPacket ResPacketQuarter;
+  using LhsPacketQuarter = typename QuarterTraits::LhsPacket;
+  using RhsPacketQuarter = typename QuarterTraits::RhsPacket;
+  using ResPacketQuarter = typename QuarterTraits::ResPacket;
 
   EIGEN_DEVICE_FUNC static inline void run(Index rows, Index cols, const LhsMapper& lhs, const RhsMapper& rhs,
                                            ResScalar* res, Index resIncr, ResScalar alpha);
 
-  // Specialized path for when cols < full packet size. Kept noinline to avoid
-  // bloating the main run() function and causing icache pressure.
-  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run_small_cols(Index rows, Index cols, const LhsMapper& lhs,
-                                                                 const RhsMapper& rhs, ResScalar* res, Index resIncr,
-                                                                 ResScalar alpha);
+  // Specialized path for when cols < full packet size.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void run_small_cols(Index rows, Index cols, const LhsMapper& lhs,
+                                                                   const RhsMapper& rhs, ResScalar* res, Index resIncr,
+                                                                   ResScalar alpha);
 
   // Templated helper that processes N rows in run_small_cols. N is a compile-time
-  // constant; row-dimension unrolling is done via recursive templates to guarantee
-  // full unrolling regardless of compiler heuristics.
+  // constant; row-dimension unrolling is done inside flat helper loops.
   template <int N>
   EIGEN_DEVICE_FUNC static EIGEN_ALWAYS_INLINE void process_rows_small_cols(Index i, Index cols, const LhsMapper& lhs,
                                                                             const RhsMapper& rhs, ResScalar* res,
@@ -324,10 +330,12 @@
 general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs,
                               Version>::run(Index rows, Index cols, const LhsMapper& alhs, const RhsMapper& rhs,
                                             ResScalar* res, Index resIncr, ResScalar alpha) {
+  // BLAS contract: if alpha == 0, the result is unchanged (and lhs/rhs need not be read).
+  if (numext::is_exactly_zero(alpha)) return;
+
   // When cols < full packet size, the main vectorized loops are empty.
-  // Dispatch to a separate noinline function to avoid polluting the icache.
-  // Only dispatch when cols is large enough that half or quarter packets can be used;
-  // otherwise the helper would just do scalar work with extra function call overhead.
+  // Use the sub-packet helper only when half or quarter packets can do useful work;
+  // otherwise it would just duplicate the scalar cleanup.
   enum {
     LhsPacketSize_ = Traits::LhsPacketSize,
     MinUsefulCols_ =
@@ -337,9 +345,13 @@
                                                                              : (int)Traits::LhsPacketSize),
     HasSubPackets_ = (int)MinUsefulCols_ < (int)LhsPacketSize_
   };
-  if (HasSubPackets_ && cols >= MinUsefulCols_ && cols < LhsPacketSize_) {
-    run_small_cols(rows, cols, alhs, rhs, res, resIncr, alpha);
-    return;
+  EIGEN_IF_CONSTEXPR (HasSubPackets_) {
+    if (cols >= MinUsefulCols_) {
+      if (cols < LhsPacketSize_) {
+        run_small_cols(rows, cols, alhs, rhs, res, resIncr, alpha);
+        return;
+      }
+    }
   }
 
   // The following copy tells the compiler that lhs's attributes are not modified outside this function
@@ -352,13 +364,17 @@
   conj_helper<LhsPacketHalf, RhsPacketHalf, ConjugateLhs, ConjugateRhs> pcj_half;
   conj_helper<LhsPacketQuarter, RhsPacketQuarter, ConjugateLhs, ConjugateRhs> pcj_quarter;
 
-  // TODO: fine tune the following heuristic. The rationale is that if the matrix is very large,
-  //       processing 8 rows at once might be counter productive wrt cache.
-  const Index n8 = lhs.stride() * sizeof(LhsScalar) > 32000 ? 0 : rows - 7;
+  // Disable the 8-row inner unroll once a single column slice no longer fits in L1; with very
+  // large LHS strides each unrolled iteration evicts the previously-loaded rows from cache.
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  const Index n8 = lhs.stride() * Index(sizeof(LhsScalar)) > Index(l1) ? 0 : rows - 7;
   const Index n4 = rows - 3;
   const Index n2 = rows - 1;
 
-  // TODO: for padded aligned inputs, we could enable aligned reads
+  // LhsAlignment stays Unaligned; enabling aligned reads would require
+  // propagating the Mapper's Alignment through the run() template, and on
+  // modern x86 aligned/unaligned packet loads are equivalent anyway.
   enum {
     LhsAlignment = Unaligned,
     ResPacketSize = Traits::ResPacketSize,
@@ -483,14 +499,14 @@
       c0 = pcj.pmadd(lhs.template load<LhsPacket, LhsAlignment>(i, j), b0, c0);
     }
     ResScalar cc0 = predux(c0);
-    if (HasHalf) {
+    EIGEN_IF_CONSTEXPR (HasHalf) {
       for (Index j = fullColBlockEnd; j < halfColBlockEnd; j += LhsPacketSizeHalf) {
         RhsPacketHalf b0 = rhs.template load<RhsPacketHalf, Unaligned>(j, 0);
         c0_h = pcj_half.pmadd(lhs.template load<LhsPacketHalf, LhsAlignment>(i, j), b0, c0_h);
       }
       cc0 += predux(c0_h);
     }
-    if (HasQuarter) {
+    EIGEN_IF_CONSTEXPR (HasQuarter) {
       for (Index j = halfColBlockEnd; j < quarterColBlockEnd; j += LhsPacketSizeQuarter) {
         RhsPacketQuarter b0 = rhs.template load<RhsPacketQuarter, Unaligned>(j, 0);
         c0_q = pcj_quarter.pmadd(lhs.template load<LhsPacketQuarter, LhsAlignment>(i, j), b0, c0_q);
@@ -504,76 +520,74 @@
   }
 }
 
-// Recursive template unroller for process_rows_small_cols.
-// Unrolls the row dimension (K = 0..N-1) at compile time, guaranteeing
-// that each accumulator lives in its own register variable regardless
-// of compiler unrolling heuristics.
-template <int K, int N>
+// Integer-sequence helper for process_rows_small_cols.
+template <int N>
 struct gemv_small_cols_unroller {
   template <typename LhsPacket, typename AccPacket, int Alignment, typename RhsType, typename ConjHelper,
-            typename LhsMapper, typename Index>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void madd(AccPacket* acc, const LhsMapper& lhs, Index i, Index j,
-                                                         const RhsType& b0, ConjHelper& pcj) {
-    gemv_small_cols_unroller<K - 1, N>::template madd<LhsPacket, AccPacket, Alignment>(acc, lhs, i, j, b0, pcj);
-    acc[K] = pcj.pmadd(lhs.template load<LhsPacket, Alignment>(i + K, j), b0, acc[K]);
+            typename LhsMapper, typename Index, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void madd_impl(std::integer_sequence<int, K...>, AccPacket* acc,
+                                                              const LhsMapper& lhs, Index i, Index j, const RhsType& b0,
+                                                              ConjHelper& pcj) {
+    int unused[] = {0, ((acc[K] = pcj.pmadd(lhs.template load<LhsPacket, Alignment>(i + K, j), b0, acc[K])), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
-  template <typename ResScalar, typename RhsScalar, typename ConjHelper, typename LhsMapper, typename Index>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scalar_madd(ResScalar* cc, const LhsMapper& lhs, Index i, Index j,
-                                                                const RhsScalar& b0, ConjHelper& cj) {
-    gemv_small_cols_unroller<K - 1, N>::scalar_madd(cc, lhs, i, j, b0, cj);
-    cc[K] += cj.pmul(lhs(i + K, j), b0);
-  }
-
-  template <typename Scalar, typename Packet>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void predux_accum(Scalar* cc, const Packet* acc) {
-    gemv_small_cols_unroller<K - 1, N>::predux_accum(cc, acc);
-    cc[K] += predux(acc[K]);
-  }
-
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void init_zero(Packet* acc) {
-    gemv_small_cols_unroller<K - 1, N>::init_zero(acc);
-    acc[K] = pzero(Packet{});
-  }
-
-  template <typename Scalar, typename Index>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void write_result(Scalar* res, Index resIncr, Index i, Scalar alpha,
-                                                                 const Scalar* cc) {
-    gemv_small_cols_unroller<K - 1, N>::write_result(res, resIncr, i, alpha, cc);
-    res[(i + K) * resIncr] += alpha * cc[K];
-  }
-};
-
-template <int N>
-struct gemv_small_cols_unroller<0, N> {
   template <typename LhsPacket, typename AccPacket, int Alignment, typename RhsType, typename ConjHelper,
             typename LhsMapper, typename Index>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void madd(AccPacket* acc, const LhsMapper& lhs, Index i, Index j,
                                                          const RhsType& b0, ConjHelper& pcj) {
-    acc[0] = pcj.pmadd(lhs.template load<LhsPacket, Alignment>(i, j), b0, acc[0]);
+    madd_impl<LhsPacket, AccPacket, Alignment>(std::make_integer_sequence<int, N>{}, acc, lhs, i, j, b0, pcj);
+  }
+
+  template <typename ResScalar, typename RhsScalar, typename ConjHelper, typename LhsMapper, typename Index, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scalar_madd_impl(std::integer_sequence<int, K...>, ResScalar* cc,
+                                                                     const LhsMapper& lhs, Index i, Index j,
+                                                                     const RhsScalar& b0, ConjHelper& cj) {
+    int unused[] = {0, ((cc[K] += cj.pmul(lhs(i + K, j), b0)), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <typename ResScalar, typename RhsScalar, typename ConjHelper, typename LhsMapper, typename Index>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void scalar_madd(ResScalar* cc, const LhsMapper& lhs, Index i, Index j,
                                                                 const RhsScalar& b0, ConjHelper& cj) {
-    cc[0] += cj.pmul(lhs(i, j), b0);
+    scalar_madd_impl(std::make_integer_sequence<int, N>{}, cc, lhs, i, j, b0, cj);
+  }
+
+  template <typename Scalar, typename Packet, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void predux_accum_impl(std::integer_sequence<int, K...>, Scalar* cc,
+                                                                      const Packet* acc) {
+    int unused[] = {0, ((cc[K] += predux(acc[K])), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <typename Scalar, typename Packet>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void predux_accum(Scalar* cc, const Packet* acc) {
-    cc[0] += predux(acc[0]);
+    predux_accum_impl(std::make_integer_sequence<int, N>{}, cc, acc);
+  }
+
+  template <typename Packet, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void init_zero_impl(std::integer_sequence<int, K...>, Packet* acc) {
+    int unused[] = {0, ((acc[K] = pzero(Packet{})), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <typename Packet>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void init_zero(Packet* acc) {
-    acc[0] = pzero(Packet{});
+    init_zero_impl(std::make_integer_sequence<int, N>{}, acc);
+  }
+
+  template <typename Scalar, typename Index, int... K>
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void write_result_impl(std::integer_sequence<int, K...>, Scalar* res,
+                                                                      Index resIncr, Index i, Scalar alpha,
+                                                                      const Scalar* cc) {
+    int unused[] = {0, ((res[(i + K) * resIncr] += alpha * cc[K]), 0)...};
+    EIGEN_UNUSED_VARIABLE(unused);
   }
 
   template <typename Scalar, typename Index>
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void write_result(Scalar* res, Index resIncr, Index i, Scalar alpha,
                                                                  const Scalar* cc) {
-    res[i * resIncr] += alpha * cc[0];
+    write_result_impl(std::make_integer_sequence<int, N>{}, res, resIncr, i, alpha, cc);
   }
 };
 
@@ -600,10 +614,10 @@
     HasQuarter = (int)ResPacketSizeQuarter < (int)ResPacketSizeHalf
   };
 
-  using Unroll = gemv_small_cols_unroller<N - 1, N>;
+  using Unroll = gemv_small_cols_unroller<N>;
 
   ResScalar cc[N] = {};
-  if (HasHalf) {
+  EIGEN_IF_CONSTEXPR (HasHalf) {
     ResPacketHalf h[N];
     Unroll::init_zero(h);
     for (Index j = 0; j < halfColBlockEnd; j += LhsPacketSizeHalf) {
@@ -612,7 +626,7 @@
     }
     Unroll::predux_accum(cc, h);
   }
-  if (HasQuarter) {
+  EIGEN_IF_CONSTEXPR (HasQuarter) {
     ResPacketQuarter q[N];
     Unroll::init_zero(q);
     for (Index j = halfColBlockEnd; j < quarterColBlockEnd; j += LhsPacketSizeQuarter) {
@@ -630,7 +644,7 @@
 
 template <typename Index, typename LhsScalar, typename LhsMapper, bool ConjugateLhs, typename RhsScalar,
           typename RhsMapper, bool ConjugateRhs, int Version>
-EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void
 general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLhs, RhsScalar, RhsMapper, ConjugateRhs,
                               Version>::run_small_cols(Index rows, Index cols, const LhsMapper& alhs,
                                                        const RhsMapper& rhs, ResScalar* res, Index resIncr,
@@ -647,7 +661,11 @@
   const Index halfColBlockEnd = LhsPacketSizeHalf * (UnsignedIndex(cols) / LhsPacketSizeHalf);
   const Index quarterColBlockEnd = LhsPacketSizeQuarter * (UnsignedIndex(cols) / LhsPacketSizeQuarter);
 
-  const Index n8 = lhs.stride() * sizeof(LhsScalar) > 32000 ? 0 : rows - 7;
+  // Disable the 8-row inner unroll once a single column slice no longer fits in L1; with very
+  // large LHS strides each unrolled iteration evicts the previously-loaded rows from cache.
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+  const Index n8 = lhs.stride() * Index(sizeof(LhsScalar)) > Index(l1) ? 0 : rows - 7;
   const Index n4 = rows - 3;
   const Index n2 = rows - 1;
 
@@ -672,4 +690,8 @@
 
 }  // end namespace Eigen
 
+#if EIGEN_COMP_MSVC
+#pragma warning(pop)
+#endif
+
 #endif  // EIGEN_GENERAL_MATRIX_VECTOR_H
diff --git a/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h b/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
index 18adfd1..a36006d 100644
--- a/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
+++ b/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
@@ -29,6 +29,7 @@
  *   General matrix-vector product functionality based on ?GEMV.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
 #define EIGEN_GENERAL_MATRIX_VECTOR_BLAS_H
@@ -61,7 +62,7 @@
     static void run(Index rows, Index cols, const const_blas_data_mapper<Scalar, Index, ColMajor>& lhs,          \
                     const const_blas_data_mapper<Scalar, Index, RowMajor>& rhs, Scalar* res, Index resIncr,      \
                     Scalar alpha) {                                                                              \
-      if (ConjugateLhs) {                                                                                        \
+      EIGEN_IF_CONSTEXPR (ConjugateLhs) {                                                                        \
         general_matrix_vector_product<Index, Scalar, const_blas_data_mapper<Scalar, Index, ColMajor>, ColMajor,  \
                                       ConjugateLhs, Scalar, const_blas_data_mapper<Scalar, Index, RowMajor>,     \
                                       ConjugateRhs, BuiltIn>::run(rows, cols, lhs, rhs, res, resIncr, alpha);    \
@@ -102,12 +103,12 @@
       const EIGTYPE beta(1);                                                                                        \
       const EIGTYPE* x_ptr;                                                                                         \
       char trans = (LhsStorageOrder == ColMajor) ? 'N' : (ConjugateLhs) ? 'C' : 'T';                                \
-      if (LhsStorageOrder == RowMajor) {                                                                            \
+      EIGEN_IF_CONSTEXPR (LhsStorageOrder == RowMajor) {                                                            \
         m = convert_index<BlasIndex>(cols);                                                                         \
         n = convert_index<BlasIndex>(rows);                                                                         \
       }                                                                                                             \
       GEMVVector x_tmp;                                                                                             \
-      if (ConjugateRhs) {                                                                                           \
+      EIGEN_IF_CONSTEXPR (ConjugateRhs) {                                                                           \
         Map<const GEMVVector, 0, InnerStride<> > map_x(rhs, cols, 1, InnerStride<>(incx));                          \
         x_tmp = map_x.conjugate();                                                                                  \
         x_ptr = x_tmp.data();                                                                                       \
@@ -126,10 +127,10 @@
 EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, MKL_Complex16, zgemv)
 EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, MKL_Complex8, cgemv)
 #else
-EIGEN_BLAS_GEMV_SPECIALIZATION(double, double, dgemv_)
-EIGEN_BLAS_GEMV_SPECIALIZATION(float, float, sgemv_)
-EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, double, zgemv_)
-EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, float, cgemv_)
+EIGEN_BLAS_GEMV_SPECIALIZATION(double, double, EIGEN_BLAS_SYM(dgemv))
+EIGEN_BLAS_GEMV_SPECIALIZATION(float, float, EIGEN_BLAS_SYM(sgemv))
+EIGEN_BLAS_GEMV_SPECIALIZATION(dcomplex, double, EIGEN_BLAS_SYM(zgemv))
+EIGEN_BLAS_GEMV_SPECIALIZATION(scomplex, float, EIGEN_BLAS_SYM(cgemv))
 #endif
 
 #undef EIGEN_BLAS_GEMV_SPECIALIZE
diff --git a/Eigen/src/Core/products/Parallelizer.h b/Eigen/src/Core/products/Parallelizer.h
index f4625e2..1d82a11 100644
--- a/Eigen/src/Core/products/Parallelizer.h
+++ b/Eigen/src/Core/products/Parallelizer.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARALLELIZER_H
 #define EIGEN_PARALLELIZER_H
@@ -46,7 +47,7 @@
 
 // Public APIs.
 
-/** Must be call first when calling Eigen from multiple threads */
+/** \deprecated Does nothing. No initialization is required before calling Eigen from multiple threads. */
 EIGEN_DEPRECATED_WITH_REASON("Initialization is no longer needed.") inline void initParallel() {}
 
 /** \returns the max number of threads reserved for Eigen
@@ -73,8 +74,10 @@
 inline ThreadPool* setGemmThreadPool(ThreadPool* new_pool) {
   static ThreadPool* pool = nullptr;
   if (new_pool != nullptr) {
-    // This will wait for work in all threads in *pool to finish,
-    // then destroy the old ThreadPool, and then replace it with new_pool.
+    // This only replaces the stored pointer: work already scheduled on the old
+    // ThreadPool is not waited for, and the old pool is not destroyed. Since
+    // this returns the new pool, the caller must keep its own pointer to the
+    // old one to dispose of it.
     pool = new_pool;
     // Reset the number of threads to the number of threads on the new pool.
     setNbThreads(pool->NumThreads());
@@ -90,6 +93,30 @@
 
 // Implementation.
 
+// Granularity of the column split. Aligning to Traits::nr instead would avoid a partial leading
+// rhs panel per thread, but nr is 8 on several backends and the coarser split balances worse: on a
+// 72-core Neoverse V2, nr-alignment cost 3.5-4.5% at high thread counts (8192x8192 float, 72
+// threads: 5132 vs 5315 GFLOP/s). gebp handles a partial panel, so prefer the finer balance.
+constexpr int kGemmColGrain = 4;
+
+/** \internal
+ * Splits [0, \a total) into \a parts contiguous ranges and returns the one belonging to \a part.
+ * Lengths are multiples of \a grain apart from the final partial one, and the remainder is spread
+ * over the leading parts rather than appended to the last: every thread waits on the slowest.
+ * The ranges tile [0, \a total) exactly, which the packed-lhs handoff in
+ * general_matrix_matrix_product relies on for its blockA offsets. */
+template <typename Index>
+EIGEN_ALWAYS_INLINE void balanced_gemm_range(Index total, Index parts, Index grain, Index part, Index& start,
+                                             Index& length) {
+  const Index chunks = numext::div_ceil(total, grain);
+  const Index base = chunks / parts;
+  const Index extra = chunks % parts;
+  const Index first_chunk = part * base + numext::mini(part, extra);
+  const Index chunk_count = base + (part < extra ? 1 : 0);
+  start = numext::mini(first_chunk * grain, total);
+  length = numext::mini(chunk_count * grain, total - start);
+}
+
 #if defined(EIGEN_USE_BLAS) || (!defined(EIGEN_HAS_OPENMP) && !defined(EIGEN_GEMM_THREADPOOL))
 
 inline void manage_multi_threading(Action action, int* v) {
@@ -114,11 +141,11 @@
 
 template <typename Index>
 struct GemmParallelTaskInfo {
-  GemmParallelTaskInfo() : sync(-1), users(0), lhs_start(0), lhs_length(0) {}
-  std::atomic<Index> sync;
-  std::atomic<int> users;
-  Index lhs_start;
-  Index lhs_length;
+  GemmParallelTaskInfo() {}
+  std::atomic<Index> sync{Index(-1)};
+  std::atomic<int> users{0};
+  Index lhs_start = 0;
+  Index lhs_length = 0;
 };
 
 template <typename Index>
@@ -141,7 +168,7 @@
     // for OpenMP.
     eigen_internal_assert(*v >= 0);
     int omp_threads = omp_get_max_threads();
-    m_maxThreads = (*v == 0 ? omp_threads : std::min(*v, omp_threads));
+    m_maxThreads = (*v == 0 ? omp_threads : std::min<int>(*v, omp_threads));
 #elif defined(EIGEN_GEMM_THREADPOOL)
     // Calling action == SetAction and *v = 0 means
     // restoring m_maxThreads to the number of threads in the ThreadPool,
@@ -219,15 +246,11 @@
     Index actual_threads = omp_get_num_threads();
     GemmParallelInfo<Index> info(static_cast<int>(i), static_cast<int>(actual_threads), task_info);
 
-    Index blockCols = (cols / actual_threads) & ~Index(0x3);
-    Index blockRows = (rows / actual_threads);
-    blockRows = (blockRows / Functor::Traits::mr) * Functor::Traits::mr;
+    Index r0, actualBlockRows;
+    balanced_gemm_range<Index>(rows, actual_threads, Index(Functor::Traits::mr), i, r0, actualBlockRows);
 
-    Index r0 = i * blockRows;
-    Index actualBlockRows = (i + 1 == actual_threads) ? rows - r0 : blockRows;
-
-    Index c0 = i * blockCols;
-    Index actualBlockCols = (i + 1 == actual_threads) ? cols - c0 : blockCols;
+    Index c0, actualBlockCols;
+    balanced_gemm_range<Index>(cols, actual_threads, Index(kGemmColGrain), i, c0, actualBlockCols);
 
     info.task_info[i].lhs_start = r0;
     info.task_info[i].lhs_length = actualBlockRows;
@@ -243,15 +266,11 @@
   auto task = [=, &func, &barrier, &task_info](int i) {
     Index actual_threads = threads;
     GemmParallelInfo<Index> info(i, static_cast<int>(actual_threads), task_info);
-    Index blockCols = (cols / actual_threads) & ~Index(0x3);
-    Index blockRows = (rows / actual_threads);
-    blockRows = (blockRows / Functor::Traits::mr) * Functor::Traits::mr;
+    Index r0, actualBlockRows;
+    balanced_gemm_range<Index>(rows, actual_threads, Index(Functor::Traits::mr), i, r0, actualBlockRows);
 
-    Index r0 = i * blockRows;
-    Index actualBlockRows = (i + 1 == actual_threads) ? rows - r0 : blockRows;
-
-    Index c0 = i * blockCols;
-    Index actualBlockCols = (i + 1 == actual_threads) ? cols - c0 : blockCols;
+    Index c0, actualBlockCols;
+    balanced_gemm_range<Index>(cols, actual_threads, Index(kGemmColGrain), i, c0, actualBlockCols);
 
     info.task_info[i].lhs_start = r0;
     info.task_info[i].lhs_length = actualBlockRows;
diff --git a/Eigen/src/Core/products/SelfadjointMatrixMatrix.h b/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
index fd66b60..52699e1 100644
--- a/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
+++ b/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_H
 #define EIGEN_SELFADJOINT_MATRIX_MATRIX_H
@@ -18,43 +19,56 @@
 namespace internal {
 
 // pack a selfadjoint block diagonal for use with the gebp_kernel
-template <typename Scalar, typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
+//
+// The panel-width schedule and depth-major layout must match gemm_pack_lhs:
+// gebp_kernel cannot tell symm-packed and gemm-packed operands apart. A panel
+// of width bw at row offset i splits at the diagonal: depth [0, i) reads the
+// stored triangle directly, depth [i + bw, cols) reads its conjugated mirror
+// through a transposed-order mapper, and both rectangles delegate to the
+// (vectorized) gemm_pack_lhs; only the bw x bw diagonal band is packed per row.
+template <typename Scalar, typename Index, int Pack1, int Pack2, int StorageOrder>
 struct symm_pack_lhs {
-  template <int BlockRows>
-  inline void pack(Scalar* blockA, const const_blas_data_mapper<Scalar, Index, StorageOrder>& lhs, Index cols, Index i,
-                   Index& count) const {
-    // normal copy
-    for (Index k = 0; k < i; k++)
-      for (Index w = 0; w < BlockRows; w++) blockA[count++] = lhs(i + w, k);  // normal
-    // symmetric copy
-    Index h = 0;
-    for (Index k = i; k < i + BlockRows; k++) {
-      for (Index w = 0; w < h; w++) blockA[count++] = numext::conj(lhs(k, i + w));  // transposed
+  static constexpr int TransposedStorageOrder = StorageOrder == ColMajor ? RowMajor : ColMajor;
+  static constexpr int PacketSize = packet_traits<Scalar>::size;
+  using PacketType = typename packet_traits<Scalar>::type;
+  using Mapper = const_blas_data_mapper<Scalar, Index, StorageOrder>;
+  using TransposedMapper = const_blas_data_mapper<Scalar, Index, TransposedStorageOrder>;
+  // Pack2 is Traits::LhsProgress, the same value the driver hands its
+  // gemm_pack_lhs for the off-diagonal panels: the diagonal block has to be
+  // packed the way those are, since gebp_kernel consumes them alike.
+  using DirectPacker = gemm_pack_lhs<Scalar, Index, Mapper, Pack1, Pack2, PacketType, StorageOrder, false, false>;
+  using MirroredPacker =
+      gemm_pack_lhs<Scalar, Index, TransposedMapper, Pack1, Pack2, PacketType, TransposedStorageOrder, true, false>;
 
-      blockA[count++] = numext::real(lhs(k, k));  // real (diagonal)
-
-      for (Index w = h + 1; w < BlockRows; w++) blockA[count++] = lhs(i + w, k);  // normal
-      ++h;
+  void pack_panel(Scalar* blockA, const Mapper& lhs, const TransposedMapper& lhs_t, Index cols, Index i, Index bw,
+                  Index& count) const {
+    Scalar* panel = blockA + count;
+    const Index band_end = i + bw;
+    if (i > 0) DirectPacker()(panel, lhs.getSubMapper(i, 0), i, bw);
+    // Diagonal band: row k mirrors its first k - i entries, drops the
+    // imaginary part of the diagonal, and reads the rest directly.
+    for (Index k = i; k < band_end; k++) {
+      Scalar* row = panel + k * bw;
+      const Index h = k - i;
+      for (Index w = 0; w < h; w++) row[w] = numext::conj(lhs(k, i + w));
+      row[h] = numext::real(lhs(k, k));
+      for (Index w = h + 1; w < bw; w++) row[w] = lhs(i + w, k);
     }
-    // transposed copy
-    for (Index k = i + BlockRows; k < cols; k++)
-      for (Index w = 0; w < BlockRows; w++) blockA[count++] = numext::conj(lhs(k, i + w));  // transposed
+    if (cols > band_end) MirroredPacker()(panel + band_end * bw, lhs_t.getSubMapper(i, band_end), cols - band_end, bw);
+    count += bw * numext::maxi(cols, band_end);
   }
-  void operator()(Scalar* blockA, const Scalar* lhs_, Index lhsStride, Index cols, Index rows) const {
-    typedef typename unpacket_traits<typename packet_traits<Scalar>::type>::half HalfPacket;
-    typedef typename unpacket_traits<typename unpacket_traits<typename packet_traits<Scalar>::type>::half>::half
-        QuarterPacket;
-    enum {
-      PacketSize = packet_traits<Scalar>::size,
-      HalfPacketSize = unpacket_traits<HalfPacket>::size,
-      QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
-      HasHalf = (int)HalfPacketSize < (int)PacketSize,
-      HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize
-    };
 
-    const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(lhs_, lhsStride);
+  void operator()(Scalar* blockA, const Scalar* lhs_, Index lhsStride, Index cols, Index rows) const {
+    using HalfPacket = typename unpacket_traits<PacketType>::half;
+    using QuarterPacket = typename unpacket_traits<HalfPacket>::half;
+    constexpr int HalfPacketSize = unpacket_traits<HalfPacket>::size;
+    constexpr int QuarterPacketSize = unpacket_traits<QuarterPacket>::size;
+    constexpr bool HasHalf = HalfPacketSize < PacketSize;
+    constexpr bool HasQuarter = QuarterPacketSize < HalfPacketSize;
+
+    const Mapper lhs(lhs_, lhsStride);
+    const TransposedMapper lhs_t(lhs_, lhsStride);
     Index count = 0;
-    // Index peeled_mc3 = (rows/Pack1)*Pack1;
 
     const Index peeled_mc3 = Pack1 >= 3 * PacketSize ? (rows / (3 * PacketSize)) * (3 * PacketSize) : 0;
     const Index peeled_mc2 =
@@ -68,174 +82,104 @@
             ? peeled_mc_half + ((rows - peeled_mc_half) / (QuarterPacketSize)) * (QuarterPacketSize)
             : 0;
 
-    if (Pack1 >= 3 * PacketSize)
-      for (Index i = 0; i < peeled_mc3; i += 3 * PacketSize) pack<3 * PacketSize>(blockA, lhs, cols, i, count);
+    auto pack_rows = [&](Index begin, Index end, Index bw) {
+      for (Index i = begin; i < end; i += bw) pack_panel(blockA, lhs, lhs_t, cols, i, bw, count);
+    };
 
-    if (Pack1 >= 2 * PacketSize)
-      for (Index i = peeled_mc3; i < peeled_mc2; i += 2 * PacketSize) pack<2 * PacketSize>(blockA, lhs, cols, i, count);
-
-    if (Pack1 >= 1 * PacketSize)
-      for (Index i = peeled_mc2; i < peeled_mc1; i += 1 * PacketSize) pack<1 * PacketSize>(blockA, lhs, cols, i, count);
-
-    if (HasHalf && Pack1 >= HalfPacketSize)
-      for (Index i = peeled_mc1; i < peeled_mc_half; i += HalfPacketSize)
-        pack<HalfPacketSize>(blockA, lhs, cols, i, count);
-
-    if (HasQuarter && Pack1 >= QuarterPacketSize)
-      for (Index i = peeled_mc_half; i < peeled_mc_quarter; i += QuarterPacketSize)
-        pack<QuarterPacketSize>(blockA, lhs, cols, i, count);
+    EIGEN_IF_CONSTEXPR (Pack1 >= 3 * PacketSize) pack_rows(0, peeled_mc3, 3 * PacketSize);
+    EIGEN_IF_CONSTEXPR (Pack1 >= 2 * PacketSize) pack_rows(peeled_mc3, peeled_mc2, 2 * PacketSize);
+    EIGEN_IF_CONSTEXPR (Pack1 >= 1 * PacketSize) pack_rows(peeled_mc2, peeled_mc1, 1 * PacketSize);
+    EIGEN_IF_CONSTEXPR (HasHalf && Pack1 >= HalfPacketSize) pack_rows(peeled_mc1, peeled_mc_half, HalfPacketSize);
+    EIGEN_IF_CONSTEXPR (HasQuarter && Pack1 >= QuarterPacketSize)
+      pack_rows(peeled_mc_half, peeled_mc_quarter, QuarterPacketSize);
 
     // do the same with mr==1
-    for (Index i = peeled_mc_quarter; i < rows; i++) {
-      for (Index k = 0; k < i; k++) blockA[count++] = lhs(i, k);  // normal
-
-      blockA[count++] = numext::real(lhs(i, i));  // real (diagonal)
-
-      for (Index k = i + 1; k < cols; k++) blockA[count++] = numext::conj(lhs(k, i));  // transposed
-    }
+    pack_rows(peeled_mc_quarter, rows, 1);
   }
 };
 
 template <typename Scalar, typename Index, int nr, int StorageOrder>
 struct symm_pack_rhs {
-  enum { PacketSize = packet_traits<Scalar>::size };
+  static constexpr int TransposedStorageOrder = StorageOrder == ColMajor ? RowMajor : ColMajor;
+  using Mapper = const_blas_data_mapper<Scalar, Index, StorageOrder>;
+  using TransposedMapper = const_blas_data_mapper<Scalar, Index, TransposedStorageOrder>;
+  using DirectPacker = gemm_pack_rhs<Scalar, Index, Mapper, nr, StorageOrder, false, false>;
+  using MirroredPacker = gemm_pack_rhs<Scalar, Index, TransposedMapper, nr, TransposedStorageOrder, true, false>;
+
+  // One nr-wide panel the diagonal crosses: a conjugated-mirror head above the
+  // diagonal, the Width x Width band packed per row, and a direct tail below.
+  template <int Width>
+  void pack_diagonal_panel(Scalar* blockB, const Mapper& rhs, const TransposedMapper& rhs_t, Index k2, Index end_k,
+                           Index j2, Index& count) const {
+    const Index band_end = j2 + Width;
+    if (j2 > k2) {
+      MirroredPacker()(blockB + count, rhs_t.getSubMapper(k2, j2), j2 - k2, Width);
+      count += Width * (j2 - k2);
+    }
+    for (Index k = j2; k < band_end; k++) {
+      Scalar* row = blockB + count;
+      const Index h = k - j2;
+      for (Index w = 0; w < h; w++) row[w] = rhs(k, j2 + w);
+      row[h] = numext::real(rhs(k, k));
+      for (Index w = h + 1; w < Width; w++) row[w] = numext::conj(rhs(j2 + w, k));
+      count += Width;
+    }
+    if (end_k > band_end) {
+      DirectPacker()(blockB + count, rhs.getSubMapper(band_end, j2), end_k - band_end, Width);
+      count += Width * (end_k - band_end);
+    }
+  }
+
   void operator()(Scalar* blockB, const Scalar* rhs_, Index rhsStride, Index rows, Index cols, Index k2) const {
-    Index end_k = k2 + rows;
+    const Index end_k = k2 + rows;
+    const Mapper rhs(rhs_, rhsStride);
+    const TransposedMapper rhs_t(rhs_, rhsStride);
     Index count = 0;
-    const_blas_data_mapper<Scalar, Index, StorageOrder> rhs(rhs_, rhsStride);
-    Index packet_cols8 = nr >= 8 ? (cols / 8) * 8 : 0;
-    Index packet_cols4 = nr >= 4 ? (cols / 4) * 4 : 0;
+    const Index packet_cols8 = nr >= 8 ? (cols / 8) * 8 : 0;
+    const Index packet_cols4 = nr >= 4 ? (cols / 4) * 4 : 0;
 
-    // first part: normal case
-    for (Index j2 = 0; j2 < k2; j2 += nr) {
-      for (Index k = k2; k < end_k; k++) {
-        blockB[count + 0] = rhs(k, j2 + 0);
-        blockB[count + 1] = rhs(k, j2 + 1);
-        if (nr >= 4) {
-          blockB[count + 2] = rhs(k, j2 + 2);
-          blockB[count + 3] = rhs(k, j2 + 3);
-        }
-        if (nr >= 8) {
-          blockB[count + 4] = rhs(k, j2 + 4);
-          blockB[count + 5] = rhs(k, j2 + 5);
-          blockB[count + 6] = rhs(k, j2 + 6);
-          blockB[count + 7] = rhs(k, j2 + 7);
-        }
-        count += nr;
-      }
+    // first part: whole panels left of the diagonal block, read directly.
+    // k2 is a multiple of the panel width (blocking rounds kc to a multiple
+    // of 8), so this region and the delegate lie on the same panel grid.
+    // The delegates re-derive that grid from the extent they are handed, so a
+    // k2 or end_k off the grid would silently pack a correctly sized buffer
+    // with the wrong panel shape.
+    eigen_internal_assert(k2 % nr == 0);
+    eigen_internal_assert(end_k % nr == 0 || end_k == cols);
+    if (k2 > 0) {
+      DirectPacker()(blockB, rhs.getSubMapper(k2, 0), rows, k2);
+      count += k2 * rows;
     }
 
-    // second part: diagonal block
-    Index end8 = nr >= 8 ? (std::min)(k2 + rows, packet_cols8) : k2;
-    if (nr >= 8) {
-      for (Index j2 = k2; j2 < end8; j2 += 8) {
-        // again we can split vertically in three different parts (transpose, symmetric, normal)
-        // transpose
-        for (Index k = k2; k < j2; k++) {
-          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
-          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
-          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
-          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
-          blockB[count + 4] = numext::conj(rhs(j2 + 4, k));
-          blockB[count + 5] = numext::conj(rhs(j2 + 5, k));
-          blockB[count + 6] = numext::conj(rhs(j2 + 6, k));
-          blockB[count + 7] = numext::conj(rhs(j2 + 7, k));
-          count += 8;
-        }
-        // symmetric
-        Index h = 0;
-        for (Index k = j2; k < j2 + 8; k++) {
-          // normal
-          for (Index w = 0; w < h; ++w) blockB[count + w] = rhs(k, j2 + w);
-
-          blockB[count + h] = numext::real(rhs(k, k));
-
-          // transpose
-          for (Index w = h + 1; w < 8; ++w) blockB[count + w] = numext::conj(rhs(j2 + w, k));
-          count += 8;
-          ++h;
-        }
-        // normal
-        for (Index k = j2 + 8; k < end_k; k++) {
-          blockB[count + 0] = rhs(k, j2 + 0);
-          blockB[count + 1] = rhs(k, j2 + 1);
-          blockB[count + 2] = rhs(k, j2 + 2);
-          blockB[count + 3] = rhs(k, j2 + 3);
-          blockB[count + 4] = rhs(k, j2 + 4);
-          blockB[count + 5] = rhs(k, j2 + 5);
-          blockB[count + 6] = rhs(k, j2 + 6);
-          blockB[count + 7] = rhs(k, j2 + 7);
-          count += 8;
-        }
-      }
+    // second part: the panels the diagonal block crosses
+    const Index end8 = nr >= 8 ? numext::mini(end_k, packet_cols8) : k2;
+    const Index end4 = numext::mini(end_k, packet_cols4);
+    EIGEN_IF_CONSTEXPR (nr >= 8) {
+      for (Index j2 = k2; j2 < end8; j2 += 8) pack_diagonal_panel<8>(blockB, rhs, rhs_t, k2, end_k, j2, count);
     }
-    if (nr >= 4) {
-      for (Index j2 = end8; j2 < (std::min)(k2 + rows, packet_cols4); j2 += 4) {
-        // again we can split vertically in three different parts (transpose, symmetric, normal)
-        // transpose
-        for (Index k = k2; k < j2; k++) {
-          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
-          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
-          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
-          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
-          count += 4;
-        }
-        // symmetric
-        Index h = 0;
-        for (Index k = j2; k < j2 + 4; k++) {
-          // normal
-          for (Index w = 0; w < h; ++w) blockB[count + w] = rhs(k, j2 + w);
-
-          blockB[count + h] = numext::real(rhs(k, k));
-
-          // transpose
-          for (Index w = h + 1; w < 4; ++w) blockB[count + w] = numext::conj(rhs(j2 + w, k));
-          count += 4;
-          ++h;
-        }
-        // normal
-        for (Index k = j2 + 4; k < end_k; k++) {
-          blockB[count + 0] = rhs(k, j2 + 0);
-          blockB[count + 1] = rhs(k, j2 + 1);
-          blockB[count + 2] = rhs(k, j2 + 2);
-          blockB[count + 3] = rhs(k, j2 + 3);
-          count += 4;
-        }
-      }
+    EIGEN_IF_CONSTEXPR (nr >= 4) {
+      for (Index j2 = end8; j2 < end4; j2 += 4) pack_diagonal_panel<4>(blockB, rhs, rhs_t, k2, end_k, j2, count);
     }
 
-    // third part: transposed
-    if (nr >= 8) {
-      for (Index j2 = k2 + rows; j2 < packet_cols8; j2 += 8) {
-        for (Index k = k2; k < end_k; k++) {
-          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
-          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
-          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
-          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
-          blockB[count + 4] = numext::conj(rhs(j2 + 4, k));
-          blockB[count + 5] = numext::conj(rhs(j2 + 5, k));
-          blockB[count + 6] = numext::conj(rhs(j2 + 6, k));
-          blockB[count + 7] = numext::conj(rhs(j2 + 7, k));
-          count += 8;
-        }
+    // third part: whole panels right of the diagonal block, read mirrored
+    EIGEN_IF_CONSTEXPR (nr >= 8) {
+      if (packet_cols8 > end_k) {
+        MirroredPacker()(blockB + count, rhs_t.getSubMapper(k2, end_k), rows, packet_cols8 - end_k);
+        count += rows * (packet_cols8 - end_k);
       }
     }
-    if (nr >= 4) {
-      for (Index j2 = (std::max)(packet_cols8, k2 + rows); j2 < packet_cols4; j2 += 4) {
-        for (Index k = k2; k < end_k; k++) {
-          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
-          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
-          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
-          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
-          count += 4;
-        }
+    EIGEN_IF_CONSTEXPR (nr >= 4) {
+      const Index j3 = numext::maxi(packet_cols8, end_k);
+      if (packet_cols4 > j3) {
+        MirroredPacker()(blockB + count, rhs_t.getSubMapper(k2, j3), rows, packet_cols4 - j3);
+        count += rows * (packet_cols4 - j3);
       }
     }
 
     // copy the remaining columns one at a time (=> the same with nr==1)
     for (Index j2 = packet_cols4; j2 < cols; ++j2) {
       // transpose
-      Index half = (std::min)(end_k, j2);
+      Index half = numext::mini(end_k, j2);
       for (Index k = k2; k < half; k++) {
         blockB[count] = numext::conj(rhs(j2, k));
         count += 1;
@@ -298,12 +242,12 @@
                                                           level3_blocking<Scalar, Scalar>& blocking) {
   Index size = rows;
 
-  typedef gebp_traits<Scalar, Scalar> Traits;
+  using Traits = gebp_traits<Scalar, Scalar>;
 
-  typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
-  typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMajor) ? ColMajor : RowMajor> LhsTransposeMapper;
-  typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
-  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+  using LhsMapper = const_blas_data_mapper<Scalar, Index, LhsStorageOrder>;
+  using LhsTransposeMapper = const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMajor) ? ColMajor : RowMajor>;
+  using RhsMapper = const_blas_data_mapper<Scalar, Index, RhsStorageOrder>;
+  using ResMapper = blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
   LhsMapper lhs(lhs_, lhsStride);
   LhsTransposeMapper lhs_transpose(lhs_, lhsStride);
   RhsMapper rhs(rhs_, rhsStride);
@@ -383,10 +327,10 @@
                                                           level3_blocking<Scalar, Scalar>& blocking) {
   Index size = cols;
 
-  typedef gebp_traits<Scalar, Scalar> Traits;
+  using Traits = gebp_traits<Scalar, Scalar>;
 
-  typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
-  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+  using LhsMapper = const_blas_data_mapper<Scalar, Index, LhsStorageOrder>;
+  using ResMapper = blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
   LhsMapper lhs(lhs_, lhsStride);
   ResMapper res(res_, resStride, resIncr);
 
@@ -428,12 +372,12 @@
 
 template <typename Lhs, int LhsMode, typename Rhs, int RhsMode>
 struct selfadjoint_product_impl<Lhs, LhsMode, false, Rhs, RhsMode, false> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
-  typedef internal::blas_traits<Lhs> LhsBlasTraits;
-  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-  typedef internal::blas_traits<Rhs> RhsBlasTraits;
-  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
+  using LhsBlasTraits = internal::blas_traits<Lhs>;
+  using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+  using RhsBlasTraits = internal::blas_traits<Rhs>;
+  using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
 
   enum {
     LhsIsUpper = (LhsMode & (Upper | Lower)) == Upper,
@@ -449,12 +393,15 @@
     add_const_on_value_type_t<ActualLhsType> lhs = LhsBlasTraits::extract(a_lhs);
     add_const_on_value_type_t<ActualRhsType> rhs = RhsBlasTraits::extract(a_rhs);
 
+    // Empty product, return early.  Otherwise, we get `nullptr` use errors below when we try to access
+    // coeffRef(0,0).
+    if (lhs.size() == 0 || rhs.size() == 0) return;
+
     Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs) * RhsBlasTraits::extractScalarFactor(a_rhs);
 
-    typedef internal::gemm_blocking_space<(Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, Scalar, Scalar,
-                                          Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime,
-                                          Lhs::MaxColsAtCompileTime, 1>
-        BlockingType;
+    using BlockingType = internal::gemm_blocking_space<(Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, Scalar,
+                                                       Scalar, Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime,
+                                                       Lhs::MaxColsAtCompileTime, 1>;
 
     BlockingType blocking(lhs.rows(), rhs.cols(), lhs.cols(), 1, false);
 
diff --git a/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h b/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
index 684a90f..5398b7d 100644
--- a/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
+++ b/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h
@@ -23,12 +23,13 @@
  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
+
  ********************************************************************************
  *   Content : Eigen bindings to BLAS F77
  *   Self adjoint matrix * matrix product functionality based on ?SYMM/?HEMM.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
 #define EIGEN_SELFADJOINT_MATRIX_MATRIX_BLAS_H
@@ -69,10 +70,12 @@
       ldc = convert_index<BlasIndex>(resStride);                                                                 \
                                                                                                                  \
       /* Set a, b, c */                                                                                          \
-      if (LhsStorageOrder == RowMajor) uplo = 'U';                                                               \
+      EIGEN_IF_CONSTEXPR (LhsStorageOrder == RowMajor) {                                                         \
+        uplo = 'U';                                                                                              \
+      }                                                                                                          \
       a = _lhs;                                                                                                  \
                                                                                                                  \
-      if (RhsStorageOrder == RowMajor) {                                                                         \
+      EIGEN_IF_CONSTEXPR (RhsStorageOrder == RowMajor) {                                                         \
         Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, n, m, OuterStride<>(rhsStride));              \
         b_tmp = rhs.adjoint();                                                                                   \
         b = b_tmp.data();                                                                                        \
@@ -85,64 +88,67 @@
     }                                                                                                            \
   };
 
-#define EIGEN_BLAS_HEMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC)                                                  \
-  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs>        \
-  struct product_selfadjoint_matrix<EIGTYPE, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false,   \
-                                    ConjugateRhs, ColMajor, 1> {                                                   \
-    static void run(Index rows, Index cols, const EIGTYPE* _lhs, Index lhsStride, const EIGTYPE* _rhs,             \
-                    Index rhsStride, EIGTYPE* res, Index resIncr, Index resStride, EIGTYPE alpha,                  \
-                    level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {                                             \
-      if (rows == 0 || cols == 0) return;                                                                          \
-      EIGEN_ONLY_USED_FOR_DEBUG(resIncr);                                                                          \
-      eigen_assert(resIncr == 1);                                                                                  \
-      char side = 'L', uplo = 'L';                                                                                 \
-      BlasIndex m, n, lda, ldb, ldc;                                                                               \
-      const EIGTYPE *a, *b;                                                                                        \
-      EIGTYPE beta(1);                                                                                             \
-      MatrixX##EIGPREFIX b_tmp;                                                                                    \
-      Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> a_tmp;                                                    \
-                                                                                                                   \
-      /* Set transpose options */                                                                                  \
-      /* Set m, n, k */                                                                                            \
-      m = convert_index<BlasIndex>(rows);                                                                          \
-      n = convert_index<BlasIndex>(cols);                                                                          \
-                                                                                                                   \
-      /* Set lda, ldb, ldc */                                                                                      \
-      lda = convert_index<BlasIndex>(lhsStride);                                                                   \
-      ldb = convert_index<BlasIndex>(rhsStride);                                                                   \
-      ldc = convert_index<BlasIndex>(resStride);                                                                   \
-                                                                                                                   \
-      /* Set a, b, c */                                                                                            \
-      if (((LhsStorageOrder == ColMajor) && ConjugateLhs) || ((LhsStorageOrder == RowMajor) && (!ConjugateLhs))) { \
-        Map<const Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder>, 0, OuterStride<> > lhs(                      \
-            _lhs, m, m, OuterStride<>(lhsStride));                                                                 \
-        a_tmp = lhs.conjugate();                                                                                   \
-        a = a_tmp.data();                                                                                          \
-        lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                       \
-      } else                                                                                                       \
-        a = _lhs;                                                                                                  \
-      if (LhsStorageOrder == RowMajor) uplo = 'U';                                                                 \
-                                                                                                                   \
-      if (RhsStorageOrder == ColMajor && (!ConjugateRhs)) {                                                        \
-        b = _rhs;                                                                                                  \
-      } else {                                                                                                     \
-        if (RhsStorageOrder == ColMajor && ConjugateRhs) {                                                         \
-          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, m, n, OuterStride<>(rhsStride));              \
-          b_tmp = rhs.conjugate();                                                                                 \
-        } else if (ConjugateRhs) {                                                                                 \
-          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, n, m, OuterStride<>(rhsStride));              \
-          b_tmp = rhs.adjoint();                                                                                   \
-        } else {                                                                                                   \
-          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, n, m, OuterStride<>(rhsStride));              \
-          b_tmp = rhs.transpose();                                                                                 \
-        }                                                                                                          \
-        b = b_tmp.data();                                                                                          \
-        ldb = convert_index<BlasIndex>(b_tmp.outerStride());                                                       \
-      }                                                                                                            \
-                                                                                                                   \
-      BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda,          \
-               (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc);          \
-    }                                                                                                              \
+#define EIGEN_BLAS_HEMM_L(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC)                                                \
+  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs>      \
+  struct product_selfadjoint_matrix<EIGTYPE, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, \
+                                    ConjugateRhs, ColMajor, 1> {                                                 \
+    static void run(Index rows, Index cols, const EIGTYPE* _lhs, Index lhsStride, const EIGTYPE* _rhs,           \
+                    Index rhsStride, EIGTYPE* res, Index resIncr, Index resStride, EIGTYPE alpha,                \
+                    level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {                                           \
+      if (rows == 0 || cols == 0) return;                                                                        \
+      EIGEN_ONLY_USED_FOR_DEBUG(resIncr);                                                                        \
+      eigen_assert(resIncr == 1);                                                                                \
+      char side = 'L', uplo = 'L';                                                                               \
+      BlasIndex m, n, lda, ldb, ldc;                                                                             \
+      const EIGTYPE *a, *b;                                                                                      \
+      EIGTYPE beta(1);                                                                                           \
+      MatrixX##EIGPREFIX b_tmp;                                                                                  \
+      Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder> a_tmp;                                                  \
+                                                                                                                 \
+      /* Set transpose options */                                                                                \
+      /* Set m, n, k */                                                                                          \
+      m = convert_index<BlasIndex>(rows);                                                                        \
+      n = convert_index<BlasIndex>(cols);                                                                        \
+                                                                                                                 \
+      /* Set lda, ldb, ldc */                                                                                    \
+      lda = convert_index<BlasIndex>(lhsStride);                                                                 \
+      ldb = convert_index<BlasIndex>(rhsStride);                                                                 \
+      ldc = convert_index<BlasIndex>(resStride);                                                                 \
+                                                                                                                 \
+      /* Set a, b, c */                                                                                          \
+      EIGEN_IF_CONSTEXPR (((LhsStorageOrder == ColMajor) && ConjugateLhs) ||                                     \
+                          ((LhsStorageOrder == RowMajor) && (!ConjugateLhs))) {                                  \
+        Map<const Matrix<EIGTYPE, Dynamic, Dynamic, LhsStorageOrder>, 0, OuterStride<> > lhs(                    \
+            _lhs, m, m, OuterStride<>(lhsStride));                                                               \
+        a_tmp = lhs.conjugate();                                                                                 \
+        a = a_tmp.data();                                                                                        \
+        lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                     \
+      } else                                                                                                     \
+        a = _lhs;                                                                                                \
+      EIGEN_IF_CONSTEXPR (LhsStorageOrder == RowMajor) {                                                         \
+        uplo = 'U';                                                                                              \
+      }                                                                                                          \
+                                                                                                                 \
+      EIGEN_IF_CONSTEXPR (RhsStorageOrder == ColMajor && (!ConjugateRhs)) {                                      \
+        b = _rhs;                                                                                                \
+      } else {                                                                                                   \
+        EIGEN_IF_CONSTEXPR (RhsStorageOrder == ColMajor && ConjugateRhs) {                                       \
+          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, m, n, OuterStride<>(rhsStride));            \
+          b_tmp = rhs.conjugate();                                                                               \
+        } else EIGEN_IF_CONSTEXPR (ConjugateRhs) {                                                               \
+          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, n, m, OuterStride<>(rhsStride));            \
+          b_tmp = rhs.adjoint();                                                                                 \
+        } else {                                                                                                 \
+          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > rhs(_rhs, n, m, OuterStride<>(rhsStride));            \
+          b_tmp = rhs.transpose();                                                                               \
+        }                                                                                                        \
+        b = b_tmp.data();                                                                                        \
+        ldb = convert_index<BlasIndex>(b_tmp.outerStride());                                                     \
+      }                                                                                                          \
+                                                                                                                 \
+      BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda,        \
+               (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc);        \
+    }                                                                                                            \
   };
 
 #ifdef EIGEN_USE_MKL
@@ -151,10 +157,10 @@
 EIGEN_BLAS_HEMM_L(dcomplex, MKL_Complex16, cd, zhemm)
 EIGEN_BLAS_HEMM_L(scomplex, MKL_Complex8, cf, chemm)
 #else
-EIGEN_BLAS_SYMM_L(double, double, d, dsymm_)
-EIGEN_BLAS_SYMM_L(float, float, f, ssymm_)
-EIGEN_BLAS_HEMM_L(dcomplex, double, cd, zhemm_)
-EIGEN_BLAS_HEMM_L(scomplex, float, cf, chemm_)
+EIGEN_BLAS_SYMM_L(double, double, d, EIGEN_BLAS_SYM(dsymm))
+EIGEN_BLAS_SYMM_L(float, float, f, EIGEN_BLAS_SYM(ssymm))
+EIGEN_BLAS_HEMM_L(dcomplex, double, cd, EIGEN_BLAS_SYM(zhemm))
+EIGEN_BLAS_HEMM_L(scomplex, float, cf, EIGEN_BLAS_SYM(chemm))
 #endif
 
 /* Optimized matrix * selfadjoint matrix (?SYMM/?HEMM) product */
@@ -185,10 +191,12 @@
       ldc = convert_index<BlasIndex>(resStride);                                                                 \
                                                                                                                  \
       /* Set a, b, c */                                                                                          \
-      if (RhsStorageOrder == RowMajor) uplo = 'U';                                                               \
+      EIGEN_IF_CONSTEXPR (RhsStorageOrder == RowMajor) {                                                         \
+        uplo = 'U';                                                                                              \
+      }                                                                                                          \
       a = _rhs;                                                                                                  \
                                                                                                                  \
-      if (LhsStorageOrder == RowMajor) {                                                                         \
+      EIGEN_IF_CONSTEXPR (LhsStorageOrder == RowMajor) {                                                         \
         Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, n, m, OuterStride<>(rhsStride));              \
         b_tmp = lhs.adjoint();                                                                                   \
         b = b_tmp.data();                                                                                        \
@@ -201,62 +209,65 @@
     }                                                                                                            \
   };
 
-#define EIGEN_BLAS_HEMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC)                                                  \
-  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs>        \
-  struct product_selfadjoint_matrix<EIGTYPE, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true,   \
-                                    ConjugateRhs, ColMajor, 1> {                                                   \
-    static void run(Index rows, Index cols, const EIGTYPE* _lhs, Index lhsStride, const EIGTYPE* _rhs,             \
-                    Index rhsStride, EIGTYPE* res, Index resIncr, Index resStride, EIGTYPE alpha,                  \
-                    level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {                                             \
-      EIGEN_ONLY_USED_FOR_DEBUG(resIncr);                                                                          \
-      eigen_assert(resIncr == 1);                                                                                  \
-      char side = 'R', uplo = 'L';                                                                                 \
-      BlasIndex m, n, lda, ldb, ldc;                                                                               \
-      const EIGTYPE *a, *b;                                                                                        \
-      EIGTYPE beta(1);                                                                                             \
-      MatrixX##EIGPREFIX b_tmp;                                                                                    \
-      Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> a_tmp;                                                    \
-                                                                                                                   \
-      /* Set m, n, k */                                                                                            \
-      m = convert_index<BlasIndex>(rows);                                                                          \
-      n = convert_index<BlasIndex>(cols);                                                                          \
-                                                                                                                   \
-      /* Set lda, ldb, ldc */                                                                                      \
-      lda = convert_index<BlasIndex>(rhsStride);                                                                   \
-      ldb = convert_index<BlasIndex>(lhsStride);                                                                   \
-      ldc = convert_index<BlasIndex>(resStride);                                                                   \
-                                                                                                                   \
-      /* Set a, b, c */                                                                                            \
-      if (((RhsStorageOrder == ColMajor) && ConjugateRhs) || ((RhsStorageOrder == RowMajor) && (!ConjugateRhs))) { \
-        Map<const Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder>, 0, OuterStride<> > rhs(                      \
-            _rhs, n, n, OuterStride<>(rhsStride));                                                                 \
-        a_tmp = rhs.conjugate();                                                                                   \
-        a = a_tmp.data();                                                                                          \
-        lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                       \
-      } else                                                                                                       \
-        a = _rhs;                                                                                                  \
-      if (RhsStorageOrder == RowMajor) uplo = 'U';                                                                 \
-                                                                                                                   \
-      if (LhsStorageOrder == ColMajor && (!ConjugateLhs)) {                                                        \
-        b = _lhs;                                                                                                  \
-      } else {                                                                                                     \
-        if (LhsStorageOrder == ColMajor && ConjugateLhs) {                                                         \
-          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, m, n, OuterStride<>(lhsStride));              \
-          b_tmp = lhs.conjugate();                                                                                 \
-        } else if (ConjugateLhs) {                                                                                 \
-          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, n, m, OuterStride<>(lhsStride));              \
-          b_tmp = lhs.adjoint();                                                                                   \
-        } else {                                                                                                   \
-          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, n, m, OuterStride<>(lhsStride));              \
-          b_tmp = lhs.transpose();                                                                                 \
-        }                                                                                                          \
-        b = b_tmp.data();                                                                                          \
-        ldb = convert_index<BlasIndex>(b_tmp.outerStride());                                                       \
-      }                                                                                                            \
-                                                                                                                   \
-      BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda,          \
-               (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc);          \
-    }                                                                                                              \
+#define EIGEN_BLAS_HEMM_R(EIGTYPE, BLASTYPE, EIGPREFIX, BLASFUNC)                                                \
+  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs>      \
+  struct product_selfadjoint_matrix<EIGTYPE, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, \
+                                    ConjugateRhs, ColMajor, 1> {                                                 \
+    static void run(Index rows, Index cols, const EIGTYPE* _lhs, Index lhsStride, const EIGTYPE* _rhs,           \
+                    Index rhsStride, EIGTYPE* res, Index resIncr, Index resStride, EIGTYPE alpha,                \
+                    level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {                                           \
+      EIGEN_ONLY_USED_FOR_DEBUG(resIncr);                                                                        \
+      eigen_assert(resIncr == 1);                                                                                \
+      char side = 'R', uplo = 'L';                                                                               \
+      BlasIndex m, n, lda, ldb, ldc;                                                                             \
+      const EIGTYPE *a, *b;                                                                                      \
+      EIGTYPE beta(1);                                                                                           \
+      MatrixX##EIGPREFIX b_tmp;                                                                                  \
+      Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> a_tmp;                                                  \
+                                                                                                                 \
+      /* Set m, n, k */                                                                                          \
+      m = convert_index<BlasIndex>(rows);                                                                        \
+      n = convert_index<BlasIndex>(cols);                                                                        \
+                                                                                                                 \
+      /* Set lda, ldb, ldc */                                                                                    \
+      lda = convert_index<BlasIndex>(rhsStride);                                                                 \
+      ldb = convert_index<BlasIndex>(lhsStride);                                                                 \
+      ldc = convert_index<BlasIndex>(resStride);                                                                 \
+                                                                                                                 \
+      /* Set a, b, c */                                                                                          \
+      EIGEN_IF_CONSTEXPR (((RhsStorageOrder == ColMajor) && ConjugateRhs) ||                                     \
+                          ((RhsStorageOrder == RowMajor) && (!ConjugateRhs))) {                                  \
+        Map<const Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder>, 0, OuterStride<> > rhs(                    \
+            _rhs, n, n, OuterStride<>(rhsStride));                                                               \
+        a_tmp = rhs.conjugate();                                                                                 \
+        a = a_tmp.data();                                                                                        \
+        lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                     \
+      } else                                                                                                     \
+        a = _rhs;                                                                                                \
+      EIGEN_IF_CONSTEXPR (RhsStorageOrder == RowMajor) {                                                         \
+        uplo = 'U';                                                                                              \
+      }                                                                                                          \
+                                                                                                                 \
+      EIGEN_IF_CONSTEXPR (LhsStorageOrder == ColMajor && (!ConjugateLhs)) {                                      \
+        b = _lhs;                                                                                                \
+      } else {                                                                                                   \
+        EIGEN_IF_CONSTEXPR (LhsStorageOrder == ColMajor && ConjugateLhs) {                                       \
+          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, m, n, OuterStride<>(lhsStride));            \
+          b_tmp = lhs.conjugate();                                                                               \
+        } else EIGEN_IF_CONSTEXPR (ConjugateLhs) {                                                               \
+          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, n, m, OuterStride<>(lhsStride));            \
+          b_tmp = lhs.adjoint();                                                                                 \
+        } else {                                                                                                 \
+          Map<const MatrixX##EIGPREFIX, 0, OuterStride<> > lhs(_lhs, n, m, OuterStride<>(lhsStride));            \
+          b_tmp = lhs.transpose();                                                                               \
+        }                                                                                                        \
+        b = b_tmp.data();                                                                                        \
+        ldb = convert_index<BlasIndex>(b_tmp.outerStride());                                                     \
+      }                                                                                                          \
+                                                                                                                 \
+      BLASFUNC(&side, &uplo, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda,        \
+               (const BLASTYPE*)b, &ldb, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &ldc);        \
+    }                                                                                                            \
   };
 
 #ifdef EIGEN_USE_MKL
@@ -265,14 +276,15 @@
 EIGEN_BLAS_HEMM_R(dcomplex, MKL_Complex16, cd, zhemm)
 EIGEN_BLAS_HEMM_R(scomplex, MKL_Complex8, cf, chemm)
 #else
-EIGEN_BLAS_SYMM_R(double, double, d, dsymm_)
-EIGEN_BLAS_SYMM_R(float, float, f, ssymm_)
-EIGEN_BLAS_HEMM_R(dcomplex, double, cd, zhemm_)
-EIGEN_BLAS_HEMM_R(scomplex, float, cf, chemm_)
+EIGEN_BLAS_SYMM_R(double, double, d, EIGEN_BLAS_SYM(dsymm))
+EIGEN_BLAS_SYMM_R(float, float, f, EIGEN_BLAS_SYM(ssymm))
+EIGEN_BLAS_HEMM_R(dcomplex, double, cd, EIGEN_BLAS_SYM(zhemm))
+EIGEN_BLAS_HEMM_R(scomplex, float, cf, EIGEN_BLAS_SYM(chemm))
 #endif
 
 #undef EIGEN_BLAS_SYMM_L
 #undef EIGEN_BLAS_SYMM_R
+#undef EIGEN_BLAS_HEMM_L
 #undef EIGEN_BLAS_HEMM_R
 }  // end namespace internal
 
diff --git a/Eigen/src/Core/products/SelfadjointMatrixVector.h b/Eigen/src/Core/products/SelfadjointMatrixVector.h
index f87509b..85a08d0 100644
--- a/Eigen/src/Core/products/SelfadjointMatrixVector.h
+++ b/Eigen/src/Core/products/SelfadjointMatrixVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_H
 #define EIGEN_SELFADJOINT_MATRIX_VECTOR_H
@@ -43,8 +44,8 @@
 EIGEN_DONT_INLINE EIGEN_DEVICE_FUNC void
 selfadjoint_matrix_vector_product<Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs, Version>::run(
     Index size, const Scalar* lhs, Index lhsStride, const Scalar* rhs, Scalar* res, Scalar alpha) {
-  typedef typename packet_traits<Scalar>::type Packet;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using Packet = typename packet_traits<Scalar>::type;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   const Index PacketSize = sizeof(Packet) / sizeof(Scalar);
 
   enum {
@@ -110,7 +111,7 @@
       res[j + 3] += cjd.pmul(numext::real(A3[j + 3]), t3);
 
       // Handle the 4x4 diagonal block: off-diagonal cross terms
-      if (FirstTriangular) {
+      EIGEN_IF_CONSTEXPR (FirstTriangular) {
         // Upper triangle stored (A_k[l] for l <= k)
         res[j] += cj0.pmul(A1[j], t1) + cj0.pmul(A2[j], t2) + cj0.pmul(A3[j], t3);
         res[j + 1] += cj0.pmul(A2[j + 1], t2) + cj0.pmul(A3[j + 1], t3);
@@ -214,7 +215,7 @@
 
       res[j] += cjd.pmul(numext::real(A0[j]), t0);
       res[j + 1] += cjd.pmul(numext::real(A1[j + 1]), t1);
-      if (FirstTriangular) {
+      EIGEN_IF_CONSTEXPR (FirstTriangular) {
         res[j] += cj0.pmul(A1[j], t1);
         t3 += cj1.pmul(A1[j], rhs[j]);
       } else {
@@ -316,15 +317,15 @@
 
 template <typename Lhs, int LhsMode, typename Rhs>
 struct selfadjoint_product_impl<Lhs, LhsMode, false, Rhs, 0, true> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
-  typedef internal::blas_traits<Lhs> LhsBlasTraits;
-  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-  typedef internal::remove_all_t<ActualLhsType> ActualLhsTypeCleaned;
+  using LhsBlasTraits = internal::blas_traits<Lhs>;
+  using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+  using ActualLhsTypeCleaned = internal::remove_all_t<ActualLhsType>;
 
-  typedef internal::blas_traits<Rhs> RhsBlasTraits;
-  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-  typedef internal::remove_all_t<ActualRhsType> ActualRhsTypeCleaned;
+  using RhsBlasTraits = internal::blas_traits<Rhs>;
+  using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
+  using ActualRhsTypeCleaned = internal::remove_all_t<ActualRhsType>;
 
   enum { LhsUpLo = LhsMode & (Upper | Lower) };
 
@@ -335,17 +336,19 @@
 
   template <typename Dest>
   static EIGEN_DEVICE_FUNC void run(Dest& dest, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha) {
-    typedef typename Dest::Scalar ResScalar;
-    typedef typename Rhs::Scalar RhsScalar;
-    typedef Map<Matrix<ResScalar, Dynamic, 1>, plain_enum_min(AlignedMax, internal::packet_traits<ResScalar>::size)>
-        MappedDest;
+    using ResScalar = typename Dest::Scalar;
+    using RhsScalar = typename Rhs::Scalar;
 
     eigen_assert(dest.rows() == a_lhs.rows() && dest.cols() == a_rhs.cols());
 
     add_const_on_value_type_t<ActualLhsType> lhs = LhsBlasTraits::extract(a_lhs);
     add_const_on_value_type_t<ActualRhsType> rhs = RhsBlasTraits::extract(a_rhs);
 
-    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs) * RhsBlasTraits::extractScalarFactor(a_rhs);
+    // Empty product, return early.  Otherwise, we get `nullptr` use errors below when we try to access
+    // coeffRef(0,0).
+    if (lhs.size() == 0) return;
+
+    Scalar actualAlpha = combine_scalar_factors(alpha, a_lhs, a_rhs);
 
     enum {
       EvalToDest = (Dest::InnerStrideAtCompileTime == 1),
@@ -364,23 +367,8 @@
     ei_declare_aligned_stack_constructed_variable(RhsScalar, actualRhsPtr, rhs.size(),
                                                   UseRhs ? const_cast<RhsScalar*>(rhs.data()) : static_rhs.data());
 
-    if (!EvalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-      constexpr int Size = Dest::SizeAtCompileTime;
-      Index size = dest.size();
-      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
-      MappedDest(actualDestPtr, dest.size()) = dest;
-    }
-
-    if (!UseRhs) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-      constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
-      Index size = rhs.size();
-      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
-      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, rhs.size()) = rhs;
-    }
+    internal::gemv_prepare_destination<EvalToDest>(dest, actualDestPtr);
+    internal::gemv_prepare_rhs<UseRhs>(rhs, actualRhsPtr);
 
     internal::selfadjoint_matrix_vector_product<
         Scalar, Index, (internal::traits<ActualLhsTypeCleaned>::Flags & RowMajorBit) ? RowMajor : ColMajor,
@@ -392,13 +380,13 @@
                                                    actualAlpha                              // scale factor
     );
 
-    if (!EvalToDest) dest = MappedDest(actualDestPtr, dest.size());
+    internal::gemv_copy_destination<EvalToDest>(dest, actualDestPtr);
   }
 };
 
 template <typename Lhs, typename Rhs, int RhsMode>
 struct selfadjoint_product_impl<Lhs, 0, true, Rhs, RhsMode, false> {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
   enum { RhsUpLo = RhsMode & (Upper | Lower) };
 
   template <typename Dest>
diff --git a/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h b/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
index 413d949..71f1dbb 100644
--- a/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
+++ b/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
@@ -26,9 +26,10 @@
 
  ********************************************************************************
  *   Content : Eigen bindings to BLAS F77
- *   Selfadjoint matrix-vector product functionality based on ?SYMV/HEMV.
+ *   Selfadjoint matrix-vector product functionality based on ?SYMV/?HEMV.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
 #define EIGEN_SELFADJOINT_MATRIX_VECTOR_BLAS_H
@@ -56,7 +57,7 @@
                                            Specialized> {                                                            \
     static void run(Index size, const Scalar* lhs, Index lhsStride, const Scalar* _rhs, Scalar* res, Scalar alpha) { \
       enum { IsColMajor = StorageOrder == ColMajor };                                                                \
-      if (IsColMajor == ConjugateLhs) {                                                                              \
+      EIGEN_IF_CONSTEXPR (IsColMajor == ConjugateLhs) {                                                              \
         selfadjoint_matrix_vector_product<Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs,             \
                                           BuiltIn>::run(size, lhs, lhsStride, _rhs, res, alpha);                     \
       } else {                                                                                                       \
@@ -85,7 +86,7 @@
       const EIGTYPE* x_ptr;                                                                                        \
       char uplo = (IsRowMajor) ? (IsLower ? 'U' : 'L') : (IsLower ? 'L' : 'U');                                    \
       SYMVVector x_tmp;                                                                                            \
-      if (ConjugateRhs) {                                                                                          \
+      EIGEN_IF_CONSTEXPR (ConjugateRhs) {                                                                          \
         Map<const SYMVVector, 0> map_x(_rhs, size, 1);                                                             \
         x_tmp = map_x.conjugate();                                                                                 \
         x_ptr = x_tmp.data();                                                                                      \
@@ -102,10 +103,10 @@
 EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, MKL_Complex16, zhemv)
 EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, MKL_Complex8, chemv)
 #else
-EIGEN_BLAS_SYMV_SPECIALIZATION(double, double, dsymv_)
-EIGEN_BLAS_SYMV_SPECIALIZATION(float, float, ssymv_)
-EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, double, zhemv_)
-EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, float, chemv_)
+EIGEN_BLAS_SYMV_SPECIALIZATION(double, double, EIGEN_BLAS_SYM(dsymv))
+EIGEN_BLAS_SYMV_SPECIALIZATION(float, float, EIGEN_BLAS_SYM(ssymv))
+EIGEN_BLAS_SYMV_SPECIALIZATION(dcomplex, double, EIGEN_BLAS_SYM(zhemv))
+EIGEN_BLAS_SYMV_SPECIALIZATION(scomplex, float, EIGEN_BLAS_SYM(chemv))
 #endif
 
 #undef EIGEN_BLAS_SYMV_SPECIALIZATION
diff --git a/Eigen/src/Core/products/SelfadjointProduct.h b/Eigen/src/Core/products/SelfadjointProduct.h
index 4a453b1..ce0070e 100644
--- a/Eigen/src/Core/products/SelfadjointProduct.h
+++ b/Eigen/src/Core/products/SelfadjointProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFADJOINT_PRODUCT_H
 #define EIGEN_SELFADJOINT_PRODUCT_H
@@ -24,7 +25,7 @@
 template <typename Scalar, typename Index, int UpLo, bool ConjLhs, bool ConjRhs>
 struct selfadjoint_rank1_update<Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs> {
   static void run(Index size, Scalar* mat, Index stride, const Scalar* vecX, const Scalar* vecY, const Scalar& alpha) {
-    typedef typename internal::packet_traits<Scalar>::type Packet;
+    using Packet = typename internal::packet_traits<Scalar>::type;
     const Index PacketSize = internal::unpacket_traits<Packet>::size;
 
     internal::conj_if<ConjRhs> cjy;
@@ -39,7 +40,7 @@
       Packet ps0 = internal::pset1<Packet>(s0);
       Packet ps1 = internal::pset1<Packet>(s1);
 
-      if (UpLo == Lower) {
+      EIGEN_IF_CONSTEXPR (UpLo == Lower) {
         Scalar* EIGEN_RESTRICT col0 = mat + stride * j + j;
         Scalar* EIGEN_RESTRICT col1 = mat + stride * (j + 1) + (j + 1);
 
@@ -140,10 +141,10 @@
 template <typename MatrixType, typename OtherType, int UpLo>
 struct selfadjoint_product_selector<MatrixType, OtherType, UpLo, true> {
   static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha) {
-    typedef typename MatrixType::Scalar Scalar;
-    typedef internal::blas_traits<OtherType> OtherBlasTraits;
-    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
-    typedef internal::remove_all_t<ActualOtherType> ActualOtherType_;
+    using Scalar = typename MatrixType::Scalar;
+    using OtherBlasTraits = internal::blas_traits<OtherType>;
+    using ActualOtherType = typename OtherBlasTraits::DirectLinearAccessType;
+    using ActualOtherType_ = internal::remove_all_t<ActualOtherType>;
     internal::add_const_on_value_type_t<ActualOtherType> actualOther = OtherBlasTraits::extract(other.derived());
 
     Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
@@ -160,8 +161,9 @@
         Scalar, actualOtherPtr, other.size(),
         (UseOtherDirectly ? const_cast<Scalar*>(actualOther.data()) : static_other.data()));
 
-    if (!UseOtherDirectly)
+    EIGEN_IF_CONSTEXPR (!UseOtherDirectly) {
       Map<typename ActualOtherType_::PlainObject>(actualOtherPtr, actualOther.size()) = actualOther;
+    }
 
     selfadjoint_rank1_update<
         Scalar, Index, StorageOrder, UpLo, OtherBlasTraits::NeedToConjugate && NumTraits<Scalar>::IsComplex,
@@ -174,10 +176,10 @@
 template <typename MatrixType, typename OtherType, int UpLo>
 struct selfadjoint_product_selector<MatrixType, OtherType, UpLo, false> {
   static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha) {
-    typedef typename MatrixType::Scalar Scalar;
-    typedef internal::blas_traits<OtherType> OtherBlasTraits;
-    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
-    typedef internal::remove_all_t<ActualOtherType> ActualOtherType_;
+    using Scalar = typename MatrixType::Scalar;
+    using OtherBlasTraits = internal::blas_traits<OtherType>;
+    using ActualOtherType = typename OtherBlasTraits::DirectLinearAccessType;
+    using ActualOtherType_ = internal::remove_all_t<ActualOtherType>;
     internal::add_const_on_value_type_t<ActualOtherType> actualOther = OtherBlasTraits::extract(other.derived());
 
     Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());
@@ -189,11 +191,13 @@
 
     Index size = mat.cols();
     Index depth = actualOther.cols();
+    eigen_assert(actualOther.rows() == size);
+    if (size == 0 || depth == 0) return;
 
-    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor, Scalar, Scalar,
-                                          MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime,
-                                          ActualOtherType_::MaxColsAtCompileTime>
-        BlockingType;
+    using BlockingType =
+        internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor, Scalar, Scalar,
+                                      MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime,
+                                      ActualOtherType_::MaxColsAtCompileTime>;
 
     BlockingType blocking(size, size, depth, 1, false);
 
@@ -213,7 +217,7 @@
 template <typename DerivedU>
 EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType, UpLo>& SelfAdjointView<MatrixType, UpLo>::rankUpdate(
     const MatrixBase<DerivedU>& u, const Scalar& alpha) {
-  selfadjoint_product_selector<MatrixType, DerivedU, UpLo>::run(_expression().const_cast_derived(), u.derived(), alpha);
+  selfadjoint_product_selector<MatrixType, DerivedU, UpLo>::run(nestedExpression(), u.derived(), alpha);
 
   return *this;
 }
diff --git a/Eigen/src/Core/products/SelfadjointRank2Update.h b/Eigen/src/Core/products/SelfadjointRank2Update.h
index 75e4ceb..6d9b217 100644
--- a/Eigen/src/Core/products/SelfadjointRank2Update.h
+++ b/Eigen/src/Core/products/SelfadjointRank2Update.h
@@ -6,9 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_SELFADJOINTRANK2UPTADE_H
-#define EIGEN_SELFADJOINTRANK2UPTADE_H
+#ifndef EIGEN_SELFADJOINTRANK2UPDATE_H
+#define EIGEN_SELFADJOINTRANK2UPDATE_H
 
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
@@ -26,8 +27,9 @@
 
 template <typename Scalar, typename Index>
 struct selfadjoint_rank2_update_selector<Scalar, Index, Lower> {
-  static void run(Index size, Scalar* mat, Index stride, const Scalar* u, const Scalar* v, const Scalar& alpha) {
-    typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC static void run(Index size, Scalar* mat, Index stride, const Scalar* u, const Scalar* v,
+                                    const Scalar& alpha) {
+    using Packet = typename packet_traits<Scalar>::type;
     const Index PacketSize = unpacket_traits<Packet>::size;
     const Scalar cAlpha = numext::conj(alpha);
 
@@ -111,8 +113,9 @@
 
 template <typename Scalar, typename Index>
 struct selfadjoint_rank2_update_selector<Scalar, Index, Upper> {
-  static void run(Index size, Scalar* mat, Index stride, const Scalar* u, const Scalar* v, const Scalar& alpha) {
-    typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC static void run(Index size, Scalar* mat, Index stride, const Scalar* u, const Scalar* v,
+                                    const Scalar& alpha) {
+    using Packet = typename packet_traits<Scalar>::type;
     const Index PacketSize = unpacket_traits<Packet>::size;
     const Scalar cAlpha = numext::conj(alpha);
 
@@ -186,24 +189,20 @@
   }
 };
 
-template <bool Cond, typename T>
-using conj_expr_if =
-    std::conditional<!Cond, const T&, CwiseUnaryOp<scalar_conjugate_op<typename traits<T>::Scalar>, T>>;
-
 }  // end namespace internal
 
 template <typename MatrixType, unsigned int UpLo>
 template <typename DerivedU, typename DerivedV>
 EIGEN_DEVICE_FUNC SelfAdjointView<MatrixType, UpLo>& SelfAdjointView<MatrixType, UpLo>::rankUpdate(
     const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, const Scalar& alpha) {
-  typedef internal::blas_traits<DerivedU> UBlasTraits;
-  typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
-  typedef internal::remove_all_t<ActualUType> ActualUType_;
+  using UBlasTraits = internal::blas_traits<DerivedU>;
+  using ActualUType = typename UBlasTraits::DirectLinearAccessType;
+  using ActualUType_ = internal::remove_all_t<ActualUType>;
   internal::add_const_on_value_type_t<ActualUType> actualU = UBlasTraits::extract(u.derived());
 
-  typedef internal::blas_traits<DerivedV> VBlasTraits;
-  typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
-  typedef internal::remove_all_t<ActualVType> ActualVType_;
+  using VBlasTraits = internal::blas_traits<DerivedV>;
+  using ActualVType = typename VBlasTraits::DirectLinearAccessType;
+  using ActualVType_ = internal::remove_all_t<ActualVType>;
   internal::add_const_on_value_type_t<ActualVType> actualV = VBlasTraits::extract(v.derived());
 
   // If MatrixType is row major, then we use the routine for lower triangular in the upper triangular case and
@@ -219,7 +218,9 @@
 
   Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()) *
                        numext::conj(VBlasTraits::extractScalarFactor(v.derived()));
-  if (IsRowMajor) actualAlpha = numext::conj(actualAlpha);
+  EIGEN_IF_CONSTEXPR (IsRowMajor) {
+    actualAlpha = numext::conj(actualAlpha);
+  }
 
   const Index size = u.size();
 
@@ -228,11 +229,12 @@
       static_u;
   ei_declare_aligned_stack_constructed_variable(Scalar, uPtr, size,
                                                 (UseUDirectly ? const_cast<Scalar*>(actualU.data()) : static_u.data()));
-  if (!UseUDirectly) {
-    if (NeedConjU)
+  EIGEN_IF_CONSTEXPR (!UseUDirectly) {
+    EIGEN_IF_CONSTEXPR (NeedConjU) {
       Map<typename ActualUType_::PlainObject>(uPtr, size) = actualU.conjugate();
-    else
+    } else {
       Map<typename ActualUType_::PlainObject>(uPtr, size) = actualU;
+    }
   }
 
   // Copy v to contiguous buffer, applying conjugation if needed
@@ -240,19 +242,22 @@
       static_v;
   ei_declare_aligned_stack_constructed_variable(Scalar, vPtr, size,
                                                 (UseVDirectly ? const_cast<Scalar*>(actualV.data()) : static_v.data()));
-  if (!UseVDirectly) {
-    if (NeedConjV)
+  EIGEN_IF_CONSTEXPR (!UseVDirectly) {
+    EIGEN_IF_CONSTEXPR (NeedConjV) {
       Map<typename ActualVType_::PlainObject>(vPtr, size) = actualV.conjugate();
-    else
+    } else {
       Map<typename ActualVType_::PlainObject>(vPtr, size) = actualV;
+    }
   }
 
-  internal::selfadjoint_rank2_update_selector<Scalar, Index, (IsRowMajor ? int(UpLo == Upper ? Lower : Upper) : UpLo)>::
-      run(size, _expression().const_cast_derived().data(), _expression().outerStride(), uPtr, vPtr, actualAlpha);
+  internal::selfadjoint_rank2_update_selector<
+      Scalar, Index, (IsRowMajor ? int(UpLo == Upper ? Lower : Upper) : UpLo)>::run(size, nestedExpression().data(),
+                                                                                    nestedExpression().outerStride(),
+                                                                                    uPtr, vPtr, actualAlpha);
 
   return *this;
 }
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_SELFADJOINTRANK2UPTADE_H
+#endif  // EIGEN_SELFADJOINTRANK2UPDATE_H
diff --git a/Eigen/src/Core/products/TriangularMatrixMatrix.h b/Eigen/src/Core/products/TriangularMatrixMatrix.h
index e4e446e..6adda5c 100644
--- a/Eigen/src/Core/products/TriangularMatrixMatrix.h
+++ b/Eigen/src/Core/products/TriangularMatrixMatrix.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_H
 #define EIGEN_TRIANGULAR_MATRIX_MATRIX_H
@@ -44,7 +45,7 @@
           bool ConjugateRhs, int ResInnerStride, int Version>
 struct product_triangular_matrix_matrix<Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder,
                                         ConjugateRhs, ColMajor, ResInnerStride, Version> {
-  typedef gebp_traits<Scalar, Scalar> Traits;
+  using Traits = gebp_traits<Scalar, Scalar>;
   enum {
     SmallPanelWidth = 2 * plain_enum_max(Traits::mr, Traits::nr),
     IsLower = (Mode & Lower) == Lower,
@@ -69,9 +70,9 @@
   Index depth = IsLower ? diagSize : _depth;
   Index cols = _cols;
 
-  typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
-  typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
-  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+  using LhsMapper = const_blas_data_mapper<Scalar, Index, LhsStorageOrder>;
+  using RhsMapper = const_blas_data_mapper<Scalar, Index, RhsStorageOrder>;
+  using ResMapper = blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
   LhsMapper lhs(lhs_, lhsStride);
   RhsMapper rhs(rhs_, rhsStride);
   ResMapper res(res_, resStride, resIncr);
@@ -91,7 +92,7 @@
 
   Matrix<Scalar, SmallPanelWidth, SmallPanelWidth, LhsStorageOrder> triangularBuffer;
   triangularBuffer.setZero();
-  if ((Mode & ZeroDiag) == ZeroDiag)
+  EIGEN_IF_CONSTEXPR ((Mode & ZeroDiag) == ZeroDiag)
     triangularBuffer.diagonal().setZero();
   else
     triangularBuffer.diagonal().setOnes();
@@ -107,9 +108,11 @@
     Index actual_k2 = IsLower ? k2 - actual_kc : k2;
 
     // align blocks with the end of the triangular part for trapezoidal lhs
-    if ((!IsLower) && (k2 < rows) && (k2 + actual_kc > rows)) {
-      actual_kc = rows - k2;
-      k2 = k2 + actual_kc - kc;
+    EIGEN_IF_CONSTEXPR (!IsLower) {
+      if ((k2 < rows) && (k2 + actual_kc > rows)) {
+        actual_kc = rows - k2;
+        k2 = k2 + actual_kc - kc;
+      }
     }
 
     pack_rhs(blockB, rhs.getSubMapper(actual_k2, 0), actual_kc, cols);
@@ -132,7 +135,7 @@
         // The trick is to pack this micro block while filling the opposite triangular part with zeros.
         // To this end we do an extra triangular copy to a small temporary buffer
         for (Index k = 0; k < actualPanelWidth; ++k) {
-          if (SetDiag) triangularBuffer.coeffRef(k, k) = lhs(startBlock + k, startBlock + k);
+          EIGEN_IF_CONSTEXPR (SetDiag) triangularBuffer.coeffRef(k, k) = lhs(startBlock + k, startBlock + k);
           for (Index i = IsLower ? k + 1 : 0; IsLower ? i < actualPanelWidth : i < k; ++i)
             triangularBuffer.coeffRef(i, k) = lhs(startBlock + i, startBlock + k);
         }
@@ -173,7 +176,7 @@
           bool ConjugateRhs, int ResInnerStride, int Version>
 struct product_triangular_matrix_matrix<Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder,
                                         ConjugateRhs, ColMajor, ResInnerStride, Version> {
-  typedef gebp_traits<Scalar, Scalar> Traits;
+  using Traits = gebp_traits<Scalar, Scalar>;
   enum {
     SmallPanelWidth = plain_enum_max(Traits::mr, Traits::nr),
     IsLower = (Mode & Lower) == Lower,
@@ -199,9 +202,9 @@
   Index depth = IsLower ? _depth : diagSize;
   Index cols = IsLower ? diagSize : _cols;
 
-  typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
-  typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
-  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
+  using LhsMapper = const_blas_data_mapper<Scalar, Index, LhsStorageOrder>;
+  using RhsMapper = const_blas_data_mapper<Scalar, Index, RhsStorageOrder>;
+  using ResMapper = blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride>;
   LhsMapper lhs(lhs_, lhsStride);
   RhsMapper rhs(rhs_, rhsStride);
   ResMapper res(res_, resStride, resIncr);
@@ -217,7 +220,7 @@
 
   Matrix<Scalar, SmallPanelWidth, SmallPanelWidth, RhsStorageOrder> triangularBuffer;
   triangularBuffer.setZero();
-  if ((Mode & ZeroDiag) == ZeroDiag)
+  EIGEN_IF_CONSTEXPR ((Mode & ZeroDiag) == ZeroDiag)
     triangularBuffer.diagonal().setZero();
   else
     triangularBuffer.diagonal().setOnes();
@@ -234,9 +237,11 @@
     Index actual_k2 = IsLower ? k2 : k2 - actual_kc;
 
     // align blocks with the end of the triangular part for trapezoidal rhs
-    if (IsLower && (k2 < cols) && (actual_k2 + actual_kc > cols)) {
-      actual_kc = cols - k2;
-      k2 = actual_k2 + actual_kc - kc;
+    EIGEN_IF_CONSTEXPR (IsLower) {
+      if ((k2 < cols) && (actual_k2 + actual_kc > cols)) {
+        actual_kc = cols - k2;
+        k2 = actual_k2 + actual_kc - kc;
+      }
     }
 
     // remaining size
@@ -262,7 +267,7 @@
 
         // append the triangular part via a temporary buffer
         for (Index j = 0; j < actualPanelWidth; ++j) {
-          if (SetDiag) triangularBuffer.coeffRef(j, j) = rhs(actual_j2 + j, actual_j2 + j);
+          EIGEN_IF_CONSTEXPR (SetDiag) triangularBuffer.coeffRef(j, j) = rhs(actual_j2 + j, actual_j2 + j);
           for (Index k = IsLower ? j + 1 : 0; IsLower ? k < actualPanelWidth : k < j; ++k)
             triangularBuffer.coeffRef(k, j) = rhs(actual_j2 + k, actual_j2 + j);
         }
@@ -304,16 +309,16 @@
 struct triangular_product_impl<Mode, LhsIsTriangular, Lhs, false, Rhs, false> {
   template <typename Dest>
   static void run(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const typename Dest::Scalar& alpha) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Rhs::Scalar RhsScalar;
-    typedef typename Dest::Scalar Scalar;
+    using LhsScalar = typename Lhs::Scalar;
+    using RhsScalar = typename Rhs::Scalar;
+    using Scalar = typename Dest::Scalar;
 
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-    typedef internal::remove_all_t<ActualLhsType> ActualLhsTypeCleaned;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-    typedef internal::remove_all_t<ActualRhsType> ActualRhsTypeCleaned;
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+    using ActualLhsTypeCleaned = internal::remove_all_t<ActualLhsType>;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
+    using ActualRhsTypeCleaned = internal::remove_all_t<ActualRhsType>;
 
     internal::add_const_on_value_type_t<ActualLhsType> lhs = LhsBlasTraits::extract(a_lhs);
     internal::add_const_on_value_type_t<ActualRhsType> rhs = RhsBlasTraits::extract(a_rhs);
@@ -328,10 +333,9 @@
     RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(a_rhs);
     Scalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
 
-    typedef internal::gemm_blocking_space<(Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, Scalar, Scalar,
-                                          Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime,
-                                          Lhs::MaxColsAtCompileTime, 4>
-        BlockingType;
+    using BlockingType = internal::gemm_blocking_space<(Dest::Flags & RowMajorBit) ? RowMajor : ColMajor, Scalar,
+                                                       Scalar, Lhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime,
+                                                       Lhs::MaxColsAtCompileTime, 4>;
 
     enum { IsLower = (Mode & Lower) == Lower };
     Index stripedRows = ((!LhsIsTriangular) || (IsLower)) ? lhs.rows() : (std::min)(lhs.rows(), lhs.cols());
@@ -354,13 +358,17 @@
                                              actualAlpha, blocking);
 
     // Apply correction if the diagonal is unit and a scalar factor was nested:
-    if ((Mode & UnitDiag) == UnitDiag) {
-      if (LhsIsTriangular && !numext::is_exactly_one(lhs_alpha)) {
-        Index diagSize = (std::min)(lhs.rows(), lhs.cols());
-        dst.topRows(diagSize) -= ((lhs_alpha - LhsScalar(1)) * a_rhs).topRows(diagSize);
-      } else if ((!LhsIsTriangular) && !numext::is_exactly_one(rhs_alpha)) {
-        Index diagSize = (std::min)(rhs.rows(), rhs.cols());
-        dst.leftCols(diagSize) -= (rhs_alpha - RhsScalar(1)) * a_lhs.leftCols(diagSize);
+    EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == UnitDiag) {
+      EIGEN_IF_CONSTEXPR (LhsIsTriangular) {
+        if (!numext::is_exactly_one(lhs_alpha)) {
+          Index diagSize = (std::min)(lhs.rows(), lhs.cols());
+          dst.topRows(diagSize) -= ((lhs_alpha - LhsScalar(1)) * a_rhs).topRows(diagSize);
+        }
+      } else {
+        if (!numext::is_exactly_one(rhs_alpha)) {
+          Index diagSize = (std::min)(rhs.rows(), rhs.cols());
+          dst.leftCols(diagSize) -= (rhs_alpha - RhsScalar(1)) * a_lhs.leftCols(diagSize);
+        }
       }
     }
   }
diff --git a/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h b/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
index 043011e..00730e6 100644
--- a/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
+++ b/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
@@ -29,6 +29,7 @@
  *   Triangular matrix * matrix product functionality based on ?TRMM.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
 #define EIGEN_TRIANGULAR_MATRIX_MATRIX_BLAS_H
@@ -143,7 +144,7 @@
       Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs, depth, cols, OuterStride<>(rhsStride));                        \
       MatrixX##EIGPREFIX b_tmp;                                                                                        \
                                                                                                                        \
-      if (ConjugateRhs)                                                                                                \
+      EIGEN_IF_CONSTEXPR (ConjugateRhs)                                                                                \
         b_tmp = rhs.conjugate();                                                                                       \
       else                                                                                                             \
         b_tmp = rhs;                                                                                                   \
@@ -152,19 +153,21 @@
                                                                                                                        \
       /* Set uplo */                                                                                                   \
       uplo = IsLower ? 'L' : 'U';                                                                                      \
-      if (LhsStorageOrder == RowMajor) uplo = (uplo == 'L') ? 'U' : 'L';                                               \
+      EIGEN_IF_CONSTEXPR (LhsStorageOrder == RowMajor) {                                                               \
+        uplo = (uplo == 'L') ? 'U' : 'L';                                                                              \
+      }                                                                                                                \
       /* Set a, lda */                                                                                                 \
       Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs, rows, depth, OuterStride<>(lhsStride));                        \
       MatrixLhs a_tmp;                                                                                                 \
                                                                                                                        \
-      if ((conjA != 0) || (SetDiag == 0)) {                                                                            \
-        if (conjA)                                                                                                     \
+      EIGEN_IF_CONSTEXPR ((conjA != 0) || (SetDiag == 0)) {                                                            \
+        EIGEN_IF_CONSTEXPR (conjA)                                                                                     \
           a_tmp = lhs.conjugate();                                                                                     \
         else                                                                                                           \
           a_tmp = lhs;                                                                                                 \
-        if (IsZeroDiag)                                                                                                \
+        EIGEN_IF_CONSTEXPR (IsZeroDiag)                                                                                \
           a_tmp.diagonal().setZero();                                                                                  \
-        else if (IsUnitDiag)                                                                                           \
+        else EIGEN_IF_CONSTEXPR (IsUnitDiag)                                                                           \
           a_tmp.diagonal().setOnes();                                                                                  \
         a = a_tmp.data();                                                                                              \
         lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                           \
@@ -189,10 +192,10 @@
 EIGEN_BLAS_TRMM_L(float, float, f, strmm)
 EIGEN_BLAS_TRMM_L(scomplex, MKL_Complex8, cf, ctrmm)
 #else
-EIGEN_BLAS_TRMM_L(double, double, d, dtrmm_)
-EIGEN_BLAS_TRMM_L(dcomplex, double, cd, ztrmm_)
-EIGEN_BLAS_TRMM_L(float, float, f, strmm_)
-EIGEN_BLAS_TRMM_L(scomplex, float, cf, ctrmm_)
+EIGEN_BLAS_TRMM_L(double, double, d, EIGEN_BLAS_SYM(dtrmm))
+EIGEN_BLAS_TRMM_L(dcomplex, double, cd, EIGEN_BLAS_SYM(ztrmm))
+EIGEN_BLAS_TRMM_L(float, float, f, EIGEN_BLAS_SYM(strmm))
+EIGEN_BLAS_TRMM_L(scomplex, float, cf, EIGEN_BLAS_SYM(ctrmm))
 #endif
 
 // implements col-major += alpha * op(general) * op(triangular)
@@ -267,7 +270,7 @@
       Map<const MatrixLhs, 0, OuterStride<> > lhs(_lhs, rows, depth, OuterStride<>(lhsStride));                        \
       MatrixX##EIGPREFIX b_tmp;                                                                                        \
                                                                                                                        \
-      if (ConjugateLhs)                                                                                                \
+      EIGEN_IF_CONSTEXPR (ConjugateLhs)                                                                                \
         b_tmp = lhs.conjugate();                                                                                       \
       else                                                                                                             \
         b_tmp = lhs;                                                                                                   \
@@ -276,19 +279,21 @@
                                                                                                                        \
       /* Set uplo */                                                                                                   \
       uplo = IsLower ? 'L' : 'U';                                                                                      \
-      if (RhsStorageOrder == RowMajor) uplo = (uplo == 'L') ? 'U' : 'L';                                               \
+      EIGEN_IF_CONSTEXPR (RhsStorageOrder == RowMajor) {                                                               \
+        uplo = (uplo == 'L') ? 'U' : 'L';                                                                              \
+      }                                                                                                                \
       /* Set a, lda */                                                                                                 \
       Map<const MatrixRhs, 0, OuterStride<> > rhs(_rhs, depth, cols, OuterStride<>(rhsStride));                        \
       MatrixRhs a_tmp;                                                                                                 \
                                                                                                                        \
-      if ((conjA != 0) || (SetDiag == 0)) {                                                                            \
-        if (conjA)                                                                                                     \
+      EIGEN_IF_CONSTEXPR ((conjA != 0) || (SetDiag == 0)) {                                                            \
+        EIGEN_IF_CONSTEXPR (conjA)                                                                                     \
           a_tmp = rhs.conjugate();                                                                                     \
         else                                                                                                           \
           a_tmp = rhs;                                                                                                 \
-        if (IsZeroDiag)                                                                                                \
+        EIGEN_IF_CONSTEXPR (IsZeroDiag)                                                                                \
           a_tmp.diagonal().setZero();                                                                                  \
-        else if (IsUnitDiag)                                                                                           \
+        else EIGEN_IF_CONSTEXPR (IsUnitDiag)                                                                           \
           a_tmp.diagonal().setOnes();                                                                                  \
         a = a_tmp.data();                                                                                              \
         lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                           \
@@ -313,10 +318,10 @@
 EIGEN_BLAS_TRMM_R(float, float, f, strmm)
 EIGEN_BLAS_TRMM_R(scomplex, MKL_Complex8, cf, ctrmm)
 #else
-EIGEN_BLAS_TRMM_R(double, double, d, dtrmm_)
-EIGEN_BLAS_TRMM_R(dcomplex, double, cd, ztrmm_)
-EIGEN_BLAS_TRMM_R(float, float, f, strmm_)
-EIGEN_BLAS_TRMM_R(scomplex, float, cf, ctrmm_)
+EIGEN_BLAS_TRMM_R(double, double, d, EIGEN_BLAS_SYM(dtrmm))
+EIGEN_BLAS_TRMM_R(dcomplex, double, cd, EIGEN_BLAS_SYM(ztrmm))
+EIGEN_BLAS_TRMM_R(float, float, f, EIGEN_BLAS_SYM(strmm))
+EIGEN_BLAS_TRMM_R(scomplex, float, cf, EIGEN_BLAS_SYM(ctrmm))
 #endif
 
 #undef EIGEN_BLAS_TRMM_SPECIALIZE
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index 41395f9..bd685ea 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRIANGULARMATRIXVECTOR_H
 #define EIGEN_TRIANGULARMATRIXVECTOR_H
@@ -23,8 +24,8 @@
 
 template <typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
 struct triangular_matrix_vector_product<Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, ColMajor, Version> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
-  static constexpr bool IsLower = ((Mode & Lower) == Lower);
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
+  static constexpr bool IsLower = (Mode & Lower) == Lower;
   static constexpr bool HasUnitDiag = (Mode & UnitDiag) == UnitDiag;
   static constexpr bool HasZeroDiag = (Mode & ZeroDiag) == ZeroDiag;
   static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* lhs_, Index lhsStride,
@@ -43,8 +44,8 @@
   Index rows = IsLower ? _rows : (std::min)(_rows, _cols);
   Index cols = IsLower ? (std::min)(_rows, _cols) : _cols;
 
-  typedef const_blas_data_mapper<LhsScalar, Index, ColMajor> LhsMapper;
-  typedef const_blas_data_mapper<RhsScalar, Index, RowMajor> RhsMapper;
+  using LhsMapper = const_blas_data_mapper<LhsScalar, Index, ColMajor>;
+  using RhsMapper = const_blas_data_mapper<RhsScalar, Index, RowMajor>;
 
   conj_if<ConjLhs> cjl;
   conj_if<ConjRhs> cjr;
@@ -54,7 +55,7 @@
 
     // Process the triangular panel using raw pointer operations with 2-column batching
     // to eliminate expression template overhead and share result loads/stores.
-    if (IsLower) {
+    EIGEN_IF_CONSTEXPR (IsLower) {
       Index k = 0;
       for (; k + 1 < actualPanelWidth; k += 2) {
         Index i0 = pi + k;
@@ -65,18 +66,18 @@
         const LhsScalar* EIGEN_RESTRICT c1 = lhs_ + i1 * lhsStride;
 
         // Diagonal of column 0
-        if (!(HasUnitDiag || HasZeroDiag)) res_[i0] += s0 * cjl(c0[i0]);
+        EIGEN_IF_CONSTEXPR (!(HasUnitDiag || HasZeroDiag)) res_[i0] += s0 * cjl(c0[i0]);
         // Row i1: contribution from column 0 + diagonal of column 1
         {
           ResScalar r1 = s0 * cjl(c0[i1]);
-          if (!(HasUnitDiag || HasZeroDiag)) r1 += s1 * cjl(c1[i1]);
+          EIGEN_IF_CONSTEXPR (!(HasUnitDiag || HasZeroDiag)) r1 += s1 * cjl(c1[i1]);
           res_[i1] += r1;
         }
         // Shared rows where both columns contribute
         Index panelEnd = pi + actualPanelWidth;
         for (Index j = i1 + 1; j < panelEnd; ++j) res_[j] += s0 * cjl(c0[j]) + s1 * cjl(c1[j]);
 
-        if (HasUnitDiag) {
+        EIGEN_IF_CONSTEXPR (HasUnitDiag) {
           res_[i0] += s0;
           res_[i1] += s1;
         }
@@ -85,8 +86,8 @@
         Index i = pi + k;
         ResScalar s = alpha * cjr(rhs_[i * rhsIncr]);
         const LhsScalar* EIGEN_RESTRICT c = lhs_ + i * lhsStride;
-        if (!(HasUnitDiag || HasZeroDiag)) res_[i] += s * cjl(c[i]);
-        if (HasUnitDiag) res_[i] += s;
+        EIGEN_IF_CONSTEXPR (!(HasUnitDiag || HasZeroDiag)) res_[i] += s * cjl(c[i]);
+        EIGEN_IF_CONSTEXPR (HasUnitDiag) res_[i] += s;
       }
     } else {
       // Upper triangular: process 2 columns at a time
@@ -105,13 +106,13 @@
         // Row i0: diagonal of col0 + contribution from col1
         {
           ResScalar r0 = s1 * cjl(c1[i0]);
-          if (!(HasUnitDiag || HasZeroDiag)) r0 += s0 * cjl(c0[i0]);
+          EIGEN_IF_CONSTEXPR (!(HasUnitDiag || HasZeroDiag)) r0 += s0 * cjl(c0[i0]);
           res_[i0] += r0;
         }
         // Diagonal of column 1
-        if (!(HasUnitDiag || HasZeroDiag)) res_[i1] += s1 * cjl(c1[i1]);
+        EIGEN_IF_CONSTEXPR (!(HasUnitDiag || HasZeroDiag)) res_[i1] += s1 * cjl(c1[i1]);
 
-        if (HasUnitDiag) {
+        EIGEN_IF_CONSTEXPR (HasUnitDiag) {
           res_[i0] += s0;
           res_[i1] += s1;
         }
@@ -121,8 +122,8 @@
         ResScalar s = alpha * cjr(rhs_[i * rhsIncr]);
         const LhsScalar* EIGEN_RESTRICT c = lhs_ + i * lhsStride;
         for (Index j = pi; j < i; ++j) res_[j] += s * cjl(c[j]);
-        if (!(HasUnitDiag || HasZeroDiag)) res_[i] += s * cjl(c[i]);
-        if (HasUnitDiag) res_[i] += s;
+        EIGEN_IF_CONSTEXPR (!(HasUnitDiag || HasZeroDiag)) res_[i] += s * cjl(c[i]);
+        EIGEN_IF_CONSTEXPR (HasUnitDiag) res_[i] += s;
       }
     }
 
@@ -135,17 +136,19 @@
                                                   RhsMapper(&rhs_[pi * rhsIncr], rhsIncr), &res_[s], resIncr, alpha);
     }
   }
-  if ((!IsLower) && cols > size) {
-    general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs>::run(
-        rows, cols - size, LhsMapper(&lhs_[size * lhsStride], lhsStride), RhsMapper(&rhs_[size * rhsIncr], rhsIncr),
-        res_, resIncr, alpha);
+  EIGEN_IF_CONSTEXPR (!IsLower) {
+    if (cols > size) {
+      general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs>::run(
+          rows, cols - size, LhsMapper(&lhs_[size * lhsStride], lhsStride), RhsMapper(&rhs_[size * rhsIncr], rhsIncr),
+          res_, resIncr, alpha);
+    }
   }
 }
 
 template <typename Index, int Mode, typename LhsScalar, bool ConjLhs, typename RhsScalar, bool ConjRhs, int Version>
 struct triangular_matrix_vector_product<Index, Mode, LhsScalar, ConjLhs, RhsScalar, ConjRhs, RowMajor, Version> {
-  typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ResScalar;
-  static constexpr bool IsLower = ((Mode & Lower) == Lower);
+  using ResScalar = typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType;
+  static constexpr bool IsLower = (Mode & Lower) == Lower;
   static constexpr bool HasUnitDiag = (Mode & UnitDiag) == UnitDiag;
   static constexpr bool HasZeroDiag = (Mode & ZeroDiag) == ZeroDiag;
   static EIGEN_DONT_INLINE void run(Index _rows, Index _cols, const LhsScalar* lhs_, Index lhsStride,
@@ -164,8 +167,8 @@
   Index rows = IsLower ? _rows : diagSize;
   Index cols = IsLower ? diagSize : _cols;
 
-  typedef const_blas_data_mapper<LhsScalar, Index, RowMajor> LhsMapper;
-  typedef const_blas_data_mapper<RhsScalar, Index, RowMajor> RhsMapper;
+  using LhsMapper = const_blas_data_mapper<LhsScalar, Index, RowMajor>;
+  using RhsMapper = const_blas_data_mapper<RhsScalar, Index, RowMajor>;
 
   conj_if<ConjLhs> cjl;
   conj_if<ConjRhs> cjr;
@@ -180,7 +183,7 @@
       const LhsScalar* EIGEN_RESTRICT row_i = lhs_ + i * lhsStride;
       ResScalar dot = ResScalar(0);
 
-      if (IsLower) {
+      EIGEN_IF_CONSTEXPR (IsLower) {
         Index s = pi;
         Index len = (HasUnitDiag || HasZeroDiag) ? k : k + 1;
         for (Index j = 0; j < len; ++j) dot += cjl(row_i[s + j]) * cjr(rhs_[s + j]);
@@ -190,7 +193,7 @@
         for (Index j = 0; j < len; ++j) dot += cjl(row_i[s + j]) * cjr(rhs_[s + j]);
       }
       res_[i * resIncr] += alpha * dot;
-      if (HasUnitDiag) res_[i * resIncr] += alpha * cjr(rhs_[i]);
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) res_[i * resIncr] += alpha * cjr(rhs_[i]);
     }
 
     // Rectangular part: delegate to optimized GEMV
@@ -202,10 +205,12 @@
                                                   RhsMapper(&rhs_[s], rhsIncr), &res_[pi * resIncr], resIncr, alpha);
     }
   }
-  if (IsLower && rows > diagSize) {
-    general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs>::run(
-        rows - diagSize, cols, LhsMapper(&lhs_[diagSize * lhsStride], lhsStride), RhsMapper(rhs_, rhsIncr),
-        &res_[diagSize * resIncr], resIncr, alpha);
+  EIGEN_IF_CONSTEXPR (IsLower) {
+    if (rows > diagSize) {
+      general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs>::run(
+          rows - diagSize, cols, LhsMapper(&lhs_[diagSize * lhsStride], lhsStride), RhsMapper(rhs_, rhsIncr),
+          &res_[diagSize * resIncr], resIncr, alpha);
+    }
   }
 }
 
@@ -250,24 +255,29 @@
 
 namespace internal {
 
-// TODO: find a way to factorize this piece of code with gemv_selector since the logic is exactly the same.
+template <int Mode, typename Lhs, typename Rhs, typename Dest, typename LhsScalar>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void trmv_correct_unit_diagonal(const Lhs& lhs, const Rhs& rhs, Dest& dest,
+                                                                      const LhsScalar& lhs_alpha) {
+  EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == UnitDiag) {
+    if (!numext::is_exactly_one(lhs_alpha)) {
+      Index diagSize = (std::min)(lhs.rows(), lhs.cols());
+      dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+    }
+  }
+}
 
 template <int Mode>
 struct trmv_selector<Mode, ColMajor> {
   template <typename Lhs, typename Rhs, typename Dest>
   static void run(const Lhs& lhs, const Rhs& rhs, Dest& dest, const typename Dest::Scalar& alpha) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Rhs::Scalar RhsScalar;
-    typedef typename Dest::Scalar ResScalar;
+    using LhsScalar = typename Lhs::Scalar;
+    using RhsScalar = typename Rhs::Scalar;
+    using ResScalar = typename Dest::Scalar;
 
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-    constexpr int Alignment = (std::min)(int(AlignedMax), int(internal::packet_traits<ResScalar>::size));
-
-    typedef Map<Matrix<ResScalar, Dynamic, 1>, Alignment> MappedDest;
-
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
     add_const_on_value_type_t<ActualLhsType> actualLhs = LhsBlasTraits::extract(lhs);
     add_const_on_value_type_t<ActualRhsType> actualRhs = RhsBlasTraits::extract(rhs);
 
@@ -284,48 +294,23 @@
     gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
         static_dest;
 
-    bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
-    bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
-
-    RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
+    gemv_destination_policy<RhsScalar, ResScalar, EvalToDestAtCompileTime, ComplexByReal> destPolicy(actualAlpha);
 
     ei_declare_aligned_stack_constructed_variable(ResScalar, actualDestPtr, dest.size(),
-                                                  evalToDest ? dest.data() : static_dest.data());
+                                                  destPolicy.eval_to_dest() ? dest.data() : static_dest.data());
 
-    if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-      constexpr int Size = Dest::SizeAtCompileTime;
-      Index size = dest.size();
-      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
-      if (!alphaIsCompatible) {
-        MappedDest(actualDestPtr, dest.size()).setZero();
-        compatibleAlpha = RhsScalar(1);
-      } else
-        MappedDest(actualDestPtr, dest.size()) = dest;
-    }
+    destPolicy.prepare(dest, actualDestPtr);
 
     internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
-                                               RhsBlasTraits::NeedToConjugate, ColMajor>::run(actualLhs.rows(),
-                                                                                              actualLhs.cols(),
-                                                                                              actualLhs.data(),
-                                                                                              actualLhs.outerStride(),
-                                                                                              actualRhs.data(),
-                                                                                              actualRhs.innerStride(),
-                                                                                              actualDestPtr, 1,
-                                                                                              compatibleAlpha);
+                                               RhsBlasTraits::NeedToConjugate,
+                                               ColMajor>::run(actualLhs.rows(), actualLhs.cols(), actualLhs.data(),
+                                                              actualLhs.outerStride(), actualRhs.data(),
+                                                              actualRhs.innerStride(), actualDestPtr, 1,
+                                                              destPolicy.compatible_alpha());
 
-    if (!evalToDest) {
-      if (!alphaIsCompatible)
-        dest += actualAlpha * MappedDest(actualDestPtr, dest.size());
-      else
-        dest = MappedDest(actualDestPtr, dest.size());
-    }
+    destPolicy.copy_back(dest, actualDestPtr);
 
-    if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
-      Index diagSize = (std::min)(lhs.rows(), lhs.cols());
-      dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
-    }
+    trmv_correct_unit_diagonal<Mode>(lhs, rhs, dest, lhs_alpha);
   }
 };
 
@@ -333,15 +318,15 @@
 struct trmv_selector<Mode, RowMajor> {
   template <typename Lhs, typename Rhs, typename Dest>
   static void run(const Lhs& lhs, const Rhs& rhs, Dest& dest, const typename Dest::Scalar& alpha) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Rhs::Scalar RhsScalar;
-    typedef typename Dest::Scalar ResScalar;
+    using LhsScalar = typename Lhs::Scalar;
+    using RhsScalar = typename Rhs::Scalar;
+    using ResScalar = typename Dest::Scalar;
 
-    typedef internal::blas_traits<Lhs> LhsBlasTraits;
-    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
-    typedef internal::blas_traits<Rhs> RhsBlasTraits;
-    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
-    typedef internal::remove_all_t<ActualRhsType> ActualRhsTypeCleaned;
+    using LhsBlasTraits = internal::blas_traits<Lhs>;
+    using ActualLhsType = typename LhsBlasTraits::DirectLinearAccessType;
+    using RhsBlasTraits = internal::blas_traits<Rhs>;
+    using ActualRhsType = typename RhsBlasTraits::DirectLinearAccessType;
+    using ActualRhsTypeCleaned = internal::remove_all_t<ActualRhsType>;
 
     std::add_const_t<ActualLhsType> actualLhs = LhsBlasTraits::extract(lhs);
     std::add_const_t<ActualRhsType> actualRhs = RhsBlasTraits::extract(rhs);
@@ -352,40 +337,15 @@
 
     constexpr bool DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime == 1;
 
-    const RhsScalar* actualRhsPtr = actualRhs.data();
-
-    // Potentially create a temporary buffer to copy RHS to contiguous memory.
     gemv_static_vector_if<RhsScalar, ActualRhsTypeCleaned::SizeAtCompileTime,
                           ActualRhsTypeCleaned::MaxSizeAtCompileTime, !DirectlyUseRhs>
-        static_rhs;  // Fixed-sized array.
-    RhsScalar* buffer = nullptr;
-    if (!DirectlyUseRhs) {
-      // Maybe used fixed-sized buffer, otherwise allocate.
-      if (static_rhs.data() != nullptr) {
-        buffer = static_rhs.data();
-      } else {
-        // Allocate either with alloca or malloc.
-        Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
-        buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
-                                             ? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
-                                             : Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
-        buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
-      }
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-      constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
-      Index size = actualRhs.size();
-      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
-      Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
-      actualRhsPtr = buffer;
-    }
-    // Deallocate only if malloced.
-    Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
-        buffer, actualRhs.size(),
-        !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+        static_rhs;
+
+    ei_declare_aligned_stack_constructed_variable(
+        RhsScalar, actualRhsPtr, actualRhs.size(),
+        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
+
+    gemv_prepare_rhs<DirectlyUseRhs>(actualRhs, actualRhsPtr);
 
     internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
                                                RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
@@ -397,10 +357,7 @@
                                                                                               dest.innerStride(),
                                                                                               actualAlpha);
 
-    if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
-      Index diagSize = (std::min)(lhs.rows(), lhs.cols());
-      dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
-    }
+    trmv_correct_unit_diagonal<Mode>(lhs, rhs, dest, lhs_alpha);
   }
 };
 
diff --git a/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h b/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
index 19ed813..9ba3dea 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
@@ -29,6 +29,7 @@
  *   Triangular matrix-vector product functionality based on ?TRMV.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
 #define EIGEN_TRIANGULAR_MATRIX_VECTOR_BLAS_H
@@ -75,88 +76,89 @@
 EIGEN_BLAS_TRMV_SPECIALIZE(scomplex)
 
 // implements col-major: res += alpha * op(triangular) * vector
-#define EIGEN_BLAS_TRMV_CM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX)                                    \
-  template <typename Index, int Mode, bool ConjLhs, bool ConjRhs>                                                    \
-  struct triangular_matrix_vector_product_trmv<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, ColMajor> {          \
-    enum {                                                                                                           \
-      IsLower = (Mode & Lower) == Lower,                                                                             \
-      SetDiag = (Mode & (ZeroDiag | UnitDiag)) ? 0 : 1,                                                              \
-      IsUnitDiag = (Mode & UnitDiag) ? 1 : 0,                                                                        \
-      IsZeroDiag = (Mode & ZeroDiag) ? 1 : 0,                                                                        \
-      LowUp = IsLower ? Lower : Upper                                                                                \
-    };                                                                                                               \
-    static void run(Index rows_, Index cols_, const EIGTYPE* lhs_, Index lhsStride, const EIGTYPE* rhs_,             \
-                    Index rhsIncr, EIGTYPE* res_, Index resIncr, EIGTYPE alpha) {                                    \
-      if (rows_ == 0 || cols_ == 0) return;                                                                          \
-      if (ConjLhs || IsZeroDiag) {                                                                                   \
-        triangular_matrix_vector_product<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, ColMajor, BuiltIn>::run(   \
-            rows_, cols_, lhs_, lhsStride, rhs_, rhsIncr, res_, resIncr, alpha);                                     \
-        return;                                                                                                      \
-      }                                                                                                              \
-      Index size = (std::min)(rows_, cols_);                                                                         \
-      Index rows = IsLower ? rows_ : size;                                                                           \
-      Index cols = IsLower ? size : cols_;                                                                           \
-                                                                                                                     \
-      typedef VectorX##EIGPREFIX VectorRhs;                                                                          \
-      EIGTYPE *x, *y;                                                                                                \
-                                                                                                                     \
-      /* Set x*/                                                                                                     \
-      Map<const VectorRhs, 0, InnerStride<> > rhs(rhs_, cols, InnerStride<>(rhsIncr));                               \
-      VectorRhs x_tmp;                                                                                               \
-      if (ConjRhs)                                                                                                   \
-        x_tmp = rhs.conjugate();                                                                                     \
-      else                                                                                                           \
-        x_tmp = rhs;                                                                                                 \
-      x = x_tmp.data();                                                                                              \
-                                                                                                                     \
-      /* Square part handling */                                                                                     \
-                                                                                                                     \
-      char trans, uplo, diag;                                                                                        \
-      BlasIndex m, n, lda, incx, incy;                                                                               \
-      EIGTYPE const* a;                                                                                              \
-      EIGTYPE beta(1);                                                                                               \
-                                                                                                                     \
-      /* Set m, n */                                                                                                 \
-      n = convert_index<BlasIndex>(size);                                                                            \
-      lda = convert_index<BlasIndex>(lhsStride);                                                                     \
-      incx = 1;                                                                                                      \
-      incy = convert_index<BlasIndex>(resIncr);                                                                      \
-                                                                                                                     \
-      /* Set uplo, trans and diag*/                                                                                  \
-      trans = 'N';                                                                                                   \
-      uplo = IsLower ? 'L' : 'U';                                                                                    \
-      diag = IsUnitDiag ? 'U' : 'N';                                                                                 \
-                                                                                                                     \
-      /* call ?TRMV*/                                                                                                \
-      BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)lhs_, &lda, (BLASTYPE*)x, &incx);     \
-                                                                                                                     \
-      /* Add op(a_tr)rhs into res*/                                                                                  \
-      BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)x, &incx,        \
-                                    (BLASTYPE*)res_, &incy);                                                         \
-      /* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/                           \
-      if (size < (std::max)(rows, cols)) {                                                                           \
-        if (ConjRhs)                                                                                                 \
-          x_tmp = rhs.conjugate();                                                                                   \
-        else                                                                                                         \
-          x_tmp = rhs;                                                                                               \
-        x = x_tmp.data();                                                                                            \
-        if (size < rows) {                                                                                           \
-          y = res_ + size * resIncr;                                                                                 \
-          a = lhs_ + size;                                                                                           \
-          m = convert_index<BlasIndex>(rows - size);                                                                 \
-          n = convert_index<BlasIndex>(size);                                                                        \
-        } else {                                                                                                     \
-          x += size;                                                                                                 \
-          y = res_;                                                                                                  \
-          a = lhs_ + size * lda;                                                                                     \
-          m = convert_index<BlasIndex>(size);                                                                        \
-          n = convert_index<BlasIndex>(cols - size);                                                                 \
-        }                                                                                                            \
-        BLASPREFIX##gemv##BLASPOSTFIX(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, \
-                                      &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta),     \
-                                      (BLASTYPE*)y, &incy);                                                          \
-      }                                                                                                              \
-    }                                                                                                                \
+#define EIGEN_BLAS_TRMV_CM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX)                                  \
+  template <typename Index, int Mode, bool ConjLhs, bool ConjRhs>                                                  \
+  struct triangular_matrix_vector_product_trmv<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, ColMajor> {        \
+    enum {                                                                                                         \
+      IsLower = (Mode & Lower) == Lower,                                                                           \
+      SetDiag = (Mode & (ZeroDiag | UnitDiag)) ? 0 : 1,                                                            \
+      IsUnitDiag = (Mode & UnitDiag) ? 1 : 0,                                                                      \
+      IsZeroDiag = (Mode & ZeroDiag) ? 1 : 0,                                                                      \
+      LowUp = IsLower ? Lower : Upper                                                                              \
+    };                                                                                                             \
+    static void run(Index rows_, Index cols_, const EIGTYPE* lhs_, Index lhsStride, const EIGTYPE* rhs_,           \
+                    Index rhsIncr, EIGTYPE* res_, Index resIncr, EIGTYPE alpha) {                                  \
+      if (rows_ == 0 || cols_ == 0) return;                                                                        \
+      EIGEN_IF_CONSTEXPR (ConjLhs || IsZeroDiag) {                                                                 \
+        triangular_matrix_vector_product<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, ColMajor, BuiltIn>::run( \
+            rows_, cols_, lhs_, lhsStride, rhs_, rhsIncr, res_, resIncr, alpha);                                   \
+        return;                                                                                                    \
+      }                                                                                                            \
+      Index size = (std::min)(rows_, cols_);                                                                       \
+      Index rows = IsLower ? rows_ : size;                                                                         \
+      Index cols = IsLower ? size : cols_;                                                                         \
+                                                                                                                   \
+      typedef VectorX##EIGPREFIX VectorRhs;                                                                        \
+      EIGTYPE *x, *y;                                                                                              \
+                                                                                                                   \
+      /* Set x*/                                                                                                   \
+      Map<const VectorRhs, 0, InnerStride<> > rhs(rhs_, cols, InnerStride<>(rhsIncr));                             \
+      VectorRhs x_tmp;                                                                                             \
+      EIGEN_IF_CONSTEXPR (ConjRhs)                                                                                 \
+        x_tmp = rhs.conjugate();                                                                                   \
+      else                                                                                                         \
+        x_tmp = rhs;                                                                                               \
+      x = x_tmp.data();                                                                                            \
+                                                                                                                   \
+      /* Square part handling */                                                                                   \
+                                                                                                                   \
+      char trans, uplo, diag;                                                                                      \
+      BlasIndex m, n, lda, incx, incy;                                                                             \
+      EIGTYPE const* a;                                                                                            \
+      EIGTYPE beta(1);                                                                                             \
+                                                                                                                   \
+      /* Set m, n */                                                                                               \
+      n = convert_index<BlasIndex>(size);                                                                          \
+      lda = convert_index<BlasIndex>(lhsStride);                                                                   \
+      incx = 1;                                                                                                    \
+      incy = convert_index<BlasIndex>(resIncr);                                                                    \
+                                                                                                                   \
+      /* Set uplo, trans and diag*/                                                                                \
+      trans = 'N';                                                                                                 \
+      uplo = IsLower ? 'L' : 'U';                                                                                  \
+      diag = IsUnitDiag ? 'U' : 'N';                                                                               \
+                                                                                                                   \
+      /* call ?TRMV*/                                                                                              \
+      EIGEN_CAT(EIGEN_CAT(BLASPREFIX, trmv), BLASPOSTFIX)                                                          \
+      (&uplo, &trans, &diag, &n, (const BLASTYPE*)lhs_, &lda, (BLASTYPE*)x, &incx);                                \
+                                                                                                                   \
+      /* Add op(a_tr)rhs into res*/                                                                                \
+      EIGEN_CAT(EIGEN_CAT(BLASPREFIX, axpy), BLASPOSTFIX)                                                          \
+      (&n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)x, &incx, (BLASTYPE*)res_, &incy);          \
+      /* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/                         \
+      if (size < (std::max)(rows, cols)) {                                                                         \
+        EIGEN_IF_CONSTEXPR (ConjRhs)                                                                               \
+          x_tmp = rhs.conjugate();                                                                                 \
+        else                                                                                                       \
+          x_tmp = rhs;                                                                                             \
+        x = x_tmp.data();                                                                                          \
+        if (size < rows) {                                                                                         \
+          y = res_ + size * resIncr;                                                                               \
+          a = lhs_ + size;                                                                                         \
+          m = convert_index<BlasIndex>(rows - size);                                                               \
+          n = convert_index<BlasIndex>(size);                                                                      \
+        } else {                                                                                                   \
+          x += size;                                                                                               \
+          y = res_;                                                                                                \
+          a = lhs_ + size * lda;                                                                                   \
+          m = convert_index<BlasIndex>(size);                                                                      \
+          n = convert_index<BlasIndex>(cols - size);                                                               \
+        }                                                                                                          \
+        EIGEN_CAT(EIGEN_CAT(BLASPREFIX, gemv), BLASPOSTFIX)                                                        \
+        (&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x,  \
+         &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy);                                    \
+      }                                                                                                            \
+    }                                                                                                              \
   };
 
 #ifdef EIGEN_USE_MKL
@@ -165,95 +167,96 @@
 EIGEN_BLAS_TRMV_CM(float, float, f, s, )
 EIGEN_BLAS_TRMV_CM(scomplex, MKL_Complex8, cf, c, )
 #else
-EIGEN_BLAS_TRMV_CM(double, double, d, d, _)
-EIGEN_BLAS_TRMV_CM(dcomplex, double, cd, z, _)
-EIGEN_BLAS_TRMV_CM(float, float, f, s, _)
-EIGEN_BLAS_TRMV_CM(scomplex, float, cf, c, _)
+EIGEN_BLAS_TRMV_CM(double, double, d, d, EIGEN_BLAS_POSTFIX)
+EIGEN_BLAS_TRMV_CM(dcomplex, double, cd, z, EIGEN_BLAS_POSTFIX)
+EIGEN_BLAS_TRMV_CM(float, float, f, s, EIGEN_BLAS_POSTFIX)
+EIGEN_BLAS_TRMV_CM(scomplex, float, cf, c, EIGEN_BLAS_POSTFIX)
 #endif
 
 // implements row-major: res += alpha * op(triangular) * vector
-#define EIGEN_BLAS_TRMV_RM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX)                                    \
-  template <typename Index, int Mode, bool ConjLhs, bool ConjRhs>                                                    \
-  struct triangular_matrix_vector_product_trmv<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, RowMajor> {          \
-    enum {                                                                                                           \
-      IsLower = (Mode & Lower) == Lower,                                                                             \
-      SetDiag = (Mode & (ZeroDiag | UnitDiag)) ? 0 : 1,                                                              \
-      IsUnitDiag = (Mode & UnitDiag) ? 1 : 0,                                                                        \
-      IsZeroDiag = (Mode & ZeroDiag) ? 1 : 0,                                                                        \
-      LowUp = IsLower ? Lower : Upper                                                                                \
-    };                                                                                                               \
-    static void run(Index rows_, Index cols_, const EIGTYPE* lhs_, Index lhsStride, const EIGTYPE* rhs_,             \
-                    Index rhsIncr, EIGTYPE* res_, Index resIncr, EIGTYPE alpha) {                                    \
-      if (rows_ == 0 || cols_ == 0) return;                                                                          \
-      if (IsZeroDiag) {                                                                                              \
-        triangular_matrix_vector_product<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, RowMajor, BuiltIn>::run(   \
-            rows_, cols_, lhs_, lhsStride, rhs_, rhsIncr, res_, resIncr, alpha);                                     \
-        return;                                                                                                      \
-      }                                                                                                              \
-      Index size = (std::min)(rows_, cols_);                                                                         \
-      Index rows = IsLower ? rows_ : size;                                                                           \
-      Index cols = IsLower ? size : cols_;                                                                           \
-                                                                                                                     \
-      typedef VectorX##EIGPREFIX VectorRhs;                                                                          \
-      EIGTYPE *x, *y;                                                                                                \
-                                                                                                                     \
-      /* Set x*/                                                                                                     \
-      Map<const VectorRhs, 0, InnerStride<> > rhs(rhs_, cols, InnerStride<>(rhsIncr));                               \
-      VectorRhs x_tmp;                                                                                               \
-      if (ConjRhs)                                                                                                   \
-        x_tmp = rhs.conjugate();                                                                                     \
-      else                                                                                                           \
-        x_tmp = rhs;                                                                                                 \
-      x = x_tmp.data();                                                                                              \
-                                                                                                                     \
-      /* Square part handling */                                                                                     \
-                                                                                                                     \
-      char trans, uplo, diag;                                                                                        \
-      BlasIndex m, n, lda, incx, incy;                                                                               \
-      EIGTYPE const* a;                                                                                              \
-      EIGTYPE beta(1);                                                                                               \
-                                                                                                                     \
-      /* Set m, n */                                                                                                 \
-      n = convert_index<BlasIndex>(size);                                                                            \
-      lda = convert_index<BlasIndex>(lhsStride);                                                                     \
-      incx = 1;                                                                                                      \
-      incy = convert_index<BlasIndex>(resIncr);                                                                      \
-                                                                                                                     \
-      /* Set uplo, trans and diag*/                                                                                  \
-      trans = ConjLhs ? 'C' : 'T';                                                                                   \
-      uplo = IsLower ? 'U' : 'L';                                                                                    \
-      diag = IsUnitDiag ? 'U' : 'N';                                                                                 \
-                                                                                                                     \
-      /* call ?TRMV*/                                                                                                \
-      BLASPREFIX##trmv##BLASPOSTFIX(&uplo, &trans, &diag, &n, (const BLASTYPE*)lhs_, &lda, (BLASTYPE*)x, &incx);     \
-                                                                                                                     \
-      /* Add op(a_tr)rhs into res*/                                                                                  \
-      BLASPREFIX##axpy##BLASPOSTFIX(&n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)x, &incx,        \
-                                    (BLASTYPE*)res_, &incy);                                                         \
-      /* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/                           \
-      if (size < (std::max)(rows, cols)) {                                                                           \
-        if (ConjRhs)                                                                                                 \
-          x_tmp = rhs.conjugate();                                                                                   \
-        else                                                                                                         \
-          x_tmp = rhs;                                                                                               \
-        x = x_tmp.data();                                                                                            \
-        if (size < rows) {                                                                                           \
-          y = res_ + size * resIncr;                                                                                 \
-          a = lhs_ + size * lda;                                                                                     \
-          m = convert_index<BlasIndex>(rows - size);                                                                 \
-          n = convert_index<BlasIndex>(size);                                                                        \
-        } else {                                                                                                     \
-          x += size;                                                                                                 \
-          y = res_;                                                                                                  \
-          a = lhs_ + size;                                                                                           \
-          m = convert_index<BlasIndex>(size);                                                                        \
-          n = convert_index<BlasIndex>(cols - size);                                                                 \
-        }                                                                                                            \
-        BLASPREFIX##gemv##BLASPOSTFIX(&trans, &n, &m, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, \
-                                      &lda, (const BLASTYPE*)x, &incx, (const BLASTYPE*)&numext::real_ref(beta),     \
-                                      (BLASTYPE*)y, &incy);                                                          \
-      }                                                                                                              \
-    }                                                                                                                \
+#define EIGEN_BLAS_TRMV_RM(EIGTYPE, BLASTYPE, EIGPREFIX, BLASPREFIX, BLASPOSTFIX)                                  \
+  template <typename Index, int Mode, bool ConjLhs, bool ConjRhs>                                                  \
+  struct triangular_matrix_vector_product_trmv<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, RowMajor> {        \
+    enum {                                                                                                         \
+      IsLower = (Mode & Lower) == Lower,                                                                           \
+      SetDiag = (Mode & (ZeroDiag | UnitDiag)) ? 0 : 1,                                                            \
+      IsUnitDiag = (Mode & UnitDiag) ? 1 : 0,                                                                      \
+      IsZeroDiag = (Mode & ZeroDiag) ? 1 : 0,                                                                      \
+      LowUp = IsLower ? Lower : Upper                                                                              \
+    };                                                                                                             \
+    static void run(Index rows_, Index cols_, const EIGTYPE* lhs_, Index lhsStride, const EIGTYPE* rhs_,           \
+                    Index rhsIncr, EIGTYPE* res_, Index resIncr, EIGTYPE alpha) {                                  \
+      if (rows_ == 0 || cols_ == 0) return;                                                                        \
+      EIGEN_IF_CONSTEXPR (IsZeroDiag) {                                                                            \
+        triangular_matrix_vector_product<Index, Mode, EIGTYPE, ConjLhs, EIGTYPE, ConjRhs, RowMajor, BuiltIn>::run( \
+            rows_, cols_, lhs_, lhsStride, rhs_, rhsIncr, res_, resIncr, alpha);                                   \
+        return;                                                                                                    \
+      }                                                                                                            \
+      Index size = (std::min)(rows_, cols_);                                                                       \
+      Index rows = IsLower ? rows_ : size;                                                                         \
+      Index cols = IsLower ? size : cols_;                                                                         \
+                                                                                                                   \
+      typedef VectorX##EIGPREFIX VectorRhs;                                                                        \
+      EIGTYPE *x, *y;                                                                                              \
+                                                                                                                   \
+      /* Set x*/                                                                                                   \
+      Map<const VectorRhs, 0, InnerStride<> > rhs(rhs_, cols, InnerStride<>(rhsIncr));                             \
+      VectorRhs x_tmp;                                                                                             \
+      EIGEN_IF_CONSTEXPR (ConjRhs)                                                                                 \
+        x_tmp = rhs.conjugate();                                                                                   \
+      else                                                                                                         \
+        x_tmp = rhs;                                                                                               \
+      x = x_tmp.data();                                                                                            \
+                                                                                                                   \
+      /* Square part handling */                                                                                   \
+                                                                                                                   \
+      char trans, uplo, diag;                                                                                      \
+      BlasIndex m, n, lda, incx, incy;                                                                             \
+      EIGTYPE const* a;                                                                                            \
+      EIGTYPE beta(1);                                                                                             \
+                                                                                                                   \
+      /* Set m, n */                                                                                               \
+      n = convert_index<BlasIndex>(size);                                                                          \
+      lda = convert_index<BlasIndex>(lhsStride);                                                                   \
+      incx = 1;                                                                                                    \
+      incy = convert_index<BlasIndex>(resIncr);                                                                    \
+                                                                                                                   \
+      /* Set uplo, trans and diag*/                                                                                \
+      trans = ConjLhs ? 'C' : 'T';                                                                                 \
+      uplo = IsLower ? 'U' : 'L';                                                                                  \
+      diag = IsUnitDiag ? 'U' : 'N';                                                                               \
+                                                                                                                   \
+      /* call ?TRMV*/                                                                                              \
+      EIGEN_CAT(EIGEN_CAT(BLASPREFIX, trmv), BLASPOSTFIX)                                                          \
+      (&uplo, &trans, &diag, &n, (const BLASTYPE*)lhs_, &lda, (BLASTYPE*)x, &incx);                                \
+                                                                                                                   \
+      /* Add op(a_tr)rhs into res*/                                                                                \
+      EIGEN_CAT(EIGEN_CAT(BLASPREFIX, axpy), BLASPOSTFIX)                                                          \
+      (&n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)x, &incx, (BLASTYPE*)res_, &incy);          \
+      /* Non-square case - doesn't fit to BLAS ?TRMV. Fall to default triangular product*/                         \
+      if (size < (std::max)(rows, cols)) {                                                                         \
+        EIGEN_IF_CONSTEXPR (ConjRhs)                                                                               \
+          x_tmp = rhs.conjugate();                                                                                 \
+        else                                                                                                       \
+          x_tmp = rhs;                                                                                             \
+        x = x_tmp.data();                                                                                          \
+        if (size < rows) {                                                                                         \
+          y = res_ + size * resIncr;                                                                               \
+          a = lhs_ + size * lda;                                                                                   \
+          m = convert_index<BlasIndex>(rows - size);                                                               \
+          n = convert_index<BlasIndex>(size);                                                                      \
+        } else {                                                                                                   \
+          x += size;                                                                                               \
+          y = res_;                                                                                                \
+          a = lhs_ + size;                                                                                         \
+          m = convert_index<BlasIndex>(size);                                                                      \
+          n = convert_index<BlasIndex>(cols - size);                                                               \
+        }                                                                                                          \
+        EIGEN_CAT(EIGEN_CAT(BLASPREFIX, gemv), BLASPOSTFIX)                                                        \
+        (&trans, &n, &m, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, &lda, (const BLASTYPE*)x,  \
+         &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)y, &incy);                                    \
+      }                                                                                                            \
+    }                                                                                                              \
   };
 
 #ifdef EIGEN_USE_MKL
@@ -262,10 +265,10 @@
 EIGEN_BLAS_TRMV_RM(float, float, f, s, )
 EIGEN_BLAS_TRMV_RM(scomplex, MKL_Complex8, cf, c, )
 #else
-EIGEN_BLAS_TRMV_RM(double, double, d, d, _)
-EIGEN_BLAS_TRMV_RM(dcomplex, double, cd, z, _)
-EIGEN_BLAS_TRMV_RM(float, float, f, s, _)
-EIGEN_BLAS_TRMV_RM(scomplex, float, cf, c, _)
+EIGEN_BLAS_TRMV_RM(double, double, d, d, EIGEN_BLAS_POSTFIX)
+EIGEN_BLAS_TRMV_RM(dcomplex, double, cd, z, EIGEN_BLAS_POSTFIX)
+EIGEN_BLAS_TRMV_RM(float, float, f, s, EIGEN_BLAS_POSTFIX)
+EIGEN_BLAS_TRMV_RM(scomplex, float, cf, c, EIGEN_BLAS_POSTFIX)
 #endif
 
 #undef EIGEN_BLAS_TRMV_RM
diff --git a/Eigen/src/Core/products/TriangularSolverMatrix.h b/Eigen/src/Core/products/TriangularSolverMatrix.h
index bee971d..03fbe14 100644
--- a/Eigen/src/Core/products/TriangularSolverMatrix.h
+++ b/Eigen/src/Core/products/TriangularSolverMatrix.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_H
 #define EIGEN_TRIANGULAR_SOLVER_MATRIX_H
@@ -23,6 +24,12 @@
 struct trsmKernelL {
   // Generic Implementation of triangular solve for triangular matrix on left and multiple rhs.
   // Handles non-packed matrices.
+  //
+  // A lower-triangular panel is addressed from its top-left element with indices in [0, size);
+  // an upper-triangular one is addressed from its bottom-right element with indices in
+  // (-size, 0]. Both origins are elements of the panel, so callers never form a pointer outside
+  // the matrix they solve in. The AVX-512 specializations take both by the top-left element and
+  // convert when they delegate here.
   static void kernel(Index size, Index otherSize, const Scalar* _tri, Index triStride, Scalar* _other, Index otherIncr,
                      Index otherStride);
 };
@@ -36,14 +43,241 @@
                      Index otherStride);
 };
 
+// The packet lanes are independent right-hand sides. Reserve registers for the
+// RHS packets and coefficient broadcasts in addition to the output accumulators.
+template <typename Scalar>
+struct triangular_solve_packet_traits {
+  static constexpr bool Enabled = packet_traits<Scalar>::Vectorizable &&
+                                  (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value) &&
+                                  std::numeric_limits<Scalar>::is_iec559 && std::numeric_limits<Scalar>::radix == 2;
+  static constexpr int PacketSize = packet_traits<Scalar>::size;
+  static constexpr int RegisterRows = 4;
+  static constexpr int RhsPackets =
+      plain_enum_max(1, plain_enum_min(2, (gebp_traits<Scalar, Scalar>::NumberOfRegisters - 2) / (RegisterRows + 1)));
+  // Allocation bound, independent of the cache-dependent direct-solve cutoff.
+  static constexpr int WorkspaceRows = 128;
+#if defined(EIGEN_VECTORIZE_AVX512) && EIGEN_USE_AVX512_TRSM_L_KERNELS
+  static constexpr bool UseUnblocked = false;
+#else
+  static constexpr bool UseUnblocked = Enabled;
+#endif
+
+  template <typename Index>
+  static EIGEN_STRONG_INLINE bool use_unblocked(Index size, Index cols, std::ptrdiff_t l1) {
+    if (!UseUnblocked || size < RegisterRows || size > WorkspaceRows || cols < PacketSize) return false;
+    const int packets = cols >= RhsPackets * PacketSize ? RhsPackets : 1;
+    // Like GEBP's L1 depth model: the RHS tile, reciprocals, and RegisterRows rows
+    // of A are reused along k. Leave half of L1 for streaming and associativity.
+    const std::ptrdiff_t rowBytes = (packets * PacketSize + RegisterRows + 1) * sizeof(Scalar);
+    const std::ptrdiff_t transposeBytes = PacketSize * PacketSize * sizeof(Scalar);
+    return std::ptrdiff_t(size) * rowBytes + transposeBytes <= l1 / 2;
+  }
+};
+
+template <typename Scalar, typename Index, int Mode, int TriStorageOrder>
+struct triangular_solve_packet_kernel {
+  using Traits = triangular_solve_packet_traits<Scalar>;
+  using Packet = typename packet_traits<Scalar>::type;
+  using TriMapper = const_blas_data_mapper<Scalar, Index, TriStorageOrder>;
+  static constexpr int PacketSize = Traits::PacketSize;
+  static constexpr bool IsLower = (Mode & Lower) != 0;
+
+  template <int RhsPackets>
+  static EIGEN_STRONG_INLINE bool all_finite(const PacketBlock<Packet, RhsPackets>& x, bool_constant<true>) {
+    // Classify bits: fast-math may assume the arithmetic results are finite.
+    using FloatTraits = binary_floating_point_traits<Scalar>;
+    bool nonfinite = false;
+    for (int p = 0; p < RhsPackets; ++p) {
+      Scalar values[PacketSize];
+      pstoreu(values, x.packet[p]);
+      EIGEN_FAST_MATH_CONSTANT_BARRIER(values);
+      for (int c = 0; c < PacketSize; ++c)
+        nonfinite |= (FloatTraits::bits(values[c]) & FloatTraits::kExponentMask) == FloatTraits::kExponentMask;
+    }
+    return !nonfinite;
+  }
+
+  // Keep disabled scalar instantiations valid in C++14.
+  template <int RhsPackets>
+  static EIGEN_STRONG_INLINE bool all_finite(const PacketBlock<Packet, RhsPackets>&, bool_constant<false>) {
+    return true;
+  }
+
+  template <int RhsPackets>
+  static EIGEN_STRONG_INLINE void update(PacketBlock<Packet, RhsPackets>& x, const PacketBlock<Packet, RhsPackets>& y,
+                                         Scalar a) {
+    const Packet pa = pset1<Packet>(a);
+    for (int p = 0; p < RhsPackets; ++p) x.packet[p] = pnmadd(pa, y.packet[p], x.packet[p]);
+  }
+
+  template <int RhsPackets>
+  static EIGEN_STRONG_INLINE void scale(PacketBlock<Packet, RhsPackets>& x, Scalar a) {
+    EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) {
+      const Packet pa = pset1<Packet>(a);
+      for (int p = 0; p < RhsPackets; ++p) x.packet[p] = pmul(x.packet[p], pa);
+    }
+  }
+
+  template <std::size_t Row, int RhsPackets, std::size_t... Next>
+  static EIGEN_STRONG_INLINE void solve_row(PacketBlock<Packet, RhsPackets>* x, const TriMapper& a,
+                                            const Scalar* inverse, Index r0, Index step, std::index_sequence<Next...>) {
+    const Index row = r0 + Index(Row) * step;
+    scale(x[Row], inverse[row]);
+    int unroll[] = {0, (update(x[Row + 1 + Next], x[Row], a(r0 + Index(Row + 1 + Next) * step, row)), 0)...};
+    EIGEN_UNUSED_VARIABLE(unroll);
+  }
+
+  // GCC generates extra instructions when the accumulator indices come from a loop.
+  template <int RhsPackets, std::size_t... Rows>
+  static EIGEN_STRONG_INLINE void solve_block(Index i, const TriMapper& a, const Scalar* inverse,
+                                              PacketBlock<Packet, RhsPackets>* work, Index r0, Index step,
+                                              std::index_sequence<Rows...>) {
+    PacketBlock<Packet, RhsPackets> x[] = {work[r0 + Index(Rows) * step]...};
+    for (Index k = 0; k < i; ++k) {
+      const Index c = IsLower ? k : r0 + i - k;
+      const PacketBlock<Packet, RhsPackets> y = work[c];
+      int unroll[] = {0, (update(x[Rows], y, a(r0 + Index(Rows) * step, c)), 0)...};
+      EIGEN_UNUSED_VARIABLE(unroll);
+    }
+    // The braced expansion orders the dependent solves by row.
+    int solve_rows[] = {
+        0,
+        (solve_row<Rows>(x, a, inverse, r0, step, std::make_index_sequence<Traits::RegisterRows - Rows - 1>{}), 0)...};
+    EIGEN_UNUSED_VARIABLE(solve_rows);
+    int store_rows[] = {0, (work[r0 + Index(Rows) * step] = x[Rows], 0)...};
+    EIGEN_UNUSED_VARIABLE(store_rows);
+  }
+
+  template <int RhsPackets>
+  static EIGEN_STRONG_INLINE void solve(Index size, const TriMapper& a, const Scalar* inverse, Scalar* other,
+                                        Index otherStride) {
+    PacketBlock<Packet, RhsPackets> work[Traits::WorkspaceRows];
+    for (int p = 0; p < RhsPackets; ++p) {
+      Index row = 0;
+      for (; row + PacketSize <= size; row += PacketSize) {
+        PacketBlock<Packet, PacketSize> block;
+        for (int c = 0; c < PacketSize; ++c)
+          block.packet[c] = ploadu<Packet>(other + row + (p * PacketSize + c) * otherStride);
+        ptranspose(block);
+        for (int r = 0; r < PacketSize; ++r) work[row + r].packet[p] = block.packet[r];
+      }
+      for (; row < size; ++row)
+        work[row].packet[p] = pgather<Scalar, Packet>(other + row + p * PacketSize * otherStride, otherStride);
+    }
+    Index i = 0;
+    const Index step = IsLower ? 1 : -1;
+    for (; i + Traits::RegisterRows <= size; i += Traits::RegisterRows) {
+      const Index r0 = IsLower ? i : size - i - 1;
+      // Preserve the four-row schedule that keeps GCC and Clang's hot loops compact.
+      EIGEN_IF_CONSTEXPR (Traits::RegisterRows == 4) {
+        const Index r1 = r0 + step, r2 = r1 + step, r3 = r2 + step;
+        PacketBlock<Packet, RhsPackets> x0 = work[r0], x1 = work[r1], x2 = work[r2], x3 = work[r3];
+        for (Index k = 0; k < i; ++k) {
+          const Index c = IsLower ? k : size - k - 1;
+          const PacketBlock<Packet, RhsPackets> y = work[c];
+          update(x0, y, a(r0, c));
+          update(x1, y, a(r1, c));
+          update(x2, y, a(r2, c));
+          update(x3, y, a(r3, c));
+        }
+        scale(x0, inverse[r0]);
+        update(x1, x0, a(r1, r0));
+        update(x2, x0, a(r2, r0));
+        update(x3, x0, a(r3, r0));
+        scale(x1, inverse[r1]);
+        update(x2, x1, a(r2, r1));
+        update(x3, x1, a(r3, r1));
+        scale(x2, inverse[r2]);
+        update(x3, x2, a(r3, r2));
+        scale(x3, inverse[r3]);
+        work[r0] = x0;
+        work[r1] = x1;
+        work[r2] = x2;
+        work[r3] = x3;
+      } else {
+        solve_block(i, a, inverse, work, r0, step, std::make_index_sequence<Traits::RegisterRows>{});
+      }
+    }
+    for (; i < size; ++i) {
+      const Index r = IsLower ? i : size - i - 1;
+      PacketBlock<Packet, RhsPackets> x = work[r];
+      for (Index k = 0; k < i; ++k) {
+        const Index c = IsLower ? k : size - k - 1;
+        update(x, work[c], a(r, c));
+      }
+      scale(x, inverse[r]);
+      work[r] = x;
+    }
+    EIGEN_IF_CONSTEXPR (TriStorageOrder == RowMajor) {
+      // Successive RHS updates can overflow before cancellation in a row's dot product.
+      // Every later row uses all solved rows, propagating nonfinite lanes to the final row.
+      // Retry with the original accumulation order before overwriting any RHS coefficient.
+      if (!all_finite(work[IsLower ? size - 1 : 0], bool_constant<Traits::Enabled>{})) {
+        const Index origin = IsLower ? 0 : size - 1;
+        trsmKernelL<Scalar, Index, Mode, false, TriStorageOrder, 1, false>::kernel(
+            size, Index(RhsPackets * PacketSize), &a(origin, origin), a.stride(), other + origin, Index(1),
+            otherStride);
+        return;
+      }
+    }
+    for (int p = 0; p < RhsPackets; ++p) {
+      Index row = 0;
+      for (; row + PacketSize <= size; row += PacketSize) {
+        PacketBlock<Packet, PacketSize> block;
+        for (int r = 0; r < PacketSize; ++r) block.packet[r] = work[row + r].packet[p];
+        ptranspose(block);
+        for (int c = 0; c < PacketSize; ++c) pstoreu(other + row + (p * PacketSize + c) * otherStride, block.packet[c]);
+      }
+      for (; row < size; ++row)
+        pscatter<Scalar, Packet>(other + row + p * PacketSize * otherStride, work[row].packet[p], otherStride);
+    }
+  }
+
+  static EIGEN_DONT_INLINE void kernel(Index size, Index cols, const Scalar* tri, Index triStride, Scalar* other,
+                                       Index otherStride) {
+    eigen_internal_assert(size <= Traits::WorkspaceRows && cols % PacketSize == 0);
+    EIGEN_IF_CONSTEXPR (!IsLower) {
+      tri -= (size - 1) * (triStride + 1);
+      other -= size - 1;
+    }
+    TriMapper a(tri, triStride);
+    Scalar inverse[Traits::WorkspaceRows];
+    Map<Vector<Scalar, Dynamic>> mapped(inverse, size);
+    EIGEN_IF_CONSTEXPR (Mode & UnitDiag) {
+      mapped.setOnes();
+    } else {
+      const Map<const Vector<Scalar, Dynamic>, Unaligned, InnerStride<Dynamic>> diagonal(
+          tri, size, InnerStride<Dynamic>(triStride + 1));
+      mapped = diagonal.cwiseInverse();
+    }
+    Index j = 0;
+    EIGEN_IF_CONSTEXPR (Traits::RhsPackets > 1) {
+      for (; j + Traits::RhsPackets * PacketSize <= cols; j += Traits::RhsPackets * PacketSize)
+        solve<Traits::RhsPackets>(size, a, inverse, other + j * otherStride, otherStride);
+    }
+    for (; j + PacketSize <= cols; j += PacketSize) solve<1>(size, a, inverse, other + j * otherStride, otherStride);
+  }
+};
+
 template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride,
           bool Specialized>
 EIGEN_STRONG_INLINE void trsmKernelL<Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride,
                                      Specialized>::kernel(Index size, Index otherSize, const Scalar* _tri,
                                                           Index triStride, Scalar* _other, Index otherIncr,
                                                           Index otherStride) {
-  typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
-  typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> OtherMapper;
+  EIGEN_IF_CONSTEXPR ((Specialized && OtherInnerStride == 1 && triangular_solve_packet_traits<Scalar>::Enabled)) {
+    if (size >= triangular_solve_packet_traits<Scalar>::RegisterRows &&
+        size <= triangular_solve_packet_traits<Scalar>::WorkspaceRows && otherSize >= packet_traits<Scalar>::size) {
+      const Index packetCols = numext::round_down(otherSize, Index(packet_traits<Scalar>::size));
+      triangular_solve_packet_kernel<Scalar, Index, Mode, TriStorageOrder>::kernel(size, packetCols, _tri, triStride,
+                                                                                   _other, otherStride);
+      if (packetCols == otherSize) return;
+      otherSize -= packetCols;
+      _other += packetCols * otherStride;
+    }
+  }
+  using TriMapper = const_blas_data_mapper<Scalar, Index, TriStorageOrder>;
+  using OtherMapper = blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride>;
   TriMapper tri(_tri, triStride);
   OtherMapper other(_other, otherStride, otherIncr);
 
@@ -53,13 +287,13 @@
   // tr solve
   for (Index k = 0; k < size; ++k) {
     // TODO: write a small kernel handling this (can be shared with trsv)
-    Index i = IsLower ? k : -k - 1;
+    Index i = IsLower ? k : -k;
     Index rs = size - k - 1;  // remaining size
     Index s = TriStorageOrder == RowMajor ? (IsLower ? 0 : i + 1) : IsLower ? i + 1 : i - rs;
 
     Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(Scalar(1) / conj(tri(i, i)));
     for (Index j = 0; j < otherSize; ++j) {
-      if (TriStorageOrder == RowMajor) {
+      EIGEN_IF_CONSTEXPR (TriStorageOrder == RowMajor) {
         Scalar b(0);
         const Scalar* l = &tri(i, s);
         typename OtherMapper::LinearMapper r = other.getLinearMapper(s, j);
@@ -84,20 +318,20 @@
                                      Specialized>::kernel(Index size, Index otherSize, const Scalar* _tri,
                                                           Index triStride, Scalar* _other, Index otherIncr,
                                                           Index otherStride) {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> LhsMapper;
-  typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using LhsMapper = blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride>;
+  using RhsMapper = const_blas_data_mapper<Scalar, Index, TriStorageOrder>;
   LhsMapper lhs(_other, otherStride, otherIncr);
   RhsMapper rhs(_tri, triStride);
 
-  enum { RhsStorageOrder = TriStorageOrder, IsLower = (Mode & Lower) == Lower };
+  enum { IsLower = (Mode & Lower) == Lower };
   conj_if<Conjugate> conj;
 
   for (Index k = 0; k < size; ++k) {
     Index j = IsLower ? size - k - 1 : k;
 
     typename LhsMapper::LinearMapper r = lhs.getLinearMapper(0, j);
-    EIGEN_IF_CONSTEXPR(OtherInnerStride == 1 && packet_traits<Scalar>::Vectorizable) {
+    EIGEN_IF_CONSTEXPR (OtherInnerStride == 1 && packet_traits<Scalar>::Vectorizable) {
       using Packet = typename packet_traits<Scalar>::type;
       constexpr Index PS = unpacket_traits<Packet>::size;
       // Unrolled k3 loop by 4 to reduce r load/store traffic.
@@ -143,7 +377,7 @@
         for (; i < otherSize; ++i) r(i) -= a(i) * b;
       }
       // Vectorized diagonal scaling.
-      EIGEN_IF_CONSTEXPR((Mode & UnitDiag) == 0) {
+      EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == 0) {
         Scalar inv_rjj = RealScalar(1) / conj(rhs(j, j));
         Packet pinv = pset1<Packet>(inv_rjj);
         Index i = 0;
@@ -152,14 +386,13 @@
         }
         for (; i < otherSize; ++i) r(i) *= inv_rjj;
       }
-    }
-    else {
+    } else {
       for (Index k3 = 0; k3 < k; ++k3) {
         Scalar b = conj(rhs(IsLower ? j + 1 + k3 : k3, j));
         typename LhsMapper::LinearMapper a = lhs.getLinearMapper(0, IsLower ? j + 1 + k3 : k3);
         for (Index i = 0; i < otherSize; ++i) r(i) -= a(i) * b;
       }
-      EIGEN_IF_CONSTEXPR((Mode & UnitDiag) == 0) {
+      EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == 0) {
         Scalar inv_rjj = RealScalar(1) / conj(rhs(j, j));
         for (Index i = 0; i < otherSize; ++i) r(i) *= inv_rjj;
       }
@@ -180,6 +413,52 @@
   }
 };
 
+/** \internal Entries of the solved operand a blocked triangular solve may keep in cache while its
+ * k-blocks sweep it: a quarter of the L3, which on a multi-die part is the package total of which one
+ * core reaches a fraction, and never less than the L2. */
+template <typename Scalar>
+std::ptrdiff_t triangular_solve_budget(std::ptrdiff_t l2, std::ptrdiff_t l3) {
+  return (numext::maxi)(l3 / 4, l2) / std::ptrdiff_t(sizeof(Scalar));
+}
+
+/** \internal Columns of the right-hand side a solve on the left takes per panel: the widest multiple
+ * of nr whose size x nc entries fit the budget, or all cols. Every panel re-packs the triangle,
+ * size^2/2 copies against size^2*nc/2 multiply-adds, and panels narrower than 512 columns measured
+ * slower than none, so a right-hand side that would need them is solved whole. */
+template <typename Index>
+Index triangular_solve_panel_columns(Index size, Index cols, std::ptrdiff_t budget, Index nr) {
+  eigen_internal_assert(size > 0);
+  const std::ptrdiff_t width = numext::round_down<std::ptrdiff_t>(budget / size, nr);
+  return width >= 512 && width < cols ? Index(width) : cols;
+}
+
+/** \internal Depth of the k-blocks of a solve against otherSize columns (on the left) or rows (on the
+ * right), whose packed buffers hold kc x extent entries. The KcFactor 4 depth SolveTriangular.h blocks
+ * with keeps the share of flops in the kc x kc diagonal blocks, which run below gebp's rate, near
+ * kc/size. Every k-block also sweeps the operand and packs a slab of the triangle, costs that scale as
+ * 1/kc and outweigh that share once the operand exceeds the budget or, for a slab packed one column
+ * run at a time (slabRuns), once half the triangle does. The depth then grows toward the
+ * single-threaded GEMM depth, no further than size/8 and 160, where deeper diagonal blocks measured
+ * slower than the sweeps they save (by up to 10% at the GEMM depth in AVX2 builds), and, when the
+ * buffers fit on the stack at the blocking's depth, no further than the depth at which they still do.
+ * A caller that preallocated the buffers sized them for the blocking's depth. */
+template <typename Scalar, typename Index>
+Index triangular_solve_kc(Index size, Index otherSize, Index extent, std::ptrdiff_t budget, bool slabRuns,
+                          level3_blocking<Scalar, Scalar>& blocking) {
+  EIGEN_UNUSED_VARIABLE(extent);
+  const bool deep = std::ptrdiff_t(size) * otherSize > budget || (slabRuns && std::ptrdiff_t(size) * size / 2 > budget);
+  if (!deep || blocking.blockA() != nullptr) return blocking.kc();
+  Index kc = size, mc = size, nc = otherSize;
+  computeProductBlockingSizes<Scalar, Scalar>(kc, mc, nc);
+  kc = (numext::mini)(kc, numext::round_down((numext::mini)(size / 8, Index(160)), Index(8)));
+#if defined(EIGEN_ALLOCA) && !defined(EIGEN_NO_ALLOCA)
+  const std::ptrdiff_t stackKc =
+      std::ptrdiff_t(EIGEN_STACK_ALLOCATION_LIMIT) / (std::ptrdiff_t(sizeof(Scalar)) * extent);
+  if (blocking.kc() <= stackKc) kc = Index((numext::mini)(std::ptrdiff_t(kc), stackKc));
+#endif
+  return (numext::maxi)(kc, blocking.kc());
+}
+
 /* Optimized triangular solver with multiple right hand side and the triangular matrix on the left
  */
 template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder, int OtherInnerStride>
@@ -194,41 +473,56 @@
                                                                       Index triStride, Scalar* _other, Index otherIncr,
                                                                       Index otherStride,
                                                                       level3_blocking<Scalar, Scalar>& blocking) {
-  Index cols = otherSize;
-
   std::ptrdiff_t l1, l2, l3;
   manage_caching_sizes(GetAction, &l1, &l2, &l3);
-
+  EIGEN_IF_CONSTEXPR ((OtherInnerStride == 1 && triangular_solve_packet_traits<Scalar>::Enabled)) {
+    using PacketTraits = triangular_solve_packet_traits<Scalar>;
+    if (PacketTraits::use_unblocked(size, otherSize, l1)) {
+      const Index origin = (Mode & Lower) ? 0 : size - 1;
+      trsmKernelL<Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride, true>::kernel(
+          size, otherSize, _tri + origin * (triStride + 1), triStride, _other + origin, otherIncr, otherStride);
+      return;
+    }
+  }
 #if defined(EIGEN_VECTORIZE_AVX512) && defined(EIGEN_USE_AVX512_TRSM_L_KERNELS) && EIGEN_USE_AVX512_TRSM_L_KERNELS && \
     EIGEN_ENABLE_AVX512_NOCOPY_TRSM_L_CUTOFFS
-  EIGEN_IF_CONSTEXPR(
-      (OtherInnerStride == 1 && (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value))) {
+  EIGEN_IF_CONSTEXPR ((OtherInnerStride == 1 &&
+                       (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value))) {
     // Very rough cutoffs to determine when to call trsm w/o packing
     // For small problem sizes trsmKernel compiled with clang is generally faster.
     // TODO: Investigate better heuristics for cutoffs.
     double L2Cap = 0.5;  // 50% of L2 size
-    if (size < avx512_trsm_cutoff<Scalar>(l2, cols, L2Cap)) {
+    if (size < avx512_trsm_cutoff<Scalar>(l2, otherSize, L2Cap)) {
       trsmKernelL<Scalar, Index, Mode, Conjugate, TriStorageOrder, 1, /*Specialized=*/true>::kernel(
-          size, cols, _tri, triStride, _other, 1, otherStride);
+          size, otherSize, _tri, triStride, _other, 1, otherStride);
       return;
     }
   }
 #endif
 
-  typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
-  typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> OtherMapper;
+  using TriMapper = const_blas_data_mapper<Scalar, Index, TriStorageOrder>;
+  using OtherMapper = blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride>;
   TriMapper tri(_tri, triStride);
-  OtherMapper other(_other, otherStride, otherIncr);
 
-  typedef gebp_traits<Scalar, Scalar> Traits;
+  using Traits = gebp_traits<Scalar, Scalar>;
 
   enum { SmallPanelWidth = plain_enum_max(Traits::mr, Traits::nr), IsLower = (Mode & Lower) == Lower };
 
-  Index kc = blocking.kc();                    // cache block size along the K direction
-  Index mc = (std::min)(size, blocking.mc());  // cache block size along the M direction
+  // Every k-block updates the rows of the right-hand side beyond it through gebp, so a right-hand side
+  // solved whole streams through the caches size/kc times (issue #3162); column panels that stay in
+  // cache keep those sweeps out of memory. This kernel packs the slabs of the triangle by rows, which
+  // costs more the deeper they are, so a large triangle alone does not deepen it.
+  const std::ptrdiff_t budget = triangular_solve_budget<Scalar>(l2, l3);
+  const Index nc = triangular_solve_panel_columns(size, otherSize, budget, Index(Traits::nr));
+  const Index mc = (numext::mini)(size, blocking.mc());  // cache block size along the M direction
+  // The tr solve below packs up to SmallPanelWidth x kc entries of the triangle into blockA.
+  const Index blockARows = (numext::maxi)(mc, Index(SmallPanelWidth));
+  // cache block size along the K direction
+  const Index kc = triangular_solve_kc<Scalar>(size, otherSize, (numext::maxi)(blockARows, nc), budget,
+                                               /*slabRuns=*/false, blocking);
 
-  std::size_t sizeA = kc * mc;
-  std::size_t sizeB = kc * cols;
+  std::size_t sizeA = kc * blockARows;
+  std::size_t sizeB = kc * nc;
 
   ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
   ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
@@ -239,76 +533,84 @@
       pack_lhs;
   gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
 
-  // the goal here is to subdivise the Rhs panels such that we keep some cache
+  // the goal here is to subdivide the Rhs panels such that we keep some cache
   // coherence when accessing the rhs elements
-  Index subcols = cols > 0 ? l2 / (4 * sizeof(Scalar) * std::max<Index>(otherStride, size)) : 0;
-  subcols = std::max<Index>((subcols / Traits::nr) * Traits::nr, Traits::nr);
+  Index subcols = otherSize > 0 ? l2 / (4 * sizeof(Scalar) * numext::maxi<Index>(otherStride, size)) : 0;
+  subcols = numext::maxi<Index>((subcols / Traits::nr) * Traits::nr, Traits::nr);
 
-  for (Index k2 = IsLower ? 0 : size; IsLower ? k2 < size : k2 > 0; IsLower ? k2 += kc : k2 -= kc) {
-    const Index actual_kc = (std::min)(IsLower ? size - k2 : k2, kc);
+  for (Index j0 = 0; j0 < otherSize; j0 += nc) {
+    const Index cols = (numext::mini)(otherSize - j0, nc);
+    Scalar* _panel = _other + j0 * otherStride;
+    OtherMapper other(_panel, otherStride, otherIncr);
 
-    // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
-    // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
-    // A11 (the triangular part) and A21 the remaining rectangular part.
-    // Then the high level algorithm is:
-    //  - B = R1                    => general block copy (done during the next step)
-    //  - R1 = A11^-1 B             => tricky part
-    //  - update B from the new R1  => actually this has to be performed continuously during the above step
-    //  - R2 -= A21 * B             => GEPP
+    for (Index k2 = IsLower ? 0 : size; IsLower ? k2 < size : k2 > 0; IsLower ? k2 += kc : k2 -= kc) {
+      const Index actual_kc = (numext::mini)(IsLower ? size - k2 : k2, kc);
 
-    // The tricky part: compute R1 = A11^-1 B while updating B from R1
-    // The idea is to split A11 into multiple small vertical panels.
-    // Each panel can be split into a small triangular part T1k which is processed without optimization,
-    // and the remaining small part T2k which is processed using gebp with appropriate block strides
-    for (Index j2 = 0; j2 < cols; j2 += subcols) {
-      Index actual_cols = (std::min)(cols - j2, subcols);
-      // for each small vertical panels [T1k^T, T2k^T]^T of lhs
-      for (Index k1 = 0; k1 < actual_kc; k1 += SmallPanelWidth) {
-        Index actualPanelWidth = std::min<Index>(actual_kc - k1, SmallPanelWidth);
-        // tr solve
-        {
-          Index i = IsLower ? k2 + k1 : k2 - k1;
+      // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
+      // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
+      // A11 (the triangular part) and A21 the remaining rectangular part.
+      // Then the high level algorithm is:
+      //  - B = R1                    => general block copy (done during the next step)
+      //  - R1 = A11^-1 B             => tricky part
+      //  - update B from the new R1  => actually this has to be performed continuously during the above step
+      //  - R2 -= A21 * B             => GEPP
+
+      // The tricky part: compute R1 = A11^-1 B while updating B from R1
+      // The idea is to split A11 into multiple small vertical panels.
+      // Each panel can be split into a small triangular part T1k which is processed without optimization,
+      // and the remaining small part T2k which is processed using gebp with appropriate block strides
+      for (Index j2 = 0; j2 < cols; j2 += subcols) {
+        Index actual_cols = (numext::mini)(cols - j2, subcols);
+        // for each small vertical panels [T1k^T, T2k^T]^T of lhs
+        for (Index k1 = 0; k1 < actual_kc; k1 += SmallPanelWidth) {
+          Index actualPanelWidth = numext::mini<Index>(actual_kc - k1, SmallPanelWidth);
+          // tr solve
+          {
+            Index i = IsLower ? k2 + k1 : k2 - k1 - 1;
 #if defined(EIGEN_VECTORIZE_AVX512) && defined(EIGEN_USE_AVX512_TRSM_L_KERNELS) && EIGEN_USE_AVX512_TRSM_L_KERNELS
-          EIGEN_IF_CONSTEXPR(
-              (OtherInnerStride == 1 && (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value))) {
-            i = IsLower ? k2 + k1 : k2 - k1 - actualPanelWidth;
-          }
+            EIGEN_IF_CONSTEXPR ((OtherInnerStride == 1 &&
+                                 (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value))) {
+              i = IsLower ? k2 + k1 : k2 - k1 - actualPanelWidth;
+            }
 #endif
-          trsmKernelL<Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride, /*Specialized=*/true>::kernel(
-              actualPanelWidth, actual_cols, _tri + i + (i)*triStride, triStride,
-              _other + i * OtherInnerStride + j2 * otherStride, otherIncr, otherStride);
-        }
+            trsmKernelL<Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride,
+                        /*Specialized=*/true>::kernel(actualPanelWidth, actual_cols, _tri + i + (i)*triStride,
+                                                      triStride, _panel + i * otherIncr + j2 * otherStride, otherIncr,
+                                                      otherStride);
+          }
 
-        Index lengthTarget = actual_kc - k1 - actualPanelWidth;
-        Index startBlock = IsLower ? k2 + k1 : k2 - k1 - actualPanelWidth;
-        Index blockBOffset = IsLower ? k1 : lengthTarget;
+          Index lengthTarget = actual_kc - k1 - actualPanelWidth;
+          Index startBlock = IsLower ? k2 + k1 : k2 - k1 - actualPanelWidth;
+          Index blockBOffset = IsLower ? k1 : lengthTarget;
 
-        // update the respective rows of B from other
-        pack_rhs(blockB + actual_kc * j2, other.getSubMapper(startBlock, j2), actualPanelWidth, actual_cols, actual_kc,
-                 blockBOffset);
+          // update the respective rows of B from other
+          pack_rhs(blockB + actual_kc * j2, other.getSubMapper(startBlock, j2), actualPanelWidth, actual_cols,
+                   actual_kc, blockBOffset);
 
-        // GEBP
-        if (lengthTarget > 0) {
-          Index startTarget = IsLower ? k2 + k1 + actualPanelWidth : k2 - actual_kc;
+          // GEBP
+          if (lengthTarget > 0) {
+            Index startTarget = IsLower ? k2 + k1 + actualPanelWidth : k2 - actual_kc;
 
-          pack_lhs(blockA, tri.getSubMapper(startTarget, startBlock), actualPanelWidth, lengthTarget);
+            pack_lhs(blockA, tri.getSubMapper(startTarget, startBlock), actualPanelWidth, lengthTarget);
 
-          gebp_kernel(other.getSubMapper(startTarget, j2), blockA, blockB + actual_kc * j2, lengthTarget,
-                      actualPanelWidth, actual_cols, Scalar(-1), actualPanelWidth, actual_kc, 0, blockBOffset);
+            gebp_kernel(other.getSubMapper(startTarget, j2), blockA, blockB + actual_kc * j2, lengthTarget,
+                        actualPanelWidth, actual_cols, Scalar(-1), actualPanelWidth, actual_kc, 0, blockBOffset);
+          }
         }
       }
-    }
 
-    // R2 -= A21 * B => GEPP
-    {
-      Index start = IsLower ? k2 + kc : 0;
-      Index end = IsLower ? size : k2 - kc;
-      for (Index i2 = start; i2 < end; i2 += mc) {
-        const Index actual_mc = (std::min)(mc, end - i2);
-        if (actual_mc > 0) {
-          pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2 - kc), actual_kc, actual_mc);
+      // R2 -= A21 * B => GEPP
+      {
+        Index start = IsLower ? k2 + kc : 0;
+        Index end = IsLower ? size : k2 - kc;
+        for (Index i2 = start; i2 < end; i2 += mc) {
+          const Index actual_mc = (numext::mini)(mc, end - i2);
+          if (actual_mc > 0) {
+            pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2 - kc), actual_kc, actual_mc);
 
-          gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
+            gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0,
+                        0);
+          }
         }
       }
     }
@@ -332,13 +634,14 @@
                                                                       level3_blocking<Scalar, Scalar>& blocking) {
   Index rows = otherSize;
 
+  std::ptrdiff_t l1, l2, l3;
+  manage_caching_sizes(GetAction, &l1, &l2, &l3);
+
 #if defined(EIGEN_VECTORIZE_AVX512) && defined(EIGEN_USE_AVX512_TRSM_R_KERNELS) && EIGEN_USE_AVX512_TRSM_R_KERNELS && \
     EIGEN_ENABLE_AVX512_NOCOPY_TRSM_R_CUTOFFS
-  EIGEN_IF_CONSTEXPR(
-      (OtherInnerStride == 1 && (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value))) {
+  EIGEN_IF_CONSTEXPR ((OtherInnerStride == 1 &&
+                       (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value))) {
     // TODO: Investigate better heuristics for cutoffs.
-    std::ptrdiff_t l1, l2, l3;
-    manage_caching_sizes(GetAction, &l1, &l2, &l3);
     double L2Cap = 0.5;  // 50% of L2 size
     if (size < avx512_trsm_cutoff<Scalar>(l2, rows, L2Cap)) {
       trsmKernelR<Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride, /*Specialized=*/true>::kernel(
@@ -348,20 +651,33 @@
   }
 #endif
 
-  typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> LhsMapper;
-  typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
+  using LhsMapper = blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride>;
+  using RhsMapper = const_blas_data_mapper<Scalar, Index, TriStorageOrder>;
   LhsMapper lhs(_other, otherStride, otherIncr);
   RhsMapper rhs(_tri, triStride);
 
-  typedef gebp_traits<Scalar, Scalar> Traits;
+  using Traits = gebp_traits<Scalar, Scalar>;
   enum {
     RhsStorageOrder = TriStorageOrder,
     SmallPanelWidth = plain_enum_max(Traits::mr, Traits::nr),
     IsLower = (Mode & Lower) == Lower
   };
 
-  Index kc = blocking.kc();                    // cache block size along the K direction
-  Index mc = (std::min)(rows, blocking.mc());  // cache block size along the M direction
+  // Every k-block sweeps all rows of the left-hand side through gebp and packs its slab of a
+  // column-major triangle one column run at a time, so a large triangle alone deepens this kernel
+  // (issue #3162); a row-major triangle is packed by rows, as on the left.
+  const std::ptrdiff_t budget = triangular_solve_budget<Scalar>(l2, l3);
+  Index mc = (numext::mini)(rows, blocking.mc());  // cache block size along the M direction
+  // cache block size along the K direction
+  const Index kc = triangular_solve_kc<Scalar>(size, rows, (numext::maxi)(mc, size), budget,
+                                               /*slabRuns=*/TriStorageOrder == ColMajor, blocking);
+  // blockA packs kc x mc entries of the left-hand side, and rows can far exceed size. Past half the
+  // budget a deeper kc takes proportionally fewer rows per pass, so blockA does not outgrow the buffer
+  // the blocking chose.
+  if (kc > blocking.kc()) {
+    const std::ptrdiff_t maxA = (numext::maxi)(std::ptrdiff_t(blocking.kc()) * mc, budget / 2);
+    mc = (numext::mini)(mc, (numext::maxi)(Index(Traits::mr), numext::round_down(Index(maxA / kc), Index(Traits::mr))));
+  }
 
   std::size_t sizeA = kc * mc;
   std::size_t sizeB = kc * size;
@@ -377,7 +693,7 @@
       pack_lhs_panel;
 
   for (Index k2 = IsLower ? size : 0; IsLower ? k2 > 0 : k2 < size; IsLower ? k2 -= kc : k2 += kc) {
-    const Index actual_kc = (std::min)(IsLower ? k2 : size - k2, kc);
+    const Index actual_kc = (numext::mini)(IsLower ? k2 : size - k2, kc);
     Index actual_k2 = IsLower ? k2 - actual_kc : k2;
 
     Index startPanel = IsLower ? 0 : k2 + actual_kc;
@@ -390,7 +706,7 @@
     // neglecting the blocks overlapping the diagonal
     {
       for (Index j2 = 0; j2 < actual_kc; j2 += SmallPanelWidth) {
-        Index actualPanelWidth = std::min<Index>(actual_kc - j2, SmallPanelWidth);
+        Index actualPanelWidth = numext::mini<Index>(actual_kc - j2, SmallPanelWidth);
         Index actual_j2 = actual_k2 + j2;
         Index panelOffset = IsLower ? j2 + actualPanelWidth : 0;
         Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
@@ -402,7 +718,7 @@
     }
 
     for (Index i2 = 0; i2 < rows; i2 += mc) {
-      const Index actual_mc = (std::min)(mc, rows - i2);
+      const Index actual_mc = (numext::mini)(mc, rows - i2);
 
       // triangular solver kernel
       {
@@ -411,7 +727,7 @@
                                                                               : Index(SmallPanelWidth)))
                                 : 0;
              IsLower ? j2 >= 0 : j2 < actual_kc; IsLower ? j2 -= SmallPanelWidth : j2 += SmallPanelWidth) {
-          Index actualPanelWidth = std::min<Index>(actual_kc - j2, SmallPanelWidth);
+          Index actualPanelWidth = numext::mini<Index>(actual_kc - j2, SmallPanelWidth);
           Index absolute_j2 = actual_k2 + j2;
           Index panelOffset = IsLower ? j2 + actualPanelWidth : 0;
           Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
@@ -428,8 +744,8 @@
             trsmKernelR<Scalar, Index, Mode, Conjugate, TriStorageOrder, OtherInnerStride,
                         /*Specialized=*/true>::kernel(actualPanelWidth, actual_mc,
                                                       _tri + absolute_j2 + absolute_j2 * triStride, triStride,
-                                                      _other + i2 * OtherInnerStride + absolute_j2 * otherStride,
-                                                      otherIncr, otherStride);
+                                                      _other + i2 * otherIncr + absolute_j2 * otherStride, otherIncr,
+                                                      otherStride);
           }
           // pack the just computed part of lhs to A
           pack_lhs_panel(blockA, lhs.getSubMapper(i2, absolute_j2), actualPanelWidth, actual_mc, actual_kc, j2);
diff --git a/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h b/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
index 20c8f20..9e7407e 100644
--- a/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
+++ b/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
@@ -26,9 +26,10 @@
 
  ********************************************************************************
  *   Content : Eigen bindings to BLAS F77
- *   Triangular matrix * matrix product functionality based on ?TRMM.
+ *   Triangular matrix-matrix solve functionality based on ?TRSM.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
 #define EIGEN_TRIANGULAR_SOLVER_MATRIX_BLAS_H
@@ -66,13 +67,15 @@
       transa = (TriStorageOrder == RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N';                                     \
       /* Set uplo */                                                                                                \
       uplo = IsLower ? 'L' : 'U';                                                                                   \
-      if (TriStorageOrder == RowMajor) uplo = (uplo == 'L') ? 'U' : 'L';                                            \
+      EIGEN_IF_CONSTEXPR (TriStorageOrder == RowMajor) {                                                            \
+        uplo = (uplo == 'L') ? 'U' : 'L';                                                                           \
+      }                                                                                                             \
       /* Set a, lda */                                                                                              \
       typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri;                                         \
       Map<const MatrixTri, 0, OuterStride<> > tri(_tri, size, size, OuterStride<>(triStride));                      \
       MatrixTri a_tmp;                                                                                              \
                                                                                                                     \
-      if (conjA) {                                                                                                  \
+      EIGEN_IF_CONSTEXPR (conjA) {                                                                                  \
         a_tmp = tri.conjugate();                                                                                    \
         a = a_tmp.data();                                                                                           \
         lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                        \
@@ -80,7 +83,9 @@
         a = _tri;                                                                                                   \
         lda = convert_index<BlasIndex>(triStride);                                                                  \
       }                                                                                                             \
-      if (IsUnitDiag) diag = 'U';                                                                                   \
+      EIGEN_IF_CONSTEXPR (IsUnitDiag) {                                                                             \
+        diag = 'U';                                                                                                 \
+      }                                                                                                             \
       /* call ?trsm*/                                                                                               \
       BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, \
                &lda, (BLASTYPE*)_other, &ldb);                                                                      \
@@ -93,10 +98,10 @@
 EIGEN_BLAS_TRSM_L(float, float, strsm)
 EIGEN_BLAS_TRSM_L(scomplex, MKL_Complex8, ctrsm)
 #else
-EIGEN_BLAS_TRSM_L(double, double, dtrsm_)
-EIGEN_BLAS_TRSM_L(dcomplex, double, ztrsm_)
-EIGEN_BLAS_TRSM_L(float, float, strsm_)
-EIGEN_BLAS_TRSM_L(scomplex, float, ctrsm_)
+EIGEN_BLAS_TRSM_L(double, double, EIGEN_BLAS_SYM(dtrsm))
+EIGEN_BLAS_TRSM_L(dcomplex, double, EIGEN_BLAS_SYM(ztrsm))
+EIGEN_BLAS_TRSM_L(float, float, EIGEN_BLAS_SYM(strsm))
+EIGEN_BLAS_TRSM_L(scomplex, float, EIGEN_BLAS_SYM(ctrsm))
 #endif
 
 // implements RightSide general * op(triangular)^-1
@@ -125,13 +130,15 @@
       transa = (TriStorageOrder == RowMajor) ? ((Conjugate) ? 'C' : 'T') : 'N';                                     \
       /* Set uplo */                                                                                                \
       uplo = IsLower ? 'L' : 'U';                                                                                   \
-      if (TriStorageOrder == RowMajor) uplo = (uplo == 'L') ? 'U' : 'L';                                            \
+      EIGEN_IF_CONSTEXPR (TriStorageOrder == RowMajor) {                                                            \
+        uplo = (uplo == 'L') ? 'U' : 'L';                                                                           \
+      }                                                                                                             \
       /* Set a, lda */                                                                                              \
       typedef Matrix<EIGTYPE, Dynamic, Dynamic, TriStorageOrder> MatrixTri;                                         \
       Map<const MatrixTri, 0, OuterStride<> > tri(_tri, size, size, OuterStride<>(triStride));                      \
       MatrixTri a_tmp;                                                                                              \
                                                                                                                     \
-      if (conjA) {                                                                                                  \
+      EIGEN_IF_CONSTEXPR (conjA) {                                                                                  \
         a_tmp = tri.conjugate();                                                                                    \
         a = a_tmp.data();                                                                                           \
         lda = convert_index<BlasIndex>(a_tmp.outerStride());                                                        \
@@ -139,7 +146,9 @@
         a = _tri;                                                                                                   \
         lda = convert_index<BlasIndex>(triStride);                                                                  \
       }                                                                                                             \
-      if (IsUnitDiag) diag = 'U';                                                                                   \
+      EIGEN_IF_CONSTEXPR (IsUnitDiag) {                                                                             \
+        diag = 'U';                                                                                                 \
+      }                                                                                                             \
       /* call ?trsm*/                                                                                               \
       BLASFUNC(&side, &uplo, &transa, &diag, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)a, \
                &lda, (BLASTYPE*)_other, &ldb);                                                                      \
@@ -153,10 +162,10 @@
 EIGEN_BLAS_TRSM_R(float, float, strsm)
 EIGEN_BLAS_TRSM_R(scomplex, MKL_Complex8, ctrsm)
 #else
-EIGEN_BLAS_TRSM_R(double, double, dtrsm_)
-EIGEN_BLAS_TRSM_R(dcomplex, double, ztrsm_)
-EIGEN_BLAS_TRSM_R(float, float, strsm_)
-EIGEN_BLAS_TRSM_R(scomplex, float, ctrsm_)
+EIGEN_BLAS_TRSM_R(double, double, EIGEN_BLAS_SYM(dtrsm))
+EIGEN_BLAS_TRSM_R(dcomplex, double, EIGEN_BLAS_SYM(ztrsm))
+EIGEN_BLAS_TRSM_R(float, float, EIGEN_BLAS_SYM(strsm))
+EIGEN_BLAS_TRSM_R(scomplex, float, EIGEN_BLAS_SYM(ctrsm))
 #endif
 
 #undef EIGEN_BLAS_TRSM_R
diff --git a/Eigen/src/Core/products/TriangularSolverVector.h b/Eigen/src/Core/products/TriangularSolverVector.h
index ff7c43f..eadf987 100644
--- a/Eigen/src/Core/products/TriangularSolverVector.h
+++ b/Eigen/src/Core/products/TriangularSolverVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRIANGULAR_SOLVER_VECTOR_H
 #define EIGEN_TRIANGULAR_SOLVER_VECTOR_H
@@ -31,11 +32,11 @@
 struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, RowMajor> {
   enum { IsLower = ((Mode & Lower) == Lower) };
   static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs) {
-    typedef Map<const Matrix<LhsScalar, Dynamic, Dynamic, RowMajor>, 0, OuterStride<> > LhsMap;
+    using LhsMap = Map<const Matrix<LhsScalar, Dynamic, Dynamic, RowMajor>, 0, OuterStride<> >;
     const LhsMap lhs(_lhs, size, size, OuterStride<>(lhsStride));
 
-    typedef const_blas_data_mapper<LhsScalar, Index, RowMajor> LhsMapper;
-    typedef const_blas_data_mapper<RhsScalar, Index, ColMajor> RhsMapper;
+    using LhsMapper = const_blas_data_mapper<LhsScalar, Index, RowMajor>;
+    using RhsMapper = const_blas_data_mapper<RhsScalar, Index, ColMajor>;
 
     std::conditional_t<Conjugate, const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>, LhsMap>,
                        const LhsMap&>
@@ -66,7 +67,9 @@
                          Map<const Matrix<RhsScalar, Dynamic, 1> >(rhs + s, k)))
                         .sum();
 
-        if ((!(Mode & UnitDiag)) && !is_identically_zero(rhs[i])) rhs[i] /= cjLhs(i, i);
+        EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) {
+          if (!is_identically_zero(rhs[i])) rhs[i] /= cjLhs(i, i);
+        }
       }
     }
   }
@@ -77,10 +80,10 @@
 struct triangular_solve_vector<LhsScalar, RhsScalar, Index, OnTheLeft, Mode, Conjugate, ColMajor> {
   enum { IsLower = ((Mode & Lower) == Lower) };
   static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs) {
-    typedef Map<const Matrix<LhsScalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> > LhsMap;
+    using LhsMap = Map<const Matrix<LhsScalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> >;
     const LhsMap lhs(_lhs, size, size, OuterStride<>(lhsStride));
-    typedef const_blas_data_mapper<LhsScalar, Index, ColMajor> LhsMapper;
-    typedef const_blas_data_mapper<RhsScalar, Index, ColMajor> RhsMapper;
+    using LhsMapper = const_blas_data_mapper<LhsScalar, Index, ColMajor>;
+    using RhsMapper = const_blas_data_mapper<RhsScalar, Index, ColMajor>;
     std::conditional_t<Conjugate, const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>, LhsMap>,
                        const LhsMap&>
         cjLhs(lhs);
@@ -94,7 +97,7 @@
       for (Index k = 0; k < actualPanelWidth; ++k) {
         Index i = IsLower ? pi + k : pi - k - 1;
         if (!is_identically_zero(rhs[i])) {
-          if (!(Mode & UnitDiag)) rhs[i] /= cjLhs.coeff(i, i);
+          EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) rhs[i] /= cjLhs.coeff(i, i);
 
           Index r = actualPanelWidth - k - 1;  // remaining size
           Index s = IsLower ? i + 1 : i - r;
diff --git a/Eigen/src/Core/util/AOCL_Support.h b/Eigen/src/Core/util/AOCL_Support.h
index 434ccfd..8f2a0bd 100644
--- a/Eigen/src/Core/util/AOCL_Support.h
+++ b/Eigen/src/Core/util/AOCL_Support.h
@@ -63,7 +63,7 @@
  * System requirements:
  * - AMD x86_64 processor (optimal performance)
  * - Linux, Windows, or compatible POSIX system
- * - C++11 or later standard
+ * - C++14 or later standard
  * - CMake 3.5+ for build system integration
  *
  * Developer:
@@ -72,6 +72,7 @@
  * Email: shbhaska@amd.com
  * Organization: Advanced Micro Devices, Inc.
  */
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_AOCL_SUPPORT_H
 #define EIGEN_AOCL_SUPPORT_H
@@ -82,20 +83,20 @@
 
 // Define AOCL component flags based on main flags
 #ifdef EIGEN_USE_AOCL_ALL
-#define EIGEN_USE_AOCL_VML  // Enable AOCL Vector Math Library
-#define EIGEN_USE_AOCL_BLAS // Enable AOCL BLAS (BLIS)
+#define EIGEN_USE_AOCL_VML   // Enable AOCL Vector Math Library
+#define EIGEN_USE_AOCL_BLAS  // Enable AOCL BLAS (BLIS)
 
 // Enable Eigen BLAS backend only if BLIS provides compatible interface
 #if defined(EIGEN_AOCL_BLIS_COMPATIBLE)
-#define EIGEN_USE_BLAS // Enable Eigen BLAS backend
+#define EIGEN_USE_BLAS  // Enable Eigen BLAS backend
 #endif
 
-#define EIGEN_USE_LAPACKE // Enable LAPACK backend (FLAME)
+#define EIGEN_USE_LAPACKE  // Enable LAPACK backend (FLAME)
 #endif
 
 #ifdef EIGEN_USE_AOCL_MT
-#define EIGEN_USE_AOCL_VML  // Enable AOCL Vector Math Library
-#define EIGEN_USE_AOCL_BLAS // Enable AOCL BLAS (BLIS)
+#define EIGEN_USE_AOCL_VML   // Enable AOCL Vector Math Library
+#define EIGEN_USE_AOCL_BLAS  // Enable AOCL BLAS (BLIS)
 
 // For multithreaded: disable EIGEN_USE_BLAS to avoid signature conflicts
 // Use direct BLIS calls instead through EIGEN_USE_AOCL_BLAS
@@ -103,8 +104,8 @@
 // interface
 
 // Note: LAPACKE disabled in MT mode to avoid header conflicts
-#define EIGEN_USE_LAPACKE // Commented out - causes conflicts with BLIS LAPACKE
-#define EIGEN_AOCL_USE_BLIS_MT 1 // Enable multithreaded BLIS
+#define EIGEN_USE_LAPACKE         // Commented out - causes conflicts with BLIS LAPACKE
+#define EIGEN_AOCL_USE_BLIS_MT 1  // Enable multithreaded BLIS
 #endif
 
 // Handle standalone EIGEN_USE_AOCL_VML flag
@@ -119,16 +120,15 @@
 
 // Configuration constants - define these for any AOCL usage
 #ifndef EIGEN_AOCL_VML_THRESHOLD
-#define EIGEN_AOCL_VML_THRESHOLD 128 // Threshold for VML dispatch
+#define EIGEN_AOCL_VML_THRESHOLD 128  // Threshold for VML dispatch
 #endif
 
 #ifndef AOCL_SIMD_WIDTH
-#define AOCL_SIMD_WIDTH 8 // AVX-512: 512 bits / 64 bits per double
+#define AOCL_SIMD_WIDTH 8  // AVX-512: 512 bits / 64 bits per double
 #endif
 
 // Include AOCL Math Library headers for VML
-#if defined(EIGEN_USE_AOCL_VML) || defined(EIGEN_USE_AOCL_ALL) ||              \
-    defined(EIGEN_USE_AOCL_MT)
+#if defined(EIGEN_USE_AOCL_VML) || defined(EIGEN_USE_AOCL_ALL) || defined(EIGEN_USE_AOCL_MT)
 #if defined(__has_include)
 #if __has_include("amdlibm.h")
 #include "amdlibm.h"
@@ -163,13 +163,6 @@
 #endif
 #endif
 
-namespace Eigen {
-// AOCL-specific type definitions
-typedef std::complex<double> dcomplex;
-typedef std::complex<float> scomplex;
-typedef int BlasIndex; // Standard BLAS index type
-} // namespace Eigen
+#endif  // EIGEN_USE_AOCL_ALL || EIGEN_USE_AOCL_MT
 
-#endif // EIGEN_USE_AOCL_ALL || EIGEN_USE_AOCL_MT
-
-#endif // EIGEN_AOCL_SUPPORT_H
+#endif  // EIGEN_AOCL_SUPPORT_H
diff --git a/Eigen/src/Core/util/Assert.h b/Eigen/src/Core/util/Assert.h
index 09a411a..22a87e1 100644
--- a/Eigen/src/Core/util/Assert.h
+++ b/Eigen/src/Core/util/Assert.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CORE_UTIL_ASSERT_H
 #define EIGEN_CORE_UTIL_ASSERT_H
@@ -40,13 +41,13 @@
 
 #ifndef EIGEN_HAS_BUILTIN_FILE
 // Clang can check if __builtin_FILE() is supported.
-// GCC > 5, MSVC 2019 14.26 (1926) all have __builtin_FILE().
+// Supported GCC versions and MSVC 2019 14.26 (1926) all have __builtin_FILE().
 //
 // For NVCC, it's more complicated.  Through trial-and-error:
 //   - nvcc+gcc supports __builtin_FILE() on host, and on device after CUDA 11.
 //   - nvcc+msvc supports __builtin_FILE() only after CUDA 11.
-#if (EIGEN_HAS_BUILTIN(__builtin_FILE) && (EIGEN_COMP_CLANG || !defined(EIGEN_CUDA_ARCH))) ||            \
-    (EIGEN_GNUC_STRICT_AT_LEAST(5, 0, 0) && (EIGEN_COMP_NVCC >= 110000 || !defined(EIGEN_CUDA_ARCH))) || \
+#if (EIGEN_HAS_BUILTIN(__builtin_FILE) && (EIGEN_COMP_CLANG || !defined(EIGEN_CUDA_ARCH))) || \
+    (EIGEN_COMP_GNUC_STRICT && (EIGEN_COMP_NVCC >= 110000 || !defined(EIGEN_CUDA_ARCH))) ||   \
     (EIGEN_COMP_MSVC >= 1926 && (!EIGEN_COMP_NVCC || EIGEN_COMP_NVCC >= 110000))
 #define EIGEN_HAS_BUILTIN_FILE 1
 #else
diff --git a/Eigen/src/Core/util/BlasTypes.h b/Eigen/src/Core/util/BlasTypes.h
new file mode 100644
index 0000000..1a08c07
--- /dev/null
+++ b/Eigen/src/Core/util/BlasTypes.h
@@ -0,0 +1,69 @@
+/*
+ Copyright (c) 2011, Intel Corporation. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ********************************************************************************
+ *   Content : Eigen bindings to Intel(R) MKL
+ *   Scalar and index types of the external BLAS/LAPACK interface, split out of MKL_support.h
+ ********************************************************************************
+*/
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef EIGEN_BLAS_TYPES_H
+#define EIGEN_BLAS_TYPES_H
+
+/* Scalar and index types of the external BLAS/LAPACK interface. These are used pervasively by the BLAS and LAPACKE
+ * backends, so they live in a backend-neutral header rather than in MKL_support.h. BlasIndex follows the integer
+ * width selected there (MKL_INT for MKL, EIGEN_BLAS_INT otherwise), so this header must be included after
+ * MKL_support.h has set those up; MKL_support.h includes it for that reason.
+ */
+
+// IWYU pragma: private
+#include "../InternalHeaderCheck.h"
+
+namespace Eigen {
+
+using dcomplex = std::complex<double>;
+using scomplex = std::complex<float>;
+
+#if defined(EIGEN_USE_MKL)
+using BlasIndex = MKL_INT;
+// Plain static_assert (not EIGEN_STATIC_ASSERT): like the LAPACKE/BLAS cross-check it must not be suppressible.
+#if defined(EIGEN_64BIT_BLAS)
+static_assert(sizeof(MKL_INT) == 8,
+              "EIGEN_64BIT_BLAS is defined but MKL_INT is 32-bit. Define MKL_ILP64 and link the MKL *_ilp64 "
+              "libraries, or undefine EIGEN_64BIT_BLAS.");
+#else
+static_assert(sizeof(MKL_INT) == 4,
+              "MKL_INT is 64-bit but EIGEN_64BIT_BLAS is not defined. Define EIGEN_64BIT_BLAS to match MKL_ILP64, or "
+              "link the MKL *_lp64 libraries.");
+#endif
+#else
+using BlasIndex = EIGEN_BLAS_INT;
+#endif
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BLAS_TYPES_H
diff --git a/Eigen/src/Core/util/BlasUtil.h b/Eigen/src/Core/util/BlasUtil.h
index 2e1ca91..af49412 100644
--- a/Eigen/src/Core/util/BlasUtil.h
+++ b/Eigen/src/Core/util/BlasUtil.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BLASUTIL_H
 #define EIGEN_BLASUTIL_H
@@ -174,9 +175,9 @@
 template <typename Scalar, typename Index, int StorageOrder, int AlignmentType>
 class blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType, 1> {
  public:
-  typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
-  typedef blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType> SubMapper;
-  typedef BlasVectorMapper<Scalar, Index> VectorMapper;
+  using LinearMapper = BlasLinearMapper<Scalar, Index, AlignmentType>;
+  using SubMapper = blas_data_mapper<Scalar, Index, StorageOrder, AlignmentType>;
+  using VectorMapper = BlasVectorMapper<Scalar, Index>;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride, Index incr = 1)
       : m_data(data), m_stride(stride) {
@@ -306,8 +307,8 @@
 template <typename Scalar, typename Index, int StorageOrder, int AlignmentType, int Incr>
 class blas_data_mapper {
  public:
-  typedef BlasLinearMapper<Scalar, Index, AlignmentType, Incr> LinearMapper;
-  typedef blas_data_mapper SubMapper;
+  using LinearMapper = BlasLinearMapper<Scalar, Index, AlignmentType, Incr>;
+  using SubMapper = blas_data_mapper;
 
   EIGEN_DEVICE_FUNC constexpr EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Index stride, Index incr)
       : m_data(data), m_stride(stride), m_incr(incr) {}
@@ -445,7 +446,7 @@
 template <typename Scalar, typename Index, int StorageOrder>
 class const_blas_data_mapper : public blas_data_mapper<const Scalar, Index, StorageOrder> {
  public:
-  typedef const_blas_data_mapper<Scalar, Index, StorageOrder> SubMapper;
+  using SubMapper = const_blas_data_mapper<Scalar, Index, StorageOrder>;
 
   EIGEN_ALWAYS_INLINE const_blas_data_mapper(const Scalar* data, Index stride)
       : blas_data_mapper<const Scalar, Index, StorageOrder>(data, stride) {}
@@ -460,22 +461,22 @@
  * and conjugate */
 template <typename XprType>
 struct blas_traits {
-  typedef typename traits<XprType>::Scalar Scalar;
-  typedef const XprType& ExtractType;
-  typedef XprType ExtractType_;
+  using Scalar = typename traits<XprType>::Scalar;
+  using ExtractType = const XprType&;
+  using ExtractType_ = XprType;
   enum {
     IsComplex = NumTraits<Scalar>::IsComplex,
     IsTransposed = false,
     NeedToConjugate = false,
     HasUsableDirectAccess =
         ((int(XprType::Flags) & DirectAccessBit) &&
-         (bool(XprType::IsVectorAtCompileTime) || int(inner_stride_at_compile_time<XprType>::ret) == 1))
+         (bool(XprType::IsVectorAtCompileTime) || int(inner_stride_at_compile_time<XprType>::value) == 1))
             ? 1
             : 0,
     HasScalarFactor = false
   };
-  typedef std::conditional_t<bool(HasUsableDirectAccess), ExtractType, typename ExtractType_::PlainObject>
-      DirectLinearAccessType;
+  using DirectLinearAccessType =
+      std::conditional_t<bool(HasUsableDirectAccess), ExtractType, typename ExtractType_::PlainObject>;
   EIGEN_DEVICE_FUNC static inline EIGEN_DEVICE_FUNC ExtractType extract(const XprType& x) { return x; }
   EIGEN_DEVICE_FUNC static inline EIGEN_DEVICE_FUNC const Scalar extractScalarFactor(const XprType&) {
     return Scalar(1);
@@ -485,9 +486,9 @@
 // pop conjugate
 template <typename Scalar, typename NestedXpr>
 struct blas_traits<CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> > : blas_traits<NestedXpr> {
-  typedef blas_traits<NestedXpr> Base;
-  typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
-  typedef typename Base::ExtractType ExtractType;
+  using Base = blas_traits<NestedXpr>;
+  using XprType = CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr>;
+  using ExtractType = typename Base::ExtractType;
 
   enum { IsComplex = NumTraits<Scalar>::IsComplex, NeedToConjugate = Base::NeedToConjugate ? 0 : IsComplex };
   EIGEN_DEVICE_FUNC static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
@@ -502,10 +503,10 @@
     CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>, Plain>, NestedXpr> >
     : blas_traits<NestedXpr> {
   enum { HasScalarFactor = true };
-  typedef blas_traits<NestedXpr> Base;
-  typedef CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>, Plain>, NestedXpr>
-      XprType;
-  typedef typename Base::ExtractType ExtractType;
+  using Base = blas_traits<NestedXpr>;
+  using XprType =
+      CwiseBinaryOp<scalar_product_op<Scalar>, const CwiseNullaryOp<scalar_constant_op<Scalar>, Plain>, NestedXpr>;
+  using ExtractType = typename Base::ExtractType;
   EIGEN_DEVICE_FUNC static inline EIGEN_DEVICE_FUNC ExtractType extract(const XprType& x) {
     return Base::extract(x.rhs());
   }
@@ -518,10 +519,10 @@
     CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>, Plain> > >
     : blas_traits<NestedXpr> {
   enum { HasScalarFactor = true };
-  typedef blas_traits<NestedXpr> Base;
-  typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>, Plain> >
-      XprType;
-  typedef typename Base::ExtractType ExtractType;
+  using Base = blas_traits<NestedXpr>;
+  using XprType =
+      CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const CwiseNullaryOp<scalar_constant_op<Scalar>, Plain>>;
+  using ExtractType = typename Base::ExtractType;
   EIGEN_DEVICE_FUNC static inline ExtractType extract(const XprType& x) { return Base::extract(x.lhs()); }
   EIGEN_DEVICE_FUNC static inline Scalar extractScalarFactor(const XprType& x) {
     return Base::extractScalarFactor(x.lhs()) * x.rhs().functor().m_other;
@@ -536,9 +537,9 @@
 template <typename Scalar, typename NestedXpr>
 struct blas_traits<CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> > : blas_traits<NestedXpr> {
   enum { HasScalarFactor = true };
-  typedef blas_traits<NestedXpr> Base;
-  typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
-  typedef typename Base::ExtractType ExtractType;
+  using Base = blas_traits<NestedXpr>;
+  using XprType = CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr>;
+  using ExtractType = typename Base::ExtractType;
   EIGEN_DEVICE_FUNC static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); }
   EIGEN_DEVICE_FUNC static inline Scalar extractScalarFactor(const XprType& x) {
     return -Base::extractScalarFactor(x.nestedExpression());
@@ -548,14 +549,14 @@
 // pop/push transpose
 template <typename NestedXpr>
 struct blas_traits<Transpose<NestedXpr> > : blas_traits<NestedXpr> {
-  typedef typename NestedXpr::Scalar Scalar;
-  typedef blas_traits<NestedXpr> Base;
-  typedef Transpose<NestedXpr> XprType;
-  typedef Transpose<const typename Base::ExtractType_>
-      ExtractType;  // const to get rid of a compile error; anyway blas traits are only used on the RHS
-  typedef Transpose<const typename Base::ExtractType_> ExtractType_;
-  typedef std::conditional_t<bool(Base::HasUsableDirectAccess), ExtractType, typename ExtractType::PlainObject>
-      DirectLinearAccessType;
+  using Scalar = typename NestedXpr::Scalar;
+  using Base = blas_traits<NestedXpr>;
+  using XprType = Transpose<NestedXpr>;
+  using ExtractType = Transpose<const typename Base::ExtractType_>;  // const to get rid of a compile error; anyway blas
+                                                                     // traits are only used on the RHS
+  using ExtractType_ = Transpose<const typename Base::ExtractType_>;
+  using DirectLinearAccessType =
+      std::conditional_t<bool(Base::HasUsableDirectAccess), ExtractType, typename ExtractType::PlainObject>;
   enum { IsTransposed = Base::IsTransposed ? 0 : 1 };
   EIGEN_DEVICE_FUNC static inline ExtractType extract(const XprType& x) {
     return ExtractType(Base::extract(x.nestedExpression()));
diff --git a/Eigen/src/Core/util/ConfigureVectorization.h b/Eigen/src/Core/util/ConfigureVectorization.h
index 095735d..df2d236 100644
--- a/Eigen/src/Core/util/ConfigureVectorization.h
+++ b/Eigen/src/Core/util/ConfigureVectorization.h
@@ -7,19 +7,20 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CONFIGURE_VECTORIZATION_H
 #define EIGEN_CONFIGURE_VECTORIZATION_H
 
 // Prepare for using the generic clang backend if requested.
+#if defined(EIGEN_VECTORIZE_GENERIC) && !defined(EIGEN_GENERIC_VECTOR_SIZE_BYTES)
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 64
+#endif
 #if defined(EIGEN_VECTORIZE_GENERIC) && !defined(EIGEN_DONT_VECTORIZE) && !defined(EIGEN_DONT_ALIGN)
 #if !EIGEN_ARCH_VECTOR_EXTENSIONS
 #error "The compiler does not support clang vector extensions."
 #endif
 #define EIGEN_VECTORIZE
-#ifndef EIGEN_GENERIC_VECTOR_SIZE_BYTES
-#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 64
-#endif
 #define EIGEN_MAX_ALIGN_BYTES EIGEN_GENERIC_VECTOR_SIZE_BYTES
 #endif
 
@@ -51,15 +52,9 @@
 #endif
 
 // Align to the boundary that avoids false sharing.
-//   https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size
-// There is a bug in android NDK < r26 where the macro is defined but std::hardware_destructive_interference_size
-// still does not exist.
-#if defined(__cpp_lib_hardware_interference_size) && __cpp_lib_hardware_interference_size >= 201603 && \
-    (!EIGEN_OS_ANDROID || __NDK_MAJOR__ + 0 >= 26)
-#include <new>
-#define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING EIGEN_ALIGN_TO_BOUNDARY(std::hardware_destructive_interference_size)
-#else
-// Overalign for the cache line size of 128 bytes (Apple M1)
+// Pinned to 128 bytes to preserve a stable ABI across architectures and standard libraries
+// and avoid GCC -Winterference-size warnings.
+#ifndef EIGEN_ALIGN_TO_AVOID_FALSE_SHARING
 #define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING EIGEN_ALIGN_TO_BOUNDARY(128)
 #endif
 
@@ -72,17 +67,42 @@
 #else
 #define EIGEN_IDEAL_MAX_ALIGN_BYTES 0
 #endif
+#elif defined(EIGEN_VECTORIZE_GENERIC)
+// Generic clang backend overrides native SIMD; align to the generic vector size.
+#define EIGEN_IDEAL_MAX_ALIGN_BYTES EIGEN_GENERIC_VECTOR_SIZE_BYTES
 #elif defined(__AVX512F__)
 // 64 bytes static alignment is preferred only if really required
 #define EIGEN_IDEAL_MAX_ALIGN_BYTES 64
+// Deliberately no SME case: this block runs long before EIGEN_VECTORIZE_SME is
+// defined, so a test for it here is unreachable -- and moving it would be wrong
+// rather than merely late. Raising the value changes the alignment, and so the
+// ABI, of every fixed-size object relative to a NEON build of the same headers;
+// past 16 bytes aligned_malloc also switches to the prefixed
+// handmade_aligned_malloc, so a matrix allocated in an SME translation unit and
+// freed in a non-SME one corrupts the heap. Keeping 16 is not free: the SME GEMM
+// kernel is up to 3.4x faster at small sizes when the result matrix starts on a
+// 64-byte boundary, which is what 64 here would give every Eigen-owned matrix.
+#elif defined(EIGEN_ARM64_USE_SVE) && defined(__ARM_FEATURE_SVE_BITS) && (__ARM_FEATURE_SVE_BITS != 0)
+// A fixed-length SVE packet is __ARM_FEATURE_SVE_BITS/8 bytes wide and asks for
+// exactly that much alignment; a fixed-size object has to be able to offer it or
+// it never reaches the vectorized path.  The Alignment enum stops at 128.
+#if __ARM_FEATURE_SVE_BITS <= 1024
+#define EIGEN_IDEAL_MAX_ALIGN_BYTES (__ARM_FEATURE_SVE_BITS / 8)
+#else
+#define EIGEN_IDEAL_MAX_ALIGN_BYTES 128
+#endif
 #elif defined(__AVX__)
 // 32 bytes static alignment is preferred only if really required
 #define EIGEN_IDEAL_MAX_ALIGN_BYTES 32
 #elif defined __HVX__ && (__HVX_LENGTH__ == 128)
 #define EIGEN_IDEAL_MAX_ALIGN_BYTES 128
 #elif defined(EIGEN_RISCV64_USE_RVV10)
+#if __riscv_v_fixed_vlen <= 512
 #define EIGEN_IDEAL_MAX_ALIGN_BYTES 64
 #else
+#define EIGEN_IDEAL_MAX_ALIGN_BYTES 128
+#endif
+#else
 #define EIGEN_IDEAL_MAX_ALIGN_BYTES 16
 #endif
 
@@ -200,8 +220,8 @@
 #endif
 #endif
 
-// The following (except #include <malloc.h> and _M_IX86_FP ??) can likely be
-// removed as gcc 4.1 and msvc 2008 are not supported anyways.
+// MSVC needs <malloc.h> for aligned allocation helpers, and 32-bit x86 uses
+// _M_IX86_FP to decide whether SSE2 is enabled.
 #if EIGEN_COMP_MSVC
 #include <malloc.h>  // for _aligned_malloc -- need it regardless of whether vectorization is enabled
 // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
@@ -216,6 +236,30 @@
 
 #if !(defined(EIGEN_DONT_VECTORIZE) || defined(EIGEN_GPUCC) || defined(EIGEN_VECTORIZE_GENERIC))
 
+// Whether the ARM SME backend can be built at all. Two hard requirements, both
+// properties of the translation unit rather than of the CPU:
+//   - SME2, not just SME: the micro-kernel's multi-vector loads (svld1_*_x2/x4)
+//     and svcount_t predicates are SME2 instructions.
+//   - scalable (VLA) SVE mode: the kernel derives its ZA-tile geometry from the
+//     runtime streaming vector length, so -msve-vector-bits=N would pin it to
+//     one SVL and silently miscompute at any other.
+#if defined(__ARM_FEATURE_SME2) && !(defined(__ARM_FEATURE_SVE_BITS) && (__ARM_FEATURE_SVE_BITS != 0))
+#define EIGEN_ARM64_SME_USABLE
+#endif
+
+// ... and whether it is the backend to use. SME is selected automatically when
+// it is usable: unlike SVE it needs no fixed vector length, and it only
+// replaces the GEMM kernels -- everything else keeps the NEON packet path. Two
+// escapes: EIGEN_ARM64_NO_SME turns it off, and EIGEN_ARM64_USE_SVE takes
+// precedence for callers who asked for SVE specifically.
+#if defined(EIGEN_ARM64_SME_USABLE) && !defined(EIGEN_ARM64_NO_SME) && !defined(EIGEN_ARM64_USE_SVE)
+#define EIGEN_ARM64_SME_SELECTED
+#endif
+
+#if defined(EIGEN_ARM64_USE_SME) && defined(EIGEN_ARM64_NO_SME)
+#error "EIGEN_ARM64_USE_SME and EIGEN_ARM64_NO_SME are mutually exclusive."
+#endif
+
 #if defined(EIGEN_SSE2_ON_NON_MSVC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
 
 // Defines symbols for compile-time detection of which instructions are
@@ -297,7 +341,10 @@
 #define EIGEN_VECTORIZE_AVX512VL
 #endif
 #ifdef __AVX512FP16__
-#ifdef __AVX512VL__
+#if EIGEN_COMP_NVHPC
+// NVC++ exposes AVX512-FP16 inconsistently: older releases define the feature without _Float16/__m512h,
+// and 24.11-26.3 lower compare/blend intrinsics to unresolved __builtin_ia32_*ph* references.
+#elif defined(__AVX512VL__)
 #define EIGEN_VECTORIZE_AVX512FP16
 // Built-in _Float16.
 #define EIGEN_HAS_BUILTIN_FLOAT16 1
@@ -356,9 +403,8 @@
 // so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too.
 // notice that since these are C headers, the extern "C" is theoretically needed anyways.
 extern "C" {
-// In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.
-// Doing so triggers some issues with ICC. However old gcc versions may not have this file, thus:
-#if EIGEN_COMP_ICC >= 1110 || EIGEN_COMP_EMSCRIPTEN
+// ICC and Emscripten need the umbrella header instead of direct *mmintrin.h includes.
+#if EIGEN_COMP_ICC || EIGEN_COMP_EMSCRIPTEN
 #include <immintrin.h>
 #else
 #include <mmintrin.h>
@@ -406,7 +452,13 @@
 #undef vector
 #undef pixel
 
-#elif ((defined __ARM_NEON) || (defined __ARM_NEON__)) && !(defined EIGEN_ARM64_USE_SVE)
+#elif defined(EIGEN_ARM64_USE_SME) && !defined(EIGEN_ARM64_SME_USABLE)
+
+#error \
+    "EIGEN_ARM64_USE_SME requires a compiler targeting SME2 in scalable (SVE VLA) mode: build with e.g. -march=armv9.2-a+sme2 and without -msve-vector-bits."
+
+#elif ((defined __ARM_NEON) || (defined __ARM_NEON__)) && !(defined EIGEN_ARM64_USE_SVE) && \
+    !(defined EIGEN_ARM64_SME_SELECTED)
 
 #define EIGEN_VECTORIZE
 #define EIGEN_VECTORIZE_NEON
@@ -424,8 +476,44 @@
 // to ensure a fixed length is set
 #if defined __ARM_FEATURE_SVE_BITS
 #define EIGEN_ARM64_SVE_VL __ARM_FEATURE_SVE_BITS
+
+// Architecture-mandated length constraints.
+static_assert((EIGEN_ARM64_SVE_VL >= 128) && (EIGEN_ARM64_SVE_VL <= 2048) &&
+                  ((EIGEN_ARM64_SVE_VL & (EIGEN_ARM64_SVE_VL - 1)) == 0),
+              "SVE vector length must be 2^n for some n in [7, 11]");
 #else
-#error "Eigen requires a fixed SVE lector length but EIGEN_ARM64_SVE_VL is not set."
+#error "Eigen requires a fixed SVE vector length but EIGEN_ARM64_SVE_VL is not set."
+#endif
+
+// TriangularMatrixMatrix.h puts a (2 * max(mr, nr))^2 panel of Scalar on the
+// stack, and mr is 3 * PacketSize, so for float -- the widest scalar this backend
+// vectorizes -- the panel is 9 * VL^2 / 64 bytes
+// -- 144 kB at VL=1024 and 576 kB at VL=2048, past the 128 kB default, and the
+// backend does not compile at those lengths without more room. Only raise Eigen's
+// default; an explicit user limit remains authoritative, including 0.
+#if defined(EIGEN_STACK_ALLOCATION_LIMIT_WAS_DEFAULTED) && \
+    EIGEN_STACK_ALLOCATION_LIMIT < (9 * EIGEN_ARM64_SVE_VL * EIGEN_ARM64_SVE_VL / 64)
+#undef EIGEN_STACK_ALLOCATION_LIMIT
+#define EIGEN_STACK_ALLOCATION_LIMIT (9 * EIGEN_ARM64_SVE_VL * EIGEN_ARM64_SVE_VL / 64)
+#endif
+
+// Selected automatically whenever the toolchain can provide it; see
+// EIGEN_ARM64_SME_SELECTED above for the conditions and the opt-out.
+#elif defined(EIGEN_ARM64_SME_SELECTED)
+
+#define EIGEN_VECTORIZE
+#define EIGEN_VECTORIZE_SME
+#include <arm_neon.h>
+#include <arm_sme.h>
+
+// Double-precision outer products (FMOPA into a ZA.D tile) need the optional
+// FEAT_SME_F64F64, which each compiler reports differently: GCC defines the ACLE
+// macro, clang defines no macro but gates the builtin on the target feature.
+// Both halves are needed -- clang otherwise accepts svmopa_za64_f64_m without the
+// feature, so a missed gate faults at run time rather than at build time.
+#if !defined(EIGEN_ARM64_NO_SME_F64F64) && \
+    (defined(__ARM_FEATURE_SME_F64F64) || EIGEN_HAS_BUILTIN(__builtin_sme_svmopa_za64_f64_m))
+#define EIGEN_VECTORIZE_SME_F64F64
 #endif
 
 #elif EIGEN_ARCH_RISCV
@@ -454,8 +542,18 @@
 #error "Eigen requires a fixed RVV vector length but -mrvv-vector-bits=zvl is not set."
 #endif
 
+// Raise Eigen's own default only, as the SVE block above does: an explicit limit is a caller
+// policy on stack safety, and rewriting it defeats the policy. nomalloc, bdcsvd, jacobisvd,
+// diagonalview and diagonalmatrices set 0 to switch the check off, and clobbering that re-enables
+// alloca underneath the very tests written to catch it.
+#ifdef EIGEN_STACK_ALLOCATION_LIMIT_WAS_DEFAULTED
 #undef EIGEN_STACK_ALLOCATION_LIMIT
+#if __riscv_v_fixed_vlen <= 512
 #define EIGEN_STACK_ALLOCATION_LIMIT 196608
+#else
+#define EIGEN_STACK_ALLOCATION_LIMIT 393216
+#endif
+#endif
 
 #if defined(__riscv_zvfh) && defined(__riscv_zfh)
 #define EIGEN_VECTORIZE_RVV10FP16
@@ -509,6 +607,9 @@
 #endif
 #endif
 
+// The backend blocks above are the only consumers; do not leak it into user code.
+#undef EIGEN_STACK_ALLOCATION_LIMIT_WAS_DEFAULTED
+
 // Following the Arm ACLE arm_neon.h should also include arm_fp16.h but not all
 // compilers seem to follow this. We therefore include it explicitly.
 // See also: https://bugs.llvm.org/show_bug.cgi?id=47955
@@ -521,7 +622,7 @@
 #define EIGEN_VECTORIZE_FMA
 #endif
 
-#if defined(__F16C__) && !defined(EIGEN_GPUCC) && (!EIGEN_COMP_CLANG_STRICT || EIGEN_CLANG_STRICT_AT_LEAST(3, 8, 0))
+#if defined(__F16C__) && !defined(EIGEN_GPUCC)
 // We can use the optimized fp16 to float and float to fp16 conversion routines
 #define EIGEN_HAS_FP16_C
 
@@ -538,20 +639,15 @@
 #if defined EIGEN_CUDACC
 #define EIGEN_VECTORIZE_GPU
 #include <vector_types.h>
-#if EIGEN_CUDA_SDK_VER >= 70500
-#define EIGEN_HAS_CUDA_FP16
-#endif
-#endif
-
-#if defined(EIGEN_HAS_CUDA_FP16)
 #include <cuda_runtime_api.h>
+#if defined(EIGEN_HAS_CUDA_FP16)
 #include <cuda_fp16.h>
 #endif
+#endif
 
 #if defined(EIGEN_HIPCC)
 #define EIGEN_VECTORIZE_GPU
 #include <hip/hip_vector_types.h>
-#define EIGEN_HAS_HIP_FP16
 #include <hip/hip_fp16.h>
 #define EIGEN_HAS_HIP_BF16
 #include <hip/hip_bfloat16.h>
@@ -568,6 +664,22 @@
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
 
+/** Whether numext::madd uses std::fma for scalars. Defaults to the hardware: fused where a single
+ * instruction exists, which keeps the scalar and vectorized paths consistent, and unfused otherwise,
+ * where software fma costs 2-3x on Intel and up to 30x on WASM. Error-free transformations such as
+ * internal::twoprod ignore this setting: they call numext::fma when EIGEN_VECTORIZE_FMA is enabled
+ * or FP_FAST_FMA* advertises a fast scalar fma, and use Dekker's product elsewhere.
+ * Resolved here rather than in Macros.h, which Eigen/Core includes first, because the architecture
+ * branches above settle EIGEN_VECTORIZE_FMA -- the ARM one only a few lines up.
+ */
+#ifndef EIGEN_SCALAR_MADD_USE_FMA
+#ifdef EIGEN_VECTORIZE_FMA
+#define EIGEN_SCALAR_MADD_USE_FMA 1
+#else
+#define EIGEN_SCALAR_MADD_USE_FMA 0
+#endif
+#endif
+
 namespace Eigen {
 
 inline static const char* SimdInstructionSetsInUse(void) {
@@ -591,6 +703,8 @@
   return "VSX";
 #elif defined(EIGEN_VECTORIZE_NEON)
   return "ARM NEON";
+#elif defined(EIGEN_VECTORIZE_SME)
+  return "ARM SME";
 #elif defined(EIGEN_VECTORIZE_SVE)
   return "ARM SVE";
 #elif defined(EIGEN_VECTORIZE_ZVECTOR)
@@ -599,6 +713,8 @@
   return "MIPS MSA";
 #elif defined(EIGEN_VECTORIZE_LSX)
   return "LOONGARCH64 LSX";
+#elif defined(EIGEN_VECTORIZE_RVV10)
+  return "RVV";
 #else
   return "None";
 #endif
diff --git a/Eigen/src/Core/util/Constants.h b/Eigen/src/Core/util/Constants.h
index f7e8b70..ea55eef 100644
--- a/Eigen/src/Core/util/Constants.h
+++ b/Eigen/src/Core/util/Constants.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CONSTANTS_H
 #define EIGEN_CONSTANTS_H
@@ -76,7 +77,7 @@
 /** \ingroup flags
  * \deprecated
  * means the expression should be evaluated before any assignment */
-EIGEN_DEPRECATED constexpr unsigned int EvalBeforeAssigningBit = 0x4;  // FIXME deprecated
+EIGEN_DEPRECATED constexpr unsigned int EvalBeforeAssigningBit = 0x4;
 
 /** \ingroup flags
  *
@@ -356,7 +357,11 @@
  * and we do not know how to get rid of them (bug 450).
  */
 
-enum NoChange_t { NoChange };
+// NoChange is set to -1 (rather than 0) so that calls like resize(NoChange, n)
+// that land in a generic resize(Index, Index) overload — missing the NoChange_t
+// overload — trip the rows/cols >= 0 assertion instead of silently producing a
+// 0-sized dimension. See issue #656.
+enum NoChange_t { NoChange = -1 };
 enum Sequential_t { Sequential };
 enum Default_t { Default };
 
@@ -429,6 +434,15 @@
   DisableQRDecomposition = NoQRPreconditioner
 };
 
+// JacobiSVD and BDCSVD combine QR preconditioner flags with decomposition flags in a single template bitmask.
+constexpr int operator|(QRPreconditioners qr_preconditioner, DecompositionOptions decomposition_option) {
+  return static_cast<int>(qr_preconditioner) | static_cast<int>(decomposition_option);
+}
+
+constexpr int operator|(DecompositionOptions decomposition_option, QRPreconditioners qr_preconditioner) {
+  return static_cast<int>(decomposition_option) | static_cast<int>(qr_preconditioner);
+}
+
 #ifdef Success
 #error The preprocessor symbol 'Success' is defined, possibly by the X11 header file X.h
 #endif
@@ -476,12 +490,15 @@
   HVX = 0x7,
   LSX = 0x8,
   RVV10 = 0x9,
+  SME = 0xa,
 #if defined EIGEN_VECTORIZE_SSE
   Target = SSE
 #elif defined EIGEN_VECTORIZE_ALTIVEC
   Target = AltiVec
 #elif defined EIGEN_VECTORIZE_VSX
   Target = VSX
+#elif defined EIGEN_VECTORIZE_SME
+  Target = SME
 #elif defined EIGEN_VECTORIZE_NEON
   Target = NEON
 #elif defined EIGEN_VECTORIZE_SVE
@@ -567,6 +584,9 @@
 struct PermutationShape {
   static std::string debugName() { return "PermutationShape"; }
 };
+struct ScaledPermutationShape {
+  static std::string debugName() { return "ScaledPermutationShape"; }
+};
 struct TranspositionsShape {
   static std::string debugName() { return "TranspositionsShape"; }
 };
diff --git a/Eigen/src/Core/util/DisableStupidWarnings.h b/Eigen/src/Core/util/DisableStupidWarnings.h
index ab0c542..8091ad4 100644
--- a/Eigen/src/Core/util/DisableStupidWarnings.h
+++ b/Eigen/src/Core/util/DisableStupidWarnings.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_WARNINGS_DISABLED
 #define EIGEN_WARNINGS_DISABLED
 
@@ -17,9 +20,7 @@
 // 4714 - function marked as __forceinline not inlined
 // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow
 // 4800 - 'type' : forcing value to bool 'true' or 'false' (performance warning)
-#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
 #pragma warning(push)
-#endif
 #pragma warning(disable : 4100 4101 4127 4181 4211 4244 4273 4324 4503 4512 4522 4700 4714 4717 4800)
 // We currently rely on has_denorm in tests, and need it defined correctly for half/bfloat16.
 #ifndef _SILENCE_CXX23_DENORM_DEPRECATION_WARNING
@@ -36,15 +37,11 @@
 //        a legitimate use case.
 // 1684 - conversion from pointer to same-sized integral type (potential portability problem)
 // 2259 - non-pointer conversion from "Eigen::Index={ptrdiff_t={long}}" to "int" may lose significant bits
-#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
 #pragma warning push
-#endif
 #pragma warning disable 2196 279 1684 2259
 
 #elif defined __clang__
-#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
 #pragma clang diagnostic push
-#endif
 #if defined(__has_warning)
 // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant
 //     this is really a stupid warning as it warns on compile-time expressions involving enums
@@ -65,15 +62,9 @@
 
 #elif defined __GNUC__ && !defined(__FUJITSU)
 
-#if (!defined(EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS)) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #pragma GCC diagnostic push
-#endif
 // g++ warns about local variables shadowing member functions, which is too strict
 #pragma GCC diagnostic ignored "-Wshadow"
-#if __GNUC__ == 4 && __GNUC_MINOR__ < 8
-// Until g++-4.7 there are warnings when comparing unsigned int vs 0, even in templated functions:
-#pragma GCC diagnostic ignored "-Wtype-limits"
-#endif
 #if __GNUC__ >= 6
 #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif
@@ -84,8 +75,7 @@
 #endif
 
 #if defined __NVCC__ && defined __CUDACC__
-// MSVC 14.16 (required by CUDA 9.*) does not support the _Pragma keyword, so
-// we instead use Microsoft's __pragma extension.
+// MSVC does not support the _Pragma keyword, so we use Microsoft's __pragma extension.
 #if defined _MSC_VER
 #define EIGEN_MAKE_PRAGMA(X) __pragma(#X)
 #else
diff --git a/Eigen/src/Core/util/EmulateArray.h b/Eigen/src/Core/util/EmulateArray.h
index 9414cb2..6cf580e 100644
--- a/Eigen/src/Core/util/EmulateArray.h
+++ b/Eigen/src/Core/util/EmulateArray.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_EMULATE_ARRAY_H
 #define EIGEN_EMULATE_ARRAY_H
@@ -17,9 +18,9 @@
 template <typename T, size_t n>
 class array {
  public:
-  typedef T value_type;
-  typedef T* iterator;
-  typedef const T* const_iterator;
+  using value_type = T;
+  using iterator = T*;
+  using const_iterator = const T*;
 
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE iterator begin() { return values; }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const_iterator begin() const { return values; }
@@ -27,8 +28,8 @@
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE iterator end() { return values + n; }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const_iterator end() const { return values + n; }
 
-  typedef std::reverse_iterator<iterator> reverse_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
   EIGEN_STRONG_INLINE reverse_iterator rbegin() { return reverse_iterator(end()); }
   EIGEN_STRONG_INLINE const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
@@ -222,7 +223,7 @@
 
 #else
 
-// The compiler supports c++11, and we're not targeting cuda: use std::array as Eigen::array
+// Not targeting cuda: use std::array as Eigen::array.
 #include <array>
 
 namespace Eigen {
diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h
index e2e7155..95efe61 100644
--- a/Eigen/src/Core/util/ForwardDeclarations.h
+++ b/Eigen/src/Core/util/ForwardDeclarations.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_FORWARDDECLARATIONS_H
 #define EIGEN_FORWARDDECLARATIONS_H
@@ -28,9 +29,7 @@
 struct traits<const T> : traits<T> {};
 
 template <typename Derived>
-struct has_direct_access {
-  enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
-};
+struct has_direct_access : bool_constant<(traits<Derived>::Flags & DirectAccessBit) != 0> {};
 
 template <typename Derived>
 struct accessors_level {
@@ -74,15 +73,11 @@
 template <typename Derived>
 class ArrayBase;
 
-template <typename ExpressionType, unsigned int Added, unsigned int Removed>
-class Flagged;
 template <typename ExpressionType, template <typename> class StorageBase>
 class NoAlias;
 template <typename ExpressionType>
 class NestByValue;
 template <typename ExpressionType>
-class ForceAlignedAccess;
-template <typename ExpressionType>
 class SwapWrapper;
 
 template <typename XprType, int BlockRows = Dynamic, int BlockCols = Dynamic, bool InnerPanel = false>
@@ -122,8 +117,6 @@
 class DiagonalWrapper;
 template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime>
 class DiagonalMatrix;
-template <typename MatrixType, typename DiagonalType, int ProductOrder>
-class DiagonalProduct;
 template <typename MatrixType, int Index = 0>
 class Diagonal;
 template <typename Derived>
@@ -134,6 +127,11 @@
 class SkewSymmetricMatrix3;
 template <int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType = int>
 class PermutationMatrix;
+template <typename Scalar_, int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime,
+          typename StorageIndex_ = int>
+class ScaledPermutationMatrix;
+template <typename Derived>
+class ScaledPermutationBase;
 template <int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType = int>
 class Transpositions;
 template <typename Derived>
@@ -160,7 +158,7 @@
 class RefBase;
 template <typename PlainObjectType, int Options = 0,
           typename StrideType =
-              typename std::conditional_t<PlainObjectType::IsVectorAtCompileTime, InnerStride<1>, OuterStride<>>>
+              std::conditional_t<PlainObjectType::IsVectorAtCompileTime, InnerStride<1>, OuterStride<>>>
 class Ref;
 template <typename ViewOp, typename MatrixType, typename StrideType = Stride<0, 0>>
 class CwiseUnaryView;
@@ -199,14 +197,6 @@
 class subvector_stl_iterator;
 template <typename XprType, DirectionType Direction>
 class subvector_stl_reverse_iterator;
-template <typename DecompositionType>
-struct kernel_retval_base;
-template <typename DecompositionType>
-struct kernel_retval;
-template <typename DecompositionType>
-struct image_retval_base;
-template <typename DecompositionType>
-struct image_retval;
 }  // end namespace internal
 
 namespace internal {
@@ -219,15 +209,12 @@
 template <typename Lhs, typename Rhs>
 struct product_type;
 
-template <bool>
-struct EnableIf;
-
 /** \internal
  * \class product_evaluator
  * Products need their own evaluator with more template arguments allowing for
  * easier partial template specializations.
  */
-template <typename T, int ProductTag = internal::product_type<typename T::Lhs, typename T::Rhs>::ret,
+template <typename T, int ProductTag = internal::product_type<typename T::Lhs, typename T::Rhs>::value,
           typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
           typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
           typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
@@ -235,13 +222,6 @@
 struct product_evaluator;
 }  // namespace internal
 
-template <typename Lhs, typename Rhs, int ProductType = internal::product_type<Lhs, Rhs>::value>
-struct ProductReturnType;
-
-// this is a workaround for sun CC
-template <typename Lhs, typename Rhs>
-struct LazyProductReturnType;
-
 namespace internal {
 
 // Provides scalar/packet-wise product and product with accumulation
@@ -405,24 +385,43 @@
 class VectorwiseOp;
 template <typename MatrixType, int RowFactor, int ColFactor>
 class Replicate;
+template <int Direction, typename LhsType, typename RhsType>
+class Concat;
 template <typename MatrixType, int Direction = BothDirections>
 class Reverse;
 
-#if defined(EIGEN_USE_LAPACKE) && defined(lapack_int)
-// Lapacke interface requires StorageIndex to be lapack_int
-typedef lapack_int DefaultPermutationIndex;
+/* EIGEN_HAS_LAPACK_INT: whether the lapack_int type from the LAPACKE headers is available. Most LAPACKE headers
+ * #define lapack_int (so defined(lapack_int) detects it), but some vendors instead expose lapack_int as a typedef
+ * and #define LAPACK_INT to advertise it. A user whose header does neither can predefine EIGEN_HAS_LAPACK_INT to
+ * 0 or 1 by hand.
+ */
+#ifndef EIGEN_HAS_LAPACK_INT
+#if defined(lapack_int) || defined(LAPACK_INT)
+#define EIGEN_HAS_LAPACK_INT 1
 #else
-typedef int DefaultPermutationIndex;
+#define EIGEN_HAS_LAPACK_INT 0
+#endif
+#endif
+
+#if defined(EIGEN_USE_LAPACKE) && EIGEN_HAS_LAPACK_INT
+// Lapacke interface requires StorageIndex to be lapack_int
+using DefaultPermutationIndex = lapack_int;
+#else
+using DefaultPermutationIndex = int;
+#endif
+
+// Plain static_assert (not EIGEN_STATIC_ASSERT): like the MKL_INT guard it must not be suppressible.
+#if defined(EIGEN_USE_LAPACKE) && defined(EIGEN_USE_BLAS) && EIGEN_HAS_LAPACK_INT
+static_assert(sizeof(lapack_int) == sizeof(BlasIndex),
+              "LAPACKE integer width (lapack_int) does not match the BLAS integer width (Eigen::BlasIndex). Build "
+              "both backends against the same integer interface: pair EIGEN_64BIT_BLAS with an ILP64 LAPACKE "
+              "(lapack_int = 64-bit), or use the 32-bit interface for both.");
 #endif
 
 template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
 class FullPivLU;
 template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
 class PartialPivLU;
-namespace internal {
-template <typename MatrixType>
-struct inverse_impl;
-}
 template <typename MatrixType>
 class HouseholderQR;
 template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
@@ -430,7 +429,15 @@
 template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
 class FullPivHouseholderQR;
 template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class RandColPivHouseholderQR;
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
 class CompleteOrthogonalDecomposition;
+template <typename MatrixType, typename PermutationIndex = DefaultPermutationIndex>
+class RandCompleteOrthogonalDecomposition;
+namespace internal {
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR>
+class CompleteOrthogonalDecompositionImpl;
+}
 template <typename MatrixType>
 class SVDBase;
 template <typename MatrixType, int Options = 0>
@@ -441,6 +448,8 @@
 class LLT;
 template <typename MatrixType, int UpLo = Lower>
 class LDLT;
+template <typename MatrixType, int UpLo = Lower>
+class BunchKaufman;
 template <typename VectorsType, typename CoeffsType, int Side = OnTheLeft>
 class HouseholderSequence;
 template <typename Scalar>
@@ -497,8 +506,8 @@
 namespace internal {
 template <typename Scalar>
 struct stem_function {
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef ComplexScalar type(ComplexScalar, int);
+  using ComplexScalar = internal::make_complex_t<Scalar>;
+  using type = ComplexScalar(ComplexScalar, int);
 };
 }  // namespace internal
 
diff --git a/Eigen/src/Core/util/GpuHipCudaDefines.inc b/Eigen/src/Core/util/GpuHipCudaDefines.inc
index f3d4023..c39ddbd 100644
--- a/Eigen/src/Core/util/GpuHipCudaDefines.inc
+++ b/Eigen/src/Core/util/GpuHipCudaDefines.inc
@@ -7,19 +7,20 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #if defined(EIGEN_USE_GPU) && !defined(EIGEN_CORE_GPU_HIP_CUDA_DEFINES_H)
-#define EIGEN_CXX11_TENSOR_GPU_HIP_CUDA_DEFINES_H
+#define EIGEN_CORE_GPU_HIP_CUDA_DEFINES_H
 
 // Note that we are using EIGEN_USE_HIP here instead of EIGEN_HIPCC...this is by design
 // There is code in the Tensorflow codebase that will define EIGEN_USE_GPU,  but
 // for some reason gets sent to the gcc/host compiler instead of the gpu/nvcc/hipcc compiler
 // When compiling such files, gcc will end up trying to pick up the CUDA headers by
-// default (see the code within "unsupported/Eigen/Tensor" that is guarded by EIGEN_USE_GPU)
+// default (see the code within "contrib/Eigen/Tensor" that is guarded by EIGEN_USE_GPU)
 // This will obviously not work when trying to compile tensorflow on a system with no CUDA
 // To work around this issue for HIP systems (and leave the default behaviour intact), the
 // HIP tensorflow build defines EIGEN_USE_HIP when compiling all source files, and
-// "unsupported/Eigen/Tensor" has been updated to use HIP header when EIGEN_USE_HIP is
+// "contrib/Eigen/Tensor" has been updated to use HIP header when EIGEN_USE_HIP is
 // defined. In continuation of that requirement, the guard here needs to be EIGEN_USE_HIP as well
 
 #if defined(EIGEN_USE_HIP)
@@ -35,6 +36,16 @@
 #define gpuGetErrorName hipGetErrorName
 #define gpuGetErrorString hipGetErrorString
 #define gpuGetDeviceProperties hipGetDeviceProperties
+#define gpuDeviceGetAttribute hipDeviceGetAttribute
+#define gpuDevAttrMultiProcessorCount hipDeviceAttributeMultiprocessorCount
+#define gpuDevAttrMaxThreadsPerBlock hipDeviceAttributeMaxThreadsPerBlock
+#define gpuDevAttrMaxThreadsPerMultiProcessor hipDeviceAttributeMaxThreadsPerMultiProcessor
+#define gpuDevAttrMaxSharedMemoryPerBlock hipDeviceAttributeMaxSharedMemoryPerBlock
+#define gpuDevAttrMaxSharedMemoryPerBlockOptin hipDeviceAttributeSharedMemPerBlockOptin
+#define gpuDevAttrComputeCapabilityMajor hipDeviceAttributeComputeCapabilityMajor
+#define gpuDevAttrComputeCapabilityMinor hipDeviceAttributeComputeCapabilityMinor
+#define gpuDevAttrWarpSize hipDeviceAttributeWarpSize
+#define gpuDevAttrMemoryPoolsSupported hipDeviceAttributeMemoryPoolsSupported
 #define gpuStreamDefault hipStreamDefault
 #define gpuGetDevice hipGetDevice
 #define gpuSetDevice hipSetDevice
@@ -47,8 +58,6 @@
 #define gpuMemcpyDeviceToHost hipMemcpyDeviceToHost
 #define gpuMemcpyHostToDevice hipMemcpyHostToDevice
 #define gpuStreamQuery hipStreamQuery
-#define gpuSharedMemConfig hipSharedMemConfig
-#define gpuDeviceSetSharedMemConfig hipDeviceSetSharedMemConfig
 #define gpuStreamSynchronize hipStreamSynchronize
 #define gpuDeviceSynchronize hipDeviceSynchronize
 #define gpuMemcpy hipMemcpy
@@ -66,6 +75,16 @@
 #define gpuGetErrorName cudaGetErrorName
 #define gpuGetErrorString cudaGetErrorString
 #define gpuGetDeviceProperties cudaGetDeviceProperties
+#define gpuDeviceGetAttribute cudaDeviceGetAttribute
+#define gpuDevAttrMultiProcessorCount cudaDevAttrMultiProcessorCount
+#define gpuDevAttrMaxThreadsPerBlock cudaDevAttrMaxThreadsPerBlock
+#define gpuDevAttrMaxThreadsPerMultiProcessor cudaDevAttrMaxThreadsPerMultiProcessor
+#define gpuDevAttrMaxSharedMemoryPerBlock cudaDevAttrMaxSharedMemoryPerBlock
+#define gpuDevAttrMaxSharedMemoryPerBlockOptin cudaDevAttrMaxSharedMemoryPerBlockOptin
+#define gpuDevAttrComputeCapabilityMajor cudaDevAttrComputeCapabilityMajor
+#define gpuDevAttrComputeCapabilityMinor cudaDevAttrComputeCapabilityMinor
+#define gpuDevAttrWarpSize cudaDevAttrWarpSize
+#define gpuDevAttrMemoryPoolsSupported cudaDevAttrMemoryPoolsSupported
 #define gpuStreamDefault cudaStreamDefault
 #define gpuGetDevice cudaGetDevice
 #define gpuSetDevice cudaSetDevice
@@ -78,8 +97,6 @@
 #define gpuMemcpyDeviceToHost cudaMemcpyDeviceToHost
 #define gpuMemcpyHostToDevice cudaMemcpyHostToDevice
 #define gpuStreamQuery cudaStreamQuery
-#define gpuSharedMemConfig cudaSharedMemConfig
-#define gpuDeviceSetSharedMemConfig cudaDeviceSetSharedMemConfig
 #define gpuStreamSynchronize cudaStreamSynchronize
 #define gpuDeviceSynchronize cudaDeviceSynchronize
 #define gpuMemcpy cudaMemcpy
diff --git a/Eigen/src/Core/util/GpuHipCudaUndefines.inc b/Eigen/src/Core/util/GpuHipCudaUndefines.inc
index 342a323..300d704 100644
--- a/Eigen/src/Core/util/GpuHipCudaUndefines.inc
+++ b/Eigen/src/Core/util/GpuHipCudaUndefines.inc
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #if defined(EIGEN_CORE_GPU_HIP_CUDA_DEFINES_H)
 
@@ -18,8 +19,21 @@
 #undef gpuSuccess
 #undef gpuErrorNotReady
 #undef gpuGetDeviceCount
+#undef gpuGetLastError
+#undef gpuPeekAtLastError
+#undef gpuGetErrorName
 #undef gpuGetErrorString
 #undef gpuGetDeviceProperties
+#undef gpuDeviceGetAttribute
+#undef gpuDevAttrMultiProcessorCount
+#undef gpuDevAttrMaxThreadsPerBlock
+#undef gpuDevAttrMaxThreadsPerMultiProcessor
+#undef gpuDevAttrMaxSharedMemoryPerBlock
+#undef gpuDevAttrMaxSharedMemoryPerBlockOptin
+#undef gpuDevAttrComputeCapabilityMajor
+#undef gpuDevAttrComputeCapabilityMinor
+#undef gpuDevAttrWarpSize
+#undef gpuDevAttrMemoryPoolsSupported
 #undef gpuStreamDefault
 #undef gpuGetDevice
 #undef gpuSetDevice
@@ -32,8 +46,6 @@
 #undef gpuMemcpyDeviceToHost
 #undef gpuMemcpyHostToDevice
 #undef gpuStreamQuery
-#undef gpuSharedMemConfig
-#undef gpuDeviceSetSharedMemConfig
 #undef gpuStreamSynchronize
 #undef gpuDeviceSynchronize
 #undef gpuMemcpy
diff --git a/Eigen/src/Core/util/GpuRuntime.h b/Eigen/src/Core/util/GpuRuntime.h
new file mode 100644
index 0000000..fb385dc
--- /dev/null
+++ b/Eigen/src/Core/util/GpuRuntime.h
@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Host-side helpers shared by the CUDA and HIP paths of the Tensor GPU device: reporting of failed runtime calls
+// and checked kernel launches. Written against the gpu* aliases of GpuHipCudaDefines.inc, so it is only meaningful
+// inside that alias window (TensorDeviceGpu.h includes it there) and neither includes nor undefines the .inc files
+// itself; outside the window it is inert, so a standalone parse sees nothing. The macros below may expand after the
+// window closes, which is why each of them only calls a function defined here.
+#if defined(EIGEN_CORE_GPU_HIP_CUDA_DEFINES_H) && !defined(EIGEN_CORE_UTIL_GPU_RUNTIME_H)
+#define EIGEN_CORE_UTIL_GPU_RUNTIME_H
+
+#include <cstdio>
+#include <cstdlib>
+#include <utility>
+
+namespace Eigen {
+namespace internal {
+
+// Prints `file:line: call: error name: description` to stderr and stops: std::abort() where assertions are
+// compiled out, a failed eigen_assert otherwise, so a debugger or the test harness sees the usual assertion.
+inline void gpu_runtime_check_failed(gpuError_t error, const char* expression, const char* file, int line) {
+  std::fprintf(stderr, "%s:%d: %s: %s: %s\n", file, line, expression, gpuGetErrorName(error), gpuGetErrorString(error));
+#if defined(EIGEN_NO_DEBUG)
+  std::abort();
+#else
+  eigen_assert(false && "GPU runtime call failed");
+#endif
+}
+
+inline void gpu_runtime_check(gpuError_t error, const char* expression, const char* file, int line) {
+  if (error != gpuSuccess) gpu_runtime_check_failed(error, expression, file, line);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+// EIGEN_GPU_RUNTIME_CHECK(call) evaluates a runtime-API call once and reports a failure through
+// gpu_runtime_check_failed(). Define the macro before including the module to route failures elsewhere; define
+// EIGEN_GPU_NO_RUNTIME_CHECKS to evaluate the call and ignore its result, which is what release builds did before.
+#if !defined(EIGEN_GPU_RUNTIME_CHECK)
+#if defined(EIGEN_GPU_NO_RUNTIME_CHECKS)
+#define EIGEN_GPU_RUNTIME_CHECK(expr) \
+  do {                                \
+    (void)(expr);                     \
+  } while (0)
+#else
+#define EIGEN_GPU_RUNTIME_CHECK(expr)                                        \
+  do {                                                                       \
+    ::Eigen::internal::gpu_runtime_check((expr), #expr, __FILE__, __LINE__); \
+  } while (0)
+#endif
+#endif
+
+#if defined(EIGEN_GPUCC)
+namespace Eigen {
+namespace internal {
+
+// Enqueues `kernel` on `stream` and reports a launch failure through EIGEN_GPU_RUNTIME_CHECK. hip-clang accepts the
+// <<<>>> syntax, so CUDA and HIP share one definition; the kernel is passed as the function pointer the occupancy
+// API takes as well. With EIGEN_GPU_SYNC_LAUNCHES defined every launch is followed by a checked synchronization of
+// its stream, so an execution failure is reported at the launch that caused it rather than at a later call.
+template <typename... KernelArgs, typename... Args>
+void gpu_launch(void (*kernel)(KernelArgs...), dim3 grid, dim3 block, size_t shared_mem, gpuStream_t stream,
+                Args&&... args) {
+  // clang-format off
+  kernel<<<grid, block, shared_mem, stream>>>(std::forward<Args>(args)...);
+  // clang-format on
+  EIGEN_GPU_RUNTIME_CHECK(gpuGetLastError());
+#if defined(EIGEN_GPU_SYNC_LAUNCHES)
+  EIGEN_GPU_RUNTIME_CHECK(gpuStreamSynchronize(stream));
+#endif
+}
+
+}  // namespace internal
+}  // namespace Eigen
+#endif  // EIGEN_GPUCC
+
+#endif  // EIGEN_CORE_UTIL_GPU_RUNTIME_H
diff --git a/Eigen/src/Core/util/IndexedViewHelper.h b/Eigen/src/Core/util/IndexedViewHelper.h
index d18b258..a612209 100644
--- a/Eigen/src/Core/util/IndexedViewHelper.h
+++ b/Eigen/src/Core/util/IndexedViewHelper.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INDEXED_VIEW_HELPER_H
 #define EIGEN_INDEXED_VIEW_HELPER_H
@@ -24,7 +25,7 @@
 
 namespace placeholders {
 
-typedef symbolic::SymbolExpr<internal::symbolic_last_tag> last_t;
+using last_t = symbolic::SymbolExpr<internal::symbolic_last_tag>;
 
 /** \var last
  * \ingroup Core_Module
@@ -47,10 +48,9 @@
  */
 static constexpr const last_t last;
 
-typedef symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,
-                          symbolic::ValueExpr<Eigen::internal::FixedInt<1>>>
-    lastp1_t;
-typedef Eigen::internal::all_t all_t;
+using lastp1_t = symbolic::AddExpr<symbolic::SymbolExpr<internal::symbolic_last_tag>,
+                                   symbolic::ValueExpr<Eigen::internal::FixedInt<1>>>;
+using all_t = Eigen::internal::all_t;
 
 /** \var lastp1
  * \ingroup Core_Module
@@ -125,6 +125,15 @@
 // Handling of generic indices (e.g. array)
 //--------------------------------------------------------------------------------
 
+// Detect Eigen expression types that are not plain objects (Matrix/Array).
+// These types may hold internal references to temporaries and must be evaluated before storing.
+template <typename T, typename = void>
+struct is_eigen_index_expression : std::false_type {};
+
+template <typename T>
+struct is_eigen_index_expression<T, std::enable_if_t<!std::is_same<T, typename T::PlainObject>::value>>
+    : std::true_type {};
+
 // Potentially wrap indices in a type that is better-suited for IndexedView evaluation.
 template <typename Indices, int NestedSizeAtCompileTime, typename EnableIf = void>
 struct IndexedViewHelperIndicesWrapper {
@@ -132,6 +141,15 @@
   static const type& CreateIndexSequence(const Indices& indices, Index /*nested_size*/) { return indices; }
 };
 
+// Specialization for Eigen expression types (Reshaped, Block, CwiseOp, etc.) used as indices.
+// These may hold dangling references to temporaries if not evaluated.
+template <typename Indices, int NestedSizeAtCompileTime>
+struct IndexedViewHelperIndicesWrapper<Indices, NestedSizeAtCompileTime,
+                                       std::enable_if_t<is_eigen_index_expression<Indices>::value>> {
+  using type = typename Indices::PlainObject;
+  static type CreateIndexSequence(const Indices& indices, Index /*nested_size*/) { return indices.eval(); }
+};
+
 // Extract compile-time and runtime first, size, increments.
 template <typename Indices, typename EnableIf = void>
 struct IndexedViewHelper {
@@ -232,10 +250,10 @@
 };
 
 template <typename T>
-struct is_single_range : public std::false_type {};
+struct is_single_range : std::false_type {};
 
 template <Index ValueAtCompileTime>
-struct is_single_range<SingleRange<ValueAtCompileTime>> : public std::true_type {};
+struct is_single_range<SingleRange<ValueAtCompileTime>> : std::true_type {};
 
 template <typename SingleIndex, int NestedSizeAtCompileTime>
 struct IndexedViewHelperIndicesWrapper<
@@ -416,9 +434,8 @@
   using ColMajorReturnType = IndexedView<Derived, IvcType<Indices, Derived::SizeAtCompileTime>, ZeroIndex>;
   using ConstColMajorReturnType = IndexedView<const Derived, IvcType<Indices, Derived::SizeAtCompileTime>, ZeroIndex>;
 
-  using ReturnType = typename internal::conditional<IsRowMajor, RowMajorReturnType, ColMajorReturnType>::type;
-  using ConstReturnType =
-      typename internal::conditional<IsRowMajor, ConstRowMajorReturnType, ConstColMajorReturnType>::type;
+  using ReturnType = std::conditional_t<IsRowMajor, RowMajorReturnType, ColMajorReturnType>;
+  using ConstReturnType = std::conditional_t<IsRowMajor, ConstRowMajorReturnType, ConstColMajorReturnType>;
 
   template <bool UseRowMajor = IsRowMajor, std::enable_if_t<UseRowMajor, bool> = true>
   static inline RowMajorReturnType run(Derived& derived, const Indices& indices) {
diff --git a/Eigen/src/Core/util/IntegralConstant.h b/Eigen/src/Core/util/IntegralConstant.h
index f79fea8..df347cc 100644
--- a/Eigen/src/Core/util/IntegralConstant.h
+++ b/Eigen/src/Core/util/IntegralConstant.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INTEGRAL_CONSTANT_H
 #define EIGEN_INTEGRAL_CONSTANT_H
@@ -27,11 +28,11 @@
  *
  * This class embeds a compile-time integer \c N.
  *
- * It is similar to c++11 std::integral_constant<int,N> but with some additional features
+ * It is similar to std::integral_constant<int,N> but with some additional features
  * such as:
  *  - implicit conversion to int
  *  - arithmetic and some bitwise operators: -, +, *, /, %, &, |
- *  - c++98/14 compatibility with fix<N> and fix<N>() syntax to define integral constants.
+ *  - fix<N> and fix<N>() syntax to define integral constants.
  *
  * It is strongly discouraged to directly deal with this class FixedInt. Instances are expected to
  * be created by the user using Eigen::fix<N> or Eigen::fix<N>().
@@ -61,9 +62,7 @@
   constexpr FixedInt(std::integral_constant<int, N>) {}
 
   constexpr FixedInt(VariableAndFixedInt<N> other) {
-#ifndef EIGEN_INTERNAL_DEBUGGING
     EIGEN_UNUSED_VARIABLE(other);
-#endif
     eigen_internal_assert(int(other) == N);
   }
 
@@ -181,29 +180,29 @@
 // By default, no cleanup:
 template <typename T, int DynamicKey = Dynamic, typename EnableIf = void>
 struct cleanup_index_type {
-  typedef T type;
+  using type = T;
 };
 
 // Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index
 template <typename T, int DynamicKey>
-struct cleanup_index_type<T, DynamicKey, std::enable_if_t<internal::is_integral<T>::value>> {
-  typedef Index type;
+struct cleanup_index_type<T, DynamicKey, std::enable_if_t<std::is_integral<T>::value>> {
+  using type = Index;
 };
 
 // If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value:
 template <int N, int DynamicKey>
 struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> {
-  typedef FixedInt<N> type;
+  using type = FixedInt<N>;
 };
 // If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index):
 template <int DynamicKey>
 struct cleanup_index_type<VariableAndFixedInt<DynamicKey>, DynamicKey> {
-  typedef Index type;
+  using type = Index;
 };
 
 template <int N, int DynamicKey>
 struct cleanup_index_type<std::integral_constant<int, N>, DynamicKey> {
-  typedef FixedInt<N> type;
+  using type = FixedInt<N>;
 };
 
 }  // end namespace internal
diff --git a/Eigen/src/Core/util/LruCache.h b/Eigen/src/Core/util/LruCache.h
new file mode 100644
index 0000000..57e51a0
--- /dev/null
+++ b/Eigen/src/Core/util/LruCache.h
@@ -0,0 +1,124 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_LRU_CACHE_H
+#define EIGEN_LRU_CACHE_H
+
+#include <cstddef>
+#include <functional>
+#include <list>
+#include <unordered_map>
+#include <utility>
+
+#include "../InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+// Bounded least-recently-used cache.
+//
+// Keyed on Key (hashed by Hash, compared by KeyEqual) and storing movable
+// Value objects. find() and insert() are O(1) average: an unordered_map
+// lookup plus a constant-time std::list splice. On hit, the touched entry
+// is promoted to the front of the list. On insert into a full cache, the
+// back of the list (least-recently-used) is destroyed before the new entry
+// is added — Value's destructor runs, so an RAII Value handles eviction
+// cleanup without any additional callback machinery.
+//
+// Thread safety: none. Callers must serialize.
+//
+// Not intended for hot-loop O(n) workloads where n is large; for the small
+// caches Eigen uses (handful of entries, low shape cardinality), the
+// node-allocation overhead of std::list / std::unordered_map is amortized
+// across many hits per insert.
+template <typename Key, typename Value, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
+class LruCache {
+ public:
+  using key_type = Key;
+  using value_type = Value;
+
+  explicit LruCache(std::size_t capacity) : capacity_(capacity) {
+    eigen_assert(capacity_ > 0 && "LruCache capacity must be positive");
+    // Pre-size the bucket array so the map never rehashes while filling. A
+    // rehash is otherwise guaranteed once load factor crosses ~1.0.
+    index_.reserve(capacity_);
+  }
+
+  LruCache(const LruCache&) = delete;
+  LruCache& operator=(const LruCache&) = delete;
+
+  LruCache(LruCache&& o) noexcept : capacity_(o.capacity_), items_(std::move(o.items_)), index_(std::move(o.index_)) {}
+
+  LruCache& operator=(LruCache&& o) noexcept {
+    if (this != &o) {
+      capacity_ = o.capacity_;
+      items_ = std::move(o.items_);
+      index_ = std::move(o.index_);
+    }
+    return *this;
+  }
+
+  ~LruCache() = default;
+
+  // Returns a pointer to the cached value and marks it most-recently-used,
+  // or nullptr if the key is not present.
+  Value* find(const Key& key) {
+    auto map_it = index_.find(key);
+    if (map_it == index_.end()) return nullptr;
+    items_.splice(items_.begin(), items_, map_it->second);
+    return &map_it->second->second;
+  }
+
+  // Inserts (key, value), evicting the least-recently-used entry if the cache
+  // is at capacity. If the key already exists, the existing entry is destroyed
+  // and a new entry is inserted as most-recently-used.
+  // Returns a pointer to the inserted value, or nullptr if capacity is 0
+  // (degenerate case — assert-firing in debug; the early return keeps release
+  // builds from dereferencing items_.back() on an empty list).
+  Value* insert(const Key& key, Value value) {
+    if (capacity_ == 0) return nullptr;
+    auto map_it = index_.find(key);
+    if (map_it != index_.end()) {
+      auto old_it = map_it->second;
+      items_.emplace_front(key, std::move(value));
+      map_it->second = items_.begin();
+      items_.erase(old_it);
+      return &map_it->second->second;
+    }
+    if (items_.size() >= capacity_) {
+      index_.erase(items_.back().first);
+      items_.pop_back();
+    }
+    items_.emplace_front(key, std::move(value));
+    index_.emplace(key, items_.begin());
+    return &items_.front().second;
+  }
+
+  void clear() {
+    items_.clear();
+    index_.clear();
+  }
+
+  std::size_t size() const { return items_.size(); }
+  std::size_t capacity() const { return capacity_; }
+  bool empty() const { return items_.empty(); }
+
+ private:
+  using list_type = std::list<std::pair<Key, Value>>;
+
+  std::size_t capacity_;
+  list_type items_;
+  std::unordered_map<Key, typename list_type::iterator, Hash, KeyEqual> index_;
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_LRU_CACHE_H
diff --git a/Eigen/src/Core/util/MKL_support.h b/Eigen/src/Core/util/MKL_support.h
index 3e44a26..6ed22e3 100644
--- a/Eigen/src/Core/util/MKL_support.h
+++ b/Eigen/src/Core/util/MKL_support.h
@@ -29,10 +29,14 @@
  *   Include file with common MKL declarations
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_MKL_SUPPORT_H
 #define EIGEN_MKL_SUPPORT_H
 
+/* Eigen/Core includes this header well before Meta.h, so <cstdint> is not yet available for EIGEN_BLAS_INT. */
+#include <cstdint>
+
 #ifdef EIGEN_USE_MKL_ALL
 #ifndef EIGEN_USE_BLAS
 #define EIGEN_USE_BLAS
@@ -72,7 +76,6 @@
 #undef EIGEN_USE_LAPACKE
 #undef EIGEN_USE_MKL_VML
 #undef EIGEN_USE_LAPACKE_STRICT
-#undef EIGEN_USE_LAPACKE
 #ifdef MKL_DIRECT_CALL_JUST_SET
 #undef MKL_DIRECT_CALL
 #endif
@@ -116,24 +119,44 @@
 #endif
 #endif
 
+/* Integer width of the external BLAS interface.
+ *
+ * Fortran BLAS passes every dimension and stride by pointer, so a width mismatch between Eigen and the linked library
+ * is invisible to both the compiler and the linker and silently corrupts arguments at run time. Define
+ * EIGEN_64BIT_BLAS to select the 64-bit-integer ("ILP64") interface. It is an ABI-affecting macro and must be
+ * consistent across all translation units.
+ */
+#if defined(EIGEN_64BIT_BLAS)
+#define EIGEN_BLAS_INT std::int64_t
+#else
+#define EIGEN_BLAS_INT int
+#endif
+
+/* Suffix appended to external BLAS symbol names, for libraries that expose the 64-bit interface under decorated names
+ * rather than in a separate library: reference LAPACK built with BUILD_INDEX64_EXT_API and oneMKL >= 2025 use _64
+ * (dgemm_64_), as does OpenBLAS built with SYMBOLSUFFIX=64_. Libraries that keep the undecorated names in a separate
+ * ILP64 build (oneMKL *_ilp64, plain OpenBLAS INTERFACE64=1) need only EIGEN_64BIT_BLAS.
+ */
+#ifndef EIGEN_BLAS_SYMBOL_SUFFIX
+#define EIGEN_BLAS_SYMBOL_SUFFIX
+#endif
+/* EIGEN_BLAS_POSTFIX is the suffix plus the Fortran trailing underscore (_ by default, _64_ for a _64 build).
+ * Both go through EIGEN_CAT rather than bare ##, which would suppress expansion of the argument.
+ */
+#define EIGEN_BLAS_POSTFIX EIGEN_CAT(EIGEN_BLAS_SYMBOL_SUFFIX, _)
+#define EIGEN_BLAS_SYM(NAME) EIGEN_CAT(NAME, EIGEN_BLAS_POSTFIX)
+
 #if defined(EIGEN_USE_BLAS) && !defined(EIGEN_USE_MKL)
-#include "../../misc/blas.h"
+#include "blas.h"
 #endif
 
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
 
-namespace Eigen {
-
-typedef std::complex<double> dcomplex;
-typedef std::complex<float> scomplex;
-
-#if defined(EIGEN_USE_MKL)
-typedef MKL_INT BlasIndex;
-#else
-typedef int BlasIndex;
-#endif
-
-}  // end namespace Eigen
+/* dcomplex, scomplex, and BlasIndex are used by both the BLAS and LAPACKE backends, so they live in a
+ * backend-neutral header. It is included here, after the integer-width macros above are set, because BlasIndex
+ * depends on them.
+ */
+#include "BlasTypes.h"
 
 #endif  // EIGEN_MKL_SUPPORT_H
diff --git a/Eigen/src/Core/util/Macros.h b/Eigen/src/Core/util/Macros.h
index 4952612..3f04bff 100644
--- a/Eigen/src/Core/util/Macros.h
+++ b/Eigen/src/Core/util/Macros.h
@@ -7,12 +7,18 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MACROS_H
 #define EIGEN_MACROS_H
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
 
+// for __cpp_lib feature test macros
+#if defined(__has_include) && __has_include(<version>)
+#include <version>
+#endif
+
 //------------------------------------------------------------------------------------------
 // Eigen version and basic defaults
 //------------------------------------------------------------------------------------------
@@ -54,26 +60,9 @@
 #else
   #define EIGEN_STACK_ALLOCATION_LIMIT 16384
 #endif
-#endif
-
-/* Specify whether to use std::fma for scalar multiply-add instructions.
- *
- * On machines that have FMA as a single instruction, this will generally
- * improve precision without significant performance implications.
- *
- * Without a single instruction, performance has been found to be reduced 2-3x
- * on Intel CPUs, and up to 30x for WASM.
- *
- * If unspecified, defaults to using FMA if hardware support is available.
- * The default should be used in most cases to ensure consistency between
- * vectorized and non-vectorized paths.
- */
-#ifndef EIGEN_SCALAR_MADD_USE_FMA
-#ifdef EIGEN_VECTORIZE_FMA
-#define EIGEN_SCALAR_MADD_USE_FMA 1
-#else
-#define EIGEN_SCALAR_MADD_USE_FMA 0
-#endif
+// Marks the limit above as Eigen's own, so that a backend needing more room can raise it without
+// overriding a caller's stack-safety policy. ConfigureVectorization.h consumes and undefines it.
+#define EIGEN_STACK_ALLOCATION_LIMIT_WAS_DEFAULTED
 #endif
 
 //------------------------------------------------------------------------------------------
@@ -87,7 +76,7 @@
 #define EIGEN_COMP_GNUC 0
 #endif
 
-/// \internal EIGEN_COMP_CLANG set to version (e.g., 372 for clang 3.7.2) if the compiler is clang
+/// \internal EIGEN_COMP_CLANG set to version (e.g., 1400 for clang 14.0.0) if the compiler is clang
 #if defined(__clang__)
 #define EIGEN_COMP_CLANG (__clang_major__ * 100 + __clang_minor__ * 10 + __clang_patchlevel__)
 #else
@@ -152,13 +141,8 @@
 #endif
 
 #if defined(__NVCC__)
-#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9)
+// CUDA 11.4+ always defines __CUDACC_VER_MAJOR__.
 #define EIGEN_COMP_NVCC ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100))
-#elif defined(__CUDACC_VER__)
-#define EIGEN_COMP_NVCC __CUDACC_VER__
-#else
-#error "NVCC did not define compiler version."
-#endif
 #else
 #define EIGEN_COMP_NVCC 0
 #endif
@@ -305,6 +289,25 @@
 #define EIGEN_GNUC_STRICT_LESS_THAN(x, y, z) 0
 #endif
 
+// Work around GCC PR tree-optimization/92420, which miscompiles some packetized complex arithmetic under -ffast-math.
+// The bug was introduced by GCC r238039, fixed on the GCC 8 branch by
+// https://gcc.gnu.org/g:785eda9390473e42f0e0b7199c42032a0432de68 and on the GCC 9 branch by
+// https://gcc.gnu.org/g:2d8ea3a0a6095a56b7c59c50b1068d602cde934a.
+// See also GitLab issues #1839 and #1840.
+#if defined(__FAST_MATH__) && EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_STRICT_AT_LEAST(7, 0, 0) && \
+    (EIGEN_GNUC_STRICT_LESS_THAN(8, 4, 0) ||                                                   \
+     (EIGEN_GNUC_STRICT_AT_LEAST(9, 0, 0) && EIGEN_GNUC_STRICT_LESS_THAN(9, 3, 0)))
+#define EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_BUG 1
+// Disable the affected loop vectorizer around the complex packet helpers.
+#define EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH \
+  _Pragma("GCC push_options") _Pragma("GCC optimize(\"no-tree-loop-vectorize\")")
+#define EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP _Pragma("GCC pop_options")
+#else
+#define EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_BUG 0
+#define EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_PUSH
+#define EIGEN_GCC_FAST_MATH_COMPLEX_VECTORIZE_WORKAROUND_POP
+#endif
+
 /// \internal EIGEN_COMP_CLANG_STRICT set to 1 if the compiler is really Clang and not a compatible compiler (e.g.,
 /// AppleClang, etc.)
 #if EIGEN_COMP_CLANG && !(EIGEN_COMP_CLANGAPPLE || EIGEN_COMP_CLANGICC || EIGEN_COMP_CLANGFCC || EIGEN_COMP_CLANGCPE)
@@ -379,15 +382,15 @@
 
 /// \internal EIGEN_HAS_ARM64_FP16 set to 1 if the architecture provides an IEEE
 /// compliant Arm fp16 type
-#if EIGEN_ARCH_ARM_OR_ARM64
 #ifndef EIGEN_HAS_ARM64_FP16
-#if defined(__ARM_FP16_FORMAT_IEEE)
+// NOTE: Older versions of Clang miscompile `__fp16` implicit conversions to `float`
+// on ARMv7 targets: <https://gitlab.com/libeigen/eigen/-/merge_requests/2273#note_3400347860>.
+#if EIGEN_ARCH_ARMV8 && defined(__ARM_FP16_FORMAT_IEEE)
 #define EIGEN_HAS_ARM64_FP16 1
 #else
 #define EIGEN_HAS_ARM64_FP16 0
 #endif
 #endif
-#endif
 
 /// \internal EIGEN_ARCH_MIPS set to 1 if the architecture is MIPS
 #if defined(__mips__) || defined(__mips)
@@ -455,8 +458,8 @@
 #define EIGEN_OS_ANDROID 1
 
 // Since NDK r16, `__NDK_MAJOR__` and `__NDK_MINOR__` are defined in
-// <android/ndk-version.h>. For NDK < r16, users should define these macros,
-// e.g. `-D__NDK_MAJOR__=11 -D__NKD_MINOR__=0` for NDK r11.
+// <android/ndk-version.h>. Include it when available so NDK-version-specific
+// workarounds can use these macros.
 #if defined __has_include
 #if __has_include(<android/ndk-version.h>)
 #include <android/ndk-version.h>
@@ -579,6 +582,19 @@
 #define EIGEN_CUDA_SDK_VER 0
 #endif
 
+// CUDA 11.8 is the oldest toolkit in GPU CI (it supports the sm_89 runners), not a new packet-intrinsic requirement.
+#if defined(EIGEN_CUDACC) && EIGEN_CUDA_SDK_VER > 0 && EIGEN_CUDA_SDK_VER < 110800
+#error "Eigen requires CUDA 11.8 or later."
+#endif
+
+// Native FP16 packet math intrinsics (e.g. __hfma2, h2exp, h2log) are only
+// declared by the CUDA headers when __CUDA_ARCH__ >= 530. Guard the device
+// pass with a clear error rather than surfacing as "identifier `__hfma2` is
+// undefined" deep inside PacketMath.h.
+#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH < 600
+#error "Eigen requires CUDA compute capability >= 6.0 (sm_60). Compile with -arch=sm_60 or higher."
+#endif
+
 #if defined(__HIPCC__) && !defined(EIGEN_NO_HIP) && !defined(__SYCL_DEVICE_ONLY__)
 // Means the compiler is HIPCC (analogous to EIGEN_CUDACC, but for HIP)
 #define EIGEN_HIPCC __HIPCC__
@@ -588,30 +604,33 @@
 // ++ host_defines.h which contains the defines for the __host__ and __device__ macros
 #include <hip/hip_runtime.h>
 
+// Eigen requires ROCm/HIP >= 5.6 (GFX906 minimum architecture).
+// This floor exists to allow simplifying shared CUDA/HIP preprocessor guards —
+// all __HIP_ARCH_HAS_WARP_SHUFFLE__, __HIP_ARCH_HAS_FP16__, etc. are always true on GFX906+.
+#if defined(HIP_VERSION_MAJOR) && (HIP_VERSION_MAJOR < 5 || (HIP_VERSION_MAJOR == 5 && HIP_VERSION_MINOR < 6))
+#error "Eigen requires ROCm/HIP >= 5.6."
+#endif
+
 #if defined(__HIP_DEVICE_COMPILE__) && !defined(__SYCL_DEVICE_ONLY__)
 // analogous to EIGEN_CUDA_ARCH, but for HIP
 #define EIGEN_HIP_DEVICE_COMPILE __HIP_DEVICE_COMPILE__
 #endif
 
-// For HIP (ROCm 3.5 and higher), we need to explicitly set the launch_bounds attribute
-// value to 1024. The compiler assigns a default value of 256 when the attribute is not
-// specified. This results in failures on the HIP platform, for cases when a GPU kernel
-// without an explicit launch_bounds attribute is called with a threads_per_block value
-// greater than 256.
-//
-// This is a regression in functionality and is expected to be fixed within the next
-// couple of ROCm releases (compiler will go back to using 1024 value as the default)
-//
-// In the meantime, we will use a "only enabled for HIP" macro to set the launch_bounds
-// attribute.
-
-#define EIGEN_HIP_LAUNCH_BOUNDS_1024 __launch_bounds__(1024)
-
 #endif
 
+// Launch-bounds attribute under either GPU compiler, nothing elsewhere. Eigen's
+// kernels declare 1024 (EIGEN_HIP_LAUNCH_BOUNDS_1024 is the older spelling):
+// hipcc defaults to 256 and refuses larger blocks at launch, and nvcc without a
+// bound may allocate registers so that a 1024-thread launch fails with
+// cudaErrorLaunchOutOfResources (the 3D convolution kernel does).
+#if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
+#define EIGEN_GPU_LAUNCH_BOUNDS(n) __launch_bounds__(n)
+#else
+#define EIGEN_GPU_LAUNCH_BOUNDS(n)
+#endif
 #if !defined(EIGEN_HIP_LAUNCH_BOUNDS_1024)
-#define EIGEN_HIP_LAUNCH_BOUNDS_1024
-#endif  // !defined(EIGEN_HIP_LAUNCH_BOUNDS_1024)
+#define EIGEN_HIP_LAUNCH_BOUNDS_1024 EIGEN_GPU_LAUNCH_BOUNDS(1024)
+#endif
 
 // Unify CUDA/HIPCC
 
@@ -620,6 +639,17 @@
 // If either EIGEN_CUDACC or EIGEN_HIPCC is defined, then define EIGEN_GPUCC
 //
 #define EIGEN_GPUCC
+// NOTE: Some platforms (e.g. SPIRV) artificially set the CUDA SDK version to 0,
+// and don't support FP16, so we need to check the version number here. Every real toolkit is past the CUDA 11.8
+// floor checked above, so this only distinguishes "has a version" from "reports none".
+#if defined(EIGEN_CUDACC) && EIGEN_CUDA_SDK_VER > 0
+#define EIGEN_HAS_CUDA_FP16 1
+#elif defined(EIGEN_HIPCC)
+#define EIGEN_HAS_HIP_FP16 1
+#endif
+#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
+#define EIGEN_HAS_GPU_FP16 1
+#endif
 //
 // EIGEN_HIPCC implies the HIP compiler and is used to tweak Eigen code for use in HIP kernels
 // EIGEN_CUDACC implies the CUDA compiler and is used to tweak Eigen code for use in CUDA kernels
@@ -700,6 +730,21 @@
 #define SYCL_DEVICE_ONLY
 #endif
 
+// Under fast-math flags (-ffinite-math-only in particular), clang attaches the
+// `nofpclass(nan inf)` attribute to every function argument and return value of floating-point
+// (vector) type. A value that is a compile-time constant of NaN or infinity class -- e.g. the
+// all-ones bitmasks of ptrue and peven_mask, or the infinity/NaN constants guarding special
+// cases -- provably violates that attribute and is folded to poison, silently deleting the code
+// that consumes it. This barrier makes such a constant unprovable, at the cost of a stack
+// store/load pair where it is materialized. It uses a memory operand so that it works for any
+// packet type, including aggregates, and expands to nothing outside affected builds.
+#if EIGEN_COMP_CLANG && defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__ && !defined(EIGEN_GPU_COMPILE_PHASE) && \
+    !defined(SYCL_DEVICE_ONLY)
+#define EIGEN_FAST_MATH_CONSTANT_BARRIER(X) __asm__("" : "+m"(X))
+#else
+#define EIGEN_FAST_MATH_CONSTANT_BARRIER(X)
+#endif
+
 //------------------------------------------------------------------------------------------
 // Detect Compiler/Architecture/OS specific features
 //------------------------------------------------------------------------------------------
@@ -729,12 +774,12 @@
 //
 // With MSVC, without defining /Zc:__cplusplus, the __cplusplus macro will
 // report 199711L regardless of the language standard specified via /std.
-// We need to rely on _MSVC_LANG instead, which is only available after
-// VS2015.3.
+// We need to rely on _MSVC_LANG instead where available. Older MSVC versions
+// supported by Eigen do not define _MSVC_LANG, so use Eigen's minimum standard.
 #if EIGEN_COMP_MSVC_LANG > 0
 #define EIGEN_CPLUSPLUS EIGEN_COMP_MSVC_LANG
-#elif EIGEN_COMP_MSVC >= 1900
-#define EIGEN_CPLUSPLUS 201103L
+#elif EIGEN_COMP_MSVC
+#define EIGEN_CPLUSPLUS 201402L
 #elif defined(__cplusplus)
 #define EIGEN_CPLUSPLUS __cplusplus
 #else
@@ -750,40 +795,31 @@
 #define EIGEN_COMP_CXXVER 17
 #elif EIGEN_CPLUSPLUS >= 201402L
 #define EIGEN_COMP_CXXVER 14
-#elif EIGEN_CPLUSPLUS >= 201103L
-#define EIGEN_COMP_CXXVER 11
 #else
-#define EIGEN_COMP_CXXVER 03
+#define EIGEN_COMP_CXXVER 0
 #endif
 
 // The macros EIGEN_HAS_CXX?? defines a rough estimate of available c++ features
 // but in practice we should not rely on them but rather on the availability of
 // individual features as defined later.
 // This is why there is no EIGEN_HAS_CXX17.
-#if EIGEN_MAX_CPP_VER < 14 || EIGEN_COMP_CXXVER < 14 || (EIGEN_COMP_MSVC && EIGEN_COMP_MSVC < 1900) || \
-    (EIGEN_COMP_ICC && EIGEN_COMP_ICC < 1500) || (EIGEN_COMP_NVCC && EIGEN_COMP_NVCC < 80000) ||       \
-    (EIGEN_COMP_CLANG_STRICT && EIGEN_COMP_CLANG < 390) ||                                             \
+#if EIGEN_MAX_CPP_VER < 14 || EIGEN_COMP_CXXVER < 14 || (EIGEN_COMP_MSVC_STRICT && EIGEN_COMP_MSVC < 1910) || \
+    (EIGEN_COMP_ICC && EIGEN_COMP_ICC < 1700) || (EIGEN_COMP_CLANG_STRICT && EIGEN_COMP_CLANG < 390) ||       \
     (EIGEN_COMP_CLANGAPPLE && EIGEN_COMP_CLANGAPPLE < 9000000) || (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC < 510)
 #error Eigen requires at least c++14 support.
 #endif
 
-// Does the compiler support C99?
-// Need to include <cmath> to make sure _GLIBCXX_USE_C99 gets defined
-#include <cmath>
+// Deprecated compatibility macro. Eigen requires C++14 and no longer uses this
+// token internally, but keep it defined so downstream #if EIGEN_HAS_C99_MATH
+// checks do not trip -Wundef.
 #ifndef EIGEN_HAS_C99_MATH
-#if ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)) ||                                          \
-     (defined(__GNUC__) && defined(_GLIBCXX_USE_C99)) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) || \
-     (EIGEN_COMP_MSVC) || defined(SYCL_DEVICE_ONLY))
 #define EIGEN_HAS_C99_MATH 1
-#else
-#define EIGEN_HAS_C99_MATH 0
-#endif
 #endif
 
 // Does the compiler support std::hash?
 #ifndef EIGEN_HAS_STD_HASH
-// The std::hash struct is defined in C++11 but is not labelled as a __device__
-// function and is not constexpr, so cannot be used on device.
+// The std::hash struct is not labelled as a __device__ function and is not
+// constexpr, so cannot be used on device.
 #if !defined(EIGEN_GPU_COMPILE_PHASE)
 #define EIGEN_HAS_STD_HASH 1
 #else
@@ -810,8 +846,8 @@
 //       See https://gitlab.com/libeigen/eigen/-/issues/2575
 // Does the compiler support C++17 if constexpr?
 #ifndef EIGEN_HAS_CXX17_IFCONSTEXPR
-#if EIGEN_MAX_CPP_VER >= 17 && EIGEN_COMP_CXXVER >= 17 &&                                                            \
-    ((EIGEN_COMP_MSVC >= 1911) || (EIGEN_GNUC_STRICT_AT_LEAST(7, 0, 0)) || (EIGEN_CLANG_STRICT_AT_LEAST(3, 9, 0)) || \
+#if EIGEN_MAX_CPP_VER >= 17 && EIGEN_COMP_CXXVER >= 17 &&                                             \
+    ((EIGEN_COMP_MSVC >= 1911) || (EIGEN_GNUC_STRICT_AT_LEAST(7, 0, 0)) || EIGEN_COMP_CLANG_STRICT || \
      (EIGEN_COMP_CLANGAPPLE && EIGEN_COMP_CLANGAPPLE >= 10000000))
 #define EIGEN_HAS_CXX17_IFCONSTEXPR 1
 #endif
@@ -829,7 +865,7 @@
 #endif
 
 #if defined(EIGEN_CUDACC)
-// While available already with c++11, this is useful mostly starting with c++14 and relaxed constexpr rules
+// Enable device-side constexpr when the toolchain supports relaxed constexpr rules.
 #if defined(__NVCC__)
 // nvcc considers constexpr functions as __host__ __device__ with the option --expt-relaxed-constexpr
 #ifdef __CUDACC_RELAXED_CONSTEXPR__
@@ -900,27 +936,31 @@
 #endif
 #endif
 
-// EIGEN_ALWAYS_INLINE is the strongest, it has the effect of making the function inline and adding every possible
-// attribute to maximize inlining. This should only be used when really necessary: in particular,
-// it uses __attribute__((always_inline)) on GCC, which most of the time is useless and can severely harm compile times.
-// FIXME with the always_inline attribute,
+// EIGEN_ALWAYS_INLINE is the strongest default inline hint. It makes the function inline and, where supported,
+// adds attributes to maximize inlining. This should only be used when really necessary: in particular, the
+// __attribute__((always_inline)) used on GCC is often unnecessary and can severely harm compile times.
+#ifndef EIGEN_ALWAYS_INLINE
 #if EIGEN_COMP_GNUC && !defined(SYCL_DEVICE_ONLY)
 #define EIGEN_ALWAYS_INLINE __attribute__((always_inline)) inline
 #else
 #define EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE
 #endif
+#endif
 
 // EIGEN_LAMBDA_ALWAYS_INLINE forces inlining of lambda functions.
 // On GCC/Clang, __attribute__((always_inline)) works on lambdas.
 // On MSVC, [[msvc::forceinline]] cannot be applied to generic lambdas
 // (those with auto parameters), so we leave it empty and rely on the
 // optimizer to inline small lambda bodies at /O2.
+#ifndef EIGEN_LAMBDA_ALWAYS_INLINE
 #if EIGEN_COMP_GNUC && !defined(SYCL_DEVICE_ONLY)
 #define EIGEN_LAMBDA_ALWAYS_INLINE __attribute__((always_inline))
 #else
 #define EIGEN_LAMBDA_ALWAYS_INLINE
 #endif
+#endif
 
+#ifndef EIGEN_DONT_INLINE
 #if EIGEN_COMP_GNUC
 #define EIGEN_DONT_INLINE __attribute__((noinline))
 #elif EIGEN_COMP_MSVC
@@ -928,6 +968,7 @@
 #else
 #define EIGEN_DONT_INLINE
 #endif
+#endif
 
 #if EIGEN_COMP_GNUC
 #define EIGEN_PERMISSIVE_EXPR __extension__
@@ -1055,7 +1096,7 @@
 EIGEN_DEVICE_FUNC constexpr void ignore_unused_variable(const T&) {}
 }  // namespace internal
 }  // namespace Eigen
-#define EIGEN_UNUSED_VARIABLE(var) Eigen::internal::ignore_unused_variable(var);
+#define EIGEN_UNUSED_VARIABLE(var) Eigen::internal::ignore_unused_variable(var)
 
 #if !defined(EIGEN_ASM_COMMENT)
 #if EIGEN_COMP_GNUC && (EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64 || EIGEN_ARCH_RISCV)
@@ -1110,16 +1151,48 @@
 // directly for std::complex<T>, Eigen::half, Eigen::bfloat16. For these,
 // you will need to apply to the underlying POD type.
 #if EIGEN_ARCH_PPC && EIGEN_COMP_GNUC_STRICT
-// This seems to be broken on clang. Packet4f is loaded into a single
-//   register rather than a vector, zeroing out some entries. Integer
-//   types also generate a compile error.
+// These register alternatives are broken on Clang. Packet4f is loaded into a single register rather than a vector,
+// zeroing out some entries, and integer types generate a compile error.
 #if EIGEN_OS_MAC
 // General, Altivec for Apple (VSX were added in ISA v2.06):
-#define EIGEN_OPTIMIZATION_BARRIER(X) __asm__("" : "+r,v"(X));
+#define EIGEN_PPC_OPTIMIZATION_BARRIER_REGISTERS "+r,v"
 #else
 // General, Altivec, VSX otherwise:
-#define EIGEN_OPTIMIZATION_BARRIER(X) __asm__("" : "+r,v,wa"(X));
+#define EIGEN_PPC_OPTIMIZATION_BARRIER_REGISTERS "+r,v,wa"
 #endif
+namespace Eigen {
+namespace internal {
+// Complex, class, and union operands go to memory: a class that must stay in memory is a compile error with the
+// register constraints, and complex<float> comes back corrupted at -O3, even with "m" added as an alternative. The two
+// constraints need separate instantiations because GCC rejects an impossible constraint even on a branch not taken.
+template <bool InMemory>
+struct ppc_optimization_barrier_impl {
+  template <typename T>
+  static EIGEN_ALWAYS_INLINE void run(T& x) {
+    __asm__("" : EIGEN_PPC_OPTIMIZATION_BARRIER_REGISTERS(x));
+  }
+};
+template <>
+struct ppc_optimization_barrier_impl<true> {
+  template <typename T>
+  static EIGEN_ALWAYS_INLINE void run(T& x) {
+    __asm__("" : "+m"(x));
+  }
+};
+template <typename T>
+EIGEN_ALWAYS_INLINE void ppc_optimization_barrier(T& x) {
+  // __builtin_classify_type does not evaluate its operand: 9 = complex, 12 = class, 13 = union.
+  constexpr int kTypeClass = __builtin_classify_type(*static_cast<T*>(nullptr));
+  ppc_optimization_barrier_impl<kTypeClass == 9 || kTypeClass == 12 || kTypeClass == 13>::run(x);
+}
+}  // namespace internal
+}  // namespace Eigen
+#undef EIGEN_PPC_OPTIMIZATION_BARRIER_REGISTERS
+#define EIGEN_OPTIMIZATION_BARRIER(X) Eigen::internal::ppc_optimization_barrier(X);
+#elif EIGEN_ARCH_PPC && EIGEN_COMP_CLANG
+// Clang's PPC backend does not accept one register constraint covering all scalar and vector operands. In particular,
+// "wa" crashes the backend for scalar integers narrower than 64 bits.
+#define EIGEN_OPTIMIZATION_BARRIER(X) __asm__("" : "+m"(X));
 #elif EIGEN_ARCH_ARM_OR_ARM64
 #ifdef __ARM_FP
 // General, VFP or NEON.
@@ -1183,26 +1256,12 @@
 #define EIGEN_USING_STD(FUNC) using std::FUNC;
 #endif
 
-#if EIGEN_COMP_CLANG  // workaround clang bug (see http://forum.kde.org/viewtopic.php?f=74&t=102653)
-#define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)                                           \
-  using Base::operator=;                                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) {                 \
-    Base::operator=(other);                                                                        \
-    return *this;                                                                                  \
-  }                                                                                                \
-  template <typename OtherDerived>                                                                 \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const DenseBase<OtherDerived>& other) { \
-    Base::operator=(other.derived());                                                              \
-    return *this;                                                                                  \
-  }
-#else
 #define EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)                           \
   using Base::operator=;                                                           \
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) { \
     Base::operator=(other);                                                        \
     return *this;                                                                  \
   }
-#endif
 
 /**
  * \internal
@@ -1214,7 +1273,7 @@
 /** \internal
  * \brief Macro to manually inherit assignment operators.
  * This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is
- * defined. With C++11 or later this also default-implements the copy-constructor
+ * defined. This also default-implements the copy-constructor.
  */
 #define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
   EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)  \
@@ -1224,8 +1283,6 @@
  * \brief Macro to manually define default constructors and destructors.
  * This is necessary when the copy constructor is re-defined.
  * For empty helper classes this should usually be protected, to avoid accidentally creating empty objects.
- *
- * Hiding the default destructor lead to problems in C++03 mode together with boost::multiprecision
  */
 #define EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(Derived) \
   EIGEN_DEVICE_FUNC Derived() = default;                        \
@@ -1276,64 +1333,64 @@
 #define EIGEN_PREDICT_TRUE(x) (x)
 #endif
 
+#define EIGEN_MAKE_CWISE_UNARY_OP(METHOD, FUNCTOR, RETURN_TYPE)     \
+  using RETURN_TYPE = CwiseUnaryOp<FUNCTOR<Scalar>, const Derived>; \
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const RETURN_TYPE METHOD() const { return RETURN_TYPE(derived()); }
+
 // the expression type of a standard coefficient wise binary operation
-#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS, RHS, OPNAME)                                                       \
-  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_, OPNAME), _op) < typename internal::traits<LHS>::Scalar, \
-                typename internal::traits<RHS>::Scalar>,                                                       \
-      const LHS, const RHS >
+#define EIGEN_CWISE_BINARY_RETURN_TYPE(LHS, RHS, FUNCTOR)                                                           \
+  CwiseBinaryOp<FUNCTOR<typename internal::traits<LHS>::Scalar, typename internal::traits<RHS>::Scalar>, const LHS, \
+                const RHS>
 
-#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD, OPNAME)                                                                \
-  template <typename OtherDerived>                                                                                \
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(                           \
-      Derived, OtherDerived, OPNAME)(METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived>& other) const { \
-    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, OPNAME)(derived(), other.derived());             \
+#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD, FUNCTOR)                                                                \
+  template <typename OtherDerived>                                                                                 \
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(                            \
+      Derived, OtherDerived, FUNCTOR)(METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived>& other) const { \
+    return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, FUNCTOR)(derived(), other.derived());             \
   }
 
-#define EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, TYPEA, TYPEB)     \
-  (Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits< \
-       TYPEA, TYPEB, EIGEN_CAT(EIGEN_CAT(Eigen::internal::scalar_, OPNAME), _op) < TYPEA, TYPEB> > > ::value)
+#define EIGEN_SCALAR_BINARY_SUPPORTED(FUNCTOR, TYPEA, TYPEB) \
+  (Eigen::internal::has_ReturnType<Eigen::ScalarBinaryOpTraits<TYPEA, TYPEB, FUNCTOR<TYPEA, TYPEB> > >::value)
 
-#define EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR, SCALAR, OPNAME)                                            \
-  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_, OPNAME), _op) < typename internal::traits<EXPR>::Scalar, \
-                SCALAR>,                                                                                        \
-      const EXPR, const typename internal::plain_constant_type<EXPR, SCALAR>::type >
+#define EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(EXPR, SCALAR, FUNCTOR)                 \
+  CwiseBinaryOp<FUNCTOR<typename internal::traits<EXPR>::Scalar, SCALAR>, const EXPR, \
+                const typename internal::plain_constant_type<EXPR, SCALAR>::type>
 
-#define EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(SCALAR, EXPR, OPNAME)           \
-  CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_, OPNAME), _op) < SCALAR, \
-                typename internal::traits<EXPR>::Scalar>,                      \
-      const typename internal::plain_constant_type<EXPR, SCALAR>::type, const EXPR >
+#define EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(SCALAR, EXPR, FUNCTOR)     \
+  CwiseBinaryOp<FUNCTOR<SCALAR, typename internal::traits<EXPR>::Scalar>, \
+                const typename internal::plain_constant_type<EXPR, SCALAR>::type, const EXPR>
 
-#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD, OPNAME)                                                       \
-  template <typename T>                                                                                              \
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(                      \
-      Derived,                                                                                                       \
-      typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(          \
-          OPNAME, Scalar, T)>::type,                                                                                 \
-      OPNAME)(METHOD)(const T& scalar) const {                                                                       \
-    typedef typename internal::promote_scalar_arg<Scalar, T, EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, Scalar, T)>::type \
-        PromotedT;                                                                                                   \
-    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, PromotedT, OPNAME)(                                       \
-        derived(), typename internal::plain_constant_type<Derived, PromotedT>::type(                                 \
-                       derived().rows(), derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)));        \
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD, FUNCTOR)                                                       \
+  template <typename T>                                                                                               \
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(                       \
+      Derived,                                                                                                        \
+      typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(           \
+          FUNCTOR, Scalar, T)>::type,                                                                                 \
+      FUNCTOR)(METHOD)(const T& scalar) const {                                                                       \
+    typedef typename internal::promote_scalar_arg<Scalar, T, EIGEN_SCALAR_BINARY_SUPPORTED(FUNCTOR, Scalar, T)>::type \
+        PromotedT;                                                                                                    \
+    return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, PromotedT, FUNCTOR)(                                       \
+        derived(), typename internal::plain_constant_type<Derived, PromotedT>::type(                                  \
+                       derived().rows(), derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)));         \
   }
 
-#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, OPNAME)                                                        \
-  template <typename T>                                                                                              \
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE friend const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(               \
-      typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(          \
-          OPNAME, T, Scalar)>::type,                                                                                 \
-      Derived, OPNAME)(METHOD)(const T& scalar, const StorageBaseType& matrix) {                                     \
-    typedef typename internal::promote_scalar_arg<Scalar, T, EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME, T, Scalar)>::type \
-        PromotedT;                                                                                                   \
-    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT, Derived, OPNAME)(                                       \
-        typename internal::plain_constant_type<Derived, PromotedT>::type(                                            \
-            matrix.derived().rows(), matrix.derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)),      \
-        matrix.derived());                                                                                           \
+#define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, FUNCTOR)                                                        \
+  template <typename T>                                                                                               \
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE friend const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(                \
+      typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(           \
+          FUNCTOR, T, Scalar)>::type,                                                                                 \
+      Derived, FUNCTOR)(METHOD)(const T& scalar, const StorageBaseType& matrix) {                                     \
+    typedef typename internal::promote_scalar_arg<Scalar, T, EIGEN_SCALAR_BINARY_SUPPORTED(FUNCTOR, T, Scalar)>::type \
+        PromotedT;                                                                                                    \
+    return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT, Derived, FUNCTOR)(                                       \
+        typename internal::plain_constant_type<Derived, PromotedT>::type(                                             \
+            matrix.derived().rows(), matrix.derived().cols(), internal::scalar_constant_op<PromotedT>(scalar)),       \
+        matrix.derived());                                                                                            \
   }
 
-#define EIGEN_MAKE_SCALAR_BINARY_OP(METHOD, OPNAME)     \
-  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, OPNAME) \
-  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD, OPNAME)
+#define EIGEN_MAKE_SCALAR_BINARY_OP(METHOD, FUNCTOR)     \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD, FUNCTOR) \
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD, FUNCTOR)
 
 #if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(EIGEN_CUDA_ARCH) && !defined(EIGEN_EXCEPTIONS) && \
     !defined(EIGEN_USE_SYCL) && !defined(EIGEN_HIP_DEVICE_COMPILE)
@@ -1392,9 +1449,9 @@
 // Notice: Use this macro with caution. The code in the if body should still
 // compile with C++14.
 #if defined(EIGEN_HAS_CXX17_IFCONSTEXPR)
-#define EIGEN_IF_CONSTEXPR(X) if constexpr (X)
+#define EIGEN_IF_CONSTEXPR(...) if constexpr (__VA_ARGS__)
 #else
-#define EIGEN_IF_CONSTEXPR(X) if (X)
+#define EIGEN_IF_CONSTEXPR(...) if (__VA_ARGS__)
 #endif
 
 #endif  // EIGEN_MACROS_H
diff --git a/Eigen/src/Core/util/MaxSizeVector.h b/Eigen/src/Core/util/MaxSizeVector.h
index 3f13b2d..b474196 100644
--- a/Eigen/src/Core/util/MaxSizeVector.h
+++ b/Eigen/src/Core/util/MaxSizeVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_FIXEDSIZEVECTOR_H
 #define EIGEN_FIXEDSIZEVECTOR_H
diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h
index 2d48eb5..15ca395 100644
--- a/Eigen/src/Core/util/Memory.h
+++ b/Eigen/src/Core/util/Memory.h
@@ -11,6 +11,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*****************************************************************************
 *** Platform checks for aligned malloc functions                           ***
@@ -63,8 +64,7 @@
 // set_is_malloc_allowed() function.
 #ifndef EIGEN_AVOID_THREAD_LOCAL
 
-#if ((EIGEN_COMP_GNUC) || __has_feature(cxx_thread_local) || EIGEN_COMP_MSVC >= 1900) && \
-    !defined(EIGEN_GPU_COMPILE_PHASE)
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
 #define EIGEN_MALLOC_CHECK_THREAD_LOCAL thread_local
 #else
 #define EIGEN_MALLOC_CHECK_THREAD_LOCAL
@@ -267,7 +267,7 @@
 
   void* result;
 #if (EIGEN_DEFAULT_ALIGN_BYTES == 0) || EIGEN_MALLOC_ALREADY_ALIGNED
-  EIGEN_UNUSED_VARIABLE(old_size)
+  EIGEN_UNUSED_VARIABLE(old_size);
 
   check_that_malloc_is_allowed();
   EIGEN_USING_STD(realloc)
@@ -420,7 +420,7 @@
 EIGEN_DEVICE_FUNC inline T* aligned_new(std::size_t size) {
   check_size_for_overflow<T>(size);
   T* result = static_cast<T*>(aligned_malloc(sizeof(T) * size));
-  EIGEN_TRY { return default_construct_elements_of_array(result, size); }
+  EIGEN_TRY { default_construct_elements_of_array(result, size); }
   EIGEN_CATCH(...) {
     aligned_free(result);
     EIGEN_THROW;
@@ -432,7 +432,7 @@
 EIGEN_DEVICE_FUNC inline T* conditional_aligned_new(std::size_t size) {
   check_size_for_overflow<T>(size);
   T* result = static_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T) * size));
-  EIGEN_TRY { return default_construct_elements_of_array(result, size); }
+  EIGEN_TRY { default_construct_elements_of_array(result, size); }
   EIGEN_CATCH(...) {
     conditional_aligned_free<Align>(result);
     EIGEN_THROW;
@@ -494,7 +494,7 @@
   if (size == 0) return nullptr;  // short-cut. Also fixes Bug 884
   check_size_for_overflow<T>(size);
   T* result = static_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T) * size));
-  if (NumTraits<T>::RequireInitialization) {
+  EIGEN_IF_CONSTEXPR (NumTraits<T>::RequireInitialization) {
     EIGEN_TRY { default_construct_elements_of_array(result, size); }
     EIGEN_CATCH(...) {
       conditional_aligned_free<Align>(result);
@@ -506,7 +506,7 @@
 
 template <typename T, bool Align>
 EIGEN_DEVICE_FUNC inline T* conditional_aligned_realloc_new_auto(T* pts, std::size_t new_size, std::size_t old_size) {
-  if (NumTraits<T>::RequireInitialization) {
+  EIGEN_IF_CONSTEXPR (NumTraits<T>::RequireInitialization) {
     return conditional_aligned_realloc_new<T, Align>(pts, new_size, old_size);
   }
 
@@ -518,7 +518,7 @@
 
 template <typename T, bool Align>
 EIGEN_DEVICE_FUNC inline void conditional_aligned_delete_auto(T* ptr, std::size_t size) {
-  if (NumTraits<T>::RequireInitialization) destruct_elements_of_array<T>(ptr, size);
+  EIGEN_IF_CONSTEXPR (NumTraits<T>::RequireInitialization) destruct_elements_of_array<T>(ptr, size);
   conditional_aligned_free<Align>(ptr);
 }
 
@@ -544,17 +544,20 @@
  */
 template <int Alignment, typename Scalar, typename Index>
 EIGEN_DEVICE_FUNC inline Index first_aligned(const Scalar* array, Index size) {
-  const Index ScalarSize = sizeof(Scalar);
-  const Index AlignmentSize = Alignment / ScalarSize;
-  const Index AlignmentMask = AlignmentSize - 1;
+  constexpr Index ScalarSize = sizeof(Scalar);
+  constexpr Index AlignmentSize = Alignment / ScalarSize;
+  constexpr Index AlignmentMask = AlignmentSize - 1;
 
-  if (AlignmentSize <= 1) {
+  EIGEN_IF_CONSTEXPR (AlignmentSize <= 1) {
     // Either the requested alignment if smaller than a scalar, or it exactly match a 1 scalar
     // so that all elements of the array have the same alignment.
     return 0;
-  } else if ((std::uintptr_t(array) & (sizeof(Scalar) - 1)) || (Alignment % ScalarSize) != 0) {
-    // The array is not aligned to the size of a single scalar, or the requested alignment is not a multiple of the
-    // scalar size. Consequently, no element of the array is well aligned.
+  } else EIGEN_IF_CONSTEXPR ((Alignment % ScalarSize) != 0) {
+    // The requested alignment is not a multiple of the scalar size. Consequently, no element of the array is well
+    // aligned.
+    return size;
+  } else if (std::uintptr_t(array) & (sizeof(Scalar) - 1)) {
+    // The array is not aligned to the size of a single scalar. Consequently, no element of the array is well aligned.
     return size;
   } else {
     Index first = (AlignmentSize - (Index((std::uintptr_t(array) / sizeof(Scalar))) & AlignmentMask)) & AlignmentMask;
@@ -566,7 +569,7 @@
  * requirement. \sa first_aligned(Scalar*,Index) and first_default_aligned(DenseBase<Derived>) */
 template <typename Scalar, typename Index>
 EIGEN_DEVICE_FUNC inline Index first_default_aligned(const Scalar* array, Index size) {
-  typedef typename packet_traits<Scalar>::type DefaultPacketType;
+  using DefaultPacketType = typename packet_traits<Scalar>::type;
   return first_aligned<unpacket_traits<DefaultPacketType>::alignment>(array, size);
 }
 
@@ -590,11 +593,11 @@
 template <typename T>
 struct smart_copy_helper<T, true> {
   EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T* target) {
-    std::intptr_t size = std::intptr_t(end) - std::intptr_t(start);
-    if (size == 0) return;
+    std::ptrdiff_t count = end - start;
+    if (count <= 0) return;
     eigen_internal_assert(start != 0 && end != 0 && target != 0);
     EIGEN_USING_STD(memcpy)
-    memcpy(target, start, size);
+    memcpy(target, start, static_cast<std::size_t>(count) * sizeof(T));
   }
 };
 
@@ -615,10 +618,10 @@
 template <typename T>
 struct smart_memmove_helper<T, true> {
   static inline void run(const T* start, const T* end, T* target) {
-    std::intptr_t size = std::intptr_t(end) - std::intptr_t(start);
-    if (size == 0) return;
+    std::ptrdiff_t count = end - start;
+    if (count <= 0) return;
     eigen_internal_assert(start != 0 && end != 0 && target != 0);
-    std::memmove(target, start, size);
+    std::memmove(target, start, static_cast<std::size_t>(count) * sizeof(T));
   }
 };
 
@@ -634,11 +637,6 @@
   }
 };
 
-template <typename T>
-EIGEN_DEVICE_FUNC T* smart_move(T* start, T* end, T* target) {
-  return std::move(start, end, target);
-}
-
 /*****************************************************************************
 *** Implementation of runtime stack allocation (falling back to malloc)    ***
 *****************************************************************************/
@@ -665,8 +663,11 @@
 // This helper class construct the allocated memory, and takes care of destructing and freeing the handled data
 // at destruction time. In practice this helper class is mainly useful to avoid memory leak in case of exceptions.
 template <typename T>
-class aligned_stack_memory_handler : noncopyable {
+class aligned_stack_memory_handler {
  public:
+  aligned_stack_memory_handler(const aligned_stack_memory_handler&) = delete;
+  aligned_stack_memory_handler& operator=(const aligned_stack_memory_handler&) = delete;
+
   /* Creates a stack_memory_handler responsible for the buffer \a ptr of size \a size.
    * Note that \a ptr can be 0 regardless of the other parameters.
    * This constructor takes care of constructing/initializing the elements of the buffer if required by the scalar type
@@ -675,10 +676,14 @@
    **/
   EIGEN_DEVICE_FUNC aligned_stack_memory_handler(T* ptr, std::size_t size, bool dealloc)
       : m_ptr(ptr), m_size(size), m_deallocate(dealloc) {
-    if (NumTraits<T>::RequireInitialization && m_ptr) Eigen::internal::default_construct_elements_of_array(m_ptr, size);
+    EIGEN_IF_CONSTEXPR (NumTraits<T>::RequireInitialization) {
+      if (m_ptr) Eigen::internal::default_construct_elements_of_array(m_ptr, size);
+    }
   }
   EIGEN_DEVICE_FUNC ~aligned_stack_memory_handler() {
-    if (NumTraits<T>::RequireInitialization && m_ptr) Eigen::internal::destruct_elements_of_array<T>(m_ptr, m_size);
+    EIGEN_IF_CONSTEXPR (NumTraits<T>::RequireInitialization) {
+      if (m_ptr) Eigen::internal::destruct_elements_of_array<T>(m_ptr, m_size);
+    }
     if (m_deallocate) Eigen::internal::aligned_free(m_ptr);
   }
 
@@ -694,8 +699,8 @@
           bool MapExternalBuffer = nested_eval<Xpr, NbEvaluations>::Evaluate && Xpr::MaxSizeAtCompileTime == Dynamic>
 struct local_nested_eval_wrapper {
   static constexpr bool NeedExternalBuffer = false;
-  typedef typename Xpr::Scalar Scalar;
-  typedef typename nested_eval<Xpr, NbEvaluations>::type ObjectType;
+  using Scalar = typename Xpr::Scalar;
+  using ObjectType = typename nested_eval<Xpr, NbEvaluations>::type;
   ObjectType object;
 
   EIGEN_DEVICE_FUNC local_nested_eval_wrapper(const Xpr& xpr, Scalar* ptr) : object(xpr) {
@@ -707,23 +712,25 @@
 template <typename Xpr, int NbEvaluations>
 struct local_nested_eval_wrapper<Xpr, NbEvaluations, true> {
   static constexpr bool NeedExternalBuffer = true;
-  typedef typename Xpr::Scalar Scalar;
-  typedef typename plain_object_eval<Xpr>::type PlainObject;
-  typedef Map<PlainObject, EIGEN_DEFAULT_ALIGN_BYTES> ObjectType;
+  using Scalar = typename Xpr::Scalar;
+  using PlainObject = typename plain_object_eval<Xpr>::type;
+  using ObjectType = Map<PlainObject, EIGEN_DEFAULT_ALIGN_BYTES>;
   ObjectType object;
 
   EIGEN_DEVICE_FUNC local_nested_eval_wrapper(const Xpr& xpr, Scalar* ptr)
       : object(ptr == 0 ? reinterpret_cast<Scalar*>(Eigen::internal::aligned_malloc(sizeof(Scalar) * xpr.size())) : ptr,
                xpr.rows(), xpr.cols()),
         m_deallocate(ptr == 0) {
-    if (NumTraits<Scalar>::RequireInitialization && object.data())
-      Eigen::internal::default_construct_elements_of_array(object.data(), object.size());
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::RequireInitialization) {
+      if (object.data()) Eigen::internal::default_construct_elements_of_array(object.data(), object.size());
+    }
     object = xpr;
   }
 
   EIGEN_DEVICE_FUNC ~local_nested_eval_wrapper() {
-    if (NumTraits<Scalar>::RequireInitialization && object.data())
-      Eigen::internal::destruct_elements_of_array(object.data(), object.size());
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::RequireInitialization) {
+      if (object.data()) Eigen::internal::destruct_elements_of_array(object.data(), object.size());
+    }
     if (m_deallocate) Eigen::internal::aligned_free(object.data());
   }
 
@@ -733,25 +740,6 @@
 
 #endif  // EIGEN_ALLOCA
 
-template <typename T>
-class scoped_array : noncopyable {
-  T* m_ptr;
-
- public:
-  explicit scoped_array(std::ptrdiff_t size) { m_ptr = new T[size]; }
-  ~scoped_array() { delete[] m_ptr; }
-  T& operator[](std::ptrdiff_t i) { return m_ptr[i]; }
-  const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
-  T*& ptr() { return m_ptr; }
-  const T* ptr() const { return m_ptr; }
-  operator const T*() const { return m_ptr; }
-};
-
-template <typename T>
-void swap(scoped_array<T>& a, scoped_array<T>& b) {
-  std::swap(a.ptr(), b.ptr());
-}
-
 }  // end namespace internal
 
 /** \internal
@@ -759,7 +747,8 @@
  * The macro ei_declare_aligned_stack_constructed_variable(TYPE,NAME,SIZE,BUFFER) declares, allocates,
  * and construct an aligned buffer named NAME of SIZE elements of type TYPE on the stack
  * if the size in bytes is smaller than EIGEN_STACK_ALLOCATION_LIMIT, and if stack allocation is supported by the
- * platform (currently, this is Linux, OSX and Visual Studio only). Otherwise the memory is allocated on the heap. The
+ * platform (currently, this is Linux, OSX and Visual Studio only). Otherwise the memory is allocated on the heap;
+ * in particular, a zero EIGEN_STACK_ALLOCATION_LIMIT disables stack allocation and every buffer is heap-allocated. The
  * allocated buffer is automatically deleted when exiting the scope of this declaration. If BUFFER is non null, then the
  * declared variable is simply an alias for BUFFER, and no allocation/deletion occurs. Here is an example: \code
  * {
@@ -779,21 +768,33 @@
  */
 #if defined(EIGEN_ALLOCA) && !defined(EIGEN_NO_ALLOCA)
 
-#if EIGEN_DEFAULT_ALIGN_BYTES > 0
+// Stack temporaries hold the GEMM packed panels. The SME kernel loads them a
+// streaming vector at a time and runs 35-50% slower when they straddle
+// 64-byte lines, so SME builds align them to that rather than to the ABI's
+// EIGEN_DEFAULT_ALIGN_BYTES.
+#ifndef EIGEN_STACK_ALIGN_BYTES
+#if defined(EIGEN_VECTORIZE_SME) && EIGEN_DEFAULT_ALIGN_BYTES < 64
+#define EIGEN_STACK_ALIGN_BYTES 64
+#else
+#define EIGEN_STACK_ALIGN_BYTES EIGEN_DEFAULT_ALIGN_BYTES
+#endif
+#endif
+
+#if EIGEN_STACK_ALIGN_BYTES > 0
 // We always manually re-align the result of EIGEN_ALLOCA.
 // If alloca is already aligned, the compiler should be smart enough to optimize away the re-alignment.
 
-#if ((EIGEN_COMP_GNUC || EIGEN_COMP_CLANG) && !EIGEN_COMP_NVHPC)
-#define EIGEN_ALIGNED_ALLOCA(SIZE) __builtin_alloca_with_align(SIZE, CHAR_BIT* EIGEN_DEFAULT_ALIGN_BYTES)
+#if ((EIGEN_COMP_GNUC || EIGEN_COMP_CLANG) && !EIGEN_COMP_NVHPC && !EIGEN_COMP_ICC)
+#define EIGEN_ALIGNED_ALLOCA(SIZE) __builtin_alloca_with_align(SIZE, CHAR_BIT* EIGEN_STACK_ALIGN_BYTES)
 #else
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* eigen_aligned_alloca_helper(void* ptr) {
-  constexpr std::uintptr_t mask = EIGEN_DEFAULT_ALIGN_BYTES - 1;
+  constexpr std::uintptr_t mask = EIGEN_STACK_ALIGN_BYTES - 1;
   std::uintptr_t ptr_int = std::uintptr_t(ptr);
   std::uintptr_t aligned_ptr_int = (ptr_int + mask) & ~mask;
   std::uintptr_t offset = aligned_ptr_int - ptr_int;
   return static_cast<void*>(static_cast<uint8_t*>(ptr) + offset);
 }
-#define EIGEN_ALIGNED_ALLOCA(SIZE) eigen_aligned_alloca_helper(EIGEN_ALLOCA(SIZE + EIGEN_DEFAULT_ALIGN_BYTES - 1))
+#define EIGEN_ALIGNED_ALLOCA(SIZE) eigen_aligned_alloca_helper(EIGEN_ALLOCA(SIZE + EIGEN_STACK_ALIGN_BYTES - 1))
 #endif
 
 #else
@@ -893,12 +894,12 @@
 #endif
 
 #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)
-#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Size)                                 \
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(                                                                            \
-      bool(((Size) != Eigen::Dynamic) &&                                                                         \
-           (((EIGEN_MAX_ALIGN_BYTES >= 16) && ((sizeof(Scalar) * (Size)) % (EIGEN_MAX_ALIGN_BYTES) == 0)) ||     \
-            ((EIGEN_MAX_ALIGN_BYTES >= 32) && ((sizeof(Scalar) * (Size)) % (EIGEN_MAX_ALIGN_BYTES / 2) == 0)) || \
-            ((EIGEN_MAX_ALIGN_BYTES >= 64) && ((sizeof(Scalar) * (Size)) % (EIGEN_MAX_ALIGN_BYTES / 4) == 0)))))
+#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Size)                                       \
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(                                                                                  \
+      bool(((Size) != Eigen::Dynamic) &&                                                                               \
+           (((EIGEN_MAX_ALIGN_BYTES >= 16) && ((sizeof(Scalar) * size_t(Size)) % (EIGEN_MAX_ALIGN_BYTES) == 0)) ||     \
+            ((EIGEN_MAX_ALIGN_BYTES >= 32) && ((sizeof(Scalar) * size_t(Size)) % (EIGEN_MAX_ALIGN_BYTES / 2) == 0)) || \
+            ((EIGEN_MAX_ALIGN_BYTES >= 64) && ((sizeof(Scalar) * size_t(Size)) % (EIGEN_MAX_ALIGN_BYTES / 4) == 0)))))
 
 #endif
 
@@ -931,17 +932,17 @@
 template <class T>
 class aligned_allocator {
  public:
-  typedef std::size_t size_type;
-  typedef std::ptrdiff_t difference_type;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef T value_type;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using value_type = T;
 
   template <class U>
   struct rebind {
-    typedef aligned_allocator<U> other;
+    using other = aligned_allocator<U>;
   };
 
   aligned_allocator() = default;
@@ -977,6 +978,11 @@
 
 //---------- Cache sizes ----------
 
+#if EIGEN_OS_LINUX && !defined(EIGEN_NO_CPU_CACHE_SYSFS)
+// Linux publishes the cache topology under sysfs on every architecture.
+#define EIGEN_CPU_CACHE_SYSFS 1
+#endif
+
 #if !defined(EIGEN_NO_CPUID)
 #if EIGEN_COMP_GNUC && EIGEN_ARCH_i386_OR_x86_64
 #if defined(__PIC__) && EIGEN_ARCH_i386
@@ -1013,7 +1019,7 @@
   return abcd[1] == vendor[0] && abcd[3] == vendor[1] && abcd[2] == vendor[2];
 }
 
-inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3) {
+inline void queryCacheSizes_intel_direct(std::ptrdiff_t& l1, std::ptrdiff_t& l2, std::ptrdiff_t& l3) {
   int abcd[4];
   l1 = l2 = l3 = 0;
   int cache_id = 0;
@@ -1030,7 +1036,8 @@
       int line_size = (abcd[1] & 0x00000FFF) >> 0;    // B[11:0]
       int sets = (abcd[2]);                           // C[31:0]
 
-      int cache_size = (ways + 1) * (partitions + 1) * (line_size + 1) * (sets + 1);
+      std::ptrdiff_t cache_size =
+          static_cast<std::ptrdiff_t>(ways + 1) * (partitions + 1) * (line_size + 1) * (sets + 1);
 
       switch (cache_level) {
         case 1:
@@ -1050,7 +1057,7 @@
   } while (cache_type > 0 && cache_id < 16);
 }
 
-inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3) {
+inline void queryCacheSizes_intel_codes(std::ptrdiff_t& l1, std::ptrdiff_t& l2, std::ptrdiff_t& l3) {
   int abcd[4];
   abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
   l1 = l2 = l3 = 0;
@@ -1246,7 +1253,7 @@
   l3 *= 1024;
 }
 
-inline void queryCacheSizes_intel(int& l1, int& l2, int& l3, int max_std_funcs) {
+inline void queryCacheSizes_intel(std::ptrdiff_t& l1, std::ptrdiff_t& l2, std::ptrdiff_t& l3, int max_std_funcs) {
   if (max_std_funcs >= 4)
     queryCacheSizes_intel_direct(l1, l2, l3);
   else if (max_std_funcs >= 2)
@@ -1255,7 +1262,7 @@
     l1 = l2 = l3 = 0;
 }
 
-inline void queryCacheSizes_amd(int& l1, int& l2, int& l3) {
+inline void queryCacheSizes_amd(std::ptrdiff_t& l1, std::ptrdiff_t& l2, std::ptrdiff_t& l3) {
   int abcd[4];
   abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
 
@@ -1266,29 +1273,224 @@
     l1 = (abcd[2] >> 24) * 1024;  // C[31:24] = L1 size in KB
     abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
     EIGEN_CPUID(abcd, 0x80000006, 0);
-    l2 = (abcd[2] >> 16) * 1024;                      // C[31;16] = l2 cache size in KB
-    l3 = ((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024;  // D[31;18] = l3 cache size in 512KB
+    l2 = (abcd[2] >> 16) * 1024;                                                 // C[31;16] = l2 cache size in KB
+    l3 = static_cast<std::ptrdiff_t>((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024;  // D[31;18] = l3 cache size in 512KB
   } else {
     l1 = l2 = l3 = 0;
   }
 }
 #endif
 
+#ifdef EIGEN_CPU_CACHE_SYSFS
+
+/** \internal Data-cache geometry as Linux describes it; a zero field means sysfs did not say. */
+struct CpuCacheTopology {
+  std::ptrdiff_t l1 = 0;
+  std::ptrdiff_t l2 = 0;
+  std::ptrdiff_t l3 = 0;
+  std::ptrdiff_t l3_per_cpu = 0;
+};
+
+/** \internal Reads the first line of the file at \a relative under the CPU topology directory \a root into
+ * \a value. The directory is /sys/devices/system/cpu in production; tests substitute a fixture tree. */
+template <int Size>
+inline bool readSysfsLine(const char* root, const char* relative, char (&value)[Size]) {
+  char path[512];
+  const int length = std::snprintf(path, sizeof(path), "%s/%s", root, relative);
+  if (length <= 0 || length >= static_cast<int>(sizeof(path))) return false;
+  const int fd = ::open(path, O_RDONLY | O_CLOEXEC);
+  if (fd < 0) return false;
+  const ssize_t bytes_read = ::read(fd, value, Size - 1);
+  ::close(fd);
+  if (bytes_read <= 0) return false;
+  value[bytes_read] = '\0';
+  char* newline = std::strchr(value, '\n');
+  if (newline != nullptr) {
+    newline[1] = '\0';
+  }
+  return true;
+}
+
+/** \internal Reads the first line of \a cpu's cache attribute \a name into \a value. */
+template <int Size>
+inline bool readCpuCacheAttribute(const char* root, int cpu, int index, const char* name, char (&value)[Size]) {
+  char relative[64];
+  const int length = std::snprintf(relative, sizeof(relative), "cpu%d/cache/index%d/%s", cpu, index, name);
+  return length > 0 && length < static_cast<int>(sizeof(relative)) && readSysfsLine(root, relative, value);
+}
+
+/** \internal Parses a sysfs cache size such as "64K". \returns 0 if \a text is not a positive size. */
+inline std::ptrdiff_t parseCpuCacheSize(const char* text) {
+  char* suffix = nullptr;
+  const std::ptrdiff_t value = std::strtol(text, &suffix, 10);
+  if (value <= 0) return 0;
+  // The kernel writes kibibytes ("%uK"), but only scale on an explicit unit: reading a bare byte
+  // count as kibibytes would overstate a cache 1024x, which is much worse than the reverse.
+  const std::ptrdiff_t multiplier = (*suffix == 'K' || *suffix == 'k')   ? 1024
+                                    : (*suffix == 'M' || *suffix == 'm') ? 1024 * 1024
+                                                                         : 1;
+  return value * multiplier;
+}
+
+/** \internal Whether \a text is where a sysfs line legitimately ends. */
+inline bool isCpuListTerminator(const char* text) { return *text == '\0' || *text == '\n' || *text == '\r'; }
+
 /** \internal
- * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively */
-inline void queryCacheSizes(int& l1, int& l2, int& l3) {
+ * Calls \a visit(first, last) for each range of a sysfs cpu list such as "0-3" or "0-3,8-11". \returns false
+ * if \a text is malformed, so that an unparsable list reads as "unknown" rather than as whatever the ranges
+ * before the parse went wrong added up to. */
+template <typename Visitor>
+inline bool parseCpuList(const char* text, Visitor&& visit) {
+  if (isCpuListTerminator(text)) return false;
+  // Far above the 8192 CPUs current kernels can number, so a larger id means the line is not a cpu list;
+  // bounding it also keeps a caller that walks the ranges from visiting ids that cannot exist.
+  const long max_cpu_id = 1 << 16;
+  const char* cursor = text;
+  for (;;) {
+    char* end = nullptr;
+    const long first = std::strtol(cursor, &end, 10);
+    if (end == cursor || first < 0) return false;
+    long last = first;
+    if (*end == '-') {
+      cursor = end + 1;
+      last = std::strtol(cursor, &end, 10);
+      if (end == cursor || last < first) return false;
+    }
+    if (last >= max_cpu_id) return false;
+    visit(static_cast<int>(first), static_cast<int>(last));
+    // A comma promises another range, so a list ending on one is malformed: going round the loop
+    // lands on the terminator and fails the strtol above.
+    if (*end == ',') {
+      cursor = end + 1;
+      continue;
+    }
+    // Anything other than a separator or the end of the line means the format is not what this
+    // parser assumes.
+    return isCpuListTerminator(end);
+  }
+}
+
+/** \internal
+ * Counts the CPUs in a sysfs cpu list. \returns 0 if \a text is malformed: reading such a line as a small
+ * count would inflate l3_per_cpu, so the whole list is treated as unknown instead. */
+inline int parseCpuListCount(const char* text) {
+  int count = 0;
+  return parseCpuList(text, [&count](int first, int last) { count += last - first + 1; }) ? count : 0;
+}
+
+/** \internal
+ * \returns \a cpu's data-cache geometry as published under \a root.
+ *
+ * l3_per_cpu is the L3 instance size divided by the CPUs sharing it, and is deliberately derived
+ * within this single pass: the l3 reported elsewhere is a package total on a multi-die part -- 128MB
+ * on a 32-core Threadripper whose cores each reach one 16MB slice -- so pairing it with one
+ * instance's sharer count would overstate the share eightfold. */
+inline CpuCacheTopology readCpuCacheTopologySysfs(const char* root, int cpu) {
+  CpuCacheTopology topology;
+  // One directory per cache, numbered contiguously from zero. The bound only guards a malformed
+  // sysfs; it is far above what any current CPU reports.
+  for (int index = 0; index < 16; ++index) {
+    // A shared_cpu_list can be long on a large machine, and truncating it would undercount the
+    // sharers and hand out too large a share.
+    char value[512];
+
+    if (!readCpuCacheAttribute(root, cpu, index, "level", value)) break;
+    const long level = std::strtol(value, nullptr, 10);
+    std::ptrdiff_t* target =
+        level == 1 ? &topology.l1 : (level == 2 ? &topology.l2 : (level == 3 ? &topology.l3 : nullptr));
+    if (target == nullptr || *target > 0) continue;
+
+    // "Data", "Instruction", or "Unified". An instruction cache never holds the operands a product
+    // blocks for, so it must not be mistaken for the L1 data cache.
+    if (!readCpuCacheAttribute(root, cpu, index, "type", value) || value[0] == 'I') continue;
+
+    if (!readCpuCacheAttribute(root, cpu, index, "size", value)) continue;
+    const std::ptrdiff_t size = parseCpuCacheSize(value);
+    if (size <= 0) continue;
+    *target = size;
+
+    if (level == 3 && readCpuCacheAttribute(root, cpu, index, "shared_cpu_list", value) &&
+        std::strchr(value, '\n') != nullptr) {
+      const int sharing = parseCpuListCount(value);
+      if (sharing > 0) topology.l3_per_cpu = size / sharing;
+    }
+  }
+  return topology;
+}
+
+/** \internal The smaller of two reported sizes, where 0 stands for "not reported". */
+inline std::ptrdiff_t smallerReportedCacheSize(std::ptrdiff_t a, std::ptrdiff_t b) {
+  return a == 0 ? b : (b == 0 ? a : (std::min)(a, b));
+}
+
+/** \internal
+ * \returns the geometry a thread confined to the CPUs \a is_allowed(cpu) admits can rely on: per level, the
+ * smallest cache any of those CPUs reports, so that blocking sized from it fits wherever the thread lands.
+ * The candidates are the CPUs listed online under \a root; one that publishes no cache directory contributes
+ * nothing, and a level it does not report is left to the CPUs that do. */
+template <typename IsAllowed>
+inline CpuCacheTopology queryCpuCacheTopologySysfs(const char* root, IsAllowed&& is_allowed) {
+  CpuCacheTopology topology;
+  char online[512];
+  if (!readSysfsLine(root, "online", online) || std::strchr(online, '\n') == nullptr) return topology;
+  // Validate the whole line before acting on any range of it, so that a malformed list reads as "unknown".
+  if (!parseCpuList(online, [](int, int) {})) return topology;
+  parseCpuList(online, [&](int first, int last) {
+    for (int cpu = first; cpu <= last; ++cpu) {
+      if (!is_allowed(cpu)) continue;
+      const CpuCacheTopology candidate = readCpuCacheTopologySysfs(root, cpu);
+      topology.l1 = smallerReportedCacheSize(topology.l1, candidate.l1);
+      topology.l2 = smallerReportedCacheSize(topology.l2, candidate.l2);
+      topology.l3 = smallerReportedCacheSize(topology.l3, candidate.l3);
+      topology.l3_per_cpu = smallerReportedCacheSize(topology.l3_per_cpu, candidate.l3_per_cpu);
+    }
+  });
+  return topology;
+}
+
+/** \internal
+ * \returns the geometry the calling thread can rely on: that of the CPUs its affinity mask admits, narrowed as
+ * queryCpuCacheTopologySysfs(root, is_allowed) describes. Sampling one fixed CPU would not do: a cpuset or
+ * taskset can exclude CPU 0 while its directory stays readable, and on a heterogeneous part the excluded CPUs
+ * can be the ones with the large caches. Where the mask is unavailable every online CPU is a candidate, which
+ * is the conservative answer. */
+inline CpuCacheTopology queryCpuCacheTopologySysfs(const char* root = "/sys/devices/system/cpu") {
+#ifdef CPU_SETSIZE
+  // The affinity API is a GNU extension that glibc, musl and bionic expose under _GNU_SOURCE, which g++ and
+  // clang++ predefine for C++; CPU_SETSIZE is defined exactly when it is exposed. The query fails on a machine
+  // with more CPU ids than cpu_set_t holds.
+  cpu_set_t allowed;
+  if (sched_getaffinity(0, sizeof(allowed), &allowed) == 0) {
+    return queryCpuCacheTopologySysfs(root,
+                                      [&allowed](int cpu) { return cpu < CPU_SETSIZE && CPU_ISSET(cpu, &allowed); });
+  }
+#endif
+  return queryCpuCacheTopologySysfs(root, [](int) { return true; });
+}
+
+#endif  // EIGEN_CPU_CACHE_SYSFS
+
+/** \internal
+ * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively, and in
+ * \a l3_per_cpu one CPU's share of the L3 where the platform publishes the sharing, 0 otherwise. */
+inline void queryCacheSizes(std::ptrdiff_t& l1, std::ptrdiff_t& l2, std::ptrdiff_t& l3, std::ptrdiff_t& l3_per_cpu) {
+  l3_per_cpu = 0;
 #ifdef EIGEN_CPUID
   int abcd[4];
   const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
   const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
   const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574};  // "AMDisbetter!"
+  // Hygon Dhyana is a Zen-based joint-venture line that returns "HygonGenuine"
+  // and shares AMD's CPUID layout for cache descriptors (AMD Family 17h).
+  const int HygonGenuine[] = {0x6f677948, 0x6e65476e, 0x656e6975};  // "HygonGenuine"
 
   // identify the CPU vendor
   EIGEN_CPUID(abcd, 0x0, 0);
   int max_std_funcs = abcd[0];
   if (cpuid_is_vendor(abcd, GenuineIntel))
     queryCacheSizes_intel(l1, l2, l3, max_std_funcs);
-  else if (cpuid_is_vendor(abcd, AuthenticAMD) || cpuid_is_vendor(abcd, AMDisbetter_))
+  else if (cpuid_is_vendor(abcd, AuthenticAMD) || cpuid_is_vendor(abcd, AMDisbetter_) ||
+           cpuid_is_vendor(abcd, HygonGenuine))
     queryCacheSizes_amd(l1, l2, l3);
   else
     // by default let's use Intel's API
@@ -1318,41 +1520,59 @@
     std::size_t val_size = sizeof(val);
     l1 = -1;
     val_size = sizeof(val);
-    if (sysctlbyname("hw.perflevel0.l1dcachesize", &val, &val_size, NULL, 0) == 0 && val > 0)
-      l1 = static_cast<int>(val);
+    if (sysctlbyname("hw.perflevel0.l1dcachesize", &val, &val_size, nullptr, 0) == 0 && val > 0)
+      l1 = val;
     else {
       val_size = sizeof(val);
-      if (sysctlbyname("hw.l1dcachesize", &val, &val_size, NULL, 0) == 0) l1 = static_cast<int>(val);
+      if (sysctlbyname("hw.l1dcachesize", &val, &val_size, nullptr, 0) == 0) l1 = val;
     }
     l2 = -1;
     val_size = sizeof(val);
-    if (sysctlbyname("hw.l2cachesize", &val, &val_size, NULL, 0) == 0) l2 = static_cast<int>(val);
+    if (sysctlbyname("hw.l2cachesize", &val, &val_size, nullptr, 0) == 0) l2 = val;
     l3 = -1;
     val_size = sizeof(val);
-    if (sysctlbyname("hw.l3cachesize", &val, &val_size, NULL, 0) == 0 && val > 0) l3 = static_cast<int>(val);
+    if (sysctlbyname("hw.l3cachesize", &val, &val_size, nullptr, 0) == 0 && val > 0) l3 = val;
   }
 #elif EIGEN_OS_UNIX && defined(_SC_LEVEL1_DCACHE_SIZE)
-  // On Linux and other POSIX systems, use sysconf to query cache sizes.
+  // A glibc extension: POSIX specifies no cache queries, and musl defines none of these names.
   l1 = sysconf(_SC_LEVEL1_DCACHE_SIZE);
   l2 = sysconf(_SC_LEVEL2_CACHE_SIZE);
   l3 = sysconf(_SC_LEVEL3_CACHE_SIZE);
 #else
   l1 = l2 = l3 = -1;
 #endif
+#ifdef EIGEN_CPU_CACHE_SYSFS
+  // glibc answers the _SC_LEVEL*_CACHE_SIZE queries from CPUID and so only implements them on x86; every
+  // other architecture gets 0, and musl has no such queries at all. Whatever the platform left unknown comes
+  // from the topology Linux publishes on every architecture, as does the L3 share, so that all four numbers
+  // describe the same CPUs.
+  const CpuCacheTopology topology = queryCpuCacheTopologySysfs();
+  if (l1 <= 0) l1 = topology.l1;
+  if (l2 <= 0) l2 = topology.l2;
+  if (l3 <= 0) l3 = topology.l3;
+  l3_per_cpu = topology.l3_per_cpu;
+#endif
+}
+
+/** \internal
+ * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively */
+inline void queryCacheSizes(std::ptrdiff_t& l1, std::ptrdiff_t& l2, std::ptrdiff_t& l3) {
+  std::ptrdiff_t l3_per_cpu;
+  queryCacheSizes(l1, l2, l3, l3_per_cpu);
 }
 
 /** \internal
  * \returns the size in Bytes of the L1 data cache */
-inline int queryL1CacheSize() {
-  int l1(-1), l2, l3;
+inline std::ptrdiff_t queryL1CacheSize() {
+  std::ptrdiff_t l1(-1), l2, l3;
   queryCacheSizes(l1, l2, l3);
   return l1;
 }
 
 /** \internal
  * \returns the size in Bytes of the L2 or L3 cache if this later is present */
-inline int queryTopLevelCacheSize() {
-  int l1, l2(-1), l3(-1);
+inline std::ptrdiff_t queryTopLevelCacheSize() {
+  std::ptrdiff_t l1, l2(-1), l3(-1);
   queryCacheSizes(l1, l2, l3);
   return (std::max)(l2, l3);
 }
@@ -1361,7 +1581,7 @@
  * This wraps C++20's std::construct_at, using placement new instead if it is not available.
  */
 
-#if EIGEN_COMP_CXXVER >= 20 && defined(__cpp_lib_constexpr_dynamic_alloc) && \
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && EIGEN_COMP_CXXVER >= 20 && defined(__cpp_lib_constexpr_dynamic_alloc) && \
     __cpp_lib_constexpr_dynamic_alloc >= 201907L
 using std::construct_at;
 #else
diff --git a/Eigen/src/Core/util/Meta.h b/Eigen/src/Core/util/Meta.h
index ececab8..9d59193 100644
--- a/Eigen/src/Core/util/Meta.h
+++ b/Eigen/src/Core/util/Meta.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_META_H
 #define EIGEN_META_H
@@ -14,72 +15,58 @@
 // IWYU pragma: private
 #include "../InternalHeaderCheck.h"
 
-#if defined(EIGEN_GPU_COMPILE_PHASE)
-
-#include <cfloat>
-
-#if defined(EIGEN_CUDA_ARCH)
-#include <math_constants.h>
-#endif
-
-#if defined(EIGEN_HIP_DEVICE_COMPILE)
-#include "Eigen/src/Core/arch/HIP/hcc/math_constants.h"
-#endif
-
-#endif
-
 // Define portable (u)int{32,64} types
 #include <cstdint>
 
 namespace Eigen {
 namespace numext {
-typedef std::uint8_t uint8_t;
-typedef std::int8_t int8_t;
-typedef std::uint16_t uint16_t;
-typedef std::int16_t int16_t;
-typedef std::uint32_t uint32_t;
-typedef std::int32_t int32_t;
-typedef std::uint64_t uint64_t;
-typedef std::int64_t int64_t;
+using uint8_t = std::uint8_t;
+using int8_t = std::int8_t;
+using uint16_t = std::uint16_t;
+using int16_t = std::int16_t;
+using uint32_t = std::uint32_t;
+using int32_t = std::int32_t;
+using uint64_t = std::uint64_t;
+using int64_t = std::int64_t;
 
 template <size_t Size>
 struct get_integer_by_size {
-  typedef void signed_type;
-  typedef void unsigned_type;
+  using signed_type = void;
+  using unsigned_type = void;
 };
 template <>
 struct get_integer_by_size<1> {
-  typedef int8_t signed_type;
-  typedef uint8_t unsigned_type;
+  using signed_type = int8_t;
+  using unsigned_type = uint8_t;
 };
 template <>
 struct get_integer_by_size<2> {
-  typedef int16_t signed_type;
-  typedef uint16_t unsigned_type;
+  using signed_type = int16_t;
+  using unsigned_type = uint16_t;
 };
 template <>
 struct get_integer_by_size<4> {
-  typedef int32_t signed_type;
-  typedef uint32_t unsigned_type;
+  using signed_type = int32_t;
+  using unsigned_type = uint32_t;
 };
 template <>
 struct get_integer_by_size<8> {
-  typedef int64_t signed_type;
-  typedef uint64_t unsigned_type;
+  using signed_type = int64_t;
+  using unsigned_type = uint64_t;
 };
 }  // namespace numext
 }  // namespace Eigen
 
 namespace Eigen {
 
-typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex;
+using DenseIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE;
 
 /**
  * \brief The Index type as used for the API.
  * \details To change this, \c \#define the preprocessor symbol \c EIGEN_DEFAULT_DENSE_INDEX_TYPE.
  * \sa \blank \ref TopicPreprocessorDirectives, StorageIndex.
  */
-typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;
+using Index = EIGEN_DEFAULT_DENSE_INDEX_TYPE;
 
 namespace internal {
 
@@ -90,41 +77,46 @@
  * we however don't want to add a dependency to Boost.
  */
 
-using std::false_type;
-using std::true_type;
-
 template <bool Condition>
 using bool_constant = std::integral_constant<bool, Condition>;
 
-// Third-party libraries rely on these.
+// Deprecated compatibility aliases. Third-party libraries rely on these, but new code should use std:: directly.
 using std::conditional;
+using std::false_type;
+using std::is_const;
+using std::is_convertible;
+using std::is_integral;
+using std::is_same;
+using std::is_void;
+using std::make_unsigned;
 using std::remove_const;
 using std::remove_pointer;
 using std::remove_reference;
+using std::true_type;
 
 template <typename T>
 struct remove_all {
-  typedef T type;
+  using type = T;
 };
 template <typename T>
 struct remove_all<const T> {
-  typedef typename remove_all<T>::type type;
+  using type = typename remove_all<T>::type;
 };
 template <typename T>
 struct remove_all<T const&> {
-  typedef typename remove_all<T>::type type;
+  using type = typename remove_all<T>::type;
 };
 template <typename T>
 struct remove_all<T&> {
-  typedef typename remove_all<T>::type type;
+  using type = typename remove_all<T>::type;
 };
 template <typename T>
 struct remove_all<T const*> {
-  typedef typename remove_all<T>::type type;
+  using type = typename remove_all<T>::type;
 };
 template <typename T>
 struct remove_all<T*> {
-  typedef typename remove_all<T>::type type;
+  using type = typename remove_all<T>::type;
 };
 
 template <typename T>
@@ -134,21 +126,13 @@
 // for SIMD packet types and other Eigen-specific types. The primary template
 // delegates to std::is_arithmetic for fundamental types.
 template <typename T>
-struct is_arithmetic {
-  enum { value = std::is_arithmetic<T>::value };
-};
+struct is_arithmetic : std::is_arithmetic<T> {};
 // GPU devices treat `long double` as `double`.
 #ifdef EIGEN_GPU_COMPILE_PHASE
 template <>
-struct is_arithmetic<long double> {
-  enum { value = false };
-};
+struct is_arithmetic<long double> : std::false_type {};
 #endif
 
-using std::is_same;
-
-using std::is_void;
-
 /** \internal
  * Implementation of std::void_t for SFINAE.
  *
@@ -164,50 +148,30 @@
 using void_t = void;
 #endif
 
-using std::is_integral;
-
-using std::make_unsigned;
-
-using std::is_const;
-
 template <typename T>
 struct add_const_on_value_type {
-  typedef const T type;
+  using type = const T;
 };
 template <typename T>
 struct add_const_on_value_type<T&> {
-  typedef T const& type;
+  using type = const T&;
 };
 template <typename T>
 struct add_const_on_value_type<T*> {
-  typedef T const* type;
+  using type = const T*;
 };
 template <typename T>
 struct add_const_on_value_type<T* const> {
-  typedef T const* const type;
+  using type = const T* const;
 };
 template <typename T>
 struct add_const_on_value_type<T const* const> {
-  typedef T const* const type;
+  using type = const T* const;
 };
 
 template <typename T>
 using add_const_on_value_type_t = typename add_const_on_value_type<T>::type;
 
-using std::is_convertible;
-
-/** \internal
- * A base class do disable default copy ctor and copy assignment operator.
- */
-class noncopyable {
-  EIGEN_DEVICE_FUNC noncopyable(const noncopyable&);
-  EIGEN_DEVICE_FUNC const noncopyable& operator=(const noncopyable&);
-
- protected:
-  EIGEN_DEVICE_FUNC noncopyable() {}
-  EIGEN_DEVICE_FUNC ~noncopyable() {}
-};
-
 /** \internal
  * Provides access to the number of elements in the object of as a compile-time constant expression.
  * It "returns" Eigen::Dynamic if the size cannot be resolved at compile-time (default).
@@ -217,7 +181,7 @@
  * It currently supports:
  *  - any types T defining T::SizeAtCompileTime
  *  - plain C arrays as T[N]
- *  - std::array (c++11)
+ *  - std::array
  *  - some internal types such as SingleRange and AllRange
  *
  * The second template parameter eases SFINAE-based specializations.
@@ -282,13 +246,21 @@
 }
 #endif
 
+// std::remove_cvref_t is C++20; use it when the standard library exposes the feature-test macro.
+#if defined(__cpp_lib_remove_cvref)
+using std::remove_cvref_t;
+#else
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+#endif
+
 /** \internal
  * Convenient struct to get the result type of a nullary, unary, binary, or
  * ternary functor.
  *
  * Pre C++17:
- * This uses std::result_of. However, note the `type` member removes
- * const and converts references/pointers to their corresponding value type.
+ * This uses std::result_of. However, note the `type` member removes references and top-level const from
+ * callable results, while preserving pointers.
  *
  * Post C++17: Uses std::invoke_result
  */
@@ -298,26 +270,14 @@
 
 template <typename F, typename... ArgTypes>
 struct result_of<F(ArgTypes...)> {
-  typedef typename std::invoke_result<F, ArgTypes...>::type type1;
-  typedef remove_all_t<type1> type;
-};
-
-template <typename F, typename... ArgTypes>
-struct invoke_result {
-  typedef typename std::invoke_result<F, ArgTypes...>::type type1;
-  typedef remove_all_t<type1> type;
+  using type1 = std::invoke_result_t<F, ArgTypes...>;
+  using type = remove_cvref_t<type1>;
 };
 #else
 template <typename T>
 struct result_of {
-  typedef typename std::result_of<T>::type type1;
-  typedef remove_all_t<type1> type;
-};
-
-template <typename F, typename... ArgTypes>
-struct invoke_result {
-  typedef typename result_of<F(ArgTypes...)>::type type1;
-  typedef remove_all_t<type1> type;
+  using type1 = std::result_of_t<T>;
+  using type = remove_cvref_t<type1>;
 };
 #endif
 
@@ -326,98 +286,42 @@
 using reduce_all =
     std::is_same<std::integer_sequence<bool, values..., true>, std::integer_sequence<bool, true, values...>>;
 
-// Reduces a sequence of bools to true if any are true, false if all false.
-template <bool... values>
-using reduce_any = std::integral_constant<bool, !std::is_same<std::integer_sequence<bool, values..., false>,
-                                                              std::integer_sequence<bool, false, values...>>::value>;
-
-struct meta_yes {
-  char a[1];
-};
-struct meta_no {
-  char a[2];
-};
-
 // Check whether T::ReturnType does exist
-template <typename T>
-struct has_ReturnType {
-  template <typename C>
-  static meta_yes testFunctor(C const*, typename C::ReturnType const* = 0);
-  template <typename C>
-  static meta_no testFunctor(...);
-
-  enum { value = sizeof(testFunctor<T>(static_cast<T*>(0))) == sizeof(meta_yes) };
-};
+template <typename T, typename EnableIf = void>
+struct has_ReturnType : std::false_type {};
 
 template <typename T>
-const T* return_ptr();
+struct has_ReturnType<T, void_t<typename T::ReturnType>> : std::true_type {};
 
-template <typename T, typename IndexType = Index>
-struct has_nullary_operator {
-  template <typename C>
-  static meta_yes testFunctor(C const*, std::enable_if_t<(sizeof(return_ptr<C>()->operator()()) > 0)>* = 0);
-  static meta_no testFunctor(...);
+template <typename T, typename IndexType = Index, typename EnableIf = void>
+struct has_nullary_operator : std::false_type {};
 
-  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
-};
+template <typename T, typename IndexType>
+struct has_nullary_operator<T, IndexType, void_t<decltype(std::declval<const T&>()())>> : std::true_type {};
 
-template <typename T, typename IndexType = Index>
-struct has_unary_operator {
-  template <typename C>
-  static meta_yes testFunctor(C const*, std::enable_if_t<(sizeof(return_ptr<C>()->operator()(IndexType(0))) > 0)>* = 0);
-  static meta_no testFunctor(...);
+template <typename T, typename IndexType = Index, typename EnableIf = void>
+struct has_unary_operator : std::false_type {};
 
-  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
-};
+template <typename T, typename IndexType>
+struct has_unary_operator<T, IndexType, void_t<decltype(std::declval<const T&>()(IndexType(0)))>> : std::true_type {};
 
-template <typename T, typename IndexType = Index>
-struct has_binary_operator {
-  template <typename C>
-  static meta_yes testFunctor(
-      C const*, std::enable_if_t<(sizeof(return_ptr<C>()->operator()(IndexType(0), IndexType(0))) > 0)>* = 0);
-  static meta_no testFunctor(...);
+template <typename T, typename IndexType = Index, typename EnableIf = void>
+struct has_binary_operator : std::false_type {};
 
-  enum { value = sizeof(testFunctor(static_cast<T*>(0))) == sizeof(meta_yes) };
-};
-
-/** \internal In short, it computes int(sqrt(\a Y)) with \a Y an integer.
- * Usage example: \code meta_sqrt<1023>::ret \endcode
- */
-template <int Y, int InfX = 0, int SupX = ((Y == 1) ? 1 : Y / 2),
-          bool Done = ((SupX - InfX) <= 1 || ((SupX * SupX <= Y) && ((SupX + 1) * (SupX + 1) > Y)))>
-class meta_sqrt {
-  enum {
-    MidX = (InfX + SupX) / 2,
-    TakeInf = MidX * MidX > Y ? 1 : 0,
-    NewInf = int(TakeInf) ? InfX : int(MidX),
-    NewSup = int(TakeInf) ? int(MidX) : SupX
-  };
-
- public:
-  enum { ret = meta_sqrt<Y, NewInf, NewSup>::ret };
-};
-
-template <int Y, int InfX, int SupX>
-class meta_sqrt<Y, InfX, SupX, true> {
- public:
-  enum { ret = (SupX * SupX <= Y) ? SupX : InfX };
-};
+template <typename T, typename IndexType>
+struct has_binary_operator<T, IndexType, void_t<decltype(std::declval<const T&>()(IndexType(0), IndexType(0)))>>
+    : std::true_type {};
 
 /** \internal Computes the least common multiple of two positive integer A and B
  * at compile-time.
  */
 template <int A, int B, int K = 1, bool Done = ((A * K) % B) == 0, bool Big = (A >= B)>
-struct meta_least_common_multiple {
-  enum { ret = meta_least_common_multiple<A, B, K + 1>::ret };
-};
+struct meta_least_common_multiple : std::integral_constant<int, meta_least_common_multiple<A, B, K + 1>::value> {};
 template <int A, int B, int K, bool Done>
-struct meta_least_common_multiple<A, B, K, Done, false> {
-  enum { ret = meta_least_common_multiple<B, A, K>::ret };
-};
+struct meta_least_common_multiple<A, B, K, Done, false>
+    : std::integral_constant<int, meta_least_common_multiple<B, A, K>::value> {};
 template <int A, int B, int K>
-struct meta_least_common_multiple<A, B, K, true, true> {
-  enum { ret = A * K };
-};
+struct meta_least_common_multiple<A, B, K, true, true> : std::integral_constant<int, A * K> {};
 
 /** \internal determines whether the product of two numeric types is allowed and what the return type is */
 template <typename T, typename U>
@@ -427,6 +331,8 @@
 
 /** \internal Obtains a POD type suitable to use as storage for an object of a size
  * of at most Len bytes, aligned as specified by \c Align.
+ *
+ * Keep this helper instead of std::aligned_storage_t deprecated in C++23.
  */
 template <unsigned Len, unsigned Align>
 struct aligned_storage {
@@ -469,7 +375,7 @@
   // X is an unsigned integer
   // Y is a signed integer
   // if Y is non-negative, it may be represented exactly as its unsigned counterpart.
-  using UnsignedY = typename internal::make_unsigned<Y>::type;
+  using UnsignedY = std::make_unsigned_t<Y>;
   static constexpr EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool run(const X& x, const Y& y) {
     return y < Y(0) ? false : (x == static_cast<UnsignedY>(y));
   }
@@ -500,6 +406,13 @@
 constexpr EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool equal_strict(const double& x, const double& y) {
   return std::equal_to<double>()(x, y);
 }
+
+#ifndef EIGEN_GPU_COMPILE_PHASE
+template <>
+constexpr EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool equal_strict(const long double& x, const long double& y) {
+  return std::equal_to<long double>()(x, y);
+}
+#endif
 #endif
 
 /**
@@ -511,6 +424,12 @@
   return equal_strict(x, typename NumTraits<X>::Literal{0});
 }
 
+// Unlike is_exactly_zero, inspect supported binary float/double encodings so DAZ cannot hide a subnormal.
+// Both signed zeros compare as zero. Other scalar types retain their usual equality semantics.
+// Defined in MathFunctions.h, after binary_floating_point_traits.
+template <typename X>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool is_exactly_zero_no_flush(const X& x);
+
 /**
  * \internal Performs an exact comparison of x to one, e.g. to decide whether a factor needs to be multiplied.
  * Use this to to bypass -Wfloat-equal warnings when exact one is what needs to be tested.
@@ -535,6 +454,13 @@
 constexpr EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool not_equal_strict(const double& x, const double& y) {
   return std::not_equal_to<double>()(x, y);
 }
+
+#ifndef EIGEN_GPU_COMPILE_PHASE
+template <>
+constexpr EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool not_equal_strict(const long double& x, const long double& y) {
+  return std::not_equal_to<long double>()(x, y);
+}
+#endif
 #endif
 
 }  // end namespace numext
@@ -551,15 +477,14 @@
   return is_identically_zero_impl<Scalar>::run(s);
 }
 
-/// \internal Returns true if its argument is of integer or enum type.
-/// FIXME this has the same purpose as `is_valid_index_type` in XprHelper.h
-template <typename A>
-constexpr bool is_int_or_enum_v = std::is_enum<A>::value || std::is_integral<A>::value;
+// true if T can be considered as an integral index (i.e., an integral type or enum)
+template <typename T>
+using is_valid_index_type = bool_constant<std::is_integral<T>::value || std::is_enum<T>::value>;
 
 template <typename A, typename B>
 constexpr void plain_enum_asserts(A, B) {
-  static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
-  static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
+  static_assert(is_valid_index_type<A>::value, "Argument a must be an integer or enum");
+  static_assert(is_valid_index_type<B>::value, "Argument b must be an integer or enum");
 }
 
 /// \internal Gets the minimum of two values which may be integers or enums
@@ -637,20 +562,6 @@
 }
 
 template <typename A, typename B>
-constexpr bool enum_le_not_dynamic(A a, B b) {
-  plain_enum_asserts(a, b);
-  if ((int)a == Dynamic || (int)b == Dynamic) return false;
-  return (int)a <= (int)b;
-}
-
-template <typename A, typename B>
-constexpr bool enum_gt_not_dynamic(A a, B b) {
-  plain_enum_asserts(a, b);
-  if ((int)a == Dynamic || (int)b == Dynamic) return false;
-  return (int)a > (int)b;
-}
-
-template <typename A, typename B>
 constexpr bool enum_ge_not_dynamic(A a, B b) {
   plain_enum_asserts(a, b);
   if ((int)a == Dynamic || (int)b == Dynamic) return false;
diff --git a/Eigen/src/Core/util/MoreMeta.h b/Eigen/src/Core/util/MoreMeta.h
index a20506e..a2a685a 100644
--- a/Eigen/src/Core/util/MoreMeta.h
+++ b/Eigen/src/Core/util/MoreMeta.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MOREMETA_H
 #define EIGEN_MOREMETA_H
@@ -26,67 +27,9 @@
 template <typename t, typename... tt>
 struct type_list<t, tt...> {
   constexpr static int count = sizeof...(tt) + 1;
-  typedef t first_type;
+  using first_type = t;
 };
 
-template <typename T, T... nn>
-struct numeric_list {
-  constexpr static std::size_t count = sizeof...(nn);
-};
-
-template <typename T, T n, T... nn>
-struct numeric_list<T, n, nn...> {
-  static constexpr std::size_t count = sizeof...(nn) + 1;
-  static constexpr T first_value = n;
-};
-
-// Ddoxygen doesn't like the recursive definition of gen_numeric_list.
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-/* numeric list constructors
- *
- * equivalencies:
- *     constructor                                              result
- *     typename gen_numeric_list<int, 5>::type                  numeric_list<int, 0,1,2,3,4>
- *     typename gen_numeric_list_reversed<int, 5>::type         numeric_list<int, 4,3,2,1,0>
- *     typename gen_numeric_list_swapped_pair<int, 5,1,2>::type numeric_list<int, 0,2,1,3,4>
- *     typename gen_numeric_list_repeated<int, 0, 5>::type      numeric_list<int, 0,0,0,0,0>
- */
-
-template <typename T, std::size_t n, T start = 0, T... ii>
-struct gen_numeric_list : gen_numeric_list<T, n - 1, start, start + n - 1, ii...> {};
-
-template <typename T, T start, T... ii>
-struct gen_numeric_list<T, 0, start, ii...> {
-  typedef numeric_list<T, ii...> type;
-};
-
-template <typename T, std::size_t n, T start = 0, T... ii>
-struct gen_numeric_list_reversed : gen_numeric_list_reversed<T, n - 1, start, ii..., start + n - 1> {};
-template <typename T, T start, T... ii>
-struct gen_numeric_list_reversed<T, 0, start, ii...> {
-  typedef numeric_list<T, ii...> type;
-};
-
-template <typename T, std::size_t n, T a, T b, T start = 0, T... ii>
-struct gen_numeric_list_swapped_pair
-    : gen_numeric_list_swapped_pair<T, n - 1, a, b, start,
-                                    (start + n - 1) == a ? b : ((start + n - 1) == b ? a : (start + n - 1)), ii...> {};
-template <typename T, T a, T b, T start, T... ii>
-struct gen_numeric_list_swapped_pair<T, 0, a, b, start, ii...> {
-  typedef numeric_list<T, ii...> type;
-};
-
-template <typename T, std::size_t n, T V, T... nn>
-struct gen_numeric_list_repeated : gen_numeric_list_repeated<T, n - 1, V, V, nn...> {};
-template <typename T, T V, T... nn>
-struct gen_numeric_list_repeated<T, 0, V, nn...> {
-  typedef numeric_list<T, nn...> type;
-};
-#else
-template <typename T, std::size_t n, T start = 0, T... ii>
-struct gen_numeric_list;
-#endif  // not EIGEN_PARSED_BY_DOXYGEN
-
 /* list manipulation: concatenate */
 
 template <class a, class b>
@@ -94,18 +37,14 @@
 
 template <typename... as, typename... bs>
 struct concat<type_list<as...>, type_list<bs...>> {
-  typedef type_list<as..., bs...> type;
-};
-template <typename T, T... as, T... bs>
-struct concat<numeric_list<T, as...>, numeric_list<T, bs...>> {
-  typedef numeric_list<T, as..., bs...> type;
+  using type = type_list<as..., bs...>;
 };
 
 template <typename... p>
 struct mconcat;
 template <typename a>
 struct mconcat<a> {
-  typedef a type;
+  using type = a;
 };
 template <typename a, typename b>
 struct mconcat<a, b> : concat<a, b> {};
@@ -122,82 +61,38 @@
 
 template <int n>
 struct take<n, type_list<>> {
-  typedef type_list<> type;
+  using type = type_list<>;
 };
 
 template <typename a, typename... as>
 struct take<0, type_list<a, as...>> {
-  typedef type_list<> type;
+  using type = type_list<>;
 };
 
 template <>
 struct take<0, type_list<>> {
-  typedef type_list<> type;
-};
-
-template <typename T, int n, T a, T... as>
-struct take<n, numeric_list<T, a, as...>>
-    : concat<numeric_list<T, a>, typename take<n - 1, numeric_list<T, as...>>::type> {};
-
-template <typename T, T a, T... as>
-struct take<0, numeric_list<T, a, as...>> {
-  typedef numeric_list<T> type;
-};
-
-template <typename T>
-struct take<0, numeric_list<T>> {
-  typedef numeric_list<T> type;
-};
-
-template <typename T, int n, T... ii>
-struct h_skip_helper_numeric;
-template <typename T, int n, T i, T... ii>
-struct h_skip_helper_numeric<T, n, i, ii...> : h_skip_helper_numeric<T, n - 1, ii...> {};
-template <typename T, T i, T... ii>
-struct h_skip_helper_numeric<T, 0, i, ii...> {
-  typedef numeric_list<T, i, ii...> type;
-};
-template <typename T, int n>
-struct h_skip_helper_numeric<T, n> {
-  typedef numeric_list<T> type;
-};
-template <typename T>
-struct h_skip_helper_numeric<T, 0> {
-  typedef numeric_list<T> type;
-};
-
-template <int n, typename... tt>
-struct h_skip_helper_type;
-template <int n, typename t, typename... tt>
-struct h_skip_helper_type<n, t, tt...> : h_skip_helper_type<n - 1, tt...> {};
-template <typename t, typename... tt>
-struct h_skip_helper_type<0, t, tt...> {
-  typedef type_list<t, tt...> type;
-};
-template <int n>
-struct h_skip_helper_type<n> {
-  typedef type_list<> type;
-};
-template <>
-struct h_skip_helper_type<0> {
-  typedef type_list<> type;
-};
-
-template <int n>
-struct h_skip {
-  template <typename T, T... ii>
-  constexpr static typename h_skip_helper_numeric<T, n, ii...>::type helper(numeric_list<T, ii...>) {
-    return typename h_skip_helper_numeric<T, n, ii...>::type();
-  }
-  template <typename... tt>
-  constexpr static typename h_skip_helper_type<n, tt...>::type helper(type_list<tt...>) {
-    return typename h_skip_helper_type<n, tt...>::type();
-  }
+  using type = type_list<>;
 };
 
 template <int n, typename a>
-struct skip {
-  typedef decltype(h_skip<n>::helper(a())) type;
+struct skip;
+
+template <int n, typename a, typename... as>
+struct skip<n, type_list<a, as...>> : skip<n - 1, type_list<as...>> {};
+
+template <typename a, typename... as>
+struct skip<0, type_list<a, as...>> {
+  using type = type_list<a, as...>;
+};
+
+template <int n>
+struct skip<n, type_list<>> {
+  using type = type_list<>;
+};
+
+template <>
+struct skip<0, type_list<>> {
+  using type = type_list<>;
 };
 
 template <int start, int count, typename a>
@@ -212,68 +107,39 @@
 struct get<n, type_list<a, as...>> : get<n - 1, type_list<as...>> {};
 template <typename a, typename... as>
 struct get<0, type_list<a, as...>> {
-  typedef a type;
+  using type = a;
 };
 
 template <typename T, int n, T a, T... as>
-struct get<n, numeric_list<T, a, as...>> : get<n - 1, numeric_list<T, as...>> {};
+struct get<n, std::integer_sequence<T, a, as...>> : get<n - 1, std::integer_sequence<T, as...>> {};
 template <typename T, T a, T... as>
-struct get<0, numeric_list<T, a, as...>> {
+struct get<0, std::integer_sequence<T, a, as...>> {
   constexpr static T value = a;
 };
 
-template <std::size_t n, typename T, T a, T... as>
-constexpr T array_get(const numeric_list<T, a, as...>&) {
-  return get<(int)n, numeric_list<T, a, as...>>::value;
-}
-
-/* always get type, regardless of dummy; good for parameter pack expansion */
-
-template <typename T, T dummy, typename t>
-struct id_numeric {
-  typedef t type;
-};
-template <typename dummy, typename t>
-struct id_type {
-  typedef t type;
-};
-
 /* equality checking, flagged version */
 
 template <typename a, typename b>
-struct is_same_gf : is_same<a, b> {
+struct is_same_gf : std::is_same<a, b> {
   constexpr static int global_flags = 0;
 };
 
 /* apply_op to list */
 
-template <bool from_left,  // false
-          template <typename, typename> class op, typename additional_param, typename... values>
-struct h_apply_op_helper {
-  typedef type_list<typename op<values, additional_param>::type...> type;
-};
+template <template <typename, typename> class op, typename additional_param, typename a>
+struct apply_op_from_left;
+
 template <template <typename, typename> class op, typename additional_param, typename... values>
-struct h_apply_op_helper<true, op, additional_param, values...> {
-  typedef type_list<typename op<additional_param, values>::type...> type;
-};
-
-template <bool from_left, template <typename, typename> class op, typename additional_param>
-struct h_apply_op {
-  template <typename... values>
-  constexpr static typename h_apply_op_helper<from_left, op, additional_param, values...>::type helper(
-      type_list<values...>) {
-    return typename h_apply_op_helper<from_left, op, additional_param, values...>::type();
-  }
+struct apply_op_from_left<op, additional_param, type_list<values...>> {
+  using type = type_list<typename op<additional_param, values>::type...>;
 };
 
 template <template <typename, typename> class op, typename additional_param, typename a>
-struct apply_op_from_left {
-  typedef decltype(h_apply_op<true, op, additional_param>::helper(a())) type;
-};
+struct apply_op_from_right;
 
-template <template <typename, typename> class op, typename additional_param, typename a>
-struct apply_op_from_right {
-  typedef decltype(h_apply_op<false, op, additional_param>::helper(a())) type;
+template <template <typename, typename> class op, typename additional_param, typename... values>
+struct apply_op_from_right<op, additional_param, type_list<values...>> {
+  using type = type_list<typename op<values, additional_param>::type...>;
 };
 
 /* see if an element is in a list */
@@ -339,8 +205,7 @@
 
 template <typename Reducer, typename A, typename... Ts>
 struct reduce<Reducer, A, Ts...> {
-  EIGEN_DEVICE_FUNC constexpr static auto run(A a, Ts... ts)
-      -> decltype(Reducer::run(a, reduce<Reducer, Ts...>::run(ts...))) {
+  EIGEN_DEVICE_FUNC constexpr static auto run(A a, Ts... ts) {
     return Reducer::run(a, reduce<Reducer, Ts...>::run(ts...));
   }
 };
@@ -349,158 +214,68 @@
 
 struct sum_op {
   template <typename A, typename B>
-  EIGEN_DEVICE_FUNC constexpr static auto run(A a, B b) -> decltype(a + b) {
+  EIGEN_DEVICE_FUNC constexpr static auto run(A a, B b) {
     return a + b;
   }
   static constexpr int Identity = 0;
 };
 struct product_op {
   template <typename A, typename B>
-  EIGEN_DEVICE_FUNC constexpr static auto run(A a, B b) -> decltype(a * b) {
+  EIGEN_DEVICE_FUNC constexpr static auto run(A a, B b) {
     return a * b;
   }
   static constexpr int Identity = 1;
 };
 
-struct logical_and_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a && b) {
-    return a && b;
-  }
-};
-struct logical_or_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a || b) {
-    return a || b;
-  }
-};
-
-struct equal_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a == b) {
-    return a == b;
-  }
-};
-struct not_equal_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a != b) {
-    return a != b;
-  }
-};
-struct lesser_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a < b) {
-    return a < b;
-  }
-};
-struct lesser_equal_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a <= b) {
-    return a <= b;
-  }
-};
-struct greater_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a > b) {
-    return a > b;
-  }
-};
-struct greater_equal_op {
-  template <typename A, typename B>
-  constexpr static auto run(A a, B b) -> decltype(a >= b) {
-    return a >= b;
-  }
-};
-
-/* generic unary operations */
-
-struct not_op {
-  template <typename A>
-  constexpr static auto run(A a) -> decltype(!a) {
-    return !a;
-  }
-};
-struct negation_op {
-  template <typename A>
-  constexpr static auto run(A a) -> decltype(-a) {
-    return -a;
-  }
-};
-struct greater_equal_zero_op {
-  template <typename A>
-  constexpr static auto run(A a) -> decltype(a >= 0) {
-    return a >= 0;
-  }
-};
-
 /* reductions for lists */
 
-// Using auto -> return value spec makes ICC 13.0 and 13.1 crash here,
-// so the return type is specified explicitly using decltype.
 template <typename... Ts>
-EIGEN_DEVICE_FUNC constexpr decltype(reduce<product_op, Ts...>::run((*((Ts*)0))...)) arg_prod(Ts... ts) {
+EIGEN_DEVICE_FUNC constexpr auto arg_prod(Ts... ts) {
   return reduce<product_op, Ts...>::run(ts...);
 }
 
 template <typename... Ts>
-constexpr decltype(reduce<sum_op, Ts...>::run((*((Ts*)0))...)) arg_sum(Ts... ts) {
+constexpr auto arg_sum(Ts... ts) {
   return reduce<sum_op, Ts...>::run(ts...);
 }
 
-/* reverse arrays */
-
-template <typename Array, int... n>
-constexpr Array h_array_reverse(Array arr, numeric_list<int, n...>) {
-  return {{array_get<sizeof...(n) - n - 1>(arr)...}};
-}
-
-template <typename T, std::size_t N>
-constexpr array<T, N> array_reverse(array<T, N> arr) {
-  return h_array_reverse(arr, typename gen_numeric_list<int, N>::type());
-}
-
 /* generic array reductions */
 
-// can't reuse standard reduce() interface above because Intel's Compiler
-// *really* doesn't like it, so we just reimplement the stuff
-// (start from N - 1 and work down to 0 because specialization for
-// n == N - 1 also doesn't work in Intel's compiler, so it goes into
-// an infinite loop)
-template <typename Reducer, typename T, std::size_t N, std::size_t n = N - 1>
-struct h_array_reduce {
-  EIGEN_DEVICE_FUNC constexpr static auto run(array<T, N> arr, T identity)
-      -> decltype(Reducer::run(h_array_reduce<Reducer, T, N, n - 1>::run(arr, identity), array_get<n>(arr))) {
-    return Reducer::run(h_array_reduce<Reducer, T, N, n - 1>::run(arr, identity), array_get<n>(arr));
+template <typename Reducer, typename T, std::size_t N>
+struct array_reducer {
+  EIGEN_DEVICE_FUNC constexpr static auto run(const array<T, N>& arr, T) {
+    auto result = Reducer::run(arr[0], arr[1]);
+    for (std::size_t i = 2; i < N; ++i) {
+      result = Reducer::run(result, arr[i]);
+    }
+    return result;
   }
 };
 
-template <typename Reducer, typename T, std::size_t N>
-struct h_array_reduce<Reducer, T, N, 0> {
-  EIGEN_DEVICE_FUNC constexpr static T run(const array<T, N>& arr, T) { return array_get<0>(arr); }
+template <typename Reducer, typename T>
+struct array_reducer<Reducer, T, 1> {
+  EIGEN_DEVICE_FUNC constexpr static T run(const array<T, 1>& arr, T) { return arr[0]; }
 };
 
 template <typename Reducer, typename T>
-struct h_array_reduce<Reducer, T, 0> {
+struct array_reducer<Reducer, T, 0> {
   EIGEN_DEVICE_FUNC constexpr static T run(const array<T, 0>&, T identity) { return identity; }
 };
 
 template <typename Reducer, typename T, std::size_t N>
-EIGEN_DEVICE_FUNC constexpr auto array_reduce(const array<T, N>& arr, T identity)
-    -> decltype(h_array_reduce<Reducer, T, N>::run(arr, identity)) {
-  return h_array_reduce<Reducer, T, N>::run(arr, identity);
+EIGEN_DEVICE_FUNC constexpr auto array_reduce(const array<T, N>& arr, T identity) {
+  return array_reducer<Reducer, T, N>::run(arr, identity);
 }
 
 /* standard array reductions */
 
 template <typename T, std::size_t N>
-EIGEN_DEVICE_FUNC constexpr auto array_sum(const array<T, N>& arr)
-    -> decltype(array_reduce<sum_op, T, N>(arr, static_cast<T>(0))) {
+EIGEN_DEVICE_FUNC constexpr auto array_sum(const array<T, N>& arr) {
   return array_reduce<sum_op, T, N>(arr, static_cast<T>(0));
 }
 
 template <typename T, std::size_t N>
-EIGEN_DEVICE_FUNC constexpr auto array_prod(const array<T, N>& arr)
-    -> decltype(array_reduce<product_op, T, N>(arr, static_cast<T>(1))) {
+EIGEN_DEVICE_FUNC constexpr auto array_prod(const array<T, N>& arr) {
   return array_reduce<product_op, T, N>(arr, static_cast<T>(1));
 }
 
@@ -514,119 +289,6 @@
   return prod;
 }
 
-/* zip an array */
-
-template <typename Op, typename A, typename B, std::size_t N, int... n>
-constexpr array<decltype(Op::run(A(), B())), N> h_array_zip(array<A, N> a, array<B, N> b, numeric_list<int, n...>) {
-  return array<decltype(Op::run(A(), B())), N>{{Op::run(array_get<n>(a), array_get<n>(b))...}};
-}
-
-template <typename Op, typename A, typename B, std::size_t N>
-constexpr array<decltype(Op::run(A(), B())), N> array_zip(array<A, N> a, array<B, N> b) {
-  return h_array_zip<Op>(a, b, typename gen_numeric_list<int, N>::type());
-}
-
-/* zip an array and reduce the result */
-
-template <typename Reducer, typename Op, typename A, typename B, std::size_t N, int... n>
-constexpr auto h_array_zip_and_reduce(array<A, N> a, array<B, N> b, numeric_list<int, n...>)
-    -> decltype(reduce<Reducer, typename id_numeric<int, n, decltype(Op::run(A(), B()))>::type...>::run(
-        Op::run(array_get<n>(a), array_get<n>(b))...)) {
-  return reduce<Reducer, typename id_numeric<int, n, decltype(Op::run(A(), B()))>::type...>::run(
-      Op::run(array_get<n>(a), array_get<n>(b))...);
-}
-
-template <typename Reducer, typename Op, typename A, typename B, std::size_t N>
-constexpr auto array_zip_and_reduce(array<A, N> a, array<B, N> b)
-    -> decltype(h_array_zip_and_reduce<Reducer, Op, A, B, N>(a, b, typename gen_numeric_list<int, N>::type())) {
-  return h_array_zip_and_reduce<Reducer, Op, A, B, N>(a, b, typename gen_numeric_list<int, N>::type());
-}
-
-/* apply stuff to an array */
-
-template <typename Op, typename A, std::size_t N, int... n>
-constexpr array<decltype(Op::run(A())), N> h_array_apply(array<A, N> a, numeric_list<int, n...>) {
-  return array<decltype(Op::run(A())), N>{{Op::run(array_get<n>(a))...}};
-}
-
-template <typename Op, typename A, std::size_t N>
-constexpr array<decltype(Op::run(A())), N> array_apply(array<A, N> a) {
-  return h_array_apply<Op>(a, typename gen_numeric_list<int, N>::type());
-}
-
-/* apply stuff to an array and reduce */
-
-template <typename Reducer, typename Op, typename A, std::size_t N, int... n>
-constexpr auto h_array_apply_and_reduce(array<A, N> arr, numeric_list<int, n...>)
-    -> decltype(reduce<Reducer, typename id_numeric<int, n, decltype(Op::run(A()))>::type...>::run(
-        Op::run(array_get<n>(arr))...)) {
-  return reduce<Reducer, typename id_numeric<int, n, decltype(Op::run(A()))>::type...>::run(
-      Op::run(array_get<n>(arr))...);
-}
-
-template <typename Reducer, typename Op, typename A, std::size_t N>
-constexpr auto array_apply_and_reduce(array<A, N> a)
-    -> decltype(h_array_apply_and_reduce<Reducer, Op, A, N>(a, typename gen_numeric_list<int, N>::type())) {
-  return h_array_apply_and_reduce<Reducer, Op, A, N>(a, typename gen_numeric_list<int, N>::type());
-}
-
-/* repeat a value n times (and make an array out of it
- * usage:
- *   array<int, 16> = repeat<16>(42);
- */
-
-template <int n>
-struct h_repeat {
-  template <typename t, int... ii>
-  constexpr static array<t, n> run(t v, numeric_list<int, ii...>) {
-    return {{typename id_numeric<int, ii, t>::type(v)...}};
-  }
-};
-
-template <int n, typename t>
-constexpr array<t, n> repeat(t v) {
-  return h_repeat<n>::run(v, typename gen_numeric_list<int, n>::type());
-}
-
-/* instantiate a class by a C-style array */
-template <class InstType, typename ArrType, std::size_t N, bool Reverse, typename... Ps>
-struct h_instantiate_by_c_array;
-
-template <class InstType, typename ArrType, std::size_t N, typename... Ps>
-struct h_instantiate_by_c_array<InstType, ArrType, N, false, Ps...> {
-  static InstType run(ArrType* arr, Ps... args) {
-    return h_instantiate_by_c_array<InstType, ArrType, N - 1, false, Ps..., ArrType>::run(arr + 1, args..., arr[0]);
-  }
-};
-
-template <class InstType, typename ArrType, std::size_t N, typename... Ps>
-struct h_instantiate_by_c_array<InstType, ArrType, N, true, Ps...> {
-  static InstType run(ArrType* arr, Ps... args) {
-    return h_instantiate_by_c_array<InstType, ArrType, N - 1, false, ArrType, Ps...>::run(arr + 1, arr[0], args...);
-  }
-};
-
-template <class InstType, typename ArrType, typename... Ps>
-struct h_instantiate_by_c_array<InstType, ArrType, 0, false, Ps...> {
-  static InstType run(ArrType* arr, Ps... args) {
-    (void)arr;
-    return InstType(args...);
-  }
-};
-
-template <class InstType, typename ArrType, typename... Ps>
-struct h_instantiate_by_c_array<InstType, ArrType, 0, true, Ps...> {
-  static InstType run(ArrType* arr, Ps... args) {
-    (void)arr;
-    return InstType(args...);
-  }
-};
-
-template <class InstType, typename ArrType, std::size_t N, bool Reverse = false>
-InstType instantiate_by_c_array(ArrType* arr) {
-  return h_instantiate_by_c_array<InstType, ArrType, N, Reverse>::run(arr);
-}
-
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Core/util/ReenableStupidWarnings.h b/Eigen/src/Core/util/ReenableStupidWarnings.h
index 0af5a43..b9be968 100644
--- a/Eigen/src/Core/util/ReenableStupidWarnings.h
+++ b/Eigen/src/Core/util/ReenableStupidWarnings.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifdef EIGEN_WARNINGS_DISABLED_2
 // "DisableStupidWarnings.h" was included twice recursively: Do not re-enable warnings yet!
 #undef EIGEN_WARNINGS_DISABLED_2
@@ -5,7 +8,6 @@
 #elif defined(EIGEN_WARNINGS_DISABLED)
 #undef EIGEN_WARNINGS_DISABLED
 
-#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
 #ifdef _MSC_VER
 #pragma warning(pop)
 #ifdef EIGEN_REENABLE_CXX23_DENORM_DEPRECATION_WARNING
@@ -17,7 +19,7 @@
 #pragma warning pop
 #elif defined __clang__
 #pragma clang diagnostic pop
-#elif defined __GNUC__ && !defined(__FUJITSU) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#elif defined __GNUC__ && !defined(__FUJITSU)
 #pragma GCC diagnostic pop
 #endif
 
@@ -39,6 +41,4 @@
 //    #undef EIGEN_MAKE_PRAGMA
 #endif
 
-#endif
-
 #endif  // EIGEN_WARNINGS_DISABLED
diff --git a/Eigen/src/Core/util/ReshapedHelper.h b/Eigen/src/Core/util/ReshapedHelper.h
index 1747950..5b39660 100644
--- a/Eigen/src/Core/util/ReshapedHelper.h
+++ b/Eigen/src/Core/util/ReshapedHelper.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RESHAPED_HELPER_H
 #define EIGEN_RESHAPED_HELPER_H
@@ -21,9 +22,7 @@
 namespace internal {
 
 template <typename SizeType, typename OtherSize, int TotalSize>
-struct get_compiletime_reshape_size {
-  enum { value = get_fixed_value<SizeType>::value };
-};
+struct get_compiletime_reshape_size : get_fixed_value<SizeType> {};
 
 template <typename SizeType>
 Index get_runtime_reshape_size(SizeType size, Index /*other*/, Index /*total*/) {
diff --git a/Eigen/src/Core/util/Serializer.h b/Eigen/src/Core/util/Serializer.h
index 6de7fe2..7361f65 100644
--- a/Eigen/src/Core/util/Serializer.h
+++ b/Eigen/src/Core/util/Serializer.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SERIALIZER_H
 #define EIGEN_SERIALIZER_H
@@ -28,8 +29,7 @@
 
 // Specialization for POD types.
 template <typename T>
-class Serializer<T,
-                 typename std::enable_if_t<std::is_trivially_copyable<T>::value && std::is_standard_layout<T>::value>> {
+class Serializer<T, std::enable_if_t<std::is_trivially_copyable<T>::value && std::is_standard_layout<T>::value>> {
  public:
   /**
    * Determines the required size of the serialization buffer for a value.
@@ -75,7 +75,7 @@
 template <typename Derived>
 class Serializer<DenseBase<Derived>, void> {
  public:
-  typedef typename Derived::Scalar Scalar;
+  using Scalar = typename Derived::Scalar;
 
   struct Header {
     typename Derived::Index rows;
@@ -123,46 +123,23 @@
 
 namespace internal {
 
-// Recursive serialization implementation helper.
-template <size_t N, typename... Types>
-struct serialize_impl;
+template <typename Arg>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t serialize_size_one(const Arg& arg) {
+  Serializer<std::decay_t<Arg>> serializer;
+  return serializer.size(arg);
+}
 
-template <size_t N, typename T1, typename... Ts>
-struct serialize_impl<N, T1, Ts...> {
-  using Serializer = Eigen::Serializer<std::decay_t<T1>>;
+template <typename Arg>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint8_t* serialize_one(uint8_t* dest, uint8_t* end, const Arg& arg) {
+  Serializer<std::decay_t<Arg>> serializer;
+  return serializer.serialize(dest, end, arg);
+}
 
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t serialize_size(const T1& value, const Ts&... args) {
-    Serializer serializer;
-    size_t size = serializer.size(value);
-    return size + serialize_impl<N - 1, Ts...>::serialize_size(args...);
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint8_t* serialize(uint8_t* dest, uint8_t* end, const T1& value,
-                                                                  const Ts&... args) {
-    Serializer serializer;
-    dest = serializer.serialize(dest, end, value);
-    return serialize_impl<N - 1, Ts...>::serialize(dest, end, args...);
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const uint8_t* deserialize(const uint8_t* src, const uint8_t* end,
-                                                                          T1& value, Ts&... args) {
-    Serializer serializer;
-    src = serializer.deserialize(src, end, value);
-    return serialize_impl<N - 1, Ts...>::deserialize(src, end, args...);
-  }
-};
-
-// Base case.
-template <>
-struct serialize_impl<0> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t serialize_size() { return 0; }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint8_t* serialize(uint8_t* dest, uint8_t* /*end*/) { return dest; }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const uint8_t* deserialize(const uint8_t* src, const uint8_t* /*end*/) {
-    return src;
-  }
-};
+template <typename Arg>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const uint8_t* deserialize_one(const uint8_t* src, const uint8_t* end, Arg& arg) {
+  Serializer<std::decay_t<Arg>> serializer;
+  return serializer.deserialize(src, end, arg);
+}
 
 }  // namespace internal
 
@@ -174,7 +151,10 @@
  */
 template <typename... Args>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t serialize_size(const Args&... args) {
-  return internal::serialize_impl<sizeof...(args), Args...>::serialize_size(args...);
+  size_t size = 0;
+  int unused[] = {0, (size += internal::serialize_size_one(args), 0)...};
+  EIGEN_UNUSED_VARIABLE(unused);
+  return size;
 }
 
 /**
@@ -187,7 +167,10 @@
  */
 template <typename... Args>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint8_t* serialize(uint8_t* dest, uint8_t* end, const Args&... args) {
-  return internal::serialize_impl<sizeof...(args), Args...>::serialize(dest, end, args...);
+  EIGEN_UNUSED_VARIABLE(end);
+  int unused[] = {0, (dest = internal::serialize_one(dest, end, args), 0)...};
+  EIGEN_UNUSED_VARIABLE(unused);
+  return dest;
 }
 
 /**
@@ -201,7 +184,10 @@
 template <typename... Args>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const uint8_t* deserialize(const uint8_t* src, const uint8_t* end,
                                                                  Args&... args) {
-  return internal::serialize_impl<sizeof...(args), Args...>::deserialize(src, end, args...);
+  EIGEN_UNUSED_VARIABLE(end);
+  int unused[] = {0, (src = internal::deserialize_one(src, end, args), 0)...};
+  EIGEN_UNUSED_VARIABLE(unused);
+  return src;
 }
 
 }  // namespace Eigen
diff --git a/Eigen/src/Core/util/StaticAssert.h b/Eigen/src/Core/util/StaticAssert.h
index f062354..e6d0f1d 100644
--- a/Eigen/src/Core/util/StaticAssert.h
+++ b/Eigen/src/Core/util/StaticAssert.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STATIC_ASSERT_H
 #define EIGEN_STATIC_ASSERT_H
@@ -14,9 +15,12 @@
 /* Some notes on Eigen's static assertion mechanism:
  *
  *  - in EIGEN_STATIC_ASSERT(CONDITION,MSG) the parameter CONDITION must be a compile time boolean
- *    expression, and MSG an enum listed in struct internal::static_assertion<true>
+ *    expression, and MSG an identifier that is stringified into the diagnostic; by convention it is written
+ *    ALL_CAPS. Prefer one of the messages already used by the derived EIGEN_STATIC_ASSERT_* macros below.
  *
- *  - currently EIGEN_STATIC_ASSERT can only be used in function scope
+ *  - EIGEN_STATIC_ASSERT expands to a plain static_assert, so it may be used wherever a declaration is allowed,
+ *    including class scope (see e.g. log1p_impl in MathFunctions.h). That is why EIGEN_NO_STATIC_ASSERT removes
+ *    the check outright instead of downgrading it to an eigen_assert, which would only be valid in function scope.
  *
  */
 
@@ -64,8 +68,8 @@
       YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES)
 
 #define EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0, TYPE1)                                                     \
-  ((int(Eigen::internal::size_of_xpr_at_compile_time<TYPE0>::ret) == 0 &&                                  \
-    int(Eigen::internal::size_of_xpr_at_compile_time<TYPE1>::ret) == 0) ||                                 \
+  ((int(Eigen::internal::size_of_xpr_at_compile_time<TYPE0>::value) == 0 &&                                \
+    int(Eigen::internal::size_of_xpr_at_compile_time<TYPE1>::value) == 0) ||                               \
    ((int(TYPE0::RowsAtCompileTime) == Eigen::Dynamic || int(TYPE1::RowsAtCompileTime) == Eigen::Dynamic || \
      int(TYPE0::RowsAtCompileTime) == int(TYPE1::RowsAtCompileTime)) &&                                    \
     (int(TYPE0::ColsAtCompileTime) == Eigen::Dynamic || int(TYPE1::ColsAtCompileTime) == Eigen::Dynamic || \
@@ -87,13 +91,13 @@
 #define EIGEN_STATIC_ASSERT_LVALUE(Derived) \
   EIGEN_STATIC_ASSERT(Eigen::internal::is_lvalue<Derived>::value, THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY)
 
-#define EIGEN_STATIC_ASSERT_ARRAYXPR(Derived)                                                                          \
-  EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived>::XprKind, ArrayXpr>::value), \
+#define EIGEN_STATIC_ASSERT_ARRAYXPR(Derived)                                                              \
+  EIGEN_STATIC_ASSERT((std::is_same<typename Eigen::internal::traits<Derived>::XprKind, ArrayXpr>::value), \
                       THIS_METHOD_IS_ONLY_FOR_ARRAYS_NOT_MATRICES)
 
-#define EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2)                                                 \
-  EIGEN_STATIC_ASSERT((Eigen::internal::is_same<typename Eigen::internal::traits<Derived1>::XprKind,          \
-                                                typename Eigen::internal::traits<Derived2>::XprKind>::value), \
+#define EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2)                                     \
+  EIGEN_STATIC_ASSERT((std::is_same<typename Eigen::internal::traits<Derived1>::XprKind,          \
+                                    typename Eigen::internal::traits<Derived2>::XprKind>::value), \
                       YOU_CANNOT_MIX_ARRAYS_AND_MATRICES)
 
 // Check that a cost value is positive, and that is stay within a reasonable range
diff --git a/Eigen/src/Core/util/SymbolicIndex.h b/Eigen/src/Core/util/SymbolicIndex.h
index a90e2bb..8e64502 100644
--- a/Eigen/src/Core/util/SymbolicIndex.h
+++ b/Eigen/src/Core/util/SymbolicIndex.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SYMBOLIC_INDEX_H
 #define EIGEN_SYMBOLIC_INDEX_H
@@ -42,8 +43,6 @@
  */
 namespace symbolic {
 
-template <typename Tag>
-class Symbol;
 template <typename Tag, typename Type>
 class SymbolValue;
 template <typename Arg0>
@@ -175,12 +174,10 @@
   }
 };
 
+// BaseExpr has no conversion ctor, so we only have to check whether T can be statically cast to its base class
+// BaseExpr<T>.
 template <typename T>
-struct is_symbolic {
-  // BaseExpr has no conversion ctor, so we only have to check whether T can be statically cast to its base class
-  // BaseExpr<T>.
-  enum { value = internal::is_convertible<T, BaseExpr<T>>::value };
-};
+struct is_symbolic : std::is_convertible<T, BaseExpr<T>> {};
 
 // A simple wrapper around an integral value to provide the eval method.
 // We could also use a free-function symbolic_eval...
@@ -320,7 +317,7 @@
 class SymbolExpr : public BaseExpr<SymbolExpr<tag>> {
  public:
   /** Alias to the template parameter \c tag */
-  typedef tag Tag;
+  using Tag = tag;
 
   constexpr SymbolExpr() = default;
 
diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index 9ae6d69..d0229af 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_XPRHELPER_H
 #define EIGEN_XPRHELPER_H
@@ -63,19 +64,10 @@
   return convert_index_impl<IndexDest, IndexSrc>::run(idx);
 }
 
-// true if T can be considered as an integral index (i.e., and integral type or enum)
-template <typename T>
-struct is_valid_index_type {
-  enum { value = internal::is_integral<T>::value || std::is_enum<T>::value };
-};
-
 // true if both types are not valid index types
 template <typename RowIndices, typename ColIndices>
-struct valid_indexed_view_overload {
-  enum {
-    value = !(internal::is_valid_index_type<RowIndices>::value && internal::is_valid_index_type<ColIndices>::value)
-  };
-};
+struct valid_indexed_view_overload : bool_constant<!(internal::is_valid_index_type<RowIndices>::value &&
+                                                     internal::is_valid_index_type<ColIndices>::value)> {};
 
 // promote_scalar_arg is an helper used in operation between an expression and a scalar, like:
 //    expression * scalar
@@ -101,7 +93,7 @@
 
 // Recursively check safe conversion to PromotedType, and then ExprScalar if they are different.
 template <typename ExprScalar, typename T, typename PromotedType,
-          bool ConvertibleToLiteral = internal::is_convertible<T, PromotedType>::value,
+          bool ConvertibleToLiteral = std::is_convertible<T, PromotedType>::value,
           bool IsSafe = NumTraits<T>::IsInteger || !NumTraits<PromotedType>::IsInteger>
 struct promote_scalar_arg_unsupported;
 
@@ -151,9 +143,9 @@
 template <typename T, int Value>
 class variable_if_dynamic {
  public:
-  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) {
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit variable_if_dynamic(T v) noexcept {
     EIGEN_ONLY_USED_FOR_DEBUG(v);
-    eigen_assert(v == T(Value));
+    eigen_plain_assert(v == T(Value));
   }
   EIGEN_DEVICE_FUNC static constexpr T value() { return T(Value); }
   EIGEN_DEVICE_FUNC constexpr operator T() const { return T(Value); }
@@ -203,6 +195,14 @@
   enum { Cost = 10, PacketAccess = false, IsRepeatable = false };
 };
 
+// Marks a binary functor as commutative: f(a, b) == f(b, a). Reductions may then reorder
+// operands, not merely re-associate them, which enables faster accumulation. Deliberately a
+// separate trait rather than a functor_traits member: user code specializes functor_traits
+// wholesale, so a new member there would break every existing specialization. The default is
+// conservative; operand order is preserved unless a functor opts in.
+template <typename Func>
+struct functor_is_commutative : std::false_type {};
+
 // estimates the cost of lazily evaluating a generic functor by unwinding the expression
 template <typename Xpr>
 struct nested_functor_cost {
@@ -269,7 +269,7 @@
 
 template <int Size, typename PacketType,
           bool Stop = Size == Dynamic || (Size % unpacket_traits<PacketType>::size) == 0 ||
-                      is_same<PacketType, typename unpacket_traits<PacketType>::half>::value>
+                      std::is_same<PacketType, typename unpacket_traits<PacketType>::half>::value>
 struct find_best_packet_helper;
 
 template <int Size, typename PacketType>
@@ -287,9 +287,64 @@
   using type = typename find_best_packet_helper<Size, typename packet_traits<T>::type>::type;
 };
 
+// Like find_best_packet, but picks the widest packet whose size is <= Size
+// rather than the widest that exactly divides Size. The caller handles any tail.
+template <int Size, typename PacketType,
+          bool Stop = Size == Dynamic || Size >= unpacket_traits<PacketType>::size ||
+                      std::is_same<PacketType, typename unpacket_traits<PacketType>::half>::value>
+struct find_largest_packet_helper;
+
+template <int Size, typename PacketType>
+struct find_largest_packet_helper<Size, PacketType, true> {
+  using type = PacketType;
+};
+
+template <int Size, typename PacketType>
+struct find_largest_packet_helper<Size, PacketType, false> {
+  using type = typename find_largest_packet_helper<Size, typename unpacket_traits<PacketType>::half>::type;
+};
+
+template <typename T, int Size>
+struct find_largest_packet {
+  using type = typename find_largest_packet_helper<Size, typename packet_traits<T>::type>::type;
+};
+
+// Pick the packet type for a linear-traversal assignment: the widest packet
+// whose <full-packet count + scalar-tail count> is minimal.
+//
+// find_best_packet picks the widest exact divisor (no scalar tail). That
+// overshoots when no exact divisor exists -- it falls through to the smallest
+// packet, e.g. Packet4f at N=9 float on AVX2 emits 2*SSE + 1 scalar where
+// 1*Packet8f + 1 scalar would do. We prefer find_largest_packet whenever it
+// strictly cuts the op count; otherwise we keep find_best_packet so kernels
+// like LLT/LDLT that rely on exact-fit narrow packets are not disturbed
+// (e.g. 3*Packet2d == 1*Packet4d + 2 scalars at N=6 double on AVX-512, both
+// 3 ops -- keep Packet2d).
+//
+// Only used in LinearVectorizedTraversal, whose tail handling already accepts
+// a partial-packet remainder. InnerVectorized / SliceVectorized still require
+// exact divisibility, so they continue to use find_best_packet.
+template <typename T, int Size>
+struct find_assign_linear_packet {
+ private:
+  using best_type = typename find_best_packet<T, Size>::type;
+  using largest_type = typename find_largest_packet<T, Size>::type;
+  // Op count = full packets + scalar-tail elements (one scalar emit per tail
+  // element under CompleteUnrolling). Both helpers return the max packet for
+  // Dynamic, so the op-count tie there harmlessly resolves to find_best.
+  template <typename P>
+  static constexpr int ops() {
+    constexpr int sz = unpacket_traits<P>::size;
+    return Size == Dynamic ? 0 : Size / sz + Size % sz;
+  }
+
+ public:
+  using type = std::conditional_t<(ops<largest_type>() < ops<best_type>()), largest_type, best_type>;
+};
+
 template <int Size, typename PacketType,
           bool Stop = (Size == unpacket_traits<PacketType>::size) ||
-                      is_same<PacketType, typename unpacket_traits<PacketType>::half>::value>
+                      std::is_same<PacketType, typename unpacket_traits<PacketType>::half>::value>
 struct find_packet_by_size_helper;
 template <int Size, typename PacketType>
 struct find_packet_by_size_helper<Size, PacketType, true> {
@@ -332,14 +387,11 @@
 #endif
 
 template <typename T, int Size>
-struct compute_default_alignment {
-  enum { value = compute_default_alignment_helper(Size * sizeof(T), EIGEN_MAX_STATIC_ALIGN_BYTES) };
-};
+struct compute_default_alignment
+    : std::integral_constant<int, compute_default_alignment_helper(Size * sizeof(T), EIGEN_MAX_STATIC_ALIGN_BYTES)> {};
 
 template <typename T>
-struct compute_default_alignment<T, Dynamic> {
-  enum { value = EIGEN_MAX_ALIGN_BYTES };
-};
+struct compute_default_alignment<T, Dynamic> : std::integral_constant<int, EIGEN_MAX_ALIGN_BYTES> {};
 
 template <typename Scalar_, int Rows_, int Cols_,
           int Options_ = AutoAlign | ((Rows_ == 1 && Cols_ != 1)   ? RowMajor
@@ -366,16 +418,20 @@
   return DirectAccessBit | LvalueBit | NestByRefBit | row_major_bit;
 }
 
+/** \internal Compile-time product of two dimensions: Dynamic when either factor is unknown, and also when the
+ * product would not fit in \c int -- no fixed-size dimension or size that large is usable anyway, and the
+ * overflowing multiplication would be ill-formed in a constant expression. */
 constexpr int size_at_compile_time(int rows, int cols) {
   if (rows == 0 || cols == 0) return 0;
   if (rows == Dynamic || cols == Dynamic) return Dynamic;
+  if (rows > (std::numeric_limits<int>::max)() / cols) return Dynamic;
   return rows * cols;
 }
 
 template <typename XprType>
-struct size_of_xpr_at_compile_time {
-  enum { ret = size_at_compile_time(traits<XprType>::RowsAtCompileTime, traits<XprType>::ColsAtCompileTime) };
-};
+struct size_of_xpr_at_compile_time
+    : std::integral_constant<int, size_at_compile_time(traits<XprType>::RowsAtCompileTime,
+                                                       traits<XprType>::ColsAtCompileTime)> {};
 
 /* plain_matrix_type : the difference from eval is that plain_matrix_type is always a plain matrix type,
  * whereas eval is a const reference in the case of a matrix
@@ -383,6 +439,24 @@
 
 template <typename T, typename StorageKind = typename traits<T>::StorageKind>
 struct plain_matrix_type;
+
+/* plain_object_options : the Options template argument (storage order and alignment) of the plain object that a
+ * decomposition's MatrixType stores: the type's own for a Matrix or Array, the referenced type's for a Ref, whose own
+ * Options is a pointer-alignment requirement instead.
+ */
+template <typename T>
+struct plain_object_options {
+  static constexpr int value = int(traits<T>::Options);
+};
+template <typename PlainObjectType, int Options, typename StrideType>
+struct plain_object_options<Ref<PlainObjectType, Options, StrideType>> : plain_object_options<PlainObjectType> {};
+
+/* is_ref : whether T is a Ref<>, i.e. a decomposition instantiated on it works in the referenced memory. */
+template <typename T>
+struct is_ref : std::false_type {};
+template <typename PlainObjectType, int Options, typename StrideType>
+struct is_ref<Ref<PlainObjectType, Options, StrideType>> : std::true_type {};
+
 template <typename T, typename BaseClassType, int Flags>
 struct plain_matrix_type_dense;
 template <typename T>
@@ -553,7 +627,7 @@
   using CurrentScalarType = typename XprType::Scalar;
   using CastType_ = remove_all_t<CastType>;
   using NewScalarType = typename CastType_::Scalar;
-  using type = std::conditional_t<is_same<CurrentScalarType, NewScalarType>::value, const XprType&, CastType>;
+  using type = std::conditional_t<std::is_same<CurrentScalarType, NewScalarType>::value, const XprType&, CastType>;
 };
 
 template <typename A, typename B>
@@ -614,22 +688,14 @@
 };
 
 template <typename LhsKind, typename RhsKind, int LhsOrder, int RhsOrder>
-struct cwise_promote_storage_order {
-  enum { value = LhsOrder };
-};
+struct cwise_promote_storage_order : std::integral_constant<int, LhsOrder> {};
 
 template <typename LhsKind, int LhsOrder, int RhsOrder>
-struct cwise_promote_storage_order<LhsKind, Sparse, LhsOrder, RhsOrder> {
-  enum { value = RhsOrder };
-};
+struct cwise_promote_storage_order<LhsKind, Sparse, LhsOrder, RhsOrder> : std::integral_constant<int, RhsOrder> {};
 template <typename RhsKind, int LhsOrder, int RhsOrder>
-struct cwise_promote_storage_order<Sparse, RhsKind, LhsOrder, RhsOrder> {
-  enum { value = LhsOrder };
-};
+struct cwise_promote_storage_order<Sparse, RhsKind, LhsOrder, RhsOrder> : std::integral_constant<int, LhsOrder> {};
 template <int Order>
-struct cwise_promote_storage_order<Sparse, Sparse, Order, Order> {
-  enum { value = Order };
-};
+struct cwise_promote_storage_order<Sparse, Sparse, Order, Order> : std::integral_constant<int, Order> {};
 
 /** \internal Specify the "storage kind" of multiplying an expression of kind A with kind B.
  * The template parameter ProductTag permits to specialize the resulting storage kind wrt to
@@ -702,6 +768,16 @@
 struct product_promote_storage_type<SkewSymmetricShape, SkewSymmetricShape, ProductTag> {
   using ret = Dense;
 };
+// A skew-symmetric matrix scaled by a diagonal is neither, and without these the <A, DiagonalShape> and
+// <SkewSymmetricShape, B> rules are ambiguous.
+template <int ProductTag>
+struct product_promote_storage_type<SkewSymmetricShape, DiagonalShape, ProductTag> {
+  using ret = Dense;
+};
+template <int ProductTag>
+struct product_promote_storage_type<DiagonalShape, SkewSymmetricShape, ProductTag> {
+  using ret = Dense;
+};
 
 template <typename A, int ProductTag>
 struct product_promote_storage_type<A, PermutationStorage, ProductTag> {
@@ -732,8 +808,8 @@
       Array<Scalar, 1, ExpressionType::ColsAtCompileTime, int(ExpressionType::PlainObject::Options) | int(RowMajor), 1,
             ExpressionType::MaxColsAtCompileTime>;
 
-  using type = std::conditional_t<is_same<typename traits<ExpressionType>::XprKind, MatrixXpr>::value, MatrixRowType,
-                                  ArrayRowType>;
+  using type = std::conditional_t<std::is_same<typename traits<ExpressionType>::XprKind, MatrixXpr>::value,
+                                  MatrixRowType, ArrayRowType>;
 };
 
 template <typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
@@ -744,8 +820,8 @@
   using ArrayColType = Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
                              ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1>;
 
-  using type = std::conditional_t<is_same<typename traits<ExpressionType>::XprKind, MatrixXpr>::value, MatrixColType,
-                                  ArrayColType>;
+  using type = std::conditional_t<std::is_same<typename traits<ExpressionType>::XprKind, MatrixXpr>::value,
+                                  MatrixColType, ArrayColType>;
 };
 
 template <typename ExpressionType, typename Scalar = typename ExpressionType::Scalar>
@@ -758,8 +834,8 @@
       Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1>;
   using ArrayDiagType = Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1>;
 
-  using type = std::conditional_t<is_same<typename traits<ExpressionType>::XprKind, MatrixXpr>::value, MatrixDiagType,
-                                  ArrayDiagType>;
+  using type = std::conditional_t<std::is_same<typename traits<ExpressionType>::XprKind, MatrixXpr>::value,
+                                  MatrixDiagType, ArrayDiagType>;
 };
 
 template <typename Expr, typename Scalar = typename Expr::Scalar>
@@ -772,45 +848,32 @@
   using matrix_type = Matrix<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>::ColsAtCompileTime, Options,
                              traits<Expr>::MaxRowsAtCompileTime, traits<Expr>::MaxColsAtCompileTime>;
 
-  using type = CwiseNullaryOp<
-      scalar_constant_op<Scalar>,
-      const std::conditional_t<is_same<typename traits<Expr>::XprKind, MatrixXpr>::value, matrix_type, array_type>>;
+  using type = CwiseNullaryOp<scalar_constant_op<Scalar>,
+                              const std::conditional_t<std::is_same<typename traits<Expr>::XprKind, MatrixXpr>::value,
+                                                       matrix_type, array_type>>;
 };
 
 template <typename ExpressionType>
-struct is_lvalue {
-  enum { value = (!bool(is_const<ExpressionType>::value)) && bool(traits<ExpressionType>::Flags & LvalueBit) };
-};
+struct is_lvalue : bool_constant<(!bool(std::is_const<ExpressionType>::value)) &&
+                                 bool((traits<ExpressionType>::Flags & LvalueBit))> {};
 
 template <typename T>
-struct is_diagonal {
-  enum { ret = false };
-};
+struct is_diagonal : std::false_type {};
 
 template <typename T>
-struct is_diagonal<DiagonalBase<T>> {
-  enum { ret = true };
-};
+struct is_diagonal<DiagonalBase<T>> : std::true_type {};
 
 template <typename T>
-struct is_diagonal<DiagonalWrapper<T>> {
-  enum { ret = true };
-};
+struct is_diagonal<DiagonalWrapper<T>> : std::true_type {};
 
 template <typename T, int S>
-struct is_diagonal<DiagonalMatrix<T, S>> {
-  enum { ret = true };
-};
+struct is_diagonal<DiagonalMatrix<T, S>> : std::true_type {};
 
 template <typename T>
-struct is_identity {
-  enum { value = false };
-};
+struct is_identity : std::false_type {};
 
 template <typename T>
-struct is_identity<CwiseNullaryOp<internal::scalar_identity_op<typename T::Scalar>, T>> {
-  enum { value = true };
-};
+struct is_identity<CwiseNullaryOp<internal::scalar_identity_op<typename T::Scalar>, T>> : std::true_type {};
 
 template <typename S1, typename S2>
 struct glue_shapes;
@@ -820,49 +883,37 @@
 };
 
 template <typename T1, typename T2>
-struct possibly_same_dense {
-  enum {
-    value = has_direct_access<T1>::ret && has_direct_access<T2>::ret &&
-            is_same<typename T1::Scalar, typename T2::Scalar>::value
-  };
-};
+struct possibly_same_dense : bool_constant<has_direct_access<T1>::value && has_direct_access<T2>::value &&
+                                           std::is_same<typename T1::Scalar, typename T2::Scalar>::value> {};
 
-template <typename T1, typename T2>
-EIGEN_DEVICE_FUNC bool is_same_dense(const T1& mat1, const T2& mat2,
-                                     std::enable_if_t<possibly_same_dense<T1, T2>::value>* = 0) {
+template <typename T1, typename T2, std::enable_if_t<possibly_same_dense<T1, T2>::value, int> = 0>
+EIGEN_DEVICE_FUNC bool is_same_dense(const T1& mat1, const T2& mat2) {
   return (mat1.data() == mat2.data()) && (mat1.innerStride() == mat2.innerStride()) &&
          (mat1.outerStride() == mat2.outerStride());
 }
 
-template <typename T1, typename T2>
-EIGEN_DEVICE_FUNC bool is_same_dense(const T1&, const T2&, std::enable_if_t<!possibly_same_dense<T1, T2>::value>* = 0) {
+template <typename T1, typename T2, std::enable_if_t<!possibly_same_dense<T1, T2>::value, int> = 0>
+EIGEN_DEVICE_FUNC bool is_same_dense(const T1&, const T2&) {
   return false;
 }
 
 // Internal helper defining the cost of a scalar division for the type T.
 // The default heuristic can be specialized for each scalar type and architecture.
 template <typename T, bool Vectorized = false, typename EnableIf = void>
-struct scalar_div_cost {
-  enum { value = 8 * NumTraits<T>::MulCost };
-};
+struct scalar_div_cost : std::integral_constant<int, 8 * NumTraits<T>::MulCost> {};
 
 template <typename T, bool Vectorized>
-struct scalar_div_cost<T, Vectorized, std::enable_if_t<NumTraits<T>::IsComplex>> {
-  using RealScalar = typename NumTraits<T>::Real;
-  enum {
-    value =
-        2 * scalar_div_cost<RealScalar>::value + 6 * NumTraits<RealScalar>::MulCost + 3 * NumTraits<RealScalar>::AddCost
-  };
-};
+struct scalar_div_cost<T, Vectorized, std::enable_if_t<NumTraits<T>::IsComplex>>
+    : std::integral_constant<int, 2 * scalar_div_cost<typename NumTraits<T>::Real>::value +
+                                      6 * NumTraits<typename NumTraits<T>::Real>::MulCost +
+                                      3 * NumTraits<typename NumTraits<T>::Real>::AddCost> {};
 
 template <bool Vectorized>
-struct scalar_div_cost<signed long, Vectorized, std::conditional_t<sizeof(long) == 8, void, false_type>> {
-  enum { value = 24 };
-};
+struct scalar_div_cost<signed long, Vectorized, std::conditional_t<sizeof(long) == 8, void, std::false_type>>
+    : std::integral_constant<int, 24> {};
 template <bool Vectorized>
-struct scalar_div_cost<unsigned long, Vectorized, std::conditional_t<sizeof(long) == 8, void, false_type>> {
-  enum { value = 21 };
-};
+struct scalar_div_cost<unsigned long, Vectorized, std::conditional_t<sizeof(long) == 8, void, std::false_type>>
+    : std::integral_constant<int, 21> {};
 
 #ifdef EIGEN_DEBUG_ASSIGN
 std::string demangle_traversal(int t) {
@@ -930,7 +981,9 @@
 
   // For block-of-block expressions, we need to combine the InnerPannel trait
   // with that of the block subexpression.
-  static constexpr bool is_inner_panel(bool inner_panel) { return InnerPanel && inner_panel; }
+  static constexpr bool is_inner_panel(bool inner_panel) {
+    return NestedXprHelper::is_inner_panel(InnerPanel && inner_panel);
+  }
 
   // Only enable non-const base function if XprType is not const (otherwise we get a duplicates definition).
   template <typename T = XprType, typename EnableIf = std::enable_if_t<!std::is_const<T>::value>>
@@ -1045,7 +1098,7 @@
 // It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized
 // paths. So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user
 // tries to add together a float matrix and a double matrix.
-#define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP, LHS, RHS)                               \
+#define EIGEN_CHECK_BINARY_COMPATIBILITY(BINOP, LHS, RHS)                              \
   EIGEN_STATIC_ASSERT(                                                                 \
       (Eigen::internal::has_ReturnType<ScalarBinaryOpTraits<LHS, RHS, BINOP>>::value), \
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
diff --git a/Eigen/src/Core/util/blas.h b/Eigen/src/Core/util/blas.h
new file mode 100644
index 0000000..0e79654
--- /dev/null
+++ b/Eigen/src/Core/util/blas.h
@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MISC_BLAS_H
+#define EIGEN_MISC_BLAS_H
+
+extern "C" {
+
+/* EIGEN_BLAS_SYM applies EIGEN_BLAS_SYMBOL_SUFFIX; both come from Core/util/MKL_support.h, this header's only
+ * includer. The declarations here must stay in step with the BLAS call sites under Core/products.
+ */
+#define BLASFUNC(FUNC) EIGEN_BLAS_SYM(FUNC)
+
+/* Level 1 routines */
+
+void BLASFUNC(saxpy)(const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(daxpy)(const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *, double *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(caxpy)(const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(zaxpy)(const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *, double *,
+                     const EIGEN_BLAS_INT *);
+
+/* Level 2 routines */
+
+void BLASFUNC(sgemv)(const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const float *, const float *,
+                     const EIGEN_BLAS_INT *, const float *, const EIGEN_BLAS_INT *, const float *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(dgemv)(const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const double *, const double *,
+                     const EIGEN_BLAS_INT *, const double *, const EIGEN_BLAS_INT *, const double *, double *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(cgemv)(const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const float *, const float *,
+                     const EIGEN_BLAS_INT *, const float *, const EIGEN_BLAS_INT *, const float *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(zgemv)(const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const double *, const double *,
+                     const EIGEN_BLAS_INT *, const double *, const EIGEN_BLAS_INT *, const double *, double *,
+                     const EIGEN_BLAS_INT *);
+
+void BLASFUNC(strmv)(const char *, const char *, const char *, const EIGEN_BLAS_INT *, const float *,
+                     const EIGEN_BLAS_INT *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(dtrmv)(const char *, const char *, const char *, const EIGEN_BLAS_INT *, const double *,
+                     const EIGEN_BLAS_INT *, double *, const EIGEN_BLAS_INT *);
+void BLASFUNC(ctrmv)(const char *, const char *, const char *, const EIGEN_BLAS_INT *, const float *,
+                     const EIGEN_BLAS_INT *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(ztrmv)(const char *, const char *, const char *, const EIGEN_BLAS_INT *, const double *,
+                     const EIGEN_BLAS_INT *, double *, const EIGEN_BLAS_INT *);
+
+void BLASFUNC(ssymv)(const char *, const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *,
+                     const float *, const EIGEN_BLAS_INT *, const float *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(dsymv)(const char *, const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *,
+                     const double *, const EIGEN_BLAS_INT *, const double *, double *, const EIGEN_BLAS_INT *);
+
+void BLASFUNC(chemv)(const char *, const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *,
+                     const float *, const EIGEN_BLAS_INT *, const float *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(zhemv)(const char *, const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *,
+                     const double *, const EIGEN_BLAS_INT *, const double *, double *, const EIGEN_BLAS_INT *);
+
+/* Level 3 routines */
+
+void BLASFUNC(sgemm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *,
+                     const float *, const float *, const EIGEN_BLAS_INT *, const float *, const EIGEN_BLAS_INT *,
+                     const float *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(dgemm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *,
+                     const double *, const double *, const EIGEN_BLAS_INT *, const double *, const EIGEN_BLAS_INT *,
+                     const double *, double *, const EIGEN_BLAS_INT *);
+void BLASFUNC(cgemm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *,
+                     const float *, const float *, const EIGEN_BLAS_INT *, const float *, const EIGEN_BLAS_INT *,
+                     const float *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(zgemm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *,
+                     const double *, const double *, const EIGEN_BLAS_INT *, const double *, const EIGEN_BLAS_INT *,
+                     const double *, double *, const EIGEN_BLAS_INT *);
+
+void BLASFUNC(strsm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(dtrsm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *, double *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(ctrsm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(ztrsm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *, double *,
+                     const EIGEN_BLAS_INT *);
+
+void BLASFUNC(strmm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(dtrmm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *, double *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(ctrmm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const float *, const float *, const EIGEN_BLAS_INT *, float *,
+                     const EIGEN_BLAS_INT *);
+void BLASFUNC(ztrmm)(const char *, const char *, const char *, const char *, const EIGEN_BLAS_INT *,
+                     const EIGEN_BLAS_INT *, const double *, const double *, const EIGEN_BLAS_INT *, double *,
+                     const EIGEN_BLAS_INT *);
+
+void BLASFUNC(ssymm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const float *,
+                     const float *, const EIGEN_BLAS_INT *, const float *, const EIGEN_BLAS_INT *, const float *,
+                     float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(dsymm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const double *,
+                     const double *, const EIGEN_BLAS_INT *, const double *, const EIGEN_BLAS_INT *, const double *,
+                     double *, const EIGEN_BLAS_INT *);
+
+void BLASFUNC(ssyrk)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const float *,
+                     const float *, const EIGEN_BLAS_INT *, const float *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(dsyrk)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const double *,
+                     const double *, const EIGEN_BLAS_INT *, const double *, double *, const EIGEN_BLAS_INT *);
+
+void BLASFUNC(chemm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const float *,
+                     const float *, const EIGEN_BLAS_INT *, const float *, const EIGEN_BLAS_INT *, const float *,
+                     float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(zhemm)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const double *,
+                     const double *, const EIGEN_BLAS_INT *, const double *, const EIGEN_BLAS_INT *, const double *,
+                     double *, const EIGEN_BLAS_INT *);
+
+void BLASFUNC(cherk)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const float *,
+                     const float *, const EIGEN_BLAS_INT *, const float *, float *, const EIGEN_BLAS_INT *);
+void BLASFUNC(zherk)(const char *, const char *, const EIGEN_BLAS_INT *, const EIGEN_BLAS_INT *, const double *,
+                     const double *, const EIGEN_BLAS_INT *, const double *, double *, const EIGEN_BLAS_INT *);
+
+#undef BLASFUNC
+}
+
+#endif
diff --git a/Eigen/src/Eigenvalues/ComplexEigenSolver.h b/Eigen/src/Eigenvalues/ComplexEigenSolver.h
index c848955..fd41a90 100644
--- a/Eigen/src/Eigenvalues/ComplexEigenSolver.h
+++ b/Eigen/src/Eigenvalues/ComplexEigenSolver.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_EIGEN_SOLVER_H
 #define EIGEN_COMPLEX_EIGEN_SOLVER_H
@@ -39,7 +40,7 @@
  * \f$. This is called the eigendecomposition.
  *
  * The main function in this class is compute(), which computes the
- * eigenvalues and eigenvectors of a given function. The
+ * eigenvalues and eigenvectors of a given matrix. The
  * documentation for that function contains an example showing the
  * main features of the class.
  *
@@ -49,20 +50,20 @@
 class ComplexEigenSolver {
  public:
   /** \brief Synonym for the template parameter \p MatrixType_. */
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
 
   /** \brief Scalar type for matrices of type #MatrixType. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
   /** \brief Complex scalar type for #MatrixType.
    *
@@ -70,31 +71,29 @@
    * \c float or \c double) and just \c Scalar if #Scalar is
    * complex.
    */
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
 
   /** \brief Type for vector of eigenvalues as returned by eigenvalues().
    *
    * This is a column vector with entries of type #ComplexScalar.
    * The length of the vector is the size of #MatrixType.
    */
-  typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & (~RowMajor), MaxColsAtCompileTime, 1> EigenvalueType;
+  using EigenvalueType = Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & (~RowMajor), MaxColsAtCompileTime, 1>;
 
   /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
    *
    * This is a square matrix with entries of type #ComplexScalar.
    * The size is the same as the size of #MatrixType.
    */
-  typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime,
-                 MaxColsAtCompileTime>
-      EigenvectorType;
+  using EigenvectorType =
+      Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
 
   /** \brief Default constructor.
    *
    * The default constructor is useful in cases in which the user intends to
    * perform decompositions via compute().
    */
-  ComplexEigenSolver()
-      : m_eivec(), m_eivalues(), m_schur(), m_isInitialized(false), m_eigenvectorsOk(false), m_matX() {}
+  ComplexEigenSolver() : m_eivec(), m_eivalues(), m_schur(), m_isInitialized(false), m_eigenvectorsOk(false) {}
 
   /** \brief Default Constructor with memory preallocation
    *
@@ -103,12 +102,7 @@
    * \sa ComplexEigenSolver()
    */
   explicit ComplexEigenSolver(Index size)
-      : m_eivec(size, size),
-        m_eivalues(size),
-        m_schur(size),
-        m_isInitialized(false),
-        m_eigenvectorsOk(false),
-        m_matX(size, size) {}
+      : m_eivec(size, size), m_eivalues(size), m_schur(size), m_isInitialized(false), m_eigenvectorsOk(false) {}
 
   /** \brief Constructor; computes eigendecomposition of given matrix.
    *
@@ -117,17 +111,37 @@
    *    eigenvalues are computed; if false, only the eigenvalues are
    *    computed.
    *
-   * This constructor calls compute() to compute the eigendecomposition.
+   * This constructor computes the eigendecomposition as compute() does.
    */
   template <typename InputType>
   explicit ComplexEigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
       : m_eivec(matrix.rows(), matrix.cols()),
         m_eivalues(matrix.cols()),
-        m_schur(matrix.rows()),
+        m_schur(matrix.derived(), computeEigenvectors),
         m_isInitialized(false),
-        m_eigenvectorsOk(false),
-        m_matX(matrix.rows(), matrix.cols()) {
-    compute(matrix.derived(), computeEigenvectors);
+        m_eigenvectorsOk(false) {
+    computeFromSchur(computeEigenvectors);
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix  Square matrix whose eigendecomposition is to be computed.
+   * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+   *    eigenvalues are computed; if false, only the eigenvalues are
+   *    computed.
+   *
+   * When \p MatrixType is a Ref<> (which requires a complex scalar type), the decomposition is computed within the
+   * memory of \p matrix, whose content is destroyed; the results are stored in the decomposition object. Otherwise
+   * this constructor behaves like ComplexEigenSolver(const EigenBase<InputType>&, bool).
+   */
+  template <typename InputType>
+  explicit ComplexEigenSolver(EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+      : m_eivec(matrix.rows(), matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_schur(matrix.derived(), computeEigenvectors),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false) {
+    computeFromSchur(computeEigenvectors);
   }
 
   /** \brief Returns the eigenvectors of given matrix.
@@ -229,12 +243,13 @@
 
   EigenvectorType m_eivec;
   EigenvalueType m_eivalues;
+  // Holds the Schur form of the last matrix; computing the eigenvectors overwrites T with the eigenvectors of T.
   ComplexSchur<MatrixType> m_schur;
   bool m_isInitialized;
   bool m_eigenvectorsOk;
-  EigenvectorType m_matX;
 
  private:
+  ComplexEigenSolver& computeFromSchur(bool computeEigenvectors);
   void doComputeEigenvectors(RealScalar matrixnorm);
   void sortEigenvalues(bool computeEigenvectors);
 };
@@ -249,7 +264,13 @@
   // Do a complex Schur decomposition, A = U T U^*
   // The eigenvalues are on the diagonal of T.
   m_schur.compute(matrix.derived(), computeEigenvectors);
+  return computeFromSchur(computeEigenvectors);
+}
 
+/** \internal Computes the eigenvalues, and the eigenvectors when requested, from the Schur decomposition held by
+ * m_schur. */
+template <typename MatrixType>
+ComplexEigenSolver<MatrixType>& ComplexEigenSolver<MatrixType>::computeFromSchur(bool computeEigenvectors) {
   if (m_schur.info() == Success) {
     m_eivalues = m_schur.matrixT().diagonal();
     if (computeEigenvectors) doComputeEigenvectors(m_schur.matrixT().norm());
@@ -266,29 +287,31 @@
   const Index n = m_eivalues.size();
 
   // Compute X such that T = X D X^(-1), where D is the diagonal of T.
-  // The matrix X is unit triangular.
-  m_matX = EigenvectorType::Zero(n, n);
+  // The matrix X is unit triangular. It overwrites T column by column from the last one: X(i,k) reads T(i,k) before
+  // replacing it, T(i,i+1..k-1) and T(i,i), T(k,k), which lie in columns not yet overwritten, and X(i+1..k-1,k),
+  // already computed.
+  typename ComplexSchur<MatrixType>::MatrixTType& matX = m_schur.m_matT;
+  matX.template triangularView<StrictlyLower>().setZero();
   for (Index k = n - 1; k >= 0; k--) {
-    m_matX.coeffRef(k, k) = ComplexScalar(1.0, 0.0);
     // Compute X(i,k) using the (i,k) entry of the equation X T = D X
     for (Index i = k - 1; i >= 0; i--) {
-      m_matX.coeffRef(i, k) = -m_schur.matrixT().coeff(i, k);
+      matX.coeffRef(i, k) = -matX.coeff(i, k);
       if (k - i - 1 > 0)
-        m_matX.coeffRef(i, k) -=
-            (m_schur.matrixT().row(i).segment(i + 1, k - i - 1) * m_matX.col(k).segment(i + 1, k - i - 1)).value();
-      ComplexScalar z = m_schur.matrixT().coeff(i, i) - m_schur.matrixT().coeff(k, k);
+        matX.coeffRef(i, k) -= (matX.row(i).segment(i + 1, k - i - 1) * matX.col(k).segment(i + 1, k - i - 1)).value();
+      ComplexScalar z = matX.coeff(i, i) - matX.coeff(k, k);
       if (z == ComplexScalar(0)) {
         // If the i-th and k-th eigenvalue are equal, then z equals 0.
         // Use a small value instead, to prevent division by zero.
         numext::real_ref(z) = numext::maxi(std::numeric_limits<RealScalar>::epsilon() * matrixnorm,
                                            (std::numeric_limits<RealScalar>::min)());
       }
-      m_matX.coeffRef(i, k) = m_matX.coeff(i, k) / z;
+      matX.coeffRef(i, k) /= z;
     }
+    matX.coeffRef(k, k) = ComplexScalar(1.0, 0.0);
   }
 
   // Compute V as V = U X; now A = U T U^* = U X D X^(-1) U^* = V D V^(-1)
-  m_eivec.noalias() = m_schur.matrixU() * m_matX;
+  m_eivec.noalias() = m_schur.matrixU() * matX;
   // .. and normalize the eigenvectors
   for (Index k = 0; k < n; k++) {
     m_eivec.col(k).stableNormalize();
diff --git a/Eigen/src/Eigenvalues/ComplexQZ.h b/Eigen/src/Eigenvalues/ComplexQZ.h
index 1d5f8d0..fb509f8 100644
--- a/Eigen/src/Eigenvalues/ComplexQZ.h
+++ b/Eigen/src/Eigenvalues/ComplexQZ.h
@@ -10,6 +10,7 @@
 // https://mozilla.org/MPL/2.0/.
 //
 // Derived from: Eigen/src/Eigenvalues/RealQZ.h
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_QZ_H_
 #define EIGEN_COMPLEX_QZ_H_
@@ -24,11 +25,11 @@
  *
  * \brief Performs a QZ decomposition of a pair of matrices A, B
  *
- * \tparam MatrixType_ the type input type of the matrix.
+ * \tparam MatrixType_ the input type of the matrix.
  *
- * Given to complex square matrices A and B, this class computes the QZ decomposition
+ * Given two complex square matrices A and B, this class computes the QZ decomposition
  * \f$ A = Q S Z \f$, \f$ B = Q T Z\f$ where Q and Z are unitary matrices and
- * S and T a re upper-triangular matrices. More precisely, Q and Z fulfill
+ * S and T are upper-triangular matrices. More precisely, Q and Z fulfill
  * \f$ Q Q* = Id\f$ and \f$ Z Z* = Id\f$. The generalized Eigenvalues are then
  * obtained as ratios of corresponding diagonal entries, lambda(i) = S(i,i) / T(i, i).
  *
@@ -57,11 +58,16 @@
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
 
+  /** \brief Type of the matrices returned by matrixQ() and matrixZ(): a plain matrix with the shape and storage
+   * options of \p MatrixType_, and \p MatrixType_ itself unless that is a Ref<>. */
+  using PlainMatrixType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+
   using Vec = Matrix<Scalar, Dynamic, 1>;
   using Vec2 = Matrix<Scalar, 2, 1>;
   using Vec3 = Matrix<Scalar, 3, 1>;
@@ -72,7 +78,7 @@
    *
    * \returns A const reference to the matrix Q.
    */
-  const MatrixType& matrixQ() const {
+  const PlainMatrixType& matrixQ() const {
     eigen_assert(m_isInitialized && "ComplexQZ is not initialized.");
     eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
     return m_Q;
@@ -82,7 +88,7 @@
    *
    * \returns A const reference to the matrix Z.
    */
-  const MatrixType& matrixZ() const {
+  const PlainMatrixType& matrixZ() const {
     eigen_assert(m_isInitialized && "ComplexQZ is not initialized.");
     eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
     return m_Z;
@@ -97,9 +103,9 @@
     return m_S;
   }
 
-  /** \brief Returns matrix S in the QZ decomposition.
+  /** \brief Returns matrix T in the QZ decomposition.
    *
-   * \returns A const reference to the matrix S.
+   * \returns A const reference to the matrix T.
    */
   const MatrixType& matrixT() const {
     eigen_assert(m_isInitialized && "ComplexQZ is not initialized.");
@@ -116,6 +122,8 @@
    */
   ComplexQZ(Index n, bool computeQZ = true, unsigned int maxIters = 400)
       : m_n(n),
+        m_maxIters(maxIters),
+        m_computeQZ(computeQZ),
         m_S(n, n),
         m_T(n, n),
         m_Q(computeQZ ? n : (MatrixType::RowsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::RowsAtCompileTime),
@@ -123,8 +131,7 @@
         m_Z(computeQZ ? n : (MatrixType::RowsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::RowsAtCompileTime),
             computeQZ ? n : (MatrixType::ColsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::ColsAtCompileTime)),
         m_ws(2 * n),
-        m_computeQZ(computeQZ),
-        m_maxIters(maxIters) {}
+        m_hCoeffs(n) {}
 
   /** \brief Constructor. computes the QZ decomposition of given matrices
    * upon creation
@@ -133,22 +140,52 @@
    * \param[in] B         input matrix B
    * \param[in] computeQZ If false, the matrices Q and Z are not computed
    *
-   * This constructor calls the compute() method to compute the QZ decomposition.
+   * This constructor computes the QZ decomposition as the compute() method does.
    * If input matrices are sparse, call the constructor that uses only the
    * size as input the computeSparse(...) method.
    */
-  ComplexQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true, unsigned int maxIters = 400)
+  template <typename InputTypeA, typename InputTypeB>
+  ComplexQZ(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B, bool computeQZ = true,
+            unsigned int maxIters = 400)
       : m_n(A.rows()),
         m_maxIters(maxIters),
         m_computeQZ(computeQZ),
-        m_S(A.rows(), A.cols()),
-        m_T(A.rows(), A.cols()),
+        m_S(A.derived()),
+        m_T(B.derived()),
         m_Q(computeQZ ? m_n : (MatrixType::RowsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::RowsAtCompileTime),
             computeQZ ? m_n : (MatrixType::ColsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::ColsAtCompileTime)),
         m_Z(computeQZ ? m_n : (MatrixType::RowsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::RowsAtCompileTime),
             computeQZ ? m_n : (MatrixType::ColsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::ColsAtCompileTime)),
-        m_ws(2 * m_n) {
-    compute(A, B, computeQZ);
+        m_ws(2 * m_n),
+        m_hCoeffs(m_n) {
+    computeInPlace(computeQZ);
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out] A         input matrix A
+   * \param[in,out] B         input matrix B
+   * \param[in]     computeQZ If false, the matrices Q and Z are not computed
+   * \param[in]     maxIters  Maximum number of iterations
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p A and \p B, which then
+   * hold S and T; Q and Z are stored in the decomposition object. Otherwise this constructor behaves like
+   * ComplexQZ(const EigenBase<InputTypeA>&, const EigenBase<InputTypeB>&, bool, unsigned int).
+   */
+  template <typename InputTypeA, typename InputTypeB>
+  ComplexQZ(EigenBase<InputTypeA>& A, EigenBase<InputTypeB>& B, bool computeQZ = true, unsigned int maxIters = 400)
+      : m_n(A.rows()),
+        m_maxIters(maxIters),
+        m_computeQZ(computeQZ),
+        m_S(A.derived()),
+        m_T(B.derived()),
+        m_Q(computeQZ ? m_n : (MatrixType::RowsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::RowsAtCompileTime),
+            computeQZ ? m_n : (MatrixType::ColsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::ColsAtCompileTime)),
+        m_Z(computeQZ ? m_n : (MatrixType::RowsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::RowsAtCompileTime),
+            computeQZ ? m_n : (MatrixType::ColsAtCompileTime == Eigen::Dynamic ? 0 : MatrixType::ColsAtCompileTime)),
+        m_ws(2 * m_n),
+        m_hCoeffs(m_n) {
+    computeInPlace(computeQZ);
   }
 
   /** \brief Compute the QZ decomposition of complex input matrices
@@ -157,7 +194,8 @@
    * \param[in] B         Matrix B.
    * \param[in] computeQZ If false, the matrices Q and Z are not computed.
    */
-  void compute(const MatrixType& A, const MatrixType& B, bool computeQZ = true);
+  template <typename InputTypeA, typename InputTypeB>
+  void compute(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B, bool computeQZ = true);
 
   /** \brief Compute the decomposition of sparse complex input matrices.
    * Main difference to the compute(...) method is that it computes a
@@ -174,7 +212,10 @@
    *
    * \returns \c Success if computation was successful, \c NoConvergence otherwise.
    */
-  ComputationInfo info() const { return m_info; }
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "ComplexQZ is not initialized.");
+    return m_info;
+  }
 
   /** \brief number of performed QZ steps
    */
@@ -186,25 +227,29 @@
  private:
   Index m_n;
   const unsigned int m_maxIters;
-  unsigned int m_global_iter;
-  bool m_isInitialized;
+  unsigned int m_global_iter = 0;
+  bool m_isInitialized = false;
   bool m_computeQZ;
-  ComputationInfo m_info;
-  MatrixType m_S, m_T, m_Q, m_Z;
+  ComputationInfo m_info = InvalidInput;
+  MatrixType m_S, m_T;
+  PlainMatrixType m_Q, m_Z;
   RealScalar m_normOfT, m_normOfS;
   Vec m_ws;
+  Vec m_hCoeffs;
 
   // Test if a Scalar is 0 up to a certain tolerance
   static bool is_negligible(const Scalar x, const RealScalar tol = NumTraits<RealScalar>::epsilon()) {
     return numext::abs(x) <= tol;
   }
 
-  void do_QZ_step(Index p, Index q);
+  void do_QZ_step(Index p, Index q, unsigned int iter);
 
-  inline Mat2 computeZk2(const Row2& b);
+  JacobiRotation<Scalar> computeZk2(const Row2& b);
+
+  void computeInPlace(bool computeQZ);
 
   // This is basically taken from Eigen3::RealQZ
-  void hessenbergTriangular(const MatrixType& A, const MatrixType& B);
+  void hessenbergTriangular();
 
   // This function can be called when m_Q and m_Z are initialized and m_S, m_T
   // are in hessenberg-triangular form
@@ -225,18 +270,32 @@
 };
 
 template <typename MatrixType_>
-void ComplexQZ<MatrixType_>::compute(const MatrixType& A, const MatrixType& B, bool computeQZ) {
-  m_computeQZ = computeQZ;
-  m_n = A.rows();
+template <typename InputTypeA, typename InputTypeB>
+void ComplexQZ<MatrixType_>::compute(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B, bool computeQZ) {
+  eigen_assert(A.rows() == A.cols() && "A is not a square matrix");
+  eigen_assert(A.rows() == B.rows() && A.rows() == B.cols() &&
+               "B is not a square matrix or B is not of the same size as A");
+  // Copy A and B, these will be the matrices on which we operate later
+  m_S = A.derived();
+  m_T = B.derived();
+  computeInPlace(computeQZ);
+}
 
-  eigen_assert(m_n == A.cols() && "A is not a square matrix");
-  eigen_assert(m_n == B.rows() && m_n == B.cols() && "B is not a square matrix or B is not of the same size as A");
+/** \internal Computes the QZ decomposition of the pencil held in (m_S, m_T), which are overwritten by S and T. */
+template <typename MatrixType_>
+void ComplexQZ<MatrixType_>::computeInPlace(bool computeQZ) {
+  m_computeQZ = computeQZ;
+  m_n = m_S.rows();
+
+  eigen_assert(m_n == m_S.cols() && "A is not a square matrix");
+  eigen_assert(m_n == m_T.rows() && m_n == m_T.cols() && "B is not a square matrix or B is not of the same size as A");
 
   m_isInitialized = true;
   m_global_iter = 0;
+  m_info = Success;
 
   // This will initialize m_Q and m_Z and bring m_S, m_T to hessenberg-triangular form
-  hessenbergTriangular(A, B);
+  hessenbergTriangular();
 
   // We assume that we already have that S is upper-Hessenberg and T is
   // upper-triangular. This is what the hessenbergTriangular(...) method does
@@ -245,22 +304,21 @@
 
 // This is basically taken from Eigen3::RealQZ
 template <typename MatrixType_>
-void ComplexQZ<MatrixType_>::hessenbergTriangular(const MatrixType& A, const MatrixType& B) {
-  // Copy A and B, these will be the matrices on which we operate later
-  m_S = A;
-  m_T = B;
-
-  // Perform QR decomposition of the matrix Q
-  HouseholderQR<MatrixType> qr(m_T);
-  m_T = qr.matrixQR();
-  m_T.template triangularView<StrictlyLower>().setZero();
-
-  if (m_computeQZ) m_Q = qr.householderQ();
+void ComplexQZ<MatrixType_>::hessenbergTriangular() {
+  // Perform the QR decomposition of T in place: T holds R above the Householder vectors Q is formed from
+  m_ws.resize(2 * m_n);
+  m_hCoeffs.resize(m_n);
+  internal::householder_qr_inplace_blocked<MatrixType, Vec>::run(m_T, m_hCoeffs, 48, m_ws.data());
+  Map<Vec> workspace(m_ws.data(), m_n);
+  const auto householderQ = householderSequence(m_T, m_hCoeffs.conjugate());
+  if (m_computeQZ) householderQ.evalTo(m_Q, workspace);
 
   // overwrite S with Q* x S
-  m_S.applyOnTheLeft(qr.householderQ().adjoint());
+  householderQ.adjoint().applyThisOnTheLeft(m_S, workspace);
 
-  if (m_computeQZ) m_Z = MatrixType::Identity(m_n, m_n);
+  m_T.template triangularView<StrictlyLower>().setZero();
+
+  if (m_computeQZ) m_Z = PlainMatrixType::Identity(m_n, m_n);
 
   // reduce S to upper Hessenberg with Givens rotations
   for (Index j = 0; j <= m_n - 3; j++) {
@@ -307,10 +365,9 @@
                "Call .makeCompressed() before passing it to SparseQR");
 
   // Computing QR decomposition of T...
-  sparseQR.setPivotThreshold(RealScalar(0));  // This prevends algorithm from doing pivoting
+  sparseQR.setPivotThreshold(RealScalar(0));  // This prevents the algorithm from doing pivoting
   sparseQR.compute(B);
   // perform QR decomposition of T, overwrite T with R, save Q
-  // HouseholderQR<Mat> qrT(m_T);
   m_T = sparseQR.matrixR();
   m_T.template triangularView<StrictlyLower>().setZero();
 
@@ -326,7 +383,6 @@
     for (Index i = m_n - 1; i >= j + 2; i--) {
       JacobiRotation<Scalar> G;
       // kill S(i,j)
-      // if(!numext::is_exactly_zero(_S.coeff(i, j)))
       if (m_S.coeff(i, j) != Scalar(0)) {
         // This is the adapted code
         G.makeGivens(m_S.coeff(i - 1, j), m_S.coeff(i, j), &m_S.coeffRef(i - 1, j));
@@ -365,6 +421,7 @@
   eigen_assert(m_n == B.rows() && m_n == B.cols() && "B is not a square matrix or B is not of the same size as A");
   m_isInitialized = true;
   m_global_iter = 0;
+  m_info = Success;
   hessenbergTriangularSparse(A, B);
 
   // We assume that we already have that A is upper-Hessenberg and B is
@@ -374,6 +431,7 @@
 
 template <typename MatrixType_>
 void ComplexQZ<MatrixType_>::reduceHessenbergTriangular() {
+  m_ws.resize(2 * m_n);
   Index l = m_n - 1, f;
   unsigned int local_iter = 0;
   computeNorms();
@@ -398,46 +456,54 @@
       if (z >= f) {
         push_down_zero_ST(z, l);
       } else {
-        do_QZ_step(f, m_n - l - 1);
+        do_QZ_step(f, m_n - l - 1, local_iter);
         local_iter++;
         m_global_iter++;
       }
     }
   }
 
-  m_info = (local_iter < m_maxIters) ? Success : NoConvergence;
+  // Preserve NumericalIssue if set
+  if (m_info != NumericalIssue) {
+    m_info = (local_iter < m_maxIters) ? Success : NoConvergence;
+  }
 }
 
 template <typename MatrixType_>
-inline typename ComplexQZ<MatrixType_>::Mat2 ComplexQZ<MatrixType_>::computeZk2(const Row2& b) {
-  Mat2 S;
-  S << Scalar(0), Scalar(1), Scalar(1), Scalar(0);
-  Vec2 bprime = S * b.adjoint();
+JacobiRotation<typename ComplexQZ<MatrixType_>::Scalar> ComplexQZ<MatrixType_>::computeZk2(const Row2& b) {
   JacobiRotation<Scalar> J;
-  J.makeGivens(bprime(0), bprime(1));
-  Mat2 Z = S;
-  Z.applyOnTheLeft(0, 1, J);
-  Z = S * Z;
-  return Z;
+  J.makeGivens(numext::conj(b(1)), numext::conj(b(0)));
+  // S J S = J.transpose() for the exchange matrix S and a real Givens cosine.
+  return J.transpose();
 }
 
 template <typename MatrixType_>
-void ComplexQZ<MatrixType_>::do_QZ_step(Index p, Index q) {
+void ComplexQZ<MatrixType_>::do_QZ_step(Index p, Index q, unsigned int iter) {
   // This is certainly not the most efficient way of doing this,
   // but a readable one.
   const auto a = [p, this](Index i, Index j) { return m_S(p + i - 1, p + j - 1); };
   const auto b = [p, this](Index i, Index j) { return m_T(p + i - 1, p + j - 1); };
   const Index m = m_n - p - q;  // Size of the inner block
   Scalar x, y, z;
-  // We could introduce doing exceptional shifts from time to time.
-  Scalar W1 = a(m - 1, m - 1) / b(m - 1, m - 1) - a(1, 1) / b(1, 1), W2 = a(m, m) / b(m, m) - a(1, 1) / b(1, 1),
-         W3 = a(m, m - 1) / b(m - 1, m - 1);
+  if (iter > 0 && iter % 10 == 0) {
+    // Break stalled double-shift iterations with a single shift displaced by the trailing subdiagonals.
+    const RealScalar displacement =
+        numext::abs(a(m, m - 1) / b(m - 1, m - 1)) + numext::abs(a(m - 1, m - 2) / b(m - 2, m - 2));
+    const Scalar shift = a(m, m) / b(m, m) + displacement;
+    // (S*T^-1 - shift*I)*e1 has only two nonzero entries.
+    x = a(1, 1) / b(1, 1) - shift;
+    y = a(2, 1) / b(1, 1);
+    z = Scalar(0);
+  } else {
+    Scalar W1 = a(m - 1, m - 1) / b(m - 1, m - 1) - a(1, 1) / b(1, 1), W2 = a(m, m) / b(m, m) - a(1, 1) / b(1, 1),
+           W3 = a(m, m - 1) / b(m - 1, m - 1);
 
-  x = (W1 * W2 - a(m - 1, m) / b(m, m) * W3 + W3 * b(m - 1, m) / b(m, m) * a(1, 1) / b(1, 1)) * b(1, 1) / a(2, 1) +
-      a(1, 2) / b(2, 2) - a(1, 1) / b(1, 1) * b(1, 2) / b(2, 2);
-  y = (a(2, 2) / b(2, 2) - a(1, 1) / b(1, 1)) - a(2, 1) / b(1, 1) * b(1, 2) / b(2, 2) - W1 - W2 +
-      W3 * (b(m - 1, m) / b(m, m));
-  z = a(3, 2) / b(2, 2);
+    x = (W1 * W2 - a(m - 1, m) / b(m, m) * W3 + W3 * b(m - 1, m) / b(m, m) * a(1, 1) / b(1, 1)) * b(1, 1) / a(2, 1) +
+        a(1, 2) / b(2, 2) - a(1, 1) / b(1, 1) * b(1, 2) / b(2, 2);
+    y = (a(2, 2) / b(2, 2) - a(1, 1) / b(1, 1)) - a(2, 1) / b(1, 1) * b(1, 2) / b(2, 2) - W1 - W2 +
+        W3 * (b(m - 1, m) / b(m, m));
+    z = a(3, 2) / b(2, 2);
+  }
   Vec3 X;
   const PermutationMatrix<3, 3, int> S3(Vector3i(2, 0, 1));
   for (Index k = p; k < p + m - 2; k++) {
@@ -453,40 +519,46 @@
         .rightCols((std::min)(m_n, m_n - k + 1))
         .applyHouseholderOnTheLeft(ess, tau, m_ws.data());
     m_T.template middleRows<3>(k).rightCols(m_n - k).applyHouseholderOnTheLeft(ess, tau, m_ws.data());
-    if (m_computeQZ) m_Q.template middleCols<3>(k).applyHouseholderOnTheRight(ess, std::conj(tau), m_ws.data());
+    if (m_computeQZ) m_Q.template middleCols<3>(k).applyHouseholderOnTheRight(ess, numext::conj(tau), m_ws.data());
 
     // Compute Matrix Zk1 s.t. (b(k+2,k) ... b(k+2, k+2)) Zk1 = (0,0,*)
     Vec3 bprime = (m_T.template block<1, 3>(k + 2, k) * S3).adjoint();
     bprime.makeHouseholder(ess, tau, beta);
-    m_S.template middleCols<3>(k).topRows((std::min)(k + 4, m_n)).applyOnTheRight(S3);
-    m_S.template middleCols<3>(k)
-        .topRows((std::min)(k + 4, m_n))
-        .applyHouseholderOnTheRight(ess, std::conj(tau), m_ws.data());
-    m_S.template middleCols<3>(k).topRows((std::min)(k + 4, m_n)).applyOnTheRight(S3.transpose());
-    m_T.template middleCols<3>(k).topRows((std::min)(k + 3, m_n)).applyOnTheRight(S3);
-    m_T.template middleCols<3>(k)
-        .topRows((std::min)(k + 3, m_n))
-        .applyHouseholderOnTheRight(ess, std::conj(tau), m_ws.data());
-    m_T.template middleCols<3>(k).topRows((std::min)(k + 3, m_n)).applyOnTheRight(S3.transpose());
+    auto Sk = m_S.template middleCols<3>(k).topRows((std::min)(k + 4, m_n));
+    auto Tk = m_T.template middleCols<3>(k).topRows((std::min)(k + 3, m_n));
+    // Right multiplication by S3 permutes columns as (2, 0, 1); reverse the swaps for S3^T.
+    Sk.col(0).swap(Sk.col(2));
+    Sk.col(1).swap(Sk.col(2));
+    Sk.applyHouseholderOnTheRight(ess, numext::conj(tau), m_ws.data());
+    Sk.col(1).swap(Sk.col(2));
+    Sk.col(0).swap(Sk.col(2));
+    Tk.col(0).swap(Tk.col(2));
+    Tk.col(1).swap(Tk.col(2));
+    Tk.applyHouseholderOnTheRight(ess, numext::conj(tau), m_ws.data());
+    Tk.col(1).swap(Tk.col(2));
+    Tk.col(0).swap(Tk.col(2));
     if (m_computeQZ) {
-      m_Z.template middleRows<3>(k).applyOnTheLeft(S3.transpose());
-      m_Z.template middleRows<3>(k).applyHouseholderOnTheLeft(ess, tau, m_ws.data());
-      m_Z.template middleRows<3>(k).applyOnTheLeft(S3);
+      auto Zk = m_Z.template middleRows<3>(k);
+      Zk.row(0).swap(Zk.row(2));
+      Zk.row(1).swap(Zk.row(2));
+      Zk.applyHouseholderOnTheLeft(ess, tau, m_ws.data());
+      Zk.row(1).swap(Zk.row(2));
+      Zk.row(0).swap(Zk.row(2));
     }
-    Mat2 Zk2 = computeZk2(m_T.template block<1, 2>(k + 1, k));
-    m_S.template middleCols<2>(k).topRows((std::min)(k + 4, m_n)).applyOnTheRight(Zk2);
-    m_T.template middleCols<2>(k).topRows((std::min)(k + 3, m_n)).applyOnTheRight(Zk2);
+    const JacobiRotation<Scalar> Zk2 = computeZk2(m_T.template block<1, 2>(k + 1, k));
+    m_S.template middleCols<2>(k).topRows((std::min)(k + 4, m_n)).applyOnTheRight(0, 1, Zk2);
+    m_T.template middleCols<2>(k).topRows((std::min)(k + 3, m_n)).applyOnTheRight(0, 1, Zk2);
 
-    if (m_computeQZ) m_Z.template middleRows<2>(k).applyOnTheLeft(Zk2.adjoint());
+    if (m_computeQZ) m_Z.template middleRows<2>(k).applyOnTheLeft(0, 1, Zk2.adjoint());
 
     x = m_S(k + 1, k);
     y = m_S(k + 2, k);
     if (k < p + m - 3) {
       z = m_S(k + 3, k);
     }
-  };
+  }
 
-  // Find a Householdermartirx Qn1 s.t. Qn1 (x y)^T = (* 0)
+  // Find a Householder matrix Qn1 s.t. Qn1 (x y)^T = (* 0)
   JacobiRotation<Scalar> J;
   J.makeGivens(x, y);
   m_S.template middleRows<2>(p + m - 2).applyOnTheLeft(0, 1, J.adjoint());
@@ -494,12 +566,12 @@
 
   if (m_computeQZ) m_Q.template middleCols<2>(p + m - 2).applyOnTheRight(0, 1, J);
 
-  // Find a Householdermatrix Zn1 s.t. (b(n,n-1) b(n,n)) * Zn1 = (0 *)
-  Mat2 Zn1 = computeZk2(m_T.template block<1, 2>(p + m - 1, p + m - 2));
-  m_S.template middleCols<2>(p + m - 2).applyOnTheRight(Zn1);
-  m_T.template middleCols<2>(p + m - 2).applyOnTheRight(Zn1);
+  // Find a rotation Zn1 s.t. (b(n,n-1) b(n,n)) * Zn1 = (0 *)
+  const JacobiRotation<Scalar> Zn1 = computeZk2(m_T.template block<1, 2>(p + m - 1, p + m - 2));
+  m_S.template middleCols<2>(p + m - 2).applyOnTheRight(0, 1, Zn1);
+  m_T.template middleCols<2>(p + m - 2).applyOnTheRight(0, 1, Zn1);
 
-  if (m_computeQZ) m_Z.template middleRows<2>(p + m - 2).applyOnTheLeft(Zn1.adjoint());
+  if (m_computeQZ) m_Z.template middleRows<2>(p + m - 2).applyOnTheLeft(0, 1, Zn1.adjoint());
 }
 
 /** \internal we found an undesired non-zero at (i+1,i) on the subdiagonal of S and reduce the block */
@@ -521,7 +593,7 @@
     m_S.applyOnTheRight(i, i + 1, G.adjoint());
     m_T.applyOnTheRight(i, i + 1, G.adjoint());
     if (m_computeQZ) m_Z.applyOnTheLeft(i, i + 1, G);
-  } else if (!is_negligible(Ti(0, 0)) && !is_negligible((Ti(1, 1)))) {
+  } else if (!is_negligible(Ti(0, 0)) && !is_negligible(Ti(1, 1))) {
     Scalar mu = Si(0, 0) / Ti(0, 0);
     Scalar a12_bar = Si(0, 1) - mu * Ti(0, 1);
     Scalar a22_bar = Si(1, 1) - mu * Ti(1, 1);
@@ -559,8 +631,6 @@
 /** \internal We found a zero at T(k,k) and want to "push it down" to T(l,l) */
 template <typename MatrixType_>
 void ComplexQZ<MatrixType_>::push_down_zero_ST(Index k, Index l) {
-  // Test Preconditions
-
   JacobiRotation<Scalar> J;
   for (Index j = k + 1; j <= l; j++) {
     // Create a 0 at _T(j, j)
@@ -576,7 +646,7 @@
 
     // Delete the non-desired non-zero at _S(j, j-2)
     if (j > 1) {
-      J.makeGivens(std::conj(m_S(j, j - 1)), std::conj(m_S(j, j - 2)));
+      J.makeGivens(numext::conj(m_S(j, j - 1)), numext::conj(m_S(j, j - 2)));
       m_S.applyOnTheRight(j - 1, j - 2, J);
       m_S(j, j - 2) = Scalar(0);
       m_T.applyOnTheRight(j - 1, j - 2, J);
@@ -586,7 +656,7 @@
 
   // Assume we have the desired structure now, up to the non-zero entry at
   // _S(l, l-1) which we will delete through a last right-jacobi-rotation
-  J.makeGivens(std::conj(m_S(l, l)), std::conj(m_S(l, l - 1)));
+  J.makeGivens(numext::conj(m_S(l, l)), numext::conj(m_S(l, l - 1)));
   m_S.topRows(l + 1).applyOnTheRight(l, l - 1, J);
 
   if (!is_negligible(m_S(l, l - 1), m_normOfS * NumTraits<Scalar>::epsilon())) {
@@ -610,13 +680,8 @@
 /** \internal Computes vector L1 norms of S and T when in Hessenberg-Triangular form already */
 template <typename MatrixType_>
 void ComplexQZ<MatrixType_>::computeNorms() {
-  const Index size = m_S.cols();
-  m_normOfS = RealScalar(0);
-  m_normOfT = RealScalar(0);
-  for (Index j = 0; j < size; ++j) {
-    m_normOfS += m_S.col(j).segment(0, (std::min)(size, j + 2)).cwiseAbs().sum();
-    m_normOfT += m_T.row(j).segment(j, size - j).cwiseAbs().sum();
-  }
+  m_normOfS = internal::hessenberg_abs_sum<Upper>(m_S);
+  m_normOfT = internal::triangular_abs_sum<Upper>(m_T);
 }
 
 /** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0). Copied from Eigen3 RealQZ
@@ -633,7 +698,6 @@
   return res;
 }
 
-//
 /** \internal Look for single small diagonal element T(res, res) for res between f and l, and return res (or f-1).
  * Copied from Eigen3 RealQZ implementation. */
 template <typename MatrixType_>
@@ -648,4 +712,4 @@
 
 }  // namespace Eigen
 
-#endif  // _COMPLEX_QZ_H_
+#endif  // EIGEN_COMPLEX_QZ_H_
diff --git a/Eigen/src/Eigenvalues/ComplexSchur.h b/Eigen/src/Eigenvalues/ComplexSchur.h
index 86d6349..5634758 100644
--- a/Eigen/src/Eigenvalues/ComplexSchur.h
+++ b/Eigen/src/Eigenvalues/ComplexSchur.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLEX_SCHUR_H
 #define EIGEN_COMPLEX_SCHUR_H
@@ -24,6 +25,9 @@
 struct complex_schur_reduce_to_hessenberg;
 }
 
+template <typename MatrixType_>
+class ComplexEigenSolver;
+
 /** \eigenvalues_module \ingroup Eigenvalues_Module
  *
  *
@@ -46,7 +50,7 @@
  * ComplexSchur(const MatrixType&, bool) constructor which computes
  * the Schur decomposition at construction time. Once the
  * decomposition is computed, you can use the matrixU() and matrixT()
- * functions to retrieve the matrices U and V in the decomposition.
+ * functions to retrieve the matrices U and T in the decomposition.
  *
  * \note This code is inspired from Jampack
  *
@@ -55,19 +59,19 @@
 template <typename MatrixType_>
 class ComplexSchur {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
 
   /** \brief Scalar type for matrices of type \p MatrixType_. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
   /** \brief Complex scalar type for \p MatrixType_.
    *
@@ -75,16 +79,21 @@
    * \c float or \c double) and just \c Scalar if #Scalar is
    * complex.
    */
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
 
   /** \brief Type for the matrices in the Schur decomposition.
    *
    * This is a square matrix with entries of type #ComplexScalar.
    * The size is the same as the size of \p MatrixType_.
    */
-  typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime,
-                 MaxColsAtCompileTime>
-      ComplexMatrixType;
+  using ComplexMatrixType =
+      Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+
+  /** \brief Type of the matrix returned by matrixT().
+   *
+   * This is #ComplexMatrixType, or \p MatrixType_ itself when that is a Ref<>: the \link InplaceDecomposition
+   * inplace decomposition \endlink then stores T in the referenced matrix. */
+  using MatrixTType = std::conditional_t<internal::is_ref<MatrixType>::value, MatrixType, ComplexMatrixType>;
 
   /** \brief Default constructor.
    *
@@ -125,6 +134,26 @@
     compute(matrix.derived(), computeU);
   }
 
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix    Square complex matrix whose Schur decomposition is to be computed.
+   * \param[in]      computeU  If true, both T and U are computed; if false, only T is computed.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p matrix, which then holds
+   * the triangular matrix T returned by matrixT(); U is stored in the decomposition object. This overload is only
+   * available for a complex Ref<>; owning matrix types use the constructor taking a const input.
+   */
+  template <typename InputType, bool IsRef = internal::is_ref<MatrixType>::value, std::enable_if_t<IsRef, int> = 0>
+  explicit ComplexSchur(EigenBase<InputType>& matrix, bool computeU = true)
+      : m_matT(matrix.derived()),
+        m_matU(matrix.rows(), matrix.cols()),
+        m_hess(matrix.rows()),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1) {
+    computeInPlace(computeU);
+  }
+
   /** \brief Returns the unitary matrix in the Schur decomposition.
    *
    * \returns A const reference to the matrix U.
@@ -162,7 +191,7 @@
    * Example: \include ComplexSchur_matrixT.cpp
    * Output: \verbinclude ComplexSchur_matrixT.out
    */
-  const ComplexMatrixType& matrixT() const {
+  const MatrixTType& matrixT() const {
     eigen_assert(m_isInitialized && "ComplexSchur is not initialized.");
     return m_matT;
   }
@@ -180,7 +209,6 @@
     * to triangular form by performing QR iterations with a single
     * shift. The cost of computing the Schur decomposition depends
     * on the number of iterations; as a rough guide, it may be taken
-    * on the number of iterations; as a rough guide, it may be taken
     * to be \f$25n^3\f$ complex flops, or \f$10n^3\f$ complex flops
     * if \a computeU is false.
     *
@@ -195,7 +223,7 @@
   /** \brief Compute Schur decomposition from a given Hessenberg matrix
    *  \param[in] matrixH Matrix in Hessenberg form H
    *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
-   *  \param computeU Computes the matriX U of the Schur vectors
+   *  \param computeU Computes the matrix U of the Schur vectors
    * \return Reference to \c *this
    *
    *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
@@ -243,14 +271,22 @@
   static const int m_maxIterationsPerRow = 30;
 
  protected:
-  ComplexMatrixType m_matT, m_matU;
-  HessenbergDecomposition<MatrixType> m_hess;
+  EIGEN_STATIC_ASSERT(NumTraits<Scalar>::IsComplex || !internal::is_ref<MatrixType>::value,
+                      INPLACE_COMPLEXSCHUR_REQUIRES_A_COMPLEX_MATRIX_TYPE)
+
+  MatrixTType m_matT;
+  ComplexMatrixType m_matU;
+  internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex> m_hess;
   ComputationInfo m_info;
   bool m_isInitialized;
   bool m_matUisUptodate;
   Index m_maxIters;
 
  private:
+  // ComplexEigenSolver computes the eigenvectors of T within this storage.
+  friend class ComplexEigenSolver<MatrixType>;
+
+  ComplexSchur& computeInPlace(bool computeU);
   bool subdiagonalEntryIsNeglegible(Index i);
   ComplexScalar computeShift(Index iu, Index iter);
   void reduceToTriangularForm(bool computeU);
@@ -284,8 +320,8 @@
   // compute the shift as one of the eigenvalues of t, the 2x2
   // diagonal block on the bottom of the active submatrix
   Matrix<ComplexScalar, 2, 2> t = m_matT.template block<2, 2>(iu - 1, iu - 1);
-  RealScalar normt = t.cwiseAbs().sum();
-  t /= normt;  // the normalization by sf is to avoid under/overflow
+  const RealScalar normt = t.cwiseAbs().sum();
+  const auto factors = internal::safe_scaling<RealScalar>::scale_to(t, t, normt);
 
   ComplexScalar b = t.coeff(0, 1) * t.coeff(1, 0);
   ComplexScalar c = t.coeff(0, 0) - t.coeff(1, 1);
@@ -304,10 +340,9 @@
     eival1 = det / eival2;
 
   // choose the eigenvalue closest to the bottom entry of the diagonal
-  if (numext::norm1(eival1 - t.coeff(1, 1)) < numext::norm1(eival2 - t.coeff(1, 1)))
-    return normt * eival1;
-  else
-    return normt * eival2;
+  ComplexScalar shift = numext::norm1(eival1 - t.coeff(1, 1)) < numext::norm1(eival2 - t.coeff(1, 1)) ? eival1 : eival2;
+  internal::safe_scaling<RealScalar>::unscale_in_place(shift, factors);
+  return shift;
 }
 
 template <typename MatrixType>
@@ -325,9 +360,44 @@
     return *this;
   }
 
-  internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>::run(*this, matrix.derived(),
-                                                                                              computeU);
+  // Reduce to Hessenberg form at unit scale, as RealSchur does: HessenbergDecomposition treats a subdiagonal tail
+  // whose squared norm underflows as already zero, so an unscaled matrix near the bottom of the exponent range loses
+  // its whole subdiagonal. For binary scalars the scale is the power of two just below the largest coefficient, clamped
+  // so that it and its reciprocal are normal; when maxCoeff < min/eps, both steps round through integer significands,
+  // which FTZ/DAZ and ARMv7 NEON cannot flush. A scale above one underflows coefficients more than the exponent range
+  // below the largest one, a perturbation bounded by the smallest subnormal relative to that largest coefficient.
+  // maxCoeff propagates NaN; a zero or non-finite maxCoeff carries no usable exponent and is left unscaled.
+  const RealScalar maxCoeff = internal::safe_scaling<RealScalar>::recover_flushed_max_coeff(
+      matrix.derived(), matrix.derived().cwiseAbs().template maxCoeff<PropagateNaN>());
+  const internal::safe_scaling_factors<RealScalar> factors = internal::safe_scaling<RealScalar>::with_scaled(
+      matrix.derived(), maxCoeff, [&](const auto& scaled) { m_hess.run(*this, scaled, computeU); });
   computeFromHessenberg(m_matT, m_matU, computeU);
+  // m_matU is unitary either way; only the triangular factor carries the scale.
+  internal::safe_scaling<RealScalar>::unscale_in_place(m_matT, maxCoeff, factors);
+  return *this;
+}
+
+/** \internal Computes the Schur decomposition of the complex matrix held in m_matT, which is overwritten by T. */
+template <typename MatrixType>
+ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::computeInPlace(bool computeU) {
+  m_matUisUptodate = false;
+  eigen_assert(m_matT.cols() == m_matT.rows());
+
+  if (m_matT.cols() == 1) {
+    if (computeU) m_matU = ComplexMatrixType::Identity(1, 1);
+    m_info = Success;
+    m_isInitialized = true;
+    m_matUisUptodate = computeU;
+    return *this;
+  }
+
+  const RealScalar maxCoeff = internal::safe_scaling<RealScalar>::recover_flushed_max_coeff(
+      m_matT, m_matT.cwiseAbs().template maxCoeff<PropagateNaN>());
+  const internal::safe_scaling_factors<RealScalar> factors =
+      internal::safe_scaling<RealScalar>::scale_in_place(m_matT, maxCoeff);
+  m_hess.runInPlace(*this, computeU);
+  computeFromHessenberg(m_matT, m_matU, computeU);
+  internal::safe_scaling<RealScalar>::unscale_in_place(m_matT, maxCoeff, factors);
   return *this;
 }
 
@@ -336,38 +406,64 @@
 ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH,
                                                                           const OrthMatrixType& matrixQ,
                                                                           bool computeU) {
-  m_matT = matrixH;
-  if (computeU) m_matU = matrixQ;
+  if (!internal::is_same_dense(m_matT, matrixH)) m_matT = matrixH;
+  if (computeU && !internal::is_same_dense(m_matU, matrixQ)) m_matU = matrixQ;
   reduceToTriangularForm(computeU);
   return *this;
 }
 namespace internal {
 
-/* Reduce given matrix to Hessenberg form */
+/* Reduce given matrix to Hessenberg form, and hold the workspace this takes. */
 template <typename MatrixType, bool IsComplex>
 struct complex_schur_reduce_to_hessenberg {
-  // this is the implementation for the case IsComplex = true
-  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU) {
-    _this.m_hess.compute(matrix);
-    _this.m_matT = _this.m_hess.matrixH();
-    if (computeU) _this.m_matU = _this.m_hess.matrixQ();
+  // this is the implementation for the case IsComplex = true: the reduction runs in place in m_matT.
+  using Schur = ComplexSchur<MatrixType>;
+  using Scalar = typename Schur::ComplexScalar;
+  using CoeffVectorType = Matrix<Scalar, Schur::RowsAtCompileTime == Dynamic ? Dynamic : Schur::RowsAtCompileTime - 1,
+                                 1, Schur::Options & ~RowMajor,
+                                 Schur::MaxRowsAtCompileTime == Dynamic ? Dynamic : Schur::MaxRowsAtCompileTime - 1, 1>;
+  using WorkspaceType =
+      Matrix<Scalar, Schur::ColsAtCompileTime, 1, Schur::Options & ~RowMajor, Schur::MaxColsAtCompileTime, 1>;
+
+  explicit complex_schur_reduce_to_hessenberg(Index size) : m_workspace(size) {
+    if (size > 1) m_hCoeffs.resize(size - 1);
   }
+
+  template <typename InputType>
+  void run(Schur& _this, const InputType& matrix, bool computeU) {
+    _this.m_matT = matrix;
+    runInPlace(_this, computeU);
+  }
+
+  void runInPlace(Schur& _this, bool computeU) {
+    hessenberg_decomposition_inplace(_this.m_matT, m_hCoeffs, m_workspace, _this.m_matU, computeU);
+  }
+
+  CoeffVectorType m_hCoeffs;
+  WorkspaceType m_workspace;
 };
 
 template <typename MatrixType>
 struct complex_schur_reduce_to_hessenberg<MatrixType, false> {
-  static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU) {
-    typedef typename ComplexSchur<MatrixType>::ComplexScalar ComplexScalar;
+  using Schur = ComplexSchur<MatrixType>;
+
+  explicit complex_schur_reduce_to_hessenberg(Index size) : m_hess(size) {}
+
+  template <typename InputType>
+  void run(Schur& _this, const InputType& matrix, bool computeU) {
+    using ComplexScalar = typename Schur::ComplexScalar;
 
     // Note: m_hess is over RealScalar; m_matT and m_matU is over ComplexScalar
-    _this.m_hess.compute(matrix);
-    _this.m_matT = _this.m_hess.matrixH().template cast<ComplexScalar>();
+    m_hess.compute(matrix);
+    _this.m_matT = m_hess.matrixH().template cast<ComplexScalar>();
     if (computeU) {
       // TODO: this temporary allocation could potentially be avoided.
-      MatrixType Q = _this.m_hess.matrixQ();
+      MatrixType Q = m_hess.matrixQ();
       _this.m_matU = Q.template cast<ComplexScalar>();
     }
   }
+
+  HessenbergDecomposition<MatrixType> m_hess;
 };
 
 }  // end namespace internal
diff --git a/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h b/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
index 5f66fd9..6a85f56 100644
--- a/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
+++ b/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
@@ -29,6 +29,7 @@
  *    Complex Schur needed to complex unsymmetrical eigenvalues/eigenvectors.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_COMPLEX_SCHUR_LAPACKE_H
 #define EIGEN_COMPLEX_SCHUR_LAPACKE_H
@@ -47,10 +48,6 @@
   inline ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >&                                              \
   ComplexSchur<Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> >::compute(const EigenBase<InputType>& matrix,         \
                                                                        bool computeU) {                            \
-    typedef Matrix<EIGTYPE, Dynamic, Dynamic, EIGCOLROW> MatrixType;                                               \
-    typedef MatrixType::RealScalar RealScalar;                                                                     \
-    typedef std::complex<RealScalar> ComplexScalar;                                                                \
-                                                                                                                   \
     eigen_assert(matrix.cols() == matrix.rows());                                                                  \
                                                                                                                    \
     m_matUisUptodate = false;                                                                                      \
@@ -90,6 +87,8 @@
 EIGEN_LAPACKE_SCHUR_COMPLEX(dcomplex, lapack_complex_double, z, Z, RowMajor, LAPACK_ROW_MAJOR)
 EIGEN_LAPACKE_SCHUR_COMPLEX(scomplex, lapack_complex_float, c, C, RowMajor, LAPACK_ROW_MAJOR)
 
+#undef EIGEN_LAPACKE_SCHUR_COMPLEX
+
 }  // end namespace Eigen
 
 #endif  // EIGEN_COMPLEX_SCHUR_LAPACKE_H
diff --git a/Eigen/src/Eigenvalues/EigenSolver.h b/Eigen/src/Eigenvalues/EigenSolver.h
index f439912..7aefd98 100644
--- a/Eigen/src/Eigenvalues/EigenSolver.h
+++ b/Eigen/src/Eigenvalues/EigenSolver.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_EIGENSOLVER_H
 #define EIGEN_EIGENSOLVER_H
@@ -68,20 +69,25 @@
 class EigenSolver {
  public:
   /** \brief Synonym for the template parameter \p MatrixType_. */
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
 
   /** \brief Scalar type for matrices of type #MatrixType. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
+
+  /** \brief Plain matrix type with the shape and storage options of #MatrixType; #MatrixType itself unless that
+   * is a Ref<>. It is the type of the real matrices returned by pseudoEigenvectors() and pseudoEigenvalueMatrix(). */
+  using PlainMatrixType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
 
   /** \brief Complex scalar type for #MatrixType.
    *
@@ -89,23 +95,22 @@
    * \c float or \c double) and just \c Scalar if #Scalar is
    * complex.
    */
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
 
   /** \brief Type for vector of eigenvalues as returned by eigenvalues().
    *
    * This is a column vector with entries of type #ComplexScalar.
    * The length of the vector is the size of #MatrixType.
    */
-  typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
+  using EigenvalueType = Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
 
   /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
    *
    * This is a square matrix with entries of type #ComplexScalar.
    * The size is the same as the size of #MatrixType.
    */
-  typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime,
-                 MaxColsAtCompileTime>
-      EigenvectorsType;
+  using EigenvectorsType =
+      Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
 
   /** \brief Default constructor.
    *
@@ -114,8 +119,7 @@
    *
    * \sa compute() for an example.
    */
-  EigenSolver()
-      : m_eivec(), m_eivalues(), m_isInitialized(false), m_eigenvectorsOk(false), m_realSchur(), m_matT(), m_tmp() {}
+  EigenSolver() : m_eivalues(), m_isInitialized(false), m_eigenvectorsOk(false), m_realSchur(), m_tmp() {}
 
   /** \brief Default constructor with memory preallocation
    *
@@ -124,13 +128,7 @@
    * \sa EigenSolver()
    */
   explicit EigenSolver(Index size)
-      : m_eivec(size, size),
-        m_eivalues(size),
-        m_isInitialized(false),
-        m_eigenvectorsOk(false),
-        m_realSchur(size),
-        m_matT(size, size),
-        m_tmp(size) {}
+      : m_eivalues(size), m_isInitialized(false), m_eigenvectorsOk(false), m_realSchur(size), m_tmp(size) {}
 
   /** \brief Constructor; computes eigendecomposition of given matrix.
    *
@@ -139,8 +137,8 @@
    *    eigenvalues are computed; if false, only the eigenvalues are
    *    computed.
    *
-   * This constructor calls compute() to compute the eigenvalues
-   * and eigenvectors.
+   * This constructor computes the eigenvalues and eigenvectors as compute()
+   * does.
    *
    * Example: \include EigenSolver_EigenSolver_MatrixType.cpp
    * Output: \verbinclude EigenSolver_EigenSolver_MatrixType.out
@@ -149,14 +147,35 @@
    */
   template <typename InputType>
   explicit EigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
-      : m_eivec(matrix.rows(), matrix.cols()),
-        m_eivalues(matrix.cols()),
+      : m_eivalues(matrix.cols()),
         m_isInitialized(false),
         m_eigenvectorsOk(false),
-        m_realSchur(matrix.cols()),
-        m_matT(matrix.rows(), matrix.cols()),
+        m_realSchur(matrix.derived(), computeEigenvectors),
         m_tmp(matrix.cols()) {
-    compute(matrix.derived(), computeEigenvectors);
+    check_template_parameters();
+    computeFromSchur(computeEigenvectors);
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix  Square matrix whose eigendecomposition is to be computed.
+   * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+   *    eigenvalues are computed; if false, only the eigenvalues are
+   *    computed.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p matrix, whose content is
+   * destroyed; the results are stored in the decomposition object. Otherwise this constructor behaves like
+   * EigenSolver(const EigenBase<InputType>&, bool).
+   */
+  template <typename InputType>
+  explicit EigenSolver(EigenBase<InputType>& matrix, bool computeEigenvectors = true)
+      : m_eivalues(matrix.cols()),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_realSchur(matrix.derived(), computeEigenvectors),
+        m_tmp(matrix.cols()) {
+    check_template_parameters();
+    computeFromSchur(computeEigenvectors);
   }
 
   /** \brief Returns the eigenvectors of given matrix.
@@ -199,10 +218,10 @@
    *
    * \sa pseudoEigenvalueMatrix(), eigenvectors()
    */
-  const MatrixType& pseudoEigenvectors() const {
+  const PlainMatrixType& pseudoEigenvectors() const {
     eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
-    return m_eivec;
+    return m_realSchur.m_matU;
   }
 
   /** \brief Returns the block-diagonal matrix in the pseudo-eigendecomposition.
@@ -223,7 +242,7 @@
    *
    * \sa pseudoEigenvectors() for an example, eigenvalues()
    */
-  MatrixType pseudoEigenvalueMatrix() const;
+  PlainMatrixType pseudoEigenvalueMatrix() const;
 
   /** \brief Returns the eigenvalues of given matrix.
    *
@@ -270,7 +289,7 @@
    * (where \f$ n \f$ is the size of the matrix) if \p computeEigenvectors
    * is true, and \f$ 10n^3 \f$ if \p computeEigenvectors is false.
    *
-   * This method reuses of the allocated data in the EigenSolver object.
+   * This method reuses the allocated data in the EigenSolver object.
    *
    * Example: \include EigenSolver_compute.cpp
    * Output: \verbinclude EigenSolver_compute.out
@@ -278,7 +297,8 @@
   template <typename InputType>
   EigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
 
-  /** \returns NumericalIssue if the input contains INF or NaN values or overflow occurred. Returns Success otherwise.
+  /** \returns NumericalIssue if the input contains INF or NaN values or overflow occurred, NoConvergence if the Schur
+   * decomposition did not converge within the maximum number of iterations, and Success otherwise.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
@@ -295,6 +315,7 @@
   Index getMaxIterations() const { return m_realSchur.getMaxIterations(); }
 
  private:
+  EigenSolver& computeFromSchur(bool computeEigenvectors);
   void doComputeEigenvectors();
 
  protected:
@@ -303,24 +324,24 @@
     EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
   }
 
-  MatrixType m_eivec;
   EigenvalueType m_eivalues;
   bool m_isInitialized;
   bool m_eigenvectorsOk;
   ComputationInfo m_info;
+  // Holds the Schur form T and U of the last matrix; computing the eigenvectors overwrites T with the eigenvectors
+  // of T and U with the pseudo-eigenvectors.
   RealSchur<MatrixType> m_realSchur;
-  MatrixType m_matT;
 
-  typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+  using ColumnVectorType = Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
   ColumnVectorType m_tmp;
 };
 
 template <typename MatrixType>
-MatrixType EigenSolver<MatrixType>::pseudoEigenvalueMatrix() const {
+typename EigenSolver<MatrixType>::PlainMatrixType EigenSolver<MatrixType>::pseudoEigenvalueMatrix() const {
   eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
   const RealScalar precision = RealScalar(2) * NumTraits<RealScalar>::epsilon();
   const Index n = m_eivalues.rows();
-  MatrixType matD = MatrixType::Zero(n, n);
+  PlainMatrixType matD = PlainMatrixType::Zero(n, n);
   Index i = 0;
   for (; i < n - 1; ++i) {
     RealScalar real = numext::real(m_eivalues.coeff(i));
@@ -345,19 +366,20 @@
   eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
   eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
   const RealScalar precision = RealScalar(2) * NumTraits<RealScalar>::epsilon();
-  Index n = m_eivec.cols();
+  const PlainMatrixType& eivec = m_realSchur.m_matU;
+  Index n = eivec.cols();
   EigenvectorsType matV(n, n);
   for (Index j = 0; j < n; ++j) {
     if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(j)), numext::real(m_eivalues.coeff(j)), precision) ||
         j + 1 == n) {
       // we have a real eigen value
-      matV.col(j) = m_eivec.col(j).template cast<ComplexScalar>();
+      matV.col(j) = eivec.col(j).template cast<ComplexScalar>();
       matV.col(j).normalize();
     } else {
       // we have a pair of complex eigen values
       for (Index i = 0; i < n; ++i) {
-        matV.coeffRef(i, j) = ComplexScalar(m_eivec.coeff(i, j), m_eivec.coeff(i, j + 1));
-        matV.coeffRef(i, j + 1) = ComplexScalar(m_eivec.coeff(i, j), -m_eivec.coeff(i, j + 1));
+        matV.coeffRef(i, j) = ComplexScalar(eivec.coeff(i, j), eivec.coeff(i, j + 1));
+        matV.coeffRef(i, j + 1) = ComplexScalar(eivec.coeff(i, j), -eivec.coeff(i, j + 1));
       }
       matV.col(j).normalize();
       matV.col(j + 1).normalize();
@@ -372,27 +394,31 @@
 EigenSolver<MatrixType>& EigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix,
                                                           bool computeEigenvectors) {
   check_template_parameters();
-
-  using numext::isfinite;
-  using std::abs;
-  using std::sqrt;
   eigen_assert(matrix.cols() == matrix.rows());
 
   // Reduce to real Schur form.
   m_realSchur.compute(matrix.derived(), computeEigenvectors);
+  return computeFromSchur(computeEigenvectors);
+}
+
+/** \internal Computes the eigenvalues, and the eigenvectors when requested, from the Schur decomposition held by
+ * m_realSchur. */
+template <typename MatrixType>
+EigenSolver<MatrixType>& EigenSolver<MatrixType>::computeFromSchur(bool computeEigenvectors) {
+  using numext::isfinite;
 
   m_info = m_realSchur.info();
 
   if (m_info == Success) {
-    m_matT = m_realSchur.matrixT();
-    if (computeEigenvectors) m_eivec = m_realSchur.matrixU();
+    const MatrixType& matT = m_realSchur.m_matT;
+    const Index n = matT.cols();
 
     // Compute eigenvalues from matT
-    m_eivalues.resize(matrix.cols());
+    m_eivalues.resize(n);
     Index i = 0;
-    while (i < matrix.cols()) {
-      if (i == matrix.cols() - 1 || m_matT.coeff(i + 1, i) == Scalar(0)) {
-        m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
+    while (i < n) {
+      if (i == n - 1 || matT.coeff(i + 1, i) == Scalar(0)) {
+        m_eivalues.coeffRef(i) = matT.coeff(i, i);
         if (!(isfinite)(m_eivalues.coeffRef(i))) {
           m_isInitialized = true;
           m_eigenvectorsOk = false;
@@ -401,22 +427,22 @@
         }
         ++i;
       } else {
-        Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i + 1, i + 1));
+        Scalar p = Scalar(0.5) * (matT.coeff(i, i) - matT.coeff(i + 1, i + 1));
         Scalar z;
-        // Compute z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
+        // Compute z = sqrt(abs(p * p + matT.coeff(i+1, i) * matT.coeff(i, i+1)));
         // without overflow
         {
-          Scalar t0 = m_matT.coeff(i + 1, i);
-          Scalar t1 = m_matT.coeff(i, i + 1);
-          Scalar maxval = numext::maxi<Scalar>(abs(p), numext::maxi<Scalar>(abs(t0), abs(t1)));
+          Scalar t0 = matT.coeff(i + 1, i);
+          Scalar t1 = matT.coeff(i, i + 1);
+          Scalar maxval = numext::maxi<Scalar>(numext::abs(p), numext::maxi<Scalar>(numext::abs(t0), numext::abs(t1)));
           t0 /= maxval;
           t1 /= maxval;
           Scalar p0 = p / maxval;
-          z = maxval * sqrt(abs(p0 * p0 + t0 * t1));
+          z = maxval * numext::sqrt(numext::abs(p0 * p0 + t0 * t1));
         }
 
-        m_eivalues.coeffRef(i) = ComplexScalar(m_matT.coeff(i + 1, i + 1) + p, z);
-        m_eivalues.coeffRef(i + 1) = ComplexScalar(m_matT.coeff(i + 1, i + 1) + p, -z);
+        m_eivalues.coeffRef(i) = ComplexScalar(matT.coeff(i + 1, i + 1) + p, z);
+        m_eivalues.coeffRef(i + 1) = ComplexScalar(matT.coeff(i + 1, i + 1) + p, -z);
         if (!((isfinite)(m_eivalues.coeffRef(i)) && (isfinite)(m_eivalues.coeffRef(i + 1)))) {
           m_isInitialized = true;
           m_eigenvectorsOk = false;
@@ -429,6 +455,9 @@
 
     // Compute eigenvectors.
     if (computeEigenvectors) doComputeEigenvectors();
+  } else if (!m_realSchur.m_matT.allFinite()) {
+    // RealSchur reports both nonfinite input and iteration exhaustion as NoConvergence.
+    m_info = NumericalIssue;
   }
 
   m_isInitialized = true;
@@ -439,15 +468,14 @@
 
 template <typename MatrixType>
 void EigenSolver<MatrixType>::doComputeEigenvectors() {
-  using std::abs;
-  const Index size = m_eivec.cols();
+  // Back-substitution stores the eigenvectors of T over T itself; the back-transformation then turns U into the
+  // pseudo-eigenvectors in place, column by column from the last one.
+  MatrixType& matT = m_realSchur.m_matT;
+  PlainMatrixType& eivec = m_realSchur.m_matU;
+  const Index size = eivec.cols();
   const Scalar eps = NumTraits<Scalar>::epsilon();
 
-  // inefficient! this is already computed in RealSchur
-  Scalar norm(0);
-  for (Index j = 0; j < size; ++j) {
-    norm += m_matT.row(j).segment((std::max)(j - 1, Index(0)), size - (std::max)(j - 1, Index(0))).cwiseAbs().sum();
-  }
+  const Scalar norm = internal::hessenberg_abs_sum<Upper>(matT);
 
   // Backsubstitute to find vectors of upper triangular form
   if (norm == Scalar(0)) {
@@ -463,10 +491,10 @@
       Scalar lastr(0), lastw(0);
       Index l = n;
 
-      m_matT.coeffRef(n, n) = Scalar(1);
+      matT.coeffRef(n, n) = Scalar(1);
       for (Index i = n - 1; i >= 0; i--) {
-        Scalar w = m_matT.coeff(i, i) - p;
-        Scalar r = m_matT.row(i).segment(l, n - l + 1).dot(m_matT.col(n).segment(l, n - l + 1));
+        Scalar w = matT.coeff(i, i) - p;
+        Scalar r = matT.row(i).segment(l, n - l + 1).dot(matT.col(n).segment(l, n - l + 1));
 
         if (m_eivalues.coeff(i).imag() < Scalar(0)) {
           lastw = w;
@@ -475,26 +503,26 @@
           l = i;
           if (m_eivalues.coeff(i).imag() == Scalar(0)) {
             if (w != Scalar(0))
-              m_matT.coeffRef(i, n) = -r / w;
+              matT.coeffRef(i, n) = -r / w;
             else
-              m_matT.coeffRef(i, n) = -r / (eps * norm);
+              matT.coeffRef(i, n) = -r / (eps * norm);
           } else  // Solve real equations
           {
-            Scalar x = m_matT.coeff(i, i + 1);
-            Scalar y = m_matT.coeff(i + 1, i);
+            Scalar x = matT.coeff(i, i + 1);
+            Scalar y = matT.coeff(i + 1, i);
             Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) +
                            m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
             Scalar t = (x * lastr - lastw * r) / denom;
-            m_matT.coeffRef(i, n) = t;
-            if (abs(x) > abs(lastw))
-              m_matT.coeffRef(i + 1, n) = (-r - w * t) / x;
+            matT.coeffRef(i, n) = t;
+            if (numext::abs(x) > numext::abs(lastw))
+              matT.coeffRef(i + 1, n) = (-r - w * t) / x;
             else
-              m_matT.coeffRef(i + 1, n) = (-lastr - y * t) / lastw;
+              matT.coeffRef(i + 1, n) = (-lastr - y * t) / lastw;
           }
 
           // Overflow control
-          Scalar t = abs(m_matT.coeff(i, n));
-          if ((eps * t) * t > Scalar(1)) m_matT.col(n).tail(size - i) /= t;
+          Scalar t = numext::abs(matT.coeff(i, n));
+          if ((eps * t) * t > Scalar(1)) matT.col(n).tail(size - i) /= t;
         }
       }
     } else if (q < Scalar(0) && n > 0)  // Complex vector
@@ -503,21 +531,21 @@
       Index l = n - 1;
 
       // Last vector component imaginary so matrix is triangular
-      if (abs(m_matT.coeff(n, n - 1)) > abs(m_matT.coeff(n - 1, n))) {
-        m_matT.coeffRef(n - 1, n - 1) = q / m_matT.coeff(n, n - 1);
-        m_matT.coeffRef(n - 1, n) = -(m_matT.coeff(n, n) - p) / m_matT.coeff(n, n - 1);
+      if (numext::abs(matT.coeff(n, n - 1)) > numext::abs(matT.coeff(n - 1, n))) {
+        matT.coeffRef(n - 1, n - 1) = q / matT.coeff(n, n - 1);
+        matT.coeffRef(n - 1, n) = -(matT.coeff(n, n) - p) / matT.coeff(n, n - 1);
       } else {
         ComplexScalar cc =
-            ComplexScalar(Scalar(0), -m_matT.coeff(n - 1, n)) / ComplexScalar(m_matT.coeff(n - 1, n - 1) - p, q);
-        m_matT.coeffRef(n - 1, n - 1) = numext::real(cc);
-        m_matT.coeffRef(n - 1, n) = numext::imag(cc);
+            ComplexScalar(Scalar(0), -matT.coeff(n - 1, n)) / ComplexScalar(matT.coeff(n - 1, n - 1) - p, q);
+        matT.coeffRef(n - 1, n - 1) = numext::real(cc);
+        matT.coeffRef(n - 1, n) = numext::imag(cc);
       }
-      m_matT.coeffRef(n, n - 1) = Scalar(0);
-      m_matT.coeffRef(n, n) = Scalar(1);
+      matT.coeffRef(n, n - 1) = Scalar(0);
+      matT.coeffRef(n, n) = Scalar(1);
       for (Index i = n - 2; i >= 0; i--) {
-        Scalar ra = m_matT.row(i).segment(l, n - l + 1).dot(m_matT.col(n - 1).segment(l, n - l + 1));
-        Scalar sa = m_matT.row(i).segment(l, n - l + 1).dot(m_matT.col(n).segment(l, n - l + 1));
-        Scalar w = m_matT.coeff(i, i) - p;
+        Scalar ra = matT.row(i).segment(l, n - l + 1).dot(matT.col(n - 1).segment(l, n - l + 1));
+        Scalar sa = matT.row(i).segment(l, n - l + 1).dot(matT.col(n).segment(l, n - l + 1));
+        Scalar w = matT.coeff(i, i) - p;
 
         if (m_eivalues.coeff(i).imag() < Scalar(0)) {
           lastw = w;
@@ -527,36 +555,37 @@
           l = i;
           if (m_eivalues.coeff(i).imag() == RealScalar(0)) {
             ComplexScalar cc = ComplexScalar(-ra, -sa) / ComplexScalar(w, q);
-            m_matT.coeffRef(i, n - 1) = numext::real(cc);
-            m_matT.coeffRef(i, n) = numext::imag(cc);
+            matT.coeffRef(i, n - 1) = numext::real(cc);
+            matT.coeffRef(i, n) = numext::imag(cc);
           } else {
             // Solve complex equations
-            Scalar x = m_matT.coeff(i, i + 1);
-            Scalar y = m_matT.coeff(i + 1, i);
+            Scalar x = matT.coeff(i, i + 1);
+            Scalar y = matT.coeff(i + 1, i);
             Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) +
                         m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
             Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
             if ((vr == Scalar(0)) && (vi == Scalar(0)))
-              vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));
+              vr =
+                  eps * norm * (numext::abs(w) + numext::abs(q) + numext::abs(x) + numext::abs(y) + numext::abs(lastw));
 
             ComplexScalar cc = ComplexScalar(x * lastra - lastw * ra + q * sa, x * lastsa - lastw * sa - q * ra) /
                                ComplexScalar(vr, vi);
-            m_matT.coeffRef(i, n - 1) = numext::real(cc);
-            m_matT.coeffRef(i, n) = numext::imag(cc);
-            if (abs(x) > (abs(lastw) + abs(q))) {
-              m_matT.coeffRef(i + 1, n - 1) = (-ra - w * m_matT.coeff(i, n - 1) + q * m_matT.coeff(i, n)) / x;
-              m_matT.coeffRef(i + 1, n) = (-sa - w * m_matT.coeff(i, n) - q * m_matT.coeff(i, n - 1)) / x;
+            matT.coeffRef(i, n - 1) = numext::real(cc);
+            matT.coeffRef(i, n) = numext::imag(cc);
+            if (numext::abs(x) > (numext::abs(lastw) + numext::abs(q))) {
+              matT.coeffRef(i + 1, n - 1) = (-ra - w * matT.coeff(i, n - 1) + q * matT.coeff(i, n)) / x;
+              matT.coeffRef(i + 1, n) = (-sa - w * matT.coeff(i, n) - q * matT.coeff(i, n - 1)) / x;
             } else {
-              cc = ComplexScalar(-lastra - y * m_matT.coeff(i, n - 1), -lastsa - y * m_matT.coeff(i, n)) /
+              cc = ComplexScalar(-lastra - y * matT.coeff(i, n - 1), -lastsa - y * matT.coeff(i, n)) /
                    ComplexScalar(lastw, q);
-              m_matT.coeffRef(i + 1, n - 1) = numext::real(cc);
-              m_matT.coeffRef(i + 1, n) = numext::imag(cc);
+              matT.coeffRef(i + 1, n - 1) = numext::real(cc);
+              matT.coeffRef(i + 1, n) = numext::imag(cc);
             }
           }
 
           // Overflow control
-          Scalar t = numext::maxi<Scalar>(abs(m_matT.coeff(i, n - 1)), abs(m_matT.coeff(i, n)));
-          if ((eps * t) * t > Scalar(1)) m_matT.block(i, n - 1, size - i, 2) /= t;
+          Scalar t = numext::maxi<Scalar>(numext::abs(matT.coeff(i, n - 1)), numext::abs(matT.coeff(i, n)));
+          if ((eps * t) * t > Scalar(1)) matT.block(i, n - 1, size - i, 2) /= t;
         }
       }
 
@@ -569,8 +598,8 @@
 
   // Back transformation to get eigenvectors of original matrix
   for (Index j = size - 1; j >= 0; j--) {
-    m_tmp.noalias() = m_eivec.leftCols(j + 1) * m_matT.col(j).segment(0, j + 1);
-    m_eivec.col(j) = m_tmp;
+    m_tmp.noalias() = eivec.leftCols(j + 1) * matT.col(j).segment(0, j + 1);
+    eivec.col(j) = m_tmp;
   }
 }
 
diff --git a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h b/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
index c0a61dc..00ba959 100644
--- a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
+++ b/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERALIZEDEIGENSOLVER_H
 #define EIGEN_GENERALIZEDEIGENSOLVER_H
@@ -62,20 +63,20 @@
 class GeneralizedEigenSolver {
  public:
   /** \brief Synonym for the template parameter \p MatrixType_. */
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
 
   /** \brief Scalar type for matrices of type #MatrixType. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
   /** \brief Complex scalar type for #MatrixType.
    *
@@ -83,35 +84,34 @@
    * \c float or \c double) and just \c Scalar if #Scalar is
    * complex.
    */
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
 
   /** \brief Type for vector of real scalar values eigenvalues as returned by betas().
    *
    * This is a column vector with entries of type #Scalar.
    * The length of the vector is the size of #MatrixType.
    */
-  typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> VectorType;
+  using VectorType = Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
 
   /** \brief Type for vector of complex scalar values eigenvalues as returned by alphas().
    *
    * This is a column vector with entries of type #ComplexScalar.
    * The length of the vector is the size of #MatrixType.
    */
-  typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ComplexVectorType;
+  using ComplexVectorType = Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
 
   /** \brief Expression type for the eigenvalues as returned by eigenvalues().
    */
-  typedef CwiseBinaryOp<internal::scalar_quotient_op<ComplexScalar, Scalar>, ComplexVectorType, VectorType>
-      EigenvalueType;
+  using EigenvalueType =
+      CwiseBinaryOp<internal::scalar_quotient_op<ComplexScalar, Scalar>, ComplexVectorType, VectorType>;
 
   /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
    *
    * This is a square matrix with entries of type #ComplexScalar.
    * The size is the same as the size of #MatrixType.
    */
-  typedef Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime,
-                 MaxColsAtCompileTime>
-      EigenvectorsType;
+  using EigenvectorsType =
+      Matrix<ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
 
   /** \brief Default constructor.
    *
@@ -145,20 +145,45 @@
    * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
    *    eigenvalues are computed; if false, only the eigenvalues are computed.
    *
-   * This constructor calls compute() to compute the generalized eigenvalues
-   * and eigenvectors.
+   * This constructor computes the generalized eigenvalues and eigenvectors
+   * as compute() does.
    *
    * \sa compute()
    */
-  GeneralizedEigenSolver(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true)
+  template <typename InputTypeA, typename InputTypeB>
+  GeneralizedEigenSolver(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B,
+                         bool computeEigenvectors = true)
       : m_eivec(A.rows(), A.cols()),
         m_alphas(A.cols()),
         m_betas(A.cols()),
         m_computeEigenvectors(false),
         m_isInitialized(false),
-        m_realQZ(A.cols()),
+        m_realQZ(A.derived(), B.derived(), computeEigenvectors),
         m_tmp(A.cols()) {
-    compute(A, B, computeEigenvectors);
+    computeFromQZ(computeEigenvectors);
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  A  Square matrix whose eigendecomposition is to be computed.
+   * \param[in,out]  B  Square matrix whose eigendecomposition is to be computed.
+   * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
+   *    eigenvalues are computed; if false, only the eigenvalues are computed.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p A and \p B, whose
+   * contents are destroyed; the results are stored in the decomposition object. Otherwise this constructor behaves
+   * like GeneralizedEigenSolver(const EigenBase<InputTypeA>&, const EigenBase<InputTypeB>&, bool).
+   */
+  template <typename InputTypeA, typename InputTypeB>
+  GeneralizedEigenSolver(EigenBase<InputTypeA>& A, EigenBase<InputTypeB>& B, bool computeEigenvectors = true)
+      : m_eivec(A.rows(), A.cols()),
+        m_alphas(A.cols()),
+        m_betas(A.cols()),
+        m_computeEigenvectors(false),
+        m_isInitialized(false),
+        m_realQZ(A.derived(), B.derived(), computeEigenvectors),
+        m_tmp(A.cols()) {
+    computeFromQZ(computeEigenvectors);
   }
 
   /** \brief Returns the computed generalized eigenvectors.
@@ -184,7 +209,7 @@
    * \returns An expression of the column vector containing the eigenvalues.
    *
    * It is a shortcut for \code this->alphas().cwiseQuotient(this->betas()); \endcode
-   * Not that betas might contain zeros. It is therefore not recommended to use this function,
+   * Note that betas might contain zeros. It is therefore not recommended to use this function,
    * but rather directly deal with the alphas and betas vectors.
    *
    * \pre Either the constructor
@@ -243,9 +268,11 @@
    * The cost of the computation is dominated by the cost of the
    * generalized Schur decomposition.
    *
-   * This method reuses of the allocated data in the GeneralizedEigenSolver object.
+   * This method reuses the allocated data in the GeneralizedEigenSolver object.
    */
-  GeneralizedEigenSolver& compute(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true);
+  template <typename InputTypeA, typename InputTypeB>
+  GeneralizedEigenSolver& compute(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B,
+                                  bool computeEigenvectors = true);
 
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
@@ -270,19 +297,28 @@
   bool m_isInitialized;
   RealQZ<MatrixType> m_realQZ;
   ComplexVectorType m_tmp;
+
+ private:
+  GeneralizedEigenSolver& computeFromQZ(bool computeEigenvectors);
 };
 
 template <typename MatrixType>
-GeneralizedEigenSolver<MatrixType>& GeneralizedEigenSolver<MatrixType>::compute(const MatrixType& A,
-                                                                                const MatrixType& B,
+template <typename InputTypeA, typename InputTypeB>
+GeneralizedEigenSolver<MatrixType>& GeneralizedEigenSolver<MatrixType>::compute(const EigenBase<InputTypeA>& A,
+                                                                                const EigenBase<InputTypeB>& B,
                                                                                 bool computeEigenvectors) {
-  using std::abs;
-  using std::sqrt;
   eigen_assert(A.cols() == A.rows() && B.cols() == A.rows() && B.cols() == B.rows());
-  Index size = A.cols();
   // Reduce to generalized real Schur form:
   // A = Q S Z and B = Q T Z
-  m_realQZ.compute(A, B, computeEigenvectors);
+  m_realQZ.compute(A.derived(), B.derived(), computeEigenvectors);
+  return computeFromQZ(computeEigenvectors);
+}
+
+/** \internal Computes the generalized eigenvalues, and the eigenvectors when requested, from the QZ decomposition
+ * held by m_realQZ. */
+template <typename MatrixType>
+GeneralizedEigenSolver<MatrixType>& GeneralizedEigenSolver<MatrixType>::computeFromQZ(bool computeEigenvectors) {
+  const Index size = m_realQZ.matrixS().cols();
   if (m_realQZ.info() == Success) {
     // Resize storage
     m_alphas.resize(size);
@@ -308,7 +344,7 @@
           v.setConstant(Scalar(0.0));
           v.coeffRef(i) = Scalar(1.0);
           // For singular eigenvalues do nothing more
-          if (abs(m_betas.coeffRef(i)) >= (std::numeric_limits<RealScalar>::min)()) {
+          if (numext::abs(m_betas.coeffRef(i)) >= (std::numeric_limits<RealScalar>::min)()) {
             // Non-singular eigenvalue
             const Scalar alpha = real(m_alphas.coeffRef(i));
             const Scalar beta = m_betas.coeffRef(i);
@@ -352,7 +388,7 @@
         Matrix<RealScalar, 2, 2> S2 = mS.template block<2, 2>(i, i) * Matrix<Scalar, 2, 1>(b, a).asDiagonal();
 
         Scalar p = Scalar(0.5) * (S2.coeff(0, 0) - S2.coeff(1, 1));
-        Scalar z = sqrt(abs(p * p + S2.coeff(1, 0) * S2.coeff(0, 1)));
+        Scalar z = numext::sqrt(numext::abs(p * p + S2.coeff(1, 0) * S2.coeff(0, 1)));
         const ComplexScalar alpha = ComplexScalar(S2.coeff(1, 1) + p, (beta > 0) ? z : -z);
         m_alphas.coeffRef(i) = conj(alpha);
         m_alphas.coeffRef(i + 1) = alpha;
@@ -361,7 +397,7 @@
           // Compute eigenvector in position (i+1) and then position (i) is just the conjugate
           cv.setZero();
           cv.coeffRef(i + 1) = Scalar(1.0);
-          // here, the "static_cast" workaround expression template issues.
+          // here, the "static_cast" works around expression template issues.
           cv.coeffRef(i) = -(static_cast<Scalar>(beta * mS.coeffRef(i, i + 1)) - alpha * mT.coeffRef(i, i + 1)) /
                            (static_cast<Scalar>(beta * mS.coeffRef(i, i)) - alpha * mT.coeffRef(i, i));
           for (Index j = i - 1; j >= 0; j--) {
@@ -384,7 +420,7 @@
                                (alpha * mT.coeffRef(j, j) - static_cast<Scalar>(beta * mS.coeffRef(j, j)));
             }
           }
-          m_eivec.col(i + 1).noalias() = (m_realQZ.matrixZ().transpose() * cv);
+          m_eivec.col(i + 1).noalias() = m_realQZ.matrixZ().transpose() * cv;
           m_eivec.col(i + 1).normalize();
           m_eivec.col(i) = m_eivec.col(i + 1).conjugate();
         }
diff --git a/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h b/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
index adff3a3..4b951ce 100644
--- a/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
+++ b/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
 #define EIGEN_GENERALIZEDSELFADJOINTEIGENSOLVER_H
@@ -49,10 +50,10 @@
  */
 template <typename MatrixType_>
 class GeneralizedSelfAdjointEigenSolver : public SelfAdjointEigenSolver<MatrixType_> {
-  typedef SelfAdjointEigenSolver<MatrixType_> Base;
+  using Base = SelfAdjointEigenSolver<MatrixType_>;
 
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 
   /** \brief Default constructor for fixed-size matrices.
    *
@@ -61,7 +62,7 @@
    * can only be used if \p MatrixType_ is a fixed-size matrix; use
    * GeneralizedSelfAdjointEigenSolver(Index) for dynamic-size matrices.
    */
-  GeneralizedSelfAdjointEigenSolver() : Base() {}
+  GeneralizedSelfAdjointEigenSolver() : Base(), m_cholB(), m_matC() {}
 
   /** \brief Constructor, pre-allocates memory for dynamic-size matrices.
    *
@@ -75,7 +76,7 @@
    *
    * \sa compute() for an example
    */
-  explicit GeneralizedSelfAdjointEigenSolver(Index size) : Base(size) {}
+  explicit GeneralizedSelfAdjointEigenSolver(Index size) : Base(size), m_cholB(size), m_matC(size, size) {}
 
   /** \brief Constructor; computes generalized eigendecomposition of given matrix pencil.
    *
@@ -91,7 +92,8 @@
    * generalized eigenproblem \f$ Ax = \lambda B x \f$ with \a matA the
    * selfadjoint matrix \f$ A \f$ and \a matB the positive definite matrix
    * \f$ B \f$. Each eigenvector \f$ x \f$ satisfies the property
-   * \f$ x^* B x = 1 \f$. The eigenvectors are computed if
+   * \f$ x^* B x = 1 \f$ for \c Ax_lBx and \c ABx_lx, and the property
+   * \f$ x^* B^{-1} x = 1 \f$ for \c BAx_lx. The eigenvectors are computed if
    * \a options contains ComputeEigenvectors.
    *
    * In addition, the two following variants can be solved via \p options:
@@ -103,10 +105,35 @@
    *
    * \sa compute(const MatrixType&, const MatrixType&, int)
    */
-  GeneralizedSelfAdjointEigenSolver(const MatrixType& matA, const MatrixType& matB,
+  template <typename InputTypeA, typename InputTypeB>
+  GeneralizedSelfAdjointEigenSolver(const EigenBase<InputTypeA>& matA, const EigenBase<InputTypeB>& matB,
                                     int options = ComputeEigenvectors | Ax_lBx)
       : Base(matA.cols()) {
-    compute(matA, matB, options);
+    compute(matA.derived(), matB.derived(), options);
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matA  Selfadjoint matrix in matrix pencil.
+   *                       Only the lower triangular part of the matrix is referenced.
+   * \param[in,out]  matB  Positive-definite matrix in matrix pencil.
+   *                       Only the lower triangular part of the matrix is referenced.
+   * \param[in]  options A or-ed set of flags {#ComputeEigenvectors,#EigenvaluesOnly} | {#Ax_lBx,#ABx_lx,#BAx_lx}.
+   *                     Default is #ComputeEigenvectors|#Ax_lBx.
+   *
+   * This constructor is only available when \p MatrixType is a Ref<>. The decomposition is then computed within
+   * the memory of \p matA and \p matB: \p matB receives the Cholesky factor of B and \p matA the transformed
+   * matrix C, then, with #ComputeEigenvectors, the eigenvectors, which eigenvectors() refers to. The forms
+   * #ABx_lx and #BAx_lx allocate one temporary of the size of \p matA for the products that cannot run in place.
+   */
+  template <typename InputTypeA, typename InputTypeB, bool IsRef = internal::is_ref<MatrixType>::value,
+            std::enable_if_t<IsRef, int> = 0>
+  GeneralizedSelfAdjointEigenSolver(EigenBase<InputTypeA>& matA, EigenBase<InputTypeB>& matB,
+                                    int options = ComputeEigenvectors | Ax_lBx)
+      : Base(matA, typename Base::BindStorageTag()), m_cholB(matB.derived()), m_matC(matA.derived()) {
+    // Complete the upper triangle from the referenced lower one.
+    m_matC = m_matC.template selfadjointView<Lower>();
+    computeInPlace(options);
   }
 
   /** \brief Computes generalized eigendecomposition of given matrix pencil.
@@ -127,7 +154,9 @@
    * - \c BAx_lx: \f$ BAx = \lambda x \f$
    * with \a matA the selfadjoint matrix \f$ A \f$ and \a matB the positive definite
    * matrix \f$ B \f$.
-   * In addition, each eigenvector \f$ x \f$ satisfies the property \f$ x^* B x = 1 \f$.
+   * In addition, each eigenvector \f$ x \f$ satisfies the property \f$ x^* B x = 1 \f$ for \c Ax_lBx and \c ABx_lx.
+   * For \c BAx_lx, the eigenvectors are instead normalized such that \f$ x^* B^{-1} x = 1 \f$, following the same
+   * convention as LAPACK's \c ?sygv with \c itype=3.
    *
    * The eigenvalues() function can be used to retrieve
    * the eigenvalues. If \p options contains ComputeEigenvectors, then the
@@ -149,16 +178,38 @@
    *
    * \sa GeneralizedSelfAdjointEigenSolver(const MatrixType&, const MatrixType&, int)
    */
-  GeneralizedSelfAdjointEigenSolver& compute(const MatrixType& matA, const MatrixType& matB,
+  template <typename InputTypeA, typename InputTypeB>
+  GeneralizedSelfAdjointEigenSolver& compute(const EigenBase<InputTypeA>& matA, const EigenBase<InputTypeB>& matB,
                                              int options = ComputeEigenvectors | Ax_lBx);
 
  protected:
+  // Reused across compute() calls so that a solver constructed with its size,
+  // or computed with once, does not allocate again.
+  LLT<MatrixType> m_cholB;
+  MatrixType m_matC;
+
+ private:
+  GeneralizedSelfAdjointEigenSolver& computeInPlace(int options);
 };
 
 template <typename MatrixType>
+template <typename InputTypeA, typename InputTypeB>
 GeneralizedSelfAdjointEigenSolver<MatrixType>& GeneralizedSelfAdjointEigenSolver<MatrixType>::compute(
-    const MatrixType& matA, const MatrixType& matB, int options) {
+    const EigenBase<InputTypeA>& matA, const EigenBase<InputTypeB>& matB, int options) {
   eigen_assert(matA.cols() == matA.rows() && matB.rows() == matA.rows() && matB.cols() == matB.rows());
+
+  // Compute the cholesky decomposition of matB = L L' = U'U
+  m_cholB.compute(matB.derived());
+  m_matC = matA.derived().template selfadjointView<Lower>();
+  return computeInPlace(options);
+}
+
+/** \internal Computes the generalized eigendecomposition from the Cholesky factor of B held by m_cholB and the
+ * selfadjoint matrix A held in full by m_matC, which is overwritten by the transformed matrix C. */
+template <typename MatrixType>
+GeneralizedSelfAdjointEigenSolver<MatrixType>& GeneralizedSelfAdjointEigenSolver<MatrixType>::computeInPlace(
+    int options) {
+  eigen_assert(m_matC.cols() == m_matC.rows() && m_cholB.rows() == m_matC.rows());
   eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
                ((options & GenEigMask) == 0 || (options & GenEigMask) == Ax_lBx || (options & GenEigMask) == ABx_lx ||
                 (options & GenEigMask) == BAx_lx) &&
@@ -166,42 +217,59 @@
 
   bool computeEigVecs = ((options & EigVecMask) == 0) || ((options & EigVecMask) == ComputeEigenvectors);
 
-  // Compute the cholesky decomposition of matB = L L' = U'U
-  LLT<MatrixType> cholB(matB);
-
   int type = (options & GenEigMask);
   if (type == 0) type = Ax_lBx;
 
+  // In the inplace decomposition the eigenvector storage is the matrix A itself, i.e. m_matC: the products of the
+  // ABx_lx and BAx_lx forms, which cannot run in place, then go through a temporary instead.
+  const bool eivecIsMatC = internal::is_same_dense(Base::m_eivec, m_matC);
+
   if (type == Ax_lBx) {
     // compute C = inv(L) A inv(L')
-    MatrixType matC = matA.template selfadjointView<Lower>();
-    cholB.matrixL().template solveInPlace<OnTheLeft>(matC);
-    cholB.matrixU().template solveInPlace<OnTheRight>(matC);
+    m_cholB.matrixL().template solveInPlace<OnTheLeft>(m_matC);
+    m_cholB.matrixU().template solveInPlace<OnTheRight>(m_matC);
 
-    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+    Base::compute(m_matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
 
     // transform back the eigen vectors: evecs = inv(U) * evecs
-    if (computeEigVecs) cholB.matrixU().solveInPlace(Base::m_eivec);
+    if (computeEigVecs) m_cholB.matrixU().solveInPlace(Base::m_eivec);
   } else if (type == ABx_lx) {
-    // compute C = L' A L
-    MatrixType matC = matA.template selfadjointView<Lower>();
-    matC = matC * cholB.matrixL();
-    matC = cholB.matrixU() * matC;
+    // compute C = L' A L, using Base::m_eivec for the intermediate product: Base::compute()
+    // overwrites it before reading it.
+    if (eivecIsMatC) {
+      typename Base::PlainMatrixType tmp = m_matC * m_cholB.matrixL();
+      m_matC.noalias() = m_cholB.matrixU() * tmp;
+    } else {
+      Base::m_eivec.noalias() = m_matC * m_cholB.matrixL();
+      m_matC.noalias() = m_cholB.matrixU() * Base::m_eivec;
+    }
 
-    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+    Base::compute(m_matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
 
     // transform back the eigen vectors: evecs = inv(U) * evecs
-    if (computeEigVecs) cholB.matrixU().solveInPlace(Base::m_eivec);
+    if (computeEigVecs) m_cholB.matrixU().solveInPlace(Base::m_eivec);
   } else if (type == BAx_lx) {
     // compute C = L' A L
-    MatrixType matC = matA.template selfadjointView<Lower>();
-    matC = matC * cholB.matrixL();
-    matC = cholB.matrixU() * matC;
+    if (eivecIsMatC) {
+      typename Base::PlainMatrixType tmp = m_matC * m_cholB.matrixL();
+      m_matC.noalias() = m_cholB.matrixU() * tmp;
+    } else {
+      Base::m_eivec.noalias() = m_matC * m_cholB.matrixL();
+      m_matC.noalias() = m_cholB.matrixU() * Base::m_eivec;
+    }
 
-    Base::compute(matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
+    Base::compute(m_matC, computeEigVecs ? ComputeEigenvectors : EigenvaluesOnly);
 
-    // transform back the eigen vectors: evecs = L * evecs
-    if (computeEigVecs) Base::m_eivec = cholB.matrixL() * Base::m_eivec;
+    // transform back the eigen vectors: evecs = L * evecs, using m_matC as the
+    // intermediate: Base::compute() has consumed it.
+    if (computeEigVecs) {
+      if (eivecIsMatC) {
+        Base::m_eivec = m_cholB.matrixL() * Base::m_eivec;
+      } else {
+        m_matC.noalias() = m_cholB.matrixL() * Base::m_eivec;
+        Base::m_eivec = m_matC;
+      }
+    }
   }
 
   return *this;
diff --git a/Eigen/src/Eigenvalues/HessenbergDecomposition.h b/Eigen/src/Eigenvalues/HessenbergDecomposition.h
index 42fe3fd..c0d792a 100644
--- a/Eigen/src/Eigenvalues/HessenbergDecomposition.h
+++ b/Eigen/src/Eigenvalues/HessenbergDecomposition.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HESSENBERGDECOMPOSITION_H
 #define EIGEN_HESSENBERGDECOMPOSITION_H
@@ -22,9 +23,12 @@
 struct HessenbergDecompositionMatrixHReturnType;
 template <typename MatrixType>
 struct traits<HessenbergDecompositionMatrixHReturnType<MatrixType>> {
-  typedef MatrixType ReturnType;
+  using ReturnType = typename MatrixType::PlainObject;
 };
 
+template <typename MatrixType, typename CoeffVectorType, typename WorkspaceType>
+void hessenberg_decomposition_inplace(MatrixType& matA, CoeffVectorType& hCoeffs, WorkspaceType& temp);
+
 }  // namespace internal
 
 /** \eigenvalues_module \ingroup Eigenvalues_Module
@@ -61,33 +65,33 @@
 class HessenbergDecomposition {
  public:
   /** \brief Synonym for the template parameter \p MatrixType_. */
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 
   enum {
     Size = MatrixType::RowsAtCompileTime,
     SizeMinusOne = Size == Dynamic ? Dynamic : Size - 1,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxSize = MatrixType::MaxRowsAtCompileTime,
     MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : MaxSize - 1
   };
 
   /** \brief Scalar type for matrices of type #MatrixType. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
   /** \brief Type for vector of Householder coefficients.
    *
    * This is column vector with entries of type #Scalar. The length of the
-   * vector is one less than the size of #MatrixType, if it is a fixed-side
+   * vector is one less than the size of #MatrixType, if it is a fixed-size
    * type.
    */
-  typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
+  using CoeffVectorType = Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1>;
 
   /** \brief Return type of matrixQ() */
-  typedef HouseholderSequence<MatrixType, internal::remove_all_t<typename CoeffVectorType::ConjugateReturnType>>
-      HouseholderSequenceType;
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, internal::remove_all_t<typename CoeffVectorType::ConjugateReturnType>>;
 
-  typedef internal::HessenbergDecompositionMatrixHReturnType<MatrixType> MatrixHReturnType;
+  using MatrixHReturnType = internal::HessenbergDecompositionMatrixHReturnType<MatrixType>;
 
   /** \brief Default constructor; the decomposition will be computed later.
    *
@@ -117,13 +121,21 @@
   template <typename InputType>
   explicit HessenbergDecomposition(const EigenBase<InputType>& matrix)
       : m_matrix(matrix.derived()), m_temp(matrix.rows()), m_isInitialized(false) {
-    if (matrix.rows() < 2) {
-      m_isInitialized = true;
-      return;
-    }
-    m_hCoeffs.resize(matrix.rows() - 1, 1);
-    _compute(m_matrix, m_hCoeffs, m_temp);
-    m_isInitialized = true;
+    computeInPlace();
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix  Square matrix whose Hessenberg decomposition is to be computed.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p matrix, which then holds
+   * the packed representation returned by packedMatrix(). Otherwise this constructor behaves like
+   * HessenbergDecomposition(const EigenBase<InputType>&).
+   */
+  template <typename InputType>
+  explicit HessenbergDecomposition(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()), m_temp(matrix.rows()), m_isInitialized(false) {
+    computeInPlace();
   }
 
   /** \brief Computes Hessenberg decomposition of given matrix.
@@ -137,7 +149,7 @@
    * Computations</i>). The cost is \f$ 10n^3/3 \f$ flops, where \f$ n \f$
    * denotes the size of the given matrix.
    *
-   * This method reuses of the allocated data in the HessenbergDecomposition
+   * This method reuses the allocated data in the HessenbergDecomposition
    * object.
    *
    * Example: \include HessenbergDecomposition_compute.cpp
@@ -146,13 +158,7 @@
   template <typename InputType>
   HessenbergDecomposition& compute(const EigenBase<InputType>& matrix) {
     m_matrix = matrix.derived();
-    if (matrix.rows() < 2) {
-      m_isInitialized = true;
-      return *this;
-    }
-    m_hCoeffs.resize(matrix.rows() - 1, 1);
-    _compute(m_matrix, m_hCoeffs, m_temp);
-    m_isInitialized = true;
+    computeInPlace();
     return *this;
   }
 
@@ -253,9 +259,18 @@
   }
 
  private:
-  typedef Matrix<Scalar, 1, Size, int(Options) | int(RowMajor), 1, MaxSize> VectorType;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  static void _compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp);
+  using VectorType = Matrix<Scalar, 1, Size, int(Options) | int(RowMajor), 1, MaxSize>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  void computeInPlace() {
+    if (m_matrix.rows() < 2) {
+      m_isInitialized = true;
+      return;
+    }
+    m_hCoeffs.resize(m_matrix.rows() - 1, 1);
+    internal::hessenberg_decomposition_inplace(m_matrix, m_hCoeffs, m_temp);
+    m_isInitialized = true;
+  }
 
  protected:
   MatrixType m_matrix;
@@ -264,20 +279,27 @@
   bool m_isInitialized;
 };
 
+namespace internal {
+
 /** \internal
- * Performs a tridiagonal decomposition of \a matA in place.
+ * Performs a Hessenberg decomposition of \a matA in place.
  *
- * \param matA the input selfadjoint matrix
+ * \param matA the input square matrix
  * \param hCoeffs returned Householder coefficients
+ * \param temp workspace of at least matA.rows() coefficients
  *
- * The result is written in the lower triangular part of \a matA.
+ * The result is written in the whole of \a matA: the upper part, including
+ * the subdiagonal, holds the Hessenberg matrix H, while the part strictly
+ * below the subdiagonal holds the Householder vectors.
  *
- * Implemented from Golub's "%Matrix Computations", algorithm 8.3.1.
+ * Implemented from Golub's "%Matrix Computations", algorithm 7.4.2.
  *
- * \sa packedMatrix()
+ * \sa HessenbergDecomposition::packedMatrix()
  */
-template <typename MatrixType>
-void HessenbergDecomposition<MatrixType>::_compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp) {
+template <typename MatrixType, typename CoeffVectorType, typename WorkspaceType>
+void hessenberg_decomposition_inplace(MatrixType& matA, CoeffVectorType& hCoeffs, WorkspaceType& temp) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   eigen_assert(matA.rows() == matA.cols());
   Index n = matA.rows();
   temp.resize(n);
@@ -286,7 +308,19 @@
     Index remainingSize = n - i - 1;
     RealScalar beta;
     Scalar h;
-    matA.col(i).tail(remainingSize).makeHouseholderInPlace(h, beta);
+    auto householder = matA.col(i).tail(remainingSize);
+    const RealScalar tailSqNorm =
+        remainingSize == 1 ? RealScalar(0) : householder.tail(remainingSize - 1).unwind().squaredNorm();
+    const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+    // Preserve negligible subdiagonal entries instead of rotating them into much larger matrix coefficients.  The
+    // latter can erase small eigenvalues through cancellation even though the reflector itself is accurate.
+    if (tailSqNorm <= tol && numext::abs2(numext::imag(householder.coeff(0))) <= tol) {
+      h = Scalar(0);
+      beta = numext::real(householder.coeff(0));
+      householder.tail(remainingSize - 1).setZero();
+    } else {
+      householder.makeHouseholderInPlace(h, beta);
+    }
     matA.col(i).coeffRef(i + 1) = beta;
     hCoeffs.coeffRef(i) = h;
 
@@ -303,7 +337,38 @@
   }
 }
 
-namespace internal {
+/** \internal
+ * Reduces \a matA in place to the Hessenberg matrix H of \f$ A = Q H Q^* \f$.
+ *
+ * \param matA the input square matrix, overwritten by H
+ * \param hCoeffs returned Householder coefficients
+ * \param temp workspace of at least matA.rows() coefficients
+ * \param matQ returned unitary matrix Q, if \a computeQ is true
+ * \param computeQ whether to compute Q
+ *
+ * Unlike the packed form above, \a matA holds only H afterwards: Q is formed from the Householder vectors below the
+ * subdiagonal before they are cleared.
+ */
+template <typename MatrixType, typename CoeffVectorType, typename WorkspaceType, typename MatrixQType>
+void hessenberg_decomposition_inplace(MatrixType& matA, CoeffVectorType& hCoeffs, WorkspaceType& temp,
+                                      MatrixQType& matQ, bool computeQ) {
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, remove_all_t<typename CoeffVectorType::ConjugateReturnType>>;
+  const Index n = matA.rows();
+  hCoeffs.resize(n - 1);
+  hessenberg_decomposition_inplace(matA, hCoeffs, temp);
+  if (computeQ) {
+    Index firstReflector = 0;
+    while (firstReflector < n - 1 && numext::is_exactly_zero(hCoeffs.coeff(firstReflector))) ++firstReflector;
+    if (firstReflector == n - 1) {
+      // All tau_i = 0: Q = I, without allocating block Householder factors.
+      matQ.setIdentity(n, n);
+    } else {
+      HouseholderSequenceType(matA, hCoeffs.conjugate()).setLength(n - 1).setShift(1).evalTo(matQ, temp);
+    }
+  }
+  if (n > 2) matA.bottomLeftCorner(n - 2, n - 2).template triangularView<Lower>().setZero();
+}
 
 /** \eigenvalues_module \ingroup Eigenvalues_Module
  *
@@ -314,7 +379,7 @@
  *
  * Objects of this type represent the Hessenberg matrix in the Hessenberg
  * decomposition of some matrix. The object holds a reference to the
- * HessenbergDecomposition class until the it is assigned or evaluated for
+ * HessenbergDecomposition class until it is assigned or evaluated for
  * some other reason (the reference should remain valid during the life time
  * of this object). This class is the return type of
  * HessenbergDecomposition::matrixH(); there is no other intended use for this
diff --git a/Eigen/src/Eigenvalues/InternalHeaderCheck.h b/Eigen/src/Eigenvalues/InternalHeaderCheck.h
index 374cbd4..6ca5ce8 100644
--- a/Eigen/src/Eigenvalues/InternalHeaderCheck.h
+++ b/Eigen/src/Eigenvalues/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_EIGENVALUES_MODULE_H
 #error "Please include Eigen/Eigenvalues instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h b/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
index 38f46f8..b452692 100644
--- a/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
+++ b/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MATRIXBASEEIGENVALUES_H
 #define EIGEN_MATRIXBASEEIGENVALUES_H
@@ -22,7 +23,7 @@
 struct eigenvalues_selector {
   // this is the implementation for the case IsComplex = true
   static inline typename MatrixBase<Derived>::EigenvaluesReturnType const run(const MatrixBase<Derived>& m) {
-    typedef typename Derived::PlainObject PlainObject;
+    using PlainObject = typename Derived::PlainObject;
     PlainObject m_eval(m);
     return ComplexEigenSolver<PlainObject>(m_eval, false).eigenvalues();
   }
@@ -31,7 +32,7 @@
 template <typename Derived>
 struct eigenvalues_selector<Derived, false> {
   static inline typename MatrixBase<Derived>::EigenvaluesReturnType const run(const MatrixBase<Derived>& m) {
-    typedef typename Derived::PlainObject PlainObject;
+    using PlainObject = typename Derived::PlainObject;
     PlainObject m_eval(m);
     return EigenSolver<PlainObject>(m_eval, false).eigenvalues();
   }
diff --git a/Eigen/src/Eigenvalues/RealQZ.h b/Eigen/src/Eigenvalues/RealQZ.h
index a54d82d..e5cd1f1 100644
--- a/Eigen/src/Eigenvalues/RealQZ.h
+++ b/Eigen/src/Eigenvalues/RealQZ.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REAL_QZ_H
 #define EIGEN_REAL_QZ_H
@@ -26,9 +27,9 @@
  * real QZ decomposition; this is expected to be an instantiation of the
  * Matrix class template.
  *
- * Given a real square matrices A and B, this class computes the real QZ
+ * Given real square matrices A and B, this class computes the real QZ
  * decomposition: \f$ A = Q S Z \f$, \f$ B = Q T Z \f$ where Q and Z are
- * real orthogonal matrixes, T is upper-triangular matrix, and S is upper
+ * real orthogonal matrices, T is upper-triangular matrix, and S is upper
  * quasi-triangular matrix. An orthogonal matrix is a matrix whose
  * inverse is equal to its transpose, \f$ U^{-1} = U^T \f$. A quasi-triangular
  * matrix is a block-triangular matrix whose diagonal consists of 1-by-1
@@ -40,7 +41,7 @@
  *
  * Call the function compute() to compute the real QZ decomposition of a
  * given pair of matrices. Alternatively, you can use the
- * RealQZ(const MatrixType& B, const MatrixType& B, bool computeQZ)
+ * RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ)
  * constructor which computes the real QZ decomposition at construction
  * time. Once the decomposition is computed, you can use the matrixS(),
  * matrixT(), matrixQ() and matrixZ() functions to retrieve the matrices
@@ -60,20 +61,25 @@
 template <typename MatrixType_>
 class RealQZ {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
-  typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
-  typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+  using EigenvalueType = Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
+  using ColumnVectorType = Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
+
+  /** \brief Type of the matrices returned by matrixQ() and matrixZ(): a plain matrix with the shape and storage
+   * options of \p MatrixType_, and \p MatrixType_ itself unless that is a Ref<>. */
+  using PlainMatrixType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
 
   /** \brief Default constructor.
    *
@@ -92,6 +98,7 @@
         m_Q(size, size),
         m_Z(size, size),
         m_workspace(size * 2),
+        m_hCoeffs(size),
         m_maxIters(400),
         m_isInitialized(false),
         m_computeQZ(true) {}
@@ -100,27 +107,53 @@
    *
    * \param[in]  A          Matrix A.
    * \param[in]  B          Matrix B.
-   * \param[in]  computeQZ  If false, A and Z are not computed.
+   * \param[in]  computeQZ  If false, Q and Z are not computed.
    *
-   * This constructor calls compute() to compute the QZ decomposition.
+   * This constructor computes the QZ decomposition as compute() does.
    */
-  RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true)
-      : m_S(A.rows(), A.cols()),
-        m_T(A.rows(), A.cols()),
+  template <typename InputTypeA, typename InputTypeB>
+  RealQZ(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B, bool computeQZ = true)
+      : m_S(A.derived()),
+        m_T(B.derived()),
         m_Q(A.rows(), A.cols()),
         m_Z(A.rows(), A.cols()),
         m_workspace(A.rows() * 2),
+        m_hCoeffs(A.rows()),
         m_maxIters(400),
         m_isInitialized(false),
         m_computeQZ(true) {
-    compute(A, B, computeQZ);
+    computeInPlace(computeQZ);
+  }
+
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  A          Matrix A.
+   * \param[in,out]  B          Matrix B.
+   * \param[in]      computeQZ  If false, Q and Z are not computed.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p A and \p B, which then
+   * hold S and T; Q and Z are stored in the decomposition object. Otherwise this constructor behaves like
+   * RealQZ(const EigenBase<InputTypeA>&, const EigenBase<InputTypeB>&, bool).
+   */
+  template <typename InputTypeA, typename InputTypeB>
+  RealQZ(EigenBase<InputTypeA>& A, EigenBase<InputTypeB>& B, bool computeQZ = true)
+      : m_S(A.derived()),
+        m_T(B.derived()),
+        m_Q(A.rows(), A.cols()),
+        m_Z(A.rows(), A.cols()),
+        m_workspace(A.rows() * 2),
+        m_hCoeffs(A.rows()),
+        m_maxIters(400),
+        m_isInitialized(false),
+        m_computeQZ(true) {
+    computeInPlace(computeQZ);
   }
 
   /** \brief Returns matrix Q in the QZ decomposition.
    *
    * \returns A const reference to the matrix Q.
    */
-  const MatrixType& matrixQ() const {
+  const PlainMatrixType& matrixQ() const {
     eigen_assert(m_isInitialized && "RealQZ is not initialized.");
     eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
     return m_Q;
@@ -130,7 +163,7 @@
    *
    * \returns A const reference to the matrix Z.
    */
-  const MatrixType& matrixZ() const {
+  const PlainMatrixType& matrixZ() const {
     eigen_assert(m_isInitialized && "RealQZ is not initialized.");
     eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
     return m_Z;
@@ -158,10 +191,11 @@
    *
    * \param[in]  A          Matrix A.
    * \param[in]  B          Matrix B.
-   * \param[in]  computeQZ  If false, A and Z are not computed.
+   * \param[in]  computeQZ  If false, Q and Z are not computed.
    * \returns    Reference to \c *this
    */
-  RealQZ& compute(const MatrixType& A, const MatrixType& B, bool computeQZ = true);
+  template <typename InputTypeA, typename InputTypeB>
+  RealQZ& compute(const EigenBase<InputTypeA>& A, const EigenBase<InputTypeB>& B, bool computeQZ = true);
 
   /** \brief Reports whether previous computation was successful.
    *
@@ -188,8 +222,10 @@
   }
 
  private:
-  MatrixType m_S, m_T, m_Q, m_Z;
+  MatrixType m_S, m_T;
+  PlainMatrixType m_Q, m_Z;
   Matrix<Scalar, Dynamic, 1> m_workspace;
+  ColumnVectorType m_hCoeffs;
   ComputationInfo m_info;
   Index m_maxIters;
   bool m_isInitialized;
@@ -197,11 +233,12 @@
   Scalar m_normOfT, m_normOfS;
   Index m_global_iter;
 
-  typedef Matrix<Scalar, 3, 1> Vector3s;
-  typedef Matrix<Scalar, 2, 1> Vector2s;
-  typedef Matrix<Scalar, 2, 2> Matrix2s;
-  typedef JacobiRotation<Scalar> JRs;
+  using Vector3s = Matrix<Scalar, 3, 1>;
+  using Vector2s = Matrix<Scalar, 2, 1>;
+  using Matrix2s = Matrix<Scalar, 2, 2>;
+  using JRs = JacobiRotation<Scalar>;
 
+  RealQZ& computeInPlace(bool computeQZ);
   void hessenbergTriangular();
   void computeNorms();
   Index findSmallSubdiagEntry(Index iu);
@@ -217,15 +254,17 @@
 void RealQZ<MatrixType>::hessenbergTriangular() {
   const Index dim = m_S.cols();
 
-  // perform QR decomposition of T, overwrite T with R, save Q
-  HouseholderQR<MatrixType> qrT(m_T);
-  m_T = qrT.matrixQR();
+  // perform QR decomposition of T in place: T holds R above the Householder vectors Q is formed from
+  m_hCoeffs.resize(dim);
+  internal::householder_qr_inplace_blocked<MatrixType, ColumnVectorType>::run(m_T, m_hCoeffs, 48, m_workspace.data());
+  Map<ColumnVectorType> workspace(m_workspace.data(), dim);
+  householderSequence(m_T, m_hCoeffs.conjugate()).evalTo(m_Q, workspace);
   m_T.template triangularView<StrictlyLower>().setZero();
-  m_Q = qrT.householderQ();
-  // overwrite S with Q* S
-  m_S.applyOnTheLeft(m_Q.adjoint());
+  // Z is unused until it is initialized below, so it can hold Q* S without aliasing S.
+  m_Z.noalias() = m_Q.adjoint() * m_S;
+  m_S.swap(m_Z);
   // init Z as Identity
-  if (m_computeQZ) m_Z = MatrixType::Identity(dim, dim);
+  if (m_computeQZ) m_Z = PlainMatrixType::Identity(dim, dim);
   // reduce S to upper Hessenberg with Givens rotations
   for (Index j = 0; j <= dim - 3; j++) {
     for (Index i = dim - 1; i >= j + 2; i--) {
@@ -255,13 +294,8 @@
 /** \internal Computes vector L1 norms of S and T when in Hessenberg-Triangular form already */
 template <typename MatrixType>
 inline void RealQZ<MatrixType>::computeNorms() {
-  const Index size = m_S.cols();
-  m_normOfS = Scalar(0.0);
-  m_normOfT = Scalar(0.0);
-  for (Index j = 0; j < size; ++j) {
-    m_normOfS += m_S.col(j).segment(0, (std::min)(size, j + 2)).cwiseAbs().sum();
-    m_normOfT += m_T.row(j).segment(j, size - j).cwiseAbs().sum();
-  }
+  m_normOfS = internal::hessenberg_abs_sum<Upper>(m_S);
+  m_normOfT = internal::triangular_abs_sum<Upper>(m_T);
 }
 
 /** \internal Look for single small sub-diagonal element S(res, res-1) and return res (or 0) */
@@ -454,7 +488,7 @@
       m_S.col(k + 2).head(lr) -= tau * tmp;
       m_S.template middleCols<2>(k).topRows(lr).noalias() -= (tau * tmp) * essential2.adjoint();
       // T
-      tmp = m_T.template middleCols<2>(k).topRows(lr) * essential2;
+      tmp.noalias() = m_T.template middleCols<2>(k).topRows(lr) * essential2;
       tmp += m_T.col(k + 2).head(lr);
       m_T.col(k + 2).head(lr) -= tau * tmp;
       m_T.template middleCols<2>(k).topRows(lr).noalias() -= (tau * tmp) * essential2.adjoint();
@@ -499,16 +533,26 @@
 }
 
 template <typename MatrixType>
-RealQZ<MatrixType>& RealQZ<MatrixType>::compute(const MatrixType& A_in, const MatrixType& B_in, bool computeQZ) {
-  const Index dim = A_in.cols();
+template <typename InputTypeA, typename InputTypeB>
+RealQZ<MatrixType>& RealQZ<MatrixType>::compute(const EigenBase<InputTypeA>& A_in, const EigenBase<InputTypeB>& B_in,
+                                                bool computeQZ) {
+  eigen_assert(A_in.rows() == A_in.cols() && B_in.rows() == A_in.cols() && B_in.cols() == A_in.cols() &&
+               "Need square matrices of the same dimension");
+  m_S = A_in.derived();
+  m_T = B_in.derived();
+  return computeInPlace(computeQZ);
+}
 
-  eigen_assert(A_in.rows() == dim && A_in.cols() == dim && B_in.rows() == dim && B_in.cols() == dim &&
+/** \internal Computes the QZ decomposition of the pencil held in (m_S, m_T), which are overwritten by S and T. */
+template <typename MatrixType>
+RealQZ<MatrixType>& RealQZ<MatrixType>::computeInPlace(bool computeQZ) {
+  const Index dim = m_S.cols();
+
+  eigen_assert(m_S.rows() == dim && m_T.rows() == dim && m_T.cols() == dim &&
                "Need square matrices of the same dimension");
 
   m_isInitialized = true;
   m_computeQZ = computeQZ;
-  m_S = A_in;
-  m_T = B_in;
   m_workspace.resize(dim * 2);
   m_global_iter = 0;
 
@@ -540,13 +584,15 @@
         // zero found
         pushDownZero(z, f, l);
       } else {
-        // We are sure now that S.block(f,f, l-f+1,l-f+1) is underuced upper-Hessenberg
-        // and T.block(f,f, l-f+1,l-f+1) is invertible uper-triangular, which allows to
+        // We are sure now that S.block(f,f, l-f+1,l-f+1) is unreduced upper-Hessenberg
+        // and T.block(f,f, l-f+1,l-f+1) is invertible upper-triangular, which allows to
         // apply a QR-like iteration to rows and columns f..l.
         step(f, l, local_iter);
-        local_iter++;
+        // count QR-like steps
         m_global_iter++;
       }
+      // count iterations toward m_maxIters
+      local_iter++;
     }
   }
   // check if we converged before reaching iterations limit
@@ -579,9 +625,14 @@
     }
   }
 
+  // The QZ sweep restores T's triangularity only up to rounding, so its strictly lower triangle
+  // can retain entries of order eps*||T||. matrixT() is documented upper triangular; make it so,
+  // as the deflation above already does for the subdiagonal of S.
+  m_T.template triangularView<StrictlyLower>().setZero();
+
   return *this;
 }  // end compute
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_REAL_QZ
+#endif  // EIGEN_REAL_QZ_H
diff --git a/Eigen/src/Eigenvalues/RealSchur.h b/Eigen/src/Eigenvalues/RealSchur.h
index 6e50a43..0493dde 100644
--- a/Eigen/src/Eigenvalues/RealSchur.h
+++ b/Eigen/src/Eigenvalues/RealSchur.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_REAL_SCHUR_H
 #define EIGEN_REAL_SCHUR_H
@@ -18,6 +19,9 @@
 
 namespace Eigen {
 
+template <typename MatrixType_>
+class EigenSolver;
+
 /** \eigenvalues_module \ingroup Eigenvalues_Module
  *
  *
@@ -57,20 +61,25 @@
 template <typename MatrixType_>
 class RealSchur {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
-  typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
-  typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
+  using EigenvalueType = Matrix<ComplexScalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
+  using ColumnVectorType = Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1>;
+
+  /** \brief Type of the matrix returned by matrixU(): a plain matrix with the shape and storage options of
+   * \p MatrixType_, and \p MatrixType_ itself unless that is a Ref<>. */
+  using MatrixUType =
+      Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime>;
 
   /** \brief Default constructor.
    *
@@ -87,10 +96,11 @@
       : m_matT(size, size),
         m_matU(size, size),
         m_workspaceVector(size),
-        m_hess(size),
         m_isInitialized(false),
         m_matUisUptodate(false),
-        m_maxIters(-1) {}
+        m_maxIters(-1) {
+    if (size > 1) m_hCoeffs.resize(size - 1);
+  }
 
   /** \brief Constructor; computes real Schur decomposition of given matrix.
    *
@@ -107,13 +117,40 @@
       : m_matT(matrix.rows(), matrix.cols()),
         m_matU(matrix.rows(), matrix.cols()),
         m_workspaceVector(matrix.rows()),
-        m_hess(matrix.rows()),
         m_isInitialized(false),
         m_matUisUptodate(false),
         m_maxIters(-1) {
     compute(matrix.derived(), computeU);
   }
 
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix    Square matrix whose Schur decomposition is to be computed.
+   * \param[in]      computeU  If true, both T and U are computed; if false, only T is computed.
+   *
+   * When \p MatrixType is a Ref<>, \p matrix holds the quasi-triangular matrix T returned by matrixT(); U is stored
+   * in the decomposition object. For an n-by-n matrix with n >= 128 and an outer stride in bytes divisible by 1024,
+   * the computation uses a temporary padded workspace of n*(n+1) coefficients and copies T back to \p matrix.
+   * Otherwise, it computes directly in the bound storage.
+   *
+   * To avoid padding, bind a Ref<> whose outer stride in bytes is not divisible by 1024. EIGEN_NO_MALLOC, or
+   * disabling allocation or deallocation through EIGEN_RUNTIME_NO_MALLOC, also suppresses padding, which may
+   * reduce performance. These controls do not remove other allocations, such as solver storage or Schur vectors;
+   * the inplace constructor is not guaranteed to be allocation-free.
+   *
+   * This overload is only available for Ref<>; owning matrix types use the constructor taking a const input.
+   */
+  template <typename InputType, bool IsRef = internal::is_ref<MatrixType>::value, std::enable_if_t<IsRef, int> = 0>
+  explicit RealSchur(EigenBase<InputType>& matrix, bool computeU = true)
+      : m_matT(matrix.derived()),
+        m_matU(matrix.rows(), matrix.cols()),
+        m_workspaceVector(matrix.rows()),
+        m_isInitialized(false),
+        m_matUisUptodate(false),
+        m_maxIters(-1) {
+    compute(m_matT, computeU);
+  }
+
   /** \brief Returns the orthogonal matrix in the Schur decomposition.
    *
    * \returns A const reference to the matrix U.
@@ -125,7 +162,7 @@
    *
    * \sa RealSchur(const MatrixType&, bool) for an example
    */
-  const MatrixType& matrixU() const {
+  const MatrixUType& matrixU() const {
     eigen_assert(m_isInitialized && "RealSchur is not initialized.");
     eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the RealSchur decomposition.");
     return m_matU;
@@ -160,6 +197,11 @@
    * may be taken to be \f$25n^3\f$ flops if \a computeU is true and
    * \f$10n^3\f$ flops if \a computeU is false.
    *
+   * To avoid cache-conflicting strides, this routine may allocate a temporary padded workspace even when
+   * the solver was constructed with the correct size. With EIGEN_NO_MALLOC, or when allocation or deallocation
+   * is disabled through EIGEN_RUNTIME_NO_MALLOC, it uses the unpadded workspace instead, which may be slower.
+   * This only suppresses padding; resizing solver storage and constructing Schur vectors may still allocate.
+   *
    * Example: \include RealSchur_compute.cpp
    * Output: \verbinclude RealSchur_compute.out
    *
@@ -170,8 +212,8 @@
 
   /** \brief Computes Schur decomposition of a Hessenberg matrix H = Z T Z^T
    *  \param[in] matrixH Matrix in Hessenberg form H
-   *  \param[in] matrixQ orthogonal matrix Q that transform a matrix A to H : A = Q H Q^T
-   *  \param computeU Computes the matriX U of the Schur vectors
+   *  \param[in] matrixQ orthogonal matrix Q that transforms a matrix A to H : A = Q H Q^T
+   *  \param computeU Computes the matrix U of the Schur vectors
    * \return Reference to \c *this
    *
    *  This routine assumes that the matrix is already reduced in Hessenberg form matrixH
@@ -183,6 +225,11 @@
    * NOTE Q is referenced if computeU is true; so, if the initial orthogonal matrix
    * is not available, the user should give an identity matrix (Q.setIdentity())
    *
+   * This routine may allocate a temporary padded workspace to avoid cache-conflicting strides. With EIGEN_NO_MALLOC,
+   * or when allocation or deallocation is disabled through EIGEN_RUNTIME_NO_MALLOC, it uses the unpadded workspace
+   * instead, which may be slower. Other allocations, such as resizing solver storage or evaluating input
+   * expressions, are unaffected.
+   *
    * \sa compute(const MatrixType&, bool)
    */
   template <typename HessMatrixType, typename OrthMatrixType>
@@ -217,56 +264,117 @@
   static const int m_maxIterationsPerRow = 40;
 
  private:
+  // EigenSolver computes the eigenvectors of T and back-transforms U within this storage.
+  friend class EigenSolver<MatrixType>;
+
+  using CoeffVectorType =
+      Matrix<Scalar, RowsAtCompileTime == Dynamic ? Dynamic : RowsAtCompileTime - 1, 1, Options & ~RowMajor,
+             MaxRowsAtCompileTime == Dynamic ? Dynamic : MaxRowsAtCompileTime - 1, 1>;
+
   MatrixType m_matT;
-  MatrixType m_matU;
+  MatrixUType m_matU;
   ColumnVectorType m_workspaceVector;
-  HessenbergDecomposition<MatrixType> m_hess;
+  CoeffVectorType m_hCoeffs;
   ComputationInfo m_info;
   bool m_isInitialized;
   bool m_matUisUptodate;
   Index m_maxIters;
 
-  typedef Matrix<Scalar, 3, 1> Vector3s;
+  template <typename TMatrix>
+  EIGEN_DONT_INLINE RealSchur& computeFromHessenbergInPlace(TMatrix& matT, bool computeU);
+  using Vector3s = Matrix<Scalar, 3, 1>;
 
-  Scalar computeNormOfT();
-  Index findSmallSubdiagEntry(Index iu, const Scalar& considerAsZero);
-  void splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift);
-  void computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo);
-  void initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im, Vector3s& firstHouseholderVector);
-  void performFrancisQRStep(Index il, Index im, Index iu, bool computeU, const Vector3s& firstHouseholderVector,
-                            Scalar* workspace);
+  using WorkspaceMatrix = Matrix<Scalar, Dynamic, Dynamic, MatrixType::IsRowMajor ? RowMajor : ColMajor>;
+
+  bool usePaddedWorkspace(Index size) const;
+  template <typename TMatrix>
+  RealSchur& computeInPlace(TMatrix& matT, bool computeU);
+  template <typename TMatrix>
+  Scalar computeNormOfT(TMatrix& matT);
+  template <typename TMatrix>
+  Index findSmallSubdiagEntry(TMatrix& matT, Index iu, const Scalar& considerAsZero);
+  template <typename TMatrix>
+  void splitOffTwoRows(TMatrix& matT, Index iu, bool computeU, const Scalar& exshift);
+  template <typename TMatrix>
+  void computeShift(TMatrix& matT, Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo);
+  template <typename TMatrix>
+  void initFrancisQRStep(TMatrix& matT, Index il, Index iu, const Vector3s& shiftInfo, Index& im,
+                         Vector3s& firstHouseholderVector);
+  template <typename TMatrix>
+  void performFrancisQRStep(TMatrix& matT, Index il, Index im, Index iu, bool computeU,
+                            const Vector3s& firstHouseholderVector, Scalar* workspace);
 };
 
 template <typename MatrixType>
 template <typename InputType>
 RealSchur<MatrixType>& RealSchur<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeU) {
-  const Scalar considerAsZero = (std::numeric_limits<Scalar>::min)();
-
   eigen_assert(matrix.cols() == matrix.rows());
-  Index maxIters = m_maxIters;
-  if (maxIters == -1) maxIters = m_maxIterationsPerRow * matrix.rows();
+  const Index size = matrix.rows();
+  if (usePaddedWorkspace(size)) {
+    WorkspaceMatrix storage(size + (MatrixType::IsRowMajor ? 0 : 1), size + (MatrixType::IsRowMajor ? 1 : 0));
+    auto matT = storage.topLeftCorner(size, size);
+    matT = matrix.derived();
+    computeInPlace(matT, computeU);
+  } else {
+    if (!internal::is_same_dense(m_matT, matrix.derived())) m_matT = matrix.derived();
+    computeInPlace(m_matT, computeU);
+  }
+  return *this;
+}
 
-  Scalar scale = matrix.derived().cwiseAbs().maxCoeff();
-  if (scale < considerAsZero) {
-    m_matT.setZero(matrix.rows(), matrix.cols());
-    if (computeU) m_matU.setIdentity(matrix.rows(), matrix.cols());
+template <typename MatrixType>
+bool RealSchur<MatrixType>::usePaddedWorkspace(Index size) const {
+  // Short reflectors traverse the outer dimension. Strides divisible by 1 KiB concentrate those accesses in
+  // very few cache sets. A Ref may already have a suitable stride; owning matrices resize to size-by-size.
+  const Index stride = internal::is_ref<MatrixType>::value ? m_matT.outerStride() : size;
+  bool usePadding = size >= 128 && (stride * sizeof(Scalar)) % 1024 == 0;
+#ifdef EIGEN_NO_MALLOC
+  usePadding = false;
+#elif defined(EIGEN_RUNTIME_NO_MALLOC)
+  usePadding = usePadding && internal::is_malloc_allowed() && internal::is_free_allowed();
+#endif
+  return usePadding;
+}
+
+/** \internal Reduces matT in place and writes the rescaled Schur form to m_matT. */
+template <typename MatrixType>
+template <typename TMatrix>
+RealSchur<MatrixType>& RealSchur<MatrixType>::computeInPlace(TMatrix& matT, bool computeU) {
+  const Scalar considerAsZero = (std::numeric_limits<Scalar>::min)();
+  const Index n = matT.rows();
+  eigen_assert(matT.cols() == n);
+
+  const Scalar maxCoeff = matT.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(maxCoeff)) {
+    if (!internal::is_same_dense(m_matT, matT)) m_matT = matT;
+    m_info = NoConvergence;
+    m_isInitialized = true;
+    m_matUisUptodate = false;
+    return *this;
+  }
+  if (maxCoeff < considerAsZero) {
+    // Ref has no setZero(rows, cols) overload.
+    m_matT.resize(n, n);
+    m_matT.setZero();
+    if (computeU) m_matU.setIdentity(n, n);
     m_info = Success;
     m_isInitialized = true;
     m_matUisUptodate = computeU;
     return *this;
   }
+  const auto factors = internal::safe_scaling<Scalar>::scale_in_place(matT, maxCoeff);
 
   // Step 1. Reduce to Hessenberg form
-  m_hess.compute(matrix.derived() / scale);
+  internal::hessenberg_decomposition_inplace(matT, m_hCoeffs, m_workspaceVector, m_matU, computeU);
 
   // Step 2. Reduce to real Schur form
-  // Note: we copy m_hess.matrixQ() into m_matU here and not in computeFromHessenberg
-  //       to be able to pass our working-space buffer for the Householder to Dense evaluation.
-  m_workspaceVector.resize(matrix.cols());
-  if (computeU) m_hess.matrixQ().evalTo(m_matU, m_workspaceVector);
-  computeFromHessenberg(m_hess.matrixH(), m_matU, computeU);
+  computeFromHessenbergInPlace(matT, computeU);
 
-  m_matT *= scale;
+  // Keep aliasing explicit for the compiler on the in-place path.
+  if (internal::is_same_dense(m_matT, matT))
+    internal::safe_scaling<Scalar>::unscale_in_place(matT, maxCoeff, factors);
+  else
+    internal::safe_scaling<Scalar>::unscale_to(m_matT, matT, maxCoeff, factors);
 
   return *this;
 }
@@ -274,25 +382,39 @@
 template <typename HessMatrixType, typename OrthMatrixType>
 RealSchur<MatrixType>& RealSchur<MatrixType>::computeFromHessenberg(const HessMatrixType& matrixH,
                                                                     const OrthMatrixType& matrixQ, bool computeU) {
-  using std::abs;
+  const Index size = matrixH.rows();
+  m_workspaceVector.resize(size);
+  if (usePaddedWorkspace(size)) {
+    WorkspaceMatrix storage(size + (MatrixType::IsRowMajor ? 0 : 1), size + (MatrixType::IsRowMajor ? 1 : 0));
+    auto matT = storage.topLeftCorner(size, size);
+    matT = matrixH;
+    if (computeU && !internal::is_same_dense(m_matU, matrixQ)) m_matU = matrixQ;
+    computeFromHessenbergInPlace(matT, computeU);
+    m_matT = matT;
+  } else {
+    if (!internal::is_same_dense(m_matT, matrixH)) m_matT = matrixH;
+    if (computeU && !internal::is_same_dense(m_matU, matrixQ)) m_matU = matrixQ;
+    computeFromHessenbergInPlace(m_matT, computeU);
+  }
+  return *this;
+}
 
-  m_matT = matrixH;
-  m_workspaceVector.resize(m_matT.cols());
-  if (computeU && !internal::is_same_dense(m_matU, matrixQ)) m_matU = matrixQ;
-
+template <typename MatrixType>
+template <typename TMatrix>
+RealSchur<MatrixType>& RealSchur<MatrixType>::computeFromHessenbergInPlace(TMatrix& matT, bool computeU) {
   Index maxIters = m_maxIters;
-  if (maxIters == -1) maxIters = m_maxIterationsPerRow * matrixH.rows();
+  if (maxIters == -1) maxIters = m_maxIterationsPerRow * matT.rows();
   Scalar* workspace = &m_workspaceVector.coeffRef(0);
 
-  // The matrix m_matT is divided in three parts.
-  // Rows 0,...,il-1 are decoupled from the rest because m_matT(il,il-1) is zero.
+  // The matrix matT is divided in three parts.
+  // Rows 0,...,il-1 are decoupled from the rest because matT(il,il-1) is zero.
   // Rows il,...,iu is the part we are working on (the active window).
   // Rows iu+1,...,end are already brought in triangular form.
-  Index iu = m_matT.cols() - 1;
+  Index iu = matT.cols() - 1;
   Index iter = 0;       // iteration count for current eigenvalue
   Index totalIter = 0;  // iteration count for whole matrix
   Scalar exshift(0);    // sum of exceptional shifts
-  Scalar norm = computeNormOfT();
+  Scalar norm = computeNormOfT(matT);
   // sub-diagonal entries smaller than considerAsZero will be treated as zero.
   // We use eps^2 to enable more precision in small eigenvalues.
   Scalar considerAsZero =
@@ -300,18 +422,18 @@
 
   if (!numext::is_exactly_zero(norm)) {
     while (iu >= 0) {
-      Index il = findSmallSubdiagEntry(iu, considerAsZero);
+      Index il = findSmallSubdiagEntry(matT, iu, considerAsZero);
 
       // Check for convergence
       if (il == iu)  // One root found
       {
-        m_matT.coeffRef(iu, iu) = m_matT.coeff(iu, iu) + exshift;
-        if (iu > 0) m_matT.coeffRef(iu, iu - 1) = Scalar(0);
+        matT.coeffRef(iu, iu) = matT.coeff(iu, iu) + exshift;
+        if (iu > 0) matT.coeffRef(iu, iu - 1) = Scalar(0);
         iu--;
         iter = 0;
       } else if (il == iu - 1)  // Two roots found
       {
-        splitOffTwoRows(iu, computeU, exshift);
+        splitOffTwoRows(matT, iu, computeU, exshift);
         iu -= 2;
         iter = 0;
       } else  // No convergence yet
@@ -319,13 +441,13 @@
         // The firstHouseholderVector vector has to be initialized to something to get rid of a silly GCC warning (-O1
         // -Wall -DNDEBUG )
         Vector3s firstHouseholderVector = Vector3s::Zero(), shiftInfo;
-        computeShift(iu, iter, exshift, shiftInfo);
+        computeShift(matT, iu, iter, exshift, shiftInfo);
         iter = iter + 1;
         totalIter = totalIter + 1;
         if (totalIter > maxIters) break;
         Index im;
-        initFrancisQRStep(il, iu, shiftInfo, im, firstHouseholderVector);
-        performFrancisQRStep(il, im, iu, computeU, firstHouseholderVector, workspace);
+        initFrancisQRStep(matT, il, iu, shiftInfo, im, firstHouseholderVector);
+        performFrancisQRStep(matT, il, im, iu, computeU, firstHouseholderVector, workspace);
       }
     }
   }
@@ -341,27 +463,23 @@
 
 /** \internal Computes and returns vector L1 norm of T */
 template <typename MatrixType>
-inline typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT() {
-  const Index size = m_matT.cols();
-  // FIXME: a triangular reduction would be more efficient here.
-  // Scalar norm = m_matT.upper().cwiseAbs().sum()
-  //               + m_matT.bottomLeftCorner(size-1,size-1).diagonal().cwiseAbs().sum();
-  Scalar norm(0);
-  for (Index j = 0; j < size; ++j) norm += m_matT.col(j).segment(0, (std::min)(size, j + 2)).cwiseAbs().sum();
-  return norm;
+template <typename TMatrix>
+inline typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT(TMatrix& matT) {
+  return internal::hessenberg_abs_sum<Upper>(matT);
 }
 
 /** \internal Look for single small sub-diagonal element and returns its index */
 template <typename MatrixType>
-inline Index RealSchur<MatrixType>::findSmallSubdiagEntry(Index iu, const Scalar& considerAsZero) {
+template <typename TMatrix>
+inline Index RealSchur<MatrixType>::findSmallSubdiagEntry(TMatrix& matT, Index iu, const Scalar& considerAsZero) {
   using std::abs;
   Index res = iu;
   while (res > 0) {
-    Scalar s = abs(m_matT.coeff(res - 1, res - 1)) + abs(m_matT.coeff(res, res));
+    Scalar s = abs(matT.coeff(res - 1, res - 1)) + abs(matT.coeff(res, res));
 
     s = numext::maxi<Scalar>(s * NumTraits<Scalar>::epsilon(), considerAsZero);
 
-    if (abs(m_matT.coeff(res, res - 1)) <= s) break;
+    if (abs(matT.coeff(res, res - 1)) <= s) break;
     res--;
   }
   return res;
@@ -369,52 +487,55 @@
 
 /** \internal Update T given that rows iu-1 and iu decouple from the rest. */
 template <typename MatrixType>
-inline void RealSchur<MatrixType>::splitOffTwoRows(Index iu, bool computeU, const Scalar& exshift) {
+template <typename TMatrix>
+inline void RealSchur<MatrixType>::splitOffTwoRows(TMatrix& matT, Index iu, bool computeU, const Scalar& exshift) {
   using std::abs;
   using std::sqrt;
-  const Index size = m_matT.cols();
+  const Index size = matT.cols();
 
   // The eigenvalues of the 2x2 matrix [a b; c d] are
   // trace +/- sqrt(discr/4) where discr = tr^2 - 4*det, tr = a + d, det = ad - bc
-  Scalar p = Scalar(0.5) * (m_matT.coeff(iu - 1, iu - 1) - m_matT.coeff(iu, iu));
-  Scalar q = p * p + m_matT.coeff(iu, iu - 1) * m_matT.coeff(iu - 1, iu);  // q = tr^2 / 4 - det = discr/4
-  m_matT.coeffRef(iu, iu) += exshift;
-  m_matT.coeffRef(iu - 1, iu - 1) += exshift;
+  Scalar p = Scalar(0.5) * (matT.coeff(iu - 1, iu - 1) - matT.coeff(iu, iu));
+  Scalar q = p * p + matT.coeff(iu, iu - 1) * matT.coeff(iu - 1, iu);  // q = tr^2 / 4 - det = discr/4
+  matT.coeffRef(iu, iu) += exshift;
+  matT.coeffRef(iu - 1, iu - 1) += exshift;
 
   if (q >= Scalar(0))  // Two real eigenvalues
   {
     Scalar z = sqrt(abs(q));
     JacobiRotation<Scalar> rot;
     if (p >= Scalar(0))
-      rot.makeGivens(p + z, m_matT.coeff(iu, iu - 1));
+      rot.makeGivens(p + z, matT.coeff(iu, iu - 1));
     else
-      rot.makeGivens(p - z, m_matT.coeff(iu, iu - 1));
+      rot.makeGivens(p - z, matT.coeff(iu, iu - 1));
 
-    m_matT.rightCols(size - iu + 1).applyOnTheLeft(iu - 1, iu, rot.adjoint());
-    m_matT.topRows(iu + 1).applyOnTheRight(iu - 1, iu, rot);
-    m_matT.coeffRef(iu, iu - 1) = Scalar(0);
+    matT.rightCols(size - iu + 1).applyOnTheLeft(iu - 1, iu, rot.adjoint());
+    matT.topRows(iu + 1).applyOnTheRight(iu - 1, iu, rot);
+    matT.coeffRef(iu, iu - 1) = Scalar(0);
     if (computeU) m_matU.applyOnTheRight(iu - 1, iu, rot);
   }
 
-  if (iu > 1) m_matT.coeffRef(iu - 1, iu - 2) = Scalar(0);
+  if (iu > 1) matT.coeffRef(iu - 1, iu - 2) = Scalar(0);
 }
 
 /** \internal Form shift in shiftInfo, and update exshift if an exceptional shift is performed. */
 template <typename MatrixType>
-inline void RealSchur<MatrixType>::computeShift(Index iu, Index iter, Scalar& exshift, Vector3s& shiftInfo) {
+template <typename TMatrix>
+inline void RealSchur<MatrixType>::computeShift(TMatrix& matT, Index iu, Index iter, Scalar& exshift,
+                                                Vector3s& shiftInfo) {
   using std::abs;
   using std::sqrt;
-  shiftInfo.coeffRef(0) = m_matT.coeff(iu, iu);
-  shiftInfo.coeffRef(1) = m_matT.coeff(iu - 1, iu - 1);
-  shiftInfo.coeffRef(2) = m_matT.coeff(iu, iu - 1) * m_matT.coeff(iu - 1, iu);
+  shiftInfo.coeffRef(0) = matT.coeff(iu, iu);
+  shiftInfo.coeffRef(1) = matT.coeff(iu - 1, iu - 1);
+  shiftInfo.coeffRef(2) = matT.coeff(iu, iu - 1) * matT.coeff(iu - 1, iu);
 
   // Alternate exceptional shifting strategy every 16 iterations.
   if (iter > 0 && iter % 16 == 0) {
     // Wilkinson's original ad hoc shift
     if (iter % 32 != 0) {
       exshift += shiftInfo.coeff(0);
-      for (Index i = 0; i <= iu; ++i) m_matT.coeffRef(i, i) -= shiftInfo.coeff(0);
-      Scalar s = abs(m_matT.coeff(iu, iu - 1)) + abs(m_matT.coeff(iu - 1, iu - 2));
+      matT.diagonal().head(iu + 1).array() -= shiftInfo.coeff(0);
+      Scalar s = abs(matT.coeff(iu, iu - 1)) + abs(matT.coeff(iu - 1, iu - 2));
       shiftInfo.coeffRef(0) = Scalar(0.75) * s;
       shiftInfo.coeffRef(1) = Scalar(0.75) * s;
       shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s;
@@ -428,7 +549,7 @@
         s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0);
         s = shiftInfo.coeff(0) - shiftInfo.coeff(2) / s;
         exshift += s;
-        for (Index i = 0; i <= iu; ++i) m_matT.coeffRef(i, i) -= s;
+        matT.diagonal().head(iu + 1).array() -= s;
         shiftInfo.setConstant(Scalar(0.964));
       }
     }
@@ -437,35 +558,37 @@
 
 /** \internal Compute index im at which Francis QR step starts and the first Householder vector. */
 template <typename MatrixType>
-inline void RealSchur<MatrixType>::initFrancisQRStep(Index il, Index iu, const Vector3s& shiftInfo, Index& im,
-                                                     Vector3s& firstHouseholderVector) {
+template <typename TMatrix>
+inline void RealSchur<MatrixType>::initFrancisQRStep(TMatrix& matT, Index il, Index iu, const Vector3s& shiftInfo,
+                                                     Index& im, Vector3s& firstHouseholderVector) {
   using std::abs;
   Vector3s& v = firstHouseholderVector;  // alias to save typing
 
   for (im = iu - 2; im >= il; --im) {
-    const Scalar Tmm = m_matT.coeff(im, im);
+    const Scalar Tmm = matT.coeff(im, im);
     const Scalar r = shiftInfo.coeff(0) - Tmm;
     const Scalar s = shiftInfo.coeff(1) - Tmm;
-    v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / m_matT.coeff(im + 1, im) + m_matT.coeff(im, im + 1);
-    v.coeffRef(1) = m_matT.coeff(im + 1, im + 1) - Tmm - r - s;
-    v.coeffRef(2) = m_matT.coeff(im + 2, im + 1);
+    v.coeffRef(0) = (r * s - shiftInfo.coeff(2)) / matT.coeff(im + 1, im) + matT.coeff(im, im + 1);
+    v.coeffRef(1) = matT.coeff(im + 1, im + 1) - Tmm - r - s;
+    v.coeffRef(2) = matT.coeff(im + 2, im + 1);
     if (im == il) {
       break;
     }
-    const Scalar lhs = m_matT.coeff(im, im - 1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
-    const Scalar rhs = v.coeff(0) * (abs(m_matT.coeff(im - 1, im - 1)) + abs(Tmm) + abs(m_matT.coeff(im + 1, im + 1)));
+    const Scalar lhs = matT.coeff(im, im - 1) * (abs(v.coeff(1)) + abs(v.coeff(2)));
+    const Scalar rhs = v.coeff(0) * (abs(matT.coeff(im - 1, im - 1)) + abs(Tmm) + abs(matT.coeff(im + 1, im + 1)));
     if (abs(lhs) < NumTraits<Scalar>::epsilon() * rhs) break;
   }
 }
 
 /** \internal Perform a Francis QR step involving rows il:iu and columns im:iu. */
 template <typename MatrixType>
-inline void RealSchur<MatrixType>::performFrancisQRStep(Index il, Index im, Index iu, bool computeU,
+template <typename TMatrix>
+inline void RealSchur<MatrixType>::performFrancisQRStep(TMatrix& matT, Index il, Index im, Index iu, bool computeU,
                                                         const Vector3s& firstHouseholderVector, Scalar* workspace) {
   eigen_assert(im >= il);
   eigen_assert(im <= iu - 2);
 
-  const Index size = m_matT.cols();
+  const Index size = matT.cols();
 
   for (Index k = im; k <= iu - 2; ++k) {
     bool firstIteration = (k == im);
@@ -474,7 +597,7 @@
     if (firstIteration)
       v = firstHouseholderVector;
     else
-      v = m_matT.template block<3, 1>(k, k - 1);
+      v = matT.template block<3, 1>(k, k - 1);
 
     Scalar tau, beta;
     Matrix<Scalar, 2, 1> ess;
@@ -483,34 +606,34 @@
     if (!numext::is_exactly_zero(beta))  // if v is not zero
     {
       if (firstIteration && k > il)
-        m_matT.coeffRef(k, k - 1) = -m_matT.coeff(k, k - 1);
+        matT.coeffRef(k, k - 1) = -matT.coeff(k, k - 1);
       else if (!firstIteration)
-        m_matT.coeffRef(k, k - 1) = beta;
+        matT.coeffRef(k, k - 1) = beta;
 
       // These Householder transformations form the O(n^3) part of the algorithm
-      m_matT.block(k, k, 3, size - k).applyHouseholderOnTheLeft(ess, tau, workspace);
-      m_matT.block(0, k, (std::min)(iu, k + 3) + 1, 3).applyHouseholderOnTheRight(ess, tau, workspace);
+      matT.block(k, k, 3, size - k).applyHouseholderOnTheLeft(ess, tau, workspace);
+      matT.block(0, k, (std::min)(iu, k + 3) + 1, 3).applyHouseholderOnTheRight(ess, tau, workspace);
       if (computeU) m_matU.block(0, k, size, 3).applyHouseholderOnTheRight(ess, tau, workspace);
     }
   }
 
-  Matrix<Scalar, 2, 1> v = m_matT.template block<2, 1>(iu - 1, iu - 2);
+  Matrix<Scalar, 2, 1> v = matT.template block<2, 1>(iu - 1, iu - 2);
   Scalar tau, beta;
   Matrix<Scalar, 1, 1> ess;
   v.makeHouseholder(ess, tau, beta);
 
   if (!numext::is_exactly_zero(beta))  // if v is not zero
   {
-    m_matT.coeffRef(iu - 1, iu - 2) = beta;
-    m_matT.block(iu - 1, iu - 1, 2, size - iu + 1).applyHouseholderOnTheLeft(ess, tau, workspace);
-    m_matT.block(0, iu - 1, iu + 1, 2).applyHouseholderOnTheRight(ess, tau, workspace);
+    matT.coeffRef(iu - 1, iu - 2) = beta;
+    matT.block(iu - 1, iu - 1, 2, size - iu + 1).applyHouseholderOnTheLeft(ess, tau, workspace);
+    matT.block(0, iu - 1, iu + 1, 2).applyHouseholderOnTheRight(ess, tau, workspace);
     if (computeU) m_matU.block(0, iu - 1, size, 2).applyHouseholderOnTheRight(ess, tau, workspace);
   }
 
   // clean up pollution due to round-off errors
   for (Index i = im + 2; i <= iu; ++i) {
-    m_matT.coeffRef(i, i - 2) = Scalar(0);
-    if (i > im + 2) m_matT.coeffRef(i, i - 3) = Scalar(0);
+    matT.coeffRef(i, i - 2) = Scalar(0);
+    if (i > im + 2) matT.coeffRef(i, i - 3) = Scalar(0);
   }
 }
 
diff --git a/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h b/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
index 05a516d..4f329f1 100644
--- a/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
+++ b/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
@@ -29,6 +29,7 @@
  *    Real Schur needed to real unsymmetrical eigenvalues/eigenvectors.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_REAL_SCHUR_LAPACKE_H
 #define EIGEN_REAL_SCHUR_LAPACKE_H
@@ -78,6 +79,8 @@
 EIGEN_LAPACKE_SCHUR_REAL(double, double, d, D, RowMajor, LAPACK_ROW_MAJOR)
 EIGEN_LAPACKE_SCHUR_REAL(float, float, s, S, RowMajor, LAPACK_ROW_MAJOR)
 
+#undef EIGEN_LAPACKE_SCHUR_REAL
+
 }  // end namespace Eigen
 
 #endif  // EIGEN_REAL_SCHUR_LAPACKE_H
diff --git a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
index 7edac1f..58e74c5 100644
--- a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
+++ b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFADJOINTEIGENSOLVER_H
 #define EIGEN_SELFADJOINTEIGENSOLVER_H
@@ -22,10 +23,10 @@
 class GeneralizedSelfAdjointEigenSolver;
 
 namespace internal {
-template <typename SolverType, int Size, bool IsComplex>
+template <typename SolverType, int Size, bool IsComplex, bool IsDirect = !IsComplex && (Size == 2 || Size == 3)>
 struct direct_selfadjoint_eigenvalues;
 
-template <typename MatrixType, typename DiagType, typename SubDiagType>
+template <bool PerBlockScaling, typename MatrixType, typename DiagType, typename SubDiagType>
 EIGEN_DEVICE_FUNC ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag,
                                                               const Index maxIterations, bool computeEigenvectors,
                                                               MatrixType& eivec);
@@ -81,19 +82,30 @@
 template <typename MatrixType_>
 class SelfAdjointEigenSolver {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum {
     Size = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
 
   /** \brief Scalar type for matrices of type \p MatrixType_. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
-  typedef Matrix<Scalar, Size, Size, ColMajor, MaxColsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
+  /** \brief Plain matrix type with the shape and storage options of \p MatrixType_; \p MatrixType_ itself unless
+   * that is a Ref<>. */
+  using PlainMatrixType =
+      Matrix<Scalar, Size, ColsAtCompileTime, Options, MatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime>;
+
+  /** \brief Type of the matrix returned by eigenvectors().
+   *
+   * A column-major plain matrix, or \p MatrixType_ itself when that is a Ref<>: the \link InplaceDecomposition
+   * inplace decomposition \endlink then stores the eigenvectors in the referenced matrix. */
+  using EigenvectorsType =
+      std::conditional_t<internal::is_ref<MatrixType>::value, MatrixType,
+                         Matrix<Scalar, Size, Size, ColMajor, MaxColsAtCompileTime, MaxColsAtCompileTime>>;
 
   /** \brief Real scalar type for \p MatrixType_.
    *
@@ -101,7 +113,7 @@
    * \c double), and the type of the real part of \c Scalar if #Scalar is
    * complex.
    */
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   friend struct internal::direct_selfadjoint_eigenvalues<SelfAdjointEigenSolver, Size, NumTraits<Scalar>::IsComplex>;
 
@@ -110,10 +122,10 @@
    * This is a column vector with entries of type #RealScalar.
    * The length of the vector is the size of \p MatrixType_.
    */
-  typedef typename internal::plain_col_type<MatrixType, Scalar>::type VectorType;
-  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType;
-  typedef Tridiagonalization<MatrixType> TridiagonalizationType;
-  typedef typename TridiagonalizationType::SubDiagonalType SubDiagonalType;
+  using VectorType = typename internal::plain_col_type<MatrixType, Scalar>::type;
+  using RealVectorType = typename internal::plain_col_type<MatrixType, RealScalar>::type;
+  using TridiagonalizationType = Tridiagonalization<MatrixType>;
+  using SubDiagonalType = typename TridiagonalizationType::SubDiagonalType;
 
   /** \brief Default constructor for fixed-size matrices.
    *
@@ -184,6 +196,24 @@
     compute(matrix.derived(), options);
   }
 
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix  Selfadjoint matrix whose eigendecomposition is to
+   *    be computed. Only the lower triangular part of the matrix is referenced.
+   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p matrix, whose content is
+   * destroyed: with #ComputeEigenvectors it holds the eigenvectors afterwards and eigenvectors() refers to it, with
+   * #EigenvaluesOnly its content is unspecified. This overload is only available for Ref<>; owning matrix types
+   * use the constructor taking a const input.
+   */
+  template <typename InputType, bool IsRef = internal::is_ref<MatrixType>::value, std::enable_if_t<IsRef, int> = 0>
+  EIGEN_DEVICE_FUNC explicit SelfAdjointEigenSolver(EigenBase<InputType>& matrix, int options = ComputeEigenvectors)
+      : SelfAdjointEigenSolver(matrix, BindStorageTag()) {
+    m_eivec.template triangularView<StrictlyUpper>().setZero();
+    computeInPlace(options);
+  }
+
   /** \brief Computes eigendecomposition of given matrix.
    *
    * \param[in]  matrix  Selfadjoint matrix whose eigendecomposition is to
@@ -218,10 +248,18 @@
   EIGEN_DEVICE_FUNC SelfAdjointEigenSolver& compute(const EigenBase<InputType>& matrix,
                                                     int options = ComputeEigenvectors);
 
-  /** \brief Computes eigendecomposition of given matrix using a closed-form algorithm
+  /** \brief Computes eigendecomposition of given matrix primarily using a closed-form algorithm
    *
    * This is a variant of compute(const MatrixType&, int options) which
-   * directly solves the underlying polynomial equation.
+   * normally solves the underlying polynomial equation directly.
+   * For supported real binary floating-point 3x3 matrices with coefficients near the
+   * overflow limit, it instead uses the iterative solver in scaled coordinates to
+   * avoid overflow from roundoff near repeated eigenvalues. This fallback has the
+   * runtime characteristics of compute() and may fail to converge. Check info()
+   * for Success before using the results; the fallback can report NoConvergence.
+   * Non-finite inputs have no guaranteed decomposition. In particular, infinite
+   * coefficients can also enter the 3x3 fallback and report NoConvergence;
+   * a Success status alone does not validate non-finite input.
    *
    * Currently only 2x2 and 3x3 matrices for which the sizes are known at compile time are supported (e.g., Matrix3d).
    *
@@ -317,25 +355,25 @@
    * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
    * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
    *
-   * \sa operatorInverseSqrt(), <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+   * \sa operatorInverseSqrt(), <a href="contrib/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
    */
-  EIGEN_DEVICE_FUNC MatrixType operatorSqrt() const {
+  EIGEN_DEVICE_FUNC PlainMatrixType operatorSqrt() const {
     eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
     return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
   }
 
-  /** \brief Computes the matrix exponential the matrix.
+  /** \brief Computes the matrix exponential of the matrix.
    *
-   * \returns the matrix exponential the matrix.
+   * \returns the matrix exponential of the matrix.
    *
    * \pre The eigenvalues and eigenvectors of a positive-definite matrix
    * have been computed before.
    *
    * \sa operatorInverseSqrt(), operatorSqrt(),
-   * <a href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+   * <a href="contrib/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
    */
-  EIGEN_DEVICE_FUNC MatrixType operatorExp() const {
+  EIGEN_DEVICE_FUNC PlainMatrixType operatorExp() const {
     eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
     return m_eivec * m_eivalues.array().exp().matrix().asDiagonal() * m_eivec.adjoint();
@@ -357,9 +395,9 @@
    * Output: \verbinclude SelfAdjointEigenSolver_operatorInverseSqrt.out
    *
    * \sa operatorSqrt(), MatrixBase::inverse(), <a
-   * href="unsupported/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
+   * href="contrib/group__MatrixFunctions__Module.html">MatrixFunctions Module</a>
    */
-  EIGEN_DEVICE_FUNC MatrixType operatorInverseSqrt() const {
+  EIGEN_DEVICE_FUNC PlainMatrixType operatorInverseSqrt() const {
     eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
     return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
@@ -384,6 +422,25 @@
  protected:
   EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
 
+  /** \internal Tag of the constructor that binds the eigenvector storage without computing anything. */
+  struct BindStorageTag {};
+
+  /** \internal Binds the eigenvector storage to \a matrix, or copies it when #EigenvectorsType is a plain matrix, and
+   * allocates the workspace without computing anything. */
+  template <typename InputType>
+  EIGEN_DEVICE_FUNC SelfAdjointEigenSolver(EigenBase<InputType>& matrix, BindStorageTag)
+      : m_eivec(matrix.derived()),
+        m_workspace(matrix.cols()),
+        m_eivalues(matrix.cols()),
+        m_subdiag(matrix.rows() > 1 ? matrix.rows() - 1 : 1),
+        m_hcoeffs(matrix.cols() > 1 ? matrix.cols() - 1 : 1),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false) {}
+
+  /** \internal Computes the eigendecomposition of the selfadjoint matrix held in m_eivec, whose lower triangle is
+   * referenced; the eigenvectors overwrite it when requested. */
+  EIGEN_DEVICE_FUNC SelfAdjointEigenSolver& computeInPlace(int options);
+
   EigenvectorsType m_eivec;
   VectorType m_workspace;
   RealVectorType m_eivalues;
@@ -406,18 +463,16 @@
  * \param subdiag the sub-diagonal part of the input selfadjoint tridiagonal matrix
  * \param start starting index of the submatrix to work on
  * \param end last+1 index of the submatrix to work on
- * \param matrixQ pointer to the column-major matrix holding the eigenvectors, can be 0
- * \param n size of the input matrix
+ * \param matrixQ pointer to the matrix accumulating the eigenvectors, can be null
  *
- * For compilation efficiency reasons, this procedure does not use eigen expression
- * for its arguments.
+ * For compilation efficiency reasons, the tridiagonal matrix is passed as raw pointers.
  *
  * Implemented from Golub's "Matrix Computations", algorithm 8.3.2:
  * "implicit symmetric QR step with Wilkinson shift"
  */
-template <int StorageOrder, typename RealScalar, typename Scalar, typename Index>
+template <typename RealScalar, typename Index, typename MatrixQType>
 EIGEN_DEVICE_FUNC static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end,
-                                                  Scalar* matrixQ, Index n);
+                                                  MatrixQType* matrixQ);
 }  // namespace internal
 
 template <typename MatrixType>
@@ -425,20 +480,24 @@
 EIGEN_DEVICE_FUNC SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>::compute(
     const EigenBase<InputType>& a_matrix, int options) {
   const InputType& matrix(a_matrix.derived());
-
-  EIGEN_USING_STD(abs);
   eigen_assert(matrix.cols() == matrix.rows());
+  m_eivec = matrix.template triangularView<Lower>();
+  return computeInPlace(options);
+}
+
+template <typename MatrixType>
+EIGEN_DEVICE_FUNC SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>::computeInPlace(int options) {
+  eigen_assert(m_eivec.cols() == m_eivec.rows());
   eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
                "invalid option parameter");
   bool computeEigenvectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
-  Index n = matrix.cols();
+  Index n = m_eivec.cols();
   m_eivalues.resize(n, 1);
 
   if (n == 1) {
-    m_eivec = matrix;
     m_eivalues.coeffRef(0, 0) = numext::real(m_eivec.coeff(0, 0));
-    if (computeEigenvectors) m_eivec.setOnes(n, n);
-    m_info = Success;
+    if (computeEigenvectors) m_eivec.setOnes();
+    m_info = (numext::isfinite)(m_eivalues.coeffRef(0, 0)) ? Success : NoConvergence;
     m_isInitialized = true;
     m_eigenvectorsOk = computeEigenvectors;
     return *this;
@@ -448,19 +507,31 @@
   RealVectorType& diag = m_eivalues;
   EigenvectorsType& mat = m_eivec;
 
-  // map the matrix coefficients to [-1:1] to avoid over- and underflow.
-  mat = matrix.template triangularView<Lower>();
-  RealScalar scale = mat.cwiseAbs().maxCoeff();
-  if (numext::is_exactly_zero(scale)) scale = RealScalar(1);
-  mat.template triangularView<Lower>() /= scale;
+  // Scale the matrix to O(1) to avoid overflow/underflow during tridiagonalization
+  // and subsequent QR iteration. Power-of-two factors avoid rounding representable scaled coefficients.
+  // Note: for block-diagonal matrices with widely separated scales, this
+  // can underflow small blocks. Users with such matrices should tridiagonalize separately
+  // and call computeFromTridiagonal(), which uses per-block scaling.
+  const RealScalar maxCoeff = internal::safe_scaling<RealScalar>::recover_flushed_max_coeff(
+      mat, mat.cwiseAbs().template maxCoeff<PropagateNaN>());
+  if (!(numext::isfinite)(maxCoeff)) {
+    // Input contains Inf or NaN.
+    m_info = NoConvergence;
+    m_isInitialized = true;
+    m_eigenvectorsOk = false;
+    return *this;
+  }
+  const auto factors = internal::safe_scaling<RealScalar>::with_scaled(mat, maxCoeff, [&](const auto& scaled) {
+    mat.template triangularView<Lower>() = scaled.template triangularView<Lower>();
+  });
   m_subdiag.resize(n - 1);
   m_hcoeffs.resize(n - 1);
   internal::tridiagonalization_inplace(mat, diag, m_subdiag, m_hcoeffs, m_workspace, computeEigenvectors);
 
-  m_info = internal::computeFromTridiagonal_impl(diag, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+  m_info = internal::computeFromTridiagonal_impl<false>(diag, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
 
-  // scale back the eigen values
-  m_eivalues *= scale;
+  // Scale back the eigenvalues.
+  internal::safe_scaling<RealScalar>::unscale_in_place(m_eivalues, maxCoeff, factors);
 
   m_isInitialized = true;
   m_eigenvectorsOk = computeEigenvectors;
@@ -470,15 +541,31 @@
 template <typename MatrixType>
 SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>::computeFromTridiagonal(
     const RealVectorType& diag, const SubDiagonalType& subdiag, int options) {
-  // TODO : Add an option to scale the values beforehand
   bool computeEigenvectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
 
   m_eivalues = diag;
   m_subdiag = subdiag;
+
+  // Check for Inf/NaN in the input.
+  {
+    RealScalar scale = RealScalar(0);
+    if (m_eivalues.size() > 0) scale = m_eivalues.cwiseAbs().maxCoeff();
+    if (m_subdiag.size() > 0) scale = numext::maxi(scale, m_subdiag.cwiseAbs().maxCoeff());
+    if (!(numext::isfinite)(scale)) {
+      m_info = NoConvergence;
+      m_isInitialized = true;
+      m_eigenvectorsOk = false;
+      return *this;
+    }
+  }
+
   if (computeEigenvectors) {
     m_eivec.setIdentity(diag.size(), diag.size());
   }
-  m_info = internal::computeFromTridiagonal_impl(m_eivalues, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
+  // Use per-deflation-block scaling (like LAPACK's DSTERF) to avoid losing
+  // precision when the tridiagonal entries span a wide range of magnitudes.
+  m_info =
+      internal::computeFromTridiagonal_impl<true>(m_eivalues, m_subdiag, m_maxIterations, computeEigenvectors, m_eivec);
 
   m_isInitialized = true;
   m_eigenvectorsOk = computeEigenvectors;
@@ -490,6 +577,10 @@
  * \internal
  * \brief Compute the eigendecomposition from a tridiagonal matrix
  *
+ * \tparam PerBlockScaling If true, each deflation block is independently scaled to O(1) before
+ *         QR iteration, following LAPACK's DSTERF approach. This prevents precision loss when entries
+ *         span a wide range of magnitudes. When false, the caller is responsible for ensuring the
+ *         entries are in a safe range (e.g. by pre-scaling the dense matrix before tridiagonalization).
  * \param[in,out] diag : On input, the diagonal of the matrix, on output the eigenvalues
  * \param[in,out] subdiag : The subdiagonal part of the matrix (entries are modified during the decomposition)
  * \param[in] maxIterations : the maximum number of iterations
@@ -497,36 +588,62 @@
  * \param[out] eivec : The matrix to store the eigenvectors if computeEigenvectors==true. Must be allocated on input.
  * \returns \c Success or \c NoConvergence
  */
-template <typename MatrixType, typename DiagType, typename SubDiagType>
+template <bool PerBlockScaling, typename MatrixType, typename DiagType, typename SubDiagType>
 EIGEN_DEVICE_FUNC ComputationInfo computeFromTridiagonal_impl(DiagType& diag, SubDiagType& subdiag,
                                                               const Index maxIterations, bool computeEigenvectors,
                                                               MatrixType& eivec) {
   ComputationInfo info;
-  typedef typename MatrixType::Scalar Scalar;
 
   Index n = diag.size();
   Index end = n - 1;
   Index start = 0;
   Index iter = 0;  // total number of iterations
 
-  typedef typename DiagType::RealScalar RealScalar;
+  using RealScalar = typename DiagType::RealScalar;
   const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
-  const RealScalar precision_inv = RealScalar(1) / NumTraits<RealScalar>::epsilon();
-  while (end > 0) {
-    for (Index i = start; i < end; ++i) {
-      if (numext::abs(subdiag[i]) < considerAsZero) {
+  const RealScalar precision = NumTraits<RealScalar>::epsilon();
+  const RealScalar precision_inv = RealScalar(1) / precision;
+
+  // Helper lambda for the deflation test.
+  auto deflate = [&](Index lo, Index hi) {
+    for (Index i = lo; i < hi; ++i) {
+      const RealScalar absSubdiag = numext::abs(subdiag[i]);
+      if (absSubdiag < considerAsZero) {
         subdiag[i] = RealScalar(0);
+      } else if (!PerBlockScaling) {
+        // Homogeneous in the global scale: both sides are linear in it, so prescaling cannot change which couplings
+        // are discarded (the previous test was quadratic on the left).
+        if (absSubdiag <= precision * numext::maxi(numext::abs(diag[i]), numext::abs(diag[i + 1]))) {
+          subdiag[i] = RealScalar(0);
+        }
       } else {
-        // abs(subdiag[i]) <= epsilon * sqrt(abs(diag[i]) + abs(diag[i+1]))
-        // Scaled to prevent underflows.
         const RealScalar scaled_subdiag = precision_inv * subdiag[i];
         if (scaled_subdiag * scaled_subdiag <= (numext::abs(diag[i]) + numext::abs(diag[i + 1]))) {
           subdiag[i] = RealScalar(0);
         }
       }
     }
+  };
 
-    // find the largest unreduced block at the end of the matrix.
+  // For per-block scaling, track the currently scaled block and its scale factor.
+  // When the outer loop identifies a block outside the scaled region, unscale the old
+  // block and scale the new one. This keeps the same outer loop structure (one QR step
+  // per iteration) while ensuring each block is processed in scaled coordinates.
+  Index scaled_start = -1, scaled_end = -1;
+  RealScalar block_norm = RealScalar(0);
+  safe_scaling_factors<RealScalar> blockFactors;
+  const auto restore_block = [&]() {
+    if (scaled_start < 0) return;
+    auto diagonal = diag.segment(scaled_start, scaled_end - scaled_start + 1);
+    auto offDiagonal = subdiag.segment(scaled_start, scaled_end - scaled_start);
+    safe_scaling<RealScalar>::unscale_in_place(diagonal, block_norm, blockFactors);
+    safe_scaling<RealScalar>::unscale_in_place(offDiagonal, block_norm, blockFactors);
+  };
+
+  while (end > 0) {
+    deflate(start, end);
+
+    // Find the largest unreduced block at the end of the matrix.
     while (end > 0 && numext::is_exactly_zero(subdiag[end - 1])) {
       end--;
     }
@@ -539,9 +656,29 @@
     start = end - 1;
     while (start > 0 && !numext::is_exactly_zero(subdiag[start - 1])) start--;
 
-    internal::tridiagonal_qr_step<MatrixType::Flags & RowMajorBit ? RowMajor : ColMajor>(
-        diag.data(), subdiag.data(), start, end, computeEigenvectors ? eivec.data() : (Scalar*)0, n);
+    if (PerBlockScaling) {
+      // Check if we've moved to a different block than the one currently scaled.
+      if (start != scaled_start || end != scaled_end) {
+        restore_block();
+        // Compute the norm and scale the new block to O(1).
+        block_norm = RealScalar(0);
+        for (Index i = start; i <= end; ++i) block_norm = numext::maxi(block_norm, numext::abs(diag[i]));
+        for (Index i = start; i < end; ++i) block_norm = numext::maxi(block_norm, numext::abs(subdiag[i]));
+        auto diagonal = diag.segment(start, end - start + 1);
+        auto offDiagonal = subdiag.segment(start, end - start);
+        blockFactors = safe_scaling<RealScalar>::scale_to(diagonal, diagonal, block_norm);
+        safe_scaling<RealScalar>::scale_to(offDiagonal, offDiagonal, block_norm, blockFactors);
+        scaled_start = start;
+        scaled_end = end;
+      }
+    }
+
+    internal::tridiagonal_qr_step(diag.data(), subdiag.data(), start, end,
+                                  computeEigenvectors ? &eivec : static_cast<MatrixType*>(nullptr));
   }
+
+  // Unscale any remaining scaled block.
+  if (PerBlockScaling) restore_block();
   if (iter <= maxIterations * n)
     info = Success;
   else
@@ -551,30 +688,44 @@
   // TODO: make the sort optional and use a more efficient sorting algorithm.
   if (info == Success) {
     for (Index i = 0; i < n - 1; ++i) {
-      Index k;
-      diag.segment(i, n - i).minCoeff(&k);
-      if (k > 0) {
-        numext::swap(diag[i], diag[k + i]);
-        if (computeEigenvectors) eivec.col(i).swap(eivec.col(k + i));
+      // Scalar argmin: the vectorized minCoeff path can return the wrong
+      // index on targets whose SIMD reduction flushes subnormals (32-bit ARM
+      // NEON always treats subnormal inputs to vminq_f32 as zero), which
+      // corrupts ordering when eigenvalues span the subnormal range.
+      Index k = i;
+      RealScalar min_val = diag[i];
+      for (Index j = i + 1; j < n; ++j) {
+        if (diag[j] < min_val) {
+          min_val = diag[j];
+          k = j;
+        }
+      }
+      if (k != i) {
+        numext::swap(diag[i], diag[k]);
+        if (computeEigenvectors) eivec.col(i).swap(eivec.col(k));
       }
     }
   }
   return info;
 }
 
-template <typename SolverType, int Size, bool IsComplex>
+template <typename SolverType, int Size, bool IsComplex, bool IsDirect>
 struct direct_selfadjoint_eigenvalues {
   EIGEN_DEVICE_FUNC static inline void run(SolverType& eig, const typename SolverType::MatrixType& A, int options) {
     eig.compute(A, options);
   }
 };
 
+template <typename SolverType, int Size>
+struct direct_selfadjoint_eigensolver_kernel;
+
 template <typename SolverType>
-struct direct_selfadjoint_eigenvalues<SolverType, 3, false> {
-  typedef typename SolverType::MatrixType MatrixType;
-  typedef typename SolverType::RealVectorType VectorType;
-  typedef typename SolverType::Scalar Scalar;
-  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+struct direct_selfadjoint_eigensolver_kernel<SolverType, 3> {
+  using MatrixType = typename SolverType::MatrixType;
+  using VectorType = typename SolverType::RealVectorType;
+  using Scalar = typename SolverType::Scalar;
+  using EigenvectorsType = typename SolverType::EigenvectorsType;
+  using PlainMatrixType = typename SolverType::PlainMatrixType;
 
   /** \internal
    * Computes the roots of the characteristic polynomial of \a m.
@@ -619,7 +770,7 @@
     roots(2) = c2_over_3 + Scalar(2) * rho * cos_theta;
   }
 
-  EIGEN_DEVICE_FUNC static inline bool extract_kernel(MatrixType& mat, Ref<VectorType> res,
+  EIGEN_DEVICE_FUNC static inline bool extract_kernel(PlainMatrixType& mat, Ref<VectorType> res,
                                                       Ref<VectorType> representative) {
     EIGEN_USING_STD(abs);
     EIGEN_USING_STD(sqrt);
@@ -641,34 +792,25 @@
     return true;
   }
 
-  EIGEN_DEVICE_FUNC static inline void run(SolverType& solver, const MatrixType& mat, int options) {
-    eigen_assert(mat.cols() == 3 && mat.cols() == mat.rows());
-    eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
-                 "invalid option parameter");
-    bool computeEigenvectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
-
-    EigenvectorsType& eivecs = solver.m_eivec;
-    VectorType& eivals = solver.m_eivalues;
-
-    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
-    Scalar shift = mat.trace() / Scalar(3);
-    // TODO: avoid this copy. Currently necessary to suppress bogus values when determining maxCoeff and for
-    // computing the eigenvectors later.
-    MatrixType scaledMat = mat.template selfadjointView<Lower>();
-    scaledMat.diagonal().array() -= shift;
-    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
-    if (scale > 0) scaledMat /= scale;  // TODO: skip remaining operations when scale==0.
-
+  EIGEN_DEVICE_FUNC static void run(PlainMatrixType& scaledMat, VectorType& eivals, EigenvectorsType& eivecs,
+                                    bool computeEigenvectors, const Scalar& maxCoeff) {
     // compute the eigenvalues
     computeRoots(scaledMat, eivals);
 
+    // computeRoots produces theoretically sorted roots, but floating-point
+    // rounding in the trigonometric formulas can break the ordering.
+    // Enforce sorting with a fixed 3-element compare-swap network.
+    if (eivals(0) > eivals(1)) numext::swap(eivals(0), eivals(1));
+    if (eivals(1) > eivals(2)) numext::swap(eivals(1), eivals(2));
+    if (eivals(0) > eivals(1)) numext::swap(eivals(0), eivals(1));
+
     // compute the eigenvectors
     if (computeEigenvectors) {
-      if ((eivals(2) - eivals(0)) <= Eigen::NumTraits<Scalar>::epsilon()) {
+      if ((eivals(2) - eivals(0)) <= Eigen::NumTraits<Scalar>::epsilon() * maxCoeff) {
         // All three eigenvalues are numerically the same
         eivecs.setIdentity();
       } else {
-        MatrixType tmp;
+        PlainMatrixType tmp;
         tmp = scaledMat;
 
         // Compute the eigenvector of the most distinct eigenvalue
@@ -691,7 +833,7 @@
         if (d0 <= 2 * Eigen::NumTraits<Scalar>::epsilon() * d1) {
           // If d0 is too small, then the two other eigenvalues are numerically the same,
           // and thus we only have to ortho-normalize the near orthogonal vector we saved above.
-          eivecs.col(l) -= eivecs.col(k).dot(eivecs.col(l)) * eivecs.col(l);
+          eivecs.col(l) -= eivecs.col(k).dot(eivecs.col(l)) * eivecs.col(k);
           eivecs.col(l).normalize();
         } else {
           tmp = scaledMat;
@@ -705,24 +847,17 @@
         eivecs.col(1) = eivecs.col(2).cross(eivecs.col(0)).normalized();
       }
     }
-
-    // Rescale back to the original size.
-    eivals *= scale;
-    eivals.array() += shift;
-
-    solver.m_info = Success;
-    solver.m_isInitialized = true;
-    solver.m_eigenvectorsOk = computeEigenvectors;
   }
 };
 
 // 2x2 direct eigenvalues decomposition, code from Hauke Heibel
 template <typename SolverType>
-struct direct_selfadjoint_eigenvalues<SolverType, 2, false> {
-  typedef typename SolverType::MatrixType MatrixType;
-  typedef typename SolverType::RealVectorType VectorType;
-  typedef typename SolverType::Scalar Scalar;
-  typedef typename SolverType::EigenvectorsType EigenvectorsType;
+struct direct_selfadjoint_eigensolver_kernel<SolverType, 2> {
+  using MatrixType = typename SolverType::MatrixType;
+  using VectorType = typename SolverType::RealVectorType;
+  using Scalar = typename SolverType::Scalar;
+  using EigenvectorsType = typename SolverType::EigenvectorsType;
+  using PlainMatrixType = typename SolverType::PlainMatrixType;
 
   EIGEN_DEVICE_FUNC static inline void computeRoots(const MatrixType& m, VectorType& roots) {
     EIGEN_USING_STD(sqrt);
@@ -732,26 +867,12 @@
     roots(1) = t1 + t0;
   }
 
-  EIGEN_DEVICE_FUNC static inline void run(SolverType& solver, const MatrixType& mat, int options) {
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static void run(PlainMatrixType& scaledMat, VectorType& eivals,
+                                                        EigenvectorsType& eivecs, bool computeEigenvectors,
+                                                        const Scalar&) {
     EIGEN_USING_STD(sqrt);
     EIGEN_USING_STD(abs);
 
-    eigen_assert(mat.cols() == 2 && mat.cols() == mat.rows());
-    eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
-                 "invalid option parameter");
-    bool computeEigenvectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
-
-    EigenvectorsType& eivecs = solver.m_eivec;
-    VectorType& eivals = solver.m_eivalues;
-
-    // Shift the matrix to the mean eigenvalue and map the matrix coefficients to [-1:1] to avoid over- and underflow.
-    Scalar shift = mat.trace() / Scalar(2);
-    MatrixType scaledMat = mat;
-    scaledMat.coeffRef(0, 1) = mat.coeff(1, 0);
-    scaledMat.diagonal().array() -= shift;
-    Scalar scale = scaledMat.cwiseAbs().maxCoeff();
-    if (scale > Scalar(0)) scaledMat /= scale;
-
     // Compute the eigenvalues
     computeRoots(scaledMat, eivals);
 
@@ -772,18 +893,120 @@
           eivecs.col(1) /= sqrt(c2 + b2);
         }
 
-        eivecs.col(0) << eivecs.col(1).unitOrthogonal();
+        // The partner is already normalized; this rotation preserves its norm.
+        eivecs.col(0) << -eivecs(1, 1), eivecs(0, 1);
       }
     }
+  }
+};
 
-    // Rescale back to the original size.
-    eivals *= scale;
-    eivals.array() += shift;
+template <typename SolverType, int Size>
+struct direct_selfadjoint_eigenvalues<SolverType, Size, false, true> {
+  using MatrixType = typename SolverType::MatrixType;
+  using PlainMatrixType = typename SolverType::PlainMatrixType;
+  using Scalar = typename SolverType::Scalar;
 
+  // Only host-side long double limits need more range than double.
+  using Limit = std::conditional_t<std::is_same<Scalar, long double>::value, long double, double>;
+
+  EIGEN_DEVICE_FUNC static constexpr Limit power_of_two(int exponent) {
+    Limit result = 1;
+    for (; exponent > 0; --exponent) result *= 2;
+    for (; exponent < 0; ++exponent) result /= 2;
+    return result;
+  }
+
+  EIGEN_DEVICE_FUNC static bool safe_without_scaling(const Scalar& magnitude, true_type) {
+    // The quadratic/cubic kernels have degree 2/6. Reserve 12 exponent bits
+    // for intermediate growth and keep flushed terms below epsilon*mu^degree.
+    constexpr int degree = Size == 3 ? 6 : 2;
+    constexpr int lower = std::numeric_limits<Scalar>::min_exponent - 1 + std::numeric_limits<Scalar>::digits - 1 + 12;
+    constexpr int upper = std::numeric_limits<Scalar>::max_exponent - 1 - 12;
+    constexpr int minExponent = lower >= 0 ? (lower + degree - 1) / degree : lower / degree;
+    constexpr int maxExponent = upper >= 0 ? upper / degree : (upper - degree + 1) / degree;
+    constexpr Limit minimum = power_of_two(minExponent);
+    constexpr Limit maximum = power_of_two(maxExponent);
+    return magnitude >= Scalar(minimum) && magnitude <= Scalar(maximum);
+  }
+
+  EIGEN_DEVICE_FUNC static bool safe_without_scaling(const Scalar& magnitude, false_type) {
+    return magnitude >= Scalar(0.25) && magnitude <= Scalar(2) &&
+           NumTraits<Scalar>::epsilon() / Scalar(4096) >= (std::numeric_limits<Scalar>::min)();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run_scaled(SolverType& solver, const MatrixType& mat,
+                                                             const Scalar& shift, Scalar centeredMax, int options) {
+    PlainMatrixType scaledMat = mat.template selfadjointView<Lower>();
+    scaledMat.diagonal().array() -= shift;
+    centeredMax = safe_scaling<Scalar>::recover_flushed_max_coeff(scaledMat, centeredMax);
+    const auto factors = safe_scaling<Scalar>::scale_to(scaledMat, scaledMat, centeredMax);
+    direct_selfadjoint_eigensolver_kernel<SolverType, Size>::run(scaledMat, solver.m_eivalues, solver.m_eivec,
+                                                                 (options & ComputeEigenvectors) == ComputeEigenvectors,
+                                                                 scaledMat.cwiseAbs().maxCoeff());
+    safe_scaling<Scalar>::unscale_in_place(solver.m_eivalues, centeredMax, factors);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static void run_centered(SolverType& solver, const MatrixType& mat,
+                                                                 int options) {
+    const bool computeEigenvectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
+    PlainMatrixType scaledMat = mat.template selfadjointView<Lower>();
+    const Scalar first = scaledMat(0, 0);
+    Scalar shift = first;
+    for (Index i = 1; i < Size; ++i) shift += (scaledMat(i, i) - first) / Scalar(Size);
+    scaledMat.diagonal().array() -= shift;
+    // Centering can leave a much smaller matrix; normalize again for the cubic and cross-product formulas.
+    const Scalar centeredMax = scaledMat.cwiseAbs().maxCoeff();
+    if (safe_without_scaling(centeredMax, supports_power_of_two_scaling<Scalar>())) {
+      direct_selfadjoint_eigensolver_kernel<SolverType, Size>::run(scaledMat, solver.m_eivalues, solver.m_eivec,
+                                                                   computeEigenvectors, centeredMax);
+    } else {
+      run_scaled(solver, mat, shift, centeredMax, options);
+    }
+    solver.m_eivalues.array() += shift;
     solver.m_info = Success;
     solver.m_isInitialized = true;
     solver.m_eigenvectorsOk = computeEigenvectors;
   }
+
+  EIGEN_DEVICE_FUNC static void run_large(SolverType& solver, PlainMatrixType& scaledMat, int options, false_type) {
+    run_centered(solver, scaledMat, options);
+  }
+
+  EIGEN_DEVICE_FUNC static void run_large(SolverType& solver, PlainMatrixType& scaledMat, int options, true_type) {
+    // The cubic loses accuracy near repeated roots; at the exponent limit that error can overflow a finite result.
+    solver.compute(scaledMat, options);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE static void run_prescaled(SolverType& solver, const MatrixType& mat,
+                                                                const Scalar& maxCoeff, int options) {
+    PlainMatrixType scaledMat = mat.template selfadjointView<Lower>();
+    const Scalar recoveredMax = safe_scaling<Scalar>::recover_flushed_max_coeff(scaledMat, maxCoeff);
+    const auto inputFactors = safe_scaling<Scalar>::scale_to(scaledMat, scaledMat, recoveredMax);
+    if (maxCoeff > (NumTraits<Scalar>::highest() * Scalar(0.5)) / Scalar(Size)) {
+      run_large(solver, scaledMat, options,
+                bool_constant<(Size == 3 && supports_power_of_two_scaling<Scalar>::value)>());
+    } else {
+      run_centered(solver, scaledMat, options);
+    }
+    safe_scaling<Scalar>::unscale_in_place(solver.m_eivalues, recoveredMax, inputFactors);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static void run(SolverType& solver, const MatrixType& mat, int options) {
+    eigen_assert(mat.rows() == Size && mat.cols() == Size);
+    eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
+                 "invalid option parameter");
+    PlainMatrixType scaledMat = mat.template selfadjointView<Lower>();
+    const Scalar maxCoeff = scaledMat.cwiseAbs().maxCoeff();
+    // Bound centered coefficients by 2*M and eigenvalues by Size*M. Prescale tiny inputs before any FTZ-sensitive
+    // subtraction, and large inputs before centering or restoring the centered eigenvalues could overflow.
+    // Halve highest() first: IBM double-double division can overflow internally at the maximum value.
+    if (EIGEN_PREDICT_FALSE(maxCoeff < (std::numeric_limits<Scalar>::min)() / NumTraits<Scalar>::epsilon() ||
+                            maxCoeff > (NumTraits<Scalar>::highest() * Scalar(0.5)) / Scalar(Size))) {
+      run_prescaled(solver, mat, maxCoeff, options);
+    } else {
+      run_centered(solver, mat, options);
+    }
+  }
 };
 
 }  // namespace internal
@@ -798,27 +1021,28 @@
 
 namespace internal {
 
-// Francis implicit QR step.
-template <int StorageOrder, typename RealScalar, typename Scalar, typename Index>
+// Francis implicit QR step; the rotations accumulate into *matrixQ when it is non-null.
+template <typename RealScalar, typename Index, typename MatrixQType>
 EIGEN_DEVICE_FUNC static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end,
-                                                  Scalar* matrixQ, Index n) {
+                                                  MatrixQType* matrixQ) {
   // Wilkinson Shift.
   RealScalar td = (diag[end - 1] - diag[end]) * RealScalar(0.5);
   RealScalar e = subdiag[end - 1];
-  // Note that thanks to scaling, e^2 or td^2 cannot overflow, however they can still
-  // underflow thus leading to inf/NaN values when using the following commented code:
-  //   RealScalar e2 = numext::abs2(subdiag[end-1]);
-  //   RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2));
-  // This explain the following, somewhat more complicated, version:
   RealScalar mu = diag[end];
   if (numext::is_exactly_zero(td)) {
     mu -= numext::abs(e);
   } else if (!numext::is_exactly_zero(e)) {
     const RealScalar e2 = numext::abs2(e);
-    const RealScalar h = numext::hypot(td, e);
     if (numext::is_exactly_zero(e2)) {
-      mu -= e / ((td + (td > RealScalar(0) ? h : -h)) / e);
+      // Scaling prevents e^2 and td^2 from overflowing, but e^2 can still underflow. A subdiagonal that survives
+      // deflation satisfies (e/epsilon)^2 > 2*abs(td), so td/e remains bounded in this branch. LAPACK's xSTEQR uses
+      // this dimensionless form; keeping td/e inside hypot prevents fast-math from reassociating the correction into
+      // an underflowing e^2 expression.
+      const RealScalar ratio = td / e;
+      const RealScalar h = numext::hypot(ratio, RealScalar(1));
+      mu -= e / (ratio + (ratio > RealScalar(0) ? h : -h));
     } else {
+      const RealScalar h = numext::hypot(td, e);
       mu -= e2 / (td + (td > RealScalar(0) ? h : -h));
     }
   }
@@ -831,14 +1055,24 @@
     JacobiRotation<RealScalar> rot;
     rot.makeGivens(x, z);
 
-    // do T = G' T G
-    RealScalar sdk = rot.s() * diag[k] + rot.c() * subdiag[k];
-    RealScalar dkp1 = rot.s() * subdiag[k] + rot.c() * diag[k + 1];
+    // do T = G' T G. The two new diagonal entries and the new off-diagonal are all expressed below
+    // as functions of the original difference diff = diag[k] - diag[k+1] and the original subdiag[k],
+    // so capture diff and compute delta/subdiag[k] before overwriting the diagonal.
+    const RealScalar diff = diag[k] - diag[k + 1];
 
-    diag[k] =
-        rot.c() * (rot.c() * diag[k] - rot.s() * subdiag[k]) - rot.s() * (rot.c() * subdiag[k] - rot.s() * diag[k + 1]);
-    diag[k + 1] = rot.s() * sdk + rot.c() * dkp1;
-    subdiag[k] = rot.c() * sdk - rot.s() * dkp1;
+    // Update the 2x2 diagonal block by the symmetric change delta, applied with opposite signs to
+    // diag[k] and diag[k+1]. A similarity leaves the trace invariant, so this preserves diag[k] +
+    // diag[k+1] exactly. Forming the two new diagonal entries from independent explicit formulas
+    // (diag[k] = c^2 d_k - 2 c s e_k + s^2 d_{k+1}, diag[k+1] = s^2 d_k + 2 c s e_k + c^2 d_{k+1})
+    // instead lets the two roundings drift the trace a little on every rotation, an error that
+    // accumulates over the O(n^2) rotations of a full solve and measurably degrades the eigenvalues.
+    // Algebraically delta = s^2 (d_k - d_{k+1}) + 2 c s e_k, which is exactly d_k minus the formula above.
+    const RealScalar delta = rot.s() * (rot.s() * diff + RealScalar(2) * rot.c() * subdiag[k]);
+    // The exact (G' T G) off-diagonal, c*s*(d_k - d_{k+1}) + (c^2 - s^2)*e_k, written in the same diff
+    // form rather than via the c*sdk - s*dkp1 temporaries.
+    subdiag[k] = rot.c() * rot.s() * diff + (rot.c() * rot.c() - rot.s() * rot.s()) * subdiag[k];
+    diag[k] -= delta;
+    diag[k + 1] += delta;
 
     if (k > start) subdiag[k - 1] = rot.c() * subdiag[k - 1] - rot.s() * z;
 
@@ -851,9 +1085,17 @@
 
     // apply the givens rotation to the unit matrix Q = Q * G
     if (matrixQ) {
-      // FIXME: this operation is inefficient for RowMajor storage order.
-      Map<Matrix<Scalar, Dynamic, Dynamic, StorageOrder> > q(matrixQ, n, n);
-      q.applyOnTheRight(k, k + 1, rot);
+      // Contiguous column-major storage is rotated through a dynamic-size map: the rotation kernel then dispatches
+      // on the runtime alignment for fixed-size matrices too, and rounds as it always did. Other storage (a
+      // row-major Ref<>) is rotated through the matrix type itself.
+      EIGEN_IF_CONSTEXPR (!MatrixQType::IsRowMajor && int(MatrixQType::InnerStrideAtCompileTime) == 1) {
+        using Scalar = typename MatrixQType::Scalar;
+        Map<Matrix<Scalar, Dynamic, Dynamic, ColMajor>, Unaligned, OuterStride<>> q(
+            matrixQ->data(), matrixQ->rows(), matrixQ->cols(), OuterStride<>(matrixQ->outerStride()));
+        q.applyOnTheRight(k, k + 1, rot);
+      } else {
+        matrixQ->applyOnTheRight(k, k + 1, rot);
+      }
     }
   }
 }
diff --git a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
index fabc30d..d41ec2e 100644
--- a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
+++ b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
@@ -29,6 +29,7 @@
  *    Self-adjoint eigenvalues/eigenvectors.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_SAEIGENSOLVER_LAPACKE_H
 #define EIGEN_SAEIGENSOLVER_LAPACKE_H
@@ -85,6 +86,9 @@
 EIGEN_LAPACKE_EIG_SELFADJ(dcomplex, lapack_complex_double, double, zheev)
 EIGEN_LAPACKE_EIG_SELFADJ(scomplex, lapack_complex_float, float, cheev)
 
+#undef EIGEN_LAPACKE_EIG_SELFADJ
+#undef EIGEN_LAPACKE_EIG_SELFADJ_2
+
 }  // end namespace Eigen
 
-#endif  // EIGEN_SAEIGENSOLVER_H
+#endif  // EIGEN_SAEIGENSOLVER_LAPACKE_H
diff --git a/Eigen/src/Eigenvalues/TridiagonalBisection.h b/Eigen/src/Eigenvalues/TridiagonalBisection.h
new file mode 100644
index 0000000..e600c86
--- /dev/null
+++ b/Eigen/src/Eigenvalues/TridiagonalBisection.h
@@ -0,0 +1,559 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TRIDIAGONAL_BISECTION_H
+#define EIGEN_TRIDIAGONAL_BISECTION_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+ *
+ * \brief Selects which eigenvalues to compute in a spectral-bisection solve.
+ *
+ * Passed to TridiagonalEigenSolver::computeEigenvalues(). The Sturm-sequence
+ * bisection algorithm can compute an arbitrary contiguous subset of the
+ * spectrum, which the implicit-QR algorithm cannot. Three modes are provided:
+ *  - all(): every eigenvalue (the default),
+ *  - indices(il, iu): the eigenvalues with 0-based ascending indices in the
+ *    half-open range [il, iu) (i.e. the (iu - il) smallest starting at il),
+ *  - values(vl, vu): the eigenvalues lying in the half-open interval [vl, vu)
+ *    (lower-closed, upper-open, like indices(); an eigenvalue exactly equal to
+ *    vl is selected, one equal to vu is not). Endpoint membership is resolved
+ *    against the computed eigenvalue approximations, so an eigenvalue within
+ *    roughly \c n*eps*||T|| of an endpoint -- but not exactly on it -- may
+ *    resolve to either side of that endpoint.
+ *
+ * In every mode the computed eigenvalues are returned in non-decreasing order.
+ */
+struct EigenvalueRange {
+  enum Kind { All, ByIndex, ByValue };
+
+  Kind kind;
+  Index il;
+  Index iu;
+  // Endpoints are held as long double so values() does not silently collapse two nearby endpoints
+  // to the same number when the solver's RealScalar is long double (they are narrowed on use).
+  long double vl;
+  long double vu;
+
+  /** \returns a selector for the entire spectrum. */
+  static EigenvalueRange all() { return EigenvalueRange{All, 0, 0, 0.0L, 0.0L}; }
+
+  /** \returns a selector for the eigenvalues with 0-based indices in [il, iu). */
+  static EigenvalueRange indices(Index il, Index iu) { return EigenvalueRange{ByIndex, il, iu, 0.0L, 0.0L}; }
+
+  /** \returns a selector for the eigenvalues in the half-open interval [vl, vu). */
+  static EigenvalueRange values(long double vl, long double vu) { return EigenvalueRange{ByValue, 0, 0, vl, vu}; }
+};
+
+namespace internal {
+
+/** \internal
+ *
+ * Evaluates Sturm sequences for a real symmetric tridiagonal matrix T at a
+ * batch of shift points, using packet math to process many points in parallel.
+ *
+ * For a shift \c x the routine computes the number of eigenvalues of T that are
+ * less than \c x via the recurrence
+ *   \f$ q_0 = \alpha_0 - x,\quad q_i = (\alpha_i - \beta_{i-1}^2 / q_{i-1}) - x \f$,
+ * counting how many pivots \f$ q_i \f$ are non-positive. To avoid division by
+ * zero and overflow, every pivot that drops to or below \c pivmin is treated as
+ * a (small) negative pivot, counted, and clamped to \c -pivmin. The same guard
+ * is applied to every pivot including the first, so the scalar tail produces
+ * counts identical to the vectorized body.
+ *
+ * \param[in] alpha     diagonal of T, length \c n.
+ * \param[in] beta_sq   squared off-diagonal of T, \f$ \beta_i^2 \f$, length \c n-1.
+ * \param[in] n         dimension of T.
+ * \param[in] pivmin    smallest allowed pivot magnitude, strictly positive,
+ *                      e.g. \c safemin * max_i beta_i^2 (floored to \c safemin).
+ * \param[in] eval_points  the \c num_points shift values at which to evaluate.
+ * \param[out] count    on output \c count[j] is the number of eigenvalues of T
+ *                      less than \c eval_points[j], as an exact integer. Must
+ *                      have room for \c num_points entries.
+ */
+// Evaluates the Sturm count for \c kUnroll packets of shift points at once, fully unrolled so the
+// per-lane state (x, q, running count) stays in vector registers. The in-register count accumulates
+// in RealScalar (one padd per row, no cross-lane traffic) and is flushed into the exact int64 output
+// every kFlushPeriod rows -- comfortably before it could reach 2^digits, where RealScalar stops
+// representing consecutive integers (float: 2^24) -- so the stored counts are exact for any n. The
+// row loop is chunked on the flush period rather than testing per row, keeping the hot inner loop
+// unchanged; matrices with n below the period (the usual case) run it exactly once.
+// See tridiagonal_sturm_counts().
+template <int kUnroll, typename RealScalar>
+EIGEN_STRONG_INLINE void tridiagonal_sturm_block(const RealScalar* alpha, const RealScalar* beta_sq, Index n,
+                                                 RealScalar pivmin, const RealScalar* eval_points,
+                                                 numext::int64_t* count, Index start) {
+  using Packet = typename packet_traits<RealScalar>::type;
+  constexpr int kPacketSize = unpacket_traits<Packet>::size;
+  constexpr int kFlushShift = NumTraits<RealScalar>::digits() - 2 < 30 ? NumTraits<RealScalar>::digits() - 2 : 30;
+  constexpr Index kFlushPeriod = Index(1) << kFlushShift;
+  const Packet pivmin_p = pset1<Packet>(pivmin);
+  const Packet neg_pivmin_p = pset1<Packet>(-pivmin);
+  const Packet one_p = pset1<Packet>(RealScalar(1));
+
+  numext::int64_t* cnt = count + start;
+  Packet x[kUnroll], q[kUnroll], c[kUnroll];
+  const Packet alpha_0 = pset1<Packet>(alpha[0]);
+  EIGEN_UNROLL_LOOP
+  for (int k = 0; k < kUnroll; ++k) {
+    x[k] = ploadu<Packet>(eval_points + start + k * kPacketSize);
+    q[k] = psub(alpha_0, x[k]);
+    const Packet mask = pcmp_le(q[k], pivmin_p);
+    c[k] = pand(one_p, mask);
+    q[k] = pselect(mask, pmin(q[k], neg_pivmin_p), q[k]);
+  }
+  // Convert the in-register lane counts to the exact int64 output: overwrite on the first flush,
+  // add into the previously flushed partials thereafter. The scratch buffer lives outside the lambda:
+  // MSVC captures kPacketSize instead of reading it as a constant, rejecting the bound inside.
+  RealScalar buf[kPacketSize];
+  auto store_counts = [&](bool accumulate) {
+    EIGEN_UNROLL_LOOP
+    for (int k = 0; k < kUnroll; ++k) {
+      pstoreu(buf, c[k]);
+      EIGEN_UNROLL_LOOP
+      for (int l = 0; l < kPacketSize; ++l) {
+        if (accumulate)
+          cnt[k * kPacketSize + l] += numext::int64_t(buf[l]);
+        else
+          cnt[k * kPacketSize + l] = numext::int64_t(buf[l]);
+      }
+    }
+  };
+  bool flushed = false;
+  Index i = 1;
+  while (true) {
+    const Index i_end = numext::mini(n, i + kFlushPeriod);
+    for (; i < i_end; ++i) {
+      const Packet alpha_i = pset1<Packet>(alpha[i]);
+      const Packet beta_sq_im1 = pset1<Packet>(beta_sq[i - 1]);
+      EIGEN_UNROLL_LOOP
+      for (int k = 0; k < kUnroll; ++k) {
+        // q = (alpha_i - beta_{i-1}^2 / q) - x.
+        q[k] = psub(psub(alpha_i, pdiv(beta_sq_im1, q[k])), x[k]);
+        const Packet mask = pcmp_le(q[k], pivmin_p);
+        c[k] = padd(c[k], pand(one_p, mask));
+        q[k] = pselect(mask, pmin(q[k], neg_pivmin_p), q[k]);
+      }
+    }
+    if (i >= n) break;
+    // Flush the in-register counts (exact: at most kFlushPeriod + 1 increments so far) into the
+    // integer output and restart the accumulators. Only reached for n above the flush period.
+    store_counts(flushed);
+    EIGEN_UNROLL_LOOP
+    for (int k = 0; k < kUnroll; ++k) c[k] = pzero(c[k]);
+    flushed = true;
+  }
+  // Final conversion to the exact integer counts (adding any flushed partials).
+  store_counts(flushed);
+}
+
+template <typename RealScalar>
+void tridiagonal_sturm_counts(const RealScalar* alpha, const RealScalar* beta_sq, Index n, RealScalar pivmin,
+                              const RealScalar* eval_points, numext::int64_t* count, Index num_points) {
+  using Packet = typename packet_traits<RealScalar>::type;
+  constexpr Index kPacketSize = Index(unpacket_traits<Packet>::size);
+  // num_points is a point count and so never negative; clearing the sign bit makes that explicit to
+  // the compiler, which lets the division by the power-of-two kPacketSize lower to a shift (and tidies
+  // the trailing cascade loops) instead of emitting signed-division sign-correction code.
+  num_points &= (std::numeric_limits<Index>::max)();
+  const Index full = num_points / kPacketSize;  // number of whole packets
+
+  // Process whole packets in register-resident blocks, cascading 8 -> 4 -> 2 -> 1 so that even a
+  // small batch gets enough independent recurrences to hide the pdiv latency. Eight packets is the
+  // measured sweet spot on AVX2 (more would spill the per-lane state out of vector registers).
+  Index p = 0;
+  for (; p + 8 <= full; p += 8)
+    tridiagonal_sturm_block<8>(alpha, beta_sq, n, pivmin, eval_points, count, p * kPacketSize);
+  for (; p + 4 <= full; p += 4)
+    tridiagonal_sturm_block<4>(alpha, beta_sq, n, pivmin, eval_points, count, p * kPacketSize);
+  for (; p + 2 <= full; p += 2)
+    tridiagonal_sturm_block<2>(alpha, beta_sq, n, pivmin, eval_points, count, p * kPacketSize);
+  for (; p + 1 <= full; p += 1)
+    tridiagonal_sturm_block<1>(alpha, beta_sq, n, pivmin, eval_points, count, p * kPacketSize);
+
+  // Scalar tail for the remaining (< kPacketSize) points. The pivot recurrence is bit-identical to
+  // the packet path above; the count accumulates directly in the exact integer type.
+  for (Index j = full * kPacketSize; j < num_points; ++j) {
+    const RealScalar xj = eval_points[j];
+    RealScalar qj = alpha[0] - xj;
+    numext::int64_t cj = 0;
+    if (qj <= pivmin) {
+      ++cj;
+      qj = numext::mini(qj, -pivmin);
+    }
+    for (Index i = 1; i < n; ++i) {
+      qj = (alpha[i] - beta_sq[i - 1] / qj) - xj;
+      if (qj <= pivmin) {
+        ++cj;
+        qj = numext::mini(qj, -pivmin);
+      }
+    }
+    count[j] = cj;
+  }
+}
+
+/** \internal
+ *
+ * Runs the (\c t_hi - \c t_lo) independent bisections for a contiguous block of
+ * target eigenvalue indices in lock-step, writing the converged shift midpoints
+ * (in the internally normalized scale) to \c out[0 .. t_hi-t_lo).
+ *
+ * This is the unit of parallel work in tridiagonal_bisection(): the bisections of
+ * two disjoint index blocks share no state, so each thread owns one block and the
+ * blocks communicate only at the join. The vectorized batch evaluator keeps every
+ * lane of every active bracket busy within a block.
+ *
+ * \param[in] alpha       normalized diagonal of T (length \c n).
+ * \param[in] beta_sq     normalized squared off-diagonal (length \c n-1).
+ * \param[in] n           dimension of T.
+ * \param[in] pivmin      smallest allowed pivot magnitude (see tridiagonal_sturm_counts()).
+ * \param[in] bracket_lo  lower end of the initial search bracket (count == 0 below it).
+ * \param[in] bracket_hi  upper end of the initial search bracket (count == n above it).
+ * \param[in] t_lo, t_hi  0-based target indices for this block, half-open [t_lo, t_hi).
+ * \param[in] max_iters   maximum number of bisection steps.
+ * \param[in] abs_tol     absolute width below which a bracket is considered converged.
+ * \param[out] out        converged midpoints for indices [t_lo, t_hi); length t_hi-t_lo.
+ */
+template <typename RealScalar>
+void tridiagonal_bisection_block(const RealScalar* alpha, const RealScalar* beta_sq, Index n, RealScalar pivmin,
+                                 RealScalar bracket_lo, RealScalar bracket_hi, Index t_lo, Index t_hi, int max_iters,
+                                 RealScalar abs_tol, RealScalar* out) {
+  using ArrayType = Array<RealScalar, Dynamic, 1>;
+  using CountArrayType = Array<numext::int64_t, Dynamic, 1>;
+  const Index m = t_hi - t_lo;
+  if (m <= 0) return;
+
+  // The eigenvalue with 0-based index i is the value where count(x) crosses from <= i to > i.
+  // Counts and targets are exact 64-bit integers (see tridiagonal_sturm_counts()).
+  ArrayType lower = ArrayType::Constant(m, bracket_lo);
+  ArrayType upper = ArrayType::Constant(m, bracket_hi);
+  const CountArrayType targets = CountArrayType::LinSpaced(m, t_lo, t_hi - 1);
+  CountArrayType counts(m);
+  ArrayType mid = RealScalar(0.5) * (lower + upper);
+
+  // Each eigenvalue is recorded the iteration it first converges, using a per-element criterion that
+  // depends only on that element's own bracket. This makes the result independent of how the index
+  // range is grouped -- in particular bitwise identical for any number of threads -- because element
+  // i's converged value never depends on when its neighbors finish. (A single global convergence test
+  // would instead keep refining an already-converged eigenvalue until the slowest one in its group
+  // caught up, so the last bits would shift with the thread count.)
+  ArrayType result = mid;
+  Array<bool, Dynamic, 1> done = Array<bool, Dynamic, 1>::Constant(m, false);
+
+  // In the early iterations many eigenvalues still share a bracket, so their (sorted) midpoints are
+  // identical and the Sturm count need only be evaluated at the distinct values and scattered back.
+  // Once every midpoint is distinct the brackets only ever get finer, so we stop deduplicating and
+  // evaluate all midpoints directly, avoiding the per-iteration bookkeeping (and its unpredictable
+  // branch). Deduplication never changes the result: count(mid[i]) is unchanged. It only pays off
+  // when there are many more points than packets (otherwise the per-point kernel cost is too small
+  // to offset the bookkeeping), so the scratch is allocated only then.
+  constexpr int kPacketSize = unpacket_traits<typename packet_traits<RealScalar>::type>::size;
+  bool deduplicate = (m >= 64 * Index(kPacketSize));
+  ArrayType distinct;
+  CountArrayType counts_distinct;
+  if (deduplicate) {
+    distinct.resize(m);
+    counts_distinct.resize(m);
+  }
+  for (int iter = 0; iter < max_iters; ++iter) {
+    if (deduplicate) {
+      const RealScalar* midp = mid.data();
+      RealScalar* distp = distinct.data();
+      Index nd = 0;
+      distp[nd++] = midp[0];
+      for (Index i = 1; i < m; ++i)
+        if (midp[i] != midp[i - 1]) distp[nd++] = midp[i];
+      tridiagonal_sturm_counts<RealScalar>(alpha, beta_sq, n, pivmin, distp, counts_distinct.data(), nd);
+      const numext::int64_t* cdp = counts_distinct.data();
+      numext::int64_t* cp = counts.data();
+      Index g = 0;
+      cp[0] = cdp[g];
+      for (Index i = 1; i < m; ++i) {
+        if (midp[i] != midp[i - 1]) ++g;
+        cp[i] = cdp[g];
+      }
+      if (nd == m) deduplicate = false;  // all distinct: finer brackets stay distinct
+    } else {
+      tridiagonal_sturm_counts<RealScalar>(alpha, beta_sq, n, pivmin, mid.data(), counts.data(), m);
+    }
+    // count(mid) <= target  =>  eigenvalue is >= mid, raise the lower bound;
+    // otherwise the eigenvalue is < mid, so lower the upper bound.
+    const auto raise = (counts <= targets);
+    lower = raise.select(mid, lower);
+    upper = raise.select(upper, mid);
+    const ArrayType new_mid = RealScalar(0.5) * (lower + upper);
+    // Freeze each eigenvalue at the midpoint of its bracket the first time that bracket is tight
+    // enough (width within abs_tol) or stops moving. Already-frozen entries keep their value.
+    const auto converged = (new_mid == mid) || ((upper - lower) <= abs_tol);
+    result = (!done && converged).select(new_mid, result);
+    done = done || converged;
+    mid = new_mid;
+    if (done.all()) break;
+  }
+  // Any eigenvalue that did not converge within max_iters keeps its last midpoint, written straight
+  // into the caller's output (no aliasing temporary: select is coefficient-wise and out is disjoint).
+  Eigen::Map<ArrayType>(out, m) = done.select(result, mid);
+}
+
+/** \internal
+ *
+ * Returns the number of eigenvalues of the (normalized) symmetric tridiagonal matrix T that are
+ * strictly less than \c x, evaluated by the same pivot recurrence as tridiagonal_sturm_counts() but
+ * counting only strictly-negative pivots. This translates the endpoints of a half-open value range
+ * [vl, vu) into a target index range. The count is only reliable when \c x is farther from every
+ * eigenvalue than the recurrence's rounding displacement (~ \c n*eps*||T||): tridiagonal_bisection()
+ * therefore evaluates it at endpoints widened outward by that bound -- yielding a guaranteed
+ * superset of [vl, vu) -- and resolves exact endpoint membership afterwards, against the converged
+ * eigenvalues themselves.
+ *
+ * As in the batch evaluator, a pivot whose magnitude reaches the floor \c pivmin is replaced by
+ * +/- pivmin, keeping its sign, so the following division cannot overflow.
+ *
+ * \param[in] alpha    normalized diagonal of T (length \c n).
+ * \param[in] beta_sq  normalized squared off-diagonal (length \c n-1).
+ * \param[in] n        dimension of T.
+ * \param[in] pivmin   smallest allowed pivot magnitude (see tridiagonal_sturm_counts()).
+ * \param[in] x        the shift at which to count.
+ */
+template <typename RealScalar>
+Index tridiagonal_sturm_count_below(const RealScalar* alpha, const RealScalar* beta_sq, Index n, RealScalar pivmin,
+                                    RealScalar x) {
+  RealScalar q = alpha[0] - x;
+  Index count = (q < RealScalar(0)) ? 1 : 0;
+  if (numext::abs(q) < pivmin) q = numext::copysign(pivmin, q);
+  for (Index i = 1; i < n; ++i) {
+    q = (alpha[i] - beta_sq[i - 1] / q) - x;
+    if (q < RealScalar(0)) ++count;
+    if (numext::abs(q) < pivmin) q = numext::copysign(pivmin, q);
+  }
+  return count;
+}
+
+/** \internal
+ *
+ * Computes a subset of the eigenvalues of a real symmetric tridiagonal matrix T
+ * by Sturm-sequence spectral bisection (cf. LAPACK's xSTEBZ), accelerated by the
+ * vectorized batch evaluator tridiagonal_sturm_counts().
+ *
+ * The eigenvalues are bracketed using the Gershgorin disc theorem, then refined
+ * by running an independent bisection per requested eigenvalue, with all active
+ * brackets evaluated together in each step so the packet evaluator stays full.
+ *
+ * \param[in] diag     diagonal of T (length \c n).
+ * \param[in] subdiag  sub-diagonal of T (length \c n-1).
+ * \param[in] range    which eigenvalues to compute (see EigenvalueRange).
+ * \param[in] abs_tol  requested absolute accuracy; the effective tolerance is
+ *                     max(abs_tol, eps * ||T||). Pass 0 for full precision.
+ * \param[out] eivalues  filled with the selected eigenvalues in non-decreasing
+ *                     order; resized to the number of selected eigenvalues.
+ * \returns the number of eigenvalues written to \c eivalues.
+ */
+template <typename DiagType, typename SubdiagType, typename EivalType>
+Index tridiagonal_bisection(const DiagType& diag, const SubdiagType& subdiag, const EigenvalueRange& range,
+                            typename DiagType::Scalar abs_tol, EivalType& eivalues) {
+  using RealScalar = typename DiagType::Scalar;
+  using ArrayType = Array<RealScalar, Dynamic, 1>;
+  EIGEN_STATIC_ASSERT(NumTraits<RealScalar>::IsInteger == 0 && NumTraits<RealScalar>::IsComplex == 0,
+                      THIS_FUNCTION_IS_NOT_FOR_INTEGER_OR_COMPLEX_TYPES)
+
+  const Index n = diag.size();
+  if (n == 0) {
+    eivalues.derived().resize(0);
+    return 0;
+  }
+
+  // Normalize the matrix to O(1) to avoid overflow/underflow when squaring the
+  // off-diagonal and during the Sturm recurrence; eigenvalues scale linearly, so the
+  // scaling is undone at the very end. (The caller has already verified the input is
+  // finite.) This mirrors the uniform scaling done in SelfAdjointEigenSolver::compute().
+  RealScalar maxCoeff = diag.cwiseAbs().maxCoeff();
+  if (n >= 2) maxCoeff = numext::maxi(maxCoeff, subdiag.cwiseAbs().maxCoeff());
+
+  // Local contiguous copies of the scaled matrix data, |off-diagonal|, and its square.
+  ArrayType alpha(n), beta_abs(n - 1);
+  const auto factors = safe_scaling<RealScalar>::scale_to(alpha, diag.array(), maxCoeff);
+  if (n >= 2) safe_scaling<RealScalar>::scale_to(beta_abs, subdiag.array().abs(), maxCoeff, factors);
+  const RealScalar scale = factors.scale;
+  const ArrayType beta_sq = (n >= 2) ? ArrayType(beta_abs.square()) : ArrayType(0);
+
+  // Smallest pivot allowed during the Sturm recurrence (positive, floored so
+  // that a matrix with an all-zero off-diagonal still has pivmin > 0).
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  const RealScalar safemin = numext::maxi(RealScalar(1) / NumTraits<RealScalar>::highest(),
+                                          (RealScalar(1) + eps) * (std::numeric_limits<RealScalar>::min)());
+  const RealScalar max_beta_sq = (n >= 2) ? beta_sq.maxCoeff() : RealScalar(0);
+  const RealScalar pivmin = safemin * numext::maxi(max_beta_sq, RealScalar(1));
+
+  // Gershgorin bounds: row k has radius |beta_{k-1}| + |beta_k| (with the
+  // missing boundary off-diagonals taken as zero).
+  ArrayType radius(n);
+  if (n == 1) {
+    radius(0) = RealScalar(0);
+  } else {
+    radius(0) = beta_abs(0);
+    radius(n - 1) = beta_abs(n - 2);
+    if (n > 2) radius.segment(1, n - 2) = beta_abs.head(n - 2) + beta_abs.segment(1, n - 2);
+  }
+  RealScalar lambda_min = (alpha - radius).minCoeff();
+  RealScalar lambda_max = (alpha + radius).maxCoeff();
+
+  // Effective tolerance and outward expansion of the bracket so that
+  // count(lambda_min) == 0 and count(lambda_max) == n (cf. LAPACK xSTEBZ).
+  const RealScalar tnorm = numext::maxi(numext::abs(lambda_min), numext::abs(lambda_max));
+  // Convergence tolerance: refine each bracket to ~1 ulp of ||T||. This is the role of xSTEBZ's
+  // relative tolerance (it stops once b - a < RELFAC * ulp * max(|a|, |b|), RELFAC = 2), here
+  // specialized to the matrix norm tnorm and folded together with any absolute tolerance the caller
+  // requested.
+  // The 2*pivmin floor mirrors xSTEBZ/xLAEBZ (which converge on max(abstol, pivmin, reltol*...)):
+  // below the pivot floor the Sturm counts are meaningless anyway, and stopping there keeps the
+  // bracket midpoints out of the subnormal range, where hardware with flush-to-zero packet
+  // arithmetic (ARMv7 NEON) would evaluate them inconsistently between the packet and scalar paths.
+  abs_tol = numext::maxi(abs_tol / scale, numext::maxi(eps * tnorm, RealScalar(2) * pivmin));
+  // Widen the Gershgorin bracket so that, despite rounding in the Sturm recurrence, count() really does
+  // reach 0 at lambda_min and n at lambda_max. The n*eps*tnorm term bounds the worst-case count error
+  // accumulated over the n recurrence steps; the 2*pivmin term covers the pivot floor. The 2.1 prefactor
+  // is xSTEBZ's FUDGE factor: ideally 1 would suffice, but it is taken slightly larger to stay robust on
+  // sloppy arithmetic, and (per xSTEBZ) widening the bracket this way only loosens the initial search
+  // interval -- it has no effect on the accuracy of the converged eigenvalues.
+  const RealScalar expand = RealScalar(2.1) * (RealScalar(n) * eps * tnorm + RealScalar(2) * pivmin);
+  lambda_min -= expand;
+  lambda_max += expand;
+
+  // Determine the target indices [t_lo, t_hi) and the search bracket.
+  Index t_lo = 0, t_hi = n;
+  RealScalar bracket_lo = lambda_min, bracket_hi = lambda_max;
+  bool value_filter = false;
+  RealScalar vl_n = RealScalar(0), vu_n = RealScalar(0);
+  RealScalar end_tol_lo = RealScalar(0), end_tol_hi = RealScalar(0);
+  if (range.kind == EigenvalueRange::ByIndex) {
+    eigen_assert(range.il >= 0 && range.il <= range.iu && range.iu <= n && "invalid eigenvalue index range");
+    t_lo = range.il;
+    t_hi = range.iu;
+  } else if (range.kind == EigenvalueRange::ByValue) {
+    eigen_assert(range.vl <= range.vu && "invalid eigenvalue value range");
+    vl_n = RealScalar(range.vl) / scale;
+    vu_n = RealScalar(range.vu) / scale;
+    // A Sturm count taken exactly at an endpoint is unreliable when an eigenvalue sits there: the
+    // rounded terminal pivot's sign is arbitrary, so an eigenvalue equal to vl could be silently
+    // dropped, or one equal to vu kept, breaking the documented half-open [vl, vu) semantics.
+    // Instead, count at endpoints widened outward by a bound on the count's rounding displacement
+    // (the same form as the Gershgorin expansion above, per endpoint magnitude, plus the convergence
+    // tolerance) -- a guaranteed superset of [vl, vu) -- converge that superset, and resolve
+    // endpoint membership against the *converged* eigenvalues after the bisection (see below).
+    // An infinite endpoint (given as such, or a finite long double that narrowed to infinity in
+    // RealScalar) means unbounded on that side: the count is trivial there, and the tolerance
+    // arithmetic must not run (inf - inf = NaN would empty the result).
+    if ((numext::isfinite)(vl_n)) {
+      end_tol_lo =
+          RealScalar(2.1) * (RealScalar(n) * eps * numext::maxi(tnorm, numext::abs(vl_n)) + RealScalar(2) * pivmin) +
+          abs_tol;
+      t_lo = tridiagonal_sturm_count_below<RealScalar>(alpha.data(), beta_sq.data(), n, pivmin,
+                                                       vl_n - RealScalar(2) * end_tol_lo);
+      bracket_lo = numext::maxi(lambda_min, vl_n - RealScalar(2) * end_tol_lo);
+    } else {
+      t_lo = (vl_n < RealScalar(0)) ? 0 : n;
+    }
+    if ((numext::isfinite)(vu_n)) {
+      end_tol_hi =
+          RealScalar(2.1) * (RealScalar(n) * eps * numext::maxi(tnorm, numext::abs(vu_n)) + RealScalar(2) * pivmin) +
+          abs_tol;
+      t_hi = tridiagonal_sturm_count_below<RealScalar>(alpha.data(), beta_sq.data(), n, pivmin, vu_n + end_tol_hi);
+      bracket_hi = numext::mini(lambda_max, vu_n + RealScalar(2) * end_tol_hi);
+    } else {
+      t_hi = (vu_n > RealScalar(0)) ? n : 0;
+    }
+    value_filter = true;
+  }
+
+  const Index m = t_hi - t_lo;
+  eivalues.derived().resize(m);
+  if (m <= 0) return 0;
+
+  const int max_iters = NumTraits<RealScalar>::digits() + 2;
+  ArrayType mid_all(m);
+  RealScalar* out = mid_all.data();
+  const RealScalar* alpha_p = alpha.data();
+  const RealScalar* beta_sq_p = beta_sq.data();
+
+  // The m eigenvalues are bisected independently, so the spectrum splits cleanly across threads with
+  // a single fork/join: thread t owns the contiguous index block [t_lo + lo, t_lo + hi) and writes
+  // its converged midpoints into the disjoint slice out[lo, hi). No communication until the join.
+#if defined(EIGEN_HAS_OPENMP)
+  int nthreads = 1;
+  // Don't nest inside an existing parallel region, and only fork when there is enough work to
+  // amortize the thread overhead while still leaving each thread a SIMD-friendly chunk of points.
+  if (omp_get_num_threads() == 1) {
+    constexpr Index kPacketSize = Index(unpacket_traits<typename packet_traits<RealScalar>::type>::size);
+    // One work unit ~ one Sturm step (a packet division); kMinTaskSize is the minimum per thread.
+    // Multiply in double: the product overflows a 32-bit Index for matrices well within reach.
+    const double work = double(m) * double(n) * double(max_iters);
+    const double kMinTaskSize = 131072.0;
+    const Index work_threads = Index(work / kMinTaskSize);
+    const Index point_threads = m / (8 * kPacketSize);
+    const Index pb = numext::maxi(Index(1), numext::mini(work_threads, point_threads));
+    nthreads = int(numext::mini(pb, Index(Eigen::nbThreads())));
+  }
+  if (nthreads > 1) {
+#pragma omp parallel num_threads(nthreads)
+    {
+      const Index nt = omp_get_num_threads();
+      const Index tid = omp_get_thread_num();
+      // Balanced split: every thread gets floor(m/nt) or ceil(m/nt) consecutive indices, none empty.
+      const Index lo = tid * m / nt;
+      const Index hi = (tid + 1) * m / nt;
+      tridiagonal_bisection_block<RealScalar>(alpha_p, beta_sq_p, n, pivmin, bracket_lo, bracket_hi, t_lo + lo,
+                                              t_lo + hi, max_iters, abs_tol, out + lo);
+    }
+  } else
+#endif
+  {
+    tridiagonal_bisection_block<RealScalar>(alpha_p, beta_sq_p, n, pivmin, bracket_lo, bracket_hi, t_lo, t_hi,
+                                            max_iters, abs_tol, out);
+  }
+
+  // Enforce the documented non-decreasing order. Under uniform IEEE arithmetic the independent
+  // brackets already yield sorted midpoints, but on hardware with non-uniform subnormal handling
+  // (ARMv7, where NEON packet lanes flush to zero while the scalar VFP tail does not) neighbouring
+  // targets refined through the two paths can disagree by ~pivmin at the subnormal boundary. The
+  // cumulative max restores the invariant at O(m) cost and is a no-op for already-sorted output.
+  for (Index j = 1; j < m; ++j) out[j] = numext::maxi(out[j], out[j - 1]);
+
+  // ByValue: resolve endpoint membership against the converged eigenvalues. Comparing against both
+  // endpoints shifted DOWN by the endpoint tolerance gives every eigenvalue within that tolerance of
+  // an endpoint the documented closed/open treatment of the endpoint itself: an eigenvalue equal to
+  // vl is deterministically kept and one equal to vu deterministically dropped, however the rounded
+  // Sturm counts at the endpoints came out. Eigenvalues near (but not on) an endpoint may resolve to
+  // either side, as with LAPACK xSTEBZ, whose endpoint counts carry the same rounding ambiguity.
+  Index m_out = m;
+  if (value_filter) {
+    // Infinite endpoints pass through unshifted: every finite eigenvalue satisfies >= -inf / < +inf.
+    const RealScalar keep_lo = (numext::isfinite)(vl_n) ? vl_n - end_tol_lo : vl_n;
+    const RealScalar keep_hi = (numext::isfinite)(vu_n) ? vu_n - end_tol_hi : vu_n;
+    Index k = 0;
+    for (Index j = 0; j < m; ++j)
+      if (out[j] >= keep_lo && out[j] < keep_hi) out[k++] = out[j];
+    m_out = k;
+    if (m_out != m) eivalues.derived().resize(m_out);
+  }
+
+  // Undo the normalization.
+  eivalues = mid_all.head(m_out).matrix();
+  safe_scaling<RealScalar>::unscale_in_place(eivalues, maxCoeff, factors);
+  return m_out;
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_TRIDIAGONAL_BISECTION_H
diff --git a/Eigen/src/Eigenvalues/TridiagonalEigenSolver.h b/Eigen/src/Eigenvalues/TridiagonalEigenSolver.h
new file mode 100644
index 0000000..e62b9f7
--- /dev/null
+++ b/Eigen/src/Eigenvalues/TridiagonalEigenSolver.h
@@ -0,0 +1,389 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TRIDIAGONAL_EIGENSOLVER_H
+#define EIGEN_TRIDIAGONAL_EIGENSOLVER_H
+
+#include "./TridiagonalBisection.h"
+#include "./TridiagonalInverseIteration.h"
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \eigenvalues_module \ingroup Eigenvalues_Module
+ *
+ * \class TridiagonalEigenSolver
+ *
+ * \brief Computes eigenvalues and eigenvectors of a real symmetric tridiagonal matrix
+ *
+ * \tparam Scalar_ the (real floating-point) scalar type of the matrix, e.g. \c float or \c double.
+ *
+ * This solver computes the eigenvalues of a real symmetric tridiagonal matrix \f$ T \f$, given by
+ * its diagonal and sub-diagonal, using SIMD-accelerated, multi-threaded Sturm-sequence spectral
+ * bisection (cf. LAPACK's \c xSTEBZ), and the corresponding eigenvectors by inverse iteration
+ * (cf. LAPACK's \c xSTEIN). Unlike the implicit-QR path of
+ * SelfAdjointEigenSolver::computeFromTridiagonal(), it can compute an arbitrary contiguous subset
+ * of the spectrum -- by index range or by value range -- selected with an EigenvalueRange, and it
+ * never pays for eigenvectors that are not requested:
+ *
+ * \code
+ * TridiagonalEigenSolver<double> es;
+ * es.compute(diag, subdiag);                            // full spectrum, eigenvalues + eigenvectors
+ * es.compute(diag, subdiag, EigenvaluesOnly);           // full spectrum, eigenvalues only
+ * es.compute(diag, subdiag, ComputeEigenvectors,
+ *            EigenvalueRange::indices(0, 10));          // the 10 smallest eigenpairs
+ *
+ * // Staged: eigenvalues now, eigenvectors later (only if they turn out to be needed).
+ * es.computeEigenvalues(diag, subdiag, EigenvalueRange::values(vl, vu));
+ * es.computeEigenvectors();
+ *
+ * // Direct: eigenvectors for already-known eigenvalues.
+ * es.computeEigenvectors(diag, subdiag, eigenvalues);
+ * \endcode
+ *
+ * In every mode the computed eigenvalues are returned by eigenvalues() in non-decreasing order,
+ * one entry per selected eigenvalue, and eigenvectors() is the \c n x \c m matrix whose column
+ * \c j is a unit-norm eigenvector for \c eigenvalues()(j).
+ *
+ * Besides subset selection, bisection is typically more accurate than the QR algorithm: it
+ * resolves each eigenvalue to about one unit in the last place of \f$ \|T\| \f$ independently of
+ * the others, whereas the QR forward error accumulates through its O(n) sweeps and grows with the
+ * matrix size. (Both are backward stable; this is absolute accuracy relative to \f$ \|T\| \f$, not
+ * high relative accuracy for eigenvalues much smaller than \f$ \|T\| \f$.)
+ *
+ * The eigenvectors are those of the tridiagonal \f$ T \f$ itself; recovering eigenvectors of a
+ * dense matrix additionally requires the Householder back-transform performed by
+ * SelfAdjointEigenSolver::compute().
+ *
+ * \note The eigenvalues of a complex Hermitian tridiagonal matrix depend only on the moduli of its
+ * off-diagonal entries: it is unitarily similar (via a diagonal phase matrix) to the real symmetric
+ * tridiagonal with the same diagonal and off-diagonals \f$ |\beta_k| \f$. So to compute them, pass
+ * \c subdiag.cwiseAbs() as the real sub-diagonal. The eigenvectors, by contrast, differ from the
+ * real ones by that diagonal phase and cannot be recovered this way.
+ *
+ * \sa EigenvalueRange, SelfAdjointEigenSolver::computeFromTridiagonal(), class Tridiagonalization
+ */
+template <typename Scalar_>
+class TridiagonalEigenSolver {
+ public:
+  /** \brief Scalar type of the matrix; must be real. */
+  using Scalar = Scalar_;
+  using RealScalar = Scalar;
+  static_assert(NumTraits<Scalar>::IsComplex == 0 && NumTraits<Scalar>::IsInteger == 0,
+                "TridiagonalEigenSolver requires a real floating-point scalar type; for the eigenvalues of a complex "
+                "Hermitian tridiagonal matrix, pass subdiag.cwiseAbs() as the real sub-diagonal (see the class "
+                "documentation).");
+
+  /** \brief Type for the eigenvalues and the input diagonals: a dynamic-size column vector. */
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  /** \brief Type for the eigenvector matrix: dynamic-size, one column per selected eigenvalue. */
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic>;
+
+  /** \brief Default constructor. Call compute() before querying any result. */
+  TridiagonalEigenSolver() = default;
+
+  /** \brief Constructor pre-allocating room for the full spectrum of a matrix of dimension \a size. */
+  explicit TridiagonalEigenSolver(Index size)
+      : m_eivalues(size), m_eivec(size, size), m_diag(size), m_subdiag(size > 1 ? size - 1 : 0) {}
+
+  /** \brief Constructor; computes the eigendecomposition of the given tridiagonal matrix.
+   *
+   * Equivalent to default construction followed by compute(\a diag, \a subdiag, \a options, \a range).
+   */
+  template <typename DiagType, typename SubdiagType>
+  TridiagonalEigenSolver(const MatrixBase<DiagType>& diag, const MatrixBase<SubdiagType>& subdiag,
+                         int options = ComputeEigenvectors, const EigenvalueRange& range = EigenvalueRange::all())
+      : TridiagonalEigenSolver() {
+    compute(diag, subdiag, options, range);
+  }
+
+  /** \brief Computes the selected eigenvalues, and optionally eigenvectors, of a real symmetric
+   * tridiagonal matrix.
+   *
+   * \param[in] diag    The diagonal of the matrix \f$ T \f$ (length \c n).
+   * \param[in] subdiag The sub-diagonal of \f$ T \f$ (length \c n-1).
+   * \param[in] options Either #ComputeEigenvectors (the default) or #EigenvaluesOnly.
+   * \param[in] range   Which eigenvalues to compute (see EigenvalueRange); defaults to the whole
+   *            spectrum.
+   * \returns Reference to \c *this
+   *
+   * Equivalent to computeEigenvalues(\a diag, \a subdiag, \a range), followed -- when \a options
+   * is #ComputeEigenvectors and the eigenvalues were computed successfully -- by
+   * computeEigenvectors().
+   */
+  template <typename DiagType, typename SubdiagType>
+  TridiagonalEigenSolver& compute(const MatrixBase<DiagType>& diag, const MatrixBase<SubdiagType>& subdiag,
+                                  int options = ComputeEigenvectors,
+                                  const EigenvalueRange& range = EigenvalueRange::all()) {
+    eigen_assert((options & ~EigVecMask) == 0 && (options & EigVecMask) != EigVecMask && "invalid option parameter");
+    computeEigenvalues(diag, subdiag, range);
+    if (m_info == Success && (options & ComputeEigenvectors) == ComputeEigenvectors) computeEigenvectors();
+    return *this;
+  }
+
+  /** \brief Computes the selected eigenvalues (only) of a real symmetric tridiagonal matrix.
+   *
+   * \param[in] diag    The diagonal of the matrix \f$ T \f$ (length \c n).
+   * \param[in] subdiag The sub-diagonal of \f$ T \f$ (length \c n-1).
+   * \param[in] range   Which eigenvalues to compute (see EigenvalueRange); defaults to the whole
+   *            spectrum.
+   * \returns Reference to \c *this
+   *
+   * After the call, eigenvalues() returns the selected eigenvalues in non-decreasing order (one
+   * entry per selected eigenvalue), and info() reports \c Success, or \c NoConvergence if the
+   * input contains a non-finite entry. The tridiagonal is retained, so the eigenvectors can be
+   * obtained afterwards with computeEigenvectors() -- and need never be computed if they turn out
+   * not to be required.
+   */
+  template <typename DiagType, typename SubdiagType>
+  TridiagonalEigenSolver& computeEigenvalues(const MatrixBase<DiagType>& diag, const MatrixBase<SubdiagType>& subdiag,
+                                             const EigenvalueRange& range = EigenvalueRange::all());
+
+  /** \brief Computes eigenvectors for the eigenvalues of the preceding compute step, by inverse
+   * iteration.
+   *
+   * \returns Reference to \c *this
+   *
+   * Completes a staged solve: call it after computeEigenvalues() to compute the eigenvectors for
+   * the eigenvalues just found, using the retained tridiagonal. See
+   * computeEigenvectors(const MatrixBase<DiagType>&, const MatrixBase<SubdiagType>&, const
+   * MatrixBase<EivalsType>&) for the algorithm and its guarantees.
+   *
+   * \pre A successful computeEigenvalues() (or compute()) call.
+   */
+  TridiagonalEigenSolver& computeEigenvectors() {
+    eigen_assert(m_isInitialized && "TridiagonalEigenSolver is not initialized.");
+    eigen_assert(m_info == Success && "computeEigenvectors() requires a preceding successful eigenvalue computation");
+    computeEigenvectorsImpl();
+    return *this;
+  }
+
+  /** \brief Computes eigenvectors of a tridiagonal matrix by inverse iteration from known eigenvalues.
+   *
+   * \param[in] diag        The diagonal of the symmetric tridiagonal matrix \f$ T \f$ (length \c n).
+   * \param[in] subdiag     The sub-diagonal of \f$ T \f$ (length \c n-1).
+   * \param[in] eigenvalues The eigenvalues whose eigenvectors are wanted, in non-decreasing order
+   *            (e.g. the output of computeEigenvalues()). Length \c m \f$\le\f$ \c n.
+   * \returns Reference to \c *this
+   *
+   * Computes an eigenvector of \f$ T \f$ for each supplied eigenvalue by inverse iteration (LAPACK's
+   * xSTEIN, built on the xLAGTF / xLAGTS factorization and overflow-safe solve of the deliberately
+   * near-singular \f$ T - \lambda I \f$), reorthogonalizing within tight clusters so that a degenerate
+   * cluster yields an orthonormal basis. After the call, eigenvectors() returns the \c n x \c m matrix
+   * whose column \c j is a unit-norm eigenvector for \c eigenvalues[j], and eigenvalues() returns the
+   * supplied eigenvalues.
+   * Shifts that are insufficiently accurate at their disconnected block's scale are refined
+   * internally before iteration, without changing the eigenvalues returned by eigenvalues().
+   *
+   * \b Subsets. This is the natural companion to the subset-selecting eigenvalue path (see
+   * EigenvalueRange): pass that subset as \a eigenvalues and you get back exactly those \c m
+   * eigenvectors -- the result has one column per supplied eigenvalue and costs one
+   * inverse-iteration solve each, so you never pay for vectors you did not ask for.
+   *
+   * \note The eigenvalues must be sorted in non-decreasing order, as the cluster
+   * reorthogonalization relies on it.
+   *
+   * \note If any eigenvector fails to converge within the internal inverse-iteration step limit, the
+   * vectors are still returned but info() reports \c NoConvergence (cf. LAPACK xSTEIN).
+   *
+   * \note The inverse iteration is bit-identical for any number of threads. The eigenvectors of a
+   * numerically degenerate cluster may nonetheless differ in their last bits between a single- and a
+   * multi-threaded run, because the cluster refinement uses parallel (non-associative) matrix products;
+   * each result is an equally valid orthonormal basis of the same invariant subspace.
+   *
+   * \warning Cluster reorthogonalization is performed only \e among the supplied eigenvalues. The
+   * returned eigenvectors are always mutually orthonormal, but they are not orthogonalized against
+   * eigenvectors of a degenerate cluster that lie outside \a eigenvalues (those are never computed). If
+   * a requested subset slices through the middle of a numerically degenerate cluster, supply the whole
+   * cluster (widen the range) to obtain the correct invariant subspace. For well-separated eigenvalues,
+   * or when the subset covers each cluster entirely, this never matters.
+   *
+   * \sa computeEigenvalues(), eigenvectors()
+   */
+  template <typename DiagType, typename SubdiagType, typename EivalsType>
+  TridiagonalEigenSolver& computeEigenvectors(const MatrixBase<DiagType>& diag, const MatrixBase<SubdiagType>& subdiag,
+                                              const MatrixBase<EivalsType>& eigenvalues);
+
+  /** \brief Returns the computed eigenvalues, in non-decreasing order.
+   *
+   * \pre compute(), computeEigenvalues() or computeEigenvectors() has been called.
+   *
+   * The returned vector has one entry per \e selected eigenvalue, so a subset request yields a
+   * vector shorter than the matrix dimension. Eigenvalues are repeated according to their
+   * algebraic multiplicity.
+   */
+  const VectorType& eigenvalues() const {
+    eigen_assert(m_isInitialized && "TridiagonalEigenSolver is not initialized.");
+    return m_eivalues;
+  }
+
+  /** \brief Returns the computed eigenvectors, one column per eigenvalue.
+   *
+   * \pre The eigenvectors have been computed (compute() with #ComputeEigenvectors, or one of the
+   * computeEigenvectors() overloads).
+   *
+   * Column \c j of the returned \c n x \c m matrix is a unit-norm eigenvector of \f$ T \f$ for
+   * eigenvalues()(j); the columns are mutually orthonormal.
+   */
+  const MatrixType& eigenvectors() const {
+    eigen_assert(m_isInitialized && "TridiagonalEigenSolver is not initialized.");
+    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed.");
+    return m_eivec;
+  }
+
+  /** \brief Reports whether the computation was successful.
+   *
+   * \returns \c Success if the computation was successful, \c NoConvergence otherwise.
+   */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "TridiagonalEigenSolver is not initialized.");
+    return m_info;
+  }
+
+ protected:
+  // Sturm counts, bisection targets, and inverse-iteration thresholds are carried in the scalar type
+  // itself, so scalars narrower than float (half, bfloat16) compute in float internally: their
+  // epsilon cannot represent consecutive integer counts beyond ~1/eps (a 257-element bfloat16
+  // identity would report an eigenvalue of "5.19"), and intermediates such as the coincident-shift
+  // perturbation quantize away. Results are rounded back to Scalar on output.
+  using ComputeScalar = std::conditional_t<(NumTraits<Scalar>::digits() < NumTraits<float>::digits()), float, Scalar>;
+
+  void computeEigenvectorsImpl();
+
+  VectorType m_eivalues;
+  MatrixType m_eivec;
+  // The tridiagonal retained by the last compute step, so the staged computeEigenvectors() can
+  // re-form T - lambda*I without the caller having to keep diag/subdiag alive.
+  VectorType m_diag;
+  VectorType m_subdiag;
+  // Narrow scalars only: the unrounded float eigenvalues of the last computeEigenvalues(), kept so
+  // the staged eigenvector pass shifts by them rather than by the Scalar-rounded m_eivalues --
+  // shifts quantized to Scalar collapse neighbouring eigenvalues and yield near-parallel vectors.
+  // Empty whenever m_eivalues did not come from this solver's own bisection.
+  Matrix<ComputeScalar, Dynamic, 1> m_eivaluesc;
+  ComputationInfo m_info = InvalidInput;
+  bool m_isInitialized = false;
+  bool m_eigenvectorsOk = false;
+};
+
+template <typename Scalar_>
+template <typename DiagType, typename SubdiagType>
+TridiagonalEigenSolver<Scalar_>& TridiagonalEigenSolver<Scalar_>::computeEigenvalues(
+    const MatrixBase<DiagType>& diag, const MatrixBase<SubdiagType>& subdiag, const EigenvalueRange& range) {
+  static_assert(internal::is_same<typename DiagType::Scalar, Scalar>::value &&
+                    internal::is_same<typename SubdiagType::Scalar, Scalar>::value,
+                "diag and subdiag must have the solver's scalar type");
+  const Index n = diag.size();
+  EIGEN_UNUSED_VARIABLE(n);
+  eigen_assert(subdiag.size() == (n > 0 ? n - 1 : 0) && "sub-diagonal must have one fewer entry than the diagonal");
+
+  m_diag = diag;
+  m_subdiag = subdiag;
+  m_eigenvectorsOk = false;
+
+  // Reject non-finite input up front (cf. SelfAdjointEigenSolver::computeFromTridiagonal()): the
+  // Gershgorin bracketing below would otherwise iterate on NaN brackets and return garbage with
+  // info() == Success. allFinite() rather than a max-reduction, whose default PropagateFast
+  // semantics may not surface a NaN.
+  if (!(m_diag.allFinite() && m_subdiag.allFinite())) {
+    m_eivalues.resize(0);
+    m_eivaluesc.resize(0);
+    m_info = NoConvergence;
+    m_isInitialized = true;
+    return *this;
+  }
+
+  if (internal::is_same<Scalar, ComputeScalar>::value) {
+    internal::tridiagonal_bisection(m_diag, m_subdiag, range, RealScalar(0), m_eivalues);
+    m_eivaluesc.resize(0);
+  } else {
+    // Narrow scalar: bisect in float and round the eigenvalues back (see ComputeScalar). The
+    // unrounded values are retained for the staged eigenvector pass (see m_eivaluesc).
+    const Matrix<ComputeScalar, Dynamic, 1> cdiag = m_diag.template cast<ComputeScalar>();
+    const Matrix<ComputeScalar, Dynamic, 1> csubdiag = m_subdiag.template cast<ComputeScalar>();
+    internal::tridiagonal_bisection(cdiag, csubdiag, range, ComputeScalar(0), m_eivaluesc);
+    m_eivalues = m_eivaluesc.template cast<Scalar>();
+  }
+  m_info = Success;
+  m_isInitialized = true;
+  return *this;
+}
+
+template <typename Scalar_>
+template <typename DiagType, typename SubdiagType, typename EivalsType>
+TridiagonalEigenSolver<Scalar_>& TridiagonalEigenSolver<Scalar_>::computeEigenvectors(
+    const MatrixBase<DiagType>& diag, const MatrixBase<SubdiagType>& subdiag,
+    const MatrixBase<EivalsType>& eigenvalues) {
+  static_assert(internal::is_same<typename DiagType::Scalar, Scalar>::value &&
+                    internal::is_same<typename SubdiagType::Scalar, Scalar>::value &&
+                    internal::is_same<typename EivalsType::Scalar, Scalar>::value,
+                "diag, subdiag and eigenvalues must have the solver's scalar type");
+  const Index n = diag.size();
+  EIGEN_UNUSED_VARIABLE(n);
+  eigen_assert(subdiag.size() == (n > 0 ? n - 1 : 0) && "sub-diagonal must have one fewer entry than the diagonal");
+  eigen_assert(eigenvalues.size() <= n && "cannot request more eigenvectors than the size of the matrix");
+
+  m_diag = diag;
+  m_subdiag = subdiag;
+  m_eivalues = eigenvalues;
+  m_eivaluesc.resize(0);  // the caller's Scalar eigenvalues are authoritative here
+
+  // Reject non-finite input up front, mirroring computeEigenvalues(): inverse iteration on NaN/Inf
+  // data (or NaN shifts) would return NaN vectors with info() == Success.
+  if (!(m_diag.allFinite() && m_subdiag.allFinite() && m_eivalues.allFinite())) {
+    m_eivalues.resize(0);
+    m_eivec.resize(m_diag.size(), 0);
+    m_info = NoConvergence;
+    m_isInitialized = true;
+    m_eigenvectorsOk = false;
+    return *this;
+  }
+
+  computeEigenvectorsImpl();
+  return *this;
+}
+
+template <typename Scalar_>
+void TridiagonalEigenSolver<Scalar_>::computeEigenvectorsImpl() {
+  const Index n = m_diag.size();
+  const Index m = m_eivalues.size();
+  m_eivec.resize(n, m);
+  Index nonconv;
+  if (internal::is_same<Scalar, ComputeScalar>::value) {
+    nonconv = internal::tridiagonal_inverse_iteration(m_diag, m_subdiag, m_eivalues, m_eivec);
+    // Refine the eigenvectors of any genuinely degenerate cluster (Rayleigh-Ritz). The eigenvalues
+    // are left unchanged, and a non-degenerate spectrum is untouched.
+    internal::tridiagonal_rayleigh_ritz_refine(m_diag, m_subdiag, m_eivalues, m_eivec);
+  } else {
+    // Narrow scalar: iterate and refine in float, then round the vectors back (see ComputeScalar).
+    // Shift by the retained unrounded eigenvalues when they exist (the staged path): shifts rounded
+    // to Scalar collapse neighbouring eigenvalues and produce near-parallel vectors.
+    const Matrix<ComputeScalar, Dynamic, 1> cdiag = m_diag.template cast<ComputeScalar>();
+    const Matrix<ComputeScalar, Dynamic, 1> csubdiag = m_subdiag.template cast<ComputeScalar>();
+    const Matrix<ComputeScalar, Dynamic, 1> cw =
+        (m_eivaluesc.size() == m) ? m_eivaluesc : m_eivalues.template cast<ComputeScalar>();
+    Matrix<ComputeScalar, Dynamic, Dynamic> cvec(n, m);
+    nonconv = internal::tridiagonal_inverse_iteration(cdiag, csubdiag, cw, cvec);
+    internal::tridiagonal_rayleigh_ritz_refine(cdiag, csubdiag, cw, cvec);
+    m_eivec = cvec.template cast<Scalar>();
+  }
+
+  // Like LAPACK xSTEIN, report NoConvergence if any eigenvector failed the inverse-iteration growth
+  // test (the columns are still returned, best effort, so eigenvectors() remains usable).
+  m_info = (nonconv == 0) ? Success : NoConvergence;
+  m_isInitialized = true;
+  m_eigenvectorsOk = true;
+}
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TRIDIAGONAL_EIGENSOLVER_H
diff --git a/Eigen/src/Eigenvalues/TridiagonalInverseIteration.h b/Eigen/src/Eigenvalues/TridiagonalInverseIteration.h
new file mode 100644
index 0000000..a117d0f
--- /dev/null
+++ b/Eigen/src/Eigenvalues/TridiagonalInverseIteration.h
@@ -0,0 +1,824 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TRIDIAGONAL_INVERSE_ITERATION_H
+#define EIGEN_TRIDIAGONAL_INVERSE_ITERATION_H
+
+#include "./SelfAdjointEigenSolver.h"
+// For tridiagonal_sturm_count_below(), used to assign eigenvalues to disconnected blocks.
+#include "./TridiagonalBisection.h"
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+/** \internal
+ *
+ * Self-contained deterministic pseudo-random generator (SplitMix64) producing reproducible
+ * values in the open interval (-1, 1). Used to seed the inverse-iteration start vectors.
+ *
+ * \c internal::random draws from the global \c rand() state, which is neither reproducible
+ * across runs nor safe to call from several threads; a deterministic generator instead keeps
+ * the eigenvector signs and the per-cluster reorthogonalization stable regardless of how the
+ * columns are scheduled.
+ */
+struct inverse_iteration_rng {
+  numext::uint64_t state;
+
+  explicit inverse_iteration_rng(numext::uint64_t seed) : state(seed) {}
+
+  template <typename RealScalar>
+  RealScalar next() {
+    // SplitMix64: a strong avalanche so that consecutive per-column seeds yield well-separated
+    // (uncorrelated) start vectors -- consecutive LCG seeds would produce near-parallel starts that
+    // collapse under the cluster reorthogonalization.
+    state += 0x9E3779B97F4A7C15ULL;
+    const numext::uint64_t z = splitmix64_mix(state);
+    // Top 32 bits give a uniform integer in [0, 2^32); map to [0, 1) and then to (-1, 1).
+    // RealScalar must be float or wider: a narrower scalar overflows RealScalar(hi) to infinity
+    // (inf * 0 = NaN start vectors), which is why TridiagonalEigenSolver computes scalars narrower
+    // than float in float (see its ComputeScalar) and none of this code ever runs on them.
+    const numext::uint32_t hi = numext::uint32_t(z >> 32);
+    const RealScalar u = RealScalar(hi) * (RealScalar(1) / RealScalar(4294967296.0));
+    return RealScalar(2) * u - RealScalar(1);
+  }
+};
+
+/** \internal
+ *
+ * In-place LU factorization of the symmetric tridiagonal matrix \f$ T - \lambda I \f$ by
+ * Gaussian elimination with partial pivoting and implicit row interchanges (LAPACK's xLAGTF):
+ *   \f$ T - \lambda I = P L U \f$,
+ * with \c P a permutation, \c L unit lower bidiagonal, and \c U upper triangular with up to two
+ * non-zero super-diagonals. This is the careful factorization that makes inverse iteration on the
+ * deliberately near-singular \f$ (T - \lambda I) \f$ (\f$ \lambda \f$ \f$ \approx \f$ a true
+ * eigenvalue) robust: the pivots are never replaced here -- tiny ones are handled, when they would
+ * otherwise overflow the back-solve, by tridiagonal_lagts().
+ *
+ * On entry \a d holds the diagonal of T, and both \a du and \a dl hold the (shared) off-diagonal of
+ * the symmetric T. On exit:
+ *  - \a d   holds the \c n diagonal elements of U,
+ *  - \a du  holds the \c n-1 first super-diagonal elements of U,
+ *  - \a du2 holds the \c n-2 second super-diagonal elements of U,
+ *  - \a dl  holds the \c n-1 multipliers of L,
+ *  - \a piv[k] (k < n-1) is 1 if rows k and k+1 were interchanged at step k, 0 otherwise.
+ *
+ * \param[in,out] d   diagonal (length \c n).
+ * \param[in,out] du  first super-diagonal (length \c n-1, indices 0..n-2).
+ * \param[in,out] dl  sub-diagonal / L multipliers (length \c n-1, indices 0..n-2).
+ * \param[out]    du2 second super-diagonal of U (length \c n-2, indices 0..n-3).
+ * \param[out]    piv row-interchange flags (length \c n).
+ * \param[in]     lambda the shift \f$ \lambda \f$.
+ * \param[in]     n      dimension of T.
+ */
+template <typename RealScalar>
+void tridiagonal_lagtf(RealScalar* d, RealScalar* du, RealScalar* dl, RealScalar* du2, Index* piv, RealScalar lambda,
+                       Index n) {
+  d[0] -= lambda;
+  piv[n - 1] = 0;
+  if (n == 1) return;
+
+  RealScalar scale1 = numext::abs(d[0]) + numext::abs(du[0]);
+  for (Index k = 0; k < n - 1; ++k) {
+    d[k + 1] -= lambda;
+    RealScalar scale2 = numext::abs(dl[k]) + numext::abs(d[k + 1]);
+    if (k < n - 2) scale2 += numext::abs(du[k + 1]);
+    // Scaled magnitudes of the two candidate pivots; pick the larger (partial pivoting).
+    const RealScalar piv1 = numext::is_exactly_zero(d[k]) ? RealScalar(0) : numext::abs(d[k]) / scale1;
+    if (numext::is_exactly_zero(dl[k])) {
+      piv[k] = 0;
+      scale1 = scale2;
+      if (k < n - 2) du2[k] = RealScalar(0);
+    } else {
+      const RealScalar piv2 = numext::abs(dl[k]) / scale2;
+      if (piv2 <= piv1) {
+        // No interchange: eliminate using the diagonal pivot d[k] (non-zero, since piv2 > 0).
+        piv[k] = 0;
+        scale1 = scale2;
+        dl[k] = dl[k] / d[k];
+        d[k + 1] -= dl[k] * du[k];
+        if (k < n - 2) du2[k] = RealScalar(0);
+      } else {
+        // Interchange rows k and k+1; the sub-diagonal entry becomes the pivot.
+        piv[k] = 1;
+        const RealScalar mult = d[k] / dl[k];
+        d[k] = dl[k];
+        const RealScalar temp = d[k + 1];
+        d[k + 1] = du[k] - mult * temp;
+        if (k < n - 2) {
+          du2[k] = du[k + 1];
+          du[k + 1] = -mult * du2[k];
+        }
+        du[k] = temp;
+        dl[k] = mult;
+      }
+    }
+  }
+}
+
+/** \internal
+ *
+ * Overflow-safe solution of \f$ (T - \lambda I) x = b \f$ from the xLAGTF factorization
+ * \f$ T - \lambda I = P L U \f$ (LAPACK's xLAGTS with JOB = -1). The right-hand side \a b is
+ * overwritten with the solution. Diagonal elements of \c U that are so small the back-solve would
+ * overflow are perturbed (by a quantity of order \f$ \mathrm{eps} \cdot \|U\| \f$, with the sign of
+ * the pivot, doubling until safe) -- exactly the situation produced by inverse iteration, where
+ * \f$ \lambda \f$ is intentionally a near-eigenvalue and \f$ U \f$ is nearly singular.
+ *
+ * \param[in]     d   diagonal of U (length \c n).
+ * \param[in]     rcp elementwise reciprocal \c 1/d (length \c n), precomputed once by the caller with
+ *                    an exact division and reused across the inverse-iteration solves. Entries for a
+ *                    vanishing pivot may be \c inf; they are only consumed on the fast path, which is
+ *                    not taken for such pivots.
+ * \param[in]     du  first super-diagonal of U (length \c n-1).
+ * \param[in]     dl  sub-diagonal multipliers of L (length \c n-1).
+ * \param[in]     du2 second super-diagonal of U (length \c n-2).
+ * \param[in]     piv row-interchange flags from tridiagonal_lagtf() (length \c n).
+ * \param[in,out] b   right-hand side on input, solution on output (length \c n).
+ * \param[in]     n   dimension of T.
+ */
+template <typename RealScalar>
+void tridiagonal_lagts(const RealScalar* d, const RealScalar* rcp, const RealScalar* du, const RealScalar* dl,
+                       const RealScalar* du2, const Index* piv, RealScalar* b, Index n) {
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  const RealScalar sfmin = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar bignum = RealScalar(1) / sfmin;
+
+  // Perturbation floor: eps times the largest magnitude entry of U.
+  using ArrayBuf = Map<const Array<RealScalar, Dynamic, 1>>;
+  RealScalar tol = ArrayBuf(d, n).abs().maxCoeff();
+  if (n > 1) tol = numext::maxi(tol, ArrayBuf(du, n - 1).abs().maxCoeff());
+  if (n > 2) tol = numext::maxi(tol, ArrayBuf(du2, n - 2).abs().maxCoeff());
+  tol *= eps;
+  if (numext::is_exactly_zero(tol)) tol = eps;
+
+  // Forward substitution: apply P then L^{-1}. Written branchlessly in the (data-dependent, roughly
+  // 50/50) pivot-interchange flag so a misprediction cannot stall the serial recurrence; both arms
+  // are evaluated and selected, reproducing the two branches bit for bit.
+  for (Index k = 1; k < n; ++k) {
+    const RealScalar dlk = dl[k - 1];
+    const RealScalar bkm1 = b[k - 1];
+    const RealScalar bk = b[k];
+    const bool interchange = piv[k - 1] != 0;
+    b[k - 1] = interchange ? bk : bkm1;
+    b[k] = interchange ? (bkm1 - dlk * bk) : (bk - dlk * bkm1);
+  }
+
+  // Back substitution: solve U x = b. Away from the singularity the pivot is safe and the quotient is
+  // a reciprocal multiply (rcp[k] = 1/d[k], exact and precomputed once for all the solves); only a
+  // dangerously small pivot -- the rare near-singular element of the deliberately singular system --
+  // falls back to the LAPACK xLAGTS perturbation/rescale with a true division. The guard is written so
+  // the fast path is taken exactly when the original would divide by the unperturbed pivot, and is
+  // virtually always predicted taken.
+  for (Index k = n - 1; k >= 0; --k) {
+    RealScalar temp = b[k];
+    if (k <= n - 2) temp -= du[k] * b[k + 1];
+    if (k <= n - 3) temp -= du2[k] * b[k + 2];
+    const RealScalar ak = d[k];
+    const RealScalar absak = numext::abs(ak);
+    if (EIGEN_PREDICT_TRUE(absak >= RealScalar(1) || (absak >= sfmin && numext::abs(temp) <= absak * bignum))) {
+      b[k] = temp * rcp[k];
+    } else {
+      // Tiny pivot: perturb (or rescale) exactly as LAPACK xLAGTS so the quotient cannot overflow.
+      RealScalar a = ak;
+      RealScalar t = temp;
+      RealScalar pert = (a >= RealScalar(0)) ? tol : -tol;
+      while (true) {
+        const RealScalar aa = numext::abs(a);
+        if (aa < RealScalar(1)) {
+          if (aa < sfmin) {
+            if (numext::is_exactly_zero(aa) || numext::abs(t) * sfmin > aa) {
+              a += pert;
+              pert *= RealScalar(2);
+              continue;
+            } else {
+              t *= bignum;
+              a *= bignum;
+            }
+          } else if (numext::abs(t) > aa * bignum) {
+            a += pert;
+            pert *= RealScalar(2);
+            continue;
+          }
+        }
+        break;
+      }
+      b[k] = t / a;
+    }
+  }
+}
+
+/** \internal
+ *
+ * Computes the eigenvectors for one contiguous block of columns [\a j_lo, \a j_hi) of a real
+ * symmetric tridiagonal matrix T by inverse iteration. This is the unit of parallel work in
+ * tridiagonal_inverse_iteration(): the block boundaries are aligned to cluster boundaries
+ * (\c clstart[j_lo]==j_lo, and likewise \a j_hi), so the intra-cluster modified Gram-Schmidt for
+ * any column in the block references only earlier columns of the same block. Two disjoint blocks
+ * therefore share no state, and the result is independent of how the columns are partitioned -- in
+ * particular bit-identical for any number of threads.
+ *
+ * The per-column shifts \a xj_scaled and cluster starts \a clstart are precomputed once by the
+ * caller (see tridiagonal_inverse_iteration()) so this routine reproduces the serial sweep exactly.
+ *
+ * \param[in]  sdiag     normalized diagonal of T (length \c n).
+ * \param[in]  ssub      normalized sub-diagonal of T (length \c n-1).
+ * \param[in]  xj_scaled per-column normalized, perturbed shifts (length \c m).
+ * \param[in]  clstart   per-column index of the first column of its cluster (length \c m).
+ * \param[in]  n         dimension of T.
+ * \param[in]  onenrm    infinity norm of the normalized T (strictly positive).
+ * \param[in]  dtpcrt    inverse-iteration growth threshold.
+ * \param[in]  maxits    maximum inverse-iteration steps per column.
+ * \param[in]  extra     number of safety iterations past the growth threshold.
+ * \param[out] eivecs    eigenvectors; only columns [\a j_lo, \a j_hi) are written (sized \c n x \c m).
+ * \param[in]  j_lo,j_hi half-open range of columns to compute, aligned to cluster boundaries.
+ * \returns the number of columns in the block that did not converge within \a maxits iterations.
+ */
+template <typename RealScalar, typename EivecType>
+Index tridiagonal_inverse_iteration_block(const RealScalar* sdiag, const RealScalar* ssub, const RealScalar* xj_scaled,
+                                          const Index* clstart, Index n, RealScalar onenrm, RealScalar dtpcrt,
+                                          int maxits, int extra, EivecType& eivecs, Index j_lo, Index j_hi) {
+  using RealVectorType = Matrix<RealScalar, Dynamic, 1>;
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+
+  // Work arrays for the LU factors of T - xj*I (reused across the block's columns) and the iterate.
+  // lu_rcp holds the exact reciprocal of the U diagonal, computed once per factorization and reused by
+  // the inverse-iteration back-solves. Being locals, each thread gets its own copy.
+  RealVectorType lu_d(n), lu_dl(n), lu_du(n), lu_du2(n), lu_rcp(n), b(n);
+  Matrix<Index, Dynamic, 1> piv(n);
+
+  Index nonconv = 0;  // columns that exhausted maxits without satisfying the growth test
+  for (Index j = j_lo; j < j_hi; ++j) {
+    const RealScalar xj = xj_scaled[j];
+    const Index gpind = clstart[j];  // first column of j's cluster (>= j_lo by block alignment)
+
+    // Factor T - xj*I = P L U once; the inverse-iteration loop reuses it.
+    lu_d = Map<const RealVectorType>(sdiag, n);
+    lu_du.head(n - 1) = Map<const RealVectorType>(ssub, n - 1);
+    lu_dl.head(n - 1) = Map<const RealVectorType>(ssub, n - 1);
+    tridiagonal_lagtf<RealScalar>(lu_d.data(), lu_du.data(), lu_dl.data(), lu_du2.data(), piv.data(), xj, n);
+    // Exact reciprocals of the U diagonal (pdiv, not the approximate preciprocal of cwiseInverse());
+    // a vanishing pivot yields inf, which the back-solve fast path never consumes.
+    lu_rcp.array() = RealScalar(1) / lu_d.array();
+
+    // Deterministic pseudo-random start vector (seeded per column for thread independence).
+    inverse_iteration_rng rng(numext::uint64_t(j) + 1);
+    for (Index i = 0; i < n; ++i) b[i] = rng.template next<RealScalar>();
+
+    int nrmchk = 0;
+    bool converged = false;
+    for (int its = 0; its < maxits; ++its) {
+      // Scale the right-hand side so the near-singular solve neither overflows nor underflows.
+      const RealScalar bmax = b.cwiseAbs().maxCoeff();
+      if (numext::is_exactly_zero(bmax)) break;  // degenerate iterate; cannot grow -> not converged
+      const RealScalar target = RealScalar(n) * onenrm * numext::maxi(eps, numext::abs(lu_d[n - 1]));
+      const RealScalar scl = target / bmax;
+      if (EIGEN_PREDICT_TRUE(scl >= (std::numeric_limits<RealScalar>::min)())) {
+        b *= scl;
+      } else {
+        // scl underflowed (huge iterate from a shift within ~pivmin of an exact eigenvalue). A
+        // subnormal or flushed-to-zero scale would zero the iterate on flush-to-zero hardware
+        // (ARMv7 NEON), so scale in two in-range steps instead.
+        b /= bmax;
+        b *= target;
+      }
+      tridiagonal_lagts<RealScalar>(lu_d.data(), lu_rcp.data(), lu_du.data(), lu_dl.data(), lu_du2.data(), piv.data(),
+                                    b.data(), n);
+
+      // Modified Gram-Schmidt against the already-accepted eigenvectors of this cluster.
+      for (Index i = gpind; i < j; ++i) b -= b.dot(eivecs.col(i)) * eivecs.col(i);
+
+      const RealScalar nrm = b.cwiseAbs().maxCoeff();
+      if (nrm < dtpcrt) continue;          // not yet grown into the eigenvector; iterate
+      if (++nrmchk < extra + 1) continue;  // a couple of safety iterations past the threshold
+      converged = true;
+      break;
+    }
+    // LAPACK xSTEIN reports vectors that never satisfied the growth test; mirror that. The column is
+    // still written (best effort), but the caller surfaces the count as ComputationInfo::NoConvergence.
+    if (!converged) ++nonconv;
+
+    // Normalize to unit 2-norm with a deterministic sign (largest-magnitude entry positive). The
+    // iterate can carry huge entries (~1/eps times the start) on a nearly singular solve, so scale
+    // before taking the norm -- otherwise squaredNorm() would overflow and zero out the vector.
+    Index jmax = 0;
+    const RealScalar binf = b.cwiseAbs().maxCoeff(&jmax);
+    safe_scaling<RealScalar>::scale_to(b, b, binf);
+    const RealScalar nrm2 = b.norm();
+    RealScalar scl = numext::is_exactly_zero(nrm2) ? RealScalar(1) : RealScalar(1) / nrm2;
+    if (b[jmax] < RealScalar(0)) scl = -scl;
+    eivecs.col(j) = b * scl;
+  }
+  return nonconv;
+}
+
+/** \internal
+ *
+ * Inverse-iteration driver for a numerically \e connected symmetric tridiagonal matrix T -- one
+ * with no negligible couplings, so a single normalization scale and perturbation floor are valid
+ * for every row (LAPACK's xSTEIN core, built on tridiagonal_lagtf() / tridiagonal_lagts()). For
+ * each requested eigenvalue \f$ \lambda_j \f$ the routine factors \f$ T - \lambda_j I \f$ and
+ * applies a few steps of inverse iteration from a deterministic pseudo-random start,
+ * reorthogonalizing (modified Gram-Schmidt) against the eigenvectors of any tightly clustered
+ * neighbours so that a degenerate cluster yields an orthonormal basis.
+ *
+ * Callers go through tridiagonal_inverse_iteration(), which first splits the matrix at negligible
+ * couplings and dispatches each numerically disconnected block here with its own scale.
+ *
+ * \param[in]  diag    diagonal of T (length \c n).
+ * \param[in]  subdiag sub-diagonal of T (length \c n-1).
+ * \param[in]  eivals  the eigenvalues whose eigenvectors are wanted, non-decreasing (length \c m).
+ * \param[out] eivecs  filled with the \c m eigenvectors as its columns (must be sized \c n x \c m);
+ *                     column \c j is a unit-norm eigenvector for \c eivals[j].
+ * \returns the number of eigenvectors that did not converge within the inverse-iteration step limit
+ *          (0 on full success); the caller maps a non-zero count to ComputationInfo::NoConvergence.
+ */
+template <typename DiagType, typename SubdiagType, typename EivalType, typename EivecType>
+Index tridiagonal_inverse_iteration_connected(const DiagType& diag, const SubdiagType& subdiag, const EivalType& eivals,
+                                              EivecType& eivecs) {
+  using RealScalar = typename DiagType::Scalar;
+  EIGEN_STATIC_ASSERT(NumTraits<RealScalar>::IsInteger == 0 && NumTraits<RealScalar>::IsComplex == 0,
+                      THIS_FUNCTION_IS_NOT_FOR_INTEGER_OR_COMPLEX_TYPES)
+
+  const Index n = diag.size();
+  const Index m = eivals.size();
+  if (n == 0 || m == 0) return 0;
+  if (n == 1) {
+    eivecs.setOnes();
+    return 0;
+  }
+
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+
+  // Normalize T (and the shifts) to O(1) so the deliberately near-singular factor/solve cannot
+  // overflow or underflow; eigenvectors are invariant under this uniform scaling.
+  const RealScalar maxCoeff = numext::maxi(diag.cwiseAbs().maxCoeff(), subdiag.cwiseAbs().maxCoeff());
+  Matrix<RealScalar, Dynamic, 1> sdiag(n), ssub(n - 1);
+  const auto factors = safe_scaling<RealScalar>::scale_to(sdiag, diag, maxCoeff);
+  safe_scaling<RealScalar>::scale_to(ssub, subdiag, maxCoeff, factors);
+  Matrix<RealScalar, Dynamic, 1> xj_scaled(m);
+  safe_scaling<RealScalar>::scale_to(xj_scaled, eivals, maxCoeff, factors);
+  if (maxCoeff > RealScalar(0) && maxCoeff < (std::numeric_limits<RealScalar>::min)()) {
+    // The first scale is clamped to normal range. Finish normalization in a second finite step
+    // so the absolute pivot floor and growth threshold still see an O(1) matrix.
+    const RealScalar scaledMax = numext::maxi(sdiag.cwiseAbs().maxCoeff(), ssub.cwiseAbs().maxCoeff());
+    const auto remaining = safe_scaling<RealScalar>::scale_in_place(sdiag, scaledMax);
+    safe_scaling<RealScalar>::scale_in_place(ssub, scaledMax, remaining);
+    safe_scaling<RealScalar>::scale_in_place(xj_scaled, scaledMax, remaining);
+  }
+
+  // Infinity norm of the scaled T: max_i (|e_{i-1}| + |d_i| + |e_i|), missing boundary off-diagonals zero.
+  RealScalar onenrm = numext::abs(sdiag[0]) + numext::abs(ssub[0]);
+  onenrm = numext::maxi(onenrm, numext::abs(sdiag[n - 1]) + numext::abs(ssub[n - 2]));
+  if (n > 2)
+    onenrm = numext::maxi(onenrm, (ssub.head(n - 2).array().abs() + sdiag.segment(1, n - 2).array().abs() +
+                                   ssub.segment(1, n - 2).array().abs())
+                                      .maxCoeff());
+  if (numext::is_exactly_zero(onenrm)) onenrm = RealScalar(1);  // T == 0: any orthonormal basis works
+
+  // Cluster threshold and convergence threshold (LAPACK xSTEIN constants).
+  const RealScalar ortol = RealScalar(1e-3) * onenrm;
+  const RealScalar dtpcrt = numext::sqrt(RealScalar(0.1) / RealScalar(n));
+  const int maxits = 5;
+  const int extra = 2;
+
+  // Pre-pass (sequential, O(m)): the perturbed, scaled shift xj_scaled[j] and the cluster start
+  // clstart[j] (index of the first eigenvalue of j's cluster). Reproduced exactly as the serial sweep
+  // would, so the parallel column blocks below match the serial result bit for bit. A shift sitting on
+  // top of its predecessor is nudged up by pertol so the two factorizations stay distinct; a gap larger
+  // than ortol starts a new cluster (within which the eigenvectors are reorthogonalized). The
+  // perturbation is at most ~pertol << ortol, so it never moves a column across a cluster boundary.
+  Matrix<Index, Dynamic, 1> clstart(m);
+  {
+    Index gpind = 0;
+    RealScalar xjm = RealScalar(0);  // previous (possibly perturbed) shift
+    for (Index j = 0; j < m; ++j) {
+      RealScalar xj = xj_scaled[j];
+      if (j > 0) {
+        // The xSTEIN nudge 10*eps*|xj| separates coincident shifts so their factorizations differ.
+        // Capped at a fraction of the cluster threshold: at low precision (bfloat16: 10*eps ~ 0.08)
+        // the un-capped nudge can push a shift across a cluster boundary into a neighbouring
+        // eigenspace. Shifts the cap leaves coincident still yield an orthonormal basis, via the
+        // per-cluster Gram-Schmidt on independent random starts.
+        const RealScalar pertol = numext::mini(RealScalar(10) * numext::abs(eps * xj), RealScalar(0.25) * ortol);
+        if (xj - xjm < pertol) xj = xjm + pertol;
+      }
+      if (j == 0 || numext::abs(xj - xjm) > ortol) gpind = j;
+      xj_scaled[j] = xj;
+      clstart[j] = gpind;
+      xjm = xj;
+    }
+  }
+
+  const RealScalar* sdiag_p = sdiag.data();
+  const RealScalar* ssub_p = ssub.data();
+  const RealScalar* xj_p = xj_scaled.data();
+  const Index* cl_p = clstart.data();
+
+  // Distinct clusters are independent, so the columns split across threads with a single fork/join:
+  // thread t owns a contiguous slice of columns snapped to cluster boundaries (so no cluster straddles
+  // two threads) and writes only those columns of eivecs. No communication until the join, and the
+  // result is bit-identical to the serial path for any thread count. Each thread tallies its own
+  // non-converged columns; the reduction sums them into the value returned to the caller.
+  Index nonconv = 0;
+#if defined(EIGEN_HAS_OPENMP)
+  int nthreads = 1;
+  // Don't nest inside an existing parallel region, and only fork when there is enough work to amortize
+  // the thread overhead. Each column costs ~one O(n) factorization plus a few O(n) back-solves.
+  if (omp_get_num_threads() == 1) {
+    // Work ~ m columns * n rows (a factorization plus a few O(n) back-solves each). kMinTaskSize is the
+    // minimum such work to give each thread before adding one: m*n / kMinTaskSize threads, capped at
+    // the pool size. The value is measured -- at m*n = 2*kMinTaskSize (the two-thread point) inverse
+    // iteration is already ~2x faster than serial, with the gain growing to the core count for larger n.
+    const double work = double(m) * double(n);
+    const double kMinTaskSize = 2048.0;
+    const Index work_threads = Index(work / kMinTaskSize);
+    nthreads = int(numext::maxi(Index(1), numext::mini(work_threads, Index(Eigen::nbThreads()))));
+  }
+  if (nthreads > 1) {
+#pragma omp parallel num_threads(nthreads) reduction(+ : nonconv)
+    {
+      const Index nt = omp_get_num_threads();
+      const Index tid = omp_get_thread_num();
+      // Balanced split snapped up to the next cluster boundary (clstart[j]==j marks a cluster start).
+      // Adjacent threads snap the same raw index to the same boundary, so the blocks tile [0, m)
+      // exactly; a thread whose whole share falls inside one cluster simply gets an empty block.
+      Index lo = tid * m / nt;
+      Index hi = (tid + 1) * m / nt;
+      while (lo < m && cl_p[lo] != lo) ++lo;
+      while (hi < m && cl_p[hi] != hi) ++hi;
+      nonconv += tridiagonal_inverse_iteration_block<RealScalar>(sdiag_p, ssub_p, xj_p, cl_p, n, onenrm, dtpcrt, maxits,
+                                                                 extra, eivecs, lo, hi);
+    }
+  } else
+#endif
+  {
+    nonconv = tridiagonal_inverse_iteration_block<RealScalar>(sdiag_p, ssub_p, xj_p, cl_p, n, onenrm, dtpcrt, maxits,
+                                                              extra, eivecs, 0, m);
+  }
+  return nonconv;
+}
+
+/** \internal
+ *
+ * Computes eigenvectors of a real symmetric tridiagonal matrix T by inverse iteration, given a set
+ * of already-computed eigenvalues (LAPACK's xSTEIN driver). The matrix is first split at negligible
+ * couplings into numerically disconnected diagonal blocks (xSTEBZ's splitting criterion, applied to
+ * the normalized matrix so it is scale-invariant), and each block is processed independently by
+ * tridiagonal_inverse_iteration_connected() with its own normalization scale and perturbation
+ * floor. Blocks at very different scales require this: a single global floor \f$ eps \|T\| \f$
+ * swamps the pivots of any block much smaller than \f$ \|T\| \f$ and returns arbitrary mixtures of
+ * its eigenvectors. Eigenvector components outside the owning block are exactly zero.
+ *
+ * Each requested eigenvalue is assigned to a block by capacity: per-block Sturm counts over the
+ * value interval bracketing each group of coincident requests (bounded by the midpoints to the
+ * neighbouring distinct requested values, widened by a rounding tolerance at the subset's edges)
+ * say how many of the block's eigenvalues that group may claim, and the group's copies are
+ * distributed to blocks in index order within that capacity. This reconstructs the
+ * eigenvalue-to-block pairing that LAPACK's xSTEIN receives explicitly (IBLOCK) from xSTEBZ,
+ * without requiring the caller to supply it. A request that exceeds every block's capacity
+ * (eigenvalues that belong to no block) is assigned best-effort and surfaces through the
+ * non-convergence count.
+ *
+ * The eigenvalues are assumed sorted in non-decreasing order (as produced by spectral bisection or
+ * the QR algorithm).
+ *
+ * \a eivals may be an arbitrary subset of the spectrum (e.g. a bisection range): exactly one column
+ * is produced per supplied eigenvalue. Reorthogonalization only ever runs among the supplied
+ * eigenvalues, so the output columns are mutually orthonormal but are not orthogonalized against
+ * cluster members omitted from \a eivals. A subset that splits a numerically degenerate cluster
+ * therefore returns an arbitrary (still orthonormal) basis of the requested slice rather than a
+ * canonical one; pass the whole cluster when that distinction matters.
+ *
+ * \param[in]  diag    diagonal of T (length \c n).
+ * \param[in]  subdiag sub-diagonal of T (length \c n-1).
+ * \param[in]  eivals  the eigenvalues whose eigenvectors are wanted, non-decreasing (length \c m).
+ * \param[out] eivecs  filled with the \c m eigenvectors as its columns (must be sized \c n x \c m);
+ *                     column \c j is a unit-norm eigenvector for \c eivals[j].
+ * \returns the number of eigenvectors that did not converge within the inverse-iteration step limit
+ *          (0 on full success); the caller maps a non-zero count to ComputationInfo::NoConvergence.
+ */
+template <typename DiagType, typename SubdiagType, typename EivalType, typename EivecType>
+Index tridiagonal_inverse_iteration(const DiagType& diag, const SubdiagType& subdiag, const EivalType& eivals,
+                                    EivecType& eivecs) {
+  using RealScalar = typename DiagType::Scalar;
+  using VectorType = Matrix<RealScalar, Dynamic, 1>;
+  const Index n = diag.size();
+  const Index m = eivals.size();
+  if (n == 0 || m == 0) return 0;
+
+  // Split at negligible couplings (cf. xSTEBZ): |e_k| <= eps * sqrt(|d_k|) * sqrt(|d_k+1|). The
+  // geometric-mean form is scale-invariant on its own (both sides scale linearly) and needs no
+  // additive floor: a floor expressed at any single scale falsely splits strongly connected blocks
+  // living far below that scale. Taking square roots before multiplying keeps every intermediate in
+  // range, so the comparison stays exact down to subnormal entries; a zero coupling always splits.
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  Matrix<Index, Dynamic, 1> bstart(n + 1);  // block b spans rows [bstart(b), bstart(b+1))
+  Index nblocks = 1;
+  bstart(0) = 0;
+  if (n > 1) {
+    const Array<bool, Dynamic, 1> split = (subdiag.array().abs() <= eps * (diag.head(n - 1).array().abs().sqrt() *
+                                                                           diag.tail(n - 1).array().abs().sqrt()));
+    for (Index k = 0; k + 1 < n; ++k)
+      if (split(k)) bstart(nblocks++) = k + 1;
+  }
+  bstart(nblocks) = n;
+
+  if (nblocks == 1) return tridiagonal_inverse_iteration_connected(diag, subdiag, eivals, eivecs);
+
+  // Per-block normalized data (block-local scale) for the assignment Sturm counts, and the
+  // per-block localization tolerance btol: the count's rounding-displacement bound at the block's
+  // own scale. The subset-edge windows below are widened by btol so that a requested value equal to
+  // a block eigenvalue (up to that block's rounding) is found, without a window at any other
+  // block's scale swallowing well-separated foreign eigenvalues -- a tolerance expressed at the
+  // global scale would hand a small block's eigenvalue to whichever block comes first.
+  const RealScalar safemin = numext::maxi(RealScalar(1) / NumTraits<RealScalar>::highest(),
+                                          (RealScalar(1) + eps) * (std::numeric_limits<RealScalar>::min)());
+  VectorType alpha_all(n), beta_sq_all(n), bscale(nblocks), bpivmin(nblocks), btol(nblocks);
+  RealScalar gscale = RealScalar(0);
+  for (Index b = 0; b < nblocks; ++b) {
+    const Index b0 = bstart(b), nb = bstart(b + 1) - b0;
+    RealScalar s = diag.segment(b0, nb).cwiseAbs().maxCoeff();
+    if (nb > 1) s = numext::maxi(s, subdiag.segment(b0, nb - 1).cwiseAbs().maxCoeff());
+    if (numext::is_exactly_zero(s)) s = RealScalar(1);
+    gscale = numext::maxi(gscale, s);
+    auto alpha = alpha_all.segment(b0, nb);
+    const auto factors = safe_scaling<RealScalar>::scale_to(alpha, diag.segment(b0, nb), s);
+    bscale(b) = factors.scale;
+    RealScalar max_bsq = RealScalar(0);
+    if (nb > 1) {
+      auto beta = beta_sq_all.segment(b0, nb - 1);
+      safe_scaling<RealScalar>::scale_to(beta, subdiag.segment(b0, nb - 1), s, factors);
+      beta = beta.array().square();
+      max_bsq = beta.maxCoeff();
+    }
+    bpivmin(b) = safemin * numext::maxi(max_bsq, RealScalar(1));
+    // In original units, block row sums are bounded by 3*s, independently of the chosen scaling factor.
+    btol(b) = RealScalar(2.1) * (RealScalar(3) * RealScalar(nb) * eps + RealScalar(4) * safemin) * s;
+  }
+
+  // Assign each requested eigenvalue to a block by capacity. Groups are runs of exactly-equal
+  // requested values; a block's capacity for a group is its Sturm count over the group's value
+  // interval, bounded by the midpoints to the neighbouring distinct values and, at the subset's
+  // edges, widened by a tolerance. The edge tolerance is tiered: the per-block btol first, so that
+  // exactly supplied eigenvalues can only be claimed by the block that owns them, and -- when the
+  // edge group still cannot cover its copies -- the matrix-scale gtol, which admits requested
+  // values whose error is at the scale of the whole matrix (e.g. the staged bisection's output for
+  // a block much smaller than the matrix norm). The intervals partition the requested span and
+  // adjacent intervals share their boundary evaluation, so each block eigenvalue is counted exactly
+  // once even at count knife-edges. A copy its own interval cannot supply is carried into the next
+  // interval; copies left at the end pair up with the blocks holding leftover span capacity (a
+  // miscount that let a block absorb a foreign copy freed exactly one such slot elsewhere).
+  const RealScalar gtol = RealScalar(2.1) * (RealScalar(3) * RealScalar(n) * eps + RealScalar(4) * safemin) * gscale;
+  Matrix<Index, Dynamic, 1> blockof(m), assigned(nblocks), caps(nblocks), below_prev(nblocks), below_cur(nblocks),
+      below_edge(nblocks), carry(m), carry_next(m);
+  assigned.setZero();
+  Matrix<Index, Dynamic, 1> local_index(m);
+  Array<bool, Dynamic, 1> claimed = Array<bool, Dynamic, 1>::Constant(n, false);
+  // Sturm count over block b of its eigenvalues strictly below the unnormalized shift x (normalized
+  // by the block's own scale, as the block's alpha/beta data is).
+  auto count_below = [&](Index b, RealScalar x) -> Index {
+    const Index b0 = bstart(b), nb = bstart(b + 1) - b0;
+    return tridiagonal_sturm_count_below<RealScalar>(alpha_all.data() + b0, beta_sq_all.data() + b0, nb, bpivmin(b),
+                                                     x / bscale(b));
+  };
+  for (Index b = 0; b < nblocks; ++b) below_prev(b) = count_below(b, eivals[0] - btol(b));
+  below_edge = below_prev;
+  Index ncarry = 0;
+  Index g_begin = 0;
+  while (g_begin < m) {
+    Index g_end = g_begin + 1;
+    while (g_end < m && !(eivals[g_begin] < eivals[g_end])) ++g_end;
+    // Upper boundary: midpoint to the next distinct value, or the per-block widened edge at the end.
+    const bool first = (g_begin == 0);
+    const bool last = (g_end >= m);
+    const RealScalar mid_bound =
+        last ? RealScalar(0) : RealScalar(0.5) * eivals[g_end - 1] + RealScalar(0.5) * eivals[g_end];
+    bool widened = false;
+    while (true) {
+      Index total = 0;
+      for (Index b = 0; b < nblocks; ++b) {
+        const RealScalar bound = last ? eivals[m - 1] + (widened ? gtol : btol(b)) : mid_bound;
+        below_cur(b) = count_below(b, bound);
+        caps(b) = numext::maxi(Index(0), below_cur(b) - below_prev(b));
+        total += caps(b);
+      }
+      // Retry an edge group once with the matrix-scale tolerance if the block-scale windows left it
+      // short; interior deficits are handled by the carry chain instead.
+      if (widened || !(first || last) || total >= g_end - g_begin + (last ? ncarry : 0)) break;
+      widened = true;
+      if (first) {
+        for (Index b = 0; b < nblocks; ++b) below_prev(b) = count_below(b, eivals[0] - gtol);
+        below_edge = below_prev;
+      }
+    }
+    // The group's own copies first, then the carried ones; whatever finds no capacity carries on.
+    Index ncarry_next = 0;
+    for (Index pass = 0; pass < 2; ++pass) {
+      const Index count = (pass == 0) ? g_end - g_begin : ncarry;
+      for (Index c = 0; c < count; ++c) {
+        const Index j = (pass == 0) ? g_begin + c : carry(c);
+        Index chosen = -1;
+        for (Index b = 0; b < nblocks && chosen < 0; ++b)
+          if (caps(b) > 0) chosen = b;
+        if (chosen < 0) {
+          carry_next(ncarry_next++) = j;
+          continue;
+        }
+        const Index index = below_cur(chosen) - caps(chosen);
+        local_index(j) = index;
+        claimed(bstart(chosen) + index) = true;
+        --caps(chosen);
+        ++assigned(chosen);
+        blockof(j) = chosen;
+      }
+    }
+    carry.swap(carry_next);
+    ncarry = ncarry_next;
+    below_prev = below_cur;
+    g_begin = g_end;
+  }
+  // Leftover copies: first blocks with leftover span capacity, then any block with spare rows.
+  for (Index c = 0; c < ncarry; ++c) {
+    const Index j = carry(c);
+    Index chosen = -1;
+    for (Index b = 0; b < nblocks && chosen < 0; ++b)
+      if (below_cur(b) - below_edge(b) - assigned(b) > 0) chosen = b;
+    if (chosen < 0)
+      for (Index b = 0; b < nblocks && chosen < 0; ++b)
+        if (bstart(b + 1) - bstart(b) - assigned(b) > 0) chosen = b;
+    if (chosen < 0) chosen = 0;
+    {
+      const Index b0 = bstart(chosen), nb = bstart(chosen + 1) - b0;
+      Index index = numext::mini(below_edge(chosen), nb - 1);
+      while (index < nb && claimed(b0 + index)) ++index;
+      if (index == nb) {
+        index = 0;
+        while (index < nb && claimed(b0 + index)) ++index;
+      }
+      if (index == nb) {
+        eivecs.setZero();
+        return m;
+      }
+      local_index(j) = index;
+      claimed(b0 + index) = true;
+    }
+    ++assigned(chosen);
+    blockof(j) = chosen;
+  }
+
+  // Run each block independently and scatter its columns; rows outside the block stay exactly zero.
+  eivecs.setZero();
+  Index nonconv = 0;
+  VectorType wloc, refined, endpoints;
+  Matrix<numext::int64_t, Dynamic, 1> counts;
+  Matrix<Index, Dynamic, 1> indices;
+  Matrix<RealScalar, Dynamic, Dynamic> vloc;
+  Matrix<Index, Dynamic, 1> colmap(m);
+  for (Index b = 0; b < nblocks; ++b) {
+    const Index b0 = bstart(b), nb = bstart(b + 1) - b0;
+    Index mb = 0;
+    for (Index j = 0; j < m; ++j)
+      if (blockof(j) == b) colmap(mb++) = j;
+    if (mb == 0) continue;
+    wloc.resize(mb);
+    for (Index k = 0; k < mb; ++k) wloc(k) = eivals[colmap(k)];
+    vloc.resize(nb, mb);
+    const VectorType bdiag = diag.segment(b0, nb);
+    const VectorType bsub = subdiag.segment(b0, nb > 1 ? nb - 1 : 0);
+    if (nb > 1) {
+      // Retain the capacity assignment, including multiplicities across blocks. As in LAPACK
+      // xSTEBZ, use block-local bisection accuracy rather than a global reorthogonalization floor.
+      indices.resize(mb);
+      for (Index k = 0; k < mb; ++k) indices(k) = local_index(colmap(k));
+      std::sort(indices.data(), indices.data() + mb);
+      endpoints.resize(2 * mb);
+      counts.resize(2 * mb);
+      endpoints.head(mb) = (wloc.array() - btol(b)) / bscale(b);
+      endpoints.tail(mb) = (wloc.array() + btol(b)) / bscale(b);
+      tridiagonal_sturm_counts(alpha_all.data() + b0, beta_sq_all.data() + b0, nb, bpivmin(b), endpoints.data(),
+                               counts.data(), 2 * mb);
+      bool needs_refinement = false;
+      // A supplied shift is locally resolved if its rounding-sized interval contains the
+      // assigned eigenvalue index. This also detects repeated coarse shifts claiming one root.
+      for (Index k = 0; k < mb && !needs_refinement; ++k) {
+        needs_refinement = counts(k) > indices(k) || counts(mb + k) <= indices(k);
+      }
+      if (needs_refinement) {
+        for (Index first = 0; first < mb;) {
+          Index last = first + 1;
+          while (last < mb && indices(last) == indices(last - 1) + 1) ++last;
+          tridiagonal_bisection(bdiag, bsub, EigenvalueRange::indices(indices(first), indices(last - 1) + 1),
+                                RealScalar(0), refined);
+          wloc.segment(first, last - first) = refined;
+          first = last;
+        }
+      }
+    }
+    nonconv += tridiagonal_inverse_iteration_connected(bdiag, bsub, wloc, vloc);
+    for (Index k = 0; k < mb; ++k) eivecs.col(colmap(k)).segment(b0, nb) = vloc.col(k);
+  }
+  return nonconv;
+}
+
+/** \internal
+ *
+ * Rayleigh-Ritz refinement of clustered eigenvectors produced by inverse iteration. Within a
+ * cluster (consecutive eigenvalues closer than \c 1e-3 * ||T||, matching the inverse-iteration
+ * grouping) the computed vectors form an orthonormal basis of the invariant subspace, but they are
+ * an arbitrary basis, so each \f$ (\lambda_i, v_i) \f$ pair carries a residual up to the cluster's
+ * eigenvalue spread. For each such cluster of size \f$ c > 1 \f$ this forms the \f$ c \times c \f$
+ * Rayleigh quotient \f$ B = V_c^\top T V_c \f$ (using the tridiagonal structure for \f$ T V_c \f$),
+ * diagonalizes it, and rotates the basis into the Ritz vectors \f$ V_c Q \f$ with the (more
+ * accurate) Ritz values, recovering near-machine-precision residuals.
+ *
+ * A cluster is refined only when its vectors are not already accurate (worst residual above a small
+ * multiple of eps). A group that is well separated relative to the working precision -- the common
+ * case in double precision, where \c 1e-3 * ||T|| spans many representable eigenvalues -- has
+ * individual inverse-iteration vectors that are *better* than any subspace-based Ritz basis, so
+ * refining it would increase the residual; such groups, singleton clusters, and a fully
+ * non-degenerate spectrum are left untouched.
+ *
+ * The two thresholds play complementary roles, so no separate float/double tolerances are needed.
+ * The grouping threshold \c 1e-3 * ||T|| is *relative* and precision-independent (the LAPACK xSTEIN
+ * constant): the boundary orthogonality error is ~ \c 1e3 * eps, a fixed number of ulp in either
+ * precision, and the grouping must match the driver's reorthogonalized clusters for \f$ B \f$ to be a
+ * valid projection. All precision dependence lives in the eps-scaled refinement gate: that is what
+ * skips a well-separated double cluster yet refines a genuinely degenerate float one.
+ *
+ * Only the eigenvectors are refined; the eigenvalues are left as supplied (within a degenerate
+ * cluster they already agree with the Ritz values to a few ulp, and keeping them preserves the
+ * contract that the returned vectors correspond to the given eigenvalues).
+ *
+ * \param[in]     diag    diagonal of T (length \c n).
+ * \param[in]     subdiag sub-diagonal of T (length \c n-1).
+ * \param[in]     eivals  the cluster eigenvalues, non-decreasing (length \c m); read, not modified.
+ * \param[in,out] eivecs  the \c n x \c m eigenvectors, refined in place.
+ */
+template <typename DiagType, typename SubdiagType, typename EivalType, typename EivecType>
+void tridiagonal_rayleigh_ritz_refine(const DiagType& diag, const SubdiagType& subdiag, const EivalType& eivals,
+                                      EivecType& eivecs) {
+  using RealScalar = typename DiagType::Scalar;
+  using DenseType = Matrix<RealScalar, Dynamic, Dynamic>;
+  const Index n = diag.size();
+  const Index m = eivals.size();
+  if (n < 2 || m < 2) return;
+
+  // Inf-norm of T and the cluster threshold, matching tridiagonal_inverse_iteration()'s grouping.
+  RealScalar onenrm = numext::abs(diag[0]) + numext::abs(subdiag[0]);
+  onenrm = numext::maxi(onenrm, numext::abs(diag[n - 1]) + numext::abs(subdiag[n - 2]));
+  for (Index i = 1; i < n - 1; ++i)
+    onenrm = numext::maxi(onenrm, numext::abs(subdiag[i - 1]) + numext::abs(diag[i]) + numext::abs(subdiag[i]));
+  const RealScalar ortol = RealScalar(1e-3) * onenrm;
+  if (!(ortol > RealScalar(0))) return;  // T == 0: nothing to refine
+  const RealScalar inv_onenrm = RealScalar(1) / onenrm;
+  const RealScalar refine_threshold = RealScalar(16) * NumTraits<RealScalar>::epsilon();
+
+  SelfAdjointEigenSolver<DenseType> block_solver;
+  // Per-cluster scratch, hoisted out of the loop and reused across clusters: each assignment below
+  // resizes only when a cluster is larger than any seen so far, so the common many-small-clusters case
+  // allocates once rather than per cluster. Bsym is the distinct target for the symmetrization, which
+  // also lets B + B.transpose() avoid an aliasing temporary.
+  DenseType Vc, TVc, B, Bsym;
+  Index s = 0;
+  while (s < m) {
+    Index t = s;
+    while (t + 1 < m && (eivals[t + 1] - eivals[t]) < ortol) ++t;
+    const Index c = t - s + 1;
+    if (c > 1) {
+      // Project T onto the cluster basis. T V_c via the tridiagonal structure:
+      //   (T V_c)(i,:) = e_{i-1} V_c(i-1,:) + d_i V_c(i,:) + e_i V_c(i+1,:).
+      Vc = eivecs.middleCols(s, c);  // copy so the write-back below cannot alias
+      TVc = diag.asDiagonal() * Vc;
+      TVc.topRows(n - 1) += subdiag.asDiagonal() * Vc.bottomRows(n - 1);
+      TVc.bottomRows(n - 1) += subdiag.asDiagonal() * Vc.topRows(n - 1);
+      // Worst per-vector residual in the cluster (scaled by 1/||T|| so it cannot overflow). Skip the
+      // refinement when the cluster is already at machine precision -- refining it would only add the
+      // subspace error to vectors that are individually more accurate.
+      const RealScalar cluster_resid =
+          ((TVc - Vc * eivals.segment(s, c).asDiagonal()) * inv_onenrm).colwise().norm().maxCoeff();
+      if (cluster_resid > refine_threshold) {
+        B.noalias() = Vc.transpose() * TVc;
+        Bsym = B + B.transpose();  // enforce exact symmetry (distinct target avoids an aliasing temp)
+        Bsym *= RealScalar(0.5);
+        block_solver.compute(Bsym, ComputeEigenvectors);
+        eivecs.middleCols(s, c).noalias() = Vc * block_solver.eigenvectors();
+      }
+    }
+    s = t + 1;
+  }
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_TRIDIAGONAL_INVERSE_ITERATION_H
diff --git a/Eigen/src/Eigenvalues/Tridiagonalization.h b/Eigen/src/Eigenvalues/Tridiagonalization.h
index aef8739..d85b5b1 100644
--- a/Eigen/src/Eigenvalues/Tridiagonalization.h
+++ b/Eigen/src/Eigenvalues/Tridiagonalization.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRIDIAGONALIZATION_H
 #define EIGEN_TRIDIAGONALIZATION_H
@@ -22,7 +23,11 @@
 struct TridiagonalizationMatrixTReturnType;
 template <typename MatrixType>
 struct traits<TridiagonalizationMatrixTReturnType<MatrixType>> : public traits<typename MatrixType::PlainObject> {
-  typedef typename MatrixType::PlainObject ReturnType;  // FIXME: consider using BandMatrix as ReturnType.
+  // matrixT() returns a dense n x n matrix. A band-stored alternative (e.g. a
+  // future matrixTBand() returning BandMatrix<Scalar, Dynamic, Dynamic, 1, 1>)
+  // would be ~3n storage instead of n^2, but changing this ReturnType in place
+  // would be API-breaking for callers that assume a dense matrix.
+  using ReturnType = typename MatrixType::PlainObject;
   enum { Flags = 0 };
 };
 
@@ -66,40 +71,39 @@
 class Tridiagonalization {
  public:
   /** \brief Synonym for the template parameter \p MatrixType_. */
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
 
   enum {
     Size = MatrixType::RowsAtCompileTime,
     SizeMinusOne = Size == Dynamic ? Dynamic : (Size > 1 ? Size - 1 : 1),
-    Options = internal::traits<MatrixType>::Options,
+    Options = internal::plain_object_options<MatrixType>::value,
     MaxSize = MatrixType::MaxRowsAtCompileTime,
     MaxSizeMinusOne = MaxSize == Dynamic ? Dynamic : (MaxSize > 1 ? MaxSize - 1 : 1)
   };
 
-  typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
-  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type DiagonalType;
-  typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType;
-  typedef internal::remove_all_t<typename MatrixType::RealReturnType> MatrixTypeRealView;
-  typedef internal::TridiagonalizationMatrixTReturnType<MatrixTypeRealView> MatrixTReturnType;
+  using CoeffVectorType = Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1>;
+  using DiagonalType = typename internal::plain_col_type<MatrixType, RealScalar>::type;
+  using SubDiagonalType = Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1>;
+  using MatrixTypeRealView = internal::remove_all_t<typename MatrixType::RealReturnType>;
+  using MatrixTReturnType = internal::TridiagonalizationMatrixTReturnType<MatrixTypeRealView>;
 
-  typedef std::conditional_t<NumTraits<Scalar>::IsComplex,
-                             internal::add_const_on_value_type_t<typename Diagonal<const MatrixType>::RealReturnType>,
-                             const Diagonal<const MatrixType>>
-      DiagonalReturnType;
+  using DiagonalReturnType =
+      std::conditional_t<NumTraits<Scalar>::IsComplex,
+                         internal::add_const_on_value_type_t<typename Diagonal<const MatrixType>::RealReturnType>,
+                         const Diagonal<const MatrixType>>;
 
-  typedef std::conditional_t<
-      NumTraits<Scalar>::IsComplex,
-      internal::add_const_on_value_type_t<typename Diagonal<const MatrixType, -1>::RealReturnType>,
-      const Diagonal<const MatrixType, -1>>
-      SubDiagonalReturnType;
+  using SubDiagonalReturnType =
+      std::conditional_t<NumTraits<Scalar>::IsComplex,
+                         internal::add_const_on_value_type_t<typename Diagonal<const MatrixType, -1>::RealReturnType>,
+                         const Diagonal<const MatrixType, -1>>;
 
   /** \brief Return type of matrixQ() */
-  typedef HouseholderSequence<MatrixType, internal::remove_all_t<typename CoeffVectorType::ConjugateReturnType>>
-      HouseholderSequenceType;
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, internal::remove_all_t<typename CoeffVectorType::ConjugateReturnType>>;
 
   /** \brief Default constructor.
    *
@@ -133,6 +137,21 @@
     m_isInitialized = true;
   }
 
+  /** \brief Constructor for \link InplaceDecomposition inplace decomposition \endlink
+   *
+   * \param[in,out]  matrix  Selfadjoint matrix whose tridiagonal decomposition is to be computed.
+   *
+   * When \p MatrixType is a Ref<>, the decomposition is computed within the memory of \p matrix, which then holds
+   * the packed representation returned by packedMatrix(). Otherwise this constructor behaves like
+   * Tridiagonalization(const EigenBase<InputType>&).
+   */
+  template <typename InputType>
+  explicit Tridiagonalization(EigenBase<InputType>& matrix)
+      : m_matrix(matrix.derived()), m_hCoeffs(matrix.cols() > 1 ? matrix.cols() - 1 : 1), m_isInitialized(false) {
+    internal::tridiagonalization_inplace(m_matrix, m_hCoeffs);
+    m_isInitialized = true;
+  }
+
   /** \brief Computes tridiagonal decomposition of given matrix.
    *
    * \param[in]  matrix  Selfadjoint matrix whose tridiagonal decomposition
@@ -144,7 +163,7 @@
    * reflections. The cost is \f$ 4n^3/3 \f$ flops, where \f$ n \f$ denotes
    * the size of the given matrix.
    *
-   * This method reuses of the allocated data in the Tridiagonalization
+   * This method reuses the allocated data in the Tridiagonalization
    * object, if the size of the matrix does not change.
    *
    * Example: \include Tridiagonalization_compute.cpp
@@ -306,11 +325,12 @@
 namespace internal {
 
 /** \internal
- * Performs a tridiagonal decomposition of the selfadjoint matrix \a matA in-place.
+ * Unblocked tridiagonal decomposition of the selfadjoint matrix \a matA in-place.
+ * Processes one column at a time using Level 2 BLAS operations (SYMV, SYR2).
  *
  * \param[in,out] matA On input the selfadjoint matrix. Only the \b lower triangular part is referenced.
  *                     On output, the strict upper part is left unchanged, and the lower triangular part
- *                     represents the T and Q matrices in packed format has detailed below.
+ *                     represents the T and Q matrices in packed format as detailed below.
  * \param[out]    hCoeffs returned Householder coefficients (see below)
  *
  * On output, the tridiagonal selfadjoint matrix T is stored in the diagonal
@@ -329,10 +349,10 @@
  * \sa Tridiagonalization::packedMatrix()
  */
 template <typename MatrixType, typename CoeffVectorType>
-EIGEN_DEVICE_FUNC void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) {
+EIGEN_DEVICE_FUNC void tridiagonalization_inplace_unblocked(MatrixType& matA, CoeffVectorType& hCoeffs) {
   using numext::conj;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
   Index n = matA.rows();
   eigen_assert(n == matA.cols());
   eigen_assert(n == hCoeffs.size() + 1 || n == 1);
@@ -364,6 +384,160 @@
   }
 }
 
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+/** \internal
+ * Blocked tridiagonal decomposition (analogous to LAPACK's dsytrd/dlatrd).
+ * Processes columns in panels of BlockSize, accumulating Householder reflectors
+ * and deferring the symmetric rank-2k update to use Level 3 BLAS (triangular GEMM).
+ * Falls back to the unblocked algorithm for the last (partial) panel.
+ */
+template <typename MatrixType, typename CoeffVectorType>
+void tridiagonalization_inplace_blocked(MatrixType& matA, CoeffVectorType& hCoeffs, Index nb = 16) {
+  using numext::conj;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  const Index n = matA.rows();
+  eigen_assert(n == matA.cols());
+  eigen_assert(n == hCoeffs.size() + 1);
+  eigen_assert(nb >= 2 && nb < n);
+
+  enum {
+    StorageOrder = (traits<MatrixType>::Flags & RowMajorBit) ? RowMajor : ColMajor,
+    RhsStorageOrder = (StorageOrder == ColMajor) ? RowMajor : ColMajor
+  };
+
+  // Workspace: W matrix (n x nb) for deferred update vectors, temp vector (nb) for GEMV, betas (nb).
+  using WorkMatrixType = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  WorkMatrixType W(n, nb);
+  Matrix<Scalar, Dynamic, 1> temp(nb);
+  Matrix<RealScalar, Dynamic, 1> betas(nb);
+
+  // Pre-allocate GEMM blocking workspace for the largest trailing matrix (first panel).
+  // Reused across all panels to avoid repeated heap allocations.
+  using BlockingType = gemm_blocking_space<StorageOrder, Scalar, Scalar, Dynamic, Dynamic, Dynamic>;
+  const Index maxTrailingSize = n - nb;
+  BlockingType blocking(maxTrailingSize, maxTrailingSize, nb, 1, false);
+
+  Index j0 = 0;
+  for (; j0 + nb < n - 1; j0 += nb) {
+    const Index j_end = j0 + nb;
+
+    // ---- Panel factorization (dlatrd) ----
+    // Process columns j0..j_end-1, computing Householder vectors (stored in matA)
+    // and update vectors (stored in W). The rank-2k update to the trailing
+    // submatrix is deferred until after the panel.
+    for (Index j = j0; j < j_end; ++j) {
+      const Index local_j = j - j0;
+      const Index remainingSize = n - j - 1;
+
+      // Step 1: Update column j for deferred rank-2 updates from columns j0..j-1.
+      // A(j:n-1, j) -= V * W(j,:)^H + W * V(j,:)^H
+      // where V = matA(j:n-1, j0:j-1) holds Householder vectors,
+      // and W(j:n-1, 0:lj-1) holds the corresponding update vectors.
+      if (local_j > 0) {
+        auto col_j = matA.col(j).segment(j, n - j);
+        col_j.noalias() -= matA.block(j, j0, n - j, local_j) * W.row(j).head(local_j).adjoint();
+        col_j.noalias() -= W.block(j, 0, n - j, local_j) * matA.row(j).segment(j0, local_j).adjoint();
+        // Keep diagonal real (for complex scalars; no-op for real).
+        matA.coeffRef(j, j) = numext::real(matA.coeff(j, j));
+      }
+
+      // Step 2: Compute Householder reflector for column j.
+      RealScalar beta;
+      Scalar h;
+      matA.col(j).tail(remainingSize).makeHouseholderInPlace(h, beta);
+      betas(local_j) = beta;
+      matA.col(j).coeffRef(j + 1) = Scalar(1);
+
+      auto v = matA.col(j).tail(remainingSize);
+      auto w = W.col(local_j).tail(remainingSize);
+
+      // Step 3: Compute w = conj(h) * A_eff * v where A_eff accounts for deferred updates.
+      // Start with SYMV on the stored (not yet updated) trailing submatrix.
+      w.noalias() =
+          matA.bottomRightCorner(remainingSize, remainingSize).template selfadjointView<Lower>() * (conj(h) * v);
+
+      // GEMV corrections for deferred rank-2 updates within this panel.
+      if (local_j > 0) {
+        auto V_prev = matA.block(j + 1, j0, remainingSize, local_j);
+        auto W_prev = W.block(j + 1, 0, remainingSize, local_j);
+
+        // w -= conj(h) * V_prev * (W_prev^H * v)
+        temp.head(local_j).noalias() = W_prev.adjoint() * v;
+        w.noalias() -= conj(h) * (V_prev * temp.head(local_j));
+
+        // w -= conj(h) * W_prev * (V_prev^H * v)
+        temp.head(local_j).noalias() = V_prev.adjoint() * v;
+        w.noalias() -= conj(h) * (W_prev * temp.head(local_j));
+      }
+
+      // Step 4: Half-dot correction: w -= 0.5 * conj(h) * (w^H * v) * v
+      w += (conj(h) * RealScalar(-0.5) * w.dot(v)) * v;
+
+      hCoeffs.coeffRef(j) = h;
+    }
+
+    // ---- Apply rank-2k update to trailing submatrix ----
+    // A(j_end:n-1, j_end:n-1) -= V_trail * W_trail^H + W_trail * V_trail^H
+    // using Level 3 BLAS (triangular GEMM).
+    const Index trailingSize = n - j_end;
+    if (trailingSize > 0) {
+      const Scalar* V_data = &matA.coeffRef(j_end, j0);
+      const Scalar* W_data = &W.coeffRef(j_end, 0);
+      Scalar* C_data = &matA.coeffRef(j_end, j_end);
+      const Index V_stride = matA.outerStride();
+      const Index W_stride = W.outerStride();
+      const Index C_stride = matA.outerStride();
+
+      // C -= V * W^H
+      general_matrix_matrix_triangular_product<Index, Scalar, StorageOrder, false, Scalar, RhsStorageOrder,
+                                               NumTraits<Scalar>::IsComplex, StorageOrder, 1,
+                                               Lower>::run(trailingSize, nb, V_data, V_stride, W_data, W_stride, C_data,
+                                                           1, C_stride, Scalar(-1), blocking);
+
+      // C -= W * V^H
+      general_matrix_matrix_triangular_product<Index, Scalar, StorageOrder, false, Scalar, RhsStorageOrder,
+                                               NumTraits<Scalar>::IsComplex, StorageOrder, 1,
+                                               Lower>::run(trailingSize, nb, W_data, W_stride, V_data, V_stride, C_data,
+                                                           1, C_stride, Scalar(-1), blocking);
+    }
+
+    // Restore subdiagonal entries (overwritten with 1 for Householder vectors).
+    for (Index j = j0; j < j_end; ++j) {
+      matA.coeffRef(j + 1, j) = betas(j - j0);
+    }
+  }
+
+  // ---- Process remaining columns with unblocked algorithm ----
+  if (j0 < n - 1) {
+    const Index remaining = n - j0;
+    auto trailing = matA.bottomRightCorner(remaining, remaining);
+    auto hCoeffs_tail = hCoeffs.segment(j0, remaining - 1);
+    tridiagonalization_inplace_unblocked(trailing, hCoeffs_tail);
+  }
+}
+#endif  // !EIGEN_GPU_COMPILE_PHASE
+
+/** \internal
+ * Dispatches to blocked or unblocked tridiagonalization based on matrix size.
+ * On GPU, always uses the unblocked algorithm.
+ */
+template <typename MatrixType, typename CoeffVectorType>
+EIGEN_DEVICE_FUNC void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) {
+  eigen_assert(matA.rows() == matA.cols());
+  eigen_assert(matA.rows() == hCoeffs.size() + 1 || matA.rows() == 1);
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+  EIGEN_IF_CONSTEXPR (MatrixType::RowsAtCompileTime == Dynamic || MatrixType::ColsAtCompileTime == Dynamic) {
+    if (matA.rows() >= 96) {
+      tridiagonalization_inplace_blocked(matA, hCoeffs);
+      return;
+    }
+  }
+#endif
+  tridiagonalization_inplace_unblocked(matA, hCoeffs);
+}
+
 // forward declaration, implementation at the end of this file
 template <typename MatrixType, int Size = MatrixType::ColsAtCompileTime,
           bool IsComplex = NumTraits<typename MatrixType::Scalar>::IsComplex>
@@ -395,7 +569,7 @@
  * The vectors \p diag and \p subdiag are not resized. The function
  * assumes that they are already of the correct size. The length of the
  * vector \p diag should equal the number of rows in \p mat, and the
- * length of the vector \p subdiag should be one left.
+ * length of the vector \p subdiag should be one less.
  *
  * This implementation contains an optimized path for 3-by-3 matrices
  * which is especially useful for plane fitting.
@@ -424,7 +598,7 @@
  */
 template <typename MatrixType, int Size, bool IsComplex>
 struct tridiagonalization_inplace_selector {
-  typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType HouseholderSequenceType;
+  using HouseholderSequenceType = typename Tridiagonalization<MatrixType>::HouseholderSequenceType;
   template <typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType, typename WorkSpaceType>
   static EIGEN_DEVICE_FUNC void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag,
                                     CoeffVectorType& hCoeffs, WorkSpaceType& workspace, bool extractQ) {
@@ -443,8 +617,8 @@
  */
 template <typename MatrixType>
 struct tridiagonalization_inplace_selector<MatrixType, 3, false> {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
 
   template <typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType, typename WorkSpaceType>
   static EIGEN_DEVICE_FUNC void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, CoeffVectorType&,
@@ -470,7 +644,7 @@
       subdiag[0] = beta;
       subdiag[1] = mat(2, 1) - m01 * q;
       if (extractQ) {
-        mat << 1, 0, 0, 0, m01, m02, 0, m02, -m01;
+        mat << Scalar(1), Scalar(0), Scalar(0), Scalar(0), m01, m02, Scalar(0), m02, -m01;
       }
     }
   }
@@ -481,7 +655,7 @@
  */
 template <typename MatrixType, bool IsComplex>
 struct tridiagonalization_inplace_selector<MatrixType, 1, IsComplex> {
-  typedef typename MatrixType::Scalar Scalar;
+  using Scalar = typename MatrixType::Scalar;
 
   template <typename DiagonalType, typename SubDiagonalType, typename CoeffVectorType, typename WorkSpaceType>
   static EIGEN_DEVICE_FUNC void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType&, CoeffVectorType&,
diff --git a/Eigen/src/Geometry/AlignedBox.h b/Eigen/src/Geometry/AlignedBox.h
index e97a8f2..2d82234 100644
--- a/Eigen/src/Geometry/AlignedBox.h
+++ b/Eigen/src/Geometry/AlignedBox.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // Function void Eigen::AlignedBox::transform(const Transform& transform)
 // is provided under the following license agreement:
@@ -70,13 +71,13 @@
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, AmbientDim_)
   enum { AmbientDimAtCompileTime = AmbientDim_ };
-  typedef Scalar_ Scalar;
-  typedef NumTraits<Scalar> ScalarTraits;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
-  typedef typename ScalarTraits::Real RealScalar;
-  typedef typename ScalarTraits::NonInteger NonInteger;
-  typedef Matrix<Scalar, AmbientDimAtCompileTime, 1> VectorType;
-  typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType> VectorTypeSum;
+  using Scalar = Scalar_;
+  using ScalarTraits = NumTraits<Scalar>;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
+  using RealScalar = typename ScalarTraits::Real;
+  using NonInteger = typename ScalarTraits::NonInteger;
+  using VectorType = Matrix<Scalar, AmbientDimAtCompileTime, 1>;
+  using VectorTypeSum = CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const VectorType, const VectorType>;
 
   /** Define constants to name the corners of a 1D, 2D or 3D axis aligned bounding box */
   enum CornerType {
@@ -123,8 +124,6 @@
   template <typename Derived>
   EIGEN_DEVICE_FUNC inline explicit AlignedBox(const MatrixBase<Derived>& p) : m_min(p), m_max(m_min) {}
 
-  EIGEN_DEVICE_FUNC ~AlignedBox() {}
-
   /** \returns the dimension in which the box holds */
   EIGEN_DEVICE_FUNC inline Index dim() const {
     return AmbientDimAtCompileTime == Dynamic ? m_min.size() : Index(AmbientDimAtCompileTime);
@@ -157,14 +156,14 @@
   EIGEN_DEVICE_FUNC inline VectorType&(max)() { return m_max; }
 
   /** \returns the center of the box */
-  EIGEN_DEVICE_FUNC inline const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(VectorTypeSum, RealScalar, quotient)
-      center() const {
+  EIGEN_DEVICE_FUNC inline const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(VectorTypeSum, RealScalar,
+                                                                        internal::scalar_quotient_op) center() const {
     return (m_min + m_max) / RealScalar(2);
   }
 
   /** \returns the lengths of the sides of the bounding box.
    * Note that this function does not get the same
-   * result for integral or floating scalar types: see
+   * result for integral or floating scalar types.
    */
   EIGEN_DEVICE_FUNC inline const CwiseBinaryOp<internal::scalar_difference_op<Scalar, Scalar>, const VectorType,
                                                const VectorType>
@@ -215,7 +214,7 @@
   EIGEN_DEVICE_FUNC inline VectorType sample() const {
     VectorType r(dim());
     for (Index d = 0; d < dim(); ++d) {
-      if (!ScalarTraits::IsInteger) {
+      EIGEN_IF_CONSTEXPR (!ScalarTraits::IsInteger) {
         r[d] = m_min[d] + (m_max[d] - m_min[d]) * internal::random<Scalar>(Scalar(0), Scalar(1));
       } else
         r[d] = internal::random(m_min[d], m_max[d]);
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed17..2796486 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ANGLEAXIS_H
 #define EIGEN_ANGLEAXIS_H
@@ -44,23 +45,23 @@
 namespace internal {
 template <typename Scalar_>
 struct traits<AngleAxis<Scalar_> > {
-  typedef Scalar_ Scalar;
+  using Scalar = Scalar_;
 };
 }  // namespace internal
 
 template <typename Scalar_>
 class AngleAxis : public RotationBase<AngleAxis<Scalar_>, 3> {
-  typedef RotationBase<AngleAxis<Scalar_>, 3> Base;
+  using Base = RotationBase<AngleAxis<Scalar_>, 3>;
 
  public:
   using Base::operator*;
 
   enum { Dim = 3 };
   /** the scalar type of the coefficients */
-  typedef Scalar_ Scalar;
-  typedef Matrix<Scalar, 3, 3> Matrix3;
-  typedef Matrix<Scalar, 3, 1> Vector3;
-  typedef Quaternion<Scalar> QuaternionType;
+  using Scalar = Scalar_;
+  using Matrix3 = Matrix<Scalar, 3, 3>;
+  using Vector3 = Matrix<Scalar, 3, 1>;
+  using QuaternionType = Quaternion<Scalar>;
 
  protected:
   Vector3 m_axis;
@@ -130,6 +131,21 @@
   EIGEN_DEVICE_FUNC AngleAxis& fromRotationMatrix(const MatrixBase<Derived>& m);
   EIGEN_DEVICE_FUNC Matrix3 toRotationMatrix(void) const;
 
+  /** Applies the rotation to a 3D vector using Rodrigues' formula directly,
+   * without constructing the full rotation matrix. */
+  template <typename OtherVectorType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Vector3 _transformVector(const OtherVectorType& v) const {
+    EIGEN_USING_STD(sin)
+    EIGEN_USING_STD(cos)
+    eigen_assert(v.size() == 3);
+
+    // Rodrigues' rotation formula: v' = v*cos(θ) + (k×v)*sin(θ) + k*(k·v)*(1-cos(θ))
+    const Vector3 v3(v);
+    const Scalar c = cos(m_angle);
+    const Scalar s = sin(m_angle);
+    return v3 * c + m_axis.cross(v3) * s + m_axis * (m_axis.dot(v3) * (Scalar(1) - c));
+  }
+
   /** \returns \c *this with scalar type casted to \a NewScalarType
    *
    * Note that if \a NewScalarType is equal to the current scalar type of \c *this
@@ -162,10 +178,10 @@
 
 /** \ingroup Geometry_Module
  * single precision angle-axis type */
-typedef AngleAxis<float> AngleAxisf;
+using AngleAxisf = AngleAxis<float>;
 /** \ingroup Geometry_Module
  * double precision angle-axis type */
-typedef AngleAxis<double> AngleAxisd;
+using AngleAxisd = AngleAxis<double>;
 
 /** Set \c *this from a \b unit quaternion.
  *
@@ -197,9 +213,10 @@
 template <typename Scalar>
 template <typename Derived>
 EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const MatrixBase<Derived>& mat) {
-  // Since a direct conversion would not be really faster,
-  // let's use the robust Quaternion implementation:
-  return *this = QuaternionType(mat);
+  if (mat.size() == 4) {
+    return *this = QuaternionType(mat);
+  }
+  return fromRotationMatrix(mat);
 }
 
 /**
@@ -208,7 +225,65 @@
 template <typename Scalar>
 template <typename Derived>
 EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& mat) {
-  return *this = QuaternionType(mat);
+  EIGEN_USING_STD(atan2)
+  EIGEN_USING_STD(sqrt)
+  EIGEN_STATIC_ASSERT(
+      (std::is_same<Scalar, typename Derived::Scalar>::value),
+      YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+  eigen_assert(mat.cols() == 3 && mat.rows() == 3);
+
+  const typename internal::nested_eval<Derived, 3>::type m(mat.derived());
+
+  // Skew-symmetric part gives sin(angle) * axis.
+  const Scalar sx = m.coeff(2, 1) - m.coeff(1, 2);
+  const Scalar sy = m.coeff(0, 2) - m.coeff(2, 0);
+  const Scalar sz = m.coeff(1, 0) - m.coeff(0, 1);
+  const Scalar s = sqrt(sx * sx + sy * sy + sz * sz);  // = 2*sin(angle)
+
+  // trace = 1 + 2*cos(angle)
+  const Scalar c = m.trace() - Scalar(1);  // = 2*cos(angle)
+
+  // Use atan2 for the angle: accurate at all angles including near 0 and pi.
+  m_angle = atan2(s, c);
+
+  // Use the skew-symmetric part only when sin(angle) is large enough for
+  // accurate axis extraction. Near angle=0 or angle=pi, sin(angle) is small
+  // and the axis must be computed differently.
+  const Scalar sin_threshold = sqrt(NumTraits<Scalar>::epsilon());
+  if (s > sin_threshold) {
+    // General case: axis from skew-symmetric part.
+    const Scalar inv_s = Scalar(1) / s;
+    m_axis << sx * inv_s, sy * inv_s, sz * inv_s;
+  } else if (c > Scalar(0)) {
+    // Near identity (angle ≈ 0): axis is arbitrary, use (1,0,0).
+    m_axis << Scalar(1), Scalar(0), Scalar(0);
+  } else {
+    // Near angle = pi: extract axis from the symmetric part (R + I) / 2.
+    // The axis is the eigenvector corresponding to eigenvalue 1.
+    // Use the column of (R + I) with the largest diagonal entry for robustness.
+    const Scalar d0 = m.coeff(0, 0);
+    const Scalar d1 = m.coeff(1, 1);
+    const Scalar d2 = m.coeff(2, 2);
+    if (d0 >= d1 && d0 >= d2) {
+      // x is the largest component
+      const Scalar x = sqrt(numext::maxi(d0 - d1 - d2 + Scalar(1), Scalar(0)) * Scalar(0.5));
+      const Scalar inv_2x = Scalar(0.5) / (x + NumTraits<Scalar>::epsilon());
+      m_axis << x, (m.coeff(0, 1) + m.coeff(1, 0)) * inv_2x, (m.coeff(0, 2) + m.coeff(2, 0)) * inv_2x;
+    } else if (d1 >= d2) {
+      // y is the largest component
+      const Scalar y = sqrt(numext::maxi(d1 - d0 - d2 + Scalar(1), Scalar(0)) * Scalar(0.5));
+      const Scalar inv_2y = Scalar(0.5) / (y + NumTraits<Scalar>::epsilon());
+      m_axis << (m.coeff(0, 1) + m.coeff(1, 0)) * inv_2y, y, (m.coeff(1, 2) + m.coeff(2, 1)) * inv_2y;
+    } else {
+      // z is the largest component
+      const Scalar z = sqrt(numext::maxi(d2 - d0 - d1 + Scalar(1), Scalar(0)) * Scalar(0.5));
+      const Scalar inv_2z = Scalar(0.5) / (z + NumTraits<Scalar>::epsilon());
+      m_axis << (m.coeff(0, 2) + m.coeff(2, 0)) * inv_2z, (m.coeff(1, 2) + m.coeff(2, 1)) * inv_2z, z;
+    }
+    m_axis.normalize();
+  }
+
+  return *this;
 }
 
 /** Constructs and \returns an equivalent 3x3 rotation matrix.
@@ -235,7 +310,7 @@
   res.coeffRef(1, 2) = tmp - sin_axis.x();
   res.coeffRef(2, 1) = tmp + sin_axis.x();
 
-  res.diagonal() = (cos1_axis.cwiseProduct(m_axis)).array() + c;
+  res.diagonal() = cos1_axis.cwiseProduct(m_axis).array() + c;
 
   return res;
 }
diff --git a/Eigen/src/Geometry/EulerAngles.h b/Eigen/src/Geometry/EulerAngles.h
index 9c6a0c1..7d56df9 100644
--- a/Eigen/src/Geometry/EulerAngles.h
+++ b/Eigen/src/Geometry/EulerAngles.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_EULERANGLES_H
 #define EIGEN_EULERANGLES_H
@@ -91,8 +92,26 @@
     //
     //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
 
-    Scalar s1 = numext::sin(res[0]);
-    Scalar c1 = numext::cos(res[0]);
+    // Recover sin(res[0]) and cos(res[0]) from the atan2 arguments directly,
+    // avoiding a redundant sin+cos evaluation. s2 = hypot(coeff(j,i), coeff(k,i))
+    // is the norm of the atan2 arguments (with sign adjustment for !odd).
+    Scalar s1, c1;
+    if (s2 > NumTraits<Scalar>::epsilon()) {
+      Scalar inv_s2 = Scalar(1) / s2;
+      if (odd) {
+        // res[0] = atan2(coeff(j,i), coeff(k,i))
+        s1 = coeff(j, i) * inv_s2;
+        c1 = coeff(k, i) * inv_s2;
+      } else {
+        // res[0] = atan2(-coeff(j,i), -coeff(k,i))
+        s1 = -coeff(j, i) * inv_s2;
+        c1 = -coeff(k, i) * inv_s2;
+      }
+    } else {
+      // Gimbal lock (s2 ≈ 0): recover sin/cos from the computed angle.
+      s1 = numext::sin(res[0]);
+      c1 = numext::cos(res[0]);
+    }
     res[2] = numext::atan2(c1 * coeff(j, k) - s1 * coeff(k, k), c1 * coeff(j, j) - s1 * coeff(k, j));
   } else {
     // Tait-Bryan angles (all three axes are different; typically used for yaw-pitch-roll calculations).
@@ -102,6 +121,11 @@
     //  c2s3    s2s1s3 + c1c3     s2c1s3 - s1c3
     // -s2      c2s1              c2c1
 
+    // Recover sin(res[0]) and cos(res[0]) from the atan2 arguments directly:
+    //   res[0] = atan2(coeff(j,k), coeff(k,k))
+    //   sin(res[0]) = coeff(j,k) / hypot(coeff(j,k), coeff(k,k))
+    //   cos(res[0]) = coeff(k,k) / hypot(coeff(j,k), coeff(k,k))
+    Scalar n1 = numext::hypot(coeff(j, k), coeff(k, k));
     res[0] = numext::atan2(coeff(j, k), coeff(k, k));
 
     Scalar c2 = numext::hypot(coeff(i, i), coeff(i, j));
@@ -109,8 +133,17 @@
     // range [-pi/2, pi/2]
     res[1] = numext::atan2(-coeff(i, k), c2);
 
-    Scalar s1 = numext::sin(res[0]);
-    Scalar c1 = numext::cos(res[0]);
+    Scalar s1, c1;
+    if (n1 > NumTraits<Scalar>::epsilon()) {
+      Scalar inv_n1 = Scalar(1) / n1;
+      s1 = coeff(j, k) * inv_n1;
+      c1 = coeff(k, k) * inv_n1;
+    } else {
+      // Gimbal lock: coeff(j,k) and coeff(k,k) are both near zero.
+      // Fall back to sin/cos of the computed angle.
+      s1 = numext::sin(res[0]);
+      c1 = numext::cos(res[0]);
+    }
     res[2] = numext::atan2(s1 * coeff(k, i) - c1 * coeff(j, i), c1 * coeff(j, j) - s1 * coeff(k, j));
   }
   if (!odd) {
diff --git a/Eigen/src/Geometry/Homogeneous.h b/Eigen/src/Geometry/Homogeneous.h
index b304b67..3e189e3 100644
--- a/Eigen/src/Geometry/Homogeneous.h
+++ b/Eigen/src/Geometry/Homogeneous.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HOMOGENEOUS_H
 #define EIGEN_HOMOGENEOUS_H
@@ -34,9 +35,9 @@
 
 template <typename MatrixType, int Direction>
 struct traits<Homogeneous<MatrixType, Direction> > : traits<MatrixType> {
-  typedef typename traits<MatrixType>::StorageKind StorageKind;
-  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNested_;
+  using StorageKind = typename traits<MatrixType>::StorageKind;
+  using MatrixTypeNested = typename ref_selector<MatrixType>::type;
+  using MatrixTypeNested_ = std::remove_reference_t<MatrixTypeNested>;
   enum {
     RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ? int(MatrixType::RowsAtCompileTime) + 1 : Dynamic,
     ColsPlusOne = (MatrixType::ColsAtCompileTime != Dynamic) ? int(MatrixType::ColsAtCompileTime) + 1 : Dynamic,
@@ -61,10 +62,10 @@
 template <typename MatrixType, int Direction_>
 class Homogeneous : public MatrixBase<Homogeneous<MatrixType, Direction_> >, internal::no_assignment_operator {
  public:
-  typedef MatrixType NestedExpression;
+  using NestedExpression = MatrixType;
   enum { Direction = Direction_ };
 
-  typedef MatrixBase<Homogeneous> Base;
+  using Base = MatrixBase<Homogeneous>;
   EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous)
 
   EIGEN_DEVICE_FUNC explicit inline Homogeneous(const MatrixType& matrix) : m_matrix(matrix) {}
@@ -204,41 +205,41 @@
 
 template <typename MatrixOrTransformType>
 struct take_matrix_for_product {
-  typedef MatrixOrTransformType type;
+  using type = MatrixOrTransformType;
   EIGEN_DEVICE_FUNC static const type& run(const type& x) { return x; }
 };
 
 template <typename Scalar, int Dim, int Mode, int Options>
 struct take_matrix_for_product<Transform<Scalar, Dim, Mode, Options> > {
-  typedef Transform<Scalar, Dim, Mode, Options> TransformType;
-  typedef std::add_const_t<typename TransformType::ConstAffinePart> type;
+  using TransformType = Transform<Scalar, Dim, Mode, Options>;
+  using type = std::add_const_t<typename TransformType::ConstAffinePart>;
   EIGEN_DEVICE_FUNC static type run(const TransformType& x) { return x.affine(); }
 };
 
 template <typename Scalar, int Dim, int Options>
 struct take_matrix_for_product<Transform<Scalar, Dim, Projective, Options> > {
-  typedef Transform<Scalar, Dim, Projective, Options> TransformType;
-  typedef typename TransformType::MatrixType type;
+  using TransformType = Transform<Scalar, Dim, Projective, Options>;
+  using type = typename TransformType::MatrixType;
   EIGEN_DEVICE_FUNC static const type& run(const TransformType& x) { return x.matrix(); }
 };
 
 template <typename MatrixType, typename Lhs>
 struct traits<homogeneous_left_product_impl<Homogeneous<MatrixType, Vertical>, Lhs> > {
-  typedef typename take_matrix_for_product<Lhs>::type LhsMatrixType;
-  typedef remove_all_t<MatrixType> MatrixTypeCleaned;
-  typedef remove_all_t<LhsMatrixType> LhsMatrixTypeCleaned;
-  typedef typename make_proper_matrix_type<
+  using LhsMatrixType = typename take_matrix_for_product<Lhs>::type;
+  using MatrixTypeCleaned = remove_all_t<MatrixType>;
+  using LhsMatrixTypeCleaned = remove_all_t<LhsMatrixType>;
+  using ReturnType = typename make_proper_matrix_type<
       typename traits<MatrixTypeCleaned>::Scalar, LhsMatrixTypeCleaned::RowsAtCompileTime,
       MatrixTypeCleaned::ColsAtCompileTime, MatrixTypeCleaned::PlainObject::Options,
-      LhsMatrixTypeCleaned::MaxRowsAtCompileTime, MatrixTypeCleaned::MaxColsAtCompileTime>::type ReturnType;
+      LhsMatrixTypeCleaned::MaxRowsAtCompileTime, MatrixTypeCleaned::MaxColsAtCompileTime>::type;
 };
 
 template <typename MatrixType, typename Lhs>
 struct homogeneous_left_product_impl<Homogeneous<MatrixType, Vertical>, Lhs>
     : public ReturnByValue<homogeneous_left_product_impl<Homogeneous<MatrixType, Vertical>, Lhs> > {
-  typedef typename traits<homogeneous_left_product_impl>::LhsMatrixType LhsMatrixType;
-  typedef remove_all_t<LhsMatrixType> LhsMatrixTypeCleaned;
-  typedef remove_all_t<typename LhsMatrixTypeCleaned::Nested> LhsMatrixTypeNested;
+  using LhsMatrixType = typename traits<homogeneous_left_product_impl>::LhsMatrixType;
+  using LhsMatrixTypeCleaned = remove_all_t<LhsMatrixType>;
+  using LhsMatrixTypeNested = remove_all_t<typename LhsMatrixTypeCleaned::Nested>;
   EIGEN_DEVICE_FUNC homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs)
       : m_lhs(take_matrix_for_product<Lhs>::run(lhs)), m_rhs(rhs) {}
 
@@ -261,16 +262,16 @@
 
 template <typename MatrixType, typename Rhs>
 struct traits<homogeneous_right_product_impl<Homogeneous<MatrixType, Horizontal>, Rhs> > {
-  typedef
+  using ReturnType =
       typename make_proper_matrix_type<typename traits<MatrixType>::Scalar, MatrixType::RowsAtCompileTime,
                                        Rhs::ColsAtCompileTime, MatrixType::PlainObject::Options,
-                                       MatrixType::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime>::type ReturnType;
+                                       MatrixType::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime>::type;
 };
 
 template <typename MatrixType, typename Rhs>
 struct homogeneous_right_product_impl<Homogeneous<MatrixType, Horizontal>, Rhs>
     : public ReturnByValue<homogeneous_right_product_impl<Homogeneous<MatrixType, Horizontal>, Rhs> > {
-  typedef remove_all_t<typename Rhs::Nested> RhsNested;
+  using RhsNested = remove_all_t<typename Rhs::Nested>;
   EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) {}
 
   EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return m_lhs.rows(); }
@@ -291,21 +292,21 @@
 
 template <typename ArgType, int Direction>
 struct evaluator_traits<Homogeneous<ArgType, Direction> > {
-  typedef typename storage_kind_to_evaluator_kind<typename ArgType::StorageKind>::Kind Kind;
-  typedef HomogeneousShape Shape;
+  using Kind = typename storage_kind_to_evaluator_kind<typename ArgType::StorageKind>::Kind;
+  using Shape = HomogeneousShape;
 };
 
 template <>
 struct AssignmentKind<DenseShape, HomogeneousShape> {
-  typedef Dense2Dense Kind;
+  using Kind = Dense2Dense;
 };
 
 template <typename ArgType, int Direction>
 struct unary_evaluator<Homogeneous<ArgType, Direction>, IndexBased>
     : evaluator<typename Homogeneous<ArgType, Direction>::PlainObject> {
-  typedef Homogeneous<ArgType, Direction> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = Homogeneous<ArgType, Direction>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) : Base(), m_temp(op) {
     internal::construct_at<Base>(this, m_temp);
@@ -319,7 +320,7 @@
 template <typename DstXprType, typename ArgType, typename Scalar>
 struct Assignment<DstXprType, Homogeneous<ArgType, Vertical>, internal::assign_op<Scalar, typename ArgType::Scalar>,
                   Dense2Dense> {
-  typedef Homogeneous<ArgType, Vertical> SrcXprType;
+  using SrcXprType = Homogeneous<ArgType, Vertical>;
   EIGEN_DEVICE_FUNC static void run(DstXprType& dst, const SrcXprType& src,
                                     const internal::assign_op<Scalar, typename ArgType::Scalar>&) {
     Index dstRows = src.rows();
@@ -335,7 +336,7 @@
 template <typename DstXprType, typename ArgType, typename Scalar>
 struct Assignment<DstXprType, Homogeneous<ArgType, Horizontal>, internal::assign_op<Scalar, typename ArgType::Scalar>,
                   Dense2Dense> {
-  typedef Homogeneous<ArgType, Horizontal> SrcXprType;
+  using SrcXprType = Homogeneous<ArgType, Horizontal>;
   EIGEN_DEVICE_FUNC static void run(DstXprType& dst, const SrcXprType& src,
                                     const internal::assign_op<Scalar, typename ArgType::Scalar>&) {
     Index dstRows = src.rows();
@@ -358,25 +359,24 @@
 template <typename Lhs, typename Rhs>
 struct homogeneous_right_product_refactoring_helper {
   enum { Dim = Lhs::ColsAtCompileTime, Rows = Lhs::RowsAtCompileTime };
-  typedef typename Rhs::template ConstNRowsBlockXpr<Dim>::Type LinearBlockConst;
-  typedef std::remove_const_t<LinearBlockConst> LinearBlock;
-  typedef typename Rhs::ConstRowXpr ConstantColumn;
-  typedef Replicate<const ConstantColumn, Rows, 1> ConstantBlock;
-  typedef Product<Lhs, LinearBlock, LazyProduct> LinearProduct;
-  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar, typename Rhs::Scalar>, const LinearProduct,
-                        const ConstantBlock>
-      Xpr;
+  using LinearBlockConst = typename Rhs::template ConstNRowsBlockXpr<Dim>::Type;
+  using LinearBlock = std::remove_const_t<LinearBlockConst>;
+  using ConstantColumn = typename Rhs::ConstRowXpr;
+  using ConstantBlock = Replicate<const ConstantColumn, Rows, 1>;
+  using LinearProduct = Product<Lhs, LinearBlock, LazyProduct>;
+  using Xpr = CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar, typename Rhs::Scalar>, const LinearProduct,
+                            const ConstantBlock>;
 };
 
 template <typename Lhs, typename Rhs, int ProductTag>
 struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, HomogeneousShape, DenseShape>
     : public evaluator<
           typename homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression, Rhs>::Xpr> {
-  typedef Product<Lhs, Rhs, LazyProduct> XprType;
-  typedef homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression, Rhs> helper;
-  typedef typename helper::ConstantBlock ConstantBlock;
-  typedef typename helper::Xpr RefactoredXpr;
-  typedef evaluator<RefactoredXpr> Base;
+  using XprType = Product<Lhs, Rhs, LazyProduct>;
+  using helper = homogeneous_right_product_refactoring_helper<typename Lhs::NestedExpression, Rhs>;
+  using ConstantBlock = typename helper::ConstantBlock;
+  using RefactoredXpr = typename helper::Xpr;
+  using Base = evaluator<RefactoredXpr>;
 
   EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
       : Base(xpr.lhs().nestedExpression().lazyProduct(
@@ -392,7 +392,6 @@
   }
 };
 
-// TODO: this specialization addresses a performance regression from 3.2 to 3.3; optimize this path.
 template <typename Lhs, typename RhsArg, int ProductTag>
 struct generic_product_impl<Lhs, Homogeneous<RhsArg, Vertical>, TriangularShape, HomogeneousShape, ProductTag> {
   template <typename Dest>
@@ -404,24 +403,23 @@
 template <typename Lhs, typename Rhs>
 struct homogeneous_left_product_refactoring_helper {
   enum { Dim = Rhs::RowsAtCompileTime, Cols = Rhs::ColsAtCompileTime };
-  typedef typename Lhs::template ConstNColsBlockXpr<Dim>::Type LinearBlockConst;
-  typedef std::remove_const_t<LinearBlockConst> LinearBlock;
-  typedef typename Lhs::ConstColXpr ConstantColumn;
-  typedef Replicate<const ConstantColumn, 1, Cols> ConstantBlock;
-  typedef Product<LinearBlock, Rhs, LazyProduct> LinearProduct;
-  typedef CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar, typename Rhs::Scalar>, const LinearProduct,
-                        const ConstantBlock>
-      Xpr;
+  using LinearBlockConst = typename Lhs::template ConstNColsBlockXpr<Dim>::Type;
+  using LinearBlock = std::remove_const_t<LinearBlockConst>;
+  using ConstantColumn = typename Lhs::ConstColXpr;
+  using ConstantBlock = Replicate<const ConstantColumn, 1, Cols>;
+  using LinearProduct = Product<LinearBlock, Rhs, LazyProduct>;
+  using Xpr = CwiseBinaryOp<internal::scalar_sum_op<typename Lhs::Scalar, typename Rhs::Scalar>, const LinearProduct,
+                            const ConstantBlock>;
 };
 
 template <typename Lhs, typename Rhs, int ProductTag>
 struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, ProductTag, DenseShape, HomogeneousShape>
     : public evaluator<typename homogeneous_left_product_refactoring_helper<Lhs, typename Rhs::NestedExpression>::Xpr> {
-  typedef Product<Lhs, Rhs, LazyProduct> XprType;
-  typedef homogeneous_left_product_refactoring_helper<Lhs, typename Rhs::NestedExpression> helper;
-  typedef typename helper::ConstantBlock ConstantBlock;
-  typedef typename helper::Xpr RefactoredXpr;
-  typedef evaluator<RefactoredXpr> Base;
+  using XprType = Product<Lhs, Rhs, LazyProduct>;
+  using helper = homogeneous_left_product_refactoring_helper<Lhs, typename Rhs::NestedExpression>;
+  using ConstantBlock = typename helper::ConstantBlock;
+  using RefactoredXpr = typename helper::Xpr;
+  using Base = evaluator<RefactoredXpr>;
 
   EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
       : Base(xpr.lhs()
@@ -433,7 +431,7 @@
 template <typename Scalar, int Dim, int Mode, int Options, typename RhsArg, int ProductTag>
 struct generic_product_impl<Transform<Scalar, Dim, Mode, Options>, Homogeneous<RhsArg, Vertical>, DenseShape,
                             HomogeneousShape, ProductTag> {
-  typedef Transform<Scalar, Dim, Mode, Options> TransformType;
+  using TransformType = Transform<Scalar, Dim, Mode, Options>;
   template <typename Dest>
   EIGEN_DEVICE_FUNC static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneous<RhsArg, Vertical>& rhs) {
     homogeneous_left_product_impl<Homogeneous<RhsArg, Vertical>, TransformType>(lhs, rhs.nestedExpression())
diff --git a/Eigen/src/Geometry/Hyperplane.h b/Eigen/src/Geometry/Hyperplane.h
index 1bdb811..c931d5b 100644
--- a/Eigen/src/Geometry/Hyperplane.h
+++ b/Eigen/src/Geometry/Hyperplane.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HYPERPLANE_H
 #define EIGEN_HYPERPLANE_H
@@ -29,7 +30,7 @@
  * \tparam AmbientDim_ the dimension of the ambient space, can be a compile time value or Dynamic.
  *             Notice that the dimension of the hyperplane is AmbientDim_-1.
  *
- * This class represents an hyperplane as the zero set of the implicit equation
+ * This class represents a hyperplane as the zero set of the implicit equation
  * \f$ n \cdot x + d = 0 \f$ where \f$ n \f$ is a unit normal vector of the plane (linear part)
  * and \f$ d \f$ is the distance (offset) to the origin.
  */
@@ -39,15 +40,15 @@
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_,
                                                              AmbientDim_ == Dynamic ? Dynamic : AmbientDim_ + 1)
   enum { AmbientDimAtCompileTime = AmbientDim_, Options = Options_ };
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
-  typedef Matrix<Scalar, AmbientDimAtCompileTime, 1> VectorType;
-  typedef Matrix<Scalar, Index(AmbientDimAtCompileTime) == Dynamic ? Dynamic : Index(AmbientDimAtCompileTime) + 1, 1,
-                 Options>
-      Coefficients;
-  typedef Block<Coefficients, AmbientDimAtCompileTime, 1> NormalReturnType;
-  typedef const Block<const Coefficients, AmbientDimAtCompileTime, 1> ConstNormalReturnType;
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
+  using VectorType = Matrix<Scalar, AmbientDimAtCompileTime, 1>;
+  using Coefficients =
+      Matrix<Scalar, Index(AmbientDimAtCompileTime) == Dynamic ? Dynamic : Index(AmbientDimAtCompileTime) + 1, 1,
+             Options>;
+  using NormalReturnType = Block<Coefficients, AmbientDimAtCompileTime, 1>;
+  using ConstNormalReturnType = const Block<const Coefficients, AmbientDimAtCompileTime, 1>;
 
   /** Default constructor without initialization */
   EIGEN_DEVICE_FUNC inline Hyperplane() {}
@@ -117,8 +118,6 @@
     offset() = -parametrized.origin().dot(normal());
   }
 
-  EIGEN_DEVICE_FUNC ~Hyperplane() {}
-
   /** \returns the dimension in which the plane holds */
   EIGEN_DEVICE_FUNC inline Index dim() const {
     return AmbientDimAtCompileTime == Dynamic ? m_coeffs.size() - 1 : Index(AmbientDimAtCompileTime);
@@ -256,7 +255,11 @@
   /** \returns \c true if \c *this is approximately equal to \a other, within the precision
    * determined by \a prec.
    *
-   * \sa MatrixBase::isApprox() */
+   * Hyperplanes are oriented: the sign of their coefficients decides which side signedDistance()
+   * reports as positive, so a hyperplane and its negation are not approximately equal here even
+   * though they describe the same point set. Use isCoincident() to compare them as point sets.
+   *
+   * \sa isCoincident(), MatrixBase::isApprox() */
   template <int OtherOptions>
   EIGEN_DEVICE_FUNC bool isApprox(
       const Hyperplane<Scalar, AmbientDimAtCompileTime, OtherOptions>& other,
@@ -264,6 +267,47 @@
     return m_coeffs.isApprox(other.m_coeffs, prec);
   }
 
+  /** \returns \c true if \c *this and \a other describe approximately the same set of points,
+   * within the precision determined by \a prec, regardless of orientation and scale.
+   *
+   * Scaling the equation signedDistance() evaluates by any nonzero \f$ \gamma \f$ leaves its zero
+   * set unchanged. Because dot() is conjugate-linear in the normal, that carries
+   * \f$ (n, d) \f$ to \f$ (\bar{\gamma} n, \gamma d) \f$, so coincident hyperplanes need not have
+   * coefficients of equal magnitude: for a real \c Scalar any nonzero real factor relates them, a
+   * sign flip - which isApprox() rejects - being the norm-preserving case, and for a complex
+   * \c Scalar any nonzero complex factor does.
+   *
+   * The comparison is therefore made on the normalized equations, which \f$ \gamma \f$ no longer
+   * distinguishes beyond a unit-modulus factor: the unit normals must agree, up to that factor,
+   * within \a prec, and the two distances to the origin must agree the way internal::isApprox()
+   * compares scalars, that is relative to their own magnitude. Comparing the two halves separately
+   * is what keeps a distant hyperplane from relaxing the comparison of the normals; it also means
+   * that a hyperplane through the origin is not coincident with one that merely passes close to it.
+   * The result is symmetric in the two hyperplanes, and unchanged both when either equation is
+   * rescaled and when the ambient coordinates are.
+   *
+   * Both normals must be nonzero.
+   *
+   * \sa isApprox(), signedDistance(), normalize() */
+  template <int OtherOptions>
+  EIGEN_DEVICE_FUNC bool isCoincident(
+      const Hyperplane<Scalar, AmbientDimAtCompileTime, OtherOptions>& other,
+      const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const {
+    const RealScalar this_norm = normal().norm();
+    const RealScalar other_norm = other.normal().norm();
+    eigen_assert(this_norm > RealScalar(0) && other_norm > RealScalar(0));
+    // Normalizing accounts for |gamma|; what is left of it is a unit-modulus factor, and the
+    // normals themselves determine it, since the inner product of two coincident unit normals is
+    // exactly that factor. Orthogonal normals leave it undetermined, but no factor makes those
+    // agree either, so the choice made for them does not matter.
+    const Scalar inner = normal().dot(other.normal());
+    const RealScalar inner_norm = numext::abs(inner);
+    const Scalar phase = inner_norm > RealScalar(0) ? inner / Scalar(inner_norm) : Scalar(1);
+    if (!((other.normal() / Scalar(other_norm) - phase * (normal() / Scalar(this_norm))).norm() <= prec)) return false;
+    return internal::isApprox(other.offset() / Scalar(other_norm), numext::conj(phase) * (offset() / Scalar(this_norm)),
+                              prec);
+  }
+
  protected:
   Coefficients m_coeffs;
 };
diff --git a/Eigen/src/Geometry/InternalHeaderCheck.h b/Eigen/src/Geometry/InternalHeaderCheck.h
index a1159a3..a2072d4 100644
--- a/Eigen/src/Geometry/InternalHeaderCheck.h
+++ b/Eigen/src/Geometry/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_GEOMETRY_MODULE_H
 #error "Please include Eigen/Geometry instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Geometry/OrthoMethods.h b/Eigen/src/Geometry/OrthoMethods.h
index 758c82e..8afe142 100644
--- a/Eigen/src/Geometry/OrthoMethods.h
+++ b/Eigen/src/Geometry/OrthoMethods.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ORTHOMETHODS_H
 #define EIGEN_ORTHOMETHODS_H
@@ -21,9 +22,9 @@
 // Vector3 version (default)
 template <typename Derived, typename OtherDerived, int Size>
 struct cross_impl {
-  typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,
-                                        typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
-  typedef Matrix<Scalar, MatrixBase<Derived>::RowsAtCompileTime, MatrixBase<Derived>::ColsAtCompileTime> return_type;
+  using Scalar = typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,
+                                               typename internal::traits<OtherDerived>::Scalar>::ReturnType;
+  using return_type = Matrix<Scalar, MatrixBase<Derived>::RowsAtCompileTime, MatrixBase<Derived>::ColsAtCompileTime>;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE return_type run(const MatrixBase<Derived>& first,
                                                                const MatrixBase<OtherDerived>& second) {
@@ -31,7 +32,7 @@
     EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, 3)
 
     // Note that there is no need for an expression here since the compiler
-    // optimize such a small temporary very well (even within a complex expression)
+    // optimizes such a small temporary very well (even within a complex expression)
     typename internal::nested_eval<Derived, 2>::type lhs(first.derived());
     typename internal::nested_eval<OtherDerived, 2>::type rhs(second.derived());
     return return_type(numext::conj(lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1)),
@@ -43,14 +44,14 @@
 // Vector2 version
 template <typename Derived, typename OtherDerived>
 struct cross_impl<Derived, OtherDerived, 2> {
-  typedef typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,
-                                        typename internal::traits<OtherDerived>::Scalar>::ReturnType Scalar;
-  typedef Scalar return_type;
+  using Scalar = typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar,
+                                               typename internal::traits<OtherDerived>::Scalar>::ReturnType;
+  using return_type = Scalar;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE return_type run(const MatrixBase<Derived>& first,
                                                                const MatrixBase<OtherDerived>& second) {
-    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived, 2);
-    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, 2);
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived, 2)
+    EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, 2)
     typename internal::nested_eval<Derived, 2>::type lhs(first.derived());
     typename internal::nested_eval<OtherDerived, 2>::type rhs(second.derived());
     return numext::conj(lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0));
@@ -125,8 +126,8 @@
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived, 4)
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, 4)
 
-  typedef typename internal::nested_eval<Derived, 2>::type DerivedNested;
-  typedef typename internal::nested_eval<OtherDerived, 2>::type OtherDerivedNested;
+  using DerivedNested = typename internal::nested_eval<Derived, 2>::type;
+  using OtherDerivedNested = typename internal::nested_eval<OtherDerived, 2>::type;
   DerivedNested lhs(derived());
   OtherDerivedNested rhs(other.derived());
 
@@ -140,7 +141,7 @@
  * of the referenced expression with the \a other vector.
  *
  * The referenced matrix must have one dimension equal to 3.
- * The result matrix has the same dimensions than the referenced one.
+ * The result matrix has the same dimensions as the referenced one.
  *
  * \sa MatrixBase::cross() */
 template <typename ExpressionType, int Direction>
@@ -149,14 +150,14 @@
 VectorwiseOp<ExpressionType, Direction>::cross(const MatrixBase<OtherDerived>& other) const {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, 3)
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+      (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
   typename internal::nested_eval<ExpressionType, 2>::type mat(_expression());
   typename internal::nested_eval<OtherDerived, 2>::type vec(other.derived());
 
   CrossReturnType res(_expression().rows(), _expression().cols());
-  if (Direction == Vertical) {
+  EIGEN_IF_CONSTEXPR (Direction == Vertical) {
     eigen_assert(CrossReturnType::RowsAtCompileTime == 3 && "the matrix must have exactly 3 rows");
     res.row(0) = (mat.row(1) * vec.coeff(2) - mat.row(2) * vec.coeff(1)).conjugate();
     res.row(1) = (mat.row(2) * vec.coeff(0) - mat.row(0) * vec.coeff(2)).conjugate();
@@ -174,10 +175,10 @@
 
 template <typename Derived, int Size = Derived::SizeAtCompileTime>
 struct unitOrthogonal_selector {
-  typedef typename plain_matrix_type<Derived>::type VectorType;
-  typedef typename traits<Derived>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Matrix<Scalar, 2, 1> Vector2;
+  using VectorType = typename plain_matrix_type<Derived>::type;
+  using Scalar = typename traits<Derived>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Vector2 = Matrix<Scalar, 2, 1>;
   EIGEN_DEVICE_FUNC static inline VectorType run(const Derived& src) {
     VectorType perp = VectorType::Zero(src.size());
     Index maxi = 0;
@@ -194,9 +195,9 @@
 
 template <typename Derived>
 struct unitOrthogonal_selector<Derived, 3> {
-  typedef typename plain_matrix_type<Derived>::type VectorType;
-  typedef typename traits<Derived>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using VectorType = typename plain_matrix_type<Derived>::type;
+  using Scalar = typename traits<Derived>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
   EIGEN_DEVICE_FUNC static inline VectorType run(const Derived& src) {
     VectorType perp;
     /* Let us compute the crossed product of *this with a vector
@@ -229,7 +230,7 @@
 
 template <typename Derived>
 struct unitOrthogonal_selector<Derived, 2> {
-  typedef typename plain_matrix_type<Derived>::type VectorType;
+  using VectorType = typename plain_matrix_type<Derived>::type;
   EIGEN_DEVICE_FUNC static inline VectorType run(const Derived& src) {
     return VectorType(-numext::conj(src.y()), numext::conj(src.x())).normalized();
   }
@@ -241,8 +242,10 @@
  *
  * \returns a unit vector which is orthogonal to \c *this
  *
- * The size of \c *this must be at least 2. If the size is exactly 2,
+ * The size of \c *this must be at least 2. If the size is exactly 2 at compile time,
  * then the returned vector is a counter-clockwise rotation of \c *this, i.e., (-y,x).normalized().
+ * A vector whose size is only known at runtime takes the generic code path even when its size is 2,
+ * and then returns the clockwise rotation (y,-x).normalized() if |y| > |x|.
  *
  * \sa cross()
  */
diff --git a/Eigen/src/Geometry/ParametrizedLine.h b/Eigen/src/Geometry/ParametrizedLine.h
index 5bbd874..8c59ffb 100644
--- a/Eigen/src/Geometry/ParametrizedLine.h
+++ b/Eigen/src/Geometry/ParametrizedLine.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARAMETRIZEDLINE_H
 #define EIGEN_PARAMETRIZEDLINE_H
@@ -25,6 +26,8 @@
  * A parametrized line is defined by an origin point \f$ \mathbf{o} \f$ and a unit
  * direction vector \f$ \mathbf{d} \f$ such that the line corresponds to
  * the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ t \in \mathbf{R} \f$.
+ * The origin is part of the parametrization: two ParametrizedLine objects may
+ * describe the same geometric line while using different origins.
  *
  * \tparam Scalar_ the scalar type, i.e., the type of the coefficients
  * \tparam AmbientDim_ the dimension of the ambient space, can be a compile time value or Dynamic.
@@ -34,10 +37,10 @@
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, AmbientDim_)
   enum { AmbientDimAtCompileTime = AmbientDim_, Options = Options_ };
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
-  typedef Matrix<Scalar, AmbientDimAtCompileTime, 1, Options> VectorType;
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
+  using VectorType = Matrix<Scalar, AmbientDimAtCompileTime, 1, Options>;
 
   /** Default constructor without initialization */
   EIGEN_DEVICE_FUNC inline ParametrizedLine() {}
@@ -51,6 +54,7 @@
   EIGEN_DEVICE_FUNC inline explicit ParametrizedLine(Index _dim) : m_origin(_dim), m_direction(_dim) {}
 
   /** Initializes a parametrized line of direction \a direction and origin \a origin.
+   * \warning the origin is part of the parametrization and is not canonicalized.
    * \warning the vector direction is assumed to be normalized.
    */
   EIGEN_DEVICE_FUNC ParametrizedLine(const VectorType& origin, const VectorType& direction)
@@ -64,8 +68,6 @@
     return ParametrizedLine(p0, (p1 - p0).normalized());
   }
 
-  EIGEN_DEVICE_FUNC ~ParametrizedLine() {}
-
   /** \returns the dimension in which the line holds */
   EIGEN_DEVICE_FUNC inline Index dim() const { return m_direction.size(); }
 
@@ -167,6 +169,9 @@
   /** \returns \c true if \c *this is approximately equal to \a other, within the precision
    * determined by \a prec.
    *
+   * \note This compares both origins and directions. Lines that represent the same set of
+   * points but use different origins are not considered approximately equal by this method.
+   *
    * \sa MatrixBase::isApprox() */
   EIGEN_DEVICE_FUNC bool isApprox(const ParametrizedLine& other, const typename NumTraits<Scalar>::Real& prec =
                                                                      NumTraits<Scalar>::dummy_precision()) const {
@@ -195,7 +200,7 @@
 template <typename Scalar_, int AmbientDim_, int Options_>
 EIGEN_DEVICE_FUNC inline typename ParametrizedLine<Scalar_, AmbientDim_, Options_>::VectorType
 ParametrizedLine<Scalar_, AmbientDim_, Options_>::pointAt(const Scalar_& t) const {
-  return origin() + (direction() * t);
+  return origin() + direction() * t;
 }
 
 /** \returns the parameter value of the intersection between \c *this and the given \a hyperplane
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index 8b71cd8..e0579c5 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_QUATERNION_H
 #define EIGEN_QUATERNION_H
@@ -34,27 +35,26 @@
 template <class Derived>
 class QuaternionBase : public RotationBase<Derived, 3> {
  public:
-  typedef RotationBase<Derived, 3> Base;
+  using Base = RotationBase<Derived, 3>;
 
   using Base::operator*;
   using Base::derived;
 
-  typedef typename internal::traits<Derived>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef typename internal::traits<Derived>::Coefficients Coefficients;
-  typedef typename Coefficients::CoeffReturnType CoeffReturnType;
-  typedef std::conditional_t<bool(internal::traits<Derived>::Flags& LvalueBit), Scalar&, CoeffReturnType>
-      NonConstCoeffReturnType;
+  using Scalar = typename internal::traits<Derived>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Coefficients = typename internal::traits<Derived>::Coefficients;
+  using CoeffReturnType = typename Coefficients::CoeffReturnType;
+  using NonConstCoeffReturnType =
+      std::conditional_t<bool(internal::traits<Derived>::Flags& LvalueBit), Scalar&, CoeffReturnType>;
 
   enum { Flags = Eigen::internal::traits<Derived>::Flags };
 
-  // typedef typename Matrix<Scalar,4,1> Coefficients;
   /** the type of a 3D vector */
-  typedef Matrix<Scalar, 3, 1> Vector3;
+  using Vector3 = Matrix<Scalar, 3, 1>;
   /** the equivalent rotation matrix type */
-  typedef Matrix<Scalar, 3, 3> Matrix3;
+  using Matrix3 = Matrix<Scalar, 3, 3>;
   /** the equivalent angle-axis type */
-  typedef AngleAxis<Scalar> AngleAxisType;
+  using AngleAxisType = AngleAxis<Scalar>;
 
   /** \returns the \c x coefficient */
   EIGEN_DEVICE_FUNC constexpr CoeffReturnType x() const { return this->derived().coeffs().coeff(0); }
@@ -170,6 +170,11 @@
   template <typename Derived1, typename Derived2>
   EIGEN_DEVICE_FUNC Derived& setFromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
 
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC Derived& setFromScaledAxis(const MatrixBase<OtherDerived>& scaled_axis);
+
+  EIGEN_DEVICE_FUNC inline Vector3 toScaledAxis() const;
+
   template <class OtherDerived>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<Scalar> operator*(const QuaternionBase<OtherDerived>& q) const;
   template <class OtherDerived>
@@ -227,14 +232,12 @@
 #else
 
   template <typename NewScalarType>
-  EIGEN_DEVICE_FUNC inline std::enable_if_t<internal::is_same<Scalar, NewScalarType>::value, const Derived&> cast()
-      const {
+  EIGEN_DEVICE_FUNC inline std::enable_if_t<std::is_same<Scalar, NewScalarType>::value, const Derived&> cast() const {
     return derived();
   }
 
   template <typename NewScalarType>
-  EIGEN_DEVICE_FUNC inline std::enable_if_t<!internal::is_same<Scalar, NewScalarType>::value,
-                                            Quaternion<NewScalarType> >
+  EIGEN_DEVICE_FUNC inline std::enable_if_t<!std::is_same<Scalar, NewScalarType>::value, Quaternion<NewScalarType> >
   cast() const {
     return Quaternion<NewScalarType>(coeffs().template cast<NewScalarType>());
   }
@@ -290,9 +293,9 @@
 namespace internal {
 template <typename Scalar_, int Options_>
 struct traits<Quaternion<Scalar_, Options_> > {
-  typedef Quaternion<Scalar_, Options_> PlainObject;
-  typedef Scalar_ Scalar;
-  typedef Matrix<Scalar_, 4, 1, Options_> Coefficients;
+  using PlainObject = Quaternion<Scalar_, Options_>;
+  using Scalar = Scalar_;
+  using Coefficients = Matrix<Scalar_, 4, 1, Options_>;
   enum { Alignment = internal::traits<Coefficients>::Alignment, Flags = LvalueBit };
 };
 }  // namespace internal
@@ -300,16 +303,16 @@
 template <typename Scalar_, int Options_>
 class Quaternion : public QuaternionBase<Quaternion<Scalar_, Options_> > {
  public:
-  typedef QuaternionBase<Quaternion<Scalar_, Options_> > Base;
+  using Base = QuaternionBase<Quaternion<Scalar_, Options_>>;
   enum { NeedsAlignment = internal::traits<Quaternion>::Alignment > 0 };
 
-  typedef Scalar_ Scalar;
+  using Scalar = Scalar_;
 
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Quaternion)
   using Base::operator*=;
 
-  typedef typename internal::traits<Quaternion>::Coefficients Coefficients;
-  typedef typename Base::AngleAxisType AngleAxisType;
+  using Coefficients = typename internal::traits<Quaternion>::Coefficients;
+  using AngleAxisType = typename Base::AngleAxisType;
 
   /** Default constructor leaving the quaternion uninitialized. */
   EIGEN_DEVICE_FUNC inline Quaternion() {}
@@ -382,6 +385,9 @@
   template <typename Derived1, typename Derived2>
   EIGEN_DEVICE_FUNC static Quaternion FromTwoVectors(const MatrixBase<Derived1>& a, const MatrixBase<Derived2>& b);
 
+  template <typename Derived>
+  EIGEN_DEVICE_FUNC static Quaternion FromScaledAxis(const MatrixBase<Derived>& scaled_axis);
+
   EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
   EIGEN_DEVICE_FUNC inline const Coefficients& coeffs() const { return m_coeffs; }
 
@@ -406,10 +412,10 @@
 
 /** \ingroup Geometry_Module
  * single precision quaternion type */
-typedef Quaternion<float> Quaternionf;
+using Quaternionf = Quaternion<float>;
 /** \ingroup Geometry_Module
  * double precision quaternion type */
-typedef Quaternion<double> Quaterniond;
+using Quaterniond = Quaternion<double>;
 
 /***************************************************************************
  * Specialization of Map<Quaternion<Scalar>>
@@ -419,7 +425,7 @@
 template <typename Scalar_, int Options_>
 struct traits<Map<Quaternion<Scalar_>, Options_> >
     : traits<Quaternion<Scalar_, (int(Options_) & Aligned) == Aligned ? AutoAlign : DontAlign> > {
-  typedef Map<Matrix<Scalar_, 4, 1>, Options_> Coefficients;
+  using Coefficients = Map<Matrix<Scalar_, 4, 1>, Options_>;
 };
 }  // namespace internal
 
@@ -427,8 +433,8 @@
 template <typename Scalar_, int Options_>
 struct traits<Map<const Quaternion<Scalar_>, Options_> >
     : traits<Quaternion<Scalar_, (int(Options_) & Aligned) == Aligned ? AutoAlign : DontAlign> > {
-  typedef Map<const Matrix<Scalar_, 4, 1>, Options_> Coefficients;
-  typedef traits<Quaternion<Scalar_, (int(Options_) & Aligned) == Aligned ? AutoAlign : DontAlign> > TraitsBase;
+  using Coefficients = Map<const Matrix<Scalar_, 4, 1>, Options_>;
+  using TraitsBase = traits<Quaternion<Scalar_, (int(Options_) & Aligned) == Aligned ? AutoAlign : DontAlign>>;
   enum { Flags = TraitsBase::Flags & ~LvalueBit };
 };
 }  // namespace internal
@@ -447,10 +453,10 @@
 template <typename Scalar_, int Options_>
 class Map<const Quaternion<Scalar_>, Options_> : public QuaternionBase<Map<const Quaternion<Scalar_>, Options_> > {
  public:
-  typedef QuaternionBase<Map<const Quaternion<Scalar_>, Options_> > Base;
+  using Base = QuaternionBase<Map<const Quaternion<Scalar_>, Options_>>;
 
-  typedef Scalar_ Scalar;
-  typedef typename internal::traits<Map>::Coefficients Coefficients;
+  using Scalar = Scalar_;
+  using Coefficients = typename internal::traits<Map>::Coefficients;
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
   using Base::operator*=;
 
@@ -488,10 +494,10 @@
 template <typename Scalar_, int Options_>
 class Map<Quaternion<Scalar_>, Options_> : public QuaternionBase<Map<Quaternion<Scalar_>, Options_> > {
  public:
-  typedef QuaternionBase<Map<Quaternion<Scalar_>, Options_> > Base;
+  using Base = QuaternionBase<Map<Quaternion<Scalar_>, Options_>>;
 
-  typedef Scalar_ Scalar;
-  typedef typename internal::traits<Map>::Coefficients Coefficients;
+  using Scalar = Scalar_;
+  using Coefficients = typename internal::traits<Map>::Coefficients;
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map)
   using Base::operator*=;
 
@@ -518,16 +524,16 @@
 
 /** \ingroup Geometry_Module
  * Map an unaligned array of single precision scalars as a quaternion */
-typedef Map<Quaternion<float>, 0> QuaternionMapf;
+using QuaternionMapf = Map<Quaternion<float>, 0>;
 /** \ingroup Geometry_Module
  * Map an unaligned array of double precision scalars as a quaternion */
-typedef Map<Quaternion<double>, 0> QuaternionMapd;
+using QuaternionMapd = Map<Quaternion<double>, 0>;
 /** \ingroup Geometry_Module
  * Map a 16-byte aligned array of single precision scalars as a quaternion */
-typedef Map<Quaternion<float>, Aligned> QuaternionMapAlignedf;
+using QuaternionMapAlignedf = Map<Quaternion<float>, Aligned>;
 /** \ingroup Geometry_Module
  * Map a 16-byte aligned array of double precision scalars as a quaternion */
-typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd;
+using QuaternionMapAlignedd = Map<Quaternion<double>, Aligned>;
 
 /***************************************************************************
  * Implementation of QuaternionBase methods
@@ -538,8 +544,19 @@
 namespace internal {
 template <int Arch, class Derived1, class Derived2, typename Scalar>
 struct quat_product {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived1>& a,
-                                                                      const QuaternionBase<Derived2>& b) {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Quaternion<Scalar> run(const QuaternionBase<Derived1>& input_a,
+                                                                      const QuaternionBase<Derived2>& input_b) {
+    const Derived1* a_ptr = &input_a.derived();
+    const Derived2* b_ptr = &input_b.derived();
+#if EIGEN_ARCH_ARM && EIGEN_COMP_CLANG
+    EIGEN_IF_CONSTEXPR (std::is_same<Scalar, double>::value) {
+      // Keep operand addresses opaque to LLVM's ARM load/store optimizer (llvm-project#223630).
+      // Register constraints avoid the spills introduced by the general optimization barrier.
+      asm("" : "+r"(a_ptr), "+r"(b_ptr));
+    }
+#endif
+    const Derived1& a = *a_ptr;
+    const Derived2& b = *b_ptr;
     return Quaternion<Scalar>(a.w() * b.w() - a.x() * b.x() - a.y() * b.y() - a.z() * b.z(),
                               a.w() * b.x() + a.x() * b.w() + a.y() * b.z() - a.z() * b.y(),
                               a.w() * b.y() + a.y() * b.w() + a.z() * b.x() - a.x() * b.z(),
@@ -554,7 +571,7 @@
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Quaternion<typename internal::traits<Derived>::Scalar>
 QuaternionBase<Derived>::operator*(const QuaternionBase<OtherDerived>& other) const {
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value),
+      (std::is_same<typename Derived::Scalar, typename OtherDerived::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
   return internal::quat_product<Architecture::Target, Derived, OtherDerived,
                                 typename internal::traits<Derived>::Scalar>::run(*this, other);
@@ -573,7 +590,7 @@
  * \remarks If the quaternion is used to rotate several points (>1)
  * then it is much more efficient to first convert it to a 3x3 Matrix.
  * Comparison of the operation cost for n transformations:
- *   - Quaternion2:    30n
+ *   - Quaternion:    30n
  *   - Via a Matrix3: 24 + 15n
  */
 template <class Derived>
@@ -626,7 +643,7 @@
 template <class MatrixDerived>
 EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::operator=(const MatrixBase<MatrixDerived>& xpr) {
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<typename Derived::Scalar, typename MatrixDerived::Scalar>::value),
+      (std::is_same<typename Derived::Scalar, typename MatrixDerived::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
   internal::quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived());
   return derived();
@@ -638,10 +655,7 @@
 template <class Derived>
 EIGEN_DEVICE_FUNC inline typename QuaternionBase<Derived>::Matrix3 QuaternionBase<Derived>::toRotationMatrix(
     void) const {
-  // NOTE if inlined, then gcc 4.2 and 4.4 get rid of the temporary (not gcc 4.3 !!)
-  // if not inlined then the cost of the return by value is huge ~ +35%,
-  // however, not inlining this function is an order of magnitude slower, so
-  // it has to be inlined, and so the return by value is not an issue
+  // Keep this inline: forcing an out-of-line call is much more expensive than returning Matrix3 by value.
   Matrix3 res;
 
   const Scalar tx = Scalar(2) * this->x();
@@ -690,19 +704,10 @@
   Scalar c = v1.dot(v0);
 
   // if dot == -1, vectors are nearly opposites
-  // => accurately compute the rotation axis by computing the
-  //    intersection of the two planes. This is done by solving:
-  //       x^T v0 = 0
-  //       x^T v1 = 0
-  //    under the constraint:
-  //       ||x|| = 1
-  //    which yields a singular value problem
+  // => any axis perpendicular to v0 will do for a ~180 degree rotation.
   if (c < Scalar(-1) + NumTraits<Scalar>::dummy_precision()) {
     c = numext::maxi(c, Scalar(-1));
-    Matrix<Scalar, 2, 3> m;
-    m << v0.transpose(), v1.transpose();
-    JacobiSVD<Matrix<Scalar, 2, 3>, ComputeFullV> svd(m);
-    Vector3 axis = svd.matrixV().col(2);
+    Vector3 axis = v0.unitOrthogonal();
 
     Scalar w2 = (Scalar(1) + c) * Scalar(0.5);
     this->w() = sqrt(w2);
@@ -718,6 +723,78 @@
   return derived();
 }
 
+/** Sets \c *this to the unit quaternion representing the rotation by `||scaled_axis||` radians
+ * around the axis `scaled_axis / ||scaled_axis||`. This is the SO(3) exponential map.
+ *
+ * The closed form \f$ q = (\cos(\theta/2),\;(\sin(\theta/2)/\theta)\,v),\;\theta=\|v\| \f$ is
+ * evaluated directly for every non-zero input; the limit value (the identity quaternion) is
+ * substituted only at the bit-exact zero input. No Taylor expansion and no scalar-type-
+ * dependent threshold are involved, and the result is accurate to a few ULPs across the
+ * full range of finite inputs.
+ *
+ * \sa toScaledAxis(), Quaternion::FromScaledAxis()
+ */
+template <class Derived>
+template <typename OtherDerived>
+EIGEN_DEVICE_FUNC inline Derived& QuaternionBase<Derived>::setFromScaledAxis(
+    const MatrixBase<OtherDerived>& scaled_axis) {
+  EIGEN_USING_STD(sin)
+  EIGEN_USING_STD(cos)
+  EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, 3)
+
+  // Materialise the input once so the caller's expression (e.g. omega*dt) is not
+  // recomputed by the norm and the subsequent assignment to vec().
+  const Vector3 v = scaled_axis;
+
+  // Fast path with stableNorm() fallback when norm() returns a suspiciously small
+  // value (below epsilon, where squaredNorm() may have underflowed); same idiom
+  // as AngleAxis::operator=(QuaternionBase).
+  Scalar angle = v.norm();
+  if (angle < NumTraits<Scalar>::epsilon()) angle = v.stableNorm();
+  if (numext::is_exactly_zero(angle)) {
+    this->w() = Scalar(1);
+    this->vec().setZero();
+    return derived();
+  }
+
+  const Scalar half_angle = Scalar(0.5) * angle;
+  this->w() = cos(half_angle);
+  this->vec() = (sin(half_angle) / angle) * v;
+  return derived();
+}
+
+/** \returns the rotation vector (axis scaled by the rotation angle in `[0, pi]`)
+ * corresponding to \c *this. This is the SO(3) logarithmic map and the inverse of
+ * setFromScaledAxis().
+ *
+ * The closed form \f$ v = (2\,\mathrm{atan2}(\|q_v\|,\,q_w)/\|q_v\|)\, q_v \f$ is evaluated
+ * directly for every quaternion with non-zero imaginary part; the limit value (the zero
+ * vector) is substituted only at the bit-exact zero imaginary part. The IEEE corner case
+ * `w == -0.0` is handled by passing \c |w| to \c atan2 and recovering the sign separately,
+ * mirroring AngleAxis::operator=(QuaternionBase). The result is accurate to a few ULPs.
+ *
+ * \pre \c *this is approximately a unit quaternion.
+ * \sa setFromScaledAxis(), Quaternion::FromScaledAxis()
+ */
+template <class Derived>
+EIGEN_DEVICE_FUNC inline typename QuaternionBase<Derived>::Vector3 QuaternionBase<Derived>::toScaledAxis() const {
+  EIGEN_USING_STD(atan2)
+  eigen_assert(internal::isApprox(this->squaredNorm(), Scalar(1), Scalar(8) * NumTraits<Scalar>::dummy_precision()) &&
+               "QuaternionBase::toScaledAxis(): the quaternion must be approximately a unit quaternion");
+
+  // Fast path with stableNorm() fallback; same idiom as AngleAxis::operator=(QuaternionBase).
+  Scalar sin_half_angle = this->vec().norm();
+  if (sin_half_angle < NumTraits<Scalar>::epsilon()) sin_half_angle = this->vec().stableNorm();
+  if (numext::is_exactly_zero(sin_half_angle)) return Vector3::Zero();
+
+  // |w| in atan2 prevents -0.0 from flipping the sign; recover it via the comparison below
+  // (false for both +0.0 and -0.0).
+  // Cannot overflow: for unit q, atan2(s, |c|) is O(s) as s -> 0, so k stays in [2, pi].
+  Scalar k = Scalar(2) * atan2(sin_half_angle, numext::abs(this->w())) / sin_half_angle;
+  if (this->w() < Scalar(0)) k = -k;
+  return k * this->vec();
+}
+
 /** \returns a random unit quaternion following a uniform distribution law on SO(3)
  *
  * \note The implementation is based on http://planning.cs.uiuc.edu/node198.html
@@ -781,6 +858,21 @@
   return quat;
 }
 
+/** Returns a unit quaternion representing the rotation by `||scaled_axis||` radians around
+ * the axis `scaled_axis / ||scaled_axis||`. The natural building block for SO(3)-aware
+ * integration of a body angular velocity \a omega over a small interval \a dt:
+ * \code Quaterniond q_next = q_curr * Quaterniond::FromScaledAxis(omega * dt); \endcode
+ * \sa setFromScaledAxis(), toScaledAxis()
+ */
+template <typename Scalar, int Options>
+template <typename Derived>
+EIGEN_DEVICE_FUNC Quaternion<Scalar, Options> Quaternion<Scalar, Options>::FromScaledAxis(
+    const MatrixBase<Derived>& scaled_axis) {
+  Quaternion quat;
+  quat.setFromScaledAxis(scaled_axis);
+  return quat;
+}
+
 /** \returns the multiplicative inverse of \c *this
  * Note that in most cases, i.e., if you simply want the opposite rotation,
  * and/or the quaternion is normalized, then it is enough to use the conjugate.
@@ -814,7 +906,7 @@
  * if the quaternion is normalized.
  * The conjugate of a quaternion represents the opposite rotation.
  *
- * \sa Quaternion2::inverse()
+ * \sa Quaternion::inverse()
  */
 template <class Derived>
 EIGEN_DEVICE_FUNC inline Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::conjugate()
@@ -854,6 +946,7 @@
   Scalar scale1;
 
   if (absD >= one) {
+    // Near-parallel quaternions: use lerp to avoid division by ~zero sinTheta.
     scale0 = Scalar(1) - t;
     scale1 = t;
   } else {
@@ -862,7 +955,7 @@
     Scalar sinTheta = numext::sqrt(Scalar(1) - absD * absD);
 
     scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
-    scale1 = sin((t * theta)) / sinTheta;
+    scale1 = sin(t * theta) / sinTheta;
   }
   if (d < Scalar(0)) scale1 = -scale1;
 
@@ -874,7 +967,7 @@
 // set from a rotation matrix
 template <typename Other>
 struct quaternionbase_assign_impl<Other, 3, 3> {
-  typedef typename Other::Scalar Scalar;
+  using Scalar = typename Other::Scalar;
   template <class Derived>
   EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& a_mat) {
     const typename internal::nested_eval<Other, 2>::type mat(a_mat);
@@ -883,7 +976,7 @@
     // Ken Shoemake, 1987 SIGGRAPH course notes
     Scalar t = mat.trace();
     if (t > Scalar(0)) {
-      t = sqrt(t + Scalar(1.0));
+      t = sqrt(numext::maxi(t + Scalar(1.0), Scalar(0)));
       q.w() = Scalar(0.5) * t;
       t = Scalar(0.5) / t;
       q.x() = (mat.coeff(2, 1) - mat.coeff(1, 2)) * t;
@@ -896,7 +989,8 @@
       Index j = (i + 1) % 3;
       Index k = (j + 1) % 3;
 
-      t = sqrt(mat.coeff(i, i) - mat.coeff(j, j) - mat.coeff(k, k) + Scalar(1.0));
+      // Guard against slightly negative argument from non-orthogonal matrices.
+      t = sqrt(numext::maxi(mat.coeff(i, i) - mat.coeff(j, j) - mat.coeff(k, k) + Scalar(1.0), Scalar(0)));
       q.coeffs().coeffRef(i) = Scalar(0.5) * t;
       t = Scalar(0.5) / t;
       q.w() = (mat.coeff(k, j) - mat.coeff(j, k)) * t;
@@ -909,7 +1003,7 @@
 // set from a vector of coefficients assumed to be a quaternion
 template <typename Other>
 struct quaternionbase_assign_impl<Other, 4, 1> {
-  typedef typename Other::Scalar Scalar;
+  using Scalar = typename Other::Scalar;
   template <class Derived>
   EIGEN_DEVICE_FUNC static inline void run(QuaternionBase<Derived>& q, const Other& vec) {
     q.coeffs() = vec;
diff --git a/Eigen/src/Geometry/Rotation2D.h b/Eigen/src/Geometry/Rotation2D.h
index 515bd27..31107b0 100644
--- a/Eigen/src/Geometry/Rotation2D.h
+++ b/Eigen/src/Geometry/Rotation2D.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ROTATION2D_H
 #define EIGEN_ROTATION2D_H
@@ -36,22 +37,22 @@
 
 template <typename Scalar_>
 struct traits<Rotation2D<Scalar_> > {
-  typedef Scalar_ Scalar;
+  using Scalar = Scalar_;
 };
 }  // end namespace internal
 
 template <typename Scalar_>
 class Rotation2D : public RotationBase<Rotation2D<Scalar_>, 2> {
-  typedef RotationBase<Rotation2D<Scalar_>, 2> Base;
+  using Base = RotationBase<Rotation2D<Scalar_>, 2>;
 
  public:
   using Base::operator*;
 
   enum { Dim = 2 };
   /** the scalar type of the coefficients */
-  typedef Scalar_ Scalar;
-  typedef Matrix<Scalar, 2, 1> Vector2;
-  typedef Matrix<Scalar, 2, 2> Matrix2;
+  using Scalar = Scalar_;
+  using Vector2 = Matrix<Scalar, 2, 1>;
+  using Matrix2 = Matrix<Scalar, 2, 2>;
 
  protected:
   Scalar m_angle;
@@ -116,7 +117,7 @@
   EIGEN_DEVICE_FUNC Matrix2 toRotationMatrix() const;
 
   /** Set \c *this from a 2x2 rotation matrix \a mat.
-   * In other words, this function extract the rotation angle from the rotation matrix.
+   * In other words, this function extracts the rotation angle from the rotation matrix.
    *
    * This method is an alias for fromRotationMatrix()
    *
@@ -166,13 +167,13 @@
 
 /** \ingroup Geometry_Module
  * single precision 2D rotation type */
-typedef Rotation2D<float> Rotation2Df;
+using Rotation2Df = Rotation2D<float>;
 /** \ingroup Geometry_Module
  * double precision 2D rotation type */
-typedef Rotation2D<double> Rotation2Dd;
+using Rotation2Dd = Rotation2D<double>;
 
 /** Set \c *this from a 2x2 rotation matrix \a mat.
- * In other words, this function extract the rotation angle
+ * In other words, this function extracts the rotation angle
  * from the rotation matrix.
  */
 template <typename Scalar>
diff --git a/Eigen/src/Geometry/RotationBase.h b/Eigen/src/Geometry/RotationBase.h
index 3a3a3e3..bba6803 100644
--- a/Eigen/src/Geometry/RotationBase.h
+++ b/Eigen/src/Geometry/RotationBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ROTATIONBASE_H
 #define EIGEN_ROTATIONBASE_H
@@ -33,11 +34,11 @@
  public:
   enum { Dim = Dim_ };
   /** the scalar type of the coefficients */
-  typedef typename internal::traits<Derived>::Scalar Scalar;
+  using Scalar = typename internal::traits<Derived>::Scalar;
 
   /** corresponding linear transformation matrix type */
-  typedef Matrix<Scalar, Dim, Dim> RotationMatrixType;
-  typedef Matrix<Scalar, Dim, 1> VectorType;
+  using RotationMatrixType = Matrix<Scalar, Dim, Dim>;
+  using VectorType = Matrix<Scalar, Dim, 1>;
 
  public:
   EIGEN_DEVICE_FUNC inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
@@ -47,7 +48,7 @@
   EIGEN_DEVICE_FUNC inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); }
 
   /** \returns an equivalent rotation matrix
-   * This function is added to be conform with the Transform class' naming scheme.
+   * This function is added to conform with the Transform class' naming scheme.
    */
   EIGEN_DEVICE_FUNC inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); }
 
@@ -111,7 +112,7 @@
 template <typename RotationDerived, typename MatrixType>
 struct rotation_base_generic_product_selector<RotationDerived, MatrixType, false> {
   enum { Dim = RotationDerived::Dim };
-  typedef Matrix<typename RotationDerived::Scalar, Dim, Dim> ReturnType;
+  using ReturnType = Matrix<typename RotationDerived::Scalar, Dim, Dim>;
   EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r, const MatrixType& m) {
     return r.toRotationMatrix() * m;
   }
@@ -119,7 +120,7 @@
 
 template <typename RotationDerived, typename Scalar, int Dim, int MaxDim>
 struct rotation_base_generic_product_selector<RotationDerived, DiagonalMatrix<Scalar, Dim, MaxDim>, false> {
-  typedef Transform<Scalar, Dim, Affine> ReturnType;
+  using ReturnType = Transform<Scalar, Dim, Affine>;
   EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r,
                                                  const DiagonalMatrix<Scalar, Dim, MaxDim>& m) {
     ReturnType res(r);
@@ -131,7 +132,7 @@
 template <typename RotationDerived, typename OtherVectorType>
 struct rotation_base_generic_product_selector<RotationDerived, OtherVectorType, true> {
   enum { Dim = RotationDerived::Dim };
-  typedef Matrix<typename RotationDerived::Scalar, Dim, 1> ReturnType;
+  using ReturnType = Matrix<typename RotationDerived::Scalar, Dim, 1>;
   EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE ReturnType run(const RotationDerived& r, const OtherVectorType& v) {
     return r._transformVector(v);
   }
@@ -168,7 +169,7 @@
 
 /** \internal
  *
- * Helper function to return an arbitrary rotation object to a rotation matrix.
+ * Helper function to convert an arbitrary rotation object to a rotation matrix.
  *
  * \tparam Scalar the numeric type of the matrix coefficients
  * \tparam Dim the dimension of the current space
@@ -184,22 +185,40 @@
  *
  * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis
  */
-template <typename Scalar, int Dim>
-EIGEN_DEVICE_FUNC static inline Matrix<Scalar, 2, 2> toRotationMatrix(const Scalar& s) {
+template <typename Scalar, int Dim, typename OtherScalar,
+          std::enable_if_t<std::is_scalar<OtherScalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar, 2, 2> toRotationMatrix(const OtherScalar& s) {
   EIGEN_STATIC_ASSERT(Dim == 2, YOU_MADE_A_PROGRAMMING_MISTAKE)
-  return Rotation2D<Scalar>(s).toRotationMatrix();
+  return Rotation2D<Scalar>(static_cast<Scalar>(s)).toRotationMatrix();
 }
 
-template <typename Scalar, int Dim, typename OtherDerived>
-EIGEN_DEVICE_FUNC static inline Matrix<Scalar, Dim, Dim> toRotationMatrix(const RotationBase<OtherDerived, Dim>& r) {
+template <typename Scalar, int Dim, typename OtherDerived,
+          std::enable_if_t<std::is_same<Scalar, typename OtherDerived::Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC static inline typename OtherDerived::RotationMatrixType toRotationMatrix(
+    const RotationBase<OtherDerived, Dim>& r) {
   return r.toRotationMatrix();
 }
 
-template <typename Scalar, int Dim, typename OtherDerived>
-EIGEN_DEVICE_FUNC static inline const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& mat) {
+template <typename Scalar, int Dim, typename OtherDerived,
+          std::enable_if_t<!std::is_same<Scalar, typename OtherDerived::Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC static inline Matrix<Scalar, Dim, Dim> toRotationMatrix(const RotationBase<OtherDerived, Dim>& r) {
+  return r.toRotationMatrix().template cast<Scalar>();
+}
+
+template <typename Scalar, int Dim, typename OtherDerived,
+          std::enable_if_t<std::is_same<Scalar, typename OtherDerived::Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC static inline const OtherDerived& toRotationMatrix(const MatrixBase<OtherDerived>& mat) {
   EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime == Dim && OtherDerived::ColsAtCompileTime == Dim,
                       YOU_MADE_A_PROGRAMMING_MISTAKE)
-  return mat;
+  return mat.derived();
+}
+
+template <typename Scalar, int Dim, typename OtherDerived,
+          std::enable_if_t<!std::is_same<Scalar, typename OtherDerived::Scalar>::value, int> = 0>
+EIGEN_DEVICE_FUNC static inline auto toRotationMatrix(const MatrixBase<OtherDerived>& mat) {
+  EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime == Dim && OtherDerived::ColsAtCompileTime == Dim,
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
+  return mat.template cast<Scalar>();
 }
 
 }  // end namespace internal
diff --git a/Eigen/src/Geometry/Scaling.h b/Eigen/src/Geometry/Scaling.h
index 5bb7c45..be50fde 100644
--- a/Eigen/src/Geometry/Scaling.h
+++ b/Eigen/src/Geometry/Scaling.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SCALING_H
 #define EIGEN_SCALING_H
@@ -23,7 +24,7 @@
  *
  * \tparam Scalar_ the scalar type, i.e., the type of the coefficients.
  *
- * This class represent a uniform scaling transformation. It is the return
+ * This class represents a uniform scaling transformation. It is the return
  * type of Scaling(Scalar), and most of the time this is the only way it
  * is used. In particular, this class is not aimed to be used to store a scaling transformation,
  * but rather to make easier the constructions and updates of Transform objects.
@@ -39,7 +40,7 @@
 template <typename Scalar, int Dim, int Mode>
 struct uniformscaling_times_affine_returntype {
   enum { NewMode = int(Mode) == int(Isometry) ? Affine : Mode };
-  typedef Transform<Scalar, Dim, NewMode> type;
+  using type = Transform<Scalar, Dim, NewMode>;
 };
 }  // namespace internal
 
@@ -47,7 +48,7 @@
 class UniformScaling {
  public:
   /** the scalar type of the coefficients */
-  typedef Scalar_ Scalar;
+  using Scalar = Scalar_;
 
  protected:
   Scalar m_factor;
@@ -129,7 +130,7 @@
 // NOTE this operator is defined in MatrixBase and not as a friend function
 // of UniformScaling to fix an internal crash of Intel's ICC
 template <typename Derived, typename Scalar>
-EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, Scalar, product)
+EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived, Scalar, internal::scalar_product_op)
 operator*(const MatrixBase<Derived>& matrix, const UniformScaling<Scalar>& s) {
   return matrix.derived() * s.factor();
 }
@@ -170,13 +171,13 @@
 }
 
 /** \deprecated */
-typedef DiagonalMatrix<float, 2> AlignedScaling2f;
+using AlignedScaling2f = DiagonalMatrix<float, 2>;
 /** \deprecated */
-typedef DiagonalMatrix<double, 2> AlignedScaling2d;
+using AlignedScaling2d = DiagonalMatrix<double, 2>;
 /** \deprecated */
-typedef DiagonalMatrix<float, 3> AlignedScaling3f;
+using AlignedScaling3f = DiagonalMatrix<float, 3>;
 /** \deprecated */
-typedef DiagonalMatrix<double, 3> AlignedScaling3d;
+using AlignedScaling3d = DiagonalMatrix<double, 3>;
 //@}
 
 template <typename Scalar>
diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h
index 88b6b30..7e977f1 100644
--- a/Eigen/src/Geometry/Transform.h
+++ b/Eigen/src/Geometry/Transform.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRANSFORM_H
 #define EIGEN_TRANSFORM_H
@@ -51,11 +52,37 @@
 template <typename TransformType>
 struct transform_take_affine_part;
 
+template <typename LhsScalar, typename RhsScalar, typename BinaryOp, typename TargetScalar, typename = void>
+struct has_matching_binary_op_traits : std::false_type {};
+
+template <typename LhsScalar, typename RhsScalar, typename BinaryOp, typename TargetScalar>
+struct has_matching_binary_op_traits<LhsScalar, RhsScalar, BinaryOp, TargetScalar,
+                                     void_t<typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, BinaryOp>::ReturnType>>
+    : std::integral_constant<
+          bool, std::is_convertible<typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, BinaryOp>::ReturnType,
+                                    TargetScalar>::value ||
+                    std::is_assignable<TargetScalar&,
+                                       typename ScalarBinaryOpTraits<LhsScalar, RhsScalar, BinaryOp>::ReturnType>::value> {};
+
+template <typename TargetScalar, typename Derived, typename LhsScalar, typename RhsScalar, typename BinaryOp,
+          typename = void>
+struct transform_convert_arg {
+  EIGEN_DEVICE_FUNC static auto run(const MatrixBase<Derived>& mat) { return mat.template cast<TargetScalar>(); }
+};
+
+template <typename TargetScalar, typename Derived, typename LhsScalar, typename RhsScalar, typename BinaryOp>
+struct transform_convert_arg<
+    TargetScalar, Derived, LhsScalar, RhsScalar, BinaryOp,
+    std::enable_if_t<std::is_same<typename Derived::Scalar, TargetScalar>::value ||
+                     has_matching_binary_op_traits<LhsScalar, RhsScalar, BinaryOp, TargetScalar>::value>> {
+  EIGEN_DEVICE_FUNC static const Derived& run(const MatrixBase<Derived>& mat) { return mat.derived(); }
+};
+
 template <typename Scalar_, int Dim_, int Mode_, int Options_>
 struct traits<Transform<Scalar_, Dim_, Mode_, Options_> > {
-  typedef Scalar_ Scalar;
-  typedef Eigen::Index StorageIndex;
-  typedef Dense StorageKind;
+  using Scalar = Scalar_;
+  using StorageIndex = Eigen::Index;
+  using StorageKind = Dense;
   enum {
     Dim1 = Dim_ == Dynamic ? Dim_ : Dim_ + 1,
     RowsAtCompileTime = Mode_ == Projective ? Dim1 : Dim_,
@@ -116,8 +143,8 @@
  * its principle consists to first convert the right/left hand sides of the product
  * to a compatible (Dim+1)^2 matrix and then perform a pure matrix product.
  * Of course, internally, operator* tries to perform the minimal number of operations
- * according to the nature of each terms. Likewise, when applying the transform
- * to points, the latters are automatically promoted to homogeneous vectors
+ * according to the nature of each term. Likewise, when applying the transform
+ * to points, the latter are automatically promoted to homogeneous vectors
  * before doing the matrix product. The conventions to homogeneous representations
  * are performed as follow:
  *
@@ -171,10 +198,13 @@
  * that case the last matrix row can be ignored, and the product returns non
  * homogeneous vectors.
  *
- * Since, for instance, a Dim x Dim matrix is interpreted as a linear transformation,
- * it is not possible to directly transform Dim vectors stored in a Dim x Dim matrix.
- * The solution is either to use a Dim x Dynamic matrix or explicitly request a
- * vector transformation by making the vector homogeneous:
+ * In particular, a Dim x Dim matrix on the right-hand side of a Transform is not
+ * interpreted as a linear transformation: like any Dim x n matrix, its columns are
+ * transformed as points, so that for Mode!=Projective, T*m returns the Dim x Dim matrix
+ * (T.linear()*m).colwise() + T.translation(). A Dim x Dim matrix is interpreted as a linear
+ * transformation in the other direction of the product, and when it is assigned to a Transform,
+ * passed to a Transform constructor, or given to rotate()/prerotate().
+ * To obtain the result in homogeneous coordinates, make the points homogeneous explicitly:
  * \code
  * m' = T * m.colwise().homogeneous();
  * \endcode
@@ -198,43 +228,40 @@
     Options = Options_,
     Dim = Dim_,       ///< space dimension in which the transformation holds
     HDim = Dim_ + 1,  ///< size of a respective homogeneous vector
-    Rows = int(Mode) == (AffineCompact) ? Dim : HDim
+    Rows = int(Mode) == int(AffineCompact) ? Dim : HDim
   };
   /** the scalar type of the coefficients */
-  typedef Scalar_ Scalar;
-  typedef Eigen::Index StorageIndex;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
+  using Scalar = Scalar_;
+  using StorageIndex = Eigen::Index;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
   /** type of the matrix used to represent the transformation */
-  typedef typename internal::make_proper_matrix_type<Scalar, Rows, HDim, Options>::type MatrixType;
+  using MatrixType = typename internal::make_proper_matrix_type<Scalar, Rows, HDim, Options>::type;
   /** constified MatrixType */
-  typedef const MatrixType ConstMatrixType;
+  using ConstMatrixType = const MatrixType;
   /** type of the matrix used to represent the linear part of the transformation */
-  typedef Matrix<Scalar, Dim, Dim, Options> LinearMatrixType;
+  using LinearMatrixType = Matrix<Scalar, Dim, Dim, Options>;
   /** type of read/write reference to the linear part of the transformation */
-  typedef Block<MatrixType, Dim, Dim, int(Mode) == (AffineCompact) && (int(Options) & RowMajor) == 0> LinearPart;
+  using LinearPart = Block<MatrixType, Dim, Dim, int(Mode) == (AffineCompact) && (int(Options) & RowMajor) == 0>;
   /** type of read reference to the linear part of the transformation */
-  typedef const Block<ConstMatrixType, Dim, Dim, int(Mode) == (AffineCompact) && (int(Options) & RowMajor) == 0>
-      ConstLinearPart;
+  using ConstLinearPart =
+      const Block<ConstMatrixType, Dim, Dim, int(Mode) == (AffineCompact) && (int(Options) & RowMajor) == 0>;
   /** type of read/write reference to the affine part of the transformation */
-  typedef std::conditional_t<int(Mode) == int(AffineCompact), MatrixType&, Block<MatrixType, Dim, HDim> > AffinePart;
+  using AffinePart = std::conditional_t<int(Mode) == int(AffineCompact), MatrixType&, Block<MatrixType, Dim, HDim>>;
   /** type of read reference to the affine part of the transformation */
-  typedef std::conditional_t<int(Mode) == int(AffineCompact), const MatrixType&,
-                             const Block<const MatrixType, Dim, HDim> >
-      ConstAffinePart;
+  using ConstAffinePart =
+      std::conditional_t<int(Mode) == int(AffineCompact), const MatrixType&, const Block<const MatrixType, Dim, HDim>>;
   /** type of a vector */
-  typedef Matrix<Scalar, Dim, 1> VectorType;
+  using VectorType = Matrix<Scalar, Dim, 1>;
   /** type of a read/write reference to the translation part of the rotation */
-  typedef Block<MatrixType, Dim, 1, !(internal::traits<MatrixType>::Flags & RowMajorBit)> TranslationPart;
+  using TranslationPart = Block<MatrixType, Dim, 1, !(internal::traits<MatrixType>::Flags & RowMajorBit)>;
   /** type of a read reference to the translation part of the rotation */
-  typedef const Block<ConstMatrixType, Dim, 1, !(internal::traits<MatrixType>::Flags & RowMajorBit)>
-      ConstTranslationPart;
+  using ConstTranslationPart =
+      const Block<ConstMatrixType, Dim, 1, !(internal::traits<MatrixType>::Flags & RowMajorBit)>;
   /** corresponding translation type */
-  typedef Translation<Scalar, Dim> TranslationType;
+  using TranslationType = Translation<Scalar, Dim>;
 
-  // this intermediate enum is needed to avoid an ICE with gcc 3.4 and 4.0
-  enum { TransformTimeDiagonalMode = ((Mode == int(Isometry)) ? Affine : int(Mode)) };
   /** The return type of the product between a diagonal matrix and a transform */
-  typedef Transform<Scalar, Dim, TransformTimeDiagonalMode> TransformTimeDiagonalReturnType;
+  using TransformTimeDiagonalReturnType = Transform<Scalar, Dim, (Mode == int(Isometry)) ? int(Affine) : int(Mode)>;
 
  protected:
   MatrixType m_matrix;
@@ -248,6 +275,11 @@
         m_matrix);
   }
 
+  // These conversion ctors are intentionally `explicit`: keeping copy-init
+  // (`Transform t = rot;`) from compiling stops a Dim+1 x Dim+1 matrix
+  // from being silently materialized in function-call argument lists.
+  // Use direct-init (`Transform t(rot);`) or assignment (`Transform t; t = rot;`)
+  // instead. See bug #1209.
   EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t) {
     check_template_params();
     *this = t;
@@ -262,13 +294,13 @@
     *this = r;
   }
 
-  typedef internal::transform_take_affine_part<Transform> take_affine_part;
+  using take_affine_part = internal::transform_take_affine_part<Transform>;
 
   /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC inline explicit Transform(const EigenBase<OtherDerived>& other) {
     EIGEN_STATIC_ASSERT(
-        (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
 
     check_template_params();
@@ -279,7 +311,7 @@
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC inline Transform& operator=(const EigenBase<OtherDerived>& other) {
     EIGEN_STATIC_ASSERT(
-        (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
 
     internal::transform_construct_from_matrix<OtherDerived, Mode, Options, Dim, HDim>::run(this, other.derived());
@@ -319,7 +351,7 @@
       m_matrix.template block<Dim, Dim + 1>(0, 0) = other.matrix().template block<Dim, Dim + 1>(0, 0);
       makeAffine();
     } else if (EIGEN_CONST_CONDITIONAL(OtherModeIsAffineCompact)) {
-      typedef typename Transform<Scalar, Dim, OtherMode, OtherOptions>::MatrixType OtherMatrixType;
+      using OtherMatrixType = typename Transform<Scalar, Dim, OtherMode, OtherOptions>::MatrixType;
       internal::transform_construct_from_matrix<OtherMatrixType, Mode, Options, Dim, HDim>::run(this, other.matrix());
     } else {
       // here we know that Mode == AffineCompact and OtherMode != AffineCompact.
@@ -423,7 +455,7 @@
   template <typename OtherDerived>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform,
                                                                                               OtherDerived>::ResultType
-  operator*(const EigenBase<OtherDerived>& other) const {
+  operator*(const MatrixBase<OtherDerived>& other) const {
     return internal::transform_right_product_impl<Transform, OtherDerived>::run(*this, other.derived());
   }
 
@@ -437,7 +469,7 @@
   template <typename OtherDerived>
   friend EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived, Mode, Options,
                                                                                        Dim_, Dim_ + 1>::ResultType
-  operator*(const EigenBase<OtherDerived>& a, const Transform& b) {
+  operator*(const MatrixBase<OtherDerived>& a, const Transform& b) {
     return internal::transform_left_product_impl<OtherDerived, Mode, Options, Dim, HDim>::run(a.derived(), b);
   }
 
@@ -472,7 +504,7 @@
   }
 
   template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC inline Transform& operator*=(const EigenBase<OtherDerived>& other) {
+  EIGEN_DEVICE_FUNC inline Transform& operator*=(const MatrixBase<OtherDerived>& other) {
     return *this = *this * other;
   }
 
@@ -481,32 +513,6 @@
     return internal::transform_transform_product_impl<Transform, Transform>::run(*this, other);
   }
 
-#if EIGEN_COMP_ICC
- private:
-  // this intermediate structure permits to workaround a bug in ICC 11:
-  //   error: template instantiation resulted in unexpected function type of "Eigen::Transform<double, 3, 32, 0>
-  //             (const Eigen::Transform<double, 3, 2, 0> &) const"
-  //  (the meaning of a name may have changed since the template declaration -- the type of the template is:
-  // "Eigen::internal::transform_transform_product_impl<Eigen::Transform<double, 3, 32, 0>,
-  //     Eigen::Transform<double, 3, Mode, Options>, <expression>>::ResultType (const Eigen::Transform<double, 3, Mode,
-  //     Options> &) const")
-  //
-  template <int OtherMode, int OtherOptions>
-  struct icc_11_workaround {
-    typedef internal::transform_transform_product_impl<Transform, Transform<Scalar, Dim, OtherMode, OtherOptions> >
-        ProductType;
-    typedef typename ProductType::ResultType ResultType;
-  };
-
- public:
-  /** Concatenates two different transformations */
-  template <int OtherMode, int OtherOptions>
-  inline typename icc_11_workaround<OtherMode, OtherOptions>::ResultType operator*(
-      const Transform<Scalar, Dim, OtherMode, OtherOptions>& other) const {
-    typedef typename icc_11_workaround<OtherMode, OtherOptions>::ProductType ProductType;
-    return ProductType::run(*this, other);
-  }
-#else
   /** Concatenates two different transformations */
   template <int OtherMode, int OtherOptions>
   EIGEN_DEVICE_FUNC inline
@@ -516,7 +522,6 @@
     return internal::transform_transform_product_impl<Transform, Transform<Scalar, Dim, OtherMode, OtherOptions> >::run(
         *this, other);
   }
-#endif
 
   /** \sa MatrixBase::setIdentity() */
   EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
@@ -581,7 +586,7 @@
   template <typename Derived>
   EIGEN_DEVICE_FUNC inline Transform operator*(const RotationBase<Derived, Dim>& r) const;
 
-  typedef std::conditional_t<int(Mode) == Isometry, ConstLinearPart, const LinearMatrixType> RotationReturnType;
+  using RotationReturnType = std::conditional_t<int(Mode) == Isometry, ConstLinearPart, const LinearMatrixType>;
   EIGEN_DEVICE_FUNC RotationReturnType rotation() const;
 
   template <typename RotationMatrixType, typename ScalingMatrixType>
@@ -677,40 +682,40 @@
 };
 
 /** \ingroup Geometry_Module */
-typedef Transform<float, 2, Isometry> Isometry2f;
+using Isometry2f = Transform<float, 2, Isometry>;
 /** \ingroup Geometry_Module */
-typedef Transform<float, 3, Isometry> Isometry3f;
+using Isometry3f = Transform<float, 3, Isometry>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 2, Isometry> Isometry2d;
+using Isometry2d = Transform<double, 2, Isometry>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 3, Isometry> Isometry3d;
+using Isometry3d = Transform<double, 3, Isometry>;
 
 /** \ingroup Geometry_Module */
-typedef Transform<float, 2, Affine> Affine2f;
+using Affine2f = Transform<float, 2, Affine>;
 /** \ingroup Geometry_Module */
-typedef Transform<float, 3, Affine> Affine3f;
+using Affine3f = Transform<float, 3, Affine>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 2, Affine> Affine2d;
+using Affine2d = Transform<double, 2, Affine>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 3, Affine> Affine3d;
+using Affine3d = Transform<double, 3, Affine>;
 
 /** \ingroup Geometry_Module */
-typedef Transform<float, 2, AffineCompact> AffineCompact2f;
+using AffineCompact2f = Transform<float, 2, AffineCompact>;
 /** \ingroup Geometry_Module */
-typedef Transform<float, 3, AffineCompact> AffineCompact3f;
+using AffineCompact3f = Transform<float, 3, AffineCompact>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 2, AffineCompact> AffineCompact2d;
+using AffineCompact2d = Transform<double, 2, AffineCompact>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 3, AffineCompact> AffineCompact3d;
+using AffineCompact3d = Transform<double, 3, AffineCompact>;
 
 /** \ingroup Geometry_Module */
-typedef Transform<float, 2, Projective> Projective2f;
+using Projective2f = Transform<float, 2, Projective>;
 /** \ingroup Geometry_Module */
-typedef Transform<float, 3, Projective> Projective3f;
+using Projective3f = Transform<float, 3, Projective>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 2, Projective> Projective2d;
+using Projective2d = Transform<double, 2, Projective>;
 /** \ingroup Geometry_Module */
-typedef Transform<double, 3, Projective> Projective3d;
+using Projective3d = Transform<double, 3, Projective>;
 
 /**************************
 *** Optional QT support ***
@@ -815,7 +820,7 @@
     const MatrixBase<OtherDerived>& other) {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, int(Dim))
   EIGEN_STATIC_ASSERT(Mode != int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
-  linearExt().noalias() = (linearExt() * other.asDiagonal());
+  linearExt() = linearExt() * other.asDiagonal();
   return *this;
 }
 
@@ -841,7 +846,7 @@
     const MatrixBase<OtherDerived>& other) {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, int(Dim))
   EIGEN_STATIC_ASSERT(Mode != int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
-  affine().noalias() = (other.asDiagonal() * affine());
+  affine() = other.asDiagonal() * affine();
   return *this;
 }
 
@@ -866,7 +871,10 @@
 EIGEN_DEVICE_FUNC Transform<Scalar, Dim, Mode, Options>& Transform<Scalar, Dim, Mode, Options>::translate(
     const MatrixBase<OtherDerived>& other) {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, int(Dim))
-  translationExt() += linearExt() * other;
+  translationExt() +=
+      linearExt() *
+      internal::transform_convert_arg<Scalar, OtherDerived, Scalar, typename OtherDerived::Scalar,
+                                      internal::fast_mult_op<Scalar, typename OtherDerived::Scalar>>::run(other);
   return *this;
 }
 
@@ -880,12 +888,95 @@
     const MatrixBase<OtherDerived>& other) {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived, int(Dim))
   if (EIGEN_CONST_CONDITIONAL(int(Mode) == int(Projective)))
-    affine() += other * m_matrix.row(Dim);
+    affine() +=
+        internal::transform_convert_arg<Scalar, OtherDerived, typename OtherDerived::Scalar, Scalar,
+                                        internal::fast_mult_op<typename OtherDerived::Scalar, Scalar>>::run(other) *
+        m_matrix.row(Dim);
   else
-    translation() += other;
+    translation() +=
+        internal::transform_convert_arg<Scalar, OtherDerived, Scalar, typename OtherDerived::Scalar,
+                                        internal::scalar_sum_op<Scalar, typename OtherDerived::Scalar>>::run(other);
   return *this;
 }
 
+namespace internal {
+
+template <typename TransformType, typename RotationType, typename Enable = void>
+struct transform_rotate_impl {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const RotationType& rotation) {
+    t.linearExt() *= internal::toRotationMatrix<typename TransformType::Scalar, TransformType::Dim>(rotation);
+  }
+};
+
+template <typename TransformType, typename Derived>
+struct transform_rotate_impl<TransformType, Derived,
+                             std::enable_if_t<std::is_base_of<MatrixBase<Derived>, Derived>::value>> {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const Derived& rotation) {
+    using Scalar = typename TransformType::Scalar;
+    t.linearExt() *= internal::transform_convert_arg<
+        Scalar, Derived, Scalar, typename Derived::Scalar,
+        internal::fast_mult_op<Scalar, typename Derived::Scalar>>::run(rotation);
+  }
+};
+
+template <typename TransformType, typename Derived>
+struct transform_rotate_impl<
+    TransformType, Derived,
+    std::enable_if_t<std::is_base_of<RotationBase<Derived, TransformType::Dim>, Derived>::value>> {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const Derived& rotation) {
+    t.rotate(rotation.toRotationMatrix());
+  }
+};
+
+template <typename TransformType, typename OtherScalar>
+struct transform_rotate_impl<TransformType, OtherScalar, std::enable_if_t<std::is_scalar<OtherScalar>::value>> {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const OtherScalar& rotation) {
+    EIGEN_STATIC_ASSERT(TransformType::Dim == 2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    t.rotate(Rotation2D<OtherScalar>(rotation).toRotationMatrix());
+  }
+};
+
+template <typename TransformType, typename RotationType, typename Enable = void>
+struct transform_prerotate_impl {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const RotationType& rotation) {
+    t.matrix().template block<TransformType::Dim, TransformType::HDim>(0, 0) =
+        internal::toRotationMatrix<typename TransformType::Scalar, TransformType::Dim>(rotation) *
+        t.matrix().template block<TransformType::Dim, TransformType::HDim>(0, 0);
+  }
+};
+
+template <typename TransformType, typename Derived>
+struct transform_prerotate_impl<TransformType, Derived,
+                                std::enable_if_t<std::is_base_of<MatrixBase<Derived>, Derived>::value>> {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const Derived& rotation) {
+    using Scalar = typename TransformType::Scalar;
+    t.matrix().template block<TransformType::Dim, TransformType::HDim>(0, 0) =
+        internal::transform_convert_arg<
+            Scalar, Derived, typename Derived::Scalar, Scalar,
+            internal::fast_mult_op<typename Derived::Scalar, Scalar>>::run(rotation) *
+        t.matrix().template block<TransformType::Dim, TransformType::HDim>(0, 0);
+  }
+};
+
+template <typename TransformType, typename Derived>
+struct transform_prerotate_impl<
+    TransformType, Derived,
+    std::enable_if_t<std::is_base_of<RotationBase<Derived, TransformType::Dim>, Derived>::value>> {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const Derived& rotation) {
+    t.prerotate(rotation.toRotationMatrix());
+  }
+};
+
+template <typename TransformType, typename OtherScalar>
+struct transform_prerotate_impl<TransformType, OtherScalar, std::enable_if_t<std::is_scalar<OtherScalar>::value>> {
+  EIGEN_DEVICE_FUNC static inline void run(TransformType& t, const OtherScalar& rotation) {
+    EIGEN_STATIC_ASSERT(TransformType::Dim == 2, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    t.prerotate(Rotation2D<OtherScalar>(rotation).toRotationMatrix());
+  }
+};
+
+}  // end namespace internal
+
 /** Applies on the right the rotation represented by the rotation \a rotation
  * to \c *this and returns a reference to \c *this.
  *
@@ -907,7 +998,7 @@
 template <typename RotationType>
 EIGEN_DEVICE_FUNC Transform<Scalar, Dim, Mode, Options>& Transform<Scalar, Dim, Mode, Options>::rotate(
     const RotationType& rotation) {
-  linearExt() *= internal::toRotationMatrix<Scalar, Dim>(rotation);
+  internal::transform_rotate_impl<Transform, RotationType>::run(*this, rotation);
   return *this;
 }
 
@@ -922,8 +1013,7 @@
 template <typename RotationType>
 EIGEN_DEVICE_FUNC Transform<Scalar, Dim, Mode, Options>& Transform<Scalar, Dim, Mode, Options>::prerotate(
     const RotationType& rotation) {
-  m_matrix.template block<Dim, HDim>(0, 0) =
-      internal::toRotationMatrix<Scalar, Dim>(rotation) * m_matrix.template block<Dim, HDim>(0, 0);
+  internal::transform_prerotate_impl<Transform, RotationType>::run(*this, rotation);
   return *this;
 }
 
@@ -1015,7 +1105,7 @@
 struct transform_rotation_impl {
   template <typename TransformType>
   EIGEN_DEVICE_FUNC static inline const typename TransformType::LinearMatrixType run(const TransformType& t) {
-    typedef typename TransformType::LinearMatrixType LinearMatrixType;
+    using LinearMatrixType = typename TransformType::LinearMatrixType;
     LinearMatrixType result;
     t.computeRotationScaling(&result, (LinearMatrixType*)0);
     return result;
@@ -1141,10 +1231,12 @@
   EIGEN_DEVICE_FUNC static void run(MatrixType&) {}
 };
 
-// selector needed to avoid taking the inverse of a 3x4 matrix
+// Selector needed to avoid taking the inverse of a 3x4 matrix. Only a Projective transform can store a general
+// inverse; for every other mode the type itself guarantees the transform is affine, so a Projective hint - which only
+// asks that no extra structure be assumed - is honoured by the general affine inverse.
 template <typename TransformType, int Mode = TransformType::Mode>
 struct projective_transform_inverse {
-  EIGEN_DEVICE_FUNC static inline void run(const TransformType&, TransformType&) {}
+  EIGEN_DEVICE_FUNC static inline void run(const TransformType& m, TransformType& res) { res = m.inverse(Affine); }
 };
 
 template <typename TransformType>
@@ -1206,9 +1298,9 @@
 
 template <typename TransformType>
 struct transform_take_affine_part {
-  typedef typename TransformType::MatrixType MatrixType;
-  typedef typename TransformType::AffinePart AffinePart;
-  typedef typename TransformType::ConstAffinePart ConstAffinePart;
+  using MatrixType = typename TransformType::MatrixType;
+  using AffinePart = typename TransformType::AffinePart;
+  using ConstAffinePart = typename TransformType::ConstAffinePart;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE AffinePart run(MatrixType& m) {
     return m.template block<TransformType::Dim, TransformType::HDim>(0, 0);
   }
@@ -1219,7 +1311,7 @@
 
 template <typename Scalar, int Dim, int Options>
 struct transform_take_affine_part<Transform<Scalar, Dim, AffineCompact, Options> > {
-  typedef typename Transform<Scalar, Dim, AffineCompact, Options>::MatrixType MatrixType;
+  using MatrixType = typename Transform<Scalar, Dim, AffineCompact, Options>::MatrixType;
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE MatrixType& run(MatrixType& m) { return m; }
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const MatrixType& run(const MatrixType& m) { return m; }
 };
@@ -1264,7 +1356,7 @@
 };
 
 /**********************************************************
-***   Specializations of operator* with rhs EigenBase   ***
+***   Specializations of operator* with rhs MatrixBase  ***
 **********************************************************/
 
 template <int LhsMode, int RhsMode>
@@ -1280,7 +1372,7 @@
 
 template <typename TransformType, typename MatrixType, int RhsCols>
 struct transform_right_product_impl<TransformType, MatrixType, 0, RhsCols> {
-  typedef typename MatrixType::PlainObject ResultType;
+  using ResultType = typename MatrixType::PlainObject;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other) {
     return T.matrix() * other;
@@ -1296,12 +1388,12 @@
     OtherCols = MatrixType::ColsAtCompileTime
   };
 
-  typedef typename MatrixType::PlainObject ResultType;
+  using ResultType = typename MatrixType::PlainObject;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other) {
     EIGEN_STATIC_ASSERT(OtherRows == HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
 
-    typedef Block<ResultType, Dim, OtherCols, int(MatrixType::RowsAtCompileTime) == Dim> TopLeftLhs;
+    using TopLeftLhs = Block<ResultType, Dim, OtherCols, int(MatrixType::RowsAtCompileTime) == Dim>;
 
     ResultType res(other.rows(), other.cols());
     TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.affine() * other;
@@ -1320,12 +1412,12 @@
     OtherCols = MatrixType::ColsAtCompileTime
   };
 
-  typedef typename MatrixType::PlainObject ResultType;
+  using ResultType = typename MatrixType::PlainObject;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other) {
     EIGEN_STATIC_ASSERT(OtherRows == Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
 
-    typedef Block<ResultType, Dim, OtherCols, true> TopLeftLhs;
+    using TopLeftLhs = Block<ResultType, Dim, OtherCols, true>;
     ResultType res(
         Replicate<typename TransformType::ConstTranslationPart, 1, OtherCols>(T.translation(), 1, other.cols()));
     TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() += T.linear() * other;
@@ -1337,7 +1429,7 @@
 template <typename TransformType, typename MatrixType>
 struct transform_right_product_impl<TransformType, MatrixType, 2, 1>  // rhs is a vector of size Dim
 {
-  typedef typename TransformType::MatrixType TransformMatrix;
+  using TransformMatrix = typename TransformType::MatrixType;
   enum {
     Dim = TransformType::Dim,
     HDim = TransformType::HDim,
@@ -1345,7 +1437,7 @@
     WorkingRows = plain_enum_min(TransformMatrix::RowsAtCompileTime, HDim)
   };
 
-  typedef typename MatrixType::PlainObject ResultType;
+  using ResultType = typename MatrixType::PlainObject;
 
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other) {
     EIGEN_STATIC_ASSERT(OtherRows == Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
@@ -1365,9 +1457,9 @@
 // generic HDim x HDim matrix * T => Projective
 template <typename Other, int Mode, int Options, int Dim, int HDim>
 struct transform_left_product_impl<Other, Mode, Options, Dim, HDim, HDim, HDim> {
-  typedef Transform<typename Other::Scalar, Dim, Mode, Options> TransformType;
-  typedef typename TransformType::MatrixType MatrixType;
-  typedef Transform<typename Other::Scalar, Dim, Projective, Options> ResultType;
+  using TransformType = Transform<typename Other::Scalar, Dim, Mode, Options>;
+  using MatrixType = typename TransformType::MatrixType;
+  using ResultType = Transform<typename Other::Scalar, Dim, Projective, Options>;
   static EIGEN_DEVICE_FUNC ResultType run(const Other& other, const TransformType& tr) {
     return ResultType(other * tr.matrix());
   }
@@ -1376,9 +1468,9 @@
 // generic HDim x HDim matrix * AffineCompact => Projective
 template <typename Other, int Options, int Dim, int HDim>
 struct transform_left_product_impl<Other, AffineCompact, Options, Dim, HDim, HDim, HDim> {
-  typedef Transform<typename Other::Scalar, Dim, AffineCompact, Options> TransformType;
-  typedef typename TransformType::MatrixType MatrixType;
-  typedef Transform<typename Other::Scalar, Dim, Projective, Options> ResultType;
+  using TransformType = Transform<typename Other::Scalar, Dim, AffineCompact, Options>;
+  using MatrixType = typename TransformType::MatrixType;
+  using ResultType = Transform<typename Other::Scalar, Dim, Projective, Options>;
   static EIGEN_DEVICE_FUNC ResultType run(const Other& other, const TransformType& tr) {
     ResultType res;
     res.matrix().noalias() = other.template block<HDim, Dim>(0, 0) * tr.matrix();
@@ -1390,9 +1482,9 @@
 // affine matrix * T
 template <typename Other, int Mode, int Options, int Dim, int HDim>
 struct transform_left_product_impl<Other, Mode, Options, Dim, HDim, Dim, HDim> {
-  typedef Transform<typename Other::Scalar, Dim, Mode, Options> TransformType;
-  typedef typename TransformType::MatrixType MatrixType;
-  typedef TransformType ResultType;
+  using TransformType = Transform<typename Other::Scalar, Dim, Mode, Options>;
+  using MatrixType = typename TransformType::MatrixType;
+  using ResultType = TransformType;
   static EIGEN_DEVICE_FUNC ResultType run(const Other& other, const TransformType& tr) {
     ResultType res;
     res.affine().noalias() = other * tr.matrix();
@@ -1404,9 +1496,9 @@
 // affine matrix * AffineCompact
 template <typename Other, int Options, int Dim, int HDim>
 struct transform_left_product_impl<Other, AffineCompact, Options, Dim, HDim, Dim, HDim> {
-  typedef Transform<typename Other::Scalar, Dim, AffineCompact, Options> TransformType;
-  typedef typename TransformType::MatrixType MatrixType;
-  typedef TransformType ResultType;
+  using TransformType = Transform<typename Other::Scalar, Dim, AffineCompact, Options>;
+  using MatrixType = typename TransformType::MatrixType;
+  using ResultType = TransformType;
   static EIGEN_DEVICE_FUNC ResultType run(const Other& other, const TransformType& tr) {
     ResultType res;
     res.matrix().noalias() = other.template block<Dim, Dim>(0, 0) * tr.matrix();
@@ -1418,12 +1510,12 @@
 // linear matrix * T
 template <typename Other, int Mode, int Options, int Dim, int HDim>
 struct transform_left_product_impl<Other, Mode, Options, Dim, HDim, Dim, Dim> {
-  typedef Transform<typename Other::Scalar, Dim, Mode, Options> TransformType;
-  typedef typename TransformType::MatrixType MatrixType;
-  typedef TransformType ResultType;
+  using TransformType = Transform<typename Other::Scalar, Dim, Mode, Options>;
+  using MatrixType = typename TransformType::MatrixType;
+  using ResultType = TransformType;
   static EIGEN_DEVICE_FUNC ResultType run(const Other& other, const TransformType& tr) {
     TransformType res;
-    if (Mode != int(AffineCompact)) res.matrix().row(Dim) = tr.matrix().row(Dim);
+    EIGEN_IF_CONSTEXPR (Mode != int(AffineCompact)) res.matrix().row(Dim) = tr.matrix().row(Dim);
     res.matrix().template topRows<Dim>().noalias() = other * tr.matrix().template topRows<Dim>();
     return res;
   }
@@ -1437,13 +1529,13 @@
 struct transform_transform_product_impl<Transform<Scalar, Dim, LhsMode, LhsOptions>,
                                         Transform<Scalar, Dim, RhsMode, RhsOptions>, false> {
   enum { ResultMode = transform_product_result<LhsMode, RhsMode>::Mode };
-  typedef Transform<Scalar, Dim, LhsMode, LhsOptions> Lhs;
-  typedef Transform<Scalar, Dim, RhsMode, RhsOptions> Rhs;
-  typedef Transform<Scalar, Dim, ResultMode, LhsOptions> ResultType;
+  using Lhs = Transform<Scalar, Dim, LhsMode, LhsOptions>;
+  using Rhs = Transform<Scalar, Dim, RhsMode, RhsOptions>;
+  using ResultType = Transform<Scalar, Dim, ResultMode, LhsOptions>;
   static EIGEN_DEVICE_FUNC ResultType run(const Lhs& lhs, const Rhs& rhs) {
     ResultType res;
     res.linear().noalias() = lhs.linear() * rhs.linear();
-    res.translation() = lhs.linear() * rhs.translation() + lhs.translation();
+    res.translation().noalias() = lhs.linear() * rhs.translation() + lhs.translation();
     res.makeAffine();
     return res;
   }
@@ -1452,9 +1544,9 @@
 template <typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
 struct transform_transform_product_impl<Transform<Scalar, Dim, LhsMode, LhsOptions>,
                                         Transform<Scalar, Dim, RhsMode, RhsOptions>, true> {
-  typedef Transform<Scalar, Dim, LhsMode, LhsOptions> Lhs;
-  typedef Transform<Scalar, Dim, RhsMode, RhsOptions> Rhs;
-  typedef Transform<Scalar, Dim, Projective> ResultType;
+  using Lhs = Transform<Scalar, Dim, LhsMode, LhsOptions>;
+  using Rhs = Transform<Scalar, Dim, RhsMode, RhsOptions>;
+  using ResultType = Transform<Scalar, Dim, Projective>;
   static EIGEN_DEVICE_FUNC ResultType run(const Lhs& lhs, const Rhs& rhs) {
     return ResultType(lhs.matrix() * rhs.matrix());
   }
@@ -1463,12 +1555,12 @@
 template <typename Scalar, int Dim, int LhsOptions, int RhsOptions>
 struct transform_transform_product_impl<Transform<Scalar, Dim, AffineCompact, LhsOptions>,
                                         Transform<Scalar, Dim, Projective, RhsOptions>, true> {
-  typedef Transform<Scalar, Dim, AffineCompact, LhsOptions> Lhs;
-  typedef Transform<Scalar, Dim, Projective, RhsOptions> Rhs;
-  typedef Transform<Scalar, Dim, Projective> ResultType;
+  using Lhs = Transform<Scalar, Dim, AffineCompact, LhsOptions>;
+  using Rhs = Transform<Scalar, Dim, Projective, RhsOptions>;
+  using ResultType = Transform<Scalar, Dim, Projective>;
   static EIGEN_DEVICE_FUNC ResultType run(const Lhs& lhs, const Rhs& rhs) {
     ResultType res;
-    res.matrix().template topRows<Dim>() = lhs.matrix() * rhs.matrix();
+    res.matrix().template topRows<Dim>().noalias() = lhs.matrix() * rhs.matrix();
     res.matrix().row(Dim) = rhs.matrix().row(Dim);
     return res;
   }
@@ -1477,9 +1569,9 @@
 template <typename Scalar, int Dim, int LhsOptions, int RhsOptions>
 struct transform_transform_product_impl<Transform<Scalar, Dim, Projective, LhsOptions>,
                                         Transform<Scalar, Dim, AffineCompact, RhsOptions>, true> {
-  typedef Transform<Scalar, Dim, Projective, LhsOptions> Lhs;
-  typedef Transform<Scalar, Dim, AffineCompact, RhsOptions> Rhs;
-  typedef Transform<Scalar, Dim, Projective> ResultType;
+  using Lhs = Transform<Scalar, Dim, Projective, LhsOptions>;
+  using Rhs = Transform<Scalar, Dim, AffineCompact, RhsOptions>;
+  using ResultType = Transform<Scalar, Dim, Projective>;
   static EIGEN_DEVICE_FUNC ResultType run(const Lhs& lhs, const Rhs& rhs) {
     ResultType res(lhs.matrix().template leftCols<Dim>() * rhs.matrix());
     res.matrix().col(Dim) += lhs.matrix().col(Dim);
diff --git a/Eigen/src/Geometry/Translation.h b/Eigen/src/Geometry/Translation.h
index d942ac8..ee25b2b 100644
--- a/Eigen/src/Geometry/Translation.h
+++ b/Eigen/src/Geometry/Translation.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRANSLATION_H
 #define EIGEN_TRANSLATION_H
@@ -22,7 +23,7 @@
  * \brief Represents a translation transformation
  *
  * \tparam Scalar_ the scalar type, i.e., the type of the coefficients.
- * \tparam Dim_ the  dimension of the space, can be a compile time value or Dynamic
+ * \tparam Dim_ the dimension of the space, can be a compile time value or Dynamic
  *
  * \note This class is not aimed to be used to store a translation transformation,
  * but rather to make easier the constructions and updates of Transform objects.
@@ -36,15 +37,15 @@
   /** dimension of the space */
   enum { Dim = Dim_ };
   /** the scalar type of the coefficients */
-  typedef Scalar_ Scalar;
+  using Scalar = Scalar_;
   /** corresponding vector type */
-  typedef Matrix<Scalar, Dim, 1> VectorType;
+  using VectorType = Matrix<Scalar, Dim, 1>;
   /** corresponding linear transformation matrix type */
-  typedef Matrix<Scalar, Dim, Dim> LinearMatrixType;
+  using LinearMatrixType = Matrix<Scalar, Dim, Dim>;
   /** corresponding affine transformation type */
-  typedef Transform<Scalar, Dim, Affine> AffineTransformType;
+  using AffineTransformType = Transform<Scalar, Dim, Affine>;
   /** corresponding isometric transformation type */
-  typedef Transform<Scalar, Dim, Isometry> IsometryTransformType;
+  using IsometryTransformType = Transform<Scalar, Dim, Isometry>;
 
  protected:
   VectorType m_coeffs;
@@ -88,7 +89,7 @@
   EIGEN_DEVICE_FUNC const VectorType& translation() const { return m_coeffs; }
   EIGEN_DEVICE_FUNC VectorType& translation() { return m_coeffs; }
 
-  /** Concatenates two translation */
+  /** Concatenates two translations */
   EIGEN_DEVICE_FUNC inline Translation operator*(const Translation& other) const {
     return Translation(m_coeffs + other.m_coeffs);
   }
@@ -107,14 +108,14 @@
   }
 
   /** \returns the concatenation of a linear transformation \a l with the translation \a t */
-  // its a nightmare to define a templated friend function outside its declaration
+  // it's a nightmare to define a templated friend function outside its declaration
   template <typename OtherDerived>
   friend EIGEN_DEVICE_FUNC inline AffineTransformType operator*(const EigenBase<OtherDerived>& linear,
                                                                 const Translation& t) {
     AffineTransformType res;
     res.matrix().setZero();
     res.linear() = linear.derived();
-    res.translation() = linear.derived() * t.m_coeffs;
+    res.translation().noalias() = linear.derived() * t.m_coeffs;
     res.matrix().row(Dim).setZero();
     res(Dim, Dim) = Scalar(1);
     return res;
@@ -169,10 +170,10 @@
 
 /** \addtogroup Geometry_Module */
 //@{
-typedef Translation<float, 2> Translation2f;
-typedef Translation<double, 2> Translation2d;
-typedef Translation<float, 3> Translation3f;
-typedef Translation<double, 3> Translation3d;
+using Translation2f = Translation<float, 2>;
+using Translation2d = Translation<double, 2>;
+using Translation3f = Translation<float, 3>;
+using Translation3d = Translation<double, 3>;
 //@}
 
 template <typename Scalar, int Dim>
diff --git a/Eigen/src/Geometry/Umeyama.h b/Eigen/src/Geometry/Umeyama.h
index 8ed6344..9584d92 100644
--- a/Eigen/src/Geometry/Umeyama.h
+++ b/Eigen/src/Geometry/Umeyama.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_UMEYAMA_H
 #define EIGEN_UMEYAMA_H
@@ -21,7 +22,7 @@
 
 namespace Eigen {
 
-// These helpers are required since it allows to use mixed types as parameters
+// These helpers are required since they allow the use of mixed types as parameters
 // for the Umeyama. The problem with mixed parameters is that the return type
 // cannot trivially be deduced when float and double types are mixed.
 namespace internal {
@@ -40,10 +41,9 @@
     HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime) + 1
   };
 
-  typedef Matrix<typename traits<MatrixType>::Scalar, HomogeneousDimension, HomogeneousDimension,
-                 AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor), HomogeneousDimension,
-                 HomogeneousDimension>
-      type;
+  using type = Matrix<typename traits<MatrixType>::Scalar, HomogeneousDimension, HomogeneousDimension,
+                      AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor), HomogeneousDimension,
+                      HomogeneousDimension>;
 };
 
 }  // namespace internal
@@ -67,7 +67,7 @@
  * \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
  * of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where
  * \f$d\f$ is corresponding to the dimension (which is typically small).
- * The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+ * The analysis involves the SVD having a complexity of \f$O(d^3)\f$
  * though the actual computational effort lies in the covariance
  * matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when
  * the input point sets have dimension \f$d \times m\f$.
@@ -89,20 +89,20 @@
 template <typename Derived, typename OtherDerived>
 typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type umeyama(
     const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true) {
-  typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType;
-  typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using TransformationMatrixType = typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type;
+  using Scalar = typename internal::traits<TransformationMatrixType>::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
+      (std::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
   enum { Dimension = internal::min_size_prefer_dynamic(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) };
 
-  typedef Matrix<Scalar, Dimension, 1> VectorType;
-  typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
-  typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType;
+  using VectorType = Matrix<Scalar, Dimension, 1>;
+  using MatrixType = Matrix<Scalar, Dimension, Dimension>;
+  using RowMajorMatrixType = typename internal::plain_matrix_type_row_major<Derived>::type;
 
   const Index m = src.rows();  // dimension
   const Index n = src.cols();  // number of measurements
@@ -141,6 +141,13 @@
     // Eq. (36)-(37)
     const Scalar src_var = src_demean.rowwise().squaredNorm().sum() * one_over_n;
 
+    if (src_var <= Scalar(0)) {
+      // Degenerate: source points have zero variance (all nearly identical).
+      // Scaling is undefined; return the best-fit pure translation.
+      Rt.col(m).head(m) = dst_mean - src_mean;
+      return Rt;
+    }
+
     // Eq. (42)
     const Scalar c = Scalar(1) / src_var * svd.singularValues().dot(S);
 
diff --git a/Eigen/src/Geometry/arch/Geometry_SIMD.h b/Eigen/src/Geometry/arch/Geometry_SIMD.h
index 5601a47..25a2bde 100644
--- a/Eigen/src/Geometry/arch/Geometry_SIMD.h
+++ b/Eigen/src/Geometry/arch/Geometry_SIMD.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GEOMETRY_SIMD_H
 #define EIGEN_GEOMETRY_SIMD_H
diff --git a/Eigen/src/Householder/BlockHouseholder.h b/Eigen/src/Householder/BlockHouseholder.h
index 6a4bc67..9e99c85 100644
--- a/Eigen/src/Householder/BlockHouseholder.h
+++ b/Eigen/src/Householder/BlockHouseholder.h
@@ -7,11 +7,12 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BLOCK_HOUSEHOLDER_H
 #define EIGEN_BLOCK_HOUSEHOLDER_H
 
-// This file contains some helper function to deal with block householder reflectors
+// This file contains some helper functions to deal with block householder reflectors
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
@@ -21,7 +22,7 @@
 namespace internal {
 
 /** \internal */
-// This variant avoid modifications in vectors
+// This variant avoids modifications in vectors
 template <typename TriangularFactorType, typename VectorsType, typename CoeffsType>
 void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors,
                                               const CoeffsType& hCoeffs) {
@@ -36,14 +37,8 @@
       triFactor.row(i).tail(rt).noalias() = -hCoeffs(i) * vectors.col(i).tail(rs).adjoint() *
                                             vectors.bottomRightCorner(rs, rt).template triangularView<UnitLower>();
 
-      // FIXME: use the following line with .noalias() once triangular product supports in-place operation.
-      // triFactor.row(i).tail(rt) = triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt,rt).template
-      // triangularView<Upper>();
-      for (Index j = nbVecs - 1; j > i; --j) {
-        typename TriangularFactorType::Scalar z = triFactor(i, j);
-        triFactor(i, j) = z * triFactor(j, j);
-        if (nbVecs - j - 1 > 0) triFactor.row(i).tail(nbVecs - j - 1) += z * triFactor.row(j).tail(nbVecs - j - 1);
-      }
+      triFactor.row(i).tail(rt) =
+          (triFactor.row(i).tail(rt) * triFactor.bottomRightCorner(rt, rt).template triangularView<Upper>()).eval();
     }
     triFactor(i, i) = hCoeffs(i);
   }
@@ -52,33 +47,98 @@
 /** \internal
  * if forward then perform   mat = H0 * H1 * H2 * mat
  * otherwise perform         mat = H2 * H1 * H0 * mat
+ *
+ * Implementation note: V (the householder vectors) is unit lower trapezoidal of shape
+ * nbRows x nbVecs. Wrapping the *whole* V as TriangularView<UnitLower> would send both
+ * V^* * mat and V * tmp through Eigen's triangular_matrix_matrix_product kernel, which
+ * is single-threaded (it bypasses parallelize_gemm). We split V into its UnitLower top
+ * nbVecs x nbVecs block and the general (nbRows - nbVecs) x nbVecs bottom block; the
+ * bottom block — which is the bulk of the work for tall panels — then flows through
+ * general_matrix_matrix_product, which parallelizes under OpenMP / EIGEN_GEMM_THREADPOOL.
  */
+EIGEN_DIAGNOSTICS(push)
+EIGEN_DIAGNOSTICS_OFF(disable : 4789, ignored "-Warray-bounds")
+
 template <typename MatrixType, typename VectorsType, typename CoeffsType>
 void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs,
                                          bool forward) {
   enum { TFactorSize = VectorsType::ColsAtCompileTime };
-  Index nbVecs = vectors.cols();
+  const Index nbVecs = vectors.cols();
+  const Index nbBelow = vectors.rows() - nbVecs;
   Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs, nbVecs);
 
   if (forward)
     make_block_householder_triangular_factor(T, vectors, hCoeffs);
   else
     make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());
-  const TriangularView<const VectorsType, UnitLower> V(vectors);
 
-  // A -= V T V^* A
+  const auto V_top = vectors.topRows(nbVecs);
+
+  // tmp = V^* * mat, computed as V_top^* * mat.topRows(nbVecs) + V_bot^* * mat.bottomRows(nbBelow).
   Matrix<typename MatrixType::Scalar, VectorsType::ColsAtCompileTime, MatrixType::ColsAtCompileTime,
          (VectorsType::MaxColsAtCompileTime == 1 && MatrixType::MaxColsAtCompileTime != 1) ? RowMajor : ColMajor,
          VectorsType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime>
-      tmp = V.adjoint() * mat;
-  // FIXME: add .noalias() once triangular product supports in-place operation.
+      tmp(nbVecs, mat.cols());
+  tmp.noalias() = V_top.template triangularView<UnitLower>().adjoint() * mat.topRows(nbVecs);
+  if (nbBelow > 0) {
+    tmp.noalias() += vectors.bottomRows(nbBelow).adjoint() * mat.bottomRows(nbBelow);
+  }
+
   if (forward)
-    tmp = T.template triangularView<Upper>() * tmp;
+    tmp = (T.template triangularView<Upper>() * tmp).eval();
   else
-    tmp = T.template triangularView<Upper>().adjoint() * tmp;
-  mat.noalias() -= V * tmp;
+    tmp = (T.template triangularView<Upper>().adjoint() * tmp).eval();
+
+  // mat -= V * tmp, split along the same top/bottom partition.
+  mat.topRows(nbVecs).noalias() -= V_top.template triangularView<UnitLower>() * tmp;
+  if (nbBelow > 0) {
+    mat.bottomRows(nbBelow).noalias() -= vectors.bottomRows(nbBelow) * tmp;
+  }
 }
 
+/** \internal
+ * if forward then perform   mat = mat * H0 * H1 * H2
+ * otherwise perform         mat = mat * H2 * H1 * H0
+ */
+template <typename MatrixType, typename VectorsType, typename CoeffsType>
+void apply_block_householder_on_the_right(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs,
+                                          bool forward) {
+  enum { TFactorSize = VectorsType::ColsAtCompileTime };
+  const Index nbVecs = vectors.cols();
+  const Index nbBelow = vectors.rows() - nbVecs;
+  Matrix<typename MatrixType::Scalar, TFactorSize, TFactorSize, RowMajor> T(nbVecs, nbVecs);
+
+  if (forward)
+    make_block_householder_triangular_factor(T, vectors, hCoeffs);
+  else
+    make_block_householder_triangular_factor(T, vectors, hCoeffs.conjugate());
+
+  const auto V_top = vectors.topRows(nbVecs);
+
+  // tmp = mat * V, split along V's top/bottom partition (see the left-apply for context).
+  Matrix<typename MatrixType::Scalar, MatrixType::RowsAtCompileTime, VectorsType::ColsAtCompileTime,
+         (MatrixType::MaxRowsAtCompileTime == 1 && VectorsType::MaxColsAtCompileTime != 1) ? ColMajor : RowMajor,
+         MatrixType::MaxRowsAtCompileTime, VectorsType::MaxColsAtCompileTime>
+      tmp(mat.rows(), nbVecs);
+  tmp.noalias() = mat.leftCols(nbVecs) * V_top.template triangularView<UnitLower>();
+  if (nbBelow > 0) {
+    tmp.noalias() += mat.rightCols(nbBelow) * vectors.bottomRows(nbBelow);
+  }
+
+  if (forward)
+    tmp = (tmp * T.template triangularView<Upper>()).eval();
+  else
+    tmp = (tmp * T.template triangularView<Upper>().adjoint()).eval();
+
+  // mat -= tmp * V^*, split along the same partition.
+  mat.leftCols(nbVecs).noalias() -= tmp * V_top.template triangularView<UnitLower>().adjoint();
+  if (nbBelow > 0) {
+    mat.rightCols(nbBelow).noalias() -= tmp * vectors.bottomRows(nbBelow).adjoint();
+  }
+}
+
+EIGEN_DIAGNOSTICS(pop)
+
 }  // end namespace internal
 
 }  // end namespace Eigen
diff --git a/Eigen/src/Householder/Householder.h b/Eigen/src/Householder/Householder.h
index f77e54f..f977a29 100644
--- a/Eigen/src/Householder/Householder.h
+++ b/Eigen/src/Householder/Householder.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HOUSEHOLDER_H
 #define EIGEN_HOUSEHOLDER_H
@@ -18,16 +19,80 @@
 
 namespace internal {
 template <int N>
-struct decrement_size {
-  static constexpr int ret = N - 1;
-};
+struct decrement_size : std::integral_constant<int, N - 1> {};
 template <>
-struct decrement_size<0> {
-  static constexpr int ret = 0;
-};
+struct decrement_size<0> : std::integral_constant<int, 0> {};
 template <>
-struct decrement_size<Dynamic> {
-  static constexpr int ret = Dynamic;
+struct decrement_size<Dynamic> : std::integral_constant<int, Dynamic> {};
+
+template <typename RealScalar>
+struct householder_norm_accumulator : stable_norm_accumulator<RealScalar> {};
+
+template <>
+struct householder_norm_accumulator<float> {
+  // Stable norm reductions can avoid underflow by scaling in float. Householder construction must also preserve each
+  // subnormal component while forming scale-free tau and essential-vector ratios, so widen only these intermediates.
+  using type = double;
+};
+
+template <typename Scalar, typename Accumulator, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct householder_rescale;
+
+template <typename Scalar, typename Accumulator>
+struct householder_rescale<Scalar, Accumulator, false> {
+  EIGEN_DEVICE_FUNC static Scalar run(const Scalar& value, const Accumulator& scale) {
+    return Scalar(Accumulator(value) / scale);
+  }
+
+  // This overload only keeps the shared C++14 call site well-formed; real inputs return before reaching it.
+  EIGEN_DEVICE_FUNC static Scalar zero_tail_tau(const Accumulator& scaledReal, const Accumulator&,
+                                                const Scalar& scaledBeta) {
+    return Scalar(1) - Scalar(scaledReal) / scaledBeta;
+  }
+
+  template <typename EssentialPart, typename TailView>
+  EIGEN_DEVICE_FUNC static void run(EssentialPart& essential, const TailView& tail, const Accumulator& scale,
+                                    const Scalar& denominator) {
+    essential = ((tail.template cast<Accumulator>().array() / scale) / Accumulator(denominator))
+                    .matrix()
+                    .template cast<Scalar>();
+  }
+};
+
+template <typename Scalar, typename Accumulator>
+struct householder_rescale<Scalar, Accumulator, true> {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  EIGEN_DEVICE_FUNC static Scalar run(const Scalar& value, const Accumulator& scale) {
+    return Scalar(RealScalar(Accumulator(numext::real(value)) / scale),
+                  RealScalar(Accumulator(numext::imag(value)) / scale));
+  }
+
+  EIGEN_DEVICE_FUNC static Scalar zero_tail_tau(const Accumulator& scaledReal, const Accumulator& scaledImag,
+                                                const RealScalar& scaledBeta) {
+    return Scalar(RealScalar(1) - RealScalar(scaledReal) / scaledBeta, RealScalar(scaledImag) / scaledBeta);
+  }
+
+  template <typename EssentialPart, typename TailView>
+  EIGEN_DEVICE_FUNC static void run(EssentialPart& essential, const TailView& tail, const Accumulator& scale,
+                                    const Scalar& denominator) {
+    run(essential, tail, scale, denominator, complex_array_access<Scalar>());
+  }
+
+ private:
+  template <typename EssentialPart, typename TailView>
+  EIGEN_DEVICE_FUNC static void run(EssentialPart& essential, const TailView& tail, const Accumulator& scale,
+                                    const Scalar& denominator, std::true_type) {
+    essential.realView().array() =
+        (tail.realView().array().template cast<Accumulator>() / scale).template cast<RealScalar>();
+    essential.array() /= denominator;
+  }
+
+  template <typename EssentialPart, typename TailView>
+  EIGEN_DEVICE_FUNC static void run(EssentialPart& essential, const TailView& tail, const Accumulator& scale,
+                                    const Scalar& denominator, std::false_type) {
+    for (Index i = 0; i < tail.size(); ++i) essential.coeffRef(i) = run(tail.coeff(i), scale) / denominator;
+  }
 };
 }  // namespace internal
 
@@ -49,7 +114,8 @@
  */
 template <typename Derived>
 EIGEN_DEVICE_FUNC void MatrixBase<Derived>::makeHouseholderInPlace(Scalar& tau, RealScalar& beta) {
-  VectorBlock<Derived, internal::decrement_size<Base::SizeAtCompileTime>::ret> essentialPart(derived(), 1, size() - 1);
+  VectorBlock<Derived, internal::decrement_size<Base::SizeAtCompileTime>::value> essentialPart(derived(), 1,
+                                                                                               size() - 1);
   makeHouseholder(essentialPart, tau, beta);
 }
 
@@ -77,22 +143,140 @@
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
   const VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size() - 1);
 
-  RealScalar tailSqNorm = size() == 1 ? RealScalar(0) : tail.unwind().squaredNorm();
+  const RealScalar tailSqNorm = size() == 1 ? RealScalar(0) : tail.unwind().squaredNorm();
   Scalar c0 = coeff(0);
   const RealScalar tol = (std::numeric_limits<RealScalar>::min)();
+  RealScalar unscaledNormThreshold = tol;
+  // Whether the direct construction's abs2(c0) + tailSqNorm would exceed the range. Integer scalars keep the direct
+  // path they have always taken; the scaled path divides by a component maximum, which does not apply to them.
+  bool unscaledSqNormOverflows = false;
+  EIGEN_IF_CONSTEXPR (!NumTraits<RealScalar>::IsInteger) {
+    const RealScalar precision = RealScalar(NumTraits<RealScalar>::epsilon());
+    // With flush-to-zero arithmetic, every tail component square below tol can be lost. Account for every component
+    // so the discarded contribution is at most epsilon relative to a squared norm above this threshold. The narrow
+    // normal range of half makes this scaled path common for moderately small inputs; preserving the bound there is
+    // intentional.
+    const RealScalar componentCount = RealScalar(size() - 1) * RealScalar(NumTraits<Scalar>::IsComplex ? 2 : 1);
+    unscaledNormThreshold = (tol / precision) * componentCount;
 
-  if (tailSqNorm <= tol && numext::abs2(numext::imag(c0)) <= tol) {
-    tau = RealScalar(0);
-    beta = numext::real(c0);
-    essential.setZero();
-  } else {
-    beta = numext::sqrt(numext::abs2(c0) + tailSqNorm);
-    if (numext::real(c0) >= RealScalar(0)) beta = -beta;
-    essential = tail.unwind() / (c0 - beta);
-    tau = conj((beta - c0) / beta);
+    // Both terms overflow well before the reflector stops being representable, so classify the input before the
+    // squares are formed: abs2(c0) is at most twice the square of the larger component of c0, and the tail's own
+    // reduction has already overflowed if tailSqNorm exceeds the bound. Testing the sum with isinf() instead would
+    // not survive -ffinite-math-only, which folds that test away, whereas a comparison against a finite bound is
+    // still evaluated.
+    const RealScalar sqNormBound = NumTraits<RealScalar>::highest() / RealScalar(2);
+    const RealScalar componentBound = numext::sqrt(sqNormBound / RealScalar(2));
+    const RealScalar c0Max = numext::maxi(numext::abs(numext::real(c0)), numext::abs(numext::imag(c0)));
+    unscaledSqNormOverflows = !(c0Max <= componentBound) || !(tailSqNorm <= sqNormBound);
   }
+
+  // The scaled path forms the reflector from ratios of the largest component and never squares an unscaled
+  // coefficient, so it is also the path for inputs the direct construction cannot square.
+  if ((tailSqNorm <= unscaledNormThreshold || unscaledSqNormOverflows) && !(numext::isnan)(c0)) {
+    using Accumulator = typename internal::householder_norm_accumulator<RealScalar>::type;
+    const auto tailView = tail.unwind();
+    const auto tailComponents = tailView.realView();
+    // Component maxima cannot underflow when a representable tail is nonzero.
+    const Accumulator tailMax =
+        tailView.size() == 0 ? Accumulator(0) : Accumulator(tailComponents.cwiseAbs().maxCoeff());
+    if (numext::is_exactly_zero(tailMax) && numext::is_exactly_zero(numext::imag(c0))) {
+      tau = RealScalar(0);
+      beta = numext::real(c0);
+      essential.setZero();
+      return;
+    }
+    const Accumulator c0RealAbs = numext::abs(Accumulator(numext::real(c0)));
+    const Accumulator c0ImagAbs = numext::abs(Accumulator(numext::imag(c0)));
+    const Accumulator c0Max = numext::maxi(c0RealAbs, c0ImagAbs);
+    const Accumulator scale = numext::maxi(c0Max, tailMax);
+    const RealScalar realScale = RealScalar(scale);
+    // A target that flushes this scale cannot form meaningful ratios from the entirely subnormal vector.
+    if (scale < Accumulator(tol) && numext::is_exactly_zero(realScale + realScale)) {
+      tau = RealScalar(0);
+      beta = numext::real(c0);
+      essential.setZero();
+      return;
+    }
+    if (numext::is_exactly_zero(tailMax)) {
+      const Accumulator scaledReal = Accumulator(numext::real(c0)) / scale;
+      const Accumulator scaledImag = Accumulator(numext::imag(c0)) / scale;
+      RealScalar scaledBeta = RealScalar(numext::hypot(scaledReal, scaledImag));
+      if (numext::real(c0) >= RealScalar(0)) scaledBeta = -scaledBeta;
+      beta = RealScalar(scale * Accumulator(scaledBeta));
+      essential.setZero();
+      tau = internal::householder_rescale<Scalar, Accumulator>::zero_tail_tau(scaledReal, scaledImag, scaledBeta);
+      return;
+    }
+    // Form the reflector from scale-free ratios to preserve subnormal inputs and avoid overflowing c0 - beta.
+    Accumulator scaledTailSqNorm;
+    EIGEN_IF_CONSTEXPR (std::is_same<RealScalar, float>::value) {
+      // Double has enough exponent range to square every finite float scale without underflow or overflow.
+      scaledTailSqNorm = tailComponents.template cast<Accumulator>().squaredNorm() / (scale * scale);
+    } else {
+      scaledTailSqNorm = (tailComponents.template cast<Accumulator>().array() / scale).matrix().squaredNorm();
+    }
+    if (numext::is_exactly_zero(RealScalar(tailMax / scale)) && numext::is_exactly_zero(numext::imag(c0))) {
+      tau = RealScalar(0);
+      beta = numext::real(c0);
+      essential.setZero();
+      return;
+    }
+    const Scalar scaledC0 = internal::householder_rescale<Scalar, Accumulator>::run(c0, scale);
+    RealScalar scaledBeta =
+        RealScalar(numext::hypot(Accumulator(numext::abs(scaledC0)), numext::sqrt(scaledTailSqNorm)));
+    if (numext::real(c0) >= RealScalar(0)) scaledBeta = -scaledBeta;
+    beta = RealScalar(scale * Accumulator(scaledBeta));
+    internal::householder_rescale<Scalar, Accumulator>::run(essential, tailView, scale, scaledC0 - scaledBeta);
+    tau = conj(Scalar(RealScalar(1)) - scaledC0 / scaledBeta);
+    return;
+  }
+  beta = numext::sqrt(numext::abs2(c0) + tailSqNorm);
+  if (numext::real(c0) >= RealScalar(0)) beta = -beta;
+  essential = tail.unwind() / (c0 - beta);
+  tau = conj((beta - c0) / beta);
 }
 
+namespace internal {
+
+template <typename Derived, typename EssentialPart,
+          bool Fused = !Derived::IsRowMajor && EssentialPart::ColsAtCompileTime == 1 &&
+                       (EssentialPart::RowsAtCompileTime == 1 || EssentialPart::RowsAtCompileTime == 2)>
+struct householder_apply_left_impl {
+  using Scalar = typename Derived::Scalar;
+  static EIGEN_DEVICE_FUNC void run(MatrixBase<Derived>& mat, const EssentialPart& essential, const Scalar& tau,
+                                    Scalar* workspace) {
+    Map<typename plain_row_type<typename Derived::PlainObject>::type> tmp(workspace, mat.cols());
+    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(mat.derived(), 1, 0,
+                                                                                        mat.rows() - 1, mat.cols());
+    tmp.noalias() = essential.adjoint() * bottom.unwind();
+    tmp = tau * (tmp + mat.row(0));
+    mat.row(0) -= tmp;
+    bottom.unwind().noalias() -= essential * tmp;
+  }
+};
+
+// Two- and three-element reflectors on column-major storage: finishing each column before advancing replaces
+// four strided row passes, which thrash the cache at large outer strides (issue #3160).
+template <typename Derived, typename EssentialPart>
+struct householder_apply_left_impl<Derived, EssentialPart, true> {
+  using Scalar = typename Derived::Scalar;
+  static EIGEN_DEVICE_FUNC void run(MatrixBase<Derived>& mat, const EssentialPart& essential, const Scalar& tau,
+                                    Scalar*) {
+    // Evaluated once so that the column loop reads plain coefficients; tau may reference a coefficient of mat.
+    const Matrix<Scalar, EssentialPart::RowsAtCompileTime, 1> v = essential;
+    const Scalar tauValue = tau;
+    Block<Derived, EssentialPart::RowsAtCompileTime, Derived::ColsAtCompileTime> bottom(mat.derived(), 1, 0,
+                                                                                        mat.rows() - 1, mat.cols());
+    for (Index j = 0; j < mat.cols(); ++j) {
+      const Scalar tmp = tauValue * (v.dot(bottom.col(j)) + mat.coeff(0, j));
+      mat.coeffRef(0, j) -= tmp;
+      bottom.col(j) -= v * tmp;
+    }
+  }
+};
+
+}  // namespace internal
+
 /** Apply the elementary reflector H given by
  * \f$ H = I - tau v v^*\f$
  * with
@@ -115,13 +299,7 @@
   if (rows() == 1) {
     *this *= Scalar(1) - tau;
   } else if (!numext::is_exactly_zero(tau)) {
-    Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace, cols());
-    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows() - 1,
-                                                                                        cols());
-    tmp.noalias() = essential.adjoint() * bottom.unwind();
-    tmp = tau * (tmp + this->row(0));
-    this->row(0) = this->row(0) - tmp;
-    bottom.unwind().noalias() -= essential * tmp;
+    internal::householder_apply_left_impl<Derived, EssentialPart>::run(*this, essential, tau, workspace);
   }
 }
 
diff --git a/Eigen/src/Householder/HouseholderSequence.h b/Eigen/src/Householder/HouseholderSequence.h
index d49c961..4c3bb06 100644
--- a/Eigen/src/Householder/HouseholderSequence.h
+++ b/Eigen/src/Householder/HouseholderSequence.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_HOUSEHOLDER_SEQUENCE_H
 #define EIGEN_HOUSEHOLDER_SEQUENCE_H
@@ -61,9 +62,9 @@
 
 template <typename VectorsType, typename CoeffsType, int Side>
 struct traits<HouseholderSequence<VectorsType, CoeffsType, Side> > {
-  typedef typename VectorsType::Scalar Scalar;
-  typedef typename VectorsType::StorageIndex StorageIndex;
-  typedef typename VectorsType::StorageKind StorageKind;
+  using Scalar = typename VectorsType::Scalar;
+  using StorageIndex = typename VectorsType::StorageIndex;
+  using StorageKind = typename VectorsType::StorageKind;
   enum {
     RowsAtCompileTime =
         Side == OnTheLeft ? traits<VectorsType>::RowsAtCompileTime : traits<VectorsType>::ColsAtCompileTime,
@@ -80,13 +81,13 @@
 template <typename VectorsType, typename CoeffsType, int Side>
 struct evaluator_traits<HouseholderSequence<VectorsType, CoeffsType, Side> >
     : public evaluator_traits_base<HouseholderSequence<VectorsType, CoeffsType, Side> > {
-  typedef HouseholderSequenceShape Shape;
+  using Shape = HouseholderSequenceShape;
 };
 
 template <typename VectorsType, typename CoeffsType, int Side>
 struct hseq_side_dependent_impl {
-  typedef Block<const VectorsType, Dynamic, 1> EssentialVectorType;
-  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> HouseholderSequenceType;
+  using EssentialVectorType = Block<const VectorsType, Dynamic, 1>;
+  using HouseholderSequenceType = HouseholderSequence<VectorsType, CoeffsType, OnTheLeft>;
   static EIGEN_DEVICE_FUNC inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k) {
     Index start = k + 1 + h.m_shift;
     return Block<const VectorsType, Dynamic, 1>(h.m_vectors, start, k, h.rows() - start, 1);
@@ -95,8 +96,8 @@
 
 template <typename VectorsType, typename CoeffsType>
 struct hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight> {
-  typedef Transpose<Block<const VectorsType, 1, Dynamic> > EssentialVectorType;
-  typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> HouseholderSequenceType;
+  using EssentialVectorType = Transpose<Block<const VectorsType, 1, Dynamic>>;
+  using HouseholderSequenceType = HouseholderSequence<VectorsType, CoeffsType, OnTheRight>;
   static inline const EssentialVectorType essentialVector(const HouseholderSequenceType& h, Index k) {
     Index start = k + 1 + h.m_shift;
     return Block<const VectorsType, 1, Dynamic>(h.m_vectors, k, start, 1, h.rows() - start).transpose();
@@ -105,18 +106,17 @@
 
 template <typename OtherScalarType, typename MatrixType>
 struct matrix_type_times_scalar_type {
-  typedef typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType ResultScalar;
-  typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime, 0,
-                 MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime>
-      Type;
+  using ResultScalar = typename ScalarBinaryOpTraits<OtherScalarType, typename MatrixType::Scalar>::ReturnType;
+  using Type = Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime, 0,
+                      MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime>;
 };
 
 }  // end namespace internal
 
 template <typename VectorsType, typename CoeffsType, int Side>
 class HouseholderSequence : public EigenBase<HouseholderSequence<VectorsType, CoeffsType, Side> > {
-  typedef typename internal::hseq_side_dependent_impl<VectorsType, CoeffsType, Side>::EssentialVectorType
-      EssentialVectorType;
+  using EssentialVectorType =
+      typename internal::hseq_side_dependent_impl<VectorsType, CoeffsType, Side>::EssentialVectorType;
 
  public:
   enum {
@@ -125,31 +125,28 @@
     MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime
   };
-  typedef typename internal::traits<HouseholderSequence>::Scalar Scalar;
+  using Scalar = typename internal::traits<HouseholderSequence>::Scalar;
 
-  typedef HouseholderSequence<
+  using ConjugateReturnType = HouseholderSequence<
       std::conditional_t<NumTraits<Scalar>::IsComplex,
                          internal::remove_all_t<typename VectorsType::ConjugateReturnType>, VectorsType>,
       std::conditional_t<NumTraits<Scalar>::IsComplex, internal::remove_all_t<typename CoeffsType::ConjugateReturnType>,
                          CoeffsType>,
-      Side>
-      ConjugateReturnType;
+      Side>;
 
-  typedef HouseholderSequence<
+  using AdjointReturnType = HouseholderSequence<
       VectorsType,
       std::conditional_t<NumTraits<Scalar>::IsComplex, internal::remove_all_t<typename CoeffsType::ConjugateReturnType>,
                          CoeffsType>,
-      Side>
-      AdjointReturnType;
+      Side>;
 
-  typedef HouseholderSequence<
+  using TransposeReturnType = HouseholderSequence<
       std::conditional_t<NumTraits<Scalar>::IsComplex,
                          internal::remove_all_t<typename VectorsType::ConjugateReturnType>, VectorsType>,
-      CoeffsType, Side>
-      TransposeReturnType;
+      CoeffsType, Side>;
 
-  typedef HouseholderSequence<std::add_const_t<VectorsType>, std::add_const_t<CoeffsType>, Side>
-      ConstHouseholderSequence;
+  using ConstHouseholderSequence =
+      HouseholderSequence<std::add_const_t<VectorsType>, std::add_const_t<CoeffsType>, Side>;
 
   /** \brief Constructor.
    * \param[in]  v      %Matrix containing the essential parts of the Householder vectors
@@ -228,12 +225,15 @@
         .setShift(m_shift);
   }
 
-  /** \returns an expression of the complex conjugate of \c *this if Cond==true,
-   *           returns \c *this otherwise.
+  /** \returns a %HouseholderSequence over the vectors and coefficients of \c *this, complex-conjugated if
+   *           Cond==true.
+   *
+   * \warning Unlike conjugate(), this function does not propagate the state of \c *this: the returned sequence uses
+   *          the defaults of the two-argument constructor, that is, not reversed, full length and zero shift.
    */
   template <bool Cond>
   EIGEN_DEVICE_FUNC inline std::conditional_t<Cond, ConjugateReturnType, ConstHouseholderSequence> conjugateIf() const {
-    typedef std::conditional_t<Cond, ConjugateReturnType, ConstHouseholderSequence> ReturnType;
+    using ReturnType = std::conditional_t<Cond, ConjugateReturnType, ConstHouseholderSequence>;
     return ReturnType(m_vectors.template conjugateIf<Cond>(), m_coeffs.template conjugateIf<Cond>());
   }
 
@@ -281,10 +281,7 @@
       for (Index k = 0; k < cols() - vecs; ++k) dst.col(k).tail(rows() - k - 1).setZero();
     } else if (m_length > BlockSize) {
       dst.setIdentity(rows(), rows());
-      if (m_reverse)
-        applyThisOnTheLeft(dst, workspace, true);
-      else
-        applyThisOnTheLeft(dst, workspace, true);
+      applyThisOnTheLeft(dst, workspace, true);
     } else {
       dst.setIdentity(rows(), rows());
       for (Index k = vecs - 1; k >= 0; --k) {
@@ -309,14 +306,49 @@
   /** \internal */
   template <typename Dest, typename Workspace>
   inline void applyThisOnTheRight(Dest& dst, Workspace& workspace) const {
-    workspace.resize(dst.rows());
-    for (Index k = 0; k < m_length; ++k) {
-      Index actual_k = m_reverse ? m_length - k - 1 : k;
-      dst.rightCols(rows() - m_shift - actual_k)
-          .applyHouseholderOnTheRight(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+    // Use the block path when the reflectors are long enough for GEMM to outperform GEMV.
+    // The threshold on rows() (the reflector length) is higher than for the left-side path because
+    // the right-side block application has more overhead from the tmp = mat * V product layout.
+    if (m_length >= BlockSize && rows() - m_shift >= 4 * BlockSize) {
+      applyBlockOnTheRight(dst);
+    } else {
+      workspace.resize(dst.rows());
+      for (Index k = 0; k < m_length; ++k) {
+        Index actual_k = m_reverse ? m_length - k - 1 : k;
+        dst.rightCols(rows() - m_shift - actual_k)
+            .applyHouseholderOnTheRight(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
+      }
     }
   }
 
+ private:
+  /** \internal Block Householder application on the right, kept out-of-line
+   * to avoid template bloat pessimizing the scalar path above. */
+  template <typename Dest>
+  EIGEN_DONT_INLINE void applyBlockOnTheRight(Dest& dst) const {
+    // Make sure we have at least 2 useful blocks, otherwise it is point-less:
+    Index blockSize = m_length < Index(2 * BlockSize) ? (m_length + 1) / 2 : Index(BlockSize);
+    for (Index i = 0; i < m_length; i += blockSize) {
+      // Right-side application processes blocks in opposite order to left-side:
+      // forward (m_reverse=false): first block first; reversed: last block first.
+      Index end = m_reverse ? m_length - i : (std::min)(m_length, i + blockSize);
+      Index k = m_reverse ? (std::max)(Index(0), end - blockSize) : i;
+      Index bs = end - k;
+      Index start = k + m_shift;
+
+      using SubVectorsType = Block<internal::remove_all_t<VectorsType>, Dynamic, Dynamic>;
+      SubVectorsType sub_vecs1(m_vectors.const_cast_derived(), Side == OnTheRight ? k : start,
+                               Side == OnTheRight ? start : k, Side == OnTheRight ? bs : m_vectors.rows() - start,
+                               Side == OnTheRight ? m_vectors.cols() - start : bs);
+      std::conditional_t<Side == OnTheRight, Transpose<SubVectorsType>, SubVectorsType&> sub_vecs(sub_vecs1);
+
+      Index dstCols = rows() - m_shift - k;
+      auto sub_dst = dst.rightCols(dstCols);
+      internal::apply_block_householder_on_the_right(sub_dst, sub_vecs, m_coeffs.segment(k, bs), !m_reverse);
+    }
+  }
+
+ public:
   /** \internal */
   template <typename Dest>
   inline void applyThisOnTheLeft(Dest& dst, bool inputIsIdentity = false) const {
@@ -338,7 +370,7 @@
         Index bs = end - k;
         Index start = k + m_shift;
 
-        typedef Block<internal::remove_all_t<VectorsType>, Dynamic, Dynamic> SubVectorsType;
+        using SubVectorsType = Block<internal::remove_all_t<VectorsType>, Dynamic, Dynamic>;
         SubVectorsType sub_vecs1(m_vectors.const_cast_derived(), Side == OnTheRight ? k : start,
                                  Side == OnTheRight ? start : k, Side == OnTheRight ? bs : m_vectors.rows() - start,
                                  Side == OnTheRight ? m_vectors.cols() - start : bs);
diff --git a/Eigen/src/Householder/InternalHeaderCheck.h b/Eigen/src/Householder/InternalHeaderCheck.h
index 70de89b..88b8f28 100644
--- a/Eigen/src/Householder/InternalHeaderCheck.h
+++ b/Eigen/src/Householder/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_HOUSEHOLDER_MODULE_H
 #error "Please include Eigen/Householder instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h b/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
index d4a187e..a8e1659 100644
--- a/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
+++ b/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BASIC_PRECONDITIONERS_H
 #define EIGEN_BASIC_PRECONDITIONERS_H
@@ -16,7 +17,7 @@
 namespace Eigen {
 
 /** \ingroup IterativeLinearSolvers_Module
-  * \brief A preconditioner based on the digonal entries
+  * \brief A preconditioner based on the diagonal entries
   *
   * This class allows to approximately solve for A.x = b problems assuming A is a diagonal matrix.
   * In other words, this preconditioner neglects all off diagonal entries and, in Eigen's language, solves for:
@@ -37,14 +38,14 @@
   */
 template <typename Scalar_>
 class DiagonalPreconditioner {
-  typedef Scalar_ Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> Vector;
+  using Scalar = Scalar_;
+  using Vector = Matrix<Scalar, Dynamic, 1>;
 
  public:
-  typedef typename Vector::StorageIndex StorageIndex;
+  using StorageIndex = typename Vector::StorageIndex;
   enum { ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };
 
-  DiagonalPreconditioner() : m_isInitialized(false) {}
+  DiagonalPreconditioner() = default;
 
   template <typename MatType>
   explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols()) {
@@ -62,7 +63,7 @@
   template <typename MatType>
   DiagonalPreconditioner& factorize(const MatType& mat) {
     m_invdiag.resize(mat.cols());
-    for (int j = 0; j < mat.outerSize(); ++j) {
+    for (Index j = 0; j < mat.outerSize(); ++j) {
       typename MatType::InnerIterator it(mat, j);
       while (it && it.index() != j) ++it;
       if (it && it.index() == j && it.value() != Scalar(0))
@@ -97,7 +98,7 @@
 
  protected:
   Vector m_invdiag;
-  bool m_isInitialized;
+  bool m_isInitialized = false;
 };
 
 /** \ingroup IterativeLinearSolvers_Module
@@ -119,13 +120,13 @@
   */
 template <typename Scalar_>
 class LeastSquareDiagonalPreconditioner : public DiagonalPreconditioner<Scalar_> {
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef DiagonalPreconditioner<Scalar_> Base;
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Base = DiagonalPreconditioner<Scalar_>;
   using Base::m_invdiag;
 
  public:
-  LeastSquareDiagonalPreconditioner() : Base() {}
+  LeastSquareDiagonalPreconditioner() = default;
 
   template <typename MatType>
   explicit LeastSquareDiagonalPreconditioner(const MatType& mat) : Base() {
@@ -141,20 +142,19 @@
   LeastSquareDiagonalPreconditioner& factorize(const MatType& mat) {
     // Compute the inverse squared-norm of each column of mat
     m_invdiag.resize(mat.cols());
-    if (MatType::IsRowMajor) {
+    EIGEN_IF_CONSTEXPR (MatType::IsRowMajor) {
       m_invdiag.setZero();
       for (Index j = 0; j < mat.outerSize(); ++j) {
         for (typename MatType::InnerIterator it(mat, j); it; ++it) m_invdiag(it.index()) += numext::abs2(it.value());
       }
-      for (Index j = 0; j < mat.cols(); ++j)
-        if (numext::real(m_invdiag(j)) > RealScalar(0)) m_invdiag(j) = RealScalar(1) / numext::real(m_invdiag(j));
+      for (Index j = 0; j < mat.cols(); ++j) {
+        RealScalar sum = numext::real(m_invdiag(j));
+        m_invdiag(j) = sum > RealScalar(0) ? RealScalar(1) / sum : RealScalar(1);
+      }
     } else {
       for (Index j = 0; j < mat.outerSize(); ++j) {
         RealScalar sum = mat.col(j).squaredNorm();
-        if (sum > RealScalar(0))
-          m_invdiag(j) = RealScalar(1) / sum;
-        else
-          m_invdiag(j) = RealScalar(1);
+        m_invdiag(j) = sum > RealScalar(0) ? RealScalar(1) / sum : RealScalar(1);
       }
     }
     Base::m_isInitialized = true;
@@ -167,8 +167,6 @@
   }
 
   ComputationInfo info() const { return Success; }
-
- protected:
 };
 
 /** \ingroup IterativeLinearSolvers_Module
@@ -180,7 +178,7 @@
  */
 class IdentityPreconditioner {
  public:
-  IdentityPreconditioner() {}
+  IdentityPreconditioner() = default;
 
   template <typename MatrixType>
   explicit IdentityPreconditioner(const MatrixType&) {}
diff --git a/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h b/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
index 2d461fe..3cf2aaf 100644
--- a/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
+++ b/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BICGSTAB_H
 #define EIGEN_BICGSTAB_H
@@ -31,9 +32,9 @@
 template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
 bool bicgstab(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond, Index& iters,
               typename Dest::RealScalar& tol_error) {
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
   Index maxIters = iters;
 
   Index n = mat.cols();
@@ -56,7 +57,6 @@
 
   VectorType v = VectorType::Zero(n), p = VectorType::Zero(n);
   VectorType y(n), z(n);
-  VectorType kt(n), ks(n);
 
   VectorType s(n), t(n);
 
@@ -70,7 +70,7 @@
     if (Eigen::numext::abs(rho) / Eigen::numext::maxi(r0_norm, r_norm) < eps * Eigen::numext::mini(r0_norm, r_norm)) {
       // The new residual vector became too orthogonal to the arbitrarily chosen direction r0
       // Let's restart with a new r0:
-      r = rhs - mat * x;
+      r.noalias() = rhs - mat * x;
       r0 = r;
       rho = r.squaredNorm();
       r0_norm = r.stableNorm();
@@ -88,7 +88,7 @@
     // For small angles ∠(r0, v) < eps, random restart.
     RealScalar v_norm = v.stableNorm();
     if (Eigen::numext::abs(theta) / Eigen::numext::maxi(r0_norm, v_norm) < eps * Eigen::numext::mini(r0_norm, v_norm)) {
-      r = rhs - mat * x;
+      r.noalias() = rhs - mat * x;
       r0.setRandom();
       r0_norm = r0.stableNorm();
       rho = Scalar(1);
@@ -129,8 +129,8 @@
 
 template <typename MatrixType_, typename Preconditioner_>
 struct traits<BiCGSTAB<MatrixType_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
 };
 
 }  // namespace internal
@@ -147,12 +147,12 @@
  * \implsparsesolverconcept
  *
  * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
- * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
- * and NumTraits<Scalar>::epsilon() for the tolerance.
+ * and setTolerance() methods. The defaults are twice the number of columns of the matrix for the maximal
+ * number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.
  *
  * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
  *
- * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format.
+ * \b Performance: when using sparse matrices, best performance is achieved for a row-major sparse matrix format.
  * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
  * See \ref TopicMultiThreading for details.
  *
@@ -168,7 +168,8 @@
  */
 template <typename MatrixType_, typename Preconditioner_>
 class BiCGSTAB : public IterativeSolverBase<BiCGSTAB<MatrixType_, Preconditioner_> > {
-  typedef IterativeSolverBase<BiCGSTAB> Base;
+ protected:
+  using Base = IterativeSolverBase<BiCGSTAB>;
   using Base::m_error;
   using Base::m_info;
   using Base::m_isInitialized;
@@ -176,10 +177,10 @@
   using Base::matrix;
 
  public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
 
  public:
   /** Default constructor. */
@@ -198,8 +199,6 @@
   template <typename MatrixDerived>
   explicit BiCGSTAB(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
 
-  ~BiCGSTAB() {}
-
   /** \internal */
   template <typename Rhs, typename Dest>
   void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
@@ -210,8 +209,6 @@
 
     m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
   }
-
- protected:
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/IterativeLinearSolvers/BiCGSTABL.h b/Eigen/src/IterativeLinearSolvers/BiCGSTABL.h
new file mode 100644
index 0000000..a69b2c9
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/BiCGSTABL.h
@@ -0,0 +1,352 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
+// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
+// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
+// Copyright (C) 2020 Adithya Vijaykumar
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+/*
+
+  This implementation of BiCGStab(L) is based on the papers
+      General algorithm:
+      1. G.L.G. Sleijpen, D.R. Fokkema. (1993). BiCGstab(l) for linear equations
+  involving unsymmetric matrices with complex spectrum. Electronic Transactions
+  on Numerical Analysis. Polynomial step update:
+      2. G.L.G. Sleijpen, M.B. Van Gijzen. (2010) Exploiting BiCGstab(l)
+  strategies to induce dimension reduction SIAM Journal on Scientific Computing.
+      3. Fokkema, Diederik R. Enhanced implementation of BiCGstab (l) for
+  solving linear systems of equations. Universiteit Utrecht. Mathematisch
+  Instituut, 1996
+      4. Sleijpen, G. L., & van der Vorst, H. A. (1996). Reliable updated
+  residuals in hybrid Bi-CG methods. Computing, 56(2), 141-163.
+*/
+
+#ifndef EIGEN_BICGSTABL_H
+#define EIGEN_BICGSTABL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+/**     \internal Low-level bi conjugate gradient stabilized algorithm with L
+   additional residual minimization steps \param mat The matrix A \param rhs The
+   right hand side vector b \param x On input and initial solution, on output
+   the computed solution. \param precond A preconditioner being able to
+   efficiently solve for an approximation of Ax=b (regardless of b) \param iters
+   On input the max number of iteration, on output the number of performed
+   iterations. \param tol_error On input the tolerance error, on output an
+   estimation of the relative error. \param L On input Number of additional
+   GMRES steps to take. If L is too large (~20) instabilities occur. \return
+   false in the case of numerical issue, for example a break down of BiCGSTABL.
+*/
+template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool bicgstabl(const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters,
+               typename Dest::RealScalar &tol_error, Index L) {
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  const Index N = rhs.size();
+  L = numext::mini(L, x.rows());
+
+  Index k = 0;
+
+  const RealScalar tol = tol_error;
+  const Index maxIters = iters;
+
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using DenseMatrixType = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  DenseMatrixType rHat(N, L + 1);
+  DenseMatrixType uHat(N, L + 1);
+
+  // We start with an initial guess x_0 and let us set r_0 as (residual
+  // calculated from x_0)
+  VectorType x0 = x;
+  rHat.col(0).noalias() = rhs - mat * x0;  // r_0
+
+  x.setZero();  // This will contain the updates to the solution.
+  // rShadow is arbitrary, but must never be orthogonal to any residual.
+  VectorType rShadow = VectorType::Random(N);
+
+  VectorType x_prime = x;
+
+  VectorType b_prime = rHat.col(0);
+
+  // Other vectors and scalars initialization
+  Scalar rho0 = 1.0;
+  Scalar alpha = 0.0;
+  Scalar omega = 1.0;
+
+  uHat.col(0).setZero();
+
+  bool bicg_convergence = false;
+
+  const RealScalar normb = rhs.stableNorm();
+  if (normb == RealScalar(0)) {
+    x.setZero();
+    iters = 0;
+    return true;
+  }
+  RealScalar normr = rHat.col(0).stableNorm();
+  RealScalar Mx = normr;
+  RealScalar Mr = normr;
+
+  // Keep track of the solution with the lowest residual
+  RealScalar normr_min = normr;
+  VectorType x_min = x_prime + x;
+
+  // Criterion for when to apply the group-wise update, conform ref 3.
+  const RealScalar delta = 0.01;
+
+  bool compute_res = false;
+  bool update_app = false;
+
+  while (normr > tol * normb && k < maxIters) {
+    rho0 *= -omega;
+
+    for (Index j = 0; j < L; ++j) {
+      const Scalar rho1 = rShadow.dot(rHat.col(j));
+
+      if (!(numext::isfinite)(rho1) || rho0 == RealScalar(0.0)) {
+        // We cannot continue computing, return the best solution found.
+        x += x_prime;
+
+        // Check if x is better than the best stored solution thus far.
+        normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm();
+
+        if (normr > normr_min || !(numext::isfinite)(normr)) {
+          // x_min is a better solution than x, return x_min
+          x = x_min;
+          normr = normr_min;
+        }
+        tol_error = normr / normb;
+        iters = k;
+        // x contains the updates to x0, add those back to obtain the solution
+        x = precond.solve(x);
+        x += x0;
+        return (normr < tol * normb);
+      }
+
+      const Scalar beta = alpha * (rho1 / rho0);
+      rho0 = rho1;
+      // Update search directions
+      uHat.leftCols(j + 1) = rHat.leftCols(j + 1) - beta * uHat.leftCols(j + 1);
+      uHat.col(j + 1).noalias() = mat * precond.solve(uHat.col(j));
+      const Scalar sigma = rShadow.dot(uHat.col(j + 1));
+      alpha = rho1 / sigma;
+      // Update residuals
+      rHat.leftCols(j + 1) -= alpha * uHat.middleCols(1, j + 1);
+      rHat.col(j + 1).noalias() = mat * precond.solve(rHat.col(j));
+      // Complete BiCG iteration by updating x
+      x += alpha * uHat.col(0);
+      normr = rHat.col(0).stableNorm();
+      // Check for early exit
+      if (normr < tol * normb) {
+        /*
+          Convergence was achieved during BiCG step.
+          Without this check BiCGStab(L) fails for trivial matrices, such as
+          when the preconditioner already is the inverse, or the input matrix is
+          identity.
+        */
+        bicg_convergence = true;
+        break;
+      } else if (normr < normr_min) {
+        // We found an x with lower residual, keep this one.
+        x_min = x + x_prime;
+        normr_min = normr;
+      }
+    }
+    if (!bicg_convergence) {
+      /*
+        The polynomial/minimize residual step.
+
+        QR Householder method for argmin is more stable than (modified)
+        Gram-Schmidt, in the sense that there is less loss of orthogonality. It
+        is more accurate than solving the normal equations, since the normal
+        equations scale with condition number squared.
+      */
+      const VectorType gamma = rHat.rightCols(L).householderQr().solve(rHat.col(0));
+      x.noalias() += rHat.leftCols(L) * gamma;
+      rHat.col(0).noalias() -= rHat.rightCols(L) * gamma;
+      uHat.col(0).noalias() -= uHat.rightCols(L) * gamma;
+      normr = rHat.col(0).stableNorm();
+      omega = gamma(L - 1);
+    }
+    if (normr < normr_min) {
+      // We found an x with lower residual, keep this one.
+      x_min = x + x_prime;
+      normr_min = normr;
+    }
+
+    k++;
+
+    /*
+      Reliable update part
+
+      The recursively computed residual can deviate from the actual residual
+      after several iterations. However, computing the residual from the
+      definition costs extra MVs and should not be done at each iteration. The
+      reliable update strategy computes the true residual from the definition:
+      r=b-A*x at strategic intervals. Furthermore a "group wise update" strategy
+      is used to combine updates, which improves accuracy.
+    */
+
+    // Maximum norm of residuals since last update of x.
+    Mx = numext::maxi(Mx, normr);
+    // Maximum norm of residuals since last computation of the true residual.
+    Mr = numext::maxi(Mr, normr);
+
+    if (normr < delta * normb && normb <= Mx) {
+      update_app = true;
+    }
+
+    if (update_app || (normr < delta * Mr && normb <= Mr)) {
+      compute_res = true;
+    }
+
+    if (bicg_convergence) {
+      update_app = true;
+      compute_res = true;
+      bicg_convergence = false;
+    }
+
+    if (compute_res) {
+      // Explicitly compute residual from the definition
+
+      // This is equivalent to the shifted version of rhs - mat *
+      // (precond.solve(x)+x0)
+      rHat.col(0).noalias() = b_prime - mat * precond.solve(x);
+      normr = rHat.col(0).stableNorm();
+      Mr = normr;
+
+      if (update_app) {
+        // After the group wise update, the original problem is translated to a
+        // shifted one.
+        x_prime += x;
+        x.setZero();
+        b_prime = rHat.col(0);
+        Mx = normr;
+      }
+    }
+    if (normr < normr_min) {
+      // We found an x with lower residual, keep this one.
+      x_min = x + x_prime;
+      normr_min = normr;
+    }
+
+    compute_res = false;
+    update_app = false;
+  }
+
+  // Convert internal variable to the true solution vector x
+  x += x_prime;
+
+  normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm();
+  if (normr > normr_min || !(numext::isfinite)(normr)) {
+    // x_min is a better solution than x, return x_min
+    x = x_min;
+    normr = normr_min;
+  }
+  tol_error = normr / normb;
+  iters = k;
+
+  // x contains the updates to x0, add those back to obtain the solution
+  x = precond.solve(x);
+  x += x0;
+  return true;
+}
+
+}  // namespace internal
+
+template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar>>
+class BiCGSTABL;
+
+namespace internal {
+
+template <typename MatrixType_, typename Preconditioner_>
+struct traits<Eigen::BiCGSTABL<MatrixType_, Preconditioner_>> {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+}  // namespace internal
+
+template <typename MatrixType_, typename Preconditioner_>
+class BiCGSTABL : public IterativeSolverBase<BiCGSTABL<MatrixType_, Preconditioner_>> {
+ protected:
+  using Base = IterativeSolverBase<BiCGSTABL>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::matrix;
+  Index m_L = 2;
+
+ public:
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
+
+  /** Default constructor. */
+  BiCGSTABL() = default;
+
+  /**
+  Initialize the solver with matrix \a A for further \c Ax=b solving.
+
+  This constructor is a shortcut for the default constructor followed
+  by a call to compute().
+
+  \warning this class stores a reference to the matrix A as well as some
+  precomputed values that depend on it. Therefore, if \a A is changed
+  this class becomes invalid. Call compute() to update it with the new
+  matrix A, or modify a copy of A.
+  */
+  template <typename MatrixDerived>
+  explicit BiCGSTABL(const EigenBase<MatrixDerived> &A) : Base(A.derived()) {}
+
+  /** \internal */
+  /** Loops over the number of columns of b and does the following:
+    1. sets the tolerance and maxIterations
+    2. Calls the function that has the core solver routine
+  */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs &b, Dest &x) const {
+    const Index max_iterations = Base::maxIterations();
+    m_iterations = max_iterations;
+
+    m_error = Base::m_tolerance;
+
+    bool ret = internal::bicgstabl(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_L);
+    Index total_iterations = m_iterations;
+    // The recursively updated residual may stop just above the requested tolerance.
+    // Restart from the current best iterate while there is still iteration budget.
+    while (ret && m_error > Base::m_tolerance && total_iterations < max_iterations) {
+      Index restart_iterations = max_iterations - total_iterations;
+      m_error = Base::m_tolerance;
+      ret = internal::bicgstabl(matrix(), b, x, Base::m_preconditioner, restart_iterations, m_error, m_L);
+      if (restart_iterations == 0) break;
+      total_iterations += restart_iterations;
+    }
+    m_iterations = total_iterations;
+    m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+  /** Sets the parameter L, indicating how many minimize residual steps are
+   * used. Default: 2 */
+  void setL(Index L) {
+    eigen_assert(L >= 1 && "L needs to be positive");
+    m_L = L;
+  }
+};
+
+}  // namespace Eigen
+
+#endif /* EIGEN_BICGSTABL_H */
diff --git a/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h b/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
index 5bb0efe..2a52f66 100644
--- a/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
+++ b/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CONJUGATE_GRADIENT_H
 #define EIGEN_CONJUGATE_GRADIENT_H
@@ -29,9 +30,12 @@
 template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
 EIGEN_DONT_INLINE void conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond,
                                           Index& iters, typename Dest::RealScalar& tol_error) {
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  // Use Dest's plain (owning) type as VectorType. For CPU Matrix/Map this
+  // resolves to Matrix<Scalar,Dynamic,1>. For GPU DeviceMatrix, PlainObject
+  // is DeviceMatrix itself (already owning).
+  using VectorType = typename Dest::PlainObject;
 
   RealScalar tol = tol_error;
   Index maxIters = iters;
@@ -40,22 +44,27 @@
 
   VectorType residual = rhs - mat * x;  // initial residual
 
-  RealScalar rhsNorm2 = rhs.squaredNorm();
-  if (rhsNorm2 == 0) {
+  RealScalar rhsNorm = rhs.stableNorm();
+  if (rhsNorm == 0) {
     x.setZero();
     iters = 0;
     tol_error = 0;
     return;
   }
   const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
-  RealScalar threshold = numext::maxi(RealScalar(tol * tol * rhsNorm2), considerAsZero);
-  RealScalar residualNorm2 = residual.squaredNorm();
-  if (residualNorm2 < threshold) {
+  RealScalar threshold = numext::maxi(RealScalar(tol * rhsNorm), considerAsZero);
+  RealScalar residualNorm = residual.stableNorm();
+  if (residualNorm < threshold) {
     iters = 0;
-    tol_error = numext::sqrt(residualNorm2 / rhsNorm2);
+    tol_error = residualNorm / rhsNorm;
     return;
   }
 
+  // Keep the quadratic recurrence terms representable for very small or large residuals.
+  const RealScalar residualScale = internal::iterative_solver_scaling_factor(residualNorm);
+  residual /= residualScale;
+  threshold /= residualScale;
+
   VectorType p(n);
   p = precond.solve(residual);  // initial search direction
 
@@ -66,11 +75,11 @@
     tmp.noalias() = mat * p;  // the bottleneck of the algorithm
 
     Scalar alpha = absNew / p.dot(tmp);  // the amount we travel on dir
-    x += alpha * p;                      // update solution
+    x += (residualScale * alpha) * p;    // update solution
     residual -= alpha * tmp;             // update residual
 
-    residualNorm2 = residual.squaredNorm();
-    if (residualNorm2 < threshold) break;
+    residualNorm = residual.stableNorm();
+    if (residualNorm < threshold) break;
 
     z = precond.solve(residual);  // approximately solve for "A z = residual"
 
@@ -80,7 +89,7 @@
     p = z + beta * p;                        // update search direction
     i++;
   }
-  tol_error = numext::sqrt(residualNorm2 / rhsNorm2);
+  tol_error = residualNorm / (rhsNorm / residualScale);
   iters = i;
 }
 
@@ -94,8 +103,8 @@
 
 template <typename MatrixType_, int UpLo_, typename Preconditioner_>
 struct traits<ConjugateGradient<MatrixType_, UpLo_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
 };
 
 }  // namespace internal
@@ -115,8 +124,8 @@
   * \implsparsesolverconcept
   *
   * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
-  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
-  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * and setTolerance() methods. The defaults are twice the number of columns of the matrix for the maximal
+  * number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.
   *
   * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
   *
@@ -150,7 +159,8 @@
   */
 template <typename MatrixType_, int UpLo_, typename Preconditioner_>
 class ConjugateGradient : public IterativeSolverBase<ConjugateGradient<MatrixType_, UpLo_, Preconditioner_> > {
-  typedef IterativeSolverBase<ConjugateGradient> Base;
+ protected:
+  using Base = IterativeSolverBase<ConjugateGradient>;
   using Base::m_error;
   using Base::m_info;
   using Base::m_isInitialized;
@@ -158,10 +168,10 @@
   using Base::matrix;
 
  public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
 
   enum { UpLo = UpLo_ };
 
@@ -182,24 +192,22 @@
   template <typename MatrixDerived>
   explicit ConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
 
-  ~ConjugateGradient() {}
-
   /** \internal */
   template <typename Rhs, typename Dest>
   void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
-    typedef typename Base::MatrixWrapper MatrixWrapper;
-    typedef typename Base::ActualMatrixType ActualMatrixType;
+    using MatrixWrapper = typename Base::MatrixWrapper;
+    using ActualMatrixType = typename Base::ActualMatrixType;
     enum {
       TransposeInput = (!MatrixWrapper::MatrixFree) && (UpLo == (Lower | Upper)) && (!MatrixType::IsRowMajor) &&
                        (!NumTraits<Scalar>::IsComplex)
     };
-    typedef std::conditional_t<TransposeInput, Transpose<const ActualMatrixType>, ActualMatrixType const&>
-        RowMajorWrapper;
+    using RowMajorWrapper =
+        std::conditional_t<TransposeInput, Transpose<const ActualMatrixType>, ActualMatrixType const&>;
     EIGEN_STATIC_ASSERT(internal::check_implication(MatrixWrapper::MatrixFree, UpLo == (Lower | Upper)),
                         MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
-    typedef std::conditional_t<UpLo == (Lower | Upper), RowMajorWrapper,
-                               typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type>
-        SelfAdjointWrapper;
+    using SelfAdjointWrapper =
+        std::conditional_t<UpLo == (Lower | Upper), RowMajorWrapper,
+                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type>;
 
     m_iterations = Base::maxIterations();
     m_error = Base::m_tolerance;
@@ -208,8 +216,6 @@
     internal::conjugate_gradient(SelfAdjointWrapper(row_mat), b, x, Base::m_preconditioner, m_iterations, m_error);
     m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
   }
-
- protected:
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/IterativeLinearSolvers/DGMRES.h b/Eigen/src/IterativeLinearSolvers/DGMRES.h
new file mode 100644
index 0000000..2e7028f
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/DGMRES.h
@@ -0,0 +1,501 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_DGMRES_H
+#define EIGEN_DGMRES_H
+
+#include "../../Eigenvalues"
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> >
+class DGMRES;
+
+namespace internal {
+
+template <typename MatrixType_, typename Preconditioner_>
+struct traits<DGMRES<MatrixType_, Preconditioner_> > {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+/** \brief Computes a permutation vector to have a sorted sequence
+ * \param vec The vector to reorder.
+ * \param perm gives the sorted sequence on output. Must be initialized with 0..n-1
+ * \param ncut Put  the ncut smallest elements at the end of the vector
+ * WARNING This is an expensive sort, so should be used only
+ * for small size vectors
+ * TODO: Use modified QuickSplit or std::nth_element to get the smallest values
+ */
+template <typename VectorType, typename IndexType>
+void sortWithPermutation(VectorType& vec, IndexType& perm, typename IndexType::Scalar& ncut) {
+  eigen_assert(vec.size() == perm.size());
+  for (Index k = 0; k < ncut; k++) {
+    bool flag = false;
+    for (Index j = 0; j < vec.size() - 1; j++) {
+      if (vec(perm(j)) < vec(perm(j + 1))) {
+        std::swap(perm(j), perm(j + 1));
+        flag = true;
+      }
+      if (!flag) break;  // The vector is in sorted order
+    }
+  }
+}
+
+}  // namespace internal
+/**
+ * \ingroup IterativeLinearSolvers_Module
+ * \brief A Restarted GMRES with deflation.
+ * This class implements a modification of the GMRES solver for
+ * sparse linear systems. The basis is built with modified
+ * Gram-Schmidt. At each restart, a few approximated eigenvectors
+ * corresponding to the smallest eigenvalues are used to build a
+ * preconditioner for the next cycle. This preconditioner
+ * for deflation can be combined with any other preconditioner,
+ * the IncompleteLUT for instance. The preconditioner is applied
+ * at right of the matrix and the combination is multiplicative.
+ *
+ * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
+ * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
+ * Typical usage :
+ * \code
+ * SparseMatrix<double> A;
+ * VectorXd x, b;
+ * //Fill A and b ...
+ * DGMRES<SparseMatrix<double> > solver;
+ * solver.set_restart(30); // Set restarting value
+ * solver.setEigenv(1); // Set the number of eigenvalues to deflate
+ * solver.compute(A);
+ * x = solver.solve(b);
+ * \endcode
+ *
+ * DGMRES can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+ *
+ * References :
+ * [1] D. NUENTSA WAKAM and F. PACULL, Memory Efficient Hybrid
+ *  Algebraic Solvers for Linear Systems Arising from Compressible
+ *  Flows, Computers and Fluids, In Press,
+ *  https://doi.org/10.1016/j.compfluid.2012.03.023
+ * [2] K. Burrage and J. Erhel, On the performance of various
+ * adaptive preconditioned GMRES strategies, 5(1998), 101-121.
+ * [3] J. Erhel, K. Burrage and B. Pohl, Restarted GMRES
+ *  preconditioned by deflation,J. Computational and Applied
+ *  Mathematics, 69(1996), 303-318.
+
+ *
+ */
+template <typename MatrixType_, typename Preconditioner_>
+class DGMRES : public IterativeSolverBase<DGMRES<MatrixType_, Preconditioner_> > {
+ protected:
+  using Base = IterativeSolverBase<DGMRES>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::m_tolerance;
+  using Base::matrix;
+
+ public:
+  using Base::_solve_impl;
+  using Base::_solve_with_guess_impl;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using RealScalar = typename MatrixType::RealScalar;
+  using ComplexScalar = internal::make_complex_t<Scalar>;
+  using Preconditioner = Preconditioner_;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic>;
+  using DenseRealMatrix = Matrix<RealScalar, Dynamic, Dynamic>;
+  using DenseVector = Matrix<Scalar, Dynamic, 1>;
+  using DenseRealVector = Matrix<RealScalar, Dynamic, 1>;
+  using ComplexVector = Matrix<ComplexScalar, Dynamic, 1>;
+
+  /** Default constructor. */
+  DGMRES()
+      : Base(), m_restart(30), m_neig(0), m_r(0), m_maxNeig(5), m_isDeflAllocated(false), m_isDeflInitialized(false) {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+   *
+   * This constructor is a shortcut for the default constructor followed
+   * by a call to compute().
+   *
+   * \warning this class stores a reference to the matrix A as well as some
+   * precomputed values that depend on it. Therefore, if \a A is changed
+   * this class becomes invalid. Call compute() to update it with the new
+   * matrix A, or modify a copy of A.
+   */
+  template <typename MatrixDerived>
+  explicit DGMRES(const EigenBase<MatrixDerived>& A)
+      : Base(A.derived()),
+        m_restart(30),
+        m_neig(0),
+        m_r(0),
+        m_maxNeig(5),
+        m_isDeflAllocated(false),
+        m_isDeflInitialized(false) {}
+
+  /** \internal */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
+    EIGEN_STATIC_ASSERT(Rhs::ColsAtCompileTime == 1 || Dest::ColsAtCompileTime == 1,
+                        YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX);
+
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    dgmres(matrix(), b, x, Base::m_preconditioner);
+  }
+
+  /**
+   * Get the restart value
+   */
+  Index restart() const { return m_restart; }
+
+  /**
+   * Set the restart value (default is 30)
+   */
+  void set_restart(const Index restart) { m_restart = restart; }
+
+  /**
+   * Set the number of eigenvalues to deflate at each restart
+   */
+  void setEigenv(const Index neig) {
+    m_neig = neig;
+    if (neig + 1 > m_maxNeig) m_maxNeig = neig + 1;  // To allow for complex conjugates
+  }
+
+  /**
+   * Get the size of the deflation subspace size
+   */
+  Index deflSize() const { return m_r; }
+
+  /**
+   * Set the maximum size of the deflation subspace
+   */
+  void setMaxEigenv(const Index maxNeig) { m_maxNeig = maxNeig; }
+
+ protected:
+  // DGMRES algorithm
+  template <typename Rhs, typename Dest>
+  void dgmres(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond) const;
+  // Perform one cycle of GMRES
+  template <typename Dest>
+  Index dgmresCycle(const MatrixType& mat, const Preconditioner& precond, Dest& x, DenseVector& r0, RealScalar& beta,
+                    const RealScalar& normRhs, Index& nbIts) const;
+  // Compute data to use for deflation
+  Index dgmresComputeDeflationData(const MatrixType& mat, const Preconditioner& precond, const Index& it,
+                                   StorageIndex& neig) const;
+  // Apply deflation to a vector
+  template <typename RhsType, typename DestType>
+  Index dgmresApplyDeflation(const RhsType& In, DestType& Out) const;
+  ComplexVector schurValues(const ComplexSchur<DenseMatrix>& schurofH) const;
+  ComplexVector schurValues(const RealSchur<DenseMatrix>& schurofH) const;
+  // Init data for deflation
+  void dgmresInitDeflation(Index& rows) const;
+  mutable DenseMatrix m_V;                  // Krylov basis vectors
+  mutable DenseMatrix m_H;                  // Hessenberg matrix
+  mutable DenseMatrix m_Hes;                // Initial hessenberg matrix without Givens rotations applied
+  mutable Index m_restart;                  // Maximum size of the Krylov subspace
+  mutable DenseMatrix m_U;                  // Vectors that form the basis of the invariant subspace
+  mutable DenseMatrix m_MU;                 // matrix operator applied to m_U (for next cycles)
+  mutable DenseMatrix m_T;                  /* T=U^T*M^{-1}*A*U */
+  mutable PartialPivLU<DenseMatrix> m_luT;  // LU factorization of m_T
+  mutable StorageIndex m_neig;              // Number of eigenvalues to extract at each restart
+  mutable Index m_r;                        // Current number of deflated eigenvalues, size of m_U
+  mutable Index m_maxNeig;                  // Maximum number of eigenvalues to deflate
+  mutable RealScalar m_lambdaN;             // Modulus of the largest eigenvalue of A
+  mutable bool m_isDeflAllocated;
+  mutable bool m_isDeflInitialized;
+
+  // Adaptive strategy
+  mutable RealScalar m_smv;  // Smaller multiple of the remaining number of steps allowed
+  mutable bool m_force;      // Force the use of deflation at each restart
+};
+/**
+ * \brief Perform several cycles of restarted GMRES with modified Gram Schmidt,
+ *
+ * A right preconditioner is used combined with deflation.
+ *
+ */
+template <typename MatrixType_, typename Preconditioner_>
+template <typename Rhs, typename Dest>
+void DGMRES<MatrixType_, Preconditioner_>::dgmres(const MatrixType& mat, const Rhs& rhs, Dest& x,
+                                                  const Preconditioner& precond) const {
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+
+  RealScalar normRhs = rhs.norm();
+  if (normRhs <= considerAsZero) {
+    x.setZero();
+    m_error = 0;
+    m_iterations = 0;
+    return;
+  }
+
+  // Initialization
+  m_isDeflInitialized = false;
+  Index n = mat.rows();
+  DenseVector r0(n);
+  Index nbIts = 0;
+  m_H.resize(m_restart + 1, m_restart);
+  m_Hes.resize(m_restart, m_restart);
+  m_V.resize(n, m_restart + 1);
+  // Initial residual vector and initial norm
+  if (x.squaredNorm() == 0) x = precond.solve(rhs);
+  r0.noalias() = rhs - mat * x;
+  RealScalar beta = r0.norm();
+
+  m_error = beta / normRhs;
+  if (m_error < m_tolerance)
+    m_info = Success;
+  else
+    m_info = NoConvergence;
+
+  // Iterative process
+  while (nbIts < m_iterations && m_info == NoConvergence) {
+    dgmresCycle(mat, precond, x, r0, beta, normRhs, nbIts);
+
+    // Compute the new residual vector for the restart
+    if (nbIts < m_iterations && m_info == NoConvergence) {
+      r0.noalias() = rhs - mat * x;
+      beta = r0.norm();
+    }
+  }
+  // m_iterations carried the iteration cap for the loops above; report the number actually performed.
+  m_iterations = nbIts;
+}
+
+/**
+ * \brief Perform one restart cycle of DGMRES
+ * \param mat The coefficient matrix
+ * \param precond The preconditioner
+ * \param x the new approximated solution
+ * \param r0 The initial residual vector
+ * \param beta The norm of the residual computed so far
+ * \param normRhs The norm of the right hand side vector
+ * \param nbIts The number of iterations
+ */
+template <typename MatrixType_, typename Preconditioner_>
+template <typename Dest>
+Index DGMRES<MatrixType_, Preconditioner_>::dgmresCycle(const MatrixType& mat, const Preconditioner& precond, Dest& x,
+                                                        DenseVector& r0, RealScalar& beta, const RealScalar& normRhs,
+                                                        Index& nbIts) const {
+  // Initialization
+  DenseVector g(m_restart + 1);  // Right hand side of the least square problem
+  g.setZero();
+  g(0) = Scalar(beta);
+  m_V.col(0) = r0 / beta;
+  m_info = NoConvergence;
+  std::vector<JacobiRotation<Scalar> > gr(m_restart);  // Givens rotations
+  Index it = 0;                                        // Number of inner iterations
+  Index n = mat.rows();
+  DenseVector tv1(n), tv2(n);  // Temporary vectors
+  while (m_info == NoConvergence && it < m_restart && nbIts < m_iterations) {
+    // Apply preconditioner(s) at right
+    if (m_isDeflInitialized) {
+      dgmresApplyDeflation(m_V.col(it), tv1);  // Deflation
+      tv2 = precond.solve(tv1);
+    } else {
+      tv2 = precond.solve(m_V.col(it));  // User's selected preconditioner
+    }
+    tv1.noalias() = mat * tv2;
+
+    // Orthogonalize it with the previous basis in the basis using modified Gram-Schmidt
+    Scalar coef;
+    for (Index i = 0; i <= it; ++i) {
+      coef = tv1.dot(m_V.col(i));
+      tv1 = tv1 - coef * m_V.col(i);
+      m_H(i, it) = coef;
+      m_Hes(i, it) = coef;
+    }
+    // Normalize the vector. coef == 0 is an Arnoldi happy breakdown: the new
+    // direction lies in span(V[0..it]), so skip the division (which would
+    // poison m_V.col(it+1) with NaN) and fall through to the termination
+    // check below.
+    coef = tv1.norm();
+    const bool happy_breakdown = numext::is_exactly_zero(coef);
+    if (!happy_breakdown) {
+      m_V.col(it + 1) = tv1 / coef;
+    }
+    m_H(it + 1, it) = coef;
+
+    // Update Hessenberg matrix with Givens rotations
+    for (Index i = 1; i <= it; ++i) {
+      m_H.col(it).applyOnTheLeft(i - 1, i, gr[i - 1].adjoint());
+    }
+
+    // If the rotated diagonal is also zero, the reduced triangular system
+    // becomes singular and the back-substitution below would produce Inf/NaN.
+    // Stop with NumericalIssue instead of polluting x.
+    if (happy_breakdown && numext::is_exactly_zero(m_H(it, it))) {
+      m_info = NumericalIssue;
+      break;
+    }
+
+    // Compute the new plane rotation
+    gr[it].makeGivens(m_H(it, it), m_H(it + 1, it));
+    // Apply the new rotation
+    m_H.col(it).applyOnTheLeft(it, it + 1, gr[it].adjoint());
+    g.applyOnTheLeft(it, it + 1, gr[it].adjoint());
+
+    beta = numext::abs(g(it + 1));
+    m_error = beta / normRhs;
+    it++;
+    nbIts++;
+
+    if (m_error < m_tolerance || happy_breakdown) {
+      // Happy breakdown: residual on the current subspace is exactly zero, so
+      // the it-dim triangular system yields the exact solution.
+      m_info = Success;
+      break;
+    }
+  }
+
+  // Compute the new coefficients by solving the least square problem.
+  DenseVector nrs = m_H.topLeftCorner(it, it).template triangularView<Upper>().solve(g.head(it));
+
+  // Form the new solution
+  if (m_isDeflInitialized) {
+    tv1.noalias() = m_V.leftCols(it) * nrs;
+    dgmresApplyDeflation(tv1, tv2);
+    x = x + precond.solve(tv2);
+  } else
+    x = x + precond.solve(m_V.leftCols(it) * nrs);
+
+  // Go for a new cycle and compute data for deflation
+  if (nbIts < m_iterations && m_info == NoConvergence && m_neig > 0 && (m_r + m_neig) < m_maxNeig)
+    dgmresComputeDeflationData(mat, precond, it, m_neig);
+  return 0;
+}
+
+template <typename MatrixType_, typename Preconditioner_>
+void DGMRES<MatrixType_, Preconditioner_>::dgmresInitDeflation(Index& rows) const {
+  m_U.resize(rows, m_maxNeig);
+  m_MU.resize(rows, m_maxNeig);
+  m_T.resize(m_maxNeig, m_maxNeig);
+  m_lambdaN = 0.0;
+  m_isDeflAllocated = true;
+}
+
+template <typename MatrixType_, typename Preconditioner_>
+inline typename DGMRES<MatrixType_, Preconditioner_>::ComplexVector DGMRES<MatrixType_, Preconditioner_>::schurValues(
+    const ComplexSchur<DenseMatrix>& schurofH) const {
+  return schurofH.matrixT().diagonal();
+}
+
+template <typename MatrixType_, typename Preconditioner_>
+inline typename DGMRES<MatrixType_, Preconditioner_>::ComplexVector DGMRES<MatrixType_, Preconditioner_>::schurValues(
+    const RealSchur<DenseMatrix>& schurofH) const {
+  const DenseMatrix& T = schurofH.matrixT();
+  Index it = T.rows();
+  ComplexVector eig(it);
+  Index j = 0;
+  while (j < it - 1) {
+    if (T(j + 1, j) == Scalar(0)) {
+      eig(j) = ComplexScalar(T(j, j), RealScalar(0));
+      j++;
+    } else {
+      eig(j) = ComplexScalar(T(j, j), T(j + 1, j));
+      eig(j + 1) = ComplexScalar(T(j, j + 1), T(j + 1, j + 1));
+      j++;
+    }
+  }
+  if (j < it - 1) eig(j) = ComplexScalar(T(j, j), RealScalar(0));
+  return eig;
+}
+
+template <typename MatrixType_, typename Preconditioner_>
+Index DGMRES<MatrixType_, Preconditioner_>::dgmresComputeDeflationData(const MatrixType& mat,
+                                                                       const Preconditioner& precond, const Index& it,
+                                                                       StorageIndex& neig) const {
+  // First, find the Schur form of the Hessenberg matrix H
+  std::conditional_t<NumTraits<Scalar>::IsComplex, ComplexSchur<DenseMatrix>, RealSchur<DenseMatrix> > schurofH;
+  bool computeU = true;
+  DenseMatrix matrixQ(it, it);
+  matrixQ.setIdentity();
+  schurofH.computeFromHessenberg(m_Hes.topLeftCorner(it, it), matrixQ, computeU);
+
+  ComplexVector eig = this->schurValues(schurofH);
+  Matrix<StorageIndex, Dynamic, 1> perm(it);
+
+  // Reorder the absolute values of Schur values
+  DenseRealVector modulEig(it);
+  for (Index j = 0; j < it; ++j) modulEig(j) = numext::abs(eig(j));
+  perm.setLinSpaced(it, 0, internal::convert_index<StorageIndex>(it - 1));
+  internal::sortWithPermutation(modulEig, perm, neig);
+
+  if (!m_lambdaN) {
+    m_lambdaN = (std::max)(modulEig.maxCoeff(), m_lambdaN);
+  }
+  // Count the real number of extracted eigenvalues (with complex conjugates)
+  Index nbrEig = 0;
+  while (nbrEig < neig) {
+    if (eig(perm(it - nbrEig - 1)).imag() == RealScalar(0))
+      nbrEig++;
+    else
+      nbrEig += 2;
+  }
+  // Extract the  Schur vectors corresponding to the smallest Ritz values
+  DenseMatrix Sr(it, nbrEig);
+  Sr.setZero();
+  for (Index j = 0; j < nbrEig; j++) {
+    Sr.col(j) = schurofH.matrixU().col(perm(it - j - 1));
+  }
+
+  // Form the Schur vectors of the initial matrix using the Krylov basis
+  DenseMatrix X = m_V.leftCols(it) * Sr;
+  if (m_r) {
+    // Orthogonalize X against m_U using modified Gram-Schmidt
+    for (Index j = 0; j < nbrEig; j++)
+      for (Index k = 0; k < m_r; k++) X.col(j) = X.col(j) - (m_U.col(k).dot(X.col(j))) * m_U.col(k);
+  }
+
+  // Compute MX = M^-1 * A * X
+  Index m = m_V.rows();
+  if (!m_isDeflAllocated) dgmresInitDeflation(m);
+  DenseMatrix MX(m, nbrEig);
+  DenseVector tv1(m);
+  for (Index j = 0; j < nbrEig; j++) {
+    tv1.noalias() = mat * X.col(j);
+    MX.col(j) = precond.solve(tv1);
+  }
+
+  // Update m_T = [U'MU U'MX; X'MU X'MX]
+  m_T.block(m_r, m_r, nbrEig, nbrEig).noalias() = X.transpose() * MX;
+  if (m_r) {
+    m_T.block(0, m_r, m_r, nbrEig).noalias() = m_U.leftCols(m_r).transpose() * MX;
+    m_T.block(m_r, 0, nbrEig, m_r).noalias() = X.transpose() * m_MU.leftCols(m_r);
+  }
+
+  // Save X into m_U and m_MX in m_MU
+  for (Index j = 0; j < nbrEig; j++) m_U.col(m_r + j) = X.col(j);
+  for (Index j = 0; j < nbrEig; j++) m_MU.col(m_r + j) = MX.col(j);
+  // Increase the size of the invariant subspace
+  m_r += nbrEig;
+
+  // Factorize m_T into m_luT
+  m_luT.compute(m_T.topLeftCorner(m_r, m_r));
+
+  // FIXME: Check if the factorization was correctly done (nonsingular matrix).
+  m_isDeflInitialized = true;
+  return 0;
+}
+template <typename MatrixType_, typename Preconditioner_>
+template <typename RhsType, typename DestType>
+Index DGMRES<MatrixType_, Preconditioner_>::dgmresApplyDeflation(const RhsType& x, DestType& y) const {
+  DenseVector x1 = m_U.leftCols(m_r).transpose() * x;
+  y = x + m_U.leftCols(m_r) * (m_lambdaN * m_luT.solve(x1) - x1);
+  return 0;
+}
+
+}  // end namespace Eigen
+#endif
diff --git a/Eigen/src/IterativeLinearSolvers/GMRES.h b/Eigen/src/IterativeLinearSolvers/GMRES.h
new file mode 100644
index 0000000..36a297a
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/GMRES.h
@@ -0,0 +1,323 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012, 2014 Kolja Brix <brix@igpm.rwth-aaachen.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GMRES_H
+#define EIGEN_GMRES_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/**
+ * Generalized Minimal Residual Algorithm based on the
+ * Arnoldi algorithm implemented with Householder reflections.
+ *
+ * Parameters:
+ *  \param mat       matrix of linear system of equations
+ *  \param rhs       right hand side vector of linear system of equations
+ *  \param x         on input: initial guess, on output: solution
+ *  \param precond   preconditioner used
+ *  \param iters     on input: maximum number of iterations to perform
+ *                   on output: number of iterations performed
+ *  \param restart_  number of iterations for a restart, clamped to [1, mat.rows()]
+ *  \param tol_error on input: relative tolerance for the preconditioned residual, normalized by the preconditioned
+ *                   right-hand side
+ *                   on output: relative preconditioned residual achieved
+ *
+ * \sa IterativeMethods::bicgstab()
+ *
+ *
+ * For references, please see:
+ *
+ * Saad, Y. and Schultz, M. H.
+ * GMRES: A Generalized Minimal Residual Algorithm for Solving Nonsymmetric Linear Systems.
+ * SIAM J.Sci.Stat.Comp. 7, 1986, pp. 856 - 869.
+ *
+ * Saad, Y.
+ * Iterative Methods for Sparse Linear Systems.
+ * Society for Industrial and Applied Mathematics, Philadelphia, 2003.
+ *
+ * Walker, H. F.
+ * Implementations of the GMRES method.
+ * Comput.Phys.Comm. 53, 1989, pp. 311 - 320.
+ *
+ * Walker, H. F.
+ * Implementation of the GMRES Method using Householder Transformations.
+ * SIAM J.Sci.Stat.Comp. 9, 1988, pp. 152 - 163.
+ *
+ */
+template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool gmres(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond, Index& iters,
+           const Index& restart_, typename Dest::RealScalar& tol_error) {
+  using std::abs;
+  using std::sqrt;
+
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using FMatrixType = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+
+  if (rhs.norm() <= considerAsZero) {
+    x.setZero();
+    tol_error = 0;
+    return true;
+  }
+
+  RealScalar tol = tol_error;
+  const Index maxIters = iters;
+  iters = 0;
+
+  const Index m = mat.rows();
+  // A GMRES cycle cannot use more Krylov vectors than the problem dimension, so cap the internal workspace even if
+  // the user requests a larger restart value.
+  const Index restart = numext::mini(numext::maxi(restart_, Index(1)), m);
+
+  // residual and preconditioned residual
+  VectorType p0 = rhs - mat * x;
+  VectorType r0 = precond.solve(p0);
+
+  const RealScalar r0Norm = r0.norm();
+  // w(k) tracks the residual norm of the left-preconditioned system. Normalize it by the matching right-hand
+  // side, not by the initial residual, so solveWithGuess() uses the same relative-residual criterion as solve().
+  const RealScalar rhsNorm = numext::maxi((x.squaredNorm() == 0) ? r0Norm : precond.solve(rhs).norm(), considerAsZero);
+  const RealScalar threshold = numext::maxi(tol * rhsNorm, considerAsZero);
+
+  // is initial guess already good enough?
+  if (r0Norm < threshold) {
+    tol_error = r0Norm / rhsNorm;
+    return true;
+  }
+
+  // storage for Hessenberg matrix and Householder data
+  FMatrixType H = FMatrixType::Zero(m, restart + 1);
+  VectorType w = VectorType::Zero(restart + 1);
+  VectorType tau = VectorType::Zero(restart + 1);
+
+  // storage for Jacobi rotations
+  std::vector<JacobiRotation<Scalar> > G(restart);
+
+  // storage for temporaries
+  VectorType t(m), v(m), workspace(m), x_new(m);
+
+  // generate first Householder vector
+  Ref<VectorType> H0_tail = H.col(0).tail(m - 1);
+  RealScalar beta;
+  r0.makeHouseholder(H0_tail, tau.coeffRef(0), beta);
+  w(0) = Scalar(beta);
+
+  for (Index k = 1; k <= restart; ++k) {
+    ++iters;
+
+    v = VectorType::Unit(m, k - 1);
+
+    // apply Householder reflections H_{1} ... H_{k-1} to v
+    // TODO: use a HouseholderSequence
+    for (Index i = k - 1; i >= 0; --i) {
+      v.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
+    }
+
+    // apply matrix M to v:  v = mat * v;
+    t.noalias() = mat * v;
+    v = precond.solve(t);
+
+    // apply Householder reflections H_{k-1} ... H_{1} to v
+    // TODO: use a HouseholderSequence
+    for (Index i = 0; i < k; ++i) {
+      v.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
+    }
+
+    if (v.tail(m - k).norm() != 0.0 && k <= restart) {
+      // generate new Householder vector
+      Ref<VectorType> Hk_tail = H.col(k).tail(m - k - 1);
+      v.tail(m - k).makeHouseholder(Hk_tail, tau.coeffRef(k), beta);
+
+      // apply Householder reflection H_{k} to v
+      v.tail(m - k).applyHouseholderOnTheLeft(Hk_tail, tau.coeffRef(k), workspace.data());
+    }
+
+    // apply old Givens rotations to v
+    for (Index i = 0; i < k - 1; ++i) {
+      v.applyOnTheLeft(i, i + 1, G[i].adjoint());
+    }
+
+    if (k < m && v(k) != (Scalar)0) {
+      // determine next Givens rotation
+      G[k - 1].makeGivens(v(k - 1), v(k));
+
+      // apply Givens rotation to v and w
+      v.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
+      w.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
+    }
+
+    // insert coefficients into upper matrix triangle
+    H.col(k - 1).head(k) = v.head(k);
+
+    tol_error = abs(w(k)) / rhsNorm;
+    bool stop = (k == m || tol_error < tol || iters == maxIters);
+
+    if (stop || k == restart) {
+      // solve upper triangular system
+      Ref<VectorType> y = w.head(k);
+      H.topLeftCorner(k, k).template triangularView<Upper>().solveInPlace(y);
+
+      // use Horner-like scheme to calculate solution vector
+      x_new.setZero();
+      for (Index i = k - 1; i >= 0; --i) {
+        x_new(i) += y(i);
+        // apply Householder reflection H_{i} to x_new
+        x_new.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
+      }
+
+      x += x_new;
+
+      if (stop) {
+        return true;
+      } else {
+        k = 0;
+
+        // reset data for restart
+        p0.noalias() = rhs - mat * x;
+        r0 = precond.solve(p0);
+
+        // clear Hessenberg matrix and Householder data
+        H.setZero();
+        w.setZero();
+        tau.setZero();
+
+        // generate first Householder vector
+        r0.makeHouseholder(H0_tail, tau.coeffRef(0), beta);
+        w(0) = Scalar(beta);
+      }
+    }
+  }
+
+  return false;
+}
+
+}  // namespace internal
+
+template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> >
+class GMRES;
+
+namespace internal {
+
+template <typename MatrixType_, typename Preconditioner_>
+struct traits<GMRES<MatrixType_, Preconditioner_> > {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+}  // namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+ * \brief A GMRES solver for sparse square problems
+ *
+ * This class allows to solve for A.x = b sparse linear problems using a generalized minimal
+ * residual method. The vectors x and b can be either dense or sparse.
+ *
+ * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
+ * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
+ *
+ * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+ * and setTolerance() methods. The defaults are twice the number of columns of the matrix for the maximal
+ * number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.
+ *
+ * When a left preconditioner M is used, GMRES applies the stopping criterion to the preconditioned
+ * system M^{-1} A x = M^{-1} b. The reported error is therefore
+ * \f$\|M^{-1}(b-Ax)\| / \|M^{-1}b\|\f$.
+ *
+ * This class can be used as the direct solver classes. Here is a typical usage example:
+ * \code
+ * int n = 10000;
+ * VectorXd x(n), b(n);
+ * SparseMatrix<double> A(n,n);
+ * // fill A and b
+ * GMRES<SparseMatrix<double> > solver(A);
+ * x = solver.solve(b);
+ * std::cout << "#iterations:     " << solver.iterations() << std::endl;
+ * std::cout << "estimated error: " << solver.error()      << std::endl;
+ * // update b, and solve again
+ * x = solver.solve(b);
+ * \endcode
+ *
+ * By default the iterations start with x=0 as an initial guess of the solution.
+ * One can control the start using the solveWithGuess() method.
+ *
+ * GMRES can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+ *
+ * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+ */
+template <typename MatrixType_, typename Preconditioner_>
+class GMRES : public IterativeSolverBase<GMRES<MatrixType_, Preconditioner_> > {
+ protected:
+  using Base = IterativeSolverBase<GMRES>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::matrix;
+
+ private:
+  Index m_restart = 30;
+
+ public:
+  using Base::_solve_impl;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
+
+ public:
+  /** Default constructor. */
+  GMRES() : Base(), m_restart(30) {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+   *
+   * This constructor is a shortcut for the default constructor followed
+   * by a call to compute().
+   *
+   * \warning this class stores a reference to the matrix A as well as some
+   * precomputed values that depend on it. Therefore, if \a A is changed
+   * this class becomes invalid. Call compute() to update it with the new
+   * matrix A, or modify a copy of A.
+   */
+  template <typename MatrixDerived>
+  explicit GMRES(const EigenBase<MatrixDerived>& A) : Base(A.derived()), m_restart(30) {}
+
+  /** Get the number of iterations after that a restart is performed.
+   */
+  Index get_restart() const { return m_restart; }
+
+  /** Set the number of iterations after that a restart is performed.
+   *  \param restart   number of iterations for a restart, default is 30.
+   */
+  void set_restart(const Index restart) { m_restart = restart; }
+
+  /** \internal */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+    bool ret = internal::gmres(matrix(), b, x, Base::m_preconditioner, m_iterations, m_restart, m_error);
+    m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+ protected:
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_GMRES_H
diff --git a/Eigen/src/IterativeLinearSolvers/IDRS.h b/Eigen/src/IterativeLinearSolvers/IDRS.h
new file mode 100644
index 0000000..91cb07e
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/IDRS.h
@@ -0,0 +1,391 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
+// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
+// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_IDRS_H
+#define EIGEN_IDRS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+/**     \internal Low-level Induced Dimension Reduction algorithm
+        \param A The matrix A
+        \param b The right hand side vector b
+        \param x On input and initial solution, on output the computed solution.
+        \param precond A preconditioner being able to efficiently solve for an
+                  approximation of Ax=b (regardless of b)
+        \param iter On input the max number of iteration, on output the number of performed iterations.
+        \param relres On input the tolerance error, on output an estimation of the relative error.
+        \param S On input Number of the dimension of the shadow space.
+                \param smoothing switches residual smoothing on.
+                \param angle small omega lead to faster convergence at the expense of numerical stability
+                \param replacement switches on a residual replacement strategy to increase accuracy of residual at the
+   expense of more Mat*vec products \return false in the case of numerical issue, for example a break down of IDRS.
+*/
+template <typename Vector, typename RealScalar>
+typename Vector::Scalar omega(const Vector& t, const Vector& s, RealScalar angle) {
+  using numext::abs;
+  using Scalar = typename Vector::Scalar;
+  const RealScalar ns = s.stableNorm();
+  const RealScalar nt = t.stableNorm();
+  const Scalar ts = t.dot(s);
+  const RealScalar rho = abs(ts / (nt * ns));
+
+  if (rho < angle) {
+    if (ts == Scalar(0)) {
+      return Scalar(0);
+    }
+    // Original relation for om is given by
+    // om = om * angle / rho;
+    // To alleviate potential (near) division by zero this can be rewritten as
+    // om = angle * (ns / nt) * (ts / abs(ts)) = angle * (ns / nt) * sgn(ts)
+    return angle * (ns / nt) * (ts / abs(ts));
+  }
+  return ts / (nt * nt);
+}
+
+template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool idrs(const MatrixType& A, const Rhs& b, Dest& x, const Preconditioner& precond, Index& iter,
+          typename Dest::RealScalar& relres, Index S, bool smoothing, typename Dest::RealScalar angle,
+          bool replacement) {
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using DenseMatrixType = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  const Index N = b.size();
+  S = numext::mini(S, x.rows());
+  const RealScalar tol = relres;
+  const Index maxit = iter;
+
+  bool trueres = false;
+
+  FullPivLU<DenseMatrixType> lu_solver;
+
+  DenseMatrixType P = internal::random_orthonormal_basis<DenseMatrixType>(N, S);
+
+  const RealScalar normb = b.stableNorm();
+
+  if (normb == RealScalar(0)) {
+    // Solution is the zero vector
+    x.setZero();
+    iter = 0;
+    relres = 0;
+    return true;
+  }
+  // from http://homepage.tudelft.nl/1w5b5/IDRS/manual.pdf
+  // A peak in the residual is considered dangerously high if‖ri‖/‖b‖> C(tol/epsilon).
+  // With epsilon the relative machine precision. The factor tol/epsilon corresponds
+  // to the size of a finite precision number that is so large that the absolute
+  // round-off error in this number, when propagated through the process, makes it
+  // impossible to achieve the required accuracy. The factor C accounts for the
+  // accumulation of round-off errors. This parameter has been set to 10^{-3}.
+  // mp is epsilon/C 10^3 * eps is very conservative, so normally no residual
+  // replacements will take place. It only happens if things go very wrong. Too many
+  // restarts may ruin the convergence.
+  const RealScalar mp = RealScalar(1e3) * NumTraits<Scalar>::epsilon();
+
+  // Compute initial residual
+  const RealScalar tolb = tol * normb;  // Relative tolerance
+  VectorType r = b - A * x;
+
+  VectorType x_s, r_s;
+
+  if (smoothing) {
+    x_s = x;
+    r_s = r;
+  }
+
+  RealScalar normr = r.stableNorm();
+
+  if (normr <= tolb) {
+    // Initial guess is a good enough solution
+    iter = 0;
+    relres = normr / normb;
+    return true;
+  }
+
+  DenseMatrixType G = DenseMatrixType::Zero(N, S);
+  DenseMatrixType U = DenseMatrixType::Zero(N, S);
+  DenseMatrixType M = DenseMatrixType::Identity(S, S);
+  VectorType t(N), v(N);
+  Scalar om = 1.;
+
+  // Main iteration loop, build G-spaces:
+  iter = 0;
+
+  while (normr > tolb && iter < maxit) {
+    // New right hand size for small system:
+    VectorType f = (r.adjoint() * P).adjoint();
+
+    for (Index k = 0; k < S; ++k) {
+      // Solve small system and make v orthogonal to P:
+      // c = M(k:s,k:s)\f(k:s);
+      lu_solver.compute(M.block(k, k, S - k, S - k));
+      VectorType c = lu_solver.solve(f.segment(k, S - k));
+      // v = r - G(:,k:s)*c;
+      v.noalias() = r - G.rightCols(S - k) * c;
+      // Preconditioning
+      v = precond.solve(v);
+
+      // Compute new U(:,k) and G(:,k), G(:,k) is in space G_j
+      U.col(k) = U.rightCols(S - k) * c + om * v;
+      G.col(k).noalias() = A * U.col(k);
+
+      // Bi-Orthogonalise the new basis vectors:
+      for (Index i = 0; i < k - 1; ++i) {
+        // alpha =  ( P(:,i)'*G(:,k) )/M(i,i);
+        Scalar alpha = P.col(i).dot(G.col(k)) / M(i, i);
+        G.col(k) = G.col(k) - alpha * G.col(i);
+        U.col(k) = U.col(k) - alpha * U.col(i);
+      }
+
+      // New column of M = P'*G  (first k-1 entries are zero)
+      // M(k:s,k) = (G(:,k)'*P(:,k:s))';
+      M.block(k, k, S - k, 1) = (G.col(k).adjoint() * P.rightCols(S - k)).adjoint();
+
+      if (M(k, k) == Scalar(0)) {
+        return false;
+      }
+
+      // Make r orthogonal to q_i, i = 0..k-1
+      Scalar beta = f(k) / M(k, k);
+      r = r - beta * G.col(k);
+      x = x + beta * U.col(k);
+      normr = r.stableNorm();
+
+      if (replacement && normr > tolb / mp) {
+        trueres = true;
+      }
+
+      // Smoothing:
+      if (smoothing) {
+        t = r_s - r;
+        // gamma is a Scalar, but the conversion is not allowed
+        Scalar gamma = t.dot(r_s) / t.stableNorm();
+        r_s = r_s - gamma * t;
+        x_s = x_s - gamma * (x_s - x);
+        normr = r_s.stableNorm();
+      }
+
+      if (normr < tolb || iter == maxit) {
+        break;
+      }
+
+      // New f = P'*r (first k  components are zero)
+      if (k < S - 1) {
+        f.segment(k + 1, S - (k + 1)) = f.segment(k + 1, S - (k + 1)) - beta * M.block(k + 1, k, S - (k + 1), 1);
+      }
+    }  // end for
+
+    if (normr < tolb || iter == maxit) {
+      break;
+    }
+
+    // Now we have sufficient vectors in G_j to compute residual in G_j+1
+    // Note: r is already perpendicular to P so v = r
+    // Preconditioning
+    v = r;
+    v = precond.solve(v);
+
+    // Matrix-vector multiplication:
+    t.noalias() = A * v;
+
+    // Computation of a new omega
+    om = internal::omega(t, r, angle);
+
+    if (om == RealScalar(0.0)) {
+      return false;
+    }
+
+    r = r - om * t;
+    x = x + om * v;
+    normr = r.stableNorm();
+
+    if (replacement && normr > tolb / mp) {
+      trueres = true;
+    }
+
+    // Residual replacement?
+    if (trueres && normr < normb) {
+      r.noalias() = b - A * x;
+      trueres = false;
+    }
+
+    // Smoothing:
+    if (smoothing) {
+      t = r_s - r;
+      Scalar gamma = t.dot(r_s) / t.stableNorm();
+      r_s = r_s - gamma * t;
+      x_s = x_s - gamma * (x_s - x);
+      normr = r_s.stableNorm();
+    }
+
+    iter++;
+
+  }  // end while
+
+  if (smoothing) {
+    x = x_s;
+  }
+  relres = normr / normb;
+  return true;
+}
+
+}  // namespace internal
+
+template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> >
+class IDRS;
+
+namespace internal {
+
+template <typename MatrixType_, typename Preconditioner_>
+struct traits<Eigen::IDRS<MatrixType_, Preconditioner_> > {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+}  // namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+ * \brief The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square
+ * problems.
+ *
+ * This class allows to solve for A.x = b sparse linear problems. The vectors x and b can be either dense or sparse.
+ * The Induced Dimension Reduction method, IDR(), is a robust and efficient short-recurrence Krylov subspace method for
+ * solving large nonsymmetric systems of linear equations.
+ *
+ * For indefinite systems IDR(S) outperforms both BiCGStab and BiCGStab(L). Additionally, IDR(S) can handle matrices
+ * with complex eigenvalues more efficiently than BiCGStab.
+ *
+ * Many problems that do not converge for BiCGSTAB converge for IDR(s) (for larger values of s). And if both methods
+ * converge the convergence for IDR(s) is typically much faster for difficult systems (for example indefinite problems).
+ *
+ * IDR(s) is a limited memory finite termination method. In exact arithmetic it converges in at most N+N/s iterations,
+ * with N the system size.  It uses a fixed number of 4+3s vectors. In comparison, BiCGSTAB terminates in 2N iterations
+ * and uses 7 vectors. GMRES terminates in at most N iterations, and uses I+3 vectors, with I the number of iterations.
+ * Restarting GMRES limits the memory consumption, but destroys the finite termination property.
+ *
+ * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
+ * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
+ *
+ * \implsparsesolverconcept
+ *
+ * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+ * and setTolerance() methods. The defaults are twice the number of columns of the matrix for the maximal
+ * number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.
+ *
+ * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
+ *
+ * \b Performance: when using sparse matrices, best performance is achieved for a row-major sparse matrix format.
+ * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
+ * See \ref TopicMultiThreading for details.
+ *
+ * By default the iterations start with x=0 as an initial guess of the solution.
+ * One can control the start using the solveWithGuess() method.
+ *
+ * IDR(s) can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+ *
+ * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+ */
+template <typename MatrixType_, typename Preconditioner_>
+class IDRS : public IterativeSolverBase<IDRS<MatrixType_, Preconditioner_> > {
+ public:
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
+
+ private:
+  using Base = IterativeSolverBase<IDRS>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::matrix;
+  Index m_S = 4;
+  bool m_smoothing = false;
+  RealScalar m_angle = RealScalar(0.7);
+  bool m_residual = false;
+
+ public:
+  /** Default constructor. */
+  IDRS() = default;
+
+  /**     Initialize the solver with matrix \a A for further \c Ax=b solving.
+
+          This constructor is a shortcut for the default constructor followed
+          by a call to compute().
+
+          \warning this class stores a reference to the matrix A as well as some
+          precomputed values that depend on it. Therefore, if \a A is changed
+          this class becomes invalid. Call compute() to update it with the new
+          matrix A, or modify a copy of A.
+  */
+  template <typename MatrixDerived>
+  explicit IDRS(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  /** \internal */
+  /**     Loops over the number of columns of b and does the following:
+                  1. sets the tolerance and maxIterations
+                  2. Calls the function that has the core solver routine
+  */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+
+    bool ret = internal::idrs(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_S, m_smoothing, m_angle,
+                              m_residual);
+
+    m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+  /** Sets the parameter S, indicating the dimension of the shadow space. Default is 4*/
+  void setS(Index S) {
+    if (S < 1) {
+      S = 4;
+    }
+
+    m_S = S;
+  }
+
+  /** Switches off and on smoothing.
+  Residual smoothing results in monotonically decreasing residual norms at
+  the expense of two extra vectors of storage and a few extra vector
+  operations. Although monotonic decrease of the residual norms is a
+  desirable property, the rate of convergence of the unsmoothed process and
+  the smoothed process is basically the same. Default is off */
+  void setSmoothing(bool smoothing) { m_smoothing = smoothing; }
+
+  /** The angle must be a real scalar. In IDR(s), a value for the
+  iteration parameter omega must be chosen in every s+1th step. The most
+  natural choice is to select a value to minimize the norm of the next residual.
+  This corresponds to the parameter omega = 0. In practice, this may lead to
+  values of omega that are so small that the other iteration parameters
+  cannot be computed with sufficient accuracy. In such cases it is better to
+  increase the value of omega sufficiently such that a compromise is reached
+  between accurate computations and reduction of the residual norm. The
+  parameter angle =0.7 (”maintaining the convergence strategy”)
+  results in such a compromise. */
+  void setAngle(RealScalar angle) { m_angle = angle; }
+
+  /** The parameter replace is a logical that determines whether a
+  residual replacement strategy is employed to increase the accuracy of the
+  solution. */
+  void setResidualUpdate(bool update) { m_residual = update; }
+};
+
+}  // namespace Eigen
+
+#endif /* EIGEN_IDRS_H */
diff --git a/Eigen/src/IterativeLinearSolvers/IDRSTABL.h b/Eigen/src/IterativeLinearSolvers/IDRSTABL.h
new file mode 100644
index 0000000..b96acad
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/IDRSTABL.h
@@ -0,0 +1,479 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
+// Copyright (C) 2020 Mischa Senders <m.j.senders@student.tue.nl>
+// Copyright (C) 2020 Lex Kuijpers <l.kuijpers@student.tue.nl>
+// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
+// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
+// Copyright (C) 2020 Adithya Vijaykumar
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+/*
+
+The IDR(S)Stab(L) method is a combination of IDR(S) and BiCGStab(L)
+
+This implementation of IDRSTABL is based on
+1. Aihara, K., Abe, K., & Ishiwata, E. (2014). A variant of IDRstab with
+reliable update strategies for solving sparse linear systems. Journal of
+Computational and Applied Mathematics, 259, 244-258.
+   doi:10.1016/j.cam.2013.08.028
+                2. Aihara, K., Abe, K., & Ishiwata, E. (2015). Preconditioned
+IDRSTABL Algorithms for Solving Nonsymmetric Linear Systems. International
+Journal of Applied Mathematics, 45(3).
+                3. Saad, Y. (2003). Iterative Methods for Sparse Linear Systems:
+Second Edition. Philadelphia, PA: SIAM.
+                4. Sonneveld, P., & Van Gijzen, M. B. (2009). IDR(s): A Family
+of Simple and Fast Algorithms for Solving Large Nonsymmetric Systems of Linear
+Equations. SIAM Journal on Scientific Computing, 31(2), 1035-1062.
+   doi:10.1137/070685804
+                5. Sonneveld, P. (2012). On the convergence behavior of IDR (s)
+and related methods. SIAM Journal on Scientific Computing, 34(5), A2576-A2598.
+
+    Right-preconditioning based on Ref. 3 is implemented here.
+*/
+
+#ifndef EIGEN_IDRSTABL_H
+#define EIGEN_IDRSTABL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+bool idrstabl(const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters,
+              typename Dest::RealScalar &tol_error, Index L, Index S) {
+  /*
+    Setup and type definitions.
+  */
+  using numext::abs;
+  using Scalar = typename Dest::Scalar;
+  using RealScalar = typename Dest::RealScalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using DenseMatrixType = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  const Index N = x.rows();
+
+  Index k = 0;  // Iteration counter
+  const Index maxIters = iters;
+
+  const RealScalar rhs_norm = rhs.stableNorm();
+  const RealScalar tol = tol_error * rhs_norm;
+
+  if (rhs_norm == 0) {
+    /*
+      If b==0, then the exact solution is x=0.
+      rhs_norm is needed for other calculations anyways, this exit is a freebie.
+    */
+    x.setZero();
+    tol_error = 0.0;
+    return true;
+  }
+  // Construct decomposition objects beforehand.
+  FullPivLU<DenseMatrixType> lu_solver;
+
+  if (S >= N || L >= N) {
+    /*
+      The matrix is very small, or the choice of L and S is very poor
+      in that case solving directly will be best.
+    */
+    lu_solver.compute(DenseMatrixType(mat));
+    x = lu_solver.solve(rhs);
+    tol_error = (rhs - mat * x).stableNorm() / rhs_norm;
+    return true;
+  }
+
+  // Define maximum sizes to prevent any reallocation later on.
+  DenseMatrixType u(N, L + 1);
+  DenseMatrixType r(N, L + 1);
+
+  DenseMatrixType V(N * (L + 1), S);
+
+  VectorType alpha(S);
+  VectorType gamma(L);
+  VectorType update(N);
+
+  /*
+    Main IDRSTABL algorithm
+  */
+  // Set up the initial residual
+  VectorType x0 = x;
+  r.col(0).noalias() = rhs - mat * x;
+  x.setZero();  // The final solution will be x0+x
+
+  tol_error = r.col(0).stableNorm();
+
+  // FOM = Full orthogonalisation method
+  DenseMatrixType h_FOM = DenseMatrixType::Zero(S, S - 1);
+
+  // Construct an initial U matrix of size N x S
+  DenseMatrixType U(N * (L + 1), S);
+  for (Index col_index = 0; col_index < S; ++col_index) {
+    // Arnoldi-like process to generate a set of orthogonal vectors spanning
+    // {u,A*u,A*A*u,...,A^(S-1)*u}. This construction can be combined with the
+    // Full Orthogonalization Method (FOM) from Ref.3 to provide a possible
+    // early exit with no additional MV.
+    if (col_index != 0) {
+      /*
+      Modified Gram-Schmidt strategy:
+      */
+      VectorType w = mat * precond.solve(u.col(0));
+      for (Index i = 0; i < col_index; ++i) {
+        auto v = U.col(i).head(N);
+        h_FOM(i, col_index - 1) = v.dot(w);
+        w -= h_FOM(i, col_index - 1) * v;
+      }
+      u.col(0) = w;
+      h_FOM(col_index, col_index - 1) = u.col(0).stableNorm();
+
+      if (abs(h_FOM(col_index, col_index - 1)) != RealScalar(0)) {
+        /*
+        This only happens if u is NOT exactly zero. In case it is exactly zero
+        it would imply that that this u has no component in the direction of the
+        current residual.
+
+        By then setting u to zero it will not contribute any further (as it
+        should). Whereas attempting to normalize results in division by zero.
+
+        Such cases occur if:
+        1. The basis of dimension <S is sufficient to exactly solve the linear
+        system. I.e. the current residual is in span{r,Ar,...A^{m-1}r}, where
+        (m-1)<=S.
+        2. Two vectors generated from r, Ar,... are (numerically)
+        parallel.
+
+        In case 1, the exact solution to the system can be obtained from the
+        "Full Orthogonalization Method" (Algorithm 6.4 in the book of Saad),
+        without any additional MV.
+
+        Contrary to what one would suspect, the comparison with ==0.0 for
+        floating-point types is intended here. Any arbitrary non-zero u is fine
+        to continue, however if u contains either NaN or Inf the algorithm will
+        break down.
+        */
+        u.col(0) /= h_FOM(col_index, col_index - 1);
+      }
+    } else {
+      u.col(0) = r.col(0);
+      u.col(0).normalize();
+    }
+
+    U.col(col_index).head(N) = u.col(0);
+  }
+
+  if (S > 1) {
+    // Check for early FOM exit.
+    Scalar beta = r.col(0).stableNorm();
+    VectorType e1 = VectorType::Zero(S - 1);
+    e1(0) = beta;
+    lu_solver.compute(h_FOM.topLeftCorner(S - 1, S - 1));
+    VectorType y = lu_solver.solve(e1);
+    VectorType x2 = x + U.topLeftCorner(N, S - 1) * y;
+
+    // Using proposition 6.7 in Saad, one MV can be saved to calculate the
+    // residual
+    RealScalar FOM_residual = (h_FOM(S - 1, S - 2) * y(S - 2) * U.col(S - 1).head(N)).stableNorm();
+
+    if (FOM_residual < tol) {
+      // Exit, the FOM algorithm was already accurate enough
+      iters = k;
+      // Convert back to the unpreconditioned solution
+      x = precond.solve(x2);
+      // x contains the updates to x0, add those back to obtain the solution
+      x += x0;
+      tol_error = FOM_residual / rhs_norm;
+      return true;
+    }
+  }
+
+  /*
+    Select an initial (N x S) matrix R0.
+    1. Generate random R0, orthonormalize the result.
+    2. This results in R0, however to save memory and compute we only need the
+    adjoint of R0. This is given by the matrix R_T. Additionally, the matrix
+    (mat.adjoint()*R_tilde).adjoint()=R_tilde.adjoint()*mat by the
+    anti-distributivity property of the adjoint. This results in AR_T, which is
+    constant if R_T does not have to be regenerated and can be precomputed.
+    Based on reference 4, this has zero probability in exact arithmetic.
+  */
+
+  // Original IDRSTABL and Kensuke choose S random vectors:
+  DenseMatrixType R_T = internal::random_orthonormal_basis<DenseMatrixType>(N, S).adjoint();
+  DenseMatrixType AR_T = DenseMatrixType(R_T * mat);
+
+  // Pre-allocate sigma.
+  DenseMatrixType sigma(S, S);
+
+  bool reset_while = false;  // Should the while loop be reset?
+
+  while (k < maxIters) {
+    for (Index j = 1; j <= L; ++j) {
+      /*
+        The IDR Step
+      */
+      // Construction of the sigma-matrix, and the decomposition of sigma.
+      for (Index i = 0; i < S; ++i) {
+        sigma.col(i).noalias() = AR_T * precond.solve(U.block(N * (j - 1), i, N, 1));
+      }
+
+      lu_solver.compute(sigma);
+      // Obtain the update coefficients alpha
+      if (j == 1) {
+        // alpha=inverse(sigma)*(R_T*r_0);
+        alpha = lu_solver.solve(R_T * r.col(0));
+      } else {
+        // alpha=inverse(sigma)*(AR_T*r_{j-2})
+        alpha = lu_solver.solve(AR_T * precond.solve(r.col(j - 2)));
+      }
+
+      // Obtain new solution and residual from this update
+      update.noalias() = U.topRows(N) * alpha;
+      r.col(0).noalias() -= mat * precond.solve(update);
+      x += update;
+
+      for (Index i = 1; i <= j - 2; ++i) {
+        // This only affects the case L>2
+        r.col(i).noalias() -= U.block(N * (i + 1), 0, N, S) * alpha;
+      }
+      if (j > 1) {
+        // r=[r;A*r_{j-2}]
+        r.col(j - 1).noalias() = mat * precond.solve(r.col(j - 2));
+      }
+      tol_error = r.col(0).stableNorm();
+
+      if (tol_error < tol) {
+        // If at this point the algorithm has converged, exit.
+        reset_while = true;
+        break;
+      }
+
+      bool break_normalization = false;
+      for (Index q = 1; q <= S; ++q) {
+        if (q == 1) {
+          // u = r;
+          u.leftCols(j + 1) = r.leftCols(j + 1);
+        } else {
+          // u=[u_1;u_2;...;u_j]
+          u.leftCols(j) = u.middleCols(1, j);
+        }
+
+        // Obtain the update coefficients beta implicitly
+        // beta=lu_sigma.solve(AR_T * u.block(N * (j - 1), 0, N, 1)
+        u.leftCols(j).reshaped() -= U.topRows(N * j) * lu_solver.solve(AR_T * precond.solve(u.col(j - 1)));
+
+        // u=[u;Au_{j-1}]
+        u.col(j).noalias() = mat * precond.solve(u.col(j - 1));
+
+        // Orthonormalize u_j to the columns of V_j(:,1:q-1)
+        if (q > 1) {
+          /*
+          Modified Gram-Schmidt-like procedure to make u orthogonal to the
+          columns of V from Ref. 1.
+
+          The vector mu from Ref. 1 is obtained implicitly:
+          mu=V.block(N * j, 0, N, q - 1).adjoint() * u.block(N * j, 0, N, 1).
+          */
+          for (Index i = 0; i <= q - 2; ++i) {
+            auto v = V.col(i).segment(N * j, N);
+            Scalar h = v.squaredNorm();
+            h = v.dot(u.col(j)) / h;
+            u.leftCols(j + 1).reshaped() -= h * V.col(i).head(N * (j + 1));
+          }
+        }
+        // Normalize u and assign to a column of V
+        Scalar normalization_constant = u.col(j).stableNorm();
+        //  If u is exactly zero, this will lead to a NaN. Small, non-zero u is
+        //  fine.
+        if (normalization_constant == RealScalar(0.0)) {
+          break_normalization = true;
+          break;
+        } else {
+          u.leftCols(j + 1) /= normalization_constant;
+        }
+
+        V.col(q - 1).head(N * (j + 1)) = u.leftCols(j + 1).reshaped();
+      }
+
+      if (!break_normalization) {
+        U = V;
+      }
+    }
+    if (reset_while) {
+      break;
+    }
+
+    // r=[r;mat*r_{L-1}]
+    r.col(L).noalias() = mat * precond.solve(r.col(L - 1));
+
+    /*
+            The polynomial step
+    */
+    ColPivHouseholderQR<DenseMatrixType> qr_solver(r.rightCols(L));
+    gamma = qr_solver.solve(r.col(0));
+
+    // Update solution and residual using the "minimized residual coefficients"
+    update.noalias() = r.leftCols(L) * gamma;
+    x += update;
+    r.col(0).noalias() -= mat * precond.solve(update);
+
+    // Update iteration info
+    ++k;
+    tol_error = r.col(0).stableNorm();
+
+    if (tol_error < tol) {
+      // Slightly early exit by moving the criterion before the update of U,
+      // after the main while loop the result of that calculation would not be
+      // needed.
+      break;
+    }
+
+    /*
+    U=U0-sum(gamma_j*U_j)
+    Consider the first iteration. Then U only contains U0, so at the start of
+    the while-loop U should be U0. Therefore only the first N rows of U have to
+    be updated.
+    */
+    for (Index i = 1; i <= L; ++i) {
+      U.topRows(N) -= U.block(N * i, 0, N, S) * gamma(i - 1);
+    }
+  }
+
+  /*
+          Exit after the while loop terminated.
+  */
+  iters = k;
+  // Convert back to the unpreconditioned solution
+  x = precond.solve(x);
+  // x contains the updates to x0, add those back to obtain the solution
+  x += x0;
+  tol_error = tol_error / rhs_norm;
+  return true;
+}
+
+}  // namespace internal
+
+template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar>>
+class IDRSTABL;
+
+namespace internal {
+
+template <typename MatrixType_, typename Preconditioner_>
+struct traits<IDRSTABL<MatrixType_, Preconditioner_>> {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+}  // namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+ * \brief The IDR(s)STAB(l) is a combination of IDR(s) and BiCGSTAB(l). It is a
+ * short-recurrences Krylov method for sparse square problems. It can outperform
+ * both IDR(s) and BiCGSTAB(l). IDR(s)STAB(l) generally closely follows the
+ * optimal GMRES convergence in terms of the number of Matrix-Vector products.
+ * However, without the increasing cost per iteration of GMRES. IDR(s)STAB(l) is
+ * suitable for both indefinite systems and systems with complex eigenvalues.
+ *
+ * This class allows solving for A.x = b sparse linear problems. The vectors x
+ * and b can be either dense or sparse.
+ *
+ * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a
+ * sparse matrix. \tparam Preconditioner_ the type of the preconditioner.
+ * Default is DiagonalPreconditioner
+ *
+ * \implsparsesolverconcept
+ *
+ * The maximum number of iterations and tolerance value can be controlled via
+ * the setMaxIterations() and setTolerance() methods. The defaults are the size
+ * of the problem for the maximum number of iterations and
+ * NumTraits<Scalar>::epsilon() for the tolerance.
+ *
+ * The tolerance is the maximum relative residual error: |Ax-b|/|b| for which
+ * the linear system is considered solved.
+ *
+ * \b Performance: When using sparse matrices, best performance is achieved for
+ * a row-major sparse matrix format. Moreover, in this case multi-threading can
+ * be exploited if the user code is compiled with OpenMP enabled. See \ref
+ * TopicMultiThreading for details.
+ *
+ * By default the iterations start with x=0 as an initial guess of the solution.
+ * One can control the start using the solveWithGuess() method.
+ *
+ * IDR(s)STAB(l) can also be used in a matrix-free context, see the following
+ * \link MatrixfreeSolverExample example \endlink.
+ *
+ * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+ */
+
+template <typename MatrixType_, typename Preconditioner_>
+class IDRSTABL : public IterativeSolverBase<IDRSTABL<MatrixType_, Preconditioner_>> {
+ protected:
+  using Base = IterativeSolverBase<IDRSTABL>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::matrix;
+  Index m_L = 2;
+  Index m_S = 4;
+
+ public:
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
+
+ public:
+  /** Default constructor. */
+  IDRSTABL() = default;
+
+  /**   Initialize the solver with matrix \a A for further \c Ax=b solving.
+
+  This constructor is a shortcut for the default constructor followed
+  by a call to compute().
+
+  \warning this class stores a reference to the matrix A as well as some
+  precomputed values that depend on it. Therefore, if \a A is changed
+  this class becomes invalid. Call compute() to update it with the new
+  matrix A, or modify a copy of A.
+          */
+  template <typename MatrixDerived>
+  explicit IDRSTABL(const EigenBase<MatrixDerived> &A) : Base(A.derived()) {}
+
+  /** \internal */
+  /**     Loops over the number of columns of b and does the following:
+                                  1. sets the tolerance and maxIterations
+                                  2. Calls the function that has the core solver
+     routine
+  */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs &b, Dest &x) const {
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+    bool ret = internal::idrstabl(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_L, m_S);
+
+    m_info = (!ret) ? NumericalIssue : m_error <= 10 * Base::m_tolerance ? Success : NoConvergence;
+  }
+
+  /** Sets the parameter L, indicating the amount of minimize residual steps are
+   * used. */
+  void setL(Index L) {
+    eigen_assert(L >= 1 && "L needs to be positive");
+    m_L = L;
+  }
+  /** Sets the parameter S, indicating the dimension of the shadow residual
+   * space. */
+  void setS(Index S) {
+    eigen_assert(S >= 1 && "S needs to be positive");
+    m_S = S;
+  }
+};
+
+}  // namespace Eigen
+
+#endif /* EIGEN_IDRSTABL_H */
diff --git a/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h b/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
index a426381..dbd9c11 100644
--- a/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
+++ b/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INCOMPLETE_CHOlESKY_H
 #define EIGEN_INCOMPLETE_CHOlESKY_H
@@ -50,19 +51,19 @@
 template <typename Scalar, int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int> >
 class IncompleteCholesky : public SparseSolverBase<IncompleteCholesky<Scalar, UpLo_, OrderingType_> > {
  protected:
-  typedef SparseSolverBase<IncompleteCholesky<Scalar, UpLo_, OrderingType_> > Base;
+  using Base = SparseSolverBase<IncompleteCholesky<Scalar, UpLo_, OrderingType_>>;
   using Base::m_isInitialized;
 
  public:
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef OrderingType_ OrderingType;
-  typedef typename OrderingType::PermutationType PermutationType;
-  typedef typename PermutationType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> FactorType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorSx;
-  typedef Matrix<RealScalar, Dynamic, 1> VectorRx;
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorIx;
-  typedef std::vector<std::list<StorageIndex> > VectorList;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using OrderingType = OrderingType_;
+  using PermutationType = typename OrderingType::PermutationType;
+  using StorageIndex = typename PermutationType::StorageIndex;
+  using FactorType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using VectorSx = Matrix<Scalar, Dynamic, 1>;
+  using VectorRx = Matrix<RealScalar, Dynamic, 1>;
+  using VectorIx = Matrix<StorageIndex, Dynamic, 1>;
+  using VectorList = std::vector<std::list<StorageIndex>>;
   enum { UpLo = UpLo_ };
   enum { ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };
 
@@ -238,10 +239,10 @@
   Index nnz = m_L.nonZeros();
   Map<VectorSx> vals(m_L.valuePtr(), nnz);           // values
   Map<VectorIx> rowIdx(m_L.innerIndexPtr(), nnz);    // Row indices
-  Map<VectorIx> colPtr(m_L.outerIndexPtr(), n + 1);  // Pointer to the beginning of each row
+  Map<VectorIx> colPtr(m_L.outerIndexPtr(), n + 1);  // Pointer to the beginning of each column
   VectorIx firstElt(n - 1);  // for each j, points to the next entry in vals that will be used in the factorization
   VectorList listCol(n);     // listCol(j) is a linked list of columns to update column j
-  VectorSx col_vals(n);      // Store a  nonzero values in each column
+  VectorSx col_vals(n);      // Store the nonzero values in each column
   VectorIx col_irow(n);      // Row indices of nonzero elements in each column
   VectorIx col_pattern(n);
   col_pattern.fill(-1);
diff --git a/Eigen/src/IterativeLinearSolvers/IncompleteLU.h b/Eigen/src/IterativeLinearSolvers/IncompleteLU.h
new file mode 100644
index 0000000..30f9583
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/IncompleteLU.h
@@ -0,0 +1,89 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_INCOMPLETE_LU_H
+#define EIGEN_INCOMPLETE_LU_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_>
+class IncompleteLU : public SparseSolverBase<IncompleteLU<Scalar_> > {
+ protected:
+  using Base = SparseSolverBase<IncompleteLU<Scalar_>>;
+  using Base::m_isInitialized;
+
+  using Scalar = Scalar_;
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  using Index = typename Vector::Index;
+  using FactorType = SparseMatrix<Scalar, RowMajor>;
+
+ public:
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic>;
+
+  IncompleteLU() {}
+
+  template <typename MatrixType>
+  IncompleteLU(const MatrixType& mat) {
+    compute(mat);
+  }
+
+  Index rows() const { return m_lu.rows(); }
+  Index cols() const { return m_lu.cols(); }
+
+  template <typename MatrixType>
+  IncompleteLU& compute(const MatrixType& mat) {
+    m_lu = mat;
+    Index size = mat.cols();
+    Vector diag(size);
+    for (Index i = 0; i < size; ++i) {
+      typename FactorType::InnerIterator k_it(m_lu, i);
+      for (; k_it && k_it.index() < i; ++k_it) {
+        Index k = k_it.index();
+        k_it.valueRef() /= diag(k);
+
+        typename FactorType::InnerIterator j_it(k_it);
+        typename FactorType::InnerIterator kj_it(m_lu, k);
+        while (kj_it && kj_it.index() <= k) ++kj_it;
+        for (++j_it; j_it;) {
+          if (kj_it.index() == j_it.index()) {
+            j_it.valueRef() -= k_it.value() * kj_it.value();
+            ++j_it;
+            ++kj_it;
+          } else if (kj_it.index() < j_it.index())
+            ++kj_it;
+          else
+            ++j_it;
+        }
+      }
+      if (k_it && k_it.index() == i)
+        diag(i) = k_it.value();
+      else
+        diag(i) = 1;
+    }
+    m_isInitialized = true;
+    return *this;
+  }
+
+  template <typename Rhs, typename Dest>
+  void _solve_impl(const Rhs& b, Dest& x) const {
+    x = m_lu.template triangularView<UnitLower>().solve(b);
+    x = m_lu.template triangularView<Upper>().solve(x);
+  }
+
+ protected:
+  FactorType m_lu;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_INCOMPLETE_LU_H
diff --git a/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h b/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
index 3a84e55..8325184 100644
--- a/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
+++ b/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INCOMPLETE_LUT_H
 #define EIGEN_INCOMPLETE_LUT_H
@@ -29,7 +30,7 @@
  **/
 template <typename VectorV, typename VectorI>
 Index QuickSplit(VectorV& row, VectorI& ind, Index ncut) {
-  typedef typename VectorV::RealScalar RealScalar;
+  using RealScalar = typename VectorV::RealScalar;
   using std::abs;
   using std::swap;
   Index mid;
@@ -101,16 +102,16 @@
 template <typename Scalar_, typename StorageIndex_ = int>
 class IncompleteLUT : public SparseSolverBase<IncompleteLUT<Scalar_, StorageIndex_> > {
  protected:
-  typedef SparseSolverBase<IncompleteLUT> Base;
+  using Base = SparseSolverBase<IncompleteLUT>;
   using Base::m_isInitialized;
 
  public:
-  typedef Scalar_ Scalar;
-  typedef StorageIndex_ StorageIndex;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Matrix<Scalar, Dynamic, 1> Vector;
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
-  typedef SparseMatrix<Scalar, RowMajor, StorageIndex> FactorType;
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
+  using FactorType = SparseMatrix<Scalar, RowMajor, StorageIndex>;
 
   enum { ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };
 
@@ -142,7 +143,11 @@
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears to be negative.
+   *          \c NumericalIssue if a zero pivot was encountered during
+   *          factorization (the resulting preconditioner is unlikely to be
+   *          usable; the input matrix typically has zero diagonal entries
+   *          that cannot be moved by a static row permutation, e.g. it is
+   *          structurally singular).
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "IncompleteLUT is not initialized.");
@@ -157,7 +162,11 @@
 
   /**
    * Compute an incomplete LU factorization with dual threshold on the matrix mat
-   * No pivoting is done in this version
+   * No partial pivoting is done in this version. A static row permutation
+   * (maximum bipartite matching) is computed in \c analyzePattern so that
+   * the permuted matrix has a structurally nonzero diagonal whenever one
+   * exists; without it, the lack of pivoting makes ILUT silently produce
+   * a useless preconditioner on matrices with zero diagonal entries.
    *
    **/
   template <typename MatrixType>
@@ -172,7 +181,7 @@
 
   template <typename Rhs, typename Dest>
   void _solve_impl(const Rhs& b, Dest& x) const {
-    x = m_Pinv * b;
+    x = m_PinvPr * b;
     x = m_lu.template triangularView<UnitLower>().solve(x);
     x = m_lu.template triangularView<Upper>().solve(x);
     x = m_P * x;
@@ -184,6 +193,9 @@
     inline bool operator()(const Index& row, const Index& col, const Scalar&) const { return row != col; }
   };
 
+  template <typename MatrixType>
+  Index computeRowMatching(const MatrixType& amat);
+
  protected:
   FactorType m_lu;
   RealScalar m_droptol;
@@ -191,8 +203,10 @@
   bool m_analysisIsOk;
   bool m_factorizationIsOk;
   ComputationInfo m_info;
-  PermutationMatrix<Dynamic, Dynamic, StorageIndex> m_P;     // Fill-reducing permutation
-  PermutationMatrix<Dynamic, Dynamic, StorageIndex> m_Pinv;  // Inverse permutation
+  PermutationMatrix<Dynamic, Dynamic, StorageIndex> m_P;       // Fill-reducing permutation
+  PermutationMatrix<Dynamic, Dynamic, StorageIndex> m_Pinv;    // Inverse permutation
+  PermutationMatrix<Dynamic, Dynamic, StorageIndex> m_Pr;      // Static row permutation (matching-based)
+  PermutationMatrix<Dynamic, Dynamic, StorageIndex> m_PinvPr;  // Cached composition m_Pinv * m_Pr for solve
 };
 
 /**
@@ -226,7 +240,7 @@
 
 /**
  * get U-Factor
- * \return L-Factor is a matrix containing the upper triangular part of the sparse matrix. All elements of the matrix
+ * \return U-Factor is a matrix containing the upper triangular part of the sparse matrix. All elements of the matrix
  * below the main diagonal are zero.
  **/
 template <typename Scalar, typename StorageIndex>
@@ -235,21 +249,177 @@
   return m_lu.template triangularView<Upper>();
 }
 
+// Compute a row permutation m_Pr such that (m_Pr * amat) has a structurally
+// nonzero diagonal wherever one exists. Returns the number of matched columns.
+// Uses a maximum bipartite cardinality matching on the sparsity pattern, with
+// a greedy initialization that prefers the natural diagonal so that matrices
+// already having a nonzero diagonal yield the identity permutation.
+template <typename Scalar, typename StorageIndex>
+template <typename MatrixType_>
+Index IncompleteLUT<Scalar, StorageIndex>::computeRowMatching(const MatrixType_& amat) {
+  using internal::convert_index;
+  const Index n = amat.rows();
+  // We only need amat's column-major sparsity pattern; never read scalar
+  // values. The pattern view aliases amat's index storage when amat is
+  // already a column-major SparseMatrix, and otherwise materializes a CSC
+  // pattern into the scratch buffers.
+  Matrix<StorageIndex, Dynamic, 1> outer_buf;
+  Matrix<StorageIndex, Dynamic, 1> inner_buf;
+  internal::SparsityPatternRef<StorageIndex> pat = internal::make_col_major_pattern_ref(amat, outer_buf, inner_buf);
+  const StorageIndex* outer = pat.outer;
+  const StorageIndex* inner = pat.inner;
+
+  const StorageIndex kUnmatched = StorageIndex(-1);
+  // match_row[j] = original row matched to column j; match_col[i] = column matched to row i.
+  std::vector<StorageIndex> match_row(n, kUnmatched);
+  std::vector<StorageIndex> match_col(n, kUnmatched);
+
+  // The matching uses the stored sparsity pattern only and is independent of
+  // numerical values. This preserves the analyzePattern/factorize contract:
+  // the same analysis is reusable for any matrix sharing this stored pattern.
+  // Phase 1: greedy diagonal preference.
+  for (Index j = 0; j < n; ++j) {
+    const Index col_end = outer[j] + pat.nonZeros(j);
+    for (Index k = outer[j]; k < col_end; ++k) {
+      if (Index(inner[k]) == j) {
+        match_row[j] = convert_index<StorageIndex>(j);
+        match_col[j] = convert_index<StorageIndex>(j);
+        break;
+      }
+    }
+  }
+  // Phase 2: greedy off-diagonal pickup of any free row.
+  for (Index j = 0; j < n; ++j) {
+    if (match_row[j] != kUnmatched) continue;
+    const Index col_end = outer[j] + pat.nonZeros(j);
+    for (Index k = outer[j]; k < col_end; ++k) {
+      Index i = inner[k];
+      if (match_col[i] == kUnmatched) {
+        match_row[j] = convert_index<StorageIndex>(i);
+        match_col[i] = convert_index<StorageIndex>(j);
+        break;
+      }
+    }
+  }
+  // Phase 3: augmenting paths for any column still unmatched.
+  std::vector<StorageIndex> visited(n, kUnmatched);
+  // Iterative DFS: the stack frames are (column, edge index, chosen row).
+  // chosen_row[k] is the row that frame k will commit to if a path is found.
+  std::vector<Index> stack_col;
+  std::vector<Index> stack_pos;
+  std::vector<Index> stack_chosen_row;
+  stack_col.reserve(n);
+  stack_pos.reserve(n);
+  stack_chosen_row.reserve(n);
+
+  for (Index start = 0; start < n; ++start) {
+    if (match_row[start] != kUnmatched) continue;
+    StorageIndex epoch = convert_index<StorageIndex>(start);
+    stack_col.clear();
+    stack_pos.clear();
+    stack_chosen_row.clear();
+    stack_col.push_back(start);
+    stack_pos.push_back(outer[start]);
+    stack_chosen_row.push_back(-1);
+
+    while (!stack_col.empty()) {
+      Index j = stack_col.back();
+      Index pos = stack_pos.back();
+      Index col_end = outer[j] + pat.nonZeros(j);
+      bool advanced = false;
+
+      while (pos < col_end) {
+        Index i = inner[pos];
+        ++pos;
+        if (visited[i] == epoch) continue;
+        visited[i] = epoch;
+
+        if (match_col[i] == kUnmatched) {
+          // Found an augmenting path: commit it.
+          stack_chosen_row.back() = i;
+          stack_pos.back() = pos;
+          for (size_t k = 0; k < stack_col.size(); ++k) {
+            Index col = stack_col[k];
+            Index row = stack_chosen_row[k];
+            match_row[col] = convert_index<StorageIndex>(row);
+            match_col[row] = convert_index<StorageIndex>(col);
+          }
+          stack_col.clear();
+          break;
+        } else {
+          // Descend into the column currently matched to row i.
+          stack_chosen_row.back() = i;
+          stack_pos.back() = pos;
+          Index next_col = match_col[i];
+          stack_col.push_back(next_col);
+          stack_pos.push_back(outer[next_col]);
+          stack_chosen_row.push_back(-1);
+          advanced = true;
+          break;
+        }
+      }
+
+      if (!advanced && !stack_col.empty()) {
+        stack_col.pop_back();
+        stack_pos.pop_back();
+        stack_chosen_row.pop_back();
+      }
+    }
+  }
+
+  // Build the row permutation. Matched columns get their matching row;
+  // any leftover columns are filled in identity-fashion with the leftover rows.
+  m_Pr.resize(n);
+  std::vector<bool> col_used(n, false), row_used(n, false);
+  Index matched = 0;
+  for (Index j = 0; j < n; ++j) {
+    if (match_row[j] != kUnmatched) {
+      m_Pr.indices()(match_row[j]) = convert_index<StorageIndex>(j);
+      col_used[j] = true;
+      row_used[match_row[j]] = true;
+      ++matched;
+    }
+  }
+  Index next_col = 0;
+  for (Index i = 0; i < n; ++i) {
+    if (row_used[i]) continue;
+    while (next_col < n && col_used[next_col]) ++next_col;
+    m_Pr.indices()(i) = convert_index<StorageIndex>(next_col);
+    ++next_col;
+  }
+  return matched;
+}
+
 template <typename Scalar, typename StorageIndex>
 template <typename MatrixType_>
 void IncompleteLUT<Scalar, StorageIndex>::analyzePattern(const MatrixType_& amat) {
-  // Compute the Fill-reducing permutation
-  // Since ILUT does not perform any numerical pivoting,
-  // it is highly preferable to keep the diagonal through symmetric permutations.
-  // To this end, let's symmetrize the pattern and perform AMD on it.
-  SparseMatrix<Scalar, ColMajor, StorageIndex> mat1 = amat;
-  SparseMatrix<Scalar, ColMajor, StorageIndex> mat2 = amat.transpose();
-  // FIXME: for a nearly symmetric pattern, mat2+mat1 is appropriate;
-  //        for a highly non-symmetric pattern, mat2*mat1 should be preferred.
-  SparseMatrix<Scalar, ColMajor, StorageIndex> AtA = mat2 + mat1;
+  eigen_assert((amat.rows() == amat.cols()) && "The factorization should be done on a square matrix");
+  // 1. Compute a static row permutation that makes the diagonal structurally
+  //    nonzero. This is a workaround for the lack of partial pivoting in ILUT.
+  //    For matrices that already have a nonzero diagonal, this returns the
+  //    identity permutation and is essentially free.
+  computeRowMatching(amat);
+
+  // 2. Compute the Fill-reducing permutation on the row-permuted matrix.
+  // Since ILUT does not perform any numerical pivoting, it is highly
+  // preferable to keep the diagonal through symmetric permutations. AMD
+  // computes a fill-reducing ordering for a symmetric matrix and only reads
+  // the sparsity pattern; build a value-free, row-permuted representation
+  // (1-byte placeholder Scalar, indices remapped through m_Pr) and feed that
+  // to AMDOrdering, avoiding the previous mat1/mat2/AtA value copies.
+  SparseMatrix<signed char, ColMajor, StorageIndex> permuted_pattern;
+  {
+    Matrix<StorageIndex, Dynamic, 1> outer_buf;
+    Matrix<StorageIndex, Dynamic, 1> inner_buf;
+    internal::SparsityPatternRef<StorageIndex> pat = internal::make_col_major_pattern_ref(amat, outer_buf, inner_buf);
+    internal::materialize_col_major_pattern(pat, m_Pr.indices().data(), permuted_pattern);
+  }
   AMDOrdering<StorageIndex> ordering;
-  ordering(AtA, m_P);
+  ordering(permuted_pattern, m_P);
   m_Pinv = m_P.inverse();  // cache the inverse permutation
+  // Cache the composition m_Pinv * m_Pr so _solve_impl applies a single
+  // permutation to the RHS instead of two.
+  m_PinvPr = m_Pinv * m_Pr;
   m_analysisIsOk = true;
   m_factorizationIsOk = false;
   m_isInitialized = true;
@@ -271,10 +441,13 @@
   VectorI ju(n);  // column position of the values in u -- maximum size  is n
   VectorI jr(n);  // Indicate the position of the nonzero elements in the vector u -- A zero location is indicated by -1
 
-  // Apply the fill-reducing permutation
+  // Apply the static row permutation (from analyzePattern), then the
+  // fill-reducing symmetric permutation.
   eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
+  SparseMatrix<Scalar, RowMajor, StorageIndex> row_permuted_mat = m_Pr * amat;
   SparseMatrix<Scalar, RowMajor, StorageIndex> mat;
-  mat = amat.twistedBy(m_Pinv);
+  mat = row_permuted_mat.twistedBy(m_Pinv);
+  Index zero_pivots = 0;
 
   // Initialization
   jr.fill(-1);
@@ -415,7 +588,10 @@
 
     // store the diagonal element
     // apply a shifting rule to avoid zero pivots (we are doing an incomplete factorization)
-    if (u(ii) == Scalar(0)) u(ii) = sqrt(m_droptol) * rownorm;
+    if (u(ii) == Scalar(0)) {
+      u(ii) = sqrt(m_droptol) * rownorm;
+      ++zero_pivots;
+    }
     m_lu.insertBackByOuterInnerUnordered(ii, ii) = u(ii);
 
     // sort the U-part of the row
@@ -441,7 +617,11 @@
   m_lu.makeCompressed();
 
   m_factorizationIsOk = true;
-  m_info = Success;
+  // If we had to shift any zero pivot, the factorization is not faithful to
+  // the input matrix and the resulting preconditioner may be useless.
+  // Report this to the caller via NumericalIssue rather than silently
+  // returning Success.
+  m_info = (zero_pivots == 0) ? Success : NumericalIssue;
 }
 
 }  // end namespace Eigen
diff --git a/Eigen/src/IterativeLinearSolvers/InternalHeaderCheck.h b/Eigen/src/IterativeLinearSolvers/InternalHeaderCheck.h
index b657e84..7b879d3 100644
--- a/Eigen/src/IterativeLinearSolvers/InternalHeaderCheck.h
+++ b/Eigen/src/IterativeLinearSolvers/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
 #error "Please include Eigen/IterativeLinearSolvers instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h b/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
index 5caa396..d14c71a 100644
--- a/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
+++ b/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ITERATIVE_SOLVER_BASE_H
 #define EIGEN_ITERATIVE_SOLVER_BASE_H
@@ -17,37 +18,29 @@
 
 namespace internal {
 
-template <typename MatrixType>
-struct is_ref_compatible_impl {
- private:
-  template <typename T0>
-  struct any_conversion {
-    template <typename T>
-    any_conversion(const volatile T&);
-    template <typename T>
-    any_conversion(T&);
-  };
-  struct yes {
-    int a[1];
-  };
-  struct no {
-    int a[2];
-  };
-
-  template <typename T>
-  static yes test(const Ref<const T>&, int);
-  template <typename T>
-  static no test(any_conversion<T>, ...);
-
- public:
-  static MatrixType ms_from;
-  enum { value = sizeof(test<MatrixType>(ms_from, 0)) == sizeof(yes) };
-};
+template <typename T>
+auto is_ref_compatible_test(T& matrix) -> decltype(Ref<const T>(matrix), std::true_type());
+std::false_type is_ref_compatible_test(...);
 
 template <typename MatrixType>
-struct is_ref_compatible {
-  enum { value = is_ref_compatible_impl<remove_all_t<MatrixType>>::value };
-};
+using is_ref_compatible = decltype(is_ref_compatible_test(std::declval<remove_all_t<MatrixType>&>()));
+
+// Returns a \a rows x \a cols matrix whose columns are an orthonormal basis of a random subspace,
+// obtained by QR-orthonormalizing a random matrix. The IDR(s)-type solvers use this to build the
+// shadow space; the basis only has to be (almost surely) non-degenerate, so any random seed is fine.
+template <typename MatrixType>
+MatrixType random_orthonormal_basis(Index rows, Index cols) {
+  HouseholderQR<MatrixType> qr(MatrixType::Random(rows, cols));
+  return qr.householderQ() * MatrixType::Identity(rows, cols);
+}
+
+template <typename RealScalar>
+EIGEN_DEVICE_FUNC RealScalar iterative_solver_scaling_factor(RealScalar norm) {
+  // Scale only when forming a quadratic recurrence term from norm may underflow or overflow.
+  const RealScalar sqrtMin = numext::sqrt((std::numeric_limits<RealScalar>::min)());
+  const RealScalar sqrtMax = numext::sqrt((std::numeric_limits<RealScalar>::max)());
+  return norm < sqrtMin || norm > sqrtMax ? norm : RealScalar(1);
+}
 
 template <typename MatrixType, bool MatrixFree = !internal::is_ref_compatible<MatrixType>::value>
 class generic_matrix_wrapper;
@@ -56,15 +49,16 @@
 template <typename MatrixType>
 class generic_matrix_wrapper<MatrixType, false> {
  public:
-  typedef Ref<const MatrixType> ActualMatrixType;
+  using ActualMatrixType = Ref<const MatrixType>;
   template <int UpLo>
   struct ConstSelfAdjointViewReturnType {
-    typedef typename ActualMatrixType::template ConstSelfAdjointViewReturnType<UpLo>::Type Type;
+    using Type = typename ActualMatrixType::template ConstSelfAdjointViewReturnType<UpLo>::Type;
   };
 
   enum { MatrixFree = false };
 
-  generic_matrix_wrapper() : m_dummy(0, 0), m_matrix(m_dummy) {}
+  // Default-construct: passing (0,0) trips the size assertion for fixed-size MatrixType (#1704).
+  generic_matrix_wrapper() : m_dummy(), m_matrix(m_dummy) {}
 
   template <typename InputType>
   generic_matrix_wrapper(const InputType& mat) : m_matrix(mat) {}
@@ -93,15 +87,15 @@
 template <typename MatrixType>
 class generic_matrix_wrapper<MatrixType, true> {
  public:
-  typedef MatrixType ActualMatrixType;
+  using ActualMatrixType = MatrixType;
   template <int UpLo>
   struct ConstSelfAdjointViewReturnType {
-    typedef ActualMatrixType Type;
+    using Type = ActualMatrixType;
   };
 
   enum { MatrixFree = true };
 
-  generic_matrix_wrapper() : mp_matrix(0) {}
+  generic_matrix_wrapper() = default;
 
   generic_matrix_wrapper(const MatrixType& mat) : mp_matrix(&mat) {}
 
@@ -110,7 +104,7 @@
   void grab(const MatrixType& mat) { mp_matrix = &mat; }
 
  protected:
-  const ActualMatrixType* mp_matrix;
+  const ActualMatrixType* mp_matrix = nullptr;
 };
 
 }  // namespace internal
@@ -123,15 +117,15 @@
 template <typename Derived>
 class IterativeSolverBase : public SparseSolverBase<Derived> {
  protected:
-  typedef SparseSolverBase<Derived> Base;
+  using Base = SparseSolverBase<Derived>;
   using Base::m_isInitialized;
 
  public:
-  typedef typename internal::traits<Derived>::MatrixType MatrixType;
-  typedef typename internal::traits<Derived>::Preconditioner Preconditioner;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef typename MatrixType::RealScalar RealScalar;
+  using MatrixType = typename internal::traits<Derived>::MatrixType;
+  using Preconditioner = typename internal::traits<Derived>::Preconditioner;
+  using Scalar = typename MatrixType::Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using RealScalar = typename MatrixType::RealScalar;
 
   enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };
 
@@ -159,8 +153,6 @@
 
   IterativeSolverBase(IterativeSolverBase&&) = default;
 
-  ~IterativeSolverBase() {}
-
   /** Initializes the iterative solver for the sparsity pattern of the matrix \a A for further solving \c Ax=b problems.
    *
    * Currently, this function mostly calls analyzePattern on the preconditioner. In the future
@@ -230,7 +222,9 @@
 
   /** Sets the tolerance threshold used by the stopping criteria.
    *
-   * This value is used as an upper bound to the relative residual error: |Ax-b|/|b|.
+   * This value is used as an upper bound to the relative residual error: |Ax-b|/|b|, or to the measure the solver
+   * documents instead; LeastSquaresConjugateGradient bounds the normal-equation residual |A'(Ax-b)|/|A'b|, and
+   * LSMR bounds |A'(Ax-b)|/(|A| |Ax-b|).
    * The default value is the machine precision given by NumTraits<Scalar>::epsilon()
    */
   Derived& setTolerance(const RealScalar& tolerance) {
@@ -265,7 +259,9 @@
   }
 
   /** \returns the tolerance error reached during the last solve.
-   * It is a close approximation of the true relative residual error |Ax-b|/|b|.
+   * It is a close approximation of the true relative residual error |Ax-b|/|b|, unless the solver documents a
+   * different measure: LeastSquaresConjugateGradient reports the normal-equation residual |A'(Ax-b)|/|A'b|, and
+   * LSMR reports the normal-equation residual estimate |A'(Ax-b)|/(|A| |Ax-b|).
    */
   RealScalar error() const {
     eigen_assert(m_isInitialized && "IterativeSolverBase is not initialized.");
@@ -298,7 +294,7 @@
     Index rhsCols = b.cols();
     Index size = b.rows();
     DestDerived& dest(aDest.derived());
-    typedef typename DestDerived::Scalar DestScalar;
+    using DestScalar = typename DestDerived::Scalar;
     Eigen::Matrix<DestScalar, Dynamic, 1> tb(size);
     Eigen::Matrix<DestScalar, Dynamic, 1> tx(cols());
     // We do not directly fill dest because sparse expressions have to be free of aliasing issue.
@@ -336,7 +332,7 @@
       typename Rhs::ConstColXpr bk(b, k);
       derived()._solve_vector_with_guess_impl(bk, xk);
 
-      // The call to _solve_vector_with_guess updates m_info, so if it failed for a previous column
+      // The call to _solve_vector_with_guess_impl updates m_info, so if it failed for a previous column
       // we need to restore it to the worst value.
       if (m_info == NumericalIssue)
         global_info = NumericalIssue;
@@ -368,8 +364,8 @@
     m_tolerance = NumTraits<Scalar>::epsilon();
   }
 
-  typedef internal::generic_matrix_wrapper<MatrixType> MatrixWrapper;
-  typedef typename MatrixWrapper::ActualMatrixType ActualMatrixType;
+  using MatrixWrapper = internal::generic_matrix_wrapper<MatrixType>;
+  using ActualMatrixType = typename MatrixWrapper::ActualMatrixType;
 
   const ActualMatrixType& matrix() const { return m_matrixWrapper.matrix(); }
 
diff --git a/Eigen/src/IterativeLinearSolvers/LSMR.h b/Eigen/src/IterativeLinearSolvers/LSMR.h
new file mode 100644
index 0000000..114837d
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/LSMR.h
@@ -0,0 +1,464 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_LSMR_H
+#define EIGEN_LSMR_H
+
+// LSMR is an iterative algorithm for least-squares problems  min ||A x - b||,
+// based on the Golub-Kahan bidiagonalization process.  It is analytically
+// equivalent to applying MINRES to the normal equation  A^T A x = A^T b, so the
+// quantity ||A^T r_k|| decreases monotonically (where r_k = b - A x_k).  In
+// practice ||r_k|| also decreases monotonically, which makes LSMR safer than
+// LSQR to stop early.  With a damping parameter lambda > 0 it instead minimizes
+// || (A; lambda I) x - (b; 0) ||, i.e. it solves the regularized (Tikhonov)
+// least-squares problem.
+//
+// This implementation follows the published algorithm:
+//
+//   D. C.-L. Fong and M. A. Saunders, "LSMR: An Iterative Algorithm for Sparse
+//   Least-Squares Problems", SIAM J. Sci. Comput. 33(5):2950-2971, 2011.
+//   https://web.stanford.edu/group/SOL/software/lsmr/
+//
+// The scalar recurrences, the cheap estimates of ||r||, ||A^T r||, ||A|| and
+// cond(A), and the stopping rules reproduce the reference Fortran 90
+// implementation by the same authors (distributed under the BSD / Common Public
+// License at the URL above).  No source code from that implementation is
+// reproduced here; only the mathematical algorithm is implemented, in Eigen's
+// own idiom.
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal Low-level LSMR algorithm
+ * \param mat       The matrix A.
+ * \param rhs       The right hand side vector b.
+ * \param x         On input the initial guess x0 (usually zero), on output the
+ *                  computed solution.
+ * \param precond   A preconditioner.  It is applied as a self-adjoint right
+ *                  preconditioner: LSMR is run on the better-conditioned system
+ *                  \f$ A M^{-1} z = b \f$ (where \c precond.solve() applies
+ *                  \f$ M^{-1} \f$) and the solution is recovered as
+ *                  \f$ x = M^{-1} z \f$.  With IdentityPreconditioner this
+ *                  reduces exactly to the reference algorithm.
+ * \param iters     On input the maximum number of iterations, on output the
+ *                  number of iterations performed.
+ * \param tol_error On output, an estimate of the relative residual of the
+ *                  normal equations \f$ ||A^T r|| / (||A||\,||r||) \f$.
+ * \param atol      Stopping tolerance bounding the assumed relative error in
+ *                  the entries of \a A.
+ * \param btol      Stopping tolerance bounding the assumed relative error in
+ *                  the entries of \a b.
+ * \param lambda    The damping parameter \f$ \lambda \ge 0 \f$ (0 for an
+ *                  unregularized problem).
+ * \param conlim    An upper limit on cond(A); iterations stop if the estimate
+ *                  exceeds it.  Pass 0 to disable (equivalent to 1/eps).
+ *
+ * \returns the LSMR stopping code \c istop:
+ *   - 0: x = 0 (i.e. the supplied guess) is the exact solution; no iterations.
+ *   - 1: A x = b is compatible and ||r|| is small enough, given atol and btol.
+ *   - 2: a least-squares solution is good enough, given atol.
+ *   - 3: the estimate of cond(A) exceeded conlim.
+ *   - 4: A x = b is compatible and ||r|| is as small as machine precision allows.
+ *   - 5: a least-squares solution is as good as machine precision allows.
+ *   - 6: cond(A) seems too large for this machine.
+ *   - 7: the iteration limit was reached.
+ */
+template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE Index lsmr(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond,
+                             Index& iters, typename Dest::RealScalar& tol_error, const typename Dest::RealScalar& atol,
+                             const typename Dest::RealScalar& btol, const typename Dest::RealScalar& lambda,
+                             const typename Dest::RealScalar& conlim) {
+  using numext::abs;
+  using numext::sqrt;
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+
+  const RealScalar zero(0);
+  const RealScalar one(1);
+
+  const Index n = mat.cols();
+  const Index maxIters = iters;
+
+  // n-vectors needed before the early-return below. u is the only m-vector.
+  VectorType v(n), Atu(n);
+
+  // Set up the first vectors u and v for the bidiagonalization. These satisfy
+  // beta*u = b - A*x0  and  alpha*v = M^{-1} A^T u.
+  VectorType u = rhs - mat * x;  // working residual r0 of the initial guess
+  RealScalar alpha = zero;
+  RealScalar beta = u.stableNorm();
+  if (beta > zero) {
+    u /= beta;
+    Atu.noalias() = mat.adjoint() * u;
+    v = precond.solve(Atu);
+    alpha = v.stableNorm();
+    if (alpha > zero) v /= alpha;
+  }
+
+  iters = 0;
+  // If b - A*x0 = 0 or A^T(b - A*x0) = 0 then the current x already solves the
+  // (least-squares) problem: no correction is needed.
+  if (alpha * beta == zero) {
+    tol_error = zero;
+    return 0;  // istop = 0
+  }
+
+  // dx accumulates the correction (in z-space when a preconditioner is used).
+  // The remaining n-vectors are only needed once we start iterating.
+  VectorType dx = VectorType::Zero(n);
+  VectorType h = v;
+  VectorType hbar = VectorType::Zero(n);
+  VectorType t(n);
+
+  // Quantities driving the two plane rotations.
+  RealScalar alphabar = alpha;
+  RealScalar zetabar = alpha * beta;
+  RealScalar rho = one;
+  RealScalar rhobar = one;
+  RealScalar cbar = one;
+  RealScalar sbar = zero;
+
+  // Quantities for the running estimate of ||r||.
+  RealScalar betadd = beta;
+  RealScalar betad = zero;
+  RealScalar rhodold = one;
+  RealScalar tautildeold = zero;
+  RealScalar thetatilde = zero;
+  RealScalar zeta = zero;
+  RealScalar d = zero;
+
+  // Quantities for the running estimates of ||A|| and cond(A).
+  RealScalar normA2 = alpha * alpha;
+  RealScalar maxrbar = zero;
+  RealScalar minrbar = NumTraits<RealScalar>::highest();
+
+  const RealScalar normb = beta;
+  const RealScalar ctol = conlim > zero ? one / conlim : zero;
+  RealScalar test2 = zero;  // recomputed each iteration; also read after the loop for tol_error
+
+  Index istop = 0;
+  Index itn = 0;
+  while (istop == 0) {
+    ++itn;
+
+    // Perform the next step of the bidiagonalization to obtain the next
+    // beta, u, alpha, v.  These satisfy
+    //     beta*u = A*(M^{-1} v) - alpha*u,
+    //     alpha*v = M^{-1} A^T u - beta*v.
+    t = precond.solve(v);
+    u *= -alpha;
+    u.noalias() += mat * t;
+    beta = u.stableNorm();
+    if (beta > zero) {
+      u /= beta;
+      Atu.noalias() = mat.adjoint() * u;
+      t = precond.solve(Atu);
+      v = t - beta * v;
+      alpha = v.stableNorm();
+      if (alpha > zero) v /= alpha;
+    }
+
+    // Construct rotation Qhat_{k} that folds in the damping.
+    const RealScalar alphahat = numext::hypot(alphabar, lambda);
+    const RealScalar chat = alphabar / alphahat;
+    const RealScalar shat = lambda / alphahat;
+
+    // Use a plane rotation Q_{k} to turn B_{k} into R_{k}.
+    const RealScalar rhoold = rho;
+    rho = numext::hypot(alphahat, beta);
+    const RealScalar c = alphahat / rho;
+    const RealScalar s = beta / rho;
+    const RealScalar thetanew = s * alpha;
+    alphabar = c * alpha;
+
+    // Use a plane rotation Qbar_{k} to turn R_{k}^T into Rbar_{k}.
+    const RealScalar rhobarold = rhobar;
+    const RealScalar zetaold = zeta;
+    const RealScalar thetabar = sbar * rho;
+    const RealScalar rhotemp = cbar * rho;
+    rhobar = numext::hypot(cbar * rho, thetanew);
+    cbar = cbar * rho / rhobar;
+    sbar = thetanew / rhobar;
+    zeta = cbar * zetabar;
+    zetabar = -sbar * zetabar;
+
+    // Update h, hbar and the (correction) solution dx.
+    hbar = h - (thetabar * rho / (rhoold * rhobarold)) * hbar;
+    dx += (zeta / (rho * rhobar)) * hbar;
+    h = v - (thetanew / rho) * h;
+
+    // Estimate ||r||.  Apply rotation Qhat_{k}, then Q_{k}, then Qtilde_{k-1}.
+    const RealScalar betaacute = chat * betadd;
+    const RealScalar betacheck = -shat * betadd;
+    const RealScalar betahat = c * betaacute;
+    betadd = -s * betaacute;
+
+    const RealScalar thetatildeold = thetatilde;
+    const RealScalar rhotildeold = numext::hypot(rhodold, thetabar);
+    const RealScalar ctildeold = rhodold / rhotildeold;
+    const RealScalar stildeold = thetabar / rhotildeold;
+    thetatilde = stildeold * rhobar;
+    rhodold = ctildeold * rhobar;
+    betad = -stildeold * betad + ctildeold * betahat;
+
+    tautildeold = (zetaold - thetatildeold * tautildeold) / rhotildeold;
+    const RealScalar taud = (zeta - thetatilde * tautildeold) / rhodold;
+    d += betacheck * betacheck;
+    const RealScalar normr = sqrt(d + numext::abs2(betad - taud) + numext::abs2(betadd));
+
+    // Estimate ||A||.
+    normA2 += beta * beta;
+    const RealScalar normA = sqrt(normA2);
+    normA2 += alpha * alpha;
+
+    // Estimate cond(A).
+    maxrbar = numext::maxi(maxrbar, rhobarold);
+    if (itn > 1) minrbar = numext::mini(minrbar, rhobarold);
+    const RealScalar condA = numext::maxi(maxrbar, rhotemp) / numext::mini(minrbar, rhotemp);
+
+    // Compute the norms needed for the stopping rules.
+    const RealScalar normAr = abs(zetabar);
+    const RealScalar normx = dx.stableNorm();
+
+    const RealScalar test1 = normr / normb;
+    test2 = (normA * normr > zero) ? normAr / (normA * normr) : zero;
+    const RealScalar test3 = one / condA;
+    const RealScalar t1 = test1 / (one + normA * normx / normb);
+    const RealScalar rtol = btol + atol * normA * normx / normb;
+
+    // The "1 + test <= 1" guards trigger near machine precision and make the
+    // method behave as if atol = btol = eps and conlim = 1/eps even when the
+    // user passed 0 for any of them.  The user tolerances are tested first so a
+    // genuine convergence (istop 1/2/3) takes priority over the machine limits.
+    // (istop 4 uses t1 rather than test1, matching the reference algorithm.)
+    if (test1 <= rtol)
+      istop = 1;
+    else if (test2 <= atol)
+      istop = 2;
+    else if (test3 <= ctol)
+      istop = 3;
+    else if (one + t1 <= one)
+      istop = 4;
+    else if (one + test2 <= one)
+      istop = 5;
+    else if (one + test3 <= one)
+      istop = 6;
+    else if (itn >= maxIters)
+      istop = 7;
+  }
+
+  // Recover the solution: x <- x0 + M^{-1} dx.
+  t = precond.solve(dx);
+  x += t;
+
+  iters = itn;
+  tol_error = test2;
+  return istop;
+}
+
+}  // namespace internal
+
+template <typename MatrixType_, typename Preconditioner_ = IdentityPreconditioner>
+class LSMR;
+
+namespace internal {
+
+template <typename MatrixType_, typename Preconditioner_>
+struct traits<LSMR<MatrixType_, Preconditioner_> > {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+}  // namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+ * \brief An LSMR solver for sparse (or dense) least-squares problems
+ *
+ * This class solves for the least-squares solution of \c A \c x = \c b using the
+ * LSMR algorithm of Fong and Saunders.  LSMR is based on the Golub-Kahan
+ * bidiagonalization and is analytically equivalent to MINRES applied to the
+ * normal equation \f$ A^T A x = A^T b \f$, so the residual of the normal
+ * equation \f$ ||A^T r|| \f$ decreases monotonically.  In exact arithmetic LSMR
+ * returns the minimum-norm least-squares solution.  The matrix \c A can be
+ * non-symmetric and rectangular; \c A and the vectors \c x and \c b can be
+ * either dense or sparse.  LSMR only needs \c A through the products \f$ Av \f$
+ * and \f$ A^T u \f$, so a matrix-free operator may be used as well.
+ *
+ * Unlike LeastSquaresConjugateGradient, which forms \f$ A^T A \f$ implicitly,
+ * LSMR works on \c A directly through the bidiagonalization and is therefore
+ * more robust on ill-conditioned problems.
+ *
+ * \tparam MatrixType_ the type of the matrix A, can be a dense or a sparse matrix.
+ * \tparam Preconditioner_ the type of the preconditioner. Default is IdentityPreconditioner.
+ *
+ * \implsparsesolverconcept
+ *
+ * The maximum number of iterations and the tolerance can be controlled via the
+ * setMaxIterations() and setTolerance() methods. The defaults are twice the
+ * number of columns of the matrix for the maximum number of iterations and
+ * NumTraits<Scalar>::epsilon() for the tolerance. setTolerance() sets both of
+ * the algorithm's stopping tolerances \c atol (relative error assumed in \c A)
+ * and \c btol (relative error assumed in \c b); they can also be set
+ * independently via setToleranceA() and setToleranceB().
+ *
+ * Unlike most other iterative solvers, error() does not report the relative
+ * residual \f$ ||Ax-b||/||b|| \f$: it reports the estimate
+ * \f$ ||A^T r|| / (||A||\,||r||) \f$, with \f$ r = b - Ax \f$, of the relative
+ * residual of the normal equations, the quantity that the least-squares
+ * stopping rule bounds by \c atol.
+ *
+ * The setDamping() method enables Tikhonov regularization: with a damping
+ * \f$ \lambda > 0 \f$ the solver minimizes
+ * \f$ ||Ax-b||^2 + \lambda^2 ||x||^2 \f$, for which a unique solution always
+ * exists. The setConditionLimit() method can be used to stop the iterations as
+ * soon as the estimated condition number of \c A exceeds a given bound.
+ *
+ * This class can be used like the other iterative solvers. Here is a typical
+ * usage example:
+   \code
+   int m = 1000000, n = 10000;
+   VectorXd x(n), b(m);
+   SparseMatrix<double> A(m, n);
+   // fill A and b
+   LSMR<SparseMatrix<double> > lsmr;
+   lsmr.compute(A);
+   x = lsmr.solve(b);
+   std::cout << "#iterations:     " << lsmr.iterations() << std::endl;
+   std::cout << "estimated error: " << lsmr.error()      << std::endl;
+   // update b, and solve again
+   x = lsmr.solve(b);
+   \endcode
+ *
+ * By default the iterations start with x=0 as an initial guess of the solution.
+ * One can control the start using the solveWithGuess() method.
+ *
+ * If a non-default preconditioner is supplied it is applied as a self-adjoint
+ * right preconditioner (LSMR is run on \f$ A M^{-1} z = b \f$ and the solution
+ * recovered from \f$ M x = z \f$); it should therefore be self-adjoint, as
+ * DiagonalPreconditioner and IdentityPreconditioner are.
+ *
+ * \sa class LeastSquaresConjugateGradient, class ConjugateGradient, SparseLU, SparseQR
+ */
+template <typename MatrixType_, typename Preconditioner_>
+class LSMR : public IterativeSolverBase<LSMR<MatrixType_, Preconditioner_> > {
+ protected:
+  using Base = IterativeSolverBase<LSMR>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::matrix;
+
+ public:
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
+
+  /** Default constructor. */
+  LSMR() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+   *
+   * This constructor is a shortcut for the default constructor followed
+   * by a call to compute().
+   *
+   * \warning this class stores a reference to the matrix A as well as some
+   * precomputed values that depend on it. Therefore, if \a A is changed
+   * this class becomes invalid. Call compute() to update it with the new
+   * matrix A, or modify a copy of A.
+   */
+  template <typename MatrixDerived>
+  explicit LSMR(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  /** Sets the damping parameter \f$ \lambda \ge 0 \f$ for Tikhonov
+   * regularization. With \a lambda > 0 the solver minimizes
+   * \f$ ||Ax-b||^2 + \lambda^2 ||x||^2 \f$. The default is 0 (no damping).
+   *
+   * \note When a non-identity preconditioner \f$ M \f$ is used the damping
+   * applies in the preconditioned variable, i.e. the solver minimizes
+   * \f$ ||Ax-b||^2 + \lambda^2 ||Mx||^2 \f$. With the default
+   * IdentityPreconditioner this is exactly \f$ ||Ax-b||^2 + \lambda^2 ||x||^2 \f$.
+   */
+  LSMR& setDamping(const RealScalar& lambda) {
+    m_lambda = lambda;
+    return *this;
+  }
+
+  /** \returns the damping parameter. \sa setDamping() */
+  RealScalar damping() const { return m_lambda; }
+
+  /** Sets an upper limit on the estimated condition number of \a A. The
+   * iterations stop as soon as the estimate exceeds \a conlim. The default is
+   * 0, which disables the limit (equivalent to 1/epsilon).
+   */
+  LSMR& setConditionLimit(const RealScalar& conlim) {
+    m_conditionLimit = conlim;
+    return *this;
+  }
+
+  /** \returns the condition-number limit. \sa setConditionLimit() */
+  RealScalar conditionLimit() const { return m_conditionLimit; }
+
+  /** Sets the stopping tolerance \c atol, which bounds the relative error
+   * assumed in the entries of \a A. It drives the least-squares stopping rule
+   * \f$ ||A^T r|| \le atol\,||A||\,||r|| \f$. If left unset (the default) it
+   * falls back to tolerance(). \sa setToleranceB(), setTolerance() */
+  LSMR& setToleranceA(const RealScalar& atol) {
+    m_atol = atol;
+    return *this;
+  }
+
+  /** \returns \c atol, or tolerance() if setToleranceA() has not been called.
+   * \sa setToleranceA() */
+  RealScalar toleranceA() const { return m_atol >= RealScalar(0) ? m_atol : Base::m_tolerance; }
+
+  /** Sets the stopping tolerance \c btol, which bounds the relative error
+   * assumed in the entries of \a b. It enters the compatible-system stopping
+   * rule \f$ ||r|| \le btol\,||b|| + atol\,||A||\,||x|| \f$. If left unset (the
+   * default) it falls back to tolerance(). \sa setToleranceA(), setTolerance() */
+  LSMR& setToleranceB(const RealScalar& btol) {
+    m_btol = btol;
+    return *this;
+  }
+
+  /** \returns \c btol, or tolerance() if setToleranceB() has not been called.
+   * \sa setToleranceB() */
+  RealScalar toleranceB() const { return m_btol >= RealScalar(0) ? m_btol : Base::m_tolerance; }
+
+  /** \internal */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
+    m_iterations = Base::maxIterations();
+
+    Index istop = internal::lsmr(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, toleranceA(),
+                                 toleranceB(), m_lambda, m_conditionLimit);
+    // istop in {0,1,2,4,5}: the (least-squares) solution was found, possibly
+    // only to within machine precision (4,5). istop in {3,6,7}: stopped on the
+    // condition-number limit or the iteration limit without meeting the
+    // requested tolerance.
+    m_info = (istop == 3 || istop == 6 || istop == 7) ? NoConvergence : Success;
+  }
+
+ protected:
+  RealScalar m_lambda = RealScalar(0);
+  RealScalar m_conditionLimit = RealScalar(0);
+  // Negative means "unset": toleranceA()/toleranceB() then fall back to tolerance().
+  RealScalar m_atol = RealScalar(-1);
+  RealScalar m_btol = RealScalar(-1);
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LSMR_H
diff --git a/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h b/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
index 182f319..1e39928 100644
--- a/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
+++ b/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
 #define EIGEN_LEAST_SQUARE_CONJUGATE_GRADIENT_H
@@ -30,11 +31,10 @@
 EIGEN_DONT_INLINE void least_square_conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
                                                        const Preconditioner& precond, Index& iters,
                                                        typename Dest::RealScalar& tol_error) {
-  using std::abs;
   using std::sqrt;
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
 
   RealScalar tol = tol_error;
   Index maxIters = iters;
@@ -43,22 +43,28 @@
 
   VectorType residual = rhs - mat * x;
   VectorType normal_residual = mat.adjoint() * residual;
+  VectorType normal_rhs = mat.adjoint() * rhs;
 
-  RealScalar rhsNorm2 = (mat.adjoint() * rhs).squaredNorm();
-  if (rhsNorm2 == 0) {
+  RealScalar rhsNorm = normal_rhs.stableNorm();
+  if (rhsNorm == 0) {
     x.setZero();
     iters = 0;
     tol_error = 0;
     return;
   }
-  RealScalar threshold = tol * tol * rhsNorm2;
-  RealScalar residualNorm2 = normal_residual.squaredNorm();
-  if (residualNorm2 < threshold) {
+  RealScalar threshold = tol * rhsNorm;
+  RealScalar residualNorm = normal_residual.stableNorm();
+  if (residualNorm == 0 || residualNorm < threshold) {
     iters = 0;
-    tol_error = sqrt(residualNorm2 / rhsNorm2);
+    tol_error = residualNorm / rhsNorm;
     return;
   }
 
+  // Keep the quadratic recurrence terms representable for very small or large residuals.
+  const RealScalar residualScale = internal::iterative_solver_scaling_factor(residualNorm);
+  normal_residual /= residualScale;
+  threshold /= residualScale;
+
   VectorType p(n);
   p = precond.solve(normal_residual);  // initial search direction
 
@@ -69,12 +75,13 @@
     tmp.noalias() = mat * p;
 
     Scalar alpha = absNew / tmp.squaredNorm();             // the amount we travel on dir
-    x += alpha * p;                                        // update solution
-    residual -= alpha * tmp;                               // update residual
+    x += (residualScale * alpha) * p;                      // update solution
+    residual -= (residualScale * alpha) * tmp;             // update residual
     normal_residual.noalias() = mat.adjoint() * residual;  // update residual of the normal equation
+    normal_residual /= residualScale;
 
-    residualNorm2 = normal_residual.squaredNorm();
-    if (residualNorm2 < threshold) break;
+    residualNorm = normal_residual.stableNorm();
+    if (residualNorm < threshold) break;
 
     z = precond.solve(normal_residual);  // approximately solve for "A'A z = normal_residual"
 
@@ -84,7 +91,7 @@
     p = z + beta * p;                   // update search direction
     i++;
   }
-  tol_error = sqrt(residualNorm2 / rhsNorm2);
+  tol_error = residualNorm / (rhsNorm / residualScale);
   iters = i;
 }
 
@@ -98,8 +105,8 @@
 
 template <typename MatrixType_, typename Preconditioner_>
 struct traits<LeastSquaresConjugateGradient<MatrixType_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
 };
 
 }  // namespace internal
@@ -119,8 +126,8 @@
   * \implsparsesolverconcept
   *
   * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
-  * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
-  * and NumTraits<Scalar>::epsilon() for the tolerance.
+  * and setTolerance() methods. The defaults are twice the number of columns of the matrix for the maximal
+  * number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.
   *
   * This class can be used as the direct solver classes. Here is a typical usage example:
     \code
@@ -145,7 +152,8 @@
 template <typename MatrixType_, typename Preconditioner_>
 class LeastSquaresConjugateGradient
     : public IterativeSolverBase<LeastSquaresConjugateGradient<MatrixType_, Preconditioner_> > {
-  typedef IterativeSolverBase<LeastSquaresConjugateGradient> Base;
+ protected:
+  using Base = IterativeSolverBase<LeastSquaresConjugateGradient>;
   using Base::m_error;
   using Base::m_info;
   using Base::m_isInitialized;
@@ -153,10 +161,10 @@
   using Base::matrix;
 
  public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
 
  public:
   /** Default constructor. */
@@ -175,8 +183,6 @@
   template <typename MatrixDerived>
   explicit LeastSquaresConjugateGradient(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
 
-  ~LeastSquaresConjugateGradient() {}
-
   /** \internal */
   template <typename Rhs, typename Dest>
   void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
diff --git a/Eigen/src/IterativeLinearSolvers/MINRES.h b/Eigen/src/IterativeLinearSolvers/MINRES.h
new file mode 100644
index 0000000..da132b3
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/MINRES.h
@@ -0,0 +1,261 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Giacomo Po <gpo@ucla.edu>
+// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2018 David Hyde <dabh@stanford.edu>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MINRES_H
+#define EIGEN_MINRES_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal Low-level MINRES algorithm
+ * \param mat The matrix A
+ * \param rhs The right hand side vector b
+ * \param x On input and initial solution, on output the computed solution.
+ * \param precond A right preconditioner being able to efficiently solve for an
+ *                approximation of Ax=b (regardless of b)
+ * \param iters On input the max number of iteration, on output the number of performed iterations.
+ * \param tol_error On input the tolerance error, on output an estimation of the relative error.
+ */
+template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
+EIGEN_DONT_INLINE void minres(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond,
+                              Index& iters, typename Dest::RealScalar& tol_error) {
+  using std::sqrt;
+  using RealScalar = typename Dest::RealScalar;
+  using Scalar = typename Dest::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+
+  // Check for zero rhs
+  const RealScalar rhsNorm(rhs.stableNorm());
+  if (rhsNorm == 0) {
+    x.setZero();
+    iters = 0;
+    tol_error = 0;
+    return;
+  }
+
+  // initialize
+  const Index maxIters(iters);                      // initialize maxIters to iters
+  const Index N(mat.cols());                        // the size of the matrix
+  const RealScalar threshold(tol_error * rhsNorm);  // convergence threshold (compared to residualNorm)
+
+  // Initialize preconditioned Lanczos
+  VectorType v_old(N);                // will be initialized inside loop
+  VectorType v(VectorType::Zero(N));  // initialize v
+  VectorType v_new(rhs - mat * x);    // initialize v_new
+  RealScalar residualNorm(v_new.stableNorm());
+  if (residualNorm == 0 || residualNorm < threshold) {
+    iters = 0;
+    tol_error = residualNorm / rhsNorm;
+    return;
+  }
+
+  // Keep the quadratic Lanczos terms representable for very small or large residuals.
+  const RealScalar residualScale = internal::iterative_solver_scaling_factor(residualNorm);
+  v_new /= residualScale;
+  VectorType w(N);                         // will be initialized inside loop
+  VectorType w_new(precond.solve(v_new));  // initialize w_new
+  RealScalar beta_new2(v_new.dot(w_new));
+  eigen_assert(beta_new2 >= 0.0 && "PRECONDITIONER IS NOT POSITIVE DEFINITE");
+  RealScalar beta_new(sqrt(beta_new2));
+  const RealScalar beta_one(beta_new);
+  // Initialize other variables
+  RealScalar c(1.0);  // the cosine of the Givens rotation
+  RealScalar c_old(1.0);
+  RealScalar s(0.0);                      // the sine of the Givens rotation
+  RealScalar s_old(0.0);                  // the sine of the Givens rotation
+  VectorType p_oold(N);                   // will be initialized in loop
+  VectorType p_old(VectorType::Zero(N));  // initialize p_old=0
+  VectorType p(p_old);                    // initialize p=0
+  RealScalar eta(1.0);
+
+  iters = 0;  // reset iters
+  while (iters < maxIters) {
+    // Preconditioned Lanczos
+    /* Note that there are 4 variants on the Lanczos algorithm. These are
+     * described in Paige, C. C. (1972). Computational variants of
+     * the Lanczos method for the eigenproblem. IMA Journal of Applied
+     * Mathematics, 10(3), 373-381. The current implementation corresponds
+     * to the case A(2,7) in the paper. It also corresponds to
+     * algorithm 6.14 in Y. Saad, Iterative Methods for Sparse Linear
+     * Systems, 2003 p.173. For the preconditioned version see
+     * A. Greenbaum, Iterative Methods for Solving Linear Systems, SIAM (1987).
+     */
+    const RealScalar beta(beta_new);
+    v_old = v;          // update: at first time step, this makes v_old = 0 so value of beta doesn't matter
+    v_new /= beta_new;  // overwrite v_new for next iteration
+    w_new /= beta_new;  // overwrite w_new for next iteration
+    v = v_new;          // update
+    w = w_new;          // update
+    v_new.noalias() = mat * w - beta * v_old;  // compute v_new
+    const RealScalar alpha = v_new.dot(w);
+    v_new -= alpha * v;            // overwrite v_new
+    w_new = precond.solve(v_new);  // overwrite w_new
+    beta_new2 = v_new.dot(w_new);  // compute beta_new
+    eigen_assert(beta_new2 >= 0.0 && "PRECONDITIONER IS NOT POSITIVE DEFINITE");
+    beta_new = sqrt(beta_new2);  // compute beta_new
+
+    // Givens rotation
+    const RealScalar r2 = s * alpha + c * c_old * beta;  // s, s_old, c and c_old are still from previous iteration
+    const RealScalar r3 = s_old * beta;                  // s, s_old, c and c_old are still from previous iteration
+    const RealScalar r1_hat = c * alpha - c_old * s * beta;
+    const RealScalar r1 = numext::hypot(r1_hat, beta_new);
+    c_old = c;          // store for next iteration
+    s_old = s;          // store for next iteration
+    c = r1_hat / r1;    // new cosine
+    s = beta_new / r1;  // new sine
+
+    // Update solution
+    p_oold = p_old;
+    p_old = p;
+    p = (w - r2 * p_old - r3 * p_oold) / r1;
+    x += (residualScale * beta_one * c * eta) * p;
+
+    /* Update the estimated residual norm. Note that this is the estimated
+    residual; the real residual |Ax-b| may be slightly larger. */
+    residualNorm *= numext::abs(s);
+
+    if (residualNorm < threshold) {
+      break;
+    }
+
+    eta = -s * eta;  // update eta
+    iters++;         // increment iteration number (for output purposes)
+  }
+
+  /* Compute error. Note that this is the estimated error. The real
+   error |Ax-b|/|b| may be slightly larger */
+  tol_error = residualNorm / rhsNorm;
+}
+
+}  // namespace internal
+
+template <typename MatrixType_, int UpLo_ = Lower, typename Preconditioner_ = IdentityPreconditioner>
+class MINRES;
+
+namespace internal {
+
+template <typename MatrixType_, int UpLo_, typename Preconditioner_>
+struct traits<MINRES<MatrixType_, UpLo_, Preconditioner_> > {
+  using MatrixType = MatrixType_;
+  using Preconditioner = Preconditioner_;
+};
+
+}  // namespace internal
+
+/** \ingroup IterativeLinearSolvers_Module
+ * \brief A minimal residual solver for sparse symmetric problems
+ *
+ * This class allows to solve for A.x = b sparse linear problems using the MINRES algorithm
+ * of Paige and Saunders (1975). The sparse matrix A must be symmetric (possibly indefinite).
+ * The vectors x and b can be either dense or sparse.
+ *
+ * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
+ * \tparam UpLo_ the triangular part that will be used for the computations. It can be Lower,
+ *               Upper, or Lower|Upper in which the full matrix entries will be considered. Default is Lower.
+ * \tparam Preconditioner_ the type of the preconditioner. Default is IdentityPreconditioner
+ *
+ * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
+ * and setTolerance() methods. The defaults are twice the number of columns of the matrix for the maximal
+ * number of iterations and NumTraits<Scalar>::epsilon() for the tolerance.
+ *
+ * This class can be used as the direct solver classes. Here is a typical usage example:
+ * \code
+ * int n = 10000;
+ * VectorXd x(n), b(n);
+ * SparseMatrix<double> A(n,n);
+ * // fill A and b
+ * MINRES<SparseMatrix<double> > mr;
+ * mr.compute(A);
+ * x = mr.solve(b);
+ * std::cout << "#iterations:     " << mr.iterations() << std::endl;
+ * std::cout << "estimated error: " << mr.error()      << std::endl;
+ * // update b, and solve again
+ * x = mr.solve(b);
+ * \endcode
+ *
+ * By default the iterations start with x=0 as an initial guess of the solution.
+ * One can control the start using the solveWithGuess() method.
+ *
+ * MINRES can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
+ *
+ * \sa class ConjugateGradient, BiCGSTAB, SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
+ */
+template <typename MatrixType_, int UpLo_, typename Preconditioner_>
+class MINRES : public IterativeSolverBase<MINRES<MatrixType_, UpLo_, Preconditioner_> > {
+ protected:
+  using Base = IterativeSolverBase<MINRES>;
+  using Base::m_error;
+  using Base::m_info;
+  using Base::m_isInitialized;
+  using Base::m_iterations;
+  using Base::matrix;
+
+ public:
+  using Base::_solve_impl;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Preconditioner = Preconditioner_;
+
+  enum { UpLo = UpLo_ };
+
+ public:
+  /** Default constructor. */
+  MINRES() : Base() {}
+
+  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
+   *
+   * This constructor is a shortcut for the default constructor followed
+   * by a call to compute().
+   *
+   * \warning this class stores a reference to the matrix A as well as some
+   * precomputed values that depend on it. Therefore, if \a A is changed
+   * this class becomes invalid. Call compute() to update it with the new
+   * matrix A, or modify a copy of A.
+   */
+  template <typename MatrixDerived>
+  explicit MINRES(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
+
+  /** \internal */
+  template <typename Rhs, typename Dest>
+  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
+    using MatrixWrapper = typename Base::MatrixWrapper;
+    using ActualMatrixType = typename Base::ActualMatrixType;
+    enum {
+      TransposeInput = (!MatrixWrapper::MatrixFree) && (UpLo == (Lower | Upper)) && (!MatrixType::IsRowMajor) &&
+                       (!NumTraits<Scalar>::IsComplex)
+    };
+    using RowMajorWrapper =
+        std::conditional_t<TransposeInput, Transpose<const ActualMatrixType>, ActualMatrixType const&>;
+    EIGEN_STATIC_ASSERT(internal::check_implication(MatrixWrapper::MatrixFree, UpLo == (Lower | Upper)),
+                        MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
+    using SelfAdjointWrapper =
+        std::conditional_t<UpLo == (Lower | Upper), RowMajorWrapper,
+                           typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type>;
+
+    m_iterations = Base::maxIterations();
+    m_error = Base::m_tolerance;
+    RowMajorWrapper row_mat(matrix());
+    internal::minres(SelfAdjointWrapper(row_mat), b, x, Base::m_preconditioner, m_iterations, m_error);
+    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
+  }
+
+ protected:
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MINRES_H
diff --git a/Eigen/src/IterativeLinearSolvers/Scaling.h b/Eigen/src/IterativeLinearSolvers/Scaling.h
new file mode 100644
index 0000000..f190c9f
--- /dev/null
+++ b/Eigen/src/IterativeLinearSolvers/Scaling.h
@@ -0,0 +1,166 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire NUENTSA WAKAM <desire.nuentsa_wakam@inria.fr
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ITERSCALING_H
+#define EIGEN_ITERSCALING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/**
+ * \ingroup IterativeLinearSolvers_Module
+ * \brief iterative scaling algorithm to equilibrate rows and column norms in matrices
+ *
+ * This class can be used as a preprocessing tool to accelerate the convergence of iterative methods
+ *
+ * This feature is useful to limit the pivoting amount during LU/ILU factorization
+ * The scaling strategy as presented here preserves the symmetry of the problem
+ * NOTE It is assumed that the matrix does not have empty row or column,
+ *
+ * Example with key steps
+ * \code
+ * VectorXd x(n), b(n);
+ * SparseMatrix<double> A;
+ * // fill A and b;
+ * IterScaling<SparseMatrix<double> > scal;
+ * // Compute the left and right scaling vectors. The matrix is equilibrated at output
+ * scal.computeRef(A);
+ * // Scale the right hand side
+ * b = scal.LeftScaling().cwiseProduct(b);
+ * // Now, solve the equilibrated linear system with any available solver
+ *
+ * // Scale back the computed solution
+ * x = scal.RightScaling().cwiseProduct(x);
+ * \endcode
+ *
+ * \tparam MatrixType_ the type of the matrix. It should be a real square sparsematrix
+ *
+ * References : D. Ruiz and B. Ucar, A Symmetry Preserving Algorithm for Matrix Scaling, INRIA Research report RR-7552
+ *
+ * \sa \ref IncompleteLUT
+ */
+template <typename MatrixType_>
+class IterScaling {
+ public:
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+  using Index = typename MatrixType::Index;
+
+  IterScaling() { init(); }
+
+  IterScaling(const MatrixType& matrix) {
+    init();
+    compute(matrix);
+  }
+
+  /**
+   * Compute the left and right diagonal matrices to scale the input matrix @p mat
+   *
+   * FIXME: This algorithm will be modified such that the diagonal elements are permuted on the diagonal.
+   *
+   * \sa LeftScaling() RightScaling()
+   */
+  void compute(const MatrixType& mat) {
+    using std::abs;
+    int m = mat.rows();
+    int n = mat.cols();
+    eigen_assert((m > 0 && m == n) && "Please give a non - empty matrix");
+    m_left.resize(m);
+    m_right.resize(n);
+    m_left.setOnes();
+    m_right.setOnes();
+    m_matrix = mat;
+    // Temporary left and right scaling vectors
+    VectorXd Dr(m), Dc(n), DrRes(m), DcRes(n);
+    double EpsRow = 1.0, EpsCol = 1.0;
+    int its = 0;
+    do {  // Iterate until the infinite norm of each row and column is approximately 1
+      // Get the maximum value in each row and column
+      Dr.setZero();
+      Dc.setZero();
+      for (int k = 0; k < m_matrix.outerSize(); ++k) {
+        for (typename MatrixType::InnerIterator it(m_matrix, k); it; ++it) {
+          if (Dr(it.row()) < abs(it.value())) Dr(it.row()) = abs(it.value());
+
+          if (Dc(it.col()) < abs(it.value())) Dc(it.col()) = abs(it.value());
+        }
+      }
+      for (int i = 0; i < m; ++i) {
+        Dr(i) = numext::sqrt(Dr(i));
+      }
+      for (int i = 0; i < n; ++i) {
+        Dc(i) = numext::sqrt(Dc(i));
+      }
+      // Save the scaling factors
+      for (int i = 0; i < m; ++i) {
+        m_left(i) /= Dr(i);
+      }
+      for (int i = 0; i < n; ++i) {
+        m_right(i) /= Dc(i);
+      }
+      // Scale the rows and the columns of the matrix
+      DrRes.setZero();
+      DcRes.setZero();
+      for (int k = 0; k < m_matrix.outerSize(); ++k) {
+        for (typename MatrixType::InnerIterator it(m_matrix, k); it; ++it) {
+          it.valueRef() = it.value() / (Dr(it.row()) * Dc(it.col()));
+          // Accumulate the norms of the row and column vectors
+          if (DrRes(it.row()) < abs(it.value())) DrRes(it.row()) = abs(it.value());
+
+          if (DcRes(it.col()) < abs(it.value())) DcRes(it.col()) = abs(it.value());
+        }
+      }
+      DrRes.array() = (1 - DrRes.array()).abs();
+      EpsRow = DrRes.maxCoeff();
+      DcRes.array() = (1 - DcRes.array()).abs();
+      EpsCol = DcRes.maxCoeff();
+      its++;
+    } while ((EpsRow > m_tol || EpsCol > m_tol) && (its < m_maxits));
+    m_isInitialized = true;
+  }
+  /** Compute the left and right vectors to scale the vectors
+   * the input matrix is scaled with the computed vectors at output
+   *
+   * \sa compute()
+   */
+  void computeRef(MatrixType& mat) {
+    compute(mat);
+    mat = m_matrix;
+  }
+  /** Get the vector to scale the rows of the matrix
+   */
+  VectorXd& LeftScaling() { return m_left; }
+
+  /** Get the vector to scale the columns of the matrix
+   */
+  VectorXd& RightScaling() { return m_right; }
+
+  /** Set the tolerance for the convergence of the iterative scaling algorithm
+   */
+  void setTolerance(double tol) { m_tol = tol; }
+
+ protected:
+  void init() {
+    m_tol = 1e-10;
+    m_maxits = 5;
+    m_isInitialized = false;
+  }
+
+  MatrixType m_matrix;
+  bool m_isInitialized;
+  VectorXd m_left;   // Left scaling vector
+  VectorXd m_right;  // Right scaling vector
+  double m_tol;
+  int m_maxits;  // Maximum number of iterations allowed
+};
+}  // namespace Eigen
+#endif
diff --git a/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h b/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
index 271679f..2f4e811 100644
--- a/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
+++ b/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SOLVEWITHGUESS_H
 #define EIGEN_SOLVEWITHGUESS_H
@@ -24,7 +25,8 @@
  * \brief Pseudo expression representing a solving operation
  *
  * \tparam Decomposition the type of the matrix or decomposition object
- * \tparam Rhstype the type of the right-hand side
+ * \tparam RhsType the type of the right-hand side
+ * \tparam GuessType the type of the initial guess
  *
  * This class represents an expression of A.solve(B)
  * and most of the time this is the only way it is used.
@@ -41,11 +43,11 @@
 class SolveWithGuess : public internal::generic_xpr_base<SolveWithGuess<Decomposition, RhsType, GuessType>, MatrixXpr,
                                                          typename internal::traits<RhsType>::StorageKind>::type {
  public:
-  typedef typename internal::traits<SolveWithGuess>::Scalar Scalar;
-  typedef typename internal::traits<SolveWithGuess>::PlainObject PlainObject;
-  typedef typename internal::generic_xpr_base<SolveWithGuess<Decomposition, RhsType, GuessType>, MatrixXpr,
-                                              typename internal::traits<RhsType>::StorageKind>::type Base;
-  typedef typename internal::ref_selector<SolveWithGuess>::type Nested;
+  using Scalar = typename internal::traits<SolveWithGuess>::Scalar;
+  using PlainObject = typename internal::traits<SolveWithGuess>::PlainObject;
+  using Base = typename internal::generic_xpr_base<SolveWithGuess<Decomposition, RhsType, GuessType>, MatrixXpr,
+                                                   typename internal::traits<RhsType>::StorageKind>::type;
+  using Nested = typename internal::ref_selector<SolveWithGuess>::type;
 
   SolveWithGuess(const Decomposition &dec, const RhsType &rhs, const GuessType &guess)
       : m_dec(dec), m_rhs(rhs), m_guess(guess) {}
@@ -73,9 +75,9 @@
 template <typename Decomposition, typename RhsType, typename GuessType>
 struct evaluator<SolveWithGuess<Decomposition, RhsType, GuessType> >
     : public evaluator<typename SolveWithGuess<Decomposition, RhsType, GuessType>::PlainObject> {
-  typedef SolveWithGuess<Decomposition, RhsType, GuessType> SolveType;
-  typedef typename SolveType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using SolveType = SolveWithGuess<Decomposition, RhsType, GuessType>;
+  using PlainObject = typename SolveType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   evaluator(const SolveType &solve) : m_result(solve.rows(), solve.cols()) {
     internal::construct_at<Base>(this, m_result);
@@ -93,14 +95,14 @@
 template <typename DstXprType, typename DecType, typename RhsType, typename GuessType, typename Scalar>
 struct Assignment<DstXprType, SolveWithGuess<DecType, RhsType, GuessType>, internal::assign_op<Scalar, Scalar>,
                   Dense2Dense> {
-  typedef SolveWithGuess<DecType, RhsType, GuessType> SrcXprType;
+  using SrcXprType = SolveWithGuess<DecType, RhsType, GuessType>;
   static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar, Scalar> &) {
     Index dstRows = src.rows();
     Index dstCols = src.cols();
     if ((dst.rows() != dstRows) || (dst.cols() != dstCols)) dst.resize(dstRows, dstCols);
 
     dst = src.guess();
-    src.dec()._solve_with_guess_impl(src.rhs(), dst /*, src.guess()*/);
+    src.dec()._solve_with_guess_impl(src.rhs(), dst);
   }
 };
 
diff --git a/Eigen/src/Jacobi/InternalHeaderCheck.h b/Eigen/src/Jacobi/InternalHeaderCheck.h
index b17b1f2..c5c4636 100644
--- a/Eigen/src/Jacobi/InternalHeaderCheck.h
+++ b/Eigen/src/Jacobi/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_JACOBI_MODULE_H
 #error "Please include Eigen/Jacobi instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/Jacobi/Jacobi.h b/Eigen/src/Jacobi/Jacobi.h
index f24a851..8f90003 100644
--- a/Eigen/src/Jacobi/Jacobi.h
+++ b/Eigen/src/Jacobi/Jacobi.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_JACOBI_H
 #define EIGEN_JACOBI_H
@@ -37,7 +38,7 @@
 template <typename Scalar>
 class JacobiRotation {
  public:
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   /** Default constructor without any initialization. */
   EIGEN_DEVICE_FUNC JacobiRotation() {}
@@ -50,7 +51,7 @@
   EIGEN_DEVICE_FUNC Scalar& s() { return m_s; }
   EIGEN_DEVICE_FUNC Scalar s() const { return m_s; }
 
-  /** Concatenates two planar rotation */
+  /** Concatenates two planar rotations */
   EIGEN_DEVICE_FUNC JacobiRotation operator*(const JacobiRotation& other) {
     using numext::conj;
     return JacobiRotation(m_c * other.m_c - conj(m_s) * other.m_s,
@@ -76,8 +77,9 @@
   EIGEN_DEVICE_FUNC void makeGivens(const Scalar& p, const Scalar& q, Scalar* r = 0);
 
  protected:
-  EIGEN_DEVICE_FUNC void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::true_type);
-  EIGEN_DEVICE_FUNC void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type);
+  EIGEN_DEVICE_FUNC void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, std::true_type);
+  EIGEN_DEVICE_FUNC void makeGivens(const Scalar& p, const Scalar& q, Scalar* r, std::false_type);
+  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void makeGivensScaled(const Scalar& p, const Scalar& q, Scalar* r);
 
   Scalar m_c, m_s;
 };
@@ -94,24 +96,41 @@
   using std::abs;
   using std::sqrt;
 
-  RealScalar deno = RealScalar(2) * abs(y);
+  const RealScalar abs_y = abs(y);
+  const RealScalar deno = RealScalar(2) * abs_y;
   if (deno < (std::numeric_limits<RealScalar>::min)()) {
     m_c = Scalar(1);
     m_s = Scalar(0);
     return false;
   } else {
-    RealScalar tau = (x - z) / deno;
-    RealScalar w = sqrt(numext::abs2(tau) + RealScalar(1));
-    RealScalar t;
-    if (tau > RealScalar(0)) {
-      t = RealScalar(1) / (tau + w);
+    const RealScalar delta = x - z;
+    const RealScalar abs_delta = abs(delta);
+    // |t| = 1 / (|tau| + sqrt(1 + tau^2)), where tau = (x - z) / (2 * |y|).
+    // Scale this numerator/denominator pair by min(1, 1/|tau|), taking scale = 1 at tau = 0.
+    // Then numerator <= 1 and denominator <= 1 + sqrt(2); only a ratio <= 1 is squared.
+    // Normalize the pair directly to save the division forming |t|.
+    RealScalar numerator;
+    RealScalar denominator;
+    if (abs_delta > deno) {
+      const RealScalar ratio = deno / abs_delta;
+      numerator = ratio;
+      denominator = sqrt(RealScalar(1) + numext::abs2(ratio)) + RealScalar(1);
     } else {
-      t = RealScalar(1) / (tau - w);
+      const RealScalar ratio = abs_delta / deno;
+      numerator = RealScalar(1);
+      denominator = sqrt(RealScalar(1) + numext::abs2(ratio)) + ratio;
     }
-    RealScalar sign_t = t > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
-    RealScalar n = RealScalar(1) / sqrt(numext::abs2(t) + RealScalar(1));
-    m_s = -sign_t * (numext::conj(y) / abs(y)) * abs(t) * n;
-    m_c = n;
+    const RealScalar n = RealScalar(1) / sqrt(numext::abs2(numerator) + numext::abs2(denominator));
+    const RealScalar sine = numerator * n;
+    const RealScalar sign_t = delta > RealScalar(0) ? RealScalar(1) : RealScalar(-1);
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+      m_s = -sign_t * (numext::conj(y) / abs_y) * sine;
+    } else {
+      // For real y, conj(y) / abs(y) is just its sign.
+      const RealScalar signed_sine = -sign_t * sine;
+      m_s = numext::real(y) < RealScalar(0) ? -signed_sine : signed_sine;
+    }
+    m_c = denominator * n;
     return true;
   }
 }
@@ -150,13 +169,12 @@
  */
 template <typename Scalar>
 EIGEN_DEVICE_FUNC void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r) {
-  makeGivens(p, q, r, std::conditional_t<NumTraits<Scalar>::IsComplex, internal::true_type, internal::false_type>());
+  makeGivens(p, q, r, internal::bool_constant<NumTraits<Scalar>::IsComplex>());
 }
 
 // specialization for complexes
 template <typename Scalar>
-EIGEN_DEVICE_FUNC void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r,
-                                                          internal::true_type) {
+EIGEN_DEVICE_FUNC void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, std::true_type) {
   using numext::conj;
   using std::abs;
   using std::sqrt;
@@ -205,31 +223,101 @@
 // specialization for reals
 template <typename Scalar>
 EIGEN_DEVICE_FUNC void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r,
-                                                          internal::false_type) {
+                                                          std::false_type) {
   using std::abs;
   using std::sqrt;
-  if (numext::is_exactly_zero(q)) {
+  if (numext::is_exactly_zero_no_flush(q)) {
+    // DAZ can hide the sign; MSVC's non-intrinsic abs(float) can flush the
+    // result through a float->double->float conversion even with FTZ alone.
+    if (abs(p) < (std::numeric_limits<Scalar>::min)() && !numext::is_exactly_zero_no_flush(p)) {
+      makeGivensScaled(p, q, r);
+      return;
+    }
     m_c = p < Scalar(0) ? Scalar(-1) : Scalar(1);
     m_s = Scalar(0);
     if (r) *r = abs(p);
-  } else if (numext::is_exactly_zero(p)) {
+    return;
+  }
+  if (numext::is_exactly_zero_no_flush(p)) {
+    if (abs(q) < (std::numeric_limits<Scalar>::min)()) {
+      makeGivensScaled(p, q, r);
+      return;
+    }
     m_c = Scalar(0);
     m_s = q < Scalar(0) ? Scalar(1) : Scalar(-1);
     if (r) *r = abs(q);
-  } else if (abs(p) > abs(q)) {
-    Scalar t = q / p;
-    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
-    if (p < Scalar(0)) u = -u;
+    return;
+  }
+
+  // Safe-range thresholds following Anderson, "Algorithm 978: Safe Scaling
+  // in the Level 1 BLAS", ACM TOMS 44(1), 2017.  When both |p| and |q| lie
+  // in (rtmin, rtmax), the direct formula r = p * sqrt(1 + (q/p)^2) cannot
+  // over- or underflow before the true result would.  Outside that range
+  // we prescale with safe_scaling (normal powers of two for supported binary
+  // scalars), preserving significant float/double subnormal inputs under FTZ/DAZ. This preserves the
+  // existing Eigen sign convention (r >= 0, sign carried in c).
+  const Scalar safmin = (std::numeric_limits<Scalar>::min)();
+  const Scalar safmax = Scalar(1) / safmin;
+  const Scalar rtmin = sqrt(safmin);
+  const Scalar rtmax = sqrt(safmax / Scalar(2));
+  const Scalar abs_p = abs(p);
+  const Scalar abs_q = abs(q);
+  const Scalar mx = numext::maxi(abs_p, abs_q);
+  const Scalar mn = numext::mini(abs_p, abs_q);
+
+  if (EIGEN_PREDICT_TRUE(mx < rtmax && mn > rtmin)) {
+    // Safe range: existing direct formulas are stable.
+    if (abs_p > abs_q) {
+      Scalar t = q / p;
+      Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+      if (p < Scalar(0)) u = -u;
+      m_c = Scalar(1) / u;
+      m_s = -t * m_c;
+      if (r) *r = p * u;
+    } else {
+      Scalar t = p / q;
+      Scalar u = sqrt(Scalar(1) + numext::abs2(t));
+      if (q < Scalar(0)) u = -u;
+      m_s = -Scalar(1) / u;
+      m_c = -t * m_s;
+      if (r) *r = q * u;
+    }
+  } else {
+    makeGivensScaled(p, q, r);
+  }
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void JacobiRotation<Scalar>::makeGivensScaled(const Scalar& p, const Scalar& q,
+                                                                                  Scalar* r) {
+  using Scaling = internal::safe_scaling<Scalar>;
+  Matrix<Scalar, 2, 1> scaled;
+  scaled << p, q;
+  const Scalar maximum = Scaling::recover_flushed_max_coeff(scaled, scaled.cwiseAbs().maxCoeff());
+  const auto factors = Scaling::scale_to(scaled, scaled, maximum);
+  const Scalar ps = scaled.x(), qs = scaled.y();
+  Scalar norm;
+  if (numext::abs(ps) > numext::abs(qs)) {
+    const Scalar t = qs / ps;
+    Scalar u = numext::sqrt<Scalar>(Scalar(1) + numext::abs2(t));
+    if (ps < Scalar(0)) u = -u;
     m_c = Scalar(1) / u;
     m_s = -t * m_c;
-    if (r) *r = p * u;
+    if (r) norm = ps * u;
   } else {
-    Scalar t = p / q;
-    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
-    if (q < Scalar(0)) u = -u;
+    const Scalar t = ps / qs;
+    Scalar u = numext::sqrt<Scalar>(Scalar(1) + numext::abs2(t));
+    if (qs < Scalar(0)) u = -u;
     m_s = -Scalar(1) / u;
     m_c = -t * m_s;
-    if (r) *r = q * u;
+    if (r) norm = qs * u;
+  }
+  if (r) {
+    // Restore subnormal r through the same FTZ/DAZ-safe path as the inputs.
+    Matrix<Scalar, 1, 1> result;
+    result[0] = norm;
+    Scaling::unscale_in_place(result, maximum, factors);
+    *r = result[0];
   }
 }
 
@@ -300,78 +388,82 @@
 template <typename Scalar, typename OtherScalar, int SizeAtCompileTime, int MinAlignment>
 struct apply_rotation_in_the_plane_selector<Scalar, OtherScalar, SizeAtCompileTime, MinAlignment,
                                             true /* vectorizable */> {
-  static inline void run(Scalar* x, Index incrx, Scalar* y, Index incry, Index size, OtherScalar c, OtherScalar s) {
-    typedef typename packet_traits<Scalar>::type Packet;
-    typedef typename packet_traits<OtherScalar>::type OtherPacket;
+  EIGEN_DEVICE_FUNC static void run(Scalar* x, Index incrx, Scalar* y, Index incry, Index size, OtherScalar c,
+                                    OtherScalar s) {
+    using Packet = typename packet_traits<Scalar>::type;
+    using OtherPacket = typename packet_traits<OtherScalar>::type;
 
     constexpr int RequiredAlignment =
         (std::max<int>)(unpacket_traits<Packet>::alignment, unpacket_traits<OtherPacket>::alignment);
     constexpr Index PacketSize = packet_traits<Scalar>::size;
 
-    /*** dynamic-size vectorized paths ***/
-    if (size >= 2 * PacketSize && SizeAtCompileTime == Dynamic && ((incrx == 1 && incry == 1) || PacketSize == 1)) {
-      // both vectors are sequentially stored in memory => vectorization
-      constexpr Index Peeling = 2;
+    EIGEN_IF_CONSTEXPR (SizeAtCompileTime == Dynamic) {
+      /*** dynamic-size vectorized paths ***/
+      if (size >= 2 * PacketSize && ((incrx == 1 && incry == 1) || PacketSize == 1)) {
+        // both vectors are sequentially stored in memory => vectorization
+        constexpr Index Peeling = 2;
 
-      Index alignedStart = internal::first_default_aligned(y, size);
-      Index alignedEnd = alignedStart + ((size - alignedStart) / PacketSize) * PacketSize;
+        Index alignedStart = internal::first_default_aligned(y, size);
+        Index alignedEnd = alignedStart + ((size - alignedStart) / PacketSize) * PacketSize;
 
-      const OtherPacket pc = pset1<OtherPacket>(c);
-      const OtherPacket ps = pset1<OtherPacket>(s);
-      conj_helper<OtherPacket, Packet, NumTraits<OtherScalar>::IsComplex, false> pcj;
-      conj_helper<OtherPacket, Packet, false, false> pm;
+        const OtherPacket pc = pset1<OtherPacket>(c);
+        const OtherPacket ps = pset1<OtherPacket>(s);
+        conj_helper<OtherPacket, Packet, NumTraits<OtherScalar>::IsComplex, false> pcj;
+        conj_helper<OtherPacket, Packet, false, false> pm;
 
-      for (Index i = 0; i < alignedStart; ++i) {
-        Scalar xi = x[i];
-        Scalar yi = y[i];
-        x[i] = c * xi + numext::conj(s) * yi;
-        y[i] = -s * xi + numext::conj(c) * yi;
-      }
-
-      Scalar* EIGEN_RESTRICT px = x + alignedStart;
-      Scalar* EIGEN_RESTRICT py = y + alignedStart;
-
-      if (internal::first_default_aligned(x, size) == alignedStart) {
-        for (Index i = alignedStart; i < alignedEnd; i += PacketSize) {
-          Packet xi = pload<Packet>(px);
-          Packet yi = pload<Packet>(py);
-          pstore(px, pm.pmadd(pc, xi, pcj.pmul(ps, yi)));
-          pstore(py, pcj.pmsub(pc, yi, pm.pmul(ps, xi)));
-          px += PacketSize;
-          py += PacketSize;
+        for (Index i = 0; i < alignedStart; ++i) {
+          Scalar xi = x[i];
+          Scalar yi = y[i];
+          x[i] = c * xi + numext::conj(s) * yi;
+          y[i] = -s * xi + numext::conj(c) * yi;
         }
-      } else {
-        Index peelingEnd = alignedStart + ((size - alignedStart) / (Peeling * PacketSize)) * (Peeling * PacketSize);
-        for (Index i = alignedStart; i < peelingEnd; i += Peeling * PacketSize) {
-          Packet xi = ploadu<Packet>(px);
-          Packet xi1 = ploadu<Packet>(px + PacketSize);
-          Packet yi = pload<Packet>(py);
-          Packet yi1 = pload<Packet>(py + PacketSize);
-          pstoreu(px, pm.pmadd(pc, xi, pcj.pmul(ps, yi)));
-          pstoreu(px + PacketSize, pm.pmadd(pc, xi1, pcj.pmul(ps, yi1)));
-          pstore(py, pcj.pmsub(pc, yi, pm.pmul(ps, xi)));
-          pstore(py + PacketSize, pcj.pmsub(pc, yi1, pm.pmul(ps, xi1)));
-          px += Peeling * PacketSize;
-          py += Peeling * PacketSize;
-        }
-        if (alignedEnd != peelingEnd) {
-          Packet xi = ploadu<Packet>(x + peelingEnd);
-          Packet yi = pload<Packet>(y + peelingEnd);
-          pstoreu(x + peelingEnd, pm.pmadd(pc, xi, pcj.pmul(ps, yi)));
-          pstore(y + peelingEnd, pcj.pmsub(pc, yi, pm.pmul(ps, xi)));
-        }
-      }
 
-      for (Index i = alignedEnd; i < size; ++i) {
-        Scalar xi = x[i];
-        Scalar yi = y[i];
-        x[i] = c * xi + numext::conj(s) * yi;
-        y[i] = -s * xi + numext::conj(c) * yi;
+        Scalar* EIGEN_RESTRICT px = x + alignedStart;
+        Scalar* EIGEN_RESTRICT py = y + alignedStart;
+
+        if (internal::first_default_aligned(x, size) == alignedStart) {
+          for (Index i = alignedStart; i < alignedEnd; i += PacketSize) {
+            Packet xi = pload<Packet>(px);
+            Packet yi = pload<Packet>(py);
+            pstore(px, pm.pmadd(pc, xi, pcj.pmul(ps, yi)));
+            pstore(py, pcj.pmsub(pc, yi, pm.pmul(ps, xi)));
+            px += PacketSize;
+            py += PacketSize;
+          }
+        } else {
+          Index peelingEnd = alignedStart + ((size - alignedStart) / (Peeling * PacketSize)) * (Peeling * PacketSize);
+          for (Index i = alignedStart; i < peelingEnd; i += Peeling * PacketSize) {
+            Packet xi = ploadu<Packet>(px);
+            Packet xi1 = ploadu<Packet>(px + PacketSize);
+            Packet yi = pload<Packet>(py);
+            Packet yi1 = pload<Packet>(py + PacketSize);
+            pstoreu(px, pm.pmadd(pc, xi, pcj.pmul(ps, yi)));
+            pstoreu(px + PacketSize, pm.pmadd(pc, xi1, pcj.pmul(ps, yi1)));
+            pstore(py, pcj.pmsub(pc, yi, pm.pmul(ps, xi)));
+            pstore(py + PacketSize, pcj.pmsub(pc, yi1, pm.pmul(ps, xi1)));
+            px += Peeling * PacketSize;
+            py += Peeling * PacketSize;
+          }
+          if (alignedEnd != peelingEnd) {
+            Packet xi = ploadu<Packet>(x + peelingEnd);
+            Packet yi = pload<Packet>(y + peelingEnd);
+            pstoreu(x + peelingEnd, pm.pmadd(pc, xi, pcj.pmul(ps, yi)));
+            pstore(y + peelingEnd, pcj.pmsub(pc, yi, pm.pmul(ps, xi)));
+          }
+        }
+
+        for (Index i = alignedEnd; i < size; ++i) {
+          Scalar xi = x[i];
+          Scalar yi = y[i];
+          x[i] = c * xi + numext::conj(s) * yi;
+          y[i] = -s * xi + numext::conj(c) * yi;
+        }
+        return;
       }
     }
 
-    /*** fixed-size vectorized path ***/
-    else if (SizeAtCompileTime != Dynamic && MinAlignment >= RequiredAlignment) {
+    EIGEN_IF_CONSTEXPR (SizeAtCompileTime != Dynamic && MinAlignment >= RequiredAlignment) {
+      /*** fixed-size vectorized path ***/
       const OtherPacket pc = pset1<OtherPacket>(c);
       const OtherPacket ps = pset1<OtherPacket>(s);
       conj_helper<OtherPacket, Packet, NumTraits<OtherScalar>::IsComplex, false> pcj;
@@ -386,20 +478,19 @@
         px += PacketSize;
         py += PacketSize;
       }
+      return;
     }
 
     /*** non-vectorized path ***/
-    else {
-      apply_rotation_in_the_plane_selector<Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, false>::run(
-          x, incrx, y, incry, size, c, s);
-    }
+    apply_rotation_in_the_plane_selector<Scalar, OtherScalar, SizeAtCompileTime, MinAlignment, false>::run(
+        x, incrx, y, incry, size, c, s);
   }
 };
 
 template <typename VectorX, typename VectorY, typename OtherScalar>
 EIGEN_DEVICE_FUNC void inline apply_rotation_in_the_plane(DenseBase<VectorX>& xpr_x, DenseBase<VectorY>& xpr_y,
                                                           const JacobiRotation<OtherScalar>& j) {
-  typedef typename VectorX::Scalar Scalar;
+  using Scalar = typename VectorX::Scalar;
   constexpr bool Vectorizable = (int(evaluator<VectorX>::Flags) & int(evaluator<VectorY>::Flags) & PacketAccessBit) &&
                                 (int(packet_traits<Scalar>::size) == int(packet_traits<OtherScalar>::size));
 
diff --git a/Eigen/src/KLUSupport/InternalHeaderCheck.h b/Eigen/src/KLUSupport/InternalHeaderCheck.h
index eb1d671..5c6a260 100644
--- a/Eigen/src/KLUSupport/InternalHeaderCheck.h
+++ b/Eigen/src/KLUSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_KLUSUPPORT_MODULE_H
 #error "Please include Eigen/KLUSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/KLUSupport/KLUSupport.h b/Eigen/src/KLUSupport/KLUSupport.h
index f07ad8d..e731c81 100644
--- a/Eigen/src/KLUSupport/KLUSupport.h
+++ b/Eigen/src/KLUSupport/KLUSupport.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_KLUSUPPORT_H
 #define EIGEN_KLUSUPPORT_H
@@ -106,7 +107,7 @@
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears to be negative.
+   *          \c NumericalIssue if the matrix appears to be negative.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
diff --git a/Eigen/src/LAPACKESupport/InternalHeaderCheck.h b/Eigen/src/LAPACKESupport/InternalHeaderCheck.h
new file mode 100644
index 0000000..875d2ec
--- /dev/null
+++ b/Eigen/src/LAPACKESupport/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_CORE_MODULE_H
+#error "Please include Eigen/Core instead of including headers inside the src directory directly."
+#endif
diff --git a/Eigen/src/LAPACKESupport/lapacke.h b/Eigen/src/LAPACKESupport/lapacke.h
new file mode 100644
index 0000000..ec17d9e
--- /dev/null
+++ b/Eigen/src/LAPACKESupport/lapacke.h
@@ -0,0 +1,220 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK (subset used by Eigen)
+* Author: Intel Corporation
+* Generated November, 2011
+* Modified: stripped to the subset of declarations actually used by Eigen.
+*****************************************************************************/
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef _MKL_LAPACKE_H_
+
+#ifndef _LAPACKE_H_
+#define _LAPACKE_H_
+
+#ifdef HAVE_LAPACK_CONFIG_H
+#include "lapacke_config.h"
+#endif
+
+#include <stdlib.h>
+
+#ifndef lapack_int
+#ifdef LAPACK_ILP64
+#define lapack_int int64_t
+#else
+#define lapack_int int
+#endif
+#endif
+
+#ifndef lapack_logical
+#define lapack_logical lapack_int
+#endif
+
+#ifndef LAPACK_COMPLEX_CUSTOM
+
+#ifndef lapack_complex_float
+#define lapack_complex_float std::complex<float>
+#endif
+
+#ifndef lapack_complex_float_real
+#define lapack_complex_float_real(z) (creal(z))
+#endif
+
+#ifndef lapack_complex_float_imag
+#define lapack_complex_float_imag(z) (cimag(z))
+#endif
+
+lapack_complex_float lapack_make_complex_float(float re, float im);
+
+#ifndef lapack_complex_double
+#define lapack_complex_double std::complex<double>
+#endif
+
+#ifndef lapack_complex_double_real
+#define lapack_complex_double_real(z) (creal(z))
+#endif
+
+#ifndef lapack_complex_double_imag
+#define lapack_complex_double_imag(z) (cimag(z))
+#endif
+
+lapack_complex_double lapack_make_complex_double(double re, double im);
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef LAPACKE_malloc
+#define LAPACKE_malloc(size) malloc(size)
+#endif
+#ifndef LAPACKE_free
+#define LAPACKE_free(p) free(p)
+#endif
+
+#define LAPACK_C2INT(x) (lapack_int)(*((float*)&x))
+#define LAPACK_Z2INT(x) (lapack_int)(*((double*)&x))
+
+#define LAPACK_ROW_MAJOR 101
+#define LAPACK_COL_MAJOR 102
+
+#define LAPACK_WORK_MEMORY_ERROR -1010
+#define LAPACK_TRANSPOSE_MEMORY_ERROR -1011
+
+/* Callback logical functions used to select eigenvalues for Schur form. */
+
+typedef lapack_logical (*LAPACK_S_SELECT2)(const float*, const float*);
+typedef lapack_logical (*LAPACK_S_SELECT3)(const float*, const float*, const float*);
+typedef lapack_logical (*LAPACK_D_SELECT2)(const double*, const double*);
+typedef lapack_logical (*LAPACK_D_SELECT3)(const double*, const double*, const double*);
+
+typedef lapack_logical (*LAPACK_C_SELECT1)(const lapack_complex_float*);
+typedef lapack_logical (*LAPACK_C_SELECT2)(const lapack_complex_float*, const lapack_complex_float*);
+typedef lapack_logical (*LAPACK_Z_SELECT1)(const lapack_complex_double*);
+typedef lapack_logical (*LAPACK_Z_SELECT2)(const lapack_complex_double*, const lapack_complex_double*);
+
+#include "lapacke_mangling.h"
+
+#define LAPACK_lsame LAPACK_GLOBAL(lsame, LSAME)
+lapack_logical LAPACK_lsame(char* ca, char* cb, lapack_int lca, lapack_int lcb);
+
+/*
+ * LAPACKE function prototypes used by Eigen.
+ *
+ * Only the subset of LAPACKE routines that Eigen actually calls is declared
+ * here.  If you need the full LAPACKE API, include your system's <lapacke.h>
+ * after including Eigen headers, or define EIGEN_LAPACKE_SYSTEM before
+ * including Eigen to use the system header instead of this bundled subset.
+ */
+
+/* Schur decomposition (gees) — used by RealSchur_LAPACKE.h, ComplexSchur_LAPACKE.h */
+lapack_int LAPACKE_sgees(int matrix_order, char jobvs, char sort, LAPACK_S_SELECT2 select, lapack_int n, float* a,
+                         lapack_int lda, lapack_int* sdim, float* wr, float* wi, float* vs, lapack_int ldvs);
+lapack_int LAPACKE_dgees(int matrix_order, char jobvs, char sort, LAPACK_D_SELECT2 select, lapack_int n, double* a,
+                         lapack_int lda, lapack_int* sdim, double* wr, double* wi, double* vs, lapack_int ldvs);
+lapack_int LAPACKE_cgees(int matrix_order, char jobvs, char sort, LAPACK_C_SELECT1 select, lapack_int n,
+                         lapack_complex_float* a, lapack_int lda, lapack_int* sdim, lapack_complex_float* w,
+                         lapack_complex_float* vs, lapack_int ldvs);
+lapack_int LAPACKE_zgees(int matrix_order, char jobvs, char sort, LAPACK_Z_SELECT1 select, lapack_int n,
+                         lapack_complex_double* a, lapack_int lda, lapack_int* sdim, lapack_complex_double* w,
+                         lapack_complex_double* vs, lapack_int ldvs);
+
+/* QR with column pivoting (geqp3) — used by ColPivHouseholderQR_LAPACKE.h */
+lapack_int LAPACKE_sgeqp3(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* jpvt,
+                          float* tau);
+lapack_int LAPACKE_dgeqp3(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, lapack_int* jpvt,
+                          double* tau);
+lapack_int LAPACKE_cgeqp3(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_int* jpvt, lapack_complex_float* tau);
+lapack_int LAPACKE_zgeqp3(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
+                          lapack_int* jpvt, lapack_complex_double* tau);
+
+/* QR factorization (geqrf) — used by HouseholderQR_LAPACKE.h */
+lapack_int LAPACKE_sgeqrf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
+lapack_int LAPACKE_dgeqrf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
+lapack_int LAPACKE_cgeqrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_complex_float* tau);
+lapack_int LAPACKE_zgeqrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
+                          lapack_complex_double* tau);
+
+/* SVD via divide-and-conquer (gesdd) — used by BDCSVD_LAPACKE.h */
+lapack_int LAPACKE_sgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, float* a, lapack_int lda, float* s,
+                          float* u, lapack_int ldu, float* vt, lapack_int ldvt);
+lapack_int LAPACKE_dgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, double* a, lapack_int lda, double* s,
+                          double* u, lapack_int ldu, double* vt, lapack_int ldvt);
+lapack_int LAPACKE_cgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, lapack_complex_float* a,
+                          lapack_int lda, float* s, lapack_complex_float* u, lapack_int ldu, lapack_complex_float* vt,
+                          lapack_int ldvt);
+lapack_int LAPACKE_zgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, double* s, lapack_complex_double* u, lapack_int ldu,
+                          lapack_complex_double* vt, lapack_int ldvt);
+
+/* SVD (gesvd) — used by JacobiSVD_LAPACKE.h */
+lapack_int LAPACKE_sgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, float* a, lapack_int lda,
+                          float* s, float* u, lapack_int ldu, float* vt, lapack_int ldvt, float* superb);
+lapack_int LAPACKE_dgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, double* a,
+                          lapack_int lda, double* s, double* u, lapack_int ldu, double* vt, lapack_int ldvt,
+                          double* superb);
+lapack_int LAPACKE_cgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, lapack_complex_float* a,
+                          lapack_int lda, float* s, lapack_complex_float* u, lapack_int ldu, lapack_complex_float* vt,
+                          lapack_int ldvt, float* superb);
+lapack_int LAPACKE_zgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, lapack_complex_double* a,
+                          lapack_int lda, double* s, lapack_complex_double* u, lapack_int ldu,
+                          lapack_complex_double* vt, lapack_int ldvt, double* superb);
+
+/* LU factorization (getrf) — used by PartialPivLU_LAPACKE.h */
+lapack_int LAPACKE_sgetrf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* ipiv);
+lapack_int LAPACKE_dgetrf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, lapack_int* ipiv);
+lapack_int LAPACKE_cgetrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
+                          lapack_int* ipiv);
+lapack_int LAPACKE_zgetrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
+                          lapack_int* ipiv);
+
+/* Cholesky factorization (potrf) — used by LLT_LAPACKE.h */
+lapack_int LAPACKE_spotrf(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
+lapack_int LAPACKE_dpotrf(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
+lapack_int LAPACKE_cpotrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
+lapack_int LAPACKE_zpotrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
+
+/* Symmetric/Hermitian eigenvalues (syev/heev) — used by SelfAdjointEigenSolver_LAPACKE.h */
+lapack_int LAPACKE_ssyev(int matrix_order, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w);
+lapack_int LAPACKE_dsyev(int matrix_order, char jobz, char uplo, lapack_int n, double* a, lapack_int lda, double* w);
+lapack_int LAPACKE_cheev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
+                         float* w);
+lapack_int LAPACKE_zheev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
+                         double* w);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _LAPACKE_H_ */
+
+#endif /* _MKL_LAPACKE_H_ */
diff --git a/Eigen/src/LAPACKESupport/lapacke_helpers.h b/Eigen/src/LAPACKESupport/lapacke_helpers.h
new file mode 100644
index 0000000..909d856
--- /dev/null
+++ b/Eigen/src/LAPACKESupport/lapacke_helpers.h
@@ -0,0 +1,164 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2021 Erik Schultheis <erik.schultheis@aalto.fi>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_LAPACKE_HELPERS_H
+#define EIGEN_LAPACKE_HELPERS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "lapacke.h"
+#endif
+
+namespace Eigen {
+namespace internal {
+/**
+ * \internal
+ * \brief Implementation details and helper functions for the lapacke glue code.
+ */
+namespace lapacke_helpers {
+
+// ---------------------------------------------------------------------------------------------------------------------
+//                  Translation from Eigen to Lapacke for types and constants
+// ---------------------------------------------------------------------------------------------------------------------
+
+// For complex numbers, the types in Eigen and Lapacke are different, but layout compatible.
+template <typename Scalar>
+struct translate_type_imp;
+template <>
+struct translate_type_imp<float> {
+  using type = float;
+};
+template <>
+struct translate_type_imp<double> {
+  using type = double;
+};
+template <>
+struct translate_type_imp<std::complex<double>> {
+  using type = lapack_complex_double;
+};
+template <>
+struct translate_type_imp<std::complex<float>> {
+  using type = lapack_complex_float;
+};
+
+/// Given an Eigen type, this is defined to be the corresponding, layout-compatible lapack type
+template <typename Scalar>
+using translated_type = typename translate_type_imp<Scalar>::type;
+
+/// These functions convert their arguments from Eigen to Lapack types
+/// This function performs conversion for any of the translations defined above.
+template <typename Source, typename Target = translated_type<Source>>
+EIGEN_ALWAYS_INLINE auto to_lapack(Source value) {
+  return static_cast<Target>(value);
+}
+
+/// This function performs conversions for pointer types corresponding to the translations above.
+/// This is valid because the translations are between layout-compatible types.
+template <typename Source, typename Target = translated_type<Source>>
+EIGEN_ALWAYS_INLINE auto to_lapack(Source *value) {
+  return reinterpret_cast<Target *>(value);
+}
+
+/// This function converts the Eigen Index to a lapack index, with possible range checks
+/// \sa internal::convert_index
+EIGEN_ALWAYS_INLINE lapack_int to_lapack(Index index) { return convert_index<lapack_int>(index); }
+
+/// translates storage order of the given Eigen object to the corresponding lapack constant
+template <typename Derived>
+EIGEN_ALWAYS_INLINE constexpr lapack_int lapack_storage_of(const EigenBase<Derived> &) {
+  return Derived::IsRowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+//              Automatic generation of low-level wrappers
+// ---------------------------------------------------------------------------------------------------------------------
+
+/*!
+ * \internal
+ * \brief Helper type to facilitate the wrapping of raw LAPACKE functions for different types into a single, overloaded
+ * C++ function. This is achieved in combination with \ref EIGEN_MAKE_LAPACKE_WRAPPER \details This implementation works
+ * by providing an overloaded call function that just forwards its arguments to the underlying lapack function. Each of
+ * these overloads is enabled only if the call is actually well formed. Because these lapack functions take pointers to
+ * the underlying scalar type as arguments, even though the actual Scalars would be implicitly convertible, the pointers
+ * are not and therefore only a single overload can be valid at the same time. Thus, despite all functions taking fully
+ * generic `Args&&... args` as arguments, there is never any ambiguity.
+ */
+template <typename DoubleFn, typename SingleFn, typename DoubleCpxFn, typename SingleCpxFn>
+struct WrappingHelper {
+  // The naming of double, single, double complex and single complex is purely for readability
+  // and doesn't actually affect the workings of this class. In principle, the arguments can
+  // be supplied in any permuted order.
+  DoubleFn double_;
+  SingleFn single_;
+  DoubleCpxFn double_cpx_;
+  SingleCpxFn single_cpx_;
+
+  template <typename... Args>
+  auto call(Args &&...args) -> decltype(double_(std::forward<Args>(args)...)) {
+    return double_(std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  auto call(Args &&...args) -> decltype(single_(std::forward<Args>(args)...)) {
+    return single_(std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  auto call(Args &&...args) -> decltype(double_cpx_(std::forward<Args>(args)...)) {
+    return double_cpx_(std::forward<Args>(args)...);
+  }
+
+  template <typename... Args>
+  auto call(Args &&...args) -> decltype(single_cpx_(std::forward<Args>(args)...)) {
+    return single_cpx_(std::forward<Args>(args)...);
+  }
+};
+
+/** \internal Helper function that generates a `WrappingHelper` object with the given function pointers and
+ * invokes its `call` method, thus selecting one of the overloads.
+ * \sa EIGEN_MAKE_LAPACKE_WRAPPER
+ */
+template <typename DoubleFn, typename SingleFn, typename DoubleCpxFn, typename SingleCpxFn, typename... Args>
+EIGEN_ALWAYS_INLINE auto call_wrapper(DoubleFn df, SingleFn sf, DoubleCpxFn dcf, SingleCpxFn scf, Args &&...args) {
+  WrappingHelper<DoubleFn, SingleFn, DoubleCpxFn, SingleCpxFn> helper{df, sf, dcf, scf};
+  return helper.call(std::forward<Args>(args)...);
+}
+
+/**
+ * \internal
+ * Generates a new function `Function` that dispatches to the corresponding LAPACKE_? prefixed functions.
+ * \sa WrappingHelper
+ */
+#define EIGEN_MAKE_LAPACKE_WRAPPER(FUNCTION)                                                                \
+  template <typename... Args>                                                                               \
+  EIGEN_ALWAYS_INLINE auto FUNCTION(Args &&...args) {                                                       \
+    return call_wrapper(LAPACKE_d##FUNCTION, LAPACKE_s##FUNCTION, LAPACKE_z##FUNCTION, LAPACKE_c##FUNCTION, \
+                        std::forward<Args>(args)...);                                                       \
+  }
+
+// Now with this macro and the helper wrappers, we can generate the dispatch for all the lapacke functions that are
+// used in Eigen.
+// We define these here instead of in the files where they are used because this allows us to #undef the macro again
+// right here
+EIGEN_MAKE_LAPACKE_WRAPPER(potrf)
+EIGEN_MAKE_LAPACKE_WRAPPER(getrf)
+EIGEN_MAKE_LAPACKE_WRAPPER(geqrf)
+EIGEN_MAKE_LAPACKE_WRAPPER(gesdd)
+
+#undef EIGEN_MAKE_LAPACKE_WRAPPER
+}  // namespace lapacke_helpers
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_LAPACKE_HELPERS_H
diff --git a/Eigen/src/LAPACKESupport/lapacke_mangling.h b/Eigen/src/LAPACKESupport/lapacke_mangling.h
new file mode 100644
index 0000000..c91f118
--- /dev/null
+++ b/Eigen/src/LAPACKESupport/lapacke_mangling.h
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef LAPACK_HEADER_INCLUDED
+#define LAPACK_HEADER_INCLUDED
+
+#ifndef LAPACK_GLOBAL
+#if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_)
+#define LAPACK_GLOBAL(lcname, UCNAME) lcname##_
+#elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER)
+#define LAPACK_GLOBAL(lcname, UCNAME) UCNAME
+#elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE)
+#define LAPACK_GLOBAL(lcname, UCNAME) lcname
+#else
+#define LAPACK_GLOBAL(lcname, UCNAME) lcname##_
+#endif
+#endif
+
+#endif
diff --git a/Eigen/src/LU/Determinant.h b/Eigen/src/LU/Determinant.h
index ae4fee3..ac9e05a 100644
--- a/Eigen/src/LU/Determinant.h
+++ b/Eigen/src/LU/Determinant.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_DETERMINANT_H
 #define EIGEN_DETERMINANT_H
@@ -25,10 +26,7 @@
 
 template <typename Derived, int DeterminantType = Derived::RowsAtCompileTime>
 struct determinant_impl {
-  static inline typename traits<Derived>::Scalar run(const Derived& m) {
-    if (Derived::ColsAtCompileTime == Dynamic && m.rows() == 0) return typename traits<Derived>::Scalar(1);
-    return m.partialPivLu().determinant();
-  }
+  static inline typename traits<Derived>::Scalar run(const Derived& m) { return internal::partial_lu_determinant(m); }
 };
 
 template <typename Derived>
@@ -52,7 +50,7 @@
 
 template <typename Derived>
 struct determinant_impl<Derived, 4> {
-  typedef typename traits<Derived>::Scalar Scalar;
+  using Scalar = typename traits<Derived>::Scalar;
   static EIGEN_DEVICE_FUNC Scalar run(const Derived& m) {
     Scalar d2_01 = det2(m, 0, 1);
     Scalar d2_02 = det2(m, 0, 2);
@@ -89,7 +87,7 @@
 template <typename Derived>
 EIGEN_DEVICE_FUNC inline typename internal::traits<Derived>::Scalar MatrixBase<Derived>::determinant() const {
   eigen_assert(rows() == cols());
-  typedef typename internal::nested_eval<Derived, Base::RowsAtCompileTime>::type Nested;
+  using Nested = typename internal::nested_eval<Derived, Base::RowsAtCompileTime>::type;
   return internal::determinant_impl<internal::remove_all_t<Nested>>::run(derived());
 }
 
diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h
index 74bdcf3..1857d27 100644
--- a/Eigen/src/LU/FullPivLU.h
+++ b/Eigen/src/LU/FullPivLU.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_LU_H
 #define EIGEN_LU_H
@@ -16,11 +17,16 @@
 namespace Eigen {
 
 namespace internal {
+template <typename DecompositionType>
+struct kernel_retval;
+template <typename DecompositionType>
+struct image_retval;
+
 template <typename MatrixType_, typename PermutationIndex_>
 struct traits<FullPivLU<MatrixType_, PermutationIndex_> > : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef PermutationIndex_ StorageIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = PermutationIndex_;
   enum { Flags = 0 };
 };
 
@@ -60,11 +66,23 @@
  * \sa MatrixBase::fullPivLu(), MatrixBase::determinant(), MatrixBase::inverse()
  */
 template <typename MatrixType_, typename PermutationIndex_>
-class FullPivLU : public SolverBase<FullPivLU<MatrixType_, PermutationIndex_> > {
+class FullPivLU : public SolverBase<FullPivLU<MatrixType_, PermutationIndex_> >,
+                  public RankRevealingBase<FullPivLU<MatrixType_, PermutationIndex_> > {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<FullPivLU> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<FullPivLU>;
+  using RankRevealingBase_ = RankRevealingBase<FullPivLU>;
   friend class SolverBase<FullPivLU>;
+  friend class RankRevealingBase<FullPivLU>;
+  using RankRevealingBase_::dimensionOfKernel;
+  using RankRevealingBase_::isInjective;
+  using RankRevealingBase_::isInvertible;
+  using RankRevealingBase_::isSurjective;
+  using RankRevealingBase_::maxPivot;
+  using RankRevealingBase_::nonzeroPivots;
+  using RankRevealingBase_::rank;
+  using RankRevealingBase_::setThreshold;
+  using RankRevealingBase_::threshold;
 
   EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivLU)
   enum {
@@ -72,11 +90,11 @@
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
   using PermutationIndex = PermutationIndex_;
-  typedef typename internal::plain_row_type<MatrixType, PermutationIndex>::type IntRowVectorType;
-  typedef typename internal::plain_col_type<MatrixType, PermutationIndex>::type IntColVectorType;
-  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex> PermutationQType;
-  typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime, PermutationIndex> PermutationPType;
-  typedef typename MatrixType::PlainObject PlainObject;
+  using IntRowVectorType = typename internal::plain_row_type<MatrixType, PermutationIndex>::type;
+  using IntColVectorType = typename internal::plain_col_type<MatrixType, PermutationIndex>::type;
+  using PermutationQType = PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex>;
+  using PermutationPType = PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime, PermutationIndex>;
+  using PlainObject = typename MatrixType::PlainObject;
 
   /** \brief Reports whether the LU factorization was successful.
    *
@@ -148,23 +166,6 @@
     return m_lu;
   }
 
-  /** \returns the number of nonzero pivots in the LU decomposition.
-   * Here nonzero is meant in the exact sense, not in a fuzzy sense.
-   * So that notion isn't really intrinsically interesting, but it is
-   * still useful when implementing algorithms.
-   *
-   * \sa rank()
-   */
-  inline Index nonzeroPivots() const {
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    return m_nonzero_pivots;
-  }
-
-  /** \returns the absolute value of the biggest pivot, i.e. the biggest
-   *          diagonal coefficient of U.
-   */
-  RealScalar maxPivot() const { return m_maxpivot; }
-
   /** \returns the permutation matrix P
    *
    * \sa permutationQ()
@@ -273,119 +274,70 @@
    *
    * \warning a determinant can be very big or small, so for matrices
    * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() and signDeterminant() instead.
+   * Also, do not rely on the determinant being exactly zero for testing
+   * singularity or rank-deficiency.
    *
-   * \sa MatrixBase::determinant()
+   * \sa absDeterminant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
    */
   typename internal::traits<MatrixType>::Scalar determinant() const;
 
-  /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
-   * who need to determine when pivots are to be considered nonzero. This is not used for the
-   * LU decomposition itself.
+  /** \returns the absolute value of the determinant of the matrix of which
+   * *this is the LU decomposition. It has only linear complexity
+   * (that is, O(n) where n is the dimension of the square matrix)
+   * as the LU decomposition has already been computed.
    *
-   * When it needs to get the threshold value, Eigen calls threshold(). By default, this
-   * uses a formula to automatically determine a reasonable threshold.
-   * Once you have called the present method setThreshold(const RealScalar&),
-   * your value is used instead.
+   * \note This is only for square matrices.
    *
-   * \param threshold The new value to use as the threshold.
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
    *
-   * A pivot will be considered nonzero if its absolute value is strictly greater than
-   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
-   * where maxpivot is the biggest pivot.
+   * \note Returns exactly zero when rank() finds the decomposition rank-deficient, as the
+   * rank-revealing QR decompositions do. determinant() is not gated that way: it returns the
+   * product of the pivots whatever the rank.
    *
-   * If you want to come back to the default behavior, call setThreshold(Default_t)
+   * \sa determinant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
    */
-  FullPivLU& setThreshold(const RealScalar& threshold) {
-    m_usePrescribedThreshold = true;
-    m_prescribedThreshold = threshold;
-    return *this;
-  }
+  RealScalar absDeterminant() const;
 
-  /** Allows to come back to the default behavior, letting Eigen use its default formula for
-   * determining the threshold.
+  /** \returns the natural log of the absolute value of the determinant of the matrix of which
+   * *this is the LU decomposition. It has only linear complexity
+   * (that is, O(n) where n is the dimension of the square matrix)
+   * as the LU decomposition has already been computed.
    *
-   * You should pass the special object Eigen::Default as parameter here.
-   * \code lu.setThreshold(Eigen::Default); \endcode
+   * \note This is only for square matrices.
    *
-   * See the documentation of setThreshold(const RealScalar&).
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation.
+   *
+   * \note Returns \c -infinity when rank() finds the decomposition rank-deficient.
+   *
+   * \sa determinant(), absDeterminant(), signDeterminant(), MatrixBase::determinant()
    */
-  FullPivLU& setThreshold(Default_t) {
-    m_usePrescribedThreshold = false;
-    return *this;
-  }
+  RealScalar logAbsDeterminant() const;
 
-  /** Returns the threshold that will be used by certain methods such as rank().
+  /** \returns the sign of the determinant of the matrix of which
+   * *this is the LU decomposition. It has only linear complexity
+   * (that is, O(n) where n is the dimension of the square matrix)
+   * as the LU decomposition has already been computed.
    *
-   * See the documentation of setThreshold(const RealScalar&).
+   * \note This is only for square matrices.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation.
+   *
+   * \note Returns zero when rank() finds the decomposition rank-deficient, matching the documented
+   * sign of a singular matrix.
+   *
+   * \sa determinant(), absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
    */
-  RealScalar threshold() const {
-    eigen_assert(m_isInitialized || m_usePrescribedThreshold);
-    return m_usePrescribedThreshold ? m_prescribedThreshold
-                                    // Higham's backward error bound for Gaussian elimination with
-                                    // complete pivoting (Theorem 9.4) is ||ΔA||₂ ≤ c·min(m,n)·u·||A||₂.
-                                    // The factor of 4 covers the constant c.
-                                    : NumTraits<Scalar>::epsilon() * RealScalar(4 * m_lu.diagonalSize());
-  }
+  Scalar signDeterminant() const;
 
-  /** \returns the rank of the matrix of which *this is the LU decomposition.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline Index rank() const {
+  /** \returns the absolute value of the i-th pivot coefficient (for RankRevealingBase). */
+  RealScalar pivotCoeff(Index i) const {
     using std::abs;
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
-    Index result = 0;
-    for (Index i = 0; i < m_nonzero_pivots; ++i) result += (abs(m_lu.coeff(i, i)) > premultiplied_threshold);
-    return result;
-  }
-
-  /** \returns the dimension of the kernel of the matrix of which *this is the LU decomposition.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline Index dimensionOfKernel() const {
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    return cols() - rank();
-  }
-
-  /** \returns true if the matrix of which *this is the LU decomposition represents an injective
-   *          linear map, i.e. has trivial kernel; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isInjective() const {
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    return rank() == cols();
-  }
-
-  /** \returns true if the matrix of which *this is the LU decomposition represents a surjective
-   *          linear map; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isSurjective() const {
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    return rank() == rows();
-  }
-
-  /** \returns true if the matrix of which *this is the LU decomposition is invertible.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isInvertible() const {
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    return isInjective() && (m_lu.rows() == m_lu.cols());
+    return abs(m_lu.coeff(i, i));
   }
 
   /** \returns the inverse of the matrix of which *this is the LU decomposition.
@@ -424,15 +376,13 @@
   PermutationQType m_q;
   IntColVectorType m_rowsTranspositions;
   IntRowVectorType m_colsTranspositions;
-  Index m_nonzero_pivots;
   RealScalar m_l1_norm;
-  RealScalar m_maxpivot, m_prescribedThreshold;
   signed char m_det_pq;
-  bool m_isInitialized, m_usePrescribedThreshold;
+  bool m_isInitialized;
 };
 
 template <typename MatrixType, typename PermutationIndex>
-FullPivLU<MatrixType, PermutationIndex>::FullPivLU() : m_isInitialized(false), m_usePrescribedThreshold(false) {}
+FullPivLU<MatrixType, PermutationIndex>::FullPivLU() : m_isInitialized(false) {}
 
 template <typename MatrixType, typename PermutationIndex>
 FullPivLU<MatrixType, PermutationIndex>::FullPivLU(Index rows, Index cols)
@@ -441,8 +391,7 @@
       m_q(cols),
       m_rowsTranspositions(rows),
       m_colsTranspositions(cols),
-      m_isInitialized(false),
-      m_usePrescribedThreshold(false) {}
+      m_isInitialized(false) {}
 
 template <typename MatrixType, typename PermutationIndex>
 template <typename InputType>
@@ -452,8 +401,7 @@
       m_q(matrix.cols()),
       m_rowsTranspositions(matrix.rows()),
       m_colsTranspositions(matrix.cols()),
-      m_isInitialized(false),
-      m_usePrescribedThreshold(false) {
+      m_isInitialized(false) {
   compute(matrix.derived());
 }
 
@@ -465,8 +413,7 @@
       m_q(matrix.cols()),
       m_rowsTranspositions(matrix.rows()),
       m_colsTranspositions(matrix.cols()),
-      m_isInitialized(false),
-      m_usePrescribedThreshold(false) {
+      m_isInitialized(false) {
   computeInPlace();
 }
 
@@ -475,7 +422,10 @@
   eigen_assert(m_lu.rows() <= NumTraits<PermutationIndex>::highest() &&
                m_lu.cols() <= NumTraits<PermutationIndex>::highest());
 
-  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+  if (m_lu.cols() > 0)
+    m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();
+  else
+    m_l1_norm = RealScalar(0);
 
   const Index size = m_lu.diagonalSize();
   const Index rows = m_lu.rows();
@@ -487,16 +437,16 @@
   m_colsTranspositions.resize(m_lu.cols());
   Index number_of_transpositions = 0;  // number of NONTRIVIAL transpositions, i.e. m_rowsTranspositions[i]!=i
 
-  m_nonzero_pivots = size;  // the generic case is that in which all pivots are nonzero (invertible case)
-  m_maxpivot = RealScalar(0);
+  this->m_nonzero_pivots = size;  // the generic case is that in which all pivots are nonzero (invertible case)
+  this->m_maxpivot = RealScalar(0);
 
   for (Index k = 0; k < size; ++k) {
     // First, we need to find the pivot.
 
     // biggest coefficient in the remaining bottom-right corner (starting at row k, col k)
     Index row_of_biggest_in_corner, col_of_biggest_in_corner;
-    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
-    typedef typename Scoring::result_type Score;
+    using Scoring = internal::scalar_score_coeff_op<Scalar>;
+    using Score = typename Scoring::result_type;
     Score biggest_in_corner;
     biggest_in_corner = m_lu.bottomRightCorner(rows - k, cols - k)
                             .unaryExpr(Scoring())
@@ -507,7 +457,7 @@
     if (numext::is_exactly_zero(biggest_in_corner)) {
       // before exiting, make sure to initialize the still uninitialized transpositions
       // in a sane state without destroying what we already have.
-      m_nonzero_pivots = k;
+      this->m_nonzero_pivots = k;
       for (Index i = k; i < size; ++i) {
         m_rowsTranspositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
         m_colsTranspositions.coeffRef(i) = internal::convert_index<StorageIndex>(i);
@@ -517,7 +467,7 @@
 
     RealScalar abs_pivot = internal::abs_knowing_score<Scalar>()(
         m_lu(row_of_biggest_in_corner, col_of_biggest_in_corner), biggest_in_corner);
-    if (abs_pivot > m_maxpivot) m_maxpivot = abs_pivot;
+    if (abs_pivot > this->m_maxpivot) this->m_maxpivot = abs_pivot;
 
     // Now that we've found the pivot, we need to apply the row/col swaps to
     // bring it to the location (k,k).
@@ -563,6 +513,30 @@
   return Scalar(m_det_pq) * Scalar(m_lu.diagonal().prod());
 }
 
+template <typename MatrixType, typename PermutationIndex>
+typename FullPivLU<MatrixType, PermutationIndex>::RealScalar FullPivLU<MatrixType, PermutationIndex>::absDeterminant()
+    const {
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!");
+  return isInjective() ? numext::abs(m_lu.diagonal().prod()) : RealScalar(0);
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename FullPivLU<MatrixType, PermutationIndex>::RealScalar
+FullPivLU<MatrixType, PermutationIndex>::logAbsDeterminant() const {
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!");
+  return isInjective() ? m_lu.diagonal().cwiseAbs().array().log().sum() : -NumTraits<RealScalar>::infinity();
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename FullPivLU<MatrixType, PermutationIndex>::Scalar FullPivLU<MatrixType, PermutationIndex>::signDeterminant()
+    const {
+  eigen_assert(m_isInitialized && "LU is not initialized.");
+  eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!");
+  return isInjective() ? Scalar(m_det_pq) * m_lu.diagonal().array().sign().prod() : Scalar(0);
+}
+
 /** \returns the matrix represented by the decomposition,
  * i.e., it returns the product: \f$ P^{-1} L U Q^{-1} \f$.
  * This function is provided for debug purposes. */
@@ -573,8 +547,8 @@
   // LU
   MatrixType res(m_lu.rows(), m_lu.cols());
   // FIXME: the .toDenseMatrix() calls should not be needed.
-  res = m_lu.leftCols(smalldim).template triangularView<UnitLower>().toDenseMatrix() *
-        m_lu.topRows(smalldim).template triangularView<Upper>().toDenseMatrix();
+  res.noalias() = m_lu.leftCols(smalldim).template triangularView<UnitLower>().toDenseMatrix() *
+                  m_lu.topRows(smalldim).template triangularView<Upper>().toDenseMatrix();
 
   // P^{-1}(LU)
   res = m_p.inverse() * res;
@@ -588,114 +562,126 @@
 /********* Implementation of kernel() **************************************************/
 
 namespace internal {
-template <typename MatrixType_, typename PermutationIndex_>
-struct kernel_retval<FullPivLU<MatrixType_, PermutationIndex_> >
-    : kernel_retval_base<FullPivLU<MatrixType_, PermutationIndex_> > {
-  using DecompositionType = FullPivLU<MatrixType_, PermutationIndex_>;
-  EIGEN_MAKE_KERNEL_HELPERS(DecompositionType)
+template <typename MatrixType, typename PermutationIndex>
+auto fullpivlu_nonzero_pivots(const FullPivLU<MatrixType, PermutationIndex>& dec, Index rank) {
+  constexpr int MaxSmallDimAtCompileTime =
+      min_size_prefer_fixed(MatrixType::MaxColsAtCompileTime, MatrixType::MaxRowsAtCompileTime);
+  Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank);
+  const typename MatrixType::RealScalar premultiplied_threshold = dec.maxPivot() * dec.threshold();
+  Index p = 0;
+  for (Index i = 0; i < dec.nonzeroPivots(); ++i)
+    if (numext::abs(dec.matrixLU().coeff(i, i)) > premultiplied_threshold) pivots.coeffRef(p++) = i;
+  eigen_internal_assert(p == rank);
+  return pivots;
+}
 
-  enum {
-    MaxSmallDimAtCompileTime = min_size_prefer_fixed(MatrixType::MaxColsAtCompileTime, MatrixType::MaxRowsAtCompileTime)
-  };
+template <typename MatrixType_, typename PermutationIndex_>
+struct traits<kernel_retval<FullPivLU<MatrixType_, PermutationIndex_>>> {
+  using ReturnType = Matrix<typename MatrixType_::Scalar, MatrixType_::ColsAtCompileTime, Dynamic,
+                            plain_object_options<MatrixType_>::value, MatrixType_::MaxColsAtCompileTime,
+                            MatrixType_::MaxColsAtCompileTime>;
+};
+
+template <typename MatrixType_, typename PermutationIndex_>
+struct kernel_retval<FullPivLU<MatrixType_, PermutationIndex_>>
+    : ReturnByValue<kernel_retval<FullPivLU<MatrixType_, PermutationIndex_>>> {
+  using DecompositionType = FullPivLU<MatrixType_, PermutationIndex_>;
+  using MatrixType = MatrixType_;
+  using Scalar = typename MatrixType::Scalar;
+
+  static constexpr int MaxSmallDimAtCompileTime =
+      min_size_prefer_fixed(MatrixType::MaxColsAtCompileTime, MatrixType::MaxRowsAtCompileTime);
+
+  explicit kernel_retval(const DecompositionType& dec)
+      : m_dec(dec), m_rank(dec.rank()), m_cols(m_rank == dec.cols() ? 1 : dec.cols() - m_rank) {}
+
+  Index rows() const { return m_dec.cols(); }
+  Index cols() const { return m_cols; }
 
   template <typename Dest>
   void evalTo(Dest& dst) const {
-    using std::abs;
-    const Index cols = dec().matrixLU().cols(), dimker = cols - rank();
+    const Index cols = m_dec.matrixLU().cols(), dimker = cols - m_rank;
     if (dimker == 0) {
-      // The Kernel is just {0}, so it doesn't have a basis properly speaking, but let's
-      // avoid crashing/asserting as that depends on floating point calculations. Let's
-      // just return a single column vector filled with zeros.
+      // Represent the zero space by a single zero column.
       dst.setZero();
       return;
     }
 
-    /* Let us use the following lemma:
-     *
-     * Lemma: If the matrix A has the LU decomposition PAQ = LU,
-     * then Ker A = Q(Ker U).
-     *
-     * Proof: trivial: just keep in mind that P, Q, L are invertible.
-     */
-
-    /* Thus, all we need to do is to compute Ker U, and then apply Q.
-     *
-     * U is upper triangular, with eigenvalues sorted so that any zeros appear at the end.
-     * Thus, the diagonal of U ends with exactly
-     * dimKer zero's. Let us use that to construct dimKer linearly
-     * independent vectors in Ker U.
-     */
-
-    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
-    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
-    Index p = 0;
-    for (Index i = 0; i < dec().nonzeroPivots(); ++i)
-      if (abs(dec().matrixLU().coeff(i, i)) > premultiplied_threshold) pivots.coeffRef(p++) = i;
-    eigen_internal_assert(p == rank());
+    // PAQ = LU implies ker(A) = Q ker(U).
+    const auto pivots = fullpivlu_nonzero_pivots(m_dec, m_rank);
 
     // Construct a temporary trapezoid matrix m by taking the U matrix and permuting
     // the rows and cols to bring the nonnegligible pivots to the top of the main diagonal.
     // This is needed to apply our triangular solvers.
     // FIXME: simplify once triangularView supports rectangular matrices.
-    Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, traits<MatrixType>::Options, MaxSmallDimAtCompileTime,
-           MatrixType::MaxColsAtCompileTime>
-        m(dec().matrixLU().block(0, 0, rank(), cols));
-    for (Index i = 0; i < rank(); ++i) {
+    Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, plain_object_options<MatrixType>::value,
+           MaxSmallDimAtCompileTime, MatrixType::MaxColsAtCompileTime>
+        m(m_dec.matrixLU().block(0, 0, m_rank, cols));
+    for (Index i = 0; i < m_rank; ++i) {
       if (i) m.row(i).head(i).setZero();
-      m.row(i).tail(cols - i) = dec().matrixLU().row(pivots.coeff(i)).tail(cols - i);
+      m.row(i).tail(cols - i) = m_dec.matrixLU().row(pivots.coeff(i)).tail(cols - i);
     }
-    m.block(0, 0, rank(), rank());
-    m.block(0, 0, rank(), rank()).template triangularView<StrictlyLower>().setZero();
-    for (Index i = 0; i < rank(); ++i) m.col(i).swap(m.col(pivots.coeff(i)));
+    m.block(0, 0, m_rank, m_rank).template triangularView<StrictlyLower>().setZero();
+    for (Index i = 0; i < m_rank; ++i) m.col(i).swap(m.col(pivots.coeff(i)));
 
     // ok, we have our trapezoid matrix, we can apply the triangular solver.
     // notice that the math behind this suggests that we should apply this to the
     // negative of the RHS, but for performance we just put the negative sign elsewhere, see below.
-    m.topLeftCorner(rank(), rank()).template triangularView<Upper>().solveInPlace(m.topRightCorner(rank(), dimker));
+    m.topLeftCorner(m_rank, m_rank).template triangularView<Upper>().solveInPlace(m.topRightCorner(m_rank, dimker));
 
     // now we must undo the column permutation that we had applied!
-    for (Index i = rank() - 1; i >= 0; --i) m.col(i).swap(m.col(pivots.coeff(i)));
+    for (Index i = m_rank - 1; i >= 0; --i) m.col(i).swap(m.col(pivots.coeff(i)));
 
     // see the negative sign in the next line, that's what we were talking about above.
-    for (Index i = 0; i < rank(); ++i) dst.row(dec().permutationQ().indices().coeff(i)) = -m.row(i).tail(dimker);
-    for (Index i = rank(); i < cols; ++i) dst.row(dec().permutationQ().indices().coeff(i)).setZero();
-    for (Index k = 0; k < dimker; ++k) dst.coeffRef(dec().permutationQ().indices().coeff(rank() + k), k) = Scalar(1);
+    for (Index i = 0; i < m_rank; ++i) dst.row(m_dec.permutationQ().indices().coeff(i)) = -m.row(i).tail(dimker);
+    for (Index i = m_rank; i < cols; ++i) dst.row(m_dec.permutationQ().indices().coeff(i)).setZero();
+    for (Index k = 0; k < dimker; ++k) dst.coeffRef(m_dec.permutationQ().indices().coeff(m_rank + k), k) = Scalar(1);
   }
+
+ private:
+  const DecompositionType& m_dec;
+  Index m_rank, m_cols;
 };
 
 /***** Implementation of image() *****************************************************/
 
 template <typename MatrixType_, typename PermutationIndex_>
-struct image_retval<FullPivLU<MatrixType_, PermutationIndex_> >
-    : image_retval_base<FullPivLU<MatrixType_, PermutationIndex_> > {
-  using DecompositionType = FullPivLU<MatrixType_, PermutationIndex_>;
-  EIGEN_MAKE_IMAGE_HELPERS(DecompositionType)
+struct traits<image_retval<FullPivLU<MatrixType_, PermutationIndex_>>> {
+  using ReturnType = Matrix<typename MatrixType_::Scalar, MatrixType_::RowsAtCompileTime, Dynamic,
+                            plain_object_options<MatrixType_>::value, MatrixType_::MaxRowsAtCompileTime,
+                            MatrixType_::MaxColsAtCompileTime>;
+};
 
-  enum {
-    MaxSmallDimAtCompileTime = min_size_prefer_fixed(MatrixType::MaxColsAtCompileTime, MatrixType::MaxRowsAtCompileTime)
-  };
+template <typename MatrixType_, typename PermutationIndex_>
+struct image_retval<FullPivLU<MatrixType_, PermutationIndex_>>
+    : ReturnByValue<image_retval<FullPivLU<MatrixType_, PermutationIndex_>>> {
+  using DecompositionType = FullPivLU<MatrixType_, PermutationIndex_>;
+  using MatrixType = MatrixType_;
+
+  image_retval(const DecompositionType& dec, const MatrixType& originalMatrix)
+      : m_dec(dec), m_rank(dec.rank()), m_originalMatrix(originalMatrix) {}
+
+  Index rows() const { return m_dec.rows(); }
+  Index cols() const { return m_rank == 0 ? 1 : m_rank; }
 
   template <typename Dest>
   void evalTo(Dest& dst) const {
-    using std::abs;
-    if (rank() == 0) {
-      // The Image is just {0}, so it doesn't have a basis properly speaking, but let's
-      // avoid crashing/asserting as that depends on floating point calculations. Let's
-      // just return a single column vector filled with zeros.
+    if (m_rank == 0) {
+      // Represent the zero space by a single zero column.
       dst.setZero();
       return;
     }
 
-    Matrix<Index, Dynamic, 1, 0, MaxSmallDimAtCompileTime, 1> pivots(rank());
-    RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold();
-    Index p = 0;
-    for (Index i = 0; i < dec().nonzeroPivots(); ++i)
-      if (abs(dec().matrixLU().coeff(i, i)) > premultiplied_threshold) pivots.coeffRef(p++) = i;
-    eigen_internal_assert(p == rank());
-
-    for (Index i = 0; i < rank(); ++i)
-      dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i)));
+    // Select pivots before writing: dst may overlap an inplace decomposition's storage.
+    const auto pivots = fullpivlu_nonzero_pivots(m_dec, m_rank);
+    for (Index i = 0; i < m_rank; ++i)
+      dst.col(i) = m_originalMatrix.col(m_dec.permutationQ().indices().coeff(pivots.coeff(i)));
   }
+
+ private:
+  const DecompositionType& m_dec;
+  Index m_rank;
+  const MatrixType& m_originalMatrix;
 };
 
 /***** Implementation of solve() *****************************************************/
@@ -798,8 +784,8 @@
     DstXprType, Inverse<FullPivLU<MatrixType, PermutationIndex> >,
     internal::assign_op<typename DstXprType::Scalar, typename FullPivLU<MatrixType, PermutationIndex>::Scalar>,
     Dense2Dense> {
-  typedef FullPivLU<MatrixType, PermutationIndex> LuType;
-  typedef Inverse<LuType> SrcXprType;
+  using LuType = FullPivLU<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<LuType>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::assign_op<typename DstXprType::Scalar, typename MatrixType::Scalar>&) {
     dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
diff --git a/Eigen/src/LU/InternalHeaderCheck.h b/Eigen/src/LU/InternalHeaderCheck.h
index f346b17..fb4d80c 100644
--- a/Eigen/src/LU/InternalHeaderCheck.h
+++ b/Eigen/src/LU/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_LU_MODULE_H
 #error "Please include Eigen/LU instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/LU/InverseImpl.h b/Eigen/src/LU/InverseImpl.h
index 5c24dfe..56327e7 100644
--- a/Eigen/src/LU/InverseImpl.h
+++ b/Eigen/src/LU/InverseImpl.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_INVERSE_IMPL_H
 #define EIGEN_INVERSE_IMPL_H
@@ -40,7 +41,7 @@
 template <typename MatrixType, typename ResultType>
 struct compute_inverse<MatrixType, ResultType, 1> {
   EIGEN_DEVICE_FUNC static inline void run(const MatrixType& matrix, ResultType& result) {
-    typedef typename MatrixType::Scalar Scalar;
+    using Scalar = typename MatrixType::Scalar;
     internal::evaluator<MatrixType> matrixEval(matrix);
     result.coeffRef(0, 0) = Scalar(1) / matrixEval.coeff(0, 0);
   }
@@ -77,7 +78,7 @@
 template <typename MatrixType, typename ResultType>
 struct compute_inverse<MatrixType, ResultType, 2> {
   EIGEN_DEVICE_FUNC static inline void run(const MatrixType& matrix, ResultType& result) {
-    typedef typename ResultType::Scalar Scalar;
+    using Scalar = typename ResultType::Scalar;
     const Scalar invdet = typename MatrixType::Scalar(1) / matrix.determinant();
     compute_inverse_size2_helper(matrix, invdet, result);
   }
@@ -90,7 +91,7 @@
                                            ResultType& inverse, typename ResultType::Scalar& determinant,
                                            bool& invertible) {
     using std::abs;
-    typedef typename ResultType::Scalar Scalar;
+    using Scalar = typename ResultType::Scalar;
     determinant = matrix.determinant();
     invertible = abs(determinant) > absDeterminantThreshold;
     if (!invertible) return;
@@ -114,7 +115,7 @@
     const MatrixType& matrix, const typename ResultType::Scalar& invdet,
     const Matrix<typename ResultType::Scalar, 3, 1>& cofactors_col0, ResultType& result) {
   // Compute cofactors in a way that avoids aliasing issues.
-  typedef typename ResultType::Scalar Scalar;
+  using Scalar = typename ResultType::Scalar;
   const Scalar c01 = cofactor_3x3<MatrixType, 0, 1>(matrix) * invdet;
   const Scalar c11 = cofactor_3x3<MatrixType, 1, 1>(matrix) * invdet;
   const Scalar c02 = cofactor_3x3<MatrixType, 0, 2>(matrix) * invdet;
@@ -130,7 +131,7 @@
 template <typename MatrixType, typename ResultType>
 struct compute_inverse<MatrixType, ResultType, 3> {
   EIGEN_DEVICE_FUNC static inline void run(const MatrixType& matrix, ResultType& result) {
-    typedef typename ResultType::Scalar Scalar;
+    using Scalar = typename ResultType::Scalar;
     Matrix<typename MatrixType::Scalar, 3, 1> cofactors_col0;
     cofactors_col0.coeffRef(0) = cofactor_3x3<MatrixType, 0, 0>(matrix);
     cofactors_col0.coeffRef(1) = cofactor_3x3<MatrixType, 1, 0>(matrix);
@@ -147,7 +148,7 @@
                                            const typename MatrixType::RealScalar& absDeterminantThreshold,
                                            ResultType& inverse, typename ResultType::Scalar& determinant,
                                            bool& invertible) {
-    typedef typename ResultType::Scalar Scalar;
+    using Scalar = typename ResultType::Scalar;
     Matrix<Scalar, 3, 1> cofactors_col0;
     cofactors_col0.coeffRef(0) = cofactor_3x3<MatrixType, 0, 0>(matrix);
     cofactors_col0.coeffRef(1) = cofactor_3x3<MatrixType, 1, 0>(matrix);
@@ -235,7 +236,7 @@
 template <typename DstXprType, typename XprType>
 struct Assignment<DstXprType, Inverse<XprType>,
                   internal::assign_op<typename DstXprType::Scalar, typename XprType::Scalar>, Dense2Dense> {
-  typedef Inverse<XprType> SrcXprType;
+  using SrcXprType = Inverse<XprType>;
   EIGEN_DEVICE_FUNC static void run(DstXprType& dst, const SrcXprType& src,
                                     const internal::assign_op<typename DstXprType::Scalar, typename XprType::Scalar>&) {
     Index dstRows = src.rows();
@@ -247,8 +248,8 @@
     eigen_assert(((Size <= 1) || (Size > 4) || (extract_data(src.nestedExpression()) != extract_data(dst))) &&
                  "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");
 
-    typedef typename internal::nested_eval<XprType, XprType::ColsAtCompileTime>::type ActualXprType;
-    typedef internal::remove_all_t<ActualXprType> ActualXprTypeCleanded;
+    using ActualXprType = typename internal::nested_eval<XprType, XprType::ColsAtCompileTime>::type;
+    using ActualXprTypeCleanded = internal::remove_all_t<ActualXprType>;
 
     ActualXprType actual_xpr(src.nestedExpression());
 
@@ -308,13 +309,14 @@
                                                                typename ResultType::Scalar& determinant,
                                                                bool& invertible,
                                                                const RealScalar& absDeterminantThreshold) const {
-  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
+  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived, ResultType)
   eigen_assert(rows() == cols());
+  inverse.resize(rows(), cols());
   // for 2x2, it's worth giving a chance to avoid evaluating.
   // for larger sizes, evaluating has negligible cost and limits code size.
-  typedef std::conditional_t<RowsAtCompileTime == 2,
-                             internal::remove_all_t<typename internal::nested_eval<Derived, 2>::type>, PlainObject>
-      MatrixType;
+  using MatrixType =
+      std::conditional_t<RowsAtCompileTime == 2,
+                         internal::remove_all_t<typename internal::nested_eval<Derived, 2>::type>, PlainObject>;
   internal::compute_inverse_and_det_with_check<MatrixType, ResultType>::run(derived(), absDeterminantThreshold, inverse,
                                                                             determinant, invertible);
 }
@@ -343,8 +345,6 @@
 inline void MatrixBase<Derived>::computeInverseWithCheck(ResultType& inverse, bool& invertible,
                                                          const RealScalar& absDeterminantThreshold) const {
   Scalar determinant;
-  // i'd love to put some static assertions there, but SFINAE means that they have no effect...
-  eigen_assert(rows() == cols());
   computeInverseAndDetWithCheck(inverse, determinant, invertible, absDeterminantThreshold);
 }
 
diff --git a/Eigen/src/LU/PartialPivLU.h b/Eigen/src/LU/PartialPivLU.h
index 4f4227e..06b5978 100644
--- a/Eigen/src/LU/PartialPivLU.h
+++ b/Eigen/src/LU/PartialPivLU.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARTIALLU_H
 #define EIGEN_PARTIALLU_H
@@ -19,21 +20,13 @@
 namespace internal {
 template <typename MatrixType_, typename PermutationIndex_>
 struct traits<PartialPivLU<MatrixType_, PermutationIndex_> > : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef PermutationIndex_ StorageIndex;
-  typedef traits<MatrixType_> BaseTraits;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = PermutationIndex_;
+  using BaseTraits = traits<MatrixType_>;
   enum { Flags = BaseTraits::Flags & RowMajorBit, CoeffReadCost = Dynamic };
 };
 
-template <typename T, typename Derived>
-struct enable_if_ref;
-
-template <typename T, typename Derived>
-struct enable_if_ref<Ref<T>, Derived> {
-  typedef Derived type;
-};
-
 }  // end namespace internal
 
 /** \ingroup LU_Module
@@ -45,8 +38,8 @@
  * \tparam MatrixType_ the type of the matrix of which we are computing the LU decomposition
  *
  * This class represents a LU decomposition of a \b square \b invertible matrix, with partial pivoting: the matrix A
- * is decomposed as A = PLU where L is unit-lower-triangular, U is upper-triangular, and P
- * is a permutation matrix.
+ * is decomposed as \f$ A = P^{-1} L U \f$ where L is unit-lower-triangular, U is upper-triangular, and
+ * \f$ P \f$ is the permutation matrix returned by permutationP(), so that \f$ P A = L U \f$.
  *
  * Typically, partial pivoting LU decomposition is only considered numerically stable for square invertible
  * matrices. Thus LAPACK's dgesv and dgesvx require the matrix to be square and invertible. The present class
@@ -73,8 +66,8 @@
 template <typename MatrixType_, typename PermutationIndex_>
 class PartialPivLU : public SolverBase<PartialPivLU<MatrixType_, PermutationIndex_> > {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<PartialPivLU> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<PartialPivLU>;
   friend class SolverBase<PartialPivLU>;
 
   EIGEN_GENERIC_PUBLIC_INTERFACE(PartialPivLU)
@@ -83,9 +76,9 @@
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
   using PermutationIndex = PermutationIndex_;
-  typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime, PermutationIndex> PermutationType;
-  typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime, PermutationIndex> TranspositionType;
-  typedef typename MatrixType::PlainObject PlainObject;
+  using PermutationType = PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime, PermutationIndex>;
+  using TranspositionType = Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime, PermutationIndex>;
+  using PlainObject = typename MatrixType::PlainObject;
 
   /** \brief Reports whether the LU factorization was successful.
    *
@@ -211,11 +204,59 @@
    *
    * \warning a determinant can be very big or small, so for matrices
    * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() and signDeterminant() instead.
+   * Also, do not rely on the determinant being exactly zero for testing
+   * singularity or rank-deficiency.
    *
-   * \sa MatrixBase::determinant()
+   * \sa absDeterminant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
    */
   Scalar determinant() const;
 
+  /** \returns the absolute value of the determinant of the matrix of which
+   * *this is the LU decomposition. It has only linear complexity
+   * (that is, O(n) where n is the dimension of the square matrix)
+   * as the LU decomposition has already been computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \warning a determinant can be very big or small, so for matrices
+   * of large enough dimension, there is a risk of overflow/underflow.
+   * One way to work around that is to use logAbsDeterminant() instead.
+   * Also, do not rely on the determinant being exactly zero for testing
+   * singularity or rank-deficiency.
+   *
+   * \sa determinant(), logAbsDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar absDeterminant() const;
+
+  /** \returns the natural log of the absolute value of the determinant of the matrix of which
+   * *this is the LU decomposition. It has only linear complexity
+   * (that is, O(n) where n is the dimension of the square matrix)
+   * as the LU decomposition has already been computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation.
+   *
+   * \sa determinant(), absDeterminant(), signDeterminant(), MatrixBase::determinant()
+   */
+  RealScalar logAbsDeterminant() const;
+
+  /** \returns the sign of the determinant of the matrix of which
+   * *this is the LU decomposition. It has only linear complexity
+   * (that is, O(n) where n is the dimension of the square matrix)
+   * as the LU decomposition has already been computed.
+   *
+   * \note This is only for square matrices.
+   *
+   * \note This method is useful to work around the risk of overflow/underflow that's inherent
+   * to determinant computation.
+   *
+   * \sa determinant(), absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
+   */
+  Scalar signDeterminant() const;
+
   MatrixType reconstructedMatrix() const;
 
   constexpr Index rows() const noexcept { return m_lu.rows(); }
@@ -308,19 +349,30 @@
 
 namespace internal {
 
-/** \internal This is the blocked version of fullpivlu_unblocked() */
+/** \internal This is the blocked version of unblocked_lu() */
 template <typename Scalar, int StorageOrder, typename PivIndex, int SizeAtCompileTime = Dynamic>
-struct partial_lu_impl {
+struct generic_partial_lu_impl {
   static constexpr int UnBlockedBound = 16;
   static constexpr bool UnBlockedAtCompileTime = SizeAtCompileTime != Dynamic && SizeAtCompileTime <= UnBlockedBound;
   static constexpr int ActualSizeAtCompileTime = UnBlockedAtCompileTime ? SizeAtCompileTime : Dynamic;
   // Remaining rows and columns at compile-time:
   static constexpr int RRows = SizeAtCompileTime == 2 ? 1 : Dynamic;
   static constexpr int RCols = SizeAtCompileTime == 2 ? 1 : Dynamic;
-  typedef Matrix<Scalar, ActualSizeAtCompileTime, ActualSizeAtCompileTime, StorageOrder> MatrixType;
-  typedef Ref<MatrixType> MatrixTypeRef;
-  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder> > BlockType;
-  typedef typename MatrixType::RealScalar RealScalar;
+  using MatrixType = Matrix<Scalar, ActualSizeAtCompileTime, ActualSizeAtCompileTime, StorageOrder>;
+  using MatrixTypeRef = Ref<MatrixType>;
+  using BlockType = Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder>>;
+  using RealScalar = typename MatrixType::RealScalar;
+
+  static void apply_row_transpositions(BlockType& matrix, Index first, Index count, const PivIndex* transpositions) {
+    EIGEN_IF_CONSTEXPR (StorageOrder == ColMajor) {
+      // Keep the pivot rows of one column in cache, even when the outer stride maps every column to the same set.
+      for (Index j = 0; j < matrix.cols(); ++j)
+        for (Index i = first; i < first + count; ++i)
+          numext::swap(matrix.coeffRef(i, j), matrix.coeffRef(transpositions[i], j));
+    } else {
+      for (Index i = first; i < first + count; ++i) matrix.row(i).swap(matrix.row(transpositions[i]));
+    }
+  }
 
   /** \internal performs the LU decomposition in-place of the matrix \a lu
    * using an unblocked algorithm.
@@ -333,14 +385,15 @@
    * \returns The index of the first pivot which is exactly zero if any, or a negative number otherwise.
    */
   static Index unblocked_lu(MatrixTypeRef& lu, PivIndex* row_transpositions, PivIndex& nb_transpositions) {
-    typedef scalar_score_coeff_op<Scalar> Scoring;
-    typedef typename Scoring::result_type Score;
+    using Scoring = scalar_score_coeff_op<Scalar>;
+    using Score = typename Scoring::result_type;
     const Index rows = lu.rows();
     const Index cols = lu.cols();
     const Index size = (std::min)(rows, cols);
-    // For small compile-time matrices it is worth processing the last row separately:
+    // For small compile-time matrices and square runtime matrices it is worth processing the last row separately:
     //  speedup: +100% for 2x2, +10% for others.
-    const Index endk = UnBlockedAtCompileTime ? size - 1 : size;
+    const bool process_last_row_separately = UnBlockedAtCompileTime || rows == cols;
+    const Index endk = process_last_row_separately ? size - 1 : size;
     nb_transpositions = 0;
     Index first_zero_pivot = -1;
     for (Index k = 0; k < endk; ++k) {
@@ -362,17 +415,18 @@
         lu.col(k).tail(fix<RRows>(rrows)) /= lu.coeff(k, k);
       } else if (first_zero_pivot == -1) {
         // the pivot is exactly zero, we record the index of the first pivot which is exactly 0,
-        // and continue the factorization such we still have A = PLU
+        // and continue the factorization such we still have P A = L U
         first_zero_pivot = k;
       }
 
-      if (k < rows - 1)
+      // Skip the trailing update for rectangular panels with no remaining columns.
+      if (rrows > 0 && rcols > 0)
         lu.bottomRightCorner(fix<RRows>(rrows), fix<RCols>(rcols)).noalias() -=
             lu.col(k).tail(fix<RRows>(rrows)) * lu.row(k).tail(fix<RCols>(rcols));
     }
 
     // special handling of the last entry
-    if (UnBlockedAtCompileTime) {
+    if (process_last_row_separately) {
       Index k = endk;
       row_transpositions[k] = PivIndex(k);
       if (numext::is_exactly_zero(Scoring()(lu(k, k))) && first_zero_pivot == -1) first_zero_pivot = k;
@@ -403,7 +457,9 @@
     const Index size = (std::min)(rows, cols);
 
     // if the matrix is too small, no blocking:
-    if (UnBlockedAtCompileTime || size <= UnBlockedBound) {
+    EIGEN_IF_CONSTEXPR (UnBlockedAtCompileTime) {
+      return unblocked_lu(lu, row_transpositions, nb_transpositions);
+    } else if (size <= UnBlockedBound) {
       return unblocked_lu(lu, row_transpositions, nb_transpositions);
     }
 
@@ -427,7 +483,6 @@
       //                          A00 | A01 | A02
       // lu  = A_0 | A_1 | A_2 =  A10 | A11 | A12
       //                          A20 | A21 | A22
-      BlockType A_0 = lu.block(0, 0, rows, k);
       BlockType A_2 = lu.block(0, k + bs, rows, tsize);
       BlockType A11 = lu.block(k, k, bs, bs);
       BlockType A12 = lu.block(k, k + bs, bs, tsize);
@@ -443,14 +498,15 @@
 
       nb_transpositions += nb_transpositions_in_panel;
       // update permutations and apply them to A_0
-      for (Index i = k; i < k + bs; ++i) {
-        Index piv = (row_transpositions[i] += internal::convert_index<PivIndex>(k));
-        A_0.row(i).swap(A_0.row(piv));
+      if (k > 0) {
+        BlockType A_0 = lu.block(0, 0, rows, k);
+        for (Index i = k; i < k + bs; ++i) row_transpositions[i] += internal::convert_index<PivIndex>(k);
+        apply_row_transpositions(A_0, k, bs, row_transpositions);
       }
 
       if (trows) {
         // apply permutations to A_2
-        for (Index i = k; i < k + bs; ++i) A_2.row(i).swap(A_2.row(row_transpositions[i]));
+        apply_row_transpositions(A_2, k, bs, row_transpositions);
 
         // A12 = A11^-1 A12
         A11.template triangularView<UnitLower>().solveInPlace(A12);
@@ -462,6 +518,9 @@
   }
 };
 
+template <typename Scalar, int StorageOrder, typename PivIndex, int SizeAtCompileTime = Dynamic>
+struct partial_lu_impl : generic_partial_lu_impl<Scalar, StorageOrder, PivIndex, SizeAtCompileTime> {};
+
 /** \internal performs the LU decomposition with partial pivoting in-place.
  */
 template <typename MatrixType, typename TranspositionType>
@@ -483,6 +542,29 @@
                  nb_transpositions);
 }
 
+/** \internal returns the determinant computed from an in-place partial-pivoting
+ * LU decomposition of \a m without constructing a PartialPivLU object.
+ */
+template <typename Derived>
+typename traits<Derived>::Scalar partial_lu_determinant(const Derived& m) {
+  using Scalar = typename traits<Derived>::Scalar;
+  if (m.rows() == 0) return Scalar(1);
+  EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+
+  using PlainObject = typename plain_matrix_type<Derived>::type;
+  using TranspositionType =
+      Transpositions<PlainObject::RowsAtCompileTime, PlainObject::MaxRowsAtCompileTime, DefaultPermutationIndex>;
+
+  eigen_assert(m.rows() < NumTraits<DefaultPermutationIndex>::highest());
+  PlainObject lu(m);
+
+  TranspositionType row_transpositions(lu.rows());
+  typename TranspositionType::StorageIndex nb_transpositions;
+  partial_lu_inplace(lu, row_transpositions, nb_transpositions);
+
+  return Scalar((nb_transpositions % 2) ? -1 : 1) * lu.diagonal().prod();
+}
+
 }  // end namespace internal
 
 template <typename MatrixType, typename PermutationIndex>
@@ -515,6 +597,27 @@
   return Scalar(m_det_p) * m_lu.diagonal().prod();
 }
 
+template <typename MatrixType, typename PermutationIndex>
+typename PartialPivLU<MatrixType, PermutationIndex>::RealScalar
+PartialPivLU<MatrixType, PermutationIndex>::absDeterminant() const {
+  eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+  return numext::abs(m_lu.diagonal().prod());
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename PartialPivLU<MatrixType, PermutationIndex>::RealScalar
+PartialPivLU<MatrixType, PermutationIndex>::logAbsDeterminant() const {
+  eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+  return m_lu.diagonal().cwiseAbs().array().log().sum();
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename PartialPivLU<MatrixType, PermutationIndex>::Scalar
+PartialPivLU<MatrixType, PermutationIndex>::signDeterminant() const {
+  eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
+  return Scalar(m_det_p) * m_lu.diagonal().array().sign().prod();
+}
+
 /** \returns the matrix represented by the decomposition,
  * i.e., it returns the product: P^{-1} L U.
  * This function is provided for debug purpose. */
@@ -540,8 +643,8 @@
     DstXprType, Inverse<PartialPivLU<MatrixType, PermutationIndex> >,
     internal::assign_op<typename DstXprType::Scalar, typename PartialPivLU<MatrixType, PermutationIndex>::Scalar>,
     Dense2Dense> {
-  typedef PartialPivLU<MatrixType, PermutationIndex> LuType;
-  typedef Inverse<LuType> SrcXprType;
+  using LuType = PartialPivLU<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<LuType>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::assign_op<typename DstXprType::Scalar, typename LuType::Scalar>&) {
     dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
diff --git a/Eigen/src/LU/PartialPivLU_LAPACKE.h b/Eigen/src/LU/PartialPivLU_LAPACKE.h
index 086c3c3..2cccd47 100644
--- a/Eigen/src/LU/PartialPivLU_LAPACKE.h
+++ b/Eigen/src/LU/PartialPivLU_LAPACKE.h
@@ -29,6 +29,7 @@
  *     LU decomposition with partial pivoting based on LAPACKE_?getrf function.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_PARTIALLU_LAPACK_H
 #define EIGEN_PARTIALLU_LAPACK_H
@@ -42,7 +43,7 @@
 
 namespace lapacke_helpers {
 // -------------------------------------------------------------------------------------------------------------------
-//        Generic lapacke partial lu implementation that converts arguments and dispatches to the function above
+//        Generic lapacke partial lu implementation that converts arguments and dispatches to getrf
 // -------------------------------------------------------------------------------------------------------------------
 
 template <typename Scalar, int StorageOrder>
@@ -50,7 +51,6 @@
   /** \internal performs the LU decomposition in-place of the matrix represented */
   static lapack_int blocked_lu(Index rows, Index cols, Scalar* lu_data, Index luStride, lapack_int* row_transpositions,
                                lapack_int& nb_transpositions, lapack_int maxBlockSize = 256) {
-    EIGEN_UNUSED_VARIABLE(maxBlockSize);
     // Set up parameters for getrf
     lapack_int matrix_order = StorageOrder == RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR;
     lapack_int lda = to_lapack(luStride);
@@ -61,6 +61,12 @@
     nb_transpositions = 0;
 
     lapack_int info = getrf(matrix_order, m, n, to_lapack(a), lda, ipiv);
+    if (info == -4) {
+      // High-level LAPACKE may reject NaN inputs before calling LAPACK. Eigen's native path preserves determinant
+      // propagation for these values.
+      return generic_partial_lu_impl<Scalar, StorageOrder, lapack_int, Dynamic>::blocked_lu(
+          rows, cols, lu_data, luStride, row_transpositions, nb_transpositions, maxBlockSize);
+    }
     eigen_assert(info >= 0);
 
     for (int i = 0; i < m; i++) {
diff --git a/Eigen/src/LU/arch/InverseSize4.h b/Eigen/src/LU/arch/InverseSize4.h
index 29c9b03..0ee4774 100644
--- a/Eigen/src/LU/arch/InverseSize4.h
+++ b/Eigen/src/LU/arch/InverseSize4.h
@@ -32,6 +32,7 @@
 // See LEGAL.TXT for all the legal information.
 //
 // TODO: Unify implementations of different data types (i.e. float and double).
+// SPDX-License-Identifier: MPL-2.0
 #ifndef EIGEN_INVERSE_SIZE_4_H
 #define EIGEN_INVERSE_SIZE_4_H
 
@@ -54,9 +55,8 @@
     ResultAlignment = traits<ResultType>::Alignment,
     StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
   };
-  typedef std::conditional_t<(MatrixType::Flags & LinearAccessBit), MatrixType const &,
-                             typename MatrixType::PlainObject>
-      ActualMatrixType;
+  using ActualMatrixType =
+      std::conditional_t<(MatrixType::Flags & LinearAccessBit), const MatrixType &, typename MatrixType::PlainObject>;
 
   static void run(const MatrixType &mat, ResultType &result) {
     ActualMatrixType matrix(mat);
@@ -73,7 +73,7 @@
     //          [C, D]]
     Packet4f A, B, C, D;
 
-    if (!StorageOrdersMatch) {
+    EIGEN_IF_CONSTEXPR (!StorageOrdersMatch) {
       A = vec4f_unpacklo(L1, L2);
       B = vec4f_unpacklo(L3, L4);
       C = vec4f_unpackhi(L1, L2);
@@ -147,7 +147,10 @@
     iC = psub(iC, pmul(vec4f_swizzle2(A, A, 1, 0, 3, 2), vec4f_swizzle2(DC, DC, 2, 1, 2, 1)));
     iC = psub(pmul(B, vec4f_duplane(dC, 0)), iC);
 
-    EIGEN_ALIGN_MAX const float sign_mask[4] = {0.0f, -0.0f, -0.0f, 0.0f};
+    // Built from integer bits: a -0.0f literal may be replaced by +0.0f under fast-math.
+    const float neg_zero = numext::bit_cast<float>(0x80000000u);
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet4f>::alignment)
+    const float sign_mask[4] = {0.0f, neg_zero, neg_zero, 0.0f};
     const Packet4f p4f_sign_PNNP = pload<Packet4f>(sign_mask);
     rd = pxor(rd, p4f_sign_PNNP);
     iA = pmul(iA, rd);
@@ -165,7 +168,7 @@
   }
 };
 
-#if !(defined EIGEN_VECTORIZE_NEON && !(EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG))
+#if !defined(EIGEN_VECTORIZE_NEON) || EIGEN_ARCH_ARM64
 // same algorithm as above, except that each operand is split into
 // halves for two registers to hold.
 template <typename MatrixType, typename ResultType>
@@ -175,9 +178,8 @@
     ResultAlignment = traits<ResultType>::Alignment,
     StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
   };
-  typedef std::conditional_t<(MatrixType::Flags & LinearAccessBit), MatrixType const &,
-                             typename MatrixType::PlainObject>
-      ActualMatrixType;
+  using ActualMatrixType =
+      std::conditional_t<(MatrixType::Flags & LinearAccessBit), const MatrixType &, typename MatrixType::PlainObject>;
 
   static void run(const MatrixType &mat, ResultType &result) {
     ActualMatrixType matrix(mat);
@@ -193,7 +195,7 @@
 
     const double *data = matrix.data();
     const Index stride = matrix.innerStride();
-    if (StorageOrdersMatch) {
+    EIGEN_IF_CONSTEXPR (StorageOrdersMatch) {
       A1 = ploadt<Packet2d, MatrixAlignment>(data + stride * 0);
       B1 = ploadt<Packet2d, MatrixAlignment>(data + stride * 2);
       A2 = ploadt<Packet2d, MatrixAlignment>(data + stride * 4);
@@ -323,8 +325,10 @@
     iC1 = psub(pmul(B1, dC), iC1);
     iC2 = psub(pmul(B2, dC), iC2);
 
-    EIGEN_ALIGN_MAX const double sign_mask1[2] = {0.0, -0.0};
-    EIGEN_ALIGN_MAX const double sign_mask2[2] = {-0.0, 0.0};
+    // Built from integer bits: a -0.0 literal may be replaced by +0.0 under fast-math.
+    const double neg_zero = numext::bit_cast<double>(0x8000000000000000ull);
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2d>::alignment) const double sign_mask1[2] = {0.0, neg_zero};
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet2d>::alignment) const double sign_mask2[2] = {neg_zero, 0.0};
     const Packet2d sign_PN = pload<Packet2d>(sign_mask1);
     const Packet2d sign_NP = pload<Packet2d>(sign_mask2);
     d1 = pxor(rd, sign_PN);
diff --git a/Eigen/src/MetisSupport/InternalHeaderCheck.h b/Eigen/src/MetisSupport/InternalHeaderCheck.h
index 9d34825..0d5e620 100644
--- a/Eigen/src/MetisSupport/InternalHeaderCheck.h
+++ b/Eigen/src/MetisSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_METISSUPPORT_MODULE_H
 #error "Please include Eigen/MetisSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/MetisSupport/MetisSupport.h b/Eigen/src/MetisSupport/MetisSupport.h
index 961c840..77fce86 100644
--- a/Eigen/src/MetisSupport/MetisSupport.h
+++ b/Eigen/src/MetisSupport/MetisSupport.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 #ifndef METIS_SUPPORT_H
 #define METIS_SUPPORT_H
 
@@ -18,8 +19,8 @@
  *
  * If A is the original matrix and Ap is the permuted matrix,
  * the fill-reducing permutation is defined as follows :
- * Row (column) i of A is the matperm(i) row (column) of Ap.
- * WARNING: As computed by METIS, this corresponds to the vector iperm (instead of perm)
+ * Row (column) i of Ap is the matperm(i) row (column) of A.
+ * WARNING: As computed by METIS, this corresponds to the vector perm (instead of iperm)
  */
 template <typename StorageIndex>
 class MetisOrdering {
@@ -100,7 +101,8 @@
     int output_error;
 
     // Call the fill-reducing routine from METIS
-    output_error = METIS_NodeND(&m, m_indexPtr.data(), m_innerIndices.data(), NULL, NULL, perm.data(), iperm.data());
+    output_error =
+        METIS_NodeND(&m, m_indexPtr.data(), m_innerIndices.data(), nullptr, nullptr, perm.data(), iperm.data());
 
     if (output_error != METIS_OK) {
       // FIXME The ordering interface should define a class of possible errors
@@ -117,7 +119,7 @@
   }
 
  protected:
-  IndexVector m_indexPtr;      // Pointer to the adjacenccy list of each row/column
+  IndexVector m_indexPtr;      // Pointer to the adjacency list of each row/column
   IndexVector m_innerIndices;  // Adjacency list
 };
 
diff --git a/Eigen/src/OrderingMethods/Amd.h b/Eigen/src/OrderingMethods/Amd.h
index 0b0bf02..3027186 100644
--- a/Eigen/src/OrderingMethods/Amd.h
+++ b/Eigen/src/OrderingMethods/Amd.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 NOTE: this routine has been adapted from the CSparse library:
@@ -32,18 +33,6 @@
 inline T amd_flip(const T& i) {
   return -i - 2;
 }
-template <typename T>
-inline T amd_unflip(const T& i) {
-  return i < 0 ? amd_flip(i) : i;
-}
-template <typename T0, typename T1>
-inline bool amd_marked(const T0* w, const T1& j) {
-  return w[j] < 0;
-}
-template <typename T0, typename T1>
-inline void amd_mark(const T0* w, const T1& j) {
-  return w[j] = amd_flip(w[j]);
-}
 
 /* clear w */
 template <typename StorageIndex>
@@ -310,7 +299,7 @@
         degree[i] = std::min<StorageIndex>(degree[i], d); /* update degree(i) */
         Ci[pn] = Ci[p3];                                  /* move first node to end */
         Ci[p3] = Ci[p1];                                  /* move 1st el. to end of Ei */
-        Ci[p1] = k;                                       /* add k as 1st element in of Ei */
+        Ci[p1] = k;                                       /* add k as 1st element in Ei */
         len[i] = pn - p1 + 1;                             /* new len of adj. list of node i */
         h %= n;                                           /* finalize hash of i */
         next[i] = hhead[h];                               /* place i in hash bucket */
diff --git a/Eigen/src/OrderingMethods/Eigen_Colamd.h b/Eigen/src/OrderingMethods/Eigen_Colamd.h
index 02be282..7259229 100644
--- a/Eigen/src/OrderingMethods/Eigen_Colamd.h
+++ b/Eigen/src/OrderingMethods/Eigen_Colamd.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This file is modified from the colamd/symamd library. The copyright is below
 
@@ -53,7 +54,7 @@
 /* Ensure that debugging is turned off: */
 #ifndef COLAMD_NDEBUG
 #define COLAMD_NDEBUG
-#endif /* NDEBUG */
+#endif /* COLAMD_NDEBUG */
 
 /* ========================================================================== */
 /* === Knob and statistics definitions ====================================== */
@@ -255,7 +256,7 @@
  * Returns recommended value of Alen for use by colamd.
  * Returns -1 if any input argument is negative.
  * The use of this routine or macro is optional.
- * Note that the macro uses its arguments   more than once,
+ * Note that the macro uses its arguments more than once,
  * so be careful for side effects, if you pass expressions as arguments to COLAMD_RECOMMENDED.
  *
  * \param nnz nonzeros in A
diff --git a/Eigen/src/OrderingMethods/InternalHeaderCheck.h b/Eigen/src/OrderingMethods/InternalHeaderCheck.h
index 713c447..b2357da 100644
--- a/Eigen/src/OrderingMethods/InternalHeaderCheck.h
+++ b/Eigen/src/OrderingMethods/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_ORDERINGMETHODS_MODULE_H
 #error "Please include Eigen/OrderingMethods instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/OrderingMethods/Ordering.h b/Eigen/src/OrderingMethods/Ordering.h
index 8ede4de..d7f8e7f 100644
--- a/Eigen/src/OrderingMethods/Ordering.h
+++ b/Eigen/src/OrderingMethods/Ordering.h
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MPL-2.0
 
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
@@ -16,62 +17,54 @@
 #include "Eigen_Colamd.h"
 
 namespace Eigen {
-namespace internal {
-
-/** \internal
- * \ingroup OrderingMethods_Module
- * \param[in] A the input non-symmetric matrix
- * \param[out] symmat the symmetric pattern A^T+A from the input matrix \a A.
- * FIXME: only the sparsity pattern should be used here; values should be ignored.
- */
-template <typename MatrixType>
-void ordering_helper_at_plus_a(const MatrixType& A, MatrixType& symmat) {
-  MatrixType C;
-  C = A.transpose();  // NOTE: Could be  costly
-  for (int i = 0; i < C.rows(); i++) {
-    for (typename MatrixType::InnerIterator it(C, i); it; ++it) it.valueRef() = typename MatrixType::Scalar(0);
-  }
-  symmat = C + A;
-}
-
-}  // namespace internal
 
 /** \ingroup OrderingMethods_Module
  * \class AMDOrdering
  *
  * Functor computing the \em approximate \em minimum \em degree ordering
- * If the matrix is not structurally symmetric, an ordering of A^T+A is computed
+ * If the matrix is not structurally symmetric, an ordering of A^T+A is computed.
+ * Only the sparsity pattern of the input is read — scalar values are not.
  * \tparam  StorageIndex The type of indices of the matrix
  * \sa COLAMDOrdering
  */
 template <typename StorageIndex>
 class AMDOrdering {
  public:
-  typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+  using PermutationType = PermutationMatrix<Dynamic, Dynamic, StorageIndex>;
 
-  /** Compute the permutation vector from a sparse matrix
-   * This routine is much faster if the input matrix is column-major
+  /** Compute the permutation vector from a sparse matrix.
+   * Only the sparsity pattern of \a mat is read; scalar values are not.
+   * This routine is much faster if the input matrix is column-major.
    */
   template <typename MatrixType>
   void operator()(const MatrixType& mat, PermutationType& perm) const {
-    // Compute the symmetric pattern
-    SparseMatrix<typename MatrixType::Scalar, ColMajor, StorageIndex> symm;
-    internal::ordering_helper_at_plus_a(mat, symm);
-
-    // Call the AMD routine
-    // m_mat.prune(keep_diag());
+    // AMD only reads the sparsity pattern. Build a column-major view of mat,
+    // then materialize \c pattern(mat + mat^T) directly into a
+    // SparseMatrix<signed char> (1-byte placeholder values), bypassing
+    // Eigen's generic transpose + sparse-sum evaluators.
+    Matrix<StorageIndex, Dynamic, 1> outer_buf;
+    Matrix<StorageIndex, Dynamic, 1> inner_buf;
+    internal::SparsityPatternRef<StorageIndex> pat = internal::make_col_major_pattern_ref(mat, outer_buf, inner_buf);
+    SparseMatrix<signed char, ColMajor, StorageIndex> symm;
+    internal::materialize_at_plus_a_pattern(pat, symm);
     internal::minimum_degree_ordering(symm, perm);
   }
 
-  /** Compute the permutation with a selfadjoint matrix */
+  /** Compute the permutation with a selfadjoint matrix.
+   * Only the sparsity pattern is used; scalar values are not.
+   */
   template <typename SrcType, unsigned int SrcUpLo>
   void operator()(const SparseSelfAdjointView<SrcType, SrcUpLo>& mat, PermutationType& perm) const {
-    SparseMatrix<typename SrcType::Scalar, ColMajor, StorageIndex> C;
-    C = mat;
-
-    // Call the AMD routine
-    // m_mat.prune(keep_diag()); //Remove the diagonal elements
-    internal::minimum_degree_ordering(C, perm);
+    // Build a column-major pattern view of the underlying matrix and expand
+    // its UpLo triangle to the full symmetric pattern in one pass, bypassing
+    // Eigen's generic selfadjointView assignment evaluator.
+    Matrix<StorageIndex, Dynamic, 1> outer_buf;
+    Matrix<StorageIndex, Dynamic, 1> inner_buf;
+    internal::SparsityPatternRef<StorageIndex> pat =
+        internal::make_col_major_pattern_ref(mat.matrix(), outer_buf, inner_buf);
+    SparseMatrix<signed char, ColMajor, StorageIndex> symm;
+    internal::materialize_selfadjoint_pattern<SrcUpLo>(pat, symm);
+    internal::minimum_degree_ordering(symm, perm);
   }
 };
 
@@ -86,7 +79,7 @@
 template <typename StorageIndex>
 class NaturalOrdering {
  public:
-  typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+  using PermutationType = PermutationMatrix<Dynamic, Dynamic, StorageIndex>;
 
   /** Compute the permutation vector from a column-major sparse matrix */
   template <typename MatrixType>
@@ -100,45 +93,67 @@
  *
  * \tparam  StorageIndex The type of indices of the matrix
  *
- * Functor computing the \em column \em approximate \em minimum \em degree ordering
- * The matrix should be in column-major and \b compressed format (see SparseMatrix::makeCompressed()).
+ * Functor computing the \em column \em approximate \em minimum \em degree ordering.
+ * Only the sparsity pattern of the input is read — scalar values are not.
  */
 template <typename StorageIndex>
 class COLAMDOrdering {
  public:
-  typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
-  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
+  using PermutationType = PermutationMatrix<Dynamic, Dynamic, StorageIndex>;
+  using IndexVector = Matrix<StorageIndex, Dynamic, 1>;
 
-  /** Compute the permutation vector \a perm form the sparse matrix \a mat
-   * \warning The input sparse matrix \a mat must be in compressed mode (see SparseMatrix::makeCompressed()).
-   */
+  /** Compute the permutation vector \a perm from the sparse matrix \a mat. */
   template <typename MatrixType>
   void operator()(const MatrixType& mat, PermutationType& perm) const {
-    eigen_assert(mat.isCompressed() &&
-                 "COLAMDOrdering requires a sparse matrix in compressed mode. Call .makeCompressed() before passing it "
-                 "to COLAMDOrdering");
+    using MatrixStorageIndex = typename MatrixType::StorageIndex;
+    Matrix<MatrixStorageIndex, Dynamic, 1> outer_buf, inner_buf;
+    internal::SparsityPatternRef<MatrixStorageIndex> pat =
+        internal::make_col_major_pattern_ref(mat, outer_buf, inner_buf);
+    const StorageIndex m = internal::convert_index<StorageIndex>(pat.innerSize);
+    const StorageIndex n = internal::convert_index<StorageIndex>(pat.outerSize);
+    // Accumulate in Index — Eigen's contract is that any valid nnz fits there
+    // (mat.nonZeros() returns Index), so the sum can't overflow. One
+    // bounds-checked narrow to StorageIndex at the end catches the only real
+    // overflow case (total > StorageIndex range).
+    Index total_nnz = 0;
+    for (Index j = 0; j < pat.outerSize; ++j) total_nnz += pat.nonZeros(j);
+    const StorageIndex nnz = internal::convert_index<StorageIndex>(total_nnz);
 
-    StorageIndex m = StorageIndex(mat.rows());
-    StorageIndex n = StorageIndex(mat.cols());
-    StorageIndex nnz = StorageIndex(mat.nonZeros());
-    // Get the recommended value of Alen to be used by colamd
     StorageIndex Alen = internal::Colamd::recommended(nnz, m, n);
-    // Set the default parameters
     double knobs[internal::Colamd::NKnobs];
     StorageIndex stats[internal::Colamd::NStats];
     internal::Colamd::set_defaults(knobs);
 
+    // Colamd writes into A[] in place and needs a contiguous CSC layout, so
+    // always compact per column — handles both compressed and uncompressed
+    // sources uniformly via SparsityPatternRef::nonZeros(j).
     IndexVector p(n + 1), A(Alen);
-    for (StorageIndex i = 0; i <= n; i++) p(i) = mat.outerIndexPtr()[i];
-    for (StorageIndex i = 0; i < nnz; i++) A(i) = mat.innerIndexPtr()[i];
-    // Call Colamd routine to compute the ordering
+    p(0) = 0;
+    for (StorageIndex j = 0; j < n; ++j) {
+      const Index nz = pat.nonZeros(j);
+      const MatrixStorageIndex* src = pat.inner + pat.outer[j];
+      copy_colamd_indices(src, nz, A.data() + p(j), std::is_same<MatrixStorageIndex, StorageIndex>());
+      p(j + 1) = p(j) + static_cast<StorageIndex>(nz);
+    }
+
     StorageIndex info = internal::Colamd::compute_ordering(m, n, Alen, A.data(), p.data(), knobs, stats);
     EIGEN_UNUSED_VARIABLE(info);
-    eigen_assert(info && "COLAMD failed ");
+    eigen_assert(info && "COLAMD failed");
 
     perm.resize(n);
     for (StorageIndex i = 0; i < n; i++) perm.indices()(p(i)) = i;
   }
+
+ private:
+  template <typename SrcStorageIndex>
+  static void copy_colamd_indices(const SrcStorageIndex* src, Index nz, StorageIndex* dst, std::true_type) {
+    std::copy_n(src, nz, dst);
+  }
+
+  template <typename SrcStorageIndex>
+  static void copy_colamd_indices(const SrcStorageIndex* src, Index nz, StorageIndex* dst, std::false_type) {
+    for (Index k = 0; k < nz; ++k) dst[k] = internal::convert_index<StorageIndex>(src[k]);
+  }
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/PaStiXSupport/InternalHeaderCheck.h b/Eigen/src/PaStiXSupport/InternalHeaderCheck.h
index f588e50..5365e09 100644
--- a/Eigen/src/PaStiXSupport/InternalHeaderCheck.h
+++ b/Eigen/src/PaStiXSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_PASTIXSUPPORT_MODULE_H
 #error "Please include Eigen/PaStiXSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/PaStiXSupport/PaStiXSupport.h b/Eigen/src/PaStiXSupport/PaStiXSupport.h
index fb75133..52b893e 100644
--- a/Eigen/src/PaStiXSupport/PaStiXSupport.h
+++ b/Eigen/src/PaStiXSupport/PaStiXSupport.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PASTIXSUPPORT_H
 #define EIGEN_PASTIXSUPPORT_H
@@ -70,12 +71,12 @@
 inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, float *vals,
                          int *perm, int *invp, float *x, int nbrhs, int *iparm, double *dparm) {
   if (n == 0) {
-    ptr = NULL;
-    idx = NULL;
-    vals = NULL;
+    ptr = nullptr;
+    idx = nullptr;
+    vals = nullptr;
   }
   if (nbrhs == 0) {
-    x = NULL;
+    x = nullptr;
     nbrhs = 1;
   }
   s_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm);
@@ -84,12 +85,12 @@
 inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, double *vals,
                          int *perm, int *invp, double *x, int nbrhs, int *iparm, double *dparm) {
   if (n == 0) {
-    ptr = NULL;
-    idx = NULL;
-    vals = NULL;
+    ptr = nullptr;
+    idx = nullptr;
+    vals = nullptr;
   }
   if (nbrhs == 0) {
-    x = NULL;
+    x = nullptr;
     nbrhs = 1;
   }
   d_pastix(pastix_data, pastix_comm, n, ptr, idx, vals, perm, invp, x, nbrhs, iparm, dparm);
@@ -99,12 +100,12 @@
                          std::complex<float> *vals, int *perm, int *invp, std::complex<float> *x, int nbrhs, int *iparm,
                          double *dparm) {
   if (n == 0) {
-    ptr = NULL;
-    idx = NULL;
-    vals = NULL;
+    ptr = nullptr;
+    idx = nullptr;
+    vals = nullptr;
   }
   if (nbrhs == 0) {
-    x = NULL;
+    x = nullptr;
     nbrhs = 1;
   }
   c_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_COMPLEX *>(vals), perm, invp,
@@ -115,19 +116,19 @@
                          std::complex<double> *vals, int *perm, int *invp, std::complex<double> *x, int nbrhs,
                          int *iparm, double *dparm) {
   if (n == 0) {
-    ptr = NULL;
-    idx = NULL;
-    vals = NULL;
+    ptr = nullptr;
+    idx = nullptr;
+    vals = nullptr;
   }
   if (nbrhs == 0) {
-    x = NULL;
+    x = nullptr;
     nbrhs = 1;
   }
   z_pastix(pastix_data, pastix_comm, n, ptr, idx, reinterpret_cast<PASTIX_DCOMPLEX *>(vals), perm, invp,
            reinterpret_cast<PASTIX_DCOMPLEX *>(x), nbrhs, iparm, dparm);
 }
 
-// Convert the matrix  to Fortran-style Numbering
+// Convert the matrix to Fortran-style Numbering
 template <typename MatrixType>
 void c_to_fortran_numbering(MatrixType &mat) {
   if (!(mat.outerIndexPtr()[0])) {
@@ -136,21 +137,10 @@
     for (i = 0; i < mat.nonZeros(); ++i) ++mat.innerIndexPtr()[i];
   }
 }
-
-// Convert to C-style Numbering
-template <typename MatrixType>
-void fortran_to_c_numbering(MatrixType &mat) {
-  // Check the Numbering
-  if (mat.outerIndexPtr()[0] == 1) {  // Convert to C-style numbering
-    int i;
-    for (i = 0; i <= mat.rows(); ++i) --mat.outerIndexPtr()[i];
-    for (i = 0; i < mat.nonZeros(); ++i) --mat.innerIndexPtr()[i];
-  }
-}
 }  // namespace internal
 
 // This is the base class to interface with PaStiX functions.
-// Users should not used this class directly.
+// Users should not use this class directly.
 template <class Derived>
 class PastixBase : public SparseSolverBase<Derived> {
  protected:
@@ -328,7 +318,6 @@
 
 template <class Derived>
 void PastixBase<Derived>::factorize(ColSpMatrix &mat) {
-  //   if(&m_cpyMat != &mat) m_cpyMat = mat;
   eigen_assert(m_analysisIsOk && "The analysis phase should be called before the factorization phase");
   m_iparm(IPARM_START_TASK) = API_TASK_NUMFACT;
   m_iparm(IPARM_END_TASK) = API_TASK_NUMFACT;
@@ -451,7 +440,7 @@
   }
 
   void grabMatrix(const MatrixType &matrix, ColSpMatrix &out) {
-    if (IsStrSym)
+    EIGEN_IF_CONSTEXPR (IsStrSym)
       out = matrix;
     else {
       if (!m_structureIsUptodate) {
@@ -487,7 +476,8 @@
  * The vectors or matrices X and B can be either dense or sparse
  *
  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
- * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+ * \tparam UpLo The part of the matrix to use : Lower or Upper. This parameter has no default: either part is accepted
+ *              and copied to the lower part required by PaStiX.
  *
  * \implsparsesolverconcept
  *
@@ -562,7 +552,8 @@
  * The vectors or matrices X and B can be either dense or sparse
  *
  * \tparam MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
- * \tparam UpLo The part of the matrix to use : Lower or Upper. The default is Lower as required by PaStiX
+ * \tparam UpLo The part of the matrix to use : Lower or Upper. This parameter has no default: either part is accepted
+ *              and copied to the lower part required by PaStiX.
  *
  * \implsparsesolverconcept
  *
@@ -629,4 +620,7 @@
 
 }  // end namespace Eigen
 
+#undef PASTIX_COMPLEX
+#undef PASTIX_DCOMPLEX
+
 #endif
diff --git a/Eigen/src/PardisoSupport/InternalHeaderCheck.h b/Eigen/src/PardisoSupport/InternalHeaderCheck.h
index 8ef33f0..bd5c3bd 100644
--- a/Eigen/src/PardisoSupport/InternalHeaderCheck.h
+++ b/Eigen/src/PardisoSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_PARDISOSUPPORT_MODULE_H
 #error "Please include Eigen/PardisoSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/PardisoSupport/PardisoSupport.h b/Eigen/src/PardisoSupport/PardisoSupport.h
index 90df3cd..c946e28 100644
--- a/Eigen/src/PardisoSupport/PardisoSupport.h
+++ b/Eigen/src/PardisoSupport/PardisoSupport.h
@@ -28,6 +28,7 @@
  *   Content : Eigen bindings to Intel(R) MKL PARDISO
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_PARDISOSUPPORT_H
 #define EIGEN_PARDISOSUPPORT_H
@@ -175,14 +176,14 @@
     {
       internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, -1,
                                                         internal::convert_index<StorageIndex>(m_size), 0, 0, 0,
-                                                        m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+                                                        m_perm.data(), 0, m_iparm.data(), m_msglvl, nullptr, nullptr);
       m_isInitialized = false;
     }
   }
 
   void pardisoInit(int type) {
     m_type = type;
-    bool symmetric = std::abs(m_type) < 10;
+    bool symmetric = numext::abs(m_type) < 10;
     m_iparm[0] = 1;                   // No solver default
     m_iparm[1] = 2;                   // use Metis for the ordering
     m_iparm[2] = 0;                   // Reserved. Set to zero. (Was number of processors / OMP_NUM_THREADS.)
@@ -254,7 +255,7 @@
   Index error;
   error = internal::pardiso_run_selector<StorageIndex>::run(
       m_pt, 1, 1, m_type, 12, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
-      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, nullptr, nullptr);
   manageErrorCode(error);
   m_analysisIsOk = m_info == Eigen::Success;
   m_factorizationIsOk = m_info == Eigen::Success;
@@ -274,7 +275,7 @@
   Index error;
   error = internal::pardiso_run_selector<StorageIndex>::run(
       m_pt, 1, 1, m_type, 11, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
-      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, nullptr, nullptr);
 
   manageErrorCode(error);
   m_analysisIsOk = m_info == Eigen::Success;
@@ -293,7 +294,7 @@
   Index error;
   error = internal::pardiso_run_selector<StorageIndex>::run(
       m_pt, 1, 1, m_type, 22, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
-      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, NULL, NULL);
+      m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl, nullptr, nullptr);
 
   manageErrorCode(error);
   m_factorizationIsOk = m_info == Eigen::Success;
@@ -309,7 +310,6 @@
     return;
   }
 
-  // Index n = m_matrix.rows();
   Index nrhs = Index(b.cols());
   eigen_assert(m_size == b.rows());
   eigen_assert(((MatrixBase<BDerived>::Flags & RowMajorBit) == 0 || nrhs == 1) &&
@@ -396,7 +396,7 @@
  * \brief A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library
  *
  * This class allows to solve for A.X = B sparse linear problems via a LL^T Cholesky factorization
- * using the Intel MKL PARDISO library. The sparse matrix A must be selfajoint and positive definite.
+ * using the Intel MKL PARDISO library. The sparse matrix A must be selfadjoint and positive definite.
  * The vectors or matrices X and B can be either dense or sparse.
  *
  * By default, it runs in in-core mode. To enable PARDISO's out-of-core feature, set:
@@ -447,7 +447,7 @@
  * \brief A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library
  *
  * This class allows to solve for A.X = B sparse linear problems via a LDL^T Cholesky factorization
- * using the Intel MKL PARDISO library. The sparse matrix A is assumed to be selfajoint and positive definite.
+ * using the Intel MKL PARDISO library. The sparse matrix A is assumed to be selfadjoint and positive definite.
  * For complex matrices, A can also be symmetric only, see the \a Options template parameter.
  * The vectors or matrices X and B can be either dense or sparse.
  *
diff --git a/Eigen/src/QR/ColPivHouseholderQR.h b/Eigen/src/QR/ColPivHouseholderQR.h
index 3695078..8b25cd6 100644
--- a/Eigen/src/QR/ColPivHouseholderQR.h
+++ b/Eigen/src/QR/ColPivHouseholderQR.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
 #define EIGEN_COLPIVOTINGHOUSEHOLDERQR_H
@@ -19,9 +20,9 @@
 namespace internal {
 template <typename MatrixType_, typename PermutationIndex_>
 struct traits<ColPivHouseholderQR<MatrixType_, PermutationIndex_>> : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef PermutationIndex_ PermutationIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using PermutationIndex = PermutationIndex_;
   enum { Flags = 0 };
 };
 
@@ -51,26 +52,38 @@
  * \sa MatrixBase::colPivHouseholderQr()
  */
 template <typename MatrixType_, typename PermutationIndex_>
-class ColPivHouseholderQR : public SolverBase<ColPivHouseholderQR<MatrixType_, PermutationIndex_>> {
+class ColPivHouseholderQR : public SolverBase<ColPivHouseholderQR<MatrixType_, PermutationIndex_>>,
+                            public RankRevealingBase<ColPivHouseholderQR<MatrixType_, PermutationIndex_>> {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<ColPivHouseholderQR> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<ColPivHouseholderQR>;
+  using RankRevealingBase_ = RankRevealingBase<ColPivHouseholderQR>;
   friend class SolverBase<ColPivHouseholderQR>;
-  typedef PermutationIndex_ PermutationIndex;
+  friend class RankRevealingBase<ColPivHouseholderQR>;
+  using RankRevealingBase_::dimensionOfKernel;
+  using RankRevealingBase_::isInjective;
+  using RankRevealingBase_::isInvertible;
+  using RankRevealingBase_::isSurjective;
+  using RankRevealingBase_::maxPivot;
+  using RankRevealingBase_::nonzeroPivots;
+  using RankRevealingBase_::rank;
+  using RankRevealingBase_::setThreshold;
+  using RankRevealingBase_::threshold;
+  using PermutationIndex = PermutationIndex_;
   EIGEN_GENERIC_PUBLIC_INTERFACE(ColPivHouseholderQR)
 
   enum {
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
-  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
-  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex> PermutationType;
-  typedef typename internal::plain_row_type<MatrixType, PermutationIndex>::type IntRowVectorType;
-  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
-  typedef typename internal::plain_row_type<MatrixType, RealScalar>::type RealRowVectorType;
-  typedef HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>
-      HouseholderSequenceType;
-  typedef typename MatrixType::PlainObject PlainObject;
+  using HCoeffsType = typename internal::plain_diag_type<MatrixType>::type;
+  using PermutationType = PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex>;
+  using IntRowVectorType = typename internal::plain_row_type<MatrixType, PermutationIndex>::type;
+  using RowVectorType = typename internal::plain_row_type<MatrixType>::type;
+  using RealRowVectorType = typename internal::plain_row_type<MatrixType, RealScalar>::type;
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>;
+  using PlainObject = typename MatrixType::PlainObject;
 
  private:
   void init(Index rows, Index cols) {
@@ -82,7 +95,6 @@
     m_colNormsUpdated.resize(cols);
     m_colNormsDirect.resize(cols);
     m_isInitialized = false;
-    m_usePrescribedThreshold = false;
   }
 
  public:
@@ -100,8 +112,7 @@
         m_temp(),
         m_colNormsUpdated(),
         m_colNormsDirect(),
-        m_isInitialized(false),
-        m_usePrescribedThreshold(false) {}
+        m_isInitialized(false) {}
 
   /** \brief Default Constructor with memory preallocation
    *
@@ -252,65 +263,10 @@
    */
   typename MatrixType::Scalar signDeterminant() const;
 
-  /** \returns the rank of the matrix of which *this is the QR decomposition.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline Index rank() const {
+  /** \returns the absolute value of the i-th pivot coefficient (for RankRevealingBase). */
+  RealScalar pivotCoeff(Index i) const {
     using std::abs;
-    eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-    RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
-    Index result = 0;
-    for (Index i = 0; i < m_nonzero_pivots; ++i) result += (abs(m_qr.coeff(i, i)) > premultiplied_threshold);
-    return result;
-  }
-
-  /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline Index dimensionOfKernel() const {
-    eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-    return cols() - rank();
-  }
-
-  /** \returns true if the matrix of which *this is the QR decomposition represents an injective
-   *          linear map, i.e. has trivial kernel; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isInjective() const {
-    eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-    return rank() == cols();
-  }
-
-  /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
-   *          linear map; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isSurjective() const {
-    eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-    return rank() == rows();
-  }
-
-  /** \returns true if the matrix of which *this is the QR decomposition is invertible.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isInvertible() const {
-    eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-    return isInjective() && isSurjective();
+    return abs(m_qr.coeff(i, i));
   }
 
   /** \returns the inverse of the matrix of which *this is the QR decomposition.
@@ -332,72 +288,6 @@
    */
   const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
 
-  /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
-   * who need to determine when pivots are to be considered nonzero. This is not used for the
-   * QR decomposition itself.
-   *
-   * When it needs to get the threshold value, Eigen calls threshold(). By default, this
-   * uses a formula to automatically determine a reasonable threshold.
-   * Once you have called the present method setThreshold(const RealScalar&),
-   * your value is used instead.
-   *
-   * \param threshold The new value to use as the threshold.
-   *
-   * A pivot will be considered nonzero if its absolute value is strictly greater than
-   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
-   * where maxpivot is the biggest pivot.
-   *
-   * If you want to come back to the default behavior, call setThreshold(Default_t)
-   */
-  ColPivHouseholderQR& setThreshold(const RealScalar& threshold) {
-    m_usePrescribedThreshold = true;
-    m_prescribedThreshold = threshold;
-    return *this;
-  }
-
-  /** Allows to come back to the default behavior, letting Eigen use its default formula for
-   * determining the threshold.
-   *
-   * You should pass the special object Eigen::Default as parameter here.
-   * \code qr.setThreshold(Eigen::Default); \endcode
-   *
-   * See the documentation of setThreshold(const RealScalar&).
-   */
-  ColPivHouseholderQR& setThreshold(Default_t) {
-    m_usePrescribedThreshold = false;
-    return *this;
-  }
-
-  /** Returns the threshold that will be used by certain methods such as rank().
-   *
-   * See the documentation of setThreshold(const RealScalar&).
-   */
-  RealScalar threshold() const {
-    eigen_assert(m_isInitialized || m_usePrescribedThreshold);
-    return m_usePrescribedThreshold ? m_prescribedThreshold
-                                    // Higham's backward error bound for Householder QR (Theorem 19.4) is
-                                    // ||ΔA||₂ ≤ c·min(m,n)·u·||A||₂. The factor of 4 covers the
-                                    // constant c (typically 3–6 worst-case, ~1 probabilistically).
-                                    : NumTraits<Scalar>::epsilon() * RealScalar(4 * m_qr.diagonalSize());
-  }
-
-  /** \returns the number of nonzero pivots in the QR decomposition.
-   * Here nonzero is meant in the exact sense, not in a fuzzy sense.
-   * So that notion isn't really intrinsically interesting, but it is
-   * still useful when implementing algorithms.
-   *
-   * \sa rank()
-   */
-  inline Index nonzeroPivots() const {
-    eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-    return m_nonzero_pivots;
-  }
-
-  /** \returns the absolute value of the biggest pivot, i.e. the biggest
-   *          diagonal coefficient of R.
-   */
-  RealScalar maxPivot() const { return m_maxpivot; }
-
   /** \brief Reports whether the QR factorization was successful.
    *
    * \note This function always returns \c Success. It is provided for compatibility
@@ -418,7 +308,7 @@
 #endif
 
  protected:
-  friend class CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>;
+  friend class internal::CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, ColPivHouseholderQR>;
 
   EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
 
@@ -431,9 +321,7 @@
   RowVectorType m_temp;
   RealRowVectorType m_colNormsUpdated;
   RealRowVectorType m_colNormsDirect;
-  bool m_isInitialized, m_usePrescribedThreshold;
-  RealScalar m_prescribedThreshold, m_maxpivot;
-  Index m_nonzero_pivots;
+  bool m_isInitialized;
   Index m_det_p;
 };
 
@@ -502,21 +390,16 @@
   m_colsTranspositions.resize(m_qr.cols());
   Index number_of_transpositions = 0;
 
-  m_colNormsUpdated.resize(cols);
-  m_colNormsDirect.resize(cols);
-  for (Index k = 0; k < cols; ++k) {
-    // colNormsDirect(k) caches the most recent directly computed norm of
-    // column k.
-    m_colNormsDirect.coeffRef(k) = m_qr.col(k).norm();
-    m_colNormsUpdated.coeffRef(k) = m_colNormsDirect.coeffRef(k);
-  }
+  // m_colNormsDirect caches the most recent directly computed column norms.
+  m_colNormsDirect = m_qr.colwise().norm();
+  m_colNormsUpdated = m_colNormsDirect;
 
   RealScalar threshold_helper =
       numext::abs2<RealScalar>(m_colNormsUpdated.maxCoeff() * NumTraits<RealScalar>::epsilon()) / RealScalar(rows);
   RealScalar norm_downdate_threshold = numext::sqrt(NumTraits<RealScalar>::epsilon());
 
-  m_nonzero_pivots = size;  // the generic case is that in which all pivots are nonzero (invertible case)
-  m_maxpivot = RealScalar(0);
+  this->m_nonzero_pivots = size;  // the generic case is that in which all pivots are nonzero (invertible case)
+  this->m_maxpivot = RealScalar(0);
 
   for (Index k = 0; k < size; ++k) {
     // first, we look up in our table m_colNormsUpdated which column has the biggest norm
@@ -526,7 +409,8 @@
 
     // Track the number of meaningful pivots but do not stop the decomposition to make
     // sure that the initial matrix is properly reproduced. See bug 941.
-    if (m_nonzero_pivots == size && biggest_col_sq_norm < threshold_helper * RealScalar(rows - k)) m_nonzero_pivots = k;
+    if (this->m_nonzero_pivots == size && biggest_col_sq_norm < threshold_helper * RealScalar(rows - k))
+      this->m_nonzero_pivots = k;
 
     // apply the transposition to the columns
     m_colsTranspositions.coeffRef(k) = static_cast<PermutationIndex>(biggest_col_index);
@@ -545,7 +429,7 @@
     m_qr.coeffRef(k, k) = beta;
 
     // remember the maximum absolute value of diagonal coefficients
-    if (abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+    if (abs(beta) > this->m_maxpivot) this->m_maxpivot = abs(beta);
 
     // apply the householder transformation
     m_qr.bottomRightCorner(rows - k, cols - k - 1)
@@ -576,7 +460,7 @@
   }
 
   m_colsPermutation.setIdentity(cols);
-  for (Index k = 0; k < size /*m_nonzero_pivots*/; ++k)
+  for (Index k = 0; k < size; ++k)
     m_colsPermutation.applyTranspositionOnTheRight(k, static_cast<Index>(m_colsTranspositions.coeff(k)));
 
   m_det_p = (number_of_transpositions % 2) ? -1 : 1;
@@ -639,8 +523,8 @@
                   internal::assign_op<typename DstXprType::Scalar,
                                       typename ColPivHouseholderQR<MatrixType, PermutationIndex>::Scalar>,
                   Dense2Dense> {
-  typedef ColPivHouseholderQR<MatrixType, PermutationIndex> QrType;
-  typedef Inverse<QrType> SrcXprType;
+  using QrType = ColPivHouseholderQR<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<QrType>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::assign_op<typename DstXprType::Scalar, typename QrType::Scalar>&) {
     dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
diff --git a/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h b/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
index 881bc3c..2c1f799 100644
--- a/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
+++ b/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
@@ -30,6 +30,7 @@
  *    LAPACKE_?geqp3 function.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
 #define EIGEN_COLPIVOTINGHOUSEHOLDERQR_LAPACKE_H
@@ -70,7 +71,7 @@
   typedef typename MatrixType::Scalar Scalar;
   typedef typename MatrixType::RealScalar RealScalar;
   typedef typename internal::lapacke_helpers::translate_type_imp<Scalar>::type LapackeType;
-  static constexpr int LapackeStorage = MatrixType::IsRowMajor ? (LAPACK_ROW_MAJOR) : (LAPACK_COL_MAJOR);
+  static constexpr int LapackeStorage = MatrixType::IsRowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR;
 
   typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
   typedef PermutationMatrix<Dynamic, Dynamic, lapack_int> PermutationType;
@@ -106,7 +107,7 @@
     colsPermutation.indices().array() -= 1;
     det_p = colsPermutation.determinant();
     isInitialized = true;
-  };
+  }
 
   static void init(Index rows, Index cols, HCoeffsType& hCoeffs, PermutationType& colsPermutation,
                    bool& usePrescribedThreshold, bool& isInitialized) {
@@ -157,6 +158,10 @@
 COLPIVQR_LAPACKE(MatrixXcfR)
 COLPIVQR_LAPACKE(MatrixXcdR)
 
+#undef COLPIVQR_LAPACKE
+#undef COLPIVQR_LAPACKE_INIT
+#undef COLPIVQR_LAPACKE_COMPUTEINPLACE
+
 #endif
 }  // end namespace Eigen
 
diff --git a/Eigen/src/QR/CompleteOrthogonalDecomposition.h b/Eigen/src/QR/CompleteOrthogonalDecomposition.h
index 3a5be59..8b11aec 100644
--- a/Eigen/src/QR/CompleteOrthogonalDecomposition.h
+++ b/Eigen/src/QR/CompleteOrthogonalDecomposition.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
 #define EIGEN_COMPLETEORTHOGONALDECOMPOSITION_H
@@ -16,375 +17,160 @@
 namespace Eigen {
 
 namespace internal {
+
+template <typename MatrixType_, typename PermutationIndex_, template <typename, typename> class RankRevealingQR_>
+class CompleteOrthogonalDecompositionImpl;
+
+template <typename MatrixType_, typename PermutationIndex_, template <typename, typename> class RankRevealingQR_>
+struct traits<CompleteOrthogonalDecompositionImpl<MatrixType_, PermutationIndex_, RankRevealingQR_>>
+    : traits<MatrixType_> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using PermutationIndex = PermutationIndex_;
+  enum { Flags = 0 };
+};
+
 template <typename MatrixType_, typename PermutationIndex_>
 struct traits<CompleteOrthogonalDecomposition<MatrixType_, PermutationIndex_>> : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef PermutationIndex_ PermutationIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using PermutationIndex = PermutationIndex_;
+  enum { Flags = 0 };
+};
+
+template <typename MatrixType_, typename PermutationIndex_>
+struct traits<RandCompleteOrthogonalDecomposition<MatrixType_, PermutationIndex_>> : traits<MatrixType_> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using PermutationIndex = PermutationIndex_;
   enum { Flags = 0 };
 };
 
 }  // end namespace internal
 
-/** \ingroup QR_Module
+namespace internal {
+
+/** \internal
  *
- * \class CompleteOrthogonalDecomposition
+ * \class CompleteOrthogonalDecompositionImpl
  *
- * \brief Complete orthogonal decomposition (COD) of a matrix.
+ * \brief Implementation backbone for CompleteOrthogonalDecomposition and
+ * RandCompleteOrthogonalDecomposition.
  *
- * \tparam MatrixType_ the type of the matrix of which we are computing the COD.
- *
- * This class performs a rank-revealing complete orthogonal decomposition of a
- * matrix  \b A into matrices \b P, \b Q, \b T, and \b Z such that
- * \f[
- *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \,
- *                     \begin{bmatrix} \mathbf{T} &  \mathbf{0} \\
- *                                     \mathbf{0} & \mathbf{0} \end{bmatrix} \, \mathbf{Z}
- * \f]
- * by using Householder transformations. Here, \b P is a permutation matrix,
- * \b Q and \b Z are unitary matrices and \b T an upper triangular matrix of
- * size rank-by-rank. \b A may be rank deficient.
- *
- * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
- *
- * \sa MatrixBase::completeOrthogonalDecomposition()
+ * Parameterized over the rank-revealing QR engine \c RankRevealingQR_. The
+ * public, source-compatible class \c CompleteOrthogonalDecomposition is a
+ * thin shim around \c CompleteOrthogonalDecompositionImpl with
+ * \c ColPivHouseholderQR; \c RandCompleteOrthogonalDecomposition is the
+ * parallel shim with \c RandColPivHouseholderQR.
  */
-template <typename MatrixType_, typename PermutationIndex_>
-class CompleteOrthogonalDecomposition
-    : public SolverBase<CompleteOrthogonalDecomposition<MatrixType_, PermutationIndex_>> {
+template <typename MatrixType_, typename PermutationIndex_, template <typename, typename> class RankRevealingQR_>
+class CompleteOrthogonalDecompositionImpl
+    : public SolverBase<CompleteOrthogonalDecompositionImpl<MatrixType_, PermutationIndex_, RankRevealingQR_>> {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<CompleteOrthogonalDecomposition> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<CompleteOrthogonalDecompositionImpl>;
 
   template <typename Derived>
   friend struct internal::solve_assertion;
-  typedef PermutationIndex_ PermutationIndex;
-  EIGEN_GENERIC_PUBLIC_INTERFACE(CompleteOrthogonalDecomposition)
+  using PermutationIndex = PermutationIndex_;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CompleteOrthogonalDecompositionImpl)
   enum {
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
-  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
-  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex> PermutationType;
-  typedef typename internal::plain_row_type<MatrixType, Index>::type IntRowVectorType;
-  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
-  typedef typename internal::plain_row_type<MatrixType, RealScalar>::type RealRowVectorType;
-  typedef HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>
-      HouseholderSequenceType;
-  typedef typename MatrixType::PlainObject PlainObject;
+  using HCoeffsType = typename internal::plain_diag_type<MatrixType>::type;
+  using PermutationType = PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex>;
+  using IntRowVectorType = typename internal::plain_row_type<MatrixType, Index>::type;
+  using RowVectorType = typename internal::plain_row_type<MatrixType>::type;
+  using RealRowVectorType = typename internal::plain_row_type<MatrixType, RealScalar>::type;
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>;
+  using PlainObject = typename MatrixType::PlainObject;
+  using RankRevealingQRType = RankRevealingQR_<MatrixType, PermutationIndex>;
 
  public:
-  /**
-   * \brief Default Constructor.
-   *
-   * The default constructor is useful in cases in which the user intends to
-   * perform decompositions via
-   * \c CompleteOrthogonalDecomposition::compute(const* MatrixType&).
-   */
-  CompleteOrthogonalDecomposition() : m_cpqr(), m_zCoeffs(), m_temp() {}
+  CompleteOrthogonalDecompositionImpl() : m_cpqr(), m_zCoeffs(), m_temp() {}
 
-  /** \brief Default Constructor with memory preallocation
-   *
-   * Like the default constructor but with preallocation of the internal data
-   * according to the specified problem \a size.
-   * \sa CompleteOrthogonalDecomposition()
-   */
-  CompleteOrthogonalDecomposition(Index rows, Index cols)
+  CompleteOrthogonalDecompositionImpl(Index rows, Index cols)
       : m_cpqr(rows, cols), m_zCoeffs((std::min)(rows, cols)), m_temp(cols) {}
 
-  /** \brief Constructs a complete orthogonal decomposition from a given
-   * matrix.
-   *
-   * This constructor computes the complete orthogonal decomposition of the
-   * matrix \a matrix by calling the method compute(). The default
-   * threshold for rank determination will be used. It is a short cut for:
-   *
-   * \code
-   * CompleteOrthogonalDecomposition<MatrixType> cod(matrix.rows(),
-   *                                                 matrix.cols());
-   * cod.setThreshold(Default);
-   * cod.compute(matrix);
-   * \endcode
-   *
-   * \sa compute()
-   */
   template <typename InputType>
-  explicit CompleteOrthogonalDecomposition(const EigenBase<InputType>& matrix)
+  explicit CompleteOrthogonalDecompositionImpl(const EigenBase<InputType>& matrix)
       : m_cpqr(matrix.rows(), matrix.cols()),
         m_zCoeffs((std::min)(matrix.rows(), matrix.cols())),
         m_temp(matrix.cols()) {
     compute(matrix.derived());
   }
 
-  /** \brief Constructs a complete orthogonal decomposition from a given matrix
-   *
-   * This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c
-   * MatrixType is a Eigen::Ref.
-   *
-   * \sa CompleteOrthogonalDecomposition(const EigenBase&)
-   */
   template <typename InputType>
-  explicit CompleteOrthogonalDecomposition(EigenBase<InputType>& matrix)
+  explicit CompleteOrthogonalDecompositionImpl(EigenBase<InputType>& matrix)
       : m_cpqr(matrix.derived()), m_zCoeffs((std::min)(matrix.rows(), matrix.cols())), m_temp(matrix.cols()) {
     computeInPlace();
   }
 
-#ifdef EIGEN_PARSED_BY_DOXYGEN
-  /** This method computes the minimum-norm solution X to a least squares
-   * problem \f[\mathrm{minimize} \|A X - B\|, \f] where \b A is the matrix of
-   * which \c *this is the complete orthogonal decomposition.
-   *
-   * \param b the right-hand sides of the problem to solve.
-   *
-   * \returns a solution.
-   *
-   */
-  template <typename Rhs>
-  inline Solve<CompleteOrthogonalDecomposition, Rhs> solve(const MatrixBase<Rhs>& b) const;
-#endif
+  HouseholderSequenceType householderQ() const;
+  HouseholderSequenceType matrixQ() const { return m_cpqr.householderQ(); }
 
-  HouseholderSequenceType householderQ(void) const;
-  HouseholderSequenceType matrixQ(void) const { return m_cpqr.householderQ(); }
-
-  /** \returns the matrix \b Z.
-   */
   MatrixType matrixZ() const {
     MatrixType Z = MatrixType::Identity(m_cpqr.cols(), m_cpqr.cols());
     applyZOnTheLeftInPlace<false>(Z);
     return Z;
   }
 
-  /** \returns a reference to the matrix where the complete orthogonal
-   * decomposition is stored
-   */
   const MatrixType& matrixQTZ() const { return m_cpqr.matrixQR(); }
-
-  /** \returns a reference to the matrix where the complete orthogonal
-   * decomposition is stored.
-   * \warning The strict lower part and \code cols() - rank() \endcode right
-   * columns of this matrix contains internal values.
-   * Only the upper triangular part should be referenced. To get it, use
-   * \code matrixT().template triangularView<Upper>() \endcode
-   * For rank-deficient matrices, use
-   * \code
-   * matrixT().topLeftCorner(rank(), rank()).template triangularView<Upper>()
-   * \endcode
-   */
   const MatrixType& matrixT() const { return m_cpqr.matrixQR(); }
 
   template <typename InputType>
-  CompleteOrthogonalDecomposition& compute(const EigenBase<InputType>& matrix) {
-    // Compute the column pivoted QR factorization A P = Q R.
+  CompleteOrthogonalDecompositionImpl& compute(const EigenBase<InputType>& matrix) {
     m_cpqr.compute(matrix);
     computeInPlace();
     return *this;
   }
 
-  /** \returns a const reference to the column permutation matrix */
   const PermutationType& colsPermutation() const { return m_cpqr.colsPermutation(); }
 
-  /** \returns the determinant of the matrix of which
-   * *this is the complete orthogonal decomposition. It has only linear
-   * complexity (that is, O(n) where n is the dimension of the square matrix)
-   * as the complete orthogonal decomposition has already been computed.
-   *
-   * \note This is only for square matrices.
-   *
-   * \warning a determinant can be very big or small, so for matrices
-   * of large enough dimension, there is a risk of overflow/underflow.
-   * One way to work around that is to use logAbsDeterminant() instead.
-   *
-   * \sa absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
-   */
   typename MatrixType::Scalar determinant() const;
-
-  /** \returns the absolute value of the determinant of the matrix of which
-   * *this is the complete orthogonal decomposition. It has only linear
-   * complexity (that is, O(n) where n is the dimension of the square matrix)
-   * as the complete orthogonal decomposition has already been computed.
-   *
-   * \note This is only for square matrices.
-   *
-   * \warning a determinant can be very big or small, so for matrices
-   * of large enough dimension, there is a risk of overflow/underflow.
-   * One way to work around that is to use logAbsDeterminant() instead.
-   *
-   * \sa determinant(), logAbsDeterminant(), MatrixBase::determinant()
-   */
   typename MatrixType::RealScalar absDeterminant() const;
-
-  /** \returns the natural log of the absolute value of the determinant of the
-   * matrix of which *this is the complete orthogonal decomposition. It has
-   * only linear complexity (that is, O(n) where n is the dimension of the
-   * square matrix) as the complete orthogonal decomposition has already been
-   * computed.
-   *
-   * \note This is only for square matrices.
-   *
-   * \note This method is useful to work around the risk of overflow/underflow
-   * that's inherent to determinant computation.
-   *
-   * \sa determinant(), absDeterminant(), MatrixBase::determinant()
-   */
   typename MatrixType::RealScalar logAbsDeterminant() const;
-
-  /** \returns the sign of the determinant of the
-   * matrix of which *this is the complete orthogonal decomposition. It has
-   * only linear complexity (that is, O(n) where n is the dimension of the
-   * square matrix) as the complete orthogonal decomposition has already been
-   * computed.
-   *
-   * \note This is only for square matrices.
-   *
-   * \note This method is useful to work around the risk of overflow/underflow
-   * that's inherent to determinant computation.
-   *
-   * \sa determinant(), absDeterminant(), logAbsDeterminant(), MatrixBase::determinant()
-   */
   typename MatrixType::Scalar signDeterminant() const;
 
-  /** \returns the rank of the matrix of which *this is the complete orthogonal
-   * decomposition.
-   *
-   * \note This method has to determine which pivots should be considered
-   * nonzero. For that, it uses the threshold value that you can control by
-   * calling setThreshold(const RealScalar&).
-   */
   inline Index rank() const { return m_cpqr.rank(); }
-
-  /** \returns the dimension of the kernel of the matrix of which *this is the
-   * complete orthogonal decomposition.
-   *
-   * \note This method has to determine which pivots should be considered
-   * nonzero. For that, it uses the threshold value that you can control by
-   * calling setThreshold(const RealScalar&).
-   */
   inline Index dimensionOfKernel() const { return m_cpqr.dimensionOfKernel(); }
-
-  /** \returns true if the matrix of which *this is the decomposition represents
-   * an injective linear map, i.e. has trivial kernel; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered
-   * nonzero. For that, it uses the threshold value that you can control by
-   * calling setThreshold(const RealScalar&).
-   */
   inline bool isInjective() const { return m_cpqr.isInjective(); }
-
-  /** \returns true if the matrix of which *this is the decomposition represents
-   * a surjective linear map; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered
-   * nonzero. For that, it uses the threshold value that you can control by
-   * calling setThreshold(const RealScalar&).
-   */
   inline bool isSurjective() const { return m_cpqr.isSurjective(); }
-
-  /** \returns true if the matrix of which *this is the complete orthogonal
-   * decomposition is invertible.
-   *
-   * \note This method has to determine which pivots should be considered
-   * nonzero. For that, it uses the threshold value that you can control by
-   * calling setThreshold(const RealScalar&).
-   */
   inline bool isInvertible() const { return m_cpqr.isInvertible(); }
 
-  /** \returns the pseudo-inverse of the matrix of which *this is the complete
-   * orthogonal decomposition.
-   * \warning: Do not compute \c this->pseudoInverse()*rhs to solve a linear systems.
-   * It is more efficient and numerically stable to call \c this->solve(rhs).
-   */
-  inline Inverse<CompleteOrthogonalDecomposition> pseudoInverse() const {
-    eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
-    return Inverse<CompleteOrthogonalDecomposition>(*this);
-  }
-
   inline Index rows() const { return m_cpqr.rows(); }
   inline Index cols() const { return m_cpqr.cols(); }
 
-  /** \returns a const reference to the vector of Householder coefficients used
-   * to represent the factor \c Q.
-   *
-   * For advanced uses only.
-   */
   inline const HCoeffsType& hCoeffs() const { return m_cpqr.hCoeffs(); }
-
-  /** \returns a const reference to the vector of Householder coefficients
-   * used to represent the factor \c Z.
-   *
-   * For advanced uses only.
-   */
   const HCoeffsType& zCoeffs() const { return m_zCoeffs; }
 
-  /** Allows to prescribe a threshold to be used by certain methods, such as
-   * rank(), who need to determine when pivots are to be considered nonzero.
-   * Most be called before calling compute().
-   *
-   * When it needs to get the threshold value, Eigen calls threshold(). By
-   * default, this uses a formula to automatically determine a reasonable
-   * threshold. Once you have called the present method
-   * setThreshold(const RealScalar&), your value is used instead.
-   *
-   * \param threshold The new value to use as the threshold.
-   *
-   * A pivot will be considered nonzero if its absolute value is strictly
-   * greater than
-   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
-   * where maxpivot is the biggest pivot.
-   *
-   * If you want to come back to the default behavior, call
-   * setThreshold(Default_t)
-   */
-  CompleteOrthogonalDecomposition& setThreshold(const RealScalar& threshold) {
+  CompleteOrthogonalDecompositionImpl& setThreshold(const RealScalar& threshold) {
     m_cpqr.setThreshold(threshold);
     return *this;
   }
 
-  /** Allows to come back to the default behavior, letting Eigen use its default
-   * formula for determining the threshold.
-   *
-   * You should pass the special object Eigen::Default as parameter here.
-   * \code qr.setThreshold(Eigen::Default); \endcode
-   *
-   * See the documentation of setThreshold(const RealScalar&).
-   */
-  CompleteOrthogonalDecomposition& setThreshold(Default_t) {
+  CompleteOrthogonalDecompositionImpl& setThreshold(Default_t) {
     m_cpqr.setThreshold(Default);
     return *this;
   }
 
-  /** Returns the threshold that will be used by certain methods such as rank().
-   *
-   * See the documentation of setThreshold(const RealScalar&).
-   */
   RealScalar threshold() const { return m_cpqr.threshold(); }
 
-  /** \returns the number of nonzero pivots in the complete orthogonal
-   * decomposition. Here nonzero is meant in the exact sense, not in a
-   * fuzzy sense. So that notion isn't really intrinsically interesting,
-   * but it is still useful when implementing algorithms.
-   *
-   * \sa rank()
-   */
   inline Index nonzeroPivots() const { return m_cpqr.nonzeroPivots(); }
-
-  /** \returns the absolute value of the biggest pivot, i.e. the biggest
-   *          diagonal coefficient of R.
-   */
   inline RealScalar maxPivot() const { return m_cpqr.maxPivot(); }
 
-  /** \brief Reports whether the complete orthogonal decomposition was
-   * successful.
-   *
-   * \note This function always returns \c Success. It is provided for
-   * compatibility
-   * with other factorization routines.
-   * \returns \c Success
-   */
   ComputationInfo info() const {
     eigen_assert(m_cpqr.m_isInitialized && "Decomposition is not initialized.");
     return Success;
   }
 
+  /** \internal Asserts that compute() has been called. */
+  void check_initialized() const {
+    eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
+  }
+
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   template <typename RhsType, typename DstType>
   void _solve_impl(const RhsType& rhs, DstType& dst) const;
@@ -400,59 +186,49 @@
   void _check_solve_assertion(const Rhs& b) const {
     EIGEN_ONLY_USED_FOR_DEBUG(b);
     eigen_assert(m_cpqr.m_isInitialized && "CompleteOrthogonalDecomposition is not initialized.");
-    eigen_assert((Transpose_ ? derived().cols() : derived().rows()) == b.rows() &&
+    eigen_assert((Transpose_ ? this->cols() : this->rows()) == b.rows() &&
                  "CompleteOrthogonalDecomposition::solve(): invalid number of rows of the right hand side matrix b");
   }
 
   void computeInPlace();
 
-  /** Overwrites \b rhs with \f$ \mathbf{Z} * \mathbf{rhs} \f$ or
-   *  \f$ \mathbf{\overline Z} * \mathbf{rhs} \f$ if \c Conjugate
-   *  is set to \c true.
-   */
   template <bool Conjugate, typename Rhs>
   void applyZOnTheLeftInPlace(Rhs& rhs) const;
 
-  /** Overwrites \b rhs with \f$ \mathbf{Z}^* * \mathbf{rhs} \f$.
-   */
   template <typename Rhs>
   void applyZAdjointOnTheLeftInPlace(Rhs& rhs) const;
 
-  ColPivHouseholderQR<MatrixType, PermutationIndex> m_cpqr;
+  RankRevealingQRType m_cpqr;
   HCoeffsType m_zCoeffs;
   RowVectorType m_temp;
 };
 
-template <typename MatrixType, typename PermutationIndex>
-typename MatrixType::Scalar CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::determinant() const {
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
+typename MatrixType::Scalar
+CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::determinant() const {
   return m_cpqr.determinant();
 }
 
-template <typename MatrixType, typename PermutationIndex>
-typename MatrixType::RealScalar CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::absDeterminant() const {
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::absDeterminant() const {
   return m_cpqr.absDeterminant();
 }
 
-template <typename MatrixType, typename PermutationIndex>
-typename MatrixType::RealScalar CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::logAbsDeterminant()
-    const {
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
+typename MatrixType::RealScalar
+CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::logAbsDeterminant() const {
   return m_cpqr.logAbsDeterminant();
 }
 
-template <typename MatrixType, typename PermutationIndex>
-typename MatrixType::Scalar CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::signDeterminant() const {
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
+typename MatrixType::Scalar
+CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::signDeterminant() const {
   return m_cpqr.signDeterminant();
 }
 
-/** Performs the complete orthogonal decomposition of the given matrix \a
- * matrix. The result of the factorization is stored into \c *this, and a
- * reference to \c *this is returned.
- *
- * \sa class CompleteOrthogonalDecomposition,
- * CompleteOrthogonalDecomposition(const MatrixType&)
- */
-template <typename MatrixType, typename PermutationIndex>
-void CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::computeInPlace() {
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
+void CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::computeInPlace() {
   eigen_assert(m_cpqr.cols() <= NumTraits<PermutationIndex>::highest());
 
   const Index rank = m_cpqr.rank();
@@ -499,9 +275,10 @@
   }
 }
 
-template <typename MatrixType, typename PermutationIndex>
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
 template <bool Conjugate, typename Rhs>
-void CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::applyZOnTheLeftInPlace(Rhs& rhs) const {
+void CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::applyZOnTheLeftInPlace(
+    Rhs& rhs) const {
   const Index cols = this->cols();
   const Index nrhs = rhs.cols();
   const Index rank = this->rank();
@@ -519,9 +296,10 @@
   }
 }
 
-template <typename MatrixType, typename PermutationIndex>
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
 template <typename Rhs>
-void CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::applyZAdjointOnTheLeftInPlace(Rhs& rhs) const {
+void CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::applyZAdjointOnTheLeftInPlace(
+    Rhs& rhs) const {
   const Index cols = this->cols();
   const Index nrhs = rhs.cols();
   const Index rank = this->rank();
@@ -539,10 +317,10 @@
 }
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-template <typename MatrixType_, typename PermutationIndex_>
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
 template <typename RhsType, typename DstType>
-void CompleteOrthogonalDecomposition<MatrixType_, PermutationIndex_>::_solve_impl(const RhsType& rhs,
-                                                                                  DstType& dst) const {
+void CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::_solve_impl(
+    const RhsType& rhs, DstType& dst) const {
   const Index rank = this->rank();
   if (rank == 0) {
     dst.setZero();
@@ -568,10 +346,10 @@
   dst = colsPermutation() * dst;
 }
 
-template <typename MatrixType_, typename PermutationIndex_>
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
 template <bool Conjugate, typename RhsType, typename DstType>
-void CompleteOrthogonalDecomposition<MatrixType_, PermutationIndex_>::_solve_impl_transposed(const RhsType& rhs,
-                                                                                             DstType& dst) const {
+void CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::_solve_impl_transposed(
+    const RhsType& rhs, DstType& dst) const {
   const Index rank = this->rank();
 
   if (rank == 0) {
@@ -599,6 +377,164 @@
 }
 #endif
 
+template <typename MatrixType, typename PermutationIndex, template <typename, typename> class RankRevealingQR_>
+typename CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::HouseholderSequenceType
+CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RankRevealingQR_>::householderQ() const {
+  return m_cpqr.householderQ();
+}
+
+}  // end namespace internal
+
+/** \ingroup QR_Module
+ *
+ * \class CompleteOrthogonalDecomposition
+ *
+ * \brief Complete orthogonal decomposition (COD) of a matrix.
+ *
+ * \tparam MatrixType_ the type of the matrix of which we are computing the COD.
+ *
+ * This class performs a rank-revealing complete orthogonal decomposition of a
+ * matrix  \b A into matrices \b P, \b Q, \b T, and \b Z such that
+ * \f[
+ *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \,
+ *                     \begin{bmatrix} \mathbf{T} &  \mathbf{0} \\
+ *                                     \mathbf{0} & \mathbf{0} \end{bmatrix} \, \mathbf{Z}
+ * \f]
+ * by using Householder transformations. Here, \b P is a permutation matrix,
+ * \b Q and \b Z are unitary matrices and \b T an upper triangular matrix of
+ * size rank-by-rank. \b A may be rank deficient.
+ *
+ * Internally backed by ColPivHouseholderQR. For large matrices, see
+ * RandCompleteOrthogonalDecomposition, which uses a randomized blocked
+ * column-pivoted QR and is faster on level-3-BLAS-friendly inputs.
+ *
+ * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
+ *
+ * \sa MatrixBase::completeOrthogonalDecomposition(), RandCompleteOrthogonalDecomposition
+ */
+template <typename MatrixType_, typename PermutationIndex_>
+class CompleteOrthogonalDecomposition
+    : public internal::CompleteOrthogonalDecompositionImpl<MatrixType_, PermutationIndex_, ColPivHouseholderQR> {
+ public:
+  using Base =
+      internal::CompleteOrthogonalDecompositionImpl<MatrixType_, PermutationIndex_, Eigen::ColPivHouseholderQR>;
+  using typename Base::RealScalar;
+
+  CompleteOrthogonalDecomposition() : Base() {}
+  CompleteOrthogonalDecomposition(Index rows, Index cols) : Base(rows, cols) {}
+
+  template <typename InputType>
+  explicit CompleteOrthogonalDecomposition(const EigenBase<InputType>& matrix) : Base(matrix.derived()) {}
+
+  template <typename InputType>
+  explicit CompleteOrthogonalDecomposition(EigenBase<InputType>& matrix) : Base(matrix.derived()) {}
+
+  /** \brief Computes the COD of \a matrix. \sa class CompleteOrthogonalDecomposition */
+  template <typename InputType>
+  CompleteOrthogonalDecomposition& compute(const EigenBase<InputType>& matrix) {
+    Base::compute(matrix);
+    return *this;
+  }
+
+  CompleteOrthogonalDecomposition& setThreshold(const RealScalar& threshold) {
+    Base::setThreshold(threshold);
+    return *this;
+  }
+
+  CompleteOrthogonalDecomposition& setThreshold(Default_t) {
+    Base::setThreshold(Default);
+    return *this;
+  }
+
+  /** \returns the pseudo-inverse of the matrix of which *this is the complete
+   * orthogonal decomposition.
+   * \warning Do not compute \c this->pseudoInverse()*rhs to solve a linear system.
+   * It is more efficient and numerically stable to call \c this->solve(rhs).
+   */
+  inline Inverse<CompleteOrthogonalDecomposition> pseudoInverse() const {
+    this->check_initialized();
+    return Inverse<CompleteOrthogonalDecomposition>(*this);
+  }
+};
+
+/** \ingroup QR_Module
+ *
+ * \class RandCompleteOrthogonalDecomposition
+ *
+ * \brief Complete orthogonal decomposition (COD) of a matrix, backed by
+ * RandColPivHouseholderQR.
+ *
+ * Same factorization as CompleteOrthogonalDecomposition, but the rank-revealing
+ * QR step uses the randomized blocked column-pivoted Householder QR
+ * (BQRRP framework). On large matrices this is faster than the classical
+ * Businger-Golub pivoting in CompleteOrthogonalDecomposition because almost
+ * all work is performed in level-3 BLAS. The pivot-quality difference is
+ * empirically minor; see RandColPivHouseholderQR for references and details.
+ *
+ * The block size and RNG seed of the underlying QR can be configured via
+ * setBlockSize() and setSeed() before calling compute().
+ *
+ * For small or fixed-size matrices prefer CompleteOrthogonalDecomposition:
+ * the sketch overhead dominates below roughly a few hundred rows/columns.
+ *
+ * \sa MatrixBase::randCompleteOrthogonalDecomposition(),
+ *     CompleteOrthogonalDecomposition, RandColPivHouseholderQR
+ */
+template <typename MatrixType_, typename PermutationIndex_>
+class RandCompleteOrthogonalDecomposition
+    : public internal::CompleteOrthogonalDecompositionImpl<MatrixType_, PermutationIndex_, RandColPivHouseholderQR> {
+ public:
+  using Base =
+      internal::CompleteOrthogonalDecompositionImpl<MatrixType_, PermutationIndex_, Eigen::RandColPivHouseholderQR>;
+  using typename Base::RealScalar;
+
+  RandCompleteOrthogonalDecomposition() : Base() {}
+  RandCompleteOrthogonalDecomposition(Index rows, Index cols) : Base(rows, cols) {}
+
+  template <typename InputType>
+  explicit RandCompleteOrthogonalDecomposition(const EigenBase<InputType>& matrix) : Base(matrix.derived()) {}
+
+  template <typename InputType>
+  explicit RandCompleteOrthogonalDecomposition(EigenBase<InputType>& matrix) : Base(matrix.derived()) {}
+
+  template <typename InputType>
+  RandCompleteOrthogonalDecomposition& compute(const EigenBase<InputType>& matrix) {
+    Base::compute(matrix);
+    return *this;
+  }
+
+  RandCompleteOrthogonalDecomposition& setThreshold(const RealScalar& threshold) {
+    Base::setThreshold(threshold);
+    return *this;
+  }
+
+  RandCompleteOrthogonalDecomposition& setThreshold(Default_t) {
+    Base::setThreshold(Default);
+    return *this;
+  }
+
+  /** \brief Sets the panel block size of the underlying randomized QR.
+   * \sa RandColPivHouseholderQR::setBlockSize
+   */
+  RandCompleteOrthogonalDecomposition& setBlockSize(Index b) {
+    this->m_cpqr.setBlockSize(b);
+    return *this;
+  }
+
+  /** \brief Fixes the RNG seed of the underlying randomized QR.
+   * \sa RandColPivHouseholderQR::setSeed
+   */
+  RandCompleteOrthogonalDecomposition& setSeed(uint64_t seed) {
+    this->m_cpqr.setSeed(seed);
+    return *this;
+  }
+
+  inline Inverse<RandCompleteOrthogonalDecomposition> pseudoInverse() const {
+    this->check_initialized();
+    return Inverse<RandCompleteOrthogonalDecomposition>(*this);
+  }
+};
+
 namespace internal {
 
 template <typename MatrixType, typename PermutationIndex>
@@ -612,26 +548,39 @@
                   internal::assign_op<typename DstXprType::Scalar,
                                       typename CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::Scalar>,
                   Dense2Dense> {
-  typedef CompleteOrthogonalDecomposition<MatrixType, PermutationIndex> CodType;
-  typedef Inverse<CodType> SrcXprType;
+  using CodType = CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<CodType>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::assign_op<typename DstXprType::Scalar, typename CodType::Scalar>&) {
-    typedef Matrix<typename CodType::Scalar, CodType::RowsAtCompileTime, CodType::RowsAtCompileTime, 0,
-                   CodType::MaxRowsAtCompileTime, CodType::MaxRowsAtCompileTime>
-        IdentityMatrixType;
+    using IdentityMatrixType = Matrix<typename CodType::Scalar, CodType::RowsAtCompileTime, CodType::RowsAtCompileTime,
+                                      0, CodType::MaxRowsAtCompileTime, CodType::MaxRowsAtCompileTime>;
+    dst = src.nestedExpression().solve(IdentityMatrixType::Identity(src.cols(), src.cols()));
+  }
+};
+
+template <typename MatrixType, typename PermutationIndex>
+struct traits<Inverse<RandCompleteOrthogonalDecomposition<MatrixType, PermutationIndex>>>
+    : traits<typename Transpose<typename MatrixType::PlainObject>::PlainObject> {
+  enum { Flags = 0 };
+};
+
+template <typename DstXprType, typename MatrixType, typename PermutationIndex>
+struct Assignment<DstXprType, Inverse<RandCompleteOrthogonalDecomposition<MatrixType, PermutationIndex>>,
+                  internal::assign_op<typename DstXprType::Scalar, typename RandCompleteOrthogonalDecomposition<
+                                                                       MatrixType, PermutationIndex>::Scalar>,
+                  Dense2Dense> {
+  using CodType = RandCompleteOrthogonalDecomposition<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<CodType>;
+  static void run(DstXprType& dst, const SrcXprType& src,
+                  const internal::assign_op<typename DstXprType::Scalar, typename CodType::Scalar>&) {
+    using IdentityMatrixType = Matrix<typename CodType::Scalar, CodType::RowsAtCompileTime, CodType::RowsAtCompileTime,
+                                      0, CodType::MaxRowsAtCompileTime, CodType::MaxRowsAtCompileTime>;
     dst = src.nestedExpression().solve(IdentityMatrixType::Identity(src.cols(), src.cols()));
   }
 };
 
 }  // end namespace internal
 
-/** \returns the matrix Q as a sequence of householder transformations */
-template <typename MatrixType, typename PermutationIndex>
-typename CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::HouseholderSequenceType
-CompleteOrthogonalDecomposition<MatrixType, PermutationIndex>::householderQ() const {
-  return m_cpqr.householderQ();
-}
-
 /** \return the complete orthogonal decomposition of \c *this.
  *
  * \sa class CompleteOrthogonalDecomposition
@@ -640,7 +589,18 @@
 template <typename PermutationIndex>
 CompleteOrthogonalDecomposition<typename MatrixBase<Derived>::PlainObject, PermutationIndex>
 MatrixBase<Derived>::completeOrthogonalDecomposition() const {
-  return CompleteOrthogonalDecomposition<PlainObject>(eval());
+  return CompleteOrthogonalDecomposition<PlainObject, PermutationIndex>(eval());
+}
+
+/** \return the randomized complete orthogonal decomposition of \c *this.
+ *
+ * \sa class RandCompleteOrthogonalDecomposition
+ */
+template <typename Derived>
+template <typename PermutationIndex>
+RandCompleteOrthogonalDecomposition<typename MatrixBase<Derived>::PlainObject, PermutationIndex>
+MatrixBase<Derived>::randCompleteOrthogonalDecomposition() const {
+  return RandCompleteOrthogonalDecomposition<PlainObject, PermutationIndex>(eval());
 }
 
 }  // end namespace Eigen
diff --git a/Eigen/src/QR/FullPivHouseholderQR.h b/Eigen/src/QR/FullPivHouseholderQR.h
index 40f9047..880115e 100644
--- a/Eigen/src/QR/FullPivHouseholderQR.h
+++ b/Eigen/src/QR/FullPivHouseholderQR.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
 #define EIGEN_FULLPIVOTINGHOUSEHOLDERQR_H
@@ -20,9 +21,9 @@
 
 template <typename MatrixType_, typename PermutationIndex_>
 struct traits<FullPivHouseholderQR<MatrixType_, PermutationIndex_> > : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef PermutationIndex_ PermutationIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using PermutationIndex = PermutationIndex_;
   enum { Flags = 0 };
 };
 
@@ -31,7 +32,7 @@
 
 template <typename MatrixType, typename PermutationIndex>
 struct traits<FullPivHouseholderQRMatrixQReturnType<MatrixType, PermutationIndex> > {
-  typedef typename MatrixType::PlainObject ReturnType;
+  using ReturnType = typename MatrixType::PlainObject;
 };
 
 }  // end namespace internal
@@ -44,13 +45,14 @@
  *
  * \tparam MatrixType_ the type of the matrix of which we are computing the QR decomposition
  *
- * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b P, \b P', \b Q and \b R
- * such that
+ * This class performs a rank-revealing QR decomposition of a matrix \b A into matrices \b Q, \b R and a column
+ * permutation \b P such that
  * \f[
- *  \mathbf{P} \, \mathbf{A} \, \mathbf{P}' = \mathbf{Q} \, \mathbf{R}
+ *  \mathbf{A} \, \mathbf{P} = \mathbf{Q} \, \mathbf{R}
  * \f]
- * by using Householder transformations. Here, \b P and \b P' are permutation matrices, \b Q a unitary matrix
- * and \b R an upper triangular matrix.
+ * by using Householder transformations. Equivalently, \f$ \mathbf{A} = \mathbf{Q} \, \mathbf{R} \, \mathbf{P}^{-1} \f$.
+ * Here \b P is the column permutation returned by colsPermutation(), \b Q is the unitary matrix returned by matrixQ(),
+ * and \b R is an upper triangular matrix. Row transpositions used during pivoting are folded into \b Q.
  *
  * This decomposition performs a very prudent full pivoting in order to be rank-revealing and achieve optimal
  * numerical stability. The trade-off is that it is slower than HouseholderQR and ColPivHouseholderQR.
@@ -60,27 +62,39 @@
  * \sa MatrixBase::fullPivHouseholderQr()
  */
 template <typename MatrixType_, typename PermutationIndex_>
-class FullPivHouseholderQR : public SolverBase<FullPivHouseholderQR<MatrixType_, PermutationIndex_> > {
+class FullPivHouseholderQR : public SolverBase<FullPivHouseholderQR<MatrixType_, PermutationIndex_> >,
+                             public RankRevealingBase<FullPivHouseholderQR<MatrixType_, PermutationIndex_> > {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<FullPivHouseholderQR> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<FullPivHouseholderQR>;
+  using RankRevealingBase_ = RankRevealingBase<FullPivHouseholderQR>;
   friend class SolverBase<FullPivHouseholderQR>;
-  typedef PermutationIndex_ PermutationIndex;
+  friend class RankRevealingBase<FullPivHouseholderQR>;
+  using RankRevealingBase_::dimensionOfKernel;
+  using RankRevealingBase_::isInjective;
+  using RankRevealingBase_::isInvertible;
+  using RankRevealingBase_::isSurjective;
+  using RankRevealingBase_::maxPivot;
+  using RankRevealingBase_::nonzeroPivots;
+  using RankRevealingBase_::rank;
+  using RankRevealingBase_::setThreshold;
+  using RankRevealingBase_::threshold;
+  using PermutationIndex = PermutationIndex_;
   EIGEN_GENERIC_PUBLIC_INTERFACE(FullPivHouseholderQR)
 
   enum {
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
-  typedef internal::FullPivHouseholderQRMatrixQReturnType<MatrixType, PermutationIndex> MatrixQReturnType;
-  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
-  typedef Matrix<PermutationIndex, 1, internal::min_size_prefer_dynamic(ColsAtCompileTime, RowsAtCompileTime), RowMajor,
-                 1, internal::min_size_prefer_fixed(MaxColsAtCompileTime, MaxRowsAtCompileTime)>
-      IntDiagSizeVectorType;
-  typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex> PermutationType;
-  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
-  typedef typename internal::plain_col_type<MatrixType>::type ColVectorType;
-  typedef typename MatrixType::PlainObject PlainObject;
+  using MatrixQReturnType = internal::FullPivHouseholderQRMatrixQReturnType<MatrixType, PermutationIndex>;
+  using HCoeffsType = typename internal::plain_diag_type<MatrixType>::type;
+  using IntDiagSizeVectorType =
+      Matrix<PermutationIndex, 1, internal::min_size_prefer_dynamic(ColsAtCompileTime, RowsAtCompileTime), RowMajor, 1,
+             internal::min_size_prefer_fixed(MaxColsAtCompileTime, MaxRowsAtCompileTime)>;
+  using PermutationType = PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex>;
+  using RowVectorType = typename internal::plain_row_type<MatrixType>::type;
+  using ColVectorType = typename internal::plain_col_type<MatrixType>::type;
+  using PlainObject = typename MatrixType::PlainObject;
 
   /** \brief Reports whether the QR factorization was successful.
    *
@@ -105,8 +119,7 @@
         m_cols_transpositions(),
         m_cols_permutation(),
         m_temp(),
-        m_isInitialized(false),
-        m_usePrescribedThreshold(false) {}
+        m_isInitialized(false) {}
 
   /** \brief Default Constructor with memory preallocation
    *
@@ -121,8 +134,7 @@
         m_cols_transpositions((std::min)(rows, cols)),
         m_cols_permutation(cols),
         m_temp(cols),
-        m_isInitialized(false),
-        m_usePrescribedThreshold(false) {}
+        m_isInitialized(false) {}
 
   /** \brief Constructs a QR factorization from a given matrix
    *
@@ -144,8 +156,7 @@
         m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
         m_cols_permutation(matrix.cols()),
         m_temp(matrix.cols()),
-        m_isInitialized(false),
-        m_usePrescribedThreshold(false) {
+        m_isInitialized(false) {
     compute(matrix.derived());
   }
 
@@ -164,8 +175,7 @@
         m_cols_transpositions((std::min)(matrix.rows(), matrix.cols())),
         m_cols_permutation(matrix.cols()),
         m_temp(matrix.cols()),
-        m_isInitialized(false),
-        m_usePrescribedThreshold(false) {
+        m_isInitialized(false) {
     computeInPlace();
   }
 
@@ -177,6 +187,9 @@
    *
    * \returns the exact or least-square solution if the rank is greater or equal to the number of columns of A,
    * and an arbitrary solution otherwise.
+   * For overdetermined systems, the least-square solution minimizes the Euclidean norm \f$ \Vert A x - b \Vert \f$.
+   * For rank-deficient matrices, this method generally does not compute the minimum-norm solution; use
+   * CompleteOrthogonalDecomposition or an SVD if that is required.
    *
    * \note_about_checking_solutions
    *
@@ -273,65 +286,10 @@
    */
   typename MatrixType::Scalar signDeterminant() const;
 
-  /** \returns the rank of the matrix of which *this is the QR decomposition.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline Index rank() const {
+  /** \returns the absolute value of the i-th pivot coefficient (for RankRevealingBase). */
+  RealScalar pivotCoeff(Index i) const {
     using std::abs;
-    eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
-    RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
-    Index result = 0;
-    for (Index i = 0; i < m_nonzero_pivots; ++i) result += (abs(m_qr.coeff(i, i)) > premultiplied_threshold);
-    return result;
-  }
-
-  /** \returns the dimension of the kernel of the matrix of which *this is the QR decomposition.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline Index dimensionOfKernel() const {
-    eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
-    return cols() - rank();
-  }
-
-  /** \returns true if the matrix of which *this is the QR decomposition represents an injective
-   *          linear map, i.e. has trivial kernel; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isInjective() const {
-    eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
-    return rank() == cols();
-  }
-
-  /** \returns true if the matrix of which *this is the QR decomposition represents a surjective
-   *          linear map; false otherwise.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isSurjective() const {
-    eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
-    return rank() == rows();
-  }
-
-  /** \returns true if the matrix of which *this is the QR decomposition is invertible.
-   *
-   * \note This method has to determine which pivots should be considered nonzero.
-   *       For that, it uses the threshold value that you can control by calling
-   *       setThreshold(const RealScalar&).
-   */
-  inline bool isInvertible() const {
-    eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
-    return isInjective() && isSurjective();
+    return abs(m_qr.coeff(i, i));
   }
 
   /** \returns the inverse of the matrix of which *this is the QR decomposition.
@@ -353,72 +311,6 @@
    */
   const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
 
-  /** Allows to prescribe a threshold to be used by certain methods, such as rank(),
-   * who need to determine when pivots are to be considered nonzero. This is not used for the
-   * QR decomposition itself.
-   *
-   * When it needs to get the threshold value, Eigen calls threshold(). By default, this
-   * uses a formula to automatically determine a reasonable threshold.
-   * Once you have called the present method setThreshold(const RealScalar&),
-   * your value is used instead.
-   *
-   * \param threshold The new value to use as the threshold.
-   *
-   * A pivot will be considered nonzero if its absolute value is strictly greater than
-   *  \f$ \vert pivot \vert \leqslant threshold \times \vert maxpivot \vert \f$
-   * where maxpivot is the biggest pivot.
-   *
-   * If you want to come back to the default behavior, call setThreshold(Default_t)
-   */
-  FullPivHouseholderQR& setThreshold(const RealScalar& threshold) {
-    m_usePrescribedThreshold = true;
-    m_prescribedThreshold = threshold;
-    return *this;
-  }
-
-  /** Allows to come back to the default behavior, letting Eigen use its default formula for
-   * determining the threshold.
-   *
-   * You should pass the special object Eigen::Default as parameter here.
-   * \code qr.setThreshold(Eigen::Default); \endcode
-   *
-   * See the documentation of setThreshold(const RealScalar&).
-   */
-  FullPivHouseholderQR& setThreshold(Default_t) {
-    m_usePrescribedThreshold = false;
-    return *this;
-  }
-
-  /** Returns the threshold that will be used by certain methods such as rank().
-   *
-   * See the documentation of setThreshold(const RealScalar&).
-   */
-  RealScalar threshold() const {
-    eigen_assert(m_isInitialized || m_usePrescribedThreshold);
-    return m_usePrescribedThreshold ? m_prescribedThreshold
-                                    // Higham's backward error bound for Householder QR (Theorem 19.4) is
-                                    // ||ΔA||₂ ≤ c·min(m,n)·u·||A||₂. The factor of 4 covers the
-                                    // constant c (typically 3–6 worst-case, ~1 probabilistically).
-                                    : NumTraits<Scalar>::epsilon() * RealScalar(4 * m_qr.diagonalSize());
-  }
-
-  /** \returns the number of nonzero pivots in the QR decomposition.
-   * Here nonzero is meant in the exact sense, not in a fuzzy sense.
-   * So that notion isn't really intrinsically interesting, but it is
-   * still useful when implementing algorithms.
-   *
-   * \sa rank()
-   */
-  inline Index nonzeroPivots() const {
-    eigen_assert(m_isInitialized && "LU is not initialized.");
-    return m_nonzero_pivots;
-  }
-
-  /** \returns the absolute value of the biggest pivot, i.e. the biggest
-   *          diagonal coefficient of U.
-   */
-  RealScalar maxPivot() const { return m_maxpivot; }
-
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   template <typename RhsType, typename DstType>
   void _solve_impl(const RhsType& rhs, DstType& dst) const;
@@ -438,9 +330,7 @@
   IntDiagSizeVectorType m_cols_transpositions;
   PermutationType m_cols_permutation;
   RowVectorType m_temp;
-  bool m_isInitialized, m_usePrescribedThreshold;
-  RealScalar m_prescribedThreshold, m_maxpivot;
-  Index m_nonzero_pivots;
+  bool m_isInitialized;
   RealScalar m_precision;
   Index m_det_p;
 };
@@ -513,13 +403,13 @@
 
   RealScalar biggest(0);
 
-  m_nonzero_pivots = size;  // the generic case is that in which all pivots are nonzero (invertible case)
-  m_maxpivot = RealScalar(0);
+  this->m_nonzero_pivots = size;  // the generic case is that in which all pivots are nonzero (invertible case)
+  this->m_maxpivot = RealScalar(0);
 
   for (Index k = 0; k < size; ++k) {
     Index row_of_biggest_in_corner, col_of_biggest_in_corner;
-    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
-    typedef typename Scoring::result_type Score;
+    using Scoring = internal::scalar_score_coeff_op<Scalar>;
+    using Score = typename Scoring::result_type;
 
     Score score = m_qr.bottomRightCorner(rows - k, cols - k)
                       .unaryExpr(Scoring())
@@ -532,7 +422,7 @@
 
     // if the corner is negligible, then we have less than full rank, and we can finish early
     if (internal::isMuchSmallerThan(biggest_in_corner, biggest, m_precision)) {
-      m_nonzero_pivots = k;
+      this->m_nonzero_pivots = k;
       for (Index i = k; i < size; i++) {
         m_rows_transpositions.coeffRef(i) = internal::convert_index<PermutationIndex>(i);
         m_cols_transpositions.coeffRef(i) = internal::convert_index<PermutationIndex>(i);
@@ -557,7 +447,7 @@
     m_qr.coeffRef(k, k) = beta;
 
     // remember the maximum absolute value of diagonal coefficients
-    if (abs(beta) > m_maxpivot) m_maxpivot = abs(beta);
+    if (abs(beta) > this->m_maxpivot) this->m_maxpivot = abs(beta);
 
     m_qr.bottomRightCorner(rows - k, cols - k - 1)
         .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows - k - 1), m_hCoeffs.coeffRef(k), &m_temp.coeffRef(k + 1));
@@ -641,8 +531,8 @@
                   internal::assign_op<typename DstXprType::Scalar,
                                       typename FullPivHouseholderQR<MatrixType, PermutationIndex>::Scalar>,
                   Dense2Dense> {
-  typedef FullPivHouseholderQR<MatrixType, PermutationIndex> QrType;
-  typedef Inverse<QrType> SrcXprType;
+  using QrType = FullPivHouseholderQR<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<QrType>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::assign_op<typename DstXprType::Scalar, typename QrType::Scalar>&) {
     dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
@@ -659,11 +549,10 @@
 struct FullPivHouseholderQRMatrixQReturnType
     : public ReturnByValue<FullPivHouseholderQRMatrixQReturnType<MatrixType, PermutationIndex> > {
  public:
-  typedef typename FullPivHouseholderQR<MatrixType, PermutationIndex>::IntDiagSizeVectorType IntDiagSizeVectorType;
-  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
-  typedef Matrix<typename MatrixType::Scalar, 1, MatrixType::RowsAtCompileTime, RowMajor, 1,
-                 MatrixType::MaxRowsAtCompileTime>
-      WorkVectorType;
+  using IntDiagSizeVectorType = typename FullPivHouseholderQR<MatrixType, PermutationIndex>::IntDiagSizeVectorType;
+  using HCoeffsType = typename internal::plain_diag_type<MatrixType>::type;
+  using WorkVectorType = Matrix<typename MatrixType::Scalar, 1, MatrixType::RowsAtCompileTime, RowMajor, 1,
+                                MatrixType::MaxRowsAtCompileTime>;
 
   FullPivHouseholderQRMatrixQReturnType(const MatrixType& qr, const HCoeffsType& hCoeffs,
                                         const IntDiagSizeVectorType& rowsTranspositions)
diff --git a/Eigen/src/QR/HouseholderQR.h b/Eigen/src/QR/HouseholderQR.h
index e7173a5..bf53835 100644
--- a/Eigen/src/QR/HouseholderQR.h
+++ b/Eigen/src/QR/HouseholderQR.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_QR_H
 #define EIGEN_QR_H
@@ -20,9 +21,9 @@
 namespace internal {
 template <typename MatrixType_>
 struct traits<HouseholderQR<MatrixType_>> : traits<MatrixType_> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef int StorageIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
   enum { Flags = 0 };
 };
 
@@ -53,13 +54,30 @@
  *
  * This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
  *
+ * \warning For a wide m-by-n matrix (m < n), transpose().solve() and adjoint().solve() use only
+ * the first m equations, through the leading m-by-m triangular block of R. This block can be
+ * ill-conditioned or singular even when A is well-conditioned and has full row rank. The remaining
+ * equations are satisfied only insofar as the right-hand side is consistent and rounding errors permit;
+ * these calls do not compute a least-squares solution for an inconsistent right-hand side.
+ * To solve using all equations when A has full row rank, factor the transpose directly:
+ * \code
+ * x = A.transpose().householderQr().solve(b);
+ * \endcode
+ * For rank-deficient A, or to reuse a decomposition of A, use CompleteOrthogonalDecomposition
+ * to obtain the minimum-norm least-squares solution:
+ * \code
+ * auto cod = A.completeOrthogonalDecomposition();
+ * x = cod.transpose().solve(b);
+ * \endcode
+ * Replace transpose() with adjoint() in these examples for the adjoint system.
+ *
  * \sa MatrixBase::householderQr()
  */
 template <typename MatrixType_>
 class HouseholderQR : public SolverBase<HouseholderQR<MatrixType_>> {
  public:
-  typedef MatrixType_ MatrixType;
-  typedef SolverBase<HouseholderQR> Base;
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<HouseholderQR>;
   friend class SolverBase<HouseholderQR>;
 
   EIGEN_GENERIC_PUBLIC_INTERFACE(HouseholderQR)
@@ -67,13 +85,13 @@
     MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
   };
-  typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags & RowMajorBit) ? RowMajor : ColMajor,
-                 MaxRowsAtCompileTime, MaxRowsAtCompileTime>
-      MatrixQType;
-  typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType;
-  typedef typename internal::plain_row_type<MatrixType>::type RowVectorType;
-  typedef HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>
-      HouseholderSequenceType;
+  using MatrixQType =
+      Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags & RowMajorBit) ? RowMajor : ColMajor,
+             MaxRowsAtCompileTime, MaxRowsAtCompileTime>;
+  using HCoeffsType = typename internal::plain_diag_type<MatrixType>::type;
+  using RowVectorType = typename internal::plain_row_type<MatrixType>::type;
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>;
 
   /** \brief Reports whether the QR factorization was successful.
    *
@@ -355,15 +373,15 @@
 /** \internal */
 template <typename MatrixQR, typename HCoeffs>
 void householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Scalar* tempData = 0) {
-  typedef typename MatrixQR::Scalar Scalar;
-  typedef typename MatrixQR::RealScalar RealScalar;
+  using Scalar = typename MatrixQR::Scalar;
+  using RealScalar = typename MatrixQR::RealScalar;
   Index rows = mat.rows();
   Index cols = mat.cols();
   Index size = (std::min)(rows, cols);
 
   eigen_assert(hCoeffs.size() == size);
 
-  typedef Matrix<Scalar, MatrixQR::ColsAtCompileTime, 1> TempType;
+  using TempType = Matrix<Scalar, MatrixQR::ColsAtCompileTime, 1>;
   TempType tempVector;
   if (tempData == 0) {
     tempVector.resize(cols);
@@ -378,26 +396,30 @@
     mat.col(k).tail(remainingRows).makeHouseholderInPlace(hCoeffs.coeffRef(k), beta);
     mat.coeffRef(k, k) = beta;
 
-    // apply H to remaining part of m_qr from the left
+    // apply H to remaining part of mat from the left
     mat.bottomRightCorner(remainingRows, remainingCols)
         .applyHouseholderOnTheLeft(mat.col(k).tail(remainingRows - 1), hCoeffs.coeffRef(k), tempData + k + 1);
   }
 }
 
-// TODO: expose a public API for rank-1 QR update.
 /** \internal
- * Basically a modified copy of @c Eigen::internal::householder_qr_inplace_unblocked that
- * performs a rank-1 update of the QR matrix in compact storage. This function assumes, that
- * the first @c k-1 columns of the matrix @c mat contain the QR decomposition of \f$A^N\f$ up to
- * column k-1. Then the QR decomposition of the k-th column (given by @c newColumn) is computed by
- * applying the k-1 Householder projectors on it and finally compute the projector \f$H_k\f$ of
- * it. On exit the matrix @c mat and the vector @c hCoeffs contain the QR decomposition of the
- * first k columns of \f$A^N\f$. The \a tempData argument must point to at least mat.cols() scalars.  */
+ * Column-insert / column-replace helper for a compact-storage Householder QR.
+ * Given a matrix @c mat and @c hCoeffs holding the QR factorization of the first @c k columns of
+ * some matrix A, this function replaces column @c k of that factorization with @c newColumn: it
+ * applies the existing k Householder reflectors (stored in columns 0..k-1 of @c mat and in
+ * @c hCoeffs.head(k)) to @c newColumn, then computes the k-th reflector in place. On exit
+ * @c mat.leftCols(k+1) and @c hCoeffs.head(k+1) hold the QR factorization of A.leftCols(k) with
+ * @c newColumn inserted at position @c k. @c tempData must point to at least @c mat.cols() scalars.
+ *
+ * Despite the historical "rank-1 update" label, this is not a full QR update in the
+ * Gill-Golub-Murray-Saunders sense: there is no public API for @c QR(A + u vT) or for column/row
+ * delete. See libeigen/eigen#3072 for a tracker of that feature gap. Currently only NNLS relies on
+ * this helper; the signature is tuned to its active-set bookkeeping. */
 template <typename MatrixQR, typename HCoeffs, typename VectorQR>
 void householder_qr_inplace_update(MatrixQR& mat, HCoeffs& hCoeffs, const VectorQR& newColumn,
                                    typename MatrixQR::Index k, typename MatrixQR::Scalar* tempData) {
-  typedef typename MatrixQR::Index Index;
-  typedef typename MatrixQR::RealScalar RealScalar;
+  using Index = typename MatrixQR::Index;
+  using RealScalar = typename MatrixQR::RealScalar;
   Index rows = mat.rows();
 
   eigen_assert(k < mat.cols());
@@ -427,14 +449,14 @@
 struct householder_qr_inplace_blocked {
   // This is specialized for LAPACK-supported Scalar types in HouseholderQR_LAPACKE.h
   static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index maxBlockSize = 32, typename MatrixQR::Scalar* tempData = 0) {
-    typedef typename MatrixQR::Scalar Scalar;
-    typedef Block<MatrixQR, Dynamic, Dynamic> BlockType;
+    using Scalar = typename MatrixQR::Scalar;
+    using BlockType = Block<MatrixQR, Dynamic, Dynamic>;
 
     Index rows = mat.rows();
     Index cols = mat.cols();
     Index size = (std::min)(rows, cols);
 
-    typedef Matrix<Scalar, Dynamic, 1, ColMajor, MatrixQR::MaxColsAtCompileTime, 1> TempType;
+    using TempType = Matrix<Scalar, Dynamic, 1, ColMajor, MatrixQR::MaxColsAtCompileTime, 1>;
     TempType tempVector;
     if (tempData == 0) {
       tempVector.resize(cols);
@@ -455,7 +477,7 @@
       //        A20 | A21 | A22
       // and performs the qr dec of [A11^T A12^T]^T
       // and update [A21^T A22^T]^T using level 3 operations.
-      // Finally, the algorithm continue on A22
+      // Finally, the algorithm continues on A22
 
       BlockType A11_21 = mat.block(k, k, brows, bs);
       Block<HCoeffs, Dynamic, 1> hCoeffsSegment = hCoeffs.segment(k, bs);
diff --git a/Eigen/src/QR/HouseholderQR_LAPACKE.h b/Eigen/src/QR/HouseholderQR_LAPACKE.h
index 3b62175..373dd26 100644
--- a/Eigen/src/QR/HouseholderQR_LAPACKE.h
+++ b/Eigen/src/QR/HouseholderQR_LAPACKE.h
@@ -30,6 +30,7 @@
  *    LAPACKE_?geqrf function.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_QR_LAPACKE_H
 #define EIGEN_QR_LAPACKE_H
@@ -45,12 +46,20 @@
 
 template <typename MatrixQR, typename HCoeffs>
 struct lapacke_hqr {
-  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, typename MatrixQR::Scalar* = 0) {
+  static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index maxBlockSize = 32, typename MatrixQR::Scalar* tempData = 0) {
     lapack_int m = to_lapack(mat.rows());
     lapack_int n = to_lapack(mat.cols());
     lapack_int lda = to_lapack(mat.outerStride());
     lapack_int matrix_order = lapack_storage_of(mat);
-    geqrf(matrix_order, m, n, to_lapack(mat.data()), lda, to_lapack(hCoeffs.data()));
+    lapack_int info = geqrf(matrix_order, m, n, to_lapack(mat.data()), lda, to_lapack(hCoeffs.data()));
+    if (info == -4) {
+      // High-level LAPACKE may reject NaN inputs before calling LAPACK. Eigen's native path still computes a
+      // compact QR representation for these values.
+      householder_qr_inplace_blocked<MatrixQR, HCoeffs, typename MatrixQR::Scalar, false>::run(mat, hCoeffs,
+                                                                                               maxBlockSize, tempData);
+      return;
+    }
+    eigen_assert(info == 0);
     hCoeffs.adjointInPlace();
   }
 };
diff --git a/Eigen/src/QR/InternalHeaderCheck.h b/Eigen/src/QR/InternalHeaderCheck.h
index bf8df01..572b7c4 100644
--- a/Eigen/src/QR/InternalHeaderCheck.h
+++ b/Eigen/src/QR/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_QR_MODULE_H
 #error "Please include Eigen/QR instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/QR/RandColPivHouseholderQR.h b/Eigen/src/QR/RandColPivHouseholderQR.h
new file mode 100644
index 0000000..71cff02
--- /dev/null
+++ b/Eigen/src/QR/RandColPivHouseholderQR.h
@@ -0,0 +1,833 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_RANDCOLPIVOTINGHOUSEHOLDERQR_H
+#define EIGEN_RANDCOLPIVOTINGHOUSEHOLDERQR_H
+
+#include <random>
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename MatrixType_, typename PermutationIndex_>
+struct traits<RandColPivHouseholderQR<MatrixType_, PermutationIndex_>> : traits<MatrixType_> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using PermutationIndex = PermutationIndex_;
+  enum { Flags = 0 };
+};
+
+// Fill `mat` with iid samples drawn from a real standard normal distribution.
+template <typename Derived, typename Engine>
+EIGEN_STRONG_INLINE std::enable_if_t<!NumTraits<typename Derived::Scalar>::IsComplex> fill_gaussian(
+    MatrixBase<Derived>& mat, Engine& engine) {
+  using Scalar = typename Derived::Scalar;
+  std::normal_distribution<Scalar> dist(Scalar(0), Scalar(1));
+  for (Index j = 0; j < mat.cols(); ++j)
+    for (Index i = 0; i < mat.rows(); ++i) mat.coeffRef(i, j) = dist(engine);
+}
+
+// Fill `mat` with iid samples drawn from a complex standard normal
+// distribution (real and imaginary parts sampled independently).
+template <typename Derived, typename Engine>
+EIGEN_STRONG_INLINE std::enable_if_t<NumTraits<typename Derived::Scalar>::IsComplex> fill_gaussian(
+    MatrixBase<Derived>& mat, Engine& engine) {
+  using Scalar = typename Derived::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  std::normal_distribution<RealScalar> dist(RealScalar(0), RealScalar(1));
+  for (Index j = 0; j < mat.cols(); ++j)
+    for (Index i = 0; i < mat.rows(); ++i) mat.coeffRef(i, j) = Scalar(dist(engine), dist(engine));
+}
+
+// Stable LAWN-176 column-norm downdate after a Householder reflector has
+// been applied. `pivot_entry` is the entry of the just-pivoted row above
+// column `j`; `tail_norm_fn` recomputes the trailing-column norm from
+// scratch when the running estimate has lost too much precision (see
+// http://www.netlib.org/lapack/lawnspdf/lawn176.pdf).
+template <typename RealScalar, typename Scalar, typename RecomputeFn>
+EIGEN_STRONG_INLINE void lawn176_norm_downdate(RealScalar& norm_updated, RealScalar& norm_direct, Scalar pivot_entry,
+                                               RealScalar downdate_threshold, RecomputeFn&& tail_norm_fn) {
+  using std::abs;
+  if (numext::is_exactly_zero(norm_updated)) return;
+  RealScalar t = abs(pivot_entry) / norm_updated;
+  t = (RealScalar(1) + t) * (RealScalar(1) - t);
+  if (t < RealScalar(0)) t = RealScalar(0);
+  RealScalar t2 = t * numext::abs2<RealScalar>(norm_updated / norm_direct);
+  if (t2 <= downdate_threshold) {
+    norm_direct = tail_norm_fn();
+    norm_updated = norm_direct;
+  } else {
+    norm_updated *= numext::sqrt(t);
+  }
+}
+
+}  // end namespace internal
+
+/** \ingroup QR_Module
+ *
+ * \class RandColPivHouseholderQR
+ *
+ * \brief Randomized blocked Householder rank-revealing QR with column pivoting
+ *
+ * \tparam MatrixType_ the type of the matrix being decomposed.
+ * \tparam PermutationIndex_ the type of the permutation indices.
+ *
+ * \warning This decomposition is significantly slower when \c MatrixType_
+ * uses \c RowMajor storage. Prefer \c ColMajor storage when performance matters.
+ *
+ * Computes \f$ \mathbf{A} \mathbf{P} = \mathbf{Q} \mathbf{R} \f$ using the
+ * BQRRP framework introduced by Melnichenko, Murray, Killian, Demmel,
+ * Mahoney, Luszczek, and Gates, *Anatomy of High-Performance Column-Pivoted
+ * QR Decomposition*, arXiv:2507.00976 (2025). BQRRP is itself a refinement
+ * of the earlier randomized blocked QRCP schemes of Duersch and Gu (RQRCP,
+ * SIAM J. Sci. Comput. 39(4):C263–C291, 2017, arXiv:1509.06820) and
+ * Martinsson, Quintana-Ortí, Heavner, and van de Geijn (HQRRP, SIAM J. Sci.
+ * Comput. 39(2):C96–C115, 2017, arXiv:1512.02671).
+ *
+ * The classical Businger–Golub pivot scan is replaced by selecting blocks
+ * of \c b pivots from a small Gaussian sketch \f$ \mathbf{Y} = \mathbf{G}
+ * \mathbf{A} \f$ with \f$ \mathbf{G} \in \mathbb{R}^{b \times m} \f$
+ * having i.i.d.\ standard normal entries. Following the BQRRP paper, pivot
+ * decisions on the sketch are produced by a partial-pivoted LU on the
+ * transposed sketch (cheap and robust), the panel itself is factored with
+ * unpivoted blocked Householder QR, the trailing block is updated through
+ * the compact-WY apply, and the sketch is downdated by the closed-form
+ * Duersch–Gu update. After each block step the asymptotic flop count
+ * matches that of an unpivoted blocked Householder QR
+ * (\f$ 2mn^2 - \tfrac{2}{3}n^3 \f$ for \f$ m \ge n \f$); almost all
+ * computation is BLAS-3, which lifts the BLAS-2 ceiling that limits
+ * ColPivHouseholderQR.
+ *
+ * The pivot-quality tradeoff is empirically minor: on the matrices in the
+ * cited papers, the rank-revealing behavior is comparable to classical
+ * column pivoting (LAPACK \c geqp3).
+ *
+ * The block size \c b can be configured via setBlockSize(); a value of
+ * \c 0 (the default) leaves the algorithm free to pick a size that scales
+ * with the input. The seed for the internal RNG can be fixed with
+ * setSeed() for reproducible output.
+ *
+ * \note The \c setOversampling() / \c oversampling() accessors are
+ * retained as documented no-ops for source compatibility with earlier
+ * HQRRP-style versions of this class. The BQRRP framework with
+ * partial-pivoted-LU pivot selection makes oversampling unnecessary
+ * (see Section 2.1 of arXiv:2507.00976).
+ *
+ * This class supports the \link InplaceDecomposition inplace decomposition
+ * \endlink mechanism. The same public API as ColPivHouseholderQR is
+ * provided.
+ *
+ * \sa ColPivHouseholderQR, MatrixBase::randColPivHouseholderQr()
+ */
+template <typename MatrixType_, typename PermutationIndex_>
+class RandColPivHouseholderQR : public SolverBase<RandColPivHouseholderQR<MatrixType_, PermutationIndex_>>,
+                                public RankRevealingBase<RandColPivHouseholderQR<MatrixType_, PermutationIndex_>> {
+ public:
+  using MatrixType = MatrixType_;
+  using Base = SolverBase<RandColPivHouseholderQR>;
+  using RankRevealingBase_ = RankRevealingBase<RandColPivHouseholderQR>;
+  friend class SolverBase<RandColPivHouseholderQR>;
+  friend class RankRevealingBase<RandColPivHouseholderQR>;
+  using RankRevealingBase_::dimensionOfKernel;
+  using RankRevealingBase_::isInjective;
+  using RankRevealingBase_::isInvertible;
+  using RankRevealingBase_::isSurjective;
+  using RankRevealingBase_::maxPivot;
+  using RankRevealingBase_::nonzeroPivots;
+  using RankRevealingBase_::rank;
+  using RankRevealingBase_::setThreshold;
+  using RankRevealingBase_::threshold;
+  using PermutationIndex = PermutationIndex_;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(RandColPivHouseholderQR)
+
+  enum {
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+  using HCoeffsType = typename internal::plain_diag_type<MatrixType>::type;
+  using PermutationType = PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime, PermutationIndex>;
+  using IntRowVectorType = typename internal::plain_row_type<MatrixType, PermutationIndex>::type;
+  using RowVectorType = typename internal::plain_row_type<MatrixType>::type;
+  using RealRowVectorType = typename internal::plain_row_type<MatrixType, RealScalar>::type;
+  using HouseholderSequenceType =
+      HouseholderSequence<MatrixType, internal::remove_all_t<typename HCoeffsType::ConjugateReturnType>>;
+  using PlainObject = typename MatrixType::PlainObject;
+
+ private:
+  // Default `m_blockSize == 0` means: let computeInPlace pick a size
+  // tuned to the input dimensions and the host cache hierarchy.
+  static constexpr Index kAutoBlockSize = 0;
+
+  // SIMD-kernel efficiency floor; smaller blocks degrade the panel-QR
+  // and trailing-GEMM kernels without speeding up the sketch.
+  static constexpr Index kKernelFloor = 48;
+  // Hard upper bound on the auto block size.
+  static constexpr Index kBlockCeiling = 1024;
+
+  // Minimum min(rows, cols) at which auto-block enters the blocked path.
+  // Below this, the per-compute sketch overhead (G fill, G*A, per-panel
+  // LU on the sketch) is not amortized by the trailing-GEMM savings vs.
+  // classical Businger-Golub pivoting. Empirically calibrated (Apple M4,
+  // double): n ~= 128 loses by ~1.5x, n >= 256 wins. Set above the
+  // kernel-efficiency floor so that `can_block` (size >= 2*b) cannot
+  // fire below it. A user who calls `setBlockSize(b > 0)` explicitly
+  // bypasses this gate.
+  static constexpr Index kAutoBlockedPathMinSize = 192;
+
+  // L2 cache size in bytes, from Eigen's shared cache-sizes singleton
+  // (which handles cross-platform detection plus user overrides via
+  // setCpuCacheSizes).
+  static Index defaultL2Bytes() {
+    std::ptrdiff_t l1, l2, l3;
+    internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
+    return Index(l2);
+  }
+
+  // Roofline-derived auto block size for `m_blockSize == kAutoBlockSize`.
+  // `size = min(rows, cols)` is passed in to avoid recomputing it.
+  //
+  // The dominant per-iteration cost is the trailing-update GEMM
+  // (compact-WY apply: C := C - V*T*V^T*C). With panel V resident in
+  // cache, the arithmetic intensity is
+  //    AI = 2*b / sizeof(Scalar)     [FLOPS / byte]
+  // which crosses the roofline ceiling AI_crit = peak_FLOPS / cache_BW
+  // at b roughly 2-3 on current hardware. That bound is dominated by the
+  // SIMD-kernel efficiency floor (~48); the roofline therefore gives no
+  // useful lower bound on b.
+  //
+  // The binding constraint is the cache-fit invariant: V must stay
+  // resident across the trailing sweep, otherwise the streamed re-reads
+  // drop us off the compute roof onto the DRAM-bandwidth side. That
+  // yields the upper bound
+  //    b * rows * sizeof(Scalar) <= L2 / 2     (half of L2; remainder
+  //                                              for the streamed C tile)
+  // BQRRP's recommended b ~= n/32 (paper Section 3.2) sits inside this
+  // window for matrices up to roughly 16 * L2 / (rows * sizeof(Scalar));
+  // beyond that, the cache bound binds and clamps b.
+  static Index computeAutoBlockSize(Index rows, Index size) {
+    // Degenerate empty inputs (0 rows or 0 cols): there is no work, and
+    // the cache-bound calculation below would divide by `rows`. Return 0
+    // so the caller's can_block check (b > 0) routes to the unblocked
+    // path, which handles empty matrices correctly.
+    if (rows <= 0 || size <= 0) return Index(0);
+    const Index scalar_bytes = Index(sizeof(Scalar));
+    const Index b_cache = numext::maxi(Index(1), (defaultL2Bytes() / Index(2)) / (rows * scalar_bytes));
+    const Index b_bqrrp = size / Index(32);
+
+    Index b = numext::maxi(Index(kKernelFloor), b_bqrrp);
+    b = numext::mini(b, numext::maxi(Index(kKernelFloor), b_cache));
+    b = numext::mini(b, Index(kBlockCeiling));
+    return b;
+  }
+
+  void init(Index rows, Index cols) {
+    Index diag = numext::mini(rows, cols);
+    m_hCoeffs.resize(diag);
+    m_colsPermutation.resize(cols);
+    m_temp.resize(cols);
+    m_isInitialized = false;
+  }
+
+ public:
+  /** \brief Default constructor. */
+  RandColPivHouseholderQR() = default;
+
+  /** \brief Constructor with memory preallocation. */
+  RandColPivHouseholderQR(Index rows, Index cols) : m_qr(rows, cols) { init(rows, cols); }
+
+  /** \brief Constructs and computes a QR factorization from \a matrix. */
+  template <typename InputType>
+  explicit RandColPivHouseholderQR(const EigenBase<InputType>& matrix) : m_qr(matrix.rows(), matrix.cols()) {
+    init(matrix.rows(), matrix.cols());
+    compute(matrix.derived());
+  }
+
+  /** \brief Inplace constructor: takes a Ref and decomposes in place. */
+  template <typename InputType>
+  explicit RandColPivHouseholderQR(EigenBase<InputType>& matrix) : m_qr(matrix.derived()) {
+    init(matrix.rows(), matrix.cols());
+    computeInPlace();
+  }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  template <typename Rhs>
+  inline Solve<RandColPivHouseholderQR, Rhs> solve(const MatrixBase<Rhs>& b) const;
+#endif
+
+  HouseholderSequenceType householderQ() const;
+  HouseholderSequenceType matrixQ() const { return householderQ(); }
+
+  const MatrixType& matrixQR() const {
+    eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+    return m_qr;
+  }
+
+  const MatrixType& matrixR() const {
+    eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+    return m_qr;
+  }
+
+  template <typename InputType>
+  RandColPivHouseholderQR& compute(const EigenBase<InputType>& matrix);
+
+  const PermutationType& colsPermutation() const {
+    eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+    return m_colsPermutation;
+  }
+
+  typename MatrixType::Scalar determinant() const;
+  typename MatrixType::RealScalar absDeterminant() const;
+  typename MatrixType::RealScalar logAbsDeterminant() const;
+  typename MatrixType::Scalar signDeterminant() const;
+
+  RealScalar pivotCoeff(Index i) const {
+    using std::abs;
+    return abs(m_qr.coeff(i, i));
+  }
+
+  inline Inverse<RandColPivHouseholderQR> inverse() const {
+    eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+    return Inverse<RandColPivHouseholderQR>(*this);
+  }
+
+  inline Index rows() const { return m_qr.rows(); }
+  inline Index cols() const { return m_qr.cols(); }
+
+  const HCoeffsType& hCoeffs() const { return m_hCoeffs; }
+
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+    return Success;
+  }
+
+  /** \brief Sets the panel block size \c b.
+   *
+   * Larger \c b increases the proportion of work performed in level-3
+   * BLAS but raises the per-iteration overhead. Pass \c b = 0 (the
+   * default) to let the algorithm pick a size that scales with the
+   * input dimensions; this matches the BQRRP paper's recommendation of
+   * roughly \c n/32 for large square inputs.
+   *
+   * For small matrices (where \c min(m,n) < 2b) this class transparently
+   * falls back to the unblocked column-pivoted scalar loop.
+   */
+  RandColPivHouseholderQR& setBlockSize(Index b) {
+    eigen_assert(b >= 0 && "Block size must be non-negative.");
+    m_blockSize = b;
+    return *this;
+  }
+
+  /** \brief Sets the oversampling parameter \c p.
+   *
+   * \deprecated With the BQRRP-style LU-on-transposed-sketch pivot
+   * selection used by this class, oversampling provides no benefit (see
+   * Section 2.1 of arXiv:2507.00976: the first \c b pivots are
+   * independent of the oversampling factor). Retained for source
+   * compatibility; the value is ignored.
+   */
+  RandColPivHouseholderQR& setOversampling(Index /*p*/) { return *this; }
+
+  /** \brief Fixes the seed of the internal RNG for reproducible factorization.
+   *
+   * If never called, each call to compute() draws a fresh seed from
+   * \c std::random_device.
+   */
+  RandColPivHouseholderQR& setSeed(uint64_t seed) {
+    m_seed = seed;
+    m_seedSet = true;
+    return *this;
+  }
+
+  /** \brief Returns the user-set panel block size, or \c 0 if the
+   * algorithm should pick automatically. The actual block size used
+   * during compute() is not exposed.
+   */
+  Index blockSize() const { return m_blockSize; }
+
+  /** \deprecated Returns 0; oversampling is no longer used. \sa setOversampling() */
+  Index oversampling() const { return Index(0); }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const;
+
+  template <bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType& rhs, DstType& dst) const;
+#endif
+
+ protected:
+  friend class internal::CompleteOrthogonalDecompositionImpl<MatrixType, PermutationIndex, RandColPivHouseholderQR>;
+
+  EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
+
+  void computeInPlace();
+
+  // Unblocked column-pivoted Householder QR on rows [row0, m) and columns
+  // [col0, col0 + ncols), using full-column swaps. Updates m_hCoeffs in
+  // [col0, col0 + ncols), m_colsPermutation, and the maxpivot tracker.
+  // Returns the number of column transpositions applied. Used both as
+  // the small-matrix fallback path and as the rank-deficient tail of the
+  // blocked path.
+  Index unblocked_pivoted_qr(Index row0, Index col0, Index ncols, RealScalar threshold_helper);
+
+  // Scan the diagonal of m_qr and set m_nonzero_pivots / m_maxpivot using
+  // the LAWN-176 threshold (same scale as ColPivHouseholderQR).
+  void finalize_rank(RealScalar threshold_helper);
+
+  MatrixType m_qr;
+  HCoeffsType m_hCoeffs;
+  PermutationType m_colsPermutation;
+  RowVectorType m_temp;
+  Index m_blockSize = kAutoBlockSize;
+  uint64_t m_seed = 0;
+  bool m_seedSet = false;
+  bool m_isInitialized = false;
+  Index m_det_p = 1;
+};
+
+template <typename MatrixType, typename PermutationIndex>
+typename MatrixType::Scalar RandColPivHouseholderQR<MatrixType, PermutationIndex>::determinant() const {
+  eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  Scalar detQ;
+  internal::householder_determinant<HCoeffsType, Scalar, NumTraits<Scalar>::IsComplex>::run(m_hCoeffs, detQ);
+  return isInjective() ? (detQ * Scalar(m_det_p)) * m_qr.diagonal().prod() : Scalar(0);
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename MatrixType::RealScalar RandColPivHouseholderQR<MatrixType, PermutationIndex>::absDeterminant() const {
+  using std::abs;
+  eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return isInjective() ? abs(m_qr.diagonal().prod()) : RealScalar(0);
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename MatrixType::RealScalar RandColPivHouseholderQR<MatrixType, PermutationIndex>::logAbsDeterminant() const {
+  eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  return isInjective() ? m_qr.diagonal().cwiseAbs().array().log().sum() : -NumTraits<RealScalar>::infinity();
+}
+
+template <typename MatrixType, typename PermutationIndex>
+typename MatrixType::Scalar RandColPivHouseholderQR<MatrixType, PermutationIndex>::signDeterminant() const {
+  eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
+  Scalar detQ;
+  internal::householder_determinant<HCoeffsType, Scalar, NumTraits<Scalar>::IsComplex>::run(m_hCoeffs, detQ);
+  return isInjective() ? (detQ * Scalar(m_det_p)) * m_qr.diagonal().array().sign().prod() : Scalar(0);
+}
+
+template <typename MatrixType, typename PermutationIndex>
+template <typename InputType>
+RandColPivHouseholderQR<MatrixType, PermutationIndex>& RandColPivHouseholderQR<MatrixType, PermutationIndex>::compute(
+    const EigenBase<InputType>& matrix) {
+  m_qr = matrix.derived();
+  computeInPlace();
+  return *this;
+}
+
+template <typename MatrixType, typename PermutationIndex>
+Index RandColPivHouseholderQR<MatrixType, PermutationIndex>::unblocked_pivoted_qr(Index row0, Index col0, Index ncols,
+                                                                                  RealScalar threshold_helper) {
+  using std::abs;
+  const Index rows = m_qr.rows();
+  const Index col_end = col0 + ncols;
+  const Index sub_rows = rows - row0;
+  Index num_transpositions = 0;
+
+  Matrix<RealScalar, 1, Dynamic> norms_direct = m_qr.block(row0, col0, sub_rows, ncols).colwise().norm();
+  Matrix<RealScalar, 1, Dynamic> norms_updated = norms_direct;
+  const RealScalar downdate_threshold = numext::sqrt(NumTraits<RealScalar>::epsilon());
+
+  const Index size = (std::min)(sub_rows, ncols);
+  for (Index k = 0; k < size; ++k) {
+    Index biggest;
+    RealScalar biggest_sq = numext::abs2(norms_updated.tail(ncols - k).maxCoeff(&biggest));
+    biggest += k;
+
+    if (this->m_nonzero_pivots == m_qr.diagonalSize() && biggest_sq < threshold_helper * RealScalar(rows - row0 - k))
+      this->m_nonzero_pivots = col0 + k;
+
+    if (k != biggest) {
+      m_qr.col(col0 + k).swap(m_qr.col(col0 + biggest));
+      std::swap(norms_updated.coeffRef(k), norms_updated.coeffRef(biggest));
+      std::swap(norms_direct.coeffRef(k), norms_direct.coeffRef(biggest));
+      m_colsPermutation.applyTranspositionOnTheRight(col0 + k, col0 + biggest);
+      ++num_transpositions;
+    }
+
+    RealScalar beta;
+    m_qr.col(col0 + k).tail(sub_rows - k).makeHouseholderInPlace(m_hCoeffs.coeffRef(col0 + k), beta);
+    m_qr.coeffRef(row0 + k, col0 + k) = beta;
+    if (abs(beta) > this->m_maxpivot) this->m_maxpivot = abs(beta);
+
+    // Apply the reflector only to the remaining panel columns. Columns at
+    // indices >= col_end are owned by the outer caller and updated via a
+    // BLAS-3 trailing update; in the tail/fallback path col_end equals
+    // m_qr.cols(), so this naturally degrades to a full apply.
+    const Index trail_cols = col_end - col0 - k - 1;
+    if (trail_cols > 0) {
+      m_qr.block(row0 + k, col0 + k + 1, sub_rows - k, trail_cols)
+          .applyHouseholderOnTheLeft(m_qr.col(col0 + k).tail(sub_rows - k - 1), m_hCoeffs.coeff(col0 + k),
+                                     &m_temp.coeffRef(col0 + k + 1));
+    }
+
+    for (Index j = k + 1; j < ncols; ++j) {
+      internal::lawn176_norm_downdate(norms_updated.coeffRef(j), norms_direct.coeffRef(j),
+                                      m_qr.coeff(row0 + k, col0 + j), downdate_threshold,
+                                      [&] { return m_qr.col(col0 + j).tail(sub_rows - k - 1).norm(); });
+    }
+  }
+  return num_transpositions;
+}
+
+template <typename MatrixType, typename PermutationIndex>
+void RandColPivHouseholderQR<MatrixType, PermutationIndex>::finalize_rank(RealScalar threshold_helper) {
+  using std::abs;
+  const Index rows = m_qr.rows();
+  const Index size = (std::min)(rows, m_qr.cols());
+  // m_maxpivot is already up-to-date: the blocked path tracks it per
+  // panel, and unblocked_pivoted_qr tracks it per step.
+  // If neither the blocked path nor the unblocked tail tightened the
+  // rank cap, fall back to the LAWN-176 first-below-threshold scan.
+  // This handles the full-rank-blocked-path case where every panel
+  // was full rank and the only "small" diagonal entries are in the
+  // unblocked tail.
+  if (this->m_nonzero_pivots == size) {
+    for (Index i = 0; i < size; ++i) {
+      RealScalar a = abs(m_qr.coeff(i, i));
+      if (numext::abs2(a) < threshold_helper * RealScalar(rows - i)) {
+        this->m_nonzero_pivots = i;
+        break;
+      }
+    }
+  }
+}
+
+template <typename MatrixType, typename PermutationIndex>
+void RandColPivHouseholderQR<MatrixType, PermutationIndex>::computeInPlace() {
+  eigen_assert(m_qr.cols() <= NumTraits<PermutationIndex>::highest());
+
+  const Index rows = m_qr.rows();
+  const Index cols = m_qr.cols();
+  const Index size = (std::min)(rows, cols);
+
+  m_hCoeffs.resize(size);
+  m_temp.resize(cols);
+  m_colsPermutation.resize(cols);
+  m_colsPermutation.setIdentity();
+  this->m_nonzero_pivots = size;
+  this->m_maxpivot = RealScalar(0);
+  Index num_transpositions = 0;
+
+  // Global rank-detection scale, derived from the original column norms
+  // exactly as ColPivHouseholderQR does (LAWN-176). All panel calls share
+  // this threshold so rank revelation is consistent across blocks.
+  RealScalar max_initial_norm = RealScalar(0);
+  for (Index j = 0; j < cols; ++j) max_initial_norm = numext::maxi(max_initial_norm, m_qr.col(j).norm());
+  const RealScalar threshold_helper =
+      cols == 0 ? RealScalar(0)
+                : numext::abs2<RealScalar>(max_initial_norm * NumTraits<RealScalar>::epsilon()) / RealScalar(rows);
+
+  const bool auto_block = (m_blockSize == kAutoBlockSize);
+  const Index requested_b = auto_block ? computeAutoBlockSize(rows, size) : m_blockSize;
+  const Index b = (std::min)(requested_b, size);
+
+  // Gates for entering the blocked path:
+  //   - `b > 0` and `rows > b` for the trailing update to have work,
+  //   - `size >= 2*b` so at least two full blocks fit (one block + tail
+  //     is handled more efficiently by the unblocked path),
+  //   - in the auto-block path, an additional size threshold so the
+  //     sketch overhead is amortized by trailing-GEMM savings (see
+  //     kAutoBlockedPathMinSize). Users who pin a block size via
+  //     setBlockSize() bypass this — useful for tests that need to
+  //     exercise the blocked path on small inputs.
+  const bool can_block = (b > 0) && (size >= 2 * b) && (rows > b) && (!auto_block || size >= kAutoBlockedPathMinSize);
+  if (!can_block) {
+    num_transpositions += unblocked_pivoted_qr(0, 0, cols, threshold_helper);
+    m_det_p = (num_transpositions % 2) ? -1 : 1;
+    finalize_rank(threshold_helper);
+    m_isInitialized = true;
+    return;
+  }
+
+  using WorkMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using WorkVector = Matrix<Scalar, Dynamic, 1>;
+  // Dynamic-sized Ref types so that a fixed-size MatrixType (e.g.
+  // Matrix<float, 8, 10>) and its run-time-sized blocks can both be
+  // wrapped without tripping Ref's compile-time-size check.
+  using WorkMatrixRef = Ref<WorkMatrix, 0, OuterStride<>>;
+  // Panels of m_qr carry MatrixType's storage order, which need not be the workspaces'.
+  using QrMatrix = Matrix<Scalar, Dynamic, Dynamic, MatrixType::IsRowMajor ? RowMajor : ColMajor>;
+  using QrPanelRef = Ref<QrMatrix, 0, OuterStride<>>;
+  using HCoeffsRef = Ref<WorkVector>;
+  using IpivType = Transpositions<Dynamic, Dynamic, PermutationIndex>;
+
+  // Hoisted workspaces — allocated once per compute() call. Worst-case
+  // sizes are computed from the first iteration (n_remain = cols,
+  // trail_cols = cols - b); subsequent iterations use shrinking
+  // sub-blocks via leftCols/topRows.
+  WorkMatrix Y(b, cols);
+  WorkMatrix YT(cols, b);
+  WorkMatrix sketch_R(b, b);
+  IpivType ipiv(b);
+  WorkVector y_hcoeffs(b);
+  WorkVector y_temp(cols);
+
+  // Initialize the sketch Y = G * A. We don't keep G around; the
+  // Duersch-Gu update (step 24) maintains Y deterministically from
+  // here on.
+  {
+    WorkMatrix G(b, rows);
+    uint64_t seed = m_seed;
+    if (!m_seedSet) {
+      std::random_device rd;
+      seed = (uint64_t(rd()) << 32) | uint64_t(rd());
+    }
+    std::mt19937_64 engine(seed);
+    internal::fill_gaussian(G, engine);
+    Y.noalias() = G * m_qr;
+  }
+
+  Index k = 0;
+  bool blocked_terminated_early = false;
+  while (k + b <= size && cols - k > b) {
+    const Index n_remain = cols - k;        // columns from k to end
+    const Index trail_cols = n_remain - b;  // columns to the right of the panel
+    const Index sub_rows = rows - k;        // rows from k to end
+
+    // === Step 7 (Algorithm 2): "crazy man's QRCP" on the sketch.
+    // Form Y_T = Y(:, k:)^T and run partial-pivoted LU on it. The IPIV
+    // vector tells us which b columns of Y(:, k:) (and thus which
+    // columns of m_qr.middleCols(k, n_remain)) to bring to the front.
+    auto Y_curr = Y.middleCols(k, n_remain);
+    auto Y_T = YT.topRows(n_remain);
+    Y_T = Y_curr.transpose();
+
+    typename IpivType::StorageIndex nb_lu_transp = 0;
+    internal::partial_lu_inplace(Y_T, ipiv, nb_lu_transp);
+
+    // === Steps 9-11: apply IPIV to columns of m_qr and Y starting at
+    // absolute column k (LAPACK-style serial swaps; equivalent to
+    // applying Algorithm 4 of the BQRRP paper to the converted pivot
+    // vector).
+    for (Index i = 0; i < b; ++i) {
+      Index dst = static_cast<Index>(ipiv.coeff(i));
+      if (dst != i) {
+        m_qr.col(k + i).swap(m_qr.col(k + dst));
+        Y.col(k + i).swap(Y.col(k + dst));
+        m_colsPermutation.applyTranspositionOnTheRight(k + i, k + dst);
+        ++num_transpositions;
+      }
+    }
+
+    // Materialize R_sk in the upper triangle of Y(:, k:) via unpivoted
+    // blocked Householder QR. We discard the resulting Householder
+    // vectors and tau; only R_sk feeds the step-24 sketch update.
+    // Wrap in `Ref` so householder_qr_inplace_blocked sees a flat
+    // MatrixQR — its internal `Block<MatrixQR, ...>` typedef does not
+    // compose with Block-of-Block expressions.
+    {
+      WorkMatrixRef Y_curr_ref(Y_curr);
+      Ref<WorkVector> y_hc_ref(y_hcoeffs);
+      internal::householder_qr_inplace_blocked<WorkMatrixRef, Ref<WorkVector>>::run(
+          Y_curr_ref, y_hc_ref, /*maxBlockSize=*/(std::min)(b, Index(48)), y_temp.data());
+    }
+
+    // Save R_sk_11 = upper-triangular portion of Y(:, k:k+b) before the
+    // panel QR overwrites the corresponding columns of m_qr (via the
+    // trailing update); we need it for step 24.
+    sketch_R = Y.block(0, k, b, b);
+    // The step-24 update below consumes R_sk_11 as a plain matrix, so clear
+    // the Householder vectors the sketch QR left below its diagonal.
+    sketch_R.template triangularView<StrictlyLower>().setZero();
+
+    // === Step 12: tall unpivoted Householder QR on the panel.
+    auto panel = m_qr.block(k, k, sub_rows, b);
+    auto hCoeffsSegment = m_hCoeffs.segment(k, b);
+    {
+      QrPanelRef panel_ref(panel);
+      HCoeffsRef hc_ref(hCoeffsSegment);
+      internal::householder_qr_inplace_blocked<QrPanelRef, HCoeffsRef>::run(
+          panel_ref, hc_ref, /*maxBlockSize=*/(std::min)(b, Index(48)), m_temp.data());
+    }
+
+    this->m_maxpivot = (std::max)(this->m_maxpivot, m_qr.diagonal().segment(k, b).cwiseAbs().maxCoeff());
+
+    // Detect rank deficiency by scanning the panel's diagonal against
+    // a relative threshold (max pivot seen so far times the default
+    // RankRevealingBase tolerance). The LAWN-176 threshold used by
+    // ColPivHouseholderQR assumes a strictly monotonic diagonal —
+    // BQRRP's unpivoted panel QR breaks that assumption for matrices
+    // with closely-spaced singular values (e.g. partial isometries),
+    // so we use the same relative tolerance that RankRevealingBase::
+    // rank() applies to the final diagonal.
+    Index panel_rank = b;
+    {
+      using std::abs;
+      const RealScalar relative_cutoff = this->m_maxpivot * NumTraits<RealScalar>::epsilon() * RealScalar(4 * size);
+      for (Index i = 0; i < b; ++i) {
+        RealScalar a = abs(m_qr.coeff(k + i, k + i));
+        if (a <= relative_cutoff) {
+          panel_rank = i;
+          break;
+        }
+      }
+    }
+
+    // === Step 17: apply Q^H from the panel to the trailing block.
+    // The loop guard `cols - k > b` guarantees `trail_cols > 0`. We
+    // pass the un-conjugated coeffs because apply_block_householder_on_the_left
+    // conjugates internally when forward=false (matching how HouseholderQR
+    // drives this same routine).
+    auto trailing = m_qr.block(k, k + b, sub_rows, trail_cols);
+    internal::apply_block_householder_on_the_left(trailing, panel, hCoeffsSegment,
+                                                  /*forward=*/false);
+
+    if (panel_rank < b) {
+      // Pin the rank cap and break out; the unblocked tail will
+      // process the remaining columns. The tail's m_nonzero_pivots
+      // write is gated on it still being unset (== diagonalSize),
+      // so a tighter cap from here survives.
+      if (this->m_nonzero_pivots == size) {
+        this->m_nonzero_pivots = k + panel_rank;
+      }
+      k += b;
+      blocked_terminated_early = true;
+      break;
+    }
+
+    // === Step 24: Duersch-Gu sketch update.
+    //   Y(:, k+b:) := R_sk_12 - R_sk_11 * R_11^{-1} * R_12
+    // R_sk_12 currently sits in Y.middleCols(k+b, trail_cols) (the QR of
+    // the sketch above placed it there). R_sk_11 we saved into sketch_R.
+    // R_11 and R_12 are the corresponding blocks of m_qr after the
+    // panel QR + trailing update.
+    // Associating as (R_sk_11 * R_11^{-1}) * R_12 keeps the triangular solve at
+    // b x b and leaves a single GEMM reading R_12 straight out of m_qr: no
+    // b x trail_cols workspace, and no wide triangular solve/product (both of
+    // which run well below GEMM throughput).
+    {
+      m_qr.block(k, k, b, b).template triangularView<Upper>().template solveInPlace<OnTheRight>(sketch_R);
+      Y.middleCols(k + b, trail_cols).noalias() -= sketch_R * m_qr.block(k, k + b, b, trail_cols);
+    }
+
+    k += b;
+  }
+
+  // Tail loop: any remaining columns (last partial block, or the rank-
+  // deficient remainder after early termination) handled by the
+  // unblocked pivoted QR. This routine also updates m_nonzero_pivots
+  // along its diagonal scan, which finalize_rank below cross-checks.
+  if (k < cols && (k < size || blocked_terminated_early)) {
+    num_transpositions += unblocked_pivoted_qr(k, k, cols - k, threshold_helper);
+  }
+
+  m_det_p = (num_transpositions % 2) ? -1 : 1;
+
+  // Final rank determination: scan the entire diagonal with the LAWN-176
+  // threshold. This refines whatever the unblocked tail set, and covers
+  // the full-rank blocked path where m_nonzero_pivots was never touched.
+  finalize_rank(threshold_helper);
+
+  m_isInitialized = true;
+}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename MatrixType_, typename PermutationIndex_>
+template <typename RhsType, typename DstType>
+void RandColPivHouseholderQR<MatrixType_, PermutationIndex_>::_solve_impl(const RhsType& rhs, DstType& dst) const {
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if (nonzero_pivots == 0) {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(rhs);
+
+  c.applyOnTheLeft(householderQ().setLength(nonzero_pivots).adjoint());
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  for (Index i = 0; i < nonzero_pivots; ++i) dst.row(m_colsPermutation.indices().coeff(i)) = c.row(i);
+  for (Index i = nonzero_pivots; i < cols(); ++i) dst.row(m_colsPermutation.indices().coeff(i)).setZero();
+}
+
+template <typename MatrixType_, typename PermutationIndex_>
+template <bool Conjugate, typename RhsType, typename DstType>
+void RandColPivHouseholderQR<MatrixType_, PermutationIndex_>::_solve_impl_transposed(const RhsType& rhs,
+                                                                                     DstType& dst) const {
+  const Index nonzero_pivots = nonzeroPivots();
+
+  if (nonzero_pivots == 0) {
+    dst.setZero();
+    return;
+  }
+
+  typename RhsType::PlainObject c(m_colsPermutation.transpose() * rhs);
+
+  m_qr.topLeftCorner(nonzero_pivots, nonzero_pivots)
+      .template triangularView<Upper>()
+      .transpose()
+      .template conjugateIf<Conjugate>()
+      .solveInPlace(c.topRows(nonzero_pivots));
+
+  dst.topRows(nonzero_pivots) = c.topRows(nonzero_pivots);
+  dst.bottomRows(rows() - nonzero_pivots).setZero();
+
+  dst.applyOnTheLeft(householderQ().setLength(nonzero_pivots).template conjugateIf<!Conjugate>());
+}
+#endif
+
+namespace internal {
+
+template <typename DstXprType, typename MatrixType, typename PermutationIndex>
+struct Assignment<DstXprType, Inverse<RandColPivHouseholderQR<MatrixType, PermutationIndex>>,
+                  internal::assign_op<typename DstXprType::Scalar,
+                                      typename RandColPivHouseholderQR<MatrixType, PermutationIndex>::Scalar>,
+                  Dense2Dense> {
+  using QrType = RandColPivHouseholderQR<MatrixType, PermutationIndex>;
+  using SrcXprType = Inverse<QrType>;
+  static void run(DstXprType& dst, const SrcXprType& src,
+                  const internal::assign_op<typename DstXprType::Scalar, typename QrType::Scalar>&) {
+    dst = src.nestedExpression().solve(MatrixType::Identity(src.rows(), src.cols()));
+  }
+};
+
+}  // end namespace internal
+
+template <typename MatrixType, typename PermutationIndex>
+typename RandColPivHouseholderQR<MatrixType, PermutationIndex>::HouseholderSequenceType
+RandColPivHouseholderQR<MatrixType, PermutationIndex>::householderQ() const {
+  eigen_assert(m_isInitialized && "RandColPivHouseholderQR is not initialized.");
+  return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
+}
+
+/** \return the randomized column-pivoted Householder QR decomposition of \c *this.
+ *
+ * \sa class RandColPivHouseholderQR
+ */
+template <typename Derived>
+template <typename PermutationIndexType>
+RandColPivHouseholderQR<typename MatrixBase<Derived>::PlainObject, PermutationIndexType>
+MatrixBase<Derived>::randColPivHouseholderQr() const {
+  return RandColPivHouseholderQR<PlainObject, PermutationIndexType>(eval());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_RANDCOLPIVOTINGHOUSEHOLDERQR_H
diff --git a/Eigen/src/SPQRSupport/InternalHeaderCheck.h b/Eigen/src/SPQRSupport/InternalHeaderCheck.h
index 8d94ba4..c24d790 100644
--- a/Eigen/src/SPQRSupport/InternalHeaderCheck.h
+++ b/Eigen/src/SPQRSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SPQRSUPPORT_MODULE_H
 #error "Please include Eigen/SPQRSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h b/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
index 3132794..e43658f 100644
--- a/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
+++ b/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SUITESPARSEQRSUPPORT_H
 #define EIGEN_SUITESPARSEQRSUPPORT_H
@@ -28,6 +29,11 @@
 template <typename SPQRType>
 struct traits<SPQRMatrixQReturnType<SPQRType> > {
   typedef typename SPQRType::MatrixType ReturnType;
+  typedef typename ReturnType::Scalar Scalar;
+  typedef typename ReturnType::StorageIndex StorageIndex;
+  typedef typename ReturnType::StorageKind StorageKind;
+  static constexpr int RowsAtCompileTime = Dynamic;
+  static constexpr int ColsAtCompileTime = Dynamic;
 };
 template <typename SPQRType>
 struct traits<SPQRMatrixQTransposeReturnType<SPQRType> > {
@@ -45,7 +51,7 @@
  * \brief Sparse QR factorization based on SuiteSparseQR library
  *
  * This class is used to perform a multithreaded and multifrontal rank-revealing QR decomposition
- * of sparse matrices. The result is then used to solve linear leasts_square systems.
+ * of sparse matrices. The result is then used to solve linear least-squares systems.
  * Clearly, a QR factorization is returned such that A*P = Q*R where :
  *
  * P is the column permutation. Use colsPermutation() to get it.
@@ -54,8 +60,8 @@
  * Use matrixQ() to get an expression and matrixQ().transpose() to get the transpose.
  * You can then apply it to a vector.
  *
- * R is the sparse triangular factor. Use matrixQR() to get it as SparseMatrix.
- * NOTE : The Index type of R is always SuiteSparse_long. You can get it with SPQR::Index
+ * R is the sparse triangular factor. Use matrixR() to get it as SparseMatrix.
+ * NOTE : The storage index type of R is always SuiteSparse_long. You can get it with SPQR::StorageIndex
  *
  * \tparam MatrixType_ The type of the sparse matrix A, must be a column-major SparseMatrix<>
  *
@@ -120,7 +126,9 @@
     cholmod_l_free_sparse(&m_cR, &m_cc);
     cholmod_l_free_dense(&m_HTau, &m_cc);
     std::free(m_E);
+    m_E = nullptr;
     std::free(m_HPinv);
+    m_HPinv = nullptr;
   }
 
   void compute(const MatrixType_& matrix) {
@@ -150,6 +158,12 @@
       m_isInitialized = false;
       return;
     }
+    if (!m_E && !initIdentityPermutation(m_cR->ncol)) {
+      SPQR_free();
+      m_info = NumericalIssue;
+      m_isInitialized = false;
+      return;
+    }
     m_info = Success;
     m_isInitialized = true;
     m_isRUpToDate = false;
@@ -185,15 +199,12 @@
     for (Index i = 0; i < rk; ++i) dest.row(m_E[i]) = y.row(i);
     for (Index i = rk; i < cols(); ++i) dest.row(m_E[i]).setZero();
 
-    //       y.bottomRows(y.rows()-rk).setZero();
-    //       dest = colsPermutation() * y.topRows(cols());
-
     m_info = Success;
   }
 
   /** \returns the sparse triangular factor R. It is a sparse matrix
    */
-  const MatrixType matrixR() const {
+  const MatrixType& matrixR() const {
     eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
     if (!m_isRUpToDate) {
       m_R = viewAsEigen<Scalar, StorageIndex>(*m_cR);
@@ -210,7 +221,8 @@
   }
   /**
    * Gets the rank of the matrix.
-   * It should be equal to matrixQR().cols if the matrix is full-rank
+   * It should be equal to matrixR().rows() if the matrix is full-rank; matrixR().cols() is always the number of
+   * columns of the input matrix.
    */
   Index rank() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
@@ -218,7 +230,7 @@
   }
   /// Set the fill-reducing ordering method to be used
   void setSPQROrdering(int ord) { m_ordering = ord; }
-  /// Set the tolerance tol to treat columns with 2-norm < =tol as zero
+  /// Set the tolerance tol to treat columns with 2-norm <= tol as zero
   void setPivotThreshold(const RealScalar& tol) {
     m_useDefaultThreshold = false;
     m_tolerance = tol;
@@ -255,6 +267,16 @@
   mutable cholmod_common m_cc;              // Workspace and parameters
   bool m_useDefaultThreshold;               // Use default threshold
   Index m_rows;
+
+  bool initIdentityPermutation(StorageIndex size) {
+    if (m_E || size == 0) return true;
+    // SuiteSparse can omit the permutation array when no column reordering is applied.
+    m_E = static_cast<StorageIndex*>(std::malloc(sizeof(StorageIndex) * size));
+    if (!m_E) return false;
+    for (StorageIndex i = 0; i < size; ++i) m_E[i] = i;
+    return true;
+  }
+
   template <typename, typename>
   friend struct SPQR_QProduct;
 };
@@ -267,33 +289,102 @@
   SPQR_QProduct(const SPQRType& spqr, const Derived& other, bool transpose)
       : m_spqr(spqr), m_other(other), m_transpose(transpose) {}
 
-  inline Index rows() const { return m_transpose ? m_spqr.rows() : m_spqr.cols(); }
+  inline Index rows() const { return m_spqr.rows(); }
   inline Index cols() const { return m_other.cols(); }
   // Assign to a vector
   template <typename ResType>
   void evalTo(ResType& res) const {
+    evalToImpl(res, m_other);
+  }
+
+ private:
+  template <typename ResType, typename OtherDerived,
+            std::enable_if_t<(int(OtherDerived::Flags) & DirectAccessBit) == DirectAccessBit, int> = 0>
+  void evalToImpl(ResType& res, const MatrixBase<OtherDerived>& otherExpr) const {
     cholmod_dense y_cd;
     cholmod_dense* x_cd;
     int method = m_transpose ? SPQR_QTX : SPQR_QX;
     cholmod_common* cc = m_spqr.cholmodCommon();
-    y_cd = viewAsCholmod(m_other.const_cast_derived());
+    y_cd = viewAsCholmod(otherExpr.const_cast_derived());
     x_cd = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cd, cc);
     res = Matrix<Scalar, ResType::RowsAtCompileTime, ResType::ColsAtCompileTime>::Map(
         reinterpret_cast<Scalar*>(x_cd->x), x_cd->nrow, x_cd->ncol);
     cholmod_l_free_dense(&x_cd, cc);
   }
+
+  template <typename ResType, typename OtherDerived,
+            std::enable_if_t<(int(OtherDerived::Flags) & DirectAccessBit) == 0, int> = 0>
+  void evalToImpl(ResType& res, const MatrixBase<OtherDerived>& otherExpr) const {
+    cholmod_dense y_cd;
+    cholmod_dense* x_cd;
+    int method = m_transpose ? SPQR_QTX : SPQR_QX;
+    cholmod_common* cc = m_spqr.cholmodCommon();
+    typename OtherDerived::PlainObject other = otherExpr;
+    y_cd = viewAsCholmod(other);
+    x_cd = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cd, cc);
+    res = Matrix<Scalar, ResType::RowsAtCompileTime, ResType::ColsAtCompileTime>::Map(
+        reinterpret_cast<Scalar*>(x_cd->x), x_cd->nrow, x_cd->ncol);
+    cholmod_l_free_dense(&x_cd, cc);
+  }
+
+  template <typename ResType, typename OtherDerived>
+  void evalToImpl(ResType& res, const SparseMatrixBase<OtherDerived>& otherExpr) const {
+    cholmod_sparse y_cs;
+    cholmod_sparse* x_cs;
+    int method = m_transpose ? SPQR_QTX : SPQR_QX;
+    cholmod_common* cc = m_spqr.cholmodCommon();
+    typename OtherDerived::PlainObject other = otherExpr;
+    other.makeCompressed();
+    y_cs = viewAsCholmod(other);
+    x_cs = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cs, cc);
+    res = viewAsEigen<Scalar, StorageIndex>(*x_cs);
+    cholmod_l_free_sparse(&x_cs, cc);
+  }
+
+  template <typename ResType, typename OtherScalar, int OtherOptions, typename OtherStorageIndex,
+            std::enable_if_t<std::is_same<OtherStorageIndex, StorageIndex>::value, int> = 0>
+  void evalToImpl(ResType& res, const SparseMatrix<OtherScalar, OtherOptions, OtherStorageIndex>& otherExpr) const {
+    cholmod_sparse y_cs;
+    cholmod_sparse* x_cs;
+    int method = m_transpose ? SPQR_QTX : SPQR_QX;
+    cholmod_common* cc = m_spqr.cholmodCommon();
+    const SparseMatrix<OtherScalar, OtherOptions, OtherStorageIndex>* otherPtr = &otherExpr;
+    SparseMatrix<OtherScalar, OtherOptions, OtherStorageIndex> other;
+
+    if (!otherExpr.isCompressed()) {
+      other = otherExpr;
+      other.makeCompressed();
+      otherPtr = &other;
+    }
+
+    y_cs = viewAsCholmod(*otherPtr);
+    x_cs = SuiteSparseQR_qmult<Scalar>(method, m_spqr.m_H, m_spqr.m_HTau, m_spqr.m_HPinv, &y_cs, cc);
+    res = viewAsEigen<Scalar, StorageIndex>(*x_cs);
+    cholmod_l_free_sparse(&x_cs, cc);
+  }
+
+ public:
   const SPQRType& m_spqr;
   const Derived& m_other;
   bool m_transpose;
 };
 template <typename SPQRType>
-struct SPQRMatrixQReturnType {
+struct SPQRMatrixQReturnType : public EigenBase<SPQRMatrixQReturnType<SPQRType> > {
+  typedef typename SPQRType::Scalar Scalar;
+  static constexpr int RowsAtCompileTime = Dynamic;
+  static constexpr int ColsAtCompileTime = Dynamic;
   SPQRMatrixQReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
   template <typename Derived>
   SPQR_QProduct<SPQRType, Derived> operator*(const MatrixBase<Derived>& other) {
     return SPQR_QProduct<SPQRType, Derived>(m_spqr, other.derived(), false);
   }
+  template <typename Derived>
+  SPQR_QProduct<SPQRType, Derived> operator*(const SparseMatrixBase<Derived>& other) {
+    return SPQR_QProduct<SPQRType, Derived>(m_spqr, other.derived(), false);
+  }
   SPQRMatrixQTransposeReturnType<SPQRType> adjoint() const { return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr); }
+  inline Index rows() const { return m_spqr.rows(); }
+  inline Index cols() const { return m_spqr.rows(); }
   // To use for operations with the transpose of Q
   SPQRMatrixQTransposeReturnType<SPQRType> transpose() const {
     return SPQRMatrixQTransposeReturnType<SPQRType>(m_spqr);
@@ -308,8 +399,47 @@
   SPQR_QProduct<SPQRType, Derived> operator*(const MatrixBase<Derived>& other) {
     return SPQR_QProduct<SPQRType, Derived>(m_spqr, other.derived(), true);
   }
+  template <typename Derived>
+  SPQR_QProduct<SPQRType, Derived> operator*(const SparseMatrixBase<Derived>& other) {
+    return SPQR_QProduct<SPQRType, Derived>(m_spqr, other.derived(), true);
+  }
   const SPQRType& m_spqr;
 };
 
+namespace internal {
+
+template <typename SPQRType>
+struct evaluator_traits<SPQRMatrixQReturnType<SPQRType> > {
+  typedef typename SPQRType::MatrixType MatrixType;
+  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
+  typedef SparseShape Shape;
+};
+
+template <typename DstXprType, typename SPQRType>
+struct Assignment<DstXprType, SPQRMatrixQReturnType<SPQRType>,
+                  internal::assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>, Sparse2Sparse> {
+  typedef SPQRMatrixQReturnType<SPQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+
+  static void run(DstXprType& dst, const SrcXprType& src, const internal::assign_op<Scalar, Scalar>& /*func*/) {
+    typename DstXprType::PlainObject idMat(src.rows(), src.cols());
+    idMat.setIdentity();
+    dst = src.m_spqr.matrixQ() * idMat;
+  }
+};
+
+template <typename DstXprType, typename SPQRType>
+struct Assignment<DstXprType, SPQRMatrixQReturnType<SPQRType>,
+                  internal::assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>, Sparse2Dense> {
+  typedef SPQRMatrixQReturnType<SPQRType> SrcXprType;
+  typedef typename DstXprType::Scalar Scalar;
+
+  static void run(DstXprType& dst, const SrcXprType& src, const internal::assign_op<Scalar, Scalar>& /*func*/) {
+    dst = src.m_spqr.matrixQ() * DstXprType::Identity(src.rows(), src.cols());
+  }
+};
+
+}  // namespace internal
+
 }  // End namespace Eigen
 #endif
diff --git a/Eigen/src/SVD/BDCSVD.h b/Eigen/src/SVD/BDCSVD.h
index ed219f0..cfaf3a5 100644
--- a/Eigen/src/SVD/BDCSVD.h
+++ b/Eigen/src/SVD/BDCSVD.h
@@ -16,24 +16,14 @@
 // Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BDCSVD_H
 #define EIGEN_BDCSVD_H
-// #define EIGEN_BDCSVD_DEBUG_VERBOSE
-// #define EIGEN_BDCSVD_SANITY_CHECKS
-
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-#undef eigen_internal_assert
-#define eigen_internal_assert(X) assert(X);
-#endif
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
 
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-#include <iostream>
-#endif
-
 // Internal D&C implementation, templated only on RealScalar.
 #include "BDCSVDImpl.h"
 
@@ -46,7 +36,7 @@
 
 template <typename MatrixType_, int Options>
 struct traits<BDCSVD<MatrixType_, Options> > : svd_traits<MatrixType_, Options> {
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 };
 
 }  // end namespace internal
@@ -64,14 +54,14 @@
  *                  Possible values are #ComputeThinU, #ComputeThinV, #ComputeFullU, #ComputeFullV, and
  *                  #DisableQRDecomposition. It is not possible to request both the thin and full version of \a U or
  *                  \a V. By default, unitaries are not computed. BDCSVD uses R-Bidiagonalization to improve
- *                  performance on tall and wide matrices. For backwards compatility, the option
+ *                  performance on tall and wide matrices. For backwards compatibility, the option
  *                  #DisableQRDecomposition can be used to disable this optimization.
  *
  * This class first reduces the input matrix to bi-diagonal form using class UpperBidiagonalization,
  * and then performs a divide-and-conquer diagonalization. Small blocks are diagonalized using class JacobiSVD.
  * You can control the switching size with the setSwitchSize() method, default is 16.
- * For small matrice (<16), it is thus preferable to directly use JacobiSVD. For larger ones, BDCSVD is highly
- * recommended and can several order of magnitude faster.
+ * For small matrices (<16), it is thus preferable to directly use JacobiSVD. For larger ones, BDCSVD is highly
+ * recommended and can be several orders of magnitude faster.
  *
  * \warning this algorithm is unlikely to provide accurate result when compiled with unsafe math optimizations.
  * For instance, this concerns Intel's compiler (ICC), which performs such optimization by default unless
@@ -82,7 +72,7 @@
  */
 template <typename MatrixType_, int Options_>
 class BDCSVD : public SVDBase<BDCSVD<MatrixType_, Options_> > {
-  typedef SVDBase<BDCSVD> Base;
+  using Base = SVDBase<BDCSVD>;
 
  public:
   using Base::cols;
@@ -91,15 +81,15 @@
   using Base::diagSize;
   using Base::rows;
 
-  typedef MatrixType_ MatrixType;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::RealScalar RealScalar;
-  typedef typename NumTraits<RealScalar>::Literal Literal;
-  typedef typename Base::Index Index;
+  using MatrixType = MatrixType_;
+  using Scalar = typename Base::Scalar;
+  using RealScalar = typename Base::RealScalar;
+  using Literal = typename NumTraits<RealScalar>::Literal;
+  using Index = typename Base::Index;
   enum {
     Options = Options_,
-    QRDecomposition = Options & internal::QRPreconditionerBits,
-    ComputationOptions = Options & internal::ComputationOptionsBits,
+    QRDecomposition = internal::get_qr_preconditioner(Options),
+    ComputationOptions = internal::get_computation_options(Options),
     RowsAtCompileTime = Base::RowsAtCompileTime,
     ColsAtCompileTime = Base::ColsAtCompileTime,
     DiagSizeAtCompileTime = Base::DiagSizeAtCompileTime,
@@ -109,17 +99,17 @@
     MatrixOptions = Base::MatrixOptions
   };
 
-  typedef typename Base::MatrixUType MatrixUType;
-  typedef typename Base::MatrixVType MatrixVType;
-  typedef typename Base::SingularValuesType SingularValuesType;
+  using MatrixUType = typename Base::MatrixUType;
+  using MatrixVType = typename Base::MatrixVType;
+  using SingularValuesType = typename Base::SingularValuesType;
 
-  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> MatrixX;
-  typedef Matrix<RealScalar, Dynamic, Dynamic, ColMajor> MatrixXr;
-  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
-  typedef Array<RealScalar, Dynamic, 1> ArrayXr;
-  typedef Array<Index, 1, Dynamic> ArrayXi;
-  typedef Ref<ArrayXr> ArrayRef;
-  typedef Ref<ArrayXi> IndicesRef;
+  using MatrixX = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using MatrixXr = Matrix<RealScalar, Dynamic, Dynamic, ColMajor>;
+  using VectorType = Matrix<RealScalar, Dynamic, 1>;
+  using ArrayXr = Array<RealScalar, Dynamic, 1>;
+  using ArrayXi = Array<Index, 1, Dynamic>;
+  using ArrayRef = Ref<ArrayXr>;
+  using IndicesRef = Ref<ArrayXi>;
 
   /** \brief Default Constructor.
    *
@@ -168,6 +158,20 @@
     compute_impl(matrix, internal::get_computation_options(Options));
   }
 
+  /** \brief Constructor performing the SVD of an upper bidiagonal matrix given its diagonal and superdiagonal.
+   *
+   * This skips the bidiagonalization step and directly runs the divide-and-conquer algorithm.
+   * The input vectors must be real-valued. For an n x n bidiagonal matrix, \a diagonal has n entries
+   * and \a superdiagonal has n-1 entries.
+   *
+   * \param diagonal the diagonal entries of the bidiagonal matrix
+   * \param superdiagonal the superdiagonal entries of the bidiagonal matrix
+   */
+  template <typename DerivedD, typename DerivedE>
+  BDCSVD(const MatrixBase<DerivedD>& diagonal, const MatrixBase<DerivedE>& superdiagonal) : m_numIters(0) {
+    compute_bidiagonal_impl(diagonal, superdiagonal, internal::get_computation_options(Options));
+  }
+
   /** \brief Constructor performing the decomposition of given matrix using specified options
    *         for computing unitaries.
    *
@@ -187,8 +191,6 @@
     compute_impl(matrix, computationOptions);
   }
 
-  ~BDCSVD() {}
-
   /** \brief Method performing the decomposition of given matrix. Computes Thin/Full unitaries U/V if specified
    *         using the \a Options template parameter or the class constructor.
    *
@@ -215,6 +217,20 @@
     return compute_impl(matrix, computationOptions);
   }
 
+  /** \brief Compute the SVD of an upper bidiagonal matrix given its diagonal and superdiagonal.
+   *
+   * This skips the bidiagonalization step and directly runs the divide-and-conquer algorithm.
+   * The input vectors must be real-valued. For an n x n bidiagonal matrix, \a diagonal has n entries
+   * and \a superdiagonal has n-1 entries.
+   *
+   * \param diagonal the diagonal entries of the bidiagonal matrix
+   * \param superdiagonal the superdiagonal entries of the bidiagonal matrix
+   */
+  template <typename DerivedD, typename DerivedE>
+  BDCSVD& compute(const MatrixBase<DerivedD>& diagonal, const MatrixBase<DerivedE>& superdiagonal) {
+    return compute_bidiagonal_impl(diagonal, superdiagonal, m_computationOptions);
+  }
+
   void setSwitchSize(int s) {
     eigen_assert(s >= 3 && "BDCSVD the size of the algo switch has to be at least 3.");
     m_impl.setAlgoSwap(s);
@@ -223,12 +239,20 @@
  private:
   template <typename Derived>
   BDCSVD& compute_impl(const MatrixBase<Derived>& matrix, unsigned int computationOptions);
+  template <typename Derived>
+  BDCSVD& compute_impl(const MatrixBase<Derived>& matrix, unsigned int computationOptions, internal::true_type);
+  template <typename Derived>
+  BDCSVD& compute_impl(const MatrixBase<Derived>& matrix, unsigned int computationOptions, internal::false_type);
+  template <typename DerivedD, typename DerivedE>
+  BDCSVD& compute_bidiagonal_impl(const MatrixBase<DerivedD>& diagonal, const MatrixBase<DerivedE>& superdiagonal,
+                                  unsigned int computationOptions);
   template <typename HouseholderU, typename HouseholderV, typename NaiveU, typename NaiveV>
   void copyUV(const HouseholderU& householderU, const HouseholderV& householderV, const NaiveU& naiveU,
               const NaiveV& naivev);
 
  protected:
   void allocate(Index rows, Index cols, unsigned int computationOptions);
+  void allocate_small(Index rows, Index cols, unsigned int computationOptions);
   internal::bdcsvd_impl<RealScalar> m_impl;
   bool m_isTranspose, m_useQrDecomp;
   JacobiSVD<MatrixX> smallSvd;
@@ -236,6 +260,9 @@
   internal::UpperBidiagonalization<MatrixX> bid;
   MatrixX copyWorkspace;
   MatrixX reducedTriangle;
+  // Reused workspace for HouseholderSequence::applyThisOnTheLeft in copyUV().
+  // Without this, each apply allocates a fresh row vector.
+  Matrix<Scalar, 1, Dynamic, RowMajor> m_householderWorkspace;
 
   using Base::m_computationOptions;
   using Base::m_computeThinU;
@@ -273,7 +300,7 @@
   // we use a larger scalar to prevent a regression for relatively square matrices.
   constexpr Index kMinAspectRatio = 4;
   constexpr bool disableQrDecomp = static_cast<int>(QRDecomposition) == static_cast<int>(DisableQRDecomposition);
-  m_useQrDecomp = !disableQrDecomp && ((rows / kMinAspectRatio > cols) || (cols / kMinAspectRatio > rows));
+  m_useQrDecomp = !disableQrDecomp && ((rows / kMinAspectRatio >= cols) || (cols / kMinAspectRatio >= rows));
   if (m_useQrDecomp) {
     qrDecomp = HouseholderQR<MatrixX>((std::max)(rows, cols), (std::min)(rows, cols));
     reducedTriangle = MatrixX(diagSize(), diagSize());
@@ -285,17 +312,48 @@
 }  // end allocate
 
 template <typename MatrixType, int Options>
+void BDCSVD<MatrixType, Options>::allocate_small(Index rows, Index cols, unsigned int computationOptions) {
+  if (Base::allocate(rows, cols, computationOptions)) return;
+
+  smallSvd.allocate(rows, cols, Options == 0 ? computationOptions : internal::get_computation_options(Options));
+  m_isTranspose = (cols > rows);
+}
+
+template <typename MatrixType, int Options>
 template <typename Derived>
-EIGEN_DONT_INLINE BDCSVD<MatrixType, Options>& BDCSVD<MatrixType, Options>::compute_impl(
-    const MatrixBase<Derived>& matrix, unsigned int computationOptions) {
+BDCSVD<MatrixType, Options>& BDCSVD<MatrixType, Options>::compute_impl(const MatrixBase<Derived>& matrix,
+                                                                       unsigned int computationOptions) {
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived, MatrixType);
   EIGEN_STATIC_ASSERT((std::is_same<typename Derived::Scalar, typename MatrixType::Scalar>::value),
                       Input matrix must have the same Scalar type as the BDCSVD object.);
 
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "\n\n\n================================================================================================="
-               "=====================\n\n\n";
-#endif
+  // setSwitchSize() enforces a minimum of 3, so these types can only use the JacobiSVD fallback.
+  typedef internal::bool_constant<(MaxColsAtCompileTime != Dynamic && MaxColsAtCompileTime < 3)> AlwaysUseSmallSvd;
+  return compute_impl(matrix, computationOptions, AlwaysUseSmallSvd());
+}
+
+template <typename MatrixType, int Options>
+template <typename Derived>
+EIGEN_DONT_INLINE BDCSVD<MatrixType, Options>& BDCSVD<MatrixType, Options>::compute_impl(
+    const MatrixBase<Derived>& matrix, unsigned int computationOptions, internal::true_type) {
+  allocate_small(matrix.rows(), matrix.cols(), computationOptions);
+
+  smallSvd.compute(matrix);
+  m_isInitialized = true;
+  m_info = smallSvd.info();
+  if (m_info == Success || m_info == NoConvergence) {
+    if (computeU()) m_matrixU = smallSvd.matrixU();
+    if (computeV()) m_matrixV = smallSvd.matrixV();
+    m_singularValues = smallSvd.singularValues();
+    m_nonzeroSingularValues = smallSvd.nonzeroSingularValues();
+  }
+  return *this;
+}
+
+template <typename MatrixType, int Options>
+template <typename Derived>
+EIGEN_DONT_INLINE BDCSVD<MatrixType, Options>& BDCSVD<MatrixType, Options>::compute_impl(
+    const MatrixBase<Derived>& matrix, unsigned int computationOptions, internal::false_type) {
   using std::abs;
 
   allocate(matrix.rows(), matrix.cols(), computationOptions);
@@ -317,19 +375,16 @@
   }
 
   //**** step 0 - Copy the input matrix and apply scaling to reduce over/under-flows
-  RealScalar scale = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
-  if (!(numext::isfinite)(scale)) {
+  const RealScalar maxCoeff = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(maxCoeff)) {
     m_isInitialized = true;
     m_info = InvalidInput;
     return *this;
   }
 
-  if (numext::is_exactly_zero(scale)) scale = Literal(1);
-
-  if (m_isTranspose)
-    copyWorkspace = matrix.adjoint() / scale;
-  else
-    copyWorkspace = matrix / scale;
+  const auto factors = m_isTranspose
+                           ? internal::safe_scaling<RealScalar>::scale_to(copyWorkspace, matrix.adjoint(), maxCoeff)
+                           : internal::safe_scaling<RealScalar>::scale_to(copyWorkspace, matrix, maxCoeff);
 
   //**** step 1 - Bidiagonalization.
   // If the problem is sufficiently rectangular, we perform R-Bidiagonalization: compute A = Q(R/0)
@@ -347,9 +402,15 @@
   //**** step 2 - Divide & Conquer
   m_impl.naiveU().setZero();
   m_impl.naiveV().setZero();
-  // FIXME: this line involves a temporary matrix.
-  m_impl.computed().topRows(diagSize()) = bid.bidiagonal().toDenseMatrix().transpose();
-  m_impl.computed().template bottomRows<1>().setZero();
+  // The transposed bidiagonal has only the main diagonal and one sub-diagonal;
+  // fill those directly instead of materializing a dense temporary.
+  // Note: BandMatrix::diagonal<N>() const has a latent type bug (returns
+  // Block<CoefficientsType, ...> instead of Block<const CoefficientsType, ...>),
+  // so use the index-based overload which is correctly const-qualified.
+  m_impl.computed().setZero();
+  m_impl.computed().topRows(diagSize()).diagonal() = bid.bidiagonal().diagonal();
+  m_impl.computed().topRows(diagSize()).template diagonal<-1>() = bid.bidiagonal().diagonal(1);
+  m_impl.splitNegligibleSuperdiagonal(diagSize());
   m_impl.divide(0, diagSize() - 1, 0, 0, 0);
   m_info = m_impl.info();
   m_numIters = m_impl.numIters();
@@ -361,7 +422,7 @@
   //**** step 3 - Copy singular values and vectors
   for (int i = 0; i < diagSize(); i++) {
     RealScalar a = abs(m_impl.computed().coeff(i, i));
-    m_singularValues.coeffRef(i) = a * scale;
+    internal::safe_scaling<RealScalar>::unscale_to(m_singularValues.coeffRef(i), a, factors);
     if (a < considerZero) {
       m_nonzeroSingularValues = i;
       m_singularValues.tail(diagSize() - i - 1).setZero();
@@ -394,31 +455,156 @@
 EIGEN_DONT_INLINE void BDCSVD<MatrixType, Options>::copyUV(const HouseholderU& householderU,
                                                            const HouseholderV& householderV, const NaiveU& naiveU,
                                                            const NaiveV& naiveV) {
-  // Note exchange of U and V: m_matrixU is set from m_naiveV and vice versa
+  // Note exchange of U and V: m_matrixU is set from m_naiveV and vice versa.
+  // Cast the diagSize x diagSize block (rather than the full naive matrix) to avoid materializing
+  // a full-size temporary when Scalar != RealScalar; reuse m_householderWorkspace across the two
+  // applyThisOnTheLeft calls so each does not allocate a fresh row vector.
   if (computeU()) {
     Index Ucols = m_computeThinU ? diagSize() : rows();
     m_matrixU = MatrixX::Identity(rows(), Ucols);
     m_matrixU.topLeftCorner(diagSize(), diagSize()) =
-        naiveV.template cast<Scalar>().topLeftCorner(diagSize(), diagSize());
-    // FIXME: the following conditionals involve temporary buffers.
-    if (m_useQrDecomp)
-      m_matrixU.topLeftCorner(householderU.cols(), diagSize()).applyOnTheLeft(householderU);
-    else
-      m_matrixU.applyOnTheLeft(householderU);
+        naiveV.topLeftCorner(diagSize(), diagSize()).template cast<Scalar>();
+    if (m_useQrDecomp) {
+      auto sub = m_matrixU.topLeftCorner(householderU.cols(), diagSize());
+      householderU.applyThisOnTheLeft(sub, m_householderWorkspace);
+    } else {
+      householderU.applyThisOnTheLeft(m_matrixU, m_householderWorkspace);
+    }
   }
   if (computeV()) {
     Index Vcols = m_computeThinV ? diagSize() : cols();
     m_matrixV = MatrixX::Identity(cols(), Vcols);
     m_matrixV.topLeftCorner(diagSize(), diagSize()) =
-        naiveU.template cast<Scalar>().topLeftCorner(diagSize(), diagSize());
-    // FIXME: the following conditionals involve temporary buffers.
-    if (m_useQrDecomp)
-      m_matrixV.topLeftCorner(householderV.cols(), diagSize()).applyOnTheLeft(householderV);
-    else
-      m_matrixV.applyOnTheLeft(householderV);
+        naiveU.topLeftCorner(diagSize(), diagSize()).template cast<Scalar>();
+    if (m_useQrDecomp) {
+      auto sub = m_matrixV.topLeftCorner(householderV.cols(), diagSize());
+      householderV.applyThisOnTheLeft(sub, m_householderWorkspace);
+    } else {
+      householderV.applyThisOnTheLeft(m_matrixV, m_householderWorkspace);
+    }
   }
 }
 
+template <typename MatrixType, int Options>
+template <typename DerivedD, typename DerivedE>
+EIGEN_DONT_INLINE BDCSVD<MatrixType, Options>& BDCSVD<MatrixType, Options>::compute_bidiagonal_impl(
+    const MatrixBase<DerivedD>& diagonal, const MatrixBase<DerivedE>& superdiagonal, unsigned int computationOptions) {
+  EIGEN_STATIC_ASSERT(DerivedD::IsVectorAtCompileTime, THIS_METHOD_IS_ONLY_FOR_VECTORS);
+  EIGEN_STATIC_ASSERT(DerivedE::IsVectorAtCompileTime, THIS_METHOD_IS_ONLY_FOR_VECTORS);
+  EIGEN_STATIC_ASSERT((NumTraits<typename DerivedD::Scalar>::IsComplex == 0),
+                      THIS_FUNCTION_IS_NOT_FOR_COMPLEX_VALUED_MATRICES);
+  EIGEN_STATIC_ASSERT((NumTraits<typename DerivedE::Scalar>::IsComplex == 0),
+                      THIS_FUNCTION_IS_NOT_FOR_COMPLEX_VALUED_MATRICES);
+
+  using std::abs;
+  const Index n = diagonal.size();
+  eigen_assert((n == 0 || superdiagonal.size() == n - 1) && "superdiagonal must have size diagonal.size() - 1");
+
+  // For a bidiagonal matrix, rows == cols == n.
+  allocate(n, n, computationOptions);
+
+  if (n == 0) {
+    m_isInitialized = true;
+    m_info = Success;
+    m_nonzeroSingularValues = 0;
+    return *this;
+  }
+
+  // Check for non-finite inputs.
+  const RealScalar diagScale = diagonal.cwiseAbs().template maxCoeff<PropagateNaN>();
+  const RealScalar superdiagScale = n > 1 ? superdiagonal.cwiseAbs().template maxCoeff<PropagateNaN>() : RealScalar(0);
+  const RealScalar maxCoeff = numext::maxi(diagScale, superdiagScale);
+  if (!(numext::isfinite)(maxCoeff)) {
+    m_isInitialized = true;
+    m_info = InvalidInput;
+    return *this;
+  }
+
+  const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
+  //**** Small problem: build dense bidiagonal and delegate to JacobiSVD.
+  if (n < m_impl.algoSwap()) {
+    // Build the dense upper bidiagonal matrix.
+    MatrixX B = MatrixX::Zero(n, n);
+    auto diagonalDest = B.diagonal();
+    const auto factors =
+        internal::safe_scaling<RealScalar>::scale_to(diagonalDest, diagonal.template cast<Scalar>(), maxCoeff);
+    if (n > 1) {
+      auto superdiagonalDest = B.diagonal(1);
+      internal::safe_scaling<RealScalar>::scale_to(superdiagonalDest, superdiagonal.template cast<Scalar>(), maxCoeff,
+                                                   factors);
+    }
+    smallSvd.compute(B);
+    m_isInitialized = true;
+    m_info = smallSvd.info();
+    if (m_info == Success || m_info == NoConvergence) {
+      internal::safe_scaling<RealScalar>::unscale_to(m_singularValues, smallSvd.singularValues(), factors);
+      m_nonzeroSingularValues = smallSvd.nonzeroSingularValues();
+      if (computeU()) m_matrixU = smallSvd.matrixU();
+      if (computeV()) m_matrixV = smallSvd.matrixV();
+    }
+    return *this;
+  }
+
+  //**** Fill m_computed with transposed bidiagonal format.
+  // D&C operates on B^T: m_computed(i,i) = d_i, m_computed(i+1,i) = e_i.
+  m_impl.naiveU().setZero();
+  m_impl.naiveV().setZero();
+  m_impl.computed().setZero();
+  auto diagonalDest = m_impl.computed().diagonal();
+  const auto factors =
+      internal::safe_scaling<RealScalar>::scale_to(diagonalDest, diagonal.template cast<RealScalar>(), maxCoeff);
+  if (n > 1) {
+    auto superdiagonalDest = m_impl.computed().template diagonal<-1>().head(n - 1);
+    internal::safe_scaling<RealScalar>::scale_to(superdiagonalDest, superdiagonal.template cast<RealScalar>(), maxCoeff,
+                                                 factors);
+  }
+
+  m_isTranspose = false;
+
+  //**** Run D&C.
+  m_impl.splitNegligibleSuperdiagonal(n);
+  m_impl.divide(0, n - 1, 0, 0, 0);
+  m_info = m_impl.info();
+  m_numIters = m_impl.numIters();
+  if (m_info != Success && m_info != NoConvergence) {
+    m_isInitialized = true;
+    return *this;
+  }
+
+  //**** Extract singular values.
+  for (int i = 0; i < diagSize(); i++) {
+    RealScalar a = abs(m_impl.computed().coeff(i, i));
+    internal::safe_scaling<RealScalar>::unscale_to(m_singularValues.coeffRef(i), a, factors);
+    if (a < considerZero) {
+      m_nonzeroSingularValues = i;
+      m_singularValues.tail(diagSize() - i - 1).setZero();
+      break;
+    } else if (i == diagSize() - 1) {
+      m_nonzeroSingularValues = i + 1;
+      break;
+    }
+  }
+
+  //**** Copy U and V directly (no Householder to apply).
+  // D&C computes B^T = naiveU * S * naiveV^T, so B = naiveV * S * naiveU^T.
+  // Thus U_of_B = naiveV, V_of_B = naiveU.
+  if (computeU()) {
+    Index Ucols = m_computeThinU ? diagSize() : rows();
+    m_matrixU = MatrixX::Identity(rows(), Ucols);
+    m_matrixU.topLeftCorner(diagSize(), diagSize()) =
+        m_impl.naiveV().template cast<Scalar>().topLeftCorner(diagSize(), diagSize());
+  }
+  if (computeV()) {
+    Index Vcols = m_computeThinV ? diagSize() : cols();
+    m_matrixV = MatrixX::Identity(cols(), Vcols);
+    m_matrixV.topLeftCorner(diagSize(), diagSize()) =
+        m_impl.naiveU().template cast<Scalar>().topLeftCorner(diagSize(), diagSize());
+  }
+
+  m_isInitialized = true;
+  return *this;
+}
+
 /** \svd_module
  *
  * \return the singular value decomposition of \c *this computed by Divide & Conquer algorithm
diff --git a/Eigen/src/SVD/BDCSVDImpl.h b/Eigen/src/SVD/BDCSVDImpl.h
index 4d0e70f..995b4ca 100644
--- a/Eigen/src/SVD/BDCSVDImpl.h
+++ b/Eigen/src/SVD/BDCSVDImpl.h
@@ -16,6 +16,7 @@
 // Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BDCSVD_IMPL_H
 #define EIGEN_BDCSVD_IMPL_H
@@ -25,18 +26,8 @@
 
 namespace Eigen {
 
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-IOFormat bdcsvdfmt(8, 0, ", ", "\n", "  [", "]");
-#endif
-
 namespace internal {
 
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-#define BDCSVD_SANITY_CHECK(expr) eigen_internal_assert(expr)
-#else
-#define BDCSVD_SANITY_CHECK(expr)
-#endif
-
 /** \internal
  * Implementation of the divide-and-conquer phase of BDCSVD.
  *
@@ -48,14 +39,15 @@
 template <typename RealScalar_>
 class bdcsvd_impl {
  public:
-  typedef RealScalar_ RealScalar;
-  typedef typename NumTraits<RealScalar>::Literal Literal;
-  typedef Matrix<RealScalar, Dynamic, Dynamic, ColMajor> MatrixXr;
-  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
-  typedef Array<RealScalar, Dynamic, 1> ArrayXr;
-  typedef Array<Index, 1, Dynamic> ArrayXi;
-  typedef Ref<ArrayXr> ArrayRef;
-  typedef Ref<ArrayXi> IndicesRef;
+  using RealScalar = RealScalar_;
+  using Literal = typename NumTraits<RealScalar>::Literal;
+  using MatrixXr = Matrix<RealScalar, Dynamic, Dynamic, ColMajor>;
+  using VectorType = Matrix<RealScalar, Dynamic, 1>;
+  using ArrayXr = Array<RealScalar, Dynamic, 1>;
+  using ArrayXi = Array<Index, 1, Dynamic>;
+  using ArrayRef = Ref<ArrayXr>;
+  using ConstArrayRef = Ref<const ArrayXr>;
+  using IndicesRef = Ref<ArrayXi>;
 
   bdcsvd_impl() : m_algoswap(16), m_compU(false), m_compV(false), m_numIters(0), m_info(Success) {}
 
@@ -64,6 +56,9 @@
   /** Entry point for the divide-and-conquer phase. */
   void divide(Index firstCol, Index lastCol, Index firstRowW, Index firstColW, Index shift);
 
+  /** Zeroes sub-diagonal entries of the stored bidiagonal that are negligible for the matrix as a whole. */
+  void splitNegligibleSuperdiagonal(Index n);
+
   MatrixXr& naiveU() { return m_naiveU; }
   const MatrixXr& naiveU() const { return m_naiveU; }
   MatrixXr& naiveV() { return m_naiveV; }
@@ -78,7 +73,7 @@
  private:
   void computeSVDofM(Index firstCol, Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V);
   void computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, VectorType& singVals,
-                       ArrayRef shifts, ArrayRef mus);
+                       ArrayRef shifts, ArrayRef mus, ArrayRef workspace);
   void perturbCol0(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals,
                    const ArrayRef& shifts, const ArrayRef& mus, ArrayRef zhat);
   void computeSingVecs(const ArrayRef& zhat, const ArrayRef& diag, const IndicesRef& perm, const VectorType& singVals,
@@ -87,8 +82,12 @@
   void deflation44(Index firstColu, Index firstColm, Index firstRowW, Index firstColW, Index i, Index j, Index size);
   void deflation(Index firstCol, Index lastCol, Index k, Index firstRowW, Index firstColW, Index shift);
   void structured_update(Block<MatrixXr, Dynamic, Dynamic> A, const MatrixXr& B, Index n1);
-  static RealScalar secularEq(RealScalar x, const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm,
-                              const ArrayRef& diagShifted, RealScalar shift);
+  static EIGEN_STRONG_INLINE RealScalar productOfQuotients(RealScalar firstNumerator, RealScalar firstDenominator,
+                                                           RealScalar secondNumerator, RealScalar secondDenominator);
+  static EIGEN_STRONG_INLINE RealScalar sequentialQuotient(RealScalar numerator, RealScalar firstDenominator,
+                                                           RealScalar secondDenominator);
+  static RealScalar secularEq(RealScalar x, const ConstArrayRef& col0, const ConstArrayRef& diag,
+                              const ConstArrayRef& diagShifted, RealScalar shift);
   template <typename SVDType>
   void computeBaseCase(SVDType& svd, Index n, Index firstCol, Index firstRowW, Index firstColW, Index shift);
 
@@ -96,6 +95,10 @@
   MatrixXr m_computed;
   ArrayXr m_workspace;
   ArrayXi m_workspaceI;
+  // Reused base-case JacobiSVDs (one per option set) so that recursive divide()
+  // calls don't reallocate JacobiSVD's internal U/V/sigma buffers each time.
+  JacobiSVD<MatrixXr, ComputeFullU> m_baseSvdU;
+  JacobiSVD<MatrixXr, ComputeFullU | ComputeFullV> m_baseSvdUV;
   int m_algoswap;
   bool m_compU, m_compV;
   int m_numIters;
@@ -118,10 +121,34 @@
 
   if (m_compV) m_naiveV = MatrixXr::Zero(diagSize, diagSize);
 
-  m_workspace.resize((diagSize + 1) * (diagSize + 1) * 3);
+  // Vector updates need the three matrix-sized packing buffers used by
+  // structured_update(). Values-only decompositions only need five vectors:
+  // diag, shifts, mus, zhat, and diagShifted.
+  if (m_compU || m_compV)
+    m_workspace.resize((diagSize + 1) * (diagSize + 1) * 3);
+  else
+    m_workspace.resize(5 * diagSize);
   m_workspaceI.resize(3 * diagSize);
 }
 
+// LAPACK's xBDSDC normalizes the bidiagonal by its largest entry and splits wherever a superdiagonal entry falls
+// below eps, so a run of rounding noise never becomes a sub-problem. Eigen scales the input matrix but has no such
+// split: every threshold in deflation() is formed from the sub-problem's own maximum, so a block whose entries are
+// uniformly tiny looks well scaled from the inside and gets resolved for its own relative accuracy. Zeroing here
+// costs one pass and leaves the perturbation within the eps * ||B|| the SVD already carries.
+template <typename RealScalar_>
+void bdcsvd_impl<RealScalar_>::splitNegligibleSuperdiagonal(Index n) {
+  if (n < 2) return;
+  // xBDSDC scales d and e by DLANST('M', n, d, e), the largest entry of either, and then splits at
+  // 0.9 * DLAMCH('E'). DLAMCH('E') is the unit roundoff, i.e. half of NumTraits::epsilon(), so the
+  // same threshold unscaled is 0.45 * epsilon * ||B||_max.
+  const RealScalar norm = numext::maxi(m_computed.topRows(n).diagonal().cwiseAbs().maxCoeff(),
+                                       m_computed.topRows(n).template diagonal<-1>().cwiseAbs().maxCoeff());
+  const RealScalar threshold = RealScalar(0.45) * NumTraits<RealScalar>::epsilon() * norm;
+  for (Index i = 0; i + 1 < n; ++i)
+    if (numext::abs(m_computed(i + 1, i)) < threshold) m_computed(i + 1, i) = RealScalar(0);
+}
+
 /** \internal
  * Performs A = A * B exploiting the special structure of the matrix A. Splitting A as:
  *  A = [A1]
@@ -198,8 +225,6 @@
 template <typename RealScalar_>
 void bdcsvd_impl<RealScalar_>::divide(Index firstCol, Index lastCol, Index firstRowW, Index firstColW, Index shift) {
   // requires rows = cols + 1;
-  using std::abs;
-  using std::sqrt;
   const Index n = lastCol - firstCol + 1;
   const Index k = n / 2;
   const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
@@ -207,17 +232,13 @@
   RealScalar betaK;
   RealScalar r0;
   RealScalar lambda, phi, c0, s0;
-  VectorType l, f;
   // We use the other algorithm which is more efficient for small
   // matrices.
   if (n < m_algoswap) {
-    // FIXME: this block involves temporaries.
     if (m_compV) {
-      JacobiSVD<MatrixXr, ComputeFullU | ComputeFullV> baseSvd;
-      computeBaseCase(baseSvd, n, firstCol, firstRowW, firstColW, shift);
+      computeBaseCase(m_baseSvdUV, n, firstCol, firstRowW, firstColW, shift);
     } else {
-      JacobiSVD<MatrixXr, ComputeFullU> baseSvd;
-      computeBaseCase(baseSvd, n, firstCol, firstRowW, firstColW, shift);
+      computeBaseCase(m_baseSvdU, n, firstCol, firstRowW, firstColW, shift);
     }
     return;
   }
@@ -239,14 +260,10 @@
     lambda = m_naiveU(1, firstCol + k);
     phi = m_naiveU(0, lastCol + 1);
   }
-  r0 = sqrt((abs(alphaK * lambda) * abs(alphaK * lambda)) + abs(betaK * phi) * abs(betaK * phi));
-  if (m_compU) {
-    l = m_naiveU.row(firstCol + k).segment(firstCol, k);
-    f = m_naiveU.row(firstCol + k + 1).segment(firstCol + k + 1, n - k - 1);
-  } else {
-    l = m_naiveU.row(1).segment(firstCol, k);
-    f = m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1);
-  }
+  // LAPACK's xLASD2 likewise uses xLAPY2 for this merge coupling. The
+  // scaled hypotenuse avoids destructive underflow when both products are
+  // below sqrt(min()).
+  r0 = numext::hypot(alphaK * lambda, betaK * phi);
   if (m_compV) m_naiveV(firstRowW + k, firstColW) = Literal(1);
   if (r0 < considerZero) {
     c0 = Literal(1);
@@ -256,13 +273,23 @@
     s0 = betaK * phi / r0;
   }
 
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
+  m_computed(firstCol + shift, firstCol + shift) = r0;
+  if (m_compU) {
+    m_computed.col(firstCol + shift).segment(firstCol + shift + 1, k) =
+        alphaK * m_naiveU.row(firstCol + k).segment(firstCol, k).transpose();
+    m_computed.col(firstCol + shift).segment(firstCol + shift + k + 1, n - k - 1) =
+        betaK * m_naiveU.row(firstCol + k + 1).segment(firstCol + k + 1, n - k - 1).transpose();
+  } else {
+    m_computed.col(firstCol + shift).segment(firstCol + shift + 1, k) =
+        alphaK * m_naiveU.row(1).segment(firstCol, k).transpose();
+    m_computed.col(firstCol + shift).segment(firstCol + shift + k + 1, n - k - 1) =
+        betaK * m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1).transpose();
+  }
 
   if (m_compU) {
-    MatrixXr q1(m_naiveU.col(firstCol + k).segment(firstCol, k + 1));
-    // we shiftW Q1 to the right
+    Map<VectorType, Aligned> q1(m_workspace.data(), k + 1);
+    q1 = m_naiveU.col(firstCol + k).segment(firstCol, k + 1);
+    // we shift Q1 to the right
     for (Index i = firstCol + k - 1; i >= firstCol; i--)
       m_naiveU.col(i + 1).segment(firstCol, k + 1) = m_naiveU.col(i).segment(firstCol, k + 1);
     // we shift q1 at the left with a factor c0
@@ -290,39 +317,14 @@
     m_naiveU.row(0).segment(firstCol + k + 1, n - k - 1).setZero();
   }
 
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
-
-  m_computed(firstCol + shift, firstCol + shift) = r0;
-  m_computed.col(firstCol + shift).segment(firstCol + shift + 1, k) = alphaK * l.transpose();
-  m_computed.col(firstCol + shift).segment(firstCol + shift + k + 1, n - k - 1) = betaK * f.transpose();
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  ArrayXr tmp1 = (m_computed.block(firstCol + shift, firstCol + shift, n, n)).jacobiSvd().singularValues();
-#endif
   // Second part: try to deflate singular values in combined matrix
   deflation(firstCol, lastCol, k, firstRowW, firstColW, shift);
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  ArrayXr tmp2 = (m_computed.block(firstCol + shift, firstCol + shift, n, n)).jacobiSvd().singularValues();
-  std::cout << "\n\nj1 = " << tmp1.transpose().format(bdcsvdfmt) << "\n";
-  std::cout << "j2 = " << tmp2.transpose().format(bdcsvdfmt) << "\n\n";
-  std::cout << "err:      " << ((tmp1 - tmp2).abs() > 1e-12 * tmp2.abs()).transpose() << "\n";
-  static int count = 0;
-  std::cout << "# " << ++count << "\n\n";
-  eigen_internal_assert((tmp1 - tmp2).matrix().norm() < 1e-14 * tmp2.matrix().norm());
-//   eigen_internal_assert(count<681);
-//   eigen_internal_assert(((tmp1-tmp2).abs()<1e-13*tmp2.abs()).all());
-#endif
 
   // Third part: compute SVD of combined matrix
   MatrixXr UofSVD, VofSVD;
   VectorType singVals;
   computeSVDofM(firstCol + shift, n, UofSVD, singVals, VofSVD);
 
-  BDCSVD_SANITY_CHECK(UofSVD.allFinite());
-  BDCSVD_SANITY_CHECK(VofSVD.allFinite());
-
   if (m_compU)
     structured_update(m_naiveU.block(firstCol, firstCol, n + 1, n + 1), UofSVD, (n + 2) / 2);
   else {
@@ -333,23 +335,16 @@
 
   if (m_compV) structured_update(m_naiveV.block(firstRowW, firstColW, n, n), VofSVD, (n + 1) / 2);
 
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
-
-  m_computed.block(firstCol + shift, firstCol + shift, n, n).setZero();
-  m_computed.block(firstCol + shift, firstCol + shift, n, n).diagonal() = singVals;
+  // Recursive children leave this block diagonal; this merge only adds its
+  // first column. Clear that column instead of rewriting the full n-by-n block.
+  m_computed.col(firstCol + shift).segment(firstCol + shift, n).setZero();
+  m_computed.diagonal().segment(firstCol + shift, n) = singVals;
 }  // end divide
 
 // Compute SVD of m_computed.block(firstCol, firstCol, n + 1, n); this block only has non-zeros in
 // the first column and on the diagonal and has undergone deflation, so diagonal is in increasing
 // order except for possibly the (0,0) entry. The computed SVD is stored U, singVals and V, except
 // that if m_compV is false, then V is not computed. Singular values are sorted in decreasing order.
-//
-// TODO: opportunities for optimization: better root-finding algorithm, better stopping criterion,
-// better handling of round-off errors, and consistent ordering.
-// For instance, to solve the secular equation using FMM, see
-// http://www.stat.uchicago.edu/~lekheng/courses/302/classics/greengard-rokhlin.pdf
 template <typename RealScalar_>
 void bdcsvd_impl<RealScalar_>::computeSVDofM(Index firstCol, Index n, MatrixXr& U, VectorType& singVals, MatrixXr& V) {
   const RealScalar considerZero = (std::numeric_limits<RealScalar>::min)();
@@ -364,10 +359,6 @@
   U.resize(n + 1, n + 1);
   if (m_compV) V.resize(n, n);
 
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  if (col0.hasNaN() || diag.hasNaN()) std::cout << "\n\nHAS NAN\n\n";
-#endif
-
   // Many singular values might have been deflated, the zero ones have been moved to the end,
   // but others are interleaved and we must ignore them at this stage.
   // To this end, let's compute a permutation skipping them:
@@ -385,63 +376,16 @@
   Map<ArrayXr> mus(m_workspace.data() + 2 * n, n);
   Map<ArrayXr> zhat(m_workspace.data() + 3 * n, n);
 
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "computeSVDofM using:\n";
-  std::cout << "  z: " << col0.transpose() << "\n";
-  std::cout << "  d: " << diag.transpose() << "\n";
-#endif
-
   // Compute singVals, shifts, and mus
-  computeSingVals(col0, diag, perm, singVals, shifts, mus);
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "  j:        "
-            << (m_computed.block(firstCol, firstCol, n, n)).jacobiSvd().singularValues().transpose().reverse()
-            << "\n\n";
-  std::cout << "  sing-val: " << singVals.transpose() << "\n";
-  std::cout << "  mu:       " << mus.transpose() << "\n";
-  std::cout << "  shift:    " << shifts.transpose() << "\n";
-
-  {
-    std::cout << "\n\n    mus:    " << mus.head(actual_n).transpose() << "\n\n";
-    std::cout << "    check1 (expect0) : "
-              << ((singVals.array() - (shifts + mus)) / singVals.array()).head(actual_n).transpose() << "\n\n";
-    eigen_internal_assert((((singVals.array() - (shifts + mus)) / singVals.array()).head(actual_n) >= 0).all());
-    std::cout << "    check2 (>0)      : " << ((singVals.array() - diag) / singVals.array()).head(actual_n).transpose()
-              << "\n\n";
-    eigen_internal_assert((((singVals.array() - diag) / singVals.array()).head(actual_n) >= 0).all());
-  }
-#endif
-
-  BDCSVD_SANITY_CHECK(singVals.allFinite());
-  BDCSVD_SANITY_CHECK(mus.allFinite());
-  BDCSVD_SANITY_CHECK(shifts.allFinite());
+  // U is filled by computeSingVecs below; reuse its storage to pack the active secular terms.
+  Map<ArrayXr> secularWorkspace(U.data(), 2 * n);
+  computeSingVals(col0, diag, perm, singVals, shifts, mus, secularWorkspace);
 
   // Compute zhat
   perturbCol0(col0, diag, perm, singVals, shifts, mus, zhat);
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "  zhat: " << zhat.transpose() << "\n";
-#endif
-
-  BDCSVD_SANITY_CHECK(zhat.allFinite());
 
   computeSingVecs(zhat, diag, perm, singVals, shifts, mus, U, V);
 
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "U^T U: " << (U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(), U.cols()))).norm() << "\n";
-  std::cout << "V^T V: " << (V.transpose() * V - MatrixXr(MatrixXr::Identity(V.cols(), V.cols()))).norm() << "\n";
-#endif
-
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
-  BDCSVD_SANITY_CHECK(U.allFinite());
-  BDCSVD_SANITY_CHECK(V.allFinite());
-  //   BDCSVD_SANITY_CHECK((U.transpose() * U - MatrixXr(MatrixXr::Identity(U.cols(),U.cols()))).norm() <
-  //   100*NumTraits<RealScalar>::epsilon() * n);
-  //   BDCSVD_SANITY_CHECK((V.transpose() * V -
-  //   MatrixXr(MatrixXr::Identity(V.cols(),V.cols()))).norm() < 100*NumTraits<RealScalar>::epsilon() * n);
-
   // Because of deflation, the singular values might not be completely sorted.
   // Fortunately, reordering them is a O(n) problem
   for (Index i = 0; i < actual_n - 1; ++i) {
@@ -453,55 +397,73 @@
     }
   }
 
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-  {
-    bool singular_values_sorted =
-        (((singVals.segment(1, actual_n - 1) - singVals.head(actual_n - 1))).array() >= 0).all();
-    if (!singular_values_sorted)
-      std::cout << "Singular values are not sorted: " << singVals.segment(1, actual_n).transpose() << "\n";
-    eigen_internal_assert(singular_values_sorted);
-  }
-#endif
-
   // Reverse order so that singular values in increased order
   // Because of deflation, the zeros singular-values are already at the end
   singVals.head(actual_n).reverseInPlace();
   U.leftCols(actual_n).rowwise().reverseInPlace();
   if (m_compV) V.leftCols(actual_n).rowwise().reverseInPlace();
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  JacobiSVD<MatrixXr> jsvd(m_computed.block(firstCol, firstCol, n, n));
-  std::cout << "  * j:        " << jsvd.singularValues().transpose() << "\n\n";
-  std::cout << "  * sing-val: " << singVals.transpose() << "\n";
-//   std::cout << "  * err:      " << ((jsvd.singularValues()-singVals)>1e-13*singVals.norm()).transpose() << "\n";
-#endif
 }
 
 template <typename RealScalar_>
-typename bdcsvd_impl<RealScalar_>::RealScalar bdcsvd_impl<RealScalar_>::secularEq(RealScalar mu, const ArrayRef& col0,
-                                                                                  const ArrayRef& diag,
-                                                                                  const IndicesRef& perm,
-                                                                                  const ArrayRef& diagShifted,
+EIGEN_STRONG_INLINE typename bdcsvd_impl<RealScalar_>::RealScalar bdcsvd_impl<RealScalar_>::productOfQuotients(
+    RealScalar firstNumerator, RealScalar firstDenominator, RealScalar secondNumerator, RealScalar secondDenominator) {
+  // Keep the divisions separate: combining their denominators can underflow even when the final product is finite.
+  RealScalar firstQuotient = firstNumerator / firstDenominator;
+  RealScalar secondQuotient = secondNumerator / secondDenominator;
+#if defined(__FAST_MATH__) || EIGEN_COMP_NVHPC
+  // NVHPC does not expose a preprocessor macro for -fast, so retain the barriers in all NVHPC builds.
+  EIGEN_OPTIMIZATION_BARRIER(firstQuotient)
+  EIGEN_OPTIMIZATION_BARRIER(secondQuotient)
+#endif
+  return firstQuotient * secondQuotient;
+}
+
+template <typename RealScalar_>
+EIGEN_STRONG_INLINE typename bdcsvd_impl<RealScalar_>::RealScalar bdcsvd_impl<RealScalar_>::sequentialQuotient(
+    RealScalar numerator, RealScalar firstDenominator, RealScalar secondDenominator) {
+  RealScalar firstQuotient = numerator / firstDenominator;
+#if defined(__FAST_MATH__) || EIGEN_COMP_NVHPC
+  EIGEN_OPTIMIZATION_BARRIER(firstQuotient)
+#endif
+  return firstQuotient / secondDenominator;
+}
+
+template <typename RealScalar_>
+typename bdcsvd_impl<RealScalar_>::RealScalar bdcsvd_impl<RealScalar_>::secularEq(RealScalar mu,
+                                                                                  const ConstArrayRef& col0,
+                                                                                  const ConstArrayRef& diag,
+                                                                                  const ConstArrayRef& diagShifted,
                                                                                   RealScalar shift) {
-  Index m = perm.size();
   RealScalar res = Literal(1);
-  for (Index i = 0; i < m; ++i) {
-    Index j = perm(i);
-    // The following expression could be rewritten to involve only a single division,
-    // but this would make the expression more sensitive to overflow.
-    res += (col0(j) / (diagShifted(j) - mu)) * (col0(j) / (diag(j) + shift + mu));
+  for (Index i = 0; i < col0.size(); ++i) {
+    res += productOfQuotients(col0(i), diagShifted(i) - mu, col0(i), diag(i) + shift + mu);
   }
   return res;
 }
 
 template <typename RealScalar_>
 void bdcsvd_impl<RealScalar_>::computeSingVals(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm,
-                                               VectorType& singVals, ArrayRef shifts, ArrayRef mus) {
+                                               VectorType& singVals, ArrayRef shifts, ArrayRef mus,
+                                               ArrayRef workspace) {
+  // See Ren-Cang Li, "Solving Secular Equations Stably and Efficiently",
+  // LAPACK Working Note 89 (1994), and LAPACK's xLASD4/xLASD5 for the
+  // stability rationale behind pole-relative shifts and safeguarded steps.
   using std::abs;
-  using std::sqrt;
   using std::swap;
 
   Index n = col0.size();
+  const Index m = perm.size();
+  // perm is strictly increasing, so its last entry identifies a contiguous prefix.
+  const bool contiguous = m == 0 || perm(m - 1) == m - 1;
+  if (!contiguous) {
+    for (Index i = 0; i < m; ++i) {
+      workspace(i) = col0(perm(i));
+      workspace(m + i) = diag(perm(i));
+    }
+  }
+  // Bind the views once for the repeated secularEq evaluations.
+  const ConstArrayRef activeCol0 = Map<const ArrayXr>(contiguous ? col0.data() : workspace.data(), m);
+  const ConstArrayRef activeDiag = Map<const ArrayXr>(contiguous ? diag.data() : workspace.data() + m, m);
   Index actual_n = n;
   // Note that here actual_n is computed based on col0(i)==0 instead of diag(i)==0 as above
   // because 1) we have diag(i)==0 => col0(i)==0 and 2) if col0(i)==0, then diag(i) is already a singular value.
@@ -521,7 +483,7 @@
     RealScalar left = diag(k);
     RealScalar right;  // was: = (k != actual_n-1) ? diag(k+1) : (diag(actual_n-1) + col0.matrix().norm());
     if (k == actual_n - 1)
-      right = (diag(actual_n - 1) + col0.matrix().norm());
+      right = (diag(actual_n - 1) + col0.matrix().stableNorm());
     else {
       // Skip deflated singular values,
       // recall that at this stage we assume that z[j]!=0 and all entries for which z[j]==0 have been put aside.
@@ -536,42 +498,24 @@
 
     // first decide whether it's closer to the left end or the right end
     RealScalar mid = left + (right - left) / Literal(2);
-    RealScalar fMid = secularEq(mid, col0, diag, perm, diag, Literal(0));
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-    std::cout << "right-left = " << right - left << "\n";
-    //     std::cout << "fMid = " << fMid << " " << secularEq(mid-left, col0, diag, perm, ArrayXr(diag-left), left)
-    //                            << " " << secularEq(mid-right, col0, diag, perm, ArrayXr(diag-right), right)   <<
-    //                            "\n";
-    std::cout << "     = " << secularEq(left + RealScalar(0.000001) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.1) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.2) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.3) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.4) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.49) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.5) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.51) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.6) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.7) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.8) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.9) * (right - left), col0, diag, perm, diag, 0) << " "
-              << secularEq(left + RealScalar(0.999999) * (right - left), col0, diag, perm, diag, 0) << "\n";
-#endif
+    RealScalar fMid = secularEq(mid, activeCol0, activeDiag, activeDiag, Literal(0));
     RealScalar shift = (k == actual_n - 1 || fMid > Literal(0)) ? left : right;
 
     // measure everything relative to shift
-    Map<ArrayXr> diagShifted(m_workspace.data() + 4 * n, n);
-    diagShifted = diag - shift;
+    Map<ArrayXr> diagShifted(m_workspace.data() + 4 * n, m);
+    const ConstArrayRef shiftedRef(diagShifted);
+    diagShifted = activeDiag - shift;
 
     if (k != actual_n - 1) {
       // check that after the shift, f(mid) is still negative:
       RealScalar midShifted = (right - left) / RealScalar(2);
       // we can test exact equality here, because shift comes from `... ? left : right`
       if (numext::equal_strict(shift, right)) midShifted = -midShifted;
-      RealScalar fMidShifted = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+      RealScalar fMidShifted = secularEq(midShifted, activeCol0, activeDiag, shiftedRef, shift);
       if (fMidShifted > 0) {
         // fMid was erroneous, fix it:
         shift = fMidShifted > Literal(0) ? left : right;
-        diagShifted = diag - shift;
+        diagShifted = activeDiag - shift;
       }
     }
 
@@ -589,16 +533,20 @@
       muCur = -(right - left) * RealScalar(0.5);
     }
 
-    RealScalar fPrev = secularEq(muPrev, col0, diag, perm, diagShifted, shift);
-    RealScalar fCur = secularEq(muCur, col0, diag, perm, diagShifted, shift);
+    RealScalar fPrev = secularEq(muPrev, activeCol0, activeDiag, shiftedRef, shift);
+    RealScalar fCur = secularEq(muCur, activeCol0, activeDiag, shiftedRef, shift);
     if (abs(fPrev) < abs(fCur)) {
       swap(fPrev, fCur);
       swap(muPrev, muCur);
     }
 
-    // rational interpolation: fit a function of the form a / mu + b through the two previous
-    // iterates and use its zero to compute the next iterate
-    bool useBisection = fPrev * fCur > Literal(0);
+    // Fit a / mu + b through the two previous iterates. Equal signs permit extrapolation; flat fits and
+    // samples whose reciprocals may overflow stay on bisection. The interval and residual checks below
+    // safeguard each interpolation step.
+    const RealScalar minNormal = (std::numeric_limits<RealScalar>::min)();
+    bool useBisection = fPrev * fCur > Literal(0) && !(abs(fCur - fPrev) > NumTraits<RealScalar>::epsilon() &&
+                                                       abs(fPrev) <= (std::numeric_limits<RealScalar>::max)() &&
+                                                       abs(muPrev) >= minNormal && abs(muCur) >= minNormal);
     while (!numext::is_exactly_zero(fCur) &&
            abs(muCur - muPrev) >
                Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(abs(muCur), abs(muPrev)) &&
@@ -610,9 +558,7 @@
       RealScalar b = fCur - a / muCur;
       // And find mu such that f(mu)==0:
       RealScalar muZero = -a / b;
-      RealScalar fZero = secularEq(muZero, col0, diag, perm, diagShifted, shift);
-
-      BDCSVD_SANITY_CHECK((numext::isfinite)(fZero));
+      RealScalar fZero = secularEq(muZero, activeCol0, activeDiag, shiftedRef, shift);
 
       muPrev = muCur;
       fPrev = fCur;
@@ -627,69 +573,38 @@
 
     // fall back on bisection method if rational interpolation did not work
     if (useBisection) {
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-      std::cout << "useBisection for k = " << k << ", actual_n = " << actual_n << "\n";
-#endif
       RealScalar leftShifted, rightShifted;
       // we can test exact equality here, because shift comes from `... ? left : right`
       if (numext::equal_strict(shift, left)) {
         // to avoid overflow, we must have mu > max(real_min, |z(k)|/sqrt(real_max)),
         // the factor 2 is to be more conservative
-        leftShifted =
-            numext::maxi<RealScalar>((std::numeric_limits<RealScalar>::min)(),
-                                     Literal(2) * abs(col0(k)) / sqrt((std::numeric_limits<RealScalar>::max)()));
+        leftShifted = numext::maxi<RealScalar>(
+            (std::numeric_limits<RealScalar>::min)(),
+            Literal(2) * abs(col0(k)) / numext::sqrt((std::numeric_limits<RealScalar>::max)()));
 
         // check that we did it right:
         eigen_internal_assert(
-            (numext::isfinite)((col0(k) / leftShifted) * (col0(k) / (diag(k) + shift + leftShifted))));
-        // It is unclear why k==0 would need special handling here:
-        // if (k == 0) rightShifted = right - left; else
+            (numext::isfinite)(productOfQuotients(col0(k), leftShifted, col0(k), diag(k) + shift + leftShifted)));
         rightShifted = (k == actual_n - 1)
                            ? right
                            : ((right - left) * RealScalar(0.51));  // theoretically we can take 0.5, but let's be safe
       } else {
         leftShifted = -(right - left) * RealScalar(0.51);
         if (k + 1 < n)
-          rightShifted = -numext::maxi<RealScalar>((std::numeric_limits<RealScalar>::min)(),
-                                                   abs(col0(k + 1)) / sqrt((std::numeric_limits<RealScalar>::max)()));
+          rightShifted =
+              -numext::maxi<RealScalar>((std::numeric_limits<RealScalar>::min)(),
+                                        abs(col0(k + 1)) / numext::sqrt((std::numeric_limits<RealScalar>::max)()));
         else
           rightShifted = -(std::numeric_limits<RealScalar>::min)();
       }
-      RealScalar fLeft = secularEq(leftShifted, col0, diag, perm, diagShifted, shift);
+      RealScalar fLeft = secularEq(leftShifted, activeCol0, activeDiag, shiftedRef, shift);
       eigen_internal_assert(fLeft < Literal(0));
 
-#if defined EIGEN_BDCSVD_DEBUG_VERBOSE || defined EIGEN_BDCSVD_SANITY_CHECKS || defined EIGEN_INTERNAL_DEBUGGING
-      RealScalar fRight = secularEq(rightShifted, col0, diag, perm, diagShifted, shift);
-#endif
-
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-      if (!(numext::isfinite)(fLeft))
-        std::cout << "f(" << leftShifted << ") =" << fLeft << " ; " << left << " " << shift << " " << right << "\n";
-      eigen_internal_assert((numext::isfinite)(fLeft));
-
-      if (!(numext::isfinite)(fRight))
-        std::cout << "f(" << rightShifted << ") =" << fRight << " ; " << left << " " << shift << " " << right << "\n";
-        // eigen_internal_assert((numext::isfinite)(fRight));
-#endif
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-      if (!(fLeft * fRight < 0)) {
-        std::cout << "f(leftShifted) using  leftShifted=" << leftShifted
-                  << " ;  diagShifted(1:10):" << diagShifted.head(10).transpose() << "\n ; "
-                  << "left==shift=" << bool(left == shift) << " ; left-shift = " << (left - shift) << "\n";
-        std::cout << "k=" << k << ", " << fLeft << " * " << fRight << " == " << fLeft * fRight << "  ;  "
-                  << "[" << left << " .. " << right << "] -> [" << leftShifted << " " << rightShifted
-                  << "], shift=" << shift << " ,  f(right)=" << secularEq(0, col0, diag, perm, diagShifted, shift)
-                  << " == " << secularEq(right, col0, diag, perm, diag, 0) << " == " << fRight << "\n";
-      }
-#endif
-      eigen_internal_assert(fLeft * fRight < Literal(0));
-
       if (fLeft < Literal(0)) {
         while (rightShifted - leftShifted > Literal(2) * NumTraits<RealScalar>::epsilon() *
                                                 numext::maxi<RealScalar>(abs(leftShifted), abs(rightShifted))) {
           RealScalar midShifted = (leftShifted + rightShifted) / Literal(2);
-          fMid = secularEq(midShifted, col0, diag, perm, diagShifted, shift);
+          fMid = secularEq(midShifted, activeCol0, activeDiag, shiftedRef, shift);
           eigen_internal_assert((numext::isfinite)(fMid));
 
           if (fLeft * fMid < Literal(0)) {
@@ -703,7 +618,7 @@
       } else {
         // We have a problem as shifting on the left or right give either a positive or negative value
         // at the middle of [left,right]...
-        // Instead of abbording or entering an infinite loop,
+        // Instead of aborting or entering an infinite loop,
         // let's just use the middle as the estimated zero-crossing:
         muCur = (right - left) * RealScalar(0.5);
         // we can test exact equality here, because shift comes from `... ? left : right`
@@ -714,20 +629,6 @@
     singVals[k] = shift + muCur;
     shifts[k] = shift;
     mus[k] = muCur;
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-    if (k + 1 < n)
-      std::cout << "found " << singVals[k] << " == " << shift << " + " << muCur << " from " << diag(k) << " .. "
-                << diag(k + 1) << "\n";
-#endif
-    BDCSVD_SANITY_CHECK(k == 0 || singVals[k] >= singVals[k - 1]);
-    BDCSVD_SANITY_CHECK(singVals[k] >= diag(k));
-
-    // perturb singular value slightly if it equals diagonal entry to avoid division by zero later
-    // (deflation is supposed to avoid this from happening)
-    // - this does no seem to be necessary anymore -
-    // if (singVals[k] == left) singVals[k] *= 1 + NumTraits<RealScalar>::epsilon();
-    // if (singVals[k] == right) singVals[k] *= 1 - NumTraits<RealScalar>::epsilon();
   }
 }
 
@@ -736,7 +637,7 @@
 void bdcsvd_impl<RealScalar_>::perturbCol0(const ArrayRef& col0, const ArrayRef& diag, const IndicesRef& perm,
                                            const VectorType& singVals, const ArrayRef& shifts, const ArrayRef& mus,
                                            ArrayRef zhat) {
-  using std::sqrt;
+  using std::abs;
   Index n = col0.size();
   Index m = perm.size();
   if (m == 0) {
@@ -751,60 +652,32 @@
     else {
       // see equation (3.6)
       RealScalar dk = diag(k);
-      RealScalar prod = (singVals(lastIdx) + dk) * (mus(lastIdx) + (shifts(lastIdx) - dk));
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-      if (prod < 0) {
-        std::cout << "k = " << k << " ;  z(k)=" << col0(k) << ", diag(k)=" << dk << "\n";
-        std::cout << "prod = "
-                  << "(" << singVals(lastIdx) << " + " << dk << ") * (" << mus(lastIdx) << " + (" << shifts(lastIdx)
-                  << " - " << dk << "))"
-                  << "\n";
-        std::cout << "     = " << singVals(lastIdx) + dk << " * " << mus(lastIdx) + (shifts(lastIdx) - dk) << "\n";
-      }
-      eigen_internal_assert(prod >= 0);
-#endif
+      // Materialize the close subtraction before adding the small correction.
+      // Unsafe FP reassociation may otherwise turn `mus + (shift - dk)` into
+      // `(mus + shift) - dk`, losing `mus` when `shift` and `dk` cancel.
+      RealScalar diff = shifts(lastIdx) - dk;
+      EIGEN_OPTIMIZATION_BARRIER(diff)
+      RealScalar prod = (singVals(lastIdx) + dk) * (mus(lastIdx) + diff);
 
       for (Index l = 0; l < m; ++l) {
         Index i = perm(l);
         if (i != k) {
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-          if (i >= k && (l == 0 || l - 1 >= m)) {
-            std::cout << "Error in perturbCol0\n";
-            std::cout << "  " << k << "/" << n << " " << l << "/" << m << " " << i << "/" << n << " ; " << col0(k)
-                      << " " << diag(k) << " "
-                      << "\n";
-            std::cout << "  " << diag(i) << "\n";
-            Index j = (i < k /*|| l==0*/) ? i : perm(l - 1);
-            std::cout << "  "
-                      << "j=" << j << "\n";
+          // There is no valid predecessor when the first active index is already on the
+          // right of k. Treat this as a numerical issue and zero the product.
+          if (i >= k && l == 0) {
+            m_info = NumericalIssue;
+            prod = Literal(0);
+            break;
           }
-#endif
-          Index j = i < k ? i : l > 0 ? perm(l - 1) : i;
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-          if (!(dk != Literal(0) || diag(i) != Literal(0))) {
-            std::cout << "k=" << k << ", i=" << i << ", l=" << l << ", perm.size()=" << perm.size() << "\n";
-          }
-          eigen_internal_assert(dk != Literal(0) || diag(i) != Literal(0));
-#endif
-          prod *= ((singVals(j) + dk) / ((diag(i) + dk))) * ((mus(j) + (shifts(j) - dk)) / ((diag(i) - dk)));
-          BDCSVD_SANITY_CHECK(prod >= 0);
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-          if (i != k &&
-              numext::abs(((singVals(j) + dk) * (mus(j) + (shifts(j) - dk))) / ((diag(i) + dk) * (diag(i) - dk)) - 1) >
-                  0.9)
-            std::cout << "     "
-                      << ((singVals(j) + dk) * (mus(j) + (shifts(j) - dk))) / ((diag(i) + dk) * (diag(i) - dk))
-                      << " == (" << (singVals(j) + dk) << " * " << (mus(j) + (shifts(j) - dk)) << ") / ("
-                      << (diag(i) + dk) << " * " << (diag(i) - dk) << ")\n";
-#endif
+          Index j = i < k ? i : perm(l - 1);
+          diff = shifts(j) - dk;
+          EIGEN_OPTIMIZATION_BARRIER(diff)
+          prod *= productOfQuotients(singVals(j) + dk, diag(i) + dk, mus(j) + diff, diag(i) - dk);
         }
       }
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-      std::cout << "zhat(" << k << ") =  sqrt( " << prod << ")  ;  " << (singVals(lastIdx) + dk) << " * "
-                << mus(lastIdx) + shifts(lastIdx) << " - " << dk << "\n";
-#endif
-      RealScalar tmp = sqrt(prod);
-      BDCSVD_SANITY_CHECK((numext::isfinite)(tmp));
+      // This product is non-negative in exact arithmetic. As in LAPACK's
+      // xLASD8, take abs before sqrt to tolerate a negative rounding residue.
+      RealScalar tmp = numext::sqrt(abs(prod));
       zhat(k) = col0(k) > Literal(0) ? RealScalar(tmp) : RealScalar(-tmp);
     }
   }
@@ -824,21 +697,32 @@
       if (m_compV) V.col(k) = VectorType::Unit(n, k);
     } else {
       U.col(k).setZero();
+      if (m_compV) V.col(k).setZero();
+      const RealScalar shift = shifts(k);
+      const RealScalar mu = mus(k);
+      const RealScalar singularValue = singVals(k);
       for (Index l = 0; l < m; ++l) {
         Index i = perm(l);
-        U(i, k) = zhat(i) / (((diag(i) - shifts(k)) - mus(k))) / ((diag(i) + singVals[k]));
+        const RealScalar diagonal = diag(i);
+        const RealScalar z = zhat(i);
+        RealScalar diff = diagonal - shift;
+        EIGEN_OPTIMIZATION_BARRIER(diff)
+        diff -= mu;
+        EIGEN_OPTIMIZATION_BARRIER(diff)
+        const RealScalar sum = diagonal + singularValue;
+        U(i, k) = sequentialQuotient(z, diff, sum);
+        if (m_compV && l > 0) V(i, k) = sequentialQuotient(diagonal * z, diff, sum);
       }
       U(n, k) = Literal(0);
-      U.col(k).normalize();
+      // LAPACK's xLASD3 normalizes these vectors with xNRM2. Use the scaled
+      // normalization unconditionally: under -ffast-math, compilers may
+      // assume that the overflowing result of norm() is finite and discard
+      // an isfinite-based fallback.
+      U.col(k).stableNormalize();
 
       if (m_compV) {
-        V.col(k).setZero();
-        for (Index l = 1; l < m; ++l) {
-          Index i = perm(l);
-          V(i, k) = diag(i) * zhat(i) / (((diag(i) - shifts(k)) - mus(k))) / ((diag(i) + singVals[k]));
-        }
         V(0, k) = Literal(-1);
-        V.col(k).normalize();
+        V.col(k).stableNormalize();
       }
     }
   }
@@ -850,8 +734,6 @@
 // We use a rotation to zero out zi applied to the left of M, and set di = 0.
 template <typename RealScalar_>
 void bdcsvd_impl<RealScalar_>::deflation43(Index firstCol, Index shift, Index i, Index size) {
-  using std::abs;
-  using std::sqrt;
   Index start = firstCol + shift;
   RealScalar c = m_computed(start, start);
   RealScalar s = m_computed(start + i, start);
@@ -877,20 +759,9 @@
 template <typename RealScalar_>
 void bdcsvd_impl<RealScalar_>::deflation44(Index firstColu, Index firstColm, Index firstRowW, Index firstColW, Index i,
                                            Index j, Index size) {
-  using std::abs;
-  using std::sqrt;
-
   RealScalar s = m_computed(firstColm + i, firstColm);
   RealScalar c = m_computed(firstColm + j, firstColm);
   RealScalar r = numext::hypot(c, s);
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "deflation 4.4: " << i << "," << j << " -> " << c << " " << s << " " << r << " ; "
-            << m_computed(firstColm + i - 1, firstColm) << " " << m_computed(firstColm + i, firstColm) << " "
-            << m_computed(firstColm + i + 1, firstColm) << " " << m_computed(firstColm + i + 2, firstColm) << "\n";
-  std::cout << m_computed(firstColm + i - 1, firstColm + i - 1) << " " << m_computed(firstColm + i, firstColm + i)
-            << " " << m_computed(firstColm + i + 1, firstColm + i + 1) << " "
-            << m_computed(firstColm + i + 2, firstColm + i + 2) << "\n";
-#endif
   if (numext::is_exactly_zero(r)) {
     m_computed(firstColm + j, firstColm + j) = m_computed(firstColm + i, firstColm + i);
     return;
@@ -914,7 +785,6 @@
 void bdcsvd_impl<RealScalar_>::deflation(Index firstCol, Index lastCol, Index k, Index firstRowW, Index firstColW,
                                          Index shift) {
   using std::abs;
-  using std::sqrt;
   const Index length = lastCol + 1 - firstCol;
 
   Block<MatrixXr, Dynamic, 1> col0(m_computed, firstCol + shift, firstCol + shift, length, 1);
@@ -927,51 +797,23 @@
   RealScalar epsilon_coarse =
       Literal(8) * NumTraits<RealScalar>::epsilon() * numext::maxi<RealScalar>(col0.cwiseAbs().maxCoeff(), maxDiag);
 
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "\ndeflate:" << diag.head(k + 1).transpose() << "  |  "
-            << diag.segment(k + 1, length - k - 1).transpose() << "\n";
-#endif
-
   // condition 4.1
   if (diag(0) < epsilon_coarse) {
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-    std::cout << "deflation 4.1, because " << diag(0) << " < " << epsilon_coarse << "\n";
-#endif
     diag(0) = epsilon_coarse;
   }
 
   // condition 4.2
   for (Index i = 1; i < length; ++i)
     if (abs(col0(i)) < epsilon_strict) {
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-      std::cout << "deflation 4.2, set z(" << i << ") to zero because " << abs(col0(i)) << " < " << epsilon_strict
-                << "  (diag(" << i << ")=" << diag(i) << ")\n";
-#endif
       col0(i) = Literal(0);
     }
 
   // condition 4.3
   for (Index i = 1; i < length; i++)
     if (diag(i) < epsilon_coarse) {
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-      std::cout << "deflation 4.3, cancel z(" << i << ")=" << col0(i) << " because diag(" << i << ")=" << diag(i)
-                << " < " << epsilon_coarse << "\n";
-#endif
       deflation43(firstCol, shift, i, length);
     }
 
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
-
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "to be sorted: " << diag.transpose() << "\n\n";
-  std::cout << "            : " << col0.transpose() << "\n\n";
-#endif
   {
     // Check for total deflation:
     // If we have a total deflation, then we have to consider col0(0)==diag(0) as a singular value during sorting.
@@ -1052,10 +894,6 @@
       realInd[i] = pi;
     }
   }
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-  std::cout << "sorted: " << diag.transpose().format(bdcsvdfmt) << "\n";
-  std::cout << "      : " << col0.transpose() << "\n\n";
-#endif
 
   // condition 4.4
   {
@@ -1064,24 +902,11 @@
     while (i > 0 && (diag(i) < considerZero || abs(col0(i)) < considerZero)) --i;
 
     for (; i > 1; --i)
-      if ((diag(i) - diag(i - 1)) < epsilon_strict) {
-#ifdef EIGEN_BDCSVD_DEBUG_VERBOSE
-        std::cout << "deflation 4.4 with i = " << i << " because " << diag(i) << " - " << diag(i - 1)
-                  << " == " << (diag(i) - diag(i - 1)) << " < " << epsilon_strict << "\n";
-#endif
-        eigen_internal_assert(abs(diag(i) - diag(i - 1)) < epsilon_coarse &&
-                              " diagonal entries are not properly sorted");
+      if ((diag(i) - diag(i - 1)) < epsilon_coarse) {
         deflation44(firstCol, firstCol + shift, firstRowW, firstColW, i, i - 1, length);
       }
   }
 
-#ifdef EIGEN_BDCSVD_SANITY_CHECKS
-  for (Index j = 2; j < length; ++j) eigen_internal_assert(diag(j - 1) <= diag(j) || abs(diag(j)) < considerZero);
-#endif
-
-  BDCSVD_SANITY_CHECK(m_naiveU.allFinite());
-  BDCSVD_SANITY_CHECK(m_naiveV.allFinite());
-  BDCSVD_SANITY_CHECK(m_computed.allFinite());
 }  // end deflation
 
 }  // end namespace internal
diff --git a/Eigen/src/SVD/BDCSVD_LAPACKE.h b/Eigen/src/SVD/BDCSVD_LAPACKE.h
index 5d2b8c7..bcd6bac 100644
--- a/Eigen/src/SVD/BDCSVD_LAPACKE.h
+++ b/Eigen/src/SVD/BDCSVD_LAPACKE.h
@@ -6,6 +6,7 @@
 //
 // This file is based on the JacobiSVD_LAPACKE.h originally from Intel -
 // see license notice below:
+// SPDX-License-Identifier: BSD-3-Clause
 /*
  Redistribution and use in source and binary forms, with or without modification,
  are permitted provided that the following conditions are met:
diff --git a/Eigen/src/SVD/InternalHeaderCheck.h b/Eigen/src/SVD/InternalHeaderCheck.h
index fa67b96..b0d0069 100644
--- a/Eigen/src/SVD/InternalHeaderCheck.h
+++ b/Eigen/src/SVD/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SVD_MODULE_H
 #error "Please include Eigen/SVD instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SVD/JacobiSVD.h b/Eigen/src/SVD/JacobiSVD.h
index fd0275c..9120423 100644
--- a/Eigen/src/SVD/JacobiSVD.h
+++ b/Eigen/src/SVD/JacobiSVD.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_JACOBISVD_H
 #define EIGEN_JACOBISVD_H
@@ -33,19 +34,17 @@
 enum { PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols };
 
 template <typename MatrixType, int QRPreconditioner, int Case>
-struct qr_preconditioner_should_do_anything {
-  enum {
-    a = MatrixType::RowsAtCompileTime != Dynamic && MatrixType::ColsAtCompileTime != Dynamic &&
-        MatrixType::ColsAtCompileTime <= MatrixType::RowsAtCompileTime,
-    b = MatrixType::RowsAtCompileTime != Dynamic && MatrixType::ColsAtCompileTime != Dynamic &&
-        MatrixType::RowsAtCompileTime <= MatrixType::ColsAtCompileTime,
-    ret = !((QRPreconditioner == NoQRPreconditioner) || (Case == PreconditionIfMoreColsThanRows && bool(a)) ||
-            (Case == PreconditionIfMoreRowsThanCols && bool(b)))
-  };
-};
+struct qr_preconditioner_should_do_anything
+    : bool_constant<!((QRPreconditioner == NoQRPreconditioner) ||
+                      (Case == PreconditionIfMoreColsThanRows && MatrixType::RowsAtCompileTime != Dynamic &&
+                       MatrixType::ColsAtCompileTime != Dynamic &&
+                       MatrixType::ColsAtCompileTime <= MatrixType::RowsAtCompileTime) ||
+                      (Case == PreconditionIfMoreRowsThanCols && MatrixType::RowsAtCompileTime != Dynamic &&
+                       MatrixType::ColsAtCompileTime != Dynamic &&
+                       MatrixType::RowsAtCompileTime <= MatrixType::ColsAtCompileTime))> {};
 
 template <typename MatrixType, int Options, int QRPreconditioner, int Case,
-          bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret>
+          bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::value>
 struct qr_preconditioner_impl {};
 
 template <typename MatrixType, int Options, int QRPreconditioner, int Case>
@@ -64,12 +63,12 @@
 class qr_preconditioner_impl<MatrixType, Options, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols,
                              true> {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef JacobiSVD<MatrixType, Options> SVDType;
+  using Scalar = typename MatrixType::Scalar;
+  using SVDType = JacobiSVD<MatrixType, Options>;
 
   enum { WorkspaceSize = MatrixType::RowsAtCompileTime, MaxWorkspaceSize = MatrixType::MaxRowsAtCompileTime };
 
-  typedef Matrix<Scalar, 1, WorkspaceSize, RowMajor, 1, MaxWorkspaceSize> WorkspaceType;
+  using WorkspaceType = Matrix<Scalar, 1, WorkspaceSize, RowMajor, 1, MaxWorkspaceSize>;
 
   void allocate(const SVDType& svd) {
     if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols()) {
@@ -91,7 +90,7 @@
   }
 
  private:
-  typedef FullPivHouseholderQR<MatrixType> QRType;
+  using QRType = FullPivHouseholderQR<MatrixType>;
   QRType m_qr;
   WorkspaceType m_workspace;
 };
@@ -100,8 +99,8 @@
 class qr_preconditioner_impl<MatrixType, Options, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows,
                              true> {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef JacobiSVD<MatrixType, Options> SVDType;
+  using Scalar = typename MatrixType::Scalar;
+  using SVDType = JacobiSVD<MatrixType, Options>;
 
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
@@ -111,9 +110,9 @@
     MatrixOptions = traits<MatrixType>::Options
   };
 
-  typedef typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, RowsAtCompileTime, MatrixOptions,
-                                                     MaxColsAtCompileTime, MaxRowsAtCompileTime>::type
-      TransposeTypeWithSameStorageOrder;
+  using TransposeTypeWithSameStorageOrder =
+      typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, RowsAtCompileTime, MatrixOptions,
+                                                 MaxColsAtCompileTime, MaxRowsAtCompileTime>::type;
 
   void allocate(const SVDType& svd) {
     if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols()) {
@@ -136,7 +135,7 @@
   }
 
  private:
-  typedef FullPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  using QRType = FullPivHouseholderQR<TransposeTypeWithSameStorageOrder>;
   QRType m_qr;
   typename plain_row_type<MatrixType>::type m_workspace;
 };
@@ -147,15 +146,15 @@
 class qr_preconditioner_impl<MatrixType, Options, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols,
                              true> {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef JacobiSVD<MatrixType, Options> SVDType;
+  using Scalar = typename MatrixType::Scalar;
+  using SVDType = JacobiSVD<MatrixType, Options>;
 
   enum {
     WorkspaceSize = internal::traits<SVDType>::MatrixUColsAtCompileTime,
     MaxWorkspaceSize = internal::traits<SVDType>::MatrixUMaxColsAtCompileTime
   };
 
-  typedef Matrix<Scalar, 1, WorkspaceSize, RowMajor, 1, MaxWorkspaceSize> WorkspaceType;
+  using WorkspaceType = Matrix<Scalar, 1, WorkspaceSize, RowMajor, 1, MaxWorkspaceSize>;
 
   void allocate(const SVDType& svd) {
     if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols()) {
@@ -185,7 +184,7 @@
   }
 
  private:
-  typedef ColPivHouseholderQR<MatrixType> QRType;
+  using QRType = ColPivHouseholderQR<MatrixType>;
   QRType m_qr;
   WorkspaceType m_workspace;
 };
@@ -194,8 +193,8 @@
 class qr_preconditioner_impl<MatrixType, Options, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows,
                              true> {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef JacobiSVD<MatrixType, Options> SVDType;
+  using Scalar = typename MatrixType::Scalar;
+  using SVDType = JacobiSVD<MatrixType, Options>;
 
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
@@ -207,11 +206,11 @@
     MaxWorkspaceSize = internal::traits<SVDType>::MatrixVMaxColsAtCompileTime
   };
 
-  typedef Matrix<Scalar, WorkspaceSize, 1, ColMajor, MaxWorkspaceSize, 1> WorkspaceType;
+  using WorkspaceType = Matrix<Scalar, WorkspaceSize, 1, ColMajor, MaxWorkspaceSize, 1>;
 
-  typedef typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, RowsAtCompileTime, MatrixOptions,
-                                                     MaxColsAtCompileTime, MaxRowsAtCompileTime>::type
-      TransposeTypeWithSameStorageOrder;
+  using TransposeTypeWithSameStorageOrder =
+      typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, RowsAtCompileTime, MatrixOptions,
+                                                 MaxColsAtCompileTime, MaxRowsAtCompileTime>::type;
 
   void allocate(const SVDType& svd) {
     if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols()) {
@@ -243,7 +242,7 @@
   }
 
  private:
-  typedef ColPivHouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  using QRType = ColPivHouseholderQR<TransposeTypeWithSameStorageOrder>;
   QRType m_qr;
   WorkspaceType m_workspace;
 };
@@ -253,15 +252,15 @@
 template <typename MatrixType, int Options>
 class qr_preconditioner_impl<MatrixType, Options, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef JacobiSVD<MatrixType, Options> SVDType;
+  using Scalar = typename MatrixType::Scalar;
+  using SVDType = JacobiSVD<MatrixType, Options>;
 
   enum {
     WorkspaceSize = internal::traits<SVDType>::MatrixUColsAtCompileTime,
     MaxWorkspaceSize = internal::traits<SVDType>::MatrixUMaxColsAtCompileTime
   };
 
-  typedef Matrix<Scalar, 1, WorkspaceSize, RowMajor, 1, MaxWorkspaceSize> WorkspaceType;
+  using WorkspaceType = Matrix<Scalar, 1, WorkspaceSize, RowMajor, 1, MaxWorkspaceSize>;
 
   void allocate(const SVDType& svd) {
     if (svd.rows() != m_qr.rows() || svd.cols() != m_qr.cols()) {
@@ -291,7 +290,7 @@
   }
 
  private:
-  typedef HouseholderQR<MatrixType> QRType;
+  using QRType = HouseholderQR<MatrixType>;
   QRType m_qr;
   WorkspaceType m_workspace;
 };
@@ -299,8 +298,8 @@
 template <typename MatrixType, int Options>
 class qr_preconditioner_impl<MatrixType, Options, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef JacobiSVD<MatrixType, Options> SVDType;
+  using Scalar = typename MatrixType::Scalar;
+  using SVDType = JacobiSVD<MatrixType, Options>;
 
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
@@ -312,11 +311,11 @@
     MaxWorkspaceSize = internal::traits<SVDType>::MatrixVMaxColsAtCompileTime
   };
 
-  typedef Matrix<Scalar, WorkspaceSize, 1, ColMajor, MaxWorkspaceSize, 1> WorkspaceType;
+  using WorkspaceType = Matrix<Scalar, WorkspaceSize, 1, ColMajor, MaxWorkspaceSize, 1>;
 
-  typedef typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, RowsAtCompileTime, MatrixOptions,
-                                                     MaxColsAtCompileTime, MaxRowsAtCompileTime>::type
-      TransposeTypeWithSameStorageOrder;
+  using TransposeTypeWithSameStorageOrder =
+      typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, RowsAtCompileTime, MatrixOptions,
+                                                 MaxColsAtCompileTime, MaxRowsAtCompileTime>::type;
 
   void allocate(const SVDType& svd) {
     if (svd.cols() != m_qr.rows() || svd.rows() != m_qr.cols()) {
@@ -349,7 +348,7 @@
   }
 
  private:
-  typedef HouseholderQR<TransposeTypeWithSameStorageOrder> QRType;
+  using QRType = HouseholderQR<TransposeTypeWithSameStorageOrder>;
   QRType m_qr;
   WorkspaceType m_workspace;
 };
@@ -361,16 +360,16 @@
 
 template <typename MatrixType, int Options>
 struct svd_precondition_2x2_block_to_be_real<MatrixType, Options, false> {
-  typedef JacobiSVD<MatrixType, Options> SVD;
-  typedef typename MatrixType::RealScalar RealScalar;
+  using SVD = JacobiSVD<MatrixType, Options>;
+  using RealScalar = typename MatrixType::RealScalar;
   static bool run(typename SVD::WorkMatrixType&, SVD&, Index, Index, RealScalar&) { return true; }
 };
 
 template <typename MatrixType, int Options>
 struct svd_precondition_2x2_block_to_be_real<MatrixType, Options, true> {
-  typedef JacobiSVD<MatrixType, Options> SVD;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
+  using SVD = JacobiSVD<MatrixType, Options>;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
   static bool run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q, RealScalar& maxDiagEntry) {
     using numext::abs;
     using numext::sqrt;
@@ -424,9 +423,109 @@
   }
 };
 
+template <typename WorkMatrixType, typename MatrixUType, typename MatrixVType>
+EIGEN_DONT_INLINE bool jacobi_svd_nonblocking_sweep(WorkMatrixType& work_matrix, MatrixUType& matrix_u,
+                                                    MatrixVType& matrix_v, bool compute_u, bool compute_v,
+                                                    typename WorkMatrixType::RealScalar considerAsZero,
+                                                    typename WorkMatrixType::RealScalar precision,
+                                                    typename WorkMatrixType::RealScalar& maxDiagEntry) {
+  using numext::abs;
+  using numext::sqrt;
+  using Scalar = typename WorkMatrixType::Scalar;
+  using RealScalar = typename WorkMatrixType::RealScalar;
+  const Index n = work_matrix.rows();
+  bool notFinished = false;
+
+  EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+    // Complex non-blocking sweep: condition each 2x2 block to be real before diagonalizing.
+    for (Index p = 1; p < n; ++p) {
+      for (Index q = 0; q < p; ++q) {
+        RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+        if (abs(work_matrix.coeff(p, q)) > threshold || abs(work_matrix.coeff(q, p)) > threshold) {
+          notFinished = true;
+          Scalar z;
+          bool doRealSvd = true;
+          RealScalar nn = sqrt(numext::abs2(work_matrix.coeff(p, p)) + numext::abs2(work_matrix.coeff(q, p)));
+
+          if (numext::is_exactly_zero(nn)) {
+            // Make sure first column is zero.
+            work_matrix.coeffRef(p, p) = work_matrix.coeffRef(q, p) = Scalar(0);
+
+            if (abs(numext::imag(work_matrix.coeff(p, q))) > considerAsZero) {
+              // work_matrix.coeff(p, q) can be zero if work_matrix.coeff(q, p) is not zero but small enough to
+              // underflow when computing nn.
+              z = abs(work_matrix.coeff(p, q)) / work_matrix.coeff(p, q);
+              work_matrix.row(p) *= z;
+              if (compute_u) matrix_u.col(p) *= numext::conj(z);
+            }
+            if (abs(numext::imag(work_matrix.coeff(q, q))) > considerAsZero) {
+              z = abs(work_matrix.coeff(q, q)) / work_matrix.coeff(q, q);
+              work_matrix.row(q) *= z;
+              if (compute_u) matrix_u.col(q) *= numext::conj(z);
+            }
+          } else {
+            JacobiRotation<Scalar> rot;
+            rot.c() = numext::conj(work_matrix.coeff(p, p)) / nn;
+            rot.s() = work_matrix.coeff(q, p) / nn;
+            work_matrix.applyOnTheLeft(p, q, rot);
+            if (compute_u) matrix_u.applyOnTheRight(p, q, rot.adjoint());
+            if (abs(numext::imag(work_matrix.coeff(p, q))) > considerAsZero) {
+              z = abs(work_matrix.coeff(p, q)) / work_matrix.coeff(p, q);
+              work_matrix.col(q) *= z;
+              if (compute_v) matrix_v.col(q) *= z;
+            }
+            if (abs(numext::imag(work_matrix.coeff(q, q))) > considerAsZero) {
+              z = abs(work_matrix.coeff(q, q)) / work_matrix.coeff(q, q);
+              work_matrix.row(q) *= z;
+              if (compute_u) matrix_u.col(q) *= numext::conj(z);
+            }
+          }
+
+          maxDiagEntry = numext::maxi<RealScalar>(
+              maxDiagEntry, numext::maxi<RealScalar>(abs(work_matrix.coeff(p, p)), abs(work_matrix.coeff(q, q))));
+          threshold = numext::maxi<RealScalar>(considerAsZero, NumTraits<Scalar>::epsilon() * maxDiagEntry);
+          doRealSvd = abs(work_matrix.coeff(p, q)) > threshold || abs(work_matrix.coeff(q, p)) > threshold;
+
+          if (doRealSvd) {
+            JacobiRotation<RealScalar> j_left, j_right;
+            internal::real_2x2_jacobi_svd(work_matrix, p, q, &j_left, &j_right);
+            work_matrix.applyOnTheLeft(p, q, j_left);
+            if (compute_u) matrix_u.applyOnTheRight(p, q, j_left.transpose());
+            work_matrix.applyOnTheRight(p, q, j_right);
+            if (compute_v) matrix_v.applyOnTheRight(p, q, j_right);
+            maxDiagEntry = numext::maxi<RealScalar>(
+                maxDiagEntry, numext::maxi<RealScalar>(abs(work_matrix.coeff(p, p)), abs(work_matrix.coeff(q, q))));
+          }
+        }
+      }
+    }
+  } else {
+    // Real non-blocking sweep: diagonalize each 2x2 block directly.
+    RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+    for (Index p = 1; p < n; ++p) {
+      for (Index q = 0; q < p; ++q) {
+        if (abs(work_matrix.coeff(p, q)) > threshold || abs(work_matrix.coeff(q, p)) > threshold) {
+          notFinished = true;
+          JacobiRotation<RealScalar> j_left, j_right;
+          internal::real_2x2_jacobi_svd(work_matrix, p, q, &j_left, &j_right);
+          work_matrix.applyOnTheLeft(p, q, j_left);
+          if (compute_u) matrix_u.applyOnTheRight(p, q, j_left.transpose());
+          work_matrix.applyOnTheRight(p, q, j_right);
+          if (compute_v) matrix_v.applyOnTheRight(p, q, j_right);
+          maxDiagEntry = numext::maxi<RealScalar>(
+              maxDiagEntry, numext::maxi<RealScalar>(abs(work_matrix.coeff(p, p)), abs(work_matrix.coeff(q, q))));
+          threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
+        }
+      }
+    }
+  }
+
+  return notFinished;
+}
+
 template <typename MatrixType_, int Options>
 struct traits<JacobiSVD<MatrixType_, Options>> : svd_traits<MatrixType_, Options> {
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
 };
 
 }  // end namespace internal
@@ -480,7 +579,7 @@
  * \li HouseholderQRPreconditioner is the fastest, and less safe and accurate than the pivoting variants. It uses
  * non-pivoting QR. This is very similar in safety and accuracy to the bidiagonalization process used by bidiagonalizing
  * SVD algorithms (since bidiagonalization is inherently non-pivoting). However the resulting SVD is still more reliable
- * than bidiagonalizing SVDs because the Jacobi-based iterarive process is more reliable than the optimized bidiagonal
+ * than bidiagonalizing SVDs because the Jacobi-based iterative process is more reliable than the optimized bidiagonal
  * SVD iterations. \li NoQRPreconditioner allows not to use a QR preconditioner at all. This is useful if you know that
  * you will only be computing JacobiSVD decompositions of square matrices. Non-square matrices require a QR
  * preconditioner. Using this option will result in faster compilation and smaller executable code. It won't
@@ -498,12 +597,12 @@
  */
 template <typename MatrixType_, int Options_>
 class JacobiSVD : public SVDBase<JacobiSVD<MatrixType_, Options_>> {
-  typedef SVDBase<JacobiSVD> Base;
+  using Base = SVDBase<JacobiSVD>;
 
  public:
-  typedef MatrixType_ MatrixType;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::RealScalar RealScalar;
+  using MatrixType = MatrixType_;
+  using Scalar = typename Base::Scalar;
+  using RealScalar = typename Base::RealScalar;
   enum : int {
     Options = Options_,
     QRPreconditioner = internal::get_qr_preconditioner(Options),
@@ -516,12 +615,11 @@
     MatrixOptions = Base::MatrixOptions
   };
 
-  typedef typename Base::MatrixUType MatrixUType;
-  typedef typename Base::MatrixVType MatrixVType;
-  typedef typename Base::SingularValuesType SingularValuesType;
-  typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime, MatrixOptions, MaxDiagSizeAtCompileTime,
-                 MaxDiagSizeAtCompileTime>
-      WorkMatrixType;
+  using MatrixUType = typename Base::MatrixUType;
+  using MatrixVType = typename Base::MatrixVType;
+  using SingularValuesType = typename Base::SingularValuesType;
+  using WorkMatrixType = Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime, MatrixOptions,
+                                MaxDiagSizeAtCompileTime, MaxDiagSizeAtCompileTime>;
 
   /** \brief Default Constructor.
    *
@@ -591,8 +689,7 @@
   // EIGEN_DEPRECATED // TODO(cantonios): re-enable after fixing a few 3p libraries that error on deprecation warnings.
   template <typename Derived>
   JacobiSVD(const MatrixBase<Derived>& matrix, unsigned int computationOptions) {
-    internal::check_svd_options_assertions<MatrixBase<Derived>, Options>(computationOptions, matrix.rows(),
-                                                                         matrix.cols());
+    internal::check_svd_options_assertions<MatrixType, Options>(computationOptions, matrix.rows(), matrix.cols());
     compute_impl(matrix, computationOptions);
   }
 
@@ -623,8 +720,7 @@
   template <typename Derived>
   EIGEN_DEPRECATED_WITH_REASON("Options should be specified using the class template parameter.")
   JacobiSVD& compute(const MatrixBase<Derived>& matrix, unsigned int computationOptions) {
-    internal::check_svd_options_assertions<MatrixBase<Derived>, Options>(m_computationOptions, matrix.rows(),
-                                                                         matrix.cols());
+    internal::check_svd_options_assertions<MatrixType, Options>(m_computationOptions, matrix.rows(), matrix.cols());
     return compute_impl(matrix, computationOptions);
   }
 
@@ -717,7 +813,7 @@
                                                                              unsigned int computationOptions) {
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived, MatrixType);
   EIGEN_STATIC_ASSERT((std::is_same<typename Derived::Scalar, typename MatrixType::Scalar>::value),
-                      Input matrix must have the same Scalar type as the BDCSVD object.);
+                      Input matrix must have the same Scalar type as the JacobiSVD object.);
 
   using numext::abs;
 
@@ -731,24 +827,28 @@
   const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
 
   // Scaling factor to reduce over/under-flows
-  RealScalar scale = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
-  if (!(numext::isfinite)(scale)) {
+  const RealScalar maxCoeff = matrix.cwiseAbs().template maxCoeff<PropagateNaN>();
+  if (!(numext::isfinite)(maxCoeff)) {
     m_isInitialized = true;
     m_info = InvalidInput;
     m_nonzeroSingularValues = 0;
     m_singularValues.setZero();
     return *this;
   }
-  if (numext::is_exactly_zero(scale)) scale = RealScalar(1);
+  internal::safe_scaling_factors<RealScalar> factors;
 
   /*** step 1. The R-SVD step: we use a QR decomposition to reduce to the case of a square matrix */
 
   if (rows() != cols()) {
-    m_qr_precond_morecols.run(*this, matrix / scale);
-    m_qr_precond_morerows.run(*this, matrix / scale);
+    factors =
+        internal::safe_scaling<RealScalar>::with_scaled(matrix.derived(), maxCoeff, [&](const auto& scaledMatrix) {
+          m_qr_precond_morecols.run(*this, scaledMatrix);
+          m_qr_precond_morerows.run(*this, scaledMatrix);
+        });
   } else {
-    m_workMatrix =
-        matrix.template topLeftCorner<DiagSizeAtCompileTime, DiagSizeAtCompileTime>(diagSize(), diagSize()) / scale;
+    factors = internal::safe_scaling<RealScalar>::scale_to(
+        m_workMatrix,
+        matrix.template topLeftCorner<DiagSizeAtCompileTime, DiagSizeAtCompileTime>(diagSize(), diagSize()), maxCoeff);
     if (m_computeFullU) m_matrixU.setIdentity(rows(), rows());
     if (m_computeThinU) m_matrixU.setIdentity(rows(), diagSize());
     if (m_computeFullV) m_matrixV.setIdentity(cols(), cols());
@@ -762,7 +862,7 @@
   while (!finished) {
     finished = true;
 
-    {
+    EIGEN_IF_CONSTEXPR (MaxDiagSizeAtCompileTime == Dynamic || MaxDiagSizeAtCompileTime > kBlockSize) {
       // Sweep with optional blocking for large matrices.
       // Use blocking when the matrix is large enough that individual left rotations
       // (strided row operations on column-major data) cause significant cache misses.
@@ -775,7 +875,8 @@
 #ifdef EIGEN_JACOBI_SVD_BLOCKING_THRESHOLD
       const Index blockingThreshold = EIGEN_JACOBI_SVD_BLOCKING_THRESHOLD;
 #else
-      const Index blockingThreshold = static_cast<Index>(std::sqrt(static_cast<double>(l2CacheSize() / sizeof(float))));
+      const Index blockingThreshold =
+          static_cast<Index>(numext::sqrt(static_cast<double>(l2CacheSize() / sizeof(float))));
 #endif
 
       if (n >= blockingThreshold) {
@@ -783,65 +884,25 @@
         // the blocking code from interfering with the compiler's optimization of
         // the non-blocking scalar sweep below.
         finished = !blocked_sweep(considerAsZero, precision, maxDiagEntry);
-      }
-      // Non-blocking paths: apply rotations individually. The real and complex
-      // paths are kept separate to avoid any codegen impact from the complex
-      // preconditioner on GCC's optimization of the real inner loop.
-      else
-        EIGEN_IF_CONSTEXPR(NumTraits<Scalar>::IsComplex) {
-          // Complex non-blocking sweep: condition each 2x2 block to be real before diagonalizing.
-          for (Index p = 1; p < n; ++p) {
-            for (Index q = 0; q < p; ++q) {
-              RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
-              if (abs(m_workMatrix.coeff(p, q)) > threshold || abs(m_workMatrix.coeff(q, p)) > threshold) {
-                finished = false;
-                if (internal::svd_precondition_2x2_block_to_be_real<MatrixType, Options>::run(m_workMatrix, *this, p, q,
-                                                                                              maxDiagEntry)) {
-                  JacobiRotation<RealScalar> j_left, j_right;
-                  internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);
-                  m_workMatrix.applyOnTheLeft(p, q, j_left);
-                  if (computeU()) m_matrixU.applyOnTheRight(p, q, j_left.transpose());
-                  m_workMatrix.applyOnTheRight(p, q, j_right);
-                  if (computeV()) m_matrixV.applyOnTheRight(p, q, j_right);
-                  maxDiagEntry = numext::maxi<RealScalar>(
-                      maxDiagEntry,
-                      numext::maxi<RealScalar>(abs(m_workMatrix.coeff(p, p)), abs(m_workMatrix.coeff(q, q))));
-                }
-              }
-            }
-          }
-        }
-      else {
-        // Real non-blocking sweep: diagonalize each 2x2 block directly.
-        RealScalar threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
-        for (Index p = 1; p < n; ++p) {
-          for (Index q = 0; q < p; ++q) {
-            if (abs(m_workMatrix.coeff(p, q)) > threshold || abs(m_workMatrix.coeff(q, p)) > threshold) {
-              finished = false;
-              JacobiRotation<RealScalar> j_left, j_right;
-              internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right);
-              m_workMatrix.applyOnTheLeft(p, q, j_left);
-              if (computeU()) m_matrixU.applyOnTheRight(p, q, j_left.transpose());
-              m_workMatrix.applyOnTheRight(p, q, j_right);
-              if (computeV()) m_matrixV.applyOnTheRight(p, q, j_right);
-              maxDiagEntry = numext::maxi<RealScalar>(
-                  maxDiagEntry, numext::maxi<RealScalar>(abs(m_workMatrix.coeff(p, p)), abs(m_workMatrix.coeff(q, q))));
-              threshold = numext::maxi<RealScalar>(considerAsZero, precision * maxDiagEntry);
-            }
-          }
-        }
+        continue;
       }
     }
+    finished = !internal::jacobi_svd_nonblocking_sweep(m_workMatrix, m_matrixU, m_matrixV, computeU(), computeV(),
+                                                       considerAsZero, precision, maxDiagEntry);
   }
 
   /*** step 3. The work matrix is now diagonal, so ensure it's positive so its diagonal entries are the singular values
    * ***/
 
   for (Index i = 0; i < diagSize(); ++i) {
-    // For a complex matrix, some diagonal coefficients might note have been
+    // For a complex matrix, some diagonal coefficients might not have been
     // treated by svd_precondition_2x2_block_to_be_real, and the imaginary part
     // of some diagonal entry might not be null.
-    if (NumTraits<Scalar>::IsComplex && abs(numext::imag(m_workMatrix.coeff(i, i))) > considerAsZero) {
+    bool diagonal_has_imaginary_part = false;
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+      diagonal_has_imaginary_part = abs(numext::imag(m_workMatrix.coeff(i, i))) > considerAsZero;
+    }
+    if (diagonal_has_imaginary_part) {
       RealScalar a = abs(m_workMatrix.coeff(i, i));
       m_singularValues.coeffRef(i) = abs(a);
       if (computeU()) m_matrixU.col(i) *= m_workMatrix.coeff(i, i) / a;
@@ -853,7 +914,7 @@
     }
   }
 
-  m_singularValues *= scale;
+  internal::safe_scaling<RealScalar>::unscale_in_place(m_singularValues, factors);
 
   /*** step 4. Sort singular values in descending order and compute the number of nonzero singular values ***/
 
@@ -910,6 +971,7 @@
   ei_declare_aligned_stack_constructed_variable(Scalar, accumPtr, kBlockBufferSize, 0);
   Map<Matrix<Scalar, kBlockSize + 1, kBlockSize + 1, MatrixOptions>, AlignedMax> accum(accumPtr, kBlockSize + 1,
                                                                                        kBlockSize + 1);
+  Matrix<Scalar, 1, Dynamic, RowMajor, 1, MaxDiagSizeAtCompileTime> Mp_save;
 
   for (Index p = 1; p < n; ++p) {
     Index q = 0;
@@ -950,7 +1012,7 @@
           // Right operations (column scaling) are applied directly since column
           // ops are contiguous in column-major layout.
           bool doRealSvd = true;
-          EIGEN_IF_CONSTEXPR(NumTraits<Scalar>::IsComplex) {
+          EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
             Scalar z;
             // nn = ||(w_pp, w_qp)||_2, the norm of the first column of the 2x2 block.
             RealScalar nn = sqrt(numext::abs2(blockBuffer.coeff(kBlockSize, kBlockSize)) +
@@ -1051,7 +1113,7 @@
           const Scalar l22 = accum(kBlockSize, kBlockSize);
           auto Mq = m_workMatrix.template middleRows<kBlockSize>(q);
           auto Mp = m_workMatrix.row(p);
-          Matrix<Scalar, 1, Dynamic> Mp_save = Mp;
+          Mp_save = Mp;
           Mp.noalias() = l21 * Mq + l22 * Mp_save;
           Mq = L11.template triangularView<Lower>() * Mq + l12 * Mp_save;
         }
@@ -1064,7 +1126,7 @@
         notFinished = true;
 
         bool doRealSvd = true;
-        EIGEN_IF_CONSTEXPR(NumTraits<Scalar>::IsComplex) {
+        EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
           doRealSvd = internal::svd_precondition_2x2_block_to_be_real<MatrixType, Options>::run(m_workMatrix, *this, p,
                                                                                                 q, maxDiagEntry);
         }
diff --git a/Eigen/src/SVD/JacobiSVD_LAPACKE.h b/Eigen/src/SVD/JacobiSVD_LAPACKE.h
index db26366..5d72db2 100644
--- a/Eigen/src/SVD/JacobiSVD_LAPACKE.h
+++ b/Eigen/src/SVD/JacobiSVD_LAPACKE.h
@@ -29,6 +29,7 @@
  *    Singular Value Decomposition - SVD.
  ********************************************************************************
 */
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef EIGEN_JACOBISVD_LAPACKE_H
 #define EIGEN_JACOBISVD_LAPACKE_H
@@ -122,6 +123,10 @@
 EIGEN_LAPACK_SVD_OPTIONS(ComputeThinU | ComputeFullV)
 EIGEN_LAPACK_SVD_OPTIONS(ComputeFullU | ComputeThinV)
 
+#undef EIGEN_LAPACK_SVD_OPTIONS
+
+#undef EIGEN_LAPACKE_SVD
+
 }  // end namespace Eigen
 
 #endif  // EIGEN_JACOBISVD_LAPACKE_H
diff --git a/Eigen/src/SVD/SVDBase.h b/Eigen/src/SVD/SVDBase.h
index c34bf0d..c224c93 100644
--- a/Eigen/src/SVD/SVDBase.h
+++ b/Eigen/src/SVD/SVDBase.h
@@ -12,6 +12,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SVDBASE_H
 #define EIGEN_SVDBASE_H
@@ -58,9 +59,9 @@
 
 template <typename Derived>
 struct traits<SVDBase<Derived> > : traits<Derived> {
-  typedef MatrixXpr XprKind;
-  typedef SolverStorage StorageKind;
-  typedef int StorageIndex;
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
   enum { Flags = 0 };
 };
 
@@ -121,10 +122,10 @@
   template <typename Derived_>
   friend struct internal::solve_assertion;
 
-  typedef typename internal::traits<Derived>::MatrixType MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
-  typedef typename Eigen::internal::traits<SVDBase>::StorageIndex StorageIndex;
+  using MatrixType = typename internal::traits<Derived>::MatrixType;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<typename MatrixType::Scalar>::Real;
+  using StorageIndex = typename Eigen::internal::traits<SVDBase>::StorageIndex;
 
   static constexpr bool ShouldComputeFullU = internal::traits<Derived>::ShouldComputeFullU;
   static constexpr bool ShouldComputeThinU = internal::traits<Derived>::ShouldComputeThinU;
@@ -148,14 +149,14 @@
   EIGEN_STATIC_ASSERT(!(ShouldComputeFullU && ShouldComputeThinU), "SVDBase: Cannot request both full and thin U")
   EIGEN_STATIC_ASSERT(!(ShouldComputeFullV && ShouldComputeThinV), "SVDBase: Cannot request both full and thin V")
 
-  typedef
+  using MatrixUType =
       typename internal::make_proper_matrix_type<Scalar, RowsAtCompileTime, MatrixUColsAtCompileTime, MatrixOptions,
-                                                 MaxRowsAtCompileTime, MatrixUMaxColsAtCompileTime>::type MatrixUType;
-  typedef
+                                                 MaxRowsAtCompileTime, MatrixUMaxColsAtCompileTime>::type;
+  using MatrixVType =
       typename internal::make_proper_matrix_type<Scalar, ColsAtCompileTime, MatrixVColsAtCompileTime, MatrixOptions,
-                                                 MaxColsAtCompileTime, MatrixVMaxColsAtCompileTime>::type MatrixVType;
+                                                 MaxColsAtCompileTime, MatrixVMaxColsAtCompileTime>::type;
 
-  typedef typename internal::plain_diag_type<MatrixType, RealScalar>::type SingularValuesType;
+  using SingularValuesType = typename internal::plain_diag_type<MatrixType, RealScalar>::type;
 
   Derived& derived() { return *static_cast<Derived*>(this); }
   const Derived& derived() const { return *static_cast<const Derived*>(this); }
@@ -230,7 +231,7 @@
    * This is not used for the SVD decomposition itself.
    *
    * When it needs to get the threshold value, Eigen calls threshold().
-   * The default is \c NumTraits<Scalar>::epsilon()
+   * The default is \c NumTraits<Scalar>::epsilon() scaled by the number of singular values, \c max(1,min(rows,cols)).
    *
    * \param threshold The new value to use as the threshold.
    *
@@ -423,10 +424,12 @@
 
   m_diagSize.setValue(numext::mini(m_rows.value(), m_cols.value()));
   m_singularValues.resize(m_diagSize.value());
-  if (RowsAtCompileTime == Dynamic)
+  EIGEN_IF_CONSTEXPR (RowsAtCompileTime == Dynamic) {
     m_matrixU.resize(m_rows.value(), m_computeFullU ? m_rows.value() : m_computeThinU ? m_diagSize.value() : 0);
-  if (ColsAtCompileTime == Dynamic)
+  }
+  EIGEN_IF_CONSTEXPR (ColsAtCompileTime == Dynamic) {
     m_matrixV.resize(m_cols.value(), m_computeFullV ? m_cols.value() : m_computeThinV ? m_diagSize.value() : 0);
+  }
 
   return false;
 }
diff --git a/Eigen/src/SVD/UpperBidiagonalization.h b/Eigen/src/SVD/UpperBidiagonalization.h
index 2cf020e..b50fbc5 100644
--- a/Eigen/src/SVD/UpperBidiagonalization.h
+++ b/Eigen/src/SVD/UpperBidiagonalization.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BIDIAGONALIZATION_H
 #define EIGEN_BIDIAGONALIZATION_H
@@ -23,26 +24,26 @@
 template <typename MatrixType_>
 class UpperBidiagonalization {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum {
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    ColsAtCompileTimeMinusOne = internal::decrement_size<ColsAtCompileTime>::ret
+    ColsAtCompileTimeMinusOne = internal::decrement_size<ColsAtCompileTime>::value
   };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Eigen::Index Index;  ///< \deprecated since Eigen 3.3
-  typedef Matrix<Scalar, 1, ColsAtCompileTime> RowVectorType;
-  typedef Matrix<Scalar, RowsAtCompileTime, 1> ColVectorType;
-  typedef BandMatrix<RealScalar, ColsAtCompileTime, ColsAtCompileTime, 1, 0, RowMajor> BidiagonalType;
-  typedef Matrix<Scalar, ColsAtCompileTime, 1> DiagVectorType;
-  typedef Matrix<Scalar, ColsAtCompileTimeMinusOne, 1> SuperDiagVectorType;
-  typedef HouseholderSequence<
-      const MatrixType, const internal::remove_all_t<typename Diagonal<const MatrixType, 0>::ConjugateReturnType> >
-      HouseholderUSequenceType;
-  typedef HouseholderSequence<const internal::remove_all_t<typename MatrixType::ConjugateReturnType>,
-                              Diagonal<const MatrixType, 1>, OnTheRight>
-      HouseholderVSequenceType;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Index = Eigen::Index;  ///< \deprecated since Eigen 3.3
+  using RowVectorType = Matrix<Scalar, 1, ColsAtCompileTime>;
+  using ColVectorType = Matrix<Scalar, RowsAtCompileTime, 1>;
+  using BidiagonalType = BandMatrix<RealScalar, ColsAtCompileTime, ColsAtCompileTime, 1, 0, RowMajor>;
+  using DiagVectorType = Matrix<Scalar, ColsAtCompileTime, 1>;
+  using SuperDiagVectorType = Matrix<Scalar, ColsAtCompileTimeMinusOne, 1>;
+  using HouseholderUSequenceType =
+      HouseholderSequence<const MatrixType,
+                          const internal::remove_all_t<typename Diagonal<const MatrixType, 0>::ConjugateReturnType>>;
+  using HouseholderVSequenceType =
+      HouseholderSequence<const internal::remove_all_t<typename MatrixType::ConjugateReturnType>,
+                          Diagonal<const MatrixType, 1>, OnTheRight>;
 
   /**
    * \brief Default Constructor.
@@ -50,7 +51,8 @@
    * The default constructor is useful in cases in which the user intends to
    * perform decompositions via Bidiagonalization::compute(const MatrixType&).
    */
-  UpperBidiagonalization() : m_householder(), m_bidiagonal(0, 0), m_isInitialized(false) {}
+  UpperBidiagonalization()
+      : m_householder(), m_bidiagonal(m_householder.cols(), m_householder.cols()), m_isInitialized(false) {}
 
   explicit UpperBidiagonalization(const MatrixType& matrix)
       : m_householder(matrix.rows(), matrix.cols()),
@@ -93,12 +95,12 @@
 void upperbidiagonalization_inplace_unblocked(MatrixType& mat, typename MatrixType::RealScalar* diagonal,
                                               typename MatrixType::RealScalar* upper_diagonal,
                                               typename MatrixType::Scalar* tempData = 0) {
-  typedef typename MatrixType::Scalar Scalar;
+  using Scalar = typename MatrixType::Scalar;
 
   Index rows = mat.rows();
   Index cols = mat.cols();
 
-  typedef Matrix<Scalar, Dynamic, 1, ColMajor, MatrixType::MaxRowsAtCompileTime, 1> TempType;
+  using TempType = Matrix<Scalar, Dynamic, 1, ColMajor, MatrixType::MaxRowsAtCompileTime, 1>;
   TempType tempVector;
   if (tempData == 0) {
     tempVector.resize(rows);
@@ -147,15 +149,15 @@
     MatrixType& A, typename MatrixType::RealScalar* diagonal, typename MatrixType::RealScalar* upper_diagonal, Index bs,
     Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, traits<MatrixType>::Flags & RowMajorBit> > X,
     Ref<Matrix<typename MatrixType::Scalar, Dynamic, Dynamic, traits<MatrixType>::Flags & RowMajorBit> > Y) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename NumTraits<RealScalar>::Literal Literal;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using Literal = typename NumTraits<RealScalar>::Literal;
   static constexpr int StorageOrder = (traits<MatrixType>::Flags & RowMajorBit) ? RowMajor : ColMajor;
-  typedef InnerStride<StorageOrder == ColMajor ? 1 : Dynamic> ColInnerStride;
-  typedef InnerStride<StorageOrder == ColMajor ? Dynamic : 1> RowInnerStride;
-  typedef Ref<Matrix<Scalar, Dynamic, 1>, 0, ColInnerStride> SubColumnType;
-  typedef Ref<Matrix<Scalar, 1, Dynamic>, 0, RowInnerStride> SubRowType;
-  typedef Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder> > SubMatType;
+  using ColInnerStride = InnerStride<StorageOrder == ColMajor ? 1 : Dynamic>;
+  using RowInnerStride = InnerStride<StorageOrder == ColMajor ? Dynamic : 1>;
+  using SubColumnType = Ref<Matrix<Scalar, Dynamic, 1>, 0, ColInnerStride>;
+  using SubRowType = Ref<Matrix<Scalar, 1, Dynamic>, 0, RowInnerStride>;
+  using SubMatType = Ref<Matrix<Scalar, Dynamic, Dynamic, StorageOrder>>;
 
   Index brows = A.rows();
   Index bcols = A.cols();
@@ -171,8 +173,10 @@
 
     // 1 - update the k-th column of A
     SubColumnType v_k = A.col(k).tail(remainingRows);
-    v_k -= V_k1 * Y.row(k).head(k).adjoint();
-    if (k) v_k.noalias() -= X_k1 * A.col(k).head(k);
+    if (k) {
+      v_k.noalias() -= V_k1 * Y.row(k).head(k).adjoint();
+      v_k.noalias() -= X_k1 * A.col(k).head(k);
+    }
 
     // 2 - construct left Householder transform in-place
     v_k.makeHouseholderInPlace(tau_v, diagonal[k]);
@@ -181,7 +185,7 @@
       SubMatType Y_k(Y.block(k + 1, 0, remainingCols, k + 1));
       SubMatType U_k1(A.block(0, k + 1, k, remainingCols));
 
-      // this eases the application of Householder transforAions
+      // this eases the application of Householder transformations
       // A(k,k) will store tau_v later
       A(k, k) = Scalar(1);
 
@@ -204,7 +208,7 @@
       u_k = u_k.conjugate();
       {
         u_k.noalias() -= Y_k * A.row(k).head(k + 1).adjoint();
-        if (k) u_k -= U_k1.adjoint() * X.row(k).head(k).adjoint();
+        if (k) u_k.noalias() -= U_k1.adjoint() * X.row(k).head(k).adjoint();
       }
 
       // 5 - construct right Householder transform in-place
@@ -263,10 +267,10 @@
  * Bidiagonal Form. by Jaeyoung Choi, Jack J. Dongarra, David W. Walker. (1995) section 3.3
  */
 template <typename MatrixType, typename BidiagType>
-void upperbidiagonalization_inplace_blocked(MatrixType& A, BidiagType& bidiagonal, Index maxBlockSize = 32,
+void upperbidiagonalization_inplace_blocked(MatrixType& A, BidiagType& bidiagonal, Index maxBlockSize = 16,
                                             typename MatrixType::Scalar* /*tempData*/ = 0) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef Block<MatrixType, Dynamic, Dynamic> BlockType;
+  using Scalar = typename MatrixType::Scalar;
+  using BlockType = Block<MatrixType, Dynamic, Dynamic>;
 
   Index rows = A.rows();
   Index cols = A.cols();
@@ -311,7 +315,7 @@
     typename MatrixType::RealScalar* upper_diagonal_ptr =
         upper_diagonal.size() > 0 ? &upper_diagonal.coeffRef(k) : nullptr;
 
-    if (k + bs == cols || bcols < 48)  // somewhat arbitrary threshold
+    if (k + bs == cols || bcols < 2 * blockSize)  // fall back to unblocked for small trailing submatrices
     {
       upperbidiagonalization_inplace_unblocked(B, &(bidiagonal.template diagonal<0>().coeffRef(k)), upper_diagonal_ptr,
                                                X.data());
diff --git a/Eigen/src/SparseCholesky/InternalHeaderCheck.h b/Eigen/src/SparseCholesky/InternalHeaderCheck.h
index f8d8762..39ecbde 100644
--- a/Eigen/src/SparseCholesky/InternalHeaderCheck.h
+++ b/Eigen/src/SparseCholesky/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SPARSECHOLESKY_MODULE_H
 #error "Please include Eigen/SparseCholesky instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SparseCholesky/SimplicialCholesky.h b/Eigen/src/SparseCholesky/SimplicialCholesky.h
index 997bc22..92e751b 100644
--- a/Eigen/src/SparseCholesky/SimplicialCholesky.h
+++ b/Eigen/src/SparseCholesky/SimplicialCholesky.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SIMPLICIAL_CHOLESKY_H
 #define EIGEN_SIMPLICIAL_CHOLESKY_H
@@ -20,7 +21,7 @@
 namespace internal {
 template <typename CholMatrixType, typename InputMatrixType>
 struct simplicial_cholesky_grab_input {
-  typedef CholMatrixType const* ConstCholMatrixPtr;
+  using ConstCholMatrixPtr = const CholMatrixType*;
   static void run(const InputMatrixType& input, ConstCholMatrixPtr& pmat, CholMatrixType& tmp) {
     tmp = input;
     pmat = &tmp;
@@ -29,9 +30,40 @@
 
 template <typename MatrixType>
 struct simplicial_cholesky_grab_input<MatrixType, MatrixType> {
-  typedef MatrixType const* ConstMatrixPtr;
+  using ConstMatrixPtr = const MatrixType*;
   static void run(const MatrixType& input, ConstMatrixPtr& pmat, MatrixType& /*tmp*/) { pmat = &input; }
 };
+
+// Compute a fill-reducing permutation for SimplicialCholesky. The generic path
+// builds the full Scalar-valued symmetric matrix that the user's OrderingType
+// expects. The AMDOrdering specialization below skips that copy: AMD reads
+// only the sparsity pattern, so we can hand it a SparseSelfAdjointView<UpLo>
+// whose pattern-only overload materializes the underlying triangle as
+// SparseMatrix<signed char> and expands once.
+template <bool UseAMDFastPath>
+struct simplicial_cholesky_amd_dispatch {
+  template <int UpLo_, bool NonHermitian, typename Ordering, typename MatrixType, typename CholMatrixType,
+            typename Perm>
+  static void run(const MatrixType& a, CholMatrixType& C, Perm& perm) {
+    permute_symm_to_fullsymm<UpLo_, NonHermitian>(a, C, nullptr);
+    Ordering ordering;
+    ordering(C, perm);
+  }
+};
+
+template <>
+struct simplicial_cholesky_amd_dispatch<true> {
+  template <int UpLo_, bool /*NonHermitian*/, typename Ordering, typename MatrixType, typename CholMatrixType,
+            typename Perm>
+  static void run(const MatrixType& a, CholMatrixType& /*C*/, Perm& perm) {
+    // Pattern-only: works for both Hermitian and NonHermitian variants because
+    // AMD's selfadjointView overload never reads scalar values, so the
+    // selfadjoint-vs-symmetric distinction (which only affects value
+    // expansion) is irrelevant.
+    Ordering ordering;
+    ordering(a.template selfadjointView<UpLo_>(), perm);
+  }
+};
 }  // end namespace internal
 
 /** \ingroup SparseCholesky_Module
@@ -49,21 +81,21 @@
  */
 template <typename Derived>
 class SimplicialCholeskyBase : public SparseSolverBase<Derived> {
-  typedef SparseSolverBase<Derived> Base;
+  using Base = SparseSolverBase<Derived>;
   using Base::m_isInitialized;
 
  public:
-  typedef typename internal::traits<Derived>::MatrixType MatrixType;
-  typedef typename internal::traits<Derived>::OrderingType OrderingType;
+  using MatrixType = typename internal::traits<Derived>::MatrixType;
+  using OrderingType = typename internal::traits<Derived>::OrderingType;
   enum { UpLo = internal::traits<Derived>::UpLo };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename internal::traits<Derived>::DiagonalScalar DiagonalScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef CholMatrixType const* ConstCholMatrixPtr;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using DiagonalScalar = typename internal::traits<Derived>::DiagonalScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using ConstCholMatrixPtr = const CholMatrixType*;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
 
   enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };
 
@@ -79,8 +111,6 @@
     derived().compute(matrix);
   }
 
-  ~SimplicialCholeskyBase() {}
-
   Derived& derived() { return *static_cast<Derived*>(this); }
   const Derived& derived() const { return *static_cast<const Derived*>(this); }
 
@@ -90,7 +120,7 @@
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears to be negative.
+   *          \c NumericalIssue if the matrix appears to be negative.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
@@ -210,6 +240,8 @@
 
   template <bool DoLDLT, bool NonHermitian>
   void factorize_preordered(const CholMatrixType& a);
+  template <bool DoLDLT, bool NonHermitian, bool UsePackets>
+  void factorize_preordered_impl(const CholMatrixType& a);
 
   template <bool DoLDLT, bool NonHermitian>
   void analyzePattern(const MatrixType& a) {
@@ -234,6 +266,8 @@
   };
 
   mutable ComputationInfo m_info;
+  // Set once factorize() has run, success or not: factorize_preordered() breaks out on a bad pivot, leaving
+  // the tails of m_diag and of m_matrix's diagonal unwritten. Readers of those also need m_info == Success.
   bool m_factorizationIsOk;
   bool m_analysisIsOk;
 
@@ -268,15 +302,15 @@
 
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 struct traits<SimplicialLLT<MatrixType_, UpLo_, Ordering_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Ordering_ OrderingType;
+  using MatrixType = MatrixType_;
+  using OrderingType = Ordering_;
   enum { UpLo = UpLo_ };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar DiagonalScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef TriangularView<const CholMatrixType, Eigen::Lower> MatrixL;
-  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::Upper> MatrixU;
+  using Scalar = typename MatrixType::Scalar;
+  using DiagonalScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using MatrixL = TriangularView<const CholMatrixType, Eigen::Lower>;
+  using MatrixU = TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::Upper>;
   static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
   static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.adjoint()); }
   static inline DiagonalScalar getDiag(Scalar x) { return numext::real(x); }
@@ -285,15 +319,15 @@
 
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 struct traits<SimplicialLDLT<MatrixType_, UpLo_, Ordering_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Ordering_ OrderingType;
+  using MatrixType = MatrixType_;
+  using OrderingType = Ordering_;
   enum { UpLo = UpLo_ };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar DiagonalScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef TriangularView<const CholMatrixType, Eigen::UnitLower> MatrixL;
-  typedef TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::UnitUpper> MatrixU;
+  using Scalar = typename MatrixType::Scalar;
+  using DiagonalScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using MatrixL = TriangularView<const CholMatrixType, Eigen::UnitLower>;
+  using MatrixU = TriangularView<const typename CholMatrixType::AdjointReturnType, Eigen::UnitUpper>;
   static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
   static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.adjoint()); }
   static inline DiagonalScalar getDiag(Scalar x) { return numext::real(x); }
@@ -302,15 +336,15 @@
 
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 struct traits<SimplicialNonHermitianLLT<MatrixType_, UpLo_, Ordering_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Ordering_ OrderingType;
+  using MatrixType = MatrixType_;
+  using OrderingType = Ordering_;
   enum { UpLo = UpLo_ };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::Scalar DiagonalScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef TriangularView<const CholMatrixType, Eigen::Lower> MatrixL;
-  typedef TriangularView<const typename CholMatrixType::ConstTransposeReturnType, Eigen::Upper> MatrixU;
+  using Scalar = typename MatrixType::Scalar;
+  using DiagonalScalar = typename MatrixType::Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using MatrixL = TriangularView<const CholMatrixType, Eigen::Lower>;
+  using MatrixU = TriangularView<const typename CholMatrixType::ConstTransposeReturnType, Eigen::Upper>;
   static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
   static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.transpose()); }
   static inline DiagonalScalar getDiag(Scalar x) { return x; }
@@ -319,15 +353,15 @@
 
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 struct traits<SimplicialNonHermitianLDLT<MatrixType_, UpLo_, Ordering_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Ordering_ OrderingType;
+  using MatrixType = MatrixType_;
+  using OrderingType = Ordering_;
   enum { UpLo = UpLo_ };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::Scalar DiagonalScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef TriangularView<const CholMatrixType, Eigen::UnitLower> MatrixL;
-  typedef TriangularView<const typename CholMatrixType::ConstTransposeReturnType, Eigen::UnitUpper> MatrixU;
+  using Scalar = typename MatrixType::Scalar;
+  using DiagonalScalar = typename MatrixType::Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using MatrixL = TriangularView<const CholMatrixType, Eigen::UnitLower>;
+  using MatrixU = TriangularView<const typename CholMatrixType::ConstTransposeReturnType, Eigen::UnitUpper>;
   static inline MatrixL getL(const CholMatrixType& m) { return MatrixL(m); }
   static inline MatrixU getU(const CholMatrixType& m) { return MatrixU(m.transpose()); }
   static inline DiagonalScalar getDiag(Scalar x) { return x; }
@@ -336,11 +370,11 @@
 
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 struct traits<SimplicialCholesky<MatrixType_, UpLo_, Ordering_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Ordering_ OrderingType;
+  using MatrixType = MatrixType_;
+  using OrderingType = Ordering_;
   enum { UpLo = UpLo_ };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar DiagonalScalar;
+  using Scalar = typename MatrixType::Scalar;
+  using DiagonalScalar = typename MatrixType::RealScalar;
   static inline DiagonalScalar getDiag(Scalar x) { return numext::real(x); }
   static inline Scalar getSymm(Scalar x) { return numext::conj(x); }
 };
@@ -370,17 +404,17 @@
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 class SimplicialLLT : public SimplicialCholeskyBase<SimplicialLLT<MatrixType_, UpLo_, Ordering_> > {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum { UpLo = UpLo_ };
-  typedef SimplicialCholeskyBase<SimplicialLLT> Base;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, Index> CholMatrixType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef internal::traits<SimplicialLLT> Traits;
-  typedef typename Traits::MatrixL MatrixL;
-  typedef typename Traits::MatrixU MatrixU;
+  using Base = SimplicialCholeskyBase<SimplicialLLT>;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, Index>;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using Traits = internal::traits<SimplicialLLT>;
+  using MatrixL = typename Traits::MatrixL;
+  using MatrixU = typename Traits::MatrixU;
 
  public:
   /** Default constructor */
@@ -425,9 +459,40 @@
 
   /** \returns the determinant of the underlying matrix from the current factorization */
   Scalar determinant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
     Scalar detL = Base::m_matrix.diagonal().prod();
     return numext::abs2(detL);
   }
+
+  /** \returns the absolute value of the determinant of the underlying matrix from the current factorization */
+  RealScalar absDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
+    return numext::abs2(Base::m_matrix.diagonal().prod());
+  }
+
+  /** \returns the natural log of the absolute value of the determinant of the underlying matrix from the current
+   * factorization.
+   *
+   * Unlike determinant(), this stays finite for the large factorizations where a determinant overflows or underflows.
+   */
+  RealScalar logAbsDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
+    return RealScalar(2) * Base::m_matrix.diagonal().cwiseAbs().array().log().sum();
+  }
+
+  /** \returns the sign of the determinant of the underlying matrix, which is \c 1 since that matrix is positive
+   * definite.
+   *
+   * This method is provided for compatibility with the other decompositions, thus enabling generic code.
+   */
+  Scalar signDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
+    return Scalar(1);
+  }
 };
 
 /** \ingroup SparseCholesky_Module
@@ -453,17 +518,17 @@
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 class SimplicialLDLT : public SimplicialCholeskyBase<SimplicialLDLT<MatrixType_, UpLo_, Ordering_> > {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum { UpLo = UpLo_ };
-  typedef SimplicialCholeskyBase<SimplicialLDLT> Base;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef internal::traits<SimplicialLDLT> Traits;
-  typedef typename Traits::MatrixL MatrixL;
-  typedef typename Traits::MatrixU MatrixU;
+  using Base = SimplicialCholeskyBase<SimplicialLDLT>;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using Traits = internal::traits<SimplicialLDLT>;
+  using MatrixL = typename Traits::MatrixL;
+  using MatrixU = typename Traits::MatrixU;
 
  public:
   /** Default constructor */
@@ -513,7 +578,36 @@
   void factorize(const MatrixType& a) { Base::template factorize<true, false>(a); }
 
   /** \returns the determinant of the underlying matrix from the current factorization */
-  Scalar determinant() const { return Base::m_diag.prod(); }
+  Scalar determinant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return Base::m_diag.prod();
+  }
+
+  /** \returns the absolute value of the determinant of the underlying matrix from the current factorization */
+  RealScalar absDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return numext::abs(Base::m_diag.real().prod());
+  }
+
+  /** \returns the natural log of the absolute value of the determinant of the underlying matrix from the current
+   * factorization.
+   *
+   * Unlike determinant(), this stays finite for the large factorizations where a determinant overflows or underflows.
+   */
+  RealScalar logAbsDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return Base::m_diag.real().cwiseAbs().array().log().sum();
+  }
+
+  /** \returns the sign of the determinant of the underlying matrix from the current factorization */
+  Scalar signDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return Scalar(Base::m_diag.real().array().sign().prod());
+  }
 };
 
 /** \ingroup SparseCholesky_Module
@@ -540,17 +634,17 @@
 class SimplicialNonHermitianLLT
     : public SimplicialCholeskyBase<SimplicialNonHermitianLLT<MatrixType_, UpLo_, Ordering_> > {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum { UpLo = UpLo_ };
-  typedef SimplicialCholeskyBase<SimplicialNonHermitianLLT> Base;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef internal::traits<SimplicialNonHermitianLLT> Traits;
-  typedef typename Traits::MatrixL MatrixL;
-  typedef typename Traits::MatrixU MatrixU;
+  using Base = SimplicialCholeskyBase<SimplicialNonHermitianLLT>;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using Traits = internal::traits<SimplicialNonHermitianLLT>;
+  using MatrixL = typename Traits::MatrixL;
+  using MatrixU = typename Traits::MatrixU;
 
  public:
   /** Default constructor */
@@ -596,9 +690,37 @@
 
   /** \returns the determinant of the underlying matrix from the current factorization */
   Scalar determinant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
     Scalar detL = Base::m_matrix.diagonal().prod();
     return detL * detL;
   }
+
+  /** \returns the absolute value of the determinant of the underlying matrix from the current factorization */
+  RealScalar absDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
+    return numext::abs2(Base::m_matrix.diagonal().prod());
+  }
+
+  /** \returns the natural log of the absolute value of the determinant of the underlying matrix from the current
+   * factorization.
+   *
+   * Unlike determinant(), this stays finite for the large factorizations where a determinant overflows or underflows.
+   */
+  RealScalar logAbsDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
+    return RealScalar(2) * Base::m_matrix.diagonal().cwiseAbs().array().log().sum();
+  }
+
+  /** \returns the sign of the determinant of the underlying matrix from the current factorization */
+  Scalar signDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LLT is not factorized, or its factorization failed");
+    Scalar signL = Base::m_matrix.diagonal().array().sign().prod();
+    return signL * signL;
+  }
 };
 
 /** \ingroup SparseCholesky_Module
@@ -625,17 +747,17 @@
 class SimplicialNonHermitianLDLT
     : public SimplicialCholeskyBase<SimplicialNonHermitianLDLT<MatrixType_, UpLo_, Ordering_> > {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum { UpLo = UpLo_ };
-  typedef SimplicialCholeskyBase<SimplicialNonHermitianLDLT> Base;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef internal::traits<SimplicialNonHermitianLDLT> Traits;
-  typedef typename Traits::MatrixL MatrixL;
-  typedef typename Traits::MatrixU MatrixU;
+  using Base = SimplicialCholeskyBase<SimplicialNonHermitianLDLT>;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using Traits = internal::traits<SimplicialNonHermitianLDLT>;
+  using MatrixL = typename Traits::MatrixL;
+  using MatrixU = typename Traits::MatrixU;
 
  public:
   /** Default constructor */
@@ -685,7 +807,36 @@
   void factorize(const MatrixType& a) { Base::template factorize<true, true>(a); }
 
   /** \returns the determinant of the underlying matrix from the current factorization */
-  Scalar determinant() const { return Base::m_diag.prod(); }
+  Scalar determinant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return Base::m_diag.prod();
+  }
+
+  /** \returns the absolute value of the determinant of the underlying matrix from the current factorization */
+  RealScalar absDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return numext::abs(Base::m_diag.prod());
+  }
+
+  /** \returns the natural log of the absolute value of the determinant of the underlying matrix from the current
+   * factorization.
+   *
+   * Unlike determinant(), this stays finite for the large factorizations where a determinant overflows or underflows.
+   */
+  RealScalar logAbsDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return Base::m_diag.cwiseAbs().array().log().sum();
+  }
+
+  /** \returns the sign of the determinant of the underlying matrix from the current factorization */
+  Scalar signDeterminant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial LDLT is not factorized, or its factorization failed");
+    return Base::m_diag.array().sign().prod();
+  }
 };
 
 /** \deprecated use SimplicialLDLT or class SimplicialLLT
@@ -697,16 +848,16 @@
 template <typename MatrixType_, int UpLo_, typename Ordering_>
 class SimplicialCholesky : public SimplicialCholeskyBase<SimplicialCholesky<MatrixType_, UpLo_, Ordering_> > {
  public:
-  typedef MatrixType_ MatrixType;
+  using MatrixType = MatrixType_;
   enum { UpLo = UpLo_ };
-  typedef SimplicialCholeskyBase<SimplicialCholesky> Base;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> CholMatrixType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef internal::traits<SimplicialLDLT<MatrixType, UpLo> > LDLTTraits;
-  typedef internal::traits<SimplicialLLT<MatrixType, UpLo> > LLTTraits;
+  using Base = SimplicialCholeskyBase<SimplicialCholesky>;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using CholMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using LDLTTraits = internal::traits<SimplicialLDLT<MatrixType, UpLo>>;
+  using LLTTraits = internal::traits<SimplicialLLT<MatrixType, UpLo>>;
 
  public:
   SimplicialCholesky() : Base(), m_LDLT(true) {}
@@ -798,7 +949,7 @@
 
     if (Base::m_diag.size() > 0) dest = Base::m_diag.real().asDiagonal().inverse() * dest;
 
-    if (Base::m_matrix.nonZeros() > 0)  // otherwise I==I
+    if (Base::m_matrix.nonZeros() > 0)  // otherwise U==I
     {
       if (m_LDLT)
         LDLTTraits::getU(Base::m_matrix).solveInPlace(dest);
@@ -816,6 +967,8 @@
   }
 
   Scalar determinant() const {
+    eigen_assert(Base::m_factorizationIsOk && Base::m_info == Success &&
+                 "Simplicial Cholesky is not factorized, or its factorization failed");
     if (m_LDLT) {
       return Base::m_diag.prod();
     } else {
@@ -835,13 +988,12 @@
   const Index size = a.rows();
   pmat = &ap;
   // Note that ordering methods compute the inverse permutation
-  if (!internal::is_same<OrderingType, NaturalOrdering<StorageIndex> >::value) {
+  EIGEN_IF_CONSTEXPR ((!std::is_same<OrderingType, NaturalOrdering<StorageIndex> >::value)) {
     {
       CholMatrixType C;
-      internal::permute_symm_to_fullsymm<UpLo, NonHermitian>(a, C, NULL);
-
-      OrderingType ordering;
-      ordering(C, m_Pinv);
+      constexpr bool kUseAMDFastPath = std::is_same<OrderingType, AMDOrdering<StorageIndex> >::value;
+      internal::simplicial_cholesky_amd_dispatch<kUseAMDFastPath>::template run<UpLo, NonHermitian, OrderingType>(
+          a, C, m_Pinv);
     }
 
     if (m_Pinv.size() > 0)
@@ -854,10 +1006,10 @@
   } else {
     m_Pinv.resize(0);
     m_P.resize(0);
-    if (int(UpLo) == int(Lower) || MatrixType::IsRowMajor) {
-      // we have to transpose the lower part to to the upper one
+    EIGEN_IF_CONSTEXPR (int(UpLo) == int(Lower) || MatrixType::IsRowMajor) {
+      // we have to transpose the lower part to the upper one
       ap.resize(size, size);
-      internal::permute_symm_to_symm<UpLo, Upper, NonHermitian>(a, ap, NULL);
+      internal::permute_symm_to_symm<UpLo, Upper, NonHermitian>(a, ap, nullptr);
     } else
       internal::simplicial_cholesky_grab_input<CholMatrixType, MatrixType>::run(a, pmat, ap);
   }
diff --git a/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h b/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
index 97f2142..85d363b 100644
--- a/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
+++ b/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 NOTE: these functions have been adapted from the LDL library:
@@ -240,7 +241,7 @@
     }
   }
 
-  // Finalizes the non zero pattern of the L factor and allocates the memory for the factorization.
+  // Finalizes the non-zero pattern of the L factor and allocates the memory for the factorization.
   static void init_matrix(const StorageIndex size, const StorageIndex* nonZerosPerCol, CholMatrixType& L) {
     eigen_assert(L.outerIndexPtr()[0] == 0);
     std::partial_sum(nonZerosPerCol, nonZerosPerCol + size, L.outerIndexPtr() + 1);
@@ -274,9 +275,12 @@
   }
 };
 
-// Symbol is ODR-used, so we need a definition.
+// Required pre-C++17 for ODR; redundant and deprecated since (C++17 makes
+// constexpr static data members implicitly inline).
+#if EIGEN_COMP_CXXVER < 17
 template <typename Scalar, typename StorageIndex>
 constexpr StorageIndex simpl_chol_helper<Scalar, StorageIndex>::kEmpty;
+#endif
 
 }  // namespace internal
 
@@ -298,6 +302,23 @@
 template <typename Derived>
 template <bool DoLDLT, bool NonHermitian>
 void SimplicialCholeskyBase<Derived>::factorize_preordered(const CholMatrixType& ap) {
+  EIGEN_IF_CONSTEXPR (internal::packet_traits<Scalar>::Vectorizable && internal::packet_traits<Scalar>::HasMul &&
+                      internal::packet_traits<Scalar>::HasSub && !NumTraits<Scalar>::IsComplex) {
+    const StorageIndex* outer = m_matrix.outerIndexPtr();
+    for (Index i = 0; i < m_matrix.cols(); ++i) {
+      // Exclude the diagonal (LLT) and the entry appended after the last update.
+      if (outer[i + 1] - outer[i] > internal::kSparseScatterPacketMinSize + (DoLDLT ? 0 : 1)) {
+        factorize_preordered_impl<DoLDLT, NonHermitian, true>(ap);
+        return;
+      }
+    }
+  }
+  factorize_preordered_impl<DoLDLT, NonHermitian, false>(ap);
+}
+
+template <typename Derived>
+template <bool DoLDLT, bool NonHermitian, bool UsePackets>
+void SimplicialCholeskyBase<Derived>::factorize_preordered_impl(const CholMatrixType& ap) {
   using std::sqrt;
   const StorageIndex size = StorageIndex(ap.rows());
 
@@ -349,20 +370,22 @@
 
       /* the nonzero entry L(k,i) */
       Scalar l_ki;
-      if (DoLDLT)
+      EIGEN_IF_CONSTEXPR (DoLDLT)
         l_ki = yi / getDiag(m_diag[i]);
       else
         yi = l_ki = yi / Lx[Lp[i]];
 
       Index p2 = Lp[i] + nonZerosPerCol[i];
-      Index p;
-      for (p = Lp[i] + (DoLDLT ? 0 : 1); p < p2; ++p) y[Li[p]] -= getSymm(Lx[p]) * yi;
+      Index p = Lp[i] + (DoLDLT ? 0 : 1);
+      EIGEN_IF_CONSTEXPR (UsePackets)
+        p += internal::sparse_scatter_sub_packets<!NonHermitian>(y, Li + p, Lx + p, p2 - p, yi);
+      for (; p < p2; ++p) y[Li[p]] -= getSymm(Lx[p]) * yi;
       d -= getDiag(l_ki * getSymm(yi));
       Li[p] = k; /* store L(k,i) in column form of L */
       Lx[p] = l_ki;
       ++nonZerosPerCol[i]; /* increment count of nonzeros in col i */
     }
-    if (DoLDLT) {
+    EIGEN_IF_CONSTEXPR (DoLDLT) {
       m_diag[k] = d;
       if (d == RealScalar(0)) {
         ok = false; /* failure, D(k,k) is zero */
@@ -371,7 +394,13 @@
     } else {
       Index p = Lp[k] + nonZerosPerCol[k]++;
       Li[p] = k; /* store L(k,k) = sqrt (d) in column k */
-      if (NonHermitian ? d == RealScalar(0) : numext::real(d) <= RealScalar(0)) {
+      bool failed;
+      EIGEN_IF_CONSTEXPR (NonHermitian) {
+        failed = d == RealScalar(0);
+      } else {
+        failed = numext::real(d) <= RealScalar(0);
+      }
+      if (failed) {
         ok = false; /* failure, matrix is not positive definite */
         break;
       }
diff --git a/Eigen/src/SparseCore/AmbiVector.h b/Eigen/src/SparseCore/AmbiVector.h
index 4af6f88..f91bd8a 100644
--- a/Eigen/src/SparseCore/AmbiVector.h
+++ b/Eigen/src/SparseCore/AmbiVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_AMBIVECTOR_H
 #define EIGEN_AMBIVECTOR_H
@@ -25,12 +26,18 @@
 template <typename Scalar_, typename StorageIndex_>
 class AmbiVector {
  public:
-  typedef Scalar_ Scalar;
-  typedef StorageIndex_ StorageIndex;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
 
   explicit AmbiVector(Index size)
-      : m_buffer(0), m_zero(0), m_size(0), m_end(0), m_allocatedSize(0), m_allocatedElements(0), m_mode(-1) {
+      : m_buffer(0),
+        m_zero(0),
+        m_size(0),
+        m_end(0),
+        m_allocatedSize(0),
+        m_allocatedElements(0),
+        m_denseConstructed(0),
+        m_mode(-1) {
     resize(size);
   }
 
@@ -53,45 +60,22 @@
 
   class Iterator;
 
-  ~AmbiVector() { delete[] m_buffer; }
+  ~AmbiVector() {
+    destructElements();
+    internal::aligned_free(m_buffer);
+  }
 
   void resize(Index size) {
     if (m_allocatedSize < size) reallocate(size);
     m_size = convert_index(size);
-  }
-
-  StorageIndex size() const { return m_size; }
-
- protected:
-  StorageIndex convert_index(Index idx) { return internal::convert_index<StorageIndex>(idx); }
-
-  void reallocate(Index size) {
-    // if the size of the matrix is not too large, let's allocate a bit more than needed such
-    // that we can handle dense vector even in sparse mode.
-    delete[] m_buffer;
-    if (size < 1000) {
-      Index allocSize = (size * sizeof(ListEl) + sizeof(Scalar) - 1) / sizeof(Scalar);
-      m_allocatedElements = convert_index((allocSize * sizeof(Scalar)) / sizeof(ListEl));
-      m_buffer = new Scalar[allocSize];
-    } else {
-      m_allocatedElements = convert_index((size * sizeof(Scalar)) / sizeof(ListEl));
-      m_buffer = new Scalar[size];
-    }
-    m_size = convert_index(size);
+    // The bounds describe a sub-vector of the old size, so they cannot survive a
+    // resize that reuses the allocation: a smaller one would leave the iterators
+    // running past the end, a larger one would stop them short of it.
     m_start = 0;
     m_end = m_size;
   }
 
-  void reallocateSparse() {
-    Index copyElements = m_allocatedElements;
-    m_allocatedElements = (std::min)(StorageIndex(m_allocatedElements * 1.5), m_size);
-    Index allocSize = m_allocatedElements * sizeof(ListEl);
-    allocSize = (allocSize + sizeof(Scalar) - 1) / sizeof(Scalar);
-    Scalar* newBuffer = new Scalar[allocSize];
-    std::memcpy(newBuffer, m_buffer, copyElements * sizeof(ListEl));
-    delete[] m_buffer;
-    m_buffer = newBuffer;
-  }
+  StorageIndex size() const { return m_size; }
 
  protected:
   // element type of the linked list
@@ -101,7 +85,72 @@
     Scalar value;
   };
 
-  // used to store data in both mode
+  StorageIndex convert_index(Index idx) { return internal::convert_index<StorageIndex>(idx); }
+
+  ListEl* listElements() { return static_cast<ListEl*>(static_cast<void*>(m_buffer)); }
+  const ListEl* listElements() const { return static_cast<const ListEl*>(static_cast<const void*>(m_buffer)); }
+
+  void reallocate(Index size) {
+    // if the size of the matrix is not too large, let's allocate a bit more than needed such
+    // that we can handle dense vector even in sparse mode.
+    destructElements();
+    internal::aligned_free(m_buffer);
+    Index allocSize;
+    if (size < 1000) {
+      allocSize = numext::div_ceil<Index>(size * sizeof(ListEl), sizeof(Scalar));
+      m_allocatedElements = convert_index((allocSize * sizeof(Scalar)) / sizeof(ListEl));
+    } else {
+      allocSize = size;
+      m_allocatedElements = convert_index((size * sizeof(Scalar)) / sizeof(ListEl));
+    }
+    // The buffer is raw storage: init() constructs the elements the mode needs.
+    m_buffer = static_cast<Scalar*>(internal::aligned_malloc(allocSize * sizeof(Scalar)));
+    m_allocatedSize = convert_index(allocSize);
+    m_mode = -1;
+  }
+
+  void reallocateSparse() {
+    Index copyElements = m_llSize;
+    StorageIndex newAllocatedElements = (std::min)(StorageIndex(m_allocatedElements * 1.5), m_size);
+    Index allocSize = newAllocatedElements * sizeof(ListEl);
+    allocSize = numext::div_ceil<Index>(allocSize, sizeof(Scalar));
+    Scalar* newBuffer = static_cast<Scalar*>(internal::aligned_malloc(allocSize * sizeof(Scalar)));
+    ListEl* newElements = static_cast<ListEl*>(static_cast<void*>(newBuffer));
+    // A throwing move leaves the nodes where they are, so the vector stays
+    // destructible; the new buffer, which nothing points to yet, must be
+    // released, and the capacity must not describe it either.
+    EIGEN_TRY { internal::move_construct_elements_of_array(newElements, listElements(), copyElements); }
+    EIGEN_CATCH(...) {
+      internal::aligned_free(newBuffer);
+      EIGEN_THROW;
+    }
+    internal::destruct_elements_of_array(listElements(), copyElements);
+    internal::aligned_free(m_buffer);
+    m_buffer = newBuffer;
+    m_allocatedElements = newAllocatedElements;
+    m_allocatedSize = convert_index(allocSize);
+  }
+
+  // Constructs a node holding a zero coefficient. Initializing the coefficient
+  // as part of the construction keeps it atomic: a throwing Scalar leaves no
+  // ListEl behind, so the caller can commit the node to the list - and to
+  // m_llSize, which is what destructElements() destroys - only once it exists.
+  static ListEl* constructListEl(ListEl* dst, StorageIndex index, StorageIndex next) {
+    return ::new (static_cast<void*>(dst)) ListEl{next, index, Scalar(0)};
+  }
+
+  // Destroy whatever elements are currently alive in the raw buffer.
+  void destructElements() {
+    if (m_mode == IsDense) {
+      internal::destruct_elements_of_array(m_buffer, m_denseConstructed);
+      m_denseConstructed = 0;
+    } else if (m_mode == IsSparse) {
+      internal::destruct_elements_of_array(listElements(), m_llSize);
+      m_llSize = 0;
+    }
+  }
+
+  // used to store data in both modes
   Scalar* m_buffer;
   Scalar m_zero;
   StorageIndex m_size;
@@ -109,6 +158,7 @@
   StorageIndex m_end;
   StorageIndex m_allocatedSize;
   StorageIndex m_allocatedElements;
+  StorageIndex m_denseConstructed;  // number of live Scalar objects in dense mode
   StorageIndex m_mode;
 
   // linked list mode
@@ -136,7 +186,19 @@
 
 template <typename Scalar_, typename StorageIndex_>
 void AmbiVector<Scalar_, StorageIndex_>::init(int mode) {
-  m_mode = mode;
+  if (mode != m_mode) {
+    destructElements();
+    m_mode = convert_index(mode);
+  } else if (m_mode == IsSparse) {
+    // Re-initializing in sparse mode discards the previous list.
+    internal::destruct_elements_of_array(listElements(), m_llSize);
+  }
+  if (m_mode == IsDense && m_denseConstructed < m_size) {
+    // Construct the dense coefficients this mode reads and writes; they stay
+    // alive across subsequent dense inits, like the values they carry.
+    internal::default_construct_elements_of_array(m_buffer + m_denseConstructed, m_size - m_denseConstructed);
+    m_denseConstructed = m_size;
+  }
   // This is only necessary in sparse mode, but we set these unconditionally to avoid some maybe-uninitialized warnings
   // if (m_mode==IsSparse)
   {
@@ -162,6 +224,9 @@
     for (Index i = m_start; i < m_end; ++i) m_buffer[i] = Scalar(0);
   } else {
     eigen_assert(m_mode == IsSparse);
+    // The nodes being dropped own their coefficients, and a later coeffRef()
+    // constructs its node in place over this storage.
+    internal::destruct_elements_of_array(listElements(), m_llSize);
     m_llSize = 0;
     m_llStart = -1;
   }
@@ -172,27 +237,22 @@
   if (m_mode == IsDense)
     return m_buffer[i];
   else {
-    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    ListEl* EIGEN_RESTRICT llElements = listElements();
     // TODO: factor out the following code to reduce code generation
     eigen_assert(m_mode == IsSparse);
     if (m_llSize == 0) {
       // this is the first element
+      ListEl& el = *constructListEl(llElements, convert_index(i), -1);
       m_llStart = 0;
       m_llCurrent = 0;
-      ++m_llSize;
-      llElements[0].value = Scalar(0);
-      llElements[0].index = convert_index(i);
-      llElements[0].next = -1;
-      return llElements[0].value;
+      m_llSize = 1;
+      return el.value;
     } else if (i < llElements[m_llStart].index) {
       // this is going to be the new first element of the list
-      ListEl& el = llElements[m_llSize];
-      el.value = Scalar(0);
-      el.index = convert_index(i);
-      el.next = m_llStart;
+      ListEl& el = *constructListEl(llElements + m_llSize, convert_index(i), m_llStart);
       m_llStart = m_llSize;
-      ++m_llSize;
       m_llCurrent = m_llStart;
+      ++m_llSize;
       return el.value;
     } else {
       StorageIndex nextel = llElements[m_llCurrent].next;
@@ -209,14 +269,11 @@
       } else {
         if (m_llSize >= m_allocatedElements) {
           reallocateSparse();
-          llElements = reinterpret_cast<ListEl*>(m_buffer);
+          llElements = listElements();
         }
         eigen_internal_assert(m_llSize < m_allocatedElements && "internal error: overflow in sparse mode");
         // let's insert a new coefficient
-        ListEl& el = llElements[m_llSize];
-        el.value = Scalar(0);
-        el.index = convert_index(i);
-        el.next = llElements[m_llCurrent].next;
+        ListEl& el = *constructListEl(llElements + m_llSize, convert_index(i), llElements[m_llCurrent].next);
         llElements[m_llCurrent].next = m_llSize;
         ++m_llSize;
         return el.value;
@@ -230,7 +287,7 @@
   if (m_mode == IsDense)
     return m_buffer[i];
   else {
-    ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer);
+    ListEl* EIGEN_RESTRICT llElements = listElements();
     eigen_assert(m_mode == IsSparse);
     if ((m_llSize == 0) || (i < llElements[m_llStart].index)) {
       return m_zero;
@@ -238,8 +295,8 @@
       Index elid = m_llStart;
       while (elid >= 0 && llElements[elid].index < i) elid = llElements[elid].next;
 
-      if (llElements[elid].index == i)
-        return llElements[m_llCurrent].value;
+      if (elid >= 0 && llElements[elid].index == i)
+        return llElements[elid].value;
       else
         return m_zero;
     }
@@ -250,8 +307,8 @@
 template <typename Scalar_, typename StorageIndex_>
 class AmbiVector<Scalar_, StorageIndex_>::Iterator {
  public:
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   /** Default constructor
    * \param vec the vector on which we iterate
@@ -269,7 +326,7 @@
       m_cachedIndex = m_vector.m_start - 1;
       ++(*this);
     } else {
-      ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+      const ListEl* EIGEN_RESTRICT llElements = m_vector.listElements();
       m_currentEl = m_vector.m_llStart;
       while (m_currentEl >= 0 && abs(llElements[m_currentEl].value) <= m_epsilon)
         m_currentEl = llElements[m_currentEl].next;
@@ -299,7 +356,7 @@
       else
         m_cachedIndex = -1;
     } else {
-      ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer);
+      const ListEl* EIGEN_RESTRICT llElements = m_vector.listElements();
       do {
         m_currentEl = llElements[m_currentEl].next;
       } while (m_currentEl >= 0 && abs(llElements[m_currentEl].value) <= m_epsilon);
diff --git a/Eigen/src/SparseCore/BlockSparseMatrix.h b/Eigen/src/SparseCore/BlockSparseMatrix.h
new file mode 100644
index 0000000..96129f8
--- /dev/null
+++ b/Eigen/src/SparseCore/BlockSparseMatrix.h
@@ -0,0 +1,1854 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BLOCKSPARSEMATRIX_H
+#define EIGEN_BLOCKSPARSEMATRIX_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <algorithm>
+#include <numeric>
+#include <utility>
+
+namespace Eigen {
+
+// Forward declarations
+template <typename, int, bool>
+class BlockSparseTriangularView;
+template <typename, int, bool>
+class BlockSparseSelfAdjointView;
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+class BlockSparseMatrix;
+
+/** Storage-kind tag for BlockSparseMatrix. */
+struct BlockSparse {};
+
+/** Evaluator shape tag for BlockSparseMatrix product dispatch. */
+struct BlockSparseShape {
+  static std::string debugName() { return "BlockSparseShape"; }
+};
+
+namespace internal {
+// Returns m.adjoint() when Conj==true, m.transpose() otherwise.
+// SFINAE overloads keep the return type concrete under C++14 (no if constexpr).
+template <bool Conj, typename T>
+std::enable_if_t<Conj, decltype(std::declval<const T&>().adjoint())> adjoint_if(const T& m) {
+  return m.adjoint();
+}
+
+template <bool Conj, typename T>
+std::enable_if_t<!Conj, decltype(std::declval<const T&>().transpose())> adjoint_if(const T& m) {
+  return m.transpose();
+}
+template <>
+struct storage_kind_to_evaluator_kind<BlockSparse> {
+  using Kind = IndexBased;
+};
+
+template <>
+struct storage_kind_to_shape<BlockSparse> {
+  using Shape = BlockSparseShape;
+};
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+struct traits<BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>> {
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using StorageKind = BlockSparse;
+  using XprKind = MatrixXpr;
+
+  static constexpr Index RowsAtCompileTime = Dynamic;
+  static constexpr Index ColsAtCompileTime = Dynamic;
+  static constexpr Index MaxRowsAtCompileTime = Dynamic;
+  static constexpr Index MaxColsAtCompileTime = Dynamic;
+  static constexpr int Options = Options_;
+  static constexpr unsigned int Flags = Options_ | NestByRefBit | LvalueBit;
+};
+
+}  // namespace internal
+
+/** \class BlockTriplet
+ * \ingroup SparseCore_Module
+ * \brief A (blockRow, blockCol, blockValue) triplet for assembling a BlockSparseMatrix.
+ *
+ * Coordinates are in \em block space, not element space.
+ *
+ * \tparam Scalar_       Numeric scalar type.
+ * \tparam BlockRows_    Number of rows in each block.
+ * \tparam BlockCols_    Number of columns in each block.
+ * \tparam StorageIndex_ Signed integer index type (default: int).
+ */
+template <typename Scalar_, int BlockRows_, int BlockCols_, int Options_ = ColMajor, typename StorageIndex_ = int>
+class BlockTriplet {
+ public:
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using BlockType = Matrix<Scalar, BlockRows_, BlockCols_, Options_>;
+  using BlockMapType = Map<BlockType, Unaligned>;
+  using ConstBlockMapType = Map<const BlockType, Unaligned>;
+
+  static constexpr int BlockSize = BlockRows_ * BlockCols_;
+
+  BlockTriplet() = default;
+
+  BlockTriplet(StorageIndex blockRow, StorageIndex blockCol, const BlockType& block)
+      : m_row(blockRow), m_col(blockCol) {
+    BlockMapType{m_value} = block;
+  }
+
+  StorageIndex row() const { return m_row; }
+  StorageIndex col() const { return m_col; }
+  // Implicitly usable wherever a MatrixBase expression is expected.
+  ConstBlockMapType value() const { return ConstBlockMapType(m_value); }
+
+ private:
+  StorageIndex m_row = 0;
+  StorageIndex m_col = 0;
+  // Flat array avoids the alignment padding that a Matrix<> member would incur.
+  Scalar m_value[BlockSize];
+};
+
+/** \class BlockSparseMatrix
+ * \ingroup SparseCore_Module
+ * \brief A sparse matrix whose stored nonzeros are fixed-size dense blocks.
+ *
+ * Each nonzero entry is a \c BlockRows x \c BlockCols dense matrix.  The
+ * block sparsity pattern is stored in block-level compressed-column
+ * (ColMajor) or compressed-row (RowMajor) format.
+ *
+ * \tparam Scalar_       Numeric scalar type.
+ * \tparam Options_      ColMajor (0) or RowMajor.  Controls both the outer
+ *                       iteration direction over blocks and the storage
+ *                       layout within each block.  Note: vector-shaped blocks
+ *                       must use a compatible order — \c BlockCols_=1 requires
+ *                       ColMajor, \c BlockRows_=1 requires RowMajor.
+ * \tparam BlockRows_    Rows per block; must be a fixed positive integer.
+ * \tparam BlockCols_    Columns per block; must be a fixed positive integer.
+ * \tparam StorageIndex_ Signed integer type for internal index arrays
+ *                       (default: int).
+ *
+ * ### Assembly
+ * Populate the matrix via setFromTriplets(), passing an iterator range of
+ * BlockTriplet objects in block coordinates.  Triplets with the same
+ * (blockRow, blockCol) are summed.
+ *
+ * ### Arithmetic
+ * Addition, subtraction, and matrix product are supported between compatible
+ * BlockSparseMatrix instances.  Scalar multiplication is also available.
+ *
+ * The matrix product \c C = A * B requires
+ * \c A.BlockCols == B.BlockRows (enforced at compile time by the template
+ * constraint) and \c A.blockCols() == B.blockRows() (checked at runtime).
+ * The result has block type \c Matrix<Scalar,A.BlockRows,B.BlockCols>.
+ *
+ * ### Conversion
+ * toSparse() converts to a standard SparseMatrix with element-level
+ * sparsity.  fromSparse() reconstructs a BlockSparseMatrix from an
+ * element-level SparseMatrix whose dimensions are divisible by BlockRows
+ * and BlockCols.  An implicit conversion operator to SparseMatrix is
+ * also provided.
+ */
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_ = int>
+class BlockSparseMatrix
+    : public EigenBase<BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>> {
+  EIGEN_STATIC_ASSERT(BlockRows_ >= 1, BLOCKROWS_MUST_BE_A_POSITIVE_COMPILE_TIME_SIZE)
+  EIGEN_STATIC_ASSERT(BlockCols_ >= 1, BLOCKCOLS_MUST_BE_A_POSITIVE_COMPILE_TIME_SIZE)
+  EIGEN_STATIC_ASSERT(std::is_integral<StorageIndex_>::value&& std::is_signed<StorageIndex_>::value,
+                      STORAGEINDEX_MUST_BE_A_SIGNED_INTEGRAL_TYPE)
+  // Eigen's Matrix<> requires: a column vector (Cols==1, Rows>1) must be ColMajor;
+  // a row vector (Rows==1, Cols>1) must be RowMajor.  Guard those cases here so
+  // the error fires at BlockSparseMatrix instantiation rather than inside BlockType.
+  EIGEN_STATIC_ASSERT(!(BlockCols_ == 1 && BlockRows_ != 1 && bool(Options_ & RowMajorBit)),
+                      INVALID_MATRIX_TEMPLATE_PARAMETERS)
+  EIGEN_STATIC_ASSERT(!(BlockRows_ == 1 && BlockCols_ != 1 && !bool(Options_ & RowMajorBit)),
+                      INVALID_MATRIX_TEMPLATE_PARAMETERS)
+
+ public:
+  // -------------------------------------------------------------------------
+  // Type aliases & compile-time constants
+  // -------------------------------------------------------------------------
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using BlockType = Matrix<Scalar, BlockRows_, BlockCols_, Options_>;
+  using TripletType = BlockTriplet<Scalar, BlockRows_, BlockCols_, Options_, StorageIndex>;
+
+  static constexpr int Options = Options_;
+  static constexpr Index BlockRows = BlockRows_;
+  static constexpr Index BlockCols = BlockCols_;
+  static constexpr bool IsRowMajor = Options_ & RowMajorBit;
+  static constexpr Index BlockSize = BlockRows_ * BlockCols_;
+
+  // If one block occupies a power-of-two number of bytes, and the values array
+  // is Eigen-allocated (guaranteed aligned to EIGEN_MAX_ALIGN_BYTES), then every
+  // block pointer is aligned to min(BlockBytes, EIGEN_MAX_ALIGN_BYTES).
+  static constexpr std::size_t BlockBytes = std::size_t(BlockSize) * sizeof(Scalar);
+  static constexpr int BlockMapAlignment = ((BlockBytes & (BlockBytes - 1)) == 0 && BlockBytes >= 8)
+                                               ? int(numext::mini(BlockBytes, std::size_t(EIGEN_MAX_ALIGN_BYTES)))
+                                               : 0;
+
+  using BlockMap = Map<BlockType, BlockMapAlignment>;
+  using ConstBlockMap = Map<const BlockType, BlockMapAlignment>;
+
+  // -------------------------------------------------------------------------
+  // Constructors / copy / move
+  // -------------------------------------------------------------------------
+
+  /** Default constructor; creates a 0×0 matrix. */
+  BlockSparseMatrix() = default;
+
+  /** Construct a zero matrix with the given number of block-rows and block-columns. */
+  BlockSparseMatrix(Index blockRows, Index blockCols)
+      : m_blockOuterSize(IsRowMajor ? blockRows : blockCols), m_blockInnerSize(IsRowMajor ? blockCols : blockRows) {}
+
+  // -------------------------------------------------------------------------
+  // Dimensions
+  // -------------------------------------------------------------------------
+
+  /** Total number of element rows. */
+  Index rows() const noexcept { return (IsRowMajor ? m_blockOuterSize : m_blockInnerSize) * BlockRows_; }
+  /** Total number of element columns. */
+  Index cols() const noexcept { return (IsRowMajor ? m_blockInnerSize : m_blockOuterSize) * BlockCols_; }
+
+  /** Number of block-rows. */
+  Index blockRows() const { return IsRowMajor ? m_blockOuterSize : m_blockInnerSize; }
+  /** Number of block-columns. */
+  Index blockCols() const { return IsRowMajor ? m_blockInnerSize : m_blockOuterSize; }
+
+  /** Outer block dimension (block-cols for ColMajor, block-rows for RowMajor). */
+  Index blockOuterSize() const { return m_blockOuterSize; }
+  /** Inner block dimension (block-rows for ColMajor, block-cols for RowMajor). */
+  Index blockInnerSize() const { return m_blockInnerSize; }
+
+  /** Element-level outer size: cols() for ColMajor, rows() for RowMajor. */
+  Index outerSize() const { return IsRowMajor ? rows() : cols(); }
+  /** Element-level inner size: rows() for ColMajor, cols() for RowMajor. */
+  Index innerSize() const { return IsRowMajor ? cols() : rows(); }
+
+  /** Number of stored (structurally non-zero) blocks. */
+  Index nonZeroBlocks() const { return m_outerIndex(m_blockOuterSize); }
+  /** Total number of stored scalar coefficients (= nonZeroBlocks() * BlockRows * BlockCols). */
+  Index nonZeros() const { return nonZeroBlocks() * BlockSize; }
+  /** Number of blocks for which storage is currently allocated (capacity). */
+  Index allocatedBlocks() const { return Index(m_innerIndex.size()); }
+
+  // -------------------------------------------------------------------------
+  // Raw pointer access (for interoperability)
+  // -------------------------------------------------------------------------
+  const StorageIndex* outerIndexPtr() const { return m_outerIndex.data(); }
+  StorageIndex* outerIndexPtr() { return m_outerIndex.data(); }
+  const StorageIndex* innerIndexPtr() const { return m_innerIndex.data(); }
+  StorageIndex* innerIndexPtr() { return m_innerIndex.data(); }
+  const Scalar* valuePtr() const { return m_values.data(); }
+  Scalar* valuePtr() { return m_values.data(); }
+
+  // -------------------------------------------------------------------------
+  // Block access by sequential nonzero index
+  // -------------------------------------------------------------------------
+
+  /** Read-only Map to the \a k-th stored block (block storage follows \c Options_). */
+  ConstBlockMap blockRef(Index k) const { return ConstBlockMap(m_values.data() + k * BlockSize); }
+  /** Mutable Map to the \a k-th stored block. */
+  BlockMap blockRef(Index k) { return BlockMap(m_values.data() + k * BlockSize); }
+
+  // -------------------------------------------------------------------------
+  // Inner iterator over blocks within one outer vector
+  // -------------------------------------------------------------------------
+
+  /** \brief Iterates over stored blocks in outer vector \a outer.
+   *
+   * Usage mirrors SparseMatrix::InnerIterator but value() returns a
+   * Map to a BlockRows×BlockCols matrix, not a scalar.
+   */
+  class InnerIterator {
+   public:
+    EIGEN_STRONG_INLINE InnerIterator(const BlockSparseMatrix& mat, Index outer)
+        : m_mat(mat), m_id(mat.m_outerIndex(outer)), m_end(mat.m_outerIndex(outer + 1)), m_outer(outer) {}
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_id < m_end; }
+    EIGEN_STRONG_INLINE InnerIterator& operator++() {
+      ++m_id;
+      return *this;
+    }
+
+    /** Current block outer index (block-col for ColMajor, block-row for RowMajor). */
+    EIGEN_STRONG_INLINE Index outer() const { return m_outer; }
+    /** Current block inner index (block-row for ColMajor, block-col for RowMajor). */
+    EIGEN_STRONG_INLINE Index index() const { return m_mat.m_innerIndex(m_id); }
+    /** Block-row of the current block. */
+    EIGEN_STRONG_INLINE Index blockRow() const { return IsRowMajor ? m_outer : index(); }
+    /** Block-column of the current block. */
+    EIGEN_STRONG_INLINE Index blockCol() const { return IsRowMajor ? index() : m_outer; }
+
+    /** Read-only Map to the current block value. */
+    EIGEN_STRONG_INLINE ConstBlockMap value() const { return m_mat.blockRef(m_id); }
+    /** Mutable Map to the current block value. */
+    EIGEN_STRONG_INLINE BlockMap valueRef() {
+      return BlockMap(const_cast<Scalar*>(m_mat.m_values.data()) + m_id * BlockSize);
+    }
+
+   private:
+    const BlockSparseMatrix& m_mat;
+    Index m_id;
+    Index m_end;
+    Index m_outer;
+  };
+
+  // -------------------------------------------------------------------------
+  // Resize / clear
+  // -------------------------------------------------------------------------
+
+  /** Resize to \a blockRows × \a blockCols blocks and set the logical nnz to zero.
+   *  Allocated block storage is retained; call squeeze() to release it. */
+  void resize(Index blockRows, Index blockCols) {
+    m_blockOuterSize = IsRowMajor ? blockRows : blockCols;
+    m_blockInnerSize = IsRowMajor ? blockCols : blockRows;
+    m_outerIndex.resize(m_blockOuterSize + 1);
+    m_outerIndex.setZero();
+  }
+
+  /** Clear all stored blocks (logical nnz → 0) while keeping dimensions and allocated storage. */
+  void setZero() {
+    m_outerIndex.resize(m_blockOuterSize + 1);
+    m_outerIndex.setZero();
+  }
+
+  /** Pre-allocate storage for at least \a n blocks without changing the logical sparsity pattern.
+   *  Existing block data is preserved up to min(n, nonZeroBlocks()). */
+  void reserve(Index n) {
+    if (n > Index(m_innerIndex.size())) conservativeResizeBlockStorage_(n);
+  }
+
+  /** Release any excess allocated block storage so that allocatedBlocks() == nonZeroBlocks(). */
+  void squeeze() {
+    Index nnz = nonZeroBlocks();
+    if (nnz < Index(m_innerIndex.size())) conservativeResizeBlockStorage_(nnz);
+  }
+
+  /** Fill the matrix with the block identity: the min(blockRows,blockCols) diagonal blocks
+   *  are set to the B×B identity; all other blocks are absent.
+   *
+   *  \pre BlockRows == BlockCols (square blocks).
+   */
+  void setIdentity() {
+    EIGEN_STATIC_ASSERT(BlockRows_ == BlockCols_, THIS_METHOD_IS_ONLY_FOR_SQUARE_BLOCK_MATRICES)
+    Index n = (std::min)(m_blockOuterSize, m_blockInnerSize);
+    m_outerIndex.resize(m_blockOuterSize + 1);
+    resizeBlockStorage_(n);
+    for (Index i = 0; i <= m_blockOuterSize; ++i) m_outerIndex(i) = StorageIndex((std::min)(i, n));
+    for (StorageIndex i = 0; i < n; ++i) {
+      m_innerIndex(i) = i;
+      blockRef(i).setIdentity();
+    }
+  }
+
+  /** Initialize the block structure directly from compressed outer/inner index arrays,
+   *  zero-initializing all block values.
+   *
+   *  \p outerPtr  has size blockCols+1 (ColMajor) or blockRows+1 (RowMajor).
+   *  \p innerPtr  has size nnzBlocks.
+   */
+  void setFromOuterInner(Index blockRows, Index blockCols, Index nnzBlocks, const StorageIndex_* outerPtr,
+                         const StorageIndex_* innerPtr) {
+    m_blockOuterSize = IsRowMajor ? blockRows : blockCols;
+    m_blockInnerSize = IsRowMajor ? blockCols : blockRows;
+    m_outerIndex = Map<const decltype(m_outerIndex)>(outerPtr, m_blockOuterSize + 1);
+    m_innerIndex = Map<const decltype(m_innerIndex)>(innerPtr, nnzBlocks);
+    resizeBlockStorage_(nnzBlocks);
+    m_values.setZero();
+  }
+
+  // -------------------------------------------------------------------------
+  // Assembly
+  // -------------------------------------------------------------------------
+
+  /** Fill the matrix from an iterator range of BlockTriplet objects.
+   *
+   * Triplet coordinates are in block space.  Triplets with the same
+   * (blockRow, blockCol) pair are summed (their block values are added).
+   * The input range may be in any order.
+   *
+   * \tparam InputIterator  Must dereference to a type with \c row(),
+   *                        \c col(), and \c value() members, matching
+   *                        BlockTriplet's interface.
+   */
+  template <typename InputIterator>
+  void setFromTriplets(InputIterator begin, InputIterator end);
+
+  // -------------------------------------------------------------------------
+  // Conversion to / from SparseMatrix
+  // -------------------------------------------------------------------------
+
+  /** Convert to a SparseMatrix with scalar nonzeros.
+   *
+   * Each stored block of size BlockRows×BlockCols expands into up to
+   * BlockRows*BlockCols scalar nonzeros.  The resulting SparseMatrix has
+   * the same storage order as \c *this.
+   */
+  SparseMatrix<Scalar, Options_, StorageIndex_> toSparse() const;
+
+  /** Construct a BlockSparseMatrix from an element-level SparseMatrix.
+   *
+   * \pre  \c sp.rows() % BlockRows == 0 and \c sp.cols() % BlockCols == 0.
+   *
+   * Each scalar entry \c sp(i,j) is placed into position
+   * \c (i%BlockRows, j%BlockCols) of block \c (i/BlockRows, j/BlockCols).
+   * Multiple entries mapping to the same element of the same block are
+   * accumulated with \c +=.
+   */
+  static BlockSparseMatrix fromSparse(const SparseMatrix<Scalar_, Options_, StorageIndex_>& sp);
+
+  /** Implicit conversion to SparseMatrix. */
+  operator SparseMatrix<Scalar_, Options_, StorageIndex_>() const { return toSparse(); }
+
+  // -------------------------------------------------------------------------
+  // Element access
+  // -------------------------------------------------------------------------
+
+  /** Read element \c (row, col); returns 0 if no block covers that position. */
+  Scalar coeff(Index row, Index col) const {
+    eigen_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
+    Index bOuter = IsRowMajor ? (row / BlockRows_) : (col / BlockCols_);
+    Index bInner = IsRowMajor ? (col / BlockCols_) : (row / BlockRows_);
+    Index localRow = row % BlockRows_;
+    Index localCol = col % BlockCols_;
+    const StorageIndex* beg = m_innerIndex.data() + m_outerIndex(bOuter);
+    const StorageIndex* fin = m_innerIndex.data() + m_outerIndex(bOuter + 1);
+    const StorageIndex* it = std::lower_bound(beg, fin, StorageIndex(bInner));
+    if (it == fin || *it != bInner) return Scalar(0);
+    return blockRef(static_cast<Index>(it - m_innerIndex.data()))(localRow, localCol);
+  }
+
+  /** Extract the main scalar diagonal as a dense vector.
+   *
+   * Iterates outer slices once and binary-searches for the diagonal block in each
+   * slice, then copies the relevant entries from that block — one search per outer
+   * slice (square blocks) or per unique inner-block boundary (non-square blocks),
+   * vs. one search per scalar element for the coeff-by-coeff approach.
+   */
+  Matrix<Scalar, Dynamic, 1> diagonal() const {
+    constexpr Index OuterB = IsRowMajor ? BlockRows_ : BlockCols_;
+    constexpr Index InnerB = IsRowMajor ? BlockCols_ : BlockRows_;
+    const Index diagSize = numext::mini(rows(), cols());
+    Matrix<Scalar, Dynamic, 1> diag = Matrix<Scalar, Dynamic, 1>::Zero(diagSize);
+
+    for (Index out = 0; out < m_blockOuterSize; ++out) {
+      const Index scalarOuterBegin = out * OuterB;
+      if (scalarOuterBegin >= diagSize) break;
+      const Index scalarOuterEnd = numext::mini(scalarOuterBegin + OuterB, diagSize);
+
+      // Group consecutive scalar positions that share the same inner block, then
+      // binary-search once per group rather than once per scalar element.
+      // For square blocks this loop runs exactly once per outer slice.
+      Index i = scalarOuterBegin;
+      while (i < scalarOuterEnd) {
+        const Index bInner = i / InnerB;
+        const Index groupEnd = numext::mini((bInner + 1) * InnerB, scalarOuterEnd);
+
+        const StorageIndex* beg = m_innerIndex.data() + m_outerIndex(out);
+        const StorageIndex* fin = m_innerIndex.data() + m_outerIndex(out + 1);
+        const StorageIndex* it = std::lower_bound(beg, fin, StorageIndex(bInner));
+        if (it != fin && *it == StorageIndex(bInner)) {
+          const ConstBlockMap blk = blockRef(static_cast<Index>(it - m_innerIndex.data()));
+          for (Index j = i; j < groupEnd; ++j) {
+            const Index localRow = IsRowMajor ? (j % OuterB) : (j % InnerB);
+            const Index localCol = IsRowMajor ? (j % InnerB) : (j % OuterB);
+            diag(j) = blk(localRow, localCol);
+          }
+        }
+        i = groupEnd;
+      }
+    }
+    return diag;
+  }
+
+  // -------------------------------------------------------------------------
+  // Arithmetic
+  // -------------------------------------------------------------------------
+
+  /** Element-wise addition.  Both matrices must have the same block dimensions. */
+  BlockSparseMatrix operator+(const BlockSparseMatrix& other) const { return disjunctionWith_(other, AddOp_{}); }
+
+  /** Element-wise subtraction. */
+  BlockSparseMatrix operator-(const BlockSparseMatrix& other) const { return disjunctionWith_(other, SubOp_{}); }
+
+  /** Element-wise product.  Only blocks present in \em both operands contribute to the result. */
+  BlockSparseMatrix cwiseProduct(const BlockSparseMatrix& other) const {
+    return conjunctionWith_(other, CwiseMulOp_{});
+  }
+
+  /** Applies a scalar unary functor to every stored nonzero, preserving the sparsity pattern. */
+  template <typename ScalarFunc>
+  BlockSparseMatrix unaryExpr(ScalarFunc func) const {
+    return withValues_([&func](const auto& v) { return v.unaryExpr(func); });
+  }
+
+  /** Applies a scalar binary functor with union sparsity.
+   *
+   * \p func must provide three members:
+   * \code
+   *   Scalar func(Scalar a, Scalar b)  // both present
+   *   Scalar func.lhs(Scalar a)        // only lhs present; rhs is implicitly zero
+   *   Scalar func.rhs(Scalar b)        // only rhs present; lhs is implicitly zero
+   * \endcode
+   */
+  template <typename ScalarFunc>
+  BlockSparseMatrix disjunctionExpr(const BlockSparseMatrix& other, ScalarFunc func) const {
+    return disjunctionWith_(other, DisjExprAdapter_<ScalarFunc>{func});
+  }
+
+  /** Applies a scalar binary functor with intersection sparsity: only block positions present
+   * in \em both matrices contribute; \p func is called as \c func(Scalar a, Scalar b). */
+  template <typename ScalarFunc>
+  BlockSparseMatrix conjunctionExpr(const BlockSparseMatrix& other, ScalarFunc func) const {
+    return conjunctionWith_(other, [&func](const auto& a, const auto& b) { return a.binaryExpr(b, func); });
+  }
+
+  /** Unary negation. */
+  BlockSparseMatrix operator-() const {
+    return withValues_([](const auto& v) { return -v; });
+  }
+
+  BlockSparseMatrix& operator+=(const BlockSparseMatrix& other) { return *this = *this + other; }
+  BlockSparseMatrix& operator-=(const BlockSparseMatrix& other) { return *this = *this - other; }
+
+  /** Scalar multiplication (returns a new matrix). */
+  BlockSparseMatrix operator*(const Scalar& s) const {
+    return withValues_([&s](const auto& v) { return v * s; });
+  }
+  BlockSparseMatrix& operator*=(const Scalar& s) {
+    m_values.head(nonZeros()) *= s;
+    return *this;
+  }
+  BlockSparseMatrix operator/(const Scalar& s) const {
+    return withValues_([&s](const auto& v) { return v / s; });
+  }
+  BlockSparseMatrix& operator/=(const Scalar& s) { return *this *= (Scalar(1) / s); }
+
+  /** Scalar-on-left multiplication. */
+  friend BlockSparseMatrix operator*(const Scalar& s, const BlockSparseMatrix& m) { return m * s; }
+
+  /** Block-sparse times dense matrix (or vector) product.
+   *
+   * Returns a lazy \c Product<> expression evaluated via \c generic_product_impl.
+   * This enables fused accumulation:
+   *   \code
+   *   b.noalias()  = A * x;       // no temporary
+   *   b.noalias() += A * x;       // fused add
+   *   b.noalias() += alpha * (A * x);  // scale then add via evaluator
+   *   \endcode
+   *
+   * \pre  \c this->cols() == rhs.rows().
+   * \pre  Scalar types must match.
+   * \warning The result uses \c AliasFreeProduct, so assignment goes directly
+   *          through \c generic_product_impl::evalTo with no aliasing temporary.
+   *          \c x = A * x silently corrupts; use an explicit temporary if needed.
+   */
+  template <typename OtherDerived>
+  Product<BlockSparseMatrix, OtherDerived, AliasFreeProduct> operator*(const MatrixBase<OtherDerived>& rhs) const {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    return Product<BlockSparseMatrix, OtherDerived, AliasFreeProduct>(*this, rhs.derived());
+  }
+
+  /** Dense matrix (or vector) times block-sparse product (hidden friend).
+   *
+   * Returns a lazy \c Product<> expression; evaluated via \c generic_product_impl.
+   *
+   * \pre  \c lhs.cols() == bsm.rows().
+   * \pre  Scalar types must match.
+   * \warning The result uses \c AliasFreeProduct, so assignment goes directly
+   *          through \c generic_product_impl::evalTo with no aliasing temporary.
+   *          \c x = x * A silently corrupts; use an explicit temporary if needed.
+   */
+  template <typename OtherDerived>
+  friend Product<OtherDerived, BlockSparseMatrix, AliasFreeProduct> operator*(const MatrixBase<OtherDerived>& lhs,
+                                                                              const BlockSparseMatrix& bsm) {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar_, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    return Product<OtherDerived, BlockSparseMatrix, AliasFreeProduct>(lhs.derived(), bsm);
+  }
+
+  /** Block-sparse matrix product.
+   *
+   * \tparam RhsBlockCols  Block-column count of the right-hand side.
+   *
+   * The left-hand side has block type \c Matrix<Scalar,BlockRows,BlockCols>
+   * and the right-hand side must have block type
+   * \c Matrix<Scalar,BlockCols,RhsBlockCols> (enforced by the template
+   * parameter).  The result has block type
+   * \c Matrix<Scalar,BlockRows,RhsBlockCols>.
+   *
+   * \pre  \c this->blockCols() == rhs.blockRows() (checked at runtime).
+   */
+  template <int RhsBlockCols>
+  BlockSparseMatrix<Scalar_, Options_, BlockRows_, RhsBlockCols, StorageIndex_> operator*(
+      const BlockSparseMatrix<Scalar_, Options_, BlockCols_, RhsBlockCols, StorageIndex_>& rhs) const;
+
+  // -------------------------------------------------------------------------
+  // Approximate equality (useful for testing)
+  // -------------------------------------------------------------------------
+  bool isApprox(const BlockSparseMatrix& other,
+                const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const {
+    using RealScalar = typename NumTraits<Scalar>::Real;
+    // Frobenius-norm comparison, matching SparseMatrixBase::isApprox semantics
+    // but computed directly from the block values — no scalar-level SparseMatrix
+    // materialization of either operand.  Explicit zero blocks contribute 0 to
+    // every norm, so the result is independent of structural differences.
+    RealScalar n2a = m_values.head(nonZeros()).matrix().squaredNorm();
+    RealScalar n2b = other.m_values.head(other.nonZeros()).matrix().squaredNorm();
+    BlockSparseMatrix diff = *this - other;
+    RealScalar d2 = diff.m_values.head(diff.nonZeros()).matrix().squaredNorm();
+    return d2 <= prec * prec * numext::mini(n2a, n2b);
+  }
+
+  // -------------------------------------------------------------------------
+  // Transpose / adjoint
+  // -------------------------------------------------------------------------
+
+  /** Returns a new BSM whose block dimensions are swapped (BlockRows ↔ BlockCols)
+   *  and each stored block is transposed.  Storage order is preserved. */
+  BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_> transpose() const;
+
+  /** Returns a new BSM whose block dimensions are swapped and each stored block
+   *  is conjugate-transposed (adjoint).  Identical to transpose() for real scalars. */
+  BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_> adjoint() const;
+
+  // -------------------------------------------------------------------------
+  // View factories
+  // -------------------------------------------------------------------------
+
+  /** Returns a block-level triangular view.
+   *
+   * \tparam Mode             \c Eigen::Upper or \c Eigen::Lower.
+   * \tparam DiagIsTriangular When \c false (default), diagonal blocks are
+   *   treated as triangular regardless of what is stored in the unused
+   *   triangle — products use \c triangularView on the block and \c eval()
+   *   explicitly zeros the unused triangle.  When \c true, the caller
+   *   guarantees that the unused triangle of every diagonal block is already
+   *   zero; products then use a full vectorised GEMV (faster, no zeroing).
+   */
+  template <int Mode, bool DiagIsTriangular = false>
+  BlockSparseTriangularView<BlockSparseMatrix, Mode, DiagIsTriangular> triangularView() const {
+    return BlockSparseTriangularView<BlockSparseMatrix, Mode, DiagIsTriangular>(*this);
+  }
+
+  /** Returns a block-level self-adjoint view.
+   *
+   * Only the triangle selected by \p UpLo is read; the opposite triangle is
+   * reconstructed on-the-fly as the adjoint of each stored off-diagonal block.
+   *
+   * \tparam UpLo              \c Eigen::Upper or \c Eigen::Lower.
+   * \tparam DiagIsSelfAdjoint Set to \c true when every diagonal block is
+   *         itself Hermitian \em and both triangles are explicitly stored.
+   *         The dense sub-product then uses a plain product rather than
+   *         \c selfadjointView, which is more efficient for the small
+   *         fixed-size blocks typical here.  When \c false (the default),
+   *         only the \p UpLo triangle of each diagonal block is assumed
+   *         valid; \c selfadjointView<UpLo>() reconstructs the full block.
+   *
+   * \pre BlockRows == BlockCols (diagonal blocks must be square).
+   */
+  template <int UpLo, bool DiagIsSelfAdjoint = false>
+  BlockSparseSelfAdjointView<BlockSparseMatrix, UpLo, DiagIsSelfAdjoint> selfadjointView() const {
+    EIGEN_STATIC_ASSERT(BlockRows_ == BlockCols_, THIS_METHOD_IS_ONLY_FOR_SQUARE_BLOCK_MATRICES)
+    return BlockSparseSelfAdjointView<BlockSparseMatrix, UpLo, DiagIsSelfAdjoint>(*this);
+  }
+
+ private:
+  struct AddOp_ {
+    template <typename A, typename B>
+    BlockType operator()(const A& a, const B& b) const {
+      return a + b;
+    }
+    template <typename A>
+    BlockType lhs(const A& a) const {
+      return a;
+    }
+    template <typename B>
+    BlockType rhs(const B& b) const {
+      return b;
+    }
+  };
+
+  struct SubOp_ {
+    template <typename A, typename B>
+    BlockType operator()(const A& a, const B& b) const {
+      return a - b;
+    }
+    template <typename A>
+    BlockType lhs(const A& a) const {
+      return a;
+    }
+    template <typename B>
+    BlockType rhs(const B& b) const {
+      return -b;
+    }
+  };
+
+  // Scalar-to-block adapter for disjunctionExpr: translates scalar functor with lhs/rhs methods
+  // to the block level.
+  template <typename ScalarFunc>
+  struct DisjExprAdapter_ {
+    ScalarFunc func_;
+    template <typename A, typename B>
+    BlockType operator()(const A& a, const B& b) const {
+      return a.binaryExpr(b, func_);
+    }
+    template <typename A>
+    BlockType lhs(const A& a) const {
+      return a.unaryExpr([this](const Scalar& x) { return func_.lhs(x); });
+    }
+    template <typename B>
+    BlockType rhs(const B& b) const {
+      return b.unaryExpr([this](const Scalar& x) { return func_.rhs(x); });
+    }
+  };
+
+  struct CwiseMulOp_ {
+    template <typename A, typename B>
+    BlockType operator()(const A& a, const B& b) const {
+      return a.cwiseProduct(b);
+    }
+  };
+
+  // Returns a copy with the same sparsity structure but m_values replaced by f(m_values).
+  // f receives the flat Eigen Array of the logical (non-zero) coefficients and returns any
+  // compatible expression.  Only the structure is copied — the source values are never
+  // duplicated, and unused tail capacity is neither copied nor evaluated.
+  template <typename F>
+  BlockSparseMatrix withValues_(F f) const {
+    Index nnz = nonZeroBlocks();
+    BlockSparseMatrix result(blockRows(), blockCols());
+    result.m_outerIndex = m_outerIndex;
+    result.m_innerIndex = m_innerIndex.head(nnz);
+    result.m_values = f(m_values.head(nnz * BlockSize));
+    return result;
+  }
+
+  // Disjunction (union-pattern): result has a block wherever *this OR other has one.
+  //   lhs-only:  block copied from *this unchanged
+  //   rhs-only:  op(b)      — unary overload of op
+  //   both:      op(a, b)   — binary overload of op
+  template <typename Op>
+  BlockSparseMatrix disjunctionWith_(const BlockSparseMatrix& other, Op op) const {
+    eigen_assert(blockRows() == other.blockRows() && blockCols() == other.blockCols() &&
+                 "BlockSparseMatrix size mismatch");
+    BlockSparseMatrix result(blockRows(), blockCols());
+    result.resizeBlockStorage_(nonZeroBlocks() + other.nonZeroBlocks());
+    Index nnz = 0;
+    for (Index j = 0; j < m_blockOuterSize; ++j) {
+      result.m_outerIndex(j) = StorageIndex_(nnz);
+      Index aId = m_outerIndex(j);
+      Index aEnd = m_outerIndex(j + 1);
+      Index bId = other.m_outerIndex(j);
+      Index bEnd = other.m_outerIndex(j + 1);
+      while (aId < aEnd || bId < bEnd) {
+        bool hasA = aId < aEnd;
+        bool hasB = bId < bEnd;
+        Index aInner = hasA ? Index(m_innerIndex(aId)) : -1;
+        Index bInner = hasB ? Index(other.m_innerIndex(bId)) : -1;
+        // Write the result block in place; the op overloads return a BlockType,
+        // which is assigned straight into the result's storage Map.
+        if (hasA && (!hasB || aInner < bInner)) {
+          result.m_innerIndex(nnz) = StorageIndex_(aInner);
+          result.blockRef(nnz) = op.lhs(blockRef(aId++));
+        } else if (hasB && (!hasA || bInner < aInner)) {
+          result.m_innerIndex(nnz) = StorageIndex_(bInner);
+          result.blockRef(nnz) = op.rhs(other.blockRef(bId++));
+        } else {
+          result.m_innerIndex(nnz) = StorageIndex_(aInner);
+          result.blockRef(nnz) = op(blockRef(aId++), other.blockRef(bId++));
+        }
+        ++nnz;
+      }
+    }
+    result.m_outerIndex(m_blockOuterSize) = StorageIndex_(nnz);
+    result.conservativeResizeBlockStorage_(nnz);
+    return result;
+  }
+
+  // Conjunction (intersection-pattern): result has a block only where *this AND other both have one.
+  template <typename BinaryOp>
+  BlockSparseMatrix conjunctionWith_(const BlockSparseMatrix& other, BinaryOp func) const {
+    eigen_assert(blockRows() == other.blockRows() && blockCols() == other.blockCols() &&
+                 "BlockSparseMatrix size mismatch");
+    BlockSparseMatrix result(blockRows(), blockCols());
+    result.resizeBlockStorage_((std::min)(nonZeroBlocks(), other.nonZeroBlocks()));
+    Index nnz = 0;
+    for (Index j = 0; j < m_blockOuterSize; ++j) {
+      result.m_outerIndex(j) = StorageIndex_(nnz);
+      Index aId = m_outerIndex(j);
+      Index aEnd = m_outerIndex(j + 1);
+      Index bId = other.m_outerIndex(j);
+      Index bEnd = other.m_outerIndex(j + 1);
+      while (aId < aEnd && bId < bEnd) {
+        Index aInner = m_innerIndex(aId);
+        Index bInner = other.m_innerIndex(bId);
+        if (aInner < bInner) {
+          ++aId;
+        } else if (bInner < aInner) {
+          ++bId;
+        } else {
+          result.m_innerIndex(nnz) = StorageIndex_(aInner);
+          result.blockRef(nnz) = func(blockRef(aId++), other.blockRef(bId++));
+          ++nnz;
+        }
+      }
+    }
+    result.m_outerIndex(m_blockOuterSize) = StorageIndex_(nnz);
+    result.conservativeResizeBlockStorage_(nnz);
+    return result;
+  }
+
+  template <bool Conjugate>
+  BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_> transposeImpl() const;
+
+  // Resize both block storage arrays non-conservatively and update the capacity counter.
+  void resizeBlockStorage_(Index n) {
+    m_innerIndex.resize(n);
+    m_values.resize(n * BlockSize);
+  }
+
+  void conservativeResizeBlockStorage_(Index n) {
+    m_innerIndex.conservativeResize(n);
+    m_values.conservativeResize(n * BlockSize);
+  }
+
+  // -------------------------------------------------------------------------
+  // Storage
+  // -------------------------------------------------------------------------
+  Index m_blockOuterSize = 0;  // block-cols (ColMajor) or block-rows (RowMajor)
+  Index m_blockInnerSize = 0;  // block-rows (ColMajor) or block-cols (RowMajor)
+
+  Array<StorageIndex, Dynamic, 1> m_outerIndex =  // size: m_blockOuterSize + 1
+      decltype(m_outerIndex)::Zero(m_blockOuterSize + 1);
+  Array<StorageIndex, Dynamic, 1> m_innerIndex;
+  // Block values stored consecutively; block k occupies
+  // m_values[k*BlockSize .. (k+1)*BlockSize - 1].
+  Array<Scalar, Dynamic, 1> m_values;
+
+  // -------------------------------------------------------------------------
+  // MultiInnerIterator
+  //
+  // Simultaneously walks BlockOuterSize_ consecutive outer vectors of a
+  // compressed SparseMatrix, yielding scalar entries one at a time in
+  // non-decreasing inner-index order.  On each step the sub-iterator with
+  // the smallest current inner index is the "active" one.
+  //
+  // BlockOuterSize_ is BlockCols_ for ColMajor (one block-column at a time)
+  // and BlockRows_ for RowMajor (one block-row at a time).
+  // -------------------------------------------------------------------------
+  template <typename SparseMatrixType>
+  class MultiInnerIterator {
+    using StorageIndex = typename SparseMatrixType::StorageIndex;
+    static constexpr int BlockOuterSize_ = IsRowMajor ? BlockRows_ : BlockCols_;
+
+   public:
+    MultiInnerIterator(const SparseMatrixType& mat, Index outerBase)
+        : m_outerPtr(mat.outerIndexPtr()),
+          m_innerPtr(mat.innerIndexPtr()),
+          m_valuePtr(mat.valuePtr()),
+          m_outerBase(outerBase) {
+      for (int k = 0; k < BlockOuterSize_; ++k) m_pos[k] = m_outerPtr[outerBase + k];
+      advance();
+    }
+
+    EIGEN_STRONG_INLINE operator bool() const { return m_valid; }
+
+    EIGEN_STRONG_INLINE MultiInnerIterator& operator++() {
+      ++m_pos[m_active];
+      advance();
+      return *this;
+    }
+
+    // Absolute outer index of the current entry.
+    EIGEN_STRONG_INLINE Index outer() const { return m_outerBase + m_active; }
+    // Inner index of the current entry.
+    EIGEN_STRONG_INLINE StorageIndex index() const { return m_innerPtr[m_pos[m_active]]; }
+    // Scalar value of the current entry.
+    EIGEN_STRONG_INLINE Scalar value() const { return m_valuePtr[m_pos[m_active]]; }
+
+   private:
+    // Find the sub-iterator with the smallest inner index.
+    void advance() {
+      m_valid = false;
+      for (int k = 0; k < BlockOuterSize_; ++k) {
+        if (m_pos[k] < m_outerPtr[m_outerBase + k + 1]) {
+          if (!m_valid || m_innerPtr[m_pos[k]] < m_innerPtr[m_pos[m_active]]) {
+            m_active = k;
+            m_valid = true;
+          }
+        }
+      }
+    }
+
+    const StorageIndex* m_outerPtr;
+    const StorageIndex* m_innerPtr;
+    const Scalar* m_valuePtr;
+    Index m_outerBase;
+    StorageIndex m_pos[BlockOuterSize_];
+    int m_active = 0;
+    bool m_valid = false;
+  };
+
+  // Allow other instantiations of BlockSparseMatrix to access private members
+  // (needed by operator*).
+  template <typename, int, int, int, typename>
+  friend class BlockSparseMatrix;
+  template <typename, int, bool>
+  friend class BlockSparseTriangularView;
+  template <typename, int, bool>
+  friend class BlockSparseSelfAdjointView;
+};
+
+// =============================================================================
+// Out-of-line method definitions
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+// setFromTriplets
+// -----------------------------------------------------------------------------
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+template <typename InputIterator>
+void BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::setFromTriplets(InputIterator begin,
+                                                                                                  InputIterator end) {
+  Index n = static_cast<Index>(std::distance(begin, end));
+
+  // Copy triplet coordinates and block values into Eigen arrays.
+  Array<StorageIndex, Dynamic, 1> tOuter(n), tInner(n);
+  Array<Scalar, Dynamic, 1> tValues(n * BlockSize);
+
+  Index k = 0;
+  for (InputIterator it = begin; it != end; ++it, ++k) {
+    eigen_assert(it->row() >= 0 && it->row() < blockRows() && "setFromTriplets: block row out of range");
+    eigen_assert(it->col() >= 0 && it->col() < blockCols() && "setFromTriplets: block col out of range");
+    tOuter(k) = IsRowMajor ? StorageIndex(it->row()) : StorageIndex(it->col());
+    tInner(k) = IsRowMajor ? StorageIndex(it->col()) : StorageIndex(it->row());
+    BlockMap(tValues.data() + k * BlockSize) = it->value();
+  }
+
+  // Order the triplet indices by (outer, inner) using a stable LSD radix sort:
+  // pass 1 buckets by inner, pass 2 by outer.  This runs in
+  // O(n + blockInnerSize + blockOuterSize) with sequential writes, avoiding the
+  // cache-unfriendly indirect comparison sort.
+  Array<Index, Dynamic, 1> order(n), scratch(n);
+  {
+    Array<Index, Dynamic, 1> count = Array<Index, Dynamic, 1>::Zero(m_blockInnerSize + 1);
+    for (Index i = 0; i < n; ++i) count(tInner(i) + 1)++;
+    for (Index i = 0; i < m_blockInnerSize; ++i) count(i + 1) += count(i);
+    for (Index i = 0; i < n; ++i) order(count(tInner(i))++) = i;
+  }
+  {
+    Array<Index, Dynamic, 1> count = Array<Index, Dynamic, 1>::Zero(m_blockOuterSize + 1);
+    for (Index i = 0; i < n; ++i) count(tOuter(i) + 1)++;
+    for (Index i = 0; i < m_blockOuterSize; ++i) count(i + 1) += count(i);
+    for (Index i = 0; i < n; ++i) {
+      Index idx = order(i);
+      scratch(count(tOuter(idx))++) = idx;
+    }
+    order.swap(scratch);
+  }
+
+  // Reset and pre-allocate (worst case: all n triplets are distinct blocks).
+  m_outerIndex.resize(m_blockOuterSize + 1);
+  m_outerIndex.setZero();
+  resizeBlockStorage_(n);
+
+  Index nnz = 0;
+  k = 0;
+  while (k < n) {
+    Index pi = order(k);
+    StorageIndex outer = tOuter(pi);
+    StorageIndex inner = tInner(pi);
+
+    BlockType block = ConstBlockMap(tValues.data() + pi * BlockSize);
+    ++k;
+
+    // Accumulate duplicate entries at the same (outer, inner) position.
+    while (k < n) {
+      Index pk = order(k);
+      if (tOuter(pk) != outer || tInner(pk) != inner) break;
+      block += ConstBlockMap(tValues.data() + pk * BlockSize);
+      ++k;
+    }
+
+    m_innerIndex(nnz) = inner;
+    blockRef(nnz) = block;
+    m_outerIndex(outer + 1)++;
+    ++nnz;
+  }
+
+  // Trim to actual number of unique blocks.
+  conservativeResizeBlockStorage_(nnz);
+
+  // Convert per-outer block counts to prefix sums.
+  for (Index j = 0; j < m_blockOuterSize; ++j) {
+    m_outerIndex(j + 1) += m_outerIndex(j);
+  }
+}
+
+// -----------------------------------------------------------------------------
+// toSparse
+// -----------------------------------------------------------------------------
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+SparseMatrix<Scalar_, Options_, StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::toSparse() const {
+  SparseMatrix<Scalar_, Options_, StorageIndex_> result(rows(), cols());
+  result.reserve(nonZeroBlocks() * BlockSize);
+
+  if (!IsRowMajor) {
+    // ColMajor: outer = block-column j.  Emit scalar columns j*BlockCols+c
+    // in order c = 0..BlockCols-1.  Within each scalar column, blocks are
+    // sorted by bi (block-row), so scalar rows bi*BlockRows+r are increasing.
+    for (Index j = 0; j < m_blockOuterSize; ++j) {
+      for (Index c = 0; c < BlockCols_; ++c) {
+        result.startVec(j * BlockCols_ + c);
+        for (Index id = m_outerIndex(j); id < m_outerIndex(j + 1); ++id) {
+          Index bi = m_innerIndex(id);
+          ConstBlockMap blk = blockRef(id);
+          for (Index r = 0; r < BlockRows_; ++r) {
+            result.insertBack(bi * BlockRows_ + r, j * BlockCols_ + c) = blk(r, c);
+          }
+        }
+      }
+    }
+  } else {
+    // RowMajor: outer = block-row bi.  Emit scalar rows bi*BlockRows+r
+    // in order r = 0..BlockRows-1.  Within each scalar row, blocks are
+    // sorted by j (block-col), so scalar cols j*BlockCols+c are increasing.
+    for (Index bi = 0; bi < m_blockOuterSize; ++bi) {
+      for (Index r = 0; r < BlockRows_; ++r) {
+        result.startVec(bi * BlockRows_ + r);
+        for (Index id = m_outerIndex(bi); id < m_outerIndex(bi + 1); ++id) {
+          Index j = m_innerIndex(id);
+          ConstBlockMap blk = blockRef(id);
+          for (Index c = 0; c < BlockCols_; ++c) {
+            result.insertBack(bi * BlockRows_ + r, j * BlockCols_ + c) = blk(r, c);
+          }
+        }
+      }
+    }
+  }
+
+  result.finalize();
+  return result;
+}
+
+// -----------------------------------------------------------------------------
+// fromSparse
+// -----------------------------------------------------------------------------
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::fromSparse(
+    const SparseMatrix<Scalar_, Options_, StorageIndex_>& sp) {
+  eigen_assert(sp.rows() % BlockRows_ == 0 && "matrix rows not divisible by BlockRows");
+  eigen_assert(sp.cols() % BlockCols_ == 0 && "matrix cols not divisible by BlockCols");
+  eigen_assert(sp.isCompressed() && "fromSparse requires a compressed SparseMatrix");
+
+  Index bRows = sp.rows() / BlockRows_;
+  Index bCols = sp.cols() / BlockCols_;
+
+  // BlockOuterSize: how many consecutive outer vectors form one block-outer strip.
+  // BlockInnerSize: the inner dimension of each block.
+  constexpr Index BlockOuterSize = IsRowMajor ? BlockRows_ : BlockCols_;
+  constexpr Index BlockInnerSize = IsRowMajor ? BlockCols_ : BlockRows_;
+  constexpr StorageIndex_ kEmptyIndex = -1;
+
+  using SpMat = SparseMatrix<Scalar_, Options_, StorageIndex_>;
+
+  BlockSparseMatrix result(bRows, bCols);
+
+  // Pass 1: count the number of unique block-inner indices per block-outer,
+  // by scanning each group of BlockOuterSize consecutive outer vectors together.
+  for (Index outerBlock = 0; outerBlock < result.m_blockOuterSize; ++outerBlock) {
+    StorageIndex_ prevInnerBlock = kEmptyIndex;
+    for (MultiInnerIterator<SpMat> it(sp, outerBlock * BlockOuterSize); it; ++it) {
+      StorageIndex_ innerBlock = it.index() / StorageIndex_(BlockInnerSize);
+      if (innerBlock != prevInnerBlock) {
+        result.m_outerIndex(outerBlock + 1)++;
+        prevInnerBlock = innerBlock;
+      }
+    }
+  }
+
+  // Prefix sum → result.m_outerIndex becomes the standard CSC/CSR outer pointer.
+  for (Index j = 0; j < result.m_blockOuterSize; ++j) result.m_outerIndex(j + 1) += result.m_outerIndex(j);
+
+  Index nBlocks = result.m_outerIndex(result.m_blockOuterSize);
+  result.resizeBlockStorage_(nBlocks);
+  result.m_values.setZero();
+
+  // Pass 2: scatter each scalar entry directly into its position within the
+  // pre-zeroed block value array.
+  for (Index outerBlock = 0; outerBlock < result.m_blockOuterSize; ++outerBlock) {
+    Index blockId = result.m_outerIndex(outerBlock) - 1;  // incremented on first new block
+    StorageIndex_ prevInnerBlock = kEmptyIndex;
+
+    for (MultiInnerIterator<SpMat> it(sp, outerBlock * BlockOuterSize); it; ++it) {
+      Index absOuter = it.outer();          // absolute outer index in sp
+      StorageIndex_ innerIdx = it.index();  // inner index in sp
+      StorageIndex_ innerBlock = innerIdx / StorageIndex_(BlockInnerSize);
+
+      if (innerBlock != prevInnerBlock) {
+        ++blockId;
+        result.m_innerIndex(blockId) = innerBlock;
+        prevInnerBlock = innerBlock;
+      }
+
+      // Scatter into block storage (layout matches the BSM's Options_).
+      // ColMajor blocks: col * BlockRows_ + row = localOuter * BlockInnerSize + localInner
+      // RowMajor blocks: row * BlockCols_ + col = localOuter * BlockInnerSize + localInner
+      Index localOuter = absOuter % BlockOuterSize;
+      Index localInner = innerIdx % BlockInnerSize;
+      Index offset = localOuter * BlockInnerSize + localInner;
+
+      result.m_values(blockId * BlockSize + offset) = it.value();
+    }
+  }
+
+  return result;
+}
+
+// -----------------------------------------------------------------------------
+// operator* (block-sparse product)
+// -----------------------------------------------------------------------------
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+template <int RhsBlockCols>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, RhsBlockCols, StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::operator*(
+    const BlockSparseMatrix<Scalar_, Options_, BlockCols_, RhsBlockCols, StorageIndex_>& rhs) const {
+  using RhsMatrix = BlockSparseMatrix<Scalar_, Options_, BlockCols_, RhsBlockCols, StorageIndex_>;
+  using ResultMatrix = BlockSparseMatrix<Scalar_, Options_, BlockRows_, RhsBlockCols, StorageIndex_>;
+  using ResultBlock = Matrix<Scalar_, BlockRows_, RhsBlockCols, Options_>;
+  constexpr int ResultBlockSize = BlockRows_ * RhsBlockCols;
+
+  eigen_assert(blockCols() == rhs.blockRows() && "BlockSparseMatrix product: lhs.blockCols() != rhs.blockRows()");
+
+  Index cBlockRows = blockRows();
+  Index cBlockCols = rhs.blockCols();
+  ResultMatrix result(cBlockRows, cBlockCols);
+
+  // For ColMajor: mask / accum indexed by block-row (size = cBlockRows).
+  // For RowMajor: mask / accum indexed by block-col (size = cBlockCols).
+  Index maskSize = IsRowMajor ? cBlockCols : cBlockRows;
+  Array<uint8_t, Dynamic, 1> mask = Array<uint8_t, Dynamic, 1>::Zero(maskSize);
+  Array<Scalar_, Dynamic, 1> accumData(maskSize * ResultBlockSize);
+  Array<Index, Dynamic, 1> indices(maskSize);
+  Index nIndices = 0;
+  // The mask is read and written through coeff/coeffRef below: the block indices
+  // are in range by construction, and operator()'s bounds check gives GCC 14+ a
+  // false -Wstringop-overflow on a negative StorageIndex_.
+
+  // Grow result storage geometrically rather than pre-allocating the dense
+  // worst case (cBlockRows*cBlockCols blocks): the product is typically far
+  // sparser than that, so the dense bound would blow up peak memory.
+  // capacity is always kept <= maxResultNnz (the true upper bound), and since
+  // any single outer emits at most maskSize blocks, the initial estimate of
+  // maskSize guarantees the first outer fits before the first grow check.
+  Index cOuterSize = result.m_blockOuterSize;
+  Index maxResultNnz = cBlockRows * cBlockCols;
+  Index capacity = numext::mini(maxResultNnz, numext::maxi(maskSize, nonZeroBlocks() + rhs.nonZeroBlocks()));
+  result.resizeBlockStorage_(capacity);
+  Index nnz = 0;
+
+  for (Index out = 0; out < cOuterSize; ++out) {
+    result.m_outerIndex(out) = StorageIndex_(nnz);
+
+    if (!IsRowMajor) {
+      // ColMajor: out is block-column j of the result.
+      // For each block B(k,j) and each block A(bi,k): C(bi,j) += A(bi,k)*B(k,j).
+      Index j = out;
+      for (Index rhsId = rhs.m_outerIndex(j); rhsId < rhs.m_outerIndex(j + 1); ++rhsId) {
+        Index k = rhs.m_innerIndex(rhsId);
+        typename RhsMatrix::ConstBlockMap Bkj = rhs.blockRef(rhsId);
+        for (Index lhsId = m_outerIndex(k); lhsId < m_outerIndex(k + 1); ++lhsId) {
+          Index bi = m_innerIndex(lhsId);
+          if (!mask.coeff(bi)) {
+            mask.coeffRef(bi) = 1;
+            Map<ResultBlock>(accumData.data() + bi * ResultBlockSize).noalias() = blockRef(lhsId) * Bkj;
+            indices(nIndices++) = bi;
+          } else {
+            Map<ResultBlock>(accumData.data() + bi * ResultBlockSize).noalias() += blockRef(lhsId) * Bkj;
+          }
+        }
+      }
+    } else {
+      // RowMajor: out is block-row bi of the result.
+      // For each block A(bi,k) and each block B(k,j): C(bi,j) += A(bi,k)*B(k,j).
+      Index bi = out;
+      for (Index lhsId = m_outerIndex(bi); lhsId < m_outerIndex(bi + 1); ++lhsId) {
+        Index k = m_innerIndex(lhsId);
+        ConstBlockMap Aik = blockRef(lhsId);
+        for (Index rhsId = rhs.m_outerIndex(k); rhsId < rhs.m_outerIndex(k + 1); ++rhsId) {
+          Index j = rhs.m_innerIndex(rhsId);
+          if (!mask.coeff(j)) {
+            mask.coeffRef(j) = 1;
+            Map<ResultBlock>(accumData.data() + j * ResultBlockSize).noalias() = Aik * rhs.blockRef(rhsId);
+            indices(nIndices++) = j;
+          } else {
+            Map<ResultBlock>(accumData.data() + j * ResultBlockSize).noalias() += Aik * rhs.blockRef(rhsId);
+          }
+        }
+      }
+    }
+
+    // Sort the accumulated indices so the result's inner index array is sorted.
+    std::sort(indices.data(), indices.data() + nIndices);
+    if (nnz + nIndices > capacity) {
+      capacity = numext::mini(maxResultNnz, numext::maxi(2 * capacity, nnz + nIndices));
+      result.conservativeResizeBlockStorage_(capacity);
+    }
+    for (Index ki = 0; ki < nIndices; ++ki) {
+      Index idx = indices(ki);
+      result.m_innerIndex(nnz) = StorageIndex_(idx);
+      result.blockRef(nnz) = Map<ResultBlock>(accumData.data() + idx * ResultBlockSize);
+      mask.coeffRef(idx) = 0;
+      ++nnz;
+    }
+    nIndices = 0;
+  }
+  result.m_outerIndex(cOuterSize) = StorageIndex_(nnz);
+
+  // Trim to actual number of result blocks.
+  result.conservativeResizeBlockStorage_(nnz);
+
+  return result;
+}
+
+// =============================================================================
+// BlockSparseTriangularView
+// =============================================================================
+
+/** \class BlockSparseTriangularView
+ * \ingroup SparseCore_Module
+ * \brief Lazy block-level triangular view of a BlockSparseMatrix.
+ *
+ * Obtained via \c BSM::triangularView<Mode>() or
+ * \c BSM::triangularView<Mode, true>() (the latter asserts that the unused
+ * triangle of every diagonal block is already zero, enabling faster vectorised
+ * products without an explicit triangularView on the block).
+ *
+ * By default (\p DiagIsTriangular = \c false) diagonal blocks are treated as
+ * triangular regardless of what is stored in the unused half: products call
+ * \c block.triangularView<DiagMode>() and \c eval() zeroes the unused
+ * triangle.  Set \p DiagIsTriangular = \c true to skip that overhead when you
+ * can guarantee the unused triangle is already zero.
+ */
+template <typename BSM, int Mode, bool DiagIsTriangular = false>
+class BlockSparseTriangularView {
+ public:
+  using Scalar = typename BSM::Scalar;
+  using StorageIndex = typename BSM::StorageIndex;
+  using BlockType = typename BSM::BlockType;
+  using BlockMap = typename BSM::BlockMap;
+  using ConstBlockMap = typename BSM::ConstBlockMap;
+  static constexpr int BlockRows = BSM::BlockRows;
+  static constexpr int BlockCols = BSM::BlockCols;
+  static constexpr int BlockSize = BSM::BlockSize;
+  static constexpr bool IsRowMajor = BSM::IsRowMajor;
+  static constexpr bool IsUpper = (Mode & Upper) != 0;
+
+  explicit BlockSparseTriangularView(const BSM& m) : m_matrix(m) {}
+
+  Index rows() const { return m_matrix.rows(); }
+  Index cols() const { return m_matrix.cols(); }
+
+  // ---- Materialize ---------------------------------------------------------
+
+  /** Copy the triangular blocks into a new BSM; off-triangle blocks are dropped.
+   *  When DiagIsTriangular is false the unused triangle of each diagonal block
+   *  is explicitly zeroed in the output. */
+  BSM eval() const {
+    constexpr int ZeroMode = IsUpper ? StrictlyLower : StrictlyUpper;
+    const BSM& m = m_matrix;
+    BSM result(m.blockRows(), m.blockCols());
+    result.resizeBlockStorage_(m.nonZeroBlocks());
+    Index nnz = 0;
+
+    for (Index out = 0; out < m.m_blockOuterSize; ++out) {
+      result.m_outerIndex(out) = StorageIndex(nnz);
+      for (Index id = m.m_outerIndex(out); id < m.m_outerIndex(out + 1); ++id) {
+        Index inner = m.m_innerIndex(id);
+        Index bi = IsRowMajor ? out : inner;
+        Index bj = IsRowMajor ? inner : out;
+        if (IsUpper ? (bj < bi) : (bj > bi)) continue;
+        result.m_innerIndex(nnz) = StorageIndex(inner);
+        result.m_values.template segment<BlockSize>(nnz * BlockSize) =
+            m.m_values.template segment<BlockSize>(id * BlockSize);
+        EIGEN_IF_CONSTEXPR (!DiagIsTriangular) {
+          if (bi == bj)
+            BlockMap(result.m_values.data() + nnz * BlockSize).template triangularView<ZeroMode>().setZero();
+        }
+        ++nnz;
+      }
+    }
+    result.m_outerIndex(m.m_blockOuterSize) = StorageIndex(nnz);
+    result.conservativeResizeBlockStorage_(nnz);
+    return result;
+  }
+
+  /** Convert to a scalar-level SparseMatrix (off-triangle blocks zeroed). */
+  SparseMatrix<Scalar, BSM::Options, StorageIndex> toSparse() const { return eval().toSparse(); }
+
+  // ---- Arithmetic ----------------------------------------------------------
+
+  BSM operator+(const BlockSparseTriangularView& other) const { return eval() + other.eval(); }
+  BSM operator-(const BlockSparseTriangularView& other) const { return eval() - other.eval(); }
+
+  /** Tri × BSM product (materialises this view then delegates). */
+  template <int RhsBlockCols>
+  BlockSparseMatrix<Scalar, BSM::Options, BlockRows, RhsBlockCols, StorageIndex> operator*(
+      const BlockSparseMatrix<Scalar, BSM::Options, BlockCols, RhsBlockCols, StorageIndex>& rhs) const {
+    return eval() * rhs;
+  }
+
+  // ---- Dense products (no intermediate materialisation) --------------------
+
+  template <typename OtherDerived>
+  Matrix<Scalar, Dynamic, OtherDerived::ColsAtCompileTime> operator*(const MatrixBase<OtherDerived>& rhs) const {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    eigen_assert(m_matrix.cols() == rhs.rows() && "BlockSparseTriangularView * Dense: dimension mismatch");
+    using ResultType = Matrix<Scalar, Dynamic, OtherDerived::ColsAtCompileTime>;
+    ResultType result = ResultType::Zero(m_matrix.rows(), rhs.cols());
+    for (Index out = 0; out < m_matrix.m_blockOuterSize; ++out) {
+      for (Index id = m_matrix.m_outerIndex(out); id < m_matrix.m_outerIndex(out + 1); ++id) {
+        Index inner = m_matrix.m_innerIndex(id);
+        Index bi = IsRowMajor ? out : inner;
+        Index bj = IsRowMajor ? inner : out;
+        if (IsUpper ? (bj < bi) : (bj > bi)) continue;
+        constexpr int DiagMode = IsUpper ? Upper : Lower;
+        if (!DiagIsTriangular && bi == bj)
+          result.template middleRows<BlockRows>(bi * BlockRows).noalias() +=
+              m_matrix.blockRef(id).template triangularView<DiagMode>() *
+              rhs.template middleRows<BlockCols>(bj * BlockCols);
+        else
+          result.template middleRows<BlockRows>(bi * BlockRows).noalias() +=
+              m_matrix.blockRef(id) * rhs.template middleRows<BlockCols>(bj * BlockCols);
+      }
+    }
+    return result;
+  }
+
+  template <typename OtherDerived>
+  friend Matrix<Scalar, OtherDerived::RowsAtCompileTime, Dynamic> operator*(const MatrixBase<OtherDerived>& lhs,
+                                                                            const BlockSparseTriangularView& tri) {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    eigen_assert(lhs.cols() == tri.m_matrix.rows() && "Dense * BlockSparseTriangularView: dimension mismatch");
+    constexpr bool isRM = BSM::IsRowMajor;
+    using ResultType = Matrix<Scalar, OtherDerived::RowsAtCompileTime, Dynamic>;
+    // BSM befriends BlockSparseTriangularView, but GCC <= 11 and MSVC do not
+    // extend that friendship to the body of a friend function defined inside
+    // the view (CWG 1699), so only BSM's public interface may be used here.
+    const BSM& m = tri.m_matrix;
+    const StorageIndex* outerPtr = m.outerIndexPtr();
+    const StorageIndex* innerPtr = m.innerIndexPtr();
+    ResultType result = ResultType::Zero(lhs.rows(), m.cols());
+    for (Index out = 0; out < m.blockOuterSize(); ++out) {
+      for (Index id = outerPtr[out]; id < outerPtr[out + 1]; ++id) {
+        Index inner = innerPtr[id];
+        Index bi = isRM ? out : inner;
+        Index bj = isRM ? inner : out;
+        if (IsUpper ? (bj < bi) : (bj > bi)) continue;
+        constexpr int DiagMode = IsUpper ? Upper : Lower;
+        if (!DiagIsTriangular && bi == bj)
+          result.template middleCols<BlockCols>(bj * BlockCols).noalias() +=
+              lhs.template middleCols<BlockRows>(bi * BlockRows) * m.blockRef(id).template triangularView<DiagMode>();
+        else
+          result.template middleCols<BlockCols>(bj * BlockCols).noalias() +=
+              lhs.template middleCols<BlockRows>(bi * BlockRows) * m.blockRef(id);
+      }
+    }
+    return result;
+  }
+
+  // ---- Triangular solve -------------------------------------------------------
+
+  /** Solve T * x = rhs in-place. Requires square blocks.
+   *  ColMajor Lower: forward sub, diagonal first per column.
+   *  ColMajor Upper: backward sub, diagonal last per column.
+   *  RowMajor Lower: forward sub, diagonal last per row.
+   *  RowMajor Upper: backward sub, diagonal first per row.
+   */
+  template <typename Derived>
+  void solveInPlace(MatrixBase<Derived>& x) const {
+    doSolveImpl<false, false>(x.derived());
+  }
+
+  /** Proxy returned by transpose(): solveInPlace solves T^T x = b. */
+  struct TransposeReturnType {
+    const BlockSparseTriangularView& m_tri;
+    template <typename Derived>
+    void solveInPlace(MatrixBase<Derived>& x) const {
+      m_tri.template doSolveImpl<true, false>(x.derived());
+    }
+  };
+
+  /** Proxy returned by adjoint(): solveInPlace solves T^H x = b. */
+  struct AdjointReturnType {
+    const BlockSparseTriangularView& m_tri;
+    template <typename Derived>
+    void solveInPlace(MatrixBase<Derived>& x) const {
+      m_tri.template doSolveImpl<true, true>(x.derived());
+    }
+  };
+
+  TransposeReturnType transpose() const { return {*this}; }
+  AdjointReturnType adjoint() const { return {*this}; }
+
+ private:
+  const BSM& m_matrix;
+
+  // Non-transposed solve for both storage orders.
+  //
+  // diagFirst = (IsUpper == IsRowMajor): ColMajor Lower→first, ColMajor Upper→last,
+  //                                      RowMajor Lower→last,  RowMajor Upper→first.
+  // Loop direction: forward for Lower, backward for Upper (same for both storage orders).
+  // ColMajor: solve diagonal first, then scatter  x[inner] -= blk * x[k].
+  // RowMajor: gather x[k] -= blk * x[inner] first, then solve diagonal.
+  template <typename Derived>
+  void doSolveDirect(Derived& x) const {
+    EIGEN_STATIC_ASSERT(BlockRows == BlockCols, THIS_METHOD_IS_ONLY_FOR_SQUARE_BLOCK_MATRICES)
+    constexpr int DiagMode = IsUpper ? Upper : Lower;
+    constexpr bool diagFirst = (IsUpper == BSM::IsRowMajor);
+    Index nb = m_matrix.blockCols();  // == blockRows() for square matrices
+    eigen_assert(x.rows() == m_matrix.rows() && "solveInPlace: size mismatch");
+
+    const StorageIndex* innerPtr = m_matrix.innerIndexPtr();
+    const StorageIndex* outerPtr = m_matrix.outerIndexPtr();
+
+    Index outerStart = IsUpper ? nb - 1 : 0;
+    Index outerEnd = IsUpper ? -1 : nb;
+    constexpr Index kStep = IsUpper ? -1 : 1;
+
+    for (Index k = outerStart; k != outerEnd; k += kStep) {
+      const StorageIndex* beg = innerPtr + outerPtr[k];
+      const StorageIndex* end = innerPtr + outerPtr[k + 1];
+      if (beg == end) continue;
+      const StorageIndex* diag_ptr = diagFirst ? beg : end - 1;
+      const StorageIndex* off_beg = diagFirst ? beg + 1 : beg;
+      const StorageIndex* off_end = diagFirst ? end : end - 1;
+      eigen_assert(*diag_ptr == k);
+      EIGEN_IF_CONSTEXPR (!BSM::IsRowMajor) {
+        m_matrix.blockRef(diag_ptr - innerPtr)
+            .template triangularView<DiagMode>()
+            .solveInPlace(x.template middleRows<BlockRows>(k * BlockRows));
+        for (const StorageIndex* it = off_beg; it != off_end; ++it)
+          x.template middleRows<BlockRows>(*it * BlockRows).noalias() -=
+              m_matrix.blockRef(it - innerPtr) * x.template middleRows<BlockRows>(k * BlockRows);
+      } else {
+        for (const StorageIndex* it = off_beg; it != off_end; ++it)
+          x.template middleRows<BlockRows>(k * BlockRows).noalias() -=
+              m_matrix.blockRef(it - innerPtr) * x.template middleRows<BlockRows>(*it * BlockRows);
+        m_matrix.blockRef(diag_ptr - innerPtr)
+            .template triangularView<DiagMode>()
+            .solveInPlace(x.template middleRows<BlockRows>(k * BlockRows));
+      }
+    }
+  }
+
+  // Transposed/adjoint solve for both storage orders.
+  //
+  // Loop direction: forward for Upper, backward for Lower (same for both storage orders).
+  // ColMajor: gather x[k] -= adj(blk) * x[inner] first, then solve adj(diagonal).
+  // RowMajor: solve adj(diagonal) first, then scatter x[inner] -= adj(blk) * x[k].
+  template <bool Conjugate, typename Derived>
+  void doSolveTransposed(Derived& x) const {
+    EIGEN_STATIC_ASSERT(BlockRows == BlockCols, THIS_METHOD_IS_ONLY_FOR_SQUARE_BLOCK_MATRICES)
+    constexpr int DiagMode = IsUpper ? Upper : Lower;
+    constexpr bool diagFirst = (IsUpper == BSM::IsRowMajor);
+    Index nb = m_matrix.blockCols();  // == blockRows() for square matrices
+    eigen_assert(x.rows() == m_matrix.rows() && "solveInPlace: size mismatch");
+
+    const StorageIndex* innerPtr = m_matrix.innerIndexPtr();
+    const StorageIndex* outerPtr = m_matrix.outerIndexPtr();
+
+    Index outerStart = IsUpper ? 0 : nb - 1;
+    Index outerEnd = IsUpper ? nb : -1;
+    constexpr Index kStep = IsUpper ? 1 : -1;
+
+    for (Index k = outerStart; k != outerEnd; k += kStep) {
+      const StorageIndex* beg = innerPtr + outerPtr[k];
+      const StorageIndex* end = innerPtr + outerPtr[k + 1];
+      if (beg == end) continue;
+      const StorageIndex* diag_ptr = diagFirst ? beg : end - 1;
+      const StorageIndex* off_beg = diagFirst ? beg + 1 : beg;
+      const StorageIndex* off_end = diagFirst ? end : end - 1;
+      eigen_assert(*diag_ptr == k);
+      EIGEN_IF_CONSTEXPR (!BSM::IsRowMajor) {
+        for (const StorageIndex* it = off_beg; it != off_end; ++it)
+          x.template middleRows<BlockRows>(k * BlockRows).noalias() -=
+              internal::adjoint_if<Conjugate>(m_matrix.blockRef(it - innerPtr)) *
+              x.template middleRows<BlockRows>(*it * BlockRows);
+        internal::adjoint_if<Conjugate>(m_matrix.blockRef(diag_ptr - innerPtr).template triangularView<DiagMode>())
+            .solveInPlace(x.template middleRows<BlockRows>(k * BlockRows));
+      } else {
+        internal::adjoint_if<Conjugate>(m_matrix.blockRef(diag_ptr - innerPtr).template triangularView<DiagMode>())
+            .solveInPlace(x.template middleRows<BlockRows>(k * BlockRows));
+        for (const StorageIndex* it = off_beg; it != off_end; ++it)
+          x.template middleRows<BlockRows>(*it * BlockRows).noalias() -=
+              internal::adjoint_if<Conjugate>(m_matrix.blockRef(it - innerPtr)) *
+              x.template middleRows<BlockRows>(k * BlockRows);
+      }
+    }
+  }
+
+  template <bool Transposed, bool Conjugate, typename Derived>
+  void doSolveImpl(Derived& x) const {
+    EIGEN_IF_CONSTEXPR (!Transposed)
+      doSolveDirect(x);
+    else
+      doSolveTransposed<Conjugate>(x);
+  }
+};
+
+// =============================================================================
+// BlockSparseSelfAdjointView
+// =============================================================================
+
+/** \class BlockSparseSelfAdjointView
+ * \ingroup SparseCore_Module
+ * \brief Lazy block-level self-adjoint (Hermitian) view of a BlockSparseMatrix.
+ *
+ * Obtained via \c BSM::selfadjointView<UpLo>() or
+ * \c BSM::selfadjointView<UpLo, true>() (the latter signals that every
+ * diagonal block is itself Hermitian, enabling DSYMM/ZHEMM on those blocks).
+ *
+ * Only the triangle selected by \p UpLo is read; the other triangle is
+ * reconstructed on-the-fly as the adjoint of each stored off-diagonal block.
+ *
+ * \pre BSM::BlockRows == BSM::BlockCols.
+ */
+template <typename BSM, int UpLo, bool DiagIsSelfAdjoint>
+class BlockSparseSelfAdjointView {
+ public:
+  using Scalar = typename BSM::Scalar;
+  using StorageIndex = typename BSM::StorageIndex;
+  using BlockType = typename BSM::BlockType;
+  using BlockMap = typename BSM::BlockMap;
+  using ConstBlockMap = typename BSM::ConstBlockMap;
+  static constexpr int BlockRows = BSM::BlockRows;  // == BlockCols
+  static constexpr int BlockCols = BSM::BlockCols;
+  static constexpr int BlockSize = BSM::BlockSize;
+  static constexpr bool IsRowMajor = BSM::IsRowMajor;
+  static constexpr bool IsUpper = (UpLo & Upper) != 0;
+  // UpLo passed to Eigen's dense selfadjointView on diagonal blocks:
+  static constexpr int DiagUpLo = IsUpper ? Upper : Lower;
+
+  explicit BlockSparseSelfAdjointView(const BSM& m) : m_matrix(m) {}
+
+  Index rows() const { return m_matrix.rows(); }
+  Index cols() const { return m_matrix.cols(); }
+
+  // ---- Materialize ---------------------------------------------------------
+
+  /** Build a full symmetric BSM: stored triangle + adjoint mirror of each
+   *  off-diagonal block.  Diagonal blocks: when DiagIsSelfAdjoint is false,
+   *  both triangles are filled from the stored triangle via selfadjointView;
+   *  when true the block is already fully populated and is copied as-is. */
+  BSM eval() const {
+    const BSM& m = m_matrix;
+
+    Index nDiag = 0, nOff = 0;
+    for (Index out = 0; out < m.m_blockOuterSize; ++out)
+      for (Index id = m.m_outerIndex(out); id < m.m_outerIndex(out + 1); ++id) {
+        Index inner = m.m_innerIndex(id);
+        Index bi = IsRowMajor ? out : inner;
+        Index bj = IsRowMajor ? inner : out;
+        if (IsUpper ? (bj < bi) : (bj > bi)) continue;
+        if (bi == bj)
+          ++nDiag;
+        else
+          ++nOff;
+      }
+
+    Index nTotal = nDiag + 2 * nOff;
+
+    Array<StorageIndex, Dynamic, 1> brows(nTotal), bcols(nTotal);
+    Array<Scalar, Dynamic, 1> bvals(nTotal * BlockSize);
+
+    Index k = 0;
+    for (Index out = 0; out < m.m_blockOuterSize; ++out)
+      for (Index id = m.m_outerIndex(out); id < m.m_outerIndex(out + 1); ++id) {
+        Index inner = m.m_innerIndex(id);
+        Index bi = IsRowMajor ? out : inner;
+        Index bj = IsRowMajor ? inner : out;
+        if (IsUpper ? (bj < bi) : (bj > bi)) continue;
+
+        brows(k) = StorageIndex(bi);
+        bcols(k) = StorageIndex(bj);
+        if (!DiagIsSelfAdjoint && bi == bj)
+          BlockMap(bvals.data() + k * BlockSize) = m.blockRef(id).template selfadjointView<DiagUpLo>();
+        else
+          BlockMap(bvals.data() + k * BlockSize) = m.blockRef(id);
+        ++k;
+
+        if (bi != bj) {
+          brows(k) = StorageIndex(bj);
+          bcols(k) = StorageIndex(bi);
+          BlockMap(bvals.data() + k * BlockSize) = m.blockRef(id).adjoint();
+          ++k;
+        }
+      }
+
+    // Sort by (outer, inner) then build BSM directly (no duplicates by construction).
+    Array<Index, Dynamic, 1> perm(nTotal);
+    std::iota(perm.data(), perm.data() + nTotal, Index(0));
+    std::sort(perm.data(), perm.data() + nTotal, [&](Index a, Index b) {
+      StorageIndex ao = IsRowMajor ? brows(a) : bcols(a);
+      StorageIndex bo = IsRowMajor ? brows(b) : bcols(b);
+      if (ao != bo) return ao < bo;
+      return (IsRowMajor ? bcols(a) : brows(a)) < (IsRowMajor ? bcols(b) : brows(b));
+    });
+
+    BSM result(m.blockRows(), m.blockCols());
+    result.resizeBlockStorage_(nTotal);
+
+    for (Index ki = 0; ki < nTotal; ++ki) {
+      Index pi = perm(ki);
+      StorageIndex outer = IsRowMajor ? brows(pi) : bcols(pi);
+      StorageIndex inner = IsRowMajor ? bcols(pi) : brows(pi);
+      result.m_outerIndex(outer + 1)++;
+      result.m_innerIndex(ki) = inner;
+      result.m_values.template segment<BlockSize>(ki * BlockSize) = bvals.template segment<BlockSize>(pi * BlockSize);
+    }
+    for (Index j = 0; j < result.m_blockOuterSize; ++j) result.m_outerIndex(j + 1) += result.m_outerIndex(j);
+
+    return result;
+  }
+
+  /** Convert to a symmetrised scalar-level SparseMatrix. */
+  SparseMatrix<Scalar, BSM::Options, StorageIndex> toSparse() const { return eval().toSparse(); }
+
+  // ---- Arithmetic ----------------------------------------------------------
+
+  BSM operator+(const BlockSparseSelfAdjointView& other) const { return eval() + other.eval(); }
+  BSM operator-(const BlockSparseSelfAdjointView& other) const { return eval() - other.eval(); }
+
+  /** SelfAdj × BSM: materialises the view then uses the general SpGEMM. */
+  template <int RhsBlockCols>
+  BlockSparseMatrix<Scalar, BSM::Options, BlockRows, RhsBlockCols, StorageIndex> operator*(
+      const BlockSparseMatrix<Scalar, BSM::Options, BlockCols, RhsBlockCols, StorageIndex>& rhs) const {
+    return eval() * rhs;
+  }
+
+  // ---- Dense products (no materialisation; exploits both triangles) ---------
+
+  /** SelfAdj × Dense.
+   *
+   *  Off-diagonal stored block A(bi,bj) contributes:
+   *    result(bi) += A(bi,bj) * rhs(bj)        [stored triangle]
+   *    result(bj) += A(bi,bj)^H * rhs(bi)      [implicit mirror]
+   *
+   *  When DiagIsSelfAdjoint is true, both triangles of each diagonal block
+   *  are valid; a plain product is used (faster for small fixed-size blocks).
+   *  Otherwise only the UpLo triangle is assumed valid and selfadjointView
+   *  reconstructs the full diagonal-block product.
+   */
+  template <typename OtherDerived>
+  Matrix<Scalar, Dynamic, OtherDerived::ColsAtCompileTime> operator*(const MatrixBase<OtherDerived>& rhs) const {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    eigen_assert(m_matrix.cols() == rhs.rows() && "BlockSparseSelfAdjointView * Dense: dimension mismatch");
+    using ResultType = Matrix<Scalar, Dynamic, OtherDerived::ColsAtCompileTime>;
+    ResultType result = ResultType::Zero(m_matrix.rows(), rhs.cols());
+
+    for (Index out = 0; out < m_matrix.m_blockOuterSize; ++out)
+      for (Index id = m_matrix.m_outerIndex(out); id < m_matrix.m_outerIndex(out + 1); ++id) {
+        Index inner = m_matrix.m_innerIndex(id);
+        Index bi = IsRowMajor ? out : inner;
+        Index bj = IsRowMajor ? inner : out;
+        if (IsUpper ? (bj < bi) : (bj > bi)) continue;
+
+        if (bi == bj) {
+          EIGEN_IF_CONSTEXPR (DiagIsSelfAdjoint) {
+            result.template middleRows<BlockRows>(bi * BlockRows).noalias() +=
+                m_matrix.blockRef(id) * rhs.template middleRows<BlockCols>(bj * BlockCols);
+          } else {
+            // Materialize the tiny diagonal block as a fixed-size Hermitian matrix, then use the
+            // ordinary (coeff-based for a vector rhs) product.  This avoids the runtime-sized,
+            // EIGEN_DONT_INLINE selfadjoint_matrix_vector_product kernel, which is tuned for large
+            // matrices and is pure overhead for a 2-4 row block.
+            BlockType diag = m_matrix.blockRef(id).template selfadjointView<DiagUpLo>();
+            result.template middleRows<BlockRows>(bi * BlockRows).noalias() +=
+                diag * rhs.template middleRows<BlockCols>(bj * BlockCols);
+          }
+        } else {
+          result.template middleRows<BlockRows>(bi * BlockRows).noalias() +=
+              m_matrix.blockRef(id) * rhs.template middleRows<BlockCols>(bj * BlockCols);
+          result.template middleRows<BlockRows>(bj * BlockRows).noalias() +=
+              m_matrix.blockRef(id).adjoint() * rhs.template middleRows<BlockRows>(bi * BlockRows);
+        }
+      }
+    return result;
+  }
+
+  /** Dense × SelfAdj:  lhs * A == (A^H * lhs^H)^H == (A * lhs^H)^H for Hermitian A. */
+  template <typename OtherDerived>
+  friend Matrix<Scalar, OtherDerived::RowsAtCompileTime, Dynamic> operator*(const MatrixBase<OtherDerived>& lhs,
+                                                                            const BlockSparseSelfAdjointView& view) {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    return (view * lhs.adjoint()).adjoint();
+  }
+
+ private:
+  const BSM& m_matrix;
+};
+
+// =============================================================================
+// BlockSparseMatrix::transposeImpl / transpose / adjoint (out-of-line)
+// =============================================================================
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+template <bool Conjugate>
+BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::transposeImpl() const {
+  using ResultType = BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_>;
+  ResultType result(blockCols(), blockRows());
+
+  // Count entries per new outer (= old inner).
+  for (Index id = 0; id < nonZeroBlocks(); ++id) result.m_outerIndex(m_innerIndex(id) + 1)++;
+
+  // Prefix sum.
+  for (Index j = 0; j < result.m_blockOuterSize; ++j) result.m_outerIndex(j + 1) += result.m_outerIndex(j);
+
+  Index nnz = nonZeroBlocks();
+  result.resizeBlockStorage_(nnz);
+
+  // One insertion cursor per new outer; start at the prefix-sum boundary.
+  // Because we iterate oldOuter in increasing order, for each newOuter = oldInner
+  // the emitted newInner = oldOuter values are automatically sorted.
+  Array<StorageIndex_, Dynamic, 1> pos = result.m_outerIndex.head(result.m_blockOuterSize);
+
+  for (Index oldOuter = 0; oldOuter < m_blockOuterSize; ++oldOuter) {
+    for (Index id = m_outerIndex(oldOuter); id < m_outerIndex(oldOuter + 1); ++id) {
+      Index newOuter = m_innerIndex(id);
+      Index insertAt = pos(newOuter)++;
+      result.m_innerIndex(insertAt) = StorageIndex_(oldOuter);
+      result.blockRef(insertAt) = internal::adjoint_if<Conjugate>(blockRef(id));
+    }
+  }
+  return result;
+}
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::transpose() const {
+  return transposeImpl<false>();
+}
+
+template <typename Scalar_, int Options_, int BlockRows_, int BlockCols_, typename StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockCols_, BlockRows_, StorageIndex_>
+BlockSparseMatrix<Scalar_, Options_, BlockRows_, BlockCols_, StorageIndex_>::adjoint() const {
+  return transposeImpl<true>();
+}
+
+namespace internal {
+
+// ---------------------------------------------------------------------------
+// generic_product_impl: BlockSparse × Dense → Dense
+// Provides evalTo / addTo / subTo / scaleAndAddTo via generic_product_impl_base.
+// ---------------------------------------------------------------------------
+template <typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, BlockSparseShape, DenseShape, ProductType>
+    : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, BlockSparseShape, DenseShape, ProductType>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+
+  template <typename Dst>
+  static void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    constexpr bool IsRM = (Lhs::Options & RowMajorBit) != 0;
+    constexpr int BR = Lhs::BlockRows;
+    constexpr int BC = Lhs::BlockCols;
+    const typename Lhs::StorageIndex* outerPtr = lhs.outerIndexPtr();
+    const typename Lhs::StorageIndex* innerPtr = lhs.innerIndexPtr();
+    // Branch on alpha before the loop: alpha==1 and alpha==-1 avoid creating a
+    // CwiseUnaryOp<scalar_multiple, B×B_block>, which defeats SIMD for complex scalars.
+    bool a1 = (alpha == Scalar(1));
+    bool am1 = (alpha == Scalar(-1));
+    for (Eigen::Index out = 0; out < lhs.blockOuterSize(); ++out) {
+      for (Eigen::Index id = outerPtr[out]; id < outerPtr[out + 1]; ++id) {
+        Eigen::Index inner = innerPtr[id];
+        Eigen::Index bi = IsRM ? out : inner;
+        Eigen::Index bj = IsRM ? inner : out;
+        auto dst_seg = dst.template middleRows<BR>(bi * BR);
+        auto rhs_seg = rhs.template middleRows<BC>(bj * BC);
+        if (EIGEN_PREDICT_TRUE(a1))
+          dst_seg.noalias() += lhs.blockRef(id) * rhs_seg;
+        else if (am1)
+          dst_seg.noalias() -= lhs.blockRef(id) * rhs_seg;
+        else {
+          // Materialize block×rhs_seg into a small fixed-size stack buffer, then
+          // scale by alpha.  Keeps the B×B block as a plain Map for vectorization.
+          using TmpType = Matrix<Scalar, BR, Rhs::ColsAtCompileTime>;
+          TmpType tmp(BR, rhs.cols());
+          tmp.noalias() = lhs.blockRef(id) * rhs_seg;
+          dst_seg += alpha * tmp;
+        }
+      }
+    }
+  }
+};
+
+// ---------------------------------------------------------------------------
+// generic_product_impl: Dense × BlockSparse → Dense
+// ---------------------------------------------------------------------------
+template <typename Lhs, typename Rhs, int ProductType>
+struct generic_product_impl<Lhs, Rhs, DenseShape, BlockSparseShape, ProductType>
+    : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DenseShape, BlockSparseShape, ProductType>> {
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
+
+  template <typename Dst>
+  static void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
+    constexpr bool IsRM = (Rhs::Options & RowMajorBit) != 0;
+    constexpr int BR = Rhs::BlockRows;
+    constexpr int BC = Rhs::BlockCols;
+    const typename Rhs::StorageIndex* outerPtr = rhs.outerIndexPtr();
+    const typename Rhs::StorageIndex* innerPtr = rhs.innerIndexPtr();
+    bool a1 = (alpha == Scalar(1));
+    bool am1 = (alpha == Scalar(-1));
+    for (Eigen::Index out = 0; out < rhs.blockOuterSize(); ++out) {
+      for (Eigen::Index id = outerPtr[out]; id < outerPtr[out + 1]; ++id) {
+        Eigen::Index inner = innerPtr[id];
+        Eigen::Index bi = IsRM ? out : inner;
+        Eigen::Index bj = IsRM ? inner : out;
+        auto dst_seg = dst.template middleCols<BC>(bj * BC);
+        auto lhs_seg = lhs.template middleCols<BR>(bi * BR);
+        if (EIGEN_PREDICT_TRUE(a1))
+          dst_seg.noalias() += lhs_seg * rhs.blockRef(id);
+        else if (am1)
+          dst_seg.noalias() -= lhs_seg * rhs.blockRef(id);
+        else {
+          using TmpType = Matrix<Scalar, Lhs::RowsAtCompileTime, BC>;
+          TmpType tmp(lhs.rows(), BC);
+          tmp.noalias() = lhs_seg * rhs.blockRef(id);
+          dst_seg += alpha * tmp;
+        }
+      }
+    }
+  }
+};
+
+}  // namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BLOCKSPARSEMATRIX_H
diff --git a/Eigen/src/SparseCore/CompressedStorage.h b/Eigen/src/SparseCore/CompressedStorage.h
index 8f8a696..72ceaf2 100644
--- a/Eigen/src/SparseCore/CompressedStorage.h
+++ b/Eigen/src/SparseCore/CompressedStorage.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_COMPRESSED_STORAGE_H
 #define EIGEN_COMPRESSED_STORAGE_H
@@ -24,14 +25,10 @@
 template <typename Scalar_, typename StorageIndex_>
 class CompressedStorage {
  public:
-  typedef Scalar_ Scalar;
-  typedef StorageIndex_ StorageIndex;
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
 
- protected:
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
- public:
-  CompressedStorage() : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0) {}
+  CompressedStorage() = default;
 
   explicit CompressedStorage(Index size) : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0) { resize(size); }
 
@@ -72,10 +69,9 @@
   void resize(Index size, double reserveSizeFactor = 0) {
     if (m_allocatedSize < size) {
       // Avoid underflow on the std::min<Index> call by choosing the smaller index type.
-      using SmallerIndexType =
-          typename std::conditional<static_cast<size_t>((std::numeric_limits<Index>::max)()) <
-                                        static_cast<size_t>((std::numeric_limits<StorageIndex>::max)()),
-                                    Index, StorageIndex>::type;
+      using SmallerIndexType = std::conditional_t<static_cast<size_t>((std::numeric_limits<Index>::max)()) <
+                                                      static_cast<size_t>((std::numeric_limits<StorageIndex>::max)()),
+                                                  Index, StorageIndex>;
       Index realloc_size =
           (std::min<Index>)(NumTraits<SmallerIndexType>::highest(), size + Index(reserveSizeFactor * double(size)));
       if (realloc_size < size) internal::throw_std_bad_alloc();
@@ -193,10 +189,10 @@
   }
 
  protected:
-  Scalar* m_values;
-  StorageIndex* m_indices;
-  Index m_size;
-  Index m_allocatedSize;
+  Scalar* m_values = nullptr;
+  StorageIndex* m_indices = nullptr;
+  Index m_size = 0;
+  Index m_allocatedSize = 0;
 };
 
 }  // end namespace internal
diff --git a/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h b/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
index 2beadab..010e795 100644
--- a/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
+++ b/Eigen/src/SparseCore/ConservativeSparseSparseProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
 #define EIGEN_CONSERVATIVESPARSESPARSEPRODUCT_H
@@ -20,9 +21,9 @@
 template <typename Lhs, typename Rhs, typename ResultType>
 static void conservative_sparse_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res,
                                                     bool sortedInsertion = false) {
-  typedef typename remove_all_t<Lhs>::Scalar LhsScalar;
-  typedef typename remove_all_t<Rhs>::Scalar RhsScalar;
-  typedef typename remove_all_t<ResultType>::Scalar ResScalar;
+  using LhsScalar = typename remove_all_t<Lhs>::Scalar;
+  using RhsScalar = typename remove_all_t<Rhs>::Scalar;
+  using ResScalar = typename remove_all_t<ResultType>::Scalar;
 
   // make sure to call innerSize/outerSize since we fake the storage order.
   Index rows = lhs.innerSize();
@@ -33,7 +34,7 @@
   ei_declare_aligned_stack_constructed_variable(ResScalar, values, rows, 0);
   ei_declare_aligned_stack_constructed_variable(Index, indices, rows, 0);
 
-  std::memset(mask, 0, sizeof(bool) * rows);
+  std::fill_n(mask, rows, false);
 
   evaluator<Lhs> lhsEval(lhs);
   evaluator<Rhs> rhsEval(rhs);
@@ -79,8 +80,6 @@
       const Index t200 = rows / 11;  // 11 == (log2(200)*1.39)
       const Index t = (rows * 100) / 139;
 
-      // FIXME: reserve space for the expected number of non-zeros.
-      // FIXME: implement faster sorting for very small nnz counts.
       // if the result is sparse enough => use a quick sort
       // otherwise => loop through the entire vector
       // In order to avoid to perform an expensive log2 when the
@@ -106,10 +105,6 @@
   res.finalize();
 }
 
-}  // end namespace internal
-
-namespace internal {
-
 // Helper template to generate new sparse matrix types
 template <class Source, int Order>
 using WithStorageOrder = SparseMatrix<typename Source::Scalar, Order, typename Source::StorageIndex>;
@@ -122,16 +117,14 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct conservative_sparse_sparse_product_selector<Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor> {
-  typedef remove_all_t<Lhs> LhsCleaned;
-  typedef typename LhsCleaned::Scalar Scalar;
-
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) {
     using RowMajorMatrix = WithStorageOrder<ResultType, RowMajor>;
     using ColMajorMatrixAux = WithStorageOrder<ResultType, ColMajor>;
 
     // If the result is tall and thin (in the extreme case a column vector)
     // then it is faster to sort the coefficients inplace instead of transposing twice.
-    // FIXME: this heuristic has known limitations and should be improved.
+    // The dimension-only test here ignores nnz / per-column density; a proper
+    // cost model using estimated_nnz_prod would pick the right path more often.
     if (lhs.rows() > rhs.cols()) {
       using ColMajorMatrix = typename sparse_eval<ColMajorMatrixAux, ResultType::RowsAtCompileTime,
                                                   ResultType::ColsAtCompileTime, ColMajorMatrixAux::Flags>::type;
@@ -185,8 +178,6 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct conservative_sparse_sparse_product_selector<Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor> {
-  typedef typename traits<remove_all_t<Lhs>>::Scalar Scalar;
-
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) {
     using ColMajorRes = WithStorageOrder<ResultType, ColMajor>;
     ColMajorRes resCol(lhs.rows(), rhs.cols());
@@ -232,14 +223,10 @@
   }
 };
 
-}  // end namespace internal
-
-namespace internal {
-
 template <typename Lhs, typename Rhs, typename ResultType>
 static void sparse_sparse_to_dense_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res) {
-  typedef typename remove_all_t<Lhs>::Scalar LhsScalar;
-  typedef typename remove_all_t<Rhs>::Scalar RhsScalar;
+  using LhsScalar = typename remove_all_t<Lhs>::Scalar;
+  using RhsScalar = typename remove_all_t<Rhs>::Scalar;
   Index cols = rhs.outerSize();
   eigen_assert(lhs.outerSize() == rhs.innerSize());
 
diff --git a/Eigen/src/SparseCore/InternalHeaderCheck.h b/Eigen/src/SparseCore/InternalHeaderCheck.h
index 9de5936..3287287 100644
--- a/Eigen/src/SparseCore/InternalHeaderCheck.h
+++ b/Eigen/src/SparseCore/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SPARSECORE_MODULE_H
 #error "Please include Eigen/SparseCore instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SparseCore/SparseAssign.h b/Eigen/src/SparseCore/SparseAssign.h
index b794263..3a75390 100644
--- a/Eigen/src/SparseCore/SparseAssign.h
+++ b/Eigen/src/SparseCore/SparseAssign.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEASSIGN_H
 #define EIGEN_SPARSEASSIGN_H
@@ -33,7 +34,7 @@
 template <typename Derived>
 template <typename OtherDerived>
 inline Derived &SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived> &other) {
-  // by default sparse evaluation do not alias, so we can safely bypass the generic call_assignment routine
+  // by default sparse evaluations do not alias, so we can safely bypass the generic call_assignment routine
   internal::Assignment<Derived, OtherDerived, internal::assign_op<Scalar, typename OtherDerived::Scalar>>::run(
       derived(), other.derived(), internal::assign_op<Scalar, typename OtherDerived::Scalar>());
   return derived();
@@ -49,12 +50,12 @@
 
 template <>
 struct storage_kind_to_evaluator_kind<Sparse> {
-  typedef IteratorBased Kind;
+  using Kind = IteratorBased;
 };
 
 template <>
 struct storage_kind_to_shape<Sparse> {
-  typedef SparseShape Shape;
+  using Shape = SparseShape;
 };
 
 struct Sparse2Sparse {};
@@ -62,35 +63,143 @@
 
 template <>
 struct AssignmentKind<SparseShape, SparseShape> {
-  typedef Sparse2Sparse Kind;
+  using Kind = Sparse2Sparse;
 };
 template <>
 struct AssignmentKind<SparseShape, SparseTriangularShape> {
-  typedef Sparse2Sparse Kind;
+  using Kind = Sparse2Sparse;
 };
 template <>
 struct AssignmentKind<DenseShape, SparseShape> {
-  typedef Sparse2Dense Kind;
+  using Kind = Sparse2Dense;
 };
 template <>
 struct AssignmentKind<DenseShape, SparseTriangularShape> {
-  typedef Sparse2Dense Kind;
+  using Kind = Sparse2Dense;
 };
 
+template <typename XprType>
+Index sparse_assignment_total_size(const XprType &src) {
+  const Index rows = src.rows();
+  const Index cols = src.cols();
+  const Index maxIndex = NumTraits<Index>::highest();
+
+  if (rows == 0 || cols == 0) {
+    return 0;
+  }
+  return rows <= maxIndex / cols ? rows * cols : maxIndex;
+}
+
+template <typename XprType>
+Index sparse_assignment_heuristic_reserve_size(const XprType &src) {
+  const Index maxSize = (std::max)(src.rows(), src.cols());
+  const Index maxIndex = NumTraits<Index>::highest();
+  const Index totalSize = sparse_assignment_total_size(src);
+  const Index vectorReserve = maxSize <= maxIndex / 2 ? 2 * maxSize : maxIndex;
+  return (std::min)(totalSize, vectorReserve);
+}
+
+inline Index scaled_sparse_assignment_reserve_size(Index count, Index numerator, Index denominator) {
+  eigen_internal_assert(denominator > 0);
+  if (count == 0 || numerator == 0) return 0;
+
+  const Index maxIndex = NumTraits<Index>::highest();
+  if (count > maxIndex / numerator) return maxIndex;
+
+  const Index product = count * numerator;
+  return product / denominator + Index(product % denominator != 0);
+}
+
+template <typename SrcXprType>
+struct use_exact_sparse_assignment_reserve : std::true_type {};
+
+template <typename SrcXprType>
+struct use_exact_sparse_assignment_reserve<const SrcXprType> : use_exact_sparse_assignment_reserve<SrcXprType> {};
+
+// SparseView over an index-based expression must scan the underlying dense coefficients to count non-zeros.
+// Use an estimated reserve there to avoid traversing the full source twice.
+template <typename ArgType>
+struct use_exact_sparse_assignment_reserve<SparseView<ArgType>>
+    : std::is_same<typename evaluator_traits<remove_all_t<ArgType>>::Kind, IteratorBased> {};
+
+// Detect whether a const SrcXprType exposes a member nonZeros(). Concrete sparse storage classes
+// (SparseMatrix via SparseCompressedBase, SparseVector, SparseMap, SparseBlock, SparseTranspose)
+// do; sparse expressions such as CwiseBinaryOp / CwiseUnaryOp / Product / SparseTriangularView /
+// SparseView do not -- their evaluators only expose nonZerosEstimate().
+template <typename T, typename = void>
+struct has_member_nonZeros : std::false_type {};
+
+template <typename T>
+struct has_member_nonZeros<T, void_t<decltype(std::declval<const T &>().nonZeros())>> : std::true_type {};
+
+template <typename SrcXprType, typename SrcEvaluatorType>
+Index sparse_assignment_reserve_size_exact(const SrcXprType &, SrcEvaluatorType &srcEvaluator,
+                                           Index outerEvaluationSize, std::false_type /*has_member_nonZeros*/) {
+  Index reserveSize = 0;
+  for (Index j = 0; j < outerEvaluationSize; ++j)
+    for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it) reserveSize++;
+  return reserveSize;
+}
+
+template <typename SrcXprType, typename SrcEvaluatorType>
+Index sparse_assignment_reserve_size_exact(const SrcXprType &src, SrcEvaluatorType &srcEvaluator,
+                                           Index outerEvaluationSize, std::true_type /*has_member_nonZeros*/) {
+  // O(1) for compressed SparseMatrix, O(outerSize) uncompressed -- both cheaper than the O(nnz)
+  // iteration fallback. SparseBlock for general (non-inner-panel) blocks reports Dynamic; iterate
+  // in that case.
+  const Index nz = src.nonZeros();
+  if (nz != Dynamic) return nz;
+  return sparse_assignment_reserve_size_exact(src, srcEvaluator, outerEvaluationSize, std::false_type{});
+}
+
+template <typename SrcXprType, typename SrcEvaluatorType>
+Index sparse_assignment_reserve_size(const SrcXprType &src, SrcEvaluatorType &srcEvaluator, Index outerEvaluationSize,
+                                     std::true_type) {
+  return sparse_assignment_reserve_size_exact(src, srcEvaluator, outerEvaluationSize,
+                                              has_member_nonZeros<SrcXprType>{});
+}
+
+template <typename SrcXprType, typename SrcEvaluatorType>
+Index sparse_assignment_reserve_size(const SrcXprType &src, SrcEvaluatorType &srcEvaluator, Index outerEvaluationSize,
+                                     std::false_type) {
+  const Index totalSize = sparse_assignment_total_size(src);
+  // For small dense sources, reserve the full possible size instead of spending another pass counting
+  // entries. The 1024-slot cap bounds transient over-reservation to ~12 KB per assignment while still
+  // letting common small-matrix shapes (up to 32x32) avoid mid-fill reallocation when the source is
+  // densely populated.
+  if (totalSize <= 1024) return totalSize;
+
+  const Index heuristicReserveSize = sparse_assignment_heuristic_reserve_size(src);
+  // Avoid turning the sample into an almost-complete pre-scan for short, wide, or tall expressions.
+  if (outerEvaluationSize <= 8) return heuristicReserveSize;
+
+  // Scan up to 8 outer slices and scale the per-slice nnz to the full size. Small enough that the
+  // sample's scan cost is negligible against the assignment itself, large enough to keep variance
+  // low at typical sparsities; the result is then clamped by total size and the heuristic floor.
+  const Index sampleOuterSize = (std::min)(outerEvaluationSize, Index(8));
+  Index sampleReserveSize = 0;
+  for (Index j = 0; j < sampleOuterSize; ++j) {
+    for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it) sampleReserveSize++;
+  }
+
+  const Index estimatedReserveSize =
+      scaled_sparse_assignment_reserve_size(sampleReserveSize, outerEvaluationSize, sampleOuterSize);
+  return (std::min)(totalSize, (std::max)(heuristicReserveSize, estimatedReserveSize));
+}
+
 template <typename DstXprType, typename SrcXprType>
 void assign_sparse_to_sparse(DstXprType &dst, const SrcXprType &src) {
-  typedef typename DstXprType::Scalar Scalar;
-  typedef internal::evaluator<DstXprType> DstEvaluatorType;
-  typedef internal::evaluator<SrcXprType> SrcEvaluatorType;
+  using Scalar = typename DstXprType::Scalar;
+  using DstEvaluatorType = internal::evaluator<DstXprType>;
+  using SrcEvaluatorType = internal::evaluator<SrcXprType>;
 
   SrcEvaluatorType srcEvaluator(src);
 
   constexpr bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
   const Index outerEvaluationSize = (SrcEvaluatorType::Flags & RowMajorBit) ? src.rows() : src.cols();
 
-  Index reserveSize = 0;
-  for (Index j = 0; j < outerEvaluationSize; ++j)
-    for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it) reserveSize++;
+  const Index reserveSize = sparse_assignment_reserve_size(src, srcEvaluator, outerEvaluationSize,
+                                                           use_exact_sparse_assignment_reserve<SrcXprType>());
 
   if ((!transpose) && src.isRValue()) {
     // eval without temporary
@@ -109,11 +218,9 @@
     // eval through a temporary
     eigen_assert((((internal::traits<DstXprType>::SupportedAccessPatterns & OuterRandomAccessPattern) ==
                    OuterRandomAccessPattern) ||
-                  (!((DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit)))) &&
+                  (!transpose)) &&
                  "the transpose operation is supposed to be handled in SparseMatrix::operator=");
 
-    enum { Flip = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit) };
-
     DstXprType temp(src.rows(), src.cols());
 
     temp.reserve(reserveSize);
@@ -121,7 +228,7 @@
       temp.startVec(j);
       for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it) {
         Scalar v = it.value();
-        temp.insertBackByOuterInner(Flip ? it.index() : j, Flip ? j : it.index()) = v;
+        temp.insertBackByOuterInner(transpose ? it.index() : j, transpose ? j : it.index()) = v;
       }
     }
     temp.finalize();
@@ -143,8 +250,8 @@
 template <typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
 struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Dense, Weak> {
   static void run(DstXprType &dst, const SrcXprType &src, const Functor &func) {
-    if (internal::is_same<Functor,
-                          internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>>::value)
+    EIGEN_IF_CONSTEXPR ((std::is_same<Functor, internal::assign_op<typename DstXprType::Scalar,
+                                                                   typename SrcXprType::Scalar>>::value))
       dst.setZero();
 
     internal::evaluator<SrcXprType> srcEval(src);
@@ -175,7 +282,7 @@
   // Specialization for dense1 = sparse + dense2; -> dense1 = dense2; dense1 += sparse;
   template <typename Lhs, typename Rhs, typename Scalar>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-      std::enable_if_t<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape, DenseShape>::value>
+      std::enable_if_t<std::is_same<typename internal::evaluator_traits<Rhs>::Shape, DenseShape>::value>
       run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_sum_op<Scalar, Scalar>, const Lhs, const Rhs> &src,
           const internal::assign_op<typename DstXprType::Scalar, Scalar> & /*func*/) {
 #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
@@ -190,7 +297,7 @@
   // Specialization for dense1 = sparse - dense2; -> dense1 = -dense2; dense1 += sparse;
   template <typename Lhs, typename Rhs, typename Scalar>
   static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-      std::enable_if_t<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape, DenseShape>::value>
+      std::enable_if_t<std::is_same<typename internal::evaluator_traits<Rhs>::Shape, DenseShape>::value>
       run(DstXprType &dst,
           const CwiseBinaryOp<internal::scalar_difference_op<Scalar, Scalar>, const Lhs, const Rhs> &src,
           const internal::assign_op<typename DstXprType::Scalar, Scalar> & /*func*/) {
@@ -209,8 +316,8 @@
   struct Assignment<                                                                                            \
       DstXprType, CwiseBinaryOp<internal::BINOP<Scalar, Scalar>, const Lhs, const Rhs>,                         \
       internal::ASSIGN_OP<typename DstXprType::Scalar, Scalar>, Sparse2Dense,                                   \
-      std::enable_if_t<internal::is_same<typename internal::evaluator_traits<Lhs>::Shape, DenseShape>::value || \
-                       internal::is_same<typename internal::evaluator_traits<Rhs>::Shape, DenseShape>::value>>  \
+      std::enable_if_t<std::is_same<typename internal::evaluator_traits<Lhs>::Shape, DenseShape>::value ||      \
+                       std::is_same<typename internal::evaluator_traits<Rhs>::Shape, DenseShape>::value>>       \
       : assignment_from_dense_op_sparse<DstXprType,                                                             \
                                         internal::ASSIGN_OP<typename DstXprType::Scalar, typename Lhs::Scalar>, \
                                         internal::ASSIGN_OP2<typename DstXprType::Scalar, typename Rhs::Scalar>> {}
@@ -223,11 +330,13 @@
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op, scalar_difference_op, sub_assign_op);
 EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op, scalar_difference_op, add_assign_op);
 
+#undef EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE
+
 // Specialization for "dst = dec.solve(rhs)"
 // NOTE we need to specialize it for Sparse2Sparse to avoid ambiguous specialization error
 template <typename DstXprType, typename DecType, typename RhsType, typename Scalar>
 struct Assignment<DstXprType, Solve<DecType, RhsType>, internal::assign_op<Scalar, Scalar>, Sparse2Sparse> {
-  typedef Solve<DecType, RhsType> SrcXprType;
+  using SrcXprType = Solve<DecType, RhsType>;
   static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar, Scalar> &) {
     Index dstRows = src.rows();
     Index dstCols = src.cols();
@@ -241,13 +350,13 @@
 
 template <>
 struct AssignmentKind<SparseShape, DiagonalShape> {
-  typedef Diagonal2Sparse Kind;
+  using Kind = Diagonal2Sparse;
 };
 
 template <typename DstXprType, typename SrcXprType, typename Functor>
 struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Sparse> {
-  typedef typename DstXprType::StorageIndex StorageIndex;
-  typedef typename DstXprType::Scalar Scalar;
+  using StorageIndex = typename DstXprType::StorageIndex;
+  using Scalar = typename DstXprType::Scalar;
 
   template <int Options, typename AssignFunc>
   static void run(SparseMatrix<Scalar, Options, StorageIndex> &dst, const SrcXprType &src, const AssignFunc &func) {
diff --git a/Eigen/src/SparseCore/SparseBlock.h b/Eigen/src/SparseCore/SparseBlock.h
index 3affff6..f7688eb 100644
--- a/Eigen/src/SparseCore/SparseBlock.h
+++ b/Eigen/src/SparseCore/SparseBlock.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_BLOCK_H
 #define EIGEN_SPARSE_BLOCK_H
@@ -18,16 +19,15 @@
 // Subset of columns or rows
 template <typename XprType, int BlockRows, int BlockCols>
 class BlockImpl<XprType, BlockRows, BlockCols, true, Sparse>
-    : public SparseMatrixBase<Block<XprType, BlockRows, BlockCols, true> > {
-  typedef internal::remove_all_t<typename XprType::Nested> MatrixTypeNested_;
-  typedef Block<XprType, BlockRows, BlockCols, true> BlockType;
+    : public SparseCompressedBase<Block<XprType, BlockRows, BlockCols, true> > {
+  using BlockType = Block<XprType, BlockRows, BlockCols, true>;
 
  public:
   enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
 
  protected:
   enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
-  typedef SparseMatrixBase<BlockType> Base;
+  using Base = SparseCompressedBase<BlockType>;
   using Base::convert_index;
 
  public:
@@ -44,7 +44,23 @@
   EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
 
   Index nonZeros() const {
-    typedef internal::evaluator<XprType> EvaluatorType;
+    return nonZerosImpl(std::integral_constant<bool, (internal::traits<XprType>::Flags & CompressedAccessBit) != 0>());
+  }
+
+ protected:
+  Index nonZerosImpl(std::true_type) const {
+    if (m_outerSize.value() == 0) return 0;
+    const StorageIndex* outer = m_matrix.outerIndexPtr();
+    if (!outer) return m_matrix.nonZeros();
+    const StorageIndex* innerNonZeros = m_matrix.innerNonZeroPtr();
+    if (!innerNonZeros) return outer[m_outerStart + m_outerSize.value()] - outer[m_outerStart];
+    Index nnz = 0;
+    for (Index j = m_outerStart; j < m_outerStart + m_outerSize.value(); ++j) nnz += innerNonZeros[j];
+    return nnz;
+  }
+
+  Index nonZerosImpl(std::false_type) const {
+    using EvaluatorType = internal::evaluator<XprType>;
     EvaluatorType matEval(m_matrix);
     Index nnz = 0;
     Index end = m_outerStart + m_outerSize.value();
@@ -53,6 +69,7 @@
     return nnz;
   }
 
+ public:
   inline const Scalar coeff(Index row, Index col) const {
     return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
   }
@@ -117,16 +134,14 @@
 
 template <typename SparseMatrixType, int BlockRows, int BlockCols>
 class sparse_matrix_block_impl : public SparseCompressedBase<Block<SparseMatrixType, BlockRows, BlockCols, true> > {
-  typedef internal::remove_all_t<typename SparseMatrixType::Nested> MatrixTypeNested_;
-  typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType;
-  typedef SparseCompressedBase<Block<SparseMatrixType, BlockRows, BlockCols, true> > Base;
+  using BlockType = Block<SparseMatrixType, BlockRows, BlockCols, true>;
+  using Base = SparseCompressedBase<Block<SparseMatrixType, BlockRows, BlockCols, true>>;
   using Base::convert_index;
 
  public:
   enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
   EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
  protected:
-  typedef typename Base::IndexVector IndexVector;
   enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
 
  public:
@@ -141,7 +156,7 @@
 
   template <typename OtherDerived>
   inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other) {
-    typedef internal::remove_all_t<typename SparseMatrixType::Nested> NestedMatrixType_;
+    using NestedMatrixType_ = internal::remove_all_t<typename SparseMatrixType::Nested>;
     NestedMatrixType_& matrix = m_matrix;
     // This assignment is slow if this vector set is not empty
     // and/or it is not at the end of the nonzeros of the underlying matrix.
@@ -203,7 +218,7 @@
     }
 
     // update outer index pointers and innerNonZeros
-    if (IsVectorAtCompileTime) {
+    EIGEN_IF_CONSTEXPR (IsVectorAtCompileTime) {
       if (!m_matrix.isCompressed()) matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz);
       matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start);
     } else {
@@ -287,9 +302,9 @@
 class BlockImpl<SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true, Sparse>
     : public internal::sparse_matrix_block_impl<SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols> {
  public:
-  typedef StorageIndex_ StorageIndex;
-  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> SparseMatrixType;
-  typedef internal::sparse_matrix_block_impl<SparseMatrixType, BlockRows, BlockCols> Base;
+  using StorageIndex = StorageIndex_;
+  using SparseMatrixType = SparseMatrix<Scalar_, Options_, StorageIndex_>;
+  using Base = internal::sparse_matrix_block_impl<SparseMatrixType, BlockRows, BlockCols>;
   inline BlockImpl(SparseMatrixType& xpr, Index i) : Base(xpr, i) {}
 
   inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
@@ -303,9 +318,9 @@
     : public internal::sparse_matrix_block_impl<const SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows,
                                                 BlockCols> {
  public:
-  typedef StorageIndex_ StorageIndex;
-  typedef const SparseMatrix<Scalar_, Options_, StorageIndex_> SparseMatrixType;
-  typedef internal::sparse_matrix_block_impl<SparseMatrixType, BlockRows, BlockCols> Base;
+  using StorageIndex = StorageIndex_;
+  using SparseMatrixType = const SparseMatrix<Scalar_, Options_, StorageIndex_>;
+  using Base = internal::sparse_matrix_block_impl<SparseMatrixType, BlockRows, BlockCols>;
   inline BlockImpl(SparseMatrixType& xpr, Index i) : Base(xpr, i) {}
 
   inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
@@ -328,15 +343,15 @@
 template <typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
 class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Sparse>
     : public SparseMatrixBase<Block<XprType, BlockRows, BlockCols, InnerPanel> >, internal::no_assignment_operator {
-  typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
-  typedef SparseMatrixBase<BlockType> Base;
+  using BlockType = Block<XprType, BlockRows, BlockCols, InnerPanel>;
+  using Base = SparseMatrixBase<BlockType>;
   using Base::convert_index;
 
  public:
   enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
   EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
 
-  typedef internal::remove_all_t<typename XprType::Nested> MatrixTypeNested_;
+  using MatrixTypeNested_ = internal::remove_all_t<typename XprType::Nested>;
 
   /** Column or Row constructor
    */
@@ -385,7 +400,6 @@
   Index blockCols() const { return m_blockCols.value(); }
 
  protected:
-  //     friend class internal::GenericSparseBlockInnerIteratorImpl<XprType,BlockRows,BlockCols,InnerPanel>;
   friend struct internal::unary_evaluator<Block<XprType, BlockRows, BlockCols, InnerPanel>, internal::IteratorBased,
                                           Scalar>;
 
@@ -416,9 +430,9 @@
   class OuterVectorInnerIterator;
 
  public:
-  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename XprType::Scalar Scalar;
+  using XprType = Block<ArgType, BlockRows, BlockCols, InnerPanel>;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename XprType::Scalar;
 
   enum {
     IsRowMajor = XprType::IsRowMajor,
@@ -427,7 +441,7 @@
     Flags = XprType::Flags
   };
 
-  typedef std::conditional_t<OuterVector, OuterVectorInnerIterator, InnerVectorInnerIterator> InnerIterator;
+  using InnerIterator = std::conditional_t<OuterVector, OuterVectorInnerIterator, InnerVectorInnerIterator>;
 
   explicit unary_evaluator(const XprType& op) : m_argImpl(op.nestedExpression()), m_block(op) {}
 
@@ -443,7 +457,7 @@
   }
 
  protected:
-  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  using EvalIterator = typename evaluator<ArgType>::InnerIterator;
 
   evaluator<ArgType> m_argImpl;
   const XprType& m_block;
@@ -538,8 +552,8 @@
 struct unary_evaluator<Block<SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true>, IteratorBased>
     : evaluator<
           SparseCompressedBase<Block<SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true> > > {
-  typedef Block<SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true> XprType;
-  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  using XprType = Block<SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true>;
+  using Base = evaluator<SparseCompressedBase<XprType>>;
   explicit unary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
@@ -548,8 +562,8 @@
                        IteratorBased>
     : evaluator<SparseCompressedBase<
           Block<const SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true> > > {
-  typedef Block<const SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true> XprType;
-  typedef evaluator<SparseCompressedBase<XprType> > Base;
+  using XprType = Block<const SparseMatrix<Scalar_, Options_, StorageIndex_>, BlockRows, BlockCols, true>;
+  using Base = evaluator<SparseCompressedBase<XprType>>;
   explicit unary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
diff --git a/Eigen/src/SparseCore/SparseColEtree.h b/Eigen/src/SparseCore/SparseColEtree.h
index 76575c9..17f458d 100644
--- a/Eigen/src/SparseCore/SparseColEtree.h
+++ b/Eigen/src/SparseCore/SparseColEtree.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -60,7 +61,7 @@
 template <typename MatrixType, typename IndexVector>
 int coletree(const MatrixType& mat, IndexVector& parent, IndexVector& firstRowElt,
              typename MatrixType::StorageIndex* perm = 0) {
-  typedef typename MatrixType::StorageIndex StorageIndex;
+  using StorageIndex = typename MatrixType::StorageIndex;
   StorageIndex nc = convert_index<StorageIndex>(mat.cols());  // Number of columns
   StorageIndex m = convert_index<StorageIndex>(mat.rows());
   StorageIndex diagSize = (std::min)(nc, m);
@@ -125,10 +126,9 @@
 template <typename IndexVector>
 void nr_etdfs(typename IndexVector::Scalar n, IndexVector& parent, IndexVector& first_kid, IndexVector& next_kid,
               IndexVector& post, typename IndexVector::Scalar postnum) {
-  typedef typename IndexVector::Scalar StorageIndex;
+  using StorageIndex = typename IndexVector::Scalar;
   StorageIndex current = n, first, next;
   while (postnum != n) {
-    // No kid for the current node
     first = first_kid(current);
 
     // no kid for the current node
@@ -166,7 +166,7 @@
  */
 template <typename IndexVector>
 void treePostorder(typename IndexVector::Scalar n, IndexVector& parent, IndexVector& post) {
-  typedef typename IndexVector::Scalar StorageIndex;
+  using StorageIndex = typename IndexVector::Scalar;
   IndexVector first_kid, next_kid;  // Linked list of children
   StorageIndex postnum;
   // Allocate storage for working arrays and results
diff --git a/Eigen/src/SparseCore/SparseCompressedBase.h b/Eigen/src/SparseCore/SparseCompressedBase.h
index 420e9fa..5e948ca 100644
--- a/Eigen/src/SparseCore/SparseCompressedBase.h
+++ b/Eigen/src/SparseCore/SparseCompressedBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_COMPRESSED_BASE_H
 #define EIGEN_SPARSE_COMPRESSED_BASE_H
@@ -42,7 +43,7 @@
 template <typename Derived>
 class SparseCompressedBase : public SparseMatrixBase<Derived> {
  public:
-  typedef SparseMatrixBase<Derived> Base;
+  using Base = SparseMatrixBase<Derived>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(SparseCompressedBase)
   using Base::operator=;
   using Base::IsRowMajor;
@@ -51,7 +52,7 @@
   class ReverseInnerIterator;
 
  protected:
-  typedef typename Base::IndexVector IndexVector;
+  using IndexVector = typename Base::IndexVector;
   Eigen::Map<IndexVector> innerNonZeros() {
     return Eigen::Map<IndexVector>(innerNonZeroPtr(), isCompressed() ? 0 : derived().outerSize());
   }
@@ -113,6 +114,13 @@
   /** \returns whether \c *this is in compressed form. */
   inline bool isCompressed() const { return innerNonZeroPtr() == 0; }
 
+ protected:
+  Index coeffsStart() const {
+    const StorageIndex* outer = outerIndexPtr();
+    return (outer && derived().outerSize() > 0) ? internal::convert_index<Index>(outer[0]) : 0;
+  }
+
+ public:
   /** \returns a read-only view of the stored coefficients as a 1D array expression.
    *
    * \warning this method is for \b compressed \b storage \b only, and it will trigger an assertion otherwise.
@@ -120,7 +128,9 @@
    * \sa valuePtr(), isCompressed() */
   const Map<const Array<Scalar, Dynamic, 1>> coeffs() const {
     eigen_assert(isCompressed());
-    return Array<Scalar, Dynamic, 1>::Map(valuePtr(), nonZeros());
+    const Index start = coeffsStart();
+    const Scalar* values = valuePtr() + start;
+    return Array<Scalar, Dynamic, 1>::Map(values, nonZeros());
   }
 
   /** \returns a read-write view of the stored coefficients as a 1D array expression
@@ -135,7 +145,9 @@
    * \sa valuePtr(), isCompressed() */
   Map<Array<Scalar, Dynamic, 1>> coeffs() {
     eigen_assert(isCompressed());
-    return Array<Scalar, Dynamic, 1>::Map(valuePtr(), nonZeros());
+    const Index start = coeffsStart();
+    Scalar* values = valuePtr() + start;
+    return Array<Scalar, Dynamic, 1>::Map(values, nonZeros());
   }
 
   /** sorts the inner vectors in the range [begin,end) with respect to `Comp`
@@ -174,7 +186,7 @@
 
  protected:
   /** Default constructor. Do nothing. */
-  SparseCompressedBase() {}
+  SparseCompressedBase() = default;
 
   /** \internal return the index of the coeff at (row,col) or just before if it does not exist.
    * This is an analogue of std::lower_bound.
@@ -206,7 +218,7 @@
 template <typename Derived>
 class SparseCompressedBase<Derived>::InnerIterator {
  public:
-  InnerIterator() : m_values(0), m_indices(0), m_outer(0), m_id(0), m_end(0) {}
+  InnerIterator() = default;
 
   InnerIterator(const InnerIterator& other)
       : m_values(other.m_values),
@@ -270,15 +282,22 @@
   inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
   inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
 
-  inline operator bool() const { return (m_id < m_end); }
+  inline operator bool() const { return m_id < m_end; }
+
+  // Position-based equality (bug #1192 — without these, == falls back to bool conversion).
+  inline bool operator==(const InnerIterator& other) const {
+    eigen_assert(m_values == other.m_values && "comparing iterators from different sources");
+    return m_outer.value() == other.m_outer.value() && m_id == other.m_id;
+  }
+  inline bool operator!=(const InnerIterator& other) const { return !(*this == other); }
 
  protected:
-  const Scalar* m_values;
-  const StorageIndex* m_indices;
-  typedef internal::variable_if_dynamic<Index, Derived::IsVectorAtCompileTime ? 0 : Dynamic> OuterType;
-  const OuterType m_outer;
-  Index m_id;
-  Index m_end;
+  const Scalar* m_values = nullptr;
+  const StorageIndex* m_indices = nullptr;
+  using OuterType = internal::variable_if_dynamic<Index, Derived::IsVectorAtCompileTime ? 0 : Dynamic>;
+  const OuterType m_outer{0};
+  Index m_id = 0;
+  Index m_end = 0;
 
  private:
   // If you get here, then you're not using the right InnerIterator type, e.g.:
@@ -305,8 +324,7 @@
     }
   }
 
-  explicit ReverseInnerIterator(const SparseCompressedBase& mat)
-      : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_start(0), m_id(mat.nonZeros()) {
+  explicit ReverseInnerIterator(const SparseCompressedBase& mat) : ReverseInnerIterator(mat, Index(0)) {
     EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
   }
 
@@ -338,12 +356,18 @@
   inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
   inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
 
-  inline operator bool() const { return (m_id > m_start); }
+  inline operator bool() const { return m_id > m_start; }
+
+  inline bool operator==(const ReverseInnerIterator& other) const {
+    eigen_assert(m_values == other.m_values && "comparing iterators from different sources");
+    return m_outer.value() == other.m_outer.value() && m_id == other.m_id;
+  }
+  inline bool operator!=(const ReverseInnerIterator& other) const { return !(*this == other); }
 
  protected:
   const Scalar* m_values;
   const StorageIndex* m_indices;
-  typedef internal::variable_if_dynamic<Index, Derived::IsVectorAtCompileTime ? 0 : Dynamic> OuterType;
+  using OuterType = internal::variable_if_dynamic<Index, Derived::IsVectorAtCompileTime ? 0 : Dynamic>;
   const OuterType m_outer;
   Index m_start;
   Index m_id;
@@ -365,7 +389,7 @@
 class StorageVal {
  public:
   StorageVal(const StorageIndex& innerIndex, const Scalar& value) : m_innerIndex(innerIndex), m_value(value) {}
-  StorageVal(const StorageVal& other) : m_innerIndex(other.m_innerIndex), m_value(other.m_value) {}
+  StorageVal(const StorageVal& other) = default;
   StorageVal(StorageVal&& other) = default;
 
   inline const StorageIndex& key() const { return m_innerIndex; }
@@ -390,7 +414,7 @@
  public:
   using value_type = StorageVal<Scalar, StorageIndex>;
 
-  // StorageRef Needs to be move-able for sort on macos.
+  // StorageRef needs to be move-able for sort on macOS.
   StorageRef(StorageRef&& other) = default;
 
   inline StorageRef& operator=(const StorageRef& other) {
@@ -428,8 +452,7 @@
   // these constructors are called by the CompressedStorageIterator constructors for convenience only
   StorageRef(StorageIndex* innerIndexIterator, Scalar* valueIterator)
       : m_innerIndexIterator(innerIndexIterator), m_valueIterator(valueIterator) {}
-  StorageRef(const StorageRef& other)
-      : m_innerIndexIterator(other.m_innerIndexIterator), m_valueIterator(other.m_valueIterator) {}
+  StorageRef(const StorageRef& other) = default;
 
   friend class CompressedStorageIterator<Scalar, StorageIndex>;
 };
@@ -448,7 +471,7 @@
   CompressedStorageIterator(difference_type index, StorageIndex* innerIndexPtr, Scalar* valuePtr)
       : m_index(index), m_data(innerIndexPtr, valuePtr) {}
   CompressedStorageIterator(difference_type index, reference data) : m_index(index), m_data(data) {}
-  CompressedStorageIterator(const CompressedStorageIterator& other) : m_index(other.m_index), m_data(other.m_data) {}
+  CompressedStorageIterator(const CompressedStorageIterator& other) = default;
   CompressedStorageIterator(CompressedStorageIterator&& other) = default;
   inline CompressedStorageIterator& operator=(const CompressedStorageIterator& other) {
     m_index = other.m_index;
@@ -499,8 +522,8 @@
 
 template <typename Derived, class Comp, bool IsVector>
 struct inner_sort_impl {
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::StorageIndex StorageIndex;
+  using Scalar = typename Derived::Scalar;
+  using StorageIndex = typename Derived::StorageIndex;
   static inline void run(SparseCompressedBase<Derived>& obj, Index begin, Index end) {
     const bool is_compressed = obj.isCompressed();
     for (Index outer = begin; outer < end; outer++) {
@@ -526,18 +549,20 @@
 };
 template <typename Derived, class Comp>
 struct inner_sort_impl<Derived, Comp, true> {
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::StorageIndex StorageIndex;
+  using Scalar = typename Derived::Scalar;
+  using StorageIndex = typename Derived::StorageIndex;
   static inline void run(SparseCompressedBase<Derived>& obj, Index, Index) {
-    Index begin_offset = 0;
-    Index end_offset = obj.nonZeros();
+    const StorageIndex* outer = obj.outerIndexPtr();
+    Index begin_offset = (outer && obj.outerSize() > 0) ? internal::convert_index<Index>(outer[0]) : 0;
+    Index end_offset = begin_offset + obj.nonZeros();
     CompressedStorageIterator<Scalar, StorageIndex> begin_it(begin_offset, obj.innerIndexPtr(), obj.valuePtr());
     CompressedStorageIterator<Scalar, StorageIndex> end_it(end_offset, obj.innerIndexPtr(), obj.valuePtr());
     std::sort(begin_it, end_it, Comp());
   }
   static inline Index check(const SparseCompressedBase<Derived>& obj, Index, Index) {
-    Index begin_offset = 0;
-    Index end_offset = obj.nonZeros();
+    const StorageIndex* outer = obj.outerIndexPtr();
+    Index begin_offset = (outer && obj.outerSize() > 0) ? internal::convert_index<Index>(outer[0]) : 0;
+    Index end_offset = begin_offset + obj.nonZeros();
     const StorageIndex* begin_it = obj.innerIndexPtr() + begin_offset;
     const StorageIndex* end_it = obj.innerIndexPtr() + end_offset;
     return std::is_sorted(begin_it, end_it, Comp()) ? 1 : 0;
@@ -546,25 +571,25 @@
 
 template <typename Derived>
 struct evaluator<SparseCompressedBase<Derived>> : evaluator_base<Derived> {
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::InnerIterator InnerIterator;
+  using Scalar = typename Derived::Scalar;
+  using InnerIterator = typename Derived::InnerIterator;
 
   enum { CoeffReadCost = NumTraits<Scalar>::ReadCost, Flags = Derived::Flags };
 
-  evaluator() : m_matrix(0), m_zero(0) { EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); }
-  explicit evaluator(const Derived& mat) : m_matrix(&mat), m_zero(0) { EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); }
+  evaluator() : m_matrix(0) { EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); }
+  explicit evaluator(const Derived& mat) : m_matrix(&mat) { EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); }
 
   inline Index nonZerosEstimate() const { return m_matrix->nonZeros(); }
 
   operator Derived&() { return m_matrix->const_cast_derived(); }
   operator const Derived&() const { return *m_matrix; }
 
-  typedef typename DenseCoeffsBase<Derived, ReadOnlyAccessors>::CoeffReturnType CoeffReturnType;
+  using CoeffReturnType = typename DenseCoeffsBase<Derived, ReadOnlyAccessors>::CoeffReturnType;
   const Scalar& coeff(Index row, Index col) const {
     Index p = find(row, col);
 
     if (p == Dynamic)
-      return m_zero;
+      return zero();
     else
       return m_matrix->const_cast_derived().valuePtr()[p];
   }
@@ -581,8 +606,16 @@
     return p.found ? p.value : Dynamic;
   }
 
+  // Stable storage for the structural zero coeff() hands out by reference. Kept
+  // out of the evaluator itself: product_evaluator and friends reconstruct their
+  // base evaluator in place with construct_at, which would leak any member that
+  // owns resources when Scalar is not trivially destructible.
+  static const Scalar& zero() {
+    static const Scalar kZero(0);
+    return kZero;
+  }
+
   const Derived* m_matrix;
-  const Scalar m_zero;
 };
 
 }  // namespace internal
diff --git a/Eigen/src/SparseCore/SparseCwiseBinaryOp.h b/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
index e3dcd57..341dcf6 100644
--- a/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
+++ b/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_CWISE_BINARY_OP_H
 #define EIGEN_SPARSE_CWISE_BINARY_OP_H
@@ -38,11 +39,11 @@
 template <typename BinaryOp, typename Lhs, typename Rhs>
 class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse> : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > {
  public:
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
-  typedef SparseMatrixBase<Derived> Base;
+  using Derived = CwiseBinaryOp<BinaryOp, Lhs, Rhs>;
+  using Base = SparseMatrixBase<Derived>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
-  EIGEN_STATIC_ASSERT(((!internal::is_same<typename internal::traits<Lhs>::StorageKind,
-                                           typename internal::traits<Rhs>::StorageKind>::value) ||
+  EIGEN_STATIC_ASSERT(((!std::is_same<typename internal::traits<Lhs>::StorageKind,
+                                      typename internal::traits<Rhs>::StorageKind>::value) ||
                        ((internal::evaluator<Lhs>::Flags & RowMajorBit) ==
                         (internal::evaluator<Rhs>::Flags & RowMajorBit))),
                       THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH)
@@ -58,18 +59,15 @@
 //   if lhs(i,j) is null and rhs(i,j) is present, dst(i,j) = func(0, rhs(i,j))
 
 // Generic "sparse OP sparse"
-template <typename XprType>
-struct binary_sparse_evaluator;
-
 template <typename BinaryOp, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IteratorBased>
     : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > {
  protected:
-  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
-  typedef typename evaluator<Rhs>::InnerIterator RhsIterator;
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
-  typedef typename traits<XprType>::Scalar Scalar;
-  typedef typename XprType::StorageIndex StorageIndex;
+  using LhsIterator = typename evaluator<Lhs>::InnerIterator;
+  using RhsIterator = typename evaluator<Rhs>::InnerIterator;
+  using XprType = CwiseBinaryOp<BinaryOp, Lhs, Rhs>;
+  using Scalar = typename traits<XprType>::Scalar;
+  using StorageIndex = typename XprType::StorageIndex;
 
  public:
   class InnerIterator {
@@ -143,10 +141,10 @@
 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IteratorBased>
     : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > {
  protected:
-  typedef typename evaluator<Rhs>::InnerIterator RhsIterator;
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
-  typedef typename traits<XprType>::Scalar Scalar;
-  typedef typename XprType::StorageIndex StorageIndex;
+  using RhsIterator = typename evaluator<Rhs>::InnerIterator;
+  using XprType = CwiseBinaryOp<BinaryOp, Lhs, Rhs>;
+  using Scalar = typename traits<XprType>::Scalar;
+  using StorageIndex = typename XprType::StorageIndex;
 
  public:
   class InnerIterator {
@@ -224,10 +222,10 @@
 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IndexBased>
     : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > {
  protected:
-  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
-  typedef typename traits<XprType>::Scalar Scalar;
-  typedef typename XprType::StorageIndex StorageIndex;
+  using LhsIterator = typename evaluator<Lhs>::InnerIterator;
+  using XprType = CwiseBinaryOp<BinaryOp, Lhs, Rhs>;
+  using Scalar = typename traits<XprType>::Scalar;
+  using StorageIndex = typename XprType::StorageIndex;
 
  public:
   class InnerIterator {
@@ -310,24 +308,24 @@
 template <typename T1, typename T2, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs>, IteratorBased, IteratorBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 // "dense .* sparse"
 template <typename T1, typename T2, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs>, IndexBased, IteratorBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 // "sparse .* dense"
 template <typename T1, typename T2, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs>, IteratorBased, IndexBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_product_op<T1, T2>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
@@ -335,8 +333,8 @@
 template <typename T1, typename T2, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_quotient_op<T1, T2>, Lhs, Rhs>, IteratorBased, IndexBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_quotient_op<T1, T2>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_quotient_op<T1, T2>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_quotient_op<T1, T2>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
@@ -344,24 +342,24 @@
 template <typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs>, IteratorBased, IteratorBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 // "dense && sparse"
 template <typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs>, IndexBased, IteratorBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 // "sparse && dense"
 template <typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs>, IteratorBased, IndexBased>
     : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs> XprType;
-  typedef sparse_conjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_boolean_and_op<bool>, Lhs, Rhs>;
+  using Base = sparse_conjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
@@ -376,13 +374,13 @@
 template <typename XprType>
 struct sparse_conjunction_evaluator<XprType, IteratorBased, IteratorBased> : evaluator_base<XprType> {
  protected:
-  typedef typename XprType::Functor BinaryOp;
-  typedef typename XprType::Lhs LhsArg;
-  typedef typename XprType::Rhs RhsArg;
-  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
-  typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using BinaryOp = typename XprType::Functor;
+  using LhsArg = typename XprType::Lhs;
+  using RhsArg = typename XprType::Rhs;
+  using LhsIterator = typename evaluator<LhsArg>::InnerIterator;
+  using RhsIterator = typename evaluator<RhsArg>::InnerIterator;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename traits<XprType>::Scalar;
 
  public:
   class InnerIterator {
@@ -416,7 +414,7 @@
     EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
     EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
 
-    EIGEN_STRONG_INLINE operator bool() const { return (m_lhsIter && m_rhsIter); }
+    EIGEN_STRONG_INLINE operator bool() const { return m_lhsIter && m_rhsIter; }
 
    protected:
     LhsIterator m_lhsIter;
@@ -450,13 +448,13 @@
 template <typename XprType>
 struct sparse_conjunction_evaluator<XprType, IndexBased, IteratorBased> : evaluator_base<XprType> {
  protected:
-  typedef typename XprType::Functor BinaryOp;
-  typedef typename XprType::Lhs LhsArg;
-  typedef typename XprType::Rhs RhsArg;
-  typedef evaluator<LhsArg> LhsEvaluator;
-  typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using BinaryOp = typename XprType::Functor;
+  using LhsArg = typename XprType::Lhs;
+  using RhsArg = typename XprType::Rhs;
+  using LhsEvaluator = evaluator<LhsArg>;
+  using RhsIterator = typename evaluator<RhsArg>::InnerIterator;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename traits<XprType>::Scalar;
 
  public:
   class InnerIterator {
@@ -515,13 +513,12 @@
 template <typename XprType>
 struct sparse_conjunction_evaluator<XprType, IteratorBased, IndexBased> : evaluator_base<XprType> {
  protected:
-  typedef typename XprType::Functor BinaryOp;
-  typedef typename XprType::Lhs LhsArg;
-  typedef typename XprType::Rhs RhsArg;
-  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
-  typedef evaluator<RhsArg> RhsEvaluator;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using BinaryOp = typename XprType::Functor;
+  using LhsArg = typename XprType::Lhs;
+  using RhsArg = typename XprType::Rhs;
+  using LhsIterator = typename evaluator<LhsArg>::InnerIterator;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename traits<XprType>::Scalar;
 
  public:
   class InnerIterator {
@@ -592,13 +589,13 @@
 template <typename XprType>
 struct sparse_disjunction_evaluator<XprType, IteratorBased, IteratorBased> : evaluator_base<XprType> {
  protected:
-  typedef typename XprType::Functor BinaryOp;
-  typedef typename XprType::Lhs LhsArg;
-  typedef typename XprType::Rhs RhsArg;
-  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
-  typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using BinaryOp = typename XprType::Functor;
+  using LhsArg = typename XprType::Lhs;
+  using RhsArg = typename XprType::Rhs;
+  using LhsIterator = typename evaluator<LhsArg>::InnerIterator;
+  using RhsIterator = typename evaluator<RhsArg>::InnerIterator;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename traits<XprType>::Scalar;
 
  public:
   class InnerIterator {
@@ -672,13 +669,12 @@
 template <typename XprType>
 struct sparse_disjunction_evaluator<XprType, IndexBased, IteratorBased> : evaluator_base<XprType> {
  protected:
-  typedef typename XprType::Functor BinaryOp;
-  typedef typename XprType::Lhs LhsArg;
-  typedef typename XprType::Rhs RhsArg;
-  typedef evaluator<LhsArg> LhsEvaluator;
-  typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using BinaryOp = typename XprType::Functor;
+  using LhsArg = typename XprType::Lhs;
+  using RhsArg = typename XprType::Rhs;
+  using RhsIterator = typename evaluator<RhsArg>::InnerIterator;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename traits<XprType>::Scalar;
 
  public:
   class InnerIterator {
@@ -755,13 +751,12 @@
 template <typename XprType>
 struct sparse_disjunction_evaluator<XprType, IteratorBased, IndexBased> : evaluator_base<XprType> {
  protected:
-  typedef typename XprType::Functor BinaryOp;
-  typedef typename XprType::Lhs LhsArg;
-  typedef typename XprType::Rhs RhsArg;
-  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
-  typedef evaluator<RhsArg> RhsEvaluator;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename traits<XprType>::Scalar Scalar;
+  using BinaryOp = typename XprType::Functor;
+  using LhsArg = typename XprType::Lhs;
+  using RhsArg = typename XprType::Rhs;
+  using LhsIterator = typename evaluator<LhsArg>::InnerIterator;
+  using StorageIndex = typename XprType::StorageIndex;
+  using Scalar = typename traits<XprType>::Scalar;
 
  public:
   class InnerIterator {
@@ -838,8 +833,8 @@
 template <typename T1, typename T2, typename DupFunc, typename Lhs, typename Rhs>
 struct binary_evaluator<CwiseBinaryOp<scalar_disjunction_op<DupFunc, T1, T2>, Lhs, Rhs>, IteratorBased, IteratorBased>
     : sparse_disjunction_evaluator<CwiseBinaryOp<scalar_disjunction_op<DupFunc, T1, T2>, Lhs, Rhs> > {
-  typedef CwiseBinaryOp<scalar_disjunction_op<DupFunc, T1, T2>, Lhs, Rhs> XprType;
-  typedef sparse_disjunction_evaluator<XprType> Base;
+  using XprType = CwiseBinaryOp<scalar_disjunction_op<DupFunc, T1, T2>, Lhs, Rhs>;
+  using Base = sparse_disjunction_evaluator<XprType>;
   explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
 };
 }  // namespace internal
@@ -858,7 +853,7 @@
 template <typename Derived>
 template <typename OtherDerived>
 Derived& SparseMatrixBase<Derived>::operator-=(const EigenBase<OtherDerived>& other) {
-  call_assignment(derived(), other.derived(), internal::assign_op<Scalar, typename OtherDerived::Scalar>());
+  call_assignment(derived(), other.derived(), internal::sub_assign_op<Scalar, typename OtherDerived::Scalar>());
   return derived();
 }
 
diff --git a/Eigen/src/SparseCore/SparseCwiseUnaryOp.h b/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
index 9fc1e66..18bf52a 100644
--- a/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
+++ b/Eigen/src/SparseCore/SparseCwiseUnaryOp.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_CWISE_UNARY_OP_H
 #define EIGEN_SPARSE_CWISE_UNARY_OP_H
@@ -21,7 +22,7 @@
 struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IteratorBased>
     : public evaluator_base<CwiseUnaryOp<UnaryOp, ArgType> > {
  public:
-  typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;
+  using XprType = CwiseUnaryOp<UnaryOp, ArgType>;
 
   class InnerIterator;
 
@@ -38,7 +39,7 @@
   inline Index nonZerosEstimate() const { return m_argImpl.nonZerosEstimate(); }
 
  protected:
-  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  using EvalIterator = typename evaluator<ArgType>::InnerIterator;
 
   const UnaryOp m_functor;
   evaluator<ArgType> m_argImpl;
@@ -48,8 +49,8 @@
 class unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IteratorBased>::InnerIterator
     : public unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IteratorBased>::EvalIterator {
  protected:
-  typedef typename XprType::Scalar Scalar;
-  typedef typename unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IteratorBased>::EvalIterator Base;
+  using Scalar = typename XprType::Scalar;
+  using Base = typename unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IteratorBased>::EvalIterator;
 
  public:
   EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
@@ -73,7 +74,7 @@
 struct unary_evaluator<CwiseUnaryView<ViewOp, ArgType>, IteratorBased>
     : public evaluator_base<CwiseUnaryView<ViewOp, ArgType> > {
  public:
-  typedef CwiseUnaryView<ViewOp, ArgType> XprType;
+  using XprType = CwiseUnaryView<ViewOp, ArgType>;
 
   class InnerIterator;
 
@@ -88,7 +89,7 @@
   }
 
  protected:
-  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  using EvalIterator = typename evaluator<ArgType>::InnerIterator;
 
   const ViewOp m_functor;
   evaluator<ArgType> m_argImpl;
@@ -98,8 +99,8 @@
 class unary_evaluator<CwiseUnaryView<ViewOp, ArgType>, IteratorBased>::InnerIterator
     : public unary_evaluator<CwiseUnaryView<ViewOp, ArgType>, IteratorBased>::EvalIterator {
  protected:
-  typedef typename XprType::Scalar Scalar;
-  typedef typename unary_evaluator<CwiseUnaryView<ViewOp, ArgType>, IteratorBased>::EvalIterator Base;
+  using Scalar = typename XprType::Scalar;
+  using Base = typename unary_evaluator<CwiseUnaryView<ViewOp, ArgType>, IteratorBased>::EvalIterator;
 
  public:
   EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& unaryOp, Index outer)
@@ -121,7 +122,7 @@
 
 template <typename Derived>
 EIGEN_STRONG_INLINE Derived& SparseMatrixBase<Derived>::operator*=(const Scalar& other) {
-  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  using EvalIterator = typename internal::evaluator<Derived>::InnerIterator;
   internal::evaluator<Derived> thisEval(derived());
   for (Index j = 0; j < outerSize(); ++j)
     for (EvalIterator i(thisEval, j); i; ++i) i.valueRef() *= other;
@@ -130,7 +131,7 @@
 
 template <typename Derived>
 EIGEN_STRONG_INLINE Derived& SparseMatrixBase<Derived>::operator/=(const Scalar& other) {
-  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
+  using EvalIterator = typename internal::evaluator<Derived>::InnerIterator;
   internal::evaluator<Derived> thisEval(derived());
   for (Index j = 0; j < outerSize(); ++j)
     for (EvalIterator i(thisEval, j); i; ++i) i.valueRef() /= other;
diff --git a/Eigen/src/SparseCore/SparseDenseProduct.h b/Eigen/src/SparseCore/SparseDenseProduct.h
index 7512793..f0dfeae 100644
--- a/Eigen/src/SparseCore/SparseDenseProduct.h
+++ b/Eigen/src/SparseCore/SparseDenseProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEDENSEPRODUCT_H
 #define EIGEN_SPARSEDENSEPRODUCT_H
@@ -19,11 +20,11 @@
 
 template <>
 struct product_promote_storage_type<Sparse, Dense, OuterProduct> {
-  typedef Sparse ret;
+  using ret = Sparse;
 };
 template <>
 struct product_promote_storage_type<Dense, Sparse, OuterProduct> {
-  typedef Sparse ret;
+  using ret = Sparse;
 };
 
 // Type trait to detect if a sparse type supports direct compressed storage access
@@ -41,12 +42,11 @@
 template <typename SparseLhsType, typename DenseRhsType, typename DenseResType>
 struct sparse_time_dense_product_impl<SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar,
                                       RowMajor, true> {
-  typedef internal::remove_all_t<SparseLhsType> Lhs;
-  typedef internal::remove_all_t<DenseRhsType> Rhs;
-  typedef internal::remove_all_t<DenseResType> Res;
-  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename Res::Scalar ResScalar;
+  using Lhs = internal::remove_all_t<SparseLhsType>;
+  using Res = internal::remove_all_t<DenseResType>;
+  using LhsInnerIterator = typename evaluator<Lhs>::InnerIterator;
+  using LhsEval = evaluator<Lhs>;
+  using ResScalar = typename Res::Scalar;
 
   static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res,
                   const typename Res::Scalar& alpha) {
@@ -54,14 +54,14 @@
     Index n = lhs.outerSize();
 
     for (Index c = 0; c < rhs.cols(); ++c) {
-      runCol(lhsEval, lhs, rhs, res, alpha, n, c, std::integral_constant<bool, has_compressed_storage<Lhs>::value>());
+      runCol(lhsEval, lhs, rhs, res, alpha, n, c, bool_constant<has_compressed_storage<Lhs>::value>());
     }
   }
 
   // Direct pointer path: works for both compressed and non-compressed storage.
   static void runCol(const LhsEval& /*lhsEval*/, const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res,
                      const ResScalar& alpha, Index n, Index c, std::true_type /* has_compressed_storage */) {
-    runColImpl(lhs, rhs, res, alpha, n, c, std::integral_constant<bool, bool(DenseRhsType::Flags & DirectAccessBit)>());
+    runColImpl(lhs, rhs, res, alpha, n, c, bool_constant<bool(DenseRhsType::Flags & DirectAccessBit)>());
   }
 
   template <typename RhsT>
@@ -82,8 +82,7 @@
 #pragma omp parallel for schedule(dynamic, (n + threads * 4 - 1) / (threads * 4)) num_threads(threads)
         for (Index i = 0; i < n; ++i) {
           Index k = outer ? outer[i] : 0;
-          const Index end = innerNnz ? (outer ? outer[i] : 0) + innerNnz[i]
-                                     : (outer ? outer[i + 1] : mat.nonZeros());
+          const Index end = innerNnz ? (outer ? outer[i] : 0) + innerNnz[i] : (outer ? outer[i + 1] : mat.nonZeros());
           ResScalar sum0(0), sum1(0);
           for (; k < end; ++k) {
             sum0 += vals[k] * x[inds[k]];
@@ -99,8 +98,7 @@
       {
         for (Index i = 0; i < n; ++i) {
           Index k = outer ? outer[i] : 0;
-          const Index end = innerNnz ? (outer ? outer[i] : 0) + innerNnz[i]
-                                     : (outer ? outer[i + 1] : mat.nonZeros());
+          const Index end = innerNnz ? (outer ? outer[i] : 0) + innerNnz[i] : (outer ? outer[i + 1] : mat.nonZeros());
           // Two independent accumulators to break the dependency chain
           ResScalar sum0(0), sum1(0);
           for (; k < end; ++k) {
@@ -130,8 +128,7 @@
     // Non-unit rhs stride (or no direct access): use direct pointers for sparse side, coeff() for rhs
     for (Index i = 0; i < n; ++i) {
       Index k = outer ? outer[i] : 0;
-      const Index end = innerNnz ? (outer ? outer[i] : 0) + innerNnz[i]
-                                 : (outer ? outer[i + 1] : mat.nonZeros());
+      const Index end = innerNnz ? (outer ? outer[i] : 0) + innerNnz[i] : (outer ? outer[i + 1] : mat.nonZeros());
       ResScalar sum0(0), sum1(0);
       for (; k < end; ++k) {
         sum0 += vals[k] * rhs.coeff(inds[k], c);
@@ -177,21 +174,21 @@
 // ColMajor, single column (ColPerCol=true): CSC SpMV
 template <typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
 struct sparse_time_dense_product_impl<SparseLhsType, DenseRhsType, DenseResType, AlphaType, ColMajor, true> {
-  typedef internal::remove_all_t<SparseLhsType> Lhs;
-  typedef internal::remove_all_t<DenseRhsType> Rhs;
-  typedef internal::remove_all_t<DenseResType> Res;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename LhsEval::InnerIterator LhsInnerIterator;
+  using Lhs = internal::remove_all_t<SparseLhsType>;
+  using Rhs = internal::remove_all_t<DenseRhsType>;
+  using Res = internal::remove_all_t<DenseResType>;
+  using LhsEval = evaluator<Lhs>;
+  using LhsInnerIterator = typename LhsEval::InnerIterator;
 
   static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha) {
-    runImpl(lhs, rhs, res, alpha, std::integral_constant<bool, has_compressed_storage<Lhs>::value>());
+    runImpl(lhs, rhs, res, alpha, bool_constant<has_compressed_storage<Lhs>::value>());
   }
 
   // Direct pointer path: works for both compressed and non-compressed storage.
   static void runImpl(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha,
                       std::true_type /* has_compressed_storage */) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Lhs::StorageIndex StorageIndex;
+    using LhsScalar = typename Lhs::Scalar;
+    using StorageIndex = typename Lhs::StorageIndex;
     const Lhs& mat = lhs;
     const LhsScalar* vals = mat.valuePtr();
     const StorageIndex* inds = mat.innerIndexPtr();
@@ -200,33 +197,136 @@
     const auto* innerNnz = mat.innerNonZeroPtr();
     // The fast result pointer path requires contiguous ColMajor result layout.
     // Transpose<ColMajor> reports innerStride()==1 but is actually RowMajor, so check both.
-    if (!(Res::Flags & RowMajorBit) && res.innerStride() == 1) {
-      for (Index c = 0; c < rhs.cols(); ++c) {
-        typename Res::Scalar* y = res.data() + c * res.outerStride();
-        for (Index j = 0; j < lhs.outerSize(); ++j) {
-          typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j, c));
-          const Index start = outer ? outer[j] : 0;
-          const Index end = innerNnz ? start + innerNnz[j] : (outer ? outer[j + 1] : mat.nonZeros());
-          Index k = start;
-          // 4-way unrolled scatter-add (no SIMD: writes are scattered)
-          for (; k + 3 < end; k += 4) {
-            y[inds[k]] += vals[k] * rhs_j;
-            y[inds[k + 1]] += vals[k + 1] * rhs_j;
-            y[inds[k + 2]] += vals[k + 2] * rhs_j;
-            y[inds[k + 3]] += vals[k + 3] * rhs_j;
+    EIGEN_IF_CONSTEXPR (!(Res::Flags & RowMajorBit)) {
+      if (res.innerStride() == 1) {
+        const Index n = lhs.outerSize();
+        // The threaded scatter+reduce path relies on a thread_local scratch buffer for
+        // host-thread safety (see below), so it is only available where thread_local is
+        // usable; under EIGEN_AVOID_THREAD_LOCAL fall through to the serial scatter.
+#if defined(EIGEN_HAS_OPENMP) && !defined(EIGEN_AVOID_THREAD_LOCAL)
+        using ResScalar = typename Res::Scalar;
+        const Index m = res.rows();
+        const Index threads = Eigen::nbThreads();
+        // Per-thread scratch + reduction: the natural per-column partition would
+        // race on the output (writes to y[inds[k]] are scattered across rows),
+        // so each thread accumulates into its own m-sized output buffer and the
+        // results are summed at the end. Activated above the same 20000-nnz
+        // threshold as the RowMajor kernel, plus a second gate on per-thread
+        // scratch size: `threads * m` scalars are touched by the reduction,
+        // and on tall / very-sparse matrices that can dwarf the SpMV cost --
+        // require avg nnz per row >= threads so the reduction can't dominate.
+        // `outer` is null for SparseVector lhs; the nnz-balanced partition needs
+        // the outer-index array, so fall back to the serial scatter below.
+        if (outer && threads > 1 && mat.nonZeros() > 20000 && mat.nonZeros() >= Index(threads) * m) {
+          // Per-calling-thread persistent scratch (per template instantiation).
+          // Grows monotonically; reused across calls. The buffer is left at
+          // all-zeros after each call by folding the zero-out into the reduction
+          // step, which avoids a separate init pass on every SpMV. `thread_local`
+          // is required: two unrelated host threads concurrently calling
+          // y = A*x would otherwise race on this static buffer (and a reallocating
+          // grow on one would dangle the other's scratch_ptr).
+          thread_local static std::vector<ResScalar> scratch_buf;
+          const std::size_t need = static_cast<std::size_t>(threads) * static_cast<std::size_t>(m);
+          if (scratch_buf.size() < need) scratch_buf.assign(need, ResScalar(0));
+          ResScalar* scratch_ptr = scratch_buf.data();
+          // nnz-balanced column partition: each thread t owns the contiguous
+          // column range [part[t], part[t+1]). Deterministic mapping of j to
+          // thread (required for bit-reproducible reduction below) AND
+          // nnz-balanced load (dynamic scheduling would balance but break
+          // determinism; static round-robin would be deterministic but
+          // imbalanced on skewed matrices).
+          std::vector<Index> part(static_cast<std::size_t>(threads) + 1);
+          part[threads] = n;
+          part[0] = 0;
+          // Targets are monotonically increasing in t, so each lower_bound starts
+          // from the previous result; total work is O(T + log n) rather than
+          // T * log n.
+          const StorageIndex* const part_last = outer + n + 1;
+          const StorageIndex* part_lo = outer;
+          for (Index t = 1; t < threads; ++t) {
+            const Index target = (t * mat.nonZeros()) / threads;
+            part_lo = std::lower_bound(part_lo, part_last, StorageIndex(target));
+            part[t] = part_lo - outer;
           }
-          for (; k < end; ++k) y[inds[k]] += vals[k] * rhs_j;
+          for (Index c = 0; c < rhs.cols(); ++c) {
+            typename Res::Scalar* y = res.data() + c * res.outerStride();
+#pragma omp parallel for schedule(static, 1) num_threads(threads)
+            for (Index t = 0; t < threads; ++t) {
+              ResScalar* yt = scratch_ptr + t * m;
+              const Index j_lo = part[t], j_hi = part[t + 1];
+              for (Index j = j_lo; j < j_hi; ++j) {
+                typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha *
+                                                                                                 rhs.coeff(j, c));
+                const Index start = outer ? outer[j] : 0;
+                const Index end = innerNnz ? start + innerNnz[j] : (outer ? outer[j + 1] : mat.nonZeros());
+                Index k = start;
+                for (; k + 3 < end; k += 4) {
+                  yt[inds[k]] += vals[k] * rhs_j;
+                  yt[inds[k + 1]] += vals[k + 1] * rhs_j;
+                  yt[inds[k + 2]] += vals[k + 2] * rhs_j;
+                  yt[inds[k + 3]] += vals[k + 3] * rhs_j;
+                }
+                for (; k < end; ++k) yt[inds[k]] += vals[k] * rhs_j;
+              }
+            }
+            // Reduce per-thread buffers into y AND zero them, so the next call
+            // doesn't have to re-init. Process rows in cache-resident blocks: the
+            // natural [t*m+i] scratch layout makes the cross-thread read for a
+            // single row a stride-m gather (one cache line per thread, ~threads*m
+            // bytes apart, unvectorizable). Blocking lets each thread's stripe be
+            // swept as a unit-stride, vectorizable stream into a small per-block
+            // accumulator. Each thread owns a contiguous range of row blocks
+            // (static schedule) so the zero stores stay independent, and the
+            // accumulator is summed in the exact t = 0..threads-1 order, keeping
+            // the result bit-identical to the scalar reduction it replaces.
+            constexpr Index kReduceBlock = 512;
+#pragma omp parallel for schedule(static) num_threads(threads)
+            for (Index i0 = 0; i0 < m; i0 += kReduceBlock) {
+              const Index i1 = numext::mini(i0 + kReduceBlock, m);
+              const Index len = i1 - i0;
+              EIGEN_ALIGN_MAX ResScalar acc[kReduceBlock];
+              for (Index ii = 0; ii < len; ++ii) acc[ii] = ResScalar(0);
+              for (Index t = 0; t < threads; ++t) {
+                ResScalar* row = scratch_ptr + t * m + i0;
+                for (Index ii = 0; ii < len; ++ii) {
+                  acc[ii] += row[ii];
+                  row[ii] = ResScalar(0);
+                }
+              }
+              for (Index ii = 0; ii < len; ++ii) y[i0 + ii] += acc[ii];
+            }
+          }
+        } else
+#endif
+        {
+          for (Index c = 0; c < rhs.cols(); ++c) {
+            typename Res::Scalar* y = res.data() + c * res.outerStride();
+            for (Index j = 0; j < n; ++j) {
+              typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j, c));
+              const Index start = outer ? outer[j] : 0;
+              const Index end = innerNnz ? start + innerNnz[j] : (outer ? outer[j + 1] : mat.nonZeros());
+              Index k = start;
+              // 4-way unrolled scatter-add (no SIMD: writes are scattered)
+              for (; k + 3 < end; k += 4) {
+                y[inds[k]] += vals[k] * rhs_j;
+                y[inds[k + 1]] += vals[k + 1] * rhs_j;
+                y[inds[k + 2]] += vals[k + 2] * rhs_j;
+                y[inds[k + 3]] += vals[k + 3] * rhs_j;
+              }
+              for (; k < end; ++k) y[inds[k]] += vals[k] * rhs_j;
+            }
+          }
         }
+        return;
       }
-    } else {
-      // Non-unit result stride: use coeffRef() for result access
-      for (Index c = 0; c < rhs.cols(); ++c) {
-        for (Index j = 0; j < lhs.outerSize(); ++j) {
-          typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j, c));
-          const Index start = outer ? outer[j] : 0;
-          const Index end = innerNnz ? start + innerNnz[j] : (outer ? outer[j + 1] : mat.nonZeros());
-          for (Index k = start; k < end; ++k) res.coeffRef(inds[k], c) += vals[k] * rhs_j;
-        }
+    }
+    // Non-unit result stride: use coeffRef() for result access
+    for (Index c = 0; c < rhs.cols(); ++c) {
+      for (Index j = 0; j < lhs.outerSize(); ++j) {
+        typename ScalarBinaryOpTraits<AlphaType, typename Rhs::Scalar>::ReturnType rhs_j(alpha * rhs.coeff(j, c));
+        const Index start = outer ? outer[j] : 0;
+        const Index end = innerNnz ? start + innerNnz[j] : (outer ? outer[j + 1] : mat.nonZeros());
+        for (Index k = start; k < end; ++k) res.coeffRef(inds[k], c) += vals[k] * rhs_j;
       }
     }
   }
@@ -248,11 +348,10 @@
 template <typename SparseLhsType, typename DenseRhsType, typename DenseResType>
 struct sparse_time_dense_product_impl<SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar,
                                       RowMajor, false> {
-  typedef internal::remove_all_t<SparseLhsType> Lhs;
-  typedef internal::remove_all_t<DenseRhsType> Rhs;
-  typedef internal::remove_all_t<DenseResType> Res;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename LhsEval::InnerIterator LhsInnerIterator;
+  using Lhs = internal::remove_all_t<SparseLhsType>;
+  using Res = internal::remove_all_t<DenseResType>;
+  using LhsEval = evaluator<Lhs>;
+  using LhsInnerIterator = typename LhsEval::InnerIterator;
 
   static constexpr bool IsCompressedLhs = has_compressed_storage<Lhs>::value;
 
@@ -267,31 +366,27 @@
     // It basically represents the minimal amount of work to be done to be worth it.
     if (threads > 1 && lhsEval.nonZerosEstimate() * rhs.cols() > 20000) {
 #pragma omp parallel for schedule(dynamic, (n + threads * 4 - 1) / (threads * 4)) num_threads(threads)
-      for (Index i = 0; i < n; ++i)
-        processRow(lhsEval, lhs, rhs, res, alpha, i, std::integral_constant<bool, IsCompressedLhs>());
+      for (Index i = 0; i < n; ++i) processRow(lhsEval, lhs, rhs, res, alpha, i, bool_constant<IsCompressedLhs>());
     } else
 #endif
     {
-      for (Index i = 0; i < n; ++i)
-        processRow(lhsEval, lhs, rhs, res, alpha, i, std::integral_constant<bool, IsCompressedLhs>());
+      for (Index i = 0; i < n; ++i) processRow(lhsEval, lhs, rhs, res, alpha, i, bool_constant<IsCompressedLhs>());
     }
   }
 
   // Direct pointer path: works for both compressed and non-compressed storage.
   static void processRow(const LhsEval& /*lhsEval*/, const SparseLhsType& lhs, const DenseRhsType& rhs, Res& res,
                          const typename Res::Scalar& alpha, Index i, std::true_type /* has_compressed_storage */) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Lhs::StorageIndex StorageIndex;
+    using LhsScalar = typename Lhs::Scalar;
+    using StorageIndex = typename Lhs::StorageIndex;
     const Lhs& mat = lhs;
     const LhsScalar* vals = mat.valuePtr();
     const StorageIndex* inds = mat.innerIndexPtr();
     // Sparse vectors don't store outer indices.
     const Index start = mat.outerIndexPtr() ? mat.outerIndexPtr()[i] : 0;
     const auto* innerNnz = mat.innerNonZeroPtr();
-    const Index end = innerNnz
-                          ? start + innerNnz[i]
-                          : (mat.outerIndexPtr() ? mat.outerIndexPtr()[i + 1]
-                                                 : mat.nonZeros());
+    const Index end =
+        innerNnz ? start + innerNnz[i] : (mat.outerIndexPtr() ? mat.outerIndexPtr()[i + 1] : mat.nonZeros());
     typename Res::RowXpr res_i(res.row(i));
     for (Index k = start; k < end; ++k) res_i += (alpha * vals[k]) * rhs.row(inds[k]);
   }
@@ -307,21 +402,21 @@
 template <typename SparseLhsType, typename DenseRhsType, typename DenseResType>
 struct sparse_time_dense_product_impl<SparseLhsType, DenseRhsType, DenseResType, typename DenseResType::Scalar,
                                       ColMajor, false> {
-  typedef internal::remove_all_t<SparseLhsType> Lhs;
-  typedef internal::remove_all_t<DenseRhsType> Rhs;
-  typedef internal::remove_all_t<DenseResType> Res;
-  typedef typename evaluator<Lhs>::InnerIterator LhsInnerIterator;
+  using Lhs = internal::remove_all_t<SparseLhsType>;
+  using Rhs = internal::remove_all_t<DenseRhsType>;
+  using Res = internal::remove_all_t<DenseResType>;
+  using LhsInnerIterator = typename evaluator<Lhs>::InnerIterator;
 
   static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res,
                   const typename Res::Scalar& alpha) {
-    runImpl(lhs, rhs, res, alpha, std::integral_constant<bool, has_compressed_storage<Lhs>::value>());
+    runImpl(lhs, rhs, res, alpha, bool_constant<has_compressed_storage<Lhs>::value>());
   }
 
   // Direct pointer path: works for both compressed and non-compressed storage.
   static void runImpl(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res,
                       const typename Res::Scalar& alpha, std::true_type /* has_compressed_storage */) {
-    typedef typename Lhs::Scalar LhsScalar;
-    typedef typename Lhs::StorageIndex StorageIndex;
+    using LhsScalar = typename Lhs::Scalar;
+    using StorageIndex = typename Lhs::StorageIndex;
     const Lhs& mat = lhs;
     const LhsScalar* vals = mat.valuePtr();
     const StorageIndex* inds = mat.innerIndexPtr();
@@ -359,12 +454,12 @@
 template <typename Lhs, typename Rhs, int ProductType>
 struct generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, SparseShape, DenseShape, ProductType> > {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
-    typedef typename nested_eval<Lhs, ((Rhs::Flags & RowMajorBit) == 0) ? 1 : Rhs::ColsAtCompileTime>::type LhsNested;
-    typedef typename nested_eval<Rhs, ((Lhs::Flags & RowMajorBit) == 0) ? 1 : Dynamic>::type RhsNested;
+    using LhsNested = typename nested_eval<Lhs, ((Rhs::Flags & RowMajorBit) == 0) ? 1 : Rhs::ColsAtCompileTime>::type;
+    using RhsNested = typename nested_eval<Rhs, ((Lhs::Flags & RowMajorBit) == 0) ? 1 : Dynamic>::type;
     LhsNested lhsNested(lhs);
     RhsNested rhsNested(rhs);
     internal::sparse_time_dense_product(lhsNested, rhsNested, dst, alpha);
@@ -378,13 +473,13 @@
 template <typename Lhs, typename Rhs, int ProductType>
 struct generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType>
     : generic_product_impl_base<Lhs, Rhs, generic_product_impl<Lhs, Rhs, DenseShape, SparseShape, ProductType> > {
-  typedef typename Product<Lhs, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<Lhs, Rhs>::Scalar;
 
   template <typename Dst>
   static void scaleAndAddTo(Dst& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha) {
-    typedef typename nested_eval<Lhs, ((Rhs::Flags & RowMajorBit) == 0) ? Dynamic : 1>::type LhsNested;
-    typedef typename nested_eval<Rhs, ((Lhs::Flags & RowMajorBit) == RowMajorBit) ? 1 : Lhs::RowsAtCompileTime>::type
-        RhsNested;
+    using LhsNested = typename nested_eval<Lhs, ((Rhs::Flags & RowMajorBit) == 0) ? Dynamic : 1>::type;
+    using RhsNested =
+        typename nested_eval<Rhs, ((Lhs::Flags & RowMajorBit) == RowMajorBit) ? 1 : Lhs::RowsAtCompileTime>::type;
     LhsNested lhsNested(lhs);
     RhsNested rhsNested(rhs);
 
@@ -401,23 +496,21 @@
 template <typename LhsT, typename RhsT, bool NeedToTranspose>
 struct sparse_dense_outer_product_evaluator {
  protected:
-  typedef std::conditional_t<NeedToTranspose, RhsT, LhsT> Lhs1;
-  typedef std::conditional_t<NeedToTranspose, LhsT, RhsT> ActualRhs;
-  typedef Product<LhsT, RhsT, DefaultProduct> ProdXprType;
+  using Lhs1 = std::conditional_t<NeedToTranspose, RhsT, LhsT>;
+  using ActualRhs = std::conditional_t<NeedToTranspose, LhsT, RhsT>;
+  using ProdXprType = Product<LhsT, RhsT, DefaultProduct>;
 
   // if the actual left-hand side is a dense vector,
   // then build a sparse-view so that we can seamlessly iterate over it.
-  typedef std::conditional_t<is_same<typename internal::traits<Lhs1>::StorageKind, Sparse>::value, Lhs1,
-                             SparseView<Lhs1> >
-      ActualLhs;
-  typedef std::conditional_t<is_same<typename internal::traits<Lhs1>::StorageKind, Sparse>::value, Lhs1 const&,
-                             SparseView<Lhs1> >
-      LhsArg;
+  using ActualLhs = std::conditional_t<std::is_same<typename internal::traits<Lhs1>::StorageKind, Sparse>::value, Lhs1,
+                                       SparseView<Lhs1>>;
+  using LhsArg = std::conditional_t<std::is_same<typename internal::traits<Lhs1>::StorageKind, Sparse>::value,
+                                    const Lhs1&, SparseView<Lhs1>>;
 
-  typedef evaluator<ActualLhs> LhsEval;
-  typedef evaluator<ActualRhs> RhsEval;
-  typedef typename evaluator<ActualLhs>::InnerIterator LhsIterator;
-  typedef typename ProdXprType::Scalar Scalar;
+  using LhsEval = evaluator<ActualLhs>;
+  using RhsEval = evaluator<ActualRhs>;
+  using LhsIterator = typename evaluator<ActualLhs>::InnerIterator;
+  using Scalar = typename ProdXprType::Scalar;
 
  public:
   enum { Flags = NeedToTranspose ? RowMajorBit : 0, CoeffReadCost = HugeCost };
@@ -473,10 +566,10 @@
 template <typename Lhs, typename Rhs>
 struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, SparseShape, DenseShape>
     : sparse_dense_outer_product_evaluator<Lhs, Rhs, Lhs::IsRowMajor> {
-  typedef sparse_dense_outer_product_evaluator<Lhs, Rhs, Lhs::IsRowMajor> Base;
+  using Base = sparse_dense_outer_product_evaluator<Lhs, Rhs, Lhs::IsRowMajor>;
 
-  typedef Product<Lhs, Rhs> XprType;
-  typedef typename XprType::PlainObject PlainObject;
+  using XprType = Product<Lhs, Rhs>;
+  using PlainObject = typename XprType::PlainObject;
 
   explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs()) {}
 };
@@ -484,10 +577,10 @@
 template <typename Lhs, typename Rhs>
 struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, DenseShape, SparseShape>
     : sparse_dense_outer_product_evaluator<Lhs, Rhs, Rhs::IsRowMajor> {
-  typedef sparse_dense_outer_product_evaluator<Lhs, Rhs, Rhs::IsRowMajor> Base;
+  using Base = sparse_dense_outer_product_evaluator<Lhs, Rhs, Rhs::IsRowMajor>;
 
-  typedef Product<Lhs, Rhs> XprType;
-  typedef typename XprType::PlainObject PlainObject;
+  using XprType = Product<Lhs, Rhs>;
+  using PlainObject = typename XprType::PlainObject;
 
   explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs()) {}
 };
diff --git a/Eigen/src/SparseCore/SparseDiagonalProduct.h b/Eigen/src/SparseCore/SparseDiagonalProduct.h
index e02fdaa..10bac4a 100644
--- a/Eigen/src/SparseCore/SparseDiagonalProduct.h
+++ b/Eigen/src/SparseCore/SparseDiagonalProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_DIAGONAL_PRODUCT_H
 #define EIGEN_SPARSE_DIAGONAL_PRODUCT_H
@@ -17,7 +18,7 @@
 
 // The product of a diagonal matrix with a sparse matrix can be easily
 // implemented using expression template.
-// We have two consider very different cases:
+// We have to consider two very different cases:
 // 1 - diag * row-major sparse
 //     => each inner vector <=> scalar * sparse vector product
 //     => so we can reuse CwiseUnaryOp::InnerIterator
@@ -38,46 +39,187 @@
 struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape>
     : public sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType,
                                                Rhs::Flags & RowMajorBit ? SDP_AsScalarProduct : SDP_AsCwiseProduct> {
-  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  using XprType = Product<Lhs, Rhs, DefaultProduct>;
   enum {
     CoeffReadCost = HugeCost,
     Flags = Rhs::Flags & RowMajorBit,
     Alignment = 0
   };  // FIXME: compute proper CoeffReadCost and propagate Flags.
 
-  typedef sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType,
-                                            Rhs::Flags & RowMajorBit ? SDP_AsScalarProduct : SDP_AsCwiseProduct>
-      Base;
-  explicit product_evaluator(const XprType &xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {}
+  using Base = sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType,
+                                                 Rhs::Flags & RowMajorBit ? SDP_AsScalarProduct : SDP_AsCwiseProduct>;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {}
 };
 
 template <typename Lhs, typename Rhs, int ProductTag>
 struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseShape, DiagonalShape>
     : public sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>,
                                                Lhs::Flags & RowMajorBit ? SDP_AsCwiseProduct : SDP_AsScalarProduct> {
-  typedef Product<Lhs, Rhs, DefaultProduct> XprType;
+  using XprType = Product<Lhs, Rhs, DefaultProduct>;
   enum {
     CoeffReadCost = HugeCost,
     Flags = Lhs::Flags & RowMajorBit,
     Alignment = 0
   };  // FIXME: compute proper CoeffReadCost and propagate Flags.
 
-  typedef sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>,
-                                            Lhs::Flags & RowMajorBit ? SDP_AsCwiseProduct : SDP_AsScalarProduct>
-      Base;
-  explicit product_evaluator(const XprType &xpr) : Base(xpr.lhs(), xpr.rhs().diagonal().transpose()) {}
+  using Base = sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>,
+                                                 Lhs::Flags & RowMajorBit ? SDP_AsCwiseProduct : SDP_AsScalarProduct>;
+  explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal().transpose()) {}
+};
+
+// SparseSelfAdjointView synthesizes mirrored entries; build the diagonal-scaled
+// full result directly instead of first materializing an unscaled PlainObject.
+template <int Mode, int ProductOrder, typename SelfAdjointViewType, typename DiagonalType, typename Dest>
+struct sparse_selfadjoint_diagonal_product_impl {
+  using MatrixType = typename SelfAdjointViewType::MatrixTypeNested_;
+  using MatrixEvaluator = evaluator<MatrixType>;
+  using MatrixIterator = typename MatrixEvaluator::InnerIterator;
+  using StorageIndex = typename Dest::StorageIndex;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
+  enum { IsFullMode = Mode == int(Upper | Lower), IsLowerMode = (Mode & int(Lower)) == int(Lower) };
+
+  static void run(Dest& dest, const SelfAdjointViewType& selfadjoint, const DiagonalType& diagonal) {
+    MatrixEvaluator matrixEval(selfadjoint.matrix());
+    const Index size = selfadjoint.rows();
+    VectorI count(size);
+    count.setZero();
+    dest.resize(size, size);
+
+    for (Index outer = 0; outer < selfadjoint.matrix().outerSize(); ++outer) {
+      for (MatrixIterator it(matrixEval, outer); it; ++it) countEntry(count, it.row(), it.col());
+    }
+
+    Index nnz = count.sum();
+    dest.resizeNonZeros(nnz);
+    dest.outerIndexPtr()[0] = 0;
+    for (Index outer = 0; outer < size; ++outer)
+      dest.outerIndexPtr()[outer + 1] = dest.outerIndexPtr()[outer] + count[outer];
+    for (Index outer = 0; outer < size; ++outer) count[outer] = dest.outerIndexPtr()[outer];
+
+    for (Index outer = 0; outer < selfadjoint.matrix().outerSize(); ++outer) {
+      for (MatrixIterator it(matrixEval, outer); it; ++it) {
+        const Index row = it.row();
+        const Index col = it.col();
+        if (isStored(row, col)) {
+          insertEntry(dest, count, diagonal, row, col, it.value());
+        }
+        if (mirrorsStoredEntry(row, col)) {
+          insertEntry(dest, count, diagonal, col, row, numext::conj(it.value()));
+        }
+      }
+    }
+  }
+
+ private:
+  static EIGEN_STRONG_INLINE bool isStored(Index row, Index col) {
+    return IsFullMode || row == col || (IsLowerMode ? row > col : row < col);
+  }
+
+  static EIGEN_STRONG_INLINE bool mirrorsStoredEntry(Index row, Index col) {
+    return !IsFullMode && row != col && (IsLowerMode ? row > col : row < col);
+  }
+
+  static void countEntry(VectorI& count, Index row, Index col) {
+    if (isStored(row, col)) {
+      ++count[outerIndex(row, col)];
+    }
+    if (mirrorsStoredEntry(row, col)) {
+      ++count[outerIndex(col, row)];
+    }
+  }
+
+  static EIGEN_STRONG_INLINE StorageIndex outerIndex(Index row, Index col) {
+    return internal::convert_index<StorageIndex>(Dest::IsRowMajor ? row : col);
+  }
+
+  static EIGEN_STRONG_INLINE StorageIndex innerIndex(Index row, Index col) {
+    return internal::convert_index<StorageIndex>(Dest::IsRowMajor ? col : row);
+  }
+
+  template <typename Coeff>
+  static void insertEntry(Dest& dest, VectorI& count, const DiagonalType& diagonal, Index row, Index col,
+                          const Coeff& coeff) {
+    const StorageIndex outer = outerIndex(row, col);
+    const Index k = count[outer]++;
+    dest.innerIndexPtr()[k] = innerIndex(row, col);
+    EIGEN_IF_CONSTEXPR (ProductOrder == OnTheLeft) {
+      dest.valuePtr()[k] = diagonal.coeff(row) * coeff;
+    } else {
+      dest.valuePtr()[k] = coeff * diagonal.coeff(col);
+    }
+  }
+};
+
+template <typename Lhs, typename Rhs>
+struct materialized_left_sparse_product_evaluator_base
+    : public evaluator<typename Product<Lhs, typename Rhs::PlainObject, DefaultProduct>::PlainObject> {
+  using XprType = Product<Lhs, Rhs, DefaultProduct>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
+
+  explicit materialized_left_sparse_product_evaluator_base(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) {
+    internal::construct_at<Base>(this, m_result);
+    sparse_selfadjoint_diagonal_product_impl<Rhs::Mode, OnTheLeft, Rhs, typename Lhs::DiagonalVectorType,
+                                             PlainObject>::run(m_result, xpr.rhs(), xpr.lhs().diagonal());
+  }
+
+ protected:
+  PlainObject m_result;
+};
+
+template <typename Lhs, typename Rhs>
+struct materialized_right_sparse_product_evaluator_base
+    : public evaluator<typename Product<typename Lhs::PlainObject, Rhs, DefaultProduct>::PlainObject> {
+  using XprType = Product<Lhs, Rhs, DefaultProduct>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
+
+  explicit materialized_right_sparse_product_evaluator_base(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) {
+    internal::construct_at<Base>(this, m_result);
+    sparse_selfadjoint_diagonal_product_impl<Lhs::Mode, OnTheRight, Lhs, typename Rhs::DiagonalVectorType,
+                                             PlainObject>::run(m_result, xpr.lhs(), xpr.rhs().diagonal());
+  }
+
+ protected:
+  PlainObject m_result;
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseTriangularShape>
+    : product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape> {
+  using Base = product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape>;
+  using Base::Base;
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseSelfAdjointShape>
+    : materialized_left_sparse_product_evaluator_base<Lhs, Rhs> {
+  using materialized_left_sparse_product_evaluator_base<Lhs, Rhs>::materialized_left_sparse_product_evaluator_base;
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseTriangularShape, DiagonalShape>
+    : product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseShape, DiagonalShape> {
+  using Base = product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseShape, DiagonalShape>;
+  using Base::Base;
+};
+
+template <typename Lhs, typename Rhs, int ProductTag>
+struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, DiagonalShape>
+    : materialized_right_sparse_product_evaluator_base<Lhs, Rhs> {
+  using materialized_right_sparse_product_evaluator_base<Lhs, Rhs>::materialized_right_sparse_product_evaluator_base;
 };
 
 template <typename SparseXprType, typename DiagonalCoeffType>
 struct sparse_diagonal_product_evaluator<SparseXprType, DiagonalCoeffType, SDP_AsScalarProduct> {
  protected:
-  typedef typename evaluator<SparseXprType>::InnerIterator SparseXprInnerIterator;
-  typedef typename SparseXprType::Scalar Scalar;
+  using SparseXprInnerIterator = typename evaluator<SparseXprType>::InnerIterator;
+  using Scalar = typename SparseXprType::Scalar;
 
  public:
   class InnerIterator : public SparseXprInnerIterator {
    public:
-    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+    InnerIterator(const sparse_diagonal_product_evaluator& xprEval, Index outer)
         : SparseXprInnerIterator(xprEval.m_sparseXprImpl, outer), m_coeff(xprEval.m_diagCoeffImpl.coeff(outer)) {}
 
     EIGEN_STRONG_INLINE Scalar value() const { return m_coeff * SparseXprInnerIterator::value(); }
@@ -86,7 +228,7 @@
     typename DiagonalCoeffType::Scalar m_coeff;
   };
 
-  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagonalCoeffType &diagCoeff)
+  sparse_diagonal_product_evaluator(const SparseXprType& sparseXpr, const DiagonalCoeffType& diagCoeff)
       : m_sparseXprImpl(sparseXpr), m_diagCoeffImpl(diagCoeff) {}
 
   Index nonZerosEstimate() const { return m_sparseXprImpl.nonZerosEstimate(); }
@@ -98,18 +240,18 @@
 
 template <typename SparseXprType, typename DiagCoeffType>
 struct sparse_diagonal_product_evaluator<SparseXprType, DiagCoeffType, SDP_AsCwiseProduct> {
-  typedef typename SparseXprType::Scalar Scalar;
-  typedef typename SparseXprType::StorageIndex StorageIndex;
+  using Scalar = typename SparseXprType::Scalar;
+  using StorageIndex = typename SparseXprType::StorageIndex;
 
-  typedef typename nested_eval<DiagCoeffType, SparseXprType::IsRowMajor ? SparseXprType::RowsAtCompileTime
-                                                                        : SparseXprType::ColsAtCompileTime>::type
-      DiagCoeffNested;
+  using DiagCoeffNested =
+      typename nested_eval<DiagCoeffType, SparseXprType::IsRowMajor ? SparseXprType::RowsAtCompileTime
+                                                                    : SparseXprType::ColsAtCompileTime>::type;
 
   class InnerIterator {
-    typedef typename evaluator<SparseXprType>::InnerIterator SparseXprIter;
+    using SparseXprIter = typename evaluator<SparseXprType>::InnerIterator;
 
    public:
-    InnerIterator(const sparse_diagonal_product_evaluator &xprEval, Index outer)
+    InnerIterator(const sparse_diagonal_product_evaluator& xprEval, Index outer)
         : m_sparseIter(xprEval.m_sparseXprEval, outer), m_diagCoeffNested(xprEval.m_diagCoeffNested) {}
 
     inline Scalar value() const { return m_sparseIter.value() * m_diagCoeffNested.coeff(index()); }
@@ -118,7 +260,7 @@
     inline Index col() const { return SparseXprType::IsRowMajor ? m_sparseIter.index() : m_sparseIter.outer(); }
     inline Index row() const { return SparseXprType::IsRowMajor ? m_sparseIter.outer() : m_sparseIter.index(); }
 
-    EIGEN_STRONG_INLINE InnerIterator &operator++() {
+    EIGEN_STRONG_INLINE InnerIterator& operator++() {
       ++m_sparseIter;
       return *this;
     }
@@ -129,7 +271,7 @@
     DiagCoeffNested m_diagCoeffNested;
   };
 
-  sparse_diagonal_product_evaluator(const SparseXprType &sparseXpr, const DiagCoeffType &diagCoeff)
+  sparse_diagonal_product_evaluator(const SparseXprType& sparseXpr, const DiagCoeffType& diagCoeff)
       : m_sparseXprEval(sparseXpr), m_diagCoeffNested(diagCoeff) {}
 
   Index nonZerosEstimate() const { return m_sparseXprEval.nonZerosEstimate(); }
diff --git a/Eigen/src/SparseCore/SparseDot.h b/Eigen/src/SparseCore/SparseDot.h
index 485605f..4471036 100644
--- a/Eigen/src/SparseCore/SparseDot.h
+++ b/Eigen/src/SparseCore/SparseDot.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_DOT_H
 #define EIGEN_SPARSE_DOT_H
@@ -23,7 +24,7 @@
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
   EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived, OtherDerived)
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+      (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
   eigen_assert(size() == other.size());
@@ -53,7 +54,7 @@
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
   EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived, OtherDerived)
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+      (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
   eigen_assert(size() == other.size());
diff --git a/Eigen/src/SparseCore/SparseFuzzy.h b/Eigen/src/SparseCore/SparseFuzzy.h
index 2285845..5701778 100644
--- a/Eigen/src/SparseCore/SparseFuzzy.h
+++ b/Eigen/src/SparseCore/SparseFuzzy.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_FUZZY_H
 #define EIGEN_SPARSE_FUZZY_H
diff --git a/Eigen/src/SparseCore/SparseMap.h b/Eigen/src/SparseCore/SparseMap.h
index 73e29c7..ccffd83 100644
--- a/Eigen/src/SparseCore/SparseMap.h
+++ b/Eigen/src/SparseCore/SparseMap.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_MAP_H
 #define EIGEN_SPARSE_MAP_H
@@ -20,16 +21,16 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct traits<Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> >
     : public traits<SparseMatrix<MatScalar, MatOptions, MatIndex> > {
-  typedef SparseMatrix<MatScalar, MatOptions, MatIndex> PlainObjectType;
-  typedef traits<PlainObjectType> TraitsBase;
+  using PlainObjectType = SparseMatrix<MatScalar, MatOptions, MatIndex>;
+  using TraitsBase = traits<PlainObjectType>;
   enum { Flags = TraitsBase::Flags & (~NestByRefBit) };
 };
 
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct traits<Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> >
     : public traits<SparseMatrix<MatScalar, MatOptions, MatIndex> > {
-  typedef SparseMatrix<MatScalar, MatOptions, MatIndex> PlainObjectType;
-  typedef traits<PlainObjectType> TraitsBase;
+  using PlainObjectType = SparseMatrix<MatScalar, MatOptions, MatIndex>;
+  using TraitsBase = traits<PlainObjectType>;
   enum { Flags = TraitsBase::Flags & (~(NestByRefBit | LvalueBit)) };
 };
 
@@ -46,16 +47,16 @@
 template <typename Derived>
 class SparseMapBase<Derived, ReadOnlyAccessors> : public SparseCompressedBase<Derived> {
  public:
-  typedef SparseCompressedBase<Derived> Base;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::StorageIndex StorageIndex;
+  using Base = SparseCompressedBase<Derived>;
+  using Scalar = typename Base::Scalar;
+  using StorageIndex = typename Base::StorageIndex;
   enum { IsRowMajor = Base::IsRowMajor };
   using Base::operator=;
 
  protected:
-  typedef std::conditional_t<bool(internal::is_lvalue<Derived>::value), Scalar*, const Scalar*> ScalarPointer;
-  typedef std::conditional_t<bool(internal::is_lvalue<Derived>::value), StorageIndex*, const StorageIndex*>
-      IndexPointer;
+  using ScalarPointer = std::conditional_t<bool(internal::is_lvalue<Derived>::value), Scalar*, const Scalar*>;
+  using IndexPointer =
+      std::conditional_t<bool(internal::is_lvalue<Derived>::value), StorageIndex*, const StorageIndex*>;
 
   Index m_outerSize;
   Index m_innerSize;
@@ -131,11 +132,8 @@
         m_values(valuePtr),
         m_innerNonZeros(0) {}
 
-  /** Empty destructor */
-  inline ~SparseMapBase() {}
-
  protected:
-  inline SparseMapBase() {}
+  inline SparseMapBase() = default;
 };
 
 /** \ingroup SparseCore_Module
@@ -144,12 +142,10 @@
  */
 template <typename Derived>
 class SparseMapBase<Derived, WriteAccessors> : public SparseMapBase<Derived, ReadOnlyAccessors> {
-  typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
-
  public:
-  typedef SparseMapBase<Derived, ReadOnlyAccessors> Base;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::StorageIndex StorageIndex;
+  using Base = SparseMapBase<Derived, ReadOnlyAccessors>;
+  using Scalar = typename Base::Scalar;
+  using StorageIndex = typename Base::StorageIndex;
   enum { IsRowMajor = Base::IsRowMajor };
 
   using Base::operator=;
@@ -171,7 +167,13 @@
   inline StorageIndex* innerNonZeroPtr() { return Base::m_innerNonZeros; }
   //----------------------------------------
 
-  /** \copydoc SparseMatrix::coeffRef */
+  /** \returns a non-const reference to the value of the matrix at position \a row, \a col
+   *
+   * The element must already exist: unlike SparseMatrix::coeffRef, this function cannot insert a new one because
+   * \c *this does not own the buffers it points to.
+   *
+   * This is a O(log(nnz_j)) operation (binary search).
+   */
   inline Scalar& coeffRef(Index row, Index col) {
     const Index outer = IsRowMajor ? row : col;
     const Index inner = IsRowMajor ? col : row;
@@ -194,11 +196,8 @@
   inline SparseMapBase(Index size, Index nnz, StorageIndex* innerIndexPtr, Scalar* valuePtr)
       : Base(size, nnz, innerIndexPtr, valuePtr) {}
 
-  /** Empty destructor */
-  inline ~SparseMapBase() {}
-
  protected:
-  inline SparseMapBase() {}
+  inline SparseMapBase() = default;
 };
 
 /** \ingroup SparseCore_Module
@@ -220,7 +219,7 @@
 #endif
 {
  public:
-  typedef SparseMapBase<Map> Base;
+  using Base = SparseMapBase<Map>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
   enum { IsRowMajor = Base::IsRowMajor };
 
@@ -238,15 +237,13 @@
              Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
       : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr) {}
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-  /** Empty destructor */
-  inline ~Map() {}
 };
 
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 class Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>
     : public SparseMapBase<Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> > {
  public:
-  typedef SparseMapBase<Map> Base;
+  using Base = SparseMapBase<Map>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Map)
   enum { IsRowMajor = Base::IsRowMajor };
 
@@ -260,9 +257,6 @@
   inline Map(Index rows, Index cols, Index nnz, const StorageIndex* outerIndexPtr, const StorageIndex* innerIndexPtr,
              const Scalar* valuePtr, const StorageIndex* innerNonZerosPtr = 0)
       : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr) {}
-
-  /** Empty destructor */
-  inline ~Map() {}
 };
 
 namespace internal {
@@ -270,21 +264,19 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct evaluator<Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> >
     : evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> > > {
-  typedef evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> > >
-      Base;
-  typedef Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
+  using Base = evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>;
+  using XprType = Map<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>;
+  evaluator() = default;
   explicit evaluator(const XprType& mat) : Base(mat) {}
 };
 
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct evaluator<Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> >
     : evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> > > {
-  typedef evaluator<
-      SparseCompressedBase<Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> > >
-      Base;
-  typedef Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
+  using Base =
+      evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>;
+  using XprType = Map<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>;
+  evaluator() = default;
   explicit evaluator(const XprType& mat) : Base(mat) {}
 };
 
diff --git a/Eigen/src/SparseCore/SparseMatrix.h b/Eigen/src/SparseCore/SparseMatrix.h
index 36646c8..1b6456c 100644
--- a/Eigen/src/SparseCore/SparseMatrix.h
+++ b/Eigen/src/SparseCore/SparseMatrix.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEMATRIX_H
 #define EIGEN_SPARSEMATRIX_H
@@ -19,18 +20,18 @@
  *
  * \class SparseMatrix
  *
- * \brief A versatible sparse matrix representation
+ * \brief A versatile sparse matrix representation
  *
- * This class implements a more versatile variants of the common \em compressed row/column storage format.
- * Each colmun's (resp. row) non zeros are stored as a pair of value with associated row (resp. colmiun) index.
+ * This class implements a more versatile variant of the common \em compressed row/column storage format.
+ * Each column's (resp. row) non zeros are stored as a pair of value with associated row (resp. column) index.
  * All the non zeros are stored in a single large buffer. Unlike the \em compressed format, there might be extra
- * space in between the nonzeros of two successive colmuns (resp. rows) such that insertion of new non-zero
+ * space in between the nonzeros of two successive columns (resp. rows) such that insertion of new non-zero
  * can be done with limited memory reallocation and copies.
  *
  * A call to the function makeCompressed() turns the matrix into the standard \em compressed format
- * compatible with many library.
+ * compatible with many libraries.
  *
- * More details on this storage sceheme are given in the \ref TutorialSparse "manual pages".
+ * More details on this storage scheme are given in the \ref TutorialSparse "manual pages".
  *
  * \tparam Scalar_ the scalar type, i.e. the type of the coefficients
  * \tparam Options_ Union of bit flags controlling the storage scheme. Currently the only possibility
@@ -49,10 +50,10 @@
 namespace internal {
 template <typename Scalar_, int Options_, typename StorageIndex_>
 struct traits<SparseMatrix<Scalar_, Options_, StorageIndex_>> {
-  typedef Scalar_ Scalar;
-  typedef StorageIndex_ StorageIndex;
-  typedef Sparse StorageKind;
-  typedef MatrixXpr XprKind;
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using StorageKind = Sparse;
+  using XprKind = MatrixXpr;
   enum {
     RowsAtCompileTime = Dynamic,
     ColsAtCompileTime = Dynamic,
@@ -66,14 +67,14 @@
 
 template <typename Scalar_, int Options_, typename StorageIndex_, int DiagIndex>
 struct traits<Diagonal<SparseMatrix<Scalar_, Options_, StorageIndex_>, DiagIndex>> {
-  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> MatrixType;
-  typedef typename ref_selector<MatrixType>::type MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNested_;
+  using MatrixType = SparseMatrix<Scalar_, Options_, StorageIndex_>;
+  using MatrixTypeNested = typename ref_selector<MatrixType>::type;
+  using MatrixTypeNested_ = std::remove_reference_t<MatrixTypeNested>;
 
-  typedef Scalar_ Scalar;
-  typedef Dense StorageKind;
-  typedef StorageIndex_ StorageIndex;
-  typedef MatrixXpr XprKind;
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using StorageIndex = StorageIndex_;
+  using XprKind = MatrixXpr;
 
   enum {
     RowsAtCompileTime = Dynamic,
@@ -119,7 +120,7 @@
 
 template <typename Scalar_, int Options_, typename StorageIndex_>
 class SparseMatrix : public SparseCompressedBase<SparseMatrix<Scalar_, Options_, StorageIndex_>> {
-  typedef SparseCompressedBase<SparseMatrix> Base;
+  using Base = SparseCompressedBase<SparseMatrix>;
   using Base::convert_index;
   friend class SparseVector<Scalar_, 0, StorageIndex_>;
   template <typename, typename, typename, typename, typename>
@@ -132,21 +133,21 @@
   using Base::operator+=;
   using Base::operator-=;
 
-  typedef Eigen::Map<SparseMatrix<Scalar, Options_, StorageIndex>> Map;
-  typedef Diagonal<SparseMatrix> DiagonalReturnType;
-  typedef Diagonal<const SparseMatrix> ConstDiagonalReturnType;
-  typedef typename Base::InnerIterator InnerIterator;
-  typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+  using Map = Eigen::Map<SparseMatrix<Scalar, Options_, StorageIndex>>;
+  using DiagonalReturnType = Diagonal<SparseMatrix>;
+  using ConstDiagonalReturnType = Diagonal<const SparseMatrix>;
+  using InnerIterator = typename Base::InnerIterator;
+  using ReverseInnerIterator = typename Base::ReverseInnerIterator;
 
   using Base::IsRowMajor;
-  typedef internal::CompressedStorage<Scalar, StorageIndex> Storage;
+  using Storage = internal::CompressedStorage<Scalar, StorageIndex>;
   enum { Options = Options_ };
 
-  typedef typename Base::IndexVector IndexVector;
-  typedef typename Base::ScalarVector ScalarVector;
+  using IndexVector = typename Base::IndexVector;
+  using ScalarVector = typename Base::ScalarVector;
 
  protected:
-  typedef SparseMatrix<Scalar, IsRowMajor ? ColMajor : RowMajor, StorageIndex> TransposedSparseMatrix;
+  using TransposedSparseMatrix = SparseMatrix<Scalar, IsRowMajor ? ColMajor : RowMajor, StorageIndex>;
 
   Index m_outerSize;
   Index m_innerSize;
@@ -277,8 +278,9 @@
   /** \returns a reference to a novel non zero coefficient with coordinates \a row x \a col.
    * The non zero coefficient must \b not already exist.
    *
-   * If the matrix \c *this is in compressed mode, then \c *this is turned into uncompressed
-   * mode while reserving room for 2 x this->innerSize() non zeros if reserve(Index) has not been called earlier.
+   * If the matrix \c *this is in compressed mode, then \c *this is turned into uncompressed mode with no spare room;
+   * whenever an insertion finds no free slot in any inner vector, room for one additional element per inner vector is
+   * reserved.
    * In this case, the insertion procedure is optimized for a \e sequential insertion mode where elements are assumed to
    * be inserted by increasing outer-indices.
    *
@@ -353,7 +355,7 @@
       // turn the matrix into non-compressed mode
       m_innerNonZeros = internal::conditional_aligned_new_auto<StorageIndex, true>(m_outerSize);
 
-      // temporarily use m_innerSizes to hold the new starting points.
+      // temporarily use m_innerNonZeros to hold the new starting points.
       StorageIndex* newOuterIndex = m_innerNonZeros;
 
       Index count = 0;
@@ -416,7 +418,7 @@
    * - the nonzero does not already exist
    * - the new coefficient is the last one according to the storage order
    *
-   * Before filling a given inner vector you must call the statVec(Index) function.
+   * Before filling a given inner vector you must call the startVec(Index) function.
    *
    * After an insertion session, you should call the finalize() function.
    *
@@ -635,7 +637,8 @@
     prune(default_prunning_func(reference, epsilon));
   }
 
-  /** Turns the matrix into compressed format, and suppresses all nonzeros which do not satisfy the predicate \a keep.
+  /** Suppresses all nonzeros which do not satisfy the predicate \a keep. The storage format is preserved: an
+   * uncompressed matrix remains uncompressed, so call makeCompressed() if a compressed result is required.
    * The functor type \a KeepFunc must implement the following function:
    * \code
    * bool operator() (const Index& row, const Index& col, const Scalar& value) const;
@@ -724,6 +727,12 @@
     m_data.resize(newSize);
   }
 
+  /** \sa conservativeResize(Index,Index) */
+  void conservativeResize(NoChange_t, Index cols) { conservativeResize(rows(), cols); }
+
+  /** \sa conservativeResize(Index,Index) */
+  void conservativeResize(Index rows, NoChange_t) { conservativeResize(rows, cols()); }
+
   /** Resizes the matrix to a \a rows x \a cols matrix and initializes it to zero.
    *
    * This function does not free the currently allocated memory. To release as much as memory as possible,
@@ -749,6 +758,12 @@
     fill_n(m_outerIndex, m_outerSize + 1, StorageIndex(0));
   }
 
+  /** \sa resize(Index,Index) */
+  void resize(NoChange_t, Index cols) { resize(rows(), cols); }
+
+  /** \sa resize(Index,Index) */
+  void resize(Index rows, NoChange_t) { resize(rows, cols()); }
+
   /** \internal
    * Resize the nonzero vector to \a size */
   void resizeNonZeros(Index size) { m_data.resize(size); }
@@ -775,7 +790,7 @@
   inline SparseMatrix(const SparseMatrixBase<OtherDerived>& other)
       : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0) {
     EIGEN_STATIC_ASSERT(
-        (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+        (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
     const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
     if (needToTranspose)
@@ -827,7 +842,6 @@
   /** Swaps the content of two sparse matrices of the same type.
    * This is a fast operation that simply swaps the underlying pointers and parameters. */
   inline void swap(SparseMatrix& other) {
-    // EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
     std::swap(m_outerIndex, other.m_outerIndex);
     std::swap(m_innerSize, other.m_innerSize);
     std::swap(m_outerSize, other.m_outerSize);
@@ -951,19 +965,6 @@
   EIGEN_DEPRECATED EIGEN_DONT_INLINE Scalar& insertCompressed(Index row, Index col);
 
   /** \internal
-   * A vector object that is equal to 0 everywhere but v at the position i */
-  class SingletonVector {
-    StorageIndex m_index;
-    StorageIndex m_value;
-
-   public:
-    typedef StorageIndex value_type;
-    SingletonVector(Index i, Index v) : m_index(convert_index(i)), m_value(convert_index(v)) {}
-
-    StorageIndex operator[](Index i) const { return i == m_index ? m_value : 0; }
-  };
-
-  /** \internal
    * \sa insert(Index,Index) */
   EIGEN_DEPRECATED EIGEN_DONT_INLINE Scalar& insertUncompressed(Index row, Index col);
 
@@ -992,9 +993,9 @@
 
   /** \internal assign \a diagXpr to the diagonal of \c *this
    * There are different strategies:
-   *   1 - if *this is overwritten (Func==assign_op) or *this is empty, then we can work treat *this as a dense vector
+   *   1 - if *this is overwritten (Func==assign_op) or *this is empty, then we can treat *this as a dense vector
    * expression. 2 - otherwise, for each diagonal coeff, 2.a - if it already exists, then we update it, 2.b - if the
-   * correct position is at the end of the vector, and there is capacity, push to back 2.b - otherwise, the insertion
+   * correct position is at the end of the vector, and there is capacity, push to back 2.c - otherwise, the insertion
    * requires a data move, record insertion locations and handle in a second pass 3 - at the end, if some entries failed
    * to be updated in-place, then we alloc a new buffer, copy each chunk at the right position, and insert the new
    * elements.
@@ -1006,7 +1007,7 @@
 
     Index n = diagXpr.size();
 
-    const bool overwrite = internal::is_same<Func, internal::assign_op<Scalar, Scalar>>::value;
+    const bool overwrite = std::is_same<Func, internal::assign_op<Scalar, Scalar>>::value;
     if (overwrite) {
       if ((m_outerSize != n) || (m_innerSize != n) || (n == 0)) resize(n, n);
     }
@@ -1062,7 +1063,7 @@
           bool doInsertion = insertionLocations(j) >= 0;
           bool breakUpCopy = doInsertion && (capacity > 0);
           // break up copy for sorted insertion into inactive nonzeros
-          // optionally, add another criterium, i.e. 'breakUpCopy || (capacity > threhsold)'
+          // optionally, add another criterion, i.e. 'breakUpCopy || (capacity > threshold)'
           // where `threshold >= 0` to skip inactive nonzeros in each vector
           // this reduces the total number of copied elements, but requires more moveChunk calls
           if (breakUpCopy) {
@@ -1147,7 +1148,9 @@
   for (InputIterator it(begin); it != end; ++it) {
     eigen_assert(it->row() >= 0 && it->row() < mat.rows() && it->col() >= 0 && it->col() < mat.cols());
     StorageIndex j = convert_index<StorageIndex>(IsRowMajor ? it->col() : it->row());
-    if (nonZeros == NumTraits<StorageIndex>::highest()) internal::throw_std_bad_alloc();
+    eigen_assert(nonZeros < NumTraits<StorageIndex>::highest() &&
+                 "non-zero count exceeds StorageIndex range, use a wider StorageIndex (e.g. int64_t)");
+    if (nonZeros >= NumTraits<StorageIndex>::highest()) internal::throw_std_bad_alloc();
     trmat.outerIndexPtr()[j + 1]++;
     nonZeros++;
   }
@@ -1201,7 +1204,9 @@
     // identify duplicates by examining previous location
     bool duplicate = (previous_j == j) && (previous_i == i);
     if (!duplicate) {
-      if (nonZeros == NumTraits<StorageIndex>::highest()) internal::throw_std_bad_alloc();
+      eigen_assert(nonZeros < NumTraits<StorageIndex>::highest() &&
+                   "non-zero count exceeds StorageIndex range, use a wider StorageIndex (e.g. int64_t)");
+      if (nonZeros >= NumTraits<StorageIndex>::highest()) internal::throw_std_bad_alloc();
       nonZeros++;
       mat.outerIndexPtr()[j + 1]++;
       previous_j = j;
@@ -1277,7 +1282,8 @@
   using SrcXprType =
       CwiseBinaryOp<scalar_disjunction_op<DupFunctor, Scalar>, const SparseMatrixType, const SparseMatrixType>;
 
-  // TODO: process triplets without making a copy
+  // Saving the trips temporary would need a direct mat+triplets merge with
+  // on-the-fly duplicate collapsing (non-trivial).
   SparseMatrixType trips(mat.rows(), mat.cols());
   set_from_triplets_sorted(begin, end, trips, dup_func);
 
@@ -1337,7 +1343,7 @@
  * \code
  * value = dup_func(OldValue, NewValue)
  * \endcode
- * Here is a C++11 example keeping the latest entry only:
+ * Here is an example keeping the latest entry only:
  * \code
  * mat.setFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
  * \endcode
@@ -1353,6 +1359,7 @@
 /** The same as setFromTriplets but triplets are assumed to be pre-sorted. This is faster and requires less temporary
  * storage. Two triplets `a` and `b` are appropriately ordered if: \code ColMajor: ((a.col() != b.col()) ? (a.col() <
  * b.col()) : (a.row() < b.row()) RowMajor: ((a.row() != b.row()) ? (a.row() < b.row()) : (a.col() < b.col()) \endcode
+ * If the range is empty, the initial contents of \c *this are left untouched instead of being destroyed.
  */
 template <typename Scalar, int Options_, typename StorageIndex_>
 template <typename InputIterators>
@@ -1366,7 +1373,7 @@
  * \code
  * value = dup_func(OldValue, NewValue)
  * \endcode
- * Here is a C++11 example keeping the latest entry only:
+ * Here is an example keeping the latest entry only:
  * \code
  * mat.setFromSortedTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
  * \endcode
@@ -1430,7 +1437,7 @@
  * \code
  * value = dup_func(OldValue, NewValue)
  * \endcode
- * Here is a C++11 example keeping the latest entry only:
+ * Here is an example keeping the latest entry only:
  * \code
  * mat.insertFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
  * \endcode
@@ -1459,7 +1466,7 @@
  * \code
  * value = dup_func(OldValue, NewValue)
  * \endcode
- * Here is a C++11 example keeping the latest entry only:
+ * Here is an example keeping the latest entry only:
  * \code
  * mat.insertFromSortedTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });
  * \endcode
@@ -1520,7 +1527,7 @@
 EIGEN_DONT_INLINE SparseMatrix<Scalar, Options_, StorageIndex_>&
 SparseMatrix<Scalar, Options_, StorageIndex_>::operator=(const SparseMatrixBase<OtherDerived>& other) {
   EIGEN_STATIC_ASSERT(
-      (internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
+      (std::is_same<Scalar, typename OtherDerived::Scalar>::value),
       YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
 #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
@@ -1567,7 +1574,8 @@
     // pass 2
     for (StorageIndex j = 0; j < otherCopy.outerSize(); ++j) {
       for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it) {
-        Index pos = positions[it.index()]++;
+        Index pos = internal::convert_index<Index>(positions.coeff(it.index()));
+        positions.coeffRef(it.index()) = internal::convert_index<StorageIndex>(pos + 1);
         dest.m_data.index(pos) = j;
         dest.m_data.value(pos) = it.value();
       }
@@ -1707,7 +1715,7 @@
 
   // no room for interior insertion
   // nonZeros() == m_data.size()
-  // record offset as outerIndxPtr will change
+  // record offset as outerIndexPtr will change
   Index dst_offset = dst - m_outerIndex[outer];
   // allocate space for random insertion
   if (m_data.allocatedSize() == 0) {
@@ -1747,9 +1755,9 @@
 template <typename Scalar_, int Options_, typename StorageIndex_>
 struct evaluator<SparseMatrix<Scalar_, Options_, StorageIndex_>>
     : evaluator<SparseCompressedBase<SparseMatrix<Scalar_, Options_, StorageIndex_>>> {
-  typedef evaluator<SparseCompressedBase<SparseMatrix<Scalar_, Options_, StorageIndex_>>> Base;
-  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> SparseMatrixType;
-  evaluator() : Base() {}
+  using Base = evaluator<SparseCompressedBase<SparseMatrix<Scalar_, Options_, StorageIndex_>>>;
+  using SparseMatrixType = SparseMatrix<Scalar_, Options_, StorageIndex_>;
+  evaluator() = default;
   explicit evaluator(const SparseMatrixType& mat) : Base(mat) {}
 };
 
@@ -1761,7 +1769,7 @@
 template <typename Scalar, int Options, typename StorageIndex>
 class Serializer<SparseMatrix<Scalar, Options, StorageIndex>, void> {
  public:
-  typedef SparseMatrix<Scalar, Options, StorageIndex> SparseMat;
+  using SparseMat = SparseMatrix<Scalar, Options, StorageIndex>;
 
   struct Header {
     typename SparseMat::Index rows;
@@ -1846,26 +1854,34 @@
       // Inner non-zero counts.
       std::size_t data_bytes = sizeof(StorageIndex) * header.outer_size;
       if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
-      memcpy(value.innerNonZeroPtr(), src, data_bytes);
+      if (data_bytes != 0) {
+        memcpy(value.innerNonZeroPtr(), src, data_bytes);
+      }
       src += data_bytes;
     }
 
     // Outer indices.
     std::size_t data_bytes = sizeof(StorageIndex) * (header.outer_size + 1);
     if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
-    memcpy(value.outerIndexPtr(), src, data_bytes);
+    if (data_bytes != 0) {
+      memcpy(value.outerIndexPtr(), src, data_bytes);
+    }
     src += data_bytes;
 
     // Inner indices.
     data_bytes = sizeof(StorageIndex) * header.inner_buffer_size;
     if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
-    memcpy(value.innerIndexPtr(), src, data_bytes);
+    if (data_bytes != 0) {
+      memcpy(value.innerIndexPtr(), src, data_bytes);
+    }
     src += data_bytes;
 
     // Values.
     data_bytes = sizeof(Scalar) * header.inner_buffer_size;
     if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
-    memcpy(value.valuePtr(), src, data_bytes);
+    if (data_bytes != 0) {
+      memcpy(value.valuePtr(), src, data_bytes);
+    }
     src += data_bytes;
     return src;
   }
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index acdaf93..6506967 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEMATRIXBASE_H
 #define EIGEN_SPARSEMATRIXBASE_H
@@ -29,27 +30,27 @@
 template <typename Derived>
 class SparseMatrixBase : public EigenBase<Derived> {
  public:
-  typedef typename internal::traits<Derived>::Scalar Scalar;
+  using Scalar = typename internal::traits<Derived>::Scalar;
 
-  /** The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.
+  /** The numeric type of the expression's coefficients, e.g. float, double, int or std::complex<float>, etc.
    *
    * It is an alias for the Scalar type */
-  typedef Scalar value_type;
+  using value_type = Scalar;
 
-  typedef typename internal::packet_traits<Scalar>::type PacketScalar;
-  typedef typename internal::traits<Derived>::StorageKind StorageKind;
+  using PacketScalar = typename internal::packet_traits<Scalar>::type;
+  using StorageKind = typename internal::traits<Derived>::StorageKind;
 
   /** The integer type used to \b store indices within a SparseMatrix.
-   * For a \c SparseMatrix<Scalar,Options,IndexType> it an alias of the third template parameter \c IndexType. */
-  typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
+   * For a \c SparseMatrix<Scalar,Options,IndexType> it is an alias of the third template parameter \c IndexType. */
+  using StorageIndex = typename internal::traits<Derived>::StorageIndex;
 
-  typedef typename internal::add_const_on_value_type_if_arithmetic<typename internal::packet_traits<Scalar>::type>::type
-      PacketReturnType;
+  using PacketReturnType = std::conditional_t<internal::is_arithmetic<PacketScalar>::value, PacketScalar,
+                                              internal::add_const_on_value_type_t<PacketScalar>>;
 
-  typedef SparseMatrixBase StorageBaseType;
+  using StorageBaseType = SparseMatrixBase;
 
-  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
-  typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
+  using IndexVector = Matrix<StorageIndex, Dynamic, 1>;
+  using ScalarVector = Matrix<Scalar, Dynamic, 1>;
 
   template <typename OtherDerived>
   Derived& operator=(const EigenBase<OtherDerived>& other);
@@ -68,7 +69,7 @@
      * it is set to the \a Dynamic constant.
      * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
 
-    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::ret),
+    SizeAtCompileTime = (internal::size_of_xpr_at_compile_time<Derived>::value),
     /**< This is equal to the number of coefficients, i.e. the number of
      * rows times the number of columns, or to \a Dynamic if this is not
      * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
@@ -108,15 +109,15 @@
   };
 
   /** \internal the return type of MatrixBase::adjoint() */
-  typedef std::conditional_t<NumTraits<Scalar>::IsComplex,
-                             CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived> >,
-                             Transpose<const Derived> >
-      AdjointReturnType;
-  typedef Transpose<Derived> TransposeReturnType;
-  typedef Transpose<const Derived> ConstTransposeReturnType;
+  using AdjointReturnType =
+      std::conditional_t<NumTraits<Scalar>::IsComplex,
+                         CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived>>,
+                         Transpose<const Derived>>;
+  using TransposeReturnType = Transpose<Derived>;
+  using ConstTransposeReturnType = Transpose<const Derived>;
 
   // FIXME: storage order may not match evaluator storage order.
-  typedef SparseMatrix<Scalar, Flags & RowMajorBit ? RowMajor : ColMajor, StorageIndex> PlainObject;
+  using PlainObject = SparseMatrix<Scalar, Flags & RowMajorBit ? RowMajor : ColMajor, StorageIndex>;
 
   /** This is the "real scalar" type; if the \a Scalar type is already real numbers
    * (e.g. int, float or double) then \a RealScalar is just the same as \a Scalar. If
@@ -124,28 +125,27 @@
    *
    * \sa class NumTraits
    */
-  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
   /** \internal the return type of coeff()
    */
-  typedef std::conditional_t<HasDirectAccess_, const Scalar&, Scalar> CoeffReturnType;
+  using CoeffReturnType = std::conditional_t<HasDirectAccess_, const Scalar&, Scalar>;
 
   /** \internal Represents a matrix with all coefficients equal to one another*/
-  typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>, Matrix<Scalar, Dynamic, Dynamic> > ConstantReturnType;
+  using ConstantReturnType = CwiseNullaryOp<internal::scalar_constant_op<Scalar>, Matrix<Scalar, Dynamic, Dynamic>>;
 
   /** type of the equivalent dense matrix */
-  typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> DenseMatrixType;
+  using DenseMatrixType = Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime>;
   /** type of the equivalent square matrix */
-  typedef Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime),
-                 internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)>
-      SquareMatrixType;
+  using SquareMatrixType = Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime),
+                                  internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)>;
 
   inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
   inline Derived& derived() { return *static_cast<Derived*>(this); }
   inline Derived& const_cast_derived() const { return *static_cast<Derived*>(const_cast<SparseMatrixBase*>(this)); }
 
-  typedef EigenBase<Derived> Base;
+  using Base = EigenBase<Derived>;
 
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
@@ -191,10 +191,10 @@
    * \sa rows(), cols(), IsVectorAtCompileTime. */
   inline bool isVector() const { return rows() == 1 || cols() == 1; }
   /** \returns the size of the storage major dimension,
-   * i.e., the number of columns for a columns major matrix, and the number of rows otherwise */
+   * i.e., the number of columns for a column major matrix, and the number of rows otherwise */
   Index outerSize() const { return (int(Flags) & RowMajorBit) ? this->rows() : this->cols(); }
   /** \returns the size of the inner dimension according to the storage order,
-   * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */
+   * i.e., the number of rows for a column major matrix, and the number of cols otherwise */
   Index innerSize() const { return (int(Flags) & RowMajorBit) ? this->cols() : this->rows(); }
 
   bool isRValue() const { return m_isRValue; }
@@ -225,9 +225,9 @@
 #ifndef EIGEN_NO_IO
   friend std::ostream& operator<<(std::ostream& s, const SparseMatrixBase& m) {
     using Nested = typename Derived::Nested;
-    using NestedCleaned = typename internal::remove_all<Nested>::type;
+    using NestedCleaned = internal::remove_all_t<Nested>;
 
-    if (Flags & RowMajorBit) {
+    EIGEN_IF_CONSTEXPR (Flags & RowMajorBit) {
       Nested nm(m.derived());
       internal::evaluator<NestedCleaned> thisEval(nm);
 
@@ -304,7 +304,7 @@
         }
       } else {
         SparseMatrix<Scalar, RowMajorBit, StorageIndex> trans = m;
-        s << static_cast<const SparseMatrixBase<SparseMatrix<Scalar, RowMajorBit, StorageIndex> >&>(trans);
+        s << static_cast<const SparseMatrixBase<SparseMatrix<Scalar, RowMajorBit, StorageIndex>>&>(trans);
       }
     }
     return s;
@@ -331,11 +331,10 @@
 
   template <typename OtherDerived>
   struct CwiseProductDenseReturnType {
-    typedef CwiseBinaryOp<
+    using Type = CwiseBinaryOp<
         internal::scalar_product_op<typename ScalarBinaryOpTraits<
             typename internal::traits<Derived>::Scalar, typename internal::traits<OtherDerived>::Scalar>::ReturnType>,
-        const Derived, const OtherDerived>
-        Type;
+        const Derived, const OtherDerived>;
   };
 
   template <typename OtherDerived>
@@ -386,11 +385,11 @@
 
   template <unsigned int UpLo>
   struct SelfAdjointViewReturnType {
-    typedef SparseSelfAdjointView<Derived, UpLo> Type;
+    using Type = SparseSelfAdjointView<Derived, UpLo>;
   };
   template <unsigned int UpLo>
   struct ConstSelfAdjointViewReturnType {
-    typedef const SparseSelfAdjointView<const Derived, UpLo> Type;
+    using Type = const SparseSelfAdjointView<const Derived, UpLo>;
   };
 
   template <unsigned int UpLo>
diff --git a/Eigen/src/SparseCore/SparsePermutation.h b/Eigen/src/SparseCore/SparsePermutation.h
index 56f572d..222ccfb 100644
--- a/Eigen/src/SparseCore/SparsePermutation.h
+++ b/Eigen/src/SparseCore/SparsePermutation.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_PERMUTATION_H
 #define EIGEN_SPARSE_PERMUTATION_H
@@ -20,7 +21,7 @@
 namespace internal {
 
 template <typename ExpressionType, typename PlainObjectType,
-          bool NeedEval = !is_same<ExpressionType, PlainObjectType>::value>
+          bool NeedEval = !std::is_same<ExpressionType, PlainObjectType>::value>
 struct XprHelper {
   XprHelper(const ExpressionType& xpr) : m_xpr(xpr) {}
   inline const PlainObjectType& xpr() const { return m_xpr; }
@@ -163,23 +164,23 @@
 
 template <int ProductTag>
 struct product_promote_storage_type<Sparse, PermutationStorage, ProductTag> {
-  typedef Sparse ret;
+  using ret = Sparse;
 };
 template <int ProductTag>
 struct product_promote_storage_type<PermutationStorage, Sparse, ProductTag> {
-  typedef Sparse ret;
+  using ret = Sparse;
 };
 
 // TODO, the following two overloads are only needed to define the right temporary type through
-// typename traits<permutation_sparse_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
+// typename traits<permutation_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
 // whereas it should be correctly handled by traits<Product<> >::PlainObject
 
 template <typename Lhs, typename Rhs, int ProductTag>
 struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, PermutationShape, SparseShape>
     : public evaluator<typename permutation_matrix_product<Rhs, OnTheLeft, false, SparseShape>::ReturnType> {
-  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
-  typedef typename permutation_matrix_product<Rhs, OnTheLeft, false, SparseShape>::ReturnType PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = Product<Lhs, Rhs, AliasFreeProduct>;
+  using PlainObject = typename permutation_matrix_product<Rhs, OnTheLeft, false, SparseShape>::ReturnType;
+  using Base = evaluator<PlainObject>;
 
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
 
@@ -195,9 +196,9 @@
 template <typename Lhs, typename Rhs, int ProductTag>
 struct product_evaluator<Product<Lhs, Rhs, AliasFreeProduct>, ProductTag, SparseShape, PermutationShape>
     : public evaluator<typename permutation_matrix_product<Lhs, OnTheRight, false, SparseShape>::ReturnType> {
-  typedef Product<Lhs, Rhs, AliasFreeProduct> XprType;
-  typedef typename permutation_matrix_product<Lhs, OnTheRight, false, SparseShape>::ReturnType PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = Product<Lhs, Rhs, AliasFreeProduct>;
+  using PlainObject = typename permutation_matrix_product<Lhs, OnTheRight, false, SparseShape>::ReturnType;
+  using Base = evaluator<PlainObject>;
 
   enum { Flags = Base::Flags | EvalBeforeNestingBit };
 
@@ -246,4 +247,4 @@
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_SPARSE_SELFADJOINTVIEW_H
+#endif  // EIGEN_SPARSE_PERMUTATION_H
diff --git a/Eigen/src/SparseCore/SparseProduct.h b/Eigen/src/SparseCore/SparseProduct.h
index 249dabc..3950142 100644
--- a/Eigen/src/SparseCore/SparseProduct.h
+++ b/Eigen/src/SparseCore/SparseProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEPRODUCT_H
 #define EIGEN_SPARSEPRODUCT_H
@@ -44,11 +45,11 @@
   }
 
   // dense += sparse * sparse
-  template <typename Dest, typename ActualLhs>
-  static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs,
-                    std::enable_if_t<is_same<typename evaluator_traits<Dest>::Shape, DenseShape>::value, int*>* = 0) {
-    typedef typename nested_eval<ActualLhs, Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
+  template <typename Dest, typename ActualLhs,
+            std::enable_if_t<std::is_same<typename evaluator_traits<Dest>::Shape, DenseShape>::value, int> = 0>
+  static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs) {
+    using LhsNested = typename nested_eval<ActualLhs, Dynamic>::type;
+    using RhsNested = typename nested_eval<Rhs, Dynamic>::type;
     LhsNested lhsNested(lhs);
     RhsNested rhsNested(rhs);
     internal::sparse_sparse_to_dense_product_selector<remove_all_t<LhsNested>, remove_all_t<RhsNested>, Dest>::run(
@@ -56,9 +57,9 @@
   }
 
   // dense -= sparse * sparse
-  template <typename Dest>
-  static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs,
-                    std::enable_if_t<is_same<typename evaluator_traits<Dest>::Shape, DenseShape>::value, int*>* = 0) {
+  template <typename Dest,
+            std::enable_if_t<std::is_same<typename evaluator_traits<Dest>::Shape, DenseShape>::value, int> = 0>
+  static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs) {
     addTo(dst, -lhs, rhs);
   }
 
@@ -66,8 +67,8 @@
   // sparse = sparse * sparse
   template <typename Dest>
   static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, SparseShape) {
-    typedef typename nested_eval<Lhs, Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
+    using LhsNested = typename nested_eval<Lhs, Dynamic>::type;
+    using RhsNested = typename nested_eval<Rhs, Dynamic>::type;
     LhsNested lhsNested(lhs);
     RhsNested rhsNested(rhs);
     internal::conservative_sparse_sparse_product_selector<remove_all_t<LhsNested>, remove_all_t<RhsNested>, Dest>::run(
@@ -98,7 +99,7 @@
     DstXprType, Product<Lhs, Rhs, AliasFreeProduct>,
     internal::assign_op<typename DstXprType::Scalar, typename Product<Lhs, Rhs, AliasFreeProduct>::Scalar>,
     Sparse2Dense> {
-  typedef Product<Lhs, Rhs, AliasFreeProduct> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, AliasFreeProduct>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>&) {
     Index dstRows = src.rows();
@@ -115,7 +116,7 @@
     DstXprType, Product<Lhs, Rhs, AliasFreeProduct>,
     internal::add_assign_op<typename DstXprType::Scalar, typename Product<Lhs, Rhs, AliasFreeProduct>::Scalar>,
     Sparse2Dense> {
-  typedef Product<Lhs, Rhs, AliasFreeProduct> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, AliasFreeProduct>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::add_assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>&) {
     generic_product_impl<Lhs, Rhs>::addTo(dst, src.lhs(), src.rhs());
@@ -128,7 +129,7 @@
     DstXprType, Product<Lhs, Rhs, AliasFreeProduct>,
     internal::sub_assign_op<typename DstXprType::Scalar, typename Product<Lhs, Rhs, AliasFreeProduct>::Scalar>,
     Sparse2Dense> {
-  typedef Product<Lhs, Rhs, AliasFreeProduct> SrcXprType;
+  using SrcXprType = Product<Lhs, Rhs, AliasFreeProduct>;
   static void run(DstXprType& dst, const SrcXprType& src,
                   const internal::sub_assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>&) {
     generic_product_impl<Lhs, Rhs>::subTo(dst, src.lhs(), src.rhs());
@@ -138,15 +139,15 @@
 template <typename Lhs, typename Rhs, int Options>
 struct unary_evaluator<SparseView<Product<Lhs, Rhs, Options> >, IteratorBased>
     : public evaluator<typename Product<Lhs, Rhs, DefaultProduct>::PlainObject> {
-  typedef SparseView<Product<Lhs, Rhs, Options> > XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = SparseView<Product<Lhs, Rhs, Options>>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   explicit unary_evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) {
     using std::abs;
     internal::construct_at<Base>(this, m_result);
-    typedef typename nested_eval<Lhs, Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
+    using LhsNested = typename nested_eval<Lhs, Dynamic>::type;
+    using RhsNested = typename nested_eval<Rhs, Dynamic>::type;
     LhsNested lhsNested(xpr.nestedExpression().lhs());
     RhsNested rhsNested(xpr.nestedExpression().rhs());
 
@@ -166,7 +167,6 @@
 template <typename Lhs, typename Rhs>
 SparseMatrix<Scalar, Options_, StorageIndex_>& SparseMatrix<Scalar, Options_, StorageIndex_>::operator=(
     const Product<Lhs, Rhs, AliasFreeProduct>& src) {
-  // std::cout << "in Assignment : " << DstOptions << "\n";
   SparseMatrix dst(src.rows(), src.cols());
   internal::generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
   this->swap(dst);
diff --git a/Eigen/src/SparseCore/SparseRedux.h b/Eigen/src/SparseCore/SparseRedux.h
index 732e4f7..c9fcaeb 100644
--- a/Eigen/src/SparseCore/SparseRedux.h
+++ b/Eigen/src/SparseCore/SparseRedux.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEREDUX_H
 #define EIGEN_SPARSEREDUX_H
diff --git a/Eigen/src/SparseCore/SparseRef.h b/Eigen/src/SparseCore/SparseRef.h
index aa8ae34..e942e6a 100644
--- a/Eigen/src/SparseCore/SparseRef.h
+++ b/Eigen/src/SparseCore/SparseRef.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_REF_H
 #define EIGEN_SPARSE_REF_H
@@ -28,7 +29,7 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options_, typename StrideType_>
 struct traits<Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options_, StrideType_>>
     : public traits<SparseMatrix<MatScalar, MatOptions, MatIndex>> {
-  typedef SparseMatrix<MatScalar, MatOptions, MatIndex> PlainObjectType;
+  using PlainObjectType = SparseMatrix<MatScalar, MatOptions, MatIndex>;
   enum { Options = Options_, Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit };
 
   template <typename Derived>
@@ -38,7 +39,7 @@
                           ((PlainObjectType::Flags & RowMajorBit) == (Derived::Flags & RowMajorBit)),
       MatchAtCompileTime = (Derived::Flags & CompressedAccessBit) && StorageOrderMatch
     };
-    typedef std::conditional_t<MatchAtCompileTime, internal::true_type, internal::false_type> type;
+    using type = bool_constant<MatchAtCompileTime>;
   };
 };
 
@@ -54,13 +55,13 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options_, typename StrideType_>
 struct traits<Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options_, StrideType_>>
     : public traits<SparseVector<MatScalar, MatOptions, MatIndex>> {
-  typedef SparseVector<MatScalar, MatOptions, MatIndex> PlainObjectType;
+  using PlainObjectType = SparseVector<MatScalar, MatOptions, MatIndex>;
   enum { Options = Options_, Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit };
 
   template <typename Derived>
   struct match {
     enum { MatchAtCompileTime = (Derived::Flags & CompressedAccessBit) && Derived::IsVectorAtCompileTime };
-    typedef std::conditional_t<MatchAtCompileTime, internal::true_type, internal::false_type> type;
+    using type = bool_constant<MatchAtCompileTime>;
   };
 };
 
@@ -79,7 +80,7 @@
 template <typename Derived>
 class SparseRefBase : public SparseMapBase<Derived> {
  public:
-  typedef SparseMapBase<Derived> Base;
+  using Base = SparseMapBase<Derived>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(SparseRefBase)
 
   SparseRefBase()
@@ -89,11 +90,19 @@
  protected:
   template <typename Expression>
   void construct(Expression& expr) {
-    if (expr.outerIndexPtr() == 0)
+    EIGEN_IF_CONSTEXPR (Expression::IsVectorAtCompileTime) {
+      const Index offset = expr.outerIndexPtr() ? expr.outerIndexPtr()[0] : 0;
+      auto inner_index_ptr = expr.innerIndexPtr();
+      auto value_ptr = expr.valuePtr();
+      if (inner_index_ptr) inner_index_ptr += offset;
+      if (value_ptr) value_ptr += offset;
+      internal::construct_at<Base>(this, expr.size(), expr.nonZeros(), inner_index_ptr, value_ptr);
+    } else if (expr.outerIndexPtr() == 0) {
       internal::construct_at<Base>(this, expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr());
-    else
+    } else {
       internal::construct_at<Base>(this, expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(),
                                    expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr());
+    }
   }
 };
 
@@ -105,7 +114,7 @@
  * \brief A sparse matrix expression referencing an existing sparse expression
  *
  * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of
- * class SparseMatrix. \tparam Options specifies whether the a standard compressed format is required \c Options is  \c
+ * class SparseMatrix. \tparam Options specifies whether a standard compressed format is required \c Options is  \c
  * #StandardCompressedFormat, or \c 0. The default is \c 0.
  *
  * \sa class Ref
@@ -121,15 +130,14 @@
                                                      // correctly via CRTP.
 #endif
 {
-  typedef SparseMatrix<MatScalar, MatOptions, MatIndex> PlainObjectType;
-  typedef internal::traits<Ref> Traits;
+  using Traits = internal::traits<Ref>;
   template <int OtherOptions>
   inline Ref(const SparseMatrix<MatScalar, OtherOptions, MatIndex>& expr);
   template <int OtherOptions>
   inline Ref(const Map<SparseMatrix<MatScalar, OtherOptions, MatIndex>>& expr);
 
  public:
-  typedef internal::SparseRefBase<Ref> Base;
+  using Base = internal::SparseRefBase<Ref>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
@@ -170,11 +178,11 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 class Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>
     : public internal::SparseRefBase<Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>> {
-  typedef SparseMatrix<MatScalar, MatOptions, MatIndex> TPlainObjectType;
-  typedef internal::traits<Ref> Traits;
+  using TPlainObjectType = SparseMatrix<MatScalar, MatOptions, MatIndex>;
+  using Traits = internal::traits<Ref>;
 
  public:
-  typedef internal::SparseRefBase<Ref> Base;
+  using Base = internal::SparseRefBase<Ref>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
 
   template <typename Derived>
@@ -199,24 +207,25 @@
 
  protected:
   template <typename Expression>
-  void construct(const Expression& expr, internal::true_type) {
-    if ((Options & int(StandardCompressedFormat)) && (!expr.isCompressed())) {
-      TPlainObjectType* obj = internal::construct_at(reinterpret_cast<TPlainObjectType*>(&m_storage), expr);
-      m_hasCopy = true;
-      Base::construct(*obj);
-    } else {
-      Base::construct(expr);
+  void construct(const Expression& expr, std::true_type) {
+    EIGEN_IF_CONSTEXPR (Options & int(StandardCompressedFormat)) {
+      if (!expr.isCompressed()) {
+        TPlainObjectType* obj = internal::construct_at(reinterpret_cast<TPlainObjectType*>(&m_storage), expr);
+        m_hasCopy = true;
+        Base::construct(*obj);
+        return;
+      }
     }
+    Base::construct(expr);
   }
 
   template <typename Expression>
-  void construct(const Expression& expr, internal::false_type) {
+  void construct(const Expression& expr, std::false_type) {
     TPlainObjectType* obj = internal::construct_at(reinterpret_cast<TPlainObjectType*>(&m_storage), expr);
     m_hasCopy = true;
     Base::construct(*obj);
   }
 
- protected:
   typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
   bool m_hasCopy;
 };
@@ -240,13 +249,13 @@
 class Ref<SparseVectorType> : public SparseMapBase<Derived, WriteAccessors>
 #endif
 {
-  typedef SparseVector<MatScalar, MatOptions, MatIndex> PlainObjectType;
-  typedef internal::traits<Ref> Traits;
+  using PlainObjectType = SparseVector<MatScalar, MatOptions, MatIndex>;
+  using Traits = internal::traits<Ref>;
   template <int OtherOptions>
   inline Ref(const SparseVector<MatScalar, OtherOptions, MatIndex>& expr);
 
  public:
-  typedef internal::SparseRefBase<Ref> Base;
+  using Base = internal::SparseRefBase<Ref>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
@@ -268,6 +277,8 @@
   {
     EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
     EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH);
+    EIGEN_STATIC_ASSERT((!std::is_same<Derived, PlainObjectType>::value),
+                        THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY);
     Base::construct(expr.const_cast_derived());
   }
 };
@@ -276,11 +287,11 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 class Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>
     : public internal::SparseRefBase<Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>> {
-  typedef SparseVector<MatScalar, MatOptions, MatIndex> TPlainObjectType;
-  typedef internal::traits<Ref> Traits;
+  using TPlainObjectType = SparseVector<MatScalar, MatOptions, MatIndex>;
+  using Traits = internal::traits<Ref>;
 
  public:
-  typedef internal::SparseRefBase<Ref> Base;
+  using Base = internal::SparseRefBase<Ref>;
   EIGEN_SPARSE_PUBLIC_INTERFACE(Ref)
 
   template <typename Derived>
@@ -305,18 +316,17 @@
 
  protected:
   template <typename Expression>
-  void construct(const Expression& expr, internal::true_type) {
+  void construct(const Expression& expr, std::true_type) {
     Base::construct(expr);
   }
 
   template <typename Expression>
-  void construct(const Expression& expr, internal::false_type) {
+  void construct(const Expression& expr, std::false_type) {
     TPlainObjectType* obj = internal::construct_at(reinterpret_cast<TPlainObjectType*>(&m_storage), expr);
     m_hasCopy = true;
     Base::construct(*obj);
   }
 
- protected:
   typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage;
   bool m_hasCopy;
 };
@@ -329,38 +339,38 @@
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct evaluator<Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>
     : evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>> {
-  typedef evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>> Base;
-  typedef Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
+  using Base = evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>;
+  using XprType = Ref<SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>;
+  evaluator() = default;
   explicit evaluator(const XprType& mat) : Base(mat) {}
 };
 
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct evaluator<Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>
     : evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>> {
-  typedef evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>
-      Base;
-  typedef Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
+  using Base =
+      evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>;
+  using XprType = Ref<const SparseMatrix<MatScalar, MatOptions, MatIndex>, Options, StrideType>;
+  evaluator() = default;
   explicit evaluator(const XprType& mat) : Base(mat) {}
 };
 
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct evaluator<Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>
     : evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>> {
-  typedef evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>> Base;
-  typedef Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
+  using Base = evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>;
+  using XprType = Ref<SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>;
+  evaluator() = default;
   explicit evaluator(const XprType& mat) : Base(mat) {}
 };
 
 template <typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
 struct evaluator<Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>
     : evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>> {
-  typedef evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>
-      Base;
-  typedef Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType> XprType;
-  evaluator() : Base() {}
+  using Base =
+      evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>>>;
+  using XprType = Ref<const SparseVector<MatScalar, MatOptions, MatIndex>, Options, StrideType>;
+  evaluator() = default;
   explicit evaluator(const XprType& mat) : Base(mat) {}
 };
 
diff --git a/Eigen/src/SparseCore/SparseScatter.h b/Eigen/src/SparseCore/SparseScatter.h
new file mode 100644
index 0000000..0a7c78d
--- /dev/null
+++ b/Eigen/src/SparseCore/SparseScatter.h
@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPARSE_SCATTER_H
+#define EIGEN_SPARSE_SCATTER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+constexpr Index kSparseScatterPacketMinSize = 32;
+
+template <typename Scalar, bool Vectorize>
+struct sparse_scatter_sub_impl {
+  template <typename StorageIndex, typename ValuesEvaluator>
+  static EIGEN_STRONG_INLINE Index run(Scalar*, const StorageIndex*, const ValuesEvaluator&, Index) {
+    return 0;
+  }
+};
+
+template <typename Scalar>
+struct sparse_scatter_sub_impl<Scalar, true> {
+  // Keep the packet loop out of the common path for short updates.
+  template <typename StorageIndex, typename ValuesEvaluator>
+  static EIGEN_DONT_INLINE Index run(Scalar* EIGEN_RESTRICT dense, const StorageIndex* indices,
+                                     const ValuesEvaluator& values, Index size) {
+    // Limit register pressure from the indirect addresses.
+    using Packet = typename find_best_packet<Scalar, 4>::type;
+    constexpr Index PacketSize = unpacket_traits<Packet>::size;
+    const Index end = size - size % PacketSize;
+    for (Index i = 0; i < end; i += PacketSize) {
+      EIGEN_ALIGN_MAX Scalar gathered[PacketSize];
+      for (Index lane = 0; lane < PacketSize; ++lane) gathered[lane] = dense[indices[i + lane]];
+      pstoreu(gathered, psub(ploadu<Packet>(gathered), values.template packet<Unaligned, Packet>(i)));
+      for (Index lane = 0; lane < PacketSize; ++lane) dense[indices[i + lane]] = gathered[lane];
+    }
+    return end;
+  }
+};
+
+// Subtract a packet-sized prefix of values from dense at distinct indices, returning its length.
+// Neither input may alias dense. Callers retain their scalar loop for short updates and the tail.
+// Packing complex destinations costs more than the packet arithmetic saves.
+template <typename Scalar, typename StorageIndex, typename Values>
+EIGEN_STRONG_INLINE Index sparse_scatter_sub_packets(Scalar* EIGEN_RESTRICT dense, const StorageIndex* indices,
+                                                     const MatrixBase<Values>& values) {
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Values)
+  EIGEN_STATIC_ASSERT((std::is_same<Scalar, typename Values::Scalar>::value), YOU_MIXED_DIFFERENT_NUMERIC_TYPES)
+  constexpr bool Vectorize = (evaluator<Values>::Flags & PacketAccessBit) &&
+                             (evaluator<Values>::Flags & LinearAccessBit) && packet_traits<Scalar>::HasSub &&
+                             !NumTraits<Scalar>::IsComplex;
+  if (!Vectorize || values.size() < kSparseScatterPacketMinSize) return 0;
+  evaluator<Values> valuesEval(values.derived());
+  return sparse_scatter_sub_impl<Scalar, Vectorize>::run(dense, indices, valuesEval, values.size());
+}
+
+template <bool Conjugate, typename Scalar, typename StorageIndex>
+EIGEN_STRONG_INLINE Index sparse_scatter_sub_packets(Scalar* dense, const StorageIndex* indices, const Scalar* values,
+                                                     Index size, const Scalar& scale) {
+  constexpr bool Vectorize = packet_traits<Scalar>::Vectorizable && packet_traits<Scalar>::HasMul &&
+                             packet_traits<Scalar>::HasSub && !NumTraits<Scalar>::IsComplex;
+  if (!Vectorize || size < kSparseScatterPacketMinSize) return 0;
+  const Map<const Matrix<Scalar, Dynamic, 1>> mappedValues(values, size);
+  return sparse_scatter_sub_packets(dense, indices, mappedValues.template conjugateIf<Conjugate>() * scale);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_SPARSE_SCATTER_H
diff --git a/Eigen/src/SparseCore/SparseSelfAdjointView.h b/Eigen/src/SparseCore/SparseSelfAdjointView.h
index 210462f..2c756e4 100644
--- a/Eigen/src/SparseCore/SparseSelfAdjointView.h
+++ b/Eigen/src/SparseCore/SparseSelfAdjointView.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_SELFADJOINTVIEW_H
 #define EIGEN_SPARSE_SELFADJOINTVIEW_H
@@ -23,7 +24,7 @@
  * \param MatrixType the type of the dense matrix storing the coefficients
  * \param Mode can be either \c #Lower or \c #Upper
  *
- * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
+ * This class is an expression of a selfadjoint matrix from a triangular part of a matrix
  * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
  * and most of the time this is the only way that it is used.
  *
@@ -58,12 +59,14 @@
     ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
   };
 
-  typedef EigenBase<SparseSelfAdjointView> Base;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
-  typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
-  typedef internal::remove_all_t<MatrixTypeNested> MatrixTypeNested_;
+  using Base = EigenBase<SparseSelfAdjointView>;
+  using Scalar = typename MatrixType::Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
+  using MatrixTypeNested = typename internal::ref_selector<MatrixType>::non_const_type;
+  using MatrixTypeNested_ = internal::remove_all_t<MatrixTypeNested>;
+  using PlainObject =
+      SparseMatrix<Scalar, (MatrixTypeNested_::Flags & RowMajorBit) ? RowMajor : ColMajor, StorageIndex>;
 
   explicit inline SparseSelfAdjointView(MatrixType& matrix) : m_matrix(matrix) {
     eigen_assert(rows() == cols() && "SelfAdjointView is only for squared matrices");
@@ -107,6 +110,11 @@
     return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
   }
 
+  template <typename OtherDerived>
+  Product<SparseSelfAdjointView, OtherDerived> operator*(const DiagonalBase<OtherDerived>& rhs) const {
+    return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
+  }
+
   /** Efficient dense vector/matrix times sparse self-adjoint matrix product */
   template <typename OtherDerived>
   friend Product<OtherDerived, SparseSelfAdjointView> operator*(const MatrixBase<OtherDerived>& lhs,
@@ -114,8 +122,26 @@
     return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
   }
 
+  template <typename OtherDerived>
+  friend Product<OtherDerived, SparseSelfAdjointView> operator*(const DiagonalBase<OtherDerived>& lhs,
+                                                                const SparseSelfAdjointView& rhs) {
+    return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
+  }
+
+  // Scalar multiplication intentionally materializes the full matrix, unlike dense SelfAdjointView's lazy wrapper,
+  // matching the existing SparseSelfAdjointView products.
+  PlainObject operator*(const Scalar& s) const { return s * *this; }
+
+  friend PlainObject operator*(const Scalar& s, const SparseSelfAdjointView& mat) {
+    PlainObject res(mat);
+    res *= s;
+    return res;
+  }
+
   /** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
    * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
+   * As a special case, if \a alpha is zero then the previous contents of \c *this are discarded and overwritten,
+   * yielding \f$ this = u u^* \f$ instead of leaving \c *this unchanged.
    *
    * \returns a reference to \c *this
    *
@@ -161,8 +187,7 @@
 
  protected:
   MatrixTypeNested m_matrix;
-  // mutable VectorI m_countPerRow;
-  // mutable VectorI m_countPerCol;
+
  private:
   template <typename Dest>
   void evalTo(Dest&) const;
@@ -211,25 +236,25 @@
 //      make it work)
 template <typename MatrixType, unsigned int Mode>
 struct evaluator_traits<SparseSelfAdjointView<MatrixType, Mode> > {
-  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
-  typedef SparseSelfAdjointShape Shape;
+  using Kind = typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind;
+  using Shape = SparseSelfAdjointShape;
 };
 
 struct SparseSelfAdjoint2Sparse {};
 
 template <>
 struct AssignmentKind<SparseShape, SparseSelfAdjointShape> {
-  typedef SparseSelfAdjoint2Sparse Kind;
+  using Kind = SparseSelfAdjoint2Sparse;
 };
 template <>
 struct AssignmentKind<SparseSelfAdjointShape, SparseShape> {
-  typedef Sparse2Sparse Kind;
+  using Kind = Sparse2Sparse;
 };
 
 template <typename DstXprType, typename SrcXprType, typename Functor>
 struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse> {
-  typedef typename DstXprType::StorageIndex StorageIndex;
-  typedef internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar> AssignOpType;
+  using StorageIndex = typename DstXprType::StorageIndex;
+  using AssignOpType = internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>;
 
   template <typename DestScalar, int StorageOrder>
   static void run(SparseMatrix<DestScalar, StorageOrder, StorageIndex>& dst, const SrcXprType& src,
@@ -267,7 +292,7 @@
 }  // end namespace internal
 
 /***************************************************************************
- * Implementation of sparse self-adjoint time dense matrix
+ * Implementation of sparse self-adjoint times dense matrix
  ***************************************************************************/
 
 namespace internal {
@@ -277,11 +302,11 @@
                                                   const AlphaType& alpha) {
   EIGEN_ONLY_USED_FOR_DEBUG(alpha);
 
-  typedef typename internal::nested_eval<SparseLhsType, DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
-  typedef internal::remove_all_t<SparseLhsTypeNested> SparseLhsTypeNestedCleaned;
-  typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
-  typedef typename LhsEval::InnerIterator LhsIterator;
-  typedef typename SparseLhsType::Scalar LhsScalar;
+  using SparseLhsTypeNested = typename internal::nested_eval<SparseLhsType, DenseRhsType::MaxColsAtCompileTime>::type;
+  using SparseLhsTypeNestedCleaned = internal::remove_all_t<SparseLhsTypeNested>;
+  using LhsEval = evaluator<SparseLhsTypeNestedCleaned>;
+  using LhsIterator = typename LhsEval::InnerIterator;
+  using LhsScalar = typename SparseLhsType::Scalar;
 
   enum {
     LhsIsRowMajor = (LhsEval::Flags & RowMajorBit) == RowMajorBit,
@@ -298,7 +323,7 @@
     for (Index j = 0; j < lhs.outerSize(); ++j) {
       LhsIterator i(lhsEval, j);
       // handle diagonal coeff
-      if (ProcessSecondHalf) {
+      EIGEN_IF_CONSTEXPR (ProcessSecondHalf) {
         while (i && i.index() < j) ++i;
         if (i && i.index() == j) {
           res.coeffRef(j, k) += alpha * i.value() * rhs.coeff(j, k);
@@ -312,7 +337,9 @@
       typename DenseResType::Scalar res_j(0);
       for (; (ProcessFirstHalf ? i && i.index() < j : i); ++i) {
         LhsScalar lhs_ij = i.value();
-        if (!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
+        EIGEN_IF_CONSTEXPR (!LhsIsRowMajor) {
+          lhs_ij = numext::conj(lhs_ij);
+        }
         res_j += lhs_ij * rhs.coeff(i.index(), k);
         res(i.index(), k) += numext::conj(lhs_ij) * rhs_j;
       }
@@ -330,9 +357,9 @@
                                 generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> > {
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha) {
-    typedef typename LhsView::MatrixTypeNested_ Lhs;
-    typedef typename nested_eval<Lhs, Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
+    using Lhs = typename LhsView::MatrixTypeNested_;
+    using LhsNested = typename nested_eval<Lhs, Dynamic>::type;
+    using RhsNested = typename nested_eval<Rhs, Dynamic>::type;
     LhsNested lhsNested(lhsView.matrix());
     RhsNested rhsNested(rhs);
 
@@ -346,9 +373,9 @@
                                 generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> > {
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha) {
-    typedef typename RhsView::MatrixTypeNested_ Rhs;
-    typedef typename nested_eval<Lhs, Dynamic>::type LhsNested;
-    typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
+    using Rhs = typename RhsView::MatrixTypeNested_;
+    using LhsNested = typename nested_eval<Lhs, Dynamic>::type;
+    using RhsNested = typename nested_eval<Rhs, Dynamic>::type;
     LhsNested lhsNested(lhs);
     RhsNested rhsNested(rhsView.matrix());
 
@@ -365,9 +392,9 @@
 template <typename LhsView, typename Rhs, int ProductTag>
 struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
     : public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject> {
-  typedef Product<LhsView, Rhs, DefaultProduct> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = Product<LhsView, Rhs, DefaultProduct>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   product_evaluator(const XprType& xpr) : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols()) {
     internal::construct_at<Base>(this, m_result);
@@ -383,9 +410,9 @@
 template <typename Lhs, typename RhsView, int ProductTag>
 struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
     : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject> {
-  typedef Product<Lhs, RhsView, DefaultProduct> XprType;
-  typedef typename XprType::PlainObject PlainObject;
-  typedef evaluator<PlainObject> Base;
+  using XprType = Product<Lhs, RhsView, DefaultProduct>;
+  using PlainObject = typename XprType::PlainObject;
+  using Base = evaluator<PlainObject>;
 
   product_evaluator(const XprType& xpr) : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols()) {
     ::new (static_cast<Base*>(this)) Base(m_result);
@@ -410,12 +437,12 @@
     const MatrixType& mat,
     SparseMatrix<typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex>& _dest,
     const typename MatrixType::StorageIndex* perm) {
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef SparseMatrix<Scalar, DestOrder, StorageIndex> Dest;
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
-  typedef evaluator<MatrixType> MatEval;
-  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using Scalar = typename MatrixType::Scalar;
+  using Dest = SparseMatrix<Scalar, DestOrder, StorageIndex>;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
+  using MatEval = evaluator<MatrixType>;
+  using MatIterator = typename evaluator<MatrixType>::InnerIterator;
 
   MatEval matEval(mat);
   Dest& dest(_dest.derived());
@@ -433,7 +460,7 @@
       Index r = it.row();
       Index c = it.col();
       Index ip = perm ? perm[i] : i;
-      if (Mode == int(Upper | Lower))
+      EIGEN_IF_CONSTEXPR (Mode == int(Upper | Lower))
         count[StorageOrderMatch ? jp : ip]++;
       else if (r == c)
         count[ip]++;
@@ -461,7 +488,7 @@
       StorageIndex jp = perm ? perm[j] : j;
       StorageIndex ip = perm ? perm[i] : i;
 
-      if (Mode == int(Upper | Lower)) {
+      EIGEN_IF_CONSTEXPR (Mode == int(Upper | Lower)) {
         Index k = count[StorageOrderMatch ? jp : ip]++;
         dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
         dest.valuePtr()[k] = it.value();
@@ -470,7 +497,7 @@
         dest.innerIndexPtr()[k] = ip;
         dest.valuePtr()[k] = it.value();
       } else if (((Mode & Lower) == Lower && r > c) || ((Mode & Upper) == Upper && r < c)) {
-        if (!StorageOrderMatch) std::swap(ip, jp);
+        EIGEN_IF_CONSTEXPR (!StorageOrderMatch) std::swap(ip, jp);
         Index k = count[jp]++;
         dest.innerIndexPtr()[k] = ip;
         dest.valuePtr()[k] = it.value();
@@ -486,12 +513,12 @@
 void permute_symm_to_symm(const MatrixType& mat,
                           SparseMatrix<typename MatrixType::Scalar, DstOrder, typename MatrixType::StorageIndex>& _dest,
                           const typename MatrixType::StorageIndex* perm) {
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef typename MatrixType::Scalar Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using Scalar = typename MatrixType::Scalar;
   SparseMatrix<Scalar, DstOrder, StorageIndex>& dest(_dest.derived());
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
-  typedef evaluator<MatrixType> MatEval;
-  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
+  using MatEval = evaluator<MatrixType>;
+  using MatIterator = typename evaluator<MatrixType>::InnerIterator;
 
   enum {
     SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
@@ -532,8 +559,8 @@
       Index k = count[int(DstMode) == int(Lower) ? (std::min)(ip, jp) : (std::max)(ip, jp)]++;
       dest.innerIndexPtr()[k] = int(DstMode) == int(Lower) ? (std::max)(ip, jp) : (std::min)(ip, jp);
 
-      if (!StorageOrderMatch) std::swap(ip, jp);
-      if (((int(DstMode) == int(Lower) && ip < jp) || (int(DstMode) == int(Upper) && ip > jp)))
+      EIGEN_IF_CONSTEXPR (!StorageOrderMatch) std::swap(ip, jp);
+      if ((int(DstMode) == int(Lower) && ip < jp) || (int(DstMode) == int(Upper) && ip > jp))
         dest.valuePtr()[k] = (NonHermitian ? it.value() : numext::conj(it.value()));
       else
         dest.valuePtr()[k] = it.value();
@@ -543,8 +570,6 @@
 
 }  // namespace internal
 
-// TODO implement twists in a more evaluator friendly fashion
-
 namespace internal {
 
 template <typename MatrixType, int Mode>
@@ -555,20 +580,20 @@
 template <typename MatrixType, int Mode>
 class SparseSymmetricPermutationProduct : public EigenBase<SparseSymmetricPermutationProduct<MatrixType, Mode> > {
  public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
+  using Scalar = typename MatrixType::Scalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
   enum {
     RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
     ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
   };
 
  protected:
-  typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> Perm;
+  using Perm = PermutationMatrix<Dynamic, Dynamic, StorageIndex>;
 
  public:
-  typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
-  typedef typename MatrixType::Nested MatrixTypeNested;
-  typedef internal::remove_all_t<MatrixTypeNested> NestedExpression;
+  using VectorI = Matrix<StorageIndex, Dynamic, 1>;
+  using MatrixTypeNested = typename MatrixType::Nested;
+  using NestedExpression = internal::remove_all_t<MatrixTypeNested>;
 
   SparseSymmetricPermutationProduct(const MatrixType& mat, const Perm& perm) : m_matrix(mat), m_perm(perm) {}
 
@@ -588,12 +613,11 @@
 template <typename DstXprType, typename MatrixType, int Mode, typename Scalar>
 struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType, Mode>,
                   internal::assign_op<Scalar, typename MatrixType::Scalar>, Sparse2Sparse> {
-  typedef SparseSymmetricPermutationProduct<MatrixType, Mode> SrcXprType;
-  typedef typename DstXprType::StorageIndex DstIndex;
+  using SrcXprType = SparseSymmetricPermutationProduct<MatrixType, Mode>;
+  using DstIndex = typename DstXprType::StorageIndex;
   template <int Options>
   static void run(SparseMatrix<Scalar, Options, DstIndex>& dst, const SrcXprType& src,
                   const internal::assign_op<Scalar, typename MatrixType::Scalar>&) {
-    // internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
     SparseMatrix<Scalar, (Options & RowMajor) == RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
     internal::permute_symm_to_fullsymm<Mode, false>(src.matrix(), tmp, src.perm().indices().data());
     dst = tmp;
diff --git a/Eigen/src/SparseCore/SparseSolverBase.h b/Eigen/src/SparseCore/SparseSolverBase.h
index acf1564..10f4c63 100644
--- a/Eigen/src/SparseCore/SparseSolverBase.h
+++ b/Eigen/src/SparseCore/SparseSolverBase.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSESOLVERBASE_H
 #define EIGEN_SPARSESOLVERBASE_H
@@ -25,7 +26,7 @@
 std::enable_if_t<Rhs::ColsAtCompileTime != 1 && Dest::ColsAtCompileTime != 1> solve_sparse_through_dense_panels(
     const Decomposition& dec, const Rhs& rhs, Dest& dest) {
   EIGEN_STATIC_ASSERT((Dest::Flags & RowMajorBit) == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
-  typedef typename Dest::Scalar DestScalar;
+  using DestScalar = typename Dest::Scalar;
   // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
   static const Index NbColsAtOnce = 4;
   Index rhsCols = rhs.cols();
@@ -46,7 +47,7 @@
 template <typename Decomposition, typename Rhs, typename Dest>
 std::enable_if_t<Rhs::ColsAtCompileTime == 1 || Dest::ColsAtCompileTime == 1> solve_sparse_through_dense_panels(
     const Decomposition& dec, const Rhs& rhs, Dest& dest) {
-  typedef typename Dest::Scalar DestScalar;
+  using DestScalar = typename Dest::Scalar;
   Index size = rhs.rows();
   Eigen::Matrix<DestScalar, Dynamic, 1> rhs_dense(rhs);
   Eigen::Matrix<DestScalar, Dynamic, 1> dest_dense(size);
@@ -64,14 +65,17 @@
  *
  */
 template <typename Derived>
-class SparseSolverBase : internal::noncopyable {
+class SparseSolverBase {
  public:
   /** Default constructor */
-  SparseSolverBase() : m_isInitialized(false) {}
+  SparseSolverBase() = default;
 
-  SparseSolverBase(SparseSolverBase&& other) : internal::noncopyable{}, m_isInitialized{other.m_isInitialized} {}
+  SparseSolverBase(const SparseSolverBase&) = delete;
+  SparseSolverBase& operator=(const SparseSolverBase&) = delete;
 
-  ~SparseSolverBase() {}
+  SparseSolverBase(SparseSolverBase&& other) : m_isInitialized{other.m_isInitialized} {}
+
+  ~SparseSolverBase() = default;
 
   Derived& derived() { return *static_cast<Derived*>(this); }
   const Derived& derived() const { return *static_cast<const Derived*>(this); }
@@ -107,7 +111,7 @@
 #endif  // EIGEN_PARSED_BY_DOXYGEN
 
  protected:
-  mutable bool m_isInitialized;
+  mutable bool m_isInitialized = false;
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/SparseCore/SparseSparseProductWithPruning.h b/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
index 84816ae..5827b20 100644
--- a/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
+++ b/Eigen/src/SparseCore/SparseSparseProductWithPruning.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
 #define EIGEN_SPARSESPARSEPRODUCTWITHPRUNING_H
@@ -21,26 +22,24 @@
 template <typename Lhs, typename Rhs, typename ResultType>
 static void sparse_sparse_product_with_pruning_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res,
                                                     const typename ResultType::RealScalar& tolerance) {
-  // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
-
-  typedef typename remove_all_t<Rhs>::Scalar RhsScalar;
-  typedef typename remove_all_t<ResultType>::Scalar ResScalar;
-  typedef typename remove_all_t<Lhs>::StorageIndex StorageIndex;
+  using RhsScalar = typename remove_all_t<Rhs>::Scalar;
+  using ResScalar = typename remove_all_t<ResultType>::Scalar;
+  using StorageIndex = typename remove_all_t<Lhs>::StorageIndex;
 
   // make sure to call innerSize/outerSize since we fake the storage order.
   Index rows = lhs.innerSize();
   Index cols = rhs.outerSize();
-  // Index size = lhs.outerSize();
   eigen_assert(lhs.outerSize() == rhs.innerSize());
 
   // allocate a temporary buffer
   AmbiVector<ResScalar, StorageIndex> tempVector(rows);
 
   // mimics a resizeByInnerOuter:
-  if (ResultType::IsRowMajor)
+  EIGEN_IF_CONSTEXPR (ResultType::IsRowMajor) {
     res.resize(cols, rows);
-  else
+  } else {
     res.resize(rows, cols);
+  }
 
   evaluator<Lhs> lhsEval(lhs);
   evaluator<Rhs> rhsEval(rhs);
@@ -81,10 +80,10 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
 
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
-    remove_all_t<ResultType> res_(res.rows(), res.cols());
+    remove_all_t<ResultType> res_{res.rows(), res.cols()};
     internal::sparse_sparse_product_with_pruning_impl<Lhs, Rhs, ResultType>(lhs, rhs, res_, tolerance);
     res.swap(res_);
   }
@@ -92,11 +91,11 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
     // we need a col-major matrix to hold the result
-    typedef SparseMatrix<typename ResultType::Scalar, ColMajor, typename ResultType::StorageIndex> SparseTemporaryType;
-    SparseTemporaryType res_(res.rows(), res.cols());
+    using SparseTemporaryType = SparseMatrix<typename ResultType::Scalar, ColMajor, typename ResultType::StorageIndex>;
+    SparseTemporaryType res_{res.rows(), res.cols()};
     internal::sparse_sparse_product_with_pruning_impl<Lhs, Rhs, SparseTemporaryType>(lhs, rhs, res_, tolerance);
     res = res_;
   }
@@ -104,10 +103,10 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
     // let's transpose the product to get a column x column product
-    remove_all_t<ResultType> res_(res.rows(), res.cols());
+    remove_all_t<ResultType> res_{res.rows(), res.cols()};
     internal::sparse_sparse_product_with_pruning_impl<Rhs, Lhs, ResultType>(rhs, lhs, res_, tolerance);
     res.swap(res_);
   }
@@ -115,28 +114,22 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
-    typedef SparseMatrix<typename Lhs::Scalar, ColMajor, typename Lhs::StorageIndex> ColMajorMatrixLhs;
-    typedef SparseMatrix<typename Rhs::Scalar, ColMajor, typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    using ColMajorMatrixLhs = SparseMatrix<typename Lhs::Scalar, ColMajor, typename Lhs::StorageIndex>;
+    using ColMajorMatrixRhs = SparseMatrix<typename Rhs::Scalar, ColMajor, typename Lhs::StorageIndex>;
     ColMajorMatrixLhs colLhs(lhs);
     ColMajorMatrixRhs colRhs(rhs);
     internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs, ColMajorMatrixRhs, ResultType>(colLhs, colRhs,
                                                                                                         res, tolerance);
-
-    // let's transpose the product to get a column x column product
-    //     typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType;
-    //     SparseTemporaryType res_(res.cols(), res.rows());
-    //     sparse_sparse_product_with_pruning_impl<Rhs,Lhs,SparseTemporaryType>(rhs, lhs, res_);
-    //     res = res_.transpose();
   }
 };
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
-    typedef SparseMatrix<typename Lhs::Scalar, RowMajor, typename Lhs::StorageIndex> RowMajorMatrixLhs;
+    using RowMajorMatrixLhs = SparseMatrix<typename Lhs::Scalar, RowMajor, typename Lhs::StorageIndex>;
     RowMajorMatrixLhs rowLhs(lhs);
     sparse_sparse_product_with_pruning_selector<RowMajorMatrixLhs, Rhs, ResultType, RowMajor, RowMajor>(rowLhs, rhs,
                                                                                                         res, tolerance);
@@ -145,9 +138,9 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
-    typedef SparseMatrix<typename Rhs::Scalar, RowMajor, typename Lhs::StorageIndex> RowMajorMatrixRhs;
+    using RowMajorMatrixRhs = SparseMatrix<typename Rhs::Scalar, RowMajor, typename Lhs::StorageIndex>;
     RowMajorMatrixRhs rowRhs(rhs);
     sparse_sparse_product_with_pruning_selector<Lhs, RowMajorMatrixRhs, ResultType, RowMajor, RowMajor, RowMajor>(
         lhs, rowRhs, res, tolerance);
@@ -156,9 +149,9 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
-    typedef SparseMatrix<typename Rhs::Scalar, ColMajor, typename Lhs::StorageIndex> ColMajorMatrixRhs;
+    using ColMajorMatrixRhs = SparseMatrix<typename Rhs::Scalar, ColMajor, typename Lhs::StorageIndex>;
     ColMajorMatrixRhs colRhs(rhs);
     internal::sparse_sparse_product_with_pruning_impl<Lhs, ColMajorMatrixRhs, ResultType>(lhs, colRhs, res, tolerance);
   }
@@ -166,9 +159,9 @@
 
 template <typename Lhs, typename Rhs, typename ResultType>
 struct sparse_sparse_product_with_pruning_selector<Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor> {
-  typedef typename ResultType::RealScalar RealScalar;
+  using RealScalar = typename ResultType::RealScalar;
   static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res, const RealScalar& tolerance) {
-    typedef SparseMatrix<typename Lhs::Scalar, ColMajor, typename Lhs::StorageIndex> ColMajorMatrixLhs;
+    using ColMajorMatrixLhs = SparseMatrix<typename Lhs::Scalar, ColMajor, typename Lhs::StorageIndex>;
     ColMajorMatrixLhs colLhs(lhs);
     internal::sparse_sparse_product_with_pruning_impl<ColMajorMatrixLhs, Rhs, ResultType>(colLhs, rhs, res, tolerance);
   }
diff --git a/Eigen/src/SparseCore/SparseTranspose.h b/Eigen/src/SparseCore/SparseTranspose.h
index 158f778..ef5dbb5 100644
--- a/Eigen/src/SparseCore/SparseTranspose.h
+++ b/Eigen/src/SparseCore/SparseTranspose.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSETRANSPOSE_H
 #define EIGEN_SPARSETRANSPOSE_H
@@ -21,12 +22,12 @@
 
 template <typename MatrixType>
 class SparseTransposeImpl<MatrixType, CompressedAccessBit> : public SparseCompressedBase<Transpose<MatrixType> > {
-  typedef SparseCompressedBase<Transpose<MatrixType> > Base;
+  using Base = SparseCompressedBase<Transpose<MatrixType>>;
 
  public:
   using Base::derived;
-  typedef typename Base::Scalar Scalar;
-  typedef typename Base::StorageIndex StorageIndex;
+  using Scalar = typename Base::Scalar;
+  using StorageIndex = typename Base::StorageIndex;
 
   inline Index nonZeros() const { return derived().nestedExpression().nonZeros(); }
 
@@ -45,17 +46,17 @@
 template <typename MatrixType>
 class TransposeImpl<MatrixType, Sparse> : public internal::SparseTransposeImpl<MatrixType> {
  protected:
-  typedef internal::SparseTransposeImpl<MatrixType> Base;
+  using Base = internal::SparseTransposeImpl<MatrixType>;
 };
 
 namespace internal {
 
 template <typename ArgType>
 struct unary_evaluator<Transpose<ArgType>, IteratorBased> : public evaluator_base<Transpose<ArgType> > {
-  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  using EvalIterator = typename evaluator<ArgType>::InnerIterator;
 
  public:
-  typedef Transpose<ArgType> XprType;
+  using XprType = Transpose<ArgType>;
 
   inline Index nonZerosEstimate() const { return m_argImpl.nonZerosEstimate(); }
 
diff --git a/Eigen/src/SparseCore/SparseTriangularView.h b/Eigen/src/SparseCore/SparseTriangularView.h
index a6c3eaa..01f9fcf 100644
--- a/Eigen/src/SparseCore/SparseTriangularView.h
+++ b/Eigen/src/SparseCore/SparseTriangularView.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
 #define EIGEN_SPARSE_TRIANGULARVIEW_H
@@ -28,36 +29,34 @@
  */
 template <typename MatrixType, unsigned int Mode>
 class TriangularViewImpl<MatrixType, Mode, Sparse> : public SparseMatrixBase<TriangularView<MatrixType, Mode> > {
-  enum {
-    SkipFirst =
-        ((Mode & Lower) && !(MatrixType::Flags & RowMajorBit)) || ((Mode & Upper) && (MatrixType::Flags & RowMajorBit)),
-    SkipLast = !SkipFirst,
-    SkipDiag = (Mode & ZeroDiag) ? 1 : 0,
-    HasUnitDiag = (Mode & UnitDiag) ? 1 : 0
-  };
-
-  typedef TriangularView<MatrixType, Mode> TriangularViewType;
+  using TriangularViewType = TriangularView<MatrixType, Mode>;
 
  protected:
   // dummy solve function to make TriangularView happy.
   void solve() const;
 
-  typedef SparseMatrixBase<TriangularViewType> Base;
+  using Base = SparseMatrixBase<TriangularViewType>;
 
  public:
   EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
 
-  typedef typename MatrixType::Nested MatrixTypeNested;
-  typedef std::remove_reference_t<MatrixTypeNested> MatrixTypeNestedNonRef;
-  typedef internal::remove_all_t<MatrixTypeNested> MatrixTypeNestedCleaned;
+  using MatrixTypeNested = typename MatrixType::Nested;
+  using MatrixTypeNestedNonRef = std::remove_reference_t<MatrixTypeNested>;
+  using MatrixTypeNestedCleaned = internal::remove_all_t<MatrixTypeNested>;
 
   template <typename RhsType, typename DstType>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void _solve_impl(const RhsType& rhs, DstType& dst) const {
-    if (!(internal::is_same<RhsType, DstType>::value && internal::extract_data(dst) == internal::extract_data(rhs)))
+    EIGEN_IF_CONSTEXPR ((std::is_same<RhsType, DstType>::value)) {
+      if (internal::extract_data(dst) != internal::extract_data(rhs)) dst = rhs;
+    } else {
       dst = rhs;
+    }
     this->solveInPlace(dst);
   }
 
+  EIGEN_DEVICE_FUNC constexpr Index rows() const noexcept { return derived().nestedExpression().rows(); }
+  EIGEN_DEVICE_FUNC constexpr Index cols() const noexcept { return derived().nestedExpression().cols(); }
+
   /** Applies the inverse of \c *this to the dense vector or matrix \a other, "in-place" */
   template <typename OtherDerived>
   void solveInPlace(MatrixBase<OtherDerived>& other) const;
@@ -71,12 +70,12 @@
 
 template <typename ArgType, unsigned int Mode>
 struct unary_evaluator<TriangularView<ArgType, Mode>, IteratorBased> : evaluator_base<TriangularView<ArgType, Mode> > {
-  typedef TriangularView<ArgType, Mode> XprType;
+  using XprType = TriangularView<ArgType, Mode>;
 
  protected:
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::StorageIndex StorageIndex;
-  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  using Scalar = typename XprType::Scalar;
+  using StorageIndex = typename XprType::StorageIndex;
+  using EvalIterator = typename evaluator<ArgType>::InnerIterator;
 
   enum {
     SkipFirst =
@@ -94,30 +93,36 @@
   inline Index nonZerosEstimate() const { return m_argImpl.nonZerosEstimate(); }
 
   class InnerIterator : public EvalIterator {
-    typedef EvalIterator Base;
+    using Base = EvalIterator;
 
    public:
     EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& xprEval, Index outer)
         : Base(xprEval.m_argImpl, outer),
           m_returnOne(false),
           m_containsDiag(Base::outer() < xprEval.m_arg.innerSize()) {
-      if (SkipFirst) {
+      EIGEN_IF_CONSTEXPR (SkipFirst) {
         while ((*this) && ((HasUnitDiag || SkipDiag) ? this->index() <= outer : this->index() < outer))
           Base::operator++();
-        if (HasUnitDiag) m_returnOne = m_containsDiag;
-      } else if (HasUnitDiag && ((!Base::operator bool()) || Base::index() >= Base::outer())) {
-        if ((!SkipFirst) && Base::operator bool()) Base::operator++();
-        m_returnOne = m_containsDiag;
+        EIGEN_IF_CONSTEXPR (HasUnitDiag) m_returnOne = m_containsDiag;
+      } else EIGEN_IF_CONSTEXPR (HasUnitDiag) {
+        if ((!Base::operator bool()) || Base::index() >= Base::outer()) {
+          if (Base::operator bool()) Base::operator++();
+          m_returnOne = m_containsDiag;
+        }
       }
     }
 
     EIGEN_STRONG_INLINE InnerIterator& operator++() {
-      if (HasUnitDiag && m_returnOne)
-        m_returnOne = false;
-      else {
-        Base::operator++();
-        if (HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index() >= Base::outer())) {
-          if ((!SkipFirst) && Base::operator bool()) Base::operator++();
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) {
+        if (m_returnOne) {
+          m_returnOne = false;
+          return *this;
+        }
+      }
+      Base::operator++();
+      EIGEN_IF_CONSTEXPR (HasUnitDiag && !SkipFirst) {
+        if ((!Base::operator bool()) || Base::index() >= Base::outer()) {
+          if (Base::operator bool()) Base::operator++();
           m_returnOne = m_containsDiag;
         }
       }
@@ -125,30 +130,33 @@
     }
 
     EIGEN_STRONG_INLINE operator bool() const {
-      if (HasUnitDiag && m_returnOne) return true;
-      if (SkipFirst)
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) {
+        if (m_returnOne) return true;
+      }
+      EIGEN_IF_CONSTEXPR (SkipFirst) {
         return Base::operator bool();
-      else {
-        if (SkipDiag)
+      } else {
+        EIGEN_IF_CONSTEXPR (SkipDiag) {
           return (Base::operator bool() && this->index() < this->outer());
-        else
+        } else {
           return (Base::operator bool() && this->index() <= this->outer());
+        }
       }
     }
 
     inline Index row() const { return (ArgType::Flags & RowMajorBit ? Base::outer() : this->index()); }
     inline Index col() const { return (ArgType::Flags & RowMajorBit ? this->index() : Base::outer()); }
     inline StorageIndex index() const {
-      if (HasUnitDiag && m_returnOne)
-        return internal::convert_index<StorageIndex>(Base::outer());
-      else
-        return Base::index();
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) {
+        if (m_returnOne) return internal::convert_index<StorageIndex>(Base::outer());
+      }
+      return Base::index();
     }
     inline Scalar value() const {
-      if (HasUnitDiag && m_returnOne)
-        return Scalar(1);
-      else
-        return Base::value();
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) {
+        if (m_returnOne) return Scalar(1);
+      }
+      return Base::value();
     }
 
    protected:
diff --git a/Eigen/src/SparseCore/SparseUtil.h b/Eigen/src/SparseCore/SparseUtil.h
index 8eedd54..e44d197 100644
--- a/Eigen/src/SparseCore/SparseUtil.h
+++ b/Eigen/src/SparseCore/SparseUtil.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEUTIL_H
 #define EIGEN_SPARSEUTIL_H
@@ -50,36 +51,24 @@
 
 template <typename MatrixType, unsigned int UpLo>
 class SparseSelfAdjointView;
-template <typename Lhs, typename Rhs>
-class SparseDiagonalProduct;
 template <typename MatrixType>
 class SparseView;
 
-template <typename Lhs, typename Rhs>
-class SparseSparseProduct;
-template <typename Lhs, typename Rhs>
-class SparseTimeDenseProduct;
-template <typename Lhs, typename Rhs>
-class DenseTimeSparseProduct;
-template <typename Lhs, typename Rhs, bool Transpose>
-class SparseDenseOuterProduct;
-
-template <typename Lhs, typename Rhs>
-struct SparseSparseProductReturnType;
-template <typename Lhs, typename Rhs,
-          int InnerSize = internal::min_size_prefer_fixed(internal::traits<Lhs>::ColsAtCompileTime,
-                                                          internal::traits<Rhs>::RowsAtCompileTime)>
-struct DenseSparseProductReturnType;
-
-template <typename Lhs, typename Rhs,
-          int InnerSize = internal::min_size_prefer_fixed(internal::traits<Lhs>::ColsAtCompileTime,
-                                                          internal::traits<Rhs>::RowsAtCompileTime)>
-struct SparseDenseProductReturnType;
 template <typename MatrixType, int UpLo>
 class SparseSymmetricPermutationProduct;
 
 namespace internal {
 
+/** \internal
+ * Compile-time test for whether a sparse expression exposes its storage directly
+ * through outerIndexPtr() / innerIndexPtr() / valuePtr() / innerNonZeroPtr()
+ * (the \ref CompressedAccessBit contract: SparseMatrix, SparseVector,
+ * Ref<Sparse>, Map<SparseMatrix>, ...). Such expressions can drive raw-pointer
+ * fast paths; anything else must be walked via InnerIterator.
+ */
+template <typename Derived>
+struct has_compressed_access : bool_constant<(int(traits<Derived>::Flags) & CompressedAccessBit) != 0> {};
+
 template <typename T, int Rows, int Cols, int Flags>
 struct sparse_eval;
 
@@ -89,49 +78,49 @@
 
 template <typename T, int Cols, int Flags>
 struct sparse_eval<T, 1, Cols, Flags> {
-  typedef typename traits<T>::Scalar Scalar_;
-  typedef typename traits<T>::StorageIndex StorageIndex_;
+  using Scalar_ = typename traits<T>::Scalar;
+  using StorageIndex_ = typename traits<T>::StorageIndex;
 
  public:
-  typedef SparseVector<Scalar_, RowMajor, StorageIndex_> type;
+  using type = SparseVector<Scalar_, RowMajor, StorageIndex_>;
 };
 
 template <typename T, int Rows, int Flags>
 struct sparse_eval<T, Rows, 1, Flags> {
-  typedef typename traits<T>::Scalar Scalar_;
-  typedef typename traits<T>::StorageIndex StorageIndex_;
+  using Scalar_ = typename traits<T>::Scalar;
+  using StorageIndex_ = typename traits<T>::StorageIndex;
 
  public:
-  typedef SparseVector<Scalar_, ColMajor, StorageIndex_> type;
+  using type = SparseVector<Scalar_, ColMajor, StorageIndex_>;
 };
 
 // TODO: consider unifying with plain_matrix_type<T, Sparse>.
 template <typename T, int Rows, int Cols, int Flags>
 struct sparse_eval {
-  typedef typename traits<T>::Scalar Scalar_;
-  typedef typename traits<T>::StorageIndex StorageIndex_;
+  using Scalar_ = typename traits<T>::Scalar;
+  using StorageIndex_ = typename traits<T>::StorageIndex;
   enum { Options_ = ((Flags & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor };
 
  public:
-  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> type;
+  using type = SparseMatrix<Scalar_, Options_, StorageIndex_>;
 };
 
 template <typename T, int Flags>
 struct sparse_eval<T, 1, 1, Flags> {
-  typedef typename traits<T>::Scalar Scalar_;
+  using Scalar_ = typename traits<T>::Scalar;
 
  public:
-  typedef Matrix<Scalar_, 1, 1> type;
+  using type = Matrix<Scalar_, 1, 1>;
 };
 
 template <typename T>
 struct plain_matrix_type<T, Sparse> {
-  typedef typename traits<T>::Scalar Scalar_;
-  typedef typename traits<T>::StorageIndex StorageIndex_;
+  using Scalar_ = typename traits<T>::Scalar;
+  using StorageIndex_ = typename traits<T>::StorageIndex;
   enum { Options_ = ((evaluator<T>::Flags & RowMajorBit) == RowMajorBit) ? RowMajor : ColMajor };
 
  public:
-  typedef SparseMatrix<Scalar_, Options_, StorageIndex_> type;
+  using type = SparseMatrix<Scalar_, Options_, StorageIndex_>;
 };
 
 template <typename T>
@@ -140,13 +129,13 @@
 
 template <typename Decomposition, typename RhsType>
 struct solve_traits<Decomposition, RhsType, Sparse> {
-  typedef typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,
-                               traits<RhsType>::Flags>::type PlainObject;
+  using PlainObject = typename sparse_eval<RhsType, RhsType::RowsAtCompileTime, RhsType::ColsAtCompileTime,
+                                           traits<RhsType>::Flags>::type;
 };
 
 template <typename Derived>
 struct generic_xpr_base<Derived, MatrixXpr, Sparse> {
-  typedef SparseMatrixBase<Derived> type;
+  using type = SparseMatrixBase<Derived>;
 };
 
 struct SparseTriangularShape {
@@ -158,19 +147,19 @@
 
 template <>
 struct glue_shapes<SparseShape, SelfAdjointShape> {
-  typedef SparseSelfAdjointShape type;
+  using type = SparseSelfAdjointShape;
 };
 template <>
 struct glue_shapes<SparseShape, TriangularShape> {
-  typedef SparseTriangularShape type;
+  using type = SparseTriangularShape;
 };
 
 // return type of SparseCompressedBase::lower_bound;
 struct LowerBoundIndex {
-  LowerBoundIndex() : value(-1), found(false) {}
+  LowerBoundIndex() = default;
   LowerBoundIndex(Index val, bool ok) : value(val), found(ok) {}
-  Index value;
-  bool found;
+  Index value = -1;
+  bool found = false;
 };
 
 }  // end namespace internal
@@ -186,7 +175,7 @@
 template <typename Scalar, typename StorageIndex = typename SparseMatrix<Scalar>::StorageIndex>
 class Triplet {
  public:
-  Triplet() : m_row(0), m_col(0), m_value(0) {}
+  Triplet() = default;
 
   Triplet(const StorageIndex& i, const StorageIndex& j, const Scalar& v = Scalar(0)) : m_row(i), m_col(j), m_value(v) {}
 
@@ -200,8 +189,9 @@
   const Scalar& value() const { return m_value; }
 
  protected:
-  StorageIndex m_row, m_col;
-  Scalar m_value;
+  StorageIndex m_row = 0;
+  StorageIndex m_col = 0;
+  Scalar m_value = Scalar(0);
 };
 
 }  // end namespace Eigen
diff --git a/Eigen/src/SparseCore/SparseVector.h b/Eigen/src/SparseCore/SparseVector.h
index 66fbb07..0de02d5 100644
--- a/Eigen/src/SparseCore/SparseVector.h
+++ b/Eigen/src/SparseCore/SparseVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEVECTOR_H
 #define EIGEN_SPARSEVECTOR_H
@@ -31,10 +32,10 @@
 namespace internal {
 template <typename Scalar_, int Options_, typename StorageIndex_>
 struct traits<SparseVector<Scalar_, Options_, StorageIndex_> > {
-  typedef Scalar_ Scalar;
-  typedef StorageIndex_ StorageIndex;
-  typedef Sparse StorageKind;
-  typedef MatrixXpr XprKind;
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using StorageKind = Sparse;
+  using XprKind = MatrixXpr;
   enum {
     IsColVector = (Options_ & RowMajorBit) ? 0 : 1,
 
@@ -60,7 +61,7 @@
 
 template <typename Scalar_, int Options_, typename StorageIndex_>
 class SparseVector : public SparseCompressedBase<SparseVector<Scalar_, Options_, StorageIndex_> > {
-  typedef SparseCompressedBase<SparseVector> Base;
+  using Base = SparseCompressedBase<SparseVector>;
   using Base::convert_index;
 
  public:
@@ -68,7 +69,7 @@
   EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, +=)
   EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseVector, -=)
 
-  typedef internal::CompressedStorage<Scalar, StorageIndex> Storage;
+  using Storage = internal::CompressedStorage<Scalar, StorageIndex>;
   enum { IsColVector = internal::traits<SparseVector>::IsColVector };
 
   enum { Options = Options_ };
@@ -121,8 +122,8 @@
   }
 
  public:
-  typedef typename Base::InnerIterator InnerIterator;
-  typedef typename Base::ReverseInnerIterator ReverseInnerIterator;
+  using InnerIterator = typename Base::InnerIterator;
+  using ReverseInnerIterator = typename Base::ReverseInnerIterator;
 
   inline void setZero() { m_data.clear(); }
 
@@ -181,8 +182,6 @@
     return m_data.value(p + 1);
   }
 
-  /**
-   */
   inline void reserve(Index reserveSize) { m_data.reserve(reserveSize); }
 
   inline void finalize() {}
@@ -196,7 +195,7 @@
    * \brief Prunes the entries of the vector based on a `predicate`
    * \tparam F Type of the predicate.
    * \param keep_predicate The predicate that is used to test whether a value should be kept. A callable that
-   * gets passed om a `Scalar` value and returns a boolean. If the predicate returns true, the value is kept.
+   * gets passed in a `Scalar` value and returns a boolean. If the predicate returns true, the value is kept.
    * \return The new number of structural non-zeros.
    */
   template <class F>
@@ -227,6 +226,12 @@
     resize(IsColVector ? rows : cols);
   }
 
+  /** \sa resize(Index,Index) */
+  void resize(NoChange_t, Index cols) { resize(rows(), cols); }
+
+  /** \sa resize(Index,Index) */
+  void resize(Index rows, NoChange_t) { resize(rows, cols()); }
+
   /** Resizes the sparse vector to \a newSize
    * This method deletes all entries, thus leaving an empty sparse vector
    *
@@ -331,13 +336,6 @@
     return *this;
   }
 
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-  template <typename Lhs, typename Rhs>
-  inline SparseVector& operator=(const SparseSparseProduct<Lhs, Rhs>& product) {
-    return Base::operator=(product);
-  }
-#endif
-
 #ifndef EIGEN_NO_IO
   friend std::ostream& operator<<(std::ostream& s, const SparseVector& m) {
     for (Index i = 0; i < m.nonZeros(); ++i) s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
@@ -346,9 +344,6 @@
   }
 #endif
 
-  /** Destructor */
-  inline ~SparseVector() {}
-
   /** Overloaded for performance */
   Scalar sum() const;
 
@@ -383,7 +378,7 @@
   /** \internal \deprecated use finalize() */
   EIGEN_DEPRECATED_WITH_REASON("Use .finalize() instead.") void endFill() {}
 
-  // These two functions were here in the 3.1 release, so let's keep them in case some code rely on them.
+  // These two functions were here in the 3.1 release, so let's keep them in case some code relies on them.
   /** \internal \deprecated use data() */
   EIGEN_DEPRECATED_WITH_REASON("Use .data() instead.") Storage& _data() { return m_data; }
   /** \internal \deprecated use data() */
@@ -405,10 +400,10 @@
 
 template <typename Scalar_, int Options_, typename Index_>
 struct evaluator<SparseVector<Scalar_, Options_, Index_> > : evaluator_base<SparseVector<Scalar_, Options_, Index_> > {
-  typedef SparseVector<Scalar_, Options_, Index_> SparseVectorType;
-  typedef evaluator_base<SparseVectorType> Base;
-  typedef typename SparseVectorType::InnerIterator InnerIterator;
-  typedef typename SparseVectorType::ReverseInnerIterator ReverseInnerIterator;
+  using SparseVectorType = SparseVector<Scalar_, Options_, Index_>;
+  using Base = evaluator_base<SparseVectorType>;
+  using InnerIterator = typename SparseVectorType::InnerIterator;
+  using ReverseInnerIterator = typename SparseVectorType::ReverseInnerIterator;
 
   enum { CoeffReadCost = NumTraits<Scalar_>::ReadCost, Flags = SparseVectorType::Flags };
 
@@ -428,7 +423,7 @@
 struct sparse_vector_assign_selector<Dest, Src, SVA_Inner> {
   static void run(Dest& dst, const Src& src) {
     eigen_internal_assert(src.innerSize() == src.size());
-    typedef internal::evaluator<Src> SrcEvaluatorType;
+    using SrcEvaluatorType = internal::evaluator<Src>;
     SrcEvaluatorType srcEval(src);
     for (typename SrcEvaluatorType::InnerIterator it(srcEval, 0); it; ++it) dst.insert(it.index()) = it.value();
   }
@@ -438,7 +433,7 @@
 struct sparse_vector_assign_selector<Dest, Src, SVA_Outer> {
   static void run(Dest& dst, const Src& src) {
     eigen_internal_assert(src.outerSize() == src.size());
-    typedef internal::evaluator<Src> SrcEvaluatorType;
+    using SrcEvaluatorType = internal::evaluator<Src>;
     SrcEvaluatorType srcEval(src);
     for (Index i = 0; i < src.size(); ++i) {
       typename SrcEvaluatorType::InnerIterator it(srcEval, i);
@@ -464,7 +459,7 @@
 template <typename Scalar, int Options, typename StorageIndex>
 class Serializer<SparseVector<Scalar, Options, StorageIndex>, void> {
  public:
-  typedef SparseVector<Scalar, Options, StorageIndex> SparseMat;
+  using SparseMat = SparseVector<Scalar, Options, StorageIndex>;
 
   struct Header {
     typename SparseMat::Index size;
@@ -487,12 +482,16 @@
 
     // Inner indices.
     std::size_t data_bytes = sizeof(StorageIndex) * header.num_non_zeros;
-    memcpy(dest, value.innerIndexPtr(), data_bytes);
+    if (data_bytes != 0) {
+      memcpy(dest, value.innerIndexPtr(), data_bytes);
+    }
     dest += data_bytes;
 
     // Values.
     data_bytes = sizeof(Scalar) * header.num_non_zeros;
-    memcpy(dest, value.valuePtr(), data_bytes);
+    if (data_bytes != 0) {
+      memcpy(dest, value.valuePtr(), data_bytes);
+    }
     dest += data_bytes;
 
     return dest;
@@ -515,13 +514,17 @@
     // Inner indices.
     std::size_t data_bytes = sizeof(StorageIndex) * header.num_non_zeros;
     if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
-    memcpy(value.innerIndexPtr(), src, data_bytes);
+    if (data_bytes != 0) {
+      memcpy(value.innerIndexPtr(), src, data_bytes);
+    }
     src += data_bytes;
 
     // Values.
     data_bytes = sizeof(Scalar) * header.num_non_zeros;
     if (EIGEN_PREDICT_FALSE(src + data_bytes > end)) return nullptr;
-    memcpy(value.valuePtr(), src, data_bytes);
+    if (data_bytes != 0) {
+      memcpy(value.valuePtr(), src, data_bytes);
+    }
     src += data_bytes;
     return src;
   }
diff --git a/Eigen/src/SparseCore/SparseView.h b/Eigen/src/SparseCore/SparseView.h
index d566898..03a2a51 100644
--- a/Eigen/src/SparseCore/SparseView.h
+++ b/Eigen/src/SparseCore/SparseView.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSEVIEW_H
 #define EIGEN_SPARSEVIEW_H
@@ -20,8 +21,8 @@
 
 template <typename MatrixType>
 struct traits<SparseView<MatrixType> > : traits<MatrixType> {
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef Sparse StorageKind;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using StorageKind = Sparse;
   enum { Flags = int(traits<MatrixType>::Flags) & (RowMajorBit) };
 };
 
@@ -35,7 +36,7 @@
  * \tparam MatrixType the type of the object of which we are removing the small entries
  *
  * This class represents an expression of a given dense or sparse matrix with
- * entries smaller than \c reference * \c epsilon are removed.
+ * entries smaller than \c reference * \c epsilon removed.
  * It is the return type of MatrixBase::sparseView() and SparseMatrixBase::pruned()
  * and most of the time this is the only way it is used.
  *
@@ -43,13 +44,12 @@
  */
 template <typename MatrixType>
 class SparseView : public SparseMatrixBase<SparseView<MatrixType> > {
-  typedef typename MatrixType::Nested MatrixTypeNested;
-  typedef internal::remove_all_t<MatrixTypeNested> MatrixTypeNested_;
-  typedef SparseMatrixBase<SparseView> Base;
+  using MatrixTypeNested = typename MatrixType::Nested;
+  using Base = SparseMatrixBase<SparseView>;
 
  public:
   EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView)
-  typedef internal::remove_all_t<MatrixType> NestedExpression;
+  using NestedExpression = internal::remove_all_t<MatrixType>;
 
   explicit SparseView(const MatrixType& mat, const Scalar& reference = Scalar(0),
                       const RealScalar& epsilon = NumTraits<Scalar>::dummy_precision())
@@ -81,14 +81,14 @@
 
 template <typename ArgType>
 struct unary_evaluator<SparseView<ArgType>, IteratorBased> : public evaluator_base<SparseView<ArgType> > {
-  typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
+  using EvalIterator = typename evaluator<ArgType>::InnerIterator;
 
  public:
-  typedef SparseView<ArgType> XprType;
+  using XprType = SparseView<ArgType>;
 
   class InnerIterator : public EvalIterator {
    protected:
-    typedef typename XprType::Scalar Scalar;
+    using Scalar = typename XprType::Scalar;
 
    public:
     EIGEN_STRONG_INLINE InnerIterator(const unary_evaluator& sve, Index outer)
@@ -109,7 +109,7 @@
 
    private:
     void incrementToNonZero() {
-      while ((bool(*this)) && internal::isMuchSmallerThan(value(), m_view.reference(), m_view.epsilon())) {
+      while (bool(*this) && internal::isMuchSmallerThan(value(), m_view.reference(), m_view.epsilon())) {
         EvalIterator::operator++();
       }
     }
@@ -127,12 +127,12 @@
 template <typename ArgType>
 struct unary_evaluator<SparseView<ArgType>, IndexBased> : public evaluator_base<SparseView<ArgType> > {
  public:
-  typedef SparseView<ArgType> XprType;
+  using XprType = SparseView<ArgType>;
 
  protected:
   enum { IsRowMajor = (XprType::Flags & RowMajorBit) == RowMajorBit };
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::StorageIndex StorageIndex;
+  using Scalar = typename XprType::Scalar;
+  using StorageIndex = typename XprType::StorageIndex;
 
  public:
   class InnerIterator {
@@ -166,7 +166,7 @@
 
    private:
     void incrementToNonZero() {
-      while ((bool(*this)) && internal::isMuchSmallerThan(value(), m_sve.m_view.reference(), m_sve.m_view.epsilon())) {
+      while (bool(*this) && internal::isMuchSmallerThan(value(), m_sve.m_view.reference(), m_sve.m_view.epsilon())) {
         m_inner++;
       }
     }
diff --git a/Eigen/src/SparseCore/SparsityPatternRef.h b/Eigen/src/SparseCore/SparsityPatternRef.h
new file mode 100644
index 0000000..711ae78
--- /dev/null
+++ b/Eigen/src/SparseCore/SparsityPatternRef.h
@@ -0,0 +1,458 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPARSITY_PATTERN_REF_H
+#define EIGEN_SPARSITY_PATTERN_REF_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+/** \internal
+ * \ingroup SparseCore_Module
+ *
+ * Non-owning view of a column-major sparsity pattern. The pattern is encoded
+ * as CSC index arrays:
+ *  - \c outer (size \c outerSize+1 when compressed) gives the start of each
+ *    column's row-index range in \c inner.
+ *  - \c inner holds the row indices.
+ *  - \c innerNonZero is non-null only for an uncompressed source: in that
+ *    case column \c j's row indices live in
+ *    [outer[j], outer[j] + innerNonZero[j]) instead of [outer[j], outer[j+1]).
+ *
+ * Use the helper \ref nonZeros to iterate uniformly over both layouts:
+ * \code
+ *   const Index nz = pattern.nonZeros(j);
+ *   for (Index k = pattern.outer[j], end = k + nz; k < end; ++k) {
+ *     Index row = pattern.inner[k];
+ *   }
+ * \endcode
+ *
+ * Construct via \ref make_col_major_pattern_ref, which shares the source
+ * storage when possible (already column-major SparseMatrix) and otherwise
+ * materializes the pattern into caller-supplied scratch buffers without ever
+ * reading the source's scalar values.
+ */
+template <typename StorageIndex>
+struct SparsityPatternRef {
+  const StorageIndex* outer = nullptr;
+  const StorageIndex* inner = nullptr;
+  // null ⇒ source is compressed: column j is [outer[j], outer[j+1]).
+  // otherwise: column j is [outer[j], outer[j] + innerNonZero[j]).
+  const StorageIndex* innerNonZero = nullptr;
+  Index outerSize = 0;  // number of columns
+  Index innerSize = 0;  // number of rows
+
+  EIGEN_DEVICE_FUNC inline bool isCompressed() const { return innerNonZero == nullptr; }
+
+  EIGEN_DEVICE_FUNC inline Index nonZeros(Index j) const {
+    return isCompressed() ? Index(outer[j + 1] - outer[j]) : Index(innerNonZero[j]);
+  }
+};
+
+/** \internal
+ * Build a column-major sparsity-pattern view of \c amat without copying any
+ * scalar values. The returned view aliases \c amat's index storage when
+ * \c amat is already a column-major \c SparseMatrix; otherwise the pattern is
+ * materialized into the caller-supplied \c outer_buf / \c inner_buf and the
+ * returned view points into them.
+ *
+ * The buffers must outlive every use of the returned view.
+ *
+ * Specialization for column-major \c SparseMatrix (the no-copy fast path).
+ */
+template <typename Scalar, typename StorageIndex>
+SparsityPatternRef<StorageIndex> make_col_major_pattern_ref(const SparseMatrix<Scalar, ColMajor, StorageIndex>& amat,
+                                                            Matrix<StorageIndex, Dynamic, 1>& /*outer_buf*/,
+                                                            Matrix<StorageIndex, Dynamic, 1>& /*inner_buf*/) {
+  SparsityPatternRef<StorageIndex> p;
+  p.outer = amat.outerIndexPtr();
+  p.inner = amat.innerIndexPtr();
+  p.innerNonZero = amat.isCompressed() ? nullptr : amat.innerNonZeroPtr();
+  p.outerSize = amat.cols();
+  p.innerSize = amat.rows();
+  return p;
+}
+
+/** \internal
+ * Generic fallback for any other sparse expression (row-major, products,
+ * permutations, etc.). The pattern is materialized into \c outer_buf and
+ * \c inner_buf via a value-free counting transpose driven by the expression
+ * evaluator. Some evaluators may materialize internally.
+ */
+template <typename Derived>
+SparsityPatternRef<typename Derived::StorageIndex> make_col_major_pattern_ref(
+    const SparseMatrixBase<Derived>& amat_base, Matrix<typename Derived::StorageIndex, Dynamic, 1>& outer_buf,
+    Matrix<typename Derived::StorageIndex, Dynamic, 1>& inner_buf) {
+  using StorageIndex = typename Derived::StorageIndex;
+  const Derived& amat = amat_base.derived();
+  internal::evaluator<Derived> amat_eval(amat);
+  const Index n_cols = amat.cols();
+  const Index n_outer = amat.outerSize();
+
+  outer_buf.setZero(n_cols + 1);
+  for (Index i = 0; i < n_outer; ++i)
+    for (typename internal::evaluator<Derived>::InnerIterator it(amat_eval, i); it; ++it) ++outer_buf(it.col() + 1);
+  for (Index j = 0; j < n_cols; ++j) outer_buf(j + 1) += outer_buf(j);
+  inner_buf.resize(outer_buf(n_cols));
+  Matrix<StorageIndex, Dynamic, 1> head = outer_buf.head(n_cols);
+  for (Index i = 0; i < n_outer; ++i)
+    for (typename internal::evaluator<Derived>::InnerIterator it(amat_eval, i); it; ++it)
+      inner_buf(head(it.col())++) = convert_index<StorageIndex>(it.row());
+
+  SparsityPatternRef<StorageIndex> p;
+  p.outer = outer_buf.data();
+  p.inner = inner_buf.data();
+  p.innerNonZero = nullptr;
+  p.outerSize = n_cols;
+  p.innerSize = amat.rows();
+  return p;
+}
+
+/** \internal
+ * Materialize a column-major sparsity pattern view as a compressed
+ * \c SparseMatrix with a 1-byte placeholder \c Scalar. Values are filled with
+ * a fixed nonzero sentinel — downstream pattern consumers (\c transpose(),
+ * sparse \c operator+, \c selfadjointView expansion) read coefficients even
+ * when the algorithm only cares about the pattern, so leaving them
+ * uninitialized would be UB.
+ *
+ * Intended for fill-reducing ordering algorithms (AMD, COLAMD) that read only
+ * the pattern. \b Precondition: \c out's storage must not alias \c pat —
+ * \c resize / \c resizeNonZeros may reallocate and invalidate the view.
+ *
+ * If \c row_perm is non-null, each inner row index is remapped through it
+ * (entry \c (i, j) of \c pat becomes \c (row_perm[i], j) in the result),
+ * implementing a left multiplication by a row permutation without copying any
+ * scalar values from the source.
+ *
+ * The result preserves SparseMatrix's invariant that inner indices are sorted
+ * within each column.
+ */
+template <typename StorageIndex>
+void materialize_col_major_pattern(const SparsityPatternRef<StorageIndex>& pat, const StorageIndex* row_perm,
+                                   SparseMatrix<signed char, ColMajor, StorageIndex>& out) {
+  const Index n_outer = pat.outerSize;
+  const Index n_inner = pat.innerSize;
+  out.resize(n_inner, n_outer);
+
+  Index total = 0;
+  if (pat.isCompressed()) {
+    total = pat.outer[n_outer];
+  } else {
+    for (Index j = 0; j < n_outer; ++j) total += pat.nonZeros(j);
+  }
+  out.resizeNonZeros(total);
+
+  StorageIndex* o_outer = out.outerIndexPtr();
+  StorageIndex* o_inner = out.innerIndexPtr();
+  if (pat.isCompressed()) {
+    // The source's outer array is already in CSC form, and SparseMatrix's
+    // outerIndexPtr() always starts at zero (as does the buffer-built fallback
+    // in make_col_major_pattern_ref), so the result's outer indices are a
+    // verbatim copy. For the no-permutation case the inner indices are also a
+    // straight bulk copy. Both reduce to single std::copy / memcpy calls.
+    std::copy(pat.outer, pat.outer + n_outer + 1, o_outer);
+    if (row_perm == nullptr) {
+      std::copy(pat.inner, pat.inner + total, o_inner);
+    } else {
+      // Remap-and-sort per column, reading from the source's inner array
+      // directly to avoid the write-amplification of bulk-copying then
+      // overwriting in place.
+      for (Index j = 0; j < n_outer; ++j) {
+        const StorageIndex* src = pat.inner + o_outer[j];
+        StorageIndex* dst = o_inner + o_outer[j];
+        const Index nz = o_outer[j + 1] - o_outer[j];
+        for (Index k = 0; k < nz; ++k) dst[k] = row_perm[src[k]];
+        std::sort(dst, dst + nz);
+      }
+    }
+  } else {
+    o_outer[0] = 0;
+    for (Index j = 0; j < n_outer; ++j) {
+      const Index nz = pat.nonZeros(j);
+      o_outer[j + 1] = convert_index<StorageIndex>(o_outer[j] + nz);
+      const StorageIndex* src = pat.inner + pat.outer[j];
+      StorageIndex* dst = o_inner + o_outer[j];
+      if (row_perm == nullptr) {
+        std::copy(src, src + nz, dst);
+      } else {
+        for (Index k = 0; k < nz; ++k) dst[k] = row_perm[src[k]];
+        std::sort(dst, dst + nz);
+      }
+    }
+  }
+  // Fill values with a fixed nonzero sentinel so downstream consumers that
+  // read coefficients (transpose, sparse +, selfadjointView expansion) do not
+  // observe uninitialized memory.
+  std::fill_n(out.valuePtr(), total, static_cast<signed char>(1));
+}
+
+/** \internal Convenience overload — identity row permutation. */
+template <typename StorageIndex>
+void materialize_col_major_pattern(const SparsityPatternRef<StorageIndex>& pat,
+                                   SparseMatrix<signed char, ColMajor, StorageIndex>& out) {
+  materialize_col_major_pattern(pat, static_cast<const StorageIndex*>(nullptr), out);
+}
+
+// The two materializers below — materialize_at_plus_a_pattern and
+// materialize_selfadjoint_pattern<UpLo> — share a common skeleton (counting
+// sort to build A^T, then two passes of linear two-way merge to count and
+// write column sizes). The two-way merge bodies are duplicated rather than
+// extracted into shared helpers because every attempt to factor them out
+// regressed performance by 2–5% on medium matrices: lambda-predicate
+// unification (because the lambda call wasn't elided across the inner loop)
+// and EIGEN_STRONG_INLINE function-template helpers (the compiler inlined
+// them but the function-template boundary still produced measurably worse
+// codegen than the explicit inline loops, presumably from differences in
+// register allocation or vectorization heuristics around the merge's
+// local-variable life-ranges). The merge logic is short enough that the
+// duplication is a small maintenance burden in exchange for stable codegen
+// on the AMD hot path. If a future compiler change makes the abstraction
+// free, this can be revisited.
+
+/** \internal
+ * Materialize the symmetric pattern \c pattern(A + A^T) of a square column-major
+ * sparsity pattern \a A as a compressed \c SparseMatrix with a 1-byte placeholder
+ * \c Scalar. Values are filled with a fixed nonzero sentinel.
+ *
+ * Avoids the \c C = A.transpose(); symmat = C + A; chain previously performed
+ * by Eigen's general-purpose evaluators. Both A's columns and A^T's columns
+ * (built by counting sort) are sorted, so per-column union is a linear two-way
+ * merge.
+ *
+ * Intended for fill-reducing ordering algorithms (AMD) that read only the
+ * pattern. \b Precondition: \a A is square (\c outerSize == innerSize) and
+ * \a out's storage must not alias \a A.
+ */
+template <typename StorageIndex>
+void materialize_at_plus_a_pattern(const SparsityPatternRef<StorageIndex>& A,
+                                   SparseMatrix<signed char, ColMajor, StorageIndex>& out) {
+  const Index n = A.outerSize;
+  eigen_assert(n == A.innerSize && "materialize_at_plus_a_pattern: A must be square");
+
+  // 1. Build A^T's column starts (= A's row counts) via counting sort.
+  Matrix<StorageIndex, Dynamic, 1> AT_p(n + 1);
+  AT_p.setZero();
+  for (Index j = 0; j < n; ++j) {
+    const Index nz = A.nonZeros(j);
+    const StorageIndex* col = A.inner + A.outer[j];
+    for (Index k = 0; k < nz; ++k) ++AT_p(col[k] + 1);
+  }
+  for (Index i = 0; i < n; ++i) AT_p(i + 1) += AT_p(i);
+
+  // 2. Place A^T's inner indices. Visiting A column-by-column in increasing j
+  //    means each A^T column accumulates its inner indices in increasing order,
+  //    so AT_i is sorted within each column. \a head is a deliberate deep copy
+  //    of \c AT_p.head(n) — it is incremented as a per-column write cursor while
+  //    \c AT_p remains the immutable column-start array used in passes 3 and 4.
+  const StorageIndex a_nnz = AT_p(n);
+  Matrix<StorageIndex, Dynamic, 1> AT_i(a_nnz);
+  Matrix<StorageIndex, Dynamic, 1> head = AT_p.head(n);
+  for (Index j = 0; j < n; ++j) {
+    const Index nz = A.nonZeros(j);
+    const StorageIndex* col = A.inner + A.outer[j];
+    for (Index k = 0; k < nz; ++k) AT_i(head(col[k])++) = convert_index<StorageIndex>(j);
+  }
+
+  // 3. First merge pass: count column sizes of pattern(A + A^T) by two-way
+  //    merge of A's and A^T's sorted columns.
+  out.resize(n, n);
+  StorageIndex* out_p = out.outerIndexPtr();
+  out_p[0] = 0;
+  for (Index j = 0; j < n; ++j) {
+    const StorageIndex* a_col = A.inner + A.outer[j];
+    const Index a_nz = A.nonZeros(j);
+    const StorageIndex* at_col = AT_i.data() + AT_p(j);
+    const Index at_nz = AT_p(j + 1) - AT_p(j);
+    Index ia = 0, it = 0, count = 0;
+    while (ia < a_nz && it < at_nz) {
+      const StorageIndex va = a_col[ia], vt = at_col[it];
+      if (va < vt) {
+        ++ia;
+      } else if (va > vt) {
+        ++it;
+      } else {
+        ++ia;
+        ++it;
+      }
+      ++count;
+    }
+    count += (a_nz - ia) + (at_nz - it);
+    out_p[j + 1] = out_p[j] + convert_index<StorageIndex>(count);
+  }
+
+  const StorageIndex total = out_p[n];
+  out.resizeNonZeros(total);
+
+  // 4. Second merge pass: write merged inner indices.
+  StorageIndex* out_i = out.innerIndexPtr();
+  for (Index j = 0; j < n; ++j) {
+    const StorageIndex* a_col = A.inner + A.outer[j];
+    const Index a_nz = A.nonZeros(j);
+    const StorageIndex* at_col = AT_i.data() + AT_p(j);
+    const Index at_nz = AT_p(j + 1) - AT_p(j);
+    StorageIndex* dst = out_i + out_p[j];
+    Index ia = 0, it = 0;
+    while (ia < a_nz && it < at_nz) {
+      const StorageIndex va = a_col[ia], vt = at_col[it];
+      if (va < vt) {
+        *dst++ = va;
+        ++ia;
+      } else if (va > vt) {
+        *dst++ = vt;
+        ++it;
+      } else {
+        *dst++ = va;
+        ++ia;
+        ++it;
+      }
+    }
+    while (ia < a_nz) *dst++ = a_col[ia++];
+    while (it < at_nz) *dst++ = at_col[it++];
+  }
+  std::fill_n(out.valuePtr(), total, static_cast<signed char>(1));
+}
+
+/** \internal
+ * Materialize the full symmetric pattern of a \c SparseSelfAdjointView<UpLo>
+ * given the underlying matrix's pattern view \a A. \c UpLo must be \c Lower or
+ * \c Upper; entries of \a A outside that triangle (and outside the diagonal)
+ * are ignored, matching \c selfadjointView semantics.
+ *
+ * Output is a compressed column-major \c SparseMatrix<signed char> with
+ * placeholder values, suitable for the AMD ordering pipeline. \b Precondition:
+ * \a A is square; \a out's storage must not alias \a A.
+ */
+template <unsigned int UpLo, typename StorageIndex>
+void materialize_selfadjoint_pattern(const SparsityPatternRef<StorageIndex>& A,
+                                     SparseMatrix<signed char, ColMajor, StorageIndex>& out) {
+  static_assert(UpLo == static_cast<unsigned>(Lower) || UpLo == static_cast<unsigned>(Upper),
+                "UpLo must be Lower or Upper");
+  const Index n = A.outerSize;
+  eigen_assert(n == A.innerSize && "materialize_selfadjoint_pattern: A must be square");
+  constexpr bool IsLower = (UpLo == static_cast<unsigned>(Lower));
+
+  // 1. Count filtered row occurrences (A^T's column lengths). For UpLo == Lower
+  //    we keep entries with row >= col; for Upper, row <= col. The diagonal is
+  //    kept in both cases.
+  Matrix<StorageIndex, Dynamic, 1> AT_p(n + 1);
+  AT_p.setZero();
+  for (Index j = 0; j < n; ++j) {
+    const Index nz = A.nonZeros(j);
+    const StorageIndex* col = A.inner + A.outer[j];
+    for (Index k = 0; k < nz; ++k) {
+      const StorageIndex r = col[k];
+      const bool keep = IsLower ? (Index(r) >= j) : (Index(r) <= j);
+      if (keep) ++AT_p(r + 1);
+    }
+  }
+  for (Index i = 0; i < n; ++i) AT_p(i + 1) += AT_p(i);
+
+  // 2. Place A^T's inner indices. The kept entries of column j are visited in
+  //    sorted row-order, so each A^T column ends up sorted. \a head is a deep
+  //    copy used as a per-column write cursor while \c AT_p stays untouched.
+  const StorageIndex a_nnz = AT_p(n);
+  Matrix<StorageIndex, Dynamic, 1> AT_i(a_nnz);
+  Matrix<StorageIndex, Dynamic, 1> head = AT_p.head(n);
+  for (Index j = 0; j < n; ++j) {
+    const Index nz = A.nonZeros(j);
+    const StorageIndex* col = A.inner + A.outer[j];
+    for (Index k = 0; k < nz; ++k) {
+      const StorageIndex r = col[k];
+      const bool keep = IsLower ? (Index(r) >= j) : (Index(r) <= j);
+      if (keep) AT_i(head(r)++) = convert_index<StorageIndex>(j);
+    }
+  }
+
+  // Cache the kept-range bound for each column so passes 3 and 4 don't both
+  // pay the binary search. For UpLo == Lower the kept range starts at
+  // \c lower_bound(j) and runs to the end of the column; for Upper it starts
+  // at 0 and ends at \c upper_bound(j). Storing only the side that requires a
+  // search keeps scratch to one Index per column.
+  Matrix<Index, Dynamic, 1> a_split(n);
+  for (Index j = 0; j < n; ++j) {
+    const StorageIndex* a_col = A.inner + A.outer[j];
+    const Index a_nz = A.nonZeros(j);
+    EIGEN_IF_CONSTEXPR (IsLower) {
+      a_split(j) = std::lower_bound(a_col, a_col + a_nz, StorageIndex(j)) - a_col;
+    } else {
+      a_split(j) = std::upper_bound(a_col, a_col + a_nz, StorageIndex(j)) - a_col;
+    }
+  }
+
+  // 3. First merge pass: count column sizes of pattern(A + A^T) over the
+  //    filtered subrange of each column.
+  out.resize(n, n);
+  StorageIndex* out_p = out.outerIndexPtr();
+  out_p[0] = 0;
+  for (Index j = 0; j < n; ++j) {
+    const StorageIndex* a_col = A.inner + A.outer[j];
+    const Index a_nz = A.nonZeros(j);
+    const StorageIndex* a_kept = IsLower ? a_col + a_split(j) : a_col;
+    const Index a_kept_nz = IsLower ? (a_nz - a_split(j)) : a_split(j);
+    const StorageIndex* at_col = AT_i.data() + AT_p(j);
+    const Index at_nz = AT_p(j + 1) - AT_p(j);
+    Index ia = 0, it = 0, count = 0;
+    while (ia < a_kept_nz && it < at_nz) {
+      const StorageIndex va = a_kept[ia], vt = at_col[it];
+      if (va < vt) {
+        ++ia;
+      } else if (va > vt) {
+        ++it;
+      } else {
+        ++ia;
+        ++it;
+      }
+      ++count;
+    }
+    count += (a_kept_nz - ia) + (at_nz - it);
+    out_p[j + 1] = out_p[j] + convert_index<StorageIndex>(count);
+  }
+
+  const StorageIndex total = out_p[n];
+  out.resizeNonZeros(total);
+
+  // 4. Second merge pass: write merged inner indices.
+  StorageIndex* out_i = out.innerIndexPtr();
+  for (Index j = 0; j < n; ++j) {
+    const StorageIndex* a_col = A.inner + A.outer[j];
+    const Index a_nz = A.nonZeros(j);
+    const StorageIndex* a_kept = IsLower ? a_col + a_split(j) : a_col;
+    const Index a_kept_nz = IsLower ? (a_nz - a_split(j)) : a_split(j);
+    const StorageIndex* at_col = AT_i.data() + AT_p(j);
+    const Index at_nz = AT_p(j + 1) - AT_p(j);
+    StorageIndex* dst = out_i + out_p[j];
+    Index ia = 0, it = 0;
+    while (ia < a_kept_nz && it < at_nz) {
+      const StorageIndex va = a_kept[ia], vt = at_col[it];
+      if (va < vt) {
+        *dst++ = va;
+        ++ia;
+      } else if (va > vt) {
+        *dst++ = vt;
+        ++it;
+      } else {
+        *dst++ = va;
+        ++ia;
+        ++it;
+      }
+    }
+    while (ia < a_kept_nz) *dst++ = a_kept[ia++];
+    while (it < at_nz) *dst++ = at_col[it++];
+  }
+  std::fill_n(out.valuePtr(), total, static_cast<signed char>(1));
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_SPARSITY_PATTERN_REF_H
diff --git a/Eigen/src/SparseCore/ThreadedSparseProduct.h b/Eigen/src/SparseCore/ThreadedSparseProduct.h
new file mode 100644
index 0000000..db62f8a
--- /dev/null
+++ b/Eigen/src/SparseCore/ThreadedSparseProduct.h
@@ -0,0 +1,405 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_THREADED_SPARSE_PRODUCT_H
+#define EIGEN_THREADED_SPARSE_PRODUCT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+inline ThreadPool& default_threaded_sparse_pool() {
+  static ThreadPool pool(numext::maxi<unsigned>(1u, std::thread::hardware_concurrency()));
+  return pool;
+}
+
+// nnz-balanced partition of an outer range [0, outerSize) into numChunks
+// contiguous chunks. boundaries[t] = first outer index owned by partition t;
+// boundaries[numChunks] = outerSize.
+//
+// The split uses std::lower_bound on the outer-index array. Targets are
+// monotonically increasing in t, so each search starts from the previous
+// boundary; total work is bounded by O(numChunks + log outerSize) rather than
+// numChunks * log(outerSize). Each chunk's nnz count differs from the ideal by
+// at most max_nnz_per_outer.
+template <typename StorageIndex>
+inline void compute_nnz_balanced_partition(const StorageIndex* outer, Index outerSize, Index totalNnz, int numChunks,
+                                           std::vector<Index>& boundaries) {
+  boundaries.assign(numChunks + 1, 0);
+  boundaries[numChunks] = outerSize;
+  if (numChunks <= 1 || outerSize == 0 || totalNnz == 0) return;
+  const StorageIndex* const last = outer + outerSize + 1;
+  const StorageIndex* lo = outer;
+  for (int t = 1; t < numChunks; ++t) {
+    Index target = (static_cast<Index>(t) * totalNnz) / numChunks;
+    lo = std::lower_bound(lo, last, static_cast<StorageIndex>(target));
+    boundaries[t] = lo - outer;
+  }
+}
+
+// Single-row dot-product kernel. Used as the body of a per-row OpenMP
+// `parallel for` (which can do its own dynamic scheduling) and from within
+// run_dot_chunk for the ThreadPool dispatch path. Marked ALWAYS_INLINE so
+// the loop body is visible to the OMP iteration scheduler for vectorization.
+template <bool Conjugate, bool Overwrite, typename Scalar, typename StorageIndex, typename XScalar, typename YScalar,
+          typename AlphaT>
+EIGEN_ALWAYS_INLINE void run_dot_row(const Scalar* EIGEN_RESTRICT vals, const StorageIndex* EIGEN_RESTRICT inner,
+                                     const StorageIndex* EIGEN_RESTRICT outer,
+                                     const StorageIndex* EIGEN_RESTRICT innerNnz, const XScalar* EIGEN_RESTRICT x,
+                                     YScalar* EIGEN_RESTRICT y, Index i, const AlphaT& alpha) {
+  const Index k0 = outer[i];
+  const Index end = innerNnz ? (k0 + innerNnz[i]) : outer[i + 1];
+  Scalar s0(0), s1(0);
+  Index k = k0;
+  const conj_if<Conjugate> cj{};
+  // Loop structure mirrors the existing kernel in SparseDenseProduct.h so
+  // the compiler vectorizes identically.
+  for (; k < end; ++k) {
+    s0 += cj(vals[k]) * x[inner[k]];
+    ++k;
+    if (k < end) s1 += cj(vals[k]) * x[inner[k]];
+  }
+  const Scalar s = s0 + s1;
+  EIGEN_IF_CONSTEXPR (Overwrite) {
+    y[i] = alpha * s;
+  } else {
+    y[i] += alpha * s;
+  }
+}
+
+// Dot-product-per-outer kernel. Used by both forward and adjoint paths; the
+// adjoint path sets Conjugate=true (no-op for real Scalar).
+//
+// Processes outer indices [lo, hi). For each outer i:
+//   if Overwrite: y[i]  = alpha * sum_k op(val[k]) * x[inner[k]]
+//   else:         y[i] += alpha * sum_k op(val[k]) * x[inner[k]]
+// where op(.) is conj(.) iff Conjugate.
+//
+// Writes are independent across threads (each thread owns a contiguous output
+// range), so no synchronization is required.
+template <bool Conjugate, bool Overwrite, typename Scalar, typename StorageIndex, typename XScalar, typename YScalar,
+          typename AlphaT>
+EIGEN_STRONG_INLINE void run_dot_chunk(const Scalar* EIGEN_RESTRICT vals, const StorageIndex* EIGEN_RESTRICT inner,
+                                       const StorageIndex* EIGEN_RESTRICT outer,
+                                       const StorageIndex* EIGEN_RESTRICT innerNnz, const XScalar* EIGEN_RESTRICT x,
+                                       YScalar* EIGEN_RESTRICT y, Index lo, Index hi, const AlphaT& alpha) {
+  for (Index i = lo; i < hi; ++i) {
+    run_dot_row<Conjugate, Overwrite, Scalar, StorageIndex>(vals, inner, outer, innerNnz, x, y, i, alpha);
+  }
+}
+
+}  // namespace internal
+
+/** \class ThreadedSparseProduct
+ * \ingroup SparseCore_Module
+ *
+ * \brief Cached, thread-parallel sparse matrix * dense vector product.
+ *
+ * Designed for iterative solvers (CG, BiCGSTAB, GMRES, LSCG) that multiply
+ * many times by the same sparse matrix and, in the case of LSCG, by its
+ * adjoint. The constructor (or analyzePattern()) computes an nnz-balanced
+ * row partition once and reuses it across every apply()/applyAdjoint() call.
+ *
+ * The forward direction (apply) always runs a dot-product-per-outer kernel,
+ * which is embarrassingly parallel (no write conflicts). For matrices whose
+ * native storage order doesn't match the forward direction (ColMajor for
+ * forward, or RowMajor for adjoint), a transposed mirror is built lazily on
+ * first use. The mirror doubles the memory footprint of the matrix but
+ * permits conflict-free parallel writes for both directions.
+ *
+ * The matrix is held by const reference (no copy). Caller is responsible for
+ * keeping it alive across apply calls, and for invalidating the cache when
+ * the matrix changes:
+ *   - sparsity-pattern change: call analyzePattern()/compute() to rebuild
+ *     the partition and drop the mirror.
+ *   - coefficient-only change (same pattern): call refreshValues() to
+ *     drop the (now-stale) mirror; the next mirror-using direction will
+ *     rebuild it lazily. Without this call, mirror-backed directions
+ *     would read frozen coefficients from the cached copy.
+ *
+ * Aliasing: apply()/applyAdjoint() do NOT insert temporaries on overlap
+ * between x and y; callers must use distinct storage (the kernel writes
+ * y[i] from a sum over x[inner[k]] reads, which would mis-compute if
+ * y aliases x). Asserted in debug builds.
+ *
+ * Thread-safety: the const apply()/applyAdjoint()/applyAddTo()/applyAdjointAddTo()
+ * methods are safe to call concurrently on the same operator -- the lazy mirror
+ * is published through an atomic with double-checked locking. The non-const
+ * methods (analyzePattern()/compute()/refreshValues()) and destruction are NOT;
+ * they mutate or free the cached mirror, so they must not overlap any in-flight
+ * apply() (the same rule as calling any method concurrently with the destructor).
+ *
+ * Layout: x and y are taken as Ref<const DenseVector> / Ref<DenseVector>.
+ * Plain vectors and unit-inner-stride views (e.g. a column of a ColMajor
+ * matrix, an unaligned Map of a contiguous buffer) bind without copying;
+ * a strided const input is copy-evaluated by Ref; a strided mutable output
+ * triggers a Ref runtime error.
+ *
+ * \tparam SparseMatrixType A compressed Eigen::SparseMatrix<Scalar, Order, StorageIndex>.
+ */
+template <typename SparseMatrixType_>
+class ThreadedSparseProduct {
+ public:
+  typedef SparseMatrixType_ SparseMatrixType;
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::RealScalar RealScalar;
+  typedef typename SparseMatrixType::StorageIndex StorageIndex;
+
+  enum { IsRowMajor = static_cast<int>(SparseMatrixType::IsRowMajor) };
+
+  // Opposite-storage-order mirror used by the conflict-free path for whichever
+  // direction doesn't match A's native order.
+  typedef SparseMatrix<Scalar, IsRowMajor ? ColMajor : RowMajor, StorageIndex> MirrorType;
+
+  // The dot-product kernel walks x/y via raw `Scalar*` with unit inner
+  // stride; constraining the public API to `Ref` forces compatible layout
+  // (binding for plain matrices, vectors, and unit-stride Maps/Blocks;
+  // copy-evaluation for non-conforming const inputs; runtime error for
+  // non-conforming mutable outputs).
+  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
+  typedef Ref<const DenseVector> ConstVectorRef;
+  typedef Ref<DenseVector> MutableVectorRef;
+
+  ThreadedSparseProduct() = default;
+
+  explicit ThreadedSparseProduct(const SparseMatrixType& mat, ThreadPool* pool = nullptr) : m_pool(pool) {
+    analyzePattern(mat);
+  }
+
+  ~ThreadedSparseProduct() { delete m_mirror.load(std::memory_order_acquire); }
+
+  ThreadedSparseProduct(const ThreadedSparseProduct&) = delete;
+  ThreadedSparseProduct& operator=(const ThreadedSparseProduct&) = delete;
+
+  /** Bind to \a mat and (re)compute the partition. Drops any previously built
+   * adjoint mirror. */
+  ThreadedSparseProduct& analyzePattern(const SparseMatrixType& mat) {
+    eigen_assert(mat.isCompressed() && "ThreadedSparseProduct requires a compressed SparseMatrix");
+    m_mat = &mat;
+    delete m_mirror.exchange(nullptr, std::memory_order_acq_rel);
+    m_adj_partition.clear();
+
+    build_partition(mat.outerIndexPtr(), mat.outerSize(), mat.nonZeros(), m_native_partition);
+    return *this;
+  }
+
+  ThreadedSparseProduct& compute(const SparseMatrixType& mat) { return analyzePattern(mat); }
+
+  /** Drops the cached adjoint mirror without recomputing the partition. Use
+   * after coefficient-only updates to the bound matrix so the next
+   * applyAdjoint() (or forward apply on a ColMajor A) rebuilds the mirror
+   * with the new values. */
+  ThreadedSparseProduct& refreshValues() {
+    delete m_mirror.exchange(nullptr, std::memory_order_acq_rel);
+    return *this;
+  }
+
+  Index rows() const { return m_mat ? m_mat->rows() : Index(0); }
+  Index cols() const { return m_mat ? m_mat->cols() : Index(0); }
+
+  /// Overwriting forward apply: y = A * x.
+  void apply(const ConstVectorRef& x, MutableVectorRef y) const {
+    apply_impl<false, /*Overwrite=*/true>(x, y, Scalar(1));
+  }
+  /// Overwriting adjoint apply: y = A^H * x.
+  void applyAdjoint(const ConstVectorRef& x, MutableVectorRef y) const {
+    apply_impl<true, /*Overwrite=*/true>(x, y, Scalar(1));
+  }
+  /// Accumulating forward apply: y += alpha * A * x.
+  void applyAddTo(const ConstVectorRef& x, MutableVectorRef y, const Scalar& alpha) const {
+    apply_impl<false, /*Overwrite=*/false>(x, y, alpha);
+  }
+  /// Accumulating adjoint apply: y += alpha * A^H * x.
+  void applyAdjointAddTo(const ConstVectorRef& x, MutableVectorRef y, const Scalar& alpha) const {
+    apply_impl<true, /*Overwrite=*/false>(x, y, alpha);
+  }
+
+  /// Returns the thread pool used by this operator.
+  ThreadPool* pool() const { return m_pool ? m_pool : &internal::default_threaded_sparse_pool(); }
+
+  /// True iff the lazy adjoint mirror has been materialized.
+  bool hasMirror() const { return m_mirror.load(std::memory_order_acquire) != nullptr; }
+
+ private:
+  template <bool Adjoint, bool Overwrite>
+  void apply_impl(const ConstVectorRef& x, MutableVectorRef& y, const Scalar& alpha) const {
+    eigen_assert(m_mat && "ThreadedSparseProduct: matrix not set; call analyzePattern() first");
+    if (Adjoint) {
+      eigen_assert(x.size() == m_mat->rows());
+      eigen_assert(y.size() == m_mat->cols());
+    } else {
+      eigen_assert(x.size() == m_mat->cols());
+      eigen_assert(y.size() == m_mat->rows());
+    }
+    // The kernel reads x and writes y concurrently across threads; aliasing
+    // (x and y overlap) would mis-compute because some x[k] reads see y
+    // writes from the same SpMV call. Cheap address-range check; cast to
+    // uintptr_t because comparing pointers from unrelated allocations is
+    // technically UB in C++.
+    eigen_assert((x.size() == 0 || y.size() == 0 || std::uintptr_t(x.data() + x.size()) <= std::uintptr_t(y.data()) ||
+                  std::uintptr_t(y.data() + y.size()) <= std::uintptr_t(x.data())) &&
+                 "ThreadedSparseProduct: x and y must not overlap");
+    // Decide which storage to read from.
+    //   Forward kernel iterates a RowMajor view of A; adjoint kernel iterates
+    //   a ColMajor view of A. If A already has the required order, read it
+    //   directly; otherwise build/use the mirror.
+    constexpr bool NeedRowMajorView = !Adjoint;
+    constexpr bool NativeIsRowMajor = IsRowMajor;
+    constexpr bool UseMirror = NeedRowMajorView != NativeIsRowMajor;
+
+    EIGEN_IF_CONSTEXPR (UseMirror) {
+      const MirrorType& m = ensure_mirror();
+      run<Adjoint, Overwrite>(m.valuePtr(), m.innerIndexPtr(), m.outerIndexPtr(), m.innerNonZeroPtr(),
+                              /*outerSize=*/m.outerSize(), m_adj_partition, x, y, alpha);
+    } else {
+      run<Adjoint, Overwrite>(m_mat->valuePtr(), m_mat->innerIndexPtr(), m_mat->outerIndexPtr(),
+                              m_mat->innerNonZeroPtr(),
+                              /*outerSize=*/m_mat->outerSize(), m_native_partition, x, y, alpha);
+    }
+  }
+
+  // Serial-fallback threshold; matches the same constant in SparseDenseProduct.h.
+  static constexpr Index kThreadingThreshold = 20000;
+
+  template <bool Conjugate, bool Overwrite>
+  void run(const Scalar* vals, const StorageIndex* inner, const StorageIndex* outer, const StorageIndex* innerNnz,
+           Index outerSize, const std::vector<Index>& part, const ConstVectorRef& x, MutableVectorRef& y,
+           const Scalar& alpha) const {
+    // OpenMP path doesn't use the cached partition (dynamic scheduling balances
+    // itself), so derive T fresh from the current Eigen::nbThreads() /
+    // OMP_NUM_THREADS at apply time -- otherwise `setNbThreads()` after
+    // analyzePattern() would be silently ignored. The ThreadPool path is
+    // bound to the partition built for a specific T at analyzePattern() time.
+#ifdef EIGEN_HAS_OPENMP
+    const int T = target_thread_count();
+#else
+    const int T = static_cast<int>(part.size()) - 1;
+#endif
+    const Index total_nnz = m_mat->nonZeros();
+    // Ref construction already enforced unit inner stride for x/y.
+    const Scalar* xp = x.data();
+    Scalar* yp = y.data();
+    if (T <= 1 || total_nnz < kThreadingThreshold) {
+      internal::run_dot_chunk<Conjugate, Overwrite, Scalar, StorageIndex>(vals, inner, outer, innerNnz, xp, yp, 0,
+                                                                          outerSize, alpha);
+      return;
+    }
+
+#ifdef EIGEN_HAS_OPENMP
+    // Prefer OpenMP for dispatch when available. Use dynamic scheduling
+    // over rows with chunks sized so the OMP runtime gets ~4*T chunks to
+    // distribute -- enough granularity to absorb residual nnz imbalance
+    // without blowing dispatch overhead.
+    const Index chunk = numext::maxi<Index>(Index(1), (outerSize + Index(T) * 4 - 1) / (Index(T) * 4));
+#pragma omp parallel for schedule(dynamic, chunk) num_threads(T)
+    for (Index i = 0; i < outerSize; ++i) {
+      internal::run_dot_row<Conjugate, Overwrite, Scalar, StorageIndex>(vals, inner, outer, innerNnz, xp, yp, i, alpha);
+    }
+#else
+    // ThreadPool path: enqueue T-1 worker tasks, run partition 0 on this
+    // thread, then wait on the barrier. Avoids ForkJoin's log(T)-hop critical
+    // path before the last leaf starts.
+    Barrier barrier(static_cast<unsigned>(T));
+    ThreadPool* p = pool();
+    for (int t = 1; t < T; ++t) {
+      const Index lo = part[t], hi = part[t + 1];
+      if (lo == hi) {
+        barrier.Notify();
+        continue;
+      }
+      p->Schedule([=, &barrier]() {
+        internal::run_dot_chunk<Conjugate, Overwrite, Scalar, StorageIndex>(vals, inner, outer, innerNnz, xp, yp, lo,
+                                                                            hi, alpha);
+        barrier.Notify();
+      });
+    }
+    internal::run_dot_chunk<Conjugate, Overwrite, Scalar, StorageIndex>(vals, inner, outer, innerNnz, xp, yp, part[0],
+                                                                        part[1], alpha);
+    barrier.Notify();
+    barrier.Wait();
+#endif
+  }
+
+  // Lazy mirror construction. Double-checked atomic init avoids per-call
+  // std::call_once cost (which historically varies across libstdc++ versions).
+  const MirrorType& ensure_mirror() const {
+    MirrorType* m = m_mirror.load(std::memory_order_acquire);
+    if (m) return *m;
+    std::lock_guard<std::mutex> lock(m_mirror_init_mu);
+    m = m_mirror.load(std::memory_order_relaxed);
+    if (!m) {
+      // Same logical matrix, opposite storage order. Eigen detects the
+      // storage-order mismatch in assignment and reorganizes the data
+      // (a "structural transpose"); the logical matrix is preserved, no
+      // conjugation. The kernel applies conj at use when needed.
+      // Hold the mirror in a unique_ptr while building: the assignment,
+      // makeCompressed(), and build_partition() can all throw (bad_alloc), and a
+      // raw owning pointer would leak. Hand ownership to the atomic only once the
+      // mirror is fully built; on throw the buffer is freed and m_mirror stays
+      // null so a later call rebuilds cleanly.
+      std::unique_ptr<MirrorType> built(new MirrorType(m_mat->rows(), m_mat->cols()));
+      *built = *m_mat;
+      built->makeCompressed();
+      build_partition(built->outerIndexPtr(), built->outerSize(), built->nonZeros(), m_adj_partition);
+      m = built.get();
+      m_mirror.store(built.release(), std::memory_order_release);
+    }
+    return *m;
+  }
+
+  // Thread count target.  Under OpenMP, respect Eigen::setNbThreads() /
+  // OMP_NUM_THREADS instead of the lazy default ThreadPool's size (which
+  // also avoids constructing that pool when OMP does the dispatch).
+  int target_thread_count() const {
+#ifdef EIGEN_HAS_OPENMP
+    return numext::maxi(1, Eigen::nbThreads());
+#else
+    return pool()->NumThreads();
+#endif
+  }
+
+  // nnz-balanced partition of A's outer dim into T contiguous chunks, with
+  // a guard against pathological skew: if more than half the partitions end
+  // up empty (one hub outer holding most of the nnz), fall back to a single
+  // serial chunk so the inner kernel doesn't pay parallel dispatch for no
+  // parallel work.
+  void build_partition(const StorageIndex* outer, Index outerSize, Index nnz, std::vector<Index>& part) const {
+    const int T = target_thread_count();
+    internal::compute_nnz_balanced_partition(outer, outerSize, nnz, T, part);
+    int non_empty = 0;
+    for (std::size_t t = 0; t + 1 < part.size(); ++t)
+      if (part[t + 1] > part[t]) ++non_empty;
+    if (non_empty * 2 < T) {
+      part.assign(2, 0);
+      part[1] = outerSize;
+    }
+  }
+
+ private:
+  const SparseMatrixType* m_mat = nullptr;
+  ThreadPool* m_pool = nullptr;
+
+  // Partition of A's native outer dim by nnz balance. Used by the direction
+  // whose kernel matches A's storage order.
+  std::vector<Index> m_native_partition;
+
+  // Lazy adjoint-direction mirror in the opposite storage order, plus its
+  // own nnz-balanced partition. Constructed on first use.
+  mutable std::atomic<MirrorType*> m_mirror{nullptr};
+  mutable std::mutex m_mirror_init_mu;
+  mutable std::vector<Index> m_adj_partition;
+};
+
+}  // namespace Eigen
+
+#endif  // EIGEN_THREADED_SPARSE_PRODUCT_H
diff --git a/Eigen/src/SparseCore/TriangularReachSolver.h b/Eigen/src/SparseCore/TriangularReachSolver.h
new file mode 100644
index 0000000..9958f1e
--- /dev/null
+++ b/Eigen/src/SparseCore/TriangularReachSolver.h
@@ -0,0 +1,323 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TRIANGULAR_REACH_SOLVER_H
+#define EIGEN_TRIANGULAR_REACH_SOLVER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// Gilbert-Peierls sparse-rhs triangular solve.
+//
+// Solves T x = b for a column-major sparse triangular T (lower OR upper) with sorted
+// columns, and a sparse right-hand side b. The cost is O(|reach| + flops): only the
+// columns reachable from b's pattern are touched, independent of the dimension.
+//
+// T is the triangular VIEW of a possibly-general stored matrix, so a column may hold
+// entries on BOTH sides of the diagonal; only the entries in the active triangle
+// participate. Everything is therefore direction-aware via a compile-time bool `Upper`:
+//   - the reach follows only in-triangle successors (strictly below the diagonal for
+//     lower, strictly above for upper -- one comparison per stored entry);
+//   - the numeric sweep locates the diagonal within the sorted column (first entry with
+//     index >= j for lower, last with index <= j for upper) and updates only the
+//     in-triangle off-diagonal entries.
+// For a genuinely triangular stored matrix (Eigen's SparseMatrix) the in-triangle
+// entries are the whole column and the diagonal sits at the extreme, so the boundary
+// scans are single-comparison no-ops.
+
+// ===========================================================================
+// Reach: any triangular view, raw CSC storage.
+// ===========================================================================
+
+// Computes reach_{G(T)}(pattern(b)) via a non-recursive depth-first search, emitting
+// the reached columns into xi[top..n) in topological (solve) order and returning top.
+// `mark` (length-n byte array; a 0/1 visited flag needs no more) must be all-zero on
+// entry; every reached node is flagged, and since the reached set is exactly the
+// output, the caller clears those flags again while gathering (no reset needed). `xi`
+// and `pstack` are size-n scratch; the DFS stack occupies xi[0..head] while the output
+// grows down from xi[n), and head < top holds so they never overlap. Only in-triangle
+// stored entries (index > j for lower, index < j for upper) are reach successors; the
+// diagonal and any out-of-triangle entries of the stored matrix are skipped.
+// `innerNonZeroPtr` is the per-column nonzero count: pass it for an uncompressed matrix
+// so column j ends at outerIndexPtr[j]+innerNonZeroPtr[j]; pass nullptr (compressed) to
+// end at outerIndexPtr[j+1].
+template <bool Upper, typename StorageIndex>
+Index triangular_reach(const StorageIndex* outerIndexPtr, const StorageIndex* innerIndexPtr,
+                       const StorageIndex* innerNonZeroPtr, const StorageIndex* bIdx, Index bCount, StorageIndex* xi,
+                       StorageIndex* pstack, uint8_t* mark, Index n) {
+  Index top = n;
+  for (Index r = 0; r < bCount; ++r) {
+    StorageIndex root = bIdx[r];
+    if (mark[root]) continue;
+
+    Index head = 0;
+    xi[0] = root;
+    while (head >= 0) {
+      StorageIndex j = xi[head];
+      Index colBeg = outerIndexPtr[j];
+      Index colEnd = innerNonZeroPtr ? outerIndexPtr[j] + innerNonZeroPtr[j] : outerIndexPtr[j + 1];
+      if (!mark[j]) {
+        mark[j] = 1;
+        pstack[head] = StorageIndex(colBeg);
+      }
+      bool done = true;
+      for (Index p = pstack[head]; p < colEnd; ++p) {
+        StorageIndex i = innerIndexPtr[p];
+        if (Upper ? (i >= j) : (i <= j)) continue;  // out of triangle, or the diagonal
+        if (mark[i]) continue;                      // already visited
+        pstack[head] = StorageIndex(p + 1);
+        xi[++head] = i;  // descend
+        done = false;
+        break;
+      }
+      if (done) {  // no unvisited successor: postorder j
+        xi[--top] = j;
+        --head;
+      }
+    }
+  }
+  return top;
+}
+
+// ===========================================================================
+// Numeric sweep over a precomputed reach.
+// ===========================================================================
+
+// Solves T x = b in place on the dense accumulator x (zero except where b was
+// scattered), touching only the reached columns in the order produced by the reach.
+// Columns are sorted, so the active triangle is a contiguous run: for lower it is the
+// suffix from the first entry with index >= j (the diagonal, then the sub-diagonal
+// off-diagonals); for upper it is the prefix up to the last entry with index <= j (the
+// off-diagonals, then the diagonal). Locating the boundary is O(1) for a genuinely
+// triangular column (the extreme stored entry is already the diagonal); only when a
+// stored column carries out-of-triangle entries (a general matrix seen through a
+// TriangularView) do we binary-search past them, in O(log nnz/col) rather than a
+// linear scan of the wrong-side run.
+// The stored lhs scalar (LhsScalar, read from valuePtr) and the accumulator/rhs scalar
+// (RhsScalar, held in x) are separate: a real factor applied to a complex rhs must
+// accumulate in the complex type. The arithmetic runs in RhsScalar; LhsScalar values
+// promote to it (e.g. double -> complex<double>).
+template <bool Upper, bool UnitDiag, typename StorageIndex, typename LhsScalar, typename RhsScalar>
+void triangular_solve_over_reach(const StorageIndex* outerIndexPtr, const StorageIndex* innerIndexPtr,
+                                 const LhsScalar* valuePtr, const StorageIndex* innerNonZeroPtr, const StorageIndex* xi,
+                                 Index top, Index n, RhsScalar* x) {
+  for (Index k = top; k < n; ++k) {
+    StorageIndex j = xi[k];
+    Index colBeg = outerIndexPtr[j];
+    Index colEnd = innerNonZeroPtr ? outerIndexPtr[j] + innerNonZeroPtr[j] : outerIndexPtr[j + 1];
+    RhsScalar xj;
+    Index offBeg, offEnd;
+    EIGEN_IF_CONSTEXPR (Upper) {
+      // e = one past the last in-triangle entry (index <= j)
+      Index e = colEnd;
+      if (e > colBeg && innerIndexPtr[e - 1] > j)  // wrong-side (below-diagonal) tail: skip it
+        e = std::upper_bound(innerIndexPtr + colBeg, innerIndexPtr + colEnd, j) - innerIndexPtr;
+      bool hasDiag = e > colBeg && innerIndexPtr[e - 1] == j;
+      offBeg = colBeg;
+      offEnd = hasDiag ? e - 1 : e;  // drop the diagonal slot from the update iff it is stored
+      EIGEN_IF_CONSTEXPR (!UnitDiag) {
+        eigen_assert(hasDiag && "sparse triangular solve: missing diagonal");
+        // Missing diagonal is out of contract; match the old AmbiVector path -- divide by 0
+        // for a deterministic inf/NaN, rather than reading valuePtr[e-1] out of bounds.
+        x[j] /= hasDiag ? valuePtr[e - 1] : LhsScalar(0);
+      }
+    } else {
+      // s = first in-triangle entry (index >= j)
+      Index s = colBeg;
+      if (s < colEnd && innerIndexPtr[s] < j)  // wrong-side (above-diagonal) head: skip it
+        s = std::lower_bound(innerIndexPtr + colBeg, innerIndexPtr + colEnd, j) - innerIndexPtr;
+      bool hasDiag = s < colEnd && innerIndexPtr[s] == j;
+      offBeg = hasDiag ? s + 1 : s;  // drop the diagonal slot from the update iff it is stored
+      offEnd = colEnd;
+      EIGEN_IF_CONSTEXPR (!UnitDiag) {
+        eigen_assert(hasDiag && "sparse triangular solve: missing diagonal");
+        x[j] /= hasDiag ? valuePtr[s] : LhsScalar(0);  // missing diagonal -> inf/NaN, not an OOB read
+      }
+    }
+    xj = x[j];
+    for (Index p = offBeg; p < offEnd; ++p) {
+      StorageIndex i = innerIndexPtr[p];
+      x[i] = numext::madd<RhsScalar>(-xj, RhsScalar(valuePtr[p]), x[i]);
+    }
+  }
+}
+
+// ===========================================================================
+// Borrow-a-buffer solve core.
+//
+// The caller owns the scratch and passes it in, so a reused buffer makes repeated
+// solves allocation-free. All buffers are restored on exit, so one setup suffices for
+// many solves.
+// ===========================================================================
+
+// Core: compute reach(pattern(b)) and run the numeric sweep, returning top -- WITHOUT
+// any cleanup. The rhs must ALREADY be scattered into xwork (xwork[bIdx[r]] = value) by
+// the caller; bIdx is the rhs pattern (the reach roots). Pulling the scatter out lets a
+// caller reading the rhs through an iterator scatter as it reads, dropping the separate
+// value array. On return, xi = iwork[top..n) holds the reached columns in topological
+// order, xwork holds their solution values, and mark is set on the reached set; the
+// caller consumes xwork/xi and clears them.
+// Solving T x = b for a column-major, sorted triangular T (lower or upper):
+//   - iwork: >= 2n StorageIndex, carved into xi | pstack (each length n).
+//   - mark:  >= n bytes, all-zero.
+//   - xwork: >= n Scalar, the dense accumulator, zero except b scattered on bIdx.
+// `innerNonZeroPtr` is nullptr for a compressed T, or the per-column nonzero count for
+// an uncompressed T (columns then end at outerIndexPtr[j]+innerNonZeroPtr[j]).
+template <bool Upper, bool UnitDiag, typename StorageIndex, typename LhsScalar, typename RhsScalar>
+Index reach_solve_dense(const StorageIndex* outerIndexPtr, const StorageIndex* innerIndexPtr, const LhsScalar* valuePtr,
+                        const StorageIndex* innerNonZeroPtr, Index n, const StorageIndex* bIdx, Index bCount,
+                        StorageIndex* iwork, uint8_t* mark, RhsScalar* xwork) {
+  Index top =
+      triangular_reach<Upper>(outerIndexPtr, innerIndexPtr, innerNonZeroPtr, bIdx, bCount, iwork, iwork + n, mark, n);
+  triangular_solve_over_reach<Upper, UnitDiag>(outerIndexPtr, innerIndexPtr, valuePtr, innerNonZeroPtr, iwork, top, n,
+                                               xwork);
+  return top;
+}
+
+// ---------------------------------------------------------------------------
+// Iterator-driven path: for a triangular, column-major sparse expression that does NOT
+// expose raw CSC storage (has_compressed_access is false). Columns are read through the
+// expression's evaluator InnerIterator. Because an InnerIterator can't cheaply hold DFS
+// resume state, the reach uses a mark-on-push worklist plus a final sort into
+// topological order (ascending index for lower, descending for upper -- both valid
+// topological orders for the respective solve); the log factor is empirically ~free.
+// ---------------------------------------------------------------------------
+
+// Reach via a mark-on-push worklist that opens one column at a time through
+// InnerIterator. Only in-triangle successors (index > j for lower, index < j for upper)
+// are pushed. Scratch: xi (n, shared stack+output) and mark (n bytes, all-zero in,
+// reach flagged out). Returns top; xi[top..n) is sorted into the topological order for
+// the solve direction.
+template <bool Upper, typename Eval, typename StorageIndex>
+Index triangular_reach_iter(const Eval& mat, const StorageIndex* bIdx, Index bCount, StorageIndex* xi, uint8_t* mark,
+                            Index n) {
+  Index top = n;
+  Index sp = 0;
+  for (Index r = 0; r < bCount; ++r) {
+    StorageIndex root = bIdx[r];
+    if (!mark[root]) {
+      mark[root] = 1;
+      xi[sp++] = root;
+    }
+  }
+  while (sp > 0) {
+    StorageIndex j = xi[--sp];
+    xi[--top] = j;  // collect
+    for (typename Eval::InnerIterator it(mat, j); it; ++it) {
+      StorageIndex i = StorageIndex(it.index());
+      if (Upper ? (i >= j) : (i <= j)) continue;  // out of triangle, or the diagonal
+      if (!mark[i]) {
+        mark[i] = 1;
+        xi[sp++] = i;
+      }
+    }
+  }
+  // descending for upper, ascending for lower (comparator type picked at compile time)
+  using Comp = std::conditional_t<Upper, std::greater<StorageIndex>, std::less<StorageIndex>>;
+  std::sort(xi + top, xi + n, Comp{});
+  return top;
+}
+
+// Numeric sweep over the reach, reading columns through InnerIterator. Direction-aware
+// like the pointer sweep: for lower the leading out-of-triangle entries (index < j) are
+// skipped so the diagonal is the first remaining entry; for upper the diagonal is found
+// by scan and only the entries with index < j are updated.
+template <bool Upper, bool UnitDiag, typename Eval, typename StorageIndex, typename Scalar>
+void triangular_solve_over_reach_iter(const Eval& mat, const StorageIndex* xi, Index top, Index n, Scalar* x) {
+  for (Index k = top; k < n; ++k) {
+    StorageIndex j = xi[k];
+    EIGEN_IF_CONSTEXPR (Upper) {
+      EIGEN_IF_CONSTEXPR (!UnitDiag) {
+        Scalar d(0);  // stays 0 if the diagonal is missing, so singularity surfaces as inf/NaN
+        bool hasDiag = false;
+        for (typename Eval::InnerIterator dt(mat, j); dt; ++dt)
+          if (StorageIndex(dt.index()) == j) {
+            d = dt.value();
+            hasDiag = true;
+          }
+        eigen_assert(hasDiag && "sparse triangular solve: missing diagonal");
+        EIGEN_UNUSED_VARIABLE(hasDiag);
+        x[j] /= d;  // d == 0 when the diagonal is missing -> inf/NaN, consistent with the pointer path
+      }
+      Scalar xj = x[j];
+      for (typename Eval::InnerIterator it(mat, j); it && StorageIndex(it.index()) < j; ++it)
+        x[it.index()] = numext::madd<Scalar>(-xj, it.value(), x[it.index()]);
+    } else {
+      typename Eval::InnerIterator it(mat, j);
+      while (it && StorageIndex(it.index()) < j) ++it;     // skip out-of-triangle (index < j)
+      bool hasDiag = it && StorageIndex(it.index()) == j;  // diagonal is the first in-triangle entry
+      EIGEN_IF_CONSTEXPR (!UnitDiag) {
+        eigen_assert(hasDiag && "sparse triangular solve: missing diagonal");
+        // Missing diagonal -> inf/NaN, not it.value() on an ended/wrong iterator (see pointer path).
+        x[j] /= hasDiag ? it.value() : Scalar(0);
+      }
+      if (hasDiag) ++it;  // step past the stored diagonal (the divisor above, or a unit entry)
+      Scalar xj = x[j];
+      for (; it; ++it) x[it.index()] = numext::madd<Scalar>(-xj, it.value(), x[it.index()]);
+    }
+  }
+}
+
+// Iterator core: reach + numeric, returning top (no cleanup), the iterator counterpart
+// of reach_solve_dense -- xwork must already hold the scattered rhs. Uses the same 2n /
+// n(bytes) / n workspace layout (the pstack half of iwork is left unused), so the two
+// general paths share one workspace contract.
+template <bool Upper, bool UnitDiag, typename LhsType, typename StorageIndex, typename Scalar>
+Index reach_solve_dense_iter(const LhsType& lhs, Index n, const StorageIndex* bIdx, Index bCount, StorageIndex* iwork,
+                             uint8_t* mark, Scalar* xwork) {
+  evaluator<LhsType> mat(lhs);
+  Index top = triangular_reach_iter<Upper>(mat, bIdx, bCount, iwork, mark, n);
+  triangular_solve_over_reach_iter<Upper, UnitDiag>(mat, iwork, top, n, xwork);
+  return top;
+}
+
+// Policy dispatch for the core (returns top): an expression that exposes raw storage
+// takes the pointer + DFS fast path; anything else takes the evaluator + worklist path.
+// Tag dispatch (not if-constexpr) keeps the untaken branch from being instantiated, so
+// outerIndexPtr() is never named on a type that lacks it.
+//
+// CompressedAccessBit is a compile-time capability, not a guarantee the instance is
+// compressed: an uncompressed SparseMatrix keeps per-column gaps addressed via
+// innerNonZeroPtr(), so its columns do NOT run to outerIndexPtr()[j+1]. Passing
+// innerNonZeroPtr() through keeps the raw-pointer path valid either way -- it is nullptr
+// exactly when compressed (columns end at outerIndexPtr[j+1]) and the per-column count
+// otherwise (columns end at outerIndexPtr[j]+innerNonZeroPtr[j]).
+template <bool Upper, bool UnitDiag, typename LhsType, typename StorageIndex, typename Scalar>
+Index reach_solve_dense_dispatch(std::true_type /*compressed*/, const LhsType& lhs, Index n, const StorageIndex* bIdx,
+                                 Index bCount, StorageIndex* iwork, uint8_t* mark, Scalar* xwork) {
+  return reach_solve_dense<Upper, UnitDiag>(lhs.outerIndexPtr(), lhs.innerIndexPtr(), lhs.valuePtr(),
+                                            lhs.innerNonZeroPtr(), n, bIdx, bCount, iwork, mark, xwork);
+}
+template <bool Upper, bool UnitDiag, typename LhsType, typename StorageIndex, typename Scalar>
+Index reach_solve_dense_dispatch(std::false_type /*iterator*/, const LhsType& lhs, Index n, const StorageIndex* bIdx,
+                                 Index bCount, StorageIndex* iwork, uint8_t* mark, Scalar* xwork) {
+  return reach_solve_dense_iter<Upper, UnitDiag>(lhs, n, bIdx, bCount, iwork, mark, xwork);
+}
+
+// Expression core: solve T x = b for a sparse-expression triangular T with the rhs
+// PRE-SCATTERED into xwork (bIdx is its pattern), selecting the pointer or iterator path
+// at compile time; RETURNS top with the solution left in xwork and the reach in
+// iwork[top..n) (see reach_solve_dense). This is what the sparse selector uses -- it
+// scatters the rhs as it reads it and consumes xwork directly, so no bVal/outIdx/outVal.
+template <bool Upper, bool UnitDiag, typename LhsDerived, typename StorageIndex, typename Scalar>
+Index reach_solve_dense(const SparseMatrixBase<LhsDerived>& lhs, const StorageIndex* bIdx, Index bCount,
+                        StorageIndex* iwork, uint8_t* mark, Scalar* xwork) {
+  return reach_solve_dense_dispatch<Upper, UnitDiag>(bool_constant<has_compressed_access<LhsDerived>::value>{},
+                                                     lhs.derived(), lhs.rows(), bIdx, bCount, iwork, mark, xwork);
+}
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TRIANGULAR_REACH_SOLVER_H
diff --git a/Eigen/src/SparseCore/TriangularSolver.h b/Eigen/src/SparseCore/TriangularSolver.h
index b005487..0a58bc9 100644
--- a/Eigen/src/SparseCore/TriangularSolver.h
+++ b/Eigen/src/SparseCore/TriangularSolver.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSETRIANGULARSOLVER_H
 #define EIGEN_SPARSETRIANGULARSOLVER_H
@@ -27,9 +28,9 @@
 // forward substitution, row-major
 template <typename Lhs, typename Rhs, int Mode>
 struct sparse_solve_triangular_selector<Lhs, Rhs, Mode, Lower, RowMajor> {
-  typedef typename Rhs::Scalar Scalar;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  using Scalar = typename Rhs::Scalar;
+  using LhsEval = evaluator<Lhs>;
+  using LhsIterator = typename evaluator<Lhs>::InnerIterator;
   static void run(const Lhs& lhs, Rhs& other) {
     LhsEval lhsEval(lhs);
     for (Index col = 0; col < other.cols(); ++col) {
@@ -43,7 +44,7 @@
           if (lastIndex == i) break;
           tmp = numext::madd<Scalar>(-lastVal, other.coeff(lastIndex, col), tmp);
         }
-        if (Mode & UnitDiag)
+        EIGEN_IF_CONSTEXPR (Mode & UnitDiag)
           other.coeffRef(i, col) = tmp;
         else {
           eigen_assert(lastIndex == i);
@@ -57,9 +58,9 @@
 // backward substitution, row-major
 template <typename Lhs, typename Rhs, int Mode>
 struct sparse_solve_triangular_selector<Lhs, Rhs, Mode, Upper, RowMajor> {
-  typedef typename Rhs::Scalar Scalar;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  using Scalar = typename Rhs::Scalar;
+  using LhsEval = evaluator<Lhs>;
+  using LhsIterator = typename evaluator<Lhs>::InnerIterator;
   static void run(const Lhs& lhs, Rhs& other) {
     LhsEval lhsEval(lhs);
     for (Index col = 0; col < other.cols(); ++col) {
@@ -68,7 +69,7 @@
         Scalar l_ii(0);
         LhsIterator it(lhsEval, i);
         while (it && it.index() < i) ++it;
-        if (!(Mode & UnitDiag)) {
+        EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) {
           eigen_assert(it && it.index() == i);
           l_ii = it.value();
           ++it;
@@ -78,7 +79,7 @@
           tmp = numext::madd<Scalar>(-it.value(), other.coeff(it.index(), col), tmp);
         }
 
-        if (Mode & UnitDiag)
+        EIGEN_IF_CONSTEXPR (Mode & UnitDiag)
           other.coeffRef(i, col) = tmp;
         else
           other.coeffRef(i, col) = tmp / l_ii;
@@ -90,9 +91,9 @@
 // forward substitution, col-major
 template <typename Lhs, typename Rhs, int Mode>
 struct sparse_solve_triangular_selector<Lhs, Rhs, Mode, Lower, ColMajor> {
-  typedef typename Rhs::Scalar Scalar;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  using Scalar = typename Rhs::Scalar;
+  using LhsEval = evaluator<Lhs>;
+  using LhsIterator = typename evaluator<Lhs>::InnerIterator;
   static void run(const Lhs& lhs, Rhs& other) {
     LhsEval lhsEval(lhs);
     for (Index col = 0; col < other.cols(); ++col) {
@@ -102,7 +103,7 @@
         {
           LhsIterator it(lhsEval, i);
           while (it && it.index() < i) ++it;
-          if (!(Mode & UnitDiag)) {
+          EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) {
             eigen_assert(it && it.index() == i);
             tmp /= it.value();
           }
@@ -119,9 +120,9 @@
 // backward substitution, col-major
 template <typename Lhs, typename Rhs, int Mode>
 struct sparse_solve_triangular_selector<Lhs, Rhs, Mode, Upper, ColMajor> {
-  typedef typename Rhs::Scalar Scalar;
-  typedef evaluator<Lhs> LhsEval;
-  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
+  using Scalar = typename Rhs::Scalar;
+  using LhsEval = evaluator<Lhs>;
+  using LhsIterator = typename evaluator<Lhs>::InnerIterator;
   static void run(const Lhs& lhs, Rhs& other) {
     LhsEval lhsEval(lhs);
     for (Index col = 0; col < other.cols(); ++col) {
@@ -129,7 +130,7 @@
         Scalar& tmp = other.coeffRef(i, col);
         if (!numext::is_exactly_zero(tmp))  // optimization when other is actually sparse
         {
-          if (!(Mode & UnitDiag)) {
+          EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) {
             // TODO: replace this with a binary search. make sure the binary search is safe for partially sorted
             // elements
             LhsIterator it(lhsEval, i);
@@ -159,8 +160,8 @@
 
   enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
 
-  typedef std::conditional_t<copy, typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>
-      OtherCopy;
+  using OtherCopy =
+      std::conditional_t<copy, typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>;
   OtherCopy otherCopy(other.derived());
 
   internal::sparse_solve_triangular_selector<ExpressionType, std::remove_reference_t<OtherCopy>, Mode>::run(
@@ -178,67 +179,128 @@
           int UpLo = (Mode & Lower)   ? Lower
                      : (Mode & Upper) ? Upper
                                       : -1,
-          int StorageOrder = int(Lhs::Flags) & (RowMajorBit)>
+          int StorageOrder = int(Lhs::Flags) & RowMajorBit>
 struct sparse_solve_triangular_sparse_selector;
 
-// forward substitution, col-major
+// True when the rhs exposes raw CSC storage with a StorageIndex matching the lhs, so a
+// column's stored index slice can serve as the reach roots directly (no bIdx copy). A
+// SparseVector qualifies too -- it is a single compressed column, handled below via the
+// null-outerIndexPtr guard (its outerIndexPtr() is null since it has no outer array).
+template <typename Lhs, typename Rhs>
+using rhs_matching_slice = std::integral_constant<
+    bool, has_compressed_access<Rhs>::value &&
+              std::is_same<typename traits<Rhs>::StorageIndex, typename traits<Lhs>::StorageIndex>::value>;
+
+// The reach for a column arrives in one of three compile-time-known orders, but the
+// output column must store ascending inner index. An unordered reach (Ordered == false,
+// the pointer/DFS path -- Upper irrelevant) is sorted ascending here; the iterator reach
+// already arrives in solve order, ascending for lower and descending for upper, so it
+// needs no pass of its own -- the descending one is read back to front at insertion.
+template <bool Ordered, bool Upper, typename StorageIndex>
+struct reach_reorder {  // Ordered == false: unordered pointer/DFS reach
+  static void run(StorageIndex* first, StorageIndex* last) { std::sort(first, last); }
+};
+template <bool Upper, typename StorageIndex>
+struct reach_reorder<true, Upper, StorageIndex> {  // iterator reach: already in solve order
+  static void run(StorageIndex* /*first*/, StorageIndex* /*last*/) {}
+};
+
+// Common per-column finish: read the reach xi[top..n) in ascending inner index order,
+// insert reading values from xwork, and clear xwork and mark for the next column.
+// The reach is a structural bound, not a numeric one: a reached coefficient can be
+// exactly zero (a zero rhs entry, or numerical cancellation), so skip exact zeros at
+// insertion. This matches the AmbiVector path, which pruned zeros, and keeps a zero rhs
+// from materializing O(|reach|) stored zeros. xwork and mark are cleared regardless.
+template <bool Ordered, bool Upper, typename Res, typename StorageIndex, typename Scalar>
+void reach_insert_column(Res& res, Index col, StorageIndex* xi, Index top, Index n, Scalar* xwork, uint8_t* mark) {
+  reach_reorder<Ordered, Upper, StorageIndex>::run(xi + top, xi + n);
+  // Only the iterator upper reach is descending; it is read back to front, so k walks
+  // up while the load walks down. Every other order is ascending by this point.
+  constexpr bool Descending = Ordered && Upper;
+  for (Index k = top; k < n; ++k) {
+    StorageIndex j = xi[Descending ? top + n - 1 - k : k];
+    if (!numext::is_exactly_zero(xwork[j])) res.insert(j, col) = xwork[j];
+    xwork[j] = Scalar(0);
+    mark[j] = 0;
+  }
+}
+
+// Column loop, fast path: the rhs matches (see rhs_matching_slice), so each column's
+// stored index slice is the reach root list and the value slice is scattered directly
+// -- no bIdx copy, so iwork is just 2n (xi | pstack).
+template <bool Upper, bool UnitDiag, typename Lhs, typename Rhs, typename Res, typename Scalar,
+          std::enable_if_t<rhs_matching_slice<Lhs, Rhs>::value, int> = 0>
+void reach_solve_columns(const Lhs& lhs, const Rhs& other, Res& res, uint8_t* mark, Scalar* xwork, Index n) {
+  using StorageIndex = typename traits<Lhs>::StorageIndex;
+  Matrix<StorageIndex, Dynamic, 1> iwork(2 * n);  // xi | pstack
+  StorageIndex* xi = iwork.data();
+  for (Index col = 0; col < other.cols(); ++col) {
+    const StorageIndex* outer = other.outerIndexPtr();  // null for a SparseVector (single column)
+    const StorageIndex* nnz = other.innerNonZeroPtr();  // null when compressed
+    Index p = outer ? outer[col] : 0;
+    Index bCount = outer ? (nnz ? Index(nnz[col]) : Index(outer[col + 1]) - p) : other.nonZeros();
+    const StorageIndex* roots = other.innerIndexPtr() + p;  // the column's stored indices
+    const Scalar* vals = other.valuePtr() + p;
+    // Roots are the rhs slice directly (no bIdx copy, so iwork stays 2n). An exact-zero
+    // stored rhs entry is seeded harmlessly -- it propagates zeros and is dropped at
+    // insertion; filtering it here would cost a compacted root buffer (the 3n path).
+    for (Index r = 0; r < bCount; ++r) xwork[roots[r]] = vals[r];
+    Index top = reach_solve_dense<Upper, UnitDiag>(lhs, roots, bCount, xi, mark, xwork);
+    reach_insert_column<!has_compressed_access<Lhs>::value, Upper>(res, col, xi, top, n, xwork, mark);
+  }
+}
+
+// Column loop, fallback: read each column through the InnerIterator, copying indices
+// into the bIdx third of a 3n iwork. For a rhs without raw storage or with a
+// mismatched index type.
+template <bool Upper, bool UnitDiag, typename Lhs, typename Rhs, typename Res, typename Scalar,
+          std::enable_if_t<!rhs_matching_slice<Lhs, Rhs>::value, int> = 0>
+void reach_solve_columns(const Lhs& lhs, const Rhs& other, Res& res, uint8_t* mark, Scalar* xwork, Index n) {
+  using StorageIndex = typename traits<Lhs>::StorageIndex;
+  Matrix<StorageIndex, Dynamic, 1> iwork(3 * n);  // xi | pstack | bIdx
+  StorageIndex* xi = iwork.data();
+  StorageIndex* bIdx = iwork.data() + 2 * n;
+  for (Index col = 0; col < other.cols(); ++col) {
+    Index bCount = 0;
+    for (typename Rhs::InnerIterator it(other, col); it; ++it) {
+      if (numext::is_exactly_zero(it.value())) continue;  // a zero root seeds nothing; xwork stays clear there
+      bIdx[bCount] = StorageIndex(it.index());
+      xwork[it.index()] = it.value();
+      ++bCount;
+    }
+    Index top = reach_solve_dense<Upper, UnitDiag>(lhs, bIdx, bCount, xi, mark, xwork);
+    reach_insert_column<!has_compressed_access<Lhs>::value, Upper>(res, col, xi, top, n, xwork, mark);
+  }
+}
+
+// Reach-based (Gilbert-Peierls) sparse triangular solve, col-major, for lower OR
+// upper. Only the columns reachable from each rhs column's pattern are touched, so
+// the cost is O(|reach| + flops) per column instead of a dense O(n)-per-column sweep
+// (which also pays a coeff(i,i) binary search per row in the upper case). It is
+// the sole col-major sparse-sparse selector, dispatching lower/upper via the UpLo
+// template argument. reach_solve_dense leaves the solution values in
+// xwork and the reached indices in iwork[top..n); reach_solve_columns (slice or
+// fallback, selected on the rhs storage) scatters each column and solves, and
+// reach_insert_column reads the values out and restores mark/xwork. Only mark and
+// xwork need zeroing -- iwork is entirely written before read.
+template <bool Upper, typename Lhs, typename Rhs, int Mode>
+void run_sparse_reach_triangular_solve(const Lhs& lhs, Rhs& other) {
+  using Scalar = typename Rhs::Scalar;
+  Index n = lhs.rows();
+  Matrix<uint8_t, Dynamic, 1> mark = Matrix<uint8_t, Dynamic, 1>::Zero(n);
+  Matrix<Scalar, Dynamic, 1> xwork = Matrix<Scalar, Dynamic, 1>::Zero(n);
+  Rhs res(other.rows(), other.cols());
+  res.reserve(other.nonZeros());
+  reach_solve_columns<Upper, bool(Mode & UnitDiag)>(lhs, other, res, mark.data(), xwork.data(), n);
+  res.finalize();
+  other = res.markAsRValue();
+}
+
+// forward and backward substitution, col-major
 template <typename Lhs, typename Rhs, int Mode, int UpLo>
 struct sparse_solve_triangular_sparse_selector<Lhs, Rhs, Mode, UpLo, ColMajor> {
-  typedef typename Rhs::Scalar Scalar;
-  typedef typename promote_index_type<typename traits<Lhs>::StorageIndex, typename traits<Rhs>::StorageIndex>::type
-      StorageIndex;
   static void run(const Lhs& lhs, Rhs& other) {
-    const bool IsLower = (UpLo == Lower);
-    AmbiVector<Scalar, StorageIndex> tempVector(other.rows() * 2);
-    tempVector.setBounds(0, other.rows());
-
-    Rhs res(other.rows(), other.cols());
-    res.reserve(other.nonZeros());
-
-    for (Index col = 0; col < other.cols(); ++col) {
-      // FIXME: estimate the number of non-zeros per column for better allocation.
-      tempVector.init(.99 /*float(other.col(col).nonZeros())/float(other.rows())*/);
-      tempVector.setZero();
-      tempVector.restart();
-      for (typename Rhs::InnerIterator rhsIt(other, col); rhsIt; ++rhsIt) {
-        tempVector.coeffRef(rhsIt.index()) = rhsIt.value();
-      }
-
-      for (Index i = IsLower ? 0 : lhs.cols() - 1; IsLower ? i < lhs.cols() : i >= 0; i += IsLower ? 1 : -1) {
-        tempVector.restart();
-        Scalar& ci = tempVector.coeffRef(i);
-        if (!numext::is_exactly_zero(ci)) {
-          // find
-          typename Lhs::InnerIterator it(lhs, i);
-          if (!(Mode & UnitDiag)) {
-            if (IsLower) {
-              eigen_assert(it.index() == i);
-              ci /= it.value();
-            } else
-              ci /= lhs.coeff(i, i);
-          }
-          tempVector.restart();
-          if (IsLower) {
-            if (it.index() == i) ++it;
-            for (; it; ++it) {
-              tempVector.coeffRef(it.index()) = numext::madd<Scalar>(-ci, it.value(), tempVector.coeffRef(it.index()));
-            }
-          } else {
-            for (; it && it.index() < i; ++it) {
-              tempVector.coeffRef(it.index()) = numext::madd<Scalar>(-ci, it.value(), tempVector.coeffRef(it.index()));
-            }
-          }
-        }
-      }
-
-      // FIXME: compute a reference value to filter zeros.
-      for (typename AmbiVector<Scalar, StorageIndex>::Iterator it(tempVector /*,1e-12*/); it; ++it) {
-        // FIXME: use insertBack for better performance.
-        res.insert(it.index(), col) = it.value();
-      }
-    }
-    res.finalize();
-    other = res.markAsRValue();
+    run_sparse_reach_triangular_solve<UpLo == Upper, Lhs, Rhs, Mode>(lhs, other);
   }
 };
 
@@ -251,17 +313,8 @@
   eigen_assert(derived().cols() == derived().rows() && derived().cols() == other.rows());
   eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper | Lower)));
 
-  //   enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit };
-
-  //   typedef std::conditional_t<copy,
-  //     typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&> OtherCopy;
-  //   OtherCopy otherCopy(other.derived());
-
   internal::sparse_solve_triangular_sparse_selector<ExpressionType, OtherDerived, Mode>::run(
       derived().nestedExpression(), other.derived());
-
-  //   if (copy)
-  //     other = otherCopy;
 }
 #endif
 
diff --git a/Eigen/src/SparseLU/InternalHeaderCheck.h b/Eigen/src/SparseLU/InternalHeaderCheck.h
index 78ebfcc..e8334bb 100644
--- a/Eigen/src/SparseLU/InternalHeaderCheck.h
+++ b/Eigen/src/SparseLU/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SPARSELU_MODULE_H
 #error "Please include Eigen/SparseLU instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index 9b12f49..f0db58d 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_LU_H
 #define EIGEN_SPARSE_LU_H
@@ -26,18 +27,18 @@
 template <bool Conjugate, class SparseLUType>
 class SparseLUTransposeView : public SparseSolverBase<SparseLUTransposeView<Conjugate, SparseLUType>> {
  protected:
-  typedef SparseSolverBase<SparseLUTransposeView<Conjugate, SparseLUType>> APIBase;
+  using APIBase = SparseSolverBase<SparseLUTransposeView<Conjugate, SparseLUType>>;
   using APIBase::m_isInitialized;
 
  public:
-  typedef typename SparseLUType::Scalar Scalar;
-  typedef typename SparseLUType::StorageIndex StorageIndex;
-  typedef typename SparseLUType::MatrixType MatrixType;
-  typedef typename SparseLUType::OrderingType OrderingType;
+  using Scalar = typename SparseLUType::Scalar;
+  using StorageIndex = typename SparseLUType::StorageIndex;
+  using MatrixType = typename SparseLUType::MatrixType;
+  using OrderingType = typename SparseLUType::OrderingType;
 
   enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };
 
-  SparseLUTransposeView() : APIBase(), m_sparseLU(NULL) {}
+  SparseLUTransposeView() = default;
   SparseLUTransposeView(const SparseLUTransposeView& view) : APIBase() {
     this->m_sparseLU = view.m_sparseLU;
     this->m_isInitialized = view.m_isInitialized;
@@ -69,8 +70,8 @@
   inline Index cols() const { return m_sparseLU->cols(); }
 
  private:
-  SparseLUType* m_sparseLU;
-  SparseLUTransposeView& operator=(const SparseLUTransposeView&);
+  SparseLUType* m_sparseLU = nullptr;
+  SparseLUTransposeView& operator=(const SparseLUTransposeView&) = delete;
 };
 
 /** \ingroup SparseLU_Module
@@ -136,10 +137,10 @@
  * \note Unlike the initial SuperLU implementation, there is no step to equilibrate the matrix.
  * For badly scaled matrices, this step can be useful to reduce the pivoting during factorization.
  * If this is the case for your matrices, you can try the basic scaling method at
- *  "unsupported/Eigen/src/IterativeSolvers/Scaling.h"
+ *  "Eigen/src/IterativeLinearSolvers/Scaling.h"
  *
  * \tparam MatrixType_ The type of the sparse matrix. It must be a column-major SparseMatrix<>
- * \tparam OrderingType_ The ordering method to use, either AMD, COLAMD or METIS. Default is COLMAD
+ * \tparam OrderingType_ The ordering method to use, either AMD, COLAMD or METIS. Default is COLAMD
  *
  * \implsparsesolverconcept
  *
@@ -150,23 +151,23 @@
 class SparseLU : public SparseSolverBase<SparseLU<MatrixType_, OrderingType_>>,
                  public internal::SparseLUImpl<typename MatrixType_::Scalar, typename MatrixType_::StorageIndex> {
  protected:
-  typedef SparseSolverBase<SparseLU<MatrixType_, OrderingType_>> APIBase;
+  using APIBase = SparseSolverBase<SparseLU<MatrixType_, OrderingType_>>;
   using APIBase::m_isInitialized;
 
  public:
   using APIBase::_solve_impl;
 
-  typedef MatrixType_ MatrixType;
-  typedef OrderingType_ OrderingType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> NCMatrix;
-  typedef internal::MappedSuperNodalMatrix<Scalar, StorageIndex> SCMatrix;
-  typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
-  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
-  typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
-  typedef internal::SparseLUImpl<Scalar, StorageIndex> Base;
+  using MatrixType = MatrixType_;
+  using OrderingType = OrderingType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using NCMatrix = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using SCMatrix = internal::MappedSuperNodalMatrix<Scalar, StorageIndex>;
+  using ScalarVector = Matrix<Scalar, Dynamic, 1>;
+  using IndexVector = Matrix<StorageIndex, Dynamic, 1>;
+  using PermutationType = PermutationMatrix<Dynamic, Dynamic, StorageIndex>;
+  using Base = internal::SparseLUImpl<Scalar, StorageIndex>;
 
   enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };
 
@@ -293,7 +294,7 @@
   inline const PermutationType& rowsPermutation() const { return m_perm_r; }
   /** \brief Give the column matrix permutation.
    *
-   * \returns a reference to the column matrix permutation\f$ P_c^T \f$ such that \f$P_r A P_c^T = L U\f$
+   * \returns a reference to the column matrix permutation \f$ P_c \f$ such that \f$P_r A P_c^T = L U\f$
    * \sa rowsPermutation()
    */
   inline const PermutationType& colsPermutation() const { return m_perm_c; }
@@ -305,7 +306,7 @@
    *
    * \returns the solution X of \f$ A X = B \f$ using the current decomposition of A.
    *
-   * \warning the destination matrix X in X = this->solve(B) must be colmun-major.
+   * \warning the destination matrix X in X = this->solve(B) must be column-major.
    *
    * \sa compute()
    */
@@ -503,8 +504,7 @@
   Index m_nnzL, m_nnzU;          // Nonzeros in L and U factors
   Index m_detPermR, m_detPermC;  // Determinants of the permutation matrices
  private:
-  // Disable copy constructor
-  SparseLU(const SparseLU&);
+  SparseLU(const SparseLU&) = delete;
 };  // End class SparseLU
 
 // Functions needed by the analysis phase
@@ -520,13 +520,13 @@
  *
  * It is possible to call compute() instead of analyzePattern() + factorize().
  *
- * If the matrix is row-major this function will do an heavy copy.
+ * If the matrix is row-major this function will do a heavy copy.
  *
  * \sa factorize(), compute()
  */
 template <typename MatrixType, typename OrderingType>
 void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat) {
-  // TODO  It is possible as in SuperLU to compute row and columns scaling vectors to equilibrate the matrix mat.
+  // TODO  It is possible as in SuperLU to compute row and column scaling vectors to equilibrate the matrix mat.
 
   // Firstly, copy the whole input matrix.
   m_mat = mat;
@@ -535,19 +535,21 @@
   OrderingType ord;
   ord(m_mat, m_perm_c);
 
-  // Apply the permutation to the column of the input  matrix
+  // Apply the permutation to the column of the input matrix
   if (m_perm_c.size()) {
-    m_mat.uncompress();  // NOTE: The effect of this command is only to create the InnerNonzeros pointers. FIXME : This
-                         // vector is filled but not subsequently used.
-    // Then, permute only the column pointers
+    // Switch to uncompressed mode so innerNonZeroPtr() exists and can be
+    // permuted consistently with outerIndexPtr().
+    // Downstream sparse traversals may also rely on these per-column counts
+    // while m_mat remains uncompressed.
+    m_mat.uncompress();
+    // A compressed column-major input already exposes valid column pointers.
+    // Otherwise snapshot the internal column-major structure before permuting in place.
+    const bool useInputOuterIndex = !MatrixType::IsRowMajor && mat.isCompressed();
     ei_declare_aligned_stack_constructed_variable(
-        StorageIndex, outerIndexPtr, mat.cols() + 1,
-        mat.isCompressed() ? const_cast<StorageIndex*>(mat.outerIndexPtr()) : 0);
-
-    // If the input matrix 'mat' is uncompressed, then the outer-indices do not match the ones of m_mat, and a copy is
-    // thus needed.
-    if (!mat.isCompressed())
-      IndexVector::Map(outerIndexPtr, mat.cols() + 1) = IndexVector::Map(m_mat.outerIndexPtr(), mat.cols() + 1);
+        StorageIndex, outerIndexPtr, m_mat.cols() + 1,
+        useInputOuterIndex ? const_cast<StorageIndex*>(mat.outerIndexPtr()) : 0);
+    if (!useInputOuterIndex)
+      IndexVector::Map(outerIndexPtr, m_mat.cols() + 1) = IndexVector::Map(m_mat.outerIndexPtr(), m_mat.cols() + 1);
 
     // Apply the permutation and compute the nnz per column.
     for (Index i = 0; i < mat.cols(); i++) {
@@ -615,24 +617,27 @@
 
   m_isInitialized = true;
 
+  // Reset state from any prior factorize() so info() and lastErrorMessage()
+  // describe this call's outcome, not the previous matrix's.
+  m_info = Success;
+  m_lastError.clear();
+
   // Apply the column permutation computed in analyzepattern()
   m_mat = matrix;
   if (m_perm_c.size()) {
-    m_mat.uncompress();  // NOTE: The effect of this command is only to create the InnerNonzeros pointers.
-    // Then, permute only the column pointers
-    const StorageIndex* outerIndexPtr;
-    if (matrix.isCompressed())
-      outerIndexPtr = matrix.outerIndexPtr();
-    else {
-      StorageIndex* outerIndexPtr_t = new StorageIndex[matrix.cols() + 1];
-      for (Index i = 0; i <= matrix.cols(); i++) outerIndexPtr_t[i] = m_mat.outerIndexPtr()[i];
-      outerIndexPtr = outerIndexPtr_t;
-    }
+    // Switch to uncompressed mode so innerNonZeroPtr() exists and can be
+    // permuted consistently with outerIndexPtr().
+    m_mat.uncompress();
+    const bool useInputOuterIndex = !MatrixType::IsRowMajor && matrix.isCompressed();
+    ei_declare_aligned_stack_constructed_variable(
+        StorageIndex, outerIndexPtr, m_mat.cols() + 1,
+        useInputOuterIndex ? const_cast<StorageIndex*>(matrix.outerIndexPtr()) : 0);
+    if (!useInputOuterIndex)
+      IndexVector::Map(outerIndexPtr, m_mat.cols() + 1) = IndexVector::Map(m_mat.outerIndexPtr(), m_mat.cols() + 1);
     for (Index i = 0; i < matrix.cols(); i++) {
       m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
       m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i + 1] - outerIndexPtr[i];
     }
-    if (!matrix.isCompressed()) delete[] outerIndexPtr;
   } else {  // FIXME This should not be needed if the empty permutation is handled transparently
     m_perm_c.resize(matrix.cols());
     for (StorageIndex i = 0; i < matrix.cols(); ++i) m_perm_c.indices()(i) = i;
@@ -762,7 +767,7 @@
       }
 
       // Form the L-segment
-      // Return O if success, i > 0 if U(i, i) is exactly zero.
+      // Return 0 if success, i > 0 if U(i, i) is exactly zero.
       info = Base::pivotL(jj, m_diagpivotthresh, m_perm_r.indices(), iperm_c.indices(), pivrow, m_glu);
       if (info) {
         m_lastError = "THE MATRIX IS STRUCTURALLY SINGULAR";
@@ -777,11 +782,6 @@
         return;
       }
 
-      // Update the determinant of the row permutation matrix
-      // FIXME: the following test is not correct; it should account for iperm_c, and pivrow is not
-      // directly the row pivot.
-      if (pivrow != jj) m_detPermR = -m_detPermR;
-
       // Prune columns (0:jj-1) using column jj
       Base::pruneL(jj, m_perm_r.indices(), pivrow, nseg, segrep, repfnz_k, xprune, m_glu);
 
@@ -814,7 +814,7 @@
 
 template <typename MappedSupernodalType>
 struct SparseLUMatrixLReturnType : internal::no_assignment_operator {
-  typedef typename MappedSupernodalType::Scalar Scalar;
+  using Scalar = typename MappedSupernodalType::Scalar;
   explicit SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m_mapL(mapL) {}
   Index rows() const { return m_mapL.rows(); }
   Index cols() const { return m_mapL.cols(); }
@@ -857,7 +857,7 @@
 
 template <typename MatrixLType, typename MatrixUType>
 struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
-  typedef typename MatrixLType::Scalar Scalar;
+  using Scalar = typename MatrixLType::Scalar;
   SparseLUMatrixUReturnType(const MatrixLType& mapL, const MatrixUType& mapU) : m_mapL(mapL), m_mapU(mapU) {}
   Index rows() const { return m_mapL.rows(); }
   Index cols() const { return m_mapL.cols(); }
@@ -924,7 +924,7 @@
         Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<>> A(&(m_mapL.valuePtr()[luptr]), nsupc,
                                                                                   nsupc, OuterStride<>(lda));
         typename Dest::RowsBlockXpr U = X.derived().middleRows(fsupc, nsupc);
-        if (Conjugate)
+        EIGEN_IF_CONSTEXPR (Conjugate)
           U = A.adjoint().template triangularView<Lower>().solve(U);
         else
           U = A.transpose().template triangularView<Lower>().solve(U);
diff --git a/Eigen/src/SparseLU/SparseLUImpl.h b/Eigen/src/SparseLU/SparseLUImpl.h
index 96b9c65..1a89569 100644
--- a/Eigen/src/SparseLU/SparseLUImpl.h
+++ b/Eigen/src/SparseLU/SparseLUImpl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 #ifndef SPARSELU_IMPL_H
 #define SPARSELU_IMPL_H
 
@@ -22,15 +23,15 @@
 template <typename Scalar, typename StorageIndex>
 class SparseLUImpl {
  public:
-  typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
-  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
-  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> ScalarMatrix;
-  typedef Map<ScalarMatrix, 0, OuterStride<> > MappedMatrixBlock;
-  typedef typename ScalarVector::RealScalar RealScalar;
-  typedef Ref<Matrix<Scalar, Dynamic, 1> > BlockScalarVector;
-  typedef Ref<Matrix<StorageIndex, Dynamic, 1> > BlockIndexVector;
-  typedef LU_GlobalLU_t<IndexVector, ScalarVector> GlobalLU_t;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
+  using ScalarVector = Matrix<Scalar, Dynamic, 1>;
+  using IndexVector = Matrix<StorageIndex, Dynamic, 1>;
+  using ScalarMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using MappedMatrixBlock = Map<ScalarMatrix, 0, OuterStride<>>;
+  using RealScalar = typename ScalarVector::RealScalar;
+  using BlockScalarVector = Ref<Matrix<Scalar, Dynamic, 1>>;
+  using BlockIndexVector = Ref<Matrix<StorageIndex, Dynamic, 1>>;
+  using GlobalLU_t = LU_GlobalLU_t<IndexVector, ScalarVector>;
+  using MatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
 
  protected:
   template <typename VectorType>
diff --git a/Eigen/src/SparseLU/SparseLU_Memory.h b/Eigen/src/SparseLU/SparseLU_Memory.h
index 7acfa5c..5fc5338 100644
--- a/Eigen/src/SparseLU/SparseLU_Memory.h
+++ b/Eigen/src/SparseLU/SparseLU_Memory.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -41,11 +42,6 @@
 enum { emptyIdxLU = -1 };
 inline Index LUnumTempV(Index& m, Index& w, Index& t, Index& b) { return (std::max)(m, (t + b) * w); }
 
-template <typename Scalar>
-inline Index LUTempSpace(Index& m, Index& w) {
-  return (2 * w + 4 + LUNoMarker) * m * sizeof(Index) + (w + 1) * m * sizeof(Scalar);
-}
-
 /**
  * Expand the existing storage to accommodate more fill-ins
  * \param vec Valid pointer to the vector to allocate or expand
@@ -88,7 +84,7 @@
       return -1;
     }
     if (keep_prev) {
-      // In this case, the memory length should not not be reduced
+      // In this case, the memory length should not be reduced
       return new_len;
     } else {
       // Reduce the size and increase again
diff --git a/Eigen/src/SparseLU/SparseLU_Structs.h b/Eigen/src/SparseLU/SparseLU_Structs.h
index 85ba884..5ac6261 100644
--- a/Eigen/src/SparseLU/SparseLU_Structs.h
+++ b/Eigen/src/SparseLU/SparseLU_Structs.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
  * NOTE: This file comes from a partly modified version of files slu_[s,d,c,z]defs.h
@@ -74,11 +75,11 @@
 namespace Eigen {
 namespace internal {
 
-enum MemType { LUSUP, UCOL, LSUB, USUB, LLVL, ULVL };
+enum MemType { LUSUP, UCOL, LSUB, USUB };
 
 template <typename IndexVector, typename ScalarVector>
 struct LU_GlobalLU_t {
-  typedef typename IndexVector::Scalar StorageIndex;
+  using StorageIndex = typename IndexVector::Scalar;
   IndexVector xsup;    // First supernode column ... xsup(s) points to the beginning of the s-th supernode
   IndexVector supno;   // Supernode number corresponding to this column (column to supernode mapping)
   ScalarVector lusup;  // nonzero values of L ordered by columns
diff --git a/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h b/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
index 98b7348..be92743 100644
--- a/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
+++ b/Eigen/src/SparseLU/SparseLU_SupernodalMatrix.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
 #define EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
@@ -20,7 +21,7 @@
 /** \ingroup SparseLU_Module
  * \brief a class to manipulate the L supernodal factor from the SparseLU factorization
  *
- * This class  contain the data to easily store
+ * This class contains the data to easily store
  * and manipulate the supernodes during the factorization and solution phase of Sparse LU.
  * Only the lower triangular matrix has supernodes.
  *
@@ -31,10 +32,10 @@
 template <typename Scalar_, typename StorageIndex_>
 class MappedSuperNodalMatrix {
  public:
-  typedef Scalar_ Scalar;
-  typedef StorageIndex_ StorageIndex;
-  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
-  typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
+  using Scalar = Scalar_;
+  using StorageIndex = StorageIndex_;
+  using IndexVector = Matrix<StorageIndex, Dynamic, 1>;
+  using ScalarVector = Matrix<Scalar, Dynamic, 1>;
 
  public:
   MappedSuperNodalMatrix() {}
@@ -43,11 +44,10 @@
     setInfos(m, n, nzval, nzval_colptr, rowind, rowind_colptr, col_to_sup, sup_to_col);
   }
 
-  ~MappedSuperNodalMatrix() {}
   /**
    * Set appropriate pointers for the lower triangular supernodal matrix
    * These infos are available at the end of the numerical factorization
-   * FIXME This class will be modified such that it can be use in the course
+   * FIXME This class will be modified such that it can be used in the course
    * of the factorization.
    */
   void setInfos(Index m, Index n, ScalarVector& nzval, IndexVector& nzval_colptr, IndexVector& rowind,
@@ -96,7 +96,7 @@
   const StorageIndex* rowIndex() const { return m_rowind; }
 
   /**
-   * Return the location in \em rowvaluePtr() which starts each column
+   * Return the location in \em rowIndex() which starts each column
    */
   StorageIndex* rowIndexPtr() { return m_rowind_colptr; }
 
@@ -194,8 +194,6 @@
 template <typename Dest>
 void MappedSuperNodalMatrix<Scalar, Index_>::solveInPlace(MatrixBase<Dest>& X) const {
   /* Explicit type conversion as the Index type of MatrixBase<Dest> may be wider than Index */
-  //    eigen_assert(X.rows() <= NumTraits<Index>::highest());
-  //    eigen_assert(X.cols() <= NumTraits<Index>::highest());
   Index n = int(X.rows());
   Index nrhs = Index(X.cols());
   const Scalar* Lval = valuePtr();                                           // Nonzero values
@@ -292,15 +290,15 @@
       Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> > A(&(Lval[luptr + nsupc]), nrow, nsupc,
                                                                                  OuterStride<>(lda));
       typename Dest::RowsBlockXpr U = X.derived().middleRows(fsupc, nsupc);
-      if (Conjugate)
-        U = U - A.adjoint() * work.topRows(nrow);
+      EIGEN_IF_CONSTEXPR (Conjugate)
+        U.noalias() -= A.adjoint() * work.topRows(nrow);
       else
-        U = U - A.transpose() * work.topRows(nrow);
+        U.noalias() -= A.transpose() * work.topRows(nrow);
 
       // Triangular solve (of transposed diagonal block)
       new (&A) Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> >(&(Lval[luptr]), nsupc, nsupc,
                                                                                         OuterStride<>(lda));
-      if (Conjugate)
+      EIGEN_IF_CONSTEXPR (Conjugate)
         U = A.adjoint().template triangularView<UnitUpper>().solve(U);
       else
         U = A.transpose().template triangularView<UnitUpper>().solve(U);
@@ -312,4 +310,4 @@
 
 }  // end namespace Eigen
 
-#endif  // EIGEN_SPARSELU_MATRIX_H
+#endif  // EIGEN_SPARSELU_SUPERNODAL_MATRIX_H
diff --git a/Eigen/src/SparseLU/SparseLU_Utils.h b/Eigen/src/SparseLU/SparseLU_Utils.h
index ef087cd..6177849 100644
--- a/Eigen/src/SparseLU/SparseLU_Utils.h
+++ b/Eigen/src/SparseLU/SparseLU_Utils.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSELU_UTILS_H
 #define EIGEN_SPARSELU_UTILS_H
@@ -22,8 +23,8 @@
 template <typename Scalar, typename StorageIndex>
 void SparseLUImpl<Scalar, StorageIndex>::countnz(const Index n, Index& nnzL, Index& nnzU, GlobalLU_t& glu) {
   nnzL = 0;
-  nnzU = (glu.xusub)(n);
-  Index nsuper = (glu.supno)(n);
+  nnzU = glu.xusub(n);
+  Index nsuper = glu.supno(n);
   Index jlen;
   Index i, j, fsupc;
   if (n <= 0) return;
@@ -52,7 +53,7 @@
   Index fsupc, i, j, k, jstart;
 
   StorageIndex nextl = 0;
-  Index nsuper = (glu.supno)(n);
+  Index nsuper = glu.supno(n);
 
   // For each supernode
   for (i = 0; i <= nsuper; i++) {
diff --git a/Eigen/src/SparseLU/SparseLU_column_bmod.h b/Eigen/src/SparseLU/SparseLU_column_bmod.h
index 014ffc2..8310cde 100644
--- a/Eigen/src/SparseLU/SparseLU_column_bmod.h
+++ b/Eigen/src/SparseLU/SparseLU_column_bmod.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -65,7 +66,7 @@
    * nsupr = number of rows in a supernode
    * luptr = location of supernodal LU-block in storage
    * kfnz = first nonz in the k-th supernodal segment
-   * no_zeros = no lf leading zeros in a supernodal U-segment
+   * no_zeros = no of leading zeros in a supernodal U-segment
    */
 
   jsupno = glu.supno(jcol);
diff --git a/Eigen/src/SparseLU/SparseLU_column_dfs.h b/Eigen/src/SparseLU/SparseLU_column_dfs.h
index 71a9ff4..1e88da7 100644
--- a/Eigen/src/SparseLU/SparseLU_column_dfs.h
+++ b/Eigen/src/SparseLU/SparseLU_column_dfs.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -41,8 +42,8 @@
 
 template <typename IndexVector, typename ScalarVector>
 struct column_dfs_traits : no_assignment_operator {
-  typedef typename ScalarVector::Scalar Scalar;
-  typedef typename IndexVector::Scalar StorageIndex;
+  using Scalar = typename ScalarVector::Scalar;
+  using StorageIndex = typename IndexVector::Scalar;
   column_dfs_traits(Index jcol, Index& jsuper, typename SparseLUImpl<Scalar, StorageIndex>::GlobalLU_t& glu,
                     SparseLUImpl<Scalar, StorageIndex>& luImpl)
       : m_jcol(jcol), m_jsuper_ref(jsuper), m_glu(glu), m_luImpl(luImpl) {}
@@ -125,7 +126,7 @@
     StorageIndex jm1ptr = glu.xlsub(jcolm1);
 
     // Use supernodes of type T2 : see SuperLU paper
-    if ((nextl - jptr != jptr - jm1ptr - 1)) jsuper = emptyIdxLU;
+    if (nextl - jptr != jptr - jm1ptr - 1) jsuper = emptyIdxLU;
 
     // Make sure the number of columns in a supernode doesn't
     // exceed threshold
@@ -136,8 +137,8 @@
      * the subscript set of the first and last columns of
      * a supernode. (first for num values, last for pruning)
      */
-    if (jsuper == emptyIdxLU) {    // starts a new supernode
-      if ((fsupc < jcolm1 - 1)) {  // >= 3 columns in nsuper
+    if (jsuper == emptyIdxLU) {  // starts a new supernode
+      if (fsupc < jcolm1 - 1) {  // >= 3 columns in nsuper
         StorageIndex ito = glu.xlsub(fsupc + 1);
         glu.xlsub(jcolm1) = ito;
         StorageIndex istop = ito + jptr - jm1ptr;
diff --git a/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h b/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
index 12e7650..e2fc0e6 100644
--- a/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
+++ b/Eigen/src/SparseLU/SparseLU_copy_to_ucol.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 /*
 
  * NOTE: This file is the modified version of [s,d,c,z]copy_to_ucol.c file in SuperLU
diff --git a/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h b/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
index 86080e4..cfa4d9f 100644
--- a/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
+++ b/Eigen/src/SparseLU/SparseLU_heap_relax_snode.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /* This file is a modified version of heap_relax_snode.c file in SuperLU
  * -- SuperLU routine (version 3.0) --
@@ -48,7 +49,7 @@
 template <typename Scalar, typename StorageIndex>
 void SparseLUImpl<Scalar, StorageIndex>::heap_relax_snode(const Index n, IndexVector& et, const Index relax_columns,
                                                           IndexVector& descendants, IndexVector& relax_end) {
-  // The etree may not be postordered, but its heap ordered
+  // The etree may not be postordered, but it's heap ordered
   IndexVector post;
   internal::treePostorder(StorageIndex(n), et, post);  // Post order etree
   IndexVector inv_post(n + 1);
diff --git a/Eigen/src/SparseLU/SparseLU_kernel_bmod.h b/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
index 54bda0c..0457b00 100644
--- a/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
+++ b/Eigen/src/SparseLU/SparseLU_kernel_bmod.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef SPARSELU_KERNEL_BMOD_H
 #define SPARSELU_KERNEL_BMOD_H
@@ -22,7 +23,7 @@
   /** \internal
    * \brief Performs numeric block updates from a given supernode to a single column
    *
-   * \param segsize Size of the segment (and blocks ) to use for updates
+   * \param segsize Size of the segment (and blocks) to use for updates
    * \param[in,out] dense Packed values of the original matrix
    * \param tempv temporary vector to use for updates
    * \param lusup array containing the supernodes
@@ -44,10 +45,10 @@
                                                                  ScalarVector& tempv, ScalarVector& lusup, Index& luptr,
                                                                  const Index lda, const Index nrow, IndexVector& lsub,
                                                                  const Index lptr, const Index no_zeros) {
-  typedef typename ScalarVector::Scalar Scalar;
+  using Scalar = typename ScalarVector::Scalar;
   // First, copy U[*,j] segment from dense(*) to tempv(*)
   // The result of triangular solve is in tempv[*];
-  // The result of matric-vector update is in dense[*]
+  // The result of matrix-vector update is in dense[*]
   Index isub = lptr + no_zeros;
   Index i;
   Index irow;
@@ -86,8 +87,8 @@
   }
 
   // Scatter l into SPA dense[]
-  for (i = 0; i < nrow; i++) {
-    irow = lsub(isub++);
+  for (i = sparse_scatter_sub_packets(dense.data(), lsub.data() + isub, l); i < nrow; i++) {
+    irow = lsub(isub + i);
     dense(irow) -= l(i);
   }
 }
@@ -105,8 +106,8 @@
                                               ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr,
                                               const Index lda, const Index nrow, IndexVector& lsub, const Index lptr,
                                               const Index no_zeros) {
-  typedef typename ScalarVector::Scalar Scalar;
-  typedef typename IndexVector::Scalar StorageIndex;
+  using Scalar = typename ScalarVector::Scalar;
+  using StorageIndex = typename IndexVector::Scalar;
   Scalar f = dense(lsub(lptr + no_zeros));
   luptr += lda * no_zeros + no_zeros + 1;
   const Scalar* a(lusup.data() + luptr);
diff --git a/Eigen/src/SparseLU/SparseLU_panel_bmod.h b/Eigen/src/SparseLU/SparseLU_panel_bmod.h
index 505d982..676ee86 100644
--- a/Eigen/src/SparseLU/SparseLU_panel_bmod.h
+++ b/Eigen/src/SparseLU/SparseLU_panel_bmod.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -118,7 +119,7 @@
 
         Index isub = lptr + no_zeros;
         Index off = u_rows - segsize;
-        for (Index i = 0; i < off; i++) U(i, u_col) = 0;
+        for (Index i = 0; i < off; i++) U(i, u_col) = Scalar(0);
         for (Index i = 0; i < segsize; i++) {
           Index irow = glu.lsub(isub);
           U(i + off, u_col) = dense_col(irow);
@@ -163,14 +164,14 @@
         for (Index i = 0; i < segsize; i++) {
           Index irow = glu.lsub(isub++);
           dense_col(irow) = U.coeff(i + off, u_col);
-          U.coeffRef(i + off, u_col) = 0;
+          U.coeffRef(i + off, u_col) = Scalar(0);
         }
 
         // Scatter l into SPA dense[]
         for (Index i = 0; i < nrow; i++) {
           Index irow = glu.lsub(isub++);
           dense_col(irow) -= L.coeff(i, u_col);
-          L.coeffRef(i, u_col) = 0;
+          L.coeffRef(i, u_col) = Scalar(0);
         }
         u_col++;
       }
@@ -190,7 +191,7 @@
 
         Index lda = glu.xlusup(fsupc + 1) - glu.xlusup(fsupc);  // nsupr
 
-        // Perform a trianglar solve and block update,
+        // Perform a triangular solve and block update,
         // then scatter the result of sup-col update to dense[]
         no_zeros = kfnz - fsupc;
         if (segsize == 1)
diff --git a/Eigen/src/SparseLU/SparseLU_panel_dfs.h b/Eigen/src/SparseLU/SparseLU_panel_dfs.h
index 4412396..be3035b 100644
--- a/Eigen/src/SparseLU/SparseLU_panel_dfs.h
+++ b/Eigen/src/SparseLU/SparseLU_panel_dfs.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -39,7 +40,7 @@
 
 template <typename IndexVector>
 struct panel_dfs_traits {
-  typedef typename IndexVector::Scalar StorageIndex;
+  using StorageIndex = typename IndexVector::Scalar;
   panel_dfs_traits(Index jcol, StorageIndex* marker) : m_jcol(jcol), m_marker(marker) {}
   bool update_segrep(Index krep, StorageIndex jj) {
     if (m_marker[krep] < m_jcol) {
@@ -135,7 +136,7 @@
         //    Place snode-rep krep in postorder DFS, if this
         //    segment is seen for the first time. (Note that
         //    "repfnz(krep)" may change later.)
-        //    Baktrack dfs to its parent
+        //    Backtrack dfs to its parent
         if (traits.update_segrep(krep, jj)) {
           segrep(nseg) = krep;
           ++nseg;
diff --git a/Eigen/src/SparseLU/SparseLU_pivotL.h b/Eigen/src/SparseLU/SparseLU_pivotL.h
index 10a090b..e781801 100644
--- a/Eigen/src/SparseLU/SparseLU_pivotL.h
+++ b/Eigen/src/SparseLU/SparseLU_pivotL.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -53,7 +54,7 @@
  * \param jcol The current column of L
  * \param diagpivotthresh diagonal pivoting threshold
  * \param[in,out] perm_r Row permutation (threshold pivoting)
- * \param[in] iperm_c column permutation - used to finf diagonal of Pc*A*Pc'
+ * \param[in] iperm_c column permutation - used to find diagonal of Pc*A*Pc'
  * \param[out] pivrow  The pivot row
  * \param glu Global LU data
  * \return 0 if success, i > 0 if U(i,i) is exactly zero
@@ -63,8 +64,8 @@
 Index SparseLUImpl<Scalar, StorageIndex>::pivotL(const Index jcol, const RealScalar& diagpivotthresh,
                                                  IndexVector& perm_r, IndexVector& iperm_c, Index& pivrow,
                                                  GlobalLU_t& glu) {
-  Index fsupc = (glu.xsup)((glu.supno)(jcol));  // First column in the supernode containing the column jcol
-  Index nsupc = jcol - fsupc;                   // Number of columns in the supernode portion, excluding jcol; nsupc >=0
+  Index fsupc = glu.xsup(glu.supno(jcol));  // First column in the supernode containing the column jcol
+  Index nsupc = jcol - fsupc;               // Number of columns in the supernode portion, excluding jcol; nsupc >=0
   Index lptr = glu.xlsub(fsupc);  // pointer to the starting location of the row subscripts for this supernode portion
   Index nsupr = glu.xlsub(fsupc + 1) - lptr;                    // Number of rows in the supernode
   Index lda = glu.xlusup(fsupc + 1) - glu.xlusup(fsupc);        // leading dimension
@@ -124,9 +125,15 @@
       std::swap(lu_sup_ptr[itemp], lu_sup_ptr[nsupc + icol * lda]);
     }
   }
-  // cdiv operations
-  Scalar temp = Scalar(1.0) / lu_col_ptr[nsupc];
-  for (k = nsupc + 1; k < nsupr; k++) lu_col_ptr[k] *= temp;
+  // cdiv operations. As in LAPACK's xGETF2: below the smallest normal number the
+  // reciprocal of the pivot may overflow, so divide instead.
+  const Scalar pivot = lu_col_ptr[nsupc];
+  if (numext::abs(pivot) >= (std::numeric_limits<RealScalar>::min)()) {
+    const Scalar temp = Scalar(1.0) / pivot;
+    for (k = nsupc + 1; k < nsupr; k++) lu_col_ptr[k] *= temp;
+  } else {
+    for (k = nsupc + 1; k < nsupr; k++) lu_col_ptr[k] /= pivot;
+  }
   return 0;
 }
 
diff --git a/Eigen/src/SparseLU/SparseLU_pruneL.h b/Eigen/src/SparseLU/SparseLU_pruneL.h
index 620f285..503bece 100644
--- a/Eigen/src/SparseLU/SparseLU_pruneL.h
+++ b/Eigen/src/SparseLU/SparseLU_pruneL.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /*
 
@@ -71,7 +72,7 @@
 
     // If a snode overlaps with the next panel, then the U-segment
     // is fragmented into two parts -- irep and irep1. We should let
-    // pruning occur at the rep-column in irep1s snode.
+    // pruning occur at the rep-column in irep1's snode.
     if (glu.supno(irep) == glu.supno(irep1)) continue;  // don't prune
 
     // If it has not been pruned & it has a nonz in row L(pivrow,i)
@@ -106,7 +107,7 @@
 
             // If the supernode has only one column, then we
             // only keep one set of subscripts. For any subscript
-            // intercnahge performed, similar interchange must be
+            // interchange performed, similar interchange must be
             // done on the numerical values.
             if (movnum) {
               minloc = glu.xlusup(irep) + (kmin - glu.xlsub(irep));
diff --git a/Eigen/src/SparseLU/SparseLU_relax_snode.h b/Eigen/src/SparseLU/SparseLU_relax_snode.h
index df3869e..69dd53a 100644
--- a/Eigen/src/SparseLU/SparseLU_relax_snode.h
+++ b/Eigen/src/SparseLU/SparseLU_relax_snode.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 /* This file is a modified version of heap_relax_snode.c file in SuperLU
  * -- SuperLU routine (version 3.0) --
diff --git a/Eigen/src/SparseQR/InternalHeaderCheck.h b/Eigen/src/SparseQR/InternalHeaderCheck.h
index 0564e93..38a3f61 100644
--- a/Eigen/src/SparseQR/InternalHeaderCheck.h
+++ b/Eigen/src/SparseQR/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SPARSEQR_MODULE_H
 #error "Please include Eigen/SparseQR instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index d11e664..c6816d9 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_QR_H
 #define EIGEN_SPARSE_QR_H
@@ -27,18 +28,18 @@
 namespace internal {
 template <typename SparseQRType>
 struct traits<SparseQRMatrixQReturnType<SparseQRType> > {
-  typedef typename SparseQRType::MatrixType ReturnType;
-  typedef typename ReturnType::StorageIndex StorageIndex;
-  typedef typename ReturnType::StorageKind StorageKind;
+  using ReturnType = typename SparseQRType::MatrixType;
+  using StorageIndex = typename ReturnType::StorageIndex;
+  using StorageKind = typename ReturnType::StorageKind;
   enum { RowsAtCompileTime = Dynamic, ColsAtCompileTime = Dynamic };
 };
 template <typename SparseQRType>
 struct traits<SparseQRMatrixQTransposeReturnType<SparseQRType> > {
-  typedef typename SparseQRType::MatrixType ReturnType;
+  using ReturnType = typename SparseQRType::MatrixType;
 };
 template <typename SparseQRType, typename Derived>
 struct traits<SparseQR_QProduct<SparseQRType, Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
+  using ReturnType = typename Derived::PlainObject;
 };
 }  // End namespace internal
 
@@ -60,7 +61,7 @@
  * Use matrixQ() to get an expression and matrixQ().adjoint() to get the adjoint.
  * You can then apply it to a vector.
  *
- * R is the sparse triangular or trapezoidal matrix. The later occurs when A is rank-deficient.
+ * R is the sparse triangular or trapezoidal matrix. The latter occurs when A is rank-deficient.
  * matrixR().topLeftCorner(rank(), rank()) always returns a triangular factor of full rank.
  *
  * \tparam MatrixType_ The type of the sparse matrix A, must be a column-major SparseMatrix<>
@@ -69,12 +70,18 @@
  *
  * \implsparsesolverconcept
  *
- * The numerical pivoting strategy and default threshold are the same as in SuiteSparse QR, and
- * detailed in the following paper:
+ * The default pivot threshold follows SuiteSparse QR and is detailed in the
+ * following paper:
  * <i>
  * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
  * Sparse QR Factorization", ACM Trans. on Math. Soft. 38(1), 2011.
  * </i>
+ * With the default threshold, Eigen also uses a bounded best-effort look-ahead
+ * to reject a pivot that is tiny relative to its candidate column if later
+ * columns provide enough stronger replacement pivots. This avoids accepting
+ * replaceable roundoff pivots after the fill-in reducing permutation. If this
+ * look-ahead exceeds its work or storage budget, the factorization keeps the
+ * usual default-threshold behavior for that pivot.
  * Even though it is qualified as "rank-revealing", this strategy might fail for some
  * rank deficient problems. When this class is used to solve linear or least-square problems
  * it is thus strongly recommended to check the accuracy of the computed solution. If it
@@ -87,26 +94,31 @@
 template <typename MatrixType_, typename OrderingType_>
 class SparseQR : public SparseSolverBase<SparseQR<MatrixType_, OrderingType_> > {
  protected:
-  typedef SparseSolverBase<SparseQR<MatrixType_, OrderingType_> > Base;
+  using Base = SparseSolverBase<SparseQR<MatrixType_, OrderingType_>>;
   using Base::m_isInitialized;
 
  public:
   using Base::_solve_impl;
-  typedef MatrixType_ MatrixType;
-  typedef OrderingType_ OrderingType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef SparseMatrix<Scalar, ColMajor, StorageIndex> QRMatrixType;
-  typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
-  typedef Matrix<Scalar, Dynamic, 1> ScalarVector;
-  typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> PermutationType;
+  using MatrixType = MatrixType_;
+  using OrderingType = OrderingType_;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using StorageIndex = typename MatrixType::StorageIndex;
+  using QRMatrixType = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using IndexVector = Matrix<StorageIndex, Dynamic, 1>;
+  using ScalarVector = Matrix<Scalar, Dynamic, 1>;
+  using PermutationType = PermutationMatrix<Dynamic, Dynamic, StorageIndex>;
 
   enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };
 
  public:
   SparseQR()
-      : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true), m_isQSorted(false), m_isEtreeOk(false) {}
+      : m_analysisIsok(false),
+        m_lastError(""),
+        m_useDefaultThreshold(true),
+        m_lastPivotLookAheadSkipped(false),
+        m_isQSorted(false),
+        m_isEtreeOk(false) {}
 
   /** Construct a QR factorization of the matrix \a mat.
    *
@@ -115,7 +127,12 @@
    * \sa compute()
    */
   explicit SparseQR(const MatrixType& mat)
-      : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true), m_isQSorted(false), m_isEtreeOk(false) {
+      : m_analysisIsok(false),
+        m_lastError(""),
+        m_useDefaultThreshold(true),
+        m_lastPivotLookAheadSkipped(false),
+        m_isQSorted(false),
+        m_isEtreeOk(false) {
     compute(mat);
   }
 
@@ -142,7 +159,7 @@
 
   /** \returns a const reference to the \b sparse upper triangular matrix R of the QR factorization.
    * \warning The entries of the returned matrix are not sorted. This means that using it in algorithms
-   *          expecting sorted entries will fail. This include random coefficient accesses (SpaseMatrix::coeff()),
+   *          expecting sorted entries will fail. This includes random coefficient accesses (SparseMatrix::coeff()),
    *          and coefficient-wise operations. Matrix products and triangular solves are fine though.
    *
    * To sort the entries, you can assign it to a row-major matrix, and if a column-major matrix
@@ -192,6 +209,19 @@
     return m_outputPerm_c;
   }
 
+  /** \returns true if the bounded default-mode look-ahead for replaceable
+   * roundoff pivots was skipped during the previous factorization because it
+   * exceeded its work or storage budget.
+   *
+   * This flag is reset at the start of factorize(). It can only become true
+   * when the default pivot threshold is in use; setting an explicit pivot
+   * threshold disables the look-ahead.
+   */
+  bool lastPivotLookAheadSkipped() const {
+    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
+    return m_lastPivotLookAheadSkipped;
+  }
+
   /** \returns A string describing the type of error.
    * This method is provided to ease debugging, not to handle errors.
    */
@@ -218,7 +248,7 @@
 
     // Apply the column permutation
     if (m_perm_c.size())
-      dest = colsPermutation() * y.topRows(cols());
+      dest.noalias() = colsPermutation() * y.topRows(cols());
     else
       dest = y.topRows(cols());
 
@@ -230,6 +260,8 @@
    *
    * In practice, if during the factorization the norm of the column that has to be eliminated is below
    * this threshold, then the entire column is treated as zero, and it is moved at the end.
+   * Setting an explicit threshold disables the additional default-mode check for
+   * replaceable roundoff pivots.
    */
   void setPivotThreshold(const RealScalar& threshold) {
     m_useDefaultThreshold = false;
@@ -260,8 +292,6 @@
    * \returns \c Success if computation was successful,
    *          \c NumericalIssue if the QR factorization reports a numerical problem
    *          \c InvalidInput if the input matrix is invalid
-   *
-   * \sa iparm()
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
@@ -291,11 +321,17 @@
   PermutationType m_outputPerm_c;  // The final column permutation
   RealScalar m_threshold;          // Threshold to determine null Householder reflections
   bool m_useDefaultThreshold;      // Use default threshold
-  Index m_nonzeropivots;           // Number of non zero pivots found
-  IndexVector m_etree;             // Column elimination tree
-  IndexVector m_firstRowElt;       // First element in each row
-  bool m_isQSorted;                // whether Q is sorted or not
-  bool m_isEtreeOk;                // whether the elimination tree match the initial input matrix
+  bool m_lastPivotLookAheadSkipped;
+  Index m_nonzeropivots;      // Number of non zero pivots found
+  IndexVector m_etree;        // Column elimination tree
+  IndexVector m_firstRowElt;  // First element in each row
+  bool m_isQSorted;           // whether Q is sorted or not
+  bool m_isEtreeOk;           // whether the elimination tree match the initial input matrix
+
+  // Bound the temporary dense replacement basis in bytes. The entry count is scaled by sizeof(Scalar), so wider scalar
+  // types inspect fewer replacement directions before keeping the usual default-threshold behavior for the pivot.
+  static constexpr Index PivotLookAheadMaxBasisBytes = Index(32) * Index(1024) * Index(1024);
+  static constexpr Index PivotLookAheadMaxExtraCandidateColumns = 64;
 
   template <typename, typename>
   friend struct SparseQR_QProduct;
@@ -356,6 +392,12 @@
   using std::abs;
 
   eigen_assert(m_analysisIsok && "analyzePattern() should be called before this step");
+
+  // Reset state from any prior factorize() so info() and lastErrorMessage()
+  // describe this call's outcome, not the previous matrix's.
+  m_info = Success;
+  m_lastError.clear();
+
   StorageIndex m = StorageIndex(mat.rows());
   StorageIndex n = StorageIndex(mat.cols());
   StorageIndex diagSize = (std::min)(m, n);
@@ -364,9 +406,12 @@
   IndexVector Ridx(n), Qidx(m);  // Store temporarily the row indexes for the current column of R and Q
   Index nzcolR, nzcolQ;          // Number of nonzero for the current column of R and Q
   ScalarVector tval(m);          // The dense vector used to compute the current column
+  ScalarVector tvalLookAhead(m);
+  Matrix<Scalar, Dynamic, Dynamic> replacementBasis;
 
   m_R.setZero();
   m_Q.setZero();
+  m_lastPivotLookAheadSkipped = false;
   m_pmat = mat;
   if (!m_isEtreeOk) {
     m_outputPerm_c = m_perm_c.inverse();
@@ -374,16 +419,18 @@
     m_isEtreeOk = true;
   }
 
-  m_pmat.uncompress();  // To have the innerNonZeroPtr allocated
+  // Switch to uncompressed mode so innerNonZeroPtr() exists and can be
+  // permuted consistently with outerIndexPtr().
+  m_pmat.uncompress();
 
   // Apply the fill-in reducing permutation lazily:
   {
-    // If the input is row major, copy the original column indices,
-    // otherwise directly use the input matrix
-    //
+    // A compressed column-major input already exposes valid column pointers.
+    // Otherwise snapshot the internal column-major structure before permuting in place.
     IndexVector originalOuterIndicesCpy;
-    const StorageIndex* originalOuterIndices = mat.outerIndexPtr();
-    if (MatrixType::IsRowMajor) {
+    const bool useInputOuterIndices = !MatrixType::IsRowMajor && mat.isCompressed();
+    const StorageIndex* originalOuterIndices = useInputOuterIndices ? mat.outerIndexPtr() : nullptr;
+    if (!useInputOuterIndices) {
       originalOuterIndicesCpy = IndexVector::Map(m_pmat.outerIndexPtr(), n + 1);
       originalOuterIndices = originalOuterIndicesCpy.data();
     }
@@ -400,11 +447,32 @@
    * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3
    */
   RealScalar pivotThreshold;
+  RealScalar max2Norm = RealScalar(0.0);
   if (m_useDefaultThreshold) {
-    RealScalar max2Norm = 0.0;
-    for (int j = 0; j < n; j++) max2Norm = numext::maxi(max2Norm, m_pmat.col(j).norm());
-    if (max2Norm == RealScalar(0)) max2Norm = RealScalar(1);
-    pivotThreshold = 20 * (m + n) * max2Norm * NumTraits<RealScalar>::epsilon();
+    // For scalar types narrower than float (half, bfloat16), compute the default threshold in float:
+    // the squared column norms and the factor 20*(m+n) overflow a 16-bit type for moderate problem
+    // sizes, and 20*(m+n)*epsilon() exceeds 1 for m+n as small as 52 (half) or 7 (bfloat16), which
+    // would reject every pivot and collapse the reported rank to zero.
+    using ThresholdReal = std::conditional_t<(sizeof(RealScalar) < sizeof(float)), float, RealScalar>;
+    if (EIGEN_CONST_CONDITIONAL((std::is_same<ThresholdReal, RealScalar>::value))) {
+      // ThresholdReal == RealScalar (float and wider scalars): keep the historical computation bit-for-bit.
+      for (int j = 0; j < n; j++) max2Norm = numext::maxi(max2Norm, m_pmat.col(j).norm());
+      if (max2Norm == RealScalar(0)) max2Norm = RealScalar(1);
+      pivotThreshold = RealScalar(20 * (m + n)) * max2Norm * NumTraits<RealScalar>::epsilon();
+    } else {
+      ThresholdReal maxColNorm = ThresholdReal(0);
+      for (int j = 0; j < n; j++) {
+        ThresholdReal colSquaredNorm = ThresholdReal(0);
+        for (typename QRMatrixType::InnerIterator it(m_pmat, j); it; ++it)
+          colSquaredNorm += numext::abs2(ThresholdReal(numext::real(it.value()))) +
+                            numext::abs2(ThresholdReal(numext::imag(it.value())));
+        maxColNorm = numext::maxi(maxColNorm, numext::sqrt(colSquaredNorm));
+      }
+      if (maxColNorm == ThresholdReal(0)) maxColNorm = ThresholdReal(1);
+      // Convert back to the narrow type only once, after the whole threshold has been formed in float.
+      pivotThreshold = RealScalar(ThresholdReal(20 * (m + n)) * maxColNorm * NumTraits<ThresholdReal>::epsilon());
+      max2Norm = RealScalar(maxColNorm);
+    }
   } else {
     pivotThreshold = m_threshold;
   }
@@ -497,7 +565,7 @@
     }  // End update current column
 
     Scalar tau = RealScalar(0);
-    RealScalar beta = 0;
+    RealScalar beta = RealScalar(0);
 
     if (nonzeroCol < diagSize) {
       // Compute the Householder reflection that eliminate the current column
@@ -505,16 +573,16 @@
       Scalar c0 = nzcolQ ? tval(Qidx(0)) : Scalar(0);
 
       // First, the squared norm of Q((col+1):m, col)
-      RealScalar sqrNorm = 0.;
+      RealScalar sqrNorm = RealScalar(0.);
       for (Index itq = 1; itq < nzcolQ; ++itq) sqrNorm += numext::abs2(tval(Qidx(itq)));
       if (sqrNorm == RealScalar(0) && numext::imag(c0) == RealScalar(0)) {
         beta = numext::real(c0);
-        tval(Qidx(0)) = 1;
+        tval(Qidx(0)) = Scalar(1);
       } else {
         using std::sqrt;
         beta = sqrt(numext::abs2(c0) + sqrNorm);
         if (numext::real(c0) >= RealScalar(0)) beta = -beta;
-        tval(Qidx(0)) = 1;
+        tval(Qidx(0)) = Scalar(1);
         for (Index itq = 1; itq < nzcolQ; ++itq) tval(Qidx(itq)) /= (c0 - beta);
         tau = numext::conj((beta - c0) / beta);
       }
@@ -529,7 +597,80 @@
       }
     }
 
-    if (nonzeroCol < diagSize && abs(beta) >= pivotThreshold) {
+    const RealScalar absBeta = abs(beta);
+    bool hasReplacement = false;
+    const bool canRejectColumn = nonzeroCol + (n - col - 1) >= diagSize;
+    // Gate for examining a pivot as replaceable. The Householder pivot `beta` of a
+    // (nearly) dependent column is a catastrophic-cancellation residual whose exact
+    // magnitude is not reproducible across compilers or FMA-contraction settings, so
+    // this examination gate uses a generous sqrt(epsilon) tolerance rather than
+    // dummy_precision. The rejection below still requires a strictly stronger,
+    // independent replacement set, so a wider gate only changes which pivots are
+    // *examined* (and never rejects a pivot that lacks a replacement). A threshold at
+    // the residual's noise floor would otherwise make the pivoting decision -- and
+    // hence the result -- depend on floating-point contraction.
+    using std::sqrt;
+    const RealScalar weakPivotTolerance = sqrt(NumTraits<RealScalar>::epsilon());
+    const RealScalar maxReplaceablePivotThreshold = max2Norm * weakPivotTolerance;
+    if (nonzeroCol < diagSize && canRejectColumn && m_useDefaultThreshold && absBeta >= pivotThreshold &&
+        absBeta < maxReplaceablePivotThreshold) {
+      const RealScalar colNorm = m_pmat.col(col).norm();
+      // Per-column replacement gate, mirroring the global max2Norm * weakPivotTolerance threshold.
+      const RealScalar replaceablePivotThreshold = colNorm * weakPivotTolerance;
+      if (absBeta < replaceablePivotThreshold) {
+        const StorageIndex requiredReplacementCount = diagSize - nonzeroCol;
+        const StorageIndex activeRows = m - nonzeroCol;
+        const Index maxReplacementBasisEntries = Index(PivotLookAheadMaxBasisBytes) / Index(sizeof(Scalar));
+        const bool canStoreReplacementBasis =
+            Index(activeRows) <= maxReplacementBasisEntries / Index(requiredReplacementCount);
+        if (canStoreReplacementBasis) {
+          replacementBasis.resize(activeRows, requiredReplacementCount);
+          StorageIndex replacementCount = 0;
+          const StorageIndex maxLookAheadCandidateColumns =
+              (std::min)(n - col - 1, requiredReplacementCount + StorageIndex(PivotLookAheadMaxExtraCandidateColumns));
+          StorageIndex inspectedCandidateCount = 0;
+          StorageIndex candidateCol = col + 1;
+
+          // A small pivot is safe to skip only if later columns can still
+          // provide enough independent replacement pivots after the previously
+          // computed reflectors. Keep this dense look-ahead bounded so sparse
+          // inputs cannot trigger unbounded dense work.
+          for (; candidateCol < n && !hasReplacement && inspectedCandidateCount < maxLookAheadCandidateColumns;
+               ++candidateCol, ++inspectedCandidateCount) {
+            if (m_pmat.col(candidateCol).norm() < replaceablePivotThreshold) continue;
+            tvalLookAhead.setZero();
+            for (typename QRMatrixType::InnerIterator itp(m_pmat, candidateCol); itp; ++itp) {
+              tvalLookAhead(itp.row()) = itp.value();
+            }
+            for (StorageIndex previousCol = 0; previousCol < nonzeroCol; ++previousCol) {
+              Scalar tdot = m_Q.col(previousCol).dot(tvalLookAhead);
+              tdot *= m_hcoeffs(previousCol);
+              tvalLookAhead -= tdot * m_Q.col(previousCol);
+            }
+
+            typename ScalarVector::SegmentReturnType candidateTail = tvalLookAhead.segment(nonzeroCol, activeRows);
+            for (StorageIndex replacement = 0; replacement < replacementCount; ++replacement) {
+              candidateTail -= replacementBasis.col(replacement).dot(candidateTail) * replacementBasis.col(replacement);
+            }
+
+            const RealScalar candidateNorm = candidateTail.norm();
+            if (candidateNorm >= replaceablePivotThreshold) {
+              replacementBasis.col(replacementCount) = candidateTail * (RealScalar(1) / candidateNorm);
+              ++replacementCount;
+              hasReplacement = replacementCount >= requiredReplacementCount;
+            }
+          }
+          if (!hasReplacement && candidateCol < n) m_lastPivotLookAheadSkipped = true;
+        } else {
+          // Retain this fallback for very large problems and wide/custom Scalar types where the best-effort dense
+          // look-ahead would exceed its storage budget.
+          m_lastPivotLookAheadSkipped = true;
+        }
+      }
+    }
+    // If a replacement set was found, the pivot is genuinely replaceable: reject it
+    // (defer the column to the end) independently of `beta`'s exact magnitude.
+    if (nonzeroCol < diagSize && absBeta >= pivotThreshold && !hasReplacement) {
       m_R.insertBackByOuterInner(col, nonzeroCol) = beta;
       // The householder coefficient
       m_hcoeffs(nonzeroCol) = tau;
@@ -578,8 +719,8 @@
 
 template <typename SparseQRType, typename Derived>
 struct SparseQR_QProduct : ReturnByValue<SparseQR_QProduct<SparseQRType, Derived> > {
-  typedef typename SparseQRType::QRMatrixType MatrixType;
-  typedef typename SparseQRType::Scalar Scalar;
+  using MatrixType = typename SparseQRType::QRMatrixType;
+  using Scalar = typename SparseQRType::Scalar;
   // Get the references
   SparseQR_QProduct(const SparseQRType& qr, const Derived& other, bool transpose)
       : m_qr(qr), m_other(other), m_transpose(transpose) {}
@@ -631,8 +772,8 @@
 
 template <typename SparseQRType>
 struct SparseQRMatrixQReturnType : public EigenBase<SparseQRMatrixQReturnType<SparseQRType> > {
-  typedef typename SparseQRType::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
+  using Scalar = typename SparseQRType::Scalar;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic>;
   enum { RowsAtCompileTime = Dynamic, ColsAtCompileTime = Dynamic };
   explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
   template <typename Derived>
@@ -667,17 +808,17 @@
 
 template <typename SparseQRType>
 struct evaluator_traits<SparseQRMatrixQReturnType<SparseQRType> > {
-  typedef typename SparseQRType::MatrixType MatrixType;
-  typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
-  typedef SparseShape Shape;
+  using MatrixType = typename SparseQRType::MatrixType;
+  using Kind = typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind;
+  using Shape = SparseShape;
 };
 
 template <typename DstXprType, typename SparseQRType>
 struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>,
                   internal::assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>, Sparse2Sparse> {
-  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
-  typedef typename DstXprType::Scalar Scalar;
-  typedef typename DstXprType::StorageIndex StorageIndex;
+  using SrcXprType = SparseQRMatrixQReturnType<SparseQRType>;
+  using Scalar = typename DstXprType::Scalar;
+  using StorageIndex = typename DstXprType::StorageIndex;
   static void run(DstXprType& dst, const SrcXprType& src, const internal::assign_op<Scalar, Scalar>& /*func*/) {
     typename DstXprType::PlainObject idMat(src.rows(), src.cols());
     idMat.setIdentity();
@@ -690,9 +831,9 @@
 template <typename DstXprType, typename SparseQRType>
 struct Assignment<DstXprType, SparseQRMatrixQReturnType<SparseQRType>,
                   internal::assign_op<typename DstXprType::Scalar, typename DstXprType::Scalar>, Sparse2Dense> {
-  typedef SparseQRMatrixQReturnType<SparseQRType> SrcXprType;
-  typedef typename DstXprType::Scalar Scalar;
-  typedef typename DstXprType::StorageIndex StorageIndex;
+  using SrcXprType = SparseQRMatrixQReturnType<SparseQRType>;
+  using Scalar = typename DstXprType::Scalar;
+  using StorageIndex = typename DstXprType::StorageIndex;
   static void run(DstXprType& dst, const SrcXprType& src, const internal::assign_op<Scalar, Scalar>& /*func*/) {
     dst = src.m_qr.matrixQ() * DstXprType::Identity(src.m_qr.rows(), src.m_qr.rows());
   }
diff --git a/Eigen/src/StlSupport/StdDeque.h b/Eigen/src/StlSupport/StdDeque.h
index 692281b..df2b5cd 100644
--- a/Eigen/src/StlSupport/StdDeque.h
+++ b/Eigen/src/StlSupport/StdDeque.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STDDEQUE_H
 #define EIGEN_STDDEQUE_H
diff --git a/Eigen/src/StlSupport/StdList.h b/Eigen/src/StlSupport/StdList.h
index 26395df..46f3bb1 100644
--- a/Eigen/src/StlSupport/StdList.h
+++ b/Eigen/src/StlSupport/StdList.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STDLIST_H
 #define EIGEN_STDLIST_H
diff --git a/Eigen/src/StlSupport/StdVector.h b/Eigen/src/StlSupport/StdVector.h
index dd538e9..1b8b44f 100644
--- a/Eigen/src/StlSupport/StdVector.h
+++ b/Eigen/src/StlSupport/StdVector.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STDVECTOR_H
 #define EIGEN_STDVECTOR_H
diff --git a/Eigen/src/StlSupport/details.h b/Eigen/src/StlSupport/details.h
index 9bc9d21..16ddb4f 100644
--- a/Eigen/src/StlSupport/details.h
+++ b/Eigen/src/StlSupport/details.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_STL_DETAILS_H
 #define EIGEN_STL_DETAILS_H
@@ -15,68 +16,4 @@
 #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator
 #endif
 
-namespace Eigen {
-
-// This one is needed to prevent reimplementing the whole std::vector.
-template <class T>
-class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR<T> {
- public:
-  typedef std::size_t size_type;
-  typedef std::ptrdiff_t difference_type;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef T value_type;
-
-  template <class U>
-  struct rebind {
-    typedef aligned_allocator_indirection<U> other;
-  };
-
-  aligned_allocator_indirection() {}
-  aligned_allocator_indirection(const aligned_allocator_indirection&) : EIGEN_ALIGNED_ALLOCATOR<T>() {}
-  aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>&) {}
-  template <class U>
-  aligned_allocator_indirection(const aligned_allocator_indirection<U>&) {}
-  template <class U>
-  aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>&) {}
-  ~aligned_allocator_indirection() {}
-};
-
-#if EIGEN_COMP_MSVC
-
-// sometimes, MSVC detects, at compile time, that the argument x
-// in std::vector::resize(size_t s,T x) won't be aligned and generate an error
-// even if this function is never called. Whence this little wrapper.
-#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) \
-  std::conditional_t<Eigen::internal::is_arithmetic<T>::value, T, Eigen::internal::workaround_msvc_stl_support<T> >
-
-namespace internal {
-template <typename T>
-struct workaround_msvc_stl_support : public T {
-  inline workaround_msvc_stl_support() : T() {}
-  inline workaround_msvc_stl_support(const T& other) : T(other) {}
-  inline operator T&() { return *static_cast<T*>(this); }
-  inline operator const T&() const { return *static_cast<const T*>(this); }
-  template <typename OtherT>
-  inline T& operator=(const OtherT& other) {
-    T::operator=(other);
-    return *this;
-  }
-  inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other) {
-    T::operator=(other);
-    return *this;
-  }
-};
-}  // namespace internal
-
-#else
-
-#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) T
-
-#endif
-
-}  // namespace Eigen
-
 #endif  // EIGEN_STL_DETAILS_H
diff --git a/Eigen/src/SuperLUSupport/InternalHeaderCheck.h b/Eigen/src/SuperLUSupport/InternalHeaderCheck.h
index 94a62b5..36af590 100644
--- a/Eigen/src/SuperLUSupport/InternalHeaderCheck.h
+++ b/Eigen/src/SuperLUSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
 #error "Please include Eigen/SuperLUSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/SuperLUSupport/SuperLUSupport.h b/Eigen/src/SuperLUSupport/SuperLUSupport.h
index bed414b..a3f88e9 100644
--- a/Eigen/src/SuperLUSupport/SuperLUSupport.h
+++ b/Eigen/src/SuperLUSupport/SuperLUSupport.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SUPERLUSUPPORT_H
 #define EIGEN_SUPERLUSUPPORT_H
@@ -57,6 +58,7 @@
 DECL_GSSVX(c, float, std::complex<float>)
 DECL_GSSVX(d, double, double)
 DECL_GSSVX(z, double, std::complex<double>)
+#undef DECL_GSSVX
 
 #ifdef MILU_ALPHA
 #define EIGEN_SUPERLU_HAS_ILU
@@ -104,6 +106,7 @@
 DECL_GSISX(c, float, std::complex<float>)
 DECL_GSISX(d, double, double)
 DECL_GSISX(z, double, std::complex<double>)
+#undef DECL_GSISX
 
 #endif
 
@@ -115,7 +118,7 @@
  * A wrapper class for SuperLU matrices. It supports only compressed sparse matrices
  * and dense matrices. Supernodal and other fancy format are not supported by this wrapper.
  *
- * This wrapper class mainly aims to avoids the need of dynamic allocation of the storage structure.
+ * This wrapper class mainly aims to avoid the need of dynamic allocation of the storage structure.
  */
 struct SluMatrix : SuperMatrix {
   SluMatrix() { Store = &storage; }
@@ -154,13 +157,13 @@
 
   template <typename Scalar>
   void setScalarType() {
-    if (internal::is_same<Scalar, float>::value)
+    EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, float>::value))
       Dtype = SLU_S;
-    else if (internal::is_same<Scalar, double>::value)
+    else EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, double>::value))
       Dtype = SLU_D;
-    else if (internal::is_same<Scalar, std::complex<float> >::value)
+    else EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, std::complex<float> >::value))
       Dtype = SLU_C;
-    else if (internal::is_same<Scalar, std::complex<double> >::value)
+    else EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, std::complex<double> >::value))
       Dtype = SLU_Z;
     else {
       eigen_assert(false && "Scalar type not supported by SuperLU");
@@ -189,7 +192,7 @@
   static SluMatrix Map(SparseMatrixBase<MatrixType> &a_mat) {
     MatrixType &mat(a_mat.derived());
     SluMatrix res;
-    if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) {
+    EIGEN_IF_CONSTEXPR ((MatrixType::Flags & RowMajorBit) == RowMajorBit) {
       res.setStorageType(SLU_NR);
       res.nrow = internal::convert_index<int>(mat.cols());
       res.ncol = internal::convert_index<int>(mat.rows());
@@ -209,8 +212,8 @@
     res.setScalarType<typename MatrixType::Scalar>();
 
     // FIXME: the following type mapping is approximate.
-    if (int(MatrixType::Flags) & int(Upper)) res.Mtype = SLU_TRU;
-    if (int(MatrixType::Flags) & int(Lower)) res.Mtype = SLU_TRL;
+    EIGEN_IF_CONSTEXPR (int(MatrixType::Flags) & int(Upper)) res.Mtype = SLU_TRU;
+    EIGEN_IF_CONSTEXPR (int(MatrixType::Flags) & int(Lower)) res.Mtype = SLU_TRL;
 
     eigen_assert(((int(MatrixType::Flags) & int(SelfAdjoint)) == 0) &&
                  "SelfAdjoint matrix shape not supported by SuperLU");
@@ -240,7 +243,7 @@
 struct SluMatrixMapHelper<SparseMatrixBase<Derived> > {
   typedef Derived MatrixType;
   static void run(MatrixType &mat, SluMatrix &res) {
-    if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) {
+    EIGEN_IF_CONSTEXPR ((MatrixType::Flags & RowMajorBit) == RowMajorBit) {
       res.setStorageType(SLU_NR);
       res.nrow = mat.cols();
       res.ncol = mat.rows();
@@ -260,8 +263,8 @@
     res.setScalarType<typename MatrixType::Scalar>();
 
     // FIXME: the following type mapping is approximate.
-    if (MatrixType::Flags & Upper) res.Mtype = SLU_TRU;
-    if (MatrixType::Flags & Lower) res.Mtype = SLU_TRL;
+    EIGEN_IF_CONSTEXPR (MatrixType::Flags & Upper) res.Mtype = SLU_TRU;
+    EIGEN_IF_CONSTEXPR (MatrixType::Flags & Lower) res.Mtype = SLU_TRL;
 
     eigen_assert(((MatrixType::Flags & SelfAdjoint) == 0) && "SelfAdjoint matrix shape not supported by SuperLU");
   }
@@ -326,14 +329,14 @@
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears to be negative.
+   *          \c NumericalIssue if the matrix appears to be negative.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
     return m_info;
   }
 
-  /** Computes the sparse Cholesky decomposition of \a matrix */
+  /** Computes the sparse LU decomposition of \a matrix */
   void compute(const MatrixType &matrix) {
     derived().analyzePattern(matrix);
     derived().factorize(matrix);
@@ -440,7 +443,7 @@
  *
  * \tparam MatrixType_ the type of the sparse matrix A, it must be a SparseMatrix<>
  *
- * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+ * \warning This class requires at least version 4.0 of SuperLU. The 3.x versions are not supported.
  *
  * \implsparsesolverconcept
  *
@@ -471,8 +474,6 @@
     Base::compute(matrix);
   }
 
-  ~SuperLU() {}
-
   /** Performs a symbolic decomposition on the sparsity of \a matrix.
    *
    * This function is particularly useful when solving for several problems having the same structure.
@@ -577,8 +578,8 @@
 
   StatInit(&m_sluStat);
   SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
-                &m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &ferr, &berr,
-                &m_sluStat, &info, Scalar());
+                &m_sluCscale[0], &m_sluL, &m_sluU, nullptr, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &ferr,
+                &berr, &m_sluStat, &info, Scalar());
   StatFree(&m_sluStat);
 
   m_extractedDataAreDirty = true;
@@ -621,7 +622,7 @@
   int info = 0;
   RealScalar recip_pivot_growth, rcond;
   SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
-                &m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond,
+                &m_sluCscale[0], &m_sluL, &m_sluU, nullptr, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond,
                 &m_sluFerr[0], &m_sluBerr[0], &m_sluStat, &info, Scalar());
   StatFree(&m_sluStat);
 
@@ -665,7 +666,6 @@
     Scalar *Uval = m_u.valuePtr();
 
     Ucol[0] = 0;
-    Ucol[0] = 0;
 
     /* for each supernode */
     for (int k = 0; k <= Lstore->nsuper; ++k) {
@@ -753,7 +753,7 @@
  * factorization using the SuperLU library. This class is aimed to be used as a preconditioner of the iterative linear
  * solvers.
  *
- * \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
+ * \warning This class requires at least version 4.0 of SuperLU. The 3.x versions are not supported.
  *
  * \tparam MatrixType_ the type of the sparse matrix A, it must be a SparseMatrix<>
  *
@@ -780,8 +780,6 @@
     Base::compute(matrix);
   }
 
-  ~SuperILU() {}
-
   /** Performs a symbolic decomposition on the sparsity of \a matrix.
    *
    * This function is particularly useful when solving for several problems having the same structure.
@@ -868,8 +866,8 @@
 
   StatInit(&m_sluStat);
   SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
-                &m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &m_sluStat,
-                &info, Scalar());
+                &m_sluCscale[0], &m_sluL, &m_sluU, nullptr, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
   StatFree(&m_sluStat);
 
   // FIXME: implement more detailed error checking based on SuperLU info codes.
@@ -912,8 +910,8 @@
 
   StatInit(&m_sluStat);
   SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
-                &m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &m_sluStat,
-                &info, Scalar());
+                &m_sluCscale[0], &m_sluL, &m_sluU, nullptr, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond,
+                &m_sluStat, &info, Scalar());
   StatFree(&m_sluStat);
 
   if (x.derived().data() != x_ref.data()) x = x_ref;
diff --git a/Eigen/src/ThreadPool/Barrier.h b/Eigen/src/ThreadPool/Barrier.h
index be530d0..0379f9a 100644
--- a/Eigen/src/ThreadPool/Barrier.h
+++ b/Eigen/src/ThreadPool/Barrier.h
@@ -6,12 +6,13 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // Barrier is an object that allows one or more threads to wait until
 // Notify has been called a specified number of times.
 
-#ifndef EIGEN_CXX11_THREADPOOL_BARRIER_H
-#define EIGEN_CXX11_THREADPOOL_BARRIER_H
+#ifndef EIGEN_THREADPOOL_BARRIER_H
+#define EIGEN_THREADPOOL_BARRIER_H
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
@@ -56,15 +57,15 @@
   bool notified_;
 };
 
-// Notification is an object that allows a user to to wait for another
+// Notification is an object that allows a user to wait for another
 // thread to signal a notification that an event has occurred.
 //
 // Multiple threads can wait on the same Notification object,
 // but only one caller must call Notify() on the object.
 struct Notification : Barrier {
-  Notification() : Barrier(1){};
+  Notification() : Barrier(1) {}
 };
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_BARRIER_H
+#endif  // EIGEN_THREADPOOL_BARRIER_H
diff --git a/Eigen/src/ThreadPool/CoreThreadPoolDevice.h b/Eigen/src/ThreadPool/CoreThreadPoolDevice.h
index c603a38..30be008 100644
--- a/Eigen/src/ThreadPool/CoreThreadPoolDevice.h
+++ b/Eigen/src/ThreadPool/CoreThreadPoolDevice.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CORE_THREAD_POOL_DEVICE_H
 #define EIGEN_CORE_THREAD_POOL_DEVICE_H
@@ -273,7 +274,7 @@
     device.template parallelFor<PacketAssignmentFunctor, PacketSize>(0, outerSize, 0, packetAccessSize, packetFunctor,
                                                                      packetCost);
     device.template parallelFor<ScalarAssignmentFunctor, 1>(0, outerSize, scalarFunctor, scalarCost);
-  };
+  }
 };
 
 template <typename Kernel>
diff --git a/Eigen/src/ThreadPool/EventCount.h b/Eigen/src/ThreadPool/EventCount.h
index c4e73cf..a8e2cff 100644
--- a/Eigen/src/ThreadPool/EventCount.h
+++ b/Eigen/src/ThreadPool/EventCount.h
@@ -6,9 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_EVENTCOUNT_H
-#define EIGEN_CXX11_THREADPOOL_EVENTCOUNT_H
+#ifndef EIGEN_THREADPOOL_EVENTCOUNT_H
+#define EIGEN_THREADPOOL_EVENTCOUNT_H
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
@@ -45,7 +46,7 @@
 // https://en.wikipedia.org/wiki/Dekker%27s_algorithm
 // Waiting thread sets state_ then checks predicate, Notifying thread sets
 // predicate then checks state_. Due to seq_cst fences in between these
-// operations it is guaranteed than either waiter will see predicate change
+// operations it is guaranteed that either waiter will see predicate change
 // and won't block, or notifying thread will see state_ change and will unblock
 // the waiter, or both. But it can't happen that both threads don't see each
 // other changes, which would lead to deadlock.
@@ -108,7 +109,6 @@
 
   // CancelWait cancels effects of the previous Prewait call.
   void CancelWait() {
-    bool notify = false;
     uint64_t state = state_.load(std::memory_order_relaxed);
     for (;;) {
       CheckState(state, true);
@@ -116,17 +116,14 @@
       // We don't know if the thread was also notified or not,
       // so we should not consume a signal unconditionally.
       // Only if number of waiters is equal to number of signals,
-      // we know that the thread was notified and we must take away the signal.
-      if (((state & kWaiterMask) >> kWaiterShift) ==
-          ((state & kSignalMask) >> kSignalShift)) {
+      // we know that the thread was notified and we must take away the signal
+      // and forward it to any other waiting thread.
+      const bool notify = (((state & kWaiterMask) >> kWaiterShift) == ((state & kSignalMask) >> kSignalShift));
+      if (notify) {
         newstate -= kSignalInc;
-        notify = true;
-      } else {
-        notify = false;
       }
       CheckState(newstate);
-      if (state_.compare_exchange_weak(state, newstate,
-                                       std::memory_order_acq_rel)) {
+      if (state_.compare_exchange_weak(state, newstate, std::memory_order_acq_rel)) {
         if (notify) {
           Notify(false);
         }
@@ -218,6 +215,7 @@
     eigen_plain_assert(waiters >= signals);
     eigen_plain_assert(waiters < (1 << kWaiterBits) - 1);
     eigen_plain_assert(!waiter || waiters > 0);
+    (void)waiter;
     (void)waiters;
     (void)signals;
   }
@@ -251,4 +249,4 @@
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_EVENTCOUNT_H
+#endif  // EIGEN_THREADPOOL_EVENTCOUNT_H
diff --git a/Eigen/src/ThreadPool/ForkJoin.h b/Eigen/src/ThreadPool/ForkJoin.h
index 588636a..5be2cef 100644
--- a/Eigen/src/ThreadPool/ForkJoin.h
+++ b/Eigen/src/ThreadPool/ForkJoin.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_THREADPOOL_FORKJOIN_H
 #define EIGEN_THREADPOOL_FORKJOIN_H
@@ -60,7 +61,11 @@
  public:
   // Runs `do_func` asynchronously for the range [start, end) with a specified
   // granularity. `do_func` should be of type `std::function<void(Index,
-  // Index)`. `done()` is called exactly once after all tasks have been executed.
+  // Index)>`. `done()` is called exactly once after all tasks have been executed.
+  //
+  // WARNING: like `ParallelFor` below, scheduling nested `ParallelForAsync`
+  // calls (one task body invokes ParallelForAsync on the same pool) can deadlock
+  // because `ForkJoin`'s help-while-waiting loop is not reentrancy-aware.
   template <typename DoFnType, typename DoneFnType, typename ThreadPoolEnv>
   static void ParallelForAsync(Index start, Index end, Index granularity, DoFnType&& do_func, DoneFnType&& done,
                                ThreadPoolTempl<ThreadPoolEnv>* thread_pool) {
@@ -84,7 +89,7 @@
     if (start >= end) return;
     Barrier barrier(1);
     auto done = [&barrier]() { barrier.Notify(); };
-    ParallelForAsync(start, end, granularity, do_func, done, thread_pool);
+    ParallelForAsync(start, end, granularity, std::forward<DoFnType>(do_func), done, thread_pool);
     barrier.Wait();
   }
 
@@ -92,13 +97,13 @@
   // Schedules `right_thunk`, runs `left_thunk`, and runs other tasks until `right_thunk` has finished.
   template <typename LeftType, typename RightType, typename ThreadPoolEnv>
   static void ForkJoin(LeftType&& left_thunk, RightType&& right_thunk, ThreadPoolTempl<ThreadPoolEnv>* thread_pool) {
-    typedef typename ThreadPoolTempl<ThreadPoolEnv>::Task Task;
+    using Task = typename ThreadPoolTempl<ThreadPoolEnv>::Task;
     std::atomic<bool> right_done(false);
     auto execute_right = [&right_thunk, &right_done]() {
       std::forward<RightType>(right_thunk)();
       right_done.store(true, std::memory_order_release);
     };
-    thread_pool->Schedule(execute_right);
+    thread_pool->Schedule(std::move(execute_right));
     std::forward<LeftType>(left_thunk)();
     Task task;
     while (!right_done.load(std::memory_order_acquire)) {
@@ -108,7 +113,7 @@
   }
 
   static Index ComputeMidpoint(Index start, Index end, Index granularity) {
-    // Typical workloads choose initial values of `{start, end, granularity}` such that `start - end` and
+    // Typical workloads choose initial values of `{start, end, granularity}` such that `end - start` and
     // `granularity` are powers of two. Since modern processors usually implement (2^x)-way
     // set-associative caches, we minimize the number of cache misses by choosing midpoints that are not
     // powers of two (to avoid having two addresses in the main memory pointing to the same point in the
diff --git a/Eigen/src/ThreadPool/InternalHeaderCheck.h b/Eigen/src/ThreadPool/InternalHeaderCheck.h
index 4384cc6..a3f9a32 100644
--- a/Eigen/src/ThreadPool/InternalHeaderCheck.h
+++ b/Eigen/src/ThreadPool/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_THREADPOOL_MODULE_H
 #error "Please include Eigen/ThreadPool instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/ThreadPool/NonBlockingThreadPool.h b/Eigen/src/ThreadPool/NonBlockingThreadPool.h
index 98d1332..7bacf52 100644
--- a/Eigen/src/ThreadPool/NonBlockingThreadPool.h
+++ b/Eigen/src/ThreadPool/NonBlockingThreadPool.h
@@ -6,9 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_NONBLOCKING_THREAD_POOL_H
-#define EIGEN_CXX11_THREADPOOL_NONBLOCKING_THREAD_POOL_H
+#ifndef EIGEN_THREADPOOL_NONBLOCKING_THREAD_POOL_H
+#define EIGEN_THREADPOOL_NONBLOCKING_THREAD_POOL_H
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
@@ -18,21 +19,20 @@
 template <typename Environment>
 class ThreadPoolTempl : public Eigen::ThreadPoolInterface {
  public:
-  typedef typename Environment::EnvThread Thread;
-  typedef typename Environment::Task Task;
-  typedef RunQueue<Task, 1024> Queue;
+  using Thread = typename Environment::EnvThread;
+  using Task = typename Environment::Task;
+  using Queue = RunQueue<Task, 1024>;
 
   struct PerThread {
-    constexpr PerThread() : pool(NULL), rand(0), thread_id(-1) {}
-    ThreadPoolTempl* pool;  // Parent pool, or null for normal threads.
-    uint64_t rand;          // Random generator state.
-    int thread_id;          // Worker thread index in pool.
+    ThreadPoolTempl* pool = nullptr;  // Parent pool, or null for normal threads.
+    uint64_t rand = 0;                // Random generator state.
+    int thread_id = -1;               // Worker thread index in pool.
   };
 
   struct ThreadData {
-    constexpr ThreadData() : thread(), steal_partition(0), queue() {}
+    constexpr ThreadData() = default;
     std::unique_ptr<Thread> thread;
-    std::atomic<unsigned> steal_partition;
+    std::atomic<unsigned> steal_partition{0};
     Queue queue;
   };
 
@@ -44,7 +44,7 @@
         allow_spinning_(allow_spinning),
         spin_count_(
             // TODO(dvyukov,rmlarsen): The time spent in NonEmptyQueueIndex() is proportional to num_threads_ and
-            // we assume that new work is scheduled at a constant rate, so we divide `kSpintCount` by number of
+            // we assume that new work is scheduled at a constant rate, so we divide `kSpinCount` by number of
             // threads and number of spinning threads. The constant was picked based on a fair dice roll, tune it.
             allow_spinning && num_threads > 0 ? kSpinCount / kMaxSpinningThreads / num_threads : 0),
         thread_data_(num_threads),
@@ -62,7 +62,7 @@
     // and NonEmptyQueueIndex. Iteration is based on the fact that if we take
     // a random starting thread index t and calculate num_threads - 1 subsequent
     // indices as (t + coprime) % num_threads, we will cover all threads without
-    // repetitions (effectively getting a presudo-random permutation of thread
+    // repetitions (effectively getting a pseudo-random permutation of thread
     // indices).
     eigen_plain_assert(num_threads_ < kMaxThreads);
     for (int i = 1; i <= num_threads_; ++i) {
@@ -70,7 +70,7 @@
       ComputeCoprimes(i, &all_coprimes_.back());
     }
 #ifndef EIGEN_THREAD_LOCAL
-    init_barrier_.reset(new Barrier(num_threads_));
+    init_barrier_ = std::make_unique<Barrier>(num_threads_);
 #endif
     thread_data_.resize(num_threads_);
     for (int i = 0; i < num_threads_; i++) {
@@ -137,10 +137,10 @@
       Queue& q = thread_data_[start + rnd].queue;
       t = q.PushBack(std::move(t));
     }
-    // Note: below we touch this after making w available to worker threads.
+    // Note: below we touch this after making t available to worker threads.
     // Strictly speaking, this can lead to a racy-use-after-free. Consider that
     // Schedule is called from a thread that is neither main thread nor a worker
-    // thread of this pool. Then, execution of w directly or indirectly
+    // thread of this pool. Then, execution of t directly or indirectly
     // completes overall computations, which in turn leads to destruction of
     // this. We expect that such scenario is prevented by program, that is,
     // this is kept alive while any threads can potentially be in Schedule.
@@ -179,8 +179,7 @@
           // Notify `spinning_state_` that we are no longer spinning.
           bool has_no_notify_task = StopSpinning();
           // A suppressed notification can belong to a different task than the
-          // one we just stole. Pass it on before executing a potentially
-          // blocking task.
+          // one we just stole. Pass it on before executing a potentially blocking task.
           if (has_no_notify_task) {
             if (t->f) {
               if (NonEmptyQueueIndex() != -1) ec_.Notify(false);
@@ -242,6 +241,8 @@
     eigen_plain_assert(start >= 0);
     eigen_plain_assert(start < end);  // non-zero sized partition
     eigen_plain_assert(end <= num_threads_);
+    (void)start;
+    (void)end;
   }
 
   inline void SetStealPartition(size_t i, unsigned val) {
@@ -337,13 +338,12 @@
   std::unordered_map<uint64_t, std::unique_ptr<PerThread>> per_thread_map_;
 #endif
 
-  unsigned NumBlockedThreads() const { return blocked_.load(); }
   unsigned NumActiveThreads() const { return num_threads_ - blocked_.load(); }
 
   // Main worker thread loop.
   void WorkerLoop(int thread_id) {
 #ifndef EIGEN_THREAD_LOCAL
-    std::unique_ptr<PerThread> new_pt(new PerThread());
+    auto new_pt = std::make_unique<PerThread>();
     per_thread_map_mutex_.lock();
     bool insertOK = per_thread_map_.emplace(GlobalThreadIdHash(), std::move(new_pt)).second;
     eigen_plain_assert(insertOK);
@@ -526,8 +526,7 @@
       if (has_no_notify_task) --state.num_no_notification;
 
       // Acquire the queue publication paired with the suppressed notification.
-      if (spinning_state_.compare_exchange_weak(spinning, state.Encode(),
-                                                std::memory_order_acquire)) {
+      if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), std::memory_order_acquire)) {
         return has_no_notify_task;
       }
     }
@@ -551,8 +550,7 @@
       ++state.num_no_notification;
 
       // Publish the queued task to the spinner that consumes this notification.
-      if (spinning_state_.compare_exchange_weak(spinning, state.Encode(),
-                                                std::memory_order_release,
+      if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), std::memory_order_release,
                                                 std::memory_order_relaxed)) {
         return false;
       }
@@ -588,8 +586,8 @@
   }
 };
 
-typedef ThreadPoolTempl<StlThreadEnvironment> ThreadPool;
+using ThreadPool = ThreadPoolTempl<StlThreadEnvironment>;
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_NONBLOCKING_THREAD_POOL_H
+#endif  // EIGEN_THREADPOOL_NONBLOCKING_THREAD_POOL_H
diff --git a/Eigen/src/ThreadPool/RunQueue.h b/Eigen/src/ThreadPool/RunQueue.h
index e419ae7..7b92045 100644
--- a/Eigen/src/ThreadPool/RunQueue.h
+++ b/Eigen/src/ThreadPool/RunQueue.h
@@ -6,16 +6,17 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_RUNQUEUE_H
-#define EIGEN_CXX11_THREADPOOL_RUNQUEUE_H
+#ifndef EIGEN_THREADPOOL_RUNQUEUE_H
+#define EIGEN_THREADPOOL_RUNQUEUE_H
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
 
 namespace Eigen {
 
-// RunQueue is a fixed-size, partially non-blocking deque or Work items.
+// RunQueue is a fixed-size, partially non-blocking deque of Work items.
 // Operations on front of the queue must be done by a single thread (owner),
 // operations on back of the queue can be done by multiple threads concurrently.
 //
@@ -92,7 +93,7 @@
     return Work();
   }
 
-  // PopBack removes and returns the last elements in the queue.
+  // PopBack removes and returns the last element in the queue.
   Work PopBack() {
     if (Empty()) return Work();
     EIGEN_MUTEX_LOCK lock(mutex_);
@@ -188,7 +189,7 @@
     // effort to not produce false positives (claim non-empty queue as empty).
     unsigned front = front_.load(std::memory_order_acquire);
     for (;;) {
-      // Capture a consistent snapshot of front/tail.
+      // Capture a consistent snapshot of front/back.
       unsigned back = back_.load(std::memory_order_acquire);
       unsigned front1 = front_.load(std::memory_order_relaxed);
       if (front != front1) {
@@ -196,7 +197,7 @@
         std::atomic_thread_fence(std::memory_order_acquire);
         continue;
       }
-      if (NeedSizeEstimate) {
+      EIGEN_IF_CONSTEXPR (NeedSizeEstimate) {
         return CalculateSize(front, back);
       } else {
         // This value will be 0 if the queue is empty, and undefined otherwise.
@@ -227,4 +228,4 @@
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_RUNQUEUE_H
+#endif  // EIGEN_THREADPOOL_RUNQUEUE_H
diff --git a/Eigen/src/ThreadPool/ThreadCancel.h b/Eigen/src/ThreadPool/ThreadCancel.h
deleted file mode 100644
index 6f4dc67..0000000
--- a/Eigen/src/ThreadPool/ThreadCancel.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_THREADPOOL_THREAD_CANCEL_H
-#define EIGEN_CXX11_THREADPOOL_THREAD_CANCEL_H
-
-// Try to come up with a portable way to cancel a thread
-#if EIGEN_OS_GNULINUX
-#define EIGEN_THREAD_CANCEL(t) pthread_cancel(t.native_handle());
-#define EIGEN_SUPPORTS_THREAD_CANCELLATION 1
-#else
-#define EIGEN_THREAD_CANCEL(t)
-#endif
-
-#endif  // EIGEN_CXX11_THREADPOOL_THREAD_CANCEL_H
diff --git a/Eigen/src/ThreadPool/ThreadEnvironment.h b/Eigen/src/ThreadPool/ThreadEnvironment.h
index b4dd05c..578780b 100644
--- a/Eigen/src/ThreadPool/ThreadEnvironment.h
+++ b/Eigen/src/ThreadPool/ThreadEnvironment.h
@@ -6,9 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_THREAD_ENVIRONMENT_H
-#define EIGEN_CXX11_THREADPOOL_THREAD_ENVIRONMENT_H
+#ifndef EIGEN_THREADPOOL_THREAD_ENVIRONMENT_H
+#define EIGEN_THREADPOOL_THREAD_ENVIRONMENT_H
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
@@ -40,4 +41,4 @@
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_THREAD_ENVIRONMENT_H
+#endif  // EIGEN_THREADPOOL_THREAD_ENVIRONMENT_H
diff --git a/Eigen/src/ThreadPool/ThreadLocal.h b/Eigen/src/ThreadPool/ThreadLocal.h
index f3ad5cc..fbac6a5 100644
--- a/Eigen/src/ThreadPool/ThreadLocal.h
+++ b/Eigen/src/ThreadPool/ThreadLocal.h
@@ -6,9 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_THREAD_LOCAL_H
-#define EIGEN_CXX11_THREADPOOL_THREAD_LOCAL_H
+#ifndef EIGEN_THREADPOOL_THREAD_LOCAL_H
+#define EIGEN_THREADPOOL_THREAD_LOCAL_H
 
 #ifdef EIGEN_AVOID_THREAD_LOCAL
 
@@ -18,37 +19,20 @@
 
 #else
 
-#if ((EIGEN_COMP_GNUC) || __has_feature(cxx_thread_local) || EIGEN_COMP_MSVC)
 #define EIGEN_THREAD_LOCAL static thread_local
-#endif
 
-// Disable TLS for Apple and Android builds with older toolchains.
+// Disable TLS for Apple builds with deployment targets that do not support it.
 #if defined(__APPLE__)
 // Included for TARGET_OS_IPHONE, __IPHONE_OS_VERSION_MIN_REQUIRED,
-// __IPHONE_8_0.
+// __IPHONE_9_0.
 #include <Availability.h>
 #include <TargetConditionals.h>
 #endif
-// Checks whether C++11's `thread_local` storage duration specifier is
-// supported.
-#if EIGEN_COMP_CLANGAPPLE && \
-    ((EIGEN_COMP_CLANGAPPLE < 8000042) || (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0))
-// Notes: Xcode's clang did not support `thread_local` until version
-// 8, and even then not for all iOS < 9.0.
-#undef EIGEN_THREAD_LOCAL
-
-#elif defined(__ANDROID__) && EIGEN_COMP_CLANG
-// There are platforms for which TLS should not be used even though the compiler
-// makes it seem like it's supported (Android NDK < r12b for example).
-// This is primarily because of linker problems and toolchain misconfiguration:
-// TLS isn't supported until NDK r12b per
-// https://developer.android.com/ndk/downloads/revision_history.html
-
-#if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && defined(__NDK_MINOR__) && \
-    ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
+// Checks whether the `thread_local` storage duration specifier is supported.
+#if EIGEN_COMP_CLANGAPPLE && TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0
+// Notes: `thread_local` is not supported when targeting iOS versions before 9.0.
 #undef EIGEN_THREAD_LOCAL
 #endif
-#endif  // defined(__ANDROID__) && defined(__clang__)
 
 #endif  // EIGEN_AVOID_THREAD_LOCAL
 
@@ -141,7 +125,7 @@
     // to our hash-map like data structure. If we didn't find an element during
     // the initial traversal, it's guaranteed that no one else could have
     // inserted it while we are in this function. This allows to massively
-    // simplify out lock-free insert-only hash map.
+    // simplify our lock-free insert-only hash map.
 
     // Check if we already have an element for `this_thread`.
     int idx = start_idx;
@@ -168,7 +152,7 @@
     if (insertion_index >= capacity_) return SpilledLocal(this_thread);
 
     // At this point it's guaranteed that we can access to
-    // data_[insertion_index_] without a data race.
+    // data_[insertion_index] without a data race.
     data_[insertion_index].thread_id = this_thread;
     initialize_(data_[insertion_index].value);
 
@@ -286,4 +270,4 @@
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_THREAD_LOCAL_H
+#endif  // EIGEN_THREADPOOL_THREAD_LOCAL_H
diff --git a/Eigen/src/ThreadPool/ThreadPoolInterface.h b/Eigen/src/ThreadPool/ThreadPoolInterface.h
index d07c03e..3d76623 100644
--- a/Eigen/src/ThreadPool/ThreadPoolInterface.h
+++ b/Eigen/src/ThreadPool/ThreadPoolInterface.h
@@ -6,9 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_THREAD_POOL_INTERFACE_H
-#define EIGEN_CXX11_THREADPOOL_THREAD_POOL_INTERFACE_H
+#ifndef EIGEN_THREADPOOL_THREAD_POOL_INTERFACE_H
+#define EIGEN_THREADPOOL_THREAD_POOL_INTERFACE_H
 
 // IWYU pragma: private
 #include "./InternalHeaderCheck.h"
@@ -42,9 +43,9 @@
   // from one of the threads in the pool. Returns -1 otherwise.
   virtual int CurrentThreadId() const = 0;
 
-  virtual ~ThreadPoolInterface() {}
+  virtual ~ThreadPoolInterface() = default;
 };
 
 }  // namespace Eigen
 
-#endif  // EIGEN_CXX11_THREADPOOL_THREAD_POOL_INTERFACE_H
+#endif  // EIGEN_THREADPOOL_THREAD_POOL_INTERFACE_H
diff --git a/Eigen/src/ThreadPool/ThreadYield.h b/Eigen/src/ThreadPool/ThreadYield.h
index f556ff6..649214a 100644
--- a/Eigen/src/ThreadPool/ThreadYield.h
+++ b/Eigen/src/ThreadPool/ThreadYield.h
@@ -6,11 +6,12 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#ifndef EIGEN_CXX11_THREADPOOL_THREAD_YIELD_H
-#define EIGEN_CXX11_THREADPOOL_THREAD_YIELD_H
+#ifndef EIGEN_THREADPOOL_THREAD_YIELD_H
+#define EIGEN_THREADPOOL_THREAD_YIELD_H
 
 // Try to come up with a portable way to yield
 #define EIGEN_THREAD_YIELD() std::this_thread::yield()
 
-#endif  // EIGEN_CXX11_THREADPOOL_THREAD_YIELD_H
+#endif  // EIGEN_THREADPOOL_THREAD_YIELD_H
diff --git a/Eigen/src/UmfPackSupport/InternalHeaderCheck.h b/Eigen/src/UmfPackSupport/InternalHeaderCheck.h
index 64112f1..86674ca 100644
--- a/Eigen/src/UmfPackSupport/InternalHeaderCheck.h
+++ b/Eigen/src/UmfPackSupport/InternalHeaderCheck.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_UMFPACKSUPPORT_MODULE_H
 #error "Please include Eigen/UmfPackSupport instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/UmfPackSupport/UmfPackSupport.h b/Eigen/src/UmfPackSupport/UmfPackSupport.h
index 51e4db1..4313409 100644
--- a/Eigen/src/UmfPackSupport/UmfPackSupport.h
+++ b/Eigen/src/UmfPackSupport/UmfPackSupport.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_UMFPACKSUPPORT_H
 #define EIGEN_UMFPACKSUPPORT_H
@@ -287,7 +288,7 @@
  * \brief A sparse LU factorization and solver based on UmfPack
  *
  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
- * using the UmfPack library. The sparse matrix A must be squared and full rank.
+ * using the UmfPack library. The sparse matrix A must be square and full rank.
  * The vectors or matrices X and B can be either dense or sparse.
  *
  * \warning The input matrix A should be in a \b compressed and \b column-major form.
@@ -341,7 +342,7 @@
   /** \brief Reports whether previous computation was successful.
    *
    * \returns \c Success if computation was successful,
-   *          \c NumericalIssue if the matrix.appears to be negative.
+   *          \c NumericalIssue if the matrix appears to be negative.
    */
   ComputationInfo info() const {
     eigen_assert(m_isInitialized && "Decomposition is not initialized.");
@@ -368,7 +369,7 @@
     return m_q;
   }
 
-  /** Computes the sparse Cholesky decomposition of \a matrix
+  /** Computes the sparse LU decomposition of \a matrix
    *  Note that the matrix should be column-major, and in compressed format for best performance.
    *  \sa SparseMatrix::makeCompressed().
    */
diff --git a/Eigen/src/misc/Image.h b/Eigen/src/misc/Image.h
deleted file mode 100644
index 38d516e..0000000
--- a/Eigen/src/misc/Image.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MISC_IMAGE_H
-#define EIGEN_MISC_IMAGE_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \class image_retval_base
- *
- */
-template <typename DecompositionType>
-struct traits<image_retval_base<DecompositionType> > {
-  typedef typename DecompositionType::MatrixType MatrixType;
-  typedef Matrix<typename MatrixType::Scalar,
-                 MatrixType::RowsAtCompileTime,  // the image is a subspace of the destination space, whose
-                                                 // dimension is the number of rows of the original matrix
-                 Dynamic,                        // we don't know at compile time the dimension of the image (the rank)
-                 traits<MatrixType>::Options,
-                 MatrixType::MaxRowsAtCompileTime,  // the image matrix will consist of columns from the original
-                                                    // matrix,
-                 MatrixType::MaxColsAtCompileTime   // so it has the same number of rows and at most as many columns.
-                 >
-      ReturnType;
-};
-
-template <typename DecompositionType_>
-struct image_retval_base : public ReturnByValue<image_retval_base<DecompositionType_> > {
-  typedef DecompositionType_ DecompositionType;
-  typedef typename DecompositionType::MatrixType MatrixType;
-  typedef ReturnByValue<image_retval_base> Base;
-
-  image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix)
-      : m_dec(dec), m_rank(dec.rank()), m_cols(m_rank == 0 ? 1 : m_rank), m_originalMatrix(originalMatrix) {}
-
-  inline Index rows() const { return m_dec.rows(); }
-  inline Index cols() const { return m_cols; }
-  inline Index rank() const { return m_rank; }
-  inline const DecompositionType& dec() const { return m_dec; }
-  inline const MatrixType& originalMatrix() const { return m_originalMatrix; }
-
-  template <typename Dest>
-  inline void evalTo(Dest& dst) const {
-    static_cast<const image_retval<DecompositionType>*>(this)->evalTo(dst);
-  }
-
- protected:
-  const DecompositionType& m_dec;
-  Index m_rank, m_cols;
-  const MatrixType& m_originalMatrix;
-};
-
-}  // end namespace internal
-
-#define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType)                   \
-  typedef typename DecompositionType::MatrixType MatrixType;          \
-  typedef typename MatrixType::Scalar Scalar;                         \
-  typedef typename MatrixType::RealScalar RealScalar;                 \
-  typedef Eigen::internal::image_retval_base<DecompositionType> Base; \
-  using Base::dec;                                                    \
-  using Base::originalMatrix;                                         \
-  using Base::rank;                                                   \
-  using Base::rows;                                                   \
-  using Base::cols;                                                   \
-  image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) : Base(dec, originalMatrix) {}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MISC_IMAGE_H
diff --git a/Eigen/src/misc/InternalHeaderCheck.h b/Eigen/src/misc/InternalHeaderCheck.h
deleted file mode 100644
index 1cea572..0000000
--- a/Eigen/src/misc/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_CORE_MODULE_H
-#error "Please include Eigen/Core instead of including headers inside the src directory directly."
-#endif
diff --git a/Eigen/src/misc/Kernel.h b/Eigen/src/misc/Kernel.h
deleted file mode 100644
index 3ed458b..0000000
--- a/Eigen/src/misc/Kernel.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MISC_KERNEL_H
-#define EIGEN_MISC_KERNEL_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \class kernel_retval_base
- *
- */
-template <typename DecompositionType>
-struct traits<kernel_retval_base<DecompositionType> > {
-  typedef typename DecompositionType::MatrixType MatrixType;
-  typedef Matrix<typename MatrixType::Scalar,
-                 MatrixType::ColsAtCompileTime,  // the number of rows in the "kernel matrix"
-                                                 // is the number of cols of the original matrix
-                                                 // so that the product "matrix * kernel = zero" makes sense
-                 Dynamic,                        // we don't know at compile-time the dimension of the kernel
-                 traits<MatrixType>::Options,
-                 MatrixType::MaxColsAtCompileTime,  // see explanation for 2nd template parameter
-                 MatrixType::MaxColsAtCompileTime   // the kernel is a subspace of the domain space,
-                                                    // whose dimension is the number of columns of the original matrix
-                 >
-      ReturnType;
-};
-
-template <typename DecompositionType_>
-struct kernel_retval_base : public ReturnByValue<kernel_retval_base<DecompositionType_> > {
-  typedef DecompositionType_ DecompositionType;
-  typedef ReturnByValue<kernel_retval_base> Base;
-
-  explicit kernel_retval_base(const DecompositionType& dec)
-      : m_dec(dec), m_rank(dec.rank()), m_cols(m_rank == dec.cols() ? 1 : dec.cols() - m_rank) {}
-
-  inline Index rows() const { return m_dec.cols(); }
-  inline Index cols() const { return m_cols; }
-  inline Index rank() const { return m_rank; }
-  inline const DecompositionType& dec() const { return m_dec; }
-
-  template <typename Dest>
-  inline void evalTo(Dest& dst) const {
-    static_cast<const kernel_retval<DecompositionType>*>(this)->evalTo(dst);
-  }
-
- protected:
-  const DecompositionType& m_dec;
-  Index m_rank, m_cols;
-};
-
-}  // end namespace internal
-
-#define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType)                   \
-  typedef typename DecompositionType::MatrixType MatrixType;           \
-  typedef typename MatrixType::Scalar Scalar;                          \
-  typedef typename MatrixType::RealScalar RealScalar;                  \
-  typedef Eigen::internal::kernel_retval_base<DecompositionType> Base; \
-  using Base::dec;                                                     \
-  using Base::rank;                                                    \
-  using Base::rows;                                                    \
-  using Base::cols;                                                    \
-  kernel_retval(const DecompositionType& dec) : Base(dec) {}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MISC_KERNEL_H
diff --git a/Eigen/src/misc/blas.h b/Eigen/src/misc/blas.h
deleted file mode 100644
index f12bc7c..0000000
--- a/Eigen/src/misc/blas.h
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifndef EIGEN_MISC_BLAS_H
-#define EIGEN_MISC_BLAS_H
-
-extern "C" {
-
-#define BLASFUNC(FUNC) FUNC##_
-
-/* Level 1 routines */
-
-void BLASFUNC(saxpy)(const int *, const float *, const float *, const int *, float *, const int *);
-void BLASFUNC(daxpy)(const int *, const double *, const double *, const int *, double *, const int *);
-void BLASFUNC(caxpy)(const int *, const float *, const float *, const int *, float *, const int *);
-void BLASFUNC(zaxpy)(const int *, const double *, const double *, const int *, double *, const int *);
-
-/* Level 2 routines */
-
-void BLASFUNC(sgemv)(const char *, const int *, const int *, const float *, const float *, const int *, const float *,
-                     const int *, const float *, float *, const int *);
-void BLASFUNC(dgemv)(const char *, const int *, const int *, const double *, const double *, const int *,
-                     const double *, const int *, const double *, double *, const int *);
-void BLASFUNC(cgemv)(const char *, const int *, const int *, const float *, const float *, const int *, const float *,
-                     const int *, const float *, float *, const int *);
-void BLASFUNC(zgemv)(const char *, const int *, const int *, const double *, const double *, const int *,
-                     const double *, const int *, const double *, double *, const int *);
-
-void BLASFUNC(strmv)(const char *, const char *, const char *, const int *, const float *, const int *, float *,
-                     const int *);
-void BLASFUNC(dtrmv)(const char *, const char *, const char *, const int *, const double *, const int *, double *,
-                     const int *);
-void BLASFUNC(ctrmv)(const char *, const char *, const char *, const int *, const float *, const int *, float *,
-                     const int *);
-void BLASFUNC(ztrmv)(const char *, const char *, const char *, const int *, const double *, const int *, double *,
-                     const int *);
-
-void BLASFUNC(ssymv)(const char *, const int *, const float *, const float *, const int *, const float *, const int *,
-                     const float *, float *, const int *);
-void BLASFUNC(dsymv)(const char *, const int *, const double *, const double *, const int *, const double *,
-                     const int *, const double *, double *, const int *);
-
-void BLASFUNC(chemv)(const char *, const int *, const float *, const float *, const int *, const float *, const int *,
-                     const float *, float *, const int *);
-void BLASFUNC(zhemv)(const char *, const int *, const double *, const double *, const int *, const double *,
-                     const int *, const double *, double *, const int *);
-
-/* Level 3 routines */
-
-void BLASFUNC(sgemm)(const char *, const char *, const int *, const int *, const int *, const float *, const float *,
-                     const int *, const float *, const int *, const float *, float *, const int *);
-void BLASFUNC(dgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *,
-                     const int *, const double *, const int *, const double *, double *, const int *);
-void BLASFUNC(cgemm)(const char *, const char *, const int *, const int *, const int *, const float *, const float *,
-                     const int *, const float *, const int *, const float *, float *, const int *);
-void BLASFUNC(zgemm)(const char *, const char *, const int *, const int *, const int *, const double *, const double *,
-                     const int *, const double *, const int *, const double *, double *, const int *);
-
-void BLASFUNC(strsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,
-                     const float *, const int *, float *, const int *);
-void BLASFUNC(dtrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *,
-                     const double *, const int *, double *, const int *);
-void BLASFUNC(ctrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,
-                     const float *, const int *, float *, const int *);
-void BLASFUNC(ztrsm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *,
-                     const double *, const int *, double *, const int *);
-
-void BLASFUNC(strmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,
-                     const float *, const int *, float *, const int *);
-void BLASFUNC(dtrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *,
-                     const double *, const int *, double *, const int *);
-void BLASFUNC(ctrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const float *,
-                     const float *, const int *, float *, const int *);
-void BLASFUNC(ztrmm)(const char *, const char *, const char *, const char *, const int *, const int *, const double *,
-                     const double *, const int *, double *, const int *);
-
-void BLASFUNC(ssymm)(const char *, const char *, const int *, const int *, const float *, const float *, const int *,
-                     const float *, const int *, const float *, float *, const int *);
-void BLASFUNC(dsymm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *,
-                     const double *, const int *, const double *, double *, const int *);
-
-void BLASFUNC(ssyrk)(const char *, const char *, const int *, const int *, const float *, const float *, const int *,
-                     const float *, float *, const int *);
-void BLASFUNC(dsyrk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *,
-                     const double *, double *, const int *);
-
-void BLASFUNC(chemm)(const char *, const char *, const int *, const int *, const float *, const float *, const int *,
-                     const float *, const int *, const float *, float *, const int *);
-void BLASFUNC(zhemm)(const char *, const char *, const int *, const int *, const double *, const double *, const int *,
-                     const double *, const int *, const double *, double *, const int *);
-
-void BLASFUNC(cherk)(const char *, const char *, const int *, const int *, const float *, const float *, const int *,
-                     const float *, float *, const int *);
-void BLASFUNC(zherk)(const char *, const char *, const int *, const int *, const double *, const double *, const int *,
-                     const double *, double *, const int *);
-
-#undef BLASFUNC
-}
-
-#endif
diff --git a/Eigen/src/misc/lapacke.h b/Eigen/src/misc/lapacke.h
deleted file mode 100644
index 94afd50..0000000
--- a/Eigen/src/misc/lapacke.h
+++ /dev/null
@@ -1,10085 +0,0 @@
-/*****************************************************************************
-  Copyright (c) 2010, Intel Corp.
-  All rights reserved.
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Intel Corporation nor the names of its contributors
-      may be used to endorse or promote products derived from this software
-      without specific prior written permission.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-  THE POSSIBILITY OF SUCH DAMAGE.
-******************************************************************************
-* Contents: Native C interface to LAPACK
-* Author: Intel Corporation
-* Generated November, 2011
-*****************************************************************************/
-
-#ifndef _MKL_LAPACKE_H_
-
-#ifndef _LAPACKE_H_
-#define _LAPACKE_H_
-
-/*
- *  Turn on HAVE_LAPACK_CONFIG_H to redefine C-LAPACK datatypes
- */
-#ifdef HAVE_LAPACK_CONFIG_H
-#include "lapacke_config.h"
-#endif
-
-#include <stdlib.h>
-
-#ifndef lapack_int
-#ifdef LAPACK_ILP64
-#define lapack_int int64_t
-#else
-#define lapack_int int
-#endif
-#endif
-
-#ifndef lapack_logical
-#define lapack_logical lapack_int
-#endif
-
-/* Complex types are structures equivalent to the
- * Fortran complex types COMPLEX(4) and COMPLEX(8).
- *
- * One can also redefine the types with his own types
- * for example by including in the code definitions like
- *
- * #define lapack_complex_float std::complex<float>
- * #define lapack_complex_double std::complex<double>
- *
- * or define these types in the command line:
- *
- * -Dlapack_complex_float="std::complex<float>"
- * -Dlapack_complex_double="std::complex<double>"
- */
-
-#ifndef LAPACK_COMPLEX_CUSTOM
-
-/* Complex type (single precision) */
-#ifndef lapack_complex_float
-#define lapack_complex_float std::complex<float>
-#endif
-
-#ifndef lapack_complex_float_real
-#define lapack_complex_float_real(z) (creal(z))
-#endif
-
-#ifndef lapack_complex_float_imag
-#define lapack_complex_float_imag(z) (cimag(z))
-#endif
-
-lapack_complex_float lapack_make_complex_float(float re, float im);
-
-/* Complex type (double precision) */
-#ifndef lapack_complex_double
-#define lapack_complex_double std::complex<double>
-#endif
-
-#ifndef lapack_complex_double_real
-#define lapack_complex_double_real(z) (creal(z))
-#endif
-
-#ifndef lapack_complex_double_imag
-#define lapack_complex_double_imag(z) (cimag(z))
-#endif
-
-lapack_complex_double lapack_make_complex_double(double re, double im);
-
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#ifndef LAPACKE_malloc
-#define LAPACKE_malloc(size) malloc(size)
-#endif
-#ifndef LAPACKE_free
-#define LAPACKE_free(p) free(p)
-#endif
-
-#define LAPACK_C2INT(x) (lapack_int)(*((float*)&x))
-#define LAPACK_Z2INT(x) (lapack_int)(*((double*)&x))
-
-#define LAPACK_ROW_MAJOR 101
-#define LAPACK_COL_MAJOR 102
-
-#define LAPACK_WORK_MEMORY_ERROR -1010
-#define LAPACK_TRANSPOSE_MEMORY_ERROR -1011
-
-/* Callback logical functions of one, two, or three arguments are used
- *  to select eigenvalues to sort to the top left of the Schur form.
- *  The value is selected if function returns TRUE (non-zero). */
-
-typedef lapack_logical (*LAPACK_S_SELECT2)(const float*, const float*);
-typedef lapack_logical (*LAPACK_S_SELECT3)(const float*, const float*, const float*);
-typedef lapack_logical (*LAPACK_D_SELECT2)(const double*, const double*);
-typedef lapack_logical (*LAPACK_D_SELECT3)(const double*, const double*, const double*);
-
-typedef lapack_logical (*LAPACK_C_SELECT1)(const lapack_complex_float*);
-typedef lapack_logical (*LAPACK_C_SELECT2)(const lapack_complex_float*, const lapack_complex_float*);
-typedef lapack_logical (*LAPACK_Z_SELECT1)(const lapack_complex_double*);
-typedef lapack_logical (*LAPACK_Z_SELECT2)(const lapack_complex_double*, const lapack_complex_double*);
-
-#include "lapacke_mangling.h"
-
-#define LAPACK_lsame LAPACK_GLOBAL(lsame, LSAME)
-lapack_logical LAPACK_lsame(char* ca, char* cb, lapack_int lca, lapack_int lcb);
-
-/* C-LAPACK function prototypes */
-
-lapack_int LAPACKE_sbdsdc(int matrix_order, char uplo, char compq, lapack_int n, float* d, float* e, float* u,
-                          lapack_int ldu, float* vt, lapack_int ldvt, float* q, lapack_int* iq);
-lapack_int LAPACKE_dbdsdc(int matrix_order, char uplo, char compq, lapack_int n, double* d, double* e, double* u,
-                          lapack_int ldu, double* vt, lapack_int ldvt, double* q, lapack_int* iq);
-
-lapack_int LAPACKE_sbdsqr(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru, lapack_int ncc,
-                          float* d, float* e, float* vt, lapack_int ldvt, float* u, lapack_int ldu, float* c,
-                          lapack_int ldc);
-lapack_int LAPACKE_dbdsqr(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru, lapack_int ncc,
-                          double* d, double* e, double* vt, lapack_int ldvt, double* u, lapack_int ldu, double* c,
-                          lapack_int ldc);
-lapack_int LAPACKE_cbdsqr(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru, lapack_int ncc,
-                          float* d, float* e, lapack_complex_float* vt, lapack_int ldvt, lapack_complex_float* u,
-                          lapack_int ldu, lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zbdsqr(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru, lapack_int ncc,
-                          double* d, double* e, lapack_complex_double* vt, lapack_int ldvt, lapack_complex_double* u,
-                          lapack_int ldu, lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sdisna(char job, lapack_int m, lapack_int n, const float* d, float* sep);
-lapack_int LAPACKE_ddisna(char job, lapack_int m, lapack_int n, const double* d, double* sep);
-
-lapack_int LAPACKE_sgbbrd(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                          lapack_int ku, float* ab, lapack_int ldab, float* d, float* e, float* q, lapack_int ldq,
-                          float* pt, lapack_int ldpt, float* c, lapack_int ldc);
-lapack_int LAPACKE_dgbbrd(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                          lapack_int ku, double* ab, lapack_int ldab, double* d, double* e, double* q, lapack_int ldq,
-                          double* pt, lapack_int ldpt, double* c, lapack_int ldc);
-lapack_int LAPACKE_cgbbrd(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                          lapack_int ku, lapack_complex_float* ab, lapack_int ldab, float* d, float* e,
-                          lapack_complex_float* q, lapack_int ldq, lapack_complex_float* pt, lapack_int ldpt,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zgbbrd(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                          lapack_int ku, lapack_complex_double* ab, lapack_int ldab, double* d, double* e,
-                          lapack_complex_double* q, lapack_int ldq, lapack_complex_double* pt, lapack_int ldpt,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sgbcon(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku, const float* ab,
-                          lapack_int ldab, const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_dgbcon(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku, const double* ab,
-                          lapack_int ldab, const lapack_int* ipiv, double anorm, double* rcond);
-lapack_int LAPACKE_cgbcon(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku,
-                          const lapack_complex_float* ab, lapack_int ldab, const lapack_int* ipiv, float anorm,
-                          float* rcond);
-lapack_int LAPACKE_zgbcon(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku,
-                          const lapack_complex_double* ab, lapack_int ldab, const lapack_int* ipiv, double anorm,
-                          double* rcond);
-
-lapack_int LAPACKE_sgbequ(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float* ab,
-                          lapack_int ldab, float* r, float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_dgbequ(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double* ab,
-                          lapack_int ldab, double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-lapack_int LAPACKE_cgbequ(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                          const lapack_complex_float* ab, lapack_int ldab, float* r, float* c, float* rowcnd,
-                          float* colcnd, float* amax);
-lapack_int LAPACKE_zgbequ(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                          const lapack_complex_double* ab, lapack_int ldab, double* r, double* c, double* rowcnd,
-                          double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgbequb(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float* ab,
-                           lapack_int ldab, float* r, float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_dgbequb(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double* ab,
-                           lapack_int ldab, double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-lapack_int LAPACKE_cgbequb(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                           const lapack_complex_float* ab, lapack_int ldab, float* r, float* c, float* rowcnd,
-                           float* colcnd, float* amax);
-lapack_int LAPACKE_zgbequb(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                           const lapack_complex_double* ab, lapack_int ldab, double* r, double* c, double* rowcnd,
-                           double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgbrfs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const float* ab, lapack_int ldab, const float* afb, lapack_int ldafb, const lapack_int* ipiv,
-                          const float* b, lapack_int ldb, float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dgbrfs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const double* ab, lapack_int ldab, const double* afb, lapack_int ldafb,
-                          const lapack_int* ipiv, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-lapack_int LAPACKE_cgbrfs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const lapack_complex_float* ab, lapack_int ldab, const lapack_complex_float* afb,
-                          lapack_int ldafb, const lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_zgbrfs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const lapack_complex_double* ab, lapack_int ldab, const lapack_complex_double* afb,
-                          lapack_int ldafb, const lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_sgbrfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, const float* ab, lapack_int ldab, const float* afb, lapack_int ldafb,
-                           const lapack_int* ipiv, const float* r, const float* c, const float* b, lapack_int ldb,
-                           float* x, lapack_int ldx, float* rcond, float* berr, lapack_int n_err_bnds,
-                           float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_dgbrfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, const double* ab, lapack_int ldab, const double* afb, lapack_int ldafb,
-                           const lapack_int* ipiv, const double* r, const double* c, const double* b, lapack_int ldb,
-                           double* x, lapack_int ldx, double* rcond, double* berr, lapack_int n_err_bnds,
-                           double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params);
-lapack_int LAPACKE_cgbrfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab,
-                           const lapack_complex_float* afb, lapack_int ldafb, const lapack_int* ipiv, const float* r,
-                           const float* c, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                           lapack_int ldx, float* rcond, float* berr, lapack_int n_err_bnds, float* err_bnds_norm,
-                           float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_zgbrfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                           const lapack_complex_double* afb, lapack_int ldafb, const lapack_int* ipiv, const double* r,
-                           const double* c, const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                           lapack_int ldx, double* rcond, double* berr, lapack_int n_err_bnds, double* err_bnds_norm,
-                           double* err_bnds_comp, lapack_int nparams, double* params);
-
-lapack_int LAPACKE_sgbsv(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs, float* ab,
-                         lapack_int ldab, lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgbsv(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs, double* ab,
-                         lapack_int ldab, lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgbsv(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                         lapack_complex_float* ab, lapack_int ldab, lapack_int* ipiv, lapack_complex_float* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_zgbsv(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                         lapack_complex_double* ab, lapack_int ldab, lapack_int* ipiv, lapack_complex_double* b,
-                         lapack_int ldb);
-
-lapack_int LAPACKE_sgbsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                          lapack_int nrhs, float* ab, lapack_int ldab, float* afb, lapack_int ldafb, lapack_int* ipiv,
-                          char* equed, float* r, float* c, float* b, lapack_int ldb, float* x, lapack_int ldx,
-                          float* rcond, float* ferr, float* berr, float* rpivot);
-lapack_int LAPACKE_dgbsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                          lapack_int nrhs, double* ab, lapack_int ldab, double* afb, lapack_int ldafb, lapack_int* ipiv,
-                          char* equed, double* r, double* c, double* b, lapack_int ldb, double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr, double* rpivot);
-lapack_int LAPACKE_cgbsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                          lapack_int nrhs, lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* afb,
-                          lapack_int ldafb, lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b,
-                          lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* ferr,
-                          float* berr, float* rpivot);
-lapack_int LAPACKE_zgbsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                          lapack_int nrhs, lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* afb,
-                          lapack_int ldafb, lapack_int* ipiv, char* equed, double* r, double* c,
-                          lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr, double* rpivot);
-
-lapack_int LAPACKE_sgbsvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, float* ab, lapack_int ldab, float* afb, lapack_int ldafb, lapack_int* ipiv,
-                           char* equed, float* r, float* c, float* b, lapack_int ldb, float* x, lapack_int ldx,
-                           float* rcond, float* rpvgrw, float* berr, lapack_int n_err_bnds, float* err_bnds_norm,
-                           float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_dgbsvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, double* ab, lapack_int ldab, double* afb, lapack_int ldafb,
-                           lapack_int* ipiv, char* equed, double* r, double* c, double* b, lapack_int ldb, double* x,
-                           lapack_int ldx, double* rcond, double* rpvgrw, double* berr, lapack_int n_err_bnds,
-                           double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params);
-lapack_int LAPACKE_cgbsvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* afb,
-                           lapack_int ldafb, lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b,
-                           lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw,
-                           float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                           lapack_int nparams, float* params);
-lapack_int LAPACKE_zgbsvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                           lapack_int nrhs, lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* afb,
-                           lapack_int ldafb, lapack_int* ipiv, char* equed, double* r, double* c,
-                           lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                           double* rcond, double* rpvgrw, double* berr, lapack_int n_err_bnds, double* err_bnds_norm,
-                           double* err_bnds_comp, lapack_int nparams, double* params);
-
-lapack_int LAPACKE_sgbtrf(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, float* ab,
-                          lapack_int ldab, lapack_int* ipiv);
-lapack_int LAPACKE_dgbtrf(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, double* ab,
-                          lapack_int ldab, lapack_int* ipiv);
-lapack_int LAPACKE_cgbtrf(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                          lapack_complex_float* ab, lapack_int ldab, lapack_int* ipiv);
-lapack_int LAPACKE_zgbtrf(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                          lapack_complex_double* ab, lapack_int ldab, lapack_int* ipiv);
-
-lapack_int LAPACKE_sgbtrs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const float* ab, lapack_int ldab, const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgbtrs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const double* ab, lapack_int ldab, const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgbtrs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const lapack_complex_float* ab, lapack_int ldab, const lapack_int* ipiv,
-                          lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgbtrs(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                          const lapack_complex_double* ab, lapack_int ldab, const lapack_int* ipiv,
-                          lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sgebak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const float* scale, lapack_int m, float* v, lapack_int ldv);
-lapack_int LAPACKE_dgebak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const double* scale, lapack_int m, double* v, lapack_int ldv);
-lapack_int LAPACKE_cgebak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const float* scale, lapack_int m, lapack_complex_float* v, lapack_int ldv);
-lapack_int LAPACKE_zgebak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const double* scale, lapack_int m, lapack_complex_double* v, lapack_int ldv);
-
-lapack_int LAPACKE_sgebal(int matrix_order, char job, lapack_int n, float* a, lapack_int lda, lapack_int* ilo,
-                          lapack_int* ihi, float* scale);
-lapack_int LAPACKE_dgebal(int matrix_order, char job, lapack_int n, double* a, lapack_int lda, lapack_int* ilo,
-                          lapack_int* ihi, double* scale);
-lapack_int LAPACKE_cgebal(int matrix_order, char job, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* ilo, lapack_int* ihi, float* scale);
-lapack_int LAPACKE_zgebal(int matrix_order, char job, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* ilo, lapack_int* ihi, double* scale);
-
-lapack_int LAPACKE_sgebrd(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* d, float* e,
-                          float* tauq, float* taup);
-lapack_int LAPACKE_dgebrd(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* d, double* e,
-                          double* tauq, double* taup);
-lapack_int LAPACKE_cgebrd(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          float* d, float* e, lapack_complex_float* tauq, lapack_complex_float* taup);
-lapack_int LAPACKE_zgebrd(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          double* d, double* e, lapack_complex_double* tauq, lapack_complex_double* taup);
-
-lapack_int LAPACKE_sgecon(int matrix_order, char norm, lapack_int n, const float* a, lapack_int lda, float anorm,
-                          float* rcond);
-lapack_int LAPACKE_dgecon(int matrix_order, char norm, lapack_int n, const double* a, lapack_int lda, double anorm,
-                          double* rcond);
-lapack_int LAPACKE_cgecon(int matrix_order, char norm, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                          float anorm, float* rcond);
-lapack_int LAPACKE_zgecon(int matrix_order, char norm, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          double anorm, double* rcond);
-
-lapack_int LAPACKE_sgeequ(int matrix_order, lapack_int m, lapack_int n, const float* a, lapack_int lda, float* r,
-                          float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_dgeequ(int matrix_order, lapack_int m, lapack_int n, const double* a, lapack_int lda, double* r,
-                          double* c, double* rowcnd, double* colcnd, double* amax);
-lapack_int LAPACKE_cgeequ(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                          float* r, float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_zgeequ(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgeequb(int matrix_order, lapack_int m, lapack_int n, const float* a, lapack_int lda, float* r,
-                           float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_dgeequb(int matrix_order, lapack_int m, lapack_int n, const double* a, lapack_int lda, double* r,
-                           double* c, double* rowcnd, double* colcnd, double* amax);
-lapack_int LAPACKE_cgeequb(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                           float* r, float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_zgeequb(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                           double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgees(int matrix_order, char jobvs, char sort, LAPACK_S_SELECT2 select, lapack_int n, float* a,
-                         lapack_int lda, lapack_int* sdim, float* wr, float* wi, float* vs, lapack_int ldvs);
-lapack_int LAPACKE_dgees(int matrix_order, char jobvs, char sort, LAPACK_D_SELECT2 select, lapack_int n, double* a,
-                         lapack_int lda, lapack_int* sdim, double* wr, double* wi, double* vs, lapack_int ldvs);
-lapack_int LAPACKE_cgees(int matrix_order, char jobvs, char sort, LAPACK_C_SELECT1 select, lapack_int n,
-                         lapack_complex_float* a, lapack_int lda, lapack_int* sdim, lapack_complex_float* w,
-                         lapack_complex_float* vs, lapack_int ldvs);
-lapack_int LAPACKE_zgees(int matrix_order, char jobvs, char sort, LAPACK_Z_SELECT1 select, lapack_int n,
-                         lapack_complex_double* a, lapack_int lda, lapack_int* sdim, lapack_complex_double* w,
-                         lapack_complex_double* vs, lapack_int ldvs);
-
-lapack_int LAPACKE_sgeesx(int matrix_order, char jobvs, char sort, LAPACK_S_SELECT2 select, char sense, lapack_int n,
-                          float* a, lapack_int lda, lapack_int* sdim, float* wr, float* wi, float* vs, lapack_int ldvs,
-                          float* rconde, float* rcondv);
-lapack_int LAPACKE_dgeesx(int matrix_order, char jobvs, char sort, LAPACK_D_SELECT2 select, char sense, lapack_int n,
-                          double* a, lapack_int lda, lapack_int* sdim, double* wr, double* wi, double* vs,
-                          lapack_int ldvs, double* rconde, double* rcondv);
-lapack_int LAPACKE_cgeesx(int matrix_order, char jobvs, char sort, LAPACK_C_SELECT1 select, char sense, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_int* sdim, lapack_complex_float* w,
-                          lapack_complex_float* vs, lapack_int ldvs, float* rconde, float* rcondv);
-lapack_int LAPACKE_zgeesx(int matrix_order, char jobvs, char sort, LAPACK_Z_SELECT1 select, char sense, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_int* sdim, lapack_complex_double* w,
-                          lapack_complex_double* vs, lapack_int ldvs, double* rconde, double* rcondv);
-
-lapack_int LAPACKE_sgeev(int matrix_order, char jobvl, char jobvr, lapack_int n, float* a, lapack_int lda, float* wr,
-                         float* wi, float* vl, lapack_int ldvl, float* vr, lapack_int ldvr);
-lapack_int LAPACKE_dgeev(int matrix_order, char jobvl, char jobvr, lapack_int n, double* a, lapack_int lda, double* wr,
-                         double* wi, double* vl, lapack_int ldvl, double* vr, lapack_int ldvr);
-lapack_int LAPACKE_cgeev(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_float* a,
-                         lapack_int lda, lapack_complex_float* w, lapack_complex_float* vl, lapack_int ldvl,
-                         lapack_complex_float* vr, lapack_int ldvr);
-lapack_int LAPACKE_zgeev(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_double* a,
-                         lapack_int lda, lapack_complex_double* w, lapack_complex_double* vl, lapack_int ldvl,
-                         lapack_complex_double* vr, lapack_int ldvr);
-
-lapack_int LAPACKE_sgeevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n, float* a,
-                          lapack_int lda, float* wr, float* wi, float* vl, lapack_int ldvl, float* vr, lapack_int ldvr,
-                          lapack_int* ilo, lapack_int* ihi, float* scale, float* abnrm, float* rconde, float* rcondv);
-lapack_int LAPACKE_dgeevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n, double* a,
-                          lapack_int lda, double* wr, double* wi, double* vl, lapack_int ldvl, double* vr,
-                          lapack_int ldvr, lapack_int* ilo, lapack_int* ihi, double* scale, double* abnrm,
-                          double* rconde, double* rcondv);
-lapack_int LAPACKE_cgeevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* w, lapack_complex_float* vl,
-                          lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
-                          float* scale, float* abnrm, float* rconde, float* rcondv);
-lapack_int LAPACKE_zgeevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* w, lapack_complex_double* vl,
-                          lapack_int ldvl, lapack_complex_double* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
-                          double* scale, double* abnrm, double* rconde, double* rcondv);
-
-lapack_int LAPACKE_sgehrd(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, float* a, lapack_int lda,
-                          float* tau);
-lapack_int LAPACKE_dgehrd(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, double* a, lapack_int lda,
-                          double* tau);
-lapack_int LAPACKE_cgehrd(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* tau);
-lapack_int LAPACKE_zgehrd(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgejsv(int matrix_order, char joba, char jobu, char jobv, char jobr, char jobt, char jobp,
-                          lapack_int m, lapack_int n, float* a, lapack_int lda, float* sva, float* u, lapack_int ldu,
-                          float* v, lapack_int ldv, float* stat, lapack_int* istat);
-lapack_int LAPACKE_dgejsv(int matrix_order, char joba, char jobu, char jobv, char jobr, char jobt, char jobp,
-                          lapack_int m, lapack_int n, double* a, lapack_int lda, double* sva, double* u, lapack_int ldu,
-                          double* v, lapack_int ldv, double* stat, lapack_int* istat);
-
-lapack_int LAPACKE_sgelq2(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgelq2(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgelq2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zgelq2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgelqf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgelqf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgelqf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zgelqf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgels(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs, float* a,
-                         lapack_int lda, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgels(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs, double* a,
-                         lapack_int lda, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgels(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs,
-                         lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgels(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs,
-                         lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sgelsd(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                          float* b, lapack_int ldb, float* s, float rcond, lapack_int* rank);
-lapack_int LAPACKE_dgelsd(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                          double* b, lapack_int ldb, double* s, double rcond, lapack_int* rank);
-lapack_int LAPACKE_cgelsd(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb, float* s, float rcond,
-                          lapack_int* rank);
-lapack_int LAPACKE_zgelsd(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb, double* s, double rcond,
-                          lapack_int* rank);
-
-lapack_int LAPACKE_sgelss(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                          float* b, lapack_int ldb, float* s, float rcond, lapack_int* rank);
-lapack_int LAPACKE_dgelss(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                          double* b, lapack_int ldb, double* s, double rcond, lapack_int* rank);
-lapack_int LAPACKE_cgelss(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb, float* s, float rcond,
-                          lapack_int* rank);
-lapack_int LAPACKE_zgelss(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb, double* s, double rcond,
-                          lapack_int* rank);
-
-lapack_int LAPACKE_sgelsy(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                          float* b, lapack_int ldb, lapack_int* jpvt, float rcond, lapack_int* rank);
-lapack_int LAPACKE_dgelsy(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                          double* b, lapack_int ldb, lapack_int* jpvt, double rcond, lapack_int* rank);
-lapack_int LAPACKE_cgelsy(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_int* jpvt, float rcond,
-                          lapack_int* rank);
-lapack_int LAPACKE_zgelsy(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_int* jpvt, double rcond,
-                          lapack_int* rank);
-
-lapack_int LAPACKE_sgeqlf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgeqlf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgeqlf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zgeqlf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgeqp3(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* jpvt,
-                          float* tau);
-lapack_int LAPACKE_dgeqp3(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, lapack_int* jpvt,
-                          double* tau);
-lapack_int LAPACKE_cgeqp3(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* jpvt, lapack_complex_float* tau);
-lapack_int LAPACKE_zgeqp3(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* jpvt, lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgeqpf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* jpvt,
-                          float* tau);
-lapack_int LAPACKE_dgeqpf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, lapack_int* jpvt,
-                          double* tau);
-lapack_int LAPACKE_cgeqpf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* jpvt, lapack_complex_float* tau);
-lapack_int LAPACKE_zgeqpf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* jpvt, lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgeqr2(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgeqr2(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgeqr2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zgeqr2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgeqrf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgeqrf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgeqrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zgeqrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgeqrfp(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgeqrfp(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgeqrfp(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           lapack_complex_float* tau);
-lapack_int LAPACKE_zgeqrfp(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                           lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgerfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                          const float* af, lapack_int ldaf, const lapack_int* ipiv, const float* b, lapack_int ldb,
-                          float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dgerfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                          const double* af, lapack_int ldaf, const lapack_int* ipiv, const double* b, lapack_int ldb,
-                          double* x, lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_cgerfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* af, lapack_int ldaf, const lapack_int* ipiv,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_zgerfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* af, lapack_int ldaf, const lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-
-lapack_int LAPACKE_sgerfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs, const float* a,
-                           lapack_int lda, const float* af, lapack_int ldaf, const lapack_int* ipiv, const float* r,
-                           const float* c, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                           float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                           lapack_int nparams, float* params);
-lapack_int LAPACKE_dgerfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs, const double* a,
-                           lapack_int lda, const double* af, lapack_int ldaf, const lapack_int* ipiv, const double* r,
-                           const double* c, const double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond,
-                           double* berr, lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                           lapack_int nparams, double* params);
-lapack_int LAPACKE_cgerfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                           lapack_int ldaf, const lapack_int* ipiv, const float* r, const float* c,
-                           const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                           float* rcond, float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                           lapack_int nparams, float* params);
-lapack_int LAPACKE_zgerfsx(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                           lapack_int ldaf, const lapack_int* ipiv, const double* r, const double* c,
-                           const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                           double* rcond, double* berr, lapack_int n_err_bnds, double* err_bnds_norm,
-                           double* err_bnds_comp, lapack_int nparams, double* params);
-
-lapack_int LAPACKE_sgerqf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dgerqf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_cgerqf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zgerqf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_sgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, float* a, lapack_int lda, float* s,
-                          float* u, lapack_int ldu, float* vt, lapack_int ldvt);
-lapack_int LAPACKE_dgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, double* a, lapack_int lda, double* s,
-                          double* u, lapack_int ldu, double* vt, lapack_int ldvt);
-lapack_int LAPACKE_cgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda, float* s, lapack_complex_float* u, lapack_int ldu, lapack_complex_float* vt,
-                          lapack_int ldvt);
-lapack_int LAPACKE_zgesdd(int matrix_order, char jobz, lapack_int m, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, double* s, lapack_complex_double* u, lapack_int ldu,
-                          lapack_complex_double* vt, lapack_int ldvt);
-
-lapack_int LAPACKE_sgesv(int matrix_order, lapack_int n, lapack_int nrhs, float* a, lapack_int lda, lapack_int* ipiv,
-                         float* b, lapack_int ldb);
-lapack_int LAPACKE_dgesv(int matrix_order, lapack_int n, lapack_int nrhs, double* a, lapack_int lda, lapack_int* ipiv,
-                         double* b, lapack_int ldb);
-lapack_int LAPACKE_cgesv(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_float* a, lapack_int lda,
-                         lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgesv(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_double* a, lapack_int lda,
-                         lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-lapack_int LAPACKE_dsgesv(int matrix_order, lapack_int n, lapack_int nrhs, double* a, lapack_int lda, lapack_int* ipiv,
-                          double* b, lapack_int ldb, double* x, lapack_int ldx, lapack_int* iter);
-lapack_int LAPACKE_zcgesv(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, lapack_int* iter);
-
-lapack_int LAPACKE_sgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, float* a, lapack_int lda,
-                          float* s, float* u, lapack_int ldu, float* vt, lapack_int ldvt, float* superb);
-lapack_int LAPACKE_dgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, double* a,
-                          lapack_int lda, double* s, double* u, lapack_int ldu, double* vt, lapack_int ldvt,
-                          double* superb);
-lapack_int LAPACKE_cgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda, float* s, lapack_complex_float* u, lapack_int ldu, lapack_complex_float* vt,
-                          lapack_int ldvt, float* superb);
-lapack_int LAPACKE_zgesvd(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, double* s, lapack_complex_double* u, lapack_int ldu,
-                          lapack_complex_double* vt, lapack_int ldvt, double* superb);
-
-lapack_int LAPACKE_sgesvj(int matrix_order, char joba, char jobu, char jobv, lapack_int m, lapack_int n, float* a,
-                          lapack_int lda, float* sva, lapack_int mv, float* v, lapack_int ldv, float* stat);
-lapack_int LAPACKE_dgesvj(int matrix_order, char joba, char jobu, char jobv, lapack_int m, lapack_int n, double* a,
-                          lapack_int lda, double* sva, lapack_int mv, double* v, lapack_int ldv, double* stat);
-
-lapack_int LAPACKE_sgesvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, float* a,
-                          lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, char* equed, float* r, float* c,
-                          float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* ferr, float* berr,
-                          float* rpivot);
-lapack_int LAPACKE_dgesvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, double* a,
-                          lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, char* equed, double* r,
-                          double* c, double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr,
-                          double* berr, double* rpivot);
-lapack_int LAPACKE_cgesvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                          lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* x, lapack_int ldx, float* rcond, float* ferr, float* berr,
-                          float* rpivot);
-lapack_int LAPACKE_zgesvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                          lapack_int* ipiv, char* equed, double* r, double* c, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                          double* rpivot);
-
-lapack_int LAPACKE_sgesvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, float* a,
-                           lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, char* equed, float* r,
-                           float* c, float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* rpvgrw,
-                           float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                           lapack_int nparams, float* params);
-lapack_int LAPACKE_dgesvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, double* a,
-                           lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, char* equed, double* r,
-                           double* c, double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond,
-                           double* rpvgrw, double* berr, lapack_int n_err_bnds, double* err_bnds_norm,
-                           double* err_bnds_comp, lapack_int nparams, double* params);
-lapack_int LAPACKE_cgesvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                           lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                           lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b, lapack_int ldb,
-                           lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_zgesvxx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                           lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                           lapack_int* ipiv, char* equed, double* r, double* c, lapack_complex_double* b,
-                           lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw,
-                           double* berr, lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                           lapack_int nparams, double* params);
-
-lapack_int LAPACKE_sgetf2(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* ipiv);
-lapack_int LAPACKE_dgetf2(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, lapack_int* ipiv);
-lapack_int LAPACKE_cgetf2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* ipiv);
-lapack_int LAPACKE_zgetf2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* ipiv);
-
-lapack_int LAPACKE_sgetrf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* ipiv);
-lapack_int LAPACKE_dgetrf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, lapack_int* ipiv);
-lapack_int LAPACKE_cgetrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* ipiv);
-lapack_int LAPACKE_zgetrf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* ipiv);
-
-lapack_int LAPACKE_sgetri(int matrix_order, lapack_int n, float* a, lapack_int lda, const lapack_int* ipiv);
-lapack_int LAPACKE_dgetri(int matrix_order, lapack_int n, double* a, lapack_int lda, const lapack_int* ipiv);
-lapack_int LAPACKE_cgetri(int matrix_order, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          const lapack_int* ipiv);
-lapack_int LAPACKE_zgetri(int matrix_order, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          const lapack_int* ipiv);
-
-lapack_int LAPACKE_sgetrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                          const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgetrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                          const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgetrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgetrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sggbak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const float* lscale, const float* rscale, lapack_int m, float* v, lapack_int ldv);
-lapack_int LAPACKE_dggbak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const double* lscale, const double* rscale, lapack_int m, double* v, lapack_int ldv);
-lapack_int LAPACKE_cggbak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const float* lscale, const float* rscale, lapack_int m, lapack_complex_float* v,
-                          lapack_int ldv);
-lapack_int LAPACKE_zggbak(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          const double* lscale, const double* rscale, lapack_int m, lapack_complex_double* v,
-                          lapack_int ldv);
-
-lapack_int LAPACKE_sggbal(int matrix_order, char job, lapack_int n, float* a, lapack_int lda, float* b, lapack_int ldb,
-                          lapack_int* ilo, lapack_int* ihi, float* lscale, float* rscale);
-lapack_int LAPACKE_dggbal(int matrix_order, char job, lapack_int n, double* a, lapack_int lda, double* b,
-                          lapack_int ldb, lapack_int* ilo, lapack_int* ihi, double* lscale, double* rscale);
-lapack_int LAPACKE_cggbal(int matrix_order, char job, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* b, lapack_int ldb, lapack_int* ilo, lapack_int* ihi, float* lscale,
-                          float* rscale);
-lapack_int LAPACKE_zggbal(int matrix_order, char job, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* b, lapack_int ldb, lapack_int* ilo, lapack_int* ihi, double* lscale,
-                          double* rscale);
-
-lapack_int LAPACKE_sgges(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_S_SELECT3 selctg, lapack_int n,
-                         float* a, lapack_int lda, float* b, lapack_int ldb, lapack_int* sdim, float* alphar,
-                         float* alphai, float* beta, float* vsl, lapack_int ldvsl, float* vsr, lapack_int ldvsr);
-lapack_int LAPACKE_dgges(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_D_SELECT3 selctg, lapack_int n,
-                         double* a, lapack_int lda, double* b, lapack_int ldb, lapack_int* sdim, double* alphar,
-                         double* alphai, double* beta, double* vsl, lapack_int ldvsl, double* vsr, lapack_int ldvsr);
-lapack_int LAPACKE_cgges(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_C_SELECT2 selctg, lapack_int n,
-                         lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                         lapack_int* sdim, lapack_complex_float* alpha, lapack_complex_float* beta,
-                         lapack_complex_float* vsl, lapack_int ldvsl, lapack_complex_float* vsr, lapack_int ldvsr);
-lapack_int LAPACKE_zgges(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_Z_SELECT2 selctg, lapack_int n,
-                         lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                         lapack_int* sdim, lapack_complex_double* alpha, lapack_complex_double* beta,
-                         lapack_complex_double* vsl, lapack_int ldvsl, lapack_complex_double* vsr, lapack_int ldvsr);
-
-lapack_int LAPACKE_sggesx(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_S_SELECT3 selctg, char sense,
-                          lapack_int n, float* a, lapack_int lda, float* b, lapack_int ldb, lapack_int* sdim,
-                          float* alphar, float* alphai, float* beta, float* vsl, lapack_int ldvsl, float* vsr,
-                          lapack_int ldvsr, float* rconde, float* rcondv);
-lapack_int LAPACKE_dggesx(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_D_SELECT3 selctg, char sense,
-                          lapack_int n, double* a, lapack_int lda, double* b, lapack_int ldb, lapack_int* sdim,
-                          double* alphar, double* alphai, double* beta, double* vsl, lapack_int ldvsl, double* vsr,
-                          lapack_int ldvsr, double* rconde, double* rcondv);
-lapack_int LAPACKE_cggesx(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_C_SELECT2 selctg, char sense,
-                          lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_complex_float* b,
-                          lapack_int ldb, lapack_int* sdim, lapack_complex_float* alpha, lapack_complex_float* beta,
-                          lapack_complex_float* vsl, lapack_int ldvsl, lapack_complex_float* vsr, lapack_int ldvsr,
-                          float* rconde, float* rcondv);
-lapack_int LAPACKE_zggesx(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_Z_SELECT2 selctg, char sense,
-                          lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_complex_double* b,
-                          lapack_int ldb, lapack_int* sdim, lapack_complex_double* alpha, lapack_complex_double* beta,
-                          lapack_complex_double* vsl, lapack_int ldvsl, lapack_complex_double* vsr, lapack_int ldvsr,
-                          double* rconde, double* rcondv);
-
-lapack_int LAPACKE_sggev(int matrix_order, char jobvl, char jobvr, lapack_int n, float* a, lapack_int lda, float* b,
-                         lapack_int ldb, float* alphar, float* alphai, float* beta, float* vl, lapack_int ldvl,
-                         float* vr, lapack_int ldvr);
-lapack_int LAPACKE_dggev(int matrix_order, char jobvl, char jobvr, lapack_int n, double* a, lapack_int lda, double* b,
-                         lapack_int ldb, double* alphar, double* alphai, double* beta, double* vl, lapack_int ldvl,
-                         double* vr, lapack_int ldvr);
-lapack_int LAPACKE_cggev(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_float* a,
-                         lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* alpha,
-                         lapack_complex_float* beta, lapack_complex_float* vl, lapack_int ldvl,
-                         lapack_complex_float* vr, lapack_int ldvr);
-lapack_int LAPACKE_zggev(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_double* a,
-                         lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* alpha,
-                         lapack_complex_double* beta, lapack_complex_double* vl, lapack_int ldvl,
-                         lapack_complex_double* vr, lapack_int ldvr);
-
-lapack_int LAPACKE_sggevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n, float* a,
-                          lapack_int lda, float* b, lapack_int ldb, float* alphar, float* alphai, float* beta,
-                          float* vl, lapack_int ldvl, float* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
-                          float* lscale, float* rscale, float* abnrm, float* bbnrm, float* rconde, float* rcondv);
-lapack_int LAPACKE_dggevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n, double* a,
-                          lapack_int lda, double* b, lapack_int ldb, double* alphar, double* alphai, double* beta,
-                          double* vl, lapack_int ldvl, double* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
-                          double* lscale, double* rscale, double* abnrm, double* bbnrm, double* rconde, double* rcondv);
-lapack_int LAPACKE_cggevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* alpha, lapack_complex_float* beta, lapack_complex_float* vl,
-                          lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
-                          float* lscale, float* rscale, float* abnrm, float* bbnrm, float* rconde, float* rcondv);
-lapack_int LAPACKE_zggevx(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* alpha, lapack_complex_double* beta, lapack_complex_double* vl,
-                          lapack_int ldvl, lapack_complex_double* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
-                          double* lscale, double* rscale, double* abnrm, double* bbnrm, double* rconde, double* rcondv);
-
-lapack_int LAPACKE_sggglm(int matrix_order, lapack_int n, lapack_int m, lapack_int p, float* a, lapack_int lda,
-                          float* b, lapack_int ldb, float* d, float* x, float* y);
-lapack_int LAPACKE_dggglm(int matrix_order, lapack_int n, lapack_int m, lapack_int p, double* a, lapack_int lda,
-                          double* b, lapack_int ldb, double* d, double* x, double* y);
-lapack_int LAPACKE_cggglm(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* d,
-                          lapack_complex_float* x, lapack_complex_float* y);
-lapack_int LAPACKE_zggglm(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* d,
-                          lapack_complex_double* x, lapack_complex_double* y);
-
-lapack_int LAPACKE_sgghrd(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          float* a, lapack_int lda, float* b, lapack_int ldb, float* q, lapack_int ldq, float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_dgghrd(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          double* a, lapack_int lda, double* b, lapack_int ldb, double* q, lapack_int ldq, double* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_cgghrd(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zgghrd(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* q, lapack_int ldq, lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_sgglse(int matrix_order, lapack_int m, lapack_int n, lapack_int p, float* a, lapack_int lda,
-                          float* b, lapack_int ldb, float* c, float* d, float* x);
-lapack_int LAPACKE_dgglse(int matrix_order, lapack_int m, lapack_int n, lapack_int p, double* a, lapack_int lda,
-                          double* b, lapack_int ldb, double* c, double* d, double* x);
-lapack_int LAPACKE_cgglse(int matrix_order, lapack_int m, lapack_int n, lapack_int p, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* c,
-                          lapack_complex_float* d, lapack_complex_float* x);
-lapack_int LAPACKE_zgglse(int matrix_order, lapack_int m, lapack_int n, lapack_int p, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* c,
-                          lapack_complex_double* d, lapack_complex_double* x);
-
-lapack_int LAPACKE_sggqrf(int matrix_order, lapack_int n, lapack_int m, lapack_int p, float* a, lapack_int lda,
-                          float* taua, float* b, lapack_int ldb, float* taub);
-lapack_int LAPACKE_dggqrf(int matrix_order, lapack_int n, lapack_int m, lapack_int p, double* a, lapack_int lda,
-                          double* taua, double* b, lapack_int ldb, double* taub);
-lapack_int LAPACKE_cggqrf(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* taua, lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* taub);
-lapack_int LAPACKE_zggqrf(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* taua, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* taub);
-
-lapack_int LAPACKE_sggrqf(int matrix_order, lapack_int m, lapack_int p, lapack_int n, float* a, lapack_int lda,
-                          float* taua, float* b, lapack_int ldb, float* taub);
-lapack_int LAPACKE_dggrqf(int matrix_order, lapack_int m, lapack_int p, lapack_int n, double* a, lapack_int lda,
-                          double* taua, double* b, lapack_int ldb, double* taub);
-lapack_int LAPACKE_cggrqf(int matrix_order, lapack_int m, lapack_int p, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* taua, lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* taub);
-lapack_int LAPACKE_zggrqf(int matrix_order, lapack_int m, lapack_int p, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* taua, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* taub);
-
-lapack_int LAPACKE_sggsvd(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n, lapack_int p,
-                          lapack_int* k, lapack_int* l, float* a, lapack_int lda, float* b, lapack_int ldb,
-                          float* alpha, float* beta, float* u, lapack_int ldu, float* v, lapack_int ldv, float* q,
-                          lapack_int ldq, lapack_int* iwork);
-lapack_int LAPACKE_dggsvd(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n, lapack_int p,
-                          lapack_int* k, lapack_int* l, double* a, lapack_int lda, double* b, lapack_int ldb,
-                          double* alpha, double* beta, double* u, lapack_int ldu, double* v, lapack_int ldv, double* q,
-                          lapack_int ldq, lapack_int* iwork);
-lapack_int LAPACKE_cggsvd(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n, lapack_int p,
-                          lapack_int* k, lapack_int* l, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* b, lapack_int ldb, float* alpha, float* beta, lapack_complex_float* u,
-                          lapack_int ldu, lapack_complex_float* v, lapack_int ldv, lapack_complex_float* q,
-                          lapack_int ldq, lapack_int* iwork);
-lapack_int LAPACKE_zggsvd(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n, lapack_int p,
-                          lapack_int* k, lapack_int* l, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* b, lapack_int ldb, double* alpha, double* beta,
-                          lapack_complex_double* u, lapack_int ldu, lapack_complex_double* v, lapack_int ldv,
-                          lapack_complex_double* q, lapack_int ldq, lapack_int* iwork);
-
-lapack_int LAPACKE_sggsvp(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          float* a, lapack_int lda, float* b, lapack_int ldb, float tola, float tolb, lapack_int* k,
-                          lapack_int* l, float* u, lapack_int ldu, float* v, lapack_int ldv, float* q, lapack_int ldq);
-lapack_int LAPACKE_dggsvp(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          double* a, lapack_int lda, double* b, lapack_int ldb, double tola, double tolb, lapack_int* k,
-                          lapack_int* l, double* u, lapack_int ldu, double* v, lapack_int ldv, double* q,
-                          lapack_int ldq);
-lapack_int LAPACKE_cggsvp(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb, float tola,
-                          float tolb, lapack_int* k, lapack_int* l, lapack_complex_float* u, lapack_int ldu,
-                          lapack_complex_float* v, lapack_int ldv, lapack_complex_float* q, lapack_int ldq);
-lapack_int LAPACKE_zggsvp(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                          double tola, double tolb, lapack_int* k, lapack_int* l, lapack_complex_double* u,
-                          lapack_int ldu, lapack_complex_double* v, lapack_int ldv, lapack_complex_double* q,
-                          lapack_int ldq);
-
-lapack_int LAPACKE_sgtcon(char norm, lapack_int n, const float* dl, const float* d, const float* du, const float* du2,
-                          const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_dgtcon(char norm, lapack_int n, const double* dl, const double* d, const double* du,
-                          const double* du2, const lapack_int* ipiv, double anorm, double* rcond);
-lapack_int LAPACKE_cgtcon(char norm, lapack_int n, const lapack_complex_float* dl, const lapack_complex_float* d,
-                          const lapack_complex_float* du, const lapack_complex_float* du2, const lapack_int* ipiv,
-                          float anorm, float* rcond);
-lapack_int LAPACKE_zgtcon(char norm, lapack_int n, const lapack_complex_double* dl, const lapack_complex_double* d,
-                          const lapack_complex_double* du, const lapack_complex_double* du2, const lapack_int* ipiv,
-                          double anorm, double* rcond);
-
-lapack_int LAPACKE_sgtrfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* dl, const float* d,
-                          const float* du, const float* dlf, const float* df, const float* duf, const float* du2,
-                          const lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* ferr,
-                          float* berr);
-lapack_int LAPACKE_dgtrfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* dl,
-                          const double* d, const double* du, const double* dlf, const double* df, const double* duf,
-                          const double* du2, const lapack_int* ipiv, const double* b, lapack_int ldb, double* x,
-                          lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_cgtrfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_float* dl,
-                          const lapack_complex_float* d, const lapack_complex_float* du,
-                          const lapack_complex_float* dlf, const lapack_complex_float* df,
-                          const lapack_complex_float* duf, const lapack_complex_float* du2, const lapack_int* ipiv,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_zgtrfs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_double* dl,
-                          const lapack_complex_double* d, const lapack_complex_double* du,
-                          const lapack_complex_double* dlf, const lapack_complex_double* df,
-                          const lapack_complex_double* duf, const lapack_complex_double* du2, const lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-
-lapack_int LAPACKE_sgtsv(int matrix_order, lapack_int n, lapack_int nrhs, float* dl, float* d, float* du, float* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_dgtsv(int matrix_order, lapack_int n, lapack_int nrhs, double* dl, double* d, double* du, double* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_cgtsv(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_float* dl,
-                         lapack_complex_float* d, lapack_complex_float* du, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgtsv(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_double* dl,
-                         lapack_complex_double* d, lapack_complex_double* du, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sgtsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, const float* dl,
-                          const float* d, const float* du, float* dlf, float* df, float* duf, float* du2,
-                          lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_dgtsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, const double* dl,
-                          const double* d, const double* du, double* dlf, double* df, double* duf, double* du2,
-                          lapack_int* ipiv, const double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond,
-                          double* ferr, double* berr);
-lapack_int LAPACKE_cgtsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* dl, const lapack_complex_float* d, const lapack_complex_float* du,
-                          lapack_complex_float* dlf, lapack_complex_float* df, lapack_complex_float* duf,
-                          lapack_complex_float* du2, lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* x, lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zgtsvx(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* dl, const lapack_complex_double* d,
-                          const lapack_complex_double* du, lapack_complex_double* dlf, lapack_complex_double* df,
-                          lapack_complex_double* duf, lapack_complex_double* du2, lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_sgttrf(lapack_int n, float* dl, float* d, float* du, float* du2, lapack_int* ipiv);
-lapack_int LAPACKE_dgttrf(lapack_int n, double* dl, double* d, double* du, double* du2, lapack_int* ipiv);
-lapack_int LAPACKE_cgttrf(lapack_int n, lapack_complex_float* dl, lapack_complex_float* d, lapack_complex_float* du,
-                          lapack_complex_float* du2, lapack_int* ipiv);
-lapack_int LAPACKE_zgttrf(lapack_int n, lapack_complex_double* dl, lapack_complex_double* d, lapack_complex_double* du,
-                          lapack_complex_double* du2, lapack_int* ipiv);
-
-lapack_int LAPACKE_sgttrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* dl, const float* d,
-                          const float* du, const float* du2, const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgttrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* dl,
-                          const double* d, const double* du, const double* du2, const lapack_int* ipiv, double* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_cgttrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_float* dl,
-                          const lapack_complex_float* d, const lapack_complex_float* du,
-                          const lapack_complex_float* du2, const lapack_int* ipiv, lapack_complex_float* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_zgttrs(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const lapack_complex_double* dl,
-                          const lapack_complex_double* d, const lapack_complex_double* du,
-                          const lapack_complex_double* du2, const lapack_int* ipiv, lapack_complex_double* b,
-                          lapack_int ldb);
-
-lapack_int LAPACKE_chbev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, lapack_complex_float* ab,
-                         lapack_int ldab, float* w, lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhbev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, lapack_complex_double* ab,
-                         lapack_int ldab, double* w, lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_chbevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, lapack_complex_float* ab,
-                          lapack_int ldab, float* w, lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhbevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd,
-                          lapack_complex_double* ab, lapack_int ldab, double* w, lapack_complex_double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_chbevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd,
-                          lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* q, lapack_int ldq, float vl,
-                          float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                          lapack_complex_float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_zhbevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd,
-                          lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* q, lapack_int ldq,
-                          double vl, double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          lapack_complex_double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_chbgst(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                          lapack_complex_float* ab, lapack_int ldab, const lapack_complex_float* bb, lapack_int ldbb,
-                          lapack_complex_float* x, lapack_int ldx);
-lapack_int LAPACKE_zhbgst(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                          lapack_complex_double* ab, lapack_int ldab, const lapack_complex_double* bb, lapack_int ldbb,
-                          lapack_complex_double* x, lapack_int ldx);
-
-lapack_int LAPACKE_chbgv(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                         lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* bb, lapack_int ldbb, float* w,
-                         lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhbgv(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                         lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* bb, lapack_int ldbb,
-                         double* w, lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_chbgvd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                          lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* bb, lapack_int ldbb,
-                          float* w, lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhbgvd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                          lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* bb, lapack_int ldbb,
-                          double* w, lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_chbgvx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                          lapack_int kb, lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* bb,
-                          lapack_int ldbb, lapack_complex_float* q, lapack_int ldq, float vl, float vu, lapack_int il,
-                          lapack_int iu, float abstol, lapack_int* m, float* w, lapack_complex_float* z, lapack_int ldz,
-                          lapack_int* ifail);
-lapack_int LAPACKE_zhbgvx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                          lapack_int kb, lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* bb,
-                          lapack_int ldbb, lapack_complex_double* q, lapack_int ldq, double vl, double vu,
-                          lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          lapack_complex_double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_chbtrd(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd, lapack_complex_float* ab,
-                          lapack_int ldab, float* d, float* e, lapack_complex_float* q, lapack_int ldq);
-lapack_int LAPACKE_zhbtrd(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd,
-                          lapack_complex_double* ab, lapack_int ldab, double* d, double* e, lapack_complex_double* q,
-                          lapack_int ldq);
-
-lapack_int LAPACKE_checon(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                          const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_zhecon(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          const lapack_int* ipiv, double anorm, double* rcond);
-
-lapack_int LAPACKE_cheequb(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                           float* s, float* scond, float* amax);
-lapack_int LAPACKE_zheequb(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                           double* s, double* scond, double* amax);
-
-lapack_int LAPACKE_cheev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                         float* w);
-lapack_int LAPACKE_zheev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                         double* w);
-
-lapack_int LAPACKE_cheevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          float* w);
-lapack_int LAPACKE_zheevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, double* w);
-
-lapack_int LAPACKE_cheevr(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda, float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m,
-                          float* w, lapack_complex_float* z, lapack_int ldz, lapack_int* isuppz);
-lapack_int LAPACKE_zheevr(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                          lapack_int* m, double* w, lapack_complex_double* z, lapack_int ldz, lapack_int* isuppz);
-
-lapack_int LAPACKE_cheevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda, float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m,
-                          float* w, lapack_complex_float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_zheevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                          lapack_int* m, double* w, lapack_complex_double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_chegst(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhegst(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chegv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                         lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb, float* w);
-lapack_int LAPACKE_zhegv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                         lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb, double* w);
-
-lapack_int LAPACKE_chegvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb, float* w);
-lapack_int LAPACKE_zhegvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                          double* w);
-
-lapack_int LAPACKE_chegvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb, float vl,
-                          float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                          lapack_complex_float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_zhegvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb, double vl,
-                          double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          lapack_complex_double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_cherfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* af, lapack_int ldaf, const lapack_int* ipiv,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_zherfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* af, lapack_int ldaf, const lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-
-lapack_int LAPACKE_cherfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                           lapack_int ldaf, const lapack_int* ipiv, const float* s, const lapack_complex_float* b,
-                           lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_zherfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                           lapack_int ldaf, const lapack_int* ipiv, const double* s, const lapack_complex_double* b,
-                           lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* rcond, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-
-lapack_int LAPACKE_chesv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                         lapack_int lda, lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhesv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                         lapack_int lda, lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chesvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                          lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                          lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zhesvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                          lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_chesvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                           lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                           lapack_int* ipiv, char* equed, float* s, lapack_complex_float* b, lapack_int ldb,
-                           lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_zhesvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                           lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                           lapack_int* ipiv, char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                           lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-
-lapack_int LAPACKE_chetrd(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda, float* d,
-                          float* e, lapack_complex_float* tau);
-lapack_int LAPACKE_zhetrd(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          double* d, double* e, lapack_complex_double* tau);
-
-lapack_int LAPACKE_chetrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* ipiv);
-lapack_int LAPACKE_zhetrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* ipiv);
-
-lapack_int LAPACKE_chetri(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          const lapack_int* ipiv);
-lapack_int LAPACKE_zhetri(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          const lapack_int* ipiv);
-
-lapack_int LAPACKE_chetrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhetrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chfrk(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k, float alpha,
-                         const lapack_complex_float* a, lapack_int lda, float beta, lapack_complex_float* c);
-lapack_int LAPACKE_zhfrk(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k, double alpha,
-                         const lapack_complex_double* a, lapack_int lda, double beta, lapack_complex_double* c);
-
-lapack_int LAPACKE_shgeqz(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, float* h, lapack_int ldh, float* t, lapack_int ldt, float* alphar,
-                          float* alphai, float* beta, float* q, lapack_int ldq, float* z, lapack_int ldz);
-lapack_int LAPACKE_dhgeqz(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, double* h, lapack_int ldh, double* t, lapack_int ldt, double* alphar,
-                          double* alphai, double* beta, double* q, lapack_int ldq, double* z, lapack_int ldz);
-lapack_int LAPACKE_chgeqz(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, lapack_complex_float* h, lapack_int ldh, lapack_complex_float* t,
-                          lapack_int ldt, lapack_complex_float* alpha, lapack_complex_float* beta,
-                          lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhgeqz(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, lapack_complex_double* h, lapack_int ldh, lapack_complex_double* t,
-                          lapack_int ldt, lapack_complex_double* alpha, lapack_complex_double* beta,
-                          lapack_complex_double* q, lapack_int ldq, lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_chpcon(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                          const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_zhpcon(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                          const lapack_int* ipiv, double anorm, double* rcond);
-
-lapack_int LAPACKE_chpev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* ap, float* w,
-                         lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhpev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* ap, double* w,
-                         lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_chpevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* ap, float* w,
-                          lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zhpevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* ap, double* w,
-                          lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_chpevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_complex_float* ap,
-                          float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                          lapack_complex_float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_zhpevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_complex_double* ap,
-                          double vl, double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          lapack_complex_double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_chpgst(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_float* ap,
-                          const lapack_complex_float* bp);
-lapack_int LAPACKE_zhpgst(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_double* ap,
-                          const lapack_complex_double* bp);
-
-lapack_int LAPACKE_chpgv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                         lapack_complex_float* ap, lapack_complex_float* bp, float* w, lapack_complex_float* z,
-                         lapack_int ldz);
-lapack_int LAPACKE_zhpgv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                         lapack_complex_double* ap, lapack_complex_double* bp, double* w, lapack_complex_double* z,
-                         lapack_int ldz);
-
-lapack_int LAPACKE_chpgvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                          lapack_complex_float* ap, lapack_complex_float* bp, float* w, lapack_complex_float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_zhpgvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                          lapack_complex_double* ap, lapack_complex_double* bp, double* w, lapack_complex_double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_chpgvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                          lapack_complex_float* ap, lapack_complex_float* bp, float vl, float vu, lapack_int il,
-                          lapack_int iu, float abstol, lapack_int* m, float* w, lapack_complex_float* z, lapack_int ldz,
-                          lapack_int* ifail);
-lapack_int LAPACKE_zhpgvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                          lapack_complex_double* ap, lapack_complex_double* bp, double vl, double vu, lapack_int il,
-                          lapack_int iu, double abstol, lapack_int* m, double* w, lapack_complex_double* z,
-                          lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_chprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* ap,
-                          const lapack_complex_float* afp, const lapack_int* ipiv, const lapack_complex_float* b,
-                          lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_zhprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* ap,
-                          const lapack_complex_double* afp, const lapack_int* ipiv, const lapack_complex_double* b,
-                          lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_chpsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* ap,
-                         lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhpsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* ap,
-                         lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chpsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* ap, lapack_complex_float* afp, lapack_int* ipiv,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zhpsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* ap, lapack_complex_double* afp, lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_chptrd(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, float* d, float* e,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zhptrd(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, double* d, double* e,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_chptrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, lapack_int* ipiv);
-lapack_int LAPACKE_zhptrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, lapack_int* ipiv);
-
-lapack_int LAPACKE_chptri(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, const lapack_int* ipiv);
-lapack_int LAPACKE_zhptri(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, const lapack_int* ipiv);
-
-lapack_int LAPACKE_chptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* ap,
-                          const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* ap,
-                          const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_shsein(int matrix_order, char job, char eigsrc, char initv, lapack_logical* select, lapack_int n,
-                          const float* h, lapack_int ldh, float* wr, const float* wi, float* vl, lapack_int ldvl,
-                          float* vr, lapack_int ldvr, lapack_int mm, lapack_int* m, lapack_int* ifaill,
-                          lapack_int* ifailr);
-lapack_int LAPACKE_dhsein(int matrix_order, char job, char eigsrc, char initv, lapack_logical* select, lapack_int n,
-                          const double* h, lapack_int ldh, double* wr, const double* wi, double* vl, lapack_int ldvl,
-                          double* vr, lapack_int ldvr, lapack_int mm, lapack_int* m, lapack_int* ifaill,
-                          lapack_int* ifailr);
-lapack_int LAPACKE_chsein(int matrix_order, char job, char eigsrc, char initv, const lapack_logical* select,
-                          lapack_int n, const lapack_complex_float* h, lapack_int ldh, lapack_complex_float* w,
-                          lapack_complex_float* vl, lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr,
-                          lapack_int mm, lapack_int* m, lapack_int* ifaill, lapack_int* ifailr);
-lapack_int LAPACKE_zhsein(int matrix_order, char job, char eigsrc, char initv, const lapack_logical* select,
-                          lapack_int n, const lapack_complex_double* h, lapack_int ldh, lapack_complex_double* w,
-                          lapack_complex_double* vl, lapack_int ldvl, lapack_complex_double* vr, lapack_int ldvr,
-                          lapack_int mm, lapack_int* m, lapack_int* ifaill, lapack_int* ifailr);
-
-lapack_int LAPACKE_shseqr(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          float* h, lapack_int ldh, float* wr, float* wi, float* z, lapack_int ldz);
-lapack_int LAPACKE_dhseqr(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          double* h, lapack_int ldh, double* wr, double* wi, double* z, lapack_int ldz);
-lapack_int LAPACKE_chseqr(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          lapack_complex_float* h, lapack_int ldh, lapack_complex_float* w, lapack_complex_float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_zhseqr(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                          lapack_complex_double* h, lapack_int ldh, lapack_complex_double* w, lapack_complex_double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_clacgv(lapack_int n, lapack_complex_float* x, lapack_int incx);
-lapack_int LAPACKE_zlacgv(lapack_int n, lapack_complex_double* x, lapack_int incx);
-
-lapack_int LAPACKE_slacpy(int matrix_order, char uplo, lapack_int m, lapack_int n, const float* a, lapack_int lda,
-                          float* b, lapack_int ldb);
-lapack_int LAPACKE_dlacpy(int matrix_order, char uplo, lapack_int m, lapack_int n, const double* a, lapack_int lda,
-                          double* b, lapack_int ldb);
-lapack_int LAPACKE_clacpy(int matrix_order, char uplo, lapack_int m, lapack_int n, const lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zlacpy(int matrix_order, char uplo, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_zlag2c(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_float* sa, lapack_int ldsa);
-
-lapack_int LAPACKE_slag2d(int matrix_order, lapack_int m, lapack_int n, const float* sa, lapack_int ldsa, double* a,
-                          lapack_int lda);
-
-lapack_int LAPACKE_dlag2s(int matrix_order, lapack_int m, lapack_int n, const double* a, lapack_int lda, float* sa,
-                          lapack_int ldsa);
-
-lapack_int LAPACKE_clag2z(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float* sa, lapack_int ldsa,
-                          lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_slagge(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float* d,
-                          float* a, lapack_int lda, lapack_int* iseed);
-lapack_int LAPACKE_dlagge(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double* d,
-                          double* a, lapack_int lda, lapack_int* iseed);
-lapack_int LAPACKE_clagge(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float* d,
-                          lapack_complex_float* a, lapack_int lda, lapack_int* iseed);
-lapack_int LAPACKE_zlagge(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double* d,
-                          lapack_complex_double* a, lapack_int lda, lapack_int* iseed);
-
-float LAPACKE_slamch(char cmach);
-double LAPACKE_dlamch(char cmach);
-
-float LAPACKE_slange(int matrix_order, char norm, lapack_int m, lapack_int n, const float* a, lapack_int lda);
-double LAPACKE_dlange(int matrix_order, char norm, lapack_int m, lapack_int n, const double* a, lapack_int lda);
-float LAPACKE_clange(int matrix_order, char norm, lapack_int m, lapack_int n, const lapack_complex_float* a,
-                     lapack_int lda);
-double LAPACKE_zlange(int matrix_order, char norm, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                      lapack_int lda);
-
-float LAPACKE_clanhe(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_float* a,
-                     lapack_int lda);
-double LAPACKE_zlanhe(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_double* a,
-                      lapack_int lda);
-
-float LAPACKE_slansy(int matrix_order, char norm, char uplo, lapack_int n, const float* a, lapack_int lda);
-double LAPACKE_dlansy(int matrix_order, char norm, char uplo, lapack_int n, const double* a, lapack_int lda);
-float LAPACKE_clansy(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_float* a,
-                     lapack_int lda);
-double LAPACKE_zlansy(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_double* a,
-                      lapack_int lda);
-
-float LAPACKE_slantr(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n, const float* a,
-                     lapack_int lda);
-double LAPACKE_dlantr(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n, const double* a,
-                      lapack_int lda);
-float LAPACKE_clantr(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n,
-                     const lapack_complex_float* a, lapack_int lda);
-double LAPACKE_zlantr(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n,
-                      const lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_slarfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, const float* v, lapack_int ldv, const float* t, lapack_int ldt, float* c,
-                          lapack_int ldc);
-lapack_int LAPACKE_dlarfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, const double* v, lapack_int ldv, const double* t, lapack_int ldt, double* c,
-                          lapack_int ldc);
-lapack_int LAPACKE_clarfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, const lapack_complex_float* v, lapack_int ldv, const lapack_complex_float* t,
-                          lapack_int ldt, lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zlarfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, const lapack_complex_double* v, lapack_int ldv, const lapack_complex_double* t,
-                          lapack_int ldt, lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_slarfg(lapack_int n, float* alpha, float* x, lapack_int incx, float* tau);
-lapack_int LAPACKE_dlarfg(lapack_int n, double* alpha, double* x, lapack_int incx, double* tau);
-lapack_int LAPACKE_clarfg(lapack_int n, lapack_complex_float* alpha, lapack_complex_float* x, lapack_int incx,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_zlarfg(lapack_int n, lapack_complex_double* alpha, lapack_complex_double* x, lapack_int incx,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_slarft(int matrix_order, char direct, char storev, lapack_int n, lapack_int k, const float* v,
-                          lapack_int ldv, const float* tau, float* t, lapack_int ldt);
-lapack_int LAPACKE_dlarft(int matrix_order, char direct, char storev, lapack_int n, lapack_int k, const double* v,
-                          lapack_int ldv, const double* tau, double* t, lapack_int ldt);
-lapack_int LAPACKE_clarft(int matrix_order, char direct, char storev, lapack_int n, lapack_int k,
-                          const lapack_complex_float* v, lapack_int ldv, const lapack_complex_float* tau,
-                          lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zlarft(int matrix_order, char direct, char storev, lapack_int n, lapack_int k,
-                          const lapack_complex_double* v, lapack_int ldv, const lapack_complex_double* tau,
-                          lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_slarfx(int matrix_order, char side, lapack_int m, lapack_int n, const float* v, float tau, float* c,
-                          lapack_int ldc, float* work);
-lapack_int LAPACKE_dlarfx(int matrix_order, char side, lapack_int m, lapack_int n, const double* v, double tau,
-                          double* c, lapack_int ldc, double* work);
-lapack_int LAPACKE_clarfx(int matrix_order, char side, lapack_int m, lapack_int n, const lapack_complex_float* v,
-                          lapack_complex_float tau, lapack_complex_float* c, lapack_int ldc,
-                          lapack_complex_float* work);
-lapack_int LAPACKE_zlarfx(int matrix_order, char side, lapack_int m, lapack_int n, const lapack_complex_double* v,
-                          lapack_complex_double tau, lapack_complex_double* c, lapack_int ldc,
-                          lapack_complex_double* work);
-
-lapack_int LAPACKE_slarnv(lapack_int idist, lapack_int* iseed, lapack_int n, float* x);
-lapack_int LAPACKE_dlarnv(lapack_int idist, lapack_int* iseed, lapack_int n, double* x);
-lapack_int LAPACKE_clarnv(lapack_int idist, lapack_int* iseed, lapack_int n, lapack_complex_float* x);
-lapack_int LAPACKE_zlarnv(lapack_int idist, lapack_int* iseed, lapack_int n, lapack_complex_double* x);
-
-lapack_int LAPACKE_slaset(int matrix_order, char uplo, lapack_int m, lapack_int n, float alpha, float beta, float* a,
-                          lapack_int lda);
-lapack_int LAPACKE_dlaset(int matrix_order, char uplo, lapack_int m, lapack_int n, double alpha, double beta, double* a,
-                          lapack_int lda);
-lapack_int LAPACKE_claset(int matrix_order, char uplo, lapack_int m, lapack_int n, lapack_complex_float alpha,
-                          lapack_complex_float beta, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zlaset(int matrix_order, char uplo, lapack_int m, lapack_int n, lapack_complex_double alpha,
-                          lapack_complex_double beta, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_slasrt(char id, lapack_int n, float* d);
-lapack_int LAPACKE_dlasrt(char id, lapack_int n, double* d);
-
-lapack_int LAPACKE_slaswp(int matrix_order, lapack_int n, float* a, lapack_int lda, lapack_int k1, lapack_int k2,
-                          const lapack_int* ipiv, lapack_int incx);
-lapack_int LAPACKE_dlaswp(int matrix_order, lapack_int n, double* a, lapack_int lda, lapack_int k1, lapack_int k2,
-                          const lapack_int* ipiv, lapack_int incx);
-lapack_int LAPACKE_claswp(int matrix_order, lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_int k1,
-                          lapack_int k2, const lapack_int* ipiv, lapack_int incx);
-lapack_int LAPACKE_zlaswp(int matrix_order, lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_int k1,
-                          lapack_int k2, const lapack_int* ipiv, lapack_int incx);
-
-lapack_int LAPACKE_slatms(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                          float* d, lapack_int mode, float cond, float dmax, lapack_int kl, lapack_int ku, char pack,
-                          float* a, lapack_int lda);
-lapack_int LAPACKE_dlatms(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                          double* d, lapack_int mode, double cond, double dmax, lapack_int kl, lapack_int ku, char pack,
-                          double* a, lapack_int lda);
-lapack_int LAPACKE_clatms(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                          float* d, lapack_int mode, float cond, float dmax, lapack_int kl, lapack_int ku, char pack,
-                          lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zlatms(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                          double* d, lapack_int mode, double cond, double dmax, lapack_int kl, lapack_int ku, char pack,
-                          lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_slauum(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dlauum(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_clauum(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zlauum(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_sopgtr(int matrix_order, char uplo, lapack_int n, const float* ap, const float* tau, float* q,
-                          lapack_int ldq);
-lapack_int LAPACKE_dopgtr(int matrix_order, char uplo, lapack_int n, const double* ap, const double* tau, double* q,
-                          lapack_int ldq);
-
-lapack_int LAPACKE_sopmtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const float* ap, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dopmtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const double* ap, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sorgbr(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k, float* a,
-                          lapack_int lda, const float* tau);
-lapack_int LAPACKE_dorgbr(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k, double* a,
-                          lapack_int lda, const double* tau);
-
-lapack_int LAPACKE_sorghr(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, float* a, lapack_int lda,
-                          const float* tau);
-lapack_int LAPACKE_dorghr(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, double* a, lapack_int lda,
-                          const double* tau);
-
-lapack_int LAPACKE_sorglq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                          const float* tau);
-lapack_int LAPACKE_dorglq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                          const double* tau);
-
-lapack_int LAPACKE_sorgql(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                          const float* tau);
-lapack_int LAPACKE_dorgql(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                          const double* tau);
-
-lapack_int LAPACKE_sorgqr(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                          const float* tau);
-lapack_int LAPACKE_dorgqr(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                          const double* tau);
-
-lapack_int LAPACKE_sorgrq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                          const float* tau);
-lapack_int LAPACKE_dorgrq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                          const double* tau);
-
-lapack_int LAPACKE_sorgtr(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, const float* tau);
-lapack_int LAPACKE_dorgtr(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, const double* tau);
-
-lapack_int LAPACKE_sormbr(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormbr(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sormhr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormhr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, const double* a, lapack_int lda, const double* tau, double* c,
-                          lapack_int ldc);
-
-lapack_int LAPACKE_sormlq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormlq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sormql(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormql(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sormqr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormqr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sormrq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormrq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sormrz(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          lapack_int l, const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormrz(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          lapack_int l, const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sormtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc);
-lapack_int LAPACKE_dormtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc);
-
-lapack_int LAPACKE_spbcon(int matrix_order, char uplo, lapack_int n, lapack_int kd, const float* ab, lapack_int ldab,
-                          float anorm, float* rcond);
-lapack_int LAPACKE_dpbcon(int matrix_order, char uplo, lapack_int n, lapack_int kd, const double* ab, lapack_int ldab,
-                          double anorm, double* rcond);
-lapack_int LAPACKE_cpbcon(int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float* ab,
-                          lapack_int ldab, float anorm, float* rcond);
-lapack_int LAPACKE_zpbcon(int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double* ab,
-                          lapack_int ldab, double anorm, double* rcond);
-
-lapack_int LAPACKE_spbequ(int matrix_order, char uplo, lapack_int n, lapack_int kd, const float* ab, lapack_int ldab,
-                          float* s, float* scond, float* amax);
-lapack_int LAPACKE_dpbequ(int matrix_order, char uplo, lapack_int n, lapack_int kd, const double* ab, lapack_int ldab,
-                          double* s, double* scond, double* amax);
-lapack_int LAPACKE_cpbequ(int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float* ab,
-                          lapack_int ldab, float* s, float* scond, float* amax);
-lapack_int LAPACKE_zpbequ(int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double* ab,
-                          lapack_int ldab, double* s, double* scond, double* amax);
-
-lapack_int LAPACKE_spbrfs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, const float* ab,
-                          lapack_int ldab, const float* afb, lapack_int ldafb, const float* b, lapack_int ldb, float* x,
-                          lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dpbrfs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, const double* ab,
-                          lapack_int ldab, const double* afb, lapack_int ldafb, const double* b, lapack_int ldb,
-                          double* x, lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_cpbrfs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          const lapack_complex_float* ab, lapack_int ldab, const lapack_complex_float* afb,
-                          lapack_int ldafb, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                          lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_zpbrfs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          const lapack_complex_double* ab, lapack_int ldab, const lapack_complex_double* afb,
-                          lapack_int ldafb, const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_spbstf(int matrix_order, char uplo, lapack_int n, lapack_int kb, float* bb, lapack_int ldbb);
-lapack_int LAPACKE_dpbstf(int matrix_order, char uplo, lapack_int n, lapack_int kb, double* bb, lapack_int ldbb);
-lapack_int LAPACKE_cpbstf(int matrix_order, char uplo, lapack_int n, lapack_int kb, lapack_complex_float* bb,
-                          lapack_int ldbb);
-lapack_int LAPACKE_zpbstf(int matrix_order, char uplo, lapack_int n, lapack_int kb, lapack_complex_double* bb,
-                          lapack_int ldbb);
-
-lapack_int LAPACKE_spbsv(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, float* ab,
-                         lapack_int ldab, float* b, lapack_int ldb);
-lapack_int LAPACKE_dpbsv(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, double* ab,
-                         lapack_int ldab, double* b, lapack_int ldb);
-lapack_int LAPACKE_cpbsv(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                         lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpbsv(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                         lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spbsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          float* ab, lapack_int ldab, float* afb, lapack_int ldafb, char* equed, float* s, float* b,
-                          lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_dpbsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          double* ab, lapack_int ldab, double* afb, lapack_int ldafb, char* equed, double* s, double* b,
-                          lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr, double* berr);
-lapack_int LAPACKE_cpbsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* afb, lapack_int ldafb,
-                          char* equed, float* s, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                          lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zpbsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* afb, lapack_int ldafb,
-                          char* equed, double* s, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_spbtrf(int matrix_order, char uplo, lapack_int n, lapack_int kd, float* ab, lapack_int ldab);
-lapack_int LAPACKE_dpbtrf(int matrix_order, char uplo, lapack_int n, lapack_int kd, double* ab, lapack_int ldab);
-lapack_int LAPACKE_cpbtrf(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_complex_float* ab,
-                          lapack_int ldab);
-lapack_int LAPACKE_zpbtrf(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_complex_double* ab,
-                          lapack_int ldab);
-
-lapack_int LAPACKE_spbtrs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, const float* ab,
-                          lapack_int ldab, float* b, lapack_int ldb);
-lapack_int LAPACKE_dpbtrs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, const double* ab,
-                          lapack_int ldab, double* b, lapack_int ldb);
-lapack_int LAPACKE_cpbtrs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          const lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpbtrs(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                          const lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spftrf(int matrix_order, char transr, char uplo, lapack_int n, float* a);
-lapack_int LAPACKE_dpftrf(int matrix_order, char transr, char uplo, lapack_int n, double* a);
-lapack_int LAPACKE_cpftrf(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_float* a);
-lapack_int LAPACKE_zpftrf(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_double* a);
-
-lapack_int LAPACKE_spftri(int matrix_order, char transr, char uplo, lapack_int n, float* a);
-lapack_int LAPACKE_dpftri(int matrix_order, char transr, char uplo, lapack_int n, double* a);
-lapack_int LAPACKE_cpftri(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_float* a);
-lapack_int LAPACKE_zpftri(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_double* a);
-
-lapack_int LAPACKE_spftrs(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                          float* b, lapack_int ldb);
-lapack_int LAPACKE_dpftrs(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                          double* b, lapack_int ldb);
-lapack_int LAPACKE_cpftrs(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* a, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpftrs(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* a, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spocon(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda, float anorm,
-                          float* rcond);
-lapack_int LAPACKE_dpocon(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda, double anorm,
-                          double* rcond);
-lapack_int LAPACKE_cpocon(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                          float anorm, float* rcond);
-lapack_int LAPACKE_zpocon(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          double anorm, double* rcond);
-
-lapack_int LAPACKE_spoequ(int matrix_order, lapack_int n, const float* a, lapack_int lda, float* s, float* scond,
-                          float* amax);
-lapack_int LAPACKE_dpoequ(int matrix_order, lapack_int n, const double* a, lapack_int lda, double* s, double* scond,
-                          double* amax);
-lapack_int LAPACKE_cpoequ(int matrix_order, lapack_int n, const lapack_complex_float* a, lapack_int lda, float* s,
-                          float* scond, float* amax);
-lapack_int LAPACKE_zpoequ(int matrix_order, lapack_int n, const lapack_complex_double* a, lapack_int lda, double* s,
-                          double* scond, double* amax);
-
-lapack_int LAPACKE_spoequb(int matrix_order, lapack_int n, const float* a, lapack_int lda, float* s, float* scond,
-                           float* amax);
-lapack_int LAPACKE_dpoequb(int matrix_order, lapack_int n, const double* a, lapack_int lda, double* s, double* scond,
-                           double* amax);
-lapack_int LAPACKE_cpoequb(int matrix_order, lapack_int n, const lapack_complex_float* a, lapack_int lda, float* s,
-                           float* scond, float* amax);
-lapack_int LAPACKE_zpoequb(int matrix_order, lapack_int n, const lapack_complex_double* a, lapack_int lda, double* s,
-                           double* scond, double* amax);
-
-lapack_int LAPACKE_sporfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                          const float* af, lapack_int ldaf, const float* b, lapack_int ldb, float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_dporfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                          const double* af, lapack_int ldaf, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-lapack_int LAPACKE_cporfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* af, lapack_int ldaf,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_zporfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* af, lapack_int ldaf,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-
-lapack_int LAPACKE_sporfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const float* a,
-                           lapack_int lda, const float* af, lapack_int ldaf, const float* s, const float* b,
-                           lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* berr, lapack_int n_err_bnds,
-                           float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_dporfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const double* a,
-                           lapack_int lda, const double* af, lapack_int ldaf, const double* s, const double* b,
-                           lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-lapack_int LAPACKE_cporfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                           lapack_int ldaf, const float* s, const lapack_complex_float* b, lapack_int ldb,
-                           lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr, lapack_int n_err_bnds,
-                           float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_zporfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                           lapack_int ldaf, const double* s, const lapack_complex_double* b, lapack_int ldb,
-                           lapack_complex_double* x, lapack_int ldx, double* rcond, double* berr, lapack_int n_err_bnds,
-                           double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params);
-
-lapack_int LAPACKE_sposv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* a, lapack_int lda, float* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_dposv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                         double* b, lapack_int ldb);
-lapack_int LAPACKE_cposv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                         lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zposv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                         lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-lapack_int LAPACKE_dsposv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                          double* b, lapack_int ldb, double* x, lapack_int ldx, lapack_int* iter);
-lapack_int LAPACKE_zcposv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, lapack_int* iter);
-
-lapack_int LAPACKE_sposvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* a,
-                          lapack_int lda, float* af, lapack_int ldaf, char* equed, float* s, float* b, lapack_int ldb,
-                          float* x, lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_dposvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* a,
-                          lapack_int lda, double* af, lapack_int ldaf, char* equed, double* s, double* b,
-                          lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr, double* berr);
-lapack_int LAPACKE_cposvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                          char* equed, float* s, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                          lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zposvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                          char* equed, double* s, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_sposvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* a,
-                           lapack_int lda, float* af, lapack_int ldaf, char* equed, float* s, float* b, lapack_int ldb,
-                           float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr, lapack_int n_err_bnds,
-                           float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_dposvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* a,
-                           lapack_int lda, double* af, lapack_int ldaf, char* equed, double* s, double* b,
-                           lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-lapack_int LAPACKE_cposvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                           lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                           char* equed, float* s, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                           lapack_int ldx, float* rcond, float* rpvgrw, float* berr, lapack_int n_err_bnds,
-                           float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params);
-lapack_int LAPACKE_zposvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                           lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                           char* equed, double* s, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                           lapack_int ldx, double* rcond, double* rpvgrw, double* berr, lapack_int n_err_bnds,
-                           double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params);
-
-lapack_int LAPACKE_spotrf(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dpotrf(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_cpotrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zpotrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_spotri(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dpotri(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_cpotri(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zpotri(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_spotrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                          float* b, lapack_int ldb);
-lapack_int LAPACKE_dpotrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                          double* b, lapack_int ldb);
-lapack_int LAPACKE_cpotrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpotrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sppcon(int matrix_order, char uplo, lapack_int n, const float* ap, float anorm, float* rcond);
-lapack_int LAPACKE_dppcon(int matrix_order, char uplo, lapack_int n, const double* ap, double anorm, double* rcond);
-lapack_int LAPACKE_cppcon(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap, float anorm,
-                          float* rcond);
-lapack_int LAPACKE_zppcon(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap, double anorm,
-                          double* rcond);
-
-lapack_int LAPACKE_sppequ(int matrix_order, char uplo, lapack_int n, const float* ap, float* s, float* scond,
-                          float* amax);
-lapack_int LAPACKE_dppequ(int matrix_order, char uplo, lapack_int n, const double* ap, double* s, double* scond,
-                          double* amax);
-lapack_int LAPACKE_cppequ(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap, float* s,
-                          float* scond, float* amax);
-lapack_int LAPACKE_zppequ(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap, double* s,
-                          double* scond, double* amax);
-
-lapack_int LAPACKE_spprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap, const float* afp,
-                          const float* b, lapack_int ldb, float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dpprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                          const double* afp, const double* b, lapack_int ldb, double* x, lapack_int ldx, double* ferr,
-                          double* berr);
-lapack_int LAPACKE_cpprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* ap,
-                          const lapack_complex_float* afp, const lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_zpprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* ap,
-                          const lapack_complex_double* afp, const lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_sppsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* ap, float* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_dppsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* ap, double* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_cppsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* ap,
-                         lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zppsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* ap,
-                         lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sppsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* ap, float* afp,
-                          char* equed, float* s, float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_dppsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* ap,
-                          double* afp, char* equed, double* s, double* b, lapack_int ldb, double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-lapack_int LAPACKE_cppsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          lapack_complex_float* ap, lapack_complex_float* afp, char* equed, float* s,
-                          lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zppsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          lapack_complex_double* ap, lapack_complex_double* afp, char* equed, double* s,
-                          lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_spptrf(int matrix_order, char uplo, lapack_int n, float* ap);
-lapack_int LAPACKE_dpptrf(int matrix_order, char uplo, lapack_int n, double* ap);
-lapack_int LAPACKE_cpptrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap);
-lapack_int LAPACKE_zpptrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap);
-
-lapack_int LAPACKE_spptri(int matrix_order, char uplo, lapack_int n, float* ap);
-lapack_int LAPACKE_dpptri(int matrix_order, char uplo, lapack_int n, double* ap);
-lapack_int LAPACKE_cpptri(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap);
-lapack_int LAPACKE_zpptri(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap);
-
-lapack_int LAPACKE_spptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap, float* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_dpptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap, double* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_cpptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* ap,
-                          lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* ap,
-                          lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spstrf(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, lapack_int* piv,
-                          lapack_int* rank, float tol);
-lapack_int LAPACKE_dpstrf(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, lapack_int* piv,
-                          lapack_int* rank, double tol);
-lapack_int LAPACKE_cpstrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* piv, lapack_int* rank, float tol);
-lapack_int LAPACKE_zpstrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* piv, lapack_int* rank, double tol);
-
-lapack_int LAPACKE_sptcon(lapack_int n, const float* d, const float* e, float anorm, float* rcond);
-lapack_int LAPACKE_dptcon(lapack_int n, const double* d, const double* e, double anorm, double* rcond);
-lapack_int LAPACKE_cptcon(lapack_int n, const float* d, const lapack_complex_float* e, float anorm, float* rcond);
-lapack_int LAPACKE_zptcon(lapack_int n, const double* d, const lapack_complex_double* e, double anorm, double* rcond);
-
-lapack_int LAPACKE_spteqr(int matrix_order, char compz, lapack_int n, float* d, float* e, float* z, lapack_int ldz);
-lapack_int LAPACKE_dpteqr(int matrix_order, char compz, lapack_int n, double* d, double* e, double* z, lapack_int ldz);
-lapack_int LAPACKE_cpteqr(int matrix_order, char compz, lapack_int n, float* d, float* e, lapack_complex_float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_zpteqr(int matrix_order, char compz, lapack_int n, double* d, double* e, lapack_complex_double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_sptrfs(int matrix_order, lapack_int n, lapack_int nrhs, const float* d, const float* e,
-                          const float* df, const float* ef, const float* b, lapack_int ldb, float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_dptrfs(int matrix_order, lapack_int n, lapack_int nrhs, const double* d, const double* e,
-                          const double* df, const double* ef, const double* b, lapack_int ldb, double* x,
-                          lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_cptrfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* d,
-                          const lapack_complex_float* e, const float* df, const lapack_complex_float* ef,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_zptrfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* d,
-                          const lapack_complex_double* e, const double* df, const lapack_complex_double* ef,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-
-lapack_int LAPACKE_sptsv(int matrix_order, lapack_int n, lapack_int nrhs, float* d, float* e, float* b, lapack_int ldb);
-lapack_int LAPACKE_dptsv(int matrix_order, lapack_int n, lapack_int nrhs, double* d, double* e, double* b,
-                         lapack_int ldb);
-lapack_int LAPACKE_cptsv(int matrix_order, lapack_int n, lapack_int nrhs, float* d, lapack_complex_float* e,
-                         lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zptsv(int matrix_order, lapack_int n, lapack_int nrhs, double* d, lapack_complex_double* e,
-                         lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sptsvx(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const float* d, const float* e,
-                          float* df, float* ef, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_dptsvx(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const double* d, const double* e,
-                          double* df, double* ef, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-lapack_int LAPACKE_cptsvx(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const float* d,
-                          const lapack_complex_float* e, float* df, lapack_complex_float* ef,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zptsvx(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const double* d,
-                          const lapack_complex_double* e, double* df, lapack_complex_double* ef,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_spttrf(lapack_int n, float* d, float* e);
-lapack_int LAPACKE_dpttrf(lapack_int n, double* d, double* e);
-lapack_int LAPACKE_cpttrf(lapack_int n, float* d, lapack_complex_float* e);
-lapack_int LAPACKE_zpttrf(lapack_int n, double* d, lapack_complex_double* e);
-
-lapack_int LAPACKE_spttrs(int matrix_order, lapack_int n, lapack_int nrhs, const float* d, const float* e, float* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_dpttrs(int matrix_order, lapack_int n, lapack_int nrhs, const double* d, const double* e, double* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_cpttrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* d,
-                          const lapack_complex_float* e, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpttrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* d,
-                          const lapack_complex_double* e, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_ssbev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, float* ab,
-                         lapack_int ldab, float* w, float* z, lapack_int ldz);
-lapack_int LAPACKE_dsbev(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, double* ab,
-                         lapack_int ldab, double* w, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_ssbevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, float* ab,
-                          lapack_int ldab, float* w, float* z, lapack_int ldz);
-lapack_int LAPACKE_dsbevd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, double* ab,
-                          lapack_int ldab, double* w, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_ssbevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd, float* ab,
-                          lapack_int ldab, float* q, lapack_int ldq, float vl, float vu, lapack_int il, lapack_int iu,
-                          float abstol, lapack_int* m, float* w, float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_dsbevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd, double* ab,
-                          lapack_int ldab, double* q, lapack_int ldq, double vl, double vu, lapack_int il,
-                          lapack_int iu, double abstol, lapack_int* m, double* w, double* z, lapack_int ldz,
-                          lapack_int* ifail);
-
-lapack_int LAPACKE_ssbgst(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb, float* ab,
-                          lapack_int ldab, const float* bb, lapack_int ldbb, float* x, lapack_int ldx);
-lapack_int LAPACKE_dsbgst(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                          double* ab, lapack_int ldab, const double* bb, lapack_int ldbb, double* x, lapack_int ldx);
-
-lapack_int LAPACKE_ssbgv(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb, float* ab,
-                         lapack_int ldab, float* bb, lapack_int ldbb, float* w, float* z, lapack_int ldz);
-lapack_int LAPACKE_dsbgv(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb, double* ab,
-                         lapack_int ldab, double* bb, lapack_int ldbb, double* w, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_ssbgvd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb, float* ab,
-                          lapack_int ldab, float* bb, lapack_int ldbb, float* w, float* z, lapack_int ldz);
-lapack_int LAPACKE_dsbgvd(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                          double* ab, lapack_int ldab, double* bb, lapack_int ldbb, double* w, double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_ssbgvx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                          lapack_int kb, float* ab, lapack_int ldab, float* bb, lapack_int ldbb, float* q,
-                          lapack_int ldq, float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m,
-                          float* w, float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_dsbgvx(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                          lapack_int kb, double* ab, lapack_int ldab, double* bb, lapack_int ldbb, double* q,
-                          lapack_int ldq, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                          lapack_int* m, double* w, double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_ssbtrd(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd, float* ab,
-                          lapack_int ldab, float* d, float* e, float* q, lapack_int ldq);
-lapack_int LAPACKE_dsbtrd(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd, double* ab,
-                          lapack_int ldab, double* d, double* e, double* q, lapack_int ldq);
-
-lapack_int LAPACKE_ssfrk(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k, float alpha,
-                         const float* a, lapack_int lda, float beta, float* c);
-lapack_int LAPACKE_dsfrk(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k, double alpha,
-                         const double* a, lapack_int lda, double beta, double* c);
-
-lapack_int LAPACKE_sspcon(int matrix_order, char uplo, lapack_int n, const float* ap, const lapack_int* ipiv,
-                          float anorm, float* rcond);
-lapack_int LAPACKE_dspcon(int matrix_order, char uplo, lapack_int n, const double* ap, const lapack_int* ipiv,
-                          double anorm, double* rcond);
-lapack_int LAPACKE_cspcon(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                          const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_zspcon(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                          const lapack_int* ipiv, double anorm, double* rcond);
-
-lapack_int LAPACKE_sspev(int matrix_order, char jobz, char uplo, lapack_int n, float* ap, float* w, float* z,
-                         lapack_int ldz);
-lapack_int LAPACKE_dspev(int matrix_order, char jobz, char uplo, lapack_int n, double* ap, double* w, double* z,
-                         lapack_int ldz);
-
-lapack_int LAPACKE_sspevd(int matrix_order, char jobz, char uplo, lapack_int n, float* ap, float* w, float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_dspevd(int matrix_order, char jobz, char uplo, lapack_int n, double* ap, double* w, double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_sspevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, float* ap, float vl,
-                          float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z,
-                          lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_dspevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, double* ap, double vl,
-                          double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w, double* z,
-                          lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_sspgst(int matrix_order, lapack_int itype, char uplo, lapack_int n, float* ap, const float* bp);
-lapack_int LAPACKE_dspgst(int matrix_order, lapack_int itype, char uplo, lapack_int n, double* ap, const double* bp);
-
-lapack_int LAPACKE_sspgv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* ap, float* bp,
-                         float* w, float* z, lapack_int ldz);
-lapack_int LAPACKE_dspgv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* ap, double* bp,
-                         double* w, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_sspgvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* ap, float* bp,
-                          float* w, float* z, lapack_int ldz);
-lapack_int LAPACKE_dspgvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* ap,
-                          double* bp, double* w, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_sspgvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n, float* ap,
-                          float* bp, float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m,
-                          float* w, float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_dspgvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                          double* ap, double* bp, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                          lapack_int* m, double* w, double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_ssprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap, const float* afp,
-                          const lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* ferr,
-                          float* berr);
-lapack_int LAPACKE_dsprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                          const double* afp, const lapack_int* ipiv, const double* b, lapack_int ldb, double* x,
-                          lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_csprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* ap,
-                          const lapack_complex_float* afp, const lapack_int* ipiv, const lapack_complex_float* b,
-                          lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_zsprfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* ap,
-                          const lapack_complex_double* afp, const lapack_int* ipiv, const lapack_complex_double* b,
-                          lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_sspsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* ap, lapack_int* ipiv,
-                         float* b, lapack_int ldb);
-lapack_int LAPACKE_dspsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* ap, lapack_int* ipiv,
-                         double* b, lapack_int ldb);
-lapack_int LAPACKE_cspsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* ap,
-                         lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zspsv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* ap,
-                         lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sspsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const float* ap,
-                          float* afp, lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx,
-                          float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_dspsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                          double* afp, lapack_int* ipiv, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-lapack_int LAPACKE_cspsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* ap, lapack_complex_float* afp, lapack_int* ipiv,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zspsvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* ap, lapack_complex_double* afp, lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_ssptrd(int matrix_order, char uplo, lapack_int n, float* ap, float* d, float* e, float* tau);
-lapack_int LAPACKE_dsptrd(int matrix_order, char uplo, lapack_int n, double* ap, double* d, double* e, double* tau);
-
-lapack_int LAPACKE_ssptrf(int matrix_order, char uplo, lapack_int n, float* ap, lapack_int* ipiv);
-lapack_int LAPACKE_dsptrf(int matrix_order, char uplo, lapack_int n, double* ap, lapack_int* ipiv);
-lapack_int LAPACKE_csptrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, lapack_int* ipiv);
-lapack_int LAPACKE_zsptrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, lapack_int* ipiv);
-
-lapack_int LAPACKE_ssptri(int matrix_order, char uplo, lapack_int n, float* ap, const lapack_int* ipiv);
-lapack_int LAPACKE_dsptri(int matrix_order, char uplo, lapack_int n, double* ap, const lapack_int* ipiv);
-lapack_int LAPACKE_csptri(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, const lapack_int* ipiv);
-lapack_int LAPACKE_zsptri(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, const lapack_int* ipiv);
-
-lapack_int LAPACKE_ssptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap,
-                          const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dsptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                          const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_csptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* ap,
-                          const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zsptrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* ap,
-                          const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sstebz(char range, char order, lapack_int n, float vl, float vu, lapack_int il, lapack_int iu,
-                          float abstol, const float* d, const float* e, lapack_int* m, lapack_int* nsplit, float* w,
-                          lapack_int* iblock, lapack_int* isplit);
-lapack_int LAPACKE_dstebz(char range, char order, lapack_int n, double vl, double vu, lapack_int il, lapack_int iu,
-                          double abstol, const double* d, const double* e, lapack_int* m, lapack_int* nsplit, double* w,
-                          lapack_int* iblock, lapack_int* isplit);
-
-lapack_int LAPACKE_sstedc(int matrix_order, char compz, lapack_int n, float* d, float* e, float* z, lapack_int ldz);
-lapack_int LAPACKE_dstedc(int matrix_order, char compz, lapack_int n, double* d, double* e, double* z, lapack_int ldz);
-lapack_int LAPACKE_cstedc(int matrix_order, char compz, lapack_int n, float* d, float* e, lapack_complex_float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_zstedc(int matrix_order, char compz, lapack_int n, double* d, double* e, lapack_complex_double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_sstegr(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl, float vu,
-                          lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z, lapack_int ldz,
-                          lapack_int* isuppz);
-lapack_int LAPACKE_dstegr(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                          double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w, double* z,
-                          lapack_int ldz, lapack_int* isuppz);
-lapack_int LAPACKE_cstegr(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl, float vu,
-                          lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, lapack_complex_float* z,
-                          lapack_int ldz, lapack_int* isuppz);
-lapack_int LAPACKE_zstegr(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                          double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          lapack_complex_double* z, lapack_int ldz, lapack_int* isuppz);
-
-lapack_int LAPACKE_sstein(int matrix_order, lapack_int n, const float* d, const float* e, lapack_int m, const float* w,
-                          const lapack_int* iblock, const lapack_int* isplit, float* z, lapack_int ldz,
-                          lapack_int* ifailv);
-lapack_int LAPACKE_dstein(int matrix_order, lapack_int n, const double* d, const double* e, lapack_int m,
-                          const double* w, const lapack_int* iblock, const lapack_int* isplit, double* z,
-                          lapack_int ldz, lapack_int* ifailv);
-lapack_int LAPACKE_cstein(int matrix_order, lapack_int n, const float* d, const float* e, lapack_int m, const float* w,
-                          const lapack_int* iblock, const lapack_int* isplit, lapack_complex_float* z, lapack_int ldz,
-                          lapack_int* ifailv);
-lapack_int LAPACKE_zstein(int matrix_order, lapack_int n, const double* d, const double* e, lapack_int m,
-                          const double* w, const lapack_int* iblock, const lapack_int* isplit, lapack_complex_double* z,
-                          lapack_int ldz, lapack_int* ifailv);
-
-lapack_int LAPACKE_sstemr(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl, float vu,
-                          lapack_int il, lapack_int iu, lapack_int* m, float* w, float* z, lapack_int ldz,
-                          lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac);
-lapack_int LAPACKE_dstemr(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                          double vu, lapack_int il, lapack_int iu, lapack_int* m, double* w, double* z, lapack_int ldz,
-                          lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac);
-lapack_int LAPACKE_cstemr(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl, float vu,
-                          lapack_int il, lapack_int iu, lapack_int* m, float* w, lapack_complex_float* z,
-                          lapack_int ldz, lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac);
-lapack_int LAPACKE_zstemr(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                          double vu, lapack_int il, lapack_int iu, lapack_int* m, double* w, lapack_complex_double* z,
-                          lapack_int ldz, lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac);
-
-lapack_int LAPACKE_ssteqr(int matrix_order, char compz, lapack_int n, float* d, float* e, float* z, lapack_int ldz);
-lapack_int LAPACKE_dsteqr(int matrix_order, char compz, lapack_int n, double* d, double* e, double* z, lapack_int ldz);
-lapack_int LAPACKE_csteqr(int matrix_order, char compz, lapack_int n, float* d, float* e, lapack_complex_float* z,
-                          lapack_int ldz);
-lapack_int LAPACKE_zsteqr(int matrix_order, char compz, lapack_int n, double* d, double* e, lapack_complex_double* z,
-                          lapack_int ldz);
-
-lapack_int LAPACKE_ssterf(lapack_int n, float* d, float* e);
-lapack_int LAPACKE_dsterf(lapack_int n, double* d, double* e);
-
-lapack_int LAPACKE_sstev(int matrix_order, char jobz, lapack_int n, float* d, float* e, float* z, lapack_int ldz);
-lapack_int LAPACKE_dstev(int matrix_order, char jobz, lapack_int n, double* d, double* e, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_sstevd(int matrix_order, char jobz, lapack_int n, float* d, float* e, float* z, lapack_int ldz);
-lapack_int LAPACKE_dstevd(int matrix_order, char jobz, lapack_int n, double* d, double* e, double* z, lapack_int ldz);
-
-lapack_int LAPACKE_sstevr(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl, float vu,
-                          lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z, lapack_int ldz,
-                          lapack_int* isuppz);
-lapack_int LAPACKE_dstevr(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                          double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w, double* z,
-                          lapack_int ldz, lapack_int* isuppz);
-
-lapack_int LAPACKE_sstevx(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl, float vu,
-                          lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z, lapack_int ldz,
-                          lapack_int* ifail);
-lapack_int LAPACKE_dstevx(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                          double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w, double* z,
-                          lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_ssycon(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda,
-                          const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_dsycon(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda,
-                          const lapack_int* ipiv, double anorm, double* rcond);
-lapack_int LAPACKE_csycon(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                          const lapack_int* ipiv, float anorm, float* rcond);
-lapack_int LAPACKE_zsycon(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          const lapack_int* ipiv, double anorm, double* rcond);
-
-lapack_int LAPACKE_ssyequb(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda, float* s,
-                           float* scond, float* amax);
-lapack_int LAPACKE_dsyequb(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda, double* s,
-                           double* scond, double* amax);
-lapack_int LAPACKE_csyequb(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                           float* s, float* scond, float* amax);
-lapack_int LAPACKE_zsyequb(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                           double* s, double* scond, double* amax);
-
-lapack_int LAPACKE_ssyev(int matrix_order, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w);
-lapack_int LAPACKE_dsyev(int matrix_order, char jobz, char uplo, lapack_int n, double* a, lapack_int lda, double* w);
-
-lapack_int LAPACKE_ssyevd(int matrix_order, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w);
-lapack_int LAPACKE_dsyevd(int matrix_order, char jobz, char uplo, lapack_int n, double* a, lapack_int lda, double* w);
-
-lapack_int LAPACKE_ssyevr(int matrix_order, char jobz, char range, char uplo, lapack_int n, float* a, lapack_int lda,
-                          float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                          float* z, lapack_int ldz, lapack_int* isuppz);
-lapack_int LAPACKE_dsyevr(int matrix_order, char jobz, char range, char uplo, lapack_int n, double* a, lapack_int lda,
-                          double vl, double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          double* z, lapack_int ldz, lapack_int* isuppz);
-
-lapack_int LAPACKE_ssyevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, float* a, lapack_int lda,
-                          float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                          float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_dsyevx(int matrix_order, char jobz, char range, char uplo, lapack_int n, double* a, lapack_int lda,
-                          double vl, double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                          double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_ssygst(int matrix_order, lapack_int itype, char uplo, lapack_int n, float* a, lapack_int lda,
-                          const float* b, lapack_int ldb);
-lapack_int LAPACKE_dsygst(int matrix_order, lapack_int itype, char uplo, lapack_int n, double* a, lapack_int lda,
-                          const double* b, lapack_int ldb);
-
-lapack_int LAPACKE_ssygv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* a,
-                         lapack_int lda, float* b, lapack_int ldb, float* w);
-lapack_int LAPACKE_dsygv(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* a,
-                         lapack_int lda, double* b, lapack_int ldb, double* w);
-
-lapack_int LAPACKE_ssygvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* a,
-                          lapack_int lda, float* b, lapack_int ldb, float* w);
-lapack_int LAPACKE_dsygvd(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* a,
-                          lapack_int lda, double* b, lapack_int ldb, double* w);
-
-lapack_int LAPACKE_ssygvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n, float* a,
-                          lapack_int lda, float* b, lapack_int ldb, float vl, float vu, lapack_int il, lapack_int iu,
-                          float abstol, lapack_int* m, float* w, float* z, lapack_int ldz, lapack_int* ifail);
-lapack_int LAPACKE_dsygvx(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n, double* a,
-                          lapack_int lda, double* b, lapack_int ldb, double vl, double vu, lapack_int il, lapack_int iu,
-                          double abstol, lapack_int* m, double* w, double* z, lapack_int ldz, lapack_int* ifail);
-
-lapack_int LAPACKE_ssyrfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                          const float* af, lapack_int ldaf, const lapack_int* ipiv, const float* b, lapack_int ldb,
-                          float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dsyrfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                          const double* af, lapack_int ldaf, const lapack_int* ipiv, const double* b, lapack_int ldb,
-                          double* x, lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_csyrfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* af, lapack_int ldaf, const lapack_int* ipiv,
-                          const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_zsyrfs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* af, lapack_int ldaf, const lapack_int* ipiv,
-                          const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-
-lapack_int LAPACKE_ssyrfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const float* a,
-                           lapack_int lda, const float* af, lapack_int ldaf, const lapack_int* ipiv, const float* s,
-                           const float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_dsyrfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const double* a,
-                           lapack_int lda, const double* af, lapack_int ldaf, const lapack_int* ipiv, const double* s,
-                           const double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-lapack_int LAPACKE_csyrfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                           lapack_int ldaf, const lapack_int* ipiv, const float* s, const lapack_complex_float* b,
-                           lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_zsyrfsx(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                           const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                           lapack_int ldaf, const lapack_int* ipiv, const double* s, const lapack_complex_double* b,
-                           lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* rcond, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-
-lapack_int LAPACKE_ssysv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                         lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dsysv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                         lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_csysv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                         lapack_int lda, lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zsysv(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                         lapack_int lda, lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_ssysvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                          lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, const float* b, lapack_int ldb,
-                          float* x, lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_dsysvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                          lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, const double* b,
-                          lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr, double* berr);
-lapack_int LAPACKE_csysvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                          lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                          lapack_int ldx, float* rcond, float* ferr, float* berr);
-lapack_int LAPACKE_zsysvx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                          lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                          lapack_int ldx, double* rcond, double* ferr, double* berr);
-
-lapack_int LAPACKE_ssysvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* a,
-                           lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, char* equed, float* s,
-                           float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_dsysvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* a,
-                           lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, char* equed, double* s,
-                           double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* rpvgrw,
-                           double* berr, lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                           lapack_int nparams, double* params);
-lapack_int LAPACKE_csysvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                           lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                           lapack_int* ipiv, char* equed, float* s, lapack_complex_float* b, lapack_int ldb,
-                           lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                           lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                           float* params);
-lapack_int LAPACKE_zsysvxx(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                           lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                           lapack_int* ipiv, char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                           lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                           lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                           double* params);
-
-lapack_int LAPACKE_ssytrd(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, float* d, float* e,
-                          float* tau);
-lapack_int LAPACKE_dsytrd(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, double* d, double* e,
-                          double* tau);
-
-lapack_int LAPACKE_ssytrf(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, lapack_int* ipiv);
-lapack_int LAPACKE_dsytrf(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, lapack_int* ipiv);
-lapack_int LAPACKE_csytrf(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_int* ipiv);
-lapack_int LAPACKE_zsytrf(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_int* ipiv);
-
-lapack_int LAPACKE_ssytri(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, const lapack_int* ipiv);
-lapack_int LAPACKE_dsytri(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, const lapack_int* ipiv);
-lapack_int LAPACKE_csytri(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          const lapack_int* ipiv);
-lapack_int LAPACKE_zsytri(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          const lapack_int* ipiv);
-
-lapack_int LAPACKE_ssytrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                          const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dsytrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                          const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_csytrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                          lapack_int lda, const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zsytrs(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                          lapack_int lda, const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stbcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                          const float* ab, lapack_int ldab, float* rcond);
-lapack_int LAPACKE_dtbcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                          const double* ab, lapack_int ldab, double* rcond);
-lapack_int LAPACKE_ctbcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                          const lapack_complex_float* ab, lapack_int ldab, float* rcond);
-lapack_int LAPACKE_ztbcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                          const lapack_complex_double* ab, lapack_int ldab, double* rcond);
-
-lapack_int LAPACKE_stbrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const float* ab, lapack_int ldab, const float* b, lapack_int ldb,
-                          const float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dtbrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const double* ab, lapack_int ldab, const double* b, lapack_int ldb,
-                          const double* x, lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_ctbrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab,
-                          const lapack_complex_float* b, lapack_int ldb, const lapack_complex_float* x, lapack_int ldx,
-                          float* ferr, float* berr);
-lapack_int LAPACKE_ztbrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                          const lapack_complex_double* b, lapack_int ldb, const lapack_complex_double* x,
-                          lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_stbtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const float* ab, lapack_int ldab, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtbtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const double* ab, lapack_int ldab, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctbtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* b,
-                          lapack_int ldb);
-lapack_int LAPACKE_ztbtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                          lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* b,
-                          lapack_int ldb);
-
-lapack_int LAPACKE_stfsm(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                         lapack_int n, float alpha, const float* a, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtfsm(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                         lapack_int n, double alpha, const double* a, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctfsm(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                         lapack_int n, lapack_complex_float alpha, const lapack_complex_float* a,
-                         lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztfsm(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                         lapack_int n, lapack_complex_double alpha, const lapack_complex_double* a,
-                         lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stftri(int matrix_order, char transr, char uplo, char diag, lapack_int n, float* a);
-lapack_int LAPACKE_dtftri(int matrix_order, char transr, char uplo, char diag, lapack_int n, double* a);
-lapack_int LAPACKE_ctftri(int matrix_order, char transr, char uplo, char diag, lapack_int n, lapack_complex_float* a);
-lapack_int LAPACKE_ztftri(int matrix_order, char transr, char uplo, char diag, lapack_int n, lapack_complex_double* a);
-
-lapack_int LAPACKE_stfttp(int matrix_order, char transr, char uplo, lapack_int n, const float* arf, float* ap);
-lapack_int LAPACKE_dtfttp(int matrix_order, char transr, char uplo, lapack_int n, const double* arf, double* ap);
-lapack_int LAPACKE_ctfttp(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* arf,
-                          lapack_complex_float* ap);
-lapack_int LAPACKE_ztfttp(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* arf,
-                          lapack_complex_double* ap);
-
-lapack_int LAPACKE_stfttr(int matrix_order, char transr, char uplo, lapack_int n, const float* arf, float* a,
-                          lapack_int lda);
-lapack_int LAPACKE_dtfttr(int matrix_order, char transr, char uplo, lapack_int n, const double* arf, double* a,
-                          lapack_int lda);
-lapack_int LAPACKE_ctfttr(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* arf,
-                          lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_ztfttr(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* arf,
-                          lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_stgevc(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                          const float* s, lapack_int lds, const float* p, lapack_int ldp, float* vl, lapack_int ldvl,
-                          float* vr, lapack_int ldvr, lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_dtgevc(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                          const double* s, lapack_int lds, const double* p, lapack_int ldp, double* vl, lapack_int ldvl,
-                          double* vr, lapack_int ldvr, lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ctgevc(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                          const lapack_complex_float* s, lapack_int lds, const lapack_complex_float* p, lapack_int ldp,
-                          lapack_complex_float* vl, lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr,
-                          lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ztgevc(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                          const lapack_complex_double* s, lapack_int lds, const lapack_complex_double* p,
-                          lapack_int ldp, lapack_complex_double* vl, lapack_int ldvl, lapack_complex_double* vr,
-                          lapack_int ldvr, lapack_int mm, lapack_int* m);
-
-lapack_int LAPACKE_stgexc(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n, float* a,
-                          lapack_int lda, float* b, lapack_int ldb, float* q, lapack_int ldq, float* z, lapack_int ldz,
-                          lapack_int* ifst, lapack_int* ilst);
-lapack_int LAPACKE_dtgexc(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n, double* a,
-                          lapack_int lda, double* b, lapack_int ldb, double* q, lapack_int ldq, double* z,
-                          lapack_int ldz, lapack_int* ifst, lapack_int* ilst);
-lapack_int LAPACKE_ctgexc(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z, lapack_int ldz,
-                          lapack_int ifst, lapack_int ilst);
-lapack_int LAPACKE_ztgexc(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* q, lapack_int ldq, lapack_complex_double* z, lapack_int ldz,
-                          lapack_int ifst, lapack_int ilst);
-
-lapack_int LAPACKE_stgsen(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                          const lapack_logical* select, lapack_int n, float* a, lapack_int lda, float* b,
-                          lapack_int ldb, float* alphar, float* alphai, float* beta, float* q, lapack_int ldq, float* z,
-                          lapack_int ldz, lapack_int* m, float* pl, float* pr, float* dif);
-lapack_int LAPACKE_dtgsen(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                          const lapack_logical* select, lapack_int n, double* a, lapack_int lda, double* b,
-                          lapack_int ldb, double* alphar, double* alphai, double* beta, double* q, lapack_int ldq,
-                          double* z, lapack_int ldz, lapack_int* m, double* pl, double* pr, double* dif);
-lapack_int LAPACKE_ctgsen(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                          const lapack_logical* select, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* b, lapack_int ldb, lapack_complex_float* alpha,
-                          lapack_complex_float* beta, lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z,
-                          lapack_int ldz, lapack_int* m, float* pl, float* pr, float* dif);
-lapack_int LAPACKE_ztgsen(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                          const lapack_logical* select, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* b, lapack_int ldb, lapack_complex_double* alpha,
-                          lapack_complex_double* beta, lapack_complex_double* q, lapack_int ldq,
-                          lapack_complex_double* z, lapack_int ldz, lapack_int* m, double* pl, double* pr, double* dif);
-
-lapack_int LAPACKE_stgsja(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          lapack_int k, lapack_int l, float* a, lapack_int lda, float* b, lapack_int ldb, float tola,
-                          float tolb, float* alpha, float* beta, float* u, lapack_int ldu, float* v, lapack_int ldv,
-                          float* q, lapack_int ldq, lapack_int* ncycle);
-lapack_int LAPACKE_dtgsja(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          lapack_int k, lapack_int l, double* a, lapack_int lda, double* b, lapack_int ldb, double tola,
-                          double tolb, double* alpha, double* beta, double* u, lapack_int ldu, double* v,
-                          lapack_int ldv, double* q, lapack_int ldq, lapack_int* ncycle);
-lapack_int LAPACKE_ctgsja(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          lapack_int k, lapack_int l, lapack_complex_float* a, lapack_int lda, lapack_complex_float* b,
-                          lapack_int ldb, float tola, float tolb, float* alpha, float* beta, lapack_complex_float* u,
-                          lapack_int ldu, lapack_complex_float* v, lapack_int ldv, lapack_complex_float* q,
-                          lapack_int ldq, lapack_int* ncycle);
-lapack_int LAPACKE_ztgsja(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p, lapack_int n,
-                          lapack_int k, lapack_int l, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* b, lapack_int ldb, double tola, double tolb, double* alpha,
-                          double* beta, lapack_complex_double* u, lapack_int ldu, lapack_complex_double* v,
-                          lapack_int ldv, lapack_complex_double* q, lapack_int ldq, lapack_int* ncycle);
-
-lapack_int LAPACKE_stgsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const float* a, lapack_int lda, const float* b, lapack_int ldb, const float* vl,
-                          lapack_int ldvl, const float* vr, lapack_int ldvr, float* s, float* dif, lapack_int mm,
-                          lapack_int* m);
-lapack_int LAPACKE_dtgsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const double* a, lapack_int lda, const double* b, lapack_int ldb, const double* vl,
-                          lapack_int ldvl, const double* vr, lapack_int ldvr, double* s, double* dif, lapack_int mm,
-                          lapack_int* m);
-lapack_int LAPACKE_ctgsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b, lapack_int ldb,
-                          const lapack_complex_float* vl, lapack_int ldvl, const lapack_complex_float* vr,
-                          lapack_int ldvr, float* s, float* dif, lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ztgsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                          lapack_int ldb, const lapack_complex_double* vl, lapack_int ldvl,
-                          const lapack_complex_double* vr, lapack_int ldvr, double* s, double* dif, lapack_int mm,
-                          lapack_int* m);
-
-lapack_int LAPACKE_stgsyl(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n, const float* a,
-                          lapack_int lda, const float* b, lapack_int ldb, float* c, lapack_int ldc, const float* d,
-                          lapack_int ldd, const float* e, lapack_int lde, float* f, lapack_int ldf, float* scale,
-                          float* dif);
-lapack_int LAPACKE_dtgsyl(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n, const double* a,
-                          lapack_int lda, const double* b, lapack_int ldb, double* c, lapack_int ldc, const double* d,
-                          lapack_int ldd, const double* e, lapack_int lde, double* f, lapack_int ldf, double* scale,
-                          double* dif);
-lapack_int LAPACKE_ctgsyl(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* c, lapack_int ldc, const lapack_complex_float* d, lapack_int ldd,
-                          const lapack_complex_float* e, lapack_int lde, lapack_complex_float* f, lapack_int ldf,
-                          float* scale, float* dif);
-lapack_int LAPACKE_ztgsyl(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                          lapack_int ldb, lapack_complex_double* c, lapack_int ldc, const lapack_complex_double* d,
-                          lapack_int ldd, const lapack_complex_double* e, lapack_int lde, lapack_complex_double* f,
-                          lapack_int ldf, double* scale, double* dif);
-
-lapack_int LAPACKE_stpcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, const float* ap,
-                          float* rcond);
-lapack_int LAPACKE_dtpcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, const double* ap,
-                          double* rcond);
-lapack_int LAPACKE_ctpcon(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                          const lapack_complex_float* ap, float* rcond);
-lapack_int LAPACKE_ztpcon(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                          const lapack_complex_double* ap, double* rcond);
-
-lapack_int LAPACKE_stprfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const float* ap, const float* b, lapack_int ldb, const float* x, lapack_int ldx, float* ferr,
-                          float* berr);
-lapack_int LAPACKE_dtprfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const double* ap, const double* b, lapack_int ldb, const double* x, lapack_int ldx,
-                          double* ferr, double* berr);
-lapack_int LAPACKE_ctprfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* ap, const lapack_complex_float* b, lapack_int ldb,
-                          const lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_ztprfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* ap, const lapack_complex_double* b, lapack_int ldb,
-                          const lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_stptri(int matrix_order, char uplo, char diag, lapack_int n, float* ap);
-lapack_int LAPACKE_dtptri(int matrix_order, char uplo, char diag, lapack_int n, double* ap);
-lapack_int LAPACKE_ctptri(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_float* ap);
-lapack_int LAPACKE_ztptri(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_double* ap);
-
-lapack_int LAPACKE_stptrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const float* ap, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtptrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const double* ap, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctptrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* ap, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztptrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* ap, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stpttf(int matrix_order, char transr, char uplo, lapack_int n, const float* ap, float* arf);
-lapack_int LAPACKE_dtpttf(int matrix_order, char transr, char uplo, lapack_int n, const double* ap, double* arf);
-lapack_int LAPACKE_ctpttf(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* ap,
-                          lapack_complex_float* arf);
-lapack_int LAPACKE_ztpttf(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* ap,
-                          lapack_complex_double* arf);
-
-lapack_int LAPACKE_stpttr(int matrix_order, char uplo, lapack_int n, const float* ap, float* a, lapack_int lda);
-lapack_int LAPACKE_dtpttr(int matrix_order, char uplo, lapack_int n, const double* ap, double* a, lapack_int lda);
-lapack_int LAPACKE_ctpttr(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                          lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_ztpttr(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                          lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_strcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, const float* a,
-                          lapack_int lda, float* rcond);
-lapack_int LAPACKE_dtrcon(int matrix_order, char norm, char uplo, char diag, lapack_int n, const double* a,
-                          lapack_int lda, double* rcond);
-lapack_int LAPACKE_ctrcon(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                          const lapack_complex_float* a, lapack_int lda, float* rcond);
-lapack_int LAPACKE_ztrcon(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                          const lapack_complex_double* a, lapack_int lda, double* rcond);
-
-lapack_int LAPACKE_strevc(int matrix_order, char side, char howmny, lapack_logical* select, lapack_int n,
-                          const float* t, lapack_int ldt, float* vl, lapack_int ldvl, float* vr, lapack_int ldvr,
-                          lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_dtrevc(int matrix_order, char side, char howmny, lapack_logical* select, lapack_int n,
-                          const double* t, lapack_int ldt, double* vl, lapack_int ldvl, double* vr, lapack_int ldvr,
-                          lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ctrevc(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                          lapack_complex_float* t, lapack_int ldt, lapack_complex_float* vl, lapack_int ldvl,
-                          lapack_complex_float* vr, lapack_int ldvr, lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ztrevc(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                          lapack_complex_double* t, lapack_int ldt, lapack_complex_double* vl, lapack_int ldvl,
-                          lapack_complex_double* vr, lapack_int ldvr, lapack_int mm, lapack_int* m);
-
-lapack_int LAPACKE_strexc(int matrix_order, char compq, lapack_int n, float* t, lapack_int ldt, float* q,
-                          lapack_int ldq, lapack_int* ifst, lapack_int* ilst);
-lapack_int LAPACKE_dtrexc(int matrix_order, char compq, lapack_int n, double* t, lapack_int ldt, double* q,
-                          lapack_int ldq, lapack_int* ifst, lapack_int* ilst);
-lapack_int LAPACKE_ctrexc(int matrix_order, char compq, lapack_int n, lapack_complex_float* t, lapack_int ldt,
-                          lapack_complex_float* q, lapack_int ldq, lapack_int ifst, lapack_int ilst);
-lapack_int LAPACKE_ztrexc(int matrix_order, char compq, lapack_int n, lapack_complex_double* t, lapack_int ldt,
-                          lapack_complex_double* q, lapack_int ldq, lapack_int ifst, lapack_int ilst);
-
-lapack_int LAPACKE_strrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const float* a, lapack_int lda, const float* b, lapack_int ldb, const float* x,
-                          lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_dtrrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const double* a, lapack_int lda, const double* b, lapack_int ldb, const double* x,
-                          lapack_int ldx, double* ferr, double* berr);
-lapack_int LAPACKE_ctrrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b, lapack_int ldb,
-                          const lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr);
-lapack_int LAPACKE_ztrrfs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                          lapack_int ldb, const lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr);
-
-lapack_int LAPACKE_strsen(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n, float* t,
-                          lapack_int ldt, float* q, lapack_int ldq, float* wr, float* wi, lapack_int* m, float* s,
-                          float* sep);
-lapack_int LAPACKE_dtrsen(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n, double* t,
-                          lapack_int ldt, double* q, lapack_int ldq, double* wr, double* wi, lapack_int* m, double* s,
-                          double* sep);
-lapack_int LAPACKE_ctrsen(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n,
-                          lapack_complex_float* t, lapack_int ldt, lapack_complex_float* q, lapack_int ldq,
-                          lapack_complex_float* w, lapack_int* m, float* s, float* sep);
-lapack_int LAPACKE_ztrsen(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n,
-                          lapack_complex_double* t, lapack_int ldt, lapack_complex_double* q, lapack_int ldq,
-                          lapack_complex_double* w, lapack_int* m, double* s, double* sep);
-
-lapack_int LAPACKE_strsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const float* t, lapack_int ldt, const float* vl, lapack_int ldvl, const float* vr,
-                          lapack_int ldvr, float* s, float* sep, lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_dtrsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const double* t, lapack_int ldt, const double* vl, lapack_int ldvl, const double* vr,
-                          lapack_int ldvr, double* s, double* sep, lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ctrsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const lapack_complex_float* t, lapack_int ldt, const lapack_complex_float* vl,
-                          lapack_int ldvl, const lapack_complex_float* vr, lapack_int ldvr, float* s, float* sep,
-                          lapack_int mm, lapack_int* m);
-lapack_int LAPACKE_ztrsna(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                          const lapack_complex_double* t, lapack_int ldt, const lapack_complex_double* vl,
-                          lapack_int ldvl, const lapack_complex_double* vr, lapack_int ldvr, double* s, double* sep,
-                          lapack_int mm, lapack_int* m);
-
-lapack_int LAPACKE_strsyl(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                          const float* a, lapack_int lda, const float* b, lapack_int ldb, float* c, lapack_int ldc,
-                          float* scale);
-lapack_int LAPACKE_dtrsyl(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                          const double* a, lapack_int lda, const double* b, lapack_int ldb, double* c, lapack_int ldc,
-                          double* scale);
-lapack_int LAPACKE_ctrsyl(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b, lapack_int ldb,
-                          lapack_complex_float* c, lapack_int ldc, float* scale);
-lapack_int LAPACKE_ztrsyl(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                          lapack_int ldb, lapack_complex_double* c, lapack_int ldc, double* scale);
-
-lapack_int LAPACKE_strtri(int matrix_order, char uplo, char diag, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dtrtri(int matrix_order, char uplo, char diag, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_ctrtri(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_float* a,
-                          lapack_int lda);
-lapack_int LAPACKE_ztrtri(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_double* a,
-                          lapack_int lda);
-
-lapack_int LAPACKE_strtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const float* a, lapack_int lda, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtrtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const double* a, lapack_int lda, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctrtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztrtrs(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                          const lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_strttf(int matrix_order, char transr, char uplo, lapack_int n, const float* a, lapack_int lda,
-                          float* arf);
-lapack_int LAPACKE_dtrttf(int matrix_order, char transr, char uplo, lapack_int n, const double* a, lapack_int lda,
-                          double* arf);
-lapack_int LAPACKE_ctrttf(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* arf);
-lapack_int LAPACKE_ztrttf(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* arf);
-
-lapack_int LAPACKE_strttp(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda, float* ap);
-lapack_int LAPACKE_dtrttp(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda, double* ap);
-lapack_int LAPACKE_ctrttp(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* ap);
-lapack_int LAPACKE_ztrttp(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* ap);
-
-lapack_int LAPACKE_stzrzf(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau);
-lapack_int LAPACKE_dtzrzf(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau);
-lapack_int LAPACKE_ctzrzf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* tau);
-lapack_int LAPACKE_ztzrzf(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* tau);
-
-lapack_int LAPACKE_cungbr(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k,
-                          lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau);
-lapack_int LAPACKE_zungbr(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k,
-                          lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cunghr(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* tau);
-lapack_int LAPACKE_zunghr(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cunglq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* tau);
-lapack_int LAPACKE_zunglq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cungql(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* tau);
-lapack_int LAPACKE_zungql(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cungqr(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* tau);
-lapack_int LAPACKE_zungqr(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cungrq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                          lapack_int lda, const lapack_complex_float* tau);
-lapack_int LAPACKE_zungrq(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                          lapack_int lda, const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cungtr(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                          const lapack_complex_float* tau);
-lapack_int LAPACKE_zungtr(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                          const lapack_complex_double* tau);
-
-lapack_int LAPACKE_cunmbr(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmbr(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmhr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, const lapack_complex_float* a, lapack_int lda,
-                          const lapack_complex_float* tau, lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmhr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                          lapack_int ihi, const lapack_complex_double* a, lapack_int lda,
-                          const lapack_complex_double* tau, lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmlq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmlq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmql(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmql(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmqr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmqr(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmrq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmrq(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmrz(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          lapack_int l, const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmrz(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                          lapack_int l, const lapack_complex_double* a, lapack_int lda,
-                          const lapack_complex_double* tau, lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cunmtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                          lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zunmtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                          lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_cupgtr(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                          const lapack_complex_float* tau, lapack_complex_float* q, lapack_int ldq);
-lapack_int LAPACKE_zupgtr(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                          const lapack_complex_double* tau, lapack_complex_double* q, lapack_int ldq);
-
-lapack_int LAPACKE_cupmtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const lapack_complex_float* ap, const lapack_complex_float* tau, lapack_complex_float* c,
-                          lapack_int ldc);
-lapack_int LAPACKE_zupmtr(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                          const lapack_complex_double* ap, const lapack_complex_double* tau, lapack_complex_double* c,
-                          lapack_int ldc);
-
-lapack_int LAPACKE_sbdsdc_work(int matrix_order, char uplo, char compq, lapack_int n, float* d, float* e, float* u,
-                               lapack_int ldu, float* vt, lapack_int ldvt, float* q, lapack_int* iq, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dbdsdc_work(int matrix_order, char uplo, char compq, lapack_int n, double* d, double* e, double* u,
-                               lapack_int ldu, double* vt, lapack_int ldvt, double* q, lapack_int* iq, double* work,
-                               lapack_int* iwork);
-
-lapack_int LAPACKE_sbdsqr_work(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru,
-                               lapack_int ncc, float* d, float* e, float* vt, lapack_int ldvt, float* u, lapack_int ldu,
-                               float* c, lapack_int ldc, float* work);
-lapack_int LAPACKE_dbdsqr_work(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru,
-                               lapack_int ncc, double* d, double* e, double* vt, lapack_int ldvt, double* u,
-                               lapack_int ldu, double* c, lapack_int ldc, double* work);
-lapack_int LAPACKE_cbdsqr_work(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru,
-                               lapack_int ncc, float* d, float* e, lapack_complex_float* vt, lapack_int ldvt,
-                               lapack_complex_float* u, lapack_int ldu, lapack_complex_float* c, lapack_int ldc,
-                               float* work);
-lapack_int LAPACKE_zbdsqr_work(int matrix_order, char uplo, lapack_int n, lapack_int ncvt, lapack_int nru,
-                               lapack_int ncc, double* d, double* e, lapack_complex_double* vt, lapack_int ldvt,
-                               lapack_complex_double* u, lapack_int ldu, lapack_complex_double* c, lapack_int ldc,
-                               double* work);
-
-lapack_int LAPACKE_sdisna_work(char job, lapack_int m, lapack_int n, const float* d, float* sep);
-lapack_int LAPACKE_ddisna_work(char job, lapack_int m, lapack_int n, const double* d, double* sep);
-
-lapack_int LAPACKE_sgbbrd_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                               lapack_int ku, float* ab, lapack_int ldab, float* d, float* e, float* q, lapack_int ldq,
-                               float* pt, lapack_int ldpt, float* c, lapack_int ldc, float* work);
-lapack_int LAPACKE_dgbbrd_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                               lapack_int ku, double* ab, lapack_int ldab, double* d, double* e, double* q,
-                               lapack_int ldq, double* pt, lapack_int ldpt, double* c, lapack_int ldc, double* work);
-lapack_int LAPACKE_cgbbrd_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                               lapack_int ku, lapack_complex_float* ab, lapack_int ldab, float* d, float* e,
-                               lapack_complex_float* q, lapack_int ldq, lapack_complex_float* pt, lapack_int ldpt,
-                               lapack_complex_float* c, lapack_int ldc, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgbbrd_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int ncc, lapack_int kl,
-                               lapack_int ku, lapack_complex_double* ab, lapack_int ldab, double* d, double* e,
-                               lapack_complex_double* q, lapack_int ldq, lapack_complex_double* pt, lapack_int ldpt,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgbcon_work(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku, const float* ab,
-                               lapack_int ldab, const lapack_int* ipiv, float anorm, float* rcond, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dgbcon_work(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku,
-                               const double* ab, lapack_int ldab, const lapack_int* ipiv, double anorm, double* rcond,
-                               double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgbcon_work(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku,
-                               const lapack_complex_float* ab, lapack_int ldab, const lapack_int* ipiv, float anorm,
-                               float* rcond, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgbcon_work(int matrix_order, char norm, lapack_int n, lapack_int kl, lapack_int ku,
-                               const lapack_complex_double* ab, lapack_int ldab, const lapack_int* ipiv, double anorm,
-                               double* rcond, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgbequ_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const float* ab, lapack_int ldab, float* r, float* c, float* rowcnd, float* colcnd,
-                               float* amax);
-lapack_int LAPACKE_dgbequ_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const double* ab, lapack_int ldab, double* r, double* c, double* rowcnd, double* colcnd,
-                               double* amax);
-lapack_int LAPACKE_cgbequ_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const lapack_complex_float* ab, lapack_int ldab, float* r, float* c, float* rowcnd,
-                               float* colcnd, float* amax);
-lapack_int LAPACKE_zgbequ_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const lapack_complex_double* ab, lapack_int ldab, double* r, double* c, double* rowcnd,
-                               double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgbequb_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                                const float* ab, lapack_int ldab, float* r, float* c, float* rowcnd, float* colcnd,
-                                float* amax);
-lapack_int LAPACKE_dgbequb_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                                const double* ab, lapack_int ldab, double* r, double* c, double* rowcnd, double* colcnd,
-                                double* amax);
-lapack_int LAPACKE_cgbequb_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                                const lapack_complex_float* ab, lapack_int ldab, float* r, float* c, float* rowcnd,
-                                float* colcnd, float* amax);
-lapack_int LAPACKE_zgbequb_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                                const lapack_complex_double* ab, lapack_int ldab, double* r, double* c, double* rowcnd,
-                                double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgbrfs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const float* ab, lapack_int ldab, const float* afb, lapack_int ldafb,
-                               const lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx,
-                               float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgbrfs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const double* ab, lapack_int ldab, const double* afb, lapack_int ldafb,
-                               const lapack_int* ipiv, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                               double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgbrfs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab,
-                               const lapack_complex_float* afb, lapack_int ldafb, const lapack_int* ipiv,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgbrfs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                               const lapack_complex_double* afb, lapack_int ldafb, const lapack_int* ipiv,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgbrfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, const float* ab, lapack_int ldab, const float* afb, lapack_int ldafb,
-                                const lapack_int* ipiv, const float* r, const float* c, const float* b, lapack_int ldb,
-                                float* x, lapack_int ldx, float* rcond, float* berr, lapack_int n_err_bnds,
-                                float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params,
-                                float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgbrfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, const double* ab, lapack_int ldab, const double* afb, lapack_int ldafb,
-                                const lapack_int* ipiv, const double* r, const double* c, const double* b,
-                                lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgbrfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab,
-                                const lapack_complex_float* afb, lapack_int ldafb, const lapack_int* ipiv,
-                                const float* r, const float* c, const lapack_complex_float* b, lapack_int ldb,
-                                lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgbrfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                                const lapack_complex_double* afb, lapack_int ldafb, const lapack_int* ipiv,
-                                const double* r, const double* c, const lapack_complex_double* b, lapack_int ldb,
-                                lapack_complex_double* x, lapack_int ldx, double* rcond, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgbsv_work(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs, float* ab,
-                              lapack_int ldab, lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgbsv_work(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs, double* ab,
-                              lapack_int ldab, lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgbsv_work(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                              lapack_complex_float* ab, lapack_int ldab, lapack_int* ipiv, lapack_complex_float* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_zgbsv_work(int matrix_order, lapack_int n, lapack_int kl, lapack_int ku, lapack_int nrhs,
-                              lapack_complex_double* ab, lapack_int ldab, lapack_int* ipiv, lapack_complex_double* b,
-                              lapack_int ldb);
-
-lapack_int LAPACKE_sgbsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, float* ab, lapack_int ldab, float* afb, lapack_int ldafb,
-                               lapack_int* ipiv, char* equed, float* r, float* c, float* b, lapack_int ldb, float* x,
-                               lapack_int ldx, float* rcond, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgbsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, double* ab, lapack_int ldab, double* afb, lapack_int ldafb,
-                               lapack_int* ipiv, char* equed, double* r, double* c, double* b, lapack_int ldb,
-                               double* x, lapack_int ldx, double* rcond, double* ferr, double* berr, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cgbsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* afb,
-                               lapack_int ldafb, lapack_int* ipiv, char* equed, float* r, float* c,
-                               lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgbsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* afb,
-                               lapack_int ldafb, lapack_int* ipiv, char* equed, double* r, double* c,
-                               lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgbsvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, float* ab, lapack_int ldab, float* afb, lapack_int ldafb,
-                                lapack_int* ipiv, char* equed, float* r, float* c, float* b, lapack_int ldb, float* x,
-                                lapack_int ldx, float* rcond, float* rpvgrw, float* berr, lapack_int n_err_bnds,
-                                float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params,
-                                float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgbsvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, double* ab, lapack_int ldab, double* afb, lapack_int ldafb,
-                                lapack_int* ipiv, char* equed, double* r, double* c, double* b, lapack_int ldb,
-                                double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgbsvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* afb,
-                                lapack_int ldafb, lapack_int* ipiv, char* equed, float* r, float* c,
-                                lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                                float* rcond, float* rpvgrw, float* berr, lapack_int n_err_bnds, float* err_bnds_norm,
-                                float* err_bnds_comp, lapack_int nparams, float* params, lapack_complex_float* work,
-                                float* rwork);
-lapack_int LAPACKE_zgbsvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                                lapack_int nrhs, lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* afb,
-                                lapack_int ldafb, lapack_int* ipiv, char* equed, double* r, double* c,
-                                lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                                double* rcond, double* rpvgrw, double* berr, lapack_int n_err_bnds,
-                                double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params,
-                                lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgbtrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, float* ab,
-                               lapack_int ldab, lapack_int* ipiv);
-lapack_int LAPACKE_dgbtrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, double* ab,
-                               lapack_int ldab, lapack_int* ipiv);
-lapack_int LAPACKE_cgbtrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_complex_float* ab, lapack_int ldab, lapack_int* ipiv);
-lapack_int LAPACKE_zgbtrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_complex_double* ab, lapack_int ldab, lapack_int* ipiv);
-
-lapack_int LAPACKE_sgbtrs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const float* ab, lapack_int ldab, const lapack_int* ipiv, float* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_dgbtrs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const double* ab, lapack_int ldab, const lapack_int* ipiv, double* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_cgbtrs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab, const lapack_int* ipiv,
-                               lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgbtrs_work(int matrix_order, char trans, lapack_int n, lapack_int kl, lapack_int ku,
-                               lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                               const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sgebak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const float* scale, lapack_int m, float* v, lapack_int ldv);
-lapack_int LAPACKE_dgebak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const double* scale, lapack_int m, double* v, lapack_int ldv);
-lapack_int LAPACKE_cgebak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const float* scale, lapack_int m, lapack_complex_float* v, lapack_int ldv);
-lapack_int LAPACKE_zgebak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const double* scale, lapack_int m, lapack_complex_double* v, lapack_int ldv);
-
-lapack_int LAPACKE_sgebal_work(int matrix_order, char job, lapack_int n, float* a, lapack_int lda, lapack_int* ilo,
-                               lapack_int* ihi, float* scale);
-lapack_int LAPACKE_dgebal_work(int matrix_order, char job, lapack_int n, double* a, lapack_int lda, lapack_int* ilo,
-                               lapack_int* ihi, double* scale);
-lapack_int LAPACKE_cgebal_work(int matrix_order, char job, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* ilo, lapack_int* ihi, float* scale);
-lapack_int LAPACKE_zgebal_work(int matrix_order, char job, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* ilo, lapack_int* ihi, double* scale);
-
-lapack_int LAPACKE_sgebrd_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* d,
-                               float* e, float* tauq, float* taup, float* work, lapack_int lwork);
-lapack_int LAPACKE_dgebrd_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* d,
-                               double* e, double* tauq, double* taup, double* work, lapack_int lwork);
-lapack_int LAPACKE_cgebrd_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               float* d, float* e, lapack_complex_float* tauq, lapack_complex_float* taup,
-                               lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgebrd_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               double* d, double* e, lapack_complex_double* tauq, lapack_complex_double* taup,
-                               lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgecon_work(int matrix_order, char norm, lapack_int n, const float* a, lapack_int lda, float anorm,
-                               float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgecon_work(int matrix_order, char norm, lapack_int n, const double* a, lapack_int lda, double anorm,
-                               double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgecon_work(int matrix_order, char norm, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                               float anorm, float* rcond, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgecon_work(int matrix_order, char norm, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, double anorm, double* rcond, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgeequ_work(int matrix_order, lapack_int m, lapack_int n, const float* a, lapack_int lda, float* r,
-                               float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_dgeequ_work(int matrix_order, lapack_int m, lapack_int n, const double* a, lapack_int lda, double* r,
-                               double* c, double* rowcnd, double* colcnd, double* amax);
-lapack_int LAPACKE_cgeequ_work(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float* a,
-                               lapack_int lda, float* r, float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_zgeequ_work(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgeequb_work(int matrix_order, lapack_int m, lapack_int n, const float* a, lapack_int lda, float* r,
-                                float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_dgeequb_work(int matrix_order, lapack_int m, lapack_int n, const double* a, lapack_int lda,
-                                double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-lapack_int LAPACKE_cgeequb_work(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float* a,
-                                lapack_int lda, float* r, float* c, float* rowcnd, float* colcnd, float* amax);
-lapack_int LAPACKE_zgeequb_work(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                                lapack_int lda, double* r, double* c, double* rowcnd, double* colcnd, double* amax);
-
-lapack_int LAPACKE_sgees_work(int matrix_order, char jobvs, char sort, LAPACK_S_SELECT2 select, lapack_int n, float* a,
-                              lapack_int lda, lapack_int* sdim, float* wr, float* wi, float* vs, lapack_int ldvs,
-                              float* work, lapack_int lwork, lapack_logical* bwork);
-lapack_int LAPACKE_dgees_work(int matrix_order, char jobvs, char sort, LAPACK_D_SELECT2 select, lapack_int n, double* a,
-                              lapack_int lda, lapack_int* sdim, double* wr, double* wi, double* vs, lapack_int ldvs,
-                              double* work, lapack_int lwork, lapack_logical* bwork);
-lapack_int LAPACKE_cgees_work(int matrix_order, char jobvs, char sort, LAPACK_C_SELECT1 select, lapack_int n,
-                              lapack_complex_float* a, lapack_int lda, lapack_int* sdim, lapack_complex_float* w,
-                              lapack_complex_float* vs, lapack_int ldvs, lapack_complex_float* work, lapack_int lwork,
-                              float* rwork, lapack_logical* bwork);
-lapack_int LAPACKE_zgees_work(int matrix_order, char jobvs, char sort, LAPACK_Z_SELECT1 select, lapack_int n,
-                              lapack_complex_double* a, lapack_int lda, lapack_int* sdim, lapack_complex_double* w,
-                              lapack_complex_double* vs, lapack_int ldvs, lapack_complex_double* work, lapack_int lwork,
-                              double* rwork, lapack_logical* bwork);
-
-lapack_int LAPACKE_sgeesx_work(int matrix_order, char jobvs, char sort, LAPACK_S_SELECT2 select, char sense,
-                               lapack_int n, float* a, lapack_int lda, lapack_int* sdim, float* wr, float* wi,
-                               float* vs, lapack_int ldvs, float* rconde, float* rcondv, float* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork, lapack_logical* bwork);
-lapack_int LAPACKE_dgeesx_work(int matrix_order, char jobvs, char sort, LAPACK_D_SELECT2 select, char sense,
-                               lapack_int n, double* a, lapack_int lda, lapack_int* sdim, double* wr, double* wi,
-                               double* vs, lapack_int ldvs, double* rconde, double* rcondv, double* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork, lapack_logical* bwork);
-lapack_int LAPACKE_cgeesx_work(int matrix_order, char jobvs, char sort, LAPACK_C_SELECT1 select, char sense,
-                               lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_int* sdim,
-                               lapack_complex_float* w, lapack_complex_float* vs, lapack_int ldvs, float* rconde,
-                               float* rcondv, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_logical* bwork);
-lapack_int LAPACKE_zgeesx_work(int matrix_order, char jobvs, char sort, LAPACK_Z_SELECT1 select, char sense,
-                               lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_int* sdim,
-                               lapack_complex_double* w, lapack_complex_double* vs, lapack_int ldvs, double* rconde,
-                               double* rcondv, lapack_complex_double* work, lapack_int lwork, double* rwork,
-                               lapack_logical* bwork);
-
-lapack_int LAPACKE_sgeev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, float* a, lapack_int lda,
-                              float* wr, float* wi, float* vl, lapack_int ldvl, float* vr, lapack_int ldvr, float* work,
-                              lapack_int lwork);
-lapack_int LAPACKE_dgeev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, double* a, lapack_int lda,
-                              double* wr, double* wi, double* vl, lapack_int ldvl, double* vr, lapack_int ldvr,
-                              double* work, lapack_int lwork);
-lapack_int LAPACKE_cgeev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_float* a,
-                              lapack_int lda, lapack_complex_float* w, lapack_complex_float* vl, lapack_int ldvl,
-                              lapack_complex_float* vr, lapack_int ldvr, lapack_complex_float* work, lapack_int lwork,
-                              float* rwork);
-lapack_int LAPACKE_zgeev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_double* a,
-                              lapack_int lda, lapack_complex_double* w, lapack_complex_double* vl, lapack_int ldvl,
-                              lapack_complex_double* vr, lapack_int ldvr, lapack_complex_double* work, lapack_int lwork,
-                              double* rwork);
-
-lapack_int LAPACKE_sgeevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               float* a, lapack_int lda, float* wr, float* wi, float* vl, lapack_int ldvl, float* vr,
-                               lapack_int ldvr, lapack_int* ilo, lapack_int* ihi, float* scale, float* abnrm,
-                               float* rconde, float* rcondv, float* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dgeevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               double* a, lapack_int lda, double* wr, double* wi, double* vl, lapack_int ldvl,
-                               double* vr, lapack_int ldvr, lapack_int* ilo, lapack_int* ihi, double* scale,
-                               double* abnrm, double* rconde, double* rcondv, double* work, lapack_int lwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cgeevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* w,
-                               lapack_complex_float* vl, lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr,
-                               lapack_int* ilo, lapack_int* ihi, float* scale, float* abnrm, float* rconde,
-                               float* rcondv, lapack_complex_float* work, lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zgeevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* w,
-                               lapack_complex_double* vl, lapack_int ldvl, lapack_complex_double* vr, lapack_int ldvr,
-                               lapack_int* ilo, lapack_int* ihi, double* scale, double* abnrm, double* rconde,
-                               double* rcondv, lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_sgehrd_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, float* a, lapack_int lda,
-                               float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dgehrd_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, double* a,
-                               lapack_int lda, double* tau, double* work, lapack_int lwork);
-lapack_int LAPACKE_cgehrd_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgehrd_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_sgejsv_work(int matrix_order, char joba, char jobu, char jobv, char jobr, char jobt, char jobp,
-                               lapack_int m, lapack_int n, float* a, lapack_int lda, float* sva, float* u,
-                               lapack_int ldu, float* v, lapack_int ldv, float* work, lapack_int lwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dgejsv_work(int matrix_order, char joba, char jobu, char jobv, char jobr, char jobt, char jobp,
-                               lapack_int m, lapack_int n, double* a, lapack_int lda, double* sva, double* u,
-                               lapack_int ldu, double* v, lapack_int ldv, double* work, lapack_int lwork,
-                               lapack_int* iwork);
-
-lapack_int LAPACKE_sgelq2_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work);
-lapack_int LAPACKE_dgelq2_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work);
-lapack_int LAPACKE_cgelq2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work);
-lapack_int LAPACKE_zgelq2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work);
-
-lapack_int LAPACKE_sgelqf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dgelqf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgelqf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgelqf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgels_work(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs, float* a,
-                              lapack_int lda, float* b, lapack_int ldb, float* work, lapack_int lwork);
-lapack_int LAPACKE_dgels_work(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs, double* a,
-                              lapack_int lda, double* b, lapack_int ldb, double* work, lapack_int lwork);
-lapack_int LAPACKE_cgels_work(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs,
-                              lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                              lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgels_work(int matrix_order, char trans, lapack_int m, lapack_int n, lapack_int nrhs,
-                              lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                              lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgelsd_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                               float* b, lapack_int ldb, float* s, float rcond, lapack_int* rank, float* work,
-                               lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dgelsd_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                               double* b, lapack_int ldb, double* s, double rcond, lapack_int* rank, double* work,
-                               lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_cgelsd_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* b, lapack_int ldb, float* s, float rcond,
-                               lapack_int* rank, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_zgelsd_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb, double* s, double rcond,
-                               lapack_int* rank, lapack_complex_double* work, lapack_int lwork, double* rwork,
-                               lapack_int* iwork);
-
-lapack_int LAPACKE_sgelss_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                               float* b, lapack_int ldb, float* s, float rcond, lapack_int* rank, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dgelss_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                               double* b, lapack_int ldb, double* s, double rcond, lapack_int* rank, double* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_cgelss_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* b, lapack_int ldb, float* s, float rcond,
-                               lapack_int* rank, lapack_complex_float* work, lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zgelss_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb, double* s, double rcond,
-                               lapack_int* rank, lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_sgelsy_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                               float* b, lapack_int ldb, lapack_int* jpvt, float rcond, lapack_int* rank, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dgelsy_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                               double* b, lapack_int ldb, lapack_int* jpvt, double rcond, lapack_int* rank,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgelsy_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_int* jpvt, float rcond,
-                               lapack_int* rank, lapack_complex_float* work, lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zgelsy_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_int* jpvt, double rcond,
-                               lapack_int* rank, lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_sgeqlf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dgeqlf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgeqlf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgeqlf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgeqp3_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* jpvt,
-                               float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dgeqp3_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda,
-                               lapack_int* jpvt, double* tau, double* work, lapack_int lwork);
-lapack_int LAPACKE_cgeqp3_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* jpvt, lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zgeqp3_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* jpvt, lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_sgeqpf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, lapack_int* jpvt,
-                               float* tau, float* work);
-lapack_int LAPACKE_dgeqpf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda,
-                               lapack_int* jpvt, double* tau, double* work);
-lapack_int LAPACKE_cgeqpf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* jpvt, lapack_complex_float* tau, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgeqpf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* jpvt, lapack_complex_double* tau, lapack_complex_double* work,
-                               double* rwork);
-
-lapack_int LAPACKE_sgeqr2_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work);
-lapack_int LAPACKE_dgeqr2_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work);
-lapack_int LAPACKE_cgeqr2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work);
-lapack_int LAPACKE_zgeqr2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work);
-
-lapack_int LAPACKE_sgeqrf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dgeqrf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgeqrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgeqrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgeqrfp_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                                float* work, lapack_int lwork);
-lapack_int LAPACKE_dgeqrfp_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                                double* work, lapack_int lwork);
-lapack_int LAPACKE_cgeqrfp_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgeqrfp_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgerfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, const float* af, lapack_int ldaf, const lapack_int* ipiv, const float* b,
-                               lapack_int ldb, float* x, lapack_int ldx, float* ferr, float* berr, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dgerfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, const double* af, lapack_int ldaf, const lapack_int* ipiv,
-                               const double* b, lapack_int ldb, double* x, lapack_int ldx, double* ferr, double* berr,
-                               double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgerfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                               lapack_int ldaf, const lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgerfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                               lapack_int ldaf, const lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgerfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs, const float* a,
-                                lapack_int lda, const float* af, lapack_int ldaf, const lapack_int* ipiv,
-                                const float* r, const float* c, const float* b, lapack_int ldb, float* x,
-                                lapack_int ldx, float* rcond, float* berr, lapack_int n_err_bnds, float* err_bnds_norm,
-                                float* err_bnds_comp, lapack_int nparams, float* params, float* work,
-                                lapack_int* iwork);
-lapack_int LAPACKE_dgerfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs,
-                                const double* a, lapack_int lda, const double* af, lapack_int ldaf,
-                                const lapack_int* ipiv, const double* r, const double* c, const double* b,
-                                lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgerfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                                lapack_int ldaf, const lapack_int* ipiv, const float* r, const float* c,
-                                const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                                float* rcond, float* berr, lapack_int n_err_bnds, float* err_bnds_norm,
-                                float* err_bnds_comp, lapack_int nparams, float* params, lapack_complex_float* work,
-                                float* rwork);
-lapack_int LAPACKE_zgerfsx_work(int matrix_order, char trans, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                                lapack_int ldaf, const lapack_int* ipiv, const double* r, const double* c,
-                                const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                                lapack_int ldx, double* rcond, double* berr, lapack_int n_err_bnds,
-                                double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params,
-                                lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgerqf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dgerqf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgerqf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgerqf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgesdd_work(int matrix_order, char jobz, lapack_int m, lapack_int n, float* a, lapack_int lda,
-                               float* s, float* u, lapack_int ldu, float* vt, lapack_int ldvt, float* work,
-                               lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dgesdd_work(int matrix_order, char jobz, lapack_int m, lapack_int n, double* a, lapack_int lda,
-                               double* s, double* u, lapack_int ldu, double* vt, lapack_int ldvt, double* work,
-                               lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_cgesdd_work(int matrix_order, char jobz, lapack_int m, lapack_int n, lapack_complex_float* a,
-                               lapack_int lda, float* s, lapack_complex_float* u, lapack_int ldu,
-                               lapack_complex_float* vt, lapack_int ldvt, lapack_complex_float* work, lapack_int lwork,
-                               float* rwork, lapack_int* iwork);
-lapack_int LAPACKE_zgesdd_work(int matrix_order, char jobz, lapack_int m, lapack_int n, lapack_complex_double* a,
-                               lapack_int lda, double* s, lapack_complex_double* u, lapack_int ldu,
-                               lapack_complex_double* vt, lapack_int ldvt, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork, lapack_int* iwork);
-
-lapack_int LAPACKE_sgesv_work(int matrix_order, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                              lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgesv_work(int matrix_order, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                              lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgesv_work(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_float* a, lapack_int lda,
-                              lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgesv_work(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_double* a, lapack_int lda,
-                              lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-lapack_int LAPACKE_dsgesv_work(int matrix_order, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                               lapack_int* ipiv, double* b, lapack_int ldb, double* x, lapack_int ldx, double* work,
-                               float* swork, lapack_int* iter);
-lapack_int LAPACKE_zcgesv_work(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                               lapack_int lda, lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, lapack_complex_double* work,
-                               lapack_complex_float* swork, double* rwork, lapack_int* iter);
-
-lapack_int LAPACKE_sgesvd_work(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, float* a,
-                               lapack_int lda, float* s, float* u, lapack_int ldu, float* vt, lapack_int ldvt,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dgesvd_work(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n, double* a,
-                               lapack_int lda, double* s, double* u, lapack_int ldu, double* vt, lapack_int ldvt,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgesvd_work(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, float* s, lapack_complex_float* u,
-                               lapack_int ldu, lapack_complex_float* vt, lapack_int ldvt, lapack_complex_float* work,
-                               lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zgesvd_work(int matrix_order, char jobu, char jobvt, lapack_int m, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, double* s, lapack_complex_double* u,
-                               lapack_int ldu, lapack_complex_double* vt, lapack_int ldvt, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_sgesvj_work(int matrix_order, char joba, char jobu, char jobv, lapack_int m, lapack_int n, float* a,
-                               lapack_int lda, float* sva, lapack_int mv, float* v, lapack_int ldv, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dgesvj_work(int matrix_order, char joba, char jobu, char jobv, lapack_int m, lapack_int n, double* a,
-                               lapack_int lda, double* sva, lapack_int mv, double* v, lapack_int ldv, double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_sgesvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, float* a,
-                               lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, char* equed, float* r,
-                               float* c, float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* ferr,
-                               float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgesvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, double* a,
-                               lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, char* equed, double* r,
-                               double* c, double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond,
-                               double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgesvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                               lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b,
-                               lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* ferr,
-                               float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgesvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                               lapack_int* ipiv, char* equed, double* r, double* c, lapack_complex_double* b,
-                               lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* rcond, double* ferr,
-                               double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgesvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, float* a,
-                                lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, char* equed, float* r,
-                                float* c, float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                                float* rpvgrw, float* berr, lapack_int n_err_bnds, float* err_bnds_norm,
-                                float* err_bnds_comp, lapack_int nparams, float* params, float* work,
-                                lapack_int* iwork);
-lapack_int LAPACKE_dgesvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, double* a,
-                                lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, char* equed, double* r,
-                                double* c, double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond,
-                                double* rpvgrw, double* berr, lapack_int n_err_bnds, double* err_bnds_norm,
-                                double* err_bnds_comp, lapack_int nparams, double* params, double* work,
-                                lapack_int* iwork);
-lapack_int LAPACKE_cgesvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                                lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                                lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b,
-                                lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw,
-                                float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                                lapack_int nparams, float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgesvxx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                                lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                                lapack_int* ipiv, char* equed, double* r, double* c, lapack_complex_double* b,
-                                lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw,
-                                double* berr, lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                                lapack_int nparams, double* params, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgetf2_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda,
-                               lapack_int* ipiv);
-lapack_int LAPACKE_dgetf2_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda,
-                               lapack_int* ipiv);
-lapack_int LAPACKE_cgetf2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* ipiv);
-lapack_int LAPACKE_zgetf2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* ipiv);
-
-lapack_int LAPACKE_sgetrf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda,
-                               lapack_int* ipiv);
-lapack_int LAPACKE_dgetrf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda,
-                               lapack_int* ipiv);
-lapack_int LAPACKE_cgetrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* ipiv);
-lapack_int LAPACKE_zgetrf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* ipiv);
-
-lapack_int LAPACKE_sgetri_work(int matrix_order, lapack_int n, float* a, lapack_int lda, const lapack_int* ipiv,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dgetri_work(int matrix_order, lapack_int n, double* a, lapack_int lda, const lapack_int* ipiv,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_cgetri_work(int matrix_order, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               const lapack_int* ipiv, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zgetri_work(int matrix_order, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               const lapack_int* ipiv, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sgetrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dgetrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_cgetrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_int* ipiv,
-                               lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgetrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_int* ipiv,
-                               lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sggbak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const float* lscale, const float* rscale, lapack_int m, float* v, lapack_int ldv);
-lapack_int LAPACKE_dggbak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const double* lscale, const double* rscale, lapack_int m, double* v, lapack_int ldv);
-lapack_int LAPACKE_cggbak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const float* lscale, const float* rscale, lapack_int m, lapack_complex_float* v,
-                               lapack_int ldv);
-lapack_int LAPACKE_zggbak_work(int matrix_order, char job, char side, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               const double* lscale, const double* rscale, lapack_int m, lapack_complex_double* v,
-                               lapack_int ldv);
-
-lapack_int LAPACKE_sggbal_work(int matrix_order, char job, lapack_int n, float* a, lapack_int lda, float* b,
-                               lapack_int ldb, lapack_int* ilo, lapack_int* ihi, float* lscale, float* rscale,
-                               float* work);
-lapack_int LAPACKE_dggbal_work(int matrix_order, char job, lapack_int n, double* a, lapack_int lda, double* b,
-                               lapack_int ldb, lapack_int* ilo, lapack_int* ihi, double* lscale, double* rscale,
-                               double* work);
-lapack_int LAPACKE_cggbal_work(int matrix_order, char job, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* b, lapack_int ldb, lapack_int* ilo, lapack_int* ihi, float* lscale,
-                               float* rscale, float* work);
-lapack_int LAPACKE_zggbal_work(int matrix_order, char job, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* b, lapack_int ldb, lapack_int* ilo, lapack_int* ihi,
-                               double* lscale, double* rscale, double* work);
-
-lapack_int LAPACKE_sgges_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_S_SELECT3 selctg,
-                              lapack_int n, float* a, lapack_int lda, float* b, lapack_int ldb, lapack_int* sdim,
-                              float* alphar, float* alphai, float* beta, float* vsl, lapack_int ldvsl, float* vsr,
-                              lapack_int ldvsr, float* work, lapack_int lwork, lapack_logical* bwork);
-lapack_int LAPACKE_dgges_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_D_SELECT3 selctg,
-                              lapack_int n, double* a, lapack_int lda, double* b, lapack_int ldb, lapack_int* sdim,
-                              double* alphar, double* alphai, double* beta, double* vsl, lapack_int ldvsl, double* vsr,
-                              lapack_int ldvsr, double* work, lapack_int lwork, lapack_logical* bwork);
-lapack_int LAPACKE_cgges_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_C_SELECT2 selctg,
-                              lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_complex_float* b,
-                              lapack_int ldb, lapack_int* sdim, lapack_complex_float* alpha, lapack_complex_float* beta,
-                              lapack_complex_float* vsl, lapack_int ldvsl, lapack_complex_float* vsr, lapack_int ldvsr,
-                              lapack_complex_float* work, lapack_int lwork, float* rwork, lapack_logical* bwork);
-lapack_int LAPACKE_zgges_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_Z_SELECT2 selctg,
-                              lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_complex_double* b,
-                              lapack_int ldb, lapack_int* sdim, lapack_complex_double* alpha,
-                              lapack_complex_double* beta, lapack_complex_double* vsl, lapack_int ldvsl,
-                              lapack_complex_double* vsr, lapack_int ldvsr, lapack_complex_double* work,
-                              lapack_int lwork, double* rwork, lapack_logical* bwork);
-
-lapack_int LAPACKE_sggesx_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_S_SELECT3 selctg,
-                               char sense, lapack_int n, float* a, lapack_int lda, float* b, lapack_int ldb,
-                               lapack_int* sdim, float* alphar, float* alphai, float* beta, float* vsl,
-                               lapack_int ldvsl, float* vsr, lapack_int ldvsr, float* rconde, float* rcondv,
-                               float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork,
-                               lapack_logical* bwork);
-lapack_int LAPACKE_dggesx_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_D_SELECT3 selctg,
-                               char sense, lapack_int n, double* a, lapack_int lda, double* b, lapack_int ldb,
-                               lapack_int* sdim, double* alphar, double* alphai, double* beta, double* vsl,
-                               lapack_int ldvsl, double* vsr, lapack_int ldvsr, double* rconde, double* rcondv,
-                               double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork,
-                               lapack_logical* bwork);
-lapack_int LAPACKE_cggesx_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_C_SELECT2 selctg,
-                               char sense, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* b, lapack_int ldb, lapack_int* sdim, lapack_complex_float* alpha,
-                               lapack_complex_float* beta, lapack_complex_float* vsl, lapack_int ldvsl,
-                               lapack_complex_float* vsr, lapack_int ldvsr, float* rconde, float* rcondv,
-                               lapack_complex_float* work, lapack_int lwork, float* rwork, lapack_int* iwork,
-                               lapack_int liwork, lapack_logical* bwork);
-lapack_int LAPACKE_zggesx_work(int matrix_order, char jobvsl, char jobvsr, char sort, LAPACK_Z_SELECT2 selctg,
-                               char sense, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* b, lapack_int ldb, lapack_int* sdim, lapack_complex_double* alpha,
-                               lapack_complex_double* beta, lapack_complex_double* vsl, lapack_int ldvsl,
-                               lapack_complex_double* vsr, lapack_int ldvsr, double* rconde, double* rcondv,
-                               lapack_complex_double* work, lapack_int lwork, double* rwork, lapack_int* iwork,
-                               lapack_int liwork, lapack_logical* bwork);
-
-lapack_int LAPACKE_sggev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, float* a, lapack_int lda,
-                              float* b, lapack_int ldb, float* alphar, float* alphai, float* beta, float* vl,
-                              lapack_int ldvl, float* vr, lapack_int ldvr, float* work, lapack_int lwork);
-lapack_int LAPACKE_dggev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, double* a, lapack_int lda,
-                              double* b, lapack_int ldb, double* alphar, double* alphai, double* beta, double* vl,
-                              lapack_int ldvl, double* vr, lapack_int ldvr, double* work, lapack_int lwork);
-lapack_int LAPACKE_cggev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_float* a,
-                              lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* alpha,
-                              lapack_complex_float* beta, lapack_complex_float* vl, lapack_int ldvl,
-                              lapack_complex_float* vr, lapack_int ldvr, lapack_complex_float* work, lapack_int lwork,
-                              float* rwork);
-lapack_int LAPACKE_zggev_work(int matrix_order, char jobvl, char jobvr, lapack_int n, lapack_complex_double* a,
-                              lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* alpha,
-                              lapack_complex_double* beta, lapack_complex_double* vl, lapack_int ldvl,
-                              lapack_complex_double* vr, lapack_int ldvr, lapack_complex_double* work, lapack_int lwork,
-                              double* rwork);
-
-lapack_int LAPACKE_sggevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               float* a, lapack_int lda, float* b, lapack_int ldb, float* alphar, float* alphai,
-                               float* beta, float* vl, lapack_int ldvl, float* vr, lapack_int ldvr, lapack_int* ilo,
-                               lapack_int* ihi, float* lscale, float* rscale, float* abnrm, float* bbnrm, float* rconde,
-                               float* rcondv, float* work, lapack_int lwork, lapack_int* iwork, lapack_logical* bwork);
-lapack_int LAPACKE_dggevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               double* a, lapack_int lda, double* b, lapack_int ldb, double* alphar, double* alphai,
-                               double* beta, double* vl, lapack_int ldvl, double* vr, lapack_int ldvr, lapack_int* ilo,
-                               lapack_int* ihi, double* lscale, double* rscale, double* abnrm, double* bbnrm,
-                               double* rconde, double* rcondv, double* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_logical* bwork);
-lapack_int LAPACKE_cggevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* alpha, lapack_complex_float* beta, lapack_complex_float* vl,
-                               lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr, lapack_int* ilo,
-                               lapack_int* ihi, float* lscale, float* rscale, float* abnrm, float* bbnrm, float* rconde,
-                               float* rcondv, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int* iwork, lapack_logical* bwork);
-lapack_int LAPACKE_zggevx_work(int matrix_order, char balanc, char jobvl, char jobvr, char sense, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* alpha, lapack_complex_double* beta, lapack_complex_double* vl,
-                               lapack_int ldvl, lapack_complex_double* vr, lapack_int ldvr, lapack_int* ilo,
-                               lapack_int* ihi, double* lscale, double* rscale, double* abnrm, double* bbnrm,
-                               double* rconde, double* rcondv, lapack_complex_double* work, lapack_int lwork,
-                               double* rwork, lapack_int* iwork, lapack_logical* bwork);
-
-lapack_int LAPACKE_sggglm_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, float* a, lapack_int lda,
-                               float* b, lapack_int ldb, float* d, float* x, float* y, float* work, lapack_int lwork);
-lapack_int LAPACKE_dggglm_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, double* a, lapack_int lda,
-                               double* b, lapack_int ldb, double* d, double* x, double* y, double* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_cggglm_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* d,
-                               lapack_complex_float* x, lapack_complex_float* y, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zggglm_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* d,
-                               lapack_complex_double* x, lapack_complex_double* y, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_sgghrd_work(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               float* a, lapack_int lda, float* b, lapack_int ldb, float* q, lapack_int ldq, float* z,
-                               lapack_int ldz);
-lapack_int LAPACKE_dgghrd_work(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               double* a, lapack_int lda, double* b, lapack_int ldb, double* q, lapack_int ldq,
-                               double* z, lapack_int ldz);
-lapack_int LAPACKE_cgghrd_work(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z, lapack_int ldz);
-lapack_int LAPACKE_zgghrd_work(int matrix_order, char compq, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* q, lapack_int ldq, lapack_complex_double* z, lapack_int ldz);
-
-lapack_int LAPACKE_sgglse_work(int matrix_order, lapack_int m, lapack_int n, lapack_int p, float* a, lapack_int lda,
-                               float* b, lapack_int ldb, float* c, float* d, float* x, float* work, lapack_int lwork);
-lapack_int LAPACKE_dgglse_work(int matrix_order, lapack_int m, lapack_int n, lapack_int p, double* a, lapack_int lda,
-                               double* b, lapack_int ldb, double* c, double* d, double* x, double* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_cgglse_work(int matrix_order, lapack_int m, lapack_int n, lapack_int p, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* c,
-                               lapack_complex_float* d, lapack_complex_float* x, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zgglse_work(int matrix_order, lapack_int m, lapack_int n, lapack_int p, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* c,
-                               lapack_complex_double* d, lapack_complex_double* x, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_sggqrf_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, float* a, lapack_int lda,
-                               float* taua, float* b, lapack_int ldb, float* taub, float* work, lapack_int lwork);
-lapack_int LAPACKE_dggqrf_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, double* a, lapack_int lda,
-                               double* taua, double* b, lapack_int ldb, double* taub, double* work, lapack_int lwork);
-lapack_int LAPACKE_cggqrf_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* taua, lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* taub, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zggqrf_work(int matrix_order, lapack_int n, lapack_int m, lapack_int p, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* taua, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* taub, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sggrqf_work(int matrix_order, lapack_int m, lapack_int p, lapack_int n, float* a, lapack_int lda,
-                               float* taua, float* b, lapack_int ldb, float* taub, float* work, lapack_int lwork);
-lapack_int LAPACKE_dggrqf_work(int matrix_order, lapack_int m, lapack_int p, lapack_int n, double* a, lapack_int lda,
-                               double* taua, double* b, lapack_int ldb, double* taub, double* work, lapack_int lwork);
-lapack_int LAPACKE_cggrqf_work(int matrix_order, lapack_int m, lapack_int p, lapack_int n, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* taua, lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* taub, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zggrqf_work(int matrix_order, lapack_int m, lapack_int p, lapack_int n, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* taua, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* taub, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sggsvd_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n,
-                               lapack_int p, lapack_int* k, lapack_int* l, float* a, lapack_int lda, float* b,
-                               lapack_int ldb, float* alpha, float* beta, float* u, lapack_int ldu, float* v,
-                               lapack_int ldv, float* q, lapack_int ldq, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dggsvd_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n,
-                               lapack_int p, lapack_int* k, lapack_int* l, double* a, lapack_int lda, double* b,
-                               lapack_int ldb, double* alpha, double* beta, double* u, lapack_int ldu, double* v,
-                               lapack_int ldv, double* q, lapack_int ldq, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cggsvd_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n,
-                               lapack_int p, lapack_int* k, lapack_int* l, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* b, lapack_int ldb, float* alpha, float* beta,
-                               lapack_complex_float* u, lapack_int ldu, lapack_complex_float* v, lapack_int ldv,
-                               lapack_complex_float* q, lapack_int ldq, lapack_complex_float* work, float* rwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_zggsvd_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int n,
-                               lapack_int p, lapack_int* k, lapack_int* l, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* b, lapack_int ldb, double* alpha, double* beta,
-                               lapack_complex_double* u, lapack_int ldu, lapack_complex_double* v, lapack_int ldv,
-                               lapack_complex_double* q, lapack_int ldq, lapack_complex_double* work, double* rwork,
-                               lapack_int* iwork);
-
-lapack_int LAPACKE_sggsvp_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, float* a, lapack_int lda, float* b, lapack_int ldb, float tola, float tolb,
-                               lapack_int* k, lapack_int* l, float* u, lapack_int ldu, float* v, lapack_int ldv,
-                               float* q, lapack_int ldq, lapack_int* iwork, float* tau, float* work);
-lapack_int LAPACKE_dggsvp_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, double* a, lapack_int lda, double* b, lapack_int ldb, double tola,
-                               double tolb, lapack_int* k, lapack_int* l, double* u, lapack_int ldu, double* v,
-                               lapack_int ldv, double* q, lapack_int ldq, lapack_int* iwork, double* tau, double* work);
-lapack_int LAPACKE_cggsvp_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_complex_float* b,
-                               lapack_int ldb, float tola, float tolb, lapack_int* k, lapack_int* l,
-                               lapack_complex_float* u, lapack_int ldu, lapack_complex_float* v, lapack_int ldv,
-                               lapack_complex_float* q, lapack_int ldq, lapack_int* iwork, float* rwork,
-                               lapack_complex_float* tau, lapack_complex_float* work);
-lapack_int LAPACKE_zggsvp_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_complex_double* b,
-                               lapack_int ldb, double tola, double tolb, lapack_int* k, lapack_int* l,
-                               lapack_complex_double* u, lapack_int ldu, lapack_complex_double* v, lapack_int ldv,
-                               lapack_complex_double* q, lapack_int ldq, lapack_int* iwork, double* rwork,
-                               lapack_complex_double* tau, lapack_complex_double* work);
-
-lapack_int LAPACKE_sgtcon_work(char norm, lapack_int n, const float* dl, const float* d, const float* du,
-                               const float* du2, const lapack_int* ipiv, float anorm, float* rcond, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dgtcon_work(char norm, lapack_int n, const double* dl, const double* d, const double* du,
-                               const double* du2, const lapack_int* ipiv, double anorm, double* rcond, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cgtcon_work(char norm, lapack_int n, const lapack_complex_float* dl, const lapack_complex_float* d,
-                               const lapack_complex_float* du, const lapack_complex_float* du2, const lapack_int* ipiv,
-                               float anorm, float* rcond, lapack_complex_float* work);
-lapack_int LAPACKE_zgtcon_work(char norm, lapack_int n, const lapack_complex_double* dl, const lapack_complex_double* d,
-                               const lapack_complex_double* du, const lapack_complex_double* du2,
-                               const lapack_int* ipiv, double anorm, double* rcond, lapack_complex_double* work);
-
-lapack_int LAPACKE_sgtrfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* dl,
-                               const float* d, const float* du, const float* dlf, const float* df, const float* duf,
-                               const float* du2, const lapack_int* ipiv, const float* b, lapack_int ldb, float* x,
-                               lapack_int ldx, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgtrfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* dl,
-                               const double* d, const double* du, const double* dlf, const double* df,
-                               const double* duf, const double* du2, const lapack_int* ipiv, const double* b,
-                               lapack_int ldb, double* x, lapack_int ldx, double* ferr, double* berr, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cgtrfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* dl, const lapack_complex_float* d,
-                               const lapack_complex_float* du, const lapack_complex_float* dlf,
-                               const lapack_complex_float* df, const lapack_complex_float* duf,
-                               const lapack_complex_float* du2, const lapack_int* ipiv, const lapack_complex_float* b,
-                               lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgtrfs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* dl, const lapack_complex_double* d,
-                               const lapack_complex_double* du, const lapack_complex_double* dlf,
-                               const lapack_complex_double* df, const lapack_complex_double* duf,
-                               const lapack_complex_double* du2, const lapack_int* ipiv, const lapack_complex_double* b,
-                               lapack_int ldb, lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgtsv_work(int matrix_order, lapack_int n, lapack_int nrhs, float* dl, float* d, float* du, float* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_dgtsv_work(int matrix_order, lapack_int n, lapack_int nrhs, double* dl, double* d, double* du,
-                              double* b, lapack_int ldb);
-lapack_int LAPACKE_cgtsv_work(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_float* dl,
-                              lapack_complex_float* d, lapack_complex_float* du, lapack_complex_float* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_zgtsv_work(int matrix_order, lapack_int n, lapack_int nrhs, lapack_complex_double* dl,
-                              lapack_complex_double* d, lapack_complex_double* du, lapack_complex_double* b,
-                              lapack_int ldb);
-
-lapack_int LAPACKE_sgtsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, const float* dl,
-                               const float* d, const float* du, float* dlf, float* df, float* duf, float* du2,
-                               lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                               float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dgtsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs, const double* dl,
-                               const double* d, const double* du, double* dlf, double* df, double* duf, double* du2,
-                               lapack_int* ipiv, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cgtsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* dl, const lapack_complex_float* d,
-                               const lapack_complex_float* du, lapack_complex_float* dlf, lapack_complex_float* df,
-                               lapack_complex_float* duf, lapack_complex_float* du2, lapack_int* ipiv,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zgtsvx_work(int matrix_order, char fact, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* dl, const lapack_complex_double* d,
-                               const lapack_complex_double* du, lapack_complex_double* dlf, lapack_complex_double* df,
-                               lapack_complex_double* duf, lapack_complex_double* du2, lapack_int* ipiv,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sgttrf_work(lapack_int n, float* dl, float* d, float* du, float* du2, lapack_int* ipiv);
-lapack_int LAPACKE_dgttrf_work(lapack_int n, double* dl, double* d, double* du, double* du2, lapack_int* ipiv);
-lapack_int LAPACKE_cgttrf_work(lapack_int n, lapack_complex_float* dl, lapack_complex_float* d,
-                               lapack_complex_float* du, lapack_complex_float* du2, lapack_int* ipiv);
-lapack_int LAPACKE_zgttrf_work(lapack_int n, lapack_complex_double* dl, lapack_complex_double* d,
-                               lapack_complex_double* du, lapack_complex_double* du2, lapack_int* ipiv);
-
-lapack_int LAPACKE_sgttrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const float* dl,
-                               const float* d, const float* du, const float* du2, const lapack_int* ipiv, float* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_dgttrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs, const double* dl,
-                               const double* d, const double* du, const double* du2, const lapack_int* ipiv, double* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_cgttrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* dl, const lapack_complex_float* d,
-                               const lapack_complex_float* du, const lapack_complex_float* du2, const lapack_int* ipiv,
-                               lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zgttrs_work(int matrix_order, char trans, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* dl, const lapack_complex_double* d,
-                               const lapack_complex_double* du, const lapack_complex_double* du2,
-                               const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chbev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd,
-                              lapack_complex_float* ab, lapack_int ldab, float* w, lapack_complex_float* z,
-                              lapack_int ldz, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zhbev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd,
-                              lapack_complex_double* ab, lapack_int ldab, double* w, lapack_complex_double* z,
-                              lapack_int ldz, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_chbevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd,
-                               lapack_complex_float* ab, lapack_int ldab, float* w, lapack_complex_float* z,
-                               lapack_int ldz, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zhbevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd,
-                               lapack_complex_double* ab, lapack_int ldab, double* w, lapack_complex_double* z,
-                               lapack_int ldz, lapack_complex_double* work, lapack_int lwork, double* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_chbevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd,
-                               lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* q, lapack_int ldq,
-                               float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                               lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work, float* rwork,
-                               lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_zhbevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd,
-                               lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* q, lapack_int ldq,
-                               double vl, double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m,
-                               double* w, lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work,
-                               double* rwork, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_chbgst_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               lapack_complex_float* ab, lapack_int ldab, const lapack_complex_float* bb,
-                               lapack_int ldbb, lapack_complex_float* x, lapack_int ldx, lapack_complex_float* work,
-                               float* rwork);
-lapack_int LAPACKE_zhbgst_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               lapack_complex_double* ab, lapack_int ldab, const lapack_complex_double* bb,
-                               lapack_int ldbb, lapack_complex_double* x, lapack_int ldx, lapack_complex_double* work,
-                               double* rwork);
-
-lapack_int LAPACKE_chbgv_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                              lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* bb, lapack_int ldbb,
-                              float* w, lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work,
-                              float* rwork);
-lapack_int LAPACKE_zhbgv_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                              lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* bb, lapack_int ldbb,
-                              double* w, lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work,
-                              double* rwork);
-
-lapack_int LAPACKE_chbgvd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* bb, lapack_int ldbb,
-                               float* w, lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work,
-                               lapack_int lwork, float* rwork, lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zhbgvd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* bb, lapack_int ldbb,
-                               double* w, lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork, lapack_int lrwork, lapack_int* iwork,
-                               lapack_int liwork);
-
-lapack_int LAPACKE_chbgvx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                               lapack_int kb, lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* bb,
-                               lapack_int ldbb, lapack_complex_float* q, lapack_int ldq, float vl, float vu,
-                               lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                               lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work, float* rwork,
-                               lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_zhbgvx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                               lapack_int kb, lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* bb,
-                               lapack_int ldbb, lapack_complex_double* q, lapack_int ldq, double vl, double vu,
-                               lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work, double* rwork,
-                               lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_chbtrd_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd,
-                               lapack_complex_float* ab, lapack_int ldab, float* d, float* e, lapack_complex_float* q,
-                               lapack_int ldq, lapack_complex_float* work);
-lapack_int LAPACKE_zhbtrd_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd,
-                               lapack_complex_double* ab, lapack_int ldab, double* d, double* e,
-                               lapack_complex_double* q, lapack_int ldq, lapack_complex_double* work);
-
-lapack_int LAPACKE_checon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                               const lapack_int* ipiv, float anorm, float* rcond, lapack_complex_float* work);
-lapack_int LAPACKE_zhecon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, const lapack_int* ipiv, double anorm, double* rcond,
-                               lapack_complex_double* work);
-
-lapack_int LAPACKE_cheequb_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a,
-                                lapack_int lda, float* s, float* scond, float* amax, lapack_complex_float* work);
-lapack_int LAPACKE_zheequb_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a,
-                                lapack_int lda, double* s, double* scond, double* amax, lapack_complex_double* work);
-
-lapack_int LAPACKE_cheev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* a,
-                              lapack_int lda, float* w, lapack_complex_float* work, lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zheev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* a,
-                              lapack_int lda, double* w, lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_cheevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* a,
-                               lapack_int lda, float* w, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zheevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* a,
-                               lapack_int lda, double* w, lapack_complex_double* work, lapack_int lwork, double* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_cheevr_work(int matrix_order, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, float vl, float vu, lapack_int il,
-                               lapack_int iu, float abstol, lapack_int* m, float* w, lapack_complex_float* z,
-                               lapack_int ldz, lapack_int* isuppz, lapack_complex_float* work, lapack_int lwork,
-                               float* rwork, lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zheevr_work(int matrix_order, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, double vl, double vu, lapack_int il,
-                               lapack_int iu, double abstol, lapack_int* m, double* w, lapack_complex_double* z,
-                               lapack_int ldz, lapack_int* isuppz, lapack_complex_double* work, lapack_int lwork,
-                               double* rwork, lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_cheevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, float vl, float vu, lapack_int il,
-                               lapack_int iu, float abstol, lapack_int* m, float* w, lapack_complex_float* z,
-                               lapack_int ldz, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_zheevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, double vl, double vu, lapack_int il,
-                               lapack_int iu, double abstol, lapack_int* m, double* w, lapack_complex_double* z,
-                               lapack_int ldz, lapack_complex_double* work, lapack_int lwork, double* rwork,
-                               lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_chegst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_float* a,
-                               lapack_int lda, const lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhegst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_double* a,
-                               lapack_int lda, const lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chegv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                              lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                              float* w, lapack_complex_float* work, lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zhegv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                              lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                              double* w, lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_chegvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                               float* w, lapack_complex_float* work, lapack_int lwork, float* rwork, lapack_int lrwork,
-                               lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zhegvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                               double* w, lapack_complex_double* work, lapack_int lwork, double* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_chegvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                               float vl, float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                               lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work, lapack_int lwork,
-                               float* rwork, lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_zhegvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                               double vl, double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m,
-                               double* w, lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_cherfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                               lapack_int ldaf, const lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zherfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                               lapack_int ldaf, const lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_cherfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                                lapack_int ldaf, const lapack_int* ipiv, const float* s, const lapack_complex_float* b,
-                                lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zherfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                                lapack_int ldaf, const lapack_int* ipiv, const double* s,
-                                const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                                lapack_int ldx, double* rcond, double* berr, lapack_int n_err_bnds,
-                                double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params,
-                                lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_chesv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                              lapack_int lda, lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb,
-                              lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zhesv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                              lapack_int lda, lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb,
-                              lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_chesvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                               lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                               lapack_int ldx, float* rcond, float* ferr, float* berr, lapack_complex_float* work,
-                               lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zhesvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, lapack_complex_double* af,
-                               lapack_int ldaf, lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                               lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_chesvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                                lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                                lapack_int* ipiv, char* equed, float* s, lapack_complex_float* b, lapack_int ldb,
-                                lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zhesvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                                lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                                lapack_int* ipiv, char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                                lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_chetrd_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               float* d, float* e, lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zhetrd_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               double* d, double* e, lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_chetrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* ipiv, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zhetrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* ipiv, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_chetri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               const lapack_int* ipiv, lapack_complex_float* work);
-lapack_int LAPACKE_zhetri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               const lapack_int* ipiv, lapack_complex_double* work);
-
-lapack_int LAPACKE_chetrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_int* ipiv,
-                               lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhetrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_int* ipiv,
-                               lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chfrk_work(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k,
-                              float alpha, const lapack_complex_float* a, lapack_int lda, float beta,
-                              lapack_complex_float* c);
-lapack_int LAPACKE_zhfrk_work(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k,
-                              double alpha, const lapack_complex_double* a, lapack_int lda, double beta,
-                              lapack_complex_double* c);
-
-lapack_int LAPACKE_shgeqz_work(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, float* h, lapack_int ldh, float* t, lapack_int ldt, float* alphar,
-                               float* alphai, float* beta, float* q, lapack_int ldq, float* z, lapack_int ldz,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dhgeqz_work(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, double* h, lapack_int ldh, double* t, lapack_int ldt, double* alphar,
-                               double* alphai, double* beta, double* q, lapack_int ldq, double* z, lapack_int ldz,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_chgeqz_work(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, lapack_complex_float* h, lapack_int ldh, lapack_complex_float* t,
-                               lapack_int ldt, lapack_complex_float* alpha, lapack_complex_float* beta,
-                               lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z, lapack_int ldz,
-                               lapack_complex_float* work, lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zhgeqz_work(int matrix_order, char job, char compq, char compz, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, lapack_complex_double* h, lapack_int ldh, lapack_complex_double* t,
-                               lapack_int ldt, lapack_complex_double* alpha, lapack_complex_double* beta,
-                               lapack_complex_double* q, lapack_int ldq, lapack_complex_double* z, lapack_int ldz,
-                               lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_chpcon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                               const lapack_int* ipiv, float anorm, float* rcond, lapack_complex_float* work);
-lapack_int LAPACKE_zhpcon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                               const lapack_int* ipiv, double anorm, double* rcond, lapack_complex_double* work);
-
-lapack_int LAPACKE_chpev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* ap, float* w,
-                              lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zhpev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* ap,
-                              double* w, lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work,
-                              double* rwork);
-
-lapack_int LAPACKE_chpevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_float* ap, float* w,
-                               lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work, lapack_int lwork,
-                               float* rwork, lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zhpevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_complex_double* ap,
-                               double* w, lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork, lapack_int lrwork, lapack_int* iwork,
-                               lapack_int liwork);
-
-lapack_int LAPACKE_chpevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_float* ap, float vl, float vu, lapack_int il, lapack_int iu, float abstol,
-                               lapack_int* m, float* w, lapack_complex_float* z, lapack_int ldz,
-                               lapack_complex_float* work, float* rwork, lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_zhpevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_double* ap, double vl, double vu, lapack_int il, lapack_int iu,
-                               double abstol, lapack_int* m, double* w, lapack_complex_double* z, lapack_int ldz,
-                               lapack_complex_double* work, double* rwork, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_chpgst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_float* ap,
-                               const lapack_complex_float* bp);
-lapack_int LAPACKE_zhpgst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, lapack_complex_double* ap,
-                               const lapack_complex_double* bp);
-
-lapack_int LAPACKE_chpgv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                              lapack_complex_float* ap, lapack_complex_float* bp, float* w, lapack_complex_float* z,
-                              lapack_int ldz, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zhpgv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                              lapack_complex_double* ap, lapack_complex_double* bp, double* w, lapack_complex_double* z,
-                              lapack_int ldz, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_chpgvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                               lapack_complex_float* ap, lapack_complex_float* bp, float* w, lapack_complex_float* z,
-                               lapack_int ldz, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zhpgvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n,
-                               lapack_complex_double* ap, lapack_complex_double* bp, double* w,
-                               lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work, lapack_int lwork,
-                               double* rwork, lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_chpgvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_float* ap, lapack_complex_float* bp, float vl, float vu, lapack_int il,
-                               lapack_int iu, float abstol, lapack_int* m, float* w, lapack_complex_float* z,
-                               lapack_int ldz, lapack_complex_float* work, float* rwork, lapack_int* iwork,
-                               lapack_int* ifail);
-lapack_int LAPACKE_zhpgvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               lapack_complex_double* ap, lapack_complex_double* bp, double vl, double vu,
-                               lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work, double* rwork,
-                               lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_chprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, const lapack_complex_float* afp, const lapack_int* ipiv,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zhprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, const lapack_complex_double* afp,
-                               const lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_chpsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* ap,
-                              lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zhpsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* ap,
-                              lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_chpsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, lapack_complex_float* afp, lapack_int* ipiv,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zhpsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, lapack_complex_double* afp, lapack_int* ipiv,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_chptrd_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, float* d, float* e,
-                               lapack_complex_float* tau);
-lapack_int LAPACKE_zhptrd_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, double* d,
-                               double* e, lapack_complex_double* tau);
-
-lapack_int LAPACKE_chptrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, lapack_int* ipiv);
-lapack_int LAPACKE_zhptrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, lapack_int* ipiv);
-
-lapack_int LAPACKE_chptri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap,
-                               const lapack_int* ipiv, lapack_complex_float* work);
-lapack_int LAPACKE_zhptri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap,
-                               const lapack_int* ipiv, lapack_complex_double* work);
-
-lapack_int LAPACKE_chptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, const lapack_int* ipiv, lapack_complex_float* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_zhptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, const lapack_int* ipiv, lapack_complex_double* b,
-                               lapack_int ldb);
-
-lapack_int LAPACKE_shsein_work(int matrix_order, char job, char eigsrc, char initv, lapack_logical* select,
-                               lapack_int n, const float* h, lapack_int ldh, float* wr, const float* wi, float* vl,
-                               lapack_int ldvl, float* vr, lapack_int ldvr, lapack_int mm, lapack_int* m, float* work,
-                               lapack_int* ifaill, lapack_int* ifailr);
-lapack_int LAPACKE_dhsein_work(int matrix_order, char job, char eigsrc, char initv, lapack_logical* select,
-                               lapack_int n, const double* h, lapack_int ldh, double* wr, const double* wi, double* vl,
-                               lapack_int ldvl, double* vr, lapack_int ldvr, lapack_int mm, lapack_int* m, double* work,
-                               lapack_int* ifaill, lapack_int* ifailr);
-lapack_int LAPACKE_chsein_work(int matrix_order, char job, char eigsrc, char initv, const lapack_logical* select,
-                               lapack_int n, const lapack_complex_float* h, lapack_int ldh, lapack_complex_float* w,
-                               lapack_complex_float* vl, lapack_int ldvl, lapack_complex_float* vr, lapack_int ldvr,
-                               lapack_int mm, lapack_int* m, lapack_complex_float* work, float* rwork,
-                               lapack_int* ifaill, lapack_int* ifailr);
-lapack_int LAPACKE_zhsein_work(int matrix_order, char job, char eigsrc, char initv, const lapack_logical* select,
-                               lapack_int n, const lapack_complex_double* h, lapack_int ldh, lapack_complex_double* w,
-                               lapack_complex_double* vl, lapack_int ldvl, lapack_complex_double* vr, lapack_int ldvr,
-                               lapack_int mm, lapack_int* m, lapack_complex_double* work, double* rwork,
-                               lapack_int* ifaill, lapack_int* ifailr);
-
-lapack_int LAPACKE_shseqr_work(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               float* h, lapack_int ldh, float* wr, float* wi, float* z, lapack_int ldz, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dhseqr_work(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               double* h, lapack_int ldh, double* wr, double* wi, double* z, lapack_int ldz,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_chseqr_work(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               lapack_complex_float* h, lapack_int ldh, lapack_complex_float* w,
-                               lapack_complex_float* z, lapack_int ldz, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zhseqr_work(int matrix_order, char job, char compz, lapack_int n, lapack_int ilo, lapack_int ihi,
-                               lapack_complex_double* h, lapack_int ldh, lapack_complex_double* w,
-                               lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_clacgv_work(lapack_int n, lapack_complex_float* x, lapack_int incx);
-lapack_int LAPACKE_zlacgv_work(lapack_int n, lapack_complex_double* x, lapack_int incx);
-
-lapack_int LAPACKE_slacpy_work(int matrix_order, char uplo, lapack_int m, lapack_int n, const float* a, lapack_int lda,
-                               float* b, lapack_int ldb);
-lapack_int LAPACKE_dlacpy_work(int matrix_order, char uplo, lapack_int m, lapack_int n, const double* a, lapack_int lda,
-                               double* b, lapack_int ldb);
-lapack_int LAPACKE_clacpy_work(int matrix_order, char uplo, lapack_int m, lapack_int n, const lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zlacpy_work(int matrix_order, char uplo, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_zlag2c_work(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_float* sa, lapack_int ldsa);
-
-lapack_int LAPACKE_slag2d_work(int matrix_order, lapack_int m, lapack_int n, const float* sa, lapack_int ldsa,
-                               double* a, lapack_int lda);
-
-lapack_int LAPACKE_dlag2s_work(int matrix_order, lapack_int m, lapack_int n, const double* a, lapack_int lda, float* sa,
-                               lapack_int ldsa);
-
-lapack_int LAPACKE_clag2z_work(int matrix_order, lapack_int m, lapack_int n, const lapack_complex_float* sa,
-                               lapack_int ldsa, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_slagge_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const float* d, float* a, lapack_int lda, lapack_int* iseed, float* work);
-lapack_int LAPACKE_dlagge_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const double* d, double* a, lapack_int lda, lapack_int* iseed, double* work);
-lapack_int LAPACKE_clagge_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const float* d, lapack_complex_float* a, lapack_int lda, lapack_int* iseed,
-                               lapack_complex_float* work);
-lapack_int LAPACKE_zlagge_work(int matrix_order, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku,
-                               const double* d, lapack_complex_double* a, lapack_int lda, lapack_int* iseed,
-                               lapack_complex_double* work);
-
-lapack_int LAPACKE_claghe_work(int matrix_order, lapack_int n, lapack_int k, const float* d, lapack_complex_float* a,
-                               lapack_int lda, lapack_int* iseed, lapack_complex_float* work);
-lapack_int LAPACKE_zlaghe_work(int matrix_order, lapack_int n, lapack_int k, const double* d, lapack_complex_double* a,
-                               lapack_int lda, lapack_int* iseed, lapack_complex_double* work);
-
-lapack_int LAPACKE_slagsy_work(int matrix_order, lapack_int n, lapack_int k, const float* d, float* a, lapack_int lda,
-                               lapack_int* iseed, float* work);
-lapack_int LAPACKE_dlagsy_work(int matrix_order, lapack_int n, lapack_int k, const double* d, double* a, lapack_int lda,
-                               lapack_int* iseed, double* work);
-lapack_int LAPACKE_clagsy_work(int matrix_order, lapack_int n, lapack_int k, const float* d, lapack_complex_float* a,
-                               lapack_int lda, lapack_int* iseed, lapack_complex_float* work);
-lapack_int LAPACKE_zlagsy_work(int matrix_order, lapack_int n, lapack_int k, const double* d, lapack_complex_double* a,
-                               lapack_int lda, lapack_int* iseed, lapack_complex_double* work);
-
-lapack_int LAPACKE_slapmr_work(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n, float* x,
-                               lapack_int ldx, lapack_int* k);
-lapack_int LAPACKE_dlapmr_work(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n, double* x,
-                               lapack_int ldx, lapack_int* k);
-lapack_int LAPACKE_clapmr_work(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n,
-                               lapack_complex_float* x, lapack_int ldx, lapack_int* k);
-lapack_int LAPACKE_zlapmr_work(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n,
-                               lapack_complex_double* x, lapack_int ldx, lapack_int* k);
-
-lapack_int LAPACKE_slartgp_work(float f, float g, float* cs, float* sn, float* r);
-lapack_int LAPACKE_dlartgp_work(double f, double g, double* cs, double* sn, double* r);
-
-lapack_int LAPACKE_slartgs_work(float x, float y, float sigma, float* cs, float* sn);
-lapack_int LAPACKE_dlartgs_work(double x, double y, double sigma, double* cs, double* sn);
-
-float LAPACKE_slapy2_work(float x, float y);
-double LAPACKE_dlapy2_work(double x, double y);
-
-float LAPACKE_slapy3_work(float x, float y, float z);
-double LAPACKE_dlapy3_work(double x, double y, double z);
-
-float LAPACKE_slamch_work(char cmach);
-double LAPACKE_dlamch_work(char cmach);
-
-float LAPACKE_slange_work(int matrix_order, char norm, lapack_int m, lapack_int n, const float* a, lapack_int lda,
-                          float* work);
-double LAPACKE_dlange_work(int matrix_order, char norm, lapack_int m, lapack_int n, const double* a, lapack_int lda,
-                           double* work);
-float LAPACKE_clange_work(int matrix_order, char norm, lapack_int m, lapack_int n, const lapack_complex_float* a,
-                          lapack_int lda, float* work);
-double LAPACKE_zlange_work(int matrix_order, char norm, lapack_int m, lapack_int n, const lapack_complex_double* a,
-                           lapack_int lda, double* work);
-
-float LAPACKE_clanhe_work(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_float* a,
-                          lapack_int lda, float* work);
-double LAPACKE_zlanhe_work(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_double* a,
-                           lapack_int lda, double* work);
-
-float LAPACKE_slansy_work(int matrix_order, char norm, char uplo, lapack_int n, const float* a, lapack_int lda,
-                          float* work);
-double LAPACKE_dlansy_work(int matrix_order, char norm, char uplo, lapack_int n, const double* a, lapack_int lda,
-                           double* work);
-float LAPACKE_clansy_work(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_float* a,
-                          lapack_int lda, float* work);
-double LAPACKE_zlansy_work(int matrix_order, char norm, char uplo, lapack_int n, const lapack_complex_double* a,
-                           lapack_int lda, double* work);
-
-float LAPACKE_slantr_work(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n, const float* a,
-                          lapack_int lda, float* work);
-double LAPACKE_dlantr_work(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n,
-                           const double* a, lapack_int lda, double* work);
-float LAPACKE_clantr_work(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n,
-                          const lapack_complex_float* a, lapack_int lda, float* work);
-double LAPACKE_zlantr_work(int matrix_order, char norm, char uplo, char diag, lapack_int m, lapack_int n,
-                           const lapack_complex_double* a, lapack_int lda, double* work);
-
-lapack_int LAPACKE_slarfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, const float* v, lapack_int ldv, const float* t,
-                               lapack_int ldt, float* c, lapack_int ldc, float* work, lapack_int ldwork);
-lapack_int LAPACKE_dlarfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, const double* v, lapack_int ldv, const double* t,
-                               lapack_int ldt, double* c, lapack_int ldc, double* work, lapack_int ldwork);
-lapack_int LAPACKE_clarfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, const lapack_complex_float* v, lapack_int ldv,
-                               const lapack_complex_float* t, lapack_int ldt, lapack_complex_float* c, lapack_int ldc,
-                               lapack_complex_float* work, lapack_int ldwork);
-lapack_int LAPACKE_zlarfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, const lapack_complex_double* v, lapack_int ldv,
-                               const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* c, lapack_int ldc,
-                               lapack_complex_double* work, lapack_int ldwork);
-
-lapack_int LAPACKE_slarfg_work(lapack_int n, float* alpha, float* x, lapack_int incx, float* tau);
-lapack_int LAPACKE_dlarfg_work(lapack_int n, double* alpha, double* x, lapack_int incx, double* tau);
-lapack_int LAPACKE_clarfg_work(lapack_int n, lapack_complex_float* alpha, lapack_complex_float* x, lapack_int incx,
-                               lapack_complex_float* tau);
-lapack_int LAPACKE_zlarfg_work(lapack_int n, lapack_complex_double* alpha, lapack_complex_double* x, lapack_int incx,
-                               lapack_complex_double* tau);
-
-lapack_int LAPACKE_slarft_work(int matrix_order, char direct, char storev, lapack_int n, lapack_int k, const float* v,
-                               lapack_int ldv, const float* tau, float* t, lapack_int ldt);
-lapack_int LAPACKE_dlarft_work(int matrix_order, char direct, char storev, lapack_int n, lapack_int k, const double* v,
-                               lapack_int ldv, const double* tau, double* t, lapack_int ldt);
-lapack_int LAPACKE_clarft_work(int matrix_order, char direct, char storev, lapack_int n, lapack_int k,
-                               const lapack_complex_float* v, lapack_int ldv, const lapack_complex_float* tau,
-                               lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zlarft_work(int matrix_order, char direct, char storev, lapack_int n, lapack_int k,
-                               const lapack_complex_double* v, lapack_int ldv, const lapack_complex_double* tau,
-                               lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_slarfx_work(int matrix_order, char side, lapack_int m, lapack_int n, const float* v, float tau,
-                               float* c, lapack_int ldc, float* work);
-lapack_int LAPACKE_dlarfx_work(int matrix_order, char side, lapack_int m, lapack_int n, const double* v, double tau,
-                               double* c, lapack_int ldc, double* work);
-lapack_int LAPACKE_clarfx_work(int matrix_order, char side, lapack_int m, lapack_int n, const lapack_complex_float* v,
-                               lapack_complex_float tau, lapack_complex_float* c, lapack_int ldc,
-                               lapack_complex_float* work);
-lapack_int LAPACKE_zlarfx_work(int matrix_order, char side, lapack_int m, lapack_int n, const lapack_complex_double* v,
-                               lapack_complex_double tau, lapack_complex_double* c, lapack_int ldc,
-                               lapack_complex_double* work);
-
-lapack_int LAPACKE_slarnv_work(lapack_int idist, lapack_int* iseed, lapack_int n, float* x);
-lapack_int LAPACKE_dlarnv_work(lapack_int idist, lapack_int* iseed, lapack_int n, double* x);
-lapack_int LAPACKE_clarnv_work(lapack_int idist, lapack_int* iseed, lapack_int n, lapack_complex_float* x);
-lapack_int LAPACKE_zlarnv_work(lapack_int idist, lapack_int* iseed, lapack_int n, lapack_complex_double* x);
-
-lapack_int LAPACKE_slaset_work(int matrix_order, char uplo, lapack_int m, lapack_int n, float alpha, float beta,
-                               float* a, lapack_int lda);
-lapack_int LAPACKE_dlaset_work(int matrix_order, char uplo, lapack_int m, lapack_int n, double alpha, double beta,
-                               double* a, lapack_int lda);
-lapack_int LAPACKE_claset_work(int matrix_order, char uplo, lapack_int m, lapack_int n, lapack_complex_float alpha,
-                               lapack_complex_float beta, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zlaset_work(int matrix_order, char uplo, lapack_int m, lapack_int n, lapack_complex_double alpha,
-                               lapack_complex_double beta, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_slasrt_work(char id, lapack_int n, float* d);
-lapack_int LAPACKE_dlasrt_work(char id, lapack_int n, double* d);
-
-lapack_int LAPACKE_slaswp_work(int matrix_order, lapack_int n, float* a, lapack_int lda, lapack_int k1, lapack_int k2,
-                               const lapack_int* ipiv, lapack_int incx);
-lapack_int LAPACKE_dlaswp_work(int matrix_order, lapack_int n, double* a, lapack_int lda, lapack_int k1, lapack_int k2,
-                               const lapack_int* ipiv, lapack_int incx);
-lapack_int LAPACKE_claswp_work(int matrix_order, lapack_int n, lapack_complex_float* a, lapack_int lda, lapack_int k1,
-                               lapack_int k2, const lapack_int* ipiv, lapack_int incx);
-lapack_int LAPACKE_zlaswp_work(int matrix_order, lapack_int n, lapack_complex_double* a, lapack_int lda, lapack_int k1,
-                               lapack_int k2, const lapack_int* ipiv, lapack_int incx);
-
-lapack_int LAPACKE_slatms_work(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                               float* d, lapack_int mode, float cond, float dmax, lapack_int kl, lapack_int ku,
-                               char pack, float* a, lapack_int lda, float* work);
-lapack_int LAPACKE_dlatms_work(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                               double* d, lapack_int mode, double cond, double dmax, lapack_int kl, lapack_int ku,
-                               char pack, double* a, lapack_int lda, double* work);
-lapack_int LAPACKE_clatms_work(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                               float* d, lapack_int mode, float cond, float dmax, lapack_int kl, lapack_int ku,
-                               char pack, lapack_complex_float* a, lapack_int lda, lapack_complex_float* work);
-lapack_int LAPACKE_zlatms_work(int matrix_order, lapack_int m, lapack_int n, char dist, lapack_int* iseed, char sym,
-                               double* d, lapack_int mode, double cond, double dmax, lapack_int kl, lapack_int ku,
-                               char pack, lapack_complex_double* a, lapack_int lda, lapack_complex_double* work);
-
-lapack_int LAPACKE_slauum_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dlauum_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_clauum_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zlauum_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_sopgtr_work(int matrix_order, char uplo, lapack_int n, const float* ap, const float* tau, float* q,
-                               lapack_int ldq, float* work);
-lapack_int LAPACKE_dopgtr_work(int matrix_order, char uplo, lapack_int n, const double* ap, const double* tau,
-                               double* q, lapack_int ldq, double* work);
-
-lapack_int LAPACKE_sopmtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const float* ap, const float* tau, float* c, lapack_int ldc, float* work);
-lapack_int LAPACKE_dopmtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const double* ap, const double* tau, double* c, lapack_int ldc, double* work);
-
-lapack_int LAPACKE_sorgbr_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k, float* a,
-                               lapack_int lda, const float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dorgbr_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k, double* a,
-                               lapack_int lda, const double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sorghr_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, float* a, lapack_int lda,
-                               const float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dorghr_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, double* a,
-                               lapack_int lda, const double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sorglq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                               const float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dorglq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                               const double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sorgql_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                               const float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dorgql_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                               const double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sorgqr_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                               const float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dorgqr_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                               const double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sorgrq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, float* a, lapack_int lda,
-                               const float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dorgrq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, double* a, lapack_int lda,
-                               const double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sorgtr_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, const float* tau,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dorgtr_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, const double* tau,
-                               double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormbr_work(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n,
-                               lapack_int k, const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dormbr_work(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n,
-                               lapack_int k, const double* a, lapack_int lda, const double* tau, double* c,
-                               lapack_int ldc, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormhr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, const float* a, lapack_int lda, const float* tau, float* c,
-                               lapack_int ldc, float* work, lapack_int lwork);
-lapack_int LAPACKE_dormhr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, const double* a, lapack_int lda, const double* tau, double* c,
-                               lapack_int ldc, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormlq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dormlq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc,
-                               double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormql_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dormql_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc,
-                               double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormqr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dormqr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc,
-                               double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormrq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dormrq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc,
-                               double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormrz_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               lapack_int l, const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dormrz_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               lapack_int l, const double* a, lapack_int lda, const double* tau, double* c,
-                               lapack_int ldc, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_sormtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const float* a, lapack_int lda, const float* tau, float* c, lapack_int ldc, float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dormtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const double* a, lapack_int lda, const double* tau, double* c, lapack_int ldc,
-                               double* work, lapack_int lwork);
-
-lapack_int LAPACKE_spbcon_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, const float* ab,
-                               lapack_int ldab, float anorm, float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dpbcon_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, const double* ab,
-                               lapack_int ldab, double anorm, double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cpbcon_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float* ab,
-                               lapack_int ldab, float anorm, float* rcond, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zpbcon_work(int matrix_order, char uplo, lapack_int n, lapack_int kd,
-                               const lapack_complex_double* ab, lapack_int ldab, double anorm, double* rcond,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spbequ_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, const float* ab,
-                               lapack_int ldab, float* s, float* scond, float* amax);
-lapack_int LAPACKE_dpbequ_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, const double* ab,
-                               lapack_int ldab, double* s, double* scond, double* amax);
-lapack_int LAPACKE_cpbequ_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float* ab,
-                               lapack_int ldab, float* s, float* scond, float* amax);
-lapack_int LAPACKE_zpbequ_work(int matrix_order, char uplo, lapack_int n, lapack_int kd,
-                               const lapack_complex_double* ab, lapack_int ldab, double* s, double* scond,
-                               double* amax);
-
-lapack_int LAPACKE_spbrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const float* ab, lapack_int ldab, const float* afb, lapack_int ldafb, const float* b,
-                               lapack_int ldb, float* x, lapack_int ldx, float* ferr, float* berr, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dpbrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const double* ab, lapack_int ldab, const double* afb, lapack_int ldafb, const double* b,
-                               lapack_int ldb, double* x, lapack_int ldx, double* ferr, double* berr, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cpbrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const lapack_complex_float* ab, lapack_int ldab, const lapack_complex_float* afb,
-                               lapack_int ldafb, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                               lapack_int ldx, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zpbrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const lapack_complex_double* ab, lapack_int ldab, const lapack_complex_double* afb,
-                               lapack_int ldafb, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spbstf_work(int matrix_order, char uplo, lapack_int n, lapack_int kb, float* bb, lapack_int ldbb);
-lapack_int LAPACKE_dpbstf_work(int matrix_order, char uplo, lapack_int n, lapack_int kb, double* bb, lapack_int ldbb);
-lapack_int LAPACKE_cpbstf_work(int matrix_order, char uplo, lapack_int n, lapack_int kb, lapack_complex_float* bb,
-                               lapack_int ldbb);
-lapack_int LAPACKE_zpbstf_work(int matrix_order, char uplo, lapack_int n, lapack_int kb, lapack_complex_double* bb,
-                               lapack_int ldbb);
-
-lapack_int LAPACKE_spbsv_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, float* ab,
-                              lapack_int ldab, float* b, lapack_int ldb);
-lapack_int LAPACKE_dpbsv_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs, double* ab,
-                              lapack_int ldab, double* b, lapack_int ldb);
-lapack_int LAPACKE_cpbsv_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                              lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpbsv_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                              lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spbsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               float* ab, lapack_int ldab, float* afb, lapack_int ldafb, char* equed, float* s,
-                               float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* ferr,
-                               float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dpbsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               double* ab, lapack_int ldab, double* afb, lapack_int ldafb, char* equed, double* s,
-                               double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr,
-                               double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cpbsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* afb, lapack_int ldafb,
-                               char* equed, float* s, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                               lapack_int ldx, float* rcond, float* ferr, float* berr, lapack_complex_float* work,
-                               float* rwork);
-lapack_int LAPACKE_zpbsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* afb, lapack_int ldafb,
-                               char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spbtrf_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, float* ab, lapack_int ldab);
-lapack_int LAPACKE_dpbtrf_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, double* ab, lapack_int ldab);
-lapack_int LAPACKE_cpbtrf_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_complex_float* ab,
-                               lapack_int ldab);
-lapack_int LAPACKE_zpbtrf_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_complex_double* ab,
-                               lapack_int ldab);
-
-lapack_int LAPACKE_spbtrs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const float* ab, lapack_int ldab, float* b, lapack_int ldb);
-lapack_int LAPACKE_dpbtrs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const double* ab, lapack_int ldab, double* b, lapack_int ldb);
-lapack_int LAPACKE_cpbtrs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const lapack_complex_float* ab, lapack_int ldab, lapack_complex_float* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_zpbtrs_work(int matrix_order, char uplo, lapack_int n, lapack_int kd, lapack_int nrhs,
-                               const lapack_complex_double* ab, lapack_int ldab, lapack_complex_double* b,
-                               lapack_int ldb);
-
-lapack_int LAPACKE_spftrf_work(int matrix_order, char transr, char uplo, lapack_int n, float* a);
-lapack_int LAPACKE_dpftrf_work(int matrix_order, char transr, char uplo, lapack_int n, double* a);
-lapack_int LAPACKE_cpftrf_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_float* a);
-lapack_int LAPACKE_zpftrf_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_double* a);
-
-lapack_int LAPACKE_spftri_work(int matrix_order, char transr, char uplo, lapack_int n, float* a);
-lapack_int LAPACKE_dpftri_work(int matrix_order, char transr, char uplo, lapack_int n, double* a);
-lapack_int LAPACKE_cpftri_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_float* a);
-lapack_int LAPACKE_zpftri_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_complex_double* a);
-
-lapack_int LAPACKE_spftrs_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                               float* b, lapack_int ldb);
-lapack_int LAPACKE_dpftrs_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                               double* b, lapack_int ldb);
-lapack_int LAPACKE_cpftrs_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpftrs_work(int matrix_order, char transr, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spocon_work(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda, float anorm,
-                               float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dpocon_work(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda, double anorm,
-                               double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cpocon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                               float anorm, float* rcond, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zpocon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, double anorm, double* rcond, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spoequ_work(int matrix_order, lapack_int n, const float* a, lapack_int lda, float* s, float* scond,
-                               float* amax);
-lapack_int LAPACKE_dpoequ_work(int matrix_order, lapack_int n, const double* a, lapack_int lda, double* s,
-                               double* scond, double* amax);
-lapack_int LAPACKE_cpoequ_work(int matrix_order, lapack_int n, const lapack_complex_float* a, lapack_int lda, float* s,
-                               float* scond, float* amax);
-lapack_int LAPACKE_zpoequ_work(int matrix_order, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                               double* s, double* scond, double* amax);
-
-lapack_int LAPACKE_spoequb_work(int matrix_order, lapack_int n, const float* a, lapack_int lda, float* s, float* scond,
-                                float* amax);
-lapack_int LAPACKE_dpoequb_work(int matrix_order, lapack_int n, const double* a, lapack_int lda, double* s,
-                                double* scond, double* amax);
-lapack_int LAPACKE_cpoequb_work(int matrix_order, lapack_int n, const lapack_complex_float* a, lapack_int lda, float* s,
-                                float* scond, float* amax);
-lapack_int LAPACKE_zpoequb_work(int matrix_order, lapack_int n, const lapack_complex_double* a, lapack_int lda,
-                                double* s, double* scond, double* amax);
-
-lapack_int LAPACKE_sporfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, const float* af, lapack_int ldaf, const float* b, lapack_int ldb,
-                               float* x, lapack_int ldx, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dporfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, const double* af, lapack_int ldaf, const double* b, lapack_int ldb,
-                               double* x, lapack_int ldx, double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cporfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                               lapack_int ldaf, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                               lapack_int ldx, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zporfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                               lapack_int ldaf, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sporfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const float* a,
-                                lapack_int lda, const float* af, lapack_int ldaf, const float* s, const float* b,
-                                lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dporfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const double* a,
-                                lapack_int lda, const double* af, lapack_int ldaf, const double* s, const double* b,
-                                lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cporfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                                lapack_int ldaf, const float* s, const lapack_complex_float* b, lapack_int ldb,
-                                lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zporfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                                lapack_int ldaf, const double* s, const lapack_complex_double* b, lapack_int ldb,
-                                lapack_complex_double* x, lapack_int ldx, double* rcond, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sposv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                              float* b, lapack_int ldb);
-lapack_int LAPACKE_dposv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                              double* b, lapack_int ldb);
-lapack_int LAPACKE_cposv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                              lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zposv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                              lapack_int lda, lapack_complex_double* b, lapack_int ldb);
-lapack_int LAPACKE_dsposv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                               double* b, lapack_int ldb, double* x, lapack_int ldx, double* work, float* swork,
-                               lapack_int* iter);
-lapack_int LAPACKE_zcposv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                               lapack_int ldx, lapack_complex_double* work, lapack_complex_float* swork, double* rwork,
-                               lapack_int* iter);
-
-lapack_int LAPACKE_sposvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* a,
-                               lapack_int lda, float* af, lapack_int ldaf, char* equed, float* s, float* b,
-                               lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* ferr, float* berr,
-                               float* work, lapack_int* iwork);
-lapack_int LAPACKE_dposvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* a,
-                               lapack_int lda, double* af, lapack_int ldaf, char* equed, double* s, double* b,
-                               lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                               double* work, lapack_int* iwork);
-lapack_int LAPACKE_cposvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                               char* equed, float* s, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                               lapack_int ldx, float* rcond, float* ferr, float* berr, lapack_complex_float* work,
-                               float* rwork);
-lapack_int LAPACKE_zposvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                               char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sposvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* a,
-                                lapack_int lda, float* af, lapack_int ldaf, char* equed, float* s, float* b,
-                                lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dposvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* a,
-                                lapack_int lda, double* af, lapack_int ldaf, char* equed, double* s, double* b,
-                                lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cposvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                                lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                                char* equed, float* s, lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                                lapack_int ldx, float* rcond, float* rpvgrw, float* berr, lapack_int n_err_bnds,
-                                float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams, float* params,
-                                lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zposvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                                lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                                char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                                lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spotrf_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dpotrf_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_cpotrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zpotrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_spotri_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dpotri_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_cpotri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zpotri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_spotrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, float* b, lapack_int ldb);
-lapack_int LAPACKE_dpotrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, double* b, lapack_int ldb);
-lapack_int LAPACKE_cpotrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpotrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, lapack_complex_double* b,
-                               lapack_int ldb);
-
-lapack_int LAPACKE_sppcon_work(int matrix_order, char uplo, lapack_int n, const float* ap, float anorm, float* rcond,
-                               float* work, lapack_int* iwork);
-lapack_int LAPACKE_dppcon_work(int matrix_order, char uplo, lapack_int n, const double* ap, double anorm, double* rcond,
-                               double* work, lapack_int* iwork);
-lapack_int LAPACKE_cppcon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap, float anorm,
-                               float* rcond, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zppcon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap, double anorm,
-                               double* rcond, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sppequ_work(int matrix_order, char uplo, lapack_int n, const float* ap, float* s, float* scond,
-                               float* amax);
-lapack_int LAPACKE_dppequ_work(int matrix_order, char uplo, lapack_int n, const double* ap, double* s, double* scond,
-                               double* amax);
-lapack_int LAPACKE_cppequ_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap, float* s,
-                               float* scond, float* amax);
-lapack_int LAPACKE_zppequ_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap, double* s,
-                               double* scond, double* amax);
-
-lapack_int LAPACKE_spprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap,
-                               const float* afp, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* ferr,
-                               float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dpprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                               const double* afp, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                               double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cpprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, const lapack_complex_float* afp,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zpprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, const lapack_complex_double* afp,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sppsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* ap, float* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_dppsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* ap, double* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_cppsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* ap,
-                              lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zppsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* ap,
-                              lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sppsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* ap,
-                               float* afp, char* equed, float* s, float* b, lapack_int ldb, float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dppsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* ap,
-                               double* afp, char* equed, double* s, double* b, lapack_int ldb, double* x,
-                               lapack_int ldx, double* rcond, double* ferr, double* berr, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cppsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               lapack_complex_float* ap, lapack_complex_float* afp, char* equed, float* s,
-                               lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zppsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               lapack_complex_double* ap, lapack_complex_double* afp, char* equed, double* s,
-                               lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spptrf_work(int matrix_order, char uplo, lapack_int n, float* ap);
-lapack_int LAPACKE_dpptrf_work(int matrix_order, char uplo, lapack_int n, double* ap);
-lapack_int LAPACKE_cpptrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap);
-lapack_int LAPACKE_zpptrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap);
-
-lapack_int LAPACKE_spptri_work(int matrix_order, char uplo, lapack_int n, float* ap);
-lapack_int LAPACKE_dpptri_work(int matrix_order, char uplo, lapack_int n, double* ap);
-lapack_int LAPACKE_cpptri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap);
-lapack_int LAPACKE_zpptri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap);
-
-lapack_int LAPACKE_spptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap, float* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_dpptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap, double* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_cpptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_spstrf_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, lapack_int* piv,
-                               lapack_int* rank, float tol, float* work);
-lapack_int LAPACKE_dpstrf_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, lapack_int* piv,
-                               lapack_int* rank, double tol, double* work);
-lapack_int LAPACKE_cpstrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* piv, lapack_int* rank, float tol, float* work);
-lapack_int LAPACKE_zpstrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* piv, lapack_int* rank, double tol, double* work);
-
-lapack_int LAPACKE_sptcon_work(lapack_int n, const float* d, const float* e, float anorm, float* rcond, float* work);
-lapack_int LAPACKE_dptcon_work(lapack_int n, const double* d, const double* e, double anorm, double* rcond,
-                               double* work);
-lapack_int LAPACKE_cptcon_work(lapack_int n, const float* d, const lapack_complex_float* e, float anorm, float* rcond,
-                               float* work);
-lapack_int LAPACKE_zptcon_work(lapack_int n, const double* d, const lapack_complex_double* e, double anorm,
-                               double* rcond, double* work);
-
-lapack_int LAPACKE_spteqr_work(int matrix_order, char compz, lapack_int n, float* d, float* e, float* z, lapack_int ldz,
-                               float* work);
-lapack_int LAPACKE_dpteqr_work(int matrix_order, char compz, lapack_int n, double* d, double* e, double* z,
-                               lapack_int ldz, double* work);
-lapack_int LAPACKE_cpteqr_work(int matrix_order, char compz, lapack_int n, float* d, float* e, lapack_complex_float* z,
-                               lapack_int ldz, float* work);
-lapack_int LAPACKE_zpteqr_work(int matrix_order, char compz, lapack_int n, double* d, double* e,
-                               lapack_complex_double* z, lapack_int ldz, double* work);
-
-lapack_int LAPACKE_sptrfs_work(int matrix_order, lapack_int n, lapack_int nrhs, const float* d, const float* e,
-                               const float* df, const float* ef, const float* b, lapack_int ldb, float* x,
-                               lapack_int ldx, float* ferr, float* berr, float* work);
-lapack_int LAPACKE_dptrfs_work(int matrix_order, lapack_int n, lapack_int nrhs, const double* d, const double* e,
-                               const double* df, const double* ef, const double* b, lapack_int ldb, double* x,
-                               lapack_int ldx, double* ferr, double* berr, double* work);
-lapack_int LAPACKE_cptrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* d,
-                               const lapack_complex_float* e, const float* df, const lapack_complex_float* ef,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zptrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* d,
-                               const lapack_complex_double* e, const double* df, const lapack_complex_double* ef,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sptsv_work(int matrix_order, lapack_int n, lapack_int nrhs, float* d, float* e, float* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_dptsv_work(int matrix_order, lapack_int n, lapack_int nrhs, double* d, double* e, double* b,
-                              lapack_int ldb);
-lapack_int LAPACKE_cptsv_work(int matrix_order, lapack_int n, lapack_int nrhs, float* d, lapack_complex_float* e,
-                              lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zptsv_work(int matrix_order, lapack_int n, lapack_int nrhs, double* d, lapack_complex_double* e,
-                              lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sptsvx_work(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const float* d,
-                               const float* e, float* df, float* ef, const float* b, lapack_int ldb, float* x,
-                               lapack_int ldx, float* rcond, float* ferr, float* berr, float* work);
-lapack_int LAPACKE_dptsvx_work(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const double* d,
-                               const double* e, double* df, double* ef, const double* b, lapack_int ldb, double* x,
-                               lapack_int ldx, double* rcond, double* ferr, double* berr, double* work);
-lapack_int LAPACKE_cptsvx_work(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const float* d,
-                               const lapack_complex_float* e, float* df, lapack_complex_float* ef,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zptsvx_work(int matrix_order, char fact, lapack_int n, lapack_int nrhs, const double* d,
-                               const lapack_complex_double* e, double* df, lapack_complex_double* ef,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_spttrf_work(lapack_int n, float* d, float* e);
-lapack_int LAPACKE_dpttrf_work(lapack_int n, double* d, double* e);
-lapack_int LAPACKE_cpttrf_work(lapack_int n, float* d, lapack_complex_float* e);
-lapack_int LAPACKE_zpttrf_work(lapack_int n, double* d, lapack_complex_double* e);
-
-lapack_int LAPACKE_spttrs_work(int matrix_order, lapack_int n, lapack_int nrhs, const float* d, const float* e,
-                               float* b, lapack_int ldb);
-lapack_int LAPACKE_dpttrs_work(int matrix_order, lapack_int n, lapack_int nrhs, const double* d, const double* e,
-                               double* b, lapack_int ldb);
-lapack_int LAPACKE_cpttrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* d,
-                               const lapack_complex_float* e, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zpttrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* d,
-                               const lapack_complex_double* e, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_ssbev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, float* ab,
-                              lapack_int ldab, float* w, float* z, lapack_int ldz, float* work);
-lapack_int LAPACKE_dsbev_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, double* ab,
-                              lapack_int ldab, double* w, double* z, lapack_int ldz, double* work);
-
-lapack_int LAPACKE_ssbevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, float* ab,
-                               lapack_int ldab, float* w, float* z, lapack_int ldz, float* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dsbevd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int kd, double* ab,
-                               lapack_int ldab, double* w, double* z, lapack_int ldz, double* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_ssbevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd,
-                               float* ab, lapack_int ldab, float* q, lapack_int ldq, float vl, float vu, lapack_int il,
-                               lapack_int iu, float abstol, lapack_int* m, float* w, float* z, lapack_int ldz,
-                               float* work, lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_dsbevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int kd,
-                               double* ab, lapack_int ldab, double* q, lapack_int ldq, double vl, double vu,
-                               lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w, double* z,
-                               lapack_int ldz, double* work, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_ssbgst_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               float* ab, lapack_int ldab, const float* bb, lapack_int ldbb, float* x, lapack_int ldx,
-                               float* work);
-lapack_int LAPACKE_dsbgst_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               double* ab, lapack_int ldab, const double* bb, lapack_int ldbb, double* x,
-                               lapack_int ldx, double* work);
-
-lapack_int LAPACKE_ssbgv_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                              float* ab, lapack_int ldab, float* bb, lapack_int ldbb, float* w, float* z,
-                              lapack_int ldz, float* work);
-lapack_int LAPACKE_dsbgv_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                              double* ab, lapack_int ldab, double* bb, lapack_int ldbb, double* w, double* z,
-                              lapack_int ldz, double* work);
-
-lapack_int LAPACKE_ssbgvd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               float* ab, lapack_int ldab, float* bb, lapack_int ldbb, float* w, float* z,
-                               lapack_int ldz, float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dsbgvd_work(int matrix_order, char jobz, char uplo, lapack_int n, lapack_int ka, lapack_int kb,
-                               double* ab, lapack_int ldab, double* bb, lapack_int ldbb, double* w, double* z,
-                               lapack_int ldz, double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_ssbgvx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                               lapack_int kb, float* ab, lapack_int ldab, float* bb, lapack_int ldbb, float* q,
-                               lapack_int ldq, float vl, float vu, lapack_int il, lapack_int iu, float abstol,
-                               lapack_int* m, float* w, float* z, lapack_int ldz, float* work, lapack_int* iwork,
-                               lapack_int* ifail);
-lapack_int LAPACKE_dsbgvx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, lapack_int ka,
-                               lapack_int kb, double* ab, lapack_int ldab, double* bb, lapack_int ldbb, double* q,
-                               lapack_int ldq, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                               lapack_int* m, double* w, double* z, lapack_int ldz, double* work, lapack_int* iwork,
-                               lapack_int* ifail);
-
-lapack_int LAPACKE_ssbtrd_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd, float* ab,
-                               lapack_int ldab, float* d, float* e, float* q, lapack_int ldq, float* work);
-lapack_int LAPACKE_dsbtrd_work(int matrix_order, char vect, char uplo, lapack_int n, lapack_int kd, double* ab,
-                               lapack_int ldab, double* d, double* e, double* q, lapack_int ldq, double* work);
-
-lapack_int LAPACKE_ssfrk_work(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k,
-                              float alpha, const float* a, lapack_int lda, float beta, float* c);
-lapack_int LAPACKE_dsfrk_work(int matrix_order, char transr, char uplo, char trans, lapack_int n, lapack_int k,
-                              double alpha, const double* a, lapack_int lda, double beta, double* c);
-
-lapack_int LAPACKE_sspcon_work(int matrix_order, char uplo, lapack_int n, const float* ap, const lapack_int* ipiv,
-                               float anorm, float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dspcon_work(int matrix_order, char uplo, lapack_int n, const double* ap, const lapack_int* ipiv,
-                               double anorm, double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_cspcon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                               const lapack_int* ipiv, float anorm, float* rcond, lapack_complex_float* work);
-lapack_int LAPACKE_zspcon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                               const lapack_int* ipiv, double anorm, double* rcond, lapack_complex_double* work);
-
-lapack_int LAPACKE_sspev_work(int matrix_order, char jobz, char uplo, lapack_int n, float* ap, float* w, float* z,
-                              lapack_int ldz, float* work);
-lapack_int LAPACKE_dspev_work(int matrix_order, char jobz, char uplo, lapack_int n, double* ap, double* w, double* z,
-                              lapack_int ldz, double* work);
-
-lapack_int LAPACKE_sspevd_work(int matrix_order, char jobz, char uplo, lapack_int n, float* ap, float* w, float* z,
-                               lapack_int ldz, float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dspevd_work(int matrix_order, char jobz, char uplo, lapack_int n, double* ap, double* w, double* z,
-                               lapack_int ldz, double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_sspevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, float* ap, float vl,
-                               float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z,
-                               lapack_int ldz, float* work, lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_dspevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, double* ap, double vl,
-                               double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               double* z, lapack_int ldz, double* work, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_sspgst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, float* ap, const float* bp);
-lapack_int LAPACKE_dspgst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, double* ap,
-                               const double* bp);
-
-lapack_int LAPACKE_sspgv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* ap,
-                              float* bp, float* w, float* z, lapack_int ldz, float* work);
-lapack_int LAPACKE_dspgv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* ap,
-                              double* bp, double* w, double* z, lapack_int ldz, double* work);
-
-lapack_int LAPACKE_sspgvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* ap,
-                               float* bp, float* w, float* z, lapack_int ldz, float* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dspgvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* ap,
-                               double* bp, double* w, double* z, lapack_int ldz, double* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_sspgvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               float* ap, float* bp, float vl, float vu, lapack_int il, lapack_int iu, float abstol,
-                               lapack_int* m, float* w, float* z, lapack_int ldz, float* work, lapack_int* iwork,
-                               lapack_int* ifail);
-lapack_int LAPACKE_dspgvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               double* ap, double* bp, double vl, double vu, lapack_int il, lapack_int iu,
-                               double abstol, lapack_int* m, double* w, double* z, lapack_int ldz, double* work,
-                               lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_ssprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap,
-                               const float* afp, const lapack_int* ipiv, const float* b, lapack_int ldb, float* x,
-                               lapack_int ldx, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dsprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                               const double* afp, const lapack_int* ipiv, const double* b, lapack_int ldb, double* x,
-                               lapack_int ldx, double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_csprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, const lapack_complex_float* afp, const lapack_int* ipiv,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zsprfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, const lapack_complex_double* afp,
-                               const lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_sspsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* ap, lapack_int* ipiv,
-                              float* b, lapack_int ldb);
-lapack_int LAPACKE_dspsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* ap, lapack_int* ipiv,
-                              double* b, lapack_int ldb);
-lapack_int LAPACKE_cspsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* ap,
-                              lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zspsv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* ap,
-                              lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_sspsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const float* ap,
-                               float* afp, lapack_int* ipiv, const float* b, lapack_int ldb, float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dspsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                               double* afp, lapack_int* ipiv, const double* b, lapack_int ldb, double* x,
-                               lapack_int ldx, double* rcond, double* ferr, double* berr, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_cspsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, lapack_complex_float* afp, lapack_int* ipiv,
-                               const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x, lapack_int ldx,
-                               float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zspsvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, lapack_complex_double* afp, lapack_int* ipiv,
-                               const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x, lapack_int ldx,
-                               double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_ssptrd_work(int matrix_order, char uplo, lapack_int n, float* ap, float* d, float* e, float* tau);
-lapack_int LAPACKE_dsptrd_work(int matrix_order, char uplo, lapack_int n, double* ap, double* d, double* e,
-                               double* tau);
-
-lapack_int LAPACKE_ssptrf_work(int matrix_order, char uplo, lapack_int n, float* ap, lapack_int* ipiv);
-lapack_int LAPACKE_dsptrf_work(int matrix_order, char uplo, lapack_int n, double* ap, lapack_int* ipiv);
-lapack_int LAPACKE_csptrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap, lapack_int* ipiv);
-lapack_int LAPACKE_zsptrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap, lapack_int* ipiv);
-
-lapack_int LAPACKE_ssptri_work(int matrix_order, char uplo, lapack_int n, float* ap, const lapack_int* ipiv,
-                               float* work);
-lapack_int LAPACKE_dsptri_work(int matrix_order, char uplo, lapack_int n, double* ap, const lapack_int* ipiv,
-                               double* work);
-lapack_int LAPACKE_csptri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* ap,
-                               const lapack_int* ipiv, lapack_complex_float* work);
-lapack_int LAPACKE_zsptri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* ap,
-                               const lapack_int* ipiv, lapack_complex_double* work);
-
-lapack_int LAPACKE_ssptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* ap,
-                               const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dsptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* ap,
-                               const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_csptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, const lapack_int* ipiv, lapack_complex_float* b,
-                               lapack_int ldb);
-lapack_int LAPACKE_zsptrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, const lapack_int* ipiv, lapack_complex_double* b,
-                               lapack_int ldb);
-
-lapack_int LAPACKE_sstebz_work(char range, char order, lapack_int n, float vl, float vu, lapack_int il, lapack_int iu,
-                               float abstol, const float* d, const float* e, lapack_int* m, lapack_int* nsplit,
-                               float* w, lapack_int* iblock, lapack_int* isplit, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dstebz_work(char range, char order, lapack_int n, double vl, double vu, lapack_int il, lapack_int iu,
-                               double abstol, const double* d, const double* e, lapack_int* m, lapack_int* nsplit,
-                               double* w, lapack_int* iblock, lapack_int* isplit, double* work, lapack_int* iwork);
-
-lapack_int LAPACKE_sstedc_work(int matrix_order, char compz, lapack_int n, float* d, float* e, float* z, lapack_int ldz,
-                               float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dstedc_work(int matrix_order, char compz, lapack_int n, double* d, double* e, double* z,
-                               lapack_int ldz, double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_cstedc_work(int matrix_order, char compz, lapack_int n, float* d, float* e, lapack_complex_float* z,
-                               lapack_int ldz, lapack_complex_float* work, lapack_int lwork, float* rwork,
-                               lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zstedc_work(int matrix_order, char compz, lapack_int n, double* d, double* e,
-                               lapack_complex_double* z, lapack_int ldz, lapack_complex_double* work, lapack_int lwork,
-                               double* rwork, lapack_int lrwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_sstegr_work(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl,
-                               float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z,
-                               lapack_int ldz, lapack_int* isuppz, float* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_int liwork);
-lapack_int LAPACKE_dstegr_work(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                               double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               double* z, lapack_int ldz, lapack_int* isuppz, double* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_cstegr_work(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl,
-                               float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w,
-                               lapack_complex_float* z, lapack_int ldz, lapack_int* isuppz, float* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zstegr_work(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                               double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               lapack_complex_double* z, lapack_int ldz, lapack_int* isuppz, double* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_sstein_work(int matrix_order, lapack_int n, const float* d, const float* e, lapack_int m,
-                               const float* w, const lapack_int* iblock, const lapack_int* isplit, float* z,
-                               lapack_int ldz, float* work, lapack_int* iwork, lapack_int* ifailv);
-lapack_int LAPACKE_dstein_work(int matrix_order, lapack_int n, const double* d, const double* e, lapack_int m,
-                               const double* w, const lapack_int* iblock, const lapack_int* isplit, double* z,
-                               lapack_int ldz, double* work, lapack_int* iwork, lapack_int* ifailv);
-lapack_int LAPACKE_cstein_work(int matrix_order, lapack_int n, const float* d, const float* e, lapack_int m,
-                               const float* w, const lapack_int* iblock, const lapack_int* isplit,
-                               lapack_complex_float* z, lapack_int ldz, float* work, lapack_int* iwork,
-                               lapack_int* ifailv);
-lapack_int LAPACKE_zstein_work(int matrix_order, lapack_int n, const double* d, const double* e, lapack_int m,
-                               const double* w, const lapack_int* iblock, const lapack_int* isplit,
-                               lapack_complex_double* z, lapack_int ldz, double* work, lapack_int* iwork,
-                               lapack_int* ifailv);
-
-lapack_int LAPACKE_sstemr_work(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl,
-                               float vu, lapack_int il, lapack_int iu, lapack_int* m, float* w, float* z,
-                               lapack_int ldz, lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac, float* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dstemr_work(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                               double vu, lapack_int il, lapack_int iu, lapack_int* m, double* w, double* z,
-                               lapack_int ldz, lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac, double* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_cstemr_work(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl,
-                               float vu, lapack_int il, lapack_int iu, lapack_int* m, float* w, lapack_complex_float* z,
-                               lapack_int ldz, lapack_int nzc, lapack_int* isuppz, lapack_logical* tryrac, float* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_zstemr_work(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                               double vu, lapack_int il, lapack_int iu, lapack_int* m, double* w,
-                               lapack_complex_double* z, lapack_int ldz, lapack_int nzc, lapack_int* isuppz,
-                               lapack_logical* tryrac, double* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_int liwork);
-
-lapack_int LAPACKE_ssteqr_work(int matrix_order, char compz, lapack_int n, float* d, float* e, float* z, lapack_int ldz,
-                               float* work);
-lapack_int LAPACKE_dsteqr_work(int matrix_order, char compz, lapack_int n, double* d, double* e, double* z,
-                               lapack_int ldz, double* work);
-lapack_int LAPACKE_csteqr_work(int matrix_order, char compz, lapack_int n, float* d, float* e, lapack_complex_float* z,
-                               lapack_int ldz, float* work);
-lapack_int LAPACKE_zsteqr_work(int matrix_order, char compz, lapack_int n, double* d, double* e,
-                               lapack_complex_double* z, lapack_int ldz, double* work);
-
-lapack_int LAPACKE_ssterf_work(lapack_int n, float* d, float* e);
-lapack_int LAPACKE_dsterf_work(lapack_int n, double* d, double* e);
-
-lapack_int LAPACKE_sstev_work(int matrix_order, char jobz, lapack_int n, float* d, float* e, float* z, lapack_int ldz,
-                              float* work);
-lapack_int LAPACKE_dstev_work(int matrix_order, char jobz, lapack_int n, double* d, double* e, double* z,
-                              lapack_int ldz, double* work);
-
-lapack_int LAPACKE_sstevd_work(int matrix_order, char jobz, lapack_int n, float* d, float* e, float* z, lapack_int ldz,
-                               float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dstevd_work(int matrix_order, char jobz, lapack_int n, double* d, double* e, double* z,
-                               lapack_int ldz, double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_sstevr_work(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl,
-                               float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z,
-                               lapack_int ldz, lapack_int* isuppz, float* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_int liwork);
-lapack_int LAPACKE_dstevr_work(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                               double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               double* z, lapack_int ldz, lapack_int* isuppz, double* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_sstevx_work(int matrix_order, char jobz, char range, lapack_int n, float* d, float* e, float vl,
-                               float vu, lapack_int il, lapack_int iu, float abstol, lapack_int* m, float* w, float* z,
-                               lapack_int ldz, float* work, lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_dstevx_work(int matrix_order, char jobz, char range, lapack_int n, double* d, double* e, double vl,
-                               double vu, lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w,
-                               double* z, lapack_int ldz, double* work, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_ssycon_work(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda,
-                               const lapack_int* ipiv, float anorm, float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dsycon_work(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda,
-                               const lapack_int* ipiv, double anorm, double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_csycon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                               const lapack_int* ipiv, float anorm, float* rcond, lapack_complex_float* work);
-lapack_int LAPACKE_zsycon_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, const lapack_int* ipiv, double anorm, double* rcond,
-                               lapack_complex_double* work);
-
-lapack_int LAPACKE_ssyequb_work(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda, float* s,
-                                float* scond, float* amax, float* work);
-lapack_int LAPACKE_dsyequb_work(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda, double* s,
-                                double* scond, double* amax, double* work);
-lapack_int LAPACKE_csyequb_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a,
-                                lapack_int lda, float* s, float* scond, float* amax, lapack_complex_float* work);
-lapack_int LAPACKE_zsyequb_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a,
-                                lapack_int lda, double* s, double* scond, double* amax, lapack_complex_double* work);
-
-lapack_int LAPACKE_ssyev_work(int matrix_order, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w,
-                              float* work, lapack_int lwork);
-lapack_int LAPACKE_dsyev_work(int matrix_order, char jobz, char uplo, lapack_int n, double* a, lapack_int lda,
-                              double* w, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_ssyevd_work(int matrix_order, char jobz, char uplo, lapack_int n, float* a, lapack_int lda, float* w,
-                               float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dsyevd_work(int matrix_order, char jobz, char uplo, lapack_int n, double* a, lapack_int lda,
-                               double* w, double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_ssyevr_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, float* a,
-                               lapack_int lda, float vl, float vu, lapack_int il, lapack_int iu, float abstol,
-                               lapack_int* m, float* w, float* z, lapack_int ldz, lapack_int* isuppz, float* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dsyevr_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, double* a,
-                               lapack_int lda, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                               lapack_int* m, double* w, double* z, lapack_int ldz, lapack_int* isuppz, double* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_ssyevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, float* a,
-                               lapack_int lda, float vl, float vu, lapack_int il, lapack_int iu, float abstol,
-                               lapack_int* m, float* w, float* z, lapack_int ldz, float* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_dsyevx_work(int matrix_order, char jobz, char range, char uplo, lapack_int n, double* a,
-                               lapack_int lda, double vl, double vu, lapack_int il, lapack_int iu, double abstol,
-                               lapack_int* m, double* w, double* z, lapack_int ldz, double* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_ssygst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, float* a, lapack_int lda,
-                               const float* b, lapack_int ldb);
-lapack_int LAPACKE_dsygst_work(int matrix_order, lapack_int itype, char uplo, lapack_int n, double* a, lapack_int lda,
-                               const double* b, lapack_int ldb);
-
-lapack_int LAPACKE_ssygv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* a,
-                              lapack_int lda, float* b, lapack_int ldb, float* w, float* work, lapack_int lwork);
-lapack_int LAPACKE_dsygv_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* a,
-                              lapack_int lda, double* b, lapack_int ldb, double* w, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_ssygvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, float* a,
-                               lapack_int lda, float* b, lapack_int ldb, float* w, float* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dsygvd_work(int matrix_order, lapack_int itype, char jobz, char uplo, lapack_int n, double* a,
-                               lapack_int lda, double* b, lapack_int ldb, double* w, double* work, lapack_int lwork,
-                               lapack_int* iwork, lapack_int liwork);
-
-lapack_int LAPACKE_ssygvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               float* a, lapack_int lda, float* b, lapack_int ldb, float vl, float vu, lapack_int il,
-                               lapack_int iu, float abstol, lapack_int* m, float* w, float* z, lapack_int ldz,
-                               float* work, lapack_int lwork, lapack_int* iwork, lapack_int* ifail);
-lapack_int LAPACKE_dsygvx_work(int matrix_order, lapack_int itype, char jobz, char range, char uplo, lapack_int n,
-                               double* a, lapack_int lda, double* b, lapack_int ldb, double vl, double vu,
-                               lapack_int il, lapack_int iu, double abstol, lapack_int* m, double* w, double* z,
-                               lapack_int ldz, double* work, lapack_int lwork, lapack_int* iwork, lapack_int* ifail);
-
-lapack_int LAPACKE_ssyrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, const float* af, lapack_int ldaf, const lapack_int* ipiv, const float* b,
-                               lapack_int ldb, float* x, lapack_int ldx, float* ferr, float* berr, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dsyrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, const double* af, lapack_int ldaf, const lapack_int* ipiv,
-                               const double* b, lapack_int ldb, double* x, lapack_int ldx, double* ferr, double* berr,
-                               double* work, lapack_int* iwork);
-lapack_int LAPACKE_csyrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                               lapack_int ldaf, const lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zsyrfs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                               lapack_int ldaf, const lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_ssyrfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const float* a,
-                                lapack_int lda, const float* af, lapack_int ldaf, const lapack_int* ipiv,
-                                const float* s, const float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond,
-                                float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                                lapack_int nparams, float* params, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dsyrfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs, const double* a,
-                                lapack_int lda, const double* af, lapack_int ldaf, const lapack_int* ipiv,
-                                const double* s, const double* b, lapack_int ldb, double* x, lapack_int ldx,
-                                double* rcond, double* berr, lapack_int n_err_bnds, double* err_bnds_norm,
-                                double* err_bnds_comp, lapack_int nparams, double* params, double* work,
-                                lapack_int* iwork);
-lapack_int LAPACKE_csyrfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* af,
-                                lapack_int ldaf, const lapack_int* ipiv, const float* s, const lapack_complex_float* b,
-                                lapack_int ldb, lapack_complex_float* x, lapack_int ldx, float* rcond, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zsyrfsx_work(int matrix_order, char uplo, char equed, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* af,
-                                lapack_int ldaf, const lapack_int* ipiv, const double* s,
-                                const lapack_complex_double* b, lapack_int ldb, lapack_complex_double* x,
-                                lapack_int ldx, double* rcond, double* berr, lapack_int n_err_bnds,
-                                double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams, double* params,
-                                lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_ssysv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, float* a, lapack_int lda,
-                              lapack_int* ipiv, float* b, lapack_int ldb, float* work, lapack_int lwork);
-lapack_int LAPACKE_dsysv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, double* a, lapack_int lda,
-                              lapack_int* ipiv, double* b, lapack_int ldb, double* work, lapack_int lwork);
-lapack_int LAPACKE_csysv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_float* a,
-                              lapack_int lda, lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb,
-                              lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zsysv_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, lapack_complex_double* a,
-                              lapack_int lda, lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb,
-                              lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_ssysvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, const float* b,
-                               lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* ferr, float* berr,
-                               float* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dsysvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, const double* b,
-                               lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                               double* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_csysvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                               lapack_int* ipiv, const lapack_complex_float* b, lapack_int ldb, lapack_complex_float* x,
-                               lapack_int ldx, float* rcond, float* ferr, float* berr, lapack_complex_float* work,
-                               lapack_int lwork, float* rwork);
-lapack_int LAPACKE_zsysvx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, lapack_complex_double* af,
-                               lapack_int ldaf, lapack_int* ipiv, const lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* x, lapack_int ldx, double* rcond, double* ferr, double* berr,
-                               lapack_complex_double* work, lapack_int lwork, double* rwork);
-
-lapack_int LAPACKE_ssysvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, float* a,
-                                lapack_int lda, float* af, lapack_int ldaf, lapack_int* ipiv, char* equed, float* s,
-                                float* b, lapack_int ldb, float* x, lapack_int ldx, float* rcond, float* rpvgrw,
-                                float* berr, lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                                lapack_int nparams, float* params, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dsysvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs, double* a,
-                                lapack_int lda, double* af, lapack_int ldaf, lapack_int* ipiv, char* equed, double* s,
-                                double* b, lapack_int ldb, double* x, lapack_int ldx, double* rcond, double* rpvgrw,
-                                double* berr, lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                                lapack_int nparams, double* params, double* work, lapack_int* iwork);
-lapack_int LAPACKE_csysvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                                lapack_complex_float* a, lapack_int lda, lapack_complex_float* af, lapack_int ldaf,
-                                lapack_int* ipiv, char* equed, float* s, lapack_complex_float* b, lapack_int ldb,
-                                lapack_complex_float* x, lapack_int ldx, float* rcond, float* rpvgrw, float* berr,
-                                lapack_int n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int nparams,
-                                float* params, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_zsysvxx_work(int matrix_order, char fact, char uplo, lapack_int n, lapack_int nrhs,
-                                lapack_complex_double* a, lapack_int lda, lapack_complex_double* af, lapack_int ldaf,
-                                lapack_int* ipiv, char* equed, double* s, lapack_complex_double* b, lapack_int ldb,
-                                lapack_complex_double* x, lapack_int ldx, double* rcond, double* rpvgrw, double* berr,
-                                lapack_int n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int nparams,
-                                double* params, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_ssytrd_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, float* d, float* e,
-                               float* tau, float* work, lapack_int lwork);
-lapack_int LAPACKE_dsytrd_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, double* d,
-                               double* e, double* tau, double* work, lapack_int lwork);
-
-lapack_int LAPACKE_ssytrf_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, lapack_int* ipiv,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dsytrf_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda, lapack_int* ipiv,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_csytrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_int* ipiv, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zsytrf_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_int* ipiv, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_ssytri_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda,
-                               const lapack_int* ipiv, float* work);
-lapack_int LAPACKE_dsytri_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda,
-                               const lapack_int* ipiv, double* work);
-lapack_int LAPACKE_csytri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               const lapack_int* ipiv, lapack_complex_float* work);
-lapack_int LAPACKE_zsytri_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               const lapack_int* ipiv, lapack_complex_double* work);
-
-lapack_int LAPACKE_ssytrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                               lapack_int lda, const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_dsytrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                               lapack_int lda, const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_csytrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_int* ipiv,
-                               lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_zsytrs_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_int* ipiv,
-                               lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stbcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                               const float* ab, lapack_int ldab, float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dtbcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                               const double* ab, lapack_int ldab, double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_ctbcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                               const lapack_complex_float* ab, lapack_int ldab, float* rcond,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztbcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, lapack_int kd,
-                               const lapack_complex_double* ab, lapack_int ldab, double* rcond,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_stbrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const float* ab, lapack_int ldab, const float* b, lapack_int ldb,
-                               const float* x, lapack_int ldx, float* ferr, float* berr, float* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dtbrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const double* ab, lapack_int ldab, const double* b, lapack_int ldb,
-                               const double* x, lapack_int ldx, double* ferr, double* berr, double* work,
-                               lapack_int* iwork);
-lapack_int LAPACKE_ctbrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab,
-                               const lapack_complex_float* b, lapack_int ldb, const lapack_complex_float* x,
-                               lapack_int ldx, float* ferr, float* berr, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztbrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                               const lapack_complex_double* b, lapack_int ldb, const lapack_complex_double* x,
-                               lapack_int ldx, double* ferr, double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_stbtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const float* ab, lapack_int ldab, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtbtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const double* ab, lapack_int ldab, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctbtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const lapack_complex_float* ab, lapack_int ldab,
-                               lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztbtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int kd,
-                               lapack_int nrhs, const lapack_complex_double* ab, lapack_int ldab,
-                               lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stfsm_work(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                              lapack_int n, float alpha, const float* a, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtfsm_work(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                              lapack_int n, double alpha, const double* a, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctfsm_work(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                              lapack_int n, lapack_complex_float alpha, const lapack_complex_float* a,
-                              lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztfsm_work(int matrix_order, char transr, char side, char uplo, char trans, char diag, lapack_int m,
-                              lapack_int n, lapack_complex_double alpha, const lapack_complex_double* a,
-                              lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stftri_work(int matrix_order, char transr, char uplo, char diag, lapack_int n, float* a);
-lapack_int LAPACKE_dtftri_work(int matrix_order, char transr, char uplo, char diag, lapack_int n, double* a);
-lapack_int LAPACKE_ctftri_work(int matrix_order, char transr, char uplo, char diag, lapack_int n,
-                               lapack_complex_float* a);
-lapack_int LAPACKE_ztftri_work(int matrix_order, char transr, char uplo, char diag, lapack_int n,
-                               lapack_complex_double* a);
-
-lapack_int LAPACKE_stfttp_work(int matrix_order, char transr, char uplo, lapack_int n, const float* arf, float* ap);
-lapack_int LAPACKE_dtfttp_work(int matrix_order, char transr, char uplo, lapack_int n, const double* arf, double* ap);
-lapack_int LAPACKE_ctfttp_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* arf,
-                               lapack_complex_float* ap);
-lapack_int LAPACKE_ztfttp_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* arf,
-                               lapack_complex_double* ap);
-
-lapack_int LAPACKE_stfttr_work(int matrix_order, char transr, char uplo, lapack_int n, const float* arf, float* a,
-                               lapack_int lda);
-lapack_int LAPACKE_dtfttr_work(int matrix_order, char transr, char uplo, lapack_int n, const double* arf, double* a,
-                               lapack_int lda);
-lapack_int LAPACKE_ctfttr_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* arf,
-                               lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_ztfttr_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* arf,
-                               lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_stgevc_work(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                               const float* s, lapack_int lds, const float* p, lapack_int ldp, float* vl,
-                               lapack_int ldvl, float* vr, lapack_int ldvr, lapack_int mm, lapack_int* m, float* work);
-lapack_int LAPACKE_dtgevc_work(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                               const double* s, lapack_int lds, const double* p, lapack_int ldp, double* vl,
-                               lapack_int ldvl, double* vr, lapack_int ldvr, lapack_int mm, lapack_int* m,
-                               double* work);
-lapack_int LAPACKE_ctgevc_work(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                               const lapack_complex_float* s, lapack_int lds, const lapack_complex_float* p,
-                               lapack_int ldp, lapack_complex_float* vl, lapack_int ldvl, lapack_complex_float* vr,
-                               lapack_int ldvr, lapack_int mm, lapack_int* m, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztgevc_work(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                               const lapack_complex_double* s, lapack_int lds, const lapack_complex_double* p,
-                               lapack_int ldp, lapack_complex_double* vl, lapack_int ldvl, lapack_complex_double* vr,
-                               lapack_int ldvr, lapack_int mm, lapack_int* m, lapack_complex_double* work,
-                               double* rwork);
-
-lapack_int LAPACKE_stgexc_work(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n, float* a,
-                               lapack_int lda, float* b, lapack_int ldb, float* q, lapack_int ldq, float* z,
-                               lapack_int ldz, lapack_int* ifst, lapack_int* ilst, float* work, lapack_int lwork);
-lapack_int LAPACKE_dtgexc_work(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n, double* a,
-                               lapack_int lda, double* b, lapack_int ldb, double* q, lapack_int ldq, double* z,
-                               lapack_int ldz, lapack_int* ifst, lapack_int* ilst, double* work, lapack_int lwork);
-lapack_int LAPACKE_ctgexc_work(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb,
-                               lapack_complex_float* q, lapack_int ldq, lapack_complex_float* z, lapack_int ldz,
-                               lapack_int ifst, lapack_int ilst);
-lapack_int LAPACKE_ztgexc_work(int matrix_order, lapack_logical wantq, lapack_logical wantz, lapack_int n,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* q, lapack_int ldq, lapack_complex_double* z, lapack_int ldz,
-                               lapack_int ifst, lapack_int ilst);
-
-lapack_int LAPACKE_stgsen_work(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                               const lapack_logical* select, lapack_int n, float* a, lapack_int lda, float* b,
-                               lapack_int ldb, float* alphar, float* alphai, float* beta, float* q, lapack_int ldq,
-                               float* z, lapack_int ldz, lapack_int* m, float* pl, float* pr, float* dif, float* work,
-                               lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_dtgsen_work(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                               const lapack_logical* select, lapack_int n, double* a, lapack_int lda, double* b,
-                               lapack_int ldb, double* alphar, double* alphai, double* beta, double* q, lapack_int ldq,
-                               double* z, lapack_int ldz, lapack_int* m, double* pl, double* pr, double* dif,
-                               double* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_ctgsen_work(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                               const lapack_logical* select, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* b, lapack_int ldb, lapack_complex_float* alpha,
-                               lapack_complex_float* beta, lapack_complex_float* q, lapack_int ldq,
-                               lapack_complex_float* z, lapack_int ldz, lapack_int* m, float* pl, float* pr, float* dif,
-                               lapack_complex_float* work, lapack_int lwork, lapack_int* iwork, lapack_int liwork);
-lapack_int LAPACKE_ztgsen_work(int matrix_order, lapack_int ijob, lapack_logical wantq, lapack_logical wantz,
-                               const lapack_logical* select, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* b, lapack_int ldb, lapack_complex_double* alpha,
-                               lapack_complex_double* beta, lapack_complex_double* q, lapack_int ldq,
-                               lapack_complex_double* z, lapack_int ldz, lapack_int* m, double* pl, double* pr,
-                               double* dif, lapack_complex_double* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_int liwork);
-
-lapack_int LAPACKE_stgsja_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, lapack_int k, lapack_int l, float* a, lapack_int lda, float* b,
-                               lapack_int ldb, float tola, float tolb, float* alpha, float* beta, float* u,
-                               lapack_int ldu, float* v, lapack_int ldv, float* q, lapack_int ldq, float* work,
-                               lapack_int* ncycle);
-lapack_int LAPACKE_dtgsja_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, lapack_int k, lapack_int l, double* a, lapack_int lda, double* b,
-                               lapack_int ldb, double tola, double tolb, double* alpha, double* beta, double* u,
-                               lapack_int ldu, double* v, lapack_int ldv, double* q, lapack_int ldq, double* work,
-                               lapack_int* ncycle);
-lapack_int LAPACKE_ctgsja_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, lapack_int k, lapack_int l, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* b, lapack_int ldb, float tola, float tolb, float* alpha,
-                               float* beta, lapack_complex_float* u, lapack_int ldu, lapack_complex_float* v,
-                               lapack_int ldv, lapack_complex_float* q, lapack_int ldq, lapack_complex_float* work,
-                               lapack_int* ncycle);
-lapack_int LAPACKE_ztgsja_work(int matrix_order, char jobu, char jobv, char jobq, lapack_int m, lapack_int p,
-                               lapack_int n, lapack_int k, lapack_int l, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* b, lapack_int ldb, double tola, double tolb, double* alpha,
-                               double* beta, lapack_complex_double* u, lapack_int ldu, lapack_complex_double* v,
-                               lapack_int ldv, lapack_complex_double* q, lapack_int ldq, lapack_complex_double* work,
-                               lapack_int* ncycle);
-
-lapack_int LAPACKE_stgsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const float* a, lapack_int lda, const float* b, lapack_int ldb, const float* vl,
-                               lapack_int ldvl, const float* vr, lapack_int ldvr, float* s, float* dif, lapack_int mm,
-                               lapack_int* m, float* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dtgsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const double* a, lapack_int lda, const double* b, lapack_int ldb, const double* vl,
-                               lapack_int ldvl, const double* vr, lapack_int ldvr, double* s, double* dif,
-                               lapack_int mm, lapack_int* m, double* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_ctgsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b,
-                               lapack_int ldb, const lapack_complex_float* vl, lapack_int ldvl,
-                               const lapack_complex_float* vr, lapack_int ldvr, float* s, float* dif, lapack_int mm,
-                               lapack_int* m, lapack_complex_float* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_ztgsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                               lapack_int ldb, const lapack_complex_double* vl, lapack_int ldvl,
-                               const lapack_complex_double* vr, lapack_int ldvr, double* s, double* dif, lapack_int mm,
-                               lapack_int* m, lapack_complex_double* work, lapack_int lwork, lapack_int* iwork);
-
-lapack_int LAPACKE_stgsyl_work(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n,
-                               const float* a, lapack_int lda, const float* b, lapack_int ldb, float* c, lapack_int ldc,
-                               const float* d, lapack_int ldd, const float* e, lapack_int lde, float* f, lapack_int ldf,
-                               float* scale, float* dif, float* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dtgsyl_work(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n,
-                               const double* a, lapack_int lda, const double* b, lapack_int ldb, double* c,
-                               lapack_int ldc, const double* d, lapack_int ldd, const double* e, lapack_int lde,
-                               double* f, lapack_int ldf, double* scale, double* dif, double* work, lapack_int lwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_ctgsyl_work(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b,
-                               lapack_int ldb, lapack_complex_float* c, lapack_int ldc, const lapack_complex_float* d,
-                               lapack_int ldd, const lapack_complex_float* e, lapack_int lde, lapack_complex_float* f,
-                               lapack_int ldf, float* scale, float* dif, lapack_complex_float* work, lapack_int lwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_ztgsyl_work(int matrix_order, char trans, lapack_int ijob, lapack_int m, lapack_int n,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                               lapack_int ldb, lapack_complex_double* c, lapack_int ldc, const lapack_complex_double* d,
-                               lapack_int ldd, const lapack_complex_double* e, lapack_int lde, lapack_complex_double* f,
-                               lapack_int ldf, double* scale, double* dif, lapack_complex_double* work,
-                               lapack_int lwork, lapack_int* iwork);
-
-lapack_int LAPACKE_stpcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, const float* ap,
-                               float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dtpcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, const double* ap,
-                               double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_ctpcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                               const lapack_complex_float* ap, float* rcond, lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztpcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                               const lapack_complex_double* ap, double* rcond, lapack_complex_double* work,
-                               double* rwork);
-
-lapack_int LAPACKE_stprfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const float* ap, const float* b, lapack_int ldb, const float* x, lapack_int ldx,
-                               float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dtprfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const double* ap, const double* b, lapack_int ldb, const double* x, lapack_int ldx,
-                               double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_ctprfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, const lapack_complex_float* b, lapack_int ldb,
-                               const lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztprfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, const lapack_complex_double* b, lapack_int ldb,
-                               const lapack_complex_double* x, lapack_int ldx, double* ferr, double* berr,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_stptri_work(int matrix_order, char uplo, char diag, lapack_int n, float* ap);
-lapack_int LAPACKE_dtptri_work(int matrix_order, char uplo, char diag, lapack_int n, double* ap);
-lapack_int LAPACKE_ctptri_work(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_float* ap);
-lapack_int LAPACKE_ztptri_work(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_double* ap);
-
-lapack_int LAPACKE_stptrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const float* ap, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtptrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const double* ap, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctptrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* ap, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztptrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* ap, lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_stpttf_work(int matrix_order, char transr, char uplo, lapack_int n, const float* ap, float* arf);
-lapack_int LAPACKE_dtpttf_work(int matrix_order, char transr, char uplo, lapack_int n, const double* ap, double* arf);
-lapack_int LAPACKE_ctpttf_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* ap,
-                               lapack_complex_float* arf);
-lapack_int LAPACKE_ztpttf_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* ap,
-                               lapack_complex_double* arf);
-
-lapack_int LAPACKE_stpttr_work(int matrix_order, char uplo, lapack_int n, const float* ap, float* a, lapack_int lda);
-lapack_int LAPACKE_dtpttr_work(int matrix_order, char uplo, lapack_int n, const double* ap, double* a, lapack_int lda);
-lapack_int LAPACKE_ctpttr_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                               lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_ztpttr_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                               lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_strcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, const float* a,
-                               lapack_int lda, float* rcond, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dtrcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n, const double* a,
-                               lapack_int lda, double* rcond, double* work, lapack_int* iwork);
-lapack_int LAPACKE_ctrcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                               const lapack_complex_float* a, lapack_int lda, float* rcond, lapack_complex_float* work,
-                               float* rwork);
-lapack_int LAPACKE_ztrcon_work(int matrix_order, char norm, char uplo, char diag, lapack_int n,
-                               const lapack_complex_double* a, lapack_int lda, double* rcond,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_strevc_work(int matrix_order, char side, char howmny, lapack_logical* select, lapack_int n,
-                               const float* t, lapack_int ldt, float* vl, lapack_int ldvl, float* vr, lapack_int ldvr,
-                               lapack_int mm, lapack_int* m, float* work);
-lapack_int LAPACKE_dtrevc_work(int matrix_order, char side, char howmny, lapack_logical* select, lapack_int n,
-                               const double* t, lapack_int ldt, double* vl, lapack_int ldvl, double* vr,
-                               lapack_int ldvr, lapack_int mm, lapack_int* m, double* work);
-lapack_int LAPACKE_ctrevc_work(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                               lapack_complex_float* t, lapack_int ldt, lapack_complex_float* vl, lapack_int ldvl,
-                               lapack_complex_float* vr, lapack_int ldvr, lapack_int mm, lapack_int* m,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztrevc_work(int matrix_order, char side, char howmny, const lapack_logical* select, lapack_int n,
-                               lapack_complex_double* t, lapack_int ldt, lapack_complex_double* vl, lapack_int ldvl,
-                               lapack_complex_double* vr, lapack_int ldvr, lapack_int mm, lapack_int* m,
-                               lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_strexc_work(int matrix_order, char compq, lapack_int n, float* t, lapack_int ldt, float* q,
-                               lapack_int ldq, lapack_int* ifst, lapack_int* ilst, float* work);
-lapack_int LAPACKE_dtrexc_work(int matrix_order, char compq, lapack_int n, double* t, lapack_int ldt, double* q,
-                               lapack_int ldq, lapack_int* ifst, lapack_int* ilst, double* work);
-lapack_int LAPACKE_ctrexc_work(int matrix_order, char compq, lapack_int n, lapack_complex_float* t, lapack_int ldt,
-                               lapack_complex_float* q, lapack_int ldq, lapack_int ifst, lapack_int ilst);
-lapack_int LAPACKE_ztrexc_work(int matrix_order, char compq, lapack_int n, lapack_complex_double* t, lapack_int ldt,
-                               lapack_complex_double* q, lapack_int ldq, lapack_int ifst, lapack_int ilst);
-
-lapack_int LAPACKE_strrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const float* a, lapack_int lda, const float* b, lapack_int ldb, const float* x,
-                               lapack_int ldx, float* ferr, float* berr, float* work, lapack_int* iwork);
-lapack_int LAPACKE_dtrrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const double* a, lapack_int lda, const double* b, lapack_int ldb, const double* x,
-                               lapack_int ldx, double* ferr, double* berr, double* work, lapack_int* iwork);
-lapack_int LAPACKE_ctrrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b,
-                               lapack_int ldb, const lapack_complex_float* x, lapack_int ldx, float* ferr, float* berr,
-                               lapack_complex_float* work, float* rwork);
-lapack_int LAPACKE_ztrrfs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                               lapack_int ldb, const lapack_complex_double* x, lapack_int ldx, double* ferr,
-                               double* berr, lapack_complex_double* work, double* rwork);
-
-lapack_int LAPACKE_strsen_work(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n,
-                               float* t, lapack_int ldt, float* q, lapack_int ldq, float* wr, float* wi, lapack_int* m,
-                               float* s, float* sep, float* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_int liwork);
-lapack_int LAPACKE_dtrsen_work(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n,
-                               double* t, lapack_int ldt, double* q, lapack_int ldq, double* wr, double* wi,
-                               lapack_int* m, double* s, double* sep, double* work, lapack_int lwork, lapack_int* iwork,
-                               lapack_int liwork);
-lapack_int LAPACKE_ctrsen_work(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n,
-                               lapack_complex_float* t, lapack_int ldt, lapack_complex_float* q, lapack_int ldq,
-                               lapack_complex_float* w, lapack_int* m, float* s, float* sep, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_ztrsen_work(int matrix_order, char job, char compq, const lapack_logical* select, lapack_int n,
-                               lapack_complex_double* t, lapack_int ldt, lapack_complex_double* q, lapack_int ldq,
-                               lapack_complex_double* w, lapack_int* m, double* s, double* sep,
-                               lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_strsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const float* t, lapack_int ldt, const float* vl, lapack_int ldvl, const float* vr,
-                               lapack_int ldvr, float* s, float* sep, lapack_int mm, lapack_int* m, float* work,
-                               lapack_int ldwork, lapack_int* iwork);
-lapack_int LAPACKE_dtrsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const double* t, lapack_int ldt, const double* vl, lapack_int ldvl, const double* vr,
-                               lapack_int ldvr, double* s, double* sep, lapack_int mm, lapack_int* m, double* work,
-                               lapack_int ldwork, lapack_int* iwork);
-lapack_int LAPACKE_ctrsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const lapack_complex_float* t, lapack_int ldt, const lapack_complex_float* vl,
-                               lapack_int ldvl, const lapack_complex_float* vr, lapack_int ldvr, float* s, float* sep,
-                               lapack_int mm, lapack_int* m, lapack_complex_float* work, lapack_int ldwork,
-                               float* rwork);
-lapack_int LAPACKE_ztrsna_work(int matrix_order, char job, char howmny, const lapack_logical* select, lapack_int n,
-                               const lapack_complex_double* t, lapack_int ldt, const lapack_complex_double* vl,
-                               lapack_int ldvl, const lapack_complex_double* vr, lapack_int ldvr, double* s,
-                               double* sep, lapack_int mm, lapack_int* m, lapack_complex_double* work,
-                               lapack_int ldwork, double* rwork);
-
-lapack_int LAPACKE_strsyl_work(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                               const float* a, lapack_int lda, const float* b, lapack_int ldb, float* c, lapack_int ldc,
-                               float* scale);
-lapack_int LAPACKE_dtrsyl_work(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                               const double* a, lapack_int lda, const double* b, lapack_int ldb, double* c,
-                               lapack_int ldc, double* scale);
-lapack_int LAPACKE_ctrsyl_work(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* b,
-                               lapack_int ldb, lapack_complex_float* c, lapack_int ldc, float* scale);
-lapack_int LAPACKE_ztrsyl_work(int matrix_order, char trana, char tranb, lapack_int isgn, lapack_int m, lapack_int n,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* b,
-                               lapack_int ldb, lapack_complex_double* c, lapack_int ldc, double* scale);
-
-lapack_int LAPACKE_strtri_work(int matrix_order, char uplo, char diag, lapack_int n, float* a, lapack_int lda);
-lapack_int LAPACKE_dtrtri_work(int matrix_order, char uplo, char diag, lapack_int n, double* a, lapack_int lda);
-lapack_int LAPACKE_ctrtri_work(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_float* a,
-                               lapack_int lda);
-lapack_int LAPACKE_ztrtri_work(int matrix_order, char uplo, char diag, lapack_int n, lapack_complex_double* a,
-                               lapack_int lda);
-
-lapack_int LAPACKE_strtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const float* a, lapack_int lda, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtrtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const double* a, lapack_int lda, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctrtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_float* a, lapack_int lda, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztrtrs_work(int matrix_order, char uplo, char trans, char diag, lapack_int n, lapack_int nrhs,
-                               const lapack_complex_double* a, lapack_int lda, lapack_complex_double* b,
-                               lapack_int ldb);
-
-lapack_int LAPACKE_strttf_work(int matrix_order, char transr, char uplo, lapack_int n, const float* a, lapack_int lda,
-                               float* arf);
-lapack_int LAPACKE_dtrttf_work(int matrix_order, char transr, char uplo, lapack_int n, const double* a, lapack_int lda,
-                               double* arf);
-lapack_int LAPACKE_ctrttf_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* arf);
-lapack_int LAPACKE_ztrttf_work(int matrix_order, char transr, char uplo, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* arf);
-
-lapack_int LAPACKE_strttp_work(int matrix_order, char uplo, lapack_int n, const float* a, lapack_int lda, float* ap);
-lapack_int LAPACKE_dtrttp_work(int matrix_order, char uplo, lapack_int n, const double* a, lapack_int lda, double* ap);
-lapack_int LAPACKE_ctrttp_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* ap);
-lapack_int LAPACKE_ztrttp_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* ap);
-
-lapack_int LAPACKE_stzrzf_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* tau,
-                               float* work, lapack_int lwork);
-lapack_int LAPACKE_dtzrzf_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* tau,
-                               double* work, lapack_int lwork);
-lapack_int LAPACKE_ctzrzf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_ztzrzf_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cungbr_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k,
-                               lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                               lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zungbr_work(int matrix_order, char vect, lapack_int m, lapack_int n, lapack_int k,
-                               lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                               lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunghr_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_float* a,
-                               lapack_int lda, const lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zunghr_work(int matrix_order, lapack_int n, lapack_int ilo, lapack_int ihi, lapack_complex_double* a,
-                               lapack_int lda, const lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_cunglq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                               lapack_int lda, const lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zunglq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                               lapack_int lda, const lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_cungql_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                               lapack_int lda, const lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zungql_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                               lapack_int lda, const lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_cungqr_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                               lapack_int lda, const lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zungqr_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                               lapack_int lda, const lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_cungrq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_float* a,
-                               lapack_int lda, const lapack_complex_float* tau, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_zungrq_work(int matrix_order, lapack_int m, lapack_int n, lapack_int k, lapack_complex_double* a,
-                               lapack_int lda, const lapack_complex_double* tau, lapack_complex_double* work,
-                               lapack_int lwork);
-
-lapack_int LAPACKE_cungtr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                               const lapack_complex_float* tau, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zungtr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                               const lapack_complex_double* tau, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmbr_work(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n,
-                               lapack_int k, const lapack_complex_float* a, lapack_int lda,
-                               const lapack_complex_float* tau, lapack_complex_float* c, lapack_int ldc,
-                               lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmbr_work(int matrix_order, char vect, char side, char trans, lapack_int m, lapack_int n,
-                               lapack_int k, const lapack_complex_double* a, lapack_int lda,
-                               const lapack_complex_double* tau, lapack_complex_double* c, lapack_int ldc,
-                               lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmhr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, const lapack_complex_float* a, lapack_int lda,
-                               const lapack_complex_float* tau, lapack_complex_float* c, lapack_int ldc,
-                               lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmhr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int ilo,
-                               lapack_int ihi, const lapack_complex_double* a, lapack_int lda,
-                               const lapack_complex_double* tau, lapack_complex_double* c, lapack_int ldc,
-                               lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmlq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                               lapack_complex_float* c, lapack_int ldc, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmlq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmql_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                               lapack_complex_float* c, lapack_int ldc, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmql_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmqr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                               lapack_complex_float* c, lapack_int ldc, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmqr_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmrq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                               lapack_complex_float* c, lapack_int ldc, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmrq_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmrz_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               lapack_int l, const lapack_complex_float* a, lapack_int lda,
-                               const lapack_complex_float* tau, lapack_complex_float* c, lapack_int ldc,
-                               lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmrz_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                               lapack_int l, const lapack_complex_double* a, lapack_int lda,
-                               const lapack_complex_double* tau, lapack_complex_double* c, lapack_int ldc,
-                               lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cunmtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const lapack_complex_float* a, lapack_int lda, const lapack_complex_float* tau,
-                               lapack_complex_float* c, lapack_int ldc, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_zunmtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const lapack_complex_double* a, lapack_int lda, const lapack_complex_double* tau,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work, lapack_int lwork);
-
-lapack_int LAPACKE_cupgtr_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_float* ap,
-                               const lapack_complex_float* tau, lapack_complex_float* q, lapack_int ldq,
-                               lapack_complex_float* work);
-lapack_int LAPACKE_zupgtr_work(int matrix_order, char uplo, lapack_int n, const lapack_complex_double* ap,
-                               const lapack_complex_double* tau, lapack_complex_double* q, lapack_int ldq,
-                               lapack_complex_double* work);
-
-lapack_int LAPACKE_cupmtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const lapack_complex_float* ap, const lapack_complex_float* tau, lapack_complex_float* c,
-                               lapack_int ldc, lapack_complex_float* work);
-lapack_int LAPACKE_zupmtr_work(int matrix_order, char side, char uplo, char trans, lapack_int m, lapack_int n,
-                               const lapack_complex_double* ap, const lapack_complex_double* tau,
-                               lapack_complex_double* c, lapack_int ldc, lapack_complex_double* work);
-
-lapack_int LAPACKE_claghe(int matrix_order, lapack_int n, lapack_int k, const float* d, lapack_complex_float* a,
-                          lapack_int lda, lapack_int* iseed);
-lapack_int LAPACKE_zlaghe(int matrix_order, lapack_int n, lapack_int k, const double* d, lapack_complex_double* a,
-                          lapack_int lda, lapack_int* iseed);
-
-lapack_int LAPACKE_slagsy(int matrix_order, lapack_int n, lapack_int k, const float* d, float* a, lapack_int lda,
-                          lapack_int* iseed);
-lapack_int LAPACKE_dlagsy(int matrix_order, lapack_int n, lapack_int k, const double* d, double* a, lapack_int lda,
-                          lapack_int* iseed);
-lapack_int LAPACKE_clagsy(int matrix_order, lapack_int n, lapack_int k, const float* d, lapack_complex_float* a,
-                          lapack_int lda, lapack_int* iseed);
-lapack_int LAPACKE_zlagsy(int matrix_order, lapack_int n, lapack_int k, const double* d, lapack_complex_double* a,
-                          lapack_int lda, lapack_int* iseed);
-
-lapack_int LAPACKE_slapmr(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n, float* x, lapack_int ldx,
-                          lapack_int* k);
-lapack_int LAPACKE_dlapmr(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n, double* x,
-                          lapack_int ldx, lapack_int* k);
-lapack_int LAPACKE_clapmr(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n, lapack_complex_float* x,
-                          lapack_int ldx, lapack_int* k);
-lapack_int LAPACKE_zlapmr(int matrix_order, lapack_logical forwrd, lapack_int m, lapack_int n, lapack_complex_double* x,
-                          lapack_int ldx, lapack_int* k);
-
-float LAPACKE_slapy2(float x, float y);
-double LAPACKE_dlapy2(double x, double y);
-
-float LAPACKE_slapy3(float x, float y, float z);
-double LAPACKE_dlapy3(double x, double y, double z);
-
-lapack_int LAPACKE_slartgp(float f, float g, float* cs, float* sn, float* r);
-lapack_int LAPACKE_dlartgp(double f, double g, double* cs, double* sn, double* r);
-
-lapack_int LAPACKE_slartgs(float x, float y, float sigma, float* cs, float* sn);
-lapack_int LAPACKE_dlartgs(double x, double y, double sigma, double* cs, double* sn);
-
-// LAPACK 3.3.0
-lapack_int LAPACKE_cbbcsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, lapack_int m,
-                          lapack_int p, lapack_int q, float* theta, float* phi, lapack_complex_float* u1,
-                          lapack_int ldu1, lapack_complex_float* u2, lapack_int ldu2, lapack_complex_float* v1t,
-                          lapack_int ldv1t, lapack_complex_float* v2t, lapack_int ldv2t, float* b11d, float* b11e,
-                          float* b12d, float* b12e, float* b21d, float* b21e, float* b22d, float* b22e);
-lapack_int LAPACKE_cbbcsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               lapack_int m, lapack_int p, lapack_int q, float* theta, float* phi,
-                               lapack_complex_float* u1, lapack_int ldu1, lapack_complex_float* u2, lapack_int ldu2,
-                               lapack_complex_float* v1t, lapack_int ldv1t, lapack_complex_float* v2t, lapack_int ldv2t,
-                               float* b11d, float* b11e, float* b12d, float* b12e, float* b21d, float* b21e,
-                               float* b22d, float* b22e, float* rwork, lapack_int lrwork);
-lapack_int LAPACKE_cheswapr(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int i1,
-                            lapack_int i2);
-lapack_int LAPACKE_cheswapr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int i1,
-                                 lapack_int i2);
-lapack_int LAPACKE_chetri2(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_chetri2_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                const lapack_int* ipiv, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_chetri2x(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                            const lapack_int* ipiv, lapack_int nb);
-lapack_int LAPACKE_chetri2x_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                 const lapack_int* ipiv, lapack_complex_float* work, lapack_int nb);
-lapack_int LAPACKE_chetrs2(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                           lapack_int lda, const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_chetrs2_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_float* a, lapack_int lda, const lapack_int* ipiv,
-                                lapack_complex_float* b, lapack_int ldb, lapack_complex_float* work);
-lapack_int LAPACKE_csyconv(int matrix_order, char uplo, char way, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_csyconv_work(int matrix_order, char uplo, char way, lapack_int n, lapack_complex_float* a,
-                                lapack_int lda, const lapack_int* ipiv, lapack_complex_float* work);
-lapack_int LAPACKE_csyswapr(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int i1,
-                            lapack_int i2);
-lapack_int LAPACKE_csyswapr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int i1,
-                                 lapack_int i2);
-lapack_int LAPACKE_csytri2(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_csytri2_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                const lapack_int* ipiv, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_csytri2x(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                            const lapack_int* ipiv, lapack_int nb);
-lapack_int LAPACKE_csytri2x_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                 const lapack_int* ipiv, lapack_complex_float* work, lapack_int nb);
-lapack_int LAPACKE_csytrs2(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_float* a,
-                           lapack_int lda, const lapack_int* ipiv, lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_csytrs2_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_float* a, lapack_int lda, const lapack_int* ipiv,
-                                lapack_complex_float* b, lapack_int ldb, lapack_complex_float* work);
-lapack_int LAPACKE_cunbdb(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                          lapack_complex_float* x11, lapack_int ldx11, lapack_complex_float* x12, lapack_int ldx12,
-                          lapack_complex_float* x21, lapack_int ldx21, lapack_complex_float* x22, lapack_int ldx22,
-                          float* theta, float* phi, lapack_complex_float* taup1, lapack_complex_float* taup2,
-                          lapack_complex_float* tauq1, lapack_complex_float* tauq2);
-lapack_int LAPACKE_cunbdb_work(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                               lapack_complex_float* x11, lapack_int ldx11, lapack_complex_float* x12, lapack_int ldx12,
-                               lapack_complex_float* x21, lapack_int ldx21, lapack_complex_float* x22, lapack_int ldx22,
-                               float* theta, float* phi, lapack_complex_float* taup1, lapack_complex_float* taup2,
-                               lapack_complex_float* tauq1, lapack_complex_float* tauq2, lapack_complex_float* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_cuncsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, char signs,
-                          lapack_int m, lapack_int p, lapack_int q, lapack_complex_float* x11, lapack_int ldx11,
-                          lapack_complex_float* x12, lapack_int ldx12, lapack_complex_float* x21, lapack_int ldx21,
-                          lapack_complex_float* x22, lapack_int ldx22, float* theta, lapack_complex_float* u1,
-                          lapack_int ldu1, lapack_complex_float* u2, lapack_int ldu2, lapack_complex_float* v1t,
-                          lapack_int ldv1t, lapack_complex_float* v2t, lapack_int ldv2t);
-lapack_int LAPACKE_cuncsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               char signs, lapack_int m, lapack_int p, lapack_int q, lapack_complex_float* x11,
-                               lapack_int ldx11, lapack_complex_float* x12, lapack_int ldx12, lapack_complex_float* x21,
-                               lapack_int ldx21, lapack_complex_float* x22, lapack_int ldx22, float* theta,
-                               lapack_complex_float* u1, lapack_int ldu1, lapack_complex_float* u2, lapack_int ldu2,
-                               lapack_complex_float* v1t, lapack_int ldv1t, lapack_complex_float* v2t, lapack_int ldv2t,
-                               lapack_complex_float* work, lapack_int lwork, float* rwork, lapack_int lrwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_dbbcsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, lapack_int m,
-                          lapack_int p, lapack_int q, double* theta, double* phi, double* u1, lapack_int ldu1,
-                          double* u2, lapack_int ldu2, double* v1t, lapack_int ldv1t, double* v2t, lapack_int ldv2t,
-                          double* b11d, double* b11e, double* b12d, double* b12e, double* b21d, double* b21e,
-                          double* b22d, double* b22e);
-lapack_int LAPACKE_dbbcsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               lapack_int m, lapack_int p, lapack_int q, double* theta, double* phi, double* u1,
-                               lapack_int ldu1, double* u2, lapack_int ldu2, double* v1t, lapack_int ldv1t, double* v2t,
-                               lapack_int ldv2t, double* b11d, double* b11e, double* b12d, double* b12e, double* b21d,
-                               double* b21e, double* b22d, double* b22e, double* work, lapack_int lwork);
-lapack_int LAPACKE_dorbdb(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                          double* x11, lapack_int ldx11, double* x12, lapack_int ldx12, double* x21, lapack_int ldx21,
-                          double* x22, lapack_int ldx22, double* theta, double* phi, double* taup1, double* taup2,
-                          double* tauq1, double* tauq2);
-lapack_int LAPACKE_dorbdb_work(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                               double* x11, lapack_int ldx11, double* x12, lapack_int ldx12, double* x21,
-                               lapack_int ldx21, double* x22, lapack_int ldx22, double* theta, double* phi,
-                               double* taup1, double* taup2, double* tauq1, double* tauq2, double* work,
-                               lapack_int lwork);
-lapack_int LAPACKE_dorcsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, char signs,
-                          lapack_int m, lapack_int p, lapack_int q, double* x11, lapack_int ldx11, double* x12,
-                          lapack_int ldx12, double* x21, lapack_int ldx21, double* x22, lapack_int ldx22, double* theta,
-                          double* u1, lapack_int ldu1, double* u2, lapack_int ldu2, double* v1t, lapack_int ldv1t,
-                          double* v2t, lapack_int ldv2t);
-lapack_int LAPACKE_dorcsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               char signs, lapack_int m, lapack_int p, lapack_int q, double* x11, lapack_int ldx11,
-                               double* x12, lapack_int ldx12, double* x21, lapack_int ldx21, double* x22,
-                               lapack_int ldx22, double* theta, double* u1, lapack_int ldu1, double* u2,
-                               lapack_int ldu2, double* v1t, lapack_int ldv1t, double* v2t, lapack_int ldv2t,
-                               double* work, lapack_int lwork, lapack_int* iwork);
-lapack_int LAPACKE_dsyconv(int matrix_order, char uplo, char way, lapack_int n, double* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_dsyconv_work(int matrix_order, char uplo, char way, lapack_int n, double* a, lapack_int lda,
-                                const lapack_int* ipiv, double* work);
-lapack_int LAPACKE_dsyswapr(int matrix_order, char uplo, lapack_int n, double* a, lapack_int i1, lapack_int i2);
-lapack_int LAPACKE_dsyswapr_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int i1, lapack_int i2);
-lapack_int LAPACKE_dsytri2(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_dsytri2_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda,
-                                const lapack_int* ipiv, lapack_complex_double* work, lapack_int lwork);
-lapack_int LAPACKE_dsytri2x(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda,
-                            const lapack_int* ipiv, lapack_int nb);
-lapack_int LAPACKE_dsytri2x_work(int matrix_order, char uplo, lapack_int n, double* a, lapack_int lda,
-                                 const lapack_int* ipiv, double* work, lapack_int nb);
-lapack_int LAPACKE_dsytrs2(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a, lapack_int lda,
-                           const lapack_int* ipiv, double* b, lapack_int ldb);
-lapack_int LAPACKE_dsytrs2_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const double* a,
-                                lapack_int lda, const lapack_int* ipiv, double* b, lapack_int ldb, double* work);
-lapack_int LAPACKE_sbbcsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, lapack_int m,
-                          lapack_int p, lapack_int q, float* theta, float* phi, float* u1, lapack_int ldu1, float* u2,
-                          lapack_int ldu2, float* v1t, lapack_int ldv1t, float* v2t, lapack_int ldv2t, float* b11d,
-                          float* b11e, float* b12d, float* b12e, float* b21d, float* b21e, float* b22d, float* b22e);
-lapack_int LAPACKE_sbbcsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               lapack_int m, lapack_int p, lapack_int q, float* theta, float* phi, float* u1,
-                               lapack_int ldu1, float* u2, lapack_int ldu2, float* v1t, lapack_int ldv1t, float* v2t,
-                               lapack_int ldv2t, float* b11d, float* b11e, float* b12d, float* b12e, float* b21d,
-                               float* b21e, float* b22d, float* b22e, float* work, lapack_int lwork);
-lapack_int LAPACKE_sorbdb(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                          float* x11, lapack_int ldx11, float* x12, lapack_int ldx12, float* x21, lapack_int ldx21,
-                          float* x22, lapack_int ldx22, float* theta, float* phi, float* taup1, float* taup2,
-                          float* tauq1, float* tauq2);
-lapack_int LAPACKE_sorbdb_work(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                               float* x11, lapack_int ldx11, float* x12, lapack_int ldx12, float* x21, lapack_int ldx21,
-                               float* x22, lapack_int ldx22, float* theta, float* phi, float* taup1, float* taup2,
-                               float* tauq1, float* tauq2, float* work, lapack_int lwork);
-lapack_int LAPACKE_sorcsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, char signs,
-                          lapack_int m, lapack_int p, lapack_int q, float* x11, lapack_int ldx11, float* x12,
-                          lapack_int ldx12, float* x21, lapack_int ldx21, float* x22, lapack_int ldx22, float* theta,
-                          float* u1, lapack_int ldu1, float* u2, lapack_int ldu2, float* v1t, lapack_int ldv1t,
-                          float* v2t, lapack_int ldv2t);
-lapack_int LAPACKE_sorcsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               char signs, lapack_int m, lapack_int p, lapack_int q, float* x11, lapack_int ldx11,
-                               float* x12, lapack_int ldx12, float* x21, lapack_int ldx21, float* x22, lapack_int ldx22,
-                               float* theta, float* u1, lapack_int ldu1, float* u2, lapack_int ldu2, float* v1t,
-                               lapack_int ldv1t, float* v2t, lapack_int ldv2t, float* work, lapack_int lwork,
-                               lapack_int* iwork);
-lapack_int LAPACKE_ssyconv(int matrix_order, char uplo, char way, lapack_int n, float* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_ssyconv_work(int matrix_order, char uplo, char way, lapack_int n, float* a, lapack_int lda,
-                                const lapack_int* ipiv, float* work);
-lapack_int LAPACKE_ssyswapr(int matrix_order, char uplo, lapack_int n, float* a, lapack_int i1, lapack_int i2);
-lapack_int LAPACKE_ssyswapr_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int i1, lapack_int i2);
-lapack_int LAPACKE_ssytri2(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, const lapack_int* ipiv);
-lapack_int LAPACKE_ssytri2_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda,
-                                const lapack_int* ipiv, lapack_complex_float* work, lapack_int lwork);
-lapack_int LAPACKE_ssytri2x(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda, const lapack_int* ipiv,
-                            lapack_int nb);
-lapack_int LAPACKE_ssytri2x_work(int matrix_order, char uplo, lapack_int n, float* a, lapack_int lda,
-                                 const lapack_int* ipiv, float* work, lapack_int nb);
-lapack_int LAPACKE_ssytrs2(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a, lapack_int lda,
-                           const lapack_int* ipiv, float* b, lapack_int ldb);
-lapack_int LAPACKE_ssytrs2_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const float* a,
-                                lapack_int lda, const lapack_int* ipiv, float* b, lapack_int ldb, float* work);
-lapack_int LAPACKE_zbbcsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, lapack_int m,
-                          lapack_int p, lapack_int q, double* theta, double* phi, lapack_complex_double* u1,
-                          lapack_int ldu1, lapack_complex_double* u2, lapack_int ldu2, lapack_complex_double* v1t,
-                          lapack_int ldv1t, lapack_complex_double* v2t, lapack_int ldv2t, double* b11d, double* b11e,
-                          double* b12d, double* b12e, double* b21d, double* b21e, double* b22d, double* b22e);
-lapack_int LAPACKE_zbbcsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               lapack_int m, lapack_int p, lapack_int q, double* theta, double* phi,
-                               lapack_complex_double* u1, lapack_int ldu1, lapack_complex_double* u2, lapack_int ldu2,
-                               lapack_complex_double* v1t, lapack_int ldv1t, lapack_complex_double* v2t,
-                               lapack_int ldv2t, double* b11d, double* b11e, double* b12d, double* b12e, double* b21d,
-                               double* b21e, double* b22d, double* b22e, double* rwork, lapack_int lrwork);
-lapack_int LAPACKE_zheswapr(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int i1,
-                            lapack_int i2);
-lapack_int LAPACKE_zheswapr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int i1,
-                                 lapack_int i2);
-lapack_int LAPACKE_zhetri2(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_zhetri2_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                const lapack_int* ipiv, lapack_complex_double* work, lapack_int lwork);
-lapack_int LAPACKE_zhetri2x(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                            const lapack_int* ipiv, lapack_int nb);
-lapack_int LAPACKE_zhetri2x_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                 const lapack_int* ipiv, lapack_complex_double* work, lapack_int nb);
-lapack_int LAPACKE_zhetrs2(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                           lapack_int lda, const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-lapack_int LAPACKE_zhetrs2_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_double* a, lapack_int lda, const lapack_int* ipiv,
-                                lapack_complex_double* b, lapack_int ldb, lapack_complex_double* work);
-lapack_int LAPACKE_zsyconv(int matrix_order, char uplo, char way, lapack_int n, lapack_complex_double* a,
-                           lapack_int lda, const lapack_int* ipiv);
-lapack_int LAPACKE_zsyconv_work(int matrix_order, char uplo, char way, lapack_int n, lapack_complex_double* a,
-                                lapack_int lda, const lapack_int* ipiv, lapack_complex_double* work);
-lapack_int LAPACKE_zsyswapr(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int i1,
-                            lapack_int i2);
-lapack_int LAPACKE_zsyswapr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int i1,
-                                 lapack_int i2);
-lapack_int LAPACKE_zsytri2(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                           const lapack_int* ipiv);
-lapack_int LAPACKE_zsytri2_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                const lapack_int* ipiv, lapack_complex_double* work, lapack_int lwork);
-lapack_int LAPACKE_zsytri2x(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                            const lapack_int* ipiv, lapack_int nb);
-lapack_int LAPACKE_zsytri2x_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                 const lapack_int* ipiv, lapack_complex_double* work, lapack_int nb);
-lapack_int LAPACKE_zsytrs2(int matrix_order, char uplo, lapack_int n, lapack_int nrhs, const lapack_complex_double* a,
-                           lapack_int lda, const lapack_int* ipiv, lapack_complex_double* b, lapack_int ldb);
-lapack_int LAPACKE_zsytrs2_work(int matrix_order, char uplo, lapack_int n, lapack_int nrhs,
-                                const lapack_complex_double* a, lapack_int lda, const lapack_int* ipiv,
-                                lapack_complex_double* b, lapack_int ldb, lapack_complex_double* work);
-lapack_int LAPACKE_zunbdb(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                          lapack_complex_double* x11, lapack_int ldx11, lapack_complex_double* x12, lapack_int ldx12,
-                          lapack_complex_double* x21, lapack_int ldx21, lapack_complex_double* x22, lapack_int ldx22,
-                          double* theta, double* phi, lapack_complex_double* taup1, lapack_complex_double* taup2,
-                          lapack_complex_double* tauq1, lapack_complex_double* tauq2);
-lapack_int LAPACKE_zunbdb_work(int matrix_order, char trans, char signs, lapack_int m, lapack_int p, lapack_int q,
-                               lapack_complex_double* x11, lapack_int ldx11, lapack_complex_double* x12,
-                               lapack_int ldx12, lapack_complex_double* x21, lapack_int ldx21,
-                               lapack_complex_double* x22, lapack_int ldx22, double* theta, double* phi,
-                               lapack_complex_double* taup1, lapack_complex_double* taup2, lapack_complex_double* tauq1,
-                               lapack_complex_double* tauq2, lapack_complex_double* work, lapack_int lwork);
-lapack_int LAPACKE_zuncsd(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans, char signs,
-                          lapack_int m, lapack_int p, lapack_int q, lapack_complex_double* x11, lapack_int ldx11,
-                          lapack_complex_double* x12, lapack_int ldx12, lapack_complex_double* x21, lapack_int ldx21,
-                          lapack_complex_double* x22, lapack_int ldx22, double* theta, lapack_complex_double* u1,
-                          lapack_int ldu1, lapack_complex_double* u2, lapack_int ldu2, lapack_complex_double* v1t,
-                          lapack_int ldv1t, lapack_complex_double* v2t, lapack_int ldv2t);
-lapack_int LAPACKE_zuncsd_work(int matrix_order, char jobu1, char jobu2, char jobv1t, char jobv2t, char trans,
-                               char signs, lapack_int m, lapack_int p, lapack_int q, lapack_complex_double* x11,
-                               lapack_int ldx11, lapack_complex_double* x12, lapack_int ldx12,
-                               lapack_complex_double* x21, lapack_int ldx21, lapack_complex_double* x22,
-                               lapack_int ldx22, double* theta, lapack_complex_double* u1, lapack_int ldu1,
-                               lapack_complex_double* u2, lapack_int ldu2, lapack_complex_double* v1t, lapack_int ldv1t,
-                               lapack_complex_double* v2t, lapack_int ldv2t, lapack_complex_double* work,
-                               lapack_int lwork, double* rwork, lapack_int lrwork, lapack_int* iwork);
-// LAPACK 3.4.0
-lapack_int LAPACKE_sgemqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int nb, const float* v, lapack_int ldv, const float* t, lapack_int ldt, float* c,
-                           lapack_int ldc);
-lapack_int LAPACKE_dgemqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int nb, const double* v, lapack_int ldv, const double* t, lapack_int ldt, double* c,
-                           lapack_int ldc);
-lapack_int LAPACKE_cgemqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int nb, const lapack_complex_float* v, lapack_int ldv, const lapack_complex_float* t,
-                           lapack_int ldt, lapack_complex_float* c, lapack_int ldc);
-lapack_int LAPACKE_zgemqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int nb, const lapack_complex_double* v, lapack_int ldv,
-                           const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* c, lapack_int ldc);
-
-lapack_int LAPACKE_sgeqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, float* a, lapack_int lda,
-                          float* t, lapack_int ldt);
-lapack_int LAPACKE_dgeqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, double* a, lapack_int lda,
-                          double* t, lapack_int ldt);
-lapack_int LAPACKE_cgeqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, lapack_complex_float* a,
-                          lapack_int lda, lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zgeqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, lapack_complex_double* a,
-                          lapack_int lda, lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_sgeqrt2(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* t,
-                           lapack_int ldt);
-lapack_int LAPACKE_dgeqrt2(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* t,
-                           lapack_int ldt);
-lapack_int LAPACKE_cgeqrt2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zgeqrt2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                           lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_sgeqrt3(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* t,
-                           lapack_int ldt);
-lapack_int LAPACKE_dgeqrt3(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* t,
-                           lapack_int ldt);
-lapack_int LAPACKE_cgeqrt3(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zgeqrt3(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                           lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_stpmqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int l, lapack_int nb, const float* v, lapack_int ldv, const float* t, lapack_int ldt,
-                           float* a, lapack_int lda, float* b, lapack_int ldb);
-lapack_int LAPACKE_dtpmqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int l, lapack_int nb, const double* v, lapack_int ldv, const double* t,
-                           lapack_int ldt, double* a, lapack_int lda, double* b, lapack_int ldb);
-lapack_int LAPACKE_ctpmqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int l, lapack_int nb, const lapack_complex_float* v, lapack_int ldv,
-                           const lapack_complex_float* t, lapack_int ldt, lapack_complex_float* a, lapack_int lda,
-                           lapack_complex_float* b, lapack_int ldb);
-lapack_int LAPACKE_ztpmqrt(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                           lapack_int l, lapack_int nb, const lapack_complex_double* v, lapack_int ldv,
-                           const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* a, lapack_int lda,
-                           lapack_complex_double* b, lapack_int ldb);
-
-lapack_int LAPACKE_dtpqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int l, lapack_int nb, double* a,
-                          lapack_int lda, double* b, lapack_int ldb, double* t, lapack_int ldt);
-lapack_int LAPACKE_ctpqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int l, lapack_int nb,
-                          lapack_complex_float* a, lapack_int lda, lapack_complex_float* t, lapack_complex_float* b,
-                          lapack_int ldb, lapack_int ldt);
-lapack_int LAPACKE_ztpqrt(int matrix_order, lapack_int m, lapack_int n, lapack_int l, lapack_int nb,
-                          lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                          lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_stpqrt2(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* b,
-                           lapack_int ldb, float* t, lapack_int ldt);
-lapack_int LAPACKE_dtpqrt2(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* b,
-                           lapack_int ldb, double* t, lapack_int ldt);
-lapack_int LAPACKE_ctpqrt2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                           lapack_complex_float* b, lapack_int ldb, lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_ztpqrt2(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                           lapack_complex_double* b, lapack_int ldb, lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_stprfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, lapack_int l, const float* v, lapack_int ldv, const float* t, lapack_int ldt,
-                          float* a, lapack_int lda, float* b, lapack_int ldb, lapack_int myldwork);
-lapack_int LAPACKE_dtprfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, lapack_int l, const double* v, lapack_int ldv, const double* t, lapack_int ldt,
-                          double* a, lapack_int lda, double* b, lapack_int ldb, lapack_int myldwork);
-lapack_int LAPACKE_ctprfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, lapack_int l, const lapack_complex_float* v, lapack_int ldv,
-                          const lapack_complex_float* t, lapack_int ldt, lapack_complex_float* a, lapack_int lda,
-                          lapack_complex_float* b, lapack_int ldb, lapack_int myldwork);
-lapack_int LAPACKE_ztprfb(int matrix_order, char side, char trans, char direct, char storev, lapack_int m, lapack_int n,
-                          lapack_int k, lapack_int l, const lapack_complex_double* v, lapack_int ldv,
-                          const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* a, lapack_int lda,
-                          lapack_complex_double* b, lapack_int ldb, lapack_int myldwork);
-
-lapack_int LAPACKE_sgemqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int nb, const float* v, lapack_int ldv, const float* t, lapack_int ldt, float* c,
-                                lapack_int ldc, float* work);
-lapack_int LAPACKE_dgemqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int nb, const double* v, lapack_int ldv, const double* t, lapack_int ldt,
-                                double* c, lapack_int ldc, double* work);
-lapack_int LAPACKE_cgemqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int nb, const lapack_complex_float* v, lapack_int ldv,
-                                const lapack_complex_float* t, lapack_int ldt, lapack_complex_float* c, lapack_int ldc,
-                                lapack_complex_float* work);
-lapack_int LAPACKE_zgemqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int nb, const lapack_complex_double* v, lapack_int ldv,
-                                const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* c,
-                                lapack_int ldc, lapack_complex_double* work);
-
-lapack_int LAPACKE_sgeqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, float* a, lapack_int lda,
-                               float* t, lapack_int ldt, float* work);
-lapack_int LAPACKE_dgeqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, double* a, lapack_int lda,
-                               double* t, lapack_int ldt, double* work);
-lapack_int LAPACKE_cgeqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, lapack_complex_float* a,
-                               lapack_int lda, lapack_complex_float* t, lapack_int ldt, lapack_complex_float* work);
-lapack_int LAPACKE_zgeqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int nb, lapack_complex_double* a,
-                               lapack_int lda, lapack_complex_double* t, lapack_int ldt, lapack_complex_double* work);
-
-lapack_int LAPACKE_sgeqrt2_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* t,
-                                lapack_int ldt);
-lapack_int LAPACKE_dgeqrt2_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* t,
-                                lapack_int ldt);
-lapack_int LAPACKE_cgeqrt2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zgeqrt2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_sgeqrt3_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* t,
-                                lapack_int ldt);
-lapack_int LAPACKE_dgeqrt3_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* t,
-                                lapack_int ldt);
-lapack_int LAPACKE_cgeqrt3_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_zgeqrt3_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_stpmqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int l, lapack_int nb, const float* v, lapack_int ldv, const float* t,
-                                lapack_int ldt, float* a, lapack_int lda, float* b, lapack_int ldb, float* work);
-lapack_int LAPACKE_dtpmqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int l, lapack_int nb, const double* v, lapack_int ldv, const double* t,
-                                lapack_int ldt, double* a, lapack_int lda, double* b, lapack_int ldb, double* work);
-lapack_int LAPACKE_ctpmqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int l, lapack_int nb, const lapack_complex_float* v, lapack_int ldv,
-                                const lapack_complex_float* t, lapack_int ldt, lapack_complex_float* a, lapack_int lda,
-                                lapack_complex_float* b, lapack_int ldb, lapack_complex_float* work);
-lapack_int LAPACKE_ztpmqrt_work(int matrix_order, char side, char trans, lapack_int m, lapack_int n, lapack_int k,
-                                lapack_int l, lapack_int nb, const lapack_complex_double* v, lapack_int ldv,
-                                const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* a,
-                                lapack_int lda, lapack_complex_double* b, lapack_int ldb, lapack_complex_double* work);
-
-lapack_int LAPACKE_dtpqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int l, lapack_int nb, double* a,
-                               lapack_int lda, double* b, lapack_int ldb, double* t, lapack_int ldt, double* work);
-lapack_int LAPACKE_ctpqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int l, lapack_int nb,
-                               lapack_complex_float* a, lapack_int lda, lapack_complex_float* t,
-                               lapack_complex_float* b, lapack_int ldb, lapack_int ldt, lapack_complex_float* work);
-lapack_int LAPACKE_ztpqrt_work(int matrix_order, lapack_int m, lapack_int n, lapack_int l, lapack_int nb,
-                               lapack_complex_double* a, lapack_int lda, lapack_complex_double* b, lapack_int ldb,
-                               lapack_complex_double* t, lapack_int ldt, lapack_complex_double* work);
-
-lapack_int LAPACKE_stpqrt2_work(int matrix_order, lapack_int m, lapack_int n, float* a, lapack_int lda, float* b,
-                                lapack_int ldb, float* t, lapack_int ldt);
-lapack_int LAPACKE_dtpqrt2_work(int matrix_order, lapack_int m, lapack_int n, double* a, lapack_int lda, double* b,
-                                lapack_int ldb, double* t, lapack_int ldt);
-lapack_int LAPACKE_ctpqrt2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_float* a, lapack_int lda,
-                                lapack_complex_float* b, lapack_int ldb, lapack_complex_float* t, lapack_int ldt);
-lapack_int LAPACKE_ztpqrt2_work(int matrix_order, lapack_int m, lapack_int n, lapack_complex_double* a, lapack_int lda,
-                                lapack_complex_double* b, lapack_int ldb, lapack_complex_double* t, lapack_int ldt);
-
-lapack_int LAPACKE_stprfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, lapack_int l, const float* v, lapack_int ldv, const float* t,
-                               lapack_int ldt, float* a, lapack_int lda, float* b, lapack_int ldb, const float* mywork,
-                               lapack_int myldwork);
-lapack_int LAPACKE_dtprfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, lapack_int l, const double* v, lapack_int ldv,
-                               const double* t, lapack_int ldt, double* a, lapack_int lda, double* b, lapack_int ldb,
-                               const double* mywork, lapack_int myldwork);
-lapack_int LAPACKE_ctprfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, lapack_int l, const lapack_complex_float* v, lapack_int ldv,
-                               const lapack_complex_float* t, lapack_int ldt, lapack_complex_float* a, lapack_int lda,
-                               lapack_complex_float* b, lapack_int ldb, const float* mywork, lapack_int myldwork);
-lapack_int LAPACKE_ztprfb_work(int matrix_order, char side, char trans, char direct, char storev, lapack_int m,
-                               lapack_int n, lapack_int k, lapack_int l, const lapack_complex_double* v, lapack_int ldv,
-                               const lapack_complex_double* t, lapack_int ldt, lapack_complex_double* a, lapack_int lda,
-                               lapack_complex_double* b, lapack_int ldb, const double* mywork, lapack_int myldwork);
-// LAPACK 3.X.X
-lapack_int LAPACKE_csyr(int matrix_order, char uplo, lapack_int n, lapack_complex_float alpha,
-                        const lapack_complex_float* x, lapack_int incx, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zsyr(int matrix_order, char uplo, lapack_int n, lapack_complex_double alpha,
-                        const lapack_complex_double* x, lapack_int incx, lapack_complex_double* a, lapack_int lda);
-
-lapack_int LAPACKE_csyr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_float alpha,
-                             const lapack_complex_float* x, lapack_int incx, lapack_complex_float* a, lapack_int lda);
-lapack_int LAPACKE_zsyr_work(int matrix_order, char uplo, lapack_int n, lapack_complex_double alpha,
-                             const lapack_complex_double* x, lapack_int incx, lapack_complex_double* a, lapack_int lda);
-
-#define LAPACK_sgetrf LAPACK_GLOBAL(sgetrf, SGETRF)
-#define LAPACK_dgetrf LAPACK_GLOBAL(dgetrf, DGETRF)
-#define LAPACK_cgetrf LAPACK_GLOBAL(cgetrf, CGETRF)
-#define LAPACK_zgetrf LAPACK_GLOBAL(zgetrf, ZGETRF)
-#define LAPACK_sgbtrf LAPACK_GLOBAL(sgbtrf, SGBTRF)
-#define LAPACK_dgbtrf LAPACK_GLOBAL(dgbtrf, DGBTRF)
-#define LAPACK_cgbtrf LAPACK_GLOBAL(cgbtrf, CGBTRF)
-#define LAPACK_zgbtrf LAPACK_GLOBAL(zgbtrf, ZGBTRF)
-#define LAPACK_sgttrf LAPACK_GLOBAL(sgttrf, SGTTRF)
-#define LAPACK_dgttrf LAPACK_GLOBAL(dgttrf, DGTTRF)
-#define LAPACK_cgttrf LAPACK_GLOBAL(cgttrf, CGTTRF)
-#define LAPACK_zgttrf LAPACK_GLOBAL(zgttrf, ZGTTRF)
-#define LAPACK_spotrf LAPACK_GLOBAL(spotrf, SPOTRF)
-#define LAPACK_dpotrf LAPACK_GLOBAL(dpotrf, DPOTRF)
-#define LAPACK_cpotrf LAPACK_GLOBAL(cpotrf, CPOTRF)
-#define LAPACK_zpotrf LAPACK_GLOBAL(zpotrf, ZPOTRF)
-#define LAPACK_dpstrf LAPACK_GLOBAL(dpstrf, DPSTRF)
-#define LAPACK_spstrf LAPACK_GLOBAL(spstrf, SPSTRF)
-#define LAPACK_zpstrf LAPACK_GLOBAL(zpstrf, ZPSTRF)
-#define LAPACK_cpstrf LAPACK_GLOBAL(cpstrf, CPSTRF)
-#define LAPACK_dpftrf LAPACK_GLOBAL(dpftrf, DPFTRF)
-#define LAPACK_spftrf LAPACK_GLOBAL(spftrf, SPFTRF)
-#define LAPACK_zpftrf LAPACK_GLOBAL(zpftrf, ZPFTRF)
-#define LAPACK_cpftrf LAPACK_GLOBAL(cpftrf, CPFTRF)
-#define LAPACK_spptrf LAPACK_GLOBAL(spptrf, SPPTRF)
-#define LAPACK_dpptrf LAPACK_GLOBAL(dpptrf, DPPTRF)
-#define LAPACK_cpptrf LAPACK_GLOBAL(cpptrf, CPPTRF)
-#define LAPACK_zpptrf LAPACK_GLOBAL(zpptrf, ZPPTRF)
-#define LAPACK_spbtrf LAPACK_GLOBAL(spbtrf, SPBTRF)
-#define LAPACK_dpbtrf LAPACK_GLOBAL(dpbtrf, DPBTRF)
-#define LAPACK_cpbtrf LAPACK_GLOBAL(cpbtrf, CPBTRF)
-#define LAPACK_zpbtrf LAPACK_GLOBAL(zpbtrf, ZPBTRF)
-#define LAPACK_spttrf LAPACK_GLOBAL(spttrf, SPTTRF)
-#define LAPACK_dpttrf LAPACK_GLOBAL(dpttrf, DPTTRF)
-#define LAPACK_cpttrf LAPACK_GLOBAL(cpttrf, CPTTRF)
-#define LAPACK_zpttrf LAPACK_GLOBAL(zpttrf, ZPTTRF)
-#define LAPACK_ssytrf LAPACK_GLOBAL(ssytrf, SSYTRF)
-#define LAPACK_dsytrf LAPACK_GLOBAL(dsytrf, DSYTRF)
-#define LAPACK_csytrf LAPACK_GLOBAL(csytrf, CSYTRF)
-#define LAPACK_zsytrf LAPACK_GLOBAL(zsytrf, ZSYTRF)
-#define LAPACK_chetrf LAPACK_GLOBAL(chetrf, CHETRF)
-#define LAPACK_zhetrf LAPACK_GLOBAL(zhetrf, ZHETRF)
-#define LAPACK_ssptrf LAPACK_GLOBAL(ssptrf, SSPTRF)
-#define LAPACK_dsptrf LAPACK_GLOBAL(dsptrf, DSPTRF)
-#define LAPACK_csptrf LAPACK_GLOBAL(csptrf, CSPTRF)
-#define LAPACK_zsptrf LAPACK_GLOBAL(zsptrf, ZSPTRF)
-#define LAPACK_chptrf LAPACK_GLOBAL(chptrf, CHPTRF)
-#define LAPACK_zhptrf LAPACK_GLOBAL(zhptrf, ZHPTRF)
-#define LAPACK_sgetrs LAPACK_GLOBAL(sgetrs, SGETRS)
-#define LAPACK_dgetrs LAPACK_GLOBAL(dgetrs, DGETRS)
-#define LAPACK_cgetrs LAPACK_GLOBAL(cgetrs, CGETRS)
-#define LAPACK_zgetrs LAPACK_GLOBAL(zgetrs, ZGETRS)
-#define LAPACK_sgbtrs LAPACK_GLOBAL(sgbtrs, SGBTRS)
-#define LAPACK_dgbtrs LAPACK_GLOBAL(dgbtrs, DGBTRS)
-#define LAPACK_cgbtrs LAPACK_GLOBAL(cgbtrs, CGBTRS)
-#define LAPACK_zgbtrs LAPACK_GLOBAL(zgbtrs, ZGBTRS)
-#define LAPACK_sgttrs LAPACK_GLOBAL(sgttrs, SGTTRS)
-#define LAPACK_dgttrs LAPACK_GLOBAL(dgttrs, DGTTRS)
-#define LAPACK_cgttrs LAPACK_GLOBAL(cgttrs, CGTTRS)
-#define LAPACK_zgttrs LAPACK_GLOBAL(zgttrs, ZGTTRS)
-#define LAPACK_spotrs LAPACK_GLOBAL(spotrs, SPOTRS)
-#define LAPACK_dpotrs LAPACK_GLOBAL(dpotrs, DPOTRS)
-#define LAPACK_cpotrs LAPACK_GLOBAL(cpotrs, CPOTRS)
-#define LAPACK_zpotrs LAPACK_GLOBAL(zpotrs, ZPOTRS)
-#define LAPACK_dpftrs LAPACK_GLOBAL(dpftrs, DPFTRS)
-#define LAPACK_spftrs LAPACK_GLOBAL(spftrs, SPFTRS)
-#define LAPACK_zpftrs LAPACK_GLOBAL(zpftrs, ZPFTRS)
-#define LAPACK_cpftrs LAPACK_GLOBAL(cpftrs, CPFTRS)
-#define LAPACK_spptrs LAPACK_GLOBAL(spptrs, SPPTRS)
-#define LAPACK_dpptrs LAPACK_GLOBAL(dpptrs, DPPTRS)
-#define LAPACK_cpptrs LAPACK_GLOBAL(cpptrs, CPPTRS)
-#define LAPACK_zpptrs LAPACK_GLOBAL(zpptrs, ZPPTRS)
-#define LAPACK_spbtrs LAPACK_GLOBAL(spbtrs, SPBTRS)
-#define LAPACK_dpbtrs LAPACK_GLOBAL(dpbtrs, DPBTRS)
-#define LAPACK_cpbtrs LAPACK_GLOBAL(cpbtrs, CPBTRS)
-#define LAPACK_zpbtrs LAPACK_GLOBAL(zpbtrs, ZPBTRS)
-#define LAPACK_spttrs LAPACK_GLOBAL(spttrs, SPTTRS)
-#define LAPACK_dpttrs LAPACK_GLOBAL(dpttrs, DPTTRS)
-#define LAPACK_cpttrs LAPACK_GLOBAL(cpttrs, CPTTRS)
-#define LAPACK_zpttrs LAPACK_GLOBAL(zpttrs, ZPTTRS)
-#define LAPACK_ssytrs LAPACK_GLOBAL(ssytrs, SSYTRS)
-#define LAPACK_dsytrs LAPACK_GLOBAL(dsytrs, DSYTRS)
-#define LAPACK_csytrs LAPACK_GLOBAL(csytrs, CSYTRS)
-#define LAPACK_zsytrs LAPACK_GLOBAL(zsytrs, ZSYTRS)
-#define LAPACK_chetrs LAPACK_GLOBAL(chetrs, CHETRS)
-#define LAPACK_zhetrs LAPACK_GLOBAL(zhetrs, ZHETRS)
-#define LAPACK_ssptrs LAPACK_GLOBAL(ssptrs, SSPTRS)
-#define LAPACK_dsptrs LAPACK_GLOBAL(dsptrs, DSPTRS)
-#define LAPACK_csptrs LAPACK_GLOBAL(csptrs, CSPTRS)
-#define LAPACK_zsptrs LAPACK_GLOBAL(zsptrs, ZSPTRS)
-#define LAPACK_chptrs LAPACK_GLOBAL(chptrs, CHPTRS)
-#define LAPACK_zhptrs LAPACK_GLOBAL(zhptrs, ZHPTRS)
-#define LAPACK_strtrs LAPACK_GLOBAL(strtrs, STRTRS)
-#define LAPACK_dtrtrs LAPACK_GLOBAL(dtrtrs, DTRTRS)
-#define LAPACK_ctrtrs LAPACK_GLOBAL(ctrtrs, CTRTRS)
-#define LAPACK_ztrtrs LAPACK_GLOBAL(ztrtrs, ZTRTRS)
-#define LAPACK_stptrs LAPACK_GLOBAL(stptrs, STPTRS)
-#define LAPACK_dtptrs LAPACK_GLOBAL(dtptrs, DTPTRS)
-#define LAPACK_ctptrs LAPACK_GLOBAL(ctptrs, CTPTRS)
-#define LAPACK_ztptrs LAPACK_GLOBAL(ztptrs, ZTPTRS)
-#define LAPACK_stbtrs LAPACK_GLOBAL(stbtrs, STBTRS)
-#define LAPACK_dtbtrs LAPACK_GLOBAL(dtbtrs, DTBTRS)
-#define LAPACK_ctbtrs LAPACK_GLOBAL(ctbtrs, CTBTRS)
-#define LAPACK_ztbtrs LAPACK_GLOBAL(ztbtrs, ZTBTRS)
-#define LAPACK_sgecon LAPACK_GLOBAL(sgecon, SGECON)
-#define LAPACK_dgecon LAPACK_GLOBAL(dgecon, DGECON)
-#define LAPACK_cgecon LAPACK_GLOBAL(cgecon, CGECON)
-#define LAPACK_zgecon LAPACK_GLOBAL(zgecon, ZGECON)
-#define LAPACK_sgbcon LAPACK_GLOBAL(sgbcon, SGBCON)
-#define LAPACK_dgbcon LAPACK_GLOBAL(dgbcon, DGBCON)
-#define LAPACK_cgbcon LAPACK_GLOBAL(cgbcon, CGBCON)
-#define LAPACK_zgbcon LAPACK_GLOBAL(zgbcon, ZGBCON)
-#define LAPACK_sgtcon LAPACK_GLOBAL(sgtcon, SGTCON)
-#define LAPACK_dgtcon LAPACK_GLOBAL(dgtcon, DGTCON)
-#define LAPACK_cgtcon LAPACK_GLOBAL(cgtcon, CGTCON)
-#define LAPACK_zgtcon LAPACK_GLOBAL(zgtcon, ZGTCON)
-#define LAPACK_spocon LAPACK_GLOBAL(spocon, SPOCON)
-#define LAPACK_dpocon LAPACK_GLOBAL(dpocon, DPOCON)
-#define LAPACK_cpocon LAPACK_GLOBAL(cpocon, CPOCON)
-#define LAPACK_zpocon LAPACK_GLOBAL(zpocon, ZPOCON)
-#define LAPACK_sppcon LAPACK_GLOBAL(sppcon, SPPCON)
-#define LAPACK_dppcon LAPACK_GLOBAL(dppcon, DPPCON)
-#define LAPACK_cppcon LAPACK_GLOBAL(cppcon, CPPCON)
-#define LAPACK_zppcon LAPACK_GLOBAL(zppcon, ZPPCON)
-#define LAPACK_spbcon LAPACK_GLOBAL(spbcon, SPBCON)
-#define LAPACK_dpbcon LAPACK_GLOBAL(dpbcon, DPBCON)
-#define LAPACK_cpbcon LAPACK_GLOBAL(cpbcon, CPBCON)
-#define LAPACK_zpbcon LAPACK_GLOBAL(zpbcon, ZPBCON)
-#define LAPACK_sptcon LAPACK_GLOBAL(sptcon, SPTCON)
-#define LAPACK_dptcon LAPACK_GLOBAL(dptcon, DPTCON)
-#define LAPACK_cptcon LAPACK_GLOBAL(cptcon, CPTCON)
-#define LAPACK_zptcon LAPACK_GLOBAL(zptcon, ZPTCON)
-#define LAPACK_ssycon LAPACK_GLOBAL(ssycon, SSYCON)
-#define LAPACK_dsycon LAPACK_GLOBAL(dsycon, DSYCON)
-#define LAPACK_csycon LAPACK_GLOBAL(csycon, CSYCON)
-#define LAPACK_zsycon LAPACK_GLOBAL(zsycon, ZSYCON)
-#define LAPACK_checon LAPACK_GLOBAL(checon, CHECON)
-#define LAPACK_zhecon LAPACK_GLOBAL(zhecon, ZHECON)
-#define LAPACK_sspcon LAPACK_GLOBAL(sspcon, SSPCON)
-#define LAPACK_dspcon LAPACK_GLOBAL(dspcon, DSPCON)
-#define LAPACK_cspcon LAPACK_GLOBAL(cspcon, CSPCON)
-#define LAPACK_zspcon LAPACK_GLOBAL(zspcon, ZSPCON)
-#define LAPACK_chpcon LAPACK_GLOBAL(chpcon, CHPCON)
-#define LAPACK_zhpcon LAPACK_GLOBAL(zhpcon, ZHPCON)
-#define LAPACK_strcon LAPACK_GLOBAL(strcon, STRCON)
-#define LAPACK_dtrcon LAPACK_GLOBAL(dtrcon, DTRCON)
-#define LAPACK_ctrcon LAPACK_GLOBAL(ctrcon, CTRCON)
-#define LAPACK_ztrcon LAPACK_GLOBAL(ztrcon, ZTRCON)
-#define LAPACK_stpcon LAPACK_GLOBAL(stpcon, STPCON)
-#define LAPACK_dtpcon LAPACK_GLOBAL(dtpcon, DTPCON)
-#define LAPACK_ctpcon LAPACK_GLOBAL(ctpcon, CTPCON)
-#define LAPACK_ztpcon LAPACK_GLOBAL(ztpcon, ZTPCON)
-#define LAPACK_stbcon LAPACK_GLOBAL(stbcon, STBCON)
-#define LAPACK_dtbcon LAPACK_GLOBAL(dtbcon, DTBCON)
-#define LAPACK_ctbcon LAPACK_GLOBAL(ctbcon, CTBCON)
-#define LAPACK_ztbcon LAPACK_GLOBAL(ztbcon, ZTBCON)
-#define LAPACK_sgerfs LAPACK_GLOBAL(sgerfs, SGERFS)
-#define LAPACK_dgerfs LAPACK_GLOBAL(dgerfs, DGERFS)
-#define LAPACK_cgerfs LAPACK_GLOBAL(cgerfs, CGERFS)
-#define LAPACK_zgerfs LAPACK_GLOBAL(zgerfs, ZGERFS)
-#define LAPACK_dgerfsx LAPACK_GLOBAL(dgerfsx, DGERFSX)
-#define LAPACK_sgerfsx LAPACK_GLOBAL(sgerfsx, SGERFSX)
-#define LAPACK_zgerfsx LAPACK_GLOBAL(zgerfsx, ZGERFSX)
-#define LAPACK_cgerfsx LAPACK_GLOBAL(cgerfsx, CGERFSX)
-#define LAPACK_sgbrfs LAPACK_GLOBAL(sgbrfs, SGBRFS)
-#define LAPACK_dgbrfs LAPACK_GLOBAL(dgbrfs, DGBRFS)
-#define LAPACK_cgbrfs LAPACK_GLOBAL(cgbrfs, CGBRFS)
-#define LAPACK_zgbrfs LAPACK_GLOBAL(zgbrfs, ZGBRFS)
-#define LAPACK_dgbrfsx LAPACK_GLOBAL(dgbrfsx, DGBRFSX)
-#define LAPACK_sgbrfsx LAPACK_GLOBAL(sgbrfsx, SGBRFSX)
-#define LAPACK_zgbrfsx LAPACK_GLOBAL(zgbrfsx, ZGBRFSX)
-#define LAPACK_cgbrfsx LAPACK_GLOBAL(cgbrfsx, CGBRFSX)
-#define LAPACK_sgtrfs LAPACK_GLOBAL(sgtrfs, SGTRFS)
-#define LAPACK_dgtrfs LAPACK_GLOBAL(dgtrfs, DGTRFS)
-#define LAPACK_cgtrfs LAPACK_GLOBAL(cgtrfs, CGTRFS)
-#define LAPACK_zgtrfs LAPACK_GLOBAL(zgtrfs, ZGTRFS)
-#define LAPACK_sporfs LAPACK_GLOBAL(sporfs, SPORFS)
-#define LAPACK_dporfs LAPACK_GLOBAL(dporfs, DPORFS)
-#define LAPACK_cporfs LAPACK_GLOBAL(cporfs, CPORFS)
-#define LAPACK_zporfs LAPACK_GLOBAL(zporfs, ZPORFS)
-#define LAPACK_dporfsx LAPACK_GLOBAL(dporfsx, DPORFSX)
-#define LAPACK_sporfsx LAPACK_GLOBAL(sporfsx, SPORFSX)
-#define LAPACK_zporfsx LAPACK_GLOBAL(zporfsx, ZPORFSX)
-#define LAPACK_cporfsx LAPACK_GLOBAL(cporfsx, CPORFSX)
-#define LAPACK_spprfs LAPACK_GLOBAL(spprfs, SPPRFS)
-#define LAPACK_dpprfs LAPACK_GLOBAL(dpprfs, DPPRFS)
-#define LAPACK_cpprfs LAPACK_GLOBAL(cpprfs, CPPRFS)
-#define LAPACK_zpprfs LAPACK_GLOBAL(zpprfs, ZPPRFS)
-#define LAPACK_spbrfs LAPACK_GLOBAL(spbrfs, SPBRFS)
-#define LAPACK_dpbrfs LAPACK_GLOBAL(dpbrfs, DPBRFS)
-#define LAPACK_cpbrfs LAPACK_GLOBAL(cpbrfs, CPBRFS)
-#define LAPACK_zpbrfs LAPACK_GLOBAL(zpbrfs, ZPBRFS)
-#define LAPACK_sptrfs LAPACK_GLOBAL(sptrfs, SPTRFS)
-#define LAPACK_dptrfs LAPACK_GLOBAL(dptrfs, DPTRFS)
-#define LAPACK_cptrfs LAPACK_GLOBAL(cptrfs, CPTRFS)
-#define LAPACK_zptrfs LAPACK_GLOBAL(zptrfs, ZPTRFS)
-#define LAPACK_ssyrfs LAPACK_GLOBAL(ssyrfs, SSYRFS)
-#define LAPACK_dsyrfs LAPACK_GLOBAL(dsyrfs, DSYRFS)
-#define LAPACK_csyrfs LAPACK_GLOBAL(csyrfs, CSYRFS)
-#define LAPACK_zsyrfs LAPACK_GLOBAL(zsyrfs, ZSYRFS)
-#define LAPACK_dsyrfsx LAPACK_GLOBAL(dsyrfsx, DSYRFSX)
-#define LAPACK_ssyrfsx LAPACK_GLOBAL(ssyrfsx, SSYRFSX)
-#define LAPACK_zsyrfsx LAPACK_GLOBAL(zsyrfsx, ZSYRFSX)
-#define LAPACK_csyrfsx LAPACK_GLOBAL(csyrfsx, CSYRFSX)
-#define LAPACK_cherfs LAPACK_GLOBAL(cherfs, CHERFS)
-#define LAPACK_zherfs LAPACK_GLOBAL(zherfs, ZHERFS)
-#define LAPACK_zherfsx LAPACK_GLOBAL(zherfsx, ZHERFSX)
-#define LAPACK_cherfsx LAPACK_GLOBAL(cherfsx, CHERFSX)
-#define LAPACK_ssprfs LAPACK_GLOBAL(ssprfs, SSPRFS)
-#define LAPACK_dsprfs LAPACK_GLOBAL(dsprfs, DSPRFS)
-#define LAPACK_csprfs LAPACK_GLOBAL(csprfs, CSPRFS)
-#define LAPACK_zsprfs LAPACK_GLOBAL(zsprfs, ZSPRFS)
-#define LAPACK_chprfs LAPACK_GLOBAL(chprfs, CHPRFS)
-#define LAPACK_zhprfs LAPACK_GLOBAL(zhprfs, ZHPRFS)
-#define LAPACK_strrfs LAPACK_GLOBAL(strrfs, STRRFS)
-#define LAPACK_dtrrfs LAPACK_GLOBAL(dtrrfs, DTRRFS)
-#define LAPACK_ctrrfs LAPACK_GLOBAL(ctrrfs, CTRRFS)
-#define LAPACK_ztrrfs LAPACK_GLOBAL(ztrrfs, ZTRRFS)
-#define LAPACK_stprfs LAPACK_GLOBAL(stprfs, STPRFS)
-#define LAPACK_dtprfs LAPACK_GLOBAL(dtprfs, DTPRFS)
-#define LAPACK_ctprfs LAPACK_GLOBAL(ctprfs, CTPRFS)
-#define LAPACK_ztprfs LAPACK_GLOBAL(ztprfs, ZTPRFS)
-#define LAPACK_stbrfs LAPACK_GLOBAL(stbrfs, STBRFS)
-#define LAPACK_dtbrfs LAPACK_GLOBAL(dtbrfs, DTBRFS)
-#define LAPACK_ctbrfs LAPACK_GLOBAL(ctbrfs, CTBRFS)
-#define LAPACK_ztbrfs LAPACK_GLOBAL(ztbrfs, ZTBRFS)
-#define LAPACK_sgetri LAPACK_GLOBAL(sgetri, SGETRI)
-#define LAPACK_dgetri LAPACK_GLOBAL(dgetri, DGETRI)
-#define LAPACK_cgetri LAPACK_GLOBAL(cgetri, CGETRI)
-#define LAPACK_zgetri LAPACK_GLOBAL(zgetri, ZGETRI)
-#define LAPACK_spotri LAPACK_GLOBAL(spotri, SPOTRI)
-#define LAPACK_dpotri LAPACK_GLOBAL(dpotri, DPOTRI)
-#define LAPACK_cpotri LAPACK_GLOBAL(cpotri, CPOTRI)
-#define LAPACK_zpotri LAPACK_GLOBAL(zpotri, ZPOTRI)
-#define LAPACK_dpftri LAPACK_GLOBAL(dpftri, DPFTRI)
-#define LAPACK_spftri LAPACK_GLOBAL(spftri, SPFTRI)
-#define LAPACK_zpftri LAPACK_GLOBAL(zpftri, ZPFTRI)
-#define LAPACK_cpftri LAPACK_GLOBAL(cpftri, CPFTRI)
-#define LAPACK_spptri LAPACK_GLOBAL(spptri, SPPTRI)
-#define LAPACK_dpptri LAPACK_GLOBAL(dpptri, DPPTRI)
-#define LAPACK_cpptri LAPACK_GLOBAL(cpptri, CPPTRI)
-#define LAPACK_zpptri LAPACK_GLOBAL(zpptri, ZPPTRI)
-#define LAPACK_ssytri LAPACK_GLOBAL(ssytri, SSYTRI)
-#define LAPACK_dsytri LAPACK_GLOBAL(dsytri, DSYTRI)
-#define LAPACK_csytri LAPACK_GLOBAL(csytri, CSYTRI)
-#define LAPACK_zsytri LAPACK_GLOBAL(zsytri, ZSYTRI)
-#define LAPACK_chetri LAPACK_GLOBAL(chetri, CHETRI)
-#define LAPACK_zhetri LAPACK_GLOBAL(zhetri, ZHETRI)
-#define LAPACK_ssptri LAPACK_GLOBAL(ssptri, SSPTRI)
-#define LAPACK_dsptri LAPACK_GLOBAL(dsptri, DSPTRI)
-#define LAPACK_csptri LAPACK_GLOBAL(csptri, CSPTRI)
-#define LAPACK_zsptri LAPACK_GLOBAL(zsptri, ZSPTRI)
-#define LAPACK_chptri LAPACK_GLOBAL(chptri, CHPTRI)
-#define LAPACK_zhptri LAPACK_GLOBAL(zhptri, ZHPTRI)
-#define LAPACK_strtri LAPACK_GLOBAL(strtri, STRTRI)
-#define LAPACK_dtrtri LAPACK_GLOBAL(dtrtri, DTRTRI)
-#define LAPACK_ctrtri LAPACK_GLOBAL(ctrtri, CTRTRI)
-#define LAPACK_ztrtri LAPACK_GLOBAL(ztrtri, ZTRTRI)
-#define LAPACK_dtftri LAPACK_GLOBAL(dtftri, DTFTRI)
-#define LAPACK_stftri LAPACK_GLOBAL(stftri, STFTRI)
-#define LAPACK_ztftri LAPACK_GLOBAL(ztftri, ZTFTRI)
-#define LAPACK_ctftri LAPACK_GLOBAL(ctftri, CTFTRI)
-#define LAPACK_stptri LAPACK_GLOBAL(stptri, STPTRI)
-#define LAPACK_dtptri LAPACK_GLOBAL(dtptri, DTPTRI)
-#define LAPACK_ctptri LAPACK_GLOBAL(ctptri, CTPTRI)
-#define LAPACK_ztptri LAPACK_GLOBAL(ztptri, ZTPTRI)
-#define LAPACK_sgeequ LAPACK_GLOBAL(sgeequ, SGEEQU)
-#define LAPACK_dgeequ LAPACK_GLOBAL(dgeequ, DGEEQU)
-#define LAPACK_cgeequ LAPACK_GLOBAL(cgeequ, CGEEQU)
-#define LAPACK_zgeequ LAPACK_GLOBAL(zgeequ, ZGEEQU)
-#define LAPACK_dgeequb LAPACK_GLOBAL(dgeequb, DGEEQUB)
-#define LAPACK_sgeequb LAPACK_GLOBAL(sgeequb, SGEEQUB)
-#define LAPACK_zgeequb LAPACK_GLOBAL(zgeequb, ZGEEQUB)
-#define LAPACK_cgeequb LAPACK_GLOBAL(cgeequb, CGEEQUB)
-#define LAPACK_sgbequ LAPACK_GLOBAL(sgbequ, SGBEQU)
-#define LAPACK_dgbequ LAPACK_GLOBAL(dgbequ, DGBEQU)
-#define LAPACK_cgbequ LAPACK_GLOBAL(cgbequ, CGBEQU)
-#define LAPACK_zgbequ LAPACK_GLOBAL(zgbequ, ZGBEQU)
-#define LAPACK_dgbequb LAPACK_GLOBAL(dgbequb, DGBEQUB)
-#define LAPACK_sgbequb LAPACK_GLOBAL(sgbequb, SGBEQUB)
-#define LAPACK_zgbequb LAPACK_GLOBAL(zgbequb, ZGBEQUB)
-#define LAPACK_cgbequb LAPACK_GLOBAL(cgbequb, CGBEQUB)
-#define LAPACK_spoequ LAPACK_GLOBAL(spoequ, SPOEQU)
-#define LAPACK_dpoequ LAPACK_GLOBAL(dpoequ, DPOEQU)
-#define LAPACK_cpoequ LAPACK_GLOBAL(cpoequ, CPOEQU)
-#define LAPACK_zpoequ LAPACK_GLOBAL(zpoequ, ZPOEQU)
-#define LAPACK_dpoequb LAPACK_GLOBAL(dpoequb, DPOEQUB)
-#define LAPACK_spoequb LAPACK_GLOBAL(spoequb, SPOEQUB)
-#define LAPACK_zpoequb LAPACK_GLOBAL(zpoequb, ZPOEQUB)
-#define LAPACK_cpoequb LAPACK_GLOBAL(cpoequb, CPOEQUB)
-#define LAPACK_sppequ LAPACK_GLOBAL(sppequ, SPPEQU)
-#define LAPACK_dppequ LAPACK_GLOBAL(dppequ, DPPEQU)
-#define LAPACK_cppequ LAPACK_GLOBAL(cppequ, CPPEQU)
-#define LAPACK_zppequ LAPACK_GLOBAL(zppequ, ZPPEQU)
-#define LAPACK_spbequ LAPACK_GLOBAL(spbequ, SPBEQU)
-#define LAPACK_dpbequ LAPACK_GLOBAL(dpbequ, DPBEQU)
-#define LAPACK_cpbequ LAPACK_GLOBAL(cpbequ, CPBEQU)
-#define LAPACK_zpbequ LAPACK_GLOBAL(zpbequ, ZPBEQU)
-#define LAPACK_dsyequb LAPACK_GLOBAL(dsyequb, DSYEQUB)
-#define LAPACK_ssyequb LAPACK_GLOBAL(ssyequb, SSYEQUB)
-#define LAPACK_zsyequb LAPACK_GLOBAL(zsyequb, ZSYEQUB)
-#define LAPACK_csyequb LAPACK_GLOBAL(csyequb, CSYEQUB)
-#define LAPACK_zheequb LAPACK_GLOBAL(zheequb, ZHEEQUB)
-#define LAPACK_cheequb LAPACK_GLOBAL(cheequb, CHEEQUB)
-#define LAPACK_sgesv LAPACK_GLOBAL(sgesv, SGESV)
-#define LAPACK_dgesv LAPACK_GLOBAL(dgesv, DGESV)
-#define LAPACK_cgesv LAPACK_GLOBAL(cgesv, CGESV)
-#define LAPACK_zgesv LAPACK_GLOBAL(zgesv, ZGESV)
-#define LAPACK_dsgesv LAPACK_GLOBAL(dsgesv, DSGESV)
-#define LAPACK_zcgesv LAPACK_GLOBAL(zcgesv, ZCGESV)
-#define LAPACK_sgesvx LAPACK_GLOBAL(sgesvx, SGESVX)
-#define LAPACK_dgesvx LAPACK_GLOBAL(dgesvx, DGESVX)
-#define LAPACK_cgesvx LAPACK_GLOBAL(cgesvx, CGESVX)
-#define LAPACK_zgesvx LAPACK_GLOBAL(zgesvx, ZGESVX)
-#define LAPACK_dgesvxx LAPACK_GLOBAL(dgesvxx, DGESVXX)
-#define LAPACK_sgesvxx LAPACK_GLOBAL(sgesvxx, SGESVXX)
-#define LAPACK_zgesvxx LAPACK_GLOBAL(zgesvxx, ZGESVXX)
-#define LAPACK_cgesvxx LAPACK_GLOBAL(cgesvxx, CGESVXX)
-#define LAPACK_sgbsv LAPACK_GLOBAL(sgbsv, SGBSV)
-#define LAPACK_dgbsv LAPACK_GLOBAL(dgbsv, DGBSV)
-#define LAPACK_cgbsv LAPACK_GLOBAL(cgbsv, CGBSV)
-#define LAPACK_zgbsv LAPACK_GLOBAL(zgbsv, ZGBSV)
-#define LAPACK_sgbsvx LAPACK_GLOBAL(sgbsvx, SGBSVX)
-#define LAPACK_dgbsvx LAPACK_GLOBAL(dgbsvx, DGBSVX)
-#define LAPACK_cgbsvx LAPACK_GLOBAL(cgbsvx, CGBSVX)
-#define LAPACK_zgbsvx LAPACK_GLOBAL(zgbsvx, ZGBSVX)
-#define LAPACK_dgbsvxx LAPACK_GLOBAL(dgbsvxx, DGBSVXX)
-#define LAPACK_sgbsvxx LAPACK_GLOBAL(sgbsvxx, SGBSVXX)
-#define LAPACK_zgbsvxx LAPACK_GLOBAL(zgbsvxx, ZGBSVXX)
-#define LAPACK_cgbsvxx LAPACK_GLOBAL(cgbsvxx, CGBSVXX)
-#define LAPACK_sgtsv LAPACK_GLOBAL(sgtsv, SGTSV)
-#define LAPACK_dgtsv LAPACK_GLOBAL(dgtsv, DGTSV)
-#define LAPACK_cgtsv LAPACK_GLOBAL(cgtsv, CGTSV)
-#define LAPACK_zgtsv LAPACK_GLOBAL(zgtsv, ZGTSV)
-#define LAPACK_sgtsvx LAPACK_GLOBAL(sgtsvx, SGTSVX)
-#define LAPACK_dgtsvx LAPACK_GLOBAL(dgtsvx, DGTSVX)
-#define LAPACK_cgtsvx LAPACK_GLOBAL(cgtsvx, CGTSVX)
-#define LAPACK_zgtsvx LAPACK_GLOBAL(zgtsvx, ZGTSVX)
-#define LAPACK_sposv LAPACK_GLOBAL(sposv, SPOSV)
-#define LAPACK_dposv LAPACK_GLOBAL(dposv, DPOSV)
-#define LAPACK_cposv LAPACK_GLOBAL(cposv, CPOSV)
-#define LAPACK_zposv LAPACK_GLOBAL(zposv, ZPOSV)
-#define LAPACK_dsposv LAPACK_GLOBAL(dsposv, DSPOSV)
-#define LAPACK_zcposv LAPACK_GLOBAL(zcposv, ZCPOSV)
-#define LAPACK_sposvx LAPACK_GLOBAL(sposvx, SPOSVX)
-#define LAPACK_dposvx LAPACK_GLOBAL(dposvx, DPOSVX)
-#define LAPACK_cposvx LAPACK_GLOBAL(cposvx, CPOSVX)
-#define LAPACK_zposvx LAPACK_GLOBAL(zposvx, ZPOSVX)
-#define LAPACK_dposvxx LAPACK_GLOBAL(dposvxx, DPOSVXX)
-#define LAPACK_sposvxx LAPACK_GLOBAL(sposvxx, SPOSVXX)
-#define LAPACK_zposvxx LAPACK_GLOBAL(zposvxx, ZPOSVXX)
-#define LAPACK_cposvxx LAPACK_GLOBAL(cposvxx, CPOSVXX)
-#define LAPACK_sppsv LAPACK_GLOBAL(sppsv, SPPSV)
-#define LAPACK_dppsv LAPACK_GLOBAL(dppsv, DPPSV)
-#define LAPACK_cppsv LAPACK_GLOBAL(cppsv, CPPSV)
-#define LAPACK_zppsv LAPACK_GLOBAL(zppsv, ZPPSV)
-#define LAPACK_sppsvx LAPACK_GLOBAL(sppsvx, SPPSVX)
-#define LAPACK_dppsvx LAPACK_GLOBAL(dppsvx, DPPSVX)
-#define LAPACK_cppsvx LAPACK_GLOBAL(cppsvx, CPPSVX)
-#define LAPACK_zppsvx LAPACK_GLOBAL(zppsvx, ZPPSVX)
-#define LAPACK_spbsv LAPACK_GLOBAL(spbsv, SPBSV)
-#define LAPACK_dpbsv LAPACK_GLOBAL(dpbsv, DPBSV)
-#define LAPACK_cpbsv LAPACK_GLOBAL(cpbsv, CPBSV)
-#define LAPACK_zpbsv LAPACK_GLOBAL(zpbsv, ZPBSV)
-#define LAPACK_spbsvx LAPACK_GLOBAL(spbsvx, SPBSVX)
-#define LAPACK_dpbsvx LAPACK_GLOBAL(dpbsvx, DPBSVX)
-#define LAPACK_cpbsvx LAPACK_GLOBAL(cpbsvx, CPBSVX)
-#define LAPACK_zpbsvx LAPACK_GLOBAL(zpbsvx, ZPBSVX)
-#define LAPACK_sptsv LAPACK_GLOBAL(sptsv, SPTSV)
-#define LAPACK_dptsv LAPACK_GLOBAL(dptsv, DPTSV)
-#define LAPACK_cptsv LAPACK_GLOBAL(cptsv, CPTSV)
-#define LAPACK_zptsv LAPACK_GLOBAL(zptsv, ZPTSV)
-#define LAPACK_sptsvx LAPACK_GLOBAL(sptsvx, SPTSVX)
-#define LAPACK_dptsvx LAPACK_GLOBAL(dptsvx, DPTSVX)
-#define LAPACK_cptsvx LAPACK_GLOBAL(cptsvx, CPTSVX)
-#define LAPACK_zptsvx LAPACK_GLOBAL(zptsvx, ZPTSVX)
-#define LAPACK_ssysv LAPACK_GLOBAL(ssysv, SSYSV)
-#define LAPACK_dsysv LAPACK_GLOBAL(dsysv, DSYSV)
-#define LAPACK_csysv LAPACK_GLOBAL(csysv, CSYSV)
-#define LAPACK_zsysv LAPACK_GLOBAL(zsysv, ZSYSV)
-#define LAPACK_ssysvx LAPACK_GLOBAL(ssysvx, SSYSVX)
-#define LAPACK_dsysvx LAPACK_GLOBAL(dsysvx, DSYSVX)
-#define LAPACK_csysvx LAPACK_GLOBAL(csysvx, CSYSVX)
-#define LAPACK_zsysvx LAPACK_GLOBAL(zsysvx, ZSYSVX)
-#define LAPACK_dsysvxx LAPACK_GLOBAL(dsysvxx, DSYSVXX)
-#define LAPACK_ssysvxx LAPACK_GLOBAL(ssysvxx, SSYSVXX)
-#define LAPACK_zsysvxx LAPACK_GLOBAL(zsysvxx, ZSYSVXX)
-#define LAPACK_csysvxx LAPACK_GLOBAL(csysvxx, CSYSVXX)
-#define LAPACK_chesv LAPACK_GLOBAL(chesv, CHESV)
-#define LAPACK_zhesv LAPACK_GLOBAL(zhesv, ZHESV)
-#define LAPACK_chesvx LAPACK_GLOBAL(chesvx, CHESVX)
-#define LAPACK_zhesvx LAPACK_GLOBAL(zhesvx, ZHESVX)
-#define LAPACK_zhesvxx LAPACK_GLOBAL(zhesvxx, ZHESVXX)
-#define LAPACK_chesvxx LAPACK_GLOBAL(chesvxx, CHESVXX)
-#define LAPACK_sspsv LAPACK_GLOBAL(sspsv, SSPSV)
-#define LAPACK_dspsv LAPACK_GLOBAL(dspsv, DSPSV)
-#define LAPACK_cspsv LAPACK_GLOBAL(cspsv, CSPSV)
-#define LAPACK_zspsv LAPACK_GLOBAL(zspsv, ZSPSV)
-#define LAPACK_sspsvx LAPACK_GLOBAL(sspsvx, SSPSVX)
-#define LAPACK_dspsvx LAPACK_GLOBAL(dspsvx, DSPSVX)
-#define LAPACK_cspsvx LAPACK_GLOBAL(cspsvx, CSPSVX)
-#define LAPACK_zspsvx LAPACK_GLOBAL(zspsvx, ZSPSVX)
-#define LAPACK_chpsv LAPACK_GLOBAL(chpsv, CHPSV)
-#define LAPACK_zhpsv LAPACK_GLOBAL(zhpsv, ZHPSV)
-#define LAPACK_chpsvx LAPACK_GLOBAL(chpsvx, CHPSVX)
-#define LAPACK_zhpsvx LAPACK_GLOBAL(zhpsvx, ZHPSVX)
-#define LAPACK_sgeqrf LAPACK_GLOBAL(sgeqrf, SGEQRF)
-#define LAPACK_dgeqrf LAPACK_GLOBAL(dgeqrf, DGEQRF)
-#define LAPACK_cgeqrf LAPACK_GLOBAL(cgeqrf, CGEQRF)
-#define LAPACK_zgeqrf LAPACK_GLOBAL(zgeqrf, ZGEQRF)
-#define LAPACK_sgeqpf LAPACK_GLOBAL(sgeqpf, SGEQPF)
-#define LAPACK_dgeqpf LAPACK_GLOBAL(dgeqpf, DGEQPF)
-#define LAPACK_cgeqpf LAPACK_GLOBAL(cgeqpf, CGEQPF)
-#define LAPACK_zgeqpf LAPACK_GLOBAL(zgeqpf, ZGEQPF)
-#define LAPACK_sgeqp3 LAPACK_GLOBAL(sgeqp3, SGEQP3)
-#define LAPACK_dgeqp3 LAPACK_GLOBAL(dgeqp3, DGEQP3)
-#define LAPACK_cgeqp3 LAPACK_GLOBAL(cgeqp3, CGEQP3)
-#define LAPACK_zgeqp3 LAPACK_GLOBAL(zgeqp3, ZGEQP3)
-#define LAPACK_sorgqr LAPACK_GLOBAL(sorgqr, SORGQR)
-#define LAPACK_dorgqr LAPACK_GLOBAL(dorgqr, DORGQR)
-#define LAPACK_sormqr LAPACK_GLOBAL(sormqr, SORMQR)
-#define LAPACK_dormqr LAPACK_GLOBAL(dormqr, DORMQR)
-#define LAPACK_cungqr LAPACK_GLOBAL(cungqr, CUNGQR)
-#define LAPACK_zungqr LAPACK_GLOBAL(zungqr, ZUNGQR)
-#define LAPACK_cunmqr LAPACK_GLOBAL(cunmqr, CUNMQR)
-#define LAPACK_zunmqr LAPACK_GLOBAL(zunmqr, ZUNMQR)
-#define LAPACK_sgelqf LAPACK_GLOBAL(sgelqf, SGELQF)
-#define LAPACK_dgelqf LAPACK_GLOBAL(dgelqf, DGELQF)
-#define LAPACK_cgelqf LAPACK_GLOBAL(cgelqf, CGELQF)
-#define LAPACK_zgelqf LAPACK_GLOBAL(zgelqf, ZGELQF)
-#define LAPACK_sorglq LAPACK_GLOBAL(sorglq, SORGLQ)
-#define LAPACK_dorglq LAPACK_GLOBAL(dorglq, DORGLQ)
-#define LAPACK_sormlq LAPACK_GLOBAL(sormlq, SORMLQ)
-#define LAPACK_dormlq LAPACK_GLOBAL(dormlq, DORMLQ)
-#define LAPACK_cunglq LAPACK_GLOBAL(cunglq, CUNGLQ)
-#define LAPACK_zunglq LAPACK_GLOBAL(zunglq, ZUNGLQ)
-#define LAPACK_cunmlq LAPACK_GLOBAL(cunmlq, CUNMLQ)
-#define LAPACK_zunmlq LAPACK_GLOBAL(zunmlq, ZUNMLQ)
-#define LAPACK_sgeqlf LAPACK_GLOBAL(sgeqlf, SGEQLF)
-#define LAPACK_dgeqlf LAPACK_GLOBAL(dgeqlf, DGEQLF)
-#define LAPACK_cgeqlf LAPACK_GLOBAL(cgeqlf, CGEQLF)
-#define LAPACK_zgeqlf LAPACK_GLOBAL(zgeqlf, ZGEQLF)
-#define LAPACK_sorgql LAPACK_GLOBAL(sorgql, SORGQL)
-#define LAPACK_dorgql LAPACK_GLOBAL(dorgql, DORGQL)
-#define LAPACK_cungql LAPACK_GLOBAL(cungql, CUNGQL)
-#define LAPACK_zungql LAPACK_GLOBAL(zungql, ZUNGQL)
-#define LAPACK_sormql LAPACK_GLOBAL(sormql, SORMQL)
-#define LAPACK_dormql LAPACK_GLOBAL(dormql, DORMQL)
-#define LAPACK_cunmql LAPACK_GLOBAL(cunmql, CUNMQL)
-#define LAPACK_zunmql LAPACK_GLOBAL(zunmql, ZUNMQL)
-#define LAPACK_sgerqf LAPACK_GLOBAL(sgerqf, SGERQF)
-#define LAPACK_dgerqf LAPACK_GLOBAL(dgerqf, DGERQF)
-#define LAPACK_cgerqf LAPACK_GLOBAL(cgerqf, CGERQF)
-#define LAPACK_zgerqf LAPACK_GLOBAL(zgerqf, ZGERQF)
-#define LAPACK_sorgrq LAPACK_GLOBAL(sorgrq, SORGRQ)
-#define LAPACK_dorgrq LAPACK_GLOBAL(dorgrq, DORGRQ)
-#define LAPACK_cungrq LAPACK_GLOBAL(cungrq, CUNGRQ)
-#define LAPACK_zungrq LAPACK_GLOBAL(zungrq, ZUNGRQ)
-#define LAPACK_sormrq LAPACK_GLOBAL(sormrq, SORMRQ)
-#define LAPACK_dormrq LAPACK_GLOBAL(dormrq, DORMRQ)
-#define LAPACK_cunmrq LAPACK_GLOBAL(cunmrq, CUNMRQ)
-#define LAPACK_zunmrq LAPACK_GLOBAL(zunmrq, ZUNMRQ)
-#define LAPACK_stzrzf LAPACK_GLOBAL(stzrzf, STZRZF)
-#define LAPACK_dtzrzf LAPACK_GLOBAL(dtzrzf, DTZRZF)
-#define LAPACK_ctzrzf LAPACK_GLOBAL(ctzrzf, CTZRZF)
-#define LAPACK_ztzrzf LAPACK_GLOBAL(ztzrzf, ZTZRZF)
-#define LAPACK_sormrz LAPACK_GLOBAL(sormrz, SORMRZ)
-#define LAPACK_dormrz LAPACK_GLOBAL(dormrz, DORMRZ)
-#define LAPACK_cunmrz LAPACK_GLOBAL(cunmrz, CUNMRZ)
-#define LAPACK_zunmrz LAPACK_GLOBAL(zunmrz, ZUNMRZ)
-#define LAPACK_sggqrf LAPACK_GLOBAL(sggqrf, SGGQRF)
-#define LAPACK_dggqrf LAPACK_GLOBAL(dggqrf, DGGQRF)
-#define LAPACK_cggqrf LAPACK_GLOBAL(cggqrf, CGGQRF)
-#define LAPACK_zggqrf LAPACK_GLOBAL(zggqrf, ZGGQRF)
-#define LAPACK_sggrqf LAPACK_GLOBAL(sggrqf, SGGRQF)
-#define LAPACK_dggrqf LAPACK_GLOBAL(dggrqf, DGGRQF)
-#define LAPACK_cggrqf LAPACK_GLOBAL(cggrqf, CGGRQF)
-#define LAPACK_zggrqf LAPACK_GLOBAL(zggrqf, ZGGRQF)
-#define LAPACK_sgebrd LAPACK_GLOBAL(sgebrd, SGEBRD)
-#define LAPACK_dgebrd LAPACK_GLOBAL(dgebrd, DGEBRD)
-#define LAPACK_cgebrd LAPACK_GLOBAL(cgebrd, CGEBRD)
-#define LAPACK_zgebrd LAPACK_GLOBAL(zgebrd, ZGEBRD)
-#define LAPACK_sgbbrd LAPACK_GLOBAL(sgbbrd, SGBBRD)
-#define LAPACK_dgbbrd LAPACK_GLOBAL(dgbbrd, DGBBRD)
-#define LAPACK_cgbbrd LAPACK_GLOBAL(cgbbrd, CGBBRD)
-#define LAPACK_zgbbrd LAPACK_GLOBAL(zgbbrd, ZGBBRD)
-#define LAPACK_sorgbr LAPACK_GLOBAL(sorgbr, SORGBR)
-#define LAPACK_dorgbr LAPACK_GLOBAL(dorgbr, DORGBR)
-#define LAPACK_sormbr LAPACK_GLOBAL(sormbr, SORMBR)
-#define LAPACK_dormbr LAPACK_GLOBAL(dormbr, DORMBR)
-#define LAPACK_cungbr LAPACK_GLOBAL(cungbr, CUNGBR)
-#define LAPACK_zungbr LAPACK_GLOBAL(zungbr, ZUNGBR)
-#define LAPACK_cunmbr LAPACK_GLOBAL(cunmbr, CUNMBR)
-#define LAPACK_zunmbr LAPACK_GLOBAL(zunmbr, ZUNMBR)
-#define LAPACK_sbdsqr LAPACK_GLOBAL(sbdsqr, SBDSQR)
-#define LAPACK_dbdsqr LAPACK_GLOBAL(dbdsqr, DBDSQR)
-#define LAPACK_cbdsqr LAPACK_GLOBAL(cbdsqr, CBDSQR)
-#define LAPACK_zbdsqr LAPACK_GLOBAL(zbdsqr, ZBDSQR)
-#define LAPACK_sbdsdc LAPACK_GLOBAL(sbdsdc, SBDSDC)
-#define LAPACK_dbdsdc LAPACK_GLOBAL(dbdsdc, DBDSDC)
-#define LAPACK_ssytrd LAPACK_GLOBAL(ssytrd, SSYTRD)
-#define LAPACK_dsytrd LAPACK_GLOBAL(dsytrd, DSYTRD)
-#define LAPACK_sorgtr LAPACK_GLOBAL(sorgtr, SORGTR)
-#define LAPACK_dorgtr LAPACK_GLOBAL(dorgtr, DORGTR)
-#define LAPACK_sormtr LAPACK_GLOBAL(sormtr, SORMTR)
-#define LAPACK_dormtr LAPACK_GLOBAL(dormtr, DORMTR)
-#define LAPACK_chetrd LAPACK_GLOBAL(chetrd, CHETRD)
-#define LAPACK_zhetrd LAPACK_GLOBAL(zhetrd, ZHETRD)
-#define LAPACK_cungtr LAPACK_GLOBAL(cungtr, CUNGTR)
-#define LAPACK_zungtr LAPACK_GLOBAL(zungtr, ZUNGTR)
-#define LAPACK_cunmtr LAPACK_GLOBAL(cunmtr, CUNMTR)
-#define LAPACK_zunmtr LAPACK_GLOBAL(zunmtr, ZUNMTR)
-#define LAPACK_ssptrd LAPACK_GLOBAL(ssptrd, SSPTRD)
-#define LAPACK_dsptrd LAPACK_GLOBAL(dsptrd, DSPTRD)
-#define LAPACK_sopgtr LAPACK_GLOBAL(sopgtr, SOPGTR)
-#define LAPACK_dopgtr LAPACK_GLOBAL(dopgtr, DOPGTR)
-#define LAPACK_sopmtr LAPACK_GLOBAL(sopmtr, SOPMTR)
-#define LAPACK_dopmtr LAPACK_GLOBAL(dopmtr, DOPMTR)
-#define LAPACK_chptrd LAPACK_GLOBAL(chptrd, CHPTRD)
-#define LAPACK_zhptrd LAPACK_GLOBAL(zhptrd, ZHPTRD)
-#define LAPACK_cupgtr LAPACK_GLOBAL(cupgtr, CUPGTR)
-#define LAPACK_zupgtr LAPACK_GLOBAL(zupgtr, ZUPGTR)
-#define LAPACK_cupmtr LAPACK_GLOBAL(cupmtr, CUPMTR)
-#define LAPACK_zupmtr LAPACK_GLOBAL(zupmtr, ZUPMTR)
-#define LAPACK_ssbtrd LAPACK_GLOBAL(ssbtrd, SSBTRD)
-#define LAPACK_dsbtrd LAPACK_GLOBAL(dsbtrd, DSBTRD)
-#define LAPACK_chbtrd LAPACK_GLOBAL(chbtrd, CHBTRD)
-#define LAPACK_zhbtrd LAPACK_GLOBAL(zhbtrd, ZHBTRD)
-#define LAPACK_ssterf LAPACK_GLOBAL(ssterf, SSTERF)
-#define LAPACK_dsterf LAPACK_GLOBAL(dsterf, DSTERF)
-#define LAPACK_ssteqr LAPACK_GLOBAL(ssteqr, SSTEQR)
-#define LAPACK_dsteqr LAPACK_GLOBAL(dsteqr, DSTEQR)
-#define LAPACK_csteqr LAPACK_GLOBAL(csteqr, CSTEQR)
-#define LAPACK_zsteqr LAPACK_GLOBAL(zsteqr, ZSTEQR)
-#define LAPACK_sstemr LAPACK_GLOBAL(sstemr, SSTEMR)
-#define LAPACK_dstemr LAPACK_GLOBAL(dstemr, DSTEMR)
-#define LAPACK_cstemr LAPACK_GLOBAL(cstemr, CSTEMR)
-#define LAPACK_zstemr LAPACK_GLOBAL(zstemr, ZSTEMR)
-#define LAPACK_sstedc LAPACK_GLOBAL(sstedc, SSTEDC)
-#define LAPACK_dstedc LAPACK_GLOBAL(dstedc, DSTEDC)
-#define LAPACK_cstedc LAPACK_GLOBAL(cstedc, CSTEDC)
-#define LAPACK_zstedc LAPACK_GLOBAL(zstedc, ZSTEDC)
-#define LAPACK_sstegr LAPACK_GLOBAL(sstegr, SSTEGR)
-#define LAPACK_dstegr LAPACK_GLOBAL(dstegr, DSTEGR)
-#define LAPACK_cstegr LAPACK_GLOBAL(cstegr, CSTEGR)
-#define LAPACK_zstegr LAPACK_GLOBAL(zstegr, ZSTEGR)
-#define LAPACK_spteqr LAPACK_GLOBAL(spteqr, SPTEQR)
-#define LAPACK_dpteqr LAPACK_GLOBAL(dpteqr, DPTEQR)
-#define LAPACK_cpteqr LAPACK_GLOBAL(cpteqr, CPTEQR)
-#define LAPACK_zpteqr LAPACK_GLOBAL(zpteqr, ZPTEQR)
-#define LAPACK_sstebz LAPACK_GLOBAL(sstebz, SSTEBZ)
-#define LAPACK_dstebz LAPACK_GLOBAL(dstebz, DSTEBZ)
-#define LAPACK_sstein LAPACK_GLOBAL(sstein, SSTEIN)
-#define LAPACK_dstein LAPACK_GLOBAL(dstein, DSTEIN)
-#define LAPACK_cstein LAPACK_GLOBAL(cstein, CSTEIN)
-#define LAPACK_zstein LAPACK_GLOBAL(zstein, ZSTEIN)
-#define LAPACK_sdisna LAPACK_GLOBAL(sdisna, SDISNA)
-#define LAPACK_ddisna LAPACK_GLOBAL(ddisna, DDISNA)
-#define LAPACK_ssygst LAPACK_GLOBAL(ssygst, SSYGST)
-#define LAPACK_dsygst LAPACK_GLOBAL(dsygst, DSYGST)
-#define LAPACK_chegst LAPACK_GLOBAL(chegst, CHEGST)
-#define LAPACK_zhegst LAPACK_GLOBAL(zhegst, ZHEGST)
-#define LAPACK_sspgst LAPACK_GLOBAL(sspgst, SSPGST)
-#define LAPACK_dspgst LAPACK_GLOBAL(dspgst, DSPGST)
-#define LAPACK_chpgst LAPACK_GLOBAL(chpgst, CHPGST)
-#define LAPACK_zhpgst LAPACK_GLOBAL(zhpgst, ZHPGST)
-#define LAPACK_ssbgst LAPACK_GLOBAL(ssbgst, SSBGST)
-#define LAPACK_dsbgst LAPACK_GLOBAL(dsbgst, DSBGST)
-#define LAPACK_chbgst LAPACK_GLOBAL(chbgst, CHBGST)
-#define LAPACK_zhbgst LAPACK_GLOBAL(zhbgst, ZHBGST)
-#define LAPACK_spbstf LAPACK_GLOBAL(spbstf, SPBSTF)
-#define LAPACK_dpbstf LAPACK_GLOBAL(dpbstf, DPBSTF)
-#define LAPACK_cpbstf LAPACK_GLOBAL(cpbstf, CPBSTF)
-#define LAPACK_zpbstf LAPACK_GLOBAL(zpbstf, ZPBSTF)
-#define LAPACK_sgehrd LAPACK_GLOBAL(sgehrd, SGEHRD)
-#define LAPACK_dgehrd LAPACK_GLOBAL(dgehrd, DGEHRD)
-#define LAPACK_cgehrd LAPACK_GLOBAL(cgehrd, CGEHRD)
-#define LAPACK_zgehrd LAPACK_GLOBAL(zgehrd, ZGEHRD)
-#define LAPACK_sorghr LAPACK_GLOBAL(sorghr, SORGHR)
-#define LAPACK_dorghr LAPACK_GLOBAL(dorghr, DORGHR)
-#define LAPACK_sormhr LAPACK_GLOBAL(sormhr, SORMHR)
-#define LAPACK_dormhr LAPACK_GLOBAL(dormhr, DORMHR)
-#define LAPACK_cunghr LAPACK_GLOBAL(cunghr, CUNGHR)
-#define LAPACK_zunghr LAPACK_GLOBAL(zunghr, ZUNGHR)
-#define LAPACK_cunmhr LAPACK_GLOBAL(cunmhr, CUNMHR)
-#define LAPACK_zunmhr LAPACK_GLOBAL(zunmhr, ZUNMHR)
-#define LAPACK_sgebal LAPACK_GLOBAL(sgebal, SGEBAL)
-#define LAPACK_dgebal LAPACK_GLOBAL(dgebal, DGEBAL)
-#define LAPACK_cgebal LAPACK_GLOBAL(cgebal, CGEBAL)
-#define LAPACK_zgebal LAPACK_GLOBAL(zgebal, ZGEBAL)
-#define LAPACK_sgebak LAPACK_GLOBAL(sgebak, SGEBAK)
-#define LAPACK_dgebak LAPACK_GLOBAL(dgebak, DGEBAK)
-#define LAPACK_cgebak LAPACK_GLOBAL(cgebak, CGEBAK)
-#define LAPACK_zgebak LAPACK_GLOBAL(zgebak, ZGEBAK)
-#define LAPACK_shseqr LAPACK_GLOBAL(shseqr, SHSEQR)
-#define LAPACK_dhseqr LAPACK_GLOBAL(dhseqr, DHSEQR)
-#define LAPACK_chseqr LAPACK_GLOBAL(chseqr, CHSEQR)
-#define LAPACK_zhseqr LAPACK_GLOBAL(zhseqr, ZHSEQR)
-#define LAPACK_shsein LAPACK_GLOBAL(shsein, SHSEIN)
-#define LAPACK_dhsein LAPACK_GLOBAL(dhsein, DHSEIN)
-#define LAPACK_chsein LAPACK_GLOBAL(chsein, CHSEIN)
-#define LAPACK_zhsein LAPACK_GLOBAL(zhsein, ZHSEIN)
-#define LAPACK_strevc LAPACK_GLOBAL(strevc, STREVC)
-#define LAPACK_dtrevc LAPACK_GLOBAL(dtrevc, DTREVC)
-#define LAPACK_ctrevc LAPACK_GLOBAL(ctrevc, CTREVC)
-#define LAPACK_ztrevc LAPACK_GLOBAL(ztrevc, ZTREVC)
-#define LAPACK_strsna LAPACK_GLOBAL(strsna, STRSNA)
-#define LAPACK_dtrsna LAPACK_GLOBAL(dtrsna, DTRSNA)
-#define LAPACK_ctrsna LAPACK_GLOBAL(ctrsna, CTRSNA)
-#define LAPACK_ztrsna LAPACK_GLOBAL(ztrsna, ZTRSNA)
-#define LAPACK_strexc LAPACK_GLOBAL(strexc, STREXC)
-#define LAPACK_dtrexc LAPACK_GLOBAL(dtrexc, DTREXC)
-#define LAPACK_ctrexc LAPACK_GLOBAL(ctrexc, CTREXC)
-#define LAPACK_ztrexc LAPACK_GLOBAL(ztrexc, ZTREXC)
-#define LAPACK_strsen LAPACK_GLOBAL(strsen, STRSEN)
-#define LAPACK_dtrsen LAPACK_GLOBAL(dtrsen, DTRSEN)
-#define LAPACK_ctrsen LAPACK_GLOBAL(ctrsen, CTRSEN)
-#define LAPACK_ztrsen LAPACK_GLOBAL(ztrsen, ZTRSEN)
-#define LAPACK_strsyl LAPACK_GLOBAL(strsyl, STRSYL)
-#define LAPACK_dtrsyl LAPACK_GLOBAL(dtrsyl, DTRSYL)
-#define LAPACK_ctrsyl LAPACK_GLOBAL(ctrsyl, CTRSYL)
-#define LAPACK_ztrsyl LAPACK_GLOBAL(ztrsyl, ZTRSYL)
-#define LAPACK_sgghrd LAPACK_GLOBAL(sgghrd, SGGHRD)
-#define LAPACK_dgghrd LAPACK_GLOBAL(dgghrd, DGGHRD)
-#define LAPACK_cgghrd LAPACK_GLOBAL(cgghrd, CGGHRD)
-#define LAPACK_zgghrd LAPACK_GLOBAL(zgghrd, ZGGHRD)
-#define LAPACK_sggbal LAPACK_GLOBAL(sggbal, SGGBAL)
-#define LAPACK_dggbal LAPACK_GLOBAL(dggbal, DGGBAL)
-#define LAPACK_cggbal LAPACK_GLOBAL(cggbal, CGGBAL)
-#define LAPACK_zggbal LAPACK_GLOBAL(zggbal, ZGGBAL)
-#define LAPACK_sggbak LAPACK_GLOBAL(sggbak, SGGBAK)
-#define LAPACK_dggbak LAPACK_GLOBAL(dggbak, DGGBAK)
-#define LAPACK_cggbak LAPACK_GLOBAL(cggbak, CGGBAK)
-#define LAPACK_zggbak LAPACK_GLOBAL(zggbak, ZGGBAK)
-#define LAPACK_shgeqz LAPACK_GLOBAL(shgeqz, SHGEQZ)
-#define LAPACK_dhgeqz LAPACK_GLOBAL(dhgeqz, DHGEQZ)
-#define LAPACK_chgeqz LAPACK_GLOBAL(chgeqz, CHGEQZ)
-#define LAPACK_zhgeqz LAPACK_GLOBAL(zhgeqz, ZHGEQZ)
-#define LAPACK_stgevc LAPACK_GLOBAL(stgevc, STGEVC)
-#define LAPACK_dtgevc LAPACK_GLOBAL(dtgevc, DTGEVC)
-#define LAPACK_ctgevc LAPACK_GLOBAL(ctgevc, CTGEVC)
-#define LAPACK_ztgevc LAPACK_GLOBAL(ztgevc, ZTGEVC)
-#define LAPACK_stgexc LAPACK_GLOBAL(stgexc, STGEXC)
-#define LAPACK_dtgexc LAPACK_GLOBAL(dtgexc, DTGEXC)
-#define LAPACK_ctgexc LAPACK_GLOBAL(ctgexc, CTGEXC)
-#define LAPACK_ztgexc LAPACK_GLOBAL(ztgexc, ZTGEXC)
-#define LAPACK_stgsen LAPACK_GLOBAL(stgsen, STGSEN)
-#define LAPACK_dtgsen LAPACK_GLOBAL(dtgsen, DTGSEN)
-#define LAPACK_ctgsen LAPACK_GLOBAL(ctgsen, CTGSEN)
-#define LAPACK_ztgsen LAPACK_GLOBAL(ztgsen, ZTGSEN)
-#define LAPACK_stgsyl LAPACK_GLOBAL(stgsyl, STGSYL)
-#define LAPACK_dtgsyl LAPACK_GLOBAL(dtgsyl, DTGSYL)
-#define LAPACK_ctgsyl LAPACK_GLOBAL(ctgsyl, CTGSYL)
-#define LAPACK_ztgsyl LAPACK_GLOBAL(ztgsyl, ZTGSYL)
-#define LAPACK_stgsna LAPACK_GLOBAL(stgsna, STGSNA)
-#define LAPACK_dtgsna LAPACK_GLOBAL(dtgsna, DTGSNA)
-#define LAPACK_ctgsna LAPACK_GLOBAL(ctgsna, CTGSNA)
-#define LAPACK_ztgsna LAPACK_GLOBAL(ztgsna, ZTGSNA)
-#define LAPACK_sggsvp LAPACK_GLOBAL(sggsvp, SGGSVP)
-#define LAPACK_dggsvp LAPACK_GLOBAL(dggsvp, DGGSVP)
-#define LAPACK_cggsvp LAPACK_GLOBAL(cggsvp, CGGSVP)
-#define LAPACK_zggsvp LAPACK_GLOBAL(zggsvp, ZGGSVP)
-#define LAPACK_stgsja LAPACK_GLOBAL(stgsja, STGSJA)
-#define LAPACK_dtgsja LAPACK_GLOBAL(dtgsja, DTGSJA)
-#define LAPACK_ctgsja LAPACK_GLOBAL(ctgsja, CTGSJA)
-#define LAPACK_ztgsja LAPACK_GLOBAL(ztgsja, ZTGSJA)
-#define LAPACK_sgels LAPACK_GLOBAL(sgels, SGELS)
-#define LAPACK_dgels LAPACK_GLOBAL(dgels, DGELS)
-#define LAPACK_cgels LAPACK_GLOBAL(cgels, CGELS)
-#define LAPACK_zgels LAPACK_GLOBAL(zgels, ZGELS)
-#define LAPACK_sgelsy LAPACK_GLOBAL(sgelsy, SGELSY)
-#define LAPACK_dgelsy LAPACK_GLOBAL(dgelsy, DGELSY)
-#define LAPACK_cgelsy LAPACK_GLOBAL(cgelsy, CGELSY)
-#define LAPACK_zgelsy LAPACK_GLOBAL(zgelsy, ZGELSY)
-#define LAPACK_sgelss LAPACK_GLOBAL(sgelss, SGELSS)
-#define LAPACK_dgelss LAPACK_GLOBAL(dgelss, DGELSS)
-#define LAPACK_cgelss LAPACK_GLOBAL(cgelss, CGELSS)
-#define LAPACK_zgelss LAPACK_GLOBAL(zgelss, ZGELSS)
-#define LAPACK_sgelsd LAPACK_GLOBAL(sgelsd, SGELSD)
-#define LAPACK_dgelsd LAPACK_GLOBAL(dgelsd, DGELSD)
-#define LAPACK_cgelsd LAPACK_GLOBAL(cgelsd, CGELSD)
-#define LAPACK_zgelsd LAPACK_GLOBAL(zgelsd, ZGELSD)
-#define LAPACK_sgglse LAPACK_GLOBAL(sgglse, SGGLSE)
-#define LAPACK_dgglse LAPACK_GLOBAL(dgglse, DGGLSE)
-#define LAPACK_cgglse LAPACK_GLOBAL(cgglse, CGGLSE)
-#define LAPACK_zgglse LAPACK_GLOBAL(zgglse, ZGGLSE)
-#define LAPACK_sggglm LAPACK_GLOBAL(sggglm, SGGGLM)
-#define LAPACK_dggglm LAPACK_GLOBAL(dggglm, DGGGLM)
-#define LAPACK_cggglm LAPACK_GLOBAL(cggglm, CGGGLM)
-#define LAPACK_zggglm LAPACK_GLOBAL(zggglm, ZGGGLM)
-#define LAPACK_ssyev LAPACK_GLOBAL(ssyev, SSYEV)
-#define LAPACK_dsyev LAPACK_GLOBAL(dsyev, DSYEV)
-#define LAPACK_cheev LAPACK_GLOBAL(cheev, CHEEV)
-#define LAPACK_zheev LAPACK_GLOBAL(zheev, ZHEEV)
-#define LAPACK_ssyevd LAPACK_GLOBAL(ssyevd, SSYEVD)
-#define LAPACK_dsyevd LAPACK_GLOBAL(dsyevd, DSYEVD)
-#define LAPACK_cheevd LAPACK_GLOBAL(cheevd, CHEEVD)
-#define LAPACK_zheevd LAPACK_GLOBAL(zheevd, ZHEEVD)
-#define LAPACK_ssyevx LAPACK_GLOBAL(ssyevx, SSYEVX)
-#define LAPACK_dsyevx LAPACK_GLOBAL(dsyevx, DSYEVX)
-#define LAPACK_cheevx LAPACK_GLOBAL(cheevx, CHEEVX)
-#define LAPACK_zheevx LAPACK_GLOBAL(zheevx, ZHEEVX)
-#define LAPACK_ssyevr LAPACK_GLOBAL(ssyevr, SSYEVR)
-#define LAPACK_dsyevr LAPACK_GLOBAL(dsyevr, DSYEVR)
-#define LAPACK_cheevr LAPACK_GLOBAL(cheevr, CHEEVR)
-#define LAPACK_zheevr LAPACK_GLOBAL(zheevr, ZHEEVR)
-#define LAPACK_sspev LAPACK_GLOBAL(sspev, SSPEV)
-#define LAPACK_dspev LAPACK_GLOBAL(dspev, DSPEV)
-#define LAPACK_chpev LAPACK_GLOBAL(chpev, CHPEV)
-#define LAPACK_zhpev LAPACK_GLOBAL(zhpev, ZHPEV)
-#define LAPACK_sspevd LAPACK_GLOBAL(sspevd, SSPEVD)
-#define LAPACK_dspevd LAPACK_GLOBAL(dspevd, DSPEVD)
-#define LAPACK_chpevd LAPACK_GLOBAL(chpevd, CHPEVD)
-#define LAPACK_zhpevd LAPACK_GLOBAL(zhpevd, ZHPEVD)
-#define LAPACK_sspevx LAPACK_GLOBAL(sspevx, SSPEVX)
-#define LAPACK_dspevx LAPACK_GLOBAL(dspevx, DSPEVX)
-#define LAPACK_chpevx LAPACK_GLOBAL(chpevx, CHPEVX)
-#define LAPACK_zhpevx LAPACK_GLOBAL(zhpevx, ZHPEVX)
-#define LAPACK_ssbev LAPACK_GLOBAL(ssbev, SSBEV)
-#define LAPACK_dsbev LAPACK_GLOBAL(dsbev, DSBEV)
-#define LAPACK_chbev LAPACK_GLOBAL(chbev, CHBEV)
-#define LAPACK_zhbev LAPACK_GLOBAL(zhbev, ZHBEV)
-#define LAPACK_ssbevd LAPACK_GLOBAL(ssbevd, SSBEVD)
-#define LAPACK_dsbevd LAPACK_GLOBAL(dsbevd, DSBEVD)
-#define LAPACK_chbevd LAPACK_GLOBAL(chbevd, CHBEVD)
-#define LAPACK_zhbevd LAPACK_GLOBAL(zhbevd, ZHBEVD)
-#define LAPACK_ssbevx LAPACK_GLOBAL(ssbevx, SSBEVX)
-#define LAPACK_dsbevx LAPACK_GLOBAL(dsbevx, DSBEVX)
-#define LAPACK_chbevx LAPACK_GLOBAL(chbevx, CHBEVX)
-#define LAPACK_zhbevx LAPACK_GLOBAL(zhbevx, ZHBEVX)
-#define LAPACK_sstev LAPACK_GLOBAL(sstev, SSTEV)
-#define LAPACK_dstev LAPACK_GLOBAL(dstev, DSTEV)
-#define LAPACK_sstevd LAPACK_GLOBAL(sstevd, SSTEVD)
-#define LAPACK_dstevd LAPACK_GLOBAL(dstevd, DSTEVD)
-#define LAPACK_sstevx LAPACK_GLOBAL(sstevx, SSTEVX)
-#define LAPACK_dstevx LAPACK_GLOBAL(dstevx, DSTEVX)
-#define LAPACK_sstevr LAPACK_GLOBAL(sstevr, SSTEVR)
-#define LAPACK_dstevr LAPACK_GLOBAL(dstevr, DSTEVR)
-#define LAPACK_sgees LAPACK_GLOBAL(sgees, SGEES)
-#define LAPACK_dgees LAPACK_GLOBAL(dgees, DGEES)
-#define LAPACK_cgees LAPACK_GLOBAL(cgees, CGEES)
-#define LAPACK_zgees LAPACK_GLOBAL(zgees, ZGEES)
-#define LAPACK_sgeesx LAPACK_GLOBAL(sgeesx, SGEESX)
-#define LAPACK_dgeesx LAPACK_GLOBAL(dgeesx, DGEESX)
-#define LAPACK_cgeesx LAPACK_GLOBAL(cgeesx, CGEESX)
-#define LAPACK_zgeesx LAPACK_GLOBAL(zgeesx, ZGEESX)
-#define LAPACK_sgeev LAPACK_GLOBAL(sgeev, SGEEV)
-#define LAPACK_dgeev LAPACK_GLOBAL(dgeev, DGEEV)
-#define LAPACK_cgeev LAPACK_GLOBAL(cgeev, CGEEV)
-#define LAPACK_zgeev LAPACK_GLOBAL(zgeev, ZGEEV)
-#define LAPACK_sgeevx LAPACK_GLOBAL(sgeevx, SGEEVX)
-#define LAPACK_dgeevx LAPACK_GLOBAL(dgeevx, DGEEVX)
-#define LAPACK_cgeevx LAPACK_GLOBAL(cgeevx, CGEEVX)
-#define LAPACK_zgeevx LAPACK_GLOBAL(zgeevx, ZGEEVX)
-#define LAPACK_sgesvd LAPACK_GLOBAL(sgesvd, SGESVD)
-#define LAPACK_dgesvd LAPACK_GLOBAL(dgesvd, DGESVD)
-#define LAPACK_cgesvd LAPACK_GLOBAL(cgesvd, CGESVD)
-#define LAPACK_zgesvd LAPACK_GLOBAL(zgesvd, ZGESVD)
-#define LAPACK_sgesdd LAPACK_GLOBAL(sgesdd, SGESDD)
-#define LAPACK_dgesdd LAPACK_GLOBAL(dgesdd, DGESDD)
-#define LAPACK_cgesdd LAPACK_GLOBAL(cgesdd, CGESDD)
-#define LAPACK_zgesdd LAPACK_GLOBAL(zgesdd, ZGESDD)
-#define LAPACK_dgejsv LAPACK_GLOBAL(dgejsv, DGEJSV)
-#define LAPACK_sgejsv LAPACK_GLOBAL(sgejsv, SGEJSV)
-#define LAPACK_dgesvj LAPACK_GLOBAL(dgesvj, DGESVJ)
-#define LAPACK_sgesvj LAPACK_GLOBAL(sgesvj, SGESVJ)
-#define LAPACK_sggsvd LAPACK_GLOBAL(sggsvd, SGGSVD)
-#define LAPACK_dggsvd LAPACK_GLOBAL(dggsvd, DGGSVD)
-#define LAPACK_cggsvd LAPACK_GLOBAL(cggsvd, CGGSVD)
-#define LAPACK_zggsvd LAPACK_GLOBAL(zggsvd, ZGGSVD)
-#define LAPACK_ssygv LAPACK_GLOBAL(ssygv, SSYGV)
-#define LAPACK_dsygv LAPACK_GLOBAL(dsygv, DSYGV)
-#define LAPACK_chegv LAPACK_GLOBAL(chegv, CHEGV)
-#define LAPACK_zhegv LAPACK_GLOBAL(zhegv, ZHEGV)
-#define LAPACK_ssygvd LAPACK_GLOBAL(ssygvd, SSYGVD)
-#define LAPACK_dsygvd LAPACK_GLOBAL(dsygvd, DSYGVD)
-#define LAPACK_chegvd LAPACK_GLOBAL(chegvd, CHEGVD)
-#define LAPACK_zhegvd LAPACK_GLOBAL(zhegvd, ZHEGVD)
-#define LAPACK_ssygvx LAPACK_GLOBAL(ssygvx, SSYGVX)
-#define LAPACK_dsygvx LAPACK_GLOBAL(dsygvx, DSYGVX)
-#define LAPACK_chegvx LAPACK_GLOBAL(chegvx, CHEGVX)
-#define LAPACK_zhegvx LAPACK_GLOBAL(zhegvx, ZHEGVX)
-#define LAPACK_sspgv LAPACK_GLOBAL(sspgv, SSPGV)
-#define LAPACK_dspgv LAPACK_GLOBAL(dspgv, DSPGV)
-#define LAPACK_chpgv LAPACK_GLOBAL(chpgv, CHPGV)
-#define LAPACK_zhpgv LAPACK_GLOBAL(zhpgv, ZHPGV)
-#define LAPACK_sspgvd LAPACK_GLOBAL(sspgvd, SSPGVD)
-#define LAPACK_dspgvd LAPACK_GLOBAL(dspgvd, DSPGVD)
-#define LAPACK_chpgvd LAPACK_GLOBAL(chpgvd, CHPGVD)
-#define LAPACK_zhpgvd LAPACK_GLOBAL(zhpgvd, ZHPGVD)
-#define LAPACK_sspgvx LAPACK_GLOBAL(sspgvx, SSPGVX)
-#define LAPACK_dspgvx LAPACK_GLOBAL(dspgvx, DSPGVX)
-#define LAPACK_chpgvx LAPACK_GLOBAL(chpgvx, CHPGVX)
-#define LAPACK_zhpgvx LAPACK_GLOBAL(zhpgvx, ZHPGVX)
-#define LAPACK_ssbgv LAPACK_GLOBAL(ssbgv, SSBGV)
-#define LAPACK_dsbgv LAPACK_GLOBAL(dsbgv, DSBGV)
-#define LAPACK_chbgv LAPACK_GLOBAL(chbgv, CHBGV)
-#define LAPACK_zhbgv LAPACK_GLOBAL(zhbgv, ZHBGV)
-#define LAPACK_ssbgvd LAPACK_GLOBAL(ssbgvd, SSBGVD)
-#define LAPACK_dsbgvd LAPACK_GLOBAL(dsbgvd, DSBGVD)
-#define LAPACK_chbgvd LAPACK_GLOBAL(chbgvd, CHBGVD)
-#define LAPACK_zhbgvd LAPACK_GLOBAL(zhbgvd, ZHBGVD)
-#define LAPACK_ssbgvx LAPACK_GLOBAL(ssbgvx, SSBGVX)
-#define LAPACK_dsbgvx LAPACK_GLOBAL(dsbgvx, DSBGVX)
-#define LAPACK_chbgvx LAPACK_GLOBAL(chbgvx, CHBGVX)
-#define LAPACK_zhbgvx LAPACK_GLOBAL(zhbgvx, ZHBGVX)
-#define LAPACK_sgges LAPACK_GLOBAL(sgges, SGGES)
-#define LAPACK_dgges LAPACK_GLOBAL(dgges, DGGES)
-#define LAPACK_cgges LAPACK_GLOBAL(cgges, CGGES)
-#define LAPACK_zgges LAPACK_GLOBAL(zgges, ZGGES)
-#define LAPACK_sggesx LAPACK_GLOBAL(sggesx, SGGESX)
-#define LAPACK_dggesx LAPACK_GLOBAL(dggesx, DGGESX)
-#define LAPACK_cggesx LAPACK_GLOBAL(cggesx, CGGESX)
-#define LAPACK_zggesx LAPACK_GLOBAL(zggesx, ZGGESX)
-#define LAPACK_sggev LAPACK_GLOBAL(sggev, SGGEV)
-#define LAPACK_dggev LAPACK_GLOBAL(dggev, DGGEV)
-#define LAPACK_cggev LAPACK_GLOBAL(cggev, CGGEV)
-#define LAPACK_zggev LAPACK_GLOBAL(zggev, ZGGEV)
-#define LAPACK_sggevx LAPACK_GLOBAL(sggevx, SGGEVX)
-#define LAPACK_dggevx LAPACK_GLOBAL(dggevx, DGGEVX)
-#define LAPACK_cggevx LAPACK_GLOBAL(cggevx, CGGEVX)
-#define LAPACK_zggevx LAPACK_GLOBAL(zggevx, ZGGEVX)
-#define LAPACK_dsfrk LAPACK_GLOBAL(dsfrk, DSFRK)
-#define LAPACK_ssfrk LAPACK_GLOBAL(ssfrk, SSFRK)
-#define LAPACK_zhfrk LAPACK_GLOBAL(zhfrk, ZHFRK)
-#define LAPACK_chfrk LAPACK_GLOBAL(chfrk, CHFRK)
-#define LAPACK_dtfsm LAPACK_GLOBAL(dtfsm, DTFSM)
-#define LAPACK_stfsm LAPACK_GLOBAL(stfsm, STFSM)
-#define LAPACK_ztfsm LAPACK_GLOBAL(ztfsm, ZTFSM)
-#define LAPACK_ctfsm LAPACK_GLOBAL(ctfsm, CTFSM)
-#define LAPACK_dtfttp LAPACK_GLOBAL(dtfttp, DTFTTP)
-#define LAPACK_stfttp LAPACK_GLOBAL(stfttp, STFTTP)
-#define LAPACK_ztfttp LAPACK_GLOBAL(ztfttp, ZTFTTP)
-#define LAPACK_ctfttp LAPACK_GLOBAL(ctfttp, CTFTTP)
-#define LAPACK_dtfttr LAPACK_GLOBAL(dtfttr, DTFTTR)
-#define LAPACK_stfttr LAPACK_GLOBAL(stfttr, STFTTR)
-#define LAPACK_ztfttr LAPACK_GLOBAL(ztfttr, ZTFTTR)
-#define LAPACK_ctfttr LAPACK_GLOBAL(ctfttr, CTFTTR)
-#define LAPACK_dtpttf LAPACK_GLOBAL(dtpttf, DTPTTF)
-#define LAPACK_stpttf LAPACK_GLOBAL(stpttf, STPTTF)
-#define LAPACK_ztpttf LAPACK_GLOBAL(ztpttf, ZTPTTF)
-#define LAPACK_ctpttf LAPACK_GLOBAL(ctpttf, CTPTTF)
-#define LAPACK_dtpttr LAPACK_GLOBAL(dtpttr, DTPTTR)
-#define LAPACK_stpttr LAPACK_GLOBAL(stpttr, STPTTR)
-#define LAPACK_ztpttr LAPACK_GLOBAL(ztpttr, ZTPTTR)
-#define LAPACK_ctpttr LAPACK_GLOBAL(ctpttr, CTPTTR)
-#define LAPACK_dtrttf LAPACK_GLOBAL(dtrttf, DTRTTF)
-#define LAPACK_strttf LAPACK_GLOBAL(strttf, STRTTF)
-#define LAPACK_ztrttf LAPACK_GLOBAL(ztrttf, ZTRTTF)
-#define LAPACK_ctrttf LAPACK_GLOBAL(ctrttf, CTRTTF)
-#define LAPACK_dtrttp LAPACK_GLOBAL(dtrttp, DTRTTP)
-#define LAPACK_strttp LAPACK_GLOBAL(strttp, STRTTP)
-#define LAPACK_ztrttp LAPACK_GLOBAL(ztrttp, ZTRTTP)
-#define LAPACK_ctrttp LAPACK_GLOBAL(ctrttp, CTRTTP)
-#define LAPACK_sgeqrfp LAPACK_GLOBAL(sgeqrfp, SGEQRFP)
-#define LAPACK_dgeqrfp LAPACK_GLOBAL(dgeqrfp, DGEQRFP)
-#define LAPACK_cgeqrfp LAPACK_GLOBAL(cgeqrfp, CGEQRFP)
-#define LAPACK_zgeqrfp LAPACK_GLOBAL(zgeqrfp, ZGEQRFP)
-#define LAPACK_clacgv LAPACK_GLOBAL(clacgv, CLACGV)
-#define LAPACK_zlacgv LAPACK_GLOBAL(zlacgv, ZLACGV)
-#define LAPACK_slarnv LAPACK_GLOBAL(slarnv, SLARNV)
-#define LAPACK_dlarnv LAPACK_GLOBAL(dlarnv, DLARNV)
-#define LAPACK_clarnv LAPACK_GLOBAL(clarnv, CLARNV)
-#define LAPACK_zlarnv LAPACK_GLOBAL(zlarnv, ZLARNV)
-#define LAPACK_sgeqr2 LAPACK_GLOBAL(sgeqr2, SGEQR2)
-#define LAPACK_dgeqr2 LAPACK_GLOBAL(dgeqr2, DGEQR2)
-#define LAPACK_cgeqr2 LAPACK_GLOBAL(cgeqr2, CGEQR2)
-#define LAPACK_zgeqr2 LAPACK_GLOBAL(zgeqr2, ZGEQR2)
-#define LAPACK_slacpy LAPACK_GLOBAL(slacpy, SLACPY)
-#define LAPACK_dlacpy LAPACK_GLOBAL(dlacpy, DLACPY)
-#define LAPACK_clacpy LAPACK_GLOBAL(clacpy, CLACPY)
-#define LAPACK_zlacpy LAPACK_GLOBAL(zlacpy, ZLACPY)
-#define LAPACK_sgetf2 LAPACK_GLOBAL(sgetf2, SGETF2)
-#define LAPACK_dgetf2 LAPACK_GLOBAL(dgetf2, DGETF2)
-#define LAPACK_cgetf2 LAPACK_GLOBAL(cgetf2, CGETF2)
-#define LAPACK_zgetf2 LAPACK_GLOBAL(zgetf2, ZGETF2)
-#define LAPACK_slaswp LAPACK_GLOBAL(slaswp, SLASWP)
-#define LAPACK_dlaswp LAPACK_GLOBAL(dlaswp, DLASWP)
-#define LAPACK_claswp LAPACK_GLOBAL(claswp, CLASWP)
-#define LAPACK_zlaswp LAPACK_GLOBAL(zlaswp, ZLASWP)
-#define LAPACK_slange LAPACK_GLOBAL(slange, SLANGE)
-#define LAPACK_dlange LAPACK_GLOBAL(dlange, DLANGE)
-#define LAPACK_clange LAPACK_GLOBAL(clange, CLANGE)
-#define LAPACK_zlange LAPACK_GLOBAL(zlange, ZLANGE)
-#define LAPACK_clanhe LAPACK_GLOBAL(clanhe, CLANHE)
-#define LAPACK_zlanhe LAPACK_GLOBAL(zlanhe, ZLANHE)
-#define LAPACK_slansy LAPACK_GLOBAL(slansy, SLANSY)
-#define LAPACK_dlansy LAPACK_GLOBAL(dlansy, DLANSY)
-#define LAPACK_clansy LAPACK_GLOBAL(clansy, CLANSY)
-#define LAPACK_zlansy LAPACK_GLOBAL(zlansy, ZLANSY)
-#define LAPACK_slantr LAPACK_GLOBAL(slantr, SLANTR)
-#define LAPACK_dlantr LAPACK_GLOBAL(dlantr, DLANTR)
-#define LAPACK_clantr LAPACK_GLOBAL(clantr, CLANTR)
-#define LAPACK_zlantr LAPACK_GLOBAL(zlantr, ZLANTR)
-#define LAPACK_slamch LAPACK_GLOBAL(slamch, SLAMCH)
-#define LAPACK_dlamch LAPACK_GLOBAL(dlamch, DLAMCH)
-#define LAPACK_sgelq2 LAPACK_GLOBAL(sgelq2, SGELQ2)
-#define LAPACK_dgelq2 LAPACK_GLOBAL(dgelq2, DGELQ2)
-#define LAPACK_cgelq2 LAPACK_GLOBAL(cgelq2, CGELQ2)
-#define LAPACK_zgelq2 LAPACK_GLOBAL(zgelq2, ZGELQ2)
-#define LAPACK_slarfb LAPACK_GLOBAL(slarfb, SLARFB)
-#define LAPACK_dlarfb LAPACK_GLOBAL(dlarfb, DLARFB)
-#define LAPACK_clarfb LAPACK_GLOBAL(clarfb, CLARFB)
-#define LAPACK_zlarfb LAPACK_GLOBAL(zlarfb, ZLARFB)
-#define LAPACK_slarfg LAPACK_GLOBAL(slarfg, SLARFG)
-#define LAPACK_dlarfg LAPACK_GLOBAL(dlarfg, DLARFG)
-#define LAPACK_clarfg LAPACK_GLOBAL(clarfg, CLARFG)
-#define LAPACK_zlarfg LAPACK_GLOBAL(zlarfg, ZLARFG)
-#define LAPACK_slarft LAPACK_GLOBAL(slarft, SLARFT)
-#define LAPACK_dlarft LAPACK_GLOBAL(dlarft, DLARFT)
-#define LAPACK_clarft LAPACK_GLOBAL(clarft, CLARFT)
-#define LAPACK_zlarft LAPACK_GLOBAL(zlarft, ZLARFT)
-#define LAPACK_slarfx LAPACK_GLOBAL(slarfx, SLARFX)
-#define LAPACK_dlarfx LAPACK_GLOBAL(dlarfx, DLARFX)
-#define LAPACK_clarfx LAPACK_GLOBAL(clarfx, CLARFX)
-#define LAPACK_zlarfx LAPACK_GLOBAL(zlarfx, ZLARFX)
-#define LAPACK_slatms LAPACK_GLOBAL(slatms, SLATMS)
-#define LAPACK_dlatms LAPACK_GLOBAL(dlatms, DLATMS)
-#define LAPACK_clatms LAPACK_GLOBAL(clatms, CLATMS)
-#define LAPACK_zlatms LAPACK_GLOBAL(zlatms, ZLATMS)
-#define LAPACK_slag2d LAPACK_GLOBAL(slag2d, SLAG2D)
-#define LAPACK_dlag2s LAPACK_GLOBAL(dlag2s, DLAG2S)
-#define LAPACK_clag2z LAPACK_GLOBAL(clag2z, CLAG2Z)
-#define LAPACK_zlag2c LAPACK_GLOBAL(zlag2c, ZLAG2C)
-#define LAPACK_slauum LAPACK_GLOBAL(slauum, SLAUUM)
-#define LAPACK_dlauum LAPACK_GLOBAL(dlauum, DLAUUM)
-#define LAPACK_clauum LAPACK_GLOBAL(clauum, CLAUUM)
-#define LAPACK_zlauum LAPACK_GLOBAL(zlauum, ZLAUUM)
-#define LAPACK_slagge LAPACK_GLOBAL(slagge, SLAGGE)
-#define LAPACK_dlagge LAPACK_GLOBAL(dlagge, DLAGGE)
-#define LAPACK_clagge LAPACK_GLOBAL(clagge, CLAGGE)
-#define LAPACK_zlagge LAPACK_GLOBAL(zlagge, ZLAGGE)
-#define LAPACK_slaset LAPACK_GLOBAL(slaset, SLASET)
-#define LAPACK_dlaset LAPACK_GLOBAL(dlaset, DLASET)
-#define LAPACK_claset LAPACK_GLOBAL(claset, CLASET)
-#define LAPACK_zlaset LAPACK_GLOBAL(zlaset, ZLASET)
-#define LAPACK_slasrt LAPACK_GLOBAL(slasrt, SLASRT)
-#define LAPACK_dlasrt LAPACK_GLOBAL(dlasrt, DLASRT)
-#define LAPACK_slagsy LAPACK_GLOBAL(slagsy, SLAGSY)
-#define LAPACK_dlagsy LAPACK_GLOBAL(dlagsy, DLAGSY)
-#define LAPACK_clagsy LAPACK_GLOBAL(clagsy, CLAGSY)
-#define LAPACK_zlagsy LAPACK_GLOBAL(zlagsy, ZLAGSY)
-#define LAPACK_claghe LAPACK_GLOBAL(claghe, CLAGHE)
-#define LAPACK_zlaghe LAPACK_GLOBAL(zlaghe, ZLAGHE)
-#define LAPACK_slapmr LAPACK_GLOBAL(slapmr, SLAPMR)
-#define LAPACK_dlapmr LAPACK_GLOBAL(dlapmr, DLAPMR)
-#define LAPACK_clapmr LAPACK_GLOBAL(clapmr, CLAPMR)
-#define LAPACK_zlapmr LAPACK_GLOBAL(zlapmr, ZLAPMR)
-#define LAPACK_slapy2 LAPACK_GLOBAL(slapy2, SLAPY2)
-#define LAPACK_dlapy2 LAPACK_GLOBAL(dlapy2, DLAPY2)
-#define LAPACK_slapy3 LAPACK_GLOBAL(slapy3, SLAPY3)
-#define LAPACK_dlapy3 LAPACK_GLOBAL(dlapy3, DLAPY3)
-#define LAPACK_slartgp LAPACK_GLOBAL(slartgp, SLARTGP)
-#define LAPACK_dlartgp LAPACK_GLOBAL(dlartgp, DLARTGP)
-#define LAPACK_slartgs LAPACK_GLOBAL(slartgs, SLARTGS)
-#define LAPACK_dlartgs LAPACK_GLOBAL(dlartgs, DLARTGS)
-// LAPACK 3.3.0
-#define LAPACK_cbbcsd LAPACK_GLOBAL(cbbcsd, CBBCSD)
-#define LAPACK_cheswapr LAPACK_GLOBAL(cheswapr, CHESWAPR)
-#define LAPACK_chetri2 LAPACK_GLOBAL(chetri2, CHETRI2)
-#define LAPACK_chetri2x LAPACK_GLOBAL(chetri2x, CHETRI2X)
-#define LAPACK_chetrs2 LAPACK_GLOBAL(chetrs2, CHETRS2)
-#define LAPACK_csyconv LAPACK_GLOBAL(csyconv, CSYCONV)
-#define LAPACK_csyswapr LAPACK_GLOBAL(csyswapr, CSYSWAPR)
-#define LAPACK_csytri2 LAPACK_GLOBAL(csytri2, CSYTRI2)
-#define LAPACK_csytri2x LAPACK_GLOBAL(csytri2x, CSYTRI2X)
-#define LAPACK_csytrs2 LAPACK_GLOBAL(csytrs2, CSYTRS2)
-#define LAPACK_cunbdb LAPACK_GLOBAL(cunbdb, CUNBDB)
-#define LAPACK_cuncsd LAPACK_GLOBAL(cuncsd, CUNCSD)
-#define LAPACK_dbbcsd LAPACK_GLOBAL(dbbcsd, DBBCSD)
-#define LAPACK_dorbdb LAPACK_GLOBAL(dorbdb, DORBDB)
-#define LAPACK_dorcsd LAPACK_GLOBAL(dorcsd, DORCSD)
-#define LAPACK_dsyconv LAPACK_GLOBAL(dsyconv, DSYCONV)
-#define LAPACK_dsyswapr LAPACK_GLOBAL(dsyswapr, DSYSWAPR)
-#define LAPACK_dsytri2 LAPACK_GLOBAL(dsytri2, DSYTRI2)
-#define LAPACK_dsytri2x LAPACK_GLOBAL(dsytri2x, DSYTRI2X)
-#define LAPACK_dsytrs2 LAPACK_GLOBAL(dsytrs2, DSYTRS2)
-#define LAPACK_sbbcsd LAPACK_GLOBAL(sbbcsd, SBBCSD)
-#define LAPACK_sorbdb LAPACK_GLOBAL(sorbdb, SORBDB)
-#define LAPACK_sorcsd LAPACK_GLOBAL(sorcsd, SORCSD)
-#define LAPACK_ssyconv LAPACK_GLOBAL(ssyconv, SSYCONV)
-#define LAPACK_ssyswapr LAPACK_GLOBAL(ssyswapr, SSYSWAPR)
-#define LAPACK_ssytri2 LAPACK_GLOBAL(ssytri2, SSYTRI2)
-#define LAPACK_ssytri2x LAPACK_GLOBAL(ssytri2x, SSYTRI2X)
-#define LAPACK_ssytrs2 LAPACK_GLOBAL(ssytrs2, SSYTRS2)
-#define LAPACK_zbbcsd LAPACK_GLOBAL(zbbcsd, ZBBCSD)
-#define LAPACK_zheswapr LAPACK_GLOBAL(zheswapr, ZHESWAPR)
-#define LAPACK_zhetri2 LAPACK_GLOBAL(zhetri2, ZHETRI2)
-#define LAPACK_zhetri2x LAPACK_GLOBAL(zhetri2x, ZHETRI2X)
-#define LAPACK_zhetrs2 LAPACK_GLOBAL(zhetrs2, ZHETRS2)
-#define LAPACK_zsyconv LAPACK_GLOBAL(zsyconv, ZSYCONV)
-#define LAPACK_zsyswapr LAPACK_GLOBAL(zsyswapr, ZSYSWAPR)
-#define LAPACK_zsytri2 LAPACK_GLOBAL(zsytri2, ZSYTRI2)
-#define LAPACK_zsytri2x LAPACK_GLOBAL(zsytri2x, ZSYTRI2X)
-#define LAPACK_zsytrs2 LAPACK_GLOBAL(zsytrs2, ZSYTRS2)
-#define LAPACK_zunbdb LAPACK_GLOBAL(zunbdb, ZUNBDB)
-#define LAPACK_zuncsd LAPACK_GLOBAL(zuncsd, ZUNCSD)
-// LAPACK 3.4.0
-#define LAPACK_sgemqrt LAPACK_GLOBAL(sgemqrt, SGEMQRT)
-#define LAPACK_dgemqrt LAPACK_GLOBAL(dgemqrt, DGEMQRT)
-#define LAPACK_cgemqrt LAPACK_GLOBAL(cgemqrt, CGEMQRT)
-#define LAPACK_zgemqrt LAPACK_GLOBAL(zgemqrt, ZGEMQRT)
-#define LAPACK_sgeqrt LAPACK_GLOBAL(sgeqrt, SGEQRT)
-#define LAPACK_dgeqrt LAPACK_GLOBAL(dgeqrt, DGEQRT)
-#define LAPACK_cgeqrt LAPACK_GLOBAL(cgeqrt, CGEQRT)
-#define LAPACK_zgeqrt LAPACK_GLOBAL(zgeqrt, ZGEQRT)
-#define LAPACK_sgeqrt2 LAPACK_GLOBAL(sgeqrt2, SGEQRT2)
-#define LAPACK_dgeqrt2 LAPACK_GLOBAL(dgeqrt2, DGEQRT2)
-#define LAPACK_cgeqrt2 LAPACK_GLOBAL(cgeqrt2, CGEQRT2)
-#define LAPACK_zgeqrt2 LAPACK_GLOBAL(zgeqrt2, ZGEQRT2)
-#define LAPACK_sgeqrt3 LAPACK_GLOBAL(sgeqrt3, SGEQRT3)
-#define LAPACK_dgeqrt3 LAPACK_GLOBAL(dgeqrt3, DGEQRT3)
-#define LAPACK_cgeqrt3 LAPACK_GLOBAL(cgeqrt3, CGEQRT3)
-#define LAPACK_zgeqrt3 LAPACK_GLOBAL(zgeqrt3, ZGEQRT3)
-#define LAPACK_stpmqrt LAPACK_GLOBAL(stpmqrt, STPMQRT)
-#define LAPACK_dtpmqrt LAPACK_GLOBAL(dtpmqrt, DTPMQRT)
-#define LAPACK_ctpmqrt LAPACK_GLOBAL(ctpmqrt, CTPMQRT)
-#define LAPACK_ztpmqrt LAPACK_GLOBAL(ztpmqrt, ZTPMQRT)
-#define LAPACK_dtpqrt LAPACK_GLOBAL(dtpqrt, DTPQRT)
-#define LAPACK_ctpqrt LAPACK_GLOBAL(ctpqrt, CTPQRT)
-#define LAPACK_ztpqrt LAPACK_GLOBAL(ztpqrt, ZTPQRT)
-#define LAPACK_stpqrt2 LAPACK_GLOBAL(stpqrt2, STPQRT2)
-#define LAPACK_dtpqrt2 LAPACK_GLOBAL(dtpqrt2, DTPQRT2)
-#define LAPACK_ctpqrt2 LAPACK_GLOBAL(ctpqrt2, CTPQRT2)
-#define LAPACK_ztpqrt2 LAPACK_GLOBAL(ztpqrt2, ZTPQRT2)
-#define LAPACK_stprfb LAPACK_GLOBAL(stprfb, STPRFB)
-#define LAPACK_dtprfb LAPACK_GLOBAL(dtprfb, DTPRFB)
-#define LAPACK_ctprfb LAPACK_GLOBAL(ctprfb, CTPRFB)
-#define LAPACK_ztprfb LAPACK_GLOBAL(ztprfb, ZTPRFB)
-// LAPACK 3.X.X
-#define LAPACK_csyr LAPACK_GLOBAL(csyr, CSYR)
-#define LAPACK_zsyr LAPACK_GLOBAL(zsyr, ZSYR)
-
-void LAPACK_sgetrf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, lapack_int* ipiv, lapack_int* info);
-void LAPACK_dgetrf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, lapack_int* ipiv, lapack_int* info);
-void LAPACK_cgetrf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_int* info);
-void LAPACK_zgetrf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_int* info);
-void LAPACK_sgbtrf(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, float* ab, lapack_int* ldab,
-                   lapack_int* ipiv, lapack_int* info);
-void LAPACK_dgbtrf(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, double* ab, lapack_int* ldab,
-                   lapack_int* ipiv, lapack_int* info);
-void LAPACK_cgbtrf(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_complex_float* ab,
-                   lapack_int* ldab, lapack_int* ipiv, lapack_int* info);
-void LAPACK_zgbtrf(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_complex_double* ab,
-                   lapack_int* ldab, lapack_int* ipiv, lapack_int* info);
-void LAPACK_sgttrf(lapack_int* n, float* dl, float* d, float* du, float* du2, lapack_int* ipiv, lapack_int* info);
-void LAPACK_dgttrf(lapack_int* n, double* dl, double* d, double* du, double* du2, lapack_int* ipiv, lapack_int* info);
-void LAPACK_cgttrf(lapack_int* n, lapack_complex_float* dl, lapack_complex_float* d, lapack_complex_float* du,
-                   lapack_complex_float* du2, lapack_int* ipiv, lapack_int* info);
-void LAPACK_zgttrf(lapack_int* n, lapack_complex_double* dl, lapack_complex_double* d, lapack_complex_double* du,
-                   lapack_complex_double* du2, lapack_int* ipiv, lapack_int* info);
-void LAPACK_spotrf(char* uplo, lapack_int* n, float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dpotrf(char* uplo, lapack_int* n, double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_cpotrf(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_zpotrf(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dpstrf(char* uplo, lapack_int* n, double* a, lapack_int* lda, lapack_int* piv, lapack_int* rank,
-                   double* tol, double* work, lapack_int* info);
-void LAPACK_spstrf(char* uplo, lapack_int* n, float* a, lapack_int* lda, lapack_int* piv, lapack_int* rank, float* tol,
-                   float* work, lapack_int* info);
-void LAPACK_zpstrf(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* piv,
-                   lapack_int* rank, double* tol, double* work, lapack_int* info);
-void LAPACK_cpstrf(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* piv,
-                   lapack_int* rank, float* tol, float* work, lapack_int* info);
-void LAPACK_dpftrf(char* transr, char* uplo, lapack_int* n, double* a, lapack_int* info);
-void LAPACK_spftrf(char* transr, char* uplo, lapack_int* n, float* a, lapack_int* info);
-void LAPACK_zpftrf(char* transr, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* info);
-void LAPACK_cpftrf(char* transr, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* info);
-void LAPACK_spptrf(char* uplo, lapack_int* n, float* ap, lapack_int* info);
-void LAPACK_dpptrf(char* uplo, lapack_int* n, double* ap, lapack_int* info);
-void LAPACK_cpptrf(char* uplo, lapack_int* n, lapack_complex_float* ap, lapack_int* info);
-void LAPACK_zpptrf(char* uplo, lapack_int* n, lapack_complex_double* ap, lapack_int* info);
-void LAPACK_spbtrf(char* uplo, lapack_int* n, lapack_int* kd, float* ab, lapack_int* ldab, lapack_int* info);
-void LAPACK_dpbtrf(char* uplo, lapack_int* n, lapack_int* kd, double* ab, lapack_int* ldab, lapack_int* info);
-void LAPACK_cpbtrf(char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
-                   lapack_int* info);
-void LAPACK_zpbtrf(char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
-                   lapack_int* info);
-void LAPACK_spttrf(lapack_int* n, float* d, float* e, lapack_int* info);
-void LAPACK_dpttrf(lapack_int* n, double* d, double* e, lapack_int* info);
-void LAPACK_cpttrf(lapack_int* n, float* d, lapack_complex_float* e, lapack_int* info);
-void LAPACK_zpttrf(lapack_int* n, double* d, lapack_complex_double* e, lapack_int* info);
-void LAPACK_ssytrf(char* uplo, lapack_int* n, float* a, lapack_int* lda, lapack_int* ipiv, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_dsytrf(char* uplo, lapack_int* n, double* a, lapack_int* lda, lapack_int* ipiv, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_csytrf(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zsytrf(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_chetrf(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zhetrf(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ssptrf(char* uplo, lapack_int* n, float* ap, lapack_int* ipiv, lapack_int* info);
-void LAPACK_dsptrf(char* uplo, lapack_int* n, double* ap, lapack_int* ipiv, lapack_int* info);
-void LAPACK_csptrf(char* uplo, lapack_int* n, lapack_complex_float* ap, lapack_int* ipiv, lapack_int* info);
-void LAPACK_zsptrf(char* uplo, lapack_int* n, lapack_complex_double* ap, lapack_int* ipiv, lapack_int* info);
-void LAPACK_chptrf(char* uplo, lapack_int* n, lapack_complex_float* ap, lapack_int* ipiv, lapack_int* info);
-void LAPACK_zhptrf(char* uplo, lapack_int* n, lapack_complex_double* ap, lapack_int* ipiv, lapack_int* info);
-void LAPACK_sgetrs(char* trans, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda,
-                   const lapack_int* ipiv, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dgetrs(char* trans, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                   const lapack_int* ipiv, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cgetrs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zgetrs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_sgbtrs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, const float* ab,
-                   lapack_int* ldab, const lapack_int* ipiv, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dgbtrs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, const double* ab,
-                   lapack_int* ldab, const lapack_int* ipiv, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cgbtrs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                   const lapack_complex_float* ab, lapack_int* ldab, const lapack_int* ipiv, lapack_complex_float* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_zgbtrs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                   const lapack_complex_double* ab, lapack_int* ldab, const lapack_int* ipiv, lapack_complex_double* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_sgttrs(char* trans, lapack_int* n, lapack_int* nrhs, const float* dl, const float* d, const float* du,
-                   const float* du2, const lapack_int* ipiv, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dgttrs(char* trans, lapack_int* n, lapack_int* nrhs, const double* dl, const double* d, const double* du,
-                   const double* du2, const lapack_int* ipiv, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cgttrs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* dl,
-                   const lapack_complex_float* d, const lapack_complex_float* du, const lapack_complex_float* du2,
-                   const lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zgttrs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* dl,
-                   const lapack_complex_double* d, const lapack_complex_double* du, const lapack_complex_double* du2,
-                   const lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_spotrs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda, float* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_dpotrs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_cpotrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zpotrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dpftrs(char* transr, char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, double* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_spftrs(char* transr, char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, float* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_zpftrs(char* transr, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cpftrs(char* transr, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_spptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* ap, float* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_dpptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* ap, double* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_cpptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap, lapack_complex_float* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_zpptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_spbtrs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const float* ab, lapack_int* ldab,
-                   float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dpbtrs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const double* ab, lapack_int* ldab,
-                   double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cpbtrs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const lapack_complex_float* ab,
-                   lapack_int* ldab, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zpbtrs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const lapack_complex_double* ab,
-                   lapack_int* ldab, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_spttrs(lapack_int* n, lapack_int* nrhs, const float* d, const float* e, float* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_dpttrs(lapack_int* n, lapack_int* nrhs, const double* d, const double* e, double* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_cpttrs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* d, const lapack_complex_float* e,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zpttrs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* d, const lapack_complex_double* e,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_ssytrs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda, const lapack_int* ipiv,
-                   float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dsytrs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                   const lapack_int* ipiv, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_csytrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zsytrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_chetrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zhetrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_ssptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* ap, const lapack_int* ipiv, float* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_dsptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* ap, const lapack_int* ipiv, double* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_csptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap, const lapack_int* ipiv,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zsptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap, const lapack_int* ipiv,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_chptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap, const lapack_int* ipiv,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zhptrs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap, const lapack_int* ipiv,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_strtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const float* a,
-                   lapack_int* lda, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dtrtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const double* a,
-                   lapack_int* lda, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_ctrtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_ztrtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_stptrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const float* ap, float* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_dtptrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const double* ap, double* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_ctptrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_ztptrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs,
-                   const lapack_complex_double* ap, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_stbtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const float* ab, lapack_int* ldab, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dtbtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const double* ab, lapack_int* ldab, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_ctbtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const lapack_complex_float* ab, lapack_int* ldab, lapack_complex_float* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_ztbtrs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const lapack_complex_double* ab, lapack_int* ldab, lapack_complex_double* b, lapack_int* ldb,
-                   lapack_int* info);
-void LAPACK_sgecon(char* norm, lapack_int* n, const float* a, lapack_int* lda, float* anorm, float* rcond, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dgecon(char* norm, lapack_int* n, const double* a, lapack_int* lda, double* anorm, double* rcond,
-                   double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cgecon(char* norm, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* anorm,
-                   float* rcond, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgecon(char* norm, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* anorm,
-                   double* rcond, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sgbcon(char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku, const float* ab, lapack_int* ldab,
-                   const lapack_int* ipiv, float* anorm, float* rcond, float* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dgbcon(char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku, const double* ab, lapack_int* ldab,
-                   const lapack_int* ipiv, double* anorm, double* rcond, double* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_cgbcon(char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku, const lapack_complex_float* ab,
-                   lapack_int* ldab, const lapack_int* ipiv, float* anorm, float* rcond, lapack_complex_float* work,
-                   float* rwork, lapack_int* info);
-void LAPACK_zgbcon(char* norm, lapack_int* n, lapack_int* kl, lapack_int* ku, const lapack_complex_double* ab,
-                   lapack_int* ldab, const lapack_int* ipiv, double* anorm, double* rcond, lapack_complex_double* work,
-                   double* rwork, lapack_int* info);
-void LAPACK_sgtcon(char* norm, lapack_int* n, const float* dl, const float* d, const float* du, const float* du2,
-                   const lapack_int* ipiv, float* anorm, float* rcond, float* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dgtcon(char* norm, lapack_int* n, const double* dl, const double* d, const double* du, const double* du2,
-                   const lapack_int* ipiv, double* anorm, double* rcond, double* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_cgtcon(char* norm, lapack_int* n, const lapack_complex_float* dl, const lapack_complex_float* d,
-                   const lapack_complex_float* du, const lapack_complex_float* du2, const lapack_int* ipiv,
-                   float* anorm, float* rcond, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zgtcon(char* norm, lapack_int* n, const lapack_complex_double* dl, const lapack_complex_double* d,
-                   const lapack_complex_double* du, const lapack_complex_double* du2, const lapack_int* ipiv,
-                   double* anorm, double* rcond, lapack_complex_double* work, lapack_int* info);
-void LAPACK_spocon(char* uplo, lapack_int* n, const float* a, lapack_int* lda, float* anorm, float* rcond, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dpocon(char* uplo, lapack_int* n, const double* a, lapack_int* lda, double* anorm, double* rcond,
-                   double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cpocon(char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* anorm,
-                   float* rcond, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zpocon(char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* anorm,
-                   double* rcond, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sppcon(char* uplo, lapack_int* n, const float* ap, float* anorm, float* rcond, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dppcon(char* uplo, lapack_int* n, const double* ap, double* anorm, double* rcond, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cppcon(char* uplo, lapack_int* n, const lapack_complex_float* ap, float* anorm, float* rcond,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zppcon(char* uplo, lapack_int* n, const lapack_complex_double* ap, double* anorm, double* rcond,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_spbcon(char* uplo, lapack_int* n, lapack_int* kd, const float* ab, lapack_int* ldab, float* anorm,
-                   float* rcond, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dpbcon(char* uplo, lapack_int* n, lapack_int* kd, const double* ab, lapack_int* ldab, double* anorm,
-                   double* rcond, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cpbcon(char* uplo, lapack_int* n, lapack_int* kd, const lapack_complex_float* ab, lapack_int* ldab,
-                   float* anorm, float* rcond, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zpbcon(char* uplo, lapack_int* n, lapack_int* kd, const lapack_complex_double* ab, lapack_int* ldab,
-                   double* anorm, double* rcond, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sptcon(lapack_int* n, const float* d, const float* e, float* anorm, float* rcond, float* work,
-                   lapack_int* info);
-void LAPACK_dptcon(lapack_int* n, const double* d, const double* e, double* anorm, double* rcond, double* work,
-                   lapack_int* info);
-void LAPACK_cptcon(lapack_int* n, const float* d, const lapack_complex_float* e, float* anorm, float* rcond,
-                   float* work, lapack_int* info);
-void LAPACK_zptcon(lapack_int* n, const double* d, const lapack_complex_double* e, double* anorm, double* rcond,
-                   double* work, lapack_int* info);
-void LAPACK_ssycon(char* uplo, lapack_int* n, const float* a, lapack_int* lda, const lapack_int* ipiv, float* anorm,
-                   float* rcond, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dsycon(char* uplo, lapack_int* n, const double* a, lapack_int* lda, const lapack_int* ipiv, double* anorm,
-                   double* rcond, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_csycon(char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                   float* anorm, float* rcond, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zsycon(char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                   double* anorm, double* rcond, lapack_complex_double* work, lapack_int* info);
-void LAPACK_checon(char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                   float* anorm, float* rcond, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zhecon(char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                   double* anorm, double* rcond, lapack_complex_double* work, lapack_int* info);
-void LAPACK_sspcon(char* uplo, lapack_int* n, const float* ap, const lapack_int* ipiv, float* anorm, float* rcond,
-                   float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dspcon(char* uplo, lapack_int* n, const double* ap, const lapack_int* ipiv, double* anorm, double* rcond,
-                   double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cspcon(char* uplo, lapack_int* n, const lapack_complex_float* ap, const lapack_int* ipiv, float* anorm,
-                   float* rcond, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zspcon(char* uplo, lapack_int* n, const lapack_complex_double* ap, const lapack_int* ipiv, double* anorm,
-                   double* rcond, lapack_complex_double* work, lapack_int* info);
-void LAPACK_chpcon(char* uplo, lapack_int* n, const lapack_complex_float* ap, const lapack_int* ipiv, float* anorm,
-                   float* rcond, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zhpcon(char* uplo, lapack_int* n, const lapack_complex_double* ap, const lapack_int* ipiv, double* anorm,
-                   double* rcond, lapack_complex_double* work, lapack_int* info);
-void LAPACK_strcon(char* norm, char* uplo, char* diag, lapack_int* n, const float* a, lapack_int* lda, float* rcond,
-                   float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtrcon(char* norm, char* uplo, char* diag, lapack_int* n, const double* a, lapack_int* lda, double* rcond,
-                   double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctrcon(char* norm, char* uplo, char* diag, lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
-                   float* rcond, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_ztrcon(char* norm, char* uplo, char* diag, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                   double* rcond, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_stpcon(char* norm, char* uplo, char* diag, lapack_int* n, const float* ap, float* rcond, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dtpcon(char* norm, char* uplo, char* diag, lapack_int* n, const double* ap, double* rcond, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_ctpcon(char* norm, char* uplo, char* diag, lapack_int* n, const lapack_complex_float* ap, float* rcond,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_ztpcon(char* norm, char* uplo, char* diag, lapack_int* n, const lapack_complex_double* ap, double* rcond,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_stbcon(char* norm, char* uplo, char* diag, lapack_int* n, lapack_int* kd, const float* ab, lapack_int* ldab,
-                   float* rcond, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtbcon(char* norm, char* uplo, char* diag, lapack_int* n, lapack_int* kd, const double* ab,
-                   lapack_int* ldab, double* rcond, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctbcon(char* norm, char* uplo, char* diag, lapack_int* n, lapack_int* kd, const lapack_complex_float* ab,
-                   lapack_int* ldab, float* rcond, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_ztbcon(char* norm, char* uplo, char* diag, lapack_int* n, lapack_int* kd, const lapack_complex_double* ab,
-                   lapack_int* ldab, double* rcond, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sgerfs(char* trans, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda, const float* af,
-                   lapack_int* ldaf, const lapack_int* ipiv, const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                   float* ferr, float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dgerfs(char* trans, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda, const double* af,
-                   lapack_int* ldaf, const lapack_int* ipiv, const double* b, lapack_int* ldb, double* x,
-                   lapack_int* ldx, double* ferr, double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cgerfs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* af, lapack_int* ldaf, const lapack_int* ipiv,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                   float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgerfs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* af, lapack_int* ldaf, const lapack_int* ipiv,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* ferr, double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_dgerfsx(char* trans, char* equed, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                    const double* af, lapack_int* ldaf, const lapack_int* ipiv, const double* r, const double* c,
-                    const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond, double* berr,
-                    lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int* nparams,
-                    double* params, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_sgerfsx(char* trans, char* equed, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda,
-                    const float* af, lapack_int* ldaf, const lapack_int* ipiv, const float* r, const float* c,
-                    const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* berr,
-                    lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams,
-                    float* params, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_zgerfsx(char* trans, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                    lapack_int* lda, const lapack_complex_double* af, lapack_int* ldaf, const lapack_int* ipiv,
-                    const double* r, const double* c, const lapack_complex_double* b, lapack_int* ldb,
-                    lapack_complex_double* x, lapack_int* ldx, double* rcond, double* berr, lapack_int* n_err_bnds,
-                    double* err_bnds_norm, double* err_bnds_comp, lapack_int* nparams, double* params,
-                    lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_cgerfsx(char* trans, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                    lapack_int* lda, const lapack_complex_float* af, lapack_int* ldaf, const lapack_int* ipiv,
-                    const float* r, const float* c, const lapack_complex_float* b, lapack_int* ldb,
-                    lapack_complex_float* x, lapack_int* ldx, float* rcond, float* berr, lapack_int* n_err_bnds,
-                    float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams, float* params,
-                    lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_sgbrfs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, const float* ab,
-                   lapack_int* ldab, const float* afb, lapack_int* ldafb, const lapack_int* ipiv, const float* b,
-                   lapack_int* ldb, float* x, lapack_int* ldx, float* ferr, float* berr, float* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dgbrfs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, const double* ab,
-                   lapack_int* ldab, const double* afb, lapack_int* ldafb, const lapack_int* ipiv, const double* b,
-                   lapack_int* ldb, double* x, lapack_int* ldx, double* ferr, double* berr, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cgbrfs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                   const lapack_complex_float* ab, lapack_int* ldab, const lapack_complex_float* afb, lapack_int* ldafb,
-                   const lapack_int* ipiv, const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x,
-                   lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work, float* rwork,
-                   lapack_int* info);
-void LAPACK_zgbrfs(char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                   const lapack_complex_double* ab, lapack_int* ldab, const lapack_complex_double* afb,
-                   lapack_int* ldafb, const lapack_int* ipiv, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr, lapack_complex_double* work,
-                   double* rwork, lapack_int* info);
-void LAPACK_dgbrfsx(char* trans, char* equed, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    const double* ab, lapack_int* ldab, const double* afb, lapack_int* ldafb, const lapack_int* ipiv,
-                    const double* r, const double* c, const double* b, lapack_int* ldb, double* x, lapack_int* ldx,
-                    double* rcond, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_sgbrfsx(char* trans, char* equed, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    const float* ab, lapack_int* ldab, const float* afb, lapack_int* ldafb, const lapack_int* ipiv,
-                    const float* r, const float* c, const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                    float* rcond, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                    lapack_int* nparams, float* params, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_zgbrfsx(char* trans, char* equed, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    const lapack_complex_double* ab, lapack_int* ldab, const lapack_complex_double* afb,
-                    lapack_int* ldafb, const lapack_int* ipiv, const double* r, const double* c,
-                    const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                    double* rcond, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_cgbrfsx(char* trans, char* equed, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    const lapack_complex_float* ab, lapack_int* ldab, const lapack_complex_float* afb,
-                    lapack_int* ldafb, const lapack_int* ipiv, const float* r, const float* c,
-                    const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                    float* rcond, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                    lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_sgtrfs(char* trans, lapack_int* n, lapack_int* nrhs, const float* dl, const float* d, const float* du,
-                   const float* dlf, const float* df, const float* duf, const float* du2, const lapack_int* ipiv,
-                   const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* ferr, float* berr, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dgtrfs(char* trans, lapack_int* n, lapack_int* nrhs, const double* dl, const double* d, const double* du,
-                   const double* dlf, const double* df, const double* duf, const double* du2, const lapack_int* ipiv,
-                   const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* ferr, double* berr,
-                   double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cgtrfs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* dl,
-                   const lapack_complex_float* d, const lapack_complex_float* du, const lapack_complex_float* dlf,
-                   const lapack_complex_float* df, const lapack_complex_float* duf, const lapack_complex_float* du2,
-                   const lapack_int* ipiv, const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x,
-                   lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work, float* rwork,
-                   lapack_int* info);
-void LAPACK_zgtrfs(char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* dl,
-                   const lapack_complex_double* d, const lapack_complex_double* du, const lapack_complex_double* dlf,
-                   const lapack_complex_double* df, const lapack_complex_double* duf, const lapack_complex_double* du2,
-                   const lapack_int* ipiv, const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x,
-                   lapack_int* ldx, double* ferr, double* berr, lapack_complex_double* work, double* rwork,
-                   lapack_int* info);
-void LAPACK_sporfs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda, const float* af,
-                   lapack_int* ldaf, const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
-                   float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dporfs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda, const double* af,
-                   lapack_int* ldaf, const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
-                   double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cporfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* af, lapack_int* ldaf, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work,
-                   float* rwork, lapack_int* info);
-void LAPACK_zporfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* af, lapack_int* ldaf, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr, lapack_complex_double* work,
-                   double* rwork, lapack_int* info);
-void LAPACK_dporfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                    const double* af, lapack_int* ldaf, const double* s, const double* b, lapack_int* ldb, double* x,
-                    lapack_int* ldx, double* rcond, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm,
-                    double* err_bnds_comp, lapack_int* nparams, double* params, double* work, lapack_int* iwork,
-                    lapack_int* info);
-void LAPACK_sporfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda,
-                    const float* af, lapack_int* ldaf, const float* s, const float* b, lapack_int* ldb, float* x,
-                    lapack_int* ldx, float* rcond, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
-                    float* err_bnds_comp, lapack_int* nparams, float* params, float* work, lapack_int* iwork,
-                    lapack_int* info);
-void LAPACK_zporfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                    lapack_int* lda, const lapack_complex_double* af, lapack_int* ldaf, const double* s,
-                    const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                    double* rcond, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_cporfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                    lapack_int* lda, const lapack_complex_float* af, lapack_int* ldaf, const float* s,
-                    const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                    float* rcond, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                    lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_spprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* ap, const float* afp, const float* b,
-                   lapack_int* ldb, float* x, lapack_int* ldx, float* ferr, float* berr, float* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dpprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* ap, const double* afp, const double* b,
-                   lapack_int* ldb, double* x, lapack_int* ldx, double* ferr, double* berr, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cpprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   const lapack_complex_float* afp, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work,
-                   float* rwork, lapack_int* info);
-void LAPACK_zpprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap,
-                   const lapack_complex_double* afp, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr, lapack_complex_double* work,
-                   double* rwork, lapack_int* info);
-void LAPACK_spbrfs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const float* ab, lapack_int* ldab,
-                   const float* afb, lapack_int* ldafb, const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                   float* ferr, float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dpbrfs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const double* ab, lapack_int* ldab,
-                   const double* afb, lapack_int* ldafb, const double* b, lapack_int* ldb, double* x, lapack_int* ldx,
-                   double* ferr, double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cpbrfs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const lapack_complex_float* ab,
-                   lapack_int* ldab, const lapack_complex_float* afb, lapack_int* ldafb, const lapack_complex_float* b,
-                   lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zpbrfs(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, const lapack_complex_double* ab,
-                   lapack_int* ldab, const lapack_complex_double* afb, lapack_int* ldafb,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* ferr, double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sptrfs(lapack_int* n, lapack_int* nrhs, const float* d, const float* e, const float* df, const float* ef,
-                   const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* ferr, float* berr, float* work,
-                   lapack_int* info);
-void LAPACK_dptrfs(lapack_int* n, lapack_int* nrhs, const double* d, const double* e, const double* df,
-                   const double* ef, const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
-                   double* berr, double* work, lapack_int* info);
-void LAPACK_cptrfs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* d, const lapack_complex_float* e,
-                   const float* df, const lapack_complex_float* ef, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work,
-                   float* rwork, lapack_int* info);
-void LAPACK_zptrfs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* d, const lapack_complex_double* e,
-                   const double* df, const lapack_complex_double* ef, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr, lapack_complex_double* work,
-                   double* rwork, lapack_int* info);
-void LAPACK_ssyrfs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda, const float* af,
-                   lapack_int* ldaf, const lapack_int* ipiv, const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                   float* ferr, float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dsyrfs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda, const double* af,
-                   lapack_int* ldaf, const lapack_int* ipiv, const double* b, lapack_int* ldb, double* x,
-                   lapack_int* ldx, double* ferr, double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_csyrfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* af, lapack_int* ldaf, const lapack_int* ipiv,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                   float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zsyrfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* af, lapack_int* ldaf, const lapack_int* ipiv,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* ferr, double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_dsyrfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                    const double* af, lapack_int* ldaf, const lapack_int* ipiv, const double* s, const double* b,
-                    lapack_int* ldb, double* x, lapack_int* ldx, double* rcond, double* berr, lapack_int* n_err_bnds,
-                    double* err_bnds_norm, double* err_bnds_comp, lapack_int* nparams, double* params, double* work,
-                    lapack_int* iwork, lapack_int* info);
-void LAPACK_ssyrfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda,
-                    const float* af, lapack_int* ldaf, const lapack_int* ipiv, const float* s, const float* b,
-                    lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* berr, lapack_int* n_err_bnds,
-                    float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams, float* params, float* work,
-                    lapack_int* iwork, lapack_int* info);
-void LAPACK_zsyrfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                    lapack_int* lda, const lapack_complex_double* af, lapack_int* ldaf, const lapack_int* ipiv,
-                    const double* s, const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x,
-                    lapack_int* ldx, double* rcond, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm,
-                    double* err_bnds_comp, lapack_int* nparams, double* params, lapack_complex_double* work,
-                    double* rwork, lapack_int* info);
-void LAPACK_csyrfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                    lapack_int* lda, const lapack_complex_float* af, lapack_int* ldaf, const lapack_int* ipiv,
-                    const float* s, const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x,
-                    lapack_int* ldx, float* rcond, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
-                    float* err_bnds_comp, lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork,
-                    lapack_int* info);
-void LAPACK_cherfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* af, lapack_int* ldaf, const lapack_int* ipiv,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                   float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zherfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* af, lapack_int* ldaf, const lapack_int* ipiv,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* ferr, double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_zherfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                    lapack_int* lda, const lapack_complex_double* af, lapack_int* ldaf, const lapack_int* ipiv,
-                    const double* s, const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x,
-                    lapack_int* ldx, double* rcond, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm,
-                    double* err_bnds_comp, lapack_int* nparams, double* params, lapack_complex_double* work,
-                    double* rwork, lapack_int* info);
-void LAPACK_cherfsx(char* uplo, char* equed, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                    lapack_int* lda, const lapack_complex_float* af, lapack_int* ldaf, const lapack_int* ipiv,
-                    const float* s, const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x,
-                    lapack_int* ldx, float* rcond, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
-                    float* err_bnds_comp, lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork,
-                    lapack_int* info);
-void LAPACK_ssprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const float* ap, const float* afp,
-                   const lapack_int* ipiv, const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* ferr,
-                   float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dsprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const double* ap, const double* afp,
-                   const lapack_int* ipiv, const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* ferr,
-                   double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_csprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   const lapack_complex_float* afp, const lapack_int* ipiv, const lapack_complex_float* b,
-                   lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zsprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap,
-                   const lapack_complex_double* afp, const lapack_int* ipiv, const lapack_complex_double* b,
-                   lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_chprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   const lapack_complex_float* afp, const lapack_int* ipiv, const lapack_complex_float* b,
-                   lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zhprfs(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap,
-                   const lapack_complex_double* afp, const lapack_int* ipiv, const lapack_complex_double* b,
-                   lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_strrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const float* a,
-                   lapack_int* lda, const float* b, lapack_int* ldb, const float* x, lapack_int* ldx, float* ferr,
-                   float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtrrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const double* a,
-                   lapack_int* lda, const double* b, lapack_int* ldb, const double* x, lapack_int* ldx, double* ferr,
-                   double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctrrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* b, lapack_int* ldb, const lapack_complex_float* x,
-                   lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work, float* rwork,
-                   lapack_int* info);
-void LAPACK_ztrrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* b, lapack_int* ldb, const lapack_complex_double* x,
-                   lapack_int* ldx, double* ferr, double* berr, lapack_complex_double* work, double* rwork,
-                   lapack_int* info);
-void LAPACK_stprfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const float* ap,
-                   const float* b, lapack_int* ldb, const float* x, lapack_int* ldx, float* ferr, float* berr,
-                   float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtprfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const double* ap,
-                   const double* b, lapack_int* ldb, const double* x, lapack_int* ldx, double* ferr, double* berr,
-                   double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctprfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   const lapack_complex_float* b, lapack_int* ldb, const lapack_complex_float* x, lapack_int* ldx,
-                   float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_ztprfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* nrhs,
-                   const lapack_complex_double* ap, const lapack_complex_double* b, lapack_int* ldb,
-                   const lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_stbrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const float* ab, lapack_int* ldab, const float* b, lapack_int* ldb, const float* x, lapack_int* ldx,
-                   float* ferr, float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtbrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const double* ab, lapack_int* ldab, const double* b, lapack_int* ldb, const double* x,
-                   lapack_int* ldx, double* ferr, double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctbrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const lapack_complex_float* ab, lapack_int* ldab, const lapack_complex_float* b, lapack_int* ldb,
-                   const lapack_complex_float* x, lapack_int* ldx, float* ferr, float* berr, lapack_complex_float* work,
-                   float* rwork, lapack_int* info);
-void LAPACK_ztbrfs(char* uplo, char* trans, char* diag, lapack_int* n, lapack_int* kd, lapack_int* nrhs,
-                   const lapack_complex_double* ab, lapack_int* ldab, const lapack_complex_double* b, lapack_int* ldb,
-                   const lapack_complex_double* x, lapack_int* ldx, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sgetri(lapack_int* n, float* a, lapack_int* lda, const lapack_int* ipiv, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dgetri(lapack_int* n, double* a, lapack_int* lda, const lapack_int* ipiv, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cgetri(lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgetri(lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_spotri(char* uplo, lapack_int* n, float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dpotri(char* uplo, lapack_int* n, double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_cpotri(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_zpotri(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dpftri(char* transr, char* uplo, lapack_int* n, double* a, lapack_int* info);
-void LAPACK_spftri(char* transr, char* uplo, lapack_int* n, float* a, lapack_int* info);
-void LAPACK_zpftri(char* transr, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* info);
-void LAPACK_cpftri(char* transr, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* info);
-void LAPACK_spptri(char* uplo, lapack_int* n, float* ap, lapack_int* info);
-void LAPACK_dpptri(char* uplo, lapack_int* n, double* ap, lapack_int* info);
-void LAPACK_cpptri(char* uplo, lapack_int* n, lapack_complex_float* ap, lapack_int* info);
-void LAPACK_zpptri(char* uplo, lapack_int* n, lapack_complex_double* ap, lapack_int* info);
-void LAPACK_ssytri(char* uplo, lapack_int* n, float* a, lapack_int* lda, const lapack_int* ipiv, float* work,
-                   lapack_int* info);
-void LAPACK_dsytri(char* uplo, lapack_int* n, double* a, lapack_int* lda, const lapack_int* ipiv, double* work,
-                   lapack_int* info);
-void LAPACK_csytri(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zsytri(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_chetri(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zhetri(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_ssptri(char* uplo, lapack_int* n, float* ap, const lapack_int* ipiv, float* work, lapack_int* info);
-void LAPACK_dsptri(char* uplo, lapack_int* n, double* ap, const lapack_int* ipiv, double* work, lapack_int* info);
-void LAPACK_csptri(char* uplo, lapack_int* n, lapack_complex_float* ap, const lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zsptri(char* uplo, lapack_int* n, lapack_complex_double* ap, const lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_chptri(char* uplo, lapack_int* n, lapack_complex_float* ap, const lapack_int* ipiv,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zhptri(char* uplo, lapack_int* n, lapack_complex_double* ap, const lapack_int* ipiv,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_strtri(char* uplo, char* diag, lapack_int* n, float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dtrtri(char* uplo, char* diag, lapack_int* n, double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_ctrtri(char* uplo, char* diag, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_ztrtri(char* uplo, char* diag, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dtftri(char* transr, char* uplo, char* diag, lapack_int* n, double* a, lapack_int* info);
-void LAPACK_stftri(char* transr, char* uplo, char* diag, lapack_int* n, float* a, lapack_int* info);
-void LAPACK_ztftri(char* transr, char* uplo, char* diag, lapack_int* n, lapack_complex_double* a, lapack_int* info);
-void LAPACK_ctftri(char* transr, char* uplo, char* diag, lapack_int* n, lapack_complex_float* a, lapack_int* info);
-void LAPACK_stptri(char* uplo, char* diag, lapack_int* n, float* ap, lapack_int* info);
-void LAPACK_dtptri(char* uplo, char* diag, lapack_int* n, double* ap, lapack_int* info);
-void LAPACK_ctptri(char* uplo, char* diag, lapack_int* n, lapack_complex_float* ap, lapack_int* info);
-void LAPACK_ztptri(char* uplo, char* diag, lapack_int* n, lapack_complex_double* ap, lapack_int* info);
-void LAPACK_sgeequ(lapack_int* m, lapack_int* n, const float* a, lapack_int* lda, float* r, float* c, float* rowcnd,
-                   float* colcnd, float* amax, lapack_int* info);
-void LAPACK_dgeequ(lapack_int* m, lapack_int* n, const double* a, lapack_int* lda, double* r, double* c, double* rowcnd,
-                   double* colcnd, double* amax, lapack_int* info);
-void LAPACK_cgeequ(lapack_int* m, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* r, float* c,
-                   float* rowcnd, float* colcnd, float* amax, lapack_int* info);
-void LAPACK_zgeequ(lapack_int* m, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* r, double* c,
-                   double* rowcnd, double* colcnd, double* amax, lapack_int* info);
-void LAPACK_dgeequb(lapack_int* m, lapack_int* n, const double* a, lapack_int* lda, double* r, double* c,
-                    double* rowcnd, double* colcnd, double* amax, lapack_int* info);
-void LAPACK_sgeequb(lapack_int* m, lapack_int* n, const float* a, lapack_int* lda, float* r, float* c, float* rowcnd,
-                    float* colcnd, float* amax, lapack_int* info);
-void LAPACK_zgeequb(lapack_int* m, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* r, double* c,
-                    double* rowcnd, double* colcnd, double* amax, lapack_int* info);
-void LAPACK_cgeequb(lapack_int* m, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* r, float* c,
-                    float* rowcnd, float* colcnd, float* amax, lapack_int* info);
-void LAPACK_sgbequ(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const float* ab, lapack_int* ldab,
-                   float* r, float* c, float* rowcnd, float* colcnd, float* amax, lapack_int* info);
-void LAPACK_dgbequ(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const double* ab, lapack_int* ldab,
-                   double* r, double* c, double* rowcnd, double* colcnd, double* amax, lapack_int* info);
-void LAPACK_cgbequ(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const lapack_complex_float* ab,
-                   lapack_int* ldab, float* r, float* c, float* rowcnd, float* colcnd, float* amax, lapack_int* info);
-void LAPACK_zgbequ(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const lapack_complex_double* ab,
-                   lapack_int* ldab, double* r, double* c, double* rowcnd, double* colcnd, double* amax,
-                   lapack_int* info);
-void LAPACK_dgbequb(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const double* ab, lapack_int* ldab,
-                    double* r, double* c, double* rowcnd, double* colcnd, double* amax, lapack_int* info);
-void LAPACK_sgbequb(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const float* ab, lapack_int* ldab,
-                    float* r, float* c, float* rowcnd, float* colcnd, float* amax, lapack_int* info);
-void LAPACK_zgbequb(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const lapack_complex_double* ab,
-                    lapack_int* ldab, double* r, double* c, double* rowcnd, double* colcnd, double* amax,
-                    lapack_int* info);
-void LAPACK_cgbequb(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const lapack_complex_float* ab,
-                    lapack_int* ldab, float* r, float* c, float* rowcnd, float* colcnd, float* amax, lapack_int* info);
-void LAPACK_spoequ(lapack_int* n, const float* a, lapack_int* lda, float* s, float* scond, float* amax,
-                   lapack_int* info);
-void LAPACK_dpoequ(lapack_int* n, const double* a, lapack_int* lda, double* s, double* scond, double* amax,
-                   lapack_int* info);
-void LAPACK_cpoequ(lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* s, float* scond, float* amax,
-                   lapack_int* info);
-void LAPACK_zpoequ(lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* s, double* scond,
-                   double* amax, lapack_int* info);
-void LAPACK_dpoequb(lapack_int* n, const double* a, lapack_int* lda, double* s, double* scond, double* amax,
-                    lapack_int* info);
-void LAPACK_spoequb(lapack_int* n, const float* a, lapack_int* lda, float* s, float* scond, float* amax,
-                    lapack_int* info);
-void LAPACK_zpoequb(lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* s, double* scond,
-                    double* amax, lapack_int* info);
-void LAPACK_cpoequb(lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* s, float* scond, float* amax,
-                    lapack_int* info);
-void LAPACK_sppequ(char* uplo, lapack_int* n, const float* ap, float* s, float* scond, float* amax, lapack_int* info);
-void LAPACK_dppequ(char* uplo, lapack_int* n, const double* ap, double* s, double* scond, double* amax,
-                   lapack_int* info);
-void LAPACK_cppequ(char* uplo, lapack_int* n, const lapack_complex_float* ap, float* s, float* scond, float* amax,
-                   lapack_int* info);
-void LAPACK_zppequ(char* uplo, lapack_int* n, const lapack_complex_double* ap, double* s, double* scond, double* amax,
-                   lapack_int* info);
-void LAPACK_spbequ(char* uplo, lapack_int* n, lapack_int* kd, const float* ab, lapack_int* ldab, float* s, float* scond,
-                   float* amax, lapack_int* info);
-void LAPACK_dpbequ(char* uplo, lapack_int* n, lapack_int* kd, const double* ab, lapack_int* ldab, double* s,
-                   double* scond, double* amax, lapack_int* info);
-void LAPACK_cpbequ(char* uplo, lapack_int* n, lapack_int* kd, const lapack_complex_float* ab, lapack_int* ldab,
-                   float* s, float* scond, float* amax, lapack_int* info);
-void LAPACK_zpbequ(char* uplo, lapack_int* n, lapack_int* kd, const lapack_complex_double* ab, lapack_int* ldab,
-                   double* s, double* scond, double* amax, lapack_int* info);
-void LAPACK_dsyequb(char* uplo, lapack_int* n, const double* a, lapack_int* lda, double* s, double* scond, double* amax,
-                    double* work, lapack_int* info);
-void LAPACK_ssyequb(char* uplo, lapack_int* n, const float* a, lapack_int* lda, float* s, float* scond, float* amax,
-                    float* work, lapack_int* info);
-void LAPACK_zsyequb(char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* s,
-                    double* scond, double* amax, lapack_complex_double* work, lapack_int* info);
-void LAPACK_csyequb(char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* s, float* scond,
-                    float* amax, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zheequb(char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda, double* s,
-                    double* scond, double* amax, lapack_complex_double* work, lapack_int* info);
-void LAPACK_cheequb(char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* s, float* scond,
-                    float* amax, lapack_complex_float* work, lapack_int* info);
-void LAPACK_sgesv(lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, lapack_int* ipiv, float* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_dgesv(lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, lapack_int* ipiv, double* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_cgesv(lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
-                  lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zgesv(lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
-                  lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dsgesv(lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, lapack_int* ipiv, double* b,
-                   lapack_int* ldb, double* x, lapack_int* ldx, double* work, float* swork, lapack_int* iter,
-                   lapack_int* info);
-void LAPACK_zcgesv(lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   lapack_complex_double* work, lapack_complex_float* swork, double* rwork, lapack_int* iter,
-                   lapack_int* info);
-void LAPACK_sgesvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* af,
-                   lapack_int* ldaf, lapack_int* ipiv, char* equed, float* r, float* c, float* b, lapack_int* ldb,
-                   float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr, float* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dgesvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* af,
-                   lapack_int* ldaf, lapack_int* ipiv, char* equed, double* r, double* c, double* b, lapack_int* ldb,
-                   double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cgesvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, float* r, float* c,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond,
-                   float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgesvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, double* r, double* c,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond,
-                   double* ferr, double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_dgesvxx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* af,
-                    lapack_int* ldaf, lapack_int* ipiv, char* equed, double* r, double* c, double* b, lapack_int* ldb,
-                    double* x, lapack_int* ldx, double* rcond, double* rpvgrw, double* berr, lapack_int* n_err_bnds,
-                    double* err_bnds_norm, double* err_bnds_comp, lapack_int* nparams, double* params, double* work,
-                    lapack_int* iwork, lapack_int* info);
-void LAPACK_sgesvxx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* af,
-                    lapack_int* ldaf, lapack_int* ipiv, char* equed, float* r, float* c, float* b, lapack_int* ldb,
-                    float* x, lapack_int* ldx, float* rcond, float* rpvgrw, float* berr, lapack_int* n_err_bnds,
-                    float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams, float* params, float* work,
-                    lapack_int* iwork, lapack_int* info);
-void LAPACK_zgesvxx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                    lapack_complex_double* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, double* r, double* c,
-                    lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond,
-                    double* rpvgrw, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_cgesvxx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                    lapack_complex_float* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, float* r, float* c,
-                    lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond,
-                    float* rpvgrw, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                    lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_sgbsv(lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, float* ab, lapack_int* ldab,
-                  lapack_int* ipiv, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dgbsv(lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, double* ab, lapack_int* ldab,
-                  lapack_int* ipiv, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cgbsv(lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, lapack_complex_float* ab,
-                  lapack_int* ldab, lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zgbsv(lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, lapack_complex_double* ab,
-                  lapack_int* ldab, lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_sgbsvx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, float* ab,
-                   lapack_int* ldab, float* afb, lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r, float* c,
-                   float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dgbsvx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, double* ab,
-                   lapack_int* ldab, double* afb, lapack_int* ldafb, lapack_int* ipiv, char* equed, double* r,
-                   double* c, double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond, double* ferr,
-                   double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cgbsvx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                   lapack_complex_float* ab, lapack_int* ldab, lapack_complex_float* afb, lapack_int* ldafb,
-                   lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgbsvx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                   lapack_complex_double* ab, lapack_int* ldab, lapack_complex_double* afb, lapack_int* ldafb,
-                   lapack_int* ipiv, char* equed, double* r, double* c, lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_dgbsvxx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    double* ab, lapack_int* ldab, double* afb, lapack_int* ldafb, lapack_int* ipiv, char* equed,
-                    double* r, double* c, double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
-                    double* rpvgrw, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_sgbsvxx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs, float* ab,
-                    lapack_int* ldab, float* afb, lapack_int* ldafb, lapack_int* ipiv, char* equed, float* r, float* c,
-                    float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
-                    lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams,
-                    float* params, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_zgbsvxx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    lapack_complex_double* ab, lapack_int* ldab, lapack_complex_double* afb, lapack_int* ldafb,
-                    lapack_int* ipiv, char* equed, double* r, double* c, lapack_complex_double* b, lapack_int* ldb,
-                    lapack_complex_double* x, lapack_int* ldx, double* rcond, double* rpvgrw, double* berr,
-                    lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp, lapack_int* nparams,
-                    double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_cgbsvxx(char* fact, char* trans, lapack_int* n, lapack_int* kl, lapack_int* ku, lapack_int* nrhs,
-                    lapack_complex_float* ab, lapack_int* ldab, lapack_complex_float* afb, lapack_int* ldafb,
-                    lapack_int* ipiv, char* equed, float* r, float* c, lapack_complex_float* b, lapack_int* ldb,
-                    lapack_complex_float* x, lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
-                    lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams,
-                    float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_sgtsv(lapack_int* n, lapack_int* nrhs, float* dl, float* d, float* du, float* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_dgtsv(lapack_int* n, lapack_int* nrhs, double* dl, double* d, double* du, double* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_cgtsv(lapack_int* n, lapack_int* nrhs, lapack_complex_float* dl, lapack_complex_float* d,
-                  lapack_complex_float* du, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zgtsv(lapack_int* n, lapack_int* nrhs, lapack_complex_double* dl, lapack_complex_double* d,
-                  lapack_complex_double* du, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_sgtsvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, const float* dl, const float* d,
-                   const float* du, float* dlf, float* df, float* duf, float* du2, lapack_int* ipiv, const float* b,
-                   lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dgtsvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, const double* dl, const double* d,
-                   const double* du, double* dlf, double* df, double* duf, double* du2, lapack_int* ipiv,
-                   const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond, double* ferr,
-                   double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cgtsvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* dl,
-                   const lapack_complex_float* d, const lapack_complex_float* du, lapack_complex_float* dlf,
-                   lapack_complex_float* df, lapack_complex_float* duf, lapack_complex_float* du2, lapack_int* ipiv,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                   float* rcond, float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgtsvx(char* fact, char* trans, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* dl,
-                   const lapack_complex_double* d, const lapack_complex_double* du, lapack_complex_double* dlf,
-                   lapack_complex_double* df, lapack_complex_double* duf, lapack_complex_double* du2, lapack_int* ipiv,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* rcond, double* ferr, double* berr, lapack_complex_double* work, double* rwork,
-                   lapack_int* info);
-void LAPACK_sposv(char* uplo, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_dposv(char* uplo, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_cposv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                  lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zposv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                  lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dsposv(char* uplo, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* b, lapack_int* ldb,
-                   double* x, lapack_int* ldx, double* work, float* swork, lapack_int* iter, lapack_int* info);
-void LAPACK_zcposv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   lapack_complex_double* work, lapack_complex_float* swork, double* rwork, lapack_int* iter,
-                   lapack_int* info);
-void LAPACK_sposvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* af,
-                   lapack_int* ldaf, char* equed, float* s, float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                   float* rcond, float* ferr, float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dposvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* af,
-                   lapack_int* ldaf, char* equed, double* s, double* b, lapack_int* ldb, double* x, lapack_int* ldx,
-                   double* rcond, double* ferr, double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cposvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* af, lapack_int* ldaf, char* equed, float* s, lapack_complex_float* b,
-                   lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zposvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* af, lapack_int* ldaf, char* equed, double* s, lapack_complex_double* b,
-                   lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond, double* ferr,
-                   double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_dposvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* af,
-                    lapack_int* ldaf, char* equed, double* s, double* b, lapack_int* ldb, double* x, lapack_int* ldx,
-                    double* rcond, double* rpvgrw, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm,
-                    double* err_bnds_comp, lapack_int* nparams, double* params, double* work, lapack_int* iwork,
-                    lapack_int* info);
-void LAPACK_sposvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* af,
-                    lapack_int* ldaf, char* equed, float* s, float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                    float* rcond, float* rpvgrw, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm,
-                    float* err_bnds_comp, lapack_int* nparams, float* params, float* work, lapack_int* iwork,
-                    lapack_int* info);
-void LAPACK_zposvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                    lapack_complex_double* af, lapack_int* ldaf, char* equed, double* s, lapack_complex_double* b,
-                    lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond, double* rpvgrw,
-                    double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_cposvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                    lapack_complex_float* af, lapack_int* ldaf, char* equed, float* s, lapack_complex_float* b,
-                    lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond, float* rpvgrw, float* berr,
-                    lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams,
-                    float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_sppsv(char* uplo, lapack_int* n, lapack_int* nrhs, float* ap, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dppsv(char* uplo, lapack_int* n, lapack_int* nrhs, double* ap, double* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_cppsv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* ap, lapack_complex_float* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_zppsv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* ap, lapack_complex_double* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_sppsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, float* ap, float* afp, char* equed,
-                   float* s, float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* ferr,
-                   float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dppsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, double* ap, double* afp, char* equed,
-                   double* s, double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond, double* ferr,
-                   double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cppsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* ap,
-                   lapack_complex_float* afp, char* equed, float* s, lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zppsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* ap,
-                   lapack_complex_double* afp, char* equed, double* s, lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_spbsv(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, float* ab, lapack_int* ldab, float* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_dpbsv(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, double* ab, lapack_int* ldab, double* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_cpbsv(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, lapack_complex_float* ab,
-                  lapack_int* ldab, lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zpbsv(char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, lapack_complex_double* ab,
-                  lapack_int* ldab, lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_spbsvx(char* fact, char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, float* ab, lapack_int* ldab,
-                   float* afb, lapack_int* ldafb, char* equed, float* s, float* b, lapack_int* ldb, float* x,
-                   lapack_int* ldx, float* rcond, float* ferr, float* berr, float* work, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dpbsvx(char* fact, char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, double* ab,
-                   lapack_int* ldab, double* afb, lapack_int* ldafb, char* equed, double* s, double* b, lapack_int* ldb,
-                   double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cpbsvx(char* fact, char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, lapack_complex_float* ab,
-                   lapack_int* ldab, lapack_complex_float* afb, lapack_int* ldafb, char* equed, float* s,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond,
-                   float* ferr, float* berr, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zpbsvx(char* fact, char* uplo, lapack_int* n, lapack_int* kd, lapack_int* nrhs, lapack_complex_double* ab,
-                   lapack_int* ldab, lapack_complex_double* afb, lapack_int* ldafb, char* equed, double* s,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond,
-                   double* ferr, double* berr, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sptsv(lapack_int* n, lapack_int* nrhs, float* d, float* e, float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_dptsv(lapack_int* n, lapack_int* nrhs, double* d, double* e, double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_cptsv(lapack_int* n, lapack_int* nrhs, float* d, lapack_complex_float* e, lapack_complex_float* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_zptsv(lapack_int* n, lapack_int* nrhs, double* d, lapack_complex_double* e, lapack_complex_double* b,
-                  lapack_int* ldb, lapack_int* info);
-void LAPACK_sptsvx(char* fact, lapack_int* n, lapack_int* nrhs, const float* d, const float* e, float* df, float* ef,
-                   const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   float* work, lapack_int* info);
-void LAPACK_dptsvx(char* fact, lapack_int* n, lapack_int* nrhs, const double* d, const double* e, double* df,
-                   double* ef, const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
-                   double* ferr, double* berr, double* work, lapack_int* info);
-void LAPACK_cptsvx(char* fact, lapack_int* n, lapack_int* nrhs, const float* d, const lapack_complex_float* e,
-                   float* df, lapack_complex_float* ef, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zptsvx(char* fact, lapack_int* n, lapack_int* nrhs, const double* d, const lapack_complex_double* e,
-                   double* df, lapack_complex_double* ef, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_ssysv(char* uplo, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, lapack_int* ipiv, float* b,
-                  lapack_int* ldb, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dsysv(char* uplo, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, lapack_int* ipiv, double* b,
-                  lapack_int* ldb, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_csysv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                  lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_zsysv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                  lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_ssysvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda, float* af,
-                   lapack_int* ldaf, lapack_int* ipiv, const float* b, lapack_int* ldb, float* x, lapack_int* ldx,
-                   float* rcond, float* ferr, float* berr, float* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dsysvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                   double* af, lapack_int* ldaf, lapack_int* ipiv, const double* b, lapack_int* ldb, double* x,
-                   lapack_int* ldx, double* rcond, double* ferr, double* berr, double* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_csysvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* af, lapack_int* ldaf, lapack_int* ipiv,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                   float* rcond, float* ferr, float* berr, lapack_complex_float* work, lapack_int* lwork, float* rwork,
-                   lapack_int* info);
-void LAPACK_zsysvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* af, lapack_int* ldaf, lapack_int* ipiv,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* rcond, double* ferr, double* berr, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* info);
-void LAPACK_dsysvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* af,
-                    lapack_int* ldaf, lapack_int* ipiv, char* equed, double* s, double* b, lapack_int* ldb, double* x,
-                    lapack_int* ldx, double* rcond, double* rpvgrw, double* berr, lapack_int* n_err_bnds,
-                    double* err_bnds_norm, double* err_bnds_comp, lapack_int* nparams, double* params, double* work,
-                    lapack_int* iwork, lapack_int* info);
-void LAPACK_ssysvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* af,
-                    lapack_int* ldaf, lapack_int* ipiv, char* equed, float* s, float* b, lapack_int* ldb, float* x,
-                    lapack_int* ldx, float* rcond, float* rpvgrw, float* berr, lapack_int* n_err_bnds,
-                    float* err_bnds_norm, float* err_bnds_comp, lapack_int* nparams, float* params, float* work,
-                    lapack_int* iwork, lapack_int* info);
-void LAPACK_zsysvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                    lapack_complex_double* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, double* s,
-                    lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond,
-                    double* rpvgrw, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_csysvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                    lapack_complex_float* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, float* s,
-                    lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond,
-                    float* rpvgrw, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                    lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_chesv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                  lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_zhesv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                  lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_chesvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* af, lapack_int* ldaf, lapack_int* ipiv,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx,
-                   float* rcond, float* ferr, float* berr, lapack_complex_float* work, lapack_int* lwork, float* rwork,
-                   lapack_int* info);
-void LAPACK_zhesvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* af, lapack_int* ldaf, lapack_int* ipiv,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx,
-                   double* rcond, double* ferr, double* berr, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* info);
-void LAPACK_zhesvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                    lapack_complex_double* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, double* s,
-                    lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* x, lapack_int* ldx, double* rcond,
-                    double* rpvgrw, double* berr, lapack_int* n_err_bnds, double* err_bnds_norm, double* err_bnds_comp,
-                    lapack_int* nparams, double* params, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_chesvxx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                    lapack_complex_float* af, lapack_int* ldaf, lapack_int* ipiv, char* equed, float* s,
-                    lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* x, lapack_int* ldx, float* rcond,
-                    float* rpvgrw, float* berr, lapack_int* n_err_bnds, float* err_bnds_norm, float* err_bnds_comp,
-                    lapack_int* nparams, float* params, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_sspsv(char* uplo, lapack_int* n, lapack_int* nrhs, float* ap, lapack_int* ipiv, float* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_dspsv(char* uplo, lapack_int* n, lapack_int* nrhs, double* ap, lapack_int* ipiv, double* b, lapack_int* ldb,
-                  lapack_int* info);
-void LAPACK_cspsv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* ap, lapack_int* ipiv,
-                  lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zspsv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* ap, lapack_int* ipiv,
-                  lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_sspsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const float* ap, float* afp,
-                   lapack_int* ipiv, const float* b, lapack_int* ldb, float* x, lapack_int* ldx, float* rcond,
-                   float* ferr, float* berr, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dspsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const double* ap, double* afp,
-                   lapack_int* ipiv, const double* b, lapack_int* ldb, double* x, lapack_int* ldx, double* rcond,
-                   double* ferr, double* berr, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_cspsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   lapack_complex_float* afp, lapack_int* ipiv, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zspsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap,
-                   lapack_complex_double* afp, lapack_int* ipiv, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_chpsv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_float* ap, lapack_int* ipiv,
-                  lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zhpsv(char* uplo, lapack_int* n, lapack_int* nrhs, lapack_complex_double* ap, lapack_int* ipiv,
-                  lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_chpsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* ap,
-                   lapack_complex_float* afp, lapack_int* ipiv, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* x, lapack_int* ldx, float* rcond, float* ferr, float* berr,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zhpsvx(char* fact, char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* ap,
-                   lapack_complex_double* afp, lapack_int* ipiv, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* x, lapack_int* ldx, double* rcond, double* ferr, double* berr,
-                   lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sgeqrf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dgeqrf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_cgeqrf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgeqrf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sgeqpf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, lapack_int* jpvt, float* tau, float* work,
-                   lapack_int* info);
-void LAPACK_dgeqpf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, lapack_int* jpvt, double* tau,
-                   double* work, lapack_int* info);
-void LAPACK_cgeqpf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* jpvt,
-                   lapack_complex_float* tau, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgeqpf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* jpvt,
-                   lapack_complex_double* tau, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sgeqp3(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, lapack_int* jpvt, float* tau, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_dgeqp3(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, lapack_int* jpvt, double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cgeqp3(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* jpvt,
-                   lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, float* rwork,
-                   lapack_int* info);
-void LAPACK_zgeqp3(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* jpvt,
-                   lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, double* rwork,
-                   lapack_int* info);
-void LAPACK_sorgqr(lapack_int* m, lapack_int* n, lapack_int* k, float* a, lapack_int* lda, const float* tau,
-                   float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorgqr(lapack_int* m, lapack_int* n, lapack_int* k, double* a, lapack_int* lda, const double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormqr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const float* a,
-                   lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dormqr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const double* a,
-                   lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cungqr(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zungqr(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cunmqr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* tau, lapack_complex_float* c, lapack_int* ldc,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunmqr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* tau, lapack_complex_double* c, lapack_int* ldc,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sgelqf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dgelqf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_cgelqf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgelqf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sorglq(lapack_int* m, lapack_int* n, lapack_int* k, float* a, lapack_int* lda, const float* tau,
-                   float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorglq(lapack_int* m, lapack_int* n, lapack_int* k, double* a, lapack_int* lda, const double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormlq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const float* a,
-                   lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dormlq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const double* a,
-                   lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cunglq(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunglq(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cunmlq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* tau, lapack_complex_float* c, lapack_int* ldc,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunmlq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* tau, lapack_complex_double* c, lapack_int* ldc,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sgeqlf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dgeqlf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_cgeqlf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgeqlf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sorgql(lapack_int* m, lapack_int* n, lapack_int* k, float* a, lapack_int* lda, const float* tau,
-                   float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorgql(lapack_int* m, lapack_int* n, lapack_int* k, double* a, lapack_int* lda, const double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cungql(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zungql(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormql(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const float* a,
-                   lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dormql(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const double* a,
-                   lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cunmql(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* tau, lapack_complex_float* c, lapack_int* ldc,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunmql(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* tau, lapack_complex_double* c, lapack_int* ldc,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sgerqf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dgerqf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_cgerqf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgerqf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sorgrq(lapack_int* m, lapack_int* n, lapack_int* k, float* a, lapack_int* lda, const float* tau,
-                   float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorgrq(lapack_int* m, lapack_int* n, lapack_int* k, double* a, lapack_int* lda, const double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cungrq(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zungrq(lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormrq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const float* a,
-                   lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dormrq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const double* a,
-                   lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cunmrq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* tau, lapack_complex_float* c, lapack_int* ldc,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunmrq(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* tau, lapack_complex_double* c, lapack_int* ldc,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_stzrzf(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dtzrzf(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_ctzrzf(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ztzrzf(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormrz(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l, const float* a,
-                   lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dormrz(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l, const double* a,
-                   lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cunmrz(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
-                   const lapack_complex_float* a, lapack_int* lda, const lapack_complex_float* tau,
-                   lapack_complex_float* c, lapack_int* ldc, lapack_complex_float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_zunmrz(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l,
-                   const lapack_complex_double* a, lapack_int* lda, const lapack_complex_double* tau,
-                   lapack_complex_double* c, lapack_int* ldc, lapack_complex_double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_sggqrf(lapack_int* n, lapack_int* m, lapack_int* p, float* a, lapack_int* lda, float* taua, float* b,
-                   lapack_int* ldb, float* taub, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dggqrf(lapack_int* n, lapack_int* m, lapack_int* p, double* a, lapack_int* lda, double* taua, double* b,
-                   lapack_int* ldb, double* taub, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cggqrf(lapack_int* n, lapack_int* m, lapack_int* p, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* taua, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* taub,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zggqrf(lapack_int* n, lapack_int* m, lapack_int* p, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* taua, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* taub,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sggrqf(lapack_int* m, lapack_int* p, lapack_int* n, float* a, lapack_int* lda, float* taua, float* b,
-                   lapack_int* ldb, float* taub, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dggrqf(lapack_int* m, lapack_int* p, lapack_int* n, double* a, lapack_int* lda, double* taua, double* b,
-                   lapack_int* ldb, double* taub, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cggrqf(lapack_int* m, lapack_int* p, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* taua, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* taub,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zggrqf(lapack_int* m, lapack_int* p, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* taua, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* taub,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sgebrd(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* d, float* e, float* tauq,
-                   float* taup, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgebrd(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* d, double* e, double* tauq,
-                   double* taup, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cgebrd(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, float* d, float* e,
-                   lapack_complex_float* tauq, lapack_complex_float* taup, lapack_complex_float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_zgebrd(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, double* d, double* e,
-                   lapack_complex_double* tauq, lapack_complex_double* taup, lapack_complex_double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_sgbbrd(char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc, lapack_int* kl, lapack_int* ku, float* ab,
-                   lapack_int* ldab, float* d, float* e, float* q, lapack_int* ldq, float* pt, lapack_int* ldpt,
-                   float* c, lapack_int* ldc, float* work, lapack_int* info);
-void LAPACK_dgbbrd(char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc, lapack_int* kl, lapack_int* ku,
-                   double* ab, lapack_int* ldab, double* d, double* e, double* q, lapack_int* ldq, double* pt,
-                   lapack_int* ldpt, double* c, lapack_int* ldc, double* work, lapack_int* info);
-void LAPACK_cgbbrd(char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc, lapack_int* kl, lapack_int* ku,
-                   lapack_complex_float* ab, lapack_int* ldab, float* d, float* e, lapack_complex_float* q,
-                   lapack_int* ldq, lapack_complex_float* pt, lapack_int* ldpt, lapack_complex_float* c,
-                   lapack_int* ldc, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zgbbrd(char* vect, lapack_int* m, lapack_int* n, lapack_int* ncc, lapack_int* kl, lapack_int* ku,
-                   lapack_complex_double* ab, lapack_int* ldab, double* d, double* e, lapack_complex_double* q,
-                   lapack_int* ldq, lapack_complex_double* pt, lapack_int* ldpt, lapack_complex_double* c,
-                   lapack_int* ldc, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sorgbr(char* vect, lapack_int* m, lapack_int* n, lapack_int* k, float* a, lapack_int* lda, const float* tau,
-                   float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorgbr(char* vect, lapack_int* m, lapack_int* n, lapack_int* k, double* a, lapack_int* lda,
-                   const double* tau, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormbr(char* vect, char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const float* a,
-                   lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_dormbr(char* vect, char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, const double* a,
-                   lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cungbr(char* vect, lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zungbr(char* vect, lapack_int* m, lapack_int* n, lapack_int* k, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cunmbr(char* vect, char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k,
-                   const lapack_complex_float* a, lapack_int* lda, const lapack_complex_float* tau,
-                   lapack_complex_float* c, lapack_int* ldc, lapack_complex_float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_zunmbr(char* vect, char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k,
-                   const lapack_complex_double* a, lapack_int* lda, const lapack_complex_double* tau,
-                   lapack_complex_double* c, lapack_int* ldc, lapack_complex_double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_sbdsqr(char* uplo, lapack_int* n, lapack_int* ncvt, lapack_int* nru, lapack_int* ncc, float* d, float* e,
-                   float* vt, lapack_int* ldvt, float* u, lapack_int* ldu, float* c, lapack_int* ldc, float* work,
-                   lapack_int* info);
-void LAPACK_dbdsqr(char* uplo, lapack_int* n, lapack_int* ncvt, lapack_int* nru, lapack_int* ncc, double* d, double* e,
-                   double* vt, lapack_int* ldvt, double* u, lapack_int* ldu, double* c, lapack_int* ldc, double* work,
-                   lapack_int* info);
-void LAPACK_cbdsqr(char* uplo, lapack_int* n, lapack_int* ncvt, lapack_int* nru, lapack_int* ncc, float* d, float* e,
-                   lapack_complex_float* vt, lapack_int* ldvt, lapack_complex_float* u, lapack_int* ldu,
-                   lapack_complex_float* c, lapack_int* ldc, float* work, lapack_int* info);
-void LAPACK_zbdsqr(char* uplo, lapack_int* n, lapack_int* ncvt, lapack_int* nru, lapack_int* ncc, double* d, double* e,
-                   lapack_complex_double* vt, lapack_int* ldvt, lapack_complex_double* u, lapack_int* ldu,
-                   lapack_complex_double* c, lapack_int* ldc, double* work, lapack_int* info);
-void LAPACK_sbdsdc(char* uplo, char* compq, lapack_int* n, float* d, float* e, float* u, lapack_int* ldu, float* vt,
-                   lapack_int* ldvt, float* q, lapack_int* iq, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dbdsdc(char* uplo, char* compq, lapack_int* n, double* d, double* e, double* u, lapack_int* ldu, double* vt,
-                   lapack_int* ldvt, double* q, lapack_int* iq, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_ssytrd(char* uplo, lapack_int* n, float* a, lapack_int* lda, float* d, float* e, float* tau, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_dsytrd(char* uplo, lapack_int* n, double* a, lapack_int* lda, double* d, double* e, double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sorgtr(char* uplo, lapack_int* n, float* a, lapack_int* lda, const float* tau, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_dorgtr(char* uplo, lapack_int* n, double* a, lapack_int* lda, const double* tau, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_sormtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const float* a, lapack_int* lda,
-                   const float* tau, float* c, lapack_int* ldc, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dormtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const double* a, lapack_int* lda,
-                   const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_chetrd(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, float* d, float* e,
-                   lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zhetrd(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, double* d, double* e,
-                   lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cungtr(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zungtr(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cunmtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* tau, lapack_complex_float* c, lapack_int* ldc,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunmtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* tau, lapack_complex_double* c, lapack_int* ldc,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ssptrd(char* uplo, lapack_int* n, float* ap, float* d, float* e, float* tau, lapack_int* info);
-void LAPACK_dsptrd(char* uplo, lapack_int* n, double* ap, double* d, double* e, double* tau, lapack_int* info);
-void LAPACK_sopgtr(char* uplo, lapack_int* n, const float* ap, const float* tau, float* q, lapack_int* ldq, float* work,
-                   lapack_int* info);
-void LAPACK_dopgtr(char* uplo, lapack_int* n, const double* ap, const double* tau, double* q, lapack_int* ldq,
-                   double* work, lapack_int* info);
-void LAPACK_sopmtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const float* ap, const float* tau,
-                   float* c, lapack_int* ldc, float* work, lapack_int* info);
-void LAPACK_dopmtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const double* ap,
-                   const double* tau, double* c, lapack_int* ldc, double* work, lapack_int* info);
-void LAPACK_chptrd(char* uplo, lapack_int* n, lapack_complex_float* ap, float* d, float* e, lapack_complex_float* tau,
-                   lapack_int* info);
-void LAPACK_zhptrd(char* uplo, lapack_int* n, lapack_complex_double* ap, double* d, double* e,
-                   lapack_complex_double* tau, lapack_int* info);
-void LAPACK_cupgtr(char* uplo, lapack_int* n, const lapack_complex_float* ap, const lapack_complex_float* tau,
-                   lapack_complex_float* q, lapack_int* ldq, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zupgtr(char* uplo, lapack_int* n, const lapack_complex_double* ap, const lapack_complex_double* tau,
-                   lapack_complex_double* q, lapack_int* ldq, lapack_complex_double* work, lapack_int* info);
-void LAPACK_cupmtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const lapack_complex_float* ap,
-                   const lapack_complex_float* tau, lapack_complex_float* c, lapack_int* ldc,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zupmtr(char* side, char* uplo, char* trans, lapack_int* m, lapack_int* n, const lapack_complex_double* ap,
-                   const lapack_complex_double* tau, lapack_complex_double* c, lapack_int* ldc,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_ssbtrd(char* vect, char* uplo, lapack_int* n, lapack_int* kd, float* ab, lapack_int* ldab, float* d,
-                   float* e, float* q, lapack_int* ldq, float* work, lapack_int* info);
-void LAPACK_dsbtrd(char* vect, char* uplo, lapack_int* n, lapack_int* kd, double* ab, lapack_int* ldab, double* d,
-                   double* e, double* q, lapack_int* ldq, double* work, lapack_int* info);
-void LAPACK_chbtrd(char* vect, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
-                   float* d, float* e, lapack_complex_float* q, lapack_int* ldq, lapack_complex_float* work,
-                   lapack_int* info);
-void LAPACK_zhbtrd(char* vect, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
-                   double* d, double* e, lapack_complex_double* q, lapack_int* ldq, lapack_complex_double* work,
-                   lapack_int* info);
-void LAPACK_ssterf(lapack_int* n, float* d, float* e, lapack_int* info);
-void LAPACK_dsterf(lapack_int* n, double* d, double* e, lapack_int* info);
-void LAPACK_ssteqr(char* compz, lapack_int* n, float* d, float* e, float* z, lapack_int* ldz, float* work,
-                   lapack_int* info);
-void LAPACK_dsteqr(char* compz, lapack_int* n, double* d, double* e, double* z, lapack_int* ldz, double* work,
-                   lapack_int* info);
-void LAPACK_csteqr(char* compz, lapack_int* n, float* d, float* e, lapack_complex_float* z, lapack_int* ldz,
-                   float* work, lapack_int* info);
-void LAPACK_zsteqr(char* compz, lapack_int* n, double* d, double* e, lapack_complex_double* z, lapack_int* ldz,
-                   double* work, lapack_int* info);
-void LAPACK_sstemr(char* jobz, char* range, lapack_int* n, float* d, float* e, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, lapack_int* m, float* w, float* z, lapack_int* ldz, lapack_int* nzc,
-                   lapack_int* isuppz, lapack_logical* tryrac, float* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_dstemr(char* jobz, char* range, lapack_int* n, double* d, double* e, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, lapack_int* m, double* w, double* z, lapack_int* ldz, lapack_int* nzc,
-                   lapack_int* isuppz, lapack_logical* tryrac, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_cstemr(char* jobz, char* range, lapack_int* n, float* d, float* e, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, lapack_int* m, float* w, lapack_complex_float* z, lapack_int* ldz, lapack_int* nzc,
-                   lapack_int* isuppz, lapack_logical* tryrac, float* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_zstemr(char* jobz, char* range, lapack_int* n, double* d, double* e, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, lapack_int* m, double* w, lapack_complex_double* z, lapack_int* ldz, lapack_int* nzc,
-                   lapack_int* isuppz, lapack_logical* tryrac, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_sstedc(char* compz, lapack_int* n, float* d, float* e, float* z, lapack_int* ldz, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_dstedc(char* compz, lapack_int* n, double* d, double* e, double* z, lapack_int* ldz, double* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_cstedc(char* compz, lapack_int* n, float* d, float* e, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* lrwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_zstedc(char* compz, lapack_int* n, double* d, double* e, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* lrwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_sstegr(char* jobz, char* range, lapack_int* n, float* d, float* e, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz,
-                   lapack_int* isuppz, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dstegr(char* jobz, char* range, lapack_int* n, double* d, double* e, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z, lapack_int* ldz,
-                   lapack_int* isuppz, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_cstegr(char* jobz, char* range, lapack_int* n, float* d, float* e, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_int* isuppz, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_zstegr(char* jobz, char* range, lapack_int* n, double* d, double* e, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, double* abstol, lapack_int* m, double* w, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_int* isuppz, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_spteqr(char* compz, lapack_int* n, float* d, float* e, float* z, lapack_int* ldz, float* work,
-                   lapack_int* info);
-void LAPACK_dpteqr(char* compz, lapack_int* n, double* d, double* e, double* z, lapack_int* ldz, double* work,
-                   lapack_int* info);
-void LAPACK_cpteqr(char* compz, lapack_int* n, float* d, float* e, lapack_complex_float* z, lapack_int* ldz,
-                   float* work, lapack_int* info);
-void LAPACK_zpteqr(char* compz, lapack_int* n, double* d, double* e, lapack_complex_double* z, lapack_int* ldz,
-                   double* work, lapack_int* info);
-void LAPACK_sstebz(char* range, char* order, lapack_int* n, float* vl, float* vu, lapack_int* il, lapack_int* iu,
-                   float* abstol, const float* d, const float* e, lapack_int* m, lapack_int* nsplit, float* w,
-                   lapack_int* iblock, lapack_int* isplit, float* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_dstebz(char* range, char* order, lapack_int* n, double* vl, double* vu, lapack_int* il, lapack_int* iu,
-                   double* abstol, const double* d, const double* e, lapack_int* m, lapack_int* nsplit, double* w,
-                   lapack_int* iblock, lapack_int* isplit, double* work, lapack_int* iwork, lapack_int* info);
-void LAPACK_sstein(lapack_int* n, const float* d, const float* e, lapack_int* m, const float* w,
-                   const lapack_int* iblock, const lapack_int* isplit, float* z, lapack_int* ldz, float* work,
-                   lapack_int* iwork, lapack_int* ifailv, lapack_int* info);
-void LAPACK_dstein(lapack_int* n, const double* d, const double* e, lapack_int* m, const double* w,
-                   const lapack_int* iblock, const lapack_int* isplit, double* z, lapack_int* ldz, double* work,
-                   lapack_int* iwork, lapack_int* ifailv, lapack_int* info);
-void LAPACK_cstein(lapack_int* n, const float* d, const float* e, lapack_int* m, const float* w,
-                   const lapack_int* iblock, const lapack_int* isplit, lapack_complex_float* z, lapack_int* ldz,
-                   float* work, lapack_int* iwork, lapack_int* ifailv, lapack_int* info);
-void LAPACK_zstein(lapack_int* n, const double* d, const double* e, lapack_int* m, const double* w,
-                   const lapack_int* iblock, const lapack_int* isplit, lapack_complex_double* z, lapack_int* ldz,
-                   double* work, lapack_int* iwork, lapack_int* ifailv, lapack_int* info);
-void LAPACK_sdisna(char* job, lapack_int* m, lapack_int* n, const float* d, float* sep, lapack_int* info);
-void LAPACK_ddisna(char* job, lapack_int* m, lapack_int* n, const double* d, double* sep, lapack_int* info);
-void LAPACK_ssygst(lapack_int* itype, char* uplo, lapack_int* n, float* a, lapack_int* lda, const float* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_dsygst(lapack_int* itype, char* uplo, lapack_int* n, double* a, lapack_int* lda, const double* b,
-                   lapack_int* ldb, lapack_int* info);
-void LAPACK_chegst(lapack_int* itype, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_zhegst(lapack_int* itype, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* b, lapack_int* ldb, lapack_int* info);
-void LAPACK_sspgst(lapack_int* itype, char* uplo, lapack_int* n, float* ap, const float* bp, lapack_int* info);
-void LAPACK_dspgst(lapack_int* itype, char* uplo, lapack_int* n, double* ap, const double* bp, lapack_int* info);
-void LAPACK_chpgst(lapack_int* itype, char* uplo, lapack_int* n, lapack_complex_float* ap,
-                   const lapack_complex_float* bp, lapack_int* info);
-void LAPACK_zhpgst(lapack_int* itype, char* uplo, lapack_int* n, lapack_complex_double* ap,
-                   const lapack_complex_double* bp, lapack_int* info);
-void LAPACK_ssbgst(char* vect, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
-                   const float* bb, lapack_int* ldbb, float* x, lapack_int* ldx, float* work, lapack_int* info);
-void LAPACK_dsbgst(char* vect, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, double* ab, lapack_int* ldab,
-                   const double* bb, lapack_int* ldbb, double* x, lapack_int* ldx, double* work, lapack_int* info);
-void LAPACK_chbgst(char* vect, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
-                   lapack_int* ldab, const lapack_complex_float* bb, lapack_int* ldbb, lapack_complex_float* x,
-                   lapack_int* ldx, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zhbgst(char* vect, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
-                   lapack_int* ldab, const lapack_complex_double* bb, lapack_int* ldbb, lapack_complex_double* x,
-                   lapack_int* ldx, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_spbstf(char* uplo, lapack_int* n, lapack_int* kb, float* bb, lapack_int* ldbb, lapack_int* info);
-void LAPACK_dpbstf(char* uplo, lapack_int* n, lapack_int* kb, double* bb, lapack_int* ldbb, lapack_int* info);
-void LAPACK_cpbstf(char* uplo, lapack_int* n, lapack_int* kb, lapack_complex_float* bb, lapack_int* ldbb,
-                   lapack_int* info);
-void LAPACK_zpbstf(char* uplo, lapack_int* n, lapack_int* kb, lapack_complex_double* bb, lapack_int* ldbb,
-                   lapack_int* info);
-void LAPACK_sgehrd(lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a, lapack_int* lda, float* tau, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_dgehrd(lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a, lapack_int* lda, double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cgehrd(lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgehrd(lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sorghr(lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a, lapack_int* lda, const float* tau,
-                   float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorghr(lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a, lapack_int* lda, const double* tau,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sormhr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* ilo, lapack_int* ihi,
-                   const float* a, lapack_int* lda, const float* tau, float* c, lapack_int* ldc, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_dormhr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* ilo, lapack_int* ihi,
-                   const double* a, lapack_int* lda, const double* tau, double* c, lapack_int* ldc, double* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_cunghr(lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_float* a, lapack_int* lda,
-                   const lapack_complex_float* tau, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zunghr(lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_double* a, lapack_int* lda,
-                   const lapack_complex_double* tau, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cunmhr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* ilo, lapack_int* ihi,
-                   const lapack_complex_float* a, lapack_int* lda, const lapack_complex_float* tau,
-                   lapack_complex_float* c, lapack_int* ldc, lapack_complex_float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_zunmhr(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* ilo, lapack_int* ihi,
-                   const lapack_complex_double* a, lapack_int* lda, const lapack_complex_double* tau,
-                   lapack_complex_double* c, lapack_int* ldc, lapack_complex_double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_sgebal(char* job, lapack_int* n, float* a, lapack_int* lda, lapack_int* ilo, lapack_int* ihi, float* scale,
-                   lapack_int* info);
-void LAPACK_dgebal(char* job, lapack_int* n, double* a, lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
-                   double* scale, lapack_int* info);
-void LAPACK_cgebal(char* job, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* ilo, lapack_int* ihi,
-                   float* scale, lapack_int* info);
-void LAPACK_zgebal(char* job, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* ilo,
-                   lapack_int* ihi, double* scale, lapack_int* info);
-void LAPACK_sgebak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const float* scale,
-                   lapack_int* m, float* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_dgebak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const double* scale,
-                   lapack_int* m, double* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_cgebak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const float* scale,
-                   lapack_int* m, lapack_complex_float* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_zgebak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const double* scale,
-                   lapack_int* m, lapack_complex_double* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_shseqr(char* job, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* h, lapack_int* ldh,
-                   float* wr, float* wi, float* z, lapack_int* ldz, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dhseqr(char* job, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* h, lapack_int* ldh,
-                   double* wr, double* wi, double* z, lapack_int* ldz, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_chseqr(char* job, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_float* h,
-                   lapack_int* ldh, lapack_complex_float* w, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zhseqr(char* job, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_double* h,
-                   lapack_int* ldh, lapack_complex_double* w, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_shsein(char* job, char* eigsrc, char* initv, lapack_logical* select, lapack_int* n, const float* h,
-                   lapack_int* ldh, float* wr, const float* wi, float* vl, lapack_int* ldvl, float* vr,
-                   lapack_int* ldvr, lapack_int* mm, lapack_int* m, float* work, lapack_int* ifaill, lapack_int* ifailr,
-                   lapack_int* info);
-void LAPACK_dhsein(char* job, char* eigsrc, char* initv, lapack_logical* select, lapack_int* n, const double* h,
-                   lapack_int* ldh, double* wr, const double* wi, double* vl, lapack_int* ldvl, double* vr,
-                   lapack_int* ldvr, lapack_int* mm, lapack_int* m, double* work, lapack_int* ifaill,
-                   lapack_int* ifailr, lapack_int* info);
-void LAPACK_chsein(char* job, char* eigsrc, char* initv, const lapack_logical* select, lapack_int* n,
-                   const lapack_complex_float* h, lapack_int* ldh, lapack_complex_float* w, lapack_complex_float* vl,
-                   lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm, lapack_int* m,
-                   lapack_complex_float* work, float* rwork, lapack_int* ifaill, lapack_int* ifailr, lapack_int* info);
-void LAPACK_zhsein(char* job, char* eigsrc, char* initv, const lapack_logical* select, lapack_int* n,
-                   const lapack_complex_double* h, lapack_int* ldh, lapack_complex_double* w, lapack_complex_double* vl,
-                   lapack_int* ldvl, lapack_complex_double* vr, lapack_int* ldvr, lapack_int* mm, lapack_int* m,
-                   lapack_complex_double* work, double* rwork, lapack_int* ifaill, lapack_int* ifailr,
-                   lapack_int* info);
-void LAPACK_strevc(char* side, char* howmny, lapack_logical* select, lapack_int* n, const float* t, lapack_int* ldt,
-                   float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr, lapack_int* mm, lapack_int* m, float* work,
-                   lapack_int* info);
-void LAPACK_dtrevc(char* side, char* howmny, lapack_logical* select, lapack_int* n, const double* t, lapack_int* ldt,
-                   double* vl, lapack_int* ldvl, double* vr, lapack_int* ldvr, lapack_int* mm, lapack_int* m,
-                   double* work, lapack_int* info);
-void LAPACK_ctrevc(char* side, char* howmny, const lapack_logical* select, lapack_int* n, lapack_complex_float* t,
-                   lapack_int* ldt, lapack_complex_float* vl, lapack_int* ldvl, lapack_complex_float* vr,
-                   lapack_int* ldvr, lapack_int* mm, lapack_int* m, lapack_complex_float* work, float* rwork,
-                   lapack_int* info);
-void LAPACK_ztrevc(char* side, char* howmny, const lapack_logical* select, lapack_int* n, lapack_complex_double* t,
-                   lapack_int* ldt, lapack_complex_double* vl, lapack_int* ldvl, lapack_complex_double* vr,
-                   lapack_int* ldvr, lapack_int* mm, lapack_int* m, lapack_complex_double* work, double* rwork,
-                   lapack_int* info);
-void LAPACK_strsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const float* t,
-                   lapack_int* ldt, const float* vl, lapack_int* ldvl, const float* vr, lapack_int* ldvr, float* s,
-                   float* sep, lapack_int* mm, lapack_int* m, float* work, lapack_int* ldwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dtrsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const double* t,
-                   lapack_int* ldt, const double* vl, lapack_int* ldvl, const double* vr, lapack_int* ldvr, double* s,
-                   double* sep, lapack_int* mm, lapack_int* m, double* work, lapack_int* ldwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_ctrsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const lapack_complex_float* t,
-                   lapack_int* ldt, const lapack_complex_float* vl, lapack_int* ldvl, const lapack_complex_float* vr,
-                   lapack_int* ldvr, float* s, float* sep, lapack_int* mm, lapack_int* m, lapack_complex_float* work,
-                   lapack_int* ldwork, float* rwork, lapack_int* info);
-void LAPACK_ztrsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const lapack_complex_double* t,
-                   lapack_int* ldt, const lapack_complex_double* vl, lapack_int* ldvl, const lapack_complex_double* vr,
-                   lapack_int* ldvr, double* s, double* sep, lapack_int* mm, lapack_int* m, lapack_complex_double* work,
-                   lapack_int* ldwork, double* rwork, lapack_int* info);
-void LAPACK_strexc(char* compq, lapack_int* n, float* t, lapack_int* ldt, float* q, lapack_int* ldq, lapack_int* ifst,
-                   lapack_int* ilst, float* work, lapack_int* info);
-void LAPACK_dtrexc(char* compq, lapack_int* n, double* t, lapack_int* ldt, double* q, lapack_int* ldq, lapack_int* ifst,
-                   lapack_int* ilst, double* work, lapack_int* info);
-void LAPACK_ctrexc(char* compq, lapack_int* n, lapack_complex_float* t, lapack_int* ldt, lapack_complex_float* q,
-                   lapack_int* ldq, lapack_int* ifst, lapack_int* ilst, lapack_int* info);
-void LAPACK_ztrexc(char* compq, lapack_int* n, lapack_complex_double* t, lapack_int* ldt, lapack_complex_double* q,
-                   lapack_int* ldq, lapack_int* ifst, lapack_int* ilst, lapack_int* info);
-void LAPACK_strsen(char* job, char* compq, const lapack_logical* select, lapack_int* n, float* t, lapack_int* ldt,
-                   float* q, lapack_int* ldq, float* wr, float* wi, lapack_int* m, float* s, float* sep, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_dtrsen(char* job, char* compq, const lapack_logical* select, lapack_int* n, double* t, lapack_int* ldt,
-                   double* q, lapack_int* ldq, double* wr, double* wi, lapack_int* m, double* s, double* sep,
-                   double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_ctrsen(char* job, char* compq, const lapack_logical* select, lapack_int* n, lapack_complex_float* t,
-                   lapack_int* ldt, lapack_complex_float* q, lapack_int* ldq, lapack_complex_float* w, lapack_int* m,
-                   float* s, float* sep, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ztrsen(char* job, char* compq, const lapack_logical* select, lapack_int* n, lapack_complex_double* t,
-                   lapack_int* ldt, lapack_complex_double* q, lapack_int* ldq, lapack_complex_double* w, lapack_int* m,
-                   double* s, double* sep, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_strsyl(char* trana, char* tranb, lapack_int* isgn, lapack_int* m, lapack_int* n, const float* a,
-                   lapack_int* lda, const float* b, lapack_int* ldb, float* c, lapack_int* ldc, float* scale,
-                   lapack_int* info);
-void LAPACK_dtrsyl(char* trana, char* tranb, lapack_int* isgn, lapack_int* m, lapack_int* n, const double* a,
-                   lapack_int* lda, const double* b, lapack_int* ldb, double* c, lapack_int* ldc, double* scale,
-                   lapack_int* info);
-void LAPACK_ctrsyl(char* trana, char* tranb, lapack_int* isgn, lapack_int* m, lapack_int* n,
-                   const lapack_complex_float* a, lapack_int* lda, const lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* c, lapack_int* ldc, float* scale, lapack_int* info);
-void LAPACK_ztrsyl(char* trana, char* tranb, lapack_int* isgn, lapack_int* m, lapack_int* n,
-                   const lapack_complex_double* a, lapack_int* lda, const lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* c, lapack_int* ldc, double* scale, lapack_int* info);
-void LAPACK_sgghrd(char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* a, lapack_int* lda,
-                   float* b, lapack_int* ldb, float* q, lapack_int* ldq, float* z, lapack_int* ldz, lapack_int* info);
-void LAPACK_dgghrd(char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* a,
-                   lapack_int* lda, double* b, lapack_int* ldb, double* q, lapack_int* ldq, double* z, lapack_int* ldz,
-                   lapack_int* info);
-void LAPACK_cgghrd(char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* q, lapack_int* ldq,
-                   lapack_complex_float* z, lapack_int* ldz, lapack_int* info);
-void LAPACK_zgghrd(char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* q,
-                   lapack_int* ldq, lapack_complex_double* z, lapack_int* ldz, lapack_int* info);
-void LAPACK_sggbal(char* job, lapack_int* n, float* a, lapack_int* lda, float* b, lapack_int* ldb, lapack_int* ilo,
-                   lapack_int* ihi, float* lscale, float* rscale, float* work, lapack_int* info);
-void LAPACK_dggbal(char* job, lapack_int* n, double* a, lapack_int* lda, double* b, lapack_int* ldb, lapack_int* ilo,
-                   lapack_int* ihi, double* lscale, double* rscale, double* work, lapack_int* info);
-void LAPACK_cggbal(char* job, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b,
-                   lapack_int* ldb, lapack_int* ilo, lapack_int* ihi, float* lscale, float* rscale, float* work,
-                   lapack_int* info);
-void LAPACK_zggbal(char* job, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b,
-                   lapack_int* ldb, lapack_int* ilo, lapack_int* ihi, double* lscale, double* rscale, double* work,
-                   lapack_int* info);
-void LAPACK_sggbak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const float* lscale,
-                   const float* rscale, lapack_int* m, float* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_dggbak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const double* lscale,
-                   const double* rscale, lapack_int* m, double* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_cggbak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const float* lscale,
-                   const float* rscale, lapack_int* m, lapack_complex_float* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_zggbak(char* job, char* side, lapack_int* n, lapack_int* ilo, lapack_int* ihi, const double* lscale,
-                   const double* rscale, lapack_int* m, lapack_complex_double* v, lapack_int* ldv, lapack_int* info);
-void LAPACK_shgeqz(char* job, char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, float* h,
-                   lapack_int* ldh, float* t, lapack_int* ldt, float* alphar, float* alphai, float* beta, float* q,
-                   lapack_int* ldq, float* z, lapack_int* ldz, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dhgeqz(char* job, char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi, double* h,
-                   lapack_int* ldh, double* t, lapack_int* ldt, double* alphar, double* alphai, double* beta, double* q,
-                   lapack_int* ldq, double* z, lapack_int* ldz, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_chgeqz(char* job, char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi,
-                   lapack_complex_float* h, lapack_int* ldh, lapack_complex_float* t, lapack_int* ldt,
-                   lapack_complex_float* alpha, lapack_complex_float* beta, lapack_complex_float* q, lapack_int* ldq,
-                   lapack_complex_float* z, lapack_int* ldz, lapack_complex_float* work, lapack_int* lwork,
-                   float* rwork, lapack_int* info);
-void LAPACK_zhgeqz(char* job, char* compq, char* compz, lapack_int* n, lapack_int* ilo, lapack_int* ihi,
-                   lapack_complex_double* h, lapack_int* ldh, lapack_complex_double* t, lapack_int* ldt,
-                   lapack_complex_double* alpha, lapack_complex_double* beta, lapack_complex_double* q, lapack_int* ldq,
-                   lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* info);
-void LAPACK_stgevc(char* side, char* howmny, const lapack_logical* select, lapack_int* n, const float* s,
-                   lapack_int* lds, const float* p, lapack_int* ldp, float* vl, lapack_int* ldvl, float* vr,
-                   lapack_int* ldvr, lapack_int* mm, lapack_int* m, float* work, lapack_int* info);
-void LAPACK_dtgevc(char* side, char* howmny, const lapack_logical* select, lapack_int* n, const double* s,
-                   lapack_int* lds, const double* p, lapack_int* ldp, double* vl, lapack_int* ldvl, double* vr,
-                   lapack_int* ldvr, lapack_int* mm, lapack_int* m, double* work, lapack_int* info);
-void LAPACK_ctgevc(char* side, char* howmny, const lapack_logical* select, lapack_int* n, const lapack_complex_float* s,
-                   lapack_int* lds, const lapack_complex_float* p, lapack_int* ldp, lapack_complex_float* vl,
-                   lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr, lapack_int* mm, lapack_int* m,
-                   lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_ztgevc(char* side, char* howmny, const lapack_logical* select, lapack_int* n,
-                   const lapack_complex_double* s, lapack_int* lds, const lapack_complex_double* p, lapack_int* ldp,
-                   lapack_complex_double* vl, lapack_int* ldvl, lapack_complex_double* vr, lapack_int* ldvr,
-                   lapack_int* mm, lapack_int* m, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_stgexc(lapack_logical* wantq, lapack_logical* wantz, lapack_int* n, float* a, lapack_int* lda, float* b,
-                   lapack_int* ldb, float* q, lapack_int* ldq, float* z, lapack_int* ldz, lapack_int* ifst,
-                   lapack_int* ilst, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dtgexc(lapack_logical* wantq, lapack_logical* wantz, lapack_int* n, double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, double* q, lapack_int* ldq, double* z, lapack_int* ldz, lapack_int* ifst,
-                   lapack_int* ilst, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ctgexc(lapack_logical* wantq, lapack_logical* wantz, lapack_int* n, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* q, lapack_int* ldq,
-                   lapack_complex_float* z, lapack_int* ldz, lapack_int* ifst, lapack_int* ilst, lapack_int* info);
-void LAPACK_ztgexc(lapack_logical* wantq, lapack_logical* wantz, lapack_int* n, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* q,
-                   lapack_int* ldq, lapack_complex_double* z, lapack_int* ldz, lapack_int* ifst, lapack_int* ilst,
-                   lapack_int* info);
-void LAPACK_stgsen(lapack_int* ijob, lapack_logical* wantq, lapack_logical* wantz, const lapack_logical* select,
-                   lapack_int* n, float* a, lapack_int* lda, float* b, lapack_int* ldb, float* alphar, float* alphai,
-                   float* beta, float* q, lapack_int* ldq, float* z, lapack_int* ldz, lapack_int* m, float* pl,
-                   float* pr, float* dif, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dtgsen(lapack_int* ijob, lapack_logical* wantq, lapack_logical* wantz, const lapack_logical* select,
-                   lapack_int* n, double* a, lapack_int* lda, double* b, lapack_int* ldb, double* alphar,
-                   double* alphai, double* beta, double* q, lapack_int* ldq, double* z, lapack_int* ldz, lapack_int* m,
-                   double* pl, double* pr, double* dif, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_ctgsen(lapack_int* ijob, lapack_logical* wantq, lapack_logical* wantz, const lapack_logical* select,
-                   lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
-                   lapack_complex_float* alpha, lapack_complex_float* beta, lapack_complex_float* q, lapack_int* ldq,
-                   lapack_complex_float* z, lapack_int* ldz, lapack_int* m, float* pl, float* pr, float* dif,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_ztgsen(lapack_int* ijob, lapack_logical* wantq, lapack_logical* wantz, const lapack_logical* select,
-                   lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
-                   lapack_complex_double* alpha, lapack_complex_double* beta, lapack_complex_double* q, lapack_int* ldq,
-                   lapack_complex_double* z, lapack_int* ldz, lapack_int* m, double* pl, double* pr, double* dif,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_stgsyl(char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n, const float* a, lapack_int* lda,
-                   const float* b, lapack_int* ldb, float* c, lapack_int* ldc, const float* d, lapack_int* ldd,
-                   const float* e, lapack_int* lde, float* f, lapack_int* ldf, float* scale, float* dif, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtgsyl(char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n, const double* a, lapack_int* lda,
-                   const double* b, lapack_int* ldb, double* c, lapack_int* ldc, const double* d, lapack_int* ldd,
-                   const double* e, lapack_int* lde, double* f, lapack_int* ldf, double* scale, double* dif,
-                   double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctgsyl(char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* c,
-                   lapack_int* ldc, const lapack_complex_float* d, lapack_int* ldd, const lapack_complex_float* e,
-                   lapack_int* lde, lapack_complex_float* f, lapack_int* ldf, float* scale, float* dif,
-                   lapack_complex_float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_ztgsyl(char* trans, lapack_int* ijob, lapack_int* m, lapack_int* n, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* c,
-                   lapack_int* ldc, const lapack_complex_double* d, lapack_int* ldd, const lapack_complex_double* e,
-                   lapack_int* lde, lapack_complex_double* f, lapack_int* ldf, double* scale, double* dif,
-                   lapack_complex_double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_stgsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const float* a,
-                   lapack_int* lda, const float* b, lapack_int* ldb, const float* vl, lapack_int* ldvl, const float* vr,
-                   lapack_int* ldvr, float* s, float* dif, lapack_int* mm, lapack_int* m, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dtgsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const double* a,
-                   lapack_int* lda, const double* b, lapack_int* ldb, const double* vl, lapack_int* ldvl,
-                   const double* vr, lapack_int* ldvr, double* s, double* dif, lapack_int* mm, lapack_int* m,
-                   double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_ctgsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const lapack_complex_float* a,
-                   lapack_int* lda, const lapack_complex_float* b, lapack_int* ldb, const lapack_complex_float* vl,
-                   lapack_int* ldvl, const lapack_complex_float* vr, lapack_int* ldvr, float* s, float* dif,
-                   lapack_int* mm, lapack_int* m, lapack_complex_float* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_ztgsna(char* job, char* howmny, const lapack_logical* select, lapack_int* n, const lapack_complex_double* a,
-                   lapack_int* lda, const lapack_complex_double* b, lapack_int* ldb, const lapack_complex_double* vl,
-                   lapack_int* ldvl, const lapack_complex_double* vr, lapack_int* ldvr, double* s, double* dif,
-                   lapack_int* mm, lapack_int* m, lapack_complex_double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_sggsvp(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n, float* a,
-                   lapack_int* lda, float* b, lapack_int* ldb, float* tola, float* tolb, lapack_int* k, lapack_int* l,
-                   float* u, lapack_int* ldu, float* v, lapack_int* ldv, float* q, lapack_int* ldq, lapack_int* iwork,
-                   float* tau, float* work, lapack_int* info);
-void LAPACK_dggsvp(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n, double* a,
-                   lapack_int* lda, double* b, lapack_int* ldb, double* tola, double* tolb, lapack_int* k,
-                   lapack_int* l, double* u, lapack_int* ldu, double* v, lapack_int* ldv, double* q, lapack_int* ldq,
-                   lapack_int* iwork, double* tau, double* work, lapack_int* info);
-void LAPACK_cggsvp(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n,
-                   lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, float* tola,
-                   float* tolb, lapack_int* k, lapack_int* l, lapack_complex_float* u, lapack_int* ldu,
-                   lapack_complex_float* v, lapack_int* ldv, lapack_complex_float* q, lapack_int* ldq,
-                   lapack_int* iwork, float* rwork, lapack_complex_float* tau, lapack_complex_float* work,
-                   lapack_int* info);
-void LAPACK_zggsvp(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n,
-                   lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, double* tola,
-                   double* tolb, lapack_int* k, lapack_int* l, lapack_complex_double* u, lapack_int* ldu,
-                   lapack_complex_double* v, lapack_int* ldv, lapack_complex_double* q, lapack_int* ldq,
-                   lapack_int* iwork, double* rwork, lapack_complex_double* tau, lapack_complex_double* work,
-                   lapack_int* info);
-void LAPACK_stgsja(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n, lapack_int* k,
-                   lapack_int* l, float* a, lapack_int* lda, float* b, lapack_int* ldb, float* tola, float* tolb,
-                   float* alpha, float* beta, float* u, lapack_int* ldu, float* v, lapack_int* ldv, float* q,
-                   lapack_int* ldq, float* work, lapack_int* ncycle, lapack_int* info);
-void LAPACK_dtgsja(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n, lapack_int* k,
-                   lapack_int* l, double* a, lapack_int* lda, double* b, lapack_int* ldb, double* tola, double* tolb,
-                   double* alpha, double* beta, double* u, lapack_int* ldu, double* v, lapack_int* ldv, double* q,
-                   lapack_int* ldq, double* work, lapack_int* ncycle, lapack_int* info);
-void LAPACK_ctgsja(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n, lapack_int* k,
-                   lapack_int* l, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
-                   float* tola, float* tolb, float* alpha, float* beta, lapack_complex_float* u, lapack_int* ldu,
-                   lapack_complex_float* v, lapack_int* ldv, lapack_complex_float* q, lapack_int* ldq,
-                   lapack_complex_float* work, lapack_int* ncycle, lapack_int* info);
-void LAPACK_ztgsja(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* p, lapack_int* n, lapack_int* k,
-                   lapack_int* l, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
-                   double* tola, double* tolb, double* alpha, double* beta, lapack_complex_double* u, lapack_int* ldu,
-                   lapack_complex_double* v, lapack_int* ldv, lapack_complex_double* q, lapack_int* ldq,
-                   lapack_complex_double* work, lapack_int* ncycle, lapack_int* info);
-void LAPACK_sgels(char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* b,
-                  lapack_int* ldb, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgels(char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* b,
-                  lapack_int* ldb, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cgels(char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                  lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* work, lapack_int* lwork,
-                  lapack_int* info);
-void LAPACK_zgels(char* trans, lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a,
-                  lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_sgelsy(lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                   lapack_int* jpvt, float* rcond, lapack_int* rank, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgelsy(lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, lapack_int* jpvt, double* rcond, lapack_int* rank, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cgelsy(lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_int* jpvt, float* rcond, lapack_int* rank,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* info);
-void LAPACK_zgelsy(lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_int* jpvt, double* rcond, lapack_int* rank,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* info);
-void LAPACK_sgelss(lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                   float* s, float* rcond, lapack_int* rank, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgelss(lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, double* s, double* rcond, lapack_int* rank, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cgelss(lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, float* s, float* rcond, lapack_int* rank,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* info);
-void LAPACK_zgelss(lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, double* s, double* rcond, lapack_int* rank,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* info);
-void LAPACK_sgelsd(lapack_int* m, lapack_int* n, lapack_int* nrhs, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                   float* s, float* rcond, lapack_int* rank, float* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dgelsd(lapack_int* m, lapack_int* n, lapack_int* nrhs, double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, double* s, double* rcond, lapack_int* rank, double* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cgelsd(lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, float* s, float* rcond, lapack_int* rank,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_zgelsd(lapack_int* m, lapack_int* n, lapack_int* nrhs, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, double* s, double* rcond, lapack_int* rank,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_sgglse(lapack_int* m, lapack_int* n, lapack_int* p, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                   float* c, float* d, float* x, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgglse(lapack_int* m, lapack_int* n, lapack_int* p, double* a, lapack_int* lda, double* b, lapack_int* ldb,
-                   double* c, double* d, double* x, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cgglse(lapack_int* m, lapack_int* n, lapack_int* p, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* c, lapack_complex_float* d,
-                   lapack_complex_float* x, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgglse(lapack_int* m, lapack_int* n, lapack_int* p, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* c, lapack_complex_double* d,
-                   lapack_complex_double* x, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_sggglm(lapack_int* n, lapack_int* m, lapack_int* p, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                   float* d, float* x, float* y, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dggglm(lapack_int* n, lapack_int* m, lapack_int* p, double* a, lapack_int* lda, double* b, lapack_int* ldb,
-                   double* d, double* x, double* y, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cggglm(lapack_int* n, lapack_int* m, lapack_int* p, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* d, lapack_complex_float* x,
-                   lapack_complex_float* y, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zggglm(lapack_int* n, lapack_int* m, lapack_int* p, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* d, lapack_complex_double* x,
-                   lapack_complex_double* y, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ssyev(char* jobz, char* uplo, lapack_int* n, float* a, lapack_int* lda, float* w, float* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_dsyev(char* jobz, char* uplo, lapack_int* n, double* a, lapack_int* lda, double* w, double* work,
-                  lapack_int* lwork, lapack_int* info);
-void LAPACK_cheev(char* jobz, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, float* w,
-                  lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* info);
-void LAPACK_zheev(char* jobz, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, double* w,
-                  lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* info);
-void LAPACK_ssyevd(char* jobz, char* uplo, lapack_int* n, float* a, lapack_int* lda, float* w, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_dsyevd(char* jobz, char* uplo, lapack_int* n, double* a, lapack_int* lda, double* w, double* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_cheevd(char* jobz, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, float* w,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* lrwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_zheevd(char* jobz, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, double* w,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* lrwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_ssyevx(char* jobz, char* range, char* uplo, lapack_int* n, float* a, lapack_int* lda, float* vl, float* vu,
-                   lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz,
-                   float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_dsyevx(char* jobz, char* range, char* uplo, lapack_int* n, double* a, lapack_int* lda, double* vl,
-                   double* vu, lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z,
-                   lapack_int* ldz, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* ifail,
-                   lapack_int* info);
-void LAPACK_cheevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                   float* vl, float* vu, lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w,
-                   lapack_complex_float* z, lapack_int* ldz, lapack_complex_float* work, lapack_int* lwork,
-                   float* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_zheevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   double* vl, double* vu, lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w,
-                   lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_ssyevr(char* jobz, char* range, char* uplo, lapack_int* n, float* a, lapack_int* lda, float* vl, float* vu,
-                   lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz,
-                   lapack_int* isuppz, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dsyevr(char* jobz, char* range, char* uplo, lapack_int* n, double* a, lapack_int* lda, double* vl,
-                   double* vu, lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z,
-                   lapack_int* ldz, lapack_int* isuppz, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_cheevr(char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                   float* vl, float* vu, lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w,
-                   lapack_complex_float* z, lapack_int* ldz, lapack_int* isuppz, lapack_complex_float* work,
-                   lapack_int* lwork, float* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_zheevr(char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   double* vl, double* vu, lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w,
-                   lapack_complex_double* z, lapack_int* ldz, lapack_int* isuppz, lapack_complex_double* work,
-                   lapack_int* lwork, double* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_sspev(char* jobz, char* uplo, lapack_int* n, float* ap, float* w, float* z, lapack_int* ldz, float* work,
-                  lapack_int* info);
-void LAPACK_dspev(char* jobz, char* uplo, lapack_int* n, double* ap, double* w, double* z, lapack_int* ldz,
-                  double* work, lapack_int* info);
-void LAPACK_chpev(char* jobz, char* uplo, lapack_int* n, lapack_complex_float* ap, float* w, lapack_complex_float* z,
-                  lapack_int* ldz, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zhpev(char* jobz, char* uplo, lapack_int* n, lapack_complex_double* ap, double* w, lapack_complex_double* z,
-                  lapack_int* ldz, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sspevd(char* jobz, char* uplo, lapack_int* n, float* ap, float* w, float* z, lapack_int* ldz, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_dspevd(char* jobz, char* uplo, lapack_int* n, double* ap, double* w, double* z, lapack_int* ldz,
-                   double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_chpevd(char* jobz, char* uplo, lapack_int* n, lapack_complex_float* ap, float* w, lapack_complex_float* z,
-                   lapack_int* ldz, lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* lrwork,
-                   lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_zhpevd(char* jobz, char* uplo, lapack_int* n, lapack_complex_double* ap, double* w,
-                   lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_sspevx(char* jobz, char* range, char* uplo, lapack_int* n, float* ap, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz, float* work,
-                   lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_dspevx(char* jobz, char* range, char* uplo, lapack_int* n, double* ap, double* vl, double* vu,
-                   lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z, lapack_int* ldz,
-                   double* work, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_chpevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_float* ap, float* vl, float* vu,
-                   lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w, lapack_complex_float* z,
-                   lapack_int* ldz, lapack_complex_float* work, float* rwork, lapack_int* iwork, lapack_int* ifail,
-                   lapack_int* info);
-void LAPACK_zhpevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_double* ap, double* vl,
-                   double* vu, lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w,
-                   lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work, double* rwork,
-                   lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_ssbev(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, float* ab, lapack_int* ldab, float* w,
-                  float* z, lapack_int* ldz, float* work, lapack_int* info);
-void LAPACK_dsbev(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, double* ab, lapack_int* ldab, double* w,
-                  double* z, lapack_int* ldz, double* work, lapack_int* info);
-void LAPACK_chbev(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
-                  float* w, lapack_complex_float* z, lapack_int* ldz, lapack_complex_float* work, float* rwork,
-                  lapack_int* info);
-void LAPACK_zhbev(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
-                  double* w, lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work, double* rwork,
-                  lapack_int* info);
-void LAPACK_ssbevd(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, float* ab, lapack_int* ldab, float* w,
-                   float* z, lapack_int* ldz, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dsbevd(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, double* ab, lapack_int* ldab, double* w,
-                   double* z, lapack_int* ldz, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_chbevd(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_float* ab, lapack_int* ldab,
-                   float* w, lapack_complex_float* z, lapack_int* ldz, lapack_complex_float* work, lapack_int* lwork,
-                   float* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_zhbevd(char* jobz, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_double* ab, lapack_int* ldab,
-                   double* w, lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_ssbevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* kd, float* ab, lapack_int* ldab,
-                   float* q, lapack_int* ldq, float* vl, float* vu, lapack_int* il, lapack_int* iu, float* abstol,
-                   lapack_int* m, float* w, float* z, lapack_int* ldz, float* work, lapack_int* iwork,
-                   lapack_int* ifail, lapack_int* info);
-void LAPACK_dsbevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* kd, double* ab, lapack_int* ldab,
-                   double* q, lapack_int* ldq, double* vl, double* vu, lapack_int* il, lapack_int* iu, double* abstol,
-                   lapack_int* m, double* w, double* z, lapack_int* ldz, double* work, lapack_int* iwork,
-                   lapack_int* ifail, lapack_int* info);
-void LAPACK_chbevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_float* ab,
-                   lapack_int* ldab, lapack_complex_float* q, lapack_int* ldq, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_complex_float* work, float* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_zhbevx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* kd, lapack_complex_double* ab,
-                   lapack_int* ldab, lapack_complex_double* q, lapack_int* ldq, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, double* abstol, lapack_int* m, double* w, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_complex_double* work, double* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_sstev(char* jobz, lapack_int* n, float* d, float* e, float* z, lapack_int* ldz, float* work,
-                  lapack_int* info);
-void LAPACK_dstev(char* jobz, lapack_int* n, double* d, double* e, double* z, lapack_int* ldz, double* work,
-                  lapack_int* info);
-void LAPACK_sstevd(char* jobz, lapack_int* n, float* d, float* e, float* z, lapack_int* ldz, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_dstevd(char* jobz, lapack_int* n, double* d, double* e, double* z, lapack_int* ldz, double* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_sstevx(char* jobz, char* range, lapack_int* n, float* d, float* e, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz, float* work,
-                   lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_dstevx(char* jobz, char* range, lapack_int* n, double* d, double* e, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z, lapack_int* ldz, double* work,
-                   lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_sstevr(char* jobz, char* range, lapack_int* n, float* d, float* e, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz,
-                   lapack_int* isuppz, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dstevr(char* jobz, char* range, lapack_int* n, double* d, double* e, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z, lapack_int* ldz,
-                   lapack_int* isuppz, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_sgees(char* jobvs, char* sort, LAPACK_S_SELECT2 select, lapack_int* n, float* a, lapack_int* lda,
-                  lapack_int* sdim, float* wr, float* wi, float* vs, lapack_int* ldvs, float* work, lapack_int* lwork,
-                  lapack_logical* bwork, lapack_int* info);
-void LAPACK_dgees(char* jobvs, char* sort, LAPACK_D_SELECT2 select, lapack_int* n, double* a, lapack_int* lda,
-                  lapack_int* sdim, double* wr, double* wi, double* vs, lapack_int* ldvs, double* work,
-                  lapack_int* lwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_cgees(char* jobvs, char* sort, LAPACK_C_SELECT1 select, lapack_int* n, lapack_complex_float* a,
-                  lapack_int* lda, lapack_int* sdim, lapack_complex_float* w, lapack_complex_float* vs,
-                  lapack_int* ldvs, lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_logical* bwork,
-                  lapack_int* info);
-void LAPACK_zgees(char* jobvs, char* sort, LAPACK_Z_SELECT1 select, lapack_int* n, lapack_complex_double* a,
-                  lapack_int* lda, lapack_int* sdim, lapack_complex_double* w, lapack_complex_double* vs,
-                  lapack_int* ldvs, lapack_complex_double* work, lapack_int* lwork, double* rwork,
-                  lapack_logical* bwork, lapack_int* info);
-void LAPACK_sgeesx(char* jobvs, char* sort, LAPACK_S_SELECT2 select, char* sense, lapack_int* n, float* a,
-                   lapack_int* lda, lapack_int* sdim, float* wr, float* wi, float* vs, lapack_int* ldvs, float* rconde,
-                   float* rcondv, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_logical* bwork, lapack_int* info);
-void LAPACK_dgeesx(char* jobvs, char* sort, LAPACK_D_SELECT2 select, char* sense, lapack_int* n, double* a,
-                   lapack_int* lda, lapack_int* sdim, double* wr, double* wi, double* vs, lapack_int* ldvs,
-                   double* rconde, double* rcondv, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_cgeesx(char* jobvs, char* sort, LAPACK_C_SELECT1 select, char* sense, lapack_int* n,
-                   lapack_complex_float* a, lapack_int* lda, lapack_int* sdim, lapack_complex_float* w,
-                   lapack_complex_float* vs, lapack_int* ldvs, float* rconde, float* rcondv, lapack_complex_float* work,
-                   lapack_int* lwork, float* rwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_zgeesx(char* jobvs, char* sort, LAPACK_Z_SELECT1 select, char* sense, lapack_int* n,
-                   lapack_complex_double* a, lapack_int* lda, lapack_int* sdim, lapack_complex_double* w,
-                   lapack_complex_double* vs, lapack_int* ldvs, double* rconde, double* rcondv,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_logical* bwork,
-                   lapack_int* info);
-void LAPACK_sgeev(char* jobvl, char* jobvr, lapack_int* n, float* a, lapack_int* lda, float* wr, float* wi, float* vl,
-                  lapack_int* ldvl, float* vr, lapack_int* ldvr, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgeev(char* jobvl, char* jobvr, lapack_int* n, double* a, lapack_int* lda, double* wr, double* wi,
-                  double* vl, lapack_int* ldvl, double* vr, lapack_int* ldvr, double* work, lapack_int* lwork,
-                  lapack_int* info);
-void LAPACK_cgeev(char* jobvl, char* jobvr, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                  lapack_complex_float* w, lapack_complex_float* vl, lapack_int* ldvl, lapack_complex_float* vr,
-                  lapack_int* ldvr, lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* info);
-void LAPACK_zgeev(char* jobvl, char* jobvr, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                  lapack_complex_double* w, lapack_complex_double* vl, lapack_int* ldvl, lapack_complex_double* vr,
-                  lapack_int* ldvr, lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* info);
-void LAPACK_sgeevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, float* a, lapack_int* lda,
-                   float* wr, float* wi, float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr, lapack_int* ilo,
-                   lapack_int* ihi, float* scale, float* abnrm, float* rconde, float* rcondv, float* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dgeevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, double* a, lapack_int* lda,
-                   double* wr, double* wi, double* vl, lapack_int* ldvl, double* vr, lapack_int* ldvr, lapack_int* ilo,
-                   lapack_int* ihi, double* scale, double* abnrm, double* rconde, double* rcondv, double* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_cgeevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* w, lapack_complex_float* vl, lapack_int* ldvl,
-                   lapack_complex_float* vr, lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi, float* scale,
-                   float* abnrm, float* rconde, float* rcondv, lapack_complex_float* work, lapack_int* lwork,
-                   float* rwork, lapack_int* info);
-void LAPACK_zgeevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* w, lapack_complex_double* vl, lapack_int* ldvl,
-                   lapack_complex_double* vr, lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi, double* scale,
-                   double* abnrm, double* rconde, double* rcondv, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* info);
-void LAPACK_sgesvd(char* jobu, char* jobvt, lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* s, float* u,
-                   lapack_int* ldu, float* vt, lapack_int* ldvt, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dgesvd(char* jobu, char* jobvt, lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* s,
-                   double* u, lapack_int* ldu, double* vt, lapack_int* ldvt, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_cgesvd(char* jobu, char* jobvt, lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                   float* s, lapack_complex_float* u, lapack_int* ldu, lapack_complex_float* vt, lapack_int* ldvt,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* info);
-void LAPACK_zgesvd(char* jobu, char* jobvt, lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   double* s, lapack_complex_double* u, lapack_int* ldu, lapack_complex_double* vt, lapack_int* ldvt,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* info);
-void LAPACK_sgesdd(char* jobz, lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* s, float* u,
-                   lapack_int* ldu, float* vt, lapack_int* ldvt, float* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_dgesdd(char* jobz, lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* s, double* u,
-                   lapack_int* ldu, double* vt, lapack_int* ldvt, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* info);
-void LAPACK_cgesdd(char* jobz, lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, float* s,
-                   lapack_complex_float* u, lapack_int* ldu, lapack_complex_float* vt, lapack_int* ldvt,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_zgesdd(char* jobz, lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, double* s,
-                   lapack_complex_double* u, lapack_int* ldu, lapack_complex_double* vt, lapack_int* ldvt,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dgejsv(char* joba, char* jobu, char* jobv, char* jobr, char* jobt, char* jobp, lapack_int* m, lapack_int* n,
-                   double* a, lapack_int* lda, double* sva, double* u, lapack_int* ldu, double* v, lapack_int* ldv,
-                   double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_sgejsv(char* joba, char* jobu, char* jobv, char* jobr, char* jobt, char* jobp, lapack_int* m, lapack_int* n,
-                   float* a, lapack_int* lda, float* sva, float* u, lapack_int* ldu, float* v, lapack_int* ldv,
-                   float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dgesvj(char* joba, char* jobu, char* jobv, lapack_int* m, lapack_int* n, double* a, lapack_int* lda,
-                   double* sva, lapack_int* mv, double* v, lapack_int* ldv, double* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_sgesvj(char* joba, char* jobu, char* jobv, lapack_int* m, lapack_int* n, float* a, lapack_int* lda,
-                   float* sva, lapack_int* mv, float* v, lapack_int* ldv, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_sggsvd(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* n, lapack_int* p, lapack_int* k,
-                   lapack_int* l, float* a, lapack_int* lda, float* b, lapack_int* ldb, float* alpha, float* beta,
-                   float* u, lapack_int* ldu, float* v, lapack_int* ldv, float* q, lapack_int* ldq, float* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_dggsvd(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* n, lapack_int* p, lapack_int* k,
-                   lapack_int* l, double* a, lapack_int* lda, double* b, lapack_int* ldb, double* alpha, double* beta,
-                   double* u, lapack_int* ldu, double* v, lapack_int* ldv, double* q, lapack_int* ldq, double* work,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_cggsvd(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* n, lapack_int* p, lapack_int* k,
-                   lapack_int* l, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
-                   float* alpha, float* beta, lapack_complex_float* u, lapack_int* ldu, lapack_complex_float* v,
-                   lapack_int* ldv, lapack_complex_float* q, lapack_int* ldq, lapack_complex_float* work, float* rwork,
-                   lapack_int* iwork, lapack_int* info);
-void LAPACK_zggsvd(char* jobu, char* jobv, char* jobq, lapack_int* m, lapack_int* n, lapack_int* p, lapack_int* k,
-                   lapack_int* l, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
-                   double* alpha, double* beta, lapack_complex_double* u, lapack_int* ldu, lapack_complex_double* v,
-                   lapack_int* ldv, lapack_complex_double* q, lapack_int* ldq, lapack_complex_double* work,
-                   double* rwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_ssygv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, float* a, lapack_int* lda, float* b,
-                  lapack_int* ldb, float* w, float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dsygv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, double* a, lapack_int* lda, double* b,
-                  lapack_int* ldb, double* w, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_chegv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                  lapack_complex_float* b, lapack_int* ldb, float* w, lapack_complex_float* work, lapack_int* lwork,
-                  float* rwork, lapack_int* info);
-void LAPACK_zhegv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                  lapack_complex_double* b, lapack_int* ldb, double* w, lapack_complex_double* work, lapack_int* lwork,
-                  double* rwork, lapack_int* info);
-void LAPACK_ssygvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, float* a, lapack_int* lda, float* b,
-                   lapack_int* ldb, float* w, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dsygvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, double* w, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_chegvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb, float* w, lapack_complex_float* work, lapack_int* lwork,
-                   float* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_zhegvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb, double* w, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_ssygvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, float* a, lapack_int* lda,
-                   float* b, lapack_int* ldb, float* vl, float* vu, lapack_int* il, lapack_int* iu, float* abstol,
-                   lapack_int* m, float* w, float* z, lapack_int* ldz, float* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_dsygvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, double* a, lapack_int* lda,
-                   double* b, lapack_int* ldb, double* vl, double* vu, lapack_int* il, lapack_int* iu, double* abstol,
-                   lapack_int* m, double* w, double* z, lapack_int* ldz, double* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_chegvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, float* vl, float* vu, lapack_int* il,
-                   lapack_int* iu, float* abstol, lapack_int* m, float* w, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* iwork, lapack_int* ifail,
-                   lapack_int* info);
-void LAPACK_zhegvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, double* vl, double* vu, lapack_int* il,
-                   lapack_int* iu, double* abstol, lapack_int* m, double* w, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* iwork, lapack_int* ifail,
-                   lapack_int* info);
-void LAPACK_sspgv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, float* ap, float* bp, float* w, float* z,
-                  lapack_int* ldz, float* work, lapack_int* info);
-void LAPACK_dspgv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, double* ap, double* bp, double* w,
-                  double* z, lapack_int* ldz, double* work, lapack_int* info);
-void LAPACK_chpgv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_float* ap,
-                  lapack_complex_float* bp, float* w, lapack_complex_float* z, lapack_int* ldz,
-                  lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zhpgv(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_double* ap,
-                  lapack_complex_double* bp, double* w, lapack_complex_double* z, lapack_int* ldz,
-                  lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_sspgvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, float* ap, float* bp, float* w, float* z,
-                   lapack_int* ldz, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_dspgvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, double* ap, double* bp, double* w,
-                   double* z, lapack_int* ldz, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_int* info);
-void LAPACK_chpgvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_float* ap,
-                   lapack_complex_float* bp, float* w, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* lrwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_zhpgvd(lapack_int* itype, char* jobz, char* uplo, lapack_int* n, lapack_complex_double* ap,
-                   lapack_complex_double* bp, double* w, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* lrwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_int* info);
-void LAPACK_sspgvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, float* ap, float* bp,
-                   float* vl, float* vu, lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w,
-                   float* z, lapack_int* ldz, float* work, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_dspgvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, double* ap, double* bp,
-                   double* vl, double* vu, lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w,
-                   double* z, lapack_int* ldz, double* work, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_chpgvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_float* ap,
-                   lapack_complex_float* bp, float* vl, float* vu, lapack_int* il, lapack_int* iu, float* abstol,
-                   lapack_int* m, float* w, lapack_complex_float* z, lapack_int* ldz, lapack_complex_float* work,
-                   float* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_zhpgvx(lapack_int* itype, char* jobz, char* range, char* uplo, lapack_int* n, lapack_complex_double* ap,
-                   lapack_complex_double* bp, double* vl, double* vu, lapack_int* il, lapack_int* iu, double* abstol,
-                   lapack_int* m, double* w, lapack_complex_double* z, lapack_int* ldz, lapack_complex_double* work,
-                   double* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_ssbgv(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
-                  float* bb, lapack_int* ldbb, float* w, float* z, lapack_int* ldz, float* work, lapack_int* info);
-void LAPACK_dsbgv(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, double* ab, lapack_int* ldab,
-                  double* bb, lapack_int* ldbb, double* w, double* z, lapack_int* ldz, double* work, lapack_int* info);
-void LAPACK_chbgv(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
-                  lapack_int* ldab, lapack_complex_float* bb, lapack_int* ldbb, float* w, lapack_complex_float* z,
-                  lapack_int* ldz, lapack_complex_float* work, float* rwork, lapack_int* info);
-void LAPACK_zhbgv(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
-                  lapack_int* ldab, lapack_complex_double* bb, lapack_int* ldbb, double* w, lapack_complex_double* z,
-                  lapack_int* ldz, lapack_complex_double* work, double* rwork, lapack_int* info);
-void LAPACK_ssbgvd(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, float* ab, lapack_int* ldab,
-                   float* bb, lapack_int* ldbb, float* w, float* z, lapack_int* ldz, float* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_dsbgvd(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, double* ab, lapack_int* ldab,
-                   double* bb, lapack_int* ldbb, double* w, double* z, lapack_int* ldz, double* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_chbgvd(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, lapack_complex_float* ab,
-                   lapack_int* ldab, lapack_complex_float* bb, lapack_int* ldbb, float* w, lapack_complex_float* z,
-                   lapack_int* ldz, lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* lrwork,
-                   lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_zhbgvd(char* jobz, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, lapack_complex_double* ab,
-                   lapack_int* ldab, lapack_complex_double* bb, lapack_int* ldbb, double* w, lapack_complex_double* z,
-                   lapack_int* ldz, lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* lrwork,
-                   lapack_int* iwork, lapack_int* liwork, lapack_int* info);
-void LAPACK_ssbgvx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, float* ab,
-                   lapack_int* ldab, float* bb, lapack_int* ldbb, float* q, lapack_int* ldq, float* vl, float* vu,
-                   lapack_int* il, lapack_int* iu, float* abstol, lapack_int* m, float* w, float* z, lapack_int* ldz,
-                   float* work, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_dsbgvx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb, double* ab,
-                   lapack_int* ldab, double* bb, lapack_int* ldbb, double* q, lapack_int* ldq, double* vl, double* vu,
-                   lapack_int* il, lapack_int* iu, double* abstol, lapack_int* m, double* w, double* z, lapack_int* ldz,
-                   double* work, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_chbgvx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb,
-                   lapack_complex_float* ab, lapack_int* ldab, lapack_complex_float* bb, lapack_int* ldbb,
-                   lapack_complex_float* q, lapack_int* ldq, float* vl, float* vu, lapack_int* il, lapack_int* iu,
-                   float* abstol, lapack_int* m, float* w, lapack_complex_float* z, lapack_int* ldz,
-                   lapack_complex_float* work, float* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_zhbgvx(char* jobz, char* range, char* uplo, lapack_int* n, lapack_int* ka, lapack_int* kb,
-                   lapack_complex_double* ab, lapack_int* ldab, lapack_complex_double* bb, lapack_int* ldbb,
-                   lapack_complex_double* q, lapack_int* ldq, double* vl, double* vu, lapack_int* il, lapack_int* iu,
-                   double* abstol, lapack_int* m, double* w, lapack_complex_double* z, lapack_int* ldz,
-                   lapack_complex_double* work, double* rwork, lapack_int* iwork, lapack_int* ifail, lapack_int* info);
-void LAPACK_sgges(char* jobvsl, char* jobvsr, char* sort, LAPACK_S_SELECT3 selctg, lapack_int* n, float* a,
-                  lapack_int* lda, float* b, lapack_int* ldb, lapack_int* sdim, float* alphar, float* alphai,
-                  float* beta, float* vsl, lapack_int* ldvsl, float* vsr, lapack_int* ldvsr, float* work,
-                  lapack_int* lwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_dgges(char* jobvsl, char* jobvsr, char* sort, LAPACK_D_SELECT3 selctg, lapack_int* n, double* a,
-                  lapack_int* lda, double* b, lapack_int* ldb, lapack_int* sdim, double* alphar, double* alphai,
-                  double* beta, double* vsl, lapack_int* ldvsl, double* vsr, lapack_int* ldvsr, double* work,
-                  lapack_int* lwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_cgges(char* jobvsl, char* jobvsr, char* sort, LAPACK_C_SELECT2 selctg, lapack_int* n,
-                  lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
-                  lapack_complex_float* alpha, lapack_complex_float* beta, lapack_complex_float* vsl, lapack_int* ldvsl,
-                  lapack_complex_float* vsr, lapack_int* ldvsr, lapack_complex_float* work, lapack_int* lwork,
-                  float* rwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_zgges(char* jobvsl, char* jobvsr, char* sort, LAPACK_Z_SELECT2 selctg, lapack_int* n,
-                  lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
-                  lapack_int* sdim, lapack_complex_double* alpha, lapack_complex_double* beta,
-                  lapack_complex_double* vsl, lapack_int* ldvsl, lapack_complex_double* vsr, lapack_int* ldvsr,
-                  lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_logical* bwork,
-                  lapack_int* info);
-void LAPACK_sggesx(char* jobvsl, char* jobvsr, char* sort, LAPACK_S_SELECT3 selctg, char* sense, lapack_int* n,
-                   float* a, lapack_int* lda, float* b, lapack_int* ldb, lapack_int* sdim, float* alphar, float* alphai,
-                   float* beta, float* vsl, lapack_int* ldvsl, float* vsr, lapack_int* ldvsr, float* rconde,
-                   float* rcondv, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_logical* bwork, lapack_int* info);
-void LAPACK_dggesx(char* jobvsl, char* jobvsr, char* sort, LAPACK_D_SELECT3 selctg, char* sense, lapack_int* n,
-                   double* a, lapack_int* lda, double* b, lapack_int* ldb, lapack_int* sdim, double* alphar,
-                   double* alphai, double* beta, double* vsl, lapack_int* ldvsl, double* vsr, lapack_int* ldvsr,
-                   double* rconde, double* rcondv, double* work, lapack_int* lwork, lapack_int* iwork,
-                   lapack_int* liwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_cggesx(char* jobvsl, char* jobvsr, char* sort, LAPACK_C_SELECT2 selctg, char* sense, lapack_int* n,
-                   lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, lapack_int* sdim,
-                   lapack_complex_float* alpha, lapack_complex_float* beta, lapack_complex_float* vsl,
-                   lapack_int* ldvsl, lapack_complex_float* vsr, lapack_int* ldvsr, float* rconde, float* rcondv,
-                   lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* iwork, lapack_int* liwork,
-                   lapack_logical* bwork, lapack_int* info);
-void LAPACK_zggesx(char* jobvsl, char* jobvsr, char* sort, LAPACK_Z_SELECT2 selctg, char* sense, lapack_int* n,
-                   lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
-                   lapack_int* sdim, lapack_complex_double* alpha, lapack_complex_double* beta,
-                   lapack_complex_double* vsl, lapack_int* ldvsl, lapack_complex_double* vsr, lapack_int* ldvsr,
-                   double* rconde, double* rcondv, lapack_complex_double* work, lapack_int* lwork, double* rwork,
-                   lapack_int* iwork, lapack_int* liwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_sggev(char* jobvl, char* jobvr, lapack_int* n, float* a, lapack_int* lda, float* b, lapack_int* ldb,
-                  float* alphar, float* alphai, float* beta, float* vl, lapack_int* ldvl, float* vr, lapack_int* ldvr,
-                  float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dggev(char* jobvl, char* jobvr, lapack_int* n, double* a, lapack_int* lda, double* b, lapack_int* ldb,
-                  double* alphar, double* alphai, double* beta, double* vl, lapack_int* ldvl, double* vr,
-                  lapack_int* ldvr, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cggev(char* jobvl, char* jobvr, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                  lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* alpha, lapack_complex_float* beta,
-                  lapack_complex_float* vl, lapack_int* ldvl, lapack_complex_float* vr, lapack_int* ldvr,
-                  lapack_complex_float* work, lapack_int* lwork, float* rwork, lapack_int* info);
-void LAPACK_zggev(char* jobvl, char* jobvr, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                  lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* alpha, lapack_complex_double* beta,
-                  lapack_complex_double* vl, lapack_int* ldvl, lapack_complex_double* vr, lapack_int* ldvr,
-                  lapack_complex_double* work, lapack_int* lwork, double* rwork, lapack_int* info);
-void LAPACK_sggevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, float* a, lapack_int* lda,
-                   float* b, lapack_int* ldb, float* alphar, float* alphai, float* beta, float* vl, lapack_int* ldvl,
-                   float* vr, lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi, float* lscale, float* rscale,
-                   float* abnrm, float* bbnrm, float* rconde, float* rcondv, float* work, lapack_int* lwork,
-                   lapack_int* iwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_dggevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, double* a, lapack_int* lda,
-                   double* b, lapack_int* ldb, double* alphar, double* alphai, double* beta, double* vl,
-                   lapack_int* ldvl, double* vr, lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi, double* lscale,
-                   double* rscale, double* abnrm, double* bbnrm, double* rconde, double* rcondv, double* work,
-                   lapack_int* lwork, lapack_int* iwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_cggevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* alpha,
-                   lapack_complex_float* beta, lapack_complex_float* vl, lapack_int* ldvl, lapack_complex_float* vr,
-                   lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi, float* lscale, float* rscale, float* abnrm,
-                   float* bbnrm, float* rconde, float* rcondv, lapack_complex_float* work, lapack_int* lwork,
-                   float* rwork, lapack_int* iwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_zggevx(char* balanc, char* jobvl, char* jobvr, char* sense, lapack_int* n, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* alpha,
-                   lapack_complex_double* beta, lapack_complex_double* vl, lapack_int* ldvl, lapack_complex_double* vr,
-                   lapack_int* ldvr, lapack_int* ilo, lapack_int* ihi, double* lscale, double* rscale, double* abnrm,
-                   double* bbnrm, double* rconde, double* rcondv, lapack_complex_double* work, lapack_int* lwork,
-                   double* rwork, lapack_int* iwork, lapack_logical* bwork, lapack_int* info);
-void LAPACK_dsfrk(char* transr, char* uplo, char* trans, lapack_int* n, lapack_int* k, double* alpha, const double* a,
-                  lapack_int* lda, double* beta, double* c);
-void LAPACK_ssfrk(char* transr, char* uplo, char* trans, lapack_int* n, lapack_int* k, float* alpha, const float* a,
-                  lapack_int* lda, float* beta, float* c);
-void LAPACK_zhfrk(char* transr, char* uplo, char* trans, lapack_int* n, lapack_int* k, double* alpha,
-                  const lapack_complex_double* a, lapack_int* lda, double* beta, lapack_complex_double* c);
-void LAPACK_chfrk(char* transr, char* uplo, char* trans, lapack_int* n, lapack_int* k, float* alpha,
-                  const lapack_complex_float* a, lapack_int* lda, float* beta, lapack_complex_float* c);
-void LAPACK_dtfsm(char* transr, char* side, char* uplo, char* trans, char* diag, lapack_int* m, lapack_int* n,
-                  double* alpha, const double* a, double* b, lapack_int* ldb);
-void LAPACK_stfsm(char* transr, char* side, char* uplo, char* trans, char* diag, lapack_int* m, lapack_int* n,
-                  float* alpha, const float* a, float* b, lapack_int* ldb);
-void LAPACK_ztfsm(char* transr, char* side, char* uplo, char* trans, char* diag, lapack_int* m, lapack_int* n,
-                  lapack_complex_double* alpha, const lapack_complex_double* a, lapack_complex_double* b,
-                  lapack_int* ldb);
-void LAPACK_ctfsm(char* transr, char* side, char* uplo, char* trans, char* diag, lapack_int* m, lapack_int* n,
-                  lapack_complex_float* alpha, const lapack_complex_float* a, lapack_complex_float* b, lapack_int* ldb);
-void LAPACK_dtfttp(char* transr, char* uplo, lapack_int* n, const double* arf, double* ap, lapack_int* info);
-void LAPACK_stfttp(char* transr, char* uplo, lapack_int* n, const float* arf, float* ap, lapack_int* info);
-void LAPACK_ztfttp(char* transr, char* uplo, lapack_int* n, const lapack_complex_double* arf, lapack_complex_double* ap,
-                   lapack_int* info);
-void LAPACK_ctfttp(char* transr, char* uplo, lapack_int* n, const lapack_complex_float* arf, lapack_complex_float* ap,
-                   lapack_int* info);
-void LAPACK_dtfttr(char* transr, char* uplo, lapack_int* n, const double* arf, double* a, lapack_int* lda,
-                   lapack_int* info);
-void LAPACK_stfttr(char* transr, char* uplo, lapack_int* n, const float* arf, float* a, lapack_int* lda,
-                   lapack_int* info);
-void LAPACK_ztfttr(char* transr, char* uplo, lapack_int* n, const lapack_complex_double* arf, lapack_complex_double* a,
-                   lapack_int* lda, lapack_int* info);
-void LAPACK_ctfttr(char* transr, char* uplo, lapack_int* n, const lapack_complex_float* arf, lapack_complex_float* a,
-                   lapack_int* lda, lapack_int* info);
-void LAPACK_dtpttf(char* transr, char* uplo, lapack_int* n, const double* ap, double* arf, lapack_int* info);
-void LAPACK_stpttf(char* transr, char* uplo, lapack_int* n, const float* ap, float* arf, lapack_int* info);
-void LAPACK_ztpttf(char* transr, char* uplo, lapack_int* n, const lapack_complex_double* ap, lapack_complex_double* arf,
-                   lapack_int* info);
-void LAPACK_ctpttf(char* transr, char* uplo, lapack_int* n, const lapack_complex_float* ap, lapack_complex_float* arf,
-                   lapack_int* info);
-void LAPACK_dtpttr(char* uplo, lapack_int* n, const double* ap, double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_stpttr(char* uplo, lapack_int* n, const float* ap, float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_ztpttr(char* uplo, lapack_int* n, const lapack_complex_double* ap, lapack_complex_double* a,
-                   lapack_int* lda, lapack_int* info);
-void LAPACK_ctpttr(char* uplo, lapack_int* n, const lapack_complex_float* ap, lapack_complex_float* a, lapack_int* lda,
-                   lapack_int* info);
-void LAPACK_dtrttf(char* transr, char* uplo, lapack_int* n, const double* a, lapack_int* lda, double* arf,
-                   lapack_int* info);
-void LAPACK_strttf(char* transr, char* uplo, lapack_int* n, const float* a, lapack_int* lda, float* arf,
-                   lapack_int* info);
-void LAPACK_ztrttf(char* transr, char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* arf, lapack_int* info);
-void LAPACK_ctrttf(char* transr, char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* arf, lapack_int* info);
-void LAPACK_dtrttp(char* uplo, lapack_int* n, const double* a, lapack_int* lda, double* ap, lapack_int* info);
-void LAPACK_strttp(char* uplo, lapack_int* n, const float* a, lapack_int* lda, float* ap, lapack_int* info);
-void LAPACK_ztrttp(char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* ap, lapack_int* info);
-void LAPACK_ctrttp(char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, lapack_complex_float* ap,
-                   lapack_int* info);
-void LAPACK_sgeqrfp(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* lwork,
-                    lapack_int* info);
-void LAPACK_dgeqrfp(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                    lapack_int* lwork, lapack_int* info);
-void LAPACK_cgeqrfp(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                    lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zgeqrfp(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                    lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_clacgv(lapack_int* n, lapack_complex_float* x, lapack_int* incx);
-void LAPACK_zlacgv(lapack_int* n, lapack_complex_double* x, lapack_int* incx);
-void LAPACK_slarnv(lapack_int* idist, lapack_int* iseed, lapack_int* n, float* x);
-void LAPACK_dlarnv(lapack_int* idist, lapack_int* iseed, lapack_int* n, double* x);
-void LAPACK_clarnv(lapack_int* idist, lapack_int* iseed, lapack_int* n, lapack_complex_float* x);
-void LAPACK_zlarnv(lapack_int* idist, lapack_int* iseed, lapack_int* n, lapack_complex_double* x);
-void LAPACK_sgeqr2(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* info);
-void LAPACK_dgeqr2(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* info);
-void LAPACK_cgeqr2(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zgeqr2(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_slacpy(char* uplo, lapack_int* m, lapack_int* n, const float* a, lapack_int* lda, float* b,
-                   lapack_int* ldb);
-void LAPACK_dlacpy(char* uplo, lapack_int* m, lapack_int* n, const double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb);
-void LAPACK_clacpy(char* uplo, lapack_int* m, lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* b, lapack_int* ldb);
-void LAPACK_zlacpy(char* uplo, lapack_int* m, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* b, lapack_int* ldb);
-void LAPACK_sgetf2(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, lapack_int* ipiv, lapack_int* info);
-void LAPACK_dgetf2(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, lapack_int* ipiv, lapack_int* info);
-void LAPACK_cgetf2(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_int* info);
-void LAPACK_zgetf2(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* ipiv,
-                   lapack_int* info);
-void LAPACK_slaswp(lapack_int* n, float* a, lapack_int* lda, lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
-                   lapack_int* incx);
-void LAPACK_dlaswp(lapack_int* n, double* a, lapack_int* lda, lapack_int* k1, lapack_int* k2, const lapack_int* ipiv,
-                   lapack_int* incx);
-void LAPACK_claswp(lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* k1, lapack_int* k2,
-                   const lapack_int* ipiv, lapack_int* incx);
-void LAPACK_zlaswp(lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* k1, lapack_int* k2,
-                   const lapack_int* ipiv, lapack_int* incx);
-float LAPACK_slange(char* norm, lapack_int* m, lapack_int* n, const float* a, lapack_int* lda, float* work);
-double LAPACK_dlange(char* norm, lapack_int* m, lapack_int* n, const double* a, lapack_int* lda, double* work);
-float LAPACK_clange(char* norm, lapack_int* m, lapack_int* n, const lapack_complex_float* a, lapack_int* lda,
-                    float* work);
-double LAPACK_zlange(char* norm, lapack_int* m, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                     double* work);
-float LAPACK_clanhe(char* norm, char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* work);
-double LAPACK_zlanhe(char* norm, char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                     double* work);
-float LAPACK_slansy(char* norm, char* uplo, lapack_int* n, const float* a, lapack_int* lda, float* work);
-double LAPACK_dlansy(char* norm, char* uplo, lapack_int* n, const double* a, lapack_int* lda, double* work);
-float LAPACK_clansy(char* norm, char* uplo, lapack_int* n, const lapack_complex_float* a, lapack_int* lda, float* work);
-double LAPACK_zlansy(char* norm, char* uplo, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                     double* work);
-float LAPACK_slantr(char* norm, char* uplo, char* diag, lapack_int* m, lapack_int* n, const float* a, lapack_int* lda,
-                    float* work);
-double LAPACK_dlantr(char* norm, char* uplo, char* diag, lapack_int* m, lapack_int* n, const double* a, lapack_int* lda,
-                     double* work);
-float LAPACK_clantr(char* norm, char* uplo, char* diag, lapack_int* m, lapack_int* n, const lapack_complex_float* a,
-                    lapack_int* lda, float* work);
-double LAPACK_zlantr(char* norm, char* uplo, char* diag, lapack_int* m, lapack_int* n, const lapack_complex_double* a,
-                     lapack_int* lda, double* work);
-float LAPACK_slamch(char* cmach);
-double LAPACK_dlamch(char* cmach);
-void LAPACK_sgelq2(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* tau, float* work, lapack_int* info);
-void LAPACK_dgelq2(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* tau, double* work,
-                   lapack_int* info);
-void LAPACK_cgelq2(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* tau,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_zgelq2(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* tau,
-                   lapack_complex_double* work, lapack_int* info);
-void LAPACK_slarfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   const float* v, lapack_int* ldv, const float* t, lapack_int* ldt, float* c, lapack_int* ldc,
-                   float* work, lapack_int* ldwork);
-void LAPACK_dlarfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   const double* v, lapack_int* ldv, const double* t, lapack_int* ldt, double* c, lapack_int* ldc,
-                   double* work, lapack_int* ldwork);
-void LAPACK_clarfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   const lapack_complex_float* v, lapack_int* ldv, const lapack_complex_float* t, lapack_int* ldt,
-                   lapack_complex_float* c, lapack_int* ldc, lapack_complex_float* work, lapack_int* ldwork);
-void LAPACK_zlarfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   const lapack_complex_double* v, lapack_int* ldv, const lapack_complex_double* t, lapack_int* ldt,
-                   lapack_complex_double* c, lapack_int* ldc, lapack_complex_double* work, lapack_int* ldwork);
-void LAPACK_slarfg(lapack_int* n, float* alpha, float* x, lapack_int* incx, float* tau);
-void LAPACK_dlarfg(lapack_int* n, double* alpha, double* x, lapack_int* incx, double* tau);
-void LAPACK_clarfg(lapack_int* n, lapack_complex_float* alpha, lapack_complex_float* x, lapack_int* incx,
-                   lapack_complex_float* tau);
-void LAPACK_zlarfg(lapack_int* n, lapack_complex_double* alpha, lapack_complex_double* x, lapack_int* incx,
-                   lapack_complex_double* tau);
-void LAPACK_slarft(char* direct, char* storev, lapack_int* n, lapack_int* k, const float* v, lapack_int* ldv,
-                   const float* tau, float* t, lapack_int* ldt);
-void LAPACK_dlarft(char* direct, char* storev, lapack_int* n, lapack_int* k, const double* v, lapack_int* ldv,
-                   const double* tau, double* t, lapack_int* ldt);
-void LAPACK_clarft(char* direct, char* storev, lapack_int* n, lapack_int* k, const lapack_complex_float* v,
-                   lapack_int* ldv, const lapack_complex_float* tau, lapack_complex_float* t, lapack_int* ldt);
-void LAPACK_zlarft(char* direct, char* storev, lapack_int* n, lapack_int* k, const lapack_complex_double* v,
-                   lapack_int* ldv, const lapack_complex_double* tau, lapack_complex_double* t, lapack_int* ldt);
-void LAPACK_slarfx(char* side, lapack_int* m, lapack_int* n, const float* v, float* tau, float* c, lapack_int* ldc,
-                   float* work);
-void LAPACK_dlarfx(char* side, lapack_int* m, lapack_int* n, const double* v, double* tau, double* c, lapack_int* ldc,
-                   double* work);
-void LAPACK_clarfx(char* side, lapack_int* m, lapack_int* n, const lapack_complex_float* v, lapack_complex_float* tau,
-                   lapack_complex_float* c, lapack_int* ldc, lapack_complex_float* work);
-void LAPACK_zlarfx(char* side, lapack_int* m, lapack_int* n, const lapack_complex_double* v, lapack_complex_double* tau,
-                   lapack_complex_double* c, lapack_int* ldc, lapack_complex_double* work);
-void LAPACK_slatms(lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed, char* sym, float* d, lapack_int* mode,
-                   float* cond, float* dmax, lapack_int* kl, lapack_int* ku, char* pack, float* a, lapack_int* lda,
-                   float* work, lapack_int* info);
-void LAPACK_dlatms(lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed, char* sym, double* d, lapack_int* mode,
-                   double* cond, double* dmax, lapack_int* kl, lapack_int* ku, char* pack, double* a, lapack_int* lda,
-                   double* work, lapack_int* info);
-void LAPACK_clatms(lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed, char* sym, float* d, lapack_int* mode,
-                   float* cond, float* dmax, lapack_int* kl, lapack_int* ku, char* pack, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zlatms(lapack_int* m, lapack_int* n, char* dist, lapack_int* iseed, char* sym, double* d, lapack_int* mode,
-                   double* cond, double* dmax, lapack_int* kl, lapack_int* ku, char* pack, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* work, lapack_int* info);
-void LAPACK_slag2d(lapack_int* m, lapack_int* n, const float* sa, lapack_int* ldsa, double* a, lapack_int* lda,
-                   lapack_int* info);
-void LAPACK_dlag2s(lapack_int* m, lapack_int* n, const double* a, lapack_int* lda, float* sa, lapack_int* ldsa,
-                   lapack_int* info);
-void LAPACK_clag2z(lapack_int* m, lapack_int* n, const lapack_complex_float* sa, lapack_int* ldsa,
-                   lapack_complex_double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_zlag2c(lapack_int* m, lapack_int* n, const lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_float* sa, lapack_int* ldsa, lapack_int* info);
-void LAPACK_slauum(char* uplo, lapack_int* n, float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_dlauum(char* uplo, lapack_int* n, double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_clauum(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_int* info);
-void LAPACK_zlauum(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_int* info);
-void LAPACK_slagge(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const float* d, float* a,
-                   lapack_int* lda, lapack_int* iseed, float* work, lapack_int* info);
-void LAPACK_dlagge(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const double* d, double* a,
-                   lapack_int* lda, lapack_int* iseed, double* work, lapack_int* info);
-void LAPACK_clagge(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const float* d,
-                   lapack_complex_float* a, lapack_int* lda, lapack_int* iseed, lapack_complex_float* work,
-                   lapack_int* info);
-void LAPACK_zlagge(lapack_int* m, lapack_int* n, lapack_int* kl, lapack_int* ku, const double* d,
-                   lapack_complex_double* a, lapack_int* lda, lapack_int* iseed, lapack_complex_double* work,
-                   lapack_int* info);
-void LAPACK_slaset(char* uplo, lapack_int* m, lapack_int* n, float* alpha, float* beta, float* a, lapack_int* lda);
-void LAPACK_dlaset(char* uplo, lapack_int* m, lapack_int* n, double* alpha, double* beta, double* a, lapack_int* lda);
-void LAPACK_claset(char* uplo, lapack_int* m, lapack_int* n, lapack_complex_float* alpha, lapack_complex_float* beta,
-                   lapack_complex_float* a, lapack_int* lda);
-void LAPACK_zlaset(char* uplo, lapack_int* m, lapack_int* n, lapack_complex_double* alpha, lapack_complex_double* beta,
-                   lapack_complex_double* a, lapack_int* lda);
-void LAPACK_slasrt(char* id, lapack_int* n, float* d, lapack_int* info);
-void LAPACK_dlasrt(char* id, lapack_int* n, double* d, lapack_int* info);
-void LAPACK_claghe(lapack_int* n, lapack_int* k, const float* d, lapack_complex_float* a, lapack_int* lda,
-                   lapack_int* iseed, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zlaghe(lapack_int* n, lapack_int* k, const double* d, lapack_complex_double* a, lapack_int* lda,
-                   lapack_int* iseed, lapack_complex_double* work, lapack_int* info);
-void LAPACK_slagsy(lapack_int* n, lapack_int* k, const float* d, float* a, lapack_int* lda, lapack_int* iseed,
-                   float* work, lapack_int* info);
-void LAPACK_dlagsy(lapack_int* n, lapack_int* k, const double* d, double* a, lapack_int* lda, lapack_int* iseed,
-                   double* work, lapack_int* info);
-void LAPACK_clagsy(lapack_int* n, lapack_int* k, const float* d, lapack_complex_float* a, lapack_int* lda,
-                   lapack_int* iseed, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zlagsy(lapack_int* n, lapack_int* k, const double* d, lapack_complex_double* a, lapack_int* lda,
-                   lapack_int* iseed, lapack_complex_double* work, lapack_int* info);
-void LAPACK_slapmr(lapack_logical* forwrd, lapack_int* m, lapack_int* n, float* x, lapack_int* ldx, lapack_int* k);
-void LAPACK_dlapmr(lapack_logical* forwrd, lapack_int* m, lapack_int* n, double* x, lapack_int* ldx, lapack_int* k);
-void LAPACK_clapmr(lapack_logical* forwrd, lapack_int* m, lapack_int* n, lapack_complex_float* x, lapack_int* ldx,
-                   lapack_int* k);
-void LAPACK_zlapmr(lapack_logical* forwrd, lapack_int* m, lapack_int* n, lapack_complex_double* x, lapack_int* ldx,
-                   lapack_int* k);
-float LAPACK_slapy2(float* x, float* y);
-double LAPACK_dlapy2(double* x, double* y);
-float LAPACK_slapy3(float* x, float* y, float* z);
-double LAPACK_dlapy3(double* x, double* y, double* z);
-void LAPACK_slartgp(float* f, float* g, float* cs, float* sn, float* r);
-void LAPACK_dlartgp(double* f, double* g, double* cs, double* sn, double* r);
-void LAPACK_slartgs(float* x, float* y, float* sigma, float* cs, float* sn);
-void LAPACK_dlartgs(double* x, double* y, double* sigma, double* cs, double* sn);
-// LAPACK 3.3.0
-void LAPACK_cbbcsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, lapack_int* m, lapack_int* p,
-                   lapack_int* q, float* theta, float* phi, lapack_complex_float* u1, lapack_int* ldu1,
-                   lapack_complex_float* u2, lapack_int* ldu2, lapack_complex_float* v1t, lapack_int* ldv1t,
-                   lapack_complex_float* v2t, lapack_int* ldv2t, float* b11d, float* b11e, float* b12d, float* b12e,
-                   float* b21d, float* b21e, float* b22d, float* b22e, float* rwork, lapack_int* lrwork,
-                   lapack_int* info);
-void LAPACK_cheswapr(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* i1, lapack_int* i2);
-void LAPACK_chetri2(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                    lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_chetri2x(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                     lapack_complex_float* work, lapack_int* nb, lapack_int* info);
-void LAPACK_chetrs2(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                    const lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* work,
-                    lapack_int* info);
-void LAPACK_csyconv(char* uplo, char* way, lapack_int* n, lapack_complex_float* a, lapack_int* lda,
-                    const lapack_int* ipiv, lapack_complex_float* work, lapack_int* info);
-void LAPACK_csyswapr(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* i1, lapack_int* i2);
-void LAPACK_csytri2(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                    lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_csytri2x(char* uplo, lapack_int* n, lapack_complex_float* a, lapack_int* lda, const lapack_int* ipiv,
-                     lapack_complex_float* work, lapack_int* nb, lapack_int* info);
-void LAPACK_csytrs2(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_float* a, lapack_int* lda,
-                    const lapack_int* ipiv, lapack_complex_float* b, lapack_int* ldb, lapack_complex_float* work,
-                    lapack_int* info);
-void LAPACK_cunbdb(char* trans, char* signs, lapack_int* m, lapack_int* p, lapack_int* q, lapack_complex_float* x11,
-                   lapack_int* ldx11, lapack_complex_float* x12, lapack_int* ldx12, lapack_complex_float* x21,
-                   lapack_int* ldx21, lapack_complex_float* x22, lapack_int* ldx22, float* theta, float* phi,
-                   lapack_complex_float* taup1, lapack_complex_float* taup2, lapack_complex_float* tauq1,
-                   lapack_complex_float* tauq2, lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_cuncsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, char* signs, lapack_int* m,
-                   lapack_int* p, lapack_int* q, lapack_complex_float* x11, lapack_int* ldx11,
-                   lapack_complex_float* x12, lapack_int* ldx12, lapack_complex_float* x21, lapack_int* ldx21,
-                   lapack_complex_float* x22, lapack_int* ldx22, float* theta, lapack_complex_float* u1,
-                   lapack_int* ldu1, lapack_complex_float* u2, lapack_int* ldu2, lapack_complex_float* v1t,
-                   lapack_int* ldv1t, lapack_complex_float* v2t, lapack_int* ldv2t, lapack_complex_float* work,
-                   lapack_int* lwork, float* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dbbcsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, lapack_int* m, lapack_int* p,
-                   lapack_int* q, double* theta, double* phi, double* u1, lapack_int* ldu1, double* u2,
-                   lapack_int* ldu2, double* v1t, lapack_int* ldv1t, double* v2t, lapack_int* ldv2t, double* b11d,
-                   double* b11e, double* b12d, double* b12e, double* b21d, double* b21e, double* b22d, double* b22e,
-                   double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorbdb(char* trans, char* signs, lapack_int* m, lapack_int* p, lapack_int* q, double* x11,
-                   lapack_int* ldx11, double* x12, lapack_int* ldx12, double* x21, lapack_int* ldx21, double* x22,
-                   lapack_int* ldx22, double* theta, double* phi, double* taup1, double* taup2, double* tauq1,
-                   double* tauq2, double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dorcsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, char* signs, lapack_int* m,
-                   lapack_int* p, lapack_int* q, double* x11, lapack_int* ldx11, double* x12, lapack_int* ldx12,
-                   double* x21, lapack_int* ldx21, double* x22, lapack_int* ldx22, double* theta, double* u1,
-                   lapack_int* ldu1, double* u2, lapack_int* ldu2, double* v1t, lapack_int* ldv1t, double* v2t,
-                   lapack_int* ldv2t, double* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_dsyconv(char* uplo, char* way, lapack_int* n, double* a, lapack_int* lda, const lapack_int* ipiv,
-                    double* work, lapack_int* info);
-void LAPACK_dsyswapr(char* uplo, lapack_int* n, double* a, lapack_int* i1, lapack_int* i2);
-void LAPACK_dsytri2(char* uplo, lapack_int* n, double* a, lapack_int* lda, const lapack_int* ipiv,
-                    lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_dsytri2x(char* uplo, lapack_int* n, double* a, lapack_int* lda, const lapack_int* ipiv, double* work,
-                     lapack_int* nb, lapack_int* info);
-void LAPACK_dsytrs2(char* uplo, lapack_int* n, lapack_int* nrhs, const double* a, lapack_int* lda,
-                    const lapack_int* ipiv, double* b, lapack_int* ldb, double* work, lapack_int* info);
-void LAPACK_sbbcsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, lapack_int* m, lapack_int* p,
-                   lapack_int* q, float* theta, float* phi, float* u1, lapack_int* ldu1, float* u2, lapack_int* ldu2,
-                   float* v1t, lapack_int* ldv1t, float* v2t, lapack_int* ldv2t, float* b11d, float* b11e, float* b12d,
-                   float* b12e, float* b21d, float* b21e, float* b22d, float* b22e, float* work, lapack_int* lwork,
-                   lapack_int* info);
-void LAPACK_sorbdb(char* trans, char* signs, lapack_int* m, lapack_int* p, lapack_int* q, float* x11, lapack_int* ldx11,
-                   float* x12, lapack_int* ldx12, float* x21, lapack_int* ldx21, float* x22, lapack_int* ldx22,
-                   float* theta, float* phi, float* taup1, float* taup2, float* tauq1, float* tauq2, float* work,
-                   lapack_int* lwork, lapack_int* info);
-void LAPACK_sorcsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, char* signs, lapack_int* m,
-                   lapack_int* p, lapack_int* q, float* x11, lapack_int* ldx11, float* x12, lapack_int* ldx12,
-                   float* x21, lapack_int* ldx21, float* x22, lapack_int* ldx22, float* theta, float* u1,
-                   lapack_int* ldu1, float* u2, lapack_int* ldu2, float* v1t, lapack_int* ldv1t, float* v2t,
-                   lapack_int* ldv2t, float* work, lapack_int* lwork, lapack_int* iwork, lapack_int* info);
-void LAPACK_ssyconv(char* uplo, char* way, lapack_int* n, float* a, lapack_int* lda, const lapack_int* ipiv,
-                    float* work, lapack_int* info);
-void LAPACK_ssyswapr(char* uplo, lapack_int* n, float* a, lapack_int* i1, lapack_int* i2);
-void LAPACK_ssytri2(char* uplo, lapack_int* n, float* a, lapack_int* lda, const lapack_int* ipiv,
-                    lapack_complex_float* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_ssytri2x(char* uplo, lapack_int* n, float* a, lapack_int* lda, const lapack_int* ipiv, float* work,
-                     lapack_int* nb, lapack_int* info);
-void LAPACK_ssytrs2(char* uplo, lapack_int* n, lapack_int* nrhs, const float* a, lapack_int* lda,
-                    const lapack_int* ipiv, float* b, lapack_int* ldb, float* work, lapack_int* info);
-void LAPACK_zbbcsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, lapack_int* m, lapack_int* p,
-                   lapack_int* q, double* theta, double* phi, lapack_complex_double* u1, lapack_int* ldu1,
-                   lapack_complex_double* u2, lapack_int* ldu2, lapack_complex_double* v1t, lapack_int* ldv1t,
-                   lapack_complex_double* v2t, lapack_int* ldv2t, double* b11d, double* b11e, double* b12d,
-                   double* b12e, double* b21d, double* b21e, double* b22d, double* b22e, double* rwork,
-                   lapack_int* lrwork, lapack_int* info);
-void LAPACK_zheswapr(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* i1, lapack_int* i2);
-void LAPACK_zhetri2(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                    lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zhetri2x(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                     lapack_complex_double* work, lapack_int* nb, lapack_int* info);
-void LAPACK_zhetrs2(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                    const lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* work,
-                    lapack_int* info);
-void LAPACK_zsyconv(char* uplo, char* way, lapack_int* n, lapack_complex_double* a, lapack_int* lda,
-                    const lapack_int* ipiv, lapack_complex_double* work, lapack_int* info);
-void LAPACK_zsyswapr(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* i1, lapack_int* i2);
-void LAPACK_zsytri2(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                    lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zsytri2x(char* uplo, lapack_int* n, lapack_complex_double* a, lapack_int* lda, const lapack_int* ipiv,
-                     lapack_complex_double* work, lapack_int* nb, lapack_int* info);
-void LAPACK_zsytrs2(char* uplo, lapack_int* n, lapack_int* nrhs, const lapack_complex_double* a, lapack_int* lda,
-                    const lapack_int* ipiv, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* work,
-                    lapack_int* info);
-void LAPACK_zunbdb(char* trans, char* signs, lapack_int* m, lapack_int* p, lapack_int* q, lapack_complex_double* x11,
-                   lapack_int* ldx11, lapack_complex_double* x12, lapack_int* ldx12, lapack_complex_double* x21,
-                   lapack_int* ldx21, lapack_complex_double* x22, lapack_int* ldx22, double* theta, double* phi,
-                   lapack_complex_double* taup1, lapack_complex_double* taup2, lapack_complex_double* tauq1,
-                   lapack_complex_double* tauq2, lapack_complex_double* work, lapack_int* lwork, lapack_int* info);
-void LAPACK_zuncsd(char* jobu1, char* jobu2, char* jobv1t, char* jobv2t, char* trans, char* signs, lapack_int* m,
-                   lapack_int* p, lapack_int* q, lapack_complex_double* x11, lapack_int* ldx11,
-                   lapack_complex_double* x12, lapack_int* ldx12, lapack_complex_double* x21, lapack_int* ldx21,
-                   lapack_complex_double* x22, lapack_int* ldx22, double* theta, lapack_complex_double* u1,
-                   lapack_int* ldu1, lapack_complex_double* u2, lapack_int* ldu2, lapack_complex_double* v1t,
-                   lapack_int* ldv1t, lapack_complex_double* v2t, lapack_int* ldv2t, lapack_complex_double* work,
-                   lapack_int* lwork, double* rwork, lapack_int* lrwork, lapack_int* iwork, lapack_int* info);
-// LAPACK 3.4.0
-void LAPACK_sgemqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* nb,
-                    const float* v, lapack_int* ldv, const float* t, lapack_int* ldt, float* c, lapack_int* ldc,
-                    float* work, lapack_int* info);
-void LAPACK_dgemqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* nb,
-                    const double* v, lapack_int* ldv, const double* t, lapack_int* ldt, double* c, lapack_int* ldc,
-                    double* work, lapack_int* info);
-void LAPACK_cgemqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* nb,
-                    const lapack_complex_float* v, lapack_int* ldv, const lapack_complex_float* t, lapack_int* ldt,
-                    lapack_complex_float* c, lapack_int* ldc, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zgemqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* nb,
-                    const lapack_complex_double* v, lapack_int* ldv, const lapack_complex_double* t, lapack_int* ldt,
-                    lapack_complex_double* c, lapack_int* ldc, lapack_complex_double* work, lapack_int* info);
-void LAPACK_sgeqrt(lapack_int* m, lapack_int* n, lapack_int* nb, float* a, lapack_int* lda, float* t, lapack_int* ldt,
-                   float* work, lapack_int* info);
-void LAPACK_dgeqrt(lapack_int* m, lapack_int* n, lapack_int* nb, double* a, lapack_int* lda, double* t, lapack_int* ldt,
-                   double* work, lapack_int* info);
-void LAPACK_cgeqrt(lapack_int* m, lapack_int* n, lapack_int* nb, lapack_complex_float* a, lapack_int* lda,
-                   lapack_complex_float* t, lapack_int* ldt, lapack_complex_float* work, lapack_int* info);
-void LAPACK_zgeqrt(lapack_int* m, lapack_int* n, lapack_int* nb, lapack_complex_double* a, lapack_int* lda,
-                   lapack_complex_double* t, lapack_int* ldt, lapack_complex_double* work, lapack_int* info);
-void LAPACK_sgeqrt2(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* t, lapack_int* ldt,
-                    lapack_int* info);
-void LAPACK_dgeqrt2(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* t, lapack_int* ldt,
-                    lapack_int* info);
-void LAPACK_cgeqrt2(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* t,
-                    lapack_int* ldt, lapack_int* info);
-void LAPACK_zgeqrt2(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* t,
-                    lapack_int* ldt, lapack_int* info);
-void LAPACK_sgeqrt3(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* t, lapack_int* ldt,
-                    lapack_int* info);
-void LAPACK_dgeqrt3(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* t, lapack_int* ldt,
-                    lapack_int* info);
-void LAPACK_cgeqrt3(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* t,
-                    lapack_int* ldt, lapack_int* info);
-void LAPACK_zgeqrt3(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* t,
-                    lapack_int* ldt, lapack_int* info);
-void LAPACK_stpmqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l, lapack_int* nb,
-                    const float* v, lapack_int* ldv, const float* t, lapack_int* ldt, float* a, lapack_int* lda,
-                    float* b, lapack_int* ldb, float* work, lapack_int* info);
-void LAPACK_dtpmqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l, lapack_int* nb,
-                    const double* v, lapack_int* ldv, const double* t, lapack_int* ldt, double* a, lapack_int* lda,
-                    double* b, lapack_int* ldb, double* work, lapack_int* info);
-void LAPACK_ctpmqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l, lapack_int* nb,
-                    const lapack_complex_float* v, lapack_int* ldv, const lapack_complex_float* t, lapack_int* ldt,
-                    lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
-                    lapack_complex_float* work, lapack_int* info);
-void LAPACK_ztpmqrt(char* side, char* trans, lapack_int* m, lapack_int* n, lapack_int* k, lapack_int* l, lapack_int* nb,
-                    const lapack_complex_double* v, lapack_int* ldv, const lapack_complex_double* t, lapack_int* ldt,
-                    lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b, lapack_int* ldb,
-                    lapack_complex_double* work, lapack_int* info);
-void LAPACK_dtpqrt(lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb, double* a, lapack_int* lda, double* b,
-                   lapack_int* ldb, double* t, lapack_int* ldt, double* work, lapack_int* info);
-void LAPACK_ctpqrt(lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb, lapack_complex_float* a,
-                   lapack_int* lda, lapack_complex_float* t, lapack_complex_float* b, lapack_int* ldb, lapack_int* ldt,
-                   lapack_complex_float* work, lapack_int* info);
-void LAPACK_ztpqrt(lapack_int* m, lapack_int* n, lapack_int* l, lapack_int* nb, lapack_complex_double* a,
-                   lapack_int* lda, lapack_complex_double* b, lapack_int* ldb, lapack_complex_double* t,
-                   lapack_int* ldt, lapack_complex_double* work, lapack_int* info);
-void LAPACK_stpqrt2(lapack_int* m, lapack_int* n, float* a, lapack_int* lda, float* b, lapack_int* ldb, float* t,
-                    lapack_int* ldt, lapack_int* info);
-void LAPACK_dtpqrt2(lapack_int* m, lapack_int* n, double* a, lapack_int* lda, double* b, lapack_int* ldb, double* t,
-                    lapack_int* ldt, lapack_int* info);
-void LAPACK_ctpqrt2(lapack_int* m, lapack_int* n, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b,
-                    lapack_int* ldb, lapack_complex_float* t, lapack_int* ldt, lapack_int* info);
-void LAPACK_ztpqrt2(lapack_int* m, lapack_int* n, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b,
-                    lapack_int* ldb, lapack_complex_double* t, lapack_int* ldt, lapack_int* info);
-void LAPACK_stprfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   lapack_int* l, const float* v, lapack_int* ldv, const float* t, lapack_int* ldt, float* a,
-                   lapack_int* lda, float* b, lapack_int* ldb, const float* mywork, lapack_int* myldwork);
-void LAPACK_dtprfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   lapack_int* l, const double* v, lapack_int* ldv, const double* t, lapack_int* ldt, double* a,
-                   lapack_int* lda, double* b, lapack_int* ldb, const double* mywork, lapack_int* myldwork);
-void LAPACK_ctprfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   lapack_int* l, const lapack_complex_float* v, lapack_int* ldv, const lapack_complex_float* t,
-                   lapack_int* ldt, lapack_complex_float* a, lapack_int* lda, lapack_complex_float* b, lapack_int* ldb,
-                   const float* mywork, lapack_int* myldwork);
-void LAPACK_ztprfb(char* side, char* trans, char* direct, char* storev, lapack_int* m, lapack_int* n, lapack_int* k,
-                   lapack_int* l, const lapack_complex_double* v, lapack_int* ldv, const lapack_complex_double* t,
-                   lapack_int* ldt, lapack_complex_double* a, lapack_int* lda, lapack_complex_double* b,
-                   lapack_int* ldb, const double* mywork, lapack_int* myldwork);
-// LAPACK 3.X.X
-void LAPACK_csyr(char* uplo, lapack_int* n, lapack_complex_float* alpha, const lapack_complex_float* x,
-                 lapack_int* incx, lapack_complex_float* a, lapack_int* lda);
-void LAPACK_zsyr(char* uplo, lapack_int* n, lapack_complex_double* alpha, const lapack_complex_double* x,
-                 lapack_int* incx, lapack_complex_double* a, lapack_int* lda);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* _LAPACKE_H_ */
-
-#endif /* _MKL_LAPACKE_H_ */
diff --git a/Eigen/src/misc/lapacke_helpers.h b/Eigen/src/misc/lapacke_helpers.h
deleted file mode 100644
index ff98639..0000000
--- a/Eigen/src/misc/lapacke_helpers.h
+++ /dev/null
@@ -1,163 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2021 Erik Schultheis <erik.schultheis@aalto.fi>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_LAPACKE_HELPERS_H
-#define EIGEN_LAPACKE_HELPERS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#ifdef EIGEN_USE_MKL
-#include "mkl_lapacke.h"
-#else
-#include "lapacke.h"
-#endif
-
-namespace Eigen {
-namespace internal {
-/**
- * \internal
- * \brief Implementation details and helper functions for the lapacke glue code.
- */
-namespace lapacke_helpers {
-
-// ---------------------------------------------------------------------------------------------------------------------
-//                  Translation from Eigen to Lapacke for types and constants
-// ---------------------------------------------------------------------------------------------------------------------
-
-// For complex numbers, the types in Eigen and Lapacke are different, but layout compatible.
-template <typename Scalar>
-struct translate_type_imp;
-template <>
-struct translate_type_imp<float> {
-  using type = float;
-};
-template <>
-struct translate_type_imp<double> {
-  using type = double;
-};
-template <>
-struct translate_type_imp<std::complex<double>> {
-  using type = lapack_complex_double;
-};
-template <>
-struct translate_type_imp<std::complex<float>> {
-  using type = lapack_complex_float;
-};
-
-/// Given an Eigen types, this is defined to be the corresponding, layout-compatible lapack type
-template <typename Scalar>
-using translated_type = typename translate_type_imp<Scalar>::type;
-
-/// These functions convert their arguments from Eigen to Lapack types
-/// This function performs conversion for any of the translations defined above.
-template <typename Source, typename Target = translated_type<Source>>
-EIGEN_ALWAYS_INLINE auto to_lapack(Source value) {
-  return static_cast<Target>(value);
-}
-
-/// This function performs conversions for pointer types corresponding to the translations abovce.
-/// This is valid because the translations are between layout-compatible types.
-template <typename Source, typename Target = translated_type<Source>>
-EIGEN_ALWAYS_INLINE auto to_lapack(Source *value) {
-  return reinterpret_cast<Target *>(value);
-}
-
-/// This function converts the Eigen Index to a lapack index, with possible range checks
-/// \sa internal::convert_index
-EIGEN_ALWAYS_INLINE lapack_int to_lapack(Index index) { return convert_index<lapack_int>(index); }
-
-/// translates storage order of the given Eigen object to the corresponding lapack constant
-template <typename Derived>
-EIGEN_ALWAYS_INLINE constexpr lapack_int lapack_storage_of(const EigenBase<Derived> &) {
-  return Derived::IsRowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR;
-}
-
-// ---------------------------------------------------------------------------------------------------------------------
-//              Automatic generation of low-level wrappers
-// ---------------------------------------------------------------------------------------------------------------------
-
-/*!
- * \internal
- * \brief Helper type to facilitate the wrapping of raw LAPACKE functions for different types into a single, overloaded
- * C++ function. This is achieved in combination with \r EIGEN_MAKE_LAPACKE_WRAPPER \details This implementation works
- * by providing an overloaded call function that just forwards its arguments to the underlying lapack function. Each of
- * these overloads is enabled only if the call is actually well formed. Because these lapack functions take pointers to
- * the underlying scalar type as arguments, even though the actual Scalars would be implicitly convertible, the pointers
- * are not and therefore only a single overload can be valid at the same time. Thus, despite all functions taking fully
- * generic `Args&&... args` as arguments, there is never any ambiguity.
- */
-template <typename DoubleFn, typename SingleFn, typename DoubleCpxFn, typename SingleCpxFn>
-struct WrappingHelper {
-  // The naming of double, single, double complex and single complex is purely for readability
-  // and doesn't actually affect the workings of this class. In principle, the arguments can
-  // be supplied in any permuted order.
-  DoubleFn double_;
-  SingleFn single_;
-  DoubleCpxFn double_cpx_;
-  SingleCpxFn single_cpx_;
-
-  template <typename... Args>
-  auto call(Args &&...args) -> decltype(double_(std::forward<Args>(args)...)) {
-    return double_(std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  auto call(Args &&...args) -> decltype(single_(std::forward<Args>(args)...)) {
-    return single_(std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  auto call(Args &&...args) -> decltype(double_cpx_(std::forward<Args>(args)...)) {
-    return double_cpx_(std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  auto call(Args &&...args) -> decltype(single_cpx_(std::forward<Args>(args)...)) {
-    return single_cpx_(std::forward<Args>(args)...);
-  }
-};
-
-/** \internal Helper function that generates a `WrappingHelper` object with the given function pointers and
- * invokes its `call` method, thus selecting one of the overloads.
- * \sa EIGEN_MAKE_LAPACKE_WRAPPER
- */
-template <typename DoubleFn, typename SingleFn, typename DoubleCpxFn, typename SingleCpxFn, typename... Args>
-EIGEN_ALWAYS_INLINE auto call_wrapper(DoubleFn df, SingleFn sf, DoubleCpxFn dcf, SingleCpxFn scf, Args &&...args) {
-  WrappingHelper<DoubleFn, SingleFn, DoubleCpxFn, SingleCpxFn> helper{df, sf, dcf, scf};
-  return helper.call(std::forward<Args>(args)...);
-}
-
-/**
- * \internal
- * Generates a new function `Function` that dispatches to the corresponding LAPACKE_? prefixed functions.
- * \sa WrappingHelper
- */
-#define EIGEN_MAKE_LAPACKE_WRAPPER(FUNCTION)                                                                \
-  template <typename... Args>                                                                               \
-  EIGEN_ALWAYS_INLINE auto FUNCTION(Args &&...args) {                                                       \
-    return call_wrapper(LAPACKE_d##FUNCTION, LAPACKE_s##FUNCTION, LAPACKE_z##FUNCTION, LAPACKE_c##FUNCTION, \
-                        std::forward<Args>(args)...);                                                       \
-  }
-
-// Now with this macro and the helper wrappers, we can generate the dispatch for all the lapacke functions that are
-// used in Eigen.
-// We define these here instead of in the files where they are used because this allows us to #undef the macro again
-// right here
-EIGEN_MAKE_LAPACKE_WRAPPER(potrf)
-EIGEN_MAKE_LAPACKE_WRAPPER(getrf)
-EIGEN_MAKE_LAPACKE_WRAPPER(geqrf)
-EIGEN_MAKE_LAPACKE_WRAPPER(gesdd)
-
-#undef EIGEN_MAKE_LAPACKE_WRAPPER
-}  // namespace lapacke_helpers
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_LAPACKE_HELPERS_H
diff --git a/Eigen/src/misc/lapacke_mangling.h b/Eigen/src/misc/lapacke_mangling.h
deleted file mode 100644
index d852de7..0000000
--- a/Eigen/src/misc/lapacke_mangling.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef LAPACK_HEADER_INCLUDED
-#define LAPACK_HEADER_INCLUDED
-
-#ifndef LAPACK_GLOBAL
-#if defined(LAPACK_GLOBAL_PATTERN_LC) || defined(ADD_)
-#define LAPACK_GLOBAL(lcname, UCNAME) lcname##_
-#elif defined(LAPACK_GLOBAL_PATTERN_UC) || defined(UPPER)
-#define LAPACK_GLOBAL(lcname, UCNAME) UCNAME
-#elif defined(LAPACK_GLOBAL_PATTERN_MC) || defined(NOCHANGE)
-#define LAPACK_GLOBAL(lcname, UCNAME) lcname
-#else
-#define LAPACK_GLOBAL(lcname, UCNAME) lcname##_
-#endif
-#endif
-
-#endif
diff --git a/Eigen/src/plugins/ArrayCwiseBinaryOps.inc b/Eigen/src/plugins/ArrayCwiseBinaryOps.inc
index ae240f1..fee9ed7 100644
--- a/Eigen/src/plugins/ArrayCwiseBinaryOps.inc
+++ b/Eigen/src/plugins/ArrayCwiseBinaryOps.inc
@@ -1,12 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 /** \returns an expression of the coefficient wise product of \c *this and \a other
  *
  * \sa MatrixBase::cwiseProduct
  */
 template <typename OtherDerived>
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, product)
+EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived,
+                                                                                     internal::scalar_product_op)
 operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const {
-  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, product)(derived(), other.derived());
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, internal::scalar_product_op)(derived(), other.derived());
 }
 
 /** \returns an expression of the coefficient wise quotient of \c *this and \a other
@@ -99,7 +102,7 @@
  *
  * \sa absolute_difference()
  */
-EIGEN_MAKE_CWISE_BINARY_OP(absolute_difference, absolute_difference)
+EIGEN_MAKE_CWISE_BINARY_OP(absolute_difference, internal::scalar_absolute_difference_op)
 
 /** \returns an expression of the coefficient-wise absolute_difference of \c *this and scalar \a other
  *
@@ -124,14 +127,14 @@
  * Example: \include Cwise_array_power_array.cpp
  * Output: \verbinclude Cwise_array_power_array.out
  */
-EIGEN_MAKE_CWISE_BINARY_OP(pow, pow)
+EIGEN_MAKE_CWISE_BINARY_OP(pow, internal::scalar_pow_op)
 
 /** \returns an expression of the coefficient-wise atan2(\c *this, \a y), where \a y is the given array argument.
  *
  * This function computes the coefficient-wise atan2.
  *
  */
-EIGEN_MAKE_CWISE_BINARY_OP(atan2, atan2)
+EIGEN_MAKE_CWISE_BINARY_OP(atan2, internal::scalar_atan2_op)
 
 // TODO: code generating macros could be moved to Macros.h and could include generation of documentation
 #define EIGEN_MAKE_CWISE_COMP_OP(OP, COMPARATOR)                                                                     \
@@ -242,7 +245,7 @@
 
 // scalar addition
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-EIGEN_MAKE_SCALAR_BINARY_OP(operator+, sum)
+EIGEN_MAKE_SCALAR_BINARY_OP(operator+, internal::scalar_sum_op)
 #else
 /** \returns an expression of \c *this with each coeff incremented by the constant \a scalar
  *
@@ -265,7 +268,7 @@
 #endif
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-EIGEN_MAKE_SCALAR_BINARY_OP(operator-, difference)
+EIGEN_MAKE_SCALAR_BINARY_OP(operator-, internal::scalar_difference_op)
 #else
 /** \returns an expression of \c *this with each coeff decremented by the constant \a scalar
  *
@@ -288,12 +291,12 @@
 #endif
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator/, quotient)
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator/, internal::scalar_quotient_op)
 #else
 /**
  * \brief Component-wise division of the scalar \a s by array elements of \a a.
  *
- * \tparam Scalar is the scalar type of \a x. It must be compatible with the scalar type of the given array expression
+ * \tparam T is the scalar type of \a s. It must be compatible with the scalar type of the given array expression
  * (\c Derived::Scalar).
  */
 template <typename T>
diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.inc b/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
index c06dc41..4bfbd46 100644
--- a/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
+++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
@@ -1,46 +1,8 @@
-typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
-typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;
-typedef CwiseUnaryOp<internal::scalar_carg_op<Scalar>, const Derived> CArgReturnType;
-typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;
-typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;
-typedef CwiseUnaryOp<internal::scalar_cbrt_op<Scalar>, const Derived> CbrtReturnType;
-typedef CwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived> RsqrtReturnType;
-typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> SignReturnType;
-typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> InverseReturnType;
-typedef CwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived> BooleanNotReturnType;
-typedef CwiseUnaryOp<internal::scalar_bitwise_not_op<Scalar>, const Derived> BitwiseNotReturnType;
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
-typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType;
-typedef CwiseUnaryOp<internal::scalar_exp2_op<Scalar>, const Derived> Exp2ReturnType;
-typedef CwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived> Expm1ReturnType;
-typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType;
-typedef CwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived> Log1pReturnType;
-typedef CwiseUnaryOp<internal::scalar_log10_op<Scalar>, const Derived> Log10ReturnType;
-typedef CwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived> Log2ReturnType;
-typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType;
-typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType;
-typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType;
-typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType;
-typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType;
-typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType;
-typedef CwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived> TanhReturnType;
-typedef CwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived> LogisticReturnType;
-typedef CwiseUnaryOp<internal::scalar_sinh_op<Scalar>, const Derived> SinhReturnType;
-typedef CwiseUnaryOp<internal::scalar_atanh_op<Scalar>, const Derived> AtanhReturnType;
-typedef CwiseUnaryOp<internal::scalar_asinh_op<Scalar>, const Derived> AsinhReturnType;
-typedef CwiseUnaryOp<internal::scalar_acosh_op<Scalar>, const Derived> AcoshReturnType;
-typedef CwiseUnaryOp<internal::scalar_cosh_op<Scalar>, const Derived> CoshReturnType;
-typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType;
-typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> CubeReturnType;
-typedef CwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived> RoundReturnType;
-typedef CwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived> RintReturnType;
-typedef CwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived> FloorReturnType;
-typedef CwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived> CeilReturnType;
-typedef CwiseUnaryOp<internal::scalar_trunc_op<Scalar>, const Derived> TruncReturnType;
-typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
-typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
-typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
-typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar, true>, const Derived> IsFiniteTypedReturnType;
+using LdexpReturnType = CwiseUnaryOp<internal::scalar_ldexp_op<Scalar>, const Derived>;
+using IsFiniteTypedReturnType = CwiseUnaryOp<internal::scalar_isfinite_op<Scalar, true>, const Derived>;
 
 /** \returns an expression of the coefficient-wise absolute value of \c *this
  *
@@ -49,7 +11,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs">Math functions</a>, abs2()
  */
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const AbsReturnType abs() const { return AbsReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(abs, internal::scalar_abs_op, AbsReturnType)
 
 /** \returns an expression of the coefficient-wise phase angle of \c *this
  *
@@ -58,9 +20,9 @@
  *
  * \sa abs()
  */
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const ArgReturnType arg() const { return ArgReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(arg, internal::scalar_arg_op, ArgReturnType)
 
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CArgReturnType carg() const { return CArgReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(carg, internal::scalar_carg_op, CArgReturnType)
 
 /** \returns an expression of the coefficient-wise squared absolute value of \c *this
  *
@@ -69,12 +31,12 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_abs2">Math functions</a>, abs(), square()
  */
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const Abs2ReturnType abs2() const { return Abs2ReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(abs2, internal::scalar_abs2_op, Abs2ReturnType)
 
 /** \returns an expression of the coefficient-wise exponential of *this.
  *
  * This function computes the coefficient-wise exponential. The function MatrixBase::exp() in the
- * unsupported module MatrixFunctions computes the matrix exponential.
+ * contrib module MatrixFunctions computes the matrix exponential.
  *
  * Example: \include Cwise_exp.cpp
  * Output: \verbinclude Cwise_exp.out
@@ -82,7 +44,7 @@
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, exp2(), pow(), log(), sin(),
  * cos()
  */
-EIGEN_DEVICE_FUNC constexpr inline const ExpReturnType exp() const { return ExpReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(exp, internal::scalar_exp_op, ExpReturnType)
 
 /** \returns an expression of the coefficient-wise exponential of *this.
  *
@@ -91,7 +53,23 @@
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_exp">Math functions</a>, exp(), pow(), log(), sin(),
  * cos()
  */
-EIGEN_DEVICE_FUNC constexpr inline const Exp2ReturnType exp2() const { return Exp2ReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(exp2, internal::scalar_exp2_op, Exp2ReturnType)
+
+/** \returns an expression of the coefficients of \c *this multiplied by \f$ 2^{exponent} \f$.
+ *
+ * The scaling is exact: it directly adjusts the floating-point exponent, so it produces
+ * correct results (including denormals) even when \f$ 2^{exponent} \f$ itself is not
+ * representable as a \c Scalar. The result saturates to zero or infinity when the scaled
+ * value falls outside the finite range of \c Scalar.
+ *
+ * Example: \include Cwise_ldexp.cpp
+ * Output: \verbinclude Cwise_ldexp.out
+ *
+ * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ldexp">Math functions</a>, exp2(), pow()
+ */
+EIGEN_DEVICE_FUNC constexpr inline const LdexpReturnType ldexp(int exponent) const {
+  return LdexpReturnType(derived(), internal::scalar_ldexp_op<Scalar>(exponent));
+}
 
 /** \returns an expression of the coefficient-wise exponential of *this minus 1.
  *
@@ -100,28 +78,28 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_expm1">Math functions</a>, exp()
  */
-EIGEN_DEVICE_FUNC constexpr inline const Expm1ReturnType expm1() const { return Expm1ReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(expm1, internal::scalar_expm1_op, Expm1ReturnType)
 
 /** \returns an expression of the coefficient-wise logarithm of *this.
  *
  * This function computes the coefficient-wise logarithm. The function MatrixBase::log() in the
- * unsupported module MatrixFunctions computes the matrix logarithm.
+ * contrib module MatrixFunctions computes the matrix logarithm.
  *
  * Example: \include Cwise_log.cpp
  * Output: \verbinclude Cwise_log.out
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log">Math functions</a>, log()
  */
-EIGEN_DEVICE_FUNC constexpr inline const LogReturnType log() const { return LogReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(log, internal::scalar_log_op, LogReturnType)
 
 /** \returns an expression of the coefficient-wise logarithm of 1 plus \c *this.
  *
- * In exact arithmetic, \c x.log() is equivalent to \c (x+1).log(),
+ * In exact arithmetic, \c x.log1p() is equivalent to \c (x+1).log(),
  * however, with finite precision, this function is much more accurate when \c x is close to zero.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log1p">Math functions</a>, log()
  */
-EIGEN_DEVICE_FUNC constexpr inline const Log1pReturnType log1p() const { return Log1pReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(log1p, internal::scalar_log1p_op, Log1pReturnType)
 
 /** \returns an expression of the coefficient-wise base-10 logarithm of *this.
  *
@@ -132,26 +110,26 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_log10">Math functions</a>, log()
  */
-EIGEN_DEVICE_FUNC constexpr inline const Log10ReturnType log10() const { return Log10ReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(log10, internal::scalar_log10_op, Log10ReturnType)
 
 /** \returns an expression of the coefficient-wise base-2 logarithm of *this.
  *
  * This function computes the coefficient-wise base-2 logarithm.
  *
  */
-EIGEN_DEVICE_FUNC constexpr inline const Log2ReturnType log2() const { return Log2ReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(log2, internal::scalar_log2_op, Log2ReturnType)
 
 /** \returns an expression of the coefficient-wise square root of *this.
  *
  * This function computes the coefficient-wise square root. The function MatrixBase::sqrt() in the
- * unsupported module MatrixFunctions computes the matrix square root.
+ * contrib module MatrixFunctions computes the matrix square root.
  *
  * Example: \include Cwise_sqrt.cpp
  * Output: \verbinclude Cwise_sqrt.out
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sqrt">Math functions</a>, pow(), square(), cbrt()
  */
-EIGEN_DEVICE_FUNC constexpr inline const SqrtReturnType sqrt() const { return SqrtReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(sqrt, internal::scalar_sqrt_op, SqrtReturnType)
 
 /** \returns an expression of the coefficient-wise cube root of *this.
  *
@@ -162,7 +140,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cbrt">Math functions</a>, sqrt(), pow(), square()
  */
-EIGEN_DEVICE_FUNC constexpr inline const CbrtReturnType cbrt() const { return CbrtReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(cbrt, internal::scalar_cbrt_op, CbrtReturnType)
 
 /** \returns an expression of the coefficient-wise inverse square root of *this.
  *
@@ -173,7 +151,7 @@
  *
  * \sa pow(), square()
  */
-EIGEN_DEVICE_FUNC constexpr inline const RsqrtReturnType rsqrt() const { return RsqrtReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(rsqrt, internal::scalar_rsqrt_op, RsqrtReturnType)
 
 /** \returns an expression of the coefficient-wise signum of *this.
  *
@@ -184,31 +162,31 @@
  *
  * \sa pow(), square()
  */
-EIGEN_DEVICE_FUNC constexpr inline const SignReturnType sign() const { return SignReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(sign, internal::scalar_sign_op, SignReturnType)
 
 /** \returns an expression of the coefficient-wise cosine of *this.
  *
  * This function computes the coefficient-wise cosine. The function MatrixBase::cos() in the
- * unsupported module MatrixFunctions computes the matrix cosine.
+ * contrib module MatrixFunctions computes the matrix cosine.
  *
  * Example: \include Cwise_cos.cpp
  * Output: \verbinclude Cwise_cos.out
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cos">Math functions</a>, sin(), acos()
  */
-EIGEN_DEVICE_FUNC constexpr inline const CosReturnType cos() const { return CosReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(cos, internal::scalar_cos_op, CosReturnType)
 
 /** \returns an expression of the coefficient-wise sine of *this.
  *
  * This function computes the coefficient-wise sine. The function MatrixBase::sin() in the
- * unsupported module MatrixFunctions computes the matrix sine.
+ * contrib module MatrixFunctions computes the matrix sine.
  *
  * Example: \include Cwise_sin.cpp
  * Output: \verbinclude Cwise_sin.out
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sin">Math functions</a>, cos(), asin()
  */
-EIGEN_DEVICE_FUNC constexpr inline const SinReturnType sin() const { return SinReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(sin, internal::scalar_sin_op, SinReturnType)
 
 /** \returns an expression of the coefficient-wise tan of *this.
  *
@@ -217,7 +195,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tan">Math functions</a>, cos(), sin()
  */
-EIGEN_DEVICE_FUNC constexpr inline const TanReturnType tan() const { return TanReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(tan, internal::scalar_tan_op, TanReturnType)
 
 /** \returns an expression of the coefficient-wise arc tan of *this.
  *
@@ -226,7 +204,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atan">Math functions</a>, tan(), asin(), acos()
  */
-EIGEN_DEVICE_FUNC constexpr inline const AtanReturnType atan() const { return AtanReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(atan, internal::scalar_atan_op, AtanReturnType)
 
 /** \returns an expression of the coefficient-wise arc cosine of *this.
  *
@@ -235,7 +213,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acos">Math functions</a>, cos(), asin()
  */
-EIGEN_DEVICE_FUNC constexpr inline const AcosReturnType acos() const { return AcosReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(acos, internal::scalar_acos_op, AcosReturnType)
 
 /** \returns an expression of the coefficient-wise arc sine of *this.
  *
@@ -244,7 +222,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asin">Math functions</a>, sin(), acos()
  */
-EIGEN_DEVICE_FUNC constexpr inline const AsinReturnType asin() const { return AsinReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(asin, internal::scalar_asin_op, AsinReturnType)
 
 /** \returns an expression of the coefficient-wise hyperbolic tan of *this.
  *
@@ -253,7 +231,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_tanh">Math functions</a>, tan(), sinh(), cosh()
  */
-EIGEN_DEVICE_FUNC constexpr inline const TanhReturnType tanh() const { return TanhReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(tanh, internal::scalar_tanh_op, TanhReturnType)
 
 /** \returns an expression of the coefficient-wise hyperbolic sin of *this.
  *
@@ -262,7 +240,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_sinh">Math functions</a>, sin(), tanh(), cosh()
  */
-EIGEN_DEVICE_FUNC constexpr inline const SinhReturnType sinh() const { return SinhReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(sinh, internal::scalar_sinh_op, SinhReturnType)
 
 /** \returns an expression of the coefficient-wise hyperbolic cos of *this.
  *
@@ -271,29 +249,29 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cosh">Math functions</a>, tanh(), sinh(), cosh()
  */
-EIGEN_DEVICE_FUNC constexpr inline const CoshReturnType cosh() const { return CoshReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(cosh, internal::scalar_cosh_op, CoshReturnType)
 
 /** \returns an expression of the coefficient-wise inverse hyperbolic tan of *this.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_atanh">Math functions</a>, atanh(), asinh(), acosh()
  */
-EIGEN_DEVICE_FUNC constexpr inline const AtanhReturnType atanh() const { return AtanhReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(atanh, internal::scalar_atanh_op, AtanhReturnType)
 
 /** \returns an expression of the coefficient-wise inverse hyperbolic sin of *this.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_asinh">Math functions</a>, atanh(), asinh(), acosh()
  */
-EIGEN_DEVICE_FUNC constexpr inline const AsinhReturnType asinh() const { return AsinhReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(asinh, internal::scalar_asinh_op, AsinhReturnType)
 
 /** \returns an expression of the coefficient-wise inverse hyperbolic cos of *this.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_acosh">Math functions</a>, atanh(), asinh(), acosh()
  */
-EIGEN_DEVICE_FUNC constexpr inline const AcoshReturnType acosh() const { return AcoshReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(acosh, internal::scalar_acosh_op, AcoshReturnType)
 
 /** \returns an expression of the coefficient-wise logistic of *this.
  */
-EIGEN_DEVICE_FUNC constexpr inline const LogisticReturnType logistic() const { return LogisticReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(logistic, internal::scalar_logistic_op, LogisticReturnType)
 
 /** \returns an expression of the coefficient-wise inverse of *this.
  *
@@ -302,7 +280,7 @@
  *
  * \sa operator/(), operator*()
  */
-EIGEN_DEVICE_FUNC constexpr inline const InverseReturnType inverse() const { return InverseReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(inverse, internal::scalar_inverse_op, InverseReturnType)
 
 /** \returns an expression of the coefficient-wise square of *this.
  *
@@ -311,7 +289,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_squareE">Math functions</a>, abs2(), cube(), pow()
  */
-EIGEN_DEVICE_FUNC constexpr inline const SquareReturnType square() const { return SquareReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(square, internal::scalar_square_op, SquareReturnType)
 
 /** \returns an expression of the coefficient-wise cube of *this.
  *
@@ -320,7 +298,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_cube">Math functions</a>, square(), pow()
  */
-EIGEN_DEVICE_FUNC constexpr inline const CubeReturnType cube() const { return CubeReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(cube, internal::scalar_cube_op, CubeReturnType)
 
 /** \returns an expression of the coefficient-wise rint of *this.
  *
@@ -329,7 +307,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_rint">Math functions</a>, ceil(), floor()
  */
-EIGEN_DEVICE_FUNC constexpr inline const RintReturnType rint() const { return RintReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(rint, internal::scalar_rint_op, RintReturnType)
 
 /** \returns an expression of the coefficient-wise round of *this.
  *
@@ -338,7 +316,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_round">Math functions</a>, ceil(), floor()
  */
-EIGEN_DEVICE_FUNC constexpr inline const RoundReturnType round() const { return RoundReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(round, internal::scalar_round_op, RoundReturnType)
 
 /** \returns an expression of the coefficient-wise floor of *this.
  *
@@ -347,7 +325,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_floor">Math functions</a>, ceil(), round()
  */
-EIGEN_DEVICE_FUNC constexpr inline const FloorReturnType floor() const { return FloorReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(floor, internal::scalar_floor_op, FloorReturnType)
 
 /** \returns an expression of the coefficient-wise ceil of *this.
  *
@@ -356,7 +334,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ceil">Math functions</a>, floor(), round()
  */
-EIGEN_DEVICE_FUNC constexpr inline const CeilReturnType ceil() const { return CeilReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(ceil, internal::scalar_ceil_op, CeilReturnType)
 
 /** \returns an expression of the coefficient-wise truncation of *this.
  *
@@ -365,40 +343,100 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_trunc">Math functions</a>, floor(), round()
  */
-EIGEN_DEVICE_FUNC constexpr inline const TruncReturnType trunc() const { return TruncReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(trunc, internal::scalar_trunc_op, TruncReturnType)
 
 template <int N>
-struct ShiftRightXpr {
-  typedef CwiseUnaryOp<internal::scalar_shift_right_op<Scalar, N>, const Derived> Type;
+struct ArithmeticShiftRightXpr {
+  using Type = CwiseUnaryOp<internal::scalar_arithmetic_shift_right_op<Scalar, N>, const Derived>;
 };
 
 /** \returns an expression of \c *this with the \a Scalar type arithmetically
  * shifted right by \a N bit positions.
  *
  * The template parameter \a N specifies the number of bit positions to shift.
+ * The vacated high bits are filled with the sign bit for a signed \a Scalar and
+ * with zero for an unsigned one, which has no sign bit to propagate. Use
+ * logicalShiftRight() to fill with zero regardless of signedness.
  *
- * \sa shiftLeft()
+ * \sa logicalShiftRight(), logicalShiftLeft()
  */
 template <int N>
-EIGEN_DEVICE_FUNC constexpr typename ShiftRightXpr<N>::Type shiftRight() const {
-  return typename ShiftRightXpr<N>::Type(derived());
+EIGEN_DEVICE_FUNC constexpr typename ArithmeticShiftRightXpr<N>::Type arithmeticShiftRight() const {
+  return typename ArithmeticShiftRightXpr<N>::Type(derived());
 }
 
 template <int N>
-struct ShiftLeftXpr {
-  typedef CwiseUnaryOp<internal::scalar_shift_left_op<Scalar, N>, const Derived> Type;
+struct LogicalShiftRightXpr {
+  using Type = CwiseUnaryOp<internal::scalar_logical_shift_right_op<Scalar, N>, const Derived>;
+};
+
+/** \returns an expression of \c *this with the \a Scalar type logically
+ * shifted right by \a N bit positions.
+ *
+ * The template parameter \a N specifies the number of bit positions to shift.
+ * The vacated high bits are filled with zero even when \a Scalar is signed; use
+ * arithmeticShiftRight() to propagate the sign bit instead.
+ *
+ * \sa arithmeticShiftRight(), logicalShiftLeft()
+ */
+template <int N>
+EIGEN_DEVICE_FUNC constexpr typename LogicalShiftRightXpr<N>::Type logicalShiftRight() const {
+  return typename LogicalShiftRightXpr<N>::Type(derived());
+}
+
+template <int N>
+struct LogicalShiftLeftXpr {
+  using Type = CwiseUnaryOp<internal::scalar_logical_shift_left_op<Scalar, N>, const Derived>;
 };
 
 /** \returns an expression of \c *this with the \a Scalar type logically
  * shifted left by \a N bit positions.
  *
  * The template parameter \a N specifies the number of bit positions to shift.
+ * The vacated low bits are filled with zero. There is no separate arithmetic
+ * left shift: for every integral \a Scalar it produces the same bit pattern.
  *
- * \sa shiftRight()
+ * \sa arithmeticShiftRight(), logicalShiftRight()
  */
 template <int N>
+EIGEN_DEVICE_FUNC constexpr typename LogicalShiftLeftXpr<N>::Type logicalShiftLeft() const {
+  return typename LogicalShiftLeftXpr<N>::Type(derived());
+}
+
+template <int N>
+struct ShiftRightXpr {
+  using Type = typename ArithmeticShiftRightXpr<N>::Type;
+};
+
+/** \deprecated Use arithmeticShiftRight() instead.
+ *
+ * \returns an expression of \c *this with the \a Scalar type arithmetically
+ * shifted right by \a N bit positions.
+ *
+ * \sa arithmeticShiftRight()
+ */
+template <int N>
+EIGEN_DEPRECATED_WITH_REASON("Use arithmeticShiftRight() instead.")
+EIGEN_DEVICE_FUNC constexpr typename ShiftRightXpr<N>::Type shiftRight() const {
+  return arithmeticShiftRight<N>();
+}
+
+template <int N>
+struct ShiftLeftXpr {
+  using Type = typename LogicalShiftLeftXpr<N>::Type;
+};
+
+/** \deprecated Use logicalShiftLeft() instead.
+ *
+ * \returns an expression of \c *this with the \a Scalar type logically
+ * shifted left by \a N bit positions.
+ *
+ * \sa logicalShiftLeft()
+ */
+template <int N>
+EIGEN_DEPRECATED_WITH_REASON("Use logicalShiftLeft() instead.")
 EIGEN_DEVICE_FUNC constexpr typename ShiftLeftXpr<N>::Type shiftLeft() const {
-  return typename ShiftLeftXpr<N>::Type(derived());
+  return logicalShiftLeft<N>();
 }
 
 /** \returns an expression of the coefficient-wise isnan of *this.
@@ -408,7 +446,7 @@
  *
  * \sa isfinite(), isinf()
  */
-EIGEN_DEVICE_FUNC constexpr inline const IsNaNReturnType isNaN() const { return IsNaNReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(isNaN, internal::scalar_isnan_op, IsNaNReturnType)
 
 /** \returns an expression of the coefficient-wise isinf of *this.
  *
@@ -417,7 +455,7 @@
  *
  * \sa isnan(), isfinite()
  */
-EIGEN_DEVICE_FUNC constexpr inline const IsInfReturnType isInf() const { return IsInfReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(isInf, internal::scalar_isinf_op, IsInfReturnType)
 
 /** \returns an expression of the coefficient-wise isfinite of *this.
  *
@@ -426,7 +464,7 @@
  *
  * \sa isnan(), isinf()
  */
-EIGEN_DEVICE_FUNC constexpr inline const IsFiniteReturnType isFinite() const { return IsFiniteReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(isFinite, internal::scalar_isfinite_op, IsFiniteReturnType)
 EIGEN_DEVICE_FUNC constexpr inline const IsFiniteTypedReturnType isFiniteTyped() const {
   return IsFiniteTypedReturnType(derived());
 }
@@ -438,35 +476,24 @@
  *
  * \sa operator!=()
  */
-EIGEN_DEVICE_FUNC constexpr inline const BooleanNotReturnType operator!() const {
-  return BooleanNotReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(operator!, internal::scalar_boolean_not_op, BooleanNotReturnType)
 
 /** \returns an expression of the bitwise ~ operator of *this
  */
-EIGEN_DEVICE_FUNC constexpr inline const BitwiseNotReturnType operator~() const {
-  return BitwiseNotReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(operator~, internal::scalar_bitwise_not_op, BitwiseNotReturnType)
 
 // --- SpecialFunctions module ---
 
-typedef CwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived> LgammaReturnType;
-typedef CwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived> DigammaReturnType;
-typedef CwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived> ErfReturnType;
-typedef CwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived> ErfcReturnType;
-typedef CwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived> NdtriReturnType;
-
-/** \cpp11 \returns an expression of the coefficient-wise ln(|gamma(*this)|).
+/** \returns an expression of the coefficient-wise ln(|gamma(*this)|).
  *
  * \specialfunctions_module
  *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of lgamma(T) for any scalar
- * type T to be supported.
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of lgamma(T) for any scalar type T to be supported.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_lgamma">Math functions</a>, digamma()
  */
-EIGEN_DEVICE_FUNC constexpr inline const LgammaReturnType lgamma() const { return LgammaReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(lgamma, internal::scalar_lgamma_op, LgammaReturnType)
 
 /** \returns an expression of the coefficient-wise digamma (psi, derivative of lgamma).
  *
@@ -479,35 +506,33 @@
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_digamma">Math functions</a>, Eigen::digamma(),
  * Eigen::polygamma(), lgamma()
  */
-EIGEN_DEVICE_FUNC constexpr inline const DigammaReturnType digamma() const { return DigammaReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(digamma, internal::scalar_digamma_op, DigammaReturnType)
 
-/** \cpp11 \returns an expression of the coefficient-wise Gauss error
+/** \returns an expression of the coefficient-wise Gauss error
  * function of *this.
  *
  * \specialfunctions_module
  *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of erf(T) for any scalar
- * type T to be supported.
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of erf(T) for any scalar type T to be supported.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erf">Math functions</a>, erfc()
  */
-EIGEN_DEVICE_FUNC constexpr inline const ErfReturnType erf() const { return ErfReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(erf, internal::scalar_erf_op, ErfReturnType)
 
-/** \cpp11 \returns an expression of the coefficient-wise Complementary error
+/** \returns an expression of the coefficient-wise Complementary error
  * function of *this.
  *
  * \specialfunctions_module
  *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of erfc(T) for any scalar
- * type T to be supported.
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of erfc(T) for any scalar type T to be supported.
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_erfc">Math functions</a>, erf()
  */
-EIGEN_DEVICE_FUNC constexpr inline const ErfcReturnType erfc() const { return ErfcReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(erfc, internal::scalar_erfc_op, ErfcReturnType)
 
-/** \returns an expression of the coefficient-wise inverse of the CDF of the Normal distribution function
+/** \returns an expression of the coefficient-wise inverse of the CDF of the Normal distribution
  * function of *this.
  *
  * \specialfunctions_module
@@ -520,7 +545,7 @@
  *
  * \sa <a href="group__CoeffwiseMathFunctions.html#cwisetable_ndtri">Math functions</a>
  */
-EIGEN_DEVICE_FUNC constexpr inline const NdtriReturnType ndtri() const { return NdtriReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(ndtri, internal::scalar_ndtri_op, NdtriReturnType)
 
 template <typename ScalarExponent>
 using UnaryPowReturnType =
@@ -534,7 +559,7 @@
  * \param exponent the scalar exponent value.
  *
  * This function computes the coefficient-wise power. The function MatrixBase::pow() in the
- * unsupported module MatrixFunctions computes the matrix power.
+ * contrib module MatrixFunctions computes the matrix power.
  *
  * Example: \include Cwise_pow.cpp
  * Output: \verbinclude Cwise_pow.out
diff --git a/Eigen/src/plugins/BlockMethods.inc b/Eigen/src/plugins/BlockMethods.inc
index 57e347e..e9fdc6b 100644
--- a/Eigen/src/plugins/BlockMethods.inc
+++ b/Eigen/src/plugins/BlockMethods.inc
@@ -7,71 +7,72 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 
-/// \internal expression type of a column */
-typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;
-typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;
-/// \internal expression type of a row */
-typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;
-typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
-/// \internal expression type of a block of whole columns */
-typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
-typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor>
-    ConstColsBlockXpr;
-/// \internal expression type of a block of whole rows */
-typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
-typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
-/// \internal expression type of a block of whole columns */
+/// \internal expression type of a column
+using ColXpr = Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor>;
+using ConstColXpr = const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor>;
+/// \internal expression type of a row
+using RowXpr = Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor>;
+using ConstRowXpr = const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor>;
+/// \internal expression type of a block of whole columns
+using ColsBlockXpr = Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor>;
+using ConstColsBlockXpr =
+    const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor>;
+/// \internal expression type of a block of whole rows
+using RowsBlockXpr = Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor>;
+using ConstRowsBlockXpr = const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor>;
+/// \internal expression type of a block of whole columns
 template <int N>
 struct NColsBlockXpr {
-  typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type;
+  using Type = Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor>;
 };
 template <int N>
 struct ConstNColsBlockXpr {
-  typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type;
+  using Type = const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor>;
 };
-/// \internal expression type of a block of whole rows */
+/// \internal expression type of a block of whole rows
 template <int N>
 struct NRowsBlockXpr {
-  typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type;
+  using Type = Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor>;
 };
 template <int N>
 struct ConstNRowsBlockXpr {
-  typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type;
+  using Type = const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor>;
 };
-/// \internal expression of a block */
-typedef Block<Derived> BlockXpr;
-typedef const Block<const Derived> ConstBlockXpr;
-/// \internal expression of a block of fixed sizes */
+/// \internal expression of a block
+using BlockXpr = Block<Derived>;
+using ConstBlockXpr = const Block<const Derived>;
+/// \internal expression of a block of fixed sizes
 template <int Rows, int Cols>
 struct FixedBlockXpr {
-  typedef Block<Derived, Rows, Cols> Type;
+  using Type = Block<Derived, Rows, Cols>;
 };
 template <int Rows, int Cols>
 struct ConstFixedBlockXpr {
-  typedef Block<const Derived, Rows, Cols> Type;
+  using Type = Block<const Derived, Rows, Cols>;
 };
 
-typedef VectorBlock<Derived> SegmentReturnType;
-typedef const VectorBlock<const Derived> ConstSegmentReturnType;
+using SegmentReturnType = VectorBlock<Derived>;
+using ConstSegmentReturnType = const VectorBlock<const Derived>;
 template <int Size>
 struct FixedSegmentReturnType {
-  typedef VectorBlock<Derived, Size> Type;
+  using Type = VectorBlock<Derived, Size>;
 };
 template <int Size>
 struct ConstFixedSegmentReturnType {
-  typedef const VectorBlock<const Derived, Size> Type;
+  using Type = const VectorBlock<const Derived, Size>;
 };
 
 /// \internal inner-vector
-typedef Block<Derived, IsRowMajor ? 1 : Dynamic, IsRowMajor ? Dynamic : 1, true> InnerVectorReturnType;
-typedef Block<const Derived, IsRowMajor ? 1 : Dynamic, IsRowMajor ? Dynamic : 1, true> ConstInnerVectorReturnType;
+using InnerVectorReturnType = std::conditional_t<IsRowMajor, RowXpr, ColXpr>;
+using ConstInnerVectorReturnType = std::conditional_t<IsRowMajor, ConstRowXpr, ConstColXpr>;
 
 /// \internal set of inner-vectors
-typedef Block<Derived, Dynamic, Dynamic, true> InnerVectorsReturnType;
-typedef Block<const Derived, Dynamic, Dynamic, true> ConstInnerVectorsReturnType;
+using InnerVectorsReturnType = std::conditional_t<IsRowMajor, RowsBlockXpr, ColsBlockXpr>;
+using ConstInnerVectorsReturnType = std::conditional_t<IsRowMajor, ConstRowsBlockXpr, ConstColsBlockXpr>;
 
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
@@ -144,7 +145,7 @@
                                                                                             blockCols));
 }
 
-/// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.
+/// \returns an expression of a top-right corner of \c *this with either dynamic or fixed sizes.
 ///
 /// \param cRows the number of rows in the corner
 /// \param cCols the number of columns in the corner
@@ -1015,7 +1016,7 @@
   return typename FixedBlockXpr<NRows, NCols>::Type(derived(), startRow, startCol);
 }
 
-/// This is the const version of block<>(Index, Index). */
+/// This is the const version of block<>(Index, Index).
 template <int NRows, int NCols>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<NRows, NCols>::Type block(
     Index startRow, Index startCol) const {
@@ -1091,7 +1092,7 @@
  * \sa col(), class Block */
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE RowXpr row(Index i) { return RowXpr(derived(), i); }
 
-/// This is the const version of row(). */
+/// This is the const version of row().
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE ConstRowXpr row(Index i) const { return ConstRowXpr(derived(), i); }
 
 /// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.
@@ -1189,7 +1190,7 @@
       derived(), 0, internal::get_runtime_value(n));
 }
 
-/// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.
+/// \returns an expression of the last coefficients of \c *this with either dynamic or fixed sizes.
 ///
 /// \only_for_vectors
 ///
@@ -1222,7 +1223,7 @@
       derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
 }
 
-/// This is the const version of tail(Index).
+/// This is the const version of tail(NType).
 template <typename NType>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
@@ -1316,7 +1317,7 @@
   return typename FixedSegmentReturnType<N>::Type(derived(), size() - n, n);
 }
 
-/// This is the const version of tail<int>.
+/// This is the const version of tail<int>().
 template <int N>
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@@ -1337,22 +1338,21 @@
   return ConstInnerVectorReturnType(derived(), outer);
 }
 
-/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
-/// is col-major (resp. row-major).
+/// \returns the \a outerSize consecutive columns (resp. rows) of the matrix \c *this starting at \a outerStart
+/// if \c *this is col-major (resp. row-major).
 ///
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE InnerVectorsReturnType innerVectors(Index outerStart, Index outerSize) {
-  return Block<Derived, Dynamic, Dynamic, true>(derived(), IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
-                                                IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
+  return InnerVectorsReturnType(derived(), IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
 }
 
-/// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
-/// is col-major (resp. row-major). Read-only.
+/// \returns the \a outerSize consecutive columns (resp. rows) of the matrix \c *this starting at \a outerStart
+/// if \c *this is col-major (resp. row-major). Read-only.
 ///
 EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const ConstInnerVectorsReturnType innerVectors(Index outerStart,
                                                                                                Index outerSize) const {
-  return Block<const Derived, Dynamic, Dynamic, true>(derived(), IsRowMajor ? outerStart : 0,
-                                                      IsRowMajor ? 0 : outerStart, IsRowMajor ? outerSize : rows(),
-                                                      IsRowMajor ? cols() : outerSize);
+  return ConstInnerVectorsReturnType(derived(), IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                     IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
 }
 
 /** \returns the i-th subvector (column or vector) according to the \c Direction
diff --git a/Eigen/src/plugins/CommonCwiseBinaryOps.inc b/Eigen/src/plugins/CommonCwiseBinaryOps.inc
index d5127e3..0c26e87 100644
--- a/Eigen/src/plugins/CommonCwiseBinaryOps.inc
+++ b/Eigen/src/plugins/CommonCwiseBinaryOps.inc
@@ -7,16 +7,19 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This file is a base class plugin containing common coefficient wise functions.
 
 /** \returns an expression of the difference of \c *this and \a other
  *
+ * \note Subtraction is not supported for \c bool coefficients. Cast to a signed integer type first.
+ *
  * \note If you want to subtract a given scalar from all coefficients, see Cwise::operator-().
  *
  * \sa class CwiseBinaryOp, operator-=()
  */
-EIGEN_MAKE_CWISE_BINARY_OP(operator-, difference)
+EIGEN_MAKE_CWISE_BINARY_OP(operator-, internal::scalar_difference_op)
 
 /** \returns an expression of the sum of \c *this and \a other
  *
@@ -24,7 +27,7 @@
  *
  * \sa class CwiseBinaryOp, operator+=()
  */
-EIGEN_MAKE_CWISE_BINARY_OP(operator+, sum)
+EIGEN_MAKE_CWISE_BINARY_OP(operator+, internal::scalar_sum_op)
 
 /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
  *
@@ -48,13 +51,13 @@
  *
  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
  */
-EIGEN_MAKE_SCALAR_BINARY_OP(operator*, product)
+EIGEN_MAKE_SCALAR_BINARY_OP(operator*, internal::scalar_product_op)
 
 /** \returns an expression of \c *this divided by the scalar value \a scalar
  *
  * \tparam T is the scalar type of \a scalar. It must be compatible with the scalar type of the given expression.
  */
-EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/, quotient)
+EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(operator/, internal::scalar_quotient_op)
 
 /** \returns an expression of the coefficient-wise boolean \b and operator of \c *this and \a other
  *
@@ -98,7 +101,7 @@
                                                                                                    other.derived());
 }
 
-/** \returns an expression of the bitwise boolean \b or operator of \c *this and \a other
+/** \returns an expression of the bitwise \b or operator of \c *this and \a other
  *
  * \sa operator&(), operator^()
  */
diff --git a/Eigen/src/plugins/CommonCwiseUnaryOps.inc b/Eigen/src/plugins/CommonCwiseUnaryOps.inc
index bf8a940..b5bfdab 100644
--- a/Eigen/src/plugins/CommonCwiseUnaryOps.inc
+++ b/Eigen/src/plugins/CommonCwiseUnaryOps.inc
@@ -7,42 +7,49 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This file is a base class plugin containing common coefficient wise functions.
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 
 /** \internal the return type of conjugate() */
-typedef std::conditional_t<NumTraits<Scalar>::IsComplex,
-                           const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>, const Derived&>
-    ConjugateReturnType;
+using ConjugateReturnType =
+    std::conditional_t<NumTraits<Scalar>::IsComplex,
+                       const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>, const Derived&>;
 /** \internal the return type of real() const */
-typedef std::conditional_t<NumTraits<Scalar>::IsComplex,
-                           const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>, const Derived&>
-    RealReturnType;
+using RealReturnType =
+    std::conditional_t<NumTraits<Scalar>::IsComplex,
+                       const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>, const Derived&>;
 /** \internal the return type of real() */
-typedef std::conditional_t<NumTraits<Scalar>::IsComplex, CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,
-                           Derived&>
-    NonConstRealReturnType;
+using NonConstRealReturnType =
+    std::conditional_t<NumTraits<Scalar>::IsComplex, CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,
+                       Derived&>;
 /** \internal the return type of imag() const */
-typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturnType;
-/** \internal the return type of imag() */
-typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
+using ImagReturnType = CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived>;
+/** \internal the return type of imag(). The imaginary part of a real-valued object is identically zero and not an
+ * lvalue, so for real scalars the non-const overload returns the same read-only zero expression as the const one
+ * instead of a writable view (whose functor would return a dangling reference to a temporary; see issue #3096). */
+using NonConstImagReturnType =
+    std::conditional_t<NumTraits<Scalar>::IsComplex, CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived>,
+                       ImagReturnType>;
 
-typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived> NegativeReturnType;
+using NegativeReturnType = CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived>;
 
 #endif  // not EIGEN_PARSED_BY_DOXYGEN
 
 /// \returns an expression of the opposite of \c *this
 ///
+/// \note Unary minus is not supported for \c bool coefficients. Cast to a signed integer type first.
+///
 EIGEN_DOC_UNARY_ADDONS(operator-, opposite)
 ///
 EIGEN_DEVICE_FUNC constexpr inline const NegativeReturnType operator-() const { return NegativeReturnType(derived()); }
 
 template <class NewType>
 struct CastXpr {
-  typedef typename internal::cast_return_type<
-      Derived, const CwiseUnaryOp<internal::core_cast_op<Scalar, NewType>, const Derived> >::type Type;
+  using Type = typename internal::cast_return_type<
+      Derived, const CwiseUnaryOp<internal::core_cast_op<Scalar, NewType>, const Derived>>::type;
 };
 
 /// \returns an expression of \c *this with the \a Scalar type casted to
@@ -81,14 +88,14 @@
 ///
 EIGEN_DOC_UNARY_ADDONS(real, real part function)
 ///
-/// \sa imag()
+/// \sa imag(), realView()
 EIGEN_DEVICE_FUNC constexpr inline RealReturnType real() const { return RealReturnType(derived()); }
 
-/// \returns an read-only expression of the imaginary part of \c *this.
+/// \returns a read-only expression of the imaginary part of \c *this.
 ///
 EIGEN_DOC_UNARY_ADDONS(imag, imaginary part function)
 ///
-/// \sa real()
+/// \sa real(), realView()
 EIGEN_DEVICE_FUNC constexpr inline const ImagReturnType imag() const { return ImagReturnType(derived()); }
 
 /// \brief Apply a unary operator coefficient-wise
@@ -96,7 +103,7 @@
 /// \tparam  CustomUnaryOp Type of \a func
 /// \returns An expression of a custom coefficient-wise unary operator \a func of *this
 ///
-/// The function \c ptr_fun() from the C++ standard library can be used to make functors out of normal functions.
+/// A lambda can be used to adapt a normal function to the functor interface expected by this method.
 ///
 /// Example:
 /// \include class_CwiseUnaryOp_ptrfun.cpp
@@ -129,7 +136,7 @@
 ///
 EIGEN_DOC_UNARY_ADDONS(unaryViewExpr, unary function)
 ///
-/// \sa unaryExpr, binaryExpr class CwiseUnaryOp
+/// \sa unaryExpr, binaryExpr, class CwiseUnaryOp
 ///
 template <typename CustomViewOp>
 EIGEN_DEVICE_FUNC constexpr inline const CwiseUnaryView<CustomViewOp, const Derived> unaryViewExpr(
@@ -144,7 +151,7 @@
 ///
 EIGEN_DOC_UNARY_ADDONS(unaryViewExpr, unary function)
 ///
-/// \sa unaryExpr, binaryExpr class CwiseUnaryOp
+/// \sa unaryExpr, binaryExpr, class CwiseUnaryOp
 ///
 template <typename CustomViewOp>
 EIGEN_DEVICE_FUNC constexpr inline CwiseUnaryView<CustomViewOp, Derived> unaryViewExpr(
@@ -156,12 +163,14 @@
 ///
 EIGEN_DOC_UNARY_ADDONS(real, real part function)
 ///
-/// \sa imag()
+/// \sa imag(), realView()
 EIGEN_DEVICE_FUNC constexpr inline NonConstRealReturnType real() { return NonConstRealReturnType(derived()); }
 
 /// \returns a non const expression of the imaginary part of \c *this.
+/// For real-valued objects the imaginary part is identically zero and not writable; this then returns the
+/// same read-only zero expression as the const overload.
 ///
 EIGEN_DOC_UNARY_ADDONS(imag, imaginary part function)
 ///
-/// \sa real()
+/// \sa real(), realView()
 EIGEN_DEVICE_FUNC constexpr inline NonConstImagReturnType imag() { return NonConstImagReturnType(derived()); }
diff --git a/Eigen/src/plugins/IndexedViewMethods.inc b/Eigen/src/plugins/IndexedViewMethods.inc
index a51e349..927731a 100644
--- a/Eigen/src/plugins/IndexedViewMethods.inc
+++ b/Eigen/src/plugins/IndexedViewMethods.inc
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #if !defined(EIGEN_PARSED_BY_DOXYGEN)
 
@@ -160,7 +161,7 @@
  * ranges, etc.
  *
  * If the submatrix can be represented using a starting position \c (i,j) and positive sizes \c (rows,columns), then
- * this method will returns a Block object after extraction of the relevant information from the passed arguments. This
+ * this method will return a Block object after extraction of the relevant information from the passed arguments. This
  * is the case when all arguments are either:
  *  - An integer
  *  - Eigen::placeholders::all
@@ -170,8 +171,8 @@
  * Otherwise a more general IndexedView<Derived,RowIndices',ColIndices'> object will be returned, after conversion of
  * the inputs to more suitable types \c RowIndices' and \c ColIndices'.
  *
- * For 1D vectors and arrays, you better use the operator()(const Indices&) overload, which behave the same way but
- * taking a single parameter.
+ * For 1D vectors and arrays, it is better to use the operator()(const Indices&) overload, which behaves the same way
+ * but takes a single parameter.
  *
  * See also this <a
  * href="https://stackoverflow.com/questions/46110917/eigen-replicate-items-along-one-dimension-without-useless-allocations">question</a>
diff --git a/Eigen/src/plugins/InternalHeaderCheck.inc b/Eigen/src/plugins/InternalHeaderCheck.inc
index ac6821d..8378b2c 100644
--- a/Eigen/src/plugins/InternalHeaderCheck.inc
+++ b/Eigen/src/plugins/InternalHeaderCheck.inc
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_CORE_MODULE_H
 #error "Please include Eigen/plugins instead of including headers inside the src directory directly."
 #endif
diff --git a/Eigen/src/plugins/MatrixCwiseBinaryOps.inc b/Eigen/src/plugins/MatrixCwiseBinaryOps.inc
index 8e0da06..5112d93 100644
--- a/Eigen/src/plugins/MatrixCwiseBinaryOps.inc
+++ b/Eigen/src/plugins/MatrixCwiseBinaryOps.inc
@@ -7,8 +7,9 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-// This file is a base class plugin containing matrix specifics coefficient wise functions.
+// This file is a base class plugin containing matrix specific coefficient wise functions.
 
 /** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
  *
@@ -18,9 +19,10 @@
  * \sa class CwiseBinaryOp, cwiseAbs2
  */
 template <typename OtherDerived>
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, product)
+EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived,
+                                                                                     internal::scalar_product_op)
     cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived>& other) const {
-  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, product)(derived(), other.derived());
+  return EIGEN_CWISE_BINARY_RETURN_TYPE(Derived, OtherDerived, internal::scalar_product_op)(derived(), other.derived());
 }
 
 template <typename OtherDerived>
diff --git a/Eigen/src/plugins/MatrixCwiseUnaryOps.inc b/Eigen/src/plugins/MatrixCwiseUnaryOps.inc
index a57548c..2d73e64 100644
--- a/Eigen/src/plugins/MatrixCwiseUnaryOps.inc
+++ b/Eigen/src/plugins/MatrixCwiseUnaryOps.inc
@@ -7,19 +7,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This file is included into the body of the base classes supporting matrix specific coefficient-wise functions.
-// This include MatrixBase and SparseMatrixBase.
-
-typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> CwiseAbsReturnType;
-typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> CwiseAbs2ReturnType;
-typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> CwiseArgReturnType;
-typedef CwiseUnaryOp<internal::scalar_carg_op<Scalar>, const Derived> CwiseCArgReturnType;
-typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> CwiseSqrtReturnType;
-typedef CwiseUnaryOp<internal::scalar_cbrt_op<Scalar>, const Derived> CwiseCbrtReturnType;
-typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> CwiseSquareReturnType;
-typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> CwiseSignReturnType;
-typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;
+// These are MatrixBase, ArrayBase, and SparseMatrixBase.
 
 /// \returns an expression of the coefficient-wise absolute value of \c *this
 ///
@@ -30,9 +21,7 @@
 ///
 /// \sa cwiseAbs2()
 ///
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CwiseAbsReturnType cwiseAbs() const {
-  return CwiseAbsReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseAbs, internal::scalar_abs_op, CwiseAbsReturnType)
 
 /// \returns an expression of the coefficient-wise squared absolute value of \c *this
 ///
@@ -43,9 +32,7 @@
 ///
 /// \sa cwiseAbs()
 ///
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CwiseAbs2ReturnType cwiseAbs2() const {
-  return CwiseAbs2ReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseAbs2, internal::scalar_abs2_op, CwiseAbs2ReturnType)
 
 /// \returns an expression of the coefficient-wise square root of *this.
 ///
@@ -56,9 +43,7 @@
 ///
 /// \sa cwisePow(), cwiseSquare(), cwiseCbrt()
 ///
-EIGEN_DEVICE_FUNC constexpr inline const CwiseSqrtReturnType cwiseSqrt() const {
-  return CwiseSqrtReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseSqrt, internal::scalar_sqrt_op, CwiseSqrtReturnType)
 
 /// \returns an expression of the coefficient-wise cube root of *this.
 ///
@@ -66,9 +51,7 @@
 ///
 /// \sa cwiseSqrt(), cwiseSquare(), cwisePow()
 ///
-EIGEN_DEVICE_FUNC constexpr inline const CwiseCbrtReturnType cwiseCbrt() const {
-  return CwiseCbrtReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseCbrt, internal::scalar_cbrt_op, CwiseCbrtReturnType)
 
 /// \returns an expression of the coefficient-wise square of *this.
 ///
@@ -76,9 +59,7 @@
 ///
 /// \sa cwisePow(), cwiseSqrt(), cwiseCbrt()
 ///
-EIGEN_DEVICE_FUNC constexpr inline const CwiseSquareReturnType cwiseSquare() const {
-  return CwiseSquareReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseSquare, internal::scalar_square_op, CwiseSquareReturnType)
 
 /// \returns an expression of the coefficient-wise signum of *this.
 ///
@@ -87,9 +68,7 @@
 ///
 EIGEN_DOC_UNARY_ADDONS(cwiseSign, sign function)
 ///
-EIGEN_DEVICE_FUNC constexpr inline const CwiseSignReturnType cwiseSign() const {
-  return CwiseSignReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseSign, internal::scalar_sign_op, CwiseSignReturnType)
 
 /// \returns an expression of the coefficient-wise inverse of *this.
 ///
@@ -100,9 +79,7 @@
 ///
 /// \sa cwiseProduct()
 ///
-EIGEN_DEVICE_FUNC constexpr inline const CwiseInverseReturnType cwiseInverse() const {
-  return CwiseInverseReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseInverse, internal::scalar_inverse_op, CwiseInverseReturnType)
 
 /// \returns an expression of the coefficient-wise phase angle of \c *this
 ///
@@ -111,11 +88,9 @@
 ///
 EIGEN_DOC_UNARY_ADDONS(cwiseArg, arg)
 
-EIGEN_DEVICE_FUNC constexpr inline const CwiseArgReturnType cwiseArg() const { return CwiseArgReturnType(derived()); }
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseArg, internal::scalar_arg_op, CwiseArgReturnType)
 
-EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE const CwiseCArgReturnType cwiseCArg() const {
-  return CwiseCArgReturnType(derived());
-}
+EIGEN_MAKE_CWISE_UNARY_OP(cwiseCArg, internal::scalar_carg_op, CwiseCArgReturnType)
 
 template <typename ScalarExponent>
 using CwisePowReturnType =
diff --git a/Eigen/src/plugins/ReshapedMethods.inc b/Eigen/src/plugins/ReshapedMethods.inc
index 1e3a196..87fc0f5 100644
--- a/Eigen/src/plugins/ReshapedMethods.inc
+++ b/Eigen/src/plugins/ReshapedMethods.inc
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifdef EIGEN_PARSED_BY_DOXYGEN
 
@@ -15,7 +17,7 @@
 /// Output: \verbinclude MatrixBase_reshaped_int_int.out
 ///
 /// The number of rows \a nRows and columns \a nCols can also be specified at compile-time by passing Eigen::fix<N>,
-/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N
+/// or Eigen::fix<N>(n) as arguments. In the latter case, \c n plays the role of a runtime fallback value in case \c N
 /// equals Eigen::Dynamic. Here is an example with a fixed number of rows and columns: \include
 /// MatrixBase_reshaped_fixed.cpp Output: \verbinclude MatrixBase_reshaped_fixed.out
 ///
@@ -39,7 +41,7 @@
 /// row-major-order (RowMajor),
 ///               or follows the \em natural order of the nested expression (AutoOrder). The default is ColMajor.
 ///
-/// This overloads is essentially a shortcut for `A.reshaped<Order>(AutoSize,fix<1>)`.
+/// This overload is essentially a shortcut for `A.reshaped<Order>(AutoSize,fix<1>)`.
 ///
 /// - If `Order==ColMajor` (the default), then it returns a column-vector from the stacked columns of \c *this.
 /// - If `Order==RowMajor`, then it returns a column-vector from the stacked rows of \c *this.
diff --git a/blas/BandTriangularSolver.h b/blas/BandTriangularSolver.h
index fbc639f..7af5684 100644
--- a/blas/BandTriangularSolver.h
+++ b/blas/BandTriangularSolver.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BAND_TRIANGULARSOLVER_H
 #define EIGEN_BAND_TRIANGULARSOLVER_H
@@ -44,7 +45,7 @@
                                         .cwiseProduct(other.col(col).segment(IsLower ? i - actual_k : i + 1, actual_k))
                                         .sum();
 
-        if ((Mode & UnitDiag) == 0) other.coeffRef(i, col) /= cjLhs(i, IsLower ? k : 0);
+        EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == 0) other.coeffRef(i, col) /= cjLhs(i, IsLower ? k : 0);
       }
     }
   }
@@ -68,7 +69,7 @@
         int actual_k = (std::min)(k, size - ii - 1);
         int actual_start = IsLower ? 1 : k - actual_k;
 
-        if ((Mode & UnitDiag) == 0) other.coeffRef(i, col) /= cjLhs(IsLower ? 0 : k, i);
+        EIGEN_IF_CONSTEXPR ((Mode & UnitDiag) == 0) other.coeffRef(i, col) /= cjLhs(IsLower ? 0 : k, i);
 
         if (actual_k > 0)
           other.col(col).segment(IsLower ? i + 1 : i - actual_k, actual_k) -=
diff --git a/blas/CMakeLists.txt b/blas/CMakeLists.txt
index c8a2885..4053b03 100644
--- a/blas/CMakeLists.txt
+++ b/blas/CMakeLists.txt
@@ -1,3 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 project(EigenBlas CXX)
 
@@ -6,11 +8,7 @@
 add_custom_target(blas)
 
 set(EigenBlas_SRCS  single.cpp double.cpp complex_single.cpp complex_double.cpp xerbla.cpp
-                    f2c/srotm.c   f2c/srotmg.c  f2c/drotm.c f2c/drotmg.c
-                    f2c/lsame.c   f2c/dspmv.c   f2c/ssbmv.c f2c/chbmv.c
-                    f2c/sspmv.c   f2c/zhbmv.c   f2c/chpmv.c f2c/dsbmv.c
-                    f2c/zhpmv.c   f2c/dtbmv.c   f2c/stbmv.c f2c/ctbmv.c
-                    f2c/ztbmv.c   f2c/complexdots.c
+                    lsame.cpp complexdots.cpp
    )
 
 set(EIGEN_BLAS_TARGETS "")
@@ -33,10 +31,12 @@
   endif()
 
   add_dependencies(blas ${target})
-  install(TARGETS ${target}
-          RUNTIME DESTINATION bin
-          LIBRARY DESTINATION lib
-          ARCHIVE DESTINATION lib)
+  if(EIGEN_INSTALL)
+    install(TARGETS ${target}
+            RUNTIME DESTINATION bin
+            LIBRARY DESTINATION lib
+            ARCHIVE DESTINATION lib)
+  endif()
 endforeach()
 
 if(EIGEN_BUILD_TESTING)
diff --git a/blas/GeneralRank1Update.h b/blas/GeneralRank1Update.h
index e6c3cab..eeba364 100644
--- a/blas/GeneralRank1Update.h
+++ b/blas/GeneralRank1Update.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GENERAL_RANK1UPDATE_H
 #define EIGEN_GENERAL_RANK1UPDATE_H
@@ -21,7 +22,7 @@
 struct general_rank1_update<Scalar, Index, ColMajor, ConjLhs, ConjRhs> {
   static void run(Index rows, Index cols, Scalar* mat, Index stride, const Scalar* u, const Scalar* v, Scalar alpha) {
     typedef Map<const Matrix<Scalar, Dynamic, 1> > OtherMap;
-    typedef typename conj_expr_if<ConjLhs, OtherMap>::type ConjRhsType;
+    typedef conj_expr_if<ConjLhs, OtherMap> ConjRhsType;
     conj_if<ConjRhs> cj;
 
     for (Index i = 0; i < cols; ++i)
diff --git a/blas/PackedSelfadjointProduct.h b/blas/PackedSelfadjointProduct.h
index 5109960..a37afe7 100644
--- a/blas/PackedSelfadjointProduct.h
+++ b/blas/PackedSelfadjointProduct.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SELFADJOINT_PACKED_PRODUCT_H
 #define EIGEN_SELFADJOINT_PACKED_PRODUCT_H
@@ -24,7 +25,7 @@
   typedef typename NumTraits<Scalar>::Real RealScalar;
   static void run(Index size, Scalar* mat, const Scalar* vec, RealScalar alpha) {
     typedef Map<const Matrix<Scalar, Dynamic, 1> > OtherMap;
-    typedef typename conj_expr_if<ConjLhs, OtherMap>::type ConjRhsType;
+    typedef conj_expr_if<ConjLhs, OtherMap> ConjRhsType;
     conj_if<ConjRhs> cj;
 
     for (Index i = 0; i < size; ++i) {
diff --git a/blas/PackedTriangularMatrixVector.h b/blas/PackedTriangularMatrixVector.h
index 4e8e085..b3ee50a 100644
--- a/blas/PackedTriangularMatrixVector.h
+++ b/blas/PackedTriangularMatrixVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKED_TRIANGULAR_MATRIX_VECTOR_H
 #define EIGEN_PACKED_TRIANGULAR_MATRIX_VECTOR_H
@@ -28,7 +29,7 @@
   static void run(Index size, const LhsScalar* lhs, const RhsScalar* rhs, ResScalar* res, ResScalar alpha) {
     internal::conj_if<ConjRhs> cj;
     typedef Map<const Matrix<LhsScalar, Dynamic, 1> > LhsMap;
-    typedef typename conj_expr_if<ConjLhs, LhsMap>::type ConjLhsType;
+    typedef conj_expr_if<ConjLhs, LhsMap> ConjLhsType;
     typedef Map<Matrix<ResScalar, Dynamic, 1> > ResMap;
 
     for (Index i = 0; i < size; ++i) {
@@ -37,7 +38,7 @@
       if (!(HasUnitDiag || HasZeroDiag) || (--r > 0)) {
         ResMap(res + (IsLower ? s + i : 0), r) += alpha * cj(rhs[i]) * ConjLhsType(LhsMap(lhs + s, r));
       }
-      if (HasUnitDiag) {
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) {
         res[i] += alpha * cj(rhs[i]);
       }
       lhs += IsLower ? size - i : i + 1;
@@ -56,9 +57,9 @@
   static void run(Index size, const LhsScalar* lhs, const RhsScalar* rhs, ResScalar* res, ResScalar alpha) {
     internal::conj_if<ConjRhs> cj;
     typedef Map<const Matrix<LhsScalar, Dynamic, 1> > LhsMap;
-    typedef typename conj_expr_if<ConjLhs, LhsMap>::type ConjLhsType;
+    typedef conj_expr_if<ConjLhs, LhsMap> ConjLhsType;
     typedef Map<const Matrix<RhsScalar, Dynamic, 1> > RhsMap;
-    typedef typename conj_expr_if<ConjRhs, RhsMap>::type ConjRhsType;
+    typedef conj_expr_if<ConjRhs, RhsMap> ConjRhsType;
 
     for (Index i = 0; i < size; ++i) {
       Index s = !IsLower && (HasUnitDiag || HasZeroDiag) ? 1 : 0;
@@ -68,7 +69,7 @@
             alpha *
             (ConjLhsType(LhsMap(lhs + s, r)).cwiseProduct(ConjRhsType(RhsMap(rhs + (IsLower ? 0 : s + i), r)))).sum();
       }
-      if (HasUnitDiag) {
+      EIGEN_IF_CONSTEXPR (HasUnitDiag) {
         res[i] += alpha * cj(rhs[i]);
       }
       lhs += IsLower ? i + 1 : size - i;
diff --git a/blas/PackedTriangularSolverVector.h b/blas/PackedTriangularSolverVector.h
index 92964fb..7d32912 100644
--- a/blas/PackedTriangularSolverVector.h
+++ b/blas/PackedTriangularSolverVector.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_PACKED_TRIANGULAR_SOLVER_VECTOR_H
 #define EIGEN_PACKED_TRIANGULAR_SOLVER_VECTOR_H
@@ -23,7 +24,7 @@
   static void run(Index size, const LhsScalar* lhs, RhsScalar* rhs) {
     internal::conj_if<Conjugate> cj;
     typedef Map<const Matrix<LhsScalar, Dynamic, 1> > LhsMap;
-    typedef typename conj_expr_if<Conjugate, LhsMap>::type ConjLhsType;
+    typedef conj_expr_if<Conjugate, LhsMap> ConjLhsType;
 
     lhs += IsLower ? 0 : (size * (size + 1) >> 1) - 1;
     for (Index pi = 0; pi < size; ++pi) {
@@ -33,7 +34,7 @@
         rhs[i] -= (ConjLhsType(LhsMap(lhs + s, pi))
                        .cwiseProduct(Map<const Matrix<RhsScalar, Dynamic, 1> >(rhs + (IsLower ? 0 : i + 1), pi)))
                       .sum();
-      if (!(Mode & UnitDiag)) rhs[i] /= cj(lhs[IsLower ? i : 0]);
+      EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) rhs[i] /= cj(lhs[IsLower ? i : 0]);
       IsLower ? lhs += pi + 1 : lhs -= pi + 2;
     }
   }
@@ -46,13 +47,13 @@
   static void run(Index size, const LhsScalar* lhs, RhsScalar* rhs) {
     internal::conj_if<Conjugate> cj;
     typedef Map<const Matrix<LhsScalar, Dynamic, 1> > LhsMap;
-    typedef typename conj_expr_if<Conjugate, LhsMap>::type ConjLhsType;
+    typedef conj_expr_if<Conjugate, LhsMap> ConjLhsType;
 
     lhs += IsLower ? 0 : size * (size - 1) >> 1;
     for (Index pi = 0; pi < size; ++pi) {
       Index i = IsLower ? pi : size - pi - 1;
       Index r = size - pi - 1;
-      if (!(Mode & UnitDiag)) rhs[i] /= cj(lhs[IsLower ? 0 : i]);
+      EIGEN_IF_CONSTEXPR (!(Mode & UnitDiag)) rhs[i] /= cj(lhs[IsLower ? 0 : i]);
       if (r > 0)
         Map<Matrix<RhsScalar, Dynamic, 1> >(rhs + (IsLower ? i + 1 : 0), r) -=
             rhs[i] * ConjLhsType(LhsMap(lhs + (IsLower ? 1 : 0), r));
diff --git a/blas/Rank2Update.h b/blas/Rank2Update.h
index 9cb96ee..aea2b1d 100644
--- a/blas/Rank2Update.h
+++ b/blas/Rank2Update.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RANK2UPDATE_H
 #define EIGEN_RANK2UPDATE_H
diff --git a/blas/blas.h b/blas/blas.h
index 220e956..51fbcf4 100644
--- a/blas/blas.h
+++ b/blas/blas.h
@@ -1,6 +1,11 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef BLAS_H
 #define BLAS_H
 
+#include <stddef.h>
+
 #if defined(_WIN32)
 #if defined(EIGEN_BLAS_BUILD_DLL)
 #define EIGEN_BLAS_API __declspec(dllexport)
@@ -30,7 +35,7 @@
 #endif
 
 EIGEN_BLAS_API int BLASFUNC(lsame)(const char *, const char *);
-EIGEN_BLAS_API void BLASFUNC(xerbla)(const char *, int *info);
+EIGEN_BLAS_API void BLASFUNC(xerbla)(const char*, int* info, size_t len);
 
 EIGEN_BLAS_API float BLASFUNC(sdot)(int *, float *, int *, float *, int *);
 EIGEN_BLAS_API float BLASFUNC(sdsdot)(int *, float *, float *, int *, float *, int *);
diff --git a/blas/common.h b/blas/common.h
index 9e46b6e..5779185 100644
--- a/blas/common.h
+++ b/blas/common.h
@@ -6,18 +6,11 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_BLAS_COMMON_H
 #define EIGEN_BLAS_COMMON_H
 
-#ifdef __GNUC__
-#if __GNUC__ < 5
-// GCC < 5.0 does not like the global Scalar typedef
-// we just keep shadow-warnings disabled permanently
-#define EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
-#endif
-#endif
-
 #include "../Eigen/Core"
 #include "../Eigen/Jacobi"
 
@@ -29,6 +22,19 @@
 
 #include "blas.h"
 
+constexpr size_t kBlasNameLength = 6;
+
+namespace Eigen {
+namespace internal {
+// Optionally wraps an expression in a conjugation, used by the product kernels
+// below. This alias used to live in Eigen's core products headers but was
+// removed there as dead code; the BLAS kernels are its only remaining users.
+template <bool Cond, typename T>
+using conj_expr_if =
+    std::conditional_t<!Cond, const T&, CwiseUnaryOp<scalar_conjugate_op<typename traits<T>::Scalar>, T>>;
+}  // namespace internal
+}  // namespace Eigen
+
 #include "BandTriangularSolver.h"
 #include "GeneralRank1Update.h"
 #include "PackedSelfadjointProduct.h"
diff --git a/blas/complex_double.cpp b/blas/complex_double.cpp
index 94b9d20..3be1446 100644
--- a/blas/complex_double.cpp
+++ b/blas/complex_double.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR std::complex<double>
 #define SCALAR_SUFFIX z
diff --git a/blas/complex_single.cpp b/blas/complex_single.cpp
index 842faec..edef995 100644
--- a/blas/complex_single.cpp
+++ b/blas/complex_single.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR std::complex<float>
 #define SCALAR_SUFFIX c
diff --git a/blas/complexdots.cpp b/blas/complexdots.cpp
new file mode 100644
index 0000000..253edbb
--- /dev/null
+++ b/blas/complexdots.cpp
@@ -0,0 +1,74 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// C++ replacements for the f2c complex dot product wrappers.
+// These are thin wrappers around the worker functions (cdotcw_, etc.)
+// defined in level1_cplx_impl.h.
+//
+// Note: blas.h declares these as void, but gfortran expects complex functions
+// to return by value. We define the correct signatures here and do not include
+// blas.h to avoid the conflicting declarations.
+
+#if defined(_WIN32)
+#if defined(EIGEN_BLAS_BUILD_DLL)
+#define EIGEN_BLAS_CDOT_API __declspec(dllexport)
+#else
+#define EIGEN_BLAS_CDOT_API
+#endif
+#elif ((defined(__GNUC__) && __GNUC__ >= 4) || defined(__clang__)) && defined(EIGEN_BLAS_BUILD_DLL)
+#define EIGEN_BLAS_CDOT_API __attribute__((visibility("default")))
+#else
+#define EIGEN_BLAS_CDOT_API
+#endif
+
+extern "C" {
+
+// Worker function declarations (defined in level1_cplx_impl.h via complex_single.cpp / complex_double.cpp).
+void cdotcw_(int *n, float *cx, int *incx, float *cy, int *incy, float *res);
+void cdotuw_(int *n, float *cx, int *incx, float *cy, int *incy, float *res);
+void zdotcw_(int *n, double *cx, int *incx, double *cy, int *incy, double *res);
+void zdotuw_(int *n, double *cx, int *incx, double *cy, int *incy, double *res);
+
+// POD complex types for C-compatible return values (matches Fortran complex layout).
+struct eigen_blas_complex_float {
+  float r, i;
+};
+struct eigen_blas_complex_double {
+  double r, i;
+};
+
+// CDOTC computes the conjugated dot product of two single-precision complex vectors.
+EIGEN_BLAS_CDOT_API eigen_blas_complex_float cdotc_(int *n, float *cx, int *incx, float *cy, int *incy) {
+  eigen_blas_complex_float res = {0.0f, 0.0f};
+  cdotcw_(n, cx, incx, cy, incy, &res.r);
+  return res;
+}
+
+// CDOTU computes the unconjugated dot product of two single-precision complex vectors.
+EIGEN_BLAS_CDOT_API eigen_blas_complex_float cdotu_(int *n, float *cx, int *incx, float *cy, int *incy) {
+  eigen_blas_complex_float res = {0.0f, 0.0f};
+  cdotuw_(n, cx, incx, cy, incy, &res.r);
+  return res;
+}
+
+// ZDOTC computes the conjugated dot product of two double-precision complex vectors.
+EIGEN_BLAS_CDOT_API eigen_blas_complex_double zdotc_(int *n, double *cx, int *incx, double *cy, int *incy) {
+  eigen_blas_complex_double res = {0.0, 0.0};
+  zdotcw_(n, cx, incx, cy, incy, &res.r);
+  return res;
+}
+
+// ZDOTU computes the unconjugated dot product of two double-precision complex vectors.
+EIGEN_BLAS_CDOT_API eigen_blas_complex_double zdotu_(int *n, double *cx, int *incx, double *cy, int *incy) {
+  eigen_blas_complex_double res = {0.0, 0.0};
+  zdotuw_(n, cx, incx, cy, incy, &res.r);
+  return res;
+}
+
+}  // extern "C"
diff --git a/blas/double.cpp b/blas/double.cpp
index 28a2563..eb99aae 100644
--- a/blas/double.cpp
+++ b/blas/double.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR double
 #define SCALAR_SUFFIX d
diff --git a/blas/eigen_blas.def b/blas/eigen_blas.def
index 20f26dc..1589d51 100644
--- a/blas/eigen_blas.def
+++ b/blas/eigen_blas.def
@@ -63,6 +63,8 @@
     scasum_
     dasum_
     dzasum_
+    dcabs1_
+    scabs1_
     ; ismax_
     ; idmax_
     ; icmax_
diff --git a/blas/f2c/chbmv.c b/blas/f2c/chbmv.c
deleted file mode 100644
index 2aa3a01..0000000
--- a/blas/f2c/chbmv.c
+++ /dev/null
@@ -1,456 +0,0 @@
-/* chbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-static inline void r_cnjg(complex *r, complex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void chbmv_(char *uplo, integer *n, integer *k, complex *alpha, complex *a, integer *lda, complex *x,
-                             integer *incx, complex *beta, complex *y, integer *incy) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
-  real r__1;
-  complex q__1, q__2, q__3, q__4;
-
-  /* Local variables */
-  integer i__, j, l, ix, iy, jx, jy, kx, ky, info;
-  complex temp1, temp2;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CHBMV  performs the matrix-vector  operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n hermitian band matrix, with k super-diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the band matrix A is being supplied as */
-  /*           follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  being supplied. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  being supplied. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry, K specifies the number of super-diagonals of the */
-  /*           matrix A. K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - COMPLEX         . */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  A      - COMPLEX          array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the hermitian matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer the upper */
-  /*           triangular part of a hermitian band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the hermitian matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer the lower */
-  /*           triangular part of a hermitian band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Note that the imaginary parts of the diagonal elements need */
-  /*           not be set and are assumed to be zero. */
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - COMPLEX          array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the */
-  /*           vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - COMPLEX         . */
-  /*           On entry, BETA specifies the scalar beta. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - COMPLEX          array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the */
-  /*           vector y. On exit, Y is overwritten by the updated vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-  --y;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*k < 0) {
-    info = 3;
-  } else if (*lda < *k + 1) {
-    info = 6;
-  } else if (*incx == 0) {
-    info = 8;
-  } else if (*incy == 0) {
-    info = 11;
-  }
-  if (info != 0) {
-    xerbla_("CHBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (alpha->r == 0.f && alpha->i == 0.f && (beta->r == 1.f && beta->i == 0.f))) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array A */
-  /*     are accessed sequentially with one pass through A. */
-
-  /*     First form  y := beta*y. */
-
-  if (beta->r != 1.f || beta->i != 0.f) {
-    if (*incy == 1) {
-      if (beta->r == 0.f && beta->i == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          y[i__2].r = 0.f, y[i__2].i = 0.f;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          i__3 = i__;
-          q__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, q__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (beta->r == 0.f && beta->i == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          y[i__2].r = 0.f, y[i__2].i = 0.f;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          i__3 = iy;
-          q__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, q__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (alpha->r == 0.f && alpha->i == 0.f) {
-    return;
-  }
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when upper triangle of A is stored. */
-
-    kplus1 = *k + 1;
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = j;
-        q__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, q__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__2 = 1, i__3 = j - *k;
-        i__4 = j - 1;
-        for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-          i__2 = i__;
-          i__3 = i__;
-          i__5 = l + i__ + j * a_dim1;
-          q__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, q__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          q__1.r = y[i__3].r + q__2.r, q__1.i = y[i__3].i + q__2.i;
-          y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-          r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-          i__2 = i__;
-          q__2.r = q__3.r * x[i__2].r - q__3.i * x[i__2].i, q__2.i = q__3.r * x[i__2].i + q__3.i * x[i__2].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          /* L50: */
-        }
-        i__4 = j;
-        i__2 = j;
-        i__3 = kplus1 + j * a_dim1;
-        r__1 = a[i__3].r;
-        q__3.r = r__1 * temp1.r, q__3.i = r__1 * temp1.i;
-        q__2.r = y[i__2].r + q__3.r, q__2.i = y[i__2].i + q__3.i;
-        q__4.r = alpha->r * temp2.r - alpha->i * temp2.i, q__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = q__2.r + q__4.r, q__1.i = q__2.i + q__4.i;
-        y[i__4].r = q__1.r, y[i__4].i = q__1.i;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__4 = jx;
-        q__1.r = alpha->r * x[i__4].r - alpha->i * x[i__4].i, q__1.i = alpha->r * x[i__4].i + alpha->i * x[i__4].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        ix = kx;
-        iy = ky;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__4 = 1, i__2 = j - *k;
-        i__3 = j - 1;
-        for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-          i__4 = iy;
-          i__2 = iy;
-          i__5 = l + i__ + j * a_dim1;
-          q__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, q__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          q__1.r = y[i__2].r + q__2.r, q__1.i = y[i__2].i + q__2.i;
-          y[i__4].r = q__1.r, y[i__4].i = q__1.i;
-          r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-          i__4 = ix;
-          q__2.r = q__3.r * x[i__4].r - q__3.i * x[i__4].i, q__2.i = q__3.r * x[i__4].i + q__3.i * x[i__4].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        i__3 = jy;
-        i__4 = jy;
-        i__2 = kplus1 + j * a_dim1;
-        r__1 = a[i__2].r;
-        q__3.r = r__1 * temp1.r, q__3.i = r__1 * temp1.i;
-        q__2.r = y[i__4].r + q__3.r, q__2.i = y[i__4].i + q__3.i;
-        q__4.r = alpha->r * temp2.r - alpha->i * temp2.i, q__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = q__2.r + q__4.r, q__1.i = q__2.i + q__4.i;
-        y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-        jx += *incx;
-        jy += *incy;
-        if (j > *k) {
-          kx += *incx;
-          ky += *incy;
-        }
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when lower triangle of A is stored. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__3 = j;
-        q__1.r = alpha->r * x[i__3].r - alpha->i * x[i__3].i, q__1.i = alpha->r * x[i__3].i + alpha->i * x[i__3].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        i__3 = j;
-        i__4 = j;
-        i__2 = j * a_dim1 + 1;
-        r__1 = a[i__2].r;
-        q__2.r = r__1 * temp1.r, q__2.i = r__1 * temp1.i;
-        q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-        y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-        l = 1 - j;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          i__4 = i__;
-          i__2 = i__;
-          i__5 = l + i__ + j * a_dim1;
-          q__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, q__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          q__1.r = y[i__2].r + q__2.r, q__1.i = y[i__2].i + q__2.i;
-          y[i__4].r = q__1.r, y[i__4].i = q__1.i;
-          r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-          i__4 = i__;
-          q__2.r = q__3.r * x[i__4].r - q__3.i * x[i__4].i, q__2.i = q__3.r * x[i__4].i + q__3.i * x[i__4].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          /* L90: */
-        }
-        i__3 = j;
-        i__4 = j;
-        q__2.r = alpha->r * temp2.r - alpha->i * temp2.i, q__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-        y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__3 = jx;
-        q__1.r = alpha->r * x[i__3].r - alpha->i * x[i__3].i, q__1.i = alpha->r * x[i__3].i + alpha->i * x[i__3].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        i__3 = jy;
-        i__4 = jy;
-        i__2 = j * a_dim1 + 1;
-        r__1 = a[i__2].r;
-        q__2.r = r__1 * temp1.r, q__2.i = r__1 * temp1.i;
-        q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-        y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-        l = 1 - j;
-        ix = jx;
-        iy = jy;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          ix += *incx;
-          iy += *incy;
-          i__4 = iy;
-          i__2 = iy;
-          i__5 = l + i__ + j * a_dim1;
-          q__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, q__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          q__1.r = y[i__2].r + q__2.r, q__1.i = y[i__2].i + q__2.i;
-          y[i__4].r = q__1.r, y[i__4].i = q__1.i;
-          r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-          i__4 = ix;
-          q__2.r = q__3.r * x[i__4].r - q__3.i * x[i__4].i, q__2.i = q__3.r * x[i__4].i + q__3.i * x[i__4].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          /* L110: */
-        }
-        i__3 = jy;
-        i__4 = jy;
-        q__2.r = alpha->r * temp2.r - alpha->i * temp2.i, q__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-        y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-        jx += *incx;
-        jy += *incy;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of CHBMV . */
-
-} /* chbmv_ */
diff --git a/blas/f2c/chpmv.c b/blas/f2c/chpmv.c
deleted file mode 100644
index 4a38a52..0000000
--- a/blas/f2c/chpmv.c
+++ /dev/null
@@ -1,407 +0,0 @@
-/* chpmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-static inline void r_cnjg(complex *r, complex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void chpmv_(char *uplo, integer *n, complex *alpha, complex *ap, complex *x, integer *incx,
-                             complex *beta, complex *y, integer *incy) {
-  /* System generated locals */
-  integer i__1, i__2, i__3, i__4, i__5;
-  real r__1;
-  complex q__1, q__2, q__3, q__4;
-
-  /* Local variables */
-  integer i__, j, k, kk, ix, iy, jx, jy, kx, ky, info;
-  complex temp1, temp2;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CHPMV  performs the matrix-vector operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n hermitian matrix, supplied in packed form. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the matrix A is supplied in the packed */
-  /*           array AP as follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - COMPLEX         . */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  AP     - COMPLEX          array of DIMENSION at least */
-  /*           ( ( n*( n + 1 ) )/2 ). */
-  /*           Before entry with UPLO = 'U' or 'u', the array AP must */
-  /*           contain the upper triangular part of the hermitian matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) */
-  /*           and a( 2, 2 ) respectively, and so on. */
-  /*           Before entry with UPLO = 'L' or 'l', the array AP must */
-  /*           contain the lower triangular part of the hermitian matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) */
-  /*           and a( 3, 1 ) respectively, and so on. */
-  /*           Note that the imaginary parts of the diagonal elements need */
-  /*           not be set and are assumed to be zero. */
-  /*           Unchanged on exit. */
-
-  /*  X      - COMPLEX          array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - COMPLEX         . */
-  /*           On entry, BETA specifies the scalar beta. When BETA is */
-  /*           supplied as zero then Y need not be set on input. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - COMPLEX          array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the n */
-  /*           element vector y. On exit, Y is overwritten by the updated */
-  /*           vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  --y;
-  --x;
-  --ap;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*incx == 0) {
-    info = 6;
-  } else if (*incy == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("CHPMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (alpha->r == 0.f && alpha->i == 0.f && (beta->r == 1.f && beta->i == 0.f))) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array AP */
-  /*     are accessed sequentially with one pass through AP. */
-
-  /*     First form  y := beta*y. */
-
-  if (beta->r != 1.f || beta->i != 0.f) {
-    if (*incy == 1) {
-      if (beta->r == 0.f && beta->i == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          y[i__2].r = 0.f, y[i__2].i = 0.f;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          i__3 = i__;
-          q__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, q__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (beta->r == 0.f && beta->i == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          y[i__2].r = 0.f, y[i__2].i = 0.f;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          i__3 = iy;
-          q__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, q__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (alpha->r == 0.f && alpha->i == 0.f) {
-    return;
-  }
-  kk = 1;
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when AP contains the upper triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = j;
-        q__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, q__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        k = kk;
-        i__2 = j - 1;
-        for (i__ = 1; i__ <= i__2; ++i__) {
-          i__3 = i__;
-          i__4 = i__;
-          i__5 = k;
-          q__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, q__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-          y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-          r_cnjg(&q__3, &ap[k]);
-          i__3 = i__;
-          q__2.r = q__3.r * x[i__3].r - q__3.i * x[i__3].i, q__2.i = q__3.r * x[i__3].i + q__3.i * x[i__3].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          ++k;
-          /* L50: */
-        }
-        i__2 = j;
-        i__3 = j;
-        i__4 = kk + j - 1;
-        r__1 = ap[i__4].r;
-        q__3.r = r__1 * temp1.r, q__3.i = r__1 * temp1.i;
-        q__2.r = y[i__3].r + q__3.r, q__2.i = y[i__3].i + q__3.i;
-        q__4.r = alpha->r * temp2.r - alpha->i * temp2.i, q__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = q__2.r + q__4.r, q__1.i = q__2.i + q__4.i;
-        y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-        kk += j;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = jx;
-        q__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, q__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        ix = kx;
-        iy = ky;
-        i__2 = kk + j - 2;
-        for (k = kk; k <= i__2; ++k) {
-          i__3 = iy;
-          i__4 = iy;
-          i__5 = k;
-          q__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, q__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-          y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-          r_cnjg(&q__3, &ap[k]);
-          i__3 = ix;
-          q__2.r = q__3.r * x[i__3].r - q__3.i * x[i__3].i, q__2.i = q__3.r * x[i__3].i + q__3.i * x[i__3].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        i__2 = jy;
-        i__3 = jy;
-        i__4 = kk + j - 1;
-        r__1 = ap[i__4].r;
-        q__3.r = r__1 * temp1.r, q__3.i = r__1 * temp1.i;
-        q__2.r = y[i__3].r + q__3.r, q__2.i = y[i__3].i + q__3.i;
-        q__4.r = alpha->r * temp2.r - alpha->i * temp2.i, q__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = q__2.r + q__4.r, q__1.i = q__2.i + q__4.i;
-        y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-        jx += *incx;
-        jy += *incy;
-        kk += j;
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when AP contains the lower triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = j;
-        q__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, q__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        i__2 = j;
-        i__3 = j;
-        i__4 = kk;
-        r__1 = ap[i__4].r;
-        q__2.r = r__1 * temp1.r, q__2.i = r__1 * temp1.i;
-        q__1.r = y[i__3].r + q__2.r, q__1.i = y[i__3].i + q__2.i;
-        y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-        k = kk + 1;
-        i__2 = *n;
-        for (i__ = j + 1; i__ <= i__2; ++i__) {
-          i__3 = i__;
-          i__4 = i__;
-          i__5 = k;
-          q__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, q__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-          y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-          r_cnjg(&q__3, &ap[k]);
-          i__3 = i__;
-          q__2.r = q__3.r * x[i__3].r - q__3.i * x[i__3].i, q__2.i = q__3.r * x[i__3].i + q__3.i * x[i__3].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          ++k;
-          /* L90: */
-        }
-        i__2 = j;
-        i__3 = j;
-        q__2.r = alpha->r * temp2.r - alpha->i * temp2.i, q__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = y[i__3].r + q__2.r, q__1.i = y[i__3].i + q__2.i;
-        y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-        kk += *n - j + 1;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = jx;
-        q__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, q__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = q__1.r, temp1.i = q__1.i;
-        temp2.r = 0.f, temp2.i = 0.f;
-        i__2 = jy;
-        i__3 = jy;
-        i__4 = kk;
-        r__1 = ap[i__4].r;
-        q__2.r = r__1 * temp1.r, q__2.i = r__1 * temp1.i;
-        q__1.r = y[i__3].r + q__2.r, q__1.i = y[i__3].i + q__2.i;
-        y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-        ix = jx;
-        iy = jy;
-        i__2 = kk + *n - j;
-        for (k = kk + 1; k <= i__2; ++k) {
-          ix += *incx;
-          iy += *incy;
-          i__3 = iy;
-          i__4 = iy;
-          i__5 = k;
-          q__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, q__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          q__1.r = y[i__4].r + q__2.r, q__1.i = y[i__4].i + q__2.i;
-          y[i__3].r = q__1.r, y[i__3].i = q__1.i;
-          r_cnjg(&q__3, &ap[k]);
-          i__3 = ix;
-          q__2.r = q__3.r * x[i__3].r - q__3.i * x[i__3].i, q__2.i = q__3.r * x[i__3].i + q__3.i * x[i__3].r;
-          q__1.r = temp2.r + q__2.r, q__1.i = temp2.i + q__2.i;
-          temp2.r = q__1.r, temp2.i = q__1.i;
-          /* L110: */
-        }
-        i__2 = jy;
-        i__3 = jy;
-        q__2.r = alpha->r * temp2.r - alpha->i * temp2.i, q__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        q__1.r = y[i__3].r + q__2.r, q__1.i = y[i__3].i + q__2.i;
-        y[i__2].r = q__1.r, y[i__2].i = q__1.i;
-        jx += *incx;
-        jy += *incy;
-        kk += *n - j + 1;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of CHPMV . */
-
-} /* chpmv_ */
diff --git a/blas/f2c/complexdots.c b/blas/f2c/complexdots.c
deleted file mode 100644
index b0dc6c8..0000000
--- a/blas/f2c/complexdots.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* This file has been modified to use the standard gfortran calling
-   convention, rather than the f2c calling convention.
-
-   It does not require -ff2c when compiled with gfortran.
-*/
-
-/* complexdots.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-complex cdotc_(integer *n, complex *cx, integer *incx, complex *cy, integer *incy) {
-  complex res;
-  extern /* Subroutine */ void cdotcw_(integer *, complex *, integer *, complex *, integer *, complex *);
-
-  /* Parameter adjustments */
-  --cy;
-  --cx;
-
-  /* Function Body */
-  cdotcw_(n, &cx[1], incx, &cy[1], incy, &res);
-  return res;
-} /* cdotc_ */
-
-complex cdotu_(integer *n, complex *cx, integer *incx, complex *cy, integer *incy) {
-  complex res;
-  extern /* Subroutine */ void cdotuw_(integer *, complex *, integer *, complex *, integer *, complex *);
-
-  /* Parameter adjustments */
-  --cy;
-  --cx;
-
-  /* Function Body */
-  cdotuw_(n, &cx[1], incx, &cy[1], incy, &res);
-  return res;
-} /* cdotu_ */
-
-doublecomplex zdotc_(integer *n, doublecomplex *cx, integer *incx, doublecomplex *cy, integer *incy) {
-  doublecomplex res;
-  extern /* Subroutine */ void zdotcw_(integer *, doublecomplex *, integer *, doublecomplex *, integer *,
-                                       doublecomplex *);
-
-  /* Parameter adjustments */
-  --cy;
-  --cx;
-
-  /* Function Body */
-  zdotcw_(n, &cx[1], incx, &cy[1], incy, &res);
-  return res;
-} /* zdotc_ */
-
-doublecomplex zdotu_(integer *n, doublecomplex *cx, integer *incx, doublecomplex *cy, integer *incy) {
-  doublecomplex res;
-  extern /* Subroutine */ void zdotuw_(integer *, doublecomplex *, integer *, doublecomplex *, integer *,
-                                       doublecomplex *);
-
-  /* Parameter adjustments */
-  --cy;
-  --cx;
-
-  /* Function Body */
-  zdotuw_(n, &cx[1], incx, &cy[1], incy, &res);
-  return res;
-} /* zdotu_ */
diff --git a/blas/f2c/ctbmv.c b/blas/f2c/ctbmv.c
deleted file mode 100644
index 2c0ce9b..0000000
--- a/blas/f2c/ctbmv.c
+++ /dev/null
@@ -1,586 +0,0 @@
-/* ctbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-static inline void r_cnjg(complex *r, complex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void ctbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, complex *a, integer *lda,
-                             complex *x, integer *incx) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
-  complex q__1, q__2, q__3;
-
-  /* Local variables */
-  integer i__, j, l, ix, jx, kx, info;
-  complex temp;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-  logical noconj, nounit;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CTBMV  performs one of the matrix-vector operations */
-
-  /*     x := A*x,   or   x := A'*x,   or   x := conjg( A' )*x, */
-
-  /*  where x is an n element vector and  A is an n by n unit, or non-unit, */
-  /*  upper or lower triangular band matrix, with ( k + 1 ) diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the matrix is an upper or */
-  /*           lower triangular matrix as follows: */
-
-  /*              UPLO = 'U' or 'u'   A is an upper triangular matrix. */
-
-  /*              UPLO = 'L' or 'l'   A is a lower triangular matrix. */
-
-  /*           Unchanged on exit. */
-
-  /*  TRANS  - CHARACTER*1. */
-  /*           On entry, TRANS specifies the operation to be performed as */
-  /*           follows: */
-
-  /*              TRANS = 'N' or 'n'   x := A*x. */
-
-  /*              TRANS = 'T' or 't'   x := A'*x. */
-
-  /*              TRANS = 'C' or 'c'   x := conjg( A' )*x. */
-
-  /*           Unchanged on exit. */
-
-  /*  DIAG   - CHARACTER*1. */
-  /*           On entry, DIAG specifies whether or not A is unit */
-  /*           triangular as follows: */
-
-  /*              DIAG = 'U' or 'u'   A is assumed to be unit triangular. */
-
-  /*              DIAG = 'N' or 'n'   A is not assumed to be unit */
-  /*                                  triangular. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry with UPLO = 'U' or 'u', K specifies the number of */
-  /*           super-diagonals of the matrix A. */
-  /*           On entry with UPLO = 'L' or 'l', K specifies the number of */
-  /*           sub-diagonals of the matrix A. */
-  /*           K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  A      - COMPLEX          array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer an upper */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer a lower */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Note that when DIAG = 'U' or 'u' the elements of the array A */
-  /*           corresponding to the diagonal elements of the matrix are not */
-  /*           referenced, but are assumed to be unity. */
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - COMPLEX          array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. On exit, X is overwritten with the */
-  /*           transformed vector x. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (!lsame_(trans, "N") && !lsame_(trans, "T") && !lsame_(trans, "C")) {
-    info = 2;
-  } else if (!lsame_(diag, "U") && !lsame_(diag, "N")) {
-    info = 3;
-  } else if (*n < 0) {
-    info = 4;
-  } else if (*k < 0) {
-    info = 5;
-  } else if (*lda < *k + 1) {
-    info = 7;
-  } else if (*incx == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("CTBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0) {
-    return;
-  }
-
-  noconj = lsame_(trans, "T");
-  nounit = lsame_(diag, "N");
-
-  /*     Set up the start point in X if the increment is not unity. This */
-  /*     will be  ( N - 1 )*INCX   too small for descending loops. */
-
-  if (*incx <= 0) {
-    kx = 1 - (*n - 1) * *incx;
-  } else if (*incx != 1) {
-    kx = 1;
-  }
-
-  /*     Start the operations. In this version the elements of A are */
-  /*     accessed sequentially with one pass through A. */
-
-  if (lsame_(trans, "N")) {
-    /*         Form  x := A*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = j;
-          if (x[i__2].r != 0.f || x[i__2].i != 0.f) {
-            i__2 = j;
-            temp.r = x[i__2].r, temp.i = x[i__2].i;
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__2 = 1, i__3 = j - *k;
-            i__4 = j - 1;
-            for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-              i__2 = i__;
-              i__3 = i__;
-              i__5 = l + i__ + j * a_dim1;
-              q__2.r = temp.r * a[i__5].r - temp.i * a[i__5].i, q__2.i = temp.r * a[i__5].i + temp.i * a[i__5].r;
-              q__1.r = x[i__3].r + q__2.r, q__1.i = x[i__3].i + q__2.i;
-              x[i__2].r = q__1.r, x[i__2].i = q__1.i;
-              /* L10: */
-            }
-            if (nounit) {
-              i__4 = j;
-              i__2 = j;
-              i__3 = kplus1 + j * a_dim1;
-              q__1.r = x[i__2].r * a[i__3].r - x[i__2].i * a[i__3].i,
-              q__1.i = x[i__2].r * a[i__3].i + x[i__2].i * a[i__3].r;
-              x[i__4].r = q__1.r, x[i__4].i = q__1.i;
-            }
-          }
-          /* L20: */
-        }
-      } else {
-        jx = kx;
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          i__4 = jx;
-          if (x[i__4].r != 0.f || x[i__4].i != 0.f) {
-            i__4 = jx;
-            temp.r = x[i__4].r, temp.i = x[i__4].i;
-            ix = kx;
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__4 = 1, i__2 = j - *k;
-            i__3 = j - 1;
-            for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-              i__4 = ix;
-              i__2 = ix;
-              i__5 = l + i__ + j * a_dim1;
-              q__2.r = temp.r * a[i__5].r - temp.i * a[i__5].i, q__2.i = temp.r * a[i__5].i + temp.i * a[i__5].r;
-              q__1.r = x[i__2].r + q__2.r, q__1.i = x[i__2].i + q__2.i;
-              x[i__4].r = q__1.r, x[i__4].i = q__1.i;
-              ix += *incx;
-              /* L30: */
-            }
-            if (nounit) {
-              i__3 = jx;
-              i__4 = jx;
-              i__2 = kplus1 + j * a_dim1;
-              q__1.r = x[i__4].r * a[i__2].r - x[i__4].i * a[i__2].i,
-              q__1.i = x[i__4].r * a[i__2].i + x[i__4].i * a[i__2].r;
-              x[i__3].r = q__1.r, x[i__3].i = q__1.i;
-            }
-          }
-          jx += *incx;
-          if (j > *k) {
-            kx += *incx;
-          }
-          /* L40: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          i__1 = j;
-          if (x[i__1].r != 0.f || x[i__1].i != 0.f) {
-            i__1 = j;
-            temp.r = x[i__1].r, temp.i = x[i__1].i;
-            l = 1 - j;
-            /* Computing MIN */
-            i__1 = *n, i__3 = j + *k;
-            i__4 = j + 1;
-            for (i__ = min(i__1, i__3); i__ >= i__4; --i__) {
-              i__1 = i__;
-              i__3 = i__;
-              i__2 = l + i__ + j * a_dim1;
-              q__2.r = temp.r * a[i__2].r - temp.i * a[i__2].i, q__2.i = temp.r * a[i__2].i + temp.i * a[i__2].r;
-              q__1.r = x[i__3].r + q__2.r, q__1.i = x[i__3].i + q__2.i;
-              x[i__1].r = q__1.r, x[i__1].i = q__1.i;
-              /* L50: */
-            }
-            if (nounit) {
-              i__4 = j;
-              i__1 = j;
-              i__3 = j * a_dim1 + 1;
-              q__1.r = x[i__1].r * a[i__3].r - x[i__1].i * a[i__3].i,
-              q__1.i = x[i__1].r * a[i__3].i + x[i__1].i * a[i__3].r;
-              x[i__4].r = q__1.r, x[i__4].i = q__1.i;
-            }
-          }
-          /* L60: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          i__4 = jx;
-          if (x[i__4].r != 0.f || x[i__4].i != 0.f) {
-            i__4 = jx;
-            temp.r = x[i__4].r, temp.i = x[i__4].i;
-            ix = kx;
-            l = 1 - j;
-            /* Computing MIN */
-            i__4 = *n, i__1 = j + *k;
-            i__3 = j + 1;
-            for (i__ = min(i__4, i__1); i__ >= i__3; --i__) {
-              i__4 = ix;
-              i__1 = ix;
-              i__2 = l + i__ + j * a_dim1;
-              q__2.r = temp.r * a[i__2].r - temp.i * a[i__2].i, q__2.i = temp.r * a[i__2].i + temp.i * a[i__2].r;
-              q__1.r = x[i__1].r + q__2.r, q__1.i = x[i__1].i + q__2.i;
-              x[i__4].r = q__1.r, x[i__4].i = q__1.i;
-              ix -= *incx;
-              /* L70: */
-            }
-            if (nounit) {
-              i__3 = jx;
-              i__4 = jx;
-              i__1 = j * a_dim1 + 1;
-              q__1.r = x[i__4].r * a[i__1].r - x[i__4].i * a[i__1].i,
-              q__1.i = x[i__4].r * a[i__1].i + x[i__4].i * a[i__1].r;
-              x[i__3].r = q__1.r, x[i__3].i = q__1.i;
-            }
-          }
-          jx -= *incx;
-          if (*n - j >= *k) {
-            kx -= *incx;
-          }
-          /* L80: */
-        }
-      }
-    }
-  } else {
-    /*        Form  x := A'*x  or  x := conjg( A' )*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          i__3 = j;
-          temp.r = x[i__3].r, temp.i = x[i__3].i;
-          l = kplus1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__3 = kplus1 + j * a_dim1;
-              q__1.r = temp.r * a[i__3].r - temp.i * a[i__3].i, q__1.i = temp.r * a[i__3].i + temp.i * a[i__3].r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              i__4 = l + i__ + j * a_dim1;
-              i__1 = i__;
-              q__2.r = a[i__4].r * x[i__1].r - a[i__4].i * x[i__1].i,
-              q__2.i = a[i__4].r * x[i__1].i + a[i__4].i * x[i__1].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              /* L90: */
-            }
-          } else {
-            if (nounit) {
-              r_cnjg(&q__2, &a[kplus1 + j * a_dim1]);
-              q__1.r = temp.r * q__2.r - temp.i * q__2.i, q__1.i = temp.r * q__2.i + temp.i * q__2.r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-              i__4 = i__;
-              q__2.r = q__3.r * x[i__4].r - q__3.i * x[i__4].i, q__2.i = q__3.r * x[i__4].i + q__3.i * x[i__4].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              /* L100: */
-            }
-          }
-          i__3 = j;
-          x[i__3].r = temp.r, x[i__3].i = temp.i;
-          /* L110: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          i__3 = jx;
-          temp.r = x[i__3].r, temp.i = x[i__3].i;
-          kx -= *incx;
-          ix = kx;
-          l = kplus1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__3 = kplus1 + j * a_dim1;
-              q__1.r = temp.r * a[i__3].r - temp.i * a[i__3].i, q__1.i = temp.r * a[i__3].i + temp.i * a[i__3].r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              i__4 = l + i__ + j * a_dim1;
-              i__1 = ix;
-              q__2.r = a[i__4].r * x[i__1].r - a[i__4].i * x[i__1].i,
-              q__2.i = a[i__4].r * x[i__1].i + a[i__4].i * x[i__1].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              ix -= *incx;
-              /* L120: */
-            }
-          } else {
-            if (nounit) {
-              r_cnjg(&q__2, &a[kplus1 + j * a_dim1]);
-              q__1.r = temp.r * q__2.r - temp.i * q__2.i, q__1.i = temp.r * q__2.i + temp.i * q__2.r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-              i__4 = ix;
-              q__2.r = q__3.r * x[i__4].r - q__3.i * x[i__4].i, q__2.i = q__3.r * x[i__4].i + q__3.i * x[i__4].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              ix -= *incx;
-              /* L130: */
-            }
-          }
-          i__3 = jx;
-          x[i__3].r = temp.r, x[i__3].i = temp.i;
-          jx -= *incx;
-          /* L140: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          i__4 = j;
-          temp.r = x[i__4].r, temp.i = x[i__4].i;
-          l = 1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__4 = j * a_dim1 + 1;
-              q__1.r = temp.r * a[i__4].r - temp.i * a[i__4].i, q__1.i = temp.r * a[i__4].i + temp.i * a[i__4].r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              i__1 = l + i__ + j * a_dim1;
-              i__2 = i__;
-              q__2.r = a[i__1].r * x[i__2].r - a[i__1].i * x[i__2].i,
-              q__2.i = a[i__1].r * x[i__2].i + a[i__1].i * x[i__2].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              /* L150: */
-            }
-          } else {
-            if (nounit) {
-              r_cnjg(&q__2, &a[j * a_dim1 + 1]);
-              q__1.r = temp.r * q__2.r - temp.i * q__2.i, q__1.i = temp.r * q__2.i + temp.i * q__2.r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-              i__1 = i__;
-              q__2.r = q__3.r * x[i__1].r - q__3.i * x[i__1].i, q__2.i = q__3.r * x[i__1].i + q__3.i * x[i__1].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              /* L160: */
-            }
-          }
-          i__4 = j;
-          x[i__4].r = temp.r, x[i__4].i = temp.i;
-          /* L170: */
-        }
-      } else {
-        jx = kx;
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          i__4 = jx;
-          temp.r = x[i__4].r, temp.i = x[i__4].i;
-          kx += *incx;
-          ix = kx;
-          l = 1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__4 = j * a_dim1 + 1;
-              q__1.r = temp.r * a[i__4].r - temp.i * a[i__4].i, q__1.i = temp.r * a[i__4].i + temp.i * a[i__4].r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              i__1 = l + i__ + j * a_dim1;
-              i__2 = ix;
-              q__2.r = a[i__1].r * x[i__2].r - a[i__1].i * x[i__2].i,
-              q__2.i = a[i__1].r * x[i__2].i + a[i__1].i * x[i__2].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              ix += *incx;
-              /* L180: */
-            }
-          } else {
-            if (nounit) {
-              r_cnjg(&q__2, &a[j * a_dim1 + 1]);
-              q__1.r = temp.r * q__2.r - temp.i * q__2.i, q__1.i = temp.r * q__2.i + temp.i * q__2.r;
-              temp.r = q__1.r, temp.i = q__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              r_cnjg(&q__3, &a[l + i__ + j * a_dim1]);
-              i__1 = ix;
-              q__2.r = q__3.r * x[i__1].r - q__3.i * x[i__1].i, q__2.i = q__3.r * x[i__1].i + q__3.i * x[i__1].r;
-              q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
-              temp.r = q__1.r, temp.i = q__1.i;
-              ix += *incx;
-              /* L190: */
-            }
-          }
-          i__4 = jx;
-          x[i__4].r = temp.r, x[i__4].i = temp.i;
-          jx += *incx;
-          /* L200: */
-        }
-      }
-    }
-  }
-
-  /*     End of CTBMV . */
-
-} /* ctbmv_ */
diff --git a/blas/f2c/datatypes.h b/blas/f2c/datatypes.h
deleted file mode 100644
index 45b108d..0000000
--- a/blas/f2c/datatypes.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* This contains a limited subset of the typedefs exposed by f2c
-   for use by the Eigen BLAS C-only implementation.
-*/
-
-#ifndef __EIGEN_DATATYPES_H__
-#define __EIGEN_DATATYPES_H__
-
-typedef int integer;
-typedef unsigned int uinteger;
-typedef float real;
-typedef double doublereal;
-typedef struct {
-  real r, i;
-} complex;
-typedef struct {
-  doublereal r, i;
-} doublecomplex;
-typedef int logical;
-
-#define abs(x) ((x) >= 0 ? (x) : -(x))
-#define dabs(x) (doublereal) abs(x)
-#define min(a, b) ((a) <= (b) ? (a) : (b))
-#define max(a, b) ((a) >= (b) ? (a) : (b))
-#define dmin(a, b) (doublereal) min(a, b)
-#define dmax(a, b) (doublereal) max(a, b)
-
-#endif
diff --git a/blas/f2c/drotm.c b/blas/f2c/drotm.c
deleted file mode 100644
index da82317..0000000
--- a/blas/f2c/drotm.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/* drotm.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void drotm_(integer *n, doublereal *dx, integer *incx, doublereal *dy, integer *incy,
-                             doublereal *dparam) {
-  /* Initialized data */
-
-  static doublereal zero = 0.;
-  static doublereal two = 2.;
-
-  /* System generated locals */
-  integer i__1, i__2;
-
-  /* Local variables */
-  integer i__;
-  doublereal w, z__;
-  integer kx, ky;
-  doublereal dh11, dh12, dh21, dh22, dflag;
-  integer nsteps;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*     APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX */
-
-  /*     (DX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN */
-  /*     (DY**T) */
-
-  /*     DX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX .GE. 0, ELSE */
-  /*     LX = (-INCX)*N, AND SIMILARLY FOR SY USING LY AND INCY. */
-  /*     WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. */
-
-  /*     DFLAG=-1.D0     DFLAG=0.D0        DFLAG=1.D0     DFLAG=-2.D0 */
-
-  /*       (DH11  DH12)    (1.D0  DH12)    (DH11  1.D0)    (1.D0  0.D0) */
-  /*     H=(          )    (          )    (          )    (          ) */
-  /*       (DH21  DH22),   (DH21  1.D0),   (-1.D0 DH22),   (0.D0  1.D0). */
-  /*     SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N      (input) INTEGER */
-  /*         number of elements in input vector(s) */
-
-  /*  DX     (input/output) DOUBLE PRECISION array, dimension N */
-  /*         double precision vector with N elements */
-
-  /*  INCX   (input) INTEGER */
-  /*         storage spacing between elements of DX */
-
-  /*  DY     (input/output) DOUBLE PRECISION array, dimension N */
-  /*         double precision vector with N elements */
-
-  /*  INCY   (input) INTEGER */
-  /*         storage spacing between elements of DY */
-
-  /*  DPARAM (input/output)  DOUBLE PRECISION array, dimension 5 */
-  /*     DPARAM(1)=DFLAG */
-  /*     DPARAM(2)=DH11 */
-  /*     DPARAM(3)=DH21 */
-  /*     DPARAM(4)=DH12 */
-  /*     DPARAM(5)=DH22 */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /* Parameter adjustments */
-  --dparam;
-  --dy;
-  --dx;
-
-  /* Function Body */
-  /*     .. */
-
-  dflag = dparam[1];
-  if (*n <= 0 || dflag + two == zero) {
-    goto L140;
-  }
-  if (!(*incx == *incy && *incx > 0)) {
-    goto L70;
-  }
-
-  nsteps = *n * *incx;
-  if (dflag < 0.) {
-    goto L50;
-  } else if (dflag == 0) {
-    goto L10;
-  } else {
-    goto L30;
-  }
-L10:
-  dh12 = dparam[4];
-  dh21 = dparam[3];
-  i__1 = nsteps;
-  i__2 = *incx;
-  for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
-    w = dx[i__];
-    z__ = dy[i__];
-    dx[i__] = w + z__ * dh12;
-    dy[i__] = w * dh21 + z__;
-    /* L20: */
-  }
-  goto L140;
-L30:
-  dh11 = dparam[2];
-  dh22 = dparam[5];
-  i__2 = nsteps;
-  i__1 = *incx;
-  for (i__ = 1; i__1 < 0 ? i__ >= i__2 : i__ <= i__2; i__ += i__1) {
-    w = dx[i__];
-    z__ = dy[i__];
-    dx[i__] = w * dh11 + z__;
-    dy[i__] = -w + dh22 * z__;
-    /* L40: */
-  }
-  goto L140;
-L50:
-  dh11 = dparam[2];
-  dh12 = dparam[4];
-  dh21 = dparam[3];
-  dh22 = dparam[5];
-  i__1 = nsteps;
-  i__2 = *incx;
-  for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
-    w = dx[i__];
-    z__ = dy[i__];
-    dx[i__] = w * dh11 + z__ * dh12;
-    dy[i__] = w * dh21 + z__ * dh22;
-    /* L60: */
-  }
-  goto L140;
-L70:
-  kx = 1;
-  ky = 1;
-  if (*incx < 0) {
-    kx = (1 - *n) * *incx + 1;
-  }
-  if (*incy < 0) {
-    ky = (1 - *n) * *incy + 1;
-  }
-
-  if (dflag < 0.) {
-    goto L120;
-  } else if (dflag == 0) {
-    goto L80;
-  } else {
-    goto L100;
-  }
-L80:
-  dh12 = dparam[4];
-  dh21 = dparam[3];
-  i__2 = *n;
-  for (i__ = 1; i__ <= i__2; ++i__) {
-    w = dx[kx];
-    z__ = dy[ky];
-    dx[kx] = w + z__ * dh12;
-    dy[ky] = w * dh21 + z__;
-    kx += *incx;
-    ky += *incy;
-    /* L90: */
-  }
-  goto L140;
-L100:
-  dh11 = dparam[2];
-  dh22 = dparam[5];
-  i__2 = *n;
-  for (i__ = 1; i__ <= i__2; ++i__) {
-    w = dx[kx];
-    z__ = dy[ky];
-    dx[kx] = w * dh11 + z__;
-    dy[ky] = -w + dh22 * z__;
-    kx += *incx;
-    ky += *incy;
-    /* L110: */
-  }
-  goto L140;
-L120:
-  dh11 = dparam[2];
-  dh12 = dparam[4];
-  dh21 = dparam[3];
-  dh22 = dparam[5];
-  i__2 = *n;
-  for (i__ = 1; i__ <= i__2; ++i__) {
-    w = dx[kx];
-    z__ = dy[ky];
-    dx[kx] = w * dh11 + z__ * dh12;
-    dy[ky] = w * dh21 + z__ * dh22;
-    kx += *incx;
-    ky += *incy;
-    /* L130: */
-  }
-L140:
-  return;
-} /* drotm_ */
diff --git a/blas/f2c/drotmg.c b/blas/f2c/drotmg.c
deleted file mode 100644
index 81233cb..0000000
--- a/blas/f2c/drotmg.c
+++ /dev/null
@@ -1,293 +0,0 @@
-/* drotmg.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void drotmg_(doublereal *dd1, doublereal *dd2, doublereal *dx1, doublereal *dy1, doublereal *dparam) {
-  /* Initialized data */
-
-  static doublereal zero = 0.;
-  static doublereal one = 1.;
-  static doublereal two = 2.;
-  static doublereal gam = 4096.;
-  static doublereal gamsq = 16777216.;
-  static doublereal rgamsq = 5.9604645e-8;
-
-  /* Format strings */
-  static char fmt_120[] = "";
-  static char fmt_150[] = "";
-  static char fmt_180[] = "";
-  static char fmt_210[] = "";
-
-  /* System generated locals */
-  doublereal d__1;
-
-  /* Local variables */
-  doublereal du, dp1, dp2, dq1, dq2, dh11, dh12, dh21, dh22;
-  integer igo;
-  doublereal dflag, dtemp;
-
-  /* Assigned format variables */
-  static char *igo_fmt;
-  (void)igo_fmt;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*     CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS */
-  /*     THE SECOND COMPONENT OF THE 2-VECTOR  (DSQRT(DD1)*DX1,DSQRT(DD2)* */
-  /*     DY2)**T. */
-  /*     WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. */
-
-  /*     DFLAG=-1.D0     DFLAG=0.D0        DFLAG=1.D0     DFLAG=-2.D0 */
-
-  /*       (DH11  DH12)    (1.D0  DH12)    (DH11  1.D0)    (1.D0  0.D0) */
-  /*     H=(          )    (          )    (          )    (          ) */
-  /*       (DH21  DH22),   (DH21  1.D0),   (-1.D0 DH22),   (0.D0  1.D0). */
-  /*     LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22 */
-  /*     RESPECTIVELY. (VALUES OF 1.D0, -1.D0, OR 0.D0 IMPLIED BY THE */
-  /*     VALUE OF DPARAM(1) ARE NOT STORED IN DPARAM.) */
-
-  /*     THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE */
-  /*     INEXACT.  THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE */
-  /*     OF DD1 AND DD2.  ALL ACTUAL SCALING OF DATA IS DONE USING GAM. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  DD1    (input/output) DOUBLE PRECISION */
-
-  /*  DD2    (input/output) DOUBLE PRECISION */
-
-  /*  DX1    (input/output) DOUBLE PRECISION */
-
-  /*  DY1    (input) DOUBLE PRECISION */
-
-  /*  DPARAM (input/output)  DOUBLE PRECISION array, dimension 5 */
-  /*     DPARAM(1)=DFLAG */
-  /*     DPARAM(2)=DH11 */
-  /*     DPARAM(3)=DH21 */
-  /*     DPARAM(4)=DH12 */
-  /*     DPARAM(5)=DH22 */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Data statements .. */
-
-  /* Parameter adjustments */
-  --dparam;
-
-  /* Function Body */
-  /*     .. */
-  if (!(*dd1 < zero)) {
-    goto L10;
-  }
-  /*       GO ZERO-H-D-AND-DX1.. */
-  goto L60;
-L10:
-  /*     CASE-DD1-NONNEGATIVE */
-  dp2 = *dd2 * *dy1;
-  if (!(dp2 == zero)) {
-    goto L20;
-  }
-  dflag = -two;
-  goto L260;
-/*     REGULAR-CASE.. */
-L20:
-  dp1 = *dd1 * *dx1;
-  dq2 = dp2 * *dy1;
-  dq1 = dp1 * *dx1;
-
-  if (!(abs(dq1) > abs(dq2))) {
-    goto L40;
-  }
-  dh21 = -(*dy1) / *dx1;
-  dh12 = dp2 / dp1;
-
-  du = one - dh12 * dh21;
-
-  if (!(du <= zero)) {
-    goto L30;
-  }
-  /*         GO ZERO-H-D-AND-DX1.. */
-  goto L60;
-L30:
-  dflag = zero;
-  *dd1 /= du;
-  *dd2 /= du;
-  *dx1 *= du;
-  /*         GO SCALE-CHECK.. */
-  goto L100;
-L40:
-  if (!(dq2 < zero)) {
-    goto L50;
-  }
-  /*         GO ZERO-H-D-AND-DX1.. */
-  goto L60;
-L50:
-  dflag = one;
-  dh11 = dp1 / dp2;
-  dh22 = *dx1 / *dy1;
-  du = one + dh11 * dh22;
-  dtemp = *dd2 / du;
-  *dd2 = *dd1 / du;
-  *dd1 = dtemp;
-  *dx1 = *dy1 * du;
-  /*         GO SCALE-CHECK */
-  goto L100;
-/*     PROCEDURE..ZERO-H-D-AND-DX1.. */
-L60:
-  dflag = -one;
-  dh11 = zero;
-  dh12 = zero;
-  dh21 = zero;
-  dh22 = zero;
-
-  *dd1 = zero;
-  *dd2 = zero;
-  *dx1 = zero;
-  /*         RETURN.. */
-  goto L220;
-/*     PROCEDURE..FIX-H.. */
-L70:
-  if (!(dflag >= zero)) {
-    goto L90;
-  }
-
-  if (!(dflag == zero)) {
-    goto L80;
-  }
-  dh11 = one;
-  dh22 = one;
-  dflag = -one;
-  goto L90;
-L80:
-  dh21 = -one;
-  dh12 = one;
-  dflag = -one;
-L90:
-  switch (igo) {
-    case 0:
-      goto L120;
-    case 1:
-      goto L150;
-    case 2:
-      goto L180;
-    case 3:
-      goto L210;
-  }
-/*     PROCEDURE..SCALE-CHECK */
-L100:
-L110:
-  if (!(*dd1 <= rgamsq)) {
-    goto L130;
-  }
-  if (*dd1 == zero) {
-    goto L160;
-  }
-  igo = 0;
-  igo_fmt = fmt_120;
-  /*              FIX-H.. */
-  goto L70;
-L120:
-  /* Computing 2nd power */
-  d__1 = gam;
-  *dd1 *= d__1 * d__1;
-  *dx1 /= gam;
-  dh11 /= gam;
-  dh12 /= gam;
-  goto L110;
-L130:
-L140:
-  if (!(*dd1 >= gamsq)) {
-    goto L160;
-  }
-  igo = 1;
-  igo_fmt = fmt_150;
-  /*              FIX-H.. */
-  goto L70;
-L150:
-  /* Computing 2nd power */
-  d__1 = gam;
-  *dd1 /= d__1 * d__1;
-  *dx1 *= gam;
-  dh11 *= gam;
-  dh12 *= gam;
-  goto L140;
-L160:
-L170:
-  if (!(abs(*dd2) <= rgamsq)) {
-    goto L190;
-  }
-  if (*dd2 == zero) {
-    goto L220;
-  }
-  igo = 2;
-  igo_fmt = fmt_180;
-  /*              FIX-H.. */
-  goto L70;
-L180:
-  /* Computing 2nd power */
-  d__1 = gam;
-  *dd2 *= d__1 * d__1;
-  dh21 /= gam;
-  dh22 /= gam;
-  goto L170;
-L190:
-L200:
-  if (!(abs(*dd2) >= gamsq)) {
-    goto L220;
-  }
-  igo = 3;
-  igo_fmt = fmt_210;
-  /*              FIX-H.. */
-  goto L70;
-L210:
-  /* Computing 2nd power */
-  d__1 = gam;
-  *dd2 /= d__1 * d__1;
-  dh21 *= gam;
-  dh22 *= gam;
-  goto L200;
-L220:
-  if (dflag < 0.) {
-    goto L250;
-  } else if (dflag == 0) {
-    goto L230;
-  } else {
-    goto L240;
-  }
-L230:
-  dparam[3] = dh21;
-  dparam[4] = dh12;
-  goto L260;
-L240:
-  dparam[2] = dh11;
-  dparam[5] = dh22;
-  goto L260;
-L250:
-  dparam[2] = dh11;
-  dparam[3] = dh21;
-  dparam[4] = dh12;
-  dparam[5] = dh22;
-L260:
-  dparam[1] = dflag;
-} /* drotmg_ */
diff --git a/blas/f2c/dsbmv.c b/blas/f2c/dsbmv.c
deleted file mode 100644
index 4619369..0000000
--- a/blas/f2c/dsbmv.c
+++ /dev/null
@@ -1,356 +0,0 @@
-/* dsbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void dsbmv_(char *uplo, integer *n, integer *k, doublereal *alpha, doublereal *a, integer *lda,
-                             doublereal *x, integer *incx, doublereal *beta, doublereal *y, integer *incy) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
-
-  /* Local variables */
-  integer i__, j, l, ix, iy, jx, jy, kx, ky, info;
-  doublereal temp1, temp2;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DSBMV  performs the matrix-vector  operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n symmetric band matrix, with k super-diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the band matrix A is being supplied as */
-  /*           follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  being supplied. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  being supplied. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry, K specifies the number of super-diagonals of the */
-  /*           matrix A. K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - DOUBLE PRECISION. */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  A      - DOUBLE PRECISION array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the symmetric matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer the upper */
-  /*           triangular part of a symmetric band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the symmetric matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer the lower */
-  /*           triangular part of a symmetric band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - DOUBLE PRECISION array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the */
-  /*           vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - DOUBLE PRECISION. */
-  /*           On entry, BETA specifies the scalar beta. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - DOUBLE PRECISION array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the */
-  /*           vector y. On exit, Y is overwritten by the updated vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-  --y;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*k < 0) {
-    info = 3;
-  } else if (*lda < *k + 1) {
-    info = 6;
-  } else if (*incx == 0) {
-    info = 8;
-  } else if (*incy == 0) {
-    info = 11;
-  }
-  if (info != 0) {
-    xerbla_("DSBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (*alpha == 0. && *beta == 1.)) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array A */
-  /*     are accessed sequentially with one pass through A. */
-
-  /*     First form  y := beta*y. */
-
-  if (*beta != 1.) {
-    if (*incy == 1) {
-      if (*beta == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = 0.;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = *beta * y[i__];
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (*beta == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = 0.;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = *beta * y[iy];
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (*alpha == 0.) {
-    return;
-  }
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when upper triangle of A is stored. */
-
-    kplus1 = *k + 1;
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__2 = 1, i__3 = j - *k;
-        i__4 = j - 1;
-        for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-          y[i__] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[i__];
-          /* L50: */
-        }
-        y[j] = y[j] + temp1 * a[kplus1 + j * a_dim1] + *alpha * temp2;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.;
-        ix = kx;
-        iy = ky;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__4 = 1, i__2 = j - *k;
-        i__3 = j - 1;
-        for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-          y[iy] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[ix];
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        y[jy] = y[jy] + temp1 * a[kplus1 + j * a_dim1] + *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        if (j > *k) {
-          kx += *incx;
-          ky += *incy;
-        }
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when lower triangle of A is stored. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.;
-        y[j] += temp1 * a[j * a_dim1 + 1];
-        l = 1 - j;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          y[i__] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[i__];
-          /* L90: */
-        }
-        y[j] += *alpha * temp2;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.;
-        y[jy] += temp1 * a[j * a_dim1 + 1];
-        l = 1 - j;
-        ix = jx;
-        iy = jy;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          ix += *incx;
-          iy += *incy;
-          y[iy] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[ix];
-          /* L110: */
-        }
-        y[jy] += *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of DSBMV . */
-
-} /* dsbmv_ */
diff --git a/blas/f2c/dspmv.c b/blas/f2c/dspmv.c
deleted file mode 100644
index 314d67b..0000000
--- a/blas/f2c/dspmv.c
+++ /dev/null
@@ -1,308 +0,0 @@
-/* dspmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void dspmv_(char *uplo, integer *n, doublereal *alpha, doublereal *ap, doublereal *x, integer *incx,
-                             doublereal *beta, doublereal *y, integer *incy) {
-  /* System generated locals */
-  integer i__1, i__2;
-
-  /* Local variables */
-  integer i__, j, k, kk, ix, iy, jx, jy, kx, ky, info;
-  doublereal temp1, temp2;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DSPMV  performs the matrix-vector operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n symmetric matrix, supplied in packed form. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the matrix A is supplied in the packed */
-  /*           array AP as follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - DOUBLE PRECISION. */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  AP     - DOUBLE PRECISION array of DIMENSION at least */
-  /*           ( ( n*( n + 1 ) )/2 ). */
-  /*           Before entry with UPLO = 'U' or 'u', the array AP must */
-  /*           contain the upper triangular part of the symmetric matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) */
-  /*           and a( 2, 2 ) respectively, and so on. */
-  /*           Before entry with UPLO = 'L' or 'l', the array AP must */
-  /*           contain the lower triangular part of the symmetric matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) */
-  /*           and a( 3, 1 ) respectively, and so on. */
-  /*           Unchanged on exit. */
-
-  /*  X      - DOUBLE PRECISION array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - DOUBLE PRECISION. */
-  /*           On entry, BETA specifies the scalar beta. When BETA is */
-  /*           supplied as zero then Y need not be set on input. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - DOUBLE PRECISION array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the n */
-  /*           element vector y. On exit, Y is overwritten by the updated */
-  /*           vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  --y;
-  --x;
-  --ap;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*incx == 0) {
-    info = 6;
-  } else if (*incy == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("DSPMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (*alpha == 0. && *beta == 1.)) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array AP */
-  /*     are accessed sequentially with one pass through AP. */
-
-  /*     First form  y := beta*y. */
-
-  if (*beta != 1.) {
-    if (*incy == 1) {
-      if (*beta == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = 0.;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = *beta * y[i__];
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (*beta == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = 0.;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = *beta * y[iy];
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (*alpha == 0.) {
-    return;
-  }
-  kk = 1;
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when AP contains the upper triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.;
-        k = kk;
-        i__2 = j - 1;
-        for (i__ = 1; i__ <= i__2; ++i__) {
-          y[i__] += temp1 * ap[k];
-          temp2 += ap[k] * x[i__];
-          ++k;
-          /* L50: */
-        }
-        y[j] = y[j] + temp1 * ap[kk + j - 1] + *alpha * temp2;
-        kk += j;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.;
-        ix = kx;
-        iy = ky;
-        i__2 = kk + j - 2;
-        for (k = kk; k <= i__2; ++k) {
-          y[iy] += temp1 * ap[k];
-          temp2 += ap[k] * x[ix];
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        y[jy] = y[jy] + temp1 * ap[kk + j - 1] + *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        kk += j;
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when AP contains the lower triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.;
-        y[j] += temp1 * ap[kk];
-        k = kk + 1;
-        i__2 = *n;
-        for (i__ = j + 1; i__ <= i__2; ++i__) {
-          y[i__] += temp1 * ap[k];
-          temp2 += ap[k] * x[i__];
-          ++k;
-          /* L90: */
-        }
-        y[j] += *alpha * temp2;
-        kk += *n - j + 1;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.;
-        y[jy] += temp1 * ap[kk];
-        ix = jx;
-        iy = jy;
-        i__2 = kk + *n - j;
-        for (k = kk + 1; k <= i__2; ++k) {
-          ix += *incx;
-          iy += *incy;
-          y[iy] += temp1 * ap[k];
-          temp2 += ap[k] * x[ix];
-          /* L110: */
-        }
-        y[jy] += *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        kk += *n - j + 1;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of DSPMV . */
-
-} /* dspmv_ */
diff --git a/blas/f2c/dtbmv.c b/blas/f2c/dtbmv.c
deleted file mode 100644
index 92a0aec..0000000
--- a/blas/f2c/dtbmv.c
+++ /dev/null
@@ -1,417 +0,0 @@
-/* dtbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void dtbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, doublereal *a, integer *lda,
-                             doublereal *x, integer *incx) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
-
-  /* Local variables */
-  integer i__, j, l, ix, jx, kx, info;
-  doublereal temp;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-  logical nounit;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DTBMV  performs one of the matrix-vector operations */
-
-  /*     x := A*x,   or   x := A'*x, */
-
-  /*  where x is an n element vector and  A is an n by n unit, or non-unit, */
-  /*  upper or lower triangular band matrix, with ( k + 1 ) diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the matrix is an upper or */
-  /*           lower triangular matrix as follows: */
-
-  /*              UPLO = 'U' or 'u'   A is an upper triangular matrix. */
-
-  /*              UPLO = 'L' or 'l'   A is a lower triangular matrix. */
-
-  /*           Unchanged on exit. */
-
-  /*  TRANS  - CHARACTER*1. */
-  /*           On entry, TRANS specifies the operation to be performed as */
-  /*           follows: */
-
-  /*              TRANS = 'N' or 'n'   x := A*x. */
-
-  /*              TRANS = 'T' or 't'   x := A'*x. */
-
-  /*              TRANS = 'C' or 'c'   x := A'*x. */
-
-  /*           Unchanged on exit. */
-
-  /*  DIAG   - CHARACTER*1. */
-  /*           On entry, DIAG specifies whether or not A is unit */
-  /*           triangular as follows: */
-
-  /*              DIAG = 'U' or 'u'   A is assumed to be unit triangular. */
-
-  /*              DIAG = 'N' or 'n'   A is not assumed to be unit */
-  /*                                  triangular. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry with UPLO = 'U' or 'u', K specifies the number of */
-  /*           super-diagonals of the matrix A. */
-  /*           On entry with UPLO = 'L' or 'l', K specifies the number of */
-  /*           sub-diagonals of the matrix A. */
-  /*           K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  A      - DOUBLE PRECISION array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer an upper */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer a lower */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Note that when DIAG = 'U' or 'u' the elements of the array A */
-  /*           corresponding to the diagonal elements of the matrix are not */
-  /*           referenced, but are assumed to be unity. */
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - DOUBLE PRECISION array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. On exit, X is overwritten with the */
-  /*           transformed vector x. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (!lsame_(trans, "N") && !lsame_(trans, "T") && !lsame_(trans, "C")) {
-    info = 2;
-  } else if (!lsame_(diag, "U") && !lsame_(diag, "N")) {
-    info = 3;
-  } else if (*n < 0) {
-    info = 4;
-  } else if (*k < 0) {
-    info = 5;
-  } else if (*lda < *k + 1) {
-    info = 7;
-  } else if (*incx == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("DTBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0) {
-    return;
-  }
-
-  nounit = lsame_(diag, "N");
-
-  /*     Set up the start point in X if the increment is not unity. This */
-  /*     will be  ( N - 1 )*INCX   too small for descending loops. */
-
-  if (*incx <= 0) {
-    kx = 1 - (*n - 1) * *incx;
-  } else if (*incx != 1) {
-    kx = 1;
-  }
-
-  /*     Start the operations. In this version the elements of A are */
-  /*     accessed sequentially with one pass through A. */
-
-  if (lsame_(trans, "N")) {
-    /*         Form  x := A*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          if (x[j] != 0.) {
-            temp = x[j];
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__2 = 1, i__3 = j - *k;
-            i__4 = j - 1;
-            for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-              x[i__] += temp * a[l + i__ + j * a_dim1];
-              /* L10: */
-            }
-            if (nounit) {
-              x[j] *= a[kplus1 + j * a_dim1];
-            }
-          }
-          /* L20: */
-        }
-      } else {
-        jx = kx;
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          if (x[jx] != 0.) {
-            temp = x[jx];
-            ix = kx;
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__4 = 1, i__2 = j - *k;
-            i__3 = j - 1;
-            for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-              x[ix] += temp * a[l + i__ + j * a_dim1];
-              ix += *incx;
-              /* L30: */
-            }
-            if (nounit) {
-              x[jx] *= a[kplus1 + j * a_dim1];
-            }
-          }
-          jx += *incx;
-          if (j > *k) {
-            kx += *incx;
-          }
-          /* L40: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          if (x[j] != 0.) {
-            temp = x[j];
-            l = 1 - j;
-            /* Computing MIN */
-            i__1 = *n, i__3 = j + *k;
-            i__4 = j + 1;
-            for (i__ = min(i__1, i__3); i__ >= i__4; --i__) {
-              x[i__] += temp * a[l + i__ + j * a_dim1];
-              /* L50: */
-            }
-            if (nounit) {
-              x[j] *= a[j * a_dim1 + 1];
-            }
-          }
-          /* L60: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          if (x[jx] != 0.) {
-            temp = x[jx];
-            ix = kx;
-            l = 1 - j;
-            /* Computing MIN */
-            i__4 = *n, i__1 = j + *k;
-            i__3 = j + 1;
-            for (i__ = min(i__4, i__1); i__ >= i__3; --i__) {
-              x[ix] += temp * a[l + i__ + j * a_dim1];
-              ix -= *incx;
-              /* L70: */
-            }
-            if (nounit) {
-              x[jx] *= a[j * a_dim1 + 1];
-            }
-          }
-          jx -= *incx;
-          if (*n - j >= *k) {
-            kx -= *incx;
-          }
-          /* L80: */
-        }
-      }
-    }
-  } else {
-    /*        Form  x := A'*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          temp = x[j];
-          l = kplus1 - j;
-          if (nounit) {
-            temp *= a[kplus1 + j * a_dim1];
-          }
-          /* Computing MAX */
-          i__4 = 1, i__1 = j - *k;
-          i__3 = max(i__4, i__1);
-          for (i__ = j - 1; i__ >= i__3; --i__) {
-            temp += a[l + i__ + j * a_dim1] * x[i__];
-            /* L90: */
-          }
-          x[j] = temp;
-          /* L100: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          temp = x[jx];
-          kx -= *incx;
-          ix = kx;
-          l = kplus1 - j;
-          if (nounit) {
-            temp *= a[kplus1 + j * a_dim1];
-          }
-          /* Computing MAX */
-          i__4 = 1, i__1 = j - *k;
-          i__3 = max(i__4, i__1);
-          for (i__ = j - 1; i__ >= i__3; --i__) {
-            temp += a[l + i__ + j * a_dim1] * x[ix];
-            ix -= *incx;
-            /* L110: */
-          }
-          x[jx] = temp;
-          jx -= *incx;
-          /* L120: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          temp = x[j];
-          l = 1 - j;
-          if (nounit) {
-            temp *= a[j * a_dim1 + 1];
-          }
-          /* Computing MIN */
-          i__1 = *n, i__2 = j + *k;
-          i__4 = min(i__1, i__2);
-          for (i__ = j + 1; i__ <= i__4; ++i__) {
-            temp += a[l + i__ + j * a_dim1] * x[i__];
-            /* L130: */
-          }
-          x[j] = temp;
-          /* L140: */
-        }
-      } else {
-        jx = kx;
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          temp = x[jx];
-          kx += *incx;
-          ix = kx;
-          l = 1 - j;
-          if (nounit) {
-            temp *= a[j * a_dim1 + 1];
-          }
-          /* Computing MIN */
-          i__1 = *n, i__2 = j + *k;
-          i__4 = min(i__1, i__2);
-          for (i__ = j + 1; i__ <= i__4; ++i__) {
-            temp += a[l + i__ + j * a_dim1] * x[ix];
-            ix += *incx;
-            /* L150: */
-          }
-          x[jx] = temp;
-          jx += *incx;
-          /* L160: */
-        }
-      }
-    }
-  }
-
-  /*     End of DTBMV . */
-
-} /* dtbmv_ */
diff --git a/blas/f2c/lsame.c b/blas/f2c/lsame.c
deleted file mode 100644
index ad51ea1..0000000
--- a/blas/f2c/lsame.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/* lsame.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-logical lsame_(char *ca, char *cb) {
-  /* System generated locals */
-  logical ret_val;
-
-  /* Local variables */
-  integer inta, intb, zcode;
-
-  /*  -- LAPACK auxiliary routine (version 3.1) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  LSAME returns .TRUE. if CA is the same letter as CB regardless of */
-  /*  case. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  CA      (input) CHARACTER*1 */
-
-  /*  CB      (input) CHARACTER*1 */
-  /*          CA and CB specify the single characters to be compared. */
-
-  /* ===================================================================== */
-
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-
-  /*     Test if the characters are equal */
-
-  ret_val = *(unsigned char *)ca == *(unsigned char *)cb;
-  if (ret_val) {
-    return ret_val;
-  }
-
-  /*     Now test for equivalence if both characters are alphabetic. */
-
-  zcode = 'Z';
-
-  /*     Use 'Z' rather than 'A' so that ASCII can be detected on Prime */
-  /*     machines, on which ICHAR returns a value with bit 8 set. */
-  /*     ICHAR('A') on Prime machines returns 193 which is the same as */
-  /*     ICHAR('A') on an EBCDIC machine. */
-
-  inta = *(unsigned char *)ca;
-  intb = *(unsigned char *)cb;
-
-  if (zcode == 90 || zcode == 122) {
-    /*        ASCII is assumed - ZCODE is the ASCII code of either lower or */
-    /*        upper case 'Z'. */
-
-    if (inta >= 97 && inta <= 122) {
-      inta += -32;
-    }
-    if (intb >= 97 && intb <= 122) {
-      intb += -32;
-    }
-
-  } else if (zcode == 233 || zcode == 169) {
-    /*        EBCDIC is assumed - ZCODE is the EBCDIC code of either lower or */
-    /*        upper case 'Z'. */
-
-    if ((inta >= 129 && inta <= 137) || (inta >= 145 && inta <= 153) || (inta >= 162 && inta <= 169)) {
-      inta += 64;
-    }
-    if ((intb >= 129 && intb <= 137) || (intb >= 145 && intb <= 153) || (intb >= 162 && intb <= 169)) {
-      intb += 64;
-    }
-
-  } else if (zcode == 218 || zcode == 250) {
-    /*        ASCII is assumed, on Prime machines - ZCODE is the ASCII code */
-    /*        plus 128 of either lower or upper case 'Z'. */
-
-    if (inta >= 225 && inta <= 250) {
-      inta += -32;
-    }
-    if (intb >= 225 && intb <= 250) {
-      intb += -32;
-    }
-  }
-  ret_val = inta == intb;
-
-  /*     RETURN */
-
-  /*     End of LSAME */
-
-  return ret_val;
-} /* lsame_ */
diff --git a/blas/f2c/srotm.c b/blas/f2c/srotm.c
deleted file mode 100644
index 410dd87..0000000
--- a/blas/f2c/srotm.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/* srotm.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void srotm_(integer *n, real *sx, integer *incx, real *sy, integer *incy, real *sparam) {
-  /* Initialized data */
-
-  static real zero = 0.f;
-  static real two = 2.f;
-
-  /* System generated locals */
-  integer i__1, i__2;
-
-  /* Local variables */
-  integer i__;
-  real w, z__;
-  integer kx, ky;
-  real sh11, sh12, sh21, sh22, sflag;
-  integer nsteps;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*     APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX */
-
-  /*     (SX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF SX ARE IN */
-  /*     (DX**T) */
-
-  /*     SX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX .GE. 0, ELSE */
-  /*     LX = (-INCX)*N, AND SIMILARLY FOR SY USING USING LY AND INCY. */
-  /*     WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS.. */
-
-  /*     SFLAG=-1.E0     SFLAG=0.E0        SFLAG=1.E0     SFLAG=-2.E0 */
-
-  /*       (SH11  SH12)    (1.E0  SH12)    (SH11  1.E0)    (1.E0  0.E0) */
-  /*     H=(          )    (          )    (          )    (          ) */
-  /*       (SH21  SH22),   (SH21  1.E0),   (-1.E0 SH22),   (0.E0  1.E0). */
-  /*     SEE  SROTMG FOR A DESCRIPTION OF DATA STORAGE IN SPARAM. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N      (input) INTEGER */
-  /*         number of elements in input vector(s) */
-
-  /*  SX     (input/output) REAL array, dimension N */
-  /*         double precision vector with N elements */
-
-  /*  INCX   (input) INTEGER */
-  /*         storage spacing between elements of SX */
-
-  /*  SY     (input/output) REAL array, dimension N */
-  /*         double precision vector with N elements */
-
-  /*  INCY   (input) INTEGER */
-  /*         storage spacing between elements of SY */
-
-  /*  SPARAM (input/output)  REAL array, dimension 5 */
-  /*     SPARAM(1)=SFLAG */
-  /*     SPARAM(2)=SH11 */
-  /*     SPARAM(3)=SH21 */
-  /*     SPARAM(4)=SH12 */
-  /*     SPARAM(5)=SH22 */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /* Parameter adjustments */
-  --sparam;
-  --sy;
-  --sx;
-
-  /* Function Body */
-  /*     .. */
-
-  sflag = sparam[1];
-  if (*n <= 0 || sflag + two == zero) {
-    goto L140;
-  }
-  if (!(*incx == *incy && *incx > 0)) {
-    goto L70;
-  }
-
-  nsteps = *n * *incx;
-  if (sflag < 0.f) {
-    goto L50;
-  } else if (sflag == 0) {
-    goto L10;
-  } else {
-    goto L30;
-  }
-L10:
-  sh12 = sparam[4];
-  sh21 = sparam[3];
-  i__1 = nsteps;
-  i__2 = *incx;
-  for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
-    w = sx[i__];
-    z__ = sy[i__];
-    sx[i__] = w + z__ * sh12;
-    sy[i__] = w * sh21 + z__;
-    /* L20: */
-  }
-  goto L140;
-L30:
-  sh11 = sparam[2];
-  sh22 = sparam[5];
-  i__2 = nsteps;
-  i__1 = *incx;
-  for (i__ = 1; i__1 < 0 ? i__ >= i__2 : i__ <= i__2; i__ += i__1) {
-    w = sx[i__];
-    z__ = sy[i__];
-    sx[i__] = w * sh11 + z__;
-    sy[i__] = -w + sh22 * z__;
-    /* L40: */
-  }
-  goto L140;
-L50:
-  sh11 = sparam[2];
-  sh12 = sparam[4];
-  sh21 = sparam[3];
-  sh22 = sparam[5];
-  i__1 = nsteps;
-  i__2 = *incx;
-  for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
-    w = sx[i__];
-    z__ = sy[i__];
-    sx[i__] = w * sh11 + z__ * sh12;
-    sy[i__] = w * sh21 + z__ * sh22;
-    /* L60: */
-  }
-  goto L140;
-L70:
-  kx = 1;
-  ky = 1;
-  if (*incx < 0) {
-    kx = (1 - *n) * *incx + 1;
-  }
-  if (*incy < 0) {
-    ky = (1 - *n) * *incy + 1;
-  }
-
-  if (sflag < 0.f) {
-    goto L120;
-  } else if (sflag == 0) {
-    goto L80;
-  } else {
-    goto L100;
-  }
-L80:
-  sh12 = sparam[4];
-  sh21 = sparam[3];
-  i__2 = *n;
-  for (i__ = 1; i__ <= i__2; ++i__) {
-    w = sx[kx];
-    z__ = sy[ky];
-    sx[kx] = w + z__ * sh12;
-    sy[ky] = w * sh21 + z__;
-    kx += *incx;
-    ky += *incy;
-    /* L90: */
-  }
-  goto L140;
-L100:
-  sh11 = sparam[2];
-  sh22 = sparam[5];
-  i__2 = *n;
-  for (i__ = 1; i__ <= i__2; ++i__) {
-    w = sx[kx];
-    z__ = sy[ky];
-    sx[kx] = w * sh11 + z__;
-    sy[ky] = -w + sh22 * z__;
-    kx += *incx;
-    ky += *incy;
-    /* L110: */
-  }
-  goto L140;
-L120:
-  sh11 = sparam[2];
-  sh12 = sparam[4];
-  sh21 = sparam[3];
-  sh22 = sparam[5];
-  i__2 = *n;
-  for (i__ = 1; i__ <= i__2; ++i__) {
-    w = sx[kx];
-    z__ = sy[ky];
-    sx[kx] = w * sh11 + z__ * sh12;
-    sy[ky] = w * sh21 + z__ * sh22;
-    kx += *incx;
-    ky += *incy;
-    /* L130: */
-  }
-L140:
-  return;
-} /* srotm_ */
diff --git a/blas/f2c/srotmg.c b/blas/f2c/srotmg.c
deleted file mode 100644
index 3a0f9f6..0000000
--- a/blas/f2c/srotmg.c
+++ /dev/null
@@ -1,293 +0,0 @@
-/* srotmg.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void srotmg_(real *sd1, real *sd2, real *sx1, real *sy1, real *sparam) {
-  /* Initialized data */
-
-  static real zero = 0.f;
-  static real one = 1.f;
-  static real two = 2.f;
-  static real gam = 4096.f;
-  static real gamsq = 16777200.f;
-  static real rgamsq = 5.96046e-8f;
-
-  /* Format strings */
-  static char fmt_120[] = "";
-  static char fmt_150[] = "";
-  static char fmt_180[] = "";
-  static char fmt_210[] = "";
-
-  /* System generated locals */
-  real r__1;
-
-  /* Local variables */
-  real su, sp1, sp2, sq1, sq2, sh11, sh12, sh21, sh22;
-  integer igo;
-  real sflag, stemp;
-
-  /* Assigned format variables */
-  static char *igo_fmt;
-  (void)igo_fmt;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*     CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS */
-  /*     THE SECOND COMPONENT OF THE 2-VECTOR  (SQRT(SD1)*SX1,SQRT(SD2)* */
-  /*     SY2)**T. */
-  /*     WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS.. */
-
-  /*     SFLAG=-1.E0     SFLAG=0.E0        SFLAG=1.E0     SFLAG=-2.E0 */
-
-  /*       (SH11  SH12)    (1.E0  SH12)    (SH11  1.E0)    (1.E0  0.E0) */
-  /*     H=(          )    (          )    (          )    (          ) */
-  /*       (SH21  SH22),   (SH21  1.E0),   (-1.E0 SH22),   (0.E0  1.E0). */
-  /*     LOCATIONS 2-4 OF SPARAM CONTAIN SH11,SH21,SH12, AND SH22 */
-  /*     RESPECTIVELY. (VALUES OF 1.E0, -1.E0, OR 0.E0 IMPLIED BY THE */
-  /*     VALUE OF SPARAM(1) ARE NOT STORED IN SPARAM.) */
-
-  /*     THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE */
-  /*     INEXACT.  THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE */
-  /*     OF SD1 AND SD2.  ALL ACTUAL SCALING OF DATA IS DONE USING GAM. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SD1    (input/output) REAL */
-
-  /*  SD2    (input/output) REAL */
-
-  /*  SX1    (input/output) REAL */
-
-  /*  SY1    (input) REAL */
-
-  /*  SPARAM (input/output)  REAL array, dimension 5 */
-  /*     SPARAM(1)=SFLAG */
-  /*     SPARAM(2)=SH11 */
-  /*     SPARAM(3)=SH21 */
-  /*     SPARAM(4)=SH12 */
-  /*     SPARAM(5)=SH22 */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Data statements .. */
-
-  /* Parameter adjustments */
-  --sparam;
-
-  /* Function Body */
-  /*     .. */
-  if (!(*sd1 < zero)) {
-    goto L10;
-  }
-  /*       GO ZERO-H-D-AND-SX1.. */
-  goto L60;
-L10:
-  /*     CASE-SD1-NONNEGATIVE */
-  sp2 = *sd2 * *sy1;
-  if (!(sp2 == zero)) {
-    goto L20;
-  }
-  sflag = -two;
-  goto L260;
-/*     REGULAR-CASE.. */
-L20:
-  sp1 = *sd1 * *sx1;
-  sq2 = sp2 * *sy1;
-  sq1 = sp1 * *sx1;
-
-  if (!(dabs(sq1) > dabs(sq2))) {
-    goto L40;
-  }
-  sh21 = -(*sy1) / *sx1;
-  sh12 = sp2 / sp1;
-
-  su = one - sh12 * sh21;
-
-  if (!(su <= zero)) {
-    goto L30;
-  }
-  /*         GO ZERO-H-D-AND-SX1.. */
-  goto L60;
-L30:
-  sflag = zero;
-  *sd1 /= su;
-  *sd2 /= su;
-  *sx1 *= su;
-  /*         GO SCALE-CHECK.. */
-  goto L100;
-L40:
-  if (!(sq2 < zero)) {
-    goto L50;
-  }
-  /*         GO ZERO-H-D-AND-SX1.. */
-  goto L60;
-L50:
-  sflag = one;
-  sh11 = sp1 / sp2;
-  sh22 = *sx1 / *sy1;
-  su = one + sh11 * sh22;
-  stemp = *sd2 / su;
-  *sd2 = *sd1 / su;
-  *sd1 = stemp;
-  *sx1 = *sy1 * su;
-  /*         GO SCALE-CHECK */
-  goto L100;
-/*     PROCEDURE..ZERO-H-D-AND-SX1.. */
-L60:
-  sflag = -one;
-  sh11 = zero;
-  sh12 = zero;
-  sh21 = zero;
-  sh22 = zero;
-
-  *sd1 = zero;
-  *sd2 = zero;
-  *sx1 = zero;
-  /*         RETURN.. */
-  goto L220;
-/*     PROCEDURE..FIX-H.. */
-L70:
-  if (!(sflag >= zero)) {
-    goto L90;
-  }
-
-  if (!(sflag == zero)) {
-    goto L80;
-  }
-  sh11 = one;
-  sh22 = one;
-  sflag = -one;
-  goto L90;
-L80:
-  sh21 = -one;
-  sh12 = one;
-  sflag = -one;
-L90:
-  switch (igo) {
-    case 0:
-      goto L120;
-    case 1:
-      goto L150;
-    case 2:
-      goto L180;
-    case 3:
-      goto L210;
-  }
-/*     PROCEDURE..SCALE-CHECK */
-L100:
-L110:
-  if (!(*sd1 <= rgamsq)) {
-    goto L130;
-  }
-  if (*sd1 == zero) {
-    goto L160;
-  }
-  igo = 0;
-  igo_fmt = fmt_120;
-  /*              FIX-H.. */
-  goto L70;
-L120:
-  /* Computing 2nd power */
-  r__1 = gam;
-  *sd1 *= r__1 * r__1;
-  *sx1 /= gam;
-  sh11 /= gam;
-  sh12 /= gam;
-  goto L110;
-L130:
-L140:
-  if (!(*sd1 >= gamsq)) {
-    goto L160;
-  }
-  igo = 1;
-  igo_fmt = fmt_150;
-  /*              FIX-H.. */
-  goto L70;
-L150:
-  /* Computing 2nd power */
-  r__1 = gam;
-  *sd1 /= r__1 * r__1;
-  *sx1 *= gam;
-  sh11 *= gam;
-  sh12 *= gam;
-  goto L140;
-L160:
-L170:
-  if (!(dabs(*sd2) <= rgamsq)) {
-    goto L190;
-  }
-  if (*sd2 == zero) {
-    goto L220;
-  }
-  igo = 2;
-  igo_fmt = fmt_180;
-  /*              FIX-H.. */
-  goto L70;
-L180:
-  /* Computing 2nd power */
-  r__1 = gam;
-  *sd2 *= r__1 * r__1;
-  sh21 /= gam;
-  sh22 /= gam;
-  goto L170;
-L190:
-L200:
-  if (!(dabs(*sd2) >= gamsq)) {
-    goto L220;
-  }
-  igo = 3;
-  igo_fmt = fmt_210;
-  /*              FIX-H.. */
-  goto L70;
-L210:
-  /* Computing 2nd power */
-  r__1 = gam;
-  *sd2 /= r__1 * r__1;
-  sh21 *= gam;
-  sh22 *= gam;
-  goto L200;
-L220:
-  if (sflag < 0.f) {
-    goto L250;
-  } else if (sflag == 0) {
-    goto L230;
-  } else {
-    goto L240;
-  }
-L230:
-  sparam[3] = sh21;
-  sparam[4] = sh12;
-  goto L260;
-L240:
-  sparam[2] = sh11;
-  sparam[5] = sh22;
-  goto L260;
-L250:
-  sparam[2] = sh11;
-  sparam[3] = sh21;
-  sparam[4] = sh12;
-  sparam[5] = sh22;
-L260:
-  sparam[1] = sflag;
-} /* srotmg_ */
diff --git a/blas/f2c/ssbmv.c b/blas/f2c/ssbmv.c
deleted file mode 100644
index ac1d70a..0000000
--- a/blas/f2c/ssbmv.c
+++ /dev/null
@@ -1,359 +0,0 @@
-/* ssbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void ssbmv_(char *uplo, integer *n, integer *k, real *alpha, real *a, integer *lda, real *x,
-                             integer *incx, real *beta, real *y, integer *incy) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
-
-  /* Local variables */
-  integer i__, j, l, ix, iy, jx, jy, kx, ky, info;
-  real temp1, temp2;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SSBMV  performs the matrix-vector  operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n symmetric band matrix, with k super-diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the band matrix A is being supplied as */
-  /*           follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  being supplied. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  being supplied. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry, K specifies the number of super-diagonals of the */
-  /*           matrix A. K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - REAL            . */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  A      - REAL             array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the symmetric matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer the upper */
-  /*           triangular part of a symmetric band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the symmetric matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer the lower */
-  /*           triangular part of a symmetric band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - REAL             array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the */
-  /*           vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - REAL            . */
-  /*           On entry, BETA specifies the scalar beta. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - REAL             array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the */
-  /*           vector y. On exit, Y is overwritten by the updated vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-  --y;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*k < 0) {
-    info = 3;
-  } else if (*lda < *k + 1) {
-    info = 6;
-  } else if (*incx == 0) {
-    info = 8;
-  } else if (*incy == 0) {
-    info = 11;
-  }
-  if (info != 0) {
-    xerbla_("SSBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (*alpha == 0.f && *beta == 1.f)) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array A */
-  /*     are accessed sequentially with one pass through A. */
-
-  /*     First form  y := beta*y. */
-
-  if (*beta != 1.f) {
-    if (*incy == 1) {
-      if (*beta == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = 0.f;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = *beta * y[i__];
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (*beta == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = 0.f;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = *beta * y[iy];
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (*alpha == 0.f) {
-    return;
-  }
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when upper triangle of A is stored. */
-
-    kplus1 = *k + 1;
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.f;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__2 = 1, i__3 = j - *k;
-        i__4 = j - 1;
-        for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-          y[i__] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[i__];
-          /* L50: */
-        }
-        y[j] = y[j] + temp1 * a[kplus1 + j * a_dim1] + *alpha * temp2;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.f;
-        ix = kx;
-        iy = ky;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__4 = 1, i__2 = j - *k;
-        i__3 = j - 1;
-        for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-          y[iy] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[ix];
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        y[jy] = y[jy] + temp1 * a[kplus1 + j * a_dim1] + *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        if (j > *k) {
-          kx += *incx;
-          ky += *incy;
-        }
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when lower triangle of A is stored. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.f;
-        y[j] += temp1 * a[j * a_dim1 + 1];
-        l = 1 - j;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          y[i__] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[i__];
-          /* L90: */
-        }
-        y[j] += *alpha * temp2;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.f;
-        y[jy] += temp1 * a[j * a_dim1 + 1];
-        l = 1 - j;
-        ix = jx;
-        iy = jy;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          ix += *incx;
-          iy += *incy;
-          y[iy] += temp1 * a[l + i__ + j * a_dim1];
-          temp2 += a[l + i__ + j * a_dim1] * x[ix];
-          /* L110: */
-        }
-        y[jy] += *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of SSBMV . */
-
-} /* ssbmv_ */
diff --git a/blas/f2c/sspmv.c b/blas/f2c/sspmv.c
deleted file mode 100644
index ea9db33..0000000
--- a/blas/f2c/sspmv.c
+++ /dev/null
@@ -1,308 +0,0 @@
-/* sspmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void sspmv_(char *uplo, integer *n, real *alpha, real *ap, real *x, integer *incx, real *beta, real *y,
-                             integer *incy) {
-  /* System generated locals */
-  integer i__1, i__2;
-
-  /* Local variables */
-  integer i__, j, k, kk, ix, iy, jx, jy, kx, ky, info;
-  real temp1, temp2;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SSPMV  performs the matrix-vector operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n symmetric matrix, supplied in packed form. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the matrix A is supplied in the packed */
-  /*           array AP as follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - REAL            . */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  AP     - REAL             array of DIMENSION at least */
-  /*           ( ( n*( n + 1 ) )/2 ). */
-  /*           Before entry with UPLO = 'U' or 'u', the array AP must */
-  /*           contain the upper triangular part of the symmetric matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) */
-  /*           and a( 2, 2 ) respectively, and so on. */
-  /*           Before entry with UPLO = 'L' or 'l', the array AP must */
-  /*           contain the lower triangular part of the symmetric matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) */
-  /*           and a( 3, 1 ) respectively, and so on. */
-  /*           Unchanged on exit. */
-
-  /*  X      - REAL             array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - REAL            . */
-  /*           On entry, BETA specifies the scalar beta. When BETA is */
-  /*           supplied as zero then Y need not be set on input. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - REAL             array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the n */
-  /*           element vector y. On exit, Y is overwritten by the updated */
-  /*           vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  --y;
-  --x;
-  --ap;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*incx == 0) {
-    info = 6;
-  } else if (*incy == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("SSPMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (*alpha == 0.f && *beta == 1.f)) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array AP */
-  /*     are accessed sequentially with one pass through AP. */
-
-  /*     First form  y := beta*y. */
-
-  if (*beta != 1.f) {
-    if (*incy == 1) {
-      if (*beta == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = 0.f;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[i__] = *beta * y[i__];
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (*beta == 0.f) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = 0.f;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          y[iy] = *beta * y[iy];
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (*alpha == 0.f) {
-    return;
-  }
-  kk = 1;
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when AP contains the upper triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.f;
-        k = kk;
-        i__2 = j - 1;
-        for (i__ = 1; i__ <= i__2; ++i__) {
-          y[i__] += temp1 * ap[k];
-          temp2 += ap[k] * x[i__];
-          ++k;
-          /* L50: */
-        }
-        y[j] = y[j] + temp1 * ap[kk + j - 1] + *alpha * temp2;
-        kk += j;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.f;
-        ix = kx;
-        iy = ky;
-        i__2 = kk + j - 2;
-        for (k = kk; k <= i__2; ++k) {
-          y[iy] += temp1 * ap[k];
-          temp2 += ap[k] * x[ix];
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        y[jy] = y[jy] + temp1 * ap[kk + j - 1] + *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        kk += j;
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when AP contains the lower triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[j];
-        temp2 = 0.f;
-        y[j] += temp1 * ap[kk];
-        k = kk + 1;
-        i__2 = *n;
-        for (i__ = j + 1; i__ <= i__2; ++i__) {
-          y[i__] += temp1 * ap[k];
-          temp2 += ap[k] * x[i__];
-          ++k;
-          /* L90: */
-        }
-        y[j] += *alpha * temp2;
-        kk += *n - j + 1;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        temp1 = *alpha * x[jx];
-        temp2 = 0.f;
-        y[jy] += temp1 * ap[kk];
-        ix = jx;
-        iy = jy;
-        i__2 = kk + *n - j;
-        for (k = kk + 1; k <= i__2; ++k) {
-          ix += *incx;
-          iy += *incy;
-          y[iy] += temp1 * ap[k];
-          temp2 += ap[k] * x[ix];
-          /* L110: */
-        }
-        y[jy] += *alpha * temp2;
-        jx += *incx;
-        jy += *incy;
-        kk += *n - j + 1;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of SSPMV . */
-
-} /* sspmv_ */
diff --git a/blas/f2c/stbmv.c b/blas/f2c/stbmv.c
deleted file mode 100644
index 43329f6..0000000
--- a/blas/f2c/stbmv.c
+++ /dev/null
@@ -1,417 +0,0 @@
-/* stbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-/* Subroutine */ void stbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, real *a, integer *lda,
-                             real *x, integer *incx) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
-
-  /* Local variables */
-  integer i__, j, l, ix, jx, kx, info;
-  real temp;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-  logical nounit;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  STBMV  performs one of the matrix-vector operations */
-
-  /*     x := A*x,   or   x := A'*x, */
-
-  /*  where x is an n element vector and  A is an n by n unit, or non-unit, */
-  /*  upper or lower triangular band matrix, with ( k + 1 ) diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the matrix is an upper or */
-  /*           lower triangular matrix as follows: */
-
-  /*              UPLO = 'U' or 'u'   A is an upper triangular matrix. */
-
-  /*              UPLO = 'L' or 'l'   A is a lower triangular matrix. */
-
-  /*           Unchanged on exit. */
-
-  /*  TRANS  - CHARACTER*1. */
-  /*           On entry, TRANS specifies the operation to be performed as */
-  /*           follows: */
-
-  /*              TRANS = 'N' or 'n'   x := A*x. */
-
-  /*              TRANS = 'T' or 't'   x := A'*x. */
-
-  /*              TRANS = 'C' or 'c'   x := A'*x. */
-
-  /*           Unchanged on exit. */
-
-  /*  DIAG   - CHARACTER*1. */
-  /*           On entry, DIAG specifies whether or not A is unit */
-  /*           triangular as follows: */
-
-  /*              DIAG = 'U' or 'u'   A is assumed to be unit triangular. */
-
-  /*              DIAG = 'N' or 'n'   A is not assumed to be unit */
-  /*                                  triangular. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry with UPLO = 'U' or 'u', K specifies the number of */
-  /*           super-diagonals of the matrix A. */
-  /*           On entry with UPLO = 'L' or 'l', K specifies the number of */
-  /*           sub-diagonals of the matrix A. */
-  /*           K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  A      - REAL             array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer an upper */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer a lower */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Note that when DIAG = 'U' or 'u' the elements of the array A */
-  /*           corresponding to the diagonal elements of the matrix are not */
-  /*           referenced, but are assumed to be unity. */
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - REAL             array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. On exit, X is overwritten with the */
-  /*           transformed vector x. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (!lsame_(trans, "N") && !lsame_(trans, "T") && !lsame_(trans, "C")) {
-    info = 2;
-  } else if (!lsame_(diag, "U") && !lsame_(diag, "N")) {
-    info = 3;
-  } else if (*n < 0) {
-    info = 4;
-  } else if (*k < 0) {
-    info = 5;
-  } else if (*lda < *k + 1) {
-    info = 7;
-  } else if (*incx == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("STBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0) {
-    return;
-  }
-
-  nounit = lsame_(diag, "N");
-
-  /*     Set up the start point in X if the increment is not unity. This */
-  /*     will be  ( N - 1 )*INCX   too small for descending loops. */
-
-  if (*incx <= 0) {
-    kx = 1 - (*n - 1) * *incx;
-  } else if (*incx != 1) {
-    kx = 1;
-  }
-
-  /*     Start the operations. In this version the elements of A are */
-  /*     accessed sequentially with one pass through A. */
-
-  if (lsame_(trans, "N")) {
-    /*         Form  x := A*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          if (x[j] != 0.f) {
-            temp = x[j];
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__2 = 1, i__3 = j - *k;
-            i__4 = j - 1;
-            for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-              x[i__] += temp * a[l + i__ + j * a_dim1];
-              /* L10: */
-            }
-            if (nounit) {
-              x[j] *= a[kplus1 + j * a_dim1];
-            }
-          }
-          /* L20: */
-        }
-      } else {
-        jx = kx;
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          if (x[jx] != 0.f) {
-            temp = x[jx];
-            ix = kx;
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__4 = 1, i__2 = j - *k;
-            i__3 = j - 1;
-            for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-              x[ix] += temp * a[l + i__ + j * a_dim1];
-              ix += *incx;
-              /* L30: */
-            }
-            if (nounit) {
-              x[jx] *= a[kplus1 + j * a_dim1];
-            }
-          }
-          jx += *incx;
-          if (j > *k) {
-            kx += *incx;
-          }
-          /* L40: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          if (x[j] != 0.f) {
-            temp = x[j];
-            l = 1 - j;
-            /* Computing MIN */
-            i__1 = *n, i__3 = j + *k;
-            i__4 = j + 1;
-            for (i__ = min(i__1, i__3); i__ >= i__4; --i__) {
-              x[i__] += temp * a[l + i__ + j * a_dim1];
-              /* L50: */
-            }
-            if (nounit) {
-              x[j] *= a[j * a_dim1 + 1];
-            }
-          }
-          /* L60: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          if (x[jx] != 0.f) {
-            temp = x[jx];
-            ix = kx;
-            l = 1 - j;
-            /* Computing MIN */
-            i__4 = *n, i__1 = j + *k;
-            i__3 = j + 1;
-            for (i__ = min(i__4, i__1); i__ >= i__3; --i__) {
-              x[ix] += temp * a[l + i__ + j * a_dim1];
-              ix -= *incx;
-              /* L70: */
-            }
-            if (nounit) {
-              x[jx] *= a[j * a_dim1 + 1];
-            }
-          }
-          jx -= *incx;
-          if (*n - j >= *k) {
-            kx -= *incx;
-          }
-          /* L80: */
-        }
-      }
-    }
-  } else {
-    /*        Form  x := A'*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          temp = x[j];
-          l = kplus1 - j;
-          if (nounit) {
-            temp *= a[kplus1 + j * a_dim1];
-          }
-          /* Computing MAX */
-          i__4 = 1, i__1 = j - *k;
-          i__3 = max(i__4, i__1);
-          for (i__ = j - 1; i__ >= i__3; --i__) {
-            temp += a[l + i__ + j * a_dim1] * x[i__];
-            /* L90: */
-          }
-          x[j] = temp;
-          /* L100: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          temp = x[jx];
-          kx -= *incx;
-          ix = kx;
-          l = kplus1 - j;
-          if (nounit) {
-            temp *= a[kplus1 + j * a_dim1];
-          }
-          /* Computing MAX */
-          i__4 = 1, i__1 = j - *k;
-          i__3 = max(i__4, i__1);
-          for (i__ = j - 1; i__ >= i__3; --i__) {
-            temp += a[l + i__ + j * a_dim1] * x[ix];
-            ix -= *incx;
-            /* L110: */
-          }
-          x[jx] = temp;
-          jx -= *incx;
-          /* L120: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          temp = x[j];
-          l = 1 - j;
-          if (nounit) {
-            temp *= a[j * a_dim1 + 1];
-          }
-          /* Computing MIN */
-          i__1 = *n, i__2 = j + *k;
-          i__4 = min(i__1, i__2);
-          for (i__ = j + 1; i__ <= i__4; ++i__) {
-            temp += a[l + i__ + j * a_dim1] * x[i__];
-            /* L130: */
-          }
-          x[j] = temp;
-          /* L140: */
-        }
-      } else {
-        jx = kx;
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          temp = x[jx];
-          kx += *incx;
-          ix = kx;
-          l = 1 - j;
-          if (nounit) {
-            temp *= a[j * a_dim1 + 1];
-          }
-          /* Computing MIN */
-          i__1 = *n, i__2 = j + *k;
-          i__4 = min(i__1, i__2);
-          for (i__ = j + 1; i__ <= i__4; ++i__) {
-            temp += a[l + i__ + j * a_dim1] * x[ix];
-            ix += *incx;
-            /* L150: */
-          }
-          x[jx] = temp;
-          jx += *incx;
-          /* L160: */
-        }
-      }
-    }
-  }
-
-  /*     End of STBMV . */
-
-} /* stbmv_ */
diff --git a/blas/f2c/zhbmv.c b/blas/f2c/zhbmv.c
deleted file mode 100644
index cef1117..0000000
--- a/blas/f2c/zhbmv.c
+++ /dev/null
@@ -1,456 +0,0 @@
-/* zhbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-static inline void d_cnjg(doublecomplex *r, doublecomplex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void zhbmv_(char *uplo, integer *n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda,
-                             doublecomplex *x, integer *incx, doublecomplex *beta, doublecomplex *y, integer *incy) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
-  doublereal d__1;
-  doublecomplex z__1, z__2, z__3, z__4;
-
-  /* Local variables */
-  integer i__, j, l, ix, iy, jx, jy, kx, ky, info;
-  doublecomplex temp1, temp2;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZHBMV  performs the matrix-vector  operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n hermitian band matrix, with k super-diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the band matrix A is being supplied as */
-  /*           follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  being supplied. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  being supplied. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry, K specifies the number of super-diagonals of the */
-  /*           matrix A. K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - COMPLEX*16      . */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  A      - COMPLEX*16       array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the hermitian matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer the upper */
-  /*           triangular part of a hermitian band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the hermitian matrix, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer the lower */
-  /*           triangular part of a hermitian band matrix from conventional */
-  /*           full matrix storage to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Note that the imaginary parts of the diagonal elements need */
-  /*           not be set and are assumed to be zero. */
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - COMPLEX*16       array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the */
-  /*           vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - COMPLEX*16      . */
-  /*           On entry, BETA specifies the scalar beta. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - COMPLEX*16       array of DIMENSION at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the */
-  /*           vector y. On exit, Y is overwritten by the updated vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-  --y;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*k < 0) {
-    info = 3;
-  } else if (*lda < *k + 1) {
-    info = 6;
-  } else if (*incx == 0) {
-    info = 8;
-  } else if (*incy == 0) {
-    info = 11;
-  }
-  if (info != 0) {
-    xerbla_("ZHBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (alpha->r == 0. && alpha->i == 0. && (beta->r == 1. && beta->i == 0.))) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array A */
-  /*     are accessed sequentially with one pass through A. */
-
-  /*     First form  y := beta*y. */
-
-  if (beta->r != 1. || beta->i != 0.) {
-    if (*incy == 1) {
-      if (beta->r == 0. && beta->i == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          y[i__2].r = 0., y[i__2].i = 0.;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          i__3 = i__;
-          z__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, z__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (beta->r == 0. && beta->i == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          y[i__2].r = 0., y[i__2].i = 0.;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          i__3 = iy;
-          z__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, z__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (alpha->r == 0. && alpha->i == 0.) {
-    return;
-  }
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when upper triangle of A is stored. */
-
-    kplus1 = *k + 1;
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = j;
-        z__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, z__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__2 = 1, i__3 = j - *k;
-        i__4 = j - 1;
-        for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-          i__2 = i__;
-          i__3 = i__;
-          i__5 = l + i__ + j * a_dim1;
-          z__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, z__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          z__1.r = y[i__3].r + z__2.r, z__1.i = y[i__3].i + z__2.i;
-          y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-          d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-          i__2 = i__;
-          z__2.r = z__3.r * x[i__2].r - z__3.i * x[i__2].i, z__2.i = z__3.r * x[i__2].i + z__3.i * x[i__2].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          /* L50: */
-        }
-        i__4 = j;
-        i__2 = j;
-        i__3 = kplus1 + j * a_dim1;
-        d__1 = a[i__3].r;
-        z__3.r = d__1 * temp1.r, z__3.i = d__1 * temp1.i;
-        z__2.r = y[i__2].r + z__3.r, z__2.i = y[i__2].i + z__3.i;
-        z__4.r = alpha->r * temp2.r - alpha->i * temp2.i, z__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = z__2.r + z__4.r, z__1.i = z__2.i + z__4.i;
-        y[i__4].r = z__1.r, y[i__4].i = z__1.i;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__4 = jx;
-        z__1.r = alpha->r * x[i__4].r - alpha->i * x[i__4].i, z__1.i = alpha->r * x[i__4].i + alpha->i * x[i__4].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        ix = kx;
-        iy = ky;
-        l = kplus1 - j;
-        /* Computing MAX */
-        i__4 = 1, i__2 = j - *k;
-        i__3 = j - 1;
-        for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-          i__4 = iy;
-          i__2 = iy;
-          i__5 = l + i__ + j * a_dim1;
-          z__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, z__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          z__1.r = y[i__2].r + z__2.r, z__1.i = y[i__2].i + z__2.i;
-          y[i__4].r = z__1.r, y[i__4].i = z__1.i;
-          d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-          i__4 = ix;
-          z__2.r = z__3.r * x[i__4].r - z__3.i * x[i__4].i, z__2.i = z__3.r * x[i__4].i + z__3.i * x[i__4].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        i__3 = jy;
-        i__4 = jy;
-        i__2 = kplus1 + j * a_dim1;
-        d__1 = a[i__2].r;
-        z__3.r = d__1 * temp1.r, z__3.i = d__1 * temp1.i;
-        z__2.r = y[i__4].r + z__3.r, z__2.i = y[i__4].i + z__3.i;
-        z__4.r = alpha->r * temp2.r - alpha->i * temp2.i, z__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = z__2.r + z__4.r, z__1.i = z__2.i + z__4.i;
-        y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-        jx += *incx;
-        jy += *incy;
-        if (j > *k) {
-          kx += *incx;
-          ky += *incy;
-        }
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when lower triangle of A is stored. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__3 = j;
-        z__1.r = alpha->r * x[i__3].r - alpha->i * x[i__3].i, z__1.i = alpha->r * x[i__3].i + alpha->i * x[i__3].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        i__3 = j;
-        i__4 = j;
-        i__2 = j * a_dim1 + 1;
-        d__1 = a[i__2].r;
-        z__2.r = d__1 * temp1.r, z__2.i = d__1 * temp1.i;
-        z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-        y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-        l = 1 - j;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          i__4 = i__;
-          i__2 = i__;
-          i__5 = l + i__ + j * a_dim1;
-          z__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, z__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          z__1.r = y[i__2].r + z__2.r, z__1.i = y[i__2].i + z__2.i;
-          y[i__4].r = z__1.r, y[i__4].i = z__1.i;
-          d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-          i__4 = i__;
-          z__2.r = z__3.r * x[i__4].r - z__3.i * x[i__4].i, z__2.i = z__3.r * x[i__4].i + z__3.i * x[i__4].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          /* L90: */
-        }
-        i__3 = j;
-        i__4 = j;
-        z__2.r = alpha->r * temp2.r - alpha->i * temp2.i, z__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-        y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__3 = jx;
-        z__1.r = alpha->r * x[i__3].r - alpha->i * x[i__3].i, z__1.i = alpha->r * x[i__3].i + alpha->i * x[i__3].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        i__3 = jy;
-        i__4 = jy;
-        i__2 = j * a_dim1 + 1;
-        d__1 = a[i__2].r;
-        z__2.r = d__1 * temp1.r, z__2.i = d__1 * temp1.i;
-        z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-        y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-        l = 1 - j;
-        ix = jx;
-        iy = jy;
-        /* Computing MIN */
-        i__4 = *n, i__2 = j + *k;
-        i__3 = min(i__4, i__2);
-        for (i__ = j + 1; i__ <= i__3; ++i__) {
-          ix += *incx;
-          iy += *incy;
-          i__4 = iy;
-          i__2 = iy;
-          i__5 = l + i__ + j * a_dim1;
-          z__2.r = temp1.r * a[i__5].r - temp1.i * a[i__5].i, z__2.i = temp1.r * a[i__5].i + temp1.i * a[i__5].r;
-          z__1.r = y[i__2].r + z__2.r, z__1.i = y[i__2].i + z__2.i;
-          y[i__4].r = z__1.r, y[i__4].i = z__1.i;
-          d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-          i__4 = ix;
-          z__2.r = z__3.r * x[i__4].r - z__3.i * x[i__4].i, z__2.i = z__3.r * x[i__4].i + z__3.i * x[i__4].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          /* L110: */
-        }
-        i__3 = jy;
-        i__4 = jy;
-        z__2.r = alpha->r * temp2.r - alpha->i * temp2.i, z__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-        y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-        jx += *incx;
-        jy += *incy;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of ZHBMV . */
-
-} /* zhbmv_ */
diff --git a/blas/f2c/zhpmv.c b/blas/f2c/zhpmv.c
deleted file mode 100644
index 6b9a000..0000000
--- a/blas/f2c/zhpmv.c
+++ /dev/null
@@ -1,407 +0,0 @@
-/* zhpmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-static inline void d_cnjg(doublecomplex *r, doublecomplex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void zhpmv_(char *uplo, integer *n, doublecomplex *alpha, doublecomplex *ap, doublecomplex *x,
-                             integer *incx, doublecomplex *beta, doublecomplex *y, integer *incy) {
-  /* System generated locals */
-  integer i__1, i__2, i__3, i__4, i__5;
-  doublereal d__1;
-  doublecomplex z__1, z__2, z__3, z__4;
-
-  /* Local variables */
-  integer i__, j, k, kk, ix, iy, jx, jy, kx, ky, info;
-  doublecomplex temp1, temp2;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZHPMV  performs the matrix-vector operation */
-
-  /*     y := alpha*A*x + beta*y, */
-
-  /*  where alpha and beta are scalars, x and y are n element vectors and */
-  /*  A is an n by n hermitian matrix, supplied in packed form. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the upper or lower */
-  /*           triangular part of the matrix A is supplied in the packed */
-  /*           array AP as follows: */
-
-  /*              UPLO = 'U' or 'u'   The upper triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*              UPLO = 'L' or 'l'   The lower triangular part of A is */
-  /*                                  supplied in AP. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  ALPHA  - COMPLEX*16      . */
-  /*           On entry, ALPHA specifies the scalar alpha. */
-  /*           Unchanged on exit. */
-
-  /*  AP     - COMPLEX*16       array of DIMENSION at least */
-  /*           ( ( n*( n + 1 ) )/2 ). */
-  /*           Before entry with UPLO = 'U' or 'u', the array AP must */
-  /*           contain the upper triangular part of the hermitian matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) */
-  /*           and a( 2, 2 ) respectively, and so on. */
-  /*           Before entry with UPLO = 'L' or 'l', the array AP must */
-  /*           contain the lower triangular part of the hermitian matrix */
-  /*           packed sequentially, column by column, so that AP( 1 ) */
-  /*           contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) */
-  /*           and a( 3, 1 ) respectively, and so on. */
-  /*           Note that the imaginary parts of the diagonal elements need */
-  /*           not be set and are assumed to be zero. */
-  /*           Unchanged on exit. */
-
-  /*  X      - COMPLEX*16       array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. */
-  /*           Unchanged on exit. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  BETA   - COMPLEX*16      . */
-  /*           On entry, BETA specifies the scalar beta. When BETA is */
-  /*           supplied as zero then Y need not be set on input. */
-  /*           Unchanged on exit. */
-
-  /*  Y      - COMPLEX*16       array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCY ) ). */
-  /*           Before entry, the incremented array Y must contain the n */
-  /*           element vector y. On exit, Y is overwritten by the updated */
-  /*           vector y. */
-
-  /*  INCY   - INTEGER. */
-  /*           On entry, INCY specifies the increment for the elements of */
-  /*           Y. INCY must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  --y;
-  --x;
-  --ap;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (*n < 0) {
-    info = 2;
-  } else if (*incx == 0) {
-    info = 6;
-  } else if (*incy == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("ZHPMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0 || (alpha->r == 0. && alpha->i == 0. && (beta->r == 1. && beta->i == 0.))) {
-    return;
-  }
-
-  /*     Set up the start points in  X  and  Y. */
-
-  if (*incx > 0) {
-    kx = 1;
-  } else {
-    kx = 1 - (*n - 1) * *incx;
-  }
-  if (*incy > 0) {
-    ky = 1;
-  } else {
-    ky = 1 - (*n - 1) * *incy;
-  }
-
-  /*     Start the operations. In this version the elements of the array AP */
-  /*     are accessed sequentially with one pass through AP. */
-
-  /*     First form  y := beta*y. */
-
-  if (beta->r != 1. || beta->i != 0.) {
-    if (*incy == 1) {
-      if (beta->r == 0. && beta->i == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          y[i__2].r = 0., y[i__2].i = 0.;
-          /* L10: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = i__;
-          i__3 = i__;
-          z__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, z__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-          /* L20: */
-        }
-      }
-    } else {
-      iy = ky;
-      if (beta->r == 0. && beta->i == 0.) {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          y[i__2].r = 0., y[i__2].i = 0.;
-          iy += *incy;
-          /* L30: */
-        }
-      } else {
-        i__1 = *n;
-        for (i__ = 1; i__ <= i__1; ++i__) {
-          i__2 = iy;
-          i__3 = iy;
-          z__1.r = beta->r * y[i__3].r - beta->i * y[i__3].i, z__1.i = beta->r * y[i__3].i + beta->i * y[i__3].r;
-          y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-          iy += *incy;
-          /* L40: */
-        }
-      }
-    }
-  }
-  if (alpha->r == 0. && alpha->i == 0.) {
-    return;
-  }
-  kk = 1;
-  if (lsame_(uplo, "U")) {
-    /*        Form  y  when AP contains the upper triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = j;
-        z__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, z__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        k = kk;
-        i__2 = j - 1;
-        for (i__ = 1; i__ <= i__2; ++i__) {
-          i__3 = i__;
-          i__4 = i__;
-          i__5 = k;
-          z__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, z__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-          y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-          d_cnjg(&z__3, &ap[k]);
-          i__3 = i__;
-          z__2.r = z__3.r * x[i__3].r - z__3.i * x[i__3].i, z__2.i = z__3.r * x[i__3].i + z__3.i * x[i__3].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          ++k;
-          /* L50: */
-        }
-        i__2 = j;
-        i__3 = j;
-        i__4 = kk + j - 1;
-        d__1 = ap[i__4].r;
-        z__3.r = d__1 * temp1.r, z__3.i = d__1 * temp1.i;
-        z__2.r = y[i__3].r + z__3.r, z__2.i = y[i__3].i + z__3.i;
-        z__4.r = alpha->r * temp2.r - alpha->i * temp2.i, z__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = z__2.r + z__4.r, z__1.i = z__2.i + z__4.i;
-        y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-        kk += j;
-        /* L60: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = jx;
-        z__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, z__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        ix = kx;
-        iy = ky;
-        i__2 = kk + j - 2;
-        for (k = kk; k <= i__2; ++k) {
-          i__3 = iy;
-          i__4 = iy;
-          i__5 = k;
-          z__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, z__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-          y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-          d_cnjg(&z__3, &ap[k]);
-          i__3 = ix;
-          z__2.r = z__3.r * x[i__3].r - z__3.i * x[i__3].i, z__2.i = z__3.r * x[i__3].i + z__3.i * x[i__3].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          ix += *incx;
-          iy += *incy;
-          /* L70: */
-        }
-        i__2 = jy;
-        i__3 = jy;
-        i__4 = kk + j - 1;
-        d__1 = ap[i__4].r;
-        z__3.r = d__1 * temp1.r, z__3.i = d__1 * temp1.i;
-        z__2.r = y[i__3].r + z__3.r, z__2.i = y[i__3].i + z__3.i;
-        z__4.r = alpha->r * temp2.r - alpha->i * temp2.i, z__4.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = z__2.r + z__4.r, z__1.i = z__2.i + z__4.i;
-        y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-        jx += *incx;
-        jy += *incy;
-        kk += j;
-        /* L80: */
-      }
-    }
-  } else {
-    /*        Form  y  when AP contains the lower triangle. */
-
-    if (*incx == 1 && *incy == 1) {
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = j;
-        z__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, z__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        i__2 = j;
-        i__3 = j;
-        i__4 = kk;
-        d__1 = ap[i__4].r;
-        z__2.r = d__1 * temp1.r, z__2.i = d__1 * temp1.i;
-        z__1.r = y[i__3].r + z__2.r, z__1.i = y[i__3].i + z__2.i;
-        y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-        k = kk + 1;
-        i__2 = *n;
-        for (i__ = j + 1; i__ <= i__2; ++i__) {
-          i__3 = i__;
-          i__4 = i__;
-          i__5 = k;
-          z__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, z__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-          y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-          d_cnjg(&z__3, &ap[k]);
-          i__3 = i__;
-          z__2.r = z__3.r * x[i__3].r - z__3.i * x[i__3].i, z__2.i = z__3.r * x[i__3].i + z__3.i * x[i__3].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          ++k;
-          /* L90: */
-        }
-        i__2 = j;
-        i__3 = j;
-        z__2.r = alpha->r * temp2.r - alpha->i * temp2.i, z__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = y[i__3].r + z__2.r, z__1.i = y[i__3].i + z__2.i;
-        y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-        kk += *n - j + 1;
-        /* L100: */
-      }
-    } else {
-      jx = kx;
-      jy = ky;
-      i__1 = *n;
-      for (j = 1; j <= i__1; ++j) {
-        i__2 = jx;
-        z__1.r = alpha->r * x[i__2].r - alpha->i * x[i__2].i, z__1.i = alpha->r * x[i__2].i + alpha->i * x[i__2].r;
-        temp1.r = z__1.r, temp1.i = z__1.i;
-        temp2.r = 0., temp2.i = 0.;
-        i__2 = jy;
-        i__3 = jy;
-        i__4 = kk;
-        d__1 = ap[i__4].r;
-        z__2.r = d__1 * temp1.r, z__2.i = d__1 * temp1.i;
-        z__1.r = y[i__3].r + z__2.r, z__1.i = y[i__3].i + z__2.i;
-        y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-        ix = jx;
-        iy = jy;
-        i__2 = kk + *n - j;
-        for (k = kk + 1; k <= i__2; ++k) {
-          ix += *incx;
-          iy += *incy;
-          i__3 = iy;
-          i__4 = iy;
-          i__5 = k;
-          z__2.r = temp1.r * ap[i__5].r - temp1.i * ap[i__5].i, z__2.i = temp1.r * ap[i__5].i + temp1.i * ap[i__5].r;
-          z__1.r = y[i__4].r + z__2.r, z__1.i = y[i__4].i + z__2.i;
-          y[i__3].r = z__1.r, y[i__3].i = z__1.i;
-          d_cnjg(&z__3, &ap[k]);
-          i__3 = ix;
-          z__2.r = z__3.r * x[i__3].r - z__3.i * x[i__3].i, z__2.i = z__3.r * x[i__3].i + z__3.i * x[i__3].r;
-          z__1.r = temp2.r + z__2.r, z__1.i = temp2.i + z__2.i;
-          temp2.r = z__1.r, temp2.i = z__1.i;
-          /* L110: */
-        }
-        i__2 = jy;
-        i__3 = jy;
-        z__2.r = alpha->r * temp2.r - alpha->i * temp2.i, z__2.i = alpha->r * temp2.i + alpha->i * temp2.r;
-        z__1.r = y[i__3].r + z__2.r, z__1.i = y[i__3].i + z__2.i;
-        y[i__2].r = z__1.r, y[i__2].i = z__1.i;
-        jx += *incx;
-        jy += *incy;
-        kk += *n - j + 1;
-        /* L120: */
-      }
-    }
-  }
-
-  /*     End of ZHPMV . */
-
-} /* zhpmv_ */
diff --git a/blas/f2c/ztbmv.c b/blas/f2c/ztbmv.c
deleted file mode 100644
index 2fbfa00..0000000
--- a/blas/f2c/ztbmv.c
+++ /dev/null
@@ -1,586 +0,0 @@
-/* ztbmv.f -- translated by f2c (version 20100827).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "datatypes.h"
-
-static inline void d_cnjg(doublecomplex *r, doublecomplex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void ztbmv_(char *uplo, char *trans, char *diag, integer *n, integer *k, doublecomplex *a,
-                             integer *lda, doublecomplex *x, integer *incx) {
-  /* System generated locals */
-  integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
-  doublecomplex z__1, z__2, z__3;
-
-  /* Local variables */
-  integer i__, j, l, ix, jx, kx, info;
-  doublecomplex temp;
-  extern logical lsame_(char *, char *);
-  integer kplus1;
-  extern /* Subroutine */ void xerbla_(const char *, integer *);
-  logical noconj, nounit;
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZTBMV  performs one of the matrix-vector operations */
-
-  /*     x := A*x,   or   x := A'*x,   or   x := conjg( A' )*x, */
-
-  /*  where x is an n element vector and  A is an n by n unit, or non-unit, */
-  /*  upper or lower triangular band matrix, with ( k + 1 ) diagonals. */
-
-  /*  Arguments */
-  /*  ========== */
-
-  /*  UPLO   - CHARACTER*1. */
-  /*           On entry, UPLO specifies whether the matrix is an upper or */
-  /*           lower triangular matrix as follows: */
-
-  /*              UPLO = 'U' or 'u'   A is an upper triangular matrix. */
-
-  /*              UPLO = 'L' or 'l'   A is a lower triangular matrix. */
-
-  /*           Unchanged on exit. */
-
-  /*  TRANS  - CHARACTER*1. */
-  /*           On entry, TRANS specifies the operation to be performed as */
-  /*           follows: */
-
-  /*              TRANS = 'N' or 'n'   x := A*x. */
-
-  /*              TRANS = 'T' or 't'   x := A'*x. */
-
-  /*              TRANS = 'C' or 'c'   x := conjg( A' )*x. */
-
-  /*           Unchanged on exit. */
-
-  /*  DIAG   - CHARACTER*1. */
-  /*           On entry, DIAG specifies whether or not A is unit */
-  /*           triangular as follows: */
-
-  /*              DIAG = 'U' or 'u'   A is assumed to be unit triangular. */
-
-  /*              DIAG = 'N' or 'n'   A is not assumed to be unit */
-  /*                                  triangular. */
-
-  /*           Unchanged on exit. */
-
-  /*  N      - INTEGER. */
-  /*           On entry, N specifies the order of the matrix A. */
-  /*           N must be at least zero. */
-  /*           Unchanged on exit. */
-
-  /*  K      - INTEGER. */
-  /*           On entry with UPLO = 'U' or 'u', K specifies the number of */
-  /*           super-diagonals of the matrix A. */
-  /*           On entry with UPLO = 'L' or 'l', K specifies the number of */
-  /*           sub-diagonals of the matrix A. */
-  /*           K must satisfy  0 .le. K. */
-  /*           Unchanged on exit. */
-
-  /*  A      - COMPLEX*16       array of DIMENSION ( LDA, n ). */
-  /*           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the upper triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row */
-  /*           ( k + 1 ) of the array, the first super-diagonal starting at */
-  /*           position 2 in row k, and so on. The top left k by k triangle */
-  /*           of the array A is not referenced. */
-  /*           The following program segment will transfer an upper */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = K + 1 - J */
-  /*                    DO 10, I = MAX( 1, J - K ), J */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) */
-  /*           by n part of the array A must contain the lower triangular */
-  /*           band part of the matrix of coefficients, supplied column by */
-  /*           column, with the leading diagonal of the matrix in row 1 of */
-  /*           the array, the first sub-diagonal starting at position 1 in */
-  /*           row 2, and so on. The bottom right k by k triangle of the */
-  /*           array A is not referenced. */
-  /*           The following program segment will transfer a lower */
-  /*           triangular band matrix from conventional full matrix storage */
-  /*           to band storage: */
-
-  /*                 DO 20, J = 1, N */
-  /*                    M = 1 - J */
-  /*                    DO 10, I = J, MIN( N, J + K ) */
-  /*                       A( M + I, J ) = matrix( I, J ) */
-  /*              10    CONTINUE */
-  /*              20 CONTINUE */
-
-  /*           Note that when DIAG = 'U' or 'u' the elements of the array A */
-  /*           corresponding to the diagonal elements of the matrix are not */
-  /*           referenced, but are assumed to be unity. */
-  /*           Unchanged on exit. */
-
-  /*  LDA    - INTEGER. */
-  /*           On entry, LDA specifies the first dimension of A as declared */
-  /*           in the calling (sub) program. LDA must be at least */
-  /*           ( k + 1 ). */
-  /*           Unchanged on exit. */
-
-  /*  X      - COMPLEX*16       array of dimension at least */
-  /*           ( 1 + ( n - 1 )*abs( INCX ) ). */
-  /*           Before entry, the incremented array X must contain the n */
-  /*           element vector x. On exit, X is overwritten with the */
-  /*           transformed vector x. */
-
-  /*  INCX   - INTEGER. */
-  /*           On entry, INCX specifies the increment for the elements of */
-  /*           X. INCX must not be zero. */
-  /*           Unchanged on exit. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  Level 2 Blas routine. */
-
-  /*  -- Written on 22-October-1986. */
-  /*     Jack Dongarra, Argonne National Lab. */
-  /*     Jeremy Du Croz, Nag Central Office. */
-  /*     Sven Hammarling, Nag Central Office. */
-  /*     Richard Hanson, Sandia National Labs. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-
-  /*     Test the input parameters. */
-
-  /* Parameter adjustments */
-  a_dim1 = *lda;
-  a_offset = 1 + a_dim1;
-  a -= a_offset;
-  --x;
-
-  /* Function Body */
-  info = 0;
-  if (!lsame_(uplo, "U") && !lsame_(uplo, "L")) {
-    info = 1;
-  } else if (!lsame_(trans, "N") && !lsame_(trans, "T") && !lsame_(trans, "C")) {
-    info = 2;
-  } else if (!lsame_(diag, "U") && !lsame_(diag, "N")) {
-    info = 3;
-  } else if (*n < 0) {
-    info = 4;
-  } else if (*k < 0) {
-    info = 5;
-  } else if (*lda < *k + 1) {
-    info = 7;
-  } else if (*incx == 0) {
-    info = 9;
-  }
-  if (info != 0) {
-    xerbla_("ZTBMV ", &info);
-    return;
-  }
-
-  /*     Quick return if possible. */
-
-  if (*n == 0) {
-    return;
-  }
-
-  noconj = lsame_(trans, "T");
-  nounit = lsame_(diag, "N");
-
-  /*     Set up the start point in X if the increment is not unity. This */
-  /*     will be  ( N - 1 )*INCX   too small for descending loops. */
-
-  if (*incx <= 0) {
-    kx = 1 - (*n - 1) * *incx;
-  } else if (*incx != 1) {
-    kx = 1;
-  }
-
-  /*     Start the operations. In this version the elements of A are */
-  /*     accessed sequentially with one pass through A. */
-
-  if (lsame_(trans, "N")) {
-    /*         Form  x := A*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = j;
-          if (x[i__2].r != 0. || x[i__2].i != 0.) {
-            i__2 = j;
-            temp.r = x[i__2].r, temp.i = x[i__2].i;
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__2 = 1, i__3 = j - *k;
-            i__4 = j - 1;
-            for (i__ = max(i__2, i__3); i__ <= i__4; ++i__) {
-              i__2 = i__;
-              i__3 = i__;
-              i__5 = l + i__ + j * a_dim1;
-              z__2.r = temp.r * a[i__5].r - temp.i * a[i__5].i, z__2.i = temp.r * a[i__5].i + temp.i * a[i__5].r;
-              z__1.r = x[i__3].r + z__2.r, z__1.i = x[i__3].i + z__2.i;
-              x[i__2].r = z__1.r, x[i__2].i = z__1.i;
-              /* L10: */
-            }
-            if (nounit) {
-              i__4 = j;
-              i__2 = j;
-              i__3 = kplus1 + j * a_dim1;
-              z__1.r = x[i__2].r * a[i__3].r - x[i__2].i * a[i__3].i,
-              z__1.i = x[i__2].r * a[i__3].i + x[i__2].i * a[i__3].r;
-              x[i__4].r = z__1.r, x[i__4].i = z__1.i;
-            }
-          }
-          /* L20: */
-        }
-      } else {
-        jx = kx;
-        i__1 = *n;
-        for (j = 1; j <= i__1; ++j) {
-          i__4 = jx;
-          if (x[i__4].r != 0. || x[i__4].i != 0.) {
-            i__4 = jx;
-            temp.r = x[i__4].r, temp.i = x[i__4].i;
-            ix = kx;
-            l = kplus1 - j;
-            /* Computing MAX */
-            i__4 = 1, i__2 = j - *k;
-            i__3 = j - 1;
-            for (i__ = max(i__4, i__2); i__ <= i__3; ++i__) {
-              i__4 = ix;
-              i__2 = ix;
-              i__5 = l + i__ + j * a_dim1;
-              z__2.r = temp.r * a[i__5].r - temp.i * a[i__5].i, z__2.i = temp.r * a[i__5].i + temp.i * a[i__5].r;
-              z__1.r = x[i__2].r + z__2.r, z__1.i = x[i__2].i + z__2.i;
-              x[i__4].r = z__1.r, x[i__4].i = z__1.i;
-              ix += *incx;
-              /* L30: */
-            }
-            if (nounit) {
-              i__3 = jx;
-              i__4 = jx;
-              i__2 = kplus1 + j * a_dim1;
-              z__1.r = x[i__4].r * a[i__2].r - x[i__4].i * a[i__2].i,
-              z__1.i = x[i__4].r * a[i__2].i + x[i__4].i * a[i__2].r;
-              x[i__3].r = z__1.r, x[i__3].i = z__1.i;
-            }
-          }
-          jx += *incx;
-          if (j > *k) {
-            kx += *incx;
-          }
-          /* L40: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          i__1 = j;
-          if (x[i__1].r != 0. || x[i__1].i != 0.) {
-            i__1 = j;
-            temp.r = x[i__1].r, temp.i = x[i__1].i;
-            l = 1 - j;
-            /* Computing MIN */
-            i__1 = *n, i__3 = j + *k;
-            i__4 = j + 1;
-            for (i__ = min(i__1, i__3); i__ >= i__4; --i__) {
-              i__1 = i__;
-              i__3 = i__;
-              i__2 = l + i__ + j * a_dim1;
-              z__2.r = temp.r * a[i__2].r - temp.i * a[i__2].i, z__2.i = temp.r * a[i__2].i + temp.i * a[i__2].r;
-              z__1.r = x[i__3].r + z__2.r, z__1.i = x[i__3].i + z__2.i;
-              x[i__1].r = z__1.r, x[i__1].i = z__1.i;
-              /* L50: */
-            }
-            if (nounit) {
-              i__4 = j;
-              i__1 = j;
-              i__3 = j * a_dim1 + 1;
-              z__1.r = x[i__1].r * a[i__3].r - x[i__1].i * a[i__3].i,
-              z__1.i = x[i__1].r * a[i__3].i + x[i__1].i * a[i__3].r;
-              x[i__4].r = z__1.r, x[i__4].i = z__1.i;
-            }
-          }
-          /* L60: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          i__4 = jx;
-          if (x[i__4].r != 0. || x[i__4].i != 0.) {
-            i__4 = jx;
-            temp.r = x[i__4].r, temp.i = x[i__4].i;
-            ix = kx;
-            l = 1 - j;
-            /* Computing MIN */
-            i__4 = *n, i__1 = j + *k;
-            i__3 = j + 1;
-            for (i__ = min(i__4, i__1); i__ >= i__3; --i__) {
-              i__4 = ix;
-              i__1 = ix;
-              i__2 = l + i__ + j * a_dim1;
-              z__2.r = temp.r * a[i__2].r - temp.i * a[i__2].i, z__2.i = temp.r * a[i__2].i + temp.i * a[i__2].r;
-              z__1.r = x[i__1].r + z__2.r, z__1.i = x[i__1].i + z__2.i;
-              x[i__4].r = z__1.r, x[i__4].i = z__1.i;
-              ix -= *incx;
-              /* L70: */
-            }
-            if (nounit) {
-              i__3 = jx;
-              i__4 = jx;
-              i__1 = j * a_dim1 + 1;
-              z__1.r = x[i__4].r * a[i__1].r - x[i__4].i * a[i__1].i,
-              z__1.i = x[i__4].r * a[i__1].i + x[i__4].i * a[i__1].r;
-              x[i__3].r = z__1.r, x[i__3].i = z__1.i;
-            }
-          }
-          jx -= *incx;
-          if (*n - j >= *k) {
-            kx -= *incx;
-          }
-          /* L80: */
-        }
-      }
-    }
-  } else {
-    /*        Form  x := A'*x  or  x := conjg( A' )*x. */
-
-    if (lsame_(uplo, "U")) {
-      kplus1 = *k + 1;
-      if (*incx == 1) {
-        for (j = *n; j >= 1; --j) {
-          i__3 = j;
-          temp.r = x[i__3].r, temp.i = x[i__3].i;
-          l = kplus1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__3 = kplus1 + j * a_dim1;
-              z__1.r = temp.r * a[i__3].r - temp.i * a[i__3].i, z__1.i = temp.r * a[i__3].i + temp.i * a[i__3].r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              i__4 = l + i__ + j * a_dim1;
-              i__1 = i__;
-              z__2.r = a[i__4].r * x[i__1].r - a[i__4].i * x[i__1].i,
-              z__2.i = a[i__4].r * x[i__1].i + a[i__4].i * x[i__1].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              /* L90: */
-            }
-          } else {
-            if (nounit) {
-              d_cnjg(&z__2, &a[kplus1 + j * a_dim1]);
-              z__1.r = temp.r * z__2.r - temp.i * z__2.i, z__1.i = temp.r * z__2.i + temp.i * z__2.r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-              i__4 = i__;
-              z__2.r = z__3.r * x[i__4].r - z__3.i * x[i__4].i, z__2.i = z__3.r * x[i__4].i + z__3.i * x[i__4].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              /* L100: */
-            }
-          }
-          i__3 = j;
-          x[i__3].r = temp.r, x[i__3].i = temp.i;
-          /* L110: */
-        }
-      } else {
-        kx += (*n - 1) * *incx;
-        jx = kx;
-        for (j = *n; j >= 1; --j) {
-          i__3 = jx;
-          temp.r = x[i__3].r, temp.i = x[i__3].i;
-          kx -= *incx;
-          ix = kx;
-          l = kplus1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__3 = kplus1 + j * a_dim1;
-              z__1.r = temp.r * a[i__3].r - temp.i * a[i__3].i, z__1.i = temp.r * a[i__3].i + temp.i * a[i__3].r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              i__4 = l + i__ + j * a_dim1;
-              i__1 = ix;
-              z__2.r = a[i__4].r * x[i__1].r - a[i__4].i * x[i__1].i,
-              z__2.i = a[i__4].r * x[i__1].i + a[i__4].i * x[i__1].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              ix -= *incx;
-              /* L120: */
-            }
-          } else {
-            if (nounit) {
-              d_cnjg(&z__2, &a[kplus1 + j * a_dim1]);
-              z__1.r = temp.r * z__2.r - temp.i * z__2.i, z__1.i = temp.r * z__2.i + temp.i * z__2.r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MAX */
-            i__4 = 1, i__1 = j - *k;
-            i__3 = max(i__4, i__1);
-            for (i__ = j - 1; i__ >= i__3; --i__) {
-              d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-              i__4 = ix;
-              z__2.r = z__3.r * x[i__4].r - z__3.i * x[i__4].i, z__2.i = z__3.r * x[i__4].i + z__3.i * x[i__4].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              ix -= *incx;
-              /* L130: */
-            }
-          }
-          i__3 = jx;
-          x[i__3].r = temp.r, x[i__3].i = temp.i;
-          jx -= *incx;
-          /* L140: */
-        }
-      }
-    } else {
-      if (*incx == 1) {
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          i__4 = j;
-          temp.r = x[i__4].r, temp.i = x[i__4].i;
-          l = 1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__4 = j * a_dim1 + 1;
-              z__1.r = temp.r * a[i__4].r - temp.i * a[i__4].i, z__1.i = temp.r * a[i__4].i + temp.i * a[i__4].r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              i__1 = l + i__ + j * a_dim1;
-              i__2 = i__;
-              z__2.r = a[i__1].r * x[i__2].r - a[i__1].i * x[i__2].i,
-              z__2.i = a[i__1].r * x[i__2].i + a[i__1].i * x[i__2].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              /* L150: */
-            }
-          } else {
-            if (nounit) {
-              d_cnjg(&z__2, &a[j * a_dim1 + 1]);
-              z__1.r = temp.r * z__2.r - temp.i * z__2.i, z__1.i = temp.r * z__2.i + temp.i * z__2.r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-              i__1 = i__;
-              z__2.r = z__3.r * x[i__1].r - z__3.i * x[i__1].i, z__2.i = z__3.r * x[i__1].i + z__3.i * x[i__1].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              /* L160: */
-            }
-          }
-          i__4 = j;
-          x[i__4].r = temp.r, x[i__4].i = temp.i;
-          /* L170: */
-        }
-      } else {
-        jx = kx;
-        i__3 = *n;
-        for (j = 1; j <= i__3; ++j) {
-          i__4 = jx;
-          temp.r = x[i__4].r, temp.i = x[i__4].i;
-          kx += *incx;
-          ix = kx;
-          l = 1 - j;
-          if (noconj) {
-            if (nounit) {
-              i__4 = j * a_dim1 + 1;
-              z__1.r = temp.r * a[i__4].r - temp.i * a[i__4].i, z__1.i = temp.r * a[i__4].i + temp.i * a[i__4].r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              i__1 = l + i__ + j * a_dim1;
-              i__2 = ix;
-              z__2.r = a[i__1].r * x[i__2].r - a[i__1].i * x[i__2].i,
-              z__2.i = a[i__1].r * x[i__2].i + a[i__1].i * x[i__2].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              ix += *incx;
-              /* L180: */
-            }
-          } else {
-            if (nounit) {
-              d_cnjg(&z__2, &a[j * a_dim1 + 1]);
-              z__1.r = temp.r * z__2.r - temp.i * z__2.i, z__1.i = temp.r * z__2.i + temp.i * z__2.r;
-              temp.r = z__1.r, temp.i = z__1.i;
-            }
-            /* Computing MIN */
-            i__1 = *n, i__2 = j + *k;
-            i__4 = min(i__1, i__2);
-            for (i__ = j + 1; i__ <= i__4; ++i__) {
-              d_cnjg(&z__3, &a[l + i__ + j * a_dim1]);
-              i__1 = ix;
-              z__2.r = z__3.r * x[i__1].r - z__3.i * x[i__1].i, z__2.i = z__3.r * x[i__1].i + z__3.i * x[i__1].r;
-              z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
-              temp.r = z__1.r, temp.i = z__1.i;
-              ix += *incx;
-              /* L190: */
-            }
-          }
-          i__4 = jx;
-          x[i__4].r = temp.r, x[i__4].i = temp.i;
-          jx += *incx;
-          /* L200: */
-        }
-      }
-    }
-  }
-
-  /*     End of ZTBMV . */
-
-} /* ztbmv_ */
diff --git a/blas/level1_cplx_impl.h b/blas/level1_cplx_impl.h
index 3181a50..314d1a7 100644
--- a/blas/level1_cplx_impl.h
+++ b/blas/level1_cplx_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 
@@ -22,18 +23,27 @@
 }  // namespace internal
 }  // namespace Eigen
 
+// computes |Re(z)| + |Im(z)| of a complex number z.
+extern "C" RealScalar EIGEN_CAT(REAL_SCALAR_SUFFIX, EIGEN_CAT(cabs1, EIGEN_BLAS_FUNC_SUFFIX))(Complex *z) {
+  return Eigen::numext::norm1(*z);
+}
+
 // computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
 // res = |Rex1| + |Imx1| + |Rex2| + |Imx2| + ... + |Rexn| + |Imxn|, where x is a vector of order n
 extern "C" RealScalar EIGEN_CAT(REAL_SCALAR_SUFFIX, EIGEN_BLAS_FUNC_NAME(asum))(int *n, RealScalar *px, int *incx) {
-  //   std::cerr << "__asum " << *n << " " << *incx << "\n";
-  Complex *x = reinterpret_cast<Complex *>(px);
-
   if (*n <= 0) return 0;
 
+  // std::complex<T> is layout-compatible with T[2], so we can reinterpret
+  // a complex vector of length n as a real vector of length 2*n and use
+  // the fully vectorized cwiseAbs().sum() path.
   if (*incx == 1)
-    return make_vector(x, *n).unaryExpr<scalar_norm1_op>().sum();
-  else
+    return make_vector(px, 2 * *n).cwiseAbs().sum();
+  else {
+    // For non-unit stride, fall back to the scalar_norm1_op approach since
+    // the real components are not contiguous across complex elements.
+    Complex *x = reinterpret_cast<Complex *>(px);
     return make_vector(x, *n, std::abs(*incx)).unaryExpr<scalar_norm1_op>().sum();
+  }
 }
 
 extern "C" int EIGEN_CAT(i, EIGEN_BLAS_FUNC_NAME(amax))(int *n, RealScalar *px, int *incx) {
@@ -117,7 +127,7 @@
 
   if (*incx == 1) return make_vector(x, *n).stableNorm();
 
-  return make_vector(x, *n, *incx).stableNorm();
+  return make_vector(x, *n, std::abs(*incx)).stableNorm();
 }
 
 EIGEN_BLAS_FUNC(EIGEN_CAT(REAL_SCALAR_SUFFIX, rot))
diff --git a/blas/level1_impl.h b/blas/level1_impl.h
index 085b356..525a628 100644
--- a/blas/level1_impl.h
+++ b/blas/level1_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 
@@ -69,15 +70,21 @@
   // be careful, *incx==0 is allowed !!
   if (*incx == 1 && *incy == 1)
     make_vector(y, *n) = make_vector(x, *n);
-  else {
-    if (*incx < 0) x = x - (*n - 1) * (*incx);
+  else if (*incx == 0) {
+    // Broadcast: copy x[0] to all elements of y.
     if (*incy < 0) y = y - (*n - 1) * (*incy);
     for (int i = 0; i < *n; ++i) {
       *y = *x;
-      x += *incx;
       y += *incy;
     }
-  }
+  } else if (*incx > 0 && *incy > 0)
+    make_vector(y, *n, *incy) = make_vector(x, *n, *incx);
+  else if (*incx > 0 && *incy < 0)
+    make_vector(y, *n, -*incy).reverse() = make_vector(x, *n, *incx);
+  else if (*incx < 0 && *incy > 0)
+    make_vector(y, *n, *incy) = make_vector(x, *n, -*incx).reverse();
+  else if (*incx < 0 && *incy < 0)
+    make_vector(y, *n, -*incy) = make_vector(x, *n, -*incx);
 }
 
 EIGEN_BLAS_FUNC(rotg)(RealScalar *pa, RealScalar *pb, RealScalar *pc, RealScalar *ps) {
diff --git a/blas/level1_real_impl.h b/blas/level1_real_impl.h
index 202f432..7a213dd 100644
--- a/blas/level1_real_impl.h
+++ b/blas/level1_real_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 
@@ -58,23 +59,21 @@
   Scalar *y = reinterpret_cast<Scalar *>(py);
 
   if (*incx == 1 && *incy == 1)
-    return (make_vector(x, *n).cwiseProduct(make_vector(y, *n))).sum();
+    return make_vector(x, *n).dot(make_vector(y, *n));
   else if (*incx > 0 && *incy > 0)
-    return (make_vector(x, *n, *incx).cwiseProduct(make_vector(y, *n, *incy))).sum();
+    return make_vector(x, *n, *incx).dot(make_vector(y, *n, *incy));
   else if (*incx < 0 && *incy > 0)
-    return (make_vector(x, *n, -*incx).reverse().cwiseProduct(make_vector(y, *n, *incy))).sum();
+    return make_vector(x, *n, -*incx).reverse().dot(make_vector(y, *n, *incy));
   else if (*incx > 0 && *incy < 0)
-    return (make_vector(x, *n, *incx).cwiseProduct(make_vector(y, *n, -*incy).reverse())).sum();
+    return make_vector(x, *n, *incx).dot(make_vector(y, *n, -*incy).reverse());
   else if (*incx < 0 && *incy < 0)
-    return (make_vector(x, *n, -*incx).reverse().cwiseProduct(make_vector(y, *n, -*incy).reverse())).sum();
+    return make_vector(x, *n, -*incx).reverse().dot(make_vector(y, *n, -*incy).reverse());
   else
     return 0;
 }
 
 // computes the Euclidean norm of a vector.
-// FIXME
 extern "C" Scalar EIGEN_BLAS_FUNC_NAME(nrm2)(int *n, Scalar *px, int *incx) {
-  //   std::cerr << "_nrm2 " << *n << " " << *incx << "\n";
   if (*n <= 0) return 0;
 
   Scalar *x = reinterpret_cast<Scalar *>(px);
@@ -108,23 +107,171 @@
     Eigen::internal::apply_rotation_in_the_plane(vx, vy, Eigen::JacobiRotation<Scalar>(c, s));
 }
 
-/*
-// performs rotation of points in the modified plane.
-EIGEN_BLAS_FUNC(rotm)(int *n, Scalar *px, int *incx, Scalar *py, int *incy, Scalar *param)
-{
-  Scalar* x = reinterpret_cast<Scalar*>(px);
-  Scalar* y = reinterpret_cast<Scalar*>(py);
+// Applies modified Givens rotation H to vectors x and y.
+//   param[0] = flag:
+//     -1: H = [[h11, h12], [h21, h22]]         (all 4 elements from param)
+//      0: H = [[1, h12], [h21, 1]]              (h12, h21 from param)
+//      1: H = [[h11, 1], [-1, h22]]             (h11, h22 from param)
+//     -2: H = identity                           (no-op)
+//   param[1..4] = h11, h21, h12, h22
+EIGEN_BLAS_FUNC(rotm)(int *n, Scalar *px, int *incx, Scalar *py, int *incy, Scalar *param) {
+  Scalar *x = reinterpret_cast<Scalar *>(px);
+  Scalar *y = reinterpret_cast<Scalar *>(py);
 
-  // TODO
+  Scalar flag = param[0];
+  if (*n <= 0 || flag == Scalar(-2)) return;
 
-  return 0;
+  Scalar h11, h12, h21, h22;
+  if (flag < Scalar(0)) {
+    h11 = param[1];
+    h21 = param[2];
+    h12 = param[3];
+    h22 = param[4];
+  } else if (flag == Scalar(0)) {
+    h11 = Scalar(1);
+    h21 = param[2];
+    h12 = param[3];
+    h22 = Scalar(1);
+  } else {
+    h11 = param[1];
+    h21 = Scalar(-1);
+    h12 = Scalar(1);
+    h22 = param[4];
+  }
+
+  int kx = *incx > 0 ? 0 : (1 - *n) * *incx;
+  int ky = *incy > 0 ? 0 : (1 - *n) * *incy;
+
+  for (int i = 0; i < *n; ++i) {
+    Scalar w = x[kx];
+    Scalar z = y[ky];
+    x[kx] = h11 * w + h12 * z;
+    y[ky] = h21 * w + h22 * z;
+    kx += *incx;
+    ky += *incy;
+  }
 }
 
-// computes the modified parameters for a Givens rotation.
-EIGEN_BLAS_FUNC(rotmg)(Scalar *d1, Scalar *d2, Scalar *x1, Scalar *x2, Scalar *param)
-{
-  // TODO
+// Constructs the modified Givens transformation matrix H which zeros the second
+// component of (sqrt(d1)*x1, sqrt(d2)*y1)^T.
+EIGEN_BLAS_FUNC(rotmg)(Scalar *d1, Scalar *d2, Scalar *x1, Scalar *y1, Scalar *param) {
+  using std::abs;
 
-  return 0;
+  const Scalar gam = Scalar(4096);
+  const Scalar gamsq = gam * gam;
+  const Scalar rgamsq = Scalar(1) / gamsq;
+
+  Scalar flag, h11 = Scalar(0), h12 = Scalar(0), h21 = Scalar(0), h22 = Scalar(0);
+
+  if (*d1 < Scalar(0)) {
+    // Negative d1: zero everything.
+    flag = Scalar(-1);
+    *d1 = *d2 = *x1 = Scalar(0);
+  } else {
+    Scalar p2 = *d2 * *y1;
+    if (p2 == Scalar(0)) {
+      // d2*y1 == 0: identity transform.
+      param[0] = Scalar(-2);
+      return;
+    }
+
+    Scalar p1 = *d1 * *x1;
+    Scalar q2 = p2 * *y1;
+    Scalar q1 = p1 * *x1;
+    bool do_scale = true;
+
+    if (abs(q1) > abs(q2)) {
+      h21 = -(*y1) / *x1;
+      h12 = p2 / p1;
+      Scalar u = Scalar(1) - h12 * h21;
+      if (u <= Scalar(0)) {
+        flag = Scalar(-1);
+        h11 = h12 = h21 = h22 = Scalar(0);
+        *d1 = *d2 = *x1 = Scalar(0);
+        do_scale = false;
+      } else {
+        flag = Scalar(0);
+        *d1 /= u;
+        *d2 /= u;
+        *x1 *= u;
+      }
+    } else if (q2 < Scalar(0)) {
+      flag = Scalar(-1);
+      h11 = h12 = h21 = h22 = Scalar(0);
+      *d1 = *d2 = *x1 = Scalar(0);
+      do_scale = false;
+    } else {
+      flag = Scalar(1);
+      h11 = p1 / p2;
+      h22 = *x1 / *y1;
+      Scalar u = Scalar(1) + h11 * h22;
+      Scalar temp = *d2 / u;
+      *d2 = *d1 / u;
+      *d1 = temp;
+      *x1 = *y1 * u;
+    }
+
+    if (do_scale) {
+      // Converts compact H representation (flag 0 or 1) to full form (flag -1)
+      // so that scaling factors can be absorbed into all four elements.
+      auto fix_h = [&]() {
+        if (flag >= Scalar(0)) {
+          if (flag == Scalar(0)) {
+            h11 = Scalar(1);
+            h22 = Scalar(1);
+          } else {
+            h21 = Scalar(-1);
+            h12 = Scalar(1);
+          }
+          flag = Scalar(-1);
+        }
+      };
+
+      // Scale d1 up if too small.
+      while (*d1 <= rgamsq && *d1 != Scalar(0)) {
+        fix_h();
+        *d1 *= gamsq;
+        *x1 /= gam;
+        h11 /= gam;
+        h12 /= gam;
+      }
+      // Scale d1 down if too large.
+      while (*d1 >= gamsq) {
+        fix_h();
+        *d1 /= gamsq;
+        *x1 *= gam;
+        h11 *= gam;
+        h12 *= gam;
+      }
+      // Scale |d2| up if too small.
+      while (abs(*d2) <= rgamsq && *d2 != Scalar(0)) {
+        fix_h();
+        *d2 *= gamsq;
+        h21 /= gam;
+        h22 /= gam;
+      }
+      // Scale |d2| down if too large.
+      while (abs(*d2) >= gamsq) {
+        fix_h();
+        *d2 /= gamsq;
+        h21 *= gam;
+        h22 *= gam;
+      }
+    }
+  }
+
+  // Store result in param array.
+  if (flag < Scalar(0)) {
+    param[1] = h11;
+    param[2] = h21;
+    param[3] = h12;
+    param[4] = h22;
+  } else if (flag == Scalar(0)) {
+    param[2] = h21;
+    param[3] = h12;
+  } else {
+    param[1] = h11;
+    param[4] = h22;
+  }
+  param[0] = flag;
 }
-*/
diff --git a/blas/level2_cplx_impl.h b/blas/level2_cplx_impl.h
index d1ce492..60d6869 100644
--- a/blas/level2_cplx_impl.h
+++ b/blas/level2_cplx_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 
@@ -47,7 +48,7 @@
     info = 7;
   else if (*incy == 0)
     info = 10;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HEMV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HEMV ", &info, kBlasNameLength);
 
   if (*n == 0) return;
 
@@ -72,31 +73,193 @@
   if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
 }
 
-/**  ZHBMV  performs the matrix-vector  operation
+/**  HBMV  performs the matrix-vector operation
  *
  *     y := alpha*A*x + beta*y,
  *
  *  where alpha and beta are scalars, x and y are n element vectors and
  *  A is an n by n hermitian band matrix, with k super-diagonals.
+ *  Diagonal elements are real; off-diagonal contributions use conjugation.
  */
-// EIGEN_BLAS_FUNC(hbmv)(char *uplo, int *n, int *k, RealScalar *alpha, RealScalar *a, int *lda,
-//                           RealScalar *x, int *incx, RealScalar *beta, RealScalar *y, int *incy)
-// {
-//   return 1;
-// }
+EIGEN_BLAS_FUNC(hbmv)
+(char *uplo, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *px, int *incx, RealScalar *pbeta,
+ RealScalar *py, int *incy) {
+  const Scalar alpha = *reinterpret_cast<const Scalar *>(palpha);
+  const Scalar beta = *reinterpret_cast<const Scalar *>(pbeta);
+  const Scalar *a = reinterpret_cast<const Scalar *>(pa);
+  const Scalar *x = reinterpret_cast<const Scalar *>(px);
+  Scalar *y = reinterpret_cast<Scalar *>(py);
 
-/**  ZHPMV  performs the matrix-vector operation
+  int info = 0;
+  if (UPLO(*uplo) == INVALID)
+    info = 1;
+  else if (*n < 0)
+    info = 2;
+  else if (*k < 0)
+    info = 3;
+  else if (*lda < *k + 1)
+    info = 6;
+  else if (*incx == 0)
+    info = 8;
+  else if (*incy == 0)
+    info = 11;
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HBMV ", &info, kBlasNameLength);
+
+  if (*n == 0 || (alpha == Scalar(0) && beta == Scalar(1))) return;
+
+  const Scalar *actual_x = get_compact_vector(x, *n, *incx);
+  Scalar *actual_y = get_compact_vector(y, *n, *incy);
+
+  // First form y := beta*y.
+  if (beta != Scalar(1)) {
+    if (beta == Scalar(0))
+      make_vector(actual_y, *n).setZero();
+    else
+      make_vector(actual_y, *n) *= beta;
+  }
+
+  if (alpha == Scalar(0)) {
+    if (actual_x != x) delete[] actual_x;
+    if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+    return;
+  }
+
+  if (*k >= 8) {
+    // Vectorized path: use Eigen Map segments for the inner band operations.
+    ConstMatrixType band(a, *k + 1, *n, *lda);
+    if (UPLO(*uplo) == UP) {
+      for (int j = 0; j < *n; ++j) {
+        int start = std::max(0, j - *k);
+        int len = j - start;
+        int offset = *k - (j - start);
+        Scalar temp1 = alpha * actual_x[j];
+        actual_y[j] += Scalar(Eigen::numext::real(band(*k, j))) * temp1;
+        if (len > 0) {
+          make_vector(actual_y + start, len) += temp1 * band.col(j).segment(offset, len);
+          actual_y[j] += alpha * band.col(j).segment(offset, len).dot(make_vector(actual_x + start, len));
+        }
+      }
+    } else {
+      for (int j = 0; j < *n; ++j) {
+        int len = std::min(*n - 1, j + *k) - j;
+        Scalar temp1 = alpha * actual_x[j];
+        actual_y[j] += Scalar(Eigen::numext::real(band(0, j))) * temp1;
+        if (len > 0) {
+          make_vector(actual_y + j + 1, len) += temp1 * band.col(j).segment(1, len);
+          actual_y[j] += alpha * band.col(j).segment(1, len).dot(make_vector(actual_x + j + 1, len));
+        }
+      }
+    }
+  } else {
+    // Scalar path: for narrow bandwidth, avoid Map overhead.
+    if (UPLO(*uplo) == UP) {
+      for (int j = 0; j < *n; ++j) {
+        Scalar temp1 = alpha * actual_x[j];
+        Scalar temp2 = Scalar(0);
+        for (int i = std::max(0, j - *k); i < j; ++i) {
+          Scalar aij = a[(*k + i - j) + j * *lda];
+          actual_y[i] += temp1 * aij;
+          temp2 += Eigen::numext::conj(aij) * actual_x[i];
+        }
+        actual_y[j] += Scalar(Eigen::numext::real(a[*k + j * *lda])) * temp1 + alpha * temp2;
+      }
+    } else {
+      for (int j = 0; j < *n; ++j) {
+        Scalar temp1 = alpha * actual_x[j];
+        Scalar temp2 = Scalar(0);
+        actual_y[j] += Scalar(Eigen::numext::real(a[j * *lda])) * temp1;
+        for (int i = j + 1; i <= std::min(*n - 1, j + *k); ++i) {
+          Scalar aij = a[(i - j) + j * *lda];
+          actual_y[i] += temp1 * aij;
+          temp2 += Eigen::numext::conj(aij) * actual_x[i];
+        }
+        actual_y[j] += alpha * temp2;
+      }
+    }
+  }
+
+  if (actual_x != x) delete[] actual_x;
+  if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+}
+
+/**  HPMV  performs the matrix-vector operation
  *
  *     y := alpha*A*x + beta*y,
  *
  *  where alpha and beta are scalars, x and y are n element vectors and
  *  A is an n by n hermitian matrix, supplied in packed form.
+ *  Diagonal elements are real; off-diagonal contributions use conjugation.
  */
-// EIGEN_BLAS_FUNC(hpmv)(char *uplo, int *n, RealScalar *alpha, RealScalar *ap, RealScalar *x, int *incx, RealScalar
-// *beta, RealScalar *y, int *incy)
-// {
-//   return 1;
-// }
+EIGEN_BLAS_FUNC(hpmv)
+(char *uplo, int *n, RealScalar *palpha, RealScalar *pap, RealScalar *px, int *incx, RealScalar *pbeta, RealScalar *py,
+ int *incy) {
+  const Scalar alpha = *reinterpret_cast<const Scalar *>(palpha);
+  const Scalar beta = *reinterpret_cast<const Scalar *>(pbeta);
+  const Scalar *ap = reinterpret_cast<const Scalar *>(pap);
+  const Scalar *x = reinterpret_cast<const Scalar *>(px);
+  Scalar *y = reinterpret_cast<Scalar *>(py);
+
+  int info = 0;
+  if (UPLO(*uplo) == INVALID)
+    info = 1;
+  else if (*n < 0)
+    info = 2;
+  else if (*incx == 0)
+    info = 6;
+  else if (*incy == 0)
+    info = 9;
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HPMV ", &info, kBlasNameLength);
+
+  if (*n == 0 || (alpha == Scalar(0) && beta == Scalar(1))) return;
+
+  const Scalar *actual_x = get_compact_vector(x, *n, *incx);
+  Scalar *actual_y = get_compact_vector(y, *n, *incy);
+
+  // First form y := beta*y.
+  if (beta != Scalar(1)) {
+    if (beta == Scalar(0))
+      make_vector(actual_y, *n).setZero();
+    else
+      make_vector(actual_y, *n) *= beta;
+  }
+
+  if (alpha == Scalar(0)) {
+    if (actual_x != x) delete[] actual_x;
+    if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+    return;
+  }
+
+  int kk = 0;
+  if (UPLO(*uplo) == UP) {
+    // Upper triangle packed: column j occupies ap[kk..kk+j].
+    for (int j = 0; j < *n; ++j) {
+      Scalar temp1 = alpha * actual_x[j];
+      // Diagonal is real.
+      actual_y[j] += Scalar(Eigen::numext::real(ap[kk + j])) * temp1;
+      if (j > 0) {
+        make_vector(actual_y, j) += temp1 * make_vector(ap + kk, j);
+        actual_y[j] += alpha * make_vector(ap + kk, j).dot(make_vector(actual_x, j));
+      }
+      kk += j + 1;
+    }
+  } else {
+    // Lower triangle packed: column j occupies ap[kk..kk+(n-j-1)].
+    for (int j = 0; j < *n; ++j) {
+      int len = *n - j - 1;
+      Scalar temp1 = alpha * actual_x[j];
+      // Diagonal is real.
+      actual_y[j] += Scalar(Eigen::numext::real(ap[kk])) * temp1;
+      if (len > 0) {
+        make_vector(actual_y + j + 1, len) += temp1 * make_vector(ap + kk + 1, len);
+        actual_y[j] += alpha * make_vector(ap + kk + 1, len).dot(make_vector(actual_x + j + 1, len));
+      }
+      kk += *n - j;
+    }
+  }
+
+  if (actual_x != x) delete[] actual_x;
+  if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+}
 
 /**  ZHPR    performs the hermitian rank 1 operation
  *
@@ -125,7 +288,7 @@
     info = 2;
   else if (*incx == 0)
     info = 5;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HPR  ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HPR  ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -170,7 +333,7 @@
     info = 5;
   else if (*incy == 0)
     info = 7;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HPR2 ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HPR2 ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -215,7 +378,7 @@
     info = 5;
   else if (*lda < std::max(1, *n))
     info = 7;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HER  ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HER  ", &info, kBlasNameLength);
 
   if (alpha == RealScalar(0)) return;
 
@@ -265,7 +428,7 @@
     info = 7;
   else if (*lda < std::max(1, *n))
     info = 9;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HER2 ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HER2 ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -308,7 +471,7 @@
     info = 7;
   else if (*lda < std::max(1, *m))
     info = 9;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GERU ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GERU ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -347,7 +510,7 @@
     info = 7;
   else if (*lda < std::max(1, *m))
     info = 9;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GERC ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GERC ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
diff --git a/blas/level2_impl.h b/blas/level2_impl.h
index ca9f48f..3f16f98 100644
--- a/blas/level2_impl.h
+++ b/blas/level2_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 
@@ -55,7 +56,7 @@
     info = 8;
   else if (*incc == 0)
     info = 11;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GEMV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GEMV ", &info, kBlasNameLength);
 
   if (*m == 0 || *n == 0 || (alpha == Scalar(0) && beta == Scalar(1))) return;
 
@@ -140,7 +141,7 @@
     info = 6;
   else if (*incb == 0)
     info = 8;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRSV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRSV ", &info, kBlasNameLength);
 
   Scalar *actual_b = get_compact_vector(b, *n, *incb);
 
@@ -212,7 +213,7 @@
     info = 6;
   else if (*incb == 0)
     info = 8;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRMV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRMV ", &info, kBlasNameLength);
 
   if (*n == 0) return;
 
@@ -263,7 +264,7 @@
     info = 10;
   else if (*incy == 0)
     info = 13;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GBMV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GBMV ", &info, kBlasNameLength);
 
   if (*m == 0 || *n == 0 || (alpha == Scalar(0) && beta == Scalar(1))) return;
 
@@ -303,61 +304,158 @@
   if (actual_y != y) delete[] copy_back(actual_y, y, actual_m, *incy);
 }
 
-#if 0
 /**  TBMV  performs one of the matrix-vector operations
-  *
-  *     x := A*x,   or   x := A'*x,
-  *
-  *  where x is an n element vector and  A is an n by n unit, or non-unit,
-  *  upper or lower triangular band matrix, with ( k + 1 ) diagonals.
-  */
-EIGEN_BLAS_FUNC(tbmv)(char *uplo, char *opa, char *diag, int *n, int *k, RealScalar *pa, int *lda, RealScalar *px, int *incx)
-{
-  Scalar* a = reinterpret_cast<Scalar*>(pa);
-  Scalar* x = reinterpret_cast<Scalar*>(px);
-  int coeff_rows = *k + 1;
+ *
+ *     x := A*x,   or   x := A'*x,   or   x := conjg(A')*x,
+ *
+ *  where x is an n element vector and A is an n by n unit, or non-unit,
+ *  upper or lower triangular band matrix, with ( k + 1 ) diagonals.
+ *
+ *  Band storage: upper triangle stores A[i,j] at a[(k+i-j) + j*lda],
+ *  lower triangle stores A[i,j] at a[(i-j) + j*lda].
+ */
+EIGEN_BLAS_FUNC(tbmv)
+(char *uplo, char *opa, char *diag, int *n, int *k, RealScalar *pa, int *lda, RealScalar *px, int *incx) {
+  Scalar *a = reinterpret_cast<Scalar *>(pa);
+  Scalar *x = reinterpret_cast<Scalar *>(px);
 
   int info = 0;
-       if(UPLO(*uplo)==INVALID)                                       info = 1;
-  else if(OP(*opa)==INVALID)                                          info = 2;
-  else if(DIAG(*diag)==INVALID)                                       info = 3;
-  else if(*n<0)                                                       info = 4;
-  else if(*k<0)                                                       info = 5;
-  else if(*lda<coeff_rows)                                            info = 7;
-  else if(*incx==0)                                                   info = 9;
-  if(info)
-    return xerbla_(SCALAR_SUFFIX_UP"TBMV ",&info,6);
+  if (UPLO(*uplo) == INVALID)
+    info = 1;
+  else if (OP(*opa) == INVALID)
+    info = 2;
+  else if (DIAG(*diag) == INVALID)
+    info = 3;
+  else if (*n < 0)
+    info = 4;
+  else if (*k < 0)
+    info = 5;
+  else if (*lda < *k + 1)
+    info = 7;
+  else if (*incx == 0)
+    info = 9;
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TBMV ", &info, kBlasNameLength);
 
-  if(*n==0) return;
+  if (*n == 0) return;
 
-  int actual_n = *n;
+  Scalar *actual_x = get_compact_vector(x, *n, *incx);
 
-  Scalar* actual_x = get_compact_vector(x,actual_n,*incx);
+  bool upper = (UPLO(*uplo) == UP);
+  int op = OP(*opa);
+  bool unit = (DIAG(*diag) == UNIT);
 
-  MatrixType mat_coeffs(a,coeff_rows,*n,*lda);
-
-  int ku = UPLO(*uplo)==UPPER ? *k : 0;
-  int kl = UPLO(*uplo)==LOWER ? *k : 0;
-
-  for(int j=0; j<*n; ++j)
-  {
-    int start = std::max(0,j - ku);
-    int end = std::min((*m)-1,j + kl);
-    int len = end - start + 1;
-    int offset = (ku) - j + start;
-
-    if(OP(*trans)==NOTR)
-      make_vector(actual_y+start,len) += (alpha*actual_x[j]) * mat_coeffs.col(j).segment(offset,len);
-    else if(OP(*trans)==TR)
-      actual_y[j] += alpha * ( mat_coeffs.col(j).segment(offset,len).transpose() * make_vector(actual_x+start,len) ).value();
-    else
-      actual_y[j] += alpha * ( mat_coeffs.col(j).segment(offset,len).adjoint()   * make_vector(actual_x+start,len) ).value();
+  if (*k >= 8) {
+    // Vectorized path: use Eigen Map segments for the inner band operations.
+    ConstMatrixType band(a, *k + 1, *n, *lda);
+    if (op == NOTR) {
+      if (upper) {
+        for (int j = 0; j < *n; ++j) {
+          if (actual_x[j] != Scalar(0)) {
+            int start = std::max(0, j - *k);
+            int len = j - start;
+            int offset = *k - (j - start);
+            Scalar temp = actual_x[j];
+            if (len > 0) make_vector(actual_x + start, len) += temp * band.col(j).segment(offset, len);
+            if (!unit) actual_x[j] = temp * band(*k, j);
+          }
+        }
+      } else {
+        for (int j = *n - 1; j >= 0; --j) {
+          if (actual_x[j] != Scalar(0)) {
+            int len = std::min(*n - 1, j + *k) - j;
+            Scalar temp = actual_x[j];
+            if (len > 0) make_vector(actual_x + j + 1, len) += temp * band.col(j).segment(1, len);
+            if (!unit) actual_x[j] = temp * band(0, j);
+          }
+        }
+      }
+    } else if (op == TR) {
+      if (upper) {
+        for (int j = *n - 1; j >= 0; --j) {
+          int start = std::max(0, j - *k);
+          int len = j - start;
+          int offset = *k - (j - start);
+          Scalar temp = actual_x[j];
+          if (!unit) temp *= band(*k, j);
+          if (len > 0)
+            temp += (band.col(j).segment(offset, len).cwiseProduct(make_vector(actual_x + start, len))).sum();
+          actual_x[j] = temp;
+        }
+      } else {
+        for (int j = 0; j < *n; ++j) {
+          int len = std::min(*n - 1, j + *k) - j;
+          Scalar temp = actual_x[j];
+          if (!unit) temp *= band(0, j);
+          if (len > 0) temp += (band.col(j).segment(1, len).cwiseProduct(make_vector(actual_x + j + 1, len))).sum();
+          actual_x[j] = temp;
+        }
+      }
+    } else {
+      // Conjugate transpose: .dot() computes conj(lhs) . rhs.
+      if (upper) {
+        for (int j = *n - 1; j >= 0; --j) {
+          int start = std::max(0, j - *k);
+          int len = j - start;
+          int offset = *k - (j - start);
+          Scalar temp = actual_x[j];
+          if (!unit) temp *= Eigen::numext::conj(band(*k, j));
+          if (len > 0) temp += band.col(j).segment(offset, len).dot(make_vector(actual_x + start, len));
+          actual_x[j] = temp;
+        }
+      } else {
+        for (int j = 0; j < *n; ++j) {
+          int len = std::min(*n - 1, j + *k) - j;
+          Scalar temp = actual_x[j];
+          if (!unit) temp *= Eigen::numext::conj(band(0, j));
+          if (len > 0) temp += band.col(j).segment(1, len).dot(make_vector(actual_x + j + 1, len));
+          actual_x[j] = temp;
+        }
+      }
+    }
+  } else {
+    // Scalar path: for narrow bandwidth, avoid Map overhead.
+    if (op == NOTR) {
+      if (upper) {
+        for (int j = 0; j < *n; ++j) {
+          if (actual_x[j] != Scalar(0)) {
+            Scalar temp = actual_x[j];
+            for (int i = std::max(0, j - *k); i < j; ++i) actual_x[i] += temp * a[(*k + i - j) + j * *lda];
+            if (!unit) actual_x[j] = temp * a[*k + j * *lda];
+          }
+        }
+      } else {
+        for (int j = *n - 1; j >= 0; --j) {
+          if (actual_x[j] != Scalar(0)) {
+            Scalar temp = actual_x[j];
+            for (int i = j + 1; i <= std::min(*n - 1, j + *k); ++i) actual_x[i] += temp * a[(i - j) + j * *lda];
+            if (!unit) actual_x[j] = temp * a[j * *lda];
+          }
+        }
+      }
+    } else {
+      // Transpose or conjugate transpose.
+      auto maybe_conj = [op](Scalar val) -> Scalar { return op == ADJ ? Eigen::numext::conj(val) : val; };
+      if (upper) {
+        for (int j = *n - 1; j >= 0; --j) {
+          Scalar temp = actual_x[j];
+          if (!unit) temp *= maybe_conj(a[*k + j * *lda]);
+          for (int i = std::max(0, j - *k); i < j; ++i) temp += maybe_conj(a[(*k + i - j) + j * *lda]) * actual_x[i];
+          actual_x[j] = temp;
+        }
+      } else {
+        for (int j = 0; j < *n; ++j) {
+          Scalar temp = actual_x[j];
+          if (!unit) temp *= maybe_conj(a[j * *lda]);
+          for (int i = j + 1; i <= std::min(*n - 1, j + *k); ++i)
+            temp += maybe_conj(a[(i - j) + j * *lda]) * actual_x[i];
+          actual_x[j] = temp;
+        }
+      }
+    }
   }
 
-  if(actual_x!=x) delete[] actual_x;
-  if(actual_y!=y) delete[] copy_back(actual_y,y,actual_m,*incy);
+  if (actual_x != x) delete[] copy_back(actual_x, x, *n, *incx);
 }
-#endif
 
 /**  DTBSV  solves one of the systems of equations
  *
@@ -429,7 +527,7 @@
     info = 7;
   else if (*incx == 0)
     info = 9;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TBSV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TBSV ", &info, kBlasNameLength);
 
   if (*n == 0 || (*k == 0 && DIAG(*diag) == UNIT)) return;
 
@@ -516,7 +614,7 @@
     info = 4;
   else if (*incx == 0)
     info = 7;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TPMV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TPMV ", &info, kBlasNameLength);
 
   if (*n == 0) return;
 
@@ -605,7 +703,7 @@
     info = 4;
   else if (*incx == 0)
     info = 7;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TPSV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TPSV ", &info, kBlasNameLength);
 
   Scalar *actual_x = get_compact_vector(x, *n, *incx);
 
diff --git a/blas/level2_real_impl.h b/blas/level2_real_impl.h
index 415944c..64265aa 100644
--- a/blas/level2_real_impl.h
+++ b/blas/level2_real_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 
@@ -42,7 +43,7 @@
     info = 7;
   else if (*incy == 0)
     info = 10;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYMV ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYMV ", &info, kBlasNameLength);
 
   if (*n == 0) return;
 
@@ -93,7 +94,7 @@
     info = 5;
   else if (*ldc < std::max(1, *n))
     info = 7;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYR  ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYR  ", &info, kBlasNameLength);
 
   if (*n == 0 || alpha == Scalar(0)) return;
 
@@ -136,7 +137,7 @@
     info = 7;
   else if (*ldc < std::max(1, *n))
     info = 9;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYR2 ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYR2 ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -158,32 +159,196 @@
   //   func[code](*n, a, *inca, b, *incb, c, *ldc, alpha);
 }
 
-/**  DSBMV  performs the matrix-vector  operation
+/**  SBMV  performs the matrix-vector operation
  *
  *     y := alpha*A*x + beta*y,
  *
  *  where alpha and beta are scalars, x and y are n element vectors and
  *  A is an n by n symmetric band matrix, with k super-diagonals.
+ *
+ *  Band storage: upper triangle stores A[i,j] at a[(k+i-j) + j*lda],
+ *  lower triangle stores A[i,j] at a[(i-j) + j*lda].
  */
-// EIGEN_BLAS_FUNC(sbmv)( char *uplo, int *n, int *k, RealScalar *alpha, RealScalar *a, int *lda,
-//                            RealScalar *x, int *incx, RealScalar *beta, RealScalar *y, int *incy)
-// {
-//   return 1;
-// }
+EIGEN_BLAS_FUNC(sbmv)
+(char *uplo, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *px, int *incx, RealScalar *pbeta,
+ RealScalar *py, int *incy) {
+  const Scalar alpha = *reinterpret_cast<const Scalar *>(palpha);
+  const Scalar beta = *reinterpret_cast<const Scalar *>(pbeta);
+  const Scalar *a = reinterpret_cast<const Scalar *>(pa);
+  const Scalar *x = reinterpret_cast<const Scalar *>(px);
+  Scalar *y = reinterpret_cast<Scalar *>(py);
 
-/**  DSPMV  performs the matrix-vector operation
+  int info = 0;
+  if (UPLO(*uplo) == INVALID)
+    info = 1;
+  else if (*n < 0)
+    info = 2;
+  else if (*k < 0)
+    info = 3;
+  else if (*lda < *k + 1)
+    info = 6;
+  else if (*incx == 0)
+    info = 8;
+  else if (*incy == 0)
+    info = 11;
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SBMV ", &info, kBlasNameLength);
+
+  if (*n == 0 || (alpha == Scalar(0) && beta == Scalar(1))) return;
+
+  const Scalar *actual_x = get_compact_vector(x, *n, *incx);
+  Scalar *actual_y = get_compact_vector(y, *n, *incy);
+
+  // First form y := beta*y.
+  if (beta != Scalar(1)) {
+    if (beta == Scalar(0))
+      make_vector(actual_y, *n).setZero();
+    else
+      make_vector(actual_y, *n) *= beta;
+  }
+
+  if (alpha == Scalar(0)) {
+    if (actual_x != x) delete[] actual_x;
+    if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+    return;
+  }
+
+  if (*k >= 8) {
+    // Vectorized path: use Eigen Map segments for the inner band operations.
+    ConstMatrixType band(a, *k + 1, *n, *lda);
+    if (UPLO(*uplo) == UP) {
+      for (int j = 0; j < *n; ++j) {
+        int start = std::max(0, j - *k);
+        int len = j - start;
+        int offset = *k - (j - start);
+        Scalar temp1 = alpha * actual_x[j];
+        actual_y[j] += temp1 * band(*k, j);
+        if (len > 0) {
+          make_vector(actual_y + start, len) += temp1 * band.col(j).segment(offset, len);
+          actual_y[j] += alpha * band.col(j).segment(offset, len).dot(make_vector(actual_x + start, len));
+        }
+      }
+    } else {
+      for (int j = 0; j < *n; ++j) {
+        int len = std::min(*n - 1, j + *k) - j;
+        Scalar temp1 = alpha * actual_x[j];
+        actual_y[j] += temp1 * band(0, j);
+        if (len > 0) {
+          make_vector(actual_y + j + 1, len) += temp1 * band.col(j).segment(1, len);
+          actual_y[j] += alpha * band.col(j).segment(1, len).dot(make_vector(actual_x + j + 1, len));
+        }
+      }
+    }
+  } else {
+    // Scalar path: for narrow bandwidth, avoid Map overhead.
+    if (UPLO(*uplo) == UP) {
+      for (int j = 0; j < *n; ++j) {
+        Scalar temp1 = alpha * actual_x[j];
+        Scalar temp2 = Scalar(0);
+        for (int i = std::max(0, j - *k); i < j; ++i) {
+          Scalar aij = a[(*k + i - j) + j * *lda];
+          actual_y[i] += temp1 * aij;
+          temp2 += aij * actual_x[i];
+        }
+        actual_y[j] += temp1 * a[*k + j * *lda] + alpha * temp2;
+      }
+    } else {
+      for (int j = 0; j < *n; ++j) {
+        Scalar temp1 = alpha * actual_x[j];
+        Scalar temp2 = Scalar(0);
+        actual_y[j] += temp1 * a[j * *lda];
+        for (int i = j + 1; i <= std::min(*n - 1, j + *k); ++i) {
+          Scalar aij = a[(i - j) + j * *lda];
+          actual_y[i] += temp1 * aij;
+          temp2 += aij * actual_x[i];
+        }
+        actual_y[j] += alpha * temp2;
+      }
+    }
+  }
+
+  if (actual_x != x) delete[] actual_x;
+  if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+}
+
+/**  SPMV  performs the matrix-vector operation
  *
  *     y := alpha*A*x + beta*y,
  *
  *  where alpha and beta are scalars, x and y are n element vectors and
  *  A is an n by n symmetric matrix, supplied in packed form.
  *
+ *  Packed storage: upper triangle stores columns sequentially so that
+ *  column j occupies positions kk..kk+j (where kk = j*(j+1)/2),
+ *  lower triangle stores column j at positions kk..kk+(n-j-1).
  */
-// EIGEN_BLAS_FUNC(spmv)(char *uplo, int *n, RealScalar *alpha, RealScalar *ap, RealScalar *x, int *incx, RealScalar
-// *beta, RealScalar *y, int *incy)
-// {
-//   return 1;
-// }
+EIGEN_BLAS_FUNC(spmv)
+(char *uplo, int *n, RealScalar *palpha, RealScalar *pap, RealScalar *px, int *incx, RealScalar *pbeta, RealScalar *py,
+ int *incy) {
+  const Scalar alpha = *reinterpret_cast<const Scalar *>(palpha);
+  const Scalar beta = *reinterpret_cast<const Scalar *>(pbeta);
+  const Scalar *ap = reinterpret_cast<const Scalar *>(pap);
+  const Scalar *x = reinterpret_cast<const Scalar *>(px);
+  Scalar *y = reinterpret_cast<Scalar *>(py);
+
+  int info = 0;
+  if (UPLO(*uplo) == INVALID)
+    info = 1;
+  else if (*n < 0)
+    info = 2;
+  else if (*incx == 0)
+    info = 6;
+  else if (*incy == 0)
+    info = 9;
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SPMV ", &info, kBlasNameLength);
+
+  if (*n == 0 || (alpha == Scalar(0) && beta == Scalar(1))) return;
+
+  const Scalar *actual_x = get_compact_vector(x, *n, *incx);
+  Scalar *actual_y = get_compact_vector(y, *n, *incy);
+
+  // First form y := beta*y.
+  if (beta != Scalar(1)) {
+    if (beta == Scalar(0))
+      make_vector(actual_y, *n).setZero();
+    else
+      make_vector(actual_y, *n) *= beta;
+  }
+
+  if (alpha == Scalar(0)) {
+    if (actual_x != x) delete[] actual_x;
+    if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+    return;
+  }
+
+  int kk = 0;
+  if (UPLO(*uplo) == UP) {
+    // Upper triangle packed: column j occupies ap[kk..kk+j].
+    for (int j = 0; j < *n; ++j) {
+      Scalar temp1 = alpha * actual_x[j];
+      actual_y[j] += temp1 * ap[kk + j];
+      if (j > 0) {
+        make_vector(actual_y, j) += temp1 * make_vector(ap + kk, j);
+        actual_y[j] += alpha * make_vector(ap + kk, j).dot(make_vector(actual_x, j));
+      }
+      kk += j + 1;
+    }
+  } else {
+    // Lower triangle packed: column j occupies ap[kk..kk+(n-j-1)].
+    for (int j = 0; j < *n; ++j) {
+      int len = *n - j - 1;
+      Scalar temp1 = alpha * actual_x[j];
+      actual_y[j] += temp1 * ap[kk];
+      if (len > 0) {
+        make_vector(actual_y + j + 1, len) += temp1 * make_vector(ap + kk + 1, len);
+        actual_y[j] += alpha * make_vector(ap + kk + 1, len).dot(make_vector(actual_x + j + 1, len));
+      }
+      kk += *n - j;
+    }
+  }
+
+  if (actual_x != x) delete[] actual_x;
+  if (actual_y != y) delete[] copy_back(actual_y, y, *n, *incy);
+}
 
 /**  DSPR    performs the symmetric rank 1 operation
  *
@@ -212,7 +377,7 @@
     info = 2;
   else if (*incx == 0)
     info = 5;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SPR  ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SPR  ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -257,7 +422,7 @@
     info = 5;
   else if (*incy == 0)
     info = 7;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SPR2 ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SPR2 ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
@@ -298,7 +463,7 @@
     info = 7;
   else if (*lda < std::max(1, *m))
     info = 9;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GER  ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GER  ", &info, kBlasNameLength);
 
   if (alpha == Scalar(0)) return;
 
diff --git a/blas/level3_impl.h b/blas/level3_impl.h
index 03d634c..94c8a08 100644
--- a/blas/level3_impl.h
+++ b/blas/level3_impl.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 #include "common.h"
 
 EIGEN_BLAS_FUNC(gemm)
@@ -74,7 +75,7 @@
     info = 10;
   else if (*ldc < std::max(1, *m))
     info = 13;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GEMM ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GEMM ", &info, kBlasNameLength);
 
   if (*m == 0 || *n == 0) return;
 
@@ -195,7 +196,7 @@
     info = 10;
   else if (*ldc < std::max(1, *n))
     info = 13;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "GEMMTR ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "GEMMTR", &info, kBlasNameLength + 1);
 
   if (*n == 0) return;
 
@@ -343,7 +344,7 @@
     info = 9;
   else if (*ldb < std::max(1, *m))
     info = 11;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRSM ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRSM ", &info, kBlasNameLength);
 
   if (*m == 0 || *n == 0) return;
 
@@ -480,7 +481,7 @@
     info = 9;
   else if (*ldb < std::max(1, *m))
     info = 11;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRMM ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "TRMM ", &info, kBlasNameLength);
 
   int code = OP(*opa) | (SIDE(*side) << 2) | (UPLO(*uplo) << 3) | (DIAG(*diag) << 4);
 
@@ -527,7 +528,7 @@
     info = 9;
   else if (*ldc < std::max(1, *m))
     info = 12;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYMM ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYMM ", &info, kBlasNameLength);
 
   if (beta != Scalar(1)) {
     if (beta == Scalar(0))
@@ -645,7 +646,7 @@
     info = 7;
   else if (*ldc < std::max(1, *n))
     info = 10;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYRK ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYRK ", &info, kBlasNameLength);
 
   if (beta != Scalar(1)) {
     if (UPLO(*uplo) == UP)
@@ -713,7 +714,7 @@
     info = 9;
   else if (*ldc < std::max(1, *n))
     info = 12;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYR2K", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "SYR2K", &info, kBlasNameLength);
 
   using Eigen::Lower;
   using Eigen::Upper;
@@ -780,7 +781,7 @@
     info = 9;
   else if (*ldc < std::max(1, *m))
     info = 12;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HEMM ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HEMM ", &info, kBlasNameLength);
 
   if (beta == Scalar(0))
     matrix(c, *m, *n, *ldc).setZero();
@@ -880,7 +881,7 @@
     info = 7;
   else if (*ldc < std::max(1, *n))
     info = 10;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HERK ", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HERK ", &info, kBlasNameLength);
 
   int code = OP(*op) | (UPLO(*uplo) << 2);
 
@@ -935,7 +936,7 @@
     info = 9;
   else if (*ldc < std::max(1, *n))
     info = 12;
-  if (info) return xerbla_(SCALAR_SUFFIX_UP "HER2K", &info);
+  if (info) return xerbla_(SCALAR_SUFFIX_UP "HER2K", &info, kBlasNameLength);
 
   using Eigen::Lower;
   using Eigen::StrictlyLower;
diff --git a/blas/lsame.cpp b/blas/lsame.cpp
new file mode 100644
index 0000000..27673b4
--- /dev/null
+++ b/blas/lsame.cpp
@@ -0,0 +1,17 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <cctype>
+
+#include "blas.h"
+
+// LSAME returns true if ca and cb are the same letter, regardless of case.
+extern "C" EIGEN_BLAS_API int lsame_(const char *ca, const char *cb) {
+  return std::toupper(static_cast<unsigned char>(*ca)) == std::toupper(static_cast<unsigned char>(*cb));
+}
diff --git a/blas/single.cpp b/blas/single.cpp
index fefb695..6928c05 100644
--- a/blas/single.cpp
+++ b/blas/single.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR float
 #define SCALAR_SUFFIX s
diff --git a/blas/testing/CMakeLists.txt b/blas/testing/CMakeLists.txt
index 8b8ff44..6f72e07 100644
--- a/blas/testing/CMakeLists.txt
+++ b/blas/testing/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 include(CheckLanguage)
 check_language(Fortran)
 if(CMAKE_Fortran_COMPILER)
diff --git a/blas/testing/cblat1.f b/blas/testing/cblat1.f
index 73015f5..0637f9e 100644
--- a/blas/testing/cblat1.f
+++ b/blas/testing/cblat1.f
@@ -35,6 +35,8 @@
 *> \ingroup complex_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM CBLAT1
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/cblat2.f b/blas/testing/cblat2.f
index 5833ea8..5b483d2 100644
--- a/blas/testing/cblat2.f
+++ b/blas/testing/cblat2.f
@@ -101,6 +101,8 @@
 *> \ingroup complex_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM CBLAT2
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/cblat3.f b/blas/testing/cblat3.f
index 09f2cb9..2ea3880 100644
--- a/blas/testing/cblat3.f
+++ b/blas/testing/cblat3.f
@@ -83,6 +83,8 @@
 *> \ingroup complex_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM CBLAT3
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/dblat1.f b/blas/testing/dblat1.f
index 03d9f13..693c817 100644
--- a/blas/testing/dblat1.f
+++ b/blas/testing/dblat1.f
@@ -35,6 +35,8 @@
 *> \ingroup double_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM DBLAT1
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/dblat2.f b/blas/testing/dblat2.f
index 0fa80af..7783ae2 100644
--- a/blas/testing/dblat2.f
+++ b/blas/testing/dblat2.f
@@ -100,6 +100,8 @@
 *> \ingroup double_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM DBLAT2
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/dblat3.f b/blas/testing/dblat3.f
index 8d37c74..62fc7fa 100644
--- a/blas/testing/dblat3.f
+++ b/blas/testing/dblat3.f
@@ -80,6 +80,8 @@
 *> \ingroup double_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM DBLAT3
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/sblat1.f b/blas/testing/sblat1.f
index 4d43d9b..5cc2cda 100644
--- a/blas/testing/sblat1.f
+++ b/blas/testing/sblat1.f
@@ -35,6 +35,8 @@
 *> \ingroup single_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM SBLAT1
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/sblat2.f b/blas/testing/sblat2.f
index 71605ed..6b800d5 100644
--- a/blas/testing/sblat2.f
+++ b/blas/testing/sblat2.f
@@ -100,6 +100,8 @@
 *> \ingroup single_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM SBLAT2
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/sblat3.f b/blas/testing/sblat3.f
index 8792696..4033e39 100644
--- a/blas/testing/sblat3.f
+++ b/blas/testing/sblat3.f
@@ -80,6 +80,8 @@
 *> \ingroup single_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM SBLAT3
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/zblat1.f b/blas/testing/zblat1.f
index c00b67d..ed01519 100644
--- a/blas/testing/zblat1.f
+++ b/blas/testing/zblat1.f
@@ -35,6 +35,8 @@
 *> \ingroup complex16_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM ZBLAT1
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/zblat2.f b/blas/testing/zblat2.f
index 53129a1..8dbdbee 100644
--- a/blas/testing/zblat2.f
+++ b/blas/testing/zblat2.f
@@ -101,6 +101,8 @@
 *> \ingroup complex16_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM ZBLAT2
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/testing/zblat3.f b/blas/testing/zblat3.f
index 59ca241..7ca0de1 100644
--- a/blas/testing/zblat3.f
+++ b/blas/testing/zblat3.f
@@ -84,6 +84,8 @@
 *> \ingroup complex16_blas_testing
 *
 *  =====================================================================
+*> SPDX-FileCopyrightText: The Eigen Authors
+*> SPDX-License-Identifier: BSD-3-Clause
       PROGRAM ZBLAT3
 *
 *  -- Reference BLAS test routine (version 3.4.1) --
diff --git a/blas/xerbla.cpp b/blas/xerbla.cpp
index 94c8c1d..5a735cc 100644
--- a/blas/xerbla.cpp
+++ b/blas/xerbla.cpp
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include <stdio.h>
 
@@ -13,7 +15,9 @@
 extern "C" {
 #endif
 
-EIGEN_WEAK_LINKING void xerbla_(const char *msg, int *info) { printf("Eigen BLAS ERROR #%i: %s\n", *info, msg); }
+EIGEN_WEAK_LINKING void xerbla_(const char* msg, int* info, size_t len) {
+  printf("Eigen BLAS ERROR #%i: %.*s\n", *info, static_cast<int>(len), msg);
+}
 
 #ifdef __cplusplus
 }
diff --git a/cmake/ComputeCppCompilerChecks.cmake b/cmake/ComputeCppCompilerChecks.cmake
index 1807485..14a9d34 100644
--- a/cmake/ComputeCppCompilerChecks.cmake
+++ b/cmake/ComputeCppCompilerChecks.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 cmake_minimum_required(VERSION 3.4.3)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
diff --git a/cmake/ComputeCppIRMap.cmake b/cmake/ComputeCppIRMap.cmake
index 942d91d..f2f0590 100644
--- a/cmake/ComputeCppIRMap.cmake
+++ b/cmake/ComputeCppIRMap.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 cmake_minimum_required(VERSION 3.4.3)
 
 # These should match the types of IR output by compute++
diff --git a/cmake/EigenConfigureTesting.cmake b/cmake/EigenConfigureTesting.cmake
index d72d88a..4638c26 100644
--- a/cmake/EigenConfigureTesting.cmake
+++ b/cmake/EigenConfigureTesting.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 include(EigenTesting)
 include(CheckCXXSourceCompiles)
 
@@ -10,6 +13,19 @@
 
 add_custom_target(buildtests)
 
+# buildsmoketests is created up-front so that ei_add_test_internal — which
+# runs from inside test/ and contrib/test/ — can attach the smoketest
+# label and the build dependency in the same directory scope where add_test()
+# was called.  CMake's set_property(TEST ...) and add_dependencies require
+# this scope match, so a single post-hoc registration from the top level
+# would silently fail for contrib entries.
+add_custom_target(buildsmoketests)
+
+# Load the smoke-test list once.  ei_smoke_test_list is then visible to both
+# test/ and contrib/test/ as a parent-scope variable, and ei_add_test_internal
+# checks it on every test it registers.
+include(EigenSmokeTestList)
+
 if (NOT EIGEN_CTEST_ARGS)
   # By default, run tests in parallel on all available cores.
   set(EIGEN_CTEST_ARGS "" CACHE STRING "-j0")
@@ -20,16 +36,14 @@
 
 # Convenience target for only building GPU tests.
 add_custom_target(buildtests_gpu)
-add_custom_target(check_gpu COMMAND "ctest" "--output-on-failure"
+add_custom_target(check_gpu COMMAND "ctest" ${EIGEN_CTEST_ARGS}
+                                            "--output-on-failure"
                                             "--no-compress-output"
                                             "--build-no-clean"
                                             "-T" "test"
                                             "-L" "gpu")
 add_dependencies(check_gpu buildtests_gpu)
 
-# check whether /bin/bash exists (disabled as not used anymore)
-# find_file(EIGEN_BIN_BASH_EXISTS "/bin/bash" PATHS "/" NO_DEFAULT_PATH)
-
 # This call activates testing and generates the DartConfiguration.tcl
 include(CTest)
 
@@ -70,5 +84,3 @@
 elseif(MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_CRT_SECURE_NO_WARNINGS /D_SCL_SECURE_NO_WARNINGS")
 endif()
-
-
diff --git a/cmake/EigenFailtest.cmake b/cmake/EigenFailtest.cmake
new file mode 100644
index 0000000..c7fd3a8
--- /dev/null
+++ b/cmake/EigenFailtest.cmake
@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Script-mode driver for the tests that ei_add_failtest() and
+# ei_add_failtest_fixture() register (cmake/EigenTesting.cmake).
+#
+# build: deletes every failtest executable, then builds them all, so that an
+#   executable exists afterwards exactly when its target built in this run.  It
+#   always succeeds; the verdicts belong to the check tests.
+# check: <name>_ok passes when its executable exists.  <name>_ko passes when its
+#   executable is missing and the _ok twin's exists: a toolchain or build-system
+#   failure breaks both variants, and must not pass as the asserted compile error.
+
+cmake_minimum_required(VERSION 3.17)
+
+set(config_args "")
+if(NOT EIGEN_FAILTEST_CONFIG STREQUAL "")
+  set(config_args --config "${EIGEN_FAILTEST_CONFIG}")
+endif()
+
+if(EIGEN_FAILTEST_ACTION STREQUAL "build")
+  include("${EIGEN_FAILTEST_LIST}")
+  file(REMOVE ${EIGEN_FAILTEST_FILES})
+
+  set(keep_going "")
+  set(parallel "")
+  if(EIGEN_FAILTEST_GENERATOR MATCHES "Ninja")
+    set(keep_going -k 0)
+  elseif(EIGEN_FAILTEST_GENERATOR MATCHES "^(Unix|MinGW|MSYS) Makefiles$")
+    set(keep_going -k)
+    # Unlike Ninja, make is serial without -j.
+    if(NOT DEFINED ENV{CMAKE_BUILD_PARALLEL_LEVEL})
+      cmake_host_system_information(RESULT jobs QUERY NUMBER_OF_LOGICAL_CORES)
+      set(parallel --parallel ${jobs})
+    endif()
+  endif()
+
+  if(keep_going)
+    execute_process(COMMAND "${CMAKE_COMMAND}" --build "${EIGEN_FAILTEST_BINARY_DIR}" ${config_args}
+                            --target buildfailtests ${parallel} -- ${keep_going})
+  else()
+    # Without a known keep-going flag, the first _ko failure would stop the
+    # batch, so build one target at a time.
+    foreach(target IN LISTS EIGEN_FAILTEST_TARGETS)
+      execute_process(COMMAND "${CMAKE_COMMAND}" --build "${EIGEN_FAILTEST_BINARY_DIR}" ${config_args}
+                              --target ${target})
+    endforeach()
+  endif()
+
+elseif(EIGEN_FAILTEST_ACTION STREQUAL "check")
+  if(DEFINED EIGEN_FAILTEST_KO)
+    if(EXISTS "${EIGEN_FAILTEST_KO_FILE}")
+      message(FATAL_ERROR "${EIGEN_FAILTEST_KO} built, but EIGEN_SHOULD_FAIL_TO_BUILD must break its compile.")
+    endif()
+    if(NOT EXISTS "${EIGEN_FAILTEST_OK_FILE}")
+      message(FATAL_ERROR "${EIGEN_FAILTEST_OK} did not build either, so the failure of "
+                          "${EIGEN_FAILTEST_KO} proves nothing; see the ${EIGEN_FAILTEST_OK} test.")
+    endif()
+  elseif(NOT EXISTS "${EIGEN_FAILTEST_OK_FILE}")
+    # Rebuild the target alone to put its errors in this test's output.  The
+    # lock keeps these builds from running concurrently in one binary directory.
+    file(LOCK "${EIGEN_FAILTEST_LOCK}" GUARD PROCESS)
+    execute_process(COMMAND "${CMAKE_COMMAND}" --build "${EIGEN_FAILTEST_BINARY_DIR}" ${config_args}
+                            --target ${EIGEN_FAILTEST_OK})
+    message(FATAL_ERROR "${EIGEN_FAILTEST_OK} did not build in the buildfailtests fixture.")
+  endif()
+
+else()
+  message(FATAL_ERROR "Unknown EIGEN_FAILTEST_ACTION '${EIGEN_FAILTEST_ACTION}'.")
+endif()
diff --git a/cmake/EigenGpuTesting.cmake b/cmake/EigenGpuTesting.cmake
new file mode 100644
index 0000000..073f14e
--- /dev/null
+++ b/cmake/EigenGpuTesting.cmake
@@ -0,0 +1,180 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# How the .cu tests are compiled. Everything the GPU test build decides lives here, so ei_add_test_internal only
+# has to ask which of three modes is in force:
+#
+#   cuda-language   CMake's first-class CUDA language, the default. nvcc, or clang as the CUDA compiler.
+#   cuda-as-cxx     the .cu files compiled as C++ by a compiler that drives CUDA itself. nvc++ has no CMake CUDA
+#                   language support, and CMake refuses clang as the CUDA compiler on Windows (issue #20776).
+#   hip             CMake's HIP language.
+#
+# ei_gpu_testing_enable() is called once from the top-level CMakeLists, which is where enable_language() has to
+# happen: it affects the calling directory and below, and test/ and contrib/test/ are siblings.
+
+# Resolve EIGEN_CUDA_COMPUTE_ARCH against the toolkit version. Empty selects the oldest architecture the toolkit
+# still compiles for: sm_60, Eigen's documented floor (see Macros.h), or sm_75 from CUDA 13 on, which dropped
+# offline compilation for Pascal and Volta. Honor CMake's architecture setting (including CUDAARCHS) when the
+# Eigen-specific override is empty.
+macro(ei_cuda_resolve_compute_arch)
+  if("${EIGEN_CUDA_COMPUTE_ARCH}" STREQUAL "")
+    if(DEFINED CMAKE_CUDA_ARCHITECTURES AND NOT "${CMAKE_CUDA_ARCHITECTURES}" STREQUAL "")
+      set(EIGEN_CUDA_COMPUTE_ARCH "${CMAKE_CUDA_ARCHITECTURES}")
+    elseif(NOT "$ENV{CUDAARCHS}" STREQUAL "")
+      set(EIGEN_CUDA_COMPUTE_ARCH "$ENV{CUDAARCHS}")
+    elseif(CUDAToolkit_VERSION VERSION_LESS 13.0)
+      set(EIGEN_CUDA_COMPUTE_ARCH 60)
+    else()
+      set(EIGEN_CUDA_COMPUTE_ARCH 75)
+    endif()
+  endif()
+  set_property(GLOBAL PROPERTY EIGEN_CUDA_COMPUTE_ARCH_RESOLVED "${EIGEN_CUDA_COMPUTE_ARCH}")
+endmacro()
+
+macro(ei_gpu_testing_enable)
+  set(EIGEN_GPU_TEST_MODE "none")
+
+  if(EIGEN_TEST_CUDA)
+    # Honours CUDAToolkit_ROOT, which is how one of several installed toolkits is chosen. Without it, an explicit nvcc
+    # selects its own toolkit, <root>/bin/nvcc. find_package derives that only once the CUDA language is enabled, which
+    # needs the toolkit version first; a toolkit other than the compiler's links a second CUDA runtime.
+    if(CMAKE_CUDA_COMPILER AND NOT EIGEN_TEST_CUDA_NVC AND NOT EIGEN_TEST_CUDA_CLANG AND
+       NOT DEFINED CUDAToolkit_ROOT AND NOT DEFINED ENV{CUDAToolkit_ROOT})
+      get_filename_component(CUDAToolkit_ROOT "${CMAKE_CUDA_COMPILER}" PROGRAM)
+      get_filename_component(CUDAToolkit_ROOT "${CUDAToolkit_ROOT}" DIRECTORY)
+      get_filename_component(CUDAToolkit_ROOT "${CUDAToolkit_ROOT}" DIRECTORY)
+    endif()
+    find_package(CUDAToolkit 11.8 REQUIRED)
+    ei_cuda_resolve_compute_arch()
+
+    if(EIGEN_TEST_CUDA_NVC OR (EIGEN_TEST_CUDA_CLANG AND WIN32))
+      set(EIGEN_GPU_TEST_MODE "cuda-as-cxx")
+      # CMake's named and suffixed architectures cannot be used verbatim in these compiler flags.
+      foreach(arch IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
+        if(NOT arch MATCHES "^[0-9]+$")
+          message(FATAL_ERROR "EIGEN_CUDA_COMPUTE_ARCH=${EIGEN_CUDA_COMPUTE_ARCH}: this compiler route takes numeric "
+                              "architectures only, for example 75;89.")
+        endif()
+      endforeach()
+      if(EIGEN_TEST_CUDA_NVC)
+        string(APPEND CMAKE_CXX_FLAGS " -cuda")
+        foreach(arch IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
+          string(APPEND CMAKE_CXX_FLAGS " -gpu=cc${arch}")
+        endforeach()
+      else()
+        string(APPEND CMAKE_CXX_FLAGS " --cuda-path=${CUDAToolkit_TARGET_DIR}")
+        foreach(arch IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
+          string(APPEND CMAKE_CXX_FLAGS " --cuda-gpu-arch=sm_${arch}")
+        endforeach()
+      endif()
+      string(APPEND CMAKE_CXX_FLAGS " ${EIGEN_CUDA_CXX_FLAGS}")
+    else()
+      set(EIGEN_GPU_TEST_MODE "cuda-language")
+      # CMP0104 is NEW from 3.18, so the architectures have to be known before the language is enabled.
+      if(EIGEN_CUDA_COMPUTE_ARCH MATCHES "native|all|all-major" AND CMAKE_VERSION VERSION_LESS 3.24)
+        message(FATAL_ERROR "EIGEN_CUDA_COMPUTE_ARCH=${EIGEN_CUDA_COMPUTE_ARCH} needs CMake 3.24 or later; "
+                            "name the architectures instead, for example 75;89.")
+      endif()
+      set(CMAKE_CUDA_ARCHITECTURES "${EIGEN_CUDA_COMPUTE_ARCH}")
+      if(NOT CMAKE_CUDA_COMPILER)
+        if(EIGEN_TEST_CUDA_CLANG)
+          set(CMAKE_CUDA_COMPILER "${CMAKE_CXX_COMPILER}")
+        else()
+          set(CMAKE_CUDA_COMPILER "${CUDAToolkit_NVCC_EXECUTABLE}")
+        endif()
+      endif()
+      # nvcc drives a host compiler; keep it the one the rest of the build uses. MSVC picks its own.
+      if(NOT EIGEN_TEST_CUDA_CLANG AND NOT MSVC AND NOT CMAKE_CUDA_HOST_COMPILER)
+        set(CMAKE_CUDA_HOST_COMPILER "${CMAKE_CXX_COMPILER}")
+      endif()
+      if(NOT CMAKE_CUDA_STANDARD AND CMAKE_CXX_STANDARD)
+        set(CMAKE_CUDA_STANDARD "${CMAKE_CXX_STANDARD}")
+      endif()
+      # ccache in front of the C++ compiler should front the CUDA compiler too, which is what the generated nvcc
+      # wrapper script used to arrange for FindCUDA.
+      if(NOT CMAKE_CUDA_COMPILER_LAUNCHER AND CMAKE_CXX_COMPILER_LAUNCHER)
+        set(CMAKE_CUDA_COMPILER_LAUNCHER "${CMAKE_CXX_COMPILER_LAUNCHER}")
+      endif()
+      # Compiler identification compiles with CMAKE_CUDA_FLAGS, so flags it depends on go in before the language is
+      # enabled: clang looks in /usr/local/cuda unless told otherwise, which need not be the toolkit found above, and
+      # refuses a version it does not support; custom flags may carry nvcc's -allow-unsupported-compiler.
+      set(eigen_cuda_flags "${EIGEN_CUDA_CXX_FLAGS}")
+      if(EIGEN_TEST_CUDA_CLANG)
+        string(PREPEND eigen_cuda_flags "--cuda-path=${CUDAToolkit_TARGET_DIR} ")
+      endif()
+      set(eigen_cuda_flags_initialized FALSE)
+      if(DEFINED CMAKE_CUDA_FLAGS)
+        set(eigen_cuda_flags_initialized TRUE)
+      else()
+        set(CMAKE_CUDA_FLAGS "$ENV{CUDAFLAGS} ${CMAKE_CUDA_FLAGS_INIT}")
+      endif()
+      string(APPEND CMAKE_CUDA_FLAGS " ${eigen_cuda_flags}")
+      enable_language(CUDA)
+      if(NOT eigen_cuda_flags_initialized)
+        # Reveal CMake's initialized cache, including platform defaults added after compiler identification.
+        # Keep Eigen's additions out of that cache so reconfiguration neither duplicates nor retains old flags.
+        unset(CMAKE_CUDA_FLAGS)
+        string(APPEND CMAKE_CUDA_FLAGS " ${eigen_cuda_flags}")
+      endif()
+      unset(eigen_cuda_flags)
+      unset(eigen_cuda_flags_initialized)
+      if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
+        string(APPEND CMAKE_CUDA_FLAGS " --expt-relaxed-constexpr -Xcudafe \"--display_error_number\"")
+      endif()
+      message(STATUS "CUDA tests: ${CMAKE_CUDA_COMPILER_ID} ${CMAKE_CUDA_COMPILER_VERSION}, "
+                     "architectures ${CMAKE_CUDA_ARCHITECTURES}")
+    endif()
+
+  elseif(EIGEN_TEST_HIP)
+    if(CMAKE_VERSION VERSION_LESS 3.21)
+      message(FATAL_ERROR "EIGEN_TEST_HIP needs CMake 3.21 or later for the HIP language.")
+    endif()
+    set(EIGEN_GPU_TEST_MODE "hip")
+    # ROCM_PATH selected the installation for the find_package(HIP) path this replaces. The HIP language finds
+    # ROCm through CMAKE_HIP_COMPILER_ROCM_ROOT and the Clang shipped beside it, so seed both from ROCM_PATH,
+    # leaving anything the user configured directly, and anything CMake's own hipconfig probe finds when
+    # ROCM_PATH names no installation, untouched.
+    set(ROCM_PATH "/opt/rocm" CACHE PATH "Path to the ROCm installation.")
+    if(IS_DIRECTORY "${ROCM_PATH}")
+      if(NOT DEFINED CMAKE_HIP_COMPILER_ROCM_ROOT)
+        set(CMAKE_HIP_COMPILER_ROCM_ROOT "${ROCM_PATH}")
+      endif()
+      if(NOT DEFINED CMAKE_HIP_COMPILER AND EXISTS "${ROCM_PATH}/llvm/bin/clang++")
+        set(CMAKE_HIP_COMPILER "${ROCM_PATH}/llvm/bin/clang++")
+      endif()
+    endif()
+    # Compiler ABI detection needs architectures even on build-only hosts without an AMD GPU.
+    if(NOT DEFINED EIGEN_HIP_ARCHITECTURES)
+      set(EIGEN_HIP_ARCHITECTURES
+          gfx900;gfx906;gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101;gfx1102;gfx1150;gfx1151
+          CACHE STRING "HIP GPU architectures to build Eigen's HIP tests for.")
+    endif()
+    # A nonempty false value such as OFF is CMake's request for no architecture flags, not an absent setting.
+    if("${CMAKE_HIP_ARCHITECTURES}" STREQUAL "")
+      set(CMAKE_HIP_ARCHITECTURES "${EIGEN_HIP_ARCHITECTURES}")
+    endif()
+    enable_language(HIP)
+    message(STATUS "HIP tests: ${CMAKE_HIP_COMPILER_ID} ${CMAKE_HIP_COMPILER_VERSION}, "
+                   "architectures ${CMAKE_HIP_ARCHITECTURES}")
+  endif()
+endmacro()
+
+# The GPU part of ei_add_test_internal: build one .cu test in whichever mode is in force.
+function(ei_add_gpu_test_executable targetname filename)
+  if(EIGEN_GPU_TEST_MODE STREQUAL "hip")
+    set_source_files_properties(${filename} PROPERTIES LANGUAGE HIP)
+    add_executable(${targetname} ${filename})
+    target_compile_definitions(${targetname} PRIVATE EIGEN_USE_HIP)
+  elseif(EIGEN_GPU_TEST_MODE STREQUAL "cuda-as-cxx")
+    # The compiler drives CUDA itself, from flags set in ei_gpu_testing_enable.
+    set_source_files_properties(${filename} PROPERTIES LANGUAGE CXX)
+    add_executable(${targetname} ${filename})
+    # nvc++ already links its shared runtime. Adding the static runtime duplicates kernel registration state.
+    if(NOT EIGEN_TEST_CUDA_NVC)
+      target_link_libraries(${targetname} CUDA::cudart_static)
+    endif()
+  else()
+    add_executable(${targetname} ${filename})
+    target_link_libraries(${targetname} CUDA::cudart_static)
+  endif()
+endfunction()
diff --git a/cmake/EigenSmokeTestList.cmake b/cmake/EigenSmokeTestList.cmake
index 247b2c4..d21c252 100644
--- a/cmake/EigenSmokeTestList.cmake
+++ b/cmake/EigenSmokeTestList.cmake
@@ -1,6 +1,8 @@
 # List of tests that will be build and run during Eigen's smoke testing. If one
 # of these tests doesn't exists or cannot be build with the current configuration
 # it will just be skipped.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 set(ei_smoke_test_list
   adjoint_1
   alignedvector3
@@ -14,18 +16,25 @@
   autodiff_scalar_1
   bandmatrix
   bdcsvd_9
+  bdcsvd_fastmath
   bessel_functions_1
+  bfloat16_classification
+  bfloat16_classification_fastmath
   bfloat16_float
   blasutil_1
   block_5
+  block_sparse_matrix_2
+  block_sparse_matrix_9
+  bunchkaufman_5
   BVH
   cholesky_1
-  cholmod_support_23
-  cholmod_support_24
+  cholmod_support_21
+  cholmod_support_22
   conservative_resize_1
   constructor_1
   corners_1
-  ctorleakmiscmatrices_4
+  ctorleak
+  miscmatrices_4
   dense_storage
   determinant_1
   diagonal_1
@@ -47,7 +56,8 @@
   geo_transformations_7
   half_float
   hessenberg_1
-  hessenberg_6qr_10
+  hessenberg_6
+  qr_10
   householder_8
   indexed_view_1
   inplace_decomposition_1
@@ -58,17 +68,19 @@
   jacobisvd_1
   kronecker_product
   linearstructure_1
+  lru_cache
+  lsmr_1
   mapped_matrix_1
   mapstaticmethods_1
   mapstride_1
-  unaryviewstride_1
-  unaryviewstride_2
-  unaryviewstride_3
+  unaryview_1
+  unaryview_2
+  unaryview_3
   matrix_square_root_1
   meta
-  minres_2
+  minres_1
   miscmatrices_1
-  mixingtypes_7
+  mixingtypes_4
   nestbyvalue
   nesting_ops_1
   nomalloc_1
@@ -77,6 +89,8 @@
   NumericalDiff
   numext
   packetmath
+  packetmath_fastmath
+  packetmath_fastmath_generic_16
   permutationmatrices_1
   polynomialsolver_1
   prec_inverse_4x4_1
@@ -91,6 +105,7 @@
   qr_1
   qr_colpivoting_7
   qr_fullpivoting_4
+  qr_rand_colpivoting_2
   rand_1
   real_qz_1
   redux_1
@@ -111,12 +126,15 @@
   sparse_product_4
   sparse_ref_1
   sparse_solvers_1
+  sparse_threaded_product_2
   sparse_vector_1
   special_functions_1
   special_numbers_1
   special_packetmath_1
   spqr_support_2
   stable_norm_1
+  stable_norm_fastmath
+  stack_allocation_limit
   stddeque_1
   stddeque_overload_1
   stdlist_1
@@ -124,12 +142,19 @@
   stdvector_1
   stdvector_overload_1
   stl_iterators_1
+  structured_cauchy
+  structured_dpr1_1
+  structured_matrices_1
+  structured_matrices_5
+  structured_matrices_13
   swap_1
   symbolic_index_1
   triangular_1
-  type_aliaslu_9
+  tridiagonal_eigensolver_1
+  tridiagonal_eigensolver_3
+  type_alias
+  lu_9
   umeyama_3
-  unalignedassert
   unalignedcount
   vectorwiseop_1
   visitor_1
diff --git a/cmake/EigenTesting.cmake b/cmake/EigenTesting.cmake
index e5aefa3..93333a0 100644
--- a/cmake/EigenTesting.cmake
+++ b/cmake/EigenTesting.cmake
@@ -1,3 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 macro(ei_add_property prop value)
   get_property(previous GLOBAL PROPERTY ${prop})
@@ -26,44 +28,7 @@
   set(is_gpu_test OFF)
   if(EIGEN_ADD_TEST_FILENAME_EXTENSION STREQUAL cu)
     set(is_gpu_test ON)
-    if(EIGEN_TEST_HIP)
-      hip_reset_flags()
-      hip_add_executable(${targetname} ${filename} HIPCC_OPTIONS -std=c++14)
-      target_compile_definitions(${targetname} PRIVATE -DEIGEN_USE_HIP)
-      set_property(TARGET ${targetname} PROPERTY HIP_ARCHITECTURES gfx900 gfx906 gfx908 gfx90a gfx940 gfx941 gfx942 gfx1030)
-    elseif(EIGEN_TEST_CUDA_CLANG)
-      set_source_files_properties(${filename} PROPERTIES LANGUAGE CXX)
-
-      if(CUDA_64_BIT_DEVICE_CODE AND (EXISTS "${CUDA_TOOLKIT_ROOT_DIR}/lib64"))
-        link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
-      else()
-        link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib")
-      endif()
-
-      add_executable(${targetname} ${filename})
-      set(CUDA_CLANG_LINK_LIBRARIES "cudart_static" "cuda" "dl" "pthread")
-      if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-      set(CUDA_CLANG_LINK_LIBRARIES ${CUDA_CLANG_LINK_LIBRARIES} "rt")
-      endif()
-      target_link_libraries(${targetname} ${CUDA_CLANG_LINK_LIBRARIES})
-    elseif(EIGEN_TEST_CUDA_NVC)
-      set_source_files_properties(${filename} PROPERTIES LANGUAGE CXX)
-
-      if(CUDA_64_BIT_DEVICE_CODE AND (EXISTS "${CUDA_TOOLKIT_ROOT_DIR}/lib64"))
-        link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
-      else()
-        link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib")
-      endif()
-
-      add_executable(${targetname} ${filename})
-      set(CUDA_NVC_LINK_LIBRARIES "cudart_static" "cuda" "dl" "pthread")
-      if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-        list(APPEND CUDA_NVC_LINK_LIBRARIES "rt")
-      endif()
-      target_link_libraries(${targetname} ${CUDA_NVC_LINK_LIBRARIES})
-    else()
-      cuda_add_executable(${targetname} ${filename})
-    endif()
+    ei_add_gpu_test_executable(${targetname} ${filename})
   else()
     add_executable(${targetname} ${filename})
   endif()
@@ -84,18 +49,32 @@
 
   target_compile_definitions(${targetname} PRIVATE EIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE})
 
+  set(test_compile_options "")
   if(MSVC)
-    target_compile_options(${targetname} PRIVATE "/bigobj")
+    list(APPEND test_compile_options "/bigobj")
   endif()
 
   # let the user pass flags.
   if(${ARGC} GREATER 2)
     separate_arguments(compile_options NATIVE_COMMAND "${ARGV2}")
-    target_compile_options(${targetname} PRIVATE ${compile_options})
+    list(APPEND test_compile_options ${compile_options})
   endif()
+  list(APPEND test_compile_options ${EIGEN_TEST_CUSTOM_CXX_FLAGS})
 
-  if(EIGEN_TEST_CUSTOM_CXX_FLAGS)
-    target_compile_options(${targetname} PRIVATE ${EIGEN_TEST_CUSTOM_CXX_FLAGS})
+  if(is_gpu_test AND MSVC AND EIGEN_GPU_TEST_MODE STREQUAL "cuda-language"
+     AND CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA")
+    # nvcc treats bare /options as input files. Definitions must reach both compilation passes.
+    foreach(option IN LISTS test_compile_options)
+      if(option MATCHES "^/D(.+)")
+        target_compile_definitions(${targetname} PRIVATE "${CMAKE_MATCH_1}")
+      elseif(option MATCHES "^/")
+        target_compile_options(${targetname} PRIVATE "-Xcompiler=${option}")
+      else()
+        target_compile_options(${targetname} PRIVATE "${option}")
+      endif()
+    endforeach()
+  else()
+    target_compile_options(${targetname} PRIVATE ${test_compile_options})
   endif()
 
   if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
@@ -134,6 +113,7 @@
   if (is_gpu_test)
     # Add gpu tag for testing only GPU tests.
     set_property(TEST ${testname_with_suffix} APPEND PROPERTY LABELS "gpu")
+    set_property(TEST ${testname_with_suffix} PROPERTY SKIP_RETURN_CODE 77)
   endif()
 
   if(EIGEN_SYCL)
@@ -145,6 +125,14 @@
     target_link_libraries(${targetname} Threads::Threads)
     add_sycl_to_target(TARGET ${targetname} SOURCES ${filename})
   endif(EIGEN_SYCL)
+
+  # Match on the parent test name (e.g. "packetmath" → all packetmath_N) or
+  # the specific subtest name (e.g. "packetmath_2"); see EigenConfigureTesting.cmake
+  # for why this lives here instead of in a post-hoc registration.
+  if ("${testname_with_suffix}" IN_LIST ei_smoke_test_list OR "${testname}" IN_LIST ei_smoke_test_list)
+    set_property(TEST ${testname_with_suffix} APPEND PROPERTY LABELS "smoketest")
+    add_dependencies(buildsmoketests ${targetname})
+  endif()
 endmacro(ei_add_test_internal)
 # Macro to add a test
 #
@@ -225,43 +213,86 @@
   endif()
 endmacro()
 
-# adds a failtest, i.e. a test that succeed if the program fails to compile
-# note that the test runner for these is CMake itself, when passed -DEIGEN_FAILTEST=ON
-# so here we're just running CMake commands immediately, we're not adding any targets.
+set(EIGEN_FAILTEST_SCRIPT "${CMAKE_CURRENT_LIST_DIR}/EigenFailtest.cmake")
+
+# Adds a compile-failure test pair from ${testname}.cpp: ${testname}_ok must
+# compile, and ${testname}_ko, built with EIGEN_SHOULD_FAIL_TO_BUILD, must not.
+# Neither test builds anything: both inspect the executables that the
+# buildfailtests fixture produced, so ei_add_failtest_fixture() must follow the
+# last ei_add_failtest() call.
 macro(ei_add_failtest testname)
 
   set(test_target_ok ${testname}_ok)
   set(test_target_ko ${testname}_ko)
 
-  # Add executables
   add_executable(${test_target_ok} ${testname}.cpp)
   add_executable(${test_target_ko} ${testname}.cpp)
-
-  # Remove them from the normal build process
   set_target_properties(${test_target_ok} ${test_target_ko} PROPERTIES
                         EXCLUDE_FROM_ALL TRUE
                         EXCLUDE_FROM_DEFAULT_BUILD TRUE)
-
-  # Configure the failing test
   target_compile_definitions(${test_target_ko} PRIVATE EIGEN_SHOULD_FAIL_TO_BUILD)
+  set_property(GLOBAL APPEND PROPERTY EIGEN_FAILTEST_TARGETS ${test_target_ok} ${test_target_ko})
 
-  # Add the tests to ctest.
+  set(test_check_args
+      -DEIGEN_FAILTEST_ACTION=check
+      -DEIGEN_FAILTEST_BINARY_DIR=${CMAKE_BINARY_DIR}
+      -DEIGEN_FAILTEST_CONFIG=$<CONFIG>
+      -DEIGEN_FAILTEST_LOCK=${CMAKE_CURRENT_BINARY_DIR}/buildfailtests.lock
+      -DEIGEN_FAILTEST_OK=${test_target_ok}
+      -DEIGEN_FAILTEST_OK_FILE=$<TARGET_FILE:${test_target_ok}>)
   add_test(NAME ${test_target_ok}
-          COMMAND ${CMAKE_COMMAND} --build . --target ${test_target_ok} --config $<CONFIG>
-          WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+           COMMAND ${CMAKE_COMMAND} ${test_check_args} -P ${EIGEN_FAILTEST_SCRIPT})
   add_test(NAME ${test_target_ko}
-          COMMAND ${CMAKE_COMMAND} --build . --target ${test_target_ko} --config $<CONFIG>
-          WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+           COMMAND ${CMAKE_COMMAND} ${test_check_args}
+                   -DEIGEN_FAILTEST_KO=${test_target_ko}
+                   -DEIGEN_FAILTEST_KO_FILE=$<TARGET_FILE:${test_target_ko}>
+                   -P ${EIGEN_FAILTEST_SCRIPT})
   # Disable emulator if cross-compiling.
   if (CMAKE_CROSSCOMPILING)
     set_property(TEST ${test_target_ok} PROPERTY CROSSCOMPILING_EMULATOR "")
     set_property(TEST ${test_target_ko} PROPERTY CROSSCOMPILING_EMULATOR "")
   endif()
 
-  # Expect the second test to fail
-  set_tests_properties(${test_target_ko} PROPERTIES WILL_FAIL TRUE)
+  set_tests_properties(${test_target_ok} ${test_target_ko} PROPERTIES
+                       FIXTURES_REQUIRED eigen_failtest LABELS failtest)
 endmacro()
 
+# Registers the buildfailtests test, the fixture that every ei_add_failtest()
+# test requires.  It builds all failtest targets in one keep-going invocation,
+# so the compiles run in parallel under a single build system instead of one
+# build per test, which would have to be serialized: concurrent builds over one
+# binary directory collide.
+function(ei_add_failtest_fixture)
+  get_property(targets GLOBAL PROPERTY EIGEN_FAILTEST_TARGETS)
+  if(NOT targets)
+    return()
+  endif()
+
+  add_custom_target(buildfailtests)
+  add_dependencies(buildfailtests ${targets})
+
+  set(files "")
+  foreach(target IN LISTS targets)
+    string(APPEND files "  \"$<TARGET_FILE:${target}>\"\n")
+  endforeach()
+  set(list_file "${CMAKE_CURRENT_BINARY_DIR}/buildfailtests-$<CONFIG>.cmake")
+  file(GENERATE OUTPUT "${list_file}"
+       CONTENT "set(EIGEN_FAILTEST_TARGETS ${targets})\nset(EIGEN_FAILTEST_FILES\n${files})\n")
+
+  add_test(NAME buildfailtests
+           COMMAND ${CMAKE_COMMAND}
+                   -DEIGEN_FAILTEST_ACTION=build
+                   -DEIGEN_FAILTEST_BINARY_DIR=${CMAKE_BINARY_DIR}
+                   -DEIGEN_FAILTEST_CONFIG=$<CONFIG>
+                   -DEIGEN_FAILTEST_GENERATOR=${CMAKE_GENERATOR}
+                   -DEIGEN_FAILTEST_LIST=${list_file}
+                   -P ${EIGEN_FAILTEST_SCRIPT})
+  if (CMAKE_CROSSCOMPILING)
+    set_property(TEST buildfailtests PROPERTY CROSSCOMPILING_EMULATOR "")
+  endif()
+  set_tests_properties(buildfailtests PROPERTIES FIXTURES_SETUP eigen_failtest LABELS failtest)
+endfunction()
+
 # print a summary of the different options
 macro(ei_testing_print_summary)
   message(STATUS "************************************************************")
@@ -405,11 +436,18 @@
       message(STATUS "SYCL:              OFF")
     endif()
     if(EIGEN_TEST_CUDA)
-      if(EIGEN_TEST_CUDA_CLANG)
-        message(STATUS "CUDA:              ON (using clang)")
-      else()
-        message(STATUS "CUDA:              ON (using nvcc)")
+      get_property(EIGEN_CUDA_ARCH_SUMMARY GLOBAL PROPERTY EIGEN_CUDA_COMPUTE_ARCH_RESOLVED)
+      if(EIGEN_CUDA_ARCH_SUMMARY)
+        string(REPLACE ";" ", sm_" EIGEN_CUDA_ARCH_SUMMARY ", sm_${EIGEN_CUDA_ARCH_SUMMARY}")
       endif()
+      if(EIGEN_TEST_CUDA_NVC)
+        set(EIGEN_CUDA_DRIVER "nvc++")
+      elseif(EIGEN_TEST_CUDA_CLANG)
+        set(EIGEN_CUDA_DRIVER "clang")
+      else()
+        set(EIGEN_CUDA_DRIVER "nvcc")
+      endif()
+      message(STATUS "CUDA:              ON (using ${EIGEN_CUDA_DRIVER}${EIGEN_CUDA_ARCH_SUMMARY})")
     else()
       message(STATUS "CUDA:              OFF")
     endif()
@@ -729,55 +767,3 @@
     add_dependencies("${current_target}" "${curr_test}")
   endforeach()
 endmacro(ei_split_testsuite num_splits)
-
-# Defines the custom command buildsmoketests to build a number of tests
-# specified in smoke_test_list.
-#
-# Test in smoke_test_list can be either test targets (e.g. packetmath) or
-# subtests targets (e.g. packetmath_2). If any of the test are not available
-# in the current configuration they are just skipped.
-#
-# All tests added via this macro are labeled with the smoketest label. This
-# allows running smoketests only using ctest.
-#
-# Smoke tests are intended to be run before the whole test suite is invoked,
-# e.g., to smoke test patches.
-macro(ei_add_smoke_tests smoke_test_list)
-  # Set the build target to build smoketests
-  set(buildtarget "buildsmoketests")
-  add_custom_target("${buildtarget}")
-
-  # Get list of all tests and translate it into a CMake list
-  get_property(EIGEN_TESTS_LIST GLOBAL PROPERTY EIGEN_TESTS_LIST)
-  string(REGEX REPLACE "\n" " " EIGEN_TESTS_LIST "${EIGEN_TESTS_LIST}")
-  set(EIGEN_TESTS_LIST "${EIGEN_TESTS_LIST}")
-  separate_arguments(EIGEN_TESTS_LIST)
-
-  # Check if the test in smoke_test_list is a currently valid test target
-  foreach(test IN ITEMS ${smoke_test_list})
-    # Add tests in smoke_test_list to our smoke test target but only if the test
-    # is currently available, i.e., is in EIGEN_SUBTESTS_LIST
-    if ("${test}" IN_LIST EIGEN_TESTS_LIST)
-      add_dependencies("${buildtarget}" "${test}")
-      # In the case of a test we match all subtests
-      set(ctest_regex "${ctest_regex}^${test}_[0-9]+$$|")
-    endif()
-  endforeach()
-
-  # Get list of all subtests and translate it into a CMake list
-  get_property(EIGEN_SUBTESTS_LIST GLOBAL PROPERTY EIGEN_SUBTESTS_LIST)
-  string(REGEX REPLACE "\n" " " EIGEN_SUBTESTS_LIST "${EIGEN_SUBTESTS_LIST}")
-  set(EIGEN_SUBTESTS_LIST "${EIGEN_SUBTESTS_LIST}")
-  separate_arguments(EIGEN_SUBTESTS_LIST)
-
-  # Check if the test in smoke_test_list is a currently valid subtest target
-  foreach(test IN ITEMS ${smoke_test_list})
-    # Add tests in smoke_test_list to our smoke test target but only if the test
-    # is currently available, i.e., is in EIGEN_SUBTESTS_LIST
-    if ("${test}" IN_LIST EIGEN_SUBTESTS_LIST)
-      add_dependencies("${buildtarget}" "${test}")
-      # Add label smoketest to be able to run smoketests using ctest
-      set_property(TEST ${test} APPEND PROPERTY LABELS "smoketest")
-    endif()
-  endforeach()
-endmacro(ei_add_smoke_tests)
diff --git a/cmake/EigenUninstall.cmake b/cmake/EigenUninstall.cmake
index 5e63c98..7c55b1c 100644
--- a/cmake/EigenUninstall.cmake
+++ b/cmake/EigenUninstall.cmake
@@ -4,6 +4,8 @@
 #
 # Used by uinstall target
 #################################################################
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 set(MANIFEST "${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt")
 
diff --git a/cmake/FindAOCL.cmake b/cmake/FindAOCL.cmake
index 5e49835..7f8b2a2 100644
--- a/cmake/FindAOCL.cmake
+++ b/cmake/FindAOCL.cmake
@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: MPL-2.0
 
 #
 # This Source Code Form is subject to the terms of the Mozilla Public
diff --git a/cmake/FindAccelerate.cmake b/cmake/FindAccelerate.cmake
index 787c31c..30975e4 100644
--- a/cmake/FindAccelerate.cmake
+++ b/cmake/FindAccelerate.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 if (Accelerate_INCLUDES AND Accelerate_LIBRARIES)
   set(Accelerate_FIND_QUIETLY TRUE)
 endif ()
diff --git a/cmake/FindAdolc.cmake b/cmake/FindAdolc.cmake
index 13c59fc..0b76e17 100644
--- a/cmake/FindAdolc.cmake
+++ b/cmake/FindAdolc.cmake
@@ -1,3 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (ADOLC_INCLUDES AND ADOLC_LIBRARIES)
   set(ADOLC_FIND_QUIETLY TRUE)
diff --git a/cmake/FindBLASEXT.cmake b/cmake/FindBLASEXT.cmake
index 69a9418..43d3951 100644
--- a/cmake/FindBLASEXT.cmake
+++ b/cmake/FindBLASEXT.cmake
@@ -22,6 +22,7 @@
 #  BLAS_LIBRARY_DIRS  - Link directories for BLAS libraries
 #  BLAS_SEQ_LIBRARIES - BLAS component libraries to be linked (sequential)
 #  BLAS_PAR_LIBRARIES - BLAS component libraries to be linked (multithreaded)
+# SPDX-License-Identifier: BSD-3-Clause
 
 #=============================================================================
 # Copyright 2012-2013 Inria
diff --git a/cmake/FindCHOLMOD.cmake b/cmake/FindCHOLMOD.cmake
index e470cb2..3599690 100644
--- a/cmake/FindCHOLMOD.cmake
+++ b/cmake/FindCHOLMOD.cmake
@@ -1,10 +1,54 @@
 # CHOLMOD lib usually requires linking to a blas and lapack library.
 # It is up to the user of this module to find a BLAS and link to it.
+#
+# This module first tries to find CHOLMOD via its CMake config-mode package
+# (shipped with SuiteSparse >= 7.0). If that fails, it falls back to a
+# manual header/library search for compatibility with older installations.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (CHOLMOD_INCLUDES AND CHOLMOD_LIBRARIES)
   set(CHOLMOD_FIND_QUIETLY TRUE)
 endif ()
 
+# --- Try config-mode first (SuiteSparse >= 7.0) ---
+# Run this on every configure, not only when the cache is cold.  The variables
+# set below name an imported target, which exists only if the config package has
+# been loaded in the *current* run.  Returning early on a warm cache left
+# CHOLMOD_LIBRARIES naming a target that was never defined, so the first
+# configure of a build tree succeeded and every later one failed.
+find_package(CHOLMOD CONFIG QUIET)
+if(CHOLMOD_FOUND AND TARGET SuiteSparse::CHOLMOD)
+  # Extract include dirs and libraries from the imported target so that the
+  # legacy variables expected by Eigen's build system are populated.
+  get_target_property(_cholmod_inc SuiteSparse::CHOLMOD INTERFACE_INCLUDE_DIRECTORIES)
+  # SuiteSparse >= 7 exports these as a generator expression, e.g.
+  # $<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>.
+  # A generator expression cannot be cached and handed to callers that inspect
+  # include directories at configure time, so keep only literal paths and let
+  # the manual search below handle the rest.
+  set(_cholmod_inc_dirs "")
+  if(_cholmod_inc)
+    foreach(_dir IN LISTS _cholmod_inc)
+      if(NOT _dir MATCHES "\\$<")
+        list(APPEND _cholmod_inc_dirs "${_dir}")
+      endif()
+    endforeach()
+  endif()
+  if(_cholmod_inc_dirs)
+    # FORCE because a plain `set(... CACHE ...)` is a no-op when the entry
+    # already exists.  A build tree first configured before this fix still
+    # holds the unusable generator-expression value, and reconfiguring it
+    # would otherwise keep it forever.
+    set(CHOLMOD_INCLUDES "${_cholmod_inc_dirs}" CACHE PATH "CHOLMOD include directory" FORCE)
+    set(CHOLMOD_LIBRARIES SuiteSparse::CHOLMOD CACHE STRING "CHOLMOD libraries" FORCE)
+    # Mark as found and return early -- no need for the manual search below.
+    mark_as_advanced(CHOLMOD_INCLUDES CHOLMOD_LIBRARIES)
+    return()
+  endif()
+endif()
+
+# --- Fallback: manual search (SuiteSparse < 7.0 or no config package) ---
 find_path(CHOLMOD_INCLUDES
   NAMES
   cholmod.h
@@ -79,7 +123,7 @@
   if (SUITESPARSE_LIBRARY)
     set(CHOLMOD_LIBRARIES ${CHOLMOD_LIBRARIES} ${SUITESPARSE_LIBRARY})
   endif ()
-  
+
 endif()
 
 include(FindPackageHandleStandardArgs)
diff --git a/cmake/FindCLANG_FORMAT.cmake b/cmake/FindCLANG_FORMAT.cmake
index e00f19f..625e675 100644
--- a/cmake/FindCLANG_FORMAT.cmake
+++ b/cmake/FindCLANG_FORMAT.cmake
@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: MPL-2.0
 
 
 # Find clang-format
diff --git a/cmake/FindComputeCpp.cmake b/cmake/FindComputeCpp.cmake
index e200522..bbba60c 100644
--- a/cmake/FindComputeCpp.cmake
+++ b/cmake/FindComputeCpp.cmake
@@ -16,6 +16,7 @@
 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
+# SPDX-License-Identifier: Apache-2.0
 
 #########################
 #  FindComputeCpp.cmake
diff --git a/cmake/FindDPCPP.cmake b/cmake/FindDPCPP.cmake
index 73aa30f..4268eef 100644
--- a/cmake/FindDPCPP.cmake
+++ b/cmake/FindDPCPP.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 include_guard()
 
 include(CheckCXXCompilerFlag)
diff --git a/cmake/FindFFTW.cmake b/cmake/FindFFTW.cmake
index ed55c5f..73acbce 100644
--- a/cmake/FindFFTW.cmake
+++ b/cmake/FindFFTW.cmake
@@ -15,6 +15,8 @@
 #   FFTW_LIBRARY            ... fftw library to use
 #   FFTW_INCLUDE_DIR        ... fftw include directory
 #
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 #If environment variable FFTWDIR is specified, it has same effect as FFTW_ROOT
 if( NOT FFTW_ROOT AND ENV{FFTWDIR} )
diff --git a/cmake/FindGMP.cmake b/cmake/FindGMP.cmake
index c41eedc..617d363 100644
--- a/cmake/FindGMP.cmake
+++ b/cmake/FindGMP.cmake
@@ -1,5 +1,7 @@
 # Try to find the GNU Multiple Precision Arithmetic Library (GMP)
 # See http://gmplib.org/
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (GMP_INCLUDES AND GMP_LIBRARIES)
   set(GMP_FIND_QUIETLY TRUE)
diff --git a/cmake/FindGoogleHash.cmake b/cmake/FindGoogleHash.cmake
index 481eb4d..cdad73d 100644
--- a/cmake/FindGoogleHash.cmake
+++ b/cmake/FindGoogleHash.cmake
@@ -1,3 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (GOOGLEHASH_INCLUDES AND GOOGLEHASH_LIBRARIES)
   set(GOOGLEHASH_FIND_QUIETLY TRUE)
diff --git a/cmake/FindHWLOC.cmake b/cmake/FindHWLOC.cmake
index 522f521..37f6df7 100644
--- a/cmake/FindHWLOC.cmake
+++ b/cmake/FindHWLOC.cmake
@@ -27,6 +27,7 @@
 #  HWLOC_LIBDIR          - Where to find the library files
 # The module can also look for the following environment variables if paths
 # are not given as cmake variable: HWLOC_DIR, HWLOC_INCDIR, HWLOC_LIBDIR
+# SPDX-License-Identifier: BSD-3-Clause
 
 #=============================================================================
 # Copyright 2012-2013 Inria
diff --git a/cmake/FindKLU.cmake b/cmake/FindKLU.cmake
index 6217d14..09f571b 100644
--- a/cmake/FindKLU.cmake
+++ b/cmake/FindKLU.cmake
@@ -1,10 +1,54 @@
 # KLU lib usually requires linking to a blas library.
 # It is up to the user of this module to find a BLAS and link to it.
+#
+# This module first tries to find KLU via its CMake config-mode package
+# (shipped with SuiteSparse >= 7.0). If that fails, it falls back to a
+# manual header/library search for compatibility with older installations.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (KLU_INCLUDES AND KLU_LIBRARIES)
   set(KLU_FIND_QUIETLY TRUE)
 endif ()
 
+# --- Try config-mode first (SuiteSparse >= 7.0) ---
+# Run this on every configure, not only when the cache is cold.  The variables
+# set below name an imported target, which exists only if the config package has
+# been loaded in the *current* run.  Returning early on a warm cache left
+# KLU_LIBRARIES naming a target that was never defined, so the first
+# configure of a build tree succeeded and every later one failed.
+find_package(KLU CONFIG QUIET)
+if(KLU_FOUND AND TARGET SuiteSparse::KLU)
+  # Extract include dirs and libraries from the imported target so that the
+  # legacy variables expected by Eigen's build system are populated.
+  get_target_property(_klu_inc SuiteSparse::KLU INTERFACE_INCLUDE_DIRECTORIES)
+  # SuiteSparse >= 7 exports these as a generator expression, e.g.
+  # $<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>.
+  # A generator expression cannot be cached and handed to callers that inspect
+  # include directories at configure time, so keep only literal paths and let
+  # the manual search below handle the rest.
+  set(_klu_inc_dirs "")
+  if(_klu_inc)
+    foreach(_dir IN LISTS _klu_inc)
+      if(NOT _dir MATCHES "\\$<")
+        list(APPEND _klu_inc_dirs "${_dir}")
+      endif()
+    endforeach()
+  endif()
+  if(_klu_inc_dirs)
+    # FORCE because a plain `set(... CACHE ...)` is a no-op when the entry
+    # already exists.  A build tree first configured before this fix still
+    # holds the unusable generator-expression value, and reconfiguring it
+    # would otherwise keep it forever.
+    set(KLU_INCLUDES "${_klu_inc_dirs}" CACHE PATH "KLU include directory" FORCE)
+    set(KLU_LIBRARIES SuiteSparse::KLU CACHE STRING "KLU libraries" FORCE)
+    # Mark as found and return early -- no need for the manual search below.
+    mark_as_advanced(KLU_INCLUDES KLU_LIBRARIES)
+    return()
+  endif()
+endif()
+
+# --- Fallback: manual search (SuiteSparse < 7.0 or no config package) ---
 find_path(KLU_INCLUDES
   NAMES
   klu.h
@@ -28,7 +72,7 @@
   if(COLAMD_LIBRARY)
     set(KLU_LIBRARIES ${KLU_LIBRARIES} ${COLAMD_LIBRARY})
   endif ()
-  
+
   find_library(AMD_LIBRARY amd PATHS ${KLU_LIBDIR} $ENV{KLUDIR} ${LIB_INSTALL_DIR})
   if(AMD_LIBRARY)
     set(KLU_LIBRARIES ${KLU_LIBRARIES} ${AMD_LIBRARY})
diff --git a/cmake/FindMPFR.cmake b/cmake/FindMPFR.cmake
index d8da9d6..b1ffb16 100644
--- a/cmake/FindMPFR.cmake
+++ b/cmake/FindMPFR.cmake
@@ -11,6 +11,7 @@
 #  MPFR_INCLUDES - the MPFR include directory
 #  MPFR_LIBRARIES - the MPFR library
 #  MPFR_VERSION - MPFR version
+# SPDX-License-Identifier: MPL-2.0
 
 # Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
 # Copyright (c) 2008, 2009 Gael Guennebaud, <g.gael@free.fr>
diff --git a/cmake/FindMPREAL.cmake b/cmake/FindMPREAL.cmake
index 947a1ce..57d4a23 100644
--- a/cmake/FindMPREAL.cmake
+++ b/cmake/FindMPREAL.cmake
@@ -11,6 +11,7 @@
 #  MPREAL_INCLUDES - MPREAL required include directories
 #  MPREAL_LIBRARIES - MPREAL required libraries
 #  MPREAL_VERSION - MPREAL version
+# SPDX-License-Identifier: MPL-2.0
 
 # Copyright (c) 2020 The Eigen Authors.
 # Redistribution and use is allowed according to the terms of the BSD license.
diff --git a/cmake/FindMetis.cmake b/cmake/FindMetis.cmake
index 747f882..371fc09 100644
--- a/cmake/FindMetis.cmake
+++ b/cmake/FindMetis.cmake
@@ -28,6 +28,7 @@
 #  METIS_LIBDIR          - Where to find the library files
 # The module can also look for the following environment variables if paths
 # are not given as cmake variable: METIS_DIR, METIS_INCDIR, METIS_LIBDIR
+# SPDX-License-Identifier: BSD-3-Clause
 
 #=============================================================================
 # Copyright 2012-2013 Inria
diff --git a/cmake/FindPASTIX.cmake b/cmake/FindPASTIX.cmake
index db1427b..0a91ccd 100644
--- a/cmake/FindPASTIX.cmake
+++ b/cmake/FindPASTIX.cmake
@@ -54,6 +54,7 @@
 #  PASTIX_LIBDIR           - Where to find the library files
 # The module can also look for the following environment variables if paths
 # are not given as cmake variable: PASTIX_DIR, PASTIX_INCDIR, PASTIX_LIBDIR
+# SPDX-License-Identifier: BSD-3-Clause
 
 #=============================================================================
 # Copyright 2012-2013 Inria
diff --git a/cmake/FindPTSCOTCH.cmake b/cmake/FindPTSCOTCH.cmake
index 6ccc743..32587dc 100644
--- a/cmake/FindPTSCOTCH.cmake
+++ b/cmake/FindPTSCOTCH.cmake
@@ -41,6 +41,7 @@
 #  PTSCOTCH_LIBDIR           - Where to find the library files
 # The module can also look for the following environment variables if paths
 # are not given as cmake variable: PTSCOTCH_DIR, PTSCOTCH_INCDIR, PTSCOTCH_LIBDIR
+# SPDX-License-Identifier: BSD-3-Clause
 
 #=============================================================================
 # Copyright 2012-2013 Inria
diff --git a/cmake/FindSCOTCH.cmake b/cmake/FindSCOTCH.cmake
index 11b971a..e3a7b0f 100644
--- a/cmake/FindSCOTCH.cmake
+++ b/cmake/FindSCOTCH.cmake
@@ -33,6 +33,7 @@
 #  SCOTCH_LIBDIR          - Where to find the library files
 # The module can also look for the following environment variables if paths
 # are not given as cmake variable: SCOTCH_DIR, SCOTCH_INCDIR, SCOTCH_LIBDIR
+# SPDX-License-Identifier: BSD-3-Clause
 
 #=============================================================================
 # Copyright 2012-2013 Inria
diff --git a/cmake/FindSPQR.cmake b/cmake/FindSPQR.cmake
index d6fb2e1..78a6dab 100644
--- a/cmake/FindSPQR.cmake
+++ b/cmake/FindSPQR.cmake
@@ -1,13 +1,57 @@
 # SPQR lib usually requires linking to a blas and lapack library.
 # It is up to the user of this module to find a BLAS and link to it.
-
-# SPQR lib requires Cholmod, colamd and amd as well. 
+#
+# SPQR lib requires Cholmod, colamd and amd as well.
 # FindCholmod.cmake can be used to find those packages before finding spqr
+#
+# This module first tries to find SPQR via its CMake config-mode package
+# (shipped with SuiteSparse >= 7.0). If that fails, it falls back to a
+# manual header/library search for compatibility with older installations.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (SPQR_INCLUDES AND SPQR_LIBRARIES)
   set(SPQR_FIND_QUIETLY TRUE)
 endif ()
 
+# --- Try config-mode first (SuiteSparse >= 7.0) ---
+# Run this on every configure, not only when the cache is cold.  The variables
+# set below name an imported target, which exists only if the config package has
+# been loaded in the *current* run.  Returning early on a warm cache left
+# SPQR_LIBRARIES naming a target that was never defined, so the first
+# configure of a build tree succeeded and every later one failed.
+find_package(SPQR CONFIG QUIET)
+if(SPQR_FOUND AND TARGET SuiteSparse::SPQR)
+  # Extract include dirs and libraries from the imported target so that the
+  # legacy variables expected by Eigen's build system are populated.
+  get_target_property(_spqr_inc SuiteSparse::SPQR INTERFACE_INCLUDE_DIRECTORIES)
+  # SuiteSparse >= 7 exports these as a generator expression, e.g.
+  # $<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>.
+  # A generator expression cannot be cached and handed to callers that inspect
+  # include directories at configure time, so keep only literal paths and let
+  # the manual search below handle the rest.
+  set(_spqr_inc_dirs "")
+  if(_spqr_inc)
+    foreach(_dir IN LISTS _spqr_inc)
+      if(NOT _dir MATCHES "\\$<")
+        list(APPEND _spqr_inc_dirs "${_dir}")
+      endif()
+    endforeach()
+  endif()
+  if(_spqr_inc_dirs)
+    # FORCE because a plain `set(... CACHE ...)` is a no-op when the entry
+    # already exists.  A build tree first configured before this fix still
+    # holds the unusable generator-expression value, and reconfiguring it
+    # would otherwise keep it forever.
+    set(SPQR_INCLUDES "${_spqr_inc_dirs}" CACHE PATH "SPQR include directory" FORCE)
+    set(SPQR_LIBRARIES SuiteSparse::SPQR CACHE STRING "SPQR libraries" FORCE)
+    # Mark as found and return early -- no need for the manual search below.
+    mark_as_advanced(SPQR_INCLUDES SPQR_LIBRARIES)
+    return()
+  endif()
+endif()
+
+# --- Fallback: manual search (SuiteSparse < 7.0 or no config package) ---
 find_path(SPQR_INCLUDES
   NAMES
   SuiteSparseQR.hpp
@@ -32,10 +76,10 @@
   if(CHOLMOD_LIBRARY)
     set(SPQR_LIBRARIES ${SPQR_LIBRARIES} ${CHOLMOD_LIBRARY})
   endif()
-  
+
 endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(SPQR DEFAULT_MSG SPQR_INCLUDES SPQR_LIBRARIES)
 
-mark_as_advanced(SPQR_INCLUDES SPQR_LIBRARIES)
\ No newline at end of file
+mark_as_advanced(SPQR_INCLUDES SPQR_LIBRARIES)
diff --git a/cmake/FindStandardMathLibrary.cmake b/cmake/FindStandardMathLibrary.cmake
index 1d1e5b3..ea8657f 100644
--- a/cmake/FindStandardMathLibrary.cmake
+++ b/cmake/FindStandardMathLibrary.cmake
@@ -12,6 +12,7 @@
 # Copyright (c) 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
 #               2020 Susi Lehtola <susi.lehtola@gmail.com>
 # Redistribution and use is allowed according to the terms of the 2-clause BSD license.
+# SPDX-License-Identifier: MPL-2.0
 
 
 include(CheckCXXSourceCompiles)
diff --git a/cmake/FindSuperLU.cmake b/cmake/FindSuperLU.cmake
index 4b779f5..ac9df04 100644
--- a/cmake/FindSuperLU.cmake
+++ b/cmake/FindSuperLU.cmake
@@ -1,3 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 # Umfpack lib usually requires linking to a blas library.
 # It is up to the user of this module to find a BLAS and link to it.
diff --git a/cmake/FindTriSYCL.cmake b/cmake/FindTriSYCL.cmake
index 8104239..f7af078 100644
--- a/cmake/FindTriSYCL.cmake
+++ b/cmake/FindTriSYCL.cmake
@@ -3,6 +3,7 @@
 #---------------
 #
 # TODO : insert Copyright and licence
+# SPDX-License-Identifier: MPL-2.0
 
 #########################
 #  FindTriSYCL.cmake
diff --git a/cmake/FindUMFPACK.cmake b/cmake/FindUMFPACK.cmake
index 91cf637..e0b9a3f 100644
--- a/cmake/FindUMFPACK.cmake
+++ b/cmake/FindUMFPACK.cmake
@@ -1,10 +1,54 @@
 # Umfpack lib usually requires linking to a blas library.
 # It is up to the user of this module to find a BLAS and link to it.
+#
+# This module first tries to find UMFPACK via its CMake config-mode package
+# (shipped with SuiteSparse >= 7.0). If that fails, it falls back to a
+# manual header/library search for compatibility with older installations.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 if (UMFPACK_INCLUDES AND UMFPACK_LIBRARIES)
   set(UMFPACK_FIND_QUIETLY TRUE)
 endif ()
 
+# --- Try config-mode first (SuiteSparse >= 7.0) ---
+# Run this on every configure, not only when the cache is cold.  The variables
+# set below name an imported target, which exists only if the config package has
+# been loaded in the *current* run.  Returning early on a warm cache left
+# UMFPACK_LIBRARIES naming a target that was never defined, so the first
+# configure of a build tree succeeded and every later one failed.
+find_package(UMFPACK CONFIG QUIET)
+if(UMFPACK_FOUND AND TARGET SuiteSparse::UMFPACK)
+  # Extract include dirs and libraries from the imported target so that the
+  # legacy variables expected by Eigen's build system are populated.
+  get_target_property(_umfpack_inc SuiteSparse::UMFPACK INTERFACE_INCLUDE_DIRECTORIES)
+  # SuiteSparse >= 7 exports these as a generator expression, e.g.
+  # $<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>.
+  # A generator expression cannot be cached and handed to callers that inspect
+  # include directories at configure time, so keep only literal paths and let
+  # the manual search below handle the rest.
+  set(_umfpack_inc_dirs "")
+  if(_umfpack_inc)
+    foreach(_dir IN LISTS _umfpack_inc)
+      if(NOT _dir MATCHES "\\$<")
+        list(APPEND _umfpack_inc_dirs "${_dir}")
+      endif()
+    endforeach()
+  endif()
+  if(_umfpack_inc_dirs)
+    # FORCE because a plain `set(... CACHE ...)` is a no-op when the entry
+    # already exists.  A build tree first configured before this fix still
+    # holds the unusable generator-expression value, and reconfiguring it
+    # would otherwise keep it forever.
+    set(UMFPACK_INCLUDES "${_umfpack_inc_dirs}" CACHE PATH "UMFPACK include directory" FORCE)
+    set(UMFPACK_LIBRARIES SuiteSparse::UMFPACK CACHE STRING "UMFPACK libraries" FORCE)
+    # Mark as found and return early -- no need for the manual search below.
+    mark_as_advanced(UMFPACK_INCLUDES UMFPACK_LIBRARIES)
+    return()
+  endif()
+endif()
+
+# --- Fallback: manual search (SuiteSparse < 7.0 or no config package) ---
 find_path(UMFPACK_INCLUDES
   NAMES
   umfpack.h
@@ -28,7 +72,7 @@
   if(COLAMD_LIBRARY)
     set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${COLAMD_LIBRARY})
   endif ()
-  
+
   find_library(AMD_LIBRARY amd PATHS ${UMFPACK_LIBDIR} $ENV{UMFPACKDIR} ${LIB_INSTALL_DIR})
   if(AMD_LIBRARY)
     set(UMFPACK_LIBRARIES ${UMFPACK_LIBRARIES} ${AMD_LIBRARY})
diff --git a/cmake/MORSE-Copyright.txt b/cmake/MORSE-Copyright.txt
new file mode 100644
index 0000000..80697a3
--- /dev/null
+++ b/cmake/MORSE-Copyright.txt
@@ -0,0 +1,45 @@
+MORSE CMake modules copyright notice
+====================================
+
+The MORSE CMake modules in this directory carry file-level copyright
+notices naming some or all of the following copyright holders:
+
+Copyright 2009-2014 The University of Tennessee and The University of
+Tennessee Research Foundation. All rights reserved.
+Copyright 2012-2017 Inria. All rights reserved.
+Copyright 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ.
+Bordeaux. All rights reserved.
+Copyright 2012-2013 Emmanuel Agullo.
+Copyright 2012-2013 Mathieu Faverge.
+Copyright 2012 Cedric Castagnede.
+Copyright 2013-2016 Florent Pruvost.
+
+The MORSE CMake modules state that they are distributed under the
+OSI-approved BSD License. The applicable BSD-style license text is:
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the applicable copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the applicable copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the names of the copyright holders nor the names of their
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/cmake/RegexUtils.cmake b/cmake/RegexUtils.cmake
index f0a1524..f5ba09c 100644
--- a/cmake/RegexUtils.cmake
+++ b/cmake/RegexUtils.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 function(escape_string_as_regex _str_out _str_in)
   string(REGEX REPLACE "\\\\" "\\\\\\\\" FILETEST2 "${_str_in}")
   string(REGEX REPLACE "([.$+*?|-])" "\\\\\\1" FILETEST2 "${FILETEST2}")
diff --git a/cmake/SyclConfigureTesting.cmake b/cmake/SyclConfigureTesting.cmake
index d4aa423..e0f5fea 100644
--- a/cmake/SyclConfigureTesting.cmake
+++ b/cmake/SyclConfigureTesting.cmake
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 set(CMAKE_CXX_STANDARD 17)
 # Forward CMake options as preprocessor definitions
 if(EIGEN_SYCL_USE_DEFAULT_SELECTOR)
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
new file mode 100644
index 0000000..48c5033
--- /dev/null
+++ b/contrib/CMakeLists.txt
@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+add_subdirectory(Eigen)
+if(EIGEN_BUILD_DOC)
+  add_subdirectory(doc EXCLUDE_FROM_ALL)
+endif()
+if(EIGEN_BUILD_TESTING)
+  if(EIGEN_LEAVE_TEST_IN_ALL_TARGET)
+    add_subdirectory(test) # CTest automatic test building relies on the "all" target.
+  else()
+    add_subdirectory(test EXCLUDE_FROM_ALL)
+  endif()
+endif()
diff --git a/contrib/Eigen/AdolcForward b/contrib/Eigen/AdolcForward
new file mode 100644
index 0000000..21e2667
--- /dev/null
+++ b/contrib/Eigen/AdolcForward
@@ -0,0 +1,158 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ADOLC_FORWARD_MODULE_H
+#define EIGEN_ADOLC_FORWARD_MODULE_H
+
+//--------------------------------------------------------------------------------
+//
+// This file provides support for adolc's adouble type in forward mode.
+// ADOL-C is a C++ automatic differentiation library,
+// see https://projects.coin-or.org/ADOL-C for more information.
+//
+// Note that the maximal number of directions is controlled by
+// the preprocessor token NUMBER_DIRECTIONS. The default is 2.
+//
+//--------------------------------------------------------------------------------
+
+#define ADOLC_TAPELESS
+#ifndef NUMBER_DIRECTIONS
+#define NUMBER_DIRECTIONS 2
+#endif
+#include <adolc/adtl.h>
+
+// adolc defines some very stupid macros:
+#if defined(malloc)
+#undef malloc
+#endif
+
+#if defined(calloc)
+#undef calloc
+#endif
+
+#if defined(realloc)
+#undef realloc
+#endif
+
+#include "../../Eigen/Core"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/**
+ * \defgroup AdolcForward_Module Adolc forward module
+ * This module provides support for adolc's adouble type in forward mode.
+ * ADOL-C is a C++ automatic differentiation library,
+ * see https://projects.coin-or.org/ADOL-C for more information.
+ * It mainly consists in:
+ *  - a struct Eigen::NumTraits<adtl::adouble> specialization
+ *  - overloads of internal::* math function for adtl::adouble type.
+ *
+ * Note that the maximal number of directions is controlled by
+ * the preprocessor token NUMBER_DIRECTIONS. The default is 2.
+ *
+ * \code
+ * #include <contrib/Eigen/AdolcForward>
+ * \endcode
+ */
+//@{
+
+}  // namespace Eigen
+
+// Eigen's require a few additional functions which must be defined in the same namespace
+// than the custom scalar type own namespace
+namespace adtl {
+
+inline const adouble& conj(const adouble& x) { return x; }
+inline const adouble& real(const adouble& x) { return x; }
+inline adouble imag(const adouble&) { return 0.; }
+inline adouble abs(const adouble& x) { return fabs(x); }
+inline adouble abs2(const adouble& x) { return x * x; }
+
+inline bool(isinf)(const adouble& x) { return (Eigen::numext::isinf)(x.getValue()); }
+inline bool(isnan)(const adouble& x) { return (Eigen::numext::isnan)(x.getValue()); }
+
+}  // namespace adtl
+
+namespace Eigen {
+
+template <>
+struct NumTraits<adtl::adouble> : NumTraits<double> {
+  typedef adtl::adouble Real;
+  typedef adtl::adouble NonInteger;
+  typedef adtl::adouble Nested;
+  enum {
+    IsComplex = 0,
+    IsInteger = 0,
+    IsSigned = 1,
+    RequireInitialization = 1,
+    ReadCost = 1,
+    AddCost = 1,
+    MulCost = 1
+  };
+};
+
+template <typename Functor>
+class AdolcForwardJacobian : public Functor {
+  typedef adtl::adouble ActiveScalar;
+
+ public:
+  AdolcForwardJacobian() : Functor() {}
+  AdolcForwardJacobian(const Functor& f) : Functor(f) {}
+
+  // forward constructors
+  template <typename T0>
+  AdolcForwardJacobian(const T0& a0) : Functor(a0) {}
+  template <typename T0, typename T1>
+  AdolcForwardJacobian(const T0& a0, const T1& a1) : Functor(a0, a1) {}
+  template <typename T0, typename T1, typename T2>
+  AdolcForwardJacobian(const T0& a0, const T1& a1, const T2& a2) : Functor(a0, a1, a2) {}
+
+  typedef typename Functor::InputType InputType;
+  typedef typename Functor::ValueType ValueType;
+  typedef typename Functor::JacobianType JacobianType;
+
+  typedef Matrix<ActiveScalar, InputType::SizeAtCompileTime, 1> ActiveInput;
+  typedef Matrix<ActiveScalar, ValueType::SizeAtCompileTime, 1> ActiveValue;
+
+  void operator()(const InputType& x, ValueType* v, JacobianType* _jac) const {
+    eigen_assert(v != 0);
+    if (!_jac) {
+      Functor::operator()(x, v);
+      return;
+    }
+
+    JacobianType& jac = *_jac;
+
+    ActiveInput ax = x.template cast<ActiveScalar>();
+    ActiveValue av(jac.rows());
+
+    for (int j = 0; j < jac.cols(); j++)
+      for (int i = 0; i < jac.cols(); i++) ax[i].setADValue(j, i == j ? 1 : 0);
+
+    Functor::operator()(ax, &av);
+
+    for (int i = 0; i < jac.rows(); i++) {
+      (*v)[i] = av[i].getValue();
+      for (int j = 0; j < jac.cols(); j++) jac.coeffRef(i, j) = av[i].getADValue(j);
+    }
+  }
+
+ protected:
+};
+
+//@}
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_ADOLC_FORWARD_MODULE_H
diff --git a/contrib/Eigen/AlignedVector3 b/contrib/Eigen/AlignedVector3
new file mode 100644
index 0000000..3be65a0
--- /dev/null
+++ b/contrib/Eigen/AlignedVector3
@@ -0,0 +1,212 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ALIGNED_VECTOR3_MODULE_H
+#define EIGEN_ALIGNED_VECTOR3_MODULE_H
+
+#include "../../Eigen/Geometry"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/**
+ * \defgroup AlignedVector3_Module Aligned vector3 module
+ *
+ * \code
+ * #include <contrib/Eigen/AlignedVector3>
+ * \endcode
+ */
+//@{
+
+/** \class AlignedVector3
+ *
+ * \brief A vectorization friendly 3D vector
+ *
+ * This class represents a 3D vector internally using a 4D vector
+ * such that vectorization can be seamlessly enabled. Of course,
+ * the same result can be achieved by directly using a 4D vector.
+ * This class makes this process simpler.
+ *
+ */
+// TODO: Specialize Cwise.
+template <typename Scalar_>
+class AlignedVector3;
+
+namespace internal {
+template <typename Scalar_>
+struct traits<AlignedVector3<Scalar_> > : traits<Matrix<Scalar_, 3, 1, 0, 4, 1> > {};
+}  // namespace internal
+
+template <typename Scalar_>
+class AlignedVector3 : public MatrixBase<AlignedVector3<Scalar_> > {
+  typedef Matrix<Scalar_, 4, 1> CoeffType;
+  CoeffType m_coeffs;
+
+ public:
+  typedef MatrixBase<AlignedVector3<Scalar_> > Base;
+  EIGEN_DENSE_PUBLIC_INTERFACE(AlignedVector3)
+  using Base::operator*;
+
+  inline Index rows() const { return 3; }
+  inline Index cols() const { return 1; }
+
+  Scalar* data() { return m_coeffs.data(); }
+  const Scalar* data() const { return m_coeffs.data(); }
+  Index innerStride() const { return 1; }
+  Index outerStride() const { return 3; }
+
+  inline const Scalar& coeff(Index row, Index col) const { return m_coeffs.coeff(row, col); }
+
+  inline Scalar& coeffRef(Index row, Index col) { return m_coeffs.coeffRef(row, col); }
+
+  inline const Scalar& coeff(Index index) const { return m_coeffs.coeff(index); }
+
+  inline Scalar& coeffRef(Index index) { return m_coeffs.coeffRef(index); }
+
+  inline AlignedVector3() {}
+
+  inline AlignedVector3(const Scalar& x, const Scalar& y, const Scalar& z) : m_coeffs(x, y, z, Scalar(0)) {}
+
+  inline AlignedVector3(const AlignedVector3& other) : Base(), m_coeffs(other.m_coeffs) {}
+
+  template <typename XprType, int Size = XprType::SizeAtCompileTime>
+  struct generic_assign_selector {};
+
+  template <typename XprType>
+  struct generic_assign_selector<XprType, 4> {
+    inline static void run(AlignedVector3& dest, const XprType& src) { dest.m_coeffs = src; }
+  };
+
+  template <typename XprType>
+  struct generic_assign_selector<XprType, 3> {
+    inline static void run(AlignedVector3& dest, const XprType& src) {
+      dest.m_coeffs.template head<3>() = src;
+      dest.m_coeffs.w() = Scalar(0);
+    }
+  };
+
+  template <typename Derived>
+  inline AlignedVector3(const MatrixBase<Derived>& other) {
+    generic_assign_selector<Derived>::run(*this, other.derived());
+  }
+
+  inline AlignedVector3& operator=(const AlignedVector3& other) {
+    m_coeffs = other.m_coeffs;
+    return *this;
+  }
+
+  template <typename Derived>
+  inline AlignedVector3& operator=(const MatrixBase<Derived>& other) {
+    generic_assign_selector<Derived>::run(*this, other.derived());
+    return *this;
+  }
+
+  inline AlignedVector3 operator+(const AlignedVector3& other) const {
+    return AlignedVector3(m_coeffs + other.m_coeffs);
+  }
+
+  inline AlignedVector3& operator+=(const AlignedVector3& other) {
+    m_coeffs += other.m_coeffs;
+    return *this;
+  }
+
+  inline AlignedVector3 operator-(const AlignedVector3& other) const {
+    return AlignedVector3(m_coeffs - other.m_coeffs);
+  }
+
+  inline AlignedVector3 operator-() const { return AlignedVector3(-m_coeffs); }
+
+  inline AlignedVector3& operator-=(const AlignedVector3& other) {
+    m_coeffs -= other.m_coeffs;
+    return *this;
+  }
+
+  inline AlignedVector3 operator*(const Scalar& s) const { return AlignedVector3(m_coeffs * s); }
+
+  inline friend AlignedVector3 operator*(const Scalar& s, const AlignedVector3& vec) {
+    return AlignedVector3(s * vec.m_coeffs);
+  }
+
+  inline AlignedVector3& operator*=(const Scalar& s) {
+    m_coeffs *= s;
+    return *this;
+  }
+
+  inline AlignedVector3 operator/(const Scalar& s) const { return AlignedVector3(m_coeffs / s); }
+
+  inline AlignedVector3& operator/=(const Scalar& s) {
+    m_coeffs /= s;
+    return *this;
+  }
+
+  inline Scalar dot(const AlignedVector3& other) const {
+    eigen_assert(m_coeffs.w() == Scalar(0));
+    eigen_assert(other.m_coeffs.w() == Scalar(0));
+    return m_coeffs.dot(other.m_coeffs);
+  }
+
+  inline void normalize() { m_coeffs /= norm(); }
+
+  inline AlignedVector3 normalized() const { return AlignedVector3(m_coeffs / norm()); }
+
+  inline Scalar sum() const {
+    eigen_assert(m_coeffs.w() == Scalar(0));
+    return m_coeffs.sum();
+  }
+
+  inline Scalar squaredNorm() const {
+    eigen_assert(m_coeffs.w() == Scalar(0));
+    return m_coeffs.squaredNorm();
+  }
+
+  inline Scalar norm() const {
+    using std::sqrt;
+    return sqrt(squaredNorm());
+  }
+
+  inline AlignedVector3 cross(const AlignedVector3& other) const {
+    return AlignedVector3(m_coeffs.cross3(other.m_coeffs));
+  }
+
+  template <typename Derived>
+  inline bool isApprox(const MatrixBase<Derived>& other,
+                       const RealScalar& eps = NumTraits<Scalar>::dummy_precision()) const {
+    return m_coeffs.template head<3>().isApprox(other, eps);
+  }
+
+  CoeffType& coeffs() { return m_coeffs; }
+  const CoeffType& coeffs() const { return m_coeffs; }
+};
+
+namespace internal {
+
+template <typename Scalar_>
+struct eval<AlignedVector3<Scalar_>, Dense> {
+  typedef const AlignedVector3<Scalar_>& type;
+};
+
+template <typename Scalar>
+struct evaluator<AlignedVector3<Scalar> > : evaluator<Matrix<Scalar, 4, 1> > {
+  typedef AlignedVector3<Scalar> XprType;
+  typedef evaluator<Matrix<Scalar, 4, 1> > Base;
+
+  evaluator(const XprType& m) : Base(m.coeffs()) {}
+};
+
+}  // namespace internal
+
+//@}
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_ALIGNED_VECTOR3_MODULE_H
diff --git a/contrib/Eigen/ArpackSupport b/contrib/Eigen/ArpackSupport
new file mode 100644
index 0000000..ba981d2
--- /dev/null
+++ b/contrib/Eigen/ArpackSupport
@@ -0,0 +1,35 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ARPACKSUPPORT_MODULE_H
+#define EIGEN_ARPACKSUPPORT_MODULE_H
+
+#include "../../Eigen/Core"
+
+/** \defgroup ArpackSupport_Module Arpack support module
+ *
+ * This module provides a wrapper to Arpack, a library for sparse eigenvalue decomposition.
+ *
+ * \code
+ * #include <contrib/Eigen/ArpackSupport>
+ * \endcode
+ */
+
+#include "../../Eigen/SparseCholesky"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/ArpackSupport/ArpackSelfAdjointEigenSolver.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_ARPACKSUPPORT_MODULE_H
diff --git a/contrib/Eigen/AutoDiff b/contrib/Eigen/AutoDiff
new file mode 100644
index 0000000..03fe928
--- /dev/null
+++ b/contrib/Eigen/AutoDiff
@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AUTODIFF_MODULE_H
+#define EIGEN_AUTODIFF_MODULE_H
+
+#include "../../Eigen/Core"
+
+namespace Eigen {
+
+/**
+ * \defgroup AutoDiff_Module Auto Diff module
+ *
+ * This module features forward automatic differentiation via a simple
+ * templated scalar type wrapper AutoDiffScalar.
+ *
+ * Warning : this should NOT be confused with numerical differentiation, which
+ * is a different method and has its own module in Eigen : \ref NumericalDiff_Module.
+ *
+ * \code
+ * #include <contrib/Eigen/AutoDiff>
+ * \endcode
+ *
+ * See \ref AutoDiffExamples for introductory examples.
+ */
+//@{
+
+}  // namespace Eigen
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/AutoDiff/CoherentPadOp.h"
+#include "src/AutoDiff/AutoDiffScalar.h"
+#include "src/AutoDiff/AutoDiffJacobian.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+namespace Eigen {
+//@}
+}
+
+#endif  // EIGEN_AUTODIFF_MODULE_H
diff --git a/contrib/Eigen/BVH b/contrib/Eigen/BVH
new file mode 100644
index 0000000..85c8f5e
--- /dev/null
+++ b/contrib/Eigen/BVH
@@ -0,0 +1,113 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BVH_MODULE_H
+#define EIGEN_BVH_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/Geometry"
+#include "../../Eigen/StdVector"
+#include <algorithm>
+#include <queue>
+
+namespace Eigen {
+
+/**
+  * \defgroup BVH_Module BVH module
+  * \brief This module provides generic bounding volume hierarchy algorithms
+  * and reference tree implementations.
+  *
+  *
+  * \code
+  * #include <contrib/Eigen/BVH>
+  * \endcode
+  *
+  * A bounding volume hierarchy (BVH) can accelerate many geometric queries.  This module provides a generic
+  implementation
+  * of the two basic algorithms over a BVH: intersection of a query object against all objects in the hierarchy and
+  minimization
+  * of a function over the objects in the hierarchy.  It also provides intersection and minimization over a cartesian
+  product of
+  * two BVH's.  A BVH accelerates intersection by using the fact that if a query object does not intersect a volume,
+  then it cannot
+  * intersect any object contained in that volume.  Similarly, a BVH accelerates minimization because the minimum of a
+  function
+  * over a volume is no greater than the minimum of a function over any object contained in it.
+  *
+  * Some sample queries that can be written in terms of intersection are:
+  *   - Determine all points where a ray intersects a triangle mesh
+  *   - Given a set of points, determine which are contained in a query sphere
+  *   - Given a set of spheres, determine which contain the query point
+  *   - Given a set of disks, determine if any is completely contained in a query rectangle (represent each 2D disk as a
+  point \f$(x,y,r)\f$
+  *     in 3D and represent the rectangle as a pyramid based on the original rectangle and shrinking in the \f$r\f$
+  direction)
+  *   - Given a set of points, count how many pairs are \f$d\pm\epsilon\f$ apart (done by looking at the cartesian
+  product of the set
+  *     of points with itself)
+  *
+  * Some sample queries that can be written in terms of function minimization over a set of objects are:
+  *   - Find the intersection between a ray and a triangle mesh closest to the ray origin (function is infinite off the
+  ray)
+  *   - Given a polyline and a query point, determine the closest point on the polyline to the query
+  *   - Find the diameter of a point cloud (done by looking at the cartesian product and using negative distance as the
+  function)
+  *   - Determine how far two meshes are from colliding (this is also a cartesian product query)
+  *
+  * This implementation decouples the basic algorithms both from the type of hierarchy (and the types of the bounding
+  volumes) and
+  * from the particulars of the query.  To enable abstraction from the BVH, the BVH is required to implement a generic
+  mechanism
+  * for traversal.  To abstract from the query, the query is responsible for keeping track of results.
+  *
+  * To be used in the algorithms, a hierarchy must implement the following traversal mechanism (see KdBVH for a sample
+  implementation): \code typedef Volume  //the type of bounding volume typedef Object  //the type of object in the
+  hierarchy typedef Index   //a reference to a node in the hierarchy--typically an int or a pointer typedef
+  VolumeIterator //an iterator type over node children--returns Index typedef ObjectIterator //an iterator over object
+  (leaf) children--returns const Object & Index getRootIndex() const //returns the index of the hierarchy root const
+  Volume &getVolume(Index index) const //returns the bounding volume of the node at given index void getChildren(Index
+  index, VolumeIterator &outVBegin, VolumeIterator &outVEnd, ObjectIterator &outOBegin, ObjectIterator &outOEnd) const
+      //getChildren takes a node index and makes [outVBegin, outVEnd) range over its node children
+      //and [outOBegin, outOEnd) range over its object children
+    \endcode
+  *
+  * To use the hierarchy, call BVIntersect or BVMinimize, passing it a BVH (or two, for cartesian product) and a
+  minimizer or intersector.
+  * For an intersection query on a single BVH, the intersector encapsulates the query and must provide two functions:
+  * \code
+      bool intersectVolume(const Volume &volume) //returns true if the query intersects the volume
+      bool intersectObject(const Object &object) //returns true if the intersection search should terminate immediately
+    \endcode
+  * The guarantee that BVIntersect provides is that intersectObject will be called on every object whose bounding volume
+  * intersects the query (but possibly on other objects too) unless the search is terminated prematurely.  It is the
+  * responsibility of the intersectObject function to keep track of the results in whatever manner is appropriate.
+  * The cartesian product intersection and the BVMinimize queries are similar--see their individual documentation.
+  *
+  * The following is a simple but complete example for how to use the BVH to accelerate the search for a closest
+  red-blue point pair:
+  * \include BVH_Example.cpp
+  * Output: \verbinclude BVH_Example.out
+  */
+}
+
+//@{
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/BVH/BVAlgorithms.h"
+#include "src/BVH/KdBVH.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+//@}
+
+#endif  // EIGEN_BVH_MODULE_H
diff --git a/contrib/Eigen/CMakeLists.txt b/contrib/Eigen/CMakeLists.txt
new file mode 100644
index 0000000..ecf39bc
--- /dev/null
+++ b/contrib/Eigen/CMakeLists.txt
@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# When adding a new umbrella header here, also add a corresponding
+# forwarding shim under unsupported/Eigen/ (and update the
+# Eigen_LegacyShim_HEADERS list in unsupported/Eigen/CMakeLists.txt) so
+# the legacy <unsupported/Eigen/...> include path keeps working.
+set(Eigen_HEADERS
+  AdolcForward
+  AlignedVector3
+  ArpackSupport
+  AutoDiff
+  BVH
+  EulerAngles
+  FFT
+  GPU
+  IterativeSolvers
+  KroneckerProduct
+  LevenbergMarquardt
+  MatrixFunctions
+  MPRealSupport
+  NNLS
+  NonLinearOptimization
+  NumericalDiff
+  OpenGLSupport
+  Polynomials
+  SparseExtra
+  SpecialFunctions
+  Splines
+  StructuredMatrices
+  Tensor
+  TensorSymmetry
+  )
+
+if(EIGEN_INSTALL)
+  install(FILES
+    ${Eigen_HEADERS}
+    DESTINATION ${INCLUDE_INSTALL_DIR}/contrib/Eigen COMPONENT Devel
+    )
+
+  install(DIRECTORY src DESTINATION ${INCLUDE_INSTALL_DIR}/contrib/Eigen COMPONENT Devel FILES_MATCHING PATTERN "*.h")
+endif()
diff --git a/contrib/Eigen/EulerAngles b/contrib/Eigen/EulerAngles
new file mode 100644
index 0000000..64aa3c2
--- /dev/null
+++ b/contrib/Eigen/EulerAngles
@@ -0,0 +1,45 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_EULERANGLES_MODULE_H
+#define EIGEN_EULERANGLES_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/Geometry"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/**
+ * \defgroup EulerAngles_Module EulerAngles module
+ * \brief This module provides generic euler angles rotation.
+ *
+ * Euler angles are a way to represent 3D rotation.
+ *
+ * In order to use this module in your code, include this header:
+ * \code
+ * #include <contrib/Eigen/EulerAngles>
+ * \endcode
+ *
+ * See \ref EulerAngles for more information.
+ *
+ */
+
+}
+
+// IWYU pragma: begin_exports
+#include "src/EulerAngles/EulerSystem.h"
+#include "src/EulerAngles/EulerAngles.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_EULERANGLES_MODULE_H
diff --git a/contrib/Eigen/FFT b/contrib/Eigen/FFT
new file mode 100644
index 0000000..56addd9
--- /dev/null
+++ b/contrib/Eigen/FFT
@@ -0,0 +1,494 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Mark Borgerding mark a borgerding net
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_MODULE_H
+#define EIGEN_FFT_MODULE_H
+
+#include <complex>
+#include <vector>
+#include <map>
+#include "../../Eigen/Core"
+
+/**
+ * \defgroup FFT_Module Fast Fourier Transform module
+ *
+ * \code
+ * #include <contrib/Eigen/FFT>
+ * \endcode
+ *
+ * This module provides Fast Fourier transformation, with a configurable backend
+ * implementation.
+ *
+ * The default implementation is based on kissfft. It is a small, free, and
+ * reasonably efficient default.
+ *
+ * There are currently four implementation backend:
+ *
+ * - kissfft(https://github.com/mborgerding/kissfft) : Simple and not so fast, BSD-3-Clause.
+ *   It is a mixed-radix Fast Fourier Transform based up on the principle, "Keep It Simple, Stupid."
+ *   Notice that:kissfft fails to handle "atypically-sized" inputs(i.e., sizes with large factors),a workaround is using
+ * fftw or pocketfft.
+ * - fftw (http://www.fftw.org) : faster, GPL -- incompatible with Eigen in LGPL form, bigger code size.
+ * - MKL (https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl-download.html) : fastest, free -- may be
+ * incompatible with Eigen in GPL form.
+ * - PocketFFT/DUCC (https://gitlab.mpcdf.mpg.de/mtr/pocketfft, https://gitlab.mpcdf.mpg.de/mtr/ducc) : faster than
+ *   kissfft, BSD 3-clause. A heavily modified implementation of FFTPack with the following advantages:
+ *   -# strictly C++14 compliant
+ *   -# more accurate twiddle factor computation
+ *   -# very fast plan generation
+ *   -# worst case complexity for transform sizes with large prime factors is N*log(N),
+ *      because Bluestein's algorithm is used for these cases.
+ *   .
+ *   According to the author, DUCC contains the "evolution" of pocketfft, though the interface is very similar.
+ *
+ * \section FFTThreadSafety Thread safety
+ *
+ * An FFT object is not thread-safe: it caches a plan, so concurrent transforms need one object per
+ * thread. Distinct objects may be used concurrently.
+ *
+ * That is not by itself enough for the FFTW backend, whose planner keeps process-wide state and
+ * whose only concurrent entry points are \c fftw_execute and its new-array variants. %Eigen
+ * therefore serializes plan creation and destruction on a mutex of its own, which covers every
+ * planner call %Eigen makes from within one process image.
+ *
+ * Two cases fall outside that. FFTW planner calls made directly, not through %Eigen, share nothing
+ * with %Eigen's mutex. And a program that loads several shared libraries which each carry their own
+ * copy of %Eigen may end up with one mutex per library instead of one per process: %Eigen gives the
+ * mutex default visibility so that the dynamic linker collapses those copies, which covers ELF
+ * libraries linked normally or loaded with \c RTLD_GLOBAL, but not separate Windows DLLs, and not a
+ * library loaded with \c RTLD_LOCAL unless the compiler emitted a unique symbol for the definition.
+ * In either case, call FFTW's own \c fftw_make_planner_thread_safe() once before any transform: it
+ * puts the lock inside the planner, where it applies to every caller. It needs FFTW 3.3.5 or later,
+ * built with thread support.
+ *
+ * \section FFTDesign Design
+ *
+ * The following design decisions were made concerning scaling and
+ * half-spectrum for real FFT.
+ *
+ * The intent is to facilitate generic programming and ease migrating code
+ * from  Matlab/octave.
+ * We think the default behavior of Eigen/FFT should favor correctness and
+ * generality over speed. Of course, the caller should be able to "opt-out" from this
+ * behavior and get the speed increase if they want it.
+ *
+ * 1) %Scaling:
+ * Other libraries (FFTW,IMKL,KISSFFT)  do not perform scaling, so there
+ * is a constant gain incurred after the forward&inverse transforms , so
+ * IFFT(FFT(x)) = Kx;  this is done to avoid a vector-by-value multiply.
+ * The downside is that algorithms that worked correctly in Matlab/octave
+ * don't behave the same way once implemented in C++.
+ *
+ * How Eigen/FFT differs: invertible scaling is performed so IFFT( FFT(x) ) = x.
+ *
+ * 2) Real FFT half-spectrum
+ * Other libraries use only half the frequency spectrum (plus one extra
+ * sample for the Nyquist bin) for a real FFT, the other half is the
+ * conjugate-symmetric of the first half.  This saves them a copy and some
+ * memory.  The downside is the caller needs to have special logic for the
+ * number of bins in complex vs real.
+ *
+ * How Eigen/FFT differs: The full spectrum is returned from the forward
+ * transform.  This facilitates generic template programming by obviating
+ * separate specializations for real vs complex.  On the inverse
+ * transform, only half the spectrum is actually used if the output type is real.
+ */
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+
+#ifdef EIGEN_FFTW_DEFAULT
+// FFTW: faster, GPL -- incompatible with Eigen in LGPL form, bigger code size
+#include <fftw3.h>
+#include "src/FFT/fftw_impl.h"
+namespace Eigen {
+template <typename T>
+struct default_fft_impl : public internal::fftw_impl<T> {};
+}  // namespace Eigen
+#elif defined EIGEN_MKL_DEFAULT
+// intel Math Kernel Library: fastest, free -- may be incompatible with Eigen in GPL form
+#include "src/FFT/imklfft_impl.h"
+namespace Eigen {
+template <typename T>
+struct default_fft_impl : public internal::imklfft::imklfft_impl<T> {};
+}  // namespace Eigen
+#elif defined EIGEN_POCKETFFT_DEFAULT
+// internal::pocketfft_impl: a heavily modified implementation of FFTPack, with many advantages.
+#include <pocketfft_hdronly.h>
+#include "src/FFT/pocketfft_impl.h"
+namespace Eigen {
+template <typename T>
+struct default_fft_impl : public internal::pocketfft_impl<T> {};
+}  // namespace Eigen
+#elif defined EIGEN_DUCCFFT_DEFAULT
+#include <ducc0/fft/fft.h>
+#include <ducc0/infra/string_utils.h>
+#include <ducc0/fft/fftnd_impl.h>
+#include "src/FFT/duccfft_impl.h"
+namespace Eigen {
+template <typename T>
+struct default_fft_impl : public internal::duccfft_impl<T> {};
+}  // namespace Eigen
+#else
+// internal::kissfft_impl:  small, free, reasonably efficient default, derived from kissfft
+#include "src/FFT/kissfft_impl.h"
+namespace Eigen {
+template <typename T>
+struct default_fft_impl : public internal::kissfft_impl<T> {};
+}  // namespace Eigen
+#endif
+
+// IWYU pragma: end_exports
+
+namespace Eigen {
+
+//
+template <typename T_SrcMat, typename T_FftIfc>
+struct fft_fwd_proxy;
+template <typename T_SrcMat, typename T_FftIfc>
+struct fft_inv_proxy;
+
+namespace internal {
+template <typename T_SrcMat, typename T_FftIfc>
+struct traits<fft_fwd_proxy<T_SrcMat, T_FftIfc> > {
+  typedef typename T_SrcMat::PlainObject ReturnType;
+};
+template <typename T_SrcMat, typename T_FftIfc>
+struct traits<fft_inv_proxy<T_SrcMat, T_FftIfc> > {
+  typedef typename T_SrcMat::PlainObject ReturnType;
+};
+}  // namespace internal
+
+template <typename T_SrcMat, typename T_FftIfc>
+struct fft_fwd_proxy : public ReturnByValue<fft_fwd_proxy<T_SrcMat, T_FftIfc> > {
+  typedef Eigen::Index Index;
+
+  fft_fwd_proxy(const T_SrcMat& src, T_FftIfc& fft, Index nfft) : m_src(src), m_ifc(fft), m_nfft(nfft) {}
+
+  template <typename T_DestMat>
+  void evalTo(T_DestMat& dst) const;
+
+  Index rows() const { return m_src.rows(); }
+  Index cols() const { return m_src.cols(); }
+
+ protected:
+  const T_SrcMat& m_src;
+  T_FftIfc& m_ifc;
+  Index m_nfft;
+};
+
+template <typename T_SrcMat, typename T_FftIfc>
+struct fft_inv_proxy : public ReturnByValue<fft_inv_proxy<T_SrcMat, T_FftIfc> > {
+  typedef Eigen::Index Index;
+
+  fft_inv_proxy(const T_SrcMat& src, T_FftIfc& fft, Index nfft) : m_src(src), m_ifc(fft), m_nfft(nfft) {}
+
+  template <typename T_DestMat>
+  void evalTo(T_DestMat& dst) const;
+
+  Index rows() const { return m_src.rows(); }
+  Index cols() const { return m_src.cols(); }
+
+ protected:
+  const T_SrcMat& m_src;
+  T_FftIfc& m_ifc;
+  Index m_nfft;
+};
+
+namespace internal {
+
+// The transforms are one-dimensional, but a matrix with a dynamic dimension only knows at run
+// time whether that dimension is one, so it cannot be rejected at compile time the way a matrix
+// of known two-dimensional shape can. Only the latter is excluded here.
+template <typename Derived>
+struct fft_accepts_as_vector {
+  static constexpr bool value = bool(Derived::IsVectorAtCompileTime) || int(Derived::RowsAtCompileTime) == Dynamic ||
+                                int(Derived::ColsAtCompileTime) == Dynamic;
+};
+
+// Distance between consecutive elements of a one-dimensional operand. The inner stride does not
+// answer this once matrices are accepted: a matrix holding a single row steps along its outer
+// stride, and only a unit distance lets the transform run over the operand's own memory.
+template <typename Derived>
+EIGEN_STRONG_INLINE Index fft_linear_stride(const DenseBase<Derived>& x) {
+  return x.rows() == 1 ? x.derived().colStride() : x.derived().rowStride();
+}
+
+// Resize a one-dimensional destination. Every orientation a compile-time dimension leaves open
+// is settled here: a fixed dimension other than one can only be the long one, and a destination
+// with two dynamic dimensions takes the orientation of the source.
+template <typename Derived>
+EIGEN_STRONG_INLINE void fft_resize_as_vector(DenseBase<Derived>& dst, Index size, bool source_is_row) {
+  // A destination already holding the transform's length in one dimension keeps that shape, which
+  // is the only one a view such as a Map can be given at all.
+  if ((dst.rows() == 1 && dst.cols() == size) || (dst.cols() == 1 && dst.rows() == size)) return;
+
+  constexpr int Rows = int(Derived::RowsAtCompileTime);
+  constexpr int Cols = int(Derived::ColsAtCompileTime);
+  const bool row = Rows == 1         ? true
+                   : Cols == 1       ? false
+                   : Cols != Dynamic ? true
+                   : Rows != Dynamic ? false
+                                     : source_is_row;
+  dst.derived().resize(row ? 1 : size, row ? size : 1);
+}
+
+}  // namespace internal
+
+#define EIGEN_STATIC_ASSERT_FFT_VECTOR(TYPE) \
+  EIGEN_STATIC_ASSERT(internal::fft_accepts_as_vector<TYPE>::value, YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX)
+
+template <typename T_Scalar, typename T_Impl = default_fft_impl<T_Scalar> >
+class FFT {
+ public:
+  typedef T_Impl impl_type;
+  typedef Eigen::Index Index;
+  typedef typename impl_type::Scalar Scalar;
+  typedef typename impl_type::Complex Complex;
+
+  using Flag = int;
+  static constexpr Flag Default = 0;
+  static constexpr Flag Unscaled = 1;
+  static constexpr Flag HalfSpectrum = 2;
+  static constexpr Flag Speedy = 32767;
+
+  FFT(const impl_type& impl = impl_type(), Flag flags = Default) : m_impl(impl), m_flag(flags) {
+    eigen_assert((flags == Default || flags == Unscaled || flags == HalfSpectrum || flags == Speedy) &&
+                 "invalid flags argument");
+  }
+
+  inline bool HasFlag(Flag f) const { return (m_flag & (int)f) == f; }
+
+  inline void SetFlag(Flag f) { m_flag |= (int)f; }
+
+  inline void ClearFlag(Flag f) { m_flag &= (~(int)f); }
+
+  inline void fwd(Complex* dst, const Scalar* src, Index nfft) {
+    m_impl.fwd(dst, src, static_cast<int>(nfft));
+    if (HasFlag(HalfSpectrum) == false) ReflectSpectrum(dst, nfft);
+  }
+
+  inline void fwd(Complex* dst, const Complex* src, Index nfft) { m_impl.fwd(dst, src, static_cast<int>(nfft)); }
+
+#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
+    defined EIGEN_MKL_DEFAULT
+  inline void fwd2(Complex* dst, const Complex* src, int n0, int n1) { m_impl.fwd2(dst, src, n0, n1); }
+#endif
+
+  template <typename Input_>
+  inline void fwd(std::vector<Complex>& dst, const std::vector<Input_>& src) {
+    EIGEN_IF_CONSTEXPR (NumTraits<Input_>::IsComplex == 0) {
+      if (HasFlag(HalfSpectrum))
+        dst.resize((src.size() >> 1) + 1);  // half the bins + Nyquist bin
+      else
+        dst.resize(src.size());
+    } else {
+      dst.resize(src.size());
+    }
+    fwd(&dst[0], &src[0], src.size());
+  }
+
+  template <typename InputDerived, typename ComplexDerived>
+  inline void fwd(DenseBase<ComplexDerived>& dst, const DenseBase<InputDerived>& src, Index nfft = -1) {
+    typedef typename ComplexDerived::Scalar dst_type;
+    typedef typename InputDerived::Scalar src_type;
+    EIGEN_STATIC_ASSERT_FFT_VECTOR(InputDerived)
+    EIGEN_STATIC_ASSERT_FFT_VECTOR(ComplexDerived)
+    EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(ComplexDerived, InputDerived)  // size at compile-time
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<dst_type, Complex>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    EIGEN_STATIC_ASSERT(int(InputDerived::Flags) & int(ComplexDerived::Flags) & DirectAccessBit,
+                        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
+    eigen_assert((src.rows() == 1 || src.cols() == 1) && "the input of an FFT must be one-dimensional");
+
+    if (nfft < 1) nfft = src.size();
+
+    Index dst_size = nfft;
+    EIGEN_IF_CONSTEXPR (NumTraits<src_type>::IsComplex == 0) {
+      if (HasFlag(HalfSpectrum)) {
+        dst_size = (nfft >> 1) + 1;
+      }
+    }
+    internal::fft_resize_as_vector(dst, dst_size, src.rows() == 1);
+
+    if (internal::fft_linear_stride(src) != 1 || src.size() < nfft) {
+      Matrix<src_type, 1, Dynamic> tmp(1, nfft);
+      const Index copy_size = (std::min)(src.size(), nfft);
+      if (copy_size > 0) {
+        tmp.head(copy_size) = src.reshaped().head(copy_size);
+      }
+      if (copy_size < nfft) tmp.tail(nfft - copy_size).setZero();
+      if (internal::fft_linear_stride(dst) != 1) {
+        Matrix<dst_type, 1, Dynamic> out(1, dst_size);
+        fwd(out.data(), tmp.data(), nfft);
+        dst.derived() = out.reshaped(dst.rows(), dst.cols());
+      } else {
+        fwd(dst.derived().data(), tmp.data(), nfft);
+      }
+    } else {
+      if (internal::fft_linear_stride(dst) != 1) {
+        Matrix<dst_type, 1, Dynamic> out(1, dst_size);
+        fwd(out.data(), src.derived().data(), nfft);
+        dst.derived() = out.reshaped(dst.rows(), dst.cols());
+      } else {
+        fwd(dst.derived().data(), src.derived().data(), nfft);
+      }
+    }
+  }
+
+  template <typename InputDerived>
+  inline fft_fwd_proxy<DenseBase<InputDerived>, FFT<T_Scalar, T_Impl> > fwd(const DenseBase<InputDerived>& src,
+                                                                            Index nfft = -1) {
+    return fft_fwd_proxy<DenseBase<InputDerived>, FFT<T_Scalar, T_Impl> >(src, *this, nfft);
+  }
+
+  template <typename InputDerived>
+  inline fft_inv_proxy<DenseBase<InputDerived>, FFT<T_Scalar, T_Impl> > inv(const DenseBase<InputDerived>& src,
+                                                                            Index nfft = -1) {
+    return fft_inv_proxy<DenseBase<InputDerived>, FFT<T_Scalar, T_Impl> >(src, *this, nfft);
+  }
+
+  inline void inv(Complex* dst, const Complex* src, Index nfft) {
+    m_impl.inv(dst, src, static_cast<int>(nfft));
+    if (HasFlag(Unscaled) == false) scale(dst, Scalar(1. / nfft), nfft);  // scale the time series
+  }
+
+  inline void inv(Scalar* dst, const Complex* src, Index nfft) {
+    m_impl.inv(dst, src, static_cast<int>(nfft));
+    if (HasFlag(Unscaled) == false) scale(dst, Scalar(1. / nfft), nfft);  // scale the time series
+  }
+
+  template <typename OutputDerived, typename ComplexDerived>
+  inline void inv(DenseBase<OutputDerived>& dst, const DenseBase<ComplexDerived>& src, Index nfft = -1) {
+    typedef typename ComplexDerived::Scalar src_type;
+    typedef typename ComplexDerived::RealScalar real_type;
+    typedef typename OutputDerived::Scalar dst_type;
+    const bool realfft = (NumTraits<dst_type>::IsComplex == 0);
+    EIGEN_STATIC_ASSERT_FFT_VECTOR(OutputDerived)
+    EIGEN_STATIC_ASSERT_FFT_VECTOR(ComplexDerived)
+    EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(ComplexDerived, OutputDerived)  // size at compile-time
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<src_type, Complex>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+    EIGEN_STATIC_ASSERT(int(OutputDerived::Flags) & int(ComplexDerived::Flags) & DirectAccessBit,
+                        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
+    eigen_assert((src.rows() == 1 || src.cols() == 1) && "the input of an FFT must be one-dimensional");
+
+    if (nfft < 1) {  // automatic FFT size determination
+      if (realfft && HasFlag(HalfSpectrum))
+        nfft = 2 * (src.size() - 1);  // assume even fft size
+      else
+        nfft = src.size();
+    }
+    internal::fft_resize_as_vector(dst, nfft, src.rows() == 1);
+
+    // check for nfft that does not fit the input data size
+    Index resize_input = (realfft && HasFlag(HalfSpectrum)) ? ((nfft / 2 + 1) - src.size()) : (nfft - src.size());
+
+    if (internal::fft_linear_stride(src) != 1 || resize_input) {
+      // if the vector is strided, then we need to copy it to a packed temporary
+      const auto src_lin = src.reshaped();
+      Matrix<src_type, 1, Dynamic> tmp;
+      if (resize_input) {
+        size_t ncopy = (std::min)(src.size(), src.size() + resize_input);
+        tmp.setZero(src.size() + resize_input);
+        if (realfft && HasFlag(HalfSpectrum)) {
+          // pad at the Nyquist bin
+          tmp.head(ncopy) = src_lin.head(ncopy);
+          tmp(ncopy - 1) = real(tmp(ncopy - 1));  // enforce real-only Nyquist bin
+        } else {
+          size_t nhead, ntail;
+          nhead = 1 + ncopy / 2 - 1;  // range  [0:pi)
+          ntail = ncopy / 2 - 1;      // range (-pi:0)
+          tmp.head(nhead) = src_lin.head(nhead);
+          tmp.tail(ntail) = src_lin.tail(ntail);
+          if (resize_input <
+              0) {  // shrinking -- create the Nyquist bin as the average of the two bins that fold into it
+            tmp(nhead) = (src_lin(nfft / 2) + src_lin(src.size() - nfft / 2)) * real_type(.5);
+          } else {  // expanding -- split the old Nyquist bin into two halves
+            tmp(nhead) = src_lin(nhead) * real_type(.5);
+            tmp(tmp.size() - nhead) = tmp(nhead);
+          }
+        }
+      } else {
+        tmp = src_lin;
+      }
+
+      if (internal::fft_linear_stride(dst) != 1) {
+        Matrix<dst_type, 1, Dynamic> out(1, nfft);
+        inv(out.data(), tmp.data(), nfft);
+        dst.derived() = out.reshaped(dst.rows(), dst.cols());
+      } else {
+        inv(dst.derived().data(), tmp.data(), nfft);
+      }
+    } else {
+      if (internal::fft_linear_stride(dst) != 1) {
+        Matrix<dst_type, 1, Dynamic> out(1, nfft);
+        inv(out.data(), src.derived().data(), nfft);
+        dst.derived() = out.reshaped(dst.rows(), dst.cols());
+      } else {
+        inv(dst.derived().data(), src.derived().data(), nfft);
+      }
+    }
+  }
+
+  template <typename Output_>
+  inline void inv(std::vector<Output_>& dst, const std::vector<Complex>& src, Index nfft = -1) {
+    if (nfft < 1)
+      nfft = (NumTraits<Output_>::IsComplex == 0 && HasFlag(HalfSpectrum)) ? 2 * (src.size() - 1) : src.size();
+    dst.resize(nfft);
+    inv(&dst[0], &src[0], nfft);
+  }
+
+#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
+    defined EIGEN_MKL_DEFAULT
+  inline void inv2(Complex* dst, const Complex* src, int n0, int n1) {
+    m_impl.inv2(dst, src, n0, n1);
+    if (HasFlag(Unscaled) == false) scale(dst, Scalar(1) / (n0 * n1), n0 * n1);
+  }
+#endif
+
+  inline impl_type& impl() { return m_impl; }
+
+ private:
+  template <typename T_Data>
+  inline void scale(T_Data* x, Scalar s, Index nx) {
+    for (int k = 0; k < nx; ++k) *x++ *= s;
+  }
+
+  inline void ReflectSpectrum(Complex* freq, Index nfft) {
+    // create the implicit right-half spectrum (conjugate-mirror of the left-half)
+    Index nhbins = (nfft >> 1) + 1;
+    for (Index k = nhbins; k < nfft; ++k) freq[k] = conj(freq[nfft - k]);
+  }
+
+  impl_type m_impl;
+  int m_flag;
+};
+
+template <typename T_SrcMat, typename T_FftIfc>
+template <typename T_DestMat>
+inline void fft_fwd_proxy<T_SrcMat, T_FftIfc>::evalTo(T_DestMat& dst) const {
+  m_ifc.fwd(dst, m_src, m_nfft);
+}
+
+template <typename T_SrcMat, typename T_FftIfc>
+template <typename T_DestMat>
+inline void fft_inv_proxy<T_SrcMat, T_FftIfc>::evalTo(T_DestMat& dst) const {
+  m_ifc.inv(dst, m_src, m_nfft);
+}
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_FFT_MODULE_H
diff --git a/contrib/Eigen/GPU b/contrib/Eigen/GPU
new file mode 100644
index 0000000..9e55590
--- /dev/null
+++ b/contrib/Eigen/GPU
@@ -0,0 +1,79 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GPU_MODULE_H
+#define EIGEN_GPU_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/SparseCore"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup GPU_Module GPU module
+ *
+ * GPU-accelerated dense linear algebra using NVIDIA CUDA libraries
+ * (cuSOLVER and cuBLAS).
+ *
+ * This module provides explicit GPU solver classes that coexist with Eigen's
+ * CPU solvers. Unlike the LAPACKE dispatch (which replaces the CPU
+ * implementation globally), GPU classes are separate types the user
+ * instantiates by choice:
+ *
+ * \code
+ * #define EIGEN_USE_GPU
+ * #include <contrib/Eigen/GPU>
+ *
+ * // CPU path (unchanged)
+ * Eigen::LLT<Eigen::MatrixXd> llt_cpu(A);
+ *
+ * // GPU path (explicit)
+ * Eigen::gpu::LLT<double> llt_gpu(A);   // L stays on device
+ * auto X = llt_gpu.solve(B);            // only B transferred per solve
+ * \endcode
+ *
+ * Requires CUDA 11.4+.
+ */
+
+#ifdef EIGEN_USE_GPU
+// IWYU pragma: begin_exports
+#include "src/GPU/FwdDecl.h"
+#include "src/GPU/Meta.h"
+#include "src/GPU/type_traits.h"
+#include "src/GPU/DeviceScalar.h"
+#include "src/GPU/DeviceMatrix.h"
+#include "src/GPU/GpuContext.h"
+#include "src/GPU/DeviceExpr.h"
+#include "src/GPU/DeviceBlasExpr.h"
+#include "src/GPU/DeviceSolverExpr.h"
+#include "src/GPU/DeviceDispatch.h"
+#include "src/GPU/GpuSolverContext.h"
+#include "src/GPU/GpuLLT.h"
+#include "src/GPU/GpuLU.h"
+#include "src/GPU/GpuQR.h"
+#include "src/GPU/GpuSVD.h"
+#include "src/GPU/GpuEigenSolver.h"
+#include "src/GPU/CuFftSupport.h"
+#include "src/GPU/GpuFFT.h"
+#include "src/GPU/CuSparseSupport.h"
+#ifdef EIGEN_SPARSECORE_MODULE_H
+#include "src/GPU/GpuSparseContext.h"
+#endif
+#if defined(EIGEN_CUDSS) && defined(EIGEN_SPARSECORE_MODULE_H)
+#include "src/GPU/CuDssSupport.h"
+#include "src/GPU/GpuSparseSolverBase.h"
+#include "src/GPU/GpuSparseLLT.h"
+#include "src/GPU/GpuSparseLDLT.h"
+#include "src/GPU/GpuSparseLU.h"
+#endif
+// IWYU pragma: end_exports
+#endif
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_GPU_MODULE_H
diff --git a/contrib/Eigen/IterativeSolvers b/contrib/Eigen/IterativeSolvers
new file mode 100644
index 0000000..41bfdfc
--- /dev/null
+++ b/contrib/Eigen/IterativeSolvers
@@ -0,0 +1,25 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ITERATIVE_SOLVERS_MODULE_H
+#define EIGEN_ITERATIVE_SOLVERS_MODULE_H
+
+// The contents of this module have been promoted to the supported
+// Eigen/IterativeLinearSolvers module. This header is retained as a thin
+// forwarding shim for backwards compatibility and may be removed in a future
+// release. Please include <Eigen/IterativeLinearSolvers> directly instead.
+#ifndef EIGEN_NO_DEPRECATED_WARNING
+#pragma message( \
+    "unsupported/Eigen/IterativeSolvers is deprecated and forwards to <Eigen/IterativeLinearSolvers>; please include that header directly. Define EIGEN_NO_DEPRECATED_WARNING to silence this message.")
+#endif
+
+#include "../../Eigen/IterativeLinearSolvers"
+
+#endif  // EIGEN_ITERATIVE_SOLVERS_MODULE_H
diff --git a/contrib/Eigen/KroneckerProduct b/contrib/Eigen/KroneckerProduct
new file mode 100644
index 0000000..730284e
--- /dev/null
+++ b/contrib/Eigen/KroneckerProduct
@@ -0,0 +1,39 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_KRONECKER_PRODUCT_MODULE_H
+#define EIGEN_KRONECKER_PRODUCT_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/SparseCore"
+
+namespace Eigen {
+
+/**
+ * \defgroup KroneckerProduct_Module KroneckerProduct module
+ *
+ * This module contains an experimental Kronecker product implementation.
+ *
+ * \code
+ * #include <contrib/Eigen/KroneckerProduct>
+ * \endcode
+ */
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/KroneckerProduct/KroneckerTensorProduct.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_KRONECKER_PRODUCT_MODULE_H
diff --git a/contrib/Eigen/LevenbergMarquardt b/contrib/Eigen/LevenbergMarquardt
new file mode 100644
index 0000000..3f595e0
--- /dev/null
+++ b/contrib/Eigen/LevenbergMarquardt
@@ -0,0 +1,46 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_LEVENBERGMARQUARDT_MODULE_H
+#define EIGEN_LEVENBERGMARQUARDT_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/Jacobi"
+#include "../../Eigen/QR"
+#include "../../Eigen/SparseCore"
+#include "../../Eigen/SparseQR"
+#include "NumericalDiff"
+
+/**
+ * \defgroup LevenbergMarquardt_Module Levenberg-Marquardt module
+ *
+ * \code
+ * #include <contrib/Eigen/LevenbergMarquardt>
+ * \endcode
+ *
+ *
+ */
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+#include "src/LevenbergMarquardt/LMqrsolv.h"
+#include "src/LevenbergMarquardt/LMcovar.h"
+#include "src/LevenbergMarquardt/LMpar.h"
+#endif
+
+#include "src/LevenbergMarquardt/LevenbergMarquardt.h"
+#include "src/LevenbergMarquardt/LMonestep.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_LEVENBERGMARQUARDT_MODULE_H
diff --git a/contrib/Eigen/MPRealSupport b/contrib/Eigen/MPRealSupport
new file mode 100644
index 0000000..756e89e
--- /dev/null
+++ b/contrib/Eigen/MPRealSupport
@@ -0,0 +1,219 @@
+// This file is part of a joint effort between Eigen, a lightweight C++ template library
+// for linear algebra, and MPFR C++, a C++ interface to MPFR library (http://www.holoborodko.com/pavel/)
+//
+// Copyright (C) 2010-2012 Pavel Holoborodko <pavel@holoborodko.com>
+// Copyright (C) 2010 Konstantin Holoborodko <konstantin@holoborodko.com>
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MPREALSUPPORT_MODULE_H
+#define EIGEN_MPREALSUPPORT_MODULE_H
+
+#include "../../Eigen/Core"
+#include <mpreal.h>
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/**
+  * \defgroup MPRealSupport_Module MPFRC++ Support module
+  * \code
+  * #include <contrib/Eigen/MPRealSupport>
+  * \endcode
+  *
+  * This module provides support for multi precision floating point numbers
+  * via the <a href="http://www.holoborodko.com/pavel/mpfr">MPFR C++</a>
+  * library which itself is built upon <a href="http://www.mpfr.org/">MPFR</a>/<a href="http://gmplib.org/">GMP</a>.
+  *
+  * \warning MPFR C++ is licensed under the GPL.
+  *
+  * You can find a copy of MPFR C++ that is known to be compatible in the contrib/test/mpreal folder.
+  *
+  * Here is an example:
+  *
+\code
+#include <iostream>
+#include <contrib/Eigen/MPRealSupport>
+#include <Eigen/LU>
+using namespace mpfr;
+using namespace Eigen;
+int main()
+{
+  // set precision to 256 bits (double has only 53 bits)
+  mpreal::set_default_prec(256);
+  // Declare matrix and vector types with multi-precision scalar type
+  typedef Matrix<mpreal,Dynamic,Dynamic>  MatrixXmp;
+  typedef Matrix<mpreal,Dynamic,1>        VectorXmp;
+
+  MatrixXmp A = MatrixXmp::Random(100,100);
+  VectorXmp b = VectorXmp::Random(100);
+
+  // Solve Ax=b using LU
+  VectorXmp x = A.lu().solve(b);
+  std::cout << "relative error: " << (A*x - b).norm() / b.norm() << std::endl;
+  return 0;
+}
+\endcode
+  *
+  */
+
+template <>
+struct NumTraits<mpfr::mpreal> : GenericNumTraits<mpfr::mpreal> {
+  enum {
+    IsInteger = 0,
+    IsSigned = 1,
+    IsComplex = 0,
+    RequireInitialization = 1,
+    ReadCost = HugeCost,
+    AddCost = HugeCost,
+    MulCost = HugeCost
+  };
+
+  typedef mpfr::mpreal Real;
+  typedef mpfr::mpreal NonInteger;
+
+  static inline Real highest(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::maxval(Precision); }
+  static inline Real lowest(long Precision = mpfr::mpreal::get_default_prec()) { return -mpfr::maxval(Precision); }
+
+  // Constants
+  static inline Real Pi(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::const_pi(Precision); }
+  static inline Real Euler(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::const_euler(Precision); }
+  static inline Real Log2(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::const_log2(Precision); }
+  static inline Real Catalan(long Precision = mpfr::mpreal::get_default_prec()) {
+    return mpfr::const_catalan(Precision);
+  }
+
+  static inline Real epsilon(long Precision = mpfr::mpreal::get_default_prec()) {
+    return mpfr::machine_epsilon(Precision);
+  }
+  static inline Real epsilon(const Real& x) { return mpfr::machine_epsilon(x); }
+
+#ifdef MPREAL_HAVE_DYNAMIC_STD_NUMERIC_LIMITS
+  static inline int digits10(long Precision = mpfr::mpreal::get_default_prec()) {
+    return std::numeric_limits<Real>::digits10(Precision);
+  }
+  static inline int digits10(const Real& x) { return std::numeric_limits<Real>::digits10(x); }
+
+  static inline int max_digits10(long Precision = mpfr::mpreal::get_default_prec()) {
+    return std::numeric_limits<Real>::max_digits10(Precision);
+  }
+
+  static inline int digits() { return std::numeric_limits<Real>::digits(); }
+  static inline int digits(const Real& x) { return std::numeric_limits<Real>::digits(x); }
+#endif
+
+  static inline Real dummy_precision() {
+    mpfr_prec_t weak_prec = ((mpfr::mpreal::get_default_prec() - 1) * 90) / 100;
+    return mpfr::machine_epsilon(weak_prec);
+  }
+};
+
+namespace internal {
+
+template <>
+inline mpfr::mpreal random<mpfr::mpreal>() {
+  return mpfr::random();
+}
+
+template <>
+inline mpfr::mpreal random<mpfr::mpreal>(const mpfr::mpreal& a, const mpfr::mpreal& b) {
+  return a + (b - a) * random<mpfr::mpreal>();
+}
+
+inline bool isMuchSmallerThan(const mpfr::mpreal& a, const mpfr::mpreal& b, const mpfr::mpreal& eps) {
+  return mpfr::abs(a) <= mpfr::abs(b) * eps;
+}
+
+inline bool isApprox(const mpfr::mpreal& a, const mpfr::mpreal& b, const mpfr::mpreal& eps) {
+  return mpfr::isEqualFuzzy(a, b, eps);
+}
+
+inline bool isApproxOrLessThan(const mpfr::mpreal& a, const mpfr::mpreal& b, const mpfr::mpreal& eps) {
+  return a <= b || mpfr::isEqualFuzzy(a, b, eps);
+}
+
+template <>
+inline long double cast<mpfr::mpreal, long double>(const mpfr::mpreal& x) {
+  return x.toLDouble();
+}
+
+template <>
+inline double cast<mpfr::mpreal, double>(const mpfr::mpreal& x) {
+  return x.toDouble();
+}
+
+template <>
+inline long cast<mpfr::mpreal, long>(const mpfr::mpreal& x) {
+  return x.toLong();
+}
+
+template <>
+inline int cast<mpfr::mpreal, int>(const mpfr::mpreal& x) {
+  return int(x.toLong());
+}
+
+// Specialize GEBP kernel and traits for mpreal (no need for peeling, nor complicated stuff)
+// This also permits to directly call mpfr's routines and avoid many temporaries produced by mpreal
+template <>
+class gebp_traits<mpfr::mpreal, mpfr::mpreal, false, false> {
+ public:
+  typedef mpfr::mpreal ResScalar;
+  enum {
+    Vectorizable = false,
+    LhsPacketSize = 1,
+    RhsPacketSize = 1,
+    ResPacketSize = 1,
+    NumberOfRegisters = 1,
+    nr = 1,
+    mr = 1,
+    LhsProgress = 1,
+    RhsProgress = 1
+  };
+  typedef ResScalar LhsPacket;
+  typedef ResScalar RhsPacket;
+  typedef ResScalar ResPacket;
+  typedef LhsPacket LhsPacket4Packing;
+};
+
+template <typename Index, typename DataMapper, bool ConjugateLhs, bool ConjugateRhs>
+struct gebp_kernel<mpfr::mpreal, mpfr::mpreal, Index, DataMapper, 1, 1, ConjugateLhs, ConjugateRhs> {
+  typedef mpfr::mpreal mpreal;
+
+  EIGEN_DONT_INLINE void operator()(const DataMapper& res, const mpreal* blockA, const mpreal* blockB, Index rows,
+                                    Index depth, Index cols, const mpreal& alpha, Index strideA = -1,
+                                    Index strideB = -1, Index offsetA = 0, Index offsetB = 0) {
+    if (rows == 0 || cols == 0 || depth == 0) return;
+
+    mpreal acc1(0, mpfr_get_prec(blockA[0].mpfr_srcptr())), tmp(0, mpfr_get_prec(blockA[0].mpfr_srcptr()));
+
+    if (strideA == -1) strideA = depth;
+    if (strideB == -1) strideB = depth;
+
+    for (Index i = 0; i < rows; ++i) {
+      for (Index j = 0; j < cols; ++j) {
+        const mpreal* A = blockA + i * strideA + offsetA;
+        const mpreal* B = blockB + j * strideB + offsetB;
+
+        acc1 = 0;
+        for (Index k = 0; k < depth; k++) {
+          mpfr_mul(tmp.mpfr_ptr(), A[k].mpfr_srcptr(), B[k].mpfr_srcptr(), mpreal::get_default_rnd());
+          mpfr_add(acc1.mpfr_ptr(), acc1.mpfr_ptr(), tmp.mpfr_ptr(), mpreal::get_default_rnd());
+        }
+
+        mpfr_mul(acc1.mpfr_ptr(), acc1.mpfr_srcptr(), alpha.mpfr_srcptr(), mpreal::get_default_rnd());
+        mpfr_add(res(i, j).mpfr_ptr(), res(i, j).mpfr_srcptr(), acc1.mpfr_srcptr(), mpreal::get_default_rnd());
+      }
+    }
+  }
+};
+}  // end namespace internal
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_MPREALSUPPORT_MODULE_H
diff --git a/contrib/Eigen/MatrixFunctions b/contrib/Eigen/MatrixFunctions
new file mode 100644
index 0000000..294d541
--- /dev/null
+++ b/contrib/Eigen/MatrixFunctions
@@ -0,0 +1,505 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2012 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_FUNCTIONS_MODULE_H
+#define EIGEN_MATRIX_FUNCTIONS_MODULE_H
+
+#include <cfloat>
+#include <list>
+
+#include "../../Eigen/Core"
+#include "../../Eigen/LU"
+#include "../../Eigen/Eigenvalues"
+
+/**
+ * \defgroup MatrixFunctions_Module Matrix functions module
+ * \brief This module aims to provide various methods for the computation of
+ * matrix functions.
+ *
+ * To use this module, add
+ * \code
+ * #include <contrib/Eigen/MatrixFunctions>
+ * \endcode
+ * at the start of your source file.
+ *
+ * This module defines the following MatrixBase methods.
+ *  - \ref matrixbase_cos "MatrixBase::cos()", for computing the matrix cosine
+ *  - \ref matrixbase_cosh "MatrixBase::cosh()", for computing the matrix hyperbolic cosine
+ *  - \ref matrixbase_exp "MatrixBase::exp()", for computing the matrix exponential
+ *  - \ref matrixbase_log "MatrixBase::log()", for computing the matrix logarithm
+ *  - \ref matrixbase_pow "MatrixBase::pow()", for computing the matrix power
+ *  - \ref matrixbase_matrixfunction "MatrixBase::matrixFunction()", for computing general matrix functions
+ *  - \ref matrixbase_sin "MatrixBase::sin()", for computing the matrix sine
+ *  - \ref matrixbase_sinh "MatrixBase::sinh()", for computing the matrix hyperbolic sine
+ *  - \ref matrixbase_sqrt "MatrixBase::sqrt()", for computing the matrix square root
+ *
+ * These methods are the main entry points to this module.
+ *
+ * %Matrix functions are defined as follows.  Suppose that \f$ f \f$
+ * is an entire function (that is, a function on the complex plane
+ * that is everywhere complex differentiable).  Then its Taylor
+ * series
+ * \f[ f(0) + f'(0) x + \frac{f''(0)}{2} x^2 + \frac{f'''(0)}{3!} x^3 + \cdots \f]
+ * converges to \f$ f(x) \f$. In this case, we can define the matrix
+ * function by the same series:
+ * \f[ f(M) = f(0) + f'(0) M + \frac{f''(0)}{2} M^2 + \frac{f'''(0)}{3!} M^3 + \cdots \f]
+ *
+ */
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/MatrixFunctions/MatrixExponential.h"
+#include "src/MatrixFunctions/MatrixFunction.h"
+#include "src/MatrixFunctions/MatrixSquareRoot.h"
+#include "src/MatrixFunctions/MatrixLogarithm.h"
+#include "src/MatrixFunctions/MatrixPower.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+/**
+\page matrixbaseextra_page
+\ingroup MatrixFunctions_Module
+
+\section matrixbaseextra MatrixBase methods defined in the MatrixFunctions module
+
+The remainder of the page documents the following MatrixBase methods
+which are defined in the MatrixFunctions module.
+
+
+
+\subsection matrixbase_cos MatrixBase::cos()
+
+Compute the matrix cosine.
+
+\code
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cos() const
+\endcode
+
+\param[in]  M  a square matrix.
+\returns  expression representing \f$ \cos(M) \f$.
+
+This function computes the matrix cosine. Use ArrayBase::cos() for computing the entry-wise cosine.
+
+The implementation calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::cos().
+
+\sa \ref matrixbase_sin "sin()" for an example.
+
+
+
+\subsection matrixbase_cosh MatrixBase::cosh()
+
+Compute the matrix hyberbolic cosine.
+
+\code
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cosh() const
+\endcode
+
+\param[in]  M  a square matrix.
+\returns  expression representing \f$ \cosh(M) \f$
+
+This function calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::cosh().
+
+\sa \ref matrixbase_sinh "sinh()" for an example.
+
+
+
+\subsection matrixbase_exp MatrixBase::exp()
+
+Compute the matrix exponential.
+
+\code
+const MatrixExponentialReturnValue<Derived> MatrixBase<Derived>::exp() const
+\endcode
+
+\param[in]  M  matrix whose exponential is to be computed.
+\returns    expression representing the matrix exponential of \p M.
+
+The matrix exponential of \f$ M \f$ is defined by
+\f[ \exp(M) = \sum_{k=0}^\infty \frac{M^k}{k!}. \f]
+The matrix exponential can be used to solve linear ordinary
+differential equations: the solution of \f$ y' = My \f$ with the
+initial condition \f$ y(0) = y_0 \f$ is given by
+\f$ y(t) = \exp(M) y_0 \f$.
+
+The matrix exponential is different from applying the exp function to all the entries in the matrix.
+Use ArrayBase::exp() if you want to do the latter.
+
+The cost of the computation is approximately \f$ 20 n^3 \f$ for
+matrices of size \f$ n \f$. The number 20 depends weakly on the
+norm of the matrix.
+
+The matrix exponential is computed using the scaling-and-squaring
+method combined with Pad&eacute; approximation. The matrix is first
+rescaled, then the exponential of the reduced matrix is computed
+approximant, and then the rescaling is undone by repeated
+squaring. The degree of the Pad&eacute; approximant is chosen such
+that the approximation error is less than the round-off
+error. However, errors may accumulate during the squaring phase.
+
+Details of the algorithm can be found in: Nicholas J. Higham, "The
+scaling and squaring method for the matrix exponential revisited,"
+<em>SIAM J. %Matrix Anal. Applic.</em>, <b>26</b>:1179&ndash;1193,
+2005.
+
+Example: The following program checks that
+\f[ \exp \left[ \begin{array}{ccc}
+      0 & \frac14\pi & 0 \\
+      -\frac14\pi & 0 & 0 \\
+      0 & 0 & 0
+    \end{array} \right] = \left[ \begin{array}{ccc}
+      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
+      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
+      0 & 0 & 1
+    \end{array} \right]. \f]
+This corresponds to a rotation of \f$ \frac14\pi \f$ radians around
+the z-axis.
+
+\include MatrixExponential.cpp
+Output: \verbinclude MatrixExponential.out
+
+\note \p M has to be a matrix of \c float, \c double, `long double`
+\c complex<float>, \c complex<double>, or `complex<long double>` .
+
+
+\subsection matrixbase_log MatrixBase::log()
+
+Compute the matrix logarithm.
+
+\code
+const MatrixLogarithmReturnValue<Derived> MatrixBase<Derived>::log() const
+\endcode
+
+\param[in]  M  invertible matrix whose logarithm is to be computed.
+\returns    expression representing the matrix logarithm root of \p M.
+
+The matrix logarithm of \f$ M \f$ is a matrix \f$ X \f$ such that
+\f$ \exp(X) = M \f$ where exp denotes the matrix exponential. As for
+the scalar logarithm, the equation \f$ \exp(X) = M \f$ may have
+multiple solutions; this function returns a matrix whose eigenvalues
+have imaginary part in the interval \f$ (-\pi,\pi] \f$.
+
+The matrix logarithm is different from applying the log function to all the entries in the matrix.
+Use ArrayBase::log() if you want to do the latter.
+
+In the real case, the matrix \f$ M \f$ should be invertible and
+it should have no eigenvalues which are real and negative (pairs of
+complex conjugate eigenvalues are allowed). In the complex case, it
+only needs to be invertible.
+
+This function computes the matrix logarithm using the Schur-Parlett
+algorithm as implemented by MatrixBase::matrixFunction(). The
+logarithm of an atomic block is computed by MatrixLogarithmAtomic,
+which uses direct computation for 1-by-1 and 2-by-2 blocks and an
+inverse scaling-and-squaring algorithm for bigger blocks, with the
+square roots computed by MatrixBase::sqrt().
+
+Details of the algorithm can be found in Section 11.6.2 of:
+Nicholas J. Higham,
+<em>Functions of Matrices: Theory and Computation</em>,
+SIAM 2008. ISBN 978-0-898716-46-7.
+
+Example: The following program checks that
+\f[ \log \left[ \begin{array}{ccc}
+      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
+      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
+      0 & 0 & 1
+    \end{array} \right] = \left[ \begin{array}{ccc}
+      0 & \frac14\pi & 0 \\
+      -\frac14\pi & 0 & 0 \\
+      0 & 0 & 0
+    \end{array} \right]. \f]
+This corresponds to a rotation of \f$ \frac14\pi \f$ radians around
+the z-axis. This is the inverse of the example used in the
+documentation of \ref matrixbase_exp "exp()".
+
+\include MatrixLogarithm.cpp
+Output: \verbinclude MatrixLogarithm.out
+
+\note \p M has to be a matrix of \c float, \c double, `long
+double`, \c complex<float>, \c complex<double>, or `complex<long double>`.
+
+\sa MatrixBase::exp(), MatrixBase::matrixFunction(),
+    class MatrixLogarithmAtomic, MatrixBase::sqrt().
+
+
+\subsection matrixbase_pow MatrixBase::pow()
+
+Compute the matrix raised to arbitrary real power.
+
+\code
+const MatrixPowerReturnValue<Derived> MatrixBase<Derived>::pow(RealScalar p) const
+\endcode
+
+\param[in]  M  base of the matrix power, should be a square matrix.
+\param[in]  p  exponent of the matrix power.
+
+The matrix power \f$ M^p \f$ is defined as \f$ \exp(p \log(M)) \f$,
+where exp denotes the matrix exponential, and log denotes the matrix
+logarithm. This is different from raising all the entries in the matrix
+to the p-th power. Use ArrayBase::pow() if you want to do the latter.
+
+If \p p is complex, the scalar type of \p M should be the type of \p
+p . \f$ M^p \f$ simply evaluates into \f$ \exp(p \log(M)) \f$.
+Therefore, the matrix \f$ M \f$ should meet the conditions to be an
+argument of matrix logarithm.
+
+If \p p is real, it is casted into the real scalar type of \p M. Then
+this function computes the matrix power using the Schur-Pad&eacute;
+algorithm as implemented by class MatrixPower. The exponent is split
+into integral part and fractional part, where the fractional part is
+in the interval \f$ (-1, 1) \f$. The main diagonal and the first
+super-diagonal is directly computed.
+
+If \p M is singular with a semisimple zero eigenvalue and \p p is
+positive, the Schur factor \f$ T \f$ is reordered with Givens
+rotations, i.e.
+
+\f[ T = \left[ \begin{array}{cc}
+      T_1 & T_2 \\
+      0   & 0
+    \end{array} \right] \f]
+
+where \f$ T_1 \f$ is invertible. Then \f$ T^p \f$ is given by
+
+\f[ T^p = \left[ \begin{array}{cc}
+      T_1^p & T_1^{-1} T_1^p T_2 \\
+      0     & 0
+    \end{array}. \right] \f]
+
+\warning Fractional power of a matrix with a non-semisimple zero
+eigenvalue is not well-defined. We introduce an assertion failure
+against inaccurate result, e.g. \code
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+int main()
+{
+  Eigen::Matrix4d A;
+  A << 0, 0, 2, 3,
+       0, 0, 4, 5,
+       0, 0, 6, 7,
+       0, 0, 8, 9;
+  std::cout << A.pow(0.37) << std::endl;
+
+  // The 1 makes eigenvalue 0 non-semisimple.
+  A.coeffRef(0, 1) = 1;
+
+  // This fails if EIGEN_NO_DEBUG is undefined.
+  std::cout << A.pow(0.37) << std::endl;
+
+  return 0;
+}
+\endcode
+
+Details of the algorithm can be found in: Nicholas J. Higham and
+Lijing Lin, "A Schur-Pad&eacute; algorithm for fractional powers of a
+matrix," <em>SIAM J. %Matrix Anal. Applic.</em>,
+<b>32(3)</b>:1056&ndash;1078, 2011.
+
+Example: The following program checks that
+\f[ \left[ \begin{array}{ccc}
+      \cos1 & -\sin1 & 0 \\
+      \sin1 & \cos1 & 0 \\
+      0 & 0 & 1
+    \end{array} \right]^{\frac14\pi} = \left[ \begin{array}{ccc}
+      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
+      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
+      0 & 0 & 1
+    \end{array} \right]. \f]
+This corresponds to \f$ \frac14\pi \f$ rotations of 1 radian around
+the z-axis.
+
+\include MatrixPower.cpp
+Output: \verbinclude MatrixPower.out
+
+MatrixBase::pow() is user-friendly. However, there are some
+circumstances under which you should use class MatrixPower directly.
+MatrixPower can save the result of Schur decomposition, so it's
+better for computing various powers for the same matrix.
+
+Example:
+\include MatrixPower_optimal.cpp
+Output: \verbinclude MatrixPower_optimal.out
+
+\note \p M has to be a matrix of \c float, \c double, `long
+double`, \c complex<float>, \c complex<double>, or
+\c complex<long double> .
+
+\sa MatrixBase::exp(), MatrixBase::log(), class MatrixPower.
+
+
+\subsection matrixbase_matrixfunction MatrixBase::matrixFunction()
+
+Compute a matrix function.
+
+\code
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(typename internal::stem_function<typename
+internal::traits<Derived>::Scalar>::type f) const \endcode
+
+\param[in]  M  argument of matrix function, should be a square matrix.
+\param[in]  f  an entire function; \c f(x,n) should compute the n-th
+derivative of f at x.
+\returns  expression representing \p f applied to \p M.
+
+Suppose that \p M is a matrix whose entries have type \c Scalar.
+Then, the second argument, \p f, should be a function with prototype
+\code
+ComplexScalar f(ComplexScalar, int)
+\endcode
+where \c ComplexScalar = \c std::complex<Scalar> if \c Scalar is
+real (e.g., \c float or \c double) and \c ComplexScalar =
+\c Scalar if \c Scalar is complex. The return value of \c f(x,n)
+should be \f$ f^{(n)}(x) \f$, the n-th derivative of f at x.
+
+This routine uses the algorithm described in:
+Philip Davies and Nicholas J. Higham,
+"A Schur-Parlett algorithm for computing matrix functions",
+<em>SIAM J. %Matrix Anal. Applic.</em>, <b>25</b>:464&ndash;485, 2003.
+
+The actual work is done by the MatrixFunction class.
+
+Example: The following program checks that
+\f[ \exp \left[ \begin{array}{ccc}
+      0 & \frac14\pi & 0 \\
+      -\frac14\pi & 0 & 0 \\
+      0 & 0 & 0
+    \end{array} \right] = \left[ \begin{array}{ccc}
+      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
+      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
+      0 & 0 & 1
+    \end{array} \right]. \f]
+This corresponds to a rotation of \f$ \frac14\pi \f$ radians around
+the z-axis. This is the same example as used in the documentation
+of \ref matrixbase_exp "exp()".
+
+\include MatrixFunction.cpp
+Output: \verbinclude MatrixFunction.out
+
+Note that the function \c expfn is defined for complex numbers
+\c x, even though the matrix \c A is over the reals. Instead of
+\c expfn, we could also have used StdStemFunctions::exp:
+\code
+A.matrixFunction(StdStemFunctions<std::complex<double> >::exp, &B);
+\endcode
+
+
+
+\subsection matrixbase_sin MatrixBase::sin()
+
+Compute the matrix sine.
+
+\code
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sin() const
+\endcode
+
+\param[in]  M  a square matrix.
+\returns  expression representing \f$ \sin(M) \f$.
+
+This function computes the matrix sine. Use ArrayBase::sin() for computing the entry-wise sine.
+
+The implementation calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::sin().
+
+Example: \include MatrixSine.cpp
+Output: \verbinclude MatrixSine.out
+
+
+
+\subsection matrixbase_sinh MatrixBase::sinh()
+
+Compute the matrix hyperbolic sine.
+
+\code
+MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sinh() const
+\endcode
+
+\param[in]  M  a square matrix.
+\returns  expression representing \f$ \sinh(M) \f$
+
+This function calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::sinh().
+
+Example: \include MatrixSinh.cpp
+Output: \verbinclude MatrixSinh.out
+
+
+\subsection matrixbase_sqrt MatrixBase::sqrt()
+
+Compute the matrix square root.
+
+\code
+const MatrixSquareRootReturnValue<Derived> MatrixBase<Derived>::sqrt() const
+\endcode
+
+\param[in]  M  invertible matrix whose square root is to be computed.
+\returns    expression representing the matrix square root of \p M.
+
+The matrix square root of \f$ M \f$ is the matrix \f$ M^{1/2} \f$
+whose square is the original matrix; so if \f$ S = M^{1/2} \f$ then
+\f$ S^2 = M \f$. This is different from taking the square root of all
+the entries in the matrix; use ArrayBase::sqrt() if you want to do the
+latter.
+
+In the <b>real case</b>, the matrix \f$ M \f$ should be invertible and
+it should have no eigenvalues which are real and negative (pairs of
+complex conjugate eigenvalues are allowed). In that case, the matrix
+has a square root which is also real, and this is the square root
+computed by this function.
+
+The matrix square root is computed by first reducing the matrix to
+quasi-triangular form with the real Schur decomposition. The square
+root of the quasi-triangular matrix can then be computed directly. The
+cost is approximately \f$ 25 n^3 \f$ real flops for the real Schur
+decomposition and \f$ 3\frac13 n^3 \f$ real flops for the remainder
+(though the computation time in practice is likely more than this
+indicates).
+
+Details of the algorithm can be found in: Nicholas J. Highan,
+"Computing real square roots of a real matrix", <em>Linear Algebra
+Appl.</em>, 88/89:405&ndash;430, 1987.
+
+If the matrix is <b>positive-definite symmetric</b>, then the square
+root is also positive-definite symmetric. In this case, it is best to
+use SelfAdjointEigenSolver::operatorSqrt() to compute it.
+
+In the <b>complex case</b>, the matrix \f$ M \f$ should be invertible;
+this is a restriction of the algorithm. The square root computed by
+this algorithm is the one whose eigenvalues have an argument in the
+interval \f$ (-\frac12\pi, \frac12\pi] \f$. This is the usual branch
+cut.
+
+The computation is the same as in the real case, except that the
+complex Schur decomposition is used to reduce the matrix to a
+triangular matrix. The theoretical cost is the same. Details are in:
+&Aring;ke Bj&ouml;rck and Sven Hammarling, "A Schur method for the
+square root of a matrix", <em>Linear Algebra Appl.</em>,
+52/53:127&ndash;140, 1983.
+
+Example: The following program checks that the square root of
+\f[ \left[ \begin{array}{cc}
+              \cos(\frac13\pi) & -\sin(\frac13\pi) \\
+              \sin(\frac13\pi) & \cos(\frac13\pi)
+    \end{array} \right], \f]
+corresponding to a rotation over 60 degrees, is a rotation over 30 degrees:
+\f[ \left[ \begin{array}{cc}
+              \cos(\frac16\pi) & -\sin(\frac16\pi) \\
+              \sin(\frac16\pi) & \cos(\frac16\pi)
+    \end{array} \right]. \f]
+
+\include MatrixSquareRoot.cpp
+Output: \verbinclude MatrixSquareRoot.out
+
+\sa class RealSchur, class ComplexSchur, class MatrixSquareRoot,
+    SelfAdjointEigenSolver::operatorSqrt().
+
+*/
+
+#endif  // EIGEN_MATRIX_FUNCTIONS_MODULE_H
diff --git a/contrib/Eigen/NNLS b/contrib/Eigen/NNLS
new file mode 100644
index 0000000..d1c9cfb
--- /dev/null
+++ b/contrib/Eigen/NNLS
@@ -0,0 +1,416 @@
+/* Non-Negagive Least Squares Algorithm for Eigen.
+ *
+ * Copyright (C) 2021 Essex Edwards, <essex.edwards@gmail.com>
+ * Copyright (C) 2013 Hannes Matuschek, hannes.matuschek at uni-potsdam.de
+ *
+ * This Source Code Form is subject to the terms of the Mozilla
+ * Public License v. 2.0. If a copy of the MPL was not distributed
+ * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// SPDX-License-Identifier: MPL-2.0
+
+/** \defgroup nnls Non-Negative Least Squares (NNLS) Module
+ * This module provides a single class @c Eigen::NNLS implementing the NNLS algorithm.
+ * The algorithm is described in "SOLVING LEAST SQUARES PROBLEMS", by Charles L. Lawson and
+ * Richard J. Hanson, Prentice-Hall, 1974 and solves optimization problems of the form
+ *
+ * \f[ \min \left\Vert Ax-b\right\Vert_2^2\quad s.t.\, x\ge 0\,.\f]
+ *
+ * The algorithm solves the constrained least-squares problem above by iteratively improving
+ * an estimate of which constraints are active (elements of \f$x\f$ equal to zero)
+ * and which constraints are inactive (elements of \f$x\f$ greater than zero).
+ * Each iteration, an unconstrained linear least-squares problem solves for the
+ * components of \f$x\f$ in the (estimated) inactive set and the sets are updated.
+ * The unconstrained problem minimizes \f$\left\Vert A^Nx^N-b\right\Vert_2^2\f$,
+ * where \f$A^N\f$ is a matrix formed by selecting all columns of A which are
+ * in the inactive set \f$N\f$.
+ *
+ */
+
+#ifndef EIGEN_NNLS_MODULE_H
+#define EIGEN_NNLS_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/QR"
+
+#include <limits>
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/** \ingroup nnls
+ * \class NNLS
+ * \brief Implementation of the Non-Negative Least Squares (NNLS) algorithm.
+ * \tparam MatrixType The type of the system matrix \f$A\f$.
+ *
+ * This class implements the NNLS algorithm as described in "SOLVING LEAST SQUARES PROBLEMS",
+ * Charles L. Lawson and Richard J. Hanson, Prentice-Hall, 1974. This algorithm solves a least
+ * squares problem iteratively and ensures that the solution is non-negative. I.e.
+ *
+ * \f[ \min \left\Vert Ax-b\right\Vert_2^2\quad s.t.\, x\ge 0 \f]
+ *
+ * The algorithm solves the constrained least-squares problem above by iteratively improving
+ * an estimate of which constraints are active (elements of \f$x\f$ equal to zero)
+ * and which constraints are inactive (elements of \f$x\f$ greater than zero).
+ * Each iteration, an unconstrained linear least-squares problem solves for the
+ * components of \f$x\f$ in the (estimated) inactive set and the sets are updated.
+ * The unconstrained problem minimizes \f$\left\Vert A^Nx^N-b\right\Vert_2^2\f$,
+ * where \f$A^N\f$ is a matrix formed by selecting all columns of A which are
+ * in the inactive set \f$N\f$.
+ *
+ * See <a href="https://en.wikipedia.org/wiki/Non-negative_least_squares">the
+ * wikipedia page on non-negative least squares</a> for more background information.
+ *
+ * \note Please note that it is possible to construct an NNLS problem for which the
+ *       algorithm does not converge. In practice these cases are extremely rare.
+ */
+template <class MatrixType_>
+class NNLS {
+ public:
+  typedef MatrixType_ MatrixType;
+
+  enum {
+    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
+    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
+    Options = MatrixType::Options,
+    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
+    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
+  };
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename MatrixType::Index Index;
+
+  /** Type of a row vector of the system matrix \f$A\f$. */
+  typedef Matrix<Scalar, ColsAtCompileTime, 1> SolutionVectorType;
+  /** Type of a column vector of the system matrix \f$A\f$. */
+  typedef Matrix<Scalar, RowsAtCompileTime, 1> RhsVectorType;
+  typedef Matrix<Index, ColsAtCompileTime, 1> IndicesType;
+
+  /** */
+  NNLS();
+
+  /** \brief Constructs a NNLS solver and initializes it with the given system matrix @c A.
+   * \param A Specifies the system matrix.
+   * \param max_iter Specifies the maximum number of iterations to solve the system.
+   * \param tol Specifies the precision of the optimum.
+   *        This is an absolute tolerance on the gradient of the Lagrangian, \f$A^T(Ax-b)-\lambda\f$
+   *        (with Lagrange multipliers \f$\lambda\f$).
+   */
+  NNLS(const MatrixType &A, Index max_iter = -1, Scalar tol = NumTraits<Scalar>::dummy_precision());
+
+  /** Initializes the solver with the matrix \a A for further solving NNLS problems.
+   *
+   * This function mostly initializes/computes the preconditioner. In the future
+   * we might, for instance, implement column reordering for faster matrix vector products.
+   */
+  template <typename MatrixDerived>
+  NNLS<MatrixType> &compute(const EigenBase<MatrixDerived> &A);
+
+  /** \brief Solves the NNLS problem.
+   *
+   * The dimension of @c b must be equal to the number of rows of @c A, given to the constructor.
+   *
+   * \returns The approximate solution vector \f$ x \f$. Use info() to determine if the solve was a success or not.
+   * \sa info()
+   */
+  const SolutionVectorType &solve(const RhsVectorType &b);
+
+  /** \brief Returns the solution if a problem was solved.
+   * If not, an uninitialized vector may be returned. */
+  const SolutionVectorType &x() const { return x_; }
+
+  /** \returns the tolerance threshold used by the stopping criteria.
+   * \sa setTolerance()
+   */
+  Scalar tolerance() const { return tolerance_; }
+
+  /** Sets the tolerance threshold used by the stopping criteria.
+   *
+   * This is an absolute tolerance on the gradient of the Lagrangian, \f$A^T(Ax-b)-\lambda\f$
+   * (with Lagrange multipliers \f$\lambda\f$).
+   */
+  NNLS<MatrixType> &setTolerance(const Scalar &tolerance) {
+    tolerance_ = tolerance;
+    return *this;
+  }
+
+  /** \returns the max number of iterations.
+   * It is either the value set by setMaxIterations or, by default, twice the number of columns of the matrix.
+   */
+  Index maxIterations() const { return max_iter_ < 0 ? 2 * A_.cols() : max_iter_; }
+
+  /** Sets the max number of iterations.
+   * Default is twice the number of columns of the matrix.
+   * The algorithm requires at least k iterations to produce a solution vector with k non-zero entries.
+   */
+  NNLS<MatrixType> &setMaxIterations(Index maxIters) {
+    max_iter_ = maxIters;
+    return *this;
+  }
+
+  /** \returns the number of iterations (least-squares solves) performed during the last solve */
+  Index iterations() const { return iterations_; }
+
+  /** \returns Success if the iterations converged, and an error values otherwise. */
+  ComputationInfo info() const { return info_; }
+
+ private:
+  /** \internal Adds the given index @c idx to the inactive set N and updates the QR decomposition of \f$A^N\f$. */
+  void moveToInactiveSet_(Index idx);
+
+  /** \internal Removes the given index idx from the inactive set N and updates the QR decomposition of \f$A^N\f$. */
+  void moveToActiveSet_(Index idx);
+
+  /** \internal Solves the least-squares problem \f$\left\Vert y-A^Nx\right\Vert_2^2\f$. */
+  void solveInactiveSet_(const RhsVectorType &b);
+
+ private:
+  typedef Matrix<Scalar, ColsAtCompileTime, ColsAtCompileTime> MatrixAtAType;
+
+  /** \internal Holds the maximum number of iterations for the NNLS algorithm.
+   *  @c -1 means to use the default value. */
+  Index max_iter_;
+  /** \internal Holds the number of iterations. */
+  Index iterations_;
+  /** \internal Holds success/fail of the last solve. */
+  ComputationInfo info_;
+  /** \internal Size of the inactive set. */
+  Index numInactive_;
+  /** \internal Accuracy of the algorithm w.r.t the optimality of the solution (gradient). */
+  Scalar tolerance_;
+  /** \internal The system matrix, a copy of the one given to the constructor. */
+  MatrixType A_;
+  /** \internal Precomputed product \f$A^TA\f$. */
+  MatrixAtAType AtA_;
+  /** \internal Will hold the solution. */
+  SolutionVectorType x_;
+  /** \internal Will hold the current gradient.\f$A^Tb - A^TAx\f$ */
+  SolutionVectorType gradient_;
+  /** \internal Will hold the partial solution. */
+  SolutionVectorType y_;
+  /** \internal Precomputed product \f$A^Tb\f$. */
+  SolutionVectorType Atb_;
+  /** \internal Holds the current permutation partitioning the active and inactive sets.
+   * The first @c numInactive_ elements form the inactive set and the rest the active set. */
+  IndicesType index_sets_;
+  /** \internal QR decomposition to solve the (inactive) sub system (together with @c qrCoeffs_). */
+  MatrixType QR_;
+  /** \internal QR decomposition to solve the (inactive) sub system (together with @c QR_). */
+  SolutionVectorType qrCoeffs_;
+  /** \internal Some workspace for QR decomposition. */
+  SolutionVectorType tempSolutionVector_;
+  RhsVectorType tempRhsVector_;
+};
+
+/* ********************************************************************************************
+ * Implementation
+ * ******************************************************************************************** */
+
+template <typename MatrixType>
+NNLS<MatrixType>::NNLS()
+    : max_iter_(-1),
+      iterations_(0),
+      info_(ComputationInfo::InvalidInput),
+      numInactive_(0),
+      tolerance_(NumTraits<Scalar>::dummy_precision()) {}
+
+template <typename MatrixType>
+NNLS<MatrixType>::NNLS(const MatrixType &A, Index max_iter, Scalar tol) : max_iter_(max_iter), tolerance_(tol) {
+  compute(A);
+}
+
+template <typename MatrixType>
+template <typename MatrixDerived>
+NNLS<MatrixType> &NNLS<MatrixType>::compute(const EigenBase<MatrixDerived> &A) {
+  // Ensure Scalar type is real. The non-negativity constraint doesn't obviously extend to complex numbers.
+  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
+
+  // max_iter_: unchanged
+  iterations_ = 0;
+  info_ = ComputationInfo::Success;
+  numInactive_ = 0;
+  // tolerance: unchanged
+  A_ = A.derived();
+  AtA_.noalias() = A_.transpose() * A_;
+  x_.resize(A_.cols());
+  gradient_.resize(A_.cols());
+  y_.resize(A_.cols());
+  Atb_.resize(A_.cols());
+  index_sets_.resize(A_.cols());
+  QR_.resize(A_.rows(), A_.cols());
+  qrCoeffs_.resize(A_.cols());
+  tempSolutionVector_.resize(A_.cols());
+  tempRhsVector_.resize(A_.rows());
+
+  return *this;
+}
+
+template <typename MatrixType>
+const typename NNLS<MatrixType>::SolutionVectorType &NNLS<MatrixType>::solve(const RhsVectorType &b) {
+  // Initialize solver
+  iterations_ = 0;
+  info_ = ComputationInfo::NumericalIssue;
+  x_.setZero();
+
+  index_sets_ = IndicesType::LinSpaced(A_.cols(), 0, A_.cols() - 1);  // Identity permutation.
+  numInactive_ = 0;
+
+  // Precompute A^T*b
+  Atb_.noalias() = A_.transpose() * b;
+
+  if (A_.rows() == 0) {
+    info_ = ComputationInfo::Success;
+    return x_;
+  }
+
+  const Index maxIterations = this->maxIterations();
+
+  // OUTER LOOP
+  while (true) {
+    // Early exit if all variables are inactive, which breaks 'maxCoeff' below.
+    if (A_.cols() == numInactive_) {
+      info_ = ComputationInfo::Success;
+      return x_;
+    }
+
+    // Find the maximum element of the gradient in the active set.
+    // If it is small or negative, then we have converged.
+    // Else, we move that variable to the inactive set.
+    gradient_.noalias() = Atb_ - AtA_ * x_;
+    if (!gradient_.allFinite()) return x_;
+
+    const Index numActive = A_.cols() - numInactive_;
+    Index argmaxGradient = -1;
+    const Scalar maxGradient = gradient_(index_sets_.tail(numActive)).maxCoeff(&argmaxGradient);
+    argmaxGradient += numInactive_;  // because tail() skipped the first numInactive_ elements
+
+    if (maxGradient < tolerance_) {
+      info_ = ComputationInfo::Success;
+      return x_;
+    }
+
+    if (iterations_ >= maxIterations) {
+      info_ = ComputationInfo::NoConvergence;
+      return x_;
+    }
+
+    // In exact arithmetic, a positive gradient guarantees that the candidate
+    // column is independent of the inactive (passive) set, so a row-sized set
+    // would have satisfied the stopping condition above. If it does not,
+    // numerical dependence has invalidated that invariant. Another rank-1 QR
+    // update would exceed the row capacity, but the current iterate cannot be
+    // reported as optimal either.
+    if (numInactive_ == A_.rows()) {
+      info_ = ComputationInfo::NumericalIssue;
+      return x_;
+    }
+
+    moveToInactiveSet_(argmaxGradient);
+
+    // INNER LOOP
+    while (true) {
+      // Check if max. number of iterations is reached
+      if (iterations_ >= maxIterations) {
+        info_ = ComputationInfo::NoConvergence;
+        return x_;
+      }
+
+      // Solve least-squares problem in inactive set only,
+      // this step is rather trivial as moveToInactiveSet_ & moveToActiveSet_
+      // updates the QR decomposition of inactive columns A^N.
+      // solveInactiveSet_ puts the solution in y_
+      solveInactiveSet_(b);
+      ++iterations_;  // The solve is expensive, so that is what we count as an iteration.
+      if (!y_.allFinite()) return x_;
+
+      // Check feasibility...
+      bool feasible = true;
+      Scalar alpha = NumTraits<Scalar>::highest();
+      Index infeasibleIdx = -1;  // Which variable became infeasible first.
+      for (Index i = 0; i < numInactive_; i++) {
+        Index idx = index_sets_[i];
+        if (y_(idx) < 0) {
+          // t should always be in [0,1].
+          Scalar t = -x_(idx) / (y_(idx) - x_(idx));
+          if (alpha > t) {
+            alpha = t;
+            infeasibleIdx = i;
+            feasible = false;
+          }
+        }
+      }
+      eigen_assert(feasible || 0 <= infeasibleIdx);
+
+      // If solution is feasible, exit to outer loop
+      if (feasible) {
+        x_ = y_;
+        break;
+      }
+
+      // Infeasible solution -> interpolate to feasible one
+      for (Index i = 0; i < numInactive_; i++) {
+        Index idx = index_sets_[i];
+        x_(idx) += alpha * (y_(idx) - x_(idx));
+      }
+
+      // Remove these indices from the inactive set and update QR decomposition
+      moveToActiveSet_(infeasibleIdx);
+    }
+  }
+}
+
+template <typename MatrixType>
+void NNLS<MatrixType>::moveToInactiveSet_(Index idx) {
+  // Update permutation matrix:
+  std::swap(index_sets_(idx), index_sets_(numInactive_));
+  numInactive_++;
+
+  // Perform rank-1 update of the QR decomposition stored in QR_ & qrCoeff_
+  internal::householder_qr_inplace_update(QR_, qrCoeffs_, A_.col(index_sets_(numInactive_ - 1)), numInactive_ - 1,
+                                          tempSolutionVector_.data());
+}
+
+template <typename MatrixType>
+void NNLS<MatrixType>::moveToActiveSet_(Index idx) {
+  // swap index with last inactive one & reduce number of inactive columns
+  std::swap(index_sets_(idx), index_sets_(numInactive_ - 1));
+  numInactive_--;
+  // Update QR decomposition starting from the removed index up to the end [idx, ..., numInactive_]
+  for (Index i = idx; i < numInactive_; i++) {
+    Index col = index_sets_(i);
+    internal::householder_qr_inplace_update(QR_, qrCoeffs_, A_.col(col), i, tempSolutionVector_.data());
+  }
+}
+
+template <typename MatrixType>
+void NNLS<MatrixType>::solveInactiveSet_(const RhsVectorType &b) {
+  eigen_assert(numInactive_ > 0);
+
+  tempRhsVector_ = b;
+
+  // tmpRHS(0:numInactive_-1) := Q'*b
+  // tmpRHS(numInactive_:end) := useless stuff we would rather not compute at all.
+  tempRhsVector_.applyOnTheLeft(
+      householderSequence(QR_.leftCols(numInactive_), qrCoeffs_.head(numInactive_)).transpose());
+
+  // tempSol(0:numInactive_-1) := inv(R) * Q' * b
+  //  = the least-squares solution for the inactive variables.
+  tempSolutionVector_.head(numInactive_) =            //
+      QR_.topLeftCorner(numInactive_, numInactive_)   //
+          .template triangularView<Upper>()           //
+          .solve(tempRhsVector_.head(numInactive_));  //
+
+  // tempSol(numInactive_:end) := 0 = the value for the constrained variables.
+  tempSolutionVector_.tail(y_.size() - numInactive_).setZero();
+
+  // Back permute into original column order of A
+  y_.noalias() = index_sets_.asPermutation() * tempSolutionVector_.head(y_.size());
+}
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_NNLS_MODULE_H
diff --git a/contrib/Eigen/NonLinearOptimization b/contrib/Eigen/NonLinearOptimization
new file mode 100644
index 0000000..1a66a89
--- /dev/null
+++ b/contrib/Eigen/NonLinearOptimization
@@ -0,0 +1,146 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_MODULE_H
+#define EIGEN_NONLINEAROPTIMIZATION_MODULE_H
+
+#include <vector>
+
+#include "../../Eigen/Core"
+#include "../../Eigen/Jacobi"
+#include "../../Eigen/QR"
+#include "NumericalDiff"
+
+/**
+ * \defgroup NonLinearOptimization_Module Non linear optimization module
+ *
+ * \code
+ * #include <contrib/Eigen/NonLinearOptimization>
+ * \endcode
+ *
+ * This module provides implementation of two important algorithms in non linear
+ * optimization. In both cases, we consider a system of non linear functions. Of
+ * course, this should work, and even work very well if those functions are
+ * actually linear. But if this is so, you should probably better use other
+ * methods more fitted to this special case.
+ *
+ * One algorithm allows to find a least-squares solution of such a system
+ * (Levenberg-Marquardt algorithm) and the second one is used to find
+ * a zero for the system (Powell hybrid "dogleg" method).
+ *
+ * This code is a port of minpack (http://en.wikipedia.org/wiki/MINPACK).
+ * Minpack is a very famous, old, robust and well renowned package, written in
+ * fortran. Those implementations have been carefully tuned, tested, and used
+ * for several decades.
+ *
+ * The original fortran code was automatically translated using f2c (http://en.wikipedia.org/wiki/F2c) in C,
+ * then c++, and then cleaned by several different authors.
+ * The last one of those cleanings being our starting point :
+ * http://devernay.free.fr/hacks/cminpack.html
+ *
+ * Finally, we ported this code to Eigen, creating classes and API
+ * coherent with Eigen. When possible, we switched to Eigen
+ * implementation, such as most linear algebra (vectors, matrices, stable norms).
+ *
+ * Doing so, we were very careful to check the tests we setup at the very
+ * beginning, which ensure that the same results are found.
+ *
+ * \section Tests Tests
+ *
+ * The tests are placed in the file contrib/test/NonLinear.cpp.
+ *
+ * There are two kinds of tests : those that come from examples bundled with cminpack.
+ * They guaranty we get the same results as the original algorithms (value for 'x',
+ * for the number of evaluations of the function, and for the number of evaluations
+ * of the Jacobian if ever).
+ *
+ * Other tests were added by myself at the very beginning of the
+ * process and check the results for Levenberg-Marquardt using the reference data
+ * on http://www.itl.nist.gov/div898/strd/nls/nls_main.shtml. Since then i've
+ * carefully checked that the same results were obtained when modifying the
+ * code. Please note that we do not always get the exact same decimals as they do,
+ * but this is ok : they use 128bits float, and we do the tests using the C type 'double',
+ * which is 64 bits on most platforms (x86 and amd64, at least).
+ * I've performed those tests on several other implementations of Levenberg-Marquardt, and
+ * (c)minpack performs VERY well compared to those, both in accuracy and speed.
+ *
+ * The documentation for running the tests is on the wiki
+ * http://eigen.tuxfamily.org/index.php?title=Tests
+ *
+ * \section API API: overview of methods
+ *
+ * Both algorithms needs a functor computing the Jacobian. It can be computed by
+ * hand, using auto-differentiation (see \ref AutoDiff_Module), or using numerical
+ * differences (see \ref NumericalDiff_Module). For instance:
+ *\code
+ * MyFunc func;
+ * NumericalDiff<MyFunc> func_with_num_diff(func);
+ * LevenbergMarquardt<NumericalDiff<MyFunc> > lm(func_with_num_diff);
+ * \endcode
+ * For HybridNonLinearSolver, the method solveNumericalDiff() does the above wrapping for
+ * you.
+ *
+ * The methods LevenbergMarquardt.lmder1()/lmdif1()/lmstr1() and
+ * HybridNonLinearSolver.hybrj1()/hybrd1() are specific methods from the original
+ * minpack package that you probably should NOT use until you are porting a code that
+ * was previously using minpack. They just define a 'simple' API with default values
+ * for some parameters.
+ *
+ * All algorithms are provided using two APIs :
+ *     - one where the user inits the algorithm, and uses '*OneStep()' as much as he wants :
+ * this way the caller have control over the steps
+ *     - one where the user just calls a method (optimize() or solve()) which will
+ * handle the loop: init + loop until a stop condition is met. Those are provided for
+ *  convenience.
+ *
+ * As an example, the method LevenbergMarquardt::minimize() is
+ * implemented as follow:
+ * \code
+ * Status LevenbergMarquardt<FunctorType,Scalar>::minimize(FVectorType  &x, const int mode)
+ * {
+ *     Status status = minimizeInit(x, mode);
+ *     do {
+ *         status = minimizeOneStep(x, mode);
+ *     } while (status==Running);
+ *     return status;
+ * }
+ * \endcode
+ *
+ * \section examples Examples
+ *
+ * The easiest way to understand how to use this module is by looking at the many examples in the file
+ * contrib/test/NonLinearOptimization.cpp.
+ */
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+#include "src/NonLinearOptimization/qrsolv.h"
+#include "src/NonLinearOptimization/r1updt.h"
+#include "src/NonLinearOptimization/r1mpyq.h"
+#include "src/NonLinearOptimization/rwupdt.h"
+#include "src/NonLinearOptimization/fdjac1.h"
+#include "src/NonLinearOptimization/lmpar.h"
+#include "src/NonLinearOptimization/dogleg.h"
+#include "src/NonLinearOptimization/covar.h"
+
+#include "src/NonLinearOptimization/chkder.h"
+
+#endif
+
+#include "src/NonLinearOptimization/HybridNonLinearSolver.h"
+#include "src/NonLinearOptimization/LevenbergMarquardt.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_MODULE_H
diff --git a/contrib/Eigen/NumericalDiff b/contrib/Eigen/NumericalDiff
new file mode 100644
index 0000000..5729082
--- /dev/null
+++ b/contrib/Eigen/NumericalDiff
@@ -0,0 +1,62 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NUMERICALDIFF_MODULE_H
+#define EIGEN_NUMERICALDIFF_MODULE_H
+
+#include "../../Eigen/Core"
+
+namespace Eigen {
+
+/**
+ * \defgroup NumericalDiff_Module Numerical differentiation module
+ *
+ * \code
+ * #include <contrib/Eigen/NumericalDiff>
+ * \endcode
+ *
+ * See http://en.wikipedia.org/wiki/Numerical_differentiation
+ *
+ * Warning : this should NOT be confused with automatic differentiation, which
+ * is a different method and has its own module in Eigen : \ref
+ * AutoDiff_Module.
+ *
+ * Currently only "Forward" and "Central" schemes are implemented. Those
+ * are basic methods, and there exist some more elaborated way of
+ * computing such approximates. They are implemented using both
+ * proprietary and free software, and usually requires linking to an
+ * external library. It is very easy for you to write a functor
+ * using such software, and the purpose is quite orthogonal to what we
+ * want to achieve with Eigen.
+ *
+ * This is why we will not provide wrappers for every great numerical
+ * differentiation software that exist, but should rather stick with those
+ * basic ones, that still are useful for testing.
+ *
+ * Also, the \ref NonLinearOptimization_Module needs this in order to
+ * provide full features compatibility with the original (c)minpack
+ * package.
+ *
+ */
+}
+
+//@{
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/NumericalDiff/NumericalDiff.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+//@}
+
+#endif  // EIGEN_NUMERICALDIFF_MODULE_H
diff --git a/contrib/Eigen/OpenGLSupport b/contrib/Eigen/OpenGLSupport
new file mode 100644
index 0000000..8b7f4b0
--- /dev/null
+++ b/contrib/Eigen/OpenGLSupport
@@ -0,0 +1,355 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_OPENGL_MODULE_H
+#define EIGEN_OPENGL_MODULE_H
+
+#include "../../Eigen/Geometry"
+
+#if defined(__APPLE_CC__)
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/**
+ * \defgroup OpenGLSupport_Module OpenGL Support module
+ *
+ * This module provides wrapper functions for a couple of OpenGL functions
+ * which simplify the way to pass Eigen's object to openGL.
+ * Here is an example:
+ *
+ * \code
+ * // You need to add path_to_eigen/contrib to your include path.
+ * #include <contrib/Eigen/OpenGLSupport>
+ * // ...
+ * Vector3f x, y;
+ * Matrix3f rot;
+ *
+ * glVertex(y + x * rot);
+ *
+ * Quaternion q;
+ * glRotate(q);
+ *
+ * // ...
+ * \endcode
+ *
+ */
+//@{
+
+#define EIGEN_GL_FUNC_DECLARATION(FUNC)                                                                          \
+  namespace internal {                                                                                           \
+  template <typename XprType, typename Scalar = typename XprType::Scalar, int Rows = XprType::RowsAtCompileTime, \
+            int Cols = XprType::ColsAtCompileTime,                                                               \
+            bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags & LinearAccessBit) &&                 \
+                                  bool(XprType::Flags & DirectAccessBit) &&                                      \
+                                  (XprType::IsVectorAtCompileTime || (XprType::Flags & RowMajorBit) == 0)>       \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl);                                                                 \
+                                                                                                                 \
+  template <typename XprType, typename Scalar, int Rows, int Cols>                                               \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, Scalar, Rows, Cols, false> {                            \
+    inline static void run(const XprType& p) {                                                                   \
+      EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<typename plain_matrix_type_column_major<XprType>::type>::run(p);    \
+    }                                                                                                            \
+  };                                                                                                             \
+  }                                                                                                              \
+                                                                                                                 \
+  template <typename Derived>                                                                                    \
+  inline void FUNC(const Eigen::DenseBase<Derived>& p) {                                                         \
+    EIGEN_CAT(EIGEN_CAT(internal::gl_, FUNC), _impl)<Derived>::run(p.derived());                                 \
+  }
+
+#define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC, SCALAR, ROWS, COLS, SUFFIX)           \
+  namespace internal {                                                               \
+  template <typename XprType>                                                        \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, ROWS, COLS, true> { \
+    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }             \
+  };                                                                                 \
+  }
+
+#define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC, SCALAR, SIZE, SUFFIX)              \
+  namespace internal {                                                            \
+  template <typename XprType>                                                     \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, SIZE, 1, true> { \
+    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }          \
+  };                                                                              \
+  template <typename XprType>                                                     \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, 1, SIZE, true> { \
+    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }          \
+  };                                                                              \
+  }
+
+EIGEN_GL_FUNC_DECLARATION(glVertex)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 2, 2iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 2, 2sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 2, 2fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 2, 2dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 3, 3iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 3, 3sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 3, 3fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 3, 3dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 4, 4iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 4, 4sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 4, 4fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 4, 4dv)
+
+EIGEN_GL_FUNC_DECLARATION(glTexCoord)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 2, 2iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 2, 2sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 2, 2fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 2, 2dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 3, 3iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 3, 3sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 3, 3fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 3, 3dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 4, 4iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 4, 4sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 4, 4fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 4, 4dv)
+
+EIGEN_GL_FUNC_DECLARATION(glColor)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 2, 2iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 2, 2sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 2, 2fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 2, 2dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 3, 3iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 3, 3sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 3, 3fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 3, 3dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 4, 4iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 4, 4sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 4, 4fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 4, 4dv)
+
+EIGEN_GL_FUNC_DECLARATION(glNormal)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, int, 3, 3iv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, short, 3, 3sv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, float, 3, 3fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, double, 3, 3dv)
+
+inline void glScale2fv(const float* v) { glScalef(v[0], v[1], 1.f); }
+inline void glScale2dv(const double* v) { glScaled(v[0], v[1], 1.0); }
+inline void glScale3fv(const float* v) { glScalef(v[0], v[1], v[2]); }
+inline void glScale3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
+
+EIGEN_GL_FUNC_DECLARATION(glScale)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, float, 2, 2fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, double, 2, 2dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, float, 3, 3fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, double, 3, 3dv)
+
+template <typename Scalar>
+void glScale(const UniformScaling<Scalar>& s) {
+  glScale(Matrix<Scalar, 3, 1>::Constant(s.factor()));
+}
+
+inline void glTranslate2fv(const float* v) { glTranslatef(v[0], v[1], 0.f); }
+inline void glTranslate2dv(const double* v) { glTranslated(v[0], v[1], 0.0); }
+inline void glTranslate3fv(const float* v) { glTranslatef(v[0], v[1], v[2]); }
+inline void glTranslate3dv(const double* v) { glTranslated(v[0], v[1], v[2]); }
+
+EIGEN_GL_FUNC_DECLARATION(glTranslate)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, float, 2, 2fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, double, 2, 2dv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, float, 3, 3fv)
+EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, double, 3, 3dv)
+
+template <typename Scalar>
+void glTranslate(const Translation<Scalar, 2>& t) {
+  glTranslate(t.vector());
+}
+template <typename Scalar>
+void glTranslate(const Translation<Scalar, 3>& t) {
+  glTranslate(t.vector());
+}
+
+EIGEN_GL_FUNC_DECLARATION(glMultMatrix)
+EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix, float, 4, 4, f)
+EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix, double, 4, 4, d)
+
+template <typename Scalar>
+void glMultMatrix(const Transform<Scalar, 3, Affine>& t) {
+  glMultMatrix(t.matrix());
+}
+template <typename Scalar>
+void glMultMatrix(const Transform<Scalar, 3, Projective>& t) {
+  glMultMatrix(t.matrix());
+}
+template <typename Scalar>
+void glMultMatrix(const Transform<Scalar, 3, AffineCompact>& t) {
+  glMultMatrix(Transform<Scalar, 3, Affine>(t).matrix());
+}
+
+EIGEN_GL_FUNC_DECLARATION(glLoadMatrix)
+EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix, float, 4, 4, f)
+EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix, double, 4, 4, d)
+
+template <typename Scalar>
+void glLoadMatrix(const Transform<Scalar, 3, Affine>& t) {
+  glLoadMatrix(t.matrix());
+}
+template <typename Scalar>
+void glLoadMatrix(const Transform<Scalar, 3, Projective>& t) {
+  glLoadMatrix(t.matrix());
+}
+template <typename Scalar>
+void glLoadMatrix(const Transform<Scalar, 3, AffineCompact>& t) {
+  glLoadMatrix(Transform<Scalar, 3, Affine>(t).matrix());
+}
+
+inline void glRotate(const Rotation2D<float>& rot) { glRotatef(rot.angle() * 180.f / float(EIGEN_PI), 0.f, 0.f, 1.f); }
+inline void glRotate(const Rotation2D<double>& rot) {
+  glRotated(rot.angle() * 180.0 / double(EIGEN_PI), 0.0, 0.0, 1.0);
+}
+
+template <typename Derived>
+void glRotate(const RotationBase<Derived, 3>& rot) {
+  Transform<typename Derived::Scalar, 3, Projective> tr(rot);
+  glMultMatrix(tr.matrix());
+}
+
+#define EIGEN_GL_MAKE_CONST_const const
+#define EIGEN_GL_MAKE_CONST__
+#define EIGEN_GL_EVAL(X) X
+
+#define EIGEN_GL_FUNC1_DECLARATION(FUNC, ARG1, CONST)                                                            \
+  namespace internal {                                                                                           \
+  template <typename XprType, typename Scalar = typename XprType::Scalar, int Rows = XprType::RowsAtCompileTime, \
+            int Cols = XprType::ColsAtCompileTime,                                                               \
+            bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags & LinearAccessBit) &&                 \
+                                  bool(XprType::Flags & DirectAccessBit) &&                                      \
+                                  (XprType::IsVectorAtCompileTime || (XprType::Flags & RowMajorBit) == 0)>       \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl);                                                                 \
+                                                                                                                 \
+  template <typename XprType, typename Scalar, int Rows, int Cols>                                               \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, Scalar, Rows, Cols, false> {                            \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) {                      \
+      EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<typename plain_matrix_type_column_major<XprType>::type>::run(a, p); \
+    }                                                                                                            \
+  };                                                                                                             \
+  }                                                                                                              \
+                                                                                                                 \
+  template <typename Derived>                                                                                    \
+  inline void FUNC(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) {            \
+    EIGEN_CAT(EIGEN_CAT(internal::gl_, FUNC), _impl)<Derived>::run(a, p.derived());                              \
+  }
+
+#define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC, ARG1, CONST, SCALAR, ROWS, COLS, SUFFIX)    \
+  namespace internal {                                                                      \
+  template <typename XprType>                                                               \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, ROWS, COLS, true> {        \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
+      FUNC##SUFFIX(a, p.data());                                                            \
+    }                                                                                       \
+  };                                                                                        \
+  }
+
+#define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC, ARG1, CONST, SCALAR, SIZE, SUFFIX)          \
+  namespace internal {                                                                      \
+  template <typename XprType>                                                               \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, SIZE, 1, true> {           \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
+      FUNC##SUFFIX(a, p.data());                                                            \
+    }                                                                                       \
+  };                                                                                        \
+  template <typename XprType>                                                               \
+  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, 1, SIZE, true> {           \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
+      FUNC##SUFFIX(a, p.data());                                                            \
+    }                                                                                       \
+  };                                                                                        \
+  }
+
+EIGEN_GL_FUNC1_DECLARATION(glGet, GLenum, _)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet, GLenum, _, float, 4, 4, Floatv)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet, GLenum, _, double, 4, 4, Doublev)
+
+// glUniform API
+
+#ifdef GL_VERSION_2_0
+
+inline void glUniform2fv_ei(GLint loc, const float* v) { glUniform2fv(loc, 1, v); }
+inline void glUniform2iv_ei(GLint loc, const int* v) { glUniform2iv(loc, 1, v); }
+
+inline void glUniform3fv_ei(GLint loc, const float* v) { glUniform3fv(loc, 1, v); }
+inline void glUniform3iv_ei(GLint loc, const int* v) { glUniform3iv(loc, 1, v); }
+
+inline void glUniform4fv_ei(GLint loc, const float* v) { glUniform4fv(loc, 1, v); }
+inline void glUniform4iv_ei(GLint loc, const int* v) { glUniform4iv(loc, 1, v); }
+
+inline void glUniformMatrix2fv_ei(GLint loc, const float* v) { glUniformMatrix2fv(loc, 1, false, v); }
+inline void glUniformMatrix3fv_ei(GLint loc, const float* v) { glUniformMatrix3fv(loc, 1, false, v); }
+inline void glUniformMatrix4fv_ei(GLint loc, const float* v) { glUniformMatrix4fv(loc, 1, false, v); }
+
+EIGEN_GL_FUNC1_DECLARATION(glUniform, GLint, const)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 2, 2fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 2, 2iv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 3, 3fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 3, 3iv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 4, 4fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 4, 4iv_ei)
+
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 2, Matrix2fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 3, Matrix3fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 4, Matrix4fv_ei)
+
+#endif
+
+#ifdef GL_VERSION_2_1
+
+inline void glUniformMatrix2x3fv_ei(GLint loc, const float* v) { glUniformMatrix2x3fv(loc, 1, false, v); }
+inline void glUniformMatrix3x2fv_ei(GLint loc, const float* v) { glUniformMatrix3x2fv(loc, 1, false, v); }
+inline void glUniformMatrix2x4fv_ei(GLint loc, const float* v) { glUniformMatrix2x4fv(loc, 1, false, v); }
+inline void glUniformMatrix4x2fv_ei(GLint loc, const float* v) { glUniformMatrix4x2fv(loc, 1, false, v); }
+inline void glUniformMatrix3x4fv_ei(GLint loc, const float* v) { glUniformMatrix3x4fv(loc, 1, false, v); }
+inline void glUniformMatrix4x3fv_ei(GLint loc, const float* v) { glUniformMatrix4x3fv(loc, 1, false, v); }
+
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 3, Matrix2x3fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 2, Matrix3x2fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 4, Matrix2x4fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 2, Matrix4x2fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 4, Matrix3x4fv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 3, Matrix4x3fv_ei)
+
+#endif
+
+#ifdef GL_VERSION_3_0
+
+inline void glUniform2uiv_ei(GLint loc, const unsigned int* v) { glUniform2uiv(loc, 1, v); }
+inline void glUniform3uiv_ei(GLint loc, const unsigned int* v) { glUniform3uiv(loc, 1, v); }
+inline void glUniform4uiv_ei(GLint loc, const unsigned int* v) { glUniform4uiv(loc, 1, v); }
+
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 2, 2uiv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 3, 3uiv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 4, 4uiv_ei)
+
+#endif
+
+#ifdef GL_ARB_gpu_shader_fp64
+inline void glUniform2dv_ei(GLint loc, const double* v) { glUniform2dv(loc, 1, v); }
+inline void glUniform3dv_ei(GLint loc, const double* v) { glUniform3dv(loc, 1, v); }
+inline void glUniform4dv_ei(GLint loc, const double* v) { glUniform4dv(loc, 1, v); }
+
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 2, 2dv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 3, 3dv_ei)
+EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 4, 4dv_ei)
+#endif
+
+//@}
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_OPENGL_MODULE_H
diff --git a/contrib/Eigen/Polynomials b/contrib/Eigen/Polynomials
new file mode 100644
index 0000000..22398e7
--- /dev/null
+++ b/contrib/Eigen/Polynomials
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_POLYNOMIALS_MODULE_H
+#define EIGEN_POLYNOMIALS_MODULE_H
+
+#include "../../Eigen/Core"
+
+#include "../../Eigen/Eigenvalues"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
+#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS >= 2)
+#ifndef EIGEN_HIDE_HEAVY_CODE
+#define EIGEN_HIDE_HEAVY_CODE
+#endif
+#elif defined EIGEN_HIDE_HEAVY_CODE
+#undef EIGEN_HIDE_HEAVY_CODE
+#endif
+
+/**
+ * \defgroup Polynomials_Module Polynomials module
+ * \brief This module provides a polynomial solver based on companion-matrix eigenvalues refined by Ehrlich-Aberth
+ * iterations.
+ *
+ * To use this module, add
+ * \code
+ * #include <contrib/Eigen/Polynomials>
+ * \endcode
+ * at the start of your source file.
+ */
+
+// IWYU pragma: begin_exports
+#include "src/Polynomials/PolynomialUtils.h"
+#include "src/Polynomials/Companion.h"
+#include "src/Polynomials/PolynomialSolver.h"
+// IWYU pragma: end_exports
+
+/**
+        \page polynomials Polynomials defines functions for dealing with polynomials
+        and a polynomial solver.
+        \ingroup Polynomials_Module
+
+        The remainder of the page documents first the functions for evaluating, computing
+        polynomials, computing estimates about polynomials and next the polynomial
+        solver.
+
+        \section polynomialUtils convenient functions to deal with polynomials
+        \subsection roots_to_monicPolynomial
+        The function
+        \code
+        void roots_to_monicPolynomial( const RootVector& rv, Polynomial& poly )
+        \endcode
+        computes the coefficients \f$ a_i \f$ of
+
+        \f$ p(x) = a_0 + a_{1}x + ... + a_{n-1}x^{n-1} + x^n \f$
+
+        where \f$ p \f$ is known through its roots i.e. \f$ p(x) = (x-r_1)(x-r_2)...(x-r_n) \f$.
+
+        \subsection poly_eval
+        The function
+        \code
+        T poly_eval( const Polynomials& poly, const T& x )
+        \endcode
+        evaluates a polynomial at a given point using stabilized H&ouml;rner method.
+
+        The following code: first computes the coefficients in the monomial basis of the monic polynomial that has the
+  provided roots; then, it evaluates the computed polynomial, using a stabilized H&ouml;rner method.
+
+        \include PolynomialUtils1.cpp
+  Output: \verbinclude PolynomialUtils1.out
+
+        \subsection Cauchy bounds
+        The function
+        \code
+        Real cauchy_max_bound( const Polynomial& poly )
+        \endcode
+        provides a maximum bound (the Cauchy one: \f$C(p)\f$) for the absolute value of a root of the given polynomial
+  i.e. \f$ \forall r_i \f$ root of \f$ p(x) = \sum_{k=0}^d a_k x^k \f$, \f$ |r_i| \le C(p) = \sum_{k=0}^{d} \left |
+  \frac{a_k}{a_d} \right | \f$ The leading coefficient \f$ p \f$: should be non zero \f$a_d \neq 0\f$.
+
+
+        The function
+        \code
+        Real cauchy_min_bound( const Polynomial& poly )
+        \endcode
+        provides a minimum bound (the Cauchy one: \f$c(p)\f$) for the absolute value of a non zero root of the given
+  polynomial i.e. \f$ \forall r_i \neq 0 \f$ root of \f$ p(x) = \sum_{k=0}^d a_k x^k \f$, \f$ |r_i| \ge c(p) = \left(
+  \sum_{k=0}^{d} \left | \frac{a_k}{a_0} \right | \right)^{-1} \f$
+
+
+
+
+        \section QR polynomial solver class
+        Computes the complex roots of a polynomial in two steps. The eigenvalues of the associated companion matrix,
+  computed with the QR algorithm, give a first approximation of the roots.
+
+        The roots of \f$ p(x) = a_0 + a_1 x + a_2 x^2 + a_{3} x^3 + x^4 \f$ are the eigenvalues of
+        \f$
+        \left [
+        \begin{array}{cccc}
+        0 & 0 &  0 & a_0 \\
+        1 & 0 &  0 & a_1 \\
+        0 & 1 &  0 & a_2 \\
+        0 & 0 &  1 & a_3
+        \end{array} \right ]
+        \f$
+
+        The QR algorithm is backward stable for the companion matrix, but a perturbation of that matrix is not a
+  perturbation of the coefficients of \f$ p \f$, so the eigenvalues can be much less accurate than the conditioning of
+  the roots allows, frequently so with 32bit (float) floating types. Each approximation is therefore refined by
+  simultaneous Ehrlich-Aberth iterations on \f$ p \f$ itself, targeting a residual within the rounding error of
+  evaluation. The number of sweeps is limited; an unfinished iterate whose residual increased falls back to its
+  initial eigenvalue estimate. A root of multiplicity \f$ m \f$ can only be located to about \f$ \epsilon^{1/m} \f$.
+
+        \include PolynomialSolver1.cpp
+
+        In the above example:
+
+        -# a simple use of the polynomial solver is shown;
+        -# a float polynomial with almost conjugate roots of almost the same modulus is solved, and the residuals of
+  its roots are compared with those of the same polynomial solved with doubles.
+
+  Output: \verbinclude PolynomialSolver1.out
+*/
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_POLYNOMIALS_MODULE_H
diff --git a/contrib/Eigen/SparseExtra b/contrib/Eigen/SparseExtra
new file mode 100644
index 0000000..4f9824e
--- /dev/null
+++ b/contrib/Eigen/SparseExtra
@@ -0,0 +1,61 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPARSE_EXTRA_MODULE_H
+#define EIGEN_SPARSE_EXTRA_MODULE_H
+
+#include "../../Eigen/Sparse"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+
+#ifdef EIGEN_GOOGLEHASH_SUPPORT
+#include <google/dense_hash_map>
+#include <google/sparse_hash_map>
+#endif
+
+/**
+ * \defgroup SparseExtra_Module SparseExtra module
+ *
+ * This module contains some experimental features extending the sparse module:
+ * - A RandomSetter which is a wrapper object allowing to set/update a sparse matrix with random access.
+ * - A SparseInverse which calculates a sparse subset of the inverse of a sparse matrix corresponding to nonzeros of the
+ * input
+ * - MatrixMarket format(https://math.nist.gov/MatrixMarket/formats.html) readers and writers for sparse and dense
+ * matrices.
+ *
+ * \code
+ * #include <contrib/Eigen/SparseExtra>
+ * \endcode
+ */
+
+// IWYU pragma: begin_exports
+#include "src/SparseExtra/RandomSetter.h"
+#include "src/SparseExtra/SparseInverse.h"
+
+#include "src/SparseExtra/MarketIO.h"
+
+#if !defined(_WIN32)
+#include <dirent.h>
+#include "src/SparseExtra/MatrixMarketIterator.h"
+#endif
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_SPARSE_EXTRA_MODULE_H
diff --git a/contrib/Eigen/SpecialFunctions b/contrib/Eigen/SpecialFunctions
new file mode 100644
index 0000000..f648cfc
--- /dev/null
+++ b/contrib/Eigen/SpecialFunctions
@@ -0,0 +1,114 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_MODULE_H
+#define EIGEN_SPECIALFUNCTIONS_MODULE_H
+
+#include <cmath>
+
+#include "../../Eigen/Core"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+namespace Eigen {
+
+/**
+ * \defgroup SpecialFunctions_Module Special math functions module
+ *
+ * This module features additional coefficient-wise math functions available
+ * within the numext:: namespace for the scalar version, and as method and/or free
+ * functions of Array. Those include:
+ *
+ * - erf
+ * - erfc
+ * - lgamma
+ * - igamma
+ * - igamma_der_a
+ * - gamma_sample_der_alpha
+ * - igammac
+ * - digamma
+ * - ndtri
+ * - polygamma
+ * - zeta
+ * - betainc
+ *
+ * Bessel Functions
+ * - bessel_i0
+ * - bessel_i0e
+ * - bessel_i1
+ * - bessel_i1e
+ * - bessel_j0
+ * - bessel_j1
+ * - bessel_k0
+ * - bessel_k0e
+ * - bessel_k1
+ * - bessel_k1e
+ * - bessel_y0
+ * - bessel_y1
+ *
+ * The implementations are tuned for \c float and \c double, so they do not carry
+ * over to an arbitrary scalar. \c erf and \c erfc accept any other scalar type
+ * that declares its own \c erf / \c erfc in the namespace of that type, where
+ * argument-dependent lookup finds it; a scalar type that declares neither is
+ * rejected at compile time.
+ *
+ * \code
+ * #include <contrib/Eigen/SpecialFunctions>
+ * \endcode
+ */
+//@{
+
+}  // namespace Eigen
+
+// IWYU pragma: begin_exports
+#include "src/SpecialFunctions/BesselFunctionsImpl.h"
+#include "src/SpecialFunctions/BesselFunctionsBFloat16.h"
+#include "src/SpecialFunctions/BesselFunctionsHalf.h"
+#include "src/SpecialFunctions/BesselFunctionsPacketMath.h"
+#include "src/SpecialFunctions/BesselFunctionsFunctors.h"
+#include "src/SpecialFunctions/BesselFunctionsArrayAPI.h"
+#include "src/SpecialFunctions/SpecialFunctionsImpl.h"
+#if defined(EIGEN_HIPCC)
+#include "src/SpecialFunctions/HipVectorCompatibility.h"
+#endif
+#include "src/SpecialFunctions/SpecialFunctionsBFloat16.h"
+#include "src/SpecialFunctions/SpecialFunctionsHalf.h"
+#include "src/SpecialFunctions/SpecialFunctionsPacketMath.h"
+#include "src/SpecialFunctions/SpecialFunctionsFunctors.h"
+#include "src/SpecialFunctions/SpecialFunctionsArrayAPI.h"
+
+#ifndef EIGEN_VECTORIZE_GENERIC
+// TODO(rmlarsen): Make these work with generic vectorization if possible.
+#if defined EIGEN_VECTORIZE_AVX512
+#include "src/SpecialFunctions/arch/AVX/BesselFunctions.h"
+#include "src/SpecialFunctions/arch/AVX/SpecialFunctions.h"
+#include "src/SpecialFunctions/arch/AVX512/BesselFunctions.h"
+#include "src/SpecialFunctions/arch/AVX512/SpecialFunctions.h"
+#elif defined EIGEN_VECTORIZE_AVX
+#include "src/SpecialFunctions/arch/AVX/BesselFunctions.h"
+#include "src/SpecialFunctions/arch/AVX/SpecialFunctions.h"
+#elif defined EIGEN_VECTORIZE_NEON || defined EIGEN_VECTORIZE_SME
+#include "src/SpecialFunctions/arch/NEON/BesselFunctions.h"
+#include "src/SpecialFunctions/arch/NEON/SpecialFunctions.h"
+#endif
+
+#if defined EIGEN_VECTORIZE_GPU
+#include "src/SpecialFunctions/arch/GPU/SpecialFunctions.h"
+#endif
+#endif
+// IWYU pragma: end_exports
+
+namespace Eigen {
+//@}
+}
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_SPECIALFUNCTIONS_MODULE_H
diff --git a/contrib/Eigen/Splines b/contrib/Eigen/Splines
new file mode 100644
index 0000000..c87e805
--- /dev/null
+++ b/contrib/Eigen/Splines
@@ -0,0 +1,39 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPLINES_MODULE_H
+#define EIGEN_SPLINES_MODULE_H
+
+#include "../../Eigen/Core"
+
+namespace Eigen {
+/**
+ * \defgroup Splines_Module Spline and spline fitting module
+ *
+ * This module provides a simple multi-dimensional spline class while
+ * offering most basic functionality to fit a spline to point sets.
+ *
+ * \code
+ * #include <contrib/Eigen/Splines>
+ * \endcode
+ */
+}
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/Splines/SplineFwd.h"
+#include "src/Splines/Spline.h"
+#include "src/Splines/SplineFitting.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_SPLINES_MODULE_H
diff --git a/contrib/Eigen/StructuredMatrices b/contrib/Eigen/StructuredMatrices
new file mode 100644
index 0000000..5ce3a49
--- /dev/null
+++ b/contrib/Eigen/StructuredMatrices
@@ -0,0 +1,108 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_STRUCTURED_MATRICES_MODULE_H
+#define EIGEN_STRUCTURED_MATRICES_MODULE_H
+
+#include "../../Eigen/Core"
+#include "../../Eigen/Eigenvalues"
+#include "../../Eigen/LU"
+#include "../../Eigen/SVD"
+#include "../../Eigen/SparseLU"
+#include "../../Eigen/IterativeLinearSolvers"
+#include "FFT"
+
+namespace Eigen {
+
+/**
+ * \defgroup StructuredMatrices_Module StructuredMatrices module
+ *
+ * This module provides lightweight operator types for displacement-structured
+ * matrices together with fast matrix-vector products and direct solvers:
+ *   - \c Circulant : a circulant matrix, diagonalized by the DFT;
+ *   - \c Toeplitz  : a (possibly rectangular) Toeplitz matrix, multiplied in
+ *     O(n log n) via circulant embedding;
+ *   - \c Hankel    : a (possibly rectangular) Hankel matrix -- a column-reversed
+ *     Toeplitz matrix -- with the same O(n log n) products, and square solves
+ *     through the Toeplitz equivalent;
+ *   - \c KroneckerOperator : the Kronecker product of two dense, diagonal or
+ *     sparse matrices as an implicit operator; products, solves, least squares,
+ *     eigendecomposition, SVD, inverse and determinant all factor through the
+ *     operands, diagonal (in particular identity) factors are stored and
+ *     applied in diagonal form, sparse factors through sparse-dense products
+ *     and \c SparseLU, and the product materializes into a dense or a sparse
+ *     matrix on assignment;
+ *   - \c DiagonalPlusLowRank : a diagonal matrix plus a rank-k correction, with
+ *     O(nk) products and O(nk^2) Woodbury solves, closed under inversion;
+ *   - \c Vandermonde : a Vandermonde matrix stored as its nodes, with Horner
+ *     products and O(n^2) Björck-Pereyra primal/dual solves
+ *     (\c BjorckPereyra);
+ *   - \c Cauchy    : a Cauchy matrix stored as its node vectors, solved in
+ *     O(n^2) with genuine partial pivoting through the displacement structure
+ *     (\c CauchyLU, Gohberg-Kailath-Olshevsky);
+ *   - \c DPR1EigenSolver : the direct O(n^2) secular-equation eigensolver for
+ *     real symmetric diagonal-plus-rank-one matrices D + rho*z*z^T, with
+ *     LAPACK-style deflation and Gu-Eisenstat orthogonal eigenvectors;
+ *   - \c Bccb      : a block circulant matrix with circulant blocks (the matrix
+ *     of a 2-D circular convolution), diagonalized by the 2-D DFT, with
+ *     closed-form solves, eigendecomposition and SVD.
+ *
+ * The operator types derive from \c EigenBase and store only compact generators
+ * or factors. The FFT-backed operators (\c Circulant, \c Toeplitz, \c Hankel and
+ * \c Bccb) also keep a precomputed DFT symbol that every product reuses.
+ * Because they expose \c operator* returning an Eigen product expression, they
+ * also plug directly into the matrix-free iterative solvers
+ * (\c ConjugateGradient, \c GMRES, \c MINRES, ...) without forming the dense
+ * matrix; and since they hook into the evaluator system, they can be assigned
+ * to a dense matrix when an explicit representation is needed. Like every
+ * matrix-free operator, they carry no coefficient storage the default
+ * preconditioners could read, so the iterative solvers must be instantiated
+ * with \c IdentityPreconditioner.
+ *
+ * All operator types are closed under transposition (\c transpose(),
+ * \c conjugate(), \c adjoint() return operators of the same kind, the FFT-based
+ * ones reusing the cached symbol), which in particular feeds the least-squares
+ * solvers \c LSMR and \c LeastSquaresConjugateGradient (again with
+ * \c IdentityPreconditioner).
+ * The \c Circulant, \c Toeplitz and \c Hankel operators are closed under
+ * transposition (\c transpose(),
+ * \c conjugate(), \c adjoint() return operators of the same kind, reusing the
+ * cached symbol), which in particular feeds the least-squares solvers \c LSMR
+ * and \c LeastSquaresConjugateGradient (again with \c IdentityPreconditioner).
+ * \c Circulant and \c Bccb additionally expose their closed-form
+ * eigendecomposition and SVD in the Fourier basis, a pseudo-inverse
+ * (minimum-norm least-squares) solve, \c rank(), \c inverse() and
+ * \c determinant().
+ *
+ * \code
+ * #include <contrib/Eigen/StructuredMatrices>
+ * \endcode
+ */
+
+}  // namespace Eigen
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "src/StructuredMatrices/StructuredMatrixUtils.h"
+#include "src/StructuredMatrices/Circulant.h"
+#include "src/StructuredMatrices/Toeplitz.h"
+#include "src/StructuredMatrices/LookAheadLevinson.h"
+#include "src/StructuredMatrices/Hankel.h"
+#include "src/StructuredMatrices/KroneckerOperator.h"
+#include "src/StructuredMatrices/DiagonalPlusLowRank.h"
+#include "src/StructuredMatrices/Vandermonde.h"
+#include "src/StructuredMatrices/Cauchy.h"
+#include "src/StructuredMatrices/DPR1EigenSolver.h"
+#include "src/StructuredMatrices/Bccb.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_STRUCTURED_MATRICES_MODULE_H
diff --git a/contrib/Eigen/Tensor b/contrib/Eigen/Tensor
new file mode 100644
index 0000000..778261c
--- /dev/null
+++ b/contrib/Eigen/Tensor
@@ -0,0 +1,156 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// A later inclusion can complete a device type after its backend macro is
+// enabled. Backend evaluation still requires the macro before including Eigen.
+#if !defined(EIGEN_TENSOR_MODULE_H) || (defined(EIGEN_USE_THREADS) && !defined(EIGEN_TENSOR_MODULE_THREADS_LOADED)) || \
+    (defined(EIGEN_USE_GPU) && !defined(EIGEN_TENSOR_MODULE_GPU_LOADED)) ||                                            \
+    (defined(EIGEN_USE_SYCL) && !defined(EIGEN_TENSOR_MODULE_SYCL_LOADED))
+#define EIGEN_TENSOR_MODULE_H
+
+// Record caller-provided backend macros before any included header can change
+// them, so later inclusions detect only backends newly enabled by the caller.
+#ifdef EIGEN_USE_THREADS
+#define EIGEN_TENSOR_MODULE_THREADS_LOADED
+#endif
+#ifdef EIGEN_USE_GPU
+#define EIGEN_TENSOR_MODULE_GPU_LOADED
+#endif
+#ifdef EIGEN_USE_SYCL
+#define EIGEN_TENSOR_MODULE_SYCL_LOADED
+#endif
+
+#include "../../Eigen/Core"
+
+#include "SpecialFunctions"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+// IWYU pragma: begin_exports
+#include "../../Eigen/src/Core/util/Meta.h"
+#include "../../Eigen/src/Core/util/MaxSizeVector.h"
+// IWYU pragma: end_exports
+
+/** \defgroup Tensor_Module Tensor Module
+ *
+ * This module provides a Tensor class for storing arbitrarily indexed
+ * objects.
+ *
+ * \code
+ * #include <contrib/Eigen/Tensor>
+ * \endcode
+ *
+ * Much of the documentation can be found \ref eigen_tensors "here".
+ */
+
+#include <atomic>
+#include <chrono>
+#include <cmath>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
+#include <numeric>
+#include <random>
+#include <thread>
+
+#if defined(EIGEN_USE_THREADS) || defined(EIGEN_USE_SYCL)
+#include "../../Eigen/ThreadPool"
+#endif
+
+#ifdef EIGEN_USE_GPU
+#include <iostream>
+#if defined(EIGEN_USE_HIP)
+#include <hip/hip_runtime.h>
+#else
+#include <cuda_runtime.h>
+#endif
+#endif
+
+// IWYU pragma: begin_exports
+#include "src/Tensor/TensorMacros.h"
+#include "src/Tensor/TensorForwardDeclarations.h"
+#include "src/Tensor/TensorMeta.h"
+#include "src/Tensor/TensorFunctors.h"
+#include "src/Tensor/TensorCostModel.h"
+#include "src/Tensor/TensorDeviceDefault.h"
+#include "src/Tensor/TensorDeviceThreadPool.h"
+#include "src/Tensor/TensorDeviceGpu.h"
+#include "src/Tensor/TensorDeviceSycl.h"
+#include "src/Tensor/TensorIndexList.h"
+#include "src/Tensor/TensorDimensionList.h"
+#include "src/Tensor/TensorDimensions.h"
+#include "src/Tensor/TensorInitializer.h"
+#include "src/Tensor/TensorTraits.h"
+#include "src/Tensor/TensorRandom.h"
+#include "src/Tensor/TensorUInt128.h"
+#include "src/Tensor/TensorIntDiv.h"
+#include "src/Tensor/TensorGlobalFunctions.h"
+
+#include "src/Tensor/TensorIO.h"
+
+#include "src/Tensor/TensorBase.h"
+#include "src/Tensor/TensorBlock.h"
+
+#include "src/Tensor/TensorEvaluator.h"
+#include "src/Tensor/TensorExpr.h"
+#include "src/Tensor/TensorReduction.h"
+#include "src/Tensor/TensorReductionGpu.h"
+#include "src/Tensor/TensorArgMax.h"
+#include "src/Tensor/TensorConcatenation.h"
+#include "src/Tensor/TensorContractionMapper.h"
+#include "src/Tensor/TensorContractionBlocking.h"
+#include "src/Tensor/TensorContraction.h"
+#include "src/Tensor/TensorContractionThreadPool.h"
+#include "src/Tensor/TensorContractionGpu.h"
+#include "src/Tensor/TensorConversion.h"
+#include "src/Tensor/TensorConvolution.h"
+#include "src/Tensor/TensorFFT.h"
+#include "src/Tensor/TensorPatch.h"
+#include "src/Tensor/TensorImagePatch.h"
+#include "src/Tensor/TensorVolumePatch.h"
+#include "src/Tensor/TensorBroadcasting.h"
+#include "src/Tensor/TensorChipping.h"
+#include "src/Tensor/TensorInflation.h"
+#include "src/Tensor/TensorLayoutSwap.h"
+#include "src/Tensor/TensorMorphing.h"
+#include "src/Tensor/TensorPadding.h"
+#include "src/Tensor/TensorReverse.h"
+#include "src/Tensor/TensorRoll.h"
+#include "src/Tensor/TensorShuffling.h"
+#include "src/Tensor/TensorStriding.h"
+#include "src/Tensor/TensorCustomOp.h"
+#include "src/Tensor/TensorEvalTo.h"
+#include "src/Tensor/TensorForcedEval.h"
+#include "src/Tensor/TensorGenerator.h"
+#include "src/Tensor/TensorAssign.h"
+#include "src/Tensor/TensorScan.h"
+#include "src/Tensor/TensorTrace.h"
+
+#ifdef EIGEN_USE_SYCL
+#include "src/Tensor/TensorReductionSycl.h"
+#include "src/Tensor/TensorConvolutionSycl.h"
+#include "src/Tensor/TensorContractionSycl.h"
+#include "src/Tensor/TensorScanSycl.h"
+#endif
+
+#include "src/Tensor/TensorExecutor.h"
+#include "src/Tensor/TensorDevice.h"
+
+#include "src/Tensor/TensorStorage.h"
+#include "src/Tensor/Tensor.h"
+#include "src/Tensor/TensorFixedSize.h"
+#include "src/Tensor/TensorMap.h"
+#include "src/Tensor/TensorRef.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // Tensor module or newly enabled backend
diff --git a/contrib/Eigen/TensorSymmetry b/contrib/Eigen/TensorSymmetry
new file mode 100644
index 0000000..1b89d6b
--- /dev/null
+++ b/contrib/Eigen/TensorSymmetry
@@ -0,0 +1,39 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSORSYMMETRY_MODULE_H
+#define EIGEN_TENSORSYMMETRY_MODULE_H
+
+#include "Tensor"
+
+#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup TensorSymmetry_Module Tensor Symmetry Module
+ *
+ * This module provides a classes that allow for the definition of
+ * symmetries w.r.t. tensor indices.
+ *
+ * Including this module will implicitly include the Tensor module.
+ *
+ * \code
+ * #include <contrib/Eigen/TensorSymmetry>
+ * \endcode
+ */
+
+// IWYU pragma: begin_exports
+#include "src/TensorSymmetry/util/TemplateGroupTheory.h"
+#include "src/TensorSymmetry/Symmetry.h"
+#include "src/TensorSymmetry/StaticSymmetry.h"
+#include "src/TensorSymmetry/DynamicSymmetry.h"
+// IWYU pragma: end_exports
+
+#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
+
+#endif  // EIGEN_TENSORSYMMETRY_MODULE_H
diff --git a/contrib/Eigen/src/ArpackSupport/ArpackSelfAdjointEigenSolver.h b/contrib/Eigen/src/ArpackSupport/ArpackSelfAdjointEigenSolver.h
new file mode 100644
index 0000000..75ee167
--- /dev/null
+++ b/contrib/Eigen/src/ArpackSupport/ArpackSelfAdjointEigenSolver.h
@@ -0,0 +1,700 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 David Harmon <dharmon@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ARPACKSELFADJOINTEIGENSOLVER_H
+#define EIGEN_ARPACKSELFADJOINTEIGENSOLVER_H
+
+#include "../../../../Eigen/Dense"
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Scalar, typename RealScalar>
+struct arpack_wrapper;
+template <typename MatrixSolver, typename MatrixType, typename Scalar, bool BisSPD>
+struct OP;
+}  // namespace internal
+
+template <typename MatrixType, typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>
+class ArpackGeneralizedSelfAdjointEigenSolver {
+ public:
+  /** \brief Scalar type for matrices of type \p MatrixType. */
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::Index Index;
+
+  /** \brief Real scalar type for \p MatrixType.
+   *
+   * This is just \c Scalar if #Scalar is real (e.g., \c float or
+   * \c double), and the type of the real part of \c Scalar if #Scalar is
+   * complex.
+   */
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  /** \brief Type for vector of eigenvalues as returned by eigenvalues().
+   *
+   * This is a column vector with entries of type #RealScalar.
+   * The length of the vector is the size of \p nbrEigenvalues.
+   */
+  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType;
+
+  /** \brief Default constructor.
+   *
+   * The default constructor is for cases in which the user intends to
+   * perform decompositions via compute().
+   *
+   */
+  ArpackGeneralizedSelfAdjointEigenSolver()
+      : m_eivec(),
+        m_eivalues(),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_nbrConverged(0),
+        m_nbrIterations(0) {}
+
+  /** \brief Constructor; computes generalized eigenvalues of given matrix with respect to another matrix.
+   *
+   * \param[in] A Self-adjoint matrix whose eigenvalues / eigenvectors will
+   *    computed. By default, the upper triangular part is used, but can be changed
+   *    through the template parameter.
+   * \param[in] B Self-adjoint matrix for the generalized eigenvalue problem.
+   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
+   *    Must be less than the size of the input matrix, or an error is returned.
+   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
+   *    respective meanings to find the largest magnitude, smallest magnitude,
+   *    largest algebraic, or smallest algebraic eigenvalues. Passing a floating
+   *    point value in string form, to find the eigenvalues closest to that value,
+   *    is not supported yet and triggers an assertion.
+   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
+   *    means machine precision.
+   *
+   * This constructor calls compute(const MatrixType&, const MatrixType&, Index, string, int, RealScalar)
+   * to compute the eigenvalues of the matrix \p A with respect to \p B. The eigenvectors are computed if
+   * \p options equals #ComputeEigenvectors.
+   *
+   */
+  ArpackGeneralizedSelfAdjointEigenSolver(const MatrixType &A, const MatrixType &B, Index nbrEigenvalues,
+                                          std::string eigs_sigma = "LM", int options = ComputeEigenvectors,
+                                          RealScalar tol = 0.0)
+      : m_eivec(),
+        m_eivalues(),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_nbrConverged(0),
+        m_nbrIterations(0) {
+    compute(A, B, nbrEigenvalues, eigs_sigma, options, tol);
+  }
+
+  /** \brief Constructor; computes eigenvalues of given matrix.
+   *
+   * \param[in] A Self-adjoint matrix whose eigenvalues / eigenvectors will
+   *    computed. By default, the upper triangular part is used, but can be changed
+   *    through the template parameter.
+   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
+   *    Must be less than the size of the input matrix, or an error is returned.
+   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
+   *    respective meanings to find the largest magnitude, smallest magnitude,
+   *    largest algebraic, or smallest algebraic eigenvalues. Passing a floating
+   *    point value in string form, to find the eigenvalues closest to that value,
+   *    is not supported yet and triggers an assertion.
+   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
+   *    means machine precision.
+   *
+   * This constructor calls compute(const MatrixType&, Index, string, int, RealScalar)
+   * to compute the eigenvalues of the matrix \p A. The eigenvectors are computed if
+   * \p options equals #ComputeEigenvectors.
+   *
+   */
+
+  ArpackGeneralizedSelfAdjointEigenSolver(const MatrixType &A, Index nbrEigenvalues, std::string eigs_sigma = "LM",
+                                          int options = ComputeEigenvectors, RealScalar tol = 0.0)
+      : m_eivec(),
+        m_eivalues(),
+        m_isInitialized(false),
+        m_eigenvectorsOk(false),
+        m_nbrConverged(0),
+        m_nbrIterations(0) {
+    compute(A, nbrEigenvalues, eigs_sigma, options, tol);
+  }
+
+  /** \brief Computes generalized eigenvalues / eigenvectors of given matrix using the external ARPACK library.
+   *
+   * \param[in]  A  Selfadjoint matrix whose eigendecomposition is to be computed.
+   * \param[in]  B  Selfadjoint matrix for generalized eigenvalues.
+   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
+   *    Must be less than the size of the input matrix, or an error is returned.
+   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
+   *    respective meanings to find the largest magnitude, smallest magnitude,
+   *    largest algebraic, or smallest algebraic eigenvalues. Passing a floating
+   *    point value in string form, to find the eigenvalues closest to that value,
+   *    is not supported yet and triggers an assertion.
+   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
+   *    means machine precision.
+   *
+   * \returns    Reference to \c *this
+   *
+   * This function computes the generalized eigenvalues of \p A with respect to \p B using ARPACK.  The eigenvalues()
+   * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
+   * then the eigenvectors are also computed and can be retrieved by
+   * calling eigenvectors().
+   *
+   */
+  ArpackGeneralizedSelfAdjointEigenSolver &compute(const MatrixType &A, const MatrixType &B, Index nbrEigenvalues,
+                                                   std::string eigs_sigma = "LM", int options = ComputeEigenvectors,
+                                                   RealScalar tol = 0.0);
+
+  /** \brief Computes eigenvalues / eigenvectors of given matrix using the external ARPACK library.
+   *
+   * \param[in]  A  Selfadjoint matrix whose eigendecomposition is to be computed.
+   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
+   *    Must be less than the size of the input matrix, or an error is returned.
+   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
+   *    respective meanings to find the largest magnitude, smallest magnitude,
+   *    largest algebraic, or smallest algebraic eigenvalues. Passing a floating
+   *    point value in string form, to find the eigenvalues closest to that value,
+   *    is not supported yet and triggers an assertion.
+   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
+   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
+   *    means machine precision.
+   *
+   * \returns    Reference to \c *this
+   *
+   * This function computes the eigenvalues of \p A using ARPACK.  The eigenvalues()
+   * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
+   * then the eigenvectors are also computed and can be retrieved by
+   * calling eigenvectors().
+   *
+   */
+  ArpackGeneralizedSelfAdjointEigenSolver &compute(const MatrixType &A, Index nbrEigenvalues,
+                                                   std::string eigs_sigma = "LM", int options = ComputeEigenvectors,
+                                                   RealScalar tol = 0.0);
+
+  /** \brief Returns the eigenvectors of given matrix.
+   *
+   * \returns  A const reference to the matrix whose columns are the eigenvectors.
+   *
+   * \pre The eigenvectors have been computed before.
+   *
+   * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
+   * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
+   * eigenvectors are normalized to have (Euclidean) norm equal to one. If
+   * this object was used to solve the eigenproblem for the selfadjoint
+   * matrix \f$ A \f$, then the matrix returned by this function is the
+   * matrix \f$ V \f$ in the eigendecomposition \f$ A V = D V \f$.
+   * For the generalized eigenproblem, the matrix returned is the solution \f$ A V = D B V \f$
+   *
+   * Example: \include SelfAdjointEigenSolver_eigenvectors.cpp
+   * Output: \verbinclude SelfAdjointEigenSolver_eigenvectors.out
+   *
+   * \sa eigenvalues()
+   */
+  const Matrix<Scalar, Dynamic, Dynamic> &eigenvectors() const {
+    eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
+    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+    return m_eivec;
+  }
+
+  /** \brief Returns the eigenvalues of given matrix.
+   *
+   * \returns A const reference to the column vector containing the eigenvalues.
+   *
+   * \pre The eigenvalues have been computed before.
+   *
+   * The returned vector has \c nbrEigenvalues entries, as requested when calling
+   * compute(): ARPACK is a partial eigensolver and cannot compute the whole
+   * spectrum. The eigenvalues are sorted in increasing order.
+   *
+   * Example: \include SelfAdjointEigenSolver_eigenvalues.cpp
+   * Output: \verbinclude SelfAdjointEigenSolver_eigenvalues.out
+   *
+   * \sa eigenvectors(), MatrixBase::eigenvalues()
+   */
+  const Matrix<Scalar, Dynamic, 1> &eigenvalues() const {
+    eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
+    return m_eivalues;
+  }
+
+  /** \brief Computes the positive-definite square root of the matrix.
+   *
+   * \returns the positive-definite square root of the matrix
+   *
+   * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+   * have been computed before.
+   *
+   * The square root of a positive-definite matrix \f$ A \f$ is the
+   * positive-definite matrix whose square equals \f$ A \f$. This function
+   * uses the eigendecomposition \f$ A = V D V^{-1} \f$ to compute the
+   * square root as \f$ A^{1/2} = V D^{1/2} V^{-1} \f$.
+   *
+   * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
+   * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
+   *
+   * \sa operatorInverseSqrt(),
+   *     \ref MatrixFunctions_Module "MatrixFunctions Module"
+   */
+  Matrix<Scalar, Dynamic, Dynamic> operatorSqrt() const {
+    eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+    return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+  }
+
+  /** \brief Computes the inverse square root of the matrix.
+   *
+   * \returns the inverse positive-definite square root of the matrix
+   *
+   * \pre The eigenvalues and eigenvectors of a positive-definite matrix
+   * have been computed before.
+   *
+   * This function uses the eigendecomposition \f$ A = V D V^{-1} \f$ to
+   * compute the inverse square root as \f$ V D^{-1/2} V^{-1} \f$. This is
+   * cheaper than first computing the square root with operatorSqrt() and
+   * then its inverse with MatrixBase::inverse().
+   *
+   * Example: \include SelfAdjointEigenSolver_operatorInverseSqrt.cpp
+   * Output: \verbinclude SelfAdjointEigenSolver_operatorInverseSqrt.out
+   *
+   * \sa operatorSqrt(), MatrixBase::inverse(),
+   *     \ref MatrixFunctions_Module "MatrixFunctions Module"
+   */
+  Matrix<Scalar, Dynamic, Dynamic> operatorInverseSqrt() const {
+    eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
+    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
+    return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
+  }
+
+  /** \brief Reports whether previous computation was successful.
+   *
+   * \returns \c Success if computation was successful, \c NoConvergence otherwise.
+   */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
+    return m_info;
+  }
+
+  size_t getNbrConvergedEigenValues() const { return m_nbrConverged; }
+
+  size_t getNbrIterations() const { return m_nbrIterations; }
+
+ protected:
+  Matrix<Scalar, Dynamic, Dynamic> m_eivec;
+  Matrix<Scalar, Dynamic, 1> m_eivalues;
+  ComputationInfo m_info;
+  bool m_isInitialized;
+  bool m_eigenvectorsOk;
+
+  size_t m_nbrConverged;
+  size_t m_nbrIterations;
+};
+
+template <typename MatrixType, typename MatrixSolver, bool BisSPD>
+ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD> &
+ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD>::compute(const MatrixType &A,
+                                                                                   Index nbrEigenvalues,
+                                                                                   std::string eigs_sigma, int options,
+                                                                                   RealScalar tol) {
+  MatrixType B(0, 0);
+  compute(A, B, nbrEigenvalues, eigs_sigma, options, tol);
+
+  return *this;
+}
+
+template <typename MatrixType, typename MatrixSolver, bool BisSPD>
+ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD> &
+ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD>::compute(const MatrixType &A,
+                                                                                   const MatrixType &B,
+                                                                                   Index nbrEigenvalues,
+                                                                                   std::string eigs_sigma, int options,
+                                                                                   RealScalar tol) {
+  eigen_assert(A.cols() == A.rows());
+  eigen_assert(B.cols() == B.rows());
+  eigen_assert(B.rows() == 0 || A.cols() == B.rows());
+  eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
+               "invalid option parameter");
+
+  bool isBempty = (B.rows() == 0) || (B.cols() == 0);
+
+  // For clarity, all parameters match their ARPACK name
+  //
+  // Always 0 on the first call
+  //
+  int ido = 0;
+
+  int n = (int)A.cols();
+
+  // User options: "LA", "SA", "SM", "LM", "BE"
+  //
+  char whch[3] = "LM";
+
+  // Specifies the shift if iparam[6] = { 3, 4, 5 }, not used if iparam[6] = { 1, 2 }
+  //
+  RealScalar sigma = 0.0;
+
+  if (eigs_sigma.length() >= 2 && isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1])) {
+    eigs_sigma[0] = toupper(eigs_sigma[0]);
+    eigs_sigma[1] = toupper(eigs_sigma[1]);
+
+    // In the following special case we're going to invert the problem, since solving
+    // for larger magnitude is much much faster
+    // i.e., if 'SM' is specified, we're going to really use 'LM', the default
+    //
+    if (eigs_sigma.substr(0, 2) != "SM") {
+      whch[0] = eigs_sigma[0];
+      whch[1] = eigs_sigma[1];
+    }
+  } else {
+    eigen_assert(false && "Specifying clustered eigenvalues is not yet supported!");
+
+    // If it's not scalar values, then the user may be explicitly
+    // specifying the sigma value to cluster the evs around
+    //
+    sigma = atof(eigs_sigma.c_str());
+
+    // If atof fails, it returns 0.0, which is a fine default
+    //
+  }
+
+  // "I" means normal eigenvalue problem, "G" means generalized
+  //
+  char bmat[2] = "I";
+  if (eigs_sigma.substr(0, 2) == "SM" || !(isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1])) || (!isBempty && !BisSPD))
+    bmat[0] = 'G';
+
+  // Now we determine the mode to use
+  //
+  int mode = (bmat[0] == 'G') + 1;
+  if (eigs_sigma.substr(0, 2) == "SM" || !(isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1]))) {
+    // We're going to use shift-and-invert mode, and basically find
+    // the largest eigenvalues of the inverse operator
+    //
+    mode = 3;
+  }
+
+  // The user-specified number of eigenvalues/vectors to compute
+  //
+  int nev = (int)nbrEigenvalues;
+
+  // Allocate space for ARPACK to store the residual
+  //
+  Scalar *resid = new Scalar[n];
+
+  // Number of Lanczos vectors, must satisfy nev < ncv <= n
+  // Note that this indicates that nev != n, and we cannot compute
+  // all eigenvalues of a matrix
+  //
+  int ncv = std::min(std::max(2 * nev, 20), n);
+
+  // The working n x ncv matrix, also store the final eigenvectors (if computed)
+  //
+  Scalar *v = new Scalar[n * ncv];
+  int ldv = n;
+
+  // Working space
+  //
+  Scalar *workd = new Scalar[3 * n];
+  int lworkl = ncv * ncv + 8 * ncv;  // Must be at least this length
+  Scalar *workl = new Scalar[lworkl];
+
+  int *iparam = new int[11];
+  iparam[0] = 1;  // 1 means we let ARPACK perform the shifts, 0 means we'd have to do it
+  iparam[2] = std::max(300, numext::div_ceil(2 * n, std::max(ncv, 1)));
+  iparam[6] = mode;  // The mode, 1 is standard ev problem, 2 for generalized ev, 3 for shift-and-invert
+
+  // Used during reverse communicate to notify where arrays start
+  //
+  int *ipntr = new int[11];
+
+  // Error codes are returned in here, initial value of 0 indicates a random initial
+  // residual vector is used, any other values means resid contains the initial residual
+  // vector, possibly from a previous run
+  //
+  int info = 0;
+
+  Scalar scale = 1.0;
+
+  MatrixSolver OP;
+  if (mode == 1 || mode == 2) {
+    if (!isBempty) OP.compute(B);
+  } else if (mode == 3) {
+    if (sigma == 0.0) {
+      OP.compute(A);
+    } else {
+      // Note: We will never enter here because sigma must be 0.0
+      //
+      if (isBempty) {
+        MatrixType AminusSigmaB(A);
+        for (Index i = 0; i < A.rows(); ++i) AminusSigmaB.coeffRef(i, i) -= sigma;
+
+        OP.compute(AminusSigmaB);
+      } else {
+        MatrixType AminusSigmaB = A - sigma * B;
+        OP.compute(AminusSigmaB);
+      }
+    }
+  }
+
+  if (!(mode == 1 && isBempty) && !(mode == 2 && isBempty) && OP.info() != Success) {
+    m_info = OP.info();
+    delete[] v;
+    delete[] iparam;
+    delete[] ipntr;
+    delete[] workd;
+    delete[] workl;
+    delete[] resid;
+    m_isInitialized = false;
+    return *this;
+  }
+
+  do {
+    internal::arpack_wrapper<Scalar, RealScalar>::saupd(&ido, bmat, &n, whch, &nev, &tol, resid, &ncv, v, &ldv, iparam,
+                                                        ipntr, workd, workl, &lworkl, &info);
+
+    if (ido == -1 || ido == 1) {
+      Scalar *in = workd + ipntr[0] - 1;
+      Scalar *out = workd + ipntr[1] - 1;
+
+      if (ido == 1 && mode != 2) {
+        Scalar *out2 = workd + ipntr[2] - 1;
+        if (isBempty || mode == 1)
+          Matrix<Scalar, Dynamic, 1>::Map(out2, n) = Matrix<Scalar, Dynamic, 1>::Map(in, n);
+        else
+          Matrix<Scalar, Dynamic, 1>::Map(out2, n) = B * Matrix<Scalar, Dynamic, 1>::Map(in, n);
+
+        in = workd + ipntr[2] - 1;
+      }
+
+      if (mode == 1) {
+        if (isBempty) {
+          // OP = A
+          //
+          Matrix<Scalar, Dynamic, 1>::Map(out, n) = A * Matrix<Scalar, Dynamic, 1>::Map(in, n);
+        } else {
+          // OP = L^{-1}AL^{-T}
+          //
+          internal::OP<MatrixSolver, MatrixType, Scalar, BisSPD>::applyOP(OP, A, n, in, out);
+        }
+      } else if (mode == 2) {
+        if (ido == 1) Matrix<Scalar, Dynamic, 1>::Map(in, n) = A * Matrix<Scalar, Dynamic, 1>::Map(in, n);
+
+        // OP = B^{-1} A
+        //
+        Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
+      } else if (mode == 3) {
+        // OP = (A-\sigmaB)B (\sigma could be 0, and B could be I)
+        // The B * in is already computed and stored at in if ido == 1
+        //
+        if (ido == 1 || isBempty)
+          Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
+        else
+          Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(B * Matrix<Scalar, Dynamic, 1>::Map(in, n));
+      }
+    } else if (ido == 2) {
+      Scalar *in = workd + ipntr[0] - 1;
+      Scalar *out = workd + ipntr[1] - 1;
+
+      if (isBempty || mode == 1)
+        Matrix<Scalar, Dynamic, 1>::Map(out, n) = Matrix<Scalar, Dynamic, 1>::Map(in, n);
+      else
+        Matrix<Scalar, Dynamic, 1>::Map(out, n) = B * Matrix<Scalar, Dynamic, 1>::Map(in, n);
+    }
+  } while (ido != 99);
+
+  if (info == 1)
+    m_info = NoConvergence;
+  else if (info == 3)
+    m_info = NumericalIssue;
+  else if (info < 0)
+    m_info = InvalidInput;
+  else if (info != 0)
+    eigen_assert(false && "Unknown ARPACK return value!");
+  else {
+    // Do we compute eigenvectors or not?
+    //
+    int rvec = (options & ComputeEigenvectors) == ComputeEigenvectors;
+
+    // "A" means "All", use "S" to choose specific eigenvalues (not yet supported in ARPACK)
+    //
+    char howmny[2] = "A";
+
+    // if howmny == "S", specifies the eigenvalues to compute (not implemented in ARPACK)
+    //
+    int *select = new int[ncv];
+
+    // Final eigenvalues
+    //
+    m_eivalues.resize(nev, 1);
+
+    internal::arpack_wrapper<Scalar, RealScalar>::seupd(&rvec, howmny, select, m_eivalues.data(), v, &ldv, &sigma, bmat,
+                                                        &n, whch, &nev, &tol, resid, &ncv, v, &ldv, iparam, ipntr,
+                                                        workd, workl, &lworkl, &info);
+
+    if (info == -14)
+      m_info = NoConvergence;
+    else if (info != 0)
+      m_info = InvalidInput;
+    else {
+      if (rvec) {
+        m_eivec.resize(A.rows(), nev);
+        for (int i = 0; i < nev; i++)
+          for (int j = 0; j < n; j++) m_eivec(j, i) = v[i * n + j] / scale;
+
+        if (mode == 1 && !isBempty && BisSPD)
+          internal::OP<MatrixSolver, MatrixType, Scalar, BisSPD>::project(OP, n, nev, m_eivec.data());
+
+        m_eigenvectorsOk = true;
+      }
+
+      m_nbrIterations = iparam[2];
+      m_nbrConverged = iparam[4];
+
+      m_info = Success;
+    }
+
+    delete[] select;
+  }
+
+  delete[] v;
+  delete[] iparam;
+  delete[] ipntr;
+  delete[] workd;
+  delete[] workl;
+  delete[] resid;
+
+  m_isInitialized = (m_info == Success);
+
+  return *this;
+}
+
+// Single precision
+//
+extern "C" void ssaupd_(int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv,
+                        float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl,
+                        int *info);
+
+extern "C" void sseupd_(int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat,
+                        int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv,
+                        int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr);
+
+// Double precision
+//
+extern "C" void dsaupd_(int *ido, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv,
+                        double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl,
+                        int *info);
+
+extern "C" void dseupd_(int *rvec, char *All, int *select, double *d, double *z, int *ldz, double *sigma, char *bmat,
+                        int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv,
+                        int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *ierr);
+
+namespace internal {
+
+template <typename Scalar, typename RealScalar>
+struct arpack_wrapper {
+  static inline void saupd(int *ido, char *bmat, int *n, char *which, int *nev, RealScalar *tol, Scalar *resid,
+                           int *ncv, Scalar *v, int *ldv, int *iparam, int *ipntr, Scalar *workd, Scalar *workl,
+                           int *lworkl, int *info) {
+    EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
+  }
+
+  static inline void seupd(int *rvec, char *All, int *select, Scalar *d, Scalar *z, int *ldz, RealScalar *sigma,
+                           char *bmat, int *n, char *which, int *nev, RealScalar *tol, Scalar *resid, int *ncv,
+                           Scalar *v, int *ldv, int *iparam, int *ipntr, Scalar *workd, Scalar *workl, int *lworkl,
+                           int *ierr) {
+    EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
+  }
+};
+
+template <>
+struct arpack_wrapper<float, float> {
+  static inline void saupd(int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv,
+                           float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl,
+                           int *info) {
+    ssaupd_(ido, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd, workl, lworkl, info);
+  }
+
+  static inline void seupd(int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat,
+                           int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv,
+                           int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr) {
+    sseupd_(rvec, All, select, d, z, ldz, sigma, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd,
+            workl, lworkl, ierr);
+  }
+};
+
+template <>
+struct arpack_wrapper<double, double> {
+  static inline void saupd(int *ido, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv,
+                           double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl,
+                           int *info) {
+    dsaupd_(ido, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd, workl, lworkl, info);
+  }
+
+  static inline void seupd(int *rvec, char *All, int *select, double *d, double *z, int *ldz, double *sigma, char *bmat,
+                           int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv,
+                           int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *ierr) {
+    dseupd_(rvec, All, select, d, v, ldv, sigma, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd,
+            workl, lworkl, ierr);
+  }
+};
+
+template <typename MatrixSolver, typename MatrixType, typename Scalar, bool BisSPD>
+struct OP {
+  static inline void applyOP(MatrixSolver &OP, const MatrixType &A, int n, Scalar *in, Scalar *out);
+  static inline void project(MatrixSolver &OP, int n, int k, Scalar *vecs);
+};
+
+template <typename MatrixSolver, typename MatrixType, typename Scalar>
+struct OP<MatrixSolver, MatrixType, Scalar, true> {
+  static inline void applyOP(MatrixSolver &OP, const MatrixType &A, int n, Scalar *in, Scalar *out) {
+    // OP = L^{-1} A L^{-T}  (B = LL^T)
+    //
+    // First solve L^T out = in
+    //
+    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.matrixU().solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
+    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.permutationPinv() * Matrix<Scalar, Dynamic, 1>::Map(out, n);
+
+    // Then compute out = A out
+    //
+    Matrix<Scalar, Dynamic, 1>::Map(out, n) = A * Matrix<Scalar, Dynamic, 1>::Map(out, n);
+
+    // Then solve L out = out
+    //
+    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.permutationP() * Matrix<Scalar, Dynamic, 1>::Map(out, n);
+    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.matrixL().solve(Matrix<Scalar, Dynamic, 1>::Map(out, n));
+  }
+
+  static inline void project(MatrixSolver &OP, int n, int k, Scalar *vecs) {
+    // Solve L^T out = in
+    //
+    Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k) =
+        OP.matrixU().solve(Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k));
+    Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k) =
+        OP.permutationPinv() * Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k);
+  }
+};
+
+template <typename MatrixSolver, typename MatrixType, typename Scalar>
+struct OP<MatrixSolver, MatrixType, Scalar, false> {
+  static inline void applyOP(MatrixSolver &OP, const MatrixType &A, int n, Scalar *in, Scalar *out) {
+    eigen_assert(false && "Should never be in here...");
+  }
+
+  static inline void project(MatrixSolver &OP, int n, int k, Scalar *vecs) {
+    eigen_assert(false && "Should never be in here...");
+  }
+};
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_ARPACKSELFADJOINTEIGENSOLVER_H
diff --git a/contrib/Eigen/src/ArpackSupport/InternalHeaderCheck.h b/contrib/Eigen/src/ArpackSupport/InternalHeaderCheck.h
new file mode 100644
index 0000000..a686dc1
--- /dev/null
+++ b/contrib/Eigen/src/ArpackSupport/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_ARPACKSUPPORT_MODULE_H
+#error "Please include contrib/Eigen/ArpackSupport instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/AutoDiff/AutoDiffJacobian.h b/contrib/Eigen/src/AutoDiff/AutoDiffJacobian.h
new file mode 100644
index 0000000..460d57c
--- /dev/null
+++ b/contrib/Eigen/src/AutoDiff/AutoDiffJacobian.h
@@ -0,0 +1,77 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AUTODIFF_JACOBIAN_H
+#define EIGEN_AUTODIFF_JACOBIAN_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Functor>
+class AutoDiffJacobian : public Functor {
+ public:
+  AutoDiffJacobian() : Functor() {}
+  AutoDiffJacobian(const Functor& f) : Functor(f) {}
+
+  // forward constructors
+  template <typename... T>
+  AutoDiffJacobian(const T&... Values) : Functor(Values...) {}
+
+  typedef typename Functor::InputType InputType;
+  typedef typename Functor::ValueType ValueType;
+  typedef typename ValueType::Scalar Scalar;
+
+  enum { InputsAtCompileTime = InputType::RowsAtCompileTime, ValuesAtCompileTime = ValueType::RowsAtCompileTime };
+
+  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
+  typedef typename JacobianType::Index Index;
+
+  typedef Matrix<Scalar, InputsAtCompileTime, 1> DerivativeType;
+  typedef AutoDiffScalar<DerivativeType> ActiveScalar;
+
+  typedef Matrix<ActiveScalar, InputsAtCompileTime, 1> ActiveInput;
+  typedef Matrix<ActiveScalar, ValuesAtCompileTime, 1> ActiveValue;
+
+  // Some compilers don't accept variadic parameters after a default parameter,
+  // i.e., we can't just write _jac=0 but we need to overload operator():
+  EIGEN_STRONG_INLINE void operator()(const InputType& x, ValueType* v) const { this->operator()(x, v, 0); }
+  template <typename... ParamsType>
+  void operator()(const InputType& x, ValueType* v, JacobianType* _jac, const ParamsType&... Params) const {
+    eigen_assert(v != 0);
+
+    if (!_jac) {
+      Functor::operator()(x, v, Params...);
+      return;
+    }
+
+    JacobianType& jac = *_jac;
+
+    ActiveInput ax = x.template cast<ActiveScalar>();
+    ActiveValue av(jac.rows());
+
+    EIGEN_IF_CONSTEXPR (InputsAtCompileTime == Dynamic)
+      for (Index j = 0; j < jac.rows(); j++) av[j].derivatives().resize(x.rows());
+
+    for (Index i = 0; i < jac.cols(); i++) ax[i].derivatives() = DerivativeType::Unit(x.rows(), i);
+
+    Functor::operator()(ax, &av, Params...);
+
+    for (Index i = 0; i < jac.rows(); i++) {
+      (*v)[i] = av[i].value();
+      jac.row(i) = av[i].derivatives();
+    }
+  }
+};
+
+}  // namespace Eigen
+
+#endif  // EIGEN_AUTODIFF_JACOBIAN_H
diff --git a/contrib/Eigen/src/AutoDiff/AutoDiffScalar.h b/contrib/Eigen/src/AutoDiff/AutoDiffScalar.h
new file mode 100644
index 0000000..71405b6
--- /dev/null
+++ b/contrib/Eigen/src/AutoDiff/AutoDiffScalar.h
@@ -0,0 +1,581 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AUTODIFF_SCALAR_H
+#define EIGEN_AUTODIFF_SCALAR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename DerivativeType, bool Enable>
+struct auto_diff_special_op;
+
+template <typename DerivativeType, typename OtherDerivativeType, typename EnableIf = void>
+struct maybe_coherent_pad_helper {
+  static constexpr int SizeAtCompileTime =
+      max_size_prefer_dynamic(DerivativeType::SizeAtCompileTime, OtherDerivativeType::SizeAtCompileTime);
+  using type = CoherentPadOp<DerivativeType, SizeAtCompileTime>;
+  static type pad(const DerivativeType& x, const OtherDerivativeType& y) {
+    // CoherentPadOp uses variable_if_dynamic<SizeAtCompileTime>.  In this case, `SizeAtCompileTime` might
+    // be Dynamic, so we need to take the runtime maximum of x, y.
+    return CoherentPadOp<DerivativeType, SizeAtCompileTime>(x, numext::maxi(x.size(), y.size()));
+  }
+};
+
+// Both are fixed-sized and equal, don't need to pad.
+// Both are fixed-size and this is larger than other, don't need to pad.
+template <typename DerivativeType, typename OtherDerivativeType>
+struct maybe_coherent_pad_helper<
+    DerivativeType, OtherDerivativeType,
+    std::enable_if_t<enum_ge_not_dynamic(DerivativeType::SizeAtCompileTime, OtherDerivativeType::SizeAtCompileTime)>> {
+  using type = const DerivativeType&;
+  static const DerivativeType& pad(const DerivativeType& x, const OtherDerivativeType& /*y*/) { return x; }
+};
+
+template <typename DerivativeType, typename OtherDerivativeType>
+typename maybe_coherent_pad_helper<DerivativeType, OtherDerivativeType>::type MaybeCoherentPad(
+    const DerivativeType& x, const OtherDerivativeType& y) {
+  return maybe_coherent_pad_helper<DerivativeType, OtherDerivativeType>::pad(x, y);
+}
+
+template <typename Op, typename LhsDerivativeType, typename RhsDerivativeType>
+auto MakeCoherentCwiseBinaryOp(const LhsDerivativeType& x, const RhsDerivativeType& y, Op op = Op()) {
+  const auto& lhs = MaybeCoherentPad(x, y);
+  const auto& rhs = MaybeCoherentPad(y, x);
+  return CwiseBinaryOp<Op, remove_all_t<decltype(lhs)>, remove_all_t<decltype(rhs)>>(lhs, rhs, op);
+}
+
+}  // namespace internal
+
+template <typename DerivativeType>
+class AutoDiffScalar;
+
+template <typename NewDerType>
+inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::Scalar& value, const NewDerType& der) {
+  return AutoDiffScalar<NewDerType>(value, der);
+}
+
+/** \class AutoDiffScalar
+ * \brief A scalar type replacement with automatic differentiation capability
+ *
+ * \param DerivativeType the vector type used to store/represent the derivatives. The base scalar type
+ *                 as well as the number of derivatives to compute are determined from this type.
+ *                 Typical choices include, e.g., \c Vector4f for 4 derivatives, or \c VectorXf
+ *                 if the number of derivatives is not known at compile time, and/or, the number
+ *                 of derivatives is large.
+ *                 Note that DerivativeType can also be a reference (e.g., \c VectorXf&) to wrap an
+ *                 existing vector into an AutoDiffScalar.
+ *                 Finally, DerivativeType can also be any Eigen compatible expression.
+ *
+ * This class represents a scalar value while tracking its respective derivatives using Eigen's expression
+ * template mechanism.
+ *
+ * It supports the following list of global math functions:
+ *  - std::abs, std::sqrt, std::pow, std::exp, std::log, std::sin, std::cos,
+ *  - internal::abs, internal::sqrt, numext::pow, internal::exp, internal::log, internal::sin, internal::cos,
+ *  - internal::conj, internal::real, internal::imag, numext::abs2.
+ *
+ * AutoDiffScalar can be used as the scalar type of an Eigen::Matrix object. However,
+ * in that case, the expression template mechanism only occurs at the top Matrix level,
+ * while derivatives are computed right away.
+ *
+ */
+
+template <typename DerivativeType>
+class AutoDiffScalar
+    : public internal::auto_diff_special_op<
+          DerivativeType, !std::is_same<typename internal::traits<internal::remove_all_t<DerivativeType>>::Scalar,
+                                        typename NumTraits<typename internal::traits<
+                                            internal::remove_all_t<DerivativeType>>::Scalar>::Real>::value> {
+ public:
+  typedef internal::auto_diff_special_op<
+      DerivativeType,
+      !std::is_same<
+          typename internal::traits<internal::remove_all_t<DerivativeType>>::Scalar,
+          typename NumTraits<typename internal::traits<internal::remove_all_t<DerivativeType>>::Scalar>::Real>::value>
+      Base;
+  typedef internal::remove_all_t<DerivativeType> DerType;
+  typedef typename internal::traits<DerType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real Real;
+
+  using Base::operator+;
+  using Base::operator*;
+
+  /** Default constructor without any initialization. */
+  AutoDiffScalar() {}
+
+  /** Constructs an active scalar from its \a value,
+      and initializes the \a nbDer derivatives such that it corresponds to the \a derNumber -th variable */
+  AutoDiffScalar(const Scalar& value, int nbDer, int derNumber) : m_value(value), m_derivatives(DerType::Zero(nbDer)) {
+    m_derivatives.coeffRef(derNumber) = Scalar(1);
+  }
+
+  /** Conversion from a scalar constant to an active scalar.
+   * The derivatives are set to zero. */
+  /*explicit*/ AutoDiffScalar(const Real& value) : m_value(value) {
+    if (m_derivatives.size() > 0) m_derivatives.setZero();
+  }
+
+  /** Constructs an active scalar from its \a value and derivatives \a der */
+  AutoDiffScalar(const Scalar& value, const DerType& der) : m_value(value), m_derivatives(der) {}
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename OtherDerType,
+            std::enable_if_t<
+                std::is_same<Scalar, typename internal::traits<internal::remove_all_t<OtherDerType>>::Scalar>::value &&
+                    std::is_convertible<OtherDerType, DerType>::value,
+                int> = 0>
+#else
+  template <typename OtherDerType>
+#endif
+  AutoDiffScalar(const AutoDiffScalar<OtherDerType>& other)
+      : m_value(other.value()), m_derivatives(other.derivatives()) {
+  }
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  template <typename OtherDerType>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only second argument.")
+  AutoDiffScalar(
+      const AutoDiffScalar<OtherDerType>& other,
+      std::enable_if_t<
+          std::is_same<Scalar, typename internal::traits<internal::remove_all_t<OtherDerType>>::Scalar>::value &&
+              std::is_convertible<OtherDerType, DerType>::value,
+          void*>)
+      : AutoDiffScalar(other) {}
+#endif
+
+  friend std::ostream& operator<<(std::ostream& s, const AutoDiffScalar& a) { return s << a.value(); }
+
+  AutoDiffScalar(const AutoDiffScalar& other) : m_value(other.value()), m_derivatives(other.derivatives()) {}
+
+  template <typename OtherDerType>
+  inline AutoDiffScalar& operator=(const AutoDiffScalar<OtherDerType>& other) {
+    m_value = other.value();
+    m_derivatives = other.derivatives();
+    return *this;
+  }
+
+  inline AutoDiffScalar& operator=(const AutoDiffScalar& other) {
+    m_value = other.value();
+    m_derivatives = other.derivatives();
+    return *this;
+  }
+
+  inline AutoDiffScalar& operator=(const Scalar& other) {
+    m_value = other;
+    if (m_derivatives.size() > 0) m_derivatives.setZero();
+    return *this;
+  }
+
+  //     inline operator const Scalar& () const { return m_value; }
+  //     inline operator Scalar& () { return m_value; }
+
+  inline const Scalar& value() const { return m_value; }
+  inline Scalar& value() { return m_value; }
+
+  inline const DerType& derivatives() const { return m_derivatives; }
+  inline DerType& derivatives() { return m_derivatives; }
+
+  inline bool operator<(const Scalar& other) const { return m_value < other; }
+  inline bool operator<=(const Scalar& other) const { return m_value <= other; }
+  inline bool operator>(const Scalar& other) const { return m_value > other; }
+  inline bool operator>=(const Scalar& other) const { return m_value >= other; }
+  inline bool operator==(const Scalar& other) const { return m_value == other; }
+  inline bool operator!=(const Scalar& other) const { return m_value != other; }
+
+  friend inline bool operator<(const Scalar& a, const AutoDiffScalar& b) { return a < b.value(); }
+  friend inline bool operator<=(const Scalar& a, const AutoDiffScalar& b) { return a <= b.value(); }
+  friend inline bool operator>(const Scalar& a, const AutoDiffScalar& b) { return a > b.value(); }
+  friend inline bool operator>=(const Scalar& a, const AutoDiffScalar& b) { return a >= b.value(); }
+  friend inline bool operator==(const Scalar& a, const AutoDiffScalar& b) { return a == b.value(); }
+  friend inline bool operator!=(const Scalar& a, const AutoDiffScalar& b) { return a != b.value(); }
+
+  template <typename OtherDerType>
+  inline bool operator<(const AutoDiffScalar<OtherDerType>& b) const {
+    return m_value < b.value();
+  }
+  template <typename OtherDerType>
+  inline bool operator<=(const AutoDiffScalar<OtherDerType>& b) const {
+    return m_value <= b.value();
+  }
+  template <typename OtherDerType>
+  inline bool operator>(const AutoDiffScalar<OtherDerType>& b) const {
+    return m_value > b.value();
+  }
+  template <typename OtherDerType>
+  inline bool operator>=(const AutoDiffScalar<OtherDerType>& b) const {
+    return m_value >= b.value();
+  }
+  template <typename OtherDerType>
+  inline bool operator==(const AutoDiffScalar<OtherDerType>& b) const {
+    return m_value == b.value();
+  }
+  template <typename OtherDerType>
+  inline bool operator!=(const AutoDiffScalar<OtherDerType>& b) const {
+    return m_value != b.value();
+  }
+
+  inline AutoDiffScalar<DerType&> operator+(const Scalar& other) const {
+    return AutoDiffScalar<DerType&>(m_value + other, m_derivatives);
+  }
+
+  friend inline AutoDiffScalar<DerType&> operator+(const Scalar& a, const AutoDiffScalar& b) {
+    return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
+  }
+
+  inline AutoDiffScalar& operator+=(const Scalar& other) {
+    value() += other;
+    return *this;
+  }
+
+  template <typename OtherDerType>
+  inline auto operator+(const AutoDiffScalar<OtherDerType>& other) const {
+    return MakeAutoDiffScalar(
+        m_value + other.value(),
+        internal::MakeCoherentCwiseBinaryOp<internal::scalar_sum_op<Scalar>>(m_derivatives, other.derivatives()));
+  }
+
+  template <typename OtherDerType>
+  inline AutoDiffScalar& operator+=(const AutoDiffScalar<OtherDerType>& other) {
+    (*this) = (*this) + other;
+    return *this;
+  }
+
+  inline AutoDiffScalar<DerType&> operator-(const Scalar& b) const {
+    return AutoDiffScalar<DerType&>(m_value - b, m_derivatives);
+  }
+
+  friend inline AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>> operator-(
+      const Scalar& a, const AutoDiffScalar& b) {
+    return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>>(a - b.value(),
+                                                                                             -b.derivatives());
+  }
+
+  inline AutoDiffScalar& operator-=(const Scalar& other) {
+    value() -= other;
+    return *this;
+  }
+
+  template <typename OtherDerType>
+  inline auto operator-(const AutoDiffScalar<OtherDerType>& other) const {
+    return MakeAutoDiffScalar(m_value - other.value(),
+                              internal::MakeCoherentCwiseBinaryOp<internal::scalar_difference_op<Scalar>>(
+                                  m_derivatives, other.derivatives()));
+  }
+
+  template <typename OtherDerType>
+  inline AutoDiffScalar& operator-=(const AutoDiffScalar<OtherDerType>& other) {
+    *this = *this - other;
+    return *this;
+  }
+
+  inline AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>> operator-() const {
+    return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>>(-m_value, -m_derivatives);
+  }
+
+  inline auto operator*(const Scalar& other) const {
+    return MakeAutoDiffScalar(m_value * other, m_derivatives * other);
+  }
+
+  friend inline auto operator*(const Scalar& other, const AutoDiffScalar& a) {
+    return MakeAutoDiffScalar(a.value() * other, a.derivatives() * other);
+  }
+
+  inline auto operator/(const Scalar& other) const {
+    return MakeAutoDiffScalar(m_value / other, (m_derivatives * (Scalar(1) / other)));
+  }
+
+  friend inline auto operator/(const Scalar& other, const AutoDiffScalar& a) {
+    return MakeAutoDiffScalar(other / a.value(), a.derivatives() * (Scalar(-other) / (a.value() * a.value())));
+  }
+
+  template <typename OtherDerType>
+  inline auto operator/(const AutoDiffScalar<OtherDerType>& other) const {
+    return MakeAutoDiffScalar(m_value / other.value(),
+                              internal::MakeCoherentCwiseBinaryOp<internal::scalar_difference_op<Scalar>>(
+                                  m_derivatives * other.value(), (other.derivatives() * m_value)) *
+                                  (Scalar(1) / (other.value() * other.value())));
+  }
+
+  template <typename OtherDerType>
+  inline auto operator*(const AutoDiffScalar<OtherDerType>& other) const {
+    return MakeAutoDiffScalar(m_value * other.value(),
+                              internal::MakeCoherentCwiseBinaryOp<internal::scalar_sum_op<Scalar>>(
+                                  m_derivatives * other.value(), other.derivatives() * m_value));
+  }
+
+  inline AutoDiffScalar& operator*=(const Scalar& other) {
+    *this = *this * other;
+    return *this;
+  }
+
+  template <typename OtherDerType>
+  inline AutoDiffScalar& operator*=(const AutoDiffScalar<OtherDerType>& other) {
+    *this = *this * other;
+    return *this;
+  }
+
+  inline AutoDiffScalar& operator/=(const Scalar& other) {
+    *this = *this / other;
+    return *this;
+  }
+
+  template <typename OtherDerType>
+  inline AutoDiffScalar& operator/=(const AutoDiffScalar<OtherDerType>& other) {
+    *this = *this / other;
+    return *this;
+  }
+
+ protected:
+  Scalar m_value;
+  DerType m_derivatives;
+};
+
+namespace internal {
+
+template <typename DerivativeType>
+struct auto_diff_special_op<DerivativeType, true> {
+  typedef remove_all_t<DerivativeType> DerType;
+  typedef typename traits<DerType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real Real;
+
+  const AutoDiffScalar<DerivativeType>& derived() const {
+    return *static_cast<const AutoDiffScalar<DerivativeType>*>(this);
+  }
+  AutoDiffScalar<DerivativeType>& derived() { return *static_cast<AutoDiffScalar<DerivativeType>*>(this); }
+
+  inline AutoDiffScalar<DerType&> operator+(const Real& other) const {
+    return AutoDiffScalar<DerType&>(derived().value() + other, derived().derivatives());
+  }
+
+  friend inline AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar<DerivativeType>& b) {
+    return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
+  }
+
+  inline AutoDiffScalar<DerivativeType>& operator+=(const Real& other) {
+    derived().value() += other;
+    return derived();
+  }
+
+  inline AutoDiffScalar<typename CwiseUnaryOp<bind2nd_op<scalar_product_op<Scalar, Real>>, DerType>::Type> operator*(
+      const Real& other) const {
+    return AutoDiffScalar<typename CwiseUnaryOp<bind2nd_op<scalar_product_op<Scalar, Real>>, DerType>::Type>(
+        derived().value() * other, derived().derivatives() * other);
+  }
+
+  friend inline AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real, Scalar>>, DerType>::Type>
+  operator*(const Real& other, const AutoDiffScalar<DerivativeType>& a) {
+    return AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real, Scalar>>, DerType>::Type>(
+        a.value() * other, a.derivatives() * other);
+  }
+
+  inline AutoDiffScalar<DerivativeType>& operator*=(const Scalar& other) {
+    *this = *this * other;
+    return derived();
+  }
+};
+
+template <typename DerivativeType>
+struct auto_diff_special_op<DerivativeType, false> {
+  void operator*() const;
+  void operator-() const;
+  void operator+() const;
+};
+
+}  // end namespace internal
+
+template <typename DerType, typename BinOp>
+struct ScalarBinaryOpTraits<AutoDiffScalar<DerType>, typename DerType::Scalar, BinOp> {
+  typedef AutoDiffScalar<DerType> ReturnType;
+};
+
+template <typename DerType, typename BinOp>
+struct ScalarBinaryOpTraits<typename DerType::Scalar, AutoDiffScalar<DerType>, BinOp> {
+  typedef AutoDiffScalar<DerType> ReturnType;
+};
+
+#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC, CODE)                                              \
+  template <typename DerType>                                                                        \
+  inline auto FUNC(const Eigen::AutoDiffScalar<DerType>& x) {                                        \
+    using namespace Eigen;                                                                           \
+    typedef typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar Scalar; \
+    EIGEN_UNUSED_VARIABLE(sizeof(Scalar));                                                           \
+    CODE;                                                                                            \
+  }
+
+template <typename DerType>
+struct CleanedUpDerType {
+  typedef AutoDiffScalar<typename Eigen::internal::remove_all_t<DerType>::PlainObject> type;
+};
+
+template <typename DerType>
+inline const AutoDiffScalar<DerType>& conj(const AutoDiffScalar<DerType>& x) {
+  return x;
+}
+template <typename DerType>
+inline const AutoDiffScalar<DerType>& real(const AutoDiffScalar<DerType>& x) {
+  return x;
+}
+template <typename DerType>
+inline typename DerType::Scalar imag(const AutoDiffScalar<DerType>&) {
+  return 0.;
+}
+template <typename DerType, typename T>
+inline typename CleanedUpDerType<DerType>::type(min)(const AutoDiffScalar<DerType>& x, const T& y) {
+  typedef typename CleanedUpDerType<DerType>::type ADS;
+  return (x <= y ? ADS(x) : ADS(y));
+}
+template <typename DerType, typename T>
+inline typename CleanedUpDerType<DerType>::type(max)(const AutoDiffScalar<DerType>& x, const T& y) {
+  typedef typename CleanedUpDerType<DerType>::type ADS;
+  return (x >= y ? ADS(x) : ADS(y));
+}
+template <typename DerType, typename T>
+inline typename CleanedUpDerType<DerType>::type(min)(const T& x, const AutoDiffScalar<DerType>& y) {
+  typedef typename CleanedUpDerType<DerType>::type ADS;
+  return (x < y ? ADS(x) : ADS(y));
+}
+template <typename DerType, typename T>
+inline typename CleanedUpDerType<DerType>::type(max)(const T& x, const AutoDiffScalar<DerType>& y) {
+  typedef typename CleanedUpDerType<DerType>::type ADS;
+  return (x > y ? ADS(x) : ADS(y));
+}
+template <typename DerType>
+inline
+    typename CleanedUpDerType<DerType>::type(min)(const AutoDiffScalar<DerType>& x, const AutoDiffScalar<DerType>& y) {
+  // Match std::min / max(ADS, ADS): on tie, return the first argument.
+  return (x.value() <= y.value() ? x : y);
+}
+template <typename DerType>
+inline
+    typename CleanedUpDerType<DerType>::type(max)(const AutoDiffScalar<DerType>& x, const AutoDiffScalar<DerType>& y) {
+  return (x.value() >= y.value() ? x : y);
+}
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs, using std::abs;
+                                    return Eigen::MakeAutoDiffScalar(abs(x.value()),
+                                                                     x.derivatives() * (x.value() < 0 ? -1 : 1));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2, using numext::abs2;
+                                    return Eigen::MakeAutoDiffScalar(abs2(x.value()),
+                                                                     x.derivatives() * (Scalar(2) * x.value()));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sqrt, using std::sqrt; Scalar sqrtx = sqrt(x.value());
+                                    return Eigen::MakeAutoDiffScalar(sqrtx, x.derivatives() * (Scalar(0.5) / sqrtx));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos, using std::cos; using std::sin;
+                                    return Eigen::MakeAutoDiffScalar(cos(x.value()),
+                                                                     x.derivatives() * (-sin(x.value())));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sin, using std::sin; using std::cos;
+                                    return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives() * cos(x.value()));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp, using std::exp; Scalar expx = exp(x.value());
+                                    return Eigen::MakeAutoDiffScalar(expx, x.derivatives() * expx);)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(log, using std::log;
+                                    return Eigen::MakeAutoDiffScalar(log(x.value()),
+                                                                     x.derivatives() * (Scalar(1) / x.value()));)
+
+template <typename DerType>
+inline auto pow(const Eigen::AutoDiffScalar<DerType>& x,
+                const typename internal::traits<internal::remove_all_t<DerType>>::Scalar& y) {
+  using namespace Eigen;
+  using std::pow;
+  return Eigen::MakeAutoDiffScalar(pow(x.value(), y), x.derivatives() * (y * pow(x.value(), y - 1)));
+}
+
+template <typename DerTypeA, typename DerTypeB>
+inline AutoDiffScalar<Matrix<typename internal::traits<internal::remove_all_t<DerTypeA>>::Scalar, Dynamic, 1>> atan2(
+    const AutoDiffScalar<DerTypeA>& a, const AutoDiffScalar<DerTypeB>& b) {
+  using std::atan2;
+  typedef typename internal::traits<internal::remove_all_t<DerTypeA>>::Scalar Scalar;
+  typedef AutoDiffScalar<Matrix<Scalar, Dynamic, 1>> PlainADS;
+  PlainADS ret;
+  ret.value() = atan2(a.value(), b.value());
+
+  Scalar squared_hypot = a.value() * a.value() + b.value() * b.value();
+
+  // if (squared_hypot==0) the derivation is undefined and the following results in a NaN:
+  ret.derivatives() = (a.derivatives() * b.value() - a.value() * b.derivatives()) / squared_hypot;
+
+  return ret;
+}
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tan, using std::tan; using std::cos; return Eigen::MakeAutoDiffScalar(
+                                        tan(x.value()), x.derivatives() * (Scalar(1) / numext::abs2(cos(x.value()))));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin, using std::sqrt; using std::asin; return Eigen::MakeAutoDiffScalar(
+                                        asin(x.value()),
+                                        x.derivatives() * (Scalar(1) / sqrt(1 - numext::abs2(x.value()))));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(acos, using std::sqrt; using std::acos; return Eigen::MakeAutoDiffScalar(
+                                        acos(x.value()),
+                                        x.derivatives() * (Scalar(-1) / sqrt(1 - numext::abs2(x.value()))));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(
+    tanh, using std::cosh; using std::tanh;
+    return Eigen::MakeAutoDiffScalar(tanh(x.value()), x.derivatives() * (Scalar(1) / numext::abs2(cosh(x.value()))));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sinh, using std::sinh; using std::cosh;
+                                    return Eigen::MakeAutoDiffScalar(sinh(x.value()),
+                                                                     x.derivatives() * cosh(x.value()));)
+
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh, using std::sinh; using std::cosh;
+                                    return Eigen::MakeAutoDiffScalar(cosh(x.value()),
+                                                                     x.derivatives() * sinh(x.value()));)
+
+#undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY
+
+template <typename DerType>
+struct NumTraits<AutoDiffScalar<DerType>>
+    : NumTraits<typename NumTraits<typename internal::remove_all_t<DerType>::Scalar>::Real> {
+  typedef internal::remove_all_t<DerType> DerTypeCleaned;
+  typedef AutoDiffScalar<Matrix<typename NumTraits<typename DerTypeCleaned::Scalar>::Real,
+                                DerTypeCleaned::RowsAtCompileTime, DerTypeCleaned::ColsAtCompileTime, 0,
+                                DerTypeCleaned::MaxRowsAtCompileTime, DerTypeCleaned::MaxColsAtCompileTime>>
+      Real;
+  typedef AutoDiffScalar<DerType> NonInteger;
+  typedef AutoDiffScalar<DerType> Nested;
+  typedef typename NumTraits<typename DerTypeCleaned::Scalar>::Literal Literal;
+  enum { RequireInitialization = 1 };
+};
+
+namespace internal {
+template <typename DerivativeType>
+struct is_identically_zero_impl<AutoDiffScalar<DerivativeType>> {
+  static inline bool run(const AutoDiffScalar<DerivativeType>& s) {
+    const DerivativeType& derivatives = s.derivatives();
+    for (int i = 0; i < derivatives.size(); ++i) {
+      if (!numext::is_exactly_zero(derivatives[i])) {
+        return false;
+      }
+    }
+    return numext::is_exactly_zero(s.value());
+  }
+};
+}  // namespace internal
+}  // namespace Eigen
+
+namespace std {
+
+template <typename T>
+class numeric_limits<Eigen::AutoDiffScalar<T>> : public numeric_limits<typename T::Scalar> {};
+
+template <typename T>
+class numeric_limits<Eigen::AutoDiffScalar<T&>> : public numeric_limits<typename T::Scalar> {};
+
+}  // namespace std
+
+#endif  // EIGEN_AUTODIFF_SCALAR_H
diff --git a/contrib/Eigen/src/AutoDiff/CoherentPadOp.h b/contrib/Eigen/src/AutoDiff/CoherentPadOp.h
new file mode 100644
index 0000000..e97378f
--- /dev/null
+++ b/contrib/Eigen/src/AutoDiff/CoherentPadOp.h
@@ -0,0 +1,155 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2020 The Eigen Team.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_COHERENT_PAD_OP_H
+#define EIGEN_COHERENT_PAD_OP_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// Pads a vector with zeros to a given size.
+template <typename XprType, int SizeAtCompileTime_>
+struct CoherentPadOp;
+
+template <typename XprType, int SizeAtCompileTime_>
+struct traits<CoherentPadOp<XprType, SizeAtCompileTime_>> : public traits<XprType> {
+  typedef internal::remove_all_t<XprType> PlainXprType;
+  typedef typename internal::ref_selector<XprType>::type XprNested;
+  typedef std::remove_reference_t<XprNested> XprNested_;
+  enum : int {
+    IsRowMajor = traits<PlainXprType>::Flags & RowMajorBit,
+    SizeAtCompileTime = SizeAtCompileTime_,
+    RowsAtCompileTime = IsRowMajor ? 1 : SizeAtCompileTime,
+    ColsAtCompileTime = IsRowMajor ? SizeAtCompileTime : 1,
+    MaxRowsAtCompileTime = RowsAtCompileTime,
+    MaxColsAtCompileTime = ColsAtCompileTime,
+    Flags = traits<XprType>::Flags & ~NestByRefBit,
+  };
+};
+
+// Pads a vector with zeros to a given size.
+template <typename XprType, int SizeAtCompileTime_>
+struct CoherentPadOp : public dense_xpr_base<CoherentPadOp<XprType, SizeAtCompileTime_>>::type {
+  typedef typename internal::generic_xpr_base<CoherentPadOp<XprType, SizeAtCompileTime_>>::type Base;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CoherentPadOp)
+
+  using XprNested = typename traits<CoherentPadOp>::XprNested;
+  using XprNested_ = typename traits<CoherentPadOp>::XprNested_;
+  using NestedExpression = XprNested_;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp() = delete;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp(const CoherentPadOp&) = default;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp(CoherentPadOp&& other) = default;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp(const XprType& xpr, Index size) : m_xpr(xpr), m_size(size) {
+    static_assert(XprNested_::IsVectorAtCompileTime, "input type must be a vector");
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const XprNested_& nestedExpression() const { return m_xpr; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_size.value(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const {
+    return traits<CoherentPadOp>::IsRowMajor ? Index(1) : size();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const {
+    return traits<CoherentPadOp>::IsRowMajor ? size() : Index(1);
+  }
+
+ private:
+  XprNested m_xpr;
+  const internal::variable_if_dynamic<Index, SizeAtCompileTime> m_size;
+};
+
+// Adapted from the Replicate evaluator.
+template <typename ArgType, int SizeAtCompileTime>
+struct unary_evaluator<CoherentPadOp<ArgType, SizeAtCompileTime>>
+    : evaluator_base<CoherentPadOp<ArgType, SizeAtCompileTime>> {
+  typedef CoherentPadOp<ArgType, SizeAtCompileTime> XprType;
+  typedef internal::remove_all_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename internal::nested_eval<ArgType, 1>::type ArgTypeNested;
+  typedef internal::remove_all_t<ArgTypeNested> ArgTypeNestedCleaned;
+
+  enum {
+    CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
+    LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
+    Flags = evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits | LinearAccessMask | RowMajorBit),
+    Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& pad)
+      : m_arg(pad.nestedExpression()), m_argImpl(m_arg), m_size(pad.nestedExpression().size()) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
+    EIGEN_IF_CONSTEXPR (XprType::IsRowMajor) {
+      if (col < m_size.value()) {
+        return m_argImpl.coeff(1, col);
+      }
+    } else {
+      if (row < m_size.value()) {
+        return m_argImpl.coeff(row, 1);
+      }
+    }
+    return CoeffReturnType(0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    if (index < m_size.value()) {
+      return m_argImpl.coeff(index);
+    }
+    return CoeffReturnType(0);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
+    // AutoDiff scalar's derivative must be a vector, which is enforced by static assert.
+    // Defer to linear access for simplicity.
+    EIGEN_IF_CONSTEXPR (XprType::IsRowMajor) {
+      return packet(col);
+    }
+    return packet(row);
+  }
+
+  template <int LoadMode, typename PacketType>
+  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
+    constexpr int kPacketSize = unpacket_traits<PacketType>::size;
+    if (index + kPacketSize <= m_size.value()) {
+      return m_argImpl.template packet<LoadMode, PacketType>(index);
+    } else if (index < m_size.value()) {
+      // Partial packet.
+      EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[kPacketSize];
+      const int partial = m_size.value() - index;
+      for (int i = 0; i < partial && i < kPacketSize; ++i) {
+        values[i] = m_argImpl.coeff(index + i);
+      }
+      for (int i = partial; i < kPacketSize; ++i) {
+        values[i] = CoeffReturnType(0);
+      }
+      return pload<PacketType>(values);
+    }
+    return pset1<PacketType>(CoeffReturnType(0));
+  }
+
+ protected:
+  ArgTypeNested m_arg;
+  evaluator<ArgTypeNestedCleaned> m_argImpl;
+  const variable_if_dynamic<Index, ArgTypeNestedCleaned::SizeAtCompileTime> m_size;
+};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_COHERENT_PAD_OP_H
diff --git a/contrib/Eigen/src/AutoDiff/InternalHeaderCheck.h b/contrib/Eigen/src/AutoDiff/InternalHeaderCheck.h
new file mode 100644
index 0000000..dc6c873
--- /dev/null
+++ b/contrib/Eigen/src/AutoDiff/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AUTODIFF_MODULE_H
+#error "Please include contrib/Eigen/AutoDiff instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/BVH/BVAlgorithms.h b/contrib/Eigen/src/BVH/BVAlgorithms.h
new file mode 100644
index 0000000..8918640
--- /dev/null
+++ b/contrib/Eigen/src/BVH/BVAlgorithms.h
@@ -0,0 +1,292 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BVALGORITHMS_H
+#define EIGEN_BVALGORITHMS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename BVH, typename Intersector>
+bool intersect_helper(const BVH &tree, Intersector &intersector, typename BVH::Index root) {
+  typedef typename BVH::Index Index;
+  typedef typename BVH::VolumeIterator VolIter;
+  typedef typename BVH::ObjectIterator ObjIter;
+
+  VolIter vBegin = VolIter(), vEnd = VolIter();
+  ObjIter oBegin = ObjIter(), oEnd = ObjIter();
+
+  std::vector<Index> todo(1, root);
+
+  while (!todo.empty()) {
+    tree.getChildren(todo.back(), vBegin, vEnd, oBegin, oEnd);
+    todo.pop_back();
+
+    for (; vBegin != vEnd; ++vBegin)  // go through child volumes
+      if (intersector.intersectVolume(tree.getVolume(*vBegin))) todo.push_back(*vBegin);
+
+    for (; oBegin != oEnd; ++oBegin)                          // go through child objects
+      if (intersector.intersectObject(*oBegin)) return true;  // intersector said to stop query
+  }
+  return false;
+}
+#endif  // not EIGEN_PARSED_BY_DOXYGEN
+
+template <typename Volume1, typename Object1, typename Object2, typename Intersector>
+struct intersector_helper1 {
+  intersector_helper1(const Object2 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
+  bool intersectVolume(const Volume1 &vol) { return intersector.intersectVolumeObject(vol, stored); }
+  bool intersectObject(const Object1 &obj) { return intersector.intersectObjectObject(obj, stored); }
+  Object2 stored;
+  Intersector &intersector;
+
+ private:
+  intersector_helper1 &operator=(const intersector_helper1 &) = delete;
+};
+
+template <typename Volume2, typename Object2, typename Object1, typename Intersector>
+struct intersector_helper2 {
+  intersector_helper2(const Object1 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
+  bool intersectVolume(const Volume2 &vol) { return intersector.intersectObjectVolume(stored, vol); }
+  bool intersectObject(const Object2 &obj) { return intersector.intersectObjectObject(stored, obj); }
+  Object1 stored;
+  Intersector &intersector;
+
+ private:
+  intersector_helper2 &operator=(const intersector_helper2 &) = delete;
+};
+
+}  // end namespace internal
+
+/**  Given a BVH, runs the query encapsulated by \a intersector.
+  *  The Intersector type must provide the following members: \code
+     bool intersectVolume(const BVH::Volume &volume) //returns true if volume intersects the query
+     bool intersectObject(const BVH::Object &object) //returns true if the search should terminate immediately
+  \endcode
+  */
+template <typename BVH, typename Intersector>
+void BVIntersect(const BVH &tree, Intersector &intersector) {
+  internal::intersect_helper(tree, intersector, tree.getRootIndex());
+}
+
+/**  Given two BVH's, runs the query on their Cartesian product encapsulated by \a intersector.
+  *  The Intersector type must provide the following members: \code
+     bool intersectVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2) //returns true if product of volumes
+  intersects the query bool intersectVolumeObject(const BVH1::Volume &v1, const BVH2::Object &o2) //returns true if the
+  volume-object product intersects the query bool intersectObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)
+  //returns true if the volume-object product intersects the query bool intersectObjectObject(const BVH1::Object &o1,
+  const BVH2::Object &o2) //returns true if the search should terminate immediately \endcode
+  */
+template <typename BVH1, typename BVH2, typename Intersector>
+void BVIntersect(const BVH1 &tree1, const BVH2 &tree2,
+                 Intersector &intersector)  // TODO: tandem descent when it makes sense
+{
+  typedef typename BVH1::Index Index1;
+  typedef typename BVH2::Index Index2;
+  typedef internal::intersector_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object,
+                                        Intersector>
+      Helper1;
+  typedef internal::intersector_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object,
+                                        Intersector>
+      Helper2;
+  typedef typename BVH1::VolumeIterator VolIter1;
+  typedef typename BVH1::ObjectIterator ObjIter1;
+  typedef typename BVH2::VolumeIterator VolIter2;
+  typedef typename BVH2::ObjectIterator ObjIter2;
+
+  VolIter1 vBegin1 = VolIter1(), vEnd1 = VolIter1();
+  ObjIter1 oBegin1 = ObjIter1(), oEnd1 = ObjIter1();
+  VolIter2 vBegin2 = VolIter2(), vEnd2 = VolIter2(), vCur2 = VolIter2();
+  ObjIter2 oBegin2 = ObjIter2(), oEnd2 = ObjIter2(), oCur2 = ObjIter2();
+
+  std::vector<std::pair<Index1, Index2> > todo(1, std::make_pair(tree1.getRootIndex(), tree2.getRootIndex()));
+
+  while (!todo.empty()) {
+    tree1.getChildren(todo.back().first, vBegin1, vEnd1, oBegin1, oEnd1);
+    tree2.getChildren(todo.back().second, vBegin2, vEnd2, oBegin2, oEnd2);
+    todo.pop_back();
+
+    for (; vBegin1 != vEnd1; ++vBegin1) {  // go through child volumes of first tree
+      const typename BVH1::Volume &vol1 = tree1.getVolume(*vBegin1);
+      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
+        if (intersector.intersectVolumeVolume(vol1, tree2.getVolume(*vCur2)))
+          todo.push_back(std::make_pair(*vBegin1, *vCur2));
+      }
+
+      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {  // go through child objects of second tree
+        Helper1 helper(*oCur2, intersector);
+        if (internal::intersect_helper(tree1, helper, *vBegin1)) return;  // intersector said to stop query
+      }
+    }
+
+    for (; oBegin1 != oEnd1; ++oBegin1) {               // go through child objects of first tree
+      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
+        Helper2 helper(*oBegin1, intersector);
+        if (internal::intersect_helper(tree2, helper, *vCur2)) return;  // intersector said to stop query
+      }
+
+      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {                    // go through child objects of second tree
+        if (intersector.intersectObjectObject(*oBegin1, *oCur2)) return;  // intersector said to stop query
+      }
+    }
+  }
+}
+
+namespace internal {
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+template <typename BVH, typename Minimizer>
+typename Minimizer::Scalar minimize_helper(const BVH &tree, Minimizer &minimizer, typename BVH::Index root,
+                                           typename Minimizer::Scalar minimum) {
+  typedef typename Minimizer::Scalar Scalar;
+  typedef typename BVH::Index Index;
+  typedef std::pair<Scalar, Index> QueueElement;  // first element is priority
+  typedef typename BVH::VolumeIterator VolIter;
+  typedef typename BVH::ObjectIterator ObjIter;
+
+  VolIter vBegin = VolIter(), vEnd = VolIter();
+  ObjIter oBegin = ObjIter(), oEnd = ObjIter();
+  std::priority_queue<QueueElement, std::vector<QueueElement>, std::greater<QueueElement> >
+      todo;  // smallest is at the top
+
+  todo.push(std::make_pair(Scalar(), root));
+
+  while (!todo.empty()) {
+    tree.getChildren(todo.top().second, vBegin, vEnd, oBegin, oEnd);
+    todo.pop();
+
+    for (; oBegin != oEnd; ++oBegin)  // go through child objects
+      minimum = (std::min)(minimum, minimizer.minimumOnObject(*oBegin));
+
+    for (; vBegin != vEnd; ++vBegin) {  // go through child volumes
+      Scalar val = minimizer.minimumOnVolume(tree.getVolume(*vBegin));
+      if (val < minimum) todo.push(std::make_pair(val, *vBegin));
+    }
+  }
+
+  return minimum;
+}
+#endif  // not EIGEN_PARSED_BY_DOXYGEN
+
+template <typename Volume1, typename Object1, typename Object2, typename Minimizer>
+struct minimizer_helper1 {
+  typedef typename Minimizer::Scalar Scalar;
+  minimizer_helper1(const Object2 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
+  Scalar minimumOnVolume(const Volume1 &vol) { return minimizer.minimumOnVolumeObject(vol, stored); }
+  Scalar minimumOnObject(const Object1 &obj) { return minimizer.minimumOnObjectObject(obj, stored); }
+  Object2 stored;
+  Minimizer &minimizer;
+
+ private:
+  minimizer_helper1 &operator=(const minimizer_helper1 &) = delete;
+};
+
+template <typename Volume2, typename Object2, typename Object1, typename Minimizer>
+struct minimizer_helper2 {
+  typedef typename Minimizer::Scalar Scalar;
+  minimizer_helper2(const Object1 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
+  Scalar minimumOnVolume(const Volume2 &vol) { return minimizer.minimumOnObjectVolume(stored, vol); }
+  Scalar minimumOnObject(const Object2 &obj) { return minimizer.minimumOnObjectObject(stored, obj); }
+  Object1 stored;
+  Minimizer &minimizer;
+
+ private:
+  minimizer_helper2 &operator=(const minimizer_helper2 &) = delete;
+};
+
+}  // end namespace internal
+
+/**  Given a BVH, runs the query encapsulated by \a minimizer.
+  *  \returns the minimum value.
+  *  The Minimizer type must provide the following members: \code
+     typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has
+  one) Scalar minimumOnVolume(const BVH::Volume &volume) Scalar minimumOnObject(const BVH::Object &object) \endcode
+  */
+template <typename BVH, typename Minimizer>
+typename Minimizer::Scalar BVMinimize(const BVH &tree, Minimizer &minimizer) {
+  return internal::minimize_helper(tree, minimizer, tree.getRootIndex(),
+                                   (std::numeric_limits<typename Minimizer::Scalar>::max)());
+}
+
+/**  Given two BVH's, runs the query on their Cartesian product encapsulated by \a minimizer.
+  *  \returns the minimum value.
+  *  The Minimizer type must provide the following members: \code
+     typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has
+  one) Scalar minimumOnVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2) Scalar minimumOnVolumeObject(const
+  BVH1::Volume &v1, const BVH2::Object &o2) Scalar minimumOnObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)
+     Scalar minimumOnObjectObject(const BVH1::Object &o1, const BVH2::Object &o2)
+  \endcode
+  */
+template <typename BVH1, typename BVH2, typename Minimizer>
+typename Minimizer::Scalar BVMinimize(const BVH1 &tree1, const BVH2 &tree2, Minimizer &minimizer) {
+  typedef typename Minimizer::Scalar Scalar;
+  typedef typename BVH1::Index Index1;
+  typedef typename BVH2::Index Index2;
+  typedef internal::minimizer_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Minimizer>
+      Helper1;
+  typedef internal::minimizer_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Minimizer>
+      Helper2;
+  typedef std::pair<Scalar, std::pair<Index1, Index2> > QueueElement;  // first element is priority
+  typedef typename BVH1::VolumeIterator VolIter1;
+  typedef typename BVH1::ObjectIterator ObjIter1;
+  typedef typename BVH2::VolumeIterator VolIter2;
+  typedef typename BVH2::ObjectIterator ObjIter2;
+
+  VolIter1 vBegin1 = VolIter1(), vEnd1 = VolIter1();
+  ObjIter1 oBegin1 = ObjIter1(), oEnd1 = ObjIter1();
+  VolIter2 vBegin2 = VolIter2(), vEnd2 = VolIter2(), vCur2 = VolIter2();
+  ObjIter2 oBegin2 = ObjIter2(), oEnd2 = ObjIter2(), oCur2 = ObjIter2();
+  std::priority_queue<QueueElement, std::vector<QueueElement>, std::greater<QueueElement> >
+      todo;  // smallest is at the top
+
+  Scalar minimum = (std::numeric_limits<Scalar>::max)();
+  todo.push(std::make_pair(Scalar(), std::make_pair(tree1.getRootIndex(), tree2.getRootIndex())));
+
+  while (!todo.empty()) {
+    tree1.getChildren(todo.top().second.first, vBegin1, vEnd1, oBegin1, oEnd1);
+    tree2.getChildren(todo.top().second.second, vBegin2, vEnd2, oBegin2, oEnd2);
+    todo.pop();
+
+    for (; oBegin1 != oEnd1; ++oBegin1) {               // go through child objects of first tree
+      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {  // go through child objects of second tree
+        minimum = (std::min)(minimum, minimizer.minimumOnObjectObject(*oBegin1, *oCur2));
+      }
+
+      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
+        Helper2 helper(*oBegin1, minimizer);
+        minimum = (std::min)(minimum, internal::minimize_helper(tree2, helper, *vCur2, minimum));
+      }
+    }
+
+    for (; vBegin1 != vEnd1; ++vBegin1) {  // go through child volumes of first tree
+      const typename BVH1::Volume &vol1 = tree1.getVolume(*vBegin1);
+
+      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {  // go through child objects of second tree
+        Helper1 helper(*oCur2, minimizer);
+        minimum = (std::min)(minimum, internal::minimize_helper(tree1, helper, *vBegin1, minimum));
+      }
+
+      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
+        Scalar val = minimizer.minimumOnVolumeVolume(vol1, tree2.getVolume(*vCur2));
+        if (val < minimum) todo.push(std::make_pair(val, std::make_pair(*vBegin1, *vCur2)));
+      }
+    }
+  }
+  return minimum;
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BVALGORITHMS_H
diff --git a/contrib/Eigen/src/BVH/InternalHeaderCheck.h b/contrib/Eigen/src/BVH/InternalHeaderCheck.h
new file mode 100644
index 0000000..8b68259
--- /dev/null
+++ b/contrib/Eigen/src/BVH/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BVH_MODULE_H
+#error "Please include contrib/Eigen/BVH instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/BVH/KdBVH.h b/contrib/Eigen/src/BVH/KdBVH.h
new file mode 100644
index 0000000..8880930
--- /dev/null
+++ b/contrib/Eigen/src/BVH/KdBVH.h
@@ -0,0 +1,224 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef KDBVH_H_INCLUDED
+#define KDBVH_H_INCLUDED
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// internal pair class for the BVH--used instead of std::pair because of alignment
+template <typename Scalar, int Dim>
+struct vector_int_pair {
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Dim)
+  typedef Matrix<Scalar, Dim, 1> VectorType;
+
+  vector_int_pair(const VectorType &v, int i) : first(v), second(i) {}
+
+  VectorType first;
+  int second;
+};
+
+// these templates help the tree initializer get the bounding boxes either from a provided
+// iterator range or using bounding_box in a unified way
+template <typename ObjectList, typename VolumeList, typename BoxIter>
+struct get_boxes_helper {
+  void operator()(const ObjectList &objects, BoxIter boxBegin, BoxIter boxEnd, VolumeList &outBoxes) const {
+    outBoxes.insert(outBoxes.end(), boxBegin, boxEnd);
+    eigen_assert(outBoxes.size() == objects.size());
+    EIGEN_ONLY_USED_FOR_DEBUG(objects);
+  }
+};
+
+template <typename ObjectList, typename VolumeList>
+struct get_boxes_helper<ObjectList, VolumeList, int> {
+  void operator()(const ObjectList &objects, int, int, VolumeList &outBoxes) const {
+    outBoxes.reserve(objects.size());
+    for (int i = 0; i < (int)objects.size(); ++i) outBoxes.push_back(bounding_box(objects[i]));
+  }
+};
+
+}  // end namespace internal
+
+/** \class KdBVH
+ *  \brief A simple bounding volume hierarchy based on AlignedBox
+ *
+ *  \param Scalar_ The underlying scalar type of the bounding boxes
+ *  \param Dim_ The dimension of the space in which the hierarchy lives
+ *  \param Object_ The object type that lives in the hierarchy.  It must have value semantics.  Either
+ *                 `bounding_box(Object_)` must be defined and return an `AlignedBox<Scalar_, Dim_>` or bounding boxes
+ *                  must be provided to the tree initializer.
+ *
+ * This class provides a simple (as opposed to optimized) implementation of a bounding volume hierarchy analogous to a
+ * Kd-tree. Given a sequence of objects, it computes their bounding boxes, constructs a Kd-tree of their centers and
+ * builds a BVH with the structure of that Kd-tree.  When the elements of the tree are too expensive to be copied
+ * around, it is useful for `Object_` to be a pointer.
+ */
+template <typename Scalar_, int Dim_, typename Object_>
+class KdBVH {
+ public:
+  enum { Dim = Dim_ };
+  typedef Object_ Object;
+  typedef std::vector<Object, aligned_allocator<Object> > ObjectList;
+  typedef Scalar_ Scalar;
+  typedef AlignedBox<Scalar, Dim> Volume;
+  typedef std::vector<Volume, aligned_allocator<Volume> > VolumeList;
+  typedef int Index;
+  typedef const int *VolumeIterator;  // the iterators are just pointers into the tree's vectors
+  typedef const Object *ObjectIterator;
+
+  KdBVH() = default;
+
+  /** Given an iterator range over \a Object references, constructs the BVH.  Requires that bounding_box(Object) return
+   * a Volume. */
+  template <typename Iter>
+  KdBVH(Iter begin, Iter end) {
+    init(begin, end, 0, 0);
+  }  // int is recognized by init as not being an iterator type
+
+  /** Given an iterator range over \a Object references and an iterator range over their bounding boxes, constructs the
+   * BVH */
+  template <typename OIter, typename BIter>
+  KdBVH(OIter begin, OIter end, BIter boxBegin, BIter boxEnd) {
+    init(begin, end, boxBegin, boxEnd);
+  }
+
+  /** Given an iterator range over \a Object references, constructs the BVH, overwriting whatever is in there currently.
+   * Requires that bounding_box(Object) return a Volume. */
+  template <typename Iter>
+  void init(Iter begin, Iter end) {
+    init(begin, end, 0, 0);
+  }
+
+  /** Given an iterator range over \a Object references and an iterator range over their bounding boxes,
+   * constructs the BVH, overwriting whatever is in there currently. */
+  template <typename OIter, typename BIter>
+  void init(OIter begin, OIter end, BIter boxBegin, BIter boxEnd) {
+    objects.clear();
+    boxes.clear();
+    children.clear();
+
+    objects.insert(objects.end(), begin, end);
+    int n = static_cast<int>(objects.size());
+
+    if (n < 2) return;  // if we have at most one object, we don't need any internal nodes
+
+    VolumeList objBoxes;
+    VIPairList objCenters;
+
+    // compute the bounding boxes depending on BIter type
+    internal::get_boxes_helper<ObjectList, VolumeList, BIter>()(objects, boxBegin, boxEnd, objBoxes);
+
+    objCenters.reserve(n);
+    boxes.reserve(n - 1);
+    children.reserve(2 * n - 2);
+
+    for (int i = 0; i < n; ++i) objCenters.push_back(VIPair(objBoxes[i].center(), i));
+
+    build(objCenters, 0, n, objBoxes, 0);  // the recursive part of the algorithm
+
+    ObjectList tmp(n);
+    tmp.swap(objects);
+    for (int i = 0; i < n; ++i) objects[i] = tmp[objCenters[i].second];
+  }
+
+  /** \returns the index of the root of the hierarchy */
+  inline Index getRootIndex() const { return (int)boxes.size() - 1; }
+
+  /** Given an \a index of a node, on exit, \a outVBegin and \a outVEnd range over the indices of the volume children of
+   * the node and \a outOBegin and \a outOEnd range over the object children of the node */
+  EIGEN_STRONG_INLINE void getChildren(Index index, VolumeIterator &outVBegin, VolumeIterator &outVEnd,
+                                       ObjectIterator &outOBegin, ObjectIterator &outOEnd)
+      const {  // inlining this function should open lots of optimization opportunities to the compiler
+    if (index < 0) {
+      outVBegin = outVEnd;
+      if (!objects.empty()) outOBegin = &(objects[0]);
+      outOEnd = outOBegin + objects.size();  // output all objects--necessary when the tree has only one object
+      return;
+    }
+
+    int numBoxes = static_cast<int>(boxes.size());
+
+    int idx = index * 2;
+    if (children[idx + 1] < numBoxes) {  // second index is always bigger
+      outVBegin = &(children[idx]);
+      outVEnd = outVBegin + 2;
+      outOBegin = outOEnd;
+    } else if (children[idx] >= numBoxes) {  // if both children are objects
+      outVBegin = outVEnd;
+      outOBegin = &(objects[children[idx] - numBoxes]);
+      outOEnd = outOBegin + 2;
+    } else {  // if the first child is a volume and the second is an object
+      outVBegin = &(children[idx]);
+      outVEnd = outVBegin + 1;
+      outOBegin = &(objects[children[idx + 1] - numBoxes]);
+      outOEnd = outOBegin + 1;
+    }
+  }
+
+  /** \returns the bounding box of the node at \a index */
+  inline const Volume &getVolume(Index index) const { return boxes[index]; }
+
+ private:
+  typedef internal::vector_int_pair<Scalar, Dim> VIPair;
+  typedef std::vector<VIPair, aligned_allocator<VIPair> > VIPairList;
+  typedef Matrix<Scalar, Dim, 1> VectorType;
+  struct VectorComparator  // compares vectors, or more specifically, VIPairs along a particular dimension
+  {
+    VectorComparator(int inDim) : dim(inDim) {}
+    inline bool operator()(const VIPair &v1, const VIPair &v2) const { return v1.first[dim] < v2.first[dim]; }
+    int dim;
+  };
+
+  // Build the part of the tree between objects[from] and objects[to] (not including objects[to]).
+  // This routine partitions the objCenters in [from, to) along the dimension dim, recursively constructs
+  // the two halves, and adds their parent node.  TODO: a cache-friendlier layout
+  void build(VIPairList &objCenters, int from, int to, const VolumeList &objBoxes, int dim) {
+    eigen_assert(to - from > 1);
+    if (to - from == 2) {
+      boxes.push_back(objBoxes[objCenters[from].second].merged(objBoxes[objCenters[from + 1].second]));
+      children.push_back(from + (int)objects.size() - 1);  // there are objects.size() - 1 tree nodes
+      children.push_back(from + (int)objects.size());
+    } else if (to - from == 3) {
+      int mid = from + 2;
+      std::nth_element(objCenters.begin() + from, objCenters.begin() + mid, objCenters.begin() + to,
+                       VectorComparator(dim));  // partition
+      build(objCenters, from, mid, objBoxes, (dim + 1) % Dim);
+      int idx1 = (int)boxes.size() - 1;
+      boxes.push_back(boxes[idx1].merged(objBoxes[objCenters[mid].second]));
+      children.push_back(idx1);
+      children.push_back(mid + (int)objects.size() - 1);
+    } else {
+      int mid = from + (to - from) / 2;
+      nth_element(objCenters.begin() + from, objCenters.begin() + mid, objCenters.begin() + to,
+                  VectorComparator(dim));  // partition
+      build(objCenters, from, mid, objBoxes, (dim + 1) % Dim);
+      int idx1 = (int)boxes.size() - 1;
+      build(objCenters, mid, to, objBoxes, (dim + 1) % Dim);
+      int idx2 = (int)boxes.size() - 1;
+      boxes.push_back(boxes[idx1].merged(boxes[idx2]));
+      children.push_back(idx1);
+      children.push_back(idx2);
+    }
+  }
+
+  std::vector<int> children;  // children of x are children[2x] and children[2x+1], indices bigger than boxes.size()
+                              // index into objects.
+  VolumeList boxes;
+  ObjectList objects;
+};
+
+}  // end namespace Eigen
+
+#endif  // KDBVH_H_INCLUDED
diff --git a/contrib/Eigen/src/EulerAngles/CMakeLists.txt b/contrib/Eigen/src/EulerAngles/CMakeLists.txt
new file mode 100644
index 0000000..a40ac07
--- /dev/null
+++ b/contrib/Eigen/src/EulerAngles/CMakeLists.txt
@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+file(GLOB Eigen_EulerAngles_SRCS "*.h")
+
+if(EIGEN_INSTALL)
+  install(FILES
+    ${Eigen_EulerAngles_SRCS}
+    DESTINATION ${INCLUDE_INSTALL_DIR}/contrib/Eigen/src/EulerAngles COMPONENT Devel
+    )
+endif()
diff --git a/contrib/Eigen/src/EulerAngles/EulerAngles.h b/contrib/Eigen/src/EulerAngles/EulerAngles.h
new file mode 100644
index 0000000..ccb3a6a
--- /dev/null
+++ b/contrib/Eigen/src/EulerAngles/EulerAngles.h
@@ -0,0 +1,361 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_EULERANGLESCLASS_H  // TODO: Fix previous "EIGEN_EULERANGLES_H" definition?
+#define EIGEN_EULERANGLESCLASS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+/** \class EulerAngles
+ *
+ * \ingroup EulerAngles_Module
+ *
+ * \brief Represents a rotation in a 3 dimensional space as three Euler angles.
+ *
+ * Euler rotation is a set of three rotation of three angles over three fixed axes, defined by the EulerSystem given as
+ * a template parameter.
+ *
+ * Here is how intrinsic Euler angles works:
+ *  - first, rotate the axes system over the alpha axis in angle alpha
+ *  - then, rotate the axes system over the beta axis(which was rotated in the first stage) in angle beta
+ *  - then, rotate the axes system over the gamma axis(which was rotated in the two stages above) in angle gamma
+ *
+ * \note This class supports only intrinsic Euler angles for simplicity,
+ *  see EulerSystem how to easily overcome this for extrinsic systems.
+ *
+ * ### Rotation representation and conversions ###
+ *
+ * It has been proved(see Wikipedia link below) that every rotation can be represented
+ *  by Euler angles, but there is no single representation (e.g. unlike rotation matrices).
+ * Therefore, you can convert from Eigen rotation and to them
+ *  (including rotation matrices, which is not called "rotations" by Eigen design).
+ *
+ * Euler angles usually used for:
+ *  - convenient human representation of rotation, especially in interactive GUI.
+ *  - gimbal systems and robotics
+ *  - efficient encoding(i.e. 3 floats only) of rotation for network protocols.
+ *
+ * However, Euler angles are slow compared to quaternion or matrices,
+ *  because of their unnatural math definition, although it's simple for human.
+ * To overcome this, this class provides easy movement from the math friendly representation
+ *  to the human friendly representation, and vice-versa.
+ *
+ * All the user needs to do is a safe simple C++ type conversion,
+ *  and this class takes care of the math.
+ * Additionally, some axes related computation is done in compile time.
+ *
+ * #### Euler angles ranges in conversions ####
+ * Rotations representation as EulerAngles are not single (unlike matrices),
+ *  and even have infinite EulerAngles representations.<BR>
+ * For example, add or subtract 2*PI from either angle of EulerAngles
+ *  and you'll get the same rotation.
+ * This is the general reason for infinite representation,
+ *  but it's not the only general reason for not having a single representation.
+ *
+ * When converting rotation to EulerAngles, this class converts it to specific ranges
+ * When converting some rotation to EulerAngles, the rules for ranges are as follows:
+ * - If the rotation we converting from is an EulerAngles
+ *  (even when it represented as RotationBase explicitly), angles ranges are __undefined__.
+ * - otherwise, alpha and gamma angles will be in the range [-PI, PI].<BR>
+ *   As for Beta angle:
+ *    - If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
+ *    - otherwise:
+ *      - If the beta axis is positive, the beta angle will be in the range [0, PI]
+ *      - If the beta axis is negative, the beta angle will be in the range [-PI, 0]
+ *
+ * \sa EulerAngles(const MatrixBase<Derived>&)
+ * \sa EulerAngles(const RotationBase<Derived, 3>&)
+ *
+ * ### Convenient user typedefs ###
+ *
+ * Convenient typedefs for EulerAngles exist for float and double scalar,
+ *  in a form of EulerAngles{A}{B}{C}{scalar},
+ *  e.g. \ref EulerAnglesXYZd, \ref EulerAnglesZYZf.
+ *
+ * Only for positive axes{+x,+y,+z} Euler systems have a convenient typedef.
+ * If you need negative axes{-x,-y,-z}, it is recommended to create your own typedef with
+ *  a word that represent what you need.
+ *
+ * ### Example ###
+ *
+ * \include EulerAngles.cpp
+ * Output: \verbinclude EulerAngles.out
+ *
+ * ### Additional reading ###
+ *
+ * If you want to get more idea about how Euler systems work in Eigen see EulerSystem.
+ *
+ * More information about Euler angles: https://en.wikipedia.org/wiki/Euler_angles
+ *
+ * \tparam Scalar_ the scalar type, i.e. the type of the angles.
+ *
+ * \tparam _System the EulerSystem to use, which represents the axes of rotation.
+ */
+template <typename Scalar_, class _System>
+class EulerAngles : public RotationBase<EulerAngles<Scalar_, _System>, 3> {
+ public:
+  typedef RotationBase<EulerAngles<Scalar_, _System>, 3> Base;
+
+  /** the scalar type of the angles */
+  typedef Scalar_ Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  /** the EulerSystem to use, which represents the axes of rotation. */
+  typedef _System System;
+
+  typedef Matrix<Scalar, 3, 3> Matrix3;      /*!< the equivalent rotation matrix type */
+  typedef Matrix<Scalar, 3, 1> Vector3;      /*!< the equivalent 3 dimension vector type */
+  typedef Quaternion<Scalar> QuaternionType; /*!< the equivalent quaternion type */
+  typedef AngleAxis<Scalar> AngleAxisType;   /*!< the equivalent angle-axis type */
+
+  /** \returns the axis vector of the first (alpha) rotation */
+  static Vector3 AlphaAxisVector() {
+    const Vector3& u = Vector3::Unit(System::AlphaAxisAbs - 1);
+    return System::IsAlphaOpposite ? -u : u;
+  }
+
+  /** \returns the axis vector of the second (beta) rotation */
+  static Vector3 BetaAxisVector() {
+    const Vector3& u = Vector3::Unit(System::BetaAxisAbs - 1);
+    return System::IsBetaOpposite ? -u : u;
+  }
+
+  /** \returns the axis vector of the third (gamma) rotation */
+  static Vector3 GammaAxisVector() {
+    const Vector3& u = Vector3::Unit(System::GammaAxisAbs - 1);
+    return System::IsGammaOpposite ? -u : u;
+  }
+
+ private:
+  Vector3 m_angles;
+
+ public:
+  /** Default constructor without initialization. */
+  EulerAngles() {}
+  /** Constructs and initialize an EulerAngles (\p alpha, \p beta, \p gamma). */
+  EulerAngles(const Scalar& alpha, const Scalar& beta, const Scalar& gamma) : m_angles(alpha, beta, gamma) {}
+
+  // TODO: Test this constructor
+  /** Constructs and initialize an EulerAngles from the array data {alpha, beta, gamma} */
+  explicit EulerAngles(const Scalar* data) : m_angles(data) {}
+
+  /** Constructs and initializes an EulerAngles from either:
+   *  - a 3x3 rotation matrix expression(i.e. pure orthogonal matrix with determinant of +1),
+   *  - a 3D vector expression representing Euler angles.
+   *
+   * \note If \p other is a 3x3 rotation matrix, the angles range rules will be as follows:<BR>
+   *  Alpha and gamma angles will be in the range [-PI, PI].<BR>
+   *  As for Beta angle:
+   *   - If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
+   *   - otherwise:
+   *     - If the beta axis is positive, the beta angle will be in the range [0, PI]
+   *     - If the beta axis is negative, the beta angle will be in the range [-PI, 0]
+   */
+  template <typename Derived>
+  explicit EulerAngles(const MatrixBase<Derived>& other) {
+    *this = other;
+  }
+
+  /** Constructs and initialize Euler angles from a rotation \p rot.
+   *
+   * \note If \p rot is an EulerAngles (even when it represented as RotationBase explicitly),
+   *  angles ranges are __undefined__.
+   *  Otherwise, alpha and gamma angles will be in the range [-PI, PI].<BR>
+   *  As for Beta angle:
+   *   - If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
+   *   - otherwise:
+   *     - If the beta axis is positive, the beta angle will be in the range [0, PI]
+   *     - If the beta axis is negative, the beta angle will be in the range [-PI, 0]
+   */
+  template <typename Derived>
+  EulerAngles(const RotationBase<Derived, 3>& rot) {
+    System::CalcEulerAngles(*this, rot.toRotationMatrix());
+  }
+
+  /*EulerAngles(const QuaternionType& q)
+  {
+    // TODO: Implement it in a faster way for quaternions
+    // According to http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/
+    //  we can compute only the needed matrix cells and then convert to euler angles. (see ZYX example below)
+    // Currently we compute all matrix cells from quaternion.
+
+    // Special case only for ZYX
+    //Scalar y2 = q.y() * q.y();
+    //m_angles[0] = std::atan2(2*(q.w()*q.z() + q.x()*q.y()), (1 - 2*(y2 + q.z()*q.z())));
+    //m_angles[1] = std::asin( 2*(q.w()*q.y() - q.z()*q.x()));
+    //m_angles[2] = std::atan2(2*(q.w()*q.x() + q.y()*q.z()), (1 - 2*(q.x()*q.x() + y2)));
+  }*/
+
+  /** \returns The angle values stored in a vector (alpha, beta, gamma). */
+  const Vector3& angles() const { return m_angles; }
+  /** \returns A read-write reference to the angle values stored in a vector (alpha, beta, gamma). */
+  Vector3& angles() { return m_angles; }
+
+  /** \returns The value of the first angle. */
+  Scalar alpha() const { return m_angles[0]; }
+  /** \returns A read-write reference to the angle of the first angle. */
+  Scalar& alpha() { return m_angles[0]; }
+
+  /** \returns The value of the second angle. */
+  Scalar beta() const { return m_angles[1]; }
+  /** \returns A read-write reference to the angle of the second angle. */
+  Scalar& beta() { return m_angles[1]; }
+
+  /** \returns The value of the third angle. */
+  Scalar gamma() const { return m_angles[2]; }
+  /** \returns A read-write reference to the angle of the third angle. */
+  Scalar& gamma() { return m_angles[2]; }
+
+  /** \returns The Euler angles with each angle negated, (-alpha, -beta, -gamma).
+   *
+   * \note In general these angles do not describe the inverse rotation: inverting
+   * \f$ R = R_\alpha R_\beta R_\gamma \f$ also reverses the order of the three factors. They do describe it
+   * whenever the three elemental rotations commute, for instance when at most one of the angles is nonzero,
+   * and, for a system whose first and third axes coincide (a proper Euler system such as ZXZ), whenever
+   * \f$ \alpha = \gamma \f$, for any \f$ \beta \f$.
+   */
+  EulerAngles inverse() const {
+    EulerAngles res;
+    res.m_angles = -m_angles;
+    return res;
+  }
+
+  /** \returns The Euler angles negative (which is the same as inverse()),
+   *  (-alpha, -beta, -gamma).
+   *
+   * \sa inverse()
+   */
+  EulerAngles operator-() const { return inverse(); }
+
+  /** Set \c *this from either:
+   *  - a 3x3 rotation matrix expression(i.e. pure orthogonal matrix with determinant of +1),
+   *  - a 3D vector expression representing Euler angles.
+   *
+   * See EulerAngles(const MatrixBase<Derived, 3>&) for more information about
+   *  angles ranges output.
+   */
+  template <class Derived>
+  EulerAngles& operator=(const MatrixBase<Derived>& other) {
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<Scalar, typename Derived::Scalar>::value),
+        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
+
+    internal::eulerangles_assign_impl<System, Derived>::run(*this, other.derived());
+    return *this;
+  }
+
+  // TODO: Assign and construct from another EulerAngles (with different system)
+
+  /** Set \c *this from a rotation.
+   *
+   * See EulerAngles(const RotationBase<Derived, 3>&) for more information about
+   *  angles ranges output.
+   */
+  template <typename Derived>
+  EulerAngles& operator=(const RotationBase<Derived, 3>& rot) {
+    System::CalcEulerAngles(*this, rot.toRotationMatrix());
+    return *this;
+  }
+
+  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
+   * determined by \a prec.
+   *
+   * \sa MatrixBase::isApprox() */
+  bool isApprox(const EulerAngles& other, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const {
+    return angles().isApprox(other.angles(), prec);
+  }
+
+  /** \returns an equivalent 3x3 rotation matrix. */
+  Matrix3 toRotationMatrix() const {
+    // TODO: Calc it faster
+    return static_cast<QuaternionType>(*this).toRotationMatrix();
+  }
+
+  /** Convert the Euler angles to quaternion. */
+  operator QuaternionType() const {
+    return AngleAxisType(alpha(), AlphaAxisVector()) * AngleAxisType(beta(), BetaAxisVector()) *
+           AngleAxisType(gamma(), GammaAxisVector());
+  }
+
+  friend std::ostream& operator<<(std::ostream& s, const EulerAngles<Scalar, System>& eulerAngles) {
+    s << eulerAngles.angles().transpose();
+    return s;
+  }
+
+  /** \returns \c *this with scalar type casted to \a NewScalarType */
+  template <typename NewScalarType>
+  EulerAngles<NewScalarType, System> cast() const {
+    EulerAngles<NewScalarType, System> e;
+    e.angles() = angles().template cast<NewScalarType>();
+    return e;
+  }
+};
+
+#define EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(AXES, SCALAR_TYPE, SCALAR_POSTFIX) \
+  /** \ingroup EulerAngles_Module */                                         \
+  typedef EulerAngles<SCALAR_TYPE, EulerSystem##AXES> EulerAngles##AXES##SCALAR_POSTFIX;
+
+#define EIGEN_EULER_ANGLES_TYPEDEFS(SCALAR_TYPE, SCALAR_POSTFIX)      \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XYZ, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XYX, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XZY, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XZX, SCALAR_TYPE, SCALAR_POSTFIX) \
+                                                                      \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YZX, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YZY, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YXZ, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YXY, SCALAR_TYPE, SCALAR_POSTFIX) \
+                                                                      \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZXY, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZXZ, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZYX, SCALAR_TYPE, SCALAR_POSTFIX) \
+  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZYZ, SCALAR_TYPE, SCALAR_POSTFIX)
+
+EIGEN_EULER_ANGLES_TYPEDEFS(float, f)
+EIGEN_EULER_ANGLES_TYPEDEFS(double, d)
+
+#undef EIGEN_EULER_ANGLES_TYPEDEFS
+#undef EIGEN_EULER_ANGLES_SINGLE_TYPEDEF
+
+// Specifically-referenced instantiations.
+/** \typedef EulerAnglesXYZd
+ * \ingroup EulerAngles_Module
+ * Euler XYZ system with type double entries.
+ */
+/** \typedef EulerAnglesZYZf
+ * \ingroup EulerAngles_Module
+ * Euler ZYZ system with type float entries.
+ */
+
+namespace internal {
+template <typename Scalar_, class _System>
+struct traits<EulerAngles<Scalar_, _System> > {
+  typedef Scalar_ Scalar;
+};
+
+// set from a rotation matrix
+template <class System, class Other>
+struct eulerangles_assign_impl<System, Other, 3, 3> {
+  typedef typename Other::Scalar Scalar;
+  static void run(EulerAngles<Scalar, System>& e, const Other& m) { System::CalcEulerAngles(e, m); }
+};
+
+// set from a vector of Euler angles
+template <class System, class Other>
+struct eulerangles_assign_impl<System, Other, 3, 1> {
+  typedef typename Other::Scalar Scalar;
+  static void run(EulerAngles<Scalar, System>& e, const Other& vec) { e.angles() = vec; }
+};
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_EULERANGLESCLASS_H
diff --git a/contrib/Eigen/src/EulerAngles/EulerSystem.h b/contrib/Eigen/src/EulerAngles/EulerSystem.h
new file mode 100644
index 0000000..ca369f3
--- /dev/null
+++ b/contrib/Eigen/src/EulerAngles/EulerSystem.h
@@ -0,0 +1,203 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_EULERSYSTEM_H
+#define EIGEN_EULERSYSTEM_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+// Forward declarations
+template <typename Scalar_, class _System>
+class EulerAngles;
+
+namespace internal {
+// TODO: Add this trait to the Eigen internal API?
+template <int Num, bool IsPositive = (Num > 0)>
+struct Abs : std::integral_constant<int, Num> {};
+
+template <int Num>
+struct Abs<Num, false> : std::integral_constant<int, -Num> {};
+
+template <int Axis>
+struct IsValidAxis : bool_constant<Axis != 0 && Abs<Axis>::value <= 3> {};
+
+template <typename System, typename Other, int OtherRows = Other::RowsAtCompileTime,
+          int OtherCols = Other::ColsAtCompileTime>
+struct eulerangles_assign_impl;
+}  // namespace internal
+
+#define EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(COND, MSG) typedef char static_assertion_##MSG[(COND) ? 1 : -1]
+
+/** \brief Representation of a fixed signed rotation axis for EulerSystem.
+ *
+ * \ingroup EulerAngles_Module
+ *
+ * Values here represent:
+ *  - The axis of the rotation: X, Y or Z.
+ *  - The sign (i.e. direction of the rotation along the axis): positive(+) or negative(-)
+ *
+ * Therefore, this could express all the axes {+X,+Y,+Z,-X,-Y,-Z}
+ *
+ * For positive axis, use +EULER_{axis}, and for negative axis use -EULER_{axis}.
+ */
+enum EulerAxis {
+  EULER_X = 1, /*!< the X axis */
+  EULER_Y = 2, /*!< the Y axis */
+  EULER_Z = 3  /*!< the Z axis */
+};
+
+/** \class EulerSystem
+ *
+ * \ingroup EulerAngles_Module
+ *
+ * \brief Represents a fixed Euler rotation system.
+ *
+ * This meta-class goal is to represent the Euler system in compilation time, for EulerAngles.
+ *
+ * You can use this class to get two things:
+ *  - Build an Euler system, and then pass it as a template parameter to EulerAngles.
+ *  - Query some compile time data about an Euler system. (e.g. Whether it's Tait-Bryan)
+ *
+ * Euler rotation is a set of three rotation on fixed axes. (see \ref EulerAngles)
+ * This meta-class store constantly those signed axes. (see \ref EulerAxis)
+ *
+ * ### Types of Euler systems ###
+ *
+ * All and only valid 3 dimension Euler rotation over standard
+ *  signed axes{+X,+Y,+Z,-X,-Y,-Z} are supported:
+ *  - all axes X, Y, Z in each valid order (see below what order is valid)
+ *  - rotation over the axis is supported both over the positive and negative directions.
+ *  - both Tait-Bryan and proper/classic Euler angles (i.e. the opposite).
+ *
+ * Since EulerSystem support both positive and negative directions,
+ *  you may call this rotation distinction in other names:
+ *  - _right handed_ or _left handed_
+ *  - _counterclockwise_ or _clockwise_
+ *
+ * Notice not all axes combinations are valid, and invalid ones would trigger a static assertion.
+ * Same unsigned axes can't be neighbors, e.g. {X,X,Y} is invalid.
+ * This yields two and only two classes:
+ *  - _Tait-Bryan_ - all unsigned axes are distinct, e.g. {X,Y,Z}
+ *  - _proper/classic Euler angles_ - The first and the third unsigned axes are equal,
+ *     and the second is different, e.g. {X,Y,X}
+ *
+ * ### Intrinsic vs extrinsic Euler systems ###
+ *
+ * Only intrinsic Euler systems are supported for simplicity.
+ *  If you want to use extrinsic Euler systems,
+ *   just use the equal intrinsic opposite order for axes and angles.
+ *  I.e axes (A,B,C) becomes (C,B,A), and angles (a,b,c) becomes (c,b,a).
+ *
+ * ### Convenient user typedefs ###
+ *
+ * Convenient typedefs for EulerSystem exist (only for positive axes Euler systems),
+ *  in a form of EulerSystem{A}{B}{C}, e.g. \ref EulerSystemXYZ.
+ *
+ * ### Additional reading ###
+ *
+ * More information about Euler angles: https://en.wikipedia.org/wiki/Euler_angles
+ *
+ * \tparam _AlphaAxis the first fixed EulerAxis
+ *
+ * \tparam _BetaAxis the second fixed EulerAxis
+ *
+ * \tparam _GammaAxis the third fixed EulerAxis
+ */
+template <int _AlphaAxis, int _BetaAxis, int _GammaAxis>
+class EulerSystem {
+ public:
+  // Defined as static constexpr rather than enum to ensure support for negative values.
+
+  /** The first rotation axis */
+  static constexpr int AlphaAxis = _AlphaAxis;
+
+  /** The second rotation axis */
+  static constexpr int BetaAxis = _BetaAxis;
+
+  /** The third rotation axis */
+  static constexpr int GammaAxis = _GammaAxis;
+
+  enum {
+    AlphaAxisAbs = internal::Abs<AlphaAxis>::value, /*!< the first rotation axis unsigned */
+    BetaAxisAbs = internal::Abs<BetaAxis>::value,   /*!< the second rotation axis unsigned */
+    GammaAxisAbs = internal::Abs<GammaAxis>::value, /*!< the third rotation axis unsigned */
+
+    IsAlphaOpposite = (AlphaAxis < 0) ? 1 : 0, /*!< whether alpha axis is negative */
+    IsBetaOpposite = (BetaAxis < 0) ? 1 : 0,   /*!< whether beta axis is negative */
+    IsGammaOpposite = (GammaAxis < 0) ? 1 : 0, /*!< whether gamma axis is negative */
+
+    // Parity is even if alpha axis X is followed by beta axis Y, or Y is followed
+    // by Z, or Z is followed by X; otherwise it is odd.
+    IsOdd = (AlphaAxisAbs % 3 == (BetaAxisAbs - 1) % 3) ? 0 : 1, /*!< whether the Euler system is odd */
+    IsEven = IsOdd ? 0 : 1,                                      /*!< whether the Euler system is even */
+
+    IsTaitBryan =
+        ((unsigned)AlphaAxisAbs != (unsigned)GammaAxisAbs) ? 1 : 0 /*!< whether the Euler system is Tait-Bryan */
+  };
+
+ private:
+  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(internal::IsValidAxis<AlphaAxis>::value, ALPHA_AXIS_IS_INVALID);
+
+  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(internal::IsValidAxis<BetaAxis>::value, BETA_AXIS_IS_INVALID);
+
+  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(internal::IsValidAxis<GammaAxis>::value, GAMMA_AXIS_IS_INVALID);
+
+  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT((unsigned)AlphaAxisAbs != (unsigned)BetaAxisAbs,
+                                         ALPHA_AXIS_CANT_BE_EQUAL_TO_BETA_AXIS);
+
+  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT((unsigned)BetaAxisAbs != (unsigned)GammaAxisAbs,
+                                         BETA_AXIS_CANT_BE_EQUAL_TO_GAMMA_AXIS);
+
+  template <typename Scalar>
+  static void CalcEulerAngles(EulerAngles<Scalar, EulerSystem>& res,
+                              const typename EulerAngles<Scalar, EulerSystem>::Matrix3& mat) {
+    res.angles() = mat.canonicalEulerAngles(AlphaAxisAbs - 1, BetaAxisAbs - 1, GammaAxisAbs - 1);
+
+    EIGEN_IF_CONSTEXPR (IsAlphaOpposite) res.alpha() = -res.alpha();
+
+    EIGEN_IF_CONSTEXPR (IsBetaOpposite) res.beta() = -res.beta();
+
+    EIGEN_IF_CONSTEXPR (IsGammaOpposite) res.gamma() = -res.gamma();
+  }
+
+  template <typename Scalar_, class _System>
+  friend class Eigen::EulerAngles;
+
+  template <typename System, typename Other, int OtherRows, int OtherCols>
+  friend struct internal::eulerangles_assign_impl;
+};
+
+#define EIGEN_EULER_SYSTEM_TYPEDEF(A, B, C) typedef EulerSystem<EULER_##A, EULER_##B, EULER_##C> EulerSystem##A##B##C;
+
+/** Default XYZ Euler coordinate system.
+ * \ingroup EulerAngles_Module
+ */
+EIGEN_EULER_SYSTEM_TYPEDEF(X, Y, Z)
+EIGEN_EULER_SYSTEM_TYPEDEF(X, Y, X)
+EIGEN_EULER_SYSTEM_TYPEDEF(X, Z, Y)
+EIGEN_EULER_SYSTEM_TYPEDEF(X, Z, X)
+
+EIGEN_EULER_SYSTEM_TYPEDEF(Y, Z, X)
+EIGEN_EULER_SYSTEM_TYPEDEF(Y, Z, Y)
+EIGEN_EULER_SYSTEM_TYPEDEF(Y, X, Z)
+EIGEN_EULER_SYSTEM_TYPEDEF(Y, X, Y)
+
+EIGEN_EULER_SYSTEM_TYPEDEF(Z, X, Y)
+EIGEN_EULER_SYSTEM_TYPEDEF(Z, X, Z)
+EIGEN_EULER_SYSTEM_TYPEDEF(Z, Y, X)
+EIGEN_EULER_SYSTEM_TYPEDEF(Z, Y, Z)
+}  // namespace Eigen
+
+#undef EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT
+#undef EIGEN_EULER_SYSTEM_TYPEDEF
+
+#endif  // EIGEN_EULERSYSTEM_H
diff --git a/contrib/Eigen/src/EulerAngles/InternalHeaderCheck.h b/contrib/Eigen/src/EulerAngles/InternalHeaderCheck.h
new file mode 100644
index 0000000..2073995
--- /dev/null
+++ b/contrib/Eigen/src/EulerAngles/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_EULERANGLES_MODULE_H
+#error "Please include contrib/Eigen/EulerAngles instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/FFT/InternalHeaderCheck.h b/contrib/Eigen/src/FFT/InternalHeaderCheck.h
new file mode 100644
index 0000000..71a632d
--- /dev/null
+++ b/contrib/Eigen/src/FFT/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_MODULE_H
+#error "Please include contrib/Eigen/FFT instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/FFT/duccfft_impl.h b/contrib/Eigen/src/FFT/duccfft_impl.h
new file mode 100644
index 0000000..15ec0a0
--- /dev/null
+++ b/contrib/Eigen/src/FFT/duccfft_impl.h
@@ -0,0 +1,78 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_DUCCFFT_IMPL_H
+#define EIGEN_FFT_DUCCFFT_IMPL_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename _Scalar>
+struct duccfft_impl {
+  using Scalar = _Scalar;
+  using Complex = std::complex<Scalar>;
+  using shape_t = ducc0::fmav_info::shape_t;
+  using stride_t = ducc0::fmav_info::stride_t;
+
+  inline void clear() {}
+
+  inline void fwd(Complex* dst, const Scalar* src, int nfft) {
+    const shape_t axes{0};
+    ducc0::cfmav<Scalar> m_in(src, shape_t{static_cast<size_t>(nfft)});
+    ducc0::vfmav<Complex> m_out(dst, shape_t{static_cast<size_t>(nfft) / 2 + 1});
+    ducc0::r2c(m_in, m_out, axes, /*forward=*/true, /*scale=*/static_cast<Scalar>(1));
+  }
+
+  inline void fwd(Complex* dst, const Complex* src, int nfft) {
+    const shape_t axes{0};
+    ducc0::cfmav<Complex> m_in(src, shape_t{static_cast<size_t>(nfft)});
+    ducc0::vfmav<Complex> m_out(dst, shape_t{static_cast<size_t>(nfft)});
+    ducc0::c2c(m_in, m_out, axes, /*forward=*/true, /*scale=*/static_cast<Scalar>(1));
+  }
+
+  inline void inv(Scalar* dst, const Complex* src, int nfft) {
+    const shape_t axes{0};
+    ducc0::cfmav<Complex> m_in(src, shape_t{static_cast<size_t>(nfft) / 2 + 1});
+    ducc0::vfmav<Scalar> m_out(dst, shape_t{static_cast<size_t>(nfft)});
+    ducc0::c2r(m_in, m_out, axes, /*forward=*/false, /*scale=*/static_cast<Scalar>(1));
+  }
+
+  inline void inv(Complex* dst, const Complex* src, int nfft) {
+    const shape_t axes{0};
+    ducc0::cfmav<Complex> m_in(src, shape_t{static_cast<size_t>(nfft)});
+    ducc0::vfmav<Complex> m_out(dst, shape_t{static_cast<size_t>(nfft)});
+    ducc0::c2c(m_in, m_out, axes, /*forward=*/false, /*scale=*/static_cast<Scalar>(1));
+  }
+
+  inline void fwd2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
+    const shape_t axes{0, 1};
+    const shape_t in_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
+    const shape_t out_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
+    const stride_t stride{static_cast<ptrdiff_t>(nfft1), static_cast<ptrdiff_t>(1)};
+    ducc0::cfmav<Complex> m_in(src, in_shape, stride);
+    ducc0::vfmav<Complex> m_out(dst, out_shape, stride);
+    ducc0::c2c(m_in, m_out, axes, /*forward=*/true, /*scale=*/static_cast<Scalar>(1));
+  }
+
+  inline void inv2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
+    const shape_t axes{0, 1};
+    const shape_t in_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
+    const shape_t out_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
+    const stride_t stride{static_cast<ptrdiff_t>(nfft1), static_cast<ptrdiff_t>(1)};
+    ducc0::cfmav<Complex> m_in(src, in_shape, stride);
+    ducc0::vfmav<Complex> m_out(dst, out_shape, stride);
+    ducc0::c2c(m_in, m_out, axes, /*forward=*/false, /*scale=*/static_cast<Scalar>(1));
+  }
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_FFT_DUCCFFT_IMPL_H
diff --git a/contrib/Eigen/src/FFT/fftw_impl.h b/contrib/Eigen/src/FFT/fftw_impl.h
new file mode 100644
index 0000000..2b34443
--- /dev/null
+++ b/contrib/Eigen/src/FFT/fftw_impl.h
@@ -0,0 +1,308 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Mark Borgerding mark a borgerding net
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_FFTW_IMPL_H
+#define EIGEN_FFT_FFTW_IMPL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <memory>
+#include <mutex>
+
+namespace Eigen {
+
+namespace internal {
+
+// FFTW uses non-const arguments,
+// so const_cast is needed for all the args it uses.
+//
+// This should be safe as long as
+// 1. we use FFTW_ESTIMATE for all our planning
+//       see the FFTW docs section 4.3.2 "Planner Flags"
+// 2. fftw_complex is compatible with std::complex
+//    This assumes std::complex<T> layout is array of size 2 with real,imag
+template <typename T>
+inline T *fftw_cast(const T *p) {
+  return const_cast<T *>(p);
+}
+
+inline fftw_complex *fftw_cast(const std::complex<double> *p) {
+  return const_cast<fftw_complex *>(reinterpret_cast<const fftw_complex *>(p));
+}
+
+inline fftwf_complex *fftw_cast(const std::complex<float> *p) {
+  return const_cast<fftwf_complex *>(reinterpret_cast<const fftwf_complex *>(p));
+}
+
+inline fftwl_complex *fftw_cast(const std::complex<long double> *p) {
+  return const_cast<fftwl_complex *>(reinterpret_cast<const fftwl_complex *>(p));
+}
+
+// The FFTW planner is not thread-safe: fftw_execute and its new-array variants,
+// which is what this backend runs transforms through, are the only entry points
+// that may be called concurrently (FFTW manual, "Thread safety"), so plan
+// creation and destruction are serialized through this mutex. A template
+// static gives the header-only definition; std::mutex is
+// constexpr-constructible, so the mutex is ready before any thread starts.
+// The planner state it stands in for is one per process, so the mutex must be
+// too: the explicit default visibility is what keeps the definition from being
+// bound locally under -fvisibility=hidden, where each library planning through
+// Eigen would get a mutex of its own and serialize nothing between them. The
+// module documentation covers what no header can reach, which needs FFTW's own
+// fftw_make_planner_thread_safe().
+#if EIGEN_HAS_ATTRIBUTE(visibility) && !EIGEN_OS_WIN
+#define EIGEN_FFTW_PLANNER_MUTEX_VISIBILITY __attribute__((visibility("default")))
+#else
+#define EIGEN_FFTW_PLANNER_MUTEX_VISIBILITY
+#endif
+
+template <typename Dummy = void>
+struct fftw_planner_lock {
+  static EIGEN_FFTW_PLANNER_MUTEX_VISIBILITY std::mutex mutex;
+};
+template <typename Dummy>
+EIGEN_FFTW_PLANNER_MUTEX_VISIBILITY std::mutex fftw_planner_lock<Dummy>::mutex;
+
+inline std::mutex &fftw_planner_mutex() { return fftw_planner_lock<>::mutex; }
+
+template <typename PlanFactory>
+inline decltype(auto) fftw_make_plan(PlanFactory factory) {
+  std::lock_guard<std::mutex> lock(fftw_planner_mutex());
+  return factory();
+}
+
+template <typename T>
+struct fftw_plan {};
+
+template <>
+struct fftw_plan<float> {
+  typedef float scalar_type;
+  typedef fftwf_complex complex_type;
+  std::shared_ptr<fftwf_plan_s> m_plan;
+  fftw_plan() = default;
+
+  void set_plan(fftwf_plan p) {
+    m_plan.reset(p, [](fftwf_plan plan) {
+      std::lock_guard<std::mutex> lock(fftw_planner_mutex());
+      fftwf_destroy_plan(plan);
+    });
+  }
+  inline void fwd(complex_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwf_plan_dft_1d(nfft, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwf_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void inv(complex_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwf_plan_dft_1d(nfft, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwf_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void fwd(complex_type *dst, scalar_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(
+          fftw_make_plan([&] { return fftwf_plan_dft_r2c_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwf_execute_dft_r2c(m_plan.get(), src, dst);
+  }
+  inline void inv(scalar_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(
+          fftw_make_plan([&] { return fftwf_plan_dft_c2r_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwf_execute_dft_c2r(m_plan.get(), src, dst);
+  }
+
+  inline void fwd2(complex_type *dst, complex_type *src, int n0, int n1) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwf_plan_dft_2d(n0, n1, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwf_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void inv2(complex_type *dst, complex_type *src, int n0, int n1) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwf_plan_dft_2d(n0, n1, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwf_execute_dft(m_plan.get(), src, dst);
+  }
+};
+template <>
+struct fftw_plan<double> {
+  typedef double scalar_type;
+  typedef fftw_complex complex_type;
+  std::shared_ptr<fftw_plan_s> m_plan;
+  fftw_plan() = default;
+
+  void set_plan(::fftw_plan p) {
+    m_plan.reset(p, [](::fftw_plan plan) {
+      std::lock_guard<std::mutex> lock(fftw_planner_mutex());
+      fftw_destroy_plan(plan);
+    });
+  }
+  inline void fwd(complex_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftw_plan_dft_1d(nfft, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftw_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void inv(complex_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftw_plan_dft_1d(nfft, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftw_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void fwd(complex_type *dst, scalar_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(
+          fftw_make_plan([&] { return fftw_plan_dft_r2c_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftw_execute_dft_r2c(m_plan.get(), src, dst);
+  }
+  inline void inv(scalar_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(
+          fftw_make_plan([&] { return fftw_plan_dft_c2r_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftw_execute_dft_c2r(m_plan.get(), src, dst);
+  }
+  inline void fwd2(complex_type *dst, complex_type *src, int n0, int n1) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftw_plan_dft_2d(n0, n1, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftw_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void inv2(complex_type *dst, complex_type *src, int n0, int n1) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftw_plan_dft_2d(n0, n1, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftw_execute_dft(m_plan.get(), src, dst);
+  }
+};
+template <>
+struct fftw_plan<long double> {
+  typedef long double scalar_type;
+  typedef fftwl_complex complex_type;
+  std::shared_ptr<fftwl_plan_s> m_plan;
+  fftw_plan() = default;
+
+  void set_plan(fftwl_plan p) {
+    m_plan.reset(p, [](fftwl_plan plan) {
+      std::lock_guard<std::mutex> lock(fftw_planner_mutex());
+      fftwl_destroy_plan(plan);
+    });
+  }
+  inline void fwd(complex_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwl_plan_dft_1d(nfft, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwl_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void inv(complex_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwl_plan_dft_1d(nfft, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwl_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void fwd(complex_type *dst, scalar_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(
+          fftw_make_plan([&] { return fftwl_plan_dft_r2c_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwl_execute_dft_r2c(m_plan.get(), src, dst);
+  }
+  inline void inv(scalar_type *dst, complex_type *src, int nfft) {
+    if (!m_plan)
+      set_plan(
+          fftw_make_plan([&] { return fftwl_plan_dft_c2r_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwl_execute_dft_c2r(m_plan.get(), src, dst);
+  }
+  inline void fwd2(complex_type *dst, complex_type *src, int n0, int n1) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwl_plan_dft_2d(n0, n1, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwl_execute_dft(m_plan.get(), src, dst);
+  }
+  inline void inv2(complex_type *dst, complex_type *src, int n0, int n1) {
+    if (!m_plan)
+      set_plan(fftw_make_plan(
+          [&] { return fftwl_plan_dft_2d(n0, n1, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT); }));
+    fftwl_execute_dft(m_plan.get(), src, dst);
+  }
+};
+
+template <typename Scalar_>
+struct fftw_impl {
+  typedef Scalar_ Scalar;
+  typedef std::complex<Scalar> Complex;
+
+  inline void clear() { m_plans.clear(); }
+
+  // complex-to-complex forward FFT
+  inline void fwd(Complex *dst, const Complex *src, int nfft) {
+    get_plan(nfft, false, /*real_io=*/false, dst, src).fwd(fftw_cast(dst), fftw_cast(src), nfft);
+  }
+
+  // real-to-complex forward FFT
+  inline void fwd(Complex *dst, const Scalar *src, int nfft) {
+    get_plan(nfft, false, /*real_io=*/true, dst, src).fwd(fftw_cast(dst), fftw_cast(src), nfft);
+  }
+
+  // 2-d complex-to-complex
+  inline void fwd2(Complex *dst, const Complex *src, int n0, int n1) {
+    get_plan(n0, n1, false, /*real_io=*/false, dst, src).fwd2(fftw_cast(dst), fftw_cast(src), n0, n1);
+  }
+
+  // inverse complex-to-complex
+  inline void inv(Complex *dst, const Complex *src, int nfft) {
+    get_plan(nfft, true, /*real_io=*/false, dst, src).inv(fftw_cast(dst), fftw_cast(src), nfft);
+  }
+
+  // half-complex to scalar
+  inline void inv(Scalar *dst, const Complex *src, int nfft) {
+    get_plan(nfft, true, /*real_io=*/true, dst, src).inv(fftw_cast(dst), fftw_cast(src), nfft);
+  }
+
+  // 2-d complex-to-complex
+  inline void inv2(Complex *dst, const Complex *src, int n0, int n1) {
+    get_plan(n0, n1, true, /*real_io=*/false, dst, src).inv2(fftw_cast(dst), fftw_cast(src), n0, n1);
+  }
+
+ protected:
+  typedef fftw_plan<Scalar> PlanData;
+
+  typedef Eigen::numext::int64_t int64_t;
+
+  typedef std::map<int64_t, PlanData> PlanMap;
+
+  PlanMap m_plans;
+
+  // Pack (inverse, real_io, inplace, aligned) into 4 contiguous low bits of
+  // the cache key.  real_io distinguishes r2c/c2r from c2c so that reusing
+  // the same FFT object across real-input and complex-input transforms
+  // doesn't return a cached plan of the wrong kind.
+  static int64_t plan_flags(bool inverse, bool real_io, void *dst, const void *src) {
+    bool inplace = (dst == src);
+    bool aligned = ((reinterpret_cast<size_t>(src) & 15) | (reinterpret_cast<size_t>(dst) & 15)) == 0;
+    return (inverse << 3) | (real_io << 2) | (inplace << 1) | aligned;
+  }
+
+  inline PlanData &get_plan(int nfft, bool inverse, bool real_io, void *dst, const void *src) {
+    int64_t key = ((nfft << 4) | plan_flags(inverse, real_io, dst, src)) << 1;
+    return m_plans[key];
+  }
+
+  inline PlanData &get_plan(int n0, int n1, bool inverse, bool real_io, void *dst, const void *src) {
+    int64_t key = (((((int64_t)n0) << 31) | (n1 << 4) | plan_flags(inverse, real_io, dst, src)) << 1) + 1;
+    return m_plans[key];
+  }
+};
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_FFT_FFTW_IMPL_H
diff --git a/contrib/Eigen/src/FFT/imklfft_impl.h b/contrib/Eigen/src/FFT/imklfft_impl.h
new file mode 100644
index 0000000..6ae8ad2
--- /dev/null
+++ b/contrib/Eigen/src/FFT/imklfft_impl.h
@@ -0,0 +1,255 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_IMKLFFT_IMPL_H
+#define EIGEN_FFT_IMKLFFT_IMPL_H
+
+#include <mkl_dfti.h>
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <complex>
+#include <memory>
+
+namespace Eigen {
+namespace internal {
+namespace imklfft {
+
+#define RUN_OR_ASSERT(EXPR, ERROR_MSG)                    \
+  {                                                       \
+    MKL_LONG status = (EXPR);                             \
+    eigen_assert(status == DFTI_NO_ERROR && (ERROR_MSG)); \
+  };
+
+inline MKL_Complex16* complex_cast(const std::complex<double>* p) {
+  return const_cast<MKL_Complex16*>(reinterpret_cast<const MKL_Complex16*>(p));
+}
+
+inline MKL_Complex8* complex_cast(const std::complex<float>* p) {
+  return const_cast<MKL_Complex8*>(reinterpret_cast<const MKL_Complex8*>(p));
+}
+
+/*
+ * Parameters:
+ * precision: enum, Precision of the transform: DFTI_SINGLE or DFTI_DOUBLE.
+ * forward_domain: enum, Forward domain of the transform: DFTI_COMPLEX or
+ * DFTI_REAL. dimension: MKL_LONG Dimension of the transform. sizes: MKL_LONG if
+ * dimension = 1. Length of the transform for a one-dimensional transform. sizes:
+ * Array of type MKL_LONG otherwise. Lengths of each dimension for a
+ * multi-dimensional transform.
+ */
+inline void configure_descriptor(std::shared_ptr<DFTI_DESCRIPTOR>& handl, enum DFTI_CONFIG_VALUE precision,
+                                 enum DFTI_CONFIG_VALUE forward_domain, MKL_LONG dimension, MKL_LONG* sizes) {
+  eigen_assert(dimension == 1 || dimension == 2 && "Transformation dimension must be less than 3.");
+
+  DFTI_DESCRIPTOR_HANDLE res = nullptr;
+  if (dimension == 1) {
+    RUN_OR_ASSERT(DftiCreateDescriptor(&res, precision, forward_domain, dimension, *sizes),
+                  "DftiCreateDescriptor failed.")
+    handl.reset(res, [](DFTI_DESCRIPTOR_HANDLE handle) { DftiFreeDescriptor(&handle); });
+    if (forward_domain == DFTI_REAL) {
+      // Set CCE storage
+      RUN_OR_ASSERT(DftiSetValue(handl.get(), DFTI_CONJUGATE_EVEN_STORAGE, DFTI_COMPLEX_COMPLEX),
+                    "DftiSetValue failed.")
+    }
+  } else {
+    RUN_OR_ASSERT(DftiCreateDescriptor(&res, precision, DFTI_COMPLEX, dimension, sizes), "DftiCreateDescriptor failed.")
+    handl.reset(res, [](DFTI_DESCRIPTOR_HANDLE handle) { DftiFreeDescriptor(&handle); });
+  }
+
+  RUN_OR_ASSERT(DftiSetValue(handl.get(), DFTI_PLACEMENT, DFTI_NOT_INPLACE), "DftiSetValue failed.")
+  RUN_OR_ASSERT(DftiCommitDescriptor(handl.get()), "DftiCommitDescriptor failed.")
+}
+
+template <typename T>
+struct plan {};
+
+template <>
+struct plan<float> {
+  typedef float scalar_type;
+  typedef MKL_Complex8 complex_type;
+
+  std::shared_ptr<DFTI_DESCRIPTOR> m_plan;
+
+  plan() = default;
+
+  enum DFTI_CONFIG_VALUE precision = DFTI_SINGLE;
+
+  inline void forward(complex_type* dst, complex_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
+  }
+
+  inline void inverse(complex_type* dst, complex_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
+  }
+
+  inline void forward(complex_type* dst, scalar_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
+  }
+
+  inline void inverse(scalar_type* dst, complex_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
+  }
+
+  inline void forward2(complex_type* dst, complex_type* src, int n0, int n1) {
+    if (m_plan == 0) {
+      MKL_LONG sizes[2] = {n0, n1};
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
+    }
+    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
+  }
+
+  inline void inverse2(complex_type* dst, complex_type* src, int n0, int n1) {
+    if (m_plan == 0) {
+      MKL_LONG sizes[2] = {n0, n1};
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
+    }
+    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
+  }
+};
+
+template <>
+struct plan<double> {
+  typedef double scalar_type;
+  typedef MKL_Complex16 complex_type;
+
+  std::shared_ptr<DFTI_DESCRIPTOR> m_plan;
+
+  plan() = default;
+
+  enum DFTI_CONFIG_VALUE precision = DFTI_DOUBLE;
+
+  inline void forward(complex_type* dst, complex_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
+  }
+
+  inline void inverse(complex_type* dst, complex_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
+  }
+
+  inline void forward(complex_type* dst, scalar_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
+  }
+
+  inline void inverse(scalar_type* dst, complex_type* src, MKL_LONG nfft) {
+    if (m_plan == 0) {
+      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
+    }
+    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
+  }
+
+  inline void forward2(complex_type* dst, complex_type* src, int n0, int n1) {
+    if (m_plan == 0) {
+      MKL_LONG sizes[2] = {n0, n1};
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
+    }
+    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
+  }
+
+  inline void inverse2(complex_type* dst, complex_type* src, int n0, int n1) {
+    if (m_plan == 0) {
+      MKL_LONG sizes[2] = {n0, n1};
+      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
+    }
+    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
+  }
+};
+
+template <typename Scalar_>
+struct imklfft_impl {
+  typedef Scalar_ Scalar;
+  typedef std::complex<Scalar> Complex;
+
+  inline void clear() { m_plans.clear(); }
+
+  // complex-to-complex forward FFT
+  inline void fwd(Complex* dst, const Complex* src, int nfft) {
+    get_plan(nfft, /*real_io=*/false, dst, src).forward(complex_cast(dst), complex_cast(src), nfft);
+  }
+
+  // real-to-complex forward FFT
+  inline void fwd(Complex* dst, const Scalar* src, int nfft) {
+    get_plan(nfft, /*real_io=*/true, dst, src).forward(complex_cast(dst), const_cast<Scalar*>(src), nfft);
+  }
+
+  // 2-d complex-to-complex
+  inline void fwd2(Complex* dst, const Complex* src, int n0, int n1) {
+    get_plan(n0, n1, /*real_io=*/false, dst, src).forward2(complex_cast(dst), complex_cast(src), n0, n1);
+  }
+
+  // inverse complex-to-complex
+  inline void inv(Complex* dst, const Complex* src, int nfft) {
+    get_plan(nfft, /*real_io=*/false, dst, src).inverse(complex_cast(dst), complex_cast(src), nfft);
+  }
+
+  // half-complex to scalar
+  inline void inv(Scalar* dst, const Complex* src, int nfft) {
+    get_plan(nfft, /*real_io=*/true, dst, src).inverse(const_cast<Scalar*>(dst), complex_cast(src), nfft);
+  }
+
+  // 2-d complex-to-complex
+  inline void inv2(Complex* dst, const Complex* src, int n0, int n1) {
+    get_plan(n0, n1, /*real_io=*/false, dst, src).inverse2(complex_cast(dst), complex_cast(src), n0, n1);
+  }
+
+ private:
+  std::map<int64_t, plan<Scalar>> m_plans;
+
+  // Pack (real_io, inplace, aligned) into 3 contiguous low bits of the cache
+  // key.  real_io distinguishes plans built with DFTI_REAL from those built
+  // with DFTI_COMPLEX so reusing the same FFT object across real-input and
+  // complex-input transforms doesn't return a cached plan of the wrong domain.
+  // MKL DFTI descriptors are bidirectional, so forward and inverse share
+  // slots intentionally.
+  static int64_t plan_flags(bool real_io, void* dst, const void* src) {
+    int inplace = (dst == src) ? 1 : 0;
+    int aligned = ((reinterpret_cast<size_t>(src) & 15) | (reinterpret_cast<size_t>(dst) & 15)) == 0 ? 1 : 0;
+    return (int(real_io) << 2) | (inplace << 1) | aligned;
+  }
+
+  inline plan<Scalar>& get_plan(int nfft, bool real_io, void* dst, const void* src) {
+    int64_t key = ((nfft << 3) | plan_flags(real_io, dst, src)) << 1;
+    return m_plans[key];
+  }
+
+  inline plan<Scalar>& get_plan(int n0, int n1, bool real_io, void* dst, const void* src) {
+    int64_t key = (((((int64_t)n0) << 31) | (n1 << 3) | plan_flags(real_io, dst, src)) << 1) + 1;
+    return m_plans[key];
+  }
+};
+
+#undef RUN_OR_ASSERT
+
+}  // namespace imklfft
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_FFT_IMKLFFT_IMPL_H
diff --git a/contrib/Eigen/src/FFT/kissfft_impl.h b/contrib/Eigen/src/FFT/kissfft_impl.h
new file mode 100644
index 0000000..b6643f8
--- /dev/null
+++ b/contrib/Eigen/src/FFT/kissfft_impl.h
@@ -0,0 +1,434 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Mark Borgerding mark a borgerding net
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_KISSFFT_IMPL_H
+#define EIGEN_FFT_KISSFFT_IMPL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// This FFT implementation was derived from kissfft http://sourceforge.net/projects/kissfft
+// Copyright 2003-2009 Mark Borgerding
+
+template <typename Scalar_>
+struct kiss_cpx_fft {
+  typedef Scalar_ Scalar;
+  typedef std::complex<Scalar> Complex;
+  std::vector<Complex> m_twiddles;
+  std::vector<int> m_stageRadix;
+  std::vector<int> m_stageRemainder;
+  std::vector<Complex> m_scratchBuf;
+  bool m_inverse;
+
+  static const Scalar m_pi4;  // constant pi / 4
+
+  inline void make_twiddles(int nfft, bool inverse) {
+    using numext::cos;
+    using numext::sin;
+    m_inverse = inverse;
+    m_twiddles.resize(nfft);
+    Scalar phinc = m_pi4 / nfft;
+    Scalar flip = inverse ? Scalar(1) : Scalar(-1);
+    m_twiddles[0] = Complex(Scalar(1), Scalar(0));
+    if ((nfft & 1) == 0) m_twiddles[nfft / 2] = Complex(Scalar(-1), Scalar(0));
+    int i = 1;
+    for (; i * 8 < nfft; ++i) {
+      Scalar c = Scalar(cos(i * 8 * phinc));
+      Scalar s = Scalar(sin(i * 8 * phinc));
+      m_twiddles[i] = Complex(c, s * flip);
+      m_twiddles[nfft - i] = Complex(c, -s * flip);
+    }
+    for (; i * 4 < nfft; ++i) {
+      Scalar c = Scalar(cos((2 * nfft - 8 * i) * phinc));
+      Scalar s = Scalar(sin((2 * nfft - 8 * i) * phinc));
+      m_twiddles[i] = Complex(s, c * flip);
+      m_twiddles[nfft - i] = Complex(s, -c * flip);
+    }
+    for (; i * 8 < 3 * nfft; ++i) {
+      Scalar c = Scalar(cos((8 * i - 2 * nfft) * phinc));
+      Scalar s = Scalar(sin((8 * i - 2 * nfft) * phinc));
+      m_twiddles[i] = Complex(-s, c * flip);
+      m_twiddles[nfft - i] = Complex(-s, -c * flip);
+    }
+    for (; i * 2 < nfft; ++i) {
+      Scalar c = Scalar(cos((4 * nfft - 8 * i) * phinc));
+      Scalar s = Scalar(sin((4 * nfft - 8 * i) * phinc));
+      m_twiddles[i] = Complex(-c, s * flip);
+      m_twiddles[nfft - i] = Complex(-c, -s * flip);
+    }
+  }
+
+  void factorize(int nfft) {
+    // start factoring out 4's, then 2's, then 3,5,7,9,...
+    int n = nfft;
+    int p = 4;
+    do {
+      while (n % p) {
+        switch (p) {
+          case 4:
+            p = 2;
+            break;
+          case 2:
+            p = 3;
+            break;
+          default:
+            p += 2;
+            break;
+        }
+        if (p * p > n) p = n;  // impossible to have a factor > sqrt(n)
+      }
+      n /= p;
+      m_stageRadix.push_back(p);
+      m_stageRemainder.push_back(n);
+      if (p > 5) m_scratchBuf.resize(p);  // scratchbuf will be needed in bfly_generic
+    } while (n > 1);
+  }
+
+  template <typename Src_>
+  inline void work(int stage, Complex *xout, const Src_ *xin, size_t fstride, size_t in_stride) {
+    int p = m_stageRadix[stage];
+    int m = m_stageRemainder[stage];
+    Complex *Fout_beg = xout;
+    Complex *Fout_end = xout + p * m;
+
+    if (m > 1) {
+      do {
+        // recursive call:
+        // DFT of size m*p performed by doing
+        // p instances of smaller DFTs of size m,
+        // each one takes a decimated version of the input
+        work(stage + 1, xout, xin, fstride * p, in_stride);
+        xin += fstride * in_stride;
+      } while ((xout += m) != Fout_end);
+    } else {
+      do {
+        *xout = *xin;
+        xin += fstride * in_stride;
+      } while (++xout != Fout_end);
+    }
+    xout = Fout_beg;
+
+    // recombine the p smaller DFTs
+    switch (p) {
+      case 2:
+        bfly2(xout, fstride, m);
+        break;
+      case 3:
+        bfly3(xout, fstride, m);
+        break;
+      case 4:
+        bfly4(xout, fstride, m);
+        break;
+      case 5:
+        bfly5(xout, fstride, m);
+        break;
+      default:
+        bfly_generic(xout, fstride, m, p);
+        break;
+    }
+  }
+
+  inline void bfly2(Complex *Fout, const size_t fstride, int m) {
+    for (int k = 0; k < m; ++k) {
+      Complex t = Fout[m + k] * m_twiddles[k * fstride];
+      Fout[m + k] = Fout[k] - t;
+      Fout[k] += t;
+    }
+  }
+
+  inline void bfly4(Complex *Fout, const size_t fstride, const size_t m) {
+    Complex scratch[6];
+    int negative_if_inverse = m_inverse * -2 + 1;
+    for (size_t k = 0; k < m; ++k) {
+      scratch[0] = Fout[k + m] * m_twiddles[k * fstride];
+      scratch[1] = Fout[k + 2 * m] * m_twiddles[k * fstride * 2];
+      scratch[2] = Fout[k + 3 * m] * m_twiddles[k * fstride * 3];
+      scratch[5] = Fout[k] - scratch[1];
+
+      Fout[k] += scratch[1];
+      scratch[3] = scratch[0] + scratch[2];
+      scratch[4] = scratch[0] - scratch[2];
+      scratch[4] = Complex(scratch[4].imag() * negative_if_inverse, -scratch[4].real() * negative_if_inverse);
+
+      Fout[k + 2 * m] = Fout[k] - scratch[3];
+      Fout[k] += scratch[3];
+      Fout[k + m] = scratch[5] + scratch[4];
+      Fout[k + 3 * m] = scratch[5] - scratch[4];
+    }
+  }
+
+  inline void bfly3(Complex *Fout, const size_t fstride, const size_t m) {
+    size_t k = m;
+    const size_t m2 = 2 * m;
+    Complex *tw1, *tw2;
+    Complex scratch[5];
+    Complex epi3;
+    epi3 = m_twiddles[fstride * m];
+
+    tw1 = tw2 = &m_twiddles[0];
+
+    do {
+      scratch[1] = Fout[m] * *tw1;
+      scratch[2] = Fout[m2] * *tw2;
+
+      scratch[3] = scratch[1] + scratch[2];
+      scratch[0] = scratch[1] - scratch[2];
+      tw1 += fstride;
+      tw2 += fstride * 2;
+      Fout[m] = Complex(Fout->real() - Scalar(.5) * scratch[3].real(), Fout->imag() - Scalar(.5) * scratch[3].imag());
+      scratch[0] *= epi3.imag();
+      *Fout += scratch[3];
+      Fout[m2] = Complex(Fout[m].real() + scratch[0].imag(), Fout[m].imag() - scratch[0].real());
+      Fout[m] += Complex(-scratch[0].imag(), scratch[0].real());
+      ++Fout;
+    } while (--k);
+  }
+
+  inline void bfly5(Complex *Fout, const size_t fstride, const size_t m) {
+    Complex *Fout0, *Fout1, *Fout2, *Fout3, *Fout4;
+    size_t u;
+    Complex scratch[13];
+    Complex *twiddles = &m_twiddles[0];
+    Complex *tw;
+    Complex ya, yb;
+    ya = twiddles[fstride * m];
+    yb = twiddles[fstride * 2 * m];
+
+    Fout0 = Fout;
+    Fout1 = Fout0 + m;
+    Fout2 = Fout0 + 2 * m;
+    Fout3 = Fout0 + 3 * m;
+    Fout4 = Fout0 + 4 * m;
+
+    tw = twiddles;
+    for (u = 0; u < m; ++u) {
+      scratch[0] = *Fout0;
+
+      scratch[1] = *Fout1 * tw[u * fstride];
+      scratch[2] = *Fout2 * tw[2 * u * fstride];
+      scratch[3] = *Fout3 * tw[3 * u * fstride];
+      scratch[4] = *Fout4 * tw[4 * u * fstride];
+
+      scratch[7] = scratch[1] + scratch[4];
+      scratch[10] = scratch[1] - scratch[4];
+      scratch[8] = scratch[2] + scratch[3];
+      scratch[9] = scratch[2] - scratch[3];
+
+      *Fout0 += scratch[7];
+      *Fout0 += scratch[8];
+
+      scratch[5] = scratch[0] + Complex((scratch[7].real() * ya.real()) + (scratch[8].real() * yb.real()),
+                                        (scratch[7].imag() * ya.real()) + (scratch[8].imag() * yb.real()));
+
+      scratch[6] = Complex((scratch[10].imag() * ya.imag()) + (scratch[9].imag() * yb.imag()),
+                           -(scratch[10].real() * ya.imag()) - (scratch[9].real() * yb.imag()));
+
+      *Fout1 = scratch[5] - scratch[6];
+      *Fout4 = scratch[5] + scratch[6];
+
+      scratch[11] = scratch[0] + Complex((scratch[7].real() * yb.real()) + (scratch[8].real() * ya.real()),
+                                         (scratch[7].imag() * yb.real()) + (scratch[8].imag() * ya.real()));
+
+      scratch[12] = Complex(-(scratch[10].imag() * yb.imag()) + (scratch[9].imag() * ya.imag()),
+                            (scratch[10].real() * yb.imag()) - (scratch[9].real() * ya.imag()));
+
+      *Fout2 = scratch[11] + scratch[12];
+      *Fout3 = scratch[11] - scratch[12];
+
+      ++Fout0;
+      ++Fout1;
+      ++Fout2;
+      ++Fout3;
+      ++Fout4;
+    }
+  }
+
+  /* perform the butterfly for one stage of a mixed radix FFT */
+  inline void bfly_generic(Complex *Fout, const size_t fstride, int m, int p) {
+    int u, k, q1, q;
+    Complex *twiddles = &m_twiddles[0];
+    Complex t;
+    int Norig = static_cast<int>(m_twiddles.size());
+    Complex *scratchbuf = &m_scratchBuf[0];
+
+    for (u = 0; u < m; ++u) {
+      k = u;
+      for (q1 = 0; q1 < p; ++q1) {
+        scratchbuf[q1] = Fout[k];
+        k += m;
+      }
+
+      k = u;
+      for (q1 = 0; q1 < p; ++q1) {
+        int twidx = 0;
+        Fout[k] = scratchbuf[0];
+        for (q = 1; q < p; ++q) {
+          twidx += static_cast<int>(fstride) * k;
+          if (twidx >= Norig) twidx -= Norig;
+          t = scratchbuf[q] * twiddles[twidx];
+          Fout[k] += t;
+        }
+        k += m;
+      }
+    }
+  }
+};
+
+template <typename _Scalar>
+const typename kiss_cpx_fft<_Scalar>::Scalar kiss_cpx_fft<_Scalar>::m_pi4 =
+    numext::atan(kiss_cpx_fft<_Scalar>::Scalar(1));
+
+template <typename Scalar_>
+struct kissfft_impl {
+  typedef Scalar_ Scalar;
+  typedef std::complex<Scalar> Complex;
+
+  void clear() {
+    m_plans.clear();
+    m_realTwiddles.clear();
+  }
+
+  inline void fwd(Complex *dst, const Complex *src, int nfft) { run_c2c(dst, src, nfft, /*inverse=*/false); }
+
+  inline void fwd2(Complex *dst, const Complex *src, int n0, int n1) {
+    EIGEN_UNUSED_VARIABLE(dst);
+    EIGEN_UNUSED_VARIABLE(src);
+    EIGEN_UNUSED_VARIABLE(n0);
+    EIGEN_UNUSED_VARIABLE(n1);
+  }
+
+  inline void inv2(Complex *dst, const Complex *src, int n0, int n1) {
+    EIGEN_UNUSED_VARIABLE(dst);
+    EIGEN_UNUSED_VARIABLE(src);
+    EIGEN_UNUSED_VARIABLE(n0);
+    EIGEN_UNUSED_VARIABLE(n1);
+  }
+
+  // real-to-complex forward FFT
+  // perform two FFTs of src even and src odd
+  // then twiddle to recombine them into the half-spectrum format
+  // then fill in the conjugate symmetric half
+  inline void fwd(Complex *dst, const Scalar *src, int nfft) {
+    if (nfft & 3) {
+      // use generic mode for odd
+      m_tmpBuf1.resize(nfft);
+      get_plan(nfft, false).work(0, &m_tmpBuf1[0], src, 1, 1);
+      std::copy(m_tmpBuf1.begin(), m_tmpBuf1.begin() + (nfft >> 1) + 1, dst);
+    } else {
+      int ncfft = nfft >> 1;
+      int ncfft2 = nfft >> 2;
+      Complex *rtw = real_twiddles(ncfft2);
+
+      // use optimized mode for even real
+      fwd(dst, reinterpret_cast<const Complex *>(src), ncfft);
+      Complex dc(dst[0].real() + dst[0].imag());
+      Complex nyquist(dst[0].real() - dst[0].imag());
+      int k;
+      for (k = 1; k <= ncfft2; ++k) {
+        Complex fpk = dst[k];
+        Complex fpnk = conj(dst[ncfft - k]);
+        Complex f1k = fpk + fpnk;
+        Complex f2k = fpk - fpnk;
+        Complex tw = f2k * rtw[k - 1];
+        dst[k] = (f1k + tw) * Scalar(.5);
+        dst[ncfft - k] = conj(f1k - tw) * Scalar(.5);
+      }
+      dst[0] = dc;
+      dst[ncfft] = nyquist;
+    }
+  }
+
+  // inverse complex-to-complex
+  inline void inv(Complex *dst, const Complex *src, int nfft) { run_c2c(dst, src, nfft, /*inverse=*/true); }
+
+  // half-complex to scalar
+  inline void inv(Scalar *dst, const Complex *src, int nfft) {
+    if (nfft & 3) {
+      m_tmpBuf1.resize(nfft);
+      m_tmpBuf2.resize(nfft);
+      std::copy(src, src + (nfft >> 1) + 1, m_tmpBuf1.begin());
+      for (int k = 1; k < (nfft >> 1) + 1; ++k) m_tmpBuf1[nfft - k] = conj(m_tmpBuf1[k]);
+      inv(&m_tmpBuf2[0], &m_tmpBuf1[0], nfft);
+      for (int k = 0; k < nfft; ++k) dst[k] = m_tmpBuf2[k].real();
+    } else {
+      // optimized version for multiple of 4
+      int ncfft = nfft >> 1;
+      int ncfft2 = nfft >> 2;
+      Complex *rtw = real_twiddles(ncfft2);
+      m_tmpBuf1.resize(ncfft);
+      m_tmpBuf1[0] = Complex(src[0].real() + src[ncfft].real(), src[0].real() - src[ncfft].real());
+      for (int k = 1; k <= ncfft / 2; ++k) {
+        Complex fk = src[k];
+        Complex fnkc = conj(src[ncfft - k]);
+        Complex fek = fk + fnkc;
+        Complex tmp = fk - fnkc;
+        Complex fok = tmp * conj(rtw[k - 1]);
+        m_tmpBuf1[k] = fek + fok;
+        m_tmpBuf1[ncfft - k] = conj(fek - fok);
+      }
+      get_plan(ncfft, true).work(0, reinterpret_cast<Complex *>(dst), &m_tmpBuf1[0], 1, 1);
+    }
+  }
+
+ protected:
+  typedef kiss_cpx_fft<Scalar> PlanData;
+  typedef std::map<int, PlanData> PlanMap;
+
+  PlanMap m_plans;
+  std::map<int, std::vector<Complex> > m_realTwiddles;
+  std::vector<Complex> m_tmpBuf1;
+  std::vector<Complex> m_tmpBuf2;
+
+  inline int PlanKey(int nfft, bool isinverse) const { return (nfft << 1) | int(isinverse); }
+
+  inline PlanData &get_plan(int nfft, bool inverse) {
+    // TODO: look for PlanKey(nfft, ! inverse) and conjugate the twiddles
+    PlanData &pd = m_plans[PlanKey(nfft, inverse)];
+    if (pd.m_twiddles.size() == 0) {
+      pd.make_twiddles(nfft, inverse);
+      pd.factorize(nfft);
+    }
+    return pd;
+  }
+
+  // work() writes dst while reading src, so an in-place call must stage src
+  // through a scratch buffer first.
+  inline void run_c2c(Complex *dst, const Complex *src, int nfft, bool inverse) {
+    if (dst == src) {
+      ei_declare_aligned_stack_constructed_variable(Complex, scratch, nfft, 0);
+      std::copy(src, src + nfft, scratch);
+      get_plan(nfft, inverse).work(0, dst, scratch, 1, 1);
+      return;
+    }
+    get_plan(nfft, inverse).work(0, dst, src, 1, 1);
+  }
+
+  inline Complex *real_twiddles(int ncfft2) {
+    using std::acos;
+    std::vector<Complex> &twidref = m_realTwiddles[ncfft2];  // creates new if not there
+    if ((int)twidref.size() != ncfft2) {
+      twidref.resize(ncfft2);
+      int ncfft = ncfft2 << 1;
+      Scalar pi = acos(Scalar(-1));
+      for (int k = 1; k <= ncfft2; ++k) twidref[k - 1] = exp(Complex(0, -pi * (Scalar(k) / ncfft + Scalar(.5))));
+    }
+    return &twidref[0];
+  }
+};
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_FFT_KISSFFT_IMPL_H
diff --git a/contrib/Eigen/src/FFT/pocketfft_impl.h b/contrib/Eigen/src/FFT/pocketfft_impl.h
new file mode 100644
index 0000000..6bcb25d
--- /dev/null
+++ b/contrib/Eigen/src/FFT/pocketfft_impl.h
@@ -0,0 +1,74 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_FFT_POCKETFFT_IMPL_H
+#define EIGEN_FFT_POCKETFFT_IMPL_H
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename _Scalar>
+struct pocketfft_impl {
+  using Scalar = _Scalar;
+  using Complex = std::complex<Scalar>;
+  using shape_t = pocketfft::shape_t;
+  using stride_t = pocketfft::stride_t;
+
+  inline void clear() {}
+
+  inline void fwd(Complex* dst, const Scalar* src, int nfft) {
+    const shape_t shape_{static_cast<size_t>(nfft)};
+    const shape_t axes_{0};
+    const stride_t stride_in{sizeof(Scalar)};
+    const stride_t stride_out{sizeof(Complex)};
+    pocketfft::r2c(shape_, stride_in, stride_out, axes_, pocketfft::FORWARD, src, dst, static_cast<Scalar>(1));
+  }
+
+  inline void fwd(Complex* dst, const Complex* src, int nfft) {
+    const shape_t shape_{static_cast<size_t>(nfft)};
+    const shape_t axes_{0};
+    const stride_t stride_{sizeof(Complex)};
+    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::FORWARD, src, dst, static_cast<Scalar>(1));
+  }
+
+  inline void inv(Scalar* dst, const Complex* src, int nfft) {
+    const shape_t shape_{static_cast<size_t>(nfft)};
+    const shape_t axes_{0};
+    const stride_t stride_in{sizeof(Complex)};
+    const stride_t stride_out{sizeof(Scalar)};
+    pocketfft::c2r(shape_, stride_in, stride_out, axes_, pocketfft::BACKWARD, src, dst, static_cast<Scalar>(1));
+  }
+
+  inline void inv(Complex* dst, const Complex* src, int nfft) {
+    const shape_t shape_{static_cast<size_t>(nfft)};
+    const shape_t axes_{0};
+    const stride_t stride_{sizeof(Complex)};
+    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::BACKWARD, src, dst, static_cast<Scalar>(1));
+  }
+
+  inline void fwd2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
+    const shape_t shape_{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
+    const shape_t axes_{0, 1};
+    const stride_t stride_{static_cast<ptrdiff_t>(sizeof(Complex) * nfft1), static_cast<ptrdiff_t>(sizeof(Complex))};
+    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::FORWARD, src, dst, static_cast<Scalar>(1));
+  }
+
+  inline void inv2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
+    const shape_t shape_{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
+    const shape_t axes_{0, 1};
+    const stride_t stride_{static_cast<ptrdiff_t>(sizeof(Complex) * nfft1), static_cast<ptrdiff_t>(sizeof(Complex))};
+    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::BACKWARD, src, dst, static_cast<Scalar>(1));
+  }
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_FFT_POCKETFFT_IMPL_H
diff --git a/contrib/Eigen/src/GPU/CuBlasSupport.h b/contrib/Eigen/src/GPU/CuBlasSupport.h
new file mode 100644
index 0000000..560e0b2
--- /dev/null
+++ b/contrib/Eigen/src/GPU/CuBlasSupport.h
@@ -0,0 +1,675 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// cuBLAS-specific support types. Generic CUDA runtime utilities (DeviceBuffer,
+// cuda_data_type) live in GpuSupport.h.
+
+#ifndef EIGEN_GPU_CUBLAS_SUPPORT_H
+#define EIGEN_GPU_CUBLAS_SUPPORT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSupport.h"
+#include <cublas_v2.h>
+#include <cublasLt.h>
+#include <cstring>
+#include <utility>
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+#define EIGEN_CUBLAS_CHECK(expr)                                       \
+  do {                                                                 \
+    cublasStatus_t _s = (expr);                                        \
+    eigen_assert(_s == CUBLAS_STATUS_SUCCESS && "cuBLAS call failed"); \
+  } while (0)
+
+constexpr cublasOperation_t to_cublas_op(GpuOp op) {
+  switch (op) {
+    case GpuOp::Trans:
+      return CUBLAS_OP_T;
+    case GpuOp::ConjTrans:
+      return CUBLAS_OP_C;
+    default:
+      return CUBLAS_OP_N;
+  }
+}
+
+// cuBLAS 12.0 added `_64` entry points taking int64_t dimensions across the
+// whole wrapped surface, so one wrapper body serves both:
+// EIGEN_CUBLAS_FN(cublasSgemm)(..., to_blas_dim(m), ...) becomes
+// cublasSgemm_64(..., m, ...) there (the plain `_64` names are cublas_v2.h
+// aliases for the real `_v2_64` symbols) and cublasSgemm(..., to_blas_int(m),
+// ...) on older cuBLAS. to_blas_dim is separate from to_blas_int, which must
+// keep narrowing for the cuSOLVER and cuFFT sites that have no `_64` API.
+
+#if defined(CUBLAS_VERSION) && CUBLAS_VERSION >= 120000
+#define EIGEN_CUBLAS_FN(name) name##_64
+inline int64_t to_blas_dim(int64_t v) { return v; }
+#else
+#define EIGEN_CUBLAS_FN(name) name
+inline int to_blas_dim(int64_t v) { return to_blas_int(v); }
+#endif
+
+// RAII cuBLAS / cuBLASLt handles; the ownership flag supports handles borrowed from a gpu::Context.
+struct CublasHandleDeleter {
+  bool owns = true;
+  void operator()(cublasHandle_t h) const noexcept {
+    if (owns && h) (void)cublasDestroy(h);
+  }
+};
+using UniqueCublasHandle = std::unique_ptr<std::remove_pointer_t<cublasHandle_t>, CublasHandleDeleter>;
+
+struct CublasLtHandleDeleter {
+  void operator()(cublasLtHandle_t h) const noexcept {
+    if (h) (void)cublasLtDestroy(h);
+  }
+};
+using UniqueCublasLtHandle = std::unique_ptr<std::remove_pointer_t<cublasLtHandle_t>, CublasLtHandleDeleter>;
+
+// cublasLtMatmul takes a compute type separate from the data type, which selects
+// the precision policy:
+//   - Default: tensor-core algorithms via the cublasLtMatmul heuristics. For
+//     double, cuBLAS may use Ozaki emulation on sm_80+ tensor cores.
+//   - EIGEN_CUDA_TF32: TF32 for float (~2x faster, 10-bit mantissa).
+//   - EIGEN_NO_CUDA_TENSOR_OPS: pedantic compute types, no tensor cores, for
+//     bit-exact reproducibility.
+// Real and complex of the same precision share a compute type, so the
+// specializations below just dispatch to a precision tag.
+namespace cuda_compute_type_detail {
+#if defined(EIGEN_NO_CUDA_TENSOR_OPS)
+constexpr cublasComputeType_t kFloat = CUBLAS_COMPUTE_32F_PEDANTIC;
+constexpr cublasComputeType_t kDouble = CUBLAS_COMPUTE_64F_PEDANTIC;
+#elif defined(EIGEN_CUDA_TF32)
+constexpr cublasComputeType_t kFloat = CUBLAS_COMPUTE_32F_FAST_TF32;
+constexpr cublasComputeType_t kDouble = CUBLAS_COMPUTE_64F;
+#else
+constexpr cublasComputeType_t kFloat = CUBLAS_COMPUTE_32F;
+constexpr cublasComputeType_t kDouble = CUBLAS_COMPUTE_64F;
+#endif
+}  // namespace cuda_compute_type_detail
+
+template <typename Scalar>
+struct cuda_compute_type;
+
+template <>
+struct cuda_compute_type<float> {
+  static constexpr cublasComputeType_t value = cuda_compute_type_detail::kFloat;
+};
+template <>
+struct cuda_compute_type<double> {
+  static constexpr cublasComputeType_t value = cuda_compute_type_detail::kDouble;
+};
+template <>
+struct cuda_compute_type<std::complex<float>> {
+  static constexpr cublasComputeType_t value = cuda_compute_type_detail::kFloat;
+};
+template <>
+struct cuda_compute_type<std::complex<double>> {
+  static constexpr cublasComputeType_t value = cuda_compute_type_detail::kDouble;
+};
+
+#define EIGEN_CUBLASLT_CHECK(expr)                                       \
+  do {                                                                   \
+    cublasStatus_t _s = (expr);                                          \
+    eigen_assert(_s == CUBLAS_STATUS_SUCCESS && "cuBLASLt call failed"); \
+  } while (0)
+
+// Maximum workspace the heuristic is allowed to consider. This is a preference
+// ceiling, not an allocation — actual allocation matches the selected algorithm.
+// Override at compile time via EIGEN_CUDA_CUBLASLT_MAX_WORKSPACE_BYTES.
+#ifndef EIGEN_CUDA_CUBLASLT_MAX_WORKSPACE_BYTES
+#define EIGEN_CUDA_CUBLASLT_MAX_WORKSPACE_BYTES (32 * 1024 * 1024)  // 32 MB
+#endif
+static constexpr size_t kCublasLtMaxWorkspaceBytes = EIGEN_CUDA_CUBLASLT_MAX_WORKSPACE_BYTES;
+
+// Algorithm hint for the cublasGemmEx fallback path.
+constexpr cublasGemmAlgo_t cuda_gemm_algo() {
+#ifdef EIGEN_NO_CUDA_TENSOR_OPS
+  return CUBLAS_GEMM_DEFAULT;
+#else
+  return CUBLAS_GEMM_DEFAULT_TENSOR_OP;
+#endif
+}
+
+// Per-call descriptor creation and heuristic lookup cost 5-35% of total GEMM time
+// for small and medium matrices, so plans are cached by shape. Typical workloads
+// (CG iteration, chained solves) touch only 1-3 distinct shapes, hence the small
+// capacity.
+static constexpr std::size_t kCublasLtPlanCacheCapacity = 8;
+
+struct CublasLtPlanKey {
+  int64_t m, n, k;
+  int64_t lda, ldb, ldc;
+  cudaDataType_t dtype;
+  cublasOperation_t transA, transB;
+
+  bool operator==(const CublasLtPlanKey& o) const {
+    return m == o.m && n == o.n && k == o.k && lda == o.lda && ldb == o.ldb && ldc == o.ldc && dtype == o.dtype &&
+           transA == o.transA && transB == o.transB;
+  }
+};
+
+struct CublasLtPlanKeyHash {
+  std::size_t operator()(const CublasLtPlanKey& k) const noexcept {
+    // boost-style hash_combine: mix each field into the rolling hash.
+    auto mix = [](std::size_t a, std::size_t b) { return a ^ (b + 0x9e3779b97f4a7c15ULL + (a << 6) + (a >> 2)); };
+    std::size_t r = std::hash<int64_t>{}(k.m);
+    r = mix(r, std::hash<int64_t>{}(k.n));
+    r = mix(r, std::hash<int64_t>{}(k.k));
+    r = mix(r, std::hash<int64_t>{}(k.lda));
+    r = mix(r, std::hash<int64_t>{}(k.ldb));
+    r = mix(r, std::hash<int64_t>{}(k.ldc));
+    r = mix(r, std::hash<int>{}(static_cast<int>(k.dtype)));
+    r = mix(r, std::hash<int>{}(static_cast<int>(k.transA)));
+    r = mix(r, std::hash<int>{}(static_cast<int>(k.transB)));
+    return r;
+  }
+};
+
+// A cached cuBLASLt matmul plan: the descriptor, three matrix layouts, and the
+// heuristic-selected algorithm. Destruction releases all four cuBLASLt handles,
+// so LruCache eviction is enough to manage entry lifetime. Move-only, since
+// copying would alias the handles and double-destroy them.
+class CublasLtPlanEntry {
+ public:
+  // If the heuristic returns no usable algorithm, use_cublaslt stays false and
+  // the caller takes the cublasGemmEx fallback path. `max_workspace_bytes` is the
+  // heuristic's ceiling — see gpu::Context::setCublasLtMaxWorkspaceBytes().
+  CublasLtPlanEntry(cublasLtHandle_t lt_handle, const CublasLtPlanKey& key, cublasComputeType_t compute,
+                    cudaDataType_t alpha_type, std::size_t max_workspace_bytes) {
+    EIGEN_CUBLASLT_CHECK(cublasLtMatmulDescCreate(&matmul_desc, compute, alpha_type));
+    EIGEN_CUBLASLT_CHECK(
+        cublasLtMatmulDescSetAttribute(matmul_desc, CUBLASLT_MATMUL_DESC_TRANSA, &key.transA, sizeof(key.transA)));
+    EIGEN_CUBLASLT_CHECK(
+        cublasLtMatmulDescSetAttribute(matmul_desc, CUBLASLT_MATMUL_DESC_TRANSB, &key.transB, sizeof(key.transB)));
+
+    // Layout dimensions are the physical (rows, cols) of the column-major operand;
+    // the leading dimension is the actual stride between columns (lda/ldb/ldc),
+    // which may exceed the active row count (e.g., a thin view of a wider buffer).
+    const int64_t a_rows = (key.transA == CUBLAS_OP_N) ? key.m : key.k;
+    const int64_t a_cols = (key.transA == CUBLAS_OP_N) ? key.k : key.m;
+    const int64_t b_rows = (key.transB == CUBLAS_OP_N) ? key.k : key.n;
+    const int64_t b_cols = (key.transB == CUBLAS_OP_N) ? key.n : key.k;
+    EIGEN_CUBLASLT_CHECK(cublasLtMatrixLayoutCreate(&layout_A, key.dtype, a_rows, a_cols, key.lda));
+    EIGEN_CUBLASLT_CHECK(cublasLtMatrixLayoutCreate(&layout_B, key.dtype, b_rows, b_cols, key.ldb));
+    EIGEN_CUBLASLT_CHECK(cublasLtMatrixLayoutCreate(&layout_C, key.dtype, key.m, key.n, key.ldc));
+
+    cublasLtMatmulPreference_t preference = nullptr;
+    EIGEN_CUBLASLT_CHECK(cublasLtMatmulPreferenceCreate(&preference));
+    EIGEN_CUBLASLT_CHECK(cublasLtMatmulPreferenceSetAttribute(preference, CUBLASLT_MATMUL_PREF_MAX_WORKSPACE_BYTES,
+                                                              &max_workspace_bytes, sizeof(max_workspace_bytes)));
+
+    cublasLtMatmulHeuristicResult_t result;
+    int returned_results = 0;
+    cublasStatus_t heuristic_status = cublasLtMatmulAlgoGetHeuristic(
+        lt_handle, matmul_desc, layout_A, layout_B, layout_C, layout_C, preference, 1, &result, &returned_results);
+
+    EIGEN_CUBLASLT_CHECK(cublasLtMatmulPreferenceDestroy(preference));
+
+    // cublasLtMatmulAlgoGetHeuristic can return CUBLAS_STATUS_SUCCESS overall while
+    // marking individual results NOT_SUPPORTED via result.state, so gate on both.
+    if (heuristic_status == CUBLAS_STATUS_SUCCESS && returned_results > 0 && result.state == CUBLAS_STATUS_SUCCESS) {
+      algo = result.algo;
+      workspace_size = result.workspaceSize;
+      use_cublaslt = true;
+    }
+  }
+
+  ~CublasLtPlanEntry() { destroy(); }
+
+  CublasLtPlanEntry(const CublasLtPlanEntry&) = delete;
+  CublasLtPlanEntry& operator=(const CublasLtPlanEntry&) = delete;
+
+  CublasLtPlanEntry(CublasLtPlanEntry&& o) noexcept
+      : matmul_desc(o.matmul_desc),
+        layout_A(o.layout_A),
+        layout_B(o.layout_B),
+        layout_C(o.layout_C),
+        algo(o.algo),
+        workspace_size(o.workspace_size),
+        use_cublaslt(o.use_cublaslt) {
+    o.matmul_desc = nullptr;
+    o.layout_A = o.layout_B = o.layout_C = nullptr;
+    o.use_cublaslt = false;
+  }
+
+  CublasLtPlanEntry& operator=(CublasLtPlanEntry&& o) noexcept {
+    if (this != &o) {
+      destroy();
+      matmul_desc = o.matmul_desc;
+      layout_A = o.layout_A;
+      layout_B = o.layout_B;
+      layout_C = o.layout_C;
+      algo = o.algo;
+      workspace_size = o.workspace_size;
+      use_cublaslt = o.use_cublaslt;
+      o.matmul_desc = nullptr;
+      o.layout_A = o.layout_B = o.layout_C = nullptr;
+      o.use_cublaslt = false;
+    }
+    return *this;
+  }
+
+  cublasLtMatmulDesc_t matmul_desc = nullptr;
+  cublasLtMatrixLayout_t layout_A = nullptr;
+  cublasLtMatrixLayout_t layout_B = nullptr;
+  cublasLtMatrixLayout_t layout_C = nullptr;
+  cublasLtMatmulAlgo_t algo{};
+  std::size_t workspace_size = 0;
+  bool use_cublaslt = false;
+
+ private:
+  void destroy() noexcept {
+    if (layout_C) cublasLtMatrixLayoutDestroy(layout_C);
+    if (layout_B) cublasLtMatrixLayoutDestroy(layout_B);
+    if (layout_A) cublasLtMatrixLayoutDestroy(layout_A);
+    if (matmul_desc) cublasLtMatmulDescDestroy(matmul_desc);
+  }
+};
+
+using CublasLtPlanCache = Eigen::internal::LruCache<CublasLtPlanKey, CublasLtPlanEntry, CublasLtPlanKeyHash>;
+
+// cublasLtMatmul with a shape-keyed plan cache, falling back to cublasGemmEx for
+// shapes and types the cublasLt heuristic cannot serve. Dimensions are 64-bit on
+// the cublasLt path. `workspace` grows monotonically to the selected algorithm's
+// requirement; neither it nor `plan_cache` is thread-safe, so all calls sharing
+// them must run on one stream.
+template <typename Scalar>
+void cublaslt_gemm(cublasLtHandle_t lt_handle, cublasHandle_t cublas_handle, cublasOperation_t transA,
+                   cublasOperation_t transB, int64_t m, int64_t n, int64_t k, const Scalar* alpha, const Scalar* A,
+                   int64_t lda, const Scalar* B, int64_t ldb, const Scalar* beta, Scalar* C, int64_t ldc,
+                   DeviceBuffer& workspace, CublasLtPlanCache& plan_cache, std::size_t max_workspace_bytes,
+                   cudaStream_t stream) {
+  constexpr cudaDataType_t dtype = cuda_data_type<Scalar>::value;
+  constexpr cublasComputeType_t compute = cuda_compute_type<Scalar>::value;
+  constexpr cudaDataType_t alpha_type = cuda_data_type<Scalar>::value;
+
+  // The key carries the leading dimensions so that strided views — e.g. SVD's
+  // thin VT/U slices — get distinct cache entries.
+  const CublasLtPlanKey key{m, n, k, lda, ldb, ldc, dtype, transA, transB};
+  CublasLtPlanEntry* entry = plan_cache.find(key);
+  if (!entry) {
+    entry = plan_cache.insert(key, CublasLtPlanEntry(lt_handle, key, compute, alpha_type, max_workspace_bytes));
+  }
+
+  if (entry->use_cublaslt) {
+    const size_t needed = entry->workspace_size;
+    if (needed > workspace.size()) {
+      // Sync only when freeing an existing buffer that may be in use.
+      if (workspace.get()) EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream));
+      workspace = DeviceBuffer(needed);
+    }
+
+    EIGEN_CUBLASLT_CHECK(cublasLtMatmul(lt_handle, entry->matmul_desc, alpha, A, entry->layout_A, B, entry->layout_B,
+                                        beta, C, entry->layout_C, C, entry->layout_C, &entry->algo, workspace.get(),
+                                        needed, stream));
+  } else {
+    // Fallback: cublasGemmEx for shapes/types that cublasLt cannot handle.
+    EIGEN_CUBLAS_CHECK(EIGEN_CUBLAS_FN(cublasGemmEx)(
+        cublas_handle, transA, transB, to_blas_dim(m), to_blas_dim(n), to_blas_dim(k), alpha, A, dtype,
+        to_blas_dim(lda), B, dtype, to_blas_dim(ldb), beta, C, dtype, to_blas_dim(ldc), compute, cuda_gemm_algo()));
+  }
+}
+
+// cuBLAS exposes one entry point per scalar type (Sgemm, Dgemm, ...). The
+// cublasX* overloads below recover a type-generic interface over them.
+inline cublasStatus_t cublasXgemm(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, int64_t k, const float* alpha, const float* A, int64_t lda, const float* B,
+                                  int64_t ldb, const float* beta, float* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasSgemm)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), to_blas_dim(k), alpha, A,
+                                      to_blas_dim(lda), B, to_blas_dim(ldb), beta, C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXgemm(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, int64_t k, const double* alpha, const double* A, int64_t lda,
+                                  const double* B, int64_t ldb, const double* beta, double* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasDgemm)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), to_blas_dim(k), alpha, A,
+                                      to_blas_dim(lda), B, to_blas_dim(ldb), beta, C, to_blas_dim(ldc));
+}
+static_assert(sizeof(cuComplex) == sizeof(std::complex<float>), "cuComplex and std::complex<float> layout mismatch");
+static_assert(sizeof(cuDoubleComplex) == sizeof(std::complex<double>),
+              "cuDoubleComplex and std::complex<double> layout mismatch");
+
+// Complex alpha/beta are type-punned from std::complex<T>* to
+// cuComplex*/cuDoubleComplex*. reinterpret_cast violates strict aliasing here:
+// once inlined, clang/MSVC no longer see a read through the original type and
+// elide the caller's store, which segfaults. std::memcpy is the standard-blessed
+// pun. Device array pointers (A, B, C) are never dereferenced by the host
+// compiler, so reinterpret_cast is safe for them.
+inline cublasStatus_t cublasXgemm(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, int64_t k, const std::complex<float>* alpha, const std::complex<float>* A,
+                                  int64_t lda, const std::complex<float>* B, int64_t ldb,
+                                  const std::complex<float>* beta, std::complex<float>* C, int64_t ldc) {
+  cuComplex a, b;
+  std::memcpy(&a, alpha, sizeof(a));
+  std::memcpy(&b, beta, sizeof(b));
+  return EIGEN_CUBLAS_FN(cublasCgemm)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), to_blas_dim(k), &a,
+                                      reinterpret_cast<const cuComplex*>(A), to_blas_dim(lda),
+                                      reinterpret_cast<const cuComplex*>(B), to_blas_dim(ldb), &b,
+                                      reinterpret_cast<cuComplex*>(C), to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXgemm(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, int64_t k, const std::complex<double>* alpha,
+                                  const std::complex<double>* A, int64_t lda, const std::complex<double>* B,
+                                  int64_t ldb, const std::complex<double>* beta, std::complex<double>* C, int64_t ldc) {
+  cuDoubleComplex a, b;
+  std::memcpy(&a, alpha, sizeof(a));
+  std::memcpy(&b, beta, sizeof(b));
+  return EIGEN_CUBLAS_FN(cublasZgemm)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), to_blas_dim(k), &a,
+                                      reinterpret_cast<const cuDoubleComplex*>(A), to_blas_dim(lda),
+                                      reinterpret_cast<const cuDoubleComplex*>(B), to_blas_dim(ldb), &b,
+                                      reinterpret_cast<cuDoubleComplex*>(C), to_blas_dim(ldc));
+}
+
+inline cublasStatus_t cublasXtrsm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo,
+                                  cublasOperation_t trans, cublasDiagType_t diag, int64_t m, int64_t n,
+                                  const float* alpha, const float* A, int64_t lda, float* B, int64_t ldb) {
+  return EIGEN_CUBLAS_FN(cublasStrsm)(h, side, uplo, trans, diag, to_blas_dim(m), to_blas_dim(n), alpha, A,
+                                      to_blas_dim(lda), B, to_blas_dim(ldb));
+}
+inline cublasStatus_t cublasXtrsm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo,
+                                  cublasOperation_t trans, cublasDiagType_t diag, int64_t m, int64_t n,
+                                  const double* alpha, const double* A, int64_t lda, double* B, int64_t ldb) {
+  return EIGEN_CUBLAS_FN(cublasDtrsm)(h, side, uplo, trans, diag, to_blas_dim(m), to_blas_dim(n), alpha, A,
+                                      to_blas_dim(lda), B, to_blas_dim(ldb));
+}
+inline cublasStatus_t cublasXtrsm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo,
+                                  cublasOperation_t trans, cublasDiagType_t diag, int64_t m, int64_t n,
+                                  const std::complex<float>* alpha, const std::complex<float>* A, int64_t lda,
+                                  std::complex<float>* B, int64_t ldb) {
+  cuComplex a;
+  std::memcpy(&a, alpha, sizeof(a));
+  return EIGEN_CUBLAS_FN(cublasCtrsm)(h, side, uplo, trans, diag, to_blas_dim(m), to_blas_dim(n), &a,
+                                      reinterpret_cast<const cuComplex*>(A), to_blas_dim(lda),
+                                      reinterpret_cast<cuComplex*>(B), to_blas_dim(ldb));
+}
+inline cublasStatus_t cublasXtrsm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo,
+                                  cublasOperation_t trans, cublasDiagType_t diag, int64_t m, int64_t n,
+                                  const std::complex<double>* alpha, const std::complex<double>* A, int64_t lda,
+                                  std::complex<double>* B, int64_t ldb) {
+  cuDoubleComplex a;
+  std::memcpy(&a, alpha, sizeof(a));
+  return EIGEN_CUBLAS_FN(cublasZtrsm)(h, side, uplo, trans, diag, to_blas_dim(m), to_blas_dim(n), &a,
+                                      reinterpret_cast<const cuDoubleComplex*>(A), to_blas_dim(lda),
+                                      reinterpret_cast<cuDoubleComplex*>(B), to_blas_dim(ldb));
+}
+
+// SYMM: real → symm, complex → hemm.
+inline cublasStatus_t cublasXsymm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo, int64_t m, int64_t n,
+                                  const float* alpha, const float* A, int64_t lda, const float* B, int64_t ldb,
+                                  const float* beta, float* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasSsymm)(h, side, uplo, to_blas_dim(m), to_blas_dim(n), alpha, A, to_blas_dim(lda), B,
+                                      to_blas_dim(ldb), beta, C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXsymm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo, int64_t m, int64_t n,
+                                  const double* alpha, const double* A, int64_t lda, const double* B, int64_t ldb,
+                                  const double* beta, double* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasDsymm)(h, side, uplo, to_blas_dim(m), to_blas_dim(n), alpha, A, to_blas_dim(lda), B,
+                                      to_blas_dim(ldb), beta, C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXsymm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo, int64_t m, int64_t n,
+                                  const std::complex<float>* alpha, const std::complex<float>* A, int64_t lda,
+                                  const std::complex<float>* B, int64_t ldb, const std::complex<float>* beta,
+                                  std::complex<float>* C, int64_t ldc) {
+  cuComplex a, b;
+  std::memcpy(&a, alpha, sizeof(a));
+  std::memcpy(&b, beta, sizeof(b));
+  return EIGEN_CUBLAS_FN(cublasChemm)(
+      h, side, uplo, to_blas_dim(m), to_blas_dim(n), &a, reinterpret_cast<const cuComplex*>(A), to_blas_dim(lda),
+      reinterpret_cast<const cuComplex*>(B), to_blas_dim(ldb), &b, reinterpret_cast<cuComplex*>(C), to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXsymm(cublasHandle_t h, cublasSideMode_t side, cublasFillMode_t uplo, int64_t m, int64_t n,
+                                  const std::complex<double>* alpha, const std::complex<double>* A, int64_t lda,
+                                  const std::complex<double>* B, int64_t ldb, const std::complex<double>* beta,
+                                  std::complex<double>* C, int64_t ldc) {
+  cuDoubleComplex a, b;
+  std::memcpy(&a, alpha, sizeof(a));
+  std::memcpy(&b, beta, sizeof(b));
+  return EIGEN_CUBLAS_FN(cublasZhemm)(h, side, uplo, to_blas_dim(m), to_blas_dim(n), &a,
+                                      reinterpret_cast<const cuDoubleComplex*>(A), to_blas_dim(lda),
+                                      reinterpret_cast<const cuDoubleComplex*>(B), to_blas_dim(ldb), &b,
+                                      reinterpret_cast<cuDoubleComplex*>(C), to_blas_dim(ldc));
+}
+
+// GEAM: C = alpha * op(A) + beta * op(B).
+inline cublasStatus_t cublasXgeam(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, const float* alpha, const float* A, int64_t lda, const float* beta,
+                                  const float* B, int64_t ldb, float* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasSgeam)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), alpha, A, to_blas_dim(lda),
+                                      beta, B, to_blas_dim(ldb), C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXgeam(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, const double* alpha, const double* A, int64_t lda, const double* beta,
+                                  const double* B, int64_t ldb, double* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasDgeam)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), alpha, A, to_blas_dim(lda),
+                                      beta, B, to_blas_dim(ldb), C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXgeam(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, const std::complex<float>* alpha, const std::complex<float>* A,
+                                  int64_t lda, const std::complex<float>* beta, const std::complex<float>* B,
+                                  int64_t ldb, std::complex<float>* C, int64_t ldc) {
+  cuComplex a, b;
+  std::memcpy(&a, alpha, sizeof(a));
+  std::memcpy(&b, beta, sizeof(b));
+  return EIGEN_CUBLAS_FN(cublasCgeam)(
+      h, transA, transB, to_blas_dim(m), to_blas_dim(n), &a, reinterpret_cast<const cuComplex*>(A), to_blas_dim(lda),
+      &b, reinterpret_cast<const cuComplex*>(B), to_blas_dim(ldb), reinterpret_cast<cuComplex*>(C), to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXgeam(cublasHandle_t h, cublasOperation_t transA, cublasOperation_t transB, int64_t m,
+                                  int64_t n, const std::complex<double>* alpha, const std::complex<double>* A,
+                                  int64_t lda, const std::complex<double>* beta, const std::complex<double>* B,
+                                  int64_t ldb, std::complex<double>* C, int64_t ldc) {
+  cuDoubleComplex a, b;
+  std::memcpy(&a, alpha, sizeof(a));
+  std::memcpy(&b, beta, sizeof(b));
+  return EIGEN_CUBLAS_FN(cublasZgeam)(h, transA, transB, to_blas_dim(m), to_blas_dim(n), &a,
+                                      reinterpret_cast<const cuDoubleComplex*>(A), to_blas_dim(lda), &b,
+                                      reinterpret_cast<const cuDoubleComplex*>(B), to_blas_dim(ldb),
+                                      reinterpret_cast<cuDoubleComplex*>(C), to_blas_dim(ldc));
+}
+
+// SYRK: real → syrk, complex → herk.
+inline cublasStatus_t cublasXsyrk(cublasHandle_t h, cublasFillMode_t uplo, cublasOperation_t trans, int64_t n,
+                                  int64_t k, const float* alpha, const float* A, int64_t lda, const float* beta,
+                                  float* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasSsyrk)(h, uplo, trans, to_blas_dim(n), to_blas_dim(k), alpha, A, to_blas_dim(lda), beta,
+                                      C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXsyrk(cublasHandle_t h, cublasFillMode_t uplo, cublasOperation_t trans, int64_t n,
+                                  int64_t k, const double* alpha, const double* A, int64_t lda, const double* beta,
+                                  double* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasDsyrk)(h, uplo, trans, to_blas_dim(n), to_blas_dim(k), alpha, A, to_blas_dim(lda), beta,
+                                      C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXsyrk(cublasHandle_t h, cublasFillMode_t uplo, cublasOperation_t trans, int64_t n,
+                                  int64_t k, const float* alpha, const std::complex<float>* A, int64_t lda,
+                                  const float* beta, std::complex<float>* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasCherk)(h, uplo, trans, to_blas_dim(n), to_blas_dim(k), alpha,
+                                      reinterpret_cast<const cuComplex*>(A), to_blas_dim(lda), beta,
+                                      reinterpret_cast<cuComplex*>(C), to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXsyrk(cublasHandle_t h, cublasFillMode_t uplo, cublasOperation_t trans, int64_t n,
+                                  int64_t k, const double* alpha, const std::complex<double>* A, int64_t lda,
+                                  const double* beta, std::complex<double>* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasZherk)(h, uplo, trans, to_blas_dim(n), to_blas_dim(k), alpha,
+                                      reinterpret_cast<const cuDoubleComplex*>(A), to_blas_dim(lda), beta,
+                                      reinterpret_cast<cuDoubleComplex*>(C), to_blas_dim(ldc));
+}
+
+// SCAL: x = alpha * x, with real alpha even for complex x (Csscal/Zdscal), as
+// needed by the intrinsically real 1/n inverse-FFT scaling.
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, const float* alpha, float* x, int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasSscal)(h, to_blas_dim(n), alpha, x, to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, const double* alpha, double* x, int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasDscal)(h, to_blas_dim(n), alpha, x, to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, const float* alpha, std::complex<float>* x,
+                                  int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasCsscal)(h, to_blas_dim(n), alpha, reinterpret_cast<cuComplex*>(x), to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, const double* alpha, std::complex<double>* x,
+                                  int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasZdscal)(h, to_blas_dim(n), alpha, reinterpret_cast<cuDoubleComplex*>(x),
+                                       to_blas_dim(incx));
+}
+
+// By-value alpha, for callers holding the scale as a scalar rather than a host
+// pointer (e.g. inverse-FFT 1/n normalization).
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, float alpha, float* x, int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasSscal)(h, to_blas_dim(n), &alpha, x, to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, double alpha, double* x, int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasDscal)(h, to_blas_dim(n), &alpha, x, to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, float alpha, std::complex<float>* x, int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasCsscal)(h, to_blas_dim(n), &alpha, reinterpret_cast<cuComplex*>(x), to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, double alpha, std::complex<double>* x, int64_t incx) {
+  return EIGEN_CUBLAS_FN(cublasZdscal)(h, to_blas_dim(n), &alpha, reinterpret_cast<cuDoubleComplex*>(x),
+                                       to_blas_dim(incx));
+}
+
+// DGMM: C = A * diag(x) (side=RIGHT) or C = diag(x) * A (side=LEFT), applying a
+// diagonal scaling without materialising diag(x). cuBLAS documents C == A as
+// safe.
+inline cublasStatus_t cublasXdgmm(cublasHandle_t h, cublasSideMode_t side, int64_t m, int64_t n, const float* A,
+                                  int64_t lda, const float* x, int64_t incx, float* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasSdgmm)(h, side, to_blas_dim(m), to_blas_dim(n), A, to_blas_dim(lda), x,
+                                      to_blas_dim(incx), C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXdgmm(cublasHandle_t h, cublasSideMode_t side, int64_t m, int64_t n, const double* A,
+                                  int64_t lda, const double* x, int64_t incx, double* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasDdgmm)(h, side, to_blas_dim(m), to_blas_dim(n), A, to_blas_dim(lda), x,
+                                      to_blas_dim(incx), C, to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXdgmm(cublasHandle_t h, cublasSideMode_t side, int64_t m, int64_t n,
+                                  const std::complex<float>* A, int64_t lda, const std::complex<float>* x, int64_t incx,
+                                  std::complex<float>* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasCdgmm)(h, side, to_blas_dim(m), to_blas_dim(n), reinterpret_cast<const cuComplex*>(A),
+                                      to_blas_dim(lda), reinterpret_cast<const cuComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<cuComplex*>(C), to_blas_dim(ldc));
+}
+inline cublasStatus_t cublasXdgmm(cublasHandle_t h, cublasSideMode_t side, int64_t m, int64_t n,
+                                  const std::complex<double>* A, int64_t lda, const std::complex<double>* x,
+                                  int64_t incx, std::complex<double>* C, int64_t ldc) {
+  return EIGEN_CUBLAS_FN(cublasZdgmm)(h, side, to_blas_dim(m), to_blas_dim(n),
+                                      reinterpret_cast<const cuDoubleComplex*>(A), to_blas_dim(lda),
+                                      reinterpret_cast<const cuDoubleComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<cuDoubleComplex*>(C), to_blas_dim(ldc));
+}
+
+// The BLAS-1 wrappers below honour whichever pointer mode the caller set on the
+// handle; under CUBLAS_POINTER_MODE_DEVICE the dot/nrm2 result pointers must
+// address device memory.
+
+// dot: result = x^T * y (real) or x^H * y (complex, conjugating x).
+inline cublasStatus_t cublasXdot(cublasHandle_t h, int64_t n, const float* x, int64_t incx, const float* y,
+                                 int64_t incy, float* result) {
+  return EIGEN_CUBLAS_FN(cublasSdot)(h, to_blas_dim(n), x, to_blas_dim(incx), y, to_blas_dim(incy), result);
+}
+inline cublasStatus_t cublasXdot(cublasHandle_t h, int64_t n, const double* x, int64_t incx, const double* y,
+                                 int64_t incy, double* result) {
+  return EIGEN_CUBLAS_FN(cublasDdot)(h, to_blas_dim(n), x, to_blas_dim(incx), y, to_blas_dim(incy), result);
+}
+inline cublasStatus_t cublasXdot(cublasHandle_t h, int64_t n, const std::complex<float>* x, int64_t incx,
+                                 const std::complex<float>* y, int64_t incy, std::complex<float>* result) {
+  return EIGEN_CUBLAS_FN(cublasCdotc)(h, to_blas_dim(n), reinterpret_cast<const cuComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<const cuComplex*>(y), to_blas_dim(incy),
+                                      reinterpret_cast<cuComplex*>(result));
+}
+inline cublasStatus_t cublasXdot(cublasHandle_t h, int64_t n, const std::complex<double>* x, int64_t incx,
+                                 const std::complex<double>* y, int64_t incy, std::complex<double>* result) {
+  return EIGEN_CUBLAS_FN(cublasZdotc)(h, to_blas_dim(n), reinterpret_cast<const cuDoubleComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<const cuDoubleComplex*>(y), to_blas_dim(incy),
+                                      reinterpret_cast<cuDoubleComplex*>(result));
+}
+
+// nrm2: result = ||x||_2, always real.
+inline cublasStatus_t cublasXnrm2(cublasHandle_t h, int64_t n, const float* x, int64_t incx, float* result) {
+  return EIGEN_CUBLAS_FN(cublasSnrm2)(h, to_blas_dim(n), x, to_blas_dim(incx), result);
+}
+inline cublasStatus_t cublasXnrm2(cublasHandle_t h, int64_t n, const double* x, int64_t incx, double* result) {
+  return EIGEN_CUBLAS_FN(cublasDnrm2)(h, to_blas_dim(n), x, to_blas_dim(incx), result);
+}
+inline cublasStatus_t cublasXnrm2(cublasHandle_t h, int64_t n, const std::complex<float>* x, int64_t incx,
+                                  float* result) {
+  return EIGEN_CUBLAS_FN(cublasScnrm2)(h, to_blas_dim(n), reinterpret_cast<const cuComplex*>(x), to_blas_dim(incx),
+                                       result);
+}
+inline cublasStatus_t cublasXnrm2(cublasHandle_t h, int64_t n, const std::complex<double>* x, int64_t incx,
+                                  double* result) {
+  return EIGEN_CUBLAS_FN(cublasDznrm2)(h, to_blas_dim(n), reinterpret_cast<const cuDoubleComplex*>(x),
+                                       to_blas_dim(incx), result);
+}
+
+// axpy: y += alpha * x.
+inline cublasStatus_t cublasXaxpy(cublasHandle_t h, int64_t n, const float* alpha, const float* x, int64_t incx,
+                                  float* y, int64_t incy) {
+  return EIGEN_CUBLAS_FN(cublasSaxpy)(h, to_blas_dim(n), alpha, x, to_blas_dim(incx), y, to_blas_dim(incy));
+}
+inline cublasStatus_t cublasXaxpy(cublasHandle_t h, int64_t n, const double* alpha, const double* x, int64_t incx,
+                                  double* y, int64_t incy) {
+  return EIGEN_CUBLAS_FN(cublasDaxpy)(h, to_blas_dim(n), alpha, x, to_blas_dim(incx), y, to_blas_dim(incy));
+}
+inline cublasStatus_t cublasXaxpy(cublasHandle_t h, int64_t n, const std::complex<float>* alpha,
+                                  const std::complex<float>* x, int64_t incx, std::complex<float>* y, int64_t incy) {
+  cuComplex a;
+  std::memcpy(&a, alpha, sizeof(a));
+  return EIGEN_CUBLAS_FN(cublasCaxpy)(h, to_blas_dim(n), &a, reinterpret_cast<const cuComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<cuComplex*>(y), to_blas_dim(incy));
+}
+inline cublasStatus_t cublasXaxpy(cublasHandle_t h, int64_t n, const std::complex<double>* alpha,
+                                  const std::complex<double>* x, int64_t incx, std::complex<double>* y, int64_t incy) {
+  cuDoubleComplex a;
+  std::memcpy(&a, alpha, sizeof(a));
+  return EIGEN_CUBLAS_FN(cublasZaxpy)(h, to_blas_dim(n), &a, reinterpret_cast<const cuDoubleComplex*>(x),
+                                      to_blas_dim(incx), reinterpret_cast<cuDoubleComplex*>(y), to_blas_dim(incy));
+}
+
+// SCAL with complex alpha (Cscal/Zscal); the real-alpha forms are above.
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, const std::complex<float>* alpha, std::complex<float>* x,
+                                  int64_t incx) {
+  cuComplex a;
+  std::memcpy(&a, alpha, sizeof(a));
+  return EIGEN_CUBLAS_FN(cublasCscal)(h, to_blas_dim(n), &a, reinterpret_cast<cuComplex*>(x), to_blas_dim(incx));
+}
+inline cublasStatus_t cublasXscal(cublasHandle_t h, int64_t n, const std::complex<double>* alpha,
+                                  std::complex<double>* x, int64_t incx) {
+  cuDoubleComplex a;
+  std::memcpy(&a, alpha, sizeof(a));
+  return EIGEN_CUBLAS_FN(cublasZscal)(h, to_blas_dim(n), &a, reinterpret_cast<cuDoubleComplex*>(x), to_blas_dim(incx));
+}
+
+// copy: y = x.
+inline cublasStatus_t cublasXcopy(cublasHandle_t h, int64_t n, const float* x, int64_t incx, float* y, int64_t incy) {
+  return EIGEN_CUBLAS_FN(cublasScopy)(h, to_blas_dim(n), x, to_blas_dim(incx), y, to_blas_dim(incy));
+}
+inline cublasStatus_t cublasXcopy(cublasHandle_t h, int64_t n, const double* x, int64_t incx, double* y, int64_t incy) {
+  return EIGEN_CUBLAS_FN(cublasDcopy)(h, to_blas_dim(n), x, to_blas_dim(incx), y, to_blas_dim(incy));
+}
+inline cublasStatus_t cublasXcopy(cublasHandle_t h, int64_t n, const std::complex<float>* x, int64_t incx,
+                                  std::complex<float>* y, int64_t incy) {
+  return EIGEN_CUBLAS_FN(cublasCcopy)(h, to_blas_dim(n), reinterpret_cast<const cuComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<cuComplex*>(y), to_blas_dim(incy));
+}
+inline cublasStatus_t cublasXcopy(cublasHandle_t h, int64_t n, const std::complex<double>* x, int64_t incx,
+                                  std::complex<double>* y, int64_t incy) {
+  return EIGEN_CUBLAS_FN(cublasZcopy)(h, to_blas_dim(n), reinterpret_cast<const cuDoubleComplex*>(x), to_blas_dim(incx),
+                                      reinterpret_cast<cuDoubleComplex*>(y), to_blas_dim(incy));
+}
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_CUBLAS_SUPPORT_H
diff --git a/contrib/Eigen/src/GPU/CuDssSupport.h b/contrib/Eigen/src/GPU/CuDssSupport.h
new file mode 100644
index 0000000..8664968
--- /dev/null
+++ b/contrib/Eigen/src/GPU/CuDssSupport.h
@@ -0,0 +1,139 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// cuDSS-specific support types. cuDSS is NVIDIA's sparse direct solver library
+// (Cholesky, LDL^T, LU); it requires CUDA 12.0+ and ships separately from the
+// CUDA Toolkit.
+
+#ifndef EIGEN_GPU_CUDSS_SUPPORT_H
+#define EIGEN_GPU_CUDSS_SUPPORT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSupport.h"
+#include <cudss.h>
+
+/** 1 when the cuDSS headers this translation unit sees name the algorithms
+ * gpu::SparseSolverConfig forwards (cuDSS >= 0.8), 0 otherwise. Where it is 0,
+ * the algorithm enumerators are not declared and setConfig() rejects every
+ * non-default field, so a caller that has to adapt its behavior branches on
+ * this macro. */
+#if defined(CUDSS_VERSION) && CUDSS_VERSION >= 800
+#define EIGEN_HAS_CUDSS_SOLVER_CONFIG 1
+#else
+#define EIGEN_HAS_CUDSS_SOLVER_CONFIG 0
+#endif
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+#define EIGEN_CUDSS_CHECK(x)                                              \
+  do {                                                                    \
+    cudssStatus_t _s = (x);                                               \
+    eigen_assert(_s == CUDSS_STATUS_SUCCESS && "cuDSS call failed: " #x); \
+    EIGEN_UNUSED_VARIABLE(_s);                                            \
+  } while (0)
+
+// cuDSS 0.8 changed cudssMatrixCreateDn/Csr from cudaDataType_t to the
+// value-compatible cudssDataType_t (CUDSS_R_32F == CUDA_R_32F, ...). Map the
+// module's cudaDataType_t traits through this alias so both API generations
+// compile.
+#if defined(CUDSS_VERSION) && CUDSS_VERSION >= 800
+using cudss_value_type_t = cudssDataType_t;
+#else
+using cudss_value_type_t = cudaDataType_t;
+#endif
+
+constexpr cudss_value_type_t to_cudss_data_type(cudaDataType_t t) { return static_cast<cudss_value_type_t>(t); }
+
+template <typename Scalar>
+struct cudss_spd_type;
+
+template <>
+struct cudss_spd_type<float> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_SPD;
+};
+template <>
+struct cudss_spd_type<double> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_SPD;
+};
+template <>
+struct cudss_spd_type<std::complex<float>> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_HPD;
+};
+template <>
+struct cudss_spd_type<std::complex<double>> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_HPD;
+};
+
+// Real → SYMMETRIC (A = A^T), complex → HERMITIAN (A = A^H). cuDSS also accepts
+// CUDSS_MTYPE_SYMMETRIC for complex (A = A^T, no conjugation), but SparseLDLT
+// implements Eigen's SimplicialLDLT semantics, which are Hermitian for complex.
+// Complex symmetric would need a separate trait and solver mode.
+template <typename Scalar>
+struct cudss_hermitian_type;
+
+template <>
+struct cudss_hermitian_type<float> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_SYMMETRIC;
+};
+template <>
+struct cudss_hermitian_type<double> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_SYMMETRIC;
+};
+template <>
+struct cudss_hermitian_type<std::complex<float>> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_HERMITIAN;
+};
+template <>
+struct cudss_hermitian_type<std::complex<double>> {
+  static constexpr cudssMatrixType_t value = CUDSS_MTYPE_HERMITIAN;
+};
+
+template <typename StorageIndex>
+struct cudss_index_type;
+
+template <>
+struct cudss_index_type<int> {
+  static constexpr cudaDataType_t value = CUDA_R_32I;
+};
+template <>
+struct cudss_index_type<int64_t> {
+  static constexpr cudaDataType_t value = CUDA_R_64I;
+};
+
+// A symmetric matrix stored as CSC (ColMajor) reaches cuDSS as CSR of A^T. The
+// data is identical since A = A^T, but the triangle view must be swapped.
+template <int UpLo, int StorageOrder>
+struct cudss_view_type;
+
+template <>
+struct cudss_view_type<Lower, ColMajor> {
+  static constexpr cudssMatrixViewType_t value = CUDSS_MVIEW_UPPER;
+};
+template <>
+struct cudss_view_type<Upper, ColMajor> {
+  static constexpr cudssMatrixViewType_t value = CUDSS_MVIEW_LOWER;
+};
+
+template <>
+struct cudss_view_type<Lower, RowMajor> {
+  static constexpr cudssMatrixViewType_t value = CUDSS_MVIEW_LOWER;
+};
+template <>
+struct cudss_view_type<Upper, RowMajor> {
+  static constexpr cudssMatrixViewType_t value = CUDSS_MVIEW_UPPER;
+};
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_CUDSS_SUPPORT_H
diff --git a/contrib/Eigen/src/GPU/CuFftSupport.h b/contrib/Eigen/src/GPU/CuFftSupport.h
new file mode 100644
index 0000000..94db97a
--- /dev/null
+++ b/contrib/Eigen/src/GPU/CuFftSupport.h
@@ -0,0 +1,134 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// cuFFT-specific support types.
+
+#ifndef EIGEN_GPU_CUFFT_SUPPORT_H
+#define EIGEN_GPU_CUFFT_SUPPORT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSupport.h"
+#include <cufft.h>
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+#define EIGEN_CUFFT_CHECK(x)                                       \
+  do {                                                             \
+    cufftResult _r = (x);                                          \
+    eigen_assert(_r == CUFFT_SUCCESS && "cuFFT call failed: " #x); \
+    EIGEN_UNUSED_VARIABLE(_r);                                     \
+  } while (0)
+
+template <typename Scalar>
+struct cufft_c2c_type;
+
+template <>
+struct cufft_c2c_type<float> {
+  static constexpr cufftType value = CUFFT_C2C;
+};
+template <>
+struct cufft_c2c_type<double> {
+  static constexpr cufftType value = CUFFT_Z2Z;
+};
+
+template <typename Scalar>
+struct cufft_r2c_type;
+
+template <>
+struct cufft_r2c_type<float> {
+  static constexpr cufftType value = CUFFT_R2C;
+};
+template <>
+struct cufft_r2c_type<double> {
+  static constexpr cufftType value = CUFFT_D2Z;
+};
+
+template <typename Scalar>
+struct cufft_c2r_type;
+
+template <>
+struct cufft_c2r_type<float> {
+  static constexpr cufftType value = CUFFT_C2R;
+};
+template <>
+struct cufft_c2r_type<double> {
+  static constexpr cufftType value = CUFFT_Z2D;
+};
+
+// Move-only owner of a cufftHandle. Used as an LruCache Value type so eviction
+// destroys the plan through this destructor, with no callback machinery in the
+// cache itself.
+class CufftPlan {
+ public:
+  CufftPlan() = default;
+  explicit CufftPlan(cufftHandle plan) : plan_(plan), owns_(true) {}
+
+  CufftPlan(const CufftPlan&) = delete;
+  CufftPlan& operator=(const CufftPlan&) = delete;
+
+  CufftPlan(CufftPlan&& o) noexcept : plan_(o.plan_), owns_(o.owns_) { o.owns_ = false; }
+
+  CufftPlan& operator=(CufftPlan&& o) noexcept {
+    if (this != &o) {
+      destroy();
+      plan_ = o.plan_;
+      owns_ = o.owns_;
+      o.owns_ = false;
+    }
+    return *this;
+  }
+
+  ~CufftPlan() { destroy(); }
+
+  cufftHandle get() const { return plan_; }
+
+ private:
+  void destroy() noexcept {
+    if (owns_) (void)cufftDestroy(plan_);
+    owns_ = false;
+  }
+
+  cufftHandle plan_{};
+  bool owns_ = false;
+};
+
+inline cufftResult cufftExecC2C_dispatch(cufftHandle plan, std::complex<float>* in, std::complex<float>* out,
+                                         int direction) {
+  return cufftExecC2C(plan, reinterpret_cast<cufftComplex*>(in), reinterpret_cast<cufftComplex*>(out), direction);
+}
+inline cufftResult cufftExecC2C_dispatch(cufftHandle plan, std::complex<double>* in, std::complex<double>* out,
+                                         int direction) {
+  return cufftExecZ2Z(plan, reinterpret_cast<cufftDoubleComplex*>(in), reinterpret_cast<cufftDoubleComplex*>(out),
+                      direction);
+}
+
+inline cufftResult cufftExecR2C_dispatch(cufftHandle plan, float* in, std::complex<float>* out) {
+  return cufftExecR2C(plan, in, reinterpret_cast<cufftComplex*>(out));
+}
+inline cufftResult cufftExecR2C_dispatch(cufftHandle plan, double* in, std::complex<double>* out) {
+  return cufftExecD2Z(plan, in, reinterpret_cast<cufftDoubleComplex*>(out));
+}
+
+inline cufftResult cufftExecC2R_dispatch(cufftHandle plan, std::complex<float>* in, float* out) {
+  return cufftExecC2R(plan, reinterpret_cast<cufftComplex*>(in), out);
+}
+inline cufftResult cufftExecC2R_dispatch(cufftHandle plan, std::complex<double>* in, double* out) {
+  return cufftExecZ2D(plan, reinterpret_cast<cufftDoubleComplex*>(in), out);
+}
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_CUFFT_SUPPORT_H
diff --git a/contrib/Eigen/src/GPU/CuSolverSupport.h b/contrib/Eigen/src/GPU/CuSolverSupport.h
new file mode 100644
index 0000000..6d4f6f9
--- /dev/null
+++ b/contrib/Eigen/src/GPU/CuSolverSupport.h
@@ -0,0 +1,184 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// cuSOLVER-specific support types. Generic CUDA runtime utilities (DeviceBuffer,
+// EIGEN_CUDA_RUNTIME_CHECK) live in GpuSupport.h.
+
+#ifndef EIGEN_GPU_CUSOLVER_SUPPORT_H
+#define EIGEN_GPU_CUSOLVER_SUPPORT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSupport.h"
+#include <cusolverDn.h>
+#include <cstdio>
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+// cuSOLVER's public API has no cusolverGetErrorString(), so failed asserts would
+// otherwise carry a bare numeric code.
+inline const char* cusolver_status_name(cusolverStatus_t s) {
+  switch (s) {
+    case CUSOLVER_STATUS_SUCCESS:
+      return "CUSOLVER_STATUS_SUCCESS";
+    case CUSOLVER_STATUS_NOT_INITIALIZED:
+      return "CUSOLVER_STATUS_NOT_INITIALIZED";
+    case CUSOLVER_STATUS_ALLOC_FAILED:
+      return "CUSOLVER_STATUS_ALLOC_FAILED";
+    case CUSOLVER_STATUS_INVALID_VALUE:
+      return "CUSOLVER_STATUS_INVALID_VALUE";
+    case CUSOLVER_STATUS_ARCH_MISMATCH:
+      return "CUSOLVER_STATUS_ARCH_MISMATCH";
+    case CUSOLVER_STATUS_EXECUTION_FAILED:
+      return "CUSOLVER_STATUS_EXECUTION_FAILED";
+    case CUSOLVER_STATUS_INTERNAL_ERROR:
+      return "CUSOLVER_STATUS_INTERNAL_ERROR";
+    case CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED:
+      return "CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED";
+    case CUSOLVER_STATUS_NOT_SUPPORTED:
+      return "CUSOLVER_STATUS_NOT_SUPPORTED";
+    default:
+      return "CUSOLVER_STATUS_UNKNOWN";
+  }
+}
+
+inline bool report_cusolver_failure(cusolverStatus_t s, const char* expr, const char* file, int line) {
+  std::fprintf(stderr,
+               "cuSOLVER call failed\n"
+               "  expr:   %s\n"
+               "  status: %s (%d)\n"
+               "  at:     %s:%d\n",
+               expr, cusolver_status_name(s), static_cast<int>(s), file, line);
+  return false;
+}
+
+#define EIGEN_CUSOLVER_CHECK(expr)                                                                \
+  do {                                                                                            \
+    cusolverStatus_t _s = (expr);                                                                 \
+    eigen_assert(_s == CUSOLVER_STATUS_SUCCESS ||                                                 \
+                 ::Eigen::gpu::internal::report_cusolver_failure(_s, #expr, __FILE__, __LINE__)); \
+  } while (0)
+
+struct CusolverParams {
+  cusolverDnParams_t p = nullptr;
+
+  CusolverParams() { EIGEN_CUSOLVER_CHECK(cusolverDnCreateParams(&p)); }
+
+  ~CusolverParams() {
+    if (p) (void)cusolverDnDestroyParams(p);  // noexcept context: cannot propagate
+  }
+
+  CusolverParams(CusolverParams&& o) noexcept : p(o.p) { o.p = nullptr; }
+  CusolverParams& operator=(CusolverParams&& o) noexcept {
+    if (this != &o) {
+      if (p) (void)cusolverDnDestroyParams(p);  // noexcept context: cannot propagate
+      p = o.p;
+      o.p = nullptr;
+    }
+    return *this;
+  }
+
+  CusolverParams(const CusolverParams&) = delete;
+  CusolverParams& operator=(const CusolverParams&) = delete;
+};
+
+// RAII cuSOLVER dense handle; the ownership flag supports handles borrowed from a gpu::Context.
+struct CusolverHandleDeleter {
+  bool owns = true;
+  void operator()(cusolverDnHandle_t h) const noexcept {
+    if (owns && h) (void)cusolverDnDestroy(h);
+  }
+};
+using UniqueCusolverHandle = std::unique_ptr<std::remove_pointer_t<cusolverDnHandle_t>, CusolverHandleDeleter>;
+
+// Alias kept for compatibility; cuda_data_type<> in GpuSupport.h is canonical.
+template <typename Scalar>
+using cusolver_data_type = cuda_data_type<Scalar>;
+
+// cuSOLVER always interprets the matrix as column-major, so callers must pass the
+// triangle that holds the data in column-major layout.
+template <int UpLo>
+struct cusolver_fill_mode;
+
+template <>
+struct cusolver_fill_mode<Lower> {
+  static constexpr cublasFillMode_t value = CUBLAS_FILL_MODE_LOWER;
+};
+template <>
+struct cusolver_fill_mode<Upper> {
+  static constexpr cublasFillMode_t value = CUBLAS_FILL_MODE_UPPER;
+};
+
+// cuSOLVER ships no generic X variant for ormqr/unmqr, so these overloads supply
+// one: real → ormqr (orthogonal Q), complex → unmqr (unitary Q).
+inline cusolverStatus_t cusolverDnXormqr(cusolverDnHandle_t h, cublasSideMode_t side, cublasOperation_t trans, int m,
+                                         int n, int k, const float* A, int lda, const float* tau, float* C, int ldc,
+                                         float* work, int lwork, int* info) {
+  return cusolverDnSormqr(h, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, info);
+}
+inline cusolverStatus_t cusolverDnXormqr(cusolverDnHandle_t h, cublasSideMode_t side, cublasOperation_t trans, int m,
+                                         int n, int k, const double* A, int lda, const double* tau, double* C, int ldc,
+                                         double* work, int lwork, int* info) {
+  return cusolverDnDormqr(h, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, info);
+}
+inline cusolverStatus_t cusolverDnXormqr(cusolverDnHandle_t h, cublasSideMode_t side, cublasOperation_t trans, int m,
+                                         int n, int k, const std::complex<float>* A, int lda,
+                                         const std::complex<float>* tau, std::complex<float>* C, int ldc,
+                                         std::complex<float>* work, int lwork, int* info) {
+  return cusolverDnCunmqr(h, side, trans, m, n, k, reinterpret_cast<const cuComplex*>(A), lda,
+                          reinterpret_cast<const cuComplex*>(tau), reinterpret_cast<cuComplex*>(C), ldc,
+                          reinterpret_cast<cuComplex*>(work), lwork, info);
+}
+inline cusolverStatus_t cusolverDnXormqr(cusolverDnHandle_t h, cublasSideMode_t side, cublasOperation_t trans, int m,
+                                         int n, int k, const std::complex<double>* A, int lda,
+                                         const std::complex<double>* tau, std::complex<double>* C, int ldc,
+                                         std::complex<double>* work, int lwork, int* info) {
+  return cusolverDnZunmqr(h, side, trans, m, n, k, reinterpret_cast<const cuDoubleComplex*>(A), lda,
+                          reinterpret_cast<const cuDoubleComplex*>(tau), reinterpret_cast<cuDoubleComplex*>(C), ldc,
+                          reinterpret_cast<cuDoubleComplex*>(work), lwork, info);
+}
+
+inline cusolverStatus_t cusolverDnXormqr_bufferSize(cusolverDnHandle_t h, cublasSideMode_t side,
+                                                    cublasOperation_t trans, int m, int n, int k, const float* A,
+                                                    int lda, const float* tau, const float* C, int ldc, int* lwork) {
+  return cusolverDnSormqr_bufferSize(h, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
+}
+inline cusolverStatus_t cusolverDnXormqr_bufferSize(cusolverDnHandle_t h, cublasSideMode_t side,
+                                                    cublasOperation_t trans, int m, int n, int k, const double* A,
+                                                    int lda, const double* tau, const double* C, int ldc, int* lwork) {
+  return cusolverDnDormqr_bufferSize(h, side, trans, m, n, k, A, lda, tau, C, ldc, lwork);
+}
+inline cusolverStatus_t cusolverDnXormqr_bufferSize(cusolverDnHandle_t h, cublasSideMode_t side,
+                                                    cublasOperation_t trans, int m, int n, int k,
+                                                    const std::complex<float>* A, int lda,
+                                                    const std::complex<float>* tau, const std::complex<float>* C,
+                                                    int ldc, int* lwork) {
+  return cusolverDnCunmqr_bufferSize(h, side, trans, m, n, k, reinterpret_cast<const cuComplex*>(A), lda,
+                                     reinterpret_cast<const cuComplex*>(tau), reinterpret_cast<const cuComplex*>(C),
+                                     ldc, lwork);
+}
+inline cusolverStatus_t cusolverDnXormqr_bufferSize(cusolverDnHandle_t h, cublasSideMode_t side,
+                                                    cublasOperation_t trans, int m, int n, int k,
+                                                    const std::complex<double>* A, int lda,
+                                                    const std::complex<double>* tau, const std::complex<double>* C,
+                                                    int ldc, int* lwork) {
+  return cusolverDnZunmqr_bufferSize(h, side, trans, m, n, k, reinterpret_cast<const cuDoubleComplex*>(A), lda,
+                                     reinterpret_cast<const cuDoubleComplex*>(tau),
+                                     reinterpret_cast<const cuDoubleComplex*>(C), ldc, lwork);
+}
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_CUSOLVER_SUPPORT_H
diff --git a/contrib/Eigen/src/GPU/CuSparseSupport.h b/contrib/Eigen/src/GPU/CuSparseSupport.h
new file mode 100644
index 0000000..de6e859
--- /dev/null
+++ b/contrib/Eigen/src/GPU/CuSparseSupport.h
@@ -0,0 +1,101 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// cuSPARSE-specific support types.
+
+#ifndef EIGEN_GPU_CUSPARSE_SUPPORT_H
+#define EIGEN_GPU_CUSPARSE_SUPPORT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSupport.h"
+#include "./Meta.h"
+#include <cusparse.h>
+
+/** \brief 1 when cuSPARSE runs SpMV and SpMM on BSR (block sparse row)
+ * descriptors, 0 otherwise.
+ *
+ * The generic API gained BSR in SpMM with cuSPARSE 12.5 (CUDA 12.8) and in SpMV
+ * with 12.6.3 (CUDA 13.0 Update 1); older toolkits declare cusparseCreateBsr but
+ * return CUSPARSE_STATUS_NOT_SUPPORTED from the products. gpu::SparseContext
+ * uploads a BlockSparseMatrix as BSR only when this is 1, and as CSC otherwise. */
+#if defined(CUSPARSE_VERSION) && CUSPARSE_VERSION >= 12603
+#define EIGEN_HAS_CUSPARSE_BSR 1
+#else
+#define EIGEN_HAS_CUSPARSE_BSR 0
+#endif
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+#define EIGEN_CUSPARSE_CHECK(x)                                                 \
+  do {                                                                          \
+    cusparseStatus_t _s = (x);                                                  \
+    eigen_assert(_s == CUSPARSE_STATUS_SUCCESS && "cuSPARSE call failed: " #x); \
+    EIGEN_UNUSED_VARIABLE(_s);                                                  \
+  } while (0)
+
+// cuSPARSE rejects CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE for real scalar
+// types; for real Scalar, ConjTrans is mathematically equivalent to Trans and
+// is silently demoted. Complex Scalar passes through unchanged.
+template <typename Scalar>
+constexpr cusparseOperation_t to_cusparse_op(GpuOp op) {
+  const auto op_ = (op == GpuOp::ConjTrans && !NumTraits<Scalar>::IsComplex) ? GpuOp::Trans : op;
+  switch (op_) {
+    case GpuOp::Trans:
+      return CUSPARSE_OPERATION_TRANSPOSE;
+    case GpuOp::ConjTrans:
+      return CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE;
+    default:
+      return CUSPARSE_OPERATION_NON_TRANSPOSE;
+  }
+}
+
+// Bind without copying when the input already has the target sparse format
+// and is compressed; otherwise convert/compress into `storage` and return
+// that. Avoids a full host copy + format conversion on the common
+// already-matching path. The SFINAE split (rather than plain overloading on
+// `const SpMatType&`) is load-bearing: an exact-match overload would bind a
+// converted temporary for other input types and return a dangling reference.
+template <typename SpMatType, typename InputType, require_same_t<SpMatType, InputType> = 0>
+const SpMatType& bind_sparse(const InputType& A, SpMatType& storage) {
+  if (A.isCompressed()) return A;
+  storage = A;
+  storage.makeCompressed();
+  return storage;
+}
+
+template <typename SpMatType, typename InputType, require_not_same_t<SpMatType, InputType> = 0>
+const SpMatType& bind_sparse(const InputType& A, SpMatType& storage) {
+  storage = A;
+  storage.makeCompressed();
+  return storage;
+}
+
+// Shared guard for the 32-bit index limits of the CUDA sparse libraries
+// (cuSPARSE, cuDSS): matrix dimensions and nonzero count must fit StorageIndex.
+template <typename StorageIndex>
+inline void check_storage_index_bounds(Index rows, Index cols, Index nnz) {
+  const Index max_storage_index = static_cast<Index>((std::numeric_limits<StorageIndex>::max)());
+  eigen_assert(rows <= max_storage_index && cols <= max_storage_index && nnz <= max_storage_index &&
+               "matrix dimensions or nonzeros exceed the index range supported by the CUDA sparse libraries");
+  EIGEN_UNUSED_VARIABLE(rows);
+  EIGEN_UNUSED_VARIABLE(cols);
+  EIGEN_UNUSED_VARIABLE(nnz);
+  EIGEN_UNUSED_VARIABLE(max_storage_index);
+}
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_CUSPARSE_SUPPORT_H
diff --git a/contrib/Eigen/src/GPU/DeviceBlasExpr.h b/contrib/Eigen/src/GPU/DeviceBlasExpr.h
new file mode 100644
index 0000000..87f18f1
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceBlasExpr.h
@@ -0,0 +1,137 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// BLAS Level 3 expression types for gpu::DeviceMatrix beyond GEMM: triangular
+// solve, self-adjoint multiply, and rank-k update.
+
+#ifndef EIGEN_GPU_DEVICE_BLAS_EXPR_H
+#define EIGEN_GPU_DEVICE_BLAS_EXPR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <functional>
+
+#include "./FwdDecl.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** d_A.triangularView<Lower>(), whose solve() builds a TrsmExpr. */
+template <typename Scalar_, int UpLo_>
+class TriangularView {
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  explicit TriangularView(const DeviceMatrix<Scalar>& m) : mat_(m) {}
+  const DeviceMatrix<Scalar>& matrix() const { return mat_; }
+
+  TrsmExpr<Scalar, UpLo_> solve(const DeviceMatrix<Scalar>& rhs) const { return {mat_, rhs}; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> mat_;
+};
+
+/** triangularView<UpLo>().solve(B), dispatched to cublasXtrsm. */
+template <typename Scalar_, int UpLo_>
+class TrsmExpr {
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  TrsmExpr(const DeviceMatrix<Scalar>& A, const DeviceMatrix<Scalar>& B) : A_(A), B_(B) {}
+  const DeviceMatrix<Scalar>& matrix() const { return A_; }
+  const DeviceMatrix<Scalar>& rhs() const { return B_; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> A_;
+  std::reference_wrapper<const DeviceMatrix<Scalar>> B_;
+};
+
+/** d_A.selfadjointView<Lower>(), which supports view * d_B and rankUpdate(). */
+template <typename Scalar_, int UpLo_>
+class SelfAdjointView {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  static constexpr int UpLo = UpLo_;
+
+  explicit SelfAdjointView(DeviceMatrix<Scalar>& m) : mat_(m) {}
+  const DeviceMatrix<Scalar>& matrix() const { return mat_; }
+  DeviceMatrix<Scalar>& matrix() { return mat_; }
+
+  /** C = alpha * A * A^H + C, writing only the UpLo triangle. Maps to
+   * cublasXsyrk (real) or cublasXherk (complex). */
+  void rankUpdate(const DeviceMatrix<Scalar>& A, RealScalar alpha = RealScalar(1));
+
+ private:
+  std::reference_wrapper<DeviceMatrix<Scalar>> mat_;
+};
+
+/** Const variant, supporting multiplication but not rankUpdate. */
+template <typename Scalar_, int UpLo_>
+class ConstSelfAdjointView {
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  explicit ConstSelfAdjointView(const DeviceMatrix<Scalar>& m) : mat_(m) {}
+  const DeviceMatrix<Scalar>& matrix() const { return mat_; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> mat_;
+};
+
+/** selfadjointView<UpLo>() * B, dispatched to cublasXsymm (real) or
+ * cublasXhemm (complex). */
+template <typename Scalar_, int UpLo_>
+class SymmExpr {
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  SymmExpr(const DeviceMatrix<Scalar>& A, const DeviceMatrix<Scalar>& B) : A_(A), B_(B) {}
+  const DeviceMatrix<Scalar>& matrix() const { return A_; }
+  const DeviceMatrix<Scalar>& rhs() const { return B_; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> A_;
+  std::reference_wrapper<const DeviceMatrix<Scalar>> B_;
+};
+
+template <typename S, int UpLo>
+SymmExpr<S, UpLo> operator*(const SelfAdjointView<S, UpLo>& a, const DeviceMatrix<S>& b) {
+  return {a.matrix(), b};
+}
+template <typename S, int UpLo>
+SymmExpr<S, UpLo> operator*(const ConstSelfAdjointView<S, UpLo>& a, const DeviceMatrix<S>& b) {
+  return {a.matrix(), b};
+}
+
+/** C.rankUpdate(A), i.e. C += A * A^H, dispatched to cublasXsyrk (real) or
+ * cublasXherk (complex). */
+template <typename Scalar_, int UpLo_>
+class SyrkExpr {
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  SyrkExpr(const DeviceMatrix<Scalar>& A) : A_(A) {}
+  const DeviceMatrix<Scalar>& matrix() const { return A_; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> A_;
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_BLAS_EXPR_H
diff --git a/contrib/Eigen/src/GPU/DeviceDispatch.h b/contrib/Eigen/src/GPU/DeviceDispatch.h
new file mode 100644
index 0000000..bd6511e
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceDispatch.h
@@ -0,0 +1,816 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Dispatch functions mapping DeviceMatrix expressions to NVIDIA library calls,
+// plus the DeviceMatrix members that need a complete gpu::Context. The
+// expression argument selects the dispatch() overload.
+
+#ifndef EIGEN_GPU_DEVICE_DISPATCH_H
+#define EIGEN_GPU_DEVICE_DISPATCH_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <cstdint>
+
+#include "./DeviceExpr.h"
+#include "./DeviceBlasExpr.h"
+#include "./DeviceSolverExpr.h"
+#include "./GpuContext.h"
+#include "./CuSolverSupport.h"
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+template <typename Scalar>
+bool aliases_device_memory(const DeviceMatrix<Scalar>& a, const DeviceMatrix<Scalar>& b) {
+  return a.data() != nullptr && a.data() == b.data();
+}
+
+template <typename Lhs, typename Rhs>
+void dispatch(Context& ctx, DeviceMatrix<scalar_type_t<Lhs>>& dst, const GemmExpr<Lhs, Rhs>& expr,
+              scalar_type_t<Lhs> beta_val, scalar_type_t<Lhs> alpha_scale = scalar_type_t<Lhs>(1)) {
+  using Scalar = scalar_type_t<Lhs>;
+  using traits_lhs = device_expr_traits<Lhs>;
+  using traits_rhs = device_expr_traits<Rhs>;
+
+  const DeviceMatrix<Scalar>& A = traits_lhs::matrix(expr.lhs());
+  const DeviceMatrix<Scalar>& B = traits_rhs::matrix(expr.rhs());
+
+  // cuBLAS leaves C aliasing A or B undefined.
+  eigen_assert(!aliases_device_memory(dst, A) && "GEMM: output aliases left operand (use a temporary)");
+  eigen_assert(!aliases_device_memory(dst, B) && "GEMM: output aliases right operand (use a temporary)");
+
+  constexpr cublasOperation_t transA = to_cublas_op(traits_lhs::op);
+  constexpr cublasOperation_t transB = to_cublas_op(traits_rhs::op);
+
+  const int64_t m = (traits_lhs::op == GpuOp::NoTrans) ? A.rows() : A.cols();
+  const int64_t k = (traits_lhs::op == GpuOp::NoTrans) ? A.cols() : A.rows();
+  const int64_t n = (traits_rhs::op == GpuOp::NoTrans) ? B.cols() : B.rows();
+  const int64_t rhs_k = (traits_rhs::op == GpuOp::NoTrans) ? B.rows() : B.cols();
+
+  eigen_assert(k == rhs_k && "DeviceMatrix GEMM dimension mismatch");
+
+  const int64_t lda = A.rows();
+  const int64_t ldb = B.rows();
+
+  if (!dst.empty()) {
+    dst.waitReady(ctx.stream());
+  }
+
+  const bool resized = dst.empty() || dst.rows() != m || dst.cols() != n;
+  if (resized) {
+    dst.resize(m, n);
+  }
+  const int64_t ldc = dst.rows();
+
+  Scalar alpha_local = alpha_scale * traits_lhs::alpha(expr.lhs()) * traits_rhs::alpha(expr.rhs());
+
+  A.waitReady(ctx.stream());
+  B.waitReady(ctx.stream());
+
+  if (resized && beta_val != Scalar(0) && dst.sizeInBytes() > 0) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemsetAsync(dst.data(), 0, dst.sizeInBytes(), ctx.stream()));
+  }
+
+  // cuBLAS reads alpha and beta through host pointers. Holding them in an array
+  // keeps the compiler from eliding their stack slots — at -O1+ clang and MSVC
+  // otherwise drop the stores for complex types, leaving cuBLAS with a dangling
+  // pointer.
+  Scalar scalars[2] = {alpha_local, beta_val};
+  cublaslt_gemm(ctx.cublasLtHandle(), ctx.cublasHandle(), transA, transB, m, n, k, &scalars[0], A.data(), lda, B.data(),
+                ldb, &scalars[1], dst.data(), ldc, ctx.gemmWorkspace(), ctx.gemmPlanCache(),
+                ctx.cublasLtMaxWorkspaceBytes(), ctx.stream());
+
+  dst.recordReady(ctx.stream());
+}
+
+// Debug-build status check shared by the one-shot solver dispatches: syncs
+// the stream and asserts on the two info words (factorize, solve). Release
+// builds skip both the check and the sync — one-shot expressions are then
+// fully async with no failure detection; use gpu::LLT / gpu::LU + info()
+// when failures must be detected.
+inline void oneshot_check_info(Context& ctx, OneShotSolverScratch& scratch, const char* what) {
+#ifdef EIGEN_NO_DEBUG
+  EIGEN_UNUSED_VARIABLE(ctx);
+  EIGEN_UNUSED_VARIABLE(scratch);
+  EIGEN_UNUSED_VARIABLE(what);
+#else
+  int* info_words = static_cast<int*>(scratch.h_info.get());
+  EIGEN_CUDA_RUNTIME_CHECK(
+      cudaMemcpyAsync(info_words, scratch.d_info.get(), kOneShotInfoBytes, cudaMemcpyDeviceToHost, ctx.stream()));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx.stream()));
+  eigen_assert(info_words[0] == 0 && "cuSOLVER one-shot factorization failed" && what);
+  eigen_assert(info_words[1] == 0 && "cuSOLVER one-shot solve failed" && what);
+  EIGEN_UNUSED_VARIABLE(what);
+#endif
+}
+
+template <typename Scalar, int UpLo>
+void dispatch(Context& ctx, DeviceMatrix<Scalar>& dst, const LltSolveExpr<Scalar, UpLo>& expr) {
+  const DeviceMatrix<Scalar>& A = expr.matrix();
+  const DeviceMatrix<Scalar>& B = expr.rhs();
+
+  eigen_assert(A.rows() == A.cols() && "LLT requires a square matrix");
+  eigen_assert(B.rows() == A.rows() && "LLT solve: RHS rows must match matrix size");
+
+  if (A.rows() == 0 || B.cols() == 0) {
+    if (!dst.empty()) dst.waitReady(ctx.stream());
+    dst.resize(A.rows(), B.cols());
+    return;
+  }
+
+  A.waitReady(ctx.stream());
+  B.waitReady(ctx.stream());
+  if (!dst.empty()) dst.waitReady(ctx.stream());
+
+  // thread_local: must outlive the async kernels (no end-of-call sync), and
+  // only TUs that instantiate the one-shot path pull in cuSOLVER symbols.
+  static thread_local CusolverParams params;
+  constexpr cublasFillMode_t uplo = cusolver_fill_mode<UpLo>::value;
+  const int64_t n = static_cast<int64_t>(A.rows());
+  constexpr cudaDataType_t dtype = cuda_data_type<Scalar>::value;
+  OneShotSolverScratch& scratch = ctx.oneshotSolverScratch();
+  {
+    const size_t mat_bytes = A.sizeInBytes();
+    // Context-owned grow-only scratch: no per-call allocation, no end-of-call sync.
+    ensure_sized(scratch.d_factor, mat_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(scratch.d_factor.get(), A.data(), mat_bytes, cudaMemcpyDeviceToDevice, ctx.stream()));
+  }
+  const int64_t lda = static_cast<int64_t>(A.rows());
+  size_t dev_ws = 0;
+  size_t host_ws = 0;
+  EIGEN_CUSOLVER_CHECK(cusolverDnXpotrf_bufferSize(ctx.cusolverHandle(), params.p, uplo, n, dtype,
+                                                   scratch.d_factor.get(), lda, dtype, &dev_ws, &host_ws));
+  ensure_sized(scratch.d_workspace, dev_ws);
+  if (scratch.h_workspace.size() < host_ws) scratch.h_workspace.resize(host_ws);
+  // Two info slots (potrf, potrs) so both kernels queue back-to-back. If potrf
+  // fails, potrs runs on garbage but the debug check catches both at once.
+  int* d_info_potrf = static_cast<int*>(scratch.d_info.get());
+  int* d_info_potrs = d_info_potrf + 1;
+  EIGEN_CUSOLVER_CHECK(cusolverDnXpotrf(ctx.cusolverHandle(), params.p, uplo, n, dtype, scratch.d_factor.get(), lda,
+                                        dtype, scratch.d_workspace.get(), dev_ws,
+                                        host_ws > 0 ? scratch.h_workspace.data() : nullptr, host_ws, d_info_potrf));
+
+  dst.resize(n, B.cols());
+  const size_t rhs_bytes = B.sizeInBytes();
+  EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(dst.data(), B.data(), rhs_bytes, cudaMemcpyDeviceToDevice, ctx.stream()));
+
+  const int64_t nrhs = static_cast<int64_t>(B.cols());
+  EIGEN_CUSOLVER_CHECK(cusolverDnXpotrs(ctx.cusolverHandle(), params.p, uplo, n, nrhs, dtype, scratch.d_factor.get(),
+                                        lda, dtype, dst.data(), static_cast<int64_t>(dst.rows()), d_info_potrs));
+  oneshot_check_info(ctx, scratch, "llt");
+  dst.recordReady(ctx.stream());
+}
+
+template <typename Scalar>
+void dispatch(Context& ctx, DeviceMatrix<Scalar>& dst, const LuSolveExpr<Scalar>& expr) {
+  const DeviceMatrix<Scalar>& A = expr.matrix();
+  const DeviceMatrix<Scalar>& B = expr.rhs();
+
+  eigen_assert(A.rows() == A.cols() && "LU requires a square matrix");
+  eigen_assert(B.rows() == A.rows() && "LU solve: RHS rows must match matrix size");
+
+  if (A.rows() == 0 || B.cols() == 0) {
+    if (!dst.empty()) dst.waitReady(ctx.stream());
+    dst.resize(A.rows(), B.cols());
+    return;
+  }
+
+  A.waitReady(ctx.stream());
+  B.waitReady(ctx.stream());
+  if (!dst.empty()) dst.waitReady(ctx.stream());
+
+  // thread_local: must outlive the async kernels (no end-of-call sync), and
+  // only TUs that instantiate the one-shot path pull in cuSOLVER symbols.
+  static thread_local CusolverParams params;
+  const int64_t n = static_cast<int64_t>(A.rows());
+  constexpr cudaDataType_t dtype = cuda_data_type<Scalar>::value;
+  OneShotSolverScratch& scratch = ctx.oneshotSolverScratch();
+  {
+    const size_t mat_bytes = A.sizeInBytes();
+    // Context-owned grow-only scratch: no per-call allocation, no end-of-call sync.
+    ensure_sized(scratch.d_factor, mat_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(scratch.d_factor.get(), A.data(), mat_bytes, cudaMemcpyDeviceToDevice, ctx.stream()));
+  }
+  ensure_sized(scratch.d_ipiv, static_cast<size_t>(n) * sizeof(int64_t));
+  const int64_t lda = static_cast<int64_t>(A.rows());
+  size_t dev_ws = 0;
+  size_t host_ws = 0;
+  EIGEN_CUSOLVER_CHECK(cusolverDnXgetrf_bufferSize(ctx.cusolverHandle(), params.p, n, n, dtype, scratch.d_factor.get(),
+                                                   lda, dtype, &dev_ws, &host_ws));
+  ensure_sized(scratch.d_workspace, dev_ws);
+  if (scratch.h_workspace.size() < host_ws) scratch.h_workspace.resize(host_ws);
+  int* d_info_getrf = static_cast<int*>(scratch.d_info.get());
+  int* d_info_getrs = d_info_getrf + 1;
+  EIGEN_CUSOLVER_CHECK(cusolverDnXgetrf(ctx.cusolverHandle(), params.p, n, n, dtype, scratch.d_factor.get(), lda,
+                                        static_cast<int64_t*>(scratch.d_ipiv.get()), dtype, scratch.d_workspace.get(),
+                                        dev_ws, host_ws > 0 ? scratch.h_workspace.data() : nullptr, host_ws,
+                                        d_info_getrf));
+
+  dst.resize(n, B.cols());
+  const size_t rhs_bytes = B.sizeInBytes();
+  EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(dst.data(), B.data(), rhs_bytes, cudaMemcpyDeviceToDevice, ctx.stream()));
+
+  const int64_t nrhs = static_cast<int64_t>(B.cols());
+  EIGEN_CUSOLVER_CHECK(cusolverDnXgetrs(ctx.cusolverHandle(), params.p, CUBLAS_OP_N, n, nrhs, dtype,
+                                        scratch.d_factor.get(), lda, static_cast<const int64_t*>(scratch.d_ipiv.get()),
+                                        dtype, dst.data(), static_cast<int64_t>(dst.rows()), d_info_getrs));
+  oneshot_check_info(ctx, scratch, "lu");
+  dst.recordReady(ctx.stream());
+}
+
+template <typename Scalar, int UpLo>
+void dispatch(Context& ctx, DeviceMatrix<Scalar>& dst, const TrsmExpr<Scalar, UpLo>& expr) {
+  const DeviceMatrix<Scalar>& A = expr.matrix();
+  const DeviceMatrix<Scalar>& B = expr.rhs();
+
+  eigen_assert(A.rows() == A.cols() && "TRSM requires a square triangular matrix");
+  eigen_assert(B.rows() == A.rows() && "TRSM: RHS rows must match matrix size");
+
+  const int64_t n = A.rows();
+  const int64_t nrhs = B.cols();
+
+  if (n == 0 || nrhs == 0) {
+    if (!dst.empty()) dst.waitReady(ctx.stream());
+    dst.resize(n, B.cols());
+    return;
+  }
+
+  A.waitReady(ctx.stream());
+  B.waitReady(ctx.stream());
+  eigen_assert(!aliases_device_memory(dst, A) && "DeviceMatrix TRSM destination aliases triangular operand");
+  eigen_assert(!aliases_device_memory(dst, B) && "DeviceMatrix TRSM destination aliases RHS operand");
+  if (!dst.empty()) dst.waitReady(ctx.stream());
+
+  dst.resize(n, B.cols());
+  const size_t rhs_bytes = static_cast<size_t>(dst.rows()) * static_cast<size_t>(nrhs) * sizeof(Scalar);
+  EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(dst.data(), B.data(), rhs_bytes, cudaMemcpyDeviceToDevice, ctx.stream()));
+
+  constexpr cublasFillMode_t uplo = (UpLo == Lower) ? CUBLAS_FILL_MODE_LOWER : CUBLAS_FILL_MODE_UPPER;
+  Scalar alpha(1);
+
+  EIGEN_CUBLAS_CHECK(cublasXtrsm(ctx.cublasHandle(), CUBLAS_SIDE_LEFT, uplo, CUBLAS_OP_N, CUBLAS_DIAG_NON_UNIT, n, nrhs,
+                                 &alpha, A.data(), A.rows(), dst.data(), dst.rows()));
+
+  dst.recordReady(ctx.stream());
+}
+
+template <typename Scalar, int UpLo>
+void dispatch(Context& ctx, DeviceMatrix<Scalar>& dst, const SymmExpr<Scalar, UpLo>& expr) {
+  const DeviceMatrix<Scalar>& A = expr.matrix();
+  const DeviceMatrix<Scalar>& B = expr.rhs();
+
+  eigen_assert(A.rows() == A.cols() && "SYMM requires a square matrix");
+  eigen_assert(B.rows() == A.rows() && "SYMM: RHS rows must match matrix size");
+
+  const int64_t m = A.rows();
+  const int64_t n = B.cols();
+
+  if (m == 0 || n == 0) {
+    if (!dst.empty()) dst.waitReady(ctx.stream());
+    dst.resize(m, B.cols());
+    return;
+  }
+
+  A.waitReady(ctx.stream());
+  B.waitReady(ctx.stream());
+  eigen_assert(!aliases_device_memory(dst, A) && "DeviceMatrix SYMM destination aliases self-adjoint operand");
+  eigen_assert(!aliases_device_memory(dst, B) && "DeviceMatrix SYMM destination aliases RHS operand");
+  if (!dst.empty()) dst.waitReady(ctx.stream());
+
+  dst.resize(m, n);
+
+  constexpr cublasFillMode_t uplo = (UpLo == Lower) ? CUBLAS_FILL_MODE_LOWER : CUBLAS_FILL_MODE_UPPER;
+  // The array keeps the host-pointer stack slots alive; see the GEMM dispatch.
+  Scalar scalars[2] = {Scalar(1), Scalar(0)};
+
+  EIGEN_CUBLAS_CHECK(cublasXsymm(ctx.cublasHandle(), CUBLAS_SIDE_LEFT, uplo, m, n, &scalars[0], A.data(), A.rows(),
+                                 B.data(), B.rows(), &scalars[1], dst.data(), dst.rows()));
+
+  dst.recordReady(ctx.stream());
+}
+
+template <typename Scalar, int UpLo>
+void dispatch(Context& ctx, DeviceMatrix<Scalar>& dst, const SyrkExpr<Scalar, UpLo>& expr,
+              typename NumTraits<Scalar>::Real alpha_val, typename NumTraits<Scalar>::Real beta_val) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  const DeviceMatrix<Scalar>& A = expr.matrix();
+
+  const int64_t n = A.rows();
+  const int64_t k = A.cols();
+
+  if (n == 0) {
+    if (!dst.empty()) dst.waitReady(ctx.stream());
+    dst.resize(0, 0);
+    return;
+  }
+
+  A.waitReady(ctx.stream());
+  eigen_assert(!aliases_device_memory(dst, A) && "DeviceMatrix SYRK destination aliases input operand");
+  if (!dst.empty()) dst.waitReady(ctx.stream());
+
+  if (dst.empty() || dst.rows() != n || dst.cols() != n) {
+    dst.resize(n, n);
+    if (beta_val != RealScalar(0)) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemsetAsync(dst.data(), 0, dst.sizeInBytes(), ctx.stream()));
+    }
+  }
+
+  constexpr cublasFillMode_t uplo = (UpLo == Lower) ? CUBLAS_FILL_MODE_LOWER : CUBLAS_FILL_MODE_UPPER;
+
+  EIGEN_CUBLAS_CHECK(cublasXsyrk(ctx.cublasHandle(), uplo, CUBLAS_OP_N, n, k, &alpha_val, A.data(), A.rows(), &beta_val,
+                                 dst.data(), dst.rows()));
+
+  dst.recordReady(ctx.stream());
+}
+
+// DeviceAddExpr → cublasXgeam: dst = alpha * A + beta * B. Safe when dst
+// aliases A and/or B (geam supports in-place operation with equal leading
+// dimensions, which always holds here since DeviceMatrix is fully dense).
+
+template <typename Scalar>
+void dispatch(Context& ctx, DeviceMatrix<Scalar>& dst, const DeviceAddExpr<Scalar>& expr) {
+  const DeviceMatrix<Scalar>& A = expr.A();
+  const DeviceMatrix<Scalar>& B = expr.B();
+  eigen_assert(A.rows() == B.rows() && A.cols() == B.cols());
+  const int64_t m = A.rows();
+  const int64_t n = A.cols();
+  // Wait on dst before resize — resize may free the old buffer while another
+  // stream is still reading it.
+  if (!dst.empty()) dst.waitReady(ctx.stream());
+  dst.resize(A.rows(), A.cols());
+  if (m > 0 && n > 0) {
+    A.waitReady(ctx.stream());
+    B.waitReady(ctx.stream());
+    // See the GEMM dispatch: array prevents compiler from eliding host-pointer stack slots.
+    Scalar scalars[2] = {expr.alpha(), expr.beta()};
+    EIGEN_CUBLAS_CHECK(cublasXgeam(ctx.cublasHandle(), CUBLAS_OP_N, CUBLAS_OP_N, m, n, &scalars[0], A.data(), m,
+                                   &scalars[1], B.data(), m, dst.data(), m));
+    dst.recordReady(ctx.stream());
+  }
+}
+}  // namespace internal
+
+template <typename Scalar_>
+class Assignment {
+ public:
+  using Scalar = Scalar_;
+
+  Assignment(DeviceMatrix<Scalar>& dst, Context& ctx) : dst_(dst), ctx_(ctx) {}
+
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix<Scalar>& operator=(const GemmExpr<Lhs, Rhs>& expr) {
+    internal::dispatch(ctx_, dst_, expr, Scalar(0));
+    return dst_;
+  }
+
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix<Scalar>& operator+=(const GemmExpr<Lhs, Rhs>& expr) {
+    internal::dispatch(ctx_, dst_, expr, Scalar(1));
+    return dst_;
+  }
+
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix<Scalar>& operator-=(const GemmExpr<Lhs, Rhs>& expr) {
+    internal::dispatch(ctx_, dst_, expr, Scalar(1), Scalar(-1));
+    return dst_;
+  }
+
+  template <int UpLo>
+  DeviceMatrix<Scalar>& operator=(const LltSolveExpr<Scalar, UpLo>& expr) {
+    internal::dispatch(ctx_, dst_, expr);
+    return dst_;
+  }
+
+  DeviceMatrix<Scalar>& operator=(const LuSolveExpr<Scalar>& expr) {
+    internal::dispatch(ctx_, dst_, expr);
+    return dst_;
+  }
+
+  template <int UpLo>
+  DeviceMatrix<Scalar>& operator=(const TrsmExpr<Scalar, UpLo>& expr) {
+    internal::dispatch(ctx_, dst_, expr);
+    return dst_;
+  }
+
+  template <int UpLo>
+  DeviceMatrix<Scalar>& operator=(const SymmExpr<Scalar, UpLo>& expr) {
+    internal::dispatch(ctx_, dst_, expr);
+    return dst_;
+  }
+
+  DeviceMatrix<Scalar>& operator=(const DeviceAddExpr<Scalar>& expr) {
+    internal::dispatch(ctx_, dst_, expr);
+    return dst_;
+  }
+
+  DeviceMatrix<Scalar>& operator=(const Scaled<DeviceMatrix<Scalar>>& expr) {
+    // geam with beta == 0: cuBLAS documents B as unread, so pass A twice.
+    internal::dispatch(ctx_, dst_, DeviceAddExpr<Scalar>(expr.scalar(), expr.inner(), Scalar(0), expr.inner()));
+    return dst_;
+  }
+
+  template <typename Expr>
+  DeviceMatrix<Scalar>& operator=(const Expr&) {
+    static_assert(sizeof(Expr) == 0,
+                  "DeviceMatrix expression not supported: no cuBLAS/cuSOLVER mapping. "
+                  "Supported: GEMM (A*B), geam (A + alpha*B, alpha*A), "
+                  "TRSM (.triangularView().solve()), SYMM (.selfadjointView()*B), "
+                  "LLT (.llt().solve()), LU (.lu().solve()).");
+    return dst_;
+  }
+
+ private:
+  DeviceMatrix<Scalar>& dst_;
+  Context& ctx_;
+};
+
+// The definitions below call Context::threadLocal(), so they cannot live in
+// DeviceMatrix.h, where Context is still incomplete.
+
+template <typename Scalar_>
+template <typename Lhs, typename Rhs>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const GemmExpr<Lhs, Rhs>& expr) {
+  device(Context::threadLocal()) = expr;
+  return *this;
+}
+
+template <typename Scalar_>
+template <typename Lhs, typename Rhs>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator+=(const GemmExpr<Lhs, Rhs>& expr) {
+  device(Context::threadLocal()) += expr;
+  return *this;
+}
+
+template <typename Scalar_>
+template <typename Lhs, typename Rhs>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator-=(const GemmExpr<Lhs, Rhs>& expr) {
+  device(Context::threadLocal()) -= expr;
+  return *this;
+}
+
+template <typename Scalar_>
+template <int UpLo>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const LltSolveExpr<Scalar_, UpLo>& expr) {
+  device(Context::threadLocal()) = expr;
+  return *this;
+}
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const LuSolveExpr<Scalar_>& expr) {
+  device(Context::threadLocal()) = expr;
+  return *this;
+}
+
+template <typename Scalar_>
+template <int UpLo>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const TrsmExpr<Scalar_, UpLo>& expr) {
+  device(Context::threadLocal()) = expr;
+  return *this;
+}
+
+template <typename Scalar_>
+template <int UpLo>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const SymmExpr<Scalar_, UpLo>& expr) {
+  device(Context::threadLocal()) = expr;
+  return *this;
+}
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const Scaled<DeviceMatrix>& expr) {
+  device(Context::threadLocal()) = expr;
+  return *this;
+}
+
+// Enable copy-initialization straight from an expression, e.g.
+//   DeviceMatrix<double> d_C = d_A * d_B;
+// Each default-constructs and delegates to the matching operator=.
+
+template <typename Scalar_>
+template <typename Lhs, typename Rhs>
+DeviceMatrix<Scalar_>::DeviceMatrix(const GemmExpr<Lhs, Rhs>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>::DeviceMatrix(const Scaled<DeviceMatrix>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>::DeviceMatrix(const DeviceAddExpr<Scalar_>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_>
+template <int UpLo>
+DeviceMatrix<Scalar_>::DeviceMatrix(const LltSolveExpr<Scalar_, UpLo>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>::DeviceMatrix(const LuSolveExpr<Scalar_>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_>
+template <int UpLo>
+DeviceMatrix<Scalar_>::DeviceMatrix(const TrsmExpr<Scalar_, UpLo>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_>
+template <int UpLo>
+DeviceMatrix<Scalar_>::DeviceMatrix(const SymmExpr<Scalar_, UpLo>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+
+template <typename Scalar_, int UpLo_>
+void SelfAdjointView<Scalar_, UpLo_>::rankUpdate(const DeviceMatrix<Scalar_>& A, RealScalar alpha) {
+  SyrkExpr<Scalar_, UpLo_> expr(A);
+  RealScalar beta = matrix().empty() ? RealScalar(0) : RealScalar(1);
+  internal::dispatch(Context::threadLocal(), matrix(), expr, alpha, beta);
+}
+
+namespace internal {
+// Runs `f` with the handle temporarily in CUBLAS_POINTER_MODE_DEVICE, restoring
+// the caller's mode afterwards.
+template <typename F>
+void with_device_pointer_mode(cublasHandle_t h, F&& f) {
+  cublasPointerMode_t prev;
+  EIGEN_CUBLAS_CHECK(cublasGetPointerMode(h, &prev));
+  EIGEN_CUBLAS_CHECK(cublasSetPointerMode(h, CUBLAS_POINTER_MODE_DEVICE));
+  f();
+  EIGEN_CUBLAS_CHECK(cublasSetPointerMode(h, prev));
+}
+}  // namespace internal
+
+// The reductions below (dot, norm, squaredNorm) run under
+// CUBLAS_POINTER_MODE_DEVICE: the scalar result is written to device memory and
+// stays there until DeviceScalar's conversion to Scalar syncs and reads it.
+
+namespace internal {
+inline int64_t blas1_size(Index rows, Index cols) { return static_cast<int64_t>(rows) * static_cast<int64_t>(cols); }
+}  // namespace internal
+
+template <typename Scalar_>
+DeviceScalar<typename DeviceMatrix<Scalar_>::Scalar> DeviceMatrix<Scalar_>::dot(Context& ctx,
+                                                                                const DeviceMatrix& other) const {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  eigen_assert(n == internal::blas1_size(other.rows_, other.cols_));
+  if (n > 0) {
+    // Allocated uninitialized: cublasXdot overwrites the slot, so uploading a
+    // zero first would be a wasted H2D transfer per reduction.
+    DeviceScalar<Scalar> result(ctx.stream());
+    waitReady(ctx.stream());
+    other.waitReady(ctx.stream());
+    internal::with_device_pointer_mode(ctx.cublasHandle(), [&] {
+      EIGEN_CUBLAS_CHECK(
+          internal::cublasXdot(ctx.cublasHandle(), n, data_.get(), 1, other.data_.get(), 1, result.devicePtr()));
+    });
+    return result;
+  }
+  return DeviceScalar<Scalar>(Scalar(0), ctx.stream());
+}
+
+namespace internal {
+// For real Scalar, dot(x,x) already has type DeviceScalar<RealScalar>, so a move
+// suffices and nothing syncs.
+template <typename Scalar, typename RealScalar>
+std::enable_if_t<std::is_same<Scalar, RealScalar>::value, DeviceScalar<RealScalar>> squaredNorm_from_dot(
+    DeviceScalar<Scalar>&& d, cudaStream_t) {
+  return std::move(d);
+}
+// Complex must sync to extract the real part: DeviceScalar arithmetic is real-only.
+template <typename Scalar, typename RealScalar>
+std::enable_if_t<!std::is_same<Scalar, RealScalar>::value, DeviceScalar<RealScalar>> squaredNorm_from_dot(
+    DeviceScalar<Scalar>&& d, cudaStream_t stream) {
+  return DeviceScalar<RealScalar>(numext::real(Scalar(d)), stream);
+}
+}  // namespace internal
+
+template <typename Scalar_>
+DeviceScalar<typename NumTraits<Scalar_>::Real> DeviceMatrix<Scalar_>::squaredNorm(Context& ctx) const {
+  // dot(x,x) rather than nrm2()^2: the dot kernel is ~4.5x faster, since nrm2
+  // runs a scaled sum of squares whose overflow protection convergence checks do
+  // not need.
+  return internal::squaredNorm_from_dot<Scalar_, RealScalar>(dot(ctx, *this), ctx.stream());
+}
+
+template <typename Scalar_>
+DeviceScalar<typename NumTraits<Scalar_>::Real> DeviceMatrix<Scalar_>::norm(Context& ctx) const {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  if (n > 0) {
+    // See dot(): uninitialized on purpose, cublasXnrm2 overwrites the slot.
+    DeviceScalar<RealScalar> result(ctx.stream());
+    waitReady(ctx.stream());
+    internal::with_device_pointer_mode(ctx.cublasHandle(), [&] {
+      EIGEN_CUBLAS_CHECK(internal::cublasXnrm2(ctx.cublasHandle(), n, data_.get(), 1, result.devicePtr()));
+    });
+    return result;
+  }
+  return DeviceScalar<RealScalar>(RealScalar(0), ctx.stream());
+}
+
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::setZero(cudaStream_t stream) {
+  if (sizeInBytes() > 0) {
+    waitReady(stream);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemsetAsync(data_.get(), 0, sizeInBytes(), stream));
+    recordReady(stream);
+  }
+}
+
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::setZero(Context& ctx) {
+  setZero(ctx.stream());
+}
+
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::addScaled(Context& ctx, Scalar alpha, const DeviceMatrix& x) {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  eigen_assert(n == internal::blas1_size(x.rows_, x.cols_));
+  if (n > 0) {
+    waitReady(ctx.stream());
+    x.waitReady(ctx.stream());
+    EIGEN_CUBLAS_CHECK(internal::cublasXaxpy(ctx.cublasHandle(), n, &alpha, x.data_.get(), 1, data_.get(), 1));
+    recordReady(ctx.stream());
+  }
+}
+
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::scale(Context& ctx, Scalar alpha) {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  if (n > 0) {
+    waitReady(ctx.stream());
+    EIGEN_CUBLAS_CHECK(internal::cublasXscal(ctx.cublasHandle(), n, &alpha, data_.get(), 1));
+    recordReady(ctx.stream());
+  }
+}
+
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::copyFrom(Context& ctx, const DeviceMatrix& other) {
+  // Wait on *this before resize — resize may free the old buffer while another
+  // stream is still reading it.
+  if (!empty()) waitReady(ctx.stream());
+  resize(other.rows_, other.cols_);
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  if (n > 0) {
+    other.waitReady(ctx.stream());
+    EIGEN_CUBLAS_CHECK(internal::cublasXcopy(ctx.cublasHandle(), n, other.data_.get(), 1, data_.get(), 1));
+    recordReady(ctx.stream());
+  }
+}
+
+// this += alpha * x  (axpy)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator+=(const Scaled<DeviceMatrix>& expr) {
+  addScaled(Context::threadLocal(), expr.scalar(), internal::device_expr_traits<DeviceMatrix>::matrix(expr.inner()));
+  return *this;
+}
+
+// this -= alpha * x  (axpy with negated alpha)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator-=(const Scaled<DeviceMatrix>& expr) {
+  addScaled(Context::threadLocal(), -expr.scalar(), internal::device_expr_traits<DeviceMatrix>::matrix(expr.inner()));
+  return *this;
+}
+
+// this += x  (axpy with alpha=1)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator+=(const DeviceMatrix& other) {
+  Scalar one(1);
+  addScaled(Context::threadLocal(), one, other);
+  return *this;
+}
+
+// this -= x  (axpy with alpha=-1)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator-=(const DeviceMatrix& other) {
+  Scalar neg_one(-1);
+  addScaled(Context::threadLocal(), neg_one, other);
+  return *this;
+}
+
+// this *= alpha  (scal, host pointer)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator*=(Scalar alpha) {
+  scale(Context::threadLocal(), alpha);
+  return *this;
+}
+
+// this *= alpha  (scal, device pointer — avoids host sync)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator*=(const DeviceScalar<Scalar>& alpha) {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  if (n > 0) {
+    auto& ctx = Context::threadLocal();
+    waitReady(ctx.stream());
+    internal::with_device_pointer_mode(ctx.cublasHandle(), [&] {
+      EIGEN_CUBLAS_CHECK(internal::cublasXscal(ctx.cublasHandle(), n, alpha.devicePtr(), data_.get(), 1));
+    });
+    recordReady(ctx.stream());
+  }
+  return *this;
+}
+
+// this += DeviceScalar * x  (axpy with CUBLAS_POINTER_MODE_DEVICE)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator+=(const DeviceScaledDevice<Scalar_>& expr) {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  const auto& x = expr.matrix();
+  eigen_assert(n == internal::blas1_size(x.rows_, x.cols_));
+  if (n > 0) {
+    auto& ctx = Context::threadLocal();
+    waitReady(ctx.stream());
+    x.waitReady(ctx.stream());
+    internal::with_device_pointer_mode(ctx.cublasHandle(), [&] {
+      EIGEN_CUBLAS_CHECK(
+          internal::cublasXaxpy(ctx.cublasHandle(), n, expr.alpha().devicePtr(), x.data_.get(), 1, data_.get(), 1));
+    });
+    recordReady(ctx.stream());
+  }
+  return *this;
+}
+
+// this -= DeviceScalar * x  (axpy with negated device scalar)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator-=(const DeviceScaledDevice<Scalar_>& expr) {
+  auto neg_alpha = -expr.alpha();
+  DeviceScaledDevice<Scalar_> neg_expr(neg_alpha, expr.matrix());
+  return operator+=(neg_expr);
+}
+
+// this = alpha * A + beta * B  (cuBLAS geam)
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const DeviceAddExpr<Scalar_>& expr) {
+  internal::dispatch(Context::threadLocal(), *this, expr);
+  return *this;
+}
+
+// cwiseProduct (allocating).
+template <typename Scalar_>
+DeviceMatrix<Scalar_> DeviceMatrix<Scalar_>::cwiseProduct(Context& ctx, const DeviceMatrix& other) const {
+  const int64_t n = internal::blas1_size(rows_, cols_);
+  eigen_assert(n == internal::blas1_size(other.rows_, other.cols_));
+  DeviceMatrix result(rows_, cols_);
+  if (n > 0) {
+    waitReady(ctx.stream());
+    other.waitReady(ctx.stream());
+    internal::device_cwiseProduct(data_.get(), other.data_.get(), result.data_.get(),
+                                  Eigen::internal::convert_index<int>(n), ctx.stream());
+    result.recordReady(ctx.stream());
+  }
+  return result;
+}
+
+// In-place cwiseProduct: this = a .* b (reuses this buffer, no allocation).
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::cwiseProduct(Context& ctx, const DeviceMatrix& a, const DeviceMatrix& b) {
+  const int64_t n = internal::blas1_size(a.rows_, a.cols_);
+  eigen_assert(n == internal::blas1_size(b.rows_, b.cols_));
+  if (!empty()) waitReady(ctx.stream());
+  resize(a.rows_, a.cols_);
+  if (n > 0) {
+    a.waitReady(ctx.stream());
+    b.waitReady(ctx.stream());
+    internal::device_cwiseProduct(a.data_.get(), b.data_.get(), data_.get(), Eigen::internal::convert_index<int>(n),
+                                  ctx.stream());
+    recordReady(ctx.stream());
+  }
+}
+
+// Convenience overloads using thread-local default Context.
+template <typename Scalar_>
+DeviceScalar<typename DeviceMatrix<Scalar_>::Scalar> DeviceMatrix<Scalar_>::dot(const DeviceMatrix& other) const {
+  return dot(Context::threadLocal(), other);
+}
+
+template <typename Scalar_>
+DeviceScalar<typename NumTraits<Scalar_>::Real> DeviceMatrix<Scalar_>::squaredNorm() const {
+  return squaredNorm(Context::threadLocal());
+}
+
+template <typename Scalar_>
+DeviceScalar<typename NumTraits<Scalar_>::Real> DeviceMatrix<Scalar_>::norm() const {
+  return norm(Context::threadLocal());
+}
+
+template <typename Scalar_>
+void DeviceMatrix<Scalar_>::setZero() {
+  setZero(Context::threadLocal());
+}
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_DISPATCH_H
diff --git a/contrib/Eigen/src/GPU/DeviceExpr.h b/contrib/Eigen/src/GPU/DeviceExpr.h
new file mode 100644
index 0000000..f0880f4
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceExpr.h
@@ -0,0 +1,326 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Lightweight expression types for DeviceMatrix operations.
+//
+// These are NOT Eigen expression templates. Each type maps 1:1 to a single
+// NVIDIA library call (cuBLAS or cuSOLVER). There is no coefficient-level
+// evaluation, no lazy fusion, no packet operations.
+//
+// Expression types:
+//   AdjointView<S>   — d_A.adjoint()  → marks ConjTrans for GEMM
+//   TransposeView<S> — d_A.transpose() → marks Trans for GEMM
+//   Scaled<Expr>     — alpha * expr    → carries scalar factor
+//   gpu::GemmExpr<Lhs, Rhs> — lhs * rhs    → dispatches to cublasXgemm
+
+#ifndef EIGEN_GPU_DEVICE_EXPR_H
+#define EIGEN_GPU_DEVICE_EXPR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./CuBlasSupport.h"
+#include "./type_traits.h"
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+// SFINAE gate for scalar factors: any type convertible to the expression's
+// scalar (so `2 * d_A` and `2.0 * d_cplx` work), except DeviceScalar.
+template <typename T, typename S>
+using require_host_scalar_convertible_t =
+    typename std::enable_if<std::is_convertible<T, S>::value && !is_device_scalar<typename std::decay<T>::type>::value,
+                            int>::type;
+
+}  // namespace internal
+
+/** \brief View returned by DeviceMatrix::adjoint(); maps to the cuBLAS conjugate-transpose operand flag. */
+template <typename Scalar_>
+class AdjointView {
+ public:
+  using Scalar = Scalar_;
+  explicit AdjointView(const DeviceMatrix<Scalar>& m) : mat_(m) {}
+  const DeviceMatrix<Scalar>& matrix() const { return mat_; }
+
+ private:
+  const DeviceMatrix<Scalar>& mat_;
+};
+
+/** \brief View returned by DeviceMatrix::transpose(); maps to the cuBLAS transpose operand flag. */
+template <typename Scalar_>
+class TransposeView {
+ public:
+  using Scalar = Scalar_;
+  explicit TransposeView(const DeviceMatrix<Scalar>& m) : mat_(m) {}
+  const DeviceMatrix<Scalar>& matrix() const { return mat_; }
+
+ private:
+  const DeviceMatrix<Scalar>& mat_;
+};
+
+/** \brief Expression returned by operator*(Scalar, DeviceMatrix/View), carrying the scalar factor.
+ *
+ * \c Inner names the scaled operand, decayed, for callers that need to reason
+ * about what is being scaled. The is_scaled_* predicates in type_traits.h
+ * deliberately do not read it: naming a member instantiates Scaled, and
+ * Scaled<GemmExpr<...>>::Scalar is ill-formed. They deduce the operand from the
+ * template-id instead.
+ */
+template <typename Inner_>
+class Scaled {
+ public:
+  using Inner = std::decay_t<Inner_>;
+  using Scalar = internal::scalar_type_t<Inner>;
+  Scaled(Scalar alpha, const Inner_& inner) : alpha_(alpha), inner_(inner) {}
+  Scalar scalar() const { return alpha_; }
+  const Inner_& inner() const { return inner_; }
+
+ private:
+  Scalar alpha_;
+  const Inner_& inner_;
+};
+
+/** \brief Expression returned by operator*(lhs_expr, rhs_expr), dispatched to cuBLAS GEMM. */
+template <typename Lhs, typename Rhs>
+class GemmExpr {
+ public:
+  using Scalar = internal::scalar_type_t<Lhs>;
+  static_assert(std::is_same<Scalar, internal::scalar_type_t<Rhs>>::value,
+                "DeviceMatrix GEMM: LHS and RHS must have the same scalar type");
+
+  GemmExpr(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {}
+  const Lhs& lhs() const { return lhs_; }
+  const Rhs& rhs() const { return rhs_; }
+
+ private:
+  // Stored by reference — like Eigen's CPU expression templates, these must
+  // not be captured with auto (the references will dangle). Assign to (or
+  // construct) a DeviceMatrix immediately.
+  const Lhs& lhs_;
+  const Rhs& rhs_;
+};
+
+// Defined after device_expr_traits so it can accept any supported view pair.
+
+// The scalar factor accepts any type convertible to the matrix scalar (int
+// and double literals included), in either operand order. Division by a
+// scalar and unary minus fold into the same Scaled wrapper.
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<DeviceMatrix<S>> operator*(T alpha, const DeviceMatrix<S>& m) {
+  return {static_cast<S>(alpha), m};
+}
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<DeviceMatrix<S>> operator*(const DeviceMatrix<S>& m, T alpha) {
+  return {static_cast<S>(alpha), m};
+}
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<DeviceMatrix<S>> operator/(const DeviceMatrix<S>& m, T alpha) {
+  return {S(1) / static_cast<S>(alpha), m};
+}
+
+template <typename S>
+Scaled<DeviceMatrix<S>> operator-(const DeviceMatrix<S>& m) {
+  return {S(-1), m};
+}
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<AdjointView<S>> operator*(T alpha, const AdjointView<S>& m) {
+  return {static_cast<S>(alpha), m};
+}
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<AdjointView<S>> operator*(const AdjointView<S>& m, T alpha) {
+  return {static_cast<S>(alpha), m};
+}
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<TransposeView<S>> operator*(T alpha, const TransposeView<S>& m) {
+  return {static_cast<S>(alpha), m};
+}
+
+template <typename T, typename S, internal::require_host_scalar_convertible_t<T, S> = 0>
+Scaled<TransposeView<S>> operator*(const TransposeView<S>& m, T alpha) {
+  return {static_cast<S>(alpha), m};
+}
+
+// Rescale / negate an already-scaled expression: T * (alpha * m), -(alpha * m).
+template <typename T, typename Inner,
+          internal::require_host_scalar_convertible_t<T, internal::scalar_type_t<Inner>> = 0>
+Scaled<Inner> operator*(T alpha, const Scaled<Inner>& s) {
+  using S = internal::scalar_type_t<Inner>;
+  return {static_cast<S>(alpha) * s.scalar(), s.inner()};
+}
+
+template <typename Inner>
+Scaled<Inner> operator-(const Scaled<Inner>& s) {
+  using S = internal::scalar_type_t<Inner>;
+  return {S(-1) * s.scalar(), s.inner()};
+}
+
+namespace internal {
+// Default: a DeviceMatrix is NoTrans. Documented on the FwdDecl.h forward declaration.
+template <typename T>
+struct device_expr_traits {
+  static constexpr bool is_device_expr = false;
+};
+
+template <typename Scalar>
+struct device_expr_traits<DeviceMatrix<Scalar>> {
+  using scalar_type = Scalar;
+  static constexpr GpuOp op = GpuOp::NoTrans;
+  static constexpr bool is_device_expr = true;
+  static const DeviceMatrix<Scalar>& matrix(const DeviceMatrix<Scalar>& x) { return x; }
+  static Scalar alpha(const DeviceMatrix<Scalar>&) { return Scalar(1); }
+};
+
+template <typename Scalar>
+struct device_expr_traits<AdjointView<Scalar>> {
+  using scalar_type = Scalar;
+  static constexpr GpuOp op = GpuOp::ConjTrans;
+  static constexpr bool is_device_expr = true;
+  static const DeviceMatrix<Scalar>& matrix(const AdjointView<Scalar>& x) { return x.matrix(); }
+  static Scalar alpha(const AdjointView<Scalar>&) { return Scalar(1); }
+};
+
+template <typename Scalar>
+struct device_expr_traits<TransposeView<Scalar>> {
+  using scalar_type = Scalar;
+  static constexpr GpuOp op = GpuOp::Trans;
+  static constexpr bool is_device_expr = true;
+  static const DeviceMatrix<Scalar>& matrix(const TransposeView<Scalar>& x) { return x.matrix(); }
+  static Scalar alpha(const TransposeView<Scalar>&) { return Scalar(1); }
+};
+
+template <typename Inner>
+struct device_expr_traits<Scaled<Inner>> {
+  using scalar_type = scalar_type_t<Inner>;
+  static constexpr GpuOp op = device_expr_traits<Inner>::op;
+  static constexpr bool is_device_expr = true;
+  static const DeviceMatrix<scalar_type>& matrix(const Scaled<Inner>& x) {
+    return device_expr_traits<Inner>::matrix(x.inner());
+  }
+  static scalar_type alpha(const Scaled<Inner>& x) { return x.scalar() * device_expr_traits<Inner>::alpha(x.inner()); }
+};
+}  // namespace internal
+
+template <typename Lhs, typename Rhs,
+          std::enable_if_t<internal::device_expr_traits<Lhs>::is_device_expr &&
+                               internal::device_expr_traits<Rhs>::is_device_expr,
+                           int> = 0>
+GemmExpr<Lhs, Rhs> operator*(const Lhs& a, const Rhs& b) {
+  return {a, b};
+}
+
+/**
+ * \brief Expression that scales a device matrix by a DeviceScalar.
+ *
+ * Unlike Scaled, this expression carries a device pointer. operator+= dispatches to cuBLAS AXPY with device pointer
+ * mode.
+ */
+template <typename Scalar_>
+class DeviceScaledDevice {
+ public:
+  using Scalar = Scalar_;
+  DeviceScaledDevice(const DeviceScalar<Scalar>& alpha, const DeviceMatrix<Scalar>& mat) : alpha_(alpha), mat_(mat) {}
+  const DeviceScalar<Scalar>& alpha() const { return alpha_; }
+  const DeviceMatrix<Scalar>& matrix() const { return mat_; }
+
+ private:
+  const DeviceScalar<Scalar>& alpha_;
+  const DeviceMatrix<Scalar>& mat_;
+};
+
+// DeviceScalar * DeviceMatrix → DeviceScaledDevice
+template <typename S>
+DeviceScaledDevice<S> operator*(const DeviceScalar<S>& alpha, const DeviceMatrix<S>& m) {
+  return {alpha, m};
+}
+
+// Captures `DeviceMatrix + Scaled<DeviceMatrix>` (and reverse).
+// Dispatched to geam: C = alpha * A + beta * B.
+//
+// Note: These operator+/- overloads are intentionally free functions on
+// DeviceMatrix, not Eigen expression templates. DeviceMatrix does not inherit
+// from MatrixBase, so there is no ambiguity with Eigen's own operator+/-.
+// If DeviceMatrix is ever made an Eigen expression type, these would need to
+// be revisited.
+
+/** \brief Linear combination of two device matrices. */
+template <typename Scalar_>
+class DeviceAddExpr {
+ public:
+  using Scalar = Scalar_;
+  DeviceAddExpr(Scalar alpha, const DeviceMatrix<Scalar>& A, Scalar beta, const DeviceMatrix<Scalar>& B)
+      : alpha_(alpha), A_(A), beta_(beta), B_(B) {}
+  Scalar alpha() const { return alpha_; }
+  Scalar beta() const { return beta_; }
+  const DeviceMatrix<Scalar>& A() const { return A_; }
+  const DeviceMatrix<Scalar>& B() const { return B_; }
+
+ private:
+  Scalar alpha_;
+  const DeviceMatrix<Scalar>& A_;
+  Scalar beta_;
+  const DeviceMatrix<Scalar>& B_;
+};
+
+// DeviceMatrix + DeviceMatrix → DeviceAddExpr (alpha=1, beta=1)
+template <typename S>
+DeviceAddExpr<S> operator+(const DeviceMatrix<S>& a, const DeviceMatrix<S>& b) {
+  return {S(1), a, S(1), b};
+}
+
+// DeviceMatrix + Scaled<DeviceMatrix> → DeviceAddExpr (alpha=1, beta=scaled)
+template <typename S>
+DeviceAddExpr<S> operator+(const DeviceMatrix<S>& a, const Scaled<DeviceMatrix<S>>& b) {
+  return {S(1), a, b.scalar(), b.inner()};
+}
+
+// Scaled<DeviceMatrix> + DeviceMatrix → DeviceAddExpr (alpha=scaled, beta=1)
+template <typename S>
+DeviceAddExpr<S> operator+(const Scaled<DeviceMatrix<S>>& a, const DeviceMatrix<S>& b) {
+  return {a.scalar(), a.inner(), S(1), b};
+}
+
+// DeviceMatrix - DeviceMatrix → DeviceAddExpr (alpha=1, beta=-1)
+template <typename S>
+DeviceAddExpr<S> operator-(const DeviceMatrix<S>& a, const DeviceMatrix<S>& b) {
+  return {S(1), a, S(-1), b};
+}
+
+// DeviceMatrix - Scaled<DeviceMatrix> → DeviceAddExpr (alpha=1, beta=-scaled)
+template <typename S>
+DeviceAddExpr<S> operator-(const DeviceMatrix<S>& a, const Scaled<DeviceMatrix<S>>& b) {
+  return {S(1), a, -b.scalar(), b.inner()};
+}
+
+// Scaled<DeviceMatrix> - DeviceMatrix → DeviceAddExpr (alpha=scaled, beta=-1)
+template <typename S>
+DeviceAddExpr<S> operator-(const Scaled<DeviceMatrix<S>>& a, const DeviceMatrix<S>& b) {
+  return {a.scalar(), a.inner(), S(-1), b};
+}
+
+// Scaled<DeviceMatrix> ± Scaled<DeviceMatrix> → DeviceAddExpr
+template <typename S>
+DeviceAddExpr<S> operator+(const Scaled<DeviceMatrix<S>>& a, const Scaled<DeviceMatrix<S>>& b) {
+  return {a.scalar(), a.inner(), b.scalar(), b.inner()};
+}
+
+template <typename S>
+DeviceAddExpr<S> operator-(const Scaled<DeviceMatrix<S>>& a, const Scaled<DeviceMatrix<S>>& b) {
+  return {a.scalar(), a.inner(), -b.scalar(), b.inner()};
+}
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_EXPR_H
diff --git a/contrib/Eigen/src/GPU/DeviceMatrix.h b/contrib/Eigen/src/GPU/DeviceMatrix.h
new file mode 100644
index 0000000..2b57c78
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceMatrix.h
@@ -0,0 +1,587 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Typed RAII wrapper for a dense column-major matrix in GPU device memory.
+//
+// Cross-stream safety is automatic: an internal CUDA event records when the last
+// write completed, and consumers on a different stream wait on it before reading.
+
+#ifndef EIGEN_GPU_DEVICE_MATRIX_H
+#define EIGEN_GPU_DEVICE_MATRIX_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <cstring>
+
+#include "./FwdDecl.h"
+#include "./GpuSupport.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** \ingroup GPU_Module
+ * \class HostTransfer
+ * \brief Future for an asynchronous device-to-host matrix transfer.
+ *
+ * Returned by gpu::DeviceMatrix::toHostAsync(). The transfer runs asynchronously
+ * on the given CUDA stream. Call get() to block until complete and retrieve
+ * the host matrix, or ready() to poll without blocking.
+ */
+template <typename Scalar_>
+class HostTransfer {
+ public:
+  using Scalar = Scalar_;
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  /** Block until the transfer completes and return the host matrix.
+   * Idempotent: subsequent calls return the same matrix without re-syncing. */
+  PlainMatrix& get() {
+    if (!synced_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaEventSynchronize(event_));
+      if (pinned_buf_ && host_buf_.size() > 0) {
+        std::memcpy(host_buf_.data(), pinned_buf_.get(), static_cast<size_t>(host_buf_.size()) * sizeof(Scalar));
+      }
+      pinned_buf_ = internal::PinnedHostBuffer();  // free pinned memory early
+      synced_ = true;
+    }
+    return host_buf_;
+  }
+
+  /** Non-blocking check: has the transfer completed? */
+  bool ready() const {
+    if (synced_) return true;
+    cudaError_t err = cudaEventQuery(event_);
+    if (err == cudaSuccess) return true;
+    eigen_assert(err == cudaErrorNotReady && "cudaEventQuery failed");
+    return false;
+  }
+
+  ~HostTransfer() {
+    if (event_) (void)cudaEventDestroy(event_);
+  }
+
+  HostTransfer(HostTransfer&& o) noexcept
+      : host_buf_(std::move(o.host_buf_)), pinned_buf_(std::move(o.pinned_buf_)), event_(o.event_), synced_(o.synced_) {
+    o.event_ = nullptr;
+    o.synced_ = true;
+  }
+
+  HostTransfer& operator=(HostTransfer&& o) noexcept {
+    if (this != &o) {
+      // Unchecked like the destructor: eigen_assert may throw, and this operator is noexcept.
+      if (event_) (void)cudaEventDestroy(event_);
+      host_buf_ = std::move(o.host_buf_);
+      pinned_buf_ = std::move(o.pinned_buf_);
+      event_ = o.event_;
+      synced_ = o.synced_;
+      o.event_ = nullptr;
+      o.synced_ = true;
+    }
+    return *this;
+  }
+
+  HostTransfer(const HostTransfer&) = delete;
+  HostTransfer& operator=(const HostTransfer&) = delete;
+
+ private:
+  template <typename>
+  friend class DeviceMatrix;
+
+  HostTransfer(PlainMatrix&& buf, internal::PinnedHostBuffer&& pinned, cudaEvent_t event)
+      : host_buf_(std::move(buf)), pinned_buf_(std::move(pinned)), event_(event), synced_(false) {}
+
+  PlainMatrix host_buf_;                   // final destination (pageable)
+  internal::PinnedHostBuffer pinned_buf_;  // staging buffer for async DMA
+  cudaEvent_t event_ = nullptr;
+  bool synced_ = false;
+};
+
+/** \ingroup GPU_Module
+ * \class DeviceMatrix
+ * \brief RAII wrapper for a dense column-major matrix in GPU device memory.
+ *
+ * \tparam Scalar_  Element type: float, double, complex<float>, complex<double>
+ *
+ * Owns a device allocation with tracked dimensions and leading dimension.
+ * An internal CUDA event records when the data was last written, enabling
+ * safe cross-stream consumption without user-visible synchronization.
+ *
+ * Transfers come in synchronous and asynchronous variants: fromHost() /
+ * fromHostAsync() and toHost() / toHostAsync().
+ */
+template <typename Scalar_>
+class DeviceMatrix {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PlainObject = DeviceMatrix;  // owning type, as generic solver code expects
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  /** Default: empty (0x0, no allocation). */
+  DeviceMatrix() = default;
+
+  /** Allocate an uninitialized column vector, mirroring
+   * Matrix<Scalar,Dynamic,1>(n) so generic solver code compiles unchanged. */
+  explicit DeviceMatrix(Index n) : rows_(n), cols_(1) {
+    eigen_assert(n >= 0);
+    allocate(sizeInBytes());
+  }
+
+  /** Allocate uninitialized device memory for a rows x cols matrix. */
+  DeviceMatrix(Index rows, Index cols) : rows_(rows), cols_(cols) {
+    eigen_assert(rows >= 0 && cols >= 0);
+    allocate(sizeInBytes());
+  }
+
+  // Copy-initialization from a device expression, mirroring the Eigen CPU idiom
+  // `DeviceMatrix<double> d_C = d_A * d_B;`. Each delegates to the corresponding
+  // operator= on the thread-local Context, and is defined out-of-line in
+  // DeviceDispatch.h — GpuSparseContext.h for SpMV — where Context is complete.
+
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix(const GemmExpr<Lhs, Rhs>& expr);
+  DeviceMatrix(const Scaled<DeviceMatrix>& expr);
+  DeviceMatrix(const DeviceAddExpr<Scalar>& expr);
+  template <int UpLo>
+  DeviceMatrix(const LltSolveExpr<Scalar, UpLo>& expr);
+  DeviceMatrix(const LuSolveExpr<Scalar>& expr);
+  template <int UpLo>
+  DeviceMatrix(const TrsmExpr<Scalar, UpLo>& expr);
+  template <int UpLo>
+  DeviceMatrix(const SymmExpr<Scalar, UpLo>& expr);
+  DeviceMatrix(const SpMVExpr<Scalar>& expr);
+
+  ~DeviceMatrix() {
+    // cudaEventDestroy on a pending event is non-blocking: the runtime defers
+    // teardown until the event completes. The trailing cudaFree() (via
+    // data_.reset()) is itself synchronous, so the buffer outlives any
+    // in-flight kernel that may still be touching it.
+    if (ready_event_) (void)cudaEventDestroy(ready_event_);
+  }
+
+  DeviceMatrix(DeviceMatrix&& o) noexcept
+      : data_(std::move(o.data_)),
+        rows_(o.rows_),
+        cols_(o.cols_),
+        capacity_bytes_(o.capacity_bytes_),
+        ready_event_(o.ready_event_),
+        ready_stream_(o.ready_stream_),
+        retained_buffer_(std::move(o.retained_buffer_)) {
+    o.rows_ = 0;
+    o.cols_ = 0;
+    o.capacity_bytes_ = 0;
+    o.ready_event_ = nullptr;
+    o.ready_stream_ = nullptr;
+  }
+
+  DeviceMatrix& operator=(DeviceMatrix&& o) noexcept {
+    if (this != &o) {
+      // Unchecked like the destructor: eigen_assert may throw, and this operator is noexcept.
+      if (ready_event_) (void)cudaEventDestroy(ready_event_);
+      data_ = std::move(o.data_);
+      rows_ = o.rows_;
+      cols_ = o.cols_;
+      capacity_bytes_ = o.capacity_bytes_;
+      ready_event_ = o.ready_event_;
+      ready_stream_ = o.ready_stream_;
+      retained_buffer_ = std::move(o.retained_buffer_);
+      o.rows_ = 0;
+      o.cols_ = 0;
+      o.capacity_bytes_ = 0;
+      o.ready_event_ = nullptr;
+      o.ready_stream_ = nullptr;
+    }
+    return *this;
+  }
+
+  DeviceMatrix(const DeviceMatrix&) = delete;
+  DeviceMatrix& operator=(const DeviceMatrix&) = delete;
+
+  /** Upload a host Eigen matrix to device memory (synchronous).
+   *
+   * Copies to device via cudaMemcpyAsync on \p stream and synchronizes before
+   * returning. Plain contiguous column-major input is transferred directly;
+   * other expressions are first evaluated into a contiguous temporary.
+   *
+   * \param host   Any Eigen dense expression.
+   * \param stream CUDA stream for the transfer (default: stream 0).
+   */
+  template <typename Derived>
+  static DeviceMatrix fromHost(const DenseBase<Derived>& host, cudaStream_t stream = nullptr) {
+    // Ref binds any column-major direct-access input in place (no host copy);
+    // row-major layouts and expressions evaluate into its temporary. A bound
+    // block keeps its parent's outer stride, so the upload must honour
+    // outerStride() rather than assume rows() -- see upload_host_matrix.
+    const Ref<const PlainMatrix> mat(host.derived());
+    DeviceMatrix dm(mat.rows(), mat.cols());
+    if (dm.sizeInBytes() > 0) {
+      internal::upload_host_matrix(dm.data_.get(), mat.rows(), mat.data(), mat.outerStride(), mat.rows(), mat.cols(),
+                                   stream);
+      EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream));
+    }
+    return dm;
+  }
+
+  /** Upload from a raw host pointer to device memory (asynchronous).
+   *
+   * Enqueues an async H2D copy on \p stream and records an internal event.
+   * The caller must keep \p host_data alive until the transfer completes.
+   *
+   * \param host_data  Pointer to contiguous column-major host data.
+   * \param rows       Number of rows.
+   * \param cols       Number of columns.
+   * \param stream     CUDA stream for the transfer.
+   */
+  static DeviceMatrix fromHostAsync(const Scalar* host_data, Index rows, Index cols, cudaStream_t stream) {
+    eigen_assert(rows >= 0 && cols >= 0);
+    eigen_assert(host_data != nullptr || (rows == 0 || cols == 0));
+    DeviceMatrix dm(rows, cols);
+    if (dm.sizeInBytes() > 0) {
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(dm.data_.get(), host_data, dm.sizeInBytes(), cudaMemcpyHostToDevice, stream));
+      dm.recordReady(stream);
+    }
+    return dm;
+  }
+
+  /** Download device matrix to host memory (synchronous).
+   *
+   * Waits on the internal ready event, enqueues a D2H copy on \p stream,
+   * synchronizes, and returns the host matrix directly.
+   *
+   * \param stream CUDA stream for the transfer (default: stream 0).
+   */
+  PlainMatrix toHost(cudaStream_t stream = nullptr) const {
+    PlainMatrix host_buf(rows_, cols_);
+    if (sizeInBytes() > 0) {
+      waitReady(stream);
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(host_buf.data(), data_.get(), sizeInBytes(), cudaMemcpyDeviceToHost, stream));
+      EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream));
+    }
+    return host_buf;
+  }
+
+  /** Enqueue an async device-to-host transfer and return a future.
+   *
+   * Waits on the internal ready event (if any) to ensure the device data is
+   * valid, then enqueues the D2H copy on \p stream. Call HostTransfer::get() to
+   * block and retrieve the host matrix.
+   *
+   * \param stream CUDA stream for the transfer (default: stream 0).
+   */
+  HostTransfer<Scalar> toHostAsync(cudaStream_t stream = nullptr) const {
+    PlainMatrix host_buf(rows_, cols_);
+    internal::PinnedHostBuffer pinned_buf(sizeInBytes());
+    if (sizeInBytes() > 0) {
+      waitReady(stream);
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(pinned_buf.get(), data_.get(), sizeInBytes(), cudaMemcpyDeviceToHost, stream));
+    }
+    cudaEvent_t transfer_event;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaEventCreateWithFlags(&transfer_event, cudaEventDisableTiming));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaEventRecord(transfer_event, stream));
+    return HostTransfer<Scalar>(std::move(host_buf), std::move(pinned_buf), transfer_event);
+  }
+
+  /** Deep copy on device. Fully async — records an event on the result, no sync.
+   *
+   * \param stream CUDA stream for the D2D copy (default: stream 0).
+   */
+  DeviceMatrix clone(cudaStream_t stream = nullptr) const {
+    DeviceMatrix result(rows_, cols_);
+    if (sizeInBytes() > 0) {
+      waitReady(stream);
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(result.data_.get(), data_.get(), sizeInBytes(), cudaMemcpyDeviceToDevice, stream));
+      result.recordReady(stream);
+    }
+    return result;
+  }
+
+  /** Discard contents and resize to (rows x cols). Contents are undefined
+   * afterwards. Keeps the existing allocation when it is large enough
+   * (capacity-aware: no cudaMalloc/cudaFree churn when cycling through
+   * same-or-smaller shapes); otherwise reallocates and clears the ready
+   * event. */
+  void resize(Index rows, Index cols) {
+    eigen_assert(rows >= 0 && cols >= 0);
+    if (rows == rows_ && cols == cols_) return;
+    const size_t bytes = static_cast<size_t>(rows) * static_cast<size_t>(cols) * sizeof(Scalar);
+    if (bytes > 0 && bytes <= capacity_bytes_ && data_) {
+      // Reuse the allocation; the ready event still orders any in-flight
+      // writes to this buffer ahead of its next producer.
+      rows_ = rows;
+      cols_ = cols;
+      return;
+    }
+    data_.reset();
+    capacity_bytes_ = 0;
+    if (ready_event_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaEventDestroy(ready_event_));
+      ready_event_ = nullptr;
+    }
+    ready_stream_ = nullptr;
+    retained_buffer_ = internal::DeviceBuffer();
+    rows_ = rows;
+    cols_ = cols;
+    allocate(bytes);
+  }
+
+  Scalar* data() { return data_.get(); }
+  const Scalar* data() const { return data_.get(); }
+  Index rows() const { return rows_; }
+  Index cols() const { return cols_; }
+  bool empty() const { return rows_ == 0 || cols_ == 0; }
+
+  /** Size of the device allocation in bytes. */
+  size_t sizeInBytes() const { return static_cast<size_t>(rows_) * static_cast<size_t>(cols_) * sizeof(Scalar); }
+
+  /** Record that device data is ready after work on \p stream. */
+  void recordReady(cudaStream_t stream) {
+    ensureEvent();
+    EIGEN_CUDA_RUNTIME_CHECK(cudaEventRecord(ready_event_, stream));
+    ready_stream_ = stream;
+  }
+
+  /** Make \p stream wait until the device data is ready.
+   * No-op if no event recorded, or if the consumer stream is the same as the
+   * producer stream (CUDA guarantees in-order execution within a stream). */
+  void waitReady(cudaStream_t stream) const {
+    if (ready_event_ && stream != ready_stream_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaStreamWaitEvent(stream, ready_event_, 0));
+    }
+  }
+
+  /** Adjoint view: maps to a GEMM operand with ConjTrans. */
+  AdjointView<Scalar> adjoint() const { return AdjointView<Scalar>(*this); }
+
+  /** Transpose view: maps to a GEMM operand with Trans. */
+  TransposeView<Scalar> transpose() const { return TransposeView<Scalar>(*this); }
+
+  /** Bind this matrix to a Context for expression assignment:
+   * `d_C.device(ctx) = d_A * d_B;` */
+  Assignment<Scalar> device(Context& ctx) { return Assignment<Scalar>(*this, ctx); }
+
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix& operator=(const GemmExpr<Lhs, Rhs>& expr);
+
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix& operator+=(const GemmExpr<Lhs, Rhs>& expr);
+
+  /** Subtract a GEMM expression using the thread-local default Context. */
+  template <typename Lhs, typename Rhs>
+  DeviceMatrix& operator-=(const GemmExpr<Lhs, Rhs>& expr);
+
+  /** Cholesky view: d_A.llt().solve(d_B) → LltSolveExpr. */
+  LLTView<Scalar, Lower> llt() const { return LLTView<Scalar, Lower>(*this); }
+
+  /** Cholesky view with explicit triangle: d_A.llt<Upper>().solve(d_B). */
+  template <int UpLo>
+  LLTView<Scalar, UpLo> llt() const {
+    return LLTView<Scalar, UpLo>(*this);
+  }
+
+  /** LU view: d_A.lu().solve(d_B) → LuSolveExpr. */
+  LUView<Scalar> lu() const { return LUView<Scalar>(*this); }
+
+  template <int UpLo>
+  DeviceMatrix& operator=(const LltSolveExpr<Scalar, UpLo>& expr);
+
+  DeviceMatrix& operator=(const LuSolveExpr<Scalar>& expr);
+
+  /** Triangular view: d_A.triangularView<Lower>().solve(d_B) → TrsmExpr. */
+  template <int UpLo>
+  TriangularView<Scalar, UpLo> triangularView() const {
+    return TriangularView<Scalar, UpLo>(*this);
+  }
+
+  /** Self-adjoint view (mutable): d_C.selfadjointView<Lower>().rankUpdate(d_A). */
+  template <int UpLo>
+  SelfAdjointView<Scalar, UpLo> selfadjointView() {
+    return SelfAdjointView<Scalar, UpLo>(*this);
+  }
+
+  /** Self-adjoint view (const): d_A.selfadjointView<Lower>() * d_B → SymmExpr. */
+  template <int UpLo>
+  ConstSelfAdjointView<Scalar, UpLo> selfadjointView() const {
+    return ConstSelfAdjointView<Scalar, UpLo>(*this);
+  }
+
+  template <int UpLo>
+  DeviceMatrix& operator=(const TrsmExpr<Scalar, UpLo>& expr);
+
+  template <int UpLo>
+  DeviceMatrix& operator=(const SymmExpr<Scalar, UpLo>& expr);
+
+  // A DeviceMatrix is always dense (lda == rows) and a vector is one with
+  // cols == 1, so the BLAS-1 methods below simply run over the flat rows*cols
+  // array and serve both. Passing an explicit Context& lets callers keep every
+  // operation on one stream, which elides the cross-stream event waits.
+
+  /** Dot product: this^H * other. The result stays on device until read through
+   * DeviceScalar's conversion to Scalar, which syncs. */
+  DeviceScalar<Scalar> dot(Context& ctx, const DeviceMatrix& other) const;
+
+  /** Squared L2 norm via dot(x, x). For real types the result stays on device;
+   * for complex it syncs, since DeviceScalar arithmetic is real-only. */
+  DeviceScalar<typename NumTraits<Scalar>::Real> squaredNorm(Context& ctx) const;
+
+  /** L2 norm, without a host sync. */
+  DeviceScalar<typename NumTraits<Scalar>::Real> norm(Context& ctx) const;
+
+  /** Set all elements to zero. */
+  void setZero(Context& ctx);
+  void setZero(cudaStream_t stream);
+
+  /** this += alpha * x (cuBLAS axpy). Requires same total size. */
+  void addScaled(Context& ctx, Scalar alpha, const DeviceMatrix& x);
+
+  /** this *= alpha (cuBLAS scal). */
+  void scale(Context& ctx, Scalar alpha);
+
+  /** Deep copy: this = other (cuBLAS copy). Resizes if needed. */
+  void copyFrom(Context& ctx, const DeviceMatrix& other);
+
+  DeviceScalar<Scalar> dot(const DeviceMatrix& other) const;
+  DeviceScalar<typename NumTraits<Scalar>::Real> squaredNorm() const;
+  DeviceScalar<typename NumTraits<Scalar>::Real> norm() const;
+  void setZero();
+
+  // The operators below let iterative-solver code written against Matrix — say
+  // `x += alpha * p` — compile unchanged against DeviceMatrix, dispatching to
+  // cuBLAS axpy/scal. `alpha * DeviceMatrix` yields Scaled<DeviceMatrix<Scalar>>
+  // from DeviceExpr.h.
+
+  /** this += alpha * x (cuBLAS axpy). */
+  DeviceMatrix& operator+=(const Scaled<DeviceMatrix>& expr);
+
+  /** this -= alpha * x (cuBLAS axpy with negated alpha). */
+  DeviceMatrix& operator-=(const Scaled<DeviceMatrix>& expr);
+
+  /** this += x (cuBLAS axpy with alpha=1). */
+  DeviceMatrix& operator+=(const DeviceMatrix& other);
+
+  /** this -= x (cuBLAS axpy with alpha=-1). */
+  DeviceMatrix& operator-=(const DeviceMatrix& other);
+
+  /** this *= alpha (cuBLAS scal, host pointer mode). */
+  DeviceMatrix& operator*=(Scalar alpha);
+
+  /** this *= alpha (cuBLAS scal, device pointer mode). Avoids a host sync. */
+  DeviceMatrix& operator*=(const DeviceScalar<Scalar>& alpha);
+
+  /** Element-wise product: result[i] = this[i] * other[i]. */
+  DeviceMatrix cwiseProduct(Context& ctx, const DeviceMatrix& other) const;
+
+  /** In-place element-wise product: this[i] = a[i] * b[i].
+   * Reuses this matrix's buffer when sizes match, avoiding cudaMalloc. */
+  void cwiseProduct(Context& ctx, const DeviceMatrix& a, const DeviceMatrix& b);
+
+  /** this += DeviceScalar * x (cuBLAS axpy with POINTER_MODE_DEVICE). */
+  DeviceMatrix& operator+=(const DeviceScaledDevice<Scalar>& expr);
+
+  /** this -= DeviceScalar * x (cuBLAS axpy with negated device scalar). */
+  DeviceMatrix& operator-=(const DeviceScaledDevice<Scalar>& expr);
+
+  /** Assign from an SpMV expression: d_y = d_A * d_x. */
+  DeviceMatrix& operator=(const SpMVExpr<Scalar>& expr);
+
+  /** Assign from an add expression: d_C = alpha * d_A + beta * d_B (cuBLAS geam). */
+  DeviceMatrix& operator=(const DeviceAddExpr<Scalar>& expr);
+
+  /** Assign from a scaled matrix: d_C = alpha * d_A (cuBLAS geam with beta=0).
+   * Also covers unary minus: d_C = -d_A. Safe when d_C aliases d_A. */
+  DeviceMatrix& operator=(const Scaled<DeviceMatrix>& expr);
+
+  /** No-op — every DeviceMatrix assignment is already implicitly noalias.
+   *
+   * Eigen's Matrix falls back to a temporary when .noalias() is omitted, but
+   * DeviceMatrix dispatches straight to NVIDIA library calls, which offer no
+   * aliasing protection. For GEMM and SpMV the caller must therefore keep the
+   * operands clear of the destination; geam (`d_C = d_A + alpha * d_B`) is safe
+   * under aliasing. Debug asserts catch violations.
+   *
+   * The method exists so `tmp.noalias() = mat * p` compiles for both types. */
+  DeviceMatrix& noalias() { return *this; }
+
+  /** Adopt an existing device pointer. Caller relinquishes ownership. */
+  static DeviceMatrix adopt(Scalar* device_ptr, Index rows, Index cols) {
+    DeviceMatrix dm;
+    dm.data_.reset(device_ptr);
+    dm.rows_ = rows;
+    dm.cols_ = cols;
+    dm.capacity_bytes_ = dm.sizeInBytes();
+    return dm;
+  }
+
+  /** Construct a non-owning view over an existing device pointer.
+   *
+   * The pointer is *borrowed*: destruction does not free, and the underlying
+   * storage must outlive this view. This chains decomposition outputs (e.g.
+   * `svd.d_matrixU()`) into downstream cuBLAS expressions without an intervening
+   * D2D copy, and supports the full read interface. Do not assign through a view:
+   * the borrowed pointer would be silently replaced, leaving the owner intact. */
+  static DeviceMatrix view(Scalar* device_ptr, Index rows, Index cols) {
+    DeviceMatrix dm;
+    dm.data_ =
+        std::unique_ptr<Scalar, internal::CudaFreeDeleter>(device_ptr, internal::CudaFreeDeleter{/*borrow=*/true});
+    dm.rows_ = rows;
+    dm.cols_ = cols;
+    return dm;
+  }
+
+  /** Transfer ownership of the device pointer out. Zeros internal state. */
+  Scalar* release() {
+    Scalar* p = data_.release();
+    rows_ = 0;
+    cols_ = 0;
+    capacity_bytes_ = 0;
+    if (ready_event_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaEventDestroy(ready_event_));
+      ready_event_ = nullptr;
+    }
+    ready_stream_ = nullptr;
+    return p;
+  }
+
+ private:
+  // Fresh owning allocation of `bytes` (no-op for empty). Also resets the
+  // deleter so a previously borrowed (view) deleter cannot leak the new
+  // owned pointer.
+  void allocate(size_t bytes) {
+    if (bytes > 0) {
+      data_ = std::unique_ptr<Scalar, internal::CudaFreeDeleter>(static_cast<Scalar*>(internal::device_malloc(bytes)),
+                                                                 internal::CudaFreeDeleter{});
+      capacity_bytes_ = bytes;
+    }
+  }
+
+  void ensureEvent() {
+    if (!ready_event_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaEventCreateWithFlags(&ready_event_, cudaEventDisableTiming));
+    }
+  }
+
+  void retainBuffer(internal::DeviceBuffer&& buffer) { retained_buffer_ = std::move(buffer); }
+
+  std::unique_ptr<Scalar, internal::CudaFreeDeleter> data_;
+  Index rows_ = 0;
+  Index cols_ = 0;
+  size_t capacity_bytes_ = 0;               // owned allocation size (0 for borrowed views)
+  cudaEvent_t ready_event_ = nullptr;       // internal: tracks last write completion
+  cudaStream_t ready_stream_ = nullptr;     // stream that recorded ready_event_ (for same-stream skip)
+  internal::DeviceBuffer retained_buffer_;  // internal: keeps async aux buffers alive
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_MATRIX_H
diff --git a/contrib/Eigen/src/GPU/DeviceScalar.h b/contrib/Eigen/src/GPU/DeviceScalar.h
new file mode 100644
index 0000000..e24d122
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceScalar.h
@@ -0,0 +1,111 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Device-resident scalar for deferred host synchronization.
+//
+// Reductions (dot, nrm2) write their result straight to device memory under
+// CUBLAS_POINTER_MODE_DEVICE, so no host sync happens until the value is read.
+// Conversion to Scalar is that read. Because the first conversion flushes the
+// stream, later conversions in the same expression only download: a CG iteration
+// costs one sync rather than three.
+
+#ifndef EIGEN_GPU_DEVICE_SCALAR_H
+#define EIGEN_GPU_DEVICE_SCALAR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSupport.h"
+#include "./DeviceScalarOps.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** \brief RAII wrapper for a scalar in GPU device memory. */
+template <typename Scalar_>
+class DeviceScalar {
+ public:
+  using Scalar = Scalar_;
+
+  /** Allocate an uninitialized device scalar. Contents are undefined until
+   * written, e.g. by cuBLAS dot/nrm2 under POINTER_MODE_DEVICE. */
+  explicit DeviceScalar(cudaStream_t stream = nullptr) : d_val_(sizeof(Scalar)), stream_(stream) {}
+
+  DeviceScalar(Scalar host_val, cudaStream_t stream) : d_val_(sizeof(Scalar)), stream_(stream) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_val_.get(), &host_val, sizeof(Scalar), cudaMemcpyHostToDevice, stream_));
+  }
+
+  DeviceScalar(DeviceScalar&& o) noexcept : d_val_(std::move(o.d_val_)), stream_(o.stream_) { o.stream_ = nullptr; }
+
+  DeviceScalar& operator=(DeviceScalar&& o) noexcept {
+    if (this != &o) {
+      d_val_ = std::move(o.d_val_);
+      stream_ = o.stream_;
+      o.stream_ = nullptr;
+    }
+    return *this;
+  }
+
+  DeviceScalar(const DeviceScalar&) = delete;
+  DeviceScalar& operator=(const DeviceScalar&) = delete;
+
+  /** Download from device, synchronizing the stream. */
+  Scalar get() const {
+    Scalar result;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(&result, d_val_.get(), sizeof(Scalar), cudaMemcpyDeviceToHost, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+    return result;
+  }
+
+  /** Implicit conversion, enabling `Scalar alpha = deviceScalar` and
+   * `if (deviceScalar < threshold)`. Triggers a sync. */
+  operator Scalar() const { return get(); }
+
+  Scalar* devicePtr() { return static_cast<Scalar*>(d_val_.get()); }
+  const Scalar* devicePtr() const { return static_cast<const Scalar*>(d_val_.get()); }
+  cudaStream_t stream() const { return stream_; }
+
+  // The arithmetic below keeps results on device via the NPP helpers in
+  // DeviceScalarOps.h, and covers real types only; complex division falls back to
+  // the implicit conversion and its host sync. Unlike DeviceMatrix, DeviceScalar
+  // tracks no cross-stream readiness, so all operands must share one stream.
+
+  friend DeviceScalar operator/(const DeviceScalar& a, const DeviceScalar& b) {
+    eigen_assert(a.stream_ == b.stream_ && "DeviceScalar operator/: operands must share the same stream");
+    DeviceScalar result(a.stream_);
+    gpu::internal::device_scalar_div(a.devicePtr(), b.devicePtr(), result.devicePtr(), a.stream_);
+    return result;
+  }
+
+  friend DeviceScalar operator/(Scalar a, const DeviceScalar& b) {
+    DeviceScalar d_a(a, b.stream_);
+    return d_a / b;
+  }
+
+  friend DeviceScalar operator/(const DeviceScalar& a, Scalar b) {
+    DeviceScalar d_b(b, a.stream_);
+    return a / d_b;
+  }
+
+  DeviceScalar operator-() const {
+    DeviceScalar result(stream_);
+    gpu::internal::device_scalar_neg(devicePtr(), result.devicePtr(), stream_);
+    return result;
+  }
+
+ private:
+  internal::DeviceBuffer d_val_;
+  cudaStream_t stream_ = nullptr;
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_SCALAR_H
diff --git a/contrib/Eigen/src/GPU/DeviceScalarOps.h b/contrib/Eigen/src/GPU/DeviceScalarOps.h
new file mode 100644
index 0000000..fb003f8
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceScalarOps.h
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Device-resident scalar and element-wise operations built on the NPP signal
+// primitives (CUDA::npps), which keeps the module header-only: no custom CUDA
+// kernels to compile.
+
+#ifndef EIGEN_GPU_DEVICE_SCALAR_OPS_H
+#define EIGEN_GPU_DEVICE_SCALAR_OPS_H
+
+#include <cuda_runtime.h>
+#include <npps_arithmetic_and_logical_operations.h>
+
+#include "./GpuSupport.h"
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+// NPP requires nCudaDeviceId and the device attributes to match the device that
+// owns `stream`. Re-querying per call is cheap next to the NPP launch itself and
+// keeps multi-device and borrowed-stream callers correct.
+inline NppStreamContext make_npp_stream_ctx(cudaStream_t stream) {
+  NppStreamContext ctx = {};
+  ctx.hStream = stream;
+#if CUDART_VERSION >= 12080
+  // cudaStreamGetDevice reports the stream's owning device irrespective of the
+  // calling thread's current device.
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamGetDevice(stream, &ctx.nCudaDeviceId));
+#else
+  // Without cudaStreamGetDevice (pre-CUDA 12.8), a caller borrowing a stream from
+  // another device must cudaSetDevice() first.
+  EIGEN_CUDA_RUNTIME_CHECK(cudaGetDevice(&ctx.nCudaDeviceId));
+#endif
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceGetAttribute(&ctx.nCudaDevAttrComputeCapabilityMajor,
+                                                  cudaDevAttrComputeCapabilityMajor, ctx.nCudaDeviceId));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceGetAttribute(&ctx.nCudaDevAttrComputeCapabilityMinor,
+                                                  cudaDevAttrComputeCapabilityMinor, ctx.nCudaDeviceId));
+  EIGEN_CUDA_RUNTIME_CHECK(
+      cudaDeviceGetAttribute(&ctx.nMultiProcessorCount, cudaDevAttrMultiProcessorCount, ctx.nCudaDeviceId));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceGetAttribute(&ctx.nMaxThreadsPerMultiProcessor,
+                                                  cudaDevAttrMaxThreadsPerMultiProcessor, ctx.nCudaDeviceId));
+  EIGEN_CUDA_RUNTIME_CHECK(
+      cudaDeviceGetAttribute(&ctx.nMaxThreadsPerBlock, cudaDevAttrMaxThreadsPerBlock, ctx.nCudaDeviceId));
+  int shared_mem_per_block = 0;
+  EIGEN_CUDA_RUNTIME_CHECK(
+      cudaDeviceGetAttribute(&shared_mem_per_block, cudaDevAttrMaxSharedMemoryPerBlock, ctx.nCudaDeviceId));
+  ctx.nSharedMemPerBlock = static_cast<size_t>(shared_mem_per_block);
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamGetFlags(stream, &ctx.nStreamFlags));
+  return ctx;
+}
+
+// c = a / b. The operands are swapped because NPP computes
+// pDst[i] = pSrc2[i] / pSrc1[i].
+inline void device_scalar_div(const float* a, const float* b, float* c, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsDiv_32f_Ctx(b, a, c, 1, npp_ctx);
+}
+
+inline void device_scalar_div(const double* a, const double* b, double* c, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsDiv_64f_Ctx(b, a, c, 1, npp_ctx);
+}
+
+// c = -a.
+inline void device_scalar_neg(const float* a, float* c, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsMulC_32f_Ctx(a, -1.0f, c, 1, npp_ctx);
+}
+
+inline void device_scalar_neg(const double* a, double* c, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsMulC_64f_Ctx(a, -1.0, c, 1, npp_ctx);
+}
+
+// c[i] = a[i] * b[i].
+inline void device_cwiseProduct(const float* a, const float* b, float* c, int n, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsMul_32f_Ctx(a, b, c, n, npp_ctx);
+}
+
+inline void device_cwiseProduct(const double* a, const double* b, double* c, int n, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsMul_64f_Ctx(a, b, c, n, npp_ctx);
+}
+
+// c[i] = a[i] / b[i], with operands swapped as in device_scalar_div.
+inline void device_cwiseQuotient(const float* a, const float* b, float* c, int n, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsDiv_32f_Ctx(b, a, c, n, npp_ctx);
+}
+
+inline void device_cwiseQuotient(const double* a, const double* b, double* c, int n, cudaStream_t stream) {
+  NppStreamContext npp_ctx = make_npp_stream_ctx(stream);
+  nppsDiv_64f_Ctx(b, a, c, n, npp_ctx);
+}
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_SCALAR_OPS_H
diff --git a/contrib/Eigen/src/GPU/DeviceSolverExpr.h b/contrib/Eigen/src/GPU/DeviceSolverExpr.h
new file mode 100644
index 0000000..27a4541
--- /dev/null
+++ b/contrib/Eigen/src/GPU/DeviceSolverExpr.h
@@ -0,0 +1,92 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Solver expression types for gpu::DeviceMatrix. Each maps 1:1 onto a pair of
+// cuSOLVER calls and factors afresh on every assignment; use the gpu::LLT /
+// gpu::LU classes when a factorization should be cached across solves.
+
+#ifndef EIGEN_GPU_DEVICE_SOLVER_EXPR_H
+#define EIGEN_GPU_DEVICE_SOLVER_EXPR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <functional>
+
+#include "./FwdDecl.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** d_A.llt().solve(d_B), dispatched to cusolverDnXpotrf + cusolverDnXpotrs. */
+template <typename Scalar_, int UpLo_ = Lower>
+class LltSolveExpr {
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  LltSolveExpr(const DeviceMatrix<Scalar>& A, const DeviceMatrix<Scalar>& B) : A_(A), B_(B) {}
+  const DeviceMatrix<Scalar>& matrix() const { return A_; }
+  const DeviceMatrix<Scalar>& rhs() const { return B_; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> A_;
+  std::reference_wrapper<const DeviceMatrix<Scalar>> B_;
+};
+
+/** d_A.lu().solve(d_B), dispatched to cusolverDnXgetrf + cusolverDnXgetrs. */
+template <typename Scalar_>
+class LuSolveExpr {
+ public:
+  using Scalar = Scalar_;
+
+  LuSolveExpr(const DeviceMatrix<Scalar>& A, const DeviceMatrix<Scalar>& B) : A_(A), B_(B) {}
+  const DeviceMatrix<Scalar>& matrix() const { return A_; }
+  const DeviceMatrix<Scalar>& rhs() const { return B_; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> A_;
+  std::reference_wrapper<const DeviceMatrix<Scalar>> B_;
+};
+
+/** d_A.llt(), whose solve() builds an LltSolveExpr. */
+template <typename Scalar_, int UpLo_ = Lower>
+class LLTView {
+ public:
+  using Scalar = Scalar_;
+
+  explicit LLTView(const DeviceMatrix<Scalar>& m) : mat_(m) {}
+
+  /** The expression is evaluated on assignment to a gpu::DeviceMatrix. */
+  LltSolveExpr<Scalar, UpLo_> solve(const DeviceMatrix<Scalar>& rhs) const { return {mat_, rhs}; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> mat_;
+};
+
+/** d_A.lu(), whose solve() builds a LuSolveExpr. */
+template <typename Scalar_>
+class LUView {
+ public:
+  using Scalar = Scalar_;
+
+  explicit LUView(const DeviceMatrix<Scalar>& m) : mat_(m) {}
+
+  /** The expression is evaluated on assignment to a gpu::DeviceMatrix. */
+  LuSolveExpr<Scalar> solve(const DeviceMatrix<Scalar>& rhs) const { return {mat_, rhs}; }
+
+ private:
+  std::reference_wrapper<const DeviceMatrix<Scalar>> mat_;
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_DEVICE_SOLVER_EXPR_H
diff --git a/contrib/Eigen/src/GPU/FwdDecl.h b/contrib/Eigen/src/GPU/FwdDecl.h
new file mode 100644
index 0000000..9cf0457
--- /dev/null
+++ b/contrib/Eigen/src/GPU/FwdDecl.h
@@ -0,0 +1,96 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GPU_FWD_DECL_H
+#define EIGEN_GPU_FWD_DECL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace gpu {
+
+class Context;
+
+enum class GpuOp;
+
+namespace internal {
+class DeviceBuffer;
+
+/** \brief Describes GPU device expression types.
+ *
+ * Specializations report the expression's scalar type, its transpose op, and
+ * how to reach the underlying matrix and deferred scalar. They live in
+ * DeviceExpr.h; this declaration is what the query aliases in type_traits.h
+ * are written against.
+ */
+template <typename Expr>
+struct device_expr_traits;
+}  // namespace internal
+
+template <typename Scalar_>
+class DeviceMatrix;
+template <typename Scalar_>
+class DeviceScalar;
+
+template <typename Scalar_, int UpLo_>
+class LLT;
+template <typename Scalar_>
+class LU;
+template <typename Scalar_>
+class QR;
+
+template <typename Scalar_>
+class AdjointView;
+template <typename Scalar_>
+class TransposeView;
+template <typename Scalar_>
+class Assignment;
+template <typename Lhs, typename Rhs>
+class GemmExpr;
+template <typename Inner>
+class Scaled;
+template <typename Scalar_>
+class DeviceAddExpr;
+template <typename Scalar_>
+class DeviceScaledDevice;
+
+template <typename Scalar_, int UpLo_>
+class LltSolveExpr;
+template <typename Scalar_>
+class LuSolveExpr;
+template <typename Scalar_, int UpLo_>
+class LLTView;
+template <typename Scalar_>
+class LUView;
+
+template <typename Scalar_, int UpLo_>
+class TriangularView;
+template <typename Scalar_, int UpLo_>
+class SelfAdjointView;
+template <typename Scalar_, int UpLo_>
+class ConstSelfAdjointView;
+template <typename Scalar_, int UpLo_>
+class TrsmExpr;
+template <typename Scalar_, int UpLo_>
+class SymmExpr;
+template <typename Scalar_, int UpLo_>
+class SyrkExpr;
+
+template <typename Scalar_>
+class SparseContext;
+template <typename Scalar_>
+class DeviceSparseView;
+template <typename Scalar_>
+class SpMVExpr;
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_FWD_DECL_H
diff --git a/contrib/Eigen/src/GPU/GpuContext.h b/contrib/Eigen/src/GPU/GpuContext.h
new file mode 100644
index 0000000..fed40e4
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuContext.h
@@ -0,0 +1,230 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Unified GPU execution context: a CUDA stream plus the NVIDIA library handles
+// used by gpu::DeviceMatrix operations.
+
+#ifndef EIGEN_GPU_CONTEXT_H
+#define EIGEN_GPU_CONTEXT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./CuBlasSupport.h"
+#include "./CuSolverSupport.h"
+#include <cusparse.h>
+#include <vector>
+
+namespace Eigen {
+namespace gpu {
+
+namespace internal {
+
+// cuSOLVER writes the factorization/solve status words to device memory in
+// every build, so d_info must exist even under EIGEN_NO_DEBUG. Only the
+// pinned host mirror is debug-only: it feeds the oneshot_check_info assert,
+// which release builds compile out.
+constexpr size_t kOneShotInfoBytes = 2 * sizeof(int);
+#ifdef EIGEN_NO_DEBUG
+constexpr size_t kOneShotHostInfoBytes = 0;
+#else
+constexpr size_t kOneShotHostInfoBytes = kOneShotInfoBytes;
+#endif
+// Grow-only scratch shared by the one-shot solver expressions
+// (d_A.llt().solve(d_B), d_A.lu().solve(d_B)), so repeated one-shot solves on
+// a Context perform no per-call device or pinned-host allocations. Holds only
+// CUDA-runtime types (no cuSOLVER types) to keep the lazy-linking property of
+// Context. Used by the one-shot solve dispatches in DeviceDispatch.h.
+struct OneShotSolverScratch {
+  DeviceBuffer d_factor;
+  DeviceBuffer d_ipiv;
+  DeviceBuffer d_workspace;
+  DeviceBuffer d_info{kOneShotInfoBytes};          // 2 ints: {factorization, solve}
+  PinnedHostBuffer h_info{kOneShotHostInfoBytes};  // debug-build info check only
+  std::vector<char> h_workspace;
+};
+
+inline void ensure_sized(DeviceBuffer& buf, size_t needed) {
+  if (needed > buf.size()) {
+    // Replacing an in-use buffer is safe: device_free is stream-ordered (or
+    // fully synchronous on the cudaMalloc fallback path) and DeviceBufferPool
+    // holds a released block back until the device has retired the work
+    // enqueued before the release, so nothing reuses the old buffer early.
+    buf = DeviceBuffer(needed);
+  }
+}
+}  // namespace internal
+
+/** \ingroup GPU_Module
+ * \class Context
+ * \brief Unified GPU execution context owning a CUDA stream and library handles.
+ *
+ * Each Context creates a dedicated CUDA stream and an eager cuBLAS handle bound
+ * to it; multiple contexts run concurrently on independent streams. The
+ * cuSOLVER, cuBLASLt, and cuSPARSE handles are created on first use, so a
+ * translation unit that never touches cuSOLVER (the cuFFT test, say) does not
+ * need it at link time. threadLocal() supplies a lazily-created default for
+ * simple single-stream usage.
+ *
+ * A Context is not thread-safe: the library handles are not thread-safe per
+ * handle and the lazy initialization above is racy, so use one per thread or
+ * synchronize externally.
+ */
+class Context {
+ public:
+  /** Create a new context with a dedicated CUDA stream. */
+  Context() {
+    cudaStream_t s = nullptr;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&s));
+    stream_ = internal::UniqueStream(s);
+    init_cublas();
+  }
+
+  /** Create a context on an existing stream (e.g., stream 0 = nullptr).
+   * The caller retains ownership of the stream — this context will not destroy it. */
+  explicit Context(cudaStream_t stream) : stream_(stream, internal::CudaStreamDeleter{/*owns=*/false}) {
+    init_cublas();
+  }
+
+  ~Context() = default;
+
+  Context(const Context&) = delete;
+  Context& operator=(const Context&) = delete;
+  Context(Context&&) = delete;
+  Context& operator=(Context&&) = delete;
+
+  /** Get the thread-local default context.
+   *
+   * If setThreadLocal() has been called, returns that context.
+   * Otherwise lazily creates a new context with a dedicated stream.
+   *
+   * \note The thread-local instance is destroyed when the thread exits (or at
+   * static destruction time for the main thread). On some CUDA driver
+   * configurations this may print "CUDA_ERROR_DEINITIALIZED" to stderr if the
+   * CUDA context has already been torn down. These errors are harmless and are
+   * suppressed in the destructor, but they can produce noise in test output.
+   * To avoid this, call cudaDeviceReset() only after all Context instances
+   * (including thread-local ones) have been destroyed — or create and own a
+   * Context and install it with setThreadLocal(): the lazily-created default
+   * is then never constructed, and teardown order is fully under application
+   * control. */
+  static Context& threadLocal() {
+    Context* override = tl_override_ptr();
+    if (override) return *override;
+    thread_local Context ctx;
+    return ctx;
+  }
+
+  /** Override the thread-local default context for this thread.
+   * The caller retains ownership of \p ctx — it must outlive all uses.
+   * Pass nullptr to restore the lazily-created default. */
+  static void setThreadLocal(Context* ctx) { tl_override_ptr() = ctx; }
+
+  cudaStream_t stream() const { return stream_.get(); }
+  cublasHandle_t cublasHandle() const { return cublas_.get(); }
+
+  /** Returns the cuSOLVER handle, creating it on first call. */
+  cusolverDnHandle_t cusolverHandle() {
+    if (!cusolver_) {
+      cusolverDnHandle_t h = nullptr;
+      EIGEN_CUSOLVER_CHECK(cusolverDnCreate(&h));
+      cusolver_ = LazyCusolverHandle(h, &destroyCusolver);
+      EIGEN_CUSOLVER_CHECK(cusolverDnSetStream(h, stream_.get()));
+    }
+    return cusolver_.get();
+  }
+
+  /** cuBLASLt handle (lazy-initialized on first GEMM call). */
+  cublasLtHandle_t cublasLtHandle() {
+    if (!cublas_lt_) {
+      cublasLtHandle_t h = nullptr;
+      EIGEN_CUBLAS_CHECK(cublasLtCreate(&h));
+      cublas_lt_ = internal::UniqueCublasLtHandle(h);
+    }
+    return cublas_lt_.get();
+  }
+
+  /** Workspace buffer for cublasLtMatmul (grown lazily by cublaslt_gemm).
+   * Not thread-safe — all GEMM calls must be on this context's stream. */
+  internal::DeviceBuffer& gemmWorkspace() { return gemm_workspace_; }
+
+  /** Plan cache for cublasLtMatmul (caches descriptors and selected algorithm
+   * by shape to avoid per-call overhead). Same thread-safety as workspace. */
+  internal::CublasLtPlanCache& gemmPlanCache() { return gemm_plan_cache_; }
+
+  /** Grow-only scratch for the one-shot solver expressions
+   * (d_A.llt().solve(d_B), d_A.lu().solve(d_B)). Same thread-safety rules as
+   * the GEMM workspace: all uses must be on this context's stream. */
+  internal::OneShotSolverScratch& oneshotSolverScratch() { return oneshot_solver_scratch_; }
+
+  /** Workspace ceiling passed to the cublasLtMatmul heuristic at plan-creation time.
+   * Defaults to internal::kCublasLtMaxWorkspaceBytes (compile-time configurable via
+   * EIGEN_CUDA_CUBLASLT_MAX_WORKSPACE_BYTES). */
+  std::size_t cublasLtMaxWorkspaceBytes() const { return cublaslt_max_workspace_bytes_; }
+
+  /** Override the workspace ceiling for future plan-cache misses on this context.
+   * The cap is consulted at plan-creation time only; pre-existing cached plans
+   * keep the cap they were built with. Call gemmPlanCache().clear() to force
+   * re-selection under the new cap. */
+  void setCublasLtMaxWorkspaceBytes(std::size_t bytes) { cublaslt_max_workspace_bytes_ = bytes; }
+
+  /** cuSPARSE handle, created on first use. */
+  cusparseHandle_t cusparseHandle() {
+    if (!cusparse_) {
+      cusparseHandle_t h = nullptr;
+      cusparseStatus_t s1 = cusparseCreate(&h);
+      eigen_assert(s1 == CUSPARSE_STATUS_SUCCESS && "cusparseCreate failed");
+      EIGEN_UNUSED_VARIABLE(s1);
+      cusparse_ = LazyCusparseHandle(h, &destroyCusparse);
+      cusparseStatus_t s2 = cusparseSetStream(h, stream_.get());
+      eigen_assert(s2 == CUSPARSE_STATUS_SUCCESS && "cusparseSetStream failed");
+      EIGEN_UNUSED_VARIABLE(s2);
+    }
+    return cusparse_.get();
+  }
+
+ private:
+  static cusolverStatus_t destroyCusolver(cusolverDnHandle_t h) { return cusolverDnDestroy(h); }
+  static cusparseStatus_t destroyCusparse(cusparseHandle_t h) { return cusparseDestroy(h); }
+
+  // Function-pointer deleters keep cusolverDnDestroy / cusparseDestroy referenced only by TUs that create handles.
+  using LazyCusolverHandle =
+      std::unique_ptr<std::remove_pointer_t<cusolverDnHandle_t>, cusolverStatus_t (*)(cusolverDnHandle_t)>;
+  using LazyCusparseHandle =
+      std::unique_ptr<std::remove_pointer_t<cusparseHandle_t>, cusparseStatus_t (*)(cusparseHandle_t)>;
+
+  // Destroyed in reverse declaration order: the plan cache before the cuBLASLt handle, the stream last.
+  internal::UniqueStream stream_;
+  internal::UniqueCublasHandle cublas_;
+  LazyCusolverHandle cusolver_{nullptr, nullptr};
+  LazyCusparseHandle cusparse_{nullptr, nullptr};
+  internal::UniqueCublasLtHandle cublas_lt_;  // lazy
+  internal::DeviceBuffer gemm_workspace_;     // lazy
+  internal::CublasLtPlanCache gemm_plan_cache_{internal::kCublasLtPlanCacheCapacity};
+  internal::OneShotSolverScratch oneshot_solver_scratch_;  // grow-only
+  std::size_t cublaslt_max_workspace_bytes_ = internal::kCublasLtMaxWorkspaceBytes;
+
+  static Context*& tl_override_ptr() {
+    thread_local Context* ptr = nullptr;
+    return ptr;
+  }
+
+  void init_cublas() {
+    cublasHandle_t h = nullptr;
+    EIGEN_CUBLAS_CHECK(cublasCreate(&h));
+    cublas_ = internal::UniqueCublasHandle(h);
+    EIGEN_CUBLAS_CHECK(cublasSetStream(h, stream_.get()));
+  }
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_CONTEXT_H
diff --git a/contrib/Eigen/src/GPU/GpuEigenSolver.h b/contrib/Eigen/src/GPU/GpuEigenSolver.h
new file mode 100644
index 0000000..0198230
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuEigenSolver.h
@@ -0,0 +1,244 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU self-adjoint eigenvalue decomposition using cuSOLVER's divide-and-conquer
+// cusolverDnXsyevd. Eigenvalues and eigenvectors stay on device.
+
+#ifndef EIGEN_GPU_EIGENSOLVER_H
+#define EIGEN_GPU_EIGENSOLVER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSolverContext.h"
+
+namespace Eigen {
+namespace gpu {
+template <typename Scalar_>
+class SelfAdjointEigenSolver {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using RealVector = Eigen::Matrix<RealScalar, Dynamic, 1>;
+
+  SelfAdjointEigenSolver() = default;
+
+  /** Bind to \p ctx: run on its stream with its cuSOLVER/cuBLAS handles, so
+   * solver work chains with other work on the same Context without
+   * cross-stream event waits. \p ctx must outlive this object. */
+  explicit SelfAdjointEigenSolver(Context& ctx) : solver_ctx_(ctx) {}
+
+  /** \param options  Eigen::ComputeEigenvectors (default) or Eigen::EigenvaluesOnly. */
+  template <typename InputType>
+  explicit SelfAdjointEigenSolver(const DenseBase<InputType>& A, int options = ComputeEigenvectors) {
+    compute(A, options);
+  }
+
+  explicit SelfAdjointEigenSolver(const DeviceMatrix<Scalar>& d_A, int options = ComputeEigenvectors) {
+    compute(d_A, options);
+  }
+
+  /** Decompose a device-resident A immediately (adopt, no copy). */
+  explicit SelfAdjointEigenSolver(DeviceMatrix<Scalar>&& d_A, int options = ComputeEigenvectors) {
+    compute(std::move(d_A), options);
+  }
+
+  /** Bind to \p ctx and decompose A immediately. */
+  template <typename InputType>
+  SelfAdjointEigenSolver(Context& ctx, const DenseBase<InputType>& A, int options = ComputeEigenvectors)
+      : solver_ctx_(ctx) {
+    compute(A, options);
+  }
+
+  /** Bind to \p ctx and decompose a device-resident A (D2D copy). */
+  SelfAdjointEigenSolver(Context& ctx, const DeviceMatrix<Scalar>& d_A, int options = ComputeEigenvectors)
+      : solver_ctx_(ctx) {
+    compute(d_A, options);
+  }
+
+  ~SelfAdjointEigenSolver() = default;
+
+  SelfAdjointEigenSolver(const SelfAdjointEigenSolver&) = delete;
+  SelfAdjointEigenSolver& operator=(const SelfAdjointEigenSolver&) = delete;
+
+  SelfAdjointEigenSolver(SelfAdjointEigenSolver&& o) noexcept
+      : solver_ctx_(std::move(o.solver_ctx_)),
+        d_A_(std::move(o.d_A_)),
+        d_W_(std::move(o.d_W_)),
+        compute_eigenvectors_(o.compute_eigenvectors_),
+        n_(o.n_),
+        lda_(o.lda_) {
+    o.compute_eigenvectors_ = true;
+    o.n_ = 0;
+    o.lda_ = 0;
+  }
+
+  SelfAdjointEigenSolver& operator=(SelfAdjointEigenSolver&& o) noexcept {
+    if (this != &o) {
+      solver_ctx_ = std::move(o.solver_ctx_);
+      d_A_ = std::move(o.d_A_);
+      d_W_ = std::move(o.d_W_);
+      compute_eigenvectors_ = o.compute_eigenvectors_;
+      n_ = o.n_;
+      lda_ = o.lda_;
+      o.compute_eigenvectors_ = true;
+      o.n_ = 0;
+      o.lda_ = 0;
+    }
+    return *this;
+  }
+
+  template <typename InputType>
+  SelfAdjointEigenSolver& compute(const DenseBase<InputType>& A, int options = ComputeEigenvectors) {
+    // Route through the adopting overload: the freshly uploaded matrix is
+    // decomposed in place (syevd overwrites its input) — no second device copy.
+    return compute(DeviceMatrix<Scalar>::fromHost(A.derived(), solver_ctx_.stream()), options);
+  }
+
+  SelfAdjointEigenSolver& compute(const DeviceMatrix<Scalar>& d_A, int options = ComputeEigenvectors) {
+    if (!begin_compute(d_A, options)) return *this;
+
+    const size_t mat_bytes = static_cast<size_t>(lda_) * static_cast<size_t>(n_) * sizeof(Scalar);
+    internal::ensure_sized(d_A_, mat_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_A_.get(), d_A.data(), mat_bytes, cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+
+    factorize();
+    return *this;
+  }
+
+  /** Decompose a device matrix (move): the buffer is adopted and overwritten
+   * in place by syevd — no copy. */
+  SelfAdjointEigenSolver& compute(DeviceMatrix<Scalar>&& d_A, int options = ComputeEigenvectors) {
+    if (!begin_compute(d_A, options)) return *this;
+
+    d_A_ = internal::DeviceBuffer::adopt(static_cast<void*>(d_A.release()),
+                                         static_cast<size_t>(lda_) * static_cast<size_t>(n_) * sizeof(Scalar));
+
+    factorize();
+    return *this;
+  }
+
+  ComputationInfo info() const { return solver_ctx_.info(); }
+
+  Index cols() const { return n_; }
+  Index rows() const { return n_; }
+
+  /** Eigenvalues in ascending order. Downloads from device. */
+  RealVector eigenvalues() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    RealVector W(n_);
+    if (n_ > 0) {
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpy(W.data(), d_W_.get(), static_cast<size_t>(n_) * sizeof(RealScalar), cudaMemcpyDeviceToHost));
+    }
+    return W;
+  }
+
+  /** Eigenvectors (columns). Downloads from device.
+   * Requires ComputeEigenvectors mode. */
+  PlainMatrix eigenvectors() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert(compute_eigenvectors_ && "eigenvectors() requires ComputeEigenvectors option");
+    PlainMatrix V(n_, n_);
+    if (n_ > 0) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy(V.data(), d_A_.get(),
+                                          static_cast<size_t>(lda_) * static_cast<size_t>(n_) * sizeof(Scalar),
+                                          cudaMemcpyDeviceToHost));
+    }
+    return V;
+  }
+
+  //
+  // These return non-owning DeviceMatrix views over this solver's internal storage. The
+  // view borrows the pointer: destruction does not free; this solver must outlive any
+  // view derived from it. Both accessors are pure metadata — zero kernel launches.
+
+  /** Eigenvalues as an n × 1 view on this solver's stream. No host sync in
+   * release builds — the recorded event orders downstream consumers after
+   * syevd; debug builds verify the factorization status. */
+  DeviceMatrix<RealScalar> d_eigenvalues() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    auto v = DeviceMatrix<RealScalar>::view(static_cast<RealScalar*>(d_W_.get()), n_, 1);
+    v.recordReady(solver_ctx_.stream());
+    return v;
+  }
+
+  /** Eigenvectors (columns) as an n × n view on this solver's stream. Same
+   * synchronization contract as d_eigenvalues(). */
+  DeviceMatrix<Scalar> d_eigenvectors() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert(compute_eigenvectors_ && "d_eigenvectors() requires ComputeEigenvectors option");
+    auto v = DeviceMatrix<Scalar>::view(static_cast<Scalar*>(d_A_.get()), n_, n_);
+    v.recordReady(solver_ctx_.stream());
+    return v;
+  }
+
+  cudaStream_t stream() const { return solver_ctx_.stream(); }
+
+ private:
+  mutable internal::GpuSolverContext solver_ctx_;
+  internal::DeviceBuffer d_A_;  // grow-only; overwritten with eigenvectors by syevd
+  internal::DeviceBuffer d_W_;  // grow-only; eigenvalues (RealScalar, length n)
+  bool compute_eigenvectors_ = true;
+  int64_t n_ = 0;
+  int64_t lda_ = 0;
+
+  // Common compute() prologue: validate, record shape, reset info, wait on
+  // input. Returns false (and clears stale buffers) for empty input.
+  bool begin_compute(const DeviceMatrix<Scalar>& d_A, int options) {
+    eigen_assert(d_A.rows() == d_A.cols() && "SelfAdjointEigenSolver requires a square matrix");
+    eigen_assert((options == ComputeEigenvectors || options == EigenvaluesOnly) &&
+                 "options must be ComputeEigenvectors or EigenvaluesOnly");
+    compute_eigenvectors_ = (options == ComputeEigenvectors);
+    n_ = d_A.rows();
+    if (!solver_ctx_.begin_compute(n_ != 0)) {
+      d_A_ = internal::DeviceBuffer();
+      d_W_ = internal::DeviceBuffer();
+      return false;
+    }
+    lda_ = n_;
+    d_A.waitReady(solver_ctx_.stream());
+    return true;
+  }
+
+  void factorize() {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+    constexpr cudaDataType_t rtype = internal::cuda_data_type<RealScalar>::value;
+
+    solver_ctx_.mark_pending();
+
+    internal::ensure_sized(d_W_, static_cast<size_t>(n_) * sizeof(RealScalar));
+
+    const cusolverEigMode_t jobz = compute_eigenvectors_ ? CUSOLVER_EIG_MODE_VECTOR : CUSOLVER_EIG_MODE_NOVECTOR;
+
+    constexpr cublasFillMode_t uplo = CUBLAS_FILL_MODE_LOWER;
+
+    size_t dev_ws = 0, host_ws = 0;
+    EIGEN_CUSOLVER_CHECK(cusolverDnXsyevd_bufferSize(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, jobz, uplo,
+                                                     n_, dtype, d_A_.get(), lda_, rtype, d_W_.get(), dtype, &dev_ws,
+                                                     &host_ws));
+
+    solver_ctx_.ensure_scratch(dev_ws);
+    solver_ctx_.h_workspace_.resize(host_ws);
+
+    EIGEN_CUSOLVER_CHECK(cusolverDnXsyevd(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, jobz, uplo, n_, dtype,
+                                          d_A_.get(), lda_, rtype, d_W_.get(), dtype, solver_ctx_.scratch_workspace(),
+                                          dev_ws, host_ws > 0 ? solver_ctx_.h_workspace_.data() : nullptr, host_ws,
+                                          solver_ctx_.scratch_info()));
+
+    solver_ctx_.enqueue_info_copy();
+  }
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_EIGENSOLVER_H
diff --git a/contrib/Eigen/src/GPU/GpuFFT.h b/contrib/Eigen/src/GPU/GpuFFT.h
new file mode 100644
index 0000000..6aac926
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuFFT.h
@@ -0,0 +1,412 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU FFT via cuFFT: 1D and 2D C2C, R2C, and C2R transforms with plan caching.
+//
+// The stream and cuBLAS handle come from a bound gpu::Context, which defaults to
+// Context::threadLocal() so an FFT shares a stream with the thread's other GPU
+// work; pass an explicit Context to bind elsewhere.
+//
+// Inverse transforms are scaled by 1/n (1D) or 1/(n*m) (2D), so inv(fwd(x)) == x
+// as in Eigen's CPU FFT.
+//
+// Not thread-safe: concurrent fwd/inv calls on one instance race on the cached
+// plans and the bound Context. Use one FFT per thread.
+
+#ifndef EIGEN_GPU_FFT_H
+#define EIGEN_GPU_FFT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./CuFftSupport.h"
+#include "./CuBlasSupport.h"
+#include "./GpuContext.h"
+
+namespace Eigen {
+namespace gpu {
+// Default capacity of the per-FFT-instance cuFFT plan cache. Override by
+// passing a capacity to the FFT constructor.
+static constexpr std::size_t kDefaultCufftPlanCacheCapacity = 16;
+
+template <typename Scalar_>
+class FFT {
+ public:
+  using Scalar = Scalar_;
+  using Complex = std::complex<Scalar>;
+  using ComplexVector = Matrix<Complex, Dynamic, 1>;
+  using RealVector = Matrix<Scalar, Dynamic, 1>;
+  using ComplexMatrix = Matrix<Complex, Dynamic, Dynamic, ColMajor>;
+
+  /** Construct an FFT bound to the calling thread's default Context.
+   * The instance is thread-affine: it must not outlive the thread that
+   * constructed it, since it borrows a pointer into thread-local storage.
+   * For cross-thread lifetimes, pass an explicit Context.
+   *
+   * @param plan_cache_capacity max number of cuFFT plans to keep cached
+   *   (silently clamped to at least 1). On overflow the least-recently-used
+   *   plan is destroyed. */
+  explicit FFT(std::size_t plan_cache_capacity = kDefaultCufftPlanCacheCapacity)
+      : ctx_(&Context::threadLocal()), plans_(plan_cache_capacity > 0 ? plan_cache_capacity : 1) {}
+
+  /** Construct an FFT bound to the given Context. The Context must outlive
+   * this FFT instance; this object only borrows its stream and cuBLAS handle.
+   *
+   * @param plan_cache_capacity max number of cuFFT plans to keep cached
+   *   (silently clamped to at least 1). On overflow the least-recently-used
+   *   plan is destroyed. */
+  explicit FFT(Context& ctx, std::size_t plan_cache_capacity = kDefaultCufftPlanCacheCapacity)
+      : ctx_(&ctx), plans_(plan_cache_capacity > 0 ? plan_cache_capacity : 1) {}
+
+  // Destructor is implicit: ~LruCache destroys each CufftPlan, which calls
+  // cufftDestroy via CufftPlan's destructor.
+
+  /** Capacity of the cuFFT plan cache (set at construction). */
+  std::size_t plan_cache_capacity() const { return plans_.capacity(); }
+
+  /** Current number of cached cuFFT plans. */
+  std::size_t plan_cache_size() const { return plans_.size(); }
+
+  FFT(const FFT&) = delete;
+  FFT& operator=(const FFT&) = delete;
+
+  /** Forward 1D C2C FFT. */
+  template <typename Derived, std::enable_if_t<NumTraits<typename Derived::Scalar>::IsComplex>* = nullptr>
+  ComplexVector fwd(const MatrixBase<Derived>& x) {
+    const ComplexVector input(x.derived());
+    const int n = static_cast<int>(input.size());
+    if (n == 0) return ComplexVector(0);
+
+    ensure_buffers(n * sizeof(Complex), n * sizeof(Complex));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_in_.get(), input.data(), n * sizeof(Complex), cudaMemcpyHostToDevice, ctx_->stream()));
+
+    cufftHandle plan = get_plan_1d(n, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(internal::cufftExecC2C_dispatch(plan, static_cast<Complex*>(d_in_.get()),
+                                                      static_cast<Complex*>(d_out_.get()), CUFFT_FORWARD));
+
+    ComplexVector result(n);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(result.data(), d_out_.get(), n * sizeof(Complex), cudaMemcpyDeviceToHost, ctx_->stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+    return result;
+  }
+
+  /** Inverse 1D C2C FFT. Scaled by 1/n. */
+  template <typename Derived>
+  ComplexVector inv(const MatrixBase<Derived>& X) {
+    static_assert(NumTraits<typename Derived::Scalar>::IsComplex, "inv() requires complex input");
+    const ComplexVector input(X.derived());
+    const int n = static_cast<int>(input.size());
+    if (n == 0) return ComplexVector(0);
+
+    ensure_buffers(n * sizeof(Complex), n * sizeof(Complex));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_in_.get(), input.data(), n * sizeof(Complex), cudaMemcpyHostToDevice, ctx_->stream()));
+
+    cufftHandle plan = get_plan_1d(n, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(internal::cufftExecC2C_dispatch(plan, static_cast<Complex*>(d_in_.get()),
+                                                      static_cast<Complex*>(d_out_.get()), CUFFT_INVERSE));
+
+    // Scale by 1/n.
+    EIGEN_CUBLAS_CHECK(
+        internal::cublasXscal(ctx_->cublasHandle(), n, Scalar(1) / Scalar(n), static_cast<Complex*>(d_out_.get()), 1));
+
+    ComplexVector result(n);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(result.data(), d_out_.get(), n * sizeof(Complex), cudaMemcpyDeviceToHost, ctx_->stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+    return result;
+  }
+
+  /** Forward 1D R2C FFT. Returns n/2+1 complex values (half-spectrum). */
+  template <typename Derived, std::enable_if_t<!NumTraits<typename Derived::Scalar>::IsComplex>* = nullptr>
+  ComplexVector fwd(const MatrixBase<Derived>& x) {
+    const RealVector input(x.derived());
+    const int n = static_cast<int>(input.size());
+    if (n == 0) return ComplexVector(0);
+
+    const int n_complex = n / 2 + 1;
+    ensure_buffers(n * sizeof(Scalar), n_complex * sizeof(Complex));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_in_.get(), input.data(), n * sizeof(Scalar), cudaMemcpyHostToDevice, ctx_->stream()));
+
+    cufftHandle plan = get_plan_1d(n, internal::cufft_r2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(
+        internal::cufftExecR2C_dispatch(plan, static_cast<Scalar*>(d_in_.get()), static_cast<Complex*>(d_out_.get())));
+
+    ComplexVector result(n_complex);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(result.data(), d_out_.get(), n_complex * sizeof(Complex),
+                                             cudaMemcpyDeviceToHost, ctx_->stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+    return result;
+  }
+
+  /** Inverse 1D C2R FFT. Input is n/2+1 complex values, output is nfft real values.
+   * Scaled by 1/nfft. Caller must specify nfft (original real signal length). */
+  template <typename Derived>
+  RealVector invReal(const MatrixBase<Derived>& X, Index nfft) {
+    static_assert(NumTraits<typename Derived::Scalar>::IsComplex, "invReal() requires complex input");
+    const ComplexVector input(X.derived());
+    const int n = static_cast<int>(nfft);
+    const int n_complex = n / 2 + 1;
+    eigen_assert(input.size() == n_complex);
+    if (n == 0) return RealVector(0);
+
+    ensure_buffers(n_complex * sizeof(Complex), n * sizeof(Scalar));
+    // cuFFT C2R may overwrite the input, so we copy to d_in_.
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_in_.get(), input.data(), n_complex * sizeof(Complex),
+                                             cudaMemcpyHostToDevice, ctx_->stream()));
+
+    cufftHandle plan = get_plan_1d(n, internal::cufft_c2r_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(
+        internal::cufftExecC2R_dispatch(plan, static_cast<Complex*>(d_in_.get()), static_cast<Scalar*>(d_out_.get())));
+
+    // Scale by 1/n.
+    EIGEN_CUBLAS_CHECK(
+        internal::cublasXscal(ctx_->cublasHandle(), n, Scalar(1) / Scalar(n), static_cast<Scalar*>(d_out_.get()), 1));
+
+    RealVector result(n);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(result.data(), d_out_.get(), n * sizeof(Scalar), cudaMemcpyDeviceToHost, ctx_->stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+    return result;
+  }
+
+  /** Forward 2D C2C FFT. Input and output are rows x cols complex matrices. */
+  template <typename Derived>
+  ComplexMatrix fwd2(const MatrixBase<Derived>& A) {
+    static_assert(NumTraits<typename Derived::Scalar>::IsComplex, "fwd2() requires complex input");
+    const ComplexMatrix input(A.derived());
+    const int rows = static_cast<int>(input.rows());
+    const int cols = static_cast<int>(input.cols());
+    if (rows == 0 || cols == 0) return ComplexMatrix(rows, cols);
+
+    const size_t total = static_cast<size_t>(rows) * static_cast<size_t>(cols) * sizeof(Complex);
+    ensure_buffers(total, total);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_in_.get(), input.data(), total, cudaMemcpyHostToDevice, ctx_->stream()));
+
+    cufftHandle plan = get_plan_2d(rows, cols, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(internal::cufftExecC2C_dispatch(plan, static_cast<Complex*>(d_in_.get()),
+                                                      static_cast<Complex*>(d_out_.get()), CUFFT_FORWARD));
+
+    ComplexMatrix result(rows, cols);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(result.data(), d_out_.get(), total, cudaMemcpyDeviceToHost, ctx_->stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+    return result;
+  }
+
+  /** Inverse 2D C2C FFT. Scaled by 1/(rows*cols). */
+  template <typename Derived>
+  ComplexMatrix inv2(const MatrixBase<Derived>& A) {
+    static_assert(NumTraits<typename Derived::Scalar>::IsComplex, "inv2() requires complex input");
+    const ComplexMatrix input(A.derived());
+    const int rows = static_cast<int>(input.rows());
+    const int cols = static_cast<int>(input.cols());
+    if (rows == 0 || cols == 0) return ComplexMatrix(rows, cols);
+
+    const size_t total = static_cast<size_t>(rows) * static_cast<size_t>(cols) * sizeof(Complex);
+    ensure_buffers(total, total);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_in_.get(), input.data(), total, cudaMemcpyHostToDevice, ctx_->stream()));
+
+    cufftHandle plan = get_plan_2d(rows, cols, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(internal::cufftExecC2C_dispatch(plan, static_cast<Complex*>(d_in_.get()),
+                                                      static_cast<Complex*>(d_out_.get()), CUFFT_INVERSE));
+
+    // Scale by 1/(rows*cols).
+    const int total_elems = rows * cols;
+    EIGEN_CUBLAS_CHECK(internal::cublasXscal(ctx_->cublasHandle(), total_elems, Scalar(1) / Scalar(total_elems),
+                                             static_cast<Complex*>(d_out_.get()), 1));
+
+    ComplexMatrix result(rows, cols);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(result.data(), d_out_.get(), total, cudaMemcpyDeviceToHost, ctx_->stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+    return result;
+  }
+
+  // DeviceMatrix in / DeviceMatrix out: no host transfer and no host
+  // synchronization. Cross-stream safety follows the DeviceMatrix event
+  // protocol (waitReady before reading, recordReady after enqueuing). 1D
+  // overloads expect column vectors.
+
+  /** Forward 1D C2C FFT, device-resident: d_X = fft(d_x). */
+  void fwd(const DeviceMatrix<Complex>& d_x, DeviceMatrix<Complex>& d_X) {
+    eigen_assert(d_x.cols() <= 1 && "device fwd(): expected a column vector");
+    const int n = internal::to_blas_int(d_x.rows());
+    prepare_out(d_x, d_X, n, 1);
+    if (n == 0) return;
+    cufftHandle plan = get_plan_1d(n, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(
+        internal::cufftExecC2C_dispatch(plan, const_cast<Complex*>(d_x.data()), d_X.data(), CUFFT_FORWARD));
+    d_X.recordReady(ctx_->stream());
+  }
+
+  /** Inverse 1D C2C FFT, device-resident. Scaled by 1/n. */
+  void inv(const DeviceMatrix<Complex>& d_X, DeviceMatrix<Complex>& d_x) {
+    eigen_assert(d_X.cols() <= 1 && "device inv(): expected a column vector");
+    const int n = internal::to_blas_int(d_X.rows());
+    prepare_out(d_X, d_x, n, 1);
+    if (n == 0) return;
+    cufftHandle plan = get_plan_1d(n, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(
+        internal::cufftExecC2C_dispatch(plan, const_cast<Complex*>(d_X.data()), d_x.data(), CUFFT_INVERSE));
+    EIGEN_CUBLAS_CHECK(internal::cublasXscal(ctx_->cublasHandle(), n, Scalar(1) / Scalar(n), d_x.data(), 1));
+    d_x.recordReady(ctx_->stream());
+  }
+
+  /** Forward 1D R2C FFT, device-resident. Output is n/2+1 complex values. */
+  void fwd(const DeviceMatrix<Scalar>& d_x, DeviceMatrix<Complex>& d_X) {
+    eigen_assert(d_x.cols() <= 1 && "device fwd(): expected a column vector");
+    const int n = internal::to_blas_int(d_x.rows());
+    const int n_complex = n / 2 + 1;
+    prepare_out(d_x, d_X, n == 0 ? 0 : n_complex, 1);
+    if (n == 0) return;
+    cufftHandle plan = get_plan_1d(n, internal::cufft_r2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(internal::cufftExecR2C_dispatch(plan, const_cast<Scalar*>(d_x.data()), d_X.data()));
+    d_X.recordReady(ctx_->stream());
+  }
+
+  /** Inverse 1D C2R FFT, device-resident. Input is nfft/2+1 complex values,
+   * output nfft real values, scaled by 1/nfft. The input is preserved (cuFFT
+   * C2R may overwrite its input, so it is staged through internal scratch). */
+  void invReal(const DeviceMatrix<Complex>& d_X, DeviceMatrix<Scalar>& d_x, Index nfft) {
+    eigen_assert(d_X.cols() <= 1 && "device invReal(): expected a column vector");
+    const int n = internal::to_blas_int(nfft);
+    const int n_complex = n / 2 + 1;
+    eigen_assert(n == 0 || d_X.rows() == n_complex);
+    prepare_out(d_X, d_x, n, 1);
+    if (n == 0) return;
+    // Stage through d_in_: cuFFT C2R may overwrite the input array.
+    ensure_buffers(static_cast<size_t>(n_complex) * sizeof(Complex), 0);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_in_.get(), d_X.data(), n_complex * sizeof(Complex),
+                                             cudaMemcpyDeviceToDevice, ctx_->stream()));
+    cufftHandle plan = get_plan_1d(n, internal::cufft_c2r_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(internal::cufftExecC2R_dispatch(plan, static_cast<Complex*>(d_in_.get()), d_x.data()));
+    EIGEN_CUBLAS_CHECK(internal::cublasXscal(ctx_->cublasHandle(), n, Scalar(1) / Scalar(n), d_x.data(), 1));
+    d_x.recordReady(ctx_->stream());
+  }
+
+  /** Forward 2D C2C FFT, device-resident. */
+  void fwd2(const DeviceMatrix<Complex>& d_A, DeviceMatrix<Complex>& d_B) {
+    const int rows = internal::to_blas_int(d_A.rows());
+    const int cols = internal::to_blas_int(d_A.cols());
+    prepare_out(d_A, d_B, rows, cols);
+    if (rows == 0 || cols == 0) return;
+    cufftHandle plan = get_plan_2d(rows, cols, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(
+        internal::cufftExecC2C_dispatch(plan, const_cast<Complex*>(d_A.data()), d_B.data(), CUFFT_FORWARD));
+    d_B.recordReady(ctx_->stream());
+  }
+
+  /** Inverse 2D C2C FFT, device-resident. Scaled by 1/(rows*cols). */
+  void inv2(const DeviceMatrix<Complex>& d_A, DeviceMatrix<Complex>& d_B) {
+    const int rows = internal::to_blas_int(d_A.rows());
+    const int cols = internal::to_blas_int(d_A.cols());
+    prepare_out(d_A, d_B, rows, cols);
+    if (rows == 0 || cols == 0) return;
+    cufftHandle plan = get_plan_2d(rows, cols, internal::cufft_c2c_type<Scalar>::value);
+    EIGEN_CUFFT_CHECK(
+        internal::cufftExecC2C_dispatch(plan, const_cast<Complex*>(d_A.data()), d_B.data(), CUFFT_INVERSE));
+    const int total_elems = internal::to_blas_int(static_cast<int64_t>(rows) * static_cast<int64_t>(cols));
+    EIGEN_CUBLAS_CHECK(
+        internal::cublasXscal(ctx_->cublasHandle(), total_elems, Scalar(1) / Scalar(total_elems), d_B.data(), 1));
+    d_B.recordReady(ctx_->stream());
+  }
+
+  /** The CUDA stream borrowed from the bound Context. */
+  cudaStream_t stream() const { return ctx_->stream(); }
+
+  /** The Context this FFT is bound to. */
+  Context& context() const { return *ctx_; }
+
+ private:
+  Context* ctx_;
+  Eigen::internal::LruCache<int64_t, internal::CufftPlan> plans_;
+  internal::DeviceBuffer d_in_;
+  internal::DeviceBuffer d_out_;
+  size_t d_in_size_ = 0;
+  size_t d_out_size_ = 0;
+
+  // Common device-transform prologue: alias check, input/output event waits,
+  // and (destructive) output resize.
+  template <typename InScalar, typename OutScalar>
+  void prepare_out(const DeviceMatrix<InScalar>& in, DeviceMatrix<OutScalar>& out, Index out_rows, Index out_cols) {
+    eigen_assert(
+        (in.data() == nullptr || static_cast<const void*>(in.data()) != static_cast<const void*>(out.data())) &&
+        "device FFT: output must not alias input");
+    in.waitReady(ctx_->stream());
+    if (!out.empty()) out.waitReady(ctx_->stream());
+    out.resize(out_rows, out_cols);
+  }
+
+  // Buffers grow but never shrink. The pre-realloc sync drains the *bound*
+  // Context's stream — including unrelated GEMMs/solves/`device(ctx) = ...`
+  // assignments queued on it — so callers running FFTs alongside other GPU
+  // work on the same Context should size up front (call fwd/inv with the
+  // largest expected n once) to avoid mid-pipeline stalls.
+  void ensure_buffers(size_t in_bytes, size_t out_bytes) {
+    if (in_bytes > d_in_size_) {
+      if (d_in_) EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+      d_in_ = internal::DeviceBuffer(in_bytes);
+      d_in_size_ = in_bytes;
+    }
+    if (out_bytes > d_out_size_) {
+      if (d_out_) EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(ctx_->stream()));
+      d_out_ = internal::DeviceBuffer(out_bytes);
+      d_out_size_ = out_bytes;
+    }
+  }
+
+  // Plan key encoding: rank (1 bit) | type (4 bits) | dims.
+  // cufftType uses 7 bits; the top 3 (precision discriminator) are redundant
+  // since Scalar fixes precision per FFT instance, so mask to 4 bits — without
+  // it, e.g. plan_key_1d(5, C2C) and plan_key_1d(7, C2C) collide.
+  static constexpr int64_t kTypeMask = 0xF;
+  static constexpr int kCols2DBits = 30;  // bits 5..34
+  static constexpr int kRows2DBits = 29;  // bits 35..63
+  static int64_t plan_key_1d(int n, cufftType type) { return (int64_t(n) << 5) | (int64_t(type & kTypeMask) << 1) | 0; }
+
+  static int64_t plan_key_2d(int rows, int cols, cufftType type) {
+    eigen_assert(rows >= 0 && int64_t(rows) < (int64_t(1) << kRows2DBits) &&
+                 "FFT plan rows exceed plan-key bit budget");
+    eigen_assert(cols >= 0 && int64_t(cols) < (int64_t(1) << kCols2DBits) &&
+                 "FFT plan cols exceed plan-key bit budget");
+    return (int64_t(rows) << 35) | (int64_t(cols) << 5) | (int64_t(type & kTypeMask) << 1) | 1;
+  }
+
+  cufftHandle get_plan_1d(int n, cufftType type) {
+    const int64_t key = plan_key_1d(n, type);
+    if (internal::CufftPlan* hit = plans_.find(key)) return hit->get();
+
+    cufftHandle plan;
+    EIGEN_CUFFT_CHECK(cufftPlan1d(&plan, n, type, /*batch=*/1));
+    EIGEN_CUFFT_CHECK(cufftSetStream(plan, ctx_->stream()));
+    return plans_.insert(key, internal::CufftPlan(plan))->get();
+  }
+
+  cufftHandle get_plan_2d(int rows, int cols, cufftType type) {
+    const int64_t key = plan_key_2d(rows, cols, type);
+    if (internal::CufftPlan* hit = plans_.find(key)) return hit->get();
+
+    // cuFFT uses row-major (C order) for 2D: first dim = rows, second = cols.
+    // Eigen matrices are column-major, so we pass (cols, rows) to cuFFT
+    // to get the correct 2D transform.
+    cufftHandle plan;
+    EIGEN_CUFFT_CHECK(cufftPlan2d(&plan, cols, rows, type));
+    EIGEN_CUFFT_CHECK(cufftSetStream(plan, ctx_->stream()));
+    return plans_.insert(key, internal::CufftPlan(plan))->get();
+  }
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_FFT_H
diff --git a/contrib/Eigen/src/GPU/GpuLLT.h b/contrib/Eigen/src/GPU/GpuLLT.h
new file mode 100644
index 0000000..f72eab6
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuLLT.h
@@ -0,0 +1,275 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU Cholesky (LLT) decomposition using cuSOLVER. Requires CUDA 11.4+ for the
+// cusolverDnX generic API.
+
+#ifndef EIGEN_GPU_LLT_H
+#define EIGEN_GPU_LLT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSolverContext.h"
+
+namespace Eigen {
+namespace gpu {
+/** \ingroup GPU_Module
+ * \class LLT
+ * \brief GPU Cholesky (LL^T) decomposition via cuSOLVER
+ *
+ * \tparam Scalar_  Element type: float, double, complex<float>, complex<double>
+ * \tparam UpLo_    Triangle used: Lower (default) or Upper
+ *
+ * Factorizes a symmetric positive-definite matrix A = LL^H on the GPU and
+ * caches the factor L in device memory. Each subsequent solve(B) uploads only
+ * B, calls cusolverDnXpotrs, and downloads the result — the factor is not
+ * re-transferred.
+ *
+ * Each LLT object owns a dedicated CUDA stream and cuSOLVER handle,
+ * enabling concurrent factorizations from multiple objects on the same host
+ * thread.
+ */
+template <typename Scalar_, int UpLo_ = Lower>
+class LLT {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  static constexpr int UpLo = UpLo_;
+
+  /** Default constructor. Does not factorize; call compute() before solve(). */
+  LLT() = default;
+
+  /** Bind to \p ctx: run on its stream with its cuSOLVER/cuBLAS handles, so
+   * solver work chains with other work on the same Context without
+   * cross-stream event waits. \p ctx must outlive this object. */
+  explicit LLT(Context& ctx) : solver_ctx_(ctx) {}
+
+  /** Factor A immediately. Equivalent to LLT llt; llt.compute(A). */
+  template <typename InputType>
+  explicit LLT(const DenseBase<InputType>& A) {
+    compute(A);
+  }
+
+  /** Factor a device-resident A immediately (D2D copy). */
+  explicit LLT(const DeviceMatrix<Scalar>& d_A) { compute(d_A); }
+
+  /** Factor a device-resident A immediately (adopt, no copy). */
+  explicit LLT(DeviceMatrix<Scalar>&& d_A) { compute(std::move(d_A)); }
+
+  /** Bind to \p ctx and factor A immediately. */
+  template <typename InputType>
+  LLT(Context& ctx, const DenseBase<InputType>& A) : solver_ctx_(ctx) {
+    compute(A);
+  }
+
+  /** Bind to \p ctx and factor a device-resident A (D2D copy). */
+  LLT(Context& ctx, const DeviceMatrix<Scalar>& d_A) : solver_ctx_(ctx) { compute(d_A); }
+
+  ~LLT() = default;
+
+  // Non-copyable (owns device memory and library handles).
+  LLT(const LLT&) = delete;
+  LLT& operator=(const LLT&) = delete;
+
+  // Movable.
+  LLT(LLT&& o) noexcept
+      : solver_ctx_(std::move(o.solver_ctx_)), d_factor_(std::move(o.d_factor_)), n_(o.n_), lda_(o.lda_) {
+    o.n_ = 0;
+    o.lda_ = 0;
+  }
+
+  LLT& operator=(LLT&& o) noexcept {
+    if (this != &o) {
+      solver_ctx_ = std::move(o.solver_ctx_);
+      d_factor_ = std::move(o.d_factor_);
+      n_ = o.n_;
+      lda_ = o.lda_;
+      o.n_ = 0;
+      o.lda_ = 0;
+    }
+    return *this;
+  }
+
+  /** Compute the Cholesky factorization of A (host matrix). The upload is
+   * complete on return; factorization remains asynchronous. */
+  template <typename InputType>
+  LLT& compute(const DenseBase<InputType>& A) {
+    eigen_assert(A.rows() == A.cols());
+    if (!begin_compute(A.rows())) return *this;
+
+    // Ref binds column-major direct-access input in place (no host copy);
+    // row-major layouts and expressions evaluate into its temporary.
+    const Ref<const PlainMatrix> mat(A.derived());
+    lda_ = static_cast<int64_t>(mat.rows());
+    allocate_factor_storage();
+    internal::upload_host_matrix(static_cast<Scalar*>(d_factor_.get()), mat.rows(), mat.data(), mat.outerStride(),
+                                 mat.rows(), mat.cols(), solver_ctx_.stream());
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+
+    factorize();
+    return *this;
+  }
+
+  /** Compute the Cholesky factorization from a device-resident matrix (D2D copy). */
+  LLT& compute(const DeviceMatrix<Scalar>& d_A) {
+    eigen_assert(d_A.rows() == d_A.cols());
+    if (!begin_compute(d_A.rows())) return *this;
+
+    lda_ = static_cast<int64_t>(d_A.rows());
+    d_A.waitReady(solver_ctx_.stream());
+    allocate_factor_storage();
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_factor_.get(), d_A.data(), factorBytes(), cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+
+    factorize();
+    return *this;
+  }
+
+  /** Compute the Cholesky factorization from a device matrix (move, no copy). */
+  LLT& compute(DeviceMatrix<Scalar>&& d_A) {
+    eigen_assert(d_A.rows() == d_A.cols());
+    if (!begin_compute(d_A.rows())) return *this;
+
+    lda_ = static_cast<int64_t>(d_A.rows());
+    d_A.waitReady(solver_ctx_.stream());
+    d_factor_ = internal::DeviceBuffer::adopt(static_cast<void*>(d_A.release()), factorBytes());
+
+    factorize();
+    return *this;
+  }
+
+  /** Solve A * X = B using the cached Cholesky factor (host → host). */
+  template <typename Rhs>
+  PlainMatrix solve(const MatrixBase<Rhs>& B) const {
+    // Debug builds verify the factorization (info() synchronizes the stream on
+    // the first call after compute()); release builds skip both the check and
+    // the sync — use info() explicitly when failure must be detected.
+    eigen_assert(solver_ctx_.info() == Success && "LLT::solve called on a failed or uninitialized factorization");
+    eigen_assert(B.rows() == n_);
+
+    const Ref<const PlainMatrix> rhs(B.derived());
+    const int64_t nrhs = static_cast<int64_t>(rhs.cols());
+    const int64_t ldb = static_cast<int64_t>(rhs.rows());
+    internal::DeviceBuffer d_x(rhsBytes(nrhs, ldb));
+    internal::upload_host_matrix(static_cast<Scalar*>(d_x.get()), ldb, rhs.data(), rhs.outerStride(), rhs.rows(),
+                                 rhs.cols(), solver_ctx_.stream());
+    DeviceMatrix<Scalar> d_X = solve_impl(nrhs, ldb, std::move(d_x));
+
+    PlainMatrix X(n_, B.cols());
+    int solve_info = 0;
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(X.data(), d_X.data(), rhsBytes(nrhs, ldb), cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(&solve_info, solver_ctx_.scratch_info(), sizeof(int),
+                                             cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+
+    eigen_assert(solve_info == 0 && "cusolverDnXpotrs reported an error");
+    return X;
+  }
+
+  /** Solve A * X = B with device-resident RHS. Fully asynchronous: returns
+   * immediately after enqueuing the solve. Debug builds verify the
+   * factorization status first (one host sync on the first solve after
+   * compute()); release builds do not — use info() when failure must be
+   * detected. */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B) const {
+    eigen_assert(solver_ctx_.info() == Success && "LLT::solve called on a failed or uninitialized factorization");
+    eigen_assert(d_B.rows() == n_);
+    d_B.waitReady(solver_ctx_.stream());
+    const int64_t nrhs = static_cast<int64_t>(d_B.cols());
+    const int64_t ldb = static_cast<int64_t>(d_B.rows());
+    internal::DeviceBuffer d_x(rhsBytes(nrhs, ldb));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_x.get(), d_B.data(), rhsBytes(nrhs, ldb), cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+    return solve_impl(nrhs, ldb, std::move(d_x));
+  }
+
+  /** Solve in place: consumes \p d_B and returns it holding the solution —
+   * no RHS copy and no allocation (potrs overwrites its RHS). */
+  DeviceMatrix<Scalar> solve(DeviceMatrix<Scalar>&& d_B) const {
+    eigen_assert(solver_ctx_.info() == Success && "LLT::solve called on a failed or uninitialized factorization");
+    eigen_assert(d_B.rows() == n_);
+    d_B.waitReady(solver_ctx_.stream());
+    const int64_t nrhs = static_cast<int64_t>(d_B.cols());
+    const int64_t ldb = static_cast<int64_t>(d_B.rows());
+    internal::DeviceBuffer d_x = internal::DeviceBuffer::adopt(static_cast<void*>(d_B.release()), rhsBytes(nrhs, ldb));
+    return solve_impl(nrhs, ldb, std::move(d_x));
+  }
+
+  ComputationInfo info() const { return solver_ctx_.info(); }
+  Index rows() const { return n_; }
+  Index cols() const { return n_; }
+  cudaStream_t stream() const { return solver_ctx_.stream(); }
+
+ private:
+  mutable internal::GpuSolverContext solver_ctx_;
+  internal::DeviceBuffer d_factor_;  // grow-only
+  int64_t n_ = 0;
+  int64_t lda_ = 0;
+
+  bool begin_compute(Index rows) {
+    n_ = rows;
+    return solver_ctx_.begin_compute(n_ != 0);
+  }
+
+  size_t factorBytes() const { return rhsBytes(n_, lda_); }
+
+  static size_t rhsBytes(int64_t cols, int64_t ld) {
+    return static_cast<size_t>(ld) * static_cast<size_t>(cols) * sizeof(Scalar);
+  }
+
+  void allocate_factor_storage() { internal::ensure_sized(d_factor_, factorBytes()); }
+
+  // Solve in place on `d_x` (which already holds B), then re-wrap as a typed
+  // DeviceMatrix carrying shape and a ready event. The release/adopt hop hands
+  // ownership of the raw cudaMalloc pointer from the untyped DeviceBuffer to
+  // the typed DeviceMatrix without copying.
+  DeviceMatrix<Scalar> solve_impl(int64_t nrhs, int64_t ldb, internal::DeviceBuffer&& d_x) const {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+    constexpr cublasFillMode_t uplo = internal::cusolver_fill_mode<UpLo_>::value;
+
+    EIGEN_CUSOLVER_CHECK(cusolverDnXpotrs(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, uplo, n_, nrhs, dtype,
+                                          d_factor_.get(), lda_, dtype, d_x.get(), ldb, solver_ctx_.scratch_info()));
+
+    DeviceMatrix<Scalar> result =
+        DeviceMatrix<Scalar>::adopt(static_cast<Scalar*>(d_x.release()), n_, static_cast<Index>(nrhs));
+    result.recordReady(solver_ctx_.stream());
+    return result;
+  }
+
+  void factorize() {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+    constexpr cublasFillMode_t uplo = internal::cusolver_fill_mode<UpLo_>::value;
+
+    solver_ctx_.mark_pending();
+
+    size_t dev_ws_bytes = 0, host_ws_bytes = 0;
+    EIGEN_CUSOLVER_CHECK(cusolverDnXpotrf_bufferSize(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, uplo, n_,
+                                                     dtype, d_factor_.get(), lda_, dtype, &dev_ws_bytes,
+                                                     &host_ws_bytes));
+
+    solver_ctx_.ensure_scratch(dev_ws_bytes);
+    solver_ctx_.h_workspace_.resize(host_ws_bytes);
+
+    EIGEN_CUSOLVER_CHECK(cusolverDnXpotrf(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, uplo, n_, dtype,
+                                          d_factor_.get(), lda_, dtype, solver_ctx_.scratch_workspace(), dev_ws_bytes,
+                                          host_ws_bytes > 0 ? solver_ctx_.h_workspace_.data() : nullptr, host_ws_bytes,
+                                          solver_ctx_.scratch_info()));
+
+    solver_ctx_.enqueue_info_copy();
+  }
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_LLT_H
diff --git a/contrib/Eigen/src/GPU/GpuLU.h b/contrib/Eigen/src/GPU/GpuLU.h
new file mode 100644
index 0000000..93dd98a
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuLU.h
@@ -0,0 +1,278 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU partial-pivoting LU decomposition using cuSOLVER, wrapping
+// cusolverDnXgetrf and cusolverDnXgetrs.
+
+#ifndef EIGEN_GPU_LU_H
+#define EIGEN_GPU_LU_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSolverContext.h"
+
+namespace Eigen {
+namespace gpu {
+/** \ingroup GPU_Module
+ * \class LU
+ * \brief GPU LU decomposition with partial pivoting via cuSOLVER
+ *
+ * \tparam Scalar_  Element type: float, double, complex<float>, complex<double>
+ *
+ * Decomposes a square matrix A = P L U on the GPU and retains the factored
+ * matrix and pivot array in device memory. Solves A*X=B, A^T*X=B, or
+ * A^H*X=B by passing the appropriate gpu::GpuOp.
+ *
+ * Each LU object owns a dedicated CUDA stream and cuSOLVER handle.
+ */
+template <typename Scalar_>
+class LU {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  LU() = default;
+
+  /** Bind to \p ctx: run on its stream with its cuSOLVER/cuBLAS handles, so
+   * solver work chains with other work on the same Context without
+   * cross-stream event waits. \p ctx must outlive this object. */
+  explicit LU(Context& ctx) : solver_ctx_(ctx) {}
+
+  template <typename InputType>
+  explicit LU(const DenseBase<InputType>& A) {
+    compute(A);
+  }
+
+  /** Factor a device-resident A immediately (D2D copy). */
+  explicit LU(const DeviceMatrix<Scalar>& d_A) { compute(d_A); }
+
+  /** Factor a device-resident A immediately (adopt, no copy). */
+  explicit LU(DeviceMatrix<Scalar>&& d_A) { compute(std::move(d_A)); }
+
+  /** Bind to \p ctx and factor A immediately. */
+  template <typename InputType>
+  LU(Context& ctx, const DenseBase<InputType>& A) : solver_ctx_(ctx) {
+    compute(A);
+  }
+
+  /** Bind to \p ctx and factor a device-resident A (D2D copy). */
+  LU(Context& ctx, const DeviceMatrix<Scalar>& d_A) : solver_ctx_(ctx) { compute(d_A); }
+
+  ~LU() = default;
+
+  LU(const LU&) = delete;
+  LU& operator=(const LU&) = delete;
+
+  LU(LU&& o) noexcept
+      : solver_ctx_(std::move(o.solver_ctx_)),
+        d_lu_(std::move(o.d_lu_)),
+        d_ipiv_(std::move(o.d_ipiv_)),
+        n_(o.n_),
+        lda_(o.lda_) {
+    o.n_ = 0;
+    o.lda_ = 0;
+  }
+
+  LU& operator=(LU&& o) noexcept {
+    if (this != &o) {
+      solver_ctx_ = std::move(o.solver_ctx_);
+      d_lu_ = std::move(o.d_lu_);
+      d_ipiv_ = std::move(o.d_ipiv_);
+      n_ = o.n_;
+      lda_ = o.lda_;
+      o.n_ = 0;
+      o.lda_ = 0;
+    }
+    return *this;
+  }
+
+  /** Compute the LU factorization of A (host matrix, must be square). The
+   * upload is complete on return; factorization remains asynchronous. */
+  template <typename InputType>
+  LU& compute(const DenseBase<InputType>& A) {
+    eigen_assert(A.rows() == A.cols() && "LU requires a square matrix");
+    if (!begin_compute(A.rows())) return *this;
+
+    // Ref binds column-major direct-access input in place (no host copy);
+    // row-major layouts and expressions evaluate into its temporary.
+    const Ref<const PlainMatrix> mat(A.derived());
+    lda_ = static_cast<int64_t>(mat.rows());
+    allocate_lu_storage();
+    internal::upload_host_matrix(static_cast<Scalar*>(d_lu_.get()), mat.rows(), mat.data(), mat.outerStride(),
+                                 mat.rows(), mat.cols(), solver_ctx_.stream());
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+
+    factorize();
+    return *this;
+  }
+
+  /** Compute the LU factorization from a device-resident matrix (D2D copy). */
+  LU& compute(const DeviceMatrix<Scalar>& d_A) {
+    eigen_assert(d_A.rows() == d_A.cols() && "LU requires a square matrix");
+    if (!begin_compute(d_A.rows())) return *this;
+
+    lda_ = static_cast<int64_t>(d_A.rows());
+    d_A.waitReady(solver_ctx_.stream());
+    allocate_lu_storage();
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_lu_.get(), d_A.data(), matrixBytes(), cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+
+    factorize();
+    return *this;
+  }
+
+  /** Compute the LU factorization from a device matrix (move, no copy). */
+  LU& compute(DeviceMatrix<Scalar>&& d_A) {
+    eigen_assert(d_A.rows() == d_A.cols() && "LU requires a square matrix");
+    if (!begin_compute(d_A.rows())) return *this;
+
+    lda_ = static_cast<int64_t>(d_A.rows());
+    d_A.waitReady(solver_ctx_.stream());
+    d_lu_ = internal::DeviceBuffer::adopt(static_cast<void*>(d_A.release()), matrixBytes());
+
+    factorize();
+    return *this;
+  }
+
+  /** Solve op(A) * X = B using the cached LU factorization (host → host).
+   *
+   * \param B  Right-hand side (n x nrhs host matrix).
+   * \param op gpu::GpuOp::NoTrans (default), Trans, or ConjTrans.
+   */
+  template <typename Rhs>
+  PlainMatrix solve(const MatrixBase<Rhs>& B, GpuOp op = GpuOp::NoTrans) const {
+    // Debug builds verify the factorization (info() synchronizes the stream on
+    // the first call after compute()); release builds skip both the check and
+    // the sync — use info() explicitly when failure must be detected.
+    eigen_assert(solver_ctx_.info() == Success && "LU::solve called on a failed or uninitialized factorization");
+    eigen_assert(B.rows() == n_);
+
+    const Ref<const PlainMatrix> rhs(B.derived());
+    const int64_t nrhs = static_cast<int64_t>(rhs.cols());
+    const int64_t ldb = static_cast<int64_t>(rhs.rows());
+    internal::DeviceBuffer d_x(matrixBytes(nrhs, ldb));
+    internal::upload_host_matrix(static_cast<Scalar*>(d_x.get()), ldb, rhs.data(), rhs.outerStride(), rhs.rows(),
+                                 rhs.cols(), solver_ctx_.stream());
+    DeviceMatrix<Scalar> d_X = solve_impl(nrhs, ldb, op, std::move(d_x));
+
+    PlainMatrix X(n_, B.cols());
+    int solve_info = 0;
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(X.data(), d_X.data(), matrixBytes(nrhs, ldb), cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(&solve_info, solver_ctx_.scratch_info(), sizeof(int),
+                                             cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+
+    eigen_assert(solve_info == 0 && "cusolverDnXgetrs reported an error");
+    return X;
+  }
+
+  /** Solve op(A) * X = B with device-resident RHS. Fully asynchronous: returns
+   * immediately after enqueuing the solve. Debug builds verify the
+   * factorization status first (one host sync on the first solve after
+   * compute()); release builds do not — use info() when failure must be
+   * detected. */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B, GpuOp op = GpuOp::NoTrans) const {
+    eigen_assert(solver_ctx_.info() == Success && "LU::solve called on a failed or uninitialized factorization");
+    eigen_assert(d_B.rows() == n_);
+    d_B.waitReady(solver_ctx_.stream());
+    const int64_t nrhs = static_cast<int64_t>(d_B.cols());
+    const int64_t ldb = static_cast<int64_t>(d_B.rows());
+    internal::DeviceBuffer d_x(matrixBytes(nrhs, ldb));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_x.get(), d_B.data(), matrixBytes(nrhs, ldb), cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+    return solve_impl(nrhs, ldb, op, std::move(d_x));
+  }
+
+  /** Solve in place: consumes \p d_B and returns it holding the solution —
+   * no RHS copy and no allocation (getrs overwrites its RHS). */
+  DeviceMatrix<Scalar> solve(DeviceMatrix<Scalar>&& d_B, GpuOp op = GpuOp::NoTrans) const {
+    eigen_assert(solver_ctx_.info() == Success && "LU::solve called on a failed or uninitialized factorization");
+    eigen_assert(d_B.rows() == n_);
+    d_B.waitReady(solver_ctx_.stream());
+    const int64_t nrhs = static_cast<int64_t>(d_B.cols());
+    const int64_t ldb = static_cast<int64_t>(d_B.rows());
+    internal::DeviceBuffer d_x =
+        internal::DeviceBuffer::adopt(static_cast<void*>(d_B.release()), matrixBytes(nrhs, ldb));
+    return solve_impl(nrhs, ldb, op, std::move(d_x));
+  }
+
+  ComputationInfo info() const { return solver_ctx_.info(); }
+  Index rows() const { return n_; }
+  Index cols() const { return n_; }
+  cudaStream_t stream() const { return solver_ctx_.stream(); }
+
+ private:
+  mutable internal::GpuSolverContext solver_ctx_;
+  internal::DeviceBuffer d_lu_;    // grow-only
+  internal::DeviceBuffer d_ipiv_;  // grow-only
+  int64_t n_ = 0;
+  int64_t lda_ = 0;
+
+  bool begin_compute(Index rows) {
+    n_ = rows;
+    return solver_ctx_.begin_compute(n_ != 0);
+  }
+
+  size_t matrixBytes() const { return matrixBytes(n_, lda_); }
+
+  static size_t matrixBytes(int64_t cols, int64_t ld) {
+    return static_cast<size_t>(ld) * static_cast<size_t>(cols) * sizeof(Scalar);
+  }
+
+  void allocate_lu_storage() { internal::ensure_sized(d_lu_, matrixBytes()); }
+
+  // Solve in place on `d_x` (which already holds B), then re-wrap as a typed
+  // DeviceMatrix carrying shape and a ready event. The release/adopt hop hands
+  // ownership of the raw cudaMalloc pointer from the untyped DeviceBuffer to
+  // the typed DeviceMatrix without copying.
+  DeviceMatrix<Scalar> solve_impl(int64_t nrhs, int64_t ldb, GpuOp op, internal::DeviceBuffer&& d_x) const {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+    const cublasOperation_t trans = internal::to_cublas_op(op);
+
+    EIGEN_CUSOLVER_CHECK(cusolverDnXgetrs(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, trans, n_, nrhs, dtype,
+                                          d_lu_.get(), lda_, static_cast<const int64_t*>(d_ipiv_.get()), dtype,
+                                          d_x.get(), ldb, solver_ctx_.scratch_info()));
+
+    DeviceMatrix<Scalar> result =
+        DeviceMatrix<Scalar>::adopt(static_cast<Scalar*>(d_x.release()), n_, static_cast<Index>(nrhs));
+    result.recordReady(solver_ctx_.stream());
+    return result;
+  }
+
+  void factorize() {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+    const size_t ipiv_bytes = static_cast<size_t>(n_) * sizeof(int64_t);
+
+    solver_ctx_.mark_pending();
+
+    internal::ensure_sized(d_ipiv_, ipiv_bytes);
+
+    size_t dev_ws_bytes = 0, host_ws_bytes = 0;
+    EIGEN_CUSOLVER_CHECK(cusolverDnXgetrf_bufferSize(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, n_, n_, dtype,
+                                                     d_lu_.get(), lda_, dtype, &dev_ws_bytes, &host_ws_bytes));
+
+    solver_ctx_.ensure_scratch(dev_ws_bytes);
+    solver_ctx_.h_workspace_.resize(host_ws_bytes);
+
+    EIGEN_CUSOLVER_CHECK(cusolverDnXgetrf(
+        solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, n_, n_, dtype, d_lu_.get(), lda_,
+        static_cast<int64_t*>(d_ipiv_.get()), dtype, solver_ctx_.scratch_workspace(), dev_ws_bytes,
+        host_ws_bytes > 0 ? solver_ctx_.h_workspace_.data() : nullptr, host_ws_bytes, solver_ctx_.scratch_info()));
+
+    solver_ctx_.enqueue_info_copy();
+  }
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_LU_H
diff --git a/contrib/Eigen/src/GPU/GpuQR.h b/contrib/Eigen/src/GPU/GpuQR.h
new file mode 100644
index 0000000..c22a9cb
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuQR.h
@@ -0,0 +1,401 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU QR decomposition using cuSOLVER, wrapping cusolverDnXgeqrf, cusolverDnXormqr
+// (apply Q), and cublasXtrsm (triangular solve on R). Q is never formed
+// explicitly.
+//
+// Both shapes are handled transparently: for m >= n the factorization is
+// A = Q R and solve() is least-squares; for m < n it is A^H = Q R internally and
+// solve() is minimum-norm.
+
+#ifndef EIGEN_GPU_QR_H
+#define EIGEN_GPU_QR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSolverContext.h"
+
+namespace Eigen {
+namespace gpu {
+template <typename Scalar_>
+class QR {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  QR() = default;
+
+  /** Bind to \p ctx: run on its stream with its cuSOLVER/cuBLAS handles, so
+   * solver work chains with other work on the same Context without
+   * cross-stream event waits. \p ctx must outlive this object. */
+  explicit QR(Context& ctx) : solver_ctx_(ctx) {}
+
+  template <typename InputType>
+  explicit QR(const DenseBase<InputType>& A) {
+    compute(A);
+  }
+
+  explicit QR(const DeviceMatrix<Scalar>& d_A) { compute(d_A); }
+
+  /** Factor a device-resident A immediately (adopt when m >= n, no copy). */
+  explicit QR(DeviceMatrix<Scalar>&& d_A) { compute(std::move(d_A)); }
+
+  /** Bind to \p ctx and factor A immediately. */
+  template <typename InputType>
+  QR(Context& ctx, const DenseBase<InputType>& A) : solver_ctx_(ctx) {
+    compute(A);
+  }
+
+  /** Bind to \p ctx and factor a device-resident A (D2D copy). */
+  QR(Context& ctx, const DeviceMatrix<Scalar>& d_A) : solver_ctx_(ctx) { compute(d_A); }
+
+  ~QR() = default;
+
+  QR(const QR&) = delete;
+  QR& operator=(const QR&) = delete;
+
+  QR(QR&& o) noexcept
+      : solver_ctx_(std::move(o.solver_ctx_)),
+        d_qr_(std::move(o.d_qr_)),
+        d_tau_(std::move(o.d_tau_)),
+        m_(o.m_),
+        n_(o.n_),
+        lda_(o.lda_),
+        transposed_(o.transposed_) {
+    o.m_ = 0;
+    o.n_ = 0;
+    o.lda_ = 0;
+    o.transposed_ = false;
+  }
+
+  QR& operator=(QR&& o) noexcept {
+    if (this != &o) {
+      solver_ctx_ = std::move(o.solver_ctx_);
+      d_qr_ = std::move(o.d_qr_);
+      d_tau_ = std::move(o.d_tau_);
+      m_ = o.m_;
+      n_ = o.n_;
+      lda_ = o.lda_;
+      transposed_ = o.transposed_;
+      o.m_ = 0;
+      o.n_ = 0;
+      o.lda_ = 0;
+      o.transposed_ = false;
+    }
+    return *this;
+  }
+
+  template <typename InputType>
+  QR& compute(const DenseBase<InputType>& A) {
+    // Upload to device, then delegate to the adopting overload — the freshly
+    // uploaded matrix is factored in place (geqrf overwrites its input), so no
+    // second device copy is made. The wide-matrix transpose runs on the GPU
+    // (via cublasXgeam) inside the device-input path; no host transpose.
+    return compute(DeviceMatrix<Scalar>::fromHost(A.derived(), solver_ctx_.stream()));
+  }
+
+  QR& compute(const DeviceMatrix<Scalar>& d_A) {
+    if (!begin_compute(d_A)) return *this;
+
+    if (transposed_) {
+      transpose_into_factor(d_A);
+    } else {
+      const size_t mat_bytes = factorBytes();
+      allocate_factor_storage(mat_bytes);
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(d_qr_.get(), d_A.data(), mat_bytes, cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+    }
+
+    factorize();
+    return *this;
+  }
+
+  /** Factor a device matrix (move). For m >= n the buffer is adopted and
+   * factored in place — no copy; for m < n a transposed copy is unavoidable. */
+  QR& compute(DeviceMatrix<Scalar>&& d_A) {
+    if (!begin_compute(d_A)) return *this;
+
+    if (transposed_) {
+      transpose_into_factor(d_A);
+    } else {
+      d_qr_ = internal::DeviceBuffer::adopt(static_cast<void*>(d_A.release()), factorBytes());
+    }
+
+    factorize();
+    return *this;
+  }
+
+  /** Solve A * X = B.
+   * For m >= n (over-/exactly-determined): least-squares X = R^{-1} Q^H B (residual A^H r ≈ 0).
+   * For m  < n (underdetermined):          minimum-norm  X = Q R^{-H} B (||X|| minimized). */
+  template <typename Rhs>
+  PlainMatrix solve(const MatrixBase<Rhs>& B) const {
+    // Debug builds verify the factorization (info() synchronizes the stream on
+    // the first call after compute()); release builds skip both the check and
+    // the sync — use info() explicitly when failure must be detected.
+    eigen_assert(solver_ctx_.info() == Success && "QR::solve called on a failed or uninitialized factorization");
+    eigen_assert(B.rows() == m_);
+
+    const Ref<const PlainMatrix> rhs(B.derived());
+    const Index nrhs = rhs.cols();
+
+    if (!transposed_) {
+      return solve_overdetermined_host(rhs);
+    }
+    return solve_underdetermined_host(rhs, nrhs);
+  }
+
+  /** Solve with device-resident RHS. Returns n × nrhs DeviceMatrix. Fully
+   * asynchronous; debug builds verify the factorization status first. */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B) const {
+    eigen_assert(solver_ctx_.info() == Success && "QR::solve called on a failed or uninitialized factorization");
+    eigen_assert(d_B.rows() == m_);
+    d_B.waitReady(solver_ctx_.stream());
+
+    if (!transposed_) {
+      return solve_overdetermined_device(d_B);
+    }
+    return solve_underdetermined_device(d_B);
+  }
+
+  ComputationInfo info() const { return solver_ctx_.info(); }
+
+  Index rows() const { return m_; }
+  Index cols() const { return n_; }
+  cudaStream_t stream() const { return solver_ctx_.stream(); }
+
+  /** Upper-triangular factor R (k × n) of A = Q R. Available only for m >= n. */
+  PlainMatrix matrixR() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert(!transposed_ && "matrixR() not available when m < n (we factored A^H internally)");
+    PlainMatrix qr_full(m_, n_);
+    if (m_ > 0 && n_ > 0) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy(qr_full.data(), d_qr_.get(),
+                                          static_cast<size_t>(lda_) * static_cast<size_t>(n_) * sizeof(Scalar),
+                                          cudaMemcpyDeviceToHost));
+    }
+    PlainMatrix R = qr_full.topRows(k()).template triangularView<Upper>();
+    return R;
+  }
+
+ private:
+  mutable internal::GpuSolverContext solver_ctx_;
+  internal::DeviceBuffer d_qr_;   // grow-only; QR factors (reflectors below diag, R above)
+  internal::DeviceBuffer d_tau_;  // grow-only; Householder scalars (length k)
+  int64_t m_ = 0;                 // original A.rows()
+  int64_t n_ = 0;                 // original A.cols()
+  int64_t lda_ = 0;               // factor leading dim = max(m_, n_)
+  bool transposed_ = false;       // true iff m_ < n_, i.e. A^H was factored
+
+  // The factored matrix is always tall: rows >= cols.
+  int64_t factor_rows() const { return transposed_ ? n_ : m_; }
+  int64_t factor_cols() const { return transposed_ ? m_ : n_; }
+  int64_t k() const { return (std::min)(m_, n_); }
+
+  size_t factorBytes() const { return static_cast<size_t>(lda_) * static_cast<size_t>(factor_cols()) * sizeof(Scalar); }
+
+  // Common compute() prologue: record shape, reset info, wait on the input.
+  // Returns false (and clears stale factors) for empty input.
+  bool begin_compute(const DeviceMatrix<Scalar>& d_A) {
+    m_ = d_A.rows();
+    n_ = d_A.cols();
+    if (!solver_ctx_.begin_compute(m_ != 0 && n_ != 0)) {
+      d_qr_ = internal::DeviceBuffer();
+      d_tau_ = internal::DeviceBuffer();
+      return false;
+    }
+    transposed_ = (m_ < n_);
+    lda_ = static_cast<int64_t>(transposed_ ? n_ : m_);
+    d_A.waitReady(solver_ctx_.stream());
+    return true;
+  }
+
+  void allocate_factor_storage(size_t mat_bytes) { internal::ensure_sized(d_qr_, mat_bytes); }
+
+  // Wide input (m < n): factor A^H, produced on device via cuBLAS geam.
+  void transpose_into_factor(const DeviceMatrix<Scalar>& d_A) {
+    allocate_factor_storage(factorBytes());
+    Scalar alpha_one(1), beta_zero(0);
+    EIGEN_CUBLAS_CHECK(internal::cublasXgeam(solver_ctx_.cublasHandle(), CUBLAS_OP_C, CUBLAS_OP_N, n_, m_, &alpha_one,
+                                             d_A.data(), d_A.rows(), &beta_zero, static_cast<const Scalar*>(nullptr),
+                                             n_, static_cast<Scalar*>(d_qr_.get()), n_));
+  }
+
+  void factorize() {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+
+    solver_ctx_.mark_pending();
+
+    internal::ensure_sized(d_tau_, static_cast<size_t>(k()) * sizeof(Scalar));
+
+    const int64_t fm = factor_rows();
+    const int64_t fn = factor_cols();
+    size_t dev_ws = 0, host_ws = 0;
+    EIGEN_CUSOLVER_CHECK(cusolverDnXgeqrf_bufferSize(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, fm, fn, dtype,
+                                                     d_qr_.get(), lda_, dtype, d_tau_.get(), dtype, &dev_ws, &host_ws));
+
+    solver_ctx_.ensure_scratch(dev_ws);
+    solver_ctx_.h_workspace_.resize(host_ws);
+
+    EIGEN_CUSOLVER_CHECK(
+        cusolverDnXgeqrf(solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, fm, fn, dtype, d_qr_.get(), lda_, dtype,
+                         d_tau_.get(), dtype, solver_ctx_.scratch_workspace(), dev_ws,
+                         host_ws > 0 ? solver_ctx_.h_workspace_.data() : nullptr, host_ws, solver_ctx_.scratch_info()));
+
+    solver_ctx_.enqueue_info_copy();
+  }
+
+  // Applies Q (CUBLAS_OP_N) or Q^H (CUBLAS_OP_T for real, CUBLAS_OP_C for complex)
+  // in place. Workspace comes from solver_ctx_'s grow-only scratch, so there is no
+  // per-call malloc/free.
+  void apply_Q(cublasOperation_t op, void* d_B, int64_t ldb, int64_t nrhs) const {
+    const int im = internal::to_blas_int(factor_rows());
+    const int in = internal::to_blas_int(nrhs);
+    const int ik = internal::to_blas_int(k());
+    const int ilda = internal::to_blas_int(lda_);
+    const int ildb = internal::to_blas_int(ldb);
+
+    int lwork = 0;
+    EIGEN_CUSOLVER_CHECK(internal::cusolverDnXormqr_bufferSize(
+        solver_ctx_.cusolverHandle(), CUBLAS_SIDE_LEFT, op, im, in, ik, static_cast<const Scalar*>(d_qr_.get()), ilda,
+        static_cast<const Scalar*>(d_tau_.get()), static_cast<const Scalar*>(d_B), ildb, &lwork));
+
+    solver_ctx_.ensure_scratch(static_cast<size_t>(lwork) * sizeof(Scalar));
+
+    EIGEN_CUSOLVER_CHECK(internal::cusolverDnXormqr(
+        solver_ctx_.cusolverHandle(), CUBLAS_SIDE_LEFT, op, im, in, ik, static_cast<const Scalar*>(d_qr_.get()), ilda,
+        static_cast<const Scalar*>(d_tau_.get()), static_cast<Scalar*>(d_B), ildb,
+        static_cast<Scalar*>(solver_ctx_.scratch_workspace()), lwork, solver_ctx_.scratch_info()));
+  }
+
+  void apply_QH(void* d_B, int64_t ldb, int64_t nrhs) const {
+    constexpr cublasOperation_t trans = NumTraits<Scalar>::IsComplex ? CUBLAS_OP_C : CUBLAS_OP_T;
+    apply_Q(trans, d_B, ldb, nrhs);
+  }
+
+  PlainMatrix solve_overdetermined_host(const Ref<const PlainMatrix>& rhs) const {
+    const Index nrhs = rhs.cols();
+    const size_t b_bytes = static_cast<size_t>(m_) * static_cast<size_t>(nrhs) * sizeof(Scalar);
+
+    internal::DeviceBuffer d_B(b_bytes);
+    internal::upload_host_matrix(static_cast<Scalar*>(d_B.get()), m_, rhs.data(), rhs.outerStride(), m_, nrhs,
+                                 solver_ctx_.stream());
+
+    apply_QH(d_B.get(), m_, nrhs);
+    trsm_R(d_B.get(), m_, nrhs, /*op=*/CUBLAS_OP_N);
+
+    PlainMatrix X(n_, nrhs);
+    if (m_ == n_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(X.data(), d_B.get(),
+                                               static_cast<size_t>(n_) * static_cast<size_t>(nrhs) * sizeof(Scalar),
+                                               cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    } else {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy2DAsync(X.data(), static_cast<size_t>(n_) * sizeof(Scalar), d_B.get(),
+                                                 static_cast<size_t>(m_) * sizeof(Scalar),
+                                                 static_cast<size_t>(n_) * sizeof(Scalar), static_cast<size_t>(nrhs),
+                                                 cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    }
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+    return X;
+  }
+
+  DeviceMatrix<Scalar> solve_overdetermined_device(const DeviceMatrix<Scalar>& d_B) const {
+    const Index nrhs = d_B.cols();
+    const size_t b_bytes = static_cast<size_t>(m_) * static_cast<size_t>(nrhs) * sizeof(Scalar);
+
+    internal::DeviceBuffer d_work(b_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_work.get(), d_B.data(), b_bytes, cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+
+    apply_QH(d_work.get(), m_, nrhs);
+    trsm_R(d_work.get(), m_, nrhs, /*op=*/CUBLAS_OP_N);
+
+    if (m_ == n_) {
+      DeviceMatrix<Scalar> result =
+          DeviceMatrix<Scalar>::adopt(static_cast<Scalar*>(d_work.release()), n_, static_cast<Index>(nrhs));
+      result.recordReady(solver_ctx_.stream());
+      return result;
+    }
+    DeviceMatrix<Scalar> result(n_, static_cast<Index>(nrhs));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy2DAsync(result.data(), static_cast<size_t>(n_) * sizeof(Scalar), d_work.get(),
+                                               static_cast<size_t>(m_) * sizeof(Scalar),
+                                               static_cast<size_t>(n_) * sizeof(Scalar), static_cast<size_t>(nrhs),
+                                               cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+    result.recordReady(solver_ctx_.stream());
+    return result;
+  }
+
+  //
+  // We factored A^H = Q R, so A = R^H Q^H. Solving A X = B for X with min ||X||:
+  //   z = R^{-H} B            (m × nrhs, occupies top m rows of an n × nrhs buffer)
+  //   X = Q [z; 0]            (n × nrhs)
+
+  PlainMatrix solve_underdetermined_host(const Ref<const PlainMatrix>& rhs, Index nrhs) const {
+    const size_t x_bytes = static_cast<size_t>(n_) * static_cast<size_t>(nrhs) * sizeof(Scalar);
+
+    internal::DeviceBuffer d_X(x_bytes);
+    // Zero the full n × nrhs buffer; B will overwrite the top m × nrhs block.
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemsetAsync(d_X.get(), 0, x_bytes, solver_ctx_.stream()));
+
+    // B (m × nrhs) into the top of d_X (leading dim n).
+    internal::upload_host_matrix(static_cast<Scalar*>(d_X.get()), n_, rhs.data(), rhs.outerStride(), m_, nrhs,
+                                 solver_ctx_.stream());
+
+    trsm_R(d_X.get(), n_, nrhs, trsm_op_conj_trans());
+    apply_Q(CUBLAS_OP_N, d_X.get(), n_, nrhs);
+
+    PlainMatrix X(n_, nrhs);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(X.data(), d_X.get(), x_bytes, cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+    return X;
+  }
+
+  DeviceMatrix<Scalar> solve_underdetermined_device(const DeviceMatrix<Scalar>& d_B) const {
+    const Index nrhs = d_B.cols();
+    const size_t x_bytes = static_cast<size_t>(n_) * static_cast<size_t>(nrhs) * sizeof(Scalar);
+
+    internal::DeviceBuffer d_X(x_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemsetAsync(d_X.get(), 0, x_bytes, solver_ctx_.stream()));
+
+    if (m_ > 0 && nrhs > 0) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy2DAsync(d_X.get(), static_cast<size_t>(n_) * sizeof(Scalar), d_B.data(),
+                                                 static_cast<size_t>(m_) * sizeof(Scalar),
+                                                 static_cast<size_t>(m_) * sizeof(Scalar), static_cast<size_t>(nrhs),
+                                                 cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+    }
+
+    trsm_R(d_X.get(), n_, nrhs, trsm_op_conj_trans());
+    apply_Q(CUBLAS_OP_N, d_X.get(), n_, nrhs);
+
+    DeviceMatrix<Scalar> result =
+        DeviceMatrix<Scalar>::adopt(static_cast<Scalar*>(d_X.release()), n_, static_cast<Index>(nrhs));
+    result.recordReady(solver_ctx_.stream());
+    return result;
+  }
+
+  static cublasOperation_t trsm_op_conj_trans() { return NumTraits<Scalar>::IsComplex ? CUBLAS_OP_C : CUBLAS_OP_T; }
+
+  // X := op(R)^{-1} B, in place on B. The m >= n branch passes CUBLAS_OP_N to
+  // solve R X = (Q^H B)[:k,:]; the m < n branch passes OP_T/OP_C to solve R^H z = B.
+  void trsm_R(void* d_B, int64_t ldb, int64_t nrhs, cublasOperation_t op) const {
+    Scalar alpha(1);
+    EIGEN_CUBLAS_CHECK(internal::cublasXtrsm(
+        solver_ctx_.cublasHandle(), CUBLAS_SIDE_LEFT, CUBLAS_FILL_MODE_UPPER, op, CUBLAS_DIAG_NON_UNIT, k(), nrhs,
+        &alpha, static_cast<const Scalar*>(d_qr_.get()), lda_, static_cast<Scalar*>(d_B), ldb));
+  }
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_QR_H
diff --git a/contrib/Eigen/src/GPU/GpuSVD.h b/contrib/Eigen/src/GPU/GpuSVD.h
new file mode 100644
index 0000000..600a873
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSVD.h
@@ -0,0 +1,639 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU SVD using cuSOLVER's divide-and-conquer cusolverDnXgesvd. U, S, and VT
+// stay on device; solve() forms X = V * diag(D) * U^H * B with cuBLAS GEMM.
+//
+// cuSOLVER returns VT rather than V, so VT is what is stored; matrixV() adjoints
+// it to match JacobiSVD and BDCSVD.
+
+#ifndef EIGEN_GPU_SVD_H
+#define EIGEN_GPU_SVD_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSolverContext.h"
+
+namespace Eigen {
+namespace gpu {
+template <typename Scalar_>
+class SVD {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using PlainMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using PlainVector = Eigen::Matrix<Scalar, Dynamic, 1>;
+  using RealVector = Eigen::Matrix<RealScalar, Dynamic, 1>;
+
+  SVD() = default;
+
+  /** Bind to \p ctx: run on its stream with its cuSOLVER/cuBLAS handles, so
+   * solver work chains with other work on the same Context without
+   * cross-stream event waits. \p ctx must outlive this object. */
+  explicit SVD(Context& ctx) : solver_ctx_(ctx) {}
+
+  template <typename InputType>
+  explicit SVD(const DenseBase<InputType>& A, unsigned int options = ComputeThinU | ComputeThinV) {
+    compute(A, options);
+  }
+
+  explicit SVD(const DeviceMatrix<Scalar>& d_A, unsigned int options = ComputeThinU | ComputeThinV) {
+    compute(d_A, options);
+  }
+
+  /** Decompose a device-resident A immediately (adopt when m >= n, no copy). */
+  explicit SVD(DeviceMatrix<Scalar>&& d_A, unsigned int options = ComputeThinU | ComputeThinV) {
+    compute(std::move(d_A), options);
+  }
+
+  /** Bind to \p ctx and decompose A immediately. */
+  template <typename InputType>
+  SVD(Context& ctx, const DenseBase<InputType>& A, unsigned int options = ComputeThinU | ComputeThinV)
+      : solver_ctx_(ctx) {
+    compute(A, options);
+  }
+
+  /** Bind to \p ctx and decompose a device-resident A (D2D copy). */
+  SVD(Context& ctx, const DeviceMatrix<Scalar>& d_A, unsigned int options = ComputeThinU | ComputeThinV)
+      : solver_ctx_(ctx) {
+    compute(d_A, options);
+  }
+
+  ~SVD() = default;
+
+  SVD(const SVD&) = delete;
+  SVD& operator=(const SVD&) = delete;
+
+  SVD(SVD&& o) noexcept
+      : solver_ctx_(std::move(o.solver_ctx_)),
+        d_A_(std::move(o.d_A_)),
+        d_U_(std::move(o.d_U_)),
+        d_S_(std::move(o.d_S_)),
+        d_VT_(std::move(o.d_VT_)),
+        d_D_(std::move(o.d_D_)),
+        cached_diag_kk_(o.cached_diag_kk_),
+        cached_diag_lambda_(o.cached_diag_lambda_),
+        diag_valid_(o.diag_valid_),
+        options_(o.options_),
+        m_(o.m_),
+        n_(o.n_),
+        lda_(o.lda_),
+        transposed_(o.transposed_) {
+    o.diag_valid_ = false;
+    o.options_ = 0;
+    o.m_ = 0;
+    o.n_ = 0;
+    o.lda_ = 0;
+    o.transposed_ = false;
+  }
+
+  SVD& operator=(SVD&& o) noexcept {
+    if (this != &o) {
+      solver_ctx_ = std::move(o.solver_ctx_);
+      d_A_ = std::move(o.d_A_);
+      d_U_ = std::move(o.d_U_);
+      d_S_ = std::move(o.d_S_);
+      d_VT_ = std::move(o.d_VT_);
+      d_D_ = std::move(o.d_D_);
+      cached_diag_kk_ = o.cached_diag_kk_;
+      cached_diag_lambda_ = o.cached_diag_lambda_;
+      diag_valid_ = o.diag_valid_;
+      options_ = o.options_;
+      m_ = o.m_;
+      n_ = o.n_;
+      lda_ = o.lda_;
+      transposed_ = o.transposed_;
+      o.diag_valid_ = false;
+      o.options_ = 0;
+      o.m_ = 0;
+      o.n_ = 0;
+      o.lda_ = 0;
+      o.transposed_ = false;
+    }
+    return *this;
+  }
+
+  template <typename InputType>
+  SVD& compute(const DenseBase<InputType>& A, unsigned int options = ComputeThinU | ComputeThinV) {
+    // Upload to device, then delegate to the adopting overload — the freshly
+    // uploaded matrix is consumed in place by gesvd, so no second device copy.
+    // The wide-matrix transpose runs on the GPU (via cublasXgeam) inside the
+    // device-input path; no host transpose.
+    return compute(DeviceMatrix<Scalar>::fromHost(A.derived(), solver_ctx_.stream()), options);
+  }
+
+  SVD& compute(const DeviceMatrix<Scalar>& d_A, unsigned int options = ComputeThinU | ComputeThinV) {
+    if (!begin_compute(d_A, options)) return *this;
+
+    if (transposed_) {
+      transpose_into_input(d_A);
+    } else {
+      const size_t mat_bytes = static_cast<size_t>(lda_) * static_cast<size_t>(n_) * sizeof(Scalar);
+      d_A_ = internal::DeviceBuffer(mat_bytes);
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(d_A_.get(), d_A.data(), mat_bytes, cudaMemcpyDeviceToDevice, solver_ctx_.stream()));
+    }
+
+    factorize();
+    return *this;
+  }
+
+  /** Decompose a device matrix (move). For m >= n the buffer is adopted and
+   * consumed in place by gesvd — no copy; for m < n a transposed copy is
+   * unavoidable. */
+  SVD& compute(DeviceMatrix<Scalar>&& d_A, unsigned int options = ComputeThinU | ComputeThinV) {
+    if (!begin_compute(d_A, options)) return *this;
+
+    if (transposed_) {
+      transpose_into_input(d_A);
+    } else {
+      const size_t a_bytes = d_A.sizeInBytes();
+      d_A_ = internal::DeviceBuffer::adopt(static_cast<void*>(d_A.release()), a_bytes);
+    }
+
+    factorize();
+    return *this;
+  }
+
+  ComputationInfo info() const { return solver_ctx_.info(); }
+
+  Index rows() const { return transposed_ ? n_ : m_; }
+  Index cols() const { return transposed_ ? m_ : n_; }
+
+  /** Singular values (always available). Downloads from device on each call. */
+  RealVector singularValues() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    const Index k = (std::min)(m_, n_);
+    RealVector S(k);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpy(S.data(), d_S_.get(), static_cast<size_t>(k) * sizeof(RealScalar), cudaMemcpyDeviceToHost));
+    return S;
+  }
+
+  /** Left singular vectors U. */
+  PlainMatrix matrixU() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert((options_ & (ComputeThinU | ComputeFullU)) && "matrixU() requires ComputeThinU or ComputeFullU");
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    const Index k = (std::min)(m_orig, n_orig);
+    if (!transposed_) {
+      const Index ucols = (options_ & ComputeFullU) ? m_ : k;
+      PlainMatrix U(m_, ucols);
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy(U.data(), d_U_.get(),
+                                          static_cast<size_t>(m_) * static_cast<size_t>(ucols) * sizeof(Scalar),
+                                          cudaMemcpyDeviceToHost));
+      return U;
+    } else {
+      const Index vtrows = (options_ & ComputeFullU) ? m_orig : k;
+      PlainMatrix VT_stored(vtrows, n_);
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy(VT_stored.data(), d_VT_.get(),
+                                          static_cast<size_t>(vtrows) * static_cast<size_t>(n_) * sizeof(Scalar),
+                                          cudaMemcpyDeviceToHost));
+      return VT_stored.adjoint();
+    }
+  }
+
+  /** Right singular vectors V (matches host JacobiSVD/BDCSVD). */
+  PlainMatrix matrixV() const { return matrixVT().adjoint(); }
+
+  /** Right singular vectors transposed V^T. */
+  PlainMatrix matrixVT() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert((options_ & (ComputeThinV | ComputeFullV)) && "matrixVT() requires ComputeThinV or ComputeFullV");
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    const Index k = (std::min)(m_orig, n_orig);
+    if (!transposed_) {
+      const Index vtrows = (options_ & ComputeFullV) ? n_ : k;
+      PlainMatrix VT(vtrows, n_);
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy(VT.data(), d_VT_.get(),
+                                          static_cast<size_t>(vtrows) * static_cast<size_t>(n_) * sizeof(Scalar),
+                                          cudaMemcpyDeviceToHost));
+      return VT;
+    } else {
+      const Index ucols = (options_ & ComputeFullV) ? n_orig : k;
+      PlainMatrix U_stored(m_, ucols);
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy(U_stored.data(), d_U_.get(),
+                                          static_cast<size_t>(m_) * static_cast<size_t>(ucols) * sizeof(Scalar),
+                                          cudaMemcpyDeviceToHost));
+      return U_stored.adjoint();
+    }
+  }
+
+  //
+  // These return non-owning DeviceMatrix views over the SVD's internal device storage.
+  // The view borrows the pointer: destruction does not free; the SVD object must outlive
+  // any view derived from it. For the common case (m >= n) all three accessors are pure
+  // metadata: zero kernel launches, zero allocations.
+  //
+  // For wide matrices (m < n, internally factored as A^H), original U and V^T are the
+  // adjoints of the stored buffers, so d_matrixU() / d_matrixVT() build them via a
+  // cublasXgeam into an owning temporary. d_singularValues() remains zero-copy.
+
+  /** Singular values as a k × 1 view on this solver's stream. */
+  DeviceMatrix<RealScalar> d_singularValues() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    const Index k = (std::min)(m_, n_);
+    auto v = DeviceMatrix<RealScalar>::view(static_cast<RealScalar*>(d_S_.get()), k, 1);
+    v.recordReady(solver_ctx_.stream());
+    return v;
+  }
+
+  /** Left singular vectors U as a DeviceMatrix on this solver's stream.
+   * For m >= n: zero-copy view. For m < n: owning (one cublasXgeam adjoint pass). */
+  DeviceMatrix<Scalar> d_matrixU() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert((options_ & (ComputeThinU | ComputeFullU)) && "d_matrixU() requires ComputeThinU or ComputeFullU");
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    const Index k = (std::min)(m_orig, n_orig);
+    if (!transposed_) {
+      const Index ucols = (options_ & ComputeFullU) ? m_ : k;
+      auto v = DeviceMatrix<Scalar>::view(static_cast<Scalar*>(d_U_.get()), m_, ucols);
+      v.recordReady(solver_ctx_.stream());
+      return v;
+    }
+    // transposed: U_orig = VT_stored^H -> conjugate-transpose via cublasXgeam.
+    const Index vtrows_stored = (options_ & ComputeFullU) ? n_ : k;
+    DeviceMatrix<Scalar> result(n_, vtrows_stored);
+    if (n_ > 0 && vtrows_stored > 0) {
+      Scalar alpha_one(1), beta_zero(0);
+      EIGEN_CUBLAS_CHECK(internal::cublasXgeam(solver_ctx_.cublasHandle(), CUBLAS_OP_C, CUBLAS_OP_N, n_, vtrows_stored,
+                                               &alpha_one, static_cast<const Scalar*>(d_VT_.get()), vtrows_stored,
+                                               &beta_zero, static_cast<const Scalar*>(nullptr), n_, result.data(), n_));
+      result.recordReady(solver_ctx_.stream());
+    }
+    return result;
+  }
+
+  /** Right singular vectors transposed V^T as a DeviceMatrix on this solver's stream.
+   * For m >= n: zero-copy view. For m < n: owning (one cublasXgeam adjoint pass). */
+  DeviceMatrix<Scalar> d_matrixVT() const {
+    eigen_assert(solver_ctx_.info() == Success);
+    eigen_assert((options_ & (ComputeThinV | ComputeFullV)) && "d_matrixVT() requires ComputeThinV or ComputeFullV");
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    const Index k = (std::min)(m_orig, n_orig);
+    if (!transposed_) {
+      const Index vtrows = (options_ & ComputeFullV) ? n_ : k;
+      auto v = DeviceMatrix<Scalar>::view(static_cast<Scalar*>(d_VT_.get()), vtrows, n_);
+      v.recordReady(solver_ctx_.stream());
+      return v;
+    }
+    // transposed: VT_orig = U_stored^H.
+    const Index ucols = (options_ & ComputeFullV) ? n_orig : k;
+    DeviceMatrix<Scalar> result(ucols, m_);
+    if (ucols > 0 && m_ > 0) {
+      Scalar alpha_one(1), beta_zero(0);
+      EIGEN_CUBLAS_CHECK(internal::cublasXgeam(solver_ctx_.cublasHandle(), CUBLAS_OP_C, CUBLAS_OP_N, ucols, m_,
+                                               &alpha_one, static_cast<const Scalar*>(d_U_.get()), m_, &beta_zero,
+                                               static_cast<const Scalar*>(nullptr), ucols, result.data(), ucols));
+      result.recordReady(solver_ctx_.stream());
+    }
+    return result;
+  }
+
+  /** Number of singular values above threshold. */
+  Index rank(RealScalar threshold = RealScalar(-1)) const {
+    RealVector S = singularValues();
+    if (S.size() == 0) return 0;
+    if (threshold < 0) {
+      threshold = (std::max)(m_, n_) * S(0) * NumTraits<RealScalar>::epsilon();
+    }
+    return (S.array() > threshold).count();
+  }
+
+  /** Pseudoinverse solve: X = V * diag(1/S) * U^H * B. */
+  template <typename Rhs>
+  PlainMatrix solve(const MatrixBase<Rhs>& B) const {
+    return solve_impl(B, (std::min)(m_, n_), RealScalar(0));
+  }
+
+  /** Truncated solve: use only top trunc singular triplets. */
+  template <typename Rhs>
+  PlainMatrix solve(const MatrixBase<Rhs>& B, Index trunc) const {
+    eigen_assert(trunc > 0 && trunc <= (std::min)(m_, n_));
+    return solve_impl(B, trunc, RealScalar(0));
+  }
+
+  /** Tikhonov-regularized solve: D_ii = S_i / (S_i^2 + lambda^2). */
+  template <typename Rhs>
+  PlainMatrix solve(const MatrixBase<Rhs>& B, RealScalar lambda) const {
+    eigen_assert(lambda > 0);
+    return solve_impl(B, (std::min)(m_, n_), lambda);
+  }
+
+  /** Pseudoinverse solve with device-resident RHS: returns an n × nrhs
+   * DeviceMatrix that stays on device. The first solve for a given
+   * (truncation, lambda) downloads the singular values (one host sync) to
+   * build the inverse diagonal; subsequent solves reuse the cached device
+   * diagonal and are fully asynchronous. */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B) const {
+    return solve_device_impl(d_B, (std::min)(m_, n_), RealScalar(0));
+  }
+
+  /** Truncated device solve: use only top trunc singular triplets. */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B, Index trunc) const {
+    eigen_assert(trunc > 0 && trunc <= (std::min)(m_, n_));
+    return solve_device_impl(d_B, trunc, RealScalar(0));
+  }
+
+  /** Tikhonov-regularized device solve: D_ii = S_i / (S_i^2 + lambda^2). */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B, RealScalar lambda) const {
+    eigen_assert(lambda > 0);
+    return solve_device_impl(d_B, (std::min)(m_, n_), lambda);
+  }
+
+  cudaStream_t stream() const { return solver_ctx_.stream(); }
+
+ private:
+  mutable internal::GpuSolverContext solver_ctx_;
+  internal::DeviceBuffer d_A_;   // gesvd input scratch; released after factorize()
+  internal::DeviceBuffer d_U_;   // grow-only
+  internal::DeviceBuffer d_S_;   // grow-only
+  internal::DeviceBuffer d_VT_;  // grow-only
+  // Cached inverse-diagonal for solve (built lazily, reused across solves; grow-only).
+  mutable internal::DeviceBuffer d_D_;
+  mutable Index cached_diag_kk_ = -1;
+  mutable RealScalar cached_diag_lambda_ = RealScalar(-1);
+  mutable bool diag_valid_ = false;
+  unsigned int options_ = 0;
+  int64_t m_ = 0;
+  int64_t n_ = 0;
+  int64_t lda_ = 0;
+  bool transposed_ = false;
+
+  // Common compute() prologue: record shape/options, reset info and cached
+  // diagonal, wait on input. Returns false (clearing state) for empty input.
+  bool begin_compute(const DeviceMatrix<Scalar>& d_A, unsigned int options) {
+    options_ = options;
+    m_ = d_A.rows();
+    n_ = d_A.cols();
+    lda_ = 0;
+    transposed_ = false;
+    diag_valid_ = false;
+    if (!solver_ctx_.begin_compute(m_ != 0 && n_ != 0)) {
+      d_A_ = internal::DeviceBuffer();
+      d_U_ = internal::DeviceBuffer();
+      d_S_ = internal::DeviceBuffer();
+      d_VT_ = internal::DeviceBuffer();
+      return false;
+    }
+    transposed_ = (m_ < n_);
+    if (transposed_) {
+      std::swap(m_, n_);
+      lda_ = m_;
+    } else {
+      lda_ = static_cast<int64_t>(d_A.rows());
+    }
+    d_A.waitReady(solver_ctx_.stream());
+    return true;
+  }
+
+  // Wide input (m < n): produce d_A_ = A^H on device via cuBLAS geam.
+  void transpose_into_input(const DeviceMatrix<Scalar>& d_A) {
+    const size_t mat_bytes = static_cast<size_t>(lda_) * static_cast<size_t>(n_) * sizeof(Scalar);
+    d_A_ = internal::DeviceBuffer(mat_bytes);
+    // geam: C(m×n) = alpha * op(A) + beta * op(B). beta=0, B=nullptr.
+    Scalar alpha_one(1), beta_zero(0);
+    EIGEN_CUBLAS_CHECK(internal::cublasXgeam(solver_ctx_.cublasHandle(), CUBLAS_OP_C, CUBLAS_OP_N, m_, n_, &alpha_one,
+                                             d_A.data(), d_A.rows(), &beta_zero, static_cast<const Scalar*>(nullptr),
+                                             m_, static_cast<Scalar*>(d_A_.get()), m_));
+  }
+
+  // Swap U↔V flags for the transposed case.
+  static unsigned int swap_uv_options(unsigned int opts) {
+    unsigned int result = 0;
+    if (opts & ComputeThinU) result |= ComputeThinV;
+    if (opts & ComputeFullU) result |= ComputeFullV;
+    if (opts & ComputeThinV) result |= ComputeThinU;
+    if (opts & ComputeFullV) result |= ComputeFullU;
+    return result;
+  }
+
+  static signed char jobu(unsigned int opts) {
+    if (opts & ComputeFullU) return 'A';
+    if (opts & ComputeThinU) return 'S';
+    return 'N';
+  }
+
+  static signed char jobvt(unsigned int opts) {
+    if (opts & ComputeFullV) return 'A';
+    if (opts & ComputeThinV) return 'S';
+    return 'N';
+  }
+
+  void factorize() {
+    constexpr cudaDataType_t dtype = internal::cusolver_data_type<Scalar>::value;
+    constexpr cudaDataType_t rtype = internal::cuda_data_type<RealScalar>::value;
+    const Index k = (std::min)(m_, n_);
+
+    solver_ctx_.mark_pending();
+
+    internal::ensure_sized(d_S_, static_cast<size_t>(k) * sizeof(RealScalar));
+
+    const unsigned int int_opts = transposed_ ? swap_uv_options(options_) : options_;
+
+    const Index ucols = (int_opts & ComputeFullU) ? m_ : ((int_opts & ComputeThinU) ? k : 0);
+    const Index vtrows = (int_opts & ComputeFullV) ? n_ : ((int_opts & ComputeThinV) ? k : 0);
+    const int64_t ldu = m_;
+    const int64_t ldvt = vtrows > 0 ? vtrows : 1;
+
+    if (ucols > 0) {
+      internal::ensure_sized(d_U_, static_cast<size_t>(m_) * static_cast<size_t>(ucols) * sizeof(Scalar));
+    }
+    if (vtrows > 0) {
+      internal::ensure_sized(d_VT_, static_cast<size_t>(vtrows) * static_cast<size_t>(n_) * sizeof(Scalar));
+    }
+
+    eigen_assert(m_ >= n_ && "Internal error: m_ < n_ should have been handled by transpose in compute()");
+    size_t dev_ws = 0, host_ws = 0;
+    EIGEN_CUSOLVER_CHECK(cusolverDnXgesvd_bufferSize(
+        solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, jobu(int_opts), jobvt(int_opts), m_, n_, dtype, d_A_.get(),
+        lda_, rtype, d_S_.get(), dtype, ucols > 0 ? d_U_.get() : nullptr, ldu, dtype,
+        vtrows > 0 ? d_VT_.get() : nullptr, ldvt, dtype, &dev_ws, &host_ws));
+
+    solver_ctx_.ensure_scratch(dev_ws);
+    solver_ctx_.h_workspace_.resize(host_ws);
+
+    EIGEN_CUSOLVER_CHECK(cusolverDnXgesvd(
+        solver_ctx_.cusolverHandle(), solver_ctx_.params_.p, jobu(int_opts), jobvt(int_opts), m_, n_, dtype, d_A_.get(),
+        lda_, rtype, d_S_.get(), dtype, ucols > 0 ? d_U_.get() : nullptr, ldu, dtype,
+        vtrows > 0 ? d_VT_.get() : nullptr, ldvt, dtype, solver_ctx_.scratch_workspace(), dev_ws,
+        host_ws > 0 ? solver_ctx_.h_workspace_.data() : nullptr, host_ws, solver_ctx_.scratch_info()));
+
+    solver_ctx_.enqueue_info_copy();
+
+    // The input copy is pure gesvd scratch — release it now. The free is
+    // stream-ordered (or synchronous on the fallback allocator), so it waits
+    // for gesvd to retire; the memory returns to the pool instead of staying
+    // resident for the solver's lifetime.
+    d_A_ = internal::DeviceBuffer();
+  }
+
+  // Ensure d_D_ holds the kk-entry inverse diagonal for (kk, lambda).
+  // Downloads S and synchronizes only when the cached diagonal doesn't match;
+  // repeated solves with the same truncation/regularization are then free of
+  // host syncs and H2D traffic for the diagonal.
+  //
+  // For lambda == 0 we mirror Eigen's SVDBase::_solve_impl: drop singular
+  // values below S(0) * k * eps (numerical-rank truncation), so this
+  // pseudoinverse solve agrees with CPU BDCSVD::solve on near-singular A.
+  // dgmm wants the diagonal in the matrix scalar type — for complex Scalar
+  // the diagonal is still real, so we build the real values then cast.
+  void build_diag(Index kk, RealScalar lambda) const {
+    if (diag_valid_ && cached_diag_kk_ == kk && cached_diag_lambda_ == lambda) return;
+
+    const Index k = (std::min)(m_, n_);
+    RealVector S(k);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(S.data(), d_S_.get(), static_cast<size_t>(k) * sizeof(RealScalar),
+                                             cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+
+    const RealScalar drop_threshold = S(0) * RealScalar(k) * NumTraits<RealScalar>::epsilon();
+    auto S_head = S.head(kk).array();
+    PlainVector D(kk);
+    if (lambda == RealScalar(0)) {
+      D = (S_head > drop_threshold).select(S_head.inverse(), RealScalar(0)).matrix().template cast<Scalar>();
+    } else {
+      D = (S_head / (S_head.square() + lambda * lambda)).matrix().template cast<Scalar>();
+    }
+
+    const size_t d_bytes = static_cast<size_t>(kk) * sizeof(Scalar);
+    internal::ensure_sized(d_D_, d_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_D_.get(), D.data(), d_bytes, cudaMemcpyHostToDevice, solver_ctx_.stream()));
+    cached_diag_kk_ = kk;
+    cached_diag_lambda_ = lambda;
+    diag_valid_ = true;
+  }
+
+  // Shared pseudoinverse application: X = V_orig * diag(D) * U_orig^H * B,
+  // entirely on device. Assumes build_diag(kk, ...) has run and B_dev/X_dev
+  // are device pointers with leading dimensions m_orig / n_orig.
+  void apply_pinv(const Scalar* B_dev, Index kk, Index nrhs, Scalar* X_dev) const {
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    const Index k = (std::min)(m_, n_);
+
+    auto* U_dev = static_cast<const Scalar*>(d_U_.get());
+    auto* VT_dev = static_cast<const Scalar*>(d_VT_.get());
+
+    Scalar scalars[2] = {Scalar(1), Scalar(0)};
+
+    // Step 1: tmp = U_orig^H * B  (kk × nrhs).
+    internal::DeviceBuffer d_tmp(static_cast<size_t>(kk) * static_cast<size_t>(nrhs) * sizeof(Scalar));
+    auto* tmp_dev = static_cast<Scalar*>(d_tmp.get());
+    if (!transposed_) {
+      internal::cublaslt_gemm(solver_ctx_.cublasLtHandle(), solver_ctx_.cublasHandle(), CUBLAS_OP_C, CUBLAS_OP_N, kk,
+                              nrhs, m_, &scalars[0], U_dev, m_, B_dev, m_orig, &scalars[1], tmp_dev, kk,
+                              solver_ctx_.gemmWorkspace(), solver_ctx_.gemmPlanCache(),
+                              solver_ctx_.cublasLtMaxWorkspaceBytes(), solver_ctx_.stream());
+    } else {
+      const Index vtrows_stored = (swap_uv_options(options_) & ComputeFullV) ? n_ : k;
+      internal::cublaslt_gemm(solver_ctx_.cublasLtHandle(), solver_ctx_.cublasHandle(), CUBLAS_OP_N, CUBLAS_OP_N, kk,
+                              nrhs, m_orig, &scalars[0], VT_dev, vtrows_stored, B_dev, m_orig, &scalars[1], tmp_dev, kk,
+                              solver_ctx_.gemmWorkspace(), solver_ctx_.gemmPlanCache(),
+                              solver_ctx_.cublasLtMaxWorkspaceBytes(), solver_ctx_.stream());
+    }
+
+    // Step 2: tmp = diag(D) * tmp on device via cublasXdgmm.
+    EIGEN_CUBLAS_CHECK(internal::cublasXdgmm(solver_ctx_.cublasHandle(), CUBLAS_SIDE_LEFT, kk, nrhs, tmp_dev, kk,
+                                             static_cast<const Scalar*>(d_D_.get()), 1, tmp_dev, kk));
+
+    // Step 3: X = V_orig * tmp  (n_orig × nrhs).
+    if (!transposed_) {
+      const Index vtrows = (options_ & ComputeFullV) ? n_ : k;
+      internal::cublaslt_gemm(solver_ctx_.cublasLtHandle(), solver_ctx_.cublasHandle(), CUBLAS_OP_C, CUBLAS_OP_N,
+                              n_orig, nrhs, kk, &scalars[0], VT_dev, vtrows, tmp_dev, kk, &scalars[1], X_dev, n_orig,
+                              solver_ctx_.gemmWorkspace(), solver_ctx_.gemmPlanCache(),
+                              solver_ctx_.cublasLtMaxWorkspaceBytes(), solver_ctx_.stream());
+    } else {
+      internal::cublaslt_gemm(solver_ctx_.cublasLtHandle(), solver_ctx_.cublasHandle(), CUBLAS_OP_N, CUBLAS_OP_N,
+                              n_orig, nrhs, kk, &scalars[0], U_dev, m_, tmp_dev, kk, &scalars[1], X_dev, n_orig,
+                              solver_ctx_.gemmWorkspace(), solver_ctx_.gemmPlanCache(),
+                              solver_ctx_.cublasLtMaxWorkspaceBytes(), solver_ctx_.stream());
+    }
+  }
+
+  template <typename Rhs>
+  PlainMatrix solve_impl(const MatrixBase<Rhs>& B, Index trunc, RealScalar lambda) const {
+    eigen_assert(solver_ctx_.info() == Success && "SVD::solve called on a failed or uninitialized decomposition");
+    eigen_assert((options_ & (ComputeThinU | ComputeFullU)) && "solve requires U");
+    eigen_assert((options_ & (ComputeThinV | ComputeFullV)) && "solve requires V");
+
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    eigen_assert(B.rows() == m_orig);
+
+    const Index k = (std::min)(m_, n_);
+    const Index kk = (std::min)(trunc, k);
+    const Index nrhs = B.cols();
+
+    // Empty problem: no rank, no RHS, or zero domain -> result is the zero matrix.
+    if (kk == 0 || nrhs == 0 || n_orig == 0) {
+      return PlainMatrix::Zero(n_orig, nrhs);
+    }
+
+    // Enqueue the B upload before build_diag: when the diagonal must be
+    // (re)built, its S-download sync then also covers the in-flight upload —
+    // one blocking wait instead of two.
+    const Ref<const PlainMatrix> rhs(B.derived());
+    internal::DeviceBuffer d_B(static_cast<size_t>(m_orig) * static_cast<size_t>(nrhs) * sizeof(Scalar));
+    internal::upload_host_matrix(static_cast<Scalar*>(d_B.get()), m_orig, rhs.data(), rhs.outerStride(), m_orig, nrhs,
+                                 solver_ctx_.stream());
+    build_diag(kk, lambda);
+
+    PlainMatrix X(n_orig, nrhs);
+    internal::DeviceBuffer d_X(static_cast<size_t>(n_orig) * static_cast<size_t>(nrhs) * sizeof(Scalar));
+    apply_pinv(static_cast<const Scalar*>(d_B.get()), kk, nrhs, static_cast<Scalar*>(d_X.get()));
+
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(X.data(), d_X.get(),
+                                             static_cast<size_t>(n_orig) * static_cast<size_t>(nrhs) * sizeof(Scalar),
+                                             cudaMemcpyDeviceToHost, solver_ctx_.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(solver_ctx_.stream()));
+
+    return X;
+  }
+
+  DeviceMatrix<Scalar> solve_device_impl(const DeviceMatrix<Scalar>& d_B, Index trunc, RealScalar lambda) const {
+    eigen_assert(solver_ctx_.info() == Success && "SVD::solve called on a failed or uninitialized decomposition");
+    eigen_assert((options_ & (ComputeThinU | ComputeFullU)) && "solve requires U");
+    eigen_assert((options_ & (ComputeThinV | ComputeFullV)) && "solve requires V");
+
+    const Index m_orig = transposed_ ? n_ : m_;
+    const Index n_orig = transposed_ ? m_ : n_;
+    eigen_assert(d_B.rows() == m_orig);
+
+    const Index k = (std::min)(m_, n_);
+    const Index kk = (std::min)(trunc, k);
+    const Index nrhs = d_B.cols();
+
+    if (kk == 0 || nrhs == 0 || n_orig == 0) {
+      DeviceMatrix<Scalar> X(n_orig, nrhs);
+      X.setZero(solver_ctx_.stream());
+      return X;
+    }
+
+    d_B.waitReady(solver_ctx_.stream());
+    build_diag(kk, lambda);
+
+    DeviceMatrix<Scalar> X(n_orig, nrhs);
+    apply_pinv(d_B.data(), kk, nrhs, X.data());
+    X.recordReady(solver_ctx_.stream());
+    return X;
+  }
+};
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SVD_H
diff --git a/contrib/Eigen/src/GPU/GpuSolverContext.h b/contrib/Eigen/src/GPU/GpuSolverContext.h
new file mode 100644
index 0000000..33b05cf
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSolverContext.h
@@ -0,0 +1,205 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Shared context for the dense GPU solvers. Each solver holds one by composition
+// and delegates handle lifetime and scratch management to it.
+
+#ifndef EIGEN_GPU_SOLVER_CONTEXT_H
+#define EIGEN_GPU_SOLVER_CONTEXT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./CuSolverSupport.h"
+#include "./CuBlasSupport.h"
+#include "./GpuContext.h"
+#include <vector>
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+struct GpuSolverContext {
+  Context* bound_ctx_ = nullptr;
+  UniqueStream stream_;
+  UniqueCusolverHandle cusolver_;
+  UniqueCublasHandle cublas_;
+  UniqueCublasLtHandle cublas_lt_;  // lazy: created on first GEMM-via-cublasLt call (standalone mode only)
+  CusolverParams params_;
+  DeviceBuffer d_scratch_;
+  std::vector<char> h_workspace_;
+  DeviceBuffer gemm_workspace_;  // grown lazily by cublaslt_gemm
+  CublasLtPlanCache gemm_plan_cache_{kCublasLtPlanCacheCapacity};
+  // Workspace ceiling fed to the cublasLtMatmul heuristic at plan-creation time.
+  // See gpu::Context::setCublasLtMaxWorkspaceBytes() for semantics.
+  std::size_t cublaslt_max_workspace_bytes_ = kCublasLtMaxWorkspaceBytes;
+  ComputationInfo info_ = InvalidInput;
+  PinnedHostBuffer pinned_info_{sizeof(int)};  // pinned host memory for async D2H of info word
+  bool info_synced_ = true;
+
+  int& info_word() { return *static_cast<int*>(pinned_info_.get()); }
+  int info_word() const { return *static_cast<const int*>(pinned_info_.get()); }
+
+  cudaStream_t stream() const { return stream_.get(); }
+  cusolverDnHandle_t cusolverHandle() const { return cusolver_.get(); }
+  cublasHandle_t cublasHandle() const { return cublas_.get(); }
+
+  GpuSolverContext() {
+    cudaStream_t s = nullptr;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&s));
+    stream_ = UniqueStream(s);
+    cusolverDnHandle_t solver = nullptr;
+    EIGEN_CUSOLVER_CHECK(cusolverDnCreate(&solver));
+    cusolver_ = UniqueCusolverHandle(solver);
+    EIGEN_CUSOLVER_CHECK(cusolverDnSetStream(solver, s));
+    cublasHandle_t blas = nullptr;
+    EIGEN_CUBLAS_CHECK(cublasCreate(&blas));
+    cublas_ = UniqueCublasHandle(blas);
+    EIGEN_CUBLAS_CHECK(cublasSetStream(blas, s));
+    ensure_scratch(0);
+  }
+
+  /** Borrow stream and cuSOLVER/cuBLAS handles from a gpu::Context, so solver
+   * work runs on the same stream as the caller's other GPU operations (no
+   * cross-stream event waits, and the solver creates no stream/handles of its
+   * own). The cuBLASLt handle, GEMM plan cache, and GEMM workspace are shared
+   * with the Context as well. The Context must outlive this solver context. */
+  explicit GpuSolverContext(Context& ctx)
+      : bound_ctx_(&ctx),
+        stream_(ctx.stream(), CudaStreamDeleter{/*owns=*/false}),
+        cusolver_(ctx.cusolverHandle(), CusolverHandleDeleter{/*owns=*/false}),
+        cublas_(ctx.cublasHandle(), CublasHandleDeleter{/*owns=*/false}) {
+    ensure_scratch(0);
+  }
+
+  ~GpuSolverContext() = default;
+  GpuSolverContext(GpuSolverContext&& o) noexcept = default;
+
+  GpuSolverContext& operator=(GpuSolverContext&& o) noexcept {
+    if (this != &o) {
+      // A pending info copy may still write pinned_info_, whose cudaFreeHost deleter is not stream-ordered.
+      if (!info_synced_ && pinned_info_) (void)cudaStreamSynchronize(stream());
+      // Release plan-cache descriptors before the moves below replace the cuBLASLt handle they were built with.
+      gemm_plan_cache_.clear();
+      bound_ctx_ = o.bound_ctx_;
+      stream_ = std::move(o.stream_);
+      cusolver_ = std::move(o.cusolver_);
+      cublas_ = std::move(o.cublas_);
+      cublas_lt_ = std::move(o.cublas_lt_);
+      params_ = std::move(o.params_);
+      d_scratch_ = std::move(o.d_scratch_);
+      h_workspace_ = std::move(o.h_workspace_);
+      gemm_workspace_ = std::move(o.gemm_workspace_);
+      gemm_plan_cache_ = std::move(o.gemm_plan_cache_);
+      cublaslt_max_workspace_bytes_ = o.cublaslt_max_workspace_bytes_;
+      info_ = o.info_;
+      pinned_info_ = std::move(o.pinned_info_);
+      info_synced_ = o.info_synced_;
+      o.bound_ctx_ = nullptr;
+    }
+    return *this;
+  }
+
+  /** cuBLASLt handle: the bound Context's when borrowing, otherwise an owned
+   * handle lazy-initialized on first GEMM-via-cublasLt call. */
+  cublasLtHandle_t cublasLtHandle() {
+    if (bound_ctx_) return bound_ctx_->cublasLtHandle();
+    if (!cublas_lt_) {
+      cublasLtHandle_t h = nullptr;
+      EIGEN_CUBLAS_CHECK(cublasLtCreate(&h));
+      cublas_lt_ = UniqueCublasLtHandle(h);
+    }
+    return cublas_lt_.get();
+  }
+
+  /** GEMM plan cache / workspace / workspace ceiling for cublaslt_gemm —
+   * shared with the bound Context when borrowing, owned otherwise. */
+  CublasLtPlanCache& gemmPlanCache() { return bound_ctx_ ? bound_ctx_->gemmPlanCache() : gemm_plan_cache_; }
+  DeviceBuffer& gemmWorkspace() { return bound_ctx_ ? bound_ctx_->gemmWorkspace() : gemm_workspace_; }
+  std::size_t cublasLtMaxWorkspaceBytes() const {
+    return bound_ctx_ ? bound_ctx_->cublasLtMaxWorkspaceBytes() : cublaslt_max_workspace_bytes_;
+  }
+
+  GpuSolverContext(const GpuSolverContext&) = delete;
+  GpuSolverContext& operator=(const GpuSolverContext&) = delete;
+
+  // Scratch layout: [ workspace (aligned) | info_word (sizeof(int)) ].
+  // Workspace size is rounded up to 16 bytes so the info word lands aligned.
+  static constexpr size_t kInfoBytes = sizeof(int);
+  static constexpr size_t kScratchAlign = 16;
+
+  static size_t scratchBytesFor(size_t workspace_bytes) {
+    workspace_bytes = (workspace_bytes + kScratchAlign - 1) & ~(kScratchAlign - 1);
+    return workspace_bytes + kInfoBytes;
+  }
+
+  // Ensure d_scratch_ holds at least `workspace_bytes` of scratch plus the trailing
+  // info word. Grows but never shrinks. Syncs the stream before reallocating to
+  // avoid freeing memory that async kernels may still be using.
+  void ensure_scratch(size_t workspace_bytes) {
+    size_t needed = scratchBytesFor(workspace_bytes);
+    if (needed > d_scratch_.size()) {
+      if (d_scratch_) EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream()));
+      d_scratch_ = DeviceBuffer(needed);
+    }
+  }
+
+  void* scratch_workspace() const { return d_scratch_.get(); }
+
+  int* scratch_info() const {
+    eigen_assert(d_scratch_ && d_scratch_.size() >= kInfoBytes);
+    return reinterpret_cast<int*>(static_cast<char*>(d_scratch_.get()) + d_scratch_.size() - kInfoBytes);
+  }
+
+  // Mark a factorization as pending: its info word is not yet available.
+  void mark_pending() {
+    info_synced_ = false;
+    info_ = InvalidInput;
+  }
+
+  // Common compute() prologue: reset info state. Returns false for the empty
+  // (n == 0) case, which is trivially successful — the caller returns early.
+  bool begin_compute(bool nonempty) {
+    info_ = InvalidInput;
+    if (!nonempty) {
+      info_ = Success;
+      info_synced_ = true;
+      return false;
+    }
+    return true;
+  }
+
+  // Common factorize() epilogue: enqueue the async D2H copy of the info word
+  // into pinned host memory. Read later by the lazy sync_info().
+  void enqueue_info_copy() {
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(&info_word(), scratch_info(), sizeof(int), cudaMemcpyDeviceToHost, stream()));
+  }
+
+  // Synchronize the stream and interpret the info word; no-op once synced.
+  void sync_info() {
+    if (!info_synced_) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream()));
+      info_ = (info_word() == 0) ? Success : NumericalIssue;
+      info_synced_ = true;
+    }
+  }
+
+  ComputationInfo info() {
+    sync_info();
+    return info_;
+  }
+};
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SOLVER_CONTEXT_H
diff --git a/contrib/Eigen/src/GPU/GpuSparseContext.h b/contrib/Eigen/src/GPU/GpuSparseContext.h
new file mode 100644
index 0000000..3de9c32
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSparseContext.h
@@ -0,0 +1,987 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU sparse matrix-vector (SpMV) and sparse matrix-dense matrix (SpMM) multiply
+// via cuSPARSE.
+//
+// SparseContext owns the cuSPARSE descriptors and device buffers. It takes
+// SparseMatrix<Scalar, ColMajor> (CSC), implicitly converting RowMajor input, and
+// can borrow a gpu::Context so that sparse products share a stream with BLAS-1
+// operations — which removes the cross-stream event waits in solvers like CG.
+// It also takes BlockSparseMatrix: as BSR (internal::BsrBinding) where
+// internal::use_cusparse_bsr holds, as the scalar-level toSparse() copy otherwise.
+//
+// Caching: host-input calls re-upload the values *and* index arrays on every
+// call. Host pointer identity cannot detect a sparsity pattern rewritten in
+// place or assigned into the same allocations (SparseMatrix reuses them for
+// same-shape assignments), so the structure is never assumed unchanged. What
+// is cached are the cuSPARSE descriptors (sparse descriptor keyed on
+// dimensions + nonzero count + block size, dense descriptors keyed on shape)
+// and the SpMV/SpMM workspace-size queries. For repeated products with no
+// re-upload at all, use deviceView().
+//
+// Not thread-safe: concurrent multiply* calls on one instance race on the
+// cuSPARSE handle, the bound stream, and the cached buffers. Use one per thread.
+
+#ifndef EIGEN_GPU_SPARSE_CONTEXT_H
+#define EIGEN_GPU_SPARSE_CONTEXT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <cstdint>
+
+#include "./CuSparseSupport.h"
+#include "./FwdDecl.h"
+
+namespace Eigen {
+namespace gpu {
+
+namespace internal {
+/** Whether a BlockSparseMatrix with this block shape uploads as BSR. cuSPARSE
+ * runs BSR products only on square blocks of size at least 2 (cusparseCreateBsr
+ * rejects rectangular blocks; SpMV on 1 x 1 blocks returns
+ * CUSPARSE_STATUS_NOT_SUPPORTED) and only from cuSPARSE 12.6.3; every other
+ * case takes the CSC path. */
+template <int BlockRows, int BlockCols>
+struct use_cusparse_bsr
+    : Eigen::internal::bool_constant<(EIGEN_HAS_CUSPARSE_BSR != 0 && BlockRows == BlockCols && BlockRows >= 2)> {};
+}  // namespace internal
+
+#if EIGEN_HAS_CUSPARSE_BSR
+namespace internal {
+
+/** The arrays cusparseCreateBsr takes: block-row offsets (brows + 1),
+ * block-column indices (bnnz), and bnnz row-major blockSize x blockSize
+ * value blocks. Sizes are in blocks; rows()/cols()/nonZeros() in scalars. */
+template <typename Scalar, typename StorageIndex>
+struct BsrArrays {
+  Index brows;
+  Index bcols;
+  Index bnnz;
+  Index blockSize;
+  const StorageIndex* outer;
+  const StorageIndex* inner;
+  const Scalar* values;
+
+  Index rows() const { return brows * blockSize; }
+  Index cols() const { return bcols * blockSize; }
+  Index nonZeros() const { return bnnz * blockSize * blockSize; }
+};
+
+/** Reads a square-block BlockSparseMatrix's buffers as BSR without copying.
+ *
+ * A RowMajor M is BSR of M: block rows are its outer vectors and its blocks are
+ * stored row-major. A ColMajor M is BSR of M^T: its outer vectors are the block
+ * rows of M^T, and a column-major B x B block read row-major is the transposed
+ * block. */
+template <typename Bsm>
+BsrArrays<typename Bsm::Scalar, typename Bsm::StorageIndex> bsr_of(const Bsm& M) {
+  return BsrArrays<typename Bsm::Scalar, typename Bsm::StorageIndex>{
+      /*brows=*/M.blockOuterSize(), /*bcols=*/M.blockInnerSize(),
+      /*bnnz=*/M.nonZeroBlocks(),   /*blockSize=*/Index(Bsm::BlockRows),
+      /*outer=*/M.outerIndexPtr(),  /*inner=*/M.innerIndexPtr(),
+      /*values=*/M.valuePtr()};
+}
+
+/** Binds op(A) as BSR arrays of op(A) itself, the only form cuSPARSE
+ * multiplies. Per bsr_of(), one of {NoTrans, Trans} reads A's buffers
+ * directly — NoTrans for RowMajor, Trans for ColMajor — and the other needs
+ * the transposed copy; ConjTrans on a complex matrix always copies for the
+ * conjugation. The copy lives as long as the binding. */
+template <typename Bsm>
+class BsrBinding {
+  EIGEN_STATIC_ASSERT((use_cusparse_bsr<int(Bsm::BlockRows), int(Bsm::BlockCols)>::value),
+                      CUSPARSE_BSR_REQUIRES_SQUARE_BLOCKS_OF_SIZE_AT_LEAST_2)
+
+ public:
+  using Scalar = typename Bsm::Scalar;
+  using Arrays = BsrArrays<Scalar, typename Bsm::StorageIndex>;
+
+  BsrBinding(const Bsm& A, GpuOp op) {
+    if (op == GpuOp::ConjTrans && !NumTraits<Scalar>::IsComplex) op = GpuOp::Trans;
+    const bool direct = Bsm::IsRowMajor ? (op == GpuOp::NoTrans) : (op == GpuOp::Trans);
+    if (direct) {
+      arrays_ = bsr_of(A);
+      return;
+    }
+    if (op == GpuOp::ConjTrans && !Bsm::IsRowMajor) {
+      // ColMajor conj(A) reads as BSR of conj(A)^T = A^H.
+      copy_ = A.unaryExpr(Eigen::internal::scalar_conjugate_op<Scalar>());
+    } else if (op == GpuOp::ConjTrans) {
+      copy_ = A.adjoint();
+    } else {
+      copy_ = A.transpose();
+    }
+    arrays_ = bsr_of(copy_);
+  }
+
+  BsrBinding(const BsrBinding&) = delete;
+  BsrBinding& operator=(const BsrBinding&) = delete;
+
+  const Arrays& arrays() const { return arrays_; }
+
+ private:
+  // transpose()/adjoint() swap the block dimensions, which are equal here, so
+  // the copy has A's own type in either storage order.
+  Bsm copy_;
+  Arrays arrays_{};
+};
+
+}  // namespace internal
+#endif  // EIGEN_HAS_CUSPARSE_BSR
+
+/** Sparse product expression: DeviceSparseView * DeviceMatrix → SpMVExpr.
+ * Evaluated by DeviceMatrix::operator=(SpMVExpr): dispatches to cusparseSpMV
+ * when the dense operand has one column, cusparseSpMM otherwise. */
+template <typename Scalar_>
+class SpMVExpr {
+ public:
+  using Scalar = Scalar_;
+  SpMVExpr(const DeviceSparseView<Scalar>& view, const DeviceMatrix<Scalar>& x) : view_(view), x_(x) {}
+  const DeviceSparseView<Scalar>& view() const { return view_; }
+  const DeviceMatrix<Scalar>& x() const { return x_; }
+
+ private:
+  const DeviceSparseView<Scalar>& view_;
+  const DeviceMatrix<Scalar>& x_;
+};
+
+/** Device-resident sparse matrix view. Returned by SparseContext::deviceView()
+ * for a SparseMatrix (CSC) or a BlockSparseMatrix (BSR). Lightweight handle
+ * referencing the context's cached device data.
+ *
+ * \warning One SparseContext caches one sparse matrix at a time. Any later
+ * upload through the same context — a second deviceView() or any host-input
+ * multiply — replaces the cached data and invalidates earlier views; a stale
+ * view is caught by an assert at evaluation time via a generation counter.
+ * For multiple simultaneous sparse matrices, use separate SparseContext
+ * instances (they can share a Context for same-stream execution).
+ *
+ * Supports `d_y = d_A * d_x` (SpMV) and `d_Y = d_A * d_X` (SpMM). */
+template <typename Scalar_>
+class DeviceSparseView {
+ public:
+  using Scalar = Scalar_;
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+
+  DeviceSparseView(SparseContext<Scalar>& ctx, Index rows, Index cols, uint64_t generation)
+      : ctx_(ctx), rows_(rows), cols_(cols), generation_(generation) {}
+
+  /** Sparse product expression: d_A * d_x. Evaluated by DeviceMatrix::operator=. */
+  SpMVExpr<Scalar> operator*(const DeviceMatrix<Scalar>& x) const { return SpMVExpr<Scalar>(*this, x); }
+
+  Index rows() const { return rows_; }
+  Index cols() const { return cols_; }
+  const SparseContext<Scalar>& context() const { return ctx_; }
+
+  /** Upload generation this view was created against. Used to detect stale
+   * views after the context has cached a different matrix. */
+  uint64_t generation() const { return generation_; }
+
+ private:
+  SparseContext<Scalar>& ctx_;
+  Index rows_;
+  Index cols_;
+  uint64_t generation_;
+};
+
+template <typename Scalar_>
+class SparseContext {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using SpMat = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using DenseVector = Matrix<Scalar, Dynamic, 1>;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  /** BlockSparseMatrix types the block-sparse overloads accept: `int` indices,
+   * either storage order, any block shape. internal::use_cusparse_bsr picks the
+   * upload: BSR — no host copy for `op == NoTrans` on a RowMajor matrix or
+   * `op == Trans` on a ColMajor one, a transposing (and conjugating) copy
+   * otherwise — or the scalar-level toSparse() copy on the CSC path. */
+  template <int Options, int BlockRows, int BlockCols>
+  using BlockSpMat = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>;
+
+  /** Standalone: creates own stream and cuSPARSE handle. */
+  SparseContext() : owns_handle_(true) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&stream_));
+    owns_stream_ = true;
+    EIGEN_CUSPARSE_CHECK(cusparseCreate(&handle_));
+    EIGEN_CUSPARSE_CHECK(cusparseSetStream(handle_, stream_));
+  }
+
+  /** Borrow a Context: shares stream and cuSPARSE handle.
+   * The Context must outlive this SparseContext. */
+  explicit SparseContext(Context& ctx)
+      : stream_(ctx.stream()), handle_(ctx.cusparseHandle()), owns_stream_(false), owns_handle_(false) {}
+
+  ~SparseContext() {
+    destroy_spmat_descriptor(/*checked=*/false);
+    destroy_dense_descriptors();
+    if (owns_handle_ && handle_) (void)cusparseDestroy(handle_);
+    if (owns_stream_ && stream_) (void)cudaStreamDestroy(stream_);
+  }
+
+  SparseContext(const SparseContext&) = delete;
+  SparseContext& operator=(const SparseContext&) = delete;
+
+  /** Upload a sparse matrix to device and return a lightweight view.
+   * The sparse data is uploaded immediately and cached in this context.
+   * The returned view can be used for repeated SpMV/SpMM without re-uploading.
+   * If the matrix values change, call deviceView() again to re-upload.
+   *
+   * \warning One context caches one matrix. Any later upload — another
+   * deviceView() or any host-input multiply — overwrites the previous upload
+   * and invalidates earlier views (asserted at evaluation time). For multiple
+   * simultaneous matrices, use separate SparseContext instances sharing the
+   * same Context.
+   *
+   * Supports `d_y = d_A * d_x` (SpMV) and `d_Y = d_A * d_X` (SpMM). */
+  DeviceSparseView<Scalar> deviceView(const SpMat& A) {
+    eigen_assert(A.isCompressed());
+    upload_sparse(A);
+    return DeviceSparseView<Scalar>(*this, A.rows(), A.cols(), generation_);
+  }
+
+  /** Generation counter of the currently cached sparse matrix. Bumped on
+   * every sparse upload (deviceView() or a host-input multiply). */
+  uint64_t uploadGeneration() const { return generation_; }
+
+  /** Compute y = A * x. Returns y as a new dense vector. */
+  template <typename InputType, typename Rhs>
+  DenseVector multiply(const SparseMatrixBase<InputType>& A, const MatrixBase<Rhs>& x) {
+    return multiply_host_return(A, x, GpuOp::NoTrans);
+  }
+
+  /** Compute y = alpha * op(A) * x + beta * y (in-place, host vectors). */
+  template <typename InputType, typename Rhs, typename Dest>
+  void multiply(const SparseMatrixBase<InputType>& A, const MatrixBase<Rhs>& x, MatrixBase<Dest>& y,
+                Scalar alpha = Scalar(1), Scalar beta = Scalar(0), GpuOp op = GpuOp::NoTrans) {
+    const InputType& input = A.derived();
+    internal::check_storage_index_bounds<StorageIndex>(input.rows(), input.cols(), input.nonZeros());
+    SpMat storage;
+    const SpMat& mat = internal::bind_sparse<SpMat>(input, storage);
+    multiply_host_impl(mat, x.derived(), y.derived(), alpha, beta, internal::to_cusparse_op<Scalar>(op));
+  }
+
+  /** Compute d_y = A * d_x. Device-resident dense vectors, no host transfer
+   * for x/y. The sparse matrix (values and index arrays) is re-uploaded on
+   * each call; for a fully device-resident sparse matrix use deviceView(). */
+  template <typename InputType>
+  void multiply(const SparseMatrixBase<InputType>& A, const DeviceMatrix<Scalar>& d_x, DeviceMatrix<Scalar>& d_y) {
+    multiply(A, d_x, d_y, Scalar(1), Scalar(0), GpuOp::NoTrans);
+  }
+
+  /** Compute d_y = alpha * op(A) * d_x + beta * d_y (DeviceMatrix, in-place). */
+  template <typename InputType>
+  void multiply(const SparseMatrixBase<InputType>& A, const DeviceMatrix<Scalar>& d_x, DeviceMatrix<Scalar>& d_y,
+                Scalar alpha, Scalar beta, GpuOp op = GpuOp::NoTrans) {
+    const InputType& input = A.derived();
+    internal::check_storage_index_bounds<StorageIndex>(input.rows(), input.cols(), input.nonZeros());
+    SpMat storage;
+    const SpMat& mat = internal::bind_sparse<SpMat>(input, storage);
+    upload_sparse(mat);
+    spmv_device_exec(d_x, d_y, alpha, beta, op);
+  }
+
+  /** Compute y = A^T * x (host vectors). */
+  template <typename InputType, typename Rhs>
+  DenseVector multiplyT(const SparseMatrixBase<InputType>& A, const MatrixBase<Rhs>& x) {
+    return multiply_host_return(A, x, GpuOp::Trans);
+  }
+
+  /** Compute y = A^H * x (conjugate transpose). For real Scalar this is equivalent to multiplyT. */
+  template <typename InputType, typename Rhs>
+  DenseVector multiplyAdjoint(const SparseMatrixBase<InputType>& A, const MatrixBase<Rhs>& x) {
+    return multiply_host_return(A, x, GpuOp::ConjTrans);
+  }
+
+  /** Compute Y = op(A) * X where X is a dense matrix (multiple RHS). Returns Y. */
+  template <typename InputType, typename Rhs>
+  DenseMatrix multiplyMat(const SparseMatrixBase<InputType>& A, const MatrixBase<Rhs>& X, GpuOp op = GpuOp::NoTrans) {
+    const InputType& input = A.derived();
+    internal::check_storage_index_bounds<StorageIndex>(input.rows(), input.cols(), input.nonZeros());
+    SpMat storage;
+    const SpMat& mat = internal::bind_sparse<SpMat>(input, storage);
+    const DenseMatrix rhs(X.derived());
+
+    const cusparseOperation_t cu_op = internal::to_cusparse_op<Scalar>(op);
+    const Index m = (op == GpuOp::NoTrans) ? mat.rows() : mat.cols();
+    const Index k = (op == GpuOp::NoTrans) ? mat.cols() : mat.rows();
+    eigen_assert(k == rhs.rows());
+
+    const Index n = rhs.cols();
+    if (m == 0 || n == 0 || mat.nonZeros() == 0) return DenseMatrix::Zero(m, n);
+
+    DenseMatrix Y = DenseMatrix::Zero(m, n);
+    spmm_impl(mat, rhs, Y, Scalar(1), Scalar(0), cu_op);
+    return Y;
+  }
+
+  // BlockSparseMatrix overloads: same contracts as the SparseMatrix ones,
+  // dispatched on internal::use_cusparse_bsr<BlockRows, BlockCols> to a BSR
+  // upload of op(A) or to the scalar-level CSC path.
+
+  /** Upload a block-sparse matrix and return a view; see the SparseMatrix
+   * overload for the caching contract. A ColMajor matrix bound as BSR is
+   * transposed on the host once, at upload. */
+  template <int Options, int BlockRows, int BlockCols>
+  DeviceSparseView<Scalar> deviceView(const BlockSpMat<Options, BlockRows, BlockCols>& A) {
+    return device_view_block(A, internal::use_cusparse_bsr<BlockRows, BlockCols>());
+  }
+
+  /** Compute y = A * x for a block-sparse A. Returns y as a new dense vector. */
+  template <int Options, int BlockRows, int BlockCols, typename Rhs>
+  DenseVector multiply(const BlockSpMat<Options, BlockRows, BlockCols>& A, const MatrixBase<Rhs>& x) {
+    return multiply_host_return_block(A, x, GpuOp::NoTrans);
+  }
+
+  /** Compute y = alpha * op(A) * x + beta * y (in-place, host vectors) for a block-sparse A. */
+  template <int Options, int BlockRows, int BlockCols, typename Rhs, typename Dest>
+  void multiply(const BlockSpMat<Options, BlockRows, BlockCols>& A, const MatrixBase<Rhs>& x, MatrixBase<Dest>& y,
+                Scalar alpha = Scalar(1), Scalar beta = Scalar(0), GpuOp op = GpuOp::NoTrans) {
+    multiply_host_block(A, x.derived(), y.derived(), alpha, beta, op,
+                        internal::use_cusparse_bsr<BlockRows, BlockCols>());
+  }
+
+  /** Compute d_y = A * d_x for a block-sparse A; the matrix is re-uploaded on
+   * each call, use deviceView() to upload once. */
+  template <int Options, int BlockRows, int BlockCols>
+  void multiply(const BlockSpMat<Options, BlockRows, BlockCols>& A, const DeviceMatrix<Scalar>& d_x,
+                DeviceMatrix<Scalar>& d_y) {
+    multiply(A, d_x, d_y, Scalar(1), Scalar(0), GpuOp::NoTrans);
+  }
+
+  /** Compute d_y = alpha * op(A) * d_x + beta * d_y (DeviceMatrix, in-place) for a block-sparse A. */
+  template <int Options, int BlockRows, int BlockCols>
+  void multiply(const BlockSpMat<Options, BlockRows, BlockCols>& A, const DeviceMatrix<Scalar>& d_x,
+                DeviceMatrix<Scalar>& d_y, Scalar alpha, Scalar beta, GpuOp op = GpuOp::NoTrans) {
+    multiply_device_block(A, d_x, d_y, alpha, beta, op, internal::use_cusparse_bsr<BlockRows, BlockCols>());
+  }
+
+  /** Compute y = A^T * x (host vectors) for a block-sparse A. */
+  template <int Options, int BlockRows, int BlockCols, typename Rhs>
+  DenseVector multiplyT(const BlockSpMat<Options, BlockRows, BlockCols>& A, const MatrixBase<Rhs>& x) {
+    return multiply_host_return_block(A, x, GpuOp::Trans);
+  }
+
+  /** Compute y = A^H * x for a block-sparse A. For real Scalar this is equivalent to multiplyT. */
+  template <int Options, int BlockRows, int BlockCols, typename Rhs>
+  DenseVector multiplyAdjoint(const BlockSpMat<Options, BlockRows, BlockCols>& A, const MatrixBase<Rhs>& x) {
+    return multiply_host_return_block(A, x, GpuOp::ConjTrans);
+  }
+
+  /** Compute Y = op(A) * X for a block-sparse A and a dense X (multiple RHS). Returns Y. */
+  template <int Options, int BlockRows, int BlockCols, typename Rhs>
+  DenseMatrix multiplyMat(const BlockSpMat<Options, BlockRows, BlockCols>& A, const MatrixBase<Rhs>& X,
+                          GpuOp op = GpuOp::NoTrans) {
+    return multiply_mat_block(A, X, op, internal::use_cusparse_bsr<BlockRows, BlockCols>());
+  }
+
+  cudaStream_t stream() const { return stream_; }
+
+ private:
+  cudaStream_t stream_ = nullptr;
+  cusparseHandle_t handle_ = nullptr;
+  bool owns_stream_ = false;
+  bool owns_handle_ = false;
+
+  // Cached device buffers for sparse matrix (grow-only).
+  internal::DeviceBuffer d_outerPtr_;
+  internal::DeviceBuffer d_innerIdx_;
+  internal::DeviceBuffer d_values_;
+
+  // Cached device buffers for host-API dense vectors (grow-only).
+  internal::DeviceBuffer d_x_;
+  internal::DeviceBuffer d_y_;
+
+  mutable internal::DeviceBuffer d_workspace_;
+
+  // Cached cuSPARSE sparse matrix descriptor, keyed on the scalar-level shape
+  // and nonzero count plus the block size (0 for CSC/CSR, B for BSR).
+  cusparseSpMatDescr_t spmat_desc_ = nullptr;
+  Index cached_rows_ = -1;
+  Index cached_cols_ = -1;
+  Index cached_nnz_ = -1;
+  Index cached_block_size_ = 0;
+
+  // Bumped on every sparse upload; DeviceSparseViews record it at creation so
+  // a stale view (its data replaced by a later upload) asserts at evaluation.
+  uint64_t generation_ = 0;
+
+  // Cached dense-vector/matrix descriptors, re-pointed per call and recreated
+  // only when the shape changes.
+  mutable cusparseDnVecDescr_t x_vec_desc_ = nullptr;
+  mutable cusparseDnVecDescr_t y_vec_desc_ = nullptr;
+  mutable int64_t x_vec_size_ = -1;
+  mutable int64_t y_vec_size_ = -1;
+  mutable cusparseDnMatDescr_t x_mat_desc_ = nullptr;
+  mutable cusparseDnMatDescr_t y_mat_desc_ = nullptr;
+  mutable int64_t x_mat_rows_ = -1, x_mat_cols_ = -1;
+  mutable int64_t y_mat_rows_ = -1, y_mat_cols_ = -1;
+
+  // Cached workspace-size query results, indexed by cusparseOperation_t.
+  // Invalidated when the sparse descriptor or a dense-descriptor shape changes.
+  static constexpr size_t kWsUnknown = static_cast<size_t>(-1);
+  mutable size_t spmv_ws_size_[3] = {kWsUnknown, kWsUnknown, kWsUnknown};
+  mutable size_t spmm_ws_size_[3] = {kWsUnknown, kWsUnknown, kWsUnknown};
+
+  static constexpr cusparseIndexType_t kIndexType =
+      (sizeof(StorageIndex) == 4) ? CUSPARSE_INDEX_32I : CUSPARSE_INDEX_64I;
+  static constexpr cudaDataType_t kValueType = internal::cuda_data_type<Scalar>::value;
+
+  // Empty-operand result on the host: y <- beta * y, no device work.
+  template <typename Dest>
+  static void scale_host(Dest& y, Scalar beta) {
+    if (beta == Scalar(0))
+      y.setZero();
+    else
+      y *= beta;
+  }
+
+  // Shared host-input SpMV entry: y = op(A) * x into a fresh vector.
+  template <typename InputType, typename Rhs>
+  DenseVector multiply_host_return(const SparseMatrixBase<InputType>& A, const MatrixBase<Rhs>& x, GpuOp op) {
+    const InputType& input = A.derived();
+    internal::check_storage_index_bounds<StorageIndex>(input.rows(), input.cols(), input.nonZeros());
+    SpMat storage;
+    const SpMat& mat = internal::bind_sparse<SpMat>(input, storage);
+    DenseVector y((op == GpuOp::NoTrans) ? mat.rows() : mat.cols());
+    y.setZero();
+    multiply_host_impl(mat, x.derived(), y, Scalar(1), Scalar(0), internal::to_cusparse_op<Scalar>(op));
+    return y;
+  }
+
+  template <typename RhsDerived, typename DestDerived>
+  void multiply_host_impl(const SpMat& A, const RhsDerived& x, DestDerived& y, Scalar alpha, Scalar beta,
+                          cusparseOperation_t op) {
+    eigen_assert(A.isCompressed());
+
+    const Index m = A.rows();
+    const Index n = A.cols();
+    const Index nnz = A.nonZeros();
+    const Index x_size = (op == CUSPARSE_OPERATION_NON_TRANSPOSE) ? n : m;
+    const Index y_size = (op == CUSPARSE_OPERATION_NON_TRANSPOSE) ? m : n;
+
+    eigen_assert(x.size() == x_size);
+    eigen_assert(y.size() == y_size);
+
+    if (m == 0 || n == 0 || nnz == 0) {
+      scale_host(y, beta);
+      return;
+    }
+
+    upload_sparse(A);
+    spmv_host_cached(x, y, x_size, y_size, alpha, beta, op);
+  }
+
+  // BlockSparseMatrix primitives, dispatched on use_cusparse_bsr: the true_type
+  // overloads bind op(A) as BSR (internal::BsrBinding) and run cuSPARSE with
+  // NON_TRANSPOSE, the false_type ones forward the scalar-level toSparse() copy
+  // to the CSC overloads.
+  template <typename Bsm, typename Rhs>
+  DenseVector multiply_host_return_block(const Bsm& A, const MatrixBase<Rhs>& x, GpuOp op) {
+    DenseVector y((op == GpuOp::NoTrans) ? A.rows() : A.cols());
+    y.setZero();
+    multiply_host_block(A, x.derived(), y, Scalar(1), Scalar(0), op,
+                        internal::use_cusparse_bsr<int(Bsm::BlockRows), int(Bsm::BlockCols)>());
+    return y;
+  }
+
+  template <typename Bsm>
+  DeviceSparseView<Scalar> device_view_block(const Bsm& A, std::false_type) {
+    return deviceView(SpMat(A.toSparse()));
+  }
+
+  template <typename Bsm, typename RhsDerived, typename DestDerived>
+  void multiply_host_block(const Bsm& A, const RhsDerived& x, DestDerived& y, Scalar alpha, Scalar beta, GpuOp op,
+                           std::false_type) {
+    multiply(A.toSparse(), x, y, alpha, beta, op);
+  }
+
+  template <typename Bsm>
+  void multiply_device_block(const Bsm& A, const DeviceMatrix<Scalar>& d_x, DeviceMatrix<Scalar>& d_y, Scalar alpha,
+                             Scalar beta, GpuOp op, std::false_type) {
+    multiply(A.toSparse(), d_x, d_y, alpha, beta, op);
+  }
+
+  template <typename Bsm, typename Rhs>
+  DenseMatrix multiply_mat_block(const Bsm& A, const MatrixBase<Rhs>& X, GpuOp op, std::false_type) {
+    return multiplyMat(A.toSparse(), X, op);
+  }
+
+#if EIGEN_HAS_CUSPARSE_BSR
+  template <typename Bsm>
+  DeviceSparseView<Scalar> device_view_block(const Bsm& A, std::true_type) {
+    internal::check_storage_index_bounds<StorageIndex>(A.rows(), A.cols(), A.nonZeros());
+    const internal::BsrBinding<Bsm> bound(A, GpuOp::NoTrans);
+    upload_bsr(bound.arrays());
+    return DeviceSparseView<Scalar>(*this, A.rows(), A.cols(), generation_);
+  }
+
+  template <typename Bsm, typename RhsDerived, typename DestDerived>
+  void multiply_host_block(const Bsm& A, const RhsDerived& x, DestDerived& y, Scalar alpha, Scalar beta, GpuOp op,
+                           std::true_type) {
+    internal::check_storage_index_bounds<StorageIndex>(A.rows(), A.cols(), A.nonZeros());
+    const internal::BsrBinding<Bsm> bound(A, op);
+    const internal::BsrArrays<Scalar, StorageIndex>& opA = bound.arrays();
+
+    eigen_assert(x.size() == opA.cols());
+    eigen_assert(y.size() == opA.rows());
+
+    if (opA.rows() == 0 || opA.cols() == 0 || opA.bnnz == 0) {
+      scale_host(y, beta);
+      return;
+    }
+
+    upload_bsr(opA);
+    spmv_host_cached(x, y, opA.cols(), opA.rows(), alpha, beta, CUSPARSE_OPERATION_NON_TRANSPOSE);
+  }
+
+  template <typename Bsm>
+  void multiply_device_block(const Bsm& A, const DeviceMatrix<Scalar>& d_x, DeviceMatrix<Scalar>& d_y, Scalar alpha,
+                             Scalar beta, GpuOp op, std::true_type) {
+    internal::check_storage_index_bounds<StorageIndex>(A.rows(), A.cols(), A.nonZeros());
+    const internal::BsrBinding<Bsm> bound(A, op);
+    upload_bsr(bound.arrays());
+    spmv_device_exec(d_x, d_y, alpha, beta, GpuOp::NoTrans);
+  }
+
+  template <typename Bsm, typename Rhs>
+  DenseMatrix multiply_mat_block(const Bsm& A, const MatrixBase<Rhs>& X, GpuOp op, std::true_type) {
+    internal::check_storage_index_bounds<StorageIndex>(A.rows(), A.cols(), A.nonZeros());
+    const internal::BsrBinding<Bsm> bound(A, op);
+    const internal::BsrArrays<Scalar, StorageIndex>& opA = bound.arrays();
+    const DenseMatrix rhs(X.derived());
+    eigen_assert(opA.cols() == rhs.rows());
+
+    const Index n = rhs.cols();
+    if (opA.rows() == 0 || opA.cols() == 0 || n == 0 || opA.bnnz == 0) return DenseMatrix::Zero(opA.rows(), n);
+
+    DenseMatrix Y = DenseMatrix::Zero(opA.rows(), n);
+    upload_bsr(opA);
+    spmm_host_cached(rhs, Y, opA.rows(), opA.cols(), Scalar(1), Scalar(0), CUSPARSE_OPERATION_NON_TRANSPOSE);
+    return Y;
+  }
+#endif  // EIGEN_HAS_CUSPARSE_BSR
+
+  // y = alpha * op(D) * x + beta * y against the cached upload D, staging the
+  // host vectors through d_x_ / d_y_. x_size and y_size are the column and row
+  // counts of op(D).
+  template <typename RhsDerived, typename DestDerived>
+  void spmv_host_cached(const RhsDerived& x, DestDerived& y, Index x_size, Index y_size, Scalar alpha, Scalar beta,
+                        cusparseOperation_t op) {
+    ensure_buffer(d_x_, static_cast<size_t>(x_size) * sizeof(Scalar));
+    // Ref binds in place when x is already a contiguous vector; only genuine
+    // expressions are evaluated into the Ref's internal temporary.
+    const Ref<const DenseVector> x_ref(x);
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_x_.get(), x_ref.data(), x_size * sizeof(Scalar), cudaMemcpyHostToDevice, stream_));
+
+    ensure_buffer(d_y_, static_cast<size_t>(y_size) * sizeof(Scalar));
+    if (beta != Scalar(0)) {
+      const Ref<const DenseVector> y_ref(y);
+      EIGEN_CUDA_RUNTIME_CHECK(
+          cudaMemcpyAsync(d_y_.get(), y_ref.data(), y_size * sizeof(Scalar), cudaMemcpyHostToDevice, stream_));
+    }
+
+    exec_spmv(x_size, y_size, d_x_.get(), d_y_.get(), alpha, beta, op);
+
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(y.data(), d_y_.get(), y_size * sizeof(Scalar), cudaMemcpyDeviceToHost, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+  }
+
+ public:
+  /** Execute SpMV using the already-uploaded sparse matrix (no re-upload).
+   * Used by SpMVExpr (d_y = d_A * d_x) for cached deviceView() paths.
+   * The sparse matrix must have been uploaded via deviceView() or multiply().
+   * A BSR upload describes op(A) as bound at upload time and cuSPARSE runs no
+   * transposed BSR product, so \p op must then be GpuOp::NoTrans. */
+  void spmv_device_exec(const DeviceMatrix<Scalar>& d_x, DeviceMatrix<Scalar>& d_y, Scalar alpha = Scalar(1),
+                        Scalar beta = Scalar(0), GpuOp op = GpuOp::NoTrans) const {
+    eigen_assert(spmat_desc_ && "sparse matrix not uploaded — call deviceView() or multiply() first");
+    check_op_against_upload(op);
+    // cuSPARSE SpMV: y must not alias x (undefined behavior).
+    eigen_assert(d_x.data() != d_y.data() && "SpMV: output aliases input vector");
+
+    const cusparseOperation_t cu_op = internal::to_cusparse_op<Scalar>(op);
+    const Index m = cached_rows_;
+    const Index n = cached_cols_;
+    const Index x_size = (cu_op == CUSPARSE_OPERATION_NON_TRANSPOSE) ? n : m;
+    const Index y_size = (cu_op == CUSPARSE_OPERATION_NON_TRANSPOSE) ? m : n;
+
+    eigen_assert(d_x.rows() * d_x.cols() == x_size);
+
+    if (m == 0 || n == 0 || cached_nnz_ == 0) {
+      // Empty A reduces SpMV to y <- beta*y; SparseContext owns no cuBLAS
+      // handle for the scale, so the beta != 0 case must be handled by the caller.
+      eigen_assert(beta == Scalar(0) && "SpMV with empty A and beta != 0 is unsupported; scale d_y externally");
+      if (d_y.rows() * d_y.cols() != y_size) d_y.resize(y_size, 1);
+      d_y.setZero(stream_);
+      return;
+    }
+
+    // Ensure d_y is allocated.
+    if (d_y.rows() * d_y.cols() != y_size) {
+      d_y.resize(y_size, 1);
+    }
+
+    // Wait for input data to be ready on this stream.
+    d_x.waitReady(stream_);
+    d_y.waitReady(stream_);
+
+    exec_spmv(x_size, y_size, const_cast<void*>(static_cast<const void*>(d_x.data())), static_cast<void*>(d_y.data()),
+              alpha, beta, cu_op);
+
+    d_y.recordReady(stream_);
+  }
+
+  /** Execute SpMM (d_Y = alpha * op(A) * d_X + beta * d_Y) using the
+   * already-uploaded sparse matrix. d_X / d_Y are device-resident dense
+   * column-major matrices. Used by SpMVExpr when the RHS has > 1 column.
+   * As for spmv_device_exec(), a BSR upload requires \p op == GpuOp::NoTrans. */
+  void spmm_device_exec(const DeviceMatrix<Scalar>& d_X, DeviceMatrix<Scalar>& d_Y, Scalar alpha = Scalar(1),
+                        Scalar beta = Scalar(0), GpuOp op = GpuOp::NoTrans) const {
+    eigen_assert(spmat_desc_ && "sparse matrix not uploaded — call deviceView() or multiply() first");
+    check_op_against_upload(op);
+    eigen_assert(d_X.data() != d_Y.data() && "SpMM: output aliases input matrix");
+
+    const cusparseOperation_t cu_op = internal::to_cusparse_op<Scalar>(op);
+    const bool transposed = (cu_op != CUSPARSE_OPERATION_NON_TRANSPOSE);
+    const Index m_op = transposed ? cached_cols_ : cached_rows_;
+    const Index k_op = transposed ? cached_rows_ : cached_cols_;
+    const Index n = d_X.cols();
+
+    eigen_assert(d_X.rows() == k_op);
+
+    if (m_op == 0 || n == 0 || cached_nnz_ == 0) {
+      eigen_assert(beta == Scalar(0) && "SpMM with empty A and beta != 0 is unsupported; scale d_Y externally");
+      if (d_Y.rows() != m_op || d_Y.cols() != n) d_Y.resize(m_op, n);
+      d_Y.setZero(stream_);
+      return;
+    }
+
+    if (d_Y.rows() != m_op || d_Y.cols() != n) {
+      d_Y.resize(m_op, n);
+    }
+
+    d_X.waitReady(stream_);
+    d_Y.waitReady(stream_);
+
+    exec_spmm(m_op, k_op, n, const_cast<void*>(static_cast<const void*>(d_X.data())), static_cast<void*>(d_Y.data()),
+              alpha, beta, cu_op);
+
+    d_Y.recordReady(stream_);
+  }
+
+ private:
+  // cuSPARSE 11.x's cusparseSpMM rejects CSC for matA (CSC support landed in
+  // CUDA 12.0). On 11.x we register the same buffers as CSR-of-A^T (dims
+  // swapped) and invert the user-facing op before each cuSPARSE call. On 12+
+  // we keep the natural CSC path so users pay no extra cost.
+#if !defined(CUSPARSE_VERSION) || CUSPARSE_VERSION < 12000
+  static constexpr bool kUseCsrOfTranspose = true;
+  static constexpr cusparseSpMMAlg_t kSpMMAlg = CUSPARSE_SPMM_CSR_ALG2;
+#else
+  static constexpr bool kUseCsrOfTranspose = false;
+  static constexpr cusparseSpMMAlg_t kSpMMAlg = CUSPARSE_SPMM_ALG_DEFAULT;
+#endif
+
+  // Map a user-facing op on A to the cuSPARSE op on the cached descriptor.
+  // Identity on cuSPARSE 12+ (descriptor is CSC of A, or BSR of op(A));
+  // inverted on 11.x (descriptor is CSR of A^T).
+  static cusparseOperation_t descriptor_op(cusparseOperation_t user_op) {
+    EIGEN_IF_CONSTEXPR (!kUseCsrOfTranspose) return user_op;
+    switch (user_op) {
+      case CUSPARSE_OPERATION_NON_TRANSPOSE:
+        return CUSPARSE_OPERATION_TRANSPOSE;
+      case CUSPARSE_OPERATION_TRANSPOSE:
+        return CUSPARSE_OPERATION_NON_TRANSPOSE;
+      default:
+        // CONJUGATE_TRANSPOSE on the CSR-of-A^T descriptor would compute
+        // conj(A) * x, not A^H * x — not supported via this representation.
+        eigen_assert(false && "CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE not supported on cuSPARSE < 12.0");
+        return user_op;
+    }
+  }
+
+  static int op_index(cusparseOperation_t op) {
+    switch (op) {
+      case CUSPARSE_OPERATION_TRANSPOSE:
+        return 1;
+      case CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE:
+        return 2;
+      default:
+        return 0;
+    }
+  }
+
+  void invalidate_ws_caches() const {
+    for (int i = 0; i < 3; ++i) {
+      spmv_ws_size_[i] = kWsUnknown;
+      spmm_ws_size_[i] = kWsUnknown;
+    }
+  }
+
+  // Recreate the descriptor when the size changes; otherwise just re-point it
+  // at the new device buffer (cusparseDnVecSetValues is a host-side pointer
+  // update, no GPU work).
+  void update_dnvec(cusparseDnVecDescr_t& desc, int64_t& cur_size, int64_t size, void* ptr) const {
+    if (!desc || cur_size != size) {
+      if (desc) EIGEN_CUSPARSE_CHECK(cusparseDestroyDnVec(desc));
+      EIGEN_CUSPARSE_CHECK(cusparseCreateDnVec(&desc, size, ptr, kValueType));
+      cur_size = size;
+      invalidate_ws_caches();
+    } else {
+      EIGEN_CUSPARSE_CHECK(cusparseDnVecSetValues(desc, ptr));
+    }
+  }
+
+  void update_dnmat(cusparseDnMatDescr_t& desc, int64_t& cur_rows, int64_t& cur_cols, int64_t rows, int64_t cols,
+                    void* ptr) const {
+    if (!desc || cur_rows != rows || cur_cols != cols) {
+      if (desc) EIGEN_CUSPARSE_CHECK(cusparseDestroyDnMat(desc));
+      // Column-major with ld = rows.
+      EIGEN_CUSPARSE_CHECK(cusparseCreateDnMat(&desc, rows, cols, rows, ptr, kValueType, CUSPARSE_ORDER_COL));
+      cur_rows = rows;
+      cur_cols = cols;
+      invalidate_ws_caches();
+    } else {
+      EIGEN_CUSPARSE_CHECK(cusparseDnMatSetValues(desc, ptr));
+    }
+  }
+
+  void destroy_dense_descriptors() {
+    if (x_vec_desc_) (void)cusparseDestroyDnVec(x_vec_desc_);
+    if (y_vec_desc_) (void)cusparseDestroyDnVec(y_vec_desc_);
+    if (x_mat_desc_) (void)cusparseDestroyDnMat(x_mat_desc_);
+    if (y_mat_desc_) (void)cusparseDestroyDnMat(y_mat_desc_);
+    x_vec_desc_ = y_vec_desc_ = nullptr;
+    x_mat_desc_ = y_mat_desc_ = nullptr;
+  }
+
+  void exec_spmv(Index x_size, Index y_size, void* d_x_ptr, void* d_y_ptr, Scalar alpha, Scalar beta,
+                 cusparseOperation_t op) const {
+    const cusparseOperation_t cu_op = descriptor_op(op);
+    update_dnvec(x_vec_desc_, x_vec_size_, x_size, d_x_ptr);
+    update_dnvec(y_vec_desc_, y_vec_size_, y_size, d_y_ptr);
+
+    size_t& ws_size = spmv_ws_size_[op_index(cu_op)];
+    if (ws_size == kWsUnknown) {
+      EIGEN_CUSPARSE_CHECK(cusparseSpMV_bufferSize(handle_, cu_op, &alpha, spmat_desc_, x_vec_desc_, &beta, y_vec_desc_,
+                                                   kValueType, CUSPARSE_SPMV_ALG_DEFAULT, &ws_size));
+    }
+    ensure_buffer(d_workspace_, ws_size);
+
+    EIGEN_CUSPARSE_CHECK(cusparseSpMV(handle_, cu_op, &alpha, spmat_desc_, x_vec_desc_, &beta, y_vec_desc_, kValueType,
+                                      CUSPARSE_SPMV_ALG_DEFAULT, d_workspace_.get()));
+  }
+
+  void exec_spmm(Index m_op, Index k_op, Index n, void* d_x_ptr, void* d_y_ptr, Scalar alpha, Scalar beta,
+                 cusparseOperation_t op) const {
+    const cusparseOperation_t cu_op = descriptor_op(op);
+    // X is k_op x n, Y is m_op x n (column-major, post-op shapes).
+    update_dnmat(x_mat_desc_, x_mat_rows_, x_mat_cols_, k_op, n, d_x_ptr);
+    update_dnmat(y_mat_desc_, y_mat_rows_, y_mat_cols_, m_op, n, d_y_ptr);
+
+    size_t& ws_size = spmm_ws_size_[op_index(cu_op)];
+    if (ws_size == kWsUnknown) {
+      EIGEN_CUSPARSE_CHECK(cusparseSpMM_bufferSize(handle_, cu_op, CUSPARSE_OPERATION_NON_TRANSPOSE, &alpha,
+                                                   spmat_desc_, x_mat_desc_, &beta, y_mat_desc_, kValueType, kSpMMAlg,
+                                                   &ws_size));
+    }
+    ensure_buffer(d_workspace_, ws_size);
+
+    EIGEN_CUSPARSE_CHECK(cusparseSpMM(handle_, cu_op, CUSPARSE_OPERATION_NON_TRANSPOSE, &alpha, spmat_desc_,
+                                      x_mat_desc_, &beta, y_mat_desc_, kValueType, kSpMMAlg, d_workspace_.get()));
+  }
+
+  void spmm_impl(const SpMat& A, const DenseMatrix& X, DenseMatrix& Y, Scalar alpha, Scalar beta,
+                 cusparseOperation_t op) {
+    eigen_assert(A.isCompressed());
+
+    // For op != NON_TRANSPOSE, Y = op(A) * X. The dense X / Y descriptors must
+    // describe the *post-op* shapes: X has k_op rows (= input dim of op(A)),
+    // Y has m_op rows (= output dim of op(A)).
+    const bool transposed = (op != CUSPARSE_OPERATION_NON_TRANSPOSE);
+    const Index m_op = transposed ? A.cols() : A.rows();
+    const Index k_op = transposed ? A.rows() : A.cols();
+    const Index n = X.cols();
+    const Index nnz = A.nonZeros();
+
+    if (m_op == 0 || n == 0 || k_op == 0 || nnz == 0) {
+      scale_host(Y, beta);
+      return;
+    }
+
+    upload_sparse(A);
+    spmm_host_cached(X, Y, m_op, k_op, alpha, beta, op);
+  }
+
+  // Y = alpha * op(D) * X + beta * Y against the cached upload D, staging the
+  // host matrices through d_x_ / d_y_. X is k_op x n, Y is m_op x n.
+  void spmm_host_cached(const DenseMatrix& X, DenseMatrix& Y, Index m_op, Index k_op, Scalar alpha, Scalar beta,
+                        cusparseOperation_t op) {
+    const Index n = X.cols();
+    const size_t x_bytes = static_cast<size_t>(k_op) * static_cast<size_t>(n) * sizeof(Scalar);
+    const size_t y_bytes = static_cast<size_t>(m_op) * static_cast<size_t>(n) * sizeof(Scalar);
+    ensure_buffer(d_x_, x_bytes);
+    ensure_buffer(d_y_, y_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_x_.get(), X.data(), x_bytes, cudaMemcpyHostToDevice, stream_));
+    if (beta != Scalar(0)) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_y_.get(), Y.data(), y_bytes, cudaMemcpyHostToDevice, stream_));
+    }
+
+    exec_spmm(m_op, k_op, n, d_x_.get(), d_y_.get(), alpha, beta, op);
+
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(Y.data(), d_y_.get(), y_bytes, cudaMemcpyDeviceToHost, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+  }
+
+  void upload_sparse(const SpMat& A) {
+    // cuSPARSE 12.0+ accepts CSC directly. On cuSPARSE 11.x, cusparseSpMM
+    // rejects CSC and CONJUGATE_TRANSPOSE on CSC+complex SpMV silently
+    // demotes to TRANSPOSE. We register the same CSC buffers as CSR-of-A^T
+    // (dims swapped) on 11.x and invert the op at exec time via
+    // descriptor_op() — no transpose-copy required.
+    const Index m = A.rows();
+    const Index n = A.cols();
+    const Index nnz = A.nonZeros();
+    upload_arrays(/*outer_count=*/n + 1, /*inner_count=*/nnz, /*value_count=*/nnz, A.outerIndexPtr(), A.innerIndexPtr(),
+                  A.valuePtr());
+    if (descriptor_key_matches(m, n, nnz, /*block_size=*/0)) return;
+
+    destroy_spmat_descriptor(/*checked=*/true);
+    EIGEN_IF_CONSTEXPR (kUseCsrOfTranspose) {
+      // cuSPARSE 11.x: cusparseSpMM rejects CSC for matA. CSC of A and CSR of
+      // A^T share the same buffers, so register the data as CSR-of-A^T (dims
+      // swapped) and invert the op in exec_spmv / spmm_impl via descriptor_op.
+      EIGEN_CUSPARSE_CHECK(cusparseCreateCsr(&spmat_desc_, n, m, nnz, d_outerPtr_.get(), d_innerIdx_.get(),
+                                             d_values_.get(), kIndexType, kIndexType, CUSPARSE_INDEX_BASE_ZERO,
+                                             kValueType));
+    } else {
+      EIGEN_CUSPARSE_CHECK(cusparseCreateCsc(&spmat_desc_, m, n, nnz, d_outerPtr_.get(), d_innerIdx_.get(),
+                                             d_values_.get(), kIndexType, kIndexType, CUSPARSE_INDEX_BASE_ZERO,
+                                             kValueType));
+    }
+    set_descriptor_key(m, n, nnz, /*block_size=*/0);
+  }
+
+#if EIGEN_HAS_CUSPARSE_BSR
+  void upload_bsr(const internal::BsrArrays<Scalar, StorageIndex>& opA) {
+    upload_arrays(/*outer_count=*/opA.brows + 1, /*inner_count=*/opA.bnnz, /*value_count=*/opA.nonZeros(), opA.outer,
+                  opA.inner, opA.values);
+    if (descriptor_key_matches(opA.rows(), opA.cols(), opA.nonZeros(), opA.blockSize)) return;
+
+    destroy_spmat_descriptor(/*checked=*/true);
+    // Row-major blocks: cusparseSpMM accepts no other block layout for BSR.
+    EIGEN_CUSPARSE_CHECK(cusparseCreateBsr(&spmat_desc_, opA.brows, opA.bcols, opA.bnnz, opA.blockSize, opA.blockSize,
+                                           d_outerPtr_.get(), d_innerIdx_.get(), d_values_.get(), kIndexType,
+                                           kIndexType, CUSPARSE_INDEX_BASE_ZERO, kValueType, CUSPARSE_ORDER_ROW));
+    set_descriptor_key(opA.rows(), opA.cols(), opA.nonZeros(), opA.blockSize);
+  }
+#endif  // EIGEN_HAS_CUSPARSE_BSR
+
+  void upload_arrays(Index outer_count, Index inner_count, Index value_count, const StorageIndex* host_outer,
+                     const StorageIndex* host_inner, const Scalar* host_values) {
+    const size_t outer_bytes = static_cast<size_t>(outer_count) * sizeof(StorageIndex);
+    const size_t inner_bytes = static_cast<size_t>(inner_count) * sizeof(StorageIndex);
+    const size_t val_bytes = static_cast<size_t>(value_count) * sizeof(Scalar);
+
+    // Values *and* index arrays are re-uploaded unconditionally: host pointer
+    // identity cannot detect a same-shape/same-nnz pattern rewritten in place
+    // or assigned into the same allocations (SparseMatrix reuses them), so a
+    // structure cache keyed on pointers would silently serve stale indices.
+    // Only the cuSPARSE descriptor and the workspace-size queries are cached,
+    // keyed on (rows, cols, nnz, block size). Every upload invalidates
+    // outstanding DeviceSparseViews via the generation counter.
+    ++generation_;
+    ensure_buffer(d_values_, val_bytes);
+    ensure_buffer(d_outerPtr_, outer_bytes);
+    ensure_buffer(d_innerIdx_, inner_bytes);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_values_.get(), host_values, val_bytes, cudaMemcpyHostToDevice, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_outerPtr_.get(), host_outer, outer_bytes, cudaMemcpyHostToDevice, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_innerIdx_.get(), host_inner, inner_bytes, cudaMemcpyHostToDevice, stream_));
+  }
+
+  // Same shape, nnz and format: the grow-only device buffers cannot have been
+  // reallocated, so the existing descriptor still points at the freshly
+  // written data.
+  bool descriptor_key_matches(Index m, Index n, Index nnz, Index block_size) const {
+    return m == cached_rows_ && n == cached_cols_ && nnz == cached_nnz_ && block_size == cached_block_size_;
+  }
+
+  void set_descriptor_key(Index m, Index n, Index nnz, Index block_size) {
+    cached_rows_ = m;
+    cached_cols_ = n;
+    cached_nnz_ = nnz;
+    cached_block_size_ = block_size;
+  }
+
+  // A BSR descriptor holds op(A) as bound at upload time, and cuSPARSE runs no
+  // transposed BSR product.
+  void check_op_against_upload(GpuOp op) const {
+    eigen_assert((cached_block_size_ == 0 || op == GpuOp::NoTrans) &&
+                 "cuSPARSE runs BSR products only with op == NoTrans; pass op to multiply(A, d_x, d_y, ...) instead");
+    EIGEN_UNUSED_VARIABLE(op);
+  }
+
+  // Destroy the sparse-matrix descriptor and reset the cache identity.
+  // `checked` selects assert-on-failure (mid-lifetime rebuilds) vs swallow
+  // (noexcept destructor).
+  void destroy_spmat_descriptor(bool checked) {
+    if (spmat_desc_) {
+      cusparseStatus_t s = cusparseDestroySpMat(spmat_desc_);
+      eigen_assert((!checked || s == CUSPARSE_STATUS_SUCCESS) && "cusparseDestroySpMat failed");
+      EIGEN_UNUSED_VARIABLE(s);
+      EIGEN_UNUSED_VARIABLE(checked);
+      spmat_desc_ = nullptr;
+    }
+    set_descriptor_key(-1, -1, -1, 0);
+    invalidate_ws_caches();
+  }
+
+  void ensure_buffer(internal::DeviceBuffer& buf, size_t needed) const {
+    if (needed > buf.size()) {
+      if (buf) EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+      buf = internal::DeviceBuffer(needed);
+    }
+  }
+};
+
+// Defined here because it needs the full SparseContext definition.
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>& DeviceMatrix<Scalar_>::operator=(const SpMVExpr<Scalar_>& expr) {
+  // Uses the sparse matrix already uploaded by deviceView() — no re-upload on
+  // repeated products with the same view. A stale view (the context has since
+  // uploaded again, replacing the cached data) is caught here.
+  eigen_assert(expr.view().generation() == expr.view().context().uploadGeneration() &&
+               "DeviceSparseView is stale: its SparseContext has since uploaded another sparse matrix");
+  if (expr.x().cols() <= 1) {
+    expr.view().context().spmv_device_exec(expr.x(), *this, Scalar_(1), Scalar_(0), GpuOp::NoTrans);
+  } else {
+    expr.view().context().spmm_device_exec(expr.x(), *this, Scalar_(1), Scalar_(0), GpuOp::NoTrans);
+  }
+  return *this;
+}
+
+template <typename Scalar_>
+DeviceMatrix<Scalar_>::DeviceMatrix(const SpMVExpr<Scalar_>& expr) : DeviceMatrix() {
+  *this = expr;
+}
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SPARSE_CONTEXT_H
diff --git a/contrib/Eigen/src/GPU/GpuSparseLDLT.h b/contrib/Eigen/src/GPU/GpuSparseLDLT.h
new file mode 100644
index 0000000..a174d2f
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSparseLDLT.h
@@ -0,0 +1,69 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU sparse LDL^T / LDL^H factorization via cuDSS, for symmetric indefinite and
+// Hermitian indefinite matrices.
+
+#ifndef EIGEN_GPU_SPARSE_LDLT_H
+#define EIGEN_GPU_SPARSE_LDLT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSparseSolverBase.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** GPU sparse LDL^T factorization (symmetric indefinite / Hermitian indefinite).
+ *
+ * Wraps cuDSS with CUDSS_MTYPE_SYMMETRIC (real) or CUDSS_MTYPE_HERMITIAN (complex).
+ * Uses pivoting for numerical stability.
+ *
+ * \tparam Scalar_  float, double, complex<float>, or complex<double>
+ * \tparam UpLo_    Lower (default) or Upper — which triangle of A is stored
+ */
+template <typename Scalar_, int UpLo_ = Lower>
+class SparseLDLT : public internal::SparseSolverBase<Scalar_, SparseLDLT<Scalar_, UpLo_>> {
+  using Base = internal::SparseSolverBase<Scalar_, SparseLDLT>;
+  friend Base;
+
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  SparseLDLT() = default;
+
+  /** Borrow \p ctx's stream so solves chain with other work on the same
+   * Context. \p ctx must outlive this object. */
+  explicit SparseLDLT(Context& ctx) : Base(ctx) {}
+
+  template <typename InputType>
+  explicit SparseLDLT(const SparseMatrixBase<InputType>& A) {
+    this->compute(A);
+  }
+
+  /** Borrow \p ctx's stream and factor A immediately. */
+  template <typename InputType>
+  SparseLDLT(Context& ctx, const SparseMatrixBase<InputType>& A) : Base(ctx) {
+    this->compute(A);
+  }
+
+  static constexpr bool needs_csr_conversion() { return false; }
+  static constexpr cudssMatrixType_t cudss_matrix_type() { return internal::cudss_hermitian_type<Scalar>::value; }
+  static constexpr cudssMatrixViewType_t cudss_matrix_view() {
+    return internal::cudss_view_type<UpLo, ColMajor>::value;
+  }
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SPARSE_LDLT_H
diff --git a/contrib/Eigen/src/GPU/GpuSparseLLT.h b/contrib/Eigen/src/GPU/GpuSparseLLT.h
new file mode 100644
index 0000000..c1b0cd7
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSparseLLT.h
@@ -0,0 +1,69 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU sparse Cholesky (LL^T / LL^H) via cuDSS.
+
+#ifndef EIGEN_GPU_SPARSE_LLT_H
+#define EIGEN_GPU_SPARSE_LLT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSparseSolverBase.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** GPU sparse Cholesky factorization (LL^T for real, LL^H for complex).
+ *
+ * Wraps cuDSS with CUDSS_MTYPE_SPD (real) or CUDSS_MTYPE_HPD (complex).
+ * Accepts ColMajor SparseMatrix (CSC), reinterpreted as CSR with swapped
+ * triangle view for zero-copy upload.
+ *
+ * \tparam Scalar_  float, double, complex<float>, or complex<double>
+ * \tparam UpLo_    Lower (default) or Upper — which triangle of A is stored
+ */
+template <typename Scalar_, int UpLo_ = Lower>
+class SparseLLT : public internal::SparseSolverBase<Scalar_, SparseLLT<Scalar_, UpLo_>> {
+  using Base = internal::SparseSolverBase<Scalar_, SparseLLT>;
+  friend Base;
+
+ public:
+  using Scalar = Scalar_;
+  static constexpr int UpLo = UpLo_;
+
+  SparseLLT() = default;
+
+  /** Borrow \p ctx's stream so solves chain with other work on the same
+   * Context. \p ctx must outlive this object. */
+  explicit SparseLLT(Context& ctx) : Base(ctx) {}
+
+  template <typename InputType>
+  explicit SparseLLT(const SparseMatrixBase<InputType>& A) {
+    this->compute(A);
+  }
+
+  /** Borrow \p ctx's stream and factor A immediately. */
+  template <typename InputType>
+  SparseLLT(Context& ctx, const SparseMatrixBase<InputType>& A) : Base(ctx) {
+    this->compute(A);
+  }
+
+  static constexpr bool needs_csr_conversion() { return false; }
+  static constexpr cudssMatrixType_t cudss_matrix_type() { return internal::cudss_spd_type<Scalar>::value; }
+  static constexpr cudssMatrixViewType_t cudss_matrix_view() {
+    return internal::cudss_view_type<UpLo, ColMajor>::value;
+  }
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SPARSE_LLT_H
diff --git a/contrib/Eigen/src/GPU/GpuSparseLU.h b/contrib/Eigen/src/GPU/GpuSparseLU.h
new file mode 100644
index 0000000..69541e3
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSparseLU.h
@@ -0,0 +1,66 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// GPU sparse LU factorization via cuDSS, with pivoting, for general
+// (non-symmetric) matrices.
+
+#ifndef EIGEN_GPU_SPARSE_LU_H
+#define EIGEN_GPU_SPARSE_LU_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./GpuSparseSolverBase.h"
+
+namespace Eigen {
+namespace gpu {
+
+/** GPU sparse LU factorization (general matrices).
+ *
+ * Wraps cuDSS with CUDSS_MTYPE_GENERAL and CUDSS_MVIEW_FULL.
+ * Accepts ColMajor SparseMatrix (CSC); internally converts to RowMajor
+ * CSR since cuDSS requires CSR input.
+ *
+ * \tparam Scalar_  float, double, complex<float>, or complex<double>
+ */
+template <typename Scalar_>
+class SparseLU : public internal::SparseSolverBase<Scalar_, SparseLU<Scalar_>> {
+  using Base = internal::SparseSolverBase<Scalar_, SparseLU>;
+  friend Base;
+
+ public:
+  using Scalar = Scalar_;
+
+  SparseLU() = default;
+
+  /** Borrow \p ctx's stream so solves chain with other work on the same
+   * Context. \p ctx must outlive this object. */
+  explicit SparseLU(Context& ctx) : Base(ctx) {}
+
+  template <typename InputType>
+  explicit SparseLU(const SparseMatrixBase<InputType>& A) {
+    this->compute(A);
+  }
+
+  /** Borrow \p ctx's stream and factor A immediately. */
+  template <typename InputType>
+  SparseLU(Context& ctx, const SparseMatrixBase<InputType>& A) : Base(ctx) {
+    this->compute(A);
+  }
+
+  static constexpr bool needs_csr_conversion() { return true; }
+  static constexpr cudssMatrixType_t cudss_matrix_type() { return CUDSS_MTYPE_GENERAL; }
+  static constexpr cudssMatrixViewType_t cudss_matrix_view() { return CUDSS_MVIEW_FULL; }
+};
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SPARSE_LU_H
diff --git a/contrib/Eigen/src/GPU/GpuSparseSolverBase.h b/contrib/Eigen/src/GPU/GpuSparseSolverBase.h
new file mode 100644
index 0000000..f3ba8f3
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSparseSolverBase.h
@@ -0,0 +1,668 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Common base for the GPU sparse direct solvers (LLT, LDLT, LU) via cuDSS.
+//
+// All three share one analyzePattern → factorize → solve workflow and differ only
+// in the cudssMatrixType_t and cudssMatrixViewType_t they pass to cuDSS, so this
+// CRTP base implements the workflow and derived classes supply the two types.
+//
+// Not thread-safe: concurrent calls race on the cuDSS handle, the bound stream,
+// and the cached scratch buffers. This includes concurrent solve() calls on one
+// instance, const though solve() is. Use one solver per thread.
+
+#ifndef EIGEN_GPU_SPARSE_SOLVER_BASE_H
+#define EIGEN_GPU_SPARSE_SOLVER_BASE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./CuSparseSupport.h"
+#include "./CuDssSupport.h"
+
+namespace Eigen {
+namespace gpu {
+
+// The named algorithms carry the cuDSS values, so apply_config() can
+// static_cast them. cuDSS < 0.8 names none of them, so there they are not
+// declared at all: selecting an algorithm the linked cuDSS cannot honor is a
+// compile error rather than a runtime rejection, and EIGEN_HAS_CUDSS_SOLVER_CONFIG
+// lets a caller branch on which case a build is in.
+// Default is declared either way and is a sentinel rather than a cuDSS value:
+// apply_config() skips its cudssConfigSet(), leaving the cuDSS default in place
+// without depending on its numeric value.
+
+/** Fill-reducing reordering algorithm, applied during analyzePattern().
+ * Default lets cuDSS choose; Natural disables reordering. BtfColamd and
+ * Colamd are valid for general (SparseLU) matrices only. The named
+ * algorithms are declared only for cuDSS >= 0.8. */
+enum class SparseReordering : int {
+  Default = -1,
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+  BtfColamd = CUDSS_REORDERING_ALG_BTF_COLAMD,
+  Colamd = CUDSS_REORDERING_ALG_COLAMD,
+  Amd = CUDSS_REORDERING_ALG_AMD,
+  NestedDissection = CUDSS_REORDERING_ALG_NESTED_DISSECTION,
+  Natural = CUDSS_REORDERING_ALG_NONE,
+#endif
+};
+
+/** Matching algorithm, applied during analyzePattern() to improve numerical
+ * robustness. Off by cuDSS default; primarily useful for SparseLU on
+ * indefinite or badly scaled systems. Auto lets cuDSS pick. The named
+ * algorithms are declared only for cuDSS >= 0.8. */
+enum class SparseMatching : int {
+  Default = -1,
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+  None = CUDSS_MATCHING_ALG_NONE,
+  MaxDiagCount = CUDSS_MATCHING_ALG_MAX_DIAG_COUNT,
+  MaxMinDiag = CUDSS_MATCHING_ALG_MAX_MIN_DIAG,
+  MaxMinDiagAlt = CUDSS_MATCHING_ALG_MAX_MIN_DIAG_ALT,
+  MaxDiagSum = CUDSS_MATCHING_ALG_MAX_DIAG_SUM,
+  MaxDiagProduct = CUDSS_MATCHING_ALG_MAX_DIAG_PRODUCT,
+  Auto = CUDSS_MATCHING_ALG_AUTO,
+#endif
+};
+
+/** Pivoting strategy, applied during factorize(). Default resolves per
+ * matrix type. Validity of the other values depends on the matrix type and
+ * reordering algorithm; see the cuDSS documentation for cudssPivotType_t.
+ * The named strategies are declared only for cuDSS >= 0.8. */
+enum class SparsePivoting : int {
+  Default = -1,
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+  None = CUDSS_PIVOT_NONE,
+  GlobalCol = CUDSS_PIVOT_GLOBAL_COL,
+  GlobalRow = CUDSS_PIVOT_GLOBAL_ROW,
+  Diagonal = CUDSS_PIVOT_DIAGONAL,
+  LocalBlock = CUDSS_PIVOT_LOCAL_BLOCK,
+#endif
+};
+
+/** Pass-through configuration for the cuDSS-backed sparse direct solvers
+ * (SparseLLT, SparseLDLT, SparseLU). Fields left at their defaults keep the
+ * corresponding cuDSS default, which is tuned for performance rather than
+ * maximum robustness (e.g. matching is off). Non-default fields require
+ * cuDSS >= 0.8, whose cudssReorderingAlg_t etc. name the algorithms with
+ * stable values; earlier versions declare no algorithm enumerator and accept
+ * only a default config, which EIGEN_HAS_CUDSS_SOLVER_CONFIG reports. */
+struct SparseSolverConfig {
+  SparseReordering reordering = SparseReordering::Default;
+  SparseMatching matching = SparseMatching::Default;
+  SparsePivoting pivoting = SparsePivoting::Default;
+  /** Pivot admissibility threshold in [0, 1]; negative keeps the cuDSS default. */
+  double pivotThreshold = -1.0;
+  /** Perturbation applied to near-zero pivots; negative keeps the cuDSS default. */
+  double pivotEpsilon = -1.0;
+  /** Iterative-refinement steps during solve(); negative keeps the cuDSS default (0). */
+  int refinementSteps = -1;
+  /** Iterative-refinement stopping tolerance; negative keeps the cuDSS default. */
+  double refinementTolerance = -1.0;
+  /** Let factor data spill to host memory when device memory is insufficient.
+   * Changes what analyzePattern() builds — set it before that phase. */
+  bool hybridMemory = false;
+  /** Device-memory budget in bytes for hybridMemory; negative keeps the cuDSS
+   * default heuristic, which is what cuDSS itself spells as -1. Zero is a
+   * budget of its own and is passed through. */
+  int64_t hybridMemoryDeviceLimit = -1;
+  /** Split factorization/solve work between host and device. cuDSS requires
+   * this before analysis, which it changes — set it before analyzePattern(). */
+  bool hybridExecute = false;
+
+  /** True when every field keeps the cuDSS default. */
+  bool isDefault() const {
+    return reordering == SparseReordering::Default && matching == SparseMatching::Default &&
+           pivoting == SparsePivoting::Default && pivotThreshold < 0 && pivotEpsilon < 0 && refinementSteps < 0 &&
+           refinementTolerance < 0 && !hybridMemory && hybridMemoryDeviceLimit < 0 && !hybridExecute;
+  }
+};
+
+namespace internal {
+
+/** CRTP base for GPU sparse direct solvers.
+ *
+ * \tparam Scalar_  Element type (passed explicitly to avoid incomplete-type issues with CRTP).
+ * \tparam Derived  The concrete solver class (SparseLLT, SparseLDLT, SparseLU).
+ *                  Must provide:
+ *                  - `static constexpr cudssMatrixType_t cudss_matrix_type()`
+ *                  - `static constexpr cudssMatrixViewType_t cudss_matrix_view()`
+ *                  - `static constexpr bool needs_csr_conversion()`
+ */
+template <typename Scalar_, typename Derived>
+class SparseSolverBase {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using SpMat = SparseMatrix<Scalar, ColMajor, StorageIndex>;
+  using CsrMat = SparseMatrix<Scalar, RowMajor, StorageIndex>;
+  using DenseVector = Matrix<Scalar, Dynamic, 1>;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  SparseSolverBase() { init_context(/*stream=*/nullptr, /*borrow_stream=*/false); }
+
+  /** Borrow \p ctx's stream: solver work runs on the same stream as the
+   * caller's other GPU operations (device-resident solves chain with SpMV /
+   * cuBLAS work without cross-stream event waits). The cuDSS handle itself is
+   * always owned by this solver. \p ctx must outlive this object. */
+  explicit SparseSolverBase(Context& ctx) { init_context(ctx.stream(), /*borrow_stream=*/true); }
+
+  ~SparseSolverBase() {
+    destroy_cudss_objects();
+    if (handle_) (void)cudssDestroy(handle_);
+    if (owns_stream_ && stream_) (void)cudaStreamDestroy(stream_);
+  }
+
+  SparseSolverBase(const SparseSolverBase&) = delete;
+  SparseSolverBase& operator=(const SparseSolverBase&) = delete;
+
+  /** Apply \p cfg to this solver. Most knobs are consumed by the phase they
+   * affect — reordering and matching by analyzePattern(), pivoting by
+   * factorize(), refinement by solve() — so call setConfig() before the
+   * first phase whose behavior it changes; phases already executed are
+   * unaffected.
+   *
+   * The two hybrid *modes* are the exception. cuDSS builds different analysis
+   * state for them, and documents that analysis has to be redone when hybrid
+   * memory is enabled afterwards, so hybridMemory and hybridExecute must be
+   * set before analyzePattern(). Changing either one after analysis
+   * invalidates it: analyzePattern() has to be called again before
+   * factorize(), which would otherwise consume analysis state built for a
+   * different execution and memory mode. hybridMemoryDeviceLimit is only a
+   * budget within hybridMemory and may be changed between factorizations.
+   *
+   * Non-default fields require cuDSS >= 0.8, which EIGEN_HAS_CUDSS_SOLVER_CONFIG
+   * reports. Below that, the algorithm enumerators are not declared, so
+   * selecting one does not compile; a non-default value of the remaining
+   * fields is rejected rather than applied, asserting and leaving info()
+   * reporting InvalidInput until the config is reset to default. */
+  Derived& setConfig(const SparseSolverConfig& cfg) {
+#if !EIGEN_HAS_CUDSS_SOLVER_CONFIG
+    eigen_assert(cfg.isDefault() && "SparseSolverConfig knobs require cuDSS >= 0.8");
+    if (!cfg.isDefault()) {
+      // The assert above is compiled out in release builds. Record what was
+      // asked for and fail through info() rather than factorizing with the
+      // cuDSS defaults this call meant to replace. analyzePattern() keeps
+      // failing while the stored config is one this cuDSS cannot honor.
+      config_opts_ = cfg;
+      analysis_done_ = false;
+      info_ = InvalidInput;
+      return derived();
+    }
+#endif
+
+    const bool hybrid_mode_changed =
+        cfg.hybridMemory != config_opts_.hybridMemory || cfg.hybridExecute != config_opts_.hybridExecute;
+    eigen_assert((!hybrid_mode_changed || !analysis_done_) &&
+                 "hybridMemory/hybridExecute change what analyzePattern() builds, so they must be set before it");
+
+    config_opts_ = cfg;
+    apply_config();
+
+    if (hybrid_mode_changed && analysis_done_) {
+      // The assert above is compiled out in release builds. Fail through
+      // info() rather than factorizing against the wrong analysis.
+      analysis_done_ = false;
+      info_ = InvalidInput;
+    }
+    return derived();
+  }
+
+  /** The configuration most recently passed to setConfig(). */
+  const SparseSolverConfig& config() const { return config_opts_; }
+
+  /** Symbolic analysis + numeric factorization. */
+  template <typename InputType>
+  Derived& compute(const SparseMatrixBase<InputType>& A) {
+    analyzePattern(A);
+    if (info_ == Success) {
+      factorize(A);
+    }
+    return derived();
+  }
+
+  /** Symbolic analysis only. Uploads sparsity structure to device.
+   * This phase is synchronous (blocks until complete). */
+  template <typename InputType>
+  Derived& analyzePattern(const SparseMatrixBase<InputType>& A) {
+#if !EIGEN_HAS_CUDSS_SOLVER_CONFIG
+    if (!config_opts_.isDefault()) {
+      // setConfig() refused this config; analyzing as if it had been applied
+      // would hand factorize() state built for settings the caller replaced.
+      info_ = InvalidInput;
+      analysis_done_ = false;
+      return derived();
+    }
+#endif
+
+    const InputType& input = A.derived();
+    check_storage_index_bounds<StorageIndex>(input.rows(), input.cols(), input.nonZeros());
+    eigen_assert(input.rows() == input.cols() && "GpuSparseSolver requires a square matrix");
+
+    n_ = input.rows();
+    info_ = InvalidInput;
+    analysis_done_ = false;
+
+    if (n_ == 0) {
+      nnz_ = 0;
+      info_ = Success;
+      analysis_done_ = true;
+      return derived();
+    }
+
+    // For symmetric solvers, ColMajor CSC can be reinterpreted as CSR with
+    // swapped triangle view — zero copy, except that Hermitian matrix types
+    // need the value array conjugated (see csc_upload_values). For general
+    // solvers, we must convert to actual RowMajor CSR so cuDSS sees the
+    // correct matrix, not A^T.
+    if (Derived::needs_csr_conversion()) {
+      const CsrMat csr(input);
+      nnz_ = csr.nonZeros();
+      upload_compressed(csr.outerIndexPtr(), csr.innerIndexPtr(), csr.valuePtr());
+    } else {
+      // Bind by reference when the input is already a compressed CSC matrix —
+      // no host copy.
+      SpMat storage;
+      const SpMat& csc = bind_sparse<SpMat>(input, storage);
+      nnz_ = csc.nonZeros();
+      upload_compressed(csc.outerIndexPtr(), csc.innerIndexPtr(), csc_upload_values(csc.valuePtr(), nnz_));
+    }
+    create_cudss_matrix();
+
+    if (data_) EIGEN_CUDSS_CHECK(cudssDataDestroy(handle_, data_));
+    EIGEN_CUDSS_CHECK(cudssDataCreate(handle_, &data_));
+
+    create_placeholder_dense();
+
+    EIGEN_CUDSS_CHECK(cudssExecute(handle_, CUDSS_PHASE_ANALYSIS, config_, data_, d_A_cudss_, d_x_cudss_, d_b_cudss_));
+
+    analysis_done_ = true;
+    info_ = Success;
+    return derived();
+  }
+
+  /** Numeric factorization using the symbolic analysis from analyzePattern.
+   *
+   * \warning The sparsity pattern (outerIndexPtr, innerIndexPtr) must be
+   * identical to the one passed to analyzePattern(). Only the numerical
+   * values may change. Passing a different pattern is undefined behavior.
+   * This matches the contract of CHOLMOD, UMFPACK, and cuDSS's own API.
+   *
+   * This phase is asynchronous — info() lazily synchronizes. */
+  template <typename InputType>
+  Derived& factorize(const SparseMatrixBase<InputType>& A) {
+    eigen_assert(analysis_done_ && "factorize() requires analyzePattern() first");
+    if (!analysis_done_) {
+      // Reachable in release builds whenever setConfig() invalidated the
+      // analysis rather than applying the request; see setConfig().
+      info_ = InvalidInput;
+      return derived();
+    }
+
+    if (n_ == 0) {
+      info_ = Success;
+      return derived();
+    }
+
+    // Convert to the same format used in analyzePattern. When the input is
+    // already a compressed CSC matrix (symmetric solvers), it is bound by
+    // reference — no host copy or conversion on refactorize (Hermitian types
+    // re-conjugate the value array; the pattern stays zero-copy).
+    // The temporaries must outlive the async memcpy (pageable H2D is actually
+    // synchronous w.r.t. the host, but keep them alive for clarity).
+    const InputType& input = A.derived();
+    check_storage_index_bounds<StorageIndex>(input.rows(), input.cols(), input.nonZeros());
+    eigen_assert(input.rows() == n_ && input.cols() == n_);
+
+    const Scalar* value_ptr;
+    Index value_nnz;
+    CsrMat csr_tmp;
+    SpMat csc_storage;
+    if (Derived::needs_csr_conversion()) {
+      csr_tmp = CsrMat(input);
+      value_ptr = csr_tmp.valuePtr();
+      value_nnz = csr_tmp.nonZeros();
+    } else {
+      const SpMat& csc = bind_sparse<SpMat>(input, csc_storage);
+      value_ptr = csc_upload_values(csc.valuePtr(), csc.nonZeros());
+      value_nnz = csc.nonZeros();
+    }
+    eigen_assert(value_nnz == nnz_);
+    EIGEN_UNUSED_VARIABLE(value_nnz);
+
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_values_.get(), value_ptr, static_cast<size_t>(nnz_) * sizeof(Scalar),
+                                             cudaMemcpyHostToDevice, stream_));
+
+    EIGEN_CUDSS_CHECK(cudssMatrixSetValues(d_A_cudss_, d_values_.get()));
+
+    info_ = InvalidInput;
+    info_synced_ = false;
+    EIGEN_CUDSS_CHECK(
+        cudssExecute(handle_, CUDSS_PHASE_FACTORIZATION, config_, data_, d_A_cudss_, d_x_cudss_, d_b_cudss_));
+
+    return derived();
+  }
+
+  /** Solve A * X = B (host → host). Returns X as a dense matrix.
+   * Supports single or multiple right-hand sides. */
+  template <typename Rhs>
+  DenseMatrix solve(const MatrixBase<Rhs>& B) const {
+    // Debug builds verify the factorization (info() synchronizes on the first
+    // call after factorize()); release builds skip both the check and the
+    // sync — use info() explicitly when failure must be detected.
+    eigen_assert(info() == Success && "GpuSparseSolver::solve requires a successful factorization");
+    eigen_assert(B.rows() == n_);
+
+    if (n_ == 0) return DenseMatrix(0, B.cols());
+
+    const Ref<const DenseMatrix> rhs(B.derived());
+    const int64_t nrhs = static_cast<int64_t>(rhs.cols());
+
+    // Reuse cached d_b/d_x scratch to avoid cudaMalloc/cudaFree per solve.
+    const size_t rhs_bytes = static_cast<size_t>(n_) * static_cast<size_t>(nrhs) * sizeof(Scalar);
+    ensure_solve_buffer(d_b_solve_, rhs_bytes);
+    ensure_solve_buffer(d_x_solve_, rhs_bytes);
+    internal::upload_host_matrix(static_cast<Scalar*>(d_b_solve_.get()), n_, rhs.data(), rhs.outerStride(), n_, nrhs,
+                                 stream_);
+
+    update_solve_descriptors(nrhs, d_b_solve_.get(), d_x_solve_.get());
+    EIGEN_CUDSS_CHECK(
+        cudssExecute(handle_, CUDSS_PHASE_SOLVE, config_, data_, d_A_cudss_, x_solve_cudss_, b_solve_cudss_));
+
+    DenseMatrix X(n_, rhs.cols());
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(X.data(), d_x_solve_.get(), rhs_bytes, cudaMemcpyDeviceToHost, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+
+    return X;
+  }
+
+  /** Solve A * X = B with device-resident RHS. Returns an n × nrhs
+   * DeviceMatrix that stays on device — no H2D/D2H transfer and no host
+   * synchronization (debug builds verify the factorization status first,
+   * which syncs once after each factorize()). Chain the result directly into
+   * SpMV / cuBLAS work, e.g. for iterative refinement. */
+  DeviceMatrix<Scalar> solve(const DeviceMatrix<Scalar>& d_B) const {
+    eigen_assert(info() == Success && "GpuSparseSolver::solve requires a successful factorization");
+    eigen_assert(d_B.rows() == n_);
+
+    const int64_t nrhs = static_cast<int64_t>(d_B.cols());
+    DeviceMatrix<Scalar> X(n_, d_B.cols());
+    if (n_ == 0 || nrhs == 0) return X;
+
+    d_B.waitReady(stream_);
+    update_solve_descriptors(nrhs, const_cast<Scalar*>(d_B.data()), X.data());
+    EIGEN_CUDSS_CHECK(
+        cudssExecute(handle_, CUDSS_PHASE_SOLVE, config_, data_, d_A_cudss_, x_solve_cudss_, b_solve_cudss_));
+    X.recordReady(stream_);
+    return X;
+  }
+
+  ComputationInfo info() const {
+    sync_info();
+    return info_;
+  }
+  Index rows() const { return n_; }
+  Index cols() const { return n_; }
+
+  cudaStream_t stream() const { return stream_; }
+
+ protected:
+  cudaStream_t stream_ = nullptr;
+  bool owns_stream_ = true;
+  cudssHandle_t handle_ = nullptr;
+  cudssConfig_t config_ = nullptr;
+  cudssData_t data_ = nullptr;
+  cudssMatrix_t d_A_cudss_ = nullptr;
+  cudssMatrix_t d_x_cudss_ = nullptr;
+  cudssMatrix_t d_b_cudss_ = nullptr;
+
+  DeviceBuffer d_rowPtr_;
+  DeviceBuffer d_colIdx_;
+  DeviceBuffer d_values_;
+
+  // Host staging for the conjugated value array (Hermitian zero-copy path
+  // only; see csc_upload_values). Kept as a member so it outlives the async
+  // H2D copy.
+  DenseVector conj_values_;
+
+  mutable DeviceBuffer d_b_solve_;
+  mutable DeviceBuffer d_x_solve_;
+
+  // Cached cuDSS dense descriptors for solve, re-pointed per call and
+  // recreated only when nrhs changes.
+  mutable cudssMatrix_t b_solve_cudss_ = nullptr;
+  mutable cudssMatrix_t x_solve_cudss_ = nullptr;
+  mutable int64_t solve_desc_nrhs_ = -1;
+
+  int64_t n_ = 0;
+  int64_t nnz_ = 0;
+  mutable ComputationInfo info_ = InvalidInput;
+  mutable bool info_synced_ = true;
+  bool analysis_done_ = false;
+  SparseSolverConfig config_opts_;
+
+ private:
+  Derived& derived() { return static_cast<Derived&>(*this); }
+  const Derived& derived() const { return static_cast<const Derived&>(*this); }
+
+  void init_context(cudaStream_t stream, bool borrow_stream) {
+    if (borrow_stream) {
+      // nullptr is CUDA's valid legacy default stream, so ownership cannot be
+      // inferred from the stream value.
+      stream_ = stream;
+      owns_stream_ = false;
+    } else {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&stream_));
+      owns_stream_ = true;
+    }
+    EIGEN_CUDSS_CHECK(cudssCreate(&handle_));
+    EIGEN_CUDSS_CHECK(cudssSetStream(handle_, stream_));
+    EIGEN_CUDSS_CHECK(cudssConfigCreate(&config_));
+  }
+
+  // Rebuild config_ from config_opts_. Recreating rather than mutating lets a
+  // field reset to Default restore the cuDSS default, whose numeric value is
+  // not part of the cuDSS API contract.
+  void apply_config() {
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+    if (config_) {
+      // cuDSS reads the config during execution, and both factorize() and the
+      // device-resident solve() return with their phase still queued. Retire
+      // that work before the config it is reading goes away.
+      EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+      (void)cudssConfigDestroy(config_);
+    }
+    config_ = nullptr;
+    EIGEN_CUDSS_CHECK(cudssConfigCreate(&config_));
+    const SparseSolverConfig& c = config_opts_;
+    if (c.reordering != SparseReordering::Default) {
+      const cudssReorderingAlg_t v = static_cast<cudssReorderingAlg_t>(c.reordering);
+      EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_REORDERING_ALG, &v, sizeof(v)));
+    }
+    if (c.matching != SparseMatching::Default) {
+      const cudssMatchingAlg_t v = static_cast<cudssMatchingAlg_t>(c.matching);
+      EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_MATCHING_ALG, &v, sizeof(v)));
+    }
+    if (c.pivoting != SparsePivoting::Default) {
+      const cudssPivotType_t v = static_cast<cudssPivotType_t>(c.pivoting);
+      EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_PIVOT_TYPE, &v, sizeof(v)));
+    }
+    if (c.pivotThreshold >= 0) {
+      EIGEN_CUDSS_CHECK(
+          cudssConfigSet(config_, CUDSS_CONFIG_PIVOT_THRESHOLD, &c.pivotThreshold, sizeof(c.pivotThreshold)));
+    }
+    if (c.pivotEpsilon >= 0) {
+      EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_PIVOT_EPSILON, &c.pivotEpsilon, sizeof(c.pivotEpsilon)));
+    }
+    if (c.refinementSteps >= 0) {
+      EIGEN_CUDSS_CHECK(
+          cudssConfigSet(config_, CUDSS_CONFIG_IR_N_STEPS, &c.refinementSteps, sizeof(c.refinementSteps)));
+    }
+    if (c.refinementTolerance >= 0) {
+      EIGEN_CUDSS_CHECK(
+          cudssConfigSet(config_, CUDSS_CONFIG_IR_TOL, &c.refinementTolerance, sizeof(c.refinementTolerance)));
+    }
+    if (c.hybridMemory) {
+      const int v = 1;
+      EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_HYBRID_MEMORY_MODE, &v, sizeof(v)));
+      if (c.hybridMemoryDeviceLimit >= 0) {
+        const int64_t limit = c.hybridMemoryDeviceLimit;
+        EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_HYBRID_DEVICE_MEMORY_LIMIT, &limit, sizeof(limit)));
+      }
+    }
+    if (c.hybridExecute) {
+      const int v = 1;
+      EIGEN_CUDSS_CHECK(cudssConfigSet(config_, CUDSS_CONFIG_HYBRID_EXECUTE_MODE, &v, sizeof(v)));
+    }
+#else
+    // setConfig() returns early for anything else, so there is nothing to apply.
+    eigen_internal_assert(config_opts_.isDefault());
+#endif
+  }
+
+  void ensure_solve_buffer(DeviceBuffer& buf, size_t needed) const {
+    if (needed > buf.size()) {
+      if (buf) EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream_));
+      buf = DeviceBuffer(needed);
+    }
+  }
+
+  // Recreate the solve descriptors when nrhs changes; otherwise just re-point
+  // them (cudssMatrixSetValues is a host-side pointer update).
+  void update_solve_descriptors(int64_t nrhs, void* b_ptr, void* x_ptr) const {
+    constexpr cudss_value_type_t dtype = to_cudss_data_type(cuda_data_type<Scalar>::value);
+    if (!b_solve_cudss_ || solve_desc_nrhs_ != nrhs) {
+      destroy_solve_descriptors();
+      EIGEN_CUDSS_CHECK(cudssMatrixCreateDn(&b_solve_cudss_, n_, nrhs, n_, b_ptr, dtype, CUDSS_LAYOUT_COL_MAJOR));
+      EIGEN_CUDSS_CHECK(cudssMatrixCreateDn(&x_solve_cudss_, n_, nrhs, n_, x_ptr, dtype, CUDSS_LAYOUT_COL_MAJOR));
+      solve_desc_nrhs_ = nrhs;
+    } else {
+      EIGEN_CUDSS_CHECK(cudssMatrixSetValues(b_solve_cudss_, b_ptr));
+      EIGEN_CUDSS_CHECK(cudssMatrixSetValues(x_solve_cudss_, x_ptr));
+    }
+  }
+
+  void destroy_solve_descriptors() const {
+    if (b_solve_cudss_) {
+      (void)cudssMatrixDestroy(b_solve_cudss_);
+      b_solve_cudss_ = nullptr;
+    }
+    if (x_solve_cudss_) {
+      (void)cudssMatrixDestroy(x_solve_cudss_);
+      x_solve_cudss_ = nullptr;
+    }
+    solve_desc_nrhs_ = -1;
+  }
+
+  void sync_info() const {
+    if (!info_synced_) {
+      // cudssDataGet for CUDSS_DATA_INFO synchronizes the stream internally,
+      // so an explicit cudaStreamSynchronize would be redundant.
+      int cudss_info = 0;
+      EIGEN_CUDSS_CHECK(cudssDataGet(handle_, data_, CUDSS_DATA_INFO, &cudss_info, sizeof(cudss_info), nullptr));
+      info_ = (cudss_info == 0) ? Success : NumericalIssue;
+      info_synced_ = true;
+    }
+  }
+
+  // Destructor-only cleanup: there is no useful recovery path for failures.
+  void destroy_cudss_objects() {
+    // Same lifetime rule as apply_config(): the queued phase reads the data
+    // handle and the matrix descriptors as well as the config. Unchecked
+    // because this runs from the destructor.
+    (void)cudaStreamSynchronize(stream_);
+    destroy_solve_descriptors();
+    if (d_A_cudss_) {
+      (void)cudssMatrixDestroy(d_A_cudss_);
+      d_A_cudss_ = nullptr;
+    }
+    if (d_x_cudss_) {
+      (void)cudssMatrixDestroy(d_x_cudss_);
+      d_x_cudss_ = nullptr;
+    }
+    if (d_b_cudss_) {
+      (void)cudssMatrixDestroy(d_b_cudss_);
+      d_b_cudss_ = nullptr;
+    }
+    if (data_) {
+      (void)cudssDataDestroy(handle_, data_);
+      data_ = nullptr;
+    }
+    if (config_) {
+      (void)cudssConfigDestroy(config_);
+      config_ = nullptr;
+    }
+  }
+
+  // The zero-copy CSC-as-CSR reinterpretation hands cuDSS the stored triangle
+  // of A^T. Real symmetric types are unaffected (A^T = A), but the Hermitian
+  // types need the triangle of A, whose entries are the conjugates of A^T's.
+  static constexpr bool needs_value_conjugation() {
+    return Derived::cudss_matrix_type() == CUDSS_MTYPE_HPD || Derived::cudss_matrix_type() == CUDSS_MTYPE_HERMITIAN;
+  }
+
+  // Value array for the zero-copy CSC-as-CSR path: conjugated into
+  // conj_values_ for Hermitian matrix types, passed through otherwise. The
+  // pattern arrays remain zero-copy either way.
+  const Scalar* csc_upload_values(const Scalar* values, Index nnz) {
+    if (!needs_value_conjugation()) return values;
+    conj_values_ = Map<const DenseVector>(values, nnz).conjugate();
+    return conj_values_.data();
+  }
+
+  void upload_compressed(const StorageIndex* outer, const StorageIndex* inner, const Scalar* values) {
+    const size_t rowptr_bytes = static_cast<size_t>(n_ + 1) * sizeof(StorageIndex);
+    const size_t colidx_bytes = static_cast<size_t>(nnz_) * sizeof(StorageIndex);
+    const size_t values_bytes = static_cast<size_t>(nnz_) * sizeof(Scalar);
+
+    d_rowPtr_ = DeviceBuffer(rowptr_bytes);
+    d_colIdx_ = DeviceBuffer(colidx_bytes);
+    d_values_ = DeviceBuffer(values_bytes);
+
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_rowPtr_.get(), outer, rowptr_bytes, cudaMemcpyHostToDevice, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_colIdx_.get(), inner, colidx_bytes, cudaMemcpyHostToDevice, stream_));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(d_values_.get(), values, values_bytes, cudaMemcpyHostToDevice, stream_));
+  }
+
+  void create_cudss_matrix() {
+    if (d_A_cudss_) EIGEN_CUDSS_CHECK(cudssMatrixDestroy(d_A_cudss_));
+
+    constexpr cudss_value_type_t idx_type = to_cudss_data_type(cudss_index_type<StorageIndex>::value);
+    constexpr cudss_value_type_t val_type = to_cudss_data_type(cuda_data_type<Scalar>::value);
+    constexpr cudssMatrixType_t mtype = Derived::cudss_matrix_type();
+    constexpr cudssMatrixViewType_t mview = Derived::cudss_matrix_view();
+
+#if defined(CUDSS_VERSION) && CUDSS_VERSION >= 800
+    // cuDSS 0.8 split the index type into separate offset/index type params.
+    EIGEN_CUDSS_CHECK(cudssMatrixCreateCsr(&d_A_cudss_, n_, n_, nnz_, d_rowPtr_.get(),
+                                           /*rowEnd=*/nullptr, d_colIdx_.get(), d_values_.get(), idx_type, idx_type,
+                                           val_type, mtype, mview, CUDSS_BASE_ZERO));
+#else
+    EIGEN_CUDSS_CHECK(cudssMatrixCreateCsr(&d_A_cudss_, n_, n_, nnz_, d_rowPtr_.get(),
+                                           /*rowEnd=*/nullptr, d_colIdx_.get(), d_values_.get(), idx_type, val_type,
+                                           mtype, mview, CUDSS_BASE_ZERO));
+#endif
+  }
+
+  void create_placeholder_dense() {
+    // A new analysis may change n_, so the cached solve descriptors are stale.
+    destroy_solve_descriptors();
+    if (d_x_cudss_) EIGEN_CUDSS_CHECK(cudssMatrixDestroy(d_x_cudss_));
+    if (d_b_cudss_) EIGEN_CUDSS_CHECK(cudssMatrixDestroy(d_b_cudss_));
+    constexpr cudss_value_type_t dtype = to_cudss_data_type(cuda_data_type<Scalar>::value);
+    EIGEN_CUDSS_CHECK(cudssMatrixCreateDn(&d_x_cudss_, n_, 1, n_, nullptr, dtype, CUDSS_LAYOUT_COL_MAJOR));
+    EIGEN_CUDSS_CHECK(cudssMatrixCreateDn(&d_b_cudss_, n_, 1, n_, nullptr, dtype, CUDSS_LAYOUT_COL_MAJOR));
+  }
+};
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SPARSE_SOLVER_BASE_H
diff --git a/contrib/Eigen/src/GPU/GpuSupport.h b/contrib/Eigen/src/GPU/GpuSupport.h
new file mode 100644
index 0000000..ef0ee6b
--- /dev/null
+++ b/contrib/Eigen/src/GPU/GpuSupport.h
@@ -0,0 +1,386 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Generic CUDA runtime support shared by all GPU library integrations.
+// Depends only on <cuda_runtime.h>; no NVIDIA library headers.
+
+#ifndef EIGEN_GPU_SUPPORT_H
+#define EIGEN_GPU_SUPPORT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <cuda_runtime.h>
+#include <vector>
+
+#include <limits>
+#include <memory>
+#include <type_traits>
+
+namespace Eigen {
+namespace gpu {
+// Transpose/adjoint flag for BLAS-, solver-, and sparse-style calls. Each
+// library's support header maps it to its own enum (cublasOperation_t,
+// cusparseOperation_t, ...) via a to_<lib>_op() helper.
+enum class GpuOp { NoTrans, Trans, ConjTrans };
+
+namespace internal {
+// Aborts via eigen_assert on failure, and eigen_assert throws where it is so
+// configured, so this must not be used in a destructor or any other noexcept
+// function: there the throw would call std::terminate.
+#define EIGEN_CUDA_RUNTIME_CHECK(expr)                             \
+  do {                                                             \
+    cudaError_t _e = (expr);                                       \
+    eigen_assert(_e == cudaSuccess && "CUDA runtime call failed"); \
+  } while (0)
+
+// cuBLAS and the legacy cuSOLVER APIs take dimensions and leading dimensions as
+// 32-bit `int`, while Eigen's Index is 64-bit by default and GPU allocations can
+// exceed INT_MAX in one dimension. Narrow through this helper at every such call
+// site so an out-of-range value asserts instead of silently overflowing.
+inline int to_blas_int(int64_t v) {
+  eigen_assert(v >= 0 && v <= static_cast<int64_t>((std::numeric_limits<int>::max)()) &&
+               "dimension exceeds the int range supported by cuBLAS / cuSOLVER");
+  return static_cast<int>(v);
+}
+
+// cudaMallocAsync / cudaFreeAsync (CUDA 11.2+) allocate from a stream-ordered
+// memory pool: both are cheap enqueues instead of the device-wide
+// synchronization performed by cudaMalloc / cudaFree. All module allocations
+// go through device_malloc / device_free on the *legacy default stream*:
+// legacy-stream ordering guarantees that work enqueued later on any blocking
+// stream observes the allocation, and that a free waits for all previously
+// enqueued work on blocking streams — the same lifetime guarantees callers
+// got from cudaMalloc / cudaFree, minus the host stalls.
+//
+// Caveat: streams created with cudaStreamNonBlocking do not synchronize with
+// the legacy stream. When borrowing such a stream (gpu::Context(stream)),
+// define EIGEN_GPU_NO_STREAM_ORDERED_ALLOC to fall back to cudaMalloc/cudaFree.
+//
+// Support is detected once per process, from the device current at first use.
+
+inline bool device_supports_memory_pools() {
+#ifdef EIGEN_GPU_NO_STREAM_ORDERED_ALLOC
+  return false;
+#else
+  static const bool supported = [] {
+    int device = 0;
+    if (cudaGetDevice(&device) != cudaSuccess) return false;
+    int v = 0;
+    if (cudaDeviceGetAttribute(&v, cudaDevAttrMemoryPoolsSupported, device) != cudaSuccess) return false;
+    if (v == 0) return false;
+    // Keep freed memory in the pool instead of trimming at every stream
+    // synchronize — repeated alloc/free cycles (temporaries in loops) then
+    // recycle at user-space speed.
+    cudaMemPool_t pool = nullptr;
+    if (cudaDeviceGetDefaultMemPool(&pool, device) == cudaSuccess) {
+      // The attribute value type is cuuint64_t; use a same-size stand-in to
+      // avoid requiring the driver-API header.
+      unsigned long long threshold = ~0ULL;
+      (void)cudaMemPoolSetAttribute(pool, cudaMemPoolAttrReleaseThreshold, &threshold);
+    }
+    return true;
+  }();
+  return supported;
+#endif
+}
+
+inline void* device_malloc(size_t bytes) {
+  void* p = nullptr;
+  if (device_supports_memory_pools()) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMallocAsync(&p, bytes, /*legacy default stream*/ nullptr));
+  } else {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&p, bytes));
+  }
+  return p;
+}
+
+inline void device_free(void* p) noexcept {
+  if (!p) return;
+  if (device_supports_memory_pools()) {
+    (void)cudaFreeAsync(p, /*legacy default stream*/ nullptr);
+  } else {
+    (void)cudaFree(p);
+  }
+}
+
+struct CudaFreeDeleter {
+  // When `borrow == true`, the unique_ptr does not free the pointer. Used by
+  // DeviceMatrix::view() to wrap a non-owning device pointer with the same
+  // smart-pointer machinery as owning storage, without changing the type.
+  bool borrow = false;
+  void operator()(void* p) const noexcept {
+    if (p && !borrow) device_free(p);
+  }
+};
+
+struct CudaFreeHostDeleter {
+  void operator()(void* p) const noexcept {
+    if (p) (void)cudaFreeHost(p);
+  }
+};
+
+// RAII CUDA stream; the ownership flag supports borrowed, caller-owned streams.
+struct CudaStreamDeleter {
+  bool owns = true;
+  void operator()(cudaStream_t s) const noexcept {
+    if (owns && s) (void)cudaStreamDestroy(s);
+  }
+};
+using UniqueStream = std::unique_ptr<std::remove_pointer_t<cudaStream_t>, CudaStreamDeleter>;
+
+// Recycles allocations up to kSmallBufferThreshold bytes (e.g. DeviceScalar) to
+// avoid cudaMalloc/cudaFree overhead on devices without memory pools; where
+// cudaMallocAsync exists it is both stream-ordered and cheaper than this pool's
+// release event, so DeviceBuffer bypasses the pool there (bench_overhead:
+// CudaMallocAsyncFree vs PoolAllocFree). Larger allocations always bypass it.
+// Invariant: a block is recycled only after the device has retired every
+// operation enqueued before its release on any blocking stream: deallocate()
+// records an event on the legacy default stream (the ordering device_free
+// relies on), the free list stays in release order, and events on one stream
+// retire in order, so allocate() scans until the first pending entry.
+template <size_t SmallBufferThreshold = 256, size_t MaxPoolSize = 64>
+struct DeviceBufferPool {
+  static constexpr size_t kSmallBufferThreshold = SmallBufferThreshold;
+  static constexpr size_t kMaxPoolSize = MaxPoolSize;
+
+  struct Entry {
+    void* ptr;
+    size_t bytes;
+    cudaEvent_t release_event;
+  };
+
+  // Lifetime marker for the thread-local pool. thread_local destruction runs
+  // in reverse construction order, so a long-lived object holding pooled
+  // buffers (e.g. the thread-local gpu::Context, or a static) can be
+  // destroyed *after* the pool. The marker is trivially destructible — it
+  // stays readable during TLS teardown — letting the deleter fall back to a
+  // direct device_free once the pool is gone instead of touching a destroyed
+  // vector.
+  enum class State : signed char { kNotConstructed = 0, kAlive = 1, kDestroyed = 2 };
+
+  static State& threadState() {
+    thread_local State state = State::kNotConstructed;
+    return state;
+  }
+
+  DeviceBufferPool() { threadState() = State::kAlive; }
+
+  ~DeviceBufferPool() {
+    for (const Entry& entry : free_list_) freeBlock(entry.ptr, entry.release_event);
+    for (cudaEvent_t event : spare_events_) (void)cudaEventDestroy(event);
+    threadState() = State::kDestroyed;
+  }
+
+  // First fit among the retired blocks, oldest release first; the first pending
+  // entry ends the scan because every later one is pending too.
+  void* allocate(size_t bytes) {
+    for (auto it = free_list_.begin(); it != free_list_.end(); ++it) {
+      if (cudaEventQuery(it->release_event) != cudaSuccess) break;
+      if (it->bytes >= bytes) {
+        void* p = it->ptr;
+        spare_events_.push_back(it->release_event);
+        free_list_.erase(it);
+        return p;
+      }
+    }
+    return device_malloc(bytes);
+  }
+
+  // Called from a noexcept deleter: every failure falls back to device_free.
+  void deallocate(void* p, size_t bytes) noexcept {
+    if (free_list_.size() >= kMaxPoolSize) {
+      device_free(p);
+      return;
+    }
+    cudaEvent_t release_event = acquireEvent();
+    if (release_event == nullptr) {
+      device_free(p);
+      return;
+    }
+    if (cudaEventRecord(release_event, /*legacy default stream*/ nullptr) != cudaSuccess) {
+      freeBlock(p, release_event);
+      return;
+    }
+    free_list_.push_back({p, bytes, release_event});
+  }
+
+  static DeviceBufferPool& threadLocal() {
+    thread_local DeviceBufferPool pool;
+    return pool;
+  }
+
+ private:
+  // Returns a spare event, or a newly created one; nullptr if creation fails.
+  cudaEvent_t acquireEvent() noexcept {
+    if (!spare_events_.empty()) {
+      cudaEvent_t event = spare_events_.back();
+      spare_events_.pop_back();
+      return event;
+    }
+    cudaEvent_t event = nullptr;
+    if (cudaEventCreateWithFlags(&event, cudaEventDisableTiming) != cudaSuccess) return nullptr;
+    return event;
+  }
+
+  // Gives up a block and the event tracking its release. Destroying a pending
+  // event is non-blocking; the runtime defers it until the event completes.
+  static void freeBlock(void* p, cudaEvent_t release_event) noexcept {
+    (void)cudaEventDestroy(release_event);
+    device_free(p);
+  }
+
+  std::vector<Entry> free_list_;
+  // Events of recycled entries; free_list_.size() + spare_events_.size() <= kMaxPoolSize.
+  std::vector<cudaEvent_t> spare_events_;
+};
+
+// Stateful deleter that returns pooled buffers to the thread-local pool and
+// device_free's the rest. size==0 means "always device_free" (adopted pointers
+// and allocations that went straight to device_malloc).
+struct PooledCudaFreeDeleter {
+  size_t size = 0;
+
+  void operator()(void* p) const noexcept {
+    if (!p) return;
+    if (size > 0 && size <= DeviceBufferPool<>::kSmallBufferThreshold &&
+        DeviceBufferPool<>::threadState() == DeviceBufferPool<>::State::kAlive) {
+      DeviceBufferPool<>::threadLocal().deallocate(p, size);
+    } else {
+      device_free(p);
+    }
+  }
+};
+
+/** \brief Internal RAII owner for an untyped GPU device allocation. */
+class DeviceBuffer {
+ public:
+  DeviceBuffer() = default;
+
+  explicit DeviceBuffer(size_t bytes) : bytes_(bytes) {
+    if (bytes > 0) {
+      // The pool serves small blocks only on the cudaMalloc fallback path, and
+      // not once its thread_local has been destroyed (allocation from a
+      // static/TLS destructor). A deleter size of 0 keeps the other
+      // allocations on the direct device_free path.
+      const bool pooled = bytes <= DeviceBufferPool<>::kSmallBufferThreshold && !device_supports_memory_pools() &&
+                          DeviceBufferPool<>::threadState() != DeviceBufferPool<>::State::kDestroyed;
+      void* p = pooled ? DeviceBufferPool<>::threadLocal().allocate(bytes) : device_malloc(bytes);
+      ptr_ = std::unique_ptr<void, PooledCudaFreeDeleter>(p, PooledCudaFreeDeleter{pooled ? bytes : 0});
+    }
+  }
+
+  // Explicit moves so a moved-from buffer reports size() == 0 (callers use
+  // size() for grow-only reuse decisions; a stale size on a null buffer would
+  // suppress the reallocation).
+  DeviceBuffer(DeviceBuffer&& o) noexcept : ptr_(std::move(o.ptr_)), bytes_(o.bytes_) { o.bytes_ = 0; }
+  DeviceBuffer& operator=(DeviceBuffer&& o) noexcept {
+    if (this != &o) {
+      ptr_ = std::move(o.ptr_);
+      bytes_ = o.bytes_;
+      o.bytes_ = 0;
+    }
+    return *this;
+  }
+
+  void* get() const noexcept { return ptr_.get(); }
+  void* release() noexcept {
+    bytes_ = 0;
+    return ptr_.release();
+  }
+  explicit operator bool() const noexcept { return static_cast<bool>(ptr_); }
+
+  /** Logical allocation size in bytes, tracked for adopted pointers as well. */
+  size_t size() const noexcept { return bytes_; }
+
+  // Adopt an existing device pointer of `bytes` usable bytes. Caller
+  // relinquishes ownership. Adopted buffers bypass the pool on destruction
+  // (deleter size == 0).
+  static DeviceBuffer adopt(void* p, size_t bytes) noexcept {
+    DeviceBuffer b;
+    b.ptr_ = std::unique_ptr<void, PooledCudaFreeDeleter>(p, PooledCudaFreeDeleter{});
+    b.bytes_ = p ? bytes : 0;
+    return b;
+  }
+
+ private:
+  std::unique_ptr<void, PooledCudaFreeDeleter> ptr_;
+  size_t bytes_ = 0;
+};
+
+// cudaMemcpyAsync only overlaps with compute when the host side is pinned, so
+// async D2H staging goes through this buffer.
+class PinnedHostBuffer {
+ public:
+  PinnedHostBuffer() = default;
+
+  explicit PinnedHostBuffer(size_t bytes) {
+    if (bytes > 0) {
+      void* p = nullptr;
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMallocHost(&p, bytes));
+      ptr_.reset(p);
+    }
+  }
+
+  void* get() const noexcept { return ptr_.get(); }
+  explicit operator bool() const noexcept { return static_cast<bool>(ptr_); }
+
+ private:
+  std::unique_ptr<void, CudaFreeHostDeleter> ptr_;
+};
+
+// Upload a column-major host matrix whose strides are in elements. Ref<const
+// PlainMatrix> can bind any outer stride in place. Use a 2D DMA for ordinary
+// padded layouts; copy legal negative or overlapping Eigen strides one
+// contiguous column at a time because CUDA cannot express them as a pitch.
+template <typename Scalar>
+void upload_host_matrix(Scalar* dst, Index dst_outer_stride, const Scalar* src, Index src_outer_stride, Index rows,
+                        Index cols, cudaStream_t stream) {
+  if (rows <= 0 || cols <= 0) return;
+  eigen_assert(dst_outer_stride >= rows);
+  const size_t column_bytes = static_cast<size_t>(rows) * sizeof(Scalar);
+  if (src_outer_stride >= rows) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpy2DAsync(dst, static_cast<size_t>(dst_outer_stride) * sizeof(Scalar), src,
+                                               static_cast<size_t>(src_outer_stride) * sizeof(Scalar), column_bytes,
+                                               static_cast<size_t>(cols), cudaMemcpyHostToDevice, stream));
+  } else {
+    for (Index col = 0; col < cols; ++col) {
+      EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(dst + col * dst_outer_stride, src + col * src_outer_stride, column_bytes,
+                                               cudaMemcpyHostToDevice, stream));
+    }
+  }
+}
+
+// cudaDataType_t lives in library_types.h, pulled in transitively by
+// cuda_runtime.h, so this trait needs no NVIDIA library header of its own.
+template <typename Scalar>
+struct cuda_data_type;
+
+template <>
+struct cuda_data_type<float> {
+  static constexpr cudaDataType_t value = CUDA_R_32F;
+};
+template <>
+struct cuda_data_type<double> {
+  static constexpr cudaDataType_t value = CUDA_R_64F;
+};
+template <>
+struct cuda_data_type<std::complex<float>> {
+  static constexpr cudaDataType_t value = CUDA_C_32F;
+};
+template <>
+struct cuda_data_type<std::complex<double>> {
+  static constexpr cudaDataType_t value = CUDA_C_64F;
+};
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_SUPPORT_H
diff --git a/contrib/Eigen/src/GPU/InternalHeaderCheck.h b/contrib/Eigen/src/GPU/InternalHeaderCheck.h
new file mode 100644
index 0000000..d0f7eef
--- /dev/null
+++ b/contrib/Eigen/src/GPU/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GPU_MODULE_H
+#error "Please include contrib/Eigen/GPU instead of including headers inside the src/GPU directory directly."
+#endif
diff --git a/contrib/Eigen/src/GPU/Meta.h b/contrib/Eigen/src/GPU/Meta.h
new file mode 100644
index 0000000..c483220
--- /dev/null
+++ b/contrib/Eigen/src/GPU/Meta.h
@@ -0,0 +1,40 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GPU_META_H
+#define EIGEN_GPU_META_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+#include <type_traits>
+
+namespace Eigen {
+namespace gpu {
+namespace internal {
+
+template <typename T>
+using require_t = std::enable_if_t<std::decay_t<T>::value, int>;
+
+template <typename T>
+using require_not_t = std::enable_if_t<!std::decay_t<T>::value, int>;
+
+template <typename T1, typename T2>
+using require_same_t = require_t<std::is_same<std::decay_t<T1>, std::decay_t<T2>>>;
+
+template <typename T1, typename T2>
+using require_not_same_t = require_not_t<std::is_same<std::decay_t<T1>, std::decay_t<T2>>>;
+
+template <bool... Values>
+using require_all_t = require_t<Eigen::internal::reduce_all<Values...>>;
+
+}  // namespace internal
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_META_H
diff --git a/contrib/Eigen/src/GPU/README.md b/contrib/Eigen/src/GPU/README.md
new file mode 100644
index 0000000..45e91b3
--- /dev/null
+++ b/contrib/Eigen/src/GPU/README.md
@@ -0,0 +1,1239 @@
+# Eigen GPU Module (`contrib/Eigen/GPU`)
+
+GPU-accelerated linear algebra for Eigen users, dispatching to NVIDIA CUDA
+Math Libraries (cuBLAS, cuSOLVER, cuFFT, cuSPARSE, cuDSS). Requires CUDA 11.4+;
+cuDSS features require CUDA 12.0+ and a separate cuDSS install. Header-only.
+
+This module dispatches rather than reimplements, so numerical behavior,
+supported shapes and scalar types, and performance characteristics are the
+vendor libraries'. Their documentation is the reference for anything this file
+does not state:
+
+| Library | Used for | Documentation |
+|---------|----------|---------------|
+| CUDA Toolkit | streams, memory, error codes | <https://docs.nvidia.com/cuda/> |
+| cuBLAS (incl. cuBLASLt) | `DeviceMatrix` products, BLAS-1 | <https://docs.nvidia.com/cuda/cublas/> |
+| cuSOLVER | dense LLT / LU / QR / SVD / EVD | <https://docs.nvidia.com/cuda/cusolver/> |
+| cuSPARSE | SpMV / SpMM (CSC and BSR) | <https://docs.nvidia.com/cuda/cusparse/> |
+| cuFFT | `gpu::FFT` | <https://docs.nvidia.com/cuda/cufft/> |
+| NPP | device-side scalar and coefficient-wise arithmetic | <https://docs.nvidia.com/cuda/npp/> |
+| cuDSS | sparse direct solvers (separate install) | <https://docs.nvidia.com/cuda/cudss/> |
+
+## Why this module
+
+Eigen is the linear algebra foundation for a large ecosystem of C++ projects
+in robotics (ROS, Drake, MoveIt, Pinocchio), computer vision (OpenCV, COLMAP,
+Open3D), scientific computing (Ceres, Stan), and beyond. Many of these
+projects run on GPU-equipped hardware but cannot use GPUs for Eigen operations
+without dropping down to raw CUDA library APIs.
+
+GPU sparse solvers are a particularly acute gap. Sparse factorization is the
+bottleneck in SLAM, bundle adjustment, FEM, and nonlinear optimization --
+exactly the workloads where GPU acceleration matters most. Downstream projects
+like [Ceres](https://github.com/ceres-solver/ceres-solver/issues/1151) and
+[COLMAP](https://github.com/colmap/colmap/issues/4018) have open requests for
+GPU-accelerated sparse solvers, and third-party projects like
+[cholespy](https://github.com/rgl-epfl/cholespy) exist specifically because
+Eigen lacks them. The `contrib/Eigen/GPU` module provides GPU sparse Cholesky, LDL^T,
+and LU factorization via cuDSS, alongside dense solvers (cuSOLVER), matrix
+products (cuBLAS), FFT (cuFFT), and sparse matrix-vector products (cuSPARSE).
+
+Existing Eigen users should be able to move performance-critical dense or
+sparse linear algebra to the GPU with minimal code changes and without
+learning CUDA library APIs directly.
+
+## Design philosophy
+
+**CPU and GPU coexist.** There is no global compile-time switch that replaces
+CPU implementations (unlike `EIGEN_USE_LAPACKE`). Users choose GPU solvers
+explicitly -- `gpu::LLT<double>` vs `Eigen::LLT<MatrixXd>`,
+`gpu::SparseLLT<double>` vs `SimplicialLLT<SparseMatrix<double>>` -- and both
+coexist in the same binary.
+This also lets users keep the factored matrix on device across multiple solves,
+something impossible with compile-time replacement.
+
+**Familiar syntax.** GPU operations use the same expression patterns as CPU
+Eigen. Here is a side-by-side comparison:
+
+```cpp
+// ---- CPU (Eigen) ----               // ---- GPU (contrib/Eigen/GPU) ----
+#include <Eigen/Dense>                  #define EIGEN_USE_GPU
+                                        #include <contrib/Eigen/GPU>
+
+// Dense
+MatrixXd A = ...;                       auto d_A = gpu::DeviceMatrix<double>::fromHost(A);
+MatrixXd B = ...;                       auto d_B = gpu::DeviceMatrix<double>::fromHost(B);
+
+MatrixXd C = A * B;                     gpu::DeviceMatrix<double> d_C = d_A * d_B;
+MatrixXd X = A.llt().solve(B);          gpu::DeviceMatrix<double> d_X = d_A.llt().solve(d_B);
+
+                                        MatrixXd X = d_X.toHost();
+
+// Sparse (using SpMat = SparseMatrix<double>)
+SimplicialLLT<SpMat> llt(A);            gpu::SparseLLT<double> llt(A);
+VectorXd x = llt.solve(b);              VectorXd x = llt.solve(b);
+```
+
+The GPU version reads like CPU Eigen with explicit upload/download for dense
+operations, and an almost identical API for sparse solvers. Expressions can
+copy-initialize a `DeviceMatrix` directly (as above), scalar factors accept
+plain literals (`2 * d_A`, `d_A / 2`, `-d_A`), and unsupported expressions are
+compile errors.
+
+**Standalone module.** `contrib/Eigen/GPU` does not modify or depend on Eigen's Core
+expression template system (`MatrixBase`, `CwiseBinaryOp`, etc.).
+`DeviceMatrix` is not an Eigen expression type and does not inherit from
+`MatrixBase`. The expression layer is a thin compile-time dispatch where every
+supported expression maps to a single NVIDIA library call. There is no
+coefficient-level evaluation, lazy fusion, or packet operations.
+
+**Interoperability where useful.** `DeviceMatrix` provides the same operator
+signatures as `Matrix` for common vector operations: `+=`, `-=`, `*=`,
+`dot()`, `squaredNorm()`, `norm()`, `setZero()`, and `noalias()`. This makes
+`DeviceMatrix` usable as a drop-in `VectorType` in Eigen algorithm templates
+that rely on these operations. For example, Eigen's `conjugate_gradient()`
+template works with `DeviceMatrix` with a single typedef change -- no
+modifications to the algorithm or the expression template system. Conjugate
+gradient is just the motivating example; we are open to expanding operator
+coverage as needed to support other high-level Eigen algorithms on the GPU.
+
+**Explicit over implicit.** Host-device transfers, stream management, and
+library handle lifetimes are visible in the API. There are no hidden
+allocations or synchronizations except where documented (e.g., `toHost()` must
+synchronize to deliver data to the host).
+
+## Key concepts
+
+### `gpu::DeviceMatrix<Scalar>`
+
+A typed RAII wrapper for a dense column-major matrix in GPU device memory.
+This is the GPU counterpart of Eigen's `MatrixX<Scalar>`. A vector is simply
+a `DeviceMatrix` with one column. All public GPU classes live in `namespace
+Eigen::gpu`.
+
+```cpp
+// Upload from host
+auto d_A = gpu::DeviceMatrix<double>::fromHost(A);
+
+// Allocate uninitialized
+gpu::DeviceMatrix<double> d_C(m, n);
+
+// Download to host
+MatrixXd C = d_C.toHost();
+
+// Async download (returns a future)
+auto transfer = d_C.toHostAsync();
+// ... do other work ...
+MatrixXd C = transfer.get();
+```
+
+`DeviceMatrix` supports expression methods that mirror Eigen's API:
+`adjoint()`, `transpose()`, `triangularView<UpLo>()`,
+`selfadjointView<UpLo>()`, `llt()`, `lu()`. These return lightweight
+expression objects that are evaluated when assigned.
+
+For BLAS Level-1 operations, `DeviceMatrix` also provides `dot()`, `norm()`,
+`squaredNorm()`, `setZero()`, `noalias()`, and arithmetic operators
+(`+=`, `-=`, `*=`) that dispatch to cuBLAS `axpy`, `nrm2`, `dot`, `scal`,
+and `geam`. These are the operations needed by iterative solvers.
+
+### `gpu::DeviceScalar<Scalar>`
+
+A device-resident scalar value. Reductions like `dot()`, `norm()`, and
+`squaredNorm()` return `DeviceScalar` instead of a host scalar, deferring
+the host synchronization until the value is actually needed:
+
+```cpp
+auto dot_val = d_x.dot(d_y);          // DeviceScalar -- no sync
+auto norm_sq = d_r.squaredNorm();      // DeviceScalar -- no sync
+Scalar alpha = dot_val / norm_sq;      // sync here (implicit conversion)
+d_x += alpha * d_p;                    // host scalar * DeviceMatrix (axpy)
+```
+
+Division between `DeviceScalar` values (real types only) is performed on
+device via NPP, avoiding extra synchronizations. Small device allocations
+(including `DeviceScalar`) go through the stream-ordered allocator like every
+other block when the device has memory pools; on the `cudaMalloc` fallback
+path they are recycled through a thread-local `DeviceBufferPool` instead, to
+avoid `cudaMalloc`/`cudaFree` overhead in tight loops.
+Pool contract: a released block is recycled only after the device has retired
+every operation enqueued before the release on any blocking stream, so pooled
+buffers may move between the streams of one thread. The release is tracked by
+an event on the legacy default stream, the same ordering the stream-ordered
+allocator relies on. The pool is thread-local, so sharing a pooled buffer
+across threads needs external synchronization, and `cudaStreamNonBlocking`
+streams are outside the guarantee.
+
+### `gpu::Context`
+
+Every GPU operation needs a CUDA stream and library handles (cuBLAS eagerly,
+cuSOLVER / cuBLASLt / cuSPARSE lazily on first use). `gpu::Context` bundles
+these together. A single `Context` is not thread-safe -- use one per thread
+(or external synchronization), since the underlying NVIDIA library handles
+are not thread-safe per handle.
+
+For simple usage, you don't need to create one -- a per-thread default context
+is created lazily on first use:
+
+```cpp
+// These use the thread-local default context automatically
+d_C = d_A * d_B;
+d_X = d_A.llt().solve(d_B);
+```
+
+For concurrent multi-stream execution, create explicit contexts:
+
+```cpp
+gpu::Context ctx1, ctx2;
+d_C1.device(ctx1) = d_A1 * d_B1;   // runs on stream 1
+d_C2.device(ctx2) = d_A2 * d_B2;   // runs on stream 2 (concurrently)
+```
+
+To integrate with existing CUDA code, borrow an existing stream:
+
+```cpp
+gpu::Context ctx(my_existing_stream);  // wraps stream, does not take ownership
+```
+
+To override the thread-local default (e.g., in CG where all ops share one
+context):
+
+```cpp
+gpu::Context ctx;
+gpu::Context::setThreadLocal(&ctx);    // all threadLocal() calls return ctx
+// ... GPU operations ...
+gpu::Context::setThreadLocal(nullptr); // restore lazy-created default
+```
+
+### Linking {#eigen_gpu_linking}
+
+The module is header-only, but each feature pulls in the corresponding NVIDIA
+library at link time. cuSOLVER, cuBLASLt, and cuSPARSE are created lazily on
+first use, so a translation unit that only uses cuBLAS or cuFFT does not need
+to link the others:
+
+| Feature                                 | Link flags                |
+|-----------------------------------------|---------------------------|
+| `DeviceMatrix`, GEMM, TRSM, SYMM, SYRK  | `-lcublas -lcublasLt`     |
+| Dense solvers (LLT, LU, QR, SVD, EVD)   | `-lcusolver -lcublas`     |
+| FFT (`gpu::FFT`)                        | `-lcufft -lcublas`        |
+| SpMV / SpMM (`gpu::SparseContext`)      | `-lcusparse -lcublas`     |
+| Sparse direct solvers (cuDSS)           | `-lcudss -lcublas`        |
+
+cuBLAS is required by `DeviceMatrix` itself (every `Context` creates a cuBLAS
+handle eagerly) and is also a runtime dependency of cuDSS, so it is the one
+constant. cuDSS additionally requires `EIGEN_CUDSS` to be defined before
+including `contrib/Eigen/GPU`.
+
+## Usage
+
+### Matrix operations (cuBLAS)
+
+Products dispatch to [cuBLAS](https://docs.nvidia.com/cuda/cublas/), GEMM
+through its cuBLASLt API; see [Precision control](#eigen_gpu_precision) for which
+compute type that selects.
+
+```cpp
+auto d_A = gpu::DeviceMatrix<double>::fromHost(A);
+auto d_B = gpu::DeviceMatrix<double>::fromHost(B);
+
+// GEMM: C = A * B, C = A^H * B, C = A * B^T, ...
+gpu::DeviceMatrix<double> d_C = d_A * d_B;
+d_C = d_A.adjoint() * d_B;
+d_C = d_A * d_B.transpose();
+
+// Scaled and accumulated
+d_C += 2.0 * d_A * d_B;             // alpha=2, beta=1
+d_C -= d_A * d_B;                   // alpha=-1, beta=1
+d_C.device(ctx) -= d_A * d_B;       // same, on an explicit stream
+
+// Triangular solve (TRSM)
+d_X = d_A.triangularView<Lower>().solve(d_B);
+
+// Symmetric/Hermitian multiply (SYMM/HEMM)
+d_C = d_A.selfadjointView<Lower>() * d_B;
+
+// Rank-k update (SYRK/HERK)
+d_C.selfadjointView<Lower>().rankUpdate(d_A);  // C += A * A^H
+```
+
+### BLAS Level-1 operations
+
+Dot products, norms and vector arithmetic map to the corresponding
+[cuBLAS](https://docs.nvidia.com/cuda/cublas/) Level-1 routines, except for
+device-side scalar arithmetic, which uses the signal-processing functions of
+[NPP](https://docs.nvidia.com/cuda/npp/).
+
+```cpp
+// Dot product and norms (return DeviceScalar -- no sync until read)
+auto dot_val = d_x.dot(d_y);          // cublasDdot / cublasCdotc
+auto norm_val = d_r.norm();            // cublasDnrm2
+double n = norm_val;                   // implicit conversion triggers sync
+
+// Vector arithmetic (cuBLAS axpy / geam)
+d_x += alpha * d_p;                    // axpy: x = x + alpha * p
+d_x -= alpha * d_p;                    // axpy: x = x - alpha * p
+d_x *= alpha;                          // scal: x = alpha * x
+d_r.setZero();                         // cudaMemsetAsync
+
+// DeviceScalar arithmetic (stays on device, real types only)
+auto alpha = absNew / dot_val;         // device-side division via NPP
+d_x += alpha * d_p;                    // DeviceScalar * DeviceMatrix (axpy with device pointer)
+
+// Matrix add/subtract/scale (cuBLAS geam)
+gpu::DeviceMatrix<double> d_C = d_A + d_B;       // C = A + B
+d_C = d_A + 2.0 * d_B;                          // C = A + 2*B
+d_C = d_A - d_B;                                 // C = A - B
+d_C = 2 * d_A - 3 * d_B;                        // scaled both sides, int literals fine
+d_C = -d_A;                                      // unary minus
+d_C = d_A / 2.0;                                 // divide by scalar
+d_C = 0.5 * d_C;                                 // in-place rescale (aliasing-safe)
+```
+
+### Dense solvers (cuSOLVER)
+
+Backed by the dense part of [cuSOLVER](https://docs.nvidia.com/cuda/cusolver/)
+(cuSolverDN), whose documentation defines what each factorization returns and
+when it reports a numerical failure.
+
+**One-shot expression syntax** -- "one-shot" means factorization and solve
+run as a single fused call with no persistent factorization object; each
+evaluation re-factorizes:
+
+```cpp
+// Cholesky solve (potrf + potrs)
+gpu::DeviceMatrix<double> d_X = d_A.llt().solve(d_B);
+
+// LU solve (getrf + getrs)
+d_Y = d_A.lu().solve(d_B);
+```
+
+Scratch for the one-shot form (factor copy, cuSOLVER workspace, info words)
+lives in the `gpu::Context` and grows monotonically — repeated one-shot solves
+perform no per-call allocations. In debug builds each call verifies the
+factorization status (one stream synchronization); release builds
+(`EIGEN_NO_DEBUG`/`NDEBUG`) skip the check *and* the sync, making the
+expression fully asynchronous — use the cached `gpu::LLT` / `gpu::LU` classes
+and `info()` when numerical failure must be detected.
+
+**Cached factorization** -- Factor once, solve many times:
+
+```cpp
+gpu::LLT<double> llt;
+llt.compute(d_A);                    // factorize (async)
+if (llt.info() != Success) { ... }   // lazy sync on first info() call
+auto d_X1 = llt.solve(d_B1);        // reuses factor (async)
+auto d_X2 = llt.solve(d_B2);        // reuses factor (async)
+auto d_X3 = llt.solve(std::move(d_B3));  // in-place: consumes RHS, no copy/alloc
+MatrixXd X2 = d_X2.toHost();
+
+// Bind a solver to an existing Context: work runs on ctx's stream with its
+// handles, so it chains with GEMM/SpMV on the same Context without
+// cross-stream event waits. All five dense solvers (LLT, LU, QR, SVD,
+// SelfAdjointEigenSolver) support this.
+gpu::Context ctx;
+gpu::LLT<double> llt_ctx(ctx, d_A);
+
+// LU with transpose solve
+gpu::LU<double> lu;
+lu.compute(d_A);
+auto d_Y = lu.solve(d_B, gpu::GpuOp::Trans);           // A^T Y = B
+
+// QR solve (overdetermined least squares)
+gpu::QR<double> qr;
+qr.compute(d_A);                     // factorize on device (async)
+auto d_X = qr.solve(d_B);           // Q^H * B via ormqr, then trsm on R
+MatrixXd X = d_X.toHost();
+
+// SVD (results downloaded on access)
+gpu::SVD<double> svd;
+svd.compute(d_A, ComputeThinU | ComputeThinV);
+VectorXd S = svd.singularValues();   // downloads to host
+MatrixXd U = svd.matrixU();          // downloads to host
+MatrixXd V = svd.matrixV();          // V (matches JacobiSVD)
+MatrixXd VT = svd.matrixVT();        // V^T (matches cuSOLVER)
+
+// SVD: device-side views (no D2H transfer; svd must outlive the views)
+auto d_S = svd.d_singularValues();   // DeviceMatrix view of singular values
+auto d_U = svd.d_matrixU();          // DeviceMatrix view of U
+auto d_VT = svd.d_matrixVT();        // DeviceMatrix view of V^T
+
+// Self-adjoint eigenvalue decomposition
+gpu::SelfAdjointEigenSolver<double> es;
+es.compute(d_A);
+VectorXd eigenvals = es.eigenvalues();    // downloads to host
+MatrixXd eigenvecs = es.eigenvectors();   // downloads to host
+auto d_W = es.d_eigenvalues();            // DeviceMatrix view of eigenvalues
+auto d_V = es.d_eigenvectors();           // DeviceMatrix view of eigenvectors
+```
+
+The cached API keeps the factored matrix on device, avoiding redundant
+host-device transfers and re-factorizations. All five solvers accept
+`compute(DeviceMatrix&&)` to adopt the input and factor it in place with no
+copy (for QR/SVD with m < n the internal transpose still copies), and all five
+can bind to a `gpu::Context` to share its stream and handles. All solvers also
+accept host dense expressions directly as a convenience (e.g.,
+`gpu::LLT<double> llt(A)` or `qr.solve(B)`), which handles upload/download
+internally. Host `compute()` finishes its upload before returning, while
+factorization remains asynchronous. The `d_*` accessors
+on `gpu::SVD` and `gpu::SelfAdjointEigenSolver` return non-owning
+`DeviceMatrix` views so downstream cuBLAS/cuSOLVER work can chain without
+round-tripping through host memory.
+
+### Sparse direct solvers (cuDSS)
+
+Requires [cuDSS](https://docs.nvidia.com/cuda/cudss/) (separate install, CUDA
+12.0+), which is distributed outside the CUDA Toolkit and versioned separately
+from it. Define `EIGEN_CUDSS` before including `contrib/Eigen/GPU`; see
+[Linking](#eigen_gpu_linking) for link flags.
+
+```cpp
+SparseMatrix<double> A = ...;  // symmetric positive definite
+VectorXd b = ...;
+
+// Sparse Cholesky -- one-liner
+gpu::SparseLLT<double> llt(A);
+VectorXd x = llt.solve(b);
+
+// Three-phase workflow for repeated solves with the same sparsity pattern
+gpu::SparseLLT<double> llt;
+llt.analyzePattern(A);               // symbolic analysis (once)
+llt.factorize(A);                    // numeric factorization
+VectorXd x = llt.solve(b);
+llt.factorize(A_new_values);         // refactorize (reuses symbolic analysis)
+VectorXd x2 = llt.solve(b);
+
+// Sparse LDL^T (symmetric indefinite)
+gpu::SparseLDLT<double> ldlt(A);
+VectorXd x = ldlt.solve(b);
+
+// Sparse LU (general non-symmetric)
+gpu::SparseLU<double> lu(A);
+VectorXd x = lu.solve(b);
+
+// Bind to an existing Context (same stream as SpMV / cuBLAS work) and solve
+// with a device-resident RHS — result stays on device, no host sync:
+gpu::Context ctx;
+gpu::SparseLLT<double> llt_ctx(ctx, A);
+auto d_b = gpu::DeviceMatrix<double>::fromHost(b, ctx.stream());
+gpu::DeviceMatrix<double> d_x = llt_ctx.solve(d_b);
+```
+
+#### Solver configuration (cuDSS >= 0.8)
+
+`gpu::SparseSolverConfig` passes cuDSS tuning knobs through to the solver:
+fill-reducing reordering, matching, pivoting strategy / threshold / epsilon,
+iterative refinement, and the hybrid host/device memory and execute modes.
+Fields left at their defaults keep the cuDSS defaults, which favor speed over
+maximum robustness — for badly scaled or nearly singular systems, consider
+enabling matching and iterative refinement:
+
+```cpp
+gpu::SparseSolverConfig cfg;
+cfg.reordering = gpu::SparseReordering::Amd;
+cfg.matching = gpu::SparseMatching::Auto;   // off by cuDSS default
+cfg.refinementSteps = 2;                    // iterative refinement in solve()
+gpu::SparseLU<double> lu;
+lu.setConfig(cfg);                          // before compute(): reordering and
+lu.compute(A);                              // matching apply at analysis time
+VectorXd x = lu.solve(b);
+```
+
+Each knob is consumed by the phase it affects (reordering/matching by
+`analyzePattern()`, pivoting by `factorize()`, refinement by `solve()`), so
+`setConfig()` must run before the first phase whose behavior it changes.
+
+Every field is a pass-through, so which values are admissible for a given matrix
+type — and what each one does — is cuDSS's contract, not ours:
+[cuDSS Data Types](https://docs.nvidia.com/cuda/cudss/types.html) documents
+`cudssConfigParam_t` and the `cudssReorderingAlg_t` / `cudssMatchingAlg_t` /
+`cudssPivotType_t` values these enums mirror, and
+[cuDSS Advanced Features](https://docs.nvidia.com/cuda/cudss/advanced_features.html)
+describes the hybrid host/device memory and execute modes.
+
+cuDSS < 0.8 names none of these algorithms. There the `SparseReordering`,
+`SparseMatching` and `SparsePivoting` enumerators other than `Default` are not
+declared, so selecting one is a compile error rather than a request the linked
+cuDSS cannot honor. The remaining fields — thresholds, refinement, the hybrid
+modes — still exist, and `setConfig()` refuses any non-default value of them: it
+asserts, and `info()` reports `InvalidInput` until the config is reset to
+default, so the request cannot be silently downgraded to the cuDSS defaults.
+`EIGEN_HAS_CUDSS_SOLVER_CONFIG` is 1 or 0 accordingly, for callers that need to
+branch at compile time.
+
+### FFT (cuFFT)
+
+Plans and data layouts are [cuFFT](https://docs.nvidia.com/cuda/cufft/)'s. The
+scaling convention is not: cuFFT leaves its transforms unnormalized, and
+`gpu::FFT` applies the 1/n on the inverse so that `inv(fwd(x)) == x`, matching
+`contrib/Eigen/FFT`.
+
+```cpp
+gpu::FFT<float> fft;                // shares stream + cuBLAS with the
+                                    // thread-local default Context
+gpu::Context ctx;
+gpu::FFT<float> fft_on_ctx(ctx);    // share stream + cuBLAS with an
+                                    // explicit Context (e.g. for
+                                    // multi-stream pipelines)
+
+// 1D complex-to-complex
+VectorXcf X = fft.fwd(x);           // forward
+VectorXcf y = fft.inv(X);           // inverse (scaled by 1/n)
+
+// 1D real-to-complex / complex-to-real
+VectorXcf R = fft.fwd(r);           // returns n/2+1 complex (half-spectrum)
+VectorXf  s = fft.invReal(R, n);    // C2R inverse, caller specifies n
+
+// 2D complex-to-complex
+MatrixXcf B = fft.fwd2(A);         // 2D forward
+MatrixXcf C = fft.inv2(B);         // 2D inverse (scaled by 1/(rows*cols))
+
+// Plans are cached and reused across calls with the same size/type.
+
+// Device-resident transforms: DeviceMatrix in/out, no host transfer, no sync.
+gpu::DeviceMatrix<std::complex<float>> d_X, d_y;
+fft.fwd(d_x, d_X);                  // 1D C2C forward (d_x: complex column vector)
+fft.inv(d_X, d_y);                  // 1D C2C inverse (scaled by 1/n)
+fft.fwd(d_r, d_R);                  // 1D R2C (d_r: real column vector)
+fft.invReal(d_R, d_s, n);           // 1D C2R (input preserved)
+fft.fwd2(d_A, d_B);                 // 2D C2C forward
+fft.inv2(d_B, d_C);                 // 2D C2C inverse
+```
+
+### Sparse matrix-vector multiply (cuSPARSE)
+
+Uses the [cuSPARSE](https://docs.nvidia.com/cuda/cusparse/) generic API
+(`cusparseSpMV` / `cusparseSpMM`), which fixes the supported index and value
+type combinations.
+
+```cpp
+SparseMatrix<double> A = ...;
+VectorXd x = ...;
+
+// Host vectors (upload/download handled internally)
+gpu::SparseContext<double> spmv;
+VectorXd y = spmv.multiply(A, x);           // y = A * x
+VectorXd z = spmv.multiplyT(A, x);          // z = A^T * x
+spmv.multiply(A, x, y, 2.0, 1.0);           // y = 2*A*x + y
+spmv.multiply(A, x, y, 1.0, 0.0,            // y = A^H * x (Hermitian SpMV)
+              gpu::GpuOp::ConjTrans);
+
+// Multiple RHS (SpMM)
+MatrixXd Y = spmv.multiplyMat(A, X);                      // Y = A * X
+MatrixXd Z = spmv.multiplyMat(A, X, gpu::GpuOp::Trans);   // Z = A^T * X
+
+// Device-resident SpMV / SpMM (sparse matrix cached on device)
+gpu::Context ctx;
+gpu::SparseContext<double> spmv_dev(ctx);   // share gpu::Context for same-stream
+auto d_A = spmv_dev.deviceView(A);          // upload sparse matrix once
+d_y = d_A * d_x;                            // SpMV, stays on device
+d_Y = d_A * d_X;                            // SpMM when the RHS has > 1 column
+```
+
+Host-input calls re-upload the sparse values *and* index arrays on every call
+(host pointer identity cannot detect a pattern rewritten in place or assigned
+into the same allocations, so the structure is never assumed unchanged). The
+cuSPARSE descriptors and workspace-size queries are cached across calls with
+matching shapes; `deviceView()` is the upload-once path. A `DeviceSparseView`
+carries a generation counter — using a view after any later upload through its
+context asserts instead of silently multiplying by the wrong matrix.
+
+#### Block sparse matrices (BSR)
+
+Every `SparseContext` entry point above also accepts a `BlockSparseMatrix`.
+Square blocks of size at least 2 upload in cuSPARSE's BSR (block sparse row)
+format on cuSPARSE 12.6.3 (CUDA 13.0 Update 1) or newer, where the generic
+SpMV and SpMM run on BSR descriptors; `EIGEN_HAS_CUSPARSE_BSR` is 1 there and
+0 on older toolkits. Any other block shape, and every `BlockSparseMatrix` on an
+older toolkit, takes the CSC path instead: the matrix is expanded with
+`toSparse()` on the host, once per host-input call or once per `deviceView()`,
+so source compatibility does not depend on the toolkit.
+
+```cpp
+BlockSparseMatrix<double, RowMajor, 3, 3> A = ...;   // 3x3 blocks, block-row storage
+VectorXd y = spmv.multiply(A, x);                    // y = A * x, no host copy
+VectorXd z = spmv.multiplyT(A, x);                   // z = A^T * x, transposed on the host
+MatrixXd Y = spmv.multiplyMat(A, X);                 // SpMM
+
+auto d_A = spmv_dev.deviceView(A);                   // upload once as BSR
+d_y = d_A * d_x;                                     // SpMV / SpMM, stays on device
+```
+
+cuSPARSE multiplies a BSR descriptor only as `op == NoTrans` with row-major
+blocks (`CUSPARSE_ORDER_ROW`), so the op is applied on the host rather than
+passed to the library. A `RowMajor` matrix is BSR of itself and uploads
+without a host copy for `NoTrans`; a `ColMajor` one — column-major blocks in
+block-column order — is BSR of its transpose and uploads without a copy for
+`Trans` (and `ConjTrans` on real scalars). Every other op / storage-order
+combination transposes (and conjugates) the matrix on the host first, once per
+host-input call or once per `deviceView()`. `spmv_device_exec()` and
+`spmm_device_exec()` consequently accept only `NoTrans` against a BSR upload
+(debug builds assert); a `BlockSparseMatrix` on the CSC path passes the op to
+cuSPARSE like a `SparseMatrix`.
+
+The CSC fallback exists because cuSPARSE rejects rectangular blocks at
+descriptor creation and runs no BSR SpMV on 1 x 1 blocks;
+`internal::use_cusparse_bsr<BlockRows, BlockCols>` is the exact selector. The
+`int` index type and the `int` limits on dimensions and nonzeros are as for
+`SparseMatrix`.
+
+### Eigen algorithm interop (example: Conjugate gradient)
+
+The BLAS-1 operators and `DeviceSparseView` make `DeviceMatrix` usable as a
+vector type in GPU implementations of algorithms like conjugate gradient.
+Conjugate gradient is the motivating example -- the GPU CG mirrors Eigen's
+`conjugate_gradient()` line for line, with only one host sync per iteration
+(the convergence check). All scalar intermediates (`alpha`, `beta`, `absNew`)
+stay on device as `DeviceScalar` values:
+
+```cpp
+gpu::Context ctx;
+gpu::Context::setThreadLocal(&ctx);
+gpu::SparseContext<double> spmv(ctx);
+auto mat = spmv.deviceView(A);              // upload sparse matrix once
+
+auto rhs = gpu::DeviceMatrix<double>::fromHost(b, ctx.stream());
+gpu::DeviceMatrix<double> x(n, 1);
+x.setZero();
+gpu::DeviceMatrix<double> residual(n, 1);
+residual.copyFrom(ctx, rhs);                // r = b (x=0)
+gpu::DeviceMatrix<double> p(n, 1);
+p.copyFrom(ctx, residual);                  // p = r
+gpu::DeviceMatrix<double> z(n, 1), tmp(n, 1);
+
+auto absNew = residual.dot(p);              // DeviceScalar -- no sync
+
+while (i < maxIters) {
+  tmp.noalias() = mat * p;                   // SpMV, device-resident
+
+  auto alpha = absNew / p.dot(tmp);          // DeviceScalar / DeviceScalar -- no sync
+
+  x += alpha * p;                            // DeviceScalar * DeviceMatrix axpy -- no sync
+  residual -= alpha * tmp;                   // DeviceScalar * DeviceMatrix axpy -- no sync
+
+  residualNorm2 = residual.squaredNorm();    // THE one sync per iteration
+  if (residualNorm2 < threshold) break;
+
+  z.copyFrom(ctx, residual);                 // no preconditioner: z = r
+  auto absOld = std::move(absNew);           // no sync, no alloc
+  absNew = residual.dot(z);                  // DeviceScalar -- no sync
+  auto beta = absNew / absOld;               // DeviceScalar / DeviceScalar -- no sync
+
+  p *= beta;                                 // DeviceScalar scal -- no sync
+  p += z;                                    // axpy -- no sync
+}
+MatrixXd result = x.toHost();
+```
+
+### Precision control {#eigen_gpu_precision}
+
+GEMM dispatch routes through `cublasLtMatmul`. The compute type is selected
+per scalar via the `cuda_compute_type` trait in `CuBlasSupport.h`, gated by
+two compile-time macros:
+
+| Macro | Effect |
+|---|---|
+| (default) | `CUBLAS_COMPUTE_32F` / `CUBLAS_COMPUTE_64F`. cublasLt heuristics may pick tensor-core algorithms; on `sm_80+` doubles can land on Ozaki-emulated tensor cores. |
+| `EIGEN_CUDA_TF32` | `CUBLAS_COMPUTE_32F_FAST_TF32` for `float` and `complex<float>` (~2x faster, 10-bit mantissa). No effect on `double` / `complex<double>`. |
+| `EIGEN_NO_CUDA_TENSOR_OPS` | Pedantic compute types (`CUBLAS_COMPUTE_*_PEDANTIC`) for every scalar — disables tensor-core algorithms. Use for bit-exact reproducibility. Takes precedence over `EIGEN_CUDA_TF32`. |
+
+These are independent of cuBLAS's runtime `cublasSetMathMode()` /
+`CUBLAS_TF32_OVERRIDE` controls; the cublasLt path keys off the compile-time
+compute type instead. The `cublasGemmEx` fallback (used when cublasLt's
+heuristic returns no candidate) honors `EIGEN_NO_CUDA_TENSOR_OPS` via its
+algorithm hint (`CUBLAS_GEMM_DEFAULT` vs `CUBLAS_GEMM_DEFAULT_TENSOR_OP`).
+
+### Stream control and async execution
+
+Operations are asynchronous by default. The compute-solve chain runs without
+host synchronization until you need a result on the host:
+
+```text
+fromHost(A) --sync-->  compute() --async-->  solve() --async-->  toHost()
+   H2D                  potrf                 potrs                D2H
+                                                                   sync
+```
+
+Mandatory sync points:
+- `fromHost()` -- Synchronizes to complete the upload before returning
+- `toHost()` / `HostTransfer::get()` -- Must deliver data to host
+- `info()` -- Must read the factorization status
+- `DeviceScalar` implicit conversion -- Downloads scalar from device
+
+Debug-only sync points (compiled out under `EIGEN_NO_DEBUG`/`NDEBUG`): every
+solver `solve()` and accessor verifies `info() == Success` via `eigen_assert`,
+which forces one stream synchronization the first time after each
+`compute()`/`factorize()`. Release builds perform no such check — call
+`info()` explicitly where failure detection matters. `gpu::SVD`'s device
+solve additionally downloads the singular values once per (truncation,
+lambda) setting to build its cached inverse diagonal.
+
+**Cross-stream safety** is automatic. `DeviceMatrix` tracks write completion
+via CUDA events. When a matrix written on stream A is read on stream B, the
+module automatically inserts `cudaStreamWaitEvent`. Same-stream operations
+skip the wait (CUDA guarantees in-order execution within a stream).
+
+**Device memory allocation is stream-ordered.** All module allocations go
+through `cudaMallocAsync` / `cudaFreeAsync` on devices that support memory
+pools (detected at runtime; `cudaMalloc`/`cudaFree` fallback otherwise, or
+force the fallback with `EIGEN_GPU_NO_STREAM_ORDERED_ALLOC` — required when
+borrowing `cudaStreamNonBlocking` streams, which do not synchronize with the
+legacy stream the allocator uses for ordering). Consequences:
+
+- Allocating/destroying `DeviceMatrix` temporaries no longer performs a
+  device-wide synchronization; freed blocks recycle through the driver pool
+  (the pool's release threshold is raised so steady-state loops reallocate at
+  user-space speed).
+- Destroying a solver (or `DeviceMatrix`) with work still in flight is safe
+  *and* async: the stream-ordered free waits for previously enqueued work
+  without stalling the host.
+- `DeviceMatrix::resize()` is capacity-aware: shrinking or same-size reshapes
+  reuse the existing allocation (contents are still discarded).
+
+## Reference
+
+### Supported scalar types
+
+`float`, `double`, `std::complex<float>`, `std::complex<double>` (unless
+noted otherwise).
+
+### Expression -> library call mapping
+
+| DeviceMatrix expression | Library call | Parameters |
+|---|---|---|
+| `C = A * B` | `cublasLtMatmul` (with `cublasGemmEx` fallback) | transA=N, transB=N, alpha=1, beta=0 |
+| `C = A.adjoint() * B` | `cublasLtMatmul` | transA=C, transB=N |
+| `C = A.transpose() * B` | `cublasLtMatmul` | transA=T, transB=N |
+| `C = A * B.adjoint()` | `cublasLtMatmul` | transA=N, transB=C |
+| `C = A * B.transpose()` | `cublasLtMatmul` | transA=N, transB=T |
+| `C = alpha * A * B` | `cublasLtMatmul` | alpha from LHS |
+| `C = A * (alpha * B)` | `cublasLtMatmul` | alpha from RHS |
+| `C += A * B` | `cublasLtMatmul` | alpha=1, beta=1 |
+| `C -= A * B` | `cublasLtMatmul` | alpha=-1, beta=1 |
+| `X = A.llt().solve(B)` | `cusolverDnXpotrf` + `Xpotrs` | uplo, n, nrhs |
+| `X = A.llt<Upper>().solve(B)` | same | uplo=Upper |
+| `X = A.lu().solve(B)` | `cusolverDnXgetrf` + `Xgetrs` | n, nrhs |
+| `X = A.triangularView<L>().solve(B)` | `cublasXtrsm` | side=L, uplo, diag=NonUnit |
+| `C = A.selfadjointView<L>() * B` | `cublasXsymm` / `cublasXhemm` | side=L, uplo |
+| `C.selfadjointView<L>().rankUpdate(A)` | `cublasXsyrk` / `cublasXherk` | uplo, trans=N |
+| `C = A + B` | `cublasXgeam` | alpha=1, beta=1 |
+| `C = A + alpha * B` | `cublasXgeam` | alpha=1, beta from scaled |
+| `C = A - B` | `cublasXgeam` | alpha=1, beta=-1 |
+| `C = A - alpha * B` | `cublasXgeam` | alpha=1, beta=-scaled |
+| `C = alpha * A + beta * B` | `cublasXgeam` | both sides scaled |
+| `C = alpha * A`, `C = -A`, `C = A / alpha` | `cublasXgeam` | beta=0, aliasing-safe |
+| `x += alpha * y` | `cublasXaxpy` | alpha (host scalar) |
+| `x += dAlpha * y` | `cublasXaxpy` | alpha (DeviceScalar, device pointer mode) |
+| `x -= alpha * y` | `cublasXaxpy` | alpha negated |
+| `x *= alpha` | `cublasXscal` | alpha (host or DeviceScalar) |
+| `x.dot(y)` | `cublasXdot` / `cublasXdotc` | returns `DeviceScalar` |
+| `x.norm()` | `cublasXnrm2` | returns `DeviceScalar<RealScalar>` |
+| `x.squaredNorm()` | `cublasXdot(x, x)` | returns `DeviceScalar<RealScalar>` |
+| `d_y = view * d_x` | `cusparseSpMV` | device-resident SpMV |
+| `d_Y = view * d_X` | `cusparseSpMM` | device-resident SpMM (RHS with >1 column) |
+| same, `view` of a `BlockSparseMatrix` | `cusparseSpMV` / `cusparseSpMM` on a BSR descriptor | opA=N, row-major blocks; op(A) formed on the host |
+
+### `DeviceMatrix<Scalar>`
+
+Typed RAII wrapper for a dense column-major matrix in GPU device memory.
+Always dense (leading dimension = rows). A vector is a `DeviceMatrix` with
+one column.
+
+```cpp
+// Construction
+DeviceMatrix<Scalar>()                                   // Empty (0x0)
+DeviceMatrix<Scalar>(Index n)                            // Allocate column vector (n x 1)
+DeviceMatrix<Scalar>(rows, cols)                         // Allocate uninitialized
+DeviceMatrix<Scalar>(expr)                               // Copy-init from any supported expression
+                                                         // (GEMM, geam/scaled, LLT/LU solve, TRSM,
+                                                         //  SYMM, SpMV/SpMM)
+
+// Upload / download / pointer adoption
+static DeviceMatrix fromHost(matrix, stream=nullptr)           // -> DeviceMatrix (syncs)
+static DeviceMatrix fromHostAsync(ptr, rows, cols, stream)         // -> DeviceMatrix (no sync, caller manages ptr lifetime)
+static DeviceMatrix adopt(Scalar* device_ptr, rows, cols)          // Owning wrapper over a raw device pointer
+static DeviceMatrix view(Scalar* device_ptr, rows, cols)           // Non-owning view (does not free on destruction)
+PlainMatrix        toHost(stream=nullptr)                      // -> host Matrix (syncs)
+HostTransfer       toHostAsync(stream=nullptr)                 // -> HostTransfer future (no sync)
+DeviceMatrix       clone(stream=nullptr)                       // -> DeviceMatrix (D2D copy, async)
+
+// Dimensions and access
+Index   rows()
+Index   cols()
+size_t  sizeInBytes()
+bool    empty()
+Scalar* data()                                           // Raw device pointer
+void    resize(Index rows, Index cols)                   // Discard contents; keeps the allocation
+                                                         // when it is already large enough
+
+// Expression builders (return lightweight views, evaluated on assignment)
+AdjointView       adjoint()                              // GEMM with ConjTrans
+TransposeView     transpose()                            // GEMM with Trans
+LltExpr            llt() / llt<UpLo>()                   // -> .solve(d_B) -> DeviceMatrix
+LuExpr             lu()                                  // -> .solve(d_B) -> DeviceMatrix
+TriangularView     triangularView<UpLo>()                // -> .solve(d_B) -> DeviceMatrix (TRSM)
+SelfAdjointView    selfadjointView<UpLo>()               // -> * d_B (SYMM), .rankUpdate(d_A) (SYRK)
+Assignment   device(gpu::Context& ctx)                // Bind assignment to explicit stream
+DeviceMatrix&      noalias()                             // No-op (all ops are implicitly noalias)
+
+// BLAS Level-1 (all have overloads with explicit gpu::Context& parameter)
+DeviceScalar<Scalar>     dot(const DeviceMatrix& other)  // cuBLAS dot/dotc -> DeviceScalar
+DeviceScalar<RealScalar> norm()                          // cuBLAS nrm2 -> DeviceScalar
+DeviceScalar<RealScalar>  squaredNorm()                    // dot(self, self) -> DeviceScalar (no sync)
+void                     setZero()                       // cudaMemsetAsync
+void                     addScaled(gpu::Context&, Scalar alpha, const DeviceMatrix& x)  // this += alpha * x (axpy)
+void                     scale(gpu::Context&, Scalar alpha)                              // this *= alpha (scal)
+void                     copyFrom(gpu::Context&, const DeviceMatrix& other)              // this = other (D2D copy)
+DeviceMatrix& operator+=(const Scaled<DeviceMatrix>&)    // axpy; spelled `mat += alpha * other`
+DeviceMatrix& operator-=(const Scaled<DeviceMatrix>&)    // axpy negated; spelled `mat -= alpha * other`
+DeviceMatrix& operator+=(const DeviceMatrix&)            // cuBLAS axpy (alpha=1)
+DeviceMatrix& operator-=(const DeviceMatrix&)            // cuBLAS axpy (alpha=-1)
+DeviceMatrix& operator+=(const DeviceScaledDevice<Scalar>&)  // axpy with device scalar; spelled `mat += d_alpha * other`
+DeviceMatrix& operator-=(const DeviceScaledDevice<Scalar>&)  // negated; spelled `mat -= d_alpha * other`
+DeviceMatrix& operator*=(Scalar)                         // cuBLAS scal (host pointer mode)
+DeviceMatrix& operator*=(const DeviceScalar<Scalar>&)    // cuBLAS scal (device pointer mode, no host sync)
+DeviceMatrix  cwiseProduct(gpu::Context&, const DeviceMatrix&)            // NPP nppsMul (float/double only)
+void          cwiseProduct(gpu::Context&, const DeviceMatrix&, const DeviceMatrix&)  // in-place: this = a .* b
+
+// geam expressions (evaluated on assignment)
+DeviceMatrix& operator=(const DeviceAddExpr&)            // C = A + B, C = A + alpha*B, C = A - B, etc.
+```
+
+### `DeviceScalar<Scalar>`
+
+Device-resident scalar. Returned by `dot()`, `norm()`, and `squaredNorm()`.
+Implicit conversion to `Scalar` triggers `cudaStreamSynchronize` + download.
+
+```cpp
+DeviceScalar(cudaStream_t stream = nullptr)              // Allocate uninitialized
+DeviceScalar(Scalar host_val, cudaStream_t stream)       // Upload host value
+
+Scalar         get()                                     // Download (syncs stream)
+               operator Scalar()                         // Implicit conversion (syncs)
+Scalar*        devicePtr()                               // Raw device pointer
+cudaStream_t   stream()
+
+// Device-side arithmetic (no host sync, real types only)
+DeviceScalar   operator/(DeviceScalar, DeviceScalar)     // NPP nppsDiv
+DeviceScalar   operator/(Scalar, DeviceScalar)           // upload + div
+DeviceScalar   operator/(DeviceScalar, Scalar)           // upload + div
+DeviceScalar   operator-()                               // NPP nppsMulC(-1)
+```
+
+### `gpu::Context`
+
+Unified GPU execution context owning a CUDA stream and library handles. Not
+thread-safe -- use one `Context` per thread, or external synchronization
+across threads.
+
+```cpp
+gpu::Context()                                             // Creates dedicated stream + cuBLAS handle
+                                                           // (cuSOLVER / cuBLASLt / cuSPARSE handles
+                                                           // are created lazily on first use)
+gpu::Context(cudaStream_t stream)                          // Borrow existing stream (not owned)
+static gpu::Context& threadLocal()                         // Per-thread default (lazy-created)
+static void        setThreadLocal(gpu::Context* ctx)       // Override thread-local default (nullptr restores)
+
+cudaStream_t       stream()
+cublasHandle_t     cublasHandle()
+cusolverDnHandle_t cusolverHandle()                        // Lazy: creates the handle on first call
+cublasLtHandle_t   cublasLtHandle()                        // Lazy-initialized
+cusparseHandle_t   cusparseHandle()                        // Lazy-initialized
+
+internal::DeviceBuffer&          gemmWorkspace()            // cublasLtMatmul scratch (lazy-grown per context)
+internal::CublasLtPlanCache&     gemmPlanCache()            // shape-keyed plan cache (per context, ~8-entry LRU)
+internal::OneShotSolverScratch&  oneshotSolverScratch()     // LLT/LU expression scratch (lazy-grown per context)
+```
+
+Non-copyable, non-movable (owns library handles). Translation units that
+never call `cusolverHandle()` do not pull cuSOLVER symbols at link time --
+see [Linking](#eigen_gpu_linking).
+
+### `gpu::LLT<Scalar, UpLo>` -- Dense Cholesky (cuSOLVER)
+
+Caches the Cholesky factor on device for repeated solves.
+
+```cpp
+gpu::LLT()                                                // Default construct, then call compute()
+gpu::LLT(Context& ctx)                                    // Bind to ctx's stream + handles
+gpu::LLT(const DenseBase<D>& A)                           // Convenience: upload + factorize
+gpu::LLT(const DeviceMatrix& d_A)                         // Convenience: D2D copy + factorize
+gpu::LLT(DeviceMatrix&& d_A)                              // Convenience: adopt + factorize
+gpu::LLT(Context& ctx, ...)                               // Bind + factorize in one step
+
+gpu::LLT&            compute(const DenseBase<D>& A)       // Upload + factorize
+gpu::LLT&            compute(const DeviceMatrix& d_A)     // D2D copy + factorize
+gpu::LLT&            compute(DeviceMatrix&& d_A)          // Adopt + factorize (no copy)
+
+PlainMatrix        solve(const MatrixBase<D>& B)         // -> host Matrix (syncs)
+DeviceMatrix       solve(const DeviceMatrix& d_B)        // -> DeviceMatrix (async, stays on device)
+DeviceMatrix       solve(DeviceMatrix&& d_B)             // In-place: consumes RHS, no copy/alloc
+
+ComputationInfo    info()                                // Lazy sync on first call: Success or NumericalIssue
+Index              rows() / cols()
+cudaStream_t       stream()
+```
+
+### `gpu::LU<Scalar>` -- Dense LU (cuSOLVER)
+
+Same pattern as `gpu::LLT`. Adds a `gpu::GpuOp` parameter on `solve()`.
+
+```cpp
+PlainMatrix        solve(const MatrixBase<D>& B, GpuOp op = GpuOp::NoTrans)  // -> host Matrix
+DeviceMatrix       solve(const DeviceMatrix& d_B, GpuOp op = GpuOp::NoTrans) // -> DeviceMatrix
+```
+
+`gpu::GpuOp`: `NoTrans`, `Trans`, `ConjTrans`.
+
+### `gpu::QR<Scalar>` -- Dense QR (cuSOLVER)
+
+QR factorization via `cusolverDnXgeqrf`. Solve uses ORMQR (apply Q^H) + TRSM
+(back-substitute on R) -- Q is never formed explicitly.
+
+```cpp
+gpu::QR()                                                  // Default construct
+gpu::QR(const DenseBase<D>& A)                             // Convenience: upload + factorize
+
+gpu::QR&             compute(const DenseBase<D>& A)        // Upload + factorize
+gpu::QR&             compute(const DeviceMatrix& d_A)      // D2D copy + factorize
+
+PlainMatrix        solve(const MatrixBase<D>& B)         // -> host Matrix (syncs)
+DeviceMatrix       solve(const DeviceMatrix& d_B)        // -> DeviceMatrix (async)
+PlainMatrix        matrixR()                             // -> host Matrix (m >= n only)
+
+ComputationInfo    info()                                // Lazy sync
+Index              rows() / cols()
+cudaStream_t       stream()
+```
+
+### `gpu::SVD<Scalar>` -- Dense SVD (cuSOLVER)
+
+SVD via `cusolverDnXgesvd`. Supports `ComputeThinU | ComputeThinV`,
+`ComputeFullU | ComputeFullV`, or `0` (values only). Wide matrices (m < n)
+handled by internal transpose.
+
+```cpp
+gpu::SVD()                                                 // Default construct, then call compute()
+gpu::SVD(const DenseBase<D>& A, unsigned options = ComputeThinU | ComputeThinV)  // Convenience
+
+gpu::SVD&            compute(const DenseBase<D>& A, unsigned options = ComputeThinU | ComputeThinV)
+gpu::SVD&            compute(const DeviceMatrix& d_A, unsigned options = ComputeThinU | ComputeThinV)
+
+RealVector         singularValues()                      // -> host vector (syncs, downloads)
+PlainMatrix        matrixU()                             // -> host Matrix (syncs, downloads)
+PlainMatrix        matrixV()                             // -> host Matrix (V = VT^H, matches JacobiSVD)
+PlainMatrix        matrixVT()                            // -> host Matrix (syncs, downloads V^T)
+
+DeviceMatrix       d_singularValues()                    // -> DeviceMatrix view (zero-copy)
+DeviceMatrix       d_matrixU()                           // -> DeviceMatrix view (zero-copy when m >= n)
+DeviceMatrix       d_matrixVT()                          // -> DeviceMatrix view (zero-copy when m >= n)
+
+PlainMatrix        solve(const MatrixBase<D>& B)         // -> host Matrix (pseudoinverse)
+PlainMatrix        solve(const MatrixBase<D>& B, Index k)       // Truncated (top k triplets)
+PlainMatrix        solve(const MatrixBase<D>& B, RealScalar l)  // Tikhonov regularized
+DeviceMatrix       solve(const DeviceMatrix& d_B)        // Device-resident pseudoinverse solve
+DeviceMatrix       solve(const DeviceMatrix& d_B, Index k)      // Truncated, device-resident
+DeviceMatrix       solve(const DeviceMatrix& d_B, RealScalar l) // Tikhonov, device-resident
+
+Index              rank(RealScalar threshold = -1)
+ComputationInfo    info()                                // Lazy sync
+Index              rows() / cols()
+cudaStream_t       stream()
+```
+
+**Note:** `singularValues()`, `matrixU()`, `matrixV()`, and `matrixVT()`
+download to host on each call. The `d_*` accessors return non-owning
+`DeviceMatrix` views into the solver's internal buffers; the `gpu::SVD` object
+must outlive any view derived from it. For wide matrices (m < n) the U/V^T
+views are owning (one `cublasXgeam` adjoint pass).
+
+### `gpu::SelfAdjointEigenSolver<Scalar>` -- Eigendecomposition (cuSOLVER)
+
+Symmetric/Hermitian eigenvalue decomposition via `cusolverDnXsyevd`.
+`ComputeMode` enum: `EigenvaluesOnly`, `ComputeEigenvectors`.
+
+```cpp
+gpu::SelfAdjointEigenSolver()                              // Default construct, then call compute()
+gpu::SelfAdjointEigenSolver(const DenseBase<D>& A, ComputeMode mode = ComputeEigenvectors)  // Convenience
+
+gpu::SelfAdjointEigenSolver& compute(const DenseBase<D>& A, ComputeMode mode = ComputeEigenvectors)
+gpu::SelfAdjointEigenSolver& compute(const DeviceMatrix& d_A, ComputeMode mode = ComputeEigenvectors)
+
+RealVector         eigenvalues()                         // -> host vector (syncs, downloads, ascending order)
+PlainMatrix        eigenvectors()                        // -> host Matrix (syncs, downloads, columns)
+
+DeviceMatrix       d_eigenvalues()                       // -> DeviceMatrix view (zero-copy)
+DeviceMatrix       d_eigenvectors()                      // -> DeviceMatrix view (zero-copy, requires ComputeEigenvectors)
+
+ComputationInfo    info()                                // Lazy sync
+Index              rows() / cols()
+cudaStream_t       stream()
+```
+
+**Note:** `eigenvalues()` and `eigenvectors()` download to host on each call.
+The `d_*` accessors return non-owning `DeviceMatrix` views into the solver's
+internal buffers; the `gpu::SelfAdjointEigenSolver` object must outlive any
+view derived from it.
+
+### `HostTransfer<Scalar>`
+
+Future for async device-to-host transfer. Returned by
+`DeviceMatrix::toHostAsync()`.
+
+```cpp
+PlainMatrix&       get()                                 // Block until complete, return host Matrix ref. Idempotent.
+bool               ready()                               // Non-blocking poll
+```
+
+### `gpu::SparseLLT<Scalar, UpLo>` -- Sparse Cholesky (cuDSS)
+
+Requires cuDSS (CUDA 12.0+, `#define EIGEN_CUDSS`). Three-phase workflow
+with symbolic reuse. Accepts `SparseMatrix<Scalar, ColMajor, int>` (CSC).
+Matrix dimensions and nonzero count must fit in `int` (cuDSS limitation;
+debug builds assert).
+
+```cpp
+gpu::SparseLLT()                                           // Default construct
+gpu::SparseLLT(const SparseMatrixBase<D>& A)               // Analyze + factorize
+
+gpu::SparseLLT&      analyzePattern(const SparseMatrixBase<D>& A)  // Symbolic analysis (reusable)
+gpu::SparseLLT&      factorize(const SparseMatrixBase<D>& A)       // Numeric factorization
+gpu::SparseLLT&      compute(const SparseMatrixBase<D>& A)         // analyzePattern + factorize
+
+DenseMatrix        solve(const MatrixBase<D>& B)         // -> host Matrix (syncs)
+DeviceMatrix       solve(const DeviceMatrix& d_B)        // -> DeviceMatrix (async, stays on device)
+
+gpu::SparseLLT&      setConfig(const SparseSolverConfig&) // cuDSS knobs (>= 0.8); call before the affected phase
+const SparseSolverConfig& config()                        // Last configuration set
+
+ComputationInfo    info()                                // Lazy sync
+Index              rows() / cols()
+cudaStream_t       stream()
+```
+
+All three cuDSS solvers also accept a `gpu::Context&` as first constructor
+argument to borrow its stream (`gpu::SparseLLT<double> llt(ctx)` or
+`llt(ctx, A)`).
+
+### `gpu::SparseLDLT<Scalar, UpLo>` -- Sparse LDL^T (cuDSS)
+
+Symmetric indefinite. Same API as `gpu::SparseLLT`.
+
+### `gpu::SparseLU<Scalar>` -- Sparse LU (cuDSS)
+
+General non-symmetric. Same API as `gpu::SparseLLT` (without `UpLo`).
+
+### `gpu::FFT<Scalar>` -- FFT (cuFFT)
+
+Plans cached by (size, type) in a bounded LRU and reused; the
+least-recently-used plan is destroyed via `cufftDestroy` on overflow. Cache
+capacity is set at construction (default
+`kDefaultCufftPlanCacheCapacity = 16`). Inverse transforms scaled so
+`inv(fwd(x)) == x`. Supported scalars: `float`, `double`. Stream and cuBLAS
+handle borrowed from a `gpu::Context` (default: `Context::threadLocal()`),
+so by default the FFT shares a stream with other GPU operations on the same
+thread.
+
+```cpp
+gpu::FFT(std::size_t plan_cache_capacity = kDefaultCufftPlanCacheCapacity)
+                                        // bind to Context::threadLocal()
+gpu::FFT(gpu::Context& ctx,
+         std::size_t plan_cache_capacity = kDefaultCufftPlanCacheCapacity)
+                                        // bind to an explicit Context
+
+// 1D transforms (host vectors in and out)
+ComplexVector      fwd(const MatrixBase<D>& x)           // C2C forward (complex input)
+ComplexVector      fwd(const MatrixBase<D>& x)           // R2C forward (real input, returns n/2+1)
+ComplexVector      inv(const MatrixBase<D>& X)           // C2C inverse, scaled by 1/n
+RealVector         invReal(const MatrixBase<D>& X, Index n)  // C2R inverse, scaled by 1/n
+
+// 2D transforms (host matrices in and out)
+ComplexMatrix      fwd2(const MatrixBase<D>& A)         // 2D C2C forward
+ComplexMatrix      inv2(const MatrixBase<D>& A)         // 2D C2C inverse, scaled by 1/(rows*cols)
+
+// Device-resident transforms (DeviceMatrix in/out, async, no host transfer)
+void               fwd(const DeviceMatrix<Complex>&, DeviceMatrix<Complex>&)      // 1D C2C
+void               inv(const DeviceMatrix<Complex>&, DeviceMatrix<Complex>&)      // 1D C2C inverse
+void               fwd(const DeviceMatrix<Scalar>&, DeviceMatrix<Complex>&)       // 1D R2C
+void               invReal(const DeviceMatrix<Complex>&, DeviceMatrix<Scalar>&, Index nfft)  // 1D C2R
+void               fwd2 / inv2(const DeviceMatrix<Complex>&, DeviceMatrix<Complex>&)  // 2D C2C
+
+cudaStream_t       stream()             // borrowed from the bound Context
+gpu::Context&      context()            // the bound Context
+std::size_t        plan_cache_capacity() // configured capacity
+std::size_t        plan_cache_size()     // currently cached plan count
+```
+
+All FFT methods accept host data and return host data. Upload/download is
+handled internally. The C2C and R2C overloads of `fwd()` are distinguished by
+the input scalar type (complex vs real).
+
+### `gpu::SparseContext<Scalar>` -- SpMV/SpMM (cuSPARSE)
+
+Accepts `SparseMatrix<Scalar, ColMajor>` and `BlockSparseMatrix<Scalar,
+Options, BlockRows, BlockCols, int>` (the `BlockSpMat<Options, BlockRows,
+BlockCols>` alias; see [Block sparse matrices](#block-sparse-matrices-bsr) for
+which block shapes upload as BSR and which op / storage-order combinations do
+so without a host copy). Host-input
+methods accept host data and return host data; device-input methods
+(`deviceView()`, `multiply(A, d_x, d_y)`) operate on `DeviceMatrix`. Matrix
+dimensions and nonzero count must fit in `int` (cuSPARSE limitation; debug
+builds assert).
+
+```cpp
+gpu::SparseContext()                                       // Creates own stream + cuSPARSE handle
+gpu::SparseContext(gpu::Context& ctx)                        // Borrow gpu::Context for same-stream execution
+
+// Host data in/out
+DenseVector        multiply(A, x)                                       // y = A * x
+void               multiply(A, x, y, alpha=1, beta=0,                   // y = alpha*op(A)*x + beta*y
+                     op=GpuOp::NoTrans)
+DenseVector        multiplyT(A, x)                                      // y = A^T * x
+DenseVector        multiplyAdjoint(A, x)                                // y = A^H * x
+DenseMatrix        multiplyMat(A, X, op=GpuOp::NoTrans)                 // Y = op(A) * X (SpMM)
+
+// DeviceMatrix in/out (sparse matrix re-uploaded per call)
+void               multiply(A, d_x, d_y)                                // SpMV with device vectors
+void               multiply(A, d_x, d_y, alpha, beta, op=GpuOp::NoTrans)
+
+// Device-resident sparse matrix (upload once, reuse)
+DeviceSparseView   deviceView(A)                                        // Upload sparse matrix, return view
+uint64_t           uploadGeneration()                                   // Generation of the cached upload
+
+// Advanced: run SpMV/SpMM against the already-uploaded matrix (op must be
+// NoTrans after a BSR upload)
+void               spmv_device_exec(d_x, d_y, alpha=1, beta=0, op=GpuOp::NoTrans)
+void               spmm_device_exec(d_X, d_Y, alpha=1, beta=0, op=GpuOp::NoTrans)
+
+cudaStream_t       stream()
+```
+
+### `DeviceSparseView<Scalar>` -- Device-resident sparse matrix
+
+Returned by `gpu::SparseContext::deviceView()`. Holds a sparse matrix on device
+for repeated SpMV without re-uploading.
+
+```cpp
+SpMVExpr           operator*(const DeviceMatrix& d_x)    // d_y = view * d_x (evaluated on assignment;
+                                                         // dispatches to SpMM when d_x has > 1 column)
+uint64_t           generation()                          // Upload generation (stale views assert)
+```
+
+### Aliasing
+
+Unlike Eigen's `Matrix`, where omitting `.noalias()` triggers a copy to a
+temporary, DeviceMatrix dispatches directly to NVIDIA library calls which have
+no built-in aliasing protection. All operations are implicitly noalias.
+The caller must ensure operands don't alias the destination for GEMM, TRSM,
+SYMM/HEMM, and SYRK/HERK. Debug builds assert on these violations before
+dispatching to cuBLAS. `geam` expressions (`d_C = d_A + alpha * d_B`) are
+safe with aliasing. The `.noalias()` method exists as a no-op for Eigen
+template compatibility.
+
+## Future work
+
+- **Reassess host-input vs. device-input API surface.** Each solver currently
+  exposes both host-input (`compute(MatrixXd)`, `solve(MatrixXd)`) and
+  device-input (`compute(DeviceMatrix)`, `solve(DeviceMatrix)`) overloads, plus
+  host- and device-side accessors (`matrixU()` vs `d_matrixU()`). This eases
+  migration from CPU Eigen but may invite accidental host ↔ device round-trips
+  when users mix the two without realising the cost. Revisit once the module
+  is in users' hands; if the convenience overloads cause more confusion than
+  they save, narrow toward a single explicit `fromHost` / `toHost` boundary.
+
+- **Robustness-oriented cuDSS defaults.** `gpu::SparseSolverConfig` exposes
+  matching, pivoting, refinement, and the hybrid modes, but a
+  default-constructed solver still runs with cuDSS's performance-tuned
+  defaults (matching off). Consider flipping the shipped defaults toward
+  robustness now that users can override them.
+
+- **cuDSS threading layer for host-side reordering.** As of cuDSS 0.7.1
+  fill-reducing reordering runs on the CPU. cuDSS supports a "threading
+  layer" plugin that parallelises this stage; for reordering-dominated
+  problems it can materially close the gap with multithreaded CPU sparse
+  direct solvers. We don't currently configure a threading layer.
+
+- **Complex symmetric (non-Hermitian) sparse LDL^T.** `gpu::SparseLDLT`
+  treats complex inputs as Hermitian (matching `Eigen::SimplicialLDLT`).
+  cuDSS also supports `CUDSS_MTYPE_SYMMETRIC` for complex matrices
+  (A = A^T, no conjugation); exposing this would need a separate solver
+  mode.
+
+## File layout
+
+| File | Depends on | Contents |
+|------|-----------|----------|
+| `GpuSupport.h` | `<cuda_runtime.h>` | Error macro, `DeviceBuffer`, `DeviceBufferPool`, `cuda_data_type<>` |
+| `DeviceMatrix.h` | `GpuSupport.h` | `gpu::DeviceMatrix<>`, `gpu::HostTransfer<>` |
+| `DeviceExpr.h` | `DeviceMatrix.h` | GEMM, geam, and device-scalar expression wrappers |
+| `DeviceBlasExpr.h` | `DeviceMatrix.h` | TRSM, SYMM, SYRK expression wrappers |
+| `DeviceSolverExpr.h` | `DeviceMatrix.h` | Solver expression wrappers (LLT, LU) |
+| `DeviceScalar.h` | `GpuSupport.h`, `DeviceScalarOps.h` | `gpu::DeviceScalar<>` (device-resident scalar) |
+| `DeviceScalarOps.h` | `<npps_*.h>` | Scalar div/neg/cwiseProduct via NPP |
+| `DeviceDispatch.h` | all above | All dispatch functions, BLAS-1 out-of-line defs, `gpu::Assignment` |
+| `GpuContext.h` | `CuBlasSupport.h`, `CuSolverSupport.h` | `gpu::Context` |
+| `CuBlasSupport.h` | `GpuSupport.h`, `<cublas_v2.h>`, `<cublasLt.h>` | cuBLAS error macro, type-specific wrappers |
+| `CuSolverSupport.h` | `GpuSupport.h`, `<cusolverDn.h>` | cuSOLVER params, fill-mode mapping |
+| `GpuSolverContext.h` | `CuSolverSupport.h`, `CuBlasSupport.h` | Shared solver context (stream, handles, scratch) |
+| `GpuLLT.h` | `GpuSolverContext.h` | `gpu::LLT<>` -- Cached dense Cholesky factorization |
+| `GpuLU.h` | `GpuSolverContext.h` | `gpu::LU<>` -- Cached dense LU factorization |
+| `GpuQR.h` | `GpuSolverContext.h` | `gpu::QR<>` -- Dense QR decomposition |
+| `GpuSVD.h` | `GpuSolverContext.h` | `gpu::SVD<>` -- Dense SVD decomposition |
+| `GpuEigenSolver.h` | `GpuSolverContext.h` | `gpu::SelfAdjointEigenSolver<>` |
+| `CuFftSupport.h` | `GpuSupport.h`, `<cufft.h>` | cuFFT error macro, type-dispatch wrappers |
+| `GpuFFT.h` | `CuFftSupport.h`, `CuBlasSupport.h`, `GpuContext.h` | `gpu::FFT<>` -- 1D/2D FFT with plan caching |
+| `CuSparseSupport.h` | `GpuSupport.h`, `<cusparse.h>` | cuSPARSE error macro, `EIGEN_HAS_CUSPARSE_BSR` |
+| `GpuSparseContext.h` | `CuSparseSupport.h` | `gpu::SparseContext<>`, `gpu::DeviceSparseView<>`, BSR binding of `BlockSparseMatrix` |
+| `CuDssSupport.h` | `GpuSupport.h`, `<cudss.h>` | cuDSS error macro, type traits (optional) |
+| `GpuSparseSolverBase.h` | `CuDssSupport.h` | CRTP base for sparse solvers (optional) |
+| `GpuSparseLLT.h` | `GpuSparseSolverBase.h` | `gpu::SparseLLT<>` -- Sparse Cholesky via cuDSS (optional) |
+| `GpuSparseLDLT.h` | `GpuSparseSolverBase.h` | `gpu::SparseLDLT<>` -- Sparse LDL^T via cuDSS (optional) |
+| `GpuSparseLU.h` | `GpuSparseSolverBase.h` | `gpu::SparseLU<>` -- Sparse LU via cuDSS (optional) |
+
+## Building and testing
+
+```bash
+cmake -G Ninja -B build -S . \
+  -DEIGEN_TEST_CUDA=ON \
+  -DEIGEN_CUDA_COMPUTE_ARCH="70" \
+  -DEIGEN_TEST_CUBLAS=ON \
+  -DEIGEN_TEST_CUSOLVER=ON
+
+cmake --build build --target cublas cusolver_llt cusolver_lu \
+  cusolver_qr cusolver_svd cusolver_eigen \
+  device_matrix cufft cusparse_spmv cusparse_bsr cg
+ctest --test-dir build -L gpu --output-on-failure
+
+# Sparse solvers (cuDSS -- separate install required)
+cmake -G Ninja -B build -S . \
+  -DEIGEN_TEST_CUDA=ON \
+  -DEIGEN_CUDA_COMPUTE_ARCH="70" \
+  -DEIGEN_TEST_CUDSS=ON
+
+cmake --build build --target cudss_llt cudss_ldlt cudss_lu
+ctest --test-dir build -R '^cudss_' --output-on-failure
+```
+
+## Future enhancements
+
+- **Batched API (`DeviceBatchMatrix`).** A strided batch of N identical-size
+  matrices dispatching to cuBLAS/cuSOLVER batched APIs (`cublasDgemmBatched`,
+  `cusolverDnXpotrfBatched`, etc.). This enables robotics and model-predictive
+  control workloads where many small independent systems are solved in
+  parallel.
+- **cuTENSOR for Tensor module.** Replace the hand-written GPU tensor
+  contraction and reduction kernels (~2300 lines in
+  `TensorContractionGpu.h` / `TensorReductionGpu.h`) with cuTENSOR dispatch,
+  following the same library-dispatch pattern used by `contrib/Eigen/GPU`.
+- **Unified/zero-copy memory for Jetson.** Use `cudaMallocManaged` or
+  `cudaHostAllocMapped` to eliminate `fromHost()` / `toHost()` copies on
+  integrated GPUs (Jetson) where CPU and GPU share DRAM.
+- **Device-side Eigen interop.** Bridge between host-side `DeviceMatrix`
+  dispatch and device-side Eigen expression templates (Core + Tensor) running
+  inside CUDA kernels. Raw-pointer + `Map` / `TensorMap` as the zero-copy
+  interop surface.
+- **Per-stream CUDA memory pools.** Allocation is now stream-ordered through
+  the device's default memory pool. Attaching a dedicated `cudaMemPool_t` per
+  stream (`cudaDeviceSetMempool` / `cudaMallocFromPoolAsync`) could further
+  reduce cross-stream allocator contention for workloads that fan out many
+  concurrent solves.
diff --git a/contrib/Eigen/src/GPU/type_traits.h b/contrib/Eigen/src/GPU/type_traits.h
new file mode 100644
index 0000000..ae9f81d
--- /dev/null
+++ b/contrib/Eigen/src/GPU/type_traits.h
@@ -0,0 +1,954 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GPU_TYPE_TRAITS_H
+#define EIGEN_GPU_TYPE_TRAITS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "./FwdDecl.h"
+#include "./Meta.h"
+
+#include <complex>
+#include <type_traits>
+
+namespace Eigen {
+namespace gpu {
+
+/**
+ * @name internal:: type traits
+ *
+ * Each one keys off the *name* of a forward-declared class. None of them
+ * inspect members so they parse cleanly with FwdDecl.h alone. is_scaled_leaf
+ * and is_scaled_gemm compose with an inner predicate, but still by matching the
+ * template-id rather than by reading a member.
+ */
+
+namespace internal {
+
+///@{
+
+template <typename Expr>
+using scalar_type_t = typename device_expr_traits<Expr>::scalar_type;
+
+template <typename T>
+struct is_device_buffer : Eigen::internal::bool_constant<false> {};
+template <>
+struct is_device_buffer<DeviceBuffer> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_device_matrix : Eigen::internal::bool_constant<false> {};
+template <typename Scalar>
+struct is_device_matrix<DeviceMatrix<Scalar>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_gemm_expr : Eigen::internal::bool_constant<false> {};
+template <typename Lhs, typename Rhs>
+struct is_gemm_expr<GemmExpr<Lhs, Rhs>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_adjoint_view : Eigen::internal::bool_constant<false> {};
+template <typename Scalar>
+struct is_adjoint_view<AdjointView<Scalar>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_transpose_view : Eigen::internal::bool_constant<false> {};
+template <typename Scalar>
+struct is_transpose_view<TransposeView<Scalar>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_scaled : Eigen::internal::bool_constant<false> {};
+template <typename Inner>
+struct is_scaled<Scaled<Inner>> : Eigen::internal::bool_constant<true> {};
+
+/**
+ * @brief Detects a Scaled directly over a leaf DeviceMatrix (no view in between).
+ * @tparam T The type to test.
+ * @note Defers to is_device_matrix on the scaled operand rather than restating
+ * the nested pattern, so it tracks whatever is_device_matrix accepts.
+ * @note The operand is deduced from the template-id, not read from Scaled::Inner:
+ * naming a member would instantiate Scaled, and Scaled<GemmExpr<...>>::Scalar is
+ * ill-formed because GemmExpr has no device_expr_traits specialization. Matching
+ * the template-id keeps this predicate usable on any Scaled, complete or not.
+ * @note Such a node arriving as a donation (owned rvalue) is materialized by
+ * stealing the leaf and applying the scalar in place (scal) instead of a geam
+ * into a fresh buffer.
+ */
+template <typename T>
+struct is_scaled_leaf : Eigen::internal::bool_constant<false> {};
+template <typename Inner>
+struct is_scaled_leaf<Scaled<Inner>> : is_device_matrix<std::decay_t<Inner>> {};
+
+/**
+ * @brief Detects a Scaled directly over a GemmExpr (a product carrying ONE deferred scalar).
+ * @tparam T The type to test.
+ * @note Defers to is_gemm_expr on the scaled operand, deduced the same way as in
+ * is_scaled_leaf and for the same reason.
+ * @note Such a summand routes through the GEMM epilogue with its factor as the
+ * gemm's alpha_scale (no temporary).
+ */
+template <typename T>
+struct is_scaled_gemm : Eigen::internal::bool_constant<false> {};
+template <typename Inner>
+struct is_scaled_gemm<Scaled<Inner>> : is_gemm_expr<std::decay_t<Inner>> {};
+
+template <typename T>
+struct is_triangular_view : Eigen::internal::bool_constant<false> {};
+template <typename Inner, int UpLo>
+struct is_triangular_view<TriangularView<Inner, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_trsm_expr : Eigen::internal::bool_constant<false> {};
+template <typename Scalar, int UpLo>
+struct is_trsm_expr<TrsmExpr<Scalar, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_selfadjoint_view : Eigen::internal::bool_constant<false> {};
+template <typename Scalar, int UpLo>
+struct is_selfadjoint_view<SelfAdjointView<Scalar, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_const_selfadjoint_view : Eigen::internal::bool_constant<false> {};
+template <typename Inner, int UpLo>
+struct is_const_selfadjoint_view<ConstSelfAdjointView<Inner, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_symm_expr : Eigen::internal::bool_constant<false> {};
+template <typename Scalar, int UpLo>
+struct is_symm_expr<SymmExpr<Scalar, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_syrk_expr : Eigen::internal::bool_constant<false> {};
+template <typename A, int UpLo>
+struct is_syrk_expr<SyrkExpr<A, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_llt_solve_expr : Eigen::internal::bool_constant<false> {};
+template <typename Scalar, int UpLo>
+struct is_llt_solve_expr<LltSolveExpr<Scalar, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_lu_solve_expr : Eigen::internal::bool_constant<false> {};
+template <typename Scalar>
+struct is_lu_solve_expr<LuSolveExpr<Scalar>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_llt_view : Eigen::internal::bool_constant<false> {};
+template <typename Scalar, int UpLo>
+struct is_llt_view<LLTView<Scalar, UpLo>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_lu_view : Eigen::internal::bool_constant<false> {};
+template <typename Scalar>
+struct is_lu_view<LUView<Scalar>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_device_add_expr : Eigen::internal::bool_constant<false> {};
+template <typename Scalar>
+struct is_device_add_expr<DeviceAddExpr<Scalar>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_device_scaled_device : Eigen::internal::bool_constant<false> {};
+template <typename Inner>
+struct is_device_scaled_device<DeviceScaledDevice<Inner>> : Eigen::internal::bool_constant<true> {};
+
+template <typename T>
+struct is_device_scalar : Eigen::internal::bool_constant<false> {};
+template <typename S>
+struct is_device_scalar<DeviceScalar<S>> : Eigen::internal::bool_constant<true> {};
+
+///@}
+
+}  // namespace internal
+
+/**
+ * @defgroup gpu_type_traits GPU type traits
+ * @name Public is_* / is_*_v / require_* / require_all_* wrappers
+ *
+ * Type traits for the Eigen GPU library
+ */
+///@{
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::internal::DeviceBuffer
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_device_buffer : internal::is_device_buffer<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::internal::DeviceBuffer
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_device_buffer_v = is_device_buffer<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::internal::DeviceBuffer
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_device_buffer = internal::require_t<is_device_buffer<T>>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_device_matrix : internal::is_device_matrix<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_device_matrix_v = is_device_matrix<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_device_matrix = internal::require_t<is_device_matrix<T>>;
+
+/**
+ * Require a type is not a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_not_device_matrix = internal::require_not_t<is_device_matrix<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::DeviceMatrix types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_device_matrix = internal::require_all_t<is_device_matrix_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::GemmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_gemm_expr : internal::is_gemm_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::GemmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_gemm_expr_v = is_gemm_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::GemmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_gemm_expr = internal::require_t<is_gemm_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::GemmExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_gemm_expr = internal::require_all_t<is_gemm_expr_v<Types>...>;
+
+/**
+ * Detect if a type is an @ref Eigen::gpu::AdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_adjoint_view : internal::is_adjoint_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is an @ref Eigen::gpu::AdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_adjoint_view_v = is_adjoint_view<T>::value;
+
+/**
+ * Require a type is an @ref Eigen::gpu::AdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_adjoint_view = internal::require_t<is_adjoint_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::AdjointView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_adjoint_view = internal::require_all_t<is_adjoint_view_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::TransposeView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_transpose_view : internal::is_transpose_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::TransposeView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_transpose_view_v = is_transpose_view<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::TransposeView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_transpose_view = internal::require_t<is_transpose_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::TransposeView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_transpose_view = internal::require_all_t<is_transpose_view_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::Scaled expression.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_scaled : internal::is_scaled<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::Scaled expression.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_scaled_v = is_scaled<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::Scaled expression.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_scaled = internal::require_t<is_scaled<T>>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::Scaled expression directly over a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_scaled_leaf : internal::is_scaled_leaf<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::Scaled expression directly over a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_scaled_leaf_v = is_scaled_leaf<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::Scaled expression directly over a @ref Eigen::gpu::DeviceMatrix
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_scaled_leaf = internal::require_t<is_scaled_leaf<T>>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::Scaled expression directly over a @ref Eigen::gpu::GemmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_scaled_gemm : internal::is_scaled_gemm<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::Scaled expression directly over a @ref Eigen::gpu::GemmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_scaled_gemm_v = is_scaled_gemm<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::Scaled expression directly over a @ref Eigen::gpu::GemmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_scaled_gemm = internal::require_t<is_scaled_gemm<T>>;
+
+/**
+ * True iff a type is a @ref Eigen::gpu::GemmExpr or a @ref Eigen::gpu::Scaled expression directly over one.
+ * @tparam T The type to test.
+ * @note Such a product may carry one deferred scalar, which becomes the GEMM alpha scale.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_gemm_like_v = is_gemm_expr_v<T> || is_scaled_gemm_v<T>;
+
+/**
+ * Require a type is an @ref Eigen::gpu::AdjointView or a @ref Eigen::gpu::TransposeView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_adjoint_or_transpose_view =
+    internal::require_t<Eigen::internal::bool_constant<is_adjoint_view_v<T> || is_transpose_view_v<T>>>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::TriangularView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_triangular_view : internal::is_triangular_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::TriangularView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_triangular_view_v = is_triangular_view<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::TriangularView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_triangular_view = internal::require_t<is_triangular_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::TriangularView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_triangular_view = internal::require_all_t<is_triangular_view_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::TrsmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_trsm_expr : internal::is_trsm_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::TrsmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_trsm_expr_v = is_trsm_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::TrsmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_trsm_expr = internal::require_t<is_trsm_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::TrsmExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_trsm_expr = internal::require_all_t<is_trsm_expr_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::SelfAdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_selfadjoint_view : internal::is_selfadjoint_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::SelfAdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_selfadjoint_view_v = is_selfadjoint_view<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::SelfAdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_selfadjoint_view = internal::require_t<is_selfadjoint_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::SelfAdjointView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_selfadjoint_view = internal::require_all_t<is_selfadjoint_view_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::ConstSelfAdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_const_selfadjoint_view : internal::is_const_selfadjoint_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::ConstSelfAdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_const_selfadjoint_view_v = is_const_selfadjoint_view<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::ConstSelfAdjointView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_const_selfadjoint_view = internal::require_t<is_const_selfadjoint_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::ConstSelfAdjointView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_const_selfadjoint_view = internal::require_all_t<is_const_selfadjoint_view_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::SymmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_symm_expr : internal::is_symm_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::SymmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_symm_expr_v = is_symm_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::SymmExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_symm_expr = internal::require_t<is_symm_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::SymmExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_symm_expr = internal::require_all_t<is_symm_expr_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::SyrkExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_syrk_expr : internal::is_syrk_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::SyrkExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_syrk_expr_v = is_syrk_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::SyrkExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_syrk_expr = internal::require_t<is_syrk_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::SyrkExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_syrk_expr = internal::require_all_t<is_syrk_expr_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::LltSolveExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_llt_solve_expr : internal::is_llt_solve_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::LltSolveExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_llt_solve_expr_v = is_llt_solve_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::LltSolveExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_llt_solve_expr = internal::require_t<is_llt_solve_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::LltSolveExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_llt_solve_expr = internal::require_all_t<is_llt_solve_expr_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::LuSolveExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_lu_solve_expr : internal::is_lu_solve_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::LuSolveExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_lu_solve_expr_v = is_lu_solve_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::LuSolveExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_lu_solve_expr = internal::require_t<is_lu_solve_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::LuSolveExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_lu_solve_expr = internal::require_all_t<is_lu_solve_expr_v<Types>...>;
+
+/**
+ * Detect if a type is an @ref Eigen::gpu::LLTView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_llt_view : internal::is_llt_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is an @ref Eigen::gpu::LLTView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_llt_view_v = is_llt_view<T>::value;
+
+/**
+ * Require a type is an @ref Eigen::gpu::LLTView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_llt_view = internal::require_t<is_llt_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::LLTView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_llt_view = internal::require_all_t<is_llt_view_v<Types>...>;
+
+/**
+ * Detect if a type is an @ref Eigen::gpu::LUView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_lu_view : internal::is_lu_view<std::decay_t<T>> {};
+
+/**
+ * True iff a type is an @ref Eigen::gpu::LUView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_lu_view_v = is_lu_view<T>::value;
+
+/**
+ * Require a type is an @ref Eigen::gpu::LUView
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_lu_view = internal::require_t<is_lu_view<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::LUView types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_lu_view = internal::require_all_t<is_lu_view_v<Types>...>;
+
+/**
+ * True iff a type is an @ref Eigen::gpu::LLTView or an @ref Eigen::gpu::LUView
+ * @tparam T The type to test.
+ * @note Arithmetic operators exclude factorization handles so they cannot be lowered as matrix operands.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_factor_expr_v = is_lu_view_v<T> || is_llt_view_v<T>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::DeviceAddExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_device_add_expr : internal::is_device_add_expr<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::DeviceAddExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_device_add_expr_v = is_device_add_expr<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::DeviceAddExpr
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_device_add_expr = internal::require_t<is_device_add_expr<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::DeviceAddExpr types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_device_add_expr = internal::require_all_t<is_device_add_expr_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::DeviceScaledDevice
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_device_scaled_device : internal::is_device_scaled_device<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::DeviceScaledDevice
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_device_scaled_device_v = is_device_scaled_device<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::DeviceScaledDevice
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_device_scaled_device = internal::require_t<is_device_scaled_device<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::DeviceScaledDevice types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_device_scaled_device = internal::require_all_t<is_device_scaled_device_v<Types>...>;
+
+/**
+ * Detect if a type is a @ref Eigen::gpu::DeviceScalar
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_device_scalar : internal::is_device_scalar<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a @ref Eigen::gpu::DeviceScalar
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_device_scalar_v = is_device_scalar<T>::value;
+
+/**
+ * Require a type is a @ref Eigen::gpu::DeviceScalar
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_device_scalar = internal::require_t<is_device_scalar<T>>;
+
+/**
+ * Require all types are @ref Eigen::gpu::DeviceScalar types.
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_device_scalar = internal::require_all_t<is_device_scalar_v<Types>...>;
+
+/**
+ * @name device_expr_traits query aliases
+ *
+ * Lazy readers of the member-inspecting internal::device_expr_traits, whose
+ * specializations live in DeviceExpr.h. Declared from the FwdDecl.h forward
+ * declaration; they resolve only when instantiated on a complete specialization.
+ */
+///@{
+
+template <typename T>
+using scalar_type_t = internal::scalar_type_t<std::decay_t<T>>;
+
+/**
+ * Detect if a type is marked as a device expression by
+ * @ref Eigen::gpu::internal::device_expr_traits
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_device_expr : Eigen::internal::bool_constant<internal::device_expr_traits<std::decay_t<T>>::is_device_expr> {
+};
+
+/**
+ * True iff a type is marked as a device expression by
+ * @ref Eigen::gpu::internal::device_expr_traits
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_device_expr_v = is_device_expr<T>::value;
+
+/**
+ * Require a type is marked as a device expression by
+ * @ref Eigen::gpu::internal::device_expr_traits
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_device_expr = internal::require_t<is_device_expr<T>>;
+
+/**
+ * Require all types are marked as device expressions by
+ * @ref Eigen::gpu::internal::device_expr_traits
+ * @tparam Types The types to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename... Types>
+using require_all_device_expr = internal::require_all_t<is_device_expr_v<Types>...>;
+
+template <typename T>
+constexpr GpuOp trans_op = internal::device_expr_traits<std::decay_t<T>>::op;
+
+///@}
+
+namespace internal {
+template <typename T>
+struct is_complex : Eigen::internal::bool_constant<false> {};
+
+template <typename T>
+struct is_complex<std::complex<T>> : Eigen::internal::bool_constant<true> {};
+}  // namespace internal
+
+/**
+ * Detect if a type is a `std::complex` specialization.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_complex : internal::is_complex<std::decay_t<T>> {};
+
+/**
+ * True iff a type is a `std::complex` specialization.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+constexpr bool is_complex_v = is_complex<T>::value;
+
+/**
+ * Detect if a type is an integral, floating-point, or `std::complex` host scalar.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+struct is_host_scalar : Eigen::internal::bool_constant<std::is_floating_point<std::decay_t<T>>::value ||
+                                                       std::is_integral<std::decay_t<T>>::value || is_complex_v<T>> {};
+
+/**
+ * Require a type is an integral, floating-point, or `std::complex` host scalar.
+ * @tparam T The type to test.
+ * @ingroup gpu_type_traits
+ */
+template <typename T>
+using require_host_scalar = internal::require_t<is_host_scalar<T>>;
+
+///@}
+
+}  // namespace gpu
+}  // namespace Eigen
+
+#endif  // EIGEN_GPU_TYPE_TRAITS_H
diff --git a/contrib/Eigen/src/KroneckerProduct/InternalHeaderCheck.h b/contrib/Eigen/src/KroneckerProduct/InternalHeaderCheck.h
new file mode 100644
index 0000000..07be5c2
--- /dev/null
+++ b/contrib/Eigen/src/KroneckerProduct/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_KRONECKER_PRODUCT_MODULE_H
+#error "Please include contrib/Eigen/KroneckerProduct instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h b/contrib/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h
new file mode 100644
index 0000000..ebecdd8
--- /dev/null
+++ b/contrib/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h
@@ -0,0 +1,285 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Kolja Brix <brix@igpm.rwth-aachen.de>
+// Copyright (C) 2011 Andreas Platen <andiplaten@gmx.de>
+// Copyright (C) 2012 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef KRONECKER_TENSOR_PRODUCT_H
+#define KRONECKER_TENSOR_PRODUCT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/*!
+ * \ingroup KroneckerProduct_Module
+ *
+ * \brief The base class of dense and sparse Kronecker product.
+ *
+ * \tparam Derived is the derived type.
+ */
+template <typename Derived>
+class KroneckerProductBase : public ReturnByValue<Derived> {
+ private:
+  typedef typename internal::traits<Derived> Traits;
+  typedef typename Traits::Scalar Scalar;
+
+ protected:
+  typedef typename Traits::Lhs Lhs;
+  typedef typename Traits::Rhs Rhs;
+
+ public:
+  /*! \brief Constructor. */
+  KroneckerProductBase(const Lhs& A, const Rhs& B) : m_A(A), m_B(B) {}
+
+  inline Index rows() const { return m_A.rows() * m_B.rows(); }
+  inline Index cols() const { return m_A.cols() * m_B.cols(); }
+
+  /*!
+   * This overrides ReturnByValue::coeff because this function is
+   * efficient enough.
+   */
+  Scalar coeff(Index row, Index col) const {
+    return m_A.coeff(row / m_B.rows(), col / m_B.cols()) * m_B.coeff(row % m_B.rows(), col % m_B.cols());
+  }
+
+  /*!
+   * This overrides ReturnByValue::coeff because this function is
+   * efficient enough.
+   */
+  Scalar coeff(Index i) const {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
+    return m_A.coeff(i / m_B.size()) * m_B.coeff(i % m_B.size());
+  }
+
+ protected:
+  typename Lhs::Nested m_A;
+  typename Rhs::Nested m_B;
+};
+
+/*!
+ * \ingroup KroneckerProduct_Module
+ *
+ * \brief Kronecker tensor product helper class for dense matrices
+ *
+ * This class is the return value of kroneckerProduct(MatrixBase,
+ * MatrixBase). Use the function rather than construct this class
+ * directly to avoid specifying template parameters.
+ *
+ * \tparam Lhs  Type of the left-hand side, a matrix expression.
+ * \tparam Rhs  Type of the right-hand side, a matrix expression.
+ */
+template <typename Lhs, typename Rhs>
+class KroneckerProduct : public KroneckerProductBase<KroneckerProduct<Lhs, Rhs> > {
+ private:
+  typedef KroneckerProductBase<KroneckerProduct> Base;
+  using Base::m_A;
+  using Base::m_B;
+
+ public:
+  /*! \brief Constructor. */
+  KroneckerProduct(const Lhs& A, const Rhs& B) : Base(A, B) {}
+
+  /*! \brief Evaluate the Kronecker tensor product. */
+  template <typename Dest>
+  void evalTo(Dest& dst) const;
+};
+
+/*!
+ * \ingroup KroneckerProduct_Module
+ *
+ * \brief Kronecker tensor product helper class for sparse matrices
+ *
+ * If at least one of the operands is a sparse matrix expression,
+ * then this class is returned and evaluates into a sparse matrix.
+ *
+ * This class is the return value of kroneckerProduct(EigenBase,
+ * EigenBase). Use the function rather than construct this class
+ * directly to avoid specifying template parameters.
+ *
+ * \tparam Lhs  Type of the left-hand side, a matrix expression.
+ * \tparam Rhs  Type of the right-hand side, a matrix expression.
+ */
+template <typename Lhs, typename Rhs>
+class KroneckerProductSparse : public KroneckerProductBase<KroneckerProductSparse<Lhs, Rhs> > {
+ private:
+  typedef KroneckerProductBase<KroneckerProductSparse> Base;
+  using Base::m_A;
+  using Base::m_B;
+
+ public:
+  /*! \brief Constructor. */
+  KroneckerProductSparse(const Lhs& A, const Rhs& B) : Base(A, B) {}
+
+  /*! \brief Evaluate the Kronecker tensor product. */
+  template <typename Dest>
+  void evalTo(Dest& dst) const;
+};
+
+template <typename Lhs, typename Rhs>
+template <typename Dest>
+void KroneckerProduct<Lhs, Rhs>::evalTo(Dest& dst) const {
+  const int BlockRows = Rhs::RowsAtCompileTime, BlockCols = Rhs::ColsAtCompileTime;
+  const Index Br = m_B.rows(), Bc = m_B.cols();
+  for (Index i = 0; i < m_A.rows(); ++i)
+    for (Index j = 0; j < m_A.cols(); ++j)
+      Block<Dest, BlockRows, BlockCols>(dst, i * Br, j * Bc, Br, Bc) = m_A.coeff(i, j) * m_B;
+}
+
+template <typename Lhs, typename Rhs>
+template <typename Dest>
+void KroneckerProductSparse<Lhs, Rhs>::evalTo(Dest& dst) const {
+  Index Br = m_B.rows(), Bc = m_B.cols();
+  dst.resize(this->rows(), this->cols());
+  dst.resizeNonZeros(0);
+
+  // 1 - evaluate the operands if needed:
+  typedef typename internal::nested_eval<Lhs, Dynamic>::type Lhs1;
+  typedef internal::remove_all_t<Lhs1> Lhs1Cleaned;
+  const Lhs1 lhs1(m_A);
+  typedef typename internal::nested_eval<Rhs, Dynamic>::type Rhs1;
+  typedef internal::remove_all_t<Rhs1> Rhs1Cleaned;
+  const Rhs1 rhs1(m_B);
+
+  // 2 - construct respective iterators
+  typedef Eigen::InnerIterator<Lhs1Cleaned> LhsInnerIterator;
+  typedef Eigen::InnerIterator<Rhs1Cleaned> RhsInnerIterator;
+
+  // compute number of non-zeros per innervectors of dst
+  {
+    // TODO: VectorXi is not necessarily big enough!
+    VectorXi nnzA = VectorXi::Zero(Dest::IsRowMajor ? m_A.rows() : m_A.cols());
+    for (Index kA = 0; kA < m_A.outerSize(); ++kA)
+      for (LhsInnerIterator itA(lhs1, kA); itA; ++itA) nnzA(Dest::IsRowMajor ? itA.row() : itA.col())++;
+
+    VectorXi nnzB = VectorXi::Zero(Dest::IsRowMajor ? m_B.rows() : m_B.cols());
+    for (Index kB = 0; kB < m_B.outerSize(); ++kB)
+      for (RhsInnerIterator itB(rhs1, kB); itB; ++itB) nnzB(Dest::IsRowMajor ? itB.row() : itB.col())++;
+
+    Matrix<int, Dynamic, Dynamic, ColMajor> nnzAB = nnzB * nnzA.transpose();
+    dst.reserve(nnzAB.reshaped());
+  }
+
+  for (Index kA = 0; kA < m_A.outerSize(); ++kA) {
+    for (Index kB = 0; kB < m_B.outerSize(); ++kB) {
+      for (LhsInnerIterator itA(lhs1, kA); itA; ++itA) {
+        for (RhsInnerIterator itB(rhs1, kB); itB; ++itB) {
+          Index i = itA.row() * Br + itB.row(), j = itA.col() * Bc + itB.col();
+          dst.insert(i, j) = itA.value() * itB.value();
+        }
+      }
+    }
+  }
+}
+
+namespace internal {
+
+template <typename Lhs_, typename Rhs_>
+struct traits<KroneckerProduct<Lhs_, Rhs_> > {
+  typedef remove_all_t<Lhs_> Lhs;
+  typedef remove_all_t<Rhs_> Rhs;
+  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
+  typedef typename promote_index_type<typename Lhs::StorageIndex, typename Rhs::StorageIndex>::type StorageIndex;
+
+  enum {
+    Rows = size_at_compile_time(traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime),
+    Cols = size_at_compile_time(traits<Lhs>::ColsAtCompileTime, traits<Rhs>::ColsAtCompileTime),
+    MaxRows = size_at_compile_time(traits<Lhs>::MaxRowsAtCompileTime, traits<Rhs>::MaxRowsAtCompileTime),
+    MaxCols = size_at_compile_time(traits<Lhs>::MaxColsAtCompileTime, traits<Rhs>::MaxColsAtCompileTime)
+  };
+
+  typedef Matrix<Scalar, Rows, Cols> ReturnType;
+};
+
+template <typename Lhs_, typename Rhs_>
+struct traits<KroneckerProductSparse<Lhs_, Rhs_> > {
+  typedef MatrixXpr XprKind;
+  typedef remove_all_t<Lhs_> Lhs;
+  typedef remove_all_t<Rhs_> Rhs;
+  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
+  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind, typename traits<Rhs>::StorageKind,
+                                              scalar_product_op<typename Lhs::Scalar, typename Rhs::Scalar> >::ret
+      StorageKind;
+  typedef typename promote_index_type<typename Lhs::StorageIndex, typename Rhs::StorageIndex>::type StorageIndex;
+
+  enum {
+    LhsFlags = Lhs::Flags,
+    RhsFlags = Rhs::Flags,
+
+    RowsAtCompileTime = size_at_compile_time(traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime),
+    ColsAtCompileTime = size_at_compile_time(traits<Lhs>::ColsAtCompileTime, traits<Rhs>::ColsAtCompileTime),
+    MaxRowsAtCompileTime = size_at_compile_time(traits<Lhs>::MaxRowsAtCompileTime, traits<Rhs>::MaxRowsAtCompileTime),
+    MaxColsAtCompileTime = size_at_compile_time(traits<Lhs>::MaxColsAtCompileTime, traits<Rhs>::MaxColsAtCompileTime),
+
+    EvalToRowMajor = (int(LhsFlags) & int(RhsFlags) & RowMajorBit),
+    RemovedBits = ~(EvalToRowMajor ? 0 : RowMajorBit),
+
+    Flags = ((int(LhsFlags) | int(RhsFlags)) & HereditaryBits & RemovedBits) | EvalBeforeNestingBit,
+    CoeffReadCost = HugeCost
+  };
+
+  typedef SparseMatrix<Scalar, 0, StorageIndex> ReturnType;
+};
+
+}  // end namespace internal
+
+/*!
+ * \ingroup KroneckerProduct_Module
+ *
+ * Computes Kronecker tensor product of two dense matrices
+ *
+ * \warning If you want to replace a matrix by its Kronecker product
+ *          with some matrix, do \b NOT do this:
+ * \code
+ * A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect
+ * \endcode
+ * instead, use eval() to work around this:
+ * \code
+ * A = kroneckerProduct(A,B).eval();
+ * \endcode
+ *
+ * \param a  Dense matrix a
+ * \param b  Dense matrix b
+ * \return   Kronecker tensor product of a and b
+ */
+template <typename A, typename B>
+KroneckerProduct<A, B> kroneckerProduct(const MatrixBase<A>& a, const MatrixBase<B>& b) {
+  return KroneckerProduct<A, B>(a.derived(), b.derived());
+}
+
+/*!
+ * \ingroup KroneckerProduct_Module
+ *
+ * Computes Kronecker tensor product of two matrices, at least one of
+ * which is sparse
+ *
+ * \warning If you want to replace a matrix by its Kronecker product
+ *          with some matrix, do \b NOT do this:
+ * \code
+ * A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect
+ * \endcode
+ * instead, use eval() to work around this:
+ * \code
+ * A = kroneckerProduct(A,B).eval();
+ * \endcode
+ *
+ * \param a  Dense/sparse matrix a
+ * \param b  Dense/sparse matrix b
+ * \return   Kronecker tensor product of a and b, stored in a sparse
+ *           matrix
+ */
+template <typename A, typename B>
+KroneckerProductSparse<A, B> kroneckerProduct(const EigenBase<A>& a, const EigenBase<B>& b) {
+  return KroneckerProductSparse<A, B>(a.derived(), b.derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // KRONECKER_TENSOR_PRODUCT_H
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/CopyrightMINPACK.txt b/contrib/Eigen/src/LevenbergMarquardt/CopyrightMINPACK.txt
similarity index 100%
rename from unsupported/Eigen/src/LevenbergMarquardt/CopyrightMINPACK.txt
rename to contrib/Eigen/src/LevenbergMarquardt/CopyrightMINPACK.txt
diff --git a/contrib/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h b/contrib/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h
new file mode 100644
index 0000000..751871f
--- /dev/null
+++ b/contrib/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_LEVENBERGMARQUARDT_MODULE_H
+#error "Please include contrib/Eigen/LevenbergMarquardt instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/LevenbergMarquardt/LMcovar.h b/contrib/Eigen/src/LevenbergMarquardt/LMcovar.h
new file mode 100644
index 0000000..cf1b3c4
--- /dev/null
+++ b/contrib/Eigen/src/LevenbergMarquardt/LMcovar.h
@@ -0,0 +1,81 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This code initially comes from MINPACK whose original authors are:
+// Copyright Jorge More - Argonne National Laboratory
+// Copyright Burt Garbow - Argonne National Laboratory
+// Copyright Ken Hillstrom - Argonne National Laboratory
+//
+// This Source Code Form is subject to the terms of the Minpack license
+// (a BSD-like license) described in the accompanying CopyrightMINPACK.txt file.
+// SPDX-License-Identifier: MPL-2.0 AND LicenseRef-MINPACK
+
+#ifndef EIGEN_LMCOVAR_H
+#define EIGEN_LMCOVAR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void covar(Matrix<Scalar, Dynamic, Dynamic>& r, const VectorXi& ipvt,
+           Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon())) {
+  using std::abs;
+  /* Local variables */
+  Index i, j, k, l, ii, jj;
+  bool sing;
+  Scalar temp;
+
+  /* Function Body */
+  const Index n = r.cols();
+  const Scalar tolr = tol * abs(r(0, 0));
+  Matrix<Scalar, Dynamic, 1> wa(n);
+  eigen_assert(ipvt.size() == n);
+
+  /* form the inverse of r in the full upper triangle of r. */
+  l = -1;
+  for (k = 0; k < n; ++k)
+    if (abs(r(k, k)) > tolr) {
+      r(k, k) = 1. / r(k, k);
+      for (j = 0; j <= k - 1; ++j) {
+        temp = r(k, k) * r(j, k);
+        r(j, k) = 0.;
+        r.col(k).head(j + 1) -= r.col(j).head(j + 1) * temp;
+      }
+      l = k;
+    }
+
+  /* form the full upper triangle of the inverse of (r transpose)*r */
+  /* in the full upper triangle of r. */
+  for (k = 0; k <= l; ++k) {
+    for (j = 0; j <= k - 1; ++j) r.col(j).head(j + 1) += r.col(k).head(j + 1) * r(j, k);
+    r.col(k).head(k + 1) *= r(k, k);
+  }
+
+  /* form the full lower triangle of the covariance matrix */
+  /* in the strict lower triangle of r and in wa. */
+  for (j = 0; j < n; ++j) {
+    jj = ipvt[j];
+    sing = j > l;
+    for (i = 0; i <= j; ++i) {
+      if (sing) r(i, j) = 0.;
+      ii = ipvt[i];
+      if (ii > jj) r(ii, jj) = r(i, j);
+      if (ii < jj) r(jj, ii) = r(i, j);
+    }
+    wa[jj] = r(j, j);
+  }
+
+  /* symmetrize the covariance matrix in r. */
+  r.topLeftCorner(n, n).template triangularView<StrictlyUpper>() = r.topLeftCorner(n, n).transpose();
+  r.diagonal() = wa;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LMCOVAR_H
diff --git a/contrib/Eigen/src/LevenbergMarquardt/LMonestep.h b/contrib/Eigen/src/LevenbergMarquardt/LMonestep.h
new file mode 100644
index 0000000..821cff3
--- /dev/null
+++ b/contrib/Eigen/src/LevenbergMarquardt/LMonestep.h
@@ -0,0 +1,188 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This code initially comes from MINPACK whose original authors are:
+// Copyright Jorge More - Argonne National Laboratory
+// Copyright Burt Garbow - Argonne National Laboratory
+// Copyright Ken Hillstrom - Argonne National Laboratory
+//
+// This Source Code Form is subject to the terms of the Minpack license
+// (a BSD-like license) described in the CopyrightMINPACK.txt file.
+// SPDX-License-Identifier: MPL-2.0 AND LicenseRef-MINPACK
+
+#ifndef EIGEN_LMONESTEP_H
+#define EIGEN_LMONESTEP_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename FunctorType>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::minimizeOneStep(FVectorType &x) {
+  using std::abs;
+  using std::sqrt;
+  RealScalar temp, temp1, temp2;
+  RealScalar ratio;
+  RealScalar pnorm, xnorm, fnorm1, actred, dirder, prered;
+  eigen_assert(x.size() == n);  // check the caller is not cheating us
+
+  temp = 0.0;
+  xnorm = 0.0;
+  /* calculate the jacobian matrix. */
+  Index df_ret = m_functor.df(x, m_fjac);
+  if (df_ret < 0) return LevenbergMarquardtSpace::UserAsked;
+  if (df_ret > 0)
+    // numerical diff, we evaluated the function df_ret times
+    m_nfev += df_ret;
+  else
+    m_njev++;
+
+  /* compute the qr factorization of the jacobian. */
+  for (int j = 0; j < x.size(); ++j) m_wa2(j) = m_fjac.col(j).blueNorm();
+  QRSolver qrfac(m_fjac);
+  if (qrfac.info() != Success) {
+    m_info = NumericalIssue;
+    return LevenbergMarquardtSpace::ImproperInputParameters;
+  }
+  // Make a copy of the first factor with the associated permutation
+  m_rfactor = qrfac.matrixR();
+  m_permutation = (qrfac.colsPermutation());
+
+  /* on the first iteration and if external scaling is not used, scale according */
+  /* to the norms of the columns of the initial jacobian. */
+  if (m_iter == 1) {
+    if (!m_useExternalScaling)
+      for (Index j = 0; j < n; ++j) m_diag[j] = (m_wa2[j] == 0.) ? 1. : m_wa2[j];
+
+    /* on the first iteration, calculate the norm of the scaled x */
+    /* and initialize the step bound m_delta. */
+    xnorm = m_diag.cwiseProduct(x).stableNorm();
+    m_delta = m_factor * xnorm;
+    if (m_delta == 0.) m_delta = m_factor;
+  }
+
+  /* form (q transpose)*m_fvec and store the first n components in */
+  /* m_qtf. */
+  m_wa4 = m_fvec;
+  m_wa4 = qrfac.matrixQ().adjoint() * m_fvec;
+  m_qtf = m_wa4.head(n);
+
+  /* compute the norm of the scaled gradient. */
+  m_gnorm = 0.;
+  if (m_fnorm != 0.)
+    for (Index j = 0; j < n; ++j)
+      if (m_wa2[m_permutation.indices()[j]] != 0.)
+        m_gnorm = (std::max)(m_gnorm, abs(m_rfactor.col(j).head(j + 1).dot(m_qtf.head(j + 1) / m_fnorm) /
+                                          m_wa2[m_permutation.indices()[j]]));
+
+  /* test for convergence of the gradient norm. */
+  if (m_gnorm <= m_gtol) {
+    m_info = Success;
+    return LevenbergMarquardtSpace::CosinusTooSmall;
+  }
+
+  /* rescale if necessary. */
+  if (!m_useExternalScaling) m_diag = m_diag.cwiseMax(m_wa2);
+
+  do {
+    /* determine the levenberg-marquardt parameter. */
+    internal::lmpar2(qrfac, m_diag, m_qtf, m_delta, m_par, m_wa1);
+
+    /* store the direction p and x + p. calculate the norm of p. */
+    m_wa1 = -m_wa1;
+    m_wa2 = x + m_wa1;
+    pnorm = m_diag.cwiseProduct(m_wa1).stableNorm();
+
+    /* on the first iteration, adjust the initial step bound. */
+    if (m_iter == 1) m_delta = (std::min)(m_delta, pnorm);
+
+    /* evaluate the function at x + p and calculate its norm. */
+    if (m_functor(m_wa2, m_wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
+    ++m_nfev;
+    fnorm1 = m_wa4.stableNorm();
+
+    /* compute the scaled actual reduction. */
+    actred = -1.;
+    if (Scalar(.1) * fnorm1 < m_fnorm) actred = 1. - numext::abs2(fnorm1 / m_fnorm);
+
+    /* compute the scaled predicted reduction and */
+    /* the scaled directional derivative. */
+    m_wa3.noalias() = m_rfactor.template triangularView<Upper>() * (m_permutation.inverse() * m_wa1);
+    temp1 = numext::abs2(m_wa3.stableNorm() / m_fnorm);
+    temp2 = numext::abs2(sqrt(m_par) * pnorm / m_fnorm);
+    prered = temp1 + temp2 / Scalar(.5);
+    dirder = -(temp1 + temp2);
+
+    /* compute the ratio of the actual to the predicted */
+    /* reduction. */
+    ratio = 0.;
+    if (prered != 0.) ratio = actred / prered;
+
+    /* update the step bound. */
+    if (ratio <= Scalar(.25)) {
+      if (actred >= 0.) temp = RealScalar(.5);
+      if (actred < 0.) temp = RealScalar(.5) * dirder / (dirder + RealScalar(.5) * actred);
+      if (RealScalar(.1) * fnorm1 >= m_fnorm || temp < RealScalar(.1)) temp = Scalar(.1);
+      /* Computing MIN */
+      m_delta = temp * (std::min)(m_delta, pnorm / RealScalar(.1));
+      m_par /= temp;
+    } else if (!(m_par != 0. && ratio < RealScalar(.75))) {
+      m_delta = pnorm / RealScalar(.5);
+      m_par = RealScalar(.5) * m_par;
+    }
+
+    /* test for successful iteration. */
+    if (ratio >= RealScalar(1e-4)) {
+      /* successful iteration. update x, m_fvec, and their norms. */
+      x = m_wa2;
+      m_wa2 = m_diag.cwiseProduct(x);
+      m_fvec = m_wa4;
+      xnorm = m_wa2.stableNorm();
+      m_fnorm = fnorm1;
+      ++m_iter;
+    }
+
+    /* tests for convergence. */
+    if (abs(actred) <= m_ftol && prered <= m_ftol && Scalar(.5) * ratio <= 1. && m_delta <= m_xtol * xnorm) {
+      m_info = Success;
+      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
+    }
+    if (abs(actred) <= m_ftol && prered <= m_ftol && Scalar(.5) * ratio <= 1.) {
+      m_info = Success;
+      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
+    }
+    if (m_delta <= m_xtol * xnorm) {
+      m_info = Success;
+      return LevenbergMarquardtSpace::RelativeErrorTooSmall;
+    }
+
+    /* tests for termination and stringent tolerances. */
+    if (m_nfev >= m_maxfev) {
+      m_info = NoConvergence;
+      return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
+    }
+    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
+        Scalar(.5) * ratio <= 1.) {
+      m_info = Success;
+      return LevenbergMarquardtSpace::FtolTooSmall;
+    }
+    if (m_delta <= NumTraits<Scalar>::epsilon() * xnorm) {
+      m_info = Success;
+      return LevenbergMarquardtSpace::XtolTooSmall;
+    }
+    if (m_gnorm <= NumTraits<Scalar>::epsilon()) {
+      m_info = Success;
+      return LevenbergMarquardtSpace::GtolTooSmall;
+    }
+
+  } while (ratio < Scalar(1e-4));
+
+  return LevenbergMarquardtSpace::Running;
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LMONESTEP_H
diff --git a/contrib/Eigen/src/LevenbergMarquardt/LMpar.h b/contrib/Eigen/src/LevenbergMarquardt/LMpar.h
new file mode 100644
index 0000000..b8d7fc1
--- /dev/null
+++ b/contrib/Eigen/src/LevenbergMarquardt/LMpar.h
@@ -0,0 +1,147 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This code initially comes from MINPACK whose original authors are:
+// Copyright Jorge More - Argonne National Laboratory
+// Copyright Burt Garbow - Argonne National Laboratory
+// Copyright Ken Hillstrom - Argonne National Laboratory
+//
+// This Source Code Form is subject to the terms of the Minpack license
+// (a BSD-like license) described in the accompanying CopyrightMINPACK.txt file.
+// SPDX-License-Identifier: MPL-2.0 AND LicenseRef-MINPACK
+
+#ifndef EIGEN_LMPAR_H
+#define EIGEN_LMPAR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename QRSolver, typename VectorType>
+void lmpar2(const QRSolver &qr, const VectorType &diag, const VectorType &qtb, typename VectorType::Scalar m_delta,
+            typename VectorType::Scalar &par, VectorType &x)
+
+{
+  using std::abs;
+  using std::sqrt;
+  typedef typename QRSolver::Scalar Scalar;
+  /* Local variables */
+  Index j;
+  Scalar fp;
+  Scalar parc, parl;
+  Index iter;
+  Scalar temp, paru;
+  Scalar gnorm;
+  Scalar dxnorm;
+
+  /* Function Body */
+  const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
+  const Index n = qr.matrixR().cols();
+
+  // Working copy of the leading n-by-n block of the triangular factor; lmqrsolv()
+  // overwrites its strict lower triangle with the eliminated factor read back
+  // below. The rotations fill that triangle in completely, so this is dense even
+  // when the QR is sparse.
+  Matrix<Scalar, Dynamic, Dynamic> s = qr.matrixR().topLeftCorner(n, n);
+
+  eigen_assert(n == diag.size());
+  eigen_assert(n == qtb.size());
+
+  VectorType wa1, wa2;
+
+  /* compute and store in x the gauss-newton direction. if the */
+  /* jacobian is rank-deficient, obtain a least squares solution. */
+
+  const Index rank = qr.rank();  // use a threshold
+  wa1 = qtb;
+  wa1.tail(n - rank).setZero();
+  s.topLeftCorner(rank, rank).template triangularView<Upper>().solveInPlace(wa1.head(rank));
+
+  x = qr.colsPermutation() * wa1;
+
+  /* initialize the iteration counter. */
+  /* evaluate the function at the origin, and test */
+  /* for acceptance of the gauss-newton direction. */
+  iter = 0;
+  wa2 = diag.cwiseProduct(x);
+  dxnorm = wa2.blueNorm();
+  fp = dxnorm - m_delta;
+  if (fp <= Scalar(0.1) * m_delta) {
+    par = 0;
+    return;
+  }
+
+  /* if the jacobian is not rank deficient, the newton */
+  /* step provides a lower bound, parl, for the zero of */
+  /* the function. otherwise set this bound to zero. */
+  parl = 0.;
+  if (rank == n) {
+    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2) / dxnorm;
+    s.topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
+    temp = wa1.blueNorm();
+    parl = fp / m_delta / temp / temp;
+  }
+
+  /* calculate an upper bound, paru, for the zero of the function. */
+  for (j = 0; j < n; ++j) wa1[j] = s.col(j).head(j + 1).dot(qtb.head(j + 1)) / diag[qr.colsPermutation().indices()(j)];
+
+  gnorm = wa1.stableNorm();
+  paru = gnorm / m_delta;
+  if (paru == 0.) paru = dwarf / (std::min)(m_delta, Scalar(0.1));
+
+  /* if the input par lies outside of the interval (parl,paru), */
+  /* set par to the closer endpoint. */
+  par = (std::max)(par, parl);
+  par = (std::min)(par, paru);
+  if (par == 0.) par = gnorm / dxnorm;
+
+  /* beginning of an iteration. */
+  while (true) {
+    ++iter;
+
+    /* evaluate the function at the current value of par. */
+    if (par == 0.) par = (std::max)(dwarf, Scalar(.001) * paru); /* Computing MAX */
+    wa1 = sqrt(par) * diag;
+
+    VectorType sdiag(n);
+    lmqrsolv(s, qr.colsPermutation(), wa1, qtb, x, sdiag);
+
+    wa2 = diag.cwiseProduct(x);
+    dxnorm = wa2.blueNorm();
+    temp = fp;
+    fp = dxnorm - m_delta;
+
+    /* if the function is small enough, accept the current value */
+    /* of par. also test for the exceptional cases where parl */
+    /* is zero or the number of iterations has reached 10. */
+    if (abs(fp) <= Scalar(0.1) * m_delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10) break;
+
+    /* compute the newton correction. */
+    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2 / dxnorm);
+    // we could almost use this here, but the diagonal is outside qr, in sdiag[]
+    for (j = 0; j < n; ++j) {
+      wa1[j] /= sdiag[j];
+      temp = wa1[j];
+      for (Index i = j + 1; i < n; ++i) wa1[i] -= s.coeff(i, j) * temp;
+    }
+    temp = wa1.blueNorm();
+    parc = fp / m_delta / temp / temp;
+
+    /* depending on the sign of the function, update parl or paru. */
+    if (fp > 0.) parl = (std::max)(parl, par);
+    if (fp < 0.) paru = (std::min)(paru, par);
+
+    /* compute an improved estimate for par. */
+    par = (std::max)(parl, par + parc);
+  }
+  if (iter == 0) par = 0.;
+  return;
+}
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LMPAR_H
diff --git a/contrib/Eigen/src/LevenbergMarquardt/LMqrsolv.h b/contrib/Eigen/src/LevenbergMarquardt/LMqrsolv.h
new file mode 100644
index 0000000..6974e38
--- /dev/null
+++ b/contrib/Eigen/src/LevenbergMarquardt/LMqrsolv.h
@@ -0,0 +1,101 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+//
+// This code initially comes from MINPACK whose original authors are:
+// Copyright Jorge More - Argonne National Laboratory
+// Copyright Burt Garbow - Argonne National Laboratory
+// Copyright Ken Hillstrom - Argonne National Laboratory
+//
+// This Source Code Form is subject to the terms of the Minpack license
+// (a BSD-like license) described in the accompanying CopyrightMINPACK.txt file.
+// SPDX-License-Identifier: MPL-2.0 AND LicenseRef-MINPACK
+
+#ifndef EIGEN_LMQRSOLV_H
+#define EIGEN_LMQRSOLV_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar, int Rows, int Cols, typename PermIndex>
+void lmqrsolv(Matrix<Scalar, Rows, Cols> &s, const PermutationMatrix<Dynamic, Dynamic, PermIndex> &iPerm,
+              const Matrix<Scalar, Dynamic, 1> &diag, const Matrix<Scalar, Dynamic, 1> &qtb,
+              Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &sdiag) {
+  /* Local variables */
+  Index i, j, k;
+  Scalar temp;
+  Index n = s.cols();
+  Matrix<Scalar, Dynamic, 1> wa(n);
+  JacobiRotation<Scalar> givens;
+
+  /* Function Body */
+  // the following will only change the lower triangular part of s, including
+  // the diagonal, though the diagonal is restored afterward
+
+  /*     copy r and (q transpose)*b to preserve input and initialize s. */
+  /*     in particular, save the diagonal elements of r in x. */
+  x = s.diagonal();
+  wa = qtb;
+
+  s.topLeftCorner(n, n).template triangularView<StrictlyLower>() = s.topLeftCorner(n, n).transpose();
+  /*     eliminate the diagonal matrix d using a givens rotation. */
+  for (j = 0; j < n; ++j) {
+    /*        prepare the row of d to be eliminated, locating the */
+    /*        diagonal element using p from the qr factorization. */
+    const PermIndex l = iPerm.indices()(j);
+    if (diag[l] == 0.) break;
+    sdiag.tail(n - j).setZero();
+    sdiag[j] = diag[l];
+
+    /*        the transformations to eliminate the row of d */
+    /*        modify only a single element of (q transpose)*b */
+    /*        beyond the first n, which is initially zero. */
+    Scalar qtbpj = 0.;
+    for (k = j; k < n; ++k) {
+      /*           determine a givens rotation which eliminates the */
+      /*           appropriate element in the current row of d. */
+      givens.makeGivens(-s(k, k), sdiag[k]);
+
+      /*           compute the modified diagonal element of r and */
+      /*           the modified element of ((q transpose)*b,0). */
+      s(k, k) = givens.c() * s(k, k) + givens.s() * sdiag[k];
+      temp = givens.c() * wa[k] + givens.s() * qtbpj;
+      qtbpj = -givens.s() * wa[k] + givens.c() * qtbpj;
+      wa[k] = temp;
+
+      /*           accumulate the transformation in the row of s. */
+      for (i = k + 1; i < n; ++i) {
+        temp = givens.c() * s(i, k) + givens.s() * sdiag[i];
+        sdiag[i] = -givens.s() * s(i, k) + givens.c() * sdiag[i];
+        s(i, k) = temp;
+      }
+    }
+  }
+
+  /*     solve the triangular system for z. if the system is */
+  /*     singular, then obtain a least squares solution. */
+  Index nsing;
+  for (nsing = 0; nsing < n && sdiag[nsing] != 0; nsing++) {
+  }
+
+  wa.tail(n - nsing).setZero();
+  s.topLeftCorner(nsing, nsing).transpose().template triangularView<Upper>().solveInPlace(wa.head(nsing));
+
+  // restore
+  sdiag = s.diagonal();
+  s.diagonal() = x;
+
+  /* permute the components of z back to components of x. */
+  x = iPerm * wa;
+}
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LMQRSOLV_H
diff --git a/contrib/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h b/contrib/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h
new file mode 100644
index 0000000..7b575b6
--- /dev/null
+++ b/contrib/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h
@@ -0,0 +1,362 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
+//
+// The algorithm of this class initially comes from MINPACK whose original authors are:
+// Copyright Jorge More - Argonne National Laboratory
+// Copyright Burt Garbow - Argonne National Laboratory
+// Copyright Ken Hillstrom - Argonne National Laboratory
+//
+// This Source Code Form is subject to the terms of the Minpack license
+// (a BSD-like license) described in the accompanying CopyrightMINPACK.txt file.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0 AND LicenseRef-MINPACK
+
+#ifndef EIGEN_LEVENBERGMARQUARDT_H
+#define EIGEN_LEVENBERGMARQUARDT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace LevenbergMarquardtSpace {
+enum Status {
+  NotStarted = -2,
+  Running = -1,
+  ImproperInputParameters = 0,
+  RelativeReductionTooSmall = 1,
+  RelativeErrorTooSmall = 2,
+  RelativeErrorAndReductionTooSmall = 3,
+  CosinusTooSmall = 4,
+  TooManyFunctionEvaluation = 5,
+  FtolTooSmall = 6,
+  XtolTooSmall = 7,
+  GtolTooSmall = 8,
+  UserAsked = 9
+};
+}
+
+template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
+struct DenseFunctor {
+  typedef Scalar_ Scalar;
+  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
+  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
+  typedef ColPivHouseholderQR<JacobianType> QRSolver;
+  const int m_inputs = InputsAtCompileTime;
+  const int m_values = ValuesAtCompileTime;
+
+  DenseFunctor() = default;
+  DenseFunctor(int inputs, int values) : m_inputs(inputs), m_values(values) {}
+
+  int inputs() const { return m_inputs; }
+  int values() const { return m_values; }
+
+  // int operator()(const InputType &x, ValueType& fvec) { }
+  //  should be defined in derived classes
+
+  // int df(const InputType &x, JacobianType& fjac) { }
+  //  should be defined in derived classes
+};
+
+template <typename Scalar_, typename Index_>
+struct SparseFunctor {
+  typedef Scalar_ Scalar;
+  typedef Index_ Index;
+  typedef Matrix<Scalar, Dynamic, 1> InputType;
+  typedef Matrix<Scalar, Dynamic, 1> ValueType;
+  typedef SparseMatrix<Scalar, ColMajor, Index> JacobianType;
+  typedef SparseQR<JacobianType, COLAMDOrdering<int> > QRSolver;
+  enum { InputsAtCompileTime = Dynamic, ValuesAtCompileTime = Dynamic };
+
+  SparseFunctor(int inputs, int values) : m_inputs(inputs), m_values(values) {}
+
+  int inputs() const { return m_inputs; }
+  int values() const { return m_values; }
+
+  const int m_inputs, m_values;
+  // int operator()(const InputType &x, ValueType& fvec) { }
+  //  to be defined in the functor
+
+  // int df(const InputType &x, JacobianType& fjac) { }
+  //  to be defined in the functor if no automatic differentiation
+};
+namespace internal {
+template <typename QRSolver, typename VectorType>
+void lmpar2(const QRSolver &qr, const VectorType &diag, const VectorType &qtb, typename VectorType::Scalar m_delta,
+            typename VectorType::Scalar &par, VectorType &x);
+}
+/**
+ * \ingroup NonLinearOptimization_Module
+ * \brief Performs non linear optimization over a non-linear function,
+ * using a variant of the Levenberg Marquardt algorithm.
+ *
+ * Check wikipedia for more information.
+ * http://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm
+ */
+template <typename FunctorType_>
+class LevenbergMarquardt : internal::no_assignment_operator {
+ public:
+  typedef FunctorType_ FunctorType;
+  typedef typename FunctorType::QRSolver QRSolver;
+  typedef typename FunctorType::JacobianType JacobianType;
+  typedef typename JacobianType::Scalar Scalar;
+  typedef typename JacobianType::RealScalar RealScalar;
+  typedef typename QRSolver::StorageIndex PermIndex;
+  typedef Matrix<Scalar, Dynamic, 1> FVectorType;
+  typedef PermutationMatrix<Dynamic, Dynamic, int> PermutationType;
+
+ public:
+  LevenbergMarquardt(FunctorType &functor)
+      : m_functor(functor),
+        m_nfev(0),
+        m_njev(0),
+        m_fnorm(0.0),
+        m_gnorm(0),
+        m_isInitialized(false),
+        m_info(InvalidInput) {
+    resetParameters();
+    m_useExternalScaling = false;
+  }
+
+  LevenbergMarquardtSpace::Status minimize(FVectorType &x);
+  LevenbergMarquardtSpace::Status minimizeInit(FVectorType &x);
+  LevenbergMarquardtSpace::Status minimizeOneStep(FVectorType &x);
+  LevenbergMarquardtSpace::Status lmder1(FVectorType &x, const Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon()));
+  static LevenbergMarquardtSpace::Status lmdif1(FunctorType &functor, FVectorType &x, Index *nfev,
+                                                const Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon()));
+
+  /** Sets the default parameters */
+  void resetParameters() {
+    using std::sqrt;
+
+    m_factor = 100.;
+    m_maxfev = 400;
+    m_ftol = sqrt(NumTraits<RealScalar>::epsilon());
+    m_xtol = sqrt(NumTraits<RealScalar>::epsilon());
+    m_gtol = 0.;
+    m_epsfcn = 0.;
+  }
+
+  /** Sets the tolerance for the norm of the solution vector*/
+  void setXtol(RealScalar xtol) { m_xtol = xtol; }
+
+  /** Sets the tolerance for the norm of the vector function*/
+  void setFtol(RealScalar ftol) { m_ftol = ftol; }
+
+  /** Sets the tolerance for the norm of the gradient of the error vector*/
+  void setGtol(RealScalar gtol) { m_gtol = gtol; }
+
+  /** Sets the step bound for the diagonal shift */
+  void setFactor(RealScalar factor) { m_factor = factor; }
+
+  /** Sets the error precision  */
+  void setEpsilon(RealScalar epsfcn) { m_epsfcn = epsfcn; }
+
+  /** Sets the maximum number of function evaluation */
+  void setMaxfev(Index maxfev) { m_maxfev = maxfev; }
+
+  /** Use an external Scaling. If set to true, pass a nonzero diagonal to diag() */
+  void setExternalScaling(bool value) { m_useExternalScaling = value; }
+
+  /** \returns the tolerance for the norm of the solution vector */
+  RealScalar xtol() const { return m_xtol; }
+
+  /** \returns the tolerance for the norm of the vector function */
+  RealScalar ftol() const { return m_ftol; }
+
+  /** \returns the tolerance for the norm of the gradient of the error vector */
+  RealScalar gtol() const { return m_gtol; }
+
+  /** \returns the step bound for the diagonal shift */
+  RealScalar factor() const { return m_factor; }
+
+  /** \returns the error precision */
+  RealScalar epsilon() const { return m_epsfcn; }
+
+  /** \returns the maximum number of function evaluation */
+  Index maxfev() const { return m_maxfev; }
+
+  /** \returns a reference to the diagonal of the jacobian */
+  FVectorType &diag() { return m_diag; }
+
+  /** \returns the number of iterations performed */
+  Index iterations() const { return m_iter; }
+
+  /** \returns the number of functions evaluation */
+  Index nfev() const { return m_nfev; }
+
+  /** \returns the number of jacobian evaluation */
+  Index njev() const { return m_njev; }
+
+  /** \returns the norm of current vector function */
+  RealScalar fnorm() const { return m_fnorm; }
+
+  /** \returns the norm of the gradient of the error */
+  RealScalar gnorm() const { return m_gnorm; }
+
+  /** \returns the LevenbergMarquardt parameter */
+  RealScalar lm_param(void) const { return m_par; }
+
+  /** \returns a reference to the  current vector function
+   */
+  FVectorType &fvec() { return m_fvec; }
+
+  /** \returns a reference to the matrix where the current Jacobian matrix is stored
+   */
+  JacobianType &jacobian() { return m_fjac; }
+
+  /** \returns a reference to the triangular matrix R from the QR of the jacobian matrix.
+   * \sa jacobian()
+   */
+  JacobianType &matrixR() { return m_rfactor; }
+
+  /** the permutation used in the QR factorization
+   */
+  PermutationType permutation() const { return m_permutation; }
+
+  /**
+   * \brief Reports whether the minimization was successful
+   * \returns \c Success if the minimization was successful,
+   *         \c NumericalIssue if a numerical problem arises during the
+   *          minimization process, for example during the QR factorization
+   *         \c NoConvergence if the minimization did not converge after
+   *          the maximum number of function evaluation allowed
+   *          \c InvalidInput if the input matrix is invalid
+   */
+  ComputationInfo info() const { return m_info; }
+
+ private:
+  JacobianType m_fjac;
+  JacobianType m_rfactor;  // The triangular matrix R from the QR of the jacobian matrix m_fjac
+  FunctorType &m_functor;
+  FVectorType m_fvec, m_qtf, m_diag;
+  Index n;
+  Index m;
+  Index m_nfev;
+  Index m_njev;
+  RealScalar m_fnorm;   // Norm of the current vector function
+  RealScalar m_gnorm;   // Norm of the gradient of the error
+  RealScalar m_factor;  //
+  Index m_maxfev;       // Maximum number of function evaluation
+  RealScalar m_ftol;    // Tolerance in the norm of the vector function
+  RealScalar m_xtol;    //
+  RealScalar m_gtol;    // tolerance of the norm of the error gradient
+  RealScalar m_epsfcn;  //
+  Index m_iter;         // Number of iterations performed
+  RealScalar m_delta;
+  bool m_useExternalScaling;
+  PermutationType m_permutation;
+  FVectorType m_wa1, m_wa2, m_wa3, m_wa4;  // Temporary vectors
+  RealScalar m_par;
+  bool m_isInitialized;  // Check whether the minimization step has been called
+  ComputationInfo m_info;
+};
+
+template <typename FunctorType>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::minimize(FVectorType &x) {
+  LevenbergMarquardtSpace::Status status = minimizeInit(x);
+  if (status == LevenbergMarquardtSpace::ImproperInputParameters) {
+    m_isInitialized = true;
+    return status;
+  }
+  do {
+    status = minimizeOneStep(x);
+  } while (status == LevenbergMarquardtSpace::Running);
+  m_isInitialized = true;
+  return status;
+}
+
+template <typename FunctorType>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::minimizeInit(FVectorType &x) {
+  n = x.size();
+  m = m_functor.values();
+
+  m_wa1.resize(n);
+  m_wa2.resize(n);
+  m_wa3.resize(n);
+  m_wa4.resize(m);
+  m_fvec.resize(m);
+  // FIXME: Sparse case: allocate space for the Jacobian.
+  m_fjac.resize(m, n);
+  if (!m_useExternalScaling) m_diag.resize(n);
+  eigen_assert((!m_useExternalScaling || m_diag.size() == n) &&
+               "When m_useExternalScaling is set, the caller must provide a valid 'm_diag'");
+  m_qtf.resize(n);
+
+  /* Function Body */
+  m_nfev = 0;
+  m_njev = 0;
+
+  /*     check the input parameters for errors. */
+  if (n <= 0 || m < n || m_ftol < 0. || m_xtol < 0. || m_gtol < 0. || m_maxfev <= 0 || m_factor <= 0.) {
+    m_info = InvalidInput;
+    return LevenbergMarquardtSpace::ImproperInputParameters;
+  }
+
+  if (m_useExternalScaling)
+    for (Index j = 0; j < n; ++j)
+      if (m_diag[j] <= 0.) {
+        m_info = InvalidInput;
+        return LevenbergMarquardtSpace::ImproperInputParameters;
+      }
+
+  /*     evaluate the function at the starting point */
+  /*     and calculate its norm. */
+  m_nfev = 1;
+  if (m_functor(x, m_fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
+  m_fnorm = m_fvec.stableNorm();
+
+  /*     initialize levenberg-marquardt parameter and iteration counter. */
+  m_par = 0.;
+  m_iter = 1;
+
+  return LevenbergMarquardtSpace::NotStarted;
+}
+
+template <typename FunctorType>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::lmder1(FVectorType &x, const Scalar tol) {
+  n = x.size();
+  m = m_functor.values();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  resetParameters();
+  m_ftol = tol;
+  m_xtol = tol;
+  m_maxfev = 100 * (n + 1);
+
+  return minimize(x);
+}
+
+template <typename FunctorType>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::lmdif1(FunctorType &functor, FVectorType &x,
+                                                                        Index *nfev, const Scalar tol) {
+  Index n = x.size();
+  Index m = functor.values();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  NumericalDiff<FunctorType> numDiff(functor);
+  // embedded LevenbergMarquardt
+  LevenbergMarquardt<NumericalDiff<FunctorType> > lm(numDiff);
+  lm.setFtol(tol);
+  lm.setXtol(tol);
+  lm.setMaxfev(200 * (n + 1));
+
+  LevenbergMarquardtSpace::Status info = LevenbergMarquardtSpace::Status(lm.minimize(x));
+  if (nfev) *nfev = lm.nfev();
+  return info;
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LEVENBERGMARQUARDT_H
diff --git a/contrib/Eigen/src/MatrixFunctions/InternalHeaderCheck.h b/contrib/Eigen/src/MatrixFunctions/InternalHeaderCheck.h
new file mode 100644
index 0000000..99cbbb0
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_FUNCTIONS_MODULE_H
+#error "Please include contrib/Eigen/MatrixFunctions instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/MatrixFunctions/MatrixExponential.h b/contrib/Eigen/src/MatrixFunctions/MatrixExponential.h
new file mode 100644
index 0000000..3a6d7ae
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/MatrixExponential.h
@@ -0,0 +1,432 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009, 2010, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2011, 2013 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_EXPONENTIAL
+#define EIGEN_MATRIX_EXPONENTIAL
+
+#include "StemFunction.h"
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+/** \brief Scale a real or complex matrix by \f$ 2^{-s} \f$. */
+template <typename MatrixType,
+          bool HasWritableRealView = !NumTraits<typename traits<MatrixType>::Scalar>::IsComplex ||
+                                     complex_array_access<typename traits<MatrixType>::Scalar>::value>
+struct matrix_exp_scale_impl {
+  template <typename ArgType>
+  static MatrixType run(const ArgType& arg, int squarings) {
+    MatrixType result(arg.rows(), arg.cols());
+    result.realView().array() = arg.realView().array().ldexp(-squarings);
+    return result;
+  }
+};
+
+template <typename MatrixType>
+struct matrix_exp_scale_impl<MatrixType, false> {
+  template <typename ArgType>
+  static MatrixType run(const ArgType& arg, int squarings) {
+    using Scalar = typename traits<MatrixType>::Scalar;
+    return arg.unaryExpr([squarings](const Scalar& x) {
+      using std::ldexp;
+      return Scalar(ldexp(numext::real(x), -squarings), ldexp(numext::imag(x), -squarings));
+    });
+  }
+};
+
+template <typename MatrixType, typename ArgType>
+MatrixType matrix_exp_scale(const ArgType& arg, int squarings) {
+  return matrix_exp_scale_impl<MatrixType>::run(arg, squarings);
+}
+
+/** \brief Compute the (3,3)-Pad&eacute; approximant to the exponential.
+ *
+ *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
+ *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
+ */
+template <typename MatA, typename MatU, typename MatV>
+void matrix_exp_pade3(const MatA& A, MatU& U, MatV& V) {
+  typedef typename MatA::PlainObject MatrixType;
+  typedef typename NumTraits<typename traits<MatA>::Scalar>::Real RealScalar;
+  const RealScalar b[] = {120.L, 60.L, 12.L, 1.L};
+  const MatrixType A2 = A * A;
+  const MatrixType tmp = b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
+  U.noalias() = A * tmp;
+  V = b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
+}
+
+/** \brief Compute the (5,5)-Pad&eacute; approximant to the exponential.
+ *
+ *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
+ *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
+ */
+template <typename MatA, typename MatU, typename MatV>
+void matrix_exp_pade5(const MatA& A, MatU& U, MatV& V) {
+  typedef typename MatA::PlainObject MatrixType;
+  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
+  const RealScalar b[] = {30240.L, 15120.L, 3360.L, 420.L, 30.L, 1.L};
+  const MatrixType A2 = A * A;
+  const MatrixType A4 = A2 * A2;
+  const MatrixType tmp = b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
+  U.noalias() = A * tmp;
+  V = b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
+}
+
+/** \brief Compute the (7,7)-Pad&eacute; approximant to the exponential.
+ *
+ *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
+ *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
+ */
+template <typename MatA, typename MatU, typename MatV>
+void matrix_exp_pade7(const MatA& A, MatU& U, MatV& V) {
+  typedef typename MatA::PlainObject MatrixType;
+  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
+  const RealScalar b[] = {17297280.L, 8648640.L, 1995840.L, 277200.L, 25200.L, 1512.L, 56.L, 1.L};
+  const MatrixType A2 = A * A;
+  const MatrixType A4 = A2 * A2;
+  const MatrixType A6 = A4 * A2;
+  const MatrixType tmp = b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
+  U.noalias() = A * tmp;
+  V = b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
+}
+
+/** \brief Compute the (9,9)-Pad&eacute; approximant to the exponential.
+ *
+ *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
+ *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
+ */
+template <typename MatA, typename MatU, typename MatV>
+void matrix_exp_pade9(const MatA& A, MatU& U, MatV& V) {
+  typedef typename MatA::PlainObject MatrixType;
+  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
+  const RealScalar b[] = {17643225600.L, 8821612800.L, 2075673600.L, 302702400.L, 30270240.L,
+                          2162160.L,     110880.L,     3960.L,       90.L,        1.L};
+  const MatrixType A2 = A * A;
+  const MatrixType A4 = A2 * A2;
+  const MatrixType A6 = A4 * A2;
+  const MatrixType A8 = A6 * A2;
+  const MatrixType tmp =
+      b[9] * A8 + b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
+  U.noalias() = A * tmp;
+  V = b[8] * A8 + b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
+}
+
+/** \brief Compute the (13,13)-Pad&eacute; approximant to the exponential.
+ *
+ *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
+ *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
+ */
+template <typename MatA, typename MatU, typename MatV>
+void matrix_exp_pade13(const MatA& A, MatU& U, MatV& V) {
+  typedef typename MatA::PlainObject MatrixType;
+  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
+  const RealScalar b[] = {64764752532480000.L,
+                          32382376266240000.L,
+                          7771770303897600.L,
+                          1187353796428800.L,
+                          129060195264000.L,
+                          10559470521600.L,
+                          670442572800.L,
+                          33522128640.L,
+                          1323241920.L,
+                          40840800.L,
+                          960960.L,
+                          16380.L,
+                          182.L,
+                          1.L};
+  const MatrixType A2 = A * A;
+  const MatrixType A4 = A2 * A2;
+  const MatrixType A6 = A4 * A2;
+  V = b[13] * A6 + b[11] * A4 + b[9] * A2;  // used for temporary storage
+  MatrixType tmp = A6 * V;
+  tmp += b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
+  U.noalias() = A * tmp;
+  tmp = b[12] * A6 + b[10] * A4 + b[8] * A2;
+  V.noalias() = A6 * tmp;
+  V += b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
+}
+
+/** \brief Compute the (17,17)-Pad&eacute; approximant to the exponential.
+ *
+ *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
+ *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
+ *
+ *  This function activates only if your long double is double-double or quadruple.
+ */
+#if LDBL_MANT_DIG > 64
+template <typename MatA, typename MatU, typename MatV>
+void matrix_exp_pade17(const MatA& A, MatU& U, MatV& V) {
+  typedef typename MatA::PlainObject MatrixType;
+  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
+  const RealScalar b[] = {830034394580628357120000.L,
+                          415017197290314178560000.L,
+                          100610229646136770560000.L,
+                          15720348382208870400000.L,
+                          1774878043152614400000.L,
+                          153822763739893248000.L,
+                          10608466464820224000.L,
+                          595373117923584000.L,
+                          27563570274240000.L,
+                          1060137318240000.L,
+                          33924394183680.L,
+                          899510451840.L,
+                          19554575040.L,
+                          341863200.L,
+                          4651200.L,
+                          46512.L,
+                          306.L,
+                          1.L};
+  const MatrixType A2 = A * A;
+  const MatrixType A4 = A2 * A2;
+  const MatrixType A6 = A4 * A2;
+  const MatrixType A8 = A4 * A4;
+  V = b[17] * A8 + b[15] * A6 + b[13] * A4 + b[11] * A2;  // used for temporary storage
+  MatrixType tmp = A8 * V;
+  tmp += b[9] * A8 + b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
+  U.noalias() = A * tmp;
+  tmp = b[16] * A8 + b[14] * A6 + b[12] * A4 + b[10] * A2;
+  V.noalias() = tmp * A8;
+  V += b[8] * A8 + b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
+}
+#endif
+
+template <typename MatrixType, typename RealScalar = typename NumTraits<typename traits<MatrixType>::Scalar>::Real>
+struct matrix_exp_computeUV {
+  /** \brief Compute Pad&eacute; approximant to the exponential.
+   *
+   * Computes \c U, \c V and \c squarings such that \f$ (V+U)(V-U)^{-1} \f$ is a Pad&eacute;
+   * approximant of \f$ \exp(2^{-\mbox{squarings}}M) \f$ around \f$ M = 0 \f$, where \f$ M \f$
+   * denotes the matrix \c arg. The degree of the Pad&eacute; approximant and the value of squarings
+   * are chosen such that the approximation error is no more than the round-off error.
+   */
+  static void run(const MatrixType& arg, MatrixType& U, MatrixType& V, int& squarings);
+};
+
+template <typename MatrixType>
+struct matrix_exp_computeUV<MatrixType, float> {
+  template <typename ArgType>
+  static void run(const ArgType& arg, MatrixType& U, MatrixType& V, int& squarings) {
+    using std::frexp;
+    using std::pow;
+    const float l1norm = arg.cwiseAbs().colwise().sum().maxCoeff();
+    squarings = 0;
+    if (l1norm < 4.258730016922831e-001f) {
+      matrix_exp_pade3(arg, U, V);
+    } else if (l1norm < 1.880152677804762e+000f) {
+      matrix_exp_pade5(arg, U, V);
+    } else {
+      const float maxnorm = 3.925724783138660f;
+      frexp(l1norm / maxnorm, &squarings);
+      if (squarings < 0) squarings = 0;
+      MatrixType A = matrix_exp_scale<MatrixType>(arg, squarings);
+      matrix_exp_pade7(A, U, V);
+    }
+  }
+};
+
+template <typename MatrixType>
+struct matrix_exp_computeUV<MatrixType, double> {
+  template <typename ArgType>
+  static void run(const ArgType& arg, MatrixType& U, MatrixType& V, int& squarings) {
+    using std::frexp;
+    using std::pow;
+    const double l1norm = arg.cwiseAbs().colwise().sum().maxCoeff();
+    squarings = 0;
+    if (l1norm < 1.495585217958292e-002) {
+      matrix_exp_pade3(arg, U, V);
+    } else if (l1norm < 2.539398330063230e-001) {
+      matrix_exp_pade5(arg, U, V);
+    } else if (l1norm < 9.504178996162932e-001) {
+      matrix_exp_pade7(arg, U, V);
+    } else if (l1norm < 2.097847961257068e+000) {
+      matrix_exp_pade9(arg, U, V);
+    } else {
+      const double maxnorm = 5.371920351148152;
+      frexp(l1norm / maxnorm, &squarings);
+      if (squarings < 0) squarings = 0;
+      MatrixType A = matrix_exp_scale<MatrixType>(arg, squarings);
+      matrix_exp_pade13(A, U, V);
+    }
+  }
+};
+
+template <typename MatrixType>
+struct matrix_exp_computeUV<MatrixType, long double> {
+  template <typename ArgType>
+  static void run(const ArgType& arg, MatrixType& U, MatrixType& V, int& squarings) {
+#if LDBL_MANT_DIG == 53  // double precision
+    matrix_exp_computeUV<MatrixType, double>::run(arg, U, V, squarings);
+
+#else
+
+    using std::frexp;
+    using std::pow;
+    const long double l1norm = arg.cwiseAbs().colwise().sum().maxCoeff();
+    squarings = 0;
+
+#if LDBL_MANT_DIG <= 64  // extended precision
+
+    if (l1norm < 4.1968497232266989671e-003L) {
+      matrix_exp_pade3(arg, U, V);
+    } else if (l1norm < 1.1848116734693823091e-001L) {
+      matrix_exp_pade5(arg, U, V);
+    } else if (l1norm < 5.5170388480686700274e-001L) {
+      matrix_exp_pade7(arg, U, V);
+    } else if (l1norm < 1.3759868875587845383e+000L) {
+      matrix_exp_pade9(arg, U, V);
+    } else {
+      const long double maxnorm = 4.0246098906697353063L;
+      frexp(l1norm / maxnorm, &squarings);
+      if (squarings < 0) squarings = 0;
+      MatrixType A = matrix_exp_scale<MatrixType>(arg, squarings);
+      matrix_exp_pade13(A, U, V);
+    }
+
+#elif LDBL_MANT_DIG <= 106  // double-double
+
+    if (l1norm < 3.2787892205607026992947488108213e-005L) {
+      matrix_exp_pade3(arg, U, V);
+    } else if (l1norm < 6.4467025060072760084130906076332e-003L) {
+      matrix_exp_pade5(arg, U, V);
+    } else if (l1norm < 6.8988028496595374751374122881143e-002L) {
+      matrix_exp_pade7(arg, U, V);
+    } else if (l1norm < 2.7339737518502231741495857201670e-001L) {
+      matrix_exp_pade9(arg, U, V);
+    } else if (l1norm < 1.3203382096514474905666448850278e+000L) {
+      matrix_exp_pade13(arg, U, V);
+    } else {
+      const long double maxnorm = 3.2579440895405400856599663723517L;
+      frexp(l1norm / maxnorm, &squarings);
+      if (squarings < 0) squarings = 0;
+      MatrixType A = matrix_exp_scale<MatrixType>(arg, squarings);
+      matrix_exp_pade17(A, U, V);
+    }
+
+#elif LDBL_MANT_DIG <= 113  // quadruple precision
+
+    if (l1norm < 1.639394610288918690547467954466970e-005L) {
+      matrix_exp_pade3(arg, U, V);
+    } else if (l1norm < 4.253237712165275566025884344433009e-003L) {
+      matrix_exp_pade5(arg, U, V);
+    } else if (l1norm < 5.125804063165764409885122032933142e-002L) {
+      matrix_exp_pade7(arg, U, V);
+    } else if (l1norm < 2.170000765161155195453205651889853e-001L) {
+      matrix_exp_pade9(arg, U, V);
+    } else if (l1norm < 1.125358383453143065081397882891878e+000L) {
+      matrix_exp_pade13(arg, U, V);
+    } else {
+      const long double maxnorm = 2.884233277829519311757165057717815L;
+      frexp(l1norm / maxnorm, &squarings);
+      if (squarings < 0) squarings = 0;
+      MatrixType A = matrix_exp_scale<MatrixType>(arg, squarings);
+      matrix_exp_pade17(A, U, V);
+    }
+
+#else
+
+    // this case should be handled in compute()
+    eigen_assert(false && "Bug in MatrixExponential");
+
+#endif
+#endif  // LDBL_MANT_DIG
+  }
+};
+
+template <typename T>
+using is_exp_known_type = bool_constant<std::is_same<T, float>::value || std::is_same<T, double>::value
+#if LDBL_MANT_DIG <= 113
+                                        || std::is_same<T, long double>::value
+#endif
+                                        >;
+
+template <typename ArgType, typename ResultType>
+void matrix_exp_compute(const ArgType& arg, ResultType& result, std::true_type)  // natively supported scalar type
+{
+  typedef typename ArgType::PlainObject MatrixType;
+  MatrixType U, V;
+  int squarings;
+  matrix_exp_computeUV<MatrixType>::run(arg, U, V, squarings);  // Pade approximant is (U+V) / (-U+V)
+  MatrixType numer = U + V;
+  MatrixType denom = -U + V;
+  result = denom.partialPivLu().solve(numer);
+  for (int i = 0; i < squarings; i++) result *= result;  // undo scaling by repeated squaring
+}
+
+/* Computes the matrix exponential
+ *
+ * \param arg    argument of matrix exponential (should be plain object)
+ * \param result variable in which result will be stored
+ */
+template <typename ArgType, typename ResultType>
+void matrix_exp_compute(const ArgType& arg, ResultType& result, std::false_type)  // default
+{
+  typedef typename ArgType::PlainObject MatrixType;
+  typedef make_complex_t<typename traits<MatrixType>::Scalar> ComplexScalar;
+  result = arg.matrixFunction(internal::stem_function_exp<ComplexScalar>);
+}
+
+}  // namespace internal
+
+/** \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix exponential of some matrix (expression).
+ *
+ * \tparam Derived  Type of the argument to the matrix exponential.
+ *
+ * This class holds the argument to the matrix exponential until it is assigned or evaluated for
+ * some other reason (so the argument should not be changed in the meantime). It is the return type
+ * of MatrixBase::exp() and most of the time this is the only way it is used.
+ */
+template <typename Derived>
+struct MatrixExponentialReturnValue : public ReturnByValue<MatrixExponentialReturnValue<Derived> > {
+ public:
+  /** \brief Constructor.
+   *
+   * \param src %Matrix (expression) forming the argument of the matrix exponential.
+   */
+  MatrixExponentialReturnValue(const Derived& src) : m_src(src) {}
+
+  /** \brief Compute the matrix exponential.
+   *
+   * \param result the matrix exponential of \p src in the constructor.
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    const typename internal::nested_eval<Derived, 10>::type tmp(m_src);
+    internal::matrix_exp_compute(tmp, result, internal::is_exp_known_type<typename Derived::RealScalar>());
+  }
+
+  Index rows() const { return m_src.rows(); }
+  Index cols() const { return m_src.cols(); }
+
+ protected:
+  const typename internal::ref_selector<Derived>::type m_src;
+};
+
+namespace internal {
+template <typename Derived>
+struct traits<MatrixExponentialReturnValue<Derived> > {
+  typedef typename Derived::PlainObject ReturnType;
+};
+}  // namespace internal
+
+template <typename Derived>
+const MatrixExponentialReturnValue<Derived> MatrixBase<Derived>::exp() const {
+  eigen_assert(rows() == cols());
+  return MatrixExponentialReturnValue<Derived>(derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATRIX_EXPONENTIAL
diff --git a/contrib/Eigen/src/MatrixFunctions/MatrixFunction.h b/contrib/Eigen/src/MatrixFunctions/MatrixFunction.h
new file mode 100644
index 0000000..a02eb46
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/MatrixFunction.h
@@ -0,0 +1,547 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2011, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_FUNCTION_H
+#define EIGEN_MATRIX_FUNCTION_H
+
+#include "StemFunction.h"
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \brief Maximum distance allowed between eigenvalues to be considered "close". */
+static const float matrix_function_separation = 0.1f;
+
+/** \ingroup MatrixFunctions_Module
+ * \class MatrixFunctionAtomic
+ * \brief Helper class for computing matrix functions of atomic matrices.
+ *
+ * Here, an atomic matrix is a triangular matrix whose diagonal entries are close to each other.
+ */
+template <typename MatrixType>
+class MatrixFunctionAtomic {
+ public:
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename stem_function<Scalar>::type StemFunction;
+
+  /** \brief Constructor
+   * \param[in]  f  matrix function to compute.
+   */
+  MatrixFunctionAtomic(StemFunction f) : m_f(f) {}
+
+  /** \brief Compute matrix function of atomic matrix
+   * \param[in]  A  argument of matrix function, should be upper triangular and atomic
+   * \returns  f(A), the matrix function evaluated at the given matrix
+   */
+  MatrixType compute(const MatrixType& A);
+
+ private:
+  StemFunction* m_f;
+};
+
+template <typename MatrixType>
+typename NumTraits<typename MatrixType::Scalar>::Real matrix_function_compute_mu(const MatrixType& A) {
+  typedef typename plain_col_type<MatrixType>::type VectorType;
+  Index rows = A.rows();
+  const MatrixType N = MatrixType::Identity(rows, rows) - A;
+  VectorType e = VectorType::Ones(rows);
+  N.template triangularView<Upper>().solveInPlace(e);
+  return e.cwiseAbs().maxCoeff();
+}
+
+template <typename MatrixType>
+MatrixType MatrixFunctionAtomic<MatrixType>::compute(const MatrixType& A) {
+  // TODO: Use that A is upper triangular
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  Index rows = A.rows();
+  Scalar avgEival = A.trace() / Scalar(RealScalar(rows));
+  MatrixType Ashifted = A - avgEival * MatrixType::Identity(rows, rows);
+  RealScalar mu = matrix_function_compute_mu(Ashifted);
+  MatrixType F = m_f(avgEival, 0) * MatrixType::Identity(rows, rows);
+  MatrixType P = Ashifted;
+  MatrixType Fincr;
+  // Reaching epsilon takes more terms as the mantissa lengthens, never fewer than ten.
+  const Index extraIterations = numext::maxi<Index>(10, NumTraits<RealScalar>::digits());
+  // s < 1.1 * rows + extraIterations, both sides scaled by ten to compare exactly.
+  for (Index s = 1; 10 * s < 11 * rows + 10 * extraIterations; ++s) {
+    Fincr = m_f(avgEival, static_cast<int>(s)) * P;
+    F += Fincr;
+    P = Scalar(RealScalar(1) / RealScalar(s + 1)) * P * Ashifted;
+
+    // test whether Taylor series converged
+    const RealScalar F_norm = F.cwiseAbs().rowwise().sum().maxCoeff();
+    const RealScalar Fincr_norm = Fincr.cwiseAbs().rowwise().sum().maxCoeff();
+    if (Fincr_norm < NumTraits<Scalar>::epsilon() * F_norm) {
+      RealScalar delta = 0;
+      RealScalar rfactorial = 1;
+      for (Index r = 0; r < rows; r++) {
+        RealScalar mx = 0;
+        for (Index i = 0; i < rows; i++)
+          mx = (std::max)(mx, std::abs(m_f(Ashifted(i, i) + avgEival, static_cast<int>(s + r))));
+        if (r != 0) rfactorial *= RealScalar(r);
+        delta = (std::max)(delta, RealScalar(mx / rfactorial));
+      }
+      const RealScalar P_norm = P.cwiseAbs().rowwise().sum().maxCoeff();
+      if (mu * delta * P_norm < NumTraits<Scalar>::epsilon() * F_norm)  // series converged
+        break;
+    }
+  }
+  return F;
+}
+
+/** \brief Find cluster in \p clusters containing some value
+ * \param[in] key Value to find
+ * \returns Iterator to cluster containing \p key, or \c clusters.end() if no cluster in \p clusters
+ * contains \p key.
+ */
+template <typename Index, typename ListOfClusters>
+typename ListOfClusters::iterator matrix_function_find_cluster(Index key, ListOfClusters& clusters) {
+  typename std::list<Index>::iterator j;
+  for (typename ListOfClusters::iterator i = clusters.begin(); i != clusters.end(); ++i) {
+    j = std::find(i->begin(), i->end(), key);
+    if (j != i->end()) return i;
+  }
+  return clusters.end();
+}
+
+/** \brief Partition eigenvalues in clusters of ei'vals close to each other
+ *
+ * \param[in]  eivals    Eigenvalues
+ * \param[out] clusters  Resulting partition of eigenvalues
+ *
+ * The partition satisfies the following two properties:
+ * # Any eigenvalue in a certain cluster is at most matrix_function_separation() away from another eigenvalue
+ *   in the same cluster.
+ * # The distance between two eigenvalues in different clusters is more than matrix_function_separation().
+ * The implementation follows Algorithm 4.1 in the paper of Davies and Higham.
+ */
+template <typename EivalsType, typename Cluster>
+void matrix_function_partition_eigenvalues(const EivalsType& eivals, std::list<Cluster>& clusters) {
+  typedef typename EivalsType::RealScalar RealScalar;
+  for (Index i = 0; i < eivals.rows(); ++i) {
+    // Find cluster containing i-th ei'val, adding a new cluster if necessary
+    typename std::list<Cluster>::iterator qi = matrix_function_find_cluster(i, clusters);
+    if (qi == clusters.end()) {
+      Cluster l;
+      l.push_back(i);
+      clusters.push_back(l);
+      qi = clusters.end();
+      --qi;
+    }
+
+    // Look for other element to add to the set
+    for (Index j = i + 1; j < eivals.rows(); ++j) {
+      if (abs(eivals(j) - eivals(i)) <= RealScalar(matrix_function_separation) &&
+          std::find(qi->begin(), qi->end(), j) == qi->end()) {
+        typename std::list<Cluster>::iterator qj = matrix_function_find_cluster(j, clusters);
+        if (qj == clusters.end()) {
+          qi->push_back(j);
+        } else {
+          qi->insert(qi->end(), qj->begin(), qj->end());
+          clusters.erase(qj);
+        }
+      }
+    }
+  }
+}
+
+/** \brief Compute size of each cluster given a partitioning */
+template <typename ListOfClusters, typename Index>
+void matrix_function_compute_cluster_size(const ListOfClusters& clusters, Matrix<Index, Dynamic, 1>& clusterSize) {
+  const Index numClusters = static_cast<Index>(clusters.size());
+  clusterSize.setZero(numClusters);
+  Index clusterIndex = 0;
+  for (typename ListOfClusters::const_iterator cluster = clusters.begin(); cluster != clusters.end(); ++cluster) {
+    clusterSize[clusterIndex] = cluster->size();
+    ++clusterIndex;
+  }
+}
+
+/** \brief Compute start of each block using clusterSize */
+template <typename VectorType>
+void matrix_function_compute_block_start(const VectorType& clusterSize, VectorType& blockStart) {
+  blockStart.resize(clusterSize.rows());
+  blockStart(0) = 0;
+  for (Index i = 1; i < clusterSize.rows(); i++) {
+    blockStart(i) = blockStart(i - 1) + clusterSize(i - 1);
+  }
+}
+
+/** \brief Compute mapping of eigenvalue indices to cluster indices */
+template <typename EivalsType, typename ListOfClusters, typename VectorType>
+void matrix_function_compute_map(const EivalsType& eivals, const ListOfClusters& clusters, VectorType& eivalToCluster) {
+  eivalToCluster.resize(eivals.rows());
+  Index clusterIndex = 0;
+  for (typename ListOfClusters::const_iterator cluster = clusters.begin(); cluster != clusters.end(); ++cluster) {
+    for (Index i = 0; i < eivals.rows(); ++i) {
+      if (std::find(cluster->begin(), cluster->end(), i) != cluster->end()) {
+        eivalToCluster[i] = clusterIndex;
+      }
+    }
+    ++clusterIndex;
+  }
+}
+
+/** \brief Compute permutation which groups ei'vals in same cluster together */
+template <typename DynVectorType, typename VectorType>
+void matrix_function_compute_permutation(const DynVectorType& blockStart, const DynVectorType& eivalToCluster,
+                                         VectorType& permutation) {
+  DynVectorType indexNextEntry = blockStart;
+  permutation.resize(eivalToCluster.rows());
+  for (Index i = 0; i < eivalToCluster.rows(); i++) {
+    Index cluster = eivalToCluster[i];
+    permutation[i] = indexNextEntry[cluster];
+    ++indexNextEntry[cluster];
+  }
+}
+
+/** \brief Permute Schur decomposition in U and T according to permutation */
+template <typename VectorType, typename MatrixType>
+void matrix_function_permute_schur(VectorType& permutation, MatrixType& U, MatrixType& T) {
+  for (Index i = 0; i < permutation.rows() - 1; i++) {
+    Index j;
+    for (j = i; j < permutation.rows(); j++) {
+      if (permutation(j) == i) break;
+    }
+    eigen_assert(permutation(j) == i);
+    for (Index k = j - 1; k >= i; k--) {
+      JacobiRotation<typename MatrixType::Scalar> rotation;
+      rotation.makeGivens(T(k, k + 1), T(k + 1, k + 1) - T(k, k));
+      T.applyOnTheLeft(k, k + 1, rotation.adjoint());
+      T.applyOnTheRight(k, k + 1, rotation);
+      U.applyOnTheRight(k, k + 1, rotation);
+      std::swap(permutation.coeffRef(k), permutation.coeffRef(k + 1));
+    }
+  }
+}
+
+/** \brief Compute block diagonal part of matrix function.
+ *
+ * This routine computes the matrix function applied to the block diagonal part of \p T (which should be
+ * upper triangular), with the blocking given by \p blockStart and \p clusterSize. The matrix function of
+ * each diagonal block is computed by \p atomic. The off-diagonal parts of \p fT are set to zero.
+ */
+template <typename MatrixType, typename AtomicType, typename VectorType>
+void matrix_function_compute_block_atomic(const MatrixType& T, AtomicType& atomic, const VectorType& blockStart,
+                                          const VectorType& clusterSize, MatrixType& fT) {
+  fT.setZero(T.rows(), T.cols());
+  for (Index i = 0; i < clusterSize.rows(); ++i) {
+    fT.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)) =
+        atomic.compute(T.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)));
+  }
+}
+
+/** \brief Solve a triangular Sylvester equation AX + XB = C
+ *
+ * \param[in]  A  the matrix A; should be square and upper triangular
+ * \param[in]  B  the matrix B; should be square and upper triangular
+ * \param[in]  C  the matrix C; should have correct size.
+ *
+ * \returns the solution X.
+ *
+ * If A is m-by-m and B is n-by-n, then both C and X are m-by-n.  The (i,j)-th component of the Sylvester
+ * equation is
+ * \f[
+ *     \sum_{k=i}^m A_{ik} X_{kj} + \sum_{k=1}^j X_{ik} B_{kj} = C_{ij}.
+ * \f]
+ * This can be re-arranged to yield:
+ * \f[
+ *     X_{ij} = \frac{1}{A_{ii} + B_{jj}} \Bigl( C_{ij}
+ *     - \sum_{k=i+1}^m A_{ik} X_{kj} - \sum_{k=1}^{j-1} X_{ik} B_{kj} \Bigr).
+ * \f]
+ * It is assumed that A and B are such that the numerator is never zero (otherwise the Sylvester equation
+ * does not have a unique solution). In that case, these equations can be evaluated in the order
+ * \f$ i=m,\ldots,1 \f$ and \f$ j=1,\ldots,n \f$.
+ */
+template <typename MatrixType>
+MatrixType matrix_function_solve_triangular_sylvester(const MatrixType& A, const MatrixType& B, const MatrixType& C) {
+  eigen_assert(A.rows() == A.cols());
+  eigen_assert(A.isUpperTriangular());
+  eigen_assert(B.rows() == B.cols());
+  eigen_assert(B.isUpperTriangular());
+  eigen_assert(C.rows() == A.rows());
+  eigen_assert(C.cols() == B.rows());
+
+  typedef typename MatrixType::Scalar Scalar;
+
+  Index m = A.rows();
+  Index n = B.rows();
+  MatrixType X(m, n);
+
+  for (Index i = m - 1; i >= 0; --i) {
+    for (Index j = 0; j < n; ++j) {
+      // Compute AX = \sum_{k=i+1}^m A_{ik} X_{kj}
+      Scalar AX;
+      if (i == m - 1) {
+        AX = 0;
+      } else {
+        Matrix<Scalar, 1, 1> AXmatrix = A.row(i).tail(m - 1 - i) * X.col(j).tail(m - 1 - i);
+        AX = AXmatrix(0, 0);
+      }
+
+      // Compute XB = \sum_{k=1}^{j-1} X_{ik} B_{kj}
+      Scalar XB;
+      if (j == 0) {
+        XB = 0;
+      } else {
+        Matrix<Scalar, 1, 1> XBmatrix = X.row(i).head(j) * B.col(j).head(j);
+        XB = XBmatrix(0, 0);
+      }
+
+      X(i, j) = (C(i, j) - AX - XB) / (A(i, i) + B(j, j));
+    }
+  }
+  return X;
+}
+
+/** \brief Compute part of matrix function above block diagonal.
+ *
+ * This routine completes the computation of \p fT, denoting a matrix function applied to the triangular
+ * matrix \p T. It assumes that the block diagonal part of \p fT has already been computed. The part below
+ * the diagonal is zero, because \p T is upper triangular.
+ */
+template <typename MatrixType, typename VectorType>
+void matrix_function_compute_above_diagonal(const MatrixType& T, const VectorType& blockStart,
+                                            const VectorType& clusterSize, MatrixType& fT) {
+  typedef internal::traits<MatrixType> Traits;
+  typedef typename MatrixType::Scalar Scalar;
+  static const int Options = MatrixType::Options;
+  typedef Matrix<Scalar, Dynamic, Dynamic, Options, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime> DynMatrixType;
+
+  for (Index k = 1; k < clusterSize.rows(); k++) {
+    for (Index i = 0; i < clusterSize.rows() - k; i++) {
+      // compute (i, i+k) block
+      DynMatrixType A = T.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i));
+      DynMatrixType B = -T.block(blockStart(i + k), blockStart(i + k), clusterSize(i + k), clusterSize(i + k));
+      DynMatrixType C = fT.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)) *
+                        T.block(blockStart(i), blockStart(i + k), clusterSize(i), clusterSize(i + k));
+      C.noalias() -= T.block(blockStart(i), blockStart(i + k), clusterSize(i), clusterSize(i + k)) *
+                     fT.block(blockStart(i + k), blockStart(i + k), clusterSize(i + k), clusterSize(i + k));
+      for (Index m = i + 1; m < i + k; m++) {
+        C.noalias() += fT.block(blockStart(i), blockStart(m), clusterSize(i), clusterSize(m)) *
+                       T.block(blockStart(m), blockStart(i + k), clusterSize(m), clusterSize(i + k));
+        C.noalias() -= T.block(blockStart(i), blockStart(m), clusterSize(i), clusterSize(m)) *
+                       fT.block(blockStart(m), blockStart(i + k), clusterSize(m), clusterSize(i + k));
+      }
+      fT.block(blockStart(i), blockStart(i + k), clusterSize(i), clusterSize(i + k)) =
+          matrix_function_solve_triangular_sylvester(A, B, C);
+    }
+  }
+}
+
+/** \ingroup MatrixFunctions_Module
+ * \brief Class for computing matrix functions.
+ * \tparam  MatrixType  type of the argument of the matrix function,
+ *                      expected to be an instantiation of the Matrix class template.
+ * \tparam  AtomicType  type for computing matrix function of atomic blocks.
+ * \tparam  IsComplex   used internally to select correct specialization.
+ *
+ * This class implements the Schur-Parlett algorithm for computing matrix functions. The spectrum of the
+ * matrix is divided into clusters of eigenvalues that lie close together. This class delegates the
+ * computation of the matrix function on every block corresponding to these clusters to an object of type
+ * \p AtomicType and uses these results to compute the matrix function of the whole matrix. The class
+ * \p AtomicType should have a \p compute() member function for computing the matrix function of a block.
+ *
+ * \sa class MatrixFunctionAtomic, class MatrixLogarithmAtomic
+ */
+template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
+struct matrix_function_compute {
+  /** \brief Compute the matrix function.
+   *
+   * \param[in]  A       argument of matrix function, should be a square matrix.
+   * \param[in]  atomic  class for computing matrix function of atomic blocks.
+   * \param[out] result  the function \p f applied to \p A, as
+   * specified in the constructor.
+   *
+   * See MatrixBase::matrixFunction() for details on how this computation
+   * is implemented.
+   */
+  template <typename AtomicType, typename ResultType>
+  static void run(const MatrixType& A, AtomicType& atomic, ResultType& result);
+};
+
+/** \internal \ingroup MatrixFunctions_Module
+ * \brief Partial specialization of MatrixFunction for real matrices
+ *
+ * This converts the real matrix to a complex matrix, compute the matrix function of that matrix, and then
+ * converts the result back to a real matrix.
+ */
+template <typename MatrixType>
+struct matrix_function_compute<MatrixType, 0> {
+  template <typename MatA, typename AtomicType, typename ResultType>
+  static void run(const MatA& A, AtomicType& atomic, ResultType& result) {
+    typedef internal::traits<MatrixType> Traits;
+    typedef typename Traits::Scalar Scalar;
+    static const int Rows = Traits::RowsAtCompileTime, Cols = Traits::ColsAtCompileTime;
+    static const int MaxRows = Traits::MaxRowsAtCompileTime, MaxCols = Traits::MaxColsAtCompileTime;
+
+    typedef internal::make_complex_t<Scalar> ComplexScalar;
+    typedef Matrix<ComplexScalar, Rows, Cols, 0, MaxRows, MaxCols> ComplexMatrix;
+
+    ComplexMatrix CA = A.template cast<ComplexScalar>();
+    ComplexMatrix Cresult;
+    matrix_function_compute<ComplexMatrix>::run(CA, atomic, Cresult);
+    result = Cresult.real();
+  }
+};
+
+/** \internal \ingroup MatrixFunctions_Module
+ * \brief Partial specialization of MatrixFunction for complex matrices
+ */
+template <typename MatrixType>
+struct matrix_function_compute<MatrixType, 1> {
+  template <typename MatA, typename AtomicType, typename ResultType>
+  static void run(const MatA& A, AtomicType& atomic, ResultType& result) {
+    typedef internal::traits<MatrixType> Traits;
+
+    // compute Schur decomposition of A
+    const ComplexSchur<MatrixType> schurOfA(A);
+    eigen_assert(schurOfA.info() == Success);
+    MatrixType T = schurOfA.matrixT();
+    MatrixType U = schurOfA.matrixU();
+
+    // partition eigenvalues into clusters of ei'vals "close" to each other
+    std::list<std::list<Index> > clusters;
+    matrix_function_partition_eigenvalues(T.diagonal(), clusters);
+
+    // compute size of each cluster
+    Matrix<Index, Dynamic, 1> clusterSize;
+    matrix_function_compute_cluster_size(clusters, clusterSize);
+
+    // blockStart[i] is row index at which block corresponding to i-th cluster starts
+    Matrix<Index, Dynamic, 1> blockStart;
+    matrix_function_compute_block_start(clusterSize, blockStart);
+
+    // compute map so that eivalToCluster[i] = j means that i-th ei'val is in j-th cluster
+    Matrix<Index, Dynamic, 1> eivalToCluster;
+    matrix_function_compute_map(T.diagonal(), clusters, eivalToCluster);
+
+    // compute permutation which groups ei'vals in same cluster together
+    Matrix<Index, Traits::RowsAtCompileTime, 1> permutation;
+    matrix_function_compute_permutation(blockStart, eivalToCluster, permutation);
+
+    // permute Schur decomposition
+    matrix_function_permute_schur(permutation, U, T);
+
+    // compute result
+    MatrixType fT;  // matrix function applied to T
+    matrix_function_compute_block_atomic(T, atomic, blockStart, clusterSize, fT);
+    matrix_function_compute_above_diagonal(T, blockStart, clusterSize, fT);
+    call_assignment_no_alias(result.derived(), U * (fT.template triangularView<Upper>() * U.adjoint()));
+  }
+};
+
+}  // end of namespace internal
+
+/** \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix function of some matrix (expression).
+ *
+ * \tparam Derived  Type of the argument to the matrix function.
+ *
+ * This class holds the argument to the matrix function until it is assigned or evaluated for some other
+ * reason (so the argument should not be changed in the meantime). It is the return type of
+ * MatrixBase::matrixFunction() and related functions and most of the time this is the only way it is used.
+ */
+template <typename Derived>
+class MatrixFunctionReturnValue : public ReturnByValue<MatrixFunctionReturnValue<Derived> > {
+ public:
+  typedef typename Derived::Scalar Scalar;
+  typedef typename internal::stem_function<Scalar>::type StemFunction;
+
+ protected:
+  typedef typename internal::ref_selector<Derived>::type DerivedNested;
+
+ public:
+  /** \brief Constructor.
+   *
+   * \param[in] A  %Matrix (expression) forming the argument of the matrix function.
+   * \param[in] f  Stem function for matrix function under consideration.
+   */
+  MatrixFunctionReturnValue(const Derived& A, StemFunction f) : m_A(A), m_f(f) {}
+
+  /** \brief Compute the matrix function.
+   *
+   * \param[out] result \p f applied to \p A, where \p f and \p A are as in the constructor.
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    typedef typename internal::nested_eval<Derived, 10>::type NestedEvalType;
+    typedef internal::remove_all_t<NestedEvalType> NestedEvalTypeClean;
+    typedef internal::traits<NestedEvalTypeClean> Traits;
+    typedef internal::make_complex_t<Scalar> ComplexScalar;
+    typedef Matrix<ComplexScalar, Dynamic, Dynamic, 0, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime>
+        DynMatrixType;
+
+    typedef internal::MatrixFunctionAtomic<DynMatrixType> AtomicType;
+    AtomicType atomic(m_f);
+
+    internal::matrix_function_compute<typename NestedEvalTypeClean::PlainObject>::run(m_A, atomic, result);
+  }
+
+  Index rows() const { return m_A.rows(); }
+  Index cols() const { return m_A.cols(); }
+
+ private:
+  DerivedNested m_A;
+  StemFunction* m_f;
+};
+
+namespace internal {
+template <typename Derived>
+struct traits<MatrixFunctionReturnValue<Derived> > {
+  typedef typename Derived::PlainObject ReturnType;
+};
+}  // namespace internal
+
+/********** MatrixBase methods **********/
+
+template <typename Derived>
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(
+    typename internal::stem_function<typename internal::traits<Derived>::Scalar>::type f) const {
+  eigen_assert(rows() == cols());
+  return MatrixFunctionReturnValue<Derived>(derived(), f);
+}
+
+template <typename Derived>
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sin() const {
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
+  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_sin<ComplexScalar>);
+}
+
+template <typename Derived>
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cos() const {
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
+  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_cos<ComplexScalar>);
+}
+
+template <typename Derived>
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sinh() const {
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
+  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_sinh<ComplexScalar>);
+}
+
+template <typename Derived>
+const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cosh() const {
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
+  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_cosh<ComplexScalar>);
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATRIX_FUNCTION_H
diff --git a/contrib/Eigen/src/MatrixFunctions/MatrixLogarithm.h b/contrib/Eigen/src/MatrixFunctions/MatrixLogarithm.h
new file mode 100644
index 0000000..e39ab60
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/MatrixLogarithm.h
@@ -0,0 +1,376 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+// Copyright (C) 2011 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_LOGARITHM
+#define EIGEN_MATRIX_LOGARITHM
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+struct matrix_log_min_pade_degree {
+  static const int value = 3;
+};
+
+template <typename Scalar>
+struct matrix_log_max_pade_degree {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  static const int value = std::numeric_limits<RealScalar>::digits <= 24 ? 5 :  // single precision
+                               std::numeric_limits<RealScalar>::digits <= 53 ? 7
+                                                                             :  // double precision
+                               std::numeric_limits<RealScalar>::digits <= 64 ? 8
+                                                                             :  // extended precision
+                               std::numeric_limits<RealScalar>::digits <= 106 ? 10
+                                                                              :  // double-double
+                               11;                                               // quadruple precision
+};
+
+/** \brief Compute logarithm of 2x2 triangular matrix. */
+template <typename MatrixType>
+void matrix_log_compute_2x2(const MatrixType& A, MatrixType& result) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  using std::abs;
+  using std::ceil;
+  using std::imag;
+  using std::log;
+
+  Scalar logA00 = log(A(0, 0));
+  Scalar logA11 = log(A(1, 1));
+
+  result(0, 0) = logA00;
+  result(1, 0) = Scalar(0);
+  result(1, 1) = logA11;
+
+  Scalar y = A(1, 1) - A(0, 0);
+  if (y == Scalar(0)) {
+    result(0, 1) = A(0, 1) / A(0, 0);
+  } else if ((abs(A(0, 0)) < RealScalar(0.5) * abs(A(1, 1))) || (abs(A(0, 0)) > 2 * abs(A(1, 1)))) {
+    result(0, 1) = A(0, 1) * (logA11 - logA00) / y;
+  } else {
+    // computation in previous branch is inaccurate if A(1,1) \approx A(0,0)
+    RealScalar unwindingNumber = ceil((imag(logA11 - logA00) - RealScalar(EIGEN_PI)) / RealScalar(2 * EIGEN_PI));
+    result(0, 1) = A(0, 1) * (numext::log1p(y / A(0, 0)) + Scalar(0, RealScalar(2 * EIGEN_PI) * unwindingNumber)) / y;
+  }
+}
+
+/* \brief Get suitable degree for Pade approximation. (specialized for RealScalar = float) */
+inline int matrix_log_get_pade_degree(float normTminusI) {
+  const float maxNormForPade[] = {2.5111573934555054e-1 /* degree = 3 */, 4.0535837411880493e-1, 5.3149729967117310e-1};
+  const int minPadeDegree = matrix_log_min_pade_degree<float>::value;
+  const int maxPadeDegree = matrix_log_max_pade_degree<float>::value;
+  int degree = minPadeDegree;
+  for (; degree <= maxPadeDegree; ++degree)
+    if (normTminusI <= maxNormForPade[degree - minPadeDegree]) break;
+  return degree;
+}
+
+/* \brief Get suitable degree for Pade approximation. (specialized for RealScalar = double) */
+inline int matrix_log_get_pade_degree(double normTminusI) {
+  const double maxNormForPade[] = {1.6206284795015624e-2 /* degree = 3 */, 5.3873532631381171e-2, 1.1352802267628681e-1,
+                                   1.8662860613541288e-1, 2.642960831111435e-1};
+  const int minPadeDegree = matrix_log_min_pade_degree<double>::value;
+  const int maxPadeDegree = matrix_log_max_pade_degree<double>::value;
+  int degree = minPadeDegree;
+  for (; degree <= maxPadeDegree; ++degree)
+    if (normTminusI <= maxNormForPade[degree - minPadeDegree]) break;
+  return degree;
+}
+
+/* \brief Get suitable degree for Pade approximation. (specialized for RealScalar = long double) */
+inline int matrix_log_get_pade_degree(long double normTminusI) {
+#if LDBL_MANT_DIG == 53  // double precision
+  const long double maxNormForPade[] = {1.6206284795015624e-2L /* degree = 3 */, 5.3873532631381171e-2L,
+                                        1.1352802267628681e-1L, 1.8662860613541288e-1L, 2.642960831111435e-1L};
+#elif LDBL_MANT_DIG <= 64   // extended precision
+  const long double maxNormForPade[] = {5.48256690357782863103e-3L /* degree = 3 */,
+                                        2.34559162387971167321e-2L,
+                                        5.84603923897347449857e-2L,
+                                        1.08486423756725170223e-1L,
+                                        1.68385767881294446649e-1L,
+                                        2.32777776523703892094e-1L};
+#elif LDBL_MANT_DIG <= 106  // double-double
+  const long double maxNormForPade[] = {8.58970550342939562202529664318890e-5L /* degree = 3 */,
+                                        9.34074328446359654039446552677759e-4L,
+                                        4.26117194647672175773064114582860e-3L,
+                                        1.21546224740281848743149666560464e-2L,
+                                        2.61100544998339436713088248557444e-2L,
+                                        4.66170074627052749243018566390567e-2L,
+                                        7.32585144444135027565872014932387e-2L,
+                                        1.05026503471351080481093652651105e-1L};
+#else                       // quadruple precision
+  const long double maxNormForPade[] = {4.7419931187193005048501568167858103e-5L /* degree = 3 */,
+                                        5.8853168473544560470387769480192666e-4L,
+                                        2.9216120366601315391789493628113520e-3L,
+                                        8.8415758124319434347116734705174308e-3L,
+                                        1.9850836029449446668518049562565291e-2L,
+                                        3.6688019729653446926585242192447447e-2L,
+                                        5.9290962294020186998954055264528393e-2L,
+                                        8.6998436081634343903250580992127677e-2L,
+                                        1.1880960220216759245467951592883642e-1L};
+#endif
+  const int minPadeDegree = matrix_log_min_pade_degree<long double>::value;
+  const int maxPadeDegree = matrix_log_max_pade_degree<long double>::value;
+  int degree = minPadeDegree;
+  for (; degree <= maxPadeDegree; ++degree)
+    if (normTminusI <= maxNormForPade[degree - minPadeDegree]) break;
+  return degree;
+}
+
+/* \brief Compute Pade approximation to matrix logarithm */
+template <typename MatrixType>
+void matrix_log_compute_pade(MatrixType& result, const MatrixType& T, int degree) {
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  const int minPadeDegree = 3;
+  const int maxPadeDegree = 11;
+  eigen_assert(degree >= minPadeDegree && degree <= maxPadeDegree);
+  // FIXME: This creates float-conversion warnings if these are enabled.
+  // Either manually convert each value, or disable the warning locally
+  const RealScalar nodes[][maxPadeDegree] = {
+      {0.1127016653792583114820734600217600L, 0.5000000000000000000000000000000000L,  // degree 3
+       0.8872983346207416885179265399782400L},
+      {0.0694318442029737123880267555535953L, 0.3300094782075718675986671204483777L,  // degree 4
+       0.6699905217924281324013328795516223L, 0.9305681557970262876119732444464048L},
+      {0.0469100770306680036011865608503035L, 0.2307653449471584544818427896498956L,  // degree 5
+       0.5000000000000000000000000000000000L, 0.7692346550528415455181572103501044L,
+       0.9530899229693319963988134391496965L},
+      {0.0337652428984239860938492227530027L, 0.1693953067668677431693002024900473L,  // degree 6
+       0.3806904069584015456847491391596440L, 0.6193095930415984543152508608403560L,
+       0.8306046932331322568306997975099527L, 0.9662347571015760139061507772469973L},
+      {0.0254460438286207377369051579760744L, 0.1292344072003027800680676133596058L,  // degree 7
+       0.2970774243113014165466967939615193L, 0.5000000000000000000000000000000000L,
+       0.7029225756886985834533032060384807L, 0.8707655927996972199319323866403942L,
+       0.9745539561713792622630948420239256L},
+      {0.0198550717512318841582195657152635L, 0.1016667612931866302042230317620848L,  // degree 8
+       0.2372337950418355070911304754053768L, 0.4082826787521750975302619288199080L,
+       0.5917173212478249024697380711800920L, 0.7627662049581644929088695245946232L,
+       0.8983332387068133697957769682379152L, 0.9801449282487681158417804342847365L},
+      {0.0159198802461869550822118985481636L, 0.0819844463366821028502851059651326L,  // degree 9
+       0.1933142836497048013456489803292629L, 0.3378732882980955354807309926783317L,
+       0.5000000000000000000000000000000000L, 0.6621267117019044645192690073216683L,
+       0.8066857163502951986543510196707371L, 0.9180155536633178971497148940348674L,
+       0.9840801197538130449177881014518364L},
+      {0.0130467357414141399610179939577740L, 0.0674683166555077446339516557882535L,  // degree 10
+       0.1602952158504877968828363174425632L, 0.2833023029353764046003670284171079L,
+       0.4255628305091843945575869994351400L, 0.5744371694908156054424130005648600L,
+       0.7166976970646235953996329715828921L, 0.8397047841495122031171636825574368L,
+       0.9325316833444922553660483442117465L, 0.9869532642585858600389820060422260L},
+      {0.0108856709269715035980309994385713L, 0.0564687001159523504624211153480364L,  // degree 11
+       0.1349239972129753379532918739844233L, 0.2404519353965940920371371652706952L,
+       0.3652284220238275138342340072995692L, 0.5000000000000000000000000000000000L,
+       0.6347715779761724861657659927004308L, 0.7595480646034059079628628347293048L,
+       0.8650760027870246620467081260155767L, 0.9435312998840476495375788846519636L,
+       0.9891143290730284964019690005614287L}};
+
+  const RealScalar weights[][maxPadeDegree] = {
+      {0.2777777777777777777777777777777778L, 0.4444444444444444444444444444444444L,  // degree 3
+       0.2777777777777777777777777777777778L},
+      {0.1739274225687269286865319746109997L, 0.3260725774312730713134680253890003L,  // degree 4
+       0.3260725774312730713134680253890003L, 0.1739274225687269286865319746109997L},
+      {0.1184634425280945437571320203599587L, 0.2393143352496832340206457574178191L,  // degree 5
+       0.2844444444444444444444444444444444L, 0.2393143352496832340206457574178191L,
+       0.1184634425280945437571320203599587L},
+      {0.0856622461895851725201480710863665L, 0.1803807865240693037849167569188581L,  // degree 6
+       0.2339569672863455236949351719947755L, 0.2339569672863455236949351719947755L,
+       0.1803807865240693037849167569188581L, 0.0856622461895851725201480710863665L},
+      {0.0647424830844348466353057163395410L, 0.1398526957446383339507338857118898L,  // degree 7
+       0.1909150252525594724751848877444876L, 0.2089795918367346938775510204081633L,
+       0.1909150252525594724751848877444876L, 0.1398526957446383339507338857118898L,
+       0.0647424830844348466353057163395410L},
+      {0.0506142681451881295762656771549811L, 0.1111905172266872352721779972131204L,  // degree 8
+       0.1568533229389436436689811009933007L, 0.1813418916891809914825752246385978L,
+       0.1813418916891809914825752246385978L, 0.1568533229389436436689811009933007L,
+       0.1111905172266872352721779972131204L, 0.0506142681451881295762656771549811L},
+      {0.0406371941807872059859460790552618L, 0.0903240803474287020292360156214564L,  // degree 9
+       0.1303053482014677311593714347093164L, 0.1561735385200014200343152032922218L,
+       0.1651196775006298815822625346434870L, 0.1561735385200014200343152032922218L,
+       0.1303053482014677311593714347093164L, 0.0903240803474287020292360156214564L,
+       0.0406371941807872059859460790552618L},
+      {0.0333356721543440687967844049466659L, 0.0747256745752902965728881698288487L,  // degree 10
+       0.1095431812579910219977674671140816L, 0.1346333596549981775456134607847347L,
+       0.1477621123573764350869464973256692L, 0.1477621123573764350869464973256692L,
+       0.1346333596549981775456134607847347L, 0.1095431812579910219977674671140816L,
+       0.0747256745752902965728881698288487L, 0.0333356721543440687967844049466659L},
+      {0.0278342835580868332413768602212743L, 0.0627901847324523123173471496119701L,  // degree 11
+       0.0931451054638671257130488207158280L, 0.1165968822959952399592618524215876L,
+       0.1314022722551233310903444349452546L, 0.1364625433889503153572417641681711L,
+       0.1314022722551233310903444349452546L, 0.1165968822959952399592618524215876L,
+       0.0931451054638671257130488207158280L, 0.0627901847324523123173471496119701L,
+       0.0278342835580868332413768602212743L}};
+
+  MatrixType TminusI = T - MatrixType::Identity(T.rows(), T.rows());
+  result.setZero(T.rows(), T.rows());
+  for (int k = 0; k < degree; ++k) {
+    RealScalar weight = weights[degree - minPadeDegree][k];
+    RealScalar node = nodes[degree - minPadeDegree][k];
+    result +=
+        weight *
+        (MatrixType::Identity(T.rows(), T.rows()) + node * TminusI).template triangularView<Upper>().solve(TminusI);
+  }
+}
+
+/** \brief Compute logarithm of triangular matrices with size > 2.
+ * \details This uses an inverse scale-and-square algorithm. */
+template <typename MatrixType>
+void matrix_log_compute_big(const MatrixType& A, MatrixType& result) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  using std::pow;
+
+  int numberOfSquareRoots = 0;
+  int numberOfExtraSquareRoots = 0;
+  int degree;
+  MatrixType T = A, sqrtT;
+
+  // The matrix logarithm is undefined for singular matrices. Without this
+  // guard, a zero diagonal entry (eigenvalue) is a fixed point of the
+  // square-rooting loop below (sqrt(0) = 0), so the loop never terminates
+  // (bug #1613).
+  if ((T.diagonal().array() == Scalar(0)).any()) {
+    result.setConstant(T.rows(), T.rows(), NumTraits<RealScalar>::quiet_NaN());
+    return;
+  }
+
+  const int maxPadeDegree = matrix_log_max_pade_degree<Scalar>::value;
+  const RealScalar maxNormForPade = RealScalar(maxPadeDegree <= 5 ? 5.3149729967117310e-1L :  // single precision
+                                                   maxPadeDegree <= 7 ? 2.6429608311114350e-1L
+                                                                      :  // double precision
+                                                   maxPadeDegree <= 8 ? 2.32777776523703892094e-1L
+                                                                      :  // extended precision
+                                                   maxPadeDegree <= 10 ? 1.05026503471351080481093652651105e-1L
+                                                                       :                       // double-double
+                                                   1.1880960220216759245467951592883642e-1L);  // quadruple precision
+
+  while (true) {
+    RealScalar normTminusI = (T - MatrixType::Identity(T.rows(), T.rows())).cwiseAbs().colwise().sum().maxCoeff();
+    if (normTminusI < maxNormForPade) {
+      degree = matrix_log_get_pade_degree(normTminusI);
+      int degree2 = matrix_log_get_pade_degree(normTminusI / RealScalar(2));
+      if ((degree - degree2 <= 1) || (numberOfExtraSquareRoots == 1)) break;
+      ++numberOfExtraSquareRoots;
+    }
+    matrix_sqrt_triangular(T, sqrtT);
+    T = sqrtT.template triangularView<Upper>();
+    ++numberOfSquareRoots;
+  }
+
+  matrix_log_compute_pade(result, T, degree);
+  result *= pow(RealScalar(2), RealScalar(numberOfSquareRoots));  // TODO: Replace by bitshift if possible.
+}
+
+/** \ingroup MatrixFunctions_Module
+ * \class MatrixLogarithmAtomic
+ * \brief Helper class for computing matrix logarithm of atomic matrices.
+ *
+ * Here, an atomic matrix is a triangular matrix whose diagonal entries are close to each other.
+ *
+ * \sa class MatrixFunctionAtomic, MatrixBase::log()
+ */
+template <typename MatrixType>
+class MatrixLogarithmAtomic {
+ public:
+  /** \brief Compute matrix logarithm of atomic matrix
+   * \param[in]  A  argument of matrix logarithm, should be upper triangular and atomic
+   * \returns  The logarithm of \p A.
+   */
+  MatrixType compute(const MatrixType& A);
+};
+
+template <typename MatrixType>
+MatrixType MatrixLogarithmAtomic<MatrixType>::compute(const MatrixType& A) {
+  using std::log;
+  MatrixType result(A.rows(), A.rows());
+  if (A.rows() == 1)
+    result(0, 0) = log(A(0, 0));
+  else if (A.rows() == 2)
+    matrix_log_compute_2x2(A, result);
+  else
+    matrix_log_compute_big(A, result);
+  return result;
+}
+
+}  // end of namespace internal
+
+/** \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix logarithm of some matrix (expression).
+ *
+ * \tparam Derived  Type of the argument to the matrix function.
+ *
+ * This class holds the argument to the matrix function until it is
+ * assigned or evaluated for some other reason (so the argument
+ * should not be changed in the meantime). It is the return type of
+ * MatrixBase::log() and most of the time this is the only way it
+ * is used.
+ */
+template <typename Derived>
+class MatrixLogarithmReturnValue : public ReturnByValue<MatrixLogarithmReturnValue<Derived> > {
+ public:
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::Index Index;
+
+ protected:
+  typedef typename internal::ref_selector<Derived>::type DerivedNested;
+
+ public:
+  /** \brief Constructor.
+   *
+   * \param[in]  A  %Matrix (expression) forming the argument of the matrix logarithm.
+   */
+  explicit MatrixLogarithmReturnValue(const Derived& A) : m_A(A) {}
+
+  /** \brief Compute the matrix logarithm.
+   *
+   * \param[out]  result  Logarithm of \c A, where \c A is as specified in the constructor.
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    typedef typename internal::nested_eval<Derived, 10>::type DerivedEvalType;
+    typedef internal::remove_all_t<DerivedEvalType> DerivedEvalTypeClean;
+    typedef internal::traits<DerivedEvalTypeClean> Traits;
+    typedef internal::make_complex_t<Scalar> ComplexScalar;
+    typedef Matrix<ComplexScalar, Dynamic, Dynamic, 0, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime>
+        DynMatrixType;
+    typedef internal::MatrixLogarithmAtomic<DynMatrixType> AtomicType;
+    AtomicType atomic;
+
+    internal::matrix_function_compute<typename DerivedEvalTypeClean::PlainObject>::run(m_A, atomic, result);
+  }
+
+  Index rows() const { return m_A.rows(); }
+  Index cols() const { return m_A.cols(); }
+
+ private:
+  DerivedNested m_A;
+};
+
+namespace internal {
+template <typename Derived>
+struct traits<MatrixLogarithmReturnValue<Derived> > {
+  typedef typename Derived::PlainObject ReturnType;
+};
+}  // namespace internal
+
+/********** MatrixBase method **********/
+
+template <typename Derived>
+const MatrixLogarithmReturnValue<Derived> MatrixBase<Derived>::log() const {
+  eigen_assert(rows() == cols());
+  return MatrixLogarithmReturnValue<Derived>(derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATRIX_LOGARITHM
diff --git a/contrib/Eigen/src/MatrixFunctions/MatrixPower.h b/contrib/Eigen/src/MatrixFunctions/MatrixPower.h
new file mode 100644
index 0000000..078c996
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/MatrixPower.h
@@ -0,0 +1,704 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012, 2013 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_POWER
+#define EIGEN_MATRIX_POWER
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename MatrixType>
+class MatrixPower;
+
+/**
+ * \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix power of some matrix.
+ *
+ * \tparam MatrixType  type of the base, a matrix.
+ *
+ * This class holds the arguments to the matrix power until it is
+ * assigned or evaluated for some other reason (so the argument
+ * should not be changed in the meantime). It is the return type of
+ * MatrixPower::operator() and related functions and most of the
+ * time this is the only way it is used.
+ */
+/* TODO: This class is only used by MatrixPower, so it should be nested
+ * into MatrixPower, like MatrixPower::ReturnValue. However, my
+ * compiler complained about unused template parameter in the
+ * following declaration in namespace internal.
+ *
+ * template<typename MatrixType>
+ * struct traits<MatrixPower<MatrixType>::ReturnValue>;
+ */
+template <typename MatrixType>
+class MatrixPowerParenthesesReturnValue : public ReturnByValue<MatrixPowerParenthesesReturnValue<MatrixType> > {
+ public:
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  /**
+   * \brief Constructor.
+   *
+   * \param[in] pow  %MatrixPower storing the base.
+   * \param[in] p    scalar, the exponent of the matrix power.
+   */
+  MatrixPowerParenthesesReturnValue(MatrixPower<MatrixType>& pow, RealScalar p) : m_pow(pow), m_p(p) {}
+
+  /**
+   * \brief Compute the matrix power.
+   *
+   * \param[out] result
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    m_pow.compute(result, m_p);
+  }
+
+  Index rows() const { return m_pow.rows(); }
+  Index cols() const { return m_pow.cols(); }
+
+ private:
+  MatrixPower<MatrixType>& m_pow;
+  const RealScalar m_p;
+};
+
+/**
+ * \ingroup MatrixFunctions_Module
+ *
+ * \brief Class for computing matrix powers.
+ *
+ * \tparam MatrixType  type of the base, expected to be an instantiation
+ * of the Matrix class template.
+ *
+ * This class is capable of computing triangular real/complex matrices
+ * raised to a power in the interval \f$ (-1, 1) \f$.
+ *
+ * \note Currently this class is only used by MatrixPower. One may
+ * insist that this be nested into MatrixPower. This class is here to
+ * facilitate future development of triangular matrix functions.
+ */
+template <typename MatrixType>
+class MatrixPowerAtomic {
+ private:
+  enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime };
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  typedef Block<MatrixType, Dynamic, Dynamic> ResultType;
+
+  const MatrixType& m_A;
+  RealScalar m_p;
+
+  void computePade(int degree, const MatrixType& IminusT, ResultType& res) const;
+  void compute2x2(ResultType& res, RealScalar p) const;
+  void computeBig(ResultType& res) const;
+  static int getPadeDegree(float normIminusT);
+  static int getPadeDegree(double normIminusT);
+  static int getPadeDegree(long double normIminusT);
+  static ComplexScalar computeSuperDiag(const ComplexScalar&, const ComplexScalar&, RealScalar p);
+  static RealScalar computeSuperDiag(RealScalar, RealScalar, RealScalar p);
+
+ public:
+  MatrixPowerAtomic(const MatrixPowerAtomic&) = delete;
+  MatrixPowerAtomic& operator=(const MatrixPowerAtomic&) = delete;
+
+  /**
+   * \brief Constructor.
+   *
+   * \param[in] T  the base of the matrix power.
+   * \param[in] p  the exponent of the matrix power, should be in
+   * \f$ (-1, 1) \f$.
+   *
+   * The class stores a reference to T, so it should not be changed
+   * (or destroyed) before evaluation. Only the upper triangular
+   * part of T is read.
+   */
+  MatrixPowerAtomic(const MatrixType& T, RealScalar p);
+
+  /**
+   * \brief Compute the matrix power.
+   *
+   * \param[out] res  \f$ A^p \f$ where A and p are specified in the
+   * constructor.
+   */
+  void compute(ResultType& res) const;
+};
+
+template <typename MatrixType>
+MatrixPowerAtomic<MatrixType>::MatrixPowerAtomic(const MatrixType& T, RealScalar p) : m_A(T), m_p(p) {
+  eigen_assert(T.rows() == T.cols());
+  eigen_assert(p > -1 && p < 1);
+}
+
+template <typename MatrixType>
+void MatrixPowerAtomic<MatrixType>::compute(ResultType& res) const {
+  using std::pow;
+  switch (m_A.rows()) {
+    case 0:
+      break;
+    case 1:
+      res(0, 0) = pow(m_A(0, 0), m_p);
+      break;
+    case 2:
+      compute2x2(res, m_p);
+      break;
+    default:
+      computeBig(res);
+  }
+}
+
+template <typename MatrixType>
+void MatrixPowerAtomic<MatrixType>::computePade(int degree, const MatrixType& IminusT, ResultType& res) const {
+  int i = 2 * degree;
+  res = (m_p - RealScalar(degree)) / RealScalar(2 * i - 2) * IminusT;
+
+  for (--i; i; --i) {
+    res = (MatrixType::Identity(IminusT.rows(), IminusT.cols()) + res)
+              .template triangularView<Upper>()
+              .solve((i == 1  ? -m_p
+                      : i & 1 ? (-m_p - RealScalar(i / 2)) / RealScalar(2 * i)
+                              : (m_p - RealScalar(i / 2)) / RealScalar(2 * i - 2)) *
+                     IminusT)
+              .eval();
+  }
+  res += MatrixType::Identity(IminusT.rows(), IminusT.cols());
+}
+
+// This function assumes that res has the correct size (see bug 614)
+template <typename MatrixType>
+void MatrixPowerAtomic<MatrixType>::compute2x2(ResultType& res, RealScalar p) const {
+  using std::abs;
+  using std::pow;
+  res.coeffRef(0, 0) = pow(m_A.coeff(0, 0), p);
+
+  for (Index i = 1; i < m_A.cols(); ++i) {
+    res.coeffRef(i, i) = pow(m_A.coeff(i, i), p);
+    Scalar a = m_A.coeff(i - 1, i - 1);
+    Scalar b = m_A.coeff(i, i);
+    Scalar diff = b - a;
+    // Use the derivative formula when eigenvalues are nearly equal to avoid
+    // catastrophic cancellation in the difference quotient.
+    if (abs(diff) <= RealScalar(2) * (std::numeric_limits<RealScalar>::epsilon)() * (std::max)(abs(a), abs(b)))
+      res.coeffRef(i - 1, i) = p * pow(b, p - 1);
+    else if (2 * abs(a) < abs(b) || 2 * abs(b) < abs(a))
+      res.coeffRef(i - 1, i) = (res.coeff(i, i) - res.coeff(i - 1, i - 1)) / diff;
+    else
+      res.coeffRef(i - 1, i) = computeSuperDiag(b, a, p);
+    res.coeffRef(i - 1, i) *= m_A.coeff(i - 1, i);
+  }
+}
+
+template <typename MatrixType>
+void MatrixPowerAtomic<MatrixType>::computeBig(ResultType& res) const {
+  using std::ldexp;
+  const int digits = std::numeric_limits<RealScalar>::digits;
+  const RealScalar maxNormForPade =
+      RealScalar(digits <= 24    ? 4.3386528e-1L                              // single precision
+                 : digits <= 53  ? 2.789358995219730e-1L                      // double precision
+                 : digits <= 64  ? 2.4471944416607995472e-1L                  // extended precision
+                 : digits <= 106 ? 1.1016843812851143391275867258512e-1L      // double-double
+                                 : 9.134603732914548552537150753385375e-2L);  // quadruple precision
+  MatrixType IminusT, sqrtT, T = m_A.template triangularView<Upper>();
+  RealScalar normIminusT;
+  int degree, degree2, numberOfSquareRoots = 0;
+  bool hasExtraSquareRoot = false;
+
+  for (Index i = 0; i < m_A.cols(); ++i) eigen_assert(m_A(i, i) != RealScalar(0));
+
+  while (true) {
+    IminusT = MatrixType::Identity(m_A.rows(), m_A.cols()) - T;
+    normIminusT = IminusT.cwiseAbs().colwise().sum().maxCoeff();
+    if (normIminusT < maxNormForPade) {
+      degree = getPadeDegree(normIminusT);
+      degree2 = getPadeDegree(normIminusT / 2);
+      if (degree - degree2 <= 1 || hasExtraSquareRoot) break;
+      hasExtraSquareRoot = true;
+    }
+    matrix_sqrt_triangular(T, sqrtT);
+    T = sqrtT.template triangularView<Upper>();
+    ++numberOfSquareRoots;
+  }
+  computePade(degree, IminusT, res);
+
+  for (; numberOfSquareRoots; --numberOfSquareRoots) {
+    compute2x2(res, ldexp(m_p, -numberOfSquareRoots));
+    res = res.template triangularView<Upper>() * res;
+  }
+  compute2x2(res, m_p);
+}
+
+template <typename MatrixType>
+inline int MatrixPowerAtomic<MatrixType>::getPadeDegree(float normIminusT) {
+  const float maxNormForPade[] = {2.8064004e-1f /* degree = 3 */, 4.3386528e-1f};
+  int degree = 3;
+  for (; degree <= 4; ++degree)
+    if (normIminusT <= maxNormForPade[degree - 3]) break;
+  return degree;
+}
+
+template <typename MatrixType>
+inline int MatrixPowerAtomic<MatrixType>::getPadeDegree(double normIminusT) {
+  const double maxNormForPade[] = {1.884160592658218e-2 /* degree = 3 */, 6.038881904059573e-2, 1.239917516308172e-1,
+                                   1.999045567181744e-1, 2.789358995219730e-1};
+  int degree = 3;
+  for (; degree <= 7; ++degree)
+    if (normIminusT <= maxNormForPade[degree - 3]) break;
+  return degree;
+}
+
+template <typename MatrixType>
+inline int MatrixPowerAtomic<MatrixType>::getPadeDegree(long double normIminusT) {
+#if LDBL_MANT_DIG == 53
+  const int maxPadeDegree = 7;
+  const double maxNormForPade[] = {1.884160592658218e-2L /* degree = 3 */, 6.038881904059573e-2L, 1.239917516308172e-1L,
+                                   1.999045567181744e-1L, 2.789358995219730e-1L};
+#elif LDBL_MANT_DIG <= 64
+  const int maxPadeDegree = 8;
+  const long double maxNormForPade[] = {6.3854693117491799460e-3L /* degree = 3 */,
+                                        2.6394893435456973676e-2L,
+                                        6.4216043030404063729e-2L,
+                                        1.1701165502926694307e-1L,
+                                        1.7904284231268670284e-1L,
+                                        2.4471944416607995472e-1L};
+#elif LDBL_MANT_DIG <= 106
+  const int maxPadeDegree = 10;
+  const double maxNormForPade[] = {1.0007161601787493236741409687186e-4L /* degree = 3 */,
+                                   1.0007161601787493236741409687186e-3L,
+                                   4.7069769360887572939882574746264e-3L,
+                                   1.3220386624169159689406653101695e-2L,
+                                   2.8063482381631737920612944054906e-2L,
+                                   4.9625993951953473052385361085058e-2L,
+                                   7.7367040706027886224557538328171e-2L,
+                                   1.1016843812851143391275867258512e-1L};
+#else
+  const int maxPadeDegree = 10;
+  const double maxNormForPade[] = {5.524506147036624377378713555116378e-5L /* degree = 3 */,
+                                   6.640600568157479679823602193345995e-4L,
+                                   3.227716520106894279249709728084626e-3L,
+                                   9.619593944683432960546978734646284e-3L,
+                                   2.134595382433742403911124458161147e-2L,
+                                   3.908166513900489428442993794761185e-2L,
+                                   6.266780814639442865832535460550138e-2L,
+                                   9.134603732914548552537150753385375e-2L};
+#endif
+  int degree = 3;
+  for (; degree <= maxPadeDegree; ++degree)
+    if (normIminusT <= static_cast<long double>(maxNormForPade[degree - 3])) break;
+  return degree;
+}
+
+template <typename MatrixType>
+inline typename MatrixPowerAtomic<MatrixType>::ComplexScalar MatrixPowerAtomic<MatrixType>::computeSuperDiag(
+    const ComplexScalar& curr, const ComplexScalar& prev, RealScalar p) {
+  using std::ceil;
+  using std::exp;
+  using std::log;
+  using std::sinh;
+
+  ComplexScalar logCurr = log(curr);
+  ComplexScalar logPrev = log(prev);
+  RealScalar unwindingNumber =
+      ceil((numext::imag(logCurr - logPrev) - RealScalar(EIGEN_PI)) / RealScalar(2 * EIGEN_PI));
+  ComplexScalar w =
+      numext::log1p((curr - prev) / prev) / RealScalar(2) + ComplexScalar(0, RealScalar(EIGEN_PI) * unwindingNumber);
+  return RealScalar(2) * exp(RealScalar(0.5) * p * (logCurr + logPrev)) * sinh(p * w) / (curr - prev);
+}
+
+template <typename MatrixType>
+inline typename MatrixPowerAtomic<MatrixType>::RealScalar MatrixPowerAtomic<MatrixType>::computeSuperDiag(
+    RealScalar curr, RealScalar prev, RealScalar p) {
+  using std::exp;
+  using std::log;
+  using std::sinh;
+
+  RealScalar w = numext::log1p((curr - prev) / prev) / RealScalar(2);
+  return 2 * exp(p * (log(curr) + log(prev)) / 2) * sinh(p * w) / (curr - prev);
+}
+
+/**
+ * \ingroup MatrixFunctions_Module
+ *
+ * \brief Class for computing matrix powers.
+ *
+ * \tparam MatrixType  type of the base, expected to be an instantiation
+ * of the Matrix class template.
+ *
+ * This class is capable of computing real/complex matrices raised to
+ * an arbitrary real power. Meanwhile, it saves the result of Schur
+ * decomposition if a non-integral power has ever been calculated.
+ * Therefore, if you want to compute multiple (>= 2) matrix powers
+ * for the same matrix, using the class directly is more efficient than
+ * calling MatrixBase::pow().
+ *
+ * Example:
+ * \include MatrixPower_optimal.cpp
+ * Output: \verbinclude MatrixPower_optimal.out
+ */
+template <typename MatrixType>
+class MatrixPower {
+ private:
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+ public:
+  MatrixPower(const MatrixPower&) = delete;
+  MatrixPower& operator=(const MatrixPower&) = delete;
+
+  /**
+   * \brief Constructor.
+   *
+   * \param[in] A  the base of the matrix power.
+   *
+   * The class stores a reference to A, so it should not be changed
+   * (or destroyed) before evaluation.
+   */
+  explicit MatrixPower(const MatrixType& A) : m_A(A), m_conditionNumber(0), m_rank(A.cols()), m_nulls(0) {
+    eigen_assert(A.rows() == A.cols());
+  }
+
+  /**
+   * \brief Returns the matrix power.
+   *
+   * \param[in] p  exponent, a real scalar.
+   * \return The expression \f$ A^p \f$, where A is specified in the
+   * constructor.
+   */
+  const MatrixPowerParenthesesReturnValue<MatrixType> operator()(RealScalar p) {
+    return MatrixPowerParenthesesReturnValue<MatrixType>(*this, p);
+  }
+
+  /**
+   * \brief Compute the matrix power.
+   *
+   * \param[in]  p    exponent, a real scalar.
+   * \param[out] res  \f$ A^p \f$ where A is specified in the
+   * constructor.
+   */
+  template <typename ResultType>
+  void compute(ResultType& res, RealScalar p);
+
+  Index rows() const { return m_A.rows(); }
+  Index cols() const { return m_A.cols(); }
+
+ private:
+  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  typedef Matrix<ComplexScalar, Dynamic, Dynamic, 0, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>
+      ComplexMatrix;
+
+  /** \brief Reference to the base of matrix power. */
+  typename MatrixType::Nested m_A;
+
+  /** \brief Temporary storage. */
+  MatrixType m_tmp;
+
+  /** \brief Store the result of Schur decomposition. */
+  ComplexMatrix m_T, m_U;
+
+  /** \brief Store fractional power of m_T. */
+  ComplexMatrix m_fT;
+
+  /**
+   * \brief Condition number of m_A.
+   *
+   * It is initialized as 0 to avoid performing unnecessary Schur
+   * decomposition, which is the bottleneck.
+   */
+  RealScalar m_conditionNumber;
+
+  /** \brief Rank of m_A. */
+  Index m_rank;
+
+  /** \brief Rank deficiency of m_A. */
+  Index m_nulls;
+
+  /**
+   * \brief Split p into integral part and fractional part.
+   *
+   * \param[in]  p        The exponent.
+   * \param[out] p        The fractional part ranging in \f$ (-1, 1) \f$.
+   * \param[out] intpart  The integral part.
+   *
+   * Only if the fractional part is nonzero, it calls initialize().
+   */
+  void split(RealScalar& p, RealScalar& intpart);
+
+  /** \brief Perform Schur decomposition for fractional power. */
+  void initialize();
+
+  template <typename ResultType>
+  void computeIntPower(ResultType& res, RealScalar p);
+
+  template <typename ResultType>
+  void computeFracPower(ResultType& res, RealScalar p);
+
+  template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+  static void revertSchur(Matrix<ComplexScalar, Rows, Cols, Options, MaxRows, MaxCols>& res, const ComplexMatrix& T,
+                          const ComplexMatrix& U);
+
+  template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+  static void revertSchur(Matrix<RealScalar, Rows, Cols, Options, MaxRows, MaxCols>& res, const ComplexMatrix& T,
+                          const ComplexMatrix& U);
+};
+
+template <typename MatrixType>
+template <typename ResultType>
+void MatrixPower<MatrixType>::compute(ResultType& res, RealScalar p) {
+  using std::pow;
+  switch (cols()) {
+    case 0:
+      break;
+    case 1:
+      res(0, 0) = pow(m_A.coeff(0, 0), p);
+      break;
+    default:
+      RealScalar intpart;
+      split(p, intpart);
+
+      res = MatrixType::Identity(rows(), cols());
+      computeIntPower(res, intpart);
+      if (p) computeFracPower(res, p);
+  }
+}
+
+template <typename MatrixType>
+void MatrixPower<MatrixType>::split(RealScalar& p, RealScalar& intpart) {
+  using std::floor;
+  using std::pow;
+
+  intpart = floor(p);
+  p -= intpart;
+
+  // Perform Schur decomposition if it is not yet performed and the power is
+  // not an integer.
+  if (!m_conditionNumber && p) initialize();
+
+  // Choose the more stable of intpart = floor(p) and intpart = ceil(p).
+  if (p > RealScalar(0.5) && p > (1 - p) * pow(m_conditionNumber, p)) {
+    --p;
+    ++intpart;
+  }
+}
+
+template <typename MatrixType>
+void MatrixPower<MatrixType>::initialize() {
+  const ComplexSchur<MatrixType> schurOfA(m_A);
+  JacobiRotation<ComplexScalar> rot;
+  ComplexScalar eigenvalue;
+
+  m_fT.resizeLike(m_A);
+  m_T = schurOfA.matrixT();
+  m_U = schurOfA.matrixU();
+  m_conditionNumber = m_T.diagonal().array().abs().maxCoeff() / m_T.diagonal().array().abs().minCoeff();
+
+  // Move zero eigenvalues to the bottom right corner.
+  for (Index i = cols() - 1; i >= 0; --i) {
+    if (m_rank <= 2) return;
+    if (m_T.coeff(i, i) == RealScalar(0)) {
+      for (Index j = i + 1; j < m_rank; ++j) {
+        eigenvalue = m_T.coeff(j, j);
+        rot.makeGivens(m_T.coeff(j - 1, j), eigenvalue);
+        m_T.applyOnTheRight(j - 1, j, rot);
+        m_T.applyOnTheLeft(j - 1, j, rot.adjoint());
+        m_T.coeffRef(j - 1, j - 1) = eigenvalue;
+        m_T.coeffRef(j, j) = RealScalar(0);
+        m_U.applyOnTheRight(j - 1, j, rot);
+      }
+      --m_rank;
+    }
+  }
+
+  m_nulls = rows() - m_rank;
+  if (m_nulls) {
+    eigen_assert(m_T.bottomRightCorner(m_nulls, m_nulls).isZero() &&
+                 "Base of matrix power should be invertible or with a semisimple zero eigenvalue.");
+    m_fT.bottomRows(m_nulls).fill(RealScalar(0));
+  }
+}
+
+template <typename MatrixType>
+template <typename ResultType>
+void MatrixPower<MatrixType>::computeIntPower(ResultType& res, RealScalar p) {
+  using std::abs;
+  using std::fmod;
+  RealScalar pp = abs(p);
+
+  if (p < 0)
+    m_tmp = m_A.inverse();
+  else
+    m_tmp = m_A;
+
+  while (true) {
+    if (fmod(pp, 2) >= 1) res = m_tmp * res;
+    pp /= 2;
+    if (pp < 1) break;
+    m_tmp *= m_tmp;
+  }
+}
+
+template <typename MatrixType>
+template <typename ResultType>
+void MatrixPower<MatrixType>::computeFracPower(ResultType& res, RealScalar p) {
+  Block<ComplexMatrix, Dynamic, Dynamic> blockTp(m_fT, 0, 0, m_rank, m_rank);
+  eigen_assert(m_conditionNumber);
+  eigen_assert(m_rank + m_nulls == rows());
+
+  MatrixPowerAtomic<ComplexMatrix>(m_T.topLeftCorner(m_rank, m_rank), p).compute(blockTp);
+  if (m_nulls) {
+    m_fT.topRightCorner(m_rank, m_nulls) = m_T.topLeftCorner(m_rank, m_rank)
+                                               .template triangularView<Upper>()
+                                               .solve(blockTp * m_T.topRightCorner(m_rank, m_nulls));
+  }
+  revertSchur(m_tmp, m_fT, m_U);
+  res = m_tmp * res;
+}
+
+template <typename MatrixType>
+template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+inline void MatrixPower<MatrixType>::revertSchur(Matrix<ComplexScalar, Rows, Cols, Options, MaxRows, MaxCols>& res,
+                                                 const ComplexMatrix& T, const ComplexMatrix& U) {
+  res.noalias() = U * (T.template triangularView<Upper>() * U.adjoint());
+}
+
+template <typename MatrixType>
+template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+inline void MatrixPower<MatrixType>::revertSchur(Matrix<RealScalar, Rows, Cols, Options, MaxRows, MaxCols>& res,
+                                                 const ComplexMatrix& T, const ComplexMatrix& U) {
+  res.noalias() = (U * (T.template triangularView<Upper>() * U.adjoint())).real();
+}
+
+/**
+ * \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix power of some matrix (expression).
+ *
+ * \tparam Derived  type of the base, a matrix (expression).
+ *
+ * This class holds the arguments to the matrix power until it is
+ * assigned or evaluated for some other reason (so the argument
+ * should not be changed in the meantime). It is the return type of
+ * MatrixBase::pow() and related functions and most of the
+ * time this is the only way it is used.
+ */
+template <typename Derived>
+class MatrixPowerReturnValue : public ReturnByValue<MatrixPowerReturnValue<Derived> > {
+ public:
+  typedef typename Derived::PlainObject PlainObject;
+  typedef typename Derived::RealScalar RealScalar;
+
+  /**
+   * \brief Constructor.
+   *
+   * \param[in] A  %Matrix (expression), the base of the matrix power.
+   * \param[in] p  real scalar, the exponent of the matrix power.
+   */
+  MatrixPowerReturnValue(const Derived& A, RealScalar p) : m_A(A), m_p(p) {}
+
+  /**
+   * \brief Compute the matrix power.
+   *
+   * \param[out] result  \f$ A^p \f$ where \p A and \p p are as in the
+   * constructor.
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    MatrixPower<PlainObject>(m_A.eval()).compute(result, m_p);
+  }
+
+  Index rows() const { return m_A.rows(); }
+  Index cols() const { return m_A.cols(); }
+
+ private:
+  const Derived& m_A;
+  const RealScalar m_p;
+};
+
+/**
+ * \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix power of some matrix (expression).
+ *
+ * \tparam Derived  type of the base, a matrix (expression).
+ *
+ * This class holds the arguments to the matrix power until it is
+ * assigned or evaluated for some other reason (so the argument
+ * should not be changed in the meantime). It is the return type of
+ * MatrixBase::pow() and related functions and most of the
+ * time this is the only way it is used.
+ */
+template <typename Derived>
+class MatrixComplexPowerReturnValue : public ReturnByValue<MatrixComplexPowerReturnValue<Derived> > {
+ public:
+  typedef typename Derived::PlainObject PlainObject;
+  typedef internal::make_complex_t<typename Derived::Scalar> ComplexScalar;
+
+  /**
+   * \brief Constructor.
+   *
+   * \param[in] A  %Matrix (expression), the base of the matrix power.
+   * \param[in] p  complex scalar, the exponent of the matrix power.
+   */
+  MatrixComplexPowerReturnValue(const Derived& A, const ComplexScalar& p) : m_A(A), m_p(p) {}
+
+  /**
+   * \brief Compute the matrix power.
+   *
+   * Because \p p is complex, \f$ A^p \f$ is simply evaluated as \f$
+   * \exp(p \log(A)) \f$.
+   *
+   * \param[out] result  \f$ A^p \f$ where \p A and \p p are as in the
+   * constructor.
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    result = (m_p * m_A.log()).exp();
+  }
+
+  Index rows() const { return m_A.rows(); }
+  Index cols() const { return m_A.cols(); }
+
+ private:
+  const Derived& m_A;
+  const ComplexScalar m_p;
+};
+
+namespace internal {
+
+template <typename MatrixPowerType>
+struct traits<MatrixPowerParenthesesReturnValue<MatrixPowerType> > {
+  typedef typename MatrixPowerType::PlainObject ReturnType;
+};
+
+template <typename Derived>
+struct traits<MatrixPowerReturnValue<Derived> > {
+  typedef typename Derived::PlainObject ReturnType;
+};
+
+template <typename Derived>
+struct traits<MatrixComplexPowerReturnValue<Derived> > {
+  typedef typename Derived::PlainObject ReturnType;
+};
+
+}  // namespace internal
+
+template <typename Derived>
+const MatrixPowerReturnValue<Derived> MatrixBase<Derived>::pow(const RealScalar& p) const {
+  return MatrixPowerReturnValue<Derived>(derived(), p);
+}
+
+template <typename Derived>
+const MatrixComplexPowerReturnValue<Derived> MatrixBase<Derived>::pow(const internal::make_complex_t<Scalar>& p) const {
+  return MatrixComplexPowerReturnValue<Derived>(derived(), p);
+}
+
+}  // namespace Eigen
+
+#endif  // EIGEN_MATRIX_POWER
diff --git a/contrib/Eigen/src/MatrixFunctions/MatrixSquareRoot.h b/contrib/Eigen/src/MatrixFunctions/MatrixSquareRoot.h
new file mode 100644
index 0000000..4aac6f5
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/MatrixSquareRoot.h
@@ -0,0 +1,346 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_MATRIX_SQUARE_ROOT
+#define EIGEN_MATRIX_SQUARE_ROOT
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// pre:  T.block(i,i,2,2) has complex conjugate eigenvalues
+// post: sqrtT.block(i,i,2,2) is square root of T.block(i,i,2,2)
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_2x2_diagonal_block(const MatrixType& T, Index i, ResultType& sqrtT) {
+  // TODO: this 2x2 complex-conjugate eigenvalue case could reuse logic from EigenSolver if exposed.
+  typedef typename traits<MatrixType>::Scalar Scalar;
+  Matrix<Scalar, 2, 2> block = T.template block<2, 2>(i, i);
+  EigenSolver<Matrix<Scalar, 2, 2> > es(block);
+  sqrtT.template block<2, 2>(i, i) =
+      (es.eigenvectors() * es.eigenvalues().cwiseSqrt().asDiagonal() * es.eigenvectors().inverse()).real();
+}
+
+// pre:  block structure of T is such that (i,j) is a 1x1 block,
+//       all blocks of sqrtT to left of and below (i,j) are correct
+// post: sqrtT(i,j) has the correct value
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
+  typedef typename traits<MatrixType>::Scalar Scalar;
+  Scalar tmp = (sqrtT.row(i).segment(i + 1, j - i - 1) * sqrtT.col(j).segment(i + 1, j - i - 1)).value();
+  sqrtT.coeffRef(i, j) = (T.coeff(i, j) - tmp) / (sqrtT.coeff(i, i) + sqrtT.coeff(j, j));
+}
+
+// similar to matrix_sqrt_quasi_triangular_1x1_off_diagonal_block()
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_1x2_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
+  typedef typename traits<MatrixType>::Scalar Scalar;
+  Matrix<Scalar, 1, 2> rhs = T.template block<1, 2>(i, j);
+  if (j - i > 1) rhs.noalias() -= sqrtT.block(i, i + 1, 1, j - i - 1) * sqrtT.block(i + 1, j, j - i - 1, 2);
+  Matrix<Scalar, 2, 2> A = sqrtT.coeff(i, i) * Matrix<Scalar, 2, 2>::Identity();
+  A += sqrtT.template block<2, 2>(j, j).transpose();
+  sqrtT.template block<1, 2>(i, j).transpose() = A.fullPivLu().solve(rhs.transpose());
+}
+
+// similar to matrix_sqrt_quasi_triangular_1x1_off_diagonal_block()
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_2x1_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
+  typedef typename traits<MatrixType>::Scalar Scalar;
+  Matrix<Scalar, 2, 1> rhs = T.template block<2, 1>(i, j);
+  if (j - i > 2) rhs.noalias() -= sqrtT.block(i, i + 2, 2, j - i - 2) * sqrtT.block(i + 2, j, j - i - 2, 1);
+  Matrix<Scalar, 2, 2> A = sqrtT.coeff(j, j) * Matrix<Scalar, 2, 2>::Identity();
+  A += sqrtT.template block<2, 2>(i, i);
+  sqrtT.template block<2, 1>(i, j) = A.fullPivLu().solve(rhs);
+}
+
+// solves the equation A X + X B = C where all matrices are 2-by-2
+template <typename MatrixType>
+void matrix_sqrt_quasi_triangular_solve_auxiliary_equation(MatrixType& X, const MatrixType& A, const MatrixType& B,
+                                                           const MatrixType& C) {
+  typedef typename traits<MatrixType>::Scalar Scalar;
+  Matrix<Scalar, 4, 4> coeffMatrix = Matrix<Scalar, 4, 4>::Zero();
+  coeffMatrix.coeffRef(0, 0) = A.coeff(0, 0) + B.coeff(0, 0);
+  coeffMatrix.coeffRef(1, 1) = A.coeff(0, 0) + B.coeff(1, 1);
+  coeffMatrix.coeffRef(2, 2) = A.coeff(1, 1) + B.coeff(0, 0);
+  coeffMatrix.coeffRef(3, 3) = A.coeff(1, 1) + B.coeff(1, 1);
+  coeffMatrix.coeffRef(0, 1) = B.coeff(1, 0);
+  coeffMatrix.coeffRef(0, 2) = A.coeff(0, 1);
+  coeffMatrix.coeffRef(1, 0) = B.coeff(0, 1);
+  coeffMatrix.coeffRef(1, 3) = A.coeff(0, 1);
+  coeffMatrix.coeffRef(2, 0) = A.coeff(1, 0);
+  coeffMatrix.coeffRef(2, 3) = B.coeff(1, 0);
+  coeffMatrix.coeffRef(3, 1) = A.coeff(1, 0);
+  coeffMatrix.coeffRef(3, 2) = B.coeff(0, 1);
+
+  Matrix<Scalar, 4, 1> rhs;
+  rhs.coeffRef(0) = C.coeff(0, 0);
+  rhs.coeffRef(1) = C.coeff(0, 1);
+  rhs.coeffRef(2) = C.coeff(1, 0);
+  rhs.coeffRef(3) = C.coeff(1, 1);
+
+  Matrix<Scalar, 4, 1> result;
+  result = coeffMatrix.fullPivLu().solve(rhs);
+
+  X.coeffRef(0, 0) = result.coeff(0);
+  X.coeffRef(0, 1) = result.coeff(1);
+  X.coeffRef(1, 0) = result.coeff(2);
+  X.coeffRef(1, 1) = result.coeff(3);
+}
+
+// similar to matrix_sqrt_quasi_triangular_1x1_off_diagonal_block()
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_2x2_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
+  typedef typename traits<MatrixType>::Scalar Scalar;
+  Matrix<Scalar, 2, 2> A = sqrtT.template block<2, 2>(i, i);
+  Matrix<Scalar, 2, 2> B = sqrtT.template block<2, 2>(j, j);
+  Matrix<Scalar, 2, 2> C = T.template block<2, 2>(i, j);
+  if (j - i > 2) C.noalias() -= sqrtT.block(i, i + 2, 2, j - i - 2) * sqrtT.block(i + 2, j, j - i - 2, 2);
+  Matrix<Scalar, 2, 2> X;
+  matrix_sqrt_quasi_triangular_solve_auxiliary_equation(X, A, B, C);
+  sqrtT.template block<2, 2>(i, j) = X;
+}
+
+// pre:  T is quasi-upper-triangular and sqrtT is a zero matrix of the same size
+// post: the diagonal blocks of sqrtT are the square roots of the diagonal blocks of T
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_diagonal(const MatrixType& T, ResultType& sqrtT) {
+  using std::sqrt;
+  const Index size = T.rows();
+  for (Index i = 0; i < size; i++) {
+    if (i == size - 1 || T.coeff(i + 1, i) == 0) {
+      eigen_assert(T(i, i) >= 0);
+      sqrtT.coeffRef(i, i) = sqrt(T.coeff(i, i));
+    } else {
+      matrix_sqrt_quasi_triangular_2x2_diagonal_block(T, i, sqrtT);
+      ++i;
+    }
+  }
+}
+
+// pre:  T is quasi-upper-triangular and diagonal blocks of sqrtT are square root of diagonal blocks of T.
+// post: sqrtT is the square root of T.
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular_off_diagonal(const MatrixType& T, ResultType& sqrtT) {
+  const Index size = T.rows();
+  for (Index j = 1; j < size; j++) {
+    if (T.coeff(j, j - 1) != 0)  // if T(j-1:j, j-1:j) is a 2-by-2 block
+      continue;
+    for (Index i = j - 1; i >= 0; i--) {
+      if (i > 0 && T.coeff(i, i - 1) != 0)  // if T(i-1:i, i-1:i) is a 2-by-2 block
+        continue;
+      bool iBlockIs2x2 = (i < size - 1) && (T.coeff(i + 1, i) != 0);
+      bool jBlockIs2x2 = (j < size - 1) && (T.coeff(j + 1, j) != 0);
+      if (iBlockIs2x2 && jBlockIs2x2)
+        matrix_sqrt_quasi_triangular_2x2_off_diagonal_block(T, i, j, sqrtT);
+      else if (iBlockIs2x2 && !jBlockIs2x2)
+        matrix_sqrt_quasi_triangular_2x1_off_diagonal_block(T, i, j, sqrtT);
+      else if (!iBlockIs2x2 && jBlockIs2x2)
+        matrix_sqrt_quasi_triangular_1x2_off_diagonal_block(T, i, j, sqrtT);
+      else if (!iBlockIs2x2 && !jBlockIs2x2)
+        matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(T, i, j, sqrtT);
+    }
+  }
+}
+
+}  // end of namespace internal
+
+/** \ingroup MatrixFunctions_Module
+ * \brief Compute matrix square root of quasi-triangular matrix.
+ *
+ * \tparam  MatrixType  type of \p arg, the argument of matrix square root,
+ *                      expected to be an instantiation of the Matrix class template.
+ * \tparam  ResultType  type of \p result, where result is to be stored.
+ * \param[in]  arg      argument of matrix square root.
+ * \param[out] result   matrix square root of upper Hessenberg part of \p arg.
+ *
+ * This function computes the square root of the upper quasi-triangular matrix stored in the upper
+ * Hessenberg part of \p arg.  Only the upper Hessenberg part of \p result is updated, the rest is
+ * not touched.  See MatrixBase::sqrt() for details on how this computation is implemented.
+ *
+ * \sa MatrixSquareRoot, MatrixSquareRootQuasiTriangular
+ */
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_quasi_triangular(const MatrixType& arg, ResultType& result) {
+  eigen_assert(arg.rows() == arg.cols());
+  result.resize(arg.rows(), arg.cols());
+  internal::matrix_sqrt_quasi_triangular_diagonal(arg, result);
+  internal::matrix_sqrt_quasi_triangular_off_diagonal(arg, result);
+}
+
+/** \ingroup MatrixFunctions_Module
+ * \brief Compute matrix square root of triangular matrix.
+ *
+ * \tparam  MatrixType  type of \p arg, the argument of matrix square root,
+ *                      expected to be an instantiation of the Matrix class template.
+ * \tparam  ResultType  type of \p result, where result is to be stored.
+ * \param[in]  arg      argument of matrix square root.
+ * \param[out] result   matrix square root of upper triangular part of \p arg.
+ *
+ * Only the upper triangular part (including the diagonal) of \p result is updated, the rest is not
+ * touched.  See MatrixBase::sqrt() for details on how this computation is implemented.
+ *
+ * \sa MatrixSquareRoot, MatrixSquareRootQuasiTriangular
+ */
+template <typename MatrixType, typename ResultType>
+void matrix_sqrt_triangular(const MatrixType& arg, ResultType& result) {
+  using std::sqrt;
+  typedef typename MatrixType::Scalar Scalar;
+
+  eigen_assert(arg.rows() == arg.cols());
+
+  // Compute square root of arg and store it in upper triangular part of result
+  // This uses that the square root of triangular matrices can be computed directly.
+  result.resize(arg.rows(), arg.cols());
+  for (Index i = 0; i < arg.rows(); i++) {
+    result.coeffRef(i, i) = sqrt(arg.coeff(i, i));
+  }
+  for (Index j = 1; j < arg.cols(); j++) {
+    for (Index i = j - 1; i >= 0; i--) {
+      // if i = j-1, then segment has length 0 so tmp = 0
+      Scalar tmp = (result.row(i).segment(i + 1, j - i - 1) * result.col(j).segment(i + 1, j - i - 1)).value();
+      // denominator may be zero if original matrix is singular
+      result.coeffRef(i, j) = (arg.coeff(i, j) - tmp) / (result.coeff(i, i) + result.coeff(j, j));
+    }
+  }
+}
+
+namespace internal {
+
+/** \ingroup MatrixFunctions_Module
+ * \brief Helper struct for computing matrix square roots of general matrices.
+ * \tparam  MatrixType  type of the argument of the matrix square root,
+ *                      expected to be an instantiation of the Matrix class template.
+ *
+ * \sa MatrixSquareRootTriangular, MatrixSquareRootQuasiTriangular, MatrixBase::sqrt()
+ */
+template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
+struct matrix_sqrt_compute {
+  /** \brief Compute the matrix square root
+   *
+   * \param[in]  arg     matrix whose square root is to be computed.
+   * \param[out] result  square root of \p arg.
+   *
+   * See MatrixBase::sqrt() for details on how this computation is implemented.
+   */
+  template <typename ResultType>
+  static void run(const MatrixType& arg, ResultType& result);
+};
+
+// ********** Partial specialization for real matrices **********
+
+template <typename MatrixType>
+struct matrix_sqrt_compute<MatrixType, 0> {
+  typedef typename MatrixType::PlainObject PlainType;
+  template <typename ResultType>
+  static void run(const MatrixType& arg, ResultType& result) {
+    eigen_assert(arg.rows() == arg.cols());
+
+    // Compute Schur decomposition of arg
+    const RealSchur<PlainType> schurOfA(arg);
+    const PlainType& T = schurOfA.matrixT();
+    const PlainType& U = schurOfA.matrixU();
+
+    // Compute square root of T
+    PlainType sqrtT = PlainType::Zero(arg.rows(), arg.cols());
+    matrix_sqrt_quasi_triangular(T, sqrtT);
+
+    // Compute square root of arg
+    call_assignment_no_alias(result.derived(), U * sqrtT * U.adjoint());
+  }
+};
+
+// ********** Partial specialization for complex matrices **********
+
+template <typename MatrixType>
+struct matrix_sqrt_compute<MatrixType, 1> {
+  typedef typename MatrixType::PlainObject PlainType;
+  template <typename ResultType>
+  static void run(const MatrixType& arg, ResultType& result) {
+    eigen_assert(arg.rows() == arg.cols());
+
+    // Compute Schur decomposition of arg
+    const ComplexSchur<PlainType> schurOfA(arg);
+    const PlainType& T = schurOfA.matrixT();
+    const PlainType& U = schurOfA.matrixU();
+
+    // Compute square root of T
+    PlainType sqrtT;
+    matrix_sqrt_triangular(T, sqrtT);
+
+    // Compute square root of arg
+    call_assignment_no_alias(result.derived(), U * (sqrtT.template triangularView<Upper>() * U.adjoint()));
+  }
+};
+
+}  // end namespace internal
+
+/** \ingroup MatrixFunctions_Module
+ *
+ * \brief Proxy for the matrix square root of some matrix (expression).
+ *
+ * \tparam Derived  Type of the argument to the matrix square root.
+ *
+ * This class holds the argument to the matrix square root until it
+ * is assigned or evaluated for some other reason (so the argument
+ * should not be changed in the meantime). It is the return type of
+ * MatrixBase::sqrt() and most of the time this is the only way it is
+ * used.
+ */
+template <typename Derived>
+class MatrixSquareRootReturnValue : public ReturnByValue<MatrixSquareRootReturnValue<Derived> > {
+ protected:
+  typedef typename internal::ref_selector<Derived>::type DerivedNested;
+
+ public:
+  /** \brief Constructor.
+   *
+   * \param[in]  src  %Matrix (expression) forming the argument of the
+   * matrix square root.
+   */
+  explicit MatrixSquareRootReturnValue(const Derived& src) : m_src(src) {}
+
+  /** \brief Compute the matrix square root.
+   *
+   * \param[out]  result  the matrix square root of \p src in the
+   * constructor.
+   */
+  template <typename ResultType>
+  inline void evalTo(ResultType& result) const {
+    typedef typename internal::nested_eval<Derived, 10>::type DerivedEvalType;
+    typedef internal::remove_all_t<DerivedEvalType> DerivedEvalTypeClean;
+    DerivedEvalType tmp(m_src);
+    internal::matrix_sqrt_compute<DerivedEvalTypeClean>::run(tmp, result);
+  }
+
+  Index rows() const { return m_src.rows(); }
+  Index cols() const { return m_src.cols(); }
+
+ protected:
+  DerivedNested m_src;
+};
+
+namespace internal {
+template <typename Derived>
+struct traits<MatrixSquareRootReturnValue<Derived> > {
+  typedef typename Derived::PlainObject ReturnType;
+};
+}  // namespace internal
+
+template <typename Derived>
+const MatrixSquareRootReturnValue<Derived> MatrixBase<Derived>::sqrt() const {
+  eigen_assert(rows() == cols());
+  return MatrixSquareRootReturnValue<Derived>(derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_MATRIX_SQUARE_ROOT
diff --git a/contrib/Eigen/src/MatrixFunctions/StemFunction.h b/contrib/Eigen/src/MatrixFunctions/StemFunction.h
new file mode 100644
index 0000000..893a119
--- /dev/null
+++ b/contrib/Eigen/src/MatrixFunctions/StemFunction.h
@@ -0,0 +1,108 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_STEM_FUNCTION
+#define EIGEN_STEM_FUNCTION
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \brief The exponential function (and its derivatives). */
+template <typename Scalar>
+Scalar stem_function_exp(Scalar x, int) {
+  using std::exp;
+  return exp(x);
+}
+
+/** \brief Cosine (and its derivatives). */
+template <typename Scalar>
+Scalar stem_function_cos(Scalar x, int n) {
+  Scalar res;
+
+  switch (n % 4) {
+    case 0:
+      res = numext::cos(x);
+      break;
+    case 1:
+      res = -numext::sin(x);
+      break;
+    case 2:
+      res = -numext::cos(x);
+      break;
+    case 3:
+      res = numext::sin(x);
+      break;
+  }
+  return res;
+}
+
+/** \brief Sine (and its derivatives). */
+template <typename Scalar>
+Scalar stem_function_sin(Scalar x, int n) {
+  Scalar res;
+
+  switch (n % 4) {
+    case 0:
+      res = numext::sin(x);
+      break;
+    case 1:
+      res = numext::cos(x);
+      break;
+    case 2:
+      res = -numext::sin(x);
+      break;
+    case 3:
+      res = -numext::cos(x);
+      break;
+  }
+  return res;
+}
+
+/** \brief Hyperbolic cosine (and its derivatives). */
+template <typename Scalar>
+Scalar stem_function_cosh(Scalar x, int n) {
+  Scalar res;
+
+  switch (n % 2) {
+    case 0:
+      res = numext::cosh(x);
+      break;
+    case 1:
+      res = numext::sinh(x);
+      break;
+  }
+  return res;
+}
+
+/** \brief Hyperbolic sine (and its derivatives). */
+template <typename Scalar>
+Scalar stem_function_sinh(Scalar x, int n) {
+  Scalar res;
+
+  switch (n % 2) {
+    case 0:
+      res = numext::sinh(x);
+      break;
+    case 1:
+      res = numext::cosh(x);
+      break;
+  }
+  return res;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_STEM_FUNCTION
diff --git a/contrib/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h b/contrib/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
new file mode 100644
index 0000000..677e63a
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
@@ -0,0 +1,547 @@
+// -*- coding: utf-8
+// vim: set fileencoding=utf-8
+// SPDX-License-Identifier: MPL-2.0
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HYBRIDNONLINEARSOLVER_H
+#define EIGEN_HYBRIDNONLINEARSOLVER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace HybridNonLinearSolverSpace {
+enum Status {
+  Running = -1,
+  ImproperInputParameters = 0,
+  RelativeErrorTooSmall = 1,
+  TooManyFunctionEvaluation = 2,
+  TolTooSmall = 3,
+  NotMakingProgressJacobian = 4,
+  NotMakingProgressIterations = 5,
+  UserAsked = 6
+};
+}
+
+/**
+ * \ingroup NonLinearOptimization_Module
+ * \brief Finds a zero of a system of n
+ * nonlinear functions in n variables by a modification of the Powell
+ * hybrid method ("dogleg").
+ *
+ * The user must provide a subroutine which calculates the
+ * functions. The Jacobian is either provided by the user, or approximated
+ * using a forward-difference method.
+ *
+ */
+template <typename FunctorType, typename Scalar = double>
+class HybridNonLinearSolver {
+ public:
+  typedef DenseIndex Index;
+
+  HybridNonLinearSolver(FunctorType &_functor) : functor(_functor) {
+    nfev = njev = iter = 0;
+    fnorm = 0.;
+    useExternalScaling = false;
+  }
+
+  struct Parameters {
+    Parameters()
+        : factor(Scalar(100.)),
+          maxfev(1000),
+          xtol(numext::sqrt(NumTraits<Scalar>::epsilon())),
+          nb_of_subdiagonals(-1),
+          nb_of_superdiagonals(-1),
+          epsfcn(Scalar(0.)) {}
+    Scalar factor;
+    Index maxfev;  // maximum number of function evaluations
+    Scalar xtol;
+    Index nb_of_subdiagonals;
+    Index nb_of_superdiagonals;
+    Scalar epsfcn;
+  };
+  typedef Matrix<Scalar, Dynamic, 1> FVectorType;
+  typedef Matrix<Scalar, Dynamic, Dynamic> JacobianType;
+  /* TODO: if eigen provides a triangular storage, use it here */
+  typedef Matrix<Scalar, Dynamic, Dynamic> UpperTriangularType;
+
+  HybridNonLinearSolverSpace::Status hybrj1(FVectorType &x,
+                                            const Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon()));
+
+  HybridNonLinearSolverSpace::Status solveInit(FVectorType &x);
+  HybridNonLinearSolverSpace::Status solveOneStep(FVectorType &x);
+  HybridNonLinearSolverSpace::Status solve(FVectorType &x);
+
+  HybridNonLinearSolverSpace::Status hybrd1(FVectorType &x,
+                                            const Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon()));
+
+  HybridNonLinearSolverSpace::Status solveNumericalDiffInit(FVectorType &x);
+  HybridNonLinearSolverSpace::Status solveNumericalDiffOneStep(FVectorType &x);
+  HybridNonLinearSolverSpace::Status solveNumericalDiff(FVectorType &x);
+
+  void resetParameters(void) { parameters = Parameters(); }
+  Parameters parameters;
+  FVectorType fvec, qtf, diag;
+  JacobianType fjac;
+  UpperTriangularType R;
+  Index nfev;
+  Index njev;
+  Index iter;
+  Scalar fnorm;
+  bool useExternalScaling;
+
+ private:
+  FunctorType &functor;
+  Index n;
+  bool sing;
+  Scalar temp;
+  Scalar delta;
+  bool jeval;
+  Index ncsuc;
+  Scalar ratio;
+  Scalar pnorm, xnorm, fnorm1;
+  Index nslow1, nslow2;
+  Index ncfail;
+  Scalar actred, prered;
+  FVectorType wa1, wa2, wa3, wa4;
+
+  HybridNonLinearSolver &operator=(const HybridNonLinearSolver &) = delete;
+};
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::hybrj1(FVectorType &x,
+                                                                                      const Scalar tol) {
+  n = x.size();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || tol < 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
+
+  resetParameters();
+  parameters.maxfev = 100 * (n + 1);
+  parameters.xtol = tol;
+  diag.setConstant(n, 1.);
+  useExternalScaling = true;
+  return solve(x);
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveInit(FVectorType &x) {
+  n = x.size();
+
+  wa1.resize(n);
+  wa2.resize(n);
+  wa3.resize(n);
+  wa4.resize(n);
+  fvec.resize(n);
+  qtf.resize(n);
+  fjac.resize(n, n);
+  if (!useExternalScaling) diag.resize(n);
+  eigen_assert((!useExternalScaling || diag.size() == n) &&
+               "When useExternalScaling is set, the caller must provide a valid 'diag'");
+
+  /* Function Body */
+  nfev = 0;
+  njev = 0;
+
+  /*     check the input parameters for errors. */
+  if (n <= 0 || parameters.xtol < 0. || parameters.maxfev <= 0 || parameters.factor <= 0.)
+    return HybridNonLinearSolverSpace::ImproperInputParameters;
+  if (useExternalScaling)
+    for (Index j = 0; j < n; ++j)
+      if (diag[j] <= 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
+
+  /*     evaluate the function at the starting point */
+  /*     and calculate its norm. */
+  nfev = 1;
+  if (functor(x, fvec) < 0) return HybridNonLinearSolverSpace::UserAsked;
+  fnorm = fvec.stableNorm();
+
+  /*     initialize iteration counter and monitors. */
+  iter = 1;
+  ncsuc = 0;
+  ncfail = 0;
+  nslow1 = 0;
+  nslow2 = 0;
+
+  return HybridNonLinearSolverSpace::Running;
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveOneStep(FVectorType &x) {
+  using std::abs;
+
+  eigen_assert(x.size() == n);  // check the caller is not cheating us
+
+  Index j;
+  std::vector<JacobiRotation<Scalar> > v_givens(n), w_givens(n);
+
+  jeval = true;
+
+  /* calculate the jacobian matrix. */
+  if (functor.df(x, fjac) < 0) return HybridNonLinearSolverSpace::UserAsked;
+  ++njev;
+
+  wa2 = fjac.colwise().blueNorm();
+
+  /* on the first iteration and if external scaling is not used, scale according */
+  /* to the norms of the columns of the initial jacobian. */
+  if (iter == 1) {
+    if (!useExternalScaling)
+      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
+
+    /* on the first iteration, calculate the norm of the scaled x */
+    /* and initialize the step bound delta. */
+    xnorm = diag.cwiseProduct(x).stableNorm();
+    delta = parameters.factor * xnorm;
+    if (delta == 0.) delta = parameters.factor;
+  }
+
+  /* compute the qr factorization of the jacobian. */
+  HouseholderQR<JacobianType> qrfac(fjac);  // no pivoting:
+
+  /* copy the triangular factor of the qr factorization into r. */
+  R = qrfac.matrixQR();
+
+  /* accumulate the orthogonal factor in fjac. */
+  fjac = qrfac.householderQ();
+
+  /* form (q transpose)*fvec and store in qtf. */
+  qtf.noalias() = fjac.transpose() * fvec;
+
+  /* rescale if necessary. */
+  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
+
+  while (true) {
+    /* determine the direction p. */
+    internal::dogleg<Scalar>(R, diag, qtf, delta, wa1);
+
+    /* store the direction p and x + p. calculate the norm of p. */
+    wa1 = -wa1;
+    wa2 = x + wa1;
+    pnorm = diag.cwiseProduct(wa1).stableNorm();
+
+    /* on the first iteration, adjust the initial step bound. */
+    if (iter == 1) delta = (std::min)(delta, pnorm);
+
+    /* evaluate the function at x + p and calculate its norm. */
+    if (functor(wa2, wa4) < 0) return HybridNonLinearSolverSpace::UserAsked;
+    ++nfev;
+    fnorm1 = wa4.stableNorm();
+
+    /* compute the scaled actual reduction. */
+    actred = -1.;
+    if (fnorm1 < fnorm) /* Computing 2nd power */
+      actred = 1. - numext::abs2(fnorm1 / fnorm);
+
+    /* compute the scaled predicted reduction. */
+    wa3.noalias() = R.template triangularView<Upper>() * wa1 + qtf;
+    temp = wa3.stableNorm();
+    prered = 0.;
+    if (temp < fnorm) /* Computing 2nd power */
+      prered = 1. - numext::abs2(temp / fnorm);
+
+    /* compute the ratio of the actual to the predicted reduction. */
+    ratio = 0.;
+    if (prered > 0.) ratio = actred / prered;
+
+    /* update the step bound. */
+    if (ratio < Scalar(.1)) {
+      ncsuc = 0;
+      ++ncfail;
+      delta = Scalar(.5) * delta;
+    } else {
+      ncfail = 0;
+      ++ncsuc;
+      if (ratio >= Scalar(.5) || ncsuc > 1) delta = (std::max)(delta, pnorm / Scalar(.5));
+      if (abs(ratio - 1.) <= Scalar(.1)) {
+        delta = pnorm / Scalar(.5);
+      }
+    }
+
+    /* test for successful iteration. */
+    if (ratio >= Scalar(1e-4)) {
+      /* successful iteration. update x, fvec, and their norms. */
+      x = wa2;
+      wa2 = diag.cwiseProduct(x);
+      fvec = wa4;
+      xnorm = wa2.stableNorm();
+      fnorm = fnorm1;
+      ++iter;
+    }
+
+    /* determine the progress of the iteration. */
+    ++nslow1;
+    if (actred >= Scalar(.001)) nslow1 = 0;
+    if (jeval) ++nslow2;
+    if (actred >= Scalar(.1)) nslow2 = 0;
+
+    /* test for convergence. */
+    if (delta <= parameters.xtol * xnorm || fnorm == 0.) return HybridNonLinearSolverSpace::RelativeErrorTooSmall;
+
+    /* tests for termination and stringent tolerances. */
+    if (nfev >= parameters.maxfev) return HybridNonLinearSolverSpace::TooManyFunctionEvaluation;
+    if (Scalar(.1) * (std::max)(Scalar(.1) * delta, pnorm) <= NumTraits<Scalar>::epsilon() * xnorm)
+      return HybridNonLinearSolverSpace::TolTooSmall;
+    if (nslow2 == 5) return HybridNonLinearSolverSpace::NotMakingProgressJacobian;
+    if (nslow1 == 10) return HybridNonLinearSolverSpace::NotMakingProgressIterations;
+
+    /* criterion for recalculating jacobian. */
+    if (ncfail == 2) break;  // leave inner loop and go for the next outer loop iteration
+
+    /* calculate the rank one modification to the jacobian */
+    /* and update qtf if necessary. */
+    wa1 = diag.cwiseProduct(diag.cwiseProduct(wa1) / pnorm);
+    wa2.noalias() = fjac.transpose() * wa4;
+    if (ratio >= Scalar(1e-4)) qtf = wa2;
+    wa2 = (wa2 - wa3) / pnorm;
+
+    /* compute the qr factorization of the updated jacobian. */
+    internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
+    internal::r1mpyq<Scalar>(fjac, v_givens, w_givens);
+    Transpose<FVectorType> qtf_row = qtf.transpose();
+    internal::r1mpyq<Scalar>(qtf_row, v_givens, w_givens);
+
+    jeval = false;
+  }
+  return HybridNonLinearSolverSpace::Running;
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solve(FVectorType &x) {
+  HybridNonLinearSolverSpace::Status status = solveInit(x);
+  if (status == HybridNonLinearSolverSpace::ImproperInputParameters) return status;
+  while (status == HybridNonLinearSolverSpace::Running) status = solveOneStep(x);
+  return status;
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::hybrd1(FVectorType &x,
+                                                                                      const Scalar tol) {
+  n = x.size();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || tol < 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
+
+  resetParameters();
+  parameters.maxfev = 200 * (n + 1);
+  parameters.xtol = tol;
+
+  diag.setConstant(n, 1.);
+  useExternalScaling = true;
+  return solveNumericalDiff(x);
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveNumericalDiffInit(FVectorType &x) {
+  n = x.size();
+
+  if (parameters.nb_of_subdiagonals < 0) parameters.nb_of_subdiagonals = n - 1;
+  if (parameters.nb_of_superdiagonals < 0) parameters.nb_of_superdiagonals = n - 1;
+
+  wa1.resize(n);
+  wa2.resize(n);
+  wa3.resize(n);
+  wa4.resize(n);
+  qtf.resize(n);
+  fjac.resize(n, n);
+  fvec.resize(n);
+  if (!useExternalScaling) diag.resize(n);
+  eigen_assert((!useExternalScaling || diag.size() == n) &&
+               "When useExternalScaling is set, the caller must provide a valid 'diag'");
+
+  /* Function Body */
+  nfev = 0;
+  njev = 0;
+
+  /*     check the input parameters for errors. */
+  if (n <= 0 || parameters.xtol < 0. || parameters.maxfev <= 0 || parameters.nb_of_subdiagonals < 0 ||
+      parameters.nb_of_superdiagonals < 0 || parameters.factor <= 0.)
+    return HybridNonLinearSolverSpace::ImproperInputParameters;
+  if (useExternalScaling)
+    for (Index j = 0; j < n; ++j)
+      if (diag[j] <= 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
+
+  /*     evaluate the function at the starting point */
+  /*     and calculate its norm. */
+  nfev = 1;
+  if (functor(x, fvec) < 0) return HybridNonLinearSolverSpace::UserAsked;
+  fnorm = fvec.stableNorm();
+
+  /*     initialize iteration counter and monitors. */
+  iter = 1;
+  ncsuc = 0;
+  ncfail = 0;
+  nslow1 = 0;
+  nslow2 = 0;
+
+  return HybridNonLinearSolverSpace::Running;
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveNumericalDiffOneStep(
+    FVectorType &x) {
+  using std::abs;
+  using std::sqrt;
+
+  eigen_assert(x.size() == n);  // check the caller is not cheating us
+
+  Index j;
+  std::vector<JacobiRotation<Scalar> > v_givens(n), w_givens(n);
+
+  jeval = true;
+  if (parameters.nb_of_subdiagonals < 0) parameters.nb_of_subdiagonals = n - 1;
+  if (parameters.nb_of_superdiagonals < 0) parameters.nb_of_superdiagonals = n - 1;
+
+  /* calculate the jacobian matrix. */
+  if (internal::fdjac1(functor, x, fvec, fjac, parameters.nb_of_subdiagonals, parameters.nb_of_superdiagonals,
+                       parameters.epsfcn) < 0)
+    return HybridNonLinearSolverSpace::UserAsked;
+  nfev += (std::min)(parameters.nb_of_subdiagonals + parameters.nb_of_superdiagonals + 1, n);
+
+  wa2 = fjac.colwise().blueNorm();
+
+  /* on the first iteration and if external scaling is not used, scale according */
+  /* to the norms of the columns of the initial jacobian. */
+  if (iter == 1) {
+    if (!useExternalScaling)
+      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
+
+    /* on the first iteration, calculate the norm of the scaled x */
+    /* and initialize the step bound delta. */
+    xnorm = diag.cwiseProduct(x).stableNorm();
+    delta = parameters.factor * xnorm;
+    if (delta == 0.) delta = parameters.factor;
+  }
+
+  /* compute the qr factorization of the jacobian. */
+  HouseholderQR<JacobianType> qrfac(fjac);  // no pivoting:
+
+  /* copy the triangular factor of the qr factorization into r. */
+  R = qrfac.matrixQR();
+
+  /* accumulate the orthogonal factor in fjac. */
+  fjac = qrfac.householderQ();
+
+  /* form (q transpose)*fvec and store in qtf. */
+  qtf.noalias() = fjac.transpose() * fvec;
+
+  /* rescale if necessary. */
+  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
+
+  while (true) {
+    /* determine the direction p. */
+    internal::dogleg<Scalar>(R, diag, qtf, delta, wa1);
+
+    /* store the direction p and x + p. calculate the norm of p. */
+    wa1 = -wa1;
+    wa2 = x + wa1;
+    pnorm = diag.cwiseProduct(wa1).stableNorm();
+
+    /* on the first iteration, adjust the initial step bound. */
+    if (iter == 1) delta = (std::min)(delta, pnorm);
+
+    /* evaluate the function at x + p and calculate its norm. */
+    if (functor(wa2, wa4) < 0) return HybridNonLinearSolverSpace::UserAsked;
+    ++nfev;
+    fnorm1 = wa4.stableNorm();
+
+    /* compute the scaled actual reduction. */
+    actred = -1.;
+    if (fnorm1 < fnorm) /* Computing 2nd power */
+      actred = 1. - numext::abs2(fnorm1 / fnorm);
+
+    /* compute the scaled predicted reduction. */
+    wa3.noalias() = R.template triangularView<Upper>() * wa1 + qtf;
+    temp = wa3.stableNorm();
+    prered = 0.;
+    if (temp < fnorm) /* Computing 2nd power */
+      prered = 1. - numext::abs2(temp / fnorm);
+
+    /* compute the ratio of the actual to the predicted reduction. */
+    ratio = 0.;
+    if (prered > 0.) ratio = actred / prered;
+
+    /* update the step bound. */
+    if (ratio < Scalar(.1)) {
+      ncsuc = 0;
+      ++ncfail;
+      delta = Scalar(.5) * delta;
+    } else {
+      ncfail = 0;
+      ++ncsuc;
+      if (ratio >= Scalar(.5) || ncsuc > 1) delta = (std::max)(delta, pnorm / Scalar(.5));
+      if (abs(ratio - 1.) <= Scalar(.1)) {
+        delta = pnorm / Scalar(.5);
+      }
+    }
+
+    /* test for successful iteration. */
+    if (ratio >= Scalar(1e-4)) {
+      /* successful iteration. update x, fvec, and their norms. */
+      x = wa2;
+      wa2 = diag.cwiseProduct(x);
+      fvec = wa4;
+      xnorm = wa2.stableNorm();
+      fnorm = fnorm1;
+      ++iter;
+    }
+
+    /* determine the progress of the iteration. */
+    ++nslow1;
+    if (actred >= Scalar(.001)) nslow1 = 0;
+    if (jeval) ++nslow2;
+    if (actred >= Scalar(.1)) nslow2 = 0;
+
+    /* test for convergence. */
+    if (delta <= parameters.xtol * xnorm || fnorm == 0.) return HybridNonLinearSolverSpace::RelativeErrorTooSmall;
+
+    /* tests for termination and stringent tolerances. */
+    if (nfev >= parameters.maxfev) return HybridNonLinearSolverSpace::TooManyFunctionEvaluation;
+    if (Scalar(.1) * (std::max)(Scalar(.1) * delta, pnorm) <= NumTraits<Scalar>::epsilon() * xnorm)
+      return HybridNonLinearSolverSpace::TolTooSmall;
+    if (nslow2 == 5) return HybridNonLinearSolverSpace::NotMakingProgressJacobian;
+    if (nslow1 == 10) return HybridNonLinearSolverSpace::NotMakingProgressIterations;
+
+    /* criterion for recalculating jacobian. */
+    if (ncfail == 2) break;  // leave inner loop and go for the next outer loop iteration
+
+    /* calculate the rank one modification to the jacobian */
+    /* and update qtf if necessary. */
+    wa1 = diag.cwiseProduct(diag.cwiseProduct(wa1) / pnorm);
+    wa2.noalias() = fjac.transpose() * wa4;
+    if (ratio >= Scalar(1e-4)) qtf = wa2;
+    wa2 = (wa2 - wa3) / pnorm;
+
+    /* compute the qr factorization of the updated jacobian. */
+    internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
+    internal::r1mpyq<Scalar>(fjac, v_givens, w_givens);
+    Transpose<FVectorType> qtf_row = qtf.transpose();
+    internal::r1mpyq<Scalar>(qtf_row, v_givens, w_givens);
+
+    jeval = false;
+  }
+  return HybridNonLinearSolverSpace::Running;
+}
+
+template <typename FunctorType, typename Scalar>
+HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveNumericalDiff(FVectorType &x) {
+  HybridNonLinearSolverSpace::Status status = solveNumericalDiffInit(x);
+  if (status == HybridNonLinearSolverSpace::ImproperInputParameters) return status;
+  while (status == HybridNonLinearSolverSpace::Running) status = solveNumericalDiffOneStep(x);
+  return status;
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_HYBRIDNONLINEARSOLVER_H
+
+// vim: ai ts=4 sts=4 et sw=4
diff --git a/contrib/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h b/contrib/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h
new file mode 100644
index 0000000..74d102a
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_MODULE_H
+#error \
+    "Please include contrib/Eigen/NonLinearOptimization instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h b/contrib/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
new file mode 100644
index 0000000..08d1252
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
@@ -0,0 +1,588 @@
+// -*- coding: utf-8
+// vim: set fileencoding=utf-8
+// SPDX-License-Identifier: MPL-2.0
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LEVENBERGMARQUARDT__H
+#define EIGEN_LEVENBERGMARQUARDT__H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace LevenbergMarquardtSpace {
+enum Status {
+  NotStarted = -2,
+  Running = -1,
+  ImproperInputParameters = 0,
+  RelativeReductionTooSmall = 1,
+  RelativeErrorTooSmall = 2,
+  RelativeErrorAndReductionTooSmall = 3,
+  CosinusTooSmall = 4,
+  TooManyFunctionEvaluation = 5,
+  FtolTooSmall = 6,
+  XtolTooSmall = 7,
+  GtolTooSmall = 8,
+  UserAsked = 9
+};
+}
+
+/**
+ * \ingroup NonLinearOptimization_Module
+ * \brief Performs non-linear optimization over a non-linear function,
+ * using a variant of the Levenberg-Marquardt algorithm.
+ *
+ * Check Wikipedia for more information.
+ * http://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm
+ */
+template <typename FunctorType, typename Scalar = double>
+class LevenbergMarquardt {
+  static Scalar sqrt_epsilon() {
+    using std::sqrt;
+    return sqrt(NumTraits<Scalar>::epsilon());
+  }
+
+ public:
+  LevenbergMarquardt(FunctorType &_functor) : functor(_functor) {
+    nfev = njev = iter = 0;
+    fnorm = gnorm = 0.;
+    useExternalScaling = false;
+  }
+
+  typedef DenseIndex Index;
+
+  struct Parameters {
+    Parameters()
+        : factor(Scalar(100.)),
+          maxfev(400),
+          ftol(sqrt_epsilon()),
+          xtol(sqrt_epsilon()),
+          gtol(Scalar(0.)),
+          epsfcn(Scalar(0.)) {}
+    Scalar factor;
+    Index maxfev;  // maximum number of function evaluation
+    Scalar ftol;
+    Scalar xtol;
+    Scalar gtol;
+    Scalar epsfcn;
+  };
+
+  typedef Matrix<Scalar, Dynamic, 1> FVectorType;
+  typedef Matrix<Scalar, Dynamic, Dynamic> JacobianType;
+
+  LevenbergMarquardtSpace::Status lmder1(FVectorType &x, const Scalar tol = sqrt_epsilon());
+
+  LevenbergMarquardtSpace::Status minimize(FVectorType &x);
+  LevenbergMarquardtSpace::Status minimizeInit(FVectorType &x);
+  LevenbergMarquardtSpace::Status minimizeOneStep(FVectorType &x);
+
+  static LevenbergMarquardtSpace::Status lmdif1(FunctorType &functor, FVectorType &x, Index *nfev,
+                                                const Scalar tol = sqrt_epsilon());
+
+  LevenbergMarquardtSpace::Status lmstr1(FVectorType &x, const Scalar tol = sqrt_epsilon());
+
+  LevenbergMarquardtSpace::Status minimizeOptimumStorage(FVectorType &x);
+  LevenbergMarquardtSpace::Status minimizeOptimumStorageInit(FVectorType &x);
+  LevenbergMarquardtSpace::Status minimizeOptimumStorageOneStep(FVectorType &x);
+
+  void resetParameters(void) { parameters = Parameters(); }
+
+  Parameters parameters;
+  FVectorType fvec, qtf, diag;
+  JacobianType fjac;
+  PermutationMatrix<Dynamic, Dynamic> permutation;
+  Index nfev;
+  Index njev;
+  Index iter;
+  Scalar fnorm, gnorm;
+  bool useExternalScaling;
+
+  Scalar lm_param(void) const { return par; }
+
+ private:
+  FunctorType &functor;
+  Index n;
+  Index m;
+  FVectorType wa1, wa2, wa3, wa4;
+
+  Scalar par, sum;
+  Scalar temp, temp1, temp2;
+  Scalar delta;
+  Scalar ratio;
+  Scalar pnorm, xnorm, fnorm1, actred, dirder, prered;
+
+  LevenbergMarquardt &operator=(const LevenbergMarquardt &) = delete;
+};
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::lmder1(FVectorType &x, const Scalar tol) {
+  n = x.size();
+  m = functor.values();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  resetParameters();
+  parameters.ftol = tol;
+  parameters.xtol = tol;
+  parameters.maxfev = 100 * (n + 1);
+
+  return minimize(x);
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimize(FVectorType &x) {
+  LevenbergMarquardtSpace::Status status = minimizeInit(x);
+  if (status == LevenbergMarquardtSpace::ImproperInputParameters) return status;
+  do {
+    status = minimizeOneStep(x);
+  } while (status == LevenbergMarquardtSpace::Running);
+  return status;
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeInit(FVectorType &x) {
+  n = x.size();
+  m = functor.values();
+
+  wa1.resize(n);
+  wa2.resize(n);
+  wa3.resize(n);
+  wa4.resize(m);
+  fvec.resize(m);
+  fjac.resize(m, n);
+  if (!useExternalScaling) diag.resize(n);
+  eigen_assert((!useExternalScaling || diag.size() == n) &&
+               "When useExternalScaling is set, the caller must provide a valid 'diag'");
+  qtf.resize(n);
+
+  /* Function Body */
+  nfev = 0;
+  njev = 0;
+
+  /*     check the input parameters for errors. */
+  if (n <= 0 || m < n || parameters.ftol < 0. || parameters.xtol < 0. || parameters.gtol < 0. ||
+      parameters.maxfev <= 0 || parameters.factor <= 0.)
+    return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  if (useExternalScaling)
+    for (Index j = 0; j < n; ++j)
+      if (diag[j] <= 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  /*     evaluate the function at the starting point */
+  /*     and calculate its norm. */
+  nfev = 1;
+  if (functor(x, fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
+  fnorm = fvec.stableNorm();
+
+  /*     initialize levenberg-marquardt parameter and iteration counter. */
+  par = 0.;
+  iter = 1;
+
+  return LevenbergMarquardtSpace::NotStarted;
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOneStep(FVectorType &x) {
+  using std::abs;
+  using std::sqrt;
+
+  eigen_assert(x.size() == n);  // check the caller is not cheating us
+
+  /* calculate the jacobian matrix. */
+  Index df_ret = functor.df(x, fjac);
+  if (df_ret < 0) return LevenbergMarquardtSpace::UserAsked;
+  if (df_ret > 0)
+    // numerical diff, we evaluated the function df_ret times
+    nfev += df_ret;
+  else
+    njev++;
+
+  /* compute the qr factorization of the jacobian. */
+  wa2 = fjac.colwise().blueNorm();
+  ColPivHouseholderQR<JacobianType> qrfac(fjac);
+  fjac = qrfac.matrixQR();
+  permutation = qrfac.colsPermutation();
+
+  /* on the first iteration and if external scaling is not used, scale according */
+  /* to the norms of the columns of the initial jacobian. */
+  if (iter == 1) {
+    if (!useExternalScaling)
+      for (Index j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
+
+    /* on the first iteration, calculate the norm of the scaled x */
+    /* and initialize the step bound delta. */
+    xnorm = diag.cwiseProduct(x).stableNorm();
+    delta = parameters.factor * xnorm;
+    if (delta == 0.) delta = parameters.factor;
+  }
+
+  /* form (q transpose)*fvec and store the first n components in */
+  /* qtf. */
+  wa4 = fvec;
+  wa4.applyOnTheLeft(qrfac.householderQ().adjoint());
+  qtf = wa4.head(n);
+
+  /* compute the norm of the scaled gradient. */
+  gnorm = 0.;
+  if (fnorm != 0.)
+    for (Index j = 0; j < n; ++j)
+      if (wa2[permutation.indices()[j]] != 0.)
+        gnorm = (std::max)(gnorm,
+                           abs(fjac.col(j).head(j + 1).dot(qtf.head(j + 1) / fnorm) / wa2[permutation.indices()[j]]));
+
+  /* test for convergence of the gradient norm. */
+  if (gnorm <= parameters.gtol) return LevenbergMarquardtSpace::CosinusTooSmall;
+
+  /* rescale if necessary. */
+  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
+
+  do {
+    /* determine the levenberg-marquardt parameter. */
+    internal::lmpar2<Scalar>(qrfac, diag, qtf, delta, par, wa1);
+
+    /* store the direction p and x + p. calculate the norm of p. */
+    wa1 = -wa1;
+    wa2 = x + wa1;
+    pnorm = diag.cwiseProduct(wa1).stableNorm();
+
+    /* on the first iteration, adjust the initial step bound. */
+    if (iter == 1) delta = (std::min)(delta, pnorm);
+
+    /* evaluate the function at x + p and calculate its norm. */
+    if (functor(wa2, wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
+    ++nfev;
+    fnorm1 = wa4.stableNorm();
+
+    /* compute the scaled actual reduction. */
+    actred = -1.;
+    if (Scalar(.1) * fnorm1 < fnorm) actred = 1. - numext::abs2(fnorm1 / fnorm);
+
+    /* compute the scaled predicted reduction and */
+    /* the scaled directional derivative. */
+    wa3.noalias() = fjac.template triangularView<Upper>() * (qrfac.colsPermutation().inverse() * wa1);
+    temp1 = numext::abs2(wa3.stableNorm() / fnorm);
+    temp2 = numext::abs2(sqrt(par) * pnorm / fnorm);
+    prered = temp1 + temp2 / Scalar(.5);
+    dirder = -(temp1 + temp2);
+
+    /* compute the ratio of the actual to the predicted */
+    /* reduction. */
+    ratio = 0.;
+    if (prered != 0.) ratio = actred / prered;
+
+    /* update the step bound. */
+    if (ratio <= Scalar(.25)) {
+      if (actred >= 0.) temp = Scalar(.5);
+      if (actred < 0.) temp = Scalar(.5) * dirder / (dirder + Scalar(.5) * actred);
+      if (Scalar(.1) * fnorm1 >= fnorm || temp < Scalar(.1)) temp = Scalar(.1);
+      /* Computing MIN */
+      delta = temp * (std::min)(delta, pnorm / Scalar(.1));
+      par /= temp;
+    } else if (!(par != 0. && ratio < Scalar(.75))) {
+      delta = pnorm / Scalar(.5);
+      par = Scalar(.5) * par;
+    }
+
+    /* test for successful iteration. */
+    if (ratio >= Scalar(1e-4)) {
+      /* successful iteration. update x, fvec, and their norms. */
+      x = wa2;
+      wa2 = diag.cwiseProduct(x);
+      fvec = wa4;
+      xnorm = wa2.stableNorm();
+      fnorm = fnorm1;
+      ++iter;
+    }
+
+    /* tests for convergence. */
+    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. &&
+        delta <= parameters.xtol * xnorm)
+      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
+    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
+      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
+    if (delta <= parameters.xtol * xnorm) return LevenbergMarquardtSpace::RelativeErrorTooSmall;
+
+    /* tests for termination and stringent tolerances. */
+    if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
+    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
+        Scalar(.5) * ratio <= 1.)
+      return LevenbergMarquardtSpace::FtolTooSmall;
+    if (delta <= NumTraits<Scalar>::epsilon() * xnorm) return LevenbergMarquardtSpace::XtolTooSmall;
+    if (gnorm <= NumTraits<Scalar>::epsilon()) return LevenbergMarquardtSpace::GtolTooSmall;
+
+  } while (ratio < Scalar(1e-4));
+
+  return LevenbergMarquardtSpace::Running;
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::lmstr1(FVectorType &x, const Scalar tol) {
+  n = x.size();
+  m = functor.values();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  resetParameters();
+  parameters.ftol = tol;
+  parameters.xtol = tol;
+  parameters.maxfev = 100 * (n + 1);
+
+  return minimizeOptimumStorage(x);
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOptimumStorageInit(FVectorType &x) {
+  n = x.size();
+  m = functor.values();
+
+  wa1.resize(n);
+  wa2.resize(n);
+  wa3.resize(n);
+  wa4.resize(m);
+  fvec.resize(m);
+  // Only R is stored in fjac. Q is only used to compute 'qtf', which is
+  // Q.transpose()*rhs. qtf will be updated using givens rotation,
+  // instead of storing them in Q.
+  // The purpose is to only use a nxn matrix, instead of mxn here, so
+  // that we can handle cases where m>>n :
+  fjac.resize(n, n);
+  if (!useExternalScaling) diag.resize(n);
+  eigen_assert((!useExternalScaling || diag.size() == n) &&
+               "When useExternalScaling is set, the caller must provide a valid 'diag'");
+  qtf.resize(n);
+
+  /* Function Body */
+  nfev = 0;
+  njev = 0;
+
+  /*     check the input parameters for errors. */
+  if (n <= 0 || m < n || parameters.ftol < 0. || parameters.xtol < 0. || parameters.gtol < 0. ||
+      parameters.maxfev <= 0 || parameters.factor <= 0.)
+    return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  if (useExternalScaling)
+    for (Index j = 0; j < n; ++j)
+      if (diag[j] <= 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  /*     evaluate the function at the starting point */
+  /*     and calculate its norm. */
+  nfev = 1;
+  if (functor(x, fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
+  fnorm = fvec.stableNorm();
+
+  /*     initialize levenberg-marquardt parameter and iteration counter. */
+  par = 0.;
+  iter = 1;
+
+  return LevenbergMarquardtSpace::NotStarted;
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOptimumStorageOneStep(FVectorType &x) {
+  using std::abs;
+  using std::sqrt;
+
+  eigen_assert(x.size() == n);  // check the caller is not cheating us
+
+  Index i, j;
+  bool sing;
+
+  /* compute the qr factorization of the jacobian matrix */
+  /* calculated one row at a time, while simultaneously */
+  /* forming (q transpose)*fvec and storing the first */
+  /* n components in qtf. */
+  qtf.fill(0.);
+  fjac.fill(0.);
+  Index rownb = 2;
+  for (i = 0; i < m; ++i) {
+    if (functor.df(x, wa3, rownb) < 0) return LevenbergMarquardtSpace::UserAsked;
+    internal::rwupdt<Scalar>(fjac, wa3, qtf, fvec[i]);
+    ++rownb;
+  }
+  ++njev;
+
+  /* if the jacobian is rank deficient, call qrfac to */
+  /* reorder its columns and update the components of qtf. */
+  sing = false;
+  for (j = 0; j < n; ++j) {
+    if (fjac(j, j) == 0.) sing = true;
+    wa2[j] = fjac.col(j).head(j).stableNorm();
+  }
+  permutation.setIdentity(n);
+  if (sing) {
+    wa2 = fjac.colwise().blueNorm();
+    // TODO: We have no unit test covering this code path, do not modify
+    // until it is carefully tested
+    ColPivHouseholderQR<JacobianType> qrfac(fjac);
+    fjac = qrfac.matrixQR();
+    wa1 = fjac.diagonal();
+    fjac.diagonal() = qrfac.hCoeffs();
+    permutation = qrfac.colsPermutation();
+    // TODO: Avoid this:
+    for (Index ii = 0; ii < fjac.cols(); ii++)
+      fjac.col(ii).segment(ii + 1, fjac.rows() - ii - 1) *= fjac(ii, ii);  // rescale vectors
+
+    for (j = 0; j < n; ++j) {
+      if (fjac(j, j) != 0.) {
+        sum = 0.;
+        for (i = j; i < n; ++i) sum += fjac(i, j) * qtf[i];
+        temp = -sum / fjac(j, j);
+        for (i = j; i < n; ++i) qtf[i] += fjac(i, j) * temp;
+      }
+      fjac(j, j) = wa1[j];
+    }
+  }
+
+  /* on the first iteration and if external scaling is not used, scale according */
+  /* to the norms of the columns of the initial jacobian. */
+  if (iter == 1) {
+    if (!useExternalScaling)
+      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
+
+    /* on the first iteration, calculate the norm of the scaled x */
+    /* and initialize the step bound delta. */
+    xnorm = diag.cwiseProduct(x).stableNorm();
+    delta = parameters.factor * xnorm;
+    if (delta == 0.) delta = parameters.factor;
+  }
+
+  /* compute the norm of the scaled gradient. */
+  gnorm = 0.;
+  if (fnorm != 0.)
+    for (j = 0; j < n; ++j)
+      if (wa2[permutation.indices()[j]] != 0.)
+        gnorm = (std::max)(gnorm,
+                           abs(fjac.col(j).head(j + 1).dot(qtf.head(j + 1) / fnorm) / wa2[permutation.indices()[j]]));
+
+  /* test for convergence of the gradient norm. */
+  if (gnorm <= parameters.gtol) return LevenbergMarquardtSpace::CosinusTooSmall;
+
+  /* rescale if necessary. */
+  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
+
+  do {
+    /* determine the levenberg-marquardt parameter. */
+    internal::lmpar<Scalar>(fjac, permutation.indices(), diag, qtf, delta, par, wa1);
+
+    /* store the direction p and x + p. calculate the norm of p. */
+    wa1 = -wa1;
+    wa2 = x + wa1;
+    pnorm = diag.cwiseProduct(wa1).stableNorm();
+
+    /* on the first iteration, adjust the initial step bound. */
+    if (iter == 1) delta = (std::min)(delta, pnorm);
+
+    /* evaluate the function at x + p and calculate its norm. */
+    if (functor(wa2, wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
+    ++nfev;
+    fnorm1 = wa4.stableNorm();
+
+    /* compute the scaled actual reduction. */
+    actred = -1.;
+    if (Scalar(.1) * fnorm1 < fnorm) actred = 1. - numext::abs2(fnorm1 / fnorm);
+
+    /* compute the scaled predicted reduction and */
+    /* the scaled directional derivative. */
+    wa3.noalias() = fjac.topLeftCorner(n, n).template triangularView<Upper>() * (permutation.inverse() * wa1);
+    temp1 = numext::abs2(wa3.stableNorm() / fnorm);
+    temp2 = numext::abs2(sqrt(par) * pnorm / fnorm);
+    prered = temp1 + temp2 / Scalar(.5);
+    dirder = -(temp1 + temp2);
+
+    /* compute the ratio of the actual to the predicted */
+    /* reduction. */
+    ratio = 0.;
+    if (prered != 0.) ratio = actred / prered;
+
+    /* update the step bound. */
+    if (ratio <= Scalar(.25)) {
+      if (actred >= 0.) temp = Scalar(.5);
+      if (actred < 0.) temp = Scalar(.5) * dirder / (dirder + Scalar(.5) * actred);
+      if (Scalar(.1) * fnorm1 >= fnorm || temp < Scalar(.1)) temp = Scalar(.1);
+      /* Computing MIN */
+      delta = temp * (std::min)(delta, pnorm / Scalar(.1));
+      par /= temp;
+    } else if (!(par != 0. && ratio < Scalar(.75))) {
+      delta = pnorm / Scalar(.5);
+      par = Scalar(.5) * par;
+    }
+
+    /* test for successful iteration. */
+    if (ratio >= Scalar(1e-4)) {
+      /* successful iteration. update x, fvec, and their norms. */
+      x = wa2;
+      wa2 = diag.cwiseProduct(x);
+      fvec = wa4;
+      xnorm = wa2.stableNorm();
+      fnorm = fnorm1;
+      ++iter;
+    }
+
+    /* tests for convergence. */
+    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. &&
+        delta <= parameters.xtol * xnorm)
+      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
+    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
+      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
+    if (delta <= parameters.xtol * xnorm) return LevenbergMarquardtSpace::RelativeErrorTooSmall;
+
+    /* tests for termination and stringent tolerances. */
+    if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
+    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
+        Scalar(.5) * ratio <= 1.)
+      return LevenbergMarquardtSpace::FtolTooSmall;
+    if (delta <= NumTraits<Scalar>::epsilon() * xnorm) return LevenbergMarquardtSpace::XtolTooSmall;
+    if (gnorm <= NumTraits<Scalar>::epsilon()) return LevenbergMarquardtSpace::GtolTooSmall;
+
+  } while (ratio < Scalar(1e-4));
+
+  return LevenbergMarquardtSpace::Running;
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOptimumStorage(FVectorType &x) {
+  LevenbergMarquardtSpace::Status status = minimizeOptimumStorageInit(x);
+  if (status == LevenbergMarquardtSpace::ImproperInputParameters) return status;
+  do {
+    status = minimizeOptimumStorageOneStep(x);
+  } while (status == LevenbergMarquardtSpace::Running);
+  return status;
+}
+
+template <typename FunctorType, typename Scalar>
+LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::lmdif1(FunctorType &functor, FVectorType &x,
+                                                                                Index *nfev, const Scalar tol) {
+  Index n = x.size();
+  Index m = functor.values();
+
+  /* check the input parameters for errors. */
+  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
+
+  NumericalDiff<FunctorType> numDiff(functor);
+  // embedded LevenbergMarquardt
+  LevenbergMarquardt<NumericalDiff<FunctorType>, Scalar> lm(numDiff);
+  lm.parameters.ftol = tol;
+  lm.parameters.xtol = tol;
+  lm.parameters.maxfev = 200 * (n + 1);
+
+  LevenbergMarquardtSpace::Status info = LevenbergMarquardtSpace::Status(lm.minimize(x));
+  if (nfev) *nfev = lm.nfev;
+  return info;
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_LEVENBERGMARQUARDT__H
+
+// vim: ai ts=4 sts=4 et sw=4
diff --git a/contrib/Eigen/src/NonLinearOptimization/chkder.h b/contrib/Eigen/src/NonLinearOptimization/chkder.h
new file mode 100644
index 0000000..7c17328
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/chkder.h
@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_CHKDER_H
+#define EIGEN_NONLINEAROPTIMIZATION_CHKDER_H
+
+#define chkder_log10e 0.43429448190325182765
+#define chkder_factor 100.
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void chkder(const Matrix<Scalar, Dynamic, 1> &x, const Matrix<Scalar, Dynamic, 1> &fvec,
+            const Matrix<Scalar, Dynamic, Dynamic> &fjac, Matrix<Scalar, Dynamic, 1> &xp,
+            const Matrix<Scalar, Dynamic, 1> &fvecp, int mode, Matrix<Scalar, Dynamic, 1> &err) {
+  using std::abs;
+  using std::log;
+  using std::sqrt;
+
+  typedef DenseIndex Index;
+
+  const Scalar eps = sqrt(NumTraits<Scalar>::epsilon());
+  const Scalar epsf = chkder_factor * NumTraits<Scalar>::epsilon();
+  const Scalar epslog = chkder_log10e * log(eps);
+  Scalar temp;
+
+  const Index m = fvec.size(), n = x.size();
+
+  if (mode != 2) {
+    /* mode = 1. */
+    xp.resize(n);
+    for (Index j = 0; j < n; ++j) {
+      temp = eps * abs(x[j]);
+      if (temp == 0.) temp = eps;
+      xp[j] = x[j] + temp;
+    }
+  } else {
+    /* mode = 2. */
+    err.setZero(m);
+    for (Index j = 0; j < n; ++j) {
+      temp = abs(x[j]);
+      if (temp == 0.) temp = 1.;
+      err += temp * fjac.col(j);
+    }
+    for (Index i = 0; i < m; ++i) {
+      temp = 1.;
+      if (fvec[i] != 0. && fvecp[i] != 0. && abs(fvecp[i] - fvec[i]) >= epsf * abs(fvec[i]))
+        temp = eps * abs((fvecp[i] - fvec[i]) / eps - err[i]) / (abs(fvec[i]) + abs(fvecp[i]));
+      err[i] = 1.;
+      if (temp > NumTraits<Scalar>::epsilon() && temp < eps) err[i] = (chkder_log10e * log(temp) - epslog) / epslog;
+      if (temp >= eps) err[i] = 0.;
+    }
+  }
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#undef chkder_log10e
+#undef chkder_factor
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_CHKDER_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/covar.h b/contrib/Eigen/src/NonLinearOptimization/covar.h
new file mode 100644
index 0000000..808893d
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/covar.h
@@ -0,0 +1,74 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_COVAR_H
+#define EIGEN_NONLINEAROPTIMIZATION_COVAR_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void covar(Matrix<Scalar, Dynamic, Dynamic> &r, const VectorXi &ipvt,
+           Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon())) {
+  using std::abs;
+  typedef DenseIndex Index;
+
+  /* Local variables */
+  Index i, j, k, l, ii, jj;
+  bool sing;
+  Scalar temp;
+
+  /* Function Body */
+  const Index n = r.cols();
+  const Scalar tolr = tol * abs(r(0, 0));
+  Matrix<Scalar, Dynamic, 1> wa(n);
+  eigen_assert(ipvt.size() == n);
+
+  /* form the inverse of r in the full upper triangle of r. */
+  l = -1;
+  for (k = 0; k < n; ++k)
+    if (abs(r(k, k)) > tolr) {
+      r(k, k) = 1. / r(k, k);
+      for (j = 0; j <= k - 1; ++j) {
+        temp = r(k, k) * r(j, k);
+        r(j, k) = 0.;
+        r.col(k).head(j + 1) -= r.col(j).head(j + 1) * temp;
+      }
+      l = k;
+    }
+
+  /* form the full upper triangle of the inverse of (r transpose)*r */
+  /* in the full upper triangle of r. */
+  for (k = 0; k <= l; ++k) {
+    for (j = 0; j <= k - 1; ++j) r.col(j).head(j + 1) += r.col(k).head(j + 1) * r(j, k);
+    r.col(k).head(k + 1) *= r(k, k);
+  }
+
+  /* form the full lower triangle of the covariance matrix */
+  /* in the strict lower triangle of r and in wa. */
+  for (j = 0; j < n; ++j) {
+    jj = ipvt[j];
+    sing = j > l;
+    for (i = 0; i <= j; ++i) {
+      if (sing) r(i, j) = 0.;
+      ii = ipvt[i];
+      if (ii > jj) r(ii, jj) = r(i, j);
+      if (ii < jj) r(jj, ii) = r(i, j);
+    }
+    wa[jj] = r(j, j);
+  }
+
+  /* symmetrize the covariance matrix in r. */
+  r.topLeftCorner(n, n).template triangularView<StrictlyUpper>() = r.topLeftCorner(n, n).transpose();
+  r.diagonal() = wa;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_COVAR_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/dogleg.h b/contrib/Eigen/src/NonLinearOptimization/dogleg.h
new file mode 100644
index 0000000..ed0c472
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/dogleg.h
@@ -0,0 +1,111 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_DOGLEG_H
+#define EIGEN_NONLINEAROPTIMIZATION_DOGLEG_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void dogleg(const Matrix<Scalar, Dynamic, Dynamic> &qrfac, const Matrix<Scalar, Dynamic, 1> &diag,
+            const Matrix<Scalar, Dynamic, 1> &qtb, Scalar delta, Matrix<Scalar, Dynamic, 1> &x) {
+  using std::abs;
+  using std::sqrt;
+
+  typedef DenseIndex Index;
+
+  /* Local variables */
+  Index i, j;
+  Scalar sum, temp, alpha, bnorm;
+  Scalar gnorm, qnorm;
+  Scalar sgnorm;
+
+  /* Function Body */
+  const Scalar epsmch = NumTraits<Scalar>::epsilon();
+  const Index n = qrfac.cols();
+  eigen_assert(n == qtb.size());
+  eigen_assert(n == x.size());
+  eigen_assert(n == diag.size());
+  Matrix<Scalar, Dynamic, 1> wa1(n), wa2(n);
+
+  /* first, calculate the gauss-newton direction. */
+  for (j = n - 1; j >= 0; --j) {
+    temp = qrfac(j, j);
+    if (temp == 0.) {
+      temp = epsmch * qrfac.col(j).head(j + 1).maxCoeff();
+      if (temp == 0.) temp = epsmch;
+    }
+    if (j == n - 1)
+      x[j] = qtb[j] / temp;
+    else
+      x[j] = (qtb[j] - qrfac.row(j).tail(n - j - 1).dot(x.tail(n - j - 1))) / temp;
+  }
+
+  /* test whether the gauss-newton direction is acceptable. */
+  qnorm = diag.cwiseProduct(x).stableNorm();
+  if (qnorm <= delta) return;
+
+  // TODO : this path is not tested by Eigen unit tests
+
+  /* the gauss-newton direction is not acceptable. */
+  /* next, calculate the scaled gradient direction. */
+
+  wa1.fill(0.);
+  for (j = 0; j < n; ++j) {
+    wa1.tail(n - j) += qrfac.row(j).tail(n - j) * qtb[j];
+    wa1[j] /= diag[j];
+  }
+
+  /* calculate the norm of the scaled gradient and test for */
+  /* the special case in which the scaled gradient is zero. */
+  gnorm = wa1.stableNorm();
+  sgnorm = 0.;
+  alpha = delta / qnorm;
+  if (gnorm == 0.) goto algo_end;
+
+  /* calculate the point along the scaled gradient */
+  /* at which the quadratic is minimized. */
+  wa1.array() /= (diag * gnorm).array();
+  // TODO : once unit tests cover this part:
+  // wa2 = qrfac.template triangularView<Upper>() * wa1;
+  for (j = 0; j < n; ++j) {
+    sum = 0.;
+    for (i = j; i < n; ++i) {
+      sum += qrfac(j, i) * wa1[i];
+    }
+    wa2[j] = sum;
+  }
+  temp = wa2.stableNorm();
+  sgnorm = gnorm / temp / temp;
+
+  /* test whether the scaled gradient direction is acceptable. */
+  alpha = 0.;
+  if (sgnorm >= delta) goto algo_end;
+
+  /* the scaled gradient direction is not acceptable. */
+  /* finally, calculate the point along the dogleg */
+  /* at which the quadratic is minimized. */
+  bnorm = qtb.stableNorm();
+  temp = bnorm / gnorm * (bnorm / qnorm) * (sgnorm / delta);
+  temp = temp - delta / qnorm * numext::abs2(sgnorm / delta) +
+         sqrt(numext::abs2(temp - delta / qnorm) +
+              (1. - numext::abs2(delta / qnorm)) * (1. - numext::abs2(sgnorm / delta)));
+  alpha = delta / qnorm * (1. - numext::abs2(sgnorm / delta)) / temp;
+algo_end:
+
+  /* form appropriate convex combination of the gauss-newton */
+  /* direction and the scaled gradient direction. */
+  temp = (1. - alpha) * (std::min)(sgnorm, delta);
+  x = temp * wa1 + alpha * x;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_DOGLEG_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/fdjac1.h b/contrib/Eigen/src/NonLinearOptimization/fdjac1.h
new file mode 100644
index 0000000..b83f9f1
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/fdjac1.h
@@ -0,0 +1,81 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_FDJAC1_H
+#define EIGEN_NONLINEAROPTIMIZATION_FDJAC1_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename FunctorType, typename Scalar>
+DenseIndex fdjac1(const FunctorType &Functor, Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &fvec,
+                  Matrix<Scalar, Dynamic, Dynamic> &fjac, DenseIndex ml, DenseIndex mu, Scalar epsfcn) {
+  using std::abs;
+  using std::sqrt;
+
+  typedef DenseIndex Index;
+
+  /* Local variables */
+  Scalar h;
+  Index j, k;
+  Scalar eps, temp;
+  Index msum;
+  int iflag;
+  Index start, length;
+
+  /* Function Body */
+  const Scalar epsmch = NumTraits<Scalar>::epsilon();
+  const Index n = x.size();
+  eigen_assert(fvec.size() == n);
+  Matrix<Scalar, Dynamic, 1> wa1(n);
+  Matrix<Scalar, Dynamic, 1> wa2(n);
+
+  eps = sqrt((std::max)(epsfcn, epsmch));
+  msum = ml + mu + 1;
+  if (msum >= n) {
+    /* computation of dense approximate jacobian. */
+    for (j = 0; j < n; ++j) {
+      temp = x[j];
+      h = eps * abs(temp);
+      if (h == 0.) h = eps;
+      x[j] = temp + h;
+      iflag = Functor(x, wa1);
+      if (iflag < 0) return iflag;
+      x[j] = temp;
+      fjac.col(j) = (wa1 - fvec) / h;
+    }
+
+  } else {
+    /* computation of banded approximate jacobian. */
+    for (k = 0; k < msum; ++k) {
+      for (j = k; (msum < 0) ? (j > n) : (j < n); j += msum) {
+        wa2[j] = x[j];
+        h = eps * abs(wa2[j]);
+        if (h == 0.) h = eps;
+        x[j] = wa2[j] + h;
+      }
+      iflag = Functor(x, wa1);
+      if (iflag < 0) return iflag;
+      for (j = k; (msum < 0) ? (j > n) : (j < n); j += msum) {
+        x[j] = wa2[j];
+        h = eps * abs(wa2[j]);
+        if (h == 0.) h = eps;
+        fjac.col(j).setZero();
+        start = std::max<Index>(0, j - mu);
+        length = (std::min)(n - 1, j + ml) - start + 1;
+        fjac.col(j).segment(start, length) = (wa1.segment(start, length) - fvec.segment(start, length)) / h;
+      }
+    }
+  }
+  return 0;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_FDJAC1_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/lmpar.h b/contrib/Eigen/src/NonLinearOptimization/lmpar.h
new file mode 100644
index 0000000..3b12dee
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/lmpar.h
@@ -0,0 +1,271 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_LMPAR_H
+#define EIGEN_NONLINEAROPTIMIZATION_LMPAR_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void lmpar(Matrix<Scalar, Dynamic, Dynamic> &r, const VectorXi &ipvt, const Matrix<Scalar, Dynamic, 1> &diag,
+           const Matrix<Scalar, Dynamic, 1> &qtb, Scalar delta, Scalar &par, Matrix<Scalar, Dynamic, 1> &x) {
+  using std::abs;
+  using std::sqrt;
+  typedef DenseIndex Index;
+
+  /* Local variables */
+  Index i, j, l;
+  Scalar fp;
+  Scalar parc, parl;
+  Index iter;
+  Scalar temp, paru;
+  Scalar gnorm;
+  Scalar dxnorm;
+
+  /* Function Body */
+  const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
+  const Index n = r.cols();
+  eigen_assert(n == diag.size());
+  eigen_assert(n == qtb.size());
+  eigen_assert(n == x.size());
+
+  Matrix<Scalar, Dynamic, 1> wa1, wa2;
+
+  /* compute and store in x the gauss-newton direction. if the */
+  /* jacobian is rank-deficient, obtain a least squares solution. */
+  Index nsing = n - 1;
+  wa1 = qtb;
+  for (j = 0; j < n; ++j) {
+    if (r(j, j) == 0. && nsing == n - 1) nsing = j - 1;
+    if (nsing < n - 1) wa1[j] = 0.;
+  }
+  for (j = nsing; j >= 0; --j) {
+    wa1[j] /= r(j, j);
+    temp = wa1[j];
+    for (i = 0; i < j; ++i) wa1[i] -= r(i, j) * temp;
+  }
+
+  for (j = 0; j < n; ++j) x[ipvt[j]] = wa1[j];
+
+  /* initialize the iteration counter. */
+  /* evaluate the function at the origin, and test */
+  /* for acceptance of the gauss-newton direction. */
+  iter = 0;
+  wa2 = diag.cwiseProduct(x);
+  dxnorm = wa2.blueNorm();
+  fp = dxnorm - delta;
+  if (fp <= Scalar(0.1) * delta) {
+    par = 0;
+    return;
+  }
+
+  /* if the jacobian is not rank deficient, the newton */
+  /* step provides a lower bound, parl, for the zero of */
+  /* the function. otherwise set this bound to zero. */
+  parl = 0.;
+  if (nsing >= n - 1) {
+    for (j = 0; j < n; ++j) {
+      l = ipvt[j];
+      wa1[j] = diag[l] * (wa2[l] / dxnorm);
+    }
+    // Triangular solve (forward substitution):
+    for (j = 0; j < n; ++j) {
+      Scalar sum = 0.;
+      for (i = 0; i < j; ++i) sum += r(i, j) * wa1[i];
+      wa1[j] = (wa1[j] - sum) / r(j, j);
+    }
+    temp = wa1.blueNorm();
+    parl = fp / delta / temp / temp;
+  }
+
+  /* calculate an upper bound, paru, for the zero of the function. */
+  for (j = 0; j < n; ++j) wa1[j] = r.col(j).head(j + 1).dot(qtb.head(j + 1)) / diag[ipvt[j]];
+
+  gnorm = wa1.stableNorm();
+  paru = gnorm / delta;
+  if (paru == 0.) paru = dwarf / (std::min)(delta, Scalar(0.1));
+
+  /* if the input par lies outside of the interval (parl,paru), */
+  /* set par to the closer endpoint. */
+  par = (std::max)(par, parl);
+  par = (std::min)(par, paru);
+  if (par == 0.) par = gnorm / dxnorm;
+
+  /* beginning of an iteration. */
+  while (true) {
+    ++iter;
+
+    /* evaluate the function at the current value of par. */
+    if (par == 0.) par = (std::max)(dwarf, Scalar(.001) * paru); /* Computing MAX */
+    wa1 = sqrt(par) * diag;
+
+    Matrix<Scalar, Dynamic, 1> sdiag(n);
+    qrsolv<Scalar>(r, ipvt, wa1, qtb, x, sdiag);
+
+    wa2 = diag.cwiseProduct(x);
+    dxnorm = wa2.blueNorm();
+    temp = fp;
+    fp = dxnorm - delta;
+
+    /* if the function is small enough, accept the current value */
+    /* of par. also test for the exceptional cases where parl */
+    /* is zero or the number of iterations has reached 10. */
+    if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10) break;
+
+    /* compute the newton correction. */
+    for (j = 0; j < n; ++j) {
+      l = ipvt[j];
+      wa1[j] = diag[l] * (wa2[l] / dxnorm);
+    }
+    for (j = 0; j < n; ++j) {
+      wa1[j] /= sdiag[j];
+      temp = wa1[j];
+      for (i = j + 1; i < n; ++i) wa1[i] -= r(i, j) * temp;
+    }
+    temp = wa1.blueNorm();
+    parc = fp / delta / temp / temp;
+
+    /* depending on the sign of the function, update parl or paru. */
+    if (fp > 0.) parl = (std::max)(parl, par);
+    if (fp < 0.) paru = (std::min)(paru, par);
+
+    /* compute an improved estimate for par. */
+    /* Computing MAX */
+    par = (std::max)(parl, par + parc);
+
+    /* end of an iteration. */
+  }
+
+  /* termination. */
+  if (iter == 0) par = 0.;
+  return;
+}
+
+template <typename Scalar>
+void lmpar2(const ColPivHouseholderQR<Matrix<Scalar, Dynamic, Dynamic> > &qr, const Matrix<Scalar, Dynamic, 1> &diag,
+            const Matrix<Scalar, Dynamic, 1> &qtb, Scalar delta, Scalar &par, Matrix<Scalar, Dynamic, 1> &x)
+
+{
+  using std::abs;
+  using std::sqrt;
+  typedef DenseIndex Index;
+
+  /* Local variables */
+  Index j;
+  Scalar fp;
+  Scalar parc, parl;
+  Index iter;
+  Scalar temp, paru;
+  Scalar gnorm;
+  Scalar dxnorm;
+
+  /* Function Body */
+  const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
+  const Index n = qr.matrixQR().cols();
+  eigen_assert(n == diag.size());
+  eigen_assert(n == qtb.size());
+
+  Matrix<Scalar, Dynamic, 1> wa1, wa2;
+
+  /* compute and store in x the gauss-newton direction. if the */
+  /* jacobian is rank-deficient, obtain a least squares solution. */
+
+  const Index rank = qr.rank();  // use a threshold
+  wa1 = qtb;
+  wa1.tail(n - rank).setZero();
+  qr.matrixQR().topLeftCorner(rank, rank).template triangularView<Upper>().solveInPlace(wa1.head(rank));
+
+  x = qr.colsPermutation() * wa1;
+
+  /* initialize the iteration counter. */
+  /* evaluate the function at the origin, and test */
+  /* for acceptance of the gauss-newton direction. */
+  iter = 0;
+  wa2 = diag.cwiseProduct(x);
+  dxnorm = wa2.blueNorm();
+  fp = dxnorm - delta;
+  if (fp <= Scalar(0.1) * delta) {
+    par = 0;
+    return;
+  }
+
+  /* if the jacobian is not rank deficient, the newton */
+  /* step provides a lower bound, parl, for the zero of */
+  /* the function. otherwise set this bound to zero. */
+  parl = 0.;
+  if (rank == n) {
+    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2) / dxnorm;
+    qr.matrixQR().topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
+    temp = wa1.blueNorm();
+    parl = fp / delta / temp / temp;
+  }
+
+  /* calculate an upper bound, paru, for the zero of the function. */
+  for (j = 0; j < n; ++j)
+    wa1[j] = qr.matrixQR().col(j).head(j + 1).dot(qtb.head(j + 1)) / diag[qr.colsPermutation().indices()(j)];
+
+  gnorm = wa1.stableNorm();
+  paru = gnorm / delta;
+  if (paru == 0.) paru = dwarf / (std::min)(delta, Scalar(0.1));
+
+  /* if the input par lies outside of the interval (parl,paru), */
+  /* set par to the closer endpoint. */
+  par = (std::max)(par, parl);
+  par = (std::min)(par, paru);
+  if (par == 0.) par = gnorm / dxnorm;
+
+  /* beginning of an iteration. */
+  Matrix<Scalar, Dynamic, Dynamic> s = qr.matrixQR();
+  while (true) {
+    ++iter;
+
+    /* evaluate the function at the current value of par. */
+    if (par == 0.) par = (std::max)(dwarf, Scalar(.001) * paru); /* Computing MAX */
+    wa1 = sqrt(par) * diag;
+
+    Matrix<Scalar, Dynamic, 1> sdiag(n);
+    qrsolv<Scalar>(s, qr.colsPermutation().indices(), wa1, qtb, x, sdiag);
+
+    wa2 = diag.cwiseProduct(x);
+    dxnorm = wa2.blueNorm();
+    temp = fp;
+    fp = dxnorm - delta;
+
+    /* if the function is small enough, accept the current value */
+    /* of par. also test for the exceptional cases where parl */
+    /* is zero or the number of iterations has reached 10. */
+    if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10) break;
+
+    /* compute the newton correction. */
+    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2 / dxnorm);
+    // we could almost use this here, but the diagonal is outside qr, in sdiag[]
+    // qr.matrixQR().topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
+    for (j = 0; j < n; ++j) {
+      wa1[j] /= sdiag[j];
+      temp = wa1[j];
+      for (Index i = j + 1; i < n; ++i) wa1[i] -= s(i, j) * temp;
+    }
+    temp = wa1.blueNorm();
+    parc = fp / delta / temp / temp;
+
+    /* depending on the sign of the function, update parl or paru. */
+    if (fp > 0.) parl = (std::max)(parl, par);
+    if (fp < 0.) paru = (std::min)(paru, par);
+
+    /* compute an improved estimate for par. */
+    par = (std::max)(parl, par + parc);
+  }
+  if (iter == 0) par = 0.;
+  return;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_LMPAR_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/qrsolv.h b/contrib/Eigen/src/NonLinearOptimization/qrsolv.h
new file mode 100644
index 0000000..951b646
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/qrsolv.h
@@ -0,0 +1,97 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_QRSOLV_H
+#define EIGEN_NONLINEAROPTIMIZATION_QRSOLV_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// TODO : once qrsolv2 is removed, use ColPivHouseholderQR or PermutationMatrix instead of ipvt
+template <typename Scalar>
+void qrsolv(Matrix<Scalar, Dynamic, Dynamic> &s,
+            // TODO : use a PermutationMatrix once lmpar is no more:
+            const VectorXi &ipvt, const Matrix<Scalar, Dynamic, 1> &diag, const Matrix<Scalar, Dynamic, 1> &qtb,
+            Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &sdiag)
+
+{
+  typedef DenseIndex Index;
+
+  /* Local variables */
+  Index i, j, k, l;
+  Scalar temp;
+  Index n = s.cols();
+  Matrix<Scalar, Dynamic, 1> wa(n);
+  JacobiRotation<Scalar> givens;
+
+  /* Function Body */
+  // the following will only change the lower triangular part of s, including
+  // the diagonal, though the diagonal is restored afterward
+
+  /*     copy r and (q transpose)*b to preserve input and initialize s. */
+  /*     in particular, save the diagonal elements of r in x. */
+  x = s.diagonal();
+  wa = qtb;
+
+  s.topLeftCorner(n, n).template triangularView<StrictlyLower>() = s.topLeftCorner(n, n).transpose();
+
+  /*     eliminate the diagonal matrix d using a givens rotation. */
+  for (j = 0; j < n; ++j) {
+    /*        prepare the row of d to be eliminated, locating the */
+    /*        diagonal element using p from the qr factorization. */
+    l = ipvt[j];
+    if (diag[l] == 0.) break;
+    sdiag.tail(n - j).setZero();
+    sdiag[j] = diag[l];
+
+    /*        the transformations to eliminate the row of d */
+    /*        modify only a single element of (q transpose)*b */
+    /*        beyond the first n, which is initially zero. */
+    Scalar qtbpj = 0.;
+    for (k = j; k < n; ++k) {
+      /*           determine a givens rotation which eliminates the */
+      /*           appropriate element in the current row of d. */
+      givens.makeGivens(-s(k, k), sdiag[k]);
+
+      /*           compute the modified diagonal element of r and */
+      /*           the modified element of ((q transpose)*b,0). */
+      s(k, k) = givens.c() * s(k, k) + givens.s() * sdiag[k];
+      temp = givens.c() * wa[k] + givens.s() * qtbpj;
+      qtbpj = -givens.s() * wa[k] + givens.c() * qtbpj;
+      wa[k] = temp;
+
+      /*           accumulate the transformation in the row of s. */
+      for (i = k + 1; i < n; ++i) {
+        temp = givens.c() * s(i, k) + givens.s() * sdiag[i];
+        sdiag[i] = -givens.s() * s(i, k) + givens.c() * sdiag[i];
+        s(i, k) = temp;
+      }
+    }
+  }
+
+  /*     solve the triangular system for z. if the system is */
+  /*     singular, then obtain a least squares solution. */
+  Index nsing;
+  for (nsing = 0; nsing < n && sdiag[nsing] != 0; nsing++) {
+  }
+
+  wa.tail(n - nsing).setZero();
+  s.topLeftCorner(nsing, nsing).transpose().template triangularView<Upper>().solveInPlace(wa.head(nsing));
+
+  // restore
+  sdiag = s.diagonal();
+  s.diagonal() = x;
+
+  /*     permute the components of z back to components of x. */
+  for (j = 0; j < n; ++j) x[ipvt[j]] = wa[j];
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_QRSOLV_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/r1mpyq.h b/contrib/Eigen/src/NonLinearOptimization/r1mpyq.h
new file mode 100644
index 0000000..e34b540
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/r1mpyq.h
@@ -0,0 +1,34 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_R1MPYQ_H
+#define EIGEN_NONLINEAROPTIMIZATION_R1MPYQ_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// TODO : move this to GivensQR once there's such a thing in Eigen
+
+// Each rotation mixes a column of a with its last column, so a row vector is
+// passed as the transpose of the column vector holding it.
+template <typename Scalar, typename Derived>
+void r1mpyq(MatrixBase<Derived> &a_, const std::vector<JacobiRotation<Scalar> > &v_givens,
+            const std::vector<JacobiRotation<Scalar> > &w_givens) {
+  Derived &a = a_.derived();
+  const Index n = a.cols();
+
+  /*     apply the first set of givens rotations to a. */
+  for (Index j = n - 2; j >= 0; --j) a.applyOnTheRight(j, n - 1, v_givens[j]);
+  /*     apply the second set of givens rotations to a. */
+  for (Index j = 0; j < n - 1; ++j) a.applyOnTheRight(j, n - 1, w_givens[j].transpose());
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_R1MPYQ_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/r1updt.h b/contrib/Eigen/src/NonLinearOptimization/r1updt.h
new file mode 100644
index 0000000..2c283be
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/r1updt.h
@@ -0,0 +1,104 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_R1UPDT_H
+#define EIGEN_NONLINEAROPTIMIZATION_R1UPDT_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1> &u,
+            std::vector<JacobiRotation<Scalar> > &v_givens, std::vector<JacobiRotation<Scalar> > &w_givens,
+            Matrix<Scalar, Dynamic, 1> &v, Matrix<Scalar, Dynamic, 1> &w, bool *sing) {
+  typedef DenseIndex Index;
+  const JacobiRotation<Scalar> IdentityRotation = JacobiRotation<Scalar>(1, 0);
+
+  /* Local variables */
+  const Index m = s.rows();
+  const Index n = s.cols();
+  Index i, j = 1;
+  Scalar temp;
+  JacobiRotation<Scalar> givens;
+
+  // r1updt had a broader use case, but we don't use it here. And, more
+  // importantly, we can not test it.
+  eigen_assert(m == n);
+  eigen_assert(u.size() == m);
+  eigen_assert(v.size() == n);
+  eigen_assert(w.size() == n);
+
+  /* move the nontrivial part of the last column of s into w. */
+  w[n - 1] = s(n - 1, n - 1);
+
+  /* rotate the vector v into a multiple of the n-th unit vector */
+  /* in such a way that a spike is introduced into w. */
+  for (j = n - 2; j >= 0; --j) {
+    w[j] = 0.;
+    if (v[j] != 0.) {
+      /* determine a givens rotation which eliminates the */
+      /* j-th element of v. */
+      givens.makeGivens(-v[n - 1], v[j]);
+
+      /* apply the transformation to v and store the information */
+      /* necessary to recover the givens rotation. */
+      v[n - 1] = givens.s() * v[j] + givens.c() * v[n - 1];
+      v_givens[j] = givens;
+
+      /* apply the transformation to s and extend the spike in w. */
+      for (i = j; i < m; ++i) {
+        temp = givens.c() * s(j, i) - givens.s() * w[i];
+        w[i] = givens.s() * s(j, i) + givens.c() * w[i];
+        s(j, i) = temp;
+      }
+    } else
+      v_givens[j] = IdentityRotation;
+  }
+
+  /* add the spike from the rank 1 update to w. */
+  w += v[n - 1] * u;
+
+  /* eliminate the spike. */
+  *sing = false;
+  for (j = 0; j < n - 1; ++j) {
+    if (w[j] != 0.) {
+      /* determine a givens rotation which eliminates the */
+      /* j-th element of the spike. */
+      givens.makeGivens(-s(j, j), w[j]);
+
+      /* apply the transformation to s and reduce the spike in w. */
+      for (i = j; i < m; ++i) {
+        temp = givens.c() * s(j, i) + givens.s() * w[i];
+        w[i] = -givens.s() * s(j, i) + givens.c() * w[i];
+        s(j, i) = temp;
+      }
+
+      /* store the information necessary to recover the */
+      /* givens rotation. */
+      w_givens[j] = givens;
+    } else
+      w_givens[j] = IdentityRotation;
+
+    /* test for zero diagonal elements in the output s. */
+    if (s(j, j) == 0.) {
+      *sing = true;
+    }
+  }
+  /* move w back into the last column of the output s. */
+  s(n - 1, n - 1) = w[n - 1];
+
+  if (s(j, j) == 0.) {
+    *sing = true;
+  }
+  return;
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_R1UPDT_H
diff --git a/contrib/Eigen/src/NonLinearOptimization/rwupdt.h b/contrib/Eigen/src/NonLinearOptimization/rwupdt.h
new file mode 100644
index 0000000..0358ad4
--- /dev/null
+++ b/contrib/Eigen/src/NonLinearOptimization/rwupdt.h
@@ -0,0 +1,55 @@
+// IWYU pragma: private
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NONLINEAROPTIMIZATION_RWUPDT_H
+#define EIGEN_NONLINEAROPTIMIZATION_RWUPDT_H
+
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Scalar>
+void rwupdt(Matrix<Scalar, Dynamic, Dynamic> &r, const Matrix<Scalar, Dynamic, 1> &w, Matrix<Scalar, Dynamic, 1> &b,
+            Scalar alpha) {
+  typedef DenseIndex Index;
+
+  const Index n = r.cols();
+  eigen_assert(r.rows() >= n);
+  std::vector<JacobiRotation<Scalar> > givens(n);
+
+  /* Local variables */
+  Scalar temp, rowj;
+
+  /* Function Body */
+  for (Index j = 0; j < n; ++j) {
+    rowj = w[j];
+
+    /* apply the previous transformations to */
+    /* r(i,j), i=0,1,...,j-1, and to w(j). */
+    for (Index i = 0; i < j; ++i) {
+      temp = givens[i].c() * r(i, j) + givens[i].s() * rowj;
+      rowj = -givens[i].s() * r(i, j) + givens[i].c() * rowj;
+      r(i, j) = temp;
+    }
+
+    /* determine a givens rotation which eliminates w(j). */
+    givens[j].makeGivens(-r(j, j), rowj);
+
+    if (rowj == 0.) continue;  // givens[j] is identity
+
+    /* apply the current transformation to r(j,j), b(j), and alpha. */
+    r(j, j) = givens[j].c() * r(j, j) + givens[j].s() * rowj;
+    temp = givens[j].c() * b[j] + givens[j].s() * alpha;
+    alpha = -givens[j].s() * b[j] + givens[j].c() * alpha;
+    b[j] = temp;
+  }
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_NONLINEAROPTIMIZATION_RWUPDT_H
diff --git a/contrib/Eigen/src/NumericalDiff/InternalHeaderCheck.h b/contrib/Eigen/src/NumericalDiff/InternalHeaderCheck.h
new file mode 100644
index 0000000..5bc2a81
--- /dev/null
+++ b/contrib/Eigen/src/NumericalDiff/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NUMERICALDIFF_MODULE_H
+#error "Please include contrib/Eigen/NumericalDiff instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/NumericalDiff/NumericalDiff.h b/contrib/Eigen/src/NumericalDiff/NumericalDiff.h
new file mode 100644
index 0000000..1944f98
--- /dev/null
+++ b/contrib/Eigen/src/NumericalDiff/NumericalDiff.h
@@ -0,0 +1,156 @@
+// -*- coding: utf-8
+// vim: set fileencoding=utf-8
+// SPDX-License-Identifier: MPL-2.0
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_NUMERICAL_DIFF_H
+#define EIGEN_NUMERICAL_DIFF_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// Keeps -ffast-math from folding the rounded evaluation points back into x and h, e.g. (x + h) - x
+// into h. EIGEN_OPTIMIZATION_BARRIER is an asm operand constraint restricted to plain types (see
+// Macros.h), so class-type scalars go unguarded.
+template <typename Scalar, std::enable_if_t<std::is_floating_point<Scalar>::value, int> = 0>
+EIGEN_STRONG_INLINE void numerical_diff_barrier(Scalar& x) {
+  EIGEN_UNUSED_VARIABLE(x);
+  EIGEN_OPTIMIZATION_BARRIER(x)
+}
+template <typename Scalar, std::enable_if_t<!std::is_floating_point<Scalar>::value, int> = 0>
+EIGEN_STRONG_INLINE void numerical_diff_barrier(Scalar&) {}
+
+}  // namespace internal
+
+enum NumericalDiffMode { Forward, Central };
+
+/**
+ * This class allows you to add a method df() to your functor, which will
+ * use numerical differentiation to compute an approximate of the
+ * derivative for the functor. Of course, if you have an analytical form
+ * for the derivative, you should rather implement df() by yourself.
+ *
+ * More information on
+ * http://en.wikipedia.org/wiki/Numerical_differentiation
+ *
+ * Currently only "Forward" and "Central" scheme are implemented.
+ */
+template <typename Functor_, NumericalDiffMode mode = Forward>
+class NumericalDiff : public Functor_ {
+ public:
+  typedef Functor_ Functor;
+  typedef typename Functor::Scalar Scalar;
+  typedef typename Functor::InputType InputType;
+  typedef typename Functor::ValueType ValueType;
+  typedef typename Functor::JacobianType JacobianType;
+
+  NumericalDiff(Scalar _epsfcn = 0.) : Functor(), epsfcn(_epsfcn) {}
+  NumericalDiff(const Functor& f, Scalar _epsfcn = 0.) : Functor(f), epsfcn(_epsfcn) {}
+
+  // forward constructors
+  template <typename T0>
+  NumericalDiff(const T0& a0) : Functor(a0), epsfcn(0) {}
+  template <typename T0, typename T1>
+  NumericalDiff(const T0& a0, const T1& a1) : Functor(a0, a1), epsfcn(0) {}
+  template <typename T0, typename T1, typename T2>
+  NumericalDiff(const T0& a0, const T1& a1, const T2& a2) : Functor(a0, a1, a2), epsfcn(0) {}
+
+  enum { InputsAtCompileTime = Functor::InputsAtCompileTime, ValuesAtCompileTime = Functor::ValuesAtCompileTime };
+
+  /**
+   * Computes the Jacobian of the functor at \a _x into \a jac and returns the number of functor evaluations.
+   *
+   * The step along coordinate \c j is <tt>h = eps * max(|x[j]|, 1)</tt> with <tt>eps = sqrt(max(epsfcn, epsilon))</tt>
+   * and \c epsilon the machine precision NumTraits<Scalar>::epsilon(); the difference quotient divides by the
+   * representable step <tt>fl(x[j] + h) - x[j]</tt> actually applied.
+   */
+  int df(const InputType& _x, JacobianType& jac) const {
+    using std::abs;
+    using std::sqrt;
+    /* Local variables */
+    Scalar h;
+    int nfev = 0;
+    const typename InputType::Index n = _x.size();
+    const Scalar eps = sqrt(((std::max)(epsfcn, NumTraits<Scalar>::epsilon())));
+    ValueType val1, val2;
+    InputType x = _x;
+    // TODO: We should do this only if the size is not already known.
+    val1.resize(Functor::values());
+    val2.resize(Functor::values());
+
+    // initialization
+    switch (mode) {
+      case Forward:
+        // compute f(x)
+        Functor::operator()(x, val1);
+        nfev++;
+        break;
+      case Central:
+        // do nothing
+        break;
+      default:
+        eigen_assert(false);
+    }
+
+    // Function Body
+    for (int j = 0; j < n; ++j) {
+      const Scalar x_abs = abs(x[j]);
+      h = numext::maxi(x_abs, Scalar(1)) * eps;
+      // The functor is evaluated at fl(x[j] + h), so divide by that representable step: the rounding
+      // of x[j] + h perturbs h by up to ulp(x[j]) <= epsilon/eps * h <= sqrt(epsilon) * h, comparable
+      // to the error of the difference quotient itself.
+      Scalar x_plus = _x[j] + h;
+      internal::numerical_diff_barrier(x_plus);
+      h = x_plus - _x[j];
+      switch (mode) {
+        case Forward:
+          x[j] = x_plus;
+          Functor::operator()(x, val2);
+          nfev++;
+          x[j] = _x[j];
+          jac.col(j) = (val2 - val1) / h;
+          break;
+        case Central: {
+          x[j] = x_plus;
+          Functor::operator()(x, val2);
+          nfev++;
+          // x[j] - h can round (a tie when x[j] < 0 has |x[j]| within h above a power of two), so
+          // divide by the separation of the two evaluation points rather than by 2*h.
+          Scalar x_minus = _x[j] - h;
+          internal::numerical_diff_barrier(x_minus);
+          x[j] = x_minus;
+          Functor::operator()(x, val1);
+          nfev++;
+          x[j] = _x[j];
+          jac.col(j) = (val2 - val1) / (x_plus - x_minus);
+          break;
+        }
+        default:
+          eigen_assert(false);
+      }
+    }
+    return nfev;
+  }
+
+ private:
+  Scalar epsfcn;
+
+  NumericalDiff& operator=(const NumericalDiff&) = delete;
+};
+
+}  // end namespace Eigen
+
+// vim: ai ts=4 sts=4 et sw=4
+#endif  // EIGEN_NUMERICAL_DIFF_H
diff --git a/contrib/Eigen/src/Polynomials/Companion.h b/contrib/Eigen/src/Polynomials/Companion.h
new file mode 100644
index 0000000..ace2de3
--- /dev/null
+++ b/contrib/Eigen/src/Polynomials/Companion.h
@@ -0,0 +1,254 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_COMPANION_H
+#define EIGEN_COMPANION_H
+
+// This file requires the user to include
+// * Eigen/Core
+// * Eigen/src/PolynomialSolver.h
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+
+template <int Size>
+struct decrement_if_fixed_size : std::integral_constant<int, (Size == Dynamic) ? Dynamic : Size - 1> {};
+
+#endif
+
+template <typename Scalar_, int Deg_>
+class companion {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Deg_ == Dynamic ? Dynamic : Deg_)
+
+  enum { Deg = Deg_, Deg_1 = decrement_if_fixed_size<Deg>::value };
+
+  typedef Scalar_ Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Deg, 1> RightColumn;
+  typedef Matrix<Scalar, Deg_1, 1> BottomLeftDiagonal;
+
+  typedef Matrix<Scalar, Deg, Deg> DenseCompanionMatrixType;
+  typedef Matrix<Scalar, Deg_, Deg_1> LeftBlock;
+  typedef Matrix<Scalar, Deg_1, Deg_1> BottomLeftBlock;
+  typedef Matrix<Scalar, 1, Deg_1> LeftBlockFirstRow;
+
+  typedef DenseIndex Index;
+
+ public:
+  EIGEN_STRONG_INLINE const Scalar_ operator()(Index row, Index col) const {
+    if (m_bl_diag.rows() > col) {
+      if (0 < row) {
+        return m_bl_diag[col];
+      } else {
+        return 0;
+      }
+    } else {
+      return m_monic[row];
+    }
+  }
+
+#ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
+  EIGEN_STRONG_INLINE const Scalar_ operator[](Index row, Index col) const { return operator()(row, col); }
+#endif
+
+ public:
+  template <typename VectorType>
+  void setPolynomial(const VectorType& poly) {
+    const Index deg = poly.size() - 1;
+    m_monic = -poly.head(deg) / poly[deg];
+    m_bl_diag.setOnes(deg - 1);
+  }
+
+  template <typename VectorType>
+  companion(const VectorType& poly) {
+    setPolynomial(poly);
+  }
+
+ public:
+  DenseCompanionMatrixType denseMatrix() const {
+    const Index deg = m_monic.size();
+    const Index deg_1 = deg - 1;
+    DenseCompanionMatrixType companMat(deg, deg);
+    companMat << (LeftBlock(deg, deg_1) << LeftBlockFirstRow::Zero(1, deg_1),
+                  BottomLeftBlock::Identity(deg - 1, deg - 1) * m_bl_diag.asDiagonal())
+                     .finished(),
+        m_monic;
+    return companMat;
+  }
+
+ protected:
+  /** Helper function for the balancing algorithm.
+   * \returns true if the row and the column, having colNorm and rowNorm
+   * as norms, are balanced, false otherwise.
+   * colB and rowB are respectively the multipliers for
+   * the column and the row in order to balance them.
+   * */
+  bool balanced(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced, RealScalar& colB, RealScalar& rowB);
+
+  /** Helper function for the balancing algorithm.
+   * \returns true if the row and the column, having colNorm and rowNorm
+   * as norms, are balanced, false otherwise.
+   * colB and rowB are respectively the multipliers for
+   * the column and the row in order to balance them.
+   * */
+  bool balancedR(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced, RealScalar& colB, RealScalar& rowB);
+
+ public:
+  /**
+   * Balancing algorithm from B. N. PARLETT and C. REINSCH (1969)
+   * "Balancing a matrix for calculation of eigenvalues and eigenvectors"
+   * adapted to the case of companion matrices.
+   * A matrix with non zero row and non zero column is balanced
+   * for a certain norm if the i-th row and the i-th column
+   * have same norm for all i.
+   */
+  void balance();
+
+ protected:
+  RightColumn m_monic;
+  BottomLeftDiagonal m_bl_diag;
+};
+
+template <typename Scalar_, int Deg_>
+inline bool companion<Scalar_, Deg_>::balanced(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced,
+                                               RealScalar& colB, RealScalar& rowB) {
+  if (RealScalar(0) == colNorm || RealScalar(0) == rowNorm || !(numext::isfinite)(colNorm) ||
+      !(numext::isfinite)(rowNorm)) {
+    return true;
+  } else {
+    // To find the balancing coefficients, if the radix is 2,
+    // one finds \f$ \sigma \f$ such that
+    //  \f$ 2^{2\sigma-1} < rowNorm / colNorm \le 2^{2\sigma+1} \f$
+    //  then the balancing coefficient for the row is \f$ 1/2^{\sigma} \f$
+    //  and the balancing coefficient for the column is \f$ 2^{\sigma} \f$
+    const RealScalar radix = RealScalar(2);
+    const RealScalar radix2 = RealScalar(4);
+
+    rowB = rowNorm / radix;
+    colB = RealScalar(1);
+    const RealScalar s = colNorm + rowNorm;
+
+    // Find sigma s.t. rowNorm / 2 <= 2^(2*sigma) * colNorm
+    RealScalar scout = colNorm;
+    while (scout < rowB) {
+      colB *= radix;
+      scout *= radix2;
+    }
+
+    // We now have an upper-bound for sigma, try to lower it.
+    // Find sigma s.t. 2^(2*sigma) * colNorm / 2 < rowNorm
+    scout = colNorm * (colB / radix) * colB;  // Avoid overflow.
+    while (scout >= rowNorm) {
+      colB /= radix;
+      scout /= radix2;
+    }
+
+    // This line is used to avoid insubstantial balancing.
+    if ((rowNorm + radix * scout) < RealScalar(0.95) * s * colB) {
+      isBalanced = false;
+      rowB = RealScalar(1) / colB;
+      return false;
+    } else {
+      return true;
+    }
+  }
+}
+
+template <typename Scalar_, int Deg_>
+inline bool companion<Scalar_, Deg_>::balancedR(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced,
+                                                RealScalar& colB, RealScalar& rowB) {
+  if (RealScalar(0) == colNorm || RealScalar(0) == rowNorm) {
+    return true;
+  } else {
+    /**
+     * Set the norm of the column and the row to the geometric mean
+     * of the row and column norm
+     */
+    const RealScalar q = colNorm / rowNorm;
+    if (!isApprox(q, Scalar_(1))) {
+      rowB = sqrt(colNorm / rowNorm);
+      colB = RealScalar(1) / rowB;
+
+      isBalanced = false;
+      return false;
+    } else {
+      return true;
+    }
+  }
+}
+
+template <typename Scalar_, int Deg_>
+void companion<Scalar_, Deg_>::balance() {
+  using std::abs;
+  EIGEN_STATIC_ASSERT(Deg == Dynamic || 1 < Deg, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  const Index deg = m_monic.size();
+  const Index deg_1 = deg - 1;
+
+  bool hasConverged = false;
+  while (!hasConverged) {
+    hasConverged = true;
+    RealScalar colNorm, rowNorm;
+    RealScalar colB, rowB;
+
+    // First row, first column excluding the diagonal
+    //==============================================
+    colNorm = abs(m_bl_diag[0]);
+    rowNorm = abs(m_monic[0]);
+
+    // Compute balancing of the row and the column
+    if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
+      m_bl_diag[0] *= colB;
+      m_monic[0] *= rowB;
+    }
+
+    // Middle rows and columns excluding the diagonal
+    //==============================================
+    for (Index i = 1; i < deg_1; ++i) {
+      // column norm, excluding the diagonal
+      colNorm = abs(m_bl_diag[i]);
+
+      // row norm, excluding the diagonal
+      rowNorm = abs(m_bl_diag[i - 1]) + abs(m_monic[i]);
+
+      // Compute balancing of the row and the column
+      if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
+        m_bl_diag[i] *= colB;
+        m_bl_diag[i - 1] *= rowB;
+        m_monic[i] *= rowB;
+      }
+    }
+
+    // Last row, last column excluding the diagonal
+    //============================================
+    const Index ebl = m_bl_diag.size() - 1;
+    VectorBlock<RightColumn, Deg_1> headMonic(m_monic, 0, deg_1);
+    colNorm = headMonic.array().abs().sum();
+    rowNorm = abs(m_bl_diag[ebl]);
+
+    // Compute balancing of the row and the column
+    if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
+      headMonic *= colB;
+      m_bl_diag[ebl] *= rowB;
+    }
+  }
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_COMPANION_H
diff --git a/contrib/Eigen/src/Polynomials/InternalHeaderCheck.h b/contrib/Eigen/src/Polynomials/InternalHeaderCheck.h
new file mode 100644
index 0000000..9892c48
--- /dev/null
+++ b/contrib/Eigen/src/Polynomials/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_POLYNOMIALS_MODULE_H
+#error "Please include contrib/Eigen/Polynomials instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/Polynomials/PolynomialSolver.h b/contrib/Eigen/src/Polynomials/PolynomialSolver.h
new file mode 100644
index 0000000..34d4148
--- /dev/null
+++ b/contrib/Eigen/src/Polynomials/PolynomialSolver.h
@@ -0,0 +1,523 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_POLYNOMIAL_SOLVER_H
+#define EIGEN_POLYNOMIAL_SOLVER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \ingroup Polynomials_Module
+ *  \class PolynomialSolverBase.
+ *
+ * \brief Defined to be inherited by polynomial solvers: it provides
+ * convenient methods such as
+ *  - real roots,
+ *  - greatest, smallest complex roots,
+ *  - real roots with greatest, smallest absolute real value,
+ *  - greatest, smallest real roots.
+ *
+ * It stores the set of roots as a vector of complexes.
+ *
+ */
+template <typename Scalar_, int Deg_>
+class PolynomialSolverBase {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Deg_ == Dynamic ? Dynamic : Deg_)
+
+  typedef Scalar_ Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef internal::make_complex_t<Scalar> RootType;
+  typedef Matrix<RootType, Deg_, 1> RootsType;
+
+  typedef DenseIndex Index;
+
+ protected:
+  template <typename OtherPolynomial>
+  inline void setPolynomial(const OtherPolynomial& poly) {
+    m_roots.resize(poly.size() - 1);
+  }
+
+ public:
+  template <typename OtherPolynomial>
+  inline PolynomialSolverBase(const OtherPolynomial& poly) {
+    setPolynomial(poly());
+  }
+
+  inline PolynomialSolverBase() {}
+
+ public:
+  /** \returns the complex roots of the polynomial */
+  inline const RootsType& roots() const { return m_roots; }
+
+ public:
+  /** Clear and fills the back insertion sequence with the real roots of the polynomial
+   * i.e. the real part of the complex roots that have an imaginary part which
+   * absolute value is smaller than absImaginaryThreshold.
+   * absImaginaryThreshold takes the dummy_precision associated
+   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
+   *
+   * \param[out] bi_seq : the back insertion sequence (stl concept)
+   * \param[in]  absImaginaryThreshold : the maximum bound of the imaginary part of a complex
+   *  number that is considered as real.
+   * */
+  template <typename Stl_back_insertion_sequence>
+  inline void realRoots(Stl_back_insertion_sequence& bi_seq,
+                        const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    using std::abs;
+    bi_seq.clear();
+    for (Index i = 0; i < m_roots.size(); ++i) {
+      if (abs(m_roots[i].imag()) < absImaginaryThreshold) {
+        bi_seq.push_back(m_roots[i].real());
+      }
+    }
+  }
+
+ protected:
+  template <typename Predicate>
+  inline const RootType& selectComplexRoot_withRespectToNorm(Predicate& pred) const {
+    Index res = 0;
+    RealScalar norm2 = numext::abs2(m_roots[0]);
+    for (Index i = 1; i < m_roots.size(); ++i) {
+      const RealScalar currNorm2 = numext::abs2(m_roots[i]);
+      if (pred(currNorm2, norm2)) {
+        res = i;
+        norm2 = currNorm2;
+      }
+    }
+    return m_roots[res];
+  }
+
+ public:
+  /**
+   * \returns the complex root with greatest norm.
+   */
+  inline const RootType& greatestRoot() const {
+    std::greater<RealScalar> greater;
+    return selectComplexRoot_withRespectToNorm(greater);
+  }
+
+  /**
+   * \returns the complex root with smallest norm.
+   */
+  inline const RootType& smallestRoot() const {
+    std::less<RealScalar> less;
+    return selectComplexRoot_withRespectToNorm(less);
+  }
+
+ protected:
+  template <typename Predicate>
+  inline const RealScalar& selectRealRoot_withRespectToAbsRealPart(
+      Predicate& pred, bool& hasArealRoot,
+      const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    using std::abs;
+    hasArealRoot = false;
+    Index res = 0;
+    RealScalar val(0);
+
+    for (Index i = 0; i < m_roots.size(); ++i) {
+      if (abs(m_roots[i].imag()) <= absImaginaryThreshold) {
+        if (!hasArealRoot) {
+          hasArealRoot = true;
+          res = i;
+          val = abs(m_roots[i].real());
+        } else {
+          const RealScalar curr = abs(m_roots[i].real());
+          if (pred(curr, val)) {
+            val = curr;
+            res = i;
+          }
+        }
+      } else if (!hasArealRoot) {
+        if (abs(m_roots[i].imag()) < abs(m_roots[res].imag())) {
+          res = i;
+        }
+      }
+    }
+    return numext::real_ref(m_roots[res]);
+  }
+
+  template <typename Predicate>
+  inline const RealScalar& selectRealRoot_withRespectToRealPart(
+      Predicate& pred, bool& hasArealRoot,
+      const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    using std::abs;
+    hasArealRoot = false;
+    Index res = 0;
+    RealScalar val(0);
+
+    for (Index i = 0; i < m_roots.size(); ++i) {
+      if (abs(m_roots[i].imag()) <= absImaginaryThreshold) {
+        if (!hasArealRoot) {
+          hasArealRoot = true;
+          res = i;
+          val = m_roots[i].real();
+        } else {
+          const RealScalar curr = m_roots[i].real();
+          if (pred(curr, val)) {
+            val = curr;
+            res = i;
+          }
+        }
+      } else {
+        if (abs(m_roots[i].imag()) < abs(m_roots[res].imag())) {
+          res = i;
+        }
+      }
+    }
+    return numext::real_ref(m_roots[res]);
+  }
+
+ public:
+  /**
+   * \returns a real root with greatest absolute magnitude.
+   * A real root is defined as the real part of a complex root with absolute imaginary
+   * part smaller than absImaginaryThreshold.
+   * absImaginaryThreshold takes the dummy_precision associated
+   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
+   * If no real root is found the boolean hasArealRoot is set to false and the real part of
+   * the root with smallest absolute imaginary part is returned instead.
+   *
+   * \param[out] hasArealRoot : boolean true if a real root is found according to the
+   *  absImaginaryThreshold criterion, false otherwise.
+   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
+   *  whether or not a root is real.
+   */
+  inline const RealScalar& absGreatestRealRoot(
+      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    std::greater<RealScalar> greater;
+    return selectRealRoot_withRespectToAbsRealPart(greater, hasArealRoot, absImaginaryThreshold);
+  }
+
+  /**
+   * \returns a real root with smallest absolute magnitude.
+   * A real root is defined as the real part of a complex root with absolute imaginary
+   * part smaller than absImaginaryThreshold.
+   * absImaginaryThreshold takes the dummy_precision associated
+   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
+   * If no real root is found the boolean hasArealRoot is set to false and the real part of
+   * the root with smallest absolute imaginary part is returned instead.
+   *
+   * \param[out] hasArealRoot : boolean true if a real root is found according to the
+   *  absImaginaryThreshold criterion, false otherwise.
+   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
+   *  whether or not a root is real.
+   */
+  inline const RealScalar& absSmallestRealRoot(
+      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    std::less<RealScalar> less;
+    return selectRealRoot_withRespectToAbsRealPart(less, hasArealRoot, absImaginaryThreshold);
+  }
+
+  /**
+   * \returns the real root with greatest value.
+   * A real root is defined as the real part of a complex root with absolute imaginary
+   * part smaller than absImaginaryThreshold.
+   * absImaginaryThreshold takes the dummy_precision associated
+   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
+   * If no real root is found the boolean hasArealRoot is set to false and the real part of
+   * the root with smallest absolute imaginary part is returned instead.
+   *
+   * \param[out] hasArealRoot : boolean true if a real root is found according to the
+   *  absImaginaryThreshold criterion, false otherwise.
+   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
+   *  whether or not a root is real.
+   */
+  inline const RealScalar& greatestRealRoot(
+      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    std::greater<RealScalar> greater;
+    return selectRealRoot_withRespectToRealPart(greater, hasArealRoot, absImaginaryThreshold);
+  }
+
+  /**
+   * \returns the real root with smallest value.
+   * A real root is defined as the real part of a complex root with absolute imaginary
+   * part smaller than absImaginaryThreshold.
+   * absImaginaryThreshold takes the dummy_precision associated
+   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
+   * If no real root is found the boolean hasArealRoot is set to false and the real part of
+   * the root with smallest absolute imaginary part is returned instead.
+   *
+   * \param[out] hasArealRoot : boolean true if a real root is found according to the
+   *  absImaginaryThreshold criterion, false otherwise.
+   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
+   *  whether or not a root is real.
+   */
+  inline const RealScalar& smallestRealRoot(
+      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
+    std::less<RealScalar> less;
+    return selectRealRoot_withRespectToRealPart(less, hasArealRoot, absImaginaryThreshold);
+  }
+
+ protected:
+  RootsType m_roots;
+};
+
+#define EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES(BASE) \
+  typedef typename BASE::Scalar Scalar;                    \
+  typedef typename BASE::RealScalar RealScalar;            \
+  typedef typename BASE::RootType RootType;                \
+  typedef typename BASE::RootsType RootsType;
+
+/** \ingroup Polynomials_Module
+ *
+ * \class PolynomialSolver
+ *
+ * \brief A polynomial solver
+ *
+ * Computes the complex roots of a real polynomial.
+ *
+ * \param Scalar_ the scalar type, i.e., the type of the polynomial coefficients
+ * \param Deg_ the degree of the polynomial, can be a compile time value or Dynamic.
+ *             Notice that the number of polynomial coefficients is Deg_+1.
+ *
+ * This class implements a polynomial solver and provides convenient methods such as
+ * - real roots,
+ * - greatest, smallest complex roots,
+ * - real roots with greatest, smallest absolute real value.
+ * - greatest, smallest real roots.
+ *
+ * WARNING: this polynomial solver is experimental, part of the contrib Eigen modules.
+ *
+ *
+ * The eigenvalues of the balanced companion matrix of the polynomial give first approximations of
+ * the roots. Ehrlich-Aberth iterations on the polynomial itself target a residual within the rounding
+ * error of evaluation, with a finite sweep limit and an initial-estimate fallback for unfinished
+ * iterates whose residual increased. The roots of a real polynomial are returned as real numbers or exact
+ * conjugate pairs. A root of multiplicity \f$ m \f$ can only be located to about
+ * \f$ \varepsilon^{1/m} \f$.
+ */
+template <typename Scalar_, int Deg_>
+class PolynomialSolver : public PolynomialSolverBase<Scalar_, Deg_> {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Deg_ == Dynamic ? Dynamic : Deg_)
+
+  typedef PolynomialSolverBase<Scalar_, Deg_> PS_Base;
+  EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES(PS_Base)
+
+  typedef Matrix<Scalar, Deg_, Deg_> CompanionMatrixType;
+  typedef std::conditional_t<NumTraits<Scalar>::IsComplex, ComplexEigenSolver<CompanionMatrixType>,
+                             EigenSolver<CompanionMatrixType> >
+      EigenSolverType;
+  typedef internal::make_complex_t<Scalar_> ComplexScalar;
+
+ public:
+  /** Computes the complex roots of a new polynomial. */
+  template <typename OtherPolynomial>
+  void compute(const OtherPolynomial& poly) {
+    eigen_assert(Scalar(0) != poly[poly.size() - 1]);
+    eigen_assert(poly.size() > 1);
+    if (poly.size() > 2) {
+      internal::companion<Scalar, Deg_> companion(poly);
+      companion.balance();
+      m_eigenSolver.compute(companion.denseMatrix());
+      eigen_assert(m_eigenSolver.info() == Eigen::Success);
+      m_roots = m_eigenSolver.eigenvalues();
+      // Uniform coefficient scaling must not overflow or underflow the refinement's Horner recurrences.
+      const RealScalar scale = poly.realView().cwiseAbs().maxCoeff();
+      const auto scaledPoly = (poly / scale).eval();
+      refineRoots(scaledPoly);
+      cleanUpRoots(scaledPoly);
+    } else if (poly.size() == 2) {
+      m_roots.resize(1);
+      m_roots[0] = -poly[0] / poly[1];
+    }
+  }
+
+ public:
+  template <typename OtherPolynomial>
+  inline PolynomialSolver(const OtherPolynomial& poly) {
+    compute(poly);
+  }
+
+  inline PolynomialSolver() {}
+
+ protected:
+  // Evaluates p(z) and p'(z) by Horner's rule. With withBound, returns Higham's running bound on the rounding error
+  // of the value (Higham 2002, Algorithm 5.1), otherwise zero: the moduli it needs cost more than the recurrence.
+  // The real bound is u (2 mu - |p(z)|), u = eps / 2; a complex product rounds by at most 2 sqrt(2) u |z| |y| and a
+  // complex sum by u |y|, so the complex bound is sqrt(2) eps (2 mu - |p(z)|).
+  template <typename OtherPolynomial>
+  static RealScalar evaluate(const OtherPolynomial& poly, const RootType& z, RootType& value, RootType& derivative,
+                             bool withBound) {
+    const Index degree = poly.size() - 1;
+    value = RootType(poly[degree]);
+    derivative = RootType(0);
+    if (!withBound) {
+      for (Index k = degree - 1; k >= 0; --k) {
+        derivative = derivative * z + value;
+        value = value * z + RootType(poly[k]);
+      }
+      return RealScalar(0);
+    }
+    const RealScalar absz = numext::abs(z);
+    RealScalar mu = numext::abs(value) / RealScalar(2);
+    for (Index k = degree - 1; k >= 0; --k) {
+      derivative = derivative * z + value;
+      value = value * z + RootType(poly[k]);
+      mu = mu * absz + numext::abs(value);
+    }
+    const RealScalar errorScale = numext::sqrt(RealScalar(2)) * NumTraits<RealScalar>::epsilon();
+    return (RealScalar(2) * errorScale) * mu - errorScale * numext::abs(value);
+  }
+
+  /** Refines the eigenvalue estimates in m_roots by Ehrlich-Aberth iterations (Ehrlich 1967; Aberth 1973),
+   * \f$ z_i \leftarrow z_i - w_i / (1 - w_i \sum_{j \ne i} (z_i - z_j)^{-1}) \f$ with \f$ w_i = p(z_i) / p'(z_i) \f$.
+   * The iteration is cubic for simple roots, and the sum keeps the iterates apart, so every root is refined at
+   * once without deflation. Updates use the latest estimates; real starting values receive an epsilon-sized imaginary
+   * perturbation so they can reach nonreal roots. At the sweep limit, unfinished estimates are compared with
+   * their initial polynomial residuals. A root is final once \f$ |p(z_i)| \f$ is
+   * within the rounding bound of its evaluation, so that \f$ z_i \f$ is an exact root of a polynomial that close to
+   * \f$ p \f$ (the stopping rule of Bini 1996), or once its Newton correction is below one ulp. */
+  template <typename OtherPolynomial>
+  void refineRoots(const OtherPolynomial& poly) {
+    const Index n = m_roots.size();
+    const RealScalar eps = NumTraits<RealScalar>::epsilon();
+    // Convergence is not guaranteed for clustered roots; retain the eigenvalue estimates as a fallback.
+    const int maxSweeps = NumTraits<RealScalar>::digits();
+    EIGEN_IF_CONSTEXPR (!NumTraits<Scalar>::IsComplex) {
+      for (Index i = 0; i < n; ++i) {
+        // Real iterates cannot reach a nonreal root; perturb by +/- i eps |z|.
+        if (numext::imag(m_roots[i]) == RealScalar(0)) {
+          const RealScalar perturbation = eps * numext::abs(m_roots[i]);
+          m_roots[i] += RootType(0, i % 2 == 0 ? perturbation : -perturbation);
+        }
+      }
+    }
+    Array<bool, Deg_, 1> active = Array<bool, Deg_, 1>::Constant(n, true);
+    RootType value, derivative;
+    for (int sweep = 0; sweep < maxSweeps; ++sweep) {
+      bool moving = false;
+      for (Index i = 0; i < n; ++i) {
+        if (!active[i]) continue;
+        const RootType z = m_roots[i];
+        // The eigenvalues can pass the rounding test with a backward error of ~10 eps, while one step from them
+        // lands near eps, so the test applies from the second sweep on.
+        const bool testResidual = sweep > 0;
+        const RealScalar bound = evaluate(poly, z, value, derivative, testResidual);
+        if ((testResidual && !(numext::abs(value) > bound)) || !(numext::isfinite)(bound) ||
+            derivative == RootType(0)) {
+          active[i] = false;
+          continue;
+        }
+        const RootType newton = value / derivative;
+        if (!(numext::abs(newton) > eps * numext::abs(z))) {
+          active[i] = false;
+          continue;
+        }
+        RootType repulsion(0);
+        for (Index j = 0; j < n; ++j) {
+          const RootType gap = z - m_roots[j];
+          if (j != i && gap != RootType(0)) repulsion += RootType(1) / gap;
+        }
+        const RootType denominator = RootType(1) - newton * repulsion;
+        const RootType refined = z - (denominator == RootType(0) ? newton : RootType(newton / denominator));
+        if ((numext::isfinite)(numext::abs(refined))) {
+          m_roots[i] = refined;
+          moving = true;
+        } else {
+          active[i] = false;
+        }
+      }
+      if (!moving) return;
+    }
+    // Keep improvements to slowly converging multiple roots, but reject a larger residual at the sweep cap.
+    for (Index i = 0; i < n; ++i) {
+      if (!active[i]) continue;
+      RootType initialValue;
+      evaluate(poly, m_roots[i], value, derivative, false);
+      evaluate(poly, m_eigenSolver.eigenvalues()[i], initialValue, derivative, false);
+      if (!(numext::abs(value) <= numext::abs(initialValue))) m_roots[i] = m_eigenSolver.eigenvalues()[i];
+    }
+  }
+
+  /** Restores the structure the in-place iteration keeps only to within rounding. The roots of a real polynomial
+   * are real or conjugate pairs: two iterates closer to each other's conjugate than to the real axis become exactly
+   * conjugate, and an iterate left without a partner becomes real. Residual-based snapping of the remaining
+   * roots requires an imaginary part at most sqrt(eps) times the real part and a finite rounding bound. */
+  template <typename OtherPolynomial>
+  void cleanUpRoots(const OtherPolynomial& poly) {
+    const Index n = m_roots.size();
+    constexpr bool realPolynomial = !NumTraits<Scalar>::IsComplex;
+    Array<bool, Deg_, 1> paired = Array<bool, Deg_, 1>::Constant(n, false);
+    EIGEN_IF_CONSTEXPR (realPolynomial) {
+      for (Index i = 0; i < n; ++i) {
+        if (!(numext::imag(m_roots[i]) > RealScalar(0))) continue;
+        Index partner = n;
+        RealScalar distance = numext::imag(m_roots[i]);
+        for (Index j = 0; j < n; ++j) {
+          if (paired[j] || !(numext::imag(m_roots[j]) < RealScalar(0))) continue;
+          const RealScalar d = numext::abs(m_roots[j] - numext::conj(m_roots[i]));
+          if (d < distance) {
+            distance = d;
+            partner = j;
+          }
+        }
+        if (partner < n) {
+          paired[i] = paired[partner] = true;
+          const RootType mean = (m_roots[i] + numext::conj(m_roots[partner])) / RealScalar(2);
+          m_roots[i] = mean;
+          m_roots[partner] = numext::conj(mean);
+        }
+      }
+    }
+    RootType value, derivative;
+    for (Index i = 0; i < n; ++i) {
+      if (numext::imag(m_roots[i]) == RealScalar(0)) continue;
+      const RootType realPart(numext::real(m_roots[i]));
+      if (realPolynomial && !paired[i]) {
+        m_roots[i] = realPart;
+        continue;
+      }
+      // A small residual at realPart can belong to a different root.
+      if (!(numext::abs(numext::imag(m_roots[i])) <=
+            numext::sqrt(NumTraits<RealScalar>::epsilon()) * numext::abs(realPart)))
+        continue;
+      const RealScalar bound = evaluate(poly, realPart, value, derivative, true);
+      if ((numext::isfinite)(bound) && numext::abs(value) <= bound) m_roots[i] = realPart;
+    }
+  }
+
+  using PS_Base::m_roots;
+  EigenSolverType m_eigenSolver;
+};
+
+template <typename Scalar_>
+class PolynomialSolver<Scalar_, 1> : public PolynomialSolverBase<Scalar_, 1> {
+ public:
+  typedef PolynomialSolverBase<Scalar_, 1> PS_Base;
+  EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES(PS_Base)
+
+ public:
+  /** Computes the complex roots of a new polynomial. */
+  template <typename OtherPolynomial>
+  void compute(const OtherPolynomial& poly) {
+    eigen_assert(poly.size() == 2);
+    eigen_assert(Scalar(0) != poly[1]);
+    m_roots[0] = -poly[0] / poly[1];
+  }
+
+ public:
+  template <typename OtherPolynomial>
+  inline PolynomialSolver(const OtherPolynomial& poly) {
+    compute(poly);
+  }
+
+  inline PolynomialSolver() {}
+
+ protected:
+  using PS_Base::m_roots;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_POLYNOMIAL_SOLVER_H
diff --git a/contrib/Eigen/src/Polynomials/PolynomialUtils.h b/contrib/Eigen/src/Polynomials/PolynomialUtils.h
new file mode 100644
index 0000000..b5435ac
--- /dev/null
+++ b/contrib/Eigen/src/Polynomials/PolynomialUtils.h
@@ -0,0 +1,145 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_POLYNOMIAL_UTILS_H
+#define EIGEN_POLYNOMIAL_UTILS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \ingroup Polynomials_Module
+ * \returns the evaluation of the polynomial at x using Horner algorithm.
+ *
+ * \param[in] poly : the vector of coefficients of the polynomial ordered
+ *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
+ *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
+ * \param[in] x : the value to evaluate the polynomial at.
+ *
+ * \note for stability:
+ *   \f$ |x| \le 1 \f$
+ */
+template <typename Polynomials, typename T>
+inline T poly_eval_horner(const Polynomials& poly, const T& x) {
+  T val = poly[poly.size() - 1];
+  for (DenseIndex i = poly.size() - 2; i >= 0; --i) {
+    val = val * x + poly[i];
+  }
+  return val;
+}
+
+/** \ingroup Polynomials_Module
+ * \returns the evaluation of the polynomial at x using stabilized Horner algorithm.
+ *
+ * \param[in] poly : the vector of coefficients of the polynomial ordered
+ *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
+ *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
+ * \param[in] x : the value to evaluate the polynomial at.
+ */
+template <typename Polynomials, typename T>
+inline T poly_eval(const Polynomials& poly, const T& x) {
+  typedef typename NumTraits<T>::Real Real;
+
+  if (numext::abs2(x) <= Real(1)) {
+    return poly_eval_horner(poly, x);
+  } else {
+    T val = poly[0];
+    T inv_x = T(1) / x;
+    for (DenseIndex i = 1; i < poly.size(); ++i) {
+      val = val * inv_x + poly[i];
+    }
+
+    return numext::pow(x, (T)(poly.size() - 1)) * val;
+  }
+}
+
+/** \ingroup Polynomials_Module
+ * \returns a maximum bound for the absolute value of any root of the polynomial.
+ *
+ * \param[in] poly : the vector of coefficients of the polynomial ordered
+ *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
+ *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
+ *
+ *  \pre
+ *   the leading coefficient of the input polynomial poly must be nonzero
+ */
+template <typename Polynomial>
+inline typename NumTraits<typename Polynomial::Scalar>::Real cauchy_max_bound(const Polynomial& poly) {
+  using std::abs;
+  typedef typename Polynomial::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real Real;
+
+  eigen_assert(Scalar(0) != poly[poly.size() - 1]);
+  const Scalar inv_leading_coeff = Scalar(1) / poly[poly.size() - 1];
+  Real cb(0);
+
+  for (DenseIndex i = 0; i < poly.size() - 1; ++i) {
+    cb += abs(poly[i] * inv_leading_coeff);
+  }
+  return cb + Real(1);
+}
+
+/** \ingroup Polynomials_Module
+ * \returns a minimum bound for the absolute value of any nonzero root of the polynomial.
+ * \param[in] poly : the vector of coefficients of the polynomial ordered
+ *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
+ *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
+ */
+template <typename Polynomial>
+inline typename NumTraits<typename Polynomial::Scalar>::Real cauchy_min_bound(const Polynomial& poly) {
+  using std::abs;
+  typedef typename Polynomial::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real Real;
+
+  DenseIndex i = 0;
+  while (i < poly.size() - 1 && Scalar(0) == poly(i)) {
+    ++i;
+  }
+  if (poly.size() - 1 == i) {
+    return Real(1);
+  }
+
+  const Scalar inv_min_coeff = Scalar(1) / poly[i];
+  Real cb(1);
+  for (DenseIndex j = i + 1; j < poly.size(); ++j) {
+    cb += abs(poly[j] * inv_min_coeff);
+  }
+  return Real(1) / cb;
+}
+
+/** \ingroup Polynomials_Module
+ * Given the roots of a polynomial compute the coefficients in the
+ * monomial basis of the monic polynomial with same roots and minimal degree.
+ * If RootVector is a vector of complexes, Polynomial should also be a vector
+ * of complexes.
+ * \param[in] rv : a vector containing the roots of a polynomial.
+ * \param[out] poly : the vector of coefficients of the polynomial ordered
+ *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
+ *  e.g. \f$ 3 + x^2 \f$ is stored as a vector \f$ [ 3, 0, 1 ] \f$.
+ */
+template <typename RootVector, typename Polynomial>
+void roots_to_monicPolynomial(const RootVector& rv, Polynomial& poly) {
+  typedef typename Polynomial::Scalar Scalar;
+
+  poly.setZero(rv.size() + 1);
+  poly[0] = -rv[0];
+  poly[1] = Scalar(1);
+  for (DenseIndex i = 1; i < rv.size(); ++i) {
+    for (DenseIndex j = i + 1; j > 0; --j) {
+      poly[j] = poly[j - 1] - rv[i] * poly[j];
+    }
+    poly[0] = -rv[i] * poly[0];
+  }
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_POLYNOMIAL_UTILS_H
diff --git a/contrib/Eigen/src/SparseExtra/InternalHeaderCheck.h b/contrib/Eigen/src/SparseExtra/InternalHeaderCheck.h
new file mode 100644
index 0000000..b36f9d8
--- /dev/null
+++ b/contrib/Eigen/src/SparseExtra/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPARSE_EXTRA_MODULE_H
+#error "Please include contrib/Eigen/SparseExtra instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/SparseExtra/MarketIO.h b/contrib/Eigen/src/SparseExtra/MarketIO.h
new file mode 100644
index 0000000..93d7d7b
--- /dev/null
+++ b/contrib/Eigen/src/SparseExtra/MarketIO.h
@@ -0,0 +1,369 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2012 Desire NUENTSA WAKAM <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPARSE_MARKET_IO_H
+#define EIGEN_SPARSE_MARKET_IO_H
+
+#include <iostream>
+#include <vector>
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Scalar, typename StorageIndex>
+inline void GetMarketLine(const char* line, StorageIndex& i, StorageIndex& j, Scalar& value) {
+  std::stringstream sline(line);
+  sline >> i >> j >> value;
+}
+
+template <>
+inline void GetMarketLine(const char* line, int& i, int& j, float& value) {
+  std::sscanf(line, "%d %d %g", &i, &j, &value);
+}
+
+template <>
+inline void GetMarketLine(const char* line, int& i, int& j, double& value) {
+  std::sscanf(line, "%d %d %lg", &i, &j, &value);
+}
+
+template <>
+inline void GetMarketLine(const char* line, int& i, int& j, std::complex<float>& value) {
+  std::sscanf(line, "%d %d %g %g", &i, &j, &numext::real_ref(value), &numext::imag_ref(value));
+}
+
+template <>
+inline void GetMarketLine(const char* line, int& i, int& j, std::complex<double>& value) {
+  std::sscanf(line, "%d %d %lg %lg", &i, &j, &numext::real_ref(value), &numext::imag_ref(value));
+}
+
+template <typename Scalar, typename StorageIndex>
+inline void GetMarketLine(const char* line, StorageIndex& i, StorageIndex& j, std::complex<Scalar>& value) {
+  std::stringstream sline(line);
+  Scalar valR, valI;
+  sline >> i >> j >> valR >> valI;
+  value = std::complex<Scalar>(valR, valI);
+}
+
+template <typename RealScalar>
+inline void GetDenseElt(const std::string& line, RealScalar& val) {
+  std::istringstream newline(line);
+  newline >> val;
+}
+
+template <typename RealScalar>
+inline void GetDenseElt(const std::string& line, std::complex<RealScalar>& val) {
+  RealScalar valR, valI;
+  std::istringstream newline(line);
+  newline >> valR >> valI;
+  val = std::complex<RealScalar>(valR, valI);
+}
+
+template <typename Scalar>
+inline void putMarketHeader(std::string& header, int sym) {
+  header = "%%MatrixMarket matrix coordinate ";
+  EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, std::complex<float> >::value ||
+                       std::is_same<Scalar, std::complex<double> >::value)) {
+    header += " complex";
+    if (sym == Symmetric)
+      header += " symmetric";
+    else if (sym == SelfAdjoint)
+      header += " Hermitian";
+    else
+      header += " general";
+  } else {
+    header += " real";
+    if (sym == Symmetric)
+      header += " symmetric";
+    else
+      header += " general";
+  }
+}
+
+template <typename Scalar, typename StorageIndex>
+inline void PutMatrixElt(Scalar value, StorageIndex row, StorageIndex col, std::ofstream& out) {
+  out << row << " " << col << " " << value << "\n";
+}
+template <typename Scalar, typename StorageIndex>
+inline void PutMatrixElt(std::complex<Scalar> value, StorageIndex row, StorageIndex col, std::ofstream& out) {
+  out << row << " " << col << " " << value.real() << " " << value.imag() << "\n";
+}
+
+template <typename Scalar>
+inline void putDenseElt(Scalar value, std::ofstream& out) {
+  out << value << "\n";
+}
+template <typename Scalar>
+inline void putDenseElt(std::complex<Scalar> value, std::ofstream& out) {
+  out << value.real() << " " << value.imag() << "\n";
+}
+
+}  // end namespace internal
+
+/**
+ * \ingroup SparseExtra_Module
+ * @brief Reads the header of a matrixmarket file and determines the properties of a matrix
+ *
+ * @param filename of the file
+ * @param sym if the matrix is hermitian, symmetric or none of the latter (sym=0)
+ * @param iscomplex if the matrix has complex or real coefficients
+ * @param isdense if the matrix is dense or sparse
+ * @return true if the file was found
+ */
+inline bool getMarketHeader(const std::string& filename, int& sym, bool& iscomplex, bool& isdense) {
+  sym = 0;
+  iscomplex = false;
+  isdense = false;
+  std::ifstream in(filename.c_str(), std::ios::in);
+  if (!in) return false;
+
+  std::string line;
+  // The matrix header is always the first line in the file
+  std::getline(in, line);
+  eigen_assert(in.good());
+
+  std::stringstream fmtline(line);
+  std::string substr[5];
+  fmtline >> substr[0] >> substr[1] >> substr[2] >> substr[3] >> substr[4];
+  if (substr[2].compare("array") == 0) isdense = true;
+  if (substr[3].compare("complex") == 0) iscomplex = true;
+  if (substr[4].compare("symmetric") == 0)
+    sym = Symmetric;
+  else if (substr[4].compare("Hermitian") == 0)
+    sym = SelfAdjoint;
+
+  return true;
+}
+/**
+ * \ingroup SparseExtra_Module
+ * @brief Loads a sparse matrix from a matrixmarket format file.
+ *
+ * @tparam SparseMatrixType to read into, symmetries are not supported
+ * @param mat SparseMatrix to read into, current values are overwritten
+ * @param filename to parse matrix from
+ * @return returns true if file exists. Returns false if the parsing did not succeed.
+ */
+template <typename SparseMatrixType>
+bool loadMarket(SparseMatrixType& mat, const std::string& filename) {
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::StorageIndex StorageIndex;
+  std::ifstream input(filename.c_str(), std::ios::in);
+  if (!input) return false;
+
+  char rdbuffer[4096];
+  input.rdbuf()->pubsetbuf(rdbuffer, 4096);
+
+  const int maxBuffersize = 2048;
+  char buffer[maxBuffersize];
+
+  bool readsizes = false;
+
+  typedef Triplet<Scalar, StorageIndex> T;
+  std::vector<T> elements;
+
+  Index M(-1), N(-1), NNZ(-1);
+  Index count = 0;
+  while (input.getline(buffer, maxBuffersize)) {
+    // skip comments
+    // NOTE An appropriate test should be done on the header to get the symmetry
+    if (buffer[0] == '%') continue;
+
+    if (!readsizes) {
+      std::stringstream line(buffer);
+      line >> M >> N >> NNZ;
+      if (M > 0 && N > 0) {
+        readsizes = true;
+        mat.resize(M, N);
+        mat.reserve(NNZ);
+        elements.reserve(NNZ);
+      }
+    } else {
+      StorageIndex i(-1), j(-1);
+      Scalar value;
+      internal::GetMarketLine(buffer, i, j, value);
+
+      i--;
+      j--;
+      if (i >= 0 && j >= 0 && i < M && j < N) {
+        ++count;
+        elements.push_back(T(i, j, value));
+      } else {
+        std::cerr << "Invalid read: " << i << "," << j << "\n";
+        return false;
+      }
+    }
+  }
+
+  mat.setFromTriplets(elements.begin(), elements.end());
+  if (count != NNZ) {
+    std::cerr << count << "!=" << NNZ << "\n";
+    return false;
+  }
+  input.close();
+  return true;
+}
+
+/**
+ * \ingroup SparseExtra_Module
+ * @brief Loads a dense Matrix or Vector from a matrixmarket file. If a statically sized matrix has to be parsed and the
+ * file contains the wrong dimensions it is undefined behaviour.
+ *
+ * @tparam DenseMatrixType to read into
+ * @param mat DenseMatrix to read into, current values are overwritten, symmetries are not supported
+ * @param filename to parse matrix from
+ * @return true if parsing was successful. Returns false if the parsing did not succeed.
+ */
+template <typename DenseType>
+bool loadMarketDense(DenseType& mat, const std::string& filename) {
+  typedef typename DenseType::Scalar Scalar;
+  std::ifstream in(filename.c_str(), std::ios::in);
+  if (!in) return false;
+
+  std::string line;
+  Index rows(0), cols(0);
+  do {  // Skip comments
+    std::getline(in, line);
+    eigen_assert(in.good());
+  } while (line[0] == '%');
+  std::istringstream newline(line);
+  newline >> rows >> cols;
+
+  bool sizes_not_positive = (rows < 1 || cols < 1);
+  bool wrong_input_rows = (DenseType::MaxRowsAtCompileTime != Dynamic && rows > DenseType::MaxRowsAtCompileTime) ||
+                          (DenseType::RowsAtCompileTime != Dynamic && rows != DenseType::RowsAtCompileTime);
+  bool wrong_input_cols = (DenseType::MaxColsAtCompileTime != Dynamic && cols > DenseType::MaxColsAtCompileTime) ||
+                          (DenseType::ColsAtCompileTime != Dynamic && cols != DenseType::ColsAtCompileTime);
+
+  if (sizes_not_positive || wrong_input_rows || wrong_input_cols) {
+    if (sizes_not_positive) {
+      std::cerr << "non-positive row or column size in file" << filename << "\n";
+    } else {
+      std::cerr << "Input matrix can not be resized to" << rows << " x " << cols << "as given in " << filename << "\n";
+    }
+    in.close();
+    return false;
+  }
+
+  mat.resize(rows, cols);
+  Index row = 0;
+  Index col = 0;
+  Index n = 0;
+  Scalar value;
+  while (std::getline(in, line) && (row < rows) && (col < cols)) {
+    internal::GetDenseElt(line, value);
+    // matrixmarket format is column major
+    mat(row, col) = value;
+    row++;
+    if (row == rows) {
+      row = 0;
+      col++;
+    }
+    n++;
+  }
+  in.close();
+  if (n != mat.size()) {
+    std::cerr << "Unable to read all elements from file " << filename << "\n";
+    return false;
+  }
+  return true;
+}
+/**
+ * \ingroup SparseExtra_Module
+ * @brief Same functionality as loadMarketDense, deprecated
+ */
+template <typename VectorType>
+bool loadMarketVector(VectorType& vec, const std::string& filename) {
+  return loadMarketDense(vec, filename);
+}
+
+/**
+ * \ingroup SparseExtra_Module
+ * @brief writes a sparse Matrix to a matrixmarket format file
+ *
+ * @tparam SparseMatrixType to write to file
+ * @param mat matrix to write to file
+ * @param filename filename to write to
+ * @param sym at the moment no symmetry operations are supported
+ * @return true if writing succeeded
+ */
+template <typename SparseMatrixType>
+bool saveMarket(const SparseMatrixType& mat, const std::string& filename, int sym = 0) {
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::RealScalar RealScalar;
+  std::ofstream out(filename.c_str(), std::ios::out);
+  if (!out) return false;
+
+  out.flags(std::ios_base::scientific);
+  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
+  std::string header;
+  internal::putMarketHeader<Scalar>(header, sym);
+  out << header << std::endl;
+  out << mat.rows() << " " << mat.cols() << " " << mat.nonZeros() << "\n";
+  int count = 0;
+  EIGEN_UNUSED_VARIABLE(count);
+  for (int j = 0; j < mat.outerSize(); ++j)
+    for (typename SparseMatrixType::InnerIterator it(mat, j); it; ++it) {
+      ++count;
+      internal::PutMatrixElt(it.value(), it.row() + 1, it.col() + 1, out);
+    }
+  out.close();
+  return true;
+}
+
+/**
+ * \ingroup SparseExtra_Module
+ * @brief writes a dense Matrix or vector to a matrixmarket format file
+ *
+ * @tparam DenseMatrixType to write to file
+ * @param mat matrix to write to file
+ * @param filename filename to write to
+ * @return true if writing succeeded
+ */
+
+template <typename DenseType>
+bool saveMarketDense(const DenseType& mat, const std::string& filename) {
+  typedef typename DenseType::Scalar Scalar;
+  typedef typename DenseType::RealScalar RealScalar;
+  std::ofstream out(filename.c_str(), std::ios::out);
+  if (!out) return false;
+
+  out.flags(std::ios_base::scientific);
+  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
+  EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, std::complex<float> >::value ||
+                       std::is_same<Scalar, std::complex<double> >::value)) {
+    out << "%%MatrixMarket matrix array complex general\n";
+  } else {
+    out << "%%MatrixMarket matrix array real general\n";
+  }
+  out << mat.rows() << " " << mat.cols() << "\n";
+  for (Index i = 0; i < mat.cols(); i++) {
+    for (Index j = 0; j < mat.rows(); j++) {
+      internal::putDenseElt(mat(j, i), out);
+    }
+  }
+  out.close();
+  return true;
+}
+
+/**
+ * \ingroup SparseExtra_Module
+ * @brief Same functionality as saveMarketDense, deprecated
+ */
+template <typename VectorType>
+bool saveMarketVector(const VectorType& vec, const std::string& filename) {
+  return saveMarketDense(vec, filename);
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPARSE_MARKET_IO_H
diff --git a/contrib/Eigen/src/SparseExtra/MatrixMarketIterator.h b/contrib/Eigen/src/SparseExtra/MatrixMarketIterator.h
new file mode 100644
index 0000000..f265984
--- /dev/null
+++ b/contrib/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Desire NUENTSA WAKAM <desire.nuentsa_wakam@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_BROWSE_MATRICES_H
+#define EIGEN_BROWSE_MATRICES_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+enum { SPD = 0x100, NonSymmetric = 0x0 };
+
+/**
+ * @brief Iterator to browse matrices from a specified folder
+ *
+ * This is used to load all the matrices from a folder.
+ * The matrices should be in Matrix Market format
+ * It is assumed that the matrices are named as matname.mtx
+ * and matname_SPD.mtx if the matrix is Symmetric and positive definite (or Hermitian)
+ * The right hand side vectors are loaded as well, if they exist.
+ * They should be named as matname_b.mtx.
+ * Note that the right hand side for a SPD matrix is named as matname_SPD_b.mtx
+ *
+ * Sometimes a reference solution is available. In this case, it should be named as matname_x.mtx
+ *
+ * Sample code
+ * \code
+ *
+ * \endcode
+ *
+ * \tparam Scalar The scalar type
+ */
+template <typename Scalar>
+class MatrixMarketIterator {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+ public:
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
+
+ public:
+  MatrixMarketIterator(const std::string& folder)
+      : m_sym(0), m_isvalid(false), m_matIsLoaded(false), m_hasRhs(false), m_hasrefX(false), m_folder(folder) {
+    m_folder_id = opendir(folder.c_str());
+    if (m_folder_id) Getnextvalidmatrix();
+  }
+
+  ~MatrixMarketIterator() {
+    if (m_folder_id) closedir(m_folder_id);
+  }
+
+  inline MatrixMarketIterator& operator++() {
+    m_matIsLoaded = false;
+    m_hasrefX = false;
+    m_hasRhs = false;
+    Getnextvalidmatrix();
+    return *this;
+  }
+  inline operator bool() const { return m_isvalid; }
+
+  /** Return the sparse matrix corresponding to the current file */
+  inline MatrixType& matrix() {
+    // Read the matrix
+    if (m_matIsLoaded) return m_mat;
+
+    std::string matrix_file = m_folder + "/" + m_matname + ".mtx";
+    if (!loadMarket(m_mat, matrix_file)) {
+      std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"" << std::endl;
+      m_matIsLoaded = false;
+      return m_mat;
+    }
+    m_matIsLoaded = true;
+
+    if (m_sym != NonSymmetric) {
+      // Check whether we need to restore a full matrix:
+      RealScalar diag_norm = m_mat.diagonal().norm();
+      RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
+      RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
+      if (lower_norm > diag_norm && upper_norm == diag_norm) {
+        // only the lower part is stored
+        MatrixType tmp(m_mat);
+        m_mat = tmp.template selfadjointView<Lower>();
+      } else if (upper_norm > diag_norm && lower_norm == diag_norm) {
+        // only the upper part is stored
+        MatrixType tmp(m_mat);
+        m_mat = tmp.template selfadjointView<Upper>();
+      }
+    }
+    return m_mat;
+  }
+
+  /** Return the right hand side corresponding to the current matrix.
+   * If the rhs file is not provided, a random rhs is generated
+   */
+  inline VectorType& rhs() {
+    // Get the right hand side
+    if (m_hasRhs) return m_rhs;
+
+    std::string rhs_file;
+    rhs_file = m_folder + "/" + m_matname + "_b.mtx";  // The pattern is matname_b.mtx
+    m_hasRhs = Fileexists(rhs_file);
+    if (m_hasRhs) {
+      m_rhs.resize(m_mat.cols());
+      m_hasRhs = loadMarketVector(m_rhs, rhs_file);
+    }
+    if (!m_hasRhs) {
+      // Generate a random right hand side
+      if (!m_matIsLoaded) this->matrix();
+      m_refX.resize(m_mat.cols());
+      m_refX.setRandom();
+      m_rhs = m_mat * m_refX;
+      m_hasrefX = true;
+      m_hasRhs = true;
+    }
+    return m_rhs;
+  }
+
+  /** Return a reference solution
+   * If it is not provided and if the right hand side is not available
+   * then refX is randomly generated such that A*refX = b
+   * where A and b are the matrix and the rhs.
+   * Note that when a rhs is provided, refX is not available
+   */
+  inline VectorType& refX() {
+    // Check if a reference solution is provided
+    if (m_hasrefX) return m_refX;
+
+    std::string lhs_file;
+    lhs_file = m_folder + "/" + m_matname + "_x.mtx";
+    m_hasrefX = Fileexists(lhs_file);
+    if (m_hasrefX) {
+      m_refX.resize(m_mat.cols());
+      m_hasrefX = loadMarketVector(m_refX, lhs_file);
+    } else
+      m_refX.resize(0);
+    return m_refX;
+  }
+
+  inline std::string& matname() { return m_matname; }
+
+  inline int sym() const { return m_sym; }
+
+  bool hasRhs() const { return m_hasRhs; }
+  bool hasrefX() const { return m_hasrefX; }
+  bool isFolderValid() const { return bool(m_folder_id); }
+
+ protected:
+  inline bool Fileexists(std::string file) const {
+    std::ifstream file_id(file.c_str());
+    if (!file_id.good()) {
+      return false;
+    } else {
+      file_id.close();
+      return true;
+    }
+  }
+
+  void Getnextvalidmatrix() {
+    m_isvalid = false;
+    // Here, we return with the next valid matrix in the folder
+    while ((m_curs_id = readdir(m_folder_id)) != nullptr) {
+      m_isvalid = false;
+      std::string curfile;
+      curfile = m_folder + "/" + m_curs_id->d_name;
+      // Discard if it is a folder
+      if (m_curs_id->d_type == DT_DIR) continue;  // FIXME: This may not be available on non-BSD systems.
+
+      // Determine from the header if it is a matrix or a right hand side
+      bool isvector, iscomplex = false;
+      if (!getMarketHeader(curfile, m_sym, iscomplex, isvector)) continue;
+      if (isvector) continue;
+      if (!iscomplex) {
+        EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, std::complex<float> >::value ||
+                             std::is_same<Scalar, std::complex<double> >::value))
+          continue;
+      }
+      if (iscomplex) {
+        EIGEN_IF_CONSTEXPR ((std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value)) {
+          continue;
+        }
+      }
+
+      // Get the matrix name
+      std::string filename = m_curs_id->d_name;
+      m_matname = filename.substr(0, filename.length() - 4);
+
+      // Find if the matrix is SPD
+      size_t found = m_matname.find("SPD");
+      if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
+
+      m_isvalid = true;
+      break;
+    }
+  }
+  int m_sym;              // Symmetry of the matrix
+  MatrixType m_mat;       // Current matrix
+  VectorType m_rhs;       // Current vector
+  VectorType m_refX;      // The reference solution, if exists
+  std::string m_matname;  // Matrix Name
+  bool m_isvalid;
+  bool m_matIsLoaded;  // Determine if the matrix has already been loaded from the file
+  bool m_hasRhs;       // The right hand side exists
+  bool m_hasrefX;      // A reference solution is provided
+  std::string m_folder;
+  DIR* m_folder_id;
+  struct dirent* m_curs_id;
+};
+
+}  // end namespace Eigen
+
+#endif
diff --git a/contrib/Eigen/src/SparseExtra/RandomSetter.h b/contrib/Eigen/src/SparseExtra/RandomSetter.h
new file mode 100644
index 0000000..1c45788
--- /dev/null
+++ b/contrib/Eigen/src/SparseExtra/RandomSetter.h
@@ -0,0 +1,308 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_RANDOMSETTER_H
+#define EIGEN_RANDOMSETTER_H
+
+#if defined(EIGEN_GOOGLEHASH_SUPPORT)
+// Ensure the ::google namespace exists, required for checking existence of
+// ::google::dense_hash_map and ::google::sparse_hash_map.
+namespace google {}
+#endif
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** Represents a std::map
+ *
+ * \see RandomSetter
+ */
+template <typename Scalar>
+struct StdMapTraits {
+  typedef int KeyType;
+  typedef std::map<KeyType, Scalar> Type;
+  enum { IsSorted = 1 };
+
+  static void setInvalidKey(Type&, const KeyType&) {}
+};
+
+/** Represents a std::unordered_map
+ * \see RandomSetter
+ */
+template <typename Scalar>
+struct StdUnorderedMapTraits {
+  typedef int KeyType;
+  typedef std::unordered_map<KeyType, Scalar> Type;
+  enum { IsSorted = 0 };
+
+  static void setInvalidKey(Type&, const KeyType&) {}
+};
+
+#if defined(EIGEN_GOOGLEHASH_SUPPORT)
+
+namespace google {
+
+// Namespace work-around, since sometimes dense_hash_map and sparse_hash_map
+// are in the global namespace, and other times they are under ::google.
+using namespace ::google;
+
+template <typename KeyType, typename Scalar>
+struct DenseHashMap {
+  typedef dense_hash_map<KeyType, Scalar> type;
+};
+
+template <typename KeyType, typename Scalar>
+struct SparseHashMap {
+  typedef sparse_hash_map<KeyType, Scalar> type;
+};
+
+}  // namespace google
+
+/** Represents a google::dense_hash_map
+ *
+ * \see RandomSetter
+ */
+template <typename Scalar>
+struct GoogleDenseHashMapTraits {
+  typedef int KeyType;
+  typedef typename google::DenseHashMap<KeyType, Scalar>::type Type;
+  enum { IsSorted = 0 };
+
+  static void setInvalidKey(Type& map, const KeyType& k) { map.set_empty_key(k); }
+};
+
+/** Represents a google::sparse_hash_map
+ *
+ * \see RandomSetter
+ */
+template <typename Scalar>
+struct GoogleSparseHashMapTraits {
+  typedef int KeyType;
+  typedef typename google::SparseHashMap<KeyType, Scalar>::type Type;
+  enum { IsSorted = 0 };
+
+  static void setInvalidKey(Type&, const KeyType&) {}
+};
+#endif
+
+/** \class RandomSetter
+ * \ingroup SparseExtra_Module
+ * \brief The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access
+ *
+ * \tparam SparseMatrixType the type of the sparse matrix we are updating
+ * \tparam MapTraits a traits class representing the map implementation used for the temporary sparse storage.
+ *                  Its default value depends on the system.
+ * \tparam OuterPacketBits defines the number of rows (or columns) managed by a single map object
+ *                        as a power of two exponent.
+ *
+ * This class temporarily represents a sparse matrix object using a generic map implementation allowing for
+ * efficient random access. The conversion from the compressed representation to a hash_map object is performed
+ * in the RandomSetter constructor, while the sparse matrix is updated back at destruction time. This strategy
+ * suggests the use of nested blocks as in this example:
+ *
+ * \code
+ * SparseMatrix<double> m(rows,cols);
+ * {
+ *   RandomSetter<SparseMatrix<double> > w(m);
+ *   // don't use m but w instead with read/write random access to the coefficients:
+ *   for(;;)
+ *     w(rand(),rand()) = rand;
+ * }
+ * // when w is deleted, the data are copied back to m
+ * // and m is ready to use.
+ * \endcode
+ *
+ * Since hash_map objects are not fully sorted, representing a full matrix as a single hash_map would
+ * involve a big and costly sort to update the compressed matrix back. To overcome this issue, a RandomSetter
+ * use multiple hash_map, each representing 2^OuterPacketBits columns or rows according to the storage order.
+ * To reach optimal performance, this value should be adjusted according to the average number of nonzeros
+ * per rows/columns.
+ *
+ * The possible values for the template parameter MapTraits are:
+ *  - \b StdMapTraits: corresponds to std::map. (does not perform very well)
+ *  - \b StdUnorderedMapTraits: corresponds to std::unordered_map
+ *  - \b GoogleDenseHashMapTraits: corresponds to google::dense_hash_map (best efficiency, reasonable memory
+ * consumption)
+ *  - \b GoogleSparseHashMapTraits: corresponds to google::sparse_hash_map (best memory consumption, relatively good
+ * performance)
+ *
+ * The default map implementation is GoogleDenseHashMapTraits if EIGEN_GOOGLEHASH_SUPPORT is defined, and
+ * StdUnorderedMapTraits otherwise; StdMapTraits is never selected by default.
+ *
+ * For performance and memory consumption reasons it is highly recommended to use one of
+ * Google's hash_map implementations. To enable the support for them, you must define
+ * EIGEN_GOOGLEHASH_SUPPORT. This will include both <google/dense_hash_map> and
+ * <google/sparse_hash_map> for you.
+ *
+ * \see https://github.com/sparsehash/sparsehash
+ */
+template <typename SparseMatrixType,
+          template <typename T> class MapTraits =
+#if defined(EIGEN_GOOGLEHASH_SUPPORT)
+              GoogleDenseHashMapTraits
+#else
+              StdUnorderedMapTraits
+#endif
+          ,
+          int OuterPacketBits = 6>
+class RandomSetter {
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef typename SparseMatrixType::StorageIndex StorageIndex;
+
+  struct ScalarWrapper {
+    Scalar value = Scalar(0);
+  };
+  typedef typename MapTraits<ScalarWrapper>::KeyType KeyType;
+  typedef typename MapTraits<ScalarWrapper>::Type HashMapType;
+  static constexpr int OuterPacketMask = (1 << OuterPacketBits) - 1;
+  enum {
+    SwapStorage = 1 - MapTraits<ScalarWrapper>::IsSorted,
+    TargetRowMajor = (SparseMatrixType::Flags & RowMajorBit) ? 1 : 0,
+    SetterRowMajor = SwapStorage ? 1 - TargetRowMajor : TargetRowMajor
+  };
+
+ public:
+  /** Constructs a random setter object from the sparse matrix \a target
+   *
+   * Note that the initial values of \a target are imported. If you want to re-set
+   * a sparse matrix from scratch, then you must set it to zero first using the
+   * setZero() function.
+   */
+  inline RandomSetter(SparseMatrixType& target) : m_target(&target) {
+    const Index outerSize = SwapStorage ? target.innerSize() : target.outerSize();
+    const Index innerSize = SwapStorage ? target.outerSize() : target.innerSize();
+    m_outerPackets = outerSize >> OuterPacketBits;
+    if (outerSize & OuterPacketMask) m_outerPackets += 1;
+    m_hashmaps = new HashMapType[m_outerPackets];
+    // compute number of bits needed to store inner indices
+    Index aux = innerSize - 1;
+    m_keyBitsOffset = 0;
+    while (aux) {
+      ++m_keyBitsOffset;
+      aux = aux >> 1;
+    }
+    KeyType ik = (1 << (OuterPacketBits + m_keyBitsOffset));
+    for (Index k = 0; k < m_outerPackets; ++k) MapTraits<ScalarWrapper>::setInvalidKey(m_hashmaps[k], ik);
+
+    // insert current coeffs
+    for (Index j = 0; j < m_target->outerSize(); ++j)
+      for (typename SparseMatrixType::InnerIterator it(*m_target, j); it; ++it)
+        (*this)(TargetRowMajor ? j : it.index(), TargetRowMajor ? it.index() : j) = it.value();
+  }
+
+  /** Destructor updating back the sparse matrix target */
+  ~RandomSetter() {
+    KeyType keyBitsMask = (1 << m_keyBitsOffset) - 1;
+    if (!SwapStorage)  // also means the map is sorted
+    {
+      m_target->setZero();
+      m_target->makeCompressed();
+      m_target->reserve(nonZeros());
+      Index prevOuter = -1;
+      for (Index k = 0; k < m_outerPackets; ++k) {
+        const Index outerOffset = (1 << OuterPacketBits) * k;
+        typename HashMapType::iterator end = m_hashmaps[k].end();
+        for (typename HashMapType::iterator it = m_hashmaps[k].begin(); it != end; ++it) {
+          const Index outer = (it->first >> m_keyBitsOffset) + outerOffset;
+          const Index inner = it->first & keyBitsMask;
+          if (prevOuter != outer) {
+            for (Index j = prevOuter + 1; j <= outer; ++j) m_target->startVec(j);
+            prevOuter = outer;
+          }
+          m_target->insertBackByOuterInner(outer, inner) = it->second.value;
+        }
+      }
+      m_target->finalize();
+    } else {
+      VectorXi positions(m_target->outerSize());
+      positions.setZero();
+      // pass 1
+      for (Index k = 0; k < m_outerPackets; ++k) {
+        typename HashMapType::iterator end = m_hashmaps[k].end();
+        for (typename HashMapType::iterator it = m_hashmaps[k].begin(); it != end; ++it) {
+          const Index outer = it->first & keyBitsMask;
+          ++positions[outer];
+        }
+      }
+      // prefix sum
+      StorageIndex count = 0;
+      for (Index j = 0; j < m_target->outerSize(); ++j) {
+        StorageIndex tmp = positions[j];
+        m_target->outerIndexPtr()[j] = count;
+        positions[j] = count;
+        count += tmp;
+      }
+      m_target->makeCompressed();
+      m_target->outerIndexPtr()[m_target->outerSize()] = count;
+      m_target->resizeNonZeros(count);
+      // pass 2
+      for (Index k = 0; k < m_outerPackets; ++k) {
+        const Index outerOffset = (1 << OuterPacketBits) * k;
+        typename HashMapType::iterator end = m_hashmaps[k].end();
+        for (typename HashMapType::iterator it = m_hashmaps[k].begin(); it != end; ++it) {
+          const Index inner = (it->first >> m_keyBitsOffset) + outerOffset;
+          const Index outer = it->first & keyBitsMask;
+          // sorted insertion
+          // Note that we have to deal with at most 2^OuterPacketBits unsorted coefficients,
+          // moreover those 2^OuterPacketBits coeffs are likely to be sparse, and so only a
+          // small fraction of them have to be sorted, whence the following simple procedure:
+          Index posStart = m_target->outerIndexPtr()[outer];
+          Index i = (positions[outer]++) - 1;
+          while ((i >= posStart) && (m_target->innerIndexPtr()[i] > inner)) {
+            m_target->valuePtr()[i + 1] = m_target->valuePtr()[i];
+            m_target->innerIndexPtr()[i + 1] = m_target->innerIndexPtr()[i];
+            --i;
+          }
+          m_target->innerIndexPtr()[i + 1] = internal::convert_index<StorageIndex>(inner);
+          m_target->valuePtr()[i + 1] = it->second.value;
+        }
+      }
+    }
+    delete[] m_hashmaps;
+  }
+
+  /** \returns a reference to the coefficient at given coordinates \a row, \a col */
+  Scalar& operator()(Index row, Index col) {
+    const Index outer = SetterRowMajor ? row : col;
+    const Index inner = SetterRowMajor ? col : row;
+    const Index outerMajor = outer >> OuterPacketBits;  // index of the packet/map
+    const Index outerMinor = outer & OuterPacketMask;   // index of the inner vector in the packet
+    const KeyType key = internal::convert_index<KeyType>((outerMinor << m_keyBitsOffset) | inner);
+    return m_hashmaps[outerMajor][key].value;
+  }
+
+#ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
+  /** \returns a reference to the coefficient at given coordinates \a row, \a col */
+  Scalar& operator[](Index row, Index col) { return operator()(row, col); }
+#endif
+
+  /** \returns the number of non zero coefficients
+   *
+   * \note According to the underlying map/hash_map implementation,
+   * this function might be quite expensive.
+   */
+  Index nonZeros() const {
+    Index nz = 0;
+    for (Index k = 0; k < m_outerPackets; ++k) nz += static_cast<Index>(m_hashmaps[k].size());
+    return nz;
+  }
+
+ protected:
+  HashMapType* m_hashmaps;
+  SparseMatrixType* m_target;
+  Index m_outerPackets;
+  unsigned char m_keyBitsOffset;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_RANDOMSETTER_H
diff --git a/contrib/Eigen/src/SparseExtra/SparseInverse.h b/contrib/Eigen/src/SparseExtra/SparseInverse.h
new file mode 100644
index 0000000..72e89bb
--- /dev/null
+++ b/contrib/Eigen/src/SparseExtra/SparseInverse.h
@@ -0,0 +1,233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2022 Julian Kent <jkflying@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPARSEINVERSE_H
+#define EIGEN_SPARSEINVERSE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "../../../../Eigen/Sparse"
+#include "../../../../Eigen/SparseLU"
+
+namespace Eigen {
+
+/**
+ * @brief Kahan algorithm based accumulator
+ *
+ * The Kahan sum algorithm guarantees to bound the error from floating point
+ * accumulation to a fixed value, regardless of the number of accumulations
+ * performed. Naive accumulation accumulates errors O(N), and pairwise O(logN).
+ * However pairwise also requires O(logN) memory while Kahan summation requires
+ * O(1) memory, but 4x the operations / latency.
+ *
+ * NB! Do not enable associative math optimizations, they may cause the Kahan
+ * summation to be optimized out leaving you with naive summation again.
+ *
+ */
+template <typename Scalar>
+class KahanSum {
+  // Straightforward Kahan summation for accurate accumulation of a sum of numbers
+  Scalar _sum{};
+  Scalar _correction{};
+
+ public:
+  Scalar value() const { return _sum; }
+
+  void operator+=(Scalar increment) {
+    const Scalar correctedIncrement = increment + _correction;
+    const Scalar previousSum = _sum;
+    _sum += correctedIncrement;
+    _correction = correctedIncrement - (_sum - previousSum);
+  }
+};
+template <typename Scalar, Index Width = 16>
+class FABSum {
+  // https://epubs.siam.org/doi/pdf/10.1137/19M1257780
+  // Fast and Accurate Blocked Summation
+  // Uses naive summation for the fast sum, and Kahan summation for the accurate sum
+  // Theoretically SIMD sum could be changed to a tree sum which would improve accuracy
+  // over naive summation
+  KahanSum<Scalar> _totalSum;
+  Matrix<Scalar, Width, 1> _block;
+  Index _blockUsed{};
+
+ public:
+  Scalar value() const { return _block.topRows(_blockUsed).sum() + _totalSum.value(); }
+
+  void operator+=(Scalar increment) {
+    _block(_blockUsed++, 0) = increment;
+    if (_blockUsed == Width) {
+      _totalSum += _block.sum();
+      _blockUsed = 0;
+    }
+  }
+};
+
+/**
+ * @brief computes an accurate dot product on two sparse vectors
+ *
+ * Uses an accurate summation algorithm for the accumulator in order to
+ * compute an accurate dot product for two sparse vectors.
+ *
+ */
+template <typename Derived, typename OtherDerived>
+typename Derived::Scalar accurateDot(const SparseMatrixBase<Derived>& A, const SparseMatrixBase<OtherDerived>& other) {
+  typedef typename Derived::Scalar Scalar;
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
+  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived, OtherDerived)
+  static_assert(std::is_same<Scalar, typename OtherDerived::Scalar>::value, "mismatched types");
+
+  internal::evaluator<Derived> thisEval(A.derived());
+  typename Derived::ReverseInnerIterator i(thisEval, 0);
+
+  internal::evaluator<OtherDerived> otherEval(other.derived());
+  typename OtherDerived::ReverseInnerIterator j(otherEval, 0);
+
+  FABSum<Scalar> res;
+  while (i && j) {
+    if (i.index() == j.index()) {
+      res += numext::conj(i.value()) * j.value();
+      --i;
+      --j;
+    } else if (i.index() > j.index())
+      --i;
+    else
+      --j;
+  }
+  return res.value();
+}
+
+/**
+ * @brief calculate sparse subset of inverse of sparse matrix
+ *
+ * This class returns a sparse subset of the inverse of the input matrix.
+ * The nonzeros correspond to the nonzeros of the input, plus any additional
+ * elements required due to fill-in of the internal LU factorization. This is
+ * minimized by applying a fill-reducing permutation as part of the LU
+ * factorization.
+ *
+ * If there are specific entries of the input matrix which you need inverse
+ * values for, which are zero for the input, you need to insert entries into
+ * the input sparse matrix for them to be calculated.
+ *
+ * Due to the sensitive nature of matrix inversion, particularly on large
+ * matrices which are made possible via sparsity, high accuracy dot products
+ * based on Kahan summation are used to reduce numerical error. If you still
+ * encounter numerical errors you may wish to equilibrate your matrix before
+ * calculating the inverse, as well as making sure it is actually full rank.
+ */
+template <typename Scalar>
+class SparseInverse {
+ public:
+  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
+  typedef SparseMatrix<Scalar, RowMajor> RowMatrixType;
+
+  SparseInverse() {}
+
+  /**
+   * @brief This Constructor is for if you already have a factored SparseLU and would like to use it to calculate a
+   * sparse inverse.
+   *
+   * Just call this constructor with your already factored SparseLU class and you can directly call the .inverse()
+   * method to get the result.
+   */
+  SparseInverse(const SparseLU<MatrixType>& slu) { _result = computeInverse(slu); }
+
+  /**
+   * @brief Calculate the sparse inverse from a given sparse input
+   */
+  SparseInverse& compute(const SparseMatrix<Scalar>& A) {
+    SparseLU<MatrixType> slu;
+    slu.compute(A);
+    _result = computeInverse(slu);
+    return *this;
+  }
+
+  /**
+   * @brief return the already-calculated sparse inverse, or a 0x0 matrix if it could not be computed
+   */
+  const MatrixType& inverse() const { return _result; }
+
+  /**
+   * @brief Internal function to calculate the sparse inverse in a functional way
+   * @return A sparse inverse representation, or, if the decomposition didn't complete, a 0x0 matrix.
+   */
+  static MatrixType computeInverse(const SparseLU<MatrixType>& slu) {
+    if (slu.info() != Success) {
+      return MatrixType(0, 0);
+    }
+
+    // Extract from SparseLU and decompose into L, inverse D and U terms
+    Matrix<Scalar, Dynamic, 1> invD;
+    RowMatrixType Upper;
+    {
+      RowMatrixType DU = slu.matrixU().toSparse();
+      invD = DU.diagonal().cwiseInverse();
+      Upper = invD.asDiagonal() * DU.template triangularView<StrictlyUpper>();
+    }
+    MatrixType Lower = slu.matrixL().toSparse().template triangularView<StrictlyLower>();
+
+    // Compute the inverse and reapply the permutation matrix from the LU decomposition
+    return slu.colsPermutation().transpose() * computeInverse(Upper, invD, Lower) * slu.rowsPermutation();
+  }
+
+  /**
+   * @brief Internal function to calculate the inverse from strictly upper, diagonal and strictly lower components
+   */
+  static MatrixType computeInverse(const RowMatrixType& Upper, const Matrix<Scalar, Dynamic, 1>& inverseDiagonal,
+                                   const MatrixType& Lower) {
+    // Calculate the 'minimal set', which is the nonzeros of (L+U).transpose()
+    // It could be zeroed, but we will overwrite all non-zeros anyways.
+    MatrixType colInv = Lower.transpose().template triangularView<UnitUpper>();
+    colInv += Upper.transpose();
+
+    // We also need rowmajor representation in order to do efficient row-wise dot products
+    RowMatrixType rowInv = Upper.transpose().template triangularView<UnitLower>();
+    rowInv += Lower.transpose();
+
+    // Use the Takahashi algorithm to build the supporting elements of the inverse
+    // upwards and to the left, from the bottom right element, 1 col/row at a time
+    for (Index recurseLevel = Upper.cols() - 1; recurseLevel >= 0; recurseLevel--) {
+      const auto& col = Lower.col(recurseLevel);
+      const auto& row = Upper.row(recurseLevel);
+
+      // Calculate the inverse values for the nonzeros in this column
+      typename MatrixType::ReverseInnerIterator colIter(colInv, recurseLevel);
+      for (; recurseLevel < colIter.index(); --colIter) {
+        const Scalar element = -accurateDot(col, rowInv.row(colIter.index()));
+        colIter.valueRef() = element;
+        rowInv.coeffRef(colIter.index(), recurseLevel) = element;
+      }
+
+      // Calculate the inverse values for the nonzeros in this row
+      typename RowMatrixType::ReverseInnerIterator rowIter(rowInv, recurseLevel);
+      for (; recurseLevel < rowIter.index(); --rowIter) {
+        const Scalar element = -accurateDot(row, colInv.col(rowIter.index()));
+        rowIter.valueRef() = element;
+        colInv.coeffRef(recurseLevel, rowIter.index()) = element;
+      }
+
+      // And finally the diagonal, which corresponds to both row and col iterator now
+      const Scalar diag = inverseDiagonal(recurseLevel) - accurateDot(row, colInv.col(recurseLevel));
+      rowIter.valueRef() = diag;
+      colIter.valueRef() = diag;
+    }
+
+    return colInv;
+  }
+
+ private:
+  MatrixType _result;
+};
+
+}  // namespace Eigen
+#endif
diff --git a/contrib/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h
new file mode 100644
index 0000000..f3aca00
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h
@@ -0,0 +1,277 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BESSELFUNCTIONS_ARRAYAPI_H
+#define EIGEN_BESSELFUNCTIONS_ARRAYAPI_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \returns an expression of the coefficient-wise i0(\a x) to the given
+ * arrays.
+ *
+ * It returns the modified Bessel function of the first kind of order zero.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of i0(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_i0()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived>
+    bessel_i0(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise i0e(\a x) to the given
+ * arrays.
+ *
+ * It returns the exponentially scaled modified Bessel
+ * function of the first kind of order zero.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of i0e(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_i0e()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived>
+    bessel_i0e(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise i1(\a x) to the given
+ * arrays.
+ *
+ * It returns the modified Bessel function of the first kind of order one.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of i1(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_i1()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived>
+    bessel_i1(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise i1e(\a x) to the given
+ * arrays.
+ *
+ * It returns the exponentially scaled modified Bessel
+ * function of the first kind of order one.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of i1e(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_i1e()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived>
+    bessel_i1e(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise k0(\a x) to the given
+ * arrays.
+ *
+ * It returns the modified Bessel function of the second kind of order zero.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of k0(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_k0()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived>
+    bessel_k0(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise k0e(\a x) to the given
+ * arrays.
+ *
+ * It returns the exponentially scaled modified Bessel
+ * function of the second kind of order zero.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of k0e(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_k0e()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived>
+    bessel_k0e(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise k1(\a x) to the given
+ * arrays.
+ *
+ * It returns the modified Bessel function of the second kind of order one.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of k1(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_k1()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived>
+    bessel_k1(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise k1e(\a x) to the given
+ * arrays.
+ *
+ * It returns the exponentially scaled modified Bessel
+ * function of the second kind of order one.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of k1e(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_k1e()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived>
+    bessel_k1e(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise j0(\a x) to the given
+ * arrays.
+ *
+ * It returns the Bessel function of the first kind of order zero.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of j0(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_j0()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived>
+    bessel_j0(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise y0(\a x) to the given
+ * arrays.
+ *
+ * It returns the Bessel function of the second kind of order zero.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of y0(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_y0()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived>
+    bessel_y0(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise j1(\a x) to the given
+ * arrays.
+ *
+ * It returns the Bessel function of the first kind of order one.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of j1(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_j1()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived>
+    bessel_j1(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+/** \returns an expression of the coefficient-wise y1(\a x) to the given
+ * arrays.
+ *
+ * It returns the Bessel function of the second kind of order one.
+ *
+ * \param x is the argument
+ *
+ * \note This function supports only float and double scalar types. To support
+ * other scalar types, the user has to provide implementations of y1(T) for
+ * any scalar type T to be supported.
+ *
+ * \sa ArrayBase::bessel_y1()
+ */
+template <typename Derived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived>
+    bessel_y1(const Eigen::ArrayBase<Derived>& x) {
+  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived>(
+      x.derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BESSELFUNCTIONS_ARRAYAPI_H
diff --git a/contrib/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h
new file mode 100644
index 0000000..a44c156
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h
@@ -0,0 +1,71 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BESSELFUNCTIONS_BFLOAT16_H
+#define EIGEN_BESSELFUNCTIONS_BFLOAT16_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace numext {
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i0(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_i0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i0e(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_i0e(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i1(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_i1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i1e(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_i1e(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_j0(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_j0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_j1(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_j1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_y0(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_y0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_y1(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_y1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k0(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_k0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k0e(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_k0e(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k1(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_k1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k1e(const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::bessel_k1e(static_cast<float>(x)));
+}
+
+}  // end namespace numext
+}  // end namespace Eigen
+
+#endif  // EIGEN_BESSELFUNCTIONS_BFLOAT16_H
diff --git a/contrib/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h
new file mode 100644
index 0000000..027c234
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h
@@ -0,0 +1,324 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BESSELFUNCTIONS_FUNCTORS_H
+#define EIGEN_BESSELFUNCTIONS_FUNCTORS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+ * \brief Template functor to compute the modified Bessel function of the first
+ * kind of order zero.
+ * \sa class CwiseUnaryOp, Cwise::bessel_i0()
+ */
+template <typename Scalar>
+struct scalar_bessel_i0_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_i0;
+    return bessel_i0(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i0(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_i0_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=20 is computed.
+    // The cost is N multiplications and 2N additions. We also add
+    // the cost of an additional exp over i0e.
+    Cost = 28 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the exponentially scaled modified Bessel
+ * function of the first kind of order zero
+ * \sa class CwiseUnaryOp, Cwise::bessel_i0e()
+ */
+template <typename Scalar>
+struct scalar_bessel_i0e_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_i0e;
+    return bessel_i0e(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i0e(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_i0e_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=20 is computed.
+    // The cost is N multiplications and 2N additions.
+    Cost = 20 * NumTraits<Scalar>::MulCost + 40 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the modified Bessel function of the first
+ * kind of order one
+ * \sa class CwiseUnaryOp, Cwise::bessel_i1()
+ */
+template <typename Scalar>
+struct scalar_bessel_i1_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_i1;
+    return bessel_i1(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i1(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_i1_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=20 is computed.
+    // The cost is N multiplications and 2N additions. We also add
+    // the cost of an additional exp over i1e.
+    Cost = 28 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the exponentially scaled modified Bessel
+ * function of the first kind of order one
+ * \sa class CwiseUnaryOp, Cwise::bessel_i1e()
+ */
+template <typename Scalar>
+struct scalar_bessel_i1e_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_i1e;
+    return bessel_i1e(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i1e(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_i1e_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=20 is computed.
+    // The cost is N multiplications and 2N additions.
+    Cost = 20 * NumTraits<Scalar>::MulCost + 40 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Bessel function of the first kind of
+ * order zero
+ * \sa class CwiseUnaryOp, Cwise::bessel_j0()
+ */
+template <typename Scalar>
+struct scalar_bessel_j0_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_j0;
+    return bessel_j0(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_j0(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_j0_op<Scalar> > {
+  enum {
+    // 6 polynomial of order ~N=8 is computed.
+    // The cost is N multiplications and N additions each, along with a
+    // sine, cosine and rsqrt cost.
+    Cost = 63 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Bessel function of the second kind of
+ * order zero
+ * \sa class CwiseUnaryOp, Cwise::bessel_y0()
+ */
+template <typename Scalar>
+struct scalar_bessel_y0_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_y0;
+    return bessel_y0(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_y0(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_y0_op<Scalar> > {
+  enum {
+    // 6 polynomial of order ~N=8 is computed.
+    // The cost is N multiplications and N additions each, along with a
+    // sine, cosine, rsqrt and j0 cost.
+    Cost = 126 * NumTraits<Scalar>::MulCost + 96 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Bessel function of the first kind of
+ * order one
+ * \sa class CwiseUnaryOp, Cwise::bessel_j1()
+ */
+template <typename Scalar>
+struct scalar_bessel_j1_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_j1;
+    return bessel_j1(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_j1(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_j1_op<Scalar> > {
+  enum {
+    // 6 polynomial of order ~N=8 is computed.
+    // The cost is N multiplications and N additions each, along with a
+    // sine, cosine and rsqrt cost.
+    Cost = 63 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Bessel function of the second kind of
+ * order one
+ * \sa class CwiseUnaryOp, Cwise::bessel_y1()
+ */
+template <typename Scalar>
+struct scalar_bessel_y1_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_y1;
+    return bessel_y1(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_y1(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_y1_op<Scalar> > {
+  enum {
+    // 6 polynomial of order ~N=8 is computed.
+    // The cost is N multiplications and N additions each, along with a
+    // sine, cosine, rsqrt and j1 cost.
+    Cost = 126 * NumTraits<Scalar>::MulCost + 96 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the modified Bessel function of the second
+ * kind of order zero
+ * \sa class CwiseUnaryOp, Cwise::bessel_k0()
+ */
+template <typename Scalar>
+struct scalar_bessel_k0_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_k0;
+    return bessel_k0(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k0(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_k0_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=10 is computed.
+    // The cost is N multiplications and 2N additions. In addition we compute
+    // i0, a log, exp and prsqrt and sin and cos.
+    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the exponentially scaled modified Bessel
+ * function of the second kind of order zero
+ * \sa class CwiseUnaryOp, Cwise::bessel_k0e()
+ */
+template <typename Scalar>
+struct scalar_bessel_k0e_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_k0e;
+    return bessel_k0e(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k0e(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_k0e_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=10 is computed.
+    // The cost is N multiplications and 2N additions. In addition we compute
+    // i0, a log, exp and prsqrt and sin and cos.
+    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the modified Bessel function of the
+ * second kind of order one
+ * \sa class CwiseUnaryOp, Cwise::bessel_k1()
+ */
+template <typename Scalar>
+struct scalar_bessel_k1_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_k1;
+    return bessel_k1(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k1(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_k1_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=10 is computed.
+    // The cost is N multiplications and 2N additions. In addition we compute
+    // i1, a log, exp and prsqrt and sin and cos.
+    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the exponentially scaled modified Bessel
+ * function of the second kind of order one
+ * \sa class CwiseUnaryOp, Cwise::bessel_k1e()
+ */
+template <typename Scalar>
+struct scalar_bessel_k1e_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    using numext::bessel_k1e;
+    return bessel_k1e(x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k1e(x); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_bessel_k1e_op<Scalar> > {
+  enum {
+    // On average, a Chebyshev polynomial of order N=10 is computed.
+    // The cost is N multiplications and 2N additions. In addition we compute
+    // i1, a log, exp and prsqrt and sin and cos.
+    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBessel
+  };
+};
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BESSELFUNCTIONS_FUNCTORS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h
new file mode 100644
index 0000000..b59ed01
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h
@@ -0,0 +1,69 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BESSELFUNCTIONS_HALF_H
+#define EIGEN_BESSELFUNCTIONS_HALF_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace numext {
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i0(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_i0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i0e(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_i0e(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i1(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_i1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i1e(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_i1e(static_cast<float>(x)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_j0(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_j0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_j1(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_j1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_y0(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_y0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_y1(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_y1(static_cast<float>(x)));
+}
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k0(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_k0(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k0e(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_k0e(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k1(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_k1(static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k1e(const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::bessel_k1e(static_cast<float>(x)));
+}
+
+}  // end namespace numext
+}  // end namespace Eigen
+
+#endif  // EIGEN_BESSELFUNCTIONS_HALF_H
diff --git a/contrib/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h
new file mode 100644
index 0000000..05690d3
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h
@@ -0,0 +1,1606 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BESSEL_FUNCTIONS_H
+#define EIGEN_BESSEL_FUNCTIONS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+//  Parts of this code are based on the Cephes Math Library.
+//
+//  Cephes Math Library Release 2.8:  June, 2000
+//  Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
+//
+//  Permission has been kindly provided by the original author
+//  to incorporate the Cephes software into the Eigen codebase:
+//
+//    From: Stephen Moshier
+//    To: Eugene Brevdo
+//    Subject: Re: Permission to wrap several cephes functions in Eigen
+//
+//    Hello Eugene,
+//
+//    Thank you for writing.
+//
+//    If your licensing is similar to BSD, the formal way that has been
+//    handled is simply to add a statement to the effect that you are incorporating
+//    the Cephes software by permission of the author.
+//
+//    Good luck with your project,
+//    Steve
+
+/****************************************************************************
+ * Implementation of Bessel function, based on Cephes                       *
+ ****************************************************************************/
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_i0e {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_i0e<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  i0ef.c
+     *
+     *  Modified Bessel function of order zero,
+     *  exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, i0ef();
+     *
+     * y = i0ef( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of order zero of the argument.
+     *
+     * The function is defined as i0e(x) = exp(-|x|) j0( ix ).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,30        100000      3.7e-7      7.0e-8
+     * See i0f().
+     *
+     */
+
+    const float A[] = {-1.30002500998624804212E-8f, 6.04699502254191894932E-8f,  -2.67079385394061173391E-7f,
+                       1.11738753912010371815E-6f,  -4.41673835845875056359E-6f, 1.64484480707288970893E-5f,
+                       -5.75419501008210370398E-5f, 1.88502885095841655729E-4f,  -5.76375574538582365885E-4f,
+                       1.63947561694133579842E-3f,  -4.32430999505057594430E-3f, 1.05464603945949983183E-2f,
+                       -2.37374148058994688156E-2f, 4.93052842396707084878E-2f,  -9.49010970480476444210E-2f,
+                       1.71620901522208775349E-1f,  -3.04682672343198398683E-1f, 6.76795274409476084995E-1f};
+
+    const float B[] = {3.39623202570838634515E-9f, 2.26666899049817806459E-8f, 2.04891858946906374183E-7f,
+                       2.89137052083475648297E-6f, 6.88975834691682398426E-5f, 3.36911647825569408990E-3f,
+                       8.04490411014108831608E-1f};
+    T y = pabs(x);
+    T y_le_eight = internal::pchebevl<T, 18>::run(pmadd(pset1<T>(0.5f), y, pset1<T>(-2.0f)), A);
+    T y_gt_eight = pmul(internal::pchebevl<T, 7>::run(psub(pdiv(pset1<T>(32.0f), y), pset1<T>(2.0f)), B), prsqrt(y));
+    // TODO: Perhaps instead check whether all packet elements are in
+    // [-8, 8] and evaluate a branch based off of that. It's possible
+    // in practice most elements are in this region.
+    return pselect(pcmp_le(y, pset1<T>(8.0f)), y_le_eight, y_gt_eight);
+  }
+};
+
+template <typename T>
+struct generic_i0e<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  i0e.c
+     *
+     *  Modified Bessel function of order zero,
+     *  exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, i0e();
+     *
+     * y = i0e( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of order zero of the argument.
+     *
+     * The function is defined as i0e(x) = exp(-|x|) j0( ix ).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,30        30000       5.4e-16     1.2e-16
+     * See i0().
+     *
+     */
+
+    const double A[] = {-4.41534164647933937950E-18, 3.33079451882223809783E-17,  -2.43127984654795469359E-16,
+                        1.71539128555513303061E-15,  -1.16853328779934516808E-14, 7.67618549860493561688E-14,
+                        -4.85644678311192946090E-13, 2.95505266312963983461E-12,  -1.72682629144155570723E-11,
+                        9.67580903537323691224E-11,  -5.18979560163526290666E-10, 2.65982372468238665035E-9,
+                        -1.30002500998624804212E-8,  6.04699502254191894932E-8,   -2.67079385394061173391E-7,
+                        1.11738753912010371815E-6,   -4.41673835845875056359E-6,  1.64484480707288970893E-5,
+                        -5.75419501008210370398E-5,  1.88502885095841655729E-4,   -5.76375574538582365885E-4,
+                        1.63947561694133579842E-3,   -4.32430999505057594430E-3,  1.05464603945949983183E-2,
+                        -2.37374148058994688156E-2,  4.93052842396707084878E-2,   -9.49010970480476444210E-2,
+                        1.71620901522208775349E-1,   -3.04682672343198398683E-1,  6.76795274409476084995E-1};
+    const double B[] = {-7.23318048787475395456E-18, -4.83050448594418207126E-18, 4.46562142029675999901E-17,
+                        3.46122286769746109310E-17,  -2.82762398051658348494E-16, -3.42548561967721913462E-16,
+                        1.77256013305652638360E-15,  3.81168066935262242075E-15,  -9.55484669882830764870E-15,
+                        -4.15056934728722208663E-14, 1.54008621752140982691E-14,  3.85277838274214270114E-13,
+                        7.18012445138366623367E-13,  -1.79417853150680611778E-12, -1.32158118404477131188E-11,
+                        -3.14991652796324136454E-11, 1.18891471078464383424E-11,  4.94060238822496958910E-10,
+                        3.39623202570838634515E-9,   2.26666899049817806459E-8,   2.04891858946906374183E-7,
+                        2.89137052083475648297E-6,   6.88975834691682398426E-5,   3.36911647825569408990E-3,
+                        8.04490411014108831608E-1};
+    T y = pabs(x);
+    T y_le_eight = internal::pchebevl<T, 30>::run(pmadd(pset1<T>(0.5), y, pset1<T>(-2.0)), A);
+    T y_gt_eight = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(32.0), y), pset1<T>(2.0)), B), prsqrt(y));
+    // TODO: Perhaps instead check whether all packet elements are in
+    // [-8, 8] and evaluate a branch based off of that. It's possible
+    // in practice most elements are in this region.
+    return pselect(pcmp_le(y, pset1<T>(8.0)), y_le_eight, y_gt_eight);
+  }
+};
+
+template <typename T>
+struct bessel_i0e_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i0e<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_i0 {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    // Evaluating i0(x) = exp(|x|) * i0e(x) can prematurely cause intermediate overflow for large |x|
+    // i.e.  88.7228 < |x| <= 91.9008 for float
+    //      709.7827 < |x| <= 713.9869 for double
+    // Instead, use i0(x) = exp(|x|/2) * (exp(|x|/2) * i0e(x)).  Cutting |x| in half keeps the intermediate result
+    // finite for all finite results.
+    const T ax = pabs(x);
+    const T i0e = generic_i0e<T, ScalarType>::run(x);
+    const T half_exp = pexp(pmul(pset1<T>(ScalarType(0.5)), ax));
+    T scaled = pmul(half_exp, i0e);
+#if defined(__FAST_MATH__) || defined(__ASSOCIATIVE_MATH__) || EIGEN_COMP_NVHPC
+    // Unfortunately fast-math reassociates (exp(|x|/2) * exp(|x|/2)) * i0e(x) which reintroduces the overflow,
+    // so we need to tell it not to.
+    EIGEN_OPTIMIZATION_BARRIER(scaled)
+#endif
+    return pmul(half_exp, scaled);
+  }
+};
+
+template <typename T>
+struct bessel_i0_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i0<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_i1e {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_i1e<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* i1ef.c
+     *
+     *  Modified Bessel function of order one,
+     *  exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, i1ef();
+     *
+     * y = i1ef( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of order one of the argument.
+     *
+     * The function is defined as i1(x) = -i exp(-|x|) j1( ix ).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       1.5e-6      1.5e-7
+     * See i1().
+     *
+     */
+    const float A[] = {9.38153738649577178388E-9f,  -4.44505912879632808065E-8f, 2.00329475355213526229E-7f,
+                       -8.56872026469545474066E-7f, 3.47025130813767847674E-6f,  -1.32731636560394358279E-5f,
+                       4.78156510755005422638E-5f,  -1.61760815825896745588E-4f, 5.12285956168575772895E-4f,
+                       -1.51357245063125314899E-3f, 4.15642294431288815669E-3f,  -1.05640848946261981558E-2f,
+                       2.47264490306265168283E-2f,  -5.29459812080949914269E-2f, 1.02643658689847095384E-1f,
+                       -1.76416518357834055153E-1f, 2.52587186443633654823E-1f};
+
+    const float B[] = {-3.83538038596423702205E-9f, -2.63146884688951950684E-8f, -2.51223623787020892529E-7f,
+                       -3.88256480887769039346E-6f, -1.10588938762623716291E-4f, -9.76109749136146840777E-3f,
+                       7.78576235018280120474E-1f};
+
+    T y = pabs(x);
+    T y_le_eight = pmul(y, internal::pchebevl<T, 17>::run(pmadd(pset1<T>(0.5f), y, pset1<T>(-2.0f)), A));
+    T y_gt_eight = pmul(internal::pchebevl<T, 7>::run(psub(pdiv(pset1<T>(32.0f), y), pset1<T>(2.0f)), B), prsqrt(y));
+    // TODO: Perhaps instead check whether all packet elements are in
+    // [-8, 8] and evaluate a branch based off of that. It's possible
+    // in practice most elements are in this region.
+    y = pselect(pcmp_le(y, pset1<T>(8.0f)), y_le_eight, y_gt_eight);
+    return pselect(pcmp_lt(x, pset1<T>(0.0f)), pnegate(y), y);
+  }
+};
+
+template <typename T>
+struct generic_i1e<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  i1e.c
+     *
+     *  Modified Bessel function of order one,
+     *  exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, i1e();
+     *
+     * y = i1e( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of order one of the argument.
+     *
+     * The function is defined as i1(x) = -i exp(-|x|) j1( ix ).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       2.0e-15     2.0e-16
+     * See i1().
+     *
+     */
+    const double A[] = {2.77791411276104639959E-18,  -2.11142121435816608115E-17, 1.55363195773620046921E-16,
+                        -1.10559694773538630805E-15, 7.60068429473540693410E-15,  -5.04218550472791168711E-14,
+                        3.22379336594557470981E-13,  -1.98397439776494371520E-12, 1.17361862988909016308E-11,
+                        -6.66348972350202774223E-11, 3.62559028155211703701E-10,  -1.88724975172282928790E-9,
+                        9.38153738649577178388E-9,   -4.44505912879632808065E-8,  2.00329475355213526229E-7,
+                        -8.56872026469545474066E-7,  3.47025130813767847674E-6,   -1.32731636560394358279E-5,
+                        4.78156510755005422638E-5,   -1.61760815825896745588E-4,  5.12285956168575772895E-4,
+                        -1.51357245063125314899E-3,  4.15642294431288815669E-3,   -1.05640848946261981558E-2,
+                        2.47264490306265168283E-2,   -5.29459812080949914269E-2,  1.02643658689847095384E-1,
+                        -1.76416518357834055153E-1,  2.52587186443633654823E-1};
+    const double B[] = {7.51729631084210481353E-18,  4.41434832307170791151E-18,  -4.65030536848935832153E-17,
+                        -3.20952592199342395980E-17, 2.96262899764595013876E-16,  3.30820231092092828324E-16,
+                        -1.88035477551078244854E-15, -3.81440307243700780478E-15, 1.04202769841288027642E-14,
+                        4.27244001671195135429E-14,  -2.10154184277266431302E-14, -4.08355111109219731823E-13,
+                        -7.19855177624590851209E-13, 2.03562854414708950722E-12,  1.41258074366137813316E-11,
+                        3.25260358301548823856E-11,  -1.89749581235054123450E-11, -5.58974346219658380687E-10,
+                        -3.83538038596423702205E-9,  -2.63146884688951950684E-8,  -2.51223623787020892529E-7,
+                        -3.88256480887769039346E-6,  -1.10588938762623716291E-4,  -9.76109749136146840777E-3,
+                        7.78576235018280120474E-1};
+    T y = pabs(x);
+    T y_le_eight = pmul(y, internal::pchebevl<T, 29>::run(pmadd(pset1<T>(0.5), y, pset1<T>(-2.0)), A));
+    T y_gt_eight = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(32.0), y), pset1<T>(2.0)), B), prsqrt(y));
+    // TODO: Perhaps instead check whether all packet elements are in
+    // [-8, 8] and evaluate a branch based off of that. It's possible
+    // in practice most elements are in this region.
+    y = pselect(pcmp_le(y, pset1<T>(8.0)), y_le_eight, y_gt_eight);
+    return pselect(pcmp_lt(x, pset1<T>(0.0)), pnegate(y), y);
+  }
+};
+
+template <typename T>
+struct bessel_i1e_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i1e<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_i1 {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    // Evaluating i1(x) = exp(|x|) * i1e(x) can prematurely cause intermediate overflow for large |x|
+    // i.e.  88.7228 < |x| <= 91.9063 for float
+    //      709.7827 < |x| <= 713.9876 for double
+    // Instead, use i1(x) = exp(|x|/2) * (exp(|x|/2) * i1e(x)).  Cutting |x| in half keeps the intermediate result
+    // finite for all finite results.
+    const T ax = pabs(x);
+    const T i1e = generic_i1e<T, ScalarType>::run(x);
+    const T half_exp = pexp(pmul(pset1<T>(ScalarType(0.5)), ax));
+    T scaled = pmul(half_exp, i1e);
+#if defined(__FAST_MATH__) || defined(__ASSOCIATIVE_MATH__) || EIGEN_COMP_NVHPC
+    // Reassociating back to (exp(|x|/2) * exp(|x|/2)) * i1e(x) would reintroduce the overflow.
+    EIGEN_OPTIMIZATION_BARRIER(scaled)
+#endif
+    return pmul(half_exp, scaled);
+  }
+};
+
+template <typename T>
+struct bessel_i1_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i1<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_k0e {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_k0e<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  k0ef.c
+     *	Modified Bessel function, third kind, order zero,
+     *	exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, k0ef();
+     *
+     * y = k0ef( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of the third kind of order zero of the argument.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       8.1e-7      7.8e-8
+     * See k0().
+     *
+     */
+
+    const float A[] = {1.90451637722020886025E-9f, 2.53479107902614945675E-7f, 2.28621210311945178607E-5f,
+                       1.26461541144692592338E-3f, 3.59799365153615016266E-2f, 3.44289899924628486886E-1f,
+                       -5.35327393233902768720E-1f};
+
+    const float B[] = {-1.69753450938905987466E-9f, 8.57403401741422608519E-9f,  -4.66048989768794782956E-8f,
+                       2.76681363944501510342E-7f,  -1.83175552271911948767E-6f, 1.39498137188764993662E-5f,
+                       -1.28495495816278026384E-4f, 1.56988388573005337491E-3f,  -3.14481013119645005427E-2f,
+                       2.44030308206595545468E0f};
+    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A);
+    x_le_two = pmadd(generic_i0<T, float>::run(x), pnegate(plog(pmul(pset1<T>(0.5), x))), x_le_two);
+    x_le_two = pmul(pexp(x), x_le_two);
+    T x_gt_two = pmul(internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
+    return pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, pselect(pcmp_le(x, two), x_le_two, x_gt_two));
+  }
+};
+
+template <typename T>
+struct generic_k0e<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  k0e.c
+     *	Modified Bessel function, third kind, order zero,
+     *	exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, k0e();
+     *
+     * y = k0e( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of the third kind of order zero of the argument.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       1.4e-15     1.4e-16
+     * See k0().
+     *
+     */
+
+    const double A[] = {1.37446543561352307156E-16, 4.25981614279661018399E-14, 1.03496952576338420167E-11,
+                        1.90451637722020886025E-9,  2.53479107902614945675E-7,  2.28621210311945178607E-5,
+                        1.26461541144692592338E-3,  3.59799365153615016266E-2,  3.44289899924628486886E-1,
+                        -5.35327393233902768720E-1};
+    const double B[] = {5.30043377268626276149E-18,  -1.64758043015242134646E-17, 5.21039150503902756861E-17,
+                        -1.67823109680541210385E-16, 5.51205597852431940784E-16,  -1.84859337734377901440E-15,
+                        6.34007647740507060557E-15,  -2.22751332699166985548E-14, 8.03289077536357521100E-14,
+                        -2.98009692317273043925E-13, 1.14034058820847496303E-12,  -4.51459788337394416547E-12,
+                        1.85594911495471785253E-11,  -7.95748924447710747776E-11, 3.57739728140030116597E-10,
+                        -1.69753450938905987466E-9,  8.57403401741422608519E-9,   -4.66048989768794782956E-8,
+                        2.76681363944501510342E-7,   -1.83175552271911948767E-6,  1.39498137188764993662E-5,
+                        -1.28495495816278026384E-4,  1.56988388573005337491E-3,   -3.14481013119645005427E-2,
+                        2.44030308206595545468E0};
+    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = internal::pchebevl<T, 10>::run(pmadd(x, x, pset1<T>(-2.0)), A);
+    x_le_two = pmadd(generic_i0<T, double>::run(x), pmul(pset1<T>(-1.0), plog(pmul(pset1<T>(0.5), x))), x_le_two);
+    x_le_two = pmul(pexp(x), x_le_two);
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct bessel_k0e_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k0e<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_k0 {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_k0<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  k0f.c
+     *	Modified Bessel function, third kind, order zero
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, k0f();
+     *
+     * y = k0f( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns modified Bessel function of the third kind
+     * of order zero of the argument.
+     *
+     * The range is partitioned into the two intervals [0,8] and
+     * (8, infinity).  Chebyshev polynomial expansions are employed
+     * in each interval.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     * Tested at 2000 random points between 0 and 8.  Peak absolute
+     * error (relative when K0 > 1) was 1.46e-14; rms, 4.26e-15.
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       7.8e-7      8.5e-8
+     *
+     * ERROR MESSAGES:
+     *
+     *   message         condition      value returned
+     *  K0 domain          x <= 0          MAXNUM
+     *
+     */
+
+    const float A[] = {1.90451637722020886025E-9f, 2.53479107902614945675E-7f, 2.28621210311945178607E-5f,
+                       1.26461541144692592338E-3f, 3.59799365153615016266E-2f, 3.44289899924628486886E-1f,
+                       -5.35327393233902768720E-1f};
+
+    const float B[] = {-1.69753450938905987466E-9f, 8.57403401741422608519E-9f,  -4.66048989768794782956E-8f,
+                       2.76681363944501510342E-7f,  -1.83175552271911948767E-6f, 1.39498137188764993662E-5f,
+                       -1.28495495816278026384E-4f, 1.56988388573005337491E-3f,  -3.14481013119645005427E-2f,
+                       2.44030308206595545468E0f};
+    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A);
+    x_le_two = pmadd(generic_i0<T, float>::run(x), pnegate(plog(pmul(pset1<T>(0.5), x))), x_le_two);
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two =
+        pmul(pmul(pexp(pnegate(x)), internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B)), prsqrt(x));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_k0<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*
+     *
+     *	Modified Bessel function, third kind, order zero,
+     *	exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, k0();
+     *
+     * y = k0( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of the third kind of order zero of the argument.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       1.4e-15     1.4e-16
+     * See k0().
+     *
+     */
+    const double A[] = {1.37446543561352307156E-16, 4.25981614279661018399E-14, 1.03496952576338420167E-11,
+                        1.90451637722020886025E-9,  2.53479107902614945675E-7,  2.28621210311945178607E-5,
+                        1.26461541144692592338E-3,  3.59799365153615016266E-2,  3.44289899924628486886E-1,
+                        -5.35327393233902768720E-1};
+    const double B[] = {5.30043377268626276149E-18,  -1.64758043015242134646E-17, 5.21039150503902756861E-17,
+                        -1.67823109680541210385E-16, 5.51205597852431940784E-16,  -1.84859337734377901440E-15,
+                        6.34007647740507060557E-15,  -2.22751332699166985548E-14, 8.03289077536357521100E-14,
+                        -2.98009692317273043925E-13, 1.14034058820847496303E-12,  -4.51459788337394416547E-12,
+                        1.85594911495471785253E-11,  -7.95748924447710747776E-11, 3.57739728140030116597E-10,
+                        -1.69753450938905987466E-9,  8.57403401741422608519E-9,   -4.66048989768794782956E-8,
+                        2.76681363944501510342E-7,   -1.83175552271911948767E-6,  1.39498137188764993662E-5,
+                        -1.28495495816278026384E-4,  1.56988388573005337491E-3,   -3.14481013119645005427E-2,
+                        2.44030308206595545468E0};
+    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = internal::pchebevl<T, 10>::run(pmadd(x, x, pset1<T>(-2.0)), A);
+    x_le_two = pmadd(generic_i0<T, double>::run(x), pnegate(plog(pmul(pset1<T>(0.5), x))), x_le_two);
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two = pmul(pmul(pexp(-x), internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B)), prsqrt(x));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct bessel_k0_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k0<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_k1e {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_k1e<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* k1ef.c
+     *
+     *	Modified Bessel function, third kind, order one,
+     *	exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, k1ef();
+     *
+     * y = k1ef( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of the third kind of order one of the argument:
+     *
+     *      k1e(x) = exp(x) * k1(x).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       4.9e-7      6.7e-8
+     * See k1().
+     *
+     */
+
+    const float A[] = {-2.21338763073472585583E-8f, -2.43340614156596823496E-6f, -1.73028895751305206302E-4f,
+                       -6.97572385963986435018E-3f, -1.22611180822657148235E-1f, -3.53155960776544875667E-1f,
+                       1.52530022733894777053E0f};
+    const float B[] = {2.01504975519703286596E-9f,  -1.03457624656780970260E-8f, 5.74108412545004946722E-8f,
+                       -3.50196060308781257119E-7f, 2.40648494783721712015E-6f,  -1.93619797416608296024E-5f,
+                       1.95215518471351631108E-4f,  -2.85781685962277938680E-3f, 1.03923736576817238437E-1f,
+                       2.72062619048444266945E0f};
+    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = pdiv(internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
+    x_le_two = pmadd(generic_i1<T, float>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
+    x_le_two = pmul(x_le_two, pexp(x));
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two = pmul(internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_k1e<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  k1e.c
+     *
+     *	Modified Bessel function, third kind, order one,
+     *	exponentially scaled
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, k1e();
+     *
+     * y = k1e( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns exponentially scaled modified Bessel function
+     * of the third kind of order one of the argument:
+     *
+     *      k1e(x) = exp(x) * k1(x).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       7.8e-16     1.2e-16
+     * See k1().
+     *
+     */
+    const double A[] = {-7.02386347938628759343E-18, -2.42744985051936593393E-15, -6.66690169419932900609E-13,
+                        -1.41148839263352776110E-10, -2.21338763073472585583E-8,  -2.43340614156596823496E-6,
+                        -1.73028895751305206302E-4,  -6.97572385963986435018E-3,  -1.22611180822657148235E-1,
+                        -3.53155960776544875667E-1,  1.52530022733894777053E0};
+    const double B[] = {-5.75674448366501715755E-18, 1.79405087314755922667E-17,  -5.68946255844285935196E-17,
+                        1.83809354436663880070E-16,  -6.05704724837331885336E-16, 2.03870316562433424052E-15,
+                        -7.01983709041831346144E-15, 2.47715442448130437068E-14,  -8.97670518232499435011E-14,
+                        3.34841966607842919884E-13,  -1.28917396095102890680E-12, 5.13963967348173025100E-12,
+                        -2.12996783842756842877E-11, 9.21831518760500529508E-11,  -4.19035475934189648750E-10,
+                        2.01504975519703286596E-9,   -1.03457624656780970260E-8,  5.74108412545004946722E-8,
+                        -3.50196060308781257119E-7,  2.40648494783721712015E-6,   -1.93619797416608296024E-5,
+                        1.95215518471351631108E-4,   -2.85781685962277938680E-3,  1.03923736576817238437E-1,
+                        2.72062619048444266945E0};
+    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = pdiv(internal::pchebevl<T, 11>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
+    x_le_two = pmadd(generic_i1<T, double>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
+    x_le_two = pmul(x_le_two, pexp(x));
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct bessel_k1e_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k1e<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_k1 {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_k1<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* k1f.c
+     *	Modified Bessel function, third kind, order one
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, k1f();
+     *
+     * y = k1f( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Computes the modified Bessel function of the third kind
+     * of order one of the argument.
+     *
+     * The range is partitioned into the two intervals [0,2] and
+     * (2, infinity).  Chebyshev polynomial expansions are employed
+     * in each interval.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       4.6e-7      7.6e-8
+     *
+     * ERROR MESSAGES:
+     *
+     *   message         condition      value returned
+     * k1 domain          x <= 0          MAXNUM
+     *
+     */
+
+    const float A[] = {-2.21338763073472585583E-8f, -2.43340614156596823496E-6f, -1.73028895751305206302E-4f,
+                       -6.97572385963986435018E-3f, -1.22611180822657148235E-1f, -3.53155960776544875667E-1f,
+                       1.52530022733894777053E0f};
+    const float B[] = {2.01504975519703286596E-9f,  -1.03457624656780970260E-8f, 5.74108412545004946722E-8f,
+                       -3.50196060308781257119E-7f, 2.40648494783721712015E-6f,  -1.93619797416608296024E-5f,
+                       1.95215518471351631108E-4f,  -2.85781685962277938680E-3f, 1.03923736576817238437E-1f,
+                       2.72062619048444266945E0f};
+    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = pdiv(internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
+    x_le_two = pmadd(generic_i1<T, float>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two =
+        pmul(pexp(pnegate(x)), pmul(internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x)));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_k1<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  k1.c
+     *	Modified Bessel function, third kind, order one
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, k1f();
+     *
+     * y = k1f( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Computes the modified Bessel function of the third kind
+     * of order one of the argument.
+     *
+     * The range is partitioned into the two intervals [0,2] and
+     * (2, infinity).  Chebyshev polynomial expansions are employed
+     * in each interval.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 30       30000       4.6e-7      7.6e-8
+     *
+     * ERROR MESSAGES:
+     *
+     *   message         condition      value returned
+     * k1 domain          x <= 0          MAXNUM
+     *
+     */
+    const double A[] = {-7.02386347938628759343E-18, -2.42744985051936593393E-15, -6.66690169419932900609E-13,
+                        -1.41148839263352776110E-10, -2.21338763073472585583E-8,  -2.43340614156596823496E-6,
+                        -1.73028895751305206302E-4,  -6.97572385963986435018E-3,  -1.22611180822657148235E-1,
+                        -3.53155960776544875667E-1,  1.52530022733894777053E0};
+    const double B[] = {-5.75674448366501715755E-18, 1.79405087314755922667E-17,  -5.68946255844285935196E-17,
+                        1.83809354436663880070E-16,  -6.05704724837331885336E-16, 2.03870316562433424052E-15,
+                        -7.01983709041831346144E-15, 2.47715442448130437068E-14,  -8.97670518232499435011E-14,
+                        3.34841966607842919884E-13,  -1.28917396095102890680E-12, 5.13963967348173025100E-12,
+                        -2.12996783842756842877E-11, 9.21831518760500529508E-11,  -4.19035475934189648750E-10,
+                        2.01504975519703286596E-9,   -1.03457624656780970260E-8,  5.74108412545004946722E-8,
+                        -3.50196060308781257119E-7,  2.40648494783721712015E-6,   -1.93619797416608296024E-5,
+                        1.95215518471351631108E-4,   -2.85781685962277938680E-3,  1.03923736576817238437E-1,
+                        2.72062619048444266945E0};
+    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
+    const T two = pset1<T>(2.0);
+    T x_le_two = pdiv(internal::pchebevl<T, 11>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
+    x_le_two = pmadd(generic_i1<T, double>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
+    T x_gt_two = pmul(pexp(-x), pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x)));
+    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct bessel_k1_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k1<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_j0 {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_j0<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* j0f.c
+     *	Bessel function of order zero
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, j0f();
+     *
+     * y = j0f( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of order zero of the argument.
+     *
+     * The domain is divided into the intervals [0, 2] and
+     * (2, infinity). In the first interval the following polynomial
+     * approximation is used:
+     *
+     *
+     *        2         2         2
+     * (w - r  ) (w - r  ) (w - r  ) P(w)
+     *       1         2         3
+     *
+     *            2
+     * where w = x  and the three r's are zeros of the function.
+     *
+     * In the second interval, the modulus and phase are approximated
+     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
+     * and Phase(x) = x + 1/x R(1/x^2) - pi/4.  The function is
+     *
+     *   j0(x) = Modulus(x) cos( Phase(x) ).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Absolute error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0, 2        100000      1.3e-7      3.6e-8
+     *    IEEE      2, 32       100000      1.9e-7      5.4e-8
+     *
+     */
+
+    const float JP[] = {-6.068350350393235E-008f, 6.388945720783375E-006f, -3.969646342510940E-004f,
+                        1.332913422519003E-002f, -1.729150680240724E-001f};
+    const float MO[] = {-6.838999669318810E-002f, 1.864949361379502E-001f,  -2.145007480346739E-001f,
+                        1.197549369473540E-001f,  -3.560281861530129E-003f, -4.969382655296620E-002f,
+                        -3.355424622293709E-006f, 7.978845717621440E-001f};
+    const float PH[] = {3.242077816988247E+001f,  -3.630592630518434E+001f, 1.756221482109099E+001f,
+                        -4.974978466280903E+000f, 1.001973420681837E+000f,  -1.939906941791308E-001f,
+                        6.490598792654666E-002f,  -1.249992184872738E-001f};
+    const T DR1 = pset1<T>(5.78318596294678452118f);
+    const T NEG_PIO4F = pset1<T>(-0.7853981633974483096f); /* -pi / 4 */
+    T y = pabs(x);
+    T z = pmul(y, y);
+    T y_le_two = pselect(pcmp_lt(y, pset1<T>(1.0e-3f)), pmadd(z, pset1<T>(-0.25f), pset1<T>(1.0f)),
+                         pmul(psub(z, DR1), internal::ppolevl<T, 4>::run(z, JP)));
+    T q = pdiv(pset1<T>(1.0f), y);
+    T w = prsqrt(y);
+    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO));
+    w = pmul(q, q);
+    T yn = pmadd(q, internal::ppolevl<T, 7>::run(w, PH), NEG_PIO4F);
+    T y_gt_two = pmul(p, pcos(padd(yn, y)));
+    return pselect(pcmp_le(y, pset1<T>(2.0)), y_le_two, y_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_j0<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  j0.c
+     *	Bessel function of order zero
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, j0();
+     *
+     * y = j0( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of order zero of the argument.
+     *
+     * The domain is divided into the intervals [0, 5] and
+     * (5, infinity). In the first interval the following rational
+     * approximation is used:
+     *
+     *
+     *        2         2
+     * (w - r  ) (w - r  ) P (w) / Q (w)
+     *       1         2    3       8
+     *
+     *            2
+     * where w = x  and the two r's are zeros of the function.
+     *
+     * In the second interval, the Hankel asymptotic expansion
+     * is employed with two rational functions of degree 6/6
+     * and 7/7.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Absolute error:
+     * arithmetic   domain     # trials      peak         rms
+     *    DEC       0, 30       10000       4.4e-17     6.3e-18
+     *    IEEE      0, 30       60000       4.2e-16     1.1e-16
+     *
+     */
+    const double PP[] = {7.96936729297347051624E-4, 8.28352392107440799803E-2, 1.23953371646414299388E0,
+                         5.44725003058768775090E0,  8.74716500199817011941E0,  5.30324038235394892183E0,
+                         9.99999999999999997821E-1};
+    const double PQ[] = {9.24408810558863637013E-4, 8.56288474354474431428E-2, 1.25352743901058953537E0,
+                         5.47097740330417105182E0,  8.76190883237069594232E0,  5.30605288235394617618E0,
+                         1.00000000000000000218E0};
+    const double QP[] = {-1.13663838898469149931E-2, -1.28252718670509318512E0, -1.95539544257735972385E1,
+                         -9.32060152123768231369E1,  -1.77681167980488050595E2, -1.47077505154951170175E2,
+                         -5.14105326766599330220E1,  -6.05014350600728481186E0};
+    const double QQ[] = {1.00000000000000000000E0, 6.43178256118178023184E1, 8.56430025976980587198E2,
+                         3.88240183605401609683E3, 7.24046774195652478189E3, 5.93072701187316984827E3,
+                         2.06209331660327847417E3, 2.42005740240291393179E2};
+    const double RP[] = {-4.79443220978201773821E9, 1.95617491946556577543E12, -2.49248344360967716204E14,
+                         9.70862251047306323952E15};
+    const double RQ[] = {1.00000000000000000000E0,  4.99563147152651017219E2,  1.73785401676374683123E5,
+                         4.84409658339962045305E7,  1.11855537045356834862E10, 2.11277520115489217587E12,
+                         3.10518229857422583814E14, 3.18121955943204943306E16, 1.71086294081043136091E18};
+    const T DR1 = pset1<T>(5.78318596294678452118E0);
+    const T DR2 = pset1<T>(3.04712623436620863991E1);
+    const T SQ2OPI = pset1<T>(7.9788456080286535587989E-1); /* sqrt(2 / pi) */
+    const T NEG_PIO4 = pset1<T>(-0.7853981633974483096);    /* -pi / 4 */
+
+    T y = pabs(x);
+    T z = pmul(y, y);
+    T y_le_five = pselect(pcmp_lt(y, pset1<T>(1.0e-5)), pmadd(z, pset1<T>(-0.25), pset1<T>(1.0)),
+                          pmul(pmul(psub(z, DR1), psub(z, DR2)),
+                               pdiv(internal::ppolevl<T, 3>::run(z, RP), internal::ppolevl<T, 8>::run(z, RQ))));
+    T s = pdiv(pset1<T>(25.0), z);
+    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
+    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
+    T yn = padd(y, NEG_PIO4);
+    T w = pdiv(pset1<T>(-5.0), y);
+    p = pmadd(p, pcos(yn), pmul(w, pmul(q, psin(yn))));
+    T y_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(y)));
+    return pselect(pcmp_le(y, pset1<T>(5.0)), y_le_five, y_gt_five);
+  }
+};
+
+template <typename T>
+struct bessel_j0_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_j0<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_y0 {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_y0<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* j0f.c
+     * 	Bessel function of the second kind, order zero
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, y0f();
+     *
+     * y = y0f( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of the second kind, of order
+     * zero, of the argument.
+     *
+     * The domain is divided into the intervals [0, 2] and
+     * (2, infinity). In the first interval a rational approximation
+     * R(x) is employed to compute
+     *
+     *                  2         2         2
+     * y0(x)  =  (w - r  ) (w - r  ) (w - r  ) R(x)  +  2/pi ln(x) j0(x).
+     *                 1         2         3
+     *
+     * Thus a call to j0() is required.  The three zeros are removed
+     * from R(x) to improve its numerical stability.
+     *
+     * In the second interval, the modulus and phase are approximated
+     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
+     * and Phase(x) = x + 1/x S(1/x^2) - pi/4.  Then the function is
+     *
+     *   y0(x) = Modulus(x) sin( Phase(x) ).
+     *
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *  Absolute error, when y0(x) < 1; else relative error:
+     *
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,  2       100000      2.4e-7      3.4e-8
+     *    IEEE      2, 32       100000      1.8e-7      5.3e-8
+     *
+     */
+
+    const float YP[] = {9.454583683980369E-008f, -9.413212653797057E-006f, 5.344486707214273E-004f,
+                        -1.584289289821316E-002f, 1.707584643733568E-001f};
+    const float MO[] = {-6.838999669318810E-002f, 1.864949361379502E-001f,  -2.145007480346739E-001f,
+                        1.197549369473540E-001f,  -3.560281861530129E-003f, -4.969382655296620E-002f,
+                        -3.355424622293709E-006f, 7.978845717621440E-001f};
+    const float PH[] = {3.242077816988247E+001f,  -3.630592630518434E+001f, 1.756221482109099E+001f,
+                        -4.974978466280903E+000f, 1.001973420681837E+000f,  -1.939906941791308E-001f,
+                        6.490598792654666E-002f,  -1.249992184872738E-001f};
+    const T YZ1 = pset1<T>(0.43221455686510834878f);
+    const T TWOOPI = pset1<T>(0.636619772367581343075535f); /* 2 / pi */
+    const T NEG_PIO4F = pset1<T>(-0.7853981633974483096f);  /* -pi / 4 */
+    const T NEG_MAXNUM = pset1<T>(-NumTraits<float>::infinity());
+    T z = pmul(x, x);
+    T x_le_two = pmul(TWOOPI, pmul(plog(x), generic_j0<T, float>::run(x)));
+    x_le_two = pmadd(psub(z, YZ1), internal::ppolevl<T, 4>::run(z, YP), x_le_two);
+    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), NEG_MAXNUM, x_le_two);
+    T q = pdiv(pset1<T>(1.0), x);
+    T w = prsqrt(x);
+    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO));
+    T u = pmul(q, q);
+    T xn = pmadd(q, internal::ppolevl<T, 7>::run(u, PH), NEG_PIO4F);
+    T x_gt_two = pmul(p, psin(padd(xn, x)));
+    return pselect(pcmp_le(x, pset1<T>(2.0)), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_y0<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  j0.c
+     *	Bessel function of the second kind, order zero
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, y0();
+     *
+     * y = y0( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of the second kind, of order
+     * zero, of the argument.
+     *
+     * The domain is divided into the intervals [0, 5] and
+     * (5, infinity). In the first interval a rational approximation
+     * R(x) is employed to compute
+     *   y0(x)  = R(x)  +   2 * log(x) * j0(x) / PI.
+     * Thus a call to j0() is required.
+     *
+     * In the second interval, the Hankel asymptotic expansion
+     * is employed with two rational functions of degree 6/6
+     * and 7/7.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *  Absolute error, when y0(x) < 1; else relative error:
+     *
+     * arithmetic   domain     # trials      peak         rms
+     *    DEC       0, 30        9400       7.0e-17     7.9e-18
+     *    IEEE      0, 30       30000       1.3e-15     1.6e-16
+     *
+     */
+    const double PP[] = {7.96936729297347051624E-4, 8.28352392107440799803E-2, 1.23953371646414299388E0,
+                         5.44725003058768775090E0,  8.74716500199817011941E0,  5.30324038235394892183E0,
+                         9.99999999999999997821E-1};
+    const double PQ[] = {9.24408810558863637013E-4, 8.56288474354474431428E-2, 1.25352743901058953537E0,
+                         5.47097740330417105182E0,  8.76190883237069594232E0,  5.30605288235394617618E0,
+                         1.00000000000000000218E0};
+    const double QP[] = {-1.13663838898469149931E-2, -1.28252718670509318512E0, -1.95539544257735972385E1,
+                         -9.32060152123768231369E1,  -1.77681167980488050595E2, -1.47077505154951170175E2,
+                         -5.14105326766599330220E1,  -6.05014350600728481186E0};
+    const double QQ[] = {1.00000000000000000000E0, 6.43178256118178023184E1, 8.56430025976980587198E2,
+                         3.88240183605401609683E3, 7.24046774195652478189E3, 5.93072701187316984827E3,
+                         2.06209331660327847417E3, 2.42005740240291393179E2};
+    const double YP[] = {1.55924367855235737965E4,   -1.46639295903971606143E7, 5.43526477051876500413E9,
+                         -9.82136065717911466409E11, 8.75906394395366999549E13, -3.46628303384729719441E15,
+                         4.42733268572569800351E16,  -1.84950800436986690637E16};
+    const double YQ[] = {1.00000000000000000000E0,  1.04128353664259848412E3,  6.26107330137134956842E5,
+                         2.68919633393814121987E8,  8.64002487103935000337E10, 2.02979612750105546709E13,
+                         3.17157752842975028269E15, 2.50596256172653059228E17};
+    const T SQ2OPI = pset1<T>(7.9788456080286535587989E-1); /* sqrt(2 / pi) */
+    const T TWOOPI = pset1<T>(0.636619772367581343075535);  /* 2 / pi */
+    const T NEG_PIO4 = pset1<T>(-0.7853981633974483096);    /* -pi / 4 */
+    const T NEG_MAXNUM = pset1<T>(-NumTraits<double>::infinity());
+
+    T z = pmul(x, x);
+    T x_le_five = pdiv(internal::ppolevl<T, 7>::run(z, YP), internal::ppolevl<T, 7>::run(z, YQ));
+    x_le_five = pmadd(pmul(TWOOPI, plog(x)), generic_j0<T, double>::run(x), x_le_five);
+    x_le_five = pselect(pcmp_le(x, pset1<T>(0.0)), NEG_MAXNUM, x_le_five);
+    T s = pdiv(pset1<T>(25.0), z);
+    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
+    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
+    T xn = padd(x, NEG_PIO4);
+    T w = pdiv(pset1<T>(5.0), x);
+    p = pmadd(p, psin(xn), pmul(w, pmul(q, pcos(xn))));
+    T x_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(x)));
+    return pselect(pcmp_le(x, pset1<T>(5.0)), x_le_five, x_gt_five);
+  }
+};
+
+template <typename T>
+struct bessel_y0_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_y0<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_j1 {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_j1<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* j1f.c
+     *	Bessel function of order one
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float x, y, j1f();
+     *
+     * y = j1f( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of order one of the argument.
+     *
+     * The domain is divided into the intervals [0, 2] and
+     * (2, infinity). In the first interval a polynomial approximation
+     *        2
+     * (w - r  ) x P(w)
+     *       1
+     *                     2
+     * is used, where w = x  and r is the first zero of the function.
+     *
+     * In the second interval, the modulus and phase are approximated
+     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
+     * and Phase(x) = x + 1/x R(1/x^2) - 3pi/4.  The function is
+     *
+     *   j0(x) = Modulus(x) cos( Phase(x) ).
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Absolute error:
+     * arithmetic   domain      # trials      peak       rms
+     *    IEEE      0,  2       100000       1.2e-7     2.5e-8
+     *    IEEE      2, 32       100000       2.0e-7     5.3e-8
+     *
+     *
+     */
+
+    const float JP[] = {-4.878788132172128E-009f, 6.009061827883699E-007f, -4.541343896997497E-005f,
+                        1.937383947804541E-003f, -3.405537384615824E-002f};
+    const float MO1[] = {6.913942741265801E-002f,  -2.284801500053359E-001f, 3.138238455499697E-001f,
+                         -2.102302420403875E-001f, 5.435364690523026E-003f,  1.493389585089498E-001f,
+                         4.976029650847191E-006f,  7.978845453073848E-001f};
+    const float PH1[] = {-4.497014141919556E+001f, 5.073465654089319E+001f,  -2.485774108720340E+001f,
+                         7.222973196770240E+000f,  -1.544842782180211E+000f, 3.503787691653334E-001f,
+                         -1.637986776941202E-001f, 3.749989509080821E-001f};
+    const T Z1 = pset1<T>(1.46819706421238932572E1f);
+    const T NEG_THPIO4F = pset1<T>(-2.35619449019234492885f); /* -3*pi/4 */
+
+    T y = pabs(x);
+    T z = pmul(y, y);
+    T y_le_two = pmul(psub(z, Z1), pmul(x, internal::ppolevl<T, 4>::run(z, JP)));
+    T q = pdiv(pset1<T>(1.0f), y);
+    T w = prsqrt(y);
+    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO1));
+    w = pmul(q, q);
+    T yn = pmadd(q, internal::ppolevl<T, 7>::run(w, PH1), NEG_THPIO4F);
+    T y_gt_two = pmul(p, pcos(padd(yn, y)));
+    // j1 is an odd function. This implementation differs from cephes to
+    // take this fact into account. Cephes returns -j1(x) for y > 2 range.
+    y_gt_two = pselect(pcmp_lt(x, pset1<T>(0.0f)), pnegate(y_gt_two), y_gt_two);
+    return pselect(pcmp_le(y, pset1<T>(2.0f)), y_le_two, y_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_j1<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  j1.c
+     *	Bessel function of order one
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, j1();
+     *
+     * y = j1( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of order one of the argument.
+     *
+     * The domain is divided into the intervals [0, 8] and
+     * (8, infinity). In the first interval a 24 term Chebyshev
+     * expansion is used. In the second, the asymptotic
+     * trigonometric representation is employed using two
+     * rational functions of degree 5/5.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Absolute error:
+     * arithmetic   domain      # trials      peak         rms
+     *    DEC       0, 30       10000       4.0e-17     1.1e-17
+     *    IEEE      0, 30       30000       2.6e-16     1.1e-16
+     *
+     */
+    const double PP[] = {7.62125616208173112003E-4, 7.31397056940917570436E-2, 1.12719608129684925192E0,
+                         5.11207951146807644818E0,  8.42404590141772420927E0,  5.21451598682361504063E0,
+                         1.00000000000000000254E0};
+    const double PQ[] = {5.71323128072548699714E-4, 6.88455908754495404082E-2, 1.10514232634061696926E0,
+                         5.07386386128601488557E0,  8.39985554327604159757E0,  5.20982848682361821619E0,
+                         9.99999999999999997461E-1};
+    const double QP[] = {5.10862594750176621635E-2, 4.98213872951233449420E0, 7.58238284132545283818E1,
+                         3.66779609360150777800E2,  7.10856304998926107277E2, 5.97489612400613639965E2,
+                         2.11688757100572135698E2,  2.52070205858023719784E1};
+    const double QQ[] = {1.00000000000000000000E0, 7.42373277035675149943E1, 1.05644886038262816351E3,
+                         4.98641058337653607651E3, 9.56231892404756170795E3, 7.99704160447350683650E3,
+                         2.82619278517639096600E3, 3.36093607810698293419E2};
+    const double RP[] = {-8.99971225705559398224E8, 4.52228297998194034323E11, -7.27494245221818276015E13,
+                         3.68295732863852883286E15};
+    const double RQ[] = {1.00000000000000000000E0,  6.20836478118054335476E2,  2.56987256757748830383E5,
+                         8.35146791431949253037E7,  2.21511595479792499675E10, 4.74914122079991414898E12,
+                         7.84369607876235854894E14, 8.95222336184627338078E16, 5.32278620332680085395E18};
+    const T Z1 = pset1<T>(1.46819706421238932572E1);
+    const T Z2 = pset1<T>(4.92184563216946036703E1);
+    const T NEG_THPIO4 = pset1<T>(-2.35619449019234492885); /* -3*pi/4 */
+    const T SQ2OPI = pset1<T>(7.9788456080286535587989E-1); /* sqrt(2 / pi) */
+    T y = pabs(x);
+    T z = pmul(y, y);
+    T y_le_five = pdiv(internal::ppolevl<T, 3>::run(z, RP), internal::ppolevl<T, 8>::run(z, RQ));
+    y_le_five = pmul(pmul(pmul(y_le_five, x), psub(z, Z1)), psub(z, Z2));
+    T s = pdiv(pset1<T>(25.0), z);
+    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
+    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
+    T yn = padd(y, NEG_THPIO4);
+    T w = pdiv(pset1<T>(-5.0), y);
+    p = pmadd(p, pcos(yn), pmul(w, pmul(q, psin(yn))));
+    T y_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(y)));
+    // j1 is an odd function. This implementation differs from cephes to
+    // take this fact into account. Cephes returns -j1(x) for y > 5 range.
+    y_gt_five = pselect(pcmp_lt(x, pset1<T>(0.0)), pnegate(y_gt_five), y_gt_five);
+    return pselect(pcmp_le(y, pset1<T>(5.0)), y_le_five, y_gt_five);
+  }
+};
+
+template <typename T>
+struct bessel_j1_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_j1<T>::run(x); }
+};
+
+template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
+struct generic_y1 {
+  EIGEN_STATIC_ASSERT((std::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
+};
+
+template <typename T>
+struct generic_y1<T, float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /* j1f.c
+     *	Bessel function of second kind of order one
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, y1();
+     *
+     * y = y1( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of the second kind of order one
+     * of the argument.
+     *
+     * The domain is divided into the intervals [0, 2] and
+     * (2, infinity). In the first interval a rational approximation
+     * R(x) is employed to compute
+     *
+     *                  2
+     * y0(x)  =  (w - r  ) x R(x^2)  +  2/pi (ln(x) j1(x) - 1/x) .
+     *                 1
+     *
+     * Thus a call to j1() is required.
+     *
+     * In the second interval, the modulus and phase are approximated
+     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
+     * and Phase(x) = x + 1/x S(1/x^2) - 3pi/4.  Then the function is
+     *
+     *   y0(x) = Modulus(x) sin( Phase(x) ).
+     *
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Absolute error:
+     * arithmetic   domain      # trials      peak         rms
+     *    IEEE      0,  2       100000       2.2e-7     4.6e-8
+     *    IEEE      2, 32       100000       1.9e-7     5.3e-8
+     *
+     * (error criterion relative when |y1| > 1).
+     *
+     */
+
+    const float YP[] = {8.061978323326852E-009f, -9.496460629917016E-007f, 6.719543806674249E-005f,
+                        -2.641785726447862E-003f, 4.202369946500099E-002f};
+    const float MO1[] = {6.913942741265801E-002f,  -2.284801500053359E-001f, 3.138238455499697E-001f,
+                         -2.102302420403875E-001f, 5.435364690523026E-003f,  1.493389585089498E-001f,
+                         4.976029650847191E-006f,  7.978845453073848E-001f};
+    const float PH1[] = {-4.497014141919556E+001f, 5.073465654089319E+001f,  -2.485774108720340E+001f,
+                         7.222973196770240E+000f,  -1.544842782180211E+000f, 3.503787691653334E-001f,
+                         -1.637986776941202E-001f, 3.749989509080821E-001f};
+    const T YO1 = pset1<T>(4.66539330185668857532f);
+    const T NEG_THPIO4F = pset1<T>(-2.35619449019234492885f); /* -3*pi/4 */
+    const T TWOOPI = pset1<T>(0.636619772367581343075535f);   /* 2/pi */
+    const T NEG_MAXNUM = pset1<T>(-NumTraits<float>::infinity());
+
+    T z = pmul(x, x);
+    T x_le_two = pmul(psub(z, YO1), internal::ppolevl<T, 4>::run(z, YP));
+    x_le_two = pmadd(x_le_two, x, pmul(TWOOPI, pmadd(generic_j1<T, float>::run(x), plog(x), pdiv(pset1<T>(-1.0f), x))));
+    x_le_two = pselect(pcmp_lt(x, pset1<T>(0.0f)), NEG_MAXNUM, x_le_two);
+
+    T q = pdiv(pset1<T>(1.0), x);
+    T w = prsqrt(x);
+    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO1));
+    w = pmul(q, q);
+    T xn = pmadd(q, internal::ppolevl<T, 7>::run(w, PH1), NEG_THPIO4F);
+    T x_gt_two = pmul(p, psin(padd(xn, x)));
+    return pselect(pcmp_le(x, pset1<T>(2.0)), x_le_two, x_gt_two);
+  }
+};
+
+template <typename T>
+struct generic_y1<T, double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
+    /*  j1.c
+     *	Bessel function of second kind of order one
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, y1();
+     *
+     * y = y1( x );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns Bessel function of the second kind of order one
+     * of the argument.
+     *
+     * The domain is divided into the intervals [0, 8] and
+     * (8, infinity). In the first interval a 25 term Chebyshev
+     * expansion is used, and a call to j1() is required.
+     * In the second, the asymptotic trigonometric representation
+     * is employed using two rational functions of degree 5/5.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     *                      Absolute error:
+     * arithmetic   domain      # trials      peak         rms
+     *    DEC       0, 30       10000       8.6e-17     1.3e-17
+     *    IEEE      0, 30       30000       1.0e-15     1.3e-16
+     *
+     * (error criterion relative when |y1| > 1).
+     *
+     */
+    const double PP[] = {7.62125616208173112003E-4, 7.31397056940917570436E-2, 1.12719608129684925192E0,
+                         5.11207951146807644818E0,  8.42404590141772420927E0,  5.21451598682361504063E0,
+                         1.00000000000000000254E0};
+    const double PQ[] = {5.71323128072548699714E-4, 6.88455908754495404082E-2, 1.10514232634061696926E0,
+                         5.07386386128601488557E0,  8.39985554327604159757E0,  5.20982848682361821619E0,
+                         9.99999999999999997461E-1};
+    const double QP[] = {5.10862594750176621635E-2, 4.98213872951233449420E0, 7.58238284132545283818E1,
+                         3.66779609360150777800E2,  7.10856304998926107277E2, 5.97489612400613639965E2,
+                         2.11688757100572135698E2,  2.52070205858023719784E1};
+    const double QQ[] = {1.00000000000000000000E0, 7.42373277035675149943E1, 1.05644886038262816351E3,
+                         4.98641058337653607651E3, 9.56231892404756170795E3, 7.99704160447350683650E3,
+                         2.82619278517639096600E3, 3.36093607810698293419E2};
+    const double YP[] = {1.26320474790178026440E9,   -6.47355876379160291031E11, 1.14509511541823727583E14,
+                         -8.12770255501325109621E15, 2.02439475713594898196E17,  -7.78877196265950026825E17};
+    const double YQ[] = {1.00000000000000000000E0,  5.94301592346128195359E2,  2.35564092943068577943E5,
+                         7.34811944459721705660E7,  1.87601316108706159478E10, 3.88231277496238566008E12,
+                         6.20557727146953693363E14, 6.87141087355300489866E16, 3.97270608116560655612E18};
+    const T SQ2OPI = pset1<T>(.79788456080286535588);
+    const T NEG_THPIO4 = pset1<T>(-2.35619449019234492885); /* -3*pi/4 */
+    const T TWOOPI = pset1<T>(0.636619772367581343075535);  /* 2/pi */
+    const T NEG_MAXNUM = pset1<T>(-NumTraits<double>::infinity());
+
+    T z = pmul(x, x);
+    T x_le_five = pdiv(internal::ppolevl<T, 5>::run(z, YP), internal::ppolevl<T, 8>::run(z, YQ));
+    x_le_five =
+        pmadd(x_le_five, x, pmul(TWOOPI, pmadd(generic_j1<T, double>::run(x), plog(x), pdiv(pset1<T>(-1.0), x))));
+
+    x_le_five = pselect(pcmp_le(x, pset1<T>(0.0)), NEG_MAXNUM, x_le_five);
+    T s = pdiv(pset1<T>(25.0), z);
+    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
+    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
+    T xn = padd(x, NEG_THPIO4);
+    T w = pdiv(pset1<T>(5.0), x);
+    p = pmadd(p, psin(xn), pmul(w, pmul(q, pcos(xn))));
+    T x_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(x)));
+    return pselect(pcmp_le(x, pset1<T>(5.0)), x_le_five, x_gt_five);
+  }
+};
+
+template <typename T>
+struct bessel_y1_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_y1<T>::run(x); }
+};
+
+}  // end namespace internal
+
+namespace numext {
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_i0(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_i0, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_i0, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_i0e(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_i0e, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_i0e, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_i1(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_i1, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_i1, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_i1e(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_i1e, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_i1e, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_k0(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_k0, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_k0, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_k0e(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_k0e, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_k0e, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_k1(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_k1, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_k1, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_k1e(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_k1e, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_k1e, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_j0(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_j0, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_j0, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_y0(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_y0, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_y0, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_j1(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_j1, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_j1, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto bessel_y1(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(bessel_y1, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(bessel_y1, Scalar)::run(x);
+}
+
+}  // end namespace numext
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BESSEL_FUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h
new file mode 100644
index 0000000..2685d39
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_BESSELFUNCTIONS_PACKETMATH_H
+#define EIGEN_BESSELFUNCTIONS_PACKETMATH_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal \returns the modified Bessel function of the first kind of
+ * order zero i0(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0(const Packet& x) {
+  return numext::bessel_i0(x);
+}
+
+/** \internal \returns the exponentially scaled modified Bessel function of
+ * the first kind of order zero i0e(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0e(const Packet& x) {
+  return numext::bessel_i0e(x);
+}
+
+/** \internal \returns the modified Bessel function of the first kind of
+ * order one i1(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1(const Packet& x) {
+  return numext::bessel_i1(x);
+}
+
+/** \internal \returns the exponentially scaled modified Bessel function of
+ * the first kind of order one i1e(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1e(const Packet& x) {
+  return numext::bessel_i1e(x);
+}
+
+/** \internal \returns the Bessel function of the first kind of order zero
+ * j0(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j0(const Packet& x) {
+  return numext::bessel_j0(x);
+}
+
+/** \internal \returns the Bessel function of the first kind of order one
+ * j1(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j1(const Packet& x) {
+  return numext::bessel_j1(x);
+}
+
+/** \internal \returns the Bessel function of the second kind of order zero
+ * y0(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y0(const Packet& x) {
+  return numext::bessel_y0(x);
+}
+
+/** \internal \returns the Bessel function of the second kind of order one
+ * y1(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y1(const Packet& x) {
+  return numext::bessel_y1(x);
+}
+
+/** \internal \returns the modified Bessel function of the second kind of
+ * order zero k0(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0(const Packet& x) {
+  return numext::bessel_k0(x);
+}
+
+/** \internal \returns the exponentially scaled modified Bessel function of
+ * the second kind of order zero k0e(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0e(const Packet& x) {
+  return numext::bessel_k0e(x);
+}
+
+/** \internal \returns the modified Bessel function of the second kind of
+ * order one k1(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1(const Packet& x) {
+  return numext::bessel_k1(x);
+}
+
+/** \internal \returns the exponentially scaled modified Bessel function of
+ * the second kind of order one k1e(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1e(const Packet& x) {
+  return numext::bessel_k1e(x);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_BESSELFUNCTIONS_PACKETMATH_H
diff --git a/contrib/Eigen/src/SpecialFunctions/HipVectorCompatibility.h b/contrib/Eigen/src/SpecialFunctions/HipVectorCompatibility.h
new file mode 100644
index 0000000..edb6bf0
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/HipVectorCompatibility.h
@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef HIP_VECTOR_COMPATIBILITY_H
+#define HIP_VECTOR_COMPATIBILITY_H
+
+namespace hip_impl {
+template <typename, typename, unsigned int>
+struct Scalar_accessor;
+}  // end namespace hip_impl
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+#define HIP_SCALAR_ACCESSOR_BUILDER(NAME)           \
+  template <typename T, typename U, unsigned int n> \
+  struct NAME<hip_impl::Scalar_accessor<T, U, n>> : NAME<T> {};
+
+#define HIP_SCALAR_ACCESSOR_BUILDER_IMPL(NAME)      \
+  template <typename T, typename U, unsigned int n> \
+  struct NAME##_impl<hip_impl::Scalar_accessor<T, U, n>> : NAME##_impl<T> {};
+
+#define HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(NAME)                                \
+  template <typename T, typename U, unsigned int n, IgammaComputationMode mode> \
+  struct NAME<hip_impl::Scalar_accessor<T, U, n>, mode> : NAME<T, mode> {};
+
+HIP_SCALAR_ACCESSOR_BUILDER(betainc_helper)
+HIP_SCALAR_ACCESSOR_BUILDER(incbeta_cfe)
+
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(erf)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(erfc)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(igammac)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(lgamma)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(ndtri)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(polygamma)
+
+HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(igamma_generic_impl)
+
+HIP_SCALAR_ACCESSOR_BUILDER(digamma_impl_maybe_poly)
+HIP_SCALAR_ACCESSOR_BUILDER(zeta_impl_series)
+
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_i0)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_i0e)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_i1)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_i1e)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_j0)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_j1)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_k0)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_k0e)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_k1)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_k1e)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_y0)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(bessel_y1)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(betainc)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(digamma)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(gamma_sample_der_alpha)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(igamma_der_a)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(igamma)
+HIP_SCALAR_ACCESSOR_BUILDER_IMPL(zeta)
+
+HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(igamma_series_impl)
+HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(igammac_cf_impl)
+
+#undef HIP_SCALAR_ACCESSOR_BUILDER
+#undef HIP_SCALAR_ACCESSOR_BUILDER_IMPL
+#undef HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // HIP_VECTOR_COMPATIBILITY_H
diff --git a/contrib/Eigen/src/SpecialFunctions/InternalHeaderCheck.h b/contrib/Eigen/src/SpecialFunctions/InternalHeaderCheck.h
new file mode 100644
index 0000000..cf263d2
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_MODULE_H
+#error "Please include contrib/Eigen/SpecialFunctions instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h
new file mode 100644
index 0000000..bb40d2b
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h
@@ -0,0 +1,148 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_ARRAYAPI_H
+#define EIGEN_SPECIALFUNCTIONS_ARRAYAPI_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \returns an expression of the coefficient-wise igamma(\a a, \a x) to the given arrays.
+ *
+ * This function computes the coefficient-wise incomplete gamma function.
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of igammac(T,T) for any scalar type T to be supported.
+ *
+ * \sa Eigen::igammac(), Eigen::lgamma()
+ */
+template <typename Derived, typename ExponentDerived>
+EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_op<typename Derived::Scalar>,
+                                               const Derived, const ExponentDerived>
+igamma(const Eigen::ArrayBase<Derived>& a, const Eigen::ArrayBase<ExponentDerived>& x) {
+  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_op<typename Derived::Scalar>, const Derived,
+                              const ExponentDerived>(a.derived(), x.derived());
+}
+
+/** \returns an expression of the coefficient-wise igamma_der_a(\a a, \a x) to the given arrays.
+ *
+ * This function computes the coefficient-wise derivative of the incomplete
+ * gamma function with respect to the parameter a.
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of igamma_der_a(T,T) for any scalar type T to be supported.
+ *
+ * \sa Eigen::igamma(), Eigen::lgamma()
+ */
+template <typename Derived, typename ExponentDerived>
+EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_der_a_op<typename Derived::Scalar>,
+                                               const Derived, const ExponentDerived>
+igamma_der_a(const Eigen::ArrayBase<Derived>& a, const Eigen::ArrayBase<ExponentDerived>& x) {
+  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_der_a_op<typename Derived::Scalar>, const Derived,
+                              const ExponentDerived>(a.derived(), x.derived());
+}
+
+/** \returns an expression of the coefficient-wise gamma_sample_der_alpha(\a alpha, \a sample) to the given
+ * arrays.
+ *
+ * This function computes the coefficient-wise derivative of the sample
+ * of a Gamma(alpha, 1) random variable with respect to the parameter alpha.
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of gamma_sample_der_alpha(T,T) for any scalar type T to be supported.
+ *
+ * \sa Eigen::igamma(), Eigen::lgamma()
+ */
+template <typename AlphaDerived, typename SampleDerived>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseBinaryOp<Eigen::internal::scalar_gamma_sample_der_alpha_op<typename AlphaDerived::Scalar>,
+                         const AlphaDerived, const SampleDerived>
+    gamma_sample_der_alpha(const Eigen::ArrayBase<AlphaDerived>& alpha, const Eigen::ArrayBase<SampleDerived>& sample) {
+  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_gamma_sample_der_alpha_op<typename AlphaDerived::Scalar>,
+                              const AlphaDerived, const SampleDerived>(alpha.derived(), sample.derived());
+}
+
+/** \returns an expression of the coefficient-wise igammac(\a a, \a x) to the given arrays.
+ *
+ * This function computes the coefficient-wise complementary incomplete gamma function.
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of igammac(T,T) for any scalar type T to be supported.
+ *
+ * \sa Eigen::igamma(), Eigen::lgamma()
+ */
+template <typename Derived, typename ExponentDerived>
+EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igammac_op<typename Derived::Scalar>,
+                                               const Derived, const ExponentDerived>
+igammac(const Eigen::ArrayBase<Derived>& a, const Eigen::ArrayBase<ExponentDerived>& x) {
+  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_igammac_op<typename Derived::Scalar>, const Derived,
+                              const ExponentDerived>(a.derived(), x.derived());
+}
+
+/** \returns an expression of the coefficient-wise polygamma(\a n, \a x) to the given arrays.
+ *
+ * It returns the \a n -th derivative of the digamma(psi) evaluated at \c x.
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of polygamma(T,T) for any scalar type T to be supported.
+ *
+ * \sa Eigen::digamma()
+ */
+template <typename DerivedN, typename DerivedX>
+EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>,
+                                               const DerivedN, const DerivedX>
+polygamma(const Eigen::ArrayBase<DerivedN>& n, const Eigen::ArrayBase<DerivedX>& x) {
+  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>, const DerivedN,
+                              const DerivedX>(n.derived(), x.derived());
+}
+
+/** \returns an expression of the coefficient-wise betainc(\a x, \a a, \a b) to the given arrays.
+ *
+ * This function computes the regularized incomplete beta function (integral).
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types,
+ * the user has to provide implementations of betainc(T,T,T) for any scalar type T to be supported.
+ *
+ * \sa Eigen::betainc(), Eigen::lgamma()
+ */
+template <typename ArgADerived, typename ArgBDerived, typename ArgXDerived>
+EIGEN_STRONG_INLINE const Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>,
+                                                const ArgADerived, const ArgBDerived, const ArgXDerived>
+betainc(const Eigen::ArrayBase<ArgADerived>& a, const Eigen::ArrayBase<ArgBDerived>& b,
+        const Eigen::ArrayBase<ArgXDerived>& x) {
+  return Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>, const ArgADerived,
+                               const ArgBDerived, const ArgXDerived>(a.derived(), b.derived(), x.derived());
+}
+
+/** \returns an expression of the coefficient-wise zeta(\a x, \a q) to the given arrays.
+ *
+ * It returns the Riemann zeta function of two arguments \a x and \a q:
+ *
+ * \param x is the exponent, it must be > 1
+ * \param q is the shift, it must be > 0
+ *
+ * \note This function supports only float and double scalar types. To support other scalar types, the user has
+ * to provide implementations of zeta(T,T) for any scalar type T to be supported.
+ *
+ * \sa ArrayBase::zeta()
+ */
+template <typename DerivedX, typename DerivedQ>
+EIGEN_STRONG_INLINE const
+    Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX, const DerivedQ>
+    zeta(const Eigen::ArrayBase<DerivedX>& x, const Eigen::ArrayBase<DerivedQ>& q) {
+  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX,
+                              const DerivedQ>(x.derived(), q.derived());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPECIALFUNCTIONS_ARRAYAPI_H
diff --git a/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h
new file mode 100644
index 0000000..5deb591
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h
@@ -0,0 +1,73 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_BFLOAT16_H
+#define EIGEN_SPECIALFUNCTIONS_BFLOAT16_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace numext {
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 lgamma(const Eigen::bfloat16& a) {
+  return Eigen::bfloat16(Eigen::numext::lgamma(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 digamma(const Eigen::bfloat16& a) {
+  return Eigen::bfloat16(Eigen::numext::digamma(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 zeta(const Eigen::bfloat16& x, const Eigen::bfloat16& q) {
+  return Eigen::bfloat16(Eigen::numext::zeta(static_cast<float>(x), static_cast<float>(q)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 polygamma(const Eigen::bfloat16& n, const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::polygamma(static_cast<float>(n), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 erf(const Eigen::bfloat16& a) {
+  return Eigen::bfloat16(Eigen::numext::erf(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 erfc(const Eigen::bfloat16& a) {
+  return Eigen::bfloat16(Eigen::numext::erfc(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 ndtri(const Eigen::bfloat16& a) {
+  return Eigen::bfloat16(Eigen::numext::ndtri(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 igamma(const Eigen::bfloat16& a, const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::igamma(static_cast<float>(a), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 igamma_der_a(const Eigen::bfloat16& a, const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::igamma_der_a(static_cast<float>(a), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 gamma_sample_der_alpha(const Eigen::bfloat16& alpha,
+                                                                             const Eigen::bfloat16& sample) {
+  return Eigen::bfloat16(Eigen::numext::gamma_sample_der_alpha(static_cast<float>(alpha), static_cast<float>(sample)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 igammac(const Eigen::bfloat16& a, const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::igammac(static_cast<float>(a), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 betainc(const Eigen::bfloat16& a, const Eigen::bfloat16& b,
+                                                              const Eigen::bfloat16& x) {
+  return Eigen::bfloat16(Eigen::numext::betainc(static_cast<float>(a), static_cast<float>(b), static_cast<float>(x)));
+}
+
+}  // end namespace numext
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPECIALFUNCTIONS_BFLOAT16_H
diff --git a/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h
new file mode 100644
index 0000000..6a16a2e
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h
@@ -0,0 +1,327 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_FUNCTORS_H
+#define EIGEN_SPECIALFUNCTIONS_FUNCTORS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal
+ * \brief Template functor to compute the incomplete gamma function igamma(a, x)
+ *
+ * \sa class CwiseBinaryOp, Cwise::igamma
+ */
+template <typename Scalar>
+struct scalar_igamma_op : binary_op_base<Scalar, Scalar> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a, const Scalar& x) const {
+    using numext::igamma;
+    return igamma(a, x);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& x) const {
+    return internal::pigamma(a, x);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_igamma_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 20 * NumTraits<Scalar>::MulCost + 10 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasIGamma
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the derivative of the incomplete gamma
+ * function igamma_der_a(a, x)
+ *
+ * \sa class CwiseBinaryOp, Cwise::igamma_der_a
+ */
+template <typename Scalar>
+struct scalar_igamma_der_a_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a, const Scalar& x) const {
+    using numext::igamma_der_a;
+    return igamma_der_a(a, x);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& x) const {
+    return internal::pigamma_der_a(a, x);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_igamma_der_a_op<Scalar> > {
+  enum {
+    // 2x the cost of igamma
+    Cost = 40 * NumTraits<Scalar>::MulCost + 20 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasIGammaDerA
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the derivative of the sample
+ * of a Gamma(alpha, 1) random variable with respect to the parameter alpha
+ * gamma_sample_der_alpha(alpha, sample)
+ *
+ * \sa class CwiseBinaryOp, Cwise::gamma_sample_der_alpha
+ */
+template <typename Scalar>
+struct scalar_gamma_sample_der_alpha_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& alpha, const Scalar& sample) const {
+    using numext::gamma_sample_der_alpha;
+    return gamma_sample_der_alpha(alpha, sample);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& alpha, const Packet& sample) const {
+    return internal::pgamma_sample_der_alpha(alpha, sample);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_gamma_sample_der_alpha_op<Scalar> > {
+  enum {
+    // 2x the cost of igamma, minus the lgamma cost (the lgamma cancels out)
+    Cost = 30 * NumTraits<Scalar>::MulCost + 15 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasGammaSampleDerAlpha
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the complementary incomplete gamma function igammac(a, x)
+ *
+ * \sa class CwiseBinaryOp, Cwise::igammac
+ */
+template <typename Scalar>
+struct scalar_igammac_op : binary_op_base<Scalar, Scalar> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a, const Scalar& x) const {
+    using numext::igammac;
+    return igammac(a, x);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& x) const {
+    return internal::pigammac(a, x);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_igammac_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 20 * NumTraits<Scalar>::MulCost + 10 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasIGammac
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the incomplete beta integral betainc(a, b, x)
+ *
+ */
+template <typename Scalar>
+struct scalar_betainc_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x, const Scalar& a,
+                                                                const Scalar& b) const {
+    using numext::betainc;
+    return betainc(x, a, b);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& x, const Packet& a, const Packet& b) const {
+    return internal::pbetainc(x, a, b);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_betainc_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 400 * NumTraits<Scalar>::MulCost + 400 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasBetaInc
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the natural log of the absolute
+ * value of Gamma of a scalar
+ * \sa class CwiseUnaryOp, Cwise::lgamma()
+ */
+template <typename Scalar>
+struct scalar_lgamma_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
+    using numext::lgamma;
+    return lgamma(a);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::plgamma(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_lgamma_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasLGamma
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute psi, the derivative of lgamma of a scalar.
+ * \sa class CwiseUnaryOp, Cwise::digamma()
+ */
+template <typename Scalar>
+struct scalar_digamma_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
+    using numext::digamma;
+    return digamma(a);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::pdigamma(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_digamma_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasDiGamma
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Riemann Zeta function of two arguments.
+ * \sa class CwiseUnaryOp, Cwise::zeta()
+ */
+template <typename Scalar>
+struct scalar_zeta_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x, const Scalar& q) const {
+    using numext::zeta;
+    return zeta(x, q);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x, const Packet& q) const {
+    return internal::pzeta(x, q);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_zeta_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasZeta
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the polygamma function.
+ * \sa class CwiseUnaryOp, Cwise::polygamma()
+ */
+template <typename Scalar>
+struct scalar_polygamma_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& n, const Scalar& x) const {
+    using numext::polygamma;
+    return polygamma(n, x);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& n, const Packet& x) const {
+    return internal::ppolygamma(n, x);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_polygamma_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasPolygamma
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the error function of a scalar
+ * \sa class CwiseUnaryOp, ArrayBase::erf()
+ */
+template <typename Scalar>
+struct scalar_erf_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const { return numext::erf(a); }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
+    return perf(x);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_erf_op<Scalar> > {
+  enum {
+    PacketAccess = packet_traits<Scalar>::HasErf,
+    Cost = (PacketAccess
+#ifdef EIGEN_VECTORIZE_FMA
+                // TODO(rmlarsen): Move the FMA cost model to a central location.
+                // Haswell can issue 2 add/mul/madd per cycle.
+                // 10 pmadd, 2 pmul, 1 div, 2 other
+                ? (2 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
+#else
+                ? (12 * NumTraits<Scalar>::AddCost + 12 * NumTraits<Scalar>::MulCost +
+                   scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
+#endif
+                // Assume for simplicity that this is as expensive as an exp().
+                : (functor_traits<scalar_exp_op<Scalar> >::Cost))
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Complementary Error Function
+ * of a scalar
+ * \sa class CwiseUnaryOp, Cwise::erfc()
+ */
+template <typename Scalar>
+struct scalar_erfc_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
+    using numext::erfc;
+    return erfc(a);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::perfc(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_erfc_op<Scalar> > {
+  enum {
+    // Guesstimate
+    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasErfc
+  };
+};
+
+/** \internal
+ * \brief Template functor to compute the Inverse of the normal distribution
+ * function of a scalar
+ * \sa class CwiseUnaryOp, Cwise::ndtri()
+ */
+template <typename Scalar>
+struct scalar_ndtri_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
+    using numext::ndtri;
+    return ndtri(a);
+  }
+  typedef typename packet_traits<Scalar>::type Packet;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::pndtri(a); }
+};
+template <typename Scalar>
+struct functor_traits<scalar_ndtri_op<Scalar> > {
+  enum {
+    // On average, we are evaluating rational functions with degree N=9 in the
+    // numerator and denominator. This results in 2*N additions and 2*N
+    // multiplications.
+    Cost = 18 * NumTraits<Scalar>::MulCost + 18 * NumTraits<Scalar>::AddCost,
+    PacketAccess = packet_traits<Scalar>::HasNdtri
+  };
+};
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPECIALFUNCTIONS_FUNCTORS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h
new file mode 100644
index 0000000..964f15c
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h
@@ -0,0 +1,73 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_HALF_H
+#define EIGEN_SPECIALFUNCTIONS_HALF_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace numext {
+
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half lgamma(const Eigen::half& a) {
+  return Eigen::half(Eigen::numext::lgamma(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half digamma(const Eigen::half& a) {
+  return Eigen::half(Eigen::numext::digamma(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half zeta(const Eigen::half& x, const Eigen::half& q) {
+  return Eigen::half(Eigen::numext::zeta(static_cast<float>(x), static_cast<float>(q)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half polygamma(const Eigen::half& n, const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::polygamma(static_cast<float>(n), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half erf(const Eigen::half& a) {
+  return Eigen::half(Eigen::numext::erf(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half erfc(const Eigen::half& a) {
+  return Eigen::half(Eigen::numext::erfc(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half ndtri(const Eigen::half& a) {
+  return Eigen::half(Eigen::numext::ndtri(static_cast<float>(a)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half igamma(const Eigen::half& a, const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::igamma(static_cast<float>(a), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half igamma_der_a(const Eigen::half& a, const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::igamma_der_a(static_cast<float>(a), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half gamma_sample_der_alpha(const Eigen::half& alpha,
+                                                                         const Eigen::half& sample) {
+  return Eigen::half(Eigen::numext::gamma_sample_der_alpha(static_cast<float>(alpha), static_cast<float>(sample)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half igammac(const Eigen::half& a, const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::igammac(static_cast<float>(a), static_cast<float>(x)));
+}
+template <>
+EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half betainc(const Eigen::half& a, const Eigen::half& b,
+                                                          const Eigen::half& x) {
+  return Eigen::half(Eigen::numext::betainc(static_cast<float>(a), static_cast<float>(b), static_cast<float>(x)));
+}
+
+}  // end namespace numext
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPECIALFUNCTIONS_HALF_H
diff --git a/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h
new file mode 100644
index 0000000..22db1be
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h
@@ -0,0 +1,2055 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIAL_FUNCTIONS_H
+#define EIGEN_SPECIAL_FUNCTIONS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+//  Parts of this code are based on the Cephes Math Library.
+//
+//  Cephes Math Library Release 2.8:  June, 2000
+//  Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
+//
+//  Permission has been kindly provided by the original author
+//  to incorporate the Cephes software into the Eigen codebase:
+//
+//    From: Stephen Moshier
+//    To: Eugene Brevdo
+//    Subject: Re: Permission to wrap several cephes functions in Eigen
+//
+//    Hello Eugene,
+//
+//    Thank you for writing.
+//
+//    If your licensing is similar to BSD, the formal way that has been
+//    handled is simply to add a statement to the effect that you are incorporating
+//    the Cephes software by permission of the author.
+//
+//    Good luck with your project,
+//    Steve
+
+/****************************************************************************
+ * Implementation of lgamma                                                 *
+ ****************************************************************************/
+
+template <typename Scalar>
+struct lgamma_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) {
+    EIGEN_STATIC_ASSERT((!std::is_same<Scalar, Scalar>::value), THIS_TYPE_IS_NOT_SUPPORTED)
+    return Scalar(0);
+  }
+};
+
+// Since glibc 2.19
+#if defined(__GLIBC__) && ((__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 19) || __GLIBC__ > 2) && \
+    (defined(_DEFAULT_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE))
+#define EIGEN_HAS_LGAMMA_R
+#endif
+
+// Glibc versions before 2.19
+#if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ < 19) || __GLIBC__ < 2) && \
+    (defined(_BSD_SOURCE) || defined(_SVID_SOURCE))
+#define EIGEN_HAS_LGAMMA_R
+#endif
+
+template <>
+struct lgamma_impl<float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(float x) {
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && defined(EIGEN_HAS_LGAMMA_R) && !defined(__APPLE__)
+    int dummy;
+    return ::lgammaf_r(x, &dummy);
+#elif defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::lgamma(x);
+#else
+    return ::lgammaf(x);
+#endif
+  }
+};
+
+template <>
+struct lgamma_impl<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(double x) {
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && defined(EIGEN_HAS_LGAMMA_R) && !defined(__APPLE__)
+    int dummy;
+    return ::lgamma_r(x, &dummy);
+#elif defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::lgamma(x);
+#else
+    return ::lgamma(x);
+#endif
+  }
+};
+
+#undef EIGEN_HAS_LGAMMA_R
+
+/****************************************************************************
+ * Implementation of digamma (psi), based on Cephes                         *
+ ****************************************************************************/
+
+/*
+ *
+ * Polynomial evaluation helper for the Psi (digamma) function.
+ *
+ * digamma_impl_maybe_poly::run(s) evaluates the asymptotic Psi expansion for
+ * input Scalar s, assuming s is above 10.0.
+ *
+ * If s is above a certain threshold for the given Scalar type, zero
+ * is returned.  Otherwise the polynomial is evaluated with enough
+ * coefficients for results matching Scalar machine precision.
+ *
+ *
+ */
+template <typename Scalar>
+struct digamma_impl_maybe_poly {
+  EIGEN_STATIC_ASSERT((std::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) { return Scalar(0); }
+};
+
+template <>
+struct digamma_impl_maybe_poly<float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(const float s) {
+    constexpr float A[] = {-4.16666666666666666667E-3f, 3.96825396825396825397E-3f, -8.33333333333333333333E-3f,
+                           8.33333333333333333333E-2f};
+
+    float z;
+    if (s < 1.0e8f) {
+      z = 1.0f / (s * s);
+      return z * internal::ppolevl<float, 3>::run(z, A);
+    } else
+      return 0.0f;
+  }
+};
+
+template <>
+struct digamma_impl_maybe_poly<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(const double s) {
+    constexpr double A[] = {8.33333333333333333333E-2,  -2.10927960927960927961E-2, 7.57575757575757575758E-3,
+                            -4.16666666666666666667E-3, 3.96825396825396825397E-3,  -8.33333333333333333333E-3,
+                            8.33333333333333333333E-2};
+
+    double z;
+    if (s < 1.0e17) {
+      z = 1.0 / (s * s);
+      return z * internal::ppolevl<double, 6>::run(z, A);
+    } else
+      return 0.0;
+  }
+};
+
+template <typename Scalar>
+struct digamma_impl {
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar x) {
+    /*
+     *
+     *     Psi (digamma) function (modified for Eigen)
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, y, psi();
+     *
+     * y = psi( x );
+     *
+     *
+     * DESCRIPTION:
+     *
+     *              d      -
+     *   psi(x)  =  -- ln | (x)
+     *              dx
+     *
+     * is the logarithmic derivative of the gamma function.
+     * For integer x,
+     *                   n-1
+     *                    -
+     * psi(n) = -EUL  +   >  1/k.
+     *                    -
+     *                   k=1
+     *
+     * If x is negative, it is transformed to a positive argument by the
+     * reflection formula  psi(1-x) = psi(x) + pi cot(pi x).
+     * For general positive x, the argument is made greater than 10
+     * using the recurrence  psi(x+1) = psi(x) + 1/x.
+     * Then the following asymptotic expansion is applied:
+     *
+     *                           inf.   B
+     *                            -      2k
+     * psi(x) = log(x) - 1/2x -   >   -------
+     *                            -        2k
+     *                           k=1   2k x
+     *
+     * where the B2k are Bernoulli numbers.
+     *
+     * ACCURACY (float):
+     *    Relative error (except absolute when |psi| < 1):
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,30        30000       1.3e-15     1.4e-16
+     *    IEEE      -30,0       40000       1.5e-15     2.2e-16
+     *
+     * ACCURACY (double):
+     *    Absolute error,  relative when |psi| > 1 :
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      -33,0        30000      8.2e-7      1.2e-7
+     *    IEEE      0,33        100000      7.3e-7      7.7e-8
+     *
+     * ERROR MESSAGES:
+     *     message         condition      value returned
+     * psi singularity    x integer <=0      INFINITY
+     */
+
+    Scalar p, q, nz, s, w, y;
+    bool negative = false;
+
+    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
+    const Scalar m_pi = Scalar(EIGEN_PI);
+
+    const Scalar zero = Scalar(0);
+    const Scalar one = Scalar(1);
+    const Scalar half = Scalar(0.5);
+    nz = zero;
+
+    // Near 0, psi(x) ~ -1/x - gamma.
+    // For x = +0.0: psi(+0.0) -> -infinity.
+    // For x = -0.0: psi(-0.0) -> +infinity.
+    if (x == zero) {
+      return (std::signbit(x)) ? NumTraits<Scalar>::infinity() : -NumTraits<Scalar>::infinity();
+    }
+    if (x < zero) {
+      negative = true;
+      q = x;
+      p = numext::floor(q);
+      if (p == q) {
+        return nan;
+      }
+      /* Remove the zeros of tan(m_pi x)
+       * by subtracting the nearest integer from x
+       */
+      nz = q - p;
+      if (nz != half) {
+        if (nz > half) {
+          p += one;
+          nz = q - p;
+        }
+        nz = m_pi / numext::tan(m_pi * nz);
+      } else {
+        nz = zero;
+      }
+      x = one - x;
+    }
+
+    /* use the recurrence psi(x+1) = psi(x) + 1/x. */
+    s = x;
+    w = zero;
+    while (s < Scalar(10)) {
+      w += one / s;
+      s += one;
+    }
+
+    y = digamma_impl_maybe_poly<Scalar>::run(s);
+
+    y = numext::log(s) - (half / s) - y - w;
+
+    return (negative) ? y - nz : y;
+  }
+};
+
+// Does unqualified lookup of erf/erfc succeed for T? The lookup below mirrors
+// the one at the call sites in erf_impl/erfc_impl, so it finds std::erf/std::erfc
+// and any overload visible through argument-dependent lookup.
+namespace unqualified_erf {
+EIGEN_USING_STD(erf)
+EIGEN_USING_STD(erfc)
+template <typename T>
+auto test_erf(int) -> decltype(void(erf(std::declval<const T&>())), std::true_type{});
+template <typename T>
+std::false_type test_erf(...);
+template <typename T>
+auto test_erfc(int) -> decltype(void(erfc(std::declval<const T&>())), std::true_type{});
+template <typename T>
+std::false_type test_erfc(...);
+}  // namespace unqualified_erf
+
+template <typename T>
+struct has_erf : decltype(unqualified_erf::test_erf<T>(0)) {};
+template <typename T>
+struct has_erfc : decltype(unqualified_erf::test_erfc<T>(0)) {};
+
+/***************************************************************************
+ * Implementation of erfc.
+ ****************************************************************************/
+template <typename Scalar>
+struct generic_fast_erfc {
+  template <typename T>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& x_in);
+};
+
+template <>
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erfc<float>::run(const T& x_in) {
+  constexpr float kClamp = 11.0f;
+  const T x = pmin<PropagateNaN>(pmax<PropagateNaN>(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
+
+  // erfc(x) = 1 + x * S(x^2), |x| <= 1.
+  //
+  // Coefficients for S and T generated with Rminimax command:
+  // ./ratapprox --function="erfc(x)-1" --dom='[-1,1]' --type=[11,0] --num="odd"
+  //   --numF="[SG]" --denF="[SG]" --log --dispCoeff="dec"
+  constexpr float alpha[] = {5.61802298761904239654541015625e-04, -4.91381669417023658752441406250e-03,
+                             2.67075151205062866210937500000e-02, -1.12800106406211853027343750000e-01,
+                             3.76122951507568359375000000000e-01, -1.12837910652160644531250000000e+00};
+  const T x2 = pmul(x, x);
+  const T one = pset1<T>(1.0f);
+  const T erfc_small = pmadd(x, ppolevl<T, 5>::run(x2, alpha), one);
+
+  // Return early if we don't need the more expensive approximation for any
+  // entry in a.
+  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
+  if (!predux_any(x_abs_gt_one_mask)) return erfc_small;
+
+  // erfc(x) = exp(-x^2) * 1/x * P(1/x^2) / Q(1/x^2), 1 < x < 9.
+  //
+  // Coefficients for P and Q generated with Rminimax command:
+  //   ./ratapprox --function="erfc(1/sqrt(x))*exp(1/x)/sqrt(x)"
+  //     --dom='[0.01,1]' --type=[3,4] --numF="[SG]" --denF="[SG]" --log
+  //     --dispCoeff="dec"
+  constexpr float gamma[] = {1.0208116471767425537109375e-01f, 4.2920666933059692382812500e-01f,
+                             3.2379078865051269531250000e-01f, 5.3971976041793823242187500e-02f};
+  constexpr float delta[] = {1.7251677811145782470703125e-02f, 3.9137163758277893066406250e-01f,
+                             1.0000000000000000000000000e+00f, 6.2173241376876831054687500e-01f,
+                             9.5662862062454223632812500e-02f};
+  const T x2_lo = twoprod_low(x, x, x2);
+  // Here we use that
+  //   exp(-x^2) = exp(-(x2+x2_lo)^2) ~= exp(-x2)*exp(-x2_lo) ~= exp(-x2)*(1-x2_lo)
+  // since x2_lo < kClamp * eps << 1 in the region we care about. This trick reduces the max error
+  // from 34 ulps to below 5 ulps.
+  const T exp2_hi = pexp(pnegate(x2));
+  const T z = pnmadd(exp2_hi, x2_lo, exp2_hi);
+  const T q2 = preciprocal(x2);
+  const T num = ppolevl<T, 3>::run(q2, gamma);
+  const T denom = pmul(x, ppolevl<T, 4>::run(q2, delta));
+  const T r = pdiv(num, denom);
+  const T maybe_two = pselect(pcmp_lt(x, pset1<T>(0.0f)), pset1<T>(2.0f), pset1<T>(0.0f));
+  const T erfc_large = pmadd(z, r, maybe_two);
+  return pselect(x_abs_gt_one_mask, erfc_large, erfc_small);
+}
+
+// Computes erf(x)/x for |x| <= 1. Used by both erf and erfc implementations.
+// Takes x2 = x^2 as input.
+//
+// PRECONDITION: x2 <= 1.
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T erf_over_x_double_small(const T& x2) {
+  // erf(x)/x =  S(x^2) / T(x^2), x^2 <= 1.
+  //
+  // Coefficients for S and T generated with Rminimax command:
+  //  ./ratapprox --function="erf(x)" --dom='[-1,1]' --type=[9,10]
+  //  --num="odd" --numF="[D]" --den="even" --denF="[D]" --log --dispCoeff="dec"
+  constexpr double alpha[] = {1.9493725660006057018823477644531294572516344487667083740234375e-04,
+                              1.8272566210022942682217328425053892715368419885635375976562500e-03,
+                              4.5303363351690106863856044583371840417385101318359375000000000e-02,
+                              1.4215015503619179981775744181504705920815467834472656250000000e-01,
+                              1.1283791670955125585606992899556644260883331298828125000000000e+00};
+  constexpr double beta[] = {2.0294484101083099089526257108317963684385176748037338256835938e-05,
+                             6.8117805899186819641732970609382391558028757572174072265625000e-04,
+                             1.0582026056098614921752165685120417037978768348693847656250000e-02,
+                             9.3252603143757495374188692949246615171432495117187500000000000e-02,
+                             4.5931062818368939559832142549566924571990966796875000000000000e-01,
+                             1.0};
+  const T num_small = ppolevl<T, 4>::run(x2, alpha);
+  const T denom_small = ppolevl<T, 5>::run(x2, beta);
+  return pdiv(num_small, denom_small);
+}
+
+// erfc(x) = exp(-x^2) * 1/x * P(1/x^2) / Q(1/x^2), 1 < x < 28.
+//
+// Coefficients for P and Q generated with Rminimax command:
+//  ./ratapprox --function="erfc(1/sqrt(x))*exp(1/x)/sqrt(x)"  --dom='[0.0013717,1]' --type=[9,9] --numF="[D]"
+//  --denF="[D]" --log --dispCoeff="dec"
+//
+// PRECONDITION: 1 < x < 28.
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T erfc_double_large(const T& x, const T& x2) {
+  constexpr double gamma[] = {1.5252844933226974316088642158462107545346952974796295166015625e-04,
+                              1.0909912393738931124520519233556115068495273590087890625000000e-02,
+                              1.0628604636755033252537572252549580298364162445068359375000000e-01,
+                              3.3492472973137982217295416376146022230386734008789062500000000e-01,
+                              4.5065776215933289750026347064704168587923049926757812500000000e-01,
+                              2.9433039130294824659017649537418037652969360351562500000000000e-01,
+                              9.8792676360600226170838311645638896152377128601074218750000000e-02,
+                              1.7095935395503719655962981960328761488199234008789062500000000e-02,
+                              1.4249109729504577659398023570247460156679153442382812500000000e-03,
+                              4.4567378313647954771875570045835956989321857690811157226562500e-05};
+  constexpr double delta[] = {2.041985103115789845773520028160419315099716186523437500000000e-03,
+                              5.316030659946043707142493417450168635696172714233398437500000e-02,
+                              3.426242193784684864077405563875799998641014099121093750000000e-01,
+                              8.565637124308049799026321124983951449394226074218750000000000e-01,
+                              1.000000000000000000000000000000000000000000000000000000000000e+00,
+                              5.968805280570776972126623149961233139038085937500000000000000e-01,
+                              1.890922854723317836356244470152887515723705291748046875000000e-01,
+                              3.152505418656005586885981983868987299501895904541015625000000e-02,
+                              2.565085751861882583380047861965067568235099315643310546875000e-03,
+                              7.899362131678837697403017248376499992446042597293853759765625e-05};
+  // Compute exp(-x^2).
+  const T x2_lo = twoprod_low(x, x, x2);
+  // Here we use that
+  //   exp(-x^2) = exp(-(x2+x2_lo)^2) ~= exp(-x2)*exp(-x2_lo) ~= exp(-x2)*(1-x2_lo)
+  // since x2_lo < kClamp * eps << 1 in the region we care about. This trick reduces the max error
+  // from 258 ulps to below 7 ulps.
+  const T exp2_hi = pexp(pnegate(x2));
+  const T z = pnmadd(exp2_hi, x2_lo, exp2_hi);
+  // Compute r = P / Q.
+  const T q2 = preciprocal(x2);
+  const T num_large = ppolevl<T, 9>::run(q2, gamma);
+  const T denom_large = pmul(x, ppolevl<T, 9>::run(q2, delta));
+  const T r = pdiv(num_large, denom_large);
+  const T maybe_two = pselect(pcmp_lt(x, pset1<T>(0.0)), pset1<T>(2.0), pset1<T>(0.0));
+  return pmadd(z, r, maybe_two);
+}
+
+template <>
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erfc<double>::run(const T& x_in) {
+  // Clamp x to [-28:28] beyond which erfc(x) is either two or zero (below the underflow threshold).
+  // This avoids having to deal with twoprod(x,x) producing NaN for sufficiently large x.
+  constexpr double kClamp = 28.0;
+  const T x = pmin<PropagateNaN>(pmax<PropagateNaN>(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
+
+  // For |x| < 1, we use erfc(x) = 1 - erf(x).
+  const T x2 = pmul(x, x);
+  const T one = pset1<T>(1.0);
+  const T erfc_small = pnmadd(x, erf_over_x_double_small(x2), one);
+
+  // Return early if we don't need the more expensive approximation for any
+  // entry in a.
+  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
+  if (!predux_any(x_abs_gt_one_mask)) return erfc_small;
+
+  const T erfc_large = erfc_double_large(x, x2);
+  return pselect(x_abs_gt_one_mask, erfc_large, erfc_small);
+}
+
+template <typename T>
+struct erfc_impl {
+  typedef typename unpacket_traits<T>::type Scalar;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) { return run_impl(x, std::is_same<T, Scalar>()); }
+
+ private:
+  // Packets of float/double: vectorized rational approximation.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_impl(const T& x, std::false_type) {
+    return generic_fast_erfc<Scalar>::run(x);
+  }
+  // Any other scalar type: defer to an erfc found by argument-dependent lookup
+  // (or std::erfc), keeping custom scalars on their own implementation instead
+  // of the float/double-tuned polynomials.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_impl(const T& x, std::true_type) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(T)
+    return run_scalar(x, has_erfc<T>());
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_scalar(const T& x, std::true_type) {
+    EIGEN_USING_STD(erfc);
+    return erfc(x);
+  }
+  // Reject the type here instead of letting overload resolution fail inside the
+  // call above: the approximations in this file are tuned for float and double
+  // and are not valid for an arbitrary scalar, so a scalar type that wants erfc
+  // has to supply it.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_scalar(const T& x, std::false_type) {
+    EIGEN_STATIC_ASSERT(has_erfc<T>::value, SCALAR_TYPE_MUST_PROVIDE_AN_ERFC_OVERLOAD_FOUND_BY_ADL_OR_IN_NAMESPACE_STD)
+    return x;
+  }
+};
+
+template <>
+struct erfc_impl<float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(const float x) {
+#if defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::erfc(x);
+#else
+    return generic_fast_erfc<float>::run(x);
+#endif
+  }
+};
+
+template <>
+struct erfc_impl<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(const double x) {
+#if defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::erfc(x);
+#else
+    return generic_fast_erfc<double>::run(x);
+#endif
+  }
+};
+
+/****************************************************************************
+ * Implementation of erf.
+ ****************************************************************************/
+
+template <typename Scalar>
+struct generic_fast_erf {
+  template <typename T>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& x_in);
+};
+
+/** \internal \returns the error function of \a a (coeff-wise)
+    This uses a 11/10-degree rational interpolant and is accurate to 3 ulp for
+    normalized floats.
+
+    This implementation works on both scalars and SIMD "packets".
+*/
+template <>
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erf<float>::run(const T& x) {
+  // The monomial coefficients of the numerator polynomial (odd).
+  constexpr float alpha[] = {2.123732201653183437883853912353515625e-06f, 2.861979592125862836837768554687500000e-04f,
+                             3.658048342913389205932617187500000000e-03f, 5.243302136659622192382812500000000000e-02f,
+                             1.874160766601562500000000000000000000e-01f, 1.128379106521606445312500000000000000e+00f};
+
+  // The monomial coefficients of the denominator polynomial (even).
+  constexpr float beta[] = {3.89185734093189239501953125000e-05f, 1.14329601638019084930419921875e-03f,
+                            1.47520881146192550659179687500e-02f, 1.12945675849914550781250000000e-01f,
+                            4.99425798654556274414062500000e-01f, 1.0f};
+
+  // Since the polynomials are odd/even, we need x^2.
+  // Since erf(4) == 1 in float, we clamp x^2 to 16 to avoid computing Inf/Inf below.
+  // NaN need not survive this clamp: multiplying by x below restores it.
+  const T x2 = pmin(pset1<T>(16.0f), pmul(x, x));
+
+  // Evaluate the numerator polynomial p.
+  T p = ppolevl<T, 5>::run(x2, alpha);
+  p = pmul(x, p);
+
+  // Evaluate the denominator polynomial q.
+  T q = ppolevl<T, 5>::run(x2, beta);
+  const T r = pdiv(p, q);
+
+  // Clamp to [-1:1].
+  return pmax<PropagateNaN>(pmin<PropagateNaN>(r, pset1<T>(1.0f)), pset1<T>(-1.0f));
+}
+
+template <>
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erf<double>::run(const T& x_in) {
+  // Clamp x to [-28:28] beyond which erf(x) is ±1 within double precision.
+  // This avoids NaN from twoprod and exp operations for infinite inputs.
+  constexpr double kClamp = 28.0;
+  const T x = pmin<PropagateNaN>(pmax<PropagateNaN>(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
+  T x2 = pmul(x, x);
+  T erf_small = pmul(x, erf_over_x_double_small(x2));
+
+  // Return early if we don't need the more expensive approximation for any
+  // entry in a.
+  const T one = pset1<T>(1.0);
+  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
+  if (!predux_any(x_abs_gt_one_mask)) return erf_small;
+
+  // For |x| > 1, use erf(x) = 1 - erfc(x).
+  const T erf_large = psub(one, erfc_double_large(x, x2));
+  return pselect(x_abs_gt_one_mask, erf_large, erf_small);
+}
+
+template <typename T>
+struct erf_impl {
+  typedef typename unpacket_traits<T>::type Scalar;
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) { return run_impl(x, std::is_same<T, Scalar>()); }
+
+ private:
+  // Packets of float/double: vectorized rational approximation.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_impl(const T& x, std::false_type) {
+    return generic_fast_erf<Scalar>::run(x);
+  }
+  // Any other scalar type: defer to an erf found by argument-dependent lookup
+  // (or std::erf), keeping custom scalars on their own implementation instead
+  // of the float/double-tuned polynomials.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_impl(const T& x, std::true_type) {
+    EIGEN_STATIC_ASSERT_NON_INTEGER(T)
+    return run_scalar(x, has_erf<T>());
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_scalar(const T& x, std::true_type) {
+    EIGEN_USING_STD(erf);
+    return erf(x);
+  }
+  // Reject the type here instead of letting overload resolution fail inside the
+  // call above: the approximations in this file are tuned for float and double
+  // and are not valid for an arbitrary scalar, so a scalar type that wants erf
+  // has to supply it.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run_scalar(const T& x, std::false_type) {
+    EIGEN_STATIC_ASSERT(has_erf<T>::value, SCALAR_TYPE_MUST_PROVIDE_AN_ERF_OVERLOAD_FOUND_BY_ADL_OR_IN_NAMESPACE_STD)
+    return x;
+  }
+};
+
+template <>
+struct erf_impl<float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(const float x) {
+#if defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::erf(x);
+#else
+    return generic_fast_erf<float>::run(x);
+#endif
+  }
+};
+
+template <>
+struct erf_impl<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(const double x) {
+#if defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::erf(x);
+#else
+    return generic_fast_erf<double>::run(x);
+#endif
+  }
+};
+
+/***************************************************************************
+ * Implementation of ndtri.                                                 *
+ ****************************************************************************/
+
+/* Inverse of Normal distribution function (modified for Eigen).
+ *
+ *
+ * SYNOPSIS:
+ *
+ * double x, y, ndtri();
+ *
+ * x = ndtri( y );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the argument, x, for which the area under the
+ * Gaussian probability density function (integrated from
+ * minus infinity to x) is equal to y.
+ *
+ *
+ * For small arguments 0 < y < exp(-2), the program computes
+ * z = sqrt( -2.0 * log(y) );  then the approximation is
+ * x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z).
+ * There are two rational functions P/Q, one for 0 < y < exp(-32)
+ * and the other for y up to exp(-2).  For larger arguments,
+ * w = y - 0.5, and  x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)).
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain        # trials      peak         rms
+ *    DEC      0.125, 1         5500       9.5e-17     2.1e-17
+ *    DEC      6e-39, 0.135     3500       5.7e-17     1.3e-17
+ *    IEEE     0.125, 1        20000       7.2e-16     1.3e-16
+ *    IEEE     3e-308, 0.135   50000       4.6e-16     9.8e-17
+ *
+ *
+ * ERROR MESSAGES:
+ *
+ *   message         condition    value returned
+ * ndtri domain       x == 0        -INF
+ * ndtri domain       x == 1         INF
+ * ndtri domain       x < 0, x > 1   NAN
+ */
+/*
+  Cephes Math Library Release 2.2: June, 1992
+  Copyright 1985, 1987, 1992 by Stephen L. Moshier
+  Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+*/
+
+// TODO: Add a cheaper approximation for float.
+
+template <typename T, bool IsScalar = is_scalar<T>::value>
+struct flipsign_impl;
+
+template <typename T>
+struct flipsign_impl<T, false> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& should_flipsign, const T& x) {
+    const T sign_mask = psignmask<T>();
+    const T sign_bit = pand<T>(should_flipsign, sign_mask);
+    return pxor<T>(sign_bit, x);
+  }
+};
+
+template <typename T>
+struct flipsign_impl<T, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& should_flipsign, const T& x) {
+    return should_flipsign == T(0) ? x : -x;
+  }
+};
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T flipsign(const T& should_flipsign, const T& x) {
+  return flipsign_impl<T>::run(should_flipsign, x);
+}
+
+template <typename T, bool IsScalar = is_scalar<T>::value>
+struct ndtri_negative_infinity_impl;
+
+template <typename T>
+struct ndtri_negative_infinity_impl<T, false> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& positive_infinity) {
+    return por(psignmask<T>(), positive_infinity);
+  }
+};
+
+template <typename T>
+struct ndtri_negative_infinity_impl<T, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& positive_infinity) { return -positive_infinity; }
+};
+
+// We split this computation in to two so that in the scalar path
+// only one branch is evaluated (due to our template specialization of pselect
+// being an if statement.)
+
+template <typename T, typename ScalarType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_ndtri_gt_exp_neg_two(const T& b) {
+  const ScalarType p0[] = {ScalarType(-5.99633501014107895267e1), ScalarType(9.80010754185999661536e1),
+                           ScalarType(-5.66762857469070293439e1), ScalarType(1.39312609387279679503e1),
+                           ScalarType(-1.23916583867381258016e0)};
+  const ScalarType q0[] = {ScalarType(1.0),
+                           ScalarType(1.95448858338141759834e0),
+                           ScalarType(4.67627912898881538453e0),
+                           ScalarType(8.63602421390890590575e1),
+                           ScalarType(-2.25462687854119370527e2),
+                           ScalarType(2.00260212380060660359e2),
+                           ScalarType(-8.20372256168333339912e1),
+                           ScalarType(1.59056225126211695515e1),
+                           ScalarType(-1.18331621121330003142e0)};
+  const T sqrt2pi = pset1<T>(ScalarType(2.50662827463100050242e0));
+  const T half = pset1<T>(ScalarType(0.5));
+  T c, c2, ndtri_gt_exp_neg_two;
+
+  c = psub(b, half);
+  c2 = pmul(c, c);
+  ndtri_gt_exp_neg_two =
+      pmadd(c, pmul(c2, pdiv(internal::ppolevl<T, 4>::run(c2, p0), internal::ppolevl<T, 8>::run(c2, q0))), c);
+  return pmul(ndtri_gt_exp_neg_two, sqrt2pi);
+}
+
+template <typename T, typename ScalarType>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_ndtri_lt_exp_neg_two(const T& b, const T& should_flipsign) {
+  /* Approximation for interval z = sqrt(-2 log a ) between 2 and 8
+   * i.e., a between exp(-2) = .135 and exp(-32) = 1.27e-14.
+   */
+  const ScalarType p1[] = {ScalarType(4.05544892305962419923e0),   ScalarType(3.15251094599893866154e1),
+                           ScalarType(5.71628192246421288162e1),   ScalarType(4.40805073893200834700e1),
+                           ScalarType(1.46849561928858024014e1),   ScalarType(2.18663306850790267539e0),
+                           ScalarType(-1.40256079171354495875e-1), ScalarType(-3.50424626827848203418e-2),
+                           ScalarType(-8.57456785154685413611e-4)};
+  const ScalarType q1[] = {ScalarType(1.0),
+                           ScalarType(1.57799883256466749731e1),
+                           ScalarType(4.53907635128879210584e1),
+                           ScalarType(4.13172038254672030440e1),
+                           ScalarType(1.50425385692907503408e1),
+                           ScalarType(2.50464946208309415979e0),
+                           ScalarType(-1.42182922854787788574e-1),
+                           ScalarType(-3.80806407691578277194e-2),
+                           ScalarType(-9.33259480895457427372e-4)};
+  /* Approximation for interval z = sqrt(-2 log a ) between 8 and 64
+   * i.e., a between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.
+   */
+  const ScalarType p2[] = {ScalarType(3.23774891776946035970e0),  ScalarType(6.91522889068984211695e0),
+                           ScalarType(3.93881025292474443415e0),  ScalarType(1.33303460815807542389e0),
+                           ScalarType(2.01485389549179081538e-1), ScalarType(1.23716634817820021358e-2),
+                           ScalarType(3.01581553508235416007e-4), ScalarType(2.65806974686737550832e-6),
+                           ScalarType(6.23974539184983293730e-9)};
+  const ScalarType q2[] = {ScalarType(1.0),
+                           ScalarType(6.02427039364742014255e0),
+                           ScalarType(3.67983563856160859403e0),
+                           ScalarType(1.37702099489081330271e0),
+                           ScalarType(2.16236993594496635890e-1),
+                           ScalarType(1.34204006088543189037e-2),
+                           ScalarType(3.28014464682127739104e-4),
+                           ScalarType(2.89247864745380683936e-6),
+                           ScalarType(6.79019408009981274425e-9)};
+  const T eight = pset1<T>(ScalarType(8.0));
+  const T neg_two = pset1<T>(ScalarType(-2));
+  T x, x0, x1, z;
+
+  x = psqrt(pmul(neg_two, plog(b)));
+  x0 = psub(x, pdiv(plog(x), x));
+  z = preciprocal(x);
+  x1 =
+      pmul(z, pselect(pcmp_lt(x, eight), pdiv(internal::ppolevl<T, 8>::run(z, p1), internal::ppolevl<T, 8>::run(z, q1)),
+                      pdiv(internal::ppolevl<T, 8>::run(z, p2), internal::ppolevl<T, 8>::run(z, q2))));
+  return flipsign(should_flipsign, psub(x0, x1));
+}
+
+template <typename T, typename ScalarType>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T generic_ndtri(const T& a) {
+  const T maxnum = pinf<T>();
+  const T neg_maxnum = ndtri_negative_infinity_impl<T>::run(maxnum);
+
+  const T zero = pset1<T>(ScalarType(0));
+  const T one = pset1<T>(ScalarType(1));
+  // exp(-2)
+  const T exp_neg_two = pset1<T>(ScalarType(0.13533528323661269189));
+  T b, ndtri, should_flipsign;
+
+  should_flipsign = pcmp_le(a, psub(one, exp_neg_two));
+  b = pselect(should_flipsign, a, psub(one, a));
+
+  ndtri = pselect(pcmp_lt(exp_neg_two, b), generic_ndtri_gt_exp_neg_two<T, ScalarType>(b),
+                  generic_ndtri_lt_exp_neg_two<T, ScalarType>(b, should_flipsign));
+
+  return pselect(pcmp_eq(a, zero), neg_maxnum, pselect(pcmp_eq(one, a), maxnum, ndtri));
+}
+
+template <typename Scalar>
+struct ndtri_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar x) { return generic_ndtri<Scalar, Scalar>(x); }
+};
+
+/**************************************************************************************************************
+ * Implementation of igammac (complemented incomplete gamma integral), based on Cephes                       *
+ **************************************************************************************************************/
+
+// NOTE: cephes_helper is also used to implement zeta
+template <typename Scalar>
+struct cephes_helper {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar machep() {
+    eigen_assert(false && "machep not supported for this type");
+    return 0.0;
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar big() {
+    eigen_assert(false && "big not supported for this type");
+    return 0.0;
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar biginv() {
+    eigen_assert(false && "biginv not supported for this type");
+    return 0.0;
+  }
+};
+
+template <>
+struct cephes_helper<float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float machep() {
+    return NumTraits<float>::epsilon() / 2;  // 1.0 - machep == 1.0
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float big() {
+    // use epsneg (1.0 - epsneg == 1.0)
+    return 1.0f / (NumTraits<float>::epsilon() / 2);
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float biginv() {
+    // epsneg
+    return machep();
+  }
+};
+
+template <>
+struct cephes_helper<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double machep() {
+    return NumTraits<double>::epsilon() / 2;  // 1.0 - machep == 1.0
+  }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double big() { return 1.0 / NumTraits<double>::epsilon(); }
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double biginv() {
+    // inverse of eps
+    return NumTraits<double>::epsilon();
+  }
+};
+
+enum IgammaComputationMode { VALUE, DERIVATIVE, SAMPLE_DERIVATIVE };
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar main_igamma_term(Scalar a, Scalar x) {
+  /* Compute  x**a * exp(-x) / gamma(a)  */
+  Scalar logax = a * numext::log(x) - x - lgamma_impl<Scalar>::run(a);
+  if (logax < -numext::log(NumTraits<Scalar>::highest()) ||
+      // Assuming x and a aren't Nan.
+      (numext::isnan)(logax)) {
+    return Scalar(0);
+  }
+  return numext::exp(logax);
+}
+
+template <typename Scalar, IgammaComputationMode mode>
+EIGEN_DEVICE_FUNC constexpr int igamma_num_iterations() {
+  /* Returns the maximum number of internal iterations for igamma computation.
+   */
+  return mode == VALUE                         ? 2000
+         : std::is_same<Scalar, float>::value  ? 200
+         : std::is_same<Scalar, double>::value ? 500
+                                               : 2000;
+}
+
+template <typename Scalar, IgammaComputationMode mode>
+struct igammac_cf_impl {
+  /* Computes igamc(a, x) or derivative (depending on the mode)
+   * using the continued fraction expansion of the complementary
+   * incomplete Gamma function.
+   *
+   * Preconditions:
+   *   a > 0
+   *   x >= 1
+   *   x >= a
+   */
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
+    const Scalar zero = 0;
+    const Scalar one = 1;
+    const Scalar two = 2;
+    const Scalar machep = cephes_helper<Scalar>::machep();
+    const Scalar big = cephes_helper<Scalar>::big();
+    const Scalar biginv = cephes_helper<Scalar>::biginv();
+
+    if ((numext::isinf)(x)) {
+      return zero;
+    }
+
+    Scalar ax = main_igamma_term<Scalar>(a, x);
+    // This is independent of mode. If this value is zero,
+    // then the function value is zero. If the function value is zero,
+    // then we are in a neighborhood where the function value evaluates to zero,
+    // so the derivative is zero.
+    if (ax == zero) {
+      return zero;
+    }
+
+    // continued fraction
+    Scalar y = one - a;
+    Scalar z = x + y + one;
+    Scalar c = zero;
+    Scalar pkm2 = one;
+    Scalar qkm2 = x;
+    Scalar pkm1 = x + one;
+    Scalar qkm1 = z * x;
+    Scalar ans = pkm1 / qkm1;
+
+    Scalar dpkm2_da = zero;
+    Scalar dqkm2_da = zero;
+    Scalar dpkm1_da = zero;
+    Scalar dqkm1_da = -x;
+    Scalar dans_da = (dpkm1_da - ans * dqkm1_da) / qkm1;
+
+    for (int i = 0; i < igamma_num_iterations<Scalar, mode>(); i++) {
+      c += one;
+      y += one;
+      z += two;
+
+      Scalar yc = y * c;
+      Scalar pk = pkm1 * z - pkm2 * yc;
+      Scalar qk = qkm1 * z - qkm2 * yc;
+
+      Scalar dpk_da = dpkm1_da * z - pkm1 - dpkm2_da * yc + pkm2 * c;
+      Scalar dqk_da = dqkm1_da * z - qkm1 - dqkm2_da * yc + qkm2 * c;
+
+      if (qk != zero) {
+        Scalar ans_prev = ans;
+        ans = pk / qk;
+
+        Scalar dans_da_prev = dans_da;
+        dans_da = (dpk_da - ans * dqk_da) / qk;
+
+        if (mode == VALUE) {
+          if (numext::abs(ans_prev - ans) <= machep * numext::abs(ans)) {
+            break;
+          }
+        } else {
+          if (numext::abs(dans_da - dans_da_prev) <= machep) {
+            break;
+          }
+        }
+      }
+
+      pkm2 = pkm1;
+      pkm1 = pk;
+      qkm2 = qkm1;
+      qkm1 = qk;
+
+      dpkm2_da = dpkm1_da;
+      dpkm1_da = dpk_da;
+      dqkm2_da = dqkm1_da;
+      dqkm1_da = dqk_da;
+
+      if (numext::abs(pk) > big) {
+        pkm2 *= biginv;
+        pkm1 *= biginv;
+        qkm2 *= biginv;
+        qkm1 *= biginv;
+
+        dpkm2_da *= biginv;
+        dpkm1_da *= biginv;
+        dqkm2_da *= biginv;
+        dqkm1_da *= biginv;
+      }
+    }
+
+    /* Compute  x**a * exp(-x) / gamma(a)  */
+    Scalar dlogax_da = numext::log(x) - digamma_impl<Scalar>::run(a);
+    Scalar dax_da = ax * dlogax_da;
+
+    switch (mode) {
+      case VALUE:
+        return ans * ax;
+      case DERIVATIVE:
+        return ans * dax_da + dans_da * ax;
+      case SAMPLE_DERIVATIVE:
+      default:  // this is needed to suppress clang warning
+        return -(dans_da + ans * dlogax_da) * x;
+    }
+  }
+};
+
+template <typename Scalar, IgammaComputationMode mode>
+struct igamma_series_impl {
+  /* Computes igam(a, x) or its derivative (depending on the mode)
+   * using the series expansion of the incomplete Gamma function.
+   *
+   * Preconditions:
+   *   x > 0
+   *   a > 0
+   *   !(x > 1 && x > a)
+   */
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
+    const Scalar zero = 0;
+    const Scalar one = 1;
+    const Scalar machep = cephes_helper<Scalar>::machep();
+
+    Scalar ax = main_igamma_term<Scalar>(a, x);
+
+    // This is independent of mode. If this value is zero,
+    // then the function value is zero. If the function value is zero,
+    // then we are in a neighborhood where the function value evaluates to zero,
+    // so the derivative is zero.
+    if (ax == zero) {
+      return zero;
+    }
+
+    ax /= a;
+
+    /* power series */
+    Scalar r = a;
+    Scalar c = one;
+    Scalar ans = one;
+
+    Scalar dc_da = zero;
+    Scalar dans_da = zero;
+
+    for (int i = 0; i < igamma_num_iterations<Scalar, mode>(); i++) {
+      r += one;
+      Scalar term = x / r;
+      Scalar dterm_da = -x / (r * r);
+      dc_da = term * dc_da + dterm_da * c;
+      dans_da += dc_da;
+      c *= term;
+      ans += c;
+
+      if (mode == VALUE) {
+        if (c <= machep * ans) {
+          break;
+        }
+      } else {
+        if (numext::abs(dc_da) <= machep * numext::abs(dans_da)) {
+          break;
+        }
+      }
+    }
+
+    Scalar dlogax_da = numext::log(x) - digamma_impl<Scalar>::run(a + one);
+    Scalar dax_da = ax * dlogax_da;
+
+    switch (mode) {
+      case VALUE:
+        return ans * ax;
+      case DERIVATIVE:
+        return ans * dax_da + dans_da * ax;
+      case SAMPLE_DERIVATIVE:
+      default:  // this is needed to suppress clang warning
+        return -(dans_da + ans * dlogax_da) * x / a;
+    }
+  }
+};
+
+template <typename Scalar>
+struct igammac_impl {
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
+    /*  igamc()
+     *
+     *	Incomplete gamma integral (modified for Eigen)
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double a, x, y, igamc();
+     *
+     * y = igamc( a, x );
+     *
+     * DESCRIPTION:
+     *
+     * The function is defined by
+     *
+     *
+     *  igamc(a,x)   =   1 - igam(a,x)
+     *
+     *                            inf.
+     *                              -
+     *                     1       | |  -t  a-1
+     *               =   -----     |   e   t   dt.
+     *                    -      | |
+     *                   | (a)    -
+     *                             x
+     *
+     *
+     * In this implementation both arguments must be positive.
+     * The integral is evaluated by either a power series or
+     * continued fraction expansion, depending on the relative
+     * values of a and x.
+     *
+     * ACCURACY (float):
+     *
+     *                      Relative error:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,30        30000       7.8e-6      5.9e-7
+     *
+     *
+     * ACCURACY (double):
+     *
+     * Tested at random a, x.
+     *                a         x                      Relative error:
+     * arithmetic   domain   domain     # trials      peak         rms
+     *    IEEE     0.5,100   0,100      200000       1.9e-14     1.7e-15
+     *    IEEE     0.01,0.5  0,100      200000       1.4e-13     1.6e-15
+     *
+     */
+    /*
+      Cephes Math Library Release 2.2: June, 1992
+      Copyright 1985, 1987, 1992 by Stephen L. Moshier
+      Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+    */
+    const Scalar zero = 0;
+    const Scalar one = 1;
+    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
+
+    if ((x < zero) || (a <= zero)) {
+      // domain error
+      return nan;
+    }
+
+    if ((numext::isnan)(a) || (numext::isnan)(x)) {  // propagate nans
+      return nan;
+    }
+
+    if ((x < one) || (x < a)) {
+      // Clamp to [0,1] since 1-igamma can produce tiny negative values
+      // due to floating-point cancellation for extreme arguments.
+      return numext::mini(one, numext::maxi(zero, one - igamma_series_impl<Scalar, VALUE>::run(a, x)));
+    }
+
+    return igammac_cf_impl<Scalar, VALUE>::run(a, x);
+  }
+};
+
+/************************************************************************************************
+ * Implementation of igamma (incomplete gamma integral), based on Cephes                         *
+ ************************************************************************************************/
+
+template <typename Scalar, IgammaComputationMode mode>
+struct igamma_generic_impl {
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
+    /* Depending on the mode, returns
+     * - VALUE: incomplete Gamma function igamma(a, x)
+     * - DERIVATIVE: derivative of incomplete Gamma function d/da igamma(a, x)
+     * - SAMPLE_DERIVATIVE: implicit derivative of a Gamma random variable
+     * x ~ Gamma(x | a, 1), dx/da = -1 / Gamma(x | a, 1) * d igamma(a, x) / dx
+     *
+     * Derivatives are implemented by forward-mode differentiation.
+     */
+    const Scalar zero = 0;
+    const Scalar one = 1;
+    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
+
+    if (x == zero) return zero;
+
+    if ((x < zero) || (a <= zero)) {  // domain error
+      return nan;
+    }
+
+    if ((numext::isnan)(a) || (numext::isnan)(x)) {  // propagate nans
+      return nan;
+    }
+
+    if ((x > one) && (x > a)) {
+      Scalar ret = igammac_cf_impl<Scalar, mode>::run(a, x);
+      if (mode == VALUE) {
+        // Clamp to [0,1] since 1-igammac can produce tiny negative values
+        // due to floating-point cancellation for extreme arguments.
+        return numext::mini(one, numext::maxi(zero, one - ret));
+      } else {
+        return -ret;
+      }
+    }
+
+    Scalar ret = igamma_series_impl<Scalar, mode>::run(a, x);
+    if (mode == VALUE) {
+      // Clamp to [0,1] since accumulated series terms can slightly exceed 1.0
+      // due to floating-point rounding for extreme arguments.
+      return numext::mini(one, numext::maxi(zero, ret));
+    }
+    return ret;
+  }
+};
+
+template <typename Scalar>
+struct igamma_impl : igamma_generic_impl<Scalar, VALUE> {
+  /* igam()
+   * Incomplete gamma integral.
+   *
+   * The CDF of Gamma(a, 1) random variable at the point x.
+   *
+   * Accuracy estimation. For each a in [10^-2, 10^-1...10^3] we sample
+   * 50 Gamma random variables x ~ Gamma(x | a, 1), a total of 300 points.
+   * The ground truth is computed by mpmath. Mean absolute error:
+   * float: 1.26713e-05
+   * double: 2.33606e-12
+   *
+   * Cephes documentation below.
+   *
+   * SYNOPSIS:
+   *
+   * double a, x, y, igam();
+   *
+   * y = igam( a, x );
+   *
+   * DESCRIPTION:
+   *
+   * The function is defined by
+   *
+   *                           x
+   *                            -
+   *                   1       | |  -t  a-1
+   *  igam(a,x)  =   -----     |   e   t   dt.
+   *                  -      | |
+   *                 | (a)    -
+   *                           0
+   *
+   *
+   * In this implementation both arguments must be positive.
+   * The integral is evaluated by either a power series or
+   * continued fraction expansion, depending on the relative
+   * values of a and x.
+   *
+   * ACCURACY (double):
+   *
+   *                      Relative error:
+   * arithmetic   domain     # trials      peak         rms
+   *    IEEE      0,30       200000       3.6e-14     2.9e-15
+   *    IEEE      0,100      300000       9.9e-14     1.5e-14
+   *
+   *
+   * ACCURACY (float):
+   *
+   *                      Relative error:
+   * arithmetic   domain     # trials      peak         rms
+   *    IEEE      0,30        20000       7.8e-6      5.9e-7
+   *
+   */
+  /*
+    Cephes Math Library Release 2.2: June, 1992
+    Copyright 1985, 1987, 1992 by Stephen L. Moshier
+    Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+  */
+
+  /* left tail of incomplete gamma function:
+   *
+   *          inf.      k
+   *   a  -x   -       x
+   *  x  e     >   ----------
+   *           -     -
+   *          k=0   | (a+k+1)
+   *
+   */
+};
+
+template <typename Scalar>
+struct igamma_der_a_impl : igamma_generic_impl<Scalar, DERIVATIVE> {
+  /* Derivative of the incomplete Gamma function with respect to a.
+   *
+   * Computes d/da igamma(a, x) by forward differentiation of the igamma code.
+   *
+   * Accuracy estimation. For each a in [10^-2, 10^-1...10^3] we sample
+   * 50 Gamma random variables x ~ Gamma(x | a, 1), a total of 300 points.
+   * The ground truth is computed by mpmath. Mean absolute error:
+   * float: 6.17992e-07
+   * double: 4.60453e-12
+   *
+   * Reference:
+   * R. Moore. "Algorithm AS 187: Derivatives of the incomplete gamma
+   * integral". Journal of the Royal Statistical Society. 1982
+   */
+};
+
+template <typename Scalar>
+struct gamma_sample_der_alpha_impl : igamma_generic_impl<Scalar, SAMPLE_DERIVATIVE> {
+  /* Derivative of a Gamma random variable sample with respect to alpha.
+   *
+   * Consider a sample of a Gamma random variable with the concentration
+   * parameter alpha: sample ~ Gamma(alpha, 1). The reparameterization
+   * derivative that we want to compute is dsample / dalpha =
+   * d igammainv(alpha, u) / dalpha, where u = igamma(alpha, sample).
+   * However, this formula is numerically unstable and expensive, so instead
+   * we use implicit differentiation:
+   *
+   * igamma(alpha, sample) = u, where u ~ Uniform(0, 1).
+   * Apply d / dalpha to both sides:
+   * d igamma(alpha, sample) / dalpha
+   *     + d igamma(alpha, sample) / dsample * dsample/dalpha  = 0
+   * d igamma(alpha, sample) / dalpha
+   *     + Gamma(sample | alpha, 1) dsample / dalpha = 0
+   * dsample/dalpha = - (d igamma(alpha, sample) / dalpha)
+   *                   / Gamma(sample | alpha, 1)
+   *
+   * Here Gamma(sample | alpha, 1) is the PDF of the Gamma distribution
+   * (note that the derivative of the CDF w.r.t. sample is the PDF).
+   * See the reference below for more details.
+   *
+   * The derivative of igamma(alpha, sample) is computed by forward
+   * differentiation of the igamma code. Division by the Gamma PDF is performed
+   * in the same code, increasing the accuracy and speed due to cancellation
+   * of some terms.
+   *
+   * Accuracy estimation. For each alpha in [10^-2, 10^-1...10^3] we sample
+   * 50 Gamma random variables sample ~ Gamma(sample | alpha, 1), a total of 300
+   * points. The ground truth is computed by mpmath. Mean absolute error:
+   * float: 2.1686e-06
+   * double: 1.4774e-12
+   *
+   * Reference:
+   * M. Figurnov, S. Mohamed, A. Mnih "Implicit Reparameterization Gradients".
+   * 2018
+   */
+};
+
+/*****************************************************************************
+ * Implementation of Riemann zeta function of two arguments, based on Cephes *
+ *****************************************************************************/
+
+template <typename Scalar>
+struct zeta_impl_series {
+  EIGEN_STATIC_ASSERT((std::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) { return Scalar(0); }
+};
+
+template <>
+struct zeta_impl_series<float> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool run(float& a, float& b, float& s, const float x,
+                                                        const float machep) {
+    int i = 0;
+    while (i < 9) {
+      i += 1;
+      a += 1.0f;
+      b = numext::pow(a, -x);
+      s += b;
+      if (numext::abs(b / s) < machep) return true;
+    }
+
+    // Return whether we are done
+    return false;
+  }
+};
+
+template <>
+struct zeta_impl_series<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool run(double& a, double& b, double& s, const double x,
+                                                        const double machep) {
+    int i = 0;
+    while ((i < 9) || (a <= 9.0)) {
+      i += 1;
+      a += 1.0;
+      b = numext::pow(a, -x);
+      s += b;
+      if (numext::abs(b / s) < machep) return true;
+    }
+
+    // Return whether we are done
+    return false;
+  }
+};
+
+template <typename Scalar>
+struct zeta_impl {
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar x, Scalar q) {
+    /*							zeta.c
+     *
+     *	Riemann zeta function of two arguments
+     *
+     *
+     *
+     * SYNOPSIS:
+     *
+     * double x, q, y, zeta();
+     *
+     * y = zeta( x, q );
+     *
+     *
+     *
+     * DESCRIPTION:
+     *
+     *
+     *
+     *                 inf.
+     *                  -        -x
+     *   zeta(x,q)  =   >   (k+q)
+     *                  -
+     *                 k=0
+     *
+     * where x > 1 and q is not a negative integer or zero.
+     * The Euler-Maclaurin summation formula is used to obtain
+     * the expansion
+     *
+     *                n
+     *                -       -x
+     * zeta(x,q)  =   >  (k+q)
+     *                -
+     *               k=1
+     *
+     *           1-x                 inf.  B   x(x+1)...(x+2j)
+     *      (n+q)           1         -     2j
+     *  +  ---------  -  -------  +   >    --------------------
+     *        x-1              x      -                   x+2j+1
+     *                   2(n+q)      j=1       (2j)! (n+q)
+     *
+     * where the B2j are Bernoulli numbers.  Note that (see zetac.c)
+     * zeta(x,1) = zetac(x) + 1.
+     *
+     *
+     *
+     * ACCURACY:
+     *
+     * Relative error for single precision:
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,25        10000       6.9e-7      1.0e-7
+     *
+     * Large arguments may produce underflow in powf(), in which
+     * case the results are inaccurate.
+     *
+     * REFERENCE:
+     *
+     * Gradshteyn, I. S., and I. M. Ryzhik, Tables of Integrals,
+     * Series, and Products, p. 1073; Academic Press, 1980.
+     *
+     */
+
+    int i;
+    Scalar p, r, a, b, k, s, t, w;
+
+    const Scalar A[] = {
+        Scalar(12.0),
+        Scalar(-720.0),
+        Scalar(30240.0),
+        Scalar(-1209600.0),
+        Scalar(47900160.0),
+        Scalar(-1.8924375803183791606e9), /*1.307674368e12/691*/
+        Scalar(7.47242496e10),
+        Scalar(-2.950130727918164224e12),  /*1.067062284288e16/3617*/
+        Scalar(1.1646782814350067249e14),  /*5.109094217170944e18/43867*/
+        Scalar(-4.5979787224074726105e15), /*8.028576626982912e20/174611*/
+        Scalar(1.8152105401943546773e17),  /*1.5511210043330985984e23/854513*/
+        Scalar(-7.1661652561756670113e18)  /*1.6938241367317436694528e27/236364091*/
+    };
+
+    const Scalar maxnum = NumTraits<Scalar>::infinity();
+    const Scalar zero = Scalar(0.0), half = Scalar(0.5), one = Scalar(1.0);
+    const Scalar machep = cephes_helper<Scalar>::machep();
+    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
+
+    if (x == one) return maxnum;
+
+    if (x < one) {
+      return nan;
+    }
+
+    if (q <= zero) {
+      if (q == numext::floor(q)) {
+        if (numext::rint(Scalar(0.5) * x) == Scalar(0.5) * x) {
+          return maxnum;
+        } else {
+          return nan;
+        }
+      }
+      p = x;
+      r = numext::floor(p);
+      if (p != r) return nan;
+    }
+
+    /* Permit negative q but continue sum until n+q > +9 .
+     * This case should be handled by a reflection formula.
+     * If q<0 and x is an integer, there is a relation to
+     * the polygamma function.
+     */
+    s = numext::pow(q, -x);
+    a = q;
+    b = zero;
+    // Run the summation in a helper function that is specific to the floating precision
+    if (zeta_impl_series<Scalar>::run(a, b, s, x, machep)) {
+      return s;
+    }
+
+    // If b is zero, then the tail sum will also end up being zero.
+    // Exiting early here can prevent NaNs for some large inputs, where
+    // the tail sum computed below has term `a` which can overflow to `inf`.
+    if (numext::equal_strict(b, zero)) {
+      return s;
+    }
+
+    w = a;
+    s += b * w / (x - one);
+    s -= half * b;
+    a = one;
+    k = zero;
+
+    for (i = 0; i < 12; i++) {
+      a *= x + k;
+      b /= w;
+      t = a * b / A[i];
+      s = s + t;
+      t = numext::abs(t / s);
+      if (t < machep) {
+        break;
+      }
+      k += one;
+      a *= x + k;
+      b /= w;
+      k += one;
+    }
+    return s;
+  }
+};
+
+/****************************************************************************
+ * Implementation of polygamma function                                      *
+ ****************************************************************************/
+
+template <typename Scalar>
+struct polygamma_impl {
+  EIGEN_DEVICE_FUNC static Scalar run(Scalar n, Scalar x) {
+    Scalar zero = 0.0, one = 1.0;
+    Scalar nplus = n + one;
+    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
+
+    // Check that n is a non-negative integer
+    if (numext::floor(n) != n || n < zero) {
+      return nan;
+    }
+    // Just return the digamma function for n = 0
+    else if (n == zero) {
+      return digamma_impl<Scalar>::run(x);
+    }
+    // Use the same implementation as scipy
+    else {
+      Scalar factorial = numext::exp(lgamma_impl<Scalar>::run(nplus));
+      return numext::pow(-one, nplus) * factorial * zeta_impl<Scalar>::run(nplus, x);
+    }
+  }
+};
+
+/************************************************************************************************
+ * Implementation of betainc (incomplete beta integral), based on Cephes                         *
+ ************************************************************************************************/
+
+template <typename Scalar>
+struct betainc_impl {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar, Scalar, Scalar) {
+    EIGEN_STATIC_ASSERT((!std::is_same<Scalar, Scalar>::value), THIS_TYPE_IS_NOT_SUPPORTED)
+    /*	betaincf.c
+     *
+     *	Incomplete beta integral
+     *
+     *
+     * SYNOPSIS:
+     *
+     * float a, b, x, y, betaincf();
+     *
+     * y = betaincf( a, b, x );
+     *
+     *
+     * DESCRIPTION:
+     *
+     * Returns incomplete beta integral of the arguments, evaluated
+     * from zero to x.  The function is defined as
+     *
+     *                  x
+     *     -            -
+     *    | (a+b)      | |  a-1     b-1
+     *  -----------    |   t   (1-t)   dt.
+     *   -     -     | |
+     *  | (a) | (b)   -
+     *                 0
+     *
+     * The domain of definition is 0 <= x <= 1.  In this
+     * implementation a and b are restricted to positive values.
+     * The integral from x to 1 may be obtained by the symmetry
+     * relation
+     *
+     *    1 - betainc( a, b, x )  =  betainc( b, a, 1-x ).
+     *
+     * The integral is evaluated by a continued fraction expansion.
+     * If a < 1, the function calls itself recursively after a
+     * transformation to increase a to a+1.
+     *
+     * ACCURACY (float):
+     *
+     * Tested at random points (a,b,x) with a and b in the indicated
+     * interval and x between 0 and 1.
+     *
+     * arithmetic   domain     # trials      peak         rms
+     * Relative error:
+     *    IEEE       0,30       10000       3.7e-5      5.1e-6
+     *    IEEE       0,100      10000       1.7e-4      2.5e-5
+     * The useful domain for relative error is limited by underflow
+     * of the single precision exponential function.
+     * Absolute error:
+     *    IEEE       0,30      100000       2.2e-5      9.6e-7
+     *    IEEE       0,100      10000       6.5e-5      3.7e-6
+     *
+     * Larger errors may occur for extreme ratios of a and b.
+     *
+     * ACCURACY (double):
+     * arithmetic   domain     # trials      peak         rms
+     *    IEEE      0,5         10000       6.9e-15     4.5e-16
+     *    IEEE      0,85       250000       2.2e-13     1.7e-14
+     *    IEEE      0,1000      30000       5.3e-12     6.3e-13
+     *    IEEE      0,10000    250000       9.3e-11     7.1e-12
+     *    IEEE      0,100000    10000       8.7e-10     4.8e-11
+     * Outputs smaller than the IEEE gradual underflow threshold
+     * were excluded from these statistics.
+     *
+     * ERROR MESSAGES:
+     *   message         condition      value returned
+     * incbet domain      x<0, x>1          nan
+     * incbet underflow                     nan
+     */
+    return Scalar(0);
+  }
+};
+
+/* Continued fraction expansion #1 for incomplete beta integral (small_branch = True)
+ * Continued fraction expansion #2 for incomplete beta integral (small_branch = False)
+ */
+template <typename Scalar>
+struct incbeta_cfe {
+  EIGEN_STATIC_ASSERT((std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value),
+                      THIS_TYPE_IS_NOT_SUPPORTED)
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar a, Scalar b, Scalar x, bool small_branch) {
+    const Scalar big = cephes_helper<Scalar>::big();
+    const Scalar machep = cephes_helper<Scalar>::machep();
+    const Scalar biginv = cephes_helper<Scalar>::biginv();
+
+    const Scalar zero = 0;
+    const Scalar one = 1;
+    const Scalar two = 2;
+
+    Scalar xk, pk, pkm1, pkm2, qk, qkm1, qkm2;
+    Scalar k1, k2, k3, k4, k5, k6, k7, k8, k26update;
+    Scalar ans;
+    int n;
+
+    constexpr int num_iters = (std::is_same<Scalar, float>::value) ? 100 : 300;
+    const Scalar thresh = (std::is_same<Scalar, float>::value) ? machep : Scalar(3) * machep;
+    Scalar r = (std::is_same<Scalar, float>::value) ? zero : one;
+
+    if (small_branch) {
+      k1 = a;
+      k2 = a + b;
+      k3 = a;
+      k4 = a + one;
+      k5 = one;
+      k6 = b - one;
+      k7 = k4;
+      k8 = a + two;
+      k26update = one;
+    } else {
+      k1 = a;
+      k2 = b - one;
+      k3 = a;
+      k4 = a + one;
+      k5 = one;
+      k6 = a + b;
+      k7 = a + one;
+      k8 = a + two;
+      k26update = -one;
+      x = x / (one - x);
+    }
+
+    pkm2 = zero;
+    qkm2 = one;
+    pkm1 = one;
+    qkm1 = one;
+    ans = one;
+    n = 0;
+
+    do {
+      xk = -(x * k1 * k2) / (k3 * k4);
+      pk = pkm1 + pkm2 * xk;
+      qk = qkm1 + qkm2 * xk;
+      pkm2 = pkm1;
+      pkm1 = pk;
+      qkm2 = qkm1;
+      qkm1 = qk;
+
+      xk = (x * k5 * k6) / (k7 * k8);
+      pk = pkm1 + pkm2 * xk;
+      qk = qkm1 + qkm2 * xk;
+      pkm2 = pkm1;
+      pkm1 = pk;
+      qkm2 = qkm1;
+      qkm1 = qk;
+
+      if (qk != zero) {
+        r = pk / qk;
+        if (numext::abs(ans - r) < numext::abs(r) * thresh) {
+          return r;
+        }
+        ans = r;
+      }
+
+      k1 += one;
+      k2 += k26update;
+      k3 += two;
+      k4 += two;
+      k5 += one;
+      k6 -= k26update;
+      k7 += two;
+      k8 += two;
+
+      if ((numext::abs(qk) + numext::abs(pk)) > big) {
+        pkm2 *= biginv;
+        pkm1 *= biginv;
+        qkm2 *= biginv;
+        qkm1 *= biginv;
+      }
+      if ((numext::abs(qk) < biginv) || (numext::abs(pk) < biginv)) {
+        pkm2 *= big;
+        pkm1 *= big;
+        qkm2 *= big;
+        qkm1 *= big;
+      }
+    } while (++n < num_iters);
+
+    return ans;
+  }
+};
+
+/* Helper functions depending on the Scalar type */
+template <typename Scalar>
+struct betainc_helper {};
+
+template <>
+struct betainc_helper<float> {
+  /* Core implementation, assumes a large (> 1.0) */
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float incbsa(float aa, float bb, float xx) {
+    float ans, a, b, t, x, onemx;
+    bool reversed_a_b = false;
+
+    onemx = 1.0f - xx;
+
+    /* see if x is greater than the mean */
+    if (xx > (aa / (aa + bb))) {
+      reversed_a_b = true;
+      a = bb;
+      b = aa;
+      t = xx;
+      x = onemx;
+    } else {
+      a = aa;
+      b = bb;
+      t = onemx;
+      x = xx;
+    }
+
+    /* Choose expansion for optimal convergence */
+    if (b > 10.0f) {
+      if (numext::abs(b * x / a) < 0.3f) {
+        t = betainc_helper<float>::incbps(a, b, x);
+        if (reversed_a_b) t = 1.0f - t;
+        return t;
+      }
+    }
+
+    ans = x * (a + b - 2.0f) / (a - 1.0f);
+    if (ans < 1.0f) {
+      ans = incbeta_cfe<float>::run(a, b, x, true /* small_branch */);
+      t = b * numext::log(t);
+    } else {
+      ans = incbeta_cfe<float>::run(a, b, x, false /* small_branch */);
+      t = (b - 1.0f) * numext::log(t);
+    }
+
+    t += a * numext::log(x) + lgamma_impl<float>::run(a + b) - lgamma_impl<float>::run(a) - lgamma_impl<float>::run(b);
+    t += numext::log(ans / a);
+    t = numext::exp(t);
+
+    if (reversed_a_b) t = 1.0f - t;
+    return t;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float incbps(float a, float b, float x) {
+    float t, u, y, s;
+    const float machep = cephes_helper<float>::machep();
+
+    y = a * numext::log(x) + (b - 1.0f) * numext::log1p(-x) - numext::log(a);
+    y -= lgamma_impl<float>::run(a) + lgamma_impl<float>::run(b);
+    y += lgamma_impl<float>::run(a + b);
+
+    t = x / (1.0f - x);
+    s = 0.0f;
+    u = 1.0f;
+    do {
+      b -= 1.0f;
+      if (b == 0.0f) {
+        break;
+      }
+      a += 1.0f;
+      u *= t * b / a;
+      s += u;
+    } while (numext::abs(u) > machep);
+
+    return numext::exp(y) * (1.0f + s);
+  }
+};
+
+template <>
+struct betainc_impl<float> {
+  EIGEN_DEVICE_FUNC static float run(float a, float b, float x) {
+    const float nan = NumTraits<float>::quiet_NaN();
+    float ans, t;
+
+    if (a == 0.0f && b == 0.0f) return nan;
+    if (x < 0.0f || x > 1.0f) return nan;
+    if (a < 0.0f) return nan;
+    if (b < 0.0f) return nan;
+    if (a == 0.0f) return 1.0f;
+    if (b == 0.0f) return 0.0f;
+    if (x == 0.0f) return 0.0f;
+    if (x == 1.0f) return 1.0f;
+    // mtherr("betaincf", DOMAIN);
+
+    /* transformation for small aa */
+    if (a <= 1.0f) {
+      ans = betainc_helper<float>::incbsa(a + 1.0f, b, x);
+      t = a * numext::log(x) + b * numext::log1p(-x) + lgamma_impl<float>::run(a + b) -
+          lgamma_impl<float>::run(a + 1.0f) - lgamma_impl<float>::run(b);
+      return (ans + numext::exp(t));
+    } else {
+      return betainc_helper<float>::incbsa(a, b, x);
+    }
+  }
+};
+
+template <>
+struct betainc_helper<double> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double incbps(double a, double b, double x) {
+    const double machep = cephes_helper<double>::machep();
+
+    double s, t, u, v, n, t1, z, ai;
+
+    ai = 1.0 / a;
+    u = (1.0 - b) * x;
+    v = u / (a + 1.0);
+    t1 = v;
+    t = u;
+    n = 2.0;
+    s = 0.0;
+    z = machep * ai;
+    while (numext::abs(v) > z) {
+      u = (n - b) * x / n;
+      t *= u;
+      v = t / (a + n);
+      s += v;
+      n += 1.0;
+    }
+    s += t1;
+    s += ai;
+
+    u = a * numext::log(x);
+    // TODO: gamma() is not directly implemented in Eigen.
+    /*
+    if ((a + b) < maxgam && numext::abs(u) < maxlog) {
+      t = gamma(a + b) / (gamma(a) * gamma(b));
+      s = s * t * pow(x, a);
+    }
+    */
+    t = lgamma_impl<double>::run(a + b) - lgamma_impl<double>::run(a) - lgamma_impl<double>::run(b) + u +
+        numext::log(s);
+    return numext::exp(t);
+  }
+};
+
+template <>
+struct betainc_impl<double> {
+  EIGEN_DEVICE_FUNC static double run(double aa, double bb, double xx) {
+    const double nan = NumTraits<double>::quiet_NaN();
+    const double machep = cephes_helper<double>::machep();
+    double a, b, t, x, xc, w, y;
+    bool reversed_a_b = false;
+
+    if (aa == 0.0 && bb == 0.0) return nan;
+    if (xx < 0.0 || xx > 1.0) return nan;
+    if (aa < 0.0) return nan;
+    if (bb < 0.0) return nan;
+    if (aa == 0.0) return 1.0;
+    if (bb == 0.0) return 0.0;
+    if (xx == 0.0) return 0.0;
+    if (xx == 1.0) return 1.0;
+    // mtherr("incbet", DOMAIN);
+
+    if ((bb * xx) <= 1.0 && xx <= 0.95) {
+      return betainc_helper<double>::incbps(aa, bb, xx);
+    }
+
+    w = 1.0 - xx;
+
+    /* Reverse a and b if x is greater than the mean. */
+    if (xx > (aa / (aa + bb))) {
+      reversed_a_b = true;
+      a = bb;
+      b = aa;
+      xc = xx;
+      x = w;
+    } else {
+      a = aa;
+      b = bb;
+      xc = w;
+      x = xx;
+    }
+
+    if (reversed_a_b && (b * x) <= 1.0 && x <= 0.95) {
+      t = betainc_helper<double>::incbps(a, b, x);
+      if (t <= machep) {
+        t = 1.0 - machep;
+      } else {
+        t = 1.0 - t;
+      }
+      return t;
+    }
+
+    /* Choose expansion for better convergence. */
+    y = x * (a + b - 2.0) - (a - 1.0);
+    if (y < 0.0) {
+      w = incbeta_cfe<double>::run(a, b, x, true /* small_branch */);
+    } else {
+      w = incbeta_cfe<double>::run(a, b, x, false /* small_branch */) / xc;
+    }
+
+    /* Multiply w by the factor
+         a      b   _             _     _
+        x  (1-x)   | (a+b) / ( a | (a) | (b) ) .   */
+
+    y = a * numext::log(x);
+    t = b * numext::log(xc);
+    // TODO: gamma is not directly implemented in Eigen.
+    /*
+    if ((a + b) < maxgam && numext::abs(y) < maxlog && numext::abs(t) < maxlog)
+    {
+      t = pow(xc, b);
+      t *= pow(x, a);
+      t /= a;
+      t *= w;
+      t *= gamma(a + b) / (gamma(a) * gamma(b));
+    } else {
+    */
+    /* Resort to logarithms.  */
+    y += t + lgamma_impl<double>::run(a + b) - lgamma_impl<double>::run(a) - lgamma_impl<double>::run(b);
+    y += numext::log(w / a);
+    t = numext::exp(y);
+
+    /* } */
+    // done:
+
+    if (reversed_a_b) {
+      if (t <= machep) {
+        t = 1.0 - machep;
+      } else {
+        t = 1.0 - t;
+      }
+    }
+    return t;
+  }
+};
+
+}  // end namespace internal
+
+namespace numext {
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto lgamma(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(lgamma, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(lgamma, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto digamma(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(digamma, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(digamma, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto zeta(const Scalar& x, const Scalar& q)
+    -> decltype(EIGEN_MATHFUNC_IMPL(zeta, Scalar)::run(x, q)) {
+  return EIGEN_MATHFUNC_IMPL(zeta, Scalar)::run(x, q);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto polygamma(const Scalar& n, const Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(polygamma, Scalar)::run(n, x)) {
+  return EIGEN_MATHFUNC_IMPL(polygamma, Scalar)::run(n, x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto erf(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(erf, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(erf, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto erfc(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(erfc, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(erfc, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto ndtri(const Scalar& x) -> decltype(EIGEN_MATHFUNC_IMPL(ndtri, Scalar)::run(x)) {
+  return EIGEN_MATHFUNC_IMPL(ndtri, Scalar)::run(x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto igamma(const Scalar& a, const Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(igamma, Scalar)::run(a, x)) {
+  return EIGEN_MATHFUNC_IMPL(igamma, Scalar)::run(a, x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto igamma_der_a(const Scalar& a, const Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(igamma_der_a, Scalar)::run(a, x)) {
+  return EIGEN_MATHFUNC_IMPL(igamma_der_a, Scalar)::run(a, x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto gamma_sample_der_alpha(const Scalar& a, const Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(gamma_sample_der_alpha, Scalar)::run(a, x)) {
+  return EIGEN_MATHFUNC_IMPL(gamma_sample_der_alpha, Scalar)::run(a, x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto igammac(const Scalar& a, const Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(igammac, Scalar)::run(a, x)) {
+  return EIGEN_MATHFUNC_IMPL(igammac, Scalar)::run(a, x);
+}
+
+template <typename Scalar>
+EIGEN_DEVICE_FUNC inline auto betainc(const Scalar& a, const Scalar& b, const Scalar& x)
+    -> decltype(EIGEN_MATHFUNC_IMPL(betainc, Scalar)::run(a, b, x)) {
+  return EIGEN_MATHFUNC_IMPL(betainc, Scalar)::run(a, b, x);
+}
+
+}  // end namespace numext
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPECIAL_FUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h
new file mode 100644
index 0000000..36cc503
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h
@@ -0,0 +1,113 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPECIALFUNCTIONS_PACKETMATH_H
+#define EIGEN_SPECIALFUNCTIONS_PACKETMATH_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/** \internal \returns the ln(|gamma(\a a)|) (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plgamma(const Packet& a) {
+  using numext::lgamma;
+  return lgamma(a);
+}
+
+/** \internal \returns the derivative of lgamma, psi(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pdigamma(const Packet& a) {
+  using numext::digamma;
+  return digamma(a);
+}
+
+/** \internal \returns the zeta function of two arguments (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pzeta(const Packet& x, const Packet& q) {
+  using numext::zeta;
+  return zeta(x, q);
+}
+
+/** \internal \returns the polygamma function (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ppolygamma(const Packet& n, const Packet& x) {
+  using numext::polygamma;
+  return polygamma(n, x);
+}
+
+/** \internal \returns the erf(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perf(const Packet& a) {
+  using numext::erf;
+  return erf(a);
+}
+
+/** \internal \returns the erfc(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perfc(const Packet& a) {
+  using numext::erfc;
+  return erfc(a);
+}
+
+/** \internal \returns the ndtri(\a a) (coeff-wise) */
+template <typename Packet>
+EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pndtri(const Packet& a) {
+  typedef typename unpacket_traits<Packet>::type ScalarType;
+  using internal::generic_ndtri;
+  return generic_ndtri<Packet, ScalarType>(a);
+}
+
+/** \internal \returns the incomplete gamma function igamma(\a a, \a x) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigamma(const Packet& a, const Packet& x) {
+  using numext::igamma;
+  return igamma(a, x);
+}
+
+/** \internal \returns the derivative of the incomplete gamma function
+ * igamma_der_a(\a a, \a x) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigamma_der_a(const Packet& a, const Packet& x) {
+  using numext::igamma_der_a;
+  return igamma_der_a(a, x);
+}
+
+/** \internal \returns compute the derivative of the sample
+ * of Gamma(alpha, 1) random variable with respect to the parameter a
+ * gamma_sample_der_alpha(\a alpha, \a sample) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pgamma_sample_der_alpha(const Packet& alpha, const Packet& sample) {
+  using numext::gamma_sample_der_alpha;
+  return gamma_sample_der_alpha(alpha, sample);
+}
+
+/** \internal \returns the complementary incomplete gamma function igammac(\a a, \a x) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigammac(const Packet& a, const Packet& x) {
+  using numext::igammac;
+  return igammac(a, x);
+}
+
+/** \internal \returns the incomplete beta function betainc(\a a, \a b, \a x) */
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pbetainc(const Packet& a, const Packet& b, const Packet& x) {
+  using numext::betainc;
+  return betainc(a, b, x);
+}
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_SPECIALFUNCTIONS_PACKETMATH_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h
new file mode 100644
index 0000000..02788c1
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AVX_BESSELFUNCTIONS_H
+#define EIGEN_AVX_BESSELFUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+EIGEN_INSTANTIATE_BESSEL_FUNCS_F16(Packet8f, Packet8h)
+EIGEN_INSTANTIATE_BESSEL_FUNCS_BF16(Packet8f, Packet8bf)
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_AVX_BESSELFUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h
new file mode 100644
index 0000000..fca747d
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AVX_SPECIALFUNCTIONS_H
+#define EIGEN_AVX_SPECIALFUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+EIGEN_INSTANTIATE_SPECIAL_FUNCS_F16(Packet8f, Packet8h)
+EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(Packet8f, Packet8bf)
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_AVX_SPECIALFUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h
new file mode 100644
index 0000000..075911b
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AVX512_BESSELFUNCTIONS_H
+#define EIGEN_AVX512_BESSELFUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+EIGEN_INSTANTIATE_BESSEL_FUNCS_F16(Packet16f, Packet16h)
+EIGEN_INSTANTIATE_BESSEL_FUNCS_BF16(Packet16f, Packet16bf)
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_AVX512_BESSELFUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h
new file mode 100644
index 0000000..220fe1b
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_AVX512_SPECIALFUNCTIONS_H
+#define EIGEN_AVX512_SPECIALFUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+EIGEN_INSTANTIATE_SPECIAL_FUNCS_F16(Packet16f, Packet16h)
+EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(Packet16f, Packet16bf)
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_AVX512_SPECIALFUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h
new file mode 100644
index 0000000..0ce7576
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h
@@ -0,0 +1,318 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_GPU_SPECIALFUNCTIONS_H
+#define EIGEN_GPU_SPECIALFUNCTIONS_H
+
+namespace Eigen {
+
+namespace internal {
+
+// Make sure this is only available when targeting a GPU: we don't want to
+// introduce conflicts between these packet_traits definitions and the ones
+// we'll use on the host side (SSE, AVX, ...)
+#if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 plgamma<float4>(const float4& a) {
+  return make_float4(lgammaf(a.x), lgammaf(a.y), lgammaf(a.z), lgammaf(a.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 plgamma<double2>(const double2& a) {
+  using numext::lgamma;
+  return make_double2(lgamma(a.x), lgamma(a.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pdigamma<float4>(const float4& a) {
+  using numext::digamma;
+  return make_float4(digamma(a.x), digamma(a.y), digamma(a.z), digamma(a.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pdigamma<double2>(const double2& a) {
+  using numext::digamma;
+  return make_double2(digamma(a.x), digamma(a.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pzeta<float4>(const float4& x, const float4& q) {
+  using numext::zeta;
+  return make_float4(zeta(x.x, q.x), zeta(x.y, q.y), zeta(x.z, q.z), zeta(x.w, q.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pzeta<double2>(const double2& x, const double2& q) {
+  using numext::zeta;
+  return make_double2(zeta(x.x, q.x), zeta(x.y, q.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ppolygamma<float4>(const float4& n, const float4& x) {
+  using numext::polygamma;
+  return make_float4(polygamma(n.x, x.x), polygamma(n.y, x.y), polygamma(n.z, x.z), polygamma(n.w, x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ppolygamma<double2>(const double2& n, const double2& x) {
+  using numext::polygamma;
+  return make_double2(polygamma(n.x, x.x), polygamma(n.y, x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 perf<float4>(const float4& a) {
+  return make_float4(erff(a.x), erff(a.y), erff(a.z), erff(a.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 perf<double2>(const double2& a) {
+  using numext::erf;
+  return make_double2(erf(a.x), erf(a.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 perfc<float4>(const float4& a) {
+  using numext::erfc;
+  return make_float4(erfc(a.x), erfc(a.y), erfc(a.z), erfc(a.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 perfc<double2>(const double2& a) {
+  using numext::erfc;
+  return make_double2(erfc(a.x), erfc(a.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pndtri<float4>(const float4& a) {
+  using numext::ndtri;
+  return make_float4(ndtri(a.x), ndtri(a.y), ndtri(a.z), ndtri(a.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pndtri<double2>(const double2& a) {
+  using numext::ndtri;
+  return make_double2(ndtri(a.x), ndtri(a.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pigamma<float4>(const float4& a, const float4& x) {
+  using numext::igamma;
+  return make_float4(igamma(a.x, x.x), igamma(a.y, x.y), igamma(a.z, x.z), igamma(a.w, x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pigamma<double2>(const double2& a, const double2& x) {
+  using numext::igamma;
+  return make_double2(igamma(a.x, x.x), igamma(a.y, x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pigamma_der_a<float4>(const float4& a, const float4& x) {
+  using numext::igamma_der_a;
+  return make_float4(igamma_der_a(a.x, x.x), igamma_der_a(a.y, x.y), igamma_der_a(a.z, x.z), igamma_der_a(a.w, x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pigamma_der_a<double2>(const double2& a, const double2& x) {
+  using numext::igamma_der_a;
+  return make_double2(igamma_der_a(a.x, x.x), igamma_der_a(a.y, x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pgamma_sample_der_alpha<float4>(const float4& alpha,
+                                                                             const float4& sample) {
+  using numext::gamma_sample_der_alpha;
+  return make_float4(gamma_sample_der_alpha(alpha.x, sample.x), gamma_sample_der_alpha(alpha.y, sample.y),
+                     gamma_sample_der_alpha(alpha.z, sample.z), gamma_sample_der_alpha(alpha.w, sample.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pgamma_sample_der_alpha<double2>(const double2& alpha,
+                                                                               const double2& sample) {
+  using numext::gamma_sample_der_alpha;
+  return make_double2(gamma_sample_der_alpha(alpha.x, sample.x), gamma_sample_der_alpha(alpha.y, sample.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pigammac<float4>(const float4& a, const float4& x) {
+  using numext::igammac;
+  return make_float4(igammac(a.x, x.x), igammac(a.y, x.y), igammac(a.z, x.z), igammac(a.w, x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pigammac<double2>(const double2& a, const double2& x) {
+  using numext::igammac;
+  return make_double2(igammac(a.x, x.x), igammac(a.y, x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbetainc<float4>(const float4& a, const float4& b, const float4& x) {
+  using numext::betainc;
+  return make_float4(betainc(a.x, b.x, x.x), betainc(a.y, b.y, x.y), betainc(a.z, b.z, x.z), betainc(a.w, b.w, x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbetainc<double2>(const double2& a, const double2& b, const double2& x) {
+  using numext::betainc;
+  return make_double2(betainc(a.x, b.x, x.x), betainc(a.y, b.y, x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i0e<float4>(const float4& x) {
+  using numext::bessel_i0e;
+  return make_float4(bessel_i0e(x.x), bessel_i0e(x.y), bessel_i0e(x.z), bessel_i0e(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i0e<double2>(const double2& x) {
+  using numext::bessel_i0e;
+  return make_double2(bessel_i0e(x.x), bessel_i0e(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i0<float4>(const float4& x) {
+  using numext::bessel_i0;
+  return make_float4(bessel_i0(x.x), bessel_i0(x.y), bessel_i0(x.z), bessel_i0(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i0<double2>(const double2& x) {
+  using numext::bessel_i0;
+  return make_double2(bessel_i0(x.x), bessel_i0(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i1e<float4>(const float4& x) {
+  using numext::bessel_i1e;
+  return make_float4(bessel_i1e(x.x), bessel_i1e(x.y), bessel_i1e(x.z), bessel_i1e(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i1e<double2>(const double2& x) {
+  using numext::bessel_i1e;
+  return make_double2(bessel_i1e(x.x), bessel_i1e(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i1<float4>(const float4& x) {
+  using numext::bessel_i1;
+  return make_float4(bessel_i1(x.x), bessel_i1(x.y), bessel_i1(x.z), bessel_i1(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i1<double2>(const double2& x) {
+  using numext::bessel_i1;
+  return make_double2(bessel_i1(x.x), bessel_i1(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k0e<float4>(const float4& x) {
+  using numext::bessel_k0e;
+  return make_float4(bessel_k0e(x.x), bessel_k0e(x.y), bessel_k0e(x.z), bessel_k0e(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k0e<double2>(const double2& x) {
+  using numext::bessel_k0e;
+  return make_double2(bessel_k0e(x.x), bessel_k0e(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k0<float4>(const float4& x) {
+  using numext::bessel_k0;
+  return make_float4(bessel_k0(x.x), bessel_k0(x.y), bessel_k0(x.z), bessel_k0(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k0<double2>(const double2& x) {
+  using numext::bessel_k0;
+  return make_double2(bessel_k0(x.x), bessel_k0(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k1e<float4>(const float4& x) {
+  using numext::bessel_k1e;
+  return make_float4(bessel_k1e(x.x), bessel_k1e(x.y), bessel_k1e(x.z), bessel_k1e(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k1e<double2>(const double2& x) {
+  using numext::bessel_k1e;
+  return make_double2(bessel_k1e(x.x), bessel_k1e(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k1<float4>(const float4& x) {
+  using numext::bessel_k1;
+  return make_float4(bessel_k1(x.x), bessel_k1(x.y), bessel_k1(x.z), bessel_k1(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k1<double2>(const double2& x) {
+  using numext::bessel_k1;
+  return make_double2(bessel_k1(x.x), bessel_k1(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_j0<float4>(const float4& x) {
+  using numext::bessel_j0;
+  return make_float4(bessel_j0(x.x), bessel_j0(x.y), bessel_j0(x.z), bessel_j0(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_j0<double2>(const double2& x) {
+  using numext::bessel_j0;
+  return make_double2(bessel_j0(x.x), bessel_j0(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_j1<float4>(const float4& x) {
+  using numext::bessel_j1;
+  return make_float4(bessel_j1(x.x), bessel_j1(x.y), bessel_j1(x.z), bessel_j1(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_j1<double2>(const double2& x) {
+  using numext::bessel_j1;
+  return make_double2(bessel_j1(x.x), bessel_j1(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_y0<float4>(const float4& x) {
+  using numext::bessel_y0;
+  return make_float4(bessel_y0(x.x), bessel_y0(x.y), bessel_y0(x.z), bessel_y0(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_y0<double2>(const double2& x) {
+  using numext::bessel_y0;
+  return make_double2(bessel_y0(x.x), bessel_y0(x.y));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_y1<float4>(const float4& x) {
+  using numext::bessel_y1;
+  return make_float4(bessel_y1(x.x), bessel_y1(x.y), bessel_y1(x.z), bessel_y1(x.w));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_y1<double2>(const double2& x) {
+  using numext::bessel_y1;
+  return make_double2(bessel_y1(x.x), bessel_y1(x.y));
+}
+
+#endif
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_GPU_SPECIALFUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h
new file mode 100644
index 0000000..cfaa48d
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h
@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NEON_BESSELFUNCTIONS_H
+#define EIGEN_NEON_BESSELFUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
+#define NEON_HALF_TO_FLOAT_FUNCTIONS(METHOD)                                              \
+  template <>                                                                             \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf METHOD<Packet8hf>(const Packet8hf& x) { \
+    const Packet4f lo = METHOD<Packet4f>(vcvt_f32_f16(vget_low_f16(x)));                  \
+    const Packet4f hi = METHOD<Packet4f>(vcvt_f32_f16(vget_high_f16(x)));                 \
+    return vcombine_f16(vcvt_f16_f32(lo), vcvt_f16_f32(hi));                              \
+  }                                                                                       \
+                                                                                          \
+  template <>                                                                             \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf METHOD<Packet4hf>(const Packet4hf& x) { \
+    return vcvt_f16_f32(METHOD<Packet4f>(vcvt_f32_f16(x)));                               \
+  }
+
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i0)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i0e)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i1)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i1e)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_j0)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_j1)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k0)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k0e)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k1)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k1e)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_y0)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_y1)
+
+#undef NEON_HALF_TO_FLOAT_FUNCTIONS
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
+EIGEN_INSTANTIATE_BESSEL_FUNCS_BF16(Packet4f, Packet4bf)
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_NEON_BESSELFUNCTIONS_H
diff --git a/contrib/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h b/contrib/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h
new file mode 100644
index 0000000..3b27b9c
--- /dev/null
+++ b/contrib/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h
@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_NEON_SPECIALFUNCTIONS_H
+#define EIGEN_NEON_SPECIALFUNCTIONS_H
+
+namespace Eigen {
+namespace internal {
+
+#if EIGEN_ARCH_ARM
+// For x = n * 2^-149, n < 2^23, erf(x) = (2/sqrt(pi))*x to float precision.
+// round((2/sqrt(pi))*2^31) = 2423175810; the coefficient error contributes < 0.000319 ULP.
+// Integer rounding avoids ARMv7 NEON's input/output flushing. The result bits also cover the first normal binade.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2i perf_subnormal_significands(const Packet2i& n) {
+  return vreinterpret_s32_u32(vrshrn_n_u64(vmull_u32(vreinterpret_u32_s32(n), vdup_n_u32(2423175810u)), 31));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4i perf_subnormal_significands(const Packet4i& n) {
+  return vcombine_s32(perf_subnormal_significands(Packet2i(vget_low_s32(n))),
+                      perf_subnormal_significands(Packet2i(vget_high_s32(n))));
+}
+
+template <typename Packet>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet perf_neon(const Packet& x) {
+  using PacketI = typename unpacket_traits<Packet>::integer_packet;
+  const Packet result = generic_fast_erf<float>::run(x);
+  const PacketI bits = preinterpret<PacketI>(x);
+  const PacketI magnitude = pand(bits, pset1<PacketI>(0x7fffffff));
+  const PacketI sign = pxor(bits, magnitude);
+  const PacketI subnormal = pcmp_lt(magnitude, pset1<PacketI>(0x00800000));
+  const PacketI recovered = por(perf_subnormal_significands(magnitude), sign);
+  return pselect(preinterpret<Packet>(subnormal), preinterpret<Packet>(recovered), result);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet2f perf<Packet2f>(const Packet2f& x) {
+  return perf_neon(x);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4f perf<Packet4f>(const Packet4f& x) {
+  return perf_neon(x);
+}
+#endif
+
+#if EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
+#define NEON_HALF_TO_FLOAT_FUNCTIONS(METHOD)                                              \
+  template <>                                                                             \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf METHOD<Packet8hf>(const Packet8hf& x) { \
+    const Packet4f lo = METHOD<Packet4f>(vcvt_f32_f16(vget_low_f16(x)));                  \
+    const Packet4f hi = METHOD<Packet4f>(vcvt_f32_f16(vget_high_f16(x)));                 \
+    return vcombine_f16(vcvt_f16_f32(lo), vcvt_f16_f32(hi));                              \
+  }                                                                                       \
+                                                                                          \
+  template <>                                                                             \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf METHOD<Packet4hf>(const Packet4hf& x) { \
+    return vcvt_f16_f32(METHOD<Packet4f>(vcvt_f32_f16(x)));                               \
+  }
+
+NEON_HALF_TO_FLOAT_FUNCTIONS(perf)
+NEON_HALF_TO_FLOAT_FUNCTIONS(pndtri)
+
+#undef NEON_HALF_TO_FLOAT_FUNCTIONS
+#endif  // EIGEN_ARCH_ARM64 && EIGEN_HAS_ARM64_FP16
+
+EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(Packet4f, Packet4bf)
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_NEON_SPECIALFUNCTIONS_H
diff --git a/contrib/Eigen/src/Splines/InternalHeaderCheck.h b/contrib/Eigen/src/Splines/InternalHeaderCheck.h
new file mode 100644
index 0000000..c2cc28c
--- /dev/null
+++ b/contrib/Eigen/src/Splines/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPLINES_MODULE_H
+#error "Please include contrib/Eigen/Splines instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/Splines/Spline.h b/contrib/Eigen/src/Splines/Spline.h
new file mode 100644
index 0000000..74eca8e
--- /dev/null
+++ b/contrib/Eigen/src/Splines/Spline.h
@@ -0,0 +1,486 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 20010-2011 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPLINE_H
+#define EIGEN_SPLINE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "SplineFwd.h"
+
+namespace Eigen {
+/**
+ * \ingroup Splines_Module
+ * \class Spline
+ * \brief A class representing multi-dimensional spline curves.
+ *
+ * The class represents B-splines with non-uniform knot vectors. Each control
+ * point of the B-spline is associated with a basis function
+ * \f{align*}
+ *   C(u) & = \sum_{i=0}^{n}N_{i,p}(u)P_i
+ * \f}
+ *
+ * The spline is parameterized over the domain \f$[u_p; u_{m-p}]\f$ of its knot
+ * vector \f$\{u_0,\hdots,u_m\}\f$, where \f$p\f$ is the degree. For the clamped
+ * knot vectors that SplineFitting produces this is \f$[u_0; u_m]\f$, which is
+ * the interval spanned by the interpolation parameters and therefore not
+ * necessarily \f$[0;1]\f$.
+ *
+ * \tparam Scalar_ The underlying data type (typically float or double)
+ * \tparam Dim_ The curve dimension (e.g. 2 or 3)
+ * \tparam Degree_ Per default set to Dynamic; could be set to the actual desired
+ *                degree for optimization purposes (would result in stack allocation
+ *                of several temporary variables).
+ **/
+template <typename Scalar_, int Dim_, int Degree_>
+class Spline {
+ public:
+  typedef Scalar_ Scalar; /*!< The spline curve's scalar type. */
+  enum { Dimension = Dim_ /*!< The spline curve's dimension. */ };
+  enum { Degree = Degree_ /*!< The spline curve's degree. */ };
+
+  /** \brief The point type the spline is representing. */
+  typedef typename SplineTraits<Spline>::PointType PointType;
+
+  /** \brief The data type used to store knot vectors. */
+  typedef typename SplineTraits<Spline>::KnotVectorType KnotVectorType;
+
+  /** \brief The data type used to store parameter vectors. */
+  typedef typename SplineTraits<Spline>::ParameterVectorType ParameterVectorType;
+
+  /** \brief The data type used to store non-zero basis functions. */
+  typedef typename SplineTraits<Spline>::BasisVectorType BasisVectorType;
+
+  /** \brief The data type used to store the values of the basis function derivatives. */
+  typedef typename SplineTraits<Spline>::BasisDerivativeType BasisDerivativeType;
+
+  /** \brief The data type representing the spline's control points. */
+  typedef typename SplineTraits<Spline>::ControlPointVectorType ControlPointVectorType;
+
+  /**
+   * \brief Creates a (constant) zero spline.
+   * For Splines with dynamic degree, the resulting degree will be 0.
+   **/
+  Spline()
+      : m_knots(1, (Degree == Dynamic ? 2 : 2 * Degree + 2)),
+        m_ctrls(ControlPointVectorType::Zero(Dimension, (Degree == Dynamic ? 1 : Degree + 1))) {
+    // in theory this code can go to the initializer list but it will get pretty
+    // much unreadable ...
+    enum { MinDegree = (Degree == Dynamic ? 0 : Degree) };
+    m_knots.template segment<MinDegree + 1>(0) = Array<Scalar, 1, MinDegree + 1>::Zero();
+    m_knots.template segment<MinDegree + 1>(MinDegree + 1) = Array<Scalar, 1, MinDegree + 1>::Ones();
+  }
+
+  /**
+   * \brief Creates a spline from a knot vector and control points.
+   * \param knots The spline's knot vector.
+   * \param ctrls The spline's control point vector.
+   **/
+  template <typename OtherVectorType, typename OtherArrayType>
+  Spline(const OtherVectorType& knots, const OtherArrayType& ctrls) : m_knots(knots), m_ctrls(ctrls) {}
+
+  /**
+   * \brief Copy constructor for splines.
+   * \param spline The input spline.
+   **/
+  template <int OtherDegree>
+  Spline(const Spline<Scalar, Dimension, OtherDegree>& spline) : m_knots(spline.knots()), m_ctrls(spline.ctrls()) {}
+
+  /**
+   * \brief Returns the knots of the underlying spline.
+   **/
+  const KnotVectorType& knots() const { return m_knots; }
+
+  /**
+   * \brief Returns the ctrls of the underlying spline.
+   **/
+  const ControlPointVectorType& ctrls() const { return m_ctrls; }
+
+  /**
+   * \brief Returns the spline value at a given site \f$u\f$.
+   *
+   * The function returns
+   * \f{align*}
+   *   C(u) & = \sum_{i=0}^{n}N_{i,p}P_i
+   * \f}
+   *
+   * \param u Parameter \f$u\f$ in the spline's knot domain at which the spline is evaluated.
+   * \return The spline value at the given location \f$u\f$.
+   **/
+  PointType operator()(Scalar u) const;
+
+  /**
+   * \brief Evaluation of spline derivatives of up-to given order.
+   *
+   * The function returns
+   * \f{align*}
+   *   \frac{d^i}{du^i}C(u) & = \sum_{i=0}^{n} \frac{d^i}{du^i} N_{i,p}(u)P_i
+   * \f}
+   * for i ranging between 0 and order.
+   *
+   * \param u Parameter \f$u\f$ in the spline's knot domain at which the spline derivative is evaluated.
+   * \param order The order up to which the derivatives are computed.
+   **/
+  typename SplineTraits<Spline>::DerivativeType derivatives(Scalar u, DenseIndex order) const;
+
+  /**
+   * \copydoc Spline::derivatives
+   * Using the template version of this function is more efficient since
+   * temporary objects are allocated on the stack whenever this is possible.
+   **/
+  template <int DerivativeOrder>
+  typename SplineTraits<Spline, DerivativeOrder>::DerivativeType derivatives(Scalar u,
+                                                                             DenseIndex order = DerivativeOrder) const;
+
+  /**
+   * \brief Computes the non-zero basis functions at the given site.
+   *
+   * Splines have local support and a point from their image is defined
+   * by exactly \f$p+1\f$ control points \f$P_i\f$ where \f$p\f$ is the
+   * spline degree.
+   *
+   * This function computes the \f$p+1\f$ non-zero basis function values
+   * for a given parameter value \f$u\f$. It returns
+   * \f{align*}{
+   *   N_{i,p}(u), \hdots, N_{i+p+1,p}(u)
+   * \f}
+   *
+   * \param u Parameter \f$u\f$ in the spline's knot domain at which the non-zero
+   *          basis functions are computed.
+   **/
+  typename SplineTraits<Spline>::BasisVectorType basisFunctions(Scalar u) const;
+
+  /**
+   * \brief Computes the non-zero spline basis function derivatives up to given order.
+   *
+   * The function computes
+   * \f{align*}{
+   *   \frac{d^i}{du^i} N_{i,p}(u), \hdots, \frac{d^i}{du^i} N_{i+p+1,p}(u)
+   * \f}
+   * with i ranging from 0 up to the specified order.
+   *
+   * \param u Parameter \f$u\f$ in the spline's knot domain at which the non-zero
+   *          basis function derivatives are computed.
+   * \param order The order up to which the basis function derivatives are computed.
+   **/
+  typename SplineTraits<Spline>::BasisDerivativeType basisFunctionDerivatives(Scalar u, DenseIndex order) const;
+
+  /**
+   * \copydoc Spline::basisFunctionDerivatives
+   * Using the template version of this function is more efficient since
+   * temporary objects are allocated on the stack whenever this is possible.
+   **/
+  template <int DerivativeOrder>
+  typename SplineTraits<Spline, DerivativeOrder>::BasisDerivativeType basisFunctionDerivatives(
+      Scalar u, DenseIndex order = DerivativeOrder) const;
+
+  /**
+   * \brief Returns the spline degree.
+   **/
+  DenseIndex degree() const;
+
+  /**
+   * \brief Returns the span within the knot vector in which u is falling.
+   * \param u The site for which the span is determined.
+   **/
+  DenseIndex span(Scalar u) const;
+
+  /**
+   * \brief Computes the span within the provided knot vector in which u is falling.
+   **/
+  static DenseIndex Span(typename SplineTraits<Spline>::Scalar u, DenseIndex degree,
+                         const typename SplineTraits<Spline>::KnotVectorType& knots);
+
+  /**
+   * \brief Returns the spline's non-zero basis functions.
+   *
+   * The function computes and returns
+   * \f{align*}{
+   *   N_{i,p}(u), \hdots, N_{i+p+1,p}(u)
+   * \f}
+   *
+   * \param u The site at which the basis functions are computed.
+   * \param degree The degree of the underlying spline.
+   * \param knots The underlying spline's knot vector.
+   **/
+  static BasisVectorType BasisFunctions(Scalar u, DenseIndex degree, const KnotVectorType& knots);
+
+  /**
+   * \copydoc Spline::basisFunctionDerivatives
+   * \param degree The degree of the underlying spline
+   * \param knots The underlying spline's knot vector.
+   **/
+  static BasisDerivativeType BasisFunctionDerivatives(const Scalar u, const DenseIndex order, const DenseIndex degree,
+                                                      const KnotVectorType& knots);
+
+ private:
+  KnotVectorType m_knots;         /*!< Knot vector. */
+  ControlPointVectorType m_ctrls; /*!< Control points. */
+
+  template <typename DerivativeType>
+  static void BasisFunctionDerivativesImpl(const typename Spline<Scalar_, Dim_, Degree_>::Scalar u,
+                                           const DenseIndex order, const DenseIndex p,
+                                           const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& U,
+                                           DerivativeType& N_);
+};
+
+template <typename Scalar_, int Dim_, int Degree_>
+DenseIndex Spline<Scalar_, Dim_, Degree_>::Span(
+    typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::Scalar u, DenseIndex degree,
+    const typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::KnotVectorType& knots) {
+  // Piegl & Tiller, "The NURBS Book", A2.1 (p. 68)
+  if (u <= knots(0)) return degree;
+  const Scalar* pos = std::upper_bound(knots.data() + degree - 1, knots.data() + knots.size() - degree - 1, u);
+  return static_cast<DenseIndex>(std::distance(knots.data(), pos) - 1);
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+typename Spline<Scalar_, Dim_, Degree_>::BasisVectorType Spline<Scalar_, Dim_, Degree_>::BasisFunctions(
+    typename Spline<Scalar_, Dim_, Degree_>::Scalar u, DenseIndex degree,
+    const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& knots) {
+  const DenseIndex p = degree;
+  const DenseIndex i = Spline::Span(u, degree, knots);
+
+  const KnotVectorType& U = knots;
+
+  BasisVectorType left(p + 1);
+  left(0) = Scalar(0);
+  BasisVectorType right(p + 1);
+  right(0) = Scalar(0);
+
+  VectorBlock<BasisVectorType, Degree>(left, 1, p) =
+      u - VectorBlock<const KnotVectorType, Degree>(U, i + 1 - p, p).reverse();
+  VectorBlock<BasisVectorType, Degree>(right, 1, p) = VectorBlock<const KnotVectorType, Degree>(U, i + 1, p) - u;
+
+  BasisVectorType N(1, p + 1);
+  N(0) = Scalar(1);
+  for (DenseIndex j = 1; j <= p; ++j) {
+    Scalar saved = Scalar(0);
+    for (DenseIndex r = 0; r < j; r++) {
+      const Scalar tmp = N(r) / (right(r + 1) + left(j - r));
+      N[r] = saved + right(r + 1) * tmp;
+      saved = left(j - r) * tmp;
+    }
+    N(j) = saved;
+  }
+  return N;
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+DenseIndex Spline<Scalar_, Dim_, Degree_>::degree() const {
+  EIGEN_IF_CONSTEXPR (Degree_ == Dynamic)
+    return m_knots.size() - m_ctrls.cols() - 1;
+  else
+    return Degree_;
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+DenseIndex Spline<Scalar_, Dim_, Degree_>::span(Scalar u) const {
+  return Spline::Span(u, degree(), knots());
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+typename Spline<Scalar_, Dim_, Degree_>::PointType Spline<Scalar_, Dim_, Degree_>::operator()(Scalar u) const {
+  enum { Order = SplineTraits<Spline>::OrderAtCompileTime };
+
+  const DenseIndex span = this->span(u);
+  const DenseIndex p = degree();
+  const BasisVectorType basis_funcs = basisFunctions(u);
+
+  const Replicate<BasisVectorType, Dimension, 1> ctrl_weights(basis_funcs);
+  const Block<const ControlPointVectorType, Dimension, Order> ctrl_pts(ctrls(), 0, span - p, Dimension, p + 1);
+  return (ctrl_weights * ctrl_pts).rowwise().sum();
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+template <typename SplineType, typename DerivativeType>
+void derivativesImpl(const SplineType& spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType& der) {
+  enum { Dimension = SplineTraits<SplineType>::Dimension };
+  enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
+  enum { DerivativeOrder = DerivativeType::ColsAtCompileTime };
+
+  typedef typename SplineTraits<SplineType>::ControlPointVectorType ControlPointVectorType;
+  typedef typename SplineTraits<SplineType, DerivativeOrder>::BasisDerivativeType BasisDerivativeType;
+  typedef typename BasisDerivativeType::ConstRowXpr BasisDerivativeRowXpr;
+
+  const DenseIndex p = spline.degree();
+  const DenseIndex span = spline.span(u);
+
+  const DenseIndex n = (std::min)(p, order);
+
+  der.resize(Dimension, n + 1);
+
+  // Retrieve the basis function derivatives up to the desired order...
+  const BasisDerivativeType basis_func_ders = spline.template basisFunctionDerivatives<DerivativeOrder>(u, n + 1);
+
+  // ... and perform the linear combinations of the control points.
+  for (DenseIndex der_order = 0; der_order < n + 1; ++der_order) {
+    const Replicate<BasisDerivativeRowXpr, Dimension, 1> ctrl_weights(basis_func_ders.row(der_order));
+    const Block<const ControlPointVectorType, Dimension, Order> ctrl_pts(spline.ctrls(), 0, span - p, Dimension, p + 1);
+    der.col(der_order) = (ctrl_weights * ctrl_pts).rowwise().sum();
+  }
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::DerivativeType Spline<Scalar_, Dim_, Degree_>::derivatives(
+    Scalar u, DenseIndex order) const {
+  typename SplineTraits<Spline>::DerivativeType res;
+  derivativesImpl(*this, u, order, res);
+  return res;
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+template <int DerivativeOrder>
+typename SplineTraits<Spline<Scalar_, Dim_, Degree_>, DerivativeOrder>::DerivativeType
+Spline<Scalar_, Dim_, Degree_>::derivatives(Scalar u, DenseIndex order) const {
+  typename SplineTraits<Spline, DerivativeOrder>::DerivativeType res;
+  derivativesImpl(*this, u, order, res);
+  return res;
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisVectorType Spline<Scalar_, Dim_, Degree_>::basisFunctions(
+    Scalar u) const {
+  return Spline::BasisFunctions(u, degree(), knots());
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+template <typename Scalar_, int Dim_, int Degree_>
+template <typename DerivativeType>
+void Spline<Scalar_, Dim_, Degree_>::BasisFunctionDerivativesImpl(
+    const typename Spline<Scalar_, Dim_, Degree_>::Scalar u, const DenseIndex order, const DenseIndex p,
+    const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& U, DerivativeType& N_) {
+  typedef Spline<Scalar_, Dim_, Degree_> SplineType;
+  enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
+
+  const DenseIndex span = SplineType::Span(u, p, U);
+
+  const DenseIndex n = (std::min)(p, order);
+
+  N_.resize(n + 1, p + 1);
+
+  BasisVectorType left = BasisVectorType::Zero(p + 1);
+  BasisVectorType right = BasisVectorType::Zero(p + 1);
+
+  Matrix<Scalar, Order, Order> ndu(p + 1, p + 1);
+
+  Scalar saved, temp;  // FIXME: These were double instead of Scalar. Was there a reason for that?
+
+  ndu(0, 0) = 1.0;
+
+  DenseIndex j;
+  for (j = 1; j <= p; ++j) {
+    left[j] = u - U[span + 1 - j];
+    right[j] = U[span + j] - u;
+    saved = 0.0;
+
+    for (DenseIndex r = 0; r < j; ++r) {
+      /* Lower triangle */
+      ndu(j, r) = right[r + 1] + left[j - r];
+      temp = ndu(r, j - 1) / ndu(j, r);
+      /* Upper triangle */
+      ndu(r, j) = static_cast<Scalar>(saved + right[r + 1] * temp);
+      saved = left[j - r] * temp;
+    }
+
+    ndu(j, j) = static_cast<Scalar>(saved);
+  }
+
+  for (j = p; j >= 0; --j) N_(0, j) = ndu(j, p);
+
+  // Compute the derivatives
+  DerivativeType a(n + 1, p + 1);
+  DenseIndex r = 0;
+  for (; r <= p; ++r) {
+    DenseIndex s1, s2;
+    s1 = 0;
+    s2 = 1;  // alternate rows in array a
+    a(0, 0) = 1.0;
+
+    // Compute the k-th derivative
+    for (DenseIndex k = 1; k <= static_cast<DenseIndex>(n); ++k) {
+      Scalar d = 0.0;
+      DenseIndex rk, pk, j1, j2;
+      rk = r - k;
+      pk = p - k;
+
+      if (r >= k) {
+        a(s2, 0) = a(s1, 0) / ndu(pk + 1, rk);
+        d = a(s2, 0) * ndu(rk, pk);
+      }
+
+      if (rk >= -1)
+        j1 = 1;
+      else
+        j1 = -rk;
+
+      if (r - 1 <= pk)
+        j2 = k - 1;
+      else
+        j2 = p - r;
+
+      for (j = j1; j <= j2; ++j) {
+        a(s2, j) = (a(s1, j) - a(s1, j - 1)) / ndu(pk + 1, rk + j);
+        d += a(s2, j) * ndu(rk + j, pk);
+      }
+
+      if (r <= pk) {
+        a(s2, k) = -a(s1, k - 1) / ndu(pk + 1, r);
+        d += a(s2, k) * ndu(r, pk);
+      }
+
+      N_(k, r) = static_cast<Scalar>(d);
+      j = s1;
+      s1 = s2;
+      s2 = j;  // Switch rows
+    }
+  }
+
+  /* Multiply through by the correct factors */
+  /* (Eq. [2.9])                             */
+  r = p;
+  for (DenseIndex k = 1; k <= static_cast<DenseIndex>(n); ++k) {
+    for (j = p; j >= 0; --j) N_(k, j) *= r;
+    r *= p - k;
+  }
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType
+Spline<Scalar_, Dim_, Degree_>::basisFunctionDerivatives(Scalar u, DenseIndex order) const {
+  typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType der;
+  BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
+  return der;
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+template <int DerivativeOrder>
+typename SplineTraits<Spline<Scalar_, Dim_, Degree_>, DerivativeOrder>::BasisDerivativeType
+Spline<Scalar_, Dim_, Degree_>::basisFunctionDerivatives(Scalar u, DenseIndex order) const {
+  typename SplineTraits<Spline<Scalar_, Dim_, Degree_>, DerivativeOrder>::BasisDerivativeType der;
+  BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
+  return der;
+}
+
+template <typename Scalar_, int Dim_, int Degree_>
+typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType
+Spline<Scalar_, Dim_, Degree_>::BasisFunctionDerivatives(
+    const typename Spline<Scalar_, Dim_, Degree_>::Scalar u, const DenseIndex order, const DenseIndex degree,
+    const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& knots) {
+  typename SplineTraits<Spline>::BasisDerivativeType der;
+  BasisFunctionDerivativesImpl(u, order, degree, knots, der);
+  return der;
+}
+}  // namespace Eigen
+
+#endif  // EIGEN_SPLINE_H
diff --git a/contrib/Eigen/src/Splines/SplineFitting.h b/contrib/Eigen/src/Splines/SplineFitting.h
new file mode 100644
index 0000000..bb39872
--- /dev/null
+++ b/contrib/Eigen/src/Splines/SplineFitting.h
@@ -0,0 +1,397 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPLINE_FITTING_H
+#define EIGEN_SPLINE_FITTING_H
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <vector>
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "SplineFwd.h"
+
+#include "../../../../Eigen/LU"
+#include "../../../../Eigen/QR"
+
+namespace Eigen {
+/**
+ * \brief Computes knot averages.
+ * \ingroup Splines_Module
+ *
+ * The knots are computed as
+ * \f{align*}
+ *  u_0 & = \hdots = u_p = \bar{u}_0 \\
+ *  u_{m-p} & = \hdots = u_{m} = \bar{u}_n \\
+ *  u_{j+p} & = \frac{1}{p}\sum_{i=j}^{j+p-1}\bar{u}_i \quad\quad j=1,\hdots,n-p
+ * \f}
+ * where \f$p\f$ is the degree, \f$m+1\f$ the number of knots of the desired
+ * interpolating spline, and \f$\bar{u}_0,\hdots,\bar{u}_n\f$ the input
+ * parameters, which may span any interval, not just \f$[0,1]\f$.
+ *
+ * \param[in] parameters The input parameters. During interpolation one for each data point.
+ * \param[in] degree The spline degree which is used during the interpolation.
+ * \param[out] knots The output knot vector.
+ *
+ * \sa Les Piegl and Wayne Tiller, The NURBS book (2nd ed.), 1997, 9.2.1 Global Curve Interpolation to Point Data
+ **/
+template <typename KnotVectorType>
+void KnotAveraging(const KnotVectorType& parameters, DenseIndex degree, KnotVectorType& knots) {
+  knots.resize(parameters.size() + degree + 1);
+
+  for (DenseIndex j = 1; j < parameters.size() - degree; ++j) knots(j + degree) = parameters.segment(j, degree).mean();
+
+  // The boundary knots replicate the first and last parameter so that the
+  // spline domain matches the parameter range, whatever interval it spans.
+  knots.head(degree + 1).setConstant(parameters(0));
+  knots.tail(degree + 1).setConstant(parameters(placeholders::last));
+}
+
+/**
+ * \brief Computes knot averages when derivative constraints are present.
+ * Note that this is a technical interpretation of the referenced article
+ * since the algorithm contained therein is incorrect as written.
+ * \ingroup Splines_Module
+ *
+ * \param[in] parameters The parameters at which the interpolation B-Spline
+ *            will intersect the given interpolation points. The parameters
+ *            are assumed to be a non-decreasing sequence.
+ * \param[in] degree The degree of the interpolating B-Spline. This must be
+ *            greater than zero.
+ * \param[in] derivativeIndices The indices corresponding to parameters at
+ *            which there are derivative constraints. The indices are assumed
+ *            to be a non-decreasing sequence.
+ * \param[out] knots The calculated knot vector. These will be returned as a
+ *             non-decreasing sequence
+ *
+ * \sa Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008.
+ * Curve interpolation with directional constraints for engineering design.
+ * Engineering with Computers
+ **/
+template <typename KnotVectorType, typename ParameterVectorType, typename IndexArray>
+void KnotAveragingWithDerivatives(const ParameterVectorType& parameters, const unsigned int degree,
+                                  const IndexArray& derivativeIndices, KnotVectorType& knots) {
+  typedef typename ParameterVectorType::Scalar Scalar;
+
+  DenseIndex numParameters = parameters.size();
+  DenseIndex numDerivatives = derivativeIndices.size();
+
+  if (numDerivatives < 1) {
+    KnotAveraging(parameters, degree, knots);
+    return;
+  }
+
+  DenseIndex startIndex;
+  DenseIndex endIndex;
+
+  DenseIndex numInternalDerivatives = numDerivatives;
+
+  if (derivativeIndices[0] == 0) {
+    startIndex = 0;
+    --numInternalDerivatives;
+  } else {
+    startIndex = 1;
+  }
+  if (derivativeIndices[numDerivatives - 1] == numParameters - 1) {
+    endIndex = numParameters - degree;
+    --numInternalDerivatives;
+  } else {
+    endIndex = numParameters - degree - 1;
+  }
+
+  // There are (endIndex - startIndex + 1) knots obtained from the averaging
+  // and 2 for the first and last parameters.
+  DenseIndex numAverageKnots = endIndex - startIndex + 3;
+  KnotVectorType averageKnots(numAverageKnots);
+  averageKnots[0] = parameters[0];
+
+  int newKnotIndex = 0;
+  for (DenseIndex i = startIndex; i <= endIndex; ++i)
+    averageKnots[++newKnotIndex] = parameters.segment(i, degree).mean();
+  averageKnots[++newKnotIndex] = parameters[numParameters - 1];
+
+  newKnotIndex = -1;
+
+  ParameterVectorType temporaryParameters(numParameters + 1);
+  KnotVectorType derivativeKnots(numInternalDerivatives);
+  for (DenseIndex i = 0; i < numAverageKnots - 1; ++i) {
+    temporaryParameters[0] = averageKnots[i];
+    ParameterVectorType parameterIndices(numParameters);
+    int temporaryParameterIndex = 1;
+    for (DenseIndex j = 0; j < numParameters; ++j) {
+      Scalar parameter = parameters[j];
+      if (parameter >= averageKnots[i] && parameter < averageKnots[i + 1]) {
+        parameterIndices[temporaryParameterIndex] = j;
+        temporaryParameters[temporaryParameterIndex++] = parameter;
+      }
+    }
+    temporaryParameters[temporaryParameterIndex] = averageKnots[i + 1];
+
+    for (int j = 0; j <= temporaryParameterIndex - 2; ++j) {
+      for (DenseIndex k = 0; k < derivativeIndices.size(); ++k) {
+        if (parameterIndices[j + 1] == derivativeIndices[k] && parameterIndices[j + 1] != 0 &&
+            parameterIndices[j + 1] != numParameters - 1) {
+          derivativeKnots[++newKnotIndex] = temporaryParameters.segment(j, 3).mean();
+          break;
+        }
+      }
+    }
+  }
+
+  KnotVectorType temporaryKnots(averageKnots.size() + derivativeKnots.size());
+
+  std::merge(averageKnots.data(), averageKnots.data() + averageKnots.size(), derivativeKnots.data(),
+             derivativeKnots.data() + derivativeKnots.size(), temporaryKnots.data());
+
+  // Number of knots (one for each point and derivative) plus spline order.
+  DenseIndex numKnots = numParameters + numDerivatives + degree + 1;
+  knots.resize(numKnots);
+
+  knots.head(degree).fill(temporaryKnots[0]);
+  knots.tail(degree).fill(temporaryKnots.template tail<1>()[0]);
+  knots.segment(degree, temporaryKnots.size()) = temporaryKnots;
+}
+
+/**
+ * \brief Computes chord length parameters which are required for spline interpolation.
+ * \ingroup Splines_Module
+ *
+ * \param[in] pts The data points to which a spline should be fit.
+ * \param[out] chord_lengths The resulting chord length vector.
+ *
+ * \sa Les Piegl and Wayne Tiller, The NURBS book (2nd ed.), 1997, 9.2.1 Global Curve Interpolation to Point Data
+ **/
+template <typename PointArrayType, typename KnotVectorType>
+void ChordLengths(const PointArrayType& pts, KnotVectorType& chord_lengths) {
+  typedef typename KnotVectorType::Scalar Scalar;
+
+  const DenseIndex n = pts.cols();
+
+  // 1. compute the column-wise norms
+  chord_lengths.resize(pts.cols());
+  chord_lengths[0] = 0;
+  chord_lengths.rightCols(n - 1) =
+      (pts.array().leftCols(n - 1) - pts.array().rightCols(n - 1)).matrix().colwise().norm();
+
+  // 2. compute the partial sums
+  std::partial_sum(chord_lengths.data(), chord_lengths.data() + n, chord_lengths.data());
+
+  // 3. normalize the data
+  chord_lengths /= chord_lengths(n - 1);
+  chord_lengths(n - 1) = Scalar(1);
+}
+
+/**
+ * \brief Spline fitting methods.
+ * \ingroup Splines_Module
+ **/
+template <typename SplineType>
+struct SplineFitting {
+  typedef typename SplineType::KnotVectorType KnotVectorType;
+  typedef typename SplineType::ParameterVectorType ParameterVectorType;
+
+  /**
+   * \brief Fits an interpolating Spline to the given data points.
+   *
+   * \param pts The points for which an interpolating spline will be computed.
+   * \param degree The degree of the interpolating spline.
+   *
+   * \returns A spline interpolating the initially provided points.
+   **/
+  template <typename PointArrayType>
+  static SplineType Interpolate(const PointArrayType& pts, DenseIndex degree);
+
+  /**
+   * \brief Fits an interpolating Spline to the given data points.
+   *
+   * \param pts The points for which an interpolating spline will be computed.
+   * \param degree The degree of the interpolating spline.
+   * \param knot_parameters The knot parameters for the interpolation.
+   *
+   * \returns A spline interpolating the initially provided points.
+   **/
+  template <typename PointArrayType>
+  static SplineType Interpolate(const PointArrayType& pts, DenseIndex degree, const KnotVectorType& knot_parameters);
+
+  /**
+   * \brief Fits an interpolating spline to the given data points and
+   * derivatives.
+   *
+   * \param points The points for which an interpolating spline will be computed.
+   * \param derivatives The desired derivatives of the interpolating spline at interpolation
+   *                    points.
+   * \param derivativeIndices An array indicating which point each derivative belongs to. This
+   *                          must be the same size as @a derivatives.
+   * \param degree The degree of the interpolating spline.
+   *
+   * \returns A spline interpolating @a points with @a derivatives at those points.
+   *
+   * \sa Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008.
+   * Curve interpolation with directional constraints for engineering design.
+   * Engineering with Computers
+   **/
+  template <typename PointArrayType, typename IndexArray>
+  static SplineType InterpolateWithDerivatives(const PointArrayType& points, const PointArrayType& derivatives,
+                                               const IndexArray& derivativeIndices, const unsigned int degree);
+
+  /**
+   * \brief Fits an interpolating spline to the given data points and derivatives.
+   *
+   * \param points The points for which an interpolating spline will be computed.
+   * \param derivatives The desired derivatives of the interpolating spline at interpolation points.
+   * \param derivativeIndices An array indicating which point each derivative belongs to. This
+   *                          must be the same size as @a derivatives.
+   * \param degree The degree of the interpolating spline.
+   * \param parameters The parameters corresponding to the interpolation points.
+   *
+   * \returns A spline interpolating @a points with @a derivatives at those points.
+   *
+   * \sa Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008.
+   * Curve interpolation with directional constraints for engineering design.
+   * Engineering with Computers
+   */
+  template <typename PointArrayType, typename IndexArray>
+  static SplineType InterpolateWithDerivatives(const PointArrayType& points, const PointArrayType& derivatives,
+                                               const IndexArray& derivativeIndices, const unsigned int degree,
+                                               const ParameterVectorType& parameters);
+};
+
+template <typename SplineType>
+template <typename PointArrayType>
+SplineType SplineFitting<SplineType>::Interpolate(const PointArrayType& pts, DenseIndex degree,
+                                                  const KnotVectorType& knot_parameters) {
+  typedef typename SplineType::KnotVectorType::Scalar Scalar;
+  typedef typename SplineType::ControlPointVectorType ControlPointVectorType;
+
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+
+  KnotVectorType knots;
+  KnotAveraging(knot_parameters, degree, knots);
+
+  DenseIndex n = pts.cols();
+  MatrixType A = MatrixType::Zero(n, n);
+  for (DenseIndex i = 1; i < n - 1; ++i) {
+    const DenseIndex span = SplineType::Span(knot_parameters[i], degree, knots);
+
+    // The segment call should somehow be told the spline order at compile time.
+    A.row(i).segment(span - degree, degree + 1) = SplineType::BasisFunctions(knot_parameters[i], degree, knots);
+  }
+  A(0, 0) = 1.0;
+  A(n - 1, n - 1) = 1.0;
+
+  HouseholderQR<MatrixType> qr(A);
+
+  // Here, we are creating a temporary due to an Eigen issue.
+  ControlPointVectorType ctrls = qr.solve(MatrixType(pts.transpose())).transpose();
+
+  return SplineType(knots, ctrls);
+}
+
+template <typename SplineType>
+template <typename PointArrayType>
+SplineType SplineFitting<SplineType>::Interpolate(const PointArrayType& pts, DenseIndex degree) {
+  KnotVectorType chord_lengths;  // knot parameters
+  ChordLengths(pts, chord_lengths);
+  return Interpolate(pts, degree, chord_lengths);
+}
+
+template <typename SplineType>
+template <typename PointArrayType, typename IndexArray>
+SplineType SplineFitting<SplineType>::InterpolateWithDerivatives(const PointArrayType& points,
+                                                                 const PointArrayType& derivatives,
+                                                                 const IndexArray& derivativeIndices,
+                                                                 const unsigned int degree,
+                                                                 const ParameterVectorType& parameters) {
+  typedef typename SplineType::KnotVectorType::Scalar Scalar;
+  typedef typename SplineType::ControlPointVectorType ControlPointVectorType;
+
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+
+  const DenseIndex n = points.cols() + derivatives.cols();
+
+  KnotVectorType knots;
+
+  KnotAveragingWithDerivatives(parameters, degree, derivativeIndices, knots);
+
+  // fill matrix
+  MatrixType A = MatrixType::Zero(n, n);
+
+  // Use these dimensions for quicker populating, then transpose for solving.
+  MatrixType b(points.rows(), n);
+
+  DenseIndex startRow;
+  DenseIndex derivativeStart;
+
+  // End derivatives.
+  if (derivativeIndices[0] == 0) {
+    A.template block<1, 2>(1, 0) << -1, 1;
+
+    Scalar y = (knots(degree + 1) - knots(0)) / degree;
+    b.col(1) = y * derivatives.col(0);
+
+    startRow = 2;
+    derivativeStart = 1;
+  } else {
+    startRow = 1;
+    derivativeStart = 0;
+  }
+  if (derivativeIndices[derivatives.cols() - 1] == points.cols() - 1) {
+    A.template block<1, 2>(n - 2, n - 2) << -1, 1;
+
+    Scalar y = (knots(knots.size() - 1) - knots(knots.size() - (degree + 2))) / degree;
+    b.col(b.cols() - 2) = y * derivatives.col(derivatives.cols() - 1);
+  }
+
+  DenseIndex row = startRow;
+  DenseIndex derivativeIndex = derivativeStart;
+  for (DenseIndex i = 1; i < parameters.size() - 1; ++i) {
+    const DenseIndex span = SplineType::Span(parameters[i], degree, knots);
+
+    if (derivativeIndex < derivativeIndices.size() && derivativeIndices[derivativeIndex] == i) {
+      A.block(row, span - degree, 2, degree + 1) =
+          SplineType::BasisFunctionDerivatives(parameters[i], 1, degree, knots);
+
+      b.col(row++) = points.col(i);
+      b.col(row++) = derivatives.col(derivativeIndex++);
+    } else {
+      A.row(row).segment(span - degree, degree + 1) = SplineType::BasisFunctions(parameters[i], degree, knots);
+      b.col(row++) = points.col(i);
+    }
+  }
+  b.col(0) = points.col(0);
+  b.col(b.cols() - 1) = points.col(points.cols() - 1);
+  A(0, 0) = 1;
+  A(n - 1, n - 1) = 1;
+
+  // Solve
+  FullPivLU<MatrixType> lu(A);
+  ControlPointVectorType controlPoints = lu.solve(MatrixType(b.transpose())).transpose();
+
+  SplineType spline(knots, controlPoints);
+
+  return spline;
+}
+
+template <typename SplineType>
+template <typename PointArrayType, typename IndexArray>
+SplineType SplineFitting<SplineType>::InterpolateWithDerivatives(const PointArrayType& points,
+                                                                 const PointArrayType& derivatives,
+                                                                 const IndexArray& derivativeIndices,
+                                                                 const unsigned int degree) {
+  ParameterVectorType parameters;
+  ChordLengths(points, parameters);
+  return InterpolateWithDerivatives(points, derivatives, derivativeIndices, degree, parameters);
+}
+}  // namespace Eigen
+
+#endif  // EIGEN_SPLINE_FITTING_H
diff --git a/contrib/Eigen/src/Splines/SplineFwd.h b/contrib/Eigen/src/Splines/SplineFwd.h
new file mode 100644
index 0000000..48cce13
--- /dev/null
+++ b/contrib/Eigen/src/Splines/SplineFwd.h
@@ -0,0 +1,110 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_SPLINES_FWD_H
+#define EIGEN_SPLINES_FWD_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+#include "../../../../Eigen/Core"
+
+namespace Eigen {
+template <typename Scalar, int Dim, int Degree = Dynamic>
+class Spline;
+
+template <typename SplineType, int DerivativeOrder = Dynamic>
+struct SplineTraits {};
+
+/**
+ * \ingroup Splines_Module
+ * \brief Compile-time attributes of the Spline class for Dynamic degree.
+ **/
+template <typename Scalar_, int Dim_, int Degree_>
+struct SplineTraits<Spline<Scalar_, Dim_, Degree_>, Dynamic> {
+  typedef Scalar_ Scalar; /*!< The spline curve's scalar type. */
+  enum { Dimension = Dim_ /*!< The spline curve's dimension. */ };
+  enum { Degree = Degree_ /*!< The spline curve's degree. */ };
+
+  enum {
+    OrderAtCompileTime = Degree_ == Dynamic ? Dynamic : Degree_ + 1 /*!< The spline curve's order at compile-time. */
+  };
+  enum {
+    NumOfDerivativesAtCompileTime = OrderAtCompileTime /*!< The number of derivatives defined for the current spline. */
+  };
+
+  enum { DerivativeMemoryLayout = Dimension == 1 ? RowMajor : ColMajor /*!< The derivative type's memory layout. */ };
+
+  /** \brief The data type used to store non-zero basis functions. */
+  typedef Array<Scalar, 1, OrderAtCompileTime> BasisVectorType;
+
+  /** \brief The data type used to store the values of the basis function derivatives. */
+  typedef Array<Scalar, Dynamic, Dynamic, RowMajor, NumOfDerivativesAtCompileTime, OrderAtCompileTime>
+      BasisDerivativeType;
+
+  /** \brief The data type used to store the spline's derivative values. */
+  typedef Array<Scalar, Dimension, Dynamic, DerivativeMemoryLayout, Dimension, NumOfDerivativesAtCompileTime>
+      DerivativeType;
+
+  /** \brief The point type the spline is representing. */
+  typedef Array<Scalar, Dimension, 1> PointType;
+
+  /** \brief The data type used to store knot vectors. */
+  typedef Array<Scalar, 1, Dynamic> KnotVectorType;
+
+  /** \brief The data type used to store parameter vectors. */
+  typedef Array<Scalar, 1, Dynamic> ParameterVectorType;
+
+  /** \brief The data type representing the spline's control points. */
+  typedef Array<Scalar, Dimension, Dynamic> ControlPointVectorType;
+};
+
+/**
+ * \ingroup Splines_Module
+ * \brief Compile-time attributes of the Spline class for fixed degree.
+ *
+ * The traits class inherits all attributes from the SplineTraits of Dynamic degree.
+ **/
+template <typename Scalar_, int Dim_, int Degree_, int _DerivativeOrder>
+struct SplineTraits<Spline<Scalar_, Dim_, Degree_>, _DerivativeOrder>
+    : public SplineTraits<Spline<Scalar_, Dim_, Degree_> > {
+  enum {
+    OrderAtCompileTime = Degree_ == Dynamic ? Dynamic : Degree_ + 1 /*!< The spline curve's order at compile-time. */
+  };
+  enum {
+    NumOfDerivativesAtCompileTime =
+        _DerivativeOrder == Dynamic
+            ? Dynamic
+            : _DerivativeOrder + 1 /*!< The number of derivatives defined for the current spline. */
+  };
+
+  enum { DerivativeMemoryLayout = Dim_ == 1 ? RowMajor : ColMajor /*!< The derivative type's memory layout. */ };
+
+  /** \brief The data type used to store the values of the basis function derivatives. */
+  typedef Array<Scalar_, Dynamic, Dynamic, RowMajor, NumOfDerivativesAtCompileTime, OrderAtCompileTime>
+      BasisDerivativeType;
+
+  /** \brief The data type used to store the spline's derivative values. */
+  typedef Array<Scalar_, Dim_, Dynamic, DerivativeMemoryLayout, Dim_, NumOfDerivativesAtCompileTime> DerivativeType;
+};
+
+/** \brief 2D float B-spline with dynamic degree. */
+typedef Spline<float, 2> Spline2f;
+
+/** \brief 3D float B-spline with dynamic degree. */
+typedef Spline<float, 3> Spline3f;
+
+/** \brief 2D double B-spline with dynamic degree. */
+typedef Spline<double, 2> Spline2d;
+
+/** \brief 3D double B-spline with dynamic degree. */
+typedef Spline<double, 3> Spline3d;
+}  // namespace Eigen
+
+#endif  // EIGEN_SPLINES_FWD_H
diff --git a/contrib/Eigen/src/StructuredMatrices/Bccb.h b/contrib/Eigen/src/StructuredMatrices/Bccb.h
new file mode 100644
index 0000000..0698656
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/Bccb.h
@@ -0,0 +1,802 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] P. J. Davis, "Circulant Matrices", Wiley, 1979. Diagonalization of
+//      circulant and block circulant matrices by the DFT; the closed-form
+//      eigenstructure used by eigenvalues()/eigenvectors(), and the SVD and
+//      pseudo-inverse below, follow from it by taking moduli/phases of the
+//      eigenvalues.
+//  [2] R. H. Chan and X.-Q. Jin, "An Introduction to Iterative Toeplitz
+//      Solvers", SIAM, 2007. BCCB matrices are diagonalized by the 2-D DFT
+//      F_{n1} (x) F_{n2}; the FFT-based products and solves below, and the use
+//      of BCCB operators as preconditioners for two-level Toeplitz (BTTB)
+//      systems, follow this reference.
+//  [3] G. H. Golub and C. F. Van Loan, "Matrix Computations", 4th ed., Johns
+//      Hopkins University Press, 2013, chapter 5.4 (numerical rank conventions).
+//  [4] J. J. Dongarra, J. R. Bunch, C. B. Moler and G. W. Stewart, "LINPACK
+//      Users' Guide", SIAM, 1979. determinant()'s balanced accumulation follows
+//      the convention of its xGEDI routines, which return determinants as a
+//      (fraction, exponent) pair to avoid spurious overflow/underflow.
+//  [5] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, the property the balanced
+//      accumulation, the rescaled rank threshold and the scaled 2-D FFT
+//      products rely on.
+
+#ifndef EIGEN_STRUCTURED_BCCB_H
+#define EIGEN_STRUCTURED_BCCB_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int BlockSize_ = Dynamic, int NumBlocks_ = Dynamic>
+class Bccb;
+
+namespace internal {
+
+/** \internal Compile-time product of the two circulant levels, Dynamic-aware. */
+constexpr int bccb_dim(int a, int b) { return (a == Dynamic || b == Dynamic) ? Dynamic : a * b; }
+
+template <typename Scalar_, int BlockSize_, int NumBlocks_>
+struct traits<Bccb<Scalar_, BlockSize_, NumBlocks_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = bccb_dim(BlockSize_, NumBlocks_);
+  static constexpr int ColsAtCompileTime = RowsAtCompileTime;
+  static constexpr int MaxRowsAtCompileTime = RowsAtCompileTime;
+  static constexpr int MaxColsAtCompileTime = RowsAtCompileTime;
+  // Deliberately no NestByRefBit: transpose(), conjugate() and adjoint() return
+  // owning temporaries, so Product must nest the operator by value for a
+  // delayed-evaluated product expression to keep its left factor alive. The copy
+  // is O(N), negligible against the O(N log N) product evaluation.
+  static constexpr unsigned int Flags = 0;
+};
+
+template <typename Scalar_, int BlockSize_, int NumBlocks_>
+struct evaluator_traits<Bccb<Scalar_, BlockSize_, NumBlocks_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class Bccb
+ * \brief A block circulant matrix with circulant blocks (BCCB), the matrix of a
+ * two-dimensional circular convolution, represented by its n2 x n1 generating
+ * array.
+ *
+ * A BCCB matrix is the \c N x \c N matrix, \c N = n1*n2, that is circulant at two
+ * levels: it is an n1 x n1 block circulant whose n2 x n2 blocks are themselves
+ * circulant. With the generating array \c G (column \c k holds the first column
+ * of the k-th block), entry \c (i,j) with \c i = b1*n2 + i2, \c j = c1*n2 + j2
+ * equals
+ * \f[ C_{i,j}=G_{(i_2-j_2)\bmod n_2,\,(b_1-c_1)\bmod n_1}. \f]
+ * On a column-major reshaped vector, \f$C\,\operatorname{vec}(X)
+ * =\operatorname{vec}(G\mathbin{\circledast}X)\f$, where \f$\circledast\f$
+ * denotes 2-D circular convolution.
+ *
+ * BCCB matrices are diagonalized by the 2-D discrete Fourier transform
+ * \f$ F_{n_1} \otimes F_{n_2} \f$ ([1], [2]): the operator's \em symbol -- the 2-D
+ * DFT of \c G -- holds the eigenvalues. Products reuse that symbol or, for an
+ * awkward transform size, an equivalent cached padded-embedding symbol. This
+ * yields O(N log N) products (\c operator*), an O(N log N) direct
+ * (pseudo-inverse) solve (\ref solve), and closed-form factorizations: the
+ * eigendecomposition (\ref eigenvalues, \ref eigenvectors) and the SVD
+ * (\ref singularValues, \ref matrixU, \ref matrixV) in the 2-D Fourier basis,
+ * plus \ref rank, \ref inverse and \ref determinant. The class is closed under
+ * \ref transpose, \ref conjugate and \ref adjoint, which reuse the cached symbols.
+ * BCCB operators are the workhorse of image deblurring with periodic boundary
+ * conditions, and the natural preconditioners for two-level Toeplitz (BTTB)
+ * systems [2].
+ *
+ * The operator stores its own copy of the generating array and derives from
+ * \c EigenBase. Because \c operator* returns an Eigen product expression, a
+ * \c Bccb also drops into the matrix-free iterative solvers, and it can be
+ * assigned to a dense matrix when an explicit representation is needed. As with
+ * any matrix-free operator, the iterative solvers must be instantiated with
+ * \c IdentityPreconditioner (e.g.
+ * \c ConjugateGradient<Bccb<double>,Lower|Upper,IdentityPreconditioner>):
+ * the default preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * Spectral operations use FFTs of the exact sizes \c n1 and \c n2. Products use
+ * those sizes when both are 5-smooth; otherwise an equivalent per-axis
+ * circulant embedding pads each awkward dimension to a 5-smooth size, avoiding
+ * the default kissfft backend's slow generic butterfly for large prime factors.
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ * \tparam BlockSize_ the circulant block dimension \c n2 at compile time, or
+ *         \c Dynamic (the default).
+ * \tparam NumBlocks_ the number of blocks \c n1 at compile time, or \c Dynamic
+ *         (the default).
+ *
+ * \sa class Circulant, makeBccb()
+ */
+template <typename Scalar_, int BlockSize_, int NumBlocks_>
+class Bccb : public EigenBase<Bccb<Scalar_, BlockSize_, NumBlocks_>> {
+  enum DenseAssignment { SetAssignment, AddAssignment, SubAssignment };
+
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using Complex = std::complex<RealScalar>;
+  // The two-level structure keys on the *column-major* flattening of the n2 x n1
+  // generating array and symbol (entry (k2, k1) is flat index k1*n2 + k2), so
+  // every internal 2-D type is pinned to ColMajor explicitly: the semantics must
+  // not change under EIGEN_DEFAULT_TO_ROW_MAJOR. The single-row special case
+  // only satisfies Eigen's rule that 1 x n matrices be row-major; with one row
+  // the two orders coincide.
+  using GeneratorType =
+      Matrix<Scalar, BlockSize_, NumBlocks_, (BlockSize_ == 1 && NumBlocks_ != 1) ? int(RowMajor) : int(ColMajor)>;
+  using ComplexArray = Matrix<Complex, Dynamic, Dynamic, ColMajor>;
+  using ComplexVector = Matrix<Complex, Dynamic, 1>;
+  using RealVector = Matrix<RealScalar, Dynamic, 1>;
+  using RealArray = Matrix<RealScalar, Dynamic, Dynamic, ColMajor>;
+  using ComplexMatrix = Matrix<Complex, Dynamic, Dynamic, ColMajor>;
+
+  static constexpr int RowsAtCompileTime = internal::bccb_dim(BlockSize_, NumBlocks_);
+  static constexpr int ColsAtCompileTime = RowsAtCompileTime;
+  static constexpr int MaxRowsAtCompileTime = RowsAtCompileTime;
+  static constexpr int MaxColsAtCompileTime = RowsAtCompileTime;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(RowsAtCompileTime, ColsAtCompileTime);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const Bccb>'s default StrideType
+  // argument reads it, so its absence makes internal::is_ref_compatible SFINAE to
+  // false and keeps the iterative solvers on their matrix-free path.
+
+  /** Builds a BCCB matrix from its generating array \a generator: column \c k is
+   * the first column of the k-th circulant block.
+   *
+   * When the matrix is large enough for products to take the FFT path, the 2-D
+   * DFT of the array -- the eigenvalues of the matrix -- and any padded product
+   * symbol are computed here. Subsequent products and solves reuse the applicable
+   * cached transform. */
+  template <typename Derived>
+  explicit Bccb(const MatrixBase<Derived>& generator) : m_g(generator) {
+    eigen_assert(m_g.rows() > 0 && m_g.cols() > 0 && "Bccb generator must be non-empty");
+    if (m_g.size() > internal::structured_direct_threshold()) {
+      m_symbol = computeSymbol();
+      m_prodSymbol = computeProdSymbol(m_g);
+    }
+    m_fftUsable = computeFftUsable();
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_g.size(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_g.size(); }
+
+  /** \returns the circulant block dimension \c n2. */
+  Index blockSize() const { return m_g.rows(); }
+  /** \returns the number of blocks \c n1 in each block row. */
+  Index numBlocks() const { return m_g.cols(); }
+  /** \returns the generating array. */
+  const GeneratorType& generator() const { return m_g; }
+
+  /** \returns the symbol of the operator: the 2-D DFT of the generating array,
+   * an n2 x n1 complex array whose entries are the eigenvalues of the matrix
+   * (see \ref eigenvalues for the ordering). Cached when the operator is large
+   * enough for products to take the FFT path, computed on the fly for small
+   * operators. */
+  ComplexArray symbol() const { return m_symbol.size() > 0 ? m_symbol : computeSymbol(); }
+
+  /** \returns the coefficient at row \a row and column \a col. */
+  Scalar coeff(Index row, Index col) const {
+    const Index n2 = blockSize();
+    Index k2 = row % n2 - col % n2;
+    if (k2 < 0) k2 += n2;
+    Index k1 = row / n2 - col / n2;
+    if (k1 < 0) k1 += numBlocks();
+    return m_g.coeff(k2, k1);
+  }
+
+  /** \returns the transpose of \c *this, itself a \c Bccb operator: the one
+   * generated by the array index-reversed in both dimensions. The cached
+   * symbols, when present, are reused -- the symbols of the transpose are their
+   * two-dimensional index reversals (embedding a generator commutes with
+   * index-reversing it, per axis, so the padded product symbol follows the same
+   * rule at its own grid) -- so no FFT is recomputed. */
+  Bccb transpose() const { return Bccb(reverse2(m_g), reverse2(m_symbol), reverse2(m_prodSymbol)); }
+
+  /** \returns the complex conjugate of \c *this, itself a \c Bccb operator. The
+   * cached symbols, when present, are reused: the symbols of the conjugate are
+   * the conjugated two-dimensional index reversals of the symbols. */
+  Bccb conjugate() const {
+    return Bccb(m_g.conjugate(), reverse2(m_symbol).conjugate(), reverse2(m_prodSymbol).conjugate());
+  }
+
+  /** \returns the adjoint of \c *this, itself a \c Bccb operator. The cached
+   * symbols, when present, are reused: the symbols of the adjoint are the
+   * elementwise conjugates of the symbols (the eigenvalues conjugate while the
+   * 2-D Fourier eigenbasis stays fixed). */
+  Bccb adjoint() const { return Bccb(reverse2(m_g).conjugate(), m_symbol.conjugate(), m_prodSymbol.conjugate()); }
+
+  /** \returns the minimum-norm least-squares solution of \c (*this) * x = b,
+   * computed directly in the 2-D Fourier domain. Symbol entries whose modulus
+   * reaches the rank threshold (see \ref rank) are inverted; the remaining ones
+   * are treated as exact zeros, so the result is the pseudo-inverse applied to
+   * \a b. For a non-singular operator this is the exact solution. Supports
+   * multiple right-hand sides. */
+  template <typename Rhs>
+  Matrix<Scalar, RowsAtCompileTime, Rhs::ColsAtCompileTime> solve(const MatrixBase<Rhs>& b) const {
+    EIGEN_STATIC_ASSERT(RowsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(RowsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    const Index N = rows();
+    eigen_assert(b.rows() == N && "right-hand side has the wrong number of rows");
+    const ComplexArray s = symbol();
+    RealArray mods;
+    RealScalar tol;
+    scaledModuli(s, mods, tol);
+    ComplexArray sinv(s.rows(), s.cols());
+    // Strictly-below-threshold entries are zeroed, matching SVDBase::rank(), so a
+    // smallest-normal 1x1 operator stays invertible. A comparison with NaN is
+    // false, so NaN symbol entries stay in the inverted set and propagate to the
+    // output instead of being silently zeroed.
+    // The packet path sanitizes discarded entries before division; exceptional
+    // packets retain the scalar branch and balanced reciprocal.
+    internal::structured_symbol_reciprocal(s.data(), mods.data(), tol, sinv.data(), s.size());
+    Matrix<Scalar, RowsAtCompileTime, Rhs::ColsAtCompileTime> x(N, b.cols());
+    if (!b.allFinite()) {
+      // A non-finite right-hand side cannot go through the transforms (see
+      // addProduct): apply the pseudo-inverse -- itself a BCCB operator,
+      // generated by the 2-D inverse DFT of the thresholded reciprocal symbol --
+      // through the direct kernel so Inf/NaN propagate entrywise.
+      const GeneratorType pg = generatorFromSymbol(sinv);
+      x.setZero();
+      Bccb(pg, ComplexArray(), ComplexArray()).directProduct(x, b.derived(), Scalar(1));
+      return x;
+    }
+    // The right-hand side is finite here (checked above), so no per-column
+    // direct kernel can be needed.
+    applySymbol(x, sinv, b.derived(), Scalar(1), /*accumulate=*/false,
+                [](Index) { eigen_assert(false && "non-finite column requires a direct kernel"); });
+    return x;
+  }
+
+  /** \returns the numerical rank: the number of symbol entries whose modulus is
+   * no smaller than the threshold \c N * epsilon * max|symbol|, both evaluated
+   * in an exactly rescaled frame so the moduli cannot overflow (see
+   * scaledModuli()) and clamped from below like \c SVDBase::rank(). This is the
+   * same threshold \ref solve uses to decide which Fourier components to invert,
+   * and the comparison is strict like SVDBase's, so an entry sitting exactly on
+   * the threshold still counts as non-zero. */
+  Index rank() const {
+    const ComplexArray s = symbol();
+    RealArray mods;
+    RealScalar tol;
+    scaledModuli(s, mods, tol);
+    return (!(mods.array() < tol)).count();  // negated so NaN entries count as non-zero
+  }
+
+  /** \returns the inverse of \c *this, itself a \c Bccb operator: the one
+   * generated by the 2-D inverse DFT of the entrywise-inverted symbol.
+   * \warning The operator must be non-singular; use \ref solve for a
+   * pseudo-inverse solve of a rank-deficient operator. */
+  Bccb inverse() const {
+    ComplexArray sinv = symbol().cwiseInverse();
+    const GeneratorType ginv = generatorFromSymbol(sinv);
+    const bool cache = rows() > internal::structured_direct_threshold();
+    return Bccb(ginv, cache ? sinv : ComplexArray(), cache ? computeProdSymbol(ginv) : ComplexArray());
+  }
+
+  /** \returns the determinant, i.e. the product of the eigenvalues (the symbol
+   * entries). The product is accumulated in the balanced form \c m * 2^e (the
+   * split fraction/exponent determinant convention of LINPACK's xGEDI [4]) --
+   * every factor and the running product are renormalized to unit magnitude with
+   * the power of two tracked separately -- so the partial products can neither
+   * overflow nor underflow when the determinant itself is representable, whatever
+   * the ordering of large and small eigenvalues. For a real operator the product
+   * is real up to roundoff, and its real part is returned. */
+  Scalar determinant() const {
+    const ComplexArray s = symbol();
+    Complex det(1);
+    Index exponent = 0;
+    for (Index k1 = 0; k1 < s.cols(); ++k1)
+      for (Index k2 = 0; k2 < s.rows(); ++k2)
+        det = internal::structured_balance(Complex(det * internal::structured_balance(s(k2, k1), exponent)), exponent);
+    return toScalar(internal::structured_ldexp_clamped(det, exponent), std::is_same<RealScalar, Scalar>());
+  }
+
+  /** \returns the eigenvalues as the column-major flattening of the symbol:
+   * eigenvalue \c f1*n2 + f2 is \c symbol()(f2, f1), and its (unit-norm)
+   * eigenvector is the Kronecker product of the 1-D Fourier vectors of
+   * frequencies \c f1 and \c f2, i.e. column \c f1*n2 + f2 of \ref eigenvectors.
+   * Every BCCB matrix is diagonalized by this same 2-D Fourier basis. */
+  ComplexVector eigenvalues() const { return symbol().reshaped(); }
+
+  /** \returns the unitary matrix of eigenvectors: column \c f1*n2 + f2 is the
+   * 2-D Fourier vector matching \c eigenvalues()[f1*n2 + f2].
+   * \note The eigenvector matrix is materialized as a dense \c N x \c N matrix;
+   * unlike the other methods of this class this costs O(N^2) storage. */
+  ComplexMatrix eigenvectors() const {
+    const Index n2 = blockSize(), n1 = numBlocks(), N = rows();
+    ComplexMatrix F(N, N);
+    for (Index f1 = 0; f1 < n1; ++f1)
+      for (Index f2 = 0; f2 < n2; ++f2) fourierColumn(F, f1, f2, f1 * n2 + f2);
+    return F;
+  }
+
+  /** \returns the singular values, sorted in decreasing order: the moduli of the
+   * symbol entries. The ordering is shared with \ref matrixU and \ref matrixV,
+   * so together they form the SVD \c *this = U * singularValues().asDiagonal() * V^H. */
+  RealVector singularValues() const {
+    const ComplexVector s = eigenvalues();
+    const RealVector mods = s.cwiseAbs();
+    const std::vector<Index> perm = internal::structured_svd_permutation(mods);
+    RealVector sv(s.size());
+    for (Index t = 0; t < s.size(); ++t) sv[t] = mods[perm[t]];
+    return sv;
+  }
+
+  /** \returns the matrix of left singular vectors \c U: column \c t is the 2-D
+   * Fourier vector of the t-th largest symbol entry, scaled by its phase (phase 1
+   * for a zero entry). Dense \c N x \c N, see the note in \ref eigenvectors. */
+  ComplexMatrix matrixU() const {
+    const Index n2 = blockSize(), N = rows();
+    const ComplexVector s = eigenvalues();
+    const RealVector mods = s.cwiseAbs();
+    const std::vector<Index> perm = internal::structured_svd_permutation(mods);
+    ComplexMatrix U(N, N);
+    for (Index t = 0; t < N; ++t) {
+      fourierColumn(U, perm[t] / n2, perm[t] % n2, t);
+      const RealScalar a = mods[perm[t]];
+      if (a > RealScalar(0)) U.col(t) *= s[perm[t]] / a;
+    }
+    return U;
+  }
+
+  /** \returns the matrix of right singular vectors \c V: column \c t is the 2-D
+   * Fourier vector of the t-th largest symbol entry. Dense \c N x \c N, see the
+   * note in \ref eigenvectors. */
+  ComplexMatrix matrixV() const {
+    const Index n2 = blockSize(), N = rows();
+    const ComplexVector s = eigenvalues();
+    const std::vector<Index> perm = internal::structured_svd_permutation(RealVector(s.cwiseAbs()));
+    ComplexMatrix V(N, N);
+    for (Index t = 0; t < N; ++t) fourierColumn(V, perm[t] / n2, perm[t] % n2, t);
+    return V;
+  }
+
+  /** \internal Writes the dense representation into \a dst: the (b1,c1) block is
+   * the generator column (b1-c1) mod n1 rotated downwards by the within-block
+   * column index, so only contiguous segment copies are involved. Invoked
+   * through \c dense = bccb; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    assignTo<SetAssignment>(dst);
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    assignTo<AddAssignment>(dst);
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    assignTo<SubAssignment>(dst);
+  }
+
+  /** \returns the product expression \c (*this) * \a x, evaluated through a fast
+   * 2-D-FFT-based matrix-vector product. The expression carries the default
+   * product tag, so assigning it behaves like any dense product: a temporary
+   * resolves aliasing between the destination and \a x, and \c .noalias() skips
+   * it. */
+  template <typename Rhs>
+  Product<Bccb, Rhs> operator*(const MatrixBase<Rhs>& x) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(x.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<Bccb, Rhs>(*this, x.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs. \c ProductScalar is the
+   * promoted scalar of the product (complex when a real operator is applied to a
+   * complex right-hand side); the accumulation runs in the promoted type.
+   *
+   * Non-finite data takes the direct O(N^2) kernel: the transforms would smear a
+   * single Inf/NaN into NaNs across the whole output, where the dense product
+   * only propagates it through the dot products that touch it. A non-finite
+   * generating array or cached symbol (which can overflow even for a finite
+   * generator: the 2-D DFT accumulates up to N addends) routes the whole
+   * product; a non-finite right-hand-side column is detected inside the FFT
+   * loop -- in the same pass that derives its scaling exponent, so finite data
+   * pays no extra scan -- and falls back per column. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    const Index N = rows();
+    eigen_assert(rhs.rows() == N && "invalid product: dimensions do not match");
+    if (N <= internal::structured_direct_threshold() || !m_fftUsable) {
+      directProduct(dst, rhs, alpha);
+      return;
+    }
+    // Products use the padded embedding symbol when a block dimension is not
+    // 5-smooth (see computeProdSymbol()); the exact-size transform of such a
+    // dimension runs through kissfft's quadratic generic butterfly.
+    const ComplexArray& s = m_prodSymbol.size() > 0 ? m_prodSymbol : m_symbol;
+    applySymbol(dst, s, rhs, alpha, /*accumulate=*/true, [&](Index k) { directProductColumn(dst, rhs, k, alpha); });
+  }
+
+ private:
+  /** \internal Materializes the dense BCCB representation with the selected
+   * assignment mode; shared by evalTo(), addTo() and subTo(). */
+  template <DenseAssignment Assignment, typename Dest>
+  void assignTo(Dest& dst) const {
+    const Index n2 = blockSize(), n1 = numBlocks();
+    for (Index c1 = 0; c1 < n1; ++c1)
+      for (Index j2 = 0; j2 < n2; ++j2) {
+        auto col = dst.col(c1 * n2 + j2);
+        for (Index b1 = 0; b1 < n1; ++b1) {
+          Index k1 = b1 - c1;
+          if (k1 < 0) k1 += n1;
+          EIGEN_IF_CONSTEXPR (Assignment == SetAssignment) {
+            col.segment(b1 * n2, j2) = m_g.col(k1).tail(j2);
+            col.segment(b1 * n2 + j2, n2 - j2) = m_g.col(k1).head(n2 - j2);
+          } else EIGEN_IF_CONSTEXPR (Assignment == AddAssignment) {
+            col.segment(b1 * n2, j2) += m_g.col(k1).tail(j2);
+            col.segment(b1 * n2 + j2, n2 - j2) += m_g.col(k1).head(n2 - j2);
+          } else {
+            col.segment(b1 * n2, j2) -= m_g.col(k1).tail(j2);
+            col.segment(b1 * n2 + j2, n2 - j2) -= m_g.col(k1).head(n2 - j2);
+          }
+        }
+      }
+  }
+
+  /** \internal Builds an operator from a generating array and already-known
+   * symbols (empty for small operators; \a prodSymbol also empty when both block
+   * dimensions are 5-smooth, which needs no padded product embedding), skipping
+   * the FFTs of the public constructor. Used by transpose(), conjugate(),
+   * adjoint() and inverse(), whose symbols are cheap transformations of the
+   * existing ones. */
+  Bccb(const GeneratorType& g, const ComplexArray& symbol, const ComplexArray& prodSymbol)
+      : m_g(g), m_symbol(symbol), m_prodSymbol(prodSymbol) {
+    m_fftUsable = computeFftUsable();
+  }
+
+  /** \internal Whether products may take the FFT path: the generating array and
+   * the cached symbols must be finite. The symbols accumulate up to N
+   * (respectively p2*p1) addends, so they can overflow to Inf even for a finite
+   * generator; such operators fall back to the direct kernel, which stays
+   * exact. */
+  bool computeFftUsable() const {
+    return m_g.allFinite() && (m_symbol.size() == 0 || m_symbol.allFinite()) &&
+           (m_prodSymbol.size() == 0 || m_prodSymbol.allFinite());
+  }
+
+  /** \internal \returns the symbol products should use for a generating array
+   * \a g: empty when both block dimensions are 5-smooth (the exact-size
+   * transforms are already fast), otherwise the 2-D DFT of the per-axis
+   * circulant embedding of \a g. kissfft falls back to a quadratic generic
+   * butterfly for prime factors other than 2, 3 and 5, and the row-column
+   * algorithm pays that cost in every transform of the awkward axis, so each
+   * such axis is padded to \c p_i = fft_next_good_size(2*n_i - 1) and the cyclic
+   * convolution along it is evaluated as a padded linear convolution -- exactly
+   * the Toeplitz embedding of a circulant, applied per dimension. Along a
+   * padded axis the generator is laid out as [g; 0...0; g(1..)] (the wrapped
+   * band g(1..) sits at the top indices), so that for reachable offsets
+   * \c d = i - j in [-(n-1), n-1] the embedded array satisfies
+   * \c Ge(d mod p) = g(d mod n); offsets outside that range only touch the zero
+   * band. The two axes decouple, so the identity holds per entry of the 2-D
+   * grid and the leading (n2, n1) block of the padded cyclic convolution equals
+   * the exact one. A 5-smooth axis is kept at its exact size with no embedding.
+   * The spectral operations (eigenvalues, solve, rank, determinant, SVD) keep
+   * the exact-size symbol, whose entries are the eigenvalues. */
+  ComplexArray computeProdSymbol(const GeneratorType& g) const {
+    const Index n2 = g.rows(), n1 = g.cols();
+    const Index p2 = internal::fft_next_good_size(n2) == n2 ? n2 : internal::fft_next_good_size(2 * n2 - 1);
+    const Index p1 = internal::fft_next_good_size(n1) == n1 ? n1 : internal::fft_next_good_size(2 * n1 - 1);
+    if (p2 == n2 && p1 == n1) return ComplexArray();
+    ComplexArray Ge = ComplexArray::Zero(p2, p1);
+    Ge.topLeftCorner(n2, n1) = g.template cast<Complex>();
+    if (p2 != n2) Ge.bottomLeftCorner(n2 - 1, n1) = g.bottomRows(n2 - 1).template cast<Complex>();
+    if (p1 != n1) Ge.topRightCorner(n2, n1 - 1) = g.rightCols(n1 - 1).template cast<Complex>();
+    if (p2 != n2 && p1 != n1)
+      Ge.bottomRightCorner(n2 - 1, n1 - 1) = g.bottomRightCorner(n2 - 1, n1 - 1).template cast<Complex>();
+    fft2(Ge);
+    return Ge;
+  }
+
+  /** \internal Direct O(N^2) kernel for column \a k of the right-hand side:
+   * computes \c dst.col(k) += alpha * (*this) * rhs.col(k) without transforms,
+   * as a plain scalar loop (the two-level segment-based middle tier of the 1-D
+   * operators does not pay off here: the within-block segments are too short at
+   * these sizes). Serves operators below the FFT threshold and any column
+   * involving non-finite data, whose entrywise IEEE semantics the transforms
+   * cannot preserve. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProductColumn(Dest& dst, const Rhs& rhs, Index k, const ProductScalar& alpha) const {
+    const Index N = rows();
+    // A unit alpha must not multiply: even the identity complex scalar (1,0)
+    // pollutes an (Inf,0) value with NaN through the 0*Inf cross term.
+    const bool unitAlpha = alpha == ProductScalar(1);
+    for (Index i = 0; i < N; ++i) {
+      ProductScalar acc(0);
+      for (Index j = 0; j < N; ++j) acc += coeff(i, j) * rhs.coeff(j, k);
+      dst.coeffRef(i, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
+    }
+  }
+
+  /** \internal Direct O(N^2) product kernel over every column, see
+   * directProductColumn(). */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    for (Index k = 0; k < rhs.cols(); ++k) directProductColumn(dst, rhs, k, alpha);
+  }
+
+  /** \internal Applies the operator whose 2-D symbol is \a s to every column of
+   * \a rhs: reshape to n2 x n1 (column-major), 2-D FFT, multiply by \a s,
+   * back-transform, take the \c ProductScalar part. Adds into \a dst when
+   * \a accumulate, overwrites otherwise. The transforms run on the grid of
+   * \a s itself: for the padded product symbol (see computeProdSymbol()) the
+   * column is zero-padded into the (p2, p1) grid and the leading (n2, n1) block
+   * of the back-transform is read out; for an exact-size symbol the grid is
+   * (n2, n1) and no padding is involved.
+   *
+   * The transforms sum up to \c N inputs, so intermediates can overflow even
+   * when every entry of the true result is representable. To keep the whole
+   * pipeline overflow-free for finite inputs anywhere in the floating-point
+   * range, the symbol and each right-hand-side column are rescaled by an exact
+   * power of two that brings their maximum modulus below one -- huge generators
+   * make huge symbols, hence both sides -- and the removed exponent is folded
+   * back into the output through per-entry ldexp, which saturates cleanly to
+   * zero or infinity if the true result itself leaves the representable range.
+   * The exponents come from the component-wise magnitudes: the modulus of a
+   * finite complex value near the overflow threshold is not representable,
+   * which would silently disable the scaling exactly where it is needed.
+   *
+   * A single plain (fast-max) reduction pass per column yields the finiteness
+   * routing, the zero-column shortcut and the scaling exponent (see
+   * internal::structured_exponent_bound_finite() for why missing a NaN in the
+   * fast max cannot change a routing decision). Non-finite columns are handed
+   * to \a directColumn, the caller's per-column direct kernel, so the remaining
+   * columns keep the fast path; a non-finite symbol is the caller's
+   * responsibility (addProduct routes it to the direct kernel up front, and
+   * solve() takes its dedicated pseudo-inverse fallback for non-finite
+   * right-hand sides). Zero columns short-circuit to zero, but only under a
+   * finite symbol (Inf*0 and NaN*0 are NaN entrywise) and after an exact
+   * recheck: the fast max can miss a NaN hiding among zeros (an Inf always
+   * surfaces), and such a column must fall back, not shortcut. */
+  template <typename Dest, typename Rhs, typename ProductScalar, typename DirectColumn>
+  void applySymbol(Dest& dst, const ComplexArray& s, const Rhs& rhs, const ProductScalar& alpha, bool accumulate,
+                   DirectColumn&& directColumn) const {
+    const Index n2 = blockSize(), n1 = numBlocks(), N = rows();
+    const Index p2 = s.rows(), p1 = s.cols();  // the symbol's transform grid: (n2, n1) or the padded product grid
+    const bool padded = p2 != n2 || p1 != n1;
+    const bool sFinite = s.allFinite();
+    // max|s| < 2^es; component bounds avoid overflow in complex moduli.
+    const int es = internal::structured_exponent_bound(s);
+    ComplexArray sScaled;
+    if (es != 0) {
+      sScaled = s;
+      ldexpInPlace(sScaled, -es);
+    }
+    const ComplexArray& sUse = es != 0 ? sScaled : s;
+    Matrix<ProductScalar, Dynamic, 1> xc(N);
+    ComplexArray X(p2, p1), Xn;  // Xn: the leading-block extraction of a padded grid
+    for (Index k = 0; k < rhs.cols(); ++k) {
+      xc = rhs.col(k).template cast<ProductScalar>();
+      const RealScalar m = xc.realView().cwiseAbs().maxCoeff();
+      if (!(numext::isfinite)(m)) {
+        directColumn(k);
+        continue;
+      }
+      if (m == RealScalar(0)) {
+        // The fast max cannot hide an Inf (those comparisons are ordered), but
+        // it can miss a NaN among zeros: recheck exactly before shortcutting.
+        if ((xc.array() == ProductScalar(0)).all()) {
+          if (sFinite) {
+            // An exactly zero column maps to an exactly zero column -- unless
+            // the symbol holds Inf or NaN, whose products with zero are NaN;
+            // falling through to the transforms produces exactly that.
+            if (!accumulate) dst.col(k).setZero();
+            continue;
+          }
+        } else {
+          directColumn(k);
+          continue;
+        }
+      }
+      int ex = 0;  // stays 0 for an all-zero column: no scaling
+      if (m > RealScalar(0)) {
+        EIGEN_USING_STD(frexp);
+        frexp(m, &ex);
+        EIGEN_IF_CONSTEXPR (NumTraits<ProductScalar>::IsComplex) ++ex;
+      }
+      // reshaped() defaults to column-major traversal, the flattening the
+      // two-level structure keys on, regardless of EIGEN_DEFAULT_TO_ROW_MAJOR.
+      if (padded) {
+        X.setZero();
+        X.topLeftCorner(n2, n1) = xc.reshaped(n2, n1).template cast<Complex>();
+      } else {
+        X = xc.reshaped(n2, n1).template cast<Complex>();
+      }
+      ldexpInPlace(X, -ex);
+      fft2(X);
+      X.array() *= sUse.array();
+      ifft2(X);
+      if (padded) Xn = X.topLeftCorner(n2, n1);
+      ComplexArray& out = padded ? Xn : X;
+      ldexpInPlace(out, ex + es);
+      if (accumulate)
+        dst.col(k) += alpha * internal::structured_scalar_part_impl<ProductScalar>::run(out.reshaped());
+      else
+        dst.col(k) = alpha * internal::structured_scalar_part_impl<ProductScalar>::run(out.reshaped());
+    }
+  }
+
+  /** \internal Multiplies every entry of \a X by 2^e, exactly. The per-entry
+   * ldexp saturates to zero / infinity component-wise without ever forming the
+   * (possibly unrepresentable) scale factor 2^e itself. */
+  static void ldexpInPlace(ComplexArray& X, int e) {
+    if (e == 0) return;
+    X.realView() = X.realView().array().ldexp(e).matrix();
+  }
+
+  /** \internal In-place forward or inverse 2-D FFT by the row-column algorithm:
+   * transform every column (length n2), then every row (length n1). Length-1
+   * transforms are the identity (and unsupported by the kissfft backend), hence
+   * the guards. */
+  template <bool Inverse>
+  void transform2(ComplexArray& X) const {
+    auto&& fft = internal::structured_fft_engine<RealScalar>();
+    const Index n2 = X.rows(), n1 = X.cols();
+    // Both passes share one output buffer (resized by the engine) and one packed
+    // input buffer, allocated at most twice for the whole transform. A column of
+    // the column-major grid is already packed and goes to the engine as is; a row
+    // is strided, and the engine would pack it into a fresh temporary per call.
+    ComplexVector tmp, rowv;
+    if (n2 > 1) {
+      for (Index k1 = 0; k1 < n1; ++k1) {
+        EIGEN_IF_CONSTEXPR (Inverse) {
+          fft.inv(tmp, X.col(k1), n2);
+        } else {
+          fft.fwd(tmp, X.col(k1), n2);
+        }
+        X.col(k1) = tmp;
+      }
+    }
+    if (n1 > 1) {
+      for (Index k2 = 0; k2 < n2; ++k2) {
+        rowv = X.row(k2).transpose();
+        EIGEN_IF_CONSTEXPR (Inverse) {
+          fft.inv(tmp, rowv, n1);
+        } else {
+          fft.fwd(tmp, rowv, n1);
+        }
+        X.row(k2) = tmp.transpose();
+      }
+    }
+  }
+
+  /** \internal In-place 2-D forward FFT. */
+  void fft2(ComplexArray& X) const { transform2<false>(X); }
+
+  /** \internal In-place 2-D inverse FFT. */
+  void ifft2(ComplexArray& X) const { transform2<true>(X); }
+
+  /** \internal Reconstructs the generating array from an exact-size symbol. */
+  GeneratorType generatorFromSymbol(ComplexArray symbol) const {
+    ifft2(symbol);
+    GeneratorType generator = internal::structured_scalar_part_impl<Scalar>::run(symbol);
+    return generator;
+  }
+
+  /** \internal \returns the 2-D DFT of the generating array. */
+  ComplexArray computeSymbol() const {
+    ComplexArray s = m_g.template cast<Complex>();
+    fft2(s);
+    return s;
+  }
+
+  /** \internal \returns \a M index-reversed in both dimensions:
+   * result(k2, k1) = M((-k2) mod n2, (-k1) mod n1). Row 0 and column 0 stay in
+   * place; the rest is a two-dimensional reversal. Empty input stays empty. */
+  template <typename MatType>
+  static MatType reverse2(const MatType& M) {
+    const Index r = M.rows(), c = M.cols();
+    MatType R(r, c);
+    if (M.size() == 0) return R;
+    R(0, 0) = M(0, 0);
+    if (c > 1) R.row(0).tail(c - 1) = M.row(0).tail(c - 1).reverse();
+    if (r > 1) R.col(0).tail(r - 1) = M.col(0).tail(r - 1).reverse();
+    if (r > 1 && c > 1) R.bottomRightCorner(r - 1, c - 1) = M.bottomRightCorner(r - 1, c - 1).reverse();
+    return R;
+  }
+
+  /** \internal Computes the moduli of the symbol entries and the matching
+   * rank/pseudo-inversion threshold, both evaluated in an exactly rescaled frame
+   * [5]: the entries are pre-scaled by a power of two chosen so no modulus can
+   * overflow. A finite complex entry near the overflow threshold has a
+   * non-representable modulus, which would otherwise turn the threshold into
+   * infinity and misclassify every other entry (rank under-reported, solve()
+   * zeroing valid Fourier modes). The rescaling is exact, so comparing scaled
+   * moduli against the scaled threshold is equivalent to the unscaled
+   * comparison. The threshold keeps the N * epsilon * max|s| convention of [3],
+   * chapter 5.4, and the smallest-normal clamp -- carried into the scaled frame,
+   * where its underflowing to zero for a huge frame is correct: no entry of such
+   * a symbol can sit below the smallest normal number. Entries at or above the
+   * threshold, in particular a smallest-normal entry of a moderate symbol, are
+   * inverted (their reciprocals are finite). */
+  static void scaledModuli(const ComplexArray& s, RealArray& mods, RealScalar& tol) {
+    const int e = numext::maxi(internal::structured_exponent_bound(s), 0);
+    // Two exact factors, as in Circulant::scaledModuli(): a single 2^-e is itself
+    // subnormal once the frame exceeds the exponent range, and reads as zero under
+    // flush-to-zero -- collapsing every scaled modulus, and the threshold with
+    // them. Neither factor exceeds one, so no intermediate underflows on its own.
+    const RealScalar down1 = numext::ldexp(RealScalar(1), -(e / 2)), down2 = numext::ldexp(RealScalar(1), -(e - e / 2));
+    mods = ((s * down1) * down2).cwiseAbs();
+    tol = numext::maxi(RealScalar(s.size()) * NumTraits<RealScalar>::epsilon() * mods.maxCoeff(),
+                       ((std::numeric_limits<RealScalar>::min)() * down1) * down2);
+  }
+
+  /** \internal Writes the unit-norm 2-D Fourier eigenvector of frequencies
+   * \c (f1, f2) into column \a dstCol of \a F: entry \c b1*n2 + i2 is
+   * exp(2 pi i (b1 f1 / n1 + i2 f2 / n2)) / sqrt(N). All frequency products are
+   * accumulated incrementally modulo their length, so the angles stay O(2 pi) at
+   * full accuracy and no Index overflow can occur. */
+  void fourierColumn(ComplexMatrix& F, Index f1, Index f2, Index dstCol) const {
+    const Index n2 = blockSize(), n1 = numBlocks();
+    const RealScalar scale = RealScalar(1) / numext::sqrt(RealScalar(rows()));
+    ComplexVector w2(n2);
+    Index jf = 0;  // i2 * f2 mod n2
+    for (Index i2 = 0; i2 < n2; ++i2) {
+      w2[i2] = std::polar(scale, RealScalar(2 * EIGEN_PI) * RealScalar(jf) / RealScalar(n2));
+      jf += f2;
+      if (jf >= n2) jf -= n2;
+    }
+    Index bf = 0;  // b1 * f1 mod n1
+    for (Index b1 = 0; b1 < n1; ++b1) {
+      const Complex w1 = std::polar(RealScalar(1), RealScalar(2 * EIGEN_PI) * RealScalar(bf) / RealScalar(n1));
+      F.col(dstCol).segment(b1 * n2, n2) = w1 * w2;
+      bf += f1;
+      if (bf >= n1) bf -= n1;
+    }
+  }
+
+  /** \internal Projects the complex determinant onto \c Scalar. */
+  static Scalar toScalar(const Complex& z, std::true_type /*scalar_is_real*/) { return numext::real(z); }
+  static Scalar toScalar(const Complex& z, std::false_type /*scalar_is_real*/) { return z; }
+
+  GeneratorType m_g;
+  ComplexArray m_symbol;
+  // The padded embedding symbol products use when a block dimension is not
+  // 5-smooth; empty otherwise. See computeProdSymbol().
+  ComplexArray m_prodSymbol;
+  bool m_fftUsable;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref Bccb operator with generating array \a generator. The
+ * compile-time dimensions of the operator are deduced from the array. */
+template <typename Derived>
+Bccb<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime> makeBccb(
+    const MatrixBase<Derived>& generator) {
+  return Bccb<typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime>(generator);
+}
+
+namespace internal {
+
+template <typename Scalar_, int BlockSize_, int NumBlocks_, typename Rhs, int ProductTag>
+struct generic_product_impl<Bccb<Scalar_, BlockSize_, NumBlocks_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<Bccb<Scalar_, BlockSize_, NumBlocks_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_BCCB_H
diff --git a/contrib/Eigen/src/StructuredMatrices/Cauchy.h b/contrib/Eigen/src/StructuredMatrices/Cauchy.h
new file mode 100644
index 0000000..e5df904
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/Cauchy.h
@@ -0,0 +1,558 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// References:
+//  [1] J. J. Dongarra, J. R. Bunch, C. B. Moler and G. W. Stewart, "LINPACK
+//      Users' Guide", SIAM, 1979. determinant()'s balanced accumulation follows
+//      the convention of its xGEDI routines, which return determinants as a
+//      (fraction, exponent) pair to avoid spurious overflow/underflow.
+//  [2] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, the property the balanced
+//      accumulation and the guarded boundary-node evaluations rely on.
+
+#ifndef EIGEN_STRUCTURED_CAUCHY_H
+#define EIGEN_STRUCTURED_CAUCHY_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int Rows_ = Dynamic, int Cols_ = Dynamic>
+class Cauchy;
+
+template <typename Scalar_>
+class CauchyLU;
+
+namespace internal {
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct traits<Cauchy<Scalar_, Rows_, Cols_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  // Deliberately no NestByRefBit: transpose(), conjugate() and adjoint() return
+  // owning temporaries, so Product must nest the operator by value for a
+  // delayed-evaluated product expression to keep its left factor alive. The copy
+  // is O(m+n), negligible against the O(mn) product evaluation.
+  static constexpr unsigned int Flags = 0;
+};
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct evaluator_traits<Cauchy<Scalar_, Rows_, Cols_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+template <typename Scalar_>
+struct traits<CauchyLU<Scalar_>> : traits<Matrix<Scalar_, Dynamic, Dynamic>> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
+  using BaseTraits = traits<Matrix<Scalar_, Dynamic, Dynamic>>;
+  static constexpr unsigned int Flags = BaseTraits::Flags & RowMajorBit;
+  static constexpr int CoeffReadCost = Dynamic;
+};
+
+/** \internal \returns the Cauchy coefficient \c 1 / (a - b), guarded against a
+ * spurious overflow of the difference (internal::structured_guarded_diff): a
+ * naively formed coefficient would collapse to 1/Inf = 0, where the true value
+ * is a representable (possibly subnormal) number. When the guard fires, one
+ * half is divided directly by the halved difference, so the subnormal result is
+ * rounded only once. Every coefficient evaluation exposed by Cauchy -- coeff(),
+ * dense materialization and the product kernel -- goes through this helper.
+ * CauchyLU and determinant() use the same guarded difference inside their
+ * balanced accumulations. */
+template <typename Scalar>
+Scalar cauchy_reciprocal_diff(const Scalar& a, const Scalar& b) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  int e;
+  const Scalar t = structured_guarded_diff(a, b, e);
+  return Scalar(e == 0 ? RealScalar(1) : RealScalar(0.5)) / t;
+}
+
+/** \internal \returns a guarded node difference as a balanced mantissa, with
+ * its power of two in \a exponent. */
+template <typename Scalar>
+Scalar cauchy_balanced_diff(const Scalar& a, const Scalar& b, Index& exponent) {
+  int guardedExponent;
+  const Scalar difference = structured_guarded_diff(a, b, guardedExponent);
+  exponent = guardedExponent;
+  return structured_balance(difference, exponent);
+}
+
+/** \internal Evaluates a GKO Schur-complement entry from generators stored as
+ * mantissa/exponent pairs. The guarded node difference is balanced before the
+ * division, and the accumulated power of two is applied only to the final
+ * result, so finite entries do not overflow or underflow in intermediate
+ * generator arithmetic. */
+template <typename Scalar>
+Scalar cauchy_scaled_entry(const Scalar& a, Index aExponent, const Scalar& b, Index bExponent, const Scalar& x,
+                           const Scalar& y) {
+  // Preserve the single-rounding coefficient path for the initial generators.
+  if (aExponent == 0 && bExponent == 0 && a == Scalar(1) && b == Scalar(1)) return cauchy_reciprocal_diff(x, y);
+  Index diffExponent;
+  const Scalar diff = cauchy_balanced_diff(x, y, diffExponent);
+  Index exponent = aExponent + bExponent - diffExponent;
+  const Scalar value = structured_balance(Scalar((a * b) / diff), exponent);
+  return structured_ldexp_clamped(value, exponent);
+}
+
+/** \internal \returns the balanced mantissa of \c (a - b) / (a - c), with its
+ * power of two in \a exponent. Separately balancing both guarded differences
+ * prevents a representable ratio from passing through Inf/Inf or zero. */
+template <typename Scalar>
+Scalar cauchy_balanced_diff_ratio(const Scalar& a, const Scalar& b, const Scalar& c, Index& exponent) {
+  Index numeratorExponent, denominatorExponent;
+  const Scalar numerator = cauchy_balanced_diff(a, b, numeratorExponent);
+  const Scalar denominator = cauchy_balanced_diff(a, c, denominatorExponent);
+  exponent = numeratorExponent - denominatorExponent;
+  return structured_balance(Scalar(numerator / denominator), exponent);
+}
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class Cauchy
+ * \brief An \c m x \c n Cauchy matrix represented by its two node vectors.
+ *
+ * A Cauchy matrix has entry \c (i,j) equal to \f$ 1/(x_i - y_j) \f$; the class
+ * stores only the \c m + \c n nodes. Products are evaluated directly at O(mn)
+ * operations -- the same cost as a dense product, but with O(m+n) storage and
+ * without ever forming the matrix. (Fast approximate products via multipole
+ * expansions are out of scope.)
+ *
+ * The class is closed under transposition: \f$ C(x,y)^T = C(-y,-x) \f$, and the
+ * determinant of a square Cauchy matrix has the classical closed form
+ * \f$ \prod_{i<j}(x_j-x_i)(y_i-y_j) \big/ \prod_{i,j}(x_i-y_j) \f$.
+ *
+ * Because \c operator* returns an Eigen product expression, a \c Cauchy also
+ * drops into the matrix-free iterative solvers, and it can be assigned to a
+ * dense matrix when an explicit representation is needed. As with any
+ * matrix-free operator, the iterative solvers must be instantiated with
+ * \c IdentityPreconditioner (e.g.
+ * \c GMRES<Cauchy<double>,IdentityPreconditioner>): the default preconditioners
+ * read individual coefficients through \c col() or \c InnerIterator, which the
+ * structured operators do not expose.
+ *
+ * Square systems are solved in O(n^2) by \ref CauchyLU, a partially pivoted LU
+ * factorization computed through the displacement structure
+ * (Gohberg-Kailath-Olshevsky): unlike the Toeplitz/Levinson world, Cauchy
+ * structure survives row permutations, which is what makes fast \em pivoted
+ * factorization possible. The Hilbert matrix is the Cauchy matrix with
+ * \c x_i = i+1, \c y_j = -j.
+ *
+ * All nodes \c x_i must differ from all nodes \c y_j (entries would be infinite
+ * otherwise); this is not checked.
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ * \tparam Rows_ the number of rows at compile time, or \c Dynamic (the default).
+ * \tparam Cols_ the number of columns at compile time, or \c Dynamic (the default).
+ *
+ * \sa class CauchyLU, makeCauchy()
+ */
+template <typename Scalar_, int Rows_, int Cols_>
+class Cauchy : public EigenBase<Cauchy<Scalar_, Rows_, Cols_>> {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using RowNodeVector = Matrix<Scalar, Rows_, 1>;
+  using ColNodeVector = Matrix<Scalar, Cols_, 1>;
+
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(RowNodeVector::NeedsToAlign || ColNodeVector::NeedsToAlign))
+
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Rows_, Cols_);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const Cauchy>'s default StrideType
+  // argument reads it, so its absence makes internal::is_ref_compatible SFINAE to
+  // false and keeps the iterative solvers on their matrix-free path.
+
+  /** Builds a Cauchy matrix from the row nodes \a x and the column nodes \a y:
+   * entry \c (i,j) is \c 1/(x[i] - y[j]). */
+  template <typename XDerived, typename YDerived>
+  Cauchy(const MatrixBase<XDerived>& x, const MatrixBase<YDerived>& y) : m_x(x), m_y(y) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(XDerived)
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(YDerived)
+    eigen_assert(m_x.size() > 0 && m_y.size() > 0 && "Cauchy node vectors must be non-empty");
+    m_boundary = computeBoundary();
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_x.size(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_y.size(); }
+
+  /** \returns the row node vector \c x. */
+  const RowNodeVector& rowNodes() const { return m_x; }
+  /** \returns the column node vector \c y. */
+  const ColNodeVector& colNodes() const { return m_y; }
+
+  /** \returns the coefficient at row \a row and column \a col, evaluated
+   * through the guarded reciprocal: nodes at the overflow boundary yield the
+   * correctly rounded (possibly subnormal) value instead of a spurious
+   * 1/Inf = 0. */
+  Scalar coeff(Index row, Index col) const { return internal::cauchy_reciprocal_diff(m_x.coeff(row), m_y.coeff(col)); }
+
+  /** \returns the transpose of \c *this, itself a Cauchy operator:
+   * \f$ C(x,y)^T = C(-y,-x) \f$. */
+  Cauchy<Scalar, Cols_, Rows_> transpose() const { return Cauchy<Scalar, Cols_, Rows_>(-m_y, -m_x); }
+
+  /** \returns the complex conjugate of \c *this, itself a Cauchy operator (the
+   * one with conjugated nodes). */
+  Cauchy conjugate() const { return Cauchy(m_x.conjugate(), m_y.conjugate()); }
+
+  /** \returns the adjoint of \c *this, itself a Cauchy operator:
+   * \f$ C(x,y)^H = C(-\bar y, -\bar x) \f$. */
+  Cauchy<Scalar, Cols_, Rows_> adjoint() const {
+    return Cauchy<Scalar, Cols_, Rows_>(-m_y.conjugate(), -m_x.conjugate());
+  }
+
+  /** \returns the determinant of a \b square Cauchy matrix through the classical
+   * closed form \f$ \prod_{i<j}(x_j-x_i)(y_i-y_j) \big/ \prod_{i,j}(x_i-y_j) \f$,
+   * in O(n^2) operations. All factors enter a single accumulation kept in the
+   * balanced form \c m * 2^e (the split fraction/exponent determinant
+   * convention of LINPACK's xGEDI [1]) -- every factor and the running value
+   * are renormalized to unit magnitude with the power of two tracked separately
+   * (exact frexp/ldexp rescaling [2]), numerator factors multiplied in and
+   * denominator factors divided out -- so no intermediate can overflow or
+   * underflow when the determinant itself is representable. A node difference
+   * that overflows even though both nodes are finite (nodes near opposite ends
+   * of the exponent range) is recomputed from the halved nodes -- exact, since
+   * such an overflow implies huge normal operands -- with the removed power of
+   * two entering the same exponent bookkeeping, so it too cannot push the
+   * accumulation to a spurious Inf. Zero factors (coincident \c x or \c y
+   * nodes) and genuinely non-finite factors propagate exactly. */
+  Scalar determinant() const {
+    eigen_assert(rows() == cols() && "Cauchy::determinant requires a square matrix");
+    const Index n = rows();
+    Scalar det(1);
+    Index exponent = 0;
+    for (Index j = 1; j < n; ++j)
+      for (Index i = 0; i < j; ++i) {
+        Index factorExponent;
+        const Scalar xDiff = internal::cauchy_balanced_diff(m_x.coeff(j), m_x.coeff(i), factorExponent);
+        exponent += factorExponent;
+        det = internal::structured_balance(Scalar(det * xDiff), exponent);
+        const Scalar yDiff = internal::cauchy_balanced_diff(m_y.coeff(i), m_y.coeff(j), factorExponent);
+        exponent += factorExponent;
+        det = internal::structured_balance(Scalar(det * yDiff), exponent);
+      }
+    for (Index j = 0; j < n; ++j)
+      for (Index i = 0; i < n; ++i) {
+        Index denomExponent = 0;
+        const Scalar d = internal::cauchy_balanced_diff(m_x.coeff(i), m_y.coeff(j), denomExponent);
+        exponent -= denomExponent;
+        det = internal::structured_balance(Scalar(det / d), exponent);
+      }
+    return internal::structured_ldexp_clamped(det, exponent);
+  }
+
+  /** \internal Writes the dense representation into \a dst, one vectorized
+   * column at a time. Operators whose nodes reach the overflow boundary (see
+   * computeBoundary()) instead evaluate every entry through the guarded
+   * reciprocal, staying consistent with coeff(). Invoked through
+   * \c dense = cauchy; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    applyAssignment(dst, internal::assign_op<typename Dest::Scalar, Scalar>());
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    applyAssignment(dst, internal::add_assign_op<typename Dest::Scalar, Scalar>());
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    applyAssignment(dst, internal::sub_assign_op<typename Dest::Scalar, Scalar>());
+  }
+
+  /** \returns the product expression \c (*this) * \a v, evaluated directly at
+   * O(mn) operations and O(1) extra storage. The expression carries the default
+   * product tag, so assigning it behaves like any dense product: a temporary
+   * resolves aliasing between the destination and \a v, and \c .noalias() skips
+   * it. */
+  template <typename Rhs>
+  Product<Cauchy, Rhs> operator*(const MatrixBase<Rhs>& v) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(v.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<Cauchy, Rhs>(*this, v.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs. \c ProductScalar is the
+   * promoted scalar of the product (complex when a real operator is applied to a
+   * complex right-hand side); the accumulation runs in the promoted type. The
+   * coefficients enter through the guarded reciprocal, so the product uses
+   * exactly the values coeff() exposes, boundary nodes included. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    const Index m = rows(), n = cols();
+    eigen_assert(rhs.rows() == n && "invalid product: dimensions do not match");
+    for (Index k = 0; k < rhs.cols(); ++k)
+      for (Index i = 0; i < m; ++i) {
+        const Scalar xi = m_x.coeff(i);
+        ProductScalar acc(0);
+        for (Index j = 0; j < n; ++j) acc += rhs.coeff(j, k) * internal::cauchy_reciprocal_diff(xi, m_y.coeff(j));
+        dst.coeffRef(i, k) += alpha * acc;
+      }
+  }
+
+ private:
+  template <typename Dest, typename Assignment>
+  void applyAssignment(Dest& dst, const Assignment& assignment) const {
+    if (m_boundary) {
+      for (Index j = 0; j < cols(); ++j)
+        for (Index i = 0; i < rows(); ++i)
+          assignment.assignCoeff(dst.coeffRef(i, j), internal::cauchy_reciprocal_diff(m_x.coeff(i), m_y.coeff(j)));
+      return;
+    }
+    for (Index j = 0; j < cols(); ++j) {
+      auto dstColumn = dst.col(j);
+      internal::call_assignment_no_alias(dstColumn, (m_x.array() - m_y.coeff(j)).inverse().matrix(), assignment);
+    }
+  }
+
+  /** \internal Whether some node difference \c x_i - y_j could overflow on
+   * finite nodes (conservative componentwise bound: the largest \c |x| and
+   * \c |y| components sum past the largest finite value), or a node is
+   * non-finite. The dense materialization then takes the guarded scalar path
+   * instead of the vectorized column expression; for moderate nodes the bound
+   * guarantees the two paths are bit-identical, so the vectorized path is kept.
+   * The magnitudes are taken componentwise: the modulus of a finite complex
+   * node near the overflow threshold is not representable. */
+  bool computeBoundary() const {
+    RealScalar mx, my;
+    EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+      mx = numext::maxi(m_x.real().cwiseAbs().maxCoeff(), m_x.imag().cwiseAbs().maxCoeff());
+      my = numext::maxi(m_y.real().cwiseAbs().maxCoeff(), m_y.imag().cwiseAbs().maxCoeff());
+    } else {
+      mx = m_x.cwiseAbs().maxCoeff();
+      my = m_y.cwiseAbs().maxCoeff();
+    }
+    return !(mx + my <= (std::numeric_limits<RealScalar>::max)());
+  }
+
+  RowNodeVector m_x;
+  ColNodeVector m_y;
+  bool m_boundary;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref Cauchy operator with row nodes \a x and column nodes \a y. The
+ * compile-time dimensions of the operator are deduced from the node vectors. */
+template <typename XDerived, typename YDerived>
+Cauchy<typename XDerived::Scalar, XDerived::SizeAtCompileTime, YDerived::SizeAtCompileTime> makeCauchy(
+    const MatrixBase<XDerived>& x, const MatrixBase<YDerived>& y) {
+  return Cauchy<typename XDerived::Scalar, XDerived::SizeAtCompileTime, YDerived::SizeAtCompileTime>(x, y);
+}
+
+/** \ingroup StructuredMatrices_Module
+ * \class CauchyLU
+ * \brief Partially pivoted O(n^2) LU solver for square Cauchy systems
+ * (Gohberg-Kailath-Olshevsky).
+ *
+ * A Cauchy matrix satisfies the displacement equation
+ * \f$ D_x C - C D_y = \mathbf{1}\mathbf{1}^T \f$, and -- crucially -- this
+ * structure survives row permutations. The GKO algorithm exploits it to compute
+ * the row-pivoted factorization \c P*C = L*U in O(n^2) operations: at each step
+ * the current column of the Schur complement is generated from O(n) data, the
+ * largest entry is chosen as pivot, and the Schur complement stays Cauchy-like
+ * with updated generators. This gives Cauchy systems what the Levinson world
+ * lacks: genuine partial pivoting at fast-algorithm cost.
+ *
+ * Usage follows the usual decomposition style, including the transposed and
+ * adjoint solves of \c SolverBase (from the same factorization):
+ * \code
+ *   CauchyLU<double> lu(C);              // or lu.compute(C);
+ *   VectorXd u = lu.solve(b);             // solve C   * u = b
+ *   VectorXd v = lu.transpose().solve(b); // solve C^T * v = b
+ *   VectorXd w = lu.adjoint().solve(b);   // solve C^H * w = b
+ * \endcode
+ *
+ * The factors are stored densely (O(n^2) memory, like the dense LU
+ * decompositions).
+ *
+ * References: I. Gohberg, T. Kailath, V. Olshevsky, "Fast Gaussian elimination
+ * with partial pivoting for matrices with displacement structure," Math. Comp.
+ * 64 (1995).
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ *
+ * \sa class Cauchy
+ */
+template <typename Scalar_>
+class CauchyLU : public SolverBase<CauchyLU<Scalar_>> {
+ public:
+  using Base = SolverBase<CauchyLU>;
+  friend class SolverBase<CauchyLU>;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(CauchyLU)
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic>;
+  using DenseVector = Matrix<Scalar, Dynamic, 1>;
+  using IndexVector = Matrix<Index, Dynamic, 1>;
+
+  /** Default constructor; call \ref compute before \ref solve. */
+  CauchyLU() : m_isInitialized(false), m_info(InvalidInput) {}
+
+  /** Constructs and factorizes from the square Cauchy matrix \a C. */
+  template <int Rows_, int Cols_>
+  explicit CauchyLU(const Cauchy<Scalar, Rows_, Cols_>& C) : m_isInitialized(false), m_info(InvalidInput) {
+    compute(C);
+  }
+
+  /** Factorizes the square Cauchy matrix \a C as \c P*C = L*U by the GKO
+   * recursion with partial pivoting. The Schur complement retains the form
+   * \f[ S_{ij}=\frac{a_i b_j}{x_i-y_j}, \qquad
+   * a_i\leftarrow a_i\frac{x_i-x_k}{x_i-y_k},\quad
+   * b_j\leftarrow b_j\frac{y_j-y_k}{y_j-x_k}. \f]
+   * This follows from the rank-one displacement
+   * \f$D_x C-C D_y=\mathbf{1}\mathbf{1}^T\f$. \sa solve */
+  template <int Rows_, int Cols_>
+  CauchyLU& compute(const Cauchy<Scalar, Rows_, Cols_>& C) {
+    eigen_assert(C.rows() == C.cols() && "CauchyLU requires a square Cauchy matrix");
+    const Index n = C.rows();
+    DenseVector x = C.rowNodes();
+    const DenseVector y = C.colNodes();
+    DenseVector a = DenseVector::Ones(n);
+    DenseVector b = DenseVector::Ones(n);
+    IndexVector aExponent = IndexVector::Zero(n);
+    IndexVector bExponent = IndexVector::Zero(n);
+    m_lu.resize(n, n);
+    m_perm.resize(static_cast<std::size_t>(n));
+    m_info = Success;
+
+    for (Index k = 0; k < n; ++k) {
+      // Guarded differences preserve subnormal Schur-complement entries at the
+      // exponent boundary instead of creating zero pivots or NaN generators.
+      Index piv = k;
+      RealScalar best(-1);
+      for (Index i = k; i < n; ++i) {
+        m_lu(i, k) = internal::cauchy_scaled_entry(a[i], aExponent[i], b[k], bExponent[k], x[i], y[k]);
+        const RealScalar mag = numext::abs(m_lu(i, k));
+        if ((numext::isnan)(mag) || mag > best) {
+          best = mag;
+          piv = i;
+        }
+      }
+      if (piv != k) {
+        m_lu.row(piv).head(k + 1).swap(m_lu.row(k).head(k + 1));
+        std::swap(x[piv], x[k]);
+        std::swap(a[piv], a[k]);
+        std::swap(aExponent[piv], aExponent[k]);
+      }
+      m_perm[static_cast<std::size_t>(k)] = piv;
+      const Scalar pivot = m_lu(k, k);
+      if (pivot == Scalar(0) || !(numext::isfinite)(pivot)) {
+        m_info = NumericalIssue;
+        m_lu.row(k).tail(n - k - 1).setZero();
+        m_lu.col(k).tail(n - k - 1).setZero();
+        continue;
+      }
+      m_lu.col(k).tail(n - k - 1) /= pivot;
+      for (Index j = k + 1; j < n; ++j) {
+        m_lu(k, j) = internal::cauchy_scaled_entry(a[k], aExponent[k], b[j], bExponent[j], x[k], y[j]);
+        if (!(numext::isfinite)(m_lu(k, j))) m_info = NumericalIssue;
+      }
+      for (Index i = k + 1; i < n; ++i) {
+        Index ratioExponent;
+        const Scalar ratio = internal::cauchy_balanced_diff_ratio(x[i], x[k], y[k], ratioExponent);
+        aExponent[i] += ratioExponent;
+        a[i] = internal::structured_balance(Scalar(a[i] * ratio), aExponent[i]);
+      }
+      for (Index j = k + 1; j < n; ++j) {
+        Index ratioExponent;
+        const Scalar ratio = internal::cauchy_balanced_diff_ratio(y[j], y[k], x[k], ratioExponent);
+        bExponent[j] += ratioExponent;
+        b[j] = internal::structured_balance(Scalar(b[j] * ratio), bExponent[j]);
+      }
+    }
+    m_isInitialized = true;
+    return *this;
+  }
+
+  Index rows() const noexcept { return m_lu.rows(); }
+  Index cols() const noexcept { return m_lu.cols(); }
+
+  /** \returns \c Success, or \c NumericalIssue when the factorization encounters
+   * a zero or non-finite entry that prevents a usable factorization. */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "CauchyLU is not initialized.");
+    return m_info;
+  }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns the solution \c u of \c C*u = \a b, as a lazily evaluated
+   * expression. Supports multiple right-hand sides. The transposed and adjoint
+   * systems reuse the same factorization through \c transpose().solve(b) and
+   * \c adjoint().solve(b). \pre \ref compute has been called. */
+  template <typename Rhs>
+  inline const Solve<CauchyLU, Rhs> solve(const MatrixBase<Rhs>& b) const;
+#endif
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  /** \internal P*C = L*U, so C*u = b becomes L*U*u = P*b. */
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const {
+    dst = rhs;
+    for (Index k = 0; k < rows(); ++k) {
+      const Index piv = m_perm[static_cast<std::size_t>(k)];
+      if (piv != k) dst.row(k).swap(dst.row(piv));
+    }
+    m_lu.template triangularView<UnitLower>().solveInPlace(dst);
+    m_lu.template triangularView<Upper>().solveInPlace(dst);
+  }
+
+  /** \internal C^T = U^T L^T P, so C^T*w = b becomes U^T (L^T (P w)) = b: solve
+   * the transposed triangles, then undo the transpositions in reverse order;
+   * conjugated on the way in and out for the adjoint. */
+  template <bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType& rhs, DstType& dst) const {
+    dst = rhs.template conjugateIf<Conjugate>();
+    m_lu.template triangularView<Upper>().transpose().solveInPlace(dst);
+    m_lu.template triangularView<UnitLower>().transpose().solveInPlace(dst);
+    for (Index k = rows() - 1; k >= 0; --k) {
+      const Index piv = m_perm[static_cast<std::size_t>(k)];
+      if (piv != k) dst.row(k).swap(dst.row(piv));
+    }
+    if (Conjugate) dst = dst.conjugate().eval();
+  }
+#endif
+
+ private:
+  DenseMatrix m_lu;
+  std::vector<Index> m_perm;  // transposition applied at each elimination step
+  bool m_isInitialized;
+  ComputationInfo m_info;
+};
+
+namespace internal {
+
+// Single product specialization covering every product tag; see the note in
+// Circulant.h.
+template <typename Scalar_, int Rows_, int Cols_, typename Rhs, int ProductTag>
+struct generic_product_impl<Cauchy<Scalar_, Rows_, Cols_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<Cauchy<Scalar_, Rows_, Cols_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_CAUCHY_H
diff --git a/contrib/Eigen/src/StructuredMatrices/Circulant.h b/contrib/Eigen/src/StructuredMatrices/Circulant.h
new file mode 100644
index 0000000..ee66df2
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/Circulant.h
@@ -0,0 +1,660 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] P. J. Davis, "Circulant Matrices", Wiley, 1979. Diagonalization of a
+//      circulant matrix by the DFT and the closed-form eigenstructure used by
+//      eigenvalues()/eigenvectors(); the SVD and pseudo-inverse below follow
+//      from it by taking moduli/phases of the eigenvalues.
+//  [2] R. M. Gray, "Toeplitz and Circulant Matrices: A Review", Foundations and
+//      Trends in Communications and Information Theory, 2(3), 2006.
+//  [3] G. H. Golub and C. F. Van Loan, "Matrix Computations", 4th ed., Johns
+//      Hopkins University Press, 2013, chapter 4.8 (circulant systems and
+//      FFT-based products) and chapter 5.4 (numerical rank conventions).
+//  [4] J. J. Dongarra, J. R. Bunch, C. B. Moler and G. W. Stewart, "LINPACK
+//      Users' Guide", SIAM, 1979. determinant()'s balanced accumulation follows
+//      the convention of its xGEDI routines, which return determinants as a
+//      (fraction, exponent) pair to avoid spurious overflow/underflow.
+//  [5] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, the property the balanced
+//      accumulation, the rescaled rank threshold and the scaled FFT products
+//      rely on.
+
+#ifndef EIGEN_STRUCTURED_CIRCULANT_H
+#define EIGEN_STRUCTURED_CIRCULANT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int Size_ = Dynamic>
+class Circulant;
+
+namespace internal {
+
+template <typename Scalar_, int Size_>
+struct traits<Circulant<Scalar_, Size_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = Size_;
+  static constexpr int ColsAtCompileTime = Size_;
+  static constexpr int MaxRowsAtCompileTime = Size_;
+  static constexpr int MaxColsAtCompileTime = Size_;
+  // Deliberately no NestByRefBit: transpose(), conjugate() and adjoint() return
+  // owning temporaries, so Product must nest the operator by value for a
+  // delayed-evaluated product expression to keep its left factor alive. The copy
+  // is O(n), negligible against the O(n log n) product evaluation.
+  static constexpr int Flags = 0;
+};
+
+template <typename Scalar_, int Size_>
+struct evaluator_traits<Circulant<Scalar_, Size_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class Circulant
+ * \brief An \c n x \c n circulant matrix represented by its first column.
+ *
+ * For first column \f$c\f$ and unitary DFT matrix \f$F\f$,
+ * \f[ C_{ij}=c_{(i-j)\bmod n}, \qquad C=F^*\operatorname{diag}(Fc)F. \f]
+ * Thus its eigenvalues -- the operator's \em symbol -- are \f$Fc\f$, computed
+ * once at construction and reused by every product. This yields an O(n log n)
+ * matrix-vector product (\c operator*), an
+ * O(n log n) direct (pseudo-inverse) solve (\ref solve), and closed-form
+ * factorizations: the eigendecomposition (\ref eigenvalues, \ref eigenvectors)
+ * and the SVD (\ref singularValues, \ref matrixU, \ref matrixV) in the Fourier
+ * basis, plus \ref rank, \ref inverse and \ref determinant. The class is closed
+ * under \ref transpose, \ref conjugate and \ref adjoint, which reuse the cached
+ * symbol instead of recomputing FFTs.
+ *
+ * The operator stores its own copy of the generating column and derives from
+ * \c EigenBase. Because \c operator* returns an Eigen product expression, a
+ * \c Circulant also drops into the matrix-free iterative solvers, and it can be
+ * assigned to a dense matrix when an explicit representation is needed. As with
+ * any matrix-free operator, the iterative solvers must be instantiated with
+ * \c IdentityPreconditioner (e.g.
+ * \c ConjugateGradient<Circulant<double>,Lower|Upper,IdentityPreconditioner>):
+ * the default preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ * \tparam Size_ the dimension at compile time, or \c Dynamic (the default).
+ *
+ * \sa class Toeplitz, makeCirculant()
+ */
+template <typename Scalar_, int Size_>
+class Circulant : public EigenBase<Circulant<Scalar_, Size_>> {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using Complex = std::complex<RealScalar>;
+  using GeneratorType = Matrix<Scalar, Size_, 1>;
+  using ComplexVector = Matrix<Complex, Dynamic, 1>;
+  using RealVector = Matrix<RealScalar, Size_, 1>;
+  using ComplexMatrix = Matrix<Complex, Size_, Size_>;
+
+  static constexpr int RowsAtCompileTime = Size_;
+  static constexpr int ColsAtCompileTime = Size_;
+  static constexpr int MaxRowsAtCompileTime = Size_;
+  static constexpr int MaxColsAtCompileTime = Size_;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Size_, Size_);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const Circulant>'s default StrideType
+  // argument reads it, so its absence makes internal::is_ref_compatible SFINAE to
+  // false and keeps the iterative solvers on their matrix-free path.
+
+  /** Builds a circulant matrix from its first column \a col.
+   *
+   * When the matrix is large enough for products to take the FFT path, the DFT of
+   * \a col -- the eigenvalues of the matrix -- is computed here, once, and reused
+   * by every subsequent product and solve. */
+  template <typename Derived>
+  explicit Circulant(const MatrixBase<Derived>& col) : m_col(col) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+    eigen_assert(m_col.size() > 0 && "Circulant generator must be non-empty");
+    if (m_col.size() > internal::structured_direct_threshold()) {
+      m_symbol = computeSymbol();
+      m_prodSymbol = computeProdSymbol(m_col);
+    }
+    m_fftUsable = computeFftUsable();
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_col.size(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_col.size(); }
+
+  /** \returns the generating first column. */
+  const GeneratorType& column() const { return m_col; }
+
+  /** \returns the symbol of the operator, i.e. the DFT of the generating column.
+   * Its entries are the eigenvalues of the matrix. Cached when the operator is
+   * large enough for products to take the FFT path, computed on the fly for small
+   * operators. */
+  ComplexVector symbol() const { return m_symbol.size() > 0 ? m_symbol : computeSymbol(); }
+
+  /** \returns the coefficient at row \a row and column \a col. */
+  Scalar coeff(Index row, Index col) const {
+    Index k = row - col;
+    if (k < 0) k += rows();
+    return m_col.coeff(k);
+  }
+
+  /** \returns the transpose of \c *this, itself a \c Circulant operator: the one
+   * generated by the index-reversed column. The cached symbols, when present, are
+   * reused -- the symbols of the transpose are the index reversals of the symbols
+   * -- so no FFT is recomputed. */
+  Circulant transpose() const {
+    const Index n = rows();
+    GeneratorType col(n);
+    col[0] = m_col[0];
+    if (n > 1) col.tail(n - 1) = m_col.tail(n - 1).reverse();
+    return Circulant(col, internal::structured_reverse_symbol(m_symbol),
+                     internal::structured_reverse_symbol(m_prodSymbol));
+  }
+
+  /** \returns the complex conjugate of \c *this, itself a \c Circulant operator.
+   * The cached symbols, when present, are reused: the symbols of the conjugate are
+   * the conjugated index reversals of the symbols. */
+  Circulant conjugate() const {
+    return Circulant(m_col.conjugate(), internal::structured_reverse_symbol(m_symbol).conjugate(),
+                     internal::structured_reverse_symbol(m_prodSymbol).conjugate());
+  }
+
+  /** \returns the adjoint of \c *this, itself a \c Circulant operator. The cached
+   * symbols, when present, are reused: the symbols of the adjoint are the
+   * elementwise conjugates of the symbols (the eigenvalues conjugate while the
+   * Fourier eigenbasis stays fixed). */
+  Circulant adjoint() const {
+    const Index n = rows();
+    GeneratorType col(n);
+    col[0] = numext::conj(m_col[0]);
+    if (n > 1) col.tail(n - 1) = m_col.tail(n - 1).reverse().conjugate();
+    return Circulant(col, m_symbol.conjugate(), m_prodSymbol.conjugate());
+  }
+
+  /** \internal Writes the dense representation into \a dst; column \c j is the
+   * generator rotated downwards by \c j. Row-major destinations use reversed
+   * generator segments along each row. Invoked through \c dense = circulant; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    const Index n = rows();
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < n; ++i) {
+        dst.row(i).head(i + 1) = m_col.head(i + 1).reverse().transpose();
+        dst.row(i).tail(n - i - 1) = m_col.tail(n - i - 1).reverse().transpose();
+      }
+      return;
+    }
+    for (Index j = 0; j < n; ++j) {
+      dst.col(j).head(j) = m_col.tail(j);
+      dst.col(j).tail(n - j) = m_col.head(n - j);
+    }
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    const Index n = rows();
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < n; ++i) {
+        dst.row(i).head(i + 1) += m_col.head(i + 1).reverse().transpose();
+        dst.row(i).tail(n - i - 1) += m_col.tail(n - i - 1).reverse().transpose();
+      }
+      return;
+    }
+    for (Index j = 0; j < n; ++j) {
+      dst.col(j).head(j) += m_col.tail(j);
+      dst.col(j).tail(n - j) += m_col.head(n - j);
+    }
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    const Index n = rows();
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < n; ++i) {
+        dst.row(i).head(i + 1) -= m_col.head(i + 1).reverse().transpose();
+        dst.row(i).tail(n - i - 1) -= m_col.tail(n - i - 1).reverse().transpose();
+      }
+      return;
+    }
+    for (Index j = 0; j < n; ++j) {
+      dst.col(j).head(j) -= m_col.tail(j);
+      dst.col(j).tail(n - j) -= m_col.head(n - j);
+    }
+  }
+
+  /** \returns the product expression \c (*this) * \a x, evaluated through a fast
+   * FFT-based matrix-vector product. The expression carries the default product
+   * tag, so assigning it behaves like any dense product: a temporary resolves
+   * aliasing between the destination and \a x, and \c .noalias() skips it. */
+  template <typename Rhs>
+  Product<Circulant, Rhs> operator*(const MatrixBase<Rhs>& x) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(x.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<Circulant, Rhs>(*this, x.derived());
+  }
+
+  /** \returns the minimum-norm least-squares solution of \c (*this) * x = b,
+   * computed directly in the Fourier domain. Symbol entries whose modulus reaches
+   * the rank threshold (see \ref rank) are inverted; the remaining ones are
+   * treated as exact zeros, so the result is the pseudo-inverse applied to \a b.
+   * For a non-singular operator this is the exact solution
+   * \c x = ifft( fft(b) ./ fft(c) ). Supports multiple right-hand sides. */
+  template <typename Rhs>
+  Matrix<Scalar, Size_, Rhs::ColsAtCompileTime> solve(const MatrixBase<Rhs>& b) const {
+    EIGEN_STATIC_ASSERT(RowsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(RowsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    const Index n = rows();
+    eigen_assert(b.rows() == n && "right-hand side has the wrong number of rows");
+    const ComplexVector s = symbol();
+    RealVector mods;
+    RealScalar tol;
+    int es = 0;
+    scaledModuli(s, mods, tol, &es);
+    // Strictly-below-threshold entries are zeroed, matching SVDBase::rank(), so a
+    // smallest-normal 1x1 operator stays invertible. NaN moduli fail the
+    // comparison and land in the inverted set, so a NaN input propagates to the
+    // output instead of being silently zeroed.
+    ComplexVector sinv(n);
+    internal::structured_symbol_reciprocal(s.data(), mods.data(), tol, sinv.data(), n);
+    Matrix<Scalar, Size_, Rhs::ColsAtCompileTime> x(n, b.cols());
+    x.setZero();
+    if (!b.allFinite()) {
+      // A non-finite right-hand side cannot go through the transforms (see
+      // addProduct): apply the pseudo-inverse -- itself a circulant matrix,
+      // generated by the inverse DFT of the thresholded reciprocal symbol --
+      // through the direct kernel so Inf/NaN propagate entrywise.
+      GeneratorType pcol(n);
+      if (n == 1) {
+        pcol[0] = internal::structured_scalar_part_impl<Scalar>::run_scalar(sinv.coeff(0));
+      } else {
+        auto&& fft = internal::structured_fft_engine<RealScalar>();
+        ComplexVector pt(n);
+        fft.inv(pt, sinv, n);
+        pcol = internal::structured_scalar_part_impl<Scalar>::run(pt);
+      }
+      Circulant(pcol, ComplexVector(), ComplexVector()).directProduct(x, b.derived(), Scalar(1));
+      return x;
+    }
+    // The reciprocal of the largest symbol entry is about 2^-es: subnormal, hence
+    // lost under flush-to-zero, only for a symbol at the top of the exponent range.
+    // Dividing by the symbol keeps that mode normal but costs a complex division
+    // per entry, so it is reserved for that band.
+    constexpr Index kSubnormalReciprocal = -(Index(std::numeric_limits<RealScalar>::min_exponent) - 1) - 2;
+    if (es <= kSubnormalReciprocal) {
+      internal::structured_fft_apply(x, sinv, n, b.derived(), Scalar(1));
+      return x;
+    }
+    // ldexp per component rather than a multiply by 2^-es: for a near-boundary
+    // symbol that constant is itself subnormal, and reads as zero under
+    // flush-to-zero. The apply folds es back into the output scaling.
+    const ComplexVector sb = s.unaryExpr([es](const Complex& z) { return internal::structured_ldexp_clamped(z, -es); });
+    // mods and tol are already in a balanced frame, so rebalancing the symbol
+    // leaves the threshold comparison unchanged.
+    internal::structured_symbol_divide<RealVector, RealScalar> divide{&mods, tol};
+    internal::structured_fft_apply(
+        x, sb, n, b.derived(), Scalar(1),
+        [](Index) { eigen_assert(false && "non-finite column requires a direct kernel"); }, divide, es);
+    return x;
+  }
+
+  /** \returns the numerical rank: the number of symbol entries whose modulus is
+   * no smaller than the threshold \c n * epsilon * max_k|symbol[k]|, both
+   * evaluated in an exactly rescaled frame so the moduli cannot overflow (see
+   * scaledModuli()). This is the same threshold \ref solve uses to decide which
+   * Fourier components to invert, and the comparison is strict like SVDBase's,
+   * so an entry sitting exactly on the threshold still counts as non-zero. */
+  Index rank() const {
+    const ComplexVector s = symbol();
+    RealVector mods;
+    RealScalar tol;
+    scaledModuli(s, mods, tol);
+    return (!(mods.array() < tol)).count();  // negated so NaN entries count as non-zero
+  }
+
+  /** \returns the inverse of \c *this, itself a \c Circulant operator: the one
+   * generated by \c ifft(1 ./ symbol), the first column of the inverse matrix.
+   * \warning The operator must be non-singular; use \ref solve for a
+   * pseudo-inverse solve of a rank-deficient operator. */
+  Circulant inverse() const {
+    const Index n = rows();
+    ComplexVector sinv = symbol();
+    internal::structured_symbol_reciprocal(sinv.data(), n);
+    GeneratorType col(n);
+    if (n == 1) {
+      col = internal::structured_scalar_part_impl<Scalar>::run(sinv);
+    } else {
+      auto&& fft = internal::structured_fft_engine<RealScalar>();
+      ComplexVector ct(n);
+      fft.inv(ct, sinv, n);
+      col = internal::structured_scalar_part_impl<Scalar>::run(ct);
+    }
+    return Circulant(col, n > internal::structured_direct_threshold() ? sinv : ComplexVector(),
+                     n > internal::structured_direct_threshold() ? computeProdSymbol(col) : ComplexVector());
+  }
+
+  /** \returns the determinant, i.e. the product of the eigenvalues (the symbol
+   * entries). The product is accumulated in the balanced form \c m * 2^e (the
+   * split fraction/exponent determinant convention of LINPACK's xGEDI [4]) --
+   * every factor and the running product are renormalized to unit magnitude with
+   * the power of two tracked separately -- so the partial products can neither
+   * overflow nor underflow when the determinant itself is representable, whatever
+   * the ordering of large and small eigenvalues. For a real operator the product
+   * is real up to roundoff, and its real part is returned. */
+  Scalar determinant() const {
+    const ComplexVector s = symbol();
+    Complex det(1);
+    Index exponent = 0;
+    for (Index k = 0; k < s.size(); ++k)
+      det = internal::structured_balance(Complex(det * internal::structured_balance(s[k], exponent)), exponent);
+    return internal::structured_scalar_part_impl<Scalar>::run_scalar(internal::structured_ldexp_clamped(det, exponent));
+  }
+
+  /** \returns the eigenvalues: eigenvalue \c k is \c symbol()[k], and its
+   * (unit-norm) eigenvector is the Fourier vector \c f_k with
+   * \f$ (f_k)_j = e^{2\pi i j k / n} / \sqrt{n} \f$, see \ref eigenvectors.
+   * Every circulant matrix is diagonalized by this same Fourier basis. */
+  ComplexVector eigenvalues() const { return symbol(); }
+
+  /** \returns the unitary matrix of eigenvectors: column \c k is the Fourier
+   * vector \c f_k matching \c eigenvalues()[k].
+   * \note The eigenvector matrix is materialized as a dense \c n x \c n matrix;
+   * unlike the other methods of this class this costs O(n^2) storage. */
+  ComplexMatrix eigenvectors() const {
+    const Index n = rows();
+    const ComplexVector roots = fourierRoots();
+    ComplexMatrix F(n, n);
+    for (Index k = 0; k < n; ++k) fourierColumn(F, roots, k, k);
+    return F;
+  }
+
+  /** \returns the singular values, sorted in decreasing order: the moduli of the
+   * symbol entries. The ordering is shared with \ref matrixU and \ref matrixV, so
+   * together they form the SVD \c *this = U * singularValues().asDiagonal() * V^H.
+   * A real operator has a conjugate-symmetric symbol, so the two modes of a
+   * conjugate pair carry exactly equal singular values. */
+  RealVector singularValues() const {
+    ComplexVector s;
+    RealVector mods;
+    const std::vector<Index> perm = svdOrdering(s, mods);
+    RealVector sv(s.size());
+    for (Index t = 0; t < s.size(); ++t) sv[t] = mods[perm[t]];
+    return sv;
+  }
+
+  /** \returns the matrix of left singular vectors \c U: column \c t is the Fourier
+   * vector of the t-th largest symbol entry, scaled by its phase (phase 1 for a
+   * zero entry). Dense \c n x \c n, see the note in \ref eigenvectors. */
+  ComplexMatrix matrixU() const {
+    const Index n = rows();
+    ComplexVector s;
+    RealVector mods;
+    const std::vector<Index> perm = svdOrdering(s, mods);
+    const ComplexVector roots = fourierRoots();
+    ComplexMatrix U(n, n);
+    for (Index t = 0; t < n; ++t) {
+      fourierColumn(U, roots, perm[t], t);
+      const RealScalar a = mods[perm[t]];
+      if (a > RealScalar(0)) U.col(t) *= s[perm[t]] / a;
+    }
+    return U;
+  }
+
+  /** \returns the matrix of right singular vectors \c V: column \c t is the
+   * Fourier vector of the t-th largest symbol entry. Dense \c n x \c n, see the
+   * note in \ref eigenvectors. */
+  ComplexMatrix matrixV() const {
+    const Index n = rows();
+    ComplexVector s;
+    RealVector mods;
+    const std::vector<Index> perm = svdOrdering(s, mods);
+    const ComplexVector roots = fourierRoots();
+    ComplexMatrix V(n, n);
+    for (Index t = 0; t < n; ++t) fourierColumn(V, roots, perm[t], t);
+    return V;
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs. \c ProductScalar is the
+   * promoted scalar of the product (complex when a real operator is applied to a
+   * complex right-hand side); the accumulation runs in the promoted type.
+   *
+   * Non-finite data takes the direct O(n^2) kernel: the transforms would smear a
+   * single Inf/NaN into NaNs across the whole output, where the dense product
+   * only propagates it through the dot products that touch it. A non-finite
+   * generator or cached symbol (which can overflow even for a finite generator)
+   * routes the whole product; a non-finite right-hand-side column is detected
+   * inside the FFT loop -- in the same pass that derives its scaling exponent,
+   * so finite data pays no extra scan -- and falls back per column. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    const Index n = rows();
+    eigen_assert(rhs.rows() == n && "invalid product: dimensions do not match");
+    if (n <= internal::structured_direct_threshold() || !m_fftUsable) {
+      directProduct(dst, rhs, alpha);
+      return;
+    }
+    // Products use the padded embedding symbol when the operator size is not
+    // 5-smooth (see computeProdSymbol()); the exact-size transform of such a
+    // size runs through kissfft's quadratic generic butterfly.
+    const ComplexVector& s = m_prodSymbol.size() > 0 ? m_prodSymbol : m_symbol;
+    internal::structured_fft_apply(dst, s, n, rhs, alpha, [&](Index k) { directProductColumn(dst, rhs, k, alpha); });
+  }
+
+ private:
+  /** \internal Builds an operator from a generator and already-known symbols
+   * (empty for small operators; \a prodSymbol also empty for 5-smooth sizes,
+   * which need no padded product embedding), skipping the FFTs of the public
+   * constructor. Used by transpose(), conjugate(), adjoint() and inverse(),
+   * whose symbols are cheap transformations of the existing ones. */
+  Circulant(const GeneratorType& col, const ComplexVector& symbol, const ComplexVector& prodSymbol)
+      : m_col(col), m_symbol(symbol), m_prodSymbol(prodSymbol) {
+    m_fftUsable = computeFftUsable();
+  }
+
+  /** \internal Whether products may take the FFT path: the generator and the
+   * cached symbols must be finite. The symbols accumulate up to n (respectively
+   * p) addends, so they can overflow to Inf even for a finite generator; such
+   * operators fall back to the direct kernel, which stays exact. */
+  bool computeFftUsable() const {
+    return m_col.allFinite() && (m_symbol.size() == 0 || m_symbol.allFinite()) &&
+           (m_prodSymbol.size() == 0 || m_prodSymbol.allFinite());
+  }
+
+  /** \internal \returns the symbol products should use for a generator \a col of
+   * size n: empty when n is 5-smooth (the exact-size transform is already fast),
+   * otherwise the DFT of the circulant embedding of size
+   * \c p = fft_next_good_size(2n - 1) -- the length-n cyclic convolution
+   * evaluated as a padded linear convolution, exactly the Toeplitz embedding of
+   * the circulant. kissfft falls back to a quadratic generic butterfly for prime
+   * factors other than 2, 3 and 5, so the exact-size transform of e.g. a prime n
+   * costs orders of magnitude more than the padded one. The spectral operations
+   * (eigenvalues, solve, rank, determinant, SVD) keep the exact-size symbol,
+   * whose entries are the eigenvalues. */
+  static ComplexVector computeProdSymbol(const GeneratorType& col) {
+    const Index n = col.size();
+    if (internal::fft_next_good_size(n) == n) return ComplexVector();
+    const Index p = internal::fft_next_good_size(2 * n - 1);
+    ComplexVector embedding = ComplexVector::Zero(p);
+    embedding.head(n) = col.template cast<Complex>();
+    embedding.tail(n - 1) = col.tail(n - 1).template cast<Complex>();
+    ComplexVector symbol(p);
+    auto&& fft = internal::structured_fft_engine<RealScalar>();
+    fft.fwd(symbol, embedding, p);
+    return symbol;
+  }
+
+  /** \internal Direct O(n^2) kernel for column \a k of the right-hand side:
+   * computes \c dst.col(k) += alpha * (*this) * rhs.col(k) without transforms.
+   * Serves operators below the FFT threshold and any column involving
+   * non-finite data, whose entrywise IEEE semantics the transforms cannot
+   * preserve. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProductColumn(Dest& dst, const Rhs& rhs, Index k, const ProductScalar& alpha) const {
+    const Index n = rows();
+    // A unit alpha must not multiply: even the identity complex scalar (1,0)
+    // pollutes an (Inf,0) value with NaN through the 0*Inf cross term.
+    const bool unitAlpha = alpha == ProductScalar(1);
+    if (n <= internal::structured_scalar_threshold()) {
+      // Tiny sizes: a plain scalar loop beats the segment-based path below, whose
+      // per-segment setup dominates when segments hold only a few entries.
+      for (Index i = 0; i < n; ++i) {
+        ProductScalar acc(0);
+        for (Index j = 0; j < n; ++j) acc += coeff(i, j) * rhs.coeff(j, k);
+        dst.coeffRef(i, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
+      }
+      return;
+    }
+
+    // Column j is c rotated downward by j; split it into two contiguous segments.
+    auto dstCol = dst.col(k);
+    for (Index j = 0; j < n; ++j) {
+      const ProductScalar xj = unitAlpha ? ProductScalar(rhs.coeff(j, k)) : ProductScalar(alpha * rhs.coeff(j, k));
+      dstCol.head(j) += xj * m_col.tail(j);
+      dstCol.tail(n - j) += xj * m_col.head(n - j);
+    }
+  }
+
+  /** \internal Direct O(n^2) product kernel over every column, see
+   * directProductColumn(). */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    for (Index k = 0; k < rhs.cols(); ++k) directProductColumn(dst, rhs, k, alpha);
+  }
+
+  /** \internal Computes the moduli of the symbol entries and the matching
+   * rank/pseudo-inversion threshold, both evaluated in an exactly rescaled frame:
+   * the entries are pre-scaled by a power of two chosen so no modulus can
+   * overflow. A finite complex entry near the overflow threshold has a
+   * non-representable modulus, which would otherwise turn the threshold into
+   * infinity and misclassify every other entry (rank under-reported, solve()
+   * zeroing valid Fourier modes). The rescaling is exact, so comparing scaled
+   * moduli against the scaled threshold is equivalent to the unscaled
+   * comparison. The threshold keeps the n * epsilon * max_k|s[k]| convention of
+   * [3], chapter 5.4, and the smallest-normal clamp -- carried into the scaled
+   * frame, where its underflowing to zero for a huge frame is correct: no entry
+   * of such a symbol can sit below the smallest normal number. Entries at or
+   * above the threshold, in particular a smallest-normal entry of a moderate
+   * symbol, are inverted (their reciprocals are finite). */
+  static void scaledModuli(const ComplexVector& s, RealVector& mods, RealScalar& tol, int* frameExp = nullptr) {
+    const int e = numext::maxi(internal::structured_exponent_bound(s), 0);
+    if (frameExp) *frameExp = e;
+    // Two exact factors, as in structured_fft_apply(): a single 2^-e is itself
+    // subnormal once the frame exceeds the exponent range, and reads as zero under
+    // flush-to-zero -- collapsing every scaled modulus, and the threshold with
+    // them. Neither factor exceeds one, so no intermediate underflows on its own.
+    const RealScalar down1 = numext::ldexp(RealScalar(1), -(e / 2)), down2 = numext::ldexp(RealScalar(1), -(e - e / 2));
+    mods = ((s * down1) * down2).cwiseAbs();
+    tol = numext::maxi(RealScalar(s.size()) * NumTraits<RealScalar>::epsilon() * mods.maxCoeff(),
+                       ((std::numeric_limits<RealScalar>::min)() * down1) * down2);
+  }
+
+  /** \internal Computes the symbol \a s and the moduli \a mods that order the
+   * SVD, and \returns the permutation sorting those moduli in decreasing order --
+   * the single ordering singularValues(), matrixU() and matrixV() agree on.
+   *
+   * For a real generator the symbol is conjugate-symmetric, so modes \c k and
+   * \c n-k have equal moduli; taken through the complex transform they agree only
+   * to roundoff. Ranking such a pair by the computed moduli leaves its order
+   * decided by those last bits, and the three accessors each derive the ordering
+   * from their own symbol computation, which nothing requires to agree down to
+   * the last bit: one of them ranking a pair the other way pairs a left singular
+   * vector with the wrong right one and breaks the reconstruction by an O(1)
+   * amount. The moduli of a conjugate pair are therefore tied exactly, which the
+   * stable sort resolves by index in every caller. Sharing one value between the
+   * pair costs nothing: it cancels out of \c U * S, where matrixU() divides the
+   * mode's phase by it and singularValues() returns it.
+   */
+  std::vector<Index> svdOrdering(ComplexVector& s, RealVector& mods) const {
+    const Index n = rows();
+    s = symbol();
+    EIGEN_IF_CONSTEXPR (!NumTraits<Scalar>::IsComplex) {
+      const Index pairs = (n - 1) / 2;
+      mods.resize(n);
+      mods.head(n - pairs) = s.head(n - pairs).cwiseAbs();
+      mods.tail(pairs) = mods.segment(1, pairs).reverse();
+    } else {
+      mods = s.cwiseAbs();
+    }
+    return internal::structured_svd_permutation(mods);
+  }
+
+  // Cache the n distinct roots once per Fourier matrix, preserving polar()'s
+  // bounded arguments and rounding while avoiding n^2 trigonometric evaluations.
+  ComplexVector fourierRoots() const {
+    const Index n = rows();
+    const RealScalar scale = RealScalar(1) / numext::sqrt(RealScalar(n));
+    ComplexVector roots(n);
+    for (Index j = 0; j < n; ++j)
+      roots[j] = std::polar(scale, RealScalar(2 * EIGEN_PI) * RealScalar(j) / RealScalar(n));
+    return roots;
+  }
+
+  // Column k uses roots[j*k mod n]; incremental modular indexing avoids j*k overflow.
+  void fourierColumn(ComplexMatrix& F, const ComplexVector& roots, Index k, Index dstCol) const {
+    const Index n = rows();
+    Index jk = 0;
+    for (Index j = 0; j < n; ++j) {
+      F(j, dstCol) = roots[jk];
+      jk += k;
+      if (jk >= n) jk -= n;
+    }
+  }
+
+  /** \internal \returns the DFT of the generating column. */
+  ComplexVector computeSymbol() const {
+    const Index n = m_col.size();
+    const ComplexVector cc = m_col.template cast<Complex>();
+    if (n == 1) return cc;  // the DFT of a single sample is the identity
+    ComplexVector symbol(n);
+    auto&& fft = internal::structured_fft_engine<RealScalar>();
+    fft.fwd(symbol, cc, n);
+    return symbol;
+  }
+
+  GeneratorType m_col;
+  ComplexVector m_symbol;
+  // The padded embedding symbol products use when the size is not 5-smooth;
+  // empty otherwise. See computeProdSymbol().
+  ComplexVector m_prodSymbol;
+  bool m_fftUsable;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref Circulant operator with first column \a col. The compile-time
+ * size of the operator is deduced from \a col. */
+template <typename Derived>
+Circulant<typename Derived::Scalar, Derived::SizeAtCompileTime> makeCirculant(const MatrixBase<Derived>& col) {
+  return Circulant<typename Derived::Scalar, Derived::SizeAtCompileTime>(col);
+}
+
+namespace internal {
+
+// StructuredShape avoids ambiguity with the stock dense product specializations.
+template <typename Scalar_, int Size_, typename Rhs, int ProductTag>
+struct generic_product_impl<Circulant<Scalar_, Size_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<Circulant<Scalar_, Size_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_CIRCULANT_H
diff --git a/contrib/Eigen/src/StructuredMatrices/DPR1EigenSolver.h b/contrib/Eigen/src/StructuredMatrices/DPR1EigenSolver.h
new file mode 100644
index 0000000..9f1e879
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/DPR1EigenSolver.h
@@ -0,0 +1,622 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_STRUCTURED_DPR1_EIGEN_SOLVER_H
+#define EIGEN_STRUCTURED_DPR1_EIGEN_SOLVER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \ingroup StructuredMatrices_Module
+ * \class DPR1EigenSolver
+ * \brief Direct O(n^2) eigensolver for real symmetric diagonal-plus-rank-one
+ * matrices \f$ A = D + \rho\, z z^T \f$, via the secular equation.
+ *
+ * This is the standalone version of the kernel at the heart of the
+ * divide-and-conquer symmetric eigensolvers (LAPACK's xLAED2/3/4): after
+ * \em deflation -- entries with negligible \f$ |z_i| \f$ are eigenpairs of the
+ * diagonal already, and (nearly) equal diagonal entries are combined by Givens
+ * rotations whose dropped coupling is below a backward-stability threshold --
+ * the surviving eigenvalues are the roots of the secular equation
+ * \f[ f(\lambda) = 1 + \rho \sum_i \frac{z_i^2}{d_i - \lambda} = 0, \f]
+ * one in each interval between consecutive poles. Each root is bracketed and
+ * bisected in coordinates \em shifted to its nearest pole, so every distance
+ * \f$ \lambda - d_i \f$ is retained as an exact data difference plus a small
+ * offset instead of a cancellation-prone subtraction of close numbers.
+ * Eigenvectors are then built not from the original \c z but from the
+ * Gu-Eisenstat vector \f$ \hat z \f$ -- the one for which the computed roots
+ * are \em exact secular eigenvalues -- which is what makes the computed
+ * eigenvector matrix numerically orthogonal without any reorthogonalization.
+ *
+ * The total cost is O(n^2): O(n log(1/eps)) per bisected root in the common
+ * case (the iteration cap is sized to the scalar's full exponent range, so
+ * even roots subnormally close to their pole resolve), O(n) per Gu-Eisenstat
+ * weight, and O(n) per eigenvector (the deflation rotations are replayed
+ * instead of accumulated into a dense matrix).
+ *
+ * Both signs of \f$ \rho \f$ are supported (negative \f$ \rho \f$ is handled by
+ * negating the matrix), as are \f$ \rho = 0 \f$, zero \c z, repeated diagonal
+ * entries and any ordering of \c d. The problem is rescaled internally by
+ * exact powers of two chosen from the component exponents alone, so data
+ * anywhere in the representable range is handled without internal overflow --
+ * including inputs for which \f$ \rho \|z\|^2 \f$ alone exceeds the largest
+ * finite value while every eigenvalue is still representable. \c InvalidInput
+ * is reported only for non-finite input or a spectrum that is itself not
+ * representable. On well-scaled data the rescaling changes no bits of the
+ * result (rounding can occur only at the subnormal boundary, far below the
+ * deflation backward-error budget).
+ *
+ * \code
+ *   DPR1EigenSolver<double> es(d, rho, z);
+ *   VectorXd  lambda = es.eigenvalues();   // ascending
+ *   MatrixXd  V      = es.eigenvectors();  // orthogonal
+ * \endcode
+ *
+ * \tparam RealScalar_ one of \c float, \c double, or \c long \c double.
+ *
+ * References:
+ *  - M. Gu and S. C. Eisenstat, "A stable and efficient algorithm for the
+ *    rank-one modification of the symmetric eigenproblem," SIAM J. Matrix Anal.
+ *    Appl., 15(4):1266-1276, 1994.
+ *  - N. J. Higham, "Accuracy and Stability of Numerical Algorithms", 2nd ed.,
+ *    SIAM, 2002, chapter 27. Avoiding spurious overflow by rescaling with
+ *    powers of two: the whole-problem scale chosen from component exponents
+ *    and the (mantissa, exponent) handling of rho*||z||^2 follow this
+ *    technique.
+ *  - P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+ *    Scaling by a power of two is exact, the property the frexp/ldexp
+ *    problem scaling and the full-range ArrayBase::ldexp unscaling of the
+ *    eigenvalues rely on.
+ *
+ * \sa class SelfAdjointEigenSolver
+ */
+template <typename RealScalar_>
+class DPR1EigenSolver {
+ public:
+  using RealScalar = RealScalar_;
+  using Scalar = RealScalar;
+  using Index = Eigen::Index;
+  using VectorType = Matrix<RealScalar, Dynamic, 1>;
+  using MatrixType = Matrix<RealScalar, Dynamic, Dynamic>;
+
+  static_assert(std::is_same<RealScalar, float>::value || std::is_same<RealScalar, double>::value ||
+                    std::is_same<RealScalar, long double>::value,
+                "DPR1EigenSolver supports only float, double, and long double scalar types.");
+
+  /** Default constructor; call \ref compute before querying results. */
+  DPR1EigenSolver() = default;
+
+  /** Computes the eigendecomposition of \c diag(d) + \c rho*z*z^T.
+   * \a options is \c ComputeEigenvectors (the default) or \c EigenvaluesOnly. */
+  DPR1EigenSolver(const VectorType& d, RealScalar rho, const VectorType& z, int options = ComputeEigenvectors) {
+    compute(d, rho, z, options);
+  }
+
+  /** Computes the eigendecomposition of \c diag(d) + \c rho*z*z^T. \sa DPR1EigenSolver() */
+  DPR1EigenSolver& compute(const VectorType& d, RealScalar rho, const VectorType& z, int options = ComputeEigenvectors);
+
+  /** \returns the eigenvalues, sorted in increasing order. */
+  const VectorType& eigenvalues() const {
+    eigen_assert(m_isInitialized && "DPR1EigenSolver is not initialized.");
+    return m_eivalues;
+  }
+
+  /** \returns the orthogonal matrix of eigenvectors; column \c k matches
+   * \c eigenvalues()[k]. \pre \ref compute was called with \c ComputeEigenvectors. */
+  const MatrixType& eigenvectors() const {
+    eigen_assert(m_isInitialized && "DPR1EigenSolver is not initialized.");
+    eigen_assert(m_vectorsComputed && "eigenvectors were not computed");
+    return m_eivec;
+  }
+
+  /** \returns \c Success if the decomposition succeeded, \c NoConvergence if a
+   * secular root or the spectrum's finite-range boundary could not be fully
+   * resolved, \c InvalidInput if the input was non-finite or its spectrum is
+   * not representable in the scalar type. */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "DPR1EigenSolver is not initialized.");
+    return m_info;
+  }
+
+ private:
+  // A deflation-stage Givens rotation acting on working rows (i, j).
+  struct Rotation {
+    Index i, j;
+    RealScalar c, s;
+  };
+
+  struct DoubleWord {
+    RealScalar hi, lo;
+  };
+
+  enum class SpectrumRange { Representable, ExactBoundary, Overflow, Uncertain };
+
+  static DoubleWord addDoubleWords(const DoubleWord& x, const DoubleWord& y) {
+    DoubleWord result;
+    internal::twosum(x.hi, x.lo, y.hi, y.lo, result.hi, result.lo);
+    return result;
+  }
+
+  static DoubleWord multiplyDoubleWords(const DoubleWord& x, const DoubleWord& y) {
+    DoubleWord result;
+    internal::twoprod(x.hi, x.lo, y.hi, y.lo, result.hi, result.lo);
+    return result;
+  }
+
+  static DoubleWord divideDoubleWords(const DoubleWord& x, const DoubleWord& y) {
+    DoubleWord quotient;
+    internal::doubleword_div_fp(x.hi, x.lo, y.hi, quotient.hi, quotient.lo);
+    const DoubleWord product = multiplyDoubleWords(quotient, y);
+    const DoubleWord remainder = addDoubleWords(x, DoubleWord{-product.hi, -product.lo});
+    DoubleWord correction;
+    internal::doubleword_div_fp(remainder.hi, remainder.lo, y.hi, correction.hi, correction.lo);
+    return addDoubleWords(quotient, correction);
+  }
+
+  static DoubleWord scaleDoubleWord(const DoubleWord& x, int exponent) {
+    EIGEN_USING_STD(ldexp)
+    DoubleWord result{ldexp(x.hi, exponent), ldexp(x.lo, exponent)};
+    if ((numext::isfinite)(result.hi)) {
+      DoubleWord normalized;
+      internal::fast_twosum(result.hi, result.lo, normalized.hi, normalized.lo);
+      result = normalized;
+    }
+    return result;
+  }
+
+  static SpectrumRange classifySpectrumRange(const VectorType& d, RealScalar rho, const VectorType& z);
+
+  /** \internal Evaluates the shifted secular function
+   * g(tau) = 1 + rho * sum_i zeta_i^2 / (delta_i - tau), with delta_i the pole
+   * offsets relative to the chosen shift. */
+  static RealScalar secular(const VectorType& delta, const VectorType& zeta2, RealScalar rho, RealScalar tau) {
+    return RealScalar(1) + rho * (zeta2.array() / (delta.array() - tau)).sum();
+  }
+
+  VectorType m_eivalues;
+  MatrixType m_eivec;
+  bool m_isInitialized = false;
+  bool m_vectorsComputed = false;
+  ComputationInfo m_info = InvalidInput;
+};
+
+template <typename RealScalar_>
+typename DPR1EigenSolver<RealScalar_>::SpectrumRange DPR1EigenSolver<RealScalar_>::classifySpectrumRange(
+    const VectorType& d, RealScalar rho, const VectorType& z) {
+  // For rho >= 0 only the largest eigenvalue can leave the finite range; with M = highest(), the
+  // matrix determinant lemma gives lambda_max <= M iff rho * sum_i z_i^2 / (M - d_i) <= 1. Evaluated
+  // from the original data, not the normalized secular problem, which has already rounded rho*||z||^2.
+  // Double-word arithmetic and its O(u^2) bounds follow Joldes, Muller and Popescu, "Tight and
+  // rigorous error bounds for basic building blocks of double-word arithmetic", ACM TOMS 44(2), 2017.
+  if (rho == RealScalar(0)) return SpectrumRange::Representable;
+
+  EIGEN_USING_STD(frexp)
+  EIGEN_USING_STD(ldexp)
+  const RealScalar highest = (std::numeric_limits<RealScalar>::max)();
+  const RealScalar highestHalf = highest / RealScalar(2);
+  int rhoExponent = 0;
+  const RealScalar rhoFraction = frexp(rho, &rhoExponent);
+  DoubleWord sum{RealScalar(0), RealScalar(0)};
+  bool exactSumValid = true;
+  Index active = 0;
+
+  for (Index i = 0; i < d.size(); ++i) {
+    if (z[i] == RealScalar(0)) continue;
+    ++active;
+    if (d[i] == highest) return SpectrumRange::Overflow;
+
+    int zExponent = 0;
+    const RealScalar zFraction = frexp(numext::abs(z[i]), &zExponent);
+    DoubleWord numerator;
+    internal::twoprod(rhoFraction, zFraction, numerator.hi, numerator.lo);
+    const bool numeratorExact = numerator.lo == RealScalar(0) || zFraction == RealScalar(0.5);
+    if (zFraction == RealScalar(0.5)) {
+      numerator.hi *= zFraction;
+      numerator.lo *= zFraction;
+      DoubleWord normalized;
+      internal::fast_twosum(numerator.hi, numerator.lo, normalized.hi, normalized.lo);
+      numerator = normalized;
+    } else if (numerator.lo == RealScalar(0)) {
+      DoubleWord product;
+      internal::twoprod(numerator.hi, zFraction, product.hi, product.lo);
+      numerator = product;
+    } else {
+      DoubleWord product;
+      internal::twoprod(numerator.hi, numerator.lo, zFraction, product.hi, product.lo);
+      numerator = product;
+    }
+
+    // Work with (M - d_i)/2, which cannot overflow even when d_i = -M.
+    const RealScalar dHalf = d[i] / RealScalar(2);
+    DoubleWord denominator;
+    internal::twosum(highestHalf, RealScalar(0), -dHalf, RealScalar(0), denominator.hi, denominator.lo);
+    const bool denominatorExact = d[i] == RealScalar(0) || dHalf * RealScalar(2) == d[i];
+    const DoubleWord unscaledDenominator = denominator;
+    int denominatorExponent = 0;
+    frexp(unscaledDenominator.hi, &denominatorExponent);
+    const RealScalar scaledDenominatorHi = ldexp(unscaledDenominator.hi, -denominatorExponent);
+    const RealScalar scaledDenominatorLo = ldexp(unscaledDenominator.lo, -denominatorExponent);
+    const bool denominatorScaleExact = ldexp(scaledDenominatorHi, denominatorExponent) == unscaledDenominator.hi &&
+                                       ldexp(scaledDenominatorLo, denominatorExponent) == unscaledDenominator.lo;
+    denominator = scaleDoubleWord(unscaledDenominator, -denominatorExponent);
+
+    const int termExponent = rhoExponent + 2 * zExponent - denominatorExponent - 1;
+    const DoubleWord quotient = divideDoubleWords(numerator, denominator);
+    const DoubleWord term = scaleDoubleWord(quotient, termExponent);
+    if (!(numext::isfinite)(term.hi) || term.hi > RealScalar(2)) return SpectrumRange::Overflow;
+
+    const RealScalar previousSum = sum.hi;
+    sum = addDoubleWords(sum, term);
+    if (!(numext::isfinite)(sum.hi) || sum.hi > RealScalar(2)) return SpectrumRange::Overflow;
+
+    // Certify an exact endpoint equality only from terms whose division,
+    // exponent scaling, and scalar accumulation are all proven exact. This is
+    // deliberately stricter than the O(u^2) sign estimate below: a rounded
+    // equality must remain Uncertain rather than become a false Success.
+    if (exactSumValid) {
+      const RealScalar normalMin = (std::numeric_limits<RealScalar>::min)();
+      bool exactTerm = numeratorExact && denominatorExact && denominatorScaleExact && denominator.lo == RealScalar(0) &&
+                       quotient.lo == RealScalar(0) && term.lo == RealScalar(0) && term.hi >= normalMin &&
+                       ldexp(term.hi, -termExponent) == quotient.hi;
+      if (exactTerm) {
+        DoubleWord recoveredNumerator;
+        internal::twoprod(quotient.hi, denominator.hi, recoveredNumerator.hi, recoveredNumerator.lo);
+        exactTerm = recoveredNumerator.hi == numerator.hi && recoveredNumerator.lo == numerator.lo;
+      }
+      if (exactTerm) {
+        const RealScalar larger = numext::maxi(previousSum, term.hi);
+        const RealScalar smaller = numext::mini(previousSum, term.hi);
+        // The reversible subtraction remains a proof if FTZ erases a
+        // subnormal low word from the double-word addition.
+        exactSumValid = sum.lo == RealScalar(0) && sum.hi - larger == smaller;
+      } else {
+        exactSumValid = false;
+      }
+    }
+  }
+
+  if (active == 0) return SpectrumRange::Representable;
+  if (exactSumValid && sum.hi == RealScalar(1)) return SpectrumRange::ExactBoundary;
+
+  const DoubleWord difference = addDoubleWords(sum, DoubleWord{RealScalar(-1), RealScalar(0)});
+  const RealScalar estimate = difference.hi + difference.lo;
+  const RealScalar unitRoundoff = NumTraits<RealScalar>::epsilon() / RealScalar(2);
+  // The factor 32 covers two products, corrected division, exponent scaling,
+  // and accumulation per active term. Proven exact endpoint equality is handled
+  // above rather than widened into the uncertainty interval.
+  const RealScalar error = RealScalar(32) * RealScalar(active + 1) * unitRoundoff * unitRoundoff;
+  if (estimate < -error) return SpectrumRange::Representable;
+  if (estimate > error) return SpectrumRange::Overflow;
+  return SpectrumRange::Uncertain;
+}
+
+template <typename RealScalar_>
+DPR1EigenSolver<RealScalar_>& DPR1EigenSolver<RealScalar_>::compute(const VectorType& d, RealScalar rho,
+                                                                    const VectorType& z, int options) {
+  const Index n = d.size();
+  eigen_assert(z.size() == n && "d and z must have the same size");
+  eigen_assert((options & ~EigVecMask) == 0 && (options & EigVecMask) != EigVecMask && "invalid option parameter");
+  const bool computeVectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
+  m_vectorsComputed = false;
+  m_info = Success;
+
+  m_eivalues.resize(n);
+  if (computeVectors) m_eivec.setIdentity(n, n);
+
+  // Non-finite input would break the sorting comparator (not a strict weak
+  // order under NaN) and silently deflate everything; reject it up front.
+  if (!(d.allFinite() && z.allFinite() && (numext::isfinite)(rho))) {
+    m_eivalues.setConstant(NumTraits<RealScalar>::quiet_NaN());
+    m_info = InvalidInput;
+    m_isInitialized = true;
+    return *this;
+  }
+  if (n == 0) {
+    m_vectorsComputed = computeVectors;
+    m_isInitialized = true;
+    return *this;
+  }
+
+  const bool negated = rho < RealScalar(0);
+  VectorType dW = negated ? VectorType(-d) : d;
+  RealScalar rhoW = negated ? -rho : rho;
+
+  // pi maps each sorted working index to its input row.
+  std::vector<Index> pi;
+  pi.reserve(static_cast<std::size_t>(n));
+  for (Index i = 0; i < n; ++i) pi.push_back(i);
+  std::stable_sort(pi.begin(), pi.end(), [&dW](Index a, Index b) { return dW[a] < dW[b]; });
+  VectorType ds(n), zs(n);
+  for (Index i = 0; i < n; ++i) {
+    ds[i] = dW[pi[static_cast<std::size_t>(i)]];
+    zs[i] = z[pi[static_cast<std::size_t>(i)]];
+  }
+
+  // Normalize z and absorb ||z||^2 into rho. Power-of-two scaling is exact away
+  // from the subnormal boundary, unlike the general scaling in LAPACK xLAED*.
+  EIGEN_USING_STD(frexp)
+  EIGEN_USING_STD(ldexp)
+  // With max|z_i| < 2^zExp, ||2^-zExp z|| is representable even if ||z|| is not.
+  int zExp = 0;
+  const RealScalar zmax = zs.cwiseAbs().maxCoeff();
+  if (zmax > RealScalar(0)) {
+    frexp(zmax, &zExp);
+    if (zExp != 0) zs.array() = zs.array().ldexp(-zExp);
+  }
+  const RealScalar znorm = zs.stableNorm();  // in [0.5, sqrt(n)): safe
+  int znormExp = 0;
+  const RealScalar znormFrac = frexp(znorm, &znormExp);
+  if (znorm > RealScalar(0)) zs /= znorm;
+  // Store rho ||z||^2 = rhoMant * 2^rhoTotExp without materializing a possibly
+  // overflowing product; each mantissa factor lies in [1/4,1).
+  int rhoExp = 0;
+  const RealScalar rhoFrac = frexp(rhoW, &rhoExp);
+  int rhoAdj = 0;
+  const RealScalar rhoMant = frexp((rhoFrac * znormFrac) * znormFrac, &rhoAdj);  // in [0.5, 1), or 0
+  // Each frexp exponent is bounded by the scalar's exponent range, but their
+  // accumulation is kept in a wide integer type until the (clamped) narrowing
+  // to the int that ldexp takes.
+  const numext::int64_t rhoTotExp =
+      numext::int64_t(rhoExp) + 2 * (numext::int64_t(zExp) + numext::int64_t(znormExp)) + numext::int64_t(rhoAdj);
+  // For s = 2^-scaleExp, eig(sD + s rho zz^T) = s eig(D + rho zz^T).
+  // Choose s so max(||sD||_inf, s rho ||z||^2) lies in [1/2,1), comparing the
+  // two scales as mantissa-exponent pairs to avoid overflow.
+  int dExp = 0;
+  const RealScalar dFrac = frexp(ds.cwiseAbs().maxCoeff(), &dExp);
+  RealScalar scaledNorm;  // max(|d|_inf, rho*||z||^2) * 2^-scaleExp, in [0.5, 1) (or 0 for a zero matrix)
+  numext::int64_t scaleExpWide;
+  if (rhoMant == RealScalar(0) ||
+      (dFrac > RealScalar(0) &&
+       (numext::int64_t(dExp) > rhoTotExp || (numext::int64_t(dExp) == rhoTotExp && dFrac >= rhoMant)))) {
+    scaledNorm = dFrac;
+    scaleExpWide = dExp;
+  } else {
+    scaledNorm = rhoMant;
+    scaleExpWide = rhoTotExp;
+  }
+  // Clamp before narrowing: 2^(2^30) is far beyond any scalar's exponent
+  // range, so the clamp never changes which values are representable.
+  const numext::int64_t expCap = numext::int64_t(1) << 30;
+  const int scaleExp = static_cast<int>(numext::maxi(-expCap, numext::mini(expCap, scaleExpWide)));
+  SpectrumRange spectrumRange = SpectrumRange::Representable;
+  if (scaleExpWide >= numext::int64_t(std::numeric_limits<RealScalar>::max_exponent) - 1) {
+    spectrumRange = classifySpectrumRange(dW, rhoW, z);
+  }
+  if (scaleExp != 0) ds.array() = ds.array().ldexp(-scaleExp);
+  // Materialize rho * ||z||^2 only in scaled form: its exponent is <= 0 by the
+  // choice of scaleExp, so this cannot overflow; it can only underflow when
+  // the update is negligible against |d|_inf, in which case it deflates below.
+  rhoW = ldexp(rhoMant, static_cast<int>(numext::maxi(-expCap, rhoTotExp - scaleExpWide)));
+
+  // Backward-error budget: dropping a coupling of size <= tol perturbs the
+  // matrix by O(tol), like LAPACK's xLAED2. Using max(|d|_inf, rho*||z||^2) as
+  // the scale is the unscaled-problem generalization of xLAED2's criterion: the
+  // perturbation stays O(eps * (||D|| + rho ||z||^2)), i.e. backward stable in
+  // the data.
+  const RealScalar tol = RealScalar(8) * NumTraits<RealScalar>::epsilon() * scaledNorm;
+
+  std::vector<Rotation> rotations;
+  std::vector<bool> deflated;
+
+  if (rhoW <= tol) {
+    deflated.assign(static_cast<std::size_t>(n), true);
+  } else {
+    // Negligible z_i leaves d_i as an eigenvalue.
+    deflated.reserve(static_cast<std::size_t>(n));
+    for (Index i = 0; i < n; ++i) deflated.push_back(rhoW * numext::abs(zs[i]) <= tol);
+    // The dropped off-diagonal coupling is |c*s*(ds[i]-ds[p])| <= tol.
+    Index p = -1;
+    for (Index i = 0; i < n; ++i) {
+      if (deflated[static_cast<std::size_t>(i)]) continue;
+      if (p >= 0) {
+        const RealScalar r = numext::hypot(zs[p], zs[i]);
+        const RealScalar c = zs[i] / r, s = zs[p] / r;  // zeroes the earlier entry
+        if (numext::abs(c * s * (ds[i] - ds[p])) <= tol) {
+          // Rotated diagonal: the deflated position keeps one entry, the
+          // surviving pole the other; both stay inside [ds[p], ds[i]].
+          const RealScalar dp = c * c * ds[p] + s * s * ds[i];
+          const RealScalar di = s * s * ds[p] + c * c * ds[i];
+          ds[p] = dp;
+          ds[i] = di;
+          zs[i] = r;
+          zs[p] = RealScalar(0);
+          deflated[static_cast<std::size_t>(p)] = true;
+          if (computeVectors) rotations.push_back(Rotation{p, i, c, s});
+        }
+      }
+      if (!deflated[static_cast<std::size_t>(i)]) p = i;
+    }
+  }
+
+  std::vector<Index> sub;  // working positions of the surviving poles
+  for (Index i = 0; i < n; ++i)
+    if (!deflated[static_cast<std::size_t>(i)]) sub.push_back(i);
+  const Index m = static_cast<Index>(sub.size());
+
+  VectorType lambdaW = ds;
+
+  MatrixType subVectors;  // m x m secular eigenvectors (in subproblem coordinates)
+
+  if (m > 0) {
+    VectorType delta(m), zeta(m), zeta2(m);
+    std::vector<Index> shiftIndex(static_cast<std::size_t>(m));
+    VectorType tau(m);
+    for (Index a = 0; a < m; ++a) {
+      delta[a] = ds[sub[static_cast<std::size_t>(a)]];
+      zeta[a] = zs[sub[static_cast<std::size_t>(a)]];
+    }
+    zeta2.array() = zeta.array() * zeta.array();
+    const RealScalar zeta2sum = zeta2.sum();
+
+    // Bisection stops when the bracket has collapsed to adjacent floating-point
+    // numbers. The backstop covers exponent_range + 2*digits halvings, enough
+    // to shrink a unit-width bracket to a subnormal root offset and resolve it.
+    const int digits =
+        (std::numeric_limits<RealScalar>::digits > 0) ? static_cast<int>(std::numeric_limits<RealScalar>::digits) : 128;
+    const int expRange = (std::numeric_limits<RealScalar>::max_exponent > std::numeric_limits<RealScalar>::min_exponent)
+                             ? static_cast<int>(std::numeric_limits<RealScalar>::max_exponent) -
+                                   static_cast<int>(std::numeric_limits<RealScalar>::min_exponent)
+                             : 16 * digits;
+    const int maxBisect = expRange + 2 * digits + 32;
+    VectorType lam(m), dsh(m);  // dsh is refilled from scratch each root
+    for (Index k = 0; k < m; ++k) {
+      // Choose the shift pole and the bracket, entirely in shifted coordinates.
+      RealScalar lo, hi;
+      Index shift;
+      if (k + 1 == m) {
+        // Last root: it lies in (delta_m, delta_m + rho*|zeta|^2]; never form
+        // the unshifted right end (it can round to the pole itself).
+        shift = k;
+        lo = RealScalar(0);
+        hi = rhoW * zeta2sum;
+      } else {
+        // Interior root: the secular function is increasing between the poles,
+        // so its sign at the midpoint picks the nearer pole as the shift.
+        const RealScalar left = delta[k], right = delta[k + 1];
+        const RealScalar mid = left + (right - left) / RealScalar(2);
+        if (secular(delta, zeta2, rhoW, mid) > RealScalar(0)) {
+          shift = k;
+          lo = RealScalar(0);
+          hi = mid - left;
+        } else {
+          shift = k + 1;
+          lo = mid - right;  // negative
+          hi = RealScalar(0);
+        }
+      }
+      const RealScalar shiftVal = delta[shift];
+      dsh.array() = delta.array() - shiftVal;
+
+      // Bisection: g(lo) < 0 < g(hi) by the pole signs (for shift = k the
+      // function tends to -inf as tau -> 0+, for shift = k+1 to +inf as
+      // tau -> 0-). The endpoints are never evaluated.
+      RealScalar a0 = lo, b0 = hi;
+      bool converged = false;
+      for (int iter = 0; iter < maxBisect; ++iter) {
+        const RealScalar t = a0 + (b0 - a0) / RealScalar(2);
+        if (t == a0 || t == b0) {
+          converged = true;  // interval fully resolved
+          break;
+        }
+        if (secular(dsh, zeta2, rhoW, t) > RealScalar(0))
+          b0 = t;
+        else
+          a0 = t;
+      }
+      if (!converged) m_info = NoConvergence;
+      const RealScalar t = a0 + (b0 - a0) / RealScalar(2);
+      shiftIndex[static_cast<std::size_t>(k)] = shift;
+      tau[k] = t;
+      lam[k] = shiftVal + t;
+    }
+
+    // ---- Gu-Eisenstat weights: the z-vector for which lam are exact roots ----
+    // zhat_i^2 = prod_j (lam_j - delta_i) / (rho * prod_{j != i} (delta_j - delta_i)),
+    // with every distance lam_j - delta_i formed as (delta_shift(j) - delta_i) + tau_j.
+    // Numerator and denominator factors are paired so the running product stays O(1).
+    VectorType zhat(m);
+    for (Index i = 0; i < m; ++i) {
+      RealScalar acc = ((delta[shiftIndex[static_cast<std::size_t>(i)]] - delta[i]) + tau[i]) / rhoW;
+      for (Index j = 0; j < m; ++j) {
+        if (j == i) continue;
+        const RealScalar num = (delta[shiftIndex[static_cast<std::size_t>(j)]] - delta[i]) + tau[j];
+        acc *= num / (delta[j] - delta[i]);
+      }
+      zhat[i] = numext::abs(acc) > RealScalar(0) ? RealScalar(numext::sqrt(numext::abs(acc))) : RealScalar(0);
+      if (zeta[i] < RealScalar(0)) zhat[i] = -zhat[i];
+    }
+
+    // ---- secular eigenvectors from the Gu-Eisenstat weights ----
+    if (computeVectors) {
+      subVectors.resize(m, m);
+      for (Index j = 0; j < m; ++j) {
+        const Index sj = shiftIndex[static_cast<std::size_t>(j)];
+        if (tau[j] == RealScalar(0)) {
+          // The root coincides with its shift pole to working precision (a
+          // fully underflowed bracket): the eigenvector is that pole's axis.
+          subVectors.col(j).setZero();
+          subVectors(sj, j) = RealScalar(1);
+          continue;
+        }
+        // Divide by the pole distances delta_i - lam_j, each formed as
+        // (delta_i - delta_sj) - tau_j.
+        subVectors.col(j).array() = zhat.array() / ((delta.array() - delta[sj]) - tau[j]);
+        subVectors.col(j).stableNormalize();
+      }
+    }
+    for (Index k = 0; k < m; ++k) lambdaW[sub[static_cast<std::size_t>(k)]] = lam[k];
+  }
+
+  std::vector<Index> order;
+  order.reserve(static_cast<std::size_t>(n));
+  for (Index i = 0; i < n; ++i) order.push_back(i);
+  std::stable_sort(order.begin(), order.end(), [&lambdaW](Index a, Index b) { return lambdaW[a] < lambdaW[b]; });
+
+  std::vector<Index> subSlot(static_cast<std::size_t>(n), -1);
+  for (Index a = 0; a < m; ++a) subSlot[static_cast<std::size_t>(sub[static_cast<std::size_t>(a)])] = a;
+
+  for (Index t = 0; t < n; ++t) {
+    const Index w = order[static_cast<std::size_t>(t)];
+    const Index outCol = negated ? n - 1 - t : t;
+    m_eivalues[outCol] = negated ? -lambdaW[w] : lambdaW[w];
+    if (!computeVectors) continue;
+
+    VectorType wvec = VectorType::Zero(n);
+    const Index slot = subSlot[static_cast<std::size_t>(w)];
+    if (slot < 0) {
+      wvec[w] = RealScalar(1);
+    } else {
+      for (Index a = 0; a < m; ++a) wvec[sub[static_cast<std::size_t>(a)]] = subVectors(a, slot);
+    }
+    // w <- G*w with G = [[c, s], [-s, c]]: for exactly equal poles this maps the
+    // deflated unit vector e_p to (c, -s) = (z_i, -z_p)/r, the exact eigenvector
+    // of the 2x2 block orthogonal to the weight vector.
+    for (auto it = rotations.rbegin(); it != rotations.rend(); ++it) {
+      const RealScalar wi = wvec[it->i], wj = wvec[it->j];
+      wvec[it->i] = it->c * wi + it->s * wj;
+      wvec[it->j] = -it->s * wi + it->c * wj;
+    }
+    for (Index i = 0; i < n; ++i) m_eivec(pi[static_cast<std::size_t>(i)], outCol) = wvec[i];
+  }
+
+  // Undo the problem scaling in one full-range pass. ArrayBase::ldexp handles
+  // exponents for which 2^scaleExp is not itself representable, preserving
+  // representable results exactly and saturating genuine overflow to infinity
+  // (validated below).
+  if (scaleExp != 0) m_eivalues.array() = m_eivalues.array().ldexp(scaleExp);
+
+  // Range classification uses the original data. The normalized secular
+  // problem can round a root across the maximum-finite boundary before this
+  // rescaling, so finiteness of the rounded result alone is not evidence that
+  // the exact spectrum is (or is not) representable.
+  const Index extreme = negated ? 0 : n - 1;
+  const RealScalar highest = (std::numeric_limits<RealScalar>::max)();
+  if (spectrumRange == SpectrumRange::Overflow) {
+    m_eivalues.setConstant(NumTraits<RealScalar>::quiet_NaN());
+    m_info = InvalidInput;
+  } else {
+    // A proven boundary root and a root the rescaling saturated to infinity both belong at the
+    // largest finite value: the first is exactly it, the second rounded across it.
+    if (spectrumRange == SpectrumRange::ExactBoundary || !(numext::isfinite)(m_eivalues[extreme])) {
+      m_eivalues[extreme] = negated ? -highest : highest;
+    }
+    if (spectrumRange == SpectrumRange::Uncertain && m_info == Success) m_info = NoConvergence;
+    if (!m_eivalues.allFinite() && m_info == Success) m_info = NoConvergence;
+  }
+
+  m_vectorsComputed = computeVectors && m_info != InvalidInput;
+  m_isInitialized = true;
+  return *this;
+}
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_DPR1_EIGEN_SOLVER_H
diff --git a/contrib/Eigen/src/StructuredMatrices/DiagonalPlusLowRank.h b/contrib/Eigen/src/StructuredMatrices/DiagonalPlusLowRank.h
new file mode 100644
index 0000000..18df0a0
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/DiagonalPlusLowRank.h
@@ -0,0 +1,459 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] M. A. Woodbury, "Inverting Modified Matrices", Memorandum Report 42,
+//      Statistical Research Group, Princeton University, 1950. The Woodbury
+//      identity behind solve() and inverse().
+//  [2] W. W. Hager, "Updating the Inverse of a Matrix", SIAM Review, 31(2),
+//      pp. 221-239, 1989. Review of the Woodbury identity and of the matrix
+//      determinant lemma used by determinant().
+//  [3] J. J. Dongarra, J. R. Bunch, C. B. Moler and G. W. Stewart, "LINPACK
+//      Users' Guide", SIAM, 1979. determinant()'s balanced accumulation follows
+//      the convention of its xGEDI routines, which return determinants as a
+//      (fraction, exponent) pair to avoid spurious overflow/underflow.
+//  [4] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, the property the balanced
+//      accumulation and the normalized Woodbury products rely on.
+//  [5] N. J. Higham, "Accuracy and Stability of Numerical Algorithms", 2nd ed.,
+//      SIAM, 2002, chapter 27. Overflow-avoiding rescaling of intermediate
+//      quantities, the technique behind the normalized capacitance products.
+//  [6] E. L. Yip, "A Note on the Stability of Solving a Rank-p Modification of
+//      a Linear System by the Sherman-Morrison-Woodbury Formula", SIAM Journal
+//      on Scientific and Statistical Computing, 7(3), pp. 507-513, 1986. The
+//      accuracy limitation of the Woodbury solve noted on solve().
+
+#ifndef EIGEN_STRUCTURED_DIAGONAL_PLUS_LOW_RANK_H
+#define EIGEN_STRUCTURED_DIAGONAL_PLUS_LOW_RANK_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int Size_ = Dynamic, int Rank_ = Dynamic>
+class DiagonalPlusLowRank;
+
+namespace internal {
+
+template <typename Scalar_, int Size_, int Rank_>
+struct traits<DiagonalPlusLowRank<Scalar_, Size_, Rank_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = Size_;
+  static constexpr int ColsAtCompileTime = Size_;
+  static constexpr int MaxRowsAtCompileTime = Size_;
+  static constexpr int MaxColsAtCompileTime = Size_;
+  // Deliberately no NestByRefBit: transpose(), conjugate(), adjoint(), inverse()
+  // and makeDiagonalPlusLowRank() return owning temporaries, so Product must nest
+  // the operator by value for a delayed-evaluated product expression to keep its
+  // left factor alive. The copy is O(nk), on par with a single product evaluation.
+  static constexpr unsigned int Flags = 0;
+};
+
+template <typename Scalar_, int Size_, int Rank_>
+struct evaluator_traits<DiagonalPlusLowRank<Scalar_, Size_, Rank_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+// Entrywise multiplication by the exact power of two 2^e [4], for the factor normalization of the
+// Woodbury products [5]. Uses structured_balance_impl::apply_exponent (an ldexp per component) rather
+// than a multiplication by 2^e or by two half powers 2^(e/2): ldexp is exact and saturates entrywise
+// for every exponent, whereas 2^-eu itself overflows for a subnormal factor bound and a saturated
+// half power turns zero entries into NaN through 0 * Inf.
+template <typename Scalar>
+struct dplr_ldexp_op {
+  int e;
+  Scalar operator()(const Scalar& x) const { return structured_balance_impl<Scalar>::apply_exponent(x, e); }
+};
+
+// The smallest e with n <= 2^e: the inner-dimension term of a product's entry
+// magnitude bound (a length-n dot product of entries below 2^a and 2^b stays
+// below 2^(a + b + e)).
+inline int dplr_index_exponent(Index n) { return log2_ceil(static_cast<std::make_unsigned_t<Index>>(n)); }
+
+// True when a product of operands with entry-magnitude exponent bounds ea and eb over an inner
+// dimension of length \a inner provably cannot overflow, with one bit of headroom for a trailing
+// addition. Where it fails the Woodbury kernels rescale their factors exactly [4][5]; where it holds
+// they keep the plain association.
+template <typename RealScalar>
+bool dplr_product_fits(int ea, int eb, Index inner) {
+  return ea + eb + dplr_index_exponent(inner) + 1 < NumTraits<RealScalar>::max_exponent();
+}
+
+// Compile-time dispatch keeps fixed rank zero from instantiating a 0 x 0 LU;
+// C++14 cannot express this branch with if constexpr.
+template <int Rank_>
+struct dplr_capacitance_impl {
+  /** Applies the Woodbury correction
+   * \f[ x\mathrel{-}=D^{-1}U(I_k+V^H D^{-1}U)^{-1}V^Hx. \f]
+   * Exact power-of-two scaling is used only when either structural product can
+   * overflow [4][5], preserving the unscaled result bit-for-bit otherwise. */
+  template <typename Op, typename Dinv, typename Workspace>
+  static void subtractSolveCorrection(const Op& op, const Dinv& dinv, Workspace& x) {
+    using Scalar = typename Op::Scalar;
+    using RealScalar = typename Op::RealScalar;
+    if (op.correctionRank() == 0 || x.size() == 0) return;
+    PartialPivLU<typename Op::CapacitanceType> cap(op.capacitance());
+    const int eu = structured_exponent_bound(op.factorU());
+    const int ev = structured_exponent_bound(op.factorV());
+    const int ed = structured_exponent_bound(dinv);
+    const int ex = structured_exponent_bound(x);
+    if (dplr_product_fits<RealScalar>(ev, ex, op.rows()) && dplr_product_fits<RealScalar>(ed, eu, 1)) {
+      x.noalias() -= dinv.asDiagonal() * (op.factorU() * cap.solve(op.factorV().adjoint() * x));
+      return;
+    }
+    Matrix<Scalar, Rank_, Workspace::ColsAtCompileTime> y =
+        cap.solve(op.factorV().unaryExpr(dplr_ldexp_op<Scalar>{-ev}).adjoint() * x);
+    y = y.unaryExpr(dplr_ldexp_op<Scalar>{eu + ev});
+    x.noalias() -= dinv.asDiagonal() * (op.factorU().unaryExpr(dplr_ldexp_op<Scalar>{-eu}) * y);
+  }
+  /** Forms \f$U'=-D^{-1}U(I_k+V^HD^{-1}U)^{-1}\f$. Scaling prevents a
+   * spurious overflow in \f$D^{-1}U\f$ when the capacitance inverse subsequently
+   * shrinks it [4][5]. */
+  template <typename Op, typename Dinv, typename Factor>
+  static void inverseFactor(const Op& op, const Dinv& dinv, Factor& Up) {
+    using Scalar = typename Op::Scalar;
+    using RealScalar = typename Op::RealScalar;
+    if (op.correctionRank() == 0) return;
+    PartialPivLU<typename Op::CapacitanceType> cap(op.capacitance());
+    const typename Op::CapacitanceType K = cap.inverse();
+    const int eu = structured_exponent_bound(op.factorU());
+    const int ed = structured_exponent_bound(dinv);
+    const int ek = structured_exponent_bound(K);
+    if (dplr_product_fits<RealScalar>(ed, eu, 1) && dplr_product_fits<RealScalar>(ed + eu, ek, op.correctionRank())) {
+      Up.noalias() = -(dinv.asDiagonal() * op.factorU() * K);
+      return;
+    }
+    Up.noalias() = -(dinv.asDiagonal() * op.factorU().unaryExpr(dplr_ldexp_op<Scalar>{-eu}) * K);
+    Up = Up.unaryExpr(dplr_ldexp_op<Scalar>{eu});
+  }
+  /** Accumulates the determinant-lemma factor
+   * \f$\det(I_k+V^HD^{-1}U)\f$ as a mantissa and power of two. Each LU pivot is
+   * renormalized before multiplication because \f$\det(D)\f$ and the capacitance
+   * determinant can occupy opposite ends of the exponent range. */
+  template <typename Op>
+  static typename Op::Scalar balancedCapacitanceDeterminant(const Op& op, Index& exponent) {
+    using Scalar = typename Op::Scalar;
+    if (op.correctionRank() == 0) return Scalar(1);
+    const PartialPivLU<typename Op::CapacitanceType> lu(op.capacitance());
+    Scalar det(static_cast<typename Op::RealScalar>(lu.permutationP().determinant()));
+    for (Index i = 0; i < lu.matrixLU().rows(); ++i)
+      det = structured_balance(det * structured_balance(lu.matrixLU().coeff(i, i), exponent), exponent);
+    return det;
+  }
+};
+
+template <>
+struct dplr_capacitance_impl<0> {
+  template <typename Op, typename Dinv, typename Workspace>
+  static void subtractSolveCorrection(const Op&, const Dinv&, Workspace&) {}
+  template <typename Op, typename Dinv, typename Factor>
+  static void inverseFactor(const Op&, const Dinv&, Factor&) {}
+  template <typename Op>
+  static typename Op::Scalar balancedCapacitanceDeterminant(const Op&, Index&) {
+    return typename Op::Scalar(1);
+  }
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class DiagonalPlusLowRank
+ * \brief An \c n x \c n operator \f$ D + U V^H \f$: a diagonal matrix plus a
+ * rank-k correction, stored as its diagonal and the two \c n x \c k factors.
+ *
+ * Products cost O(nk) instead of O(n^2). Linear systems are solved in O(nk^2)
+ * through the Woodbury identity [1]
+ * \f$ (D + UV^H)^{-1} = D^{-1} - D^{-1} U (I_k + V^H D^{-1} U)^{-1} V^H D^{-1} \f$,
+ * factoring only the \c k x \c k \em capacitance matrix (\ref solve). The
+ * determinant follows from the matrix determinant lemma [2]
+ * \f$ \det(D)\,\det(I_k + V^H D^{-1} U) \f$ (\ref determinant), and the class is
+ * closed under \ref inverse, \ref transpose, \ref conjugate and \ref adjoint.
+ *
+ * The rank-k correction may have \c k = 0 (a plain diagonal operator). \c k is
+ * not required to be small, but every advantage over a dense matrix vanishes as
+ * \c k approaches \c n.
+ *
+ * The operator stores its own copies of the diagonal and the factors and derives
+ * from \c EigenBase. Because \c operator* returns an Eigen product expression, a
+ * \c DiagonalPlusLowRank also drops into the matrix-free iterative solvers, and
+ * it can be assigned to a dense matrix when an explicit representation is
+ * needed. As with any matrix-free operator, the iterative solvers must be
+ * instantiated with \c IdentityPreconditioner (e.g.
+ * \c GMRES<DiagonalPlusLowRank<double>,IdentityPreconditioner>): the default
+ * preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ * \tparam Size_ the dimension at compile time, or \c Dynamic (the default).
+ * \tparam Rank_ the correction rank at compile time, or \c Dynamic (the default).
+ *
+ * \sa makeDiagonalPlusLowRank()
+ */
+template <typename Scalar_, int Size_, int Rank_>
+class DiagonalPlusLowRank : public EigenBase<DiagonalPlusLowRank<Scalar_, Size_, Rank_>> {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using DiagonalVector = Matrix<Scalar, Size_, 1>;
+  using FactorType = Matrix<Scalar, Size_, Rank_>;
+  using CapacitanceType = Matrix<Scalar, Rank_, Rank_>;
+
+  static constexpr int RowsAtCompileTime = Size_;
+  static constexpr int ColsAtCompileTime = Size_;
+  static constexpr int MaxRowsAtCompileTime = Size_;
+  static constexpr int MaxColsAtCompileTime = Size_;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Size_, Size_);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const DiagonalPlusLowRank>'s default
+  // StrideType argument reads it, so its absence makes internal::is_ref_compatible
+  // SFINAE to false and keeps the iterative solvers on their matrix-free path.
+
+  /** Builds the operator \c diag(d) + \c U*V.adjoint(). The factors must have the
+   * same number of columns (the correction rank \c k, possibly zero) and as many
+   * rows as \a d has entries. */
+  template <typename DDerived, typename UDerived, typename VDerived>
+  DiagonalPlusLowRank(const MatrixBase<DDerived>& d, const MatrixBase<UDerived>& U, const MatrixBase<VDerived>& V)
+      : m_d(d), m_U(U), m_V(V) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(DDerived)
+    eigen_assert(m_d.size() > 0 && "DiagonalPlusLowRank must be non-empty");
+    eigen_assert(m_U.rows() == m_d.size() && m_V.rows() == m_d.size() && m_U.cols() == m_V.cols() &&
+                 "factor dimensions do not match");
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_d.size(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_d.size(); }
+  /** \returns the correction rank \c k. */
+  Index correctionRank() const { return m_U.cols(); }
+
+  /** \returns the diagonal vector \c d. */
+  const DiagonalVector& diagonal() const { return m_d; }
+  /** \returns the left factor \c U. */
+  const FactorType& factorU() const { return m_U; }
+  /** \returns the right factor \c V. */
+  const FactorType& factorV() const { return m_V; }
+
+  /** \returns the coefficient at row \a row and column \a col. */
+  Scalar coeff(Index row, Index col) const {
+    Scalar r = m_V.row(col).dot(m_U.row(row));  // dot() conjugates its first argument
+    if (row == col) r += m_d.coeff(row);
+    return r;
+  }
+
+  /** \returns the transpose of \c *this, itself a \c DiagonalPlusLowRank
+   * operator: \f$ (D + UV^H)^T = D + \bar V \bar U^H \f$. */
+  DiagonalPlusLowRank transpose() const { return DiagonalPlusLowRank(m_d, m_V.conjugate(), m_U.conjugate()); }
+
+  /** \returns the complex conjugate of \c *this, itself a \c DiagonalPlusLowRank
+   * operator. */
+  DiagonalPlusLowRank conjugate() const {
+    return DiagonalPlusLowRank(m_d.conjugate(), m_U.conjugate(), m_V.conjugate());
+  }
+
+  /** \returns the adjoint of \c *this, itself a \c DiagonalPlusLowRank operator:
+   * \f$ (D + UV^H)^H = \bar D + V U^H \f$. */
+  DiagonalPlusLowRank adjoint() const { return DiagonalPlusLowRank(m_d.conjugate(), m_V, m_U); }
+
+  /** \returns the capacitance matrix \f$ I_k + V^H D^{-1} U \f$ of the Woodbury
+   * identity. Every consumer of the triple product -- \ref solve, \ref inverse
+   * and \ref determinant -- forms it through this one method.
+   *
+   * With extreme factor magnitudes the plain association can overflow even
+   * though the capacitance itself is representable: for \c d = 1e-200,
+   * \c U = 1e-200, \c V = 1e200 the operator is essentially the identity and
+   * the capacitance \c 1 + 1e200 is representable, but \f$ V^H D^{-1} \f$ is
+   * \c 1e400. The factors are therefore rescaled by exact powers of two [4]
+   * when a conservative exponent bound detects the danger, the product is
+   * formed as \f$ \hat V^H (D^{-1} \hat U) \f$ -- whose intermediates are
+   * bounded by roughly \c n * max|1/d| -- and the removed exponent is folded
+   * back entrywise before the identity is added [5]. When the plain
+   * association provably cannot overflow it is kept, so results for moderate
+   * data are bit-identical to the unnormalized evaluation.
+   * \warning The diagonal must have no zero entries. */
+  CapacitanceType capacitance() const {
+    const Index k = correctionRank();
+    CapacitanceType c = CapacitanceType::Identity(k, k);
+    if (k == 0) return c;
+    const DiagonalVector dinv = m_d.cwiseInverse();
+    const int eu = internal::structured_exponent_bound(m_U);
+    const int ev = internal::structured_exponent_bound(m_V);
+    const int ed = internal::structured_exponent_bound(dinv);
+    if (internal::dplr_product_fits<RealScalar>(ev, ed, 1) &&
+        internal::dplr_product_fits<RealScalar>(ev + ed, eu, rows())) {
+      c.noalias() += m_V.adjoint() * dinv.asDiagonal() * m_U;
+      return c;
+    }
+    const FactorType W = dinv.asDiagonal() * m_U.unaryExpr(internal::dplr_ldexp_op<Scalar>{-eu});
+    CapacitanceType t(k, k);
+    t.noalias() = m_V.unaryExpr(internal::dplr_ldexp_op<Scalar>{-ev}).adjoint() * W;
+    t = t.unaryExpr(internal::dplr_ldexp_op<Scalar>{eu + ev});
+    c += t;
+    return c;
+  }
+
+  /** \returns the solution of \c (*this) * x = b through the Woodbury identity
+   * [1], factoring only the \c k x \c k capacitance matrix: O(nk^2 + k^3) setup
+   * and O(nk) per right-hand side. Supports multiple right-hand sides.
+   * \warning Requires an invertible diagonal \em and an invertible capacitance
+   * matrix (equivalently, an invertible operator); this is not checked beyond
+   * the NaN/Inf propagation of the arithmetic itself.
+   * \warning The Woodbury splitting routes the solution through \f$ D^{-1} b \f$:
+   * when \c max|1/d| greatly exceeds the norm of the operator's inverse, the
+   * correction cancels most of those amplified digits and the achievable
+   * accuracy degrades accordingly, even for a well-conditioned operator [6].
+   * The normalized kernels keep such solves finite; they cannot restore the
+   * cancelled digits. */
+  template <typename Rhs>
+  Matrix<Scalar, Size_, Rhs::ColsAtCompileTime> solve(const MatrixBase<Rhs>& b) const {
+    EIGEN_STATIC_ASSERT(RowsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(RowsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    eigen_assert(b.rows() == rows() && "right-hand side has the wrong number of rows");
+    const DiagonalVector dinv = m_d.cwiseInverse();
+    // D^{-1} b can overflow while the solution is representable: at d = 1e-200, b = 1e200 the operator
+    // is essentially the identity and x is 1e200, yet this term is 1e400. The solve is linear in b, so
+    // b is rescaled by an exact power of two [4] on the same exponent test the other kernels use and
+    // the exponent is folded back into the result [5]; the plain form is kept where it provably
+    // cannot overflow.
+    const int eb = internal::structured_exponent_bound(b.derived());
+    const int ed = internal::structured_exponent_bound(dinv);
+    const bool rescale = !internal::dplr_product_fits<RealScalar>(ed, eb, 1);
+
+    Matrix<Scalar, Size_, Rhs::ColsAtCompileTime> x =
+        rescale ? (dinv.asDiagonal() * b.derived().unaryExpr(internal::dplr_ldexp_op<Scalar>{-eb})).eval()
+                : (dinv.asDiagonal() * b).eval();
+    internal::dplr_capacitance_impl<Rank_>::subtractSolveCorrection(*this, dinv, x);
+    if (rescale) x = x.unaryExpr(internal::dplr_ldexp_op<Scalar>{eb});
+    return x;
+  }
+
+  /** \returns the inverse of \c *this, itself a \c DiagonalPlusLowRank operator:
+   * by the Woodbury identity [1], \f$ (D + UV^H)^{-1} = D^{-1} + U' V'^H \f$ with
+   * \f$ U' = -D^{-1} U (I_k + V^H D^{-1} U)^{-1} \f$ and \f$ V' = D^{-H} V \f$.
+   * \warning Same invertibility requirements as \ref solve. */
+  DiagonalPlusLowRank inverse() const {
+    const DiagonalVector dinv = m_d.cwiseInverse();
+    FactorType Up(rows(), correctionRank());
+    internal::dplr_capacitance_impl<Rank_>::inverseFactor(*this, dinv, Up);
+    FactorType Vp = dinv.conjugate().asDiagonal() * m_V;
+    return DiagonalPlusLowRank(dinv, Up, Vp);
+  }
+
+  /** \returns the determinant through the matrix determinant lemma [2]:
+   * \f$ \det(D)\,\det(I_k + V^H D^{-1} U) \f$, in O(nk^2 + k^3) operations.
+   * Both factors are accumulated in the balanced form \c m * 2^e (the split
+   * fraction/exponent determinant convention of LINPACK's xGEDI [3]) -- the
+   * diagonal entries and the LU pivots of the capacitance matrix are
+   * renormalized to unit magnitude one at a time, with the powers of two tracked
+   * in a shared exponent
+   * -- so no partial product, in particular neither ordinary determinant on its
+   * own, can overflow or underflow when the combined determinant is
+   * representable, whatever the ordering and magnitudes of the entries.
+   * Genuinely out-of-range determinants still saturate to (signed) zero or
+   * infinity.
+   * \warning The diagonal must have no zero entries (use the lemma symmetrically
+   * or a dense fallback for that case), and, as with \ref solve and \ref inverse,
+   * its reciprocals must be finite: a subnormal diagonal entry overflows
+   * \f$ D^{-1} \f$ -- and with it the capacitance entries -- to infinity. */
+  Scalar determinant() const {
+    Scalar det(1);
+    Index exponent = 0;
+    for (Index i = 0; i < rows(); ++i)
+      det = internal::structured_balance(det * internal::structured_balance(m_d.coeff(i), exponent), exponent);
+    const Scalar capDet = internal::dplr_capacitance_impl<Rank_>::balancedCapacitanceDeterminant(*this, exponent);
+    det = internal::structured_balance(det * capDet, exponent);
+    return internal::structured_ldexp_clamped(det, exponent);
+  }
+
+  /** \internal Writes the dense representation into \a dst. Invoked through
+   * \c dense = op; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    dst.noalias() = m_U * m_V.adjoint();
+    dst.diagonal() += m_d;
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    dst.noalias() += m_U * m_V.adjoint();
+    dst.diagonal() += m_d;
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    dst.noalias() -= m_U * m_V.adjoint();
+    dst.diagonal() -= m_d;
+  }
+
+  /** \returns the product expression \c (*this) * \a v, evaluated at O(nk)
+   * operations without forming the matrix. The expression carries the default
+   * product tag, so assigning it behaves like any dense product: a temporary
+   * resolves aliasing between the destination and \a v, and \c .noalias() skips
+   * it. */
+  template <typename Rhs>
+  Product<DiagonalPlusLowRank, Rhs> operator*(const MatrixBase<Rhs>& v) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(v.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<DiagonalPlusLowRank, Rhs>(*this, v.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs. \c ProductScalar is the
+   * promoted scalar of the product (complex when a real operator is applied to a
+   * complex right-hand side); the workspaces and the accumulation run in the
+   * promoted type. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    eigen_assert(rhs.rows() == rows() && "invalid product: dimensions do not match");
+    const Matrix<ProductScalar, Size_, Rhs::ColsAtCompileTime> r = rhs;
+    dst += alpha * (m_d.asDiagonal() * r);
+    if (correctionRank() > 0) {
+      const Matrix<ProductScalar, Rank_, Rhs::ColsAtCompileTime> t = m_V.adjoint() * r;
+      dst.noalias() += alpha * (m_U * t);
+    }
+  }
+
+ private:
+  DiagonalVector m_d;
+  FactorType m_U;
+  FactorType m_V;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref DiagonalPlusLowRank operator \c diag(d) + \c U*V.adjoint().
+ * The compile-time dimension and rank are deduced from the arguments. */
+template <typename DDerived, typename UDerived, typename VDerived>
+DiagonalPlusLowRank<typename DDerived::Scalar, DDerived::SizeAtCompileTime, UDerived::ColsAtCompileTime>
+makeDiagonalPlusLowRank(const MatrixBase<DDerived>& d, const MatrixBase<UDerived>& U, const MatrixBase<VDerived>& V) {
+  return DiagonalPlusLowRank<typename DDerived::Scalar, DDerived::SizeAtCompileTime, UDerived::ColsAtCompileTime>(d, U,
+                                                                                                                  V);
+}
+
+namespace internal {
+
+// Single product specialization covering every product tag; see the note in
+// Circulant.h.
+template <typename Scalar_, int Size_, int Rank_, typename Rhs, int ProductTag>
+struct generic_product_impl<DiagonalPlusLowRank<Scalar_, Size_, Rank_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<DiagonalPlusLowRank<Scalar_, Size_, Rank_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_DIAGONAL_PLUS_LOW_RANK_H
diff --git a/contrib/Eigen/src/StructuredMatrices/Hankel.h b/contrib/Eigen/src/StructuredMatrices/Hankel.h
new file mode 100644
index 0000000..22b9aaa
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/Hankel.h
@@ -0,0 +1,451 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] G. H. Golub and C. F. Van Loan, "Matrix Computations", 4th ed., Johns
+//      Hopkins University Press, 2013, chapter 4.7 (Toeplitz, Hankel and
+//      related systems) and chapter 4.8 (fast products via circulant embedding
+//      and the FFT).
+//  [2] R. H. Chan and X.-Q. Jin, "An Introduction to Iterative Toeplitz
+//      Solvers", SIAM, 2007 (a Hankel matrix is a column-reversed Toeplitz
+//      matrix, so its products and solves reduce to the Toeplitz machinery).
+
+#ifndef EIGEN_STRUCTURED_HANKEL_H
+#define EIGEN_STRUCTURED_HANKEL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int Rows_ = Dynamic, int Cols_ = Dynamic>
+class Hankel;
+
+namespace internal {
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct traits<Hankel<Scalar_, Rows_, Cols_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  // Deliberately no NestByRefBit: transpose(), conjugate() and adjoint() return
+  // owning temporaries, so Product must nest the operator by value for a
+  // delayed-evaluated product expression to keep its left factor alive. The copy
+  // is O(n), negligible against the O(n log n) product evaluation.
+  static constexpr unsigned int Flags = 0;
+};
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct evaluator_traits<Hankel<Scalar_, Rows_, Cols_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class Hankel
+ * \brief An \c m x \c n Hankel matrix represented by its first column and last row.
+ *
+ * A Hankel matrix has constant anti-diagonals: entry \c (i,j) equals \c h[i+j],
+ * where \c h is the length \c m+n-1 sequence formed by the first column followed
+ * by the tail of the last row. The overlap entry \c h[m-1] is taken from the
+ * column, so \c row[0] is ignored. Every column of the matrix is a contiguous
+ * slice of \c h. A real square Hankel matrix is symmetric.
+ *
+ * The matrix-vector product (\c operator*) is evaluated in O(n log n): a Hankel
+ * matrix is a column-reversed Toeplitz matrix, so the product is a circulant
+ * convolution of \c h with the reversed input, evaluated through a DFT symbol
+ * computed once at construction. (Small operators, and single-row or
+ * single-column ones -- whose products cost O(n) directly -- skip the FFT for a
+ * direct evaluation.) As with \ref Toeplitz, \c operator* returns an Eigen
+ * product expression, so a \c Hankel plugs into the matrix-free iterative
+ * solvers (including the least-squares solvers, through \ref adjoint), and it can
+ * be assigned to a dense matrix when an explicit representation is needed. As
+ * with any matrix-free operator, the iterative solvers must be instantiated with
+ * \c IdentityPreconditioner (e.g.
+ * \c LeastSquaresConjugateGradient<Hankel<double>,IdentityPreconditioner>):
+ * the default preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * The class is closed under \ref transpose, \ref conjugate and \ref adjoint. The
+ * transpose is the Hankel matrix of the same sequence with the dimensions
+ * swapped, and its symbol is obtained from the cached one by a diagonal phase
+ * multiplication instead of a new FFT.
+ *
+ * Square linear systems are solved directly in O(n^2) through the column-reversed
+ * \ref Toeplitz equivalent (\ref toToeplitz) and the \ref LookAheadLevinson
+ * solver, see \ref solve.
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ * \tparam Rows_ the number of rows at compile time, or \c Dynamic (the default).
+ * \tparam Cols_ the number of columns at compile time, or \c Dynamic (the default).
+ *
+ * \sa class Toeplitz, class Circulant, makeHankel()
+ */
+template <typename Scalar_, int Rows_, int Cols_>
+class Hankel : public EigenBase<Hankel<Scalar_, Rows_, Cols_>> {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using Complex = std::complex<RealScalar>;
+  using ColGeneratorType = Matrix<Scalar, Rows_, 1>;
+  using RowGeneratorType = Matrix<Scalar, Cols_, 1>;
+  using ComplexVector = Matrix<Complex, Dynamic, 1>;
+
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Rows_, Cols_);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const Hankel>'s default StrideType
+  // argument reads it, so its absence makes internal::is_ref_compatible SFINAE to
+  // false and keeps the iterative solvers on their matrix-free path.
+
+  /** \internal Compile-time length of the generating sequence h. */
+  static constexpr int GenSizeAtCompileTime = (Rows_ == Dynamic || Cols_ == Dynamic) ? Dynamic : (Rows_ + Cols_ - 1);
+  using GeneratorType = Matrix<Scalar, GenSizeAtCompileTime, 1>;
+
+  /** Builds a Hankel matrix from its first column \a col and last row \a row.
+   * The anti-diagonal overlap entry is taken from \a col, hence \c row[0] is
+   * ignored.
+   *
+   * Unless the matrix is small, or a single row or column (whose products are
+   * always evaluated directly, in linear time), the DFT symbol of the underlying
+   * circulant convolution is computed here, once, and reused by every subsequent
+   * product. */
+  template <typename ColDerived, typename RowDerived>
+  Hankel(const MatrixBase<ColDerived>& col, const MatrixBase<RowDerived>& row)
+      : m_rows(col.size()), m_cols(row.size()) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(ColDerived)
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(RowDerived)
+    const Index m = col.size(), n = row.size();
+    eigen_assert(m > 0 && n > 0 && "Hankel generators must be non-empty");
+    m_h.resize(m + n - 1);
+    m_h.head(m) = col;
+    if (n > 1) m_h.tail(n - 1) = row.tail(n - 1);
+    if (m > 1 && n > 1 && (m > internal::structured_direct_threshold() || n > internal::structured_direct_threshold()))
+      m_symbol = computeSymbol();
+    m_fftUsable = computeFftUsable();
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_rows.value(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_cols.value(); }
+
+  /** \returns the generating sequence \c h of length \c m+n-1; entry \c (i,j) of
+   * the matrix is \c h[i+j]. */
+  const GeneratorType& generator() const { return m_h; }
+
+  /** \returns the first column, \c h[0..m-1]. */
+  ColGeneratorType column() const { return m_h.head(rows()); }
+
+  /** \returns the last row, \c h[m-1..m+n-2]. */
+  RowGeneratorType lastRow() const { return m_h.segment(rows() - 1, cols()); }
+
+  /** \returns the symbol of the underlying circulant convolution: the DFT of the
+   * generating sequence, zero-padded to a 5-smooth size p >= m+n-1 and rotated so
+   * the product appears in the leading \c m entries of the back-transform. Cached
+   * when the operator is large enough for products to take the FFT path, computed
+   * on the fly for small operators. */
+  ComplexVector symbol() const { return m_symbol.size() > 0 ? m_symbol : computeSymbol(); }
+
+  /** \returns the coefficient at row \a row and column \a col. */
+  Scalar coeff(Index row, Index col) const { return m_h.coeff(row + col); }
+
+  /** \returns the transpose of \c *this, itself a Hankel operator: the same
+   * generating sequence with the dimensions swapped. The cached symbol, when
+   * present, is reused: transposing changes the rotation of the embedding from
+   * \c n-1 to \c m-1, which multiplies DFT entry \c f by \c exp(2 pi i f (m-n)/p)
+   * -- a diagonal phase multiplication instead of a new FFT. */
+  Hankel<Scalar, Cols_, Rows_> transpose() const {
+    return Hankel<Scalar, Cols_, Rows_>(m_h, cols(), rows(), transposedSymbol());
+  }
+
+  /** \returns the complex conjugate of \c *this, itself a Hankel operator. The
+   * cached symbol, when present, is reused: the symbol of the conjugate is the
+   * conjugated index reversal of the symbol. */
+  Hankel conjugate() const {
+    return Hankel(m_h.conjugate(), rows(), cols(), internal::structured_reverse_symbol(m_symbol).conjugate());
+  }
+
+  /** \returns the adjoint of \c *this, itself a Hankel operator (the conjugated
+   * transpose); the cached symbol is reused through the composition of the
+   * \ref conjugate and \ref transpose rules. */
+  Hankel<Scalar, Cols_, Rows_> adjoint() const { return conjugate().transpose(); }
+
+  /** \returns the column-reversed \ref Toeplitz equivalent \c T = H*E (with \c E
+   * the exchange matrix), i.e. \c T(i,j) = h[i + n-1 - j]. Its symbol is computed
+   * afresh. Useful for solving Hankel systems with the Toeplitz machinery:
+   * \c H*x = b is \c T*(E*x) = b. */
+  Toeplitz<Scalar, Rows_, Cols_> toToeplitz() const {
+    ColGeneratorType c = m_h.segment(cols() - 1, rows());
+    RowGeneratorType r = m_h.head(cols()).reverse();
+    return Toeplitz<Scalar, Rows_, Cols_>(c, r);
+  }
+
+  /** \internal Compile-time row count of solve() results: the solution of a
+   * square system has cols() == rows() entries, so either fixed dimension
+   * determines it at compile time. */
+  static constexpr int SolveRowsAtCompileTime = Cols_ != Dynamic ? Cols_ : Rows_;
+
+  /** \returns the solution \c x of \c (*this) * x = b for a \b square Hankel
+   * matrix, computed in O(n^2) by solving the column-reversed Toeplitz system
+   * \c T*y = b with the \ref LookAheadLevinson solver and reversing the solution.
+   * Supports multiple right-hand sides. Each call factorizes anew; to reuse a
+   * factorization across calls, or to check for numerical breakdown through
+   * \c info(), use \c LookAheadLevinson on \ref toToeplitz directly and reverse
+   * the solution rows. */
+  template <typename Rhs>
+  Matrix<Scalar, SolveRowsAtCompileTime, Rhs::ColsAtCompileTime> solve(const MatrixBase<Rhs>& b) const {
+    EIGEN_STATIC_ASSERT(RowsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(RowsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    eigen_assert(rows() == cols() && "Hankel::solve requires a square matrix");
+    eigen_assert(b.rows() == rows() && "right-hand side has the wrong number of rows");
+    LookAheadLevinson<Scalar> levinson(toToeplitz());
+    eigen_assert(levinson.info() == Success &&
+                 "Hankel::solve: the Levinson recursion broke down; "
+                 "use LookAheadLevinson on toToeplitz() for diagnostics");
+    return levinson.solve(b).colwise().reverse();
+  }
+
+  /** \internal Writes the dense representation into \a dst; column \c j is the
+   * contiguous slice \c h[j..j+m-1]. Row-major destinations copy the contiguous
+   * slice \c h[i..i+n-1] into row i. Invoked through \c dense = hankel; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < rows(); ++i) dst.row(i) = m_h.segment(i, cols()).transpose();
+      return;
+    }
+    for (Index j = 0; j < cols(); ++j) dst.col(j) = m_h.segment(j, rows());
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < rows(); ++i) dst.row(i) += m_h.segment(i, cols()).transpose();
+      return;
+    }
+    for (Index j = 0; j < cols(); ++j) dst.col(j) += m_h.segment(j, rows());
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < rows(); ++i) dst.row(i) -= m_h.segment(i, cols()).transpose();
+      return;
+    }
+    for (Index j = 0; j < cols(); ++j) dst.col(j) -= m_h.segment(j, rows());
+  }
+
+  /** \returns the product expression \c (*this) * \a x, evaluated through a fast
+   * FFT-based matrix-vector product. The expression carries the default product
+   * tag, so assigning it behaves like any dense product: a temporary resolves
+   * aliasing between the destination and \a x, and \c .noalias() skips it. */
+  template <typename Rhs>
+  Product<Hankel, Rhs> operator*(const MatrixBase<Rhs>& x) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(x.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<Hankel, Rhs>(*this, x.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs. \c ProductScalar is the
+   * promoted scalar of the product (complex when a real operator is applied to a
+   * complex right-hand side); the accumulation runs in the promoted type.
+   *
+   * The FFT path evaluates the circular convolution
+   * \f[ (Hx)_i = \sum_{j=0}^{n-1} h_{i+j} x_j. \f]
+   * Reversing \f$x\f$ and rotating the padded symbol by \f$n-1\f$ places these
+   * entries at the start of the inverse transform.
+   *
+   * Non-finite data takes the direct kernels: the transforms would smear a
+   * single Inf/NaN into NaNs across the whole output, where the dense product
+   * only propagates it through the dot products that touch it. A non-finite
+   * generating sequence or cached symbol (which can overflow even for a finite
+   * sequence) routes the whole product; a non-finite right-hand-side column is
+   * detected inside the FFT loop -- in the same pass that derives its scaling
+   * exponent, so finite data pays no extra scan -- and falls back per column. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    const Index m = rows(), n = cols();
+    eigen_assert(rhs.rows() == n && "invalid product: dimensions do not match");
+    const bool small = m == 1 || n == 1 ||
+                       (m <= internal::structured_direct_threshold() && n <= internal::structured_direct_threshold());
+    if (small || !m_fftUsable) {
+      directProduct(dst, rhs, alpha);
+      return;
+    }
+    // Reversal preserves which right-hand-side columns need the direct fallback.
+    internal::structured_fft_apply(dst, m_symbol, m, rhs.colwise().reverse(), alpha,
+                                   [&](Index k) { directProductColumn(dst, rhs, k, alpha); });
+  }
+
+ private:
+  template <typename OtherScalar, int OtherRows, int OtherCols>
+  friend class Hankel;
+
+  /** \internal Builds an operator from the generating sequence and an
+   * already-known symbol (empty for small operators), skipping the FFT of the
+   * public constructor. Used by transpose(), conjugate() and adjoint(), whose
+   * symbols are cheap transformations of the existing one. */
+  Hankel(const GeneratorType& h, Index rows, Index cols, const ComplexVector& symbol)
+      : m_rows(rows), m_cols(cols), m_h(h), m_symbol(symbol), m_fftUsable(computeFftUsable()) {}
+
+  /** \internal Whether products may take the FFT path: the generating sequence
+   * and the cached symbol must be finite. The symbol accumulates up to p addends,
+   * so it can overflow to Inf even for a finite sequence; such operators fall
+   * back to the direct kernels, which stay exact. */
+  bool computeFftUsable() const { return m_h.allFinite() && (m_symbol.size() == 0 || m_symbol.allFinite()); }
+
+  /** \internal Direct kernel for column \a k of the right-hand side: computes
+   * \c dst.col(k) += alpha * (*this) * rhs.col(k) without transforms. Serves
+   * operators below the FFT threshold, single-row and single-column operators
+   * (whose products cost O(n) directly, however large the operator), and any
+   * column involving non-finite data, whose entrywise IEEE semantics the
+   * transforms cannot preserve. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProductColumn(Dest& dst, const Rhs& rhs, Index k, const ProductScalar& alpha) const {
+    const Index m = rows(), n = cols();
+    // A unit alpha must not multiply: even the identity complex scalar (1,0)
+    // pollutes an (Inf,0) value with NaN through the 0*Inf cross term.
+    const bool unitAlpha = alpha == ProductScalar(1);
+
+    if (n == 1) {
+      // The runtime-sized head keeps other fixed-size shapes well-formed.
+      const ProductScalar xj = unitAlpha ? ProductScalar(rhs.coeff(0, k)) : ProductScalar(alpha * rhs.coeff(0, k));
+      dst.col(k) += xj * m_h.head(m);
+      return;
+    }
+
+    if (m == 1) {
+      const ProductScalar acc = m_h.head(n).cwiseProduct(rhs.col(k)).sum();
+      dst.coeffRef(0, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
+      return;
+    }
+
+    if (m <= internal::structured_scalar_threshold() && n <= internal::structured_scalar_threshold()) {
+      // Tiny sizes: a plain scalar loop beats the segment-based path below, whose
+      // per-segment setup dominates when segments hold only a few entries.
+      for (Index i = 0; i < m; ++i) {
+        ProductScalar acc(0);
+        for (Index j = 0; j < n; ++j) acc += coeff(i, j) * rhs.coeff(j, k);
+        dst.coeffRef(i, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
+      }
+      return;
+    }
+
+    // Column j is the contiguous, vectorizable slice h[j..j+m-1].
+    auto dstCol = dst.col(k);
+    for (Index j = 0; j < n; ++j) {
+      const ProductScalar xj = unitAlpha ? ProductScalar(rhs.coeff(j, k)) : ProductScalar(alpha * rhs.coeff(j, k));
+      dstCol += xj * m_h.segment(j, m);
+    }
+  }
+
+  /** \internal Direct product kernel over every column, see
+   * directProductColumn(). */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    for (Index k = 0; k < rhs.cols(); ++k) directProductColumn(dst, rhs, k, alpha);
+  }
+
+  /** \internal \returns the DFT of the generating sequence, zero-padded to the
+   * 5-smooth size p >= m+n-1 and rotated left by n-1 so that the convolution
+   * against a reversed input lands the product in the leading m entries. */
+  ComplexVector computeSymbol() const {
+    const Index m = rows(), n = cols();
+    const Index p = internal::fft_next_good_size(m + n - 1);
+    ComplexVector embedding = ComplexVector::Zero(p);
+    embedding.head(m) = m_h.tail(m).template cast<Complex>();  // h[n-1 .. m+n-2]
+    embedding.tail(n - 1) = m_h.head(n - 1).template cast<Complex>();
+    if (p == 1) return embedding;  // the DFT of a single sample is the identity
+    ComplexVector symbol(p);
+    auto&& fft = internal::structured_fft_engine<RealScalar>();
+    fft.fwd(symbol, embedding, p);
+    return symbol;
+  }
+
+  /** \internal \returns the symbol of the transposed operator: the embedding
+   * rotation changes from n-1 to m-1, which by the DFT shift theorem multiplies
+   * entry f by exp(2 pi i f (m-n) / p). The frequency-shift product f*(m-n) is
+   * accumulated incrementally modulo p, so the angle stays O(2 pi) at full
+   * accuracy and no Index overflow can occur. An empty symbol stays empty. */
+  ComplexVector transposedSymbol() const {
+    ComplexVector sym = m_symbol;
+    const Index p = sym.size();
+    if (p > 0 && rows() != cols()) {
+      Index s = (rows() - cols()) % p;
+      if (s < 0) s += p;
+      // Contiguous real buffers let sin/cos use packets; complex component views
+      // alone have stride two and would force scalar trigonometric evaluation.
+      Array<RealScalar, 64, 1> angles, values;
+      Matrix<Complex, 64, 1> phases;
+      Index fs = 0;  // f * s mod p
+      for (Index f = 0; f < p;) {
+        const Index count = numext::mini<Index>(64, p - f);
+        for (Index i = 0; i < count; ++i) {
+          angles[i] = RealScalar(2 * EIGEN_PI) * RealScalar(fs) / RealScalar(p);
+          fs += s;
+          if (fs >= p) fs -= p;
+        }
+        values.head(count) = angles.head(count).cos();
+        phases.head(count).real() = values.head(count);
+        values.head(count) = angles.head(count).sin();
+        phases.head(count).imag() = values.head(count);
+        sym.segment(f, count).array() *= phases.head(count).array();
+        f += count;
+      }
+    }
+    return sym;
+  }
+
+  // Empty (compile-time constant) when the corresponding dimension is fixed; the
+  // dimensions cannot be recovered from m_h alone, whose length is rows()+cols()-1.
+  internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
+  internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
+  GeneratorType m_h;
+  ComplexVector m_symbol;
+  bool m_fftUsable;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref Hankel operator with first column \a col and last row \a row.
+ * The compile-time dimensions of the operator are deduced from the generators. */
+template <typename ColDerived, typename RowDerived>
+Hankel<typename ColDerived::Scalar, ColDerived::SizeAtCompileTime, RowDerived::SizeAtCompileTime> makeHankel(
+    const MatrixBase<ColDerived>& col, const MatrixBase<RowDerived>& row) {
+  return Hankel<typename ColDerived::Scalar, ColDerived::SizeAtCompileTime, RowDerived::SizeAtCompileTime>(col, row);
+}
+
+namespace internal {
+
+// Single product specialization covering every product tag; see the note in
+// Circulant.h.
+template <typename Scalar_, int Rows_, int Cols_, typename Rhs, int ProductTag>
+struct generic_product_impl<Hankel<Scalar_, Rows_, Cols_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<Hankel<Scalar_, Rows_, Cols_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_HANKEL_H
diff --git a/contrib/Eigen/src/StructuredMatrices/InternalHeaderCheck.h b/contrib/Eigen/src/StructuredMatrices/InternalHeaderCheck.h
new file mode 100644
index 0000000..038f608
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_STRUCTURED_MATRICES_MODULE_H
+#error "Please include contrib/Eigen/StructuredMatrices instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/StructuredMatrices/KroneckerOperator.h b/contrib/Eigen/src/StructuredMatrices/KroneckerOperator.h
new file mode 100644
index 0000000..964e280
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/KroneckerOperator.h
@@ -0,0 +1,1146 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] C. F. Van Loan, "The ubiquitous Kronecker product", Journal of
+//      Computational and Applied Mathematics 123 (2000), 85-100. The vec
+//      identity driving every product and solve below -- stated there as
+//      Y = C X B^T <=> vec(Y) = (B (x) C) vec(X), i.e. with this file's
+//      operand naming (A (x) B) vec(X) = vec(B X A^T) -- together with the
+//      factor-wise identities for the inverse, pseudo-inverse,
+//      eigendecomposition, SVD and determinant of a Kronecker product.
+//  [2] N. J. Higham, "Accuracy and Stability of Numerical Algorithms", 2nd ed.,
+//      SIAM, 2002, chapter 27. Avoiding spurious overflow by rescaling with
+//      powers of two, the technique behind the scaled vec-trick products, the
+//      normalized-frame solves, the exponent-split pseudo-inversion and the
+//      exponent-balanced determinant.
+//  [3] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, the property every rescaling in this
+//      file relies on.
+
+#ifndef EIGEN_STRUCTURED_KRONECKER_OPERATOR_H
+#define EIGEN_STRUCTURED_KRONECKER_OPERATOR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename LhsMatrix, typename RhsMatrix>
+class KroneckerOperator;
+
+namespace internal {
+
+template <typename LhsMatrix, typename RhsMatrix>
+struct traits<KroneckerOperator<LhsMatrix, RhsMatrix>> {
+  using Scalar = typename LhsMatrix::Scalar;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  // size_at_compile_time is the compile-time dimension product, Dynamic when a
+  // factor is unknown or the product would overflow int.
+  static constexpr int RowsAtCompileTime =
+      size_at_compile_time(traits<LhsMatrix>::RowsAtCompileTime, traits<RhsMatrix>::RowsAtCompileTime);
+  static constexpr int ColsAtCompileTime =
+      size_at_compile_time(traits<LhsMatrix>::ColsAtCompileTime, traits<RhsMatrix>::ColsAtCompileTime);
+  static constexpr int MaxRowsAtCompileTime = RowsAtCompileTime;
+  static constexpr int MaxColsAtCompileTime = ColsAtCompileTime;
+  // Deliberately no NestByRefBit: transpose(), conjugate(), adjoint(), inverse(),
+  // eigenvectors(), matrixU() and matrixV() return owning temporaries (the
+  // operator stores its factors by value), so Product must nest the operator by
+  // value for a delayed-evaluated product expression to keep its left factor
+  // alive. The copy is O(m1 n1 + m2 n2), negligible against the product
+  // evaluation.
+  static constexpr int Flags = 0;
+};
+
+template <typename LhsMatrix, typename RhsMatrix>
+struct evaluator_traits<KroneckerOperator<LhsMatrix, RhsMatrix>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+// Three factor kinds -- dense, diagonal, sparse -- with every kind-specific
+// operation in the kron_factor_* helpers below, so the operator has a single
+// implementation. Diagonal: stored as its diagonal, applied as a scaling, solved
+// entrywise, closed under transposition, inverse and determinant. Sparse: stored
+// compressed, applied by sparse-dense products, solved via SparseLU; inverse dense.
+
+template <typename Factor>
+struct kron_factor_is_diagonal : std::false_type {};
+template <typename Scalar, int Size, int MaxSize>
+struct kron_factor_is_diagonal<DiagonalMatrix<Scalar, Size, MaxSize>> : std::true_type {};
+
+template <typename Factor>
+struct kron_factor_is_dense_matrix : std::false_type {};
+template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
+struct kron_factor_is_dense_matrix<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> : std::true_type {};
+
+template <typename Factor>
+struct kron_factor_is_sparse_matrix : std::false_type {};
+template <typename Scalar, int Options, typename StorageIndex>
+struct kron_factor_is_sparse_matrix<SparseMatrix<Scalar, Options, StorageIndex>> : std::true_type {};
+
+// The factor kind, the dispatch key of kron_factor_ops and kron_factor_solver.
+constexpr int kKronDenseFactor = 0;
+constexpr int kKronDiagonalFactor = 1;
+constexpr int kKronSparseFactor = 2;
+
+template <typename Factor>
+constexpr int kron_factor_kind() {
+  return kron_factor_is_diagonal<Factor>::value        ? kKronDiagonalFactor
+         : kron_factor_is_sparse_matrix<Factor>::value ? kKronSparseFactor
+                                                       : kKronDenseFactor;
+}
+
+// Apply 2^e without forming a possibly unrepresentable scale factor. For
+// std::complex storage, realView exposes both components to the real ldexp packets.
+template <typename Xpr, std::enable_if_t<!NumTraits<typename Xpr::Scalar>::IsComplex, bool> = true>
+void kron_ldexp_entries(Xpr& M, int e) {
+  M.array() = M.array().ldexp(e);
+}
+
+template <typename Xpr, std::enable_if_t<complex_array_access<typename Xpr::Scalar>::value, bool> = true>
+void kron_ldexp_entries(Xpr& M, int e) {
+  M.realView().array() = M.realView().array().ldexp(e);
+}
+
+template <typename Xpr, std::enable_if_t<NumTraits<typename Xpr::Scalar>::IsComplex &&
+                                             !complex_array_access<typename Xpr::Scalar>::value,
+                                         bool> = true>
+void kron_ldexp_entries(Xpr& M, int e) {
+  using Scalar = typename Xpr::Scalar;
+  M = M.unaryExpr([e](const Scalar& z) { return structured_ldexp_clamped(z, Index(e)); });
+}
+
+template <typename Factor, int Kind = kron_factor_kind<Factor>()>
+struct kron_factor_ops {
+  // Dense factor.
+  using Scalar = typename Factor::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using TransposedFactor = Matrix<Scalar, Factor::ColsAtCompileTime, Factor::RowsAtCompileTime>;
+  using InverseFactor = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  // Every entry is stored: a materialization has no structurally zero blocks
+  // to clear, and forEachNonZero visits all m*n entries in column-major order.
+  static constexpr bool StoresAllEntries = true;
+
+  static void prepare(Factor&) {}
+  static bool coeffIfStored(const Factor& f, Index row, Index col, Scalar& value) {
+    value = f.coeff(row, col);
+    return true;
+  }
+  template <typename Visitor>
+  static void forEachNonZero(const Factor& f, Visitor&& visit) {
+    for (Index j = 0; j < f.cols(); ++j)
+      for (Index i = 0; i < f.rows(); ++i) visit(i, j, f.coeff(i, j));
+  }
+  /** \internal \returns the number of stored entries of each inner vector, for a
+   * destination of the storage order selected by \a rowMajor. */
+  static Matrix<Index, Dynamic, 1> innerNonZeros(const Factor& f, bool rowMajor) {
+    return Matrix<Index, Dynamic, 1>::Constant(rowMajor ? f.rows() : f.cols(), rowMajor ? f.cols() : f.rows());
+  }
+  static auto transposed(const Factor& f) { return f.transpose(); }
+  static auto conjugated(const Factor& f) { return f.conjugate(); }
+  static auto adjointed(const Factor& f) { return f.adjoint(); }
+  static auto inversed(const Factor& f) { return f.inverse(); }
+  // The factor as a dense expression, for the decomposition family.
+  static const Factor& denseFactor(const Factor& f) { return f; }
+  // The right operand op(F) of the vec-trick product Y = B X op(A): the
+  // transpose for a dense factor, the factor itself for a diagonal one.
+  static auto transposedOperand(const Factor& f) { return f.transpose(); }
+  static bool allFinite(const Factor& f) { return f.allFinite(); }
+  static int exponentBound(const Factor& f) { return structured_exponent_bound(f); }
+  /** \internal \returns the dot-product growth bits of a product contracting
+   * over \a n entries of this factor. Cast to an unsigned type deliberately:
+   * the generic count_bits_impl fallback static_asserts on unsignedness, and
+   * only the GCC/Clang and MSVC specialisations accept a signed Index. */
+  static int growthBits(Index n) { return log2_floor(static_cast<numext::uint64_t>(n)) + 1; }
+  /** \internal \returns the mantissa of \c det(M) in the balanced form
+   * \c m * 2^e, adding \c e into \a exponent: the determinant is accumulated
+   * directly from the LU diagonal (times the permutation sign), each entry and
+   * the running product renormalized by \c structured_balance. */
+  static Scalar balancedDet(const Factor& M, Index& exponent) {
+    PartialPivLU<Factor> lu(M);
+    Scalar m = Scalar(RealScalar(lu.permutationP().determinant()));  // +-1
+    for (Index i = 0; i < M.rows(); ++i)
+      m = structured_balance(m * structured_balance(lu.matrixLU().coeff(i, i), exponent), exponent);
+    return m;
+  }
+};
+
+template <typename Factor>
+struct kron_factor_ops<Factor, kKronDiagonalFactor> {
+  // Diagonal factor: everything runs on the stored diagonal vector.
+  using Scalar = typename Factor::Scalar;
+  using TransposedFactor = typename Factor::PlainObject;  // a diagonal matrix is its own transpose
+  using InverseFactor = typename Factor::PlainObject;     // entrywise reciprocals stay diagonal
+  static constexpr bool StoresAllEntries = false;
+
+  static void prepare(Factor&) {}
+  static bool coeffIfStored(const Factor& f, Index row, Index col, Scalar& value) {
+    if (row != col) return false;
+    value = f.diagonal().coeff(row);
+    return true;
+  }
+  template <typename Visitor>
+  static void forEachNonZero(const Factor& f, Visitor&& visit) {
+    for (Index k = 0; k < f.rows(); ++k) visit(k, k, f.diagonal().coeff(k));
+  }
+  static Matrix<Index, Dynamic, 1> innerNonZeros(const Factor& f, bool) {
+    return Matrix<Index, Dynamic, 1>::Ones(f.rows());
+  }
+  static const Factor& transposed(const Factor& f) { return f; }
+  static auto conjugated(const Factor& f) { return f.diagonal().conjugate().asDiagonal(); }
+  static auto adjointed(const Factor& f) { return f.diagonal().conjugate().asDiagonal(); }
+  static auto inversed(const Factor& f) { return f.inverse(); }
+  static typename Factor::DenseMatrixType denseFactor(const Factor& f) { return f.toDenseMatrix(); }
+  static const Factor& transposedOperand(const Factor& f) { return f; }
+  static bool allFinite(const Factor& f) { return f.diagonal().allFinite(); }
+  static int exponentBound(const Factor& f) { return structured_exponent_bound(f.diagonal()); }
+  // A diagonal product has no accumulation, hence no dot-product growth.
+  static int growthBits(Index) { return 0; }
+  static Scalar balancedDet(const Factor& D, Index& exponent) {
+    Scalar m(1);
+    for (Index i = 0; i < D.rows(); ++i)
+      m = structured_balance(m * structured_balance(D.diagonal().coeff(i), exponent), exponent);
+    return m;
+  }
+};
+
+/** \internal SparseLU extended with the balanced determinant of the dense path:
+ * the U diagonal -- stored on the diagonal of the supernodal L, where
+ * SparseLU::determinant() reads it -- times the permutation signs, each entry
+ * and the running product renormalized by structured_balance. */
+template <typename SparseType>
+class kron_sparse_lu : public SparseLU<SparseType> {
+ public:
+  using Base = SparseLU<SparseType>;
+  using Scalar = typename SparseType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Scalar balancedDet(Index& exponent) const {
+    eigen_assert(Base::info() == Success);
+    Scalar m = Scalar(RealScalar(Base::m_detPermR * Base::m_detPermC));
+    for (Index j = 0; j < Base::cols(); ++j) {
+      typename Base::SCMatrix::InnerIterator it(Base::m_Lstore, j);
+      while (it && it.index() != j) ++it;
+      if (it) m = structured_balance(m * structured_balance(it.value(), exponent), exponent);
+    }
+    return m;
+  }
+};
+
+template <typename Factor>
+struct kron_factor_ops<Factor, kKronSparseFactor> {
+  // Sparse factor: the products run through the sparse-dense kernels, the
+  // solve and the determinant through a SparseLU factorization.
+  using Scalar = typename Factor::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using ColMajorFactor = SparseMatrix<Scalar, ColMajor, typename Factor::StorageIndex>;
+  using TransposedFactor = Factor;  // the transpose is stored sparse, in the same storage order
+  using InverseFactor = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;  // dense in general
+  static constexpr bool StoresAllEntries = false;
+
+  // coeffs() below reads the compressed value array.
+  static void prepare(Factor& f) { f.makeCompressed(); }
+  static bool coeffIfStored(const Factor& f, Index row, Index col, Scalar& value) {
+    const Index outer = Factor::IsRowMajor ? row : col;
+    const Index inner = Factor::IsRowMajor ? col : row;
+    const Index start = f.outerIndexPtr()[outer], end = f.outerIndexPtr()[outer + 1];
+    if (start == end) return false;
+    const Index position = f.data().searchLowerIndex(start, end, inner);
+    if (position == end || f.innerIndexPtr()[position] != inner) return false;
+    value = f.valuePtr()[position];
+    return true;
+  }
+  template <typename Visitor>
+  static void forEachNonZero(const Factor& f, Visitor&& visit) {
+    for (Index k = 0; k < f.outerSize(); ++k)
+      for (typename Factor::InnerIterator it(f, k); it; ++it) visit(it.row(), it.col(), it.value());
+  }
+  static Matrix<Index, Dynamic, 1> innerNonZeros(const Factor& f, bool rowMajor) {
+    Matrix<Index, Dynamic, 1> counts = Matrix<Index, Dynamic, 1>::Zero(rowMajor ? f.rows() : f.cols());
+    for (Index k = 0; k < f.outerSize(); ++k)
+      for (typename Factor::InnerIterator it(f, k); it; ++it) ++counts[rowMajor ? it.row() : it.col()];
+    return counts;
+  }
+  static auto transposed(const Factor& f) { return f.transpose(); }
+  static auto conjugated(const Factor& f) { return f.conjugate(); }
+  static auto adjointed(const Factor& f) { return f.adjoint(); }
+  /** \internal \returns the dense inverse, one SparseLU solve against the
+   * identity: O(n^2) storage and n substitutions; NaN when the factorization
+   * fails, see nanMatrix(). */
+  static InverseFactor inversed(const Factor& f) {
+    const ColMajorFactor colMajor(f);
+    SparseLU<ColMajorFactor> lu(colMajor);
+    if (lu.info() != Success) return nanMatrix(f.rows(), f.cols());
+    return lu.solve(InverseFactor::Identity(f.rows(), f.cols()));
+  }
+  /** \internal SparseLU aborts on an exactly zero or non-finite pivot column
+   * and leaves no usable factors, so such a factor solves and inverts to NaN:
+   * the sparse counterpart of the Inf/NaN a dense LU substitutes through. */
+  static InverseFactor nanMatrix(Index rows, Index cols) {
+    return InverseFactor::Constant(rows, cols, Scalar(NumTraits<RealScalar>::quiet_NaN()));
+  }
+  static InverseFactor denseFactor(const Factor& f) { return InverseFactor(f); }
+  static auto transposedOperand(const Factor& f) { return f.transpose(); }
+  static bool allFinite(const Factor& f) { return f.coeffs().allFinite(); }
+  static int exponentBound(const Factor& f) { return structured_exponent_bound(f.coeffs()); }
+  // The dense contraction bound: a row holds at most n stored entries.
+  static int growthBits(Index n) { return log2_floor(static_cast<numext::uint64_t>(n)) + 1; }
+  static Scalar balancedDet(const Factor& M, Index& exponent) {
+    // Scale small factors up, exactly, so that the elimination runs on normal
+    // numbers: a subnormal near 2^e carries only e - min_exponent + digits bits.
+    // Scaling down could erase small pivots in factors with a wide exponent range.
+    const int scaleExponent = numext::mini(exponentBound(M), 0);
+    ColMajorFactor normalized(M);
+    if (scaleExponent != 0) {
+      auto values = normalized.coeffs();
+      kron_ldexp_entries(values, -scaleExponent);
+    }
+    kron_sparse_lu<ColMajorFactor> lu;
+    lu.compute(normalized);
+    if (lu.info() == Success) {
+      exponent += M.rows() * scaleExponent;
+      return lu.balancedDet(exponent);
+    }
+    // An aborted factorization met an exactly zero pivot column -- an exactly
+    // singular factor -- unless a non-finite entry defeated the pivot search.
+    return M.coeffs().allFinite() ? Scalar(0) : Scalar(NumTraits<RealScalar>::quiet_NaN());
+  }
+};
+
+/** \internal Per-factor solve adapter for KroneckerOperator::solve(). All
+ * kinds normalize the factor by an exact power of two up front and then solve
+ * per right-hand-side column in the shared normalized frame; the caller folds
+ * the removed \c exponent() back together with the other factor's and the
+ * column's. A dense factor is LU-factorized once, a sparse factor once by
+ * SparseLU; a diagonal factor is solved by entrywise division, whose
+ * intermediates are bounded by the factor's conditioning exactly like the
+ * substitutions of the LU paths (and each division saturates per entry, like
+ * every step of a substitution). */
+template <typename Factor, int Kind = kron_factor_kind<Factor>()>
+class kron_factor_solver {
+ public:
+  using Scalar = typename Factor::Scalar;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  explicit kron_factor_solver(const Factor& f) : m_exponent(structured_exponent_bound(f)) {
+    DenseMatrix normalized = f;
+    kron_ldexp_entries(normalized, -m_exponent);
+    m_lu.compute(normalized);
+  }
+  int exponent() const { return m_exponent; }
+  /** \internal \returns \f$ F_{norm}^{-1} M \f$. */
+  template <typename Xpr>
+  DenseMatrix solveLeft(const Xpr& M) const {
+    return m_lu.solve(M);
+  }
+  /** \internal \returns \f$ M F_{norm}^{-T} \f$. */
+  template <typename Xpr>
+  DenseMatrix solveTransposedRight(const Xpr& M) const {
+    return m_lu.solve(M.transpose()).transpose();
+  }
+
+ private:
+  int m_exponent;
+  PartialPivLU<DenseMatrix> m_lu;
+};
+
+template <typename Factor>
+class kron_factor_solver<Factor, kKronDiagonalFactor> {
+ public:
+  using Scalar = typename Factor::Scalar;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  explicit kron_factor_solver(const Factor& f)
+      : m_exponent(structured_exponent_bound(f.diagonal())), m_d(f.diagonal()) {
+    kron_ldexp_entries(m_d, -m_exponent);
+  }
+  int exponent() const { return m_exponent; }
+  template <typename Xpr>
+  DenseMatrix solveLeft(const Xpr& M) const {
+    return (M.array().colwise() / m_d.array()).matrix();
+  }
+  template <typename Xpr>
+  DenseMatrix solveTransposedRight(const Xpr& M) const {
+    return (M.array().rowwise() / m_d.transpose().array()).matrix();
+  }
+
+ private:
+  int m_exponent;
+  typename Factor::DiagonalVectorType m_d;
+};
+
+template <typename Factor>
+class kron_factor_solver<Factor, kKronSparseFactor> {
+ public:
+  using Scalar = typename Factor::Scalar;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using ColMajorFactor = SparseMatrix<Scalar, ColMajor, typename Factor::StorageIndex>;
+
+  explicit kron_factor_solver(const Factor& f) : m_exponent(structured_exponent_bound(f.coeffs())) {
+    ColMajorFactor normalized(f);
+    normalized.makeCompressed();
+    if (m_exponent != 0) {
+      auto values = normalized.coeffs();
+      kron_ldexp_entries(values, -m_exponent);
+    }
+    m_lu.compute(normalized);
+    m_factorized = m_lu.info() == Success;  // else the solves fill with NaN, see kron_factor_ops::nanMatrix
+  }
+  int exponent() const { return m_exponent; }
+  template <typename Xpr>
+  DenseMatrix solveLeft(const Xpr& M) const {
+    if (!m_factorized) return kron_factor_ops<Factor>::nanMatrix(M.rows(), M.cols());
+    return m_lu.solve(M);
+  }
+  template <typename Xpr>
+  DenseMatrix solveTransposedRight(const Xpr& M) const {
+    if (!m_factorized) return kron_factor_ops<Factor>::nanMatrix(M.rows(), M.cols());
+    // SparseLU solves into column-major storage only, which a transposed Solve
+    // expression would not evaluate into; the right-hand side stays a view.
+    const DenseMatrix Xt = m_lu.solve(M.transpose());
+    return Xt.transpose();
+  }
+
+ private:
+  int m_exponent;
+  bool m_factorized;
+  SparseLU<ColMajorFactor> m_lu;
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class KroneckerOperator
+ * \brief The Kronecker product \f$ A \otimes B \f$ as an implicit operator that is
+ * never materialized.
+ *
+ * For \c A of size \c m1 x \c n1 and \c B of size \c m2 x \c n2, the Kronecker
+ * product is the \c m1*m2 x \c n1*n2 block matrix whose block \c (i,j) is
+ * \c A(i,j)*B. This class stores only the two factors and evaluates every
+ * operation through them:
+ *
+ * - the matrix-vector product uses the vec identity
+ *   \f$ (A \otimes B)\,\mathrm{vec}(X) = \mathrm{vec}(B X A^T) \f$, costing
+ *   O(m2 n2 n1 + m2 n1 m1) instead of the O(m1 m2 n1 n2) of a materialized
+ *   product;
+ * - linear solves and \ref inverse factor through decompositions of \c A and
+ *   \c B (\f$ (A \otimes B)^{-1} = A^{-1} \otimes B^{-1} \f$); \ref rank and
+ *   minimum-norm least-squares solves (\f$ (A \otimes B)^+ = A^+ \otimes B^+ \f$)
+ *   go through the factor SVDs, thresholding the pairwise singular-value
+ *   products \f$ \sigma_i(A)\,\sigma_j(B) \f$ -- the singular values of the
+ *   Kronecker product -- at the product level;
+ * - the eigendecomposition and the (thin) SVD are Kronecker products of the
+ *   factor decompositions: the eigenvector and singular-vector matrices are
+ *   returned as \c KroneckerOperator objects themselves, never materialized;
+ * - \ref determinant uses \f$ \det(A \otimes B) = \det(A)^{n_2}\det(B)^{n_1} \f$,
+ *   accumulated in an exponent-balanced form so it neither overflows nor
+ *   underflows when the result is representable.
+ *
+ * The class is closed under \ref transpose, \ref conjugate and \ref adjoint
+ * (\f$ (A \otimes B)^T = A^T \otimes B^T \f$). \c operator* returns an Eigen
+ * product expression, so the operator plugs into the matrix-free iterative
+ * solvers, and it can be assigned to a dense matrix when an explicit
+ * representation is needed. As with any matrix-free operator, the iterative
+ * solvers must be instantiated with \c IdentityPreconditioner (e.g.
+ * \c ConjugateGradient<KroneckerOperator<MatrixXd,MatrixXd>,Lower|Upper,IdentityPreconditioner>):
+ * the default preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * In contrast to \c kroneckerProduct() (the KroneckerProduct module), which
+ * builds an expression meant to be evaluated into a dense matrix, this class is
+ * an operator meant to be applied and solved with, without ever forming the
+ * product.
+ *
+ * Either factor may be a \c DiagonalMatrix, with the identity as the
+ * unit-diagonal special case. A diagonal factor is stored as its diagonal --
+ * O(n) instead of O(n^2) -- its side of every product is a diagonal scaling
+ * instead of a GEMM, \ref solve divides entrywise instead of factorizing, and
+ * \ref transpose, \ref conjugate, \ref adjoint, \ref inverse and
+ * \ref determinant never leave diagonal form. This covers the
+ * identity-Kronecker operators \f$ I \otimes A \f$ and \f$ A \otimes I \f$
+ * ubiquitous in finite-difference and Sylvester/Lyapunov settings, e.g.
+ * \code
+ * auto K = makeKroneckerOperator(VectorXd::Ones(p).asDiagonal(), A);  // I_p (x) A, applied in O(p m n)
+ * \endcode
+ * The decomposition family (\ref eigenvalues, \ref eigenvectors,
+ * \ref singularValues, \ref matrixU, \ref matrixV, \ref leastSquaresSolve,
+ * \ref rank) currently materializes a diagonal factor densely for the factor
+ * decomposition.
+ *
+ * Either factor may also be a \c SparseMatrix, stored compressed. For finite
+ * inputs, its side of a product is sparse-dense -- O(nnz) per right-hand-side column
+ * instead of O(m n) -- \ref solve factorizes it once with \c SparseLU and
+ * back-substitutes per column, \ref transpose, \ref conjugate and \ref adjoint
+ * stay sparse, and \ref determinant accumulates the SparseLU pivots in the same
+ * balanced form as the dense LU path, scaling small factors up before
+ * factorization to keep the elimination out of the subnormal range. Its \ref inverse is
+ * dense (one SparseLU solve against the identity), and the decomposition family
+ * densifies it like a diagonal factor. As in every sparse kernel, absent entries
+ * are exact zeros: a structural zero annihilates the Inf or NaN it meets, where a stored zero
+ * (or a dense factor) would produce NaN. Products with non-finite inputs visit
+ * pairs of stored factor entries to preserve this distinction without
+ * materializing the product. A sparse factor whose \c SparseLU factorization
+ * fails -- an exactly zero or non-finite pivot column -- solves
+ * and inverts to NaN, and has determinant 0 when exactly singular (NaN when
+ * non-finite). Assigning the operator to a \c SparseMatrix materializes the
+ * product sparsely, every inner vector reserved to its exact size. For a sparse
+ * \c A of size \c n with \c nnz(A) stored entries:
+ * \code
+ * auto K = makeKroneckerOperator(VectorXd::Ones(p).asDiagonal(), A);  // I_p (x) A
+ * VectorXd y = K * x;             // O(p nnz(A)), no p n x p n matrix
+ * VectorXd z = K.solve(b);        // one SparseLU of A, then p column solves
+ * SparseMatrix<double> M;
+ * M = K;                          // p nnz(A) stored entries, when the matrix itself is needed
+ * \endcode
+ *
+ * \tparam LhsMatrix the plain type of the left factor \c A: a dense \c Matrix,
+ *         a \c DiagonalMatrix to exploit diagonal structure, or a
+ *         \c SparseMatrix to exploit sparsity.
+ * \tparam RhsMatrix the plain type of the right factor \c B, under the same
+ *         convention; its scalar type must match that of \c LhsMatrix.
+ *
+ * \sa makeKroneckerOperator(), class Circulant, class Toeplitz
+ */
+template <typename LhsMatrix, typename RhsMatrix>
+class KroneckerOperator : public EigenBase<KroneckerOperator<LhsMatrix, RhsMatrix>> {
+ public:
+  using Scalar = typename LhsMatrix::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using ComplexScalar = std::complex<RealScalar>;
+  // The vec-trick reshapes below identify a vector of length n1*n2 with an
+  // n2 x n1 matrix whose columns are stacked, so every workspace taking part
+  // in a reshape is pinned to ColMajor explicitly: the semantics must not
+  // change under EIGEN_DEFAULT_TO_ROW_MAJOR.
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using DenseVector = Matrix<Scalar, Dynamic, 1>;
+  using RealVector = Matrix<RealScalar, Dynamic, 1>;
+  using ComplexMatrix = Matrix<ComplexScalar, Dynamic, Dynamic, ColMajor>;
+  using ComplexVector = Matrix<ComplexScalar, Dynamic, 1>;
+
+  static_assert(std::is_same<Scalar, typename RhsMatrix::Scalar>::value,
+                "KroneckerOperator requires both factors to have the same scalar type");
+  static_assert((internal::kron_factor_is_dense_matrix<LhsMatrix>::value ||
+                 internal::kron_factor_is_diagonal<LhsMatrix>::value ||
+                 internal::kron_factor_is_sparse_matrix<LhsMatrix>::value) &&
+                    (internal::kron_factor_is_dense_matrix<RhsMatrix>::value ||
+                     internal::kron_factor_is_diagonal<RhsMatrix>::value ||
+                     internal::kron_factor_is_sparse_matrix<RhsMatrix>::value),
+                "KroneckerOperator factors must be plain Matrix, DiagonalMatrix or SparseMatrix types (owning their "
+                "storage: views and expressions would dangle)");
+
+ private:
+  // Factor-kind dispatch (dense, diagonal or sparse), see kron_factor_ops.
+  using LhsOps = internal::kron_factor_ops<LhsMatrix>;
+  using RhsOps = internal::kron_factor_ops<RhsMatrix>;
+  static constexpr bool kHasSparseFactor = internal::kron_factor_is_sparse_matrix<LhsMatrix>::value ||
+                                           internal::kron_factor_is_sparse_matrix<RhsMatrix>::value;
+
+ public:
+  static constexpr int RowsAtCompileTime =
+      internal::size_at_compile_time(LhsMatrix::RowsAtCompileTime, RhsMatrix::RowsAtCompileTime);
+  static constexpr int ColsAtCompileTime =
+      internal::size_at_compile_time(LhsMatrix::ColsAtCompileTime, RhsMatrix::ColsAtCompileTime);
+  static constexpr int MaxRowsAtCompileTime = RowsAtCompileTime;
+  static constexpr int MaxColsAtCompileTime = ColsAtCompileTime;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(RowsAtCompileTime, ColsAtCompileTime);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const KroneckerOperator>'s default
+  // StrideType argument reads it, so its absence makes internal::is_ref_compatible
+  // SFINAE to false and keeps the iterative solvers on their matrix-free path.
+
+  /** Builds the operator \c A (x) \c B from the two factors, evaluated into the
+   * operator's factor types: a dense expression into a \c Matrix, a diagonal
+   * one into a \c DiagonalMatrix (stored as its diagonal), a sparse one into a
+   * compressed \c SparseMatrix. */
+  template <typename LhsDerived, typename RhsDerived>
+  KroneckerOperator(const EigenBase<LhsDerived>& a, const EigenBase<RhsDerived>& b)
+      : m_A(a.derived()), m_B(b.derived()) {
+    eigen_assert(m_A.size() > 0 && m_B.size() > 0 && "KroneckerOperator factors must be non-empty");
+    LhsOps::prepare(m_A);
+    RhsOps::prepare(m_B);
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_A.rows() * m_B.rows(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_A.cols() * m_B.cols(); }
+
+  /** \returns the left factor \c A. */
+  const LhsMatrix& lhs() const { return m_A; }
+  /** \returns the right factor \c B. */
+  const RhsMatrix& rhs() const { return m_B; }
+
+  /** \returns the coefficient at row \a row and column \a col. */
+  Scalar coeff(Index row, Index col) const {
+    eigen_assert(row >= 0 && row < rows() && col >= 0 && col < cols());
+    const Index m2 = m_B.rows(), n2 = m_B.cols();
+    Scalar a, b;
+    if (!LhsOps::coeffIfStored(m_A, row / m2, col / n2, a) || !RhsOps::coeffIfStored(m_B, row % m2, col % n2, b))
+      return Scalar(0);
+    return a * b;
+  }
+
+  /** \returns the transpose \f$ A^T \otimes B^T \f$, itself a Kronecker
+   * operator. A diagonal factor stays diagonal (it is its own transpose). */
+  KroneckerOperator<typename LhsOps::TransposedFactor, typename RhsOps::TransposedFactor> transpose() const {
+    return {LhsOps::transposed(m_A), RhsOps::transposed(m_B)};
+  }
+
+  /** \returns the conjugate \f$ \bar A \otimes \bar B \f$, itself a Kronecker operator. */
+  KroneckerOperator conjugate() const { return {LhsOps::conjugated(m_A), RhsOps::conjugated(m_B)}; }
+
+  /** \returns the adjoint \f$ A^H \otimes B^H \f$, itself a Kronecker
+   * operator. A diagonal factor stays diagonal (its adjoint is its conjugate). */
+  KroneckerOperator<typename LhsOps::TransposedFactor, typename RhsOps::TransposedFactor> adjoint() const {
+    return {LhsOps::adjointed(m_A), RhsOps::adjointed(m_B)};
+  }
+
+  /** \returns the solution of \c (*this) * x = b for \b square factors, obtained
+   * from one LU decomposition per dense factor and one \c SparseLU per sparse
+   * factor (a diagonal factor is solved by entrywise division instead):
+   * reshaping \c b column-wise as \c mat(b) of size \c n2 x \c n1, the system
+   * reads \f$ B X A^T = \mathrm{mat}(b) \f$, so
+   * \f$ X = B^{-1} \mathrm{mat}(b) A^{-T} \f$. Supports multiple right-hand
+   * sides at O(n1^3 + n2^3 + nrhs (n1 + n2) n1 n2) total cost for dense
+   * factors; a diagonal factor contributes only O(nrhs n1 n2) per application,
+   * a sparse one its factorization plus \c nrhs times its column solves.
+   *
+   * The solves run in a normalized frame [2][3]: the factors and each right-hand
+   * side are rescaled to unit magnitude by exact powers of two, and the combined
+   * exponent is folded back into the solution entrywise afterwards. In the raw
+   * frame the intermediate \f$ B^{-1} \mathrm{mat}(b) \f$ can overflow, or
+   * silently underflow to zero, on factor magnitudes alone even when the
+   * solution is representable (the subsequent \f$ A^{-T} \f$ rescales it: think
+   * \c B huge and \c A tiny); in the normalized frame the intermediates are
+   * bounded by the conditioning of the factors, and the final fold saturates to
+   * 0/Inf exactly when the true solution leaves the representable range.
+   * Partial pivoting is invariant under the uniform power-of-two normalization
+   * and every substitution step scales exactly with it, so the result is
+   * bit-identical to the unnormalized evaluation whenever that evaluation
+   * encounters no intermediate over- or underflow.
+   * \warning Both factors must be invertible, like in \c PartialPivLU: a
+   * singular dense factor substitutes Inf/NaN through the solution, and a
+   * sparse factor whose \c SparseLU factorization fails solves to NaN. Use
+   * \ref leastSquaresSolve for rank-deficient or rectangular factors. */
+  template <typename Rhs>
+  Matrix<Scalar, ColsAtCompileTime, Rhs::ColsAtCompileTime> solve(const MatrixBase<Rhs>& b) const {
+    EIGEN_STATIC_ASSERT(RowsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(RowsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    const Index n1 = m_A.cols(), n2 = m_B.cols();
+    eigen_assert(m_A.rows() == n1 && m_B.rows() == n2 && "KroneckerOperator::solve requires square factors");
+    eigen_assert(b.rows() == n1 * n2 && "right-hand side has the wrong number of rows");
+    // The exponent bounds are 0 for zero or non-finite data, which is then left
+    // unnormalized (Inf/NaN propagate through the substitutions as usual).
+    const internal::kron_factor_solver<LhsMatrix> solverA(m_A);
+    const internal::kron_factor_solver<RhsMatrix> solverB(m_B);
+    Matrix<Scalar, ColsAtCompileTime, Rhs::ColsAtCompileTime> x(n1 * n2, b.cols());
+    DenseVector bc(n1 * n2);
+    DenseMatrix X(n2, n1);
+    for (Index k = 0; k < b.cols(); ++k) {
+      bc = b.col(k);
+      const int ec = internal::structured_exponent_bound(bc);
+      if (ec != 0) internal::kron_ldexp_entries(bc, -ec);
+      X = solverA.solveTransposedRight(solverB.solveLeft(bc.reshaped(n2, n1)));
+      // Fold the combined exponent back. The entrywise ldexp saturates exactly
+      // where the true solution over- or underflows; a multiplicative fold could
+      // not (the combined exponent can exceed the representable range of any
+      // fixed number of power-of-two factors).
+      const int e = ec - solverA.exponent() - solverB.exponent();
+      if (e != 0) internal::kron_ldexp_entries(X, e);
+      x.col(k) = X.reshaped();
+    }
+    return x;
+  }
+
+  /** \returns the minimum-norm least-squares solution of \c (*this) * x = b,
+   * through one SVD per factor: with \f$ A = U_A \Sigma_A V_A^H \f$ and
+   * \f$ B = U_B \Sigma_B V_B^H \f$, the SVD of the product is
+   * \f$ (U_A \otimes U_B)(\Sigma_A \otimes \Sigma_B)(V_A \otimes V_B)^H \f$, and
+   * the pseudo-inverse is applied via the vec identity. The singular values of
+   * the product are the pairwise products \f$ \sigma_i(A)\,\sigma_j(B) \f$, so
+   * the truncation thresholds those products against the product-level
+   * threshold of \ref rank, in the same overflow-safe ratio form -- factor-wise
+   * truncation would invert modes that are negligible at the product level.
+   * Handles rectangular and rank-deficient factors. Supports multiple
+   * right-hand sides.
+   *
+   * Unlike \ref solve, no rescaling of the intermediates is needed here: the
+   * projection and back-transformation matrices have orthonormal columns, so no
+   * intermediate can outgrow the data by more than a dimension factor, exactly
+   * as in a dense product. */
+  template <typename Rhs>
+  Matrix<Scalar, ColsAtCompileTime, Rhs::ColsAtCompileTime> leastSquaresSolve(const MatrixBase<Rhs>& b) const {
+    EIGEN_STATIC_ASSERT(RowsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(RowsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    const Index m1 = m_A.rows(), m2 = m_B.rows();
+    eigen_assert(b.rows() == m1 * m2 && "right-hand side has the wrong number of rows");
+    BDCSVD<DenseMatrix, ComputeThinU | ComputeThinV> svdA(LhsOps::denseFactor(m_A)), svdB(RhsOps::denseFactor(m_B));
+    const RealVector sa = svdA.singularValues(), sb = svdB.singularValues();
+    const RealScalar tol = relativeRankThreshold();
+    const Index kA = sa.size(), kB = sb.size();
+    Matrix<Scalar, ColsAtCompileTime, Rhs::ColsAtCompileTime> x(cols(), b.cols());
+    if (sa[0] == RealScalar(0) || sb[0] == RealScalar(0)) {
+      // An exactly zero factor zeroes the whole operator, whose pseudo-inverse is
+      // zero (and the singular-value ratios below would be 0/0).
+      x.setZero();
+      return x;
+    }
+    const SingularModes modesA(sa), modesB(sb);
+    Matrix<RealScalar, Dynamic, Dynamic, ColMajor> divisors(kB, kA);
+    Matrix<int, Dynamic, Dynamic, ColMajor> exponents(kB, kA);
+    Matrix<bool, Dynamic, Dynamic, ColMajor> retained(kB, kA);
+    for (Index j = 0; j < kA; ++j)
+      for (Index i = 0; i < kB; ++i) {
+        retained(i, j) = modesA.retains(modesB, j, i, tol);
+        divisors(i, j) = modesA.mantissas[j] * modesB.mantissas[i];
+        exponents(i, j) = -(modesA.exponents[j] + modesB.exponents[i]);
+      }
+    DenseVector bc(m1 * m2);
+    DenseMatrix M(kB, kA), X(m_B.cols(), m_A.cols());
+    for (Index k = 0; k < b.cols(); ++k) {
+      bc = b.col(k);
+      // By [1], M = U_B^H mat(b) conj(U_A) matricizes (U_A (x) U_B)^H b.
+      M.noalias() = svdB.matrixU().adjoint() * bc.reshaped(m2, m1) * svdA.matrixU().conjugate();
+      // Apply the exponent before dividing by the mantissa product [2]: the
+      // singular-value product or its reciprocal need not be representable.
+      for (Index j = 0; j < kA; ++j)
+        for (Index i = 0; i < kB; ++i) {
+          if (retained(i, j))
+            M(i, j) = internal::structured_ldexp_clamped(M(i, j), Index(exponents(i, j))) / divisors(i, j);
+          else
+            M(i, j) = Scalar(0);
+        }
+      X.noalias() = svdB.matrixV() * M * svdA.matrixV().transpose();
+      x.col(k) = X.reshaped();
+    }
+    return x;
+  }
+
+  /** \returns the numerical rank: the number of pairwise singular-value products
+   * \f$ \sigma_i(A)\,\sigma_j(B) \f$ -- the singular values of the Kronecker
+   * product -- that reach the threshold
+   * \c min(rows(),cols()) * epsilon * sigma_max(A) * sigma_max(B) (the
+   * \c SVDBase convention), and that reach the smallest normal number (the
+   * \c SVDBase threshold clamp, so subnormal products count as exact zeros).
+   * The relative comparison is made in ratio space,
+   * \f$ (\sigma_i(A)/\sigma_{max}(A))(\sigma_j(B)/\sigma_{max}(B)) \f$ against
+   * \c min(rows(),cols()) * epsilon, and the clamp in exponent space, so that
+   * neither the thresholds nor the products can spuriously under- or overflow.
+   * This is the same threshold \ref leastSquaresSolve uses to decide which
+   * modes to invert. Thresholding the products matters: factors that are each
+   * full rank against their own threshold can still form pairwise products
+   * that are negligible at the product level, so the rank can be smaller than
+   * the product of the factor ranks. */
+  Index rank() const {
+    BDCSVD<DenseMatrix> svdA(LhsOps::denseFactor(m_A)), svdB(RhsOps::denseFactor(m_B));
+    const RealVector sa = svdA.singularValues(), sb = svdB.singularValues();
+    // An exactly zero factor zeroes the whole operator (and would make the
+    // ratios below 0/0).
+    if (sa[0] == RealScalar(0) || sb[0] == RealScalar(0)) return 0;
+    const RealScalar tol = relativeRankThreshold();
+    const SingularModes modesA(sa), modesB(sb);
+    Index r = 0;
+    for (Index i = 0; i < sa.size(); ++i)
+      for (Index j = 0; j < sb.size(); ++j)
+        // Negated ratio comparison so NaN ratios count as non-zero.
+        if (modesA.retains(modesB, i, j, tol)) ++r;
+    return r;
+  }
+
+  /** \returns the inverse \f$ A^{-1} \otimes B^{-1} \f$, itself a Kronecker
+   * operator, for square invertible factors. A diagonal factor's inverse stays
+   * diagonal (entrywise reciprocals); a sparse factor's inverse is a dense
+   * matrix, computed by one \c SparseLU solve against the identity (NaN when
+   * the factorization fails). */
+  KroneckerOperator<typename LhsOps::InverseFactor, typename RhsOps::InverseFactor> inverse() const {
+    eigen_assert(m_A.rows() == m_A.cols() && m_B.rows() == m_B.cols() &&
+                 "KroneckerOperator::inverse requires square factors");
+    return {LhsOps::inversed(m_A), RhsOps::inversed(m_B)};
+  }
+
+  /** \returns the determinant \f$ \det(A)^{n_2} \det(B)^{n_1} \f$ for square
+   * factors \c A of size \c n1 and \c B of size \c n2. The product is
+   * accumulated from the factor LU diagonals (the \c SparseLU pivots for a
+   * sparse factor, the diagonal itself for a diagonal factor, skipping the LU)
+   * in the balanced form \c m * 2^e --
+   * every factor and the running product are renormalized to unit magnitude
+   * with the power of two tracked separately -- so the partial products (in
+   * particular \c det(A) and \c det(B) themselves, which can overflow or
+   * underflow on their own) never leave the representable range when the
+   * determinant itself is representable. */
+  Scalar determinant() const {
+    eigen_assert(m_A.rows() == m_A.cols() && m_B.rows() == m_B.cols() &&
+                 "KroneckerOperator::determinant requires square factors");
+    Index exponent = 0;
+    Scalar mant = balancedDetPow(m_A, m_B.cols(), exponent);
+    mant = internal::structured_balance(mant * balancedDetPow(m_B, m_A.cols(), exponent), exponent);
+    return internal::structured_ldexp_clamped(mant, exponent);
+  }
+
+  /** \returns the eigenvalues for square factors, in Kronecker order: entry
+   * \c i*n2 + j is \f$ \lambda_i(A)\,\mu_j(B) \f$, matching column \c i*n2 + j of
+   * \ref eigenvectors. The set is not sorted -- there is no canonical eigenvalue
+   * order, and sorting would break the Kronecker structure of the eigenvector
+   * matrix. */
+  ComplexVector eigenvalues() const {
+    eigen_assert(m_A.rows() == m_A.cols() && m_B.rows() == m_B.cols() &&
+                 "KroneckerOperator::eigenvalues requires square factors");
+    ComplexEigenSolver<ComplexMatrix> esA(LhsOps::denseFactor(m_A).template cast<ComplexScalar>(),
+                                          /*computeEigenvectors=*/false);
+    ComplexEigenSolver<ComplexMatrix> esB(RhsOps::denseFactor(m_B).template cast<ComplexScalar>(),
+                                          /*computeEigenvectors=*/false);
+    eigen_assert(esA.info() == Success && esB.info() == Success);
+    // Column-major stacking of the nB x nA outer product puts mu_j(B) lambda_i(A)
+    // at index i*nB + j, the Kronecker order.
+    return (esB.eigenvalues() * esA.eigenvalues().transpose()).reshaped();
+  }
+
+  /** \returns the matrix of eigenvectors \f$ V_A \otimes V_B \f$ for square
+   * factors -- itself a Kronecker operator, never materialized. Column
+   * \c i*n2 + j is \f$ v_i(A) \otimes v_j(B) \f$ and matches
+   * \c eigenvalues()[i*n2 + j]. Assign it to a dense matrix to materialize. */
+  KroneckerOperator<ComplexMatrix, ComplexMatrix> eigenvectors() const {
+    eigen_assert(m_A.rows() == m_A.cols() && m_B.rows() == m_B.cols() &&
+                 "KroneckerOperator::eigenvectors requires square factors");
+    ComplexEigenSolver<ComplexMatrix> esA(LhsOps::denseFactor(m_A).template cast<ComplexScalar>());
+    ComplexEigenSolver<ComplexMatrix> esB(RhsOps::denseFactor(m_B).template cast<ComplexScalar>());
+    eigen_assert(esA.info() == Success && esB.info() == Success);
+    return {esA.eigenvectors(), esB.eigenvectors()};
+  }
+
+  /** \returns the singular values of the thin SVD
+   * \f$ A \otimes B = U \Sigma V^H \f$ in Kronecker order: entry \c i*k_B + j is
+   * \f$ \sigma_i(A)\,\sigma_j(B) \f$ with \c k_A, \c k_B the factor thin ranks
+   * \c min(rows, cols), matching the columns of \ref matrixU and \ref matrixV.
+   * The values are not sorted (sorting would break the Kronecker structure of
+   * \c U and \c V); for rectangular shapes the full SVD pads this set with
+   * \c min(rows(),cols()) - k_A*k_B structural zeros. */
+  RealVector singularValues() const {
+    BDCSVD<DenseMatrix> svdA(LhsOps::denseFactor(m_A)), svdB(RhsOps::denseFactor(m_B));
+    // Column-major stacking of the kB x kA outer product puts sigma_j(B) sigma_i(A)
+    // at index i*kB + j, the Kronecker order.
+    return (svdB.singularValues() * svdA.singularValues().transpose()).reshaped();
+  }
+
+  /** \returns the left singular vectors \f$ U_A \otimes U_B \f$ of the thin SVD,
+   * itself a Kronecker operator with orthonormal columns; column \c i*k_B + j
+   * matches \c singularValues()[i*k_B + j]. */
+  KroneckerOperator<DenseMatrix, DenseMatrix> matrixU() const {
+    BDCSVD<DenseMatrix, ComputeThinU> svdA(LhsOps::denseFactor(m_A)), svdB(RhsOps::denseFactor(m_B));
+    return {svdA.matrixU(), svdB.matrixU()};
+  }
+
+  /** \returns the right singular vectors \f$ V_A \otimes V_B \f$ of the thin SVD,
+   * itself a Kronecker operator with orthonormal columns; column \c i*k_B + j
+   * matches \c singularValues()[i*k_B + j]. */
+  KroneckerOperator<DenseMatrix, DenseMatrix> matrixV() const {
+    BDCSVD<DenseMatrix, ComputeThinV> svdA(LhsOps::denseFactor(m_A)), svdB(RhsOps::denseFactor(m_B));
+    return {svdA.matrixV(), svdB.matrixV()};
+  }
+
+  /** \internal Writes the representation into \a dst, dense or sparse according
+   * to the destination's storage kind; invoked through \c dense = kron; and
+   * \c sparse = kron; (there is no converting constructor for a SparseMatrix). */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    evalToImpl(dst, IsSparseDestination<Dest>());
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    addToImpl(dst, IsSparseDestination<Dest>());
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    subToImpl(dst, IsSparseDestination<Dest>());
+  }
+
+ private:
+  template <typename Dest>
+  using IsSparseDestination = std::is_same<typename internal::traits<Dest>::StorageKind, Sparse>;
+
+  /** \internal The dense representation, one block per stored entry of \c A. A
+   * diagonal or sparse \c B writes each block through the diagonal- or
+   * sparse-to-dense assignment (zeros plus the stored entries); the structurally
+   * zero blocks of a diagonal or sparse \c A are cleared up front instead of
+   * visited. */
+  template <typename Dest>
+  void evalToImpl(Dest& dst, std::false_type) const {
+    const Index m2 = m_B.rows(), n2 = m_B.cols();
+    if (!LhsOps::StoresAllEntries) dst.setZero();
+    LhsOps::forEachNonZero(
+        m_A, [&dst, m2, n2, this](Index i, Index j, const Scalar& a) { dst.block(i * m2, j * n2, m2, n2) = a * m_B; });
+  }
+
+  template <typename Dest>
+  void addToImpl(Dest& dst, std::false_type) const {
+    const Index m2 = m_B.rows(), n2 = m_B.cols();
+    LhsOps::forEachNonZero(
+        m_A, [&dst, m2, n2, this](Index i, Index j, const Scalar& a) { dst.block(i * m2, j * n2, m2, n2) += a * m_B; });
+  }
+
+  template <typename Dest>
+  void subToImpl(Dest& dst, std::false_type) const {
+    const Index m2 = m_B.rows(), n2 = m_B.cols();
+    LhsOps::forEachNonZero(
+        m_A, [&dst, m2, n2, this](Index i, Index j, const Scalar& a) { dst.block(i * m2, j * n2, m2, n2) -= a * m_B; });
+  }
+
+  /** \internal The sparse representation. Every stored entry of \c A (all
+   * entries of a dense factor, the diagonal of a diagonal one, the nonzeros of a
+   * sparse one) meets every stored entry of \c B, so \a dst holds exactly the
+   * products of the stored entries, explicit zeros included (\c prune() drops
+   * them). Each inner vector is reserved to its exact final size, the product of
+   * the factors' inner-vector counts, and receives its entries in increasing
+   * inner index for every mix of storage orders: with the loop over \c A
+   * outermost, the visits to a fixed column <tt>(jA, jB)</tt> are lexicographic
+   * in <tt>(iA, iB)</tt>, and those to a fixed row in <tt>(jA, jB)</tt>. */
+  template <typename Dest>
+  void evalToImpl(Dest& S, std::true_type) const {
+    const Index m2 = m_B.rows(), n2 = m_B.cols();
+    S.resize(rows(), cols());
+    using IndexVector = Matrix<Index, Dynamic, 1>;
+    const IndexVector nnzA = LhsOps::innerNonZeros(m_A, Dest::IsRowMajor);
+    const IndexVector nnzB = RhsOps::innerNonZeros(m_B, Dest::IsRowMajor);
+    // Inner vectors kA of A and kB of B meet in inner vector kA * nnzB.size() + kB
+    // of the product: the column-major stacking of the count outer product.
+    const Matrix<Index, Dynamic, Dynamic, ColMajor> counts = nnzB * nnzA.transpose();
+    S.reserve(counts.reshaped());
+    LhsOps::forEachNonZero(m_A, [&S, m2, n2, this](Index iA, Index jA, const Scalar& a) {
+      RhsOps::forEachNonZero(m_B, [&S, m2, n2, iA, jA, &a](Index iB, Index jB, const Scalar& b) {
+        S.insert(iA * m2 + iB, jA * n2 + jB) = a * b;
+      });
+    });
+    S.makeCompressed();
+  }
+
+  template <typename Dest>
+  void addToImpl(Dest& dst, std::true_type) const {
+    typename Dest::PlainObject product;
+    evalTo(product);
+    dst += product;
+  }
+
+  template <typename Dest>
+  void subToImpl(Dest& dst, std::true_type) const {
+    typename Dest::PlainObject product;
+    evalTo(product);
+    dst -= product;
+  }
+
+ public:
+  /** \returns the product expression \c (*this) * \a x, evaluated through the vec
+   * identity without materializing the Kronecker product. The expression carries
+   * the default product tag, so assigning it behaves like any dense product: a
+   * temporary resolves aliasing between the destination and \a x, and
+   * \c .noalias() skips it. */
+  template <typename Rhs>
+  Product<KroneckerOperator, Rhs> operator*(const MatrixBase<Rhs>& x) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(x.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<KroneckerOperator, Rhs>(*this, x.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs through the vec identity
+   * \f$ (A \otimes B)\,\mathrm{vec}(X) = \mathrm{vec}(B X A^T) \f$ of [1], column
+   * by column. \c ProductScalar is the promoted scalar of the product (complex
+   * when a real operator is applied to a complex right-hand side); the
+   * workspaces and the accumulation run in the promoted type.
+   *
+   * Evaluated as \c (B X) A^T, the first factor \c B X can overflow even when
+   * the product itself is representable (the multiplication by \c A^T rescales
+   * it: think \c B huge and \c A tiny). Each column is therefore pre-scaled by
+   * an exact power of two [2][3] derived from the component-wise exponent
+   * bounds of \c A, \c B and the column -- never from complex moduli, which
+   * overflow near the threshold -- so that no intermediate can spuriously
+   * overflow, and the
+   * exponent is folded back into the result through two representable
+   * half-factors, saturating to 0/Inf exactly when the true result leaves the
+   * representable range. The scale is one whenever the conservative bound shows
+   * no overflow risk, so results of moderate magnitude are bit-identical to the
+   * unscaled evaluation. Non-finite data is never scaled (the bounds cannot see
+   * past an Inf/NaN, and 0 * Inf would manufacture NaNs); the unscaled GEMMs
+   * propagate it entrywise exactly like a dense product. With a sparse factor,
+   * non-finite inputs instead use the stored-entry product to preserve the
+   * distinction between absent entries and stored zeros. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    using ProductVector = Matrix<ProductScalar, Dynamic, 1>;
+    using ProductMatrix = Matrix<ProductScalar, Dynamic, Dynamic, ColMajor>;  // ColMajor: see DenseMatrix
+    using ProductReal = typename NumTraits<ProductScalar>::Real;
+    // In particular, materialize a nested matrix product once before taking
+    // per-column expressions from it. Otherwise each column evaluator may
+    // independently evaluate the entire nested product.
+    typename internal::nested_eval<Rhs, 1>::type actualRhs(rhs);
+    const Index n1 = m_A.cols(), n2 = m_B.cols();
+    eigen_assert(actualRhs.rows() == n1 * n2 && "invalid product: dimensions do not match");
+    // If max|X| < 2^eX, the two factor applications are bounded by
+    // 2^(eB+eX+bits2) and 2^(eA+eB+eX+bits1+bits2), including dot-product growth.
+    const bool factorsFinite = LhsOps::allFinite(m_A) && RhsOps::allFinite(m_B);
+    const int expA = LhsOps::exponentBound(m_A);
+    const int expB = RhsOps::exponentBound(m_B);
+    // Bit widths of the contracted dimensions, i.e. the dot-product growth
+    // bound; zero for a diagonal factor, whose application has no accumulation.
+    const int bits1 = LhsOps::growthBits(n1);
+    const int bits2 = RhsOps::growthBits(n2);
+    const int budget = std::numeric_limits<ProductReal>::max_exponent - 2;
+    ProductVector xc(n1 * n2);
+    ProductMatrix Y(m_B.rows(), m_A.rows());
+    for (Index k = 0; k < actualRhs.cols(); ++k) {
+      xc = actualRhs.col(k).template cast<ProductScalar>();
+      int e = 0;
+      const bool finite = factorsFinite && xc.allFinite();
+      if (finite) {
+        const int expX = internal::structured_exponent_bound(xc);  // 0 for an all-zero column: no scaling
+        e = numext::maxi(0, numext::maxi(expB + expX + bits2 - budget, expA + expB + expX + bits1 + bits2 - budget));
+        // The cap keeps the half-factors below overflow; it only binds when the
+        // true result overflows anyway, so the saturation to Inf is genuine.
+        e = numext::mini(e, 2 * budget);
+      }
+      if (e > 0) {
+        // Each power of two is split in halves so that the factors themselves
+        // stay representable; scaling by the two exact factors in sequence is
+        // still an exact shift wherever the result is representable.
+        const ProductReal down1 = ProductReal(std::ldexp(ProductReal(1), -(e / 2)));
+        const ProductReal down2 = ProductReal(std::ldexp(ProductReal(1), -(e - e / 2)));
+        xc = (xc * down1) * down2;
+      }
+      // For a diagonal factor its side degenerates to a diagonal scaling
+      // (transposedOperand: a diagonal matrix is its own transpose), a single
+      // stored term per entry: only a sparse factor can leave an exact 0 in B X
+      // (an empty row) for an Inf/NaN of A to meet.
+      if (EIGEN_PREDICT_FALSE(!finite && kHasSparseFactor))
+        productNonFinite(Y, xc);
+      else
+        Y.noalias() = m_B * xc.reshaped(n2, n1) * LhsOps::transposedOperand(m_A);
+      if (e > 0) {
+        const ProductReal up1 = ProductReal(std::ldexp(ProductReal(1), e / 2));
+        const ProductReal up2 = ProductReal(std::ldexp(ProductReal(1), e - e / 2));
+        dst.col(k) += alpha * ((Y.reshaped() * up1) * up2);
+      } else {
+        dst.col(k) += alpha * Y.reshaped();
+      }
+    }
+  }
+
+ private:
+  // A dense intermediate loses which zeros were structural; a later Inf/NaN
+  // factor would turn those absent terms into NaNs. Preserve the stored pairs.
+  template <typename ProductScalar>
+  EIGEN_DONT_INLINE void productNonFinite(Matrix<ProductScalar, Dynamic, Dynamic, ColMajor>& result,
+                                          const Matrix<ProductScalar, Dynamic, 1>& x) const {
+    result.setZero();
+    LhsOps::forEachNonZero(m_A, [&result, &x, this](Index iA, Index jA, const Scalar& a) {
+      RhsOps::forEachNonZero(m_B, [&result, &x, jA, iA, &a, this](Index iB, Index jB, const Scalar& b) {
+        result.coeffRef(iB, iA) += (a * b) * x.coeff(jA * m_B.cols() + jB);
+      });
+    });
+  }
+
+  /** \internal \returns the relative rank/pseudo-inversion threshold for the
+   * pairwise singular-value products, in the spirit of the SVD-based
+   * pseudo-inverse: a mode \c (i,j) is kept when
+   * \c (sa[i]/sa[0]) * (sb[j]/sb[0]) >= min(rows,cols) * epsilon, the \c SVDBase
+   * convention for \c sa[i]*sb[j] measured against \c smax = sa[0]*sb[0]. The
+   * comparison must happen in ratio space: the absolute form both underflows
+   * (\c min(rows,cols) * epsilon * sa[0] can flush to zero before the \c sb[0]
+   * multiplication, silently accepting every mode) and overflows
+   * (\c sa[0]*sb[0] can exceed the representable range). The ratios never
+   * exceed one, and a ratio product that underflows is genuinely below any
+   * epsilon-sized threshold. */
+  RealScalar relativeRankThreshold() const {
+    return RealScalar(numext::mini(rows(), cols())) * NumTraits<RealScalar>::epsilon();
+  }
+
+  // Factor-level ratios and frexp decompositions are independent of the RHS and
+  // of the other factor. Keep rank() and pseudo-inversion on the same predicate.
+  struct SingularModes {
+    explicit SingularModes(const RealVector& s) : ratios(s.size()), mantissas(s.size()), exponents(s.size()) {
+      for (Index i = 0; i < s.size(); ++i) {
+        ratios[i] = s[i] / s[0];
+        exponents[i] = 0;
+        EIGEN_USING_STD(frexp);
+        mantissas[i] = frexp(s[i], &exponents[i]);
+      }
+    }
+
+    bool retains(const SingularModes& other, Index i, Index j, RealScalar tol) const {
+      // Negation keeps NaN ratios in the inverted set, matching SVDBase.
+      if (ratios[i] * other.ratios[j] < tol) return false;
+      const RealScalar m = mantissas[i] * other.mantissas[j];
+      if (!(numext::isfinite)(m)) return true;
+      if (m == RealScalar(0)) return false;
+      // s_i*s_j = m*2^(e_i+e_j), with m in [0.25,1). Test the
+      // smallest-normal clamp without forming an overflowing/underflowing product.
+      const int e = exponents[i] + other.exponents[j] - (m < RealScalar(0.5) ? 1 : 0);
+      return e >= std::numeric_limits<RealScalar>::min_exponent;
+    }
+
+    RealVector ratios, mantissas;
+    Matrix<int, Dynamic, 1> exponents;
+  };
+
+  /** \internal \returns the mantissa of \c det(M)^power in the balanced form
+   * \c m * 2^e, adding \c e into \a exponent. The determinant is accumulated
+   * directly from the LU diagonal, times the permutation sign (from the
+   * diagonal itself for a diagonal factor, see kron_factor_ops::balancedDet),
+   * each entry and the running product renormalized by \ref balance, and the
+   * integer power is applied by balanced repeated multiplication -- exact
+   * integer-power semantics for negative real and complex determinants (no
+   * exp/log branch-cut roundoff), with the bulk of the magnitude carried
+   * exactly on the exponent side. */
+  template <typename Factor>
+  static Scalar balancedDetPow(const Factor& M, Index power, Index& exponent) {
+    Index e = 0;
+    const Scalar m = internal::kron_factor_ops<Factor>::balancedDet(M, e);
+    Scalar r(1);
+    Index er = 0;
+    for (Index k = 0; k < power; ++k) r = internal::structured_balance(r * m, er);
+    exponent += power * e + er;
+    return r;
+  }
+
+  LhsMatrix m_A;
+  RhsMatrix m_B;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref KroneckerOperator \c a (x) \c b holding evaluated copies of the
+ * factors. The operator type is deduced from the plain types of \a a and \a b:
+ * a dense argument becomes a \c Matrix factor, a diagonal one (e.g.
+ * \c VectorXd::Ones(n).asDiagonal() for an identity factor) an owning
+ * \c DiagonalMatrix, a sparse one a compressed \c SparseMatrix, each exploited
+ * structurally, see \ref KroneckerOperator. */
+template <typename LhsDerived, typename RhsDerived>
+KroneckerOperator<typename LhsDerived::PlainObject, typename RhsDerived::PlainObject> makeKroneckerOperator(
+    const EigenBase<LhsDerived>& a, const EigenBase<RhsDerived>& b) {
+  return {a.derived(), b.derived()};
+}
+
+namespace internal {
+
+template <typename LhsMatrix, typename RhsMatrix, typename Rhs, int ProductTag>
+struct generic_product_impl<KroneckerOperator<LhsMatrix, RhsMatrix>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<KroneckerOperator<LhsMatrix, RhsMatrix>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_KRONECKER_OPERATOR_H
diff --git a/contrib/Eigen/src/StructuredMatrices/LookAheadLevinson.h b/contrib/Eigen/src/StructuredMatrices/LookAheadLevinson.h
new file mode 100644
index 0000000..898469b
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/LookAheadLevinson.h
@@ -0,0 +1,453 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_STRUCTURED_LOOK_AHEAD_LEVINSON_H
+#define EIGEN_STRUCTURED_LOOK_AHEAD_LEVINSON_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_>
+class LookAheadLevinson;
+
+namespace internal {
+
+template <typename Scalar_>
+struct traits<LookAheadLevinson<Scalar_>> : traits<Matrix<Scalar_, Dynamic, Dynamic>> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
+  using BaseTraits = traits<Matrix<Scalar_, Dynamic, Dynamic>>;
+  static constexpr int Flags = BaseTraits::Flags & RowMajorBit;
+  static constexpr int CoeffReadCost = Dynamic;
+};
+
+// Persymmetry E_n T_n E_n = T_n^T requires sum_i a_i b_i, not the conjugating dot().
+template <typename D1, typename D2>
+typename D1::Scalar structured_tdot(const MatrixBase<D1>& a, const MatrixBase<D2>& b) {
+  return a.cwiseProduct(b).sum();
+}
+
+template <typename Scalar>
+Matrix<Scalar, Dynamic, 1> structured_upshift(const Matrix<Scalar, Dynamic, 1>& v) {
+  const Index k = v.size();
+  Matrix<Scalar, Dynamic, 1> w = Matrix<Scalar, Dynamic, 1>::Zero(k);
+  if (k > 1) w.head(k - 1) = v.tail(k - 1);
+  return w;
+}
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class LookAheadLevinson
+ * \brief Look-ahead Levinson direct solver for general Toeplitz systems.
+ *
+ * Solves \c T*x = b for a square \ref Toeplitz matrix \c T in O(n^2) operations.
+ * This is an implementation of the look-ahead Levinson algorithm of T. F. Chan and
+ * P. C. Hansen, which extends the classical Levinson recursion to remain (weakly)
+ * numerically stable for general — including indefinite and ill-conditioned —
+ * Toeplitz matrices. When the recursion would otherwise break down at a
+ * near-singular leading principal submatrix, the algorithm "looks ahead" and takes
+ * a block step (up to \ref maxBlockSize) over it. As a by-product it produces an
+ * estimate of the matrix condition number (\ref conditionEstimate).
+ *
+ * The class derives from \c SolverBase and follows the usual decomposition style;
+ * transposed and adjoint systems reuse the factorization of \c T through the
+ * persymmetry \f$ T^T = E T E \f$ (with \c E the exchange matrix), so all three
+ * solves below cost the same:
+ * \code
+ *   LookAheadLevinson<double> levinson(T);      // or levinson.compute(T);
+ *   VectorXd x = levinson.solve(b);              // solve T   * x = b
+ *   VectorXd y = levinson.transpose().solve(b);  // solve T^T * y = b
+ *   VectorXd z = levinson.adjoint().solve(b);    // solve T^H * z = b
+ * \endcode
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ *
+ * References:
+ *  - T. F. Chan and P. C. Hansen, "A look-ahead Levinson algorithm for general
+ *    Toeplitz systems," IEEE Trans. Signal Process., 40(5):1079-1090, 1992.
+ *  - T. F. Chan and P. C. Hansen, "A look-ahead Levinson algorithm for indefinite
+ *    Toeplitz systems," SIAM J. Matrix Anal. Appl., 13(2):490-506, 1992.
+ *
+ * \sa class Toeplitz
+ */
+template <typename Scalar_>
+class LookAheadLevinson : public SolverBase<LookAheadLevinson<Scalar_>> {
+ public:
+  using Base = SolverBase<LookAheadLevinson>;
+  friend class SolverBase<LookAheadLevinson>;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(LookAheadLevinson)
+  using DenseVector = Matrix<Scalar, Dynamic, 1>;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic>;
+
+  /** Default constructor; call \ref compute before \ref solve. */
+  LookAheadLevinson() : m_maxBlockSize(4), m_n(0), m_isInitialized(false), m_info(InvalidInput) {}
+
+  /** Constructs and factorizes from the Toeplitz matrix \a T, which may have fixed
+   * or dynamic dimensions. */
+  template <int Rows_, int Cols_>
+  explicit LookAheadLevinson(const Toeplitz<Scalar, Rows_, Cols_>& T)
+      : m_maxBlockSize(4), m_n(0), m_isInitialized(false), m_info(InvalidInput) {
+    compute(T);
+  }
+
+  /** Sets the maximum look-ahead block size \f$ p_{\max} \f$ (default 4). The solver
+   * is numerically stable as long as \c T has no more than \c p-1 consecutive
+   * ill-conditioned leading principal submatrices. Must be called before \ref compute. */
+  LookAheadLevinson& setMaxBlockSize(Index p) {
+    eigen_assert(p >= 1);
+    m_maxBlockSize = p;
+    return *this;
+  }
+
+  /** \returns the maximum look-ahead block size \f$ p_{\max} \f$. \sa setMaxBlockSize */
+  Index maxBlockSize() const { return m_maxBlockSize; }
+
+  Index rows() const noexcept { return m_n; }
+  Index cols() const noexcept { return m_n; }
+
+  /** Factorizes the square Toeplitz matrix \a T. \sa solve */
+  template <int Rows_, int Cols_>
+  LookAheadLevinson& compute(const Toeplitz<Scalar, Rows_, Cols_>& T);
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns the solution \c x of \c T*x = \a b, as a lazily evaluated expression.
+   * Supports multiple right-hand sides. The transposed and adjoint systems are
+   * solved at the same cost, and with the same factorization, through
+   * \c transpose().solve(b) and \c adjoint().solve(b).
+   * \pre \ref compute has been called. */
+  template <typename Rhs>
+  inline const Solve<LookAheadLevinson, Rhs> solve(const MatrixBase<Rhs>& b) const;
+#endif
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  /** \internal Evaluates the solution of \c T*x = rhs into \a dst; called through
+   * the \c Solve expression returned by \c SolverBase::solve. The copy must be
+   * coefficient-wise (noalias), never a move: when the Solve expression is
+   * evaluated inside a larger expression, \c evaluator<Solve> caches pointers
+   * into \a dst before calling this, and a move-assignment of the returned
+   * matrix (same plain type for a matrix right-hand side) would steal its buffer
+   * and leave those pointers dangling. */
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const {
+    dst.noalias() = solveForward(rhs);
+  }
+
+  /** \internal Persymmetry E T E = T^T (with E the exchange matrix) turns the
+   * transposed system T^T x = b into T (E x) = E b, so a transposed solve is a
+   * forward solve with row-reversed right-hand side and solution -- conjugated on
+   * the way in and out for the adjoint -- reusing the factorization of T as is. */
+  template <bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType& rhs, DstType& dst) const {
+    const DenseMatrix reversed = rhs.template conjugateIf<Conjugate>().colwise().reverse();
+    dst = solveForward(reversed).colwise().reverse().template conjugateIf<Conjugate>();
+  }
+#endif
+
+  /** \returns \c Success if the algorithm could skip all ill-conditioned leading
+   * submatrices within the look-ahead range, \c NumericalIssue otherwise. */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "LookAheadLevinson is not initialized.");
+    return m_info;
+  }
+
+  /** \returns an estimate of the 2-norm condition number of \c T, available after
+   * \ref compute (the "algorithm condition number" of Chan and Hansen). */
+  RealScalar conditionEstimate() const {
+    eigen_assert(m_isInitialized && "LookAheadLevinson is not initialized.");
+    return m_sMin > RealScalar(0) ? m_normEst / m_sMin : NumTraits<RealScalar>::infinity();
+  }
+
+ private:
+  /** \internal \returns the solution of the forward system \c T*x = b by advancing
+   * x through the recorded steps of the factorization. */
+  template <typename Rhs>
+  DenseMatrix solveForward(const Rhs& b) const {
+    const Index nrhs = b.cols();
+    DenseMatrix x = m_luInit.solve(b.topRows(m_k0));
+    DenseMatrix rhs, a, xn;
+    for (const Step& s : m_steps) {
+      rhs.noalias() = b.middleRows(s.k, s.p) - s.WspEk * x;  // (27): b_p - S_p^T E_k x_k
+      a = s.luGamma.solve(rhs);
+      xn.resize(s.k + s.p, nrhs);
+      xn.topRows(s.k).noalias() = x + s.EkYp * a;  // [E_k Y_p; I_p] a_p
+      xn.bottomRows(s.p) = a;
+      x = xn;
+    }
+    return x;
+  }
+
+  // Per accepted block step, the b-independent data needed to advance x in solve().
+  struct Step {
+    Index k;            // order before the step
+    Index p;            // block size
+    DenseMatrix EkYp;   // E_k Y_p          (k x p)
+    DenseMatrix WspEk;  // S_p^T E_k        (p x k)
+    FullPivLU<DenseMatrix> luGamma;
+  };
+
+  // Leading p x p principal submatrix built directly from the generators.
+  static DenseMatrix leadingBlock(const DenseVector& c, const DenseVector& r, Index p) {
+    DenseMatrix B(p, p);
+    for (Index j = 0; j < p; ++j) {
+      B.col(j).head(j) = r.segment(1, j).reverse();
+      B.col(j).tail(p - j) = c.head(p - j);
+    }
+    return B;
+  }
+
+  // Builds a (len x cols) block whose column j is the length-len generator segment
+  // v.segment(first + j, len); used to assemble the S_p and R_p shift blocks.
+  static DenseMatrix shiftBlock(const DenseVector& v, Index first, Index len, Index cols) {
+    DenseMatrix B(len, cols);
+    for (Index j = 0; j < cols; ++j) B.col(j) = v.segment(first + j, len);
+    return B;
+  }
+
+  static RealScalar smallestSingularValue(const DenseMatrix& M) {
+    if (M.rows() == 1) return numext::abs(M(0, 0));
+    JacobiSVD<DenseMatrix> svd(M);
+    return svd.singularValues()(svd.singularValues().size() - 1);
+  }
+
+  Index m_maxBlockSize;
+  Index m_n;
+  Index m_k0;
+  FullPivLU<DenseMatrix> m_luInit;  // LU of the leading T_{k0}
+  std::vector<Step> m_steps;
+  bool m_isInitialized;
+  ComputationInfo m_info;
+  RealScalar m_sMin;
+  RealScalar m_normEst;
+};
+
+template <typename Scalar_>
+template <int Rows_, int Cols_>
+LookAheadLevinson<Scalar_>& LookAheadLevinson<Scalar_>::compute(const Toeplitz<Scalar, Rows_, Cols_>& T) {
+  using internal::structured_tdot;
+  using internal::structured_upshift;
+
+  EIGEN_STATIC_ASSERT(Rows_ == Dynamic || Cols_ == Dynamic || Rows_ == Cols_, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+  eigen_assert(T.rows() == T.cols() && "LookAheadLevinson requires a square Toeplitz matrix");
+  const Index n = T.rows();
+  const DenseVector c = T.column();  // (rho_0, sigma_1, ..., sigma_{n-1})
+  const DenseVector r = T.row();     // (rho_0, rho_1,   ..., rho_{n-1})
+  const Scalar rho0 = c[0];
+
+  m_n = n;
+  m_steps.clear();
+  m_info = Success;
+  m_normEst = c.cwiseAbs().sum() + r.cwiseAbs().sum();  // cheap upper bound on ||T||_2
+
+  Index k;
+  DenseVector y, z;
+  Scalar gamma(0);
+  {
+    Index kbest = 1;
+    RealScalar best = RealScalar(-1);
+    const Index kmax = numext::mini<Index>(m_maxBlockSize, n);
+    for (Index i = 1; i <= kmax; ++i) {
+      RealScalar sv = smallestSingularValue(leadingBlock(c, r, i));
+      if (sv > best) {
+        best = sv;
+        kbest = i;
+      }
+    }
+    k = m_k0 = kbest;
+    m_luInit.compute(leadingBlock(c, r, k));
+    m_sMin = best;
+  }
+
+  bool lastWasBlock = false;
+  DenseVector yPrev, zPrev;
+  Scalar gammaPrev(0);
+  Index kp = 0, pp = 0;
+  DenseMatrix Ypp, Zpp;
+  FullPivLU<DenseMatrix> luGammaPP;
+  DenseVector y_kp_1, z_kp_1;
+
+  if (k < n) {
+    y = m_luInit.transpose().solve((-r.segment(1, k)).eval());  // T_k^T y = -r_k
+    z = m_luInit.solve((-c.segment(1, k)).eval());              // T_k z   = -s_k
+    gamma = rho0 + structured_tdot(c.segment(1, k), y);
+    if (k == 1) {
+      lastWasBlock = false;
+      yPrev = DenseVector::Zero(0);
+      zPrev = DenseVector::Zero(0);
+      gammaPrev = rho0;  // gamma^{(0)}
+    } else {
+      lastWasBlock = true;  // treat init as a block step of size k from order 0
+      kp = 0;
+      pp = k;
+      Ypp = DenseMatrix::Zero(0, k);
+      Zpp = DenseMatrix::Zero(0, k);
+      luGammaPP = m_luInit;
+      y_kp_1 = DenseVector::Zero(0);
+      z_kp_1 = DenseVector::Zero(0);
+    }
+  }
+
+  while (k < n) {
+    const Index pcap = numext::mini<Index>(m_maxBlockSize, n - k);
+    const DenseVector Ek_y = y.reverse(), Ek_z = z.reverse();
+
+    DenseVector g_k, h_k;
+    bool gh_ready = false;
+    auto ensure_gh = [&]() {
+      if (gh_ready) return;
+      if (!lastWasBlock) {
+        // Theorem 1, eq (33)
+        g_k.resize(k);
+        h_k.resize(k);
+        g_k.head(k - 1) = zPrev.reverse();
+        g_k[k - 1] = Scalar(1);
+        g_k /= gammaPrev;
+        h_k.head(k - 1) = yPrev.reverse();
+        h_k[k - 1] = Scalar(1);
+        h_k /= gammaPrev;
+      } else {
+        // Theorem 2: y_{k,1}, z_{k,1} (eqs 47-49), then g_k, h_k (eq 50).
+        DenseVector rhs_y = -r.segment(kp + 2, pp);
+        DenseVector rhs_z = -c.segment(kp + 2, pp);
+        if (kp > 0) {
+          const DenseMatrix Rpp = shiftBlock(r, 1, kp, pp);
+          const DenseMatrix Spp = shiftBlock(c, 1, kp, pp);
+          rhs_y.noalias() -= Rpp.transpose() * y_kp_1.reverse();
+          rhs_z.noalias() -= Spp.transpose() * z_kp_1.reverse();
+        }
+        const DenseVector a_y = luGammaPP.transpose().solve(rhs_y);
+        const DenseVector a_z = luGammaPP.solve(rhs_z);
+        DenseVector yk1 = DenseVector::Zero(k), zk1 = DenseVector::Zero(k);
+        if (kp > 0) {
+          yk1.head(kp) = y_kp_1 + (Zpp * a_y).reverse();
+          zk1.head(kp) = z_kp_1 + (Ypp * a_z).reverse();
+        }
+        yk1.tail(pp) = a_y;
+        zk1.tail(pp) = a_z;
+        const Scalar c1 = -r[k + 1] - structured_tdot(r.segment(1, k), Ek_y);
+        const Scalar d1 = -c[k + 1] - structured_tdot(c.segment(1, k), Ek_z);
+        g_k = (yk1 - structured_upshift<Scalar>(y) + y[0] * y) / c1;
+        h_k = (zk1 - structured_upshift<Scalar>(z) + z[0] * z) / d1;
+      }
+      gh_ready = true;
+    };
+
+    // Build Y_p, Z_p incrementally and pick the block size p (eqs 31-32, 46, 39).
+    DenseMatrix Yp(k, pcap), Zp(k, pcap);
+    Yp.col(0) = y;
+    Zp.col(0) = z;
+    Index chosen = -1;
+    Index bestP = 1;
+    RealScalar bestPsi = RealScalar(-1);
+    DenseMatrix bestGamma;
+
+    for (Index p = 1; p <= pcap; ++p) {
+      if (p >= 2) {
+        ensure_gh();
+        const Index i = p - 1;
+        const Scalar ci = -r[k + i] - structured_tdot(r.segment(i, k), Ek_y);
+        const Scalar di = -c[k + i] - structured_tdot(c.segment(i, k), Ek_z);
+        Yp.col(i) = structured_upshift<Scalar>(Yp.col(i - 1)) - Yp.col(i - 1)[0] * y + ci * g_k;
+        Zp.col(i) = structured_upshift<Scalar>(Zp.col(i - 1)) - Zp.col(i - 1)[0] * z + di * h_k;
+      }
+      const DenseMatrix Sp = shiftBlock(c, 1, k, p);
+      DenseMatrix Gamma = leadingBlock(c, r, p) + Sp.transpose() * Yp.leftCols(p);  // (20)
+      const RealScalar muY = Yp.leftCols(p).cwiseAbs().maxCoeff();
+      const RealScalar muZ = Zp.leftCols(p).cwiseAbs().maxCoeff();
+      const RealScalar denom = numext::maxi(numext::maxi(RealScalar(1), muY), numext::maxi(muZ, muY * muZ));
+      const RealScalar psi = smallestSingularValue(Gamma) / denom;  // (46)
+      if (psi > bestPsi) {
+        bestPsi = psi;
+        bestP = p;
+        bestGamma = Gamma;
+      }
+      if (psi > RealScalar(0.1) * m_sMin) {  // (39)
+        chosen = p;
+        bestGamma = Gamma;
+        break;
+      }
+    }
+
+    DenseMatrix Gamma = bestGamma;
+    Index p;
+    if (chosen > 0) {
+      p = chosen;
+    } else {
+      p = bestP;
+      m_sMin = bestPsi;  // pmax too small to skip cleanly; record the degraded conditioning
+    }
+
+    const Index K = k + p;
+    const bool finalStep = (K == n);
+
+    const DenseMatrix Sp = shiftBlock(c, 1, k, p);
+    const DenseMatrix Rp = shiftBlock(r, 1, k, p);
+    FullPivLU<DenseMatrix> luG(Gamma);
+
+    // Record the b-independent data for solve(): rhs = b_p - (S_p^T E_k) x_k ; x update via E_k Y_p.
+    Step step;
+    step.k = k;
+    step.p = p;
+    step.EkYp = Yp.leftCols(p).colwise().reverse();   // E_k Y_p
+    step.WspEk = Sp.transpose().rowwise().reverse();  // S_p^T E_k
+    step.luGamma = luG;
+    m_steps.push_back(step);
+
+    if (!finalStep) {
+      const DenseVector rhs_e = -r.segment(k + 1, p) - Rp.transpose() * Ek_y;  // (28)
+      const DenseVector rhs_f = -c.segment(k + 1, p) - Sp.transpose() * Ek_z;  // (29)
+      const DenseVector e_p = luG.transpose().solve(rhs_e);
+      const DenseVector f_p = luG.solve(rhs_f);
+
+      DenseVector y_new(K), z_new(K);
+      y_new.head(k) = y + (Zp.leftCols(p) * e_p).reverse();  // (25)
+      y_new.tail(p) = e_p;
+      z_new.head(k) = z + (Yp.leftCols(p) * f_p).reverse();  // (26)
+      z_new.tail(p) = f_p;
+
+      const DenseVector y_save = y, z_save = z;
+      const Scalar gamma_save = gamma;
+      if (p == 1)
+        gamma = (Scalar(1) - e_p[0] * f_p[0]) * gamma;  // (15)
+      else
+        gamma = rho0 + structured_tdot(c.segment(1, K), y_new);  // (5)
+      y = y_new;
+      z = z_new;
+
+      if (p == 1) {
+        lastWasBlock = false;
+        yPrev = y_save;
+        zPrev = z_save;
+        gammaPrev = gamma_save;
+      } else {
+        lastWasBlock = true;
+        kp = k;
+        pp = p;
+        Ypp = Yp.leftCols(p);
+        Zpp = Zp.leftCols(p);
+        luGammaPP = luG;
+        y_kp_1 = Yp.col(1);
+        z_kp_1 = Zp.col(1);
+      }
+    }
+    k = K;
+  }
+
+  const RealScalar kappa = m_sMin > RealScalar(0) ? m_normEst / m_sMin : NumTraits<RealScalar>::infinity();
+  if (!(kappa * NumTraits<RealScalar>::epsilon() < RealScalar(1))) m_info = NumericalIssue;
+  m_isInitialized = true;
+  return *this;
+}
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_LOOK_AHEAD_LEVINSON_H
diff --git a/contrib/Eigen/src/StructuredMatrices/StructuredMatrixUtils.h b/contrib/Eigen/src/StructuredMatrices/StructuredMatrixUtils.h
new file mode 100644
index 0000000..ab4cbd9
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/StructuredMatrixUtils.h
@@ -0,0 +1,574 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] N. J. Higham, "Accuracy and Stability of Numerical Algorithms", 2nd ed.,
+//      SIAM, 2002, chapter 27. Avoiding spurious overflow by rescaling with
+//      powers of two, the technique behind structured_exponent_bound() and the
+//      column scaling in structured_fft_apply() and Bccb::applySymbol().
+//  [2] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, so the scaled transforms introduce
+//      no roundoff beyond the transforms themselves.
+
+#ifndef EIGEN_STRUCTURED_MATRIX_UTILS_H
+#define EIGEN_STRUCTURED_MATRIX_UTILS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// A distinct shape routes assignment through evalTo/addTo/subTo and lets one
+// product specialization cover every product tag without colliding with DenseShape.
+struct StructuredShape {};
+
+// Below this dimension the FFT setup costs more than a plain O(n^2) evaluation,
+// so the structured operators fall back to a direct segment-based product.
+constexpr Index structured_direct_threshold() { return 32; }
+
+// Below this dimension even the segment-based direct product loses to a plain
+// scalar loop: the per-segment setup dominates when the average segment holds
+// fewer than a couple of packets (measured crossover on AVX2 hardware).
+constexpr Index structured_scalar_threshold() { return 16; }
+
+// Numerical scale exponents are independent of Eigen's configurable dimension
+// index. A 32-bit Index can overflow while accumulating O(n^2) factor
+// exponents for dimensions that are otherwise practical.
+using structured_exponent_type = numext::int64_t;
+
+/** \internal Balanced mantissa*2^e arithmetic shared by the structured
+ * operators' determinant-style accumulations (the split fraction/exponent
+ * convention of LINPACK's xGEDI; see the per-class references).
+ * structured_balance() rescales \a z by the power of two that brings
+ * \c max(|re|,|im|) (the modulus can overflow where the components do not) --
+ * or \c |z| for a real scalar -- into [0.5, 1), accumulating the removed
+ * exponent into \a exponent. The rescaling is exact, so no roundoff is
+ * introduced; zeros and non-finite values, which must propagate exactly, are
+ * returned untouched. */
+template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct structured_balance_impl {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  template <typename Exponent>
+  static Scalar run(const Scalar& z, Exponent& exponent) {
+    const RealScalar mag = numext::maxi(numext::abs(numext::real(z)), numext::abs(numext::imag(z)));
+    if (!(mag > RealScalar(0)) || !(numext::isfinite)(mag)) return z;
+    int e;
+    EIGEN_USING_STD(frexp);
+    frexp(mag, &e);
+    exponent += e;
+    return Scalar(numext::ldexp(numext::real(z), -e), numext::ldexp(numext::imag(z), -e));
+  }
+  static Scalar apply_exponent(const Scalar& z, int e) {
+    return Scalar(numext::ldexp(numext::real(z), e), numext::ldexp(numext::imag(z), e));
+  }
+};
+
+template <typename Scalar>
+struct structured_balance_impl<Scalar, false> {
+  template <typename Exponent>
+  static Scalar run(const Scalar& x, Exponent& exponent) {
+    const Scalar mag = numext::abs(x);
+    if (!(mag > Scalar(0)) || !(numext::isfinite)(mag)) return x;
+    int e;
+    EIGEN_USING_STD(frexp);
+    frexp(mag, &e);
+    exponent += e;
+    return numext::ldexp(x, -e);
+  }
+  static Scalar apply_exponent(const Scalar& x, int e) { return numext::ldexp(x, e); }
+};
+
+template <typename Scalar, typename Exponent>
+Scalar structured_balance(const Scalar& z, Exponent& exponent) {
+  return structured_balance_impl<Scalar>::run(z, exponent);
+}
+
+/** \internal Applies an accumulated power-of-two \a exponent to \a z,
+ * component-wise for complex scalars. ldexp saturates cleanly to zero /
+ * infinity (preserving signs) once the exponent leaves the representable
+ * range; the clamp only guards the narrowing to int. */
+template <typename Scalar, typename Exponent>
+Scalar structured_ldexp_clamped(const Scalar& z, Exponent exponent) {
+  constexpr Exponent kMaxExponent = Exponent(1) << 24;
+  const int e = static_cast<int>(numext::mini(numext::maxi(exponent, -kMaxExponent), kMaxExponent));
+  return structured_balance_impl<Scalar>::apply_exponent(z, e);
+}
+
+/** \internal \returns 1 / \a z, formed in a balanced frame where the direct
+ * reciprocal is unreliable: near the representable boundary both conj(z)/|z|^2
+ * and Smith's algorithm (internal::complex_divide_fast and _smith) overflow to
+ * zero when |Re z| and |Im z| are each around half the largest finite value.
+ * Balancing puts the larger component in [0.5, 1), where the reciprocal is
+ * always representable, and both rescalings are exact. Zeros and non-finite
+ * values pass through structured_balance() untouched. */
+template <typename Scalar>
+Scalar structured_scaled_reciprocal(const Scalar& z) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  const RealScalar mag = numext::maxi(numext::abs(numext::real(z)), numext::abs(numext::imag(z)));
+  const RealScalar m2 = mag * mag;
+  // Where |z|^2 <= 2*mag^2 is normal, no implementation of the reciprocal can
+  // overflow or underflow, so only the remaining entries pay for the balancing.
+  if (m2 >= (std::numeric_limits<RealScalar>::min)() && (numext::isfinite)(m2 + m2)) return Scalar(1) / z;
+  Index e = 0;
+  const Scalar zs = structured_balance(z, e);
+  return structured_ldexp_clamped(Scalar(1) / zs, -e);
+}
+
+template <typename RealScalar>
+struct structured_reciprocal_packet_traits {
+  // These backends provide interleaved complex packets, ploaddup and mask reductions.
+#if defined(EIGEN_VECTORIZE_SSE2)
+  static constexpr bool Vectorizable =
+      std::is_same<RealScalar, float>::value || std::is_same<RealScalar, double>::value;
+#else
+  static constexpr bool Vectorizable = false;
+#endif
+};
+
+template <typename RealScalar, bool ApplyThreshold,
+          bool Vectorize = structured_reciprocal_packet_traits<RealScalar>::Vectorizable>
+struct structured_symbol_reciprocal_impl {
+  using Complex = std::complex<RealScalar>;
+  static void run(const Complex* symbol, const RealScalar* moduli, RealScalar tol, Complex* inverse, Index size) {
+    for (Index k = 0; k < size; ++k)
+      inverse[k] = ApplyThreshold && moduli[k] < tol ? Complex(0) : structured_scaled_reciprocal(symbol[k]);
+  }
+};
+
+template <typename RealScalar, bool ApplyThreshold>
+struct structured_symbol_reciprocal_impl<RealScalar, ApplyThreshold, true> {
+  using Complex = std::complex<RealScalar>;
+  using Packet = typename packet_traits<Complex>::type;
+  using RealPacket = typename unpacket_traits<Packet>::as_real;
+
+  EIGEN_DONT_INLINE static void run(const Complex* symbol, const RealScalar* moduli, RealScalar tol, Complex* inverse,
+                                    Index size) {
+    constexpr Index kPacketSize = unpacket_traits<Packet>::size;
+    const Packet zero = pset1<Packet>(Complex(0));
+    const Packet safe_value = pset1<Packet>(Complex(1, 1));
+    const RealPacket threshold = pset1<RealPacket>(tol);
+    // min_normal <= mag^2 and 2*mag^2 <= 2^(max_exponent-1) < max_finite.
+    const RealPacket lower =
+        pset1<RealPacket>(numext::ldexp(RealScalar(1), std::numeric_limits<RealScalar>::min_exponent / 2));
+    const RealPacket upper =
+        pset1<RealPacket>(numext::ldexp(RealScalar(1), std::numeric_limits<RealScalar>::max_exponent / 2 - 1));
+    const Index packet_end = size - size % kPacketSize;
+    Index k = 0;
+    for (; k < packet_end; k += kPacketSize) {
+      const RealPacket discard = ApplyThreshold ? pcmp_lt(ploaddup<RealPacket>(moduli + k), threshold) : zero.v;
+      // Sanitize before arithmetic: selecting the output alone still divides discarded zeros.
+      const Packet z = pselect(Packet(discard), safe_value, ploadu<Packet>(symbol + k));
+      const RealPacket a = pabs(z.v);
+      const RealPacket mag = pmax(a, pcplxflip(Packet(a)).v);
+      // Zero components use the scalar path to preserve std::complex's signed-zero choices.
+      const RealPacket safe = pand(pand(pcmp_le(lower, mag), pcmp_le(mag, upper)), pcmp_lt(zero.v, a));
+      if (!predux_any(pandnot(ptrue(safe), safe))) {
+        const RealPacket square = pmul(z.v, z.v);
+        const RealPacket denom = padd(square, pcplxflip(Packet(square)).v);
+        const Packet reciprocal(pdiv(pconj(z).v, denom));
+        // Underflowed components also retain the scalar signed-zero convention.
+        if (!predux_any(pcmp_eq(reciprocal.v, zero.v))) {
+          pstoreu(inverse + k, pselect(Packet(discard), zero, reciprocal));
+          continue;
+        }
+      }
+      structured_symbol_reciprocal_impl<RealScalar, ApplyThreshold, false>::run(
+          symbol + k, ApplyThreshold ? moduli + k : nullptr, tol, inverse + k, kPacketSize);
+    }
+    if (k < size)
+      structured_symbol_reciprocal_impl<RealScalar, ApplyThreshold, false>::run(
+          symbol + k, ApplyThreshold ? moduli + k : nullptr, tol, inverse + k, size - k);
+  }
+};
+
+// The input and output may alias exactly. Threshold equality and NaN moduli are retained.
+template <typename RealScalar>
+void structured_symbol_reciprocal(const std::complex<RealScalar>* symbol, const RealScalar* moduli, RealScalar tol,
+                                  std::complex<RealScalar>* inverse, Index size) {
+  structured_symbol_reciprocal_impl<RealScalar, true>::run(symbol, moduli, tol, inverse, size);
+}
+
+// True inverses retain every mode and reuse the symbol storage without allocating a modulus array.
+template <typename RealScalar>
+void structured_symbol_reciprocal(std::complex<RealScalar>* symbol, Index size) {
+  structured_symbol_reciprocal_impl<RealScalar, false>::run(symbol, nullptr, RealScalar(0), symbol, size);
+}
+
+/** \internal \returns \c a - b guarded against spurious overflow: when the
+ * plain difference of two finite values overflows to infinity, it is
+ * recomputed from the halved operands with \a e set to 1 so the caller can
+ * carry the factor of two in its running exponent (the balanced accumulations
+ * fold it into \c exponent at the call site). The recomputation is exact where
+ * it matters: a difference of finite values only overflows when both operands
+ * are huge, normal values, whose halves and halved difference are exactly
+ * representable. For complex scalars the finiteness tests are component-wise;
+ * a subnormal component riding along with a huge one loses its last bit to the
+ * halving, an error far below one ulp of the factor's magnitude. Non-finite
+ * operands (genuine Inf/NaN nodes) propagate untouched, with \a e = 0. */
+template <typename Scalar>
+Scalar structured_guarded_diff(const Scalar& a, const Scalar& b, int& e) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  e = 0;
+  const Scalar t = a - b;
+  if ((numext::isfinite)(t) || !(numext::isfinite)(a) || !(numext::isfinite)(b)) return t;
+  e = 1;
+  return a * RealScalar(0.5) - b * RealScalar(0.5);
+}
+
+/** \internal \returns the indices sorted by decreasing precomputed modulus
+ * \a mods (each modulus is computed once, not on every comparison); the shared
+ * ordering of the operators' singularValues()/matrixU()/matrixV(). The sort is
+ * stable so repeated calls agree even in the presence of ties, and NaN moduli
+ * order last (comparing through NaN directly would break the strict weak
+ * ordering std::stable_sort requires). */
+template <typename RealVectorType>
+std::vector<Index> structured_svd_permutation(const RealVectorType& mods) {
+  using RealScalar = typename RealVectorType::Scalar;
+  std::vector<Index> perm;
+  perm.reserve(static_cast<std::size_t>(mods.size()));
+  for (Index k = 0; k < mods.size(); ++k) perm.push_back(k);
+  std::stable_sort(perm.begin(), perm.end(), [&mods](Index a, Index b) {
+    const RealScalar ka = mods[a], kb = mods[b];
+    // isgreater is quiet for NaNs; the second clause implements NaN-last ordering.
+    return std::isgreater(ka, kb) || (!(numext::isnan)(ka) && (numext::isnan)(kb));
+  });
+  return perm;
+}
+
+/** \internal \returns the per-thread FFT engine shared by all structured
+ * operators. The kissfft backend caches its twiddle/plan tables per transform
+ * size inside the engine, so reusing one engine amortizes the plan setup that a
+ * per-call engine would redo on every product, solve and symbol computation
+ * (the tables themselves are identical, so results are bit-for-bit unchanged).
+ * One engine per thread keeps concurrent products on the same operator free of
+ * data races; the cache grows with the number of distinct transform sizes a
+ * thread touches, which mirrors the operators it works with.
+ *
+ * Under EIGEN_AVOID_THREAD_LOCAL -- the library-wide opt-out for targets
+ * without usable `thread_local` (see Core's Memory.h and ThreadPool's
+ * ThreadLocal.h) -- each call returns a fresh engine by value instead: the
+ * plan tables are rebuilt per call, the results are identical. Callers bind
+ * the engine with `auto&&`, which works for both signatures. */
+#ifndef EIGEN_AVOID_THREAD_LOCAL
+template <typename RealScalar>
+FFT<RealScalar>& structured_fft_engine() {
+  static thread_local FFT<RealScalar> fft;
+  return fft;
+}
+#else
+template <typename RealScalar>
+FFT<RealScalar> structured_fft_engine() {
+  return FFT<RealScalar>();
+}
+#endif
+
+/** \internal
+ * \returns the smallest integer >= \a n whose only prime factors are 2, 3 and 5.
+ *
+ * Such "5-smooth" sizes keep the FFT fast and sidestep the default kissfft
+ * backend's poor handling of sizes with large prime factors. Used to pad the
+ * circulant embedding of a Toeplitz matrix. The {2,3,5}-smooth numbers are dense
+ * enough that the linear search returns after only a handful of steps.
+ */
+inline Index fft_next_good_size(Index n) {
+  if (n < 1) return 1;
+  for (Index m = n;; ++m) {
+    Index r = m;
+    while (r % 2 == 0) r /= 2;
+    while (r % 3 == 0) r /= 3;
+    while (r % 5 == 0) r /= 5;
+    if (r == 1) return m;
+  }
+}
+
+/** \internal View a complex-valued expression as \a Scalar: the expression itself
+ * when \a Scalar is complex, its real part when \a Scalar is real (the imaginary
+ * part then only holds numerically negligible roundoff). \c run_scalar is the
+ * single-coefficient analogue. A single dispatch struct keeps the number of
+ * instantiated helpers down to one per scalar type. */
+template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
+struct structured_scalar_part_impl {
+  template <typename Xpr>
+  static const Xpr& run(const Xpr& xpr) {
+    return xpr;
+  }
+  static const Scalar& run_scalar(const Scalar& x) { return x; }
+};
+
+template <typename Scalar>
+struct structured_scalar_part_impl<Scalar, false> {
+  template <typename Xpr>
+  static typename Xpr::RealReturnType run(const Xpr& xpr) {
+    return xpr.real();
+  }
+  static Scalar run_scalar(const std::complex<Scalar>& x) { return numext::real(x); }
+};
+
+/** \internal Computes an exponent bound \c e with \c max_k|x[k]| < 2^e (0 when
+ * \a x is zero or reduces to a non-finite maximum) and \returns whether \a x is
+ * safe for the transforms, from a single plain (fast-max) reduction pass. The
+ * bound is derived from the component-wise magnitudes, never from the modulus:
+ * a finite complex value near the overflow threshold has a non-representable
+ * modulus, which would silently disable the overflow-protection scaling exactly
+ * where it is needed. Bounding the modulus by twice the largest component costs
+ * at most one extra bit.
+ *
+ * The routing predicate deliberately uses the fast max reduction, which is not
+ * guaranteed to propagate NaN (the NaN-propagating reduction de-vectorizes to a
+ * branchy scalar loop on strided component views). That is sufficient: an Inf
+ * in NaN-free data always surfaces in the maximum (every comparison is
+ * ordered), and a column containing NaN produces the all-NaN output the dense
+ * product semantics require through *either* path -- every dot product picks
+ * up a coeff*NaN term, and the transforms propagate NaN just the same -- so
+ * missing a NaN here cannot change the result. */
+template <typename Xpr>
+bool structured_exponent_bound_finite(const Xpr& x, int& e) {
+  using ScalarTraits = NumTraits<typename Xpr::Scalar>;
+  using RealScalar = typename ScalarTraits::Real;
+  // maxCoeff() asserts on an empty input, and a degenerate operand -- a rank-0
+  // factor, a solve with no right-hand sides -- reaches here legitimately.
+  // An empty operand bounds nothing, so its exponent bound is 0.
+  e = 0;
+  if (x.size() == 0) return true;
+  RealScalar m;
+  if (ScalarTraits::IsComplex)
+    // realView() reduces over both components in one pass, vectorized for
+    // direct-access storage; the strided real()/imag() views never vectorize.
+    m = x.realView().cwiseAbs().maxCoeff();
+  else
+    m = x.cwiseAbs().maxCoeff();
+  e = 0;
+  if (!(numext::isfinite)(m)) return false;
+  if (m > RealScalar(0)) {
+    EIGEN_USING_STD(frexp);
+    frexp(m, &e);
+    if (ScalarTraits::IsComplex) ++e;
+  }
+  return true;
+}
+
+/** \internal The exponent bound alone (see structured_exponent_bound_finite()),
+ * for callers that handle non-finite data separately: the bound is 0 there. */
+template <typename Xpr>
+int structured_exponent_bound(const Xpr& x) {
+  int e;
+  structured_exponent_bound_finite(x, e);
+  return e;
+}
+
+/** \internal \returns the index reversal of a DFT \a symbol: result[k] =
+ * symbol[(p - k) mod p]. This is the symbol of the transposed operator: reversing
+ * the generating sequence in index space reverses the frequencies of its DFT, for
+ * both a circulant generator and the circulant embedding of a Toeplitz matrix.
+ * An empty symbol (small operator, nothing cached) stays empty. */
+template <typename ComplexVectorType>
+ComplexVectorType structured_reverse_symbol(const ComplexVectorType& symbol) {
+  const Index p = symbol.size();
+  ComplexVectorType reversed(p);
+  if (p > 0) {
+    reversed[0] = symbol[0];
+    reversed.tail(p - 1) = symbol.tail(p - 1).reverse();
+  }
+  return reversed;
+}
+
+/** \internal Default pointwise step: multiply the transformed column by the symbol. */
+struct structured_symbol_multiply {
+  template <typename SymbolType>
+  int exponent_growth(const SymbolType& symbol) const {
+    return structured_exponent_bound(symbol);
+  }
+  template <typename XfType, typename SymbolType>
+  void operator()(XfType& xf, const SymbolType& symbol) const {
+    xf.array() *= symbol.array();
+  }
+};
+
+/** \internal
+ * By default computes
+ * \c dst.col(k) += alpha * ifft( symbol .* fft(rhs.col(k)) ) for every column of
+ * \a rhs, i.e. applies the circulant operator whose eigenvalues are \a symbol.
+ * A caller may supply another pointwise operation with its matching exponent
+ * growth bound. The leading \a outSize entries of each back-transform form the
+ * corresponding output column. All workspace is allocated once outside the
+ * per-column loop; right-hand sides shorter than the transform length are
+ * zero-padded into the preallocated buffer so the FFT never re-allocates.
+ *
+ * The transforms accumulate up to \c p addends, so a finite column near the
+ * overflow threshold (or one applied through a symbol of huge magnitude) would
+ * overflow inside the FFT and turn a representable result into Inf/NaN. Each
+ * column is therefore scaled down by a power of two -- an exact shift, no
+ * roundoff -- derived from the column's exponent and the pointwise operation's
+ * maximum exponent growth, and the exponent is folded back into the output after
+ * the back-transform. The scale is one whenever the conservative intermediate
+ * bound cannot overflow, so results are bit-identical for inputs of moderate
+ * magnitude; zero columns are never scaled. If \f$|x_i|<2^c\f$ and the pointwise
+ * operation magnifies by less than \f$2^g\f$, its result and both transforms are
+ * bounded by
+ * \f[ 2^{c+g+2\lceil\log_2 p\rceil+1}. \f]
+ *
+ * Genuinely non-finite data must not go through the transforms: they mix every
+ * input entry into every output entry, so a single special value would
+ * contaminate the whole column with NaN where the dense product only propagates
+ * it through the dot products that touch it. A non-finite symbol is the
+ * caller's responsibility (the operators route it to their direct kernels up
+ * front); a non-finite column is detected here -- in the same single pass that
+ * derives its scaling exponent -- and handed to \a directColumn, the caller's
+ * per-column direct kernel, so the remaining columns keep the fast path.
+ */
+template <typename Scalar, typename Dest, typename Rhs, typename DirectColumn,
+          typename Pointwise = structured_symbol_multiply>
+void structured_fft_apply(Dest& dst, const Matrix<std::complex<typename NumTraits<Scalar>::Real>, Dynamic, 1>& symbol,
+                          Index outSize, const Rhs& rhs, const Scalar& alpha, DirectColumn&& directColumn,
+                          Pointwise pointwise = Pointwise(), Index outExpAdjust = 0) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Complex = std::complex<RealScalar>;
+  using ComplexVector = Matrix<Complex, Dynamic, 1>;
+
+  const Index p = symbol.size();
+  eigen_assert(rhs.rows() <= p && outSize <= p);
+
+  // Growth of the pointwise step -- max|symbol| for a multiply, the largest
+  // retained reciprocal for a divide -- included in the pre-scaling so a
+  // representable result cannot overflow before the output rescaling.
+  const int pointwiseExp = pointwise.exponent_growth(symbol);
+
+  if (p == 1) {
+    // The length-one DFT is the identity and is unsupported by kissfft. The
+    // pointwise step still runs, scaled around just as the transforms are on the
+    // general path.
+    const int budget = NumTraits<RealScalar>::max_exponent() - 2;
+    ComplexVector xf(1);
+    for (Index k = 0; k < rhs.cols(); ++k) {
+      int colExp;
+      if (!structured_exponent_bound_finite(rhs.col(k), colExp)) {
+        directColumn(k);
+        continue;
+      }
+      const int e = numext::maxi(colExp + pointwiseExp - budget, 0);
+      const RealScalar down1 = numext::ldexp(RealScalar(1), -(e / 2)),
+                       down2 = numext::ldexp(RealScalar(1), -(e - e / 2));
+      const int eo = e - static_cast<int>(outExpAdjust);
+      const RealScalar up1 = numext::ldexp(RealScalar(1), eo / 2), up2 = numext::ldexp(RealScalar(1), eo - eo / 2);
+      xf.coeffRef(0) = static_cast<Complex>((rhs.coeff(0, k) * down1) * down2);
+      pointwise(xf, symbol);
+      dst.coeffRef(0, k) += alpha * structured_scalar_part_impl<Scalar>::run_scalar((xf.coeff(0) * up1) * up2);
+    }
+    return;
+  }
+
+  // The bit width of p (>= 1 here), an upper bound for the ceil(log2 p) of the
+  // magnitude bound above -- one bit looser at power-of-two transform lengths.
+  const int log2p = log2_floor(static_cast<std::make_unsigned_t<Index>>(p)) + 1;
+  const int budget = NumTraits<RealScalar>::max_exponent() - 2 * log2p - 2;
+
+  auto&& fft = structured_fft_engine<RealScalar>();
+  ComplexVector xt = ComplexVector::Zero(p);
+  ComplexVector xf(p), yt(p);
+  for (Index k = 0; k < rhs.cols(); ++k) {
+    int colExp;  // 0 for an all-zero column: no scaling
+    if (!structured_exponent_bound_finite(rhs.col(k), colExp)) {
+      directColumn(k);
+      continue;
+    }
+    const int e = numext::maxi(colExp + pointwiseExp - budget, 0);
+    // Each power of two is split in halves so that the factors themselves stay
+    // inside the exponent range even when e exceeds it (a huge column applied
+    // through a huge symbol); scaling by the two exact factors in sequence is
+    // still an exact shift wherever the result is representable.
+    const RealScalar down1 = numext::ldexp(RealScalar(1), -(e / 2)), down2 = numext::ldexp(RealScalar(1), -(e - e / 2));
+    // A caller that pre-balanced the symbol passes its exponent in outExpAdjust,
+    // so the pointwise step sees an O(1) symbol whose result never passes through
+    // a subnormal; the exponent is folded back into the output here.
+    const int eo = e - static_cast<int>(outExpAdjust);
+    const RealScalar up1 = numext::ldexp(RealScalar(1), eo / 2), up2 = numext::ldexp(RealScalar(1), eo - eo / 2);
+    xt.head(rhs.rows()) = ((rhs.col(k) * down1) * down2).template cast<Complex>();
+    fft.fwd(xf, xt, p);
+    pointwise(xf, symbol);
+    fft.inv(yt, xf, p);
+    dst.col(k) += alpha * structured_scalar_part_impl<Scalar>::run((yt.head(outSize) * up1) * up2);
+  }
+}
+
+/** \internal Overload for callers that guarantee finite right-hand-side data
+ * (e.g. solve(), which checks its input up front and takes a dedicated
+ * pseudo-inverse fallback otherwise): a non-finite column has no direct kernel
+ * here and would be skipped, so it asserts. */
+template <typename Scalar, typename Dest, typename Rhs>
+void structured_fft_apply(Dest& dst, const Matrix<std::complex<typename NumTraits<Scalar>::Real>, Dynamic, 1>& symbol,
+                          Index outSize, const Rhs& rhs, const Scalar& alpha) {
+  structured_fft_apply(dst, symbol, outSize, rhs, alpha,
+                       [](Index) { eigen_assert(false && "non-finite column requires a direct kernel"); });
+}
+
+/** \internal Pointwise step for the pseudo-inverse solve: divides by the symbol
+ * instead of multiplying by its reciprocal, since the reciprocal of an entry near
+ * the representable boundary is subnormal -- and lost under flush-to-zero -- while
+ * the quotient stays normal. Entries below the rank threshold are zeroed, matching
+ * the pseudo-inverse convention. */
+template <typename ModsType, typename RealScalar>
+struct structured_symbol_divide {
+  const ModsType* mods;
+  RealScalar tol;
+  template <typename SymbolType>
+  int exponent_growth(const SymbolType&) const {
+    if (mods->size() == 0) return 0;
+    const auto retained = (RealScalar(1) - mods->cwiseTypedLess(tol).array()) *
+                          mods->cwiseTypedGreater(RealScalar(0)).array() * mods->array().isFiniteTyped();
+    const RealScalar smallest = retained.select(mods->array(), NumTraits<RealScalar>::infinity()).minCoeff();
+    if (!(numext::isfinite)(smallest)) return 0;
+    int modExp;
+    EIGEN_USING_STD(frexp);
+    frexp(smallest, &modExp);
+    // The smallest retained modulus maximizes 2-frexp(mod).exponent.
+    return numext::maxi(0, 2 - modExp);
+  }
+  template <typename XfType, typename SymbolType>
+  void operator()(XfType& xf, const SymbolType& symbol) const {
+    using Complex = std::complex<RealScalar>;
+    xf.array() = (mods->array() < tol).select(Complex(0), xf.array() / symbol.array());
+  }
+};
+
+/** \internal Shared product implementation for the structured operator types.
+ * Forwards to the operator's \c addProduct member, which performs the fast
+ * matrix-vector product. The same body serves every dense product dispatch tag.
+ *
+ * The structured products carry the default product tag, so assignment has the
+ * ordinary dense-product semantics: \c x = op * expr first materializes the
+ * product into a temporary, which resolves every form of aliasing between the
+ * destination and the right-hand side (same object, overlapping views,
+ * expressions referencing the destination, destinations resized by the
+ * assignment), and \c .noalias() skips the temporary under the usual caller
+ * promise that no aliasing exists. */
+template <typename Op, typename Rhs>
+struct structured_product_impl : generic_product_impl_base<Op, Rhs, structured_product_impl<Op, Rhs>> {
+  using Scalar = typename Product<Op, Rhs>::Scalar;
+
+  template <typename Dest>
+  static void evalTo(Dest& dst, const Op& lhs, const Rhs& rhs) {
+    dst.setZero();
+    scaleAndAddTo(dst, lhs, rhs, Scalar(1));
+  }
+
+  template <typename Dest>
+  static void scaleAndAddTo(Dest& dst, const Op& lhs, const Rhs& rhs, const Scalar& alpha) {
+    using RhsNested = typename nested_eval<Rhs, Op::RowsAtCompileTime>::type;
+    RhsNested actualRhs(rhs);
+    lhs.addProduct(dst, actualRhs, alpha);
+  }
+};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_MATRIX_UTILS_H
diff --git a/contrib/Eigen/src/StructuredMatrices/Toeplitz.h b/contrib/Eigen/src/StructuredMatrices/Toeplitz.h
new file mode 100644
index 0000000..a166c2b
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/Toeplitz.h
@@ -0,0 +1,375 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] R. M. Gray, "Toeplitz and Circulant Matrices: A Review", Foundations and
+//      Trends in Communications and Information Theory, 2(3), 2006.
+//  [2] G. H. Golub and C. F. Van Loan, "Matrix Computations", 4th ed., Johns
+//      Hopkins University Press, 2013, chapter 4.8 (fast Toeplitz products via
+//      circulant embedding and the FFT).
+
+#ifndef EIGEN_STRUCTURED_TOEPLITZ_H
+#define EIGEN_STRUCTURED_TOEPLITZ_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int Rows_ = Dynamic, int Cols_ = Dynamic>
+class Toeplitz;
+
+namespace internal {
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct traits<Toeplitz<Scalar_, Rows_, Cols_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  // Deliberately no NestByRefBit: transpose(), conjugate() and adjoint() return
+  // owning temporaries, so Product must nest the operator by value for a
+  // delayed-evaluated product expression to keep its left factor alive. The copy
+  // is O(m+n), negligible against the O(n log n) product evaluation.
+  static constexpr int Flags = 0;
+};
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct evaluator_traits<Toeplitz<Scalar_, Rows_, Cols_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class Toeplitz
+ * \brief An \c m x \c n Toeplitz matrix represented by its first column and row.
+ *
+ * For first column \f$c\f$ and first row \f$r\f$,
+ * \f[ T_{ij}=\begin{cases}c_{i-j},&i\ge j,\\r_{j-i},&i<j.\end{cases} \f]
+ * The diagonal is taken from \f$c\f$, so \f$r_0\f$ is ignored.
+ *
+ * The matrix-vector product (\c operator*) is evaluated in O(n log n) by
+ * embedding the Toeplitz matrix in a larger circulant matrix, whose DFT symbol is
+ * computed once at construction. As with \ref Circulant, \c operator* returns an
+ * Eigen product expression, so a \c Toeplitz also plugs into the matrix-free
+ * iterative solvers, and it can be assigned to a dense matrix when an explicit
+ * representation is needed. As with any matrix-free operator, the iterative
+ * solvers must be instantiated with \c IdentityPreconditioner (e.g.
+ * \c LeastSquaresConjugateGradient<Toeplitz<double>,IdentityPreconditioner>):
+ * the default preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * \tparam Scalar_ the scalar type, real or complex.
+ * \tparam Rows_ the number of rows at compile time, or \c Dynamic (the default).
+ * \tparam Cols_ the number of columns at compile time, or \c Dynamic (the default).
+ *
+ * \sa class Circulant, makeToeplitz()
+ */
+template <typename Scalar_, int Rows_, int Cols_>
+class Toeplitz : public EigenBase<Toeplitz<Scalar_, Rows_, Cols_>> {
+ public:
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  using Complex = std::complex<RealScalar>;
+  using ColGeneratorType = Matrix<Scalar, Rows_, 1>;
+  using RowGeneratorType = Matrix<Scalar, Cols_, 1>;
+  using ComplexVector = Matrix<Complex, Dynamic, 1>;
+
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Rows_, Cols_);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr bool IsRowMajor = false;
+  // Deliberately no IsVectorAtCompileTime: Ref<const Toeplitz>'s default StrideType
+  // argument reads it, so its absence makes internal::is_ref_compatible SFINAE to
+  // false and keeps the iterative solvers on their matrix-free path.
+
+  /** Builds a Toeplitz matrix from its first column \a col and first row \a row.
+   * The diagonal is taken from \a col, hence \c row[0] is ignored.
+   *
+   * Unless the matrix is small enough for products to always take the direct
+   * path, it is embedded into a circulant matrix of 5-smooth size p >= m+n-1
+   * whose first column is \c [c; 0...0; r[n-1], ..., r[1]]; multiplying that
+   * circulant by \c [x; 0] reproduces the Toeplitz product in its leading \c m
+   * entries. The circulant's DFT symbol is computed here, once, and reused by
+   * every subsequent product. */
+  template <typename ColDerived, typename RowDerived>
+  Toeplitz(const MatrixBase<ColDerived>& col, const MatrixBase<RowDerived>& row) : m_col(col), m_row(row) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(ColDerived)
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(RowDerived)
+    eigen_assert(m_col.size() > 0 && m_row.size() > 0 && "Toeplitz generators must be non-empty");
+    // Below the threshold every product takes the direct path and the symbol has
+    // no consumer, so skip the embedding altogether.
+    if (rows() > internal::structured_direct_threshold() || cols() > internal::structured_direct_threshold())
+      m_symbol = computeSymbol();
+    m_fftUsable = computeFftUsable();
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_col.size(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_row.size(); }
+
+  /** \returns the generating first column. */
+  const ColGeneratorType& column() const { return m_col; }
+  /** \returns the generating first row. */
+  const RowGeneratorType& row() const { return m_row; }
+
+  /** \returns the symbol of the circulant embedding, i.e. the DFT of the first
+   * column of the size-p circulant matrix the operator is embedded in. Cached
+   * when the operator is large enough for products to take the FFT path,
+   * computed on the fly for small operators. */
+  ComplexVector symbol() const { return m_symbol.size() > 0 ? m_symbol : computeSymbol(); }
+
+  /** \returns the coefficient at row \a row and column \a col. */
+  Scalar coeff(Index row, Index col) const {
+    Index k = row - col;
+    return k >= 0 ? m_col.coeff(k) : m_row.coeff(-k);
+  }
+
+  /** \returns the transpose of \c *this, itself a Toeplitz operator with the
+   * generators swapped (the new first column is the old first row, with its
+   * leading entry set to the diagonal value \c column()[0]). The cached embedding
+   * symbol, when present, is reused -- the symbol of the transpose is the index
+   * reversal of the symbol -- so no FFT is recomputed. */
+  Toeplitz<Scalar, Cols_, Rows_> transpose() const {
+    using TransposeType = Toeplitz<Scalar, Cols_, Rows_>;
+    const Index n = cols();
+    typename TransposeType::ColGeneratorType col(n);
+    col[0] = m_col[0];
+    if (n > 1) col.tail(n - 1) = m_row.tail(n - 1);
+    return TransposeType(col, m_col, internal::structured_reverse_symbol(m_symbol));
+  }
+
+  /** \returns the complex conjugate of \c *this, itself a Toeplitz operator. The
+   * cached embedding symbol, when present, is reused: the symbol of the conjugate
+   * is the conjugated index reversal of the symbol. */
+  Toeplitz conjugate() const {
+    return Toeplitz(m_col.conjugate(), m_row.conjugate(), internal::structured_reverse_symbol(m_symbol).conjugate());
+  }
+
+  /** \returns the adjoint of \c *this, itself a Toeplitz operator (the conjugated
+   * transpose). The cached embedding symbol, when present, is reused: the symbol
+   * of the adjoint is the elementwise conjugate of the symbol. */
+  Toeplitz<Scalar, Cols_, Rows_> adjoint() const {
+    using AdjointType = Toeplitz<Scalar, Cols_, Rows_>;
+    const Index n = cols();
+    typename AdjointType::ColGeneratorType col(n);
+    col[0] = numext::conj(m_col[0]);
+    if (n > 1) col.tail(n - 1) = m_row.tail(n - 1).conjugate();
+    return AdjointType(col, m_col.conjugate(), m_symbol.conjugate());
+  }
+
+  /** \internal Writes the dense representation into \a dst; the head of column
+   * \c j is a reversed slice of the row generator (entry \c i holds \c r[j-i])
+   * and its tail the leading part of the column generator. Row-major destinations
+   * use the corresponding row segments. Invoked through \c dense = toeplitz; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    const Index m = rows(), n = cols();
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < m; ++i) {
+        const Index h = numext::mini(i + 1, n);
+        dst.row(i).head(h) = m_col.segment(i - h + 1, h).reverse().transpose();
+        if (i + 1 < n) dst.row(i).tail(n - i - 1) = m_row.segment(1, n - i - 1).transpose();
+      }
+      return;
+    }
+    for (Index j = 0; j < n; ++j) {
+      const Index h = numext::mini(j, m);
+      dst.col(j).head(h) = m_row.segment(j - h + 1, h).reverse();
+      if (j < m) dst.col(j).tail(m - j) = m_col.head(m - j);
+    }
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    const Index m = rows(), n = cols();
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < m; ++i) {
+        const Index h = numext::mini(i + 1, n);
+        dst.row(i).head(h) += m_col.segment(i - h + 1, h).reverse().transpose();
+        if (i + 1 < n) dst.row(i).tail(n - i - 1) += m_row.segment(1, n - i - 1).transpose();
+      }
+      return;
+    }
+    for (Index j = 0; j < n; ++j) {
+      const Index h = numext::mini(j, m);
+      dst.col(j).head(h) += m_row.segment(j - h + 1, h).reverse();
+      if (j < m) dst.col(j).tail(m - j) += m_col.head(m - j);
+    }
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    const Index m = rows(), n = cols();
+    EIGEN_IF_CONSTEXPR (Dest::IsRowMajor) {
+      for (Index i = 0; i < m; ++i) {
+        const Index h = numext::mini(i + 1, n);
+        dst.row(i).head(h) -= m_col.segment(i - h + 1, h).reverse().transpose();
+        if (i + 1 < n) dst.row(i).tail(n - i - 1) -= m_row.segment(1, n - i - 1).transpose();
+      }
+      return;
+    }
+    for (Index j = 0; j < n; ++j) {
+      const Index h = numext::mini(j, m);
+      dst.col(j).head(h) -= m_row.segment(j - h + 1, h).reverse();
+      if (j < m) dst.col(j).tail(m - j) -= m_col.head(m - j);
+    }
+  }
+
+  /** \returns the product expression \c (*this) * \a x, evaluated through a fast
+   * FFT-based matrix-vector product (circulant embedding). The expression carries
+   * the default product tag, so assigning it behaves like any dense product: a
+   * temporary resolves aliasing between the destination and \a x, and
+   * \c .noalias() skips it. */
+  template <typename Rhs>
+  Product<Toeplitz, Rhs> operator*(const MatrixBase<Rhs>& x) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(x.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<Toeplitz, Rhs>(*this, x.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs. \c ProductScalar is the
+   * promoted scalar of the product (complex when a real operator is applied to a
+   * complex right-hand side); the accumulation runs in the promoted type.
+   *
+   * Non-finite data takes the direct O(mn) kernel: the transforms would smear a
+   * single Inf/NaN into NaNs across the whole output, where the dense product
+   * only propagates it through the dot products that touch it. Non-finite
+   * generators or a non-finite cached embedding symbol (which can overflow even
+   * for finite generators) route the whole product; a non-finite right-hand-side
+   * column is detected inside the FFT loop -- in the same pass that derives its
+   * scaling exponent, so finite data pays no extra scan -- and falls back per
+   * column. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    const Index m = rows(), n = cols();
+    eigen_assert(rhs.rows() == n && "invalid product: dimensions do not match");
+    const bool small = m <= internal::structured_direct_threshold() && n <= internal::structured_direct_threshold();
+    if (small || !m_fftUsable)
+      directProduct(dst, rhs, alpha);
+    else
+      internal::structured_fft_apply(dst, m_symbol, m, rhs, alpha,
+                                     [&](Index k) { directProductColumn(dst, rhs, k, alpha); });
+  }
+
+ private:
+  // Grants transpose() and adjoint() access to the private constructor of the
+  // dimension-swapped instantiation.
+  template <typename OtherScalar, int OtherRows, int OtherCols>
+  friend class Toeplitz;
+
+  /** \internal Builds an operator from generators and an already-known symbol
+   * (empty for small operators), skipping the FFT of the public constructor. Used
+   * by transpose(), conjugate() and adjoint(), whose symbols are cheap
+   * transformations of the existing one. */
+  Toeplitz(const ColGeneratorType& col, const RowGeneratorType& row, const ComplexVector& symbol)
+      : m_col(col), m_row(row), m_symbol(symbol) {
+    m_fftUsable = computeFftUsable();
+  }
+
+  /** \internal Whether products may take the FFT path: the generators and the
+   * cached embedding symbol must be finite. The symbol accumulates up to p
+   * addends, so it can overflow to Inf even for finite generators; such operators
+   * fall back to the direct kernel, which stays exact. */
+  bool computeFftUsable() const {
+    return m_col.allFinite() && m_row.allFinite() && (m_symbol.size() == 0 || m_symbol.allFinite());
+  }
+
+  /** \internal Direct O(mn) kernel for column \a k of the right-hand side:
+   * computes \c dst.col(k) += alpha * (*this) * rhs.col(k) without transforms.
+   * Serves operators below the FFT threshold and any column involving
+   * non-finite data, whose entrywise IEEE semantics the transforms cannot
+   * preserve. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProductColumn(Dest& dst, const Rhs& rhs, Index k, const ProductScalar& alpha) const {
+    const Index m = rows(), n = cols();
+    // A unit alpha must not multiply: even the identity complex scalar (1,0)
+    // pollutes an (Inf,0) value with NaN through the 0*Inf cross term.
+    const bool unitAlpha = alpha == ProductScalar(1);
+    if (m <= internal::structured_scalar_threshold() && n <= internal::structured_scalar_threshold()) {
+      // Tiny sizes: a plain scalar loop beats the segment-based path below, whose
+      // per-segment setup dominates when segments hold only a few entries.
+      for (Index i = 0; i < m; ++i) {
+        ProductScalar acc(0);
+        for (Index j = 0; j < n; ++j) acc += coeff(i, j) * rhs.coeff(j, k);
+        dst.coeffRef(i, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
+      }
+      return;
+    }
+
+    // Split each column at its diagonal into contiguous generator slices.
+    auto dstCol = dst.col(k);
+    for (Index j = 0; j < n; ++j) {
+      const ProductScalar xj = unitAlpha ? ProductScalar(rhs.coeff(j, k)) : ProductScalar(alpha * rhs.coeff(j, k));
+      const Index h = numext::mini(j, m);
+      dstCol.head(h) += xj * m_row.segment(j - h + 1, h).reverse();
+      if (j < m) dstCol.tail(m - j) += xj * m_col.head(m - j);
+    }
+  }
+
+  /** \internal Direct O(mn) product kernel over every column, see
+   * directProductColumn(). */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void directProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    for (Index k = 0; k < rhs.cols(); ++k) directProductColumn(dst, rhs, k, alpha);
+  }
+
+  /** \internal \returns the DFT of the first column of the circulant embedding. */
+  ComplexVector computeSymbol() const {
+    const Index m = rows(), n = cols();
+    const Index p = internal::fft_next_good_size(m + n - 1);
+    ComplexVector embedding = ComplexVector::Zero(p);
+    embedding.head(m) = m_col.template cast<Complex>();
+    embedding.tail(n - 1) = m_row.tail(n - 1).reverse().template cast<Complex>();
+    if (p == 1) return embedding;  // the DFT of a single sample is the identity
+    ComplexVector symbol(p);
+    auto&& fft = internal::structured_fft_engine<RealScalar>();
+    fft.fwd(symbol, embedding, p);
+    return symbol;
+  }
+
+  ColGeneratorType m_col;
+  RowGeneratorType m_row;
+  ComplexVector m_symbol;
+  bool m_fftUsable;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns a \ref Toeplitz operator with first column \a col and first row \a row.
+ * The compile-time dimensions of the operator are deduced from the generators. */
+template <typename ColDerived, typename RowDerived>
+Toeplitz<typename ColDerived::Scalar, ColDerived::SizeAtCompileTime, RowDerived::SizeAtCompileTime> makeToeplitz(
+    const MatrixBase<ColDerived>& col, const MatrixBase<RowDerived>& row) {
+  return Toeplitz<typename ColDerived::Scalar, ColDerived::SizeAtCompileTime, RowDerived::SizeAtCompileTime>(col, row);
+}
+
+namespace internal {
+
+template <typename Scalar_, int Rows_, int Cols_, typename Rhs, int ProductTag>
+struct generic_product_impl<Toeplitz<Scalar_, Rows_, Cols_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<Toeplitz<Scalar_, Rows_, Cols_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_TOEPLITZ_H
diff --git a/contrib/Eigen/src/StructuredMatrices/Vandermonde.h b/contrib/Eigen/src/StructuredMatrices/Vandermonde.h
new file mode 100644
index 0000000..f218f09
--- /dev/null
+++ b/contrib/Eigen/src/StructuredMatrices/Vandermonde.h
@@ -0,0 +1,770 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// References:
+//  [1] N. J. Higham, "Accuracy and Stability of Numerical Algorithms", 2nd ed.,
+//      SIAM, 2002, chapter 27. Avoiding spurious overflow by rescaling with
+//      powers of two, the technique behind determinant()'s balanced
+//      accumulation and the scaled Horner recurrence of addProduct().
+//  [2] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
+//      Scaling by a power of two is exact, the property the balanced
+//      accumulation and the scaled Horner recurrence rely on.
+//  [3] J. J. Dongarra, J. R. Bunch, C. B. Moler and G. W. Stewart, "LINPACK
+//      Users' Guide", SIAM, 1979. determinant()'s balanced accumulation follows
+//      the convention of its xGEDI routines, which return determinants as a
+//      (fraction, exponent) pair to avoid spurious overflow/underflow.
+//  [4] L. Reichel, "Newton Interpolation at Leja Points", BIT 30 (1990),
+//      332--346. Leja ordering controls growth in the Newton representation;
+//      BjorckPereyra uses it for genuinely complex node sets.
+
+#ifndef EIGEN_STRUCTURED_VANDERMONDE_H
+#define EIGEN_STRUCTURED_VANDERMONDE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar_, int Rows_ = Dynamic, int Cols_ = Dynamic>
+class Vandermonde;
+
+template <typename Scalar_>
+class BjorckPereyra;
+
+namespace internal {
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct traits<Vandermonde<Scalar_, Rows_, Cols_>> {
+  using Scalar = Scalar_;
+  using StorageKind = Dense;
+  using XprKind = MatrixXpr;
+  using StorageIndex = int;
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  // Deliberately no NestByRefBit: the makeVandermonde() factories (and any
+  // function returning the operator by value) produce owning temporaries, so
+  // Product must nest the operator by value for a delayed-evaluated product
+  // expression to keep its left factor alive. The copy is O(m), negligible
+  // against the O(mn) product evaluation.
+  static constexpr int Flags = Rows_ == 1 && Cols_ != 1 ? RowMajorBit : 0;
+};
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct evaluator_traits<Vandermonde<Scalar_, Rows_, Cols_>> {
+  using Kind = IndexBased;
+  using Shape = StructuredShape;
+};
+
+// Core rewrites alpha * (lhs * rhs) as (alpha * lhs) * rhs. The scaled
+// Vandermonde wrapper needs coefficient and BLAS metadata to participate in
+// that general dense-expression machinery.
+template <typename Scalar_, int Rows_, int Cols_>
+struct evaluator<Vandermonde<Scalar_, Rows_, Cols_>> : evaluator_base<Vandermonde<Scalar_, Rows_, Cols_>> {
+  using XprType = Vandermonde<Scalar_, Rows_, Cols_>;
+  using Scalar = Scalar_;
+  static constexpr int CoeffReadCost = HugeCost;
+  static constexpr int Flags = traits<XprType>::Flags;
+  static constexpr int Alignment = 0;
+
+  EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr) : m_xpr(xpr) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar coeff(Index row, Index col) const { return m_xpr.coeff(row, col); }
+
+ private:
+  const XprType& m_xpr;
+};
+
+template <typename Scalar_, int Rows_, int Cols_>
+struct blas_traits<Vandermonde<Scalar_, Rows_, Cols_>> {
+  using XprType = Vandermonde<Scalar_, Rows_, Cols_>;
+  using Scalar = Scalar_;
+  using ExtractType = const XprType&;
+  using ExtractType_ = XprType;
+  using DirectLinearAccessType = XprType;
+  static constexpr bool IsComplex = NumTraits<Scalar>::IsComplex;
+  static constexpr bool IsTransposed = false;
+  static constexpr bool NeedToConjugate = false;
+  static constexpr bool HasUsableDirectAccess = false;
+  static constexpr bool HasScalarFactor = false;
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ExtractType extract(const XprType& x) { return x; }
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar extractScalarFactor(const XprType&) { return Scalar(1); }
+};
+
+template <typename Scalar_>
+struct traits<BjorckPereyra<Scalar_>> : traits<Matrix<Scalar_, Dynamic, Dynamic>> {
+  using XprKind = MatrixXpr;
+  using StorageKind = SolverStorage;
+  using StorageIndex = int;
+  using BaseTraits = traits<Matrix<Scalar_, Dynamic, Dynamic>>;
+  static constexpr int Flags = BaseTraits::Flags & RowMajorBit;
+  static constexpr int CoeffReadCost = Dynamic;
+};
+
+}  // namespace internal
+
+/** \ingroup StructuredMatrices_Module
+ * \class Vandermonde
+ * \brief An \c m x \c n Vandermonde matrix represented by its node vector.
+ *
+ * A Vandermonde matrix has entry \c (i,j) equal to \f$ x_i^j \f$, where \c x is
+ * the node vector. Thus
+ * \f[ (Va)_i = \sum_{j=0}^{n-1} a_j x_i^j, \qquad
+ *     p_{n-1}=a_{n-1},\quad p_j=a_j+x_i p_{j+1}. \f]
+ * The class stores only the \c m nodes; products evaluate this Horner recurrence
+ * rule at O(mn) operations -- the same cost as a dense product, but with O(m)
+ * storage and without ever forming the matrix.
+ *
+ * Square systems are solved in O(n^2) by the Björck-Pereyra algorithm (class
+ * \ref BjorckPereyra), whose \c transpose().solve() form covers the dual
+ * (moment) system. There is no fast transposed \em product, so the class is not
+ * closed under transposition and rectangular least-squares problems are best
+ * handled by a dense QR of the materialized matrix.
+ *
+ * Because \c operator* returns an Eigen product expression, a \c Vandermonde
+ * also drops into the matrix-free iterative solvers, and it can be assigned to
+ * a dense matrix when an explicit representation is needed. As with any
+ * matrix-free operator, the iterative solvers must be instantiated with
+ * \c IdentityPreconditioner (e.g.
+ * \c BiCGSTAB<Vandermonde<double>,IdentityPreconditioner>): the default
+ * preconditioners read individual coefficients through \c col() or
+ * \c InnerIterator, which the structured operators do not expose.
+ *
+ * \warning Vandermonde matrices with real nodes are exponentially
+ * ill-conditioned: the condition number grows at least like \f$ 2^n \f$ for any
+ * real node configuration (Beckermann, 2000). Solves remain surprisingly
+ * accurate for monotone node sets and sign-alternating right-hand sides
+ * (Björck-Pereyra's celebrated property, see Higham, ASNA ch. 22), but forward
+ * errors necessarily scale with the conditioning in general. Complex nodes on
+ * the unit circle are the well-conditioned case: for the n-th roots of unity,
+ * \f$ V/\sqrt{n} \f$ is unitary.
+ *
+ * \tparam Scalar_ a floating-point-like real or complex scalar supporting
+ * Eigen's scalar math hooks, including \c isfinite, \c frexp and \c ldexp (and
+ * \c log for complex solver ordering). Integer types are rejected.
+ * \tparam Rows_ the number of rows (nodes) at compile time, or \c Dynamic.
+ * \tparam Cols_ the number of columns (powers) at compile time, or \c Dynamic.
+ *
+ * \sa class BjorckPereyra, makeVandermonde()
+ */
+template <typename Scalar_, int Rows_, int Cols_>
+class Vandermonde : public EigenBase<Vandermonde<Scalar_, Rows_, Cols_>> {
+ public:
+  using Derived = Vandermonde;
+  using StorageBaseType = Vandermonde;
+  using Scalar = Scalar_;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using StorageIndex = int;
+  static constexpr int NodeOptions = Rows_ == Dynamic ? AutoAlign : DontAlign;
+  using NodeVector = Matrix<Scalar, Rows_, 1, NodeOptions>;
+  using Nested = Vandermonde;
+
+  static constexpr int RowsAtCompileTime = Rows_;
+  static constexpr int ColsAtCompileTime = Cols_;
+  static constexpr int MaxRowsAtCompileTime = Rows_;
+  static constexpr int MaxColsAtCompileTime = Cols_;
+  static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Rows_, Cols_);
+  static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
+  static constexpr int Flags = internal::traits<Vandermonde>::Flags;
+  static constexpr bool IsRowMajor = (Flags & RowMajorBit) != 0;
+  // Deliberately no IsVectorAtCompileTime: Ref<const Vandermonde>'s default
+  // StrideType argument reads it, so its absence makes internal::is_ref_compatible
+  // SFINAE to false and keeps the iterative solvers on their matrix-free path.
+
+  EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
+  EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(operator*, internal::scalar_product_op)
+
+  /** Builds an \c m x \a cols Vandermonde matrix from the \c m nodes \a nodes. */
+  template <typename Derived>
+  Vandermonde(const MatrixBase<Derived>& nodes, Index cols) : m_x(nodes), m_cols(cols) {
+    EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
+    eigen_assert(m_x.size() > 0 && m_cols > 0 && "Vandermonde must be non-empty");
+    eigen_assert((Cols_ == Dynamic || Cols_ == cols) && "cols does not match the compile-time column count");
+  }
+
+  /** Builds the square Vandermonde matrix of the nodes \a nodes. */
+  template <typename Derived>
+  explicit Vandermonde(const MatrixBase<Derived>& nodes) : Vandermonde(nodes, nodes.size()) {
+    EIGEN_STATIC_ASSERT(Rows_ == Dynamic || Cols_ == Dynamic || Rows_ == Cols_, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    EIGEN_STATIC_ASSERT(
+        Cols_ == Dynamic || Derived::SizeAtCompileTime == Dynamic || Cols_ == Derived::SizeAtCompileTime,
+        YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+  }
+
+  EIGEN_DEVICE_FUNC Index rows() const { return m_x.size(); }
+  EIGEN_DEVICE_FUNC Index cols() const { return m_cols; }
+
+  /** \returns the node vector. */
+  const NodeVector& nodes() const { return m_x; }
+
+  /** \returns the coefficient at row \a row and column \a col, \f$ x_i^j \f$. */
+  EIGEN_DEVICE_FUNC Scalar coeff(Index row, Index col) const {
+    Scalar p(1);
+    const Scalar xi = m_x.coeff(row);
+    for (Index t = 0; t < col; ++t) p *= xi;
+    return p;
+  }
+
+  /** \returns the determinant of a \b square Vandermonde matrix through the
+   * closed form \f$ \prod_{i<j} (x_j - x_i) \f$, in O(n^2) operations. The
+   * product is accumulated in the balanced form \c m * 2^e (the split
+   * fraction/exponent determinant convention of LINPACK's xGEDI [3]) -- every
+   * factor and the running product are renormalized to unit magnitude with the
+   * power of two tracked separately, an exact rescaling [2] -- so the partial
+   * products can neither overflow nor underflow when the determinant itself is
+   * representable, whatever the spread of the nodes. Zero factors (repeated
+   * nodes, giving an exactly singular matrix) and non-finite factors propagate
+   * exactly. */
+  Scalar determinant() const {
+    eigen_assert(rows() == cols() && "Vandermonde::determinant requires a square matrix");
+    const Index n = rows();
+    Scalar det(1);
+    internal::structured_exponent_type exponent = 0;
+    for (Index j = 1; j < n; ++j)
+      for (Index i = 0; i < j; ++i) {
+        // A node difference can overflow even though the determinant is
+        // representable (e.g. nodes near +-max); the guarded difference then
+        // enters at half scale with the factor of two carried by the running
+        // exponent.
+        int shift;
+        const Scalar diff = internal::structured_guarded_diff(m_x.coeff(j), m_x.coeff(i), shift);
+        exponent += shift;
+        det = internal::structured_balance(det * internal::structured_balance(diff, exponent), exponent);
+      }
+    // ldexp saturates cleanly to zero / infinity once the accumulated exponent
+    // leaves the representable range; the clamp only guards the narrowing to int.
+    return internal::structured_ldexp_clamped(det, exponent);
+  }
+
+  /** \internal Writes the dense representation into \a dst: column \c j is the
+   * elementwise product of column \c j-1 with the nodes, so only cumulative
+   * columnwise products are involved. Invoked through \c dense = vandermonde; */
+  template <typename Dest>
+  void evalTo(Dest& dst) const {
+    dst.col(0).setOnes();
+    for (Index j = 1; j < m_cols; ++j) dst.col(j) = dst.col(j - 1).cwiseProduct(m_x);
+  }
+
+  /** \internal Computes \c dst += (*this), see evalTo(). */
+  template <typename Dest>
+  void addTo(Dest& dst) const {
+    NodeVector p = NodeVector::Ones(rows());
+    dst.col(0) += p;
+    for (Index j = 1; j < m_cols; ++j) {
+      p = p.cwiseProduct(m_x);
+      dst.col(j) += p;
+    }
+  }
+
+  /** \internal Computes \c dst -= (*this), see evalTo(). */
+  template <typename Dest>
+  void subTo(Dest& dst) const {
+    NodeVector p = NodeVector::Ones(rows());
+    dst.col(0) -= p;
+    for (Index j = 1; j < m_cols; ++j) {
+      p = p.cwiseProduct(m_x);
+      dst.col(j) -= p;
+    }
+  }
+
+  /** \returns the product expression \c (*this) * \a a: the polynomial with
+   * ascending coefficients \c a (per column) evaluated at every node by Horner's
+   * rule, at O(mn) operations and O(1) extra storage. The expression carries the
+   * default product tag, so assigning it behaves like any dense product: a
+   * temporary resolves aliasing between the destination and \a a, and
+   * \c .noalias() skips it. */
+  template <typename Rhs>
+  Product<Vandermonde, Rhs> operator*(const MatrixBase<Rhs>& a) const {
+    EIGEN_STATIC_ASSERT(ColsAtCompileTime == Dynamic || Rhs::RowsAtCompileTime == Dynamic ||
+                            int(ColsAtCompileTime) == int(Rhs::RowsAtCompileTime),
+                        INVALID_MATRIX_PRODUCT)
+    eigen_assert(a.rows() == cols() && "invalid product: dimensions do not match");
+    return Product<Vandermonde, Rhs>(*this, a.derived());
+  }
+
+  /** \internal Computes \c dst += alpha * (*this) * rhs by Horner's rule.
+   * \c ProductScalar is the promoted scalar of the product (complex when a real
+   * operator is applied to a complex right-hand side); the accumulation runs in
+   * the promoted type.
+   *
+   * Horner intermediates can overflow even when the polynomial value itself is
+   * representable (e.g. coefficients near the overflow threshold evaluated at a
+   * node of magnitude 1/2). Each (node, column) pair is therefore screened with
+   * a conservative exponent bound: when no intermediate can overflow -- every
+   * input of moderate magnitude -- the plain Horner loop runs, matching the naive
+   * evaluation step for step, though not necessarily bit for bit: the compiler
+   * may contract one loop's multiply-add into an FMA and not the other's.
+   * Otherwise scaledHorner() keeps the running value in
+   * the balanced form m * 2^e of determinant(). Non-finite nodes or coefficients
+   * also take the plain loop, which propagates Inf/NaN entrywise like a dense
+   * product; and a unit alpha must not multiply -- even the identity complex
+   * scalar (1,0) pollutes an (Inf,0) value with NaN through the 0*Inf cross
+   * term.
+   *
+   * The column's finiteness and its exponent bound come from the single
+   * fast-max pass of internal::structured_exponent_bound_finite(), which is not
+   * guaranteed to propagate NaN. That is sufficient here for the same reason as
+   * in the FFT products: an Inf in NaN-free data always surfaces in a fast
+   * maximum, and a column containing NaN yields the NaN results dense-product
+   * semantics require through the plain loop and the scaled recurrence alike
+   * (every Horner step folds the NaN coefficient in, and the balancing helpers
+   * pass non-finite values through), so missing a NaN cannot change the
+   * result. */
+  template <typename Dest, typename Rhs, typename ProductScalar>
+  void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
+    const Index m = rows(), n = m_cols;
+    using Exponent = internal::structured_exponent_type;
+    eigen_assert(rhs.rows() == n && "invalid product: dimensions do not match");
+    const bool unitAlpha = alpha == ProductScalar(1);
+    int log2n = 0;  // n < 2^log2n: bounds the number of addends of the Horner sum
+    for (Index t = n; t > 0; t /= 2) ++log2n;
+    for (Index k = 0; k < rhs.cols(); ++k) {
+      int colExp;  // max modulus < 2^colExp; 0 for a zero or non-finite column
+      const bool colFinite = internal::structured_exponent_bound_finite(rhs.col(k), colExp);
+      for (Index i = 0; i < m; ++i) {
+        const Scalar xi = m_x.coeff(i);
+        // |p_j| < 2^(colExp+log2n+(n-1) max(xiExp,0)+1).
+        const Exponent intermediateBound =
+            Exponent(colExp) + Exponent(log2n) + (Exponent(n) - 1) * Exponent(numext::maxi(exponentBound(xi), 0)) + 2;
+        const bool plain = !colFinite || !(numext::isfinite)(xi) ||
+                           intermediateBound <= Exponent(NumTraits<RealScalar>::max_exponent());
+        ProductScalar acc;
+        if (plain) {
+          acc = rhs.coeff(n - 1, k);
+          for (Index j = n - 2; j >= 0; --j) acc = acc * xi + rhs.coeff(j, k);
+        } else {
+          acc = scaledHorner<ProductScalar>(xi, rhs, k);
+        }
+        dst.coeffRef(i, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
+      }
+    }
+  }
+
+ private:
+  /** \internal \returns an exponent bound \c e with \c |z| < 2^e (the modulus
+   * for a complex \a z), or 0 for a zero or non-finite \a z; the
+   * single-coefficient analogue of internal::structured_exponent_bound(). */
+  template <typename T>
+  static int exponentBound(const T& z) {
+    return exponentBoundImpl(z, internal::bool_constant<NumTraits<T>::IsComplex>());
+  }
+
+  template <typename T>
+  static int exponentBoundImpl(const T& z, std::false_type) {
+    if (!(numext::abs(z) > T(0)) || !(numext::isfinite)(z)) return 0;
+    int e;
+    EIGEN_USING_STD(frexp);
+    frexp(z, &e);
+    return e;
+  }
+
+  template <typename T>
+  static int exponentBoundImpl(const T& z, std::true_type) {
+    using Real = typename NumTraits<T>::Real;
+    const Real mag = numext::maxi(numext::abs(numext::real(z)), numext::abs(numext::imag(z)));
+    if (!(mag > Real(0)) || !(numext::isfinite)(mag)) return 0;
+    int e;
+    EIGEN_USING_STD(frexp);
+    frexp(mag, &e);
+    return e + 1;  // the modulus is at most sqrt(2) times the largest component
+  }
+
+  /** \internal \returns \a z * 2^e computed through two exact half-factors, so
+   * the factors themselves stay representable for the exponent swings the scaled
+   * Horner recurrence produces (|e| up to about twice the scalar's exponent
+   * range on the negative side, at most one exponent range on the positive
+   * side); a factor past the underflow threshold flushes to zero together with
+   * the then-negligible contribution it scales. */
+  template <typename T>
+  static T twoHalfScale(const T& z, internal::structured_exponent_type e) {
+    using Real = typename NumTraits<T>::Real;
+    constexpr internal::structured_exponent_type kMaxExponent = internal::structured_exponent_type(1) << 24;
+    const int ec = static_cast<int>(numext::mini(numext::maxi(e, -kMaxExponent), kMaxExponent));
+    const Real h1 = numext::ldexp(Real(1), ec / 2);
+    const Real h2 = numext::ldexp(Real(1), ec - ec / 2);
+    return (z * h1) * h2;
+  }
+
+  /** \internal Evaluates the polynomial with ascending coefficients
+   * \c rhs.col(k) at the node \a xi, keeping the running value in the balanced
+   * form \c acc * 2^exponent of determinant() (overflow-avoiding power-of-two
+   * rescaling [1], exact by [2]): the node enters through its unit mantissa
+   * with its exponent folded into the running one, the mantissa is
+   * renormalized after every step, and each coefficient is folded into the
+   * running frame scaled by an exact power of two split into two half-factors
+   * (when the coefficient dominates the frame, the frame is rebased onto the
+   * coefficient's exponent instead). Intermediates can therefore neither
+   * overflow nor underflow, and the final ldexp saturates to +-Inf / +-0 exactly
+   * where the true value leaves the representable range.
+   *
+   * An exactly zero mantissa carries no scale, so the frame is reset before
+   * every fold: after an exact cancellation (or a zero node annihilating the
+   * running value) a stale huge frame would otherwise underflow the next small
+   * coefficient to zero. A cancellation that leaves a tiny nonzero mantissa
+   * needs no such care -- the frexp renormalization rebases the frame to the
+   * surviving magnitude (which is a multiple of the operands' unit roundoff,
+   * hence never subnormal for real scalars, and frexp is exact on subnormal
+   * component values regardless).
+   * \pre the node is finite and the column passed the fast-max routing
+   * predicate of addProduct(): it holds no Inf without an accompanying NaN. A
+   * NaN-bearing column can reach the recurrence when the fast maximum misses
+   * the NaN; every helper passes non-finite values through, so it produces the
+   * NaN result dense-product semantics require. */
+  template <typename ProductScalar, typename Rhs>
+  ProductScalar scaledHorner(const Scalar& xi, const Rhs& rhs, Index k) const {
+    using Exponent = internal::structured_exponent_type;
+    Exponent xiE = 0;
+    const Scalar xiMant = internal::structured_balance(xi, xiE);  // xi = xiMant * 2^xiE, exactly
+    ProductScalar acc(0);
+    Exponent exponent = 0;  // running value = acc * 2^exponent
+    for (Index j = m_cols - 1; j >= 0; --j) {
+      if (j < m_cols - 1) {
+        exponent += xiE;
+        acc = internal::structured_balance(acc * xiMant, exponent);
+      }
+      // A zero value has no scale: reset the frame so the next coefficient
+      // enters at its own magnitude instead of underflowing in a stale one.
+      if (acc == ProductScalar(0)) exponent = 0;
+      const ProductScalar aj(rhs.coeff(j, k));
+      if (aj == ProductScalar(0)) continue;
+      const Exponent ajExp = exponentBound(aj);
+      if (exponent < ajExp) {
+        // The coefficient dominates the running frame: rebase onto the
+        // coefficient's exponent. The running value rescales exactly, or
+        // underflows harmlessly once it is negligible against the coefficient.
+        acc = twoHalfScale(acc, exponent - ajExp);
+        exponent = ajExp;
+      }
+      acc = internal::structured_balance(acc + twoHalfScale(aj, -exponent), exponent);
+    }
+    return internal::structured_ldexp_clamped(acc, exponent);
+  }
+
+  NodeVector m_x;
+  Index m_cols;
+};
+
+/** \ingroup StructuredMatrices_Module
+ * \returns an \c m x \a cols \ref Vandermonde operator with node vector \a nodes;
+ * the compile-time row count is deduced from \a nodes. */
+template <typename Derived>
+Vandermonde<typename Derived::Scalar, Derived::SizeAtCompileTime, Dynamic> makeVandermonde(
+    const MatrixBase<Derived>& nodes, Index cols) {
+  return Vandermonde<typename Derived::Scalar, Derived::SizeAtCompileTime, Dynamic>(nodes, cols);
+}
+
+/** \ingroup StructuredMatrices_Module
+ * \returns the square \ref Vandermonde operator of the nodes \a nodes. */
+template <typename Derived>
+Vandermonde<typename Derived::Scalar, Derived::SizeAtCompileTime, Derived::SizeAtCompileTime> makeVandermonde(
+    const MatrixBase<Derived>& nodes) {
+  return Vandermonde<typename Derived::Scalar, Derived::SizeAtCompileTime, Derived::SizeAtCompileTime>(nodes);
+}
+
+/** \ingroup StructuredMatrices_Module
+ * \class BjorckPereyra
+ * \brief Björck-Pereyra O(n^2) solver for square Vandermonde systems.
+ *
+ * Solves \c V*a = f -- polynomial interpolation: find the coefficients of the
+ * polynomial taking values \c f at the nodes -- in O(n^2) operations and O(n)
+ * storage, via divided differences in the Newton basis followed by the basis
+ * change to monomials (Björck & Pereyra, 1970; Golub & Van Loan, Alg. 4.6.2).
+ * The transposed (dual, or moment) system \f$ V^T w = b \f$ is solved by the
+ * companion dual recurrences through the standard \c SolverBase idiom:
+ * \code
+ *   BjorckPereyra<double> bp(V);            // or bp.compute(V);
+ *   VectorXd a = bp.solve(f);                // solve V   * a = f
+ *   VectorXd w = bp.transpose().solve(b);    // solve V^T * w = b
+ *   VectorXd u = bp.adjoint().solve(b);      // solve V^H * u = b
+ * \endcode
+ *
+ * There is no factorization: \c compute() stores the nodes (and flags exactly
+ * repeated or non-finite nodes through \c info()), and each solve runs the
+ * O(n^2) recurrences directly. Genuinely complex node sets are put in a
+ * deterministic Leja order to control growth in the Newton representation;
+ * real nodes, including complex scalars with zero imaginary parts, retain their
+ * input order and its useful monotonicity properties.
+ *
+ * Despite the exponential conditioning of real-node Vandermonde matrices, the
+ * computed solution is often far more accurate than the conditioning suggests:
+ * for monotonically ordered nodes and a right-hand side with alternating signs
+ * the forward error is governed by a small relative-perturbation bound
+ * independent of the condition number (Higham, ASNA ch. 22).
+ *
+ * \tparam Scalar_ a floating-point-like real or complex scalar supporting
+ * Eigen's scalar math hooks, including \c isfinite (and \c abs and \c log for
+ * complex node ordering). Integer types are rejected.
+ *
+ * \sa class Vandermonde
+ */
+template <typename Scalar_>
+class BjorckPereyra : public SolverBase<BjorckPereyra<Scalar_>> {
+ public:
+  using Base = SolverBase<BjorckPereyra>;
+  friend class SolverBase<BjorckPereyra>;
+  EIGEN_GENERIC_PUBLIC_INTERFACE(BjorckPereyra)
+  EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
+  using NodeVector = Matrix<Scalar, Dynamic, 1>;
+
+  /** Default constructor; call \ref compute before \ref solve. */
+  BjorckPereyra() : m_isInitialized(false), m_info(InvalidInput) {}
+
+  /** Constructs the solver for the square Vandermonde matrix \a V. */
+  template <int Rows_, int Cols_>
+  explicit BjorckPereyra(const Vandermonde<Scalar, Rows_, Cols_>& V) : m_isInitialized(false), m_info(InvalidInput) {
+    compute(V);
+  }
+
+  /** Stores the nodes of the square Vandermonde matrix \a V, checks that they
+   * are finite and distinct, and computes a Leja order for genuinely complex
+   * nodes. */
+  template <int Rows_, int Cols_>
+  BjorckPereyra& compute(const Vandermonde<Scalar, Rows_, Cols_>& V) {
+    EIGEN_STATIC_ASSERT(Rows_ == Dynamic || Cols_ == Dynamic || Rows_ == Cols_, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES)
+    eigen_assert(V.rows() == V.cols() && "BjorckPereyra requires a square Vandermonde matrix");
+    m_x = V.nodes();
+    m_order.clear();
+    m_info = Success;
+    const Index n = m_x.size();
+    if (!m_x.allFinite()) m_info = InvalidInput;
+    for (Index j = 1; j < n && m_info == Success; ++j)
+      for (Index i = 0; i < j; ++i) {
+        if (m_x[i] == m_x[j]) {
+          m_info = NumericalIssue;
+          break;
+        }
+      }
+    if (m_info == Success) initializeNodeOrder(m_x, internal::bool_constant<NumTraits<Scalar>::IsComplex>());
+    m_isInitialized = true;
+    return *this;
+  }
+
+  Index rows() const noexcept { return m_x.size(); }
+  Index cols() const noexcept { return m_x.size(); }
+
+  /** \returns \c Success, \c NumericalIssue when the nodes contain an exact
+   * duplicate (the matrix is singular), or \c InvalidInput for a non-finite
+   * node. */
+  ComputationInfo info() const {
+    eigen_assert(m_isInitialized && "BjorckPereyra is not initialized.");
+    return m_info;
+  }
+
+#ifdef EIGEN_PARSED_BY_DOXYGEN
+  /** \returns the solution \c a of \c V*a = \a f, as a lazily evaluated
+   * expression. Supports multiple right-hand sides. The transposed and adjoint
+   * systems are solved through \c transpose().solve(b) and \c adjoint().solve(b).
+   * \pre \ref compute has been called. */
+  template <typename Rhs>
+  inline const Solve<BjorckPereyra, Rhs> solve(const MatrixBase<Rhs>& f) const;
+#endif
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+  /** \internal Primal solve V*a = rhs: divided differences (Newton coefficients),
+   * then the Newton-to-monomial basis change. */
+  template <typename RhsType, typename DstType>
+  void _solve_impl(const RhsType& rhs, DstType& dst) const {
+    using RhsScalar = typename RhsType::Scalar;
+    using WorkScalar = typename DstType::Scalar;
+    using ProductOp = internal::scalar_product_op<Scalar, RhsScalar>;
+    EIGEN_CHECK_BINARY_COMPATIBILITY(ProductOp, Scalar, RhsScalar)
+
+    const Index n = m_x.size();
+    dst = rhs;
+    Matrix<WorkScalar, Dynamic, 1> permuted;
+    if (!m_order.empty()) permuted.resize(n);
+    for (Index k = 0; k < rhs.cols(); ++k) {
+      auto a = dst.col(k);
+      if (!m_order.empty()) {
+        for (Index i = 0; i < n; ++i) permuted[i] = a[m_order[static_cast<std::size_t>(i)]];
+        a = permuted;
+      }
+      for (Index j = 0; j < n - 1; ++j)
+        for (Index i = n - 1; i > j; --i) a[i] = (a[i] - a[i - 1]) / (m_x[i] - m_x[i - j - 1]);
+      for (Index j = n - 2; j >= 0; --j)
+        for (Index i = j; i < n - 1; ++i) a[i] -= m_x[j] * a[i + 1];
+    }
+  }
+
+  /** \internal Transposed (dual) solve V^T*w = rhs: the transposes of the primal
+   * elementary steps, applied in reverse order; conjugated on the way in and out
+   * for the adjoint. */
+  template <bool Conjugate, typename RhsType, typename DstType>
+  void _solve_impl_transposed(const RhsType& rhs, DstType& dst) const {
+    using RhsScalar = typename RhsType::Scalar;
+    using WorkScalar = typename DstType::Scalar;
+    using ProductOp = internal::scalar_product_op<Scalar, RhsScalar>;
+    EIGEN_CHECK_BINARY_COMPATIBILITY(ProductOp, Scalar, RhsScalar)
+
+    const Index n = m_x.size();
+    dst = rhs.template conjugateIf<Conjugate>();
+    Matrix<WorkScalar, Dynamic, 1> permuted;
+    if (!m_order.empty()) permuted.resize(n);
+    for (Index k = 0; k < rhs.cols(); ++k) {
+      auto w = dst.col(k);
+      for (Index j = 0; j < n - 1; ++j)
+        for (Index i = n - 1; i > j; --i) w[i] -= m_x[j] * w[i - 1];
+      for (Index j = n - 2; j >= 0; --j) {
+        w.tail(n - j - 1).array() /= (m_x.tail(n - j - 1) - m_x.head(n - j - 1)).array();
+        for (Index i = j; i < n - 1; ++i) w[i] -= w[i + 1];
+      }
+
+      if (!m_order.empty()) {
+        permuted = w;
+        for (Index i = 0; i < n; ++i) w[m_order[static_cast<std::size_t>(i)]] = permuted[i];
+      }
+    }
+    if (Conjugate) dst = dst.conjugate().eval();
+  }
+#endif
+
+ private:
+  static RealScalar lejaLogAbs(const Scalar& z) {
+    const RealScalar re = numext::abs(numext::real(z));
+    const RealScalar im = numext::abs(numext::imag(z));
+    const RealScalar scale = numext::maxi(re, im);
+    if (scale == RealScalar(0)) return -NumTraits<RealScalar>::infinity();
+    const RealScalar scaledRe = re / scale;
+    const RealScalar scaledIm = im / scale;
+    return numext::log(scale) + RealScalar(0.5) * numext::log(scaledRe * scaledRe + scaledIm * scaledIm);
+  }
+
+  static RealScalar lejaLogDistance(const Scalar& a, const Scalar& b) {
+    int exponent;
+    const Scalar difference = internal::structured_guarded_diff(a, b, exponent);
+    return lejaLogAbs(difference) + RealScalar(exponent) * numext::log(RealScalar(2));
+  }
+
+  void initializeNodeOrder(const NodeVector&, std::false_type) {}
+
+  void initializeNodeOrder(const NodeVector& nodes, std::true_type) {
+    using Real = typename NumTraits<Scalar>::Real;
+    const Index n = nodes.size();
+    bool genuinelyComplex = false;
+    for (Index i = 0; i < n; ++i) genuinelyComplex = genuinelyComplex || numext::imag(nodes[i]) != Real(0);
+    if (!genuinelyComplex || n < 2) return;
+
+    const NodeVector original = nodes;
+
+    m_order.resize(static_cast<std::size_t>(n));
+    std::vector<char> selected(static_cast<std::size_t>(n), 0);
+    std::vector<RealScalar> scores(static_cast<std::size_t>(n), RealScalar(0));
+    Index next;  // the Leja sequence starts at a node of largest modulus
+    original.unaryExpr(&lejaLogAbs).maxCoeff(&next);
+
+    for (Index position = 0; position < n; ++position) {
+      m_order[static_cast<std::size_t>(position)] = next;
+      selected[static_cast<std::size_t>(next)] = 1;
+      if (position + 1 == n) break;
+
+      Index candidate = -1;
+      RealScalar candidateScore = -NumTraits<RealScalar>::infinity();
+      for (Index i = 0; i < n; ++i) {
+        if (selected[static_cast<std::size_t>(i)]) continue;
+        scores[static_cast<std::size_t>(i)] += lejaLogDistance(original[i], original[next]);
+        if (candidate < 0 || scores[static_cast<std::size_t>(i)] > candidateScore) {
+          candidate = i;
+          candidateScore = scores[static_cast<std::size_t>(i)];
+        }
+      }
+      next = candidate;
+    }
+
+    for (Index i = 0; i < n; ++i) m_x[i] = original[m_order[static_cast<std::size_t>(i)]];
+  }
+
+  NodeVector m_x;
+  std::vector<Index> m_order;
+  bool m_isInitialized;
+  ComputationInfo m_info;
+};
+
+namespace internal {
+
+/** \internal Solve results use the scalar promoted from the solver and RHS.
+ * Core's generic solve traits retain the RHS scalar, which would discard the
+ * imaginary part when a complex Vandermonde is applied to a real RHS. */
+template <typename SolverScalar, typename RhsScalar,
+          bool Compatible = has_ReturnType<ScalarBinaryOpTraits<SolverScalar, RhsScalar>>::value>
+struct bjorck_pereyra_result_scalar {
+  using type = SolverScalar;
+};
+
+template <typename SolverScalar, typename RhsScalar>
+struct bjorck_pereyra_result_scalar<SolverScalar, RhsScalar, true> {
+  using type = typename ScalarBinaryOpTraits<SolverScalar, RhsScalar>::ReturnType;
+};
+
+template <typename SolverScalar, typename RhsType>
+struct bjorck_pereyra_solve_traits {
+  using ResultScalar = typename bjorck_pereyra_result_scalar<SolverScalar, typename RhsType::Scalar>::type;
+  using PlainObject =
+      typename make_proper_matrix_type<ResultScalar, Dynamic, RhsType::ColsAtCompileTime, RhsType::PlainObject::Options,
+                                       Dynamic, RhsType::MaxColsAtCompileTime>::type;
+};
+
+template <typename Scalar_, typename RhsType>
+struct solve_traits<BjorckPereyra<Scalar_>, RhsType, Dense> : bjorck_pereyra_solve_traits<Scalar_, RhsType> {};
+
+template <typename Scalar_, typename RhsType>
+struct solve_traits<Transpose<const BjorckPereyra<Scalar_>>, RhsType, Dense>
+    : bjorck_pereyra_solve_traits<Scalar_, RhsType> {};
+
+template <typename Scalar_, typename RhsType>
+struct solve_traits<CwiseUnaryOp<scalar_conjugate_op<Scalar_>, const Transpose<const BjorckPereyra<Scalar_>>>, RhsType,
+                    Dense> : bjorck_pereyra_solve_traits<Scalar_, RhsType> {};
+
+template <typename Factor, typename Scalar_, int Rows_, int Cols_, typename Plain, typename Rhs>
+struct scaled_vandermonde_product_impl
+    : generic_product_impl_base<
+          CwiseBinaryOp<scalar_product_op<Factor, Scalar_>, const CwiseNullaryOp<scalar_constant_op<Factor>, Plain>,
+                        const Vandermonde<Scalar_, Rows_, Cols_>>,
+          Rhs, scaled_vandermonde_product_impl<Factor, Scalar_, Rows_, Cols_, Plain, Rhs>> {
+  using Op = Vandermonde<Scalar_, Rows_, Cols_>;
+  using ScaledOp = CwiseBinaryOp<scalar_product_op<Factor, Scalar_>,
+                                 const CwiseNullaryOp<scalar_constant_op<Factor>, Plain>, const Op>;
+  using Scalar = typename Product<ScaledOp, Rhs>::Scalar;
+
+  template <typename Dest>
+  static void scaleAndAddTo(Dest& dst, const ScaledOp& lhs, const Rhs& rhs, const Scalar& alpha) {
+    using RhsNested = typename nested_eval<Rhs, Rows_>::type;
+    RhsNested actualRhs(rhs);
+    lhs.rhs().addProduct(dst, actualRhs, Scalar(alpha * lhs.lhs().functor().m_other));
+  }
+};
+
+// Preserve the Horner kernel after Core introduces the scaled wrapper above;
+// otherwise the wrapper has DenseShape and falls back to a coefficient product.
+#define EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(ProductTag)                                                        \
+  template <typename Factor, typename Scalar_, int Rows_, int Cols_, typename Plain, typename Rhs>               \
+  struct generic_product_impl<                                                                                   \
+      CwiseBinaryOp<scalar_product_op<Factor, Scalar_>, const CwiseNullaryOp<scalar_constant_op<Factor>, Plain>, \
+                    const Vandermonde<Scalar_, Rows_, Cols_>>,                                                   \
+      Rhs, DenseShape, DenseShape, ProductTag>                                                                   \
+      : scaled_vandermonde_product_impl<Factor, Scalar_, Rows_, Cols_, Plain, Rhs> {};
+
+EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(CoeffBasedProductMode)
+EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(LazyCoeffBasedProductMode)
+EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(OuterProduct)
+EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(InnerProduct)
+EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(GemvProduct)
+EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL(GemmProduct)
+
+#undef EIGEN_SCALED_VANDERMONDE_PRODUCT_IMPL
+
+template <typename Scalar_, int Rows_, int Cols_, typename Rhs, int ProductTag>
+struct generic_product_impl<Vandermonde<Scalar_, Rows_, Cols_>, Rhs, StructuredShape, DenseShape, ProductTag>
+    : structured_product_impl<Vandermonde<Scalar_, Rows_, Cols_>, Rhs> {};
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_STRUCTURED_VANDERMONDE_H
diff --git a/contrib/Eigen/src/Tensor/InternalHeaderCheck.h b/contrib/Eigen/src/Tensor/InternalHeaderCheck.h
new file mode 100644
index 0000000..c26c8f6
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_MODULE_H
+#error "Please include contrib/Eigen/Tensor instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/Tensor/README.md b/contrib/Eigen/src/Tensor/README.md
new file mode 100644
index 0000000..45348bb
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/README.md
@@ -0,0 +1,2987 @@
+# Eigen Tensors {#eigen_tensors}
+
+Tensors are multidimensional arrays of elements. Elements are typically scalars,
+but more complex types such as strings are also supported.
+
+The Tensor module is part of Eigen's contrib modules. While it is actively
+used in production (e.g. in TensorFlow), its API may change without notice.
+
+To use the Tensor module, include the following header:
+
+```cpp
+#include <contrib/Eigen/Tensor>
+```
+
+## Quick Start
+
+```cpp
+#include <contrib/Eigen/Tensor>
+#include <iostream>
+
+int main() {
+  // Create a 3x4 matrix as a rank-2 tensor.
+  Eigen::Tensor<float, 2> a(3, 4);
+  a.setRandom();
+
+  // Create another tensor and compute their element-wise sum.
+  Eigen::Tensor<float, 2> b(3, 4);
+  b.setConstant(1.0f);
+  Eigen::Tensor<float, 2> c = a + b;
+
+  // A full reduction can initialize its exact scalar result type.
+  const float total = c.sum();
+  std::cout << "Sum of all elements: " << total << "\n";
+
+  // Reshape and broadcast.
+  Eigen::Tensor<float, 2> d = c.reshape(Eigen::array<Eigen::Index, 2>{{1, 12}})
+                                .broadcast(Eigen::array<Eigen::Index, 2>{{3, 1}});
+  std::cout << "d has shape: " << d.dimension(0) << " x " << d.dimension(1) << "\n";
+  return 0;
+}
+```
+
+## Tensor Classes
+
+You can manipulate a tensor with one of the following classes.  They all are in
+the namespace `::Eigen`.
+
+### Class Tensor\<Scalar, NumIndices, Options, IndexType\>
+
+This is the class to use to create a tensor and allocate memory for it.
+
+Template parameters:
+
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| `Scalar` | Element type (e.g. `float`, `int`, `std::string`) | (required) |
+| `NumIndices` | Rank (number of dimensions) | (required) |
+| `Options` | `ColMajor` (0) or `RowMajor` | `0` (`ColMajor`) |
+| `IndexType` | Type used for indexing (e.g. `int`, `long`) | `Eigen::DenseIndex` |
+
+Tensors of this class are resizable.  For example, if you assign a tensor of a
+different size to a Tensor, that tensor is resized to match its new value.
+
+#### Constructor Tensor\<Scalar, NumIndices\>(size0, size1, ...)
+
+Constructor for a Tensor.  The constructor must be passed `NumIndices` integers
+indicating the sizes of the instance along each of the dimensions.
+
+```cpp
+// Create a tensor of rank 3 of sizes 2, 3, 4.  This tensor owns
+// memory to hold 24 floating point values (24 = 2 x 3 x 4).
+Tensor<float, 3> t_3d(2, 3, 4);
+
+// Resize t_3d by assigning a tensor of different sizes, but same rank.
+t_3d = Tensor<float, 3>(3, 4, 3);
+```
+
+#### Constructor Tensor\<Scalar, NumIndices\>(size_array)
+
+Constructor where the sizes for the constructor are specified as an array of
+values instead of an explicit list of parameters.  The array type to use is
+`Eigen::array<Eigen::Index, NumIndices>`.  The array can be constructed
+automatically from an initializer list.
+
+```cpp
+// Create a tensor of strings of rank 2 with sizes 5, 7.
+Tensor<string, 2> t_2d({5, 7});
+```
+
+### Class TensorFixedSize\<Scalar, Sizes\<size0, size1, ...\>, Options, IndexType\>
+
+Class to use for tensors of fixed size, where the size is known at compile
+time.  Fixed sized tensors can provide very fast computations because all their
+dimensions are known by the compiler.  FixedSize tensors are not resizable.
+
+If the total number of elements in a fixed size tensor is small enough the
+tensor data is held onto the stack and does not cause heap allocation and free.
+
+```cpp
+// Create a 4 x 3 tensor of floats.
+TensorFixedSize<float, Sizes<4, 3>> t_4x3;
+```
+
+### Class TensorMap\<Tensor\<Scalar, NumIndices, Options\>\>
+
+This is the class to use to create a tensor on top of memory allocated and
+owned by another part of your code.  It allows to view any piece of allocated
+memory as a `Tensor`.  Instances of this class do not own the memory where the
+data are stored.
+
+A `TensorMap` is not resizable because it does not own the memory where its data
+are stored.
+
+An optional alignment template parameter controls whether Eigen can assume
+the data pointer is aligned: `TensorMap<Tensor<float, 2>, Aligned>`.
+
+#### Constructor TensorMap\<Tensor\<Scalar, NumIndices\>\>(data, size0, size1, ...)
+
+Constructor for a TensorMap.  The constructor must be passed a pointer to the
+storage for the data, and `NumIndices` size attributes.  The storage has to be
+large enough to hold all the data.
+
+```cpp
+// Map a tensor of ints on top of stack-allocated storage.
+int storage[128];  // 2 x 4 x 2 x 8 = 128
+TensorMap<Tensor<int, 4>> t_4d(storage, 2, 4, 2, 8);
+
+// The same storage can be viewed as a different tensor.
+// You can also pass the sizes as an array.
+TensorMap<Tensor<int, 2>> t_2d(storage, 16, 8);
+
+// You can also map fixed-size tensors.  Here we get a 1d view of
+// the 2d fixed-size tensor.
+TensorFixedSize<float, Sizes<4, 3>> t_4x3;
+TensorMap<Tensor<float, 1>> t_12(t_4x3.data(), 12);
+```
+
+#### Class TensorRef
+
+See **Assigning to a `TensorRef`**.
+
+## Accessing Tensor Elements
+
+#### Scalar tensor(index0, index1...)
+
+Return the element at position `(index0, index1...)` in tensor
+`tensor`.  You must pass as many parameters as the rank of `tensor`.
+The expression can be used as an l-value to set the value of the element at the
+specified position.  The value returned is of the datatype of the tensor.
+
+```cpp
+// Set the value of the element at position (0, 1, 0);
+Tensor<float, 3> t_3d(2, 3, 4);
+t_3d(0, 1, 0) = 12.0f;
+
+// Initialize all elements to random values.
+for (int i = 0; i < 2; ++i) {
+  for (int j = 0; j < 3; ++j) {
+    for (int k = 0; k < 4; ++k) {
+      t_3d(i, j, k) = ...some random value...;
+    }
+  }
+}
+
+// Print elements of a tensor.
+for (int i = 0; i < 2; ++i) {
+  std::cout << t_3d(i, 0, 0);
+}
+```
+
+## TensorLayout
+
+The tensor library supports 2 layouts: `ColMajor` (the default) and
+`RowMajor`.
+
+The layout of a tensor is optionally specified as the third template parameter
+(`Options`). If not specified explicitly, column major is assumed.
+
+```cpp
+Tensor<float, 3, ColMajor> col_major;  // equivalent to Tensor<float, 3>
+TensorMap<Tensor<float, 3, RowMajor>> row_major(data, ...);
+```
+
+All the arguments to an expression must use the same layout. Attempting to mix
+different layouts will result in a compilation error.
+
+It is possible to change the layout of a tensor or an expression using the
+`swap_layout()` method.  Note that this will also reverse the order of the
+dimensions.
+
+```cpp
+Tensor<float, 2, ColMajor> col_major(2, 4);
+Tensor<float, 2, RowMajor> row_major(2, 4);
+
+Tensor<float, 2> col_major_result = col_major;  // ok, layouts match
+Tensor<float, 2> col_major_result = row_major;  // will not compile
+
+// Simple layout swap
+col_major_result = row_major.swap_layout();
+eigen_assert(col_major_result.dimension(0) == 4);
+eigen_assert(col_major_result.dimension(1) == 2);
+
+// Swap the layout and preserve the order of the dimensions
+array<int, 2> shuffle{{1, 0}};
+col_major_result = row_major.swap_layout().shuffle(shuffle);
+eigen_assert(col_major_result.dimension(0) == 2);
+eigen_assert(col_major_result.dimension(1) == 4);
+```
+
+## Tensor Operations
+
+The Eigen Tensor library provides a vast library of operations on Tensors:
+numerical operations such as addition and multiplication, geometry operations
+such as slicing and shuffling, etc.  These operations are available as methods
+of the `Tensor` classes, and in some cases as operator overloads.  For example
+the following code computes the elementwise addition of two tensors:
+
+```cpp
+Tensor<float, 3> t1(2, 3, 4);
+t1.setRandom();
+Tensor<float, 3> t2(2, 3, 4);
+t2.setRandom();
+// Set t3 to the element wise sum of t1 and t2
+Tensor<float, 3> t3 = t1 + t2;
+```
+
+While the code above looks easy enough, it is important to understand that the
+expression `t1 + t2` is not actually adding the values of the tensors.  The
+expression instead constructs a "tensor operator" object of the class
+`TensorCwiseBinaryOp<scalar_sum>`, which has references to the tensors
+`t1` and `t2`.  This is a small C++ object that knows how to add
+`t1` and `t2`.  It is only when the value of the expression is assigned
+to the tensor `t3` that the addition is actually performed.  Technically,
+this happens through the overloading of `operator=` in the Tensor class.
+
+This mechanism for computing tensor expressions allows for lazy evaluation and
+optimizations which are what make the tensor library very fast.
+
+Of course, the tensor operators do nest, and the expression `t1 + t2 * 0.3f`
+is actually represented with the (approximate) tree of operators:
+
+```cpp
+TensorCwiseBinaryOp<scalar_sum>(t1, TensorCwiseUnaryOp<scalar_mul>(t2, 0.3f))
+```
+
+### Tensor Operations and C++ "auto"
+
+Because `Tensor` operations create tensor operators, the C++ `auto` keyword
+does not have its intuitive meaning.  Consider these 2 lines of code:
+
+```cpp
+Tensor<float, 3> t3 = t1 + t2;
+auto t4 = t1 + t2;
+```
+
+In the first line we allocate the tensor `t3` and it will contain the
+result of the addition of `t1` and `t2`.  In the second line, `t4`
+is actually the tree of tensor operators that will compute the addition of
+`t1` and `t2`.  In fact, `t4` is *not* a tensor and you cannot get
+the values of its elements:
+
+```cpp
+Tensor<float, 3> t3 = t1 + t2;
+std::cout << t3(0, 0, 0);  // OK prints the value of t1(0, 0, 0) + t2(0, 0, 0)
+
+auto t4 = t1 + t2;
+std::cout << t4(0, 0, 0);  // Compilation error!
+```
+
+When you use `auto` you do not get a `Tensor` as a result but instead a
+non-evaluated expression.
+So only use `auto` to delay evaluation.
+
+Unfortunately, there is no single underlying concrete type for holding
+non-evaluated expressions, hence you have to use `auto` in the case when you do
+want to hold non-evaluated expressions.
+
+When you need the results of set of tensor computations you have to assign the
+result to a `Tensor` that will be capable of holding onto them.  This can be
+either a normal `Tensor`, a `TensorFixedSize`, or a `TensorMap` on an existing
+piece of memory.  All the following will work:
+
+```cpp
+auto t4 = t1 + t2;
+
+Tensor<float, 3> result = t4;  // Could also be: result(t4);
+std::cout << result(0, 0, 0);
+
+TensorMap<Tensor<float, 3>> result2(some_float_ptr, dim0, dim1, dim2);
+result2 = t4;
+std::cout << result2(0, 0, 0);
+
+TensorFixedSize<float, Sizes<4, 4, 2>> result3 = t4;
+std::cout << result3(0, 0, 0);
+```
+
+Until you need the results, you can keep the operation around, and even reuse
+it for additional operations.  As long as you keep the expression as an
+operation, no computation is performed.
+
+```cpp
+// One way to compute exp((t1 + t2) * 0.2f);
+auto t3 = t1 + t2;
+auto t4 = t3 * 0.2f;
+auto t5 = t4.exp();
+Tensor<float, 3> result = t5;
+
+// Another way, exactly as efficient as the previous one:
+Tensor<float, 3> result = ((t1 + t2) * 0.2f).exp();
+```
+
+### Controlling When Expressions are Evaluated
+
+There are several ways to control when expressions are evaluated:
+
+*   Assignment to a `Tensor`, `TensorFixedSize`, or `TensorMap`.
+*   Use of the `eval()` method.
+*   Assignment to a `TensorRef`.
+
+#### Assigning to a Tensor, TensorFixedSize, or TensorMap.
+
+The most common way to evaluate an expression is to assign it to a `Tensor`.
+In the example below, the `auto` declarations make the intermediate values
+"Operations", not Tensors, and do not cause the expressions to be evaluated.
+The assignment to the Tensor `result` causes the evaluation of all the
+operations.
+
+```cpp
+auto t3 = t1 + t2;             // t3 is an Operation.
+auto t4 = t3 * 0.2f;           // t4 is an Operation.
+auto t5 = t4.exp();            // t5 is an Operation.
+Tensor<float, 3> result = t5;  // The operations are evaluated.
+```
+
+If you know the ranks and sizes of the Operation value you can assign the
+Operation to a `TensorFixedSize` instead of a `Tensor`, which is a bit more efficient.
+
+```cpp
+// We know that the result is a 4x4x2 tensor!
+TensorFixedSize<float, Sizes<4, 4, 2>> result = t5;
+```
+
+Similarly, assigning an expression to a `TensorMap` causes its evaluation.
+Like tensors of type `TensorFixedSize`, a `TensorMap` cannot be resized so they have to
+have the rank and sizes of the expression that are assigned to them.
+
+#### Calling eval().
+
+When you compute large composite expressions, you sometimes want to tell Eigen
+that an intermediate value in the expression tree is worth evaluating ahead of
+time.
+This is done by inserting a call to the `eval()` method of the
+expression Operation.
+
+```cpp
+// The previous example could have been written:
+Tensor<float, 3> result = ((t1 + t2) * 0.2f).exp();
+
+// If you want to compute (t1 + t2) once ahead of time you can write:
+Tensor<float, 3> result = ((t1 + t2).eval() * 0.2f).exp();
+```
+
+Semantically, calling `eval()` is equivalent to materializing the value of
+the expression in a temporary `Tensor` of the right size.
+The code above in effect does:
+
+```cpp
+// .eval() knows the size!
+TensorFixedSize<float, Sizes<4, 4, 2>> tmp = t1 + t2;
+Tensor<float, 3> result = (tmp * 0.2f).exp();
+```
+
+Note that the return value of `eval()` is itself an Operation, so the
+following code does not do what you may think:
+
+```cpp
+// Here t3 is an evaluation Operation.  t3 has not been evaluated yet.
+auto t3 = (t1 + t2).eval();
+
+// You can use t3 in another expression.  Still no evaluation.
+auto t4 = (t3 * 0.2f).exp();
+
+// The value is evaluated when you assign the Operation to a Tensor, using
+// an intermediate tensor to represent t3.
+Tensor<float, 3> result = t4;
+```
+
+While in the examples above calling `eval()` does not make a difference in
+performance, in other cases it can make a huge difference.  In the expression
+below the `broadcast()` expression causes the `X.maximum()` expression
+to be evaluated many times:
+
+```cpp
+Tensor<...> X ...;
+Tensor<...> Y = ((X - X.maximum(depth_dim).reshape(dims2d).broadcast(bcast))
+                 * beta).exp();
+```
+
+Inserting a call to `eval()` between the `maximum()` and
+`reshape()` calls guarantees that `maximum()` is only computed once and
+greatly speeds-up execution:
+
+```cpp
+Tensor<...> Y =
+  ((X - X.maximum(depth_dim).eval().reshape(dims2d).broadcast(bcast))
+    * beta).exp();
+```
+
+In the other example below, the tensor `Y` is both used in the expression and its assignment.
+This is an aliasing problem and if the evaluation is not done in the right order
+Y will be updated incrementally during the evaluation
+resulting in bogus results:
+
+```cpp
+ Tensor<...> Y ...;
+ Y = Y / (Y.sum(depth_dim).reshape(dims2d).broadcast(bcast));
+```
+
+Inserting a call to `eval()` between the `sum()` and `reshape()`
+expressions ensures that the sum is computed before any updates to `Y` are
+done.
+
+```cpp
+ Y = Y / (Y.sum(depth_dim).eval().reshape(dims2d).broadcast(bcast));
+```
+
+Note that an eval around the full right hand side expression is not needed
+because the generated has to compute the `i`-th value of the right hand side
+before assigning it to the left hand side.
+
+However, if you were assigning the expression value to a shuffle of `Y`
+then you would need to force an eval for correctness by adding an `eval()`
+call for the right hand side:
+
+```cpp
+ Y.shuffle(...) =
+    (Y / (Y.sum(depth_dim).eval().reshape(dims2d).broadcast(bcast))).eval();
+```
+
+#### Assigning to a TensorRef.
+
+If you need to access only a few elements from the value of an expression you
+can avoid materializing the value in a full tensor by using a `TensorRef`.
+
+A `TensorRef` is a small wrapper class for any Eigen Operation.  It provides
+overloads for the `()` operator that let you access individual values in
+the expression.
+`TensorRef` is convenient, because the Operation themselves do
+not provide a way to access individual elements.
+A read-only expression must be wrapped in a `TensorRef<const Tensor<...>>`; the
+mutable `TensorRef<Tensor<...>>` statically requires an lvalue expression such
+as a `Tensor` or a slice.
+
+```cpp
+// Create a TensorRef for the expression.  The expression is not
+// evaluated yet.
+TensorRef<const Tensor<float, 3>> ref = ((t1 + t2) * 0.2f).exp();
+
+// Use "ref" to access individual elements.  The expression is evaluated
+// on the fly.
+float at_0 = ref(0, 0, 0);
+std::cout << ref(0, 1, 0);
+```
+
+Only use `TensorRef` when you need a subset of the values of the expression.
+`TensorRef` only computes the values you access.
+However note that if you are going to access all the values it will be much
+ faster to materialize the results in a `Tensor` first.
+
+In some cases, if the full `Tensor` result would be very large, you may save
+memory by accessing it as a `TensorRef`.
+But not always.
+So don't count on it.
+
+
+### Controlling How Expressions Are Evaluated
+
+The tensor library provides several implementations of the various operations
+such as contractions and convolutions.  The implementations are optimized for
+different environments: single threaded on CPU, multi threaded on CPU, or on a
+GPU using CUDA/HIP/SYCL.
+
+You can choose which implementation to use with the `device()` call.  If
+you do not choose an implementation explicitly the default implementation that
+uses a single thread on the CPU is used.
+
+The default implementation has been optimized for modern CPUs, taking
+advantage of SSE, AVX, AVX-512, ARM NEON, SVE, RISC-V Vector (RVV), and other
+SIMD instruction sets. Note that you need to pass compiler-dependent flags
+to enable the use of these instructions (e.g. `-mavx2`, `-march=native`).
+
+For example, the following code adds two tensors using the default
+single-threaded CPU implementation:
+
+```cpp
+Tensor<float, 2> a(30, 40);
+Tensor<float, 2> b(30, 40);
+Tensor<float, 2> c = a + b;
+```
+
+To choose a different implementation you have to insert a `device()` call
+before the assignment of the result.  For technical C++ reasons this requires
+that the `Tensor` for the result be declared on its own.
+This means that you have to know the size of the result.
+
+```cpp
+Eigen::Tensor<float, 2> c(30, 40);
+c.device(...) = a + b;
+```
+
+The call to `device()` must be the last call on the left of the operator=.
+
+You must pass to the `device()` call an Eigen device object.  There are
+presently four devices you can use: `DefaultDevice`, `ThreadPoolDevice`,
+`GpuDevice`, and `SyclDevice`.
+
+
+#### Evaluating With the DefaultDevice
+
+This is exactly the same as not inserting a `device()` call.
+
+```cpp
+DefaultDevice my_device;
+c.device(my_device) = a + b;
+```
+
+#### Evaluating with a Thread Pool
+
+To use `ThreadPoolDevice`, you must define `EIGEN_USE_THREADS` before
+including the Tensor header:
+
+```cpp
+#define EIGEN_USE_THREADS
+#include <contrib/Eigen/Tensor>
+
+// Create the Eigen ThreadPool.
+Eigen::ThreadPool pool(8 /* number of threads in pool */);
+
+// Create the Eigen ThreadPoolDevice.
+Eigen::ThreadPoolDevice my_device(&pool, 4 /* number of threads to use */);
+
+// Now just use the device when evaluating expressions.
+Eigen::Tensor<float, 2> c(30, 50);
+c.device(my_device) = a.contract(b, dot_product_dims);
+```
+
+
+#### Evaluating On GPU
+
+To use `GpuDevice`, you must define `EIGEN_USE_GPU` before including the
+Tensor header.  GPU tensors require explicitly allocating device memory
+with CUDA or HIP APIs.
+
+```cpp
+#define EIGEN_USE_GPU
+#include <contrib/Eigen/Tensor>
+
+// Allocate data on GPU.
+float* d_a;
+float* d_b;
+float* d_c;
+cudaMalloc((void**)&d_a, 30 * 40 * sizeof(float));
+cudaMalloc((void**)&d_b, 30 * 40 * sizeof(float));
+cudaMalloc((void**)&d_c, 30 * 40 * sizeof(float));
+
+// Copy host data to device.
+cudaMemcpy(d_a, h_a, 30 * 40 * sizeof(float), cudaMemcpyHostToDevice);
+cudaMemcpy(d_b, h_b, 30 * 40 * sizeof(float), cudaMemcpyHostToDevice);
+
+// Create device maps.
+Eigen::TensorMap<Eigen::Tensor<float, 2>> gpu_a(d_a, 30, 40);
+Eigen::TensorMap<Eigen::Tensor<float, 2>> gpu_b(d_b, 30, 40);
+Eigen::TensorMap<Eigen::Tensor<float, 2>> gpu_c(d_c, 30, 40);
+
+// Create a GPU device and evaluate.
+Eigen::GpuStreamDevice stream;
+Eigen::GpuDevice gpu_device(&stream);
+gpu_c.device(gpu_device) = gpu_a + gpu_b;
+
+// Synchronize and copy back.
+cudaStreamSynchronize(stream.stream());
+cudaMemcpy(h_c, d_c, 30 * 40 * sizeof(float), cudaMemcpyDeviceToHost);
+
+cudaFree(d_a);
+cudaFree(d_b);
+cudaFree(d_c);
+```
+
+For HIP, replace `cuda*` calls with the corresponding `hip*` calls.
+
+`GpuDevice` caches attributes for the device that owns its stream. When HIP
+does not implement the opt-in shared-memory attribute, `sharedMemPerBlockOptin()`
+returns the ordinary block limit. `memoryPoolsSupported()` returns false on CUDA
+drivers older than 11.2, which do not support the memory-pool attribute query.
+
+Every runtime call `GpuDevice` makes, and every kernel launch, is checked: an
+unexpected failure is reported on `stderr` as `file:line: call: error name: description`
+and stops the program, through `std::abort()` when `EIGEN_NO_DEBUG` (or
+`NDEBUG`) is defined and a failed `eigen_assert` otherwise. Define
+`EIGEN_GPU_RUNTIME_CHECK(call)` before including the Tensor header to route
+failures elsewhere, `EIGEN_GPU_NO_RUNTIME_CHECKS` to ignore them as release
+builds of earlier versions did, or `EIGEN_GPU_SYNC_LAUNCHES` to synchronize
+after every kernel launch so that an execution failure is reported at the
+launch that caused it.
+
+#### Asynchronous Device Execution
+
+You can pass a callback to the `device()` call that will be invoked when the
+computation completes.  This is supported by `ThreadPoolDevice` and `GpuDevice`.
+
+```cpp
+Eigen::Tensor<float, 2> c(30, 40);
+auto done = []() { std::cout << "Computation complete!\n"; };
+c.device(my_device, done) = a + b;
+// The callback will be invoked when evaluation finishes.
+```
+
+
+## API Reference
+
+### Datatypes
+
+In the documentation of the tensor methods and Operation we mention datatypes
+that are tensor-type specific:
+
+#### \<Tensor-Type\>::Dimensions
+
+Acts like an array of `Index`. Has a `size()` method (inherited from
+`std::array`) and a static `count` member equal to the rank. Can be
+indexed like an array to access individual values.  Used to represent the
+dimensions of a tensor.  See `dimensions()`.
+
+#### \<Tensor-Type\>::Index
+
+Acts like an `int`.  Used for indexing tensors along their dimensions.  See
+`operator()`, `dimension()`, and `size()`.
+
+#### \<Tensor-Type\>::Scalar
+
+Represents the datatype of individual tensor elements.  For example, for a
+`Tensor<float>`, `Scalar` is the type `float`.  See `setConstant()`.
+
+#### (Operation)
+
+We use this pseudo type to indicate that a tensor Operation is returned by a
+method.  We indicate in the text the type and dimensions of the tensor that the
+Operation returns after evaluation.
+
+The Operation will have to be evaluated, for example by assigning it to a
+`Tensor`, before you can access the values of the resulting tensor.  You can also
+access the values through a `TensorRef`.
+
+
+## Built-in Tensor Methods
+
+These are usual C++ methods that act on tensors immediately.  They are not
+Operations which provide delayed evaluation of their results.  Unless specified
+otherwise, all the methods listed below are available on all tensor classes:
+`Tensor`, `TensorFixedSize`, and `TensorMap`.
+
+## Metadata
+
+### int NumDimensions
+
+Constant value indicating the number of dimensions of a `Tensor`.
+This is also known as the tensor rank.
+
+```cpp
+Eigen::Tensor<float, 2> a(3, 4);
+std::cout << "Dims " << a.NumDimensions;
+// Dims 2
+```
+
+### Dimensions dimensions()
+
+Returns an array-like object representing the dimensions of the tensor.
+The actual type of the `dimensions()` result is `<Tensor-Type>::Dimensions`.
+
+```cpp
+Eigen::Tensor<float, 2> a(3, 4);
+const Eigen::Tensor<float, 2>::Dimensions& d = a.dimensions();
+std::cout << "Dim size: " << d.size() << ", dim 0: " << d[0]
+          << ", dim 1: " << d[1];
+//  Dim size: 2, dim 0: 3, dim 1: 4
+```
+
+You can use `auto` to simplify the code:
+
+```cpp
+const auto& d = a.dimensions();
+std::cout << "Dim size: " << d.size() << ", dim 0: " << d[0]
+        << ", dim 1: " << d[1];
+// Dim size: 2, dim 0: 3, dim 1: 4
+```
+
+### Index dimension(Index n)
+
+Returns the n-th dimension of the tensor.  The actual type of the
+`dimension()` result is `<Tensor-Type>::Index`, but you can
+always use it like an int.
+
+```cpp
+Eigen::Tensor<float, 2> a(3, 4);
+int dim1 = a.dimension(1);
+std::cout << "Dim 1: " << dim1;
+// Dim 1: 4
+```
+
+### Index size()
+
+Returns the total number of elements in the tensor.  This is the product of all
+the tensor dimensions.  The actual type of the `size()` result is
+`<Tensor-Type>::Index`, but you can always use it like an int.
+
+```cpp
+Eigen::Tensor<float, 2> a(3, 4);
+std::cout << "Size: " << a.size();
+/// Size: 12
+```
+
+### Getting Dimensions From An Operation
+
+A few operations provide `dimensions()` directly,
+e.g. `TensorReshapingOp`.  Most operations defer calculating dimensions
+until the operation is being evaluated.  If you need access to the dimensions
+of a deferred operation, you can wrap it in a `TensorRef` (see
+**Assigning to a TensorRef** above), which provides
+`dimensions()` and `dimension()` as above.
+
+`TensorRef` can also wrap the plain `Tensor` types, so this is a useful idiom in
+templated contexts where the underlying object could be either a raw `Tensor`
+or some deferred operation (e.g. a slice of a `Tensor`).  In this case, the
+template code can wrap the object in a TensorRef and reason about its
+dimensionality while remaining agnostic to the underlying type.
+
+
+## Constructors
+
+### Tensor
+
+Creates a tensor of the specified size. The number of arguments must be equal
+to the rank of the tensor. The content of the tensor is not initialized.
+
+```cpp
+Eigen::Tensor<float, 2> a(3, 4);
+std::cout << "NumRows: " << a.dimension(0) << " NumCols: " << a.dimension(1) << endl;
+// NumRows: 3 NumCols: 4
+```
+### TensorFixedSize
+
+Creates a tensor of the specified size. The number of arguments in the `Sizes<>`
+template parameter determines the rank of the tensor. The content of the tensor
+is not initialized.
+
+```cpp
+Eigen::TensorFixedSize<float, Sizes<3, 4>> a;
+std::cout << "Rank: " << a.rank() << endl;
+// Rank: 2
+std::cout << "NumRows: " << a.dimension(0)
+          << " NumCols: " << a.dimension(1) << endl;
+// NumRows: 3 NumCols: 4
+```
+
+### TensorMap
+
+Creates a tensor mapping an existing array of data. The data must not be freed
+until the `TensorMap` is discarded, and the size of the data must be large enough
+to accommodate the coefficients of the tensor.
+
+```cpp
+float data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+Eigen::TensorMap<Tensor<float, 2>> a(data, 3, 4);
+std::cout << "NumRows: " << a.dimension(0) << " NumCols: " << a.dimension(1) << endl;
+// NumRows: 3 NumCols: 4
+std::cout << "a(1, 2): " << a(1, 2) << endl;
+// a(1, 2): 7
+```
+
+## Contents Initialization
+
+When a new `Tensor` or a new `TensorFixedSize` are created, memory is allocated to
+hold all the tensor elements, but the memory is not initialized.  Similarly,
+when a new `TensorMap` is created on top of non-initialized memory the memory its
+contents are not initialized.
+
+You can use one of the methods below to initialize the tensor memory.  These
+have an immediate effect on the tensor and return the tensor itself as a
+result.  These are not tensor Operations which delay evaluation.
+
+### \<Tensor-Type\> setConstant(const Scalar& val)
+
+Sets all elements of the tensor to the constant value `val`.  `Scalar`
+is the type of data stored in the tensor.  You can pass any value that is
+convertible to that type.
+
+Returns the tensor itself in case you want to chain another call.
+
+```cpp
+a.setConstant(12.3f);
+std::cout << "Constant: " << endl << a << endl << endl;
+
+// Constant:
+// 12.3 12.3 12.3 12.3
+// 12.3 12.3 12.3 12.3
+// 12.3 12.3 12.3 12.3
+```
+Note that `setConstant()` can be used on any tensor where the element type
+has a copy constructor and an `operator=()`:
+
+```cpp
+Eigen::Tensor<string, 2> a(2, 3);
+a.setConstant("yolo");
+std::cout << "String tensor: " << endl << a << endl << endl;
+
+// String tensor:
+// yolo yolo yolo
+// yolo yolo yolo
+```
+
+### \<Tensor-Type\> setZero()
+
+Fills the tensor with zeros.  Equivalent to `setConstant(Scalar(0))`.
+Returns the tensor itself in case you want to chain another call.
+
+```cpp
+a.setZero();
+std::cout << "Zeros: " << endl << a << endl << endl;
+
+// Zeros:
+// 0 0 0 0
+// 0 0 0 0
+// 0 0 0 0
+```
+
+### \<Tensor-Type\> setValues({..initializer_list})
+
+Fills the tensor with explicit values specified in a std::initializer_list.
+The type of the initializer list depends on the type and rank of the tensor.
+
+If the tensor has rank N, the initializer list must be nested N times.  The
+most deeply nested lists must contains P scalars of the `Tensor` type where P is
+the size of the last dimension of the Tensor.
+
+For example, for a `TensorFixedSize<float, Sizes<2, 3>>` the initializer list
+must contains 2 lists of 3 floats each.
+
+`setValues()` returns the tensor itself in case you want to chain another
+call.
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setValues({{0.0f, 1.0f, 2.0f}, {3.0f, 4.0f, 5.0f}});
+std::cout << "a" << endl << a << endl << endl;
+
+// a
+// 0 1 2
+// 3 4 5
+```
+
+If a list is too short, the corresponding elements of the tensor will not be
+changed.  This is valid at each level of nesting.  For example the following
+code only sets the values of the first row of the tensor.
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setConstant(1000);
+a.setValues({{10, 20, 30}});
+std::cout << "a" << endl << a << endl << endl;
+// a
+// 10   20   30
+// 1000 1000 1000
+```
+
+### \<Tensor-Type\> setRandom()
+
+Fills the tensor with random values.  Returns the tensor itself in case you
+want to chain another call.
+
+```cpp
+a.setRandom();
+std::cout << "Random: " << endl << a << endl << endl;
+// Random:
+//   0.680375    0.59688  -0.329554    0.10794
+//  -0.211234   0.823295   0.536459 -0.0452059
+//   0.566198  -0.604897  -0.444451   0.257742
+```
+
+You can customize `setRandom()` by providing your own random number
+generator as a template argument:
+
+```cpp
+a.setRandom<MyRandomGenerator>();
+```
+
+Here, `MyRandomGenerator` must be a struct with the following member
+functions, where Scalar and Index are the same as `<Tensor-Type>::Scalar`
+and `<Tensor-Type>::Index`.
+
+See `struct UniformRandomGenerator` in TensorFunctors.h for an example.
+
+```cpp
+// Custom number generator for use with setRandom().
+struct MyRandomGenerator {
+  // Default and copy constructors. Both are needed
+  MyRandomGenerator() { }
+  MyRandomGenerator(const MyRandomGenerator& ) { }
+
+  // Return a random value to be used.  "element_location" is the
+  // location of the entry to set in the tensor, it can typically
+  // be ignored.
+  Scalar operator()(Eigen::DenseIndex element_location,
+                    Eigen::DenseIndex /*unused*/ = 0) const {
+    return <randomly generated value of type T>;
+  }
+
+  // Same as above but generates several numbers at a time.
+  typename internal::packet_traits<Scalar>::type packetOp(
+      Eigen::DenseIndex packet_location, Eigen::DenseIndex /*unused*/ = 0) const {
+    return <a packet of randomly generated values>;
+  }
+};
+```
+
+You can also use one of the 2 random number generators that are part of the
+tensor library:
+*   UniformRandomGenerator
+*   NormalRandomGenerator
+
+## Data Access
+
+The Tensor, TensorFixedSize, and TensorRef classes provide the following
+accessors to access the tensor coefficients:
+
+```cpp
+const Scalar& operator()(const array<Index, NumIndices>& indices)
+const Scalar& operator()(Index firstIndex, IndexTypes... otherIndices)
+Scalar& operator()(const array<Index, NumIndices>& indices)
+Scalar& operator()(Index firstIndex, IndexTypes... otherIndices)
+```
+
+The number of indices must be equal to the rank of the tensor. Moreover, these
+accessors are not available on tensor expressions. In order to access the
+values of a tensor expression, the expression must either be evaluated or
+wrapped in a TensorRef.
+
+### Scalar* data() and const Scalar* data() const
+
+Returns a pointer to the storage for the tensor.  The pointer is const if the
+tensor was const.  This allows direct access to the data.  The layout of the
+data depends on the tensor layout: `RowMajor` or `ColMajor`.
+
+This access is usually only needed for special cases, for example when mixing
+Eigen Tensor code with other libraries.
+
+Scalar is the type of data stored in the tensor.
+
+```cpp
+Eigen::Tensor<float, 2> a(3, 4);
+float* a_data = a.data();
+a_data[0] = 123.45f;
+std::cout << "a(0, 0): " << a(0, 0);
+// a(0, 0): 123.45
+```
+
+## Tensor Operations
+
+All the methods documented below return non evaluated tensor `Operations`.
+These can be chained: you can apply another `Tensor` Operation to the value
+returned by the method.
+
+The chain of Operation is evaluated lazily, typically when it is assigned to a
+tensor.  See **Controlling When Expressions are Evaluated** for more details about
+their evaluation.
+
+### (Operation) constant(const Scalar& val)
+
+Returns a tensor of the same type and dimensions as the original tensor but
+where all elements have the value `val`.
+
+This is useful, for example, when you want to add or subtract a constant from a
+tensor, or multiply every element of a tensor by a scalar.
+However, such operations can also be performed using operator overloads (see `operator+`).
+
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setConstant(1.0f);
+Eigen::Tensor<float, 2> b = a + a.constant(2.0f);
+Eigen::Tensor<float, 2> c = b * b.constant(0.2f);
+std::cout << "a" << endl << a << endl << endl;
+std::cout << "b" << endl << b << endl << endl;
+std::cout << "c" << endl << c << endl << endl;
+// a
+// 1 1 1
+// 1 1 1
+
+// b
+// 3 3 3
+// 3 3 3
+
+// c
+// 0.6 0.6 0.6
+// 0.6 0.6 0.6
+```
+
+### (Operation) random()
+
+Returns a tensor of the same type and dimensions as the current tensor
+but where all elements have random values.
+
+This is for example useful to add random values to an existing tensor.
+The generation of random values can be customized in the same manner
+as for `setRandom()`.
+
+With the built-in generators every value is a pure function of the
+generator's seed and the element's index, so a random expression evaluates
+to the same values each time it is used, whether by coefficient, by packet,
+by block, or across threads:
+
+```cpp
+auto expr = a.random();
+Eigen::Tensor<float, 2> first = expr;
+Eigen::Tensor<float, 2> second = expr;  // the same values as first
+```
+
+This also holds when no seed is given: the default seed of zero selects one
+when the generator is constructed. To draw a new fill, construct a new random
+expression or call `setRandom()` again; to reproduce a fill, pass a seed:
+
+```cpp
+Eigen::Tensor<float, 2> b = a.random(Eigen::internal::UniformRandomGenerator<float>(42));
+```
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setConstant(1.0f);
+Eigen::Tensor<float, 2> b = a + a.random();
+std::cout << "a\n" << a << "\n\n";
+std::cout << "b\n" << b << "\n\n";
+
+// a
+// 1 1 1
+// 1 1 1
+// b
+// 1.68038   1.5662  1.82329
+// 0.788766  1.59688
+```
+
+## Unary Element Wise Operations
+
+All these operations take a single input tensor as argument and return a tensor
+of the same type and dimensions as the tensor to which they are applied.  The
+requested operations are applied to each element independently.
+
+### (Operation) operator-()
+
+Returns a tensor of the same type and dimensions as the original tensor
+containing the opposite values of the original tensor.
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setConstant(1.0f);
+Eigen::Tensor<float, 2> b = -a;
+std::cout << "a\n" << a << "\n\n";
+std::cout << "b\n" << b << "\n\n";
+
+// a
+// 1 1 1
+// 1 1 1
+//
+// b
+// -1 -1 -1
+// -1 -1 -1
+```
+
+### (Operation) sqrt()
+
+Returns a tensor containing the square roots of the original tensor.
+
+### (Operation) rsqrt()
+
+Returns a tensor containing the inverse square roots (1/sqrt(x)) of the original tensor.
+
+### (Operation) square()
+
+Returns a tensor containing the squares of the original tensor values.
+
+### (Operation) cube()
+
+Returns a tensor containing the cubes (x^3) of the original tensor values.
+
+### (Operation) inverse()
+
+Returns a tensor containing the inverse (1/x) of the original tensor values.
+
+### (Operation) exp()
+
+Returns a tensor containing the exponential of the original tensor.
+
+### (Operation) expm1()
+
+Returns a tensor containing `exp(x) - 1` for each element. More accurate
+than `exp(x) - 1` for small values of x.
+
+### (Operation) log()
+
+Returns a tensor containing the natural logarithms of the original tensor.
+
+### (Operation) log1p()
+
+Returns a tensor containing `log(1 + x)` for each element. More accurate
+than `log(1 + x)` for small values of x.
+
+### (Operation) log2()
+
+Returns a tensor containing the base-2 logarithms of the original tensor.
+
+### (Operation) abs()
+
+Returns a tensor containing the absolute values of the original tensor.
+
+### (Operation) sign()
+
+Returns a tensor containing the sign (-1, 0, or +1) of each element.
+
+### (Operation) arg()
+
+Returns a tensor containing the complex argument (phase angle) of the
+values of the original tensor.
+
+### (Operation) real()
+
+Returns a tensor containing the real part of the complex values of the
+original tensor.  The result has a real-valued scalar type.
+
+### (Operation) imag()
+
+Returns a tensor containing the imaginary part of the complex values of
+the original tensor. The result has a real-valued scalar type.
+
+### (Operation) conjugate()
+
+Returns a tensor containing the complex conjugate of each element.
+For real-valued tensors, this is a no-op.
+
+### (Operation) pow(Scalar exponent)
+
+Returns a tensor containing the coefficients of the original tensor raised
+to the power of the exponent.
+
+The type of the exponent, Scalar, is always the same as the type of the
+tensor coefficients.  For example, only integer exponents can be used in
+conjunction with tensors of integer values.
+
+You can use `cast()` to lift this restriction.  For example this computes
+cubic roots of an int Tensor:
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 1, 8}, {27, 64, 125}});
+Eigen::Tensor<double, 2> b = a.cast<double>().pow(1.0 / 3.0);
+std::cout << "a" << endl << a << endl << endl;
+std::cout << "b" << endl << b << endl << endl;
+
+// a
+// 0   1   8
+// 27  64 125
+//
+// b
+// 0 1 2
+// 3 4 5
+```
+
+### (Operation) clip(Scalar min_val, Scalar max_val)
+
+Returns a tensor with each element clamped to the range `[min_val, max_val]`.
+
+```cpp
+Eigen::Tensor<float, 1> a(5);
+a.setValues({-2.0f, -0.5f, 0.0f, 0.5f, 2.0f});
+Eigen::Tensor<float, 1> b = a.clip(-1.0f, 1.0f);
+// b: -1 -0.5  0  0.5  1
+```
+
+### Rounding Operations
+
+### (Operation) round()
+
+Returns a tensor with each element rounded to the nearest integer.
+
+### (Operation) rint()
+
+Returns a tensor with each element rounded to the nearest integer
+(using the current rounding mode).
+
+### (Operation) ceil()
+
+Returns a tensor with each element rounded up to the nearest integer.
+
+### (Operation) floor()
+
+Returns a tensor with each element rounded down to the nearest integer.
+
+### Predicates
+
+### (Operation) (isnan)()
+
+Returns a bool tensor indicating which elements are NaN.
+
+```cpp
+Eigen::Tensor<float, 1> a(3);
+a.setValues({1.0f, std::numeric_limits<float>::quiet_NaN(), 3.0f});
+Eigen::Tensor<bool, 1> b = a.isnan().cast<bool>();
+// b: false true false
+```
+
+### (Operation) (isinf)()
+
+Returns a bool tensor indicating which elements are infinite.
+
+### (Operation) (isfinite)()
+
+Returns a bool tensor indicating which elements are finite (not NaN or Inf).
+
+### Hyperbolic and Activation Functions
+
+### (Operation) tanh()
+
+Returns a tensor containing the hyperbolic tangent of each element.
+
+### (Operation) sigmoid()
+
+Returns a tensor containing the logistic sigmoid (1/(1+exp(-x))) of each element.
+
+### Error Functions
+
+### (Operation) erf()
+
+Returns a tensor containing the error function of each element.
+
+### (Operation) erfc()
+
+Returns a tensor containing the complementary error function (1 - erf(x)) of each element.
+
+### (Operation) ndtri()
+
+Returns a tensor containing the inverse of the normal cumulative distribution function of each element.
+
+### Special Math Functions
+
+These require including `<contrib/Eigen/SpecialFunctions>` in addition to
+the Tensor header.
+
+### (Operation) lgamma()
+
+Returns a tensor containing the log-gamma function of each element.
+
+### (Operation) digamma()
+
+Returns a tensor containing the digamma (psi) function of each element.
+
+### (Operation) bessel_i0(), bessel_i0e(), bessel_i1(), bessel_i1e()
+
+Modified Bessel functions of the first kind. The `e` variants are exponentially scaled.
+
+### (Operation) bessel_j0(), bessel_j1()
+
+Bessel functions of the first kind.
+
+### (Operation) bessel_y0(), bessel_y1()
+
+Bessel functions of the second kind.
+
+### (Operation) bessel_k0(), bessel_k0e(), bessel_k1(), bessel_k1e()
+
+Modified Bessel functions of the second kind. The `e` variants are exponentially scaled.
+
+### (Operation) igamma(const OtherDerived& other)
+
+Regularized lower incomplete gamma function. `this` is the parameter `a` and
+`other` is `x`.
+
+### (Operation) igammac(const OtherDerived& other)
+
+Regularized upper incomplete gamma function (1 - igamma).
+
+### (Operation) zeta(const OtherDerived& other)
+
+Riemann zeta function. `this` is `x` and `other` is `q`.
+
+### (Operation) polygamma(const OtherDerived& other)
+
+Polygamma function. `this` is `n` and `other` is `x`.
+
+### Scalar Arithmetic
+
+### (Operation) operator*(Scalar s)
+
+Multiplies every element of the input tensor by the scalar `s`:
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{1, 2, 3},
+                {4, 5, 6}});
+Eigen::Tensor<int,2> scaled_a = a * 2;
+
+std::cout << "a\n" << a << "\n";
+std::cout << "scaled_a\n" << scaled_a << "\n";
+
+// a
+// 1 2 3
+// 4 5 6
+//
+// scaled_a
+// 2  4  6
+// 8 10 12
+```
+### (Operation) operator+ (Scalar s)
+Adds `s` to every element in the tensor.
+
+### (Operation) operator- (Scalar s)
+Subtracts `s` from every element in the tensor.
+
+### (Operation) operator/ (Scalar s)
+Divides every element in the tensor by `s`.
+
+### (Operation) operator% (Scalar s)
+Computes the element-wise modulus (remainder) of each tensor element divided by `s`.
+
+**Only integer types are supported.**
+For floating-point tensors, implement a `unaryExpr` using `std::fmod`.
+
+### (Operation)  cwiseMax(Scalar threshold)
+Returns a tensor where each element is the maximum of the original element and the
+scalar threshold.
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500}});
+
+Eigen::Tensor<int, 2> b(2, 3);
+b.setValues({{-1, -2, 300}, {-4, 555, -6}});
+
+Eigen::Tensor<int, 2> c = a.cwiseMax(b);
+
+std::cout << "a\n" << a << "\n"
+            << "b\n" << b << "\n"
+            << "c\n" << c << "\n";
+
+// a
+//   0 100 200
+// 300 400 500
+
+// b
+// -1  -2 300
+// -4 555  -6
+
+// c
+//   0 100 300
+// 300 555 500
+```
+### (Operation)  cwiseMin(Scalar threshold)
+Returns a tensor where each element is the minimum of the original element and the
+scalar threshold.
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 2);
+a.setValues({{0, 100}, {300, -900}});
+
+Eigen::Tensor<int, 2> b(2, 2);
+b.setValues({{-1, -2}, {400, 555}});
+
+Eigen::Tensor<int, 2> c = a.cwiseMin(b);
+
+std::cout << "a\n" << a << "\n"
+          << "b\n" << b << "\n"
+          << "c\n" << c << "\n";
+
+// a
+//   0  100
+// 300 -900
+
+// b
+//  -1  -2
+// 400 555
+
+// c
+//  -1   -2
+// 300 -900
+```
+
+### NaN Propagation for cwiseMax and cwiseMin
+
+The `cwiseMax` and `cwiseMin` operations accept an optional template parameter
+controlling NaN propagation:
+
+*   `cwiseMax<Eigen::PropagateNaN>(other)` — if either operand is NaN, the result is NaN.
+*   `cwiseMax<Eigen::PropagateNumbers>(other)` — NaN is treated as missing; the non-NaN value wins.
+*   `cwiseMax(other)` — default behavior (fast; may or may not propagate NaN, depends on platform).
+
+```cpp
+Eigen::Tensor<float, 1> a(3), b(3);
+a.setValues({1.0f, NAN, 3.0f});
+b.setValues({2.0f, 2.0f, NAN});
+
+Eigen::Tensor<float, 1> c = a.cwiseMax<Eigen::PropagateNaN>(b);
+// c: 2.0, NaN, NaN
+
+Eigen::Tensor<float, 1> d = a.cwiseMax<Eigen::PropagateNumbers>(b);
+// d: 2.0, 2.0, 3.0
+```
+
+
+### (Operation)  unaryExpr(const CustomUnaryOp& func)
+Applies a user defined function to each element in the tensor.
+Supports lambdas or functor structs with an operator().
+
+Using lambda:
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setValues({{0, -.5, -1}, {.5, 1.5, 2.0}});
+auto my_func = [](float el){ return std::abs(el + 0.5f);};
+Eigen::Tensor<float, 2> b = a.unaryExpr(my_func);
+std::cout << "a\n" << a << "\n"
+        << "b\n" << b << "\n";
+=>
+a
+    0  -0.5   -1
+0.5   1.5    2
+b
+0.5     0  0.5
+    1     2  2.5
+```
+
+Using a functor to normalize and clamp values to `[-1.0, 1.0]`:
+
+```cpp
+template<typename Scalar>
+struct NormalizedClamp {
+NormalizedClamp(Scalar lo, Scalar hi) : _lo(lo), _hi(hi) {}
+Scalar operator()(Scalar x) const {
+    if (x < _lo) return Scalar(0);
+    if (x > _hi) return Scalar(1);
+    return (x - _lo) / (_hi - _lo);
+}
+Scalar _lo, _hi;
+};
+
+Eigen::Tensor<float, 2> c = a.unaryExpr(NormalizedClamp<float>(-1.0f, 1.0f));
+std::cout << "c\n" << c << "\n";
+
+// c
+// 0.5    0.25    0
+// 0.75   1       1
+```
+
+### Bitwise and Boolean Unary Operations
+
+### (Operation) operator~()
+
+Bitwise NOT of each element (integer types only).
+
+### (Operation) operator!()
+
+Boolean NOT of each element.
+
+
+## Binary Element Wise Operations
+
+These operations take two input tensors as arguments. The 2 input tensors should
+be of the same type and dimensions. The result is a tensor of the same
+dimensions as the tensors to which they are applied, and unless otherwise
+specified it is also of the same type. The requested operations are applied to
+each pair of elements independently.
+
+### (Operation) operator+(const OtherDerived& other)
+
+Returns a tensor of the same type and dimensions as the input tensors
+containing the coefficient wise sums of the inputs.
+
+### (Operation) operator-(const OtherDerived& other)
+
+Returns a tensor of the same type and dimensions as the input tensors
+containing the coefficient wise differences of the inputs.
+
+### (Operation) operator*(const OtherDerived& other)
+
+Returns a tensor of the same type and dimensions as the input tensors
+containing the coefficient wise products of the inputs.
+
+### (Operation) operator/(const OtherDerived& other)
+
+Returns a tensor of the same type and dimensions as the input tensors
+containing the coefficient wise quotients of the inputs.
+
+This operator is not supported for integer types.
+
+### (Operation) cwiseMax(const OtherDerived& other)
+
+Returns a tensor of the same type and dimensions as the input tensors
+containing the coefficient wise maximums of the inputs.
+
+### (Operation) cwiseMin(const OtherDerived& other)
+
+Returns a tensor of the same type and dimensions as the input tensors
+containing the coefficient wise minimums of the inputs.
+
+### (Operation) binaryExpr(const OtherDerived& other, const CustomBinaryOp& func)
+
+Applies a custom binary functor element-wise to two tensors.
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3), b(2, 3);
+a.setRandom(); b.setRandom();
+auto my_op = [](float x, float y) { return x * x + y * y; };
+Eigen::Tensor<float, 2> c = a.binaryExpr(b, my_op);
+```
+
+### (Operation) Logical operators
+
+The following boolean operators are supported:
+
+ * `operator&&(const OtherDerived& other)`
+ * `operator||(const OtherDerived& other)`
+ * `operator<(const OtherDerived& other)`
+ * `operator<=(const OtherDerived& other)`
+ * `operator>(const OtherDerived& other)`
+ * `operator>=(const OtherDerived& other)`
+ * `operator==(const OtherDerived& other)`
+ * `operator!=(const OtherDerived& other)`
+
+ as well as bitwise operators:
+
+ * `operator&(const OtherDerived& other)`
+ * `operator|(const OtherDerived& other)`
+ * `operator^(const OtherDerived& other)`
+
+The comparison operators (`<`, `<=`, `>`, `>=`, `==`, `!=`) produce a tensor
+whose scalar type is `bool`.  The boolean and bitwise operators retain the
+input scalar type.
+
+Scalar comparison variants are also available (e.g. `a < 0.5f`), and likewise
+produce a `bool` tensor.
+
+## Selection (select(const ThenDerived& thenTensor, const ElseDerived& elseTensor)
+
+Selection is a coefficient-wise ternary operator that is the tensor equivalent
+to the if-then-else operation.
+
+```cpp
+    Tensor<bool, 3> if = ...;
+    Tensor<float, 3> then = ...;
+    Tensor<float, 3> else = ...;
+    Tensor<float, 3> result = if.select(then, else);
+```
+
+The 3 arguments must be of the same dimensions, which will also be the dimension
+of the result.  The 'if' tensor must be of type boolean, the 'then' and the
+'else' tensor must be of the same type, which will also be the type of the
+result.
+
+Each coefficient in the result is equal to the corresponding coefficient in the
+'then' tensor if the corresponding value in the 'if' tensor is true. If not, the
+resulting coefficient will come from the 'else' tensor.
+
+
+## Contraction
+
+Tensor *contractions* are a generalization of the matrix product to the
+multidimensional case.
+
+```cpp
+// Create 2 matrices using tensors of rank 2
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{1, 2, 3}, {6, 5, 4}});
+Eigen::Tensor<int, 2> b(3, 2);
+b.setValues({{1, 2}, {4, 5}, {5, 6}});
+
+// Compute the traditional matrix product
+Eigen::array<Eigen::IndexPair<int>, 1> product_dims = { Eigen::IndexPair<int>(1, 0) };
+Eigen::Tensor<int, 2> AB = a.contract(b, product_dims);
+
+// Compute the product of the transpose of the matrices
+Eigen::array<Eigen::IndexPair<int>, 1> transposed_product_dims = { Eigen::IndexPair<int>(0, 1) };
+Eigen::Tensor<int, 2> AtBt = a.contract(b, transposed_product_dims);
+
+// Contraction to scalar value using a double contraction.
+// First coordinate of both tensors are contracted as well as both second coordinates, i.e., this computes the sum of the squares of the elements.
+Eigen::array<Eigen::IndexPair<int>, 2> double_contraction_product_dims = { Eigen::IndexPair<int>(0, 0), Eigen::IndexPair<int>(1, 1) };
+Eigen::Tensor<int, 0> AdoubleContractedA = a.contract(a, double_contraction_product_dims);
+
+// Extracting the scalar value of the tensor contraction for further usage
+int value = AdoubleContractedA(0);
+```
+
+## Reduction Operations
+
+A *Reduction* operation returns a tensor with fewer dimensions than the
+original tensor.  The values in the returned tensor are computed by applying a
+*reduction operator* to slices of values from the original tensor.  You specify
+the dimensions along which the slices are made.
+
+The Eigen Tensor library provides a set of predefined reduction operators such
+as `maximum()` and `sum()` and lets you define additional operators by
+implementing a few methods from a reductor template.
+
+### Reduction Dimensions
+
+All reduction operations take a single parameter of type
+`<TensorType>::``Dimensions` which can always be specified as an array of
+ints.  These are called the "reduction dimensions."  The values are the indices
+of the dimensions of the input tensor over which the reduction is done.  The
+parameter can have at most as many element as the rank of the input tensor;
+each element must be less than the tensor rank, as it indicates one of the
+dimensions to reduce.
+
+Each dimension of the input tensor should occur at most once in the reduction
+dimensions as the implementation does not remove duplicates.
+
+The order of the values in the reduction dimensions does not affect the
+results, but the code may execute faster if you list the dimensions in
+increasing order.
+
+Example: Reduction along one dimension.
+```cpp
+// Create a tensor of 2 dimensions
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{1, 2, 3}, {6, 5, 4}});
+// Reduce it along the second dimension (1)...
+Eigen::array<int, 1> dims{1 /* dimension to reduce */};
+// ...using the "maximum" operator.
+// The result is a tensor with one dimension.  The size of
+// that dimension is the same as the first (non-reduced) dimension of a.
+Eigen::Tensor<int, 1> b = a.maximum(dims);
+std::cout << "a" << endl << a << endl << endl;
+std::cout << "b" << endl << b << endl << endl;
+
+// a
+// 1 2 3
+// 6 5 4
+
+// b
+// 3
+// 6
+```
+Example: Reduction along two dimensions.
+```cpp
+Eigen::Tensor<float, 3, Eigen::ColMajor> a(2, 3, 4);
+a.setValues({{{0.0f, 1.0f, 2.0f, 3.0f},
+                {7.0f, 6.0f, 5.0f, 4.0f},
+                {8.0f, 9.0f, 10.0f, 11.0f}},
+                {{12.0f, 13.0f, 14.0f, 15.0f},
+                {19.0f, 18.0f, 17.0f, 16.0f},
+                {20.0f, 21.0f, 22.0f, 23.0f}}});
+// The tensor a has 3 dimensions.  We reduce along the
+// first 2, resulting in a tensor with a single dimension
+// of size 4 (the last dimension of a.)
+// Note that we pass the array of reduction dimensions
+// directly to the maximum() call.
+Eigen::Tensor<float, 1, Eigen::ColMajor> b =
+    a.maximum(Eigen::array<int, 2>{0, 1});
+std::cout << "b" << endl << b << endl << endl;
+
+// b
+// 20
+// 21
+// 22
+// 23
+```
+#### Reduction along all dimensions
+
+The no-argument overloads of `sum()`, `mean()`, `prod()`, `maximum()`,
+`minimum()`, `all()`, and `any()` reduce the original tensor along *all* its
+dimensions.  The result is a rank-0 `TensorReductionOp`, which can be assigned
+directly to its exact scalar result type.  The dimension-taking overloads of
+these operations, as well as `reduce()`, provide the same conversion when the
+reduction dimensions contain every dimension of the input.
+
+```cpp
+Eigen::Tensor<float, 3> a(2, 3, 4);
+a.setValues({{{0.0f, 1.0f, 2.0f, 3.0f},
+              {7.0f, 6.0f, 5.0f, 4.0f},
+              {8.0f, 9.0f, 10.0f, 11.0f}},
+              {{12.0f, 13.0f, 14.0f, 15.0f},
+              {19.0f, 18.0f, 17.0f, 16.0f},
+              {20.0f, 21.0f, 22.0f, 23.0f}}});
+// An exact scalar target evaluates the rank-0 reduction immediately.
+const float b = a.sum();
+std::cout << "b\n" << b;
+
+// b
+// 276
+```
+A scalar target of the reduction result's exact type must be supplied by the
+context.  A bare `auto` declaration supplies no target and therefore keeps the
+lazy reduction expression:
+
+```cpp
+// auto preserves the expression type; the scalar cast forces evaluation.
+auto sum_expression = a.sum();
+const auto sum = static_cast<float>(a.sum());
+```
+
+For example, a reduction with a `float` result cannot convert directly to
+`double`.  First evaluate it as `float`, as in the `static_cast` above, and then
+convert the resulting scalar to `double`.  Reductions such as `all()` and
+`any()` have `bool` as their exact scalar result type, regardless of the input
+tensor's scalar type.
+
+The conversion is available only when the reduction removes every dimension;
+partial reductions remain tensor expressions.  It evaluates immediately on
+the default device, and each conversion evaluates the expression again.  Store
+the result when it will be used more than once.
+
+The conversion applies to the full reduction itself.  Expressions such as
+`2 * a.sum()` and `a.sum() > 0` remain lazy rank-0 tensor expressions.  For
+ordinary scalar arithmetic or comparisons, evaluate the reduction first:
+
+```cpp
+const float sum = a.sum();
+const float twice_sum = 2 * sum;
+const bool positive = sum > 0;
+```
+
+To evaluate on a specific device, retain a rank-0 tensor result:
+
+```cpp
+Eigen::Tensor<float, 0> result;
+result.device(device) = a.sum();
+```
+
+### (Operation) sum(const Dimensions& reduction_dims)
+### (Operation) sum()
+
+Reduce a tensor using the `sum()` operator.  The resulting values
+are the sum of the reduced values.
+
+### (Operation) mean(const Dimensions& reduction_dims)
+### (Operation) mean()
+
+Reduce a tensor using the `mean()` operator.  The resulting values
+are the mean of the reduced values.
+
+### (Operation) maximum(const Dimensions& reduction_dims)
+### (Operation) maximum()
+
+Reduce a tensor using the `maximum()` operator.  The resulting values are the
+largest of the reduced values.
+
+### (Operation) minimum(const Dimensions& reduction_dims)
+### (Operation) minimum()
+
+Reduce a tensor using the `minimum()` operator.  The resulting values
+are the smallest of the reduced values.
+
+### NaN Propagation for maximum and minimum
+
+Like `cwiseMax` and `cwiseMin`, the `maximum` and `minimum` reductions accept
+an optional NaN propagation template parameter:
+
+```cpp
+// If any element along the reduction is NaN, the result is NaN.
+Eigen::Tensor<float, 1> b = a.maximum<Eigen::PropagateNaN>(dims);
+
+// NaN values are ignored during reduction.
+Eigen::Tensor<float, 1> c = a.maximum<Eigen::PropagateNumbers>(dims);
+```
+
+### (Operation) prod(const Dimensions& reduction_dims)
+### (Operation) prod()
+
+Reduce a tensor using the `prod()` operator.  The resulting values
+are the product of the reduced values.
+
+### (Operation) all(const Dimensions& reduction_dims)
+### (Operation) all()
+Reduce a tensor using the `all()` operator.  Casts tensor to bool and then checks
+whether all elements are true.  Runs through all elements rather than
+short-circuiting, so may be significantly inefficient.
+
+### (Operation) any(const Dimensions& reduction_dims)
+### (Operation) any()
+Reduce a tensor using the `any()` operator.  Casts tensor to bool and then checks
+whether any element is true.  Runs through all elements rather than
+short-circuiting, so may be significantly inefficient.
+
+
+### (Operation) argmax(const Dimensions& reduction_dim)
+### (Operation) argmax()
+
+Reduce a tensor using the `argmax()` operator.
+
+The resulting values are the indices of the largest elements along the specified dimension.
+
+Only a single `reduction_dim` is supported.
+
+If multiple elements share the maximum value, the one with the **lowest index** is returned.
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setValues({{1, 4, 8}, {3, 4, 2}});
+
+Eigen::Tensor<Eigen::Index, 1> argmax_dim0 = a.argmax(0);
+
+std::cout << "a:\n" << a << "\n";
+for (int i = 0; i < argmax_dim0.size(); ++i) {
+    std::cout << "argmax along dim 0 at index " << i << " = " << argmax_dim0(i) << "\n";
+}
+
+// a:
+// 1 4 8
+// 3 4 2
+// argmax along dim 0 at index 0 = 1
+// argmax along dim 0 at index 1 = 0
+// argmax along dim 0 at index 2 = 0
+```
+
+ To compute the index of the global maximum, use the overload without arguments (which flattens the tensor).
+
+
+```cpp
+Eigen::Tensor<Eigen::Index, 0> argmax_flat = a.argmax();
+std::cout << "Flat argmax index: " << argmax_flat();
+
+// Flat argmax index: 4
+```
+
+### (Operation) argmin(const Dimensions& reduction_dim)
+### (Operation) argmin()
+See `argmax`.
+
+### (Operation) reduce(const Dimensions& reduction_dims, const Reducer& reducer)
+
+Reduce a tensor using a user-defined reduction operator.  See `SumReducer`
+in TensorFunctors.h for information on how to implement a reduction operator.
+
+
+## Trace
+
+A *Trace* operation returns a tensor with fewer dimensions than the original
+tensor. It returns a tensor whose elements are the sum of the elements of the
+original tensor along the main diagonal for a list of specified dimensions, the
+"trace dimensions". Similar to the `Reduction Dimensions`, the trace dimensions
+are passed as an input parameter to the operation, are of type `<TensorType>::``Dimensions`
+, and have the same requirements when passed as an input parameter. In addition,
+the trace dimensions must have the same size.
+
+Example: Trace along 2 dimensions.
+
+```cpp
+// Create a tensor of 3 dimensions
+Eigen::Tensor<int, 3> a(2, 2, 3);
+a.setValues({{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}});
+// Specify the dimensions along which the trace will be computed.
+// In this example, the trace can only be computed along the dimensions
+// with indices 0 and 1
+Eigen::array<int, 2> dims{0, 1};
+// The output tensor contains all but the trace dimensions.
+Tensor<int, 1> a_trace = a.trace(dims);
+std::cout << "a_trace:" << endl;
+std::cout << a_trace << endl;
+
+// a_trace:
+// 11
+// 13
+// 15
+```
+
+### (Operation) trace(const Dimensions& new_dims)
+### (Operation) trace()
+
+As a special case, if no parameter is passed to the operation, trace is computed
+along *all* dimensions of the input tensor.
+
+Example: Trace along all dimensions.
+
+```cpp
+// Create a tensor of 3 dimensions, with all dimensions having the same size.
+Eigen::Tensor<int, 3> a(3, 3, 3);
+a.setValues({{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
+            {{10, 11, 12}, {13, 14, 15}, {16, 17, 18}},
+            {{19, 20, 21}, {22, 23, 24}, {25, 26, 27}}});
+// Result is a zero dimension tensor
+Tensor<int, 0> a_trace = a.trace();
+std::cout<<"a_trace:"<<endl;
+std::cout<<a_trace<<endl;
+
+// a_trace:
+// 42
+```
+
+## Scan Operations
+
+A *Scan* operation returns a tensor with the same dimensions as the original
+tensor. The operation performs an inclusive scan along the specified
+axis, which means it computes a running total along the axis for a given
+reduction operation.
+If the reduction operation corresponds to summation, then this computes the
+prefix sum of the tensor along the given axis.
+
+Example:
+Cumulative sum along the second dimension
+
+```cpp
+// Create a tensor of 2 dimensions
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{1, 2, 3}, {4, 5, 6}});
+// Scan it along the second dimension (1) using summation
+Eigen::Tensor<int, 2> b = a.cumsum(1);
+// The result is a tensor with the same size as the input
+std::cout << "a" << endl << a << endl << endl;
+std::cout << "b" << endl << b << endl << endl;
+
+// a
+// 1 2 3
+// 4 5 6
+
+// b
+// 1  3  6
+// 4  9 15
+```
+
+### (Operation) cumsum(const Index& axis, bool exclusive = false)
+
+Perform a scan by summing consecutive entries.
+
+When `exclusive` is true, element `i` contains the sum of all elements before
+index `i` (exclusive prefix sum). The first element along the axis is 0.
+
+```cpp
+Eigen::Tensor<int, 1> a(4);
+a.setValues({1, 2, 3, 4});
+
+Eigen::Tensor<int, 1> inclusive = a.cumsum(0);           // 1, 3, 6, 10
+Eigen::Tensor<int, 1> exclusive = a.cumsum(0, true);     // 0, 1, 3, 6
+```
+
+### (Operation) cumprod(const Index& axis, bool exclusive = false)
+
+Perform a scan by multiplying consecutive entries.
+
+When `exclusive` is true, element `i` contains the product of all elements
+before index `i`. The first element along the axis is 1.
+
+```cpp
+Eigen::Tensor<int, 1> a(4);
+a.setValues({1, 2, 3, 4});
+
+Eigen::Tensor<int, 1> inclusive = a.cumprod(0);           // 1, 2, 6, 24
+Eigen::Tensor<int, 1> exclusive = a.cumprod(0, true);     // 1, 1, 2, 6
+```
+
+## Convolutions
+
+### (Operation) convolve(const Kernel& kernel, const Dimensions& dims)
+
+Returns a tensor that is the output of the convolution of the input tensor with the kernel,
+along the specified dimensions of the input tensor. The dimension size for dimensions of the output tensor
+which were part of the convolution will be reduced by the formula:
+```cpp
+output_dim_size = input_dim_size - kernel_dim_size + 1 // (requires: input_dim_size >= kernel_dim_size).
+```
+The dimension sizes for dimensions that were not part of the convolution will remain the same.
+Performance of the convolution can depend on the length of the stride(s) of the input tensor dimension(s) along which the
+convolution is computed (the first dimension has the shortest stride for `ColMajor`, whereas `RowMajor`'s shortest stride is
+for the last dimension).
+
+```cpp
+// Compute convolution along the second and third dimension.
+Tensor<float, 4, DataLayout> input(3, 3, 7, 11);
+Tensor<float, 2, DataLayout> kernel(2, 2);
+Tensor<float, 4, DataLayout> output(3, 2, 6, 11);
+input.setRandom();
+kernel.setRandom();
+
+Eigen::array<ptrdiff_t, 2> dims{1, 2};  // Specify second and third dimension for convolution.
+output = input.convolve(kernel, dims);
+
+for (int i = 0; i < 3; ++i) {
+  for (int j = 0; j < 2; ++j) {
+    for (int k = 0; k < 6; ++k) {
+      for (int l = 0; l < 11; ++l) {
+        const float result = output(i,j,k,l);
+        const float expected = input(i,j+0,k+0,l) * kernel(0,0) +
+                               input(i,j+1,k+0,l) * kernel(1,0) +
+                               input(i,j+0,k+1,l) * kernel(0,1) +
+                               input(i,j+1,k+1,l) * kernel(1,1);
+        VERIFY_IS_APPROX(result, expected);
+      }
+    }
+  }
+}
+```
+
+## FFT (Fast Fourier Transform)
+
+### (Operation) fft\<FFTResultType, FFTDirection\>(const FFTDims& dims)
+
+Computes the Fast Fourier Transform of the input tensor along the specified
+dimensions.
+
+Template parameters:
+
+| Parameter | Values | Description |
+|-----------|--------|-------------|
+| `FFTResultType` | `RealPart`, `ImagPart`, `BothParts` | Which part(s) of the result to return |
+| `FFTDirection` | `FFT_FORWARD`, `FFT_REVERSE` | Forward or inverse transform |
+
+When `FFTResultType` is `BothParts`, the output scalar type is
+`std::complex<Scalar>`. When `RealPart` or `ImagPart`, the output retains
+the real scalar type.
+
+```cpp
+// Forward FFT of a 2D tensor along both dimensions.
+Eigen::Tensor<float, 2> input(8, 16);
+input.setRandom();
+Eigen::array<int, 2> fft_dims{{0, 1}};
+
+// Get the full complex result.
+Eigen::Tensor<std::complex<float>, 2> complex_result =
+    input.fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft_dims);
+
+// Get only the real part.
+Eigen::Tensor<float, 2> real_result =
+    input.fft<Eigen::RealPart, Eigen::FFT_FORWARD>(fft_dims);
+
+// Inverse FFT to recover the original signal.
+Eigen::Tensor<float, 2> recovered =
+    complex_result.fft<Eigen::RealPart, Eigen::FFT_REVERSE>(fft_dims);
+```
+
+The FFT uses the Cooley-Tukey algorithm for power-of-2 sizes and falls back to
+the Bluestein algorithm for arbitrary sizes.
+
+## Geometrical Operations
+
+These operations return a `Tensor` with different dimensions than the original
+`Tensor`.  They can be used to access slices of tensors, see them with different
+dimensions, or pad tensors with additional data.
+
+### (Operation) reshape(const Dimensions& new_dims)
+
+Returns a view of the input tensor that has been reshaped to the specified
+new dimensions.
+
+The argument `new_dims` is an array of Index values.
+
+The rank of the resulting tensor is equal to the number of elements in `new_dims`.
+
+The product of all the sizes in the new dimension array must be equal to
+the number of elements in the input tensor.
+
+```cpp
+// Increase the rank of the input tensor by introducing a new dimension
+// of size 1.
+Tensor<float, 2> input(7, 11);
+array<int, 3> three_dims{{7, 11, 1}};
+Tensor<float, 3> result = input.reshape(three_dims);
+
+// Decrease the rank of the input tensor by merging 2 dimensions;
+array<int, 1> one_dim{{7 * 11}};
+Tensor<float, 1> result = input.reshape(one_dim);
+```
+
+This operation does not move any data in the input tensor, so the resulting
+contents of a reshaped `Tensor` depend on the data layout of the original `Tensor`.
+
+For example this is what happens when you `reshape()` a 2D `ColMajor` tensor
+to one dimension:
+
+```cpp
+Eigen::Tensor<float, 2, Eigen::ColMajor> a(2, 3);
+a.setValues({{0.0f, 100.0f, 200.0f}, {300.0f, 400.0f, 500.0f}});
+Eigen::array<Eigen::DenseIndex, 1> one_dim{3 * 2};
+Eigen::Tensor<float, 1, Eigen::ColMajor> b = a.reshape(one_dim);
+std::cout << "b" << endl << b << endl;
+
+// b
+//   0
+// 300
+// 100
+// 400
+// 200
+// 500
+```
+
+This is what happens when the 2D `Tensor` is `RowMajor`:
+
+```cpp
+Eigen::Tensor<float, 2, Eigen::RowMajor> a(2, 3);
+a.setValues({{0.0f, 100.0f, 200.0f}, {300.0f, 400.0f, 500.0f}});
+Eigen::array<Eigen::DenseIndex, 1> one_dim{3 * 2};
+Eigen::Tensor<float, 1, Eigen::RowMajor> b = a.reshape(one_dim);
+std::cout << "b" << endl << b << endl;
+
+// b
+//   0
+// 100
+// 200
+// 300
+// 400
+// 500
+```
+
+The reshape operation is a lvalue. In other words, it can be used on the left
+side of the assignment operator.
+
+The previous example can be rewritten as follow:
+
+```cpp
+Eigen::Tensor<float, 2, Eigen::ColMajor> a(2, 3);
+a.setValues({{0.0f, 100.0f, 200.0f}, {300.0f, 400.0f, 500.0f}});
+Eigen::array<Eigen::DenseIndex, 2> two_dim{2, 3};
+Eigen::Tensor<float, 1, Eigen::ColMajor> b(6);
+b.reshape(two_dim) = a;
+std::cout << "b" << endl << b << endl;
+
+// b
+//   0
+// 300
+// 100
+// 400
+// 200
+// 500
+```
+
+Note that "b" itself was not reshaped but that instead the assignment is done to
+the reshape view of b.
+
+### (Operation) shuffle(const Shuffle& shuffle)
+
+Returns a view of the input tensor whose dimensions have been
+reordered according to the specified permutation.
+
+Pass the permutation as a concrete array object. A braced initializer list such as
+`input.shuffle({1, 2, 0})` cannot be used directly because the template parameter cannot be deduced from it.
+
+The argument `shuffle` is an array of `Index` values:
+* Its size is the rank of the input tensor.
+* It must contain a permutation of `[0, 1, ..., rank - 1]`.
+* The `i`-th dimension of the output tensor corresponds to the size of the dimension at position `shuffle[i]` in the input tensor. For example:
+
+```cpp
+// Shuffle all dimensions to the left by 1.
+Tensor<float, 3> input(20, 30, 50);
+// ... set some values in input.
+Eigen::array<Eigen::Index, 3> shuffle{{1, 2, 0}};
+Tensor<float, 3> output = input.shuffle(shuffle);
+
+eigen_assert(output.dimension(0) == 30);
+eigen_assert(output.dimension(1) == 50);
+eigen_assert(output.dimension(2) == 20);
+
+// Indices into the output tensor are shuffled accordingly to formulate
+// indices into the input tensor.
+eigen_assert(output(3, 7, 11) == input(11, 3, 7));
+
+// In general:
+eigen_assert(output(..., indices[shuffle[i]], ...) ==
+             input(..., indices[i], ...));
+```
+
+The shuffle operation results in a lvalue, which means that it can be assigned
+to. In other words, it can be used on the left side of the assignment operator.
+
+Let's rewrite the previous example to take advantage of this feature:
+
+```cpp
+// Shuffle all dimensions to the left by 1.
+Tensor<float, 3> input(20, 30, 50);
+input.setRandom();
+Tensor<float, 3> output(30, 50, 20);
+Eigen::array<Eigen::Index, 3> unshuffle{{2, 0, 1}};
+output.shuffle(unshuffle) = input;
+```
+
+### (Operation) stride(const Strides& strides)
+
+Returns a view of the input tensor that strides (skips stride-1
+elements) along each of the dimensions.
+
+The argument strides is an array of `Index` values:
+* Its size is the rank of the input tensor.
+* Must be >= 1
+
+ The dimensions of the resulting tensor are `ceil(input_dimensions[i] / strides[i])`.
+
+For example this is what happens when you `stride()` a 2D tensor:
+
+```cpp
+Eigen::Tensor<int, 2> a(4, 3);
+a.setValues({{0, 100, 200},
+             {300, 400, 500},
+             {600, 700, 800},
+             {900, 1000, 1100}});
+Eigen::array<Eigen::DenseIndex, 2> strides{3, 2};
+Eigen::Tensor<int, 2> b = a.stride(strides);
+std::cout << "b" << endl << b << endl;
+// b
+//    0   200
+//  900  1100
+```
+
+It is possible to assign a tensor to a stride:
+```cpp
+Tensor<float, 3> input(20, 30, 50);
+input.setRandom();
+Tensor<float, 3> output(40, 90, 200);
+output.stride({2, 3, 4}) = input;
+```
+
+### (Operation) slice(const StartIndices& offsets, const Sizes& extents)
+
+Returns a sub-tensor of the given tensor. For each dimension i, the slice is
+made of the coefficients stored between `offset[i]` and `offset[i] + extents[i]` in
+the input tensor.
+
+```cpp
+Eigen::Tensor<int, 2> a(4, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500},
+             {600, 700, 800}, {900, 1000, 1100}});
+Eigen::array<Eigen::Index, 2> offsets = {1, 0};
+Eigen::array<Eigen::Index, 2> extents = {2, 2};
+Eigen::Tensor<int, 2> slice = a.slice(offsets, extents);
+std::cout << "a" << endl << a << endl;
+// a
+//    0   100   200
+//  300   400   500
+//  600   700   800
+//  900  1000  1100
+
+std::cout << "slice" << endl << slice << endl;
+// slice
+//  300   400
+//  600   700
+```
+
+### (Operation) stridedSlice(const StartIndices& start, const StopIndices& stop, const Strides& strides)
+
+Returns a sub-tensor by selecting elements using `start`, `stop` (exclusive), and `strides` for each dimension.
+
+This is similar to slicing in Python using [start:stop:step].
+
+``` cpp
+Eigen::Tensor<int, 2> a(4, 6);
+a.setValues({{  0,  10,  20,  30,  40,   50},
+             {100, 110, 120, 130, 140,  150},
+             {200, 210, 220, 230, 240,  250},
+             {300, 310, 320, 330, 340,  350}});
+
+Eigen::array<Eigen::Index, 2> start = {1, 1};
+Eigen::array<Eigen::Index, 2> stop  = {4, 6}; // Stop is exclusive
+Eigen::array<Eigen::Index, 2> strides = {2, 2};
+
+Eigen::Tensor<int, 2> sub = a.stridedSlice(start, stop, strides);
+
+std::cout << "a\n" << a << "\n";
+std::cout << "sub\n" << sub << "\n";
+
+// a
+//   0  10  20  30  40  50
+// 100 110 120 130 140 150
+// 200 210 220 230 240 250
+// 300 310 320 330 340 350
+
+// sub
+// 110 130 150
+// 310 330 350
+```
+It is also possible to assign to a strided slice:
+
+``` cpp
+Eigen::Tensor<int, 2> b(sub.dimensions());
+b.setConstant(-1);
+a.stridedSlice(start, stop, strides) = b;
+std::cout << "modified a\n" << a << "\n";
+
+
+// modified a
+//   0  10  20  30  40  50
+// 100  -1 120  -1 140  -1
+// 200 210 220 230 240 250
+// 300  -1 320  -1 340  -1
+
+```
+### (Operation) chip(const Index offset, const Index dim)
+
+A chip is a special kind of slice.
+It is the subtensor at the given offset in the dimension `dim`.
+
+The returned tensor has one fewer dimension than the input tensor: the dimension dim is removed.
+
+For example, a matrix chip would be either a row or a column of the input matrix:
+
+```cpp
+Eigen::Tensor<int, 2> a(4, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500},
+             {600, 700, 800}, {900, 1000, 1100}});
+Eigen::Tensor<int, 1> row_3 = a.chip(2, 0);
+Eigen::Tensor<int, 1> col_2 = a.chip(1, 1);
+std::cout << "a\n" << a << "\n";
+
+// a
+//    0   100   200
+//  300   400   500
+//  600   700   800
+//  900  1000  1100
+
+std::cout << "row_3\n" << row_3 << "\n";
+// row_3
+//    600   700   800
+
+std::cout << "col_2\n" << col_2 << "\n";
+// col_2
+//   100   400   700    1000
+```
+
+It is possible to assign values to a tensor chip since the chip operation is a
+lvalue. For example:
+
+```cpp
+Eigen::Tensor<int, 1> a(3);
+a.setValues({{100, 200, 300}});
+Eigen::Tensor<int, 2> b(2, 3);
+b.setZero();
+b.chip(0, 0) = a;
+std::cout << "a\n" << a << "\n";
+std::cout << "b\n" << b << "\n";
+
+// a
+// 100
+// 200
+// 300
+
+// b
+//   100   200   300
+//     0     0     0
+```
+
+
+The dimension can also be passed as a template parameter:
+
+```cpp
+b.chip<0>(1) = a;  // Equivalent to b.chip(1,0) = a;
+```
+
+Note that only one dimension can be chipped at a time.
+To chip off multiple dimensions, you can chain calls
+
+```cpp
+Eigen::Tensor<int, 3> a(2, 3, 4);
+Eigen::Tensor<int, 1> b = b.chip<2>(0) // Now has shape [2,3]
+                           .chip<1>(0); // Now has shape [2]
+```
+
+Be careful in which order you chip, as each operation affects the shape of the intermediate result.
+For example:
+
+```cpp
+// AVOID THIS
+Eigen::Tensor<int, 1> c = b.chip<1>(0) // Now has shape [2,4]
+                           .chip<1>(0); // Now has shape [2]
+```
+
+In general, it's more intuitive to chip from the outermost dimension first.
+
+
+### (Operation) reverse(const ReverseDimensions& reverse)
+
+Returns a view of the input tensor that reverses the order of the coefficients
+along a subset of the dimensions.  The argument reverse is an array of boolean
+values that indicates whether or not the order of the coefficients should be
+reversed along each of the dimensions.  This operation preserves the dimensions
+of the input tensor.
+
+For example this is what happens when you `reverse()` the first dimension
+of a 2D tensor:
+
+```cpp
+Eigen::Tensor<int, 2> a(4, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500},
+            {600, 700, 800}, {900, 1000, 1100}});
+Eigen::array<bool, 2> reverse{true, false};
+Eigen::Tensor<int, 2> b = a.reverse(reverse);
+std::cout << "a\n" << a << "\n";
+std::cout << "b\n" << b << "\n";
+
+// a
+//    0   100   200
+//  300   400   500
+//  600   700   800
+//  900  1000  1100
+// b
+//  900  1000  1100
+//  600   700   800
+//  300   400   500
+//    0   100   200
+```
+
+### (Operation) roll(const Rolls& shifts)
+
+Returns a tensor with the elements **circularly shifted** (like bit rotation) along one or more dimensions.
+
+For each dimension `i`, the content is shifted by `shifts[i]` positions:
+
+- A **positive shift** of `+s` moves each value to a **lower index** by `s`.
+- A **negative shift** of `-s` moves each value to a **higher index** by `s`.
+
+```cpp
+Eigen::Tensor<int, 2> a(3, 4);
+a.setValues({{ 1,  2,  3,  4},
+             { 5,  6,  7,  8},
+             { 9, 10, 11, 12}});
+
+Eigen::array<Eigen::Index, 2> shifts = {1, -2};
+
+Eigen::Tensor<int, 2> rolled = a.roll(shifts);
+
+std::cout << "a\n" << a << "\n";
+std::cout << "rolled\n" << rolled << "\n";
+
+// a
+// 1  2  3  4
+// 5  6  7  8
+// 9 10 11 12
+//
+// rolled
+// 7  8  5  6
+// 11 12  9 10
+// 3  4  1  2
+```
+
+### (Operation) broadcast(const Broadcast& broadcast)
+
+Returns a view of the input tensor in which the input is replicated one to many
+times.
+The broadcast argument specifies how many copies of the input tensor need to be
+made in each of the dimensions.
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500}});
+Eigen::array<int, 2> bcast{3, 2};
+Eigen::Tensor<int, 2> b = a.broadcast(bcast);
+std::cout << "a" << endl << a << endl << "b" << endl << b << endl;
+// a
+//    0   100   200
+//  300   400   500
+// b
+//    0   100   200    0   100   200
+//  300   400   500  300   400   500
+//    0   100   200    0   100   200
+//  300   400   500  300   400   500
+//    0   100   200    0   100   200
+//  300   400   500  300   400   500
+```
+
+Note: Broadcasting does not increase rank.
+To broadcast into higher dimensions, you must first reshape the tensor with singleton (1) dimensions:
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500}});
+
+Eigen::array<Eigen::Index, 3> new_shape = {1, 2, 3}; //Reshape to [1, 2, 3]
+Eigen::array<int, 3> bcast = {4, 1, 1}; // Broadcast to [4, 2, 3]
+Eigen::Tensor<int, 3> b = a.reshape(new_shape).broadcast(bcast);
+
+std::cout << "b dimensions: " << b.dimensions() << "\n";
+std::cout << b << "\n";
+```
+
+### (Operation) concatenate(const OtherDerived& other, Axis axis)
+
+Returns a view of two tensors joined along a specified axis.
+Both operands must have the same static rank (i.e. the same `NumDimensions`
+template parameter). Eigen Tensor expressions are fully typed at compile time
+on a fixed rank, so a rank-`N` tensor cannot be concatenated directly with a
+rank-`M` tensor; reshape one of the operands explicitly if you want to mix
+ranks.
+The dimensions of the two tensors must match on all axes except the
+concatenation axis.
+The resulting tensor has the same rank as the inputs.
+
+For example, to join a rank-2 tensor of shape `(2, 3)` and a rank-3 tensor of
+shape `(2, 3, 1)` along axis 0, reshape the rank-2 operand to rank 3 first:
+
+```cpp
+Eigen::Tensor<int, 2> left(2, 3);
+Eigen::Tensor<int, 3> right(2, 3, 1);
+Eigen::Tensor<int, 3> result =
+    left.reshape(Eigen::Tensor<int, 3>::Dimensions(2, 3, 1)).concatenate(right, 0);
+```
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500}});
+
+Eigen::Tensor<int, 2> b(2, 3);
+b.setValues({{-1, -2, -3}, {-4, -5, -6}});
+
+// Concatenate along dimension 0: resulting shape is [4, 3]
+Eigen::Tensor<int, 2> c = a.concatenate(b, 0);
+
+// Concatenate along dimension 1: resulting shape is [2, 6]
+Eigen::Tensor<int, 2> d = a.concatenate(b, 1);
+
+std::cout << "a\n" << a << "\n"
+          << "b\n" << b << "\n"
+          << "c (concatenated along dim 0)\n" << c << "\n"
+          << "d (concatenated along dim 1)\n" << d << "\n";
+// a
+//   0 100 200
+// 300 400 500
+// b
+// -1 -2 -3
+// -4 -5 -6
+// c (concatenated along dim 0)
+//   0 100 200
+// 300 400 500
+//  -1  -2  -3
+//  -4  -5  -6
+// d (concatenated along dim 1)
+//   0 100 200  -1  -2  -3
+// 300 400 500  -4  -5  -6
+```
+
+### (Operation)  pad(const PaddingDimensions& padding)
+
+Returns a view of the input tensor in which the input is padded with zeros.
+
+An optional second argument specifies the padding value (default is zero):
+`a.pad(paddings, 42)` pads with the value 42.
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 100, 200}, {300, 400, 500}});
+Eigen::array<pair<int, int>, 2> paddings;
+paddings[0] = make_pair(0, 1);
+paddings[1] = make_pair(2, 3);
+Eigen::Tensor<int, 2> b = a.pad(paddings);
+std::cout << "a" << endl << a << endl << "b" << endl << b << endl;
+// a
+//    0   100   200
+//  300   400   500
+// b
+//    0     0     0    0
+//    0     0     0    0
+//    0   100   200    0
+//  300   400   500    0
+//    0     0     0    0
+//    0     0     0    0
+//    0     0     0    0
+```
+
+### (Operation) inflate(const Strides& strides)
+
+Returns a tensor with zeros inserted between the elements of the input tensor
+along each dimension. The `strides` array specifies the inflation factor for
+each dimension: a stride of `s` inserts `s-1` zeros between consecutive
+elements in that dimension. A stride of 1 leaves the dimension unchanged.
+
+The output dimension sizes are `(input_dim - 1) * stride + 1`.
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+a.setValues({{1, 2, 3}, {4, 5, 6}});
+Eigen::array<Eigen::Index, 2> strides{{2, 3}};
+Eigen::Tensor<float, 2> b = a.inflate(strides);
+std::cout << "b dimensions: " << b.dimension(0) << " x " << b.dimension(1) << "\n";
+std::cout << "b\n" << b << "\n";
+
+// b dimensions: 3 x 7
+// b
+// 1 0 0 2 0 0 3
+// 0 0 0 0 0 0 0
+// 4 0 0 5 0 0 6
+```
+
+This is the adjoint of the `stride()` operation and is useful for implementing
+transposed convolutions (deconvolutions).
+
+### (Operation)  extract_patches(const PatchDims& patch_dims)
+
+Returns a tensor of coefficient patches extracted from the input tensor, where
+each patch is of dimension specified by `patch_dims`. The returned tensor has
+one greater dimension than the input tensor, which is used to index each patch.
+The patch index in the output tensor depends on the data layout of the input
+tensor: the patch index is the last dimension `ColMajor` layout, and the first
+dimension in `RowMajor` layout.
+
+For example, given the following input tensor:
+
+```cpp
+Eigen::Tensor<float, 2, DataLayout> tensor(3,4);
+tensor.setValues({{0.0f, 1.0f, 2.0f, 3.0f},
+                  {4.0f, 5.0f, 6.0f, 7.0f},
+                  {8.0f, 9.0f, 10.0f, 11.0f}});
+
+std::cout << "tensor: " << endl << tensor << endl;
+
+// tensor:
+//  0   1   2   3
+//  4   5   6   7
+//  8   9  10  11
+```
+
+Six 2x2 patches can be extracted and indexed using the following code:
+
+```cpp
+Eigen::Tensor<float, 3, DataLayout> patch;
+Eigen::array<ptrdiff_t, 2> patch_dims;
+patch_dims[0] = 2;
+patch_dims[1] = 2;
+patch = tensor.extract_patches(patch_dims);
+for (int k = 0; k < 6; ++k) {
+  std::cout << "patch index: " << k << endl;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      if (DataLayout == ColMajor) {
+        std::cout << patch(i, j, k) << " ";
+      } else {
+        std::cout << patch(k, i, j) << " ";
+      }
+    }
+    std::cout << endl;
+  }
+}
+```
+
+This code results in the following output when the data layout is `ColMajor`:
+
+    patch index: 0
+    0 1
+    4 5
+    patch index: 1
+    4 5
+    8 9
+    patch index: 2
+    1 2
+    5 6
+    patch index: 3
+    5 6
+    9 10
+    patch index: 4
+    2 3
+    6 7
+    patch index: 5
+    6 7
+    10 11
+
+This code results in the following output when the data layout is RowMajor:
+
+**NOTE**: the set of patches is the same as in `ColMajor`, but are indexed differently
+
+    patch index: 0
+    0 1
+    4 5
+    patch index: 1
+    1 2
+    5 6
+    patch index: 2
+    2 3
+    6 7
+    patch index: 3
+    4 5
+    8 9
+    patch index: 4
+    5 6
+    9 10
+    patch index: 5
+    6 7
+    10 11
+
+### (Operation)  extract_image_patches(const Index patch_rows, const Index patch_cols, const Index row_stride, const Index col_stride, ...)
+
+Returns a tensor of coefficient image patches extracted from the input tensor,
+which is expected to have dimensions ordered as follows (depending on the data
+layout of the input tensor, and the number of additional dimensions 'N'):
+
+- `ColMajor`
+    - 1st dimension: channels (of size d)
+    - 2nd dimension: rows (of size r)
+    - 3rd dimension: columns (of size c)
+    - 4th-Nth dimension: time (for video) or batch (for bulk processing).
+
+* `RowMajor` (reverse order of `ColMajor`)
+    - 1st-Nth dimension: time (for video) or batch (for bulk processing).
+    - N+1'th dimension: columns (of size c)
+    - N+2'th dimension: rows (of size r)
+    - N+3'th dimension: channels (of size d)
+
+The returned tensor has one greater dimension than the input tensor, which is
+used to index each patch. The patch index in the output tensor depends on the
+data layout of the input tensor: the patch index is the 4'th dimension in
+`ColMajor` layout, and the 4'th from the last dimension in `RowMajor` layout.
+
+All the arguments are optional and default to 1, except for the two trailing
+ones. `in_row_stride` and `in_col_stride` dilate the patch, so that it samples
+every `in_row_stride`'th input row and every `in_col_stride`'th input column.
+`padding_type` selects `PADDING_SAME` (the default) or `PADDING_VALID`, and
+`padding_value` (`Scalar(0)` by default) is used for the coefficients of a
+patch that fall outside the input.
+
+For example, given the following input tensor with the following dimension
+sizes:
+- depth:   2
+- rows:    3
+- columns: 5
+- batch:   7
+
+```cpp
+Tensor<float, 4> tensor(2,3,5,7);
+Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
+```
+
+2x2 image patches can be extracted and indexed using the following code:
+
+#### 2D patch: `ColMajor` (patch indexed by second-to-last dimension)
+
+```cpp
+Tensor<float, 5> twod_patch;
+twod_patch = tensor.extract_image_patches(2, 2);
+// twod_patch.dimension(0) == 2
+// twod_patch.dimension(1) == 2
+// twod_patch.dimension(2) == 2
+// twod_patch.dimension(3) == 3*5
+// twod_patch.dimension(4) == 7
+```
+
+#### 2D patch: `RowMajor` (patch indexed by the second dimension)
+
+```cpp
+Tensor<float, 5, RowMajor> twod_patch_row_major;
+twod_patch_row_major = tensor_row_major.extract_image_patches(2, 2);
+// twod_patch_row_major.dimension(0) == 7
+// twod_patch_row_major.dimension(1) == 3*5
+// twod_patch_row_major.dimension(2) == 2
+// twod_patch_row_major.dimension(3) == 2
+// twod_patch_row_major.dimension(4) == 2
+```
+
+## Generation and Custom Operations
+
+### (Operation) generate(const Generator& generator)
+
+Returns a tensor whose values are computed by the given generator functor based
+on element coordinates. The generator must define `operator()` taking an
+`array<Index, NumDims>` of coordinates and returning a `Scalar`.
+
+```cpp
+// Generator that produces the linear index of each element.
+template <typename Index, int NumDims>
+struct LinearIndexGenerator {
+  Eigen::array<Index, NumDims> dims_;
+  LinearIndexGenerator(const Eigen::array<Index, NumDims>& dims) : dims_(dims) {}
+
+  float operator()(const Eigen::array<Index, NumDims>& coords) const {
+    float idx = 0;
+    float stride = 1;
+    for (int i = 0; i < NumDims; ++i) {
+      idx += coords[i] * stride;
+      stride *= dims_[i];
+    }
+    return idx;
+  }
+};
+
+Eigen::Tensor<float, 2> t(3, 4);
+Eigen::array<Eigen::Index, 2> dims{{3, 4}};
+Eigen::Tensor<float, 2> result = t.generate(LinearIndexGenerator<Eigen::Index, 2>(dims));
+```
+
+### (Operation) customOp(const CustomUnaryFunc& func)
+
+Applies a custom operation that can produce output with different dimensions
+than the input. Unlike `unaryExpr()` which is element-wise, `customOp()`
+gives full control over how the output is computed.
+
+The functor must implement:
+- `dimensions(const InputType& input)` — returns the output dimensions. Its
+  return type (e.g. `DSizes<Index, Rank>`) determines the rank of the result;
+  its index type must be the expression's index type, or one that promotes to
+  it. Only the shape is functor-controlled: the scalar type and layout of the
+  result are inherited from the input expression(s).
+- `eval(const InputType& input, OutputType& output, const Device& device)` —
+  computes the result.
+
+```cpp
+struct RowSumOp {
+  // Output is a 1D tensor with size equal to the number of rows.
+  template <typename Input>
+  Eigen::DSizes<Eigen::Index, 1> dimensions(const Input& input) const {
+    return Eigen::DSizes<Eigen::Index, 1>(input.dimension(0));
+  }
+
+  template <typename Input, typename Output, typename Device>
+  void eval(const Input& input, Output& output, const Device& device) const {
+    Eigen::array<Eigen::Index, 1> reduce_dims{{1}};
+    output.device(device) = input.sum(reduce_dims);
+  }
+};
+
+Eigen::Tensor<float, 2> a(3, 4);
+a.setRandom();
+Eigen::Tensor<float, 1> row_sums = a.customOp(RowSumOp());
+```
+
+`InputType` is whatever expression `customOp()` was applied to (both operands,
+in the binary form) and need not be a plain tensor or map. A lazy expression
+does not expose `dimension()`/`dimensions()`, so compute the sizes with a
+`TensorEvaluator`, whose constructor determines the dimensions without
+evaluating the expression:
+
+```cpp
+template <typename Input>
+Eigen::DSizes<Eigen::Index, 1> dimensions(const Input& input) const {
+  Eigen::DefaultDevice device;
+  Eigen::TensorEvaluator<const Input, Eigen::DefaultDevice> eval(input, device);
+  return Eigen::DSizes<Eigen::Index, 1>(eval.dimensions()[0]);
+}
+```
+
+Do not materialize the input (e.g. through a `TensorRef` or by converting it
+to a `Tensor`) just to read its size: that evaluates the whole expression on
+the host, and with a non-default device it would touch device memory from the
+host.
+
+A binary variant is also available:
+```cpp
+Eigen::Tensor<float, 2> result = a.customOp(b, MyBinaryCustomOp());
+```
+
+### (Operation) nullaryExpr(const CustomNullaryOp& func)
+
+Creates a tensor from a custom nullary functor. The functor is called for
+each element position.
+
+
+## Special Operations
+
+### (Operation) cast\<T\>()
+
+Returns a tensor of type `T` with the same dimensions as the original tensor.
+The returned tensor contains the values of the original tensor converted to
+type `T`.
+
+```cpp
+Eigen::Tensor<float, 2> a(2, 3);
+Eigen::Tensor<int, 2> b = a.cast<int>();
+```
+
+This can be useful for example if you need to do element-wise division of
+Tensors of integers.
+This is not currently supported by the Tensor library
+but you can easily cast the tensors to floats to do the division:
+
+```cpp
+Eigen::Tensor<int, 2> a(2, 3);
+a.setValues({{0, 1, 2}, {3, 4, 5}});
+Eigen::Tensor<int, 2> b =
+    (a.cast<float>() / a.constant(2).cast<float>()).cast<int>();
+std::cout << "a\n" << a << "\n";
+std::cout << "b\n" << b << "\n";
+
+// a
+// 0 1 2
+// 3 4 5
+//
+// b
+// 0 0 1
+// 1 2 2
+```
+
+### (Operation)     eval()
+See **Calling eval()**.
+
+
+
+## Tensor Printing
+Tensors can be printed into a stream object (e.g. `std::cout`) using different formatting options.
+
+```cpp
+Eigen::Tensor<float, 3> tensor3d(4, 3, 2);
+tensor3d.setValues( {{{1, 2},
+                      {3, 4},
+                      {5, 6}},
+                     {{7, 8},
+                      {9, 10},
+                      {11, 12}},
+                     {{13, 14},
+                      {15, 16},
+                      {17, 18}},
+                     {{19, 20},
+                      {21, 22},
+                      {23, 24}}} );
+std::cout << tensor3d.format(Eigen::TensorIOFormat::Plain()) << "\n";
+//  1  2
+//  3  4
+//  5  6
+//
+//  7  8
+//  9 10
+// 11 12
+//
+// 13 14
+// 15 16
+// 17 18
+//
+// 19 20
+// 21 22
+// 23 24
+```
+
+In the example, we used the predefined format `Eigen::TensorIOFormat::Plain`.
+Here is the list of all predefined formats from which you can choose:
+- `Eigen::TensorIOFormat::Plain()` for a plain output without braces. Different submatrices are separated by a blank line.
+- `Eigen::TensorIOFormat::Numpy()` for numpy-like output.
+- `Eigen::TensorIOFormat::Native()` for a `c++` like output which can be directly copy-pasted to `setValues()`.
+- `Eigen::TensorIOFormat::Legacy()` for a backwards compatible printing of tensors.
+
+If you send the tensor directly to the stream the default format is called which is `Eigen::TensorIOFormat::Plain()`.
+
+You can define your own format by explicitly providing a `Eigen::TensorIOFormat` class instance. Here, you can specify:
+- The overall prefix and suffix with `std::string tenPrefix` and `std::string tenSuffix`
+- The prefix, separator and suffix for each new element, row, matrix, 3d subtensor, ... with `std::vector<std::string> prefix`, `std::vector<std::string> separator` and `std::vector<std::string> suffix`. Note that the first entry in each of the vectors refer to the last dimension of the tensor, e.g. `separator[0]` will be printed between adjacent elements,  `separator[1]` will be printed between adjacent matrices, ...
+- `char fill`: character which will be placed if the elements are aligned.
+- `int precision`
+- `int flags`: an OR-ed combination of flags, the default value is 0, the only currently available flag is `Eigen::DontAlignCols` which allows to disable the alignment of columns, resulting in faster code.
+
+## Interop with Eigen Matrix and Vector Types
+
+Tensor data can be wrapped as an Eigen `Map<Matrix>`, and vice versa, Eigen
+dense matrix/vector data can be wrapped as a `TensorMap`. This is a zero-copy
+operation that simply reinterprets the underlying memory.
+
+### Wrapping a Tensor as a Matrix
+
+```cpp
+Eigen::Tensor<float, 2> tensor(3, 4);
+tensor.setRandom();
+
+// View the tensor's data as an Eigen Matrix (no copy).
+Eigen::Map<Eigen::MatrixXf> matrix(tensor.data(), 3, 4);
+std::cout << "Matrix view:\n" << matrix << "\n";
+
+// Modifications through the map are reflected in the tensor.
+matrix(0, 0) = 42.0f;
+assert(tensor(0, 0) == 42.0f);
+```
+
+### Wrapping a Matrix as a Tensor
+
+```cpp
+Eigen::MatrixXf matrix(3, 4);
+matrix.setRandom();
+
+// View the matrix's data as a rank-2 Tensor (no copy).
+Eigen::TensorMap<Eigen::Tensor<float, 2>> tensor(matrix.data(), 3, 4);
+std::cout << "Tensor view:\n" << tensor << "\n";
+
+// You can also reshape to a different rank.
+Eigen::TensorMap<Eigen::Tensor<float, 1>> flat(matrix.data(), 12);
+```
+
+**Important**: Both the Map and TensorMap are non-owning views. The underlying
+data must remain valid for the lifetime of the view. Also note that the default
+storage order of Eigen matrices is `ColMajor`, which matches the default Tensor
+layout.
+
+## Representation of scalar values
+
+Scalar values are often represented by tensors of size 1 and rank 0.
+
+For example, the no-argument `Tensor<T, N>::maximum()` returns a rank-0
+`TensorReductionOp`.  Such reduction expressions can be assigned directly to
+their exact scalar result type, as explained in **Reduction along all
+dimensions**.
+
+Other rank-0 expressions, such as `argmax()` or the inner product of two rank-1
+tensors computed through contraction, must still be evaluated into a rank-0
+`Tensor` before accessing their scalar coefficient with `operator()`.
+
+
+## Limitations
+
+*   The number of tensor dimensions is currently limited to 250.
+*   On GPUs only floating point values are properly tested and optimized for.
+*   C++14 or later is required to use the Tensor module.
diff --git a/contrib/Eigen/src/Tensor/Tensor.h b/contrib/Eigen/src/Tensor/Tensor.h
new file mode 100644
index 0000000..95014f8
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/Tensor.h
@@ -0,0 +1,381 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_H
+#define EIGEN_TENSOR_TENSOR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \class Tensor
+ * \ingroup Tensor_Module
+ *
+ * \brief The tensor class.
+ *
+ * The %Tensor class is the work-horse for all \em dense tensors within Eigen.
+ *
+ * The %Tensor class encompasses only dynamic-size objects so far.
+ *
+ * The first two template parameters are required:
+ * \tparam Scalar_  Numeric type, e.g. float, double, int or `std::complex<float>`.
+ *                 User defined scalar types are supported as well (see \ref user_defined_scalars "here").
+ * \tparam NumIndices_ Number of indices (i.e. rank of the tensor)
+ *
+ * The remaining template parameters are optional -- in most cases you don't have to worry about them.
+ * \tparam Options_  A combination of either \b #RowMajor or \b #ColMajor, and of either
+ *                 \b #AutoAlign or \b #DontAlign.
+ *                 The former controls \ref TopicStorageOrders "storage order", and defaults to column-major. The latter
+ * controls alignment, which is required for vectorization. It defaults to aligning tensors. Tensor expressions such as
+ * the sum of two tensors are evaluated with packet instructions whenever the evaluators involved support packet
+ * access.
+ *
+ * You can access elements of tensors using normal subscripting:
+ *
+ * \code
+ * Eigen::Tensor<double, 4> t(10, 10, 10, 10);
+ * t(0, 1, 2, 3) = 42.0;
+ * \endcode
+ *
+ * This class can be extended with the help of the plugin mechanism described on the page
+ * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_TENSOR_PLUGIN,
+ * \c EIGEN_TENSORBASE_PLUGIN, and \c EIGEN_READONLY_TENSORBASE_PLUGIN.
+ *
+ * <i><b>Some notes:</b></i>
+ *
+ * <dl>
+ * <dt><b>Relation to other parts of Eigen:</b></dt>
+ * <dd>The midterm development goal for this class is to have a similar hierarchy as Eigen uses for matrices, so that
+ * taking blocks or using tensors in expressions is easily possible, including an interface with the vector/matrix code
+ * by providing .asMatrix() and .asVector() (or similar) methods for rank 2 and 1 tensors. Taking blocks and using
+ * tensors in expressions is already supported through \c TensorBase; interoperability with the vector/matrix code
+ * currently relies on wrapping the data in a \c Map or a \c TensorMap instead of dedicated methods. Fixed-size tensors
+ * are provided by the separate \c TensorFixedSize class.</dd>
+ * </dl>
+ *
+ * \ref TopicStorageOrders
+ */
+
+template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
+class Tensor : public TensorBase<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {
+ public:
+  typedef Tensor<Scalar_, NumIndices_, Options_, IndexType_> Self;
+  typedef TensorBase<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > Base;
+  typedef typename Eigen::internal::ref_selector<Self>::type Nested;
+  typedef typename internal::traits<Self>::StorageKind StorageKind;
+  typedef typename internal::traits<Self>::Index Index;
+  typedef Scalar_ Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename Base::CoeffReturnType CoeffReturnType;
+
+  enum { IsAligned = (EIGEN_MAX_ALIGN_BYTES > 0) && !(Options_ & DontAlign), CoordAccess = true, RawAccess = true };
+
+  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
+  static constexpr int Options = Options_;
+  static constexpr int NumIndices = NumIndices_;
+  typedef DSizes<Index, NumIndices_> Dimensions;
+
+ protected:
+  TensorStorage<Scalar, Dimensions, Options> m_storage;
+
+  template <typename CustomIndices>
+  struct isOfNormalIndex {
+    static constexpr bool is_array = std::is_base_of<array<Index, NumIndices>, CustomIndices>::value;
+    static constexpr bool is_int = NumTraits<CustomIndices>::IsInteger;
+    static constexpr bool value = is_array | is_int;
+  };
+
+ public:
+  // Metadata
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return NumIndices; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(std::size_t n) const { return m_storage.dimensions()[n]; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_storage.dimensions(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_storage.size(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar* data() { return m_storage.data(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_storage.data(); }
+
+  // This makes EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+  // work, because that uses base().coeffRef() - and we don't yet
+  // implement a similar class hierarchy
+  inline Self& base() { return *this; }
+  inline const Self& base() const { return *this; }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index firstIndex, Index secondIndex,
+                                                            IndexTypes... otherIndices) const {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return coeff(array<Index, NumIndices>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  // normal indices
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(const array<Index, NumIndices>& indices) const {
+    eigen_internal_assert(checkIndexRange(indices));
+    return m_storage.data()[linearizedIndex(indices)];
+  }
+
+  // custom indices
+  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(CustomIndices& indices) const {
+    return coeff(internal::customIndices2Array<Index, NumIndices>(indices));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff() const {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return m_storage.data()[0];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const {
+    eigen_internal_assert(index >= 0 && index < size());
+    return m_storage.data()[index];
+  }
+
+  template <typename... IndexTypes>
+  inline Scalar& coeffRef(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return coeffRef(array<Index, NumIndices>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  // normal indices
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) {
+    eigen_internal_assert(checkIndexRange(indices));
+    return m_storage.data()[linearizedIndex(indices)];
+  }
+
+  // custom indices
+  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(CustomIndices& indices) {
+    return coeffRef(internal::customIndices2Array<Index, NumIndices>(indices));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef() {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return m_storage.data()[0];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
+    eigen_internal_assert(index >= 0 && index < size());
+    return m_storage.data()[index];
+  }
+
+  template <typename... IndexTypes>
+  inline const Scalar& operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) const {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return this->operator()(array<Index, NumIndices>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  // custom indices
+  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(CustomIndices& indices) const {
+    return coeff(internal::customIndices2Array<Index, NumIndices>(indices));
+  }
+
+  // normal indices
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(const array<Index, NumIndices>& indices) const {
+    return coeff(indices);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index index) const {
+    eigen_internal_assert(index >= 0 && index < size());
+    return coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()() const {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return coeff();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator[](Index index) const {
+    // The bracket operator is only for vectors, use the parenthesis operator instead.
+    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return coeff(index);
+  }
+
+  template <typename... IndexTypes>
+  inline Scalar& operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return operator()(array<Index, NumIndices>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  // normal indices
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(const array<Index, NumIndices>& indices) {
+    return coeffRef(indices);
+  }
+
+  // custom indices
+  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(CustomIndices& indices) {
+    return coeffRef(internal::customIndices2Array<Index, NumIndices>(indices));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index index) {
+    eigen_assert(index >= 0 && index < size());
+    return coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()() {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return coeffRef();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator[](Index index) {
+    // The bracket operator is only for vectors, use the parenthesis operator instead.
+    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    return coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor() : m_storage() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(const Self& other) = default;
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index firstDimension, IndexTypes... otherDimensions)
+      : m_storage(firstDimension, otherDimensions...) {
+    // The number of dimensions used to construct a tensor must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  }
+
+  /** Normal Dimension */
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit Tensor(const array<Index, NumIndices>& dimensions)
+      : m_storage(internal::array_prod(dimensions), dimensions) {
+    EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+  }
+
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
+    EIGEN_STATIC_ASSERT(OtherDerived::NumDimensions == Base::NumDimensions, Number_of_dimensions_must_match)
+    typedef TensorAssignOp<Tensor, const OtherDerived> Assign;
+    Assign assign(*this, other.derived());
+    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
+    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+  }
+
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(const TensorBase<OtherDerived, WriteAccessors>& other) {
+    EIGEN_STATIC_ASSERT(OtherDerived::NumDimensions == Base::NumDimensions, Number_of_dimensions_must_match)
+    typedef TensorAssignOp<Tensor, const OtherDerived> Assign;
+    Assign assign(*this, other.derived());
+    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
+    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Self&& other) : m_storage(std::move(other.m_storage)) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor& operator=(Self&& other) {
+    m_storage = std::move(other.m_storage);
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor& operator=(const Tensor& other) {
+    typedef TensorAssignOp<Tensor, const Tensor> Assign;
+    Assign assign(*this, other);
+    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
+    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+    return *this;
+  }
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor& operator=(const OtherDerived& other) {
+    typedef TensorAssignOp<Tensor, const OtherDerived> Assign;
+    Assign assign(*this, other);
+    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
+    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+    return *this;
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC void resize(Index firstDimension, IndexTypes... otherDimensions) {
+    // The number of dimensions used to resize a tensor must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherDimensions...));
+    resize(array<Index, NumIndices>{{firstDimension, static_cast<Index>(otherDimensions)...}});
+  }
+
+  /** Normal Dimension */
+  EIGEN_DEVICE_FUNC void resize(const array<Index, NumIndices>& dimensions) {
+#ifndef EIGEN_NO_DEBUG
+    Index size = Index(1);
+    for (int i = 0; i < NumIndices; i++) {
+      internal::check_rows_cols_for_overflow<Dynamic, Dynamic, Dynamic>::run(size, dimensions[i]);
+      size *= dimensions[i];
+    }
+#else
+    Index size = internal::array_prod(dimensions);
+#endif
+
+#ifdef EIGEN_INITIALIZE_COEFFS
+    bool size_changed = size != this->size();
+    m_storage.resize(size, dimensions);
+    if (size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+#else
+    m_storage.resize(size, dimensions);
+#endif
+  }
+
+  EIGEN_DEVICE_FUNC void resize() {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    // Nothing to do: rank 0 tensors have fixed size
+  }
+
+  template <typename FirstType, typename... OtherTypes>
+  EIGEN_DEVICE_FUNC void resize(const Eigen::IndexList<FirstType, OtherTypes...>& dimensions) {
+    array<Index, NumIndices> dims;
+    for (int i = 0; i < NumIndices; ++i) {
+      dims[i] = static_cast<Index>(dimensions[i]);
+    }
+    resize(dims);
+  }
+
+  /** Custom Dimension */
+  template <typename CustomDimension, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomDimension>::value))>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(CustomDimension& dimensions) {
+    resize(internal::customIndices2Array<Index, NumIndices>(dimensions));
+  }
+
+  template <std::ptrdiff_t... Indices>
+  EIGEN_DEVICE_FUNC void resize(const Sizes<Indices...>& dimensions) {
+    array<Index, NumIndices> dims;
+    for (int i = 0; i < NumIndices; ++i) {
+      dims[i] = static_cast<Index>(dimensions[i]);
+    }
+    resize(dims);
+  }
+
+#ifdef EIGEN_TENSOR_PLUGIN
+#include EIGEN_TENSOR_PLUGIN
+#endif
+
+ protected:
+  bool checkIndexRange(const array<Index, NumIndices>& indices) const {
+    for (std::size_t i = 0; i < NumIndices; ++i) {
+      if (indices[i] < 0 || indices[i] >= m_storage.dimensions()[i]) return false;
+    }
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index linearizedIndex(const array<Index, NumIndices>& indices) const {
+    EIGEN_IF_CONSTEXPR (Options & RowMajor) {
+      return m_storage.dimensions().IndexOfRowMajor(indices);
+    } else {
+      return m_storage.dimensions().IndexOfColMajor(indices);
+    }
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_H
diff --git a/contrib/Eigen/src/Tensor/TensorArgMax.h b/contrib/Eigen/src/Tensor/TensorArgMax.h
new file mode 100644
index 0000000..2f28c49
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorArgMax.h
@@ -0,0 +1,267 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Eugene Brevdo <ebrevdo@gmail.com>
+//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_ARG_MAX_H
+#define EIGEN_TENSOR_TENSOR_ARG_MAX_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+template <typename XprType>
+struct traits<TensorIndexPairOp<XprType>> : public traits<XprType> {
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  typedef Pair<Index, typename XprTraits::Scalar> Scalar;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+};
+
+template <typename XprType>
+struct eval<TensorIndexPairOp<XprType>, Eigen::Dense> {
+  typedef const TensorIndexPairOp<XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor + Index Pair class.
+ */
+template <typename XprType>
+class TensorIndexPairOp : public TensorBase<TensorIndexPairOp<XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorIndexPairOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename Eigen::internal::ref_selector<TensorIndexPairOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorIndexPairOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorIndexPairOp>::Index Index;
+  typedef Pair<Index, typename XprType::CoeffReturnType> CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIndexPairOp(const XprType& expr) : m_xpr(expr) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+};
+
+// Eval as rvalue
+template <typename ArgType, typename Device>
+struct TensorEvaluator<const TensorIndexPairOp<ArgType>, Device> {
+  typedef TensorIndexPairOp<ArgType> XprType;
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  enum {
+    IsAligned = false,
+    PacketAccess = false,
+    BlockAccess = false,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    return CoeffReturnType(index, m_impl.coeff(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, 1);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ protected:
+  TensorEvaluator<ArgType, Device> m_impl;
+};
+
+namespace internal {
+
+/** \class TensorPairReducerOp
+ * \ingroup Tensor_Module
+ *
+ * \brief Converts to Tensor<Pair<Index, Scalar> > and reduces to Tensor<Index>.
+ *
+ */
+template <typename ReduceOp, typename Dims, typename XprType>
+struct traits<TensorPairReducerOp<ReduceOp, Dims, XprType>> : public traits<XprType> {
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  typedef Index Scalar;
+  static constexpr int NumDimensions = XprTraits::NumDimensions - array_size<Dims>::value;
+  static constexpr int Layout = XprTraits::Layout;
+};
+
+template <typename ReduceOp, typename Dims, typename XprType>
+struct eval<TensorPairReducerOp<ReduceOp, Dims, XprType>, Eigen::Dense> {
+  typedef const TensorPairReducerOp<ReduceOp, Dims, XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+template <typename ReduceOp, typename Dims, typename XprType>
+class TensorPairReducerOp : public TensorBase<TensorPairReducerOp<ReduceOp, Dims, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorPairReducerOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename Eigen::internal::ref_selector<TensorPairReducerOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorPairReducerOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorPairReducerOp>::Index Index;
+  typedef Index CoeffReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorPairReducerOp(const XprType& expr, const ReduceOp& reduce_op,
+                                                            const Index return_dim, const Dims& reduce_dims)
+      : m_xpr(expr), m_reduce_op(reduce_op), m_return_dim(return_dim), m_reduce_dims(reduce_dims) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_DEVICE_FUNC const ReduceOp& reduce_op() const { return m_reduce_op; }
+
+  EIGEN_DEVICE_FUNC const Dims& reduce_dims() const { return m_reduce_dims; }
+
+  EIGEN_DEVICE_FUNC Index return_dim() const { return m_return_dim; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const ReduceOp m_reduce_op;
+  const Index m_return_dim;
+  const Dims m_reduce_dims;
+};
+
+// Eval as rvalue
+template <typename ReduceOp, typename Dims, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorPairReducerOp<ReduceOp, Dims, ArgType>, Device> {
+  typedef TensorPairReducerOp<ReduceOp, Dims, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename TensorIndexPairOp<ArgType>::CoeffReturnType PairType;
+  typedef typename TensorEvaluator<const TensorReductionOp<ReduceOp, Dims, const TensorIndexPairOp<ArgType>>,
+                                   Device>::Dimensions Dimensions;
+  typedef typename TensorEvaluator<const TensorIndexPairOp<ArgType>, Device>::Dimensions InputDimensions;
+  static constexpr int NumDims = internal::array_size<InputDimensions>::value;
+  typedef array<Index, NumDims> StrideDims;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  enum {
+    IsAligned = false,
+    PacketAccess = false,
+    BlockAccess = false,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+  static constexpr int Layout =
+      TensorEvaluator<const TensorReductionOp<ReduceOp, Dims, const TensorIndexPairOp<ArgType>>, Device>::Layout;
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_orig_impl(op.expression(), device),
+        m_impl(op.expression().index_pairs().reduce(op.reduce_dims(), op.reduce_op()), device),
+        m_return_dim(op.return_dim()) {
+    gen_strides(m_orig_impl.dimensions(), m_strides);
+    EIGEN_IF_CONSTEXPR (Layout == static_cast<int>(ColMajor)) {
+      const Index total_size = internal::array_prod(m_orig_impl.dimensions());
+      m_stride_mod = (m_return_dim < NumDims - 1) ? m_strides[m_return_dim + 1] : total_size;
+    } else {
+      const Index total_size = internal::array_prod(m_orig_impl.dimensions());
+      m_stride_mod = (m_return_dim > 0) ? m_strides[m_return_dim - 1] : total_size;
+    }
+    // If m_return_dim is not a valid index, returns 1 or this can crash on Windows.
+    m_stride_div =
+        ((m_return_dim >= 0) && (m_return_dim < static_cast<Index>(m_strides.size()))) ? m_strides[m_return_dim] : 1;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    const PairType v = m_impl.coeff(index);
+    return (m_return_dim < 0) ? v.first : (v.first % m_stride_mod) / m_stride_div;
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost =
+        1.0 + (m_return_dim < 0 ? 0.0 : (TensorOpCost::ModCost<Index>() + TensorOpCost::DivCost<Index>()));
+    return m_orig_impl.costPerCoeff(vectorized) + m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost);
+  }
+
+ private:
+  EIGEN_DEVICE_FUNC void gen_strides(const InputDimensions& dims, StrideDims& strides) {
+    if (m_return_dim < 0) {
+      return;  // Won't be using the strides.
+    }
+    eigen_assert(m_return_dim < NumDims && "Asking to convert index to a dimension outside of the rank");
+
+    // Calculate m_stride_div and m_stride_mod, which are used to
+    // calculate the value of an index w.r.t. the m_return_dim.
+    EIGEN_IF_CONSTEXPR (Layout == static_cast<int>(ColMajor)) {
+      strides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        strides[i] = strides[i - 1] * dims[i - 1];
+      }
+    } else {
+      strides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        strides[i] = strides[i + 1] * dims[i + 1];
+      }
+    }
+  }
+
+ protected:
+  TensorEvaluator<const TensorIndexPairOp<ArgType>, Device> m_orig_impl;
+  TensorEvaluator<const TensorReductionOp<ReduceOp, Dims, const TensorIndexPairOp<ArgType>>, Device> m_impl;
+  const Index m_return_dim;
+  StrideDims m_strides;
+  Index m_stride_mod;
+  Index m_stride_div;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_ARG_MAX_H
diff --git a/contrib/Eigen/src/Tensor/TensorAssign.h b/contrib/Eigen/src/Tensor/TensorAssign.h
new file mode 100644
index 0000000..0093c24
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorAssign.h
@@ -0,0 +1,213 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_ASSIGN_H
+#define EIGEN_TENSOR_TENSOR_ASSIGN_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename LhsXprType, typename RhsXprType>
+struct traits<TensorAssignOp<LhsXprType, RhsXprType> > {
+  typedef typename LhsXprType::Scalar Scalar;
+  typedef typename traits<LhsXprType>::StorageKind StorageKind;
+  typedef
+      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
+  static constexpr std::size_t NumDimensions = internal::traits<LhsXprType>::NumDimensions;
+  static constexpr int Layout = internal::traits<LhsXprType>::Layout;
+  typedef typename traits<LhsXprType>::PointerType PointerType;
+
+  enum { Flags = 0 };
+};
+
+template <typename LhsXprType, typename RhsXprType>
+struct eval<TensorAssignOp<LhsXprType, RhsXprType>, Eigen::Dense> {
+  typedef const TensorAssignOp<LhsXprType, RhsXprType>& type;
+};
+
+}  // end namespace internal
+
+/** The tensor assignment class.
+ * \ingroup Tensor_Module
+ *
+ * This class represents the assignment of the values resulting from the evaluation of
+ * the rhs expression to the memory locations denoted by the lhs expression.
+ */
+template <typename LhsXprType, typename RhsXprType>
+class TensorAssignOp : public TensorBase<TensorAssignOp<LhsXprType, RhsXprType> > {
+ public:
+  typedef typename Eigen::internal::traits<TensorAssignOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename LhsXprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorAssignOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorAssignOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorAssignOp>::Index Index;
+
+  static constexpr int NumDims = Eigen::internal::traits<TensorAssignOp>::NumDimensions;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorAssignOp(LhsXprType& lhs, const RhsXprType& rhs)
+      : m_lhs_xpr(lhs), m_rhs_xpr(rhs) {
+    EIGEN_STATIC_ASSERT((internal::traits<LhsXprType>::NumDimensions == internal::traits<RhsXprType>::NumDimensions),
+                        Number_of_dimensions_must_match)
+  }
+
+  /** \returns the nested expressions */
+  EIGEN_DEVICE_FUNC internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
+    return *((internal::remove_all_t<typename LhsXprType::Nested>*)&m_lhs_xpr);
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
+    return m_rhs_xpr;
+  }
+
+ protected:
+  internal::remove_all_t<typename LhsXprType::Nested>& m_lhs_xpr;
+  const internal::remove_all_t<typename RhsXprType::Nested>& m_rhs_xpr;
+};
+
+template <typename LeftArgType, typename RightArgType, typename Device>
+struct TensorEvaluator<const TensorAssignOp<LeftArgType, RightArgType>, Device> {
+  typedef TensorAssignOp<LeftArgType, RightArgType> XprType;
+  typedef typename XprType::Index Index;
+  using LeftIndex = typename TensorEvaluator<LeftArgType, Device>::Index;
+  using RightIndex = typename TensorEvaluator<RightArgType, Device>::Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename TensorEvaluator<RightArgType, Device>::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  static constexpr int NumDims = XprType::NumDims;
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+
+  enum {
+    IsAligned =
+        int(TensorEvaluator<LeftArgType, Device>::IsAligned) & int(TensorEvaluator<RightArgType, Device>::IsAligned),
+    PacketAccess = int(TensorEvaluator<LeftArgType, Device>::PacketAccess) &
+                   int(TensorEvaluator<RightArgType, Device>::PacketAccess),
+    BlockAccess = int(TensorEvaluator<LeftArgType, Device>::BlockAccess) &
+                  int(TensorEvaluator<RightArgType, Device>::BlockAccess),
+    PreferBlockAccess = int(TensorEvaluator<LeftArgType, Device>::PreferBlockAccess) |
+                        int(TensorEvaluator<RightArgType, Device>::PreferBlockAccess),
+    RawAccess = TensorEvaluator<LeftArgType, Device>::RawAccess
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const RightArgType, Device>::TensorBlock RightTensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  TensorEvaluator(const XprType& op, const Device& device)
+      : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
+                         static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+  }
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
+    // The dimensions of the lhs and the rhs tensors should be equal to prevent
+    // overflows and ensure the result is fully initialized.
+    // TODO: use left impl instead if right impl dimensions are known at compile time.
+    return m_rightImpl.dimensions();
+  }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    eigen_assert(dimensions_match(m_leftImpl.dimensions(), m_rightImpl.dimensions()));
+    m_leftImpl.evalSubExprsIfNeeded(nullptr);
+    // If the lhs provides raw access to its storage area (i.e. if m_leftImpl.data() returns a non
+    // null value), attempt to evaluate the rhs expression in place. Returns true iff in place
+    // evaluation isn't supported and the caller still needs to manually assign the values generated
+    // by the rhs to the lhs.
+    return m_rightImpl.evalSubExprsIfNeeded(m_leftImpl.data());
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_leftImpl.evalSubExprsIfNeededAsync(nullptr, [this, done](bool) {
+      m_rightImpl.evalSubExprsIfNeededAsync(m_leftImpl.data(), [done](bool need_assign) { done(need_assign); });
+    });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_leftImpl.cleanup();
+    m_rightImpl.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalScalar(Index i) const {
+    m_leftImpl.coeffRef(internal::convert_index<LeftIndex>(i)) =
+        m_rightImpl.coeff(internal::convert_index<RightIndex>(i));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalPacket(Index i) const {
+    constexpr int LhsStoreMode = TensorEvaluator<LeftArgType, Device>::IsAligned ? Aligned : Unaligned;
+    constexpr int RhsLoadMode = TensorEvaluator<RightArgType, Device>::IsAligned ? Aligned : Unaligned;
+    m_leftImpl.template writePacket<LhsStoreMode>(
+        internal::convert_index<LeftIndex>(i),
+        m_rightImpl.template packet<RhsLoadMode>(internal::convert_index<RightIndex>(i)));
+  }
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
+    return m_leftImpl.coeff(internal::convert_index<LeftIndex>(index));
+  }
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
+    return m_leftImpl.template packet<LoadMode>(internal::convert_index<LeftIndex>(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // We assume that evalPacket or evalScalar is called to perform the
+    // assignment and account for the cost of the write here, but reduce left
+    // cost by one load because we are using m_leftImpl.coeffRef.
+    TensorOpCost left = m_leftImpl.costPerCoeff(vectorized);
+    return m_rightImpl.costPerCoeff(vectorized) +
+           TensorOpCost(numext::maxi(0.0, left.bytes_loaded() - sizeof(CoeffReturnType)), left.bytes_stored(),
+                        left.compute_cycles()) +
+           TensorOpCost(0, sizeof(CoeffReturnType), 0, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::merge(m_leftImpl.getResourceRequirements(),
+                                                            m_rightImpl.getResourceRequirements());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalBlock(TensorBlockDesc& desc, TensorBlockScratch& scratch) {
+    if (TensorEvaluator<LeftArgType, Device>::RawAccess && m_leftImpl.data() != nullptr) {
+      // If destination has raw data access, we pass it as a potential
+      // destination for a block descriptor evaluation.
+      desc.template AddDestinationBuffer<Layout>(
+          /*dst_base=*/m_leftImpl.data() + desc.offset(),
+          /*dst_strides=*/internal::strides<Layout>(m_leftImpl.dimensions()));
+    }
+
+    RightTensorBlock block = m_rightImpl.block(desc, scratch, /*root_of_expr_ast=*/true);
+    // If block was evaluated into a destination, there is no need to do assignment.
+    if (block.kind() != internal::TensorBlockKind::kMaterializedInOutput) {
+      m_leftImpl.writeBlock(desc, block);
+    }
+    block.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_leftImpl.data(); }
+
+ private:
+  TensorEvaluator<LeftArgType, Device> m_leftImpl;
+  TensorEvaluator<RightArgType, Device> m_rightImpl;
+};
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_ASSIGN_H
diff --git a/contrib/Eigen/src/Tensor/TensorBase.h b/contrib/Eigen/src/Tensor/TensorBase.h
new file mode 100644
index 0000000..66ba73e
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorBase.h
@@ -0,0 +1,1316 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_BASE_H
+#define EIGEN_TENSOR_TENSOR_BASE_H
+
+// clang-format off
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+// Const TensorMap expressions expose a const-qualified Scalar. Ignore cv-qualifiers for an exact scalar match, while
+// keeping mixed arithmetic and enum operands within the existing implicit-conversion boundary.
+template <typename OtherScalar, typename Scalar>
+struct is_scalar_operand
+    : bool_constant<std::is_same<typename std::remove_cv<OtherScalar>::type,
+                                 typename std::remove_cv<Scalar>::type>::value ||
+                    ((std::is_arithmetic<OtherScalar>::value || std::is_enum<OtherScalar>::value) &&
+                     std::is_convertible<OtherScalar, Scalar>::value)> {};
+}  // namespace internal
+
+/** \class TensorBase
+  * \ingroup Tensor_Module
+  *
+  * \brief The tensor base class.
+  *
+  * This class is the common parent of the Tensor and TensorMap classes, thus
+  * making it possible to use either class interchangeably in expressions.
+  */
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+// FIXME: Doxygen does not like the inheritance with different template parameters
+// Since there is no doxygen documentation inside, we disable it for now
+template<typename Derived>
+class TensorBase<Derived, ReadOnlyAccessors>
+{
+  public:
+    typedef internal::traits<Derived> DerivedTraits;
+    typedef typename DerivedTraits::Scalar Scalar;
+    typedef typename DerivedTraits::Index Index;
+    typedef std::remove_const_t<Scalar> CoeffReturnType;
+    static constexpr int NumDimensions = DerivedTraits::NumDimensions;
+
+    // Generic nullary operation support.
+    template <typename CustomNullaryOp> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<CustomNullaryOp, const Derived>
+    nullaryExpr(const CustomNullaryOp& func) const {
+      return TensorCwiseNullaryOp<CustomNullaryOp, const Derived>(derived(), func);
+    }
+
+    // Coefficient-wise nullary operators
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived>
+    constant(const Scalar& value) const {
+      return nullaryExpr(internal::scalar_constant_op<Scalar>(value));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<internal::UniformRandomGenerator<Scalar>, const Derived>
+    random() const {
+      return nullaryExpr(internal::UniformRandomGenerator<Scalar>());
+    }
+    template <typename RandomGenerator> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<RandomGenerator, const Derived>
+    random(const RandomGenerator& gen = RandomGenerator()) const {
+      return nullaryExpr(gen);
+    }
+
+    // Tensor generation
+    template <typename Generator> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorGeneratorOp<Generator, const Derived>
+    generate(const Generator& generator) const {
+      return TensorGeneratorOp<Generator, const Derived>(derived(), generator);
+    }
+
+    // Generic unary operation support.
+    template <typename CustomUnaryOp> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<CustomUnaryOp, const Derived>
+    unaryExpr(const CustomUnaryOp& func) const {
+      return TensorCwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);
+    }
+
+    // Coefficient-wise unary operators
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived>
+    operator-() const {
+      return unaryExpr(internal::scalar_opposite_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived>
+    sqrt() const {
+      return unaryExpr(internal::scalar_sqrt_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived>
+    sign() const {
+      return unaryExpr(internal::scalar_sign_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived>
+    rsqrt() const {
+      return unaryExpr(internal::scalar_rsqrt_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived>
+    square() const {
+      return unaryExpr(internal::scalar_square_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived>
+    cube() const {
+      return unaryExpr(internal::scalar_cube_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived>
+    inverse() const {
+      return unaryExpr(internal::scalar_inverse_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived>
+    tanh() const {
+      return unaryExpr(internal::scalar_tanh_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived>
+    lgamma() const {
+      return unaryExpr(internal::scalar_lgamma_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived>
+    digamma() const {
+      return unaryExpr(internal::scalar_digamma_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i0_op<Scalar>, const Derived>
+    bessel_i0() const {
+      return unaryExpr(internal::scalar_bessel_i0_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i0e_op<Scalar>, const Derived>
+    bessel_i0e() const {
+      return unaryExpr(internal::scalar_bessel_i0e_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i1_op<Scalar>, const Derived>
+    bessel_i1() const {
+      return unaryExpr(internal::scalar_bessel_i1_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i1e_op<Scalar>, const Derived>
+    bessel_i1e() const {
+      return unaryExpr(internal::scalar_bessel_i1e_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_j0_op<Scalar>, const Derived>
+    bessel_j0() const {
+      return unaryExpr(internal::scalar_bessel_j0_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_y0_op<Scalar>, const Derived>
+    bessel_y0() const {
+      return unaryExpr(internal::scalar_bessel_y0_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_j1_op<Scalar>, const Derived>
+    bessel_j1() const {
+      return unaryExpr(internal::scalar_bessel_j1_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_y1_op<Scalar>, const Derived>
+    bessel_y1() const {
+      return unaryExpr(internal::scalar_bessel_y1_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k0_op<Scalar>, const Derived>
+    bessel_k0() const {
+      return unaryExpr(internal::scalar_bessel_k0_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k0e_op<Scalar>, const Derived>
+    bessel_k0e() const {
+      return unaryExpr(internal::scalar_bessel_k0e_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k1_op<Scalar>, const Derived>
+    bessel_k1() const {
+      return unaryExpr(internal::scalar_bessel_k1_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k1e_op<Scalar>, const Derived>
+    bessel_k1e() const {
+      return unaryExpr(internal::scalar_bessel_k1e_op<Scalar>());
+    }
+
+    // igamma(a = this, x = other)
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_igamma_op<Scalar>, const Derived, const OtherDerived>
+    igamma(const OtherDerived& other) const {
+      return binaryExpr(other.derived(), internal::scalar_igamma_op<Scalar>());
+    }
+
+    // igamma_der_a(a = this, x = other)
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_igamma_der_a_op<Scalar>, const Derived, const OtherDerived>
+    igamma_der_a(const OtherDerived& other) const {
+      return binaryExpr(other.derived(), internal::scalar_igamma_der_a_op<Scalar>());
+    }
+
+    // gamma_sample_der_alpha(alpha = this, sample = other)
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_gamma_sample_der_alpha_op<Scalar>, const Derived, const OtherDerived>
+    gamma_sample_der_alpha(const OtherDerived& other) const {
+      return binaryExpr(other.derived(), internal::scalar_gamma_sample_der_alpha_op<Scalar>());
+    }
+
+    // igammac(a = this, x = other)
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_igammac_op<Scalar>, const Derived, const OtherDerived>
+    igammac(const OtherDerived& other) const {
+      return binaryExpr(other.derived(), internal::scalar_igammac_op<Scalar>());
+    }
+
+    // zeta(x = this, q = other)
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const OtherDerived>
+    zeta(const OtherDerived& other) const {
+      return binaryExpr(other.derived(), internal::scalar_zeta_op<Scalar>());
+    }
+
+    // polygamma(n = this, x = other)
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const Derived, const OtherDerived>
+    polygamma(const OtherDerived& other) const {
+      return binaryExpr(other.derived(), internal::scalar_polygamma_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived>
+    erf() const {
+      return unaryExpr(internal::scalar_erf_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived>
+    erfc() const {
+      return unaryExpr(internal::scalar_erfc_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived>
+    ndtri() const {
+      return unaryExpr(internal::scalar_ndtri_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived>
+    sigmoid() const {
+      return unaryExpr(internal::scalar_logistic_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived>
+    exp() const {
+      return unaryExpr(internal::scalar_exp_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived>
+    expm1() const {
+      return unaryExpr(internal::scalar_expm1_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived>
+    log() const {
+      return unaryExpr(internal::scalar_log_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived>
+    log1p() const {
+      return unaryExpr(internal::scalar_log1p_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived>
+    log2() const {
+      return unaryExpr(internal::scalar_log2_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived>
+    abs() const {
+      return unaryExpr(internal::scalar_abs_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived>
+    arg() const {
+      return unaryExpr(internal::scalar_arg_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_clamp_op<Scalar>, const Derived>
+    clip(Scalar min, Scalar max) const {
+      return unaryExpr(internal::scalar_clamp_op<Scalar>(min, max));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const std::conditional_t<NumTraits<CoeffReturnType>::IsComplex,
+                                                      TensorCwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,
+                                                      Derived>
+    conjugate() const {
+      return choose(Cond<NumTraits<CoeffReturnType>::IsComplex>(), unaryExpr(internal::scalar_conjugate_op<Scalar>()), derived());
+    }
+
+    template<typename ScalarExponent>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const std::enable_if_t<internal::is_arithmetic<typename NumTraits<ScalarExponent>::Real>::value,
+        TensorCwiseUnaryOp<internal::scalar_unary_pow_op<Scalar, ScalarExponent>, const Derived>>
+        pow(ScalarExponent exponent) const
+    {
+        return unaryExpr(internal::scalar_unary_pow_op<Scalar, ScalarExponent>(exponent));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>
+    real() const {
+      return unaryExpr(internal::scalar_real_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived>
+    imag() const {
+      return unaryExpr(internal::scalar_imag_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_sum_op<Scalar,Scalar> >, const Derived>
+    operator+ (Scalar rhs) const {
+      return unaryExpr(internal::bind2nd_op<internal::scalar_sum_op<Scalar,Scalar> >(rhs));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_difference_op<Scalar,Scalar> >, const Derived>
+    operator- (Scalar rhs) const {
+      EIGEN_STATIC_ASSERT((NumTraits<Scalar>::IsSigned || std::is_same<Scalar, const std::complex<float> >::value), YOU_MADE_A_PROGRAMMING_MISTAKE);
+      return unaryExpr(internal::bind2nd_op<internal::scalar_difference_op<Scalar,Scalar> >(rhs));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_product_op<Scalar,Scalar> >, const Derived>
+    operator* (Scalar rhs) const {
+      return unaryExpr(internal::bind2nd_op<internal::scalar_product_op<Scalar,Scalar> >(rhs));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_quotient_op<Scalar,Scalar> >, const Derived>
+    operator/ (Scalar rhs) const {
+      return unaryExpr(internal::bind2nd_op<internal::scalar_quotient_op<Scalar,Scalar> >(rhs));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_mod_op<Scalar>, const Derived>
+    operator% (Scalar rhs) const {
+      EIGEN_STATIC_ASSERT(NumTraits<Scalar>::IsInteger, YOU_MADE_A_PROGRAMMING_MISTAKE_TRY_MOD);
+      return unaryExpr(internal::scalar_mod_op<Scalar>(rhs));
+    }
+
+    template <typename OtherScalar, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<OtherScalar, Scalar>::value))>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_mod_op<Scalar>, const Derived>
+    operator% (OtherScalar rhs) const {
+      return operator%(static_cast<Scalar>(rhs));
+    }
+
+    template <int NanPropagation=PropagateFast>
+    EIGEN_DEVICE_FUNC
+        EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar,NanPropagation>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    cwiseMax(Scalar threshold) const {
+      return cwiseMax<NanPropagation>(constant(threshold));
+    }
+
+    template <int NanPropagation=PropagateFast>
+    EIGEN_DEVICE_FUNC
+        EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar,NanPropagation>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    cwiseMin(Scalar threshold) const {
+      return cwiseMin<NanPropagation>(constant(threshold));
+    }
+
+    template<typename NewType>
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const std::conditional_t<std::is_same<NewType, CoeffReturnType>::value,
+                                                      Derived,
+                                                      TensorConversionOp<NewType, const Derived> >
+    cast() const {
+      return choose(Cond<std::is_same<NewType, CoeffReturnType>::value>(), derived(), TensorConversionOp<NewType, const Derived>(derived()));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived>
+    round() const {
+      return unaryExpr(internal::scalar_round_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived>
+    rint() const {
+      return unaryExpr(internal::scalar_rint_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived>
+    ceil() const {
+      return unaryExpr(internal::scalar_ceil_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived>
+    floor() const {
+      return unaryExpr(internal::scalar_floor_op<Scalar>());
+    }
+
+    // Generic binary operation support.
+    template <typename CustomBinaryOp, typename OtherDerived> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>
+    binaryExpr(const OtherDerived& other, const CustomBinaryOp& func) const {
+      return TensorCwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>(derived(), other, func);
+    }
+
+    // Coefficient-wise binary operators. The TensorBase-constrained operand keeps scalar
+    // right-hand sides on the scalar overloads instead of a deduced tensor-tensor expression
+    // whose instantiation fails.
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_sum_op<Scalar>, const Derived, const OtherDerived>
+    operator+(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_sum_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_difference_op<Scalar>, const Derived, const OtherDerived>
+    operator-(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_difference_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_product_op<Scalar>, const Derived, const OtherDerived>
+    operator*(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_product_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>
+    operator/(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_quotient_op<Scalar>());
+    }
+
+    template<int NaNPropagation=PropagateFast, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar, NaNPropagation>, const Derived, const OtherDerived>
+    cwiseMax(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_max_op<Scalar,Scalar, NaNPropagation>());
+    }
+
+    template<int NaNPropagation=PropagateFast, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar, NaNPropagation>, const Derived, const OtherDerived>
+    cwiseMin(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_min_op<Scalar,Scalar, NaNPropagation>());
+    }
+
+    // logical operators
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_boolean_and_op<Scalar>, const Derived, const OtherDerived>
+    operator&&(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_boolean_and_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_boolean_or_op<Scalar>, const Derived, const OtherDerived>
+    operator||(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_boolean_or_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_bitwise_and_op<Scalar>, const Derived, const OtherDerived>
+    operator&(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_bitwise_and_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_bitwise_or_op<Scalar>, const Derived, const OtherDerived>
+    operator|(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_bitwise_or_op<Scalar>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_bitwise_xor_op<Scalar>, const Derived, const OtherDerived>
+    operator^(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_bitwise_xor_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived>
+    operator!() const {
+      return unaryExpr(internal::scalar_boolean_not_op<Scalar>());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseUnaryOp<internal::scalar_bitwise_not_op<Scalar>, const Derived>
+    operator~() const {
+      return unaryExpr(internal::scalar_bitwise_not_op<Scalar>());
+    }
+
+    // Comparisons and tests.
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT>, const Derived, const OtherDerived>
+    operator<(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT>());
+    }
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE>, const Derived, const OtherDerived>
+    operator<=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE>());
+    }
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT>, const Derived, const OtherDerived>
+    operator>(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT>());
+    }
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE>, const Derived, const OtherDerived>
+    operator>=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>, const Derived, const OtherDerived>
+    operator==(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>());
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ>, const Derived, const OtherDerived>
+    operator!=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
+      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ>());
+    }
+
+    // comparisons and tests for Scalars
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    operator<(Scalar threshold) const {
+      return operator<(constant(threshold));
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    operator<=(Scalar threshold) const {
+      return operator<=(constant(threshold));
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    operator>(Scalar threshold) const {
+      return operator>(constant(threshold));
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    operator>=(Scalar threshold) const {
+      return operator>=(constant(threshold));
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    operator==(Scalar threshold) const {
+      return operator==(constant(threshold));
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
+    operator!=(Scalar threshold) const {
+      return operator!=(constant(threshold));
+    }
+
+    // Exact matches keep rank-0 reductions' mixed-scalar comparisons from becoming ambiguous with built-ins.
+#define EIGEN_FORWARD_SCALAR_CMP(op, tag)                                                                             \
+  template <typename OtherScalar, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<OtherScalar, Scalar>::value))>  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const                                                                         \
+      TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_##tag>, const Derived,                \
+                          const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >           \
+  op(OtherScalar threshold) const {                                                                                   \
+    return op(static_cast<Scalar>(threshold));                                                                        \
+  }
+    EIGEN_FORWARD_SCALAR_CMP(operator<, LT)
+    EIGEN_FORWARD_SCALAR_CMP(operator<=, LE)
+    EIGEN_FORWARD_SCALAR_CMP(operator>, GT)
+    EIGEN_FORWARD_SCALAR_CMP(operator>=, GE)
+    EIGEN_FORWARD_SCALAR_CMP(operator==, EQ)
+    EIGEN_FORWARD_SCALAR_CMP(operator!=, NEQ)
+#undef EIGEN_FORWARD_SCALAR_CMP
+
+    // Predicates.
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorConversionOp<bool, const TensorCwiseUnaryOp<internal::scalar_isnan_op<Scalar, true>, const Derived>>
+    (isnan)() const {
+      return unaryExpr(internal::scalar_isnan_op<Scalar, true>()).template cast<bool>();
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorConversionOp<bool, const TensorCwiseUnaryOp<internal::scalar_isinf_op<Scalar, true>, const Derived>>
+    (isinf)() const {
+      return unaryExpr(internal::scalar_isinf_op<Scalar, true>()).template cast<bool>();
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const TensorConversionOp<bool, const TensorCwiseUnaryOp<internal::scalar_isfinite_op<Scalar, true>, const Derived>>
+    (isfinite)() const {
+      return unaryExpr(internal::scalar_isfinite_op<Scalar, true>()).template cast<bool>();
+    }
+
+    // Coefficient-wise ternary operators.
+    template<typename ThenDerived, typename ElseDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorSelectOp<const Derived, const ThenDerived, const ElseDerived>
+    select(const ThenDerived& thenTensor, const ElseDerived& elseTensor) const {
+      return TensorSelectOp<const Derived, const ThenDerived, const ElseDerived>(derived(), thenTensor.derived(), elseTensor.derived());
+    }
+
+    // Contractions.
+    typedef Eigen::IndexPair<Index> DimensionPair;
+
+    template<typename OtherDerived, typename Dimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const NoOpOutputKernel>
+    contract(const OtherDerived& other, const Dimensions& dims) const {
+      return TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const NoOpOutputKernel>(derived(), other.derived(), dims);
+    }
+
+    template<typename OtherDerived, typename Dimensions, typename OutputKernel> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const OutputKernel>
+    contract(const OtherDerived& other, const Dimensions& dims, const OutputKernel& output_kernel) const {
+      return TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const OutputKernel>(derived(), other.derived(), dims, output_kernel);
+    }
+
+    // Convolutions.
+    template<typename KernelDerived, typename Dimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorConvolutionOp<const Dimensions, const Derived, const KernelDerived>
+    convolve(const KernelDerived& kernel, const Dimensions& dims) const {
+      return TensorConvolutionOp<const Dimensions, const Derived, const KernelDerived>(derived(), kernel.derived(), dims);
+    }
+
+    // Fourier transforms
+    template <int FFTDataType, int FFTDirection, typename FFT> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorFFTOp<const FFT, const Derived, FFTDataType, FFTDirection>
+    fft(const FFT& dims) const {
+      return TensorFFTOp<const FFT, const Derived, FFTDataType, FFTDirection>(derived(), dims);
+    }
+
+    // Scan.
+    typedef TensorScanOp<internal::SumReducer<CoeffReturnType>, const Derived> TensorScanSumOp;
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorScanSumOp
+    cumsum(const Index& axis, bool exclusive = false) const {
+      return TensorScanSumOp(derived(), axis, exclusive);
+    }
+
+    typedef TensorScanOp<internal::ProdReducer<CoeffReturnType>, const Derived> TensorScanProdOp;
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorScanProdOp
+    cumprod(const Index& axis, bool exclusive = false) const {
+      return TensorScanProdOp(derived(), axis, exclusive);
+    }
+
+    template <typename Reducer>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorScanOp<Reducer, const Derived>
+    scan(const Index& axis, const Reducer& reducer, bool exclusive = false) const {
+      return TensorScanOp<Reducer, const Derived>(derived(), axis, exclusive, reducer);
+    }
+
+    // Reductions.
+    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::SumReducer<CoeffReturnType>, const Dims, const Derived>
+    sum(const Dims& dims) const {
+      return TensorReductionOp<internal::SumReducer<CoeffReturnType>, const Dims, const Derived>(derived(), dims, internal::SumReducer<CoeffReturnType>());
+    }
+
+    const TensorReductionOp<internal::SumReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>
+    sum() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return TensorReductionOp<internal::SumReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::SumReducer<CoeffReturnType>());
+    }
+
+    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const Dims, const Derived>
+    mean(const Dims& dims) const {
+      return TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const Dims, const Derived>(derived(), dims, internal::MeanReducer<CoeffReturnType>());
+    }
+
+    const TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>
+    mean() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::MeanReducer<CoeffReturnType>());
+    }
+
+    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const Dims, const Derived>
+    prod(const Dims& dims) const {
+      return TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const Dims, const Derived>(derived(), dims, internal::ProdReducer<CoeffReturnType>());
+    }
+
+    const TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>
+    prod() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::ProdReducer<CoeffReturnType>());
+    }
+
+    template <typename Dims,int NanPropagation=PropagateFast> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>
+    maximum(const Dims& dims) const {
+      return TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>(derived(), dims, internal::MaxReducer<CoeffReturnType,NanPropagation>());
+    }
+
+    template <int NanPropagation=PropagateFast>
+    const TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>
+    maximum() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::MaxReducer<CoeffReturnType,NanPropagation>());
+    }
+
+    template <typename Dims,int NanPropagation=PropagateFast> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>
+    minimum(const Dims& dims) const {
+      return TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>(derived(), dims, internal::MinReducer<CoeffReturnType,NanPropagation>());
+    }
+
+    template <int NanPropagation=PropagateFast>
+    const TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>
+    minimum() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::MinReducer<CoeffReturnType,NanPropagation>());
+    }
+
+    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::AndReducer, const Dims, const std::conditional_t<std::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
+    all(const Dims& dims) const {
+      return cast<bool>().reduce(dims, internal::AndReducer());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::AndReducer, const DimensionList<Index, NumDimensions>, const std::conditional_t<std::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
+    all() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return cast<bool>().reduce(in_dims, internal::AndReducer());
+    }
+
+    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::OrReducer, const Dims, const std::conditional_t<std::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
+    any(const Dims& dims) const {
+      return cast<bool>().reduce(dims, internal::OrReducer());
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<internal::OrReducer, const DimensionList<Index, NumDimensions>, const std::conditional_t<std::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
+    any() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return cast<bool>().reduce(in_dims, internal::OrReducer());
+    }
+
+   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPairReducerOp<
+      internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
+      const array<Index, NumDimensions>, const Derived>
+    argmax() const {
+      array<Index, NumDimensions> in_dims;
+      for (Index d = 0; d < NumDimensions; ++d) in_dims[d] = d;
+      return TensorPairReducerOp<
+        internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
+        const array<Index, NumDimensions>,
+        const Derived>(derived(), internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >(), -1, in_dims);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPairReducerOp<
+      internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
+      const array<Index, NumDimensions>, const Derived>
+    argmin() const {
+      array<Index, NumDimensions> in_dims;
+      for (Index d = 0; d < NumDimensions; ++d) in_dims[d] = d;
+      return TensorPairReducerOp<
+        internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
+        const array<Index, NumDimensions>,
+        const Derived>(derived(), internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >(), -1, in_dims);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPairReducerOp<
+      internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
+      const array<Index, 1>, const Derived>
+    argmax(const Index return_dim) const {
+      array<Index, 1> in_dims;
+      in_dims[0] = return_dim;
+      return TensorPairReducerOp<
+        internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
+        const array<Index, 1>,
+        const Derived>(derived(), internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >(), return_dim, in_dims);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPairReducerOp<
+      internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
+      const array<Index, 1>, const Derived>
+    argmin(const Index return_dim) const {
+      array<Index, 1> in_dims;
+      in_dims[0] = return_dim;
+      return TensorPairReducerOp<
+        internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
+        const array<Index, 1>,
+        const Derived>(derived(), internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >(), return_dim, in_dims);
+    }
+
+    template <typename Reducer, typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReductionOp<Reducer, const Dims, const Derived>
+    reduce(const Dims& dims, const Reducer& reducer) const {
+      return TensorReductionOp<Reducer, const Dims, const Derived>(derived(), dims, reducer);
+    }
+
+    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorTraceOp<const Dims, const Derived>
+    trace(const Dims& dims) const {
+      return TensorTraceOp<const Dims, const Derived>(derived(), dims);
+    }
+
+    const TensorTraceOp<const DimensionList<Index, NumDimensions>, const Derived>
+    trace() const {
+      DimensionList<Index, NumDimensions> in_dims;
+      return TensorTraceOp<const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims);
+    }
+
+    template <typename Broadcast> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorBroadcastingOp<const Broadcast, const Derived>
+    broadcast(const Broadcast& bcast) const {
+      return TensorBroadcastingOp<const Broadcast, const Derived>(derived(), bcast);
+    }
+
+    template <typename Axis, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorConcatenationOp<Axis, const Derived, const OtherDerived>
+    concatenate(const OtherDerived& other, Axis axis) const {
+      return TensorConcatenationOp<Axis, const Derived, const OtherDerived>(derived(), other.derived(), axis);
+    }
+
+    template <typename PatchDims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPatchOp<const PatchDims, const Derived>
+    extract_patches(const PatchDims& patch_dims) const {
+      return TensorPatchOp<const PatchDims, const Derived>(derived(), patch_dims);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorImagePatchOp<Dynamic, Dynamic, const Derived>
+    extract_image_patches(const Index patch_rows = 1, const Index patch_cols = 1,
+                          const Index row_stride = 1, const Index col_stride = 1,
+                          const Index in_row_stride = 1, const Index in_col_stride = 1,
+                          const PaddingType padding_type = PADDING_SAME, const Scalar padding_value = Scalar(0)) const {
+      return TensorImagePatchOp<Dynamic, Dynamic, const Derived>(derived(), patch_rows, patch_cols, row_stride, col_stride,
+                                                                 in_row_stride, in_col_stride, 1, 1, padding_type, padding_value);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorImagePatchOp<Dynamic, Dynamic, const Derived>
+    extract_image_patches(const Index patch_rows, const Index patch_cols,
+                          const Index row_stride, const Index col_stride,
+                          const Index in_row_stride, const Index in_col_stride,
+                          const Index row_inflate_stride, const Index col_inflate_stride,
+                          const Index padding_top, const Index padding_bottom,
+                          const Index padding_left,const Index padding_right,
+                          const Scalar padding_value) const {
+      return TensorImagePatchOp<Dynamic, Dynamic, const Derived>(derived(), patch_rows, patch_cols, row_stride, col_stride,
+                                                                 in_row_stride, in_col_stride, row_inflate_stride, col_inflate_stride,
+                                                                 padding_top, padding_bottom, padding_left, padding_right, padding_value);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>
+    extract_volume_patches(const Index patch_planes, const Index patch_rows, const Index patch_cols,
+                           const Index plane_stride = 1, const Index row_stride = 1, const Index col_stride = 1,
+                           const PaddingType padding_type = PADDING_SAME, const Scalar padding_value = Scalar(0)) const {
+      return TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>(derived(), patch_planes, patch_rows, patch_cols, plane_stride, row_stride, col_stride, 1, 1, 1, 1, 1, 1, padding_type, padding_value);
+    }
+
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>
+    extract_volume_patches(const Index patch_planes, const Index patch_rows, const Index patch_cols,
+                           const Index plane_stride, const Index row_stride, const Index col_stride,
+                           const Index plane_inflate_stride, const Index row_inflate_stride, const Index col_inflate_stride,
+                           const Index padding_top_z, const Index padding_bottom_z,
+                           const Index padding_top, const Index padding_bottom,
+                           const Index padding_left, const Index padding_right, const Scalar padding_value = Scalar(0)) const {
+      return TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>(derived(), patch_planes, patch_rows, patch_cols, plane_stride, row_stride, col_stride, 1, 1, 1, plane_inflate_stride, row_inflate_stride, col_inflate_stride, padding_top_z, padding_bottom_z, padding_top, padding_bottom, padding_left, padding_right, padding_value);
+    }
+
+    // Morphing operators.
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorLayoutSwapOp<const Derived>
+    swap_layout() const {
+      return TensorLayoutSwapOp<const Derived>(derived());
+    }
+    template <typename NewDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReshapingOp<const NewDimensions, const Derived>
+    reshape(const NewDimensions& newDimensions) const {
+      return TensorReshapingOp<const NewDimensions, const Derived>(derived(), newDimensions);
+    }
+    template <typename StartIndices, typename Sizes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorSlicingOp<const StartIndices, const Sizes, const Derived>
+    slice(const StartIndices& startIndices, const Sizes& sizes) const {
+      return TensorSlicingOp<const StartIndices, const Sizes, const Derived>(derived(), startIndices, sizes);
+    }
+    template <typename StartIndices, typename StopIndices, typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides, const Derived>
+    stridedSlice(const StartIndices& startIndices, const StopIndices& stopIndices, const Strides& strides) const {
+      return TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides,
+                                const Derived>(derived(), startIndices, stopIndices, strides);
+    }
+    template <Index DimId> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorChippingOp<DimId, const Derived>
+    chip(const Index offset) const {
+      EIGEN_STATIC_ASSERT(DimId < Derived::NumDimensions && DimId >= 0, Chip_Dim_out_of_range)
+      return TensorChippingOp<DimId, const Derived>(derived(), offset, DimId);
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorChippingOp<Dynamic, const Derived>
+    chip(const Index offset, const Index dim) const {
+      return TensorChippingOp<Dynamic, const Derived>(derived(), offset, dim);
+    }
+    template <typename ReverseDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReverseOp<const ReverseDimensions, const Derived>
+    reverse(const ReverseDimensions& rev) const {
+      return TensorReverseOp<const ReverseDimensions, const Derived>(derived(), rev);
+    }
+    template <typename Rolls> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorRollOp<const Rolls, const Derived>
+    roll(const Rolls& rolls) const {
+      return TensorRollOp<const Rolls, const Derived>(derived(), rolls);
+    }
+    template <typename PaddingDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPaddingOp<const PaddingDimensions, const Derived>
+    pad(const PaddingDimensions& padding) const {
+      return TensorPaddingOp<const PaddingDimensions, const Derived>(derived(), padding, internal::scalar_cast_op<int, Scalar>()(0));
+    }
+    template <typename PaddingDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorPaddingOp<const PaddingDimensions, const Derived>
+    pad(const PaddingDimensions& padding, const Scalar padding_value) const {
+      return TensorPaddingOp<const PaddingDimensions, const Derived>(derived(), padding, padding_value);
+    }
+    template <typename Shuffle> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorShufflingOp<const Shuffle, const Derived>
+    shuffle(const Shuffle& shfl) const {
+      return TensorShufflingOp<const Shuffle, const Derived>(derived(), shfl);
+    }
+    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorStridingOp<const Strides, const Derived>
+    stride(const Strides& strides) const {
+      return TensorStridingOp<const Strides, const Derived>(derived(), strides);
+    }
+    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorInflationOp<const Strides, const Derived>
+    inflate(const Strides& strides) const {
+      return TensorInflationOp<const Strides, const Derived>(derived(), strides);
+    }
+
+    // Returns a tensor containing index/value pairs
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorIndexPairOp<const Derived>
+    index_pairs() const {
+      return TensorIndexPairOp<const Derived>(derived());
+    }
+
+    // Support for custom unary and binary operations
+    template <typename CustomUnaryFunc>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCustomUnaryOp<const CustomUnaryFunc, const Derived> customOp(const CustomUnaryFunc& op) const {
+      return TensorCustomUnaryOp<const CustomUnaryFunc, const Derived>(derived(), op);
+    }
+    template <typename OtherDerived, typename CustomBinaryFunc>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorCustomBinaryOp<const CustomBinaryFunc, const Derived, const OtherDerived> customOp(const OtherDerived& other, const CustomBinaryFunc& op) const {
+      return TensorCustomBinaryOp<const CustomBinaryFunc, const Derived, const OtherDerived>(derived(), other, op);
+    }
+
+    // Force the evaluation of the expression.
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorForcedEvalOp<const Derived> eval() const {
+      return TensorForcedEvalOp<const Derived>(derived());
+    }
+
+    // Returns a formatted tensor ready for printing to a stream
+    template<typename Format>
+    inline const TensorWithFormat<Derived,DerivedTraits::Layout,DerivedTraits::NumDimensions, Format> format(const Format& fmt) const {
+      return TensorWithFormat<Derived,DerivedTraits::Layout,DerivedTraits::NumDimensions, Format>(derived(), fmt);
+    }
+
+    #ifdef EIGEN_READONLY_TENSORBASE_PLUGIN
+    #include EIGEN_READONLY_TENSORBASE_PLUGIN
+    #endif
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+  protected:
+    template <typename Scalar, int NumIndices, int Options, typename IndexType> friend class Tensor;
+    template <typename Scalar, typename Dimensions, int Option, typename IndexTypes> friend class TensorFixedSize;
+    // the Eigen:: prefix is required to workaround a compilation issue with nvcc 9.0
+    template <typename OtherDerived, int AccessLevel> friend class Eigen::TensorBase;
+};
+
+template<typename Derived, int AccessLevel = internal::accessors_level<Derived>::value>
+class TensorBase : public TensorBase<Derived, ReadOnlyAccessors> {
+ public:
+    typedef TensorBase<Derived, ReadOnlyAccessors> Base;
+    typedef internal::traits<Derived> DerivedTraits;
+    typedef typename DerivedTraits::Scalar Scalar;
+    typedef typename DerivedTraits::Index Index;
+    typedef Scalar CoeffReturnType;
+    static constexpr int NumDimensions = DerivedTraits::NumDimensions;
+
+    template <typename Scalar, int NumIndices, int Options, typename IndexType> friend class Tensor;
+    template <typename Scalar, typename Dimensions, int Option, typename IndexTypes> friend class TensorFixedSize;
+    // the Eigen:: prefix is required to workaround a compilation issue with nvcc 9.0
+    template <typename OtherDerived, int OtherAccessLevel> friend class Eigen::TensorBase;
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& setZero() {
+      return setConstant(Scalar(0));
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& setConstant(const Scalar& val) {
+      return derived() = this->constant(val);
+    }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& setRandom() {
+      return derived() = this->random();
+    }
+    template <typename RandomGenerator> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& setRandom() {
+      return derived() = this->template random<RandomGenerator>();
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& setValues(
+        const typename internal::Initializer<Derived, NumDimensions>::InitList& vals) {
+      TensorEvaluator<Derived, DefaultDevice> eval(derived(), DefaultDevice());
+      internal::initialize_tensor<Derived, NumDimensions>(eval, vals);
+      return derived();
+    }
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator+=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
+      return derived() = derived() + other.derived();
+    }
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator-=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
+      return derived() = derived() - other.derived();
+    }
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator*=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
+      return derived() = derived() * other.derived();
+    }
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    Derived& operator/=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
+      return derived() = derived() / other.derived();
+    }
+
+    template <typename OtherScalar, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<OtherScalar, Scalar>::value))>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator+=(OtherScalar other) {
+      return derived() = derived() + static_cast<Scalar>(other);
+    }
+    template <typename OtherScalar, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<OtherScalar, Scalar>::value))>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator-=(OtherScalar other) {
+      return derived() = derived() - static_cast<Scalar>(other);
+    }
+    template <typename OtherScalar, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<OtherScalar, Scalar>::value))>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator*=(OtherScalar other) {
+      return derived() = derived() * static_cast<Scalar>(other);
+    }
+    template <typename OtherScalar, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<OtherScalar, Scalar>::value))>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator/=(OtherScalar other) {
+      return derived() = derived() / static_cast<Scalar>(other);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorLayoutSwapOp<const Derived>
+    swap_layout() const {
+      return TensorLayoutSwapOp<const Derived>(derived());
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorLayoutSwapOp<Derived>
+    swap_layout() {
+      return TensorLayoutSwapOp<Derived>(derived());
+    }
+
+    template <typename Axis, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorConcatenationOp<const Axis, const Derived, const OtherDerived>
+    concatenate(const OtherDerived& other, const Axis& axis) const {
+      return TensorConcatenationOp<const Axis, const Derived, const OtherDerived>(derived(), other, axis);
+    }
+    template <typename Axis, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorConcatenationOp<const Axis, Derived, OtherDerived>
+    concatenate(const OtherDerived& other, const Axis& axis) {
+      return TensorConcatenationOp<const Axis, Derived, OtherDerived>(derived(), other, axis);
+    }
+
+    template <typename NewDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReshapingOp<const NewDimensions, const Derived>
+    reshape(const NewDimensions& newDimensions) const {
+      return TensorReshapingOp<const NewDimensions, const Derived>(derived(), newDimensions);
+    }
+    template <typename NewDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorReshapingOp<const NewDimensions, Derived>
+    reshape(const NewDimensions& newDimensions) {
+      return TensorReshapingOp<const NewDimensions, Derived>(derived(), newDimensions);
+    }
+
+    template <typename StartIndices, typename Sizes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorSlicingOp<const StartIndices, const Sizes, const Derived>
+    slice(const StartIndices& startIndices, const Sizes& sizes) const {
+      return TensorSlicingOp<const StartIndices, const Sizes, const Derived>(derived(), startIndices, sizes);
+    }
+    template <typename StartIndices, typename Sizes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorSlicingOp<const StartIndices, const Sizes, Derived>
+    slice(const StartIndices& startIndices, const Sizes& sizes) {
+      return TensorSlicingOp<const StartIndices, const Sizes, Derived>(derived(), startIndices, sizes);
+    }
+
+    template <typename StartIndices, typename StopIndices, typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides, const Derived>
+    stridedSlice(const StartIndices& startIndices, const StopIndices& stopIndices, const Strides& strides) const {
+      return TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides,
+                                const Derived>(derived(), startIndices, stopIndices, strides);
+    }
+    template <typename StartIndices, typename StopIndices, typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides, Derived>
+    stridedSlice(const StartIndices& startIndices, const StopIndices& stopIndices, const Strides& strides) {
+      return TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides,
+                                Derived>(derived(), startIndices, stopIndices, strides);
+    }
+
+    template <DenseIndex DimId> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorChippingOp<DimId, const Derived>
+    chip(const Index offset) const {
+      EIGEN_STATIC_ASSERT(DimId < Derived::NumDimensions && DimId >= 0, Chip_Dim_out_of_range)
+      return TensorChippingOp<DimId, const Derived>(derived(), offset, DimId);
+    }
+    template <Index DimId> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorChippingOp<DimId, Derived>
+    chip(const Index offset) {
+      EIGEN_STATIC_ASSERT(DimId < Derived::NumDimensions && DimId >= 0, Chip_Dim_out_of_range)
+      return TensorChippingOp<DimId, Derived>(derived(), offset, DimId);
+    }
+
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorChippingOp<Dynamic, const Derived>
+    chip(const Index offset, const Index dim) const {
+      return TensorChippingOp<Dynamic, const Derived>(derived(), offset, dim);
+    }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorChippingOp<Dynamic, Derived>
+    chip(const Index offset, const Index dim) {
+      return TensorChippingOp<Dynamic, Derived>(derived(), offset, dim);
+    }
+
+    template <typename ReverseDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorReverseOp<const ReverseDimensions, const Derived>
+    reverse(const ReverseDimensions& rev) const {
+      return TensorReverseOp<const ReverseDimensions, const Derived>(derived(), rev);
+    }
+    template <typename ReverseDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorReverseOp<const ReverseDimensions, Derived>
+    reverse(const ReverseDimensions& rev) {
+      return TensorReverseOp<const ReverseDimensions, Derived>(derived(), rev);
+    }
+
+    template <typename Rolls> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorRollOp<const Rolls, const Derived>
+    roll(const Rolls& roll) const {
+      return TensorRollOp<const Rolls, const Derived>(derived(), roll);
+    }
+    template <typename Rolls> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorRollOp<const Rolls, Derived>
+    roll(const Rolls& roll) {
+      return TensorRollOp<const Rolls, Derived>(derived(), roll);
+    }
+
+    template <typename Shuffle> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorShufflingOp<const Shuffle, const Derived>
+    shuffle(const Shuffle& shfl) const {
+      return TensorShufflingOp<const Shuffle, const Derived>(derived(), shfl);
+    }
+    template <typename Shuffle> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorShufflingOp<const Shuffle, Derived>
+    shuffle(const Shuffle& shfl) {
+      return TensorShufflingOp<const Shuffle, Derived>(derived(), shfl);
+    }
+
+    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    const TensorStridingOp<const Strides, const Derived>
+    stride(const Strides& strides) const {
+      return TensorStridingOp<const Strides, const Derived>(derived(), strides);
+    }
+    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    TensorStridingOp<const Strides, Derived>
+    stride(const Strides& strides) {
+      return TensorStridingOp<const Strides, Derived>(derived(), strides);
+    }
+
+    // Select the device on which to evaluate the expression.
+    template <typename DeviceType>
+    TensorDevice<Derived, DeviceType> device(const DeviceType& dev) {
+      return TensorDevice<Derived, DeviceType>(dev, derived());
+    }
+
+    // Select the async device on which to evaluate the expression.
+    template <typename DeviceType, typename DoneCallback>
+    TensorAsyncDevice<Derived, DeviceType, DoneCallback> device(const DeviceType& dev, DoneCallback done) {
+      return TensorAsyncDevice<Derived, DeviceType, DoneCallback>(dev, derived(), std::move(done));
+    }
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& derived() { return *static_cast<Derived*>(this); }
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE const Derived& derived() const { return *static_cast<const Derived*>(this); }
+
+    #ifdef EIGEN_TENSORBASE_PLUGIN
+    #include EIGEN_TENSORBASE_PLUGIN
+    #endif
+
+ protected:
+    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TensorBase)
+    EIGEN_DEFAULT_COPY_CONSTRUCTOR(TensorBase)
+
+    template<typename OtherDerived> EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Derived& operator=(const OtherDerived& other)
+    {
+      typedef TensorAssignOp<Derived, const OtherDerived> Assign;
+      Assign assign(derived(), other.derived());
+      internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+      return derived();
+    }
+};
+#endif // EIGEN_PARSED_BY_DOXYGEN
+
+// Exact matches keep rank-0 reductions' mixed-scalar arithmetic from becoming ambiguous with built-ins.
+// Namespace scope avoids hidden-friend ADL pollution of NumTraits enum arithmetic on MSVC 14.29.
+#define EIGEN_FORWARD_SCALAR_BINOP(op, name)                                                                           \
+  template <typename OtherScalar, typename Derived,                                                                   \
+            EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<                                                       \
+                                    OtherScalar, typename internal::traits<Derived>::Scalar>::value))>                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<                                                       \
+      internal::bind1st_op<internal::scalar_##name##_op<typename internal::traits<Derived>::Scalar> >, const Derived>  \
+  op(OtherScalar lhs, const TensorBase<Derived, ReadOnlyAccessors>& rhs) {                                              \
+    typedef typename internal::traits<Derived>::Scalar Scalar;                                                         \
+    return rhs.derived().unaryExpr(                                                                                    \
+        internal::bind1st_op<internal::scalar_##name##_op<Scalar> >(static_cast<Scalar>(lhs)));                        \
+  }
+EIGEN_FORWARD_SCALAR_BINOP(operator+, sum)
+EIGEN_FORWARD_SCALAR_BINOP(operator-, difference)
+EIGEN_FORWARD_SCALAR_BINOP(operator*, product)
+EIGEN_FORWARD_SCALAR_BINOP(operator/, quotient)
+#undef EIGEN_FORWARD_SCALAR_BINOP
+
+// Scalar-on-the-left comparisons reflect the operator, so scalar < tensor yields the same rank-0
+// tensor expression as the member tensor > scalar. The scalar operand has no rank-0 conversion the
+// built-in comparison could use, so without these the left-hand scalar form does not compile.
+#define EIGEN_FORWARD_SCALAR_CMP_LHS(op, reflected, tag)                                                       \
+  template <typename OtherScalar, typename Derived,                                                            \
+            EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<                                                \
+                                    OtherScalar, typename internal::traits<Derived>::Scalar>::value))>          \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<                                              \
+      internal::scalar_cmp_op<typename internal::traits<Derived>::Scalar,                                      \
+                              typename internal::traits<Derived>::Scalar, internal::cmp_##tag>,                 \
+      const Derived,                                                                                           \
+      const TensorCwiseNullaryOp<internal::scalar_constant_op<typename internal::traits<Derived>::Scalar>,     \
+                                 const Derived> >                                                              \
+  op(OtherScalar lhs, const TensorBase<Derived, ReadOnlyAccessors>& rhs) {                                     \
+    typedef typename internal::traits<Derived>::Scalar Scalar;                                                 \
+    return rhs.derived().reflected(static_cast<Scalar>(lhs));                                                  \
+  }
+EIGEN_FORWARD_SCALAR_CMP_LHS(operator<, operator>, GT)
+EIGEN_FORWARD_SCALAR_CMP_LHS(operator<=, operator>=, GE)
+EIGEN_FORWARD_SCALAR_CMP_LHS(operator>, operator<, LT)
+EIGEN_FORWARD_SCALAR_CMP_LHS(operator>=, operator<=, LE)
+EIGEN_FORWARD_SCALAR_CMP_LHS(operator==, operator==, EQ)
+EIGEN_FORWARD_SCALAR_CMP_LHS(operator!=, operator!=, NEQ)
+#undef EIGEN_FORWARD_SCALAR_CMP_LHS
+
+} // end namespace Eigen
+
+#endif // EIGEN_TENSOR_TENSOR_BASE_H
diff --git a/contrib/Eigen/src/Tensor/TensorBlock.h b/contrib/Eigen/src/Tensor/TensorBlock.h
new file mode 100644
index 0000000..66a4c7d
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorBlock.h
@@ -0,0 +1,1864 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_BLOCK_H
+#define EIGEN_TENSOR_TENSOR_BLOCK_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+// -------------------------------------------------------------------------- //
+// Forward declarations for templates defined below.
+template <typename Scalar, typename IndexType, int NumDims, int Layout>
+class TensorBlockIO;
+
+// -------------------------------------------------------------------------- //
+// Helper function to compute strides for densely stored buffer of given
+// dimensions.
+
+// TODO(ezhulenev): We compute strides many times in different evaluators, use
+// this function instead everywhere.
+template <int Layout, typename IndexType, int NumDims>
+EIGEN_ALWAYS_INLINE std::enable_if_t<NumDims == 0, DSizes<IndexType, NumDims> > strides_impl(
+    const DSizes<IndexType, NumDims>& /*dimensions*/) {
+  DSizes<IndexType, NumDims> strides;
+  return strides;
+}
+
+template <int Layout, typename IndexType, int NumDims>
+EIGEN_ALWAYS_INLINE std::enable_if_t<(NumDims > 0), DSizes<IndexType, NumDims> > strides_impl(
+    const DSizes<IndexType, NumDims>& dimensions) {
+  DSizes<IndexType, NumDims> strides;
+  // TODO(ezhulenev): Benchmark whether template-unrolling this loop is beneficial.
+  EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+    strides[0] = 1;
+    for (int i = 1; i < NumDims; ++i) {
+      strides[i] = strides[i - 1] * dimensions[i - 1];
+    }
+  } else {
+    strides[NumDims - 1] = 1;
+    for (int i = NumDims - 2; i >= 0; --i) {
+      strides[i] = strides[i + 1] * dimensions[i + 1];
+    }
+  }
+
+  return strides;
+}
+
+template <int Layout, typename IndexType, int NumDims>
+EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> strides(const DSizes<IndexType, NumDims>& dimensions) {
+  return strides_impl<Layout>(dimensions);
+}
+
+template <int Layout, typename IndexType, size_t NumDims>
+EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> strides(const Eigen::array<IndexType, NumDims>& dimensions) {
+  return strides<Layout>(DSizes<IndexType, NumDims>(dimensions));
+}
+
+template <int Layout, std::ptrdiff_t... Indices>
+EIGEN_STRONG_INLINE DSizes<std::ptrdiff_t, sizeof...(Indices)> strides(const Sizes<Indices...>& sizes) {
+  return strides<Layout>(DSizes<std::ptrdiff_t, sizeof...(Indices)>(sizes));
+}
+
+// -------------------------------------------------------------------------- //
+
+// Tensor block shape type defines what are the shape preference for the blocks
+// extracted from the larger tensor.
+//
+// Example: blocks of 100 elements from the large 100x100 tensor:
+// - tensor: 100x100
+// - target_block_size: 100
+//
+// TensorBlockShapeType:
+//  - kUniformAllDims: 100 blocks of size 10x10
+//  - kSkewedInnerDims: 100 blocks of size 100x1 (or 1x100 depending on a column
+//                      or row major layout)
+enum class TensorBlockShapeType { kUniformAllDims, kSkewedInnerDims };
+
+struct TensorBlockResourceRequirements {
+  TensorBlockShapeType shape_type;  // target block shape
+  size_t size;                      // target block size
+  TensorOpCost cost_per_coeff;      // cost of computing a single block element
+
+#ifdef EIGEN_HIPCC
+  // For HIPCC, we need to explicitly declare as a "device fun", the constructor
+  // which is implicitly invoked in the "merge" / "any" routines. else HIPCC
+  // errors out complaining about the lack of a matching constructor
+  EIGEN_DEVICE_FUNC TensorBlockResourceRequirements(TensorBlockShapeType shape_type_, size_t size_, TensorOpCost cost_)
+      : shape_type(shape_type_), size(size_), cost_per_coeff(cost_) {}
+#endif
+
+  template <typename Scalar>
+  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements withShapeAndSize(TensorBlockShapeType shape_type,
+                                                                            size_t size_in_bytes, TensorOpCost cost) {
+    const size_t size = numext::maxi(size_t(1), size_in_bytes / sizeof(Scalar));
+    return {shape_type, size, cost};
+  }
+
+  template <typename Scalar>
+  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements withShapeAndSize(TensorBlockShapeType shape_type,
+                                                                            size_t size_in_bytes) {
+    // This default cost per coefficient is valid for most materialized tensor
+    // block evaluation implementations, because they typically just read
+    // coefficients from the underlying tensor storage, and write to the tensor
+    // block buffer (scratch or destination memory, reads and writes have linear
+    // access pattern). We ignore the fixed cost of block evaluation, because in
+    // practice it should be negligible.
+    //
+    // Lazy block evaluation adds the cost of calling a functor for each
+    // coefficient.
+    //
+    // All non-trivial block evaluation implementations must provide their own
+    // cost approximation (e.g. shuffling inner dimension has a much higher cost
+    // because it reads memory randomly, although the total number of moved
+    // bytes is the same).
+    return withShapeAndSize<Scalar>(shape_type, size_in_bytes,
+                                    {/*bytes_loaded=*/sizeof(Scalar),
+                                     /*bytes_stored=*/sizeof(Scalar),
+                                     /*compute_cycles=*/0});
+  }
+
+  template <typename Scalar>
+  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements skewed(size_t size_in_bytes) {
+    return withShapeAndSize<Scalar>(TensorBlockShapeType::kSkewedInnerDims, size_in_bytes);
+  }
+
+  template <typename Scalar>
+  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements uniform(size_t size_in_bytes) {
+    return withShapeAndSize<Scalar>(TensorBlockShapeType::kUniformAllDims, size_in_bytes);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorBlockResourceRequirements
+  merge(const TensorBlockResourceRequirements& lhs, const TensorBlockResourceRequirements& rhs) {
+    return {merge(lhs.shape_type, rhs.shape_type),           // shape_type
+            merge(lhs.size, rhs.size),                       // size
+            merge(lhs.cost_per_coeff, rhs.cost_per_coeff)};  // cost_per_coeff
+  }
+
+  EIGEN_DEVICE_FUNC TensorBlockResourceRequirements& addCostPerCoeff(TensorOpCost cost) {
+    cost_per_coeff += cost;
+    return *this;
+  }
+
+  // This is a resource requirement that should be returned from expressions
+  // that do not have any block evaluation preference (e.g. default tensor
+  // expression with raw buffer access).
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorBlockResourceRequirements any() {
+    return {TensorBlockShapeType::kUniformAllDims, 1, {0, 0, 0}};
+  }
+
+ private:
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE size_t merge(size_t lhs_size, size_t rhs_size) {
+    return numext::maxi(lhs_size, rhs_size);
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorBlockShapeType merge(TensorBlockShapeType lhs,
+                                                                          TensorBlockShapeType rhs) {
+    return (lhs == TensorBlockShapeType::kSkewedInnerDims || rhs == TensorBlockShapeType::kSkewedInnerDims)
+               ? TensorBlockShapeType::kSkewedInnerDims
+               : TensorBlockShapeType::kUniformAllDims;
+  }
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorOpCost merge(TensorOpCost lhs_cost, TensorOpCost rhs_cost) {
+    return lhs_cost + rhs_cost;
+  }
+};
+
+// -------------------------------------------------------------------------- //
+// TensorBlockDescriptor specifies a block offset within a tensor and the block
+// sizes along each of the tensor dimensions.
+
+template <int NumDims, typename IndexType = Eigen::Index>
+class TensorBlockDescriptor {
+ public:
+  typedef DSizes<IndexType, NumDims> Dimensions;
+
+  // If we evaluate a Tensor assignment, and expression on the left, already has
+  // a memory buffer, then we might do performance optimization, and evaluate
+  // the root expression directly into the final output memory. Some time it's
+  // possible to reuse it for materializing subexpressions inside an expression
+  // tree, to avoid dynamic memory allocation.
+  //
+  // The pointer type of the underlying storage is erased, because passing
+  // Scalar type through all the expression evaluation layers is way too many
+  // templates. In practice destination buffer type should always match the
+  // evaluated expression scalar type.
+  class DestinationBuffer {
+   public:
+    enum DestinationBufferKind : int {
+      // The above explicit specification of "int" as the enum basetype is
+      // needed to get around a HIPCC link error ("the field type is not
+      // amp-compatible")
+      // which is issued for class members with the enum type.
+      // TODO(rocm):
+      // remove the "int" basetype once HIPCC has been fixed to not error out
+      // in the above scenario.
+
+      // Destination buffer is not defined (`m_data` == nullptr).
+      kEmpty,
+
+      // Tensor block defined by an owning tensor block descriptor can fit
+      // contiguously into the destination buffer. In this case it's safe to
+      // materialize a tensor block in the destination buffer and build an
+      // expression over a dense view of it.
+      kContiguous,
+
+      // Destination buffer strides do not match strides of the contiguously
+      // stored block, and it's impossible to define a TensorMap over this
+      // buffer. However if we are evaluating a root of an expression tree, we
+      // still can materialize an output into this destination, because we can
+      // guarantee that no one will ever access it through block API.
+      //
+      // Strided input views are represented by TensorBlockView. Output
+      // materialization still reserves this destination for the root so that
+      // a child cannot overwrite another operand before it has been consumed.
+      kStrided
+    };
+
+    template <typename Scalar>
+    Scalar* data() const {
+      eigen_assert(m_data_type_size == sizeof(Scalar));
+      return static_cast<Scalar*>(m_data);
+    }
+
+    const Dimensions& strides() const { return m_strides; }
+    const DestinationBufferKind& kind() const { return m_kind; }
+
+   private:
+    friend class TensorBlockDescriptor<NumDims, IndexType>;
+
+    DestinationBuffer() = default;
+
+    template <typename Scalar>
+    DestinationBuffer(Scalar* data, const Dimensions& strides, DestinationBufferKind kind)
+        : m_data(static_cast<void*>(data)), m_data_type_size(sizeof(Scalar)), m_strides(strides), m_kind(kind) {}
+
+    template <int Layout, typename Scalar>
+    static DestinationBuffer make(const TensorBlockDescriptor& desc, Scalar* data, const Dimensions& strides) {
+      return DestinationBuffer(data, strides, kind<Layout>(desc, strides));
+    }
+
+    template <int Layout>
+    static DestinationBufferKind kind(const TensorBlockDescriptor& desc, const Dimensions& strides) {
+      const Dimensions& desc_dims = desc.dimensions();
+      const Dimensions& desc_strides = internal::strides<Layout>(desc_dims);
+      for (int i = 0; i < NumDims; ++i) {
+        if (desc_dims[i] == 1) continue;
+        if (desc_strides[i] != strides[i]) return kStrided;
+      }
+      return kContiguous;
+    }
+
+    // Storage pointer is type erased, to reduce template bloat, but we still
+    // keep the size of the underlying element type for error checking.
+    void* m_data = nullptr;
+    size_t m_data_type_size = 0;
+
+    // Destination buffer dimensions always match the dimensions of a tensor
+    // block descriptor it belongs to, however strides might be different.
+    Dimensions m_strides;
+
+    DestinationBufferKind m_kind = kEmpty;
+  };
+
+  TensorBlockDescriptor(const IndexType offset, const Dimensions& dimensions, const DestinationBuffer& destination)
+      : m_offset(offset), m_dimensions(dimensions), m_destination(destination) {}
+
+  TensorBlockDescriptor(const IndexType offset, const Dimensions& dimensions)
+      : m_offset(offset), m_dimensions(dimensions), m_destination(DestinationBuffer()) {}
+
+  IndexType offset() const { return m_offset; }
+  const Dimensions& dimensions() const { return m_dimensions; }
+  IndexType dimension(int index) const { return m_dimensions[index]; }
+  IndexType size() const { return array_prod<IndexType>(m_dimensions); }
+
+  const DestinationBuffer& destination() const { return m_destination; }
+
+  template <int Layout, typename Scalar>
+  void AddDestinationBuffer(Scalar* dst_base, const Dimensions& dst_strides) {
+    eigen_assert(dst_base != nullptr);
+    m_destination = DestinationBuffer::template make<Layout>(*this, dst_base, dst_strides);
+  }
+
+  template <int Layout, typename Scalar, typename DstStridesIndexType>
+  void AddDestinationBuffer(Scalar* dst_base, const DSizes<DstStridesIndexType, NumDims>& dst_strides) {
+    // DSizes constructor will do index type promotion if it's safe.
+    AddDestinationBuffer<Layout>(dst_base, Dimensions(dst_strides));
+  }
+
+  TensorBlockDescriptor& DropDestinationBuffer() {
+    m_destination.m_data = nullptr;
+    m_destination.m_kind = DestinationBuffer::kEmpty;
+    return *this;
+  }
+
+  bool HasDestinationBuffer() const { return m_destination.kind() != DestinationBuffer::kEmpty; }
+
+  // Returns a copy of `*this` with updated offset.
+  TensorBlockDescriptor WithOffset(IndexType offset) const {
+    return TensorBlockDescriptor(offset, m_dimensions, m_destination);
+  }
+
+ private:
+  // Offset and dimensions are immutable after construction. Block descriptor
+  // can only be mutated by adding or dropping destination.
+  const IndexType m_offset;
+  const Dimensions m_dimensions;
+  DestinationBuffer m_destination;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorBlockMapper is responsible for iterating over the blocks of a tensor.
+
+template <int NumDims, int Layout, typename IndexType = Eigen::Index>
+class TensorBlockMapper {
+  typedef TensorBlockDescriptor<NumDims, IndexType> BlockDescriptor;
+
+ public:
+  typedef DSizes<IndexType, NumDims> Dimensions;
+
+  TensorBlockMapper() = default;
+  TensorBlockMapper(const DSizes<IndexType, NumDims>& dimensions, const TensorBlockResourceRequirements& requirements)
+      : m_tensor_dimensions(dimensions), m_requirements(requirements) {
+    // Compute block dimensions and the total number of blocks.
+    InitializeBlockDimensions();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType blockCount() const { return m_total_block_count; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType blockTotalSize() const { return m_block_dimensions.TotalSize(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const DSizes<IndexType, NumDims>& blockDimensions() const {
+    return m_block_dimensions;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockDescriptor blockDescriptor(IndexType block_index) const {
+    static constexpr bool isColMajor = Layout == static_cast<int>(ColMajor);
+
+    IndexType offset = 0;
+    DSizes<IndexType, NumDims> dimensions;
+
+    EIGEN_IF_CONSTEXPR (NumDims == 0) return BlockDescriptor(offset, dimensions);
+
+    // Iterate outer -> inner dimensions.
+    for (int i = NumDims - 1; i >= 0; --i) {
+      const int dim = isColMajor ? i : NumDims - i - 1;
+
+      const IndexType idx = block_index / m_block_strides[dim];
+      block_index -= idx * m_block_strides[dim];
+
+      const IndexType coord = idx * m_block_dimensions[dim];
+      dimensions[dim] = numext::mini(m_tensor_dimensions[dim] - coord, m_block_dimensions[dim]);
+      offset += coord * m_tensor_strides[dim];
+    }
+
+    return {offset, dimensions};
+  }
+
+ private:
+  void InitializeBlockDimensions() {
+    // Requested block shape and size.
+    const TensorBlockShapeType shape_type = m_requirements.shape_type;
+    IndexType target_block_size = numext::maxi<IndexType>(1, static_cast<IndexType>(m_requirements.size));
+
+    IndexType tensor_size = m_tensor_dimensions.TotalSize();
+
+    // Corner case: one of the dimensions is zero. Logic below is too complex
+    // to handle this case on a general basis, just use unit block size.
+    // Note: we must not yield blocks with zero dimensions (recipe for
+    // overflows/underflows, divisions by zero and NaNs later).
+    if (tensor_size == 0) {
+      for (int i = 0; i < NumDims; ++i) {
+        m_block_dimensions[i] = 1;
+      }
+      m_total_block_count = 0;
+      return;
+    }
+
+    // If tensor fits into a target block size, evaluate it as a single block.
+    if (tensor_size <= target_block_size) {
+      m_block_dimensions = m_tensor_dimensions;
+      m_total_block_count = 1;
+      // The only valid block index is `0`, and in this case we do not need
+      // to compute real strides for tensor or blocks (see blockDescriptor).
+      for (int i = 0; i < NumDims; ++i) {
+        m_tensor_strides[i] = 0;
+        m_block_strides[i] = 1;
+      }
+      return;
+    }
+
+    static constexpr bool isColMajor = Layout == static_cast<int>(ColMajor);
+
+    // Block shape skewed towards inner dimension.
+    if (shape_type == TensorBlockShapeType::kSkewedInnerDims) {
+      IndexType coeff_to_allocate = target_block_size;
+
+      for (int i = 0; i < NumDims; ++i) {
+        const int dim = isColMajor ? i : NumDims - i - 1;
+        m_block_dimensions[dim] = numext::mini(coeff_to_allocate, m_tensor_dimensions[dim]);
+        coeff_to_allocate =
+            numext::div_ceil(coeff_to_allocate, numext::maxi(static_cast<IndexType>(1), m_block_dimensions[dim]));
+      }
+      eigen_assert(coeff_to_allocate == 1);
+
+    } else if (shape_type == TensorBlockShapeType::kUniformAllDims) {
+      // Tensor will not fit within 'target_block_size' budget: calculate tensor
+      // block dimension sizes based on "square" dimension size target.
+      const IndexType dim_size_target = convert_index<IndexType>(
+          numext::pow(static_cast<float>(target_block_size), 1.0f / static_cast<float>(m_block_dimensions.rank())));
+
+      for (int i = 0; i < NumDims; ++i) {
+        // TODO(andydavis): Adjust the inner most 'block_dim_size' to make it
+        // a multiple of the packet size. Note that reducing
+        // 'block_dim_size' in this manner can increase the number of
+        // blocks, and so will amplify any per-block overhead.
+        m_block_dimensions[i] = numext::mini(dim_size_target, m_tensor_dimensions[i]);
+      }
+
+      // Add any un-allocated coefficients to inner dimension(s).
+      IndexType total_size = m_block_dimensions.TotalSize();
+      for (int i = 0; i < NumDims; ++i) {
+        const int dim = isColMajor ? i : NumDims - i - 1;
+
+        if (m_block_dimensions[dim] < m_tensor_dimensions[dim]) {
+          const IndexType total_size_other_dims = total_size / m_block_dimensions[dim];
+          const IndexType alloc_avail = numext::div_ceil<IndexType>(target_block_size, total_size_other_dims);
+          if (alloc_avail == m_block_dimensions[dim]) {
+            // Insufficient excess coefficients to allocate.
+            break;
+          }
+          m_block_dimensions[dim] = numext::mini(m_tensor_dimensions[dim], alloc_avail);
+          total_size = total_size_other_dims * m_block_dimensions[dim];
+        }
+      }
+
+    } else {
+      eigen_assert(false);  // unknown block shape
+    }
+
+    eigen_assert(m_block_dimensions.TotalSize() >=
+                 numext::mini<IndexType>(target_block_size, m_tensor_dimensions.TotalSize()));
+
+    // Calculate block counts by dimension and total block count.
+    DSizes<IndexType, NumDims> block_count;
+    for (int i = 0; i < NumDims; ++i) {
+      block_count[i] = numext::div_ceil(m_tensor_dimensions[i], m_block_dimensions[i]);
+    }
+    m_total_block_count = array_prod(block_count);
+
+    // Calculate block strides (used for enumerating blocks).
+    m_tensor_strides = strides<Layout>(m_tensor_dimensions);
+    m_block_strides = strides<Layout>(block_count);
+  }
+
+  DSizes<IndexType, NumDims> m_tensor_dimensions;
+  TensorBlockResourceRequirements m_requirements;
+
+  DSizes<IndexType, NumDims> m_block_dimensions;
+  IndexType m_total_block_count;
+
+  DSizes<IndexType, NumDims> m_tensor_strides;
+  DSizes<IndexType, NumDims> m_block_strides;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorBlockScratchAllocator is responsible for allocating temporary buffers
+// for block evaluation (output or input block materialization). Given that
+// Eigen expression traversal order is deterministic, all temporary allocations
+// are happening in the same order, and usually have exactly the same size.
+// Scratch allocator keeps a trace of all dynamic allocations, and after the
+// first block evaluation is completed, we should be able to reuse all the
+// temporary buffers for the next block evaluation.
+
+template <typename Device>
+class TensorBlockScratchAllocator {
+ public:
+  explicit TensorBlockScratchAllocator(const Device& device) : m_device(device), m_allocation_index(0) {}
+
+  ~TensorBlockScratchAllocator() {
+    for (size_t i = 0; i < m_allocations.size(); ++i) {
+      m_device.deallocate(m_allocations[i].ptr);
+    }
+  }
+
+  void* allocate(size_t size) {
+    // TODO(ezhulenev): Remove when replaced with inlined vector.
+    if (m_allocations.capacity() == 0) m_allocations.reserve(8);
+
+    // Check if we already have an existing allocation at current index.
+    const int num_allocations = static_cast<int>(m_allocations.size());
+    const bool has_allocation = m_allocation_index < num_allocations;
+
+    // Allocation index can't be larger than the number of allocations.
+    eigen_assert(m_allocation_index <= num_allocations);
+
+    // If we have existing allocation, and its size is larger or equal to
+    // requested size, we do nothing.
+
+    // If current allocation can't fit requested size, we deallocate it, and
+    // replace with a larger allocation.
+    if (has_allocation && m_allocations[m_allocation_index].size < size) {
+      m_device.deallocate(m_allocations[m_allocation_index].ptr);
+      m_allocations[m_allocation_index].ptr = m_device.allocate(size);
+      m_allocations[m_allocation_index].size = size;
+    }
+
+    // Make a new allocation if we don't have an existing one.
+    if (!has_allocation) {
+      Allocation allocation;
+      allocation.ptr = m_device.allocate(size);
+      allocation.size = size;
+      m_allocations.push_back(allocation);
+    }
+
+    eigen_assert(m_allocations[m_allocation_index].ptr != nullptr);
+    eigen_assert(m_allocations[m_allocation_index].size >= size);
+
+    return m_allocations[m_allocation_index++].ptr;
+  }
+
+  void reset() { m_allocation_index = 0; }
+
+ private:
+  struct Allocation {
+    void* ptr;
+    size_t size;
+  };
+
+  const Device& m_device;
+  int m_allocation_index;
+  // TODO(ezhulenev): This should be an inlined vector.
+  std::vector<Allocation> m_allocations;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorBlockKind represents all possible block kinds, that can be produced by
+// TensorEvaluator::evalBlock function.
+enum TensorBlockKind {
+  // Tensor block that is a lazy expression that must be assigned to a
+  // destination using TensorBlockAssign.
+  kExpr,
+
+  // Tensor block that is a view into a memory buffer owned by an underlying
+  // Tensor expression (e.g. it can be a view into a Tensor buffer).
+  kView,
+
+  // Tensor block that was materialized in a scratch memory buffer, allocated
+  // with TensorBlockScratchAllocator. This block must be copied to a
+  // destination, similar to a block of `kExpr` type.
+  kMaterializedInScratch,
+
+  // Tensor block that was materialized directly into the final output memory
+  // buffer. For example if the left side of an assignment is a Tensor, we can
+  // directly materialize the block in the destination memory.
+  //
+  // If strides in the output buffer do not match tensor block strides, the
+  // Tensor expression will be invalid, and should not be used by
+  // TensorBlockAssign or for constructing another block expression.
+  kMaterializedInOutput
+};
+
+// -------------------------------------------------------------------------- //
+// TensorBlockNotImplemented should be used to define TensorBlock typedef in
+// TensorEvaluators that do not support block evaluation.
+
+class TensorBlockNotImplemented {
+ public:
+  typedef void XprType;
+};
+
+template <typename Scalar, int NumDims, int Layout, typename IndexType>
+class TensorBlockView;
+
+template <typename Scalar, int NumDims, int Layout, typename IndexType>
+struct traits<TensorBlockView<Scalar, NumDims, Layout, IndexType>>
+    : traits<Tensor<Scalar, NumDims, Layout, IndexType>> {
+  static constexpr unsigned int Flags = 0;
+};
+
+// A block's inner runs are contiguous, but successive runs can belong to different
+// rows, columns, or planes of the underlying tensor.
+template <typename Scalar_, int NumDims, int Layout, typename IndexType>
+class TensorBlockView : public TensorBase<TensorBlockView<Scalar_, NumDims, Layout, IndexType>> {
+ public:
+  using Scalar = Scalar_;
+  using Index = IndexType;
+  using Dimensions = DSizes<Index, NumDims>;
+  using Nested = TensorBlockView;
+  using StorageKind = Dense;
+  using CoeffReturnType = Scalar;
+
+  TensorBlockView(const Scalar* data, const Dimensions& dimensions)
+      : TensorBlockView(data, dimensions, internal::strides<Layout>(dimensions)) {}
+
+  TensorBlockView(const Scalar* data, const Dimensions& dimensions, const Dimensions& strides)
+      : m_data(data), m_dimensions(dimensions), m_strides(strides), m_contiguous(true) {
+    eigen_assert(NumDims == 0 || strides[Layout == ColMajor ? 0 : NumDims - 1] == 1);
+    Index stride = 1;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = Layout == ColMajor ? i : NumDims - 1 - i;
+      if (dimensions[dim] > 1 && strides[dim] != stride) m_contiguous = false;
+      stride *= dimensions[dim];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_dimensions; }
+  EIGEN_DEVICE_FUNC const Dimensions& strides() const { return m_strides; }
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_contiguous ? m_data : nullptr; }
+  EIGEN_DEVICE_FUNC const Scalar* rawData() const { return m_data; }
+
+ private:
+  const Scalar* m_data;
+  Dimensions m_dimensions;
+  Dimensions m_strides;
+  bool m_contiguous;
+};
+
+}  // namespace internal
+
+template <typename Scalar_, int NumDims, int Layout_, typename IndexType, typename Device>
+struct TensorEvaluator<const internal::TensorBlockView<Scalar_, NumDims, Layout_, IndexType>, Device> {
+  using XprType = internal::TensorBlockView<Scalar_, NumDims, Layout_, IndexType>;
+  using Scalar = Scalar_;
+  using Index = IndexType;
+  using Dimensions = DSizes<Index, NumDims>;
+  using CoeffReturnType = Scalar;
+  using PacketReturnType = typename PacketType<Scalar, Device>::type;
+  using EvaluatorPointerType = const Scalar*;
+  using TensorBlock = internal::TensorBlockNotImplemented;
+  static constexpr int Layout = Layout_;
+  static constexpr bool IsAligned = false;
+  static constexpr bool PacketAccess = internal::packet_traits<Scalar>::Vectorizable;
+  static constexpr bool BlockAccess = false;
+  static constexpr bool PreferBlockAccess = false;
+  static constexpr bool CoordAccess = false;
+  static constexpr bool RawAccess = false;
+
+  TensorEvaluator(const XprType& expression, const Device&)
+      : m_expression(expression), m_output_strides(internal::strides<Layout>(expression.dimensions())) {
+    if (!expression.data()) {
+      for (int i = 0; i < NumDims; ++i) {
+        m_divisors[i] = internal::TensorIntDivisor<Index>(numext::maxi(Index(1), m_output_strides[i]));
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_expression.dimensions(); }
+  EIGEN_DEVICE_FUNC bool evalSubExprsIfNeeded(EvaluatorPointerType) { return true; }
+  EIGEN_DEVICE_FUNC void cleanup() {}
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_expression.data(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
+    if (m_expression.data()) return index;
+    Index offset = 0;
+    for (int i = NumDims - 1; i > 0; --i) {
+      const int dim = Layout == ColMajor ? i : NumDims - 1 - i;
+      const Index coordinate = index / m_divisors[dim];
+      offset += coordinate * m_expression.strides()[dim];
+      index -= coordinate * m_output_strides[dim];
+    }
+    return offset + index;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    return m_expression.rawData()[srcCoeff(index)];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* coeffAddress(Index index) const {
+    return m_expression.rawData() + srcCoeff(index);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    constexpr int PacketSize = PacketType<Scalar, Device>::size;
+    const Index first = srcCoeff(index);
+    if (m_expression.data() || srcCoeff(index + PacketSize - 1) == first + PacketSize - 1) {
+      return internal::ploadu<PacketReturnType>(m_expression.rawData() + first);
+    }
+    EIGEN_ALIGN_MAX Scalar values[PacketSize];
+    for (int i = 0; i < PacketSize; ++i) values[i] = coeff(index + i);
+    return internal::ploadu<PacketReturnType>(values);
+  }
+
+  EIGEN_DEVICE_FUNC TensorOpCost costPerCoeff(bool vectorized) const {
+    return TensorOpCost(sizeof(Scalar), 0, m_expression.data() ? 0 : NumDims, vectorized,
+                        PacketType<Scalar, Device>::size);
+  }
+
+ private:
+  XprType m_expression;
+  Dimensions m_output_strides;
+  array<internal::TensorIntDivisor<Index>, NumDims> m_divisors;
+};
+
+template <typename Scalar, int Layout, typename Index, typename Device>
+struct TensorEvaluator<const internal::TensorBlockView<Scalar, 1, Layout, Index>, Device>
+    : TensorEvaluator<const TensorMap<const Tensor<Scalar, 1, Layout, Index>>, Device> {
+  using XprType = internal::TensorBlockView<Scalar, 1, Layout, Index>;
+  using MapType = TensorMap<const Tensor<Scalar, 1, Layout, Index>>;
+  using Base = TensorEvaluator<const MapType, Device>;
+  TensorEvaluator(const XprType& expression, const Device& device)
+      : Base(MapType(expression.rawData(), expression.dimensions()), device) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* coeffAddress(Index index) const { return this->data() + index; }
+};
+
+namespace internal {
+
+// -------------------------------------------------------------------------- //
+// XprScalar extracts Scalar type from the Eigen expressions (if expression type
+// is not void). It's required to be able to define lazy block expression for
+// argument types, that do not support block evaluation.
+
+template <typename XprType>
+struct XprScalar {
+  typedef typename XprType::Scalar type;
+};
+template <>
+struct XprScalar<void> {
+  typedef void type;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorMaterializedBlock is a fully evaluated block of the original tensor,
+// and XprType is a view over its data, allowing non-unit outer strides. It is
+// used to materialize blocks of tensor expressions, that can't be efficiently
+// represented as lazy Tensor expressions with fast coeff/packet operations,
+// e.g. we materialize all broadcasts into evaluated blocks.
+//
+// TensorMaterializedBlock does not own its memory buffer, it's either a memory
+// buffer that backs the original expression (e.g. block is just a view into a
+// Tensor), or a memory buffer allocated with scratch allocator, and in this
+// case the scratch allocator will deallocate it at the end of block based
+// expression execution.
+//
+// If the block was evaluated directly into the output buffer, and strides in
+// the output buffer do not match block strides, the dense block expression will
+// be invalid, and should never be used in block assignment or any other tensor
+// expression.
+
+template <typename Scalar, int NumDims, int Layout, typename IndexType = Eigen::Index>
+class TensorMaterializedBlock {
+ public:
+  typedef DSizes<IndexType, NumDims> Dimensions;
+  using XprType = TensorBlockView<Scalar, NumDims, Layout, IndexType>;
+
+  TensorMaterializedBlock(TensorBlockKind kind, const Scalar* data, const Dimensions& dimensions,
+                          bool valid_expr = true)
+      : m_kind(kind), m_data(data), m_dimensions(dimensions), m_expr(m_data, m_dimensions), m_valid_expr(valid_expr) {
+    eigen_assert(m_kind == internal::TensorBlockKind::kView ||
+                 m_kind == internal::TensorBlockKind::kMaterializedInScratch ||
+                 m_kind == internal::TensorBlockKind::kMaterializedInOutput);
+  }
+
+  TensorBlockKind kind() const { return m_kind; }
+  const XprType& expr() const {
+    eigen_assert(m_valid_expr);
+    return m_expr;
+  }
+  // Consumers of data() require a dense buffer; strided views must use expr().
+  const Scalar* data() const { return m_valid_expr ? m_expr.data() : m_data; }
+  void cleanup() {}
+
+  typedef internal::TensorBlockDescriptor<NumDims, IndexType> TensorBlockDesc;
+
+  // TensorMaterializedBlock can be backed by different types of storage:
+  //
+  //   (1) Contiguous block of memory allocated with scratch allocator.
+  //   (2) Contiguous block of memory reused from tensor block descriptor
+  //       destination buffer.
+  //   (3) Strided block of memory reused from tensor block descriptor
+  //       destination buffer.
+  //
+  class Storage {
+   public:
+    Scalar* data() const { return m_data; }
+    const Dimensions& dimensions() const { return m_dimensions; }
+    const Dimensions& strides() const { return m_strides; }
+
+    TensorMaterializedBlock AsTensorMaterializedBlock() const {
+      return TensorMaterializedBlock(m_materialized_in_output ? internal::TensorBlockKind::kMaterializedInOutput
+                                                              : internal::TensorBlockKind::kMaterializedInScratch,
+                                     m_data, m_dimensions, !m_strided_storage);
+    }
+
+   private:
+    friend class TensorMaterializedBlock<Scalar, NumDims, Layout, IndexType>;
+
+    Storage(Scalar* data, const Dimensions& dimensions, const Dimensions& strides, bool materialized_in_output,
+            bool strided_storage)
+        : m_data(data),
+          m_dimensions(dimensions),
+          m_strides(strides),
+          m_materialized_in_output(materialized_in_output),
+          m_strided_storage(strided_storage) {}
+
+    Scalar* m_data;
+    Dimensions m_dimensions;
+    Dimensions m_strides;
+    bool m_materialized_in_output;
+    bool m_strided_storage;
+  };
+
+  // Creates a storage for materialized block either from the block descriptor
+  // destination buffer, or allocates a new buffer with scratch allocator.
+  template <typename TensorBlockScratch>
+  EIGEN_STRONG_INLINE static Storage prepareStorage(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                    bool allow_strided_storage = false) {
+    // Try to reuse destination as an output block buffer.
+    typedef typename TensorBlockDesc::DestinationBuffer DestinationBuffer;
+
+    if (desc.destination().kind() == DestinationBuffer::kContiguous) {
+      Scalar* buffer = desc.destination().template data<Scalar>();
+      desc.DropDestinationBuffer();
+      return Storage(buffer, desc.dimensions(), internal::strides<Layout>(desc.dimensions()),
+                     /*materialized_in_output=*/true,
+                     /*strided_storage=*/false);
+
+    } else if (desc.destination().kind() == DestinationBuffer::kStrided && allow_strided_storage) {
+      Scalar* buffer = desc.destination().template data<Scalar>();
+      desc.DropDestinationBuffer();
+      return Storage(buffer, desc.dimensions(), desc.destination().strides(),
+                     /*materialized_in_output=*/true, /*strided_storage=*/true);
+
+    } else {
+      void* mem = scratch.allocate(desc.size() * sizeof(Scalar));
+      return Storage(static_cast<Scalar*>(mem), desc.dimensions(), internal::strides<Layout>(desc.dimensions()),
+                     /*materialized_in_output=*/false,
+                     /*strided_storage=*/false);
+    }
+  }
+
+  // Creates a materialized block for the given descriptor from a memory buffer.
+  template <typename DataDimensions, typename TensorBlockScratch>
+  EIGEN_STRONG_INLINE static TensorMaterializedBlock materialize(const Scalar* data, const DataDimensions& data_dims,
+                                                                 TensorBlockDesc& desc,
+                                                                 TensorBlockScratch& /*scratch*/) {
+    eigen_assert(array_size<DataDimensions>::value == desc.dimensions().size());
+
+    TensorMaterializedBlock block(internal::TensorBlockKind::kView, data + desc.offset(), desc.dimensions());
+    block.m_expr = XprType(data + desc.offset(), desc.dimensions(), internal::strides<Layout>(Dimensions(data_dims)));
+    return block;
+  }
+
+ private:
+  TensorBlockKind m_kind;
+  const Scalar* m_data;
+  Dimensions m_dimensions;
+  XprType m_expr;
+  bool m_valid_expr;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorCwiseUnaryBlock is a lazy tensor expression block that applies UnaryOp
+// functor to the blocks produced by the underlying Tensor expression.
+
+template <typename UnaryOp, typename ArgTensorBlock>
+class TensorCwiseUnaryBlock {
+  static constexpr bool NoArgBlockAccess = std::is_void<typename ArgTensorBlock::XprType>::value;
+
+ public:
+  typedef std::conditional_t<NoArgBlockAccess, void,
+                             TensorCwiseUnaryOp<UnaryOp, const typename ArgTensorBlock::XprType> >
+      XprType;
+
+  typedef typename XprScalar<XprType>::type Scalar;
+
+  TensorCwiseUnaryBlock(const ArgTensorBlock& arg_block, const UnaryOp& functor)
+      : m_arg_block(arg_block), m_functor(functor) {}
+
+  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
+
+  XprType expr() const { return XprType(m_arg_block.expr(), m_functor); }
+  const Scalar* data() const { return nullptr; }
+  void cleanup() { m_arg_block.cleanup(); }
+
+ private:
+  ArgTensorBlock m_arg_block;
+  UnaryOp m_functor;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorCwiseBinaryBlock is a lazy tensor expression block that applies BinaryOp
+// functor to the blocks produced by the underlying Tensor expression.
+
+template <typename BinaryOp, typename LhsTensorBlock, typename RhsTensorBlock>
+class TensorCwiseBinaryBlock {
+  static constexpr bool NoArgBlockAccess =
+      std::is_void<typename LhsTensorBlock::XprType>::value || std::is_void<typename RhsTensorBlock::XprType>::value;
+
+ public:
+  typedef std::conditional_t<
+      NoArgBlockAccess, void,
+      TensorCwiseBinaryOp<BinaryOp, const typename LhsTensorBlock::XprType, const typename RhsTensorBlock::XprType> >
+      XprType;
+
+  typedef typename XprScalar<XprType>::type Scalar;
+
+  TensorCwiseBinaryBlock(const LhsTensorBlock& left_block, const RhsTensorBlock& right_block, const BinaryOp& functor)
+      : m_left_block(left_block), m_right_block(right_block), m_functor(functor) {}
+
+  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
+
+  XprType expr() const { return XprType(m_left_block.expr(), m_right_block.expr(), m_functor); }
+
+  const Scalar* data() const { return nullptr; }
+
+  void cleanup() {
+    m_left_block.cleanup();
+    m_right_block.cleanup();
+  }
+
+ private:
+  LhsTensorBlock m_left_block;
+  RhsTensorBlock m_right_block;
+  BinaryOp m_functor;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorUnaryExprBlock is a lazy tensor expression block that can construct
+// an arbitrary tensor expression from a block of the underlying type (this is a
+// generalization of the TensorCwiseUnaryBlock for arbitrary expressions).
+
+template <typename BlockFactory, typename ArgTensorBlock>
+class TensorUnaryExprBlock {
+  typedef typename ArgTensorBlock::XprType ArgXprType;
+  static constexpr bool NoArgBlockAccess = std::is_void<ArgXprType>::value;
+
+ public:
+  typedef std::conditional_t<NoArgBlockAccess, void, typename BlockFactory::template XprType<ArgXprType>::type> XprType;
+
+  typedef typename XprScalar<XprType>::type Scalar;
+
+  TensorUnaryExprBlock(const ArgTensorBlock& arg_block, const BlockFactory& factory)
+      : m_arg_block(arg_block), m_factory(factory) {}
+
+  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
+  XprType expr() const { return m_factory.expr(m_arg_block.expr()); }
+  const Scalar* data() const { return nullptr; }
+  void cleanup() { m_arg_block.cleanup(); }
+
+ private:
+  ArgTensorBlock m_arg_block;
+  BlockFactory m_factory;
+};
+
+// -------------------------------------------------------------------------- //
+// TensorTernaryExprBlock is a lazy tensor expression block that can construct
+// an arbitrary tensor expression from three blocks of the underlying type.
+
+template <typename BlockFactory, typename Arg1TensorBlock, typename Arg2TensorBlock, typename Arg3TensorBlock>
+class TensorTernaryExprBlock {
+  typedef typename Arg1TensorBlock::XprType Arg1XprType;
+  typedef typename Arg2TensorBlock::XprType Arg2XprType;
+  typedef typename Arg3TensorBlock::XprType Arg3XprType;
+
+  static constexpr bool NoArgBlockAccess =
+      std::is_void<Arg1XprType>::value || std::is_void<Arg2XprType>::value || std::is_void<Arg3XprType>::value;
+
+ public:
+  typedef std::conditional_t<NoArgBlockAccess, void,
+                             typename BlockFactory::template XprType<Arg1XprType, Arg2XprType, Arg3XprType>::type>
+      XprType;
+
+  typedef typename XprScalar<XprType>::type Scalar;
+
+  TensorTernaryExprBlock(const Arg1TensorBlock& arg1_block, const Arg2TensorBlock& arg2_block,
+                         const Arg3TensorBlock& arg3_block, const BlockFactory& factory)
+      : m_arg1_block(arg1_block), m_arg2_block(arg2_block), m_arg3_block(arg3_block), m_factory(factory) {}
+
+  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
+  XprType expr() const { return m_factory.expr(m_arg1_block.expr(), m_arg2_block.expr(), m_arg3_block.expr()); }
+  const Scalar* data() const { return nullptr; }
+  void cleanup() {
+    m_arg1_block.cleanup();
+    m_arg2_block.cleanup();
+    m_arg3_block.cleanup();
+  }
+
+ private:
+  Arg1TensorBlock m_arg1_block;
+  Arg2TensorBlock m_arg2_block;
+  Arg3TensorBlock m_arg3_block;
+  BlockFactory m_factory;
+};
+
+// -------------------------------------------------------------------------- //
+// StridedLinearBufferCopy provides a method to copy data between two linear
+// buffers with different strides, with optimized paths for scatter/gather.
+
+template <typename Scalar, typename IndexType>
+class StridedLinearBufferCopy {
+  typedef typename packet_traits<Scalar>::type Packet;
+  typedef typename unpacket_traits<Packet>::half HalfPacket;
+  enum {
+    Vectorizable = packet_traits<Scalar>::Vectorizable,
+    PacketSize = packet_traits<Scalar>::size,
+    HalfPacketSize = unpacket_traits<HalfPacket>::size,
+    HasHalfPacket = static_cast<int>(HalfPacketSize) < static_cast<int>(PacketSize)
+  };
+
+ public:
+  // Specifying linear copy kind statically gives ~30% speedup for small sizes.
+  enum class Kind {
+    Linear = 0,        // src_stride == 1 && dst_stride == 1
+    Scatter = 1,       // src_stride == 1 && dst_stride != 1 && dst_stride != -1
+    FillLinear = 2,    // src_stride == 0 && dst_stride == 1
+    FillScatter = 3,   // src_stride == 0 && dst_stride != 1
+    Gather = 4,        // dst_stride == 1 && src_stride != -1
+    Random = 5,        // everything else
+    ReverseStore = 6,  // src_stride == 1 && dst_stride == -1
+    ReverseLoad = 7,   // src_stride == -1 && dst_stride == 1
+    ReverseBoth = 8    // src_stride == -1 && dst_stride == -1
+  };
+
+  struct Dst {
+    Dst(IndexType o, IndexType s, Scalar* d) : offset(o), stride(s), data(d) {}
+
+    IndexType offset;
+    IndexType stride;
+    Scalar* data;
+  };
+
+  struct Src {
+    Src(IndexType o, IndexType s, const Scalar* d) : offset(o), stride(s), data(d) {}
+
+    IndexType offset;
+    IndexType stride;
+    const Scalar* data;
+  };
+
+  template <typename StridedLinearBufferCopy::Kind kind>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Dst& dst, const Src& src, const size_t count) {
+    Run<kind>(count, dst.offset, dst.stride, dst.data, src.offset, src.stride, src.data);
+  }
+
+ private:
+  template <typename StridedLinearBufferCopy::Kind kind>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const IndexType count, const IndexType dst_offset,
+                                                        const IndexType dst_stride, Scalar* EIGEN_RESTRICT dst_data,
+                                                        const IndexType src_offset, const IndexType src_stride,
+                                                        const Scalar* EIGEN_RESTRICT src_data) {
+    const Scalar* src = &src_data[src_offset];
+    Scalar* dst = &dst_data[dst_offset];
+
+    EIGEN_IF_CONSTEXPR (!Vectorizable) {
+      for (Index i = 0; i < count; ++i) {
+        dst[i * dst_stride] = src[i * src_stride];
+      }
+      return;
+    }
+
+    const IndexType vectorized_size = PacketSize * (count / PacketSize);
+    IndexType i = 0;
+
+    EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::Linear ||
+                        kind == StridedLinearBufferCopy::Kind::ReverseBoth) {
+      // ******************************************************************** //
+      // Linear copy from `src` to `dst`. `ReverseBoth` walks both runs
+      // backwards, which leaves the elements contiguous and in the same order
+      // in both buffers, so it is this same copy once each pointer is moved to
+      // the low end of its run. No evaluator produces a reversed run on both
+      // sides today; the kind exists so that such a run does not fall back to
+      // `Random`.
+      constexpr IndexType run_stride = kind == StridedLinearBufferCopy::Kind::ReverseBoth ? -1 : 1;
+      eigen_assert(src_stride == run_stride && dst_stride == run_stride);
+      const IndexType run_offset = run_stride == 1 ? 0 : count - 1;
+      const Scalar* run_src = src - run_offset;
+      Scalar* run_dst = dst - run_offset;
+      const IndexType unrolled_size = (4 * PacketSize) * (count / (4 * PacketSize));
+      for (; i < unrolled_size; i += 4 * PacketSize) {
+        for (int j = 0; j < 4; ++j) {
+          Packet p = ploadu<Packet>(run_src + i + j * PacketSize);
+          pstoreu<Scalar, Packet>(run_dst + i + j * PacketSize, p);
+        }
+      }
+      for (; i < vectorized_size; i += PacketSize) {
+        Packet p = ploadu<Packet>(run_src + i);
+        pstoreu<Scalar, Packet>(run_dst + i, p);
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket p = ploadu<HalfPacket>(run_src + i);
+          pstoreu<Scalar, HalfPacket>(run_dst + i, p);
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        run_dst[i] = run_src[i];
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::Scatter) {
+      // Scatter from `src` to `dst`.
+      eigen_assert(src_stride == 1 && dst_stride != 1);
+      for (; i < vectorized_size; i += PacketSize) {
+        Packet p = ploadu<Packet>(src + i);
+        pscatter<Scalar, Packet>(dst + i * dst_stride, p, dst_stride);
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket p = ploadu<HalfPacket>(src + i);
+          pscatter<Scalar, HalfPacket>(dst + i * dst_stride, p, dst_stride);
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        dst[i * dst_stride] = src[i];
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::FillLinear) {
+      // Fill `dst` with value at `*src`.
+      eigen_assert(src_stride == 0 && dst_stride == 1);
+
+      const IndexType unrolled_size = (4 * PacketSize) * (count / (4 * PacketSize));
+      Scalar s = *src;
+      Packet p = pset1<Packet>(s);
+      for (; i < unrolled_size; i += 4 * PacketSize) {
+        for (int j = 0; j < 4; ++j) {
+          pstoreu<Scalar, Packet>(dst + i + j * PacketSize, p);
+        }
+      }
+      for (; i < vectorized_size; i += PacketSize) {
+        pstoreu<Scalar, Packet>(dst + i, p);
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket hp = pset1<HalfPacket>(s);
+          pstoreu<Scalar, HalfPacket>(dst + i, hp);
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        dst[i] = s;
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::FillScatter) {
+      // Scatter `*src` into `dst`.
+      eigen_assert(src_stride == 0 && dst_stride != 1);
+      Scalar s = *src;
+      Packet p = pset1<Packet>(s);
+      for (; i < vectorized_size; i += PacketSize) {
+        pscatter<Scalar, Packet>(dst + i * dst_stride, p, dst_stride);
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket hp = pset1<HalfPacket>(s);
+          pscatter<Scalar, HalfPacket>(dst + i * dst_stride, hp, dst_stride);
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        dst[i * dst_stride] = s;
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::Gather) {
+      // Gather from `src` into `dst`.
+      eigen_assert(dst_stride == 1);
+      for (; i < vectorized_size; i += PacketSize) {
+        Packet p = pgather<Scalar, Packet>(src + i * src_stride, src_stride);
+        pstoreu<Scalar, Packet>(dst + i, p);
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket p = pgather<Scalar, HalfPacket>(src + i * src_stride, src_stride);
+          pstoreu<Scalar, HalfPacket>(dst + i, p);
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        dst[i] = src[i * src_stride];
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::ReverseStore) {
+      // ******************************************************************** //
+      // Contiguous read, reversed write: `dst[-i] = src[i]`. The destination
+      // run covers [dst - count + 1, dst], so a packet is one contiguous load,
+      // one `preverse` and one contiguous store -- instead of the `pscatter`
+      // that a stride of -1 would otherwise fall into.
+      eigen_assert(src_stride == 1 && dst_stride == -1);
+      for (; i < vectorized_size; i += PacketSize) {
+        Packet p = ploadu<Packet>(src + i);
+        pstoreu<Scalar, Packet>(dst - i - (PacketSize - 1), preverse(p));
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket p = ploadu<HalfPacket>(src + i);
+          pstoreu<Scalar, HalfPacket>(dst - i - (HalfPacketSize - 1), preverse(p));
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        dst[-i] = src[i];
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::ReverseLoad) {
+      // Reversed read, contiguous write: `dst[i] = src[-i]`.
+      eigen_assert(src_stride == -1 && dst_stride == 1);
+      for (; i < vectorized_size; i += PacketSize) {
+        Packet p = ploadu<Packet>(src - i - (PacketSize - 1));
+        pstoreu<Scalar, Packet>(dst + i, preverse(p));
+      }
+      EIGEN_IF_CONSTEXPR (HasHalfPacket) {
+        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
+        if (i < vectorized_half_size) {
+          HalfPacket p = ploadu<HalfPacket>(src - i - (HalfPacketSize - 1));
+          pstoreu<Scalar, HalfPacket>(dst + i, preverse(p));
+          i += HalfPacketSize;
+        }
+      }
+      for (; i < count; ++i) {
+        dst[i] = src[-i];
+      }
+      // ******************************************************************** //
+    } else EIGEN_IF_CONSTEXPR (kind == StridedLinearBufferCopy::Kind::Random) {
+      // Random.
+      for (; i < count; ++i) {
+        dst[i * dst_stride] = src[i * src_stride];
+      }
+    } else {
+      eigen_assert(false);
+    }
+  }
+};
+
+// -------------------------------------------------------------------------- //
+// TensorBlockIO copies data from `src` tensor block, to the `dst` tensor block.
+// It's possible to specify src->dst dimension mapping for the copy operation.
+// Dimensions of `dst` specify how many elements have to be copied, for the
+// `src` we need to know only stride to navigate through source memory buffer.
+//
+// Strides may be non-unit (strided/dilated views), negative (reversed views),
+// or, on the `src` side only, zero (the broadcasting trick). Inner dimensions
+// are fused into one copy only while the elements keep forming a single
+// arithmetic progression at the inner stride on both sides.
+
+template <typename Scalar, typename IndexType, int NumDims, int Layout>
+class TensorBlockIO {
+  static constexpr bool IsColMajor = Layout == ColMajor;
+
+  typedef StridedLinearBufferCopy<Scalar, IndexType> LinCopy;
+
+ public:
+  typedef DSizes<IndexType, NumDims> Dimensions;
+  typedef DSizes<int, NumDims> DimensionsMap;
+
+  struct Dst {
+    Dst(const Dimensions& dst_dims, const Dimensions& dst_strides, Scalar* dst, IndexType dst_offset = 0)
+        : dims(dst_dims), strides(dst_strides), data(dst), offset(dst_offset) {}
+
+    Dimensions dims;
+    Dimensions strides;
+    Scalar* data;
+    IndexType offset;
+  };
+
+  struct Src {
+    Src(const Dimensions& src_strides, const Scalar* src, IndexType src_offset = 0)
+        : strides(src_strides), data(src), offset(src_offset) {}
+
+    Dimensions strides;
+    const Scalar* data;
+    IndexType offset;
+  };
+
+  // Copies data to `dst` from `src`, using provided dimensions mapping:
+  //
+  //   src_dimension_index = dst_to_src_dim_map[dst_dimension_index]
+  //
+  // Returns the number of copied elements.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType Copy(const Dst& dst, const Src& src,
+                                                              const DimensionsMap& dst_to_src_dim_map) {
+    // Copy single scalar value from `src` to `dst`.
+    EIGEN_IF_CONSTEXPR (NumDims == 0) {
+      *(dst.data + dst.offset) = *(src.data + src.offset);
+      return 1;
+    }
+
+    // Give a shorter name to `dst_to_src_dim_map`.
+    const DimensionsMap& dim_map = dst_to_src_dim_map;
+
+    // Do not squeeze reordered inner dimensions.
+    int num_squeezable_dims = NumSqueezableInnerDims(dim_map);
+
+    // NOTE: We find the innermost dimension (contiguous in memory) in the dst
+    // block, and we write data linearly into that dimension, reading it from
+    // the src. If dimensions are reordered, we might end up reading data from
+    // the src with `stride != 1`.
+    //
+    // NOTE: Random-Read/Linear-Write can be up to ~2X faster than
+    // Linear-Read/Random-Write: https://stackoverflow.com/a/54935680
+
+    // Find the innermost dimension in the dst whose size is not 1. This is the
+    // effective inner dim.
+    int num_size_one_inner_dims = 0;
+    for (int i = 0; i < num_squeezable_dims; ++i) {
+      const int dst_dim = IsColMajor ? i : NumDims - i - 1;
+      if (dst.dims[dst_dim] != 1) break;
+      num_size_one_inner_dims++;
+    }
+
+    // If all dimensions are of size 1, just copy a scalar from `src` to `dst`.
+    if (num_size_one_inner_dims == NumDims) {
+      *(dst.data + dst.offset) = *(src.data + src.offset);
+      return 1;
+    }
+
+    // Innermost dimension in the dst that still has to be copied. Its stride
+    // need not be 1: the run may be dilated or reversed.
+    const int dst_inner_dim = IsColMajor ? num_size_one_inner_dims : NumDims - num_size_one_inner_dims - 1;
+
+    // Dimension in the src that corresponds to the dst innermost dimension.
+    const int src_dim_for_dst_inner_dim = NumDims == 0 ? 1 : dim_map[dst_inner_dim];
+
+    // Number of elements copied per line.
+    IndexType dst_inner_dim_size = NumDims == 0 ? 1 : dst.dims[dst_inner_dim];
+
+    // Squeeze multiple inner dims into one if the elements keep forming a
+    // single arithmetic progression at the inner stride across the dimension
+    // boundary in both `dst` and `src` memory, so we can do less linear copy
+    // calls.
+    const IndexType output_stride = NumDims == 0 ? 1 : dst.strides[dst_inner_dim];
+    const IndexType input_stride = NumDims == 0 ? 1 : src.strides[src_dim_for_dst_inner_dim];
+    for (int i = num_size_one_inner_dims + 1; i < num_squeezable_dims; ++i) {
+      const int dst_dim = IsColMajor ? i : NumDims - i - 1;
+      const IndexType dst_stride = dst.strides[dst_dim];
+      const IndexType src_stride = src.strides[dim_map[dst_dim]];
+      if (dst_stride == dst_inner_dim_size * output_stride && src_stride == dst_inner_dim_size * input_stride) {
+        dst_inner_dim_size *= dst.dims[dst_dim];
+        ++num_size_one_inner_dims;
+      } else {
+        break;
+      }
+    }
+
+    // Setup strides to read data from `src` and write to `dst`.
+    IndexType input_offset = src.offset;
+    IndexType output_offset = dst.offset;
+
+    constexpr int at_least_1_dim = NumDims <= 1 ? 1 : NumDims - 1;
+    array<BlockIteratorState, at_least_1_dim> it;
+
+    // Initialize block iterator state. Squeeze away any dimension of size 1.
+    int idx = 0;  // currently initialized iterator state index
+    for (int i = num_size_one_inner_dims; i < NumDims - 1; ++i) {
+      const int dst_dim = IsColMajor ? i + 1 : NumDims - i - 2;
+      if (dst.dims[dst_dim] == 1) continue;
+
+      it[idx].size = dst.dims[dst_dim];
+      it[idx].input_stride = src.strides[dim_map[dst_dim]];
+      it[idx].output_stride = dst.strides[dst_dim];
+
+      it[idx].input_span = it[idx].input_stride * (it[idx].size - 1);
+      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
+
+      idx++;
+    }
+
+    // Iterate copying data from src to dst.
+    const IndexType block_total_size = NumDims == 0 ? 1 : dst.dims.TotalSize();
+
+#define COPY_INNER_DIM(KIND)                                                                                      \
+  IndexType num_copied = 0;                                                                                       \
+  for (num_copied = 0; num_copied < block_total_size; num_copied += dst_inner_dim_size) {                         \
+    LinCopy::template Run<KIND>(typename LinCopy::Dst(output_offset, output_stride, dst.data),                    \
+                                typename LinCopy::Src(input_offset, input_stride, src.data), dst_inner_dim_size); \
+                                                                                                                  \
+    for (int j = 0; j < idx; ++j) {                                                                               \
+      if (++it[j].count < it[j].size) {                                                                           \
+        input_offset += it[j].input_stride;                                                                       \
+        output_offset += it[j].output_stride;                                                                     \
+        break;                                                                                                    \
+      }                                                                                                           \
+      it[j].count = 0;                                                                                            \
+      input_offset -= it[j].input_span;                                                                           \
+      output_offset -= it[j].output_span;                                                                         \
+    }                                                                                                             \
+  }                                                                                                               \
+  return num_copied;
+
+    if (input_stride == 1 && output_stride == 1) {
+      COPY_INNER_DIM(LinCopy::Kind::Linear);
+    } else if (input_stride == 1 && output_stride == -1) {
+      COPY_INNER_DIM(LinCopy::Kind::ReverseStore);
+    } else if (input_stride == -1 && output_stride == 1) {
+      COPY_INNER_DIM(LinCopy::Kind::ReverseLoad);
+    } else if (input_stride == -1 && output_stride == -1) {
+      COPY_INNER_DIM(LinCopy::Kind::ReverseBoth);
+    } else if (input_stride == 1 && output_stride != 1) {
+      COPY_INNER_DIM(LinCopy::Kind::Scatter);
+    } else if (input_stride == 0 && output_stride == 1) {
+      COPY_INNER_DIM(LinCopy::Kind::FillLinear);
+    } else if (input_stride == 0 && output_stride != 1) {
+      COPY_INNER_DIM(LinCopy::Kind::FillScatter);
+    } else if (output_stride == 1) {
+      COPY_INNER_DIM(LinCopy::Kind::Gather);
+    } else {
+      COPY_INNER_DIM(LinCopy::Kind::Random);
+    }
+
+#undef COPY_INNER_DIM
+  }
+
+  // Copy from `src` to `dst` with an identity src->dst dimension map. Returns
+  // the number of copied elements.
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexType Copy(const Dst& dst, const Src& src) {
+    DimensionsMap dst_to_src_map;
+    for (int i = 0; i < NumDims; ++i) dst_to_src_map[i] = i;
+    return Copy(dst, src, dst_to_src_map);
+  }
+
+ private:
+  struct BlockIteratorState {
+    BlockIteratorState() = default;
+
+    IndexType size = 0;
+    IndexType count = 0;
+    IndexType input_stride = 0;
+    IndexType output_stride = 0;
+    IndexType input_span = 0;
+    IndexType output_span = 0;
+  };
+
+  // Compute how many inner dimensions it's allowed to squeeze when doing IO
+  // between two tensor blocks. It's safe to squeeze inner dimensions, only
+  // if they are not reordered.
+  static int NumSqueezableInnerDims(const DimensionsMap& dim_map) {
+    int num_squeezable_dims = 0;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      if (dim_map[dim] != dim) break;
+      num_squeezable_dims++;
+    }
+    return num_squeezable_dims;
+  }
+};
+
+// -------------------------------------------------------------------------- //
+// Bind coefficient-wise block expressions to one contiguous inner run at a time.
+// This moves strided source index calculations out of the coefficient/packet loop.
+template <typename XprType>
+struct TensorBlockRead {
+  static constexpr bool Supported = false;
+  using Expression = XprType;
+  using Index = typename XprType::Index;
+  explicit TensorBlockRead(const XprType& expression) : m_expression(expression) {}
+  Index innerSize() const { return NumTraits<Index>::highest(); }
+  const Expression& expr(Index, Index) const { return m_expression; }
+
+ private:
+  const XprType& m_expression;
+};
+
+template <typename Scalar, int NumDims, int Layout, typename Index>
+struct TensorBlockRead<TensorBlockView<Scalar, NumDims, Layout, Index>> {
+  static constexpr bool Supported = true;
+  using XprType = TensorBlockView<Scalar, NumDims, Layout, Index>;
+  using Expression = TensorBlockView<Scalar, 1, Layout, Index>;
+  explicit TensorBlockRead(const XprType& expression) : m_evaluator(expression, m_device), m_inner_size(1) {
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = Layout == ColMajor ? i : NumDims - 1 - i;
+      if (expression.dimensions()[dim] > 1 && expression.strides()[dim] != m_inner_size) break;
+      m_inner_size *= expression.dimensions()[dim];
+    }
+  }
+  Index innerSize() const { return m_inner_size; }
+  Expression expr(Index offset, Index size) const {
+    return Expression(m_evaluator.coeffAddress(offset), DSizes<Index, 1>(size));
+  }
+
+ private:
+  DefaultDevice m_device;
+  TensorEvaluator<const XprType, DefaultDevice> m_evaluator;
+  Index m_inner_size;
+};
+
+// Rebinding a run must not restart a functor's mutable state.
+template <typename Functor>
+class TensorBlockReadFunctor {
+ public:
+  explicit TensorBlockReadFunctor(const Functor& functor) : m_functor(&functor) {}
+  template <typename... Args>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto operator()(Args&&... args) const
+      -> decltype(std::declval<const Functor&>()(std::forward<Args>(args)...)) {
+    return (*m_functor)(std::forward<Args>(args)...);
+  }
+  template <typename... Args, typename F = Functor>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE auto packetOp(Args&&... args) const
+      -> decltype(std::declval<const F&>().packetOp(std::forward<Args>(args)...)) {
+    return m_functor->packetOp(std::forward<Args>(args)...);
+  }
+
+ private:
+  const Functor* m_functor;
+};
+
+template <typename Functor>
+struct functor_traits<TensorBlockReadFunctor<Functor>> : functor_traits<Functor> {};
+
+template <typename UnaryOp, typename Arg>
+struct TensorBlockRead<TensorCwiseUnaryOp<UnaryOp, Arg>> {
+  using ArgRead = TensorBlockRead<remove_all_t<Arg>>;
+  static constexpr bool Supported = ArgRead::Supported;
+  using XprType = TensorCwiseUnaryOp<UnaryOp, Arg>;
+  using Expression = TensorCwiseUnaryOp<TensorBlockReadFunctor<UnaryOp>, const typename ArgRead::Expression>;
+  using Index = typename XprType::Index;
+  explicit TensorBlockRead(const XprType& expression)
+      : m_arg(expression.nestedExpression()), m_functor(expression.functor()) {}
+  Index innerSize() const { return m_arg.innerSize(); }
+  Expression expr(Index offset, Index size) const {
+    return Expression(m_arg.expr(offset, size), TensorBlockReadFunctor<UnaryOp>(m_functor));
+  }
+
+ private:
+  ArgRead m_arg;
+  UnaryOp m_functor;
+};
+
+template <typename BinaryOp, typename Left, typename Right>
+struct TensorBlockRead<TensorCwiseBinaryOp<BinaryOp, Left, Right>> {
+  using LeftRead = TensorBlockRead<remove_all_t<Left>>;
+  using RightRead = TensorBlockRead<remove_all_t<Right>>;
+  static constexpr bool Supported = LeftRead::Supported && RightRead::Supported;
+  using XprType = TensorCwiseBinaryOp<BinaryOp, Left, Right>;
+  using Expression = TensorCwiseBinaryOp<TensorBlockReadFunctor<BinaryOp>, const typename LeftRead::Expression,
+                                         const typename RightRead::Expression>;
+  using Index = typename XprType::Index;
+  explicit TensorBlockRead(const XprType& expression)
+      : m_left(expression.lhsExpression()), m_right(expression.rhsExpression()), m_functor(expression.functor()) {}
+  Index innerSize() const { return numext::mini(m_left.innerSize(), m_right.innerSize()); }
+  Expression expr(Index offset, Index size) const {
+    return Expression(m_left.expr(offset, size), m_right.expr(offset, size),
+                      TensorBlockReadFunctor<BinaryOp>(m_functor));
+  }
+
+ private:
+  LeftRead m_left;
+  RightRead m_right;
+  BinaryOp m_functor;
+};
+
+template <typename NullaryOp, typename Arg>
+struct TensorBlockRead<TensorCwiseNullaryOp<NullaryOp, Arg>> {
+  using XprType = TensorCwiseNullaryOp<NullaryOp, Arg>;
+  using Evaluator = TensorEvaluator<const XprType, DefaultDevice>;
+  static constexpr bool Supported = Evaluator::IndexIndependentFunctor;
+  using Index = typename XprType::Index;
+  using RunView = TensorBlockView<typename XprType::Scalar, 1, traits<XprType>::Layout, Index>;
+  using Expression = TensorCwiseNullaryOp<NullaryOp, const RunView>;
+  explicit TensorBlockRead(const XprType& expression) : m_functor(expression.functor()) {}
+  Index innerSize() const { return NumTraits<Index>::highest(); }
+  Expression expr(Index, Index size) const { return Expression(RunView(nullptr, DSizes<Index, 1>(size)), m_functor); }
+
+ private:
+  NullaryOp m_functor;
+};
+
+template <typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
+struct TensorBlockRead<TensorCwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>> {
+  using Arg1Read = TensorBlockRead<remove_all_t<Arg1>>;
+  using Arg2Read = TensorBlockRead<remove_all_t<Arg2>>;
+  using Arg3Read = TensorBlockRead<remove_all_t<Arg3>>;
+  static constexpr bool Supported = Arg1Read::Supported && Arg2Read::Supported && Arg3Read::Supported;
+  using XprType = TensorCwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>;
+  using Expression = TensorCwiseTernaryOp<TensorBlockReadFunctor<TernaryOp>, const typename Arg1Read::Expression,
+                                          const typename Arg2Read::Expression, const typename Arg3Read::Expression>;
+  using Index = typename XprType::Index;
+  explicit TensorBlockRead(const XprType& expression)
+      : m_arg1(expression.arg1Expression()),
+        m_arg2(expression.arg2Expression()),
+        m_arg3(expression.arg3Expression()),
+        m_functor(expression.functor()) {}
+  Index innerSize() const {
+    return numext::mini(m_arg1.innerSize(), numext::mini(m_arg2.innerSize(), m_arg3.innerSize()));
+  }
+  Expression expr(Index offset, Index size) const {
+    return Expression(m_arg1.expr(offset, size), m_arg2.expr(offset, size), m_arg3.expr(offset, size),
+                      TensorBlockReadFunctor<TernaryOp>(m_functor));
+  }
+
+ private:
+  Arg1Read m_arg1;
+  Arg2Read m_arg2;
+  Arg3Read m_arg3;
+  TernaryOp m_functor;
+};
+
+template <typename Cond, typename Then, typename Else>
+struct TensorBlockRead<TensorSelectOp<Cond, Then, Else>> {
+  using CondRead = TensorBlockRead<remove_all_t<Cond>>;
+  using ThenRead = TensorBlockRead<remove_all_t<Then>>;
+  using ElseRead = TensorBlockRead<remove_all_t<Else>>;
+  static constexpr bool Supported = CondRead::Supported && ThenRead::Supported && ElseRead::Supported;
+  using XprType = TensorSelectOp<Cond, Then, Else>;
+  using Expression = TensorSelectOp<const typename CondRead::Expression, const typename ThenRead::Expression,
+                                    const typename ElseRead::Expression>;
+  using Index = typename XprType::Index;
+  explicit TensorBlockRead(const XprType& expression)
+      : m_cond(expression.ifExpression()), m_then(expression.thenExpression()), m_else(expression.elseExpression()) {}
+  Index innerSize() const {
+    return numext::mini(m_cond.innerSize(), numext::mini(m_then.innerSize(), m_else.innerSize()));
+  }
+  Expression expr(Index offset, Index size) const {
+    return Expression(m_cond.expr(offset, size), m_then.expr(offset, size), m_else.expr(offset, size));
+  }
+
+ private:
+  CondRead m_cond;
+  ThenRead m_then;
+  ElseRead m_else;
+};
+
+template <typename Scalar, typename Arg>
+struct TensorBlockRead<TensorConversionOp<Scalar, Arg>> {
+  using ArgRead = TensorBlockRead<remove_all_t<Arg>>;
+  static constexpr bool Supported = ArgRead::Supported;
+  using XprType = TensorConversionOp<Scalar, Arg>;
+  using Expression = TensorConversionOp<Scalar, const typename ArgRead::Expression>;
+  using Index = typename XprType::Index;
+  explicit TensorBlockRead(const XprType& expression) : m_arg(expression.expression()) {}
+  Index innerSize() const { return m_arg.innerSize(); }
+  Expression expr(Index offset, Index size) const { return Expression(m_arg.expr(offset, size)); }
+
+ private:
+  ArgRead m_arg;
+};
+
+// TensorBlockAssignment assigns a block expression of type `TensorBlockExpr` to
+// a Tensor block defined by `desc`, backed by a memory buffer at `target`.
+//
+// Currently there is no way to write from a Tensor expression to a block of
+// memory, if dimensions are reordered. If you need to do that, you should
+// materialize a Tensor block expression into a memory buffer, and then use
+// TensorBlockIO to copy data between two memory buffers with a custom
+// `target->src` dimension map (see definition above).
+//
+// Also currently the innermost dimension of `target` must have a stride '1'
+// (contiguous in memory). This restriction could be lifted with a `pscatter`,
+// but in practice it's never needed, and there is a similar TensorBlockIO
+// workaround for that.
+//
+// TODO(ezhulenev): TensorBlockAssignment is a special case of TensorBlockIO
+// where `src` is a tensor expression. Explore if it is possible to rewrite IO
+// to use expressions instead of pointers, and after that TensorBlockAssignment
+// will become an alias to IO.
+template <typename Scalar, int NumDims, typename TensorBlockExpr, typename IndexType = Eigen::Index>
+class TensorBlockAssignment {
+  // We will use coeff/packet path to evaluate block expressions.
+  typedef TensorEvaluator<const TensorBlockExpr, DefaultDevice> TensorBlockEvaluator;
+
+  typedef DSizes<IndexType, NumDims> Dimensions;
+  using BlockRead = TensorBlockRead<TensorBlockExpr>;
+
+  enum { Vectorizable = packet_traits<Scalar>::Vectorizable, PacketSize = packet_traits<Scalar>::size };
+
+  template <bool Vectorizable, typename Evaluator>
+  struct InnerDimAssign {
+    EIGEN_ALWAYS_INLINE static void Run(Scalar* target, IndexType count, const Evaluator& eval, IndexType eval_offset) {
+      for (IndexType i = 0; i < count; ++i) {
+        target[i] = eval.coeff(eval_offset + i);
+      }
+    }
+  };
+
+  template <typename Evaluator>
+  struct InnerDimAssign<true, Evaluator> {
+    EIGEN_ALWAYS_INLINE static void Run(Scalar* target, IndexType count, const Evaluator& eval, IndexType eval_offset) {
+      typedef typename packet_traits<Scalar>::type Packet;
+
+      const IndexType unrolled_size = (4 * PacketSize) * (count / (4 * PacketSize));
+      const IndexType vectorized_size = PacketSize * (count / PacketSize);
+      IndexType i = 0;
+
+      for (; i < unrolled_size; i += 4 * PacketSize) {
+        for (int j = 0; j < 4; ++j) {
+          const IndexType idx = eval_offset + i + j * PacketSize;
+          Packet p = eval.template packet<Unaligned>(idx);
+          pstoreu<Scalar>(target + i + j * PacketSize, p);
+        }
+      }
+
+      for (; i < vectorized_size; i += PacketSize) {
+        Packet p = eval.template packet<Unaligned>(eval_offset + i);
+        pstoreu<Scalar>(target + i, p);
+      }
+
+      for (; i < count; ++i) {
+        target[i] = eval.coeff(eval_offset + i);
+      }
+    }
+  };
+
+  template <typename Evaluator>
+  static EIGEN_STRONG_INLINE void AssignInner(Scalar* target, IndexType count, const Evaluator& eval, const BlockRead&,
+                                              IndexType offset, std::false_type) {
+    InnerDimAssign<Vectorizable && Evaluator::PacketAccess, Evaluator>::Run(target, count, eval, offset);
+  }
+
+  static EIGEN_STRONG_INLINE void AssignInner(Scalar* target, IndexType count, const TensorBlockEvaluator&,
+                                              const BlockRead& reader, IndexType offset, std::true_type) {
+    const auto expression = reader.expr(offset, count);
+    using RunEvaluator = TensorEvaluator<const typename BlockRead::Expression, DefaultDevice>;
+    const DefaultDevice device;
+    const RunEvaluator eval(expression, device);
+    InnerDimAssign<Vectorizable && RunEvaluator::PacketAccess, RunEvaluator>::Run(target, count, eval, 0);
+  }
+
+ public:
+  struct Target {
+    Target(const Dimensions& target_dims, const Dimensions& target_strides, Scalar* target_data,
+           IndexType target_offset = 0)
+        : dims(target_dims), strides(target_strides), data(target_data), offset(target_offset) {}
+
+    Dimensions dims;
+    Dimensions strides;
+    Scalar* data;
+    IndexType offset;
+  };
+
+  static Target target(const Dimensions& target_dims, const Dimensions& target_strides, Scalar* target_data,
+                       IndexType target_offset = 0) {
+    return Target(target_dims, target_strides, target_data, target_offset);
+  }
+
+  template <typename TargetDimsIndexType, typename TargetStridesIndexType>
+  static Target target(const DSizes<TargetDimsIndexType, NumDims>& target_dims,
+                       const DSizes<TargetStridesIndexType, NumDims>& target_strides, Scalar* target_data,
+                       IndexType target_offset = 0) {
+    // DSizes constructor will do index type promotion if it's safe.
+    return Target(Dimensions(target_dims), Dimensions(target_strides), target_data, target_offset);
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Target& target, const TensorBlockExpr& expr) {
+    // Prepare evaluator for block expression.
+    DefaultDevice default_device;
+    TensorBlockEvaluator eval(expr, default_device);
+    const BlockRead reader(expr);
+
+    // Tensor block expression dimension should match destination dimensions.
+    eigen_assert(dimensions_match(target.dims, eval.dimensions()));
+
+    Run(target, eval, reader, bool_constant<BlockRead::Supported>());
+  }
+
+ private:
+  static void Run(const Target& target, const TensorBlockEvaluator& eval, const BlockRead& reader, std::false_type) {
+    RunImpl<false>(target, eval, reader);
+  }
+
+  static void Run(const Target& target, const TensorBlockEvaluator& eval, const BlockRead& reader, std::true_type) {
+    const IndexType size = NumDims == 0 ? 1 : target.dims.TotalSize();
+    if (reader.innerSize() >= size) {
+      // Bind a dense source once, even when the destination has strided rows.
+      const auto expression = reader.expr(0, size);
+      using RunEvaluator = TensorEvaluator<const typename BlockRead::Expression, DefaultDevice>;
+      const DefaultDevice device;
+      const RunEvaluator dense_eval(expression, device);
+      RunImpl<false>(target, dense_eval, reader);
+    } else {
+      RunImpl<true>(target, eval, reader);
+    }
+  }
+
+  template <bool UseInnerRuns, typename Evaluator>
+  static EIGEN_STRONG_INLINE void RunImpl(const Target& target, const Evaluator& eval, const BlockRead& reader) {
+    static constexpr int Layout = Evaluator::Layout;
+    static constexpr bool is_col_major = Layout == ColMajor;
+
+    // Initialize output inner dimension size based on a layout.
+    const IndexType output_size = NumDims == 0 ? 1 : target.dims.TotalSize();
+    constexpr int inner_dim_idx = NumDims == 0 ? 0 : (is_col_major ? 0 : NumDims - 1);
+    IndexType output_inner_dim_size = NumDims == 0 ? 1 : target.dims[inner_dim_idx];
+
+    // Target inner dimension stride must be '1'.
+    EIGEN_IF_CONSTEXPR (NumDims > 0) {
+      eigen_assert(target.strides[inner_dim_idx] == 1);
+    }
+
+    // Squeeze multiple inner dims into one if they are contiguous in `target`.
+    IndexType num_squeezed_dims = 0;
+    for (Index i = 1; i < NumDims; ++i) {
+      const Index dim = is_col_major ? i : NumDims - i - 1;
+      const IndexType target_stride = target.strides[dim];
+
+      if (output_inner_dim_size == target_stride &&
+          (!UseInnerRuns || output_inner_dim_size * target.dims[dim] <= reader.innerSize())) {
+        output_inner_dim_size *= target.dims[dim];
+        num_squeezed_dims++;
+      } else {
+        break;
+      }
+    }
+
+    // Initialize output block iterator state. Dimension in this array are
+    // always in inner_most -> outer_most order (col major layout).
+    array<BlockIteratorState, NumDims> it;
+
+    int idx = 0;  // currently initialized iterator state index
+    for (Index i = num_squeezed_dims; i < NumDims - 1; ++i) {
+      const Index dim = is_col_major ? i + 1 : NumDims - i - 2;
+
+      it[idx].count = 0;
+      it[idx].size = target.dims[dim];
+      it[idx].output_stride = target.strides[dim];
+      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
+      idx++;
+    }
+
+    // We read block expression from the beginning, and start writing data to
+    // `target` at given offset.
+    IndexType input_offset = 0;
+    IndexType output_offset = target.offset;
+
+    // Iterate copying data from `eval` to `target`.
+    for (IndexType i = 0; i < output_size; i += output_inner_dim_size) {
+      // Assign to `target` at current offset.
+      AssignInner(target.data + output_offset, output_inner_dim_size, eval, reader, input_offset,
+                  bool_constant<UseInnerRuns>());
+
+      // Move input offset forward by the number of assigned coefficients.
+      input_offset += output_inner_dim_size;
+
+      // Update index.
+      for (int j = 0; j < idx; ++j) {
+        if (++it[j].count < it[j].size) {
+          output_offset += it[j].output_stride;
+          break;
+        }
+        it[j].count = 0;
+        output_offset -= it[j].output_span;
+      }
+    }
+  }
+
+ private:
+  struct BlockIteratorState {
+    BlockIteratorState() = default;
+
+    IndexType count = 0;
+    IndexType size = 0;
+    IndexType output_stride = 0;
+    IndexType output_span = 0;
+  };
+};
+
+// -------------------------------------------------------------------------- //
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_BLOCK_H
diff --git a/contrib/Eigen/src/Tensor/TensorBroadcasting.h b/contrib/Eigen/src/Tensor/TensorBroadcasting.h
new file mode 100644
index 0000000..cdde133
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorBroadcasting.h
@@ -0,0 +1,1000 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_BROADCASTING_H
+#define EIGEN_TENSOR_TENSOR_BROADCASTING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Broadcast, typename XprType>
+struct traits<TensorBroadcastingOp<Broadcast, XprType>> : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+  enum {
+    // Broadcast is read-only.
+    Flags = traits<XprType>::Flags & ~LvalueBit
+  };
+};
+
+template <typename Broadcast, typename XprType>
+struct eval<TensorBroadcastingOp<Broadcast, XprType>, Eigen::Dense> {
+  typedef const TensorBroadcastingOp<Broadcast, XprType> EIGEN_DEVICE_REF type;
+};
+
+template <typename Dims>
+struct is_input_scalar : std::false_type {};
+template <>
+struct is_input_scalar<Sizes<>> : std::true_type {};
+template <std::ptrdiff_t... Indices>
+struct is_input_scalar<Sizes<Indices...>> : bool_constant<Sizes<Indices...>::total_size == 1> {};
+
+}  // end namespace internal
+
+/** Tensor broadcasting class.
+ * \ingroup Tensor_Module
+ */
+template <typename Broadcast, typename XprType>
+class TensorBroadcastingOp : public TensorBase<TensorBroadcastingOp<Broadcast, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorBroadcastingOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorBroadcastingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorBroadcastingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorBroadcastingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBroadcastingOp(const XprType& expr, const Broadcast& broadcast)
+      : m_xpr(expr), m_broadcast(broadcast) {}
+
+  EIGEN_DEVICE_FUNC const Broadcast& broadcast() const { return m_broadcast; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Broadcast m_broadcast;
+};
+
+// Eval as rvalue
+template <typename Broadcast, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorBroadcastingOp<Broadcast, ArgType>, Device> {
+  typedef TensorBroadcastingOp<Broadcast, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+
+ protected:  //  all the non-static fields must have the same access control, otherwise the TensorEvaluator won't be
+             //  standard layout;
+  bool isCopy, nByOne, oneByN;
+
+ public:
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
+    PreferBlockAccess = true,
+    RawAccess = false
+  };
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  // We do block based broadcasting using a trick with 2x tensor rank and 0
+  // strides. See block method implementation for details.
+  typedef DSizes<Index, 2 * NumDims> BroadcastDimensions;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : isCopy(false),
+        nByOne(false),
+        oneByN(false),
+        m_device(device),
+        m_broadcast(op.broadcast()),
+        m_impl(op.expression(), device) {
+    // The broadcasting op doesn't change the rank of the tensor. One can't broadcast a scalar
+    // and store the result in a scalar. Instead one should reshape the scalar into a N-D
+    // tensor with N >= 1 of 1 element first and then broadcast.
+    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    const InputDimensions& input_dims = m_impl.dimensions();
+    isCopy = true;
+    for (int i = 0; i < NumDims; ++i) {
+      eigen_assert(input_dims[i] > 0);
+      m_dimensions[i] = input_dims[i] * m_broadcast[i];
+      if (m_broadcast[i] != 1) {
+        isCopy = false;
+      }
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputStrides[0] = 1;
+      m_outputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
+        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+      }
+    } else {
+      m_inputStrides[NumDims - 1] = 1;
+      m_outputStrides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
+        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+      }
+    }
+
+    if (input_dims[0] == 1) {
+      oneByN = true;
+      for (int i = 1; i < NumDims; ++i) {
+        if (m_broadcast[i] != 1) {
+          oneByN = false;
+          break;
+        }
+      }
+    } else if (input_dims[NumDims - 1] == 1) {
+      nByOne = true;
+      for (int i = 0; i < NumDims - 1; ++i) {
+        if (m_broadcast[i] != 1) {
+          nByOne = false;
+          break;
+        }
+      }
+    }
+
+    // Handle special format like NCHW, its input shape is '[1, N..., 1]' and
+    // broadcast shape is '[N, 1..., N]'
+    if (!oneByN && !nByOne) {
+      if (input_dims[0] == 1 && input_dims[NumDims - 1] == 1 && NumDims > 2) {
+        nByOne = true;
+        oneByN = true;
+        for (int i = 1; i < NumDims - 1; ++i) {
+          if (m_broadcast[i] != 1) {
+            nByOne = false;
+            oneByN = false;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffReturnType coeff(Index index) const {
+    EIGEN_IF_CONSTEXPR ((internal::is_input_scalar<internal::remove_all_t<InputDimensions>>::value)) {
+      return m_impl.coeff(0);
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      if (isCopy) {
+        return m_impl.coeff(index);
+      } else {
+        return coeffColMajor(index);
+      }
+    } else {
+      if (isCopy) {
+        return m_impl.coeff(index);
+      } else {
+        return coeffRowMajor(index);
+      }
+    }
+  }
+
+  // The per-dim integer div/mod look expensive but amortize well: packet paths
+  // call this once per PacketSize outputs, and modern x86 hardware div is
+  // ~20 cycles. Prototyped replacing div/mod with TensorIntDivisor (the
+  // pattern used in TensorShuffling et al.); measured net-negative on Intel
+  // Raptor Lake across bench_broadcasting (more shapes regress 3-5% than
+  // improve). Left as hardware div.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index indexColMajor(Index index) const {
+    Index inputIndex = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = NumDims - 1; i > 0; --i) {
+      const Index idx = index / m_outputStrides[i];
+      if (internal::index_statically_eq<Broadcast>(i, 1)) {
+        eigen_assert(idx < m_impl.dimensions()[i]);
+        inputIndex += idx * m_inputStrides[i];
+      } else {
+        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
+          eigen_assert(idx % m_impl.dimensions()[i] == 0);
+        } else {
+          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
+        }
+      }
+      index -= idx * m_outputStrides[i];
+    }
+    EIGEN_IF_CONSTEXPR (internal::index_statically_eq<Broadcast>(0, 1)) {
+      eigen_assert(index < m_impl.dimensions()[0]);
+      inputIndex += index;
+    } else {
+      EIGEN_IF_CONSTEXPR (internal::index_statically_eq<InputDimensions>(0, 1)) {
+        eigen_assert(index % m_impl.dimensions()[0] == 0);
+      } else {
+        inputIndex += (index % m_impl.dimensions()[0]);
+      }
+    }
+    return inputIndex;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeffColMajor(Index index) const {
+    return m_impl.coeff(indexColMajor(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index indexRowMajor(Index index) const {
+    Index inputIndex = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < NumDims - 1; ++i) {
+      const Index idx = index / m_outputStrides[i];
+      if (internal::index_statically_eq<Broadcast>(i, 1)) {
+        eigen_assert(idx < m_impl.dimensions()[i]);
+        inputIndex += idx * m_inputStrides[i];
+      } else {
+        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
+          eigen_assert(idx % m_impl.dimensions()[i] == 0);
+        } else {
+          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
+        }
+      }
+      index -= idx * m_outputStrides[i];
+    }
+    EIGEN_IF_CONSTEXPR (internal::index_statically_eq<Broadcast>(NumDims - 1, 1)) {
+      eigen_assert(index < m_impl.dimensions()[NumDims - 1]);
+      inputIndex += index;
+    } else {
+      EIGEN_IF_CONSTEXPR (internal::index_statically_eq<InputDimensions>(NumDims - 1, 1)) {
+        eigen_assert(index % m_impl.dimensions()[NumDims - 1] == 0);
+      } else {
+        inputIndex += (index % m_impl.dimensions()[NumDims - 1]);
+      }
+    }
+    return inputIndex;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeffRowMajor(Index index) const {
+    return m_impl.coeff(indexRowMajor(index));
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketReturnType packet(Index index) const {
+    EIGEN_IF_CONSTEXPR ((internal::is_input_scalar<internal::remove_all_t<InputDimensions>>::value)) {
+      return internal::pset1<PacketReturnType>(m_impl.coeff(0));
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      if (isCopy) {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+        // See PR 437: on NVIDIA P100 and K20m we observed a x3-4 speed up by enforcing
+        // unaligned loads here. The reason is unclear though.
+        return m_impl.template packet<Unaligned>(index);
+#else
+        return m_impl.template packet<LoadMode>(index);
+#endif
+      } else if (oneByN && !nByOne) {
+        return packetNByOne<LoadMode>(index);
+      } else if (!oneByN && nByOne) {
+        return packetOneByN<LoadMode>(index);
+      } else if (oneByN && nByOne) {
+        return packetOneByNByOne<LoadMode>(index);
+      } else {
+        return packetColMajor<LoadMode>(index);
+      }
+    } else {
+      if (isCopy) {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+        // See above.
+        return m_impl.template packet<Unaligned>(index);
+#else
+        return m_impl.template packet<LoadMode>(index);
+#endif
+      } else if (oneByN && !nByOne) {
+        return packetOneByN<LoadMode>(index);
+      } else if (!oneByN && nByOne) {
+        return packetNByOne<LoadMode>(index);
+      } else if (oneByN && nByOne) {
+        return packetOneByNByOne<LoadMode>(index);
+      } else {
+        return packetRowMajor<LoadMode>(index);
+      }
+    }
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetOneByNByOne(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    Index startDim, endDim;
+    Index inputIndex, outputOffset, batchedIndex;
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      startDim = NumDims - 1;
+      endDim = 1;
+    } else {
+      startDim = 0;
+      endDim = NumDims - 2;
+    }
+
+    batchedIndex = index % m_outputStrides[startDim];
+    inputIndex = batchedIndex / m_outputStrides[endDim];
+    outputOffset = batchedIndex % m_outputStrides[endDim];
+
+    if (outputOffset + PacketSize <= m_outputStrides[endDim]) {
+      values[0] = m_impl.coeff(inputIndex);
+      return internal::pload1<PacketReturnType>(values);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0, cur = 0; i < PacketSize; ++i, ++cur) {
+        if (outputOffset + cur < m_outputStrides[endDim]) {
+          values[i] = m_impl.coeff(inputIndex);
+        } else {
+          ++inputIndex;
+          inputIndex = (inputIndex == m_inputStrides[startDim] ? 0 : inputIndex);
+          values[i] = m_impl.coeff(inputIndex);
+          outputOffset = 0;
+          cur = 0;
+        }
+      }
+      return internal::pload<PacketReturnType>(values);
+    }
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetOneByN(Index index) const {
+    // Consider the flattened tensor [v0, ..., vN],
+    // Concatenates m_broadcast[dim] copies,
+    //    [v0, ..., vN, v0, ..., vN, ... ]
+    // with dim == NumDims - 1 for col-major, dim == 0 for row-major.
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    // Size of flattened tensor.
+    const Index M =
+        (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? m_inputStrides[NumDims - 1] : m_inputStrides[0];
+    Index inputIndex = index % M;
+    if (inputIndex + PacketSize <= M) {
+      return m_impl.template packet<Unaligned>(inputIndex);
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < PacketSize; ++i) {
+        if (inputIndex > M - 1) {
+          inputIndex = 0;
+        }
+        values[i] = m_impl.coeff(inputIndex++);
+      }
+      return internal::pload<PacketReturnType>(values);
+    }
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetNByOne(Index index) const {
+    // Consider the flattened tensor [v0, ..., vN],
+    // Interleaves m_broadcast[dim] copies,
+    //    [v0, v0, ..., v1, v1, ..., vN, vN, ... ]
+    // with dim == 0 for col-major, dim == NumDims - 1 for row-major.
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    const Index M =
+        (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? m_broadcast[0] : m_broadcast[NumDims - 1];
+
+    Index inputIndex = index / M;
+    Index outputOffset = index % M;
+    if (outputOffset + PacketSize <= M) {
+      return internal::pset1<PacketReturnType>(m_impl.coeff(inputIndex));
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < PacketSize; ++i) {
+        if (outputOffset < M) {
+          values[i] = m_impl.coeff(inputIndex);
+          ++outputOffset;
+        } else {
+          values[i] = m_impl.coeff(++inputIndex);
+          outputOffset = 1;  // Next offset.
+        }
+      }
+      return internal::pload<PacketReturnType>(values);
+    }
+  }
+
+  // Ignore the LoadMode and always use unaligned loads since we can't guarantee
+  // the alignment at compile time.
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetColMajor(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    const Index originalIndex = index;
+
+    Index inputIndex = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = NumDims - 1; i > 0; --i) {
+      const Index idx = index / m_outputStrides[i];
+      if (internal::index_statically_eq<Broadcast>(i, 1)) {
+        eigen_assert(idx < m_impl.dimensions()[i]);
+        inputIndex += idx * m_inputStrides[i];
+      } else {
+        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
+          eigen_assert(idx % m_impl.dimensions()[i] == 0);
+        } else {
+          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
+        }
+      }
+      index -= idx * m_outputStrides[i];
+    }
+    Index innermostLoc;
+    EIGEN_IF_CONSTEXPR (internal::index_statically_eq<Broadcast>(0, 1)) {
+      eigen_assert(index < m_impl.dimensions()[0]);
+      innermostLoc = index;
+    } else {
+      EIGEN_IF_CONSTEXPR (internal::index_statically_eq<InputDimensions>(0, 1)) {
+        eigen_assert(index % m_impl.dimensions()[0] == 0);
+        innermostLoc = 0;
+      } else {
+        innermostLoc = index % m_impl.dimensions()[0];
+      }
+    }
+    inputIndex += innermostLoc;
+
+    // TODO: This could be extended to the second dimension if we're not
+    // broadcasting alongside the first dimension, and so on.
+    if (innermostLoc + PacketSize <= m_impl.dimensions()[0]) {
+      return m_impl.template packet<Unaligned>(inputIndex);
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      values[0] = m_impl.coeff(inputIndex);
+      EIGEN_UNROLL_LOOP
+      for (int i = 1; i < PacketSize; ++i) {
+        if (innermostLoc + i < m_impl.dimensions()[0]) {
+          values[i] = m_impl.coeff(inputIndex + i);
+        } else {
+          values[i] = coeffColMajor(originalIndex + i);
+        }
+      }
+      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+      return rslt;
+    }
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetRowMajor(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    const Index originalIndex = index;
+
+    Index inputIndex = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < NumDims - 1; ++i) {
+      const Index idx = index / m_outputStrides[i];
+      if (internal::index_statically_eq<Broadcast>(i, 1)) {
+        eigen_assert(idx < m_impl.dimensions()[i]);
+        inputIndex += idx * m_inputStrides[i];
+      } else {
+        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
+          eigen_assert(idx % m_impl.dimensions()[i] == 0);
+        } else {
+          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
+        }
+      }
+      index -= idx * m_outputStrides[i];
+    }
+    Index innermostLoc;
+    EIGEN_IF_CONSTEXPR (internal::index_statically_eq<Broadcast>(NumDims - 1, 1)) {
+      eigen_assert(index < m_impl.dimensions()[NumDims - 1]);
+      innermostLoc = index;
+    } else {
+      EIGEN_IF_CONSTEXPR (internal::index_statically_eq<InputDimensions>(NumDims - 1, 1)) {
+        eigen_assert(index % m_impl.dimensions()[NumDims - 1] == 0);
+        innermostLoc = 0;
+      } else {
+        innermostLoc = index % m_impl.dimensions()[NumDims - 1];
+      }
+    }
+    inputIndex += innermostLoc;
+
+    // TODO: This could be extended to the second dimension if we're not
+    // broadcasting alongside the first dimension, and so on.
+    if (innermostLoc + PacketSize <= m_impl.dimensions()[NumDims - 1]) {
+      return m_impl.template packet<Unaligned>(inputIndex);
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      values[0] = m_impl.coeff(inputIndex);
+      EIGEN_UNROLL_LOOP
+      for (int i = 1; i < PacketSize; ++i) {
+        if (innermostLoc + i < m_impl.dimensions()[NumDims - 1]) {
+          values[i] = m_impl.coeff(inputIndex + i);
+        } else {
+          values[i] = coeffRowMajor(originalIndex + i);
+        }
+      }
+      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+      return rslt;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    double compute_cost = TensorOpCost::AddCost<Index>();
+    EIGEN_IF_CONSTEXPR (NumDims > 0) {
+      if (!isCopy) {
+        EIGEN_UNROLL_LOOP
+        for (int i = NumDims - 1; i > 0; --i) {
+          compute_cost += TensorOpCost::DivCost<Index>();
+          if (internal::index_statically_eq<Broadcast>(i, 1)) {
+            compute_cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
+          } else {
+            if (!internal::index_statically_eq<InputDimensions>(i, 1)) {
+              compute_cost +=
+                  TensorOpCost::MulCost<Index>() + TensorOpCost::ModCost<Index>() + TensorOpCost::AddCost<Index>();
+            }
+          }
+          compute_cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
+        }
+      }
+    }
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    // Target the L1 cache: measured ~30% faster than targeting the last-level
+    // cache on large tensors.
+    const size_t target_size = m_device.firstLevelCacheSize();
+    return internal::TensorBlockResourceRequirements::merge(
+        m_impl.getResourceRequirements(), internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    BlockBroadcastingParams params = blockBroadcastingParams(desc);
+
+    if (params.inner_dim_size == 0 || params.bcast_dim_size == 0) {
+      return emptyBlock();
+    }
+
+    // Prepare storage for the materialized broadcasting result.
+    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    ScalarNoConst* materialized_output = block_storage.data();
+
+    // We potentially will need to materialize input blocks.
+    size_t materialized_input_size = 0;
+    ScalarNoConst* materialized_input = nullptr;
+
+    // Initialize block broadcasting iterator state for outer dimensions (outer
+    // with regard to bcast dimension). Dimensions in this array are always in
+    // inner_most -> outer_most order (col major layout).
+    array<BlockBroadcastingIteratorState, NumDims> it;
+    int idx = 0;
+
+    for (int i = params.inner_dim_count + 1; i < NumDims; ++i) {
+      const Index dim = IsColMajor ? i : NumDims - 1 - i;
+      it[idx].size = params.output_dims[dim];
+      it[idx].count = 0;
+      it[idx].output_stride = m_outputStrides[dim];
+      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
+      idx++;
+    }
+
+    // Write output into the beginning of `materialized_output`.
+    Index output_offset = 0;
+
+    // We will fill output block by broadcasting along the bcast dim, and
+    // iterating over outer dimension.
+    const Index output_size = NumDims == 0 ? 1 : params.output_dims.TotalSize();
+
+    for (Index num_output_coeffs = 0; num_output_coeffs < output_size;) {
+      ScalarNoConst* bcast_output = materialized_output + num_output_coeffs;
+      Index bcast_offset = desc.offset() + output_offset;
+
+      // Broadcast along the bcast dimension.
+      num_output_coeffs += BroadcastBlockAlongBcastDim(params, bcast_offset, scratch, bcast_output, &materialized_input,
+                                                       &materialized_input_size);
+
+      // Switch to the next outer dimension.
+      for (int j = 0; j < idx; ++j) {
+        if (++it[j].count < it[j].size) {
+          output_offset += it[j].output_stride;
+          break;
+        }
+        it[j].count = 0;
+        output_offset -= it[j].output_span;
+      }
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+
+  Broadcast functor() const { return m_broadcast; }
+
+ private:
+  static constexpr bool IsColMajor = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+  // We will build a general case block broadcasting on top of broadcasting
+  // primitive that will do broadcasting only for the inner dimension(s) along
+  // the first dimension smaller than the input size (it's called `bcast_dim`).
+  //
+  // Example:
+  //           dim:  0  1  2   (ColMajor)
+  //    input size: [9, 3, 6]
+  //    block size: [9, 2, 6]
+  //
+  // We will compute broadcasted block by iterating over the outer dimensions
+  // before `bcast_dim` (only dimension `2` in this example) and computing
+  // broadcasts along the `bcast_dim` (dimension `1` in this example).
+
+  // BlockBroadcastingParams holds precomputed parameters for broadcasting a
+  // single block along the broadcasting dimension. Sizes and strides along the
+  // `bcast_dim` might be invalid, they will be adjusted later in
+  // `BroadcastBlockAlongBcastDim`.
+  struct BlockBroadcastingParams {
+    Dimensions input_dims;      // input expression dimensions
+    Dimensions output_dims;     // output block sizes
+    Dimensions output_strides;  // output block strides
+
+    int inner_dim_count;   // count inner dimensions matching in size
+    int bcast_dim;         // broadcasting dimension index
+    Index bcast_dim_size;  // broadcasting dimension size
+    Index inner_dim_size;  // inner dimensions size
+
+    // Block sizes and strides for the input block where all dimensions before
+    // `bcast_dim` are equal to `1`.
+    Dimensions input_block_sizes;
+    Dimensions input_block_strides;
+
+    // Block sizes and strides for blocks with extra dimensions and strides `0`.
+    BroadcastDimensions bcast_block_sizes;
+    BroadcastDimensions bcast_block_strides;
+    BroadcastDimensions bcast_input_strides;
+  };
+
+  struct BlockBroadcastingIteratorState {
+    Index size;
+    Index count;
+    Index output_stride;
+    Index output_span;
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlockBroadcastingParams blockBroadcastingParams(TensorBlockDesc& desc) const {
+    BlockBroadcastingParams params;
+
+    params.input_dims = Dimensions(m_impl.dimensions());
+
+    // Output block sizes and strides.
+    params.output_dims = desc.dimensions();
+    params.output_strides = internal::strides<Layout>(params.output_dims);
+
+    // Find the broadcasting dimension (first dimension with output size smaller
+    // than the input size).
+    params.bcast_dim = 0;
+    params.bcast_dim_size = 1;
+    params.inner_dim_size = 1;
+
+    // Count the number of inner dimensions that have the same size in the block
+    // and in the broadcast expression.
+    params.inner_dim_count = 0;
+
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+
+      if (params.output_dims[dim] == m_dimensions[dim]) {
+        params.inner_dim_size *= params.output_dims[dim];
+        ++params.inner_dim_count;
+        continue;
+      }
+
+      // First non-matching dimension is the broadcasting dimension.
+      eigen_assert(params.output_dims[dim] < m_dimensions[dim]);
+      params.bcast_dim = dim;
+      params.bcast_dim_size = params.output_dims[dim];
+      break;
+    }
+
+    // Calculate the input block size for looking into the input.
+    for (int i = 0; i < params.inner_dim_count; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      params.input_block_sizes[dim] = params.input_dims[dim];
+    }
+    for (int i = params.inner_dim_count; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      params.input_block_sizes[dim] = 1;
+    }
+    params.input_block_strides = internal::strides<Layout>(params.input_block_sizes);
+
+    // Broadcast with the 0-stride trick: Create 1 extra dim for each
+    // broadcast, set the input stride to 0.
+    //
+    // When ColMajor:
+    //
+    // - bcast_block_sizes:
+    //   [d_0, b_0, d_1, b_1, ...]
+    //
+    // - bcast_block_strides:
+    //   [output_block_strides[0], output_block_strides[0] * d_0,
+    //    output_block_strides[1], output_block_strides[1] * d_1,
+    //   ...]
+    //
+    // - bcast_input_strides:
+    //   [input_block_strides[0], 0,
+    //    input_block_strides[1], 0,
+    //   ...].
+    //
+    for (int i = 0; i < params.inner_dim_count; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+
+      const int copy_dim = IsColMajor ? 2 * i : 2 * NumDims - 2 * i - 1;
+      const int broadcast_dim = IsColMajor ? copy_dim + 1 : copy_dim - 1;
+
+      params.bcast_block_sizes[copy_dim] = params.input_dims[dim];
+      params.bcast_block_sizes[broadcast_dim] = m_broadcast[dim];
+      params.bcast_block_strides[copy_dim] = params.output_strides[dim];
+      params.bcast_block_strides[broadcast_dim] = params.output_strides[dim] * params.input_dims[dim];
+      params.bcast_input_strides[copy_dim] = params.input_block_strides[dim];
+      params.bcast_input_strides[broadcast_dim] = 0;
+    }
+
+    for (int i = 2 * params.inner_dim_count; i < 2 * NumDims; ++i) {
+      const int dim = IsColMajor ? i : 2 * NumDims - i - 1;
+      params.bcast_block_sizes[dim] = 1;
+      params.bcast_block_strides[dim] = 0;
+      params.bcast_input_strides[dim] = 0;
+    }
+
+    return params;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock emptyBlock() const {
+    DSizes<Index, NumDims> dimensions;
+    for (int i = 0; i < NumDims; ++i) dimensions[i] = 0;
+    return TensorBlock(internal::TensorBlockKind::kView, nullptr, dimensions);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index BroadcastBlockAlongBcastDim(
+      BlockBroadcastingParams params, Index bcast_offset, TensorBlockScratch& scratch,
+      ScalarNoConst* materialized_output, ScalarNoConst** materialized_input, size_t* materialized_input_size) const {
+    if (params.bcast_dim_size == 1) {
+      // We just need one block read using the ready-set values above.
+      return BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
+                            params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
+                            materialized_output, materialized_input, materialized_input_size);
+
+    } else if (params.input_dims[params.bcast_dim] == 1) {
+      // Broadcast bcast dimension (< NumDims) by bcast_dim_size.
+      const int broadcast_bcast_dim =
+          IsColMajor ? 2 * params.inner_dim_count + 1 : 2 * NumDims - 2 * params.inner_dim_count - 2;
+
+      params.bcast_block_sizes[broadcast_bcast_dim] = params.bcast_dim_size;
+      params.bcast_input_strides[broadcast_bcast_dim] = 0;
+      params.bcast_block_strides[broadcast_bcast_dim] = params.output_strides[params.bcast_dim];
+
+      return BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
+                            params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
+                            materialized_output, materialized_input, materialized_input_size);
+
+    } else {
+      // Keep track of the total number of the coefficients written to the
+      // output block.
+      Index num_output_coeffs = 0;
+
+      // The general case. Let's denote the output block as
+      //
+      //   x[..., a:a+bcast_dim_size, :, ..., :]
+      //
+      // where a:a+bcast_dim_size is a slice on the bcast_dim dimension
+      // (< NumDims). We need to split the a:a+bcast_dim_size into possibly 3
+      // sub-blocks:
+      //
+      // (1) a:b, where b is the smallest multiple of
+      //     input_dims[bcast_dim_start] in [a, a+bcast_dim_size].
+      //
+      // (2) b:c, where c is the largest multiple of input_dims[bcast_dim_start]
+      //     in [a, a+bcast_dim_size].
+      //
+      // (3) c:a+bcast_dim_size .
+      //
+      // Or, when b and c do not exist, we just need to process the whole block
+      // together.
+
+      // Find a.
+      const Index bcast_dim_left_index = bcast_offset / m_outputStrides[params.bcast_dim];
+
+      // Find b and c.
+      const Index input_bcast_dim_size = params.input_dims[params.bcast_dim];
+
+      // First multiple after a. This is b when <= bcast_dim_left_index +
+      // bcast_dim_size.
+      const Index first_multiple =
+          numext::div_ceil<Index>(bcast_dim_left_index, input_bcast_dim_size) * input_bcast_dim_size;
+
+      if (first_multiple <= bcast_dim_left_index + params.bcast_dim_size) {
+        // b exists, so does c. Find it.
+        const Index last_multiple =
+            (bcast_dim_left_index + params.bcast_dim_size) / input_bcast_dim_size * input_bcast_dim_size;
+        const int copy_bcast_dim =
+            IsColMajor ? 2 * params.inner_dim_count : 2 * NumDims - 2 * params.inner_dim_count - 1;
+        const int broadcast_bcast_dim =
+            IsColMajor ? 2 * params.inner_dim_count + 1 : 2 * NumDims - 2 * params.inner_dim_count - 2;
+
+        if (first_multiple > bcast_dim_left_index) {
+          const Index head_size = first_multiple - bcast_dim_left_index;
+          params.input_block_sizes[params.bcast_dim] = head_size;
+          params.bcast_block_sizes[copy_bcast_dim] = head_size;
+          params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
+          params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
+          params.bcast_block_sizes[broadcast_bcast_dim] = 1;
+          params.bcast_input_strides[broadcast_bcast_dim] = 0;
+          params.bcast_block_strides[broadcast_bcast_dim] =
+              params.output_strides[params.bcast_dim] * params.input_dims[params.bcast_dim];
+
+          num_output_coeffs +=
+              BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
+                             params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
+                             materialized_output, materialized_input, materialized_input_size);
+        }
+        if (first_multiple < last_multiple) {
+          params.input_block_sizes[params.bcast_dim] = input_bcast_dim_size;
+          params.bcast_block_sizes[copy_bcast_dim] = input_bcast_dim_size;
+          params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
+          params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
+          params.bcast_block_sizes[broadcast_bcast_dim] = (last_multiple - first_multiple) / input_bcast_dim_size;
+          params.bcast_input_strides[broadcast_bcast_dim] = 0;
+          params.bcast_block_strides[broadcast_bcast_dim] =
+              params.output_strides[params.bcast_dim] * params.input_dims[params.bcast_dim];
+          const Index offset = (first_multiple - bcast_dim_left_index) * m_outputStrides[params.bcast_dim];
+
+          num_output_coeffs +=
+              BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
+                             params.bcast_block_strides, params.bcast_input_strides, bcast_offset, offset, scratch,
+                             materialized_output, materialized_input, materialized_input_size);
+        }
+        if (last_multiple < bcast_dim_left_index + params.bcast_dim_size) {
+          const Index tail_size = bcast_dim_left_index + params.bcast_dim_size - last_multiple;
+          params.input_block_sizes[params.bcast_dim] = tail_size;
+          params.bcast_block_sizes[copy_bcast_dim] = tail_size;
+          params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
+          params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
+          params.bcast_block_sizes[broadcast_bcast_dim] = 1;
+          params.bcast_input_strides[broadcast_bcast_dim] = 0;
+          params.bcast_block_strides[broadcast_bcast_dim] =
+              params.output_strides[params.bcast_dim] * params.input_dims[params.bcast_dim];
+          const Index offset = (last_multiple - bcast_dim_left_index) * m_outputStrides[params.bcast_dim];
+
+          num_output_coeffs +=
+              BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
+                             params.bcast_block_strides, params.bcast_input_strides, bcast_offset, offset, scratch,
+                             materialized_output, materialized_input, materialized_input_size);
+        }
+      } else {
+        // b and c do not exist.
+        const int copy_bcast_dim =
+            IsColMajor ? 2 * params.inner_dim_count : 2 * NumDims - 2 * params.inner_dim_count - 1;
+        params.input_block_sizes[params.bcast_dim] = params.bcast_dim_size;
+        params.bcast_block_sizes[copy_bcast_dim] = params.bcast_dim_size;
+        params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
+        params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
+
+        num_output_coeffs +=
+            BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
+                           params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
+                           materialized_output, materialized_input, materialized_input_size);
+      }
+
+      return num_output_coeffs;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index BroadcastBlock(
+      const Dimensions& input_block_sizes, const Dimensions& input_block_strides,
+      const BroadcastDimensions& bcast_block_sizes, const BroadcastDimensions& bcast_block_strides,
+      const BroadcastDimensions& bcast_input_strides, Index bcast_offset, Index offset, TensorBlockScratch& scratch,
+      ScalarNoConst* materialized_output, ScalarNoConst** materialized_input, size_t* materialized_input_size) const {
+    // ---------------------------------------------------------------------- //
+    // Tensor block descriptor for reading block from the input.
+    const Index input_offset = bcast_offset + offset;
+    TensorBlockDesc input_desc(IsColMajor ? indexColMajor(input_offset) : indexRowMajor(input_offset),
+                               input_block_sizes);
+
+    ArgTensorBlock input_block = m_impl.block(input_desc, scratch);
+
+    // ---------------------------------------------------------------------- //
+    // Materialize input block into a temporary memory buffer only if it's not
+    // already available in the arg block.
+    const ScalarNoConst* input_buffer = nullptr;
+
+    if (input_block.data() != nullptr) {
+      // Input block already has raw data, there is no need to materialize it.
+      input_buffer = input_block.data();
+
+    } else {
+      // Otherwise we have to do block assignment into a temporary buffer.
+
+      // Maybe reuse previously allocated buffer, or allocate a new one with a
+      // scratch allocator.
+      const size_t input_total_size = input_block_sizes.TotalSize();
+      if (*materialized_input == nullptr || *materialized_input_size < input_total_size) {
+        *materialized_input_size = input_total_size;
+        void* mem = scratch.allocate(*materialized_input_size * sizeof(Scalar));
+        *materialized_input = static_cast<ScalarNoConst*>(mem);
+      }
+
+      typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename ArgTensorBlock::XprType, Index>
+          TensorBlockAssignment;
+
+      TensorBlockAssignment::Run(
+          TensorBlockAssignment::target(input_block_sizes, input_block_strides, *materialized_input),
+          input_block.expr());
+
+      input_buffer = *materialized_input;
+    }
+
+    // ---------------------------------------------------------------------- //
+    // Copy data from materialized input block to the materialized output, using
+    // given broadcast strides (strides with zeroes).
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, 2 * NumDims, Layout> TensorBlockIO;
+
+    typename TensorBlockIO::Src src(bcast_input_strides, input_buffer);
+    typename TensorBlockIO::Dst dst(bcast_block_sizes, bcast_block_strides, materialized_output + offset);
+
+    return TensorBlockIO::Copy(dst, src);
+  }
+
+ protected:
+  const Device EIGEN_DEVICE_REF m_device;
+  const std::remove_reference_t<Broadcast> m_broadcast;
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_outputStrides;
+  array<Index, NumDims> m_inputStrides;
+  TensorEvaluator<ArgType, Device> m_impl;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_BROADCASTING_H
diff --git a/contrib/Eigen/src/Tensor/TensorChipping.h b/contrib/Eigen/src/Tensor/TensorChipping.h
new file mode 100644
index 0000000..188ae92
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorChipping.h
@@ -0,0 +1,508 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CHIPPING_H
+#define EIGEN_TENSOR_TENSOR_CHIPPING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <DenseIndex DimId, typename XprType>
+struct traits<TensorChippingOp<DimId, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions - 1;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <DenseIndex DimId, typename XprType>
+struct eval<TensorChippingOp<DimId, XprType>, Eigen::Dense> {
+  typedef const TensorChippingOp<DimId, XprType> EIGEN_DEVICE_REF type;
+};
+
+template <DenseIndex DimId>
+struct DimensionId {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DimensionId(DenseIndex dim) {
+    EIGEN_UNUSED_VARIABLE(dim);
+    eigen_assert(dim == DimId);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex actualDim() const { return DimId; }
+};
+template <>
+struct DimensionId<Dynamic> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DimensionId(DenseIndex dim) : actual_dim(dim) { eigen_assert(dim >= 0); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex actualDim() const { return actual_dim; }
+
+ private:
+  const DenseIndex actual_dim;
+};
+
+}  // end namespace internal
+
+/** A chip is a thin slice, corresponding to a column or a row in a 2-d tensor.
+ * \ingroup Tensor_Module
+ */
+template <DenseIndex DimId, typename XprType>
+class TensorChippingOp : public TensorBase<TensorChippingOp<DimId, XprType> > {
+ public:
+  typedef TensorBase<TensorChippingOp<DimId, XprType> > Base;
+  typedef typename Eigen::internal::traits<TensorChippingOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorChippingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorChippingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorChippingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorChippingOp(const XprType& expr, const Index offset, const Index dim)
+      : m_xpr(expr), m_offset(offset), m_dim(dim) {
+    eigen_assert(dim < XprType::NumDimensions && dim >= 0 && "Chip_Dim_out_of_range");
+  }
+
+  EIGEN_DEVICE_FUNC const Index offset() const { return m_offset; }
+  EIGEN_DEVICE_FUNC const Index dim() const { return m_dim.actualDim(); }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorChippingOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Index m_offset;
+  const internal::DimensionId<DimId> m_dim;
+};
+
+// Eval as rvalue
+template <DenseIndex DimId, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device> {
+  typedef TensorChippingOp<DimId, ArgType> XprType;
+  static constexpr int NumInputDims =
+      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  static constexpr int NumDims = NumInputDims - 1;
+  typedef typename XprType::Index Index;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+
+  enum {
+    // Alignment can't be guaranteed at compile time since it depends on the
+    // slice offsets.
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
+    // Chipping of outer-most dimension is a trivial operation, because we can
+    // read and write directly from the underlying tensor using a single offset.
+    IsOuterChipping = (Layout == ColMajor && DimId == NumInputDims - 1) || (Layout == RowMajor && DimId == 0),
+    // Chipping inner-most dimension.
+    IsInnerChipping = (Layout == ColMajor && DimId == 0) || (Layout == RowMajor && DimId == NumInputDims - 1),
+    // Prefer block access if the underlying expression prefers it, otherwise
+    // only if chipping is not trivial.
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess || !IsOuterChipping,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef internal::TensorBlockDescriptor<NumInputDims, Index> ArgTensorBlockDesc;
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_dim(op.dim()), m_device(device) {
+    EIGEN_STATIC_ASSERT((NumInputDims >= 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    eigen_assert(NumInputDims > m_dim.actualDim() && op.offset() < input_dims[m_dim.actualDim()]);
+
+    int j = 0;
+    for (int i = 0; i < NumInputDims; ++i) {
+      if (i != m_dim.actualDim()) {
+        m_dimensions[j] = input_dims[i];
+        ++j;
+      }
+    }
+
+    m_stride = 1;
+    m_inputStride = 1;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = 0; i < m_dim.actualDim(); ++i) {
+        m_stride *= input_dims[i];
+        m_inputStride *= input_dims[i];
+      }
+    } else {
+      for (int i = NumInputDims - 1; i > m_dim.actualDim(); --i) {
+        m_stride *= input_dims[i];
+        m_inputStride *= input_dims[i];
+      }
+    }
+    m_inputStride *= input_dims[m_dim.actualDim()];
+    m_inputOffset = m_stride * op.offset();
+
+    // Check if chipping is effectively inner or outer: product of dimensions
+    // before or after the chipped dimension is `1`.
+    Index after_chipped_dim_product = 1;
+    for (int i = static_cast<int>(m_dim.actualDim()) + 1; i < NumInputDims; ++i) {
+      after_chipped_dim_product *= input_dims[i];
+    }
+
+    Index before_chipped_dim_product = 1;
+    for (int i = 0; i < m_dim.actualDim(); ++i) {
+      before_chipped_dim_product *= input_dims[i];
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_isEffectivelyInnerChipping = before_chipped_dim_product == 1;
+      m_isEffectivelyOuterChipping = after_chipped_dim_product == 1;
+    } else {
+      m_isEffectivelyInnerChipping = after_chipped_dim_product == 1;
+      m_isEffectivelyOuterChipping = before_chipped_dim_product == 1;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType /*data*/, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    return m_impl.coeff(srcCoeff(index));
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    EIGEN_IF_CONSTEXPR (IsInnerChipping) {
+      return packetInnerChipping<LoadMode>(index);
+    } else EIGEN_IF_CONSTEXPR (IsOuterChipping) {
+      return packetOuterChipping<LoadMode>(index);
+    } else if (m_isEffectivelyInnerChipping) {
+      return packetInnerChipping<LoadMode>(index);
+    } else if (m_isEffectivelyOuterChipping) {
+      return packetOuterChipping<LoadMode>(index);
+    } else {
+      const Index idx = index / m_stride;
+      const Index rem = index - idx * m_stride;
+      if (rem + PacketSize <= m_stride) {
+        Index inputIndex = idx * m_inputStride + m_inputOffset + rem;
+        return m_impl.template packet<LoadMode>(inputIndex);
+      } else {
+        // Cross the stride boundary. Fallback to slow path.
+        EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+        std::remove_const_t<CoeffReturnType> values[PacketSize];
+        EIGEN_UNROLL_LOOP
+        for (int i = 0; i < PacketSize; ++i) {
+          values[i] = coeff(index);
+          ++index;
+        }
+        PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+        return rslt;
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    double cost = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      if (m_dim.actualDim() == 0) {
+        cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
+      } else if (m_dim.actualDim() == NumInputDims - 1) {
+        cost += TensorOpCost::AddCost<Index>();
+      } else {
+        cost +=
+            3 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>() + 3 * TensorOpCost::AddCost<Index>();
+      }
+    } else {
+      if (m_dim.actualDim() == NumInputDims - 1) {
+        cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
+      } else if (m_dim.actualDim() == 0) {
+        cost += TensorOpCost::AddCost<Index>();
+      } else {
+        cost +=
+            3 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>() + 3 * TensorOpCost::AddCost<Index>();
+      }
+    }
+
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.lastLevelCacheSize();
+    return internal::TensorBlockResourceRequirements::merge(
+        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size), m_impl.getResourceRequirements());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool root_of_expr_ast = false) const {
+    const Index chip_dim = m_dim.actualDim();
+
+    DSizes<Index, NumInputDims> input_block_dims;
+    input_block_dims[chip_dim] = 1;
+    for (int i = 0; i < NumDims; ++i) {
+      input_block_dims[i < chip_dim ? i : i + 1] = desc.dimension(i);
+    }
+
+    ArgTensorBlockDesc arg_desc(srcCoeff(desc.offset()), input_block_dims);
+
+    // Try to reuse destination buffer for materializing argument block.
+    if (desc.HasDestinationBuffer()) {
+      DSizes<Index, NumInputDims> arg_destination_strides;
+      arg_destination_strides[chip_dim] = 0;  // The size-one chipped dimension does not use its stride.
+      for (int i = 0; i < NumDims; ++i) {
+        arg_destination_strides[i < chip_dim ? i : i + 1] = desc.destination().strides()[i];
+      }
+
+      arg_desc.template AddDestinationBuffer<Layout>(desc.destination().template data<ScalarNoConst>(),
+                                                     arg_destination_strides);
+    }
+
+    ArgTensorBlock arg_block = m_impl.block(arg_desc, scratch, root_of_expr_ast);
+    if (!arg_desc.HasDestinationBuffer()) desc.DropDestinationBuffer();
+
+    if (arg_block.data() != nullptr) {
+      // Forward argument block buffer if possible.
+      return TensorBlock(arg_block.kind(), arg_block.data(), desc.dimensions());
+
+    } else {
+      // Assign argument block expression to a buffer.
+
+      // Prepare storage for the materialized chipping result.
+      const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+
+      typedef internal::TensorBlockAssignment<ScalarNoConst, NumInputDims, typename ArgTensorBlock::XprType, Index>
+          TensorBlockAssignment;
+
+      TensorBlockAssignment::Run(
+          TensorBlockAssignment::target(arg_desc.dimensions(), internal::strides<Layout>(arg_desc.dimensions()),
+                                        block_storage.data()),
+          arg_block.expr());
+
+      return block_storage.AsTensorMaterializedBlock();
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Storage::Type data() const {
+    typename Storage::Type result = constCast(m_impl.data());
+    if (isOuterChipping() && result) {
+      return result + m_inputOffset;
+    } else {
+      return nullptr;
+    }
+  }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
+    EIGEN_IF_CONSTEXPR (IsInnerChipping) {
+      return srcCoeffInnerChipping(index);
+    } else EIGEN_IF_CONSTEXPR (IsOuterChipping) {
+      return srcCoeffOuterChipping(index);
+    } else if (m_isEffectivelyInnerChipping) {
+      return srcCoeffInnerChipping(index);
+    } else if (m_isEffectivelyOuterChipping) {
+      return srcCoeffOuterChipping(index);
+    } else {
+      const Index idx = index / m_stride;
+      Index inputIndex = idx * m_inputStride + m_inputOffset;
+      index -= idx * m_stride;
+      inputIndex += index;
+      return inputIndex;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeffInnerChipping(Index index) const {
+    // m_stride is equal to 1, so let's avoid the integer division.
+    eigen_assert(m_stride == 1);
+    return index * m_inputStride + m_inputOffset;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeffOuterChipping(Index index) const {
+    // m_stride is always greater than index, so let's avoid the integer division.
+    eigen_assert(m_stride > index);
+    return index + m_inputOffset;
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetInnerChipping(Index index) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    Index inputIndex = srcCoeffInnerChipping(index);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = m_impl.coeff(inputIndex);
+      inputIndex += m_inputStride;
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetOuterChipping(Index index) const {
+    return m_impl.template packet<LoadMode>(srcCoeffOuterChipping(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool isInnerChipping() const {
+    return IsInnerChipping || m_isEffectivelyInnerChipping;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool isOuterChipping() const {
+    return IsOuterChipping || m_isEffectivelyOuterChipping;
+  }
+
+  Dimensions m_dimensions;
+  Index m_stride;
+  Index m_inputOffset;
+  Index m_inputStride;
+  TensorEvaluator<ArgType, Device> m_impl;
+  const internal::DimensionId<DimId> m_dim;
+  const Device EIGEN_DEVICE_REF m_device;
+
+  // If product of all dimensions after or before the chipped dimension is `1`,
+  // it is effectively the same as chipping innermost or outermost dimension.
+  bool m_isEffectivelyInnerChipping;
+  bool m_isEffectivelyOuterChipping;
+};
+
+// Eval as lvalue
+template <DenseIndex DimId, typename ArgType, typename Device>
+struct TensorEvaluator<TensorChippingOp<DimId, ArgType>, Device>
+    : public TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device> Base;
+  typedef TensorChippingOp<DimId, ArgType> XprType;
+  static constexpr int NumInputDims =
+      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  static constexpr int NumDims = NumInputDims - 1;
+  typedef typename XprType::Index Index;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    Layout = TensorEvaluator<ArgType, Device>::Layout,
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    return this->m_impl.coeffRef(this->srcCoeff(index));
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    EIGEN_IF_CONSTEXPR (Base::IsInnerChipping) {
+      writePacketInnerChipping<StoreMode>(index, x);
+    } else EIGEN_IF_CONSTEXPR (Base::IsOuterChipping) {
+      writePacketOuterChipping<StoreMode>(index, x);
+    } else if (this->m_isEffectivelyInnerChipping) {
+      writePacketInnerChipping<StoreMode>(index, x);
+    } else if (this->m_isEffectivelyOuterChipping) {
+      writePacketOuterChipping<StoreMode>(index, x);
+    } else {
+      const Index idx = index / this->m_stride;
+      const Index rem = index - idx * this->m_stride;
+      if (rem + PacketSize <= this->m_stride) {
+        const Index inputIndex = idx * this->m_inputStride + this->m_inputOffset + rem;
+        this->m_impl.template writePacket<StoreMode>(inputIndex, x);
+      } else {
+        // Cross stride boundary. Fallback to slow path.
+        EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+        std::remove_const_t<CoeffReturnType> values[PacketSize];
+        internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+        EIGEN_UNROLL_LOOP
+        for (int i = 0; i < PacketSize; ++i) {
+          this->coeffRef(index) = values[i];
+          ++index;
+        }
+      }
+    }
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(this->m_impl.data() != nullptr);
+
+    const Index chip_dim = this->m_dim.actualDim();
+
+    DSizes<Index, NumInputDims> input_block_dims;
+    input_block_dims[chip_dim] = 1;
+    for (int i = 0; i < NumDims; ++i) {
+      input_block_dims[i < chip_dim ? i : i + 1] = desc.dimension(i);
+    }
+
+    typedef TensorReshapingOp<const DSizes<Index, NumInputDims>, const typename TensorBlock::XprType> TensorBlockExpr;
+
+    typedef internal::TensorBlockAssignment<Scalar, NumInputDims, TensorBlockExpr, Index> TensorBlockAssign;
+
+    TensorBlockAssign::Run(
+        TensorBlockAssign::target(input_block_dims, internal::strides<Layout>(this->m_impl.dimensions()),
+                                  this->m_impl.data(), this->srcCoeff(desc.offset())),
+        block.expr().reshape(input_block_dims));
+  }
+
+ private:
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacketInnerChipping(Index index, const PacketReturnType& x) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+    Index inputIndex = this->srcCoeffInnerChipping(index);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      this->m_impl.coeffRef(inputIndex) = values[i];
+      inputIndex += this->m_inputStride;
+    }
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacketOuterChipping(Index index, const PacketReturnType& x) const {
+    this->m_impl.template writePacket<StoreMode>(this->srcCoeffOuterChipping(index), x);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CHIPPING_H
diff --git a/contrib/Eigen/src/Tensor/TensorConcatenation.h b/contrib/Eigen/src/Tensor/TensorConcatenation.h
new file mode 100644
index 0000000..4792647
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorConcatenation.h
@@ -0,0 +1,707 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONCATENATION_H
+#define EIGEN_TENSOR_TENSOR_CONCATENATION_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Axis, typename LhsXprType, typename RhsXprType>
+struct traits<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>> {
+  // Type promotion to handle the case where the types of the lhs and the rhs are different.
+  typedef typename promote_storage_type<typename LhsXprType::Scalar, typename RhsXprType::Scalar>::ret Scalar;
+  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
+                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
+  typedef
+      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
+  static constexpr int NumDimensions = traits<LhsXprType>::NumDimensions;
+  static constexpr int Layout = traits<LhsXprType>::Layout;
+  enum { Flags = 0 };
+  typedef std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
+                             typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>
+      PointerType;
+};
+
+template <typename Axis, typename LhsXprType, typename RhsXprType>
+struct eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, Eigen::Dense> {
+  typedef const TensorConcatenationOp<Axis, LhsXprType, RhsXprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor concatenation class.
+ */
+template <typename Axis, typename LhsXprType, typename RhsXprType>
+class TensorConcatenationOp : public TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors> {
+ public:
+  typedef TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors> Base;
+  typedef typename internal::traits<TensorConcatenationOp>::Scalar Scalar;
+  typedef typename internal::traits<TensorConcatenationOp>::StorageKind StorageKind;
+  typedef typename internal::traits<TensorConcatenationOp>::Index Index;
+  typedef typename internal::ref_selector<TensorConcatenationOp>::type Nested;
+  typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
+                                                  typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConcatenationOp(const LhsXprType& lhs, const RhsXprType& rhs, Axis axis)
+      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_axis(axis) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
+    return m_lhs_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
+    return m_rhs_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const Axis& axis() const { return m_axis; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorConcatenationOp)
+ protected:
+  typename LhsXprType::Nested m_lhs_xpr;
+  typename RhsXprType::Nested m_rhs_xpr;
+  const Axis m_axis;
+};
+
+// Eval as rvalue
+template <typename Axis, typename LeftArgType, typename RightArgType, typename Device>
+struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> {
+  typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
+  static constexpr int RightNumDims =
+      internal::array_size<typename TensorEvaluator<RightArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess =
+        TensorEvaluator<LeftArgType, Device>::PacketAccess && TensorEvaluator<RightArgType, Device>::PacketAccess,
+    // block() reads each operand's data() pointer directly, so both must
+    // expose raw storage. Scalar-changing block consumers
+    // (TensorCwiseUnaryOp, TensorConversionOp) drop the forwarded destination
+    // buffer before reaching us, so prepareStorage always sees either a
+    // matching-Scalar buffer or no buffer at all.
+    BlockAccess = TensorEvaluator<LeftArgType, Device>::RawAccess && TensorEvaluator<RightArgType, Device>::RawAccess,
+    // Matches TensorShuffling / TensorBroadcasting / TensorPadding: bulk copy
+    // wins over the per-element coeff/packet path (which pays div/mod per
+    // access) at every size we benchmarked, so always prefer block.
+    PreferBlockAccess = true,
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_leftImpl(op.lhsExpression(), device),
+        m_rightImpl(op.rhsExpression(), device),
+        m_device(device),
+        m_axis(op.axis()) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
+                             static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) ||
+                         NumDims == 1),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+    // TensorConcatenationOp requires both operands to have the same static
+    // rank. Reshape the lower-rank operand explicitly if you need to mix
+    // ranks; see the concatenate() entry in contrib/Eigen/src/Tensor/README.md.
+    EIGEN_STATIC_ASSERT((NumDims == RightNumDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    eigen_assert(0 <= m_axis && m_axis < NumDims);
+    m_leftAxisSize = m_leftImpl.dimensions()[m_axis];
+    const Dimensions& lhs_dims = m_leftImpl.dimensions();
+    const Dimensions& rhs_dims = m_rightImpl.dimensions();
+    {
+      int i = 0;
+      for (; i < m_axis; ++i) {
+        eigen_assert(lhs_dims[i] > 0);
+        eigen_assert(lhs_dims[i] == rhs_dims[i]);
+        m_dimensions[i] = lhs_dims[i];
+      }
+      eigen_assert(lhs_dims[i] > 0);  // Now i == m_axis.
+      eigen_assert(rhs_dims[i] > 0);
+      m_dimensions[i] = lhs_dims[i] + rhs_dims[i];
+      for (++i; i < NumDims; ++i) {
+        eigen_assert(lhs_dims[i] > 0);
+        eigen_assert(lhs_dims[i] == rhs_dims[i]);
+        m_dimensions[i] = lhs_dims[i];
+      }
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_leftStrides[0] = 1;
+      m_rightStrides[0] = 1;
+      m_outputStrides[0] = 1;
+
+      for (int j = 1; j < NumDims; ++j) {
+        m_leftStrides[j] = m_leftStrides[j - 1] * lhs_dims[j - 1];
+        m_rightStrides[j] = m_rightStrides[j - 1] * rhs_dims[j - 1];
+        m_outputStrides[j] = m_outputStrides[j - 1] * m_dimensions[j - 1];
+      }
+    } else {
+      m_leftStrides[NumDims - 1] = 1;
+      m_rightStrides[NumDims - 1] = 1;
+      m_outputStrides[NumDims - 1] = 1;
+
+      for (int j = NumDims - 2; j >= 0; --j) {
+        m_leftStrides[j] = m_leftStrides[j + 1] * lhs_dims[j + 1];
+        m_rightStrides[j] = m_rightStrides[j + 1] * rhs_dims[j + 1];
+        m_outputStrides[j] = m_outputStrides[j + 1] * m_dimensions[j + 1];
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  // TODO(phli): Add short-circuit memcpy evaluation if underlying data are linear.
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_leftImpl.evalSubExprsIfNeeded(nullptr);
+    m_rightImpl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_leftImpl.cleanup();
+    m_rightImpl.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    // Target the L1 cache. A block straddling the concat axis is materialized
+    // into a merged scratch slab that the cwise consumer reads straight back;
+    // sizing the block to L1 keeps that round-trip out of the last-level
+    // cache. It also splits an otherwise cache-resident output into many
+    // blocks, so the off-axis ones qualify for the zero-copy view path in
+    // block(). Matches TensorBroadcasting, which likewise targets L1 for its
+    // materialized block path.
+    const size_t target_size = m_device.firstLevelCacheSize();
+    return internal::TensorBlockResourceRequirements::merge(
+        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size),
+        internal::TensorBlockResourceRequirements::merge(m_leftImpl.getResourceRequirements(),
+                                                         m_rightImpl.getResourceRequirements()));
+  }
+
+  // True when a block of shape `block_dims` is a contiguous run of an operand
+  // whose shape is `operand_dims` -- i.e. it can be addressed as a plain
+  // pointer offset with no per-row stride walk. Mirrors the direct-access test
+  // in TensorMaterializedBlock::materialize().
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool isContiguousOperandSlab(const Dimensions& operand_dims,
+                                                                     const Dimensions& block_dims) const {
+    static constexpr bool IsColMajor = Layout == static_cast<int>(ColMajor);
+    int matching_inner_dims = 0;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      if (operand_dims[dim] != block_dims[dim]) break;
+      ++matching_inner_dims;
+    }
+    // Every dimension above the single partial dimension must be of size 1.
+    for (int i = matching_inner_dims + 1; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      if (block_dims[dim] != 1) return false;
+    }
+    return true;
+  }
+
+  // Returns a zero-copy view when the block lies within a single operand and
+  // is contiguous there; otherwise materializes the slab(s) with
+  // TensorBlockIO::Copy, which collapses to a memcpy per contiguous slab.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool root_of_expr_ast = false) const {
+    static constexpr bool IsColMajor = Layout == static_cast<int>(ColMajor);
+
+    if (desc.size() == 0) {
+      return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+    }
+
+    Index remaining = desc.offset();
+    DSizes<Index, NumDims> out_coords;
+    EIGEN_IF_CONSTEXPR (IsColMajor) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        out_coords[i] = remaining / m_outputStrides[i];
+        remaining -= out_coords[i] * m_outputStrides[i];
+      }
+      out_coords[0] = remaining;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        out_coords[i] = remaining / m_outputStrides[i];
+        remaining -= out_coords[i] * m_outputStrides[i];
+      }
+      out_coords[NumDims - 1] = remaining;
+    }
+
+    const Index axis_start = out_coords[m_axis];
+    const Index axis_size = desc.dimension(static_cast<int>(m_axis));
+    const Index axis_end = axis_start + axis_size;
+
+    // Fast path: a block that lies entirely within one operand and forms a
+    // contiguous run of its storage needs no copy at all -- return a view
+    // straight into A / B. This is what keeps a cwise expression that reads
+    // the concatenation (e.g. `(A.concatenate(B, axis) + C)`) streaming: a
+    // cwise consumer drops our destination buffer before calling block() (see
+    // TensorCwiseBinaryOp::block), so without the view the slab would be
+    // bounced through a scratch buffer and read straight back, doubling cache
+    // traffic. Straddling blocks still need the merged buffer materialized
+    // below.
+    if (axis_end <= m_leftAxisSize) {
+      if (isContiguousOperandSlab(m_leftImpl.dimensions(), desc.dimensions())) {
+        Index left_src_offset = 0;
+        for (int i = 0; i < NumDims; ++i) {
+          left_src_offset += out_coords[i] * m_leftStrides[i];
+        }
+        return TensorBlock(internal::TensorBlockKind::kView, m_leftImpl.data() + left_src_offset, desc.dimensions());
+      }
+    } else if (axis_start >= m_leftAxisSize) {
+      if (isContiguousOperandSlab(m_rightImpl.dimensions(), desc.dimensions())) {
+        Index right_src_offset = (axis_start - m_leftAxisSize) * m_rightStrides[m_axis];
+        for (int i = 0; i < NumDims; ++i) {
+          if (i != m_axis) {
+            right_src_offset += out_coords[i] * m_rightStrides[i];
+          }
+        }
+        return TensorBlock(internal::TensorBlockKind::kView, m_rightImpl.data() + right_src_offset, desc.dimensions());
+      }
+    }
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+
+    // Strided destination buffers are safe here because we only ever write
+    // dense slabs into them; allowing strided storage lets a root-of-AST
+    // assignment materialize directly into the output tensor.
+    typename TensorBlock::Storage block_storage =
+        TensorBlock::prepareStorage(desc, scratch, /*allow_strided_storage=*/root_of_expr_ast);
+
+    if (axis_start < m_leftAxisSize) {
+      const Index left_rows_in_block = numext::mini(m_leftAxisSize, axis_end) - axis_start;
+      DSizes<Index, NumDims> left_sub_dims = desc.dimensions();
+      left_sub_dims[m_axis] = left_rows_in_block;
+
+      Index left_src_offset = 0;
+      for (int i = 0; i < NumDims; ++i) {
+        left_src_offset += out_coords[i] * m_leftStrides[i];
+      }
+
+      typename TensorBlockIO::Dimensions left_strides(m_leftStrides);
+      TensorBlockIOSrc src(left_strides, m_leftImpl.data(), left_src_offset);
+      TensorBlockIODst dst(left_sub_dims, block_storage.strides(), block_storage.data(),
+                           /*dst_offset=*/0);
+      TensorBlockIO::Copy(dst, src);
+    }
+
+    if (axis_end > m_leftAxisSize) {
+      const Index right_rows_in_block = axis_end - numext::maxi(m_leftAxisSize, axis_start);
+      DSizes<Index, NumDims> right_sub_dims = desc.dimensions();
+      right_sub_dims[m_axis] = right_rows_in_block;
+
+      // Right operand has the same per-dim coords as out_coords except along
+      // the concat axis, where it starts at max(0, axis_start - left_size).
+      const Index right_axis_start = numext::maxi(Index(0), axis_start - m_leftAxisSize);
+      Index right_src_offset = right_axis_start * m_rightStrides[m_axis];
+      for (int i = 0; i < NumDims; ++i) {
+        if (i != m_axis) {
+          right_src_offset += out_coords[i] * m_rightStrides[i];
+        }
+      }
+
+      // Offset within the materialized buffer where the right-side slab starts.
+      const Index dst_axis_offset = numext::maxi(Index(0), m_leftAxisSize - axis_start);
+      const Index dst_offset = dst_axis_offset * block_storage.strides()[m_axis];
+
+      typename TensorBlockIO::Dimensions right_strides(m_rightStrides);
+      TensorBlockIOSrc src(right_strides, m_rightImpl.data(), right_src_offset);
+      TensorBlockIODst dst(right_sub_dims, block_storage.strides(), block_storage.data(), dst_offset);
+      TensorBlockIO::Copy(dst, src);
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  // The per-dim integer div/mod in this loop are the obvious "slow" candidates,
+  // but the same TensorIntDivisor substitution was measured net-negative on
+  // Intel Raptor Lake when prototyped for TensorBroadcasting (see the comment
+  // on TensorBroadcasting::indexColMajor). Modern x86 hardware div (~20
+  // cycles) amortizes well and the mul+shifts don't win back the added state.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    // Collect dimension-wise indices (subs).
+    array<Index, NumDims> subs;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        subs[i] = index / m_outputStrides[i];
+        index -= subs[i] * m_outputStrides[i];
+      }
+      subs[0] = index;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        subs[i] = index / m_outputStrides[i];
+        index -= subs[i] * m_outputStrides[i];
+      }
+      subs[NumDims - 1] = index;
+    }
+
+    const Dimensions& left_dims = m_leftImpl.dimensions();
+    if (subs[m_axis] < left_dims[m_axis]) {
+      Index left_index;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        left_index = subs[0];
+        EIGEN_UNROLL_LOOP
+        for (int i = 1; i < NumDims; ++i) {
+          left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
+        }
+      } else {
+        left_index = subs[NumDims - 1];
+        EIGEN_UNROLL_LOOP
+        for (int i = NumDims - 2; i >= 0; --i) {
+          left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
+        }
+      }
+      return m_leftImpl.coeff(left_index);
+    } else {
+      subs[m_axis] -= left_dims[m_axis];
+      const Dimensions& right_dims = m_rightImpl.dimensions();
+      Index right_index;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        right_index = subs[0];
+        EIGEN_UNROLL_LOOP
+        for (int i = 1; i < NumDims; ++i) {
+          right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
+        }
+      } else {
+        right_index = subs[NumDims - 1];
+        EIGEN_UNROLL_LOOP
+        for (int i = NumDims - 2; i >= 0; --i) {
+          right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
+        }
+      }
+      return m_rightImpl.coeff(right_index);
+    }
+  }
+
+  // When the packet sits entirely on one side of the concat boundary, delegate
+  // to that operand's packet<>() rather than assembling PacketSize coeff()
+  // calls. The packet stays on one side iff only the innermost dim varies
+  // across the packet -- i.e. all other subs match between the first and last
+  // index. When that holds, subs[m_axis] is either constant (m_axis is not
+  // innermost) or monotonic non-decreasing (m_axis is innermost), so checking
+  // just the endpoints decides the side. Otherwise subs[m_axis] can wrap back
+  // through the boundary mid-packet (as when the inner dim has fewer than
+  // PacketSize elements and the packet spills past the concat axis), so fall
+  // back to scalars.
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    const int packetSize = PacketType<CoeffReturnType, Device>::size;
+    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
+
+    array<Index, NumDims> subs;
+    array<Index, NumDims> subs_end;
+    Index remaining = index;
+    Index remaining_end = index + packetSize - 1;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        subs[i] = remaining / m_outputStrides[i];
+        remaining -= subs[i] * m_outputStrides[i];
+        subs_end[i] = remaining_end / m_outputStrides[i];
+        remaining_end -= subs_end[i] * m_outputStrides[i];
+      }
+      subs[0] = remaining;
+      subs_end[0] = remaining_end;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        subs[i] = remaining / m_outputStrides[i];
+        remaining -= subs[i] * m_outputStrides[i];
+        subs_end[i] = remaining_end / m_outputStrides[i];
+        remaining_end -= subs_end[i] * m_outputStrides[i];
+      }
+      subs[NumDims - 1] = remaining;
+      subs_end[NumDims - 1] = remaining_end;
+    }
+
+    const Dimensions& left_dims = m_leftImpl.dimensions();
+    const Index left_axis_size = left_dims[m_axis];
+
+    constexpr int innermost = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    bool packet_in_single_inner_row = true;
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < NumDims; ++i) {
+      if (i != innermost && subs[i] != subs_end[i]) {
+        packet_in_single_inner_row = false;
+      }
+    }
+
+    const bool on_left =
+        packet_in_single_inner_row && subs[m_axis] < left_axis_size && subs_end[m_axis] < left_axis_size;
+    const bool on_right =
+        packet_in_single_inner_row && subs[m_axis] >= left_axis_size && subs_end[m_axis] >= left_axis_size;
+
+    if (on_left) {
+      Index left_index;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        left_index = subs[0];
+        EIGEN_UNROLL_LOOP
+        for (int i = 1; i < NumDims; ++i) {
+          left_index += subs[i] * m_leftStrides[i];
+        }
+      } else {
+        left_index = subs[NumDims - 1];
+        EIGEN_UNROLL_LOOP
+        for (int i = NumDims - 2; i >= 0; --i) {
+          left_index += subs[i] * m_leftStrides[i];
+        }
+      }
+      return m_leftImpl.template packet<LoadMode>(left_index);
+    }
+    if (on_right) {
+      subs[m_axis] -= left_axis_size;
+      Index right_index;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        right_index = subs[0];
+        EIGEN_UNROLL_LOOP
+        for (int i = 1; i < NumDims; ++i) {
+          right_index += subs[i] * m_rightStrides[i];
+        }
+      } else {
+        right_index = subs[NumDims - 1];
+        EIGEN_UNROLL_LOOP
+        for (int i = NumDims - 2; i >= 0; --i) {
+          right_index += subs[i] * m_rightStrides[i];
+        }
+      }
+      return m_rightImpl.template packet<LoadMode>(right_index);
+    }
+
+    // The packet straddles the boundary or spans multiple inner rows: fall
+    // back to assembling scalars.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) CoeffReturnType values[packetSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < packetSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
+                                           TensorOpCost::DivCost<Index>() + TensorOpCost::ModCost<Index>());
+    const double lhs_size = m_leftImpl.dimensions().TotalSize();
+    const double rhs_size = m_rightImpl.dimensions().TotalSize();
+    return (lhs_size / (lhs_size + rhs_size)) * m_leftImpl.costPerCoeff(vectorized) +
+           (rhs_size / (lhs_size + rhs_size)) * m_rightImpl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ protected:
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_outputStrides;
+  array<Index, NumDims> m_leftStrides;
+  array<Index, NumDims> m_rightStrides;
+  TensorEvaluator<LeftArgType, Device> m_leftImpl;
+  TensorEvaluator<RightArgType, Device> m_rightImpl;
+  const Device EIGEN_DEVICE_REF m_device;
+  const Axis m_axis;
+  Index m_leftAxisSize;
+};
+
+// Eval as lvalue
+template <typename Axis, typename LeftArgType, typename RightArgType, typename Device>
+struct TensorEvaluator<TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
+    : public TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> {
+  typedef TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> Base;
+  typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
+  typedef typename Base::Dimensions Dimensions;
+  static constexpr int NumDims = Base::NumDims;
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess =
+        TensorEvaluator<LeftArgType, Device>::PacketAccess && TensorEvaluator<RightArgType, Device>::PacketAccess,
+    // writeBlock() splits the block at the concat axis and copies each piece
+    // straight into the operand's buffer, so both must expose raw storage.
+    BlockAccess = TensorEvaluator<LeftArgType, Device>::RawAccess && TensorEvaluator<RightArgType, Device>::RawAccess,
+    // The coeff/packet write path pays a div/mod cascade plus a per-dim mod
+    // for every scalar; the block path is a pair of bulk copies. Mirrors the
+    // rvalue evaluator.
+    PreferBlockAccess = true,
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<typename XprType::Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, typename XprType::Index> TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  // The ColMajor-only static_assert lives in coeffRef/writePacket rather than
+  // here so that passthrough evaluators (e.g. TensorSlicingOp's) can
+  // instantiate this type for RowMajor concat operands without ever calling
+  // its lvalue methods. writeBlock() below is layout-generic, so tiled
+  // assignments through a RowMajor concatenation are supported.
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    // Collect dimension-wise indices (subs).
+    array<Index, Base::NumDims> subs;
+    for (int i = Base::NumDims - 1; i > 0; --i) {
+      subs[i] = index / this->m_outputStrides[i];
+      index -= subs[i] * this->m_outputStrides[i];
+    }
+    subs[0] = index;
+
+    const Dimensions& left_dims = this->m_leftImpl.dimensions();
+    if (subs[this->m_axis] < left_dims[this->m_axis]) {
+      Index left_index = subs[0];
+      for (int i = 1; i < Base::NumDims; ++i) {
+        left_index += (subs[i] % left_dims[i]) * this->m_leftStrides[i];
+      }
+      return this->m_leftImpl.coeffRef(left_index);
+    } else {
+      subs[this->m_axis] -= left_dims[this->m_axis];
+      const Dimensions& right_dims = this->m_rightImpl.dimensions();
+      Index right_index = subs[0];
+      for (int i = 1; i < Base::NumDims; ++i) {
+        right_index += (subs[i] % right_dims[i]) * this->m_rightStrides[i];
+      }
+      return this->m_rightImpl.coeffRef(right_index);
+    }
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    const int packetSize = PacketType<CoeffReturnType, Device>::size;
+    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(index + packetSize - 1 < this->dimensions().TotalSize());
+
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) CoeffReturnType values[packetSize];
+    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+    for (int i = 0; i < packetSize; ++i) {
+      coeffRef(index + i) = values[i];
+    }
+  }
+
+  // Mirror of the rvalue block(): split the block at the concat axis and copy
+  // each piece into the corresponding operand's buffer.
+  template <typename TensorBlock>
+  EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    if (desc.size() == 0) return;
+    eigen_assert(this->m_leftImpl.data() != nullptr && this->m_rightImpl.data() != nullptr);
+
+    const DSizes<Index, NumDims> block_strides = internal::strides<Layout>(desc.dimensions());
+
+    // Materialize the block into a temporary buffer if it is lazy.
+    const ScalarNoConst* block_buffer = block.data();
+    void* mem = nullptr;
+    if (block_buffer == nullptr) {
+      mem = this->m_device.allocate(desc.size() * sizeof(Scalar));
+      ScalarNoConst* buf = static_cast<ScalarNoConst*>(mem);
+
+      typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename TensorBlock::XprType, Index>
+          TensorBlockAssignment;
+      TensorBlockAssignment::Run(TensorBlockAssignment::target(desc.dimensions(), block_strides, buf), block.expr());
+
+      block_buffer = buf;
+    }
+
+    // Decompose the block's offset into output coordinates.
+    Index remaining = desc.offset();
+    DSizes<Index, NumDims> out_coords;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        out_coords[i] = remaining / this->m_outputStrides[i];
+        remaining -= out_coords[i] * this->m_outputStrides[i];
+      }
+      out_coords[0] = remaining;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        out_coords[i] = remaining / this->m_outputStrides[i];
+        remaining -= out_coords[i] * this->m_outputStrides[i];
+      }
+      out_coords[NumDims - 1] = remaining;
+    }
+
+    const Index axis_start = out_coords[this->m_axis];
+    const Index axis_size = desc.dimension(static_cast<int>(this->m_axis));
+    const Index axis_end = axis_start + axis_size;
+    const Index left_axis_size = this->m_leftAxisSize;
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+
+    if (axis_start < left_axis_size) {
+      DSizes<Index, NumDims> left_sub_dims = desc.dimensions();
+      left_sub_dims[this->m_axis] = numext::mini(left_axis_size, axis_end) - axis_start;
+
+      Index left_dst_offset = 0;
+      for (int i = 0; i < NumDims; ++i) {
+        left_dst_offset += out_coords[i] * this->m_leftStrides[i];
+      }
+
+      TensorBlockIOSrc src(block_strides, block_buffer, /*src_offset=*/0);
+      TensorBlockIODst dst(left_sub_dims, typename TensorBlockIO::Dimensions(this->m_leftStrides),
+                           this->m_leftImpl.data(), left_dst_offset);
+      TensorBlockIO::Copy(dst, src);
+    }
+
+    if (axis_end > left_axis_size) {
+      DSizes<Index, NumDims> right_sub_dims = desc.dimensions();
+      right_sub_dims[this->m_axis] = axis_end - numext::maxi(left_axis_size, axis_start);
+
+      const Index right_axis_start = numext::maxi(Index(0), axis_start - left_axis_size);
+      Index right_dst_offset = right_axis_start * this->m_rightStrides[this->m_axis];
+      for (int i = 0; i < NumDims; ++i) {
+        if (i != this->m_axis) {
+          right_dst_offset += out_coords[i] * this->m_rightStrides[i];
+        }
+      }
+
+      // Offset within the block buffer where the right-side piece starts.
+      const Index src_offset = numext::maxi(Index(0), left_axis_size - axis_start) * block_strides[this->m_axis];
+
+      TensorBlockIOSrc src(block_strides, block_buffer, src_offset);
+      TensorBlockIODst dst(right_sub_dims, typename TensorBlockIO::Dimensions(this->m_rightStrides),
+                           this->m_rightImpl.data(), right_dst_offset);
+      TensorBlockIO::Copy(dst, src);
+    }
+
+    // Deallocate temporary buffer used for the block materialization.
+    if (mem != nullptr) this->m_device.deallocate(mem);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONCATENATION_H
diff --git a/contrib/Eigen/src/Tensor/TensorContraction.h b/contrib/Eigen/src/Tensor/TensorContraction.h
new file mode 100644
index 0000000..4195f5b
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContraction.h
@@ -0,0 +1,1069 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Dimensions, typename LhsXprType, typename RhsXprType, typename OutputKernelType>
+struct traits<TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>> {
+  // Type promotion to handle the case where the types of the lhs and the rhs are different.
+  using Scalar = typename gebp_traits<std::remove_const_t<typename LhsXprType::Scalar>,
+                                      std::remove_const_t<typename RhsXprType::Scalar>>::ResScalar;
+
+  using StorageKind = typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
+                                                    typename traits<RhsXprType>::StorageKind>::ret;
+  using Index =
+      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type;
+  // From NumDims below.
+  static constexpr int NumDimensions =
+      traits<LhsXprType>::NumDimensions + traits<RhsXprType>::NumDimensions - 2 * array_size<Dimensions>::value;
+  static constexpr int Layout = traits<LhsXprType>::Layout;
+  using PointerType =
+      std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
+                         typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>;
+
+  static constexpr int Flags = 0;
+};
+
+template <typename Dimensions, typename LhsXprType, typename RhsXprType, typename OutputKernelType>
+struct eval<TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>, Eigen::Dense> {
+  using type = const TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>&;
+};
+
+template <typename Indices_, typename LeftArgType_, typename RightArgType_, typename OutputKernelType_,
+          typename Device_>
+struct traits<
+    TensorEvaluator<const TensorContractionOp<Indices_, LeftArgType_, RightArgType_, OutputKernelType_>, Device_>> {
+  using Indices = Indices_;
+  using LeftArgType = LeftArgType_;
+  using RightArgType = RightArgType_;
+  using OutputKernelType = OutputKernelType_;
+  using Device = Device_;
+
+  // From NumDims below.
+  static constexpr int NumDimensions =
+      traits<LeftArgType_>::NumDimensions + traits<RightArgType_>::NumDimensions - 2 * array_size<Indices_>::value;
+};
+
+// Helper class to allocate and deallocate temporary memory for packed buffers.
+template <typename LhsScalar, typename RhsScalar>
+struct TensorContractionBlockMemAllocator {
+  using BlockMemHandle = void*;
+
+  template <typename Device>
+  EIGEN_DEVICE_FUNC static BlockMemHandle allocate(Device& d, const Index bm, const Index bk, const Index bn,
+                                                   LhsScalar** lhs_block, RhsScalar** rhs_block) {
+    eigen_assert(lhs_block);
+    eigen_assert(rhs_block);
+    BlockSizes sz = ComputeLhsRhsBlockSizes(bm, bk, bn);
+    char* block_mem = static_cast<char*>(d.allocate(sz.lhs_size + sz.rhs_size));
+    *lhs_block = static_cast<LhsScalar*>(static_cast<void*>(block_mem));
+    *rhs_block = static_cast<RhsScalar*>(static_cast<void*>(block_mem + sz.lhs_size));
+    return block_mem;
+  }
+
+  template <typename Device>
+  EIGEN_DEVICE_FUNC static BlockMemHandle allocateSlices(Device& d, const Index bm, const Index bk, const Index bn,
+                                                         const Index num_lhs, const Index num_rhs,
+                                                         const Index num_slices, std::vector<LhsScalar*>* lhs_blocks,
+                                                         std::vector<RhsScalar*>* rhs_blocks) {
+    eigen_assert(num_slices > 0);
+    eigen_assert(num_lhs >= 0 && num_rhs >= 0);
+    eigen_assert(num_lhs == 0 || lhs_blocks);
+    eigen_assert(num_rhs == 0 || rhs_blocks);
+    BlockSizes sz = ComputeLhsRhsBlockSizes(bm, bk, bn);
+    void* block_mem = d.allocate((num_lhs * sz.lhs_size + num_rhs * sz.rhs_size) * num_slices);
+    eigen_assert(block_mem);
+    char* mem = static_cast<char*>(block_mem);
+
+    for (Index x = 0; x < num_slices; x++) {
+      if (num_lhs > 0) lhs_blocks[x].resize(num_lhs);
+      for (Index m = 0; m < num_lhs; m++) {
+        lhs_blocks[x][m] = static_cast<LhsScalar*>(static_cast<void*>(mem));
+        mem += sz.lhs_size;
+      }
+      if (num_rhs > 0) rhs_blocks[x].resize(num_rhs);
+      for (Index n = 0; n < num_rhs; n++) {
+        rhs_blocks[x][n] = static_cast<RhsScalar*>(static_cast<void*>(mem));
+        mem += sz.rhs_size;
+      }
+    }
+
+    return block_mem;
+  }
+
+  template <typename Device>
+  EIGEN_DEVICE_FUNC static void deallocate(Device& d, BlockMemHandle handle) {
+    d.deallocate(handle);
+  }
+
+ private:
+  struct BlockSizes {
+    Index lhs_size;
+    Index rhs_size;
+  };
+  EIGEN_DEVICE_FUNC static BlockSizes ComputeLhsRhsBlockSizes(const Index bm, const Index bk, const Index bn) {
+    Index align = numext::maxi(EIGEN_MAX_ALIGN_BYTES, 1);
+    BlockSizes sz;
+    sz.lhs_size = numext::div_ceil<Index>(bm * bk * sizeof(LhsScalar), align) * align;
+    sz.rhs_size = numext::div_ceil<Index>(bn * bk * sizeof(RhsScalar), align) * align;
+    return sz;
+  }
+};
+
+// WARNING: In this code we assume that Lhs and Rhs tensor expressions are in
+// ColMajor storage order. This property is guaranteed by the
+// TensorContractionOp evaluator. TensorContractionKernel specifies how we pack
+// blocks of Lhs and Rhs tensor expressions, and how we invoke matrix
+// multiplication for these blocks. Default tensor contraction uses
+// gemm_pack_rhs, gemm_pack_lhs and gebp_kernel from Eigen Core (see
+// GeneralBlockPanelKernel.h for details).
+//
+// By specializing contraction kernels we can use other low level libraries to
+// perform matrix multiplication, and still rely on Eigen contraction evaluator.
+// This also includes full support in TensorContractionThreadPool, assuming that
+// underlying gemm does not use its own threading.
+//
+// - ResScalar/LhsScalar/RhsScalar - scalar type for the result of
+//   multiplication, lhs tensor and rhs tensor respectively.
+//
+// - StorageIndex - index type for the tensor expressions. In practice almost
+//   always is Eigen::Index.
+//
+// - OutputMapper provides access to the memory of the output matrix. In
+//   practice it's always column major blas_data_mapper (it must be of ResScalar
+//   type).
+//
+// - LhsMapper/RhsMapper similarly to blas_data_mapper provide a two dimensional
+//   view into the Lhs/Rhs tensor expressions. In practice it's
+//   TensorContractionInputMapper, or some specialization of it based on the
+//   type of tensor expression (e.g. TensorImagePatchOp has optimized input
+//   mapper).
+template <typename ResScalar, typename LhsScalar, typename RhsScalar, typename StorageIndex, typename OutputMapper,
+          typename LhsMapper, typename RhsMapper>
+struct TensorContractionKernel {
+  // True if `invoke()` supports `beta` in `C <- alpha * A * B + beta * C`
+  // (otherwise beta should be always equal to 1).
+  static constexpr bool HasBeta = false;
+
+  EIGEN_DEVICE_FUNC TensorContractionKernel(StorageIndex m_, StorageIndex k_, StorageIndex n_, StorageIndex bm_,
+                                            StorageIndex bk_, StorageIndex bn_)
+      : m(m_), k(k_), n(n_), bm(bm_), bk(bk_), bn(bn_) {}
+
+  // Pack blocks of Lhs and Rhs into contiguous blocks in memory.
+  using LhsBlock = LhsScalar*;
+  using RhsBlock = RhsScalar*;
+
+  // Packed Lhs/Rhs block memory allocator.
+  using BlockMemAllocator = TensorContractionBlockMemAllocator<LhsScalar, RhsScalar>;
+  using BlockMemHandle = typename BlockMemAllocator::BlockMemHandle;
+
+  using Traits = typename internal::gebp_traits<LhsScalar, RhsScalar>;
+
+  using LhsPacker = internal::gemm_pack_lhs<LhsScalar, StorageIndex, typename LhsMapper::SubMapper, Traits::mr,
+                                            Traits::LhsProgress, typename Traits::LhsPacket4Packing, ColMajor>;
+
+  using RhsPacker =
+      internal::gemm_pack_rhs<RhsScalar, StorageIndex, typename RhsMapper::SubMapper, Traits::nr, ColMajor>;
+
+  using GebpKernel = internal::gebp_kernel<LhsScalar, RhsScalar, StorageIndex, OutputMapper, Traits::mr, Traits::nr,
+                                           /*ConjugateLhs*/ false, /*ConjugateRhs*/ false>;
+
+  template <typename Device>
+  EIGEN_DEVICE_FUNC BlockMemHandle allocate(Device& d, LhsBlock* lhs_block, RhsBlock* rhs_block) {
+    return BlockMemAllocator::allocate(d, bm, bk, bn, lhs_block, rhs_block);
+  }
+
+  template <typename Device>
+  EIGEN_DEVICE_FUNC BlockMemHandle allocateSlices(Device& d, const StorageIndex num_lhs, const StorageIndex num_rhs,
+                                                  const StorageIndex num_slices, std::vector<LhsBlock>* lhs_blocks,
+                                                  std::vector<RhsBlock>* rhs_blocks) {
+    return BlockMemAllocator::allocateSlices(d, bm, bk, bn, num_lhs, num_rhs, num_slices, lhs_blocks, rhs_blocks);
+  }
+
+  template <typename Device>
+  EIGEN_DEVICE_FUNC static void deallocate(Device& d, BlockMemHandle handle) {
+    BlockMemAllocator::deallocate(d, handle);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void packLhs(LhsBlock* lhsBlock, const typename LhsMapper::SubMapper& data_mapper,
+                                                   const StorageIndex depth, const StorageIndex rows) {
+    LhsPacker()(*lhsBlock, data_mapper, depth, rows, /*stride*/ 0,
+                /*offset*/ 0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void packRhs(RhsBlock* rhsBlock, const typename RhsMapper::SubMapper& data_mapper,
+                                                   const StorageIndex depth, const StorageIndex cols) {
+    RhsPacker()(*rhsBlock, data_mapper, depth, cols);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void invoke(const OutputMapper& output_mapper, const LhsBlock& lhsBlock,
+                                                  const RhsBlock& rhsBlock, const StorageIndex rows,
+                                                  const StorageIndex depth, const StorageIndex cols,
+                                                  const ResScalar alpha, const ResScalar beta) {
+    // Default GEBP kernel does not support beta.
+    EIGEN_ONLY_USED_FOR_DEBUG(beta);
+    eigen_assert(beta == ResScalar(1));
+    static constexpr int kComputeStrideFromBlockDimensions = -1;
+    GebpKernel()(output_mapper, lhsBlock, rhsBlock, rows, depth, cols, alpha,
+                 /*strideA*/ kComputeStrideFromBlockDimensions,
+                 /*strideB*/ kComputeStrideFromBlockDimensions,
+                 /*offsetA*/ 0, /*offsetB*/ 0);
+  }
+
+ private:
+  // These are dimensions of the original Tensors, and selected block sizes. The
+  // actual block sizes passed to all function above might be smaller because of
+  // the partial blocks at the end.
+  const StorageIndex m;
+  const StorageIndex k;
+  const StorageIndex n;
+  const StorageIndex bm;
+  const StorageIndex bk;
+  const StorageIndex bn;
+};
+
+// Dispatches a contraction operation over all 8 combinations of the three
+// runtime boolean parameters (lhs_inner_dim_contiguous, rhs_inner_dim_contiguous,
+// rhs_inner_dim_reordered), passing them as compile-time bool_constant
+// tags to the callable `fn`.
+template <typename Func>
+EIGEN_STRONG_INLINE void tensor_contraction_dispatch(Func&& fn, bool lhs_inner_dim_contiguous,
+                                                     bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered) {
+  if (lhs_inner_dim_contiguous) {
+    if (rhs_inner_dim_contiguous) {
+      if (rhs_inner_dim_reordered)
+        fn(bool_constant<true>{}, bool_constant<true>{}, bool_constant<true>{});
+      else
+        fn(bool_constant<true>{}, bool_constant<true>{}, bool_constant<false>{});
+    } else {
+      if (rhs_inner_dim_reordered)
+        fn(bool_constant<true>{}, bool_constant<false>{}, bool_constant<true>{});
+      else
+        fn(bool_constant<true>{}, bool_constant<false>{}, bool_constant<false>{});
+    }
+  } else {
+    if (rhs_inner_dim_contiguous) {
+      if (rhs_inner_dim_reordered)
+        fn(bool_constant<false>{}, bool_constant<true>{}, bool_constant<true>{});
+      else
+        fn(bool_constant<false>{}, bool_constant<true>{}, bool_constant<false>{});
+    } else {
+      if (rhs_inner_dim_reordered)
+        fn(bool_constant<false>{}, bool_constant<false>{}, bool_constant<true>{});
+      else
+        fn(bool_constant<false>{}, bool_constant<false>{}, bool_constant<false>{});
+    }
+  }
+}
+
+}  // end namespace internal
+
+// Legacy macros kept for backward compatibility with code that overrides them
+// (e.g. TensorFlow Lite restricts template instantiations for binary size).
+// New Eigen code should use internal::tensor_contraction_dispatch() instead.
+#ifndef TENSOR_CONTRACTION_DISPATCH
+#define TENSOR_CONTRACTION_DISPATCH(METHOD, ALIGNMENT, ARGS)                                          \
+  ::Eigen::internal::tensor_contraction_dispatch(                                                     \
+      [&](auto lhs_c, auto rhs_c, auto rhs_r) { METHOD<lhs_c(), rhs_c(), rhs_r(), ALIGNMENT> ARGS; }, \
+      this->m_lhs_inner_dim_contiguous, this->m_rhs_inner_dim_contiguous, this->m_rhs_inner_dim_reordered)
+#endif
+
+#ifndef TENSOR_CONTRACTION_ASYNC_DISPATCH
+#define TENSOR_CONTRACTION_ASYNC_DISPATCH(METHOD, DONE, ALIGNMENT, ARGS, FN)                                          \
+  ::Eigen::internal::tensor_contraction_dispatch(                                                                     \
+      [&](auto lhs_c, auto rhs_c, auto rhs_r) { (new METHOD<DONE, lhs_c(), rhs_c(), rhs_r(), ALIGNMENT> ARGS)->FN; }, \
+      this->m_lhs_inner_dim_contiguous, this->m_rhs_inner_dim_contiguous, this->m_rhs_inner_dim_reordered)
+#endif
+
+// Tensor contraction params that should enable to get from output matrix
+// 2-dimensional coordinates to the output tensor dimensions.
+struct TensorContractionParams {
+  // TensorContraction evaluator assumes that both tensors are in ColMajor
+  // layout, if tensors are in RowMajor evaluator swap lhs with rhs.
+  bool swapped_arguments;
+};
+
+// Output kernel allows to fuse operations into the tensor contraction.
+//
+// Examples:
+//   1. Elementwise Relu transformation following Conv2D.
+//   2. AddBias to the Conv2D output channels dimension.
+//
+// The NoOpOutputKernel implements an output kernel that does absolutely nothing.
+struct NoOpOutputKernel {
+  /**
+   * Tensor contraction evaluator calls this kernel after finishing each block
+   * of output matrix. Output blocks belong to the 2-dimensional output tensor.
+   *
+   * TensorContractionParams contains contraction dimensions information
+   * required to map output 2-d space into the expected output tensor space
+   * (potentially higher dimensional).
+   *
+   * \param[in] output_mapper Access to output tensor memory
+   * \param[in] params   Tensor contraction parameters
+   * \param[in] i        Index of a first row available through output_mapper
+   * \param[in] j        Index of a first column available through output_mapper
+   * \param[in] num_rows Number of available rows
+   * \param[in] num_cols Number of available columns
+   */
+  template <typename Index, typename Scalar>
+  EIGEN_ALWAYS_INLINE void operator()(const internal::blas_data_mapper<Scalar, Index, ColMajor>&,
+                                      const TensorContractionParams&, Index, Index, Index, Index) const {}
+};
+
+/** Tensor contraction class.
+ * \ingroup Tensor_Module
+ */
+template <typename Indices, typename LhsXprType, typename RhsXprType,
+          typename OutputKernelType = const NoOpOutputKernel>
+class TensorContractionOp
+    : public TensorBase<TensorContractionOp<Indices, LhsXprType, RhsXprType, OutputKernelType>, ReadOnlyAccessors> {
+ public:
+  using Scalar = typename Eigen::internal::traits<TensorContractionOp>::Scalar;
+  using CoeffReturnType = typename internal::gebp_traits<typename LhsXprType::CoeffReturnType,
+                                                         typename RhsXprType::CoeffReturnType>::ResScalar;
+  using Nested = typename Eigen::internal::ref_selector<TensorContractionOp>::type;
+  using StorageKind = typename Eigen::internal::traits<TensorContractionOp>::StorageKind;
+  using Index = typename Eigen::internal::traits<TensorContractionOp>::Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionOp(const LhsXprType& lhs, const RhsXprType& rhs,
+                                                            const Indices& dims,
+                                                            const OutputKernelType& output_kernel = OutputKernelType())
+      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_indices(dims), m_output_kernel(output_kernel) {}
+
+  EIGEN_DEVICE_FUNC const Indices& indices() const { return m_indices; }
+
+  /** \returns the nested expressions */
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
+    return m_lhs_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
+    return m_rhs_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const OutputKernelType& outputKernel() const { return m_output_kernel; }
+
+ protected:
+  typename LhsXprType::Nested m_lhs_xpr;
+  typename RhsXprType::Nested m_rhs_xpr;
+  const Indices m_indices;
+  const OutputKernelType m_output_kernel;
+};
+
+namespace internal {
+template <bool TypesMatch, int StorageOrder, bool MatrixIsRight>
+struct GemvDirectDispatcher {
+  template <typename Evaluator, typename Scalar>
+  static bool run(const Evaluator* self, Scalar* buffer) {
+    self->template evalGemvDirect<StorageOrder, MatrixIsRight>(buffer);
+    return true;
+  }
+};
+
+template <int StorageOrder, bool MatrixIsRight>
+struct GemvDirectDispatcher<false, StorageOrder, MatrixIsRight> {
+  template <typename Evaluator, typename Scalar>
+  static bool run(const Evaluator*, Scalar*) {
+    return false;
+  }
+};
+}  // namespace internal
+
+template <typename Derived>
+struct TensorContractionEvaluatorBase {
+  using Indices = typename internal::traits<Derived>::Indices;
+  using LeftArgType = typename internal::traits<Derived>::LeftArgType;
+  using RightArgType = typename internal::traits<Derived>::RightArgType;
+  using OutputKernelType = typename internal::traits<Derived>::OutputKernelType;
+  using Device = typename internal::traits<Derived>::Device;
+
+  using XprType = TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>;
+  using Scalar = std::remove_const_t<typename XprType::Scalar>;
+  using Index = typename XprType::Index;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
+  using PacketReturnType = typename PacketType<CoeffReturnType, Device>::type;
+  using Storage = StorageMemory<Scalar, Device>;
+  using EvaluatorPointerType = typename Storage::Type;
+
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+  static constexpr bool IsAligned = true;
+  static constexpr bool PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1);
+  static constexpr bool BlockAccess = false;
+  static constexpr bool PreferBlockAccess = false;
+  static constexpr bool CoordAccess = false;  // to be implemented
+  static constexpr bool RawAccess = true;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  using TensorBlock = internal::TensorBlockNotImplemented;
+  //===--------------------------------------------------------------------===//
+
+  // Most of the code is assuming that both input tensors are ColMajor. If the
+  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
+  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
+  // will pretend B is LHS and A is RHS.
+  using EvalLeftArgType =
+      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), LeftArgType, RightArgType>;
+  using EvalRightArgType =
+      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), RightArgType, LeftArgType>;
+
+  static constexpr int LDims =
+      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
+  static constexpr int RDims =
+      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
+  static constexpr int ContractDims = internal::array_size<Indices>::value;
+  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
+
+  using contract_t = array<Index, ContractDims>;
+  using left_nocontract_t = array<Index, LDims - ContractDims>;
+  using right_nocontract_t = array<Index, RDims - ContractDims>;
+
+  using Dimensions = DSizes<Index, NumDims>;
+
+  EIGEN_STRONG_INLINE TensorContractionEvaluatorBase(const XprType& op, const Device& device)
+      : m_leftImpl(choose(Cond<static_cast<int>(Layout) == static_cast<int>(ColMajor)>(), op.lhsExpression(),
+                          op.rhsExpression()),
+                   device),
+        m_rightImpl(choose(Cond<static_cast<int>(Layout) == static_cast<int>(ColMajor)>(), op.rhsExpression(),
+                           op.lhsExpression()),
+                    device),
+        m_device(device),
+        m_output_kernel(op.outputKernel()),
+        m_result(nullptr) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
+                         static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    DSizes<Index, LDims> eval_left_dims;
+    DSizes<Index, RDims> eval_right_dims;
+    array<IndexPair<Index>, ContractDims> eval_op_indices;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      // For ColMajor, we keep using the existing dimensions
+      for (int i = 0; i < LDims; i++) {
+        eval_left_dims[i] = m_leftImpl.dimensions()[i];
+      }
+      for (int i = 0; i < RDims; i++) {
+        eval_right_dims[i] = m_rightImpl.dimensions()[i];
+      }
+      // We keep the pairs of contracting indices.
+      for (int i = 0; i < ContractDims; i++) {
+        eval_op_indices[i].first = op.indices()[i].first;
+        eval_op_indices[i].second = op.indices()[i].second;
+      }
+    } else {
+      // For RowMajor, we need to reverse the existing dimensions
+      for (int i = 0; i < LDims; i++) {
+        eval_left_dims[i] = m_leftImpl.dimensions()[LDims - i - 1];
+      }
+      for (int i = 0; i < RDims; i++) {
+        eval_right_dims[i] = m_rightImpl.dimensions()[RDims - i - 1];
+      }
+      // We need to flip all the pairs of contracting indices as well as
+      // reversing the dimensions.
+      for (int i = 0; i < ContractDims; i++) {
+        eval_op_indices[i].first = LDims - 1 - op.indices()[ContractDims - 1 - i].second;
+        eval_op_indices[i].second = RDims - 1 - op.indices()[ContractDims - 1 - i].first;
+      }
+    }
+
+    // Check for duplicate axes and make sure the first index in eval_op_indices
+    // is increasing. Using O(n^2) sorting is OK since ContractDims is small
+    for (int i = 0; i < ContractDims; i++) {
+      for (int j = i + 1; j < ContractDims; j++) {
+        eigen_assert(eval_op_indices[j].first != eval_op_indices[i].first &&
+                     eval_op_indices[j].second != eval_op_indices[i].second && "contraction axes should be unique");
+        if (eval_op_indices[j].first < eval_op_indices[i].first) {
+          numext::swap(eval_op_indices[j], eval_op_indices[i]);
+        }
+      }
+    }
+
+    array<Index, LDims> lhs_strides;
+    lhs_strides[0] = 1;
+    for (int i = 0; i < LDims - 1; ++i) {
+      lhs_strides[i + 1] = lhs_strides[i] * eval_left_dims[i];
+    }
+
+    array<Index, RDims> rhs_strides;
+    rhs_strides[0] = 1;
+    for (int i = 0; i < RDims - 1; ++i) {
+      rhs_strides[i + 1] = rhs_strides[i] * eval_right_dims[i];
+    }
+
+    m_i_size = 1;
+    m_j_size = 1;
+    m_k_size = 1;
+
+    // To compute the dimension, we simply concatenate the non-contracting
+    // dimensions of the left and then the right tensor. Additionally, we also
+    // compute the strides corresponding to the left non-contracting
+    // dimensions and right non-contracting dimensions.
+    m_lhs_inner_dim_contiguous = true;
+    int dim_idx = 0;
+    Index nocontract_idx = 0;
+
+    for (int i = 0; i < LDims; i++) {
+      // find if we are contracting on index i of left tensor
+      bool contracting = false;
+      for (int j = 0; j < ContractDims; j++) {
+        if (eval_op_indices[j].first == i) {
+          contracting = true;
+          break;
+        }
+      }
+      if (!contracting) {
+        // add dimension size to output dimensions
+        m_dimensions[dim_idx] = eval_left_dims[i];
+        m_left_nocontract_strides[nocontract_idx] = lhs_strides[i];
+        if (dim_idx != i) {
+          m_lhs_inner_dim_contiguous = false;
+        }
+        m_i_strides[nocontract_idx] = m_i_size;
+        m_i_size *= eval_left_dims[i];
+        dim_idx++;
+        nocontract_idx++;
+      }
+    }
+
+    nocontract_idx = 0;
+    for (int i = 0; i < RDims; i++) {
+      bool contracting = false;
+      // find if we are contracting on index i of right tensor
+      for (int j = 0; j < ContractDims; j++) {
+        if (eval_op_indices[j].second == i) {
+          contracting = true;
+          break;
+        }
+      }
+      if (!contracting) {
+        m_dimensions[dim_idx] = eval_right_dims[i];
+        m_j_strides[nocontract_idx] = m_j_size;
+        m_j_size *= eval_right_dims[i];
+        m_right_nocontract_strides[nocontract_idx] = rhs_strides[i];
+        dim_idx++;
+        nocontract_idx++;
+      }
+    }
+
+    // Now compute the strides corresponding to the contracting dimensions. We
+    // assumed above that non-contracting axes are represented in the same order
+    // in the matrix as they are in the tensor. This is not the case for
+    // contracting axes. As the contracting axes must be of the same size in
+    // each tensor, we'll only look at the first tensor here.
+    m_rhs_inner_dim_contiguous = true;
+    m_rhs_inner_dim_reordered = false;
+    for (int i = 0; i < ContractDims; i++) {
+      Index left = eval_op_indices[i].first;
+      Index right = eval_op_indices[i].second;
+
+      Index size = eval_left_dims[left];
+      eigen_assert(size == eval_right_dims[right] && "Contraction axes must be same size");
+
+      m_k_strides[i] = m_k_size;
+      m_k_size *= size;
+      m_left_contracting_strides[i] = lhs_strides[left];
+      m_right_contracting_strides[i] = rhs_strides[right];
+
+      if (i > 0 && right < eval_op_indices[i - 1].second) {
+        m_rhs_inner_dim_reordered = true;
+      }
+      if (right != i) {
+        m_rhs_inner_dim_contiguous = false;
+      }
+    }
+
+    // After the sort above, eval_op_indices[*].first is in ascending order. The
+    // contracted LHS dims are the contiguous prefix of storage iff that prefix
+    // is exactly {0, 1, ..., ContractDims-1}. Similarly for the RHS — and we
+    // also detect the "contracted dims at the trailing end" case, which
+    // matters when LHS/RHS were swapped at the type level for RowMajor inputs.
+    m_lhs_contracted_dims_leading = true;
+    m_rhs_contracted_dims_leading = true;
+    m_rhs_contracted_dims_trailing = true;
+    const int rhs_trail_start = RDims - ContractDims;
+    for (int i = 0; i < ContractDims; i++) {
+      if (eval_op_indices[i].first != i) m_lhs_contracted_dims_leading = false;
+      if (eval_op_indices[i].second != i) m_rhs_contracted_dims_leading = false;
+      if (eval_op_indices[i].second != rhs_trail_start + i) m_rhs_contracted_dims_trailing = false;
+    }
+
+    // If the layout is RowMajor, we need to reverse the m_dimensions
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(RowMajor)) {
+      for (int i = 0, j = NumDims - 1; i < j; i++, j--) {
+        numext::swap(m_dimensions[i], m_dimensions[j]);
+      }
+    }
+
+    // A set of parameters that will allow output kernel to get from output
+    // tensor dimensions (i, j) into the original tensor dimensions.
+    // TODO(ezhulenev): Add parameters required to infer output tensor index for
+    // more complex contractions than 2x2 on internal dimension.
+    m_tensor_contraction_params.swapped_arguments = static_cast<int>(Layout) == RowMajor;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    m_leftImpl.evalSubExprsIfNeeded(nullptr);
+    m_rightImpl.evalSubExprsIfNeeded(nullptr);
+    if (data) {
+      evalTo(data);
+      return false;
+    } else {
+      m_result = static_cast<EvaluatorPointerType>(m_device.allocate(dimensions().TotalSize() * sizeof(Scalar)));
+      evalTo(m_result);
+      return true;
+    }
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType dest, EvalSubExprsCallback done) {
+    m_leftImpl.evalSubExprsIfNeededAsync(nullptr, [this, done, dest](bool) {
+      m_rightImpl.evalSubExprsIfNeededAsync(nullptr, [this, done, dest](bool) {
+        if (dest) {
+          evalToAsync(dest, [done]() { done(false); });
+        } else {
+          m_result = static_cast<EvaluatorPointerType>(m_device.allocate(dimensions().TotalSize() * sizeof(Scalar)));
+          evalToAsync(m_result, [done]() { done(true); });
+        }
+      });
+    });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_DEVICE_FUNC void evalTo(Scalar* buffer) const {
+    static_cast<const Derived*>(this)->template evalProduct<Unaligned>(buffer);
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalToCallback>
+  void evalToAsync(Scalar* buffer, EvalToCallback done) const {
+    static_cast<const Derived*>(this)->template evalProductAsync<EvalToCallback, Unaligned>(buffer, std::move(done));
+  }
+#endif  // EIGEN_USE_THREADS
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
+  void evalProductSequential(Scalar* buffer) const {
+    if (this->m_i_size == 0 || this->m_j_size == 0) {
+      return;
+    }
+    if (this->m_k_size == 0) {
+      // Contraction over dimension of size zero results in an all-zero output.
+      this->m_device.fill(buffer, buffer + this->m_i_size * this->m_j_size, Scalar(0));
+      using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+      this->m_output_kernel(OutputMapper(buffer, this->m_i_size), this->m_tensor_contraction_params,
+                            static_cast<Index>(0), static_cast<Index>(0), this->m_i_size, this->m_j_size);
+      return;
+    }
+    // Gemv-shape contractions (output is a vector) get a direct GEMV kernel
+    // call when the operand layout admits one. There are four shapes:
+    //
+    //   m_j_size == 1: ColMajor inputs. m_leftImpl is the matrix.
+    //     (A) lhs_inner_dim_contiguous: contracted dims at non-contiguous end
+    //         of LHS. Existing evalGemv via TensorContractionInputMapper.
+    //     (B) m_lhs_contracted_dims_leading: contracted dims at contiguous end.
+    //         RowMajor view of LHS via const_blas_data_mapper.
+    //
+    //   m_i_size == 1: RowMajor inputs (lines 431-434 swap LHS/RHS at the type
+    //         level, so the matrix is m_rightImpl).
+    //     (C) m_rhs_contracted_dims_leading: contracted dims at contiguous end
+    //         of (eval-)RHS. RowMajor view of m_rightImpl.
+    //     (D) m_rhs_contracted_dims_trailing: contracted dims at non-contiguous
+    //         end. ColMajor view of m_rightImpl.
+    //
+    // Cases B/C/D require direct memory (data() != nullptr) on both impls.
+    // Anything else falls back to evalGemm.
+    constexpr bool types_match = std::is_same<typename EvalLeftArgType::Scalar, Scalar>::value &&
+                                 std::is_same<typename EvalRightArgType::Scalar, Scalar>::value;
+    if (this->m_j_size == 1) {
+      if (lhs_inner_dim_contiguous) {
+        this->template evalGemv<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(
+            buffer);
+        return;
+      }
+      EIGEN_IF_CONSTEXPR (types_match) {
+        if (m_lhs_contracted_dims_leading && m_leftImpl.data() != nullptr && m_rightImpl.data() != nullptr) {
+          if (internal::GemvDirectDispatcher<types_match, RowMajor, false>::run(this, buffer)) {
+            return;
+          }
+        }
+      }
+    } else if (this->m_i_size == 1 && m_leftImpl.data() != nullptr && m_rightImpl.data() != nullptr) {
+      EIGEN_IF_CONSTEXPR (types_match) {
+        if (m_rhs_contracted_dims_leading) {
+          if (internal::GemvDirectDispatcher<types_match, RowMajor, true>::run(this, buffer)) {
+            return;
+          }
+        }
+        if (m_rhs_contracted_dims_trailing) {
+          if (internal::GemvDirectDispatcher<types_match, ColMajor, true>::run(this, buffer)) {
+            return;
+          }
+        }
+      }
+    }
+    this->template evalGemm<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(
+        buffer);
+  }
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
+#if !defined(EIGEN_HIPCC)
+  EIGEN_DEVICE_FUNC
+#endif
+      void
+      evalGemv(Scalar* buffer) const {
+    const Index rows = m_i_size;
+    const Index cols = m_k_size;
+
+    using LhsScalar = std::remove_const_t<typename EvalLeftArgType::Scalar>;
+    using RhsScalar = std::remove_const_t<typename EvalRightArgType::Scalar>;
+    using LeftEvaluator = TensorEvaluator<EvalLeftArgType, Device>;
+    using RightEvaluator = TensorEvaluator<EvalRightArgType, Device>;
+    const int lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
+    const int rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
+    constexpr int lhs_alignment = LeftEvaluator::IsAligned ? Aligned : Unaligned;
+    constexpr int rhs_alignment = RightEvaluator::IsAligned ? Aligned : Unaligned;
+    using LhsMapper = internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator,
+                                                             left_nocontract_t, contract_t, lhs_packet_size,
+                                                             lhs_inner_dim_contiguous, false, lhs_alignment>;
+
+    using RhsMapper =
+        internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
+                                               contract_t, rhs_packet_size, rhs_inner_dim_contiguous,
+                                               rhs_inner_dim_reordered, rhs_alignment>;
+
+    LhsMapper lhs(m_leftImpl, m_left_nocontract_strides, m_i_strides, m_left_contracting_strides, m_k_strides);
+    RhsMapper rhs(m_rightImpl, m_right_nocontract_strides, m_j_strides, m_right_contracting_strides, m_k_strides);
+
+    const Scalar alpha(1);
+    const Index resIncr(1);
+
+    // zero out the result buffer (which must be of size at least rows * sizeof(Scalar)
+    m_device.fill(buffer, buffer + rows, Scalar(0));
+
+    internal::general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, false, RhsScalar, RhsMapper,
+                                            false>::run(rows, cols, lhs, rhs, buffer, resIncr, alpha);
+
+    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+    m_output_kernel(OutputMapper(buffer, rows), m_tensor_contraction_params, static_cast<Index>(0),
+                    static_cast<Index>(0), rows, static_cast<Index>(1));
+  }
+
+  // Direct gemv fast path: drives the GEMV kernel against raw tensor memory via
+  // const_blas_data_mapper, bypassing TensorContractionInputMapper (which only
+  // delivers vectorized loads along the free dim) and the GEBP packing overhead
+  // of evalGemm.
+  //
+  // StorageOrder is the layout of the (rows × cols) matrix view in memory.
+  // MatrixIsRight selects which TensorEvaluator holds the matrix and which
+  // holds the vector — needed because the constructor swaps LHS/RHS for
+  // RowMajor inputs (lines 431-434), so the gemv shape lives in m_rightImpl
+  // there. Caller guarantees both impls expose direct memory.
+  template <int StorageOrder, bool MatrixIsRight>
+#if !defined(EIGEN_HIPCC)
+  EIGEN_DEVICE_FUNC
+#endif
+      void
+      evalGemvDirect(Scalar* buffer) const {
+    using MatScalar = std::remove_const_t<
+        std::conditional_t<MatrixIsRight, typename EvalRightArgType::Scalar, typename EvalLeftArgType::Scalar>>;
+    using VecScalar = std::remove_const_t<
+        std::conditional_t<MatrixIsRight, typename EvalLeftArgType::Scalar, typename EvalRightArgType::Scalar>>;
+
+    const Index rows = MatrixIsRight ? m_j_size : m_i_size;
+    const Index cols = m_k_size;
+    // For a row-major (rows × cols) view the row stride is cols; for a
+    // column-major view the column stride is rows.
+    const Index mat_stride = (StorageOrder == RowMajor) ? cols : rows;
+
+    const MatScalar* mat_data = MatrixIsRight ? m_rightImpl.data() : m_leftImpl.data();
+    const VecScalar* vec_data = MatrixIsRight ? m_leftImpl.data() : m_rightImpl.data();
+    eigen_assert(mat_data != nullptr && vec_data != nullptr);
+
+    using LhsMapper = internal::const_blas_data_mapper<MatScalar, Index, StorageOrder>;
+    using RhsMapper = internal::const_blas_data_mapper<VecScalar, Index, ColMajor>;
+    LhsMapper lhs(mat_data, mat_stride);
+    RhsMapper rhs(vec_data, /*stride=*/1);
+
+    m_device.fill(buffer, buffer + rows, Scalar(0));
+
+    internal::general_matrix_vector_product<Index, MatScalar, LhsMapper, StorageOrder, false, VecScalar, RhsMapper,
+                                            false>::run(rows, cols, lhs, rhs, buffer, /*resIncr=*/1, Scalar(1));
+
+    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+    m_output_kernel(OutputMapper(buffer, rows), m_tensor_contraction_params, static_cast<Index>(0),
+                    static_cast<Index>(0), rows, static_cast<Index>(1));
+  }
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
+#if !defined(EIGEN_HIPCC)
+  EIGEN_DEVICE_FUNC
+#endif
+      void
+      evalGemm(Scalar* buffer) const {
+    // columns in left side, rows in right side
+    const Index k = this->m_k_size;
+    this->template evalGemmPartial<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered,
+                                   Alignment, true>(buffer, 0, k, 1);
+  }
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
+  EIGEN_DEVICE_FUNC void evalGemmPartialWithoutOutputKernel(Scalar* buffer, Index k_start, Index k_end,
+                                                            int num_threads) const {
+    evalGemmPartial<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment,
+                    /*use_output_kernel*/ false>(buffer, k_start, k_end, num_threads);
+  }
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment,
+            bool use_output_kernel>
+  EIGEN_DEVICE_FUNC void evalGemmPartial(Scalar* buffer, Index k_start, Index k_end, int num_threads) const {
+    eigen_assert(k_end >= k_start && k_start >= 0 && k_end <= this->m_k_size);
+    // columns in slice on left side, rows on right side
+    const Index k_slice = k_end - k_start;
+
+    // rows in left side
+    const Index m = this->m_i_size;
+
+    // columns in right side
+    const Index n = this->m_j_size;
+
+    if (m == 0 || n == 0) return;
+    if (k_slice == 0) {
+      this->m_device.fill(buffer, buffer + m * n, Scalar(0));
+      if (use_output_kernel) {
+        using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+        m_output_kernel(OutputMapper(buffer, m), m_tensor_contraction_params, static_cast<Index>(0),
+                        static_cast<Index>(0), m, n);
+      }
+      return;
+    }
+
+    // define data mappers for Lhs and Rhs
+    using LhsScalar = std::remove_const_t<typename EvalLeftArgType::Scalar>;
+    using RhsScalar = std::remove_const_t<typename EvalRightArgType::Scalar>;
+
+    using LeftEvaluator = TensorEvaluator<EvalLeftArgType, Device>;
+    using RightEvaluator = TensorEvaluator<EvalRightArgType, Device>;
+
+    const int lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
+    const int rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
+
+    using LhsMapper =
+        internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
+                                               contract_t, lhs_packet_size, lhs_inner_dim_contiguous, false, Unaligned>;
+
+    using RhsMapper =
+        internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
+                                               contract_t, rhs_packet_size, rhs_inner_dim_contiguous,
+                                               rhs_inner_dim_reordered, Unaligned>;
+
+    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+
+    using TensorContractionKernel =
+        internal::TensorContractionKernel<Scalar, LhsScalar, RhsScalar, Index, OutputMapper, LhsMapper, RhsMapper>;
+
+    // initialize data mappers
+    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
+                  this->m_left_contracting_strides, this->m_k_strides);
+
+    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
+                  this->m_right_contracting_strides, this->m_k_strides);
+
+    OutputMapper output(buffer, m);
+
+    // Sizes of the blocks to load in cache. See the Goto paper for details.
+    internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(
+        k_slice, m, n, num_threads);
+    const Index kc = blocking.kc();
+    const Index mc = numext::mini(m, blocking.mc());
+    const Index nc = numext::mini(n, blocking.nc());
+
+    using LhsBlock = typename TensorContractionKernel::LhsBlock;
+    using RhsBlock = typename TensorContractionKernel::RhsBlock;
+
+    LhsBlock blockA;
+    RhsBlock blockB;
+
+    TensorContractionKernel kernel(m, k_slice, n, mc, kc, nc);
+
+    using BlockMemHandle = typename TensorContractionKernel::BlockMemHandle;
+    const BlockMemHandle packed_mem = kernel.allocate(this->m_device, &blockA, &blockB);
+
+    // If a contraction kernel does not support beta, explicitly initialize
+    // output buffer with zeroes.
+    EIGEN_IF_CONSTEXPR (!TensorContractionKernel::HasBeta) {
+      this->m_device.fill(buffer, buffer + m * n, Scalar(0));
+    }
+
+    for (Index i2 = 0; i2 < m; i2 += mc) {
+      const Index actual_mc = numext::mini(i2 + mc, m) - i2;
+      for (Index k2 = k_start; k2 < k_end; k2 += kc) {
+        // make sure we don't overshoot right edge of left matrix, then pack vertical panel
+        const Index actual_kc = numext::mini(k2 + kc, k_end) - k2;
+        kernel.packLhs(&blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
+
+        // If kernel supports beta, there is no need to initialize output
+        // buffer with zeroes.
+        const Scalar alpha = Scalar(1);
+        const Scalar beta = (TensorContractionKernel::HasBeta && k2 == k_start) ? Scalar(0) : Scalar(1);
+
+        // series of horizontal blocks
+        for (Index j2 = 0; j2 < n; j2 += nc) {
+          // make sure we don't overshoot right edge of right matrix, then pack block
+          const Index actual_nc = numext::mini(j2 + nc, n) - j2;
+          kernel.packRhs(&blockB, rhs.getSubMapper(k2, j2), actual_kc, actual_nc);
+
+          // call gebp (matrix kernel)
+          // The parameters here are copied from Eigen's GEMM implementation
+          const OutputMapper output_mapper = output.getSubMapper(i2, j2);
+          kernel.invoke(output_mapper, blockA, blockB, actual_mc, actual_kc, actual_nc, alpha, beta);
+
+          // We are done with this [i2, j2] output block.
+          if (use_output_kernel && k2 + kc >= k_end) {
+            m_output_kernel(output_mapper, m_tensor_contraction_params, i2, j2, actual_mc, actual_nc);
+          }
+        }
+      }
+    }
+
+    kernel.deallocate(this->m_device, packed_mem);
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_leftImpl.cleanup();
+    m_rightImpl.cleanup();
+
+    if (m_result != nullptr) {
+      m_device.deallocate(m_result);
+      m_result = nullptr;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_result[index]; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool) const {
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return m_result; }
+
+  // Required so a contraction can be composed with operators whose own
+  // getResourceRequirements() forwards into m_impl (TensorPaddingOp,
+  // TensorBroadcastingOp, etc.). Without this, e.g. an expression like
+  // `Tensor B = A.contract(C, dims).pad(p)` fails to compile because
+  // Pad's BlockAccess is gated on m_impl.RawAccess (which is true here)
+  // and instantiating Pad's getResourceRequirements then requires this
+  // method on the operand evaluator.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+ protected:
+  Dimensions m_dimensions;
+
+  contract_t m_k_strides{};
+  contract_t m_left_contracting_strides{};
+  contract_t m_right_contracting_strides{};
+
+  bool m_lhs_inner_dim_contiguous;
+  bool m_rhs_inner_dim_contiguous;
+  bool m_rhs_inner_dim_reordered;
+  // Set in the constructor; describe whether the contracted LHS/RHS dims
+  // form a contiguous block at the leading or trailing end of storage. Used
+  // by evalProductSequential to pick a direct GEMV path when applicable.
+  bool m_lhs_contracted_dims_leading;
+  bool m_rhs_contracted_dims_leading;
+  bool m_rhs_contracted_dims_trailing;
+
+  left_nocontract_t m_i_strides{};
+  right_nocontract_t m_j_strides{};
+  left_nocontract_t m_left_nocontract_strides{};
+  right_nocontract_t m_right_nocontract_strides{};
+
+  Index m_i_size;
+  Index m_j_size;
+  Index m_k_size;
+
+  TensorContractionParams m_tensor_contraction_params;
+
+  TensorEvaluator<EvalLeftArgType, Device> m_leftImpl;
+  TensorEvaluator<EvalRightArgType, Device> m_rightImpl;
+  const Device EIGEN_DEVICE_REF m_device;
+  OutputKernelType m_output_kernel;
+  EvaluatorPointerType m_result;
+};
+
+// evaluator for default device
+template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType, typename Device>
+struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>
+    : public TensorContractionEvaluatorBase<
+          TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>> {
+  using Self = TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>;
+  using Base = TensorContractionEvaluatorBase<Self>;
+
+  using XprType = TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>;
+  using Scalar = std::remove_const_t<typename XprType::Scalar>;
+  using Index = typename XprType::Index;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
+  using PacketReturnType = typename PacketType<CoeffReturnType, Device>::type;
+
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+
+  // Most of the code is assuming that both input tensors are ColMajor. If the
+  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
+  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
+  // will pretend B is LHS and A is RHS.
+  using EvalLeftArgType = std::conditional_t<Layout == static_cast<int>(ColMajor), LeftArgType, RightArgType>;
+  using EvalRightArgType = std::conditional_t<Layout == static_cast<int>(ColMajor), RightArgType, LeftArgType>;
+
+  static constexpr int LDims =
+      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
+  static constexpr int RDims =
+      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
+  static constexpr int ContractDims = internal::array_size<Indices>::value;
+
+  using contract_t = array<Index, ContractDims>;
+  using left_nocontract_t = array<Index, LDims - ContractDims>;
+  using right_nocontract_t = array<Index, RDims - ContractDims>;
+
+  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
+
+  // Could we use NumDimensions here?
+  using Dimensions = DSizes<Index, NumDims>;
+
+  TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  template <int Alignment>
+  void evalProduct(Scalar* buffer) const {
+    internal::tensor_contraction_dispatch(
+        [&](auto lhs_c, auto rhs_c, auto rhs_r) {
+          this->template evalProductSequential<lhs_c(), rhs_c(), rhs_r(), Alignment>(buffer);
+        },
+        this->m_lhs_inner_dim_contiguous, this->m_rhs_inner_dim_contiguous, this->m_rhs_inner_dim_reordered);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_H
diff --git a/contrib/Eigen/src/Tensor/TensorContractionBlocking.h b/contrib/Eigen/src/Tensor/TensorContractionBlocking.h
new file mode 100644
index 0000000..7997068
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContractionBlocking.h
@@ -0,0 +1,71 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_BLOCKING_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_BLOCKING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+constexpr int ShardByRow = 0;
+constexpr int ShardByCol = 1;
+
+// Default Blocking Strategy
+template <typename ResScalar, typename LhsScalar, typename RhsScalar, typename StorageIndex,
+          int ShardingType = ShardByCol>
+class TensorContractionBlocking {
+ public:
+  /*
+    adding EIGEN_DEVICE_FUNC unconditionally to 'TensorContractionBlocking' constructor in `TensorContractionBlocking.h`
+      requires adding EIGEN_DEVICE_FUNC to `computeProductBlockingSizes` in `GeneralBlockPanelKernel.h`
+      which in turn, requires adding EIGEN_DEVICE_FUNC to `evaluateProductBlockingSizesHeuristic` in
+    `GeneralBlockPanelKernel.h` which in turn, requires adding EIGEN_DEVICE_FUNC to `manage_caching_sizes` in
+    `GeneralBlockPanelKernel.h` (else HIPCC will error out)
+
+    However adding EIGEN_DEVICE_FUNC to `manage_caching_sizes` in `GeneralBlockPanelKernel.h`
+    results in NVCC erroring out with the following error
+
+    ../Eigen/src/Core/products/GeneralBlockPanelKernel.h(57): error #2901:
+       dynamic initialization is not supported for function-scope static variables within a __device__/__global__
+    function
+  */
+
+#if !defined(EIGEN_HIPCC)
+  EIGEN_DEVICE_FUNC
+#endif
+  TensorContractionBlocking(StorageIndex k, StorageIndex m, StorageIndex n, StorageIndex num_threads = 1)
+      : kc_(k), mc_(m), nc_(n) {
+    if (ShardingType == ShardByCol) {
+      computeProductBlockingSizes<LhsScalar, RhsScalar, 1>(kc_, mc_, nc_, num_threads);
+    } else {
+      computeProductBlockingSizes<LhsScalar, RhsScalar, 1>(kc_, nc_, mc_, num_threads);
+    }
+
+    const int rhs_packet_size = internal::packet_traits<RhsScalar>::size;
+    kc_ = (rhs_packet_size <= 8 || kc_ <= rhs_packet_size) ? kc_ : (kc_ / rhs_packet_size) * rhs_packet_size;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE StorageIndex kc() const { return kc_; }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE StorageIndex mc() const { return mc_; }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE StorageIndex nc() const { return nc_; }
+
+ private:
+  StorageIndex kc_;
+  StorageIndex mc_;
+  StorageIndex nc_;
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_BLOCKING_H
diff --git a/contrib/Eigen/src/Tensor/TensorContractionCuda.h b/contrib/Eigen/src/Tensor/TensorContractionCuda.h
new file mode 100644
index 0000000..c61d8a5
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContractionCuda.h
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_CUDA_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_CUDA_H
+
+#if defined(__clang__) || defined(__GNUC__)
+#warning \
+    "Deprecated header file, please either include the main contrib/Eigen/Tensor header or the respective TensorContractionGpu.h file"
+#endif
+
+#include "TensorContractionGpu.h"
+
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_CUDA_H
diff --git a/contrib/Eigen/src/Tensor/TensorContractionGpu.h b/contrib/Eigen/src/Tensor/TensorContractionGpu.h
new file mode 100644
index 0000000..8e4fac4
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContractionGpu.h
@@ -0,0 +1,1437 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014-2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2015 Navdeep Jaitly <ndjaitly@google.com>
+// Copyright (C) 2014 Eric Martin <eric@ericmart.in>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_GPU_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_GPU_H
+
+#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Scalar, typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper,
+          bool needs_edge_check>
+__device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapper lhs, const RhsMapper rhs,
+                                                                   const OutputMapper output, Scalar* lhs_shmem,
+                                                                   Scalar* rhs_shmem, const Index m_size,
+                                                                   const Index n_size, const Index k_size) {
+  const Index m_block_idx = blockIdx.x;
+  const Index n_block_idx = blockIdx.y;
+
+  const Index base_m = 64 * m_block_idx;
+  const Index base_n = 64 * n_block_idx;
+  const Index thread_x = threadIdx.x;
+  const Index thread_y = threadIdx.y;
+  const Index thread_z = threadIdx.z;
+
+  // declare and initialize 64 registers for output 8x8 block
+
+  // prefetch registers
+  Scalar lhs_pf0;
+  Scalar lhs_pf1;
+  Scalar lhs_pf2;
+  Scalar lhs_pf3;
+  Scalar lhs_pf4;
+  Scalar lhs_pf5;
+  Scalar lhs_pf6;
+  Scalar lhs_pf7;
+
+  Scalar rhs_pf0;
+  Scalar rhs_pf1;
+  Scalar rhs_pf2;
+  Scalar rhs_pf3;
+  Scalar rhs_pf4;
+  Scalar rhs_pf5;
+  Scalar rhs_pf6;
+  Scalar rhs_pf7;
+
+  // shared memory is formatted
+  // (contract idx in block, nocontract idx in block, block idx)
+  // where block idx is column major. This transposition limits the number of
+  // bank conflicts when reading the LHS. The core idea is that since the contracting
+  // index is shared by both sides, then the contracting index should be in threadIdx.x.
+
+  // On the LHS, we pad each row inside of each block with an extra element. This makes
+  // each block 8 rows of 9 elements, which is 72 elements. This gives no bank conflicts
+  // on writes and very few 2-way conflicts on reads. There is an 8x8 grid of these blocks.
+
+  // On the RHS we just add 8 padding elements to the end of each block. This gives no bank
+  // conflicts on writes and also none on reads.
+
+  // storage indices
+  const Index lhs_store_idx_base = thread_y * 72 + thread_x * 9 + thread_z;
+  const Index rhs_store_idx_base = thread_y * 72 + thread_z * 8 + thread_x;
+
+  const Index lhs_store_idx_0 = lhs_store_idx_base + 576 * 0;
+  const Index lhs_store_idx_1 = lhs_store_idx_base + 576 * 1;
+  const Index lhs_store_idx_2 = lhs_store_idx_base + 576 * 2;
+  const Index lhs_store_idx_3 = lhs_store_idx_base + 576 * 3;
+  const Index lhs_store_idx_4 = lhs_store_idx_base + 576 * 4;
+  const Index lhs_store_idx_5 = lhs_store_idx_base + 576 * 5;
+  const Index lhs_store_idx_6 = lhs_store_idx_base + 576 * 6;
+  const Index lhs_store_idx_7 = lhs_store_idx_base + 576 * 7;
+
+  const Index rhs_store_idx_0 = rhs_store_idx_base + 576 * 0;
+  const Index rhs_store_idx_1 = rhs_store_idx_base + 576 * 1;
+  const Index rhs_store_idx_2 = rhs_store_idx_base + 576 * 2;
+  const Index rhs_store_idx_3 = rhs_store_idx_base + 576 * 3;
+  const Index rhs_store_idx_4 = rhs_store_idx_base + 576 * 4;
+  const Index rhs_store_idx_5 = rhs_store_idx_base + 576 * 5;
+  const Index rhs_store_idx_6 = rhs_store_idx_base + 576 * 6;
+  const Index rhs_store_idx_7 = rhs_store_idx_base + 576 * 7;
+
+  // in the loading code, the following variables are important:
+  // thread_x: the vertical position in an 8x8 block
+  // thread_y: the vertical index of the 8x8 block in the grid
+  // thread_z: the horizontal position in an 8x8 block
+  // k: the horizontal index of the 8x8 block in the grid
+  //
+  // The k parameter is implicit (it was the loop counter for a loop that went
+  // from 0 to <8, but now that loop is unrolled in the below code).
+
+  const Index load_idx_vert = thread_x + 8 * thread_y;
+  const Index lhs_vert = base_m + load_idx_vert;
+
+#define prefetchIntoRegisters(base_k)                      \
+  {                                                        \
+    lhs_pf0 = conv(0);                                     \
+    lhs_pf1 = conv(0);                                     \
+    lhs_pf2 = conv(0);                                     \
+    lhs_pf3 = conv(0);                                     \
+    lhs_pf4 = conv(0);                                     \
+    lhs_pf5 = conv(0);                                     \
+    lhs_pf6 = conv(0);                                     \
+    lhs_pf7 = conv(0);                                     \
+                                                           \
+    rhs_pf0 = conv(0);                                     \
+    rhs_pf1 = conv(0);                                     \
+    rhs_pf2 = conv(0);                                     \
+    rhs_pf3 = conv(0);                                     \
+    rhs_pf4 = conv(0);                                     \
+    rhs_pf5 = conv(0);                                     \
+    rhs_pf6 = conv(0);                                     \
+    rhs_pf7 = conv(0);                                     \
+                                                           \
+    if (!needs_edge_check || lhs_vert < m_size) {          \
+      const Index lhs_horiz_0 = base_k + thread_z + 0 * 8; \
+      const Index lhs_horiz_1 = base_k + thread_z + 1 * 8; \
+      const Index lhs_horiz_2 = base_k + thread_z + 2 * 8; \
+      const Index lhs_horiz_3 = base_k + thread_z + 3 * 8; \
+      const Index lhs_horiz_4 = base_k + thread_z + 4 * 8; \
+      const Index lhs_horiz_5 = base_k + thread_z + 5 * 8; \
+      const Index lhs_horiz_6 = base_k + thread_z + 6 * 8; \
+      const Index lhs_horiz_7 = base_k + thread_z + 7 * 8; \
+                                                           \
+      if (!needs_edge_check || lhs_horiz_7 < k_size) {     \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
+        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
+        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
+        lhs_pf5 = lhs(lhs_vert, lhs_horiz_5);              \
+        lhs_pf6 = lhs(lhs_vert, lhs_horiz_6);              \
+        lhs_pf7 = lhs(lhs_vert, lhs_horiz_7);              \
+      } else if (lhs_horiz_6 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
+        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
+        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
+        lhs_pf5 = lhs(lhs_vert, lhs_horiz_5);              \
+        lhs_pf6 = lhs(lhs_vert, lhs_horiz_6);              \
+      } else if (lhs_horiz_5 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
+        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
+        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
+        lhs_pf5 = lhs(lhs_vert, lhs_horiz_5);              \
+      } else if (lhs_horiz_4 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
+        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
+        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
+      } else if (lhs_horiz_3 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
+        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
+      } else if (lhs_horiz_2 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
+      } else if (lhs_horiz_1 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
+      } else if (lhs_horiz_0 < k_size) {                   \
+        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
+      }                                                    \
+    }                                                      \
+                                                           \
+    const Index rhs_vert = base_k + load_idx_vert;         \
+    if (!needs_edge_check || rhs_vert < k_size) {          \
+      const Index rhs_horiz_0 = base_n + thread_z + 0 * 8; \
+      const Index rhs_horiz_1 = base_n + thread_z + 1 * 8; \
+      const Index rhs_horiz_2 = base_n + thread_z + 2 * 8; \
+      const Index rhs_horiz_3 = base_n + thread_z + 3 * 8; \
+      const Index rhs_horiz_4 = base_n + thread_z + 4 * 8; \
+      const Index rhs_horiz_5 = base_n + thread_z + 5 * 8; \
+      const Index rhs_horiz_6 = base_n + thread_z + 6 * 8; \
+      const Index rhs_horiz_7 = base_n + thread_z + 7 * 8; \
+                                                           \
+      if (rhs_horiz_7 < n_size) {                          \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
+        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
+        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
+        rhs_pf5 = rhs(rhs_vert, rhs_horiz_5);              \
+        rhs_pf6 = rhs(rhs_vert, rhs_horiz_6);              \
+        rhs_pf7 = rhs(rhs_vert, rhs_horiz_7);              \
+      } else if (rhs_horiz_6 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
+        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
+        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
+        rhs_pf5 = rhs(rhs_vert, rhs_horiz_5);              \
+        rhs_pf6 = rhs(rhs_vert, rhs_horiz_6);              \
+      } else if (rhs_horiz_5 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
+        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
+        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
+        rhs_pf5 = rhs(rhs_vert, rhs_horiz_5);              \
+      } else if (rhs_horiz_4 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
+        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
+        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
+      } else if (rhs_horiz_3 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
+        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
+      } else if (rhs_horiz_2 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
+      } else if (rhs_horiz_1 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
+      } else if (rhs_horiz_0 < n_size) {                   \
+        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
+      }                                                    \
+    }                                                      \
+  }
+
+#define writeRegToShmem()               \
+  lhs_shmem[lhs_store_idx_0] = lhs_pf0; \
+  rhs_shmem[rhs_store_idx_0] = rhs_pf0; \
+                                        \
+  lhs_shmem[lhs_store_idx_1] = lhs_pf1; \
+  rhs_shmem[rhs_store_idx_1] = rhs_pf1; \
+                                        \
+  lhs_shmem[lhs_store_idx_2] = lhs_pf2; \
+  rhs_shmem[rhs_store_idx_2] = rhs_pf2; \
+                                        \
+  lhs_shmem[lhs_store_idx_3] = lhs_pf3; \
+  rhs_shmem[rhs_store_idx_3] = rhs_pf3; \
+                                        \
+  lhs_shmem[lhs_store_idx_4] = lhs_pf4; \
+  rhs_shmem[rhs_store_idx_4] = rhs_pf4; \
+                                        \
+  lhs_shmem[lhs_store_idx_5] = lhs_pf5; \
+  rhs_shmem[rhs_store_idx_5] = rhs_pf5; \
+                                        \
+  lhs_shmem[lhs_store_idx_6] = lhs_pf6; \
+  rhs_shmem[rhs_store_idx_6] = rhs_pf6; \
+                                        \
+  lhs_shmem[lhs_store_idx_7] = lhs_pf7; \
+  rhs_shmem[rhs_store_idx_7] = rhs_pf7;
+
+  // declare and initialize result array
+#define res(i, j) _res_##i##j
+#define initResultRow(i)      \
+  Scalar res(i, 0) = conv(0); \
+  Scalar res(i, 1) = conv(0); \
+  Scalar res(i, 2) = conv(0); \
+  Scalar res(i, 3) = conv(0); \
+  Scalar res(i, 4) = conv(0); \
+  Scalar res(i, 5) = conv(0); \
+  Scalar res(i, 6) = conv(0); \
+  Scalar res(i, 7) = conv(0);
+
+  internal::scalar_cast_op<int, Scalar> conv;
+  initResultRow(0);
+  initResultRow(1);
+  initResultRow(2);
+  initResultRow(3);
+  initResultRow(4);
+  initResultRow(5);
+  initResultRow(6);
+  initResultRow(7);
+#undef initResultRow
+
+  for (Index base_k = 0; base_k < k_size; base_k += 64) {
+    // wait for previous iteration to finish with shmem. Despite common sense,
+    // the code is a bit faster with this here than at bottom of loop
+    __syncthreads();
+
+    prefetchIntoRegisters(base_k);
+    writeRegToShmem();
+
+#undef prefetchIntoRegisters
+#undef writeRegToShmem
+
+    // wait for shared mem packing to be done before starting computation
+    __syncthreads();
+
+    // compute 8x8 matrix product by outer product. This involves packing one column
+    // of LHS and one row of RHS into registers (takes 16 registers).
+
+#define lcol(i) _lcol##i
+    Scalar lcol(0);
+    Scalar lcol(1);
+    Scalar lcol(2);
+    Scalar lcol(3);
+    Scalar lcol(4);
+    Scalar lcol(5);
+    Scalar lcol(6);
+    Scalar lcol(7);
+
+#define rrow(j) _rrow##j
+    Scalar rrow(0);
+    Scalar rrow(1);
+    Scalar rrow(2);
+    Scalar rrow(3);
+    Scalar rrow(4);
+    Scalar rrow(5);
+    Scalar rrow(6);
+    Scalar rrow(7);
+
+    // Now x corresponds to k, y to m, and z to n
+    const Scalar* lhs_block = &lhs_shmem[thread_x + 9 * thread_y];
+    const Scalar* rhs_block = &rhs_shmem[thread_x + 8 * thread_z];
+
+#define lhs_element(i, j) lhs_block[72 * ((i) + 8 * (j))]
+#define rhs_element(i, j) rhs_block[72 * ((i) + 8 * (j))]
+
+#define loadData(i, j)         \
+  lcol(0) = lhs_element(0, j); \
+  rrow(0) = rhs_element(i, 0); \
+  lcol(1) = lhs_element(1, j); \
+  rrow(1) = rhs_element(i, 1); \
+  lcol(2) = lhs_element(2, j); \
+  rrow(2) = rhs_element(i, 2); \
+  lcol(3) = lhs_element(3, j); \
+  rrow(3) = rhs_element(i, 3); \
+  lcol(4) = lhs_element(4, j); \
+  rrow(4) = rhs_element(i, 4); \
+  lcol(5) = lhs_element(5, j); \
+  rrow(5) = rhs_element(i, 5); \
+  lcol(6) = lhs_element(6, j); \
+  rrow(6) = rhs_element(i, 6); \
+  lcol(7) = lhs_element(7, j); \
+  rrow(7) = rhs_element(i, 7);
+
+#define computeCol(j)             \
+  res(0, j) += lcol(0) * rrow(j); \
+  res(1, j) += lcol(1) * rrow(j); \
+  res(2, j) += lcol(2) * rrow(j); \
+  res(3, j) += lcol(3) * rrow(j); \
+  res(4, j) += lcol(4) * rrow(j); \
+  res(5, j) += lcol(5) * rrow(j); \
+  res(6, j) += lcol(6) * rrow(j); \
+  res(7, j) += lcol(7) * rrow(j);
+
+#define computePass(i) \
+  loadData(i, i);      \
+                       \
+  computeCol(0);       \
+  computeCol(1);       \
+  computeCol(2);       \
+  computeCol(3);       \
+  computeCol(4);       \
+  computeCol(5);       \
+  computeCol(6);       \
+  computeCol(7);
+
+    computePass(0);
+    computePass(1);
+    computePass(2);
+    computePass(3);
+    computePass(4);
+    computePass(5);
+    computePass(6);
+    computePass(7);
+
+#undef lcol
+#undef rrow
+#undef lhs_element
+#undef rhs_element
+#undef loadData
+#undef computeCol
+#undef computePass
+  }  // end loop over k
+
+  // we've now iterated over all of the large (ie width 64) k blocks and
+  // accumulated results in registers. At this point thread (x, y, z) contains
+  // the sum across all big k blocks of the product of little k block of index (x, y)
+  // with block of index (y, z). To compute the final output, we need to reduce
+  // the 8 threads over y by summation.
+  // HIP uses non-sync warp shuffles; CUDA requires the _sync variants.
+#if defined(EIGEN_HIPCC)
+#define shuffleInc(i, j, mask) res(i, j) += __shfl_xor(res(i, j), mask)
+#else
+#define shuffleInc(i, j, mask) res(i, j) += __shfl_xor_sync(0xFFFFFFFF, res(i, j), mask)
+#endif
+
+#define reduceRow(i, mask) \
+  shuffleInc(i, 0, mask);  \
+  shuffleInc(i, 1, mask);  \
+  shuffleInc(i, 2, mask);  \
+  shuffleInc(i, 3, mask);  \
+  shuffleInc(i, 4, mask);  \
+  shuffleInc(i, 5, mask);  \
+  shuffleInc(i, 6, mask);  \
+  shuffleInc(i, 7, mask);
+
+#define reduceMatrix(mask) \
+  reduceRow(0, mask);      \
+  reduceRow(1, mask);      \
+  reduceRow(2, mask);      \
+  reduceRow(3, mask);      \
+  reduceRow(4, mask);      \
+  reduceRow(5, mask);      \
+  reduceRow(6, mask);      \
+  reduceRow(7, mask);
+
+  // actually perform the reduction, now each thread of index (_, y, z)
+  // contains the correct values in its registers that belong in the output
+  // block
+  reduceMatrix(1);
+  reduceMatrix(2);
+  reduceMatrix(4);
+
+#undef shuffleInc
+#undef reduceRow
+#undef reduceMatrix
+
+  // now we need to copy the 64 values into main memory. We can't split work
+  // among threads because all variables are in registers. There's 2 ways
+  // to do this:
+  // (1) have 1 thread do 64 writes from registers into global memory
+  // (2) have 1 thread do 64 writes into shared memory, and then 8 threads
+  //     each do 8 writes into global memory. We can just overwrite the shared
+  //     memory from the problem we just solved.
+  // (2) is slightly faster than (1) due to less branching and more ILP
+
+  // TODO: won't yield much gain, but could just use currently unused shared mem
+  //       and then we won't have to sync
+  // wait for shared mem to be out of use
+  __syncthreads();
+
+#define writeResultShmem(i, j) lhs_shmem[i + 8 * thread_y + 64 * thread_z + 512 * j] = res(i, j);
+
+#define writeRow(i)       \
+  writeResultShmem(i, 0); \
+  writeResultShmem(i, 1); \
+  writeResultShmem(i, 2); \
+  writeResultShmem(i, 3); \
+  writeResultShmem(i, 4); \
+  writeResultShmem(i, 5); \
+  writeResultShmem(i, 6); \
+  writeResultShmem(i, 7);
+
+  if (thread_x == 0) {
+    writeRow(0);
+    writeRow(1);
+    writeRow(2);
+    writeRow(3);
+    writeRow(4);
+    writeRow(5);
+    writeRow(6);
+    writeRow(7);
+  }
+#undef writeResultShmem
+#undef writeRow
+
+  const int max_i_write = numext::mini((int)((m_size - base_m - thread_y + 7) / 8), 8);
+  const int max_j_write = numext::mini((int)((n_size - base_n - thread_z + 7) / 8), 8);
+
+  if (thread_x < max_i_write) {
+    if (max_j_write == 8) {
+      // TODO: Can we trade bank conflicts for coalesced writes?
+      Scalar val0 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 0];
+      Scalar val1 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 1];
+      Scalar val2 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 2];
+      Scalar val3 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 3];
+      Scalar val4 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 4];
+      Scalar val5 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 5];
+      Scalar val6 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 6];
+      Scalar val7 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 7];
+
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 0) = val0;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 1) = val1;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 2) = val2;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 3) = val3;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 4) = val4;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 5) = val5;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 6) = val6;
+      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 7) = val7;
+    } else {
+#pragma unroll 7
+      for (int j = 0; j < max_j_write; j++) {
+        Scalar val = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * j];
+        output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * j) = val;
+      }
+    }
+  }
+#undef res
+}
+
+template <typename Scalar, typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
+__global__ void
+#if defined(EIGEN_HIPCC)
+__launch_bounds__(512, 1)
+#else
+__launch_bounds__(512)
+#endif
+    EigenContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
+                           const Index n_size, const Index k_size) {
+  __shared__ Scalar lhs_shmem[72 * 64];
+  __shared__ Scalar rhs_shmem[72 * 64];
+
+  const Index m_block_idx = blockIdx.x;
+  const Index n_block_idx = blockIdx.y;
+
+  const Index base_m = 64 * m_block_idx;
+  const Index base_n = 64 * n_block_idx;
+
+  if (base_m + 63 < m_size && base_n + 63 < n_size) {
+    EigenContractionKernelInternal<Scalar, Index, LhsMapper, RhsMapper, OutputMapper, false>(
+        lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size);
+  } else {
+    EigenContractionKernelInternal<Scalar, Index, LhsMapper, RhsMapper, OutputMapper, true>(
+        lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size);
+  }
+}
+
+template <typename Scalar, typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
+__global__ void
+#if defined(EIGEN_HIPCC)
+__launch_bounds__(256, 1)
+#else
+__launch_bounds__(256)
+#endif
+    EigenContractionKernelNaive(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
+                                const Index n_size, const Index k_size) {
+  const Index row = static_cast<Index>(blockIdx.x) * static_cast<Index>(blockDim.x) + static_cast<Index>(threadIdx.x);
+  const Index col = static_cast<Index>(blockIdx.y) * static_cast<Index>(blockDim.y) + static_cast<Index>(threadIdx.y);
+
+  if (row >= m_size || col >= n_size) {
+    return;
+  }
+
+  internal::scalar_cast_op<int, Scalar> conv;
+  Scalar result = conv(0);
+  for (Index k = 0; k < k_size; ++k) {
+    result += lhs(row, k) * rhs(k, col);
+  }
+  output(row, col) = result;
+}
+
+template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper, bool CHECK_LHS_BOUNDARY,
+          bool CHECK_RHS_BOUNDARY>
+__device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const LhsMapper lhs, const RhsMapper rhs,
+                                                                         const OutputMapper output,
+                                                                         float2 lhs_shmem2[][16],
+                                                                         float2 rhs_shmem2[][8], const Index m_size,
+                                                                         const Index n_size, const Index k_size,
+                                                                         const Index base_m, const Index base_n) {
+  // prefetch registers
+  float4 lhs_pf0, rhs_pf0;
+
+  float4 results[4];
+  const Index thread_x = threadIdx.x;
+  const Index thread_y = threadIdx.y;
+  for (int i = 0; i < 4; i++) {
+    results[i].x = results[i].y = results[i].z = results[i].w = 0;
+  }
+
+#define prefetch_lhs(reg, row, col)                                 \
+  if (!CHECK_LHS_BOUNDARY) {                                        \
+    if (col < k_size) {                                             \
+      reg = lhs.template loadPacket<float4, Unaligned>(row, col);   \
+    }                                                               \
+  } else {                                                          \
+    if (col < k_size) {                                             \
+      if (row + 3 < m_size) {                                       \
+        reg = lhs.template loadPacket<float4, Unaligned>(row, col); \
+      } else if (row + 2 < m_size) {                                \
+        reg.x = lhs(row + 0, col);                                  \
+        reg.y = lhs(row + 1, col);                                  \
+        reg.z = lhs(row + 2, col);                                  \
+      } else if (row + 1 < m_size) {                                \
+        reg.x = lhs(row + 0, col);                                  \
+        reg.y = lhs(row + 1, col);                                  \
+      } else if (row < m_size) {                                    \
+        reg.x = lhs(row + 0, col);                                  \
+      }                                                             \
+    }                                                               \
+  }
+
+  Index lhs_vert = base_m + thread_x * 4;
+
+  for (Index k = 0; k < k_size; k += 16) {
+    lhs_pf0 = internal::pset1<float4>(0);
+    rhs_pf0 = internal::pset1<float4>(0);
+
+    Index lhs_horiz = thread_y + k;
+    prefetch_lhs(lhs_pf0, lhs_vert, lhs_horiz)
+
+        Index rhs_vert = k + (thread_x % 4) * 4;
+    Index rhs_horiz0 = (thread_x >> 2) + thread_y * 4 + base_n;
+
+    if (!CHECK_RHS_BOUNDARY) {
+      if ((rhs_vert + 3) < k_size) {
+        // just CHECK_RHS_BOUNDARY
+        rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
+      } else if (rhs_vert + 2 < k_size) {
+        // just CHECK_RHS_BOUNDARY
+        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+        rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
+      } else if (rhs_vert + 1 < k_size) {
+        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+      } else if (rhs_vert < k_size) {
+        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+      }
+    } else {
+      if (rhs_horiz0 < n_size) {
+        if ((rhs_vert + 3) < k_size) {
+          rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
+        } else if ((rhs_vert + 2) < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+          rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
+        } else if ((rhs_vert + 1) < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+        } else if (rhs_vert < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        }
+      }
+    }
+    float x1, x2;
+    // TODO: The following can be a bitwise operation.
+    if ((thread_x % 8) < 4) {
+      x1 = rhs_pf0.y;
+      x2 = rhs_pf0.w;
+    } else {
+      x1 = rhs_pf0.x;
+      x2 = rhs_pf0.z;
+    }
+#if defined(EIGEN_HIPCC)
+    x1 = __shfl_xor(x1, 4);
+    x2 = __shfl_xor(x2, 4);
+#else
+    x1 = __shfl_xor_sync(0xFFFFFFFF, x1, 4);
+    x2 = __shfl_xor_sync(0xFFFFFFFF, x2, 4);
+#endif
+    if ((thread_x % 8) < 4) {
+      rhs_pf0.y = x1;
+      rhs_pf0.w = x2;
+    } else {
+      rhs_pf0.x = x1;
+      rhs_pf0.z = x2;
+    }
+
+    // We have 64 features.
+    // Row 0 -> times (0, 4, 8, 12, 1, 5, 9, 13) for features 0, 1.
+    // Row 1 -> times (0, 4, 8, 12, 1, 5, 9, 13) for features 2, 3.
+    // ...
+    // Row 31 -> times (0, 4, 8, 12, 1, 5, 9, 13) for features 62, 63
+    // Row 32 -> times (2, 6, 10, 14, 3, 7, 11, 15) for features 0, 1
+    // ...
+    rhs_shmem2[(thread_x >> 3) + thread_y * 2][thread_x % 8] = make_float2(rhs_pf0.x, rhs_pf0.y);
+    rhs_shmem2[(thread_x >> 3) + thread_y * 2 + 32][thread_x % 8] = make_float2(rhs_pf0.z, rhs_pf0.w);
+
+    // Row 0 (time 0) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61)
+    // Row 1 (time 1) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61)
+    // ...
+    // Row 15 (time 15) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61)
+    // Row 16 (time 0) -> features (2, 3), (6, 7), .. (30, 31), (34, 35), ..  (62, 63)
+    // ...
+
+    lhs_shmem2[thread_y][thread_x] = make_float2(lhs_pf0.x, lhs_pf0.y);
+    lhs_shmem2[thread_y + 16][thread_x] = make_float2(lhs_pf0.z, lhs_pf0.w);
+
+#define add_vals(fl1, fl2, fr1, fr2) \
+  results[0].x += fl1.x * fr1.x;     \
+  results[0].y += fl1.y * fr1.x;     \
+  results[0].z += fl2.x * fr1.x;     \
+  results[0].w += fl2.y * fr1.x;     \
+                                     \
+  results[1].x += fl1.x * fr1.y;     \
+  results[1].y += fl1.y * fr1.y;     \
+  results[1].z += fl2.x * fr1.y;     \
+  results[1].w += fl2.y * fr1.y;     \
+                                     \
+  results[2].x += fl1.x * fr2.x;     \
+  results[2].y += fl1.y * fr2.x;     \
+  results[2].z += fl2.x * fr2.x;     \
+  results[2].w += fl2.y * fr2.x;     \
+                                     \
+  results[3].x += fl1.x * fr2.y;     \
+  results[3].y += fl1.y * fr2.y;     \
+  results[3].z += fl2.x * fr2.y;     \
+  results[3].w += fl2.y * fr2.y;
+
+    __syncthreads();
+
+// Do the multiplies.
+#pragma unroll
+    for (int koff = 0; koff < 16; koff++) {
+      // 32 x threads.
+      float2 fl1 = lhs_shmem2[koff][thread_x];
+      float2 fl2 = lhs_shmem2[koff + 16][thread_x];
+
+      int start_feature = thread_y * 4;
+      float2 fr1 = rhs_shmem2[(start_feature >> 1) + 32 * ((koff % 4) / 2)][koff / 4 + (koff % 2) * 4];
+      float2 fr2 = rhs_shmem2[(start_feature >> 1) + 1 + 32 * ((koff % 4) / 2)][koff / 4 + (koff % 2) * 4];
+
+      add_vals(fl1, fl2, fr1, fr2)
+    }
+    __syncthreads();
+  }
+
+#undef prefetch_lhs
+#undef add_vals
+
+  Index horiz_base = thread_y * 4 + base_n;
+  if (!CHECK_LHS_BOUNDARY && !CHECK_RHS_BOUNDARY) {
+    for (int i = 0; i < 4; i++) {
+      output(lhs_vert, horiz_base + i) = results[i].x;
+      output(lhs_vert + 1, horiz_base + i) = results[i].y;
+      output(lhs_vert + 2, horiz_base + i) = results[i].z;
+      output(lhs_vert + 3, horiz_base + i) = results[i].w;
+    }
+  } else if (!CHECK_RHS_BOUNDARY) {
+    // CHECK LHS
+    if (lhs_vert + 3 < m_size) {
+      for (int i = 0; i < 4; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        output(lhs_vert + 2, horiz_base + i) = results[i].z;
+        output(lhs_vert + 3, horiz_base + i) = results[i].w;
+      }
+    } else if (lhs_vert + 2 < m_size) {
+      for (int i = 0; i < 4; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        output(lhs_vert + 2, horiz_base + i) = results[i].z;
+      }
+    } else if (lhs_vert + 1 < m_size) {
+      for (int i = 0; i < 4; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+      }
+    } else if (lhs_vert < m_size) {
+      for (int i = 0; i < 4; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+      }
+    }
+  } else if (!CHECK_LHS_BOUNDARY) {
+    // CHECK RHS
+    for (int i = 0; i < 4; i++) {
+      if (horiz_base + i < n_size) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        output(lhs_vert + 2, horiz_base + i) = results[i].z;
+        output(lhs_vert + 3, horiz_base + i) = results[i].w;
+      }
+    }
+  } else {
+    // CHECK both boundaries.
+    for (int i = 0; i < 4; i++) {
+      if (horiz_base + i < n_size) {
+        if (lhs_vert < m_size) output(lhs_vert, horiz_base + i) = results[i].x;
+        if (lhs_vert + 1 < m_size) output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        if (lhs_vert + 2 < m_size) output(lhs_vert + 2, horiz_base + i) = results[i].z;
+        if (lhs_vert + 3 < m_size) output(lhs_vert + 3, horiz_base + i) = results[i].w;
+      }
+    }
+  }
+}
+
+template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper, bool CHECK_LHS_BOUNDARY,
+          bool CHECK_RHS_BOUNDARY>
+__device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMapper lhs, const RhsMapper rhs,
+                                                                    const OutputMapper output, float2 lhs_shmem2[][32],
+                                                                    float2 rhs_shmem2[][8], const Index m_size,
+                                                                    const Index n_size, const Index k_size,
+                                                                    const Index base_m, const Index base_n) {
+  // prefetch registers
+  float4 lhs_pf0, lhs_pf1, lhs_pf2, lhs_pf3;
+  float4 rhs_pf0, rhs_pf1;
+
+  float4 results[8];
+  const Index thread_x = threadIdx.x;
+  const Index thread_y = threadIdx.y;
+
+  for (int i = 0; i < 8; i++) {
+    results[i].x = results[i].y = results[i].z = results[i].w = 0;
+  }
+
+  Index lhs_vert = base_m + thread_x * 4 + (thread_y % 4) * 32;
+
+  for (Index k = 0; k < k_size; k += 32) {
+    lhs_pf0 = internal::pset1<float4>(0);
+    lhs_pf1 = internal::pset1<float4>(0);
+    lhs_pf2 = internal::pset1<float4>(0);
+    lhs_pf3 = internal::pset1<float4>(0);
+
+    rhs_pf0 = internal::pset1<float4>(0);
+    rhs_pf1 = internal::pset1<float4>(0);
+
+    if (!CHECK_LHS_BOUNDARY) {
+      if ((thread_y / 4 + k + 24) < k_size) {
+        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+        lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
+        lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
+        lhs_pf3 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 24));
+      } else if ((thread_y / 4 + k + 16) < k_size) {
+        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+        lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
+        lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
+      } else if ((thread_y / 4 + k + 8) < k_size) {
+        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+        lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
+      } else if ((thread_y / 4 + k) < k_size) {
+        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+      }
+    } else {
+      // just CHECK_LHS_BOUNDARY
+      if (lhs_vert + 3 < m_size) {
+        if ((thread_y / 4 + k + 24) < k_size) {
+          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+          lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
+          lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
+          lhs_pf3 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 24));
+        } else if ((thread_y / 4 + k + 16) < k_size) {
+          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+          lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
+          lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
+        } else if ((thread_y / 4 + k + 8) < k_size) {
+          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+          lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
+        } else if ((thread_y / 4 + k) < k_size) {
+          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
+        }
+      } else if (lhs_vert + 2 < m_size) {
+        if ((thread_y / 4 + k + 24) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
+          lhs_pf1.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 8));
+          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
+          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
+          lhs_pf2.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 16));
+          lhs_pf3.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 24));
+          lhs_pf3.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 24));
+          lhs_pf3.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 24));
+        } else if ((thread_y / 4 + k + 16) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
+          lhs_pf1.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 8));
+          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
+          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
+          lhs_pf2.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 16));
+        } else if ((thread_y / 4 + k + 8) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
+          lhs_pf1.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 8));
+        } else if ((thread_y / 4 + k) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
+        }
+      } else if (lhs_vert + 1 < m_size) {
+        if ((thread_y / 4 + k + 24) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
+          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
+          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
+          lhs_pf3.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 24));
+          lhs_pf3.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 24));
+        } else if ((thread_y / 4 + k + 16) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
+          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
+          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
+        } else if ((thread_y / 4 + k + 8) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
+        } else if ((thread_y / 4 + k) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
+        }
+      } else if (lhs_vert < m_size) {
+        if ((thread_y / 4 + k + 24) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
+          lhs_pf3.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 24));
+        } else if ((thread_y / 4 + k + 16) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
+        } else if ((thread_y / 4 + k + 8) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
+        } else if ((thread_y / 4 + k) < k_size) {
+          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
+        }
+      }
+    }
+    __syncthreads();
+    Index rhs_vert = k + thread_x * 4;
+    Index rhs_horiz0 = thread_y * 2 + base_n;
+    Index rhs_horiz1 = thread_y * 2 + 1 + base_n;
+    if (!CHECK_RHS_BOUNDARY) {
+      if ((rhs_vert + 3) < k_size) {
+        // just CHECK_RHS_BOUNDARY
+        rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
+        rhs_pf1 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz1);
+      } else if (rhs_vert + 2 < k_size) {
+        // just CHECK_RHS_BOUNDARY
+        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+        rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
+        rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
+        rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
+        rhs_pf1.z = rhs(rhs_vert + 2, rhs_horiz1);
+      } else if (rhs_vert + 1 < k_size) {
+        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+        rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
+        rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
+      } else if (rhs_vert < k_size) {
+        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
+      }
+    } else {
+      if (rhs_horiz1 < n_size) {
+        if ((rhs_vert + 3) < k_size) {
+          // just CHECK_RHS_BOUNDARY
+          rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
+          rhs_pf1 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz1);
+        } else if (rhs_vert + 2 < k_size) {
+          // just CHECK_RHS_BOUNDARY
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+          rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
+          rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
+          rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
+          rhs_pf1.z = rhs(rhs_vert + 2, rhs_horiz1);
+        } else if (k + thread_x * 4 + 1 < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+          rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
+          rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
+        } else if (k + thread_x * 4 < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
+        }
+      } else if (rhs_horiz0 < n_size) {
+        if ((rhs_vert + 3) < k_size) {
+          // just CHECK_RHS_BOUNDARY
+          rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
+        } else if ((rhs_vert + 2) < k_size) {
+          // just CHECK_RHS_BOUNDARY
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+          rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
+        } else if ((rhs_vert + 1) < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
+        } else if (rhs_vert < k_size) {
+          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+        }
+      }
+    }
+    __syncthreads();
+    // Loaded. Do computation
+    // Row 0 -> times (0, 4, 8, .. 28) for features 0, 1.
+    // Row 1 -> times (0, 4, 8, .. 28) for features 2, 3.
+    // ..
+    // Row 31 -> times (0, 4, 8, .. 28) for features 62, 63
+    rhs_shmem2[thread_y][thread_x] = make_float2(rhs_pf0.x, rhs_pf1.x);
+    // Row 32 -> times (1, 5, 9, .. 29) for features 0, 1.
+    // Row 33 -> times (1, 5, 9, .. 29) for features 2, 3.
+    // ..
+    rhs_shmem2[thread_y + 32][thread_x] = make_float2(rhs_pf0.y, rhs_pf1.y);
+    // Row 64 -> times (2, 6, 10, .. 30) for features 0, 1.
+    // Row 65 -> times (2, 6, 10, .. 30) for features 2, 3.
+    rhs_shmem2[thread_y + 64][thread_x] = make_float2(rhs_pf0.z, rhs_pf1.z);
+    // Row 96 -> times (3, 7, 11, .. 31) for features 0, 1.
+    // Row 97 -> times (3, 7, 11, .. 31) for features 2, 3.
+    rhs_shmem2[thread_y + 96][thread_x] = make_float2(rhs_pf0.w, rhs_pf1.w);
+
+    // LHS.
+    // Row 0 (time 0) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61) .. (124, 125)
+    // Row 1 (time 1) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61) .. (124, 125)
+    // ...
+    // Row 8 (time 0) -> features (2, 3), (6, 7), .. (30, 31), (34, 35), ..  (62, 63) .. (126, 127)
+    // Row 15 (time 7) -> features (2, 3), (6, 7), .. (30, 31), (34, 35), ..  (62, 63) .. (126, 127)
+
+#define add_vals(a_feat1, a_feat2, f1, f2, f3, f4) \
+  results[0].x += a_feat1.x * f1.x;                \
+  results[1].x += a_feat1.x * f1.y;                \
+  results[2].x += a_feat1.x * f2.x;                \
+  results[3].x += a_feat1.x * f2.y;                \
+  results[4].x += a_feat1.x * f3.x;                \
+  results[5].x += a_feat1.x * f3.y;                \
+  results[6].x += a_feat1.x * f4.x;                \
+  results[7].x += a_feat1.x * f4.y;                \
+                                                   \
+  results[0].y += a_feat1.y * f1.x;                \
+  results[1].y += a_feat1.y * f1.y;                \
+  results[2].y += a_feat1.y * f2.x;                \
+  results[3].y += a_feat1.y * f2.y;                \
+  results[4].y += a_feat1.y * f3.x;                \
+  results[5].y += a_feat1.y * f3.y;                \
+  results[6].y += a_feat1.y * f4.x;                \
+  results[7].y += a_feat1.y * f4.y;                \
+                                                   \
+  results[0].z += a_feat2.x * f1.x;                \
+  results[1].z += a_feat2.x * f1.y;                \
+  results[2].z += a_feat2.x * f2.x;                \
+  results[3].z += a_feat2.x * f2.y;                \
+  results[4].z += a_feat2.x * f3.x;                \
+  results[5].z += a_feat2.x * f3.y;                \
+  results[6].z += a_feat2.x * f4.x;                \
+  results[7].z += a_feat2.x * f4.y;                \
+                                                   \
+  results[0].w += a_feat2.y * f1.x;                \
+  results[1].w += a_feat2.y * f1.y;                \
+  results[2].w += a_feat2.y * f2.x;                \
+  results[3].w += a_feat2.y * f2.y;                \
+  results[4].w += a_feat2.y * f3.x;                \
+  results[5].w += a_feat2.y * f3.y;                \
+  results[6].w += a_feat2.y * f4.x;                \
+  results[7].w += a_feat2.y * f4.y;
+
+    lhs_shmem2[thread_y / 4][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf0.x, lhs_pf0.y);
+    lhs_shmem2[thread_y / 4 + 8][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf1.x, lhs_pf1.y);
+    lhs_shmem2[thread_y / 4 + 16][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf2.x, lhs_pf2.y);
+    lhs_shmem2[thread_y / 4 + 24][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf3.x, lhs_pf3.y);
+
+    lhs_shmem2[thread_y / 4 + 32][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf0.z, lhs_pf0.w);
+    lhs_shmem2[thread_y / 4 + 40][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf1.z, lhs_pf1.w);
+    lhs_shmem2[thread_y / 4 + 48][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf2.z, lhs_pf2.w);
+    lhs_shmem2[thread_y / 4 + 56][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf3.z, lhs_pf3.w);
+
+    __syncthreads();
+
+// Do the multiplies.
+#pragma unroll
+    for (int koff = 0; koff < 32; koff++) {
+      float2 a3 = lhs_shmem2[koff][thread_x + (thread_y % 4) * 8];
+      float2 a4 = lhs_shmem2[koff + 32][thread_x + (thread_y % 4) * 8];
+
+      // first feature is at (thread_y/4) * 8 last is at start + 8.
+      int start_feature = (thread_y / 4) * 8;
+
+      float2 br1 = rhs_shmem2[start_feature / 2 + (koff % 4) * 32][koff / 4];
+      float2 br2 = rhs_shmem2[start_feature / 2 + 1 + (koff % 4) * 32][koff / 4];
+      float2 br3 = rhs_shmem2[start_feature / 2 + 2 + (koff % 4) * 32][koff / 4];
+      float2 br4 = rhs_shmem2[start_feature / 2 + 3 + (koff % 4) * 32][koff / 4];
+
+      add_vals(a3, a4, br1, br2, br3, br4)
+    }
+    __syncthreads();
+  }  // end loop over k
+
+#undef add_vals
+
+  __syncthreads();
+  Index horiz_base = (thread_y / 4) * 8 + base_n;
+  if (!CHECK_LHS_BOUNDARY && !CHECK_RHS_BOUNDARY) {
+    for (int i = 0; i < 8; i++) {
+      output(lhs_vert, horiz_base + i) = results[i].x;
+      output(lhs_vert + 1, horiz_base + i) = results[i].y;
+      output(lhs_vert + 2, horiz_base + i) = results[i].z;
+      output(lhs_vert + 3, horiz_base + i) = results[i].w;
+    }
+  } else if (!CHECK_RHS_BOUNDARY) {
+    if (lhs_vert + 3 < m_size) {
+      for (int i = 0; i < 8; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        output(lhs_vert + 2, horiz_base + i) = results[i].z;
+        output(lhs_vert + 3, horiz_base + i) = results[i].w;
+      }
+    } else if (lhs_vert + 2 < m_size) {
+      for (int i = 0; i < 8; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        output(lhs_vert + 2, horiz_base + i) = results[i].z;
+      }
+    } else if (lhs_vert + 1 < m_size) {
+      for (int i = 0; i < 8; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+      }
+    } else if (lhs_vert < m_size) {
+      for (int i = 0; i < 8; i++) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+      }
+    }
+  } else if (!CHECK_LHS_BOUNDARY) {
+    // CHECK BOUNDARY_B
+    for (int i = 0; i < 8; i++) {
+      if (horiz_base + i < n_size) {
+        output(lhs_vert, horiz_base + i) = results[i].x;
+        output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        output(lhs_vert + 2, horiz_base + i) = results[i].z;
+        output(lhs_vert + 3, horiz_base + i) = results[i].w;
+      }
+    }
+  } else {
+    // CHECK both boundaries.
+    for (int i = 0; i < 8; i++) {
+      if (horiz_base + i < n_size) {
+        if (lhs_vert < m_size) output(lhs_vert, horiz_base + i) = results[i].x;
+        if (lhs_vert + 1 < m_size) output(lhs_vert + 1, horiz_base + i) = results[i].y;
+        if (lhs_vert + 2 < m_size) output(lhs_vert + 2, horiz_base + i) = results[i].z;
+        if (lhs_vert + 3 < m_size) output(lhs_vert + 3, horiz_base + i) = results[i].w;
+      }
+    }
+  }
+}
+
+template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
+__global__ void
+#if defined(EIGEN_HIPCC)
+__launch_bounds__(256, 1)
+#else
+__launch_bounds__(256)
+#endif
+    EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
+                                const Index n_size, const Index k_size) {
+  __shared__ float2 lhs_shmem[64 * 32];
+  __shared__ float2 rhs_shmem[128 * 8];
+
+  typedef float2 LHS_MEM[64][32];
+  typedef float2 RHS_MEM[128][8];
+
+  const Index m_block_idx = blockIdx.x;
+  const Index n_block_idx = blockIdx.y;
+
+  const Index base_m = 128 * m_block_idx;
+  const Index base_n = 64 * n_block_idx;
+
+  bool check_rhs = (base_n + 63) >= n_size;
+  bool check_lhs128 = (base_m + 127) >= m_size;
+
+  if (!check_rhs) {
+    if (!check_lhs128) {
+      // >= 128 rows left
+      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
+          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
+    } else {
+      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
+          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
+    }
+  } else {
+    if (!check_lhs128) {
+      // >= 128 rows left
+      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
+          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
+    } else {
+      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
+          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
+    }
+  }
+}
+
+template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
+__global__ void
+#if defined(EIGEN_HIPCC)
+__launch_bounds__(256, 1)
+#else
+__launch_bounds__(256)
+#endif
+    EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
+                                     const Index m_size, const Index n_size, const Index k_size) {
+  __shared__ float2 lhs_shmem[32][16];
+  __shared__ float2 rhs_shmem[64][8];
+
+  const Index m_block_idx = blockIdx.x;
+  const Index n_block_idx = blockIdx.y;
+
+  const Index base_m = 64 * m_block_idx;
+  const Index base_n = 64 * n_block_idx;
+
+  if (base_m + 63 < m_size) {
+    if (base_n + 63 < n_size) {
+      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
+          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
+    } else {
+      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
+          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
+    }
+  } else {
+    if (base_n + 63 < n_size) {
+      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
+          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
+    } else {
+      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
+          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
+    }
+  }
+}
+
+template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
+struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
+    : public TensorContractionEvaluatorBase<TensorEvaluator<
+          const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice> > {
+  typedef GpuDevice Device;
+
+  typedef TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device> Self;
+  typedef TensorContractionEvaluatorBase<Self> Base;
+
+  typedef TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType> XprType;
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef typename XprType::Index Index;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, GpuDevice>::type PacketReturnType;
+
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+
+  // Most of the code is assuming that both input tensors are ColMajor. If the
+  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
+  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
+  // will pretend B is LHS and A is RHS.
+  typedef std::conditional_t<Layout == static_cast<int>(ColMajor), LeftArgType, RightArgType> EvalLeftArgType;
+  typedef std::conditional_t<Layout == static_cast<int>(ColMajor), RightArgType, LeftArgType> EvalRightArgType;
+
+  static constexpr int LDims =
+      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
+  static constexpr int RDims =
+      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
+  static constexpr int ContractDims = internal::array_size<Indices>::value;
+
+  typedef array<Index, LDims> left_dim_mapper_t;
+  typedef array<Index, RDims> right_dim_mapper_t;
+
+  typedef array<Index, ContractDims> contract_t;
+  typedef array<Index, LDims - ContractDims> left_nocontract_t;
+  typedef array<Index, RDims - ContractDims> right_nocontract_t;
+
+  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
+
+  typedef DSizes<Index, NumDims> Dimensions;
+
+  // typedefs needed in evalTo
+  typedef std::remove_const_t<typename EvalLeftArgType::Scalar> LhsScalar;
+  typedef std::remove_const_t<typename EvalRightArgType::Scalar> RhsScalar;
+
+  typedef TensorEvaluator<EvalLeftArgType, Device> LeftEvaluator;
+  typedef TensorEvaluator<EvalRightArgType, Device> RightEvaluator;
+
+  typedef typename LeftEvaluator::Dimensions LeftDimensions;
+  typedef typename RightEvaluator::Dimensions RightDimensions;
+
+  TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {
+    EIGEN_STATIC_ASSERT((std::is_same<OutputKernelType, const NoOpOutputKernel>::value),
+                        GPU_TENSOR_CONTRACTION_DOES_NOT_SUPPORT_OUTPUT_KERNELS);
+  }
+
+  // We need to redefine this method to make nvcc happy
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* data) {
+    this->m_leftImpl.evalSubExprsIfNeeded(nullptr);
+    this->m_rightImpl.evalSubExprsIfNeeded(nullptr);
+    if (data) {
+      evalTo(data);
+      return false;
+    } else {
+      this->m_result = static_cast<Scalar*>(this->m_device.allocate(this->dimensions().TotalSize() * sizeof(Scalar)));
+      evalTo(this->m_result);
+      return true;
+    }
+  }
+
+  void evalTo(Scalar* buffer) const {
+    if (this->m_lhs_inner_dim_contiguous) {
+      if (this->m_rhs_inner_dim_contiguous) {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<true, true, true, Unaligned>(buffer);
+        } else {
+          evalTyped<true, true, false, Unaligned>(buffer);
+        }
+      } else {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<true, false, true, Unaligned>(buffer);
+        } else {
+          evalTyped<true, false, false, Unaligned>(buffer);
+        }
+      }
+    } else {
+      if (this->m_rhs_inner_dim_contiguous) {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<false, true, true, Unaligned>(buffer);
+        } else {
+          evalTyped<false, true, false, Unaligned>(buffer);
+        }
+      } else {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<false, false, true, Unaligned>(buffer);
+        } else {
+          evalTyped<false, false, false, Unaligned>(buffer);
+        }
+      }
+    }
+  }
+
+  template <int Alignment>
+  void evalProduct(Scalar* buffer) const {
+    evalTo(buffer);
+  }
+
+  template <typename LhsScalar, typename RhsScalar, typename Index, typename LhsMapper, typename RhsMapper,
+            typename OutputMapper, bool UseNaiveKernel>
+  struct LaunchKernelsImpl;
+
+  template <typename LhsScalar, typename RhsScalar, typename Index, typename LhsMapper, typename RhsMapper,
+            typename OutputMapper>
+  struct LaunchKernelsImpl<LhsScalar, RhsScalar, Index, LhsMapper, RhsMapper, OutputMapper, false> {
+    static void Run(const LhsMapper& lhs, const RhsMapper& rhs, const OutputMapper& output, Index m, Index n, Index k,
+                    const GpuDevice& device) {
+      const Index m_blocks = (m + 63) / 64;
+      const Index n_blocks = (n + 63) / 64;
+      const dim3 num_blocks(m_blocks, n_blocks, 1);
+      const dim3 block_size(8, 8, 8);
+      LAUNCH_GPU_KERNEL((EigenContractionKernel<Scalar, Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
+                        block_size, 0, device, lhs, rhs, output, m, n, k);
+    }
+  };
+
+  template <typename LhsScalar, typename RhsScalar, typename Index, typename LhsMapper, typename RhsMapper,
+            typename OutputMapper>
+  struct LaunchKernelsImpl<LhsScalar, RhsScalar, Index, LhsMapper, RhsMapper, OutputMapper, true> {
+    static void Run(const LhsMapper& lhs, const RhsMapper& rhs, const OutputMapper& output, Index m, Index n, Index k,
+                    const GpuDevice& device) {
+      const dim3 block_size(16, 16, 1);
+      const dim3 num_blocks((m + 15) / 16, (n + 15) / 16, 1);
+      LAUNCH_GPU_KERNEL((EigenContractionKernelNaive<Scalar, Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
+                        block_size, 0, device, lhs, rhs, output, m, n, k);
+    }
+  };
+
+  template <typename LhsScalar, typename RhsScalar, typename Index, typename LhsMapper, typename RhsMapper,
+            typename OutputMapper>
+  // The optimized generic kernel reserves two 72x64 shared-memory tiles. With 8-byte scalars that exceeds
+  // the 48KB static shared-memory limit of common CUDA targets, so use a slower no-shared-memory fallback.
+  struct LaunchKernels
+      : LaunchKernelsImpl<LhsScalar, RhsScalar, Index, LhsMapper, RhsMapper, OutputMapper, (sizeof(Scalar) > 4)> {};
+
+  template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
+  struct LaunchKernels<float, float, Index, LhsMapper, RhsMapper, OutputMapper> {
+    static void Run(const LhsMapper& lhs, const RhsMapper& rhs, const OutputMapper& output, Index m, Index n, Index k,
+                    const GpuDevice& device) {
+      if (m < 768 || n < 768) {
+        const Index m_blocks = (m + 63) / 64;
+        const Index n_blocks = (n + 63) / 64;
+        const dim3 num_blocks(m_blocks, n_blocks, 1);
+        const dim3 block_size(16, 16, 1);
+        LAUNCH_GPU_KERNEL((EigenFloatContractionKernel16x16<Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
+                          block_size, 0, device, lhs, rhs, output, m, n, k);
+      } else {
+        const Index m_blocks = (m + 127) / 128;
+        const Index n_blocks = (n + 63) / 64;
+        const dim3 num_blocks(m_blocks, n_blocks, 1);
+        const dim3 block_size(8, 32, 1);
+        LAUNCH_GPU_KERNEL((EigenFloatContractionKernel<Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
+                          block_size, 0, device, lhs, rhs, output, m, n, k);
+      }
+    }
+  };
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
+  void evalTyped(Scalar* buffer) const {
+    // columns in left side, rows in right side
+    const Index k = this->m_k_size;
+    // rows in left side
+    const Index m = this->m_i_size;
+
+    // columns in right side
+    const Index n = this->m_j_size;
+
+    if (m == 0 || n == 0) return;
+
+    // zero out the result buffer (which must be of size at least m * n * sizeof(Scalar))
+    this->m_device.fill(buffer, buffer + m * n, Scalar(0));
+
+    if (k == 0) return;
+
+    typedef internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
+                                                   contract_t, 4, lhs_inner_dim_contiguous, false, Unaligned>
+        LhsMapper;
+
+    typedef internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
+                                                   contract_t, 4, rhs_inner_dim_contiguous, rhs_inner_dim_reordered,
+                                                   Unaligned>
+        RhsMapper;
+
+    typedef internal::blas_data_mapper<Scalar, Index, ColMajor> OutputMapper;
+
+    // initialize data mappers
+    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
+                  this->m_left_contracting_strides, this->m_k_strides);
+
+    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
+                  this->m_right_contracting_strides, this->m_k_strides);
+
+    OutputMapper output(buffer, m);
+    LaunchKernels<LhsScalar, RhsScalar, Index, LhsMapper, RhsMapper, OutputMapper>::Run(lhs, rhs, output, m, n, k,
+                                                                                        this->m_device);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_USE_GPU and EIGEN_GPUCC
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_GPU_H
diff --git a/contrib/Eigen/src/Tensor/TensorContractionMapper.h b/contrib/Eigen/src/Tensor/TensorContractionMapper.h
new file mode 100644
index 0000000..f819761
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContractionMapper.h
@@ -0,0 +1,532 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_MAPPER_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_MAPPER_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+constexpr int Rhs = 0;
+constexpr int Lhs = 1;
+
+/*
+ * Implementation of the Eigen blas_data_mapper class for tensors.
+ */
+/// The make pointer class is used by sycl in order to build the mapper class on the device. For other platforms the
+/// default make pointer is used which is scalar * for CoeffLoader.
+template <typename Tensor, bool HasRawAccess, template <class> class MakePointer_ = MakePointer>
+struct CoeffLoader;
+
+template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
+          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
+          template <class> class MakePointer_ = MakePointer>
+class BaseTensorContractionMapper;
+
+template <typename Tensor, bool HasRawAccess, template <class> class MakePointer_>
+struct CoeffLoader {
+  static constexpr bool DirectOffsets = false;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffLoader(const Tensor& tensor) : m_tensor(tensor) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void offsetBuffer(typename Tensor::Index) {
+    eigen_assert(false && "unsupported");
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const typename MakePointer_<const typename Tensor::Scalar>::Type data() const {
+    eigen_assert(false && "unsupported");
+    return nullptr;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename Tensor::Scalar coeff(typename Tensor::Index index) const {
+    return m_tensor.coeff(index);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Tensor::PacketReturnType packet(typename Tensor::Index index) const {
+    return m_tensor.template packet<LoadMode>(index);
+  }
+
+ private:
+  const Tensor m_tensor;
+};
+
+template <typename Tensor, template <class> class MakePointer_>
+struct CoeffLoader<Tensor, true, MakePointer_> {
+  static constexpr bool DirectOffsets = true;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffLoader(const Tensor& tensor) : m_data(tensor.data()) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void offsetBuffer(typename Tensor::Index offset) { m_data += offset; }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const typename MakePointer_<const typename Tensor::Scalar>::Type data() const {
+    return m_data;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename Tensor::Scalar coeff(typename Tensor::Index index) const {
+    return loadConstant(m_data + index);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Tensor::PacketReturnType packet(typename Tensor::Index index) const {
+    return internal::ploadt_ro<typename Tensor::PacketReturnType, LoadMode>(m_data + index);
+  }
+
+ private:
+  using Scalar = typename Tensor::Scalar;
+
+  typename MakePointer_<const Scalar>::Type m_data;
+};
+
+template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
+          int packet_size, bool inner_dim_contiguous, int Alignment, template <class> class MakePointer_ = MakePointer>
+class SimpleTensorContractionMapper {
+ public:
+  EIGEN_DEVICE_FUNC SimpleTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
+                                                  const nocontract_t& ij_strides, const contract_t& contract_strides,
+                                                  const contract_t& k_strides)
+      : m_tensor(tensor),
+        m_nocontract_strides(nocontract_strides),
+        m_ij_strides(ij_strides),
+        m_contract_strides(contract_strides),
+        m_k_strides(k_strides) {}
+
+  static constexpr bool DirectOffsets = CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_>::DirectOffsets;
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void offsetBuffer(typename Tensor::Index offset) {
+    m_tensor.offsetBuffer(offset);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void prefetch(Index /*i*/) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(Index row) const {
+    // column major assumption
+    return operator()(row, 0);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(Index row, Index col) const {
+    return m_tensor.coeff(computeIndex(row, col));
+  }
+
+#ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator[](Index row, Index col) const { return operator()(row, col); }
+#endif
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index computeIndex(Index row, Index col) const {
+    const bool left = (side == Lhs);
+    Index nocontract_val = left ? row : col;
+    Index linidx = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = static_cast<int>(array_size<nocontract_t>::value) - 1; i > 0; i--) {
+      const Index idx = nocontract_val / m_ij_strides[i];
+      linidx += idx * m_nocontract_strides[i];
+      nocontract_val -= idx * m_ij_strides[i];
+    }
+    EIGEN_IF_CONSTEXPR (array_size<typename Tensor::Dimensions>::value > array_size<contract_t>::value) {
+      EIGEN_IF_CONSTEXPR (side == Lhs && inner_dim_contiguous) {
+        eigen_assert(m_nocontract_strides[0] == 1);
+        linidx += nocontract_val;
+      } else {
+        linidx += nocontract_val * m_nocontract_strides[0];
+      }
+    }
+
+    Index contract_val = left ? col : row;
+    EIGEN_IF_CONSTEXPR (array_size<contract_t>::value > 0) {
+      EIGEN_UNROLL_LOOP
+      for (int i = static_cast<int>(array_size<contract_t>::value) - 1; i > 0; i--) {
+        const Index idx = contract_val / m_k_strides[i];
+        linidx += idx * m_contract_strides[i];
+        contract_val -= idx * m_k_strides[i];
+      }
+
+      EIGEN_IF_CONSTEXPR (side == Rhs && inner_dim_contiguous) {
+        eigen_assert(m_contract_strides[0] == 1);
+        linidx += contract_val;
+      } else {
+        linidx += contract_val * m_contract_strides[0];
+      }
+    }
+
+    return linidx;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexPair<Index> computeIndexPair(Index row, Index col,
+                                                                          const Index distance) const {
+    const bool left = (side == Lhs);
+    Index nocontract_val[2] = {left ? row : col, left ? row + distance : col};
+    Index linidx[2] = {0, 0};
+    EIGEN_IF_CONSTEXPR (array_size<typename Tensor::Dimensions>::value > array_size<contract_t>::value) {
+      EIGEN_UNROLL_LOOP
+      for (int i = static_cast<int>(array_size<nocontract_t>::value) - 1; i > 0; i--) {
+        const Index idx0 = nocontract_val[0] / m_ij_strides[i];
+        const Index idx1 = nocontract_val[1] / m_ij_strides[i];
+        linidx[0] += idx0 * m_nocontract_strides[i];
+        linidx[1] += idx1 * m_nocontract_strides[i];
+        nocontract_val[0] -= idx0 * m_ij_strides[i];
+        nocontract_val[1] -= idx1 * m_ij_strides[i];
+      }
+      EIGEN_IF_CONSTEXPR (side == Lhs && inner_dim_contiguous) {
+        eigen_assert(m_nocontract_strides[0] == 1);
+        linidx[0] += nocontract_val[0];
+        linidx[1] += nocontract_val[1];
+      } else {
+        linidx[0] += nocontract_val[0] * m_nocontract_strides[0];
+        linidx[1] += nocontract_val[1] * m_nocontract_strides[0];
+      }
+    }
+
+    Index contract_val[2] = {left ? col : row, left ? col : row + distance};
+    EIGEN_IF_CONSTEXPR (array_size<contract_t>::value > 0) {
+      EIGEN_UNROLL_LOOP
+      for (int i = static_cast<int>(array_size<contract_t>::value) - 1; i > 0; i--) {
+        const Index idx0 = contract_val[0] / m_k_strides[i];
+        const Index idx1 = contract_val[1] / m_k_strides[i];
+        linidx[0] += idx0 * m_contract_strides[i];
+        linidx[1] += idx1 * m_contract_strides[i];
+        contract_val[0] -= idx0 * m_k_strides[i];
+        contract_val[1] -= idx1 * m_k_strides[i];
+      }
+
+      EIGEN_IF_CONSTEXPR (side == Rhs && inner_dim_contiguous) {
+        eigen_assert(m_contract_strides[0] == 1);
+        linidx[0] += contract_val[0];
+        linidx[1] += contract_val[1];
+      } else {
+        linidx[0] += contract_val[0] * m_contract_strides[0];
+        linidx[1] += contract_val[1] * m_contract_strides[0];
+      }
+    }
+    return IndexPair<Index>(linidx[0], linidx[1]);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index firstAligned(Index size) const {
+    // Only claim alignment when we can compute the actual stride (ie when we're
+    // dealing with the lhs with inner_dim_contiguous). This is because the
+    // matrix-vector product relies on the stride when dealing with aligned inputs.
+    return (Alignment == Aligned) && (side == Lhs) && inner_dim_contiguous ? 0 : size;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index stride() const {
+    return ((side == Lhs) && inner_dim_contiguous && array_size<contract_t>::value > 0) ? m_contract_strides[0] : 1;
+  }
+
+  const CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_>& tensor() const { return m_tensor; }
+
+  const nocontract_t& nocontract_strides() const { return m_nocontract_strides; }
+  const nocontract_t& ij_strides() const { return m_ij_strides; }
+  const contract_t& contract_strides() const { return m_contract_strides; }
+  const contract_t& k_strides() const { return m_k_strides; }
+
+ protected:
+  CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_> m_tensor;
+  const nocontract_t m_nocontract_strides;
+  const nocontract_t m_ij_strides;
+  const contract_t m_contract_strides;
+  const contract_t m_k_strides;
+};
+
+template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
+          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
+          template <class> class MakePointer_>
+class BaseTensorContractionMapper
+    : public SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                           inner_dim_contiguous, Alignment, MakePointer_> {
+ public:
+  using ParentMapper = SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                                     inner_dim_contiguous, Alignment, MakePointer_>;
+
+  EIGEN_DEVICE_FUNC BaseTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
+                                                const nocontract_t& ij_strides, const contract_t& contract_strides,
+                                                const contract_t& k_strides)
+      : ParentMapper(tensor, nocontract_strides, ij_strides, contract_strides, k_strides) {}
+
+  template <typename PacketT, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      std::enable_if_t<internal::unpacket_traits<PacketT>::size == packet_size, PacketT>
+      load(Index i, Index j) const {
+    // whole method makes column major assumption
+
+    // don't need to add offsets for now (because operator handles that)
+    // current code assumes packet size must be a multiple of 2
+    EIGEN_STATIC_ASSERT(packet_size % 2 == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    EIGEN_IF_CONSTEXPR (Tensor::PacketAccess && inner_dim_contiguous && !inner_dim_reordered) {
+      const Index index = this->computeIndex(i, j);
+      eigen_assert(this->computeIndex(i + packet_size - 1, j) == index + packet_size - 1);
+      return this->m_tensor.template packet<AlignmentType>(index);
+    }
+
+    const IndexPair<Index> indexPair = this->computeIndexPair(i, j, packet_size - 1);
+    const Index first = indexPair.first;
+    const Index lastIdx = indexPair.second;
+
+    // We can always do optimized packet reads from left hand side right now, because
+    // the vertical matrix dimension on the left hand side is never contracting.
+    // On the right hand side we need to check if the contracting dimensions may have
+    // been shuffled first.
+    EIGEN_IF_CONSTEXPR (Tensor::PacketAccess &&
+                        (side == Lhs || internal::array_size<contract_t>::value <= 1 || !inner_dim_reordered)) {
+      if ((lastIdx - first) == (packet_size - 1)) {
+        return this->m_tensor.template packet<AlignmentType>(first);
+      }
+    }
+
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketT>::alignment) Scalar data[packet_size];
+
+    data[0] = this->m_tensor.coeff(first);
+    EIGEN_UNROLL_LOOP
+    for (Index k = 1; k < packet_size - 1; k += 2) {
+      const IndexPair<Index> internal_pair = this->computeIndexPair(i + k, j, 1);
+      data[k] = this->m_tensor.coeff(internal_pair.first);
+      data[k + 1] = this->m_tensor.coeff(internal_pair.second);
+    }
+    data[packet_size - 1] = this->m_tensor.coeff(lastIdx);
+
+    return pload<PacketT>(data);
+  }
+
+  template <typename PacketT, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      std::enable_if_t<internal::unpacket_traits<PacketT>::size != packet_size, PacketT>
+      load(Index i, Index j) const {
+    const Index requested_packet_size = internal::unpacket_traits<PacketT>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketT>::alignment) Scalar data[requested_packet_size];
+
+    const IndexPair<Index> indexPair = this->computeIndexPair(i, j, requested_packet_size - 1);
+    const Index first = indexPair.first;
+    const Index lastIdx = indexPair.second;
+
+    data[0] = this->m_tensor.coeff(first);
+    for (Index k = 1; k < requested_packet_size - 1; k += 2) {
+      const IndexPair<Index> internal_pair = this->computeIndexPair(i + k, j, 1);
+      data[k] = this->m_tensor.coeff(internal_pair.first);
+      data[k + 1] = this->m_tensor.coeff(internal_pair.second);
+    }
+    data[requested_packet_size - 1] = this->m_tensor.coeff(lastIdx);
+
+    return pload<PacketT>(data);
+  }
+
+  template <typename PacketT, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketT loadPacket(Index i, Index j) const {
+    return this->load<PacketT, AlignmentType>(i, j);
+  }
+};
+
+template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
+          bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment, template <class> class MakePointer_>
+class BaseTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, 1, inner_dim_contiguous,
+                                  inner_dim_reordered, Alignment, MakePointer_>
+    : public SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, 1,
+                                           inner_dim_contiguous, Alignment, MakePointer_> {
+ public:
+  using ParentMapper = SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, 1,
+                                                     inner_dim_contiguous, Alignment, MakePointer_>;
+
+  EIGEN_DEVICE_FUNC BaseTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
+                                                const nocontract_t& ij_strides, const contract_t& contract_strides,
+                                                const contract_t& k_strides)
+      : ParentMapper(tensor, nocontract_strides, ij_strides, contract_strides, k_strides) {}
+
+  template <typename PacketT, int>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketT loadPacket(Index i, Index j) const {
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketT>::alignment) Scalar data[1];
+    data[0] = this->m_tensor.coeff(this->computeIndex(i, j));
+    return pload<PacketT>(data);
+  }
+  template <typename PacketT, int>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketT load(Index i, Index j) const {
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<PacketT>::alignment) Scalar data[1];
+    data[0] = this->m_tensor.coeff(this->computeIndex(i, j));
+    return pload<PacketT>(data);
+  }
+};
+
+template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
+          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
+          template <class> class MakePointer_ = MakePointer>
+class TensorContractionSubMapper {
+ public:
+  using ParentMapper = BaseTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                                   inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
+  using Self = TensorContractionSubMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                          inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
+  using LinearMapper = Self;
+  using SubMapper = Self;
+
+  // We can use direct offsets iff the parent mapper supports them and we can compute the strides.
+  // TODO: we should also enable direct offsets for the Rhs case.
+  static constexpr bool UseDirectOffsets =
+      ParentMapper::DirectOffsets && (side == Lhs) && inner_dim_contiguous && (array_size<contract_t>::value > 0);
+
+  EIGEN_DEVICE_FUNC TensorContractionSubMapper(const ParentMapper& base_mapper, Index vert_offset, Index horiz_offset)
+      : m_base_mapper(base_mapper), m_vert_offset(vert_offset), m_horiz_offset(horiz_offset) {
+    // Bake the offsets into the buffer used by the base mapper whenever possible. This avoids the need to recompute
+    // this offset every time we attempt to access a coefficient.
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      Index stride = m_base_mapper.stride();
+      m_base_mapper.offsetBuffer(vert_offset + horiz_offset * stride);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper(i, 0);
+    }
+    return m_base_mapper(i + m_vert_offset, m_horiz_offset);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i, Index j) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper(i, j);
+    }
+    return m_base_mapper(i + m_vert_offset, j + m_horiz_offset);
+  }
+
+  template <typename PacketT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacket(Index i) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper.template loadPacket<PacketT, Alignment>(i, 0);
+    }
+    return m_base_mapper.template loadPacket<PacketT, Alignment>(i + m_vert_offset, m_horiz_offset);
+  }
+
+  template <typename PacketT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacket(Index i, Index j) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper.template loadPacket<PacketT, Alignment>(i, j);
+    }
+    return m_base_mapper.template loadPacket<PacketT, Alignment>(i + m_vert_offset, j + m_horiz_offset);
+  }
+
+  template <typename PacketT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacketPartial(Index i, Index j, Index, Index = 0) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper.template loadPacket<PacketT, Alignment>(i, j);
+    }
+    return m_base_mapper.template loadPacket<PacketT, Alignment>(i + m_vert_offset, j + m_horiz_offset);
+  }
+
+  template <typename PacketT, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacket(Index i, Index j) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper.template load<PacketT, AlignmentType>(i, j);
+    }
+    return m_base_mapper.template loadPacket<PacketT, AlignmentType>(i + m_vert_offset, j + m_horiz_offset);
+  }
+
+  template <typename PacketT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const PacketT& p) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      m_base_mapper.storePacket(i, 0, p);
+    } else {
+      m_base_mapper.storePacket(i + m_vert_offset, m_horiz_offset, p);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return LinearMapper(m_base_mapper, i, j);
+    }
+    return LinearMapper(m_base_mapper, i + m_vert_offset, j + m_horiz_offset);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubMapper getSubMapper(Index i, Index j) const {
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return SubMapper(m_base_mapper, i, j);
+    }
+    return SubMapper(m_base_mapper, i + m_vert_offset, j + m_horiz_offset);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const Index stride() const { return m_base_mapper.stride(); }
+
+  template <typename PacketT, int AlignmentType>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i) const {
+    static_assert(std::is_same<PacketT, PacketT>::value, "YOU_MADE_A_PROGRAMMING_MISTAKE");
+    constexpr int ActualAlignment = (AlignmentType == Aligned) && (Alignment == Aligned) ? Aligned : Unaligned;
+    EIGEN_IF_CONSTEXPR (UseDirectOffsets) {
+      return m_base_mapper.template loadPacket<PacketT, ActualAlignment>(i, 0);
+    }
+    return m_base_mapper.template loadPacket<PacketT, ActualAlignment>(i + m_vert_offset, m_horiz_offset);
+  }
+
+  template <typename PacketT>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool aligned(Index) const {
+    return false;
+  }
+
+  const ParentMapper& base_mapper() const { return m_base_mapper; }
+  Index vert_offset() const { return m_vert_offset; }
+  Index horiz_offset() const { return m_horiz_offset; }
+
+ private:
+  ParentMapper m_base_mapper;
+  const Index m_vert_offset;
+  const Index m_horiz_offset;
+};
+
+template <typename Scalar_, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
+          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
+          template <class> class MakePointer_ = MakePointer>
+class TensorContractionInputMapper
+    : public BaseTensorContractionMapper<Scalar_, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                         inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_> {
+ public:
+  using Scalar = Scalar_;
+  using Base = BaseTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                           inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
+  using SubMapper = TensorContractionSubMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
+                                               inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
+  using VectorMapper = SubMapper;
+  using LinearMapper = SubMapper;
+
+  EIGEN_DEVICE_FUNC TensorContractionInputMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
+                                                 const nocontract_t& ij_strides, const contract_t& contract_strides,
+                                                 const contract_t& k_strides)
+      : Base(tensor, nocontract_strides, ij_strides, contract_strides, k_strides) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE SubMapper getSubMapper(Index i, Index j) const {
+    return SubMapper(*this, i, j);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
+    return LinearMapper(*this, i, j);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE VectorMapper getVectorMapper(Index i, Index j) const {
+    return VectorMapper(*this, i, j);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_>& get_tensor() const {
+    return Base::m_tensor;
+  }
+};
+
+template <typename T>
+struct TensorContractionInputMapperTrait;
+
+template <typename Scalar_, typename Index_, int side_, typename Tensor_, typename nocontract_t_, typename contract_t_,
+          int packet_size_, bool inner_dim_contiguous_, bool inner_dim_reordered_, int Alignment_,
+          template <class> class MakePointer_>
+struct TensorContractionInputMapperTrait<
+    TensorContractionInputMapper<Scalar_, Index_, side_, Tensor_, nocontract_t_, contract_t_, packet_size_,
+                                 inner_dim_contiguous_, inner_dim_reordered_, Alignment_, MakePointer_> > {
+  using XprType = Tensor_;
+  static constexpr bool inner_dim_contiguous = inner_dim_contiguous_;
+  static constexpr bool inner_dim_reordered = inner_dim_reordered_;
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_MAPPER_H
diff --git a/contrib/Eigen/src/Tensor/TensorContractionSycl.h b/contrib/Eigen/src/Tensor/TensorContractionSycl.h
new file mode 100644
index 0000000..c81e95d
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContractionSycl.h
@@ -0,0 +1,1649 @@
+// This file is part of Eigen, a lightweight C++ template library for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License v. 2.0. If a copy of the MPL was not
+// distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+/*****************************************************************
+ * TensorContractionSycl.h
+ *
+ * \brief:
+ *  TensorContractionSycl.h, provides various tensor contraction kernel for SYCL backend
+ *
+ *****************************************************************/
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_SYCL_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_SYCL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace TensorSycl {
+namespace internal {
+
+#ifndef EIGEN_SYCL_DISABLE_GEMV
+/*!
+ * \brief TVPanelSize, a template class used for setting the panel size required for launching General TensorVector
+ * contraction kernel on various hardware devices.
+ *
+ * \tparam Scalar: determines the element type of the tensor/vector
+ *
+ * \tparam StorageIndex  determines the Index type.
+ *
+ * \tparam NCWindow: determines the number of non-contracting element to be process by each work-group
+ *
+ * \tparam CFactor: determines the number of contracting element to be process by each thread
+ *
+ * \tparam NCFactor: determines the number of non-contracting element to be process by each thread
+ */
+template <typename Scalar, typename StorageIndex, StorageIndex NCWindow, StorageIndex CFactor, StorageIndex NCFactor>
+struct TVPanelSize {
+  // LocalThreadSizeC: determines total number of thread per workgroup for the contracting dimension
+  static constexpr StorageIndex LocalThreadSizeC = EIGEN_SYCL_LOCAL_THREAD_DIM0;
+  // LocalThreadSizeNC: determines total number of thread per workgroup for the non-contracting dimension
+  static constxpr StorageIndex LocalThreadSizeNC = EIGEN_SYCL_LOCAL_THREAD_DIM1;
+  // TileSizeDimNC: determines the tile size for the non-contracting dimension
+  static constexpr StorageIndex TileSizeDimNC = NCWindow / NCFactor;
+  // TileSizeDimC: determines the tile size for the contracting dimension
+  static constexpr StorageIndex TileSizeDimC = CFactor * LocalThreadSizeNC * LocalThreadSizeC;
+  // WorkLoadPerThreadNC : determines workload per thread for loading the non-contracting dimension
+  static constexpr StorageIndex WorkLoadPerThreadNC = TileSizeDimNC / LocalThreadSizeNC;
+  // WorkLoadPerThreadC: determines workload per thread for loading the non-contracting dimension
+  static constexpr StorageIndex WorkLoadPerThreadC = TileSizeDimC / LocalThreadSizeC;
+  // BC : determines if supporting bank conflict is required
+  static constexpr bool BC = false;
+};
+#endif
+
+/*!
+ * \brief TTPanelSize, a template class used for setting the panel size required for launching General Tensor Tensor
+ contraction kernel on various hardware devices.
+ *
+ * \tparam Scalar: determines the element type of the tensor
+ *
+ * \tparam StorageIndex: determines the Index type.
+ *
+ * \tparam REG_SIZE_M: determines workload per thread for loading the M dimension This can be varied based on the
+ available register on a chosen device(can be controlled by EIGEN_SYCL_REG_M macro).
+ *
+ * \tparam REG_SIZE_N: determines workload per thread for loading the N dimension This can be varied based on the
+ available register on a chosen device(can be controlled by EIGEN_SYCL_REG_N macro).
+ *
+ * \tparam TSDK: determines Tile size for dimension K. The packet size is assumed to be considered
+ */
+
+template <typename Scalar, typename StorageIndex, StorageIndex REG_SIZE_M, StorageIndex REG_SIZE_N, StorageIndex TSDK>
+struct TTPanelSize {
+  // TileSizeDimK: determines Tile size for dimension K. The packet size is assumed to be considered
+  static constexpr StorageIndex TileSizeDimK = TSDK;
+  // WorkLoadPerThreadM : determines workload per thread for loading the M dimension This can be varied based on the
+  // available register on a chosen device(can be controlled by EIGEN_SYCL_REG_M macro
+#ifndef EIGEN_SYCL_REG_M
+  static constexpr StorageIndex WorkLoadPerThreadM = REG_SIZE_M;
+#else
+  static constexpr StorageIndex WorkLoadPerThreadM = EIGEN_SYCL_REG_M;
+#endif
+// WorkLoadPerThreadN : determines workload per thread for loading the N dimension This can be varied based on the
+// available register on a chosen device(can be controlled by EIGEN_SYCL_REG_N macro
+#ifndef EIGEN_SYCL_REG_N
+  static constexpr StorageIndex WorkLoadPerThreadN = REG_SIZE_N;
+#else
+  static constexpr StorageIndex WorkLoadPerThreadN = EIGEN_SYCL_REG_N;
+#endif
+  // LocalThreadSizeM: determines total number of thread per workgroup for the m dimension
+  static constexpr StorageIndex LocalThreadSizeM = EIGEN_SYCL_LOCAL_THREAD_DIM0;
+  // LocalThreadSizeN: determines total number of thread per workgroup for the n dimension
+  static constexpr StorageIndex LocalThreadSizeN = EIGEN_SYCL_LOCAL_THREAD_DIM1;
+  // TileSizeDimM: determines the tile size for the m dimension
+  static constexpr StorageIndex TileSizeDimM = LocalThreadSizeM * WorkLoadPerThreadM;
+  // TileSizeDimN: determines the tile size for the n dimension
+  static constexpr StorageIndex TileSizeDimN = LocalThreadSizeN * WorkLoadPerThreadN;
+  // LoadPerThreadLhs: determines workload per thread for loading Lhs Tensor. This must be divisible by packetsize
+  static constexpr StorageIndex LoadPerThreadLhs =
+      ((TileSizeDimK * WorkLoadPerThreadM * WorkLoadPerThreadN) / (TileSizeDimN));
+  // LoadPerThreadRhs: determines workload per thread for loading Rhs Tensor. This must be divisible by packetsize
+  static constexpr StorageIndex LoadPerThreadRhs =
+      ((TileSizeDimK * WorkLoadPerThreadM * WorkLoadPerThreadN) / (TileSizeDimM));
+  // BC : determines if supporting bank conflict is required
+  static constexpr bool BC = true;
+  // DoubleBuffer: determines if double buffering technique should be used (This can be disabled by
+  // EIGEN_SYCL_DISABLE_DOUBLE_BUFFER macro when the device does not have sufficient local memory)
+  static constexpr bool DoubleBuffer =
+#ifdef EIGEN_SYCL_DISABLE_DOUBLE_BUFFER
+      false;
+#else
+      true;
+#endif
+};
+
+/* !
+ * \brief contraction_type: an enum class representing the Tensor Contraction implementation algorithm. This is used to
+ * specialize the contraction algorithm based on device support for dedicated local memory.
+ */
+enum class contraction_type { local, no_local };
+/* !
+ * \brief data_source an enum class determining the location of the data in a memory hierarchy (global, local, private).
+ */
+enum class data_source { global_mem, local_mem, private_mem };
+
+/*!
+ * \brief read, a template function used for loading the data from global
+ memory. This function is used to guarantee coalesced and vectorized load whenever possible
+ *
+ * \tparam PacketLoad: determines if the each element of this tensor block should be loaded in a packet mode
+ *
+ * \param is_coalesced_layout: determines whether or not the Tensor data in a memory can be access coalesced and
+ vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the
+ contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case
+ when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.
+ *
+ * \tparam PacketType:  determines the type of packet
+ *
+ * \tparam TensorMapper: determines the input tensor mapper type
+ *
+ * \tparam StorageIndex: determines the Index type
+
+ * \param tensorMapper: is the input tensor
+ *
+ * \param NCIndex: is the non-contracting dim index
+ *
+ * \param CIndex is the contracting dim index
+ *
+ * \param ld: is the leading dimension of the flattened tensor
+ */
+template <bool PacketLoad, bool is_coalesced_layout, bool, typename PacketType, typename TensorMapper,
+          typename StorageIndex>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<PacketLoad, PacketType> read(
+    const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &ld) {
+  const StorageIndex row = (is_coalesced_layout) ? NCIndex : CIndex;
+  const StorageIndex col = (is_coalesced_layout) ? CIndex : NCIndex;
+  return tensorMapper.get_tensor().template packet<Unaligned>(row + (col * ld));
+}
+
+/*!
+ * \brief read, special overload of read function, when the read access is not vectorized
+ *
+ * \tparam PacketLoad: determines if the each element of this tensor block should be loaded in a packet mode
+ *
+ * \param is_coalesced_layout: determines whether or not the Tensor data in a memory can be access coalesced and
+  vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the
+  contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case
+  when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.
+ *
+ * \tparam PacketType: determines the type of packet
+ *
+ * \tparam TensorMapper: determines the input tensor mapper type
+ *
+ * \tparam StorageIndex: determines the Index type
+
+ * \param tensorMapper: is the input tensor
+ *
+ * \param NCIndex: is the non-contracting dim index
+ *
+ * \param CIndex: is the contracting dim index
+ */
+template <bool PacketLoad, bool, bool IsRhs, typename PacketType, typename TensorMapper, typename StorageIndex>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!PacketLoad, PacketType> read(
+    const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &) {
+  const StorageIndex row = (IsRhs) ? CIndex : NCIndex;
+  const StorageIndex col = (IsRhs) ? NCIndex : CIndex;
+  return tensorMapper(row, col);
+}
+
+/*!
+ * \brief write, a template function used for storing the data to local memory. This function is used to guarantee
+ * coalesced and vectorized store whenever possible.
+ *
+ * \tparam StorageIndex: determines the Index type
+ *
+ * \param ld is the leading dimension of the local memory. ld is a compile time value for the local memory
+ *
+ * \tparam data_source: an enum value representing if the location of the data in a memory hierarchy.
+ *
+ * \tparam PacketType:  determines the type of packet
+ *
+ * \tparam DataScalar: determines the output data type
+ *
+ * \param packet_data: the data to be written in the local memory
+ *
+ * \param ptr: a pointer to the local memory
+ *
+ * \param CIndex is the contracting dim index
+ */
+
+template <typename StorageIndex, StorageIndex ld, data_source dt, typename PacketType, typename DataScalar>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<dt != data_source::global_mem, void> write(
+    PacketType &packet_data, DataScalar ptr) {
+  constexpr int PacketSize = Eigen::internal::unpacket_traits<PacketType>::size;
+  EIGEN_UNROLL_LOOP
+  for (int i = 0; i < PacketSize; i++) {
+    *ptr = PacketWrapper<PacketType, PacketSize>::scalarize(i, packet_data);
+    ptr += ld;
+  }
+}
+
+/*!
+ * \brief Overloading the write function for storing the data to global memory, when vectorization enabled This function
+ * is used to guarantee coalesced and vectorized store whenever possible.
+ *
+ * \tparam data_source: an enum value representing if the location of the data in a memory hierarchy.
+ *
+ * \tparam PacketType:  determines the type of packet
+ *
+ * \tparam DataScalar: determines the output data type
+ *
+ * \param packet_data: the data to be written in the local memory
+ *
+ * \param ptr: a pointer to the local memory
+ */
+
+template <data_source dt, typename PacketType, typename DataScalar>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    std::enable_if_t<Eigen::internal::unpacket_traits<PacketType>::size != 1 && dt == data_source::global_mem, void>
+    write(PacketType &packet_data, DataScalar *ptr) {
+  ::Eigen::internal::pstoreu<DataScalar, PacketType>(ptr, packet_data);
+}
+
+/*!
+ * \brief Overloading the write function for storing the data to global memory, when vectorization is disabled.
+ *
+ * \tparam data_source: an enum value representing if the location of the data in a memory hierarchy.
+ *
+ * \tparam PacketType:  determines the type of packet
+ *
+ * \tparam DataScalar: determines the output data type
+ *
+ * \param packet_data: the data to be written in the local memory
+ *
+ * \param ptr: a pointer to the local memory
+ */
+template <data_source dt, typename PacketType, typename DataScalar>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+    std::enable_if_t<Eigen::internal::unpacket_traits<PacketType>::size == 1 && dt == data_source::global_mem, void>
+    write(PacketType &packet_data, DataScalar *ptr) {
+  *ptr = packet_data;
+}
+
+/*!
+ * \brief check_boundary: is used to check the edge condition for non-internal blocks.
+ *
+ * \tparam is_internal: determines if the block is internal
+ */
+template <bool is_internal>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_boundary(bool) {
+  return true;
+}
+
+/*!
+ * \brief check_boundary: specialization of the check_boundary for non-internal blocks.
+ *
+ * \param cond: true when the data is in range. Otherwise false
+ */
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_boundary<false>(bool cond) {
+  return cond;
+}
+
+/*!
+ * \brief BlockProperties is a template class that provides different characteristic of a block of each Tensor processed
+ * by each workgroup.
+ *
+ * \tparam is_transposed: iff true, determines whether or not the block of the Tensor is transposed
+ *
+ * \tparam packet_load_: determines if the each element of this tensor block should be loaded in a packet mode
+ *
+ * \tparam PacketType:  determines the type of packet
+ *
+ * \tparam OutType: determines the type of each element for this block of tensor. If packet load is true, it will be
+ * packetType; Otherwise it will be scalar Type
+ *
+ * \param elements_per_access determines the size of each element based on OutType
+ *
+ * \param is_coalesced_layout  determines whether or not the Tensor data in a memory can be access coalesced and
+ * vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the
+ * contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case
+ * when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.
+ *
+ * \param nc_stride determines the stride of non-contracting dimension to access the next adjustment element within the
+ * Tensor Block for each workgroup
+ *
+ * \param c_stride  determines the stride of contracting dimension to access the next adjustment element within the
+ * Tensor Block for each workgroup
+ */
+template <bool is_transposed, bool is_rhs_, bool packet_load_, typename PacketType>
+struct BlockProperties {
+  static constexpr bool packet_load = packet_load_;
+  typedef typename Eigen::internal::unpacket_traits<PacketType>::type OutScalar;
+  static constexpr bool is_rhs = is_rhs_;
+  typedef std::conditional_t<packet_load, PacketType, OutScalar> OutType;
+  static constexpr int elements_per_access = Eigen::internal::unpacket_traits<OutType>::size;
+  static constexpr bool is_coalesced_layout = !(is_transposed ^ is_rhs);
+  static constexpr int nc_stride = (is_coalesced_layout ? elements_per_access : 1);
+  static constexpr int c_stride = (is_coalesced_layout ? 1 : elements_per_access);
+};
+
+/*!
+ * \brief ThreadProperties is a template class that provides each thread's properties within a workgroup.  Please see
+ * the sycl-1.2.1 specification (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for the workgroup,
+ * work-items
+ *
+ * \tparam StorageIndex: determines the StorageIndex Type
+ *
+ * \param linearLocalThreadId: determines the linearized location of a thread within a work-group
+ *
+ * \param kGroupId: determines the logical group id in a k dimension of the flattened tensor. It will be > 1 when
+ * tall/skinny algorithm is used
+ *
+ * \param mGroupOffset: determines the logical start position of all thread within a workgroup for the m dimension of
+ * the flattened tensor.
+ *
+ * \param kGroupOffset determines the logical start position of all thread within a workgroup for the k dimension of the
+ * flattened tensor. It will be > 1 when tall/skinny algorithm is used.
+ *
+ * \param mLocalOffset: determines the logical start position of each thread within a workgroup for the m dimension of a
+ * flattened tensor. The position determines the distance of each thread within the workgroup from each other
+ * independent from their global position.
+ *
+ * \param nLocalOffset: determines the logical start position of each thread within a workgroup for the n dimension of a
+ * flattened tensor. The position determines the distance of each thread within the workgroup from each other
+ * independent from their global position.
+ *
+ * \param mGlobalOffset: determines the logical start position of each thread a thread for the m dimension on a
+ * flattened tensor
+ *
+ * \param nGlobalOffset: determines the logical start position of each thread a thread for the n dimension on a
+ * flattened tensor
+ *
+ * \param kSize : determine the number of the k elements of the flattened Tensor to be processed by each thread for the
+ * given tensor block. This is !=K dimension of Flattened Tensor when Tall/Skinny matrix is used.
+ *
+ * \param is_internal : this will determined if the thread within the work-group computes an internal block of tensor or
+ * the edge blocks. When it is internal, there is no need to check the boundaries and all the if statements can be
+ * resolved by compiler.
+ */
+template <typename StorageIndex>
+struct ThreadProperties {
+  const StorageIndex linearLocalThreadId;
+  const StorageIndex kGroupId;
+  const StorageIndex mGroupOffset;
+  const StorageIndex nGroupOffset;
+  const StorageIndex kGroupOffset;
+  const StorageIndex mLocalOffset;
+  const StorageIndex nLocalOffset;
+  const StorageIndex mGlobalOffset;
+  const StorageIndex nGlobalOffset;
+  StorageIndex kSize;
+  const bool is_internal;
+  // this is used to adjust the last block
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ThreadProperties(
+      const StorageIndex linearLocalThreadId_, const StorageIndex kGroupId_, const StorageIndex mGroupOffset_,
+      const StorageIndex nGroupOffset_, const StorageIndex kGroupOffset_, const StorageIndex mLocalOffset_,
+      const StorageIndex nLocalOffset_, const StorageIndex mGlobalOffset_, const StorageIndex nGlobalOffset_,
+      StorageIndex kSize_, const bool is_internal_)
+      : linearLocalThreadId(linearLocalThreadId_),
+        kGroupId(kGroupId_),
+        mGroupOffset(mGroupOffset_),
+        nGroupOffset(nGroupOffset_),
+        kGroupOffset(kGroupOffset_),
+        mLocalOffset(mLocalOffset_),
+        nLocalOffset(nLocalOffset_),
+        mGlobalOffset(mGlobalOffset_),
+        nGlobalOffset(nGlobalOffset_),
+        kSize(kSize_),
+        is_internal(is_internal_) {}
+};
+
+/*!
+ * \brief TensorContractionKernel is a template class that provides Tensor -Tensor contraction operation.
+ *
+ * \tparam OutScalar: determines the output scalar type
+ *
+ * \tparam LhsScalar: determines the left-hand-side scalar type
+ *
+ * \tparam RhsScalar: determines the right-hand-side scalar type
+ *
+ * \tparam OutAccessor: determines the sycl accessor type for out put (please see the sycl-1.2.1 specification
+ (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for accessor definition)
+ *
+ * \tparam LhsMapper determines the tensor contraction mapper type for left-hand-side matrix
+ *
+ * \tparam RhsMapper determines the tensor contraction mapper type for right-hand-side matrix
+ *
+ * \tparam StorageIndex: determines the StorageIndex Type
+ *
+ * \tparam Properties: determines the Contraction Panel properties
+ *
+ * \tparam TripleDim: determines the M, K, N dimensions for the flatten tensors in order to treat them as a matrix
+ *
+ * \tparam Vectorizable: determines whether or not the vectorization is enabled for the Eigen expression.
+ *
+ * \tparam input_mapper_properties : determine if the input tensors are matrix. If they are matrix, special memory
+ access is used to guarantee that always the memory access are coalesced.
+ *
+ * \tparam IsFinal : determine if this is the final kernel. If so, the result will be written in a final output.
+ Otherwise, the result of contraction will be written in a temporary buffer. This is the case when Tall/Skinny
+ contraction is used. So in this case, a final reduction step is required to compute final output.
+
+ * \tparam contraction_tp: it is an enum value representing whether the local memory/no local memory implementation of
+ the algorithm to be used
+ *
+ * \param scratch: local memory containing tiles of LHS and RHS tensors for each work-group
+ *
+ * \param lhs: determines the left-hand-side flattened tensor (tensor mapper)
+ *
+ * \param rhs: determines the right-hand-side flattened tensor (tensor mapper)
+ *
+ * \param out_res: determines the output tensor containing the contraction result
+ *
+ * \param groupSizeM: a logical number determining the number of work-group for m dimension
+ *
+ * \param groupSizeN: a logical number determining the number of work-group for n dimension
+ *
+ * \param numTiles: determines total number of tiles on the k dimension
+ *
+ * \param TripleDim: determines the M, K, N dimensions for the flatten tensors in order to treat them as a matrix
+ */
+template <typename OutScalar, typename LhsScalar, typename RhsScalar, typename OutAccessor, typename LhsMapper,
+          typename RhsMapper, typename StorageIndex, typename Properties, typename TripleDim, bool Vectorizable,
+          typename input_mapper_properties, bool IsFinal, contraction_type contraction_tp>
+class TensorContractionKernel {
+ public:
+  typedef typename Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketReturnType
+      PacketReturnType;
+  static constexpr int PacketSize =
+      Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketSize;
+  static constexpr bool is_lhs_transposed =
+      !::Eigen::internal::TensorContractionInputMapperTrait<LhsMapper>::inner_dim_contiguous;
+  static constexpr bool is_rhs_transposed =
+      !::Eigen::internal::TensorContractionInputMapperTrait<RhsMapper>::inner_dim_contiguous;
+
+  typedef BlockProperties<is_lhs_transposed, false, input_mapper_properties::is_lhs_matrix && Vectorizable,
+                          PacketReturnType>
+      LHSBlockProperties;
+
+  typedef BlockProperties<is_rhs_transposed, true, input_mapper_properties::is_rhs_matrix && Vectorizable,
+                          PacketReturnType>
+      RHSBlockProperties;
+
+  static constexpr StorageIndex NStride =
+      contraction_tp == contraction_type::local ? Properties::WorkLoadPerThreadN : RHSBlockProperties::nc_stride;
+
+  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> Scratch;
+  typedef cl::sycl::multi_ptr<OutScalar, cl::sycl::access::address_space::local_space> local_ptr;
+  typedef OutScalar * /*cl::sycl::multi_ptr<OutScalar, cl::sycl::access::address_space::private_space>*/ private_ptr;
+  typedef std::conditional_t<contraction_tp == contraction_type::local, local_ptr, private_ptr> tile_ptr;
+  static constexpr StorageIndex LSDL = contraction_tp == contraction_type::local
+                                           ? Properties::TileSizeDimM + Properties::BC
+                                           : Properties::WorkLoadPerThreadM;
+  static constexpr StorageIndex LSDR = contraction_tp == contraction_type::local
+                                           ? Properties::TileSizeDimN + Properties::BC
+                                           : Properties::WorkLoadPerThreadN;
+  static constexpr StorageIndex LocalOffset = Properties::LocalThreadSizeM * Properties::LocalThreadSizeN;
+
+  /**
+   * \brief MemHolder this is a place holder struct for creating memory hierarchy in SYCL. Inside SYCL kernel it is not
+   * allowed to have dynamic memory allocation. While the local memory is created outside of the kernel and passed to
+   * the kernel as an accessor, the private memory can only allowed to be allocated statically. Since we are abstracting
+   * the TiledMemory for both local and private memory, the MemHolder structs is used as a helper to abstract out
+   * different type of memory needed when local/no_local memory computation is called.
+   *
+   * \tparam contraction_type: it is an enum value representing whether the local memory/no local memory implementation
+   of the algorithm to be used
+   * \tparam the private memory size
+   * \param ptr the tile memory pointer type
+   */
+  template <contraction_type, StorageIndex>
+  struct MemHolder {
+    tile_ptr ptr;
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE MemHolder(local_ptr block_start_ptr) : ptr(block_start_ptr) {}
+  };
+  /**
+   * \brief specialization of memHolder class when no local memory kernel is used.
+   */
+  template <StorageIndex MemSize>
+  struct MemHolder<contraction_type::no_local, MemSize> {
+    OutScalar ptr[MemSize] = {OutScalar{0}};
+  };
+  /**
+   * \brief TiledMemory: contains required memory pointer for loading  each tile of the TensorContraction panel from
+   * global memory to local/private memory when local/no_local algorithm used.
+   *
+   * \param lhs_scratch_extract : determines the LHS tile memory. It is either private or local memory based on the
+   * selected contraction_type.
+   *
+   * \param rhs_scratch_extract : determines the RHS tile memory. It is either private or local memory based on the
+   * selected contraction_type.
+   *
+   * \param lhs_extract_index: determines the position of each thread on a local memory for lhs input. When private
+   * memory is used this is set to zero as this is not applicable in case of private memory.
+   *
+   * \param rhs_extract_index: determines the position of each thread on a local memory for rhs input. When private
+   * memory is used this is set to zero as this is not applicable in case of private memory.
+   *
+   * \param lhs_scratch_compute : determines the  location to load for computation for lhs_local memory. This is the
+   * same as lhs_scratch_extract for private memory.
+   *
+   * \param rhs_scratch_compute : determines the  location to load for computation for rhs_local memory. This is the
+   * same as rhs_scratch_extract for private memory.
+   */
+  struct TiledMemory {
+    MemHolder<contraction_tp, Properties::WorkLoadPerThreadM * Properties::TileSizeDimK> lhs_scratch_extract;
+    MemHolder<contraction_tp, Properties::WorkLoadPerThreadN * Properties::TileSizeDimK> rhs_scratch_extract;
+    tile_ptr lhs_scratch_ptr_compute;
+    tile_ptr rhs_scratch_ptr_compute;
+    const std::pair<StorageIndex, StorageIndex> lhs_extract_index;
+    const std::pair<StorageIndex, StorageIndex> rhs_extract_index;
+    template <contraction_type tp = contraction_tp, std::enable_if_t<tp == contraction_type::no_local, int> = 0>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TiledMemory(const ThreadProperties<StorageIndex> &, local_ptr)
+        : lhs_scratch_extract{},
+          rhs_scratch_extract{},
+          lhs_scratch_ptr_compute(lhs_scratch_extract.ptr),
+          rhs_scratch_ptr_compute(rhs_scratch_extract.ptr),
+          lhs_extract_index(std::pair<StorageIndex, StorageIndex>(StorageIndex{0}, StorageIndex{0})),
+          rhs_extract_index(std::pair<StorageIndex, StorageIndex>(StorageIndex{0}, StorageIndex{0})) {}
+
+    template <contraction_type tp = contraction_tp, std::enable_if_t<tp == contraction_type::local, int> = 0>
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TiledMemory(const ThreadProperties<StorageIndex> &thread_properties,
+                                                      local_ptr block_start_ptr)
+        : lhs_scratch_extract{block_start_ptr},
+          rhs_scratch_extract{lhs_scratch_extract.ptr +
+                              ((Properties::DoubleBuffer + 1) * LSDL * Properties::TileSizeDimK)},
+          lhs_scratch_ptr_compute(lhs_scratch_extract.ptr + thread_properties.mLocalOffset),
+          rhs_scratch_ptr_compute(rhs_scratch_extract.ptr + thread_properties.nLocalOffset),
+          lhs_extract_index(
+              local_id_extract<LHSBlockProperties, Properties::TileSizeDimM>(thread_properties.linearLocalThreadId)),
+          rhs_extract_index(
+              local_id_extract<RHSBlockProperties, Properties::TileSizeDimN>(thread_properties.linearLocalThreadId)) {}
+  };
+
+  Scratch scratch;
+  const LhsMapper lhs;
+  const RhsMapper rhs;
+  OutAccessor out_res;
+  const StorageIndex groupSizeM;
+  const StorageIndex groupSizeN;
+  const StorageIndex numTiles;
+  const TripleDim triple_dim;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionKernel(Scratch scratch_, const LhsMapper lhs_,
+                                                                const RhsMapper rhs_, OutAccessor out_res_,
+                                                                const StorageIndex groupSizeM_,
+                                                                const StorageIndex groupSizeN_,
+                                                                const StorageIndex numTiles_,
+                                                                const TripleDim triple_dim_)
+      : scratch(scratch_),
+        lhs(lhs_),
+        rhs(rhs_),
+        out_res(out_res_),
+        groupSizeM(groupSizeM_),
+        groupSizeN(groupSizeN_),
+        numTiles(numTiles_),
+        triple_dim(triple_dim_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionKernel(Scratch scratch_, const LhsMapper lhs_,
+                                                                const RhsMapper rhs_, OutAccessor out_res_,
+                                                                const StorageIndex groupSizeM_,
+                                                                const StorageIndex numTiles_,
+                                                                const TripleDim triple_dim_)
+      : TensorContractionKernel(scratch_, lhs_, rhs_, out_res_, groupSizeM_, 1, numTiles_, triple_dim_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
+    const StorageIndex linearLocalThreadId = itemID.get_local_id(0);
+    const StorageIndex nLocalThreadId = linearLocalThreadId / Properties::LocalThreadSizeM;
+    const StorageIndex mLocalThreadId = linearLocalThreadId % Properties::LocalThreadSizeM;
+    const StorageIndex mGroupId = itemID.get_group(0) % groupSizeM;
+    const StorageIndex tmp = itemID.get_group(0) / groupSizeM;
+    const StorageIndex nGroupId = IsFinal ? tmp : tmp % groupSizeN;
+    const StorageIndex kGroupId = IsFinal ? 0 : tmp / groupSizeN;
+    const StorageIndex mGroupOffset = mGroupId * Properties::TileSizeDimM;
+    const StorageIndex nGroupOffset = nGroupId * Properties::TileSizeDimN;
+    const StorageIndex mLocalOffset = PacketSize * mLocalThreadId;
+    const StorageIndex nLocalOffset = NStride * nLocalThreadId;
+    const StorageIndex mGlobalOffset = mGroupOffset + mLocalOffset;
+    const StorageIndex nGlobalOffset = nGroupOffset + nLocalOffset;
+
+    const StorageIndex kSizePerWG = IsFinal ? triple_dim.K : numTiles * Properties::TileSizeDimK;
+    StorageIndex kGroupOffset = kGroupId * kSizePerWG;
+    const bool is_internal = triple_dim.M - mGroupOffset >= Properties::TileSizeDimM &&
+                             triple_dim.N - nGroupOffset >= Properties::TileSizeDimN &&
+                             triple_dim.K - kGroupOffset >= kSizePerWG;
+    // this is used to adjust the last block
+    StorageIndex kSize = IsFinal ? triple_dim.K : std::min(kSizePerWG, triple_dim.K - kGroupOffset);
+    // This is used to find out the last K offset so that kGroupOffset -kSize can compute the coffset for loading to
+    // tile
+    kGroupOffset += kSize;
+
+    auto thread_properties =
+        ThreadProperties<StorageIndex>(linearLocalThreadId, kGroupId, mGroupOffset, nGroupOffset, kGroupOffset,
+                                       mLocalOffset, nLocalOffset, mGlobalOffset, nGlobalOffset, kSize, is_internal);
+
+    auto out_ptr = out_res + (IsFinal ? 0 : thread_properties.kGroupId * triple_dim.M * triple_dim.N);
+
+    (thread_properties.is_internal) ? compute_panel<true>(itemID, thread_properties, out_ptr)
+                                    : compute_panel<false>(itemID, thread_properties, out_ptr);
+  }
+  // The compute block computes the contraction operation private block for each thread and store the result in the
+  // privateRes memory of Each computation the compute block function is independent of local and no local concepts as
+  // it only compute the block on each thread's private memory space
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_block_per_tile(OutScalar *lhs_block_ptr, OutScalar *rhs_block_ptr,
+                                                                    PacketReturnType *privateRes) const {
+    StorageIndex idx = 0;
+    constexpr StorageIndex lhs_stride =
+        contraction_tp == contraction_type::local ? (PacketSize * Properties::LocalThreadSizeM) : 1;
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex wLPTN = 0; wLPTN < Properties::WorkLoadPerThreadN; wLPTN++) {
+      auto rhsPacket = PacketReturnType{*(rhs_block_ptr + wLPTN)};
+      StorageIndex lhs_index = 0;
+      EIGEN_UNROLL_LOOP
+      for (StorageIndex wLPTM = 0; wLPTM < Properties::WorkLoadPerThreadM / PacketSize; wLPTM++) {
+        PacketReturnType lhsPack{};
+        Eigen::TensorSycl::internal::PacketWrapper<PacketReturnType, PacketSize>::set_packet(lhsPack,
+                                                                                             lhs_block_ptr + lhs_index);
+        privateRes[idx] = ::Eigen::internal::pmadd(lhsPack, rhsPacket, privateRes[idx]);
+
+        lhs_index += lhs_stride;
+        idx++;
+      }
+    }
+  }
+  // The store function write the computed contraction operation in the private memory of each thread to the global
+  // memory. The store function is independent of local and no local concepts so that it can be abstracted out in the
+  // base class.
+  template <bool is_internal_block, StorageIndex PrivateNStride, typename OutPtr>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void store(OutPtr *out_ptr, PacketReturnType *privateRes,
+                                                   StorageIndex mGlobalOffset, StorageIndex nGlobalOffset) const {
+    auto chk_bound = [&](const StorageIndex &mIndex, const StorageIndex &nIndex) EIGEN_DEVICE_FUNC {
+      return (mIndex + PacketSize - 1 < triple_dim.M && nGlobalOffset + nIndex < triple_dim.N);
+    };
+    // when local memory is not used M and N are both accessed in a coalesced way. However, when local memory is
+    // available the k*N is transposed in the local to N*K therefore, each blocks operates on blockId*
+    // WorkLoadPerThreadN slice of N
+    constexpr StorageIndex GlobalNStride = contraction_tp == contraction_type::local ? 1 : Properties::LocalThreadSizeN;
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex wLPTN = 0; wLPTN < Properties::WorkLoadPerThreadN / PrivateNStride; wLPTN++) {
+      // output leading dimension
+      StorageIndex outputLD = 0;
+      // When local memory is used the PrivateNstride is always 1 because the coalesced access on N is loaded into Local
+      // memory and extracting from local to global is the same as no transposed version. However, when local memory is
+      // not used and RHS is transposed we packetize the load for RHS.
+      EIGEN_UNROLL_LOOP
+      for (StorageIndex nId = 0; nId < PrivateNStride; nId++) {
+        StorageIndex globalRow = mGlobalOffset;
+        EIGEN_UNROLL_LOOP
+        for (StorageIndex wLPTM = 0; wLPTM < Properties::WorkLoadPerThreadM / PacketSize; wLPTM++) {
+          PacketReturnType privetOut = privateRes[wLPTM];
+          if (check_boundary<is_internal_block>(chk_bound(globalRow, nId))) {
+            // Store the final results in C. The C matrix has always M as a first StorageIndex and N as a second
+            // StorageIndex Therefore it is always coalesced layout
+            write<data_source::global_mem>(privetOut, out_ptr + outputLD + globalRow);
+          } else {
+            EIGEN_UNROLL_LOOP
+            for (StorageIndex mId = 0; mId < PacketSize; mId++) {
+              StorageIndex mOffset = globalRow + mId;
+              if (mOffset < triple_dim.M && (nGlobalOffset + nId < triple_dim.N)) {
+                out_ptr[mOffset + outputLD] =
+                    Eigen::TensorSycl::internal::PacketWrapper<PacketReturnType, PacketSize>::scalarize(mId, privetOut);
+              }
+            }
+          }
+          globalRow += (PacketSize * Properties::LocalThreadSizeM);
+        }
+        outputLD += triple_dim.M;
+        privateRes += Properties::WorkLoadPerThreadM / PacketSize;
+      }
+      out_ptr += (GlobalNStride * outputLD);
+
+      nGlobalOffset += (PrivateNStride * GlobalNStride);
+    }
+  }
+  // when no local memory is used the following extract_block will be enabled
+  template <typename InputBlockProperties, bool is_internal_block, typename Input, typename PrivateReg,
+            contraction_type contract_tp = contraction_tp>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<contract_tp == contraction_type::no_local> extract_block(
+      const Input &inpt, PrivateReg private_ptr, const std::pair<StorageIndex, StorageIndex> &,
+      const StorageIndex &ncOffset, const StorageIndex cOffset) const {
+    constexpr StorageIndex LocalThreadSizeNC =
+        InputBlockProperties::is_rhs ? Properties::LocalThreadSizeN : Properties::LocalThreadSizeM;
+    constexpr StorageIndex WorkLoadPerThreadNC =
+        InputBlockProperties::is_rhs ? Properties::WorkLoadPerThreadN : Properties::WorkLoadPerThreadM;
+    const StorageIndex &NC = InputBlockProperties::is_rhs ? triple_dim.N : triple_dim.M;
+
+    auto chk_bound = [&](const StorageIndex &CIndex, const StorageIndex &NCIndex) EIGEN_DEVICE_FUNC {
+      return ((CIndex + InputBlockProperties::c_stride - 1 < triple_dim.K) &&
+              (NCIndex + InputBlockProperties::nc_stride - 1 < NC));
+    };
+    const StorageIndex ld = InputBlockProperties::is_coalesced_layout ? NC : triple_dim.K;
+    StorageIndex cIndex = cOffset;
+
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex cId = 0; cId < Properties::TileSizeDimK / InputBlockProperties::c_stride; cId++) {
+      StorageIndex ncIndex = ncOffset;
+      EIGEN_UNROLL_LOOP
+      for (StorageIndex ncId = 0; ncId < WorkLoadPerThreadNC / InputBlockProperties::nc_stride; ncId++) {
+        if (check_boundary<is_internal_block>(chk_bound(cIndex, ncIndex))) {
+          auto val =
+              read<InputBlockProperties::packet_load, InputBlockProperties::is_coalesced_layout,
+                   InputBlockProperties::is_rhs, typename InputBlockProperties::OutType>(inpt, ncIndex, cIndex, ld);
+
+          write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : WorkLoadPerThreadNC),
+                data_source::private_mem>(val, private_ptr);
+        } else {
+          EIGEN_UNROLL_LOOP
+          for (StorageIndex i = 0; i < InputBlockProperties::elements_per_access; i++) {
+            const StorageIndex ncInd = ncIndex + (InputBlockProperties::is_coalesced_layout ? i : 0);
+            const StorageIndex cInd = cIndex + (InputBlockProperties::is_coalesced_layout ? 0 : i);
+            OutScalar val =
+                (ncInd < NC && cInd < triple_dim.K)
+                    ? read<false, InputBlockProperties::is_coalesced_layout, InputBlockProperties::is_rhs, OutScalar>(
+                          inpt, ncInd, cInd, ld)
+                    : OutScalar(0);
+            write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : WorkLoadPerThreadNC),
+                  data_source::private_mem>(
+                val, private_ptr + (InputBlockProperties::is_coalesced_layout ? i : 0) +
+                         ((InputBlockProperties::is_coalesced_layout ? 0 : i) * WorkLoadPerThreadNC));
+          }
+        }
+
+        // if it is lhs we have to load it packetised when the packet size is > 1, because the output is coalesced. So
+        // even if M is not accessed in a coalesced mode, we have to load packet_size number of m per thread.
+        ncIndex = (!InputBlockProperties::is_rhs && InputBlockProperties::nc_stride == 1 && PacketSize != 1)
+                      ? ncOffset + (ncId + 1) % PacketSize + ((ncId + 1) / PacketSize) * LocalThreadSizeNC
+                      : (ncIndex + InputBlockProperties::nc_stride * LocalThreadSizeNC);
+        private_ptr += InputBlockProperties::nc_stride;
+      }
+      // the previous for loop ( private_ptr += (ncId * nc_stride)) has already moved ptr with one WorkLoadPerThreadNC
+      private_ptr += (InputBlockProperties::c_stride - 1) * WorkLoadPerThreadNC;
+      cIndex += InputBlockProperties::c_stride;
+    }
+  }
+  template <typename InputBlockProperties, StorageIndex TileSizeDimNC>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::pair<StorageIndex, StorageIndex> local_id_extract(
+      const StorageIndex &linearLocalThreadId) {
+    const StorageIndex localThreadNC =
+        (InputBlockProperties::is_coalesced_layout)
+            ? linearLocalThreadId % (TileSizeDimNC / InputBlockProperties::nc_stride)
+            : linearLocalThreadId / (Properties::TileSizeDimK / InputBlockProperties::c_stride);
+    const StorageIndex localThreadC =
+        (InputBlockProperties::is_coalesced_layout)
+            ? linearLocalThreadId / (TileSizeDimNC / InputBlockProperties::nc_stride)
+            : linearLocalThreadId % (Properties::TileSizeDimK / InputBlockProperties::c_stride);
+    return std::pair<StorageIndex, StorageIndex>(localThreadNC, localThreadC);
+  }
+
+  template <bool db = Properties::DoubleBuffer, contraction_type ctp = contraction_tp>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<db && ctp == contraction_type::local> sync_mem(
+      const cl::sycl::nd_item<1> &, bool &db_offset) noexcept {
+    db_offset = !db_offset;
+  }
+
+  template <bool db = Properties::DoubleBuffer, contraction_type ctp = contraction_tp>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!db && ctp == contraction_type::local> sync_mem(
+      const cl::sycl::nd_item<1> &itemID, bool &) noexcept {
+    itemID.barrier(cl::sycl::access::fence_space::local_space);
+  }
+
+  template <contraction_type ctp = contraction_tp>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<ctp == contraction_type::no_local> sync_mem(
+      const cl::sycl::nd_item<1> &, bool &) noexcept {
+    return;
+  }
+
+  template <bool need_sync, contraction_type ctp = contraction_tp>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<need_sync && ctp == contraction_type::no_local>
+  sync_thread(const cl::sycl::nd_item<1> &
+#ifdef EIGEN_SYCL_ARM_GPU_CACHE_OPTIMISATION
+                  itemID
+#endif
+              ) noexcept {
+#ifdef EIGEN_SYCL_ARM_GPU_CACHE_OPTIMISATION
+    itemID.barrier(cl::sycl::access::fence_spacce::local_space);
+#else
+    return;
+#endif
+  }
+  template <bool need_sync, contraction_type ctp = contraction_tp>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<need_sync && ctp == contraction_type::local>
+  sync_thread(const cl::sycl::nd_item<1> &itemID) {
+    itemID.barrier(cl::sycl::access::fence_space::local_space);
+  }
+  template <bool need_sync>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!need_sync> sync_thread(const cl::sycl::nd_item<1> &) {
+    return;
+  }
+
+  template <bool is_internal_block>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_tile_per_panel(const cl::sycl::nd_item<1> &itemID,
+                                                                    ThreadProperties<StorageIndex> &thread_properties,
+                                                                    TiledMemory &tiled_input_block,
+                                                                    PacketReturnType *privateRes,
+                                                                    bool &db_offset) const {
+    // Tiling the Rhs block from global to local memory
+    extract_block<RHSBlockProperties, is_internal_block>(
+        rhs, tiled_input_block.rhs_scratch_extract.ptr + (db_offset * Properties::TileSizeDimK * LSDR),
+        tiled_input_block.rhs_extract_index,
+        contraction_tp == contraction_type::local ? thread_properties.nGroupOffset : thread_properties.nGlobalOffset,
+        thread_properties.kGroupOffset - thread_properties.kSize);
+
+    sync_thread<contraction_tp == contraction_type::no_local>(itemID);
+
+    // Tiling the Lhs block from global to local memory
+    extract_block<LHSBlockProperties, is_internal_block>(
+        lhs, tiled_input_block.lhs_scratch_extract.ptr + (db_offset * LSDL * Properties::TileSizeDimK),
+        tiled_input_block.lhs_extract_index,
+        contraction_tp == contraction_type::local ? thread_properties.mGroupOffset : thread_properties.mGlobalOffset,
+        thread_properties.kGroupOffset - thread_properties.kSize);
+
+    sync_thread<contraction_tp == contraction_type::local>(itemID);
+    // switch to compute mode
+    StorageIndex lhs_offset = (db_offset * LSDL * Properties::TileSizeDimK);
+    StorageIndex rhs_offset = (db_offset * Properties::TileSizeDimK * LSDR);
+    // Loop over the values of a single tile
+    for (StorageIndex k = 0; k < Properties::TileSizeDimK; k++) {
+      compute_block_per_tile(tiled_input_block.lhs_scratch_ptr_compute + lhs_offset,
+                             tiled_input_block.rhs_scratch_ptr_compute + rhs_offset, privateRes);
+      lhs_offset += LSDL;
+      rhs_offset += LSDR;
+    }
+    // computing the K index for the next tile
+    thread_properties.kSize -= Properties::TileSizeDimK;
+    sync_mem(itemID, db_offset);
+  }
+
+  // when local memory is available the following compute_panel will be enabled
+  template <bool is_internal_block, typename OutPtr>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(const cl::sycl::nd_item<1> &itemID,
+                                                           ThreadProperties<StorageIndex> &thread_properties,
+                                                           OutPtr out_ptr) const {
+    auto tiled_input_block = TiledMemory{thread_properties, scratch.get_pointer()};
+    // Allocate register space
+    PacketReturnType privateRes[Properties::WorkLoadPerThreadM * Properties::WorkLoadPerThreadN / PacketSize] = {
+        PacketReturnType{0}};
+    bool db_offset = 0;
+
+    while (thread_properties.kSize >= Properties::TileSizeDimK) {
+      compute_tile_per_panel<is_internal_block>(itemID, thread_properties, tiled_input_block, privateRes, db_offset);
+    }
+    if (thread_properties.kSize > 0) {
+      compute_tile_per_panel<false>(itemID, thread_properties, tiled_input_block, privateRes, db_offset);
+    }
+
+    // Storing the final results in the output
+    store<is_internal_block,
+          contraction_tp == contraction_type::local ? static_cast<StorageIndex>(1) : RHSBlockProperties::nc_stride>(
+        out_ptr + thread_properties.nGlobalOffset * triple_dim.M, privateRes, thread_properties.mGlobalOffset,
+        thread_properties.nGlobalOffset);
+  }
+  // When local memory is available the following extract_block will be enabled
+  template <typename InputBlockProperties, bool is_internal_block, typename Input, typename Local,
+            contraction_type contract_tp = contraction_tp>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<contract_tp == contraction_type::local> extract_block(
+      const Input &inpt, Local local_ptr, const std::pair<StorageIndex, StorageIndex> &local_index,
+      const StorageIndex &ncOffset, const StorageIndex cOffset) const {
+    constexpr StorageIndex TileSizeDimNC =
+        InputBlockProperties::is_rhs ? Properties::TileSizeDimN : Properties::TileSizeDimM;
+    constexpr StorageIndex LoadPerThread =
+        InputBlockProperties::is_rhs ? Properties::LoadPerThreadRhs : Properties::LoadPerThreadLhs;
+    constexpr StorageIndex LSD = InputBlockProperties::is_rhs ? LSDR : LSDL;
+    static_assert(((LocalOffset % (TileSizeDimNC / InputBlockProperties::nc_stride) == 0) &&
+                   (LocalOffset % (Properties::TileSizeDimK / InputBlockProperties::c_stride) == 0)),
+                  " LocalOffset must be divisible by stride");
+    const StorageIndex &NC = InputBlockProperties::is_rhs ? triple_dim.N : triple_dim.M;
+    StorageIndex localThreadNC = local_index.first;
+    StorageIndex localThreadC = local_index.second;
+    auto chk_bound = [&](const StorageIndex &CIndex, const StorageIndex &NCIndex) EIGEN_DEVICE_FUNC {
+      return ((CIndex + InputBlockProperties::c_stride - 1 < triple_dim.K) &&
+              (NCIndex + InputBlockProperties::nc_stride - 1 < NC));
+    };
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex lPT = 0; lPT < LoadPerThread / InputBlockProperties::elements_per_access; lPT++) {
+      const StorageIndex CIndex = cOffset + (InputBlockProperties::c_stride * localThreadC);
+      const StorageIndex NCIndex = ncOffset + (InputBlockProperties::nc_stride * localThreadNC);
+      const StorageIndex ld = InputBlockProperties::is_coalesced_layout ? NC : triple_dim.K;
+      if (check_boundary<is_internal_block>(chk_bound(CIndex, NCIndex))) {
+        auto val =
+            read<InputBlockProperties::packet_load, InputBlockProperties::is_coalesced_layout,
+                 InputBlockProperties::is_rhs, typename InputBlockProperties::OutType>(inpt, NCIndex, CIndex, ld);
+        write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : LSD), data_source::local_mem>(
+            val, local_ptr + (InputBlockProperties::nc_stride * localThreadNC) +
+                     (InputBlockProperties::c_stride * localThreadC * LSD));
+      } else {
+        EIGEN_UNROLL_LOOP
+        for (StorageIndex i = 0; i < InputBlockProperties::elements_per_access; i++) {
+          const StorageIndex nCInd = NCIndex + (InputBlockProperties::is_coalesced_layout ? i : 0);
+          const StorageIndex cInd = CIndex + (InputBlockProperties::is_coalesced_layout ? 0 : i);
+          OutScalar val =
+              (nCInd < NC && cInd < triple_dim.K)
+                  ? read<false, InputBlockProperties::is_coalesced_layout, InputBlockProperties::is_rhs, OutScalar>(
+                        inpt, nCInd, cInd, ld)
+                  : OutScalar(0);
+
+          write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : LSD), data_source::local_mem>(
+              val, local_ptr + (InputBlockProperties::nc_stride * localThreadNC) +
+                       (InputBlockProperties::is_coalesced_layout ? i : 0) +
+                       ((InputBlockProperties::c_stride * localThreadC +
+                         (InputBlockProperties::is_coalesced_layout ? 0 : i)) *
+                        LSD));
+        }
+      }
+      localThreadNC += (InputBlockProperties::is_coalesced_layout)
+                           ? LocalOffset % (TileSizeDimNC / InputBlockProperties::nc_stride)
+                           : LocalOffset / (Properties::TileSizeDimK / InputBlockProperties::c_stride);
+      localThreadC += (InputBlockProperties::is_coalesced_layout)
+                          ? LocalOffset / (TileSizeDimNC / InputBlockProperties::nc_stride)
+                          : LocalOffset % (Properties::TileSizeDimK / InputBlockProperties::c_stride);
+    }
+  }
+};
+
+#ifndef EIGEN_SYCL_DISABLE_GEMV
+
+/*!
+ * \brief GeneralVectorTensor is a template class that provides Tensor -vector contraction operation, which is a special
+ * case of Tensor Tensor contraction.
+ *
+ * \tparam OutScalar: determines the output scalar type
+ *
+ * \tparam OutAccessor: determines the sycl accessor type for out put (please see the sycl-1.2.1 specification
+ * (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for accessor definition)
+ *
+ * \tparam VectorMapper: determines the tensor contraction mapper for the vector input (can be lhs or rhs)
+ *
+ * \tparam TensorMapper: determines the tensor contraction mapper for the tensor input (can be lhs or rhs)
+ *
+ * \tparam StorageIndex: determines the StorageIndex Type
+ *
+ * \tparam Properties: determines the Contraction Panel properties
+ *
+ * \tparam KFactor: determines the number of elements in K dimension in a Tile
+ *
+ * \tparam Vectorizable: determines whether or not the vectorization is enabled for the Eigen expression.
+ *
+ * \tparam is_lhs_vec: determines whether lhs is a vector or rhs is a vector
+ *
+ * \tparam IsFinal: determine if this is the final kernel. If so, the result will be written in a final output.
+ * Otherwise, the result of contraction will be written in a temporary buffer.
+ *
+ * \param scratch: determines the local memory containing the vector block for each work-group
+ *
+ * \param vec: determines the vector input (tensor mapper)
+ *
+ * \param mat: determines the tensor input (tensor mapper)
+ *
+ * \param out_res: determines the output vector containing the contraction result
+ *
+ * \param nonContractGroupSize: a logical number determining the number of work-group for non-contracting dimension
+ *
+ * \param nonContractDim: determines the size of non contracting dimension for the flattened tensor
+ *
+ * \param contractDim: determines the size of non contracting dimension for the flattened tensor
+ *
+ */
+template <typename OutScalar, typename OutAccessor, typename VectorMapper, typename TensorMapper, typename StorageIndex,
+          typename Properties, StorageIndex KFactor, bool Vectorizable, bool is_lhs_vec, bool IsFinal>
+struct GeneralVectorTensor {
+  typedef typename Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketReturnType
+      PacketReturnType;
+  static constexpr int PacketSize =
+      Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketSize;
+  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> Scratch;
+
+  static constexpr StorageIndex OutScratchOffset =
+      KFactor * Properties::LocalThreadSizeC * Properties::LocalThreadSizeNC;
+
+  // Since the access layout for a vector can always be coalesced, when LHS is a vector, we pass false and false to make
+  // sure that the !^ is true When RHS is a vector, we pass true and true to make sure that the !^ is true.
+  typedef BlockProperties<!is_lhs_vec, !is_lhs_vec, Vectorizable, PacketReturnType> VecBlockProperties;
+
+  Scratch scratch;
+  const VectorMapper vec;
+  const TensorMapper mat;
+  OutAccessor out_res;
+  const StorageIndex nonContractGroupSize;
+  const StorageIndex nonContractDim;
+  const StorageIndex contractDim;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE GeneralVectorTensor(Scratch scratch_, const VectorMapper vec_,
+                                                            const TensorMapper mat_, OutAccessor out_res_,
+                                                            const StorageIndex nonContractGroupSize_,
+                                                            const StorageIndex nonContractDim_,
+                                                            const StorageIndex contractDim_)
+      : scratch(scratch_),
+        vec(vec_),
+        mat(mat_),
+        out_res(out_res_),
+        nonContractGroupSize(nonContractGroupSize_),
+        nonContractDim(nonContractDim_),
+        contractDim(contractDim_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
+    auto scratch_ptr = scratch.get_pointer();
+    const StorageIndex linearLocalThreadId = itemID.get_local_id(0);
+    StorageIndex nonContractId = is_lhs_vec ? linearLocalThreadId / Properties::LocalThreadSizeC
+                                            : linearLocalThreadId % Properties::LocalThreadSizeNC;
+    StorageIndex contractId = is_lhs_vec ? linearLocalThreadId % Properties::LocalThreadSizeC
+                                         : linearLocalThreadId / Properties::LocalThreadSizeNC;
+    const StorageIndex cGroupSize = itemID.get_group_range(0) / nonContractGroupSize;
+    const StorageIndex nonContractGroupId =
+        is_lhs_vec ? itemID.get_group(0) / cGroupSize : itemID.get_group(0) % nonContractGroupSize;
+    const StorageIndex contractGroupId =
+        is_lhs_vec ? itemID.get_group(0) % cGroupSize : itemID.get_group(0) / nonContractGroupSize;
+    auto out_ptr = out_res + (IsFinal ? 0 : contractGroupId * nonContractDim);
+
+    const StorageIndex nonContractGroupOffset = nonContractGroupId * Properties::TileSizeDimNC;
+    const StorageIndex contractGroupOffset = contractGroupId * Properties::TileSizeDimC;
+    auto outScratchIndex = nonContractId + contractId * Properties::LocalThreadSizeNC;
+    const StorageIndex globalNonContractDimOffset = nonContractGroupOffset + nonContractId;
+    const StorageIndex globalContractDimOffset = contractGroupOffset + contractId;
+    auto local_output = scratch_ptr + OutScratchOffset;
+    const bool is_internal = nonContractDim - nonContractGroupOffset >= Properties::TileSizeDimNC &&
+                             contractDim - contractGroupOffset >= Properties::TileSizeDimC;
+    is_internal
+        ? compute_panel<true>(itemID, vec, mat, local_output, out_ptr,
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+                              scratch_ptr, contractGroupOffset,
+#endif
+                              nonContractGroupOffset, linearLocalThreadId, contractDim, nonContractDim, contractId,
+                              nonContractId, globalContractDimOffset, globalNonContractDimOffset, outScratchIndex)
+        : compute_panel<false>(itemID, vec, mat, local_output, out_ptr,
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+                               scratch_ptr, contractGroupOffset,
+#endif
+                               nonContractGroupOffset, linearLocalThreadId, contractDim, nonContractDim, contractId,
+                               nonContractId, globalContractDimOffset, globalNonContractDimOffset, outScratchIndex);
+  }
+  template <bool is_internal_block, typename OutPtr>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(
+      const cl::sycl::nd_item<1> &itemID, const VectorMapper &vec, const TensorMapper &mat, OutScalar *local_output,
+      OutPtr out_ptr,
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+      OutScalar *scratch_ptr, const StorageIndex contractGroupOffset,
+#endif
+      const StorageIndex nonContractGroupOffset, const StorageIndex linearLocalThreadId, StorageIndex contractDim,
+      StorageIndex nonContractDim, StorageIndex contractId, StorageIndex nonContractId,
+      StorageIndex globalContractDimOffset, StorageIndex globalNonContractDimOffset, StorageIndex outScratchIndex) {
+    OutScalar outScalar[Properties::WorkLoadPerThreadNC] = {OutScalar(0)};
+    // Reading the vector
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+    const StorageIndex vectorOffset = contractGroupOffset + linearLocalThreadId;
+    extract_block<VecBlockProperties, is_internal_block, KFactor,
+                  Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC>(vec, scratch_ptr, linearLocalThreadId,
+                                                                                vectorOffset, contractDim);
+
+    itemID.barrier(cl::sycl::access::fence_space::local_space);
+    auto in_scratch_ptr = scratch_ptr + contractId;
+#endif
+
+    StorageIndex privateOffsetC = 0;
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex i = 0; i < Properties::WorkLoadPerThreadC; i++) {
+      StorageIndex privateOffsetNC = 0;
+      bool contract_conds = ((globalContractDimOffset + privateOffsetC) < contractDim);
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+      auto vecScalar = *in_scratch_ptr;
+#else
+      auto vecScalar = (check_boundary<is_internal_block>(contract_conds))
+                           ? vec(is_lhs_vec ? StorageIndex(0) : globalContractDimOffset + privateOffsetC,
+                                 is_lhs_vec ? globalContractDimOffset + privateOffsetC : StorageIndex(0))
+                           : OutScalar(0);
+#endif
+      EIGEN_UNROLL_LOOP
+      for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
+        auto matScalar = (check_boundary<is_internal_block>(
+                             contract_conds && ((globalNonContractDimOffset + privateOffsetNC) < nonContractDim)))
+                             ? mat(is_lhs_vec ? globalContractDimOffset + privateOffsetC
+                                              : globalNonContractDimOffset + privateOffsetNC,
+                                   is_lhs_vec ? globalNonContractDimOffset + privateOffsetNC
+                                              : globalContractDimOffset + privateOffsetC)
+                             : OutScalar(0);
+
+        outScalar[j] = ::Eigen::internal::pmadd(matScalar, vecScalar, outScalar[j]);
+        privateOffsetNC += Properties::LocalThreadSizeNC;
+      }
+      privateOffsetC += Properties::LocalThreadSizeC;
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+      in_scratch_ptr += Properties::LocalThreadSizeC;
+#endif
+    }
+
+    auto out_scratch_ptr = local_output + outScratchIndex;
+    // Each block of 16*16 element in shared memory should reduce to 16*1
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
+      *out_scratch_ptr = outScalar[j];
+
+      out_scratch_ptr += (Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC);
+    }
+    EIGEN_IF_CONSTEXPR (is_lhs_vec) {
+      nonContractId = linearLocalThreadId % Properties::LocalThreadSizeNC;
+      contractId = linearLocalThreadId / Properties::LocalThreadSizeNC;
+      outScratchIndex = nonContractId + contractId * Properties::LocalThreadSizeNC;
+    }
+
+    out_scratch_ptr = local_output + outScratchIndex;
+    EIGEN_UNROLL_LOOP
+    for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
+      EIGEN_UNROLL_LOOP
+      for (StorageIndex offset = Properties::LocalThreadSizeC >> 1; offset > 0; offset >>= 1) {
+        itemID.barrier(cl::sycl::access::fence_space::local_space);
+        if (contractId < offset) {
+          StorageIndex myNeigbourId = (Properties::LocalThreadSizeNC * offset);
+          *out_scratch_ptr += out_scratch_ptr[myNeigbourId];
+        }
+      }
+      // moving to next 16 by 16 block
+      out_scratch_ptr += (Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC);
+    }
+
+    if (contractId == 0) {
+      out_scratch_ptr = local_output + nonContractId;
+      StorageIndex global_final_offset = nonContractGroupOffset + nonContractId;
+      out_ptr += global_final_offset;
+      EIGEN_UNROLL_LOOP
+      for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
+        if (check_boundary<is_internal_block>(global_final_offset < nonContractDim)) {
+          auto res = *out_scratch_ptr;
+
+          *out_ptr = res;
+          out_ptr += Properties::LocalThreadSizeNC;
+        }
+        // moving to next 16 by 16 block to get the next 16 reduced elements
+        out_scratch_ptr += (Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC);
+        if (!(is_internal_block)) global_final_offset += Properties::LocalThreadSizeNC;
+      }
+    }
+  }
+
+  template <typename InputBlockProperties, bool is_internal_block, int CFactor, int GroupSize, typename Input,
+            typename Local>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_block(const Input &inpt, Local *local_ptr,
+                                                                  const StorageIndex &linearLocalThreadId,
+                                                                  const StorageIndex &cOffset, const StorageIndex &C) {
+    local_ptr += InputBlockProperties::c_stride * linearLocalThreadId;
+    StorageIndex cIndex = cOffset;
+    for (StorageIndex cId = 0; cId < CFactor / InputBlockProperties::c_stride; cId++) {
+      if (check_boundary<is_internal_block>(cIndex + InputBlockProperties::c_stride - 1 < C)) {
+        auto val = read<InputBlockProperties::packet_load, InputBlockProperties::is_coalesced_layout,
+                        InputBlockProperties::is_rhs, typename InputBlockProperties::OutType>(inpt, StorageIndex(0),
+                                                                                              cIndex, StorageIndex(1));
+        write<StorageIndex, 1, data_source::local_mem>(val, local_ptr);
+      } else {
+        EIGEN_UNROLL_LOOP
+        for (StorageIndex i = 0; i < InputBlockProperties::elements_per_access; i++) {
+          OutScalar val =
+              (cIndex + i < C)
+                  ? read<false, InputBlockProperties::is_coalesced_layout, InputBlockProperties::is_rhs, OutScalar>(
+                        inpt, StorageIndex(0), cIndex + i, StorageIndex(1))
+                  : OutScalar(0);
+          write<StorageIndex, 1, data_source::local_mem>(val, local_ptr + i);
+        }
+      }
+      local_ptr += InputBlockProperties::c_stride * GroupSize;
+      cIndex += InputBlockProperties::c_stride * GroupSize;
+    }
+  }
+};
+#endif
+
+#ifndef EIGEN_SYCL_DISABLE_SCALAR
+
+/*!
+ * \brief GeneralScalarContraction is a template class that provides the scalar value of Tensor -Tensor contraction
+ * operation, when all the dimensions are contracting dimensions. This Kernel reduces two tensors to a scalar
+ *
+ * \tparam OutScalar: determines the output scalar type
+ *
+ * \tparam LhsScalar: determines the left-hand-side scalar type
+ *
+ * \tparam RhsScalar: determines the right-hand-side scalar type
+ *
+ * \tparam OutAccessor: determines the sycl accessor type for out put (please see the sycl-1.2.1 specification
+ * (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for accessor definition)
+ *
+ * \tparam LhsMapper: determines the tensor contraction mapper type for left-hand-side matrix
+ *
+ * \tparam RhsMapper: determines the tensor contraction mapper type for right-hand-side matrix
+ *
+ * \tparam StorageIndex: determines the StorageIndex Type
+ *
+ * \tparam Vectorizable: determines whether or not the vectorization is enabled for the Eigen expression.
+ *
+ * \param scratch: local memory containing tiles of LHS and RHS tensors for each work-group
+ *
+ * \param lhs: determines the left-hand-side flattened tensor (tensor mapper)
+ *
+ * \param rhs: determines the right-hand-side flattened tensor (tensor mapper)
+ *
+ * \param out_res: determines the output tensor containing the contraction result
+ *
+ * \param rng: determines the total input data size
+ */
+template <typename OutScalar, typename LhsScalar, typename RhsScalar, typename OutAccessor, typename LhsMapper,
+          typename RhsMapper, typename StorageIndex, bool Vectorizable>
+struct GeneralScalarContraction {
+  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> Scratch;
+  Scratch scratch;
+  const LhsMapper lhs;
+  const RhsMapper rhs;
+  OutAccessor out_res;
+  const StorageIndex rng;
+
+  EIGEN_DEVICE_FUNC GeneralScalarContraction(Scratch scratch_, const LhsMapper lhs_, const RhsMapper rhs_,
+                                             OutAccessor out_res_, const StorageIndex rng_)
+      : scratch(scratch_), lhs(lhs_), rhs(rhs_), out_res(out_res_), rng(rng_) {}
+
+  EIGEN_DEVICE_FUNC void operator()(cl::sycl::nd_item<1> itemID) const {
+    auto out_ptr = out_res;
+    OutScalar *scratch_ptr = scratch.get_pointer();
+
+    StorageIndex globalid = itemID.get_global_id(0);
+    StorageIndex localid = itemID.get_local_id(0);
+    OutScalar accumulator = OutScalar(0);
+    for (StorageIndex i = globalid; i < rng; i += itemID.get_global_range(0)) {
+      accumulator = Eigen::internal::pmadd(lhs(0, i), rhs(i, 0), accumulator);
+    }
+    auto out_scratch_ptr = scratch_ptr + localid;
+    *out_scratch_ptr = accumulator;
+    for (StorageIndex offset = itemID.get_local_range(0) >> 1; offset > 0; offset >>= 1) {
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+      if (localid < offset) {
+        *out_scratch_ptr = (accumulator += out_scratch_ptr[offset]);
+      }
+    }
+    if (localid == 0) {
+      out_ptr[itemID.get_group(0)] = accumulator;
+    }
+  }
+};
+#endif
+
+}  // namespace internal
+}  // namespace TensorSycl
+
+template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
+struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>,
+                       Eigen::SyclDevice>
+    : public TensorContractionEvaluatorBase<TensorEvaluator<
+          const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Eigen::SyclDevice>> {
+  static_assert(std::is_same<OutputKernelType, const NoOpOutputKernel>::value,
+                "SYCL tensor contraction does not support output kernels.");
+
+  typedef Eigen::SyclDevice Device;
+
+  typedef TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device> Self;
+  typedef TensorContractionEvaluatorBase<Self> Base;
+  typedef TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType> XprType;
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef typename XprType::Index StorageIndex;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename Base::Storage Storage;
+  typedef typename Base::EvaluatorPointerType EvaluatorPointerType;
+  struct TripleDim {
+    const StorageIndex M;
+    const StorageIndex N;
+    const StorageIndex K;
+    TripleDim(const StorageIndex M_, const StorageIndex N_, const StorageIndex K_) : M(M_), N(N_), K(K_) {}
+  };
+  enum {
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = false,
+  };
+
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+  static constexpr int LDims = Base::LDims;
+  static constexpr int RDims = Base::RDims;
+  static constexpr int ContractDims = Base::ContractDims;
+
+  typedef array<StorageIndex, LDims> left_dim_mapper_t;
+  typedef array<StorageIndex, RDims> right_dim_mapper_t;
+
+  typedef array<StorageIndex, ContractDims> contract_t;
+  typedef array<StorageIndex, LDims - ContractDims> left_nocontract_t;
+  typedef array<StorageIndex, RDims - ContractDims> right_nocontract_t;
+
+  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
+
+  typedef DSizes<StorageIndex, NumDims> Dimensions;
+
+  typedef TensorEvaluator<typename Base::EvalLeftArgType, Device> LeftEvaluator;
+  typedef TensorEvaluator<typename Base::EvalRightArgType, Device> RightEvaluator;
+  typedef std::remove_const_t<typename LeftEvaluator::CoeffReturnType> LhsScalar;
+  typedef std::remove_const_t<typename RightEvaluator::CoeffReturnType> RhsScalar;
+
+  typedef typename LeftEvaluator::Dimensions LeftDimensions;
+  typedef typename RightEvaluator::Dimensions RightDimensions;
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered>
+  struct input_mapper_propertis {
+    static constexpr bool is_lhs_matrix = (LDims == 2 && ContractDims == 1) || lhs_inner_dim_contiguous;
+    static constexpr bool is_rhs_matrix =
+        (RDims == 2 && ContractDims == 1) || (rhs_inner_dim_contiguous && !rhs_inner_dim_reordered);
+  };
+
+  TensorEvaluator(const XprType &op, const Device &device) : Base(op, device) {}
+
+  // We need to redefine this method to make nvcc happy
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(typename Base::EvaluatorPointerType data) {
+    this->m_leftImpl.evalSubExprsIfNeeded(nullptr);
+    this->m_rightImpl.evalSubExprsIfNeeded(nullptr);
+    if (!data) {
+      this->m_result = this->m_device.get(
+          static_cast<Scalar *>(this->m_device.allocate_temp(this->dimensions().TotalSize() * sizeof(Scalar))));
+      data = this->m_result;
+    }
+    evalToSycl(data);
+    return (this->m_result != nullptr);
+  }
+  const Eigen::SyclDevice &device() const { return this->m_device; }
+  void evalToSycl(typename Base::EvaluatorPointerType buffer) const {
+    if (this->m_lhs_inner_dim_contiguous) {
+      if (this->m_rhs_inner_dim_contiguous) {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<true, true, true, Unaligned>(buffer);
+        } else {
+          evalTyped<true, true, false, Unaligned>(buffer);
+        }
+      } else {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<true, false, true, Unaligned>(buffer);
+        } else {
+          evalTyped<true, false, false, Unaligned>(buffer);
+        }
+      }
+    } else {
+      if (this->m_rhs_inner_dim_contiguous) {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<false, true, true, Unaligned>(buffer);
+        } else {
+          evalTyped<false, true, false, Unaligned>(buffer);
+        }
+      } else {
+        if (this->m_rhs_inner_dim_reordered) {
+          evalTyped<false, false, true, Unaligned>(buffer);
+        } else {
+          evalTyped<false, false, false, Unaligned>(buffer);
+        }
+      }
+    }
+  }
+
+  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
+  void evalTyped(typename Base::EvaluatorPointerType buffer) const {
+    const auto triple_dim = TripleDim{this->m_i_size, this->m_j_size, this->m_k_size};
+    typedef internal::TensorContractionInputMapper<
+        LhsScalar, StorageIndex, internal::Lhs, LeftEvaluator, left_nocontract_t, contract_t,
+        PacketType<CoeffReturnType, Device>::size, lhs_inner_dim_contiguous, false, Unaligned, MakePointer>
+        LhsMapper;
+
+    typedef internal::TensorContractionInputMapper<RhsScalar, StorageIndex, internal::Rhs, RightEvaluator,
+                                                   right_nocontract_t, contract_t,
+                                                   PacketType<CoeffReturnType, Device>::size, rhs_inner_dim_contiguous,
+                                                   rhs_inner_dim_reordered, Unaligned, MakePointer>
+        RhsMapper;
+
+    // initialize data mappers
+    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
+                  this->m_left_contracting_strides, this->m_k_strides);
+
+    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
+                  this->m_right_contracting_strides, this->m_k_strides);
+
+#ifndef EIGEN_SYCL_DISABLE_SCALAR
+    if (triple_dim.M == 1 && triple_dim.N == 1) {
+      launchSC(buffer, lhs, rhs, triple_dim.K);
+    } else
+#endif
+#ifndef EIGEN_SYCL_DISABLE_GEMV
+        if (triple_dim.M != 1 && triple_dim.N == 1) {
+      LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
+    } else if (triple_dim.M == 1 && triple_dim.N != 1) {
+      LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
+    } else  // This is equivalent of if (m!=1 && n!=1)
+#endif
+    {
+      typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
+          inpt_mapper_properties;
+#ifndef EIGEN_SYCL_DISABLE_SKINNY
+      bool skinny = false;
+      auto platform_name = this->device().getPlatformName();
+      // This is based on empirical calculation for AMD r9-nano and Fiji
+      if (platform_name.find("AMD") == 0) {
+        skinny = (triple_dim.M < triple_dim.K || triple_dim.N < triple_dim.K) &&
+                 ((triple_dim.M < 1024 && triple_dim.N < 1024) ||
+                  (uint64_t(triple_dim.M * triple_dim.N) < uint64_t(triple_dim.K)));
+      } else {
+        skinny = (((std::max(triple_dim.K, triple_dim.N) / std::min(triple_dim.K, triple_dim.N)) > 100) ||
+                  ((std::max(triple_dim.K, triple_dim.M) / std::min(triple_dim.K, triple_dim.M)) > 100) ||
+                  ((std::max(triple_dim.N, triple_dim.M) / std::min(triple_dim.N, triple_dim.M)) > 100));
+      }
+      if (skinny)
+        adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
+      else
+#endif  // EIGEN_SYCL_DISABLE_SKINNY
+        adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
+    }
+  }
+
+  template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
+  void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
+                                    const TripleDim &triple_dim) const {
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+    if (device().has_local_memory()) {
+      typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
+      launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
+          buffer, lhs, rhs, triple_dim);
+    }
+#endif
+#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+    if (!(device().has_local_memory())) {
+      typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
+      launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
+          buffer, lhs, rhs, triple_dim);
+    }
+#endif
+  }
+
+  template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
+            typename Properties, typename LhsMapper, typename RhsMapper>
+  void launchTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
+                const TripleDim &triple_dim) const {
+    const StorageIndex roundUpM = Eigen::TensorSycl::internal::roundUp(triple_dim.M, Properties::TileSizeDimM);
+    const StorageIndex roundUpN = Eigen::TensorSycl::internal::roundUp(triple_dim.N, Properties::TileSizeDimN);
+    const StorageIndex groupSizeM = roundUpM / Properties::TileSizeDimM;
+    const StorageIndex groupSizeN = roundUpN / Properties::TileSizeDimN;
+
+    const StorageIndex roundUpK = Eigen::TensorSycl::internal::roundUp(triple_dim.K, Properties::TileSizeDimK);
+    StorageIndex totalTilesK = roundUpK / Properties::TileSizeDimK;
+    StorageIndex groupSizeK =
+        skinny
+            ? std::max(std::min(totalTilesK,
+                                (StorageIndex)(device().getPowerOfTwo(device().getNumSyclMultiProcessors(), true) * 4) /
+                                    (groupSizeM * groupSizeN)),
+                       StorageIndex(1))
+            : StorageIndex(1);
+
+    const StorageIndex numTilesPerGroup = Eigen::TensorSycl::internal::roundUp(totalTilesK, groupSizeK) / groupSizeK;
+
+    const StorageIndex totalGroupSize = groupSizeM * groupSizeN * groupSizeK;
+
+    const StorageIndex localRange = Properties::LocalThreadSizeM * Properties::LocalThreadSizeN;
+    const StorageIndex globalRange = totalGroupSize * localRange;
+
+    const StorageIndex scratchSize = (ct == TensorSycl::internal::contraction_type::local)
+                                         ? ((Properties::DoubleBuffer + 1) *
+                                            (Properties::TileSizeDimM + Properties::BC) * (Properties::TileSizeDimK)) +
+                                               ((Properties::DoubleBuffer + 1) * (Properties::TileSizeDimK) *
+                                                (Properties::TileSizeDimN + Properties::BC))
+                                         : StorageIndex(1);
+
+    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(globalRange), cl::sycl::range<1>(localRange));
+    if (groupSizeK == 1) {
+      typedef TensorSycl::internal::TensorContractionKernel<CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType,
+                                                            LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim,
+                                                            PacketAccess, input_mapper_properties, true, ct>
+          ContractKernelName;
+      device()
+          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
+              lhs, rhs, buffer, thread_range, scratchSize, groupSizeM, groupSizeN, numTilesPerGroup, triple_dim)
+          .wait();
+    } else {
+      typedef TensorSycl::internal::TensorContractionKernel<CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType,
+                                                            LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim,
+                                                            PacketAccess, input_mapper_properties, false, ct>
+          ContractKernelName;
+      CoeffReturnType *temp_pointer = static_cast<CoeffReturnType *>(
+          device().allocate_temp(triple_dim.M * triple_dim.N * groupSizeK * sizeof(CoeffReturnType)));
+      EvaluatorPointerType tmp_global_accessor = device().get(temp_pointer);
+
+      device()
+          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
+              lhs, rhs, tmp_global_accessor, thread_range, scratchSize, groupSizeM, groupSizeN, numTilesPerGroup,
+              triple_dim)
+          .wait();
+
+      typedef Eigen::internal::SumReducer<CoeffReturnType> Op;
+      auto op = Op();
+      typedef TensorSycl::internal::SecondStepPartialReduction<CoeffReturnType, StorageIndex, EvaluatorPointerType,
+                                                               EvaluatorPointerType, Op>
+          ReductionKernel;
+
+      device()
+          .template unary_kernel_launcher<CoeffReturnType, ReductionKernel>(
+              tmp_global_accessor, buffer,
+              cl::sycl::nd_range<1>(cl::sycl::range<1>(StorageIndex(
+                                        Eigen::TensorSycl::internal::roundUp(triple_dim.M * triple_dim.N, localRange))),
+                                    cl::sycl::range<1>(localRange)),
+              StorageIndex(1), op, StorageIndex(triple_dim.M * triple_dim.N), groupSizeK)
+          .wait();
+      device().deallocate_temp(temp_pointer);
+    }
+  }
+
+#ifndef EIGEN_SYCL_DISABLE_GEMV
+  template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
+  void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
+                                    StorageIndex NC, StorageIndex C) const {
+    const StorageIndex nonContractDim = NC;
+    constexpr StorageIndex NCFactor = 1;
+    constexpr StorageIndex CFactor = 1;
+    constexpr StorageIndex NCWindow = 16;
+    typedef Eigen::TensorSycl::internal::TVPanelSize<CoeffReturnType, StorageIndex, NCWindow, CFactor, NCFactor>
+        Properties;
+    const StorageIndex roundUpC = Eigen::TensorSycl::internal::roundUp(C, Properties::TileSizeDimC);
+    const StorageIndex cNumGroups = roundUpC / (Properties::LocalThreadSizeC * Properties::WorkLoadPerThreadC);
+    const StorageIndex roundUpNC = Eigen::TensorSycl::internal::roundUp(nonContractDim, Properties::TileSizeDimNC);
+    const StorageIndex nCNumGroups = roundUpNC / (Properties::LocalThreadSizeNC * Properties::WorkLoadPerThreadNC);
+    const StorageIndex globalRange =
+        (roundUpNC / (Properties::WorkLoadPerThreadNC)) * (roundUpC / (Properties::WorkLoadPerThreadC));
+    const StorageIndex localRange = Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC;
+    const StorageIndex scratchSize =
+        (Properties::WorkLoadPerThreadNC + CFactor) * Properties::LocalThreadSizeC * Properties::LocalThreadSizeNC;
+    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(globalRange), cl::sycl::range<1>(localRange));
+    if (cNumGroups > 1) {
+      typedef Eigen::TensorSycl::internal::GeneralVectorTensor<CoeffReturnType, EvaluatorPointerType, VectorMapper,
+                                                               TensorMapper, StorageIndex, Properties, CFactor, false,
+                                                               is_lhs_vec, false>
+          ContractKernelName;
+      CoeffReturnType *temp_pointer =
+          static_cast<CoeffReturnType *>(device().allocate_temp(nonContractDim * cNumGroups * sizeof(CoeffReturnType)));
+      EvaluatorPointerType tmp_global_accessor = device().get(temp_pointer);
+
+      device()
+          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
+              vec, mat, tmp_global_accessor, thread_range, scratchSize, nCNumGroups, nonContractDim, C)
+          .wait();
+
+      typedef Eigen::internal::SumReducer<CoeffReturnType> Op;
+      typedef TensorSycl::internal::SecondStepPartialReduction<CoeffReturnType, StorageIndex, EvaluatorPointerType,
+                                                               EvaluatorPointerType, Op>
+          ReductionKernel;
+
+      device()
+          .template unary_kernel_launcher<CoeffReturnType, ReductionKernel>(
+              tmp_global_accessor, buffer,
+              cl::sycl::nd_range<1>(
+                  cl::sycl::range<1>(Eigen::TensorSycl::internal::roundUp(nonContractDim, localRange)),
+                  cl::sycl::range<1>(localRange)),
+              StorageIndex(1), Op(), nonContractDim, cNumGroups)
+          .wait();
+      device().deallocate_temp(temp_pointer);
+    } else {
+      typedef Eigen::TensorSycl::internal::GeneralVectorTensor<CoeffReturnType, EvaluatorPointerType, VectorMapper,
+                                                               TensorMapper, StorageIndex, Properties, CFactor, false,
+                                                               is_lhs_vec, true>
+          ContractKernelName;
+      device()
+          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
+              vec, mat, buffer, thread_range, scratchSize, nCNumGroups, nonContractDim, C)
+          .wait();
+    }
+  }
+#endif
+
+#ifndef EIGEN_SYCL_DISABLE_SCALAR
+  template <typename LhsMapper, typename RhsMapper>
+  EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
+                                    StorageIndex K) const {
+    EIGEN_STATIC_ASSERT(!((EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1) &
+                          (EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1 - 1)),
+                        "The Local thread size must be a power of 2 for the reduction "
+                        "operation");
+    constexpr StorageIndex local_range = EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1;
+
+    // Here we force the code not to be more than 2-step reduction: Our empirical research shows that if each thread
+    // reduces at least 512 elements individually, we get better performance.
+    const StorageIndex num_work_group = ((K + (512 * local_range - 1)) / (512 * local_range) > 1 ? local_range : 1);
+    const StorageIndex global_range = num_work_group * local_range;
+
+    typedef Eigen::TensorSycl::internal::GeneralScalarContraction<
+        CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType, LhsMapper, RhsMapper, StorageIndex, false>
+        ContractKernelName;
+    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
+    if (num_work_group > 1) {
+      CoeffReturnType *temp_pointer =
+          static_cast<CoeffReturnType *>(device().allocate_temp(num_work_group * sizeof(CoeffReturnType)));
+      EvaluatorPointerType tmp_global_accessor = device().get(temp_pointer);
+      device()
+          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(lhs, rhs, tmp_global_accessor,
+                                                                                thread_range, local_range, K)
+          .wait();
+      typedef Eigen::internal::SumReducer<CoeffReturnType> Op;
+      typedef TensorSycl::internal::SecondStepFullReducer<CoeffReturnType, Op, EvaluatorPointerType,
+                                                          EvaluatorPointerType, StorageIndex, local_range>
+          GenericRKernel;
+      device()
+          .template unary_kernel_launcher<CoeffReturnType, GenericRKernel>(
+              tmp_global_accessor, buffer,
+              cl::sycl::nd_range<1>(cl::sycl::range<1>(local_range), cl::sycl::range<1>(local_range)), local_range,
+              Op())
+          .wait();
+      device().deallocate_temp(temp_pointer);
+    } else {
+      device()
+          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(lhs, rhs, buffer, thread_range,
+                                                                                local_range, K)
+          .wait();
+    }
+  }
+#endif
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    this->m_leftImpl.cleanup();
+    this->m_rightImpl.cleanup();
+
+    if (this->m_result) {
+      this->m_device.deallocate_temp(this->m_result);
+      this->m_result = nullptr;
+    }
+  }
+};
+}  // namespace Eigen
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_SYCL_H
diff --git a/contrib/Eigen/src/Tensor/TensorContractionThreadPool.h b/contrib/Eigen/src/Tensor/TensorContractionThreadPool.h
new file mode 100644
index 0000000..96da0ca
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorContractionThreadPool.h
@@ -0,0 +1,1557 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
+#define EIGEN_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
+
+// evaluator for thread pool device
+#ifdef EIGEN_USE_THREADS
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
+struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>,
+                       ThreadPoolDevice>
+    : public TensorContractionEvaluatorBase<TensorEvaluator<
+          const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, ThreadPoolDevice>> {
+  using Device = ThreadPoolDevice;
+
+  using Self = TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>;
+  using Base = TensorContractionEvaluatorBase<Self>;
+
+  using XprType = TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>;
+  using Scalar = std::remove_const_t<typename XprType::Scalar>;
+  using Index = typename XprType::Index;
+  using CoeffReturnType = typename XprType::CoeffReturnType;
+  using PacketReturnType = typename PacketType<CoeffReturnType, Device>::type;
+
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+
+  // Most of the code is assuming that both input tensors are ColMajor. If the
+  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
+  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
+  // will pretend B is LHS and A is RHS.
+  using EvalLeftArgType =
+      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), LeftArgType, RightArgType>;
+  using EvalRightArgType =
+      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), RightArgType, LeftArgType>;
+
+  static constexpr int LDims =
+      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
+  static constexpr int RDims =
+      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
+  static constexpr int ContractDims = internal::array_size<Indices>::value;
+
+  using left_dim_mapper_t = array<Index, LDims>;
+  using right_dim_mapper_t = array<Index, RDims>;
+
+  using contract_t = array<Index, ContractDims>;
+  using left_nocontract_t = array<Index, LDims - ContractDims>;
+  using right_nocontract_t = array<Index, RDims - ContractDims>;
+
+  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
+
+  using Dimensions = DSizes<Index, NumDims>;
+
+  // typedefs needed in evalTo
+  using LhsScalar = std::remove_const_t<typename EvalLeftArgType::Scalar>;
+  using RhsScalar = std::remove_const_t<typename EvalRightArgType::Scalar>;
+  using Traits = typename internal::gebp_traits<LhsScalar, RhsScalar>;
+
+  using LeftEvaluator = TensorEvaluator<EvalLeftArgType, Device>;
+  using RightEvaluator = TensorEvaluator<EvalRightArgType, Device>;
+
+  TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  template <int Alignment>
+  void evalProduct(Scalar* buffer) const {
+    evalProductImpl<NoCallback, Alignment>(buffer, NoCallback());
+  }
+
+  template <typename EvalToCallback, int Alignment>
+  void evalProductAsync(Scalar* buffer, EvalToCallback done) const {
+    evalProductImpl<EvalToCallback, Alignment>(buffer, std::move(done));
+  }
+
+  template <typename DoneCallback, int Alignment>
+  void evalProductImpl(Scalar* buffer, DoneCallback done) const {
+    // This function computes a lot of heuristics in multiple steps, and it
+    // also has multiple exit points. To keep it sane, readable and all in one
+    // place, sync/async execution decision is made at runtime at the very end.
+    //
+    // (1) In sync mode we allocate Context on the stack, submit computations
+    //     to the device thread pool, and block on a barrier until it is
+    //     completed.
+    //
+    // (2) In async mode we allocate Context on the heap, and after all tasks
+    //     are finished, we call the provided done callback, and delete a
+    //     context from the heap.
+    //
+    // (*) EvalParallelContext & EvalShardedByInnerDimContext owns all the state
+    // and temporary buffers, required for executing the tensor contraction.
+    // They are responsible for cleaning it up after contraction is done.
+    static constexpr bool IsEvalInSyncMode = std::is_same<DoneCallback, NoCallback>::value;
+
+    const Index m = this->m_i_size;
+    const Index n = this->m_j_size;
+    const Index k = this->m_k_size;
+    if (m == 0 || n == 0) {
+      EIGEN_IF_CONSTEXPR (!IsEvalInSyncMode) done();
+      return;
+    }
+    if (k == 0) {
+      internal::tensor_contraction_dispatch(
+          [&](auto lhs_c, auto rhs_c, auto rhs_r) {
+            this->template evalProductSequential<lhs_c(), rhs_c(), rhs_r(), Unaligned>(buffer);
+          },
+          this->m_lhs_inner_dim_contiguous, this->m_rhs_inner_dim_contiguous, this->m_rhs_inner_dim_reordered);
+      EIGEN_IF_CONSTEXPR (!IsEvalInSyncMode) done();
+      return;
+    }
+
+    // Compute a set of algorithm parameters:
+    // - kernel block sizes (bm, bn, bk)
+    // - task grain sizes (number of kernels executed per task: gm, gn)
+    // - number of threads
+    // - sharding by row/column
+    // - parallel packing or first lhs then rhs
+    // and some derived parameters:
+    // - number of tasks (nm, nn, nk)
+    // - number of kernels (nm0, nn0)
+    // Unfortunately, all these parameters are tightly interdependent.
+    // So in some cases we first compute approximate values, then compute other
+    // values based on these approximations and then refine the approximations.
+
+    // There are lots of heuristics here. There is some reasoning behind them,
+    // but ultimately they are just tuned on contraction benchmarks for
+    // different input configurations, thread counts and instruction sets.
+    // So feel free to question any of them.
+
+    // Compute whether we want to shard by row or by column.
+    // This is a first approximation, it will be refined later. Since we don't
+    // know number of threads yet we use 2, because what we are most
+    // interested in at this point is whether it makes sense to use
+    // parallelization at all or not.
+    bool shard_by_col = shardByCol(m, n, 2);
+
+    // First approximation of kernel blocking sizes.
+    // Again, we don't know number of threads yet, so we use 2.
+    Index bm, bn, bk;
+    if (shard_by_col) {
+      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(k, m, n,
+                                                                                                              2);
+      bm = blocking.mc();
+      bn = blocking.nc();
+      bk = blocking.kc();
+    } else {
+      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByRow> blocking(k, m, n,
+                                                                                                              2);
+      bm = blocking.mc();
+      bn = blocking.nc();
+      bk = blocking.kc();
+    }
+
+    // Compute optimal number of threads.
+    // Note: we use bk instead of k here because we are interested in amount of
+    // _parallelizable_ computations, and computations are not parallelizable
+    // across k dimension.
+    const TensorOpCost cost = contractionCost(m, n, bm, bn, bk, shard_by_col, false);
+    int num_threads =
+        TensorCostModel<ThreadPoolDevice>::numThreads(static_cast<double>(n) * m, cost, this->m_device.numThreads());
+    int num_threads_by_k = numThreadsInnerDim(m, n, k);
+    if (shardByInnerDim(m, n, k, num_threads, num_threads_by_k)) {
+      // We are in the scenario where it is more effective to shard by the
+      // inner dimension.
+      EIGEN_IF_CONSTEXPR (IsEvalInSyncMode) {
+        EvalShardedByInnerDimContext<DoneCallback> ctx(this, num_threads_by_k, buffer, m, n, k, std::move(done));
+        ctx.template run<Alignment>();
+      } else {
+        auto* ctx =
+            new EvalShardedByInnerDimContext<DoneCallback>(this, num_threads_by_k, buffer, m, n, k, std::move(done));
+        ctx->template runAsync<Alignment>();
+      }
+
+      return;
+    }
+
+    // TODO(dvyukov): this is a stop-gap to prevent regressions while the cost
+    // model is not tuned. Remove this when the cost model is tuned.
+    if (n == 1) num_threads = 1;
+
+    if (num_threads == 1) {
+      internal::tensor_contraction_dispatch(
+          [&](auto lhs_c, auto rhs_c, auto rhs_r) {
+            this->template evalProductSequential<lhs_c(), rhs_c(), rhs_r(), Unaligned>(buffer);
+          },
+          this->m_lhs_inner_dim_contiguous, this->m_rhs_inner_dim_contiguous, this->m_rhs_inner_dim_reordered);
+      EIGEN_IF_CONSTEXPR (!IsEvalInSyncMode) done();
+      return;
+    }
+
+    // Now that we know number of threads, recalculate sharding and blocking.
+    shard_by_col = shardByCol(m, n, num_threads);
+    if (shard_by_col) {
+      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(
+          k, m, n, num_threads);
+      bm = blocking.mc();
+      bn = blocking.nc();
+      bk = blocking.kc();
+    } else {
+      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByRow> blocking(
+          k, m, n, num_threads);
+      bm = blocking.mc();
+      bn = blocking.nc();
+      bk = blocking.kc();
+    }
+
+    // Number of kernels for each dimension.
+    Index nm0 = numext::div_ceil(m, bm);
+    Index nn0 = numext::div_ceil(n, bn);
+    Index nk = numext::div_ceil(k, bk);
+
+    // Calculate task grain size (number of kernels executed per task).
+    // This task size coarsening serves two purposes:
+    // 1. It reduces per-task overheads including synchronization overheads.
+    // 2. It allows to use caches better (reuse the same packed rhs in several
+    // consecutive kernels).
+    Index gm = 1;
+    Index gn = 1;
+    // If we are sharding by column, then we prefer to reduce rows first.
+    if (shard_by_col) {
+      gm = coarsenM(m, n, bm, bn, bk, gn, num_threads, shard_by_col);
+      gn = coarsenN(m, n, bm, bn, bk, gm, num_threads, shard_by_col);
+    } else {
+      gn = coarsenN(m, n, bm, bn, bk, gm, num_threads, shard_by_col);
+      gm = coarsenM(m, n, bm, bn, bk, gn, num_threads, shard_by_col);
+    }
+    // Number of tasks in each dimension.
+    Index nm = numext::div_ceil(nm0, gm);
+    Index nn = numext::div_ceil(nn0, gn);
+
+    // If there is enough concurrency in the sharding dimension, we choose not
+    // to parallelize by the other dimension, and execute all kernels in sync
+    // mode. This reduces parallelism from the nm x nn down to nn
+    // (shard_by_col==true) or nm (shard_by_col==false).
+    const Index sharding_dim_tasks = shard_by_col ? nn : nm;
+    const int num_worker_threads = this->m_device.numThreadsInPool();
+
+    // With small number of threads we want to make sure that we do not reduce
+    // parallelism too much. With large number of threads we trade maximum
+    // parallelism for better memory locality.
+    const float oversharding_factor = num_worker_threads <= 4    ? 8.0
+                                      : num_worker_threads <= 8  ? 4.0
+                                      : num_worker_threads <= 16 ? 2.0
+                                      : num_worker_threads <= 32 ? 1.0
+                                      : num_worker_threads <= 64 ? 0.8
+                                                                 : /* num_worker_threads > 64 */ 0.6;
+
+    const bool parallelize_by_sharding_dim_only = sharding_dim_tasks >= oversharding_factor * num_worker_threads;
+
+    // Last by not least, decide whether we want to issue both lhs and rhs
+    // packing in parallel; or issue lhs packing first, and then issue rhs
+    // packing when lhs packing completes (for !shard_by_col lhs and rhs are
+    // swapped). Parallel packing allows more parallelism (for both packing and
+    // kernels), while sequential packing provides better locality (once
+    // a thread finishes rhs packing it proceed to kernels with that rhs).
+    // First, we are interested in parallel packing if there are few tasks.
+    bool parallel_pack = num_threads >= nm * nn;
+    // Also do parallel packing if all data fits into L2$.
+    if (m * bk * Index(sizeof(LhsScalar)) + n * bk * Index(sizeof(RhsScalar)) <= l2CacheSize() * num_threads)
+      parallel_pack = true;
+    // But don't do it if we will use each rhs only once. Locality seems to be
+    // more important in this case.
+    if ((shard_by_col ? nm : nn) == 1) parallel_pack = false;
+    // Also don't get in the way of parallelize_by_sharding_dim_only
+    // optimization.
+    if (parallelize_by_sharding_dim_only) parallel_pack = false;
+
+    internal::tensor_contraction_dispatch(
+        [&](auto lhs_c, auto rhs_c, auto rhs_r) {
+          EIGEN_IF_CONSTEXPR (IsEvalInSyncMode) {
+            EvalParallelContext<NoCallback, lhs_c(), rhs_c(), rhs_r(), Alignment> ctx(
+                this, num_threads, buffer, m, n, k, bm, bn, bk, nm, nn, nk, gm, gn, nm0, nn0, shard_by_col,
+                parallel_pack, parallelize_by_sharding_dim_only, NoCallback());
+            ctx.run();
+          } else {
+            auto* ctx = new EvalParallelContext<DoneCallback, lhs_c(), rhs_c(), rhs_r(), Alignment>(
+                this, num_threads, buffer, m, n, k, bm, bn, bk, nm, nn, nk, gm, gn, nm0, nn0, shard_by_col,
+                parallel_pack, parallelize_by_sharding_dim_only, std::move(done));
+            ctx->run();
+          }
+        },
+        this->m_lhs_inner_dim_contiguous, this->m_rhs_inner_dim_contiguous, this->m_rhs_inner_dim_reordered);
+  }
+
+  // ------------------------------------------------------------------------ //
+
+  // Dummy struct to represent an empty DoneCallback.
+
+  struct NoCallback {
+    void operator()() const { eigen_assert(false && "NoCallback should never be called"); }
+  };
+
+  // ------------------------------------------------------------------------ //
+
+  template <typename DoneCallback, typename Context>
+  class EvalParallelNotification;
+
+  // Synchronous evaluation notification that blocks caller thread in Wait().
+  template <typename Context>
+  class EvalParallelNotification<NoCallback, Context> {
+   public:
+    EvalParallelNotification(Context*, NoCallback) {}
+    void Notify() { done_.Notify(); }
+    void Wait() { done_.Wait(); }
+
+   private:
+    Eigen::Notification done_;
+  };
+
+  // Asynchronous evaluation notification that does not block in Wait().
+  template <typename DoneCallback, typename Context>
+  class EvalParallelNotification {
+   public:
+    EvalParallelNotification(Context* ctx, DoneCallback done) : ctx_(ctx), done_(std::move(done)) {}
+
+    void Notify() {
+      // Make a copy of done callback, because it will be destructed when we
+      // will delete context in the next line (EvalParallelNotification is a
+      // data member of EvalParallelContext class).
+      DoneCallback done_copy = std::move(done_);
+
+      // Delete parallel evaluation context.
+      delete ctx_;
+
+      // Now safely call the done callback.
+      done_copy();
+    }
+
+    void Wait() {}
+
+   private:
+    Context* ctx_;
+    DoneCallback done_;
+  };
+
+  // Context orchestrates sync/async parallel contraction evaluation. When it is
+  // executed in asynchronous mode, it owns all the shared state that might be
+  // accessible by block packing and kernel tasks.
+
+  template <typename DoneCallback, bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous,
+            bool rhs_inner_dim_reordered, int Alignment>
+  class EvalParallelContext {
+   public:
+    using LhsMapper =
+        internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
+                                               contract_t, internal::packet_traits<LhsScalar>::size,
+                                               lhs_inner_dim_contiguous, false, Unaligned>;
+    using RhsMapper =
+        internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
+                                               contract_t, internal::packet_traits<RhsScalar>::size,
+                                               rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Unaligned>;
+
+    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+
+    using TensorContractionKernel =
+        internal::TensorContractionKernel<Scalar, LhsScalar, RhsScalar, Index, OutputMapper, LhsMapper, RhsMapper>;
+
+    using LhsBlock = typename TensorContractionKernel::LhsBlock;
+    using RhsBlock = typename TensorContractionKernel::RhsBlock;
+    using BlockMemHandle = typename TensorContractionKernel::BlockMemHandle;
+
+    EvalParallelContext(const Self* self, int num_threads, Scalar* buffer, Index tm, Index tn, Index tk, Index bm,
+                        Index bn, Index bk, Index nm, Index nn, Index nk, Index gm, Index gn, Index nm0, Index nn0,
+                        bool shard_by_col, bool parallel_pack, bool parallelize_by_sharding_dim_only, DoneCallback done)
+        : created_by_thread_id_(std::this_thread::get_id()),
+          done_(this, std::move(done)),
+          device_(self->m_device),
+          lhs_(self->m_leftImpl, self->m_left_nocontract_strides, self->m_i_strides, self->m_left_contracting_strides,
+               self->m_k_strides),
+          rhs_(self->m_rightImpl, self->m_right_nocontract_strides, self->m_j_strides,
+               self->m_right_contracting_strides, self->m_k_strides),
+          buffer_(buffer),
+          output_(buffer, tm),
+          output_kernel_(self->m_output_kernel),
+          tensor_contraction_params_(self->m_tensor_contraction_params),
+          num_threads_(num_threads),
+          shard_by_col_(shard_by_col),
+          parallel_pack_(parallel_pack),
+          parallelize_by_sharding_dim_only_(parallelize_by_sharding_dim_only),
+          m_(tm),
+          n_(tn),
+          k_(tk),
+          bm_(bm),
+          bn_(bn),
+          bk_(bk),
+          nm_(nm),
+          nn_(nn),
+          nk_(nk),
+          gm_(gm),
+          gn_(gn),
+          nm0_(nm0),
+          nn0_(nn0),
+          kernel_(m_, k_, n_, bm_, bk_, bn_),
+          num_thread_local_allocations_(0),
+          // We reserve 2X more capacity for a thread local values, than the
+          // number of threads in the pool to efficiently handle task stealing
+          // by threads that are not managed by the pool.
+          thread_local_capacity(2 * (parallelize_by_sharding_dim_only_ ? device_.numThreadsInPool() : 0)),
+          // We will use only one of the Lhs/Rhs thread local storage depending
+          // on the shard_by_col value and we parallelize by sharding dim ONLY.
+          lhs_thread_local_blocks_(shard_by_col_ ? 0 : thread_local_capacity, {*this}, {*this}),
+          rhs_thread_local_blocks_(shard_by_col_ ? thread_local_capacity : 0, {*this}, {*this}) {
+      // These two options are mutually exclusive.
+      eigen_assert(!(parallel_pack && parallelize_by_sharding_dim_only));
+
+      for (Index x = 0; x < P; x++) {
+        // Normal number of notifications for k slice switch is
+        // nm_ + nn_ + nm_ * nn_. However, first P - 1 slices will receive only
+        // nm_ + nn_ notifications, because they will not receive notifications
+        // from preceding kernels.
+        state_switch_[x] =
+            x == 0 ? 1 : (parallel_pack_ ? nn_ + nm_ : (shard_by_col_ ? nn_ : nm_)) + (x == P - 1 ? nm_ * nn_ : 0);
+        state_packing_ready_[x] = parallel_pack_ ? 0 : (shard_by_col_ ? nm_ : nn_);
+        state_kernel_[x] = new std::atomic<uint8_t>*[nm_];
+        for (Index m = 0; m < nm_; m++) {
+          state_kernel_[x][m] = new std::atomic<uint8_t>[nn_];
+          // Kernels generally receive 3 notifications (previous kernel + 2
+          // packing), but the first slice won't get notifications from previous
+          // kernels.
+          for (Index n = 0; n < nn_; n++)
+            state_kernel_[x][m][n].store((x == 0 ? 0 : 1) + (parallel_pack_ ? 2 : 1), std::memory_order_relaxed);
+        }
+      }
+
+      // Allocate memory for packed rhs/lhs matrices.
+      packed_mem_ = kernel_.allocateSlices(            //
+          device_,                                     //
+          /*num_lhs=*/nm0_,                            //
+          /*num_rhs=*/nn0_,                            //
+          /*num_slices=*/std::min<Index>(nk_, P - 1),  //
+          packed_lhs_, packed_rhs_);
+
+      if (parallelize_by_sharding_dim_only_) {
+        const int num_worker_threads = device_.numThreadsInPool();
+
+        if (shard_by_col) {
+          can_use_thread_local_packed_ = new std::atomic<bool>[nn_];
+          for (int i = 0; i < nn_; ++i) can_use_thread_local_packed_[i].store(true, std::memory_order_relaxed);
+
+          Index num_blocks = num_worker_threads * gn_;
+          thread_local_pre_allocated_mem_ = kernel_.allocateSlices(  //
+              device_,                                               //
+              /*num_lhs=*/0,                                         //
+              /*num_rhs=*/num_blocks,                                //
+              /*num_slices=*/1,                                      //
+              /*lhs_blocks=*/nullptr, &rhs_thread_local_pre_allocated_);
+
+        } else {
+          can_use_thread_local_packed_ = new std::atomic<bool>[nm_];
+          for (int i = 0; i < nm_; ++i) can_use_thread_local_packed_[i].store(true, std::memory_order_relaxed);
+
+          Index num_blocks = num_worker_threads * gm_;
+          thread_local_pre_allocated_mem_ = kernel_.allocateSlices(  //
+              device_,                                               //
+              /*num_lhs=*/num_blocks,                                //
+              /*num_rhs=*/0,                                         //
+              /*num_slices=*/1, &lhs_thread_local_pre_allocated_,    //
+              /*rhs_blocks=*/nullptr);
+        }
+      }
+    }
+
+    ~EvalParallelContext() {
+      for (Index x = 0; x < P; x++) {
+        for (Index m = 0; m < nm_; m++) delete[] state_kernel_[x][m];
+        delete[] state_kernel_[x];
+      }
+      kernel_.deallocate(device_, packed_mem_);
+      if (parallelize_by_sharding_dim_only_) {
+        kernel_.deallocate(device_, thread_local_pre_allocated_mem_);
+        delete[] can_use_thread_local_packed_;
+      }
+    }
+
+    void run() {
+      // Kick off packing of the first slice.
+      signal_switch(0, 1);
+
+      // Wait for overall completion.
+      //
+      // If parallel evaluation is executed in async mode, this is a no-op, and
+      // Wait() will return immediately. In synchronous mode it will block the
+      // caller thread until it will receive notification from last task.
+      //
+      // In async mode, last task when completed will call done callback from
+      // the same thread, and will delete this context.
+      //
+      // TODO(dvyukov): This wait can lead to deadlock if contraction is
+      // evaluated in synchronous mode. If nthreads contractions are
+      // concurrently submitted from worker threads, this wait will block all
+      // worker threads and the system will deadlock.
+      done_.Wait();
+    }
+
+   private:
+    std::thread::id created_by_thread_id_;
+
+    // This notification is specialized on the type of DoneCallback and can be
+    // blocking or non-blocking.
+    EvalParallelNotification<DoneCallback, EvalParallelContext> done_;
+
+    const Device& device_;
+    LhsMapper lhs_;
+    RhsMapper rhs_;
+    Scalar* const buffer_;
+    OutputMapper output_;
+    OutputKernelType output_kernel_;
+    TensorContractionParams tensor_contraction_params_;
+    const int num_threads_;
+    const bool shard_by_col_;
+    const bool parallel_pack_;
+    const bool parallelize_by_sharding_dim_only_;
+    // Matrix sizes.
+    const Index m_;
+    const Index n_;
+    const Index k_;
+    // Block sizes.
+    const Index bm_;
+    const Index bn_;
+    const Index bk_;
+    // Number of tasks.
+    const Index nm_;
+    const Index nn_;
+    const Index nk_;
+    // Task grain sizes (number of kernels executed per task).
+    const Index gm_;
+    const Index gn_;
+    // Number of blocks (this is different from nm_/nn_ because of task size
+    // coarsening).
+    const Index nm0_;
+    const Index nn0_;
+    // Tensor contraction kernel.
+    TensorContractionKernel kernel_;
+
+    // Parallelization strategy.
+    //
+    // Blocks related to the same k block can run in parallel because they write
+    // to different output blocks. So we parallelize within k slices, this
+    // gives us parallelism level of m x n. Before we can start any kernels
+    // related to k-th slice, we need to issue m lhs packing tasks and n rhs
+    // packing tasks.
+    //
+    // However, there is a bottleneck when we are finishing kernels for k-th
+    // slice (at the very end there is only 1 runnable kernel). To mitigate this
+    // bottleneck we allow kernels from k-th and k+1-th slices to run in
+    // parallel. Note that (m, n, k) and (m, n, k+1) kernels write to the same
+    // output block, so they must not run in parallel.
+    //
+    // This gives us the following dependency graph.
+    // On each k slice we have m x n kernel tasks, m lhs packing tasks and n rhs
+    // packing tasks.
+    // Kernel (m, n, k) can start when:
+    //  - kernel (m, n, k-1) has finished
+    //  - lhs packing (m, k) has finished
+    //  - rhs packing (n, k) has finished
+    // Lhs/rhs packing can start when:
+    //  - all k-1 packing has finished (artificially imposed to limit amount of
+    //  parallel packing)
+    //
+    // On top of that we limit runnable tasks to two consecutive k slices.
+    // This is done to limit amount of memory we need for packed lhs/rhs
+    // (for each k slice we need m*bk + n*bk memory in packed_lhs_/packed_rhs_).
+    //
+    // state_switch_ tracks when we are ready to switch to the next k slice.
+    // state_kernel_[m][n] tracks when we are ready to kick off kernel (m, n).
+    // These variable are rolling over 3 consecutive k slices: first two we are
+    // actively executing + one to track completion of kernels in the second
+    // slice.
+    static constexpr Index P = 3;
+
+    // Handle to the allocated temporary storage for Lhs/Rhs blocks.
+    BlockMemHandle packed_mem_;
+    std::vector<LhsBlock> packed_lhs_[P - 1];
+    std::vector<RhsBlock> packed_rhs_[P - 1];
+
+    // If we choose to parallelize only by the sharding dimension, each thread
+    // will have its own "thread local" (not a C++ thread local storage) memory
+    // for packed_lhs or packed_rhs (shard_by_col = false of true). This memory
+    // can't be passed to a kernel that might execute on a different thread.
+    //
+    // In practice when we are ready to pack memory for the sharding dimension
+    // (rhs if shard_by_col==true) of the K-th slice, all kernels for K-1 slice
+    // already computed (99% of the time), and we can pack data into the thread
+    // local storage, and guarantee that all the kernels will be executed
+    // immediately in the same thread. This significantly increases L1 cache hit
+    // ratio and reduces pressure on the memory bus.
+    //
+    // It's still possible that kernel for the K-th slice will be ready before
+    // completion of the K-1 kernel, so we have to allocate "global" packed_lhs_
+    // and packed_rhs_ to allow kernels to be executed later on a thread
+    // different from the thread that was used for packing.
+
+    // Handle for pre-allocated thread local memory buffers.
+    BlockMemHandle thread_local_pre_allocated_mem_;
+
+    // Only one of these will be initialized depending on shard_by_col value
+    // (the size will be `num_worker_threads * num_grains_in_the_sharding_dim`).
+    std::vector<LhsBlock> lhs_thread_local_pre_allocated_;
+    std::vector<RhsBlock> rhs_thread_local_pre_allocated_;
+
+    // How many thread local blocks were already allocated.
+    std::atomic<int> num_thread_local_allocations_;
+    const int thread_local_capacity;
+
+    // We will use pre-allocated Lhs/Rhs blocks defined above, if the number of
+    // unique threads in a system is below or equal to the number of threads in
+    // a thread pool. We will fallback on dynamic memory allocation after that.
+
+    // ThreadLocalBlocks is a container for Lhs or Rhs thread local buffers. Its
+    // size is equal to the grain size in Lhs/Rhs sharding dimension.
+    template <typename BlockType>
+    class ThreadLocalBlocks {
+     public:
+      ThreadLocalBlocks() = default;
+
+      ThreadLocalBlocks(BlockType* base, size_t grain_size)
+          : is_pre_allocated_(true), thread_local_pre_allocated_base_(base), grain_size_(grain_size) {}
+
+      ThreadLocalBlocks(BlockMemHandle mem_handle, std::vector<BlockType> blocks)
+          : is_pre_allocated_(false), mem_handle_(std::move(mem_handle)), blocks_(std::move(blocks)) {}
+
+      BlockType& block(int grain_index) {
+        eigen_assert(grain_index >= 0);
+        eigen_assert(static_cast<size_t>(grain_index) < size());
+        return is_pre_allocated_ ? thread_local_pre_allocated_base_[grain_index] : blocks_[grain_index];
+      }
+
+      void Release(EvalParallelContext& ctx) const {
+        if (!is_pre_allocated_) {
+          ctx.kernel_.deallocate(ctx.device_, mem_handle_);
+        }
+      }
+
+      size_t size() const { return is_pre_allocated_ ? grain_size_ : blocks_.size(); }
+
+     private:
+      bool is_pre_allocated_;
+
+      // Reuse pre-allocated thread local buffers.
+      BlockType* thread_local_pre_allocated_base_ = nullptr;
+      size_t grain_size_ = 0;
+
+      // These will be initialized only if `is_pre_allocated == false`.
+      BlockMemHandle mem_handle_{};
+      std::vector<BlockType> blocks_;
+    };
+
+    // ThreadLocalBlocksInitialize callable does custom thread local blocks
+    // initialization, and will reuse pre-allocated buffers if possible, or will
+    // dynamically allocate new memory.
+    //
+    // Lhs/Rhs blocks might be of the same type, so we have to pass explicitly
+    // for what side do we plan to do block allocation.
+    template <typename BlockType, bool is_rhs>
+    class ThreadLocalBlocksInitialize {
+      static constexpr bool kIsLhs = !is_rhs && std::is_same<BlockType, LhsBlock>::value;
+      static constexpr bool kIsRhs = is_rhs && std::is_same<BlockType, RhsBlock>::value;
+      static_assert(kIsLhs || kIsRhs, "Unknown block type");
+
+      using Blocks = ThreadLocalBlocks<BlockType>;
+
+     public:
+      ThreadLocalBlocksInitialize(EvalParallelContext& ctx)
+          : ctx_(ctx), num_worker_threads_(ctx_.device_.numThreadsInPool()) {}
+
+      void operator()(Blocks& blocks) {
+        const int n = ctx_.num_thread_local_allocations_.fetch_add(1, std::memory_order_relaxed);
+
+        if (n >= num_worker_threads_) {
+          ThreadLocalBlocksAllocator<is_rhs>::allocate(ctx_, blocks);
+        } else {
+          ThreadLocalBlocksAllocator<is_rhs>::reuse(ctx_, n, blocks);
+        }
+      }
+
+     private:
+      // Explicit specializations are not allowed at class scope, so EvalCtx is
+      // a dummy template parameter to make these partial specializations.
+      template <bool pack_rhs, typename EvalCtx = EvalParallelContext>
+      struct ThreadLocalBlocksAllocator;
+
+      template <typename EvalCtx>
+      struct ThreadLocalBlocksAllocator</*pack_rhs=*/true, EvalCtx> {
+        static void allocate(EvalCtx& ctx, Blocks& blocks) {
+          std::vector<RhsBlock> rhs_blocks;
+          BlockMemHandle mem_handle = ctx.kernel_.allocateSlices(ctx.device_,
+                                                                 /*num_lhs=*/0,
+                                                                 /*num_rhs=*/ctx.gn_,
+                                                                 /*num_slices=*/1,
+                                                                 /*lhs_blocks=*/nullptr, /*rhs_blocks=*/&rhs_blocks);
+          blocks = ThreadLocalBlocks<RhsBlock>(std::move(mem_handle), std::move(rhs_blocks));
+        }
+
+        static void reuse(EvalCtx& ctx, int index, Blocks& blocks) {
+          RhsBlock* ptr = &ctx.rhs_thread_local_pre_allocated_[ctx.gn_ * index];
+          blocks = ThreadLocalBlocks<RhsBlock>(ptr, ctx.gn_);
+        }
+      };
+
+      template <typename EvalCtx>
+      struct ThreadLocalBlocksAllocator</*pack_rhs=*/false, EvalCtx> {
+        static void allocate(EvalCtx& ctx, Blocks& blocks) {
+          std::vector<LhsBlock> lhs_blocks;
+          BlockMemHandle mem_handle = ctx.kernel_.allocateSlices(ctx.device_,
+                                                                 /*num_lhs=*/ctx.gm_,
+                                                                 /*num_rhs=*/0,
+                                                                 /*num_slices=*/1,
+                                                                 /*lhs_blocks=*/&lhs_blocks, /*rhs_blocks=*/nullptr);
+          blocks = ThreadLocalBlocks<LhsBlock>(std::move(mem_handle), std::move(lhs_blocks));
+        }
+
+        static void reuse(EvalCtx& ctx, int index, Blocks& blocks) {
+          LhsBlock* ptr = &ctx.lhs_thread_local_pre_allocated_[ctx.gm_ * index];
+          blocks = ThreadLocalBlocks<LhsBlock>(ptr, ctx.gm_);
+        }
+      };
+
+      EvalParallelContext& ctx_;
+      const int num_worker_threads_;
+    };
+
+    template <typename BlockType>
+    class ThreadLocalBlocksRelease {
+     public:
+      using Blocks = ThreadLocalBlocks<BlockType>;
+      ThreadLocalBlocksRelease(EvalParallelContext& ctx) : ctx_(ctx) {}
+      void operator()(Blocks& blocks) { blocks.Release(ctx_); }
+
+     private:
+      EvalParallelContext& ctx_;
+    };
+
+    // ThreadLocalBlocks initialization callables.
+    using ThreadLocalLhsInit = ThreadLocalBlocksInitialize<LhsBlock, /*is_rhs=*/false>;
+    using ThreadLocalRhsInit = ThreadLocalBlocksInitialize<RhsBlock, /*is_rhs=*/true>;
+
+    // ThreadLocalBlocks release callables.
+    using ThreadLocalLhsRelease = ThreadLocalBlocksRelease<LhsBlock>;
+    using ThreadLocalRhsRelease = ThreadLocalBlocksRelease<RhsBlock>;
+
+    // Thread local containers for Lhs/Rhs block packs. In practice only one of
+    // them will be used, depending on the shard_by_col value.
+    Eigen::ThreadLocal<ThreadLocalBlocks<LhsBlock>, ThreadLocalLhsInit, ThreadLocalLhsRelease> lhs_thread_local_blocks_;
+    Eigen::ThreadLocal<ThreadLocalBlocks<RhsBlock>, ThreadLocalRhsInit, ThreadLocalRhsRelease> rhs_thread_local_blocks_;
+
+    // After a particular shard for Kth slice missed thread local execution
+    // opportunity (K-1 slice didn't complete kernels execution), we can no
+    // longer schedule K+1 and following slices in thread local mode, because
+    // there is no more guarantee that previous kernels were executed
+    // sequentially in the same thread (size is nn_ or nm_).
+    std::atomic<bool>* can_use_thread_local_packed_;
+
+    std::atomic<uint8_t>** state_kernel_[P];
+    // state_switch_ is frequently modified by worker threads, while other
+    // fields are read-only after constructor. Let's move it to a separate cache
+    // line to reduce cache-coherency traffic.
+    char pad_[128];
+    std::atomic<Index> state_packing_ready_[P];
+    std::atomic<Index> state_switch_[P];
+
+    LhsBlock& packed_lhs(Index m, Index k, Index m1, bool use_thread_local) {
+      if (use_thread_local) {
+        eigen_assert(!shard_by_col_);
+        ThreadLocalBlocks<LhsBlock>& blocks = lhs_thread_local_blocks_.local();
+
+        Index grain_index = m1 - m * gm_;
+        return blocks.block(
+            internal::convert_index<int>(grain_index));  // FIXME: Consider making ThreadLocalBlocks use Eigen::Index.
+      } else {
+        return packed_lhs_[k % (P - 1)][m1];
+      }
+    }
+
+    RhsBlock& packed_rhs(Index n, Index k, Index n1, bool use_thread_local) {
+      if (use_thread_local) {
+        eigen_assert(shard_by_col_);
+        ThreadLocalBlocks<RhsBlock>& blocks = rhs_thread_local_blocks_.local();
+
+        Index grain_index = n1 - n * gn_;
+        return blocks.block(
+            internal::convert_index<int>(grain_index));  // FIXME: Consider making ThreadLocalBlocks use Eigen::Index.
+      } else {
+        return packed_rhs_[k % (P - 1)][n1];
+      }
+    }
+
+    // In following two methods (pack_lhs and pack_rhs), if we know for sure
+    // that we'll be able to immediately call a kernel with packed data, and do
+    // not submit it to the thread pool, we can use thread local memory for
+    // packed data.
+    //
+    // We can only reliably check it if we are running all kernels in sync mode
+    // (parallelize only by sharding dim). If kernel for m==0 (n==0) is ready to
+    // run, it's guaranteed that all kernels with larger values of m (n) are
+    // also ready, because we execute them in the same order for all K slices.
+
+    void pack_lhs(Index m, Index k) {
+      bool use_thread_local = false;
+
+      if (parallelize_by_sharding_dim_only_ && !shard_by_col_ &&
+          can_use_thread_local_packed_[m].load(std::memory_order_relaxed)) {
+        if (state_kernel_[k % P][m][0].load(std::memory_order_relaxed) == 1) {
+          use_thread_local = true;
+        } else {
+          // If we can't guarantee that all kernels in `k` slice will be
+          // executed sequentially in current thread, it's no longer safe to use
+          // thread local memory in following slices along the k dimensions.
+          eigen_assert(k > 0);
+          can_use_thread_local_packed_[m].store(false, std::memory_order_relaxed);
+        }
+      }
+
+      const Index mend = m * gm_ + gm(m);
+      for (Index m1 = m * gm_; m1 < mend; m1++)
+        kernel_.packLhs(&packed_lhs(m, k, m1, use_thread_local), lhs_.getSubMapper(m1 * bm_, k * bk_), bk(k), bm(m1));
+
+      if (!parallel_pack_ && shard_by_col_) {
+        eigen_assert(!use_thread_local);
+        signal_packing(k);
+      } else {
+        signal_switch(k + 1);
+        for (Index n = nn_ - 1; n >= 0; n--) {
+          bool sync = parallelize_by_sharding_dim_only_ || n == 0;
+          signal_kernel(m, n, k, sync, use_thread_local);
+        }
+      }
+    }
+
+    void pack_rhs(Index n, Index k) {
+      bool use_thread_local = false;
+
+      if (parallelize_by_sharding_dim_only_ && shard_by_col_ &&
+          can_use_thread_local_packed_[n].load(std::memory_order_relaxed)) {
+        if (state_kernel_[k % P][0][n].load(std::memory_order_relaxed) == 1) {
+          use_thread_local = true;
+        } else {
+          // If we can't guarantee that all kernels in `k` slice will be
+          // executed sequentially in current thread, it's no longer safe to use
+          // thread local memory in following slices along the k dimensions.
+          eigen_assert(k > 0);
+          can_use_thread_local_packed_[n].store(false, std::memory_order_relaxed);
+        }
+      }
+
+      const Index nend = n * gn_ + gn(n);
+      for (Index n1 = n * gn_; n1 < nend; n1++) {
+        EIGEN_IF_CONSTEXPR (!TensorContractionKernel::HasBeta) {
+          if (k == 0) {
+            // Zero the output memory in parallel, only if contraction kernel does
+            // not support `beta`. Otherwise we will pass beta 0.0 to the first
+            // call to the `TensorContractionKernel::invoke()`.
+            //
+            // On 10000x2x10000 mm zeroing can easily take half of time. Zero (bn
+            // x m) row. Safe to do here because all kernels that will write to
+            // this memory depend on completion of this task. Note: don't call
+            // device_.fill() here. device_.fill() blocks on thread pool
+            // worker thread, which can lead to underutilization and deadlocks.
+            std::fill_n(buffer_ + n1 * bn_ * m_, bn(n1) * m_, Scalar(0));
+          }
+        }
+        kernel_.packRhs(&packed_rhs(n, k, n1, use_thread_local), rhs_.getSubMapper(k * bk_, n1 * bn_), bk(k), bn(n1));
+      }
+
+      if (parallel_pack_ || shard_by_col_) {
+        signal_switch(k + 1);
+        for (Index m = nm_ - 1; m >= 0; m--) {
+          bool sync = parallelize_by_sharding_dim_only_ || m == 0;
+          signal_kernel(m, n, k, sync, use_thread_local);
+        }
+      } else {
+        eigen_assert(!use_thread_local);
+        signal_packing(k);
+      }
+    }
+
+    void kernel(Index m, Index n, Index k, bool use_thread_local) {
+      // Note: order of iteration matters here. Iteration over m is innermost
+      // because we want to reuse the same packed rhs in consecutive tasks
+      // (rhs fits into L2$ while lhs only into L3$).
+      const Index nend = n * gn_ + gn(n);
+      const Index mend = m * gm_ + gm(m);
+
+      // NOTE: output = alpha * LHS * RHS + beta * output.
+      const Scalar alpha = Scalar(1);
+      const Scalar beta = (TensorContractionKernel::HasBeta && k == 0) ? Scalar(0) : Scalar(1);
+
+      if (shard_by_col_) {
+        for (Index n1 = n * gn_; n1 < nend; n1++) {
+          for (Index m1 = m * gm_; m1 < mend; m1++) {
+            const auto output_mapper = output_.getSubMapper(m1 * bm_, n1 * bn_);
+            kernel_.invoke(output_mapper, packed_lhs(m, k, m1, !shard_by_col_ && use_thread_local),
+                           packed_rhs(n, k, n1, shard_by_col_ && use_thread_local), bm(m1), bk(k), bn(n1), alpha, beta);
+
+            // We are done with the last task for the [m1, n1] block.
+            if (k + 1 == nk_) {
+              output_kernel_(output_mapper, tensor_contraction_params_, m1 * bm_, n1 * bn_, bm(m1), bn(n1));
+            }
+          }
+        }
+      } else {
+        for (Index m1 = m * gm_; m1 < mend; m1++)
+          for (Index n1 = n * gn_; n1 < nend; n1++) {
+            const auto output_mapper = output_.getSubMapper(m1 * bm_, n1 * bn_);
+            kernel_.invoke(output_mapper, packed_lhs(m, k, m1, !shard_by_col_ && use_thread_local),
+                           packed_rhs(n, k, n1, shard_by_col_ && use_thread_local), bm(m1), bk(k), bn(n1), alpha, beta);
+
+            // We are done with the last task for the [m1, n1] block.
+            if (k + 1 == nk_) {
+              output_kernel_(output_mapper, tensor_contraction_params_, m1 * bm_, n1 * bn_, bm(m1), bn(n1));
+            }
+          }
+      }
+      signal_kernel(m, n, k + 1, /*sync=*/false, /*use_thread_local=*/false);
+      signal_switch(k + 2);
+    }
+
+    void signal_packing(Index k) {
+      eigen_assert(!parallel_pack_);
+      Index s = state_packing_ready_[k % P].fetch_sub(1);
+      eigen_assert(s > 0);
+      if (s != 1) return;
+      state_packing_ready_[k % P] = shard_by_col_ ? nm_ : nn_;
+      enqueue_packing(k, shard_by_col_);
+    }
+
+    void signal_kernel(Index m, Index n, Index k, bool sync, bool use_thread_local) {
+      std::atomic<uint8_t>* state = &state_kernel_[k % P][m][n];
+      Index s = state->load();
+      eigen_assert(s > 0);
+      if (s != 1 && state->fetch_sub(1) != 1) {
+        eigen_assert(!use_thread_local);
+        return;
+      }
+      state->store(parallel_pack_ ? 3 : 2, std::memory_order_relaxed);
+      if (sync) {
+        kernel(m, n, k, use_thread_local);
+      } else {
+        eigen_assert(!use_thread_local);
+        device_.enqueue([this, m, n, k, use_thread_local]() { kernel(m, n, k, use_thread_local); });
+      }
+    }
+
+    void signal_switch(Index k, Index v = 1) {
+      Index s = state_switch_[k % P].fetch_sub(v);
+      eigen_assert(s >= v);
+      if (s != v) return;
+
+      // Ready to switch to the next k slice.
+      // Reset counter for the next iteration.
+      state_switch_[k % P] = (parallel_pack_ ? nm_ + nn_ : (shard_by_col_ ? nn_ : nm_)) + nm_ * nn_;
+      if (k < nk_) {
+        // Issue lhs/rhs packing. Their completion will in turn kick off
+        // kernels.
+        if (parallel_pack_) {
+          enqueue_packing(k, !shard_by_col_);
+          enqueue_packing(k, shard_by_col_);
+        } else if (shard_by_col_) {
+          enqueue_packing(k, false);
+        } else {
+          enqueue_packing(k, true);
+        }
+
+        // Termination handling.
+        // Because kernel completion signals k + 2 switch, we need to finish nk
+        // + 2 slices without issuing any tasks on nk + 1 slice. So here we
+        // pretend that all nk + 1 packing tasks just finish instantly; so that
+        // nk + 2 switch only waits for completion of nk kernels.
+      } else if (k == nk_) {
+        signal_switch(k + 1, parallel_pack_ ? nm_ + nn_ : (shard_by_col_ ? nn_ : nm_));
+      } else {
+        done_.Notify();
+      }
+    }
+
+    // Enqueue all rhs/lhs packing for k-th slice.
+    void enqueue_packing(Index k, bool rhs) { enqueue_packing_helper(0, rhs ? nn_ : nm_, k, rhs); }
+
+    void enqueue_packing_helper(Index start, Index end, Index k, bool rhs) {
+      if (end - start == 1) {
+        if (rhs)
+          pack_rhs(start, k);
+        else
+          pack_lhs(start, k);
+      } else {
+        while (end - start > 1) {
+          Index mid = (start + end) / 2;
+          device_.enqueue([this, mid, end, k, rhs]() { enqueue_packing_helper(mid, end, k, rhs); });
+          end = mid;
+        }
+
+        // Decide if we want to run first packing task (start == 0) in
+        // async mode if we parallelize only by sharding dim:
+        // (1) pack_lhs and pack_rhs call signal_switch before completing
+        //     all calls to signal_kernel, which in sync mode might lead
+        //     to the execution of the first kernel of the k+1 slice, before
+        //     completing a call to the last kernel of the k slice.
+        // (2) all pack tasks for sharded dim must be executed in a thread
+        //     pool to get pre-allocated thread local buffers.
+        bool pack_async = (start == 0) && (parallelize_by_sharding_dim_only_ && shard_by_col_ == rhs) &&
+                          (k > 0 || std::this_thread::get_id() == created_by_thread_id_);
+
+        if (pack_async) {
+          device_.enqueue([this, start, end, k, rhs]() { enqueue_packing_helper(start, end, k, rhs); });
+        } else {
+          enqueue_packing_helper(start, end, k, rhs);
+        }
+      }
+    }
+
+    // Block sizes with accounting for potentially incomplete last block.
+    Index bm(Index m) const { return m + 1 < nm0_ ? bm_ : m_ + bm_ - bm_ * nm0_; }
+    Index bn(Index n) const { return n + 1 < nn0_ ? bn_ : n_ + bn_ - bn_ * nn0_; }
+    Index bk(Index k) const { return k + 1 < nk_ ? bk_ : k_ + bk_ - bk_ * nk_; }
+    // Task grain sizes accounting for potentially incomplete last task.
+    Index gm(Index m) const { return m + 1 < nm_ ? gm_ : nm0_ + gm_ - gm_ * nm_; }
+    Index gn(Index n) const { return n + 1 < nn_ ? gn_ : nn0_ + gn_ - gn_ * nn_; }
+
+    EvalParallelContext(const EvalParallelContext&) = delete;
+    void operator=(const EvalParallelContext&) = delete;
+  };
+
+  // ------------------------------------------------------------------------ //
+
+  // EvalShardedByInnerDimContext orchestrates sync/async contraction
+  // evaluation, when we shard by inner dimension. When it is executed in
+  // asynchronous mode, it owns all the shared state that might be accessible by
+  // block processing tasks.
+
+  template <typename DoneCallback>
+  struct EvalShardedByInnerDimContext {
+    EvalShardedByInnerDimContext(const Self* self, int num_threads, Scalar* result_buffer, Index m_size, Index n_size,
+                                 Index k_size, DoneCallback done_callback)
+        : evaluator(self),
+          m_lhs_inner_dim_contiguous(evaluator->m_lhs_inner_dim_contiguous),
+          m_rhs_inner_dim_contiguous(evaluator->m_rhs_inner_dim_contiguous),
+          m_rhs_inner_dim_reordered(evaluator->m_rhs_inner_dim_reordered),
+          result(result_buffer),
+          m(m_size),
+          n(n_size),
+          k(k_size),
+          done(std::move(done_callback)),
+          buffer_size_bytes(m * n * sizeof(Scalar)),
+          block_size(blockSize(k, num_threads)),
+          num_blocks(numext::div_ceil<Index>(k, block_size)),
+          num_pending_blocks(internal::convert_index<int>(num_blocks)),
+          l0_ranges(numext::div_ceil<Index>(num_blocks, l0_size)),
+          l0_state(l0_ranges),
+          block_buffers(num_blocks) {
+      // Keep count of pending gemm tasks for each l0 range.
+      for (int i = 0; i < l0_ranges; ++i) {
+        const Index num_pending_tasks = actualRangeSize(l0_ranges, l0_size, i);
+        l0_state.emplace_back(internal::convert_index<int>(num_pending_tasks));
+      }
+
+      // Allocate temporary buffers for each block.
+      for (Index block_idx = 0; block_idx < num_blocks; ++block_idx) {
+        Scalar* buf = block_idx == 0 ? result : static_cast<Scalar*>(evaluator->m_device.allocate(buffer_size_bytes));
+        block_buffers.emplace_back(buf);
+      }
+    }
+
+    ~EvalShardedByInnerDimContext() {
+      for (Index i = 1; i < num_blocks; ++i) {
+        evaluator->m_device.deallocate(block_buffers[i]);
+      }
+    }
+
+    template <int Alignment>
+    void run() {
+      Barrier barrier(internal::convert_index<int>(num_blocks));
+      eval<Alignment>(barrier, 0, num_blocks);
+      barrier.Wait();
+
+      // Aggregate partial sums from l0 ranges.
+      aggregateL0Blocks<Alignment>();
+
+      // Apply output kernel.
+      applyOutputKernel();
+    }
+
+    template <int Alignment>
+    void runAsync() {
+      evalAsync<Alignment>(0, num_blocks);
+    }
+
+   private:
+    // The underlying GEMM kernel assumes that k is a multiple of
+    // the packet size and subtle breakage occurs if this is violated.
+    static constexpr Index packet_size = internal::packet_traits<RhsScalar>::size;
+
+    const Self* evaluator;  // TensorContraction evaluator
+
+    // These fields cache values from the evaluator for use in processBlock dispatch.
+    bool m_lhs_inner_dim_contiguous;
+    bool m_rhs_inner_dim_contiguous;
+    bool m_rhs_inner_dim_reordered;
+
+    Scalar* result;
+
+    Index m;
+    Index n;
+    Index k;
+
+    DoneCallback done;
+
+    // ----------------------------------------------------------------------//
+    // Algorithm parameters.
+
+    // We will compute partial results into the buffers of this size.
+    Index buffer_size_bytes;
+
+    Index block_size;
+    Index num_blocks;
+
+    // Keep track of pending tasks when evaluate in async mode.
+    std::atomic<int> num_pending_blocks;
+
+    // We compute partial gemm results in parallel, and to get the final result
+    // we need to add them all together. For the large number of threads (>= 48)
+    // this adds a very expensive sequential step at the end.
+    //
+    // We split the [0, num_blocks) into small ranges, and when a task for the
+    // block finishes its partial gemm computation, it checks if it was the last
+    // gemm in the range, and if so, it will add all blocks of the range.
+    //
+    // After all tasks done, we need to add only these pre-aggregated blocks.
+
+    // For now we use just a single level of ranges to compute pre-aggregated
+    // partial sums, but in general we can use more layers to compute tree
+    // aggregation in parallel and reduce the size of the sequential step.
+    //
+    // TODO(ezhulenev): Add multilevel tree aggregation? Probably will make
+    // sense only if number of threads >= ~128?
+    static constexpr Index l0_size = 4;
+    Index l0_ranges;
+
+    // Keep count of pending gemm tasks for each l0 range.
+    MaxSizeVector<std::atomic<int>> l0_state;  // [0, l0_ranges)
+
+    // Buffers allocated for each temporary block computation.
+    MaxSizeVector<Scalar*> block_buffers;  // [0, num_blocks)
+
+    template <int Alignment>
+    void processBlock(Index block_idx, Index begin, Index end) {
+      Scalar* buf = block_buffers[block_idx];
+
+      internal::tensor_contraction_dispatch(
+          [&](auto lhs_c, auto rhs_c, auto rhs_r) {
+            evaluator->template evalGemmPartialWithoutOutputKernel<lhs_c(), rhs_c(), rhs_r(), Alignment>(
+                buf, begin, end, /*num_threads=*/internal::convert_index<int>(num_blocks));
+          },
+          m_lhs_inner_dim_contiguous, m_rhs_inner_dim_contiguous, m_rhs_inner_dim_reordered);
+
+      // Check if it was the last task in l0 range.
+      const Index l0_index = block_idx / l0_size;
+      const int v = l0_state[l0_index].fetch_sub(1);
+      eigen_assert(v >= 1);
+
+      // If we processed the last block of the range, we can aggregate all
+      // partial results into the first block of the range.
+      if (v == 1) {
+        const Index rng_size = actualRangeSize(l0_ranges, l0_size, l0_index);
+        const Index dst_block_idx = l0_index * l0_size;
+
+        if (rng_size == l0_size) {
+          addAllToBuffer<Alignment>(m * n,
+                                    /*src_buf0=*/block_buffers[dst_block_idx + 1],
+                                    /*src_buf1=*/block_buffers[dst_block_idx + 2],
+                                    /*src_buf2=*/block_buffers[dst_block_idx + 3],
+                                    /*dst_buf= */ block_buffers[dst_block_idx]);
+        } else {
+          // Aggregate blocks of potentially incomplete last range.
+          for (int i = 1; i < rng_size; ++i) {
+            addToBuffer<Alignment>(m * n,
+                                   /*src_buf=*/block_buffers[dst_block_idx + i],
+                                   /*dst_buf=*/block_buffers[dst_block_idx]);
+          }
+        }
+      }
+    }
+
+    // Aggregate partial sums from l0 ranges.
+    template <int Alignment>
+    void aggregateL0Blocks() const {
+      Index l0_index = 1;
+
+      for (; l0_index + 2 < l0_ranges; l0_index += 3) {
+        addAllToBuffer<Alignment>(m * n,
+                                  /*src_buf0=*/block_buffers[(l0_index + 0) * l0_size],
+                                  /*src_buf1=*/block_buffers[(l0_index + 1) * l0_size],
+                                  /*src_buf2=*/block_buffers[(l0_index + 2) * l0_size],
+                                  /*dst_buf= */ block_buffers[0]);
+      }
+
+      for (; l0_index < l0_ranges; ++l0_index) {
+        addToBuffer<Alignment>(m * n, block_buffers[l0_index * l0_size], block_buffers[0]);
+      }
+    }
+
+    void applyOutputKernel() const {
+      using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
+      evaluator->m_output_kernel(OutputMapper(result, m), evaluator->m_tensor_contraction_params,
+                                 static_cast<Eigen::Index>(0), static_cast<Eigen::Index>(0), m, n);
+    }
+
+    // Compute block size with accounting for potentially incomplete last block.
+    Index actualBlockSize(Index block_idx) const {
+      return block_idx + 1 < num_blocks ? block_size : k + block_size - block_size * num_blocks;
+    }
+
+    // Compute range size with accounting for potentially incomplete last range.
+    Index actualRangeSize(Index num_ranges, Index range_size, Index range_idx) const {
+      eigen_assert(range_idx < num_ranges);
+      return range_idx + 1 < num_ranges ? range_size : num_blocks + range_size - range_size * num_ranges;
+    }
+
+    template <int Alignment>
+    EIGEN_STRONG_INLINE static void addToBuffer(size_t n, const Scalar* src_buf, Scalar* tgt_buf) {
+      const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
+      size_t i = 0;
+      const size_t num_packets = n / output_packet_size;
+      for (; i < output_packet_size * num_packets; i += output_packet_size) {
+        const PacketReturnType src_val = internal::pload<PacketReturnType>(src_buf + i);
+        const PacketReturnType tgt_val = internal::ploadt<PacketReturnType, Alignment>(tgt_buf + i);
+        const PacketReturnType sum = internal::padd(src_val, tgt_val);
+        internal::pstoret<Scalar, PacketReturnType, Alignment>(tgt_buf + i, sum);
+      }
+      for (; i < n; ++i) {
+        tgt_buf[i] += src_buf[i];
+      }
+    }
+
+    template <int Alignment>
+    EIGEN_STRONG_INLINE static void addAllToBuffer(size_t n, const Scalar* src_buf0, const Scalar* src_buf1,
+                                                   const Scalar* src_buf2, Scalar* dst_buf) {
+      using ::Eigen::internal::padd;
+      using ::Eigen::internal::pload;
+      using ::Eigen::internal::ploadt;
+      using ::Eigen::internal::pstoret;
+
+      const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
+
+      size_t i = 0;
+      const size_t num_packets = n / output_packet_size;
+      for (; i < output_packet_size * num_packets; i += output_packet_size) {
+        const auto src_val0 = pload<PacketReturnType>(src_buf0 + i);
+        const auto src_val1 = pload<PacketReturnType>(src_buf1 + i);
+        const auto src_val2 = pload<PacketReturnType>(src_buf2 + i);
+
+        const auto dst_val = ploadt<PacketReturnType, Alignment>(dst_buf + i);
+        const auto sum = padd(padd(dst_val, src_val0), padd(src_val1, src_val2));
+
+        pstoret<Scalar, PacketReturnType, Alignment>(dst_buf + i, sum);
+      }
+      for (; i < n; ++i) {
+        dst_buf[i] += src_buf0[i] + src_buf1[i] + src_buf2[i];
+      }
+    }
+
+    template <int Alignment>
+    void eval(Barrier& barrier, Index start_block_idx, Index end_block_idx) {
+      while (end_block_idx - start_block_idx > 1) {
+        Index mid_block_idx = (start_block_idx + end_block_idx) / 2;
+        evaluator->m_device.enqueue([this, &barrier, mid_block_idx, end_block_idx]() {
+          eval<Alignment>(barrier, mid_block_idx, end_block_idx);
+        });
+        end_block_idx = mid_block_idx;
+      }
+
+      Index block_idx = start_block_idx;
+      Index block_start = block_idx * block_size;
+      Index block_end = block_start + actualBlockSize(block_idx);
+
+      processBlock<Alignment>(block_idx, block_start, block_end);
+      barrier.Notify();
+    }
+
+    template <int Alignment>
+    void evalAsync(Index start_block_idx, Index end_block_idx) {
+      while (end_block_idx - start_block_idx > 1) {
+        Index mid_block_idx = (start_block_idx + end_block_idx) / 2;
+        evaluator->m_device.enqueue(
+            [this, mid_block_idx, end_block_idx]() { evalAsync<Alignment>(mid_block_idx, end_block_idx); });
+        end_block_idx = mid_block_idx;
+      }
+
+      Index block_idx = start_block_idx;
+
+      Index block_start = block_idx * block_size;
+      Index block_end = block_start + actualBlockSize(block_idx);
+
+      processBlock<Alignment>(block_idx, block_start, block_end);
+
+      int v = num_pending_blocks.fetch_sub(1);
+      eigen_assert(v >= 1);
+
+      if (v == 1) {
+        // Aggregate partial sums from l0 ranges.
+        aggregateL0Blocks<Alignment>();
+
+        // Apply output kernel.
+        applyOutputKernel();
+
+        // NOTE: If we call `done` callback before deleting this (context),
+        // it might deallocate Self* pointer captured by context, and we'll
+        // fail in destructor trying to deallocate temporary buffers.
+
+        // Move done call back from context before it will be destructed.
+        DoneCallback done_copy = std::move(done);
+
+        // We are confident that we are the last one who touches context.
+        delete this;
+
+        // Now safely call the done callback.
+        done_copy();
+      }
+    }
+
+    // Cost model doesn't capture well the cost associated with constructing
+    // tensor contraction mappers and computing loop bounds in gemm_pack_lhs
+    // and gemm_pack_rhs, so we specify minimum desired block size.
+    static Index blockSize(Index k, int num_threads) {
+      const auto round_up = [=](Index index) -> Index {
+        const Index kmultiple = packet_size <= 8 ? 8 : packet_size;
+        return numext::div_ceil<Index>(index, kmultiple) * kmultiple;
+      };
+
+      const Index target_block_size = round_up(numext::div_ceil<Index>(k, num_threads));
+      const Index desired_min_block_size = 12 * packet_size;
+
+      return numext::mini<Index>(k, numext::maxi<Index>(desired_min_block_size, target_block_size));
+    }
+
+    EvalShardedByInnerDimContext(const EvalShardedByInnerDimContext&) = delete;
+    void operator=(const EvalShardedByInnerDimContext&) = delete;
+  };
+
+  // ------------------------------------------------------------------------ //
+
+  // Below are the function used by evalProductImpl heuristics, trying to select
+  // optimal parameters for parallelization algorithm.
+
+  // Decide whether we want to shard m x n contraction by columns or by rows.
+  static bool shardByCol(Index m, Index n, Index num_threads) {
+    // Note: we are comparing both n and m against Traits::nr, it is not
+    // a mistake. We are trying to figure out how both n and m will fit into
+    // the main sharding dimension.
+
+    // Sharding by column is the default
+    // ... unless there is enough data for vectorization over rows
+    if (m / num_threads >= Traits::nr &&
+        // and not enough data for vectorization over columns
+        (n / num_threads < Traits::nr ||
+         // ... or barely enough data for vectorization over columns,
+         // but it is not evenly dividable across threads
+         (n / num_threads < 4 * Traits::nr && (n % (num_threads * Traits::nr)) != 0 &&
+          // ... and it is evenly dividable across threads for rows
+          ((m % (num_threads * Traits::nr)) == 0 ||
+           // .. or it is not evenly dividable for both dimensions but
+           // there is much more data over rows so that corner effects are
+           // mitigated.
+           (m / n >= 6)))))
+      return false;
+    // Wait, or if matrices are just substantially prolonged over the other
+    // dimension.
+    if (n / num_threads < 16 * Traits::nr && m > n * 32) return false;
+    return true;
+  }
+
+  Index coarsenM(Index m, Index n, Index bm, Index bn, Index bk, Index gn, int num_threads, bool shard_by_col) const {
+    Index gm = 1;
+    Index gm1 = 1;
+    Index nm0 = numext::div_ceil(m, bm);
+    Index nm1 = nm0;
+    for (;;) {
+      // Find the next candidate for m grain size. It needs to result in
+      // different number of blocks. E.g. if we have 10 kernels, we want to try
+      // 5 and 10, but not 6, 7, 8 and 9.
+      while (gm1 <= nm0 && nm1 == numext::div_ceil(nm0, gm1)) gm1++;
+      if (gm1 > nm0) break;
+      // Check the candidate.
+      int res = checkGrain(m, n, bm, bn, bk, gm1, gn, gm, gn, num_threads, shard_by_col);
+      if (res < 0) break;
+      nm1 = numext::div_ceil(nm0, gm1);
+      if (res == 0) continue;
+      // Commit new grain size.
+      gm = gm1;
+    }
+    return gm;
+  }
+
+  Index coarsenN(Index m, Index n, Index bm, Index bn, Index bk, Index gm, int num_threads, bool shard_by_col) const {
+    Index gn = 1;
+    Index gn1 = 1;
+    Index nn0 = numext::div_ceil(n, bn);
+    Index nn1 = nn0;
+    for (;;) {
+      while (gn1 <= nn0 && nn1 == numext::div_ceil(nn0, gn1)) gn1++;
+      if (gn1 > nn0) break;
+      int res = checkGrain(m, n, bm, bn, bk, gm, gn1, gm, gn, num_threads, shard_by_col);
+      if (res < 0) break;
+      nn1 = numext::div_ceil(nn0, gn1);
+      if (res == 0) continue;
+      gn = gn1;
+    }
+    return gn;
+  }
+
+  // checkGrain checks whether grain (gm, gn) is suitable and is better than
+  // (oldgm, oldgn).
+  int checkGrain(Index m, Index n, Index bm, Index bn, Index bk, Index gm, Index gn, Index oldgm, Index oldgn,
+                 int num_threads, bool shard_by_col) const {
+    const TensorOpCost cost = contractionCost(bm * gm, bn * gn, bm, bn, bk, shard_by_col, true);
+    double taskSize = TensorCostModel<ThreadPoolDevice>::taskSize(static_cast<double>(bm) * gm * bn * gn, cost);
+    // If the task is too small, then we agree on it regardless of anything
+    // else. Otherwise synchronization overheads will dominate.
+    if (taskSize < 1) return 1;
+    // If it is too large, then we reject it and all larger tasks.
+    if (taskSize > 2) return -1;
+    // Now we are in presumably good task size range.
+    // The main deciding factor here is parallelism. Consider that we have 12
+    // kernels and 4 threads. Grains of 2, 3 and 4 all yield good task sizes.
+    // But 2/4 yield 6/3 tasks, which gives us parallelism of 0.75 (at most 3/4
+    // of cores will be busy). While grain size 3 gives us 4 tasks, which gives
+    // us parallelism of 1 (we can load all cores).
+    Index nm0 = numext::div_ceil(m, bm);
+    Index nn0 = numext::div_ceil(n, bn);
+    Index new_tasks = numext::div_ceil(nm0, gm) * numext::div_ceil(nn0, gn);
+    double new_parallelism =
+        static_cast<double>(new_tasks) / (numext::div_ceil<Index>(new_tasks, num_threads) * num_threads);
+    Index old_tasks = numext::div_ceil(nm0, oldgm) * numext::div_ceil(nn0, oldgn);
+    double old_parallelism =
+        static_cast<double>(old_tasks) / (numext::div_ceil<Index>(old_tasks, num_threads) * num_threads);
+    if (new_parallelism > old_parallelism || new_parallelism == 1) return 1;
+    return 0;
+  }
+
+  TensorOpCost contractionCost(Index m, Index n, Index bm, Index bn, Index bk, bool shard_by_col,
+                               bool prepacked) const {
+    const int packed_size = std::min<int>(PacketType<LhsScalar, Device>::size, PacketType<RhsScalar, Device>::size);
+    const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
+    const double kd = static_cast<double>(bk);
+    double compute_bandwidth = computeBandwidth(false, bm, bn, bk);
+    // Computations.
+    TensorOpCost cost = TensorOpCost(0, 0, kd * compute_bandwidth, true, packed_size);
+    // Output stores.
+    cost += TensorOpCost(0, sizeof(CoeffReturnType), 0, true, output_packet_size);
+    if (prepacked) {
+      // Packing and kernels are executed in different tasks. When we calculate
+      // task grain size we look only at kernel cost assuming that kernel
+      // is more expensive than packing.
+      return cost;
+    }
+    // Lhs/rhs loads + computations.
+    TensorOpCost lhsCost = this->m_leftImpl.costPerCoeff(true) * (kd / n);
+    TensorOpCost rhsCost = this->m_rightImpl.costPerCoeff(true) * (kd / m);
+    // Lhs packing memory cost does not contribute considerably to overall
+    // execution time because lhs is prefetched early and accessed sequentially.
+    if (shard_by_col)
+      lhsCost.dropMemoryCost();
+    else
+      rhsCost.dropMemoryCost();
+    return cost + lhsCost + rhsCost;
+  }
+
+  // Decide whether we want to shard m x k x n contraction over the inner
+  // (contraction) dimension (k).
+  static bool shardByInnerDim(Index m, Index n, Index k, int num_threads, int num_threads_by_k) {
+    std::ptrdiff_t bufsize = m * n * sizeof(Scalar);
+    bool shard_by_k = false;
+    if (n == 1 ||                                      // If mat*vec or...
+        num_threads_by_k < 2 ||                        // running single threaded or...
+        num_threads_by_k < num_threads ||              // sharding by k gives less parallelism or...
+        bufsize > l3CacheSize() / num_threads_by_k ||  // need more buffer space
+        // than L3 cache or...
+        k / num_threads_by_k < 2 * Traits::nr) {  // k per thread is tiny.
+      shard_by_k = false;
+    } else if (numext::maxi(m, n) / num_threads < Traits::nr ||  // both other dimensions are tiny or...
+                                                                 // k per thread is not small and...
+               (k / num_threads_by_k > 8 * Traits::nr &&
+                // one of the outer dimensions is tiny or sharding by k offers
+                // more parallelism.
+                (numext::mini(m, n) < 2 * Traits::nr || num_threads_by_k > num_threads))) {
+      shard_by_k = true;
+    }
+    return shard_by_k;
+  }
+
+  TensorOpCost contractionCostPerInnerDim(Index m, Index n, Index k) const {
+    // Compute cost.
+    const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
+    TensorOpCost cost(0, 0, (computeBandwidth(true, m, n, k) * m) * n, true, output_packet_size);
+    // Output stores.
+    cost += TensorOpCost(0, sizeof(CoeffReturnType), 0, true, output_packet_size);
+    TensorOpCost lhsCost = this->m_leftImpl.costPerCoeff(true) * m;
+    TensorOpCost rhsCost = this->m_rightImpl.costPerCoeff(true) * n;
+    // Since the inner gemm kernel is always sharded by column, the lhs
+    // load cost is negligible.
+    lhsCost.dropMemoryCost();
+    return cost + lhsCost + rhsCost;
+  }
+
+  int numThreadsInnerDim(Index m, Index n, Index k) const {
+    const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
+    TensorOpCost cost = contractionCostPerInnerDim(m, n, k);
+    double total_parallel_cost = TensorCostModel<ThreadPoolDevice>::totalCost(k, cost);
+    // Cost of reduction step accumulating the m*n per-thread buffers into the
+    // result.
+    double reduction_cost =
+        TensorCostModel<ThreadPoolDevice>::totalCost(m * n, TensorOpCost(2, 1, 1, true, output_packet_size));
+    int num_threads = 1;
+    double min_cost = total_parallel_cost;
+    double kPerThreadOverHead = 3000;
+    double kFixedOverHead = 20000;
+    for (int nt = 2; nt <= this->m_device.numThreads(); nt += 2) {
+      double sequential_cost = kFixedOverHead + nt * (reduction_cost + kPerThreadOverHead);
+      double parallel_cost = total_parallel_cost / nt + sequential_cost;
+      if (parallel_cost < min_cost) {
+        num_threads = nt;
+        min_cost = parallel_cost;
+      }
+    }
+    return num_threads;
+  }
+
+  double computeBandwidth(bool shard_by_col, Index bm, Index bn, Index bk) const {
+    // Peak VFMA bandwidth is 0.5. However if we have not enough data for
+    // vectorization bandwidth drops. The 4.0 and 2.0 bandwidth is determined
+    // experimentally.
+    double computeBandwidth = bk == 1                                                                          ? 4.0
+                              : (shard_by_col ? bn : bm) < Traits::nr || (shard_by_col ? bm : bn) < Traits::mr ? 2.0
+                                                                                                               : 0.5;
+#ifndef EIGEN_VECTORIZE_FMA
+    // Bandwidth of all of VFMA/MULPS/ADDPS is 0.5 on latest Intel processors.
+    // However for MULPS/ADDPS we have dependent sequence of 2 such
+    // instructions,
+    // so overall bandwidth is 1.0.
+    if (computeBandwidth == 0.5) computeBandwidth = 1.0;
+#endif
+    return computeBandwidth;
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_USE_THREADS
+#endif  // EIGEN_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
diff --git a/contrib/Eigen/src/Tensor/TensorConversion.h b/contrib/Eigen/src/Tensor/TensorConversion.h
new file mode 100644
index 0000000..82a2796
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorConversion.h
@@ -0,0 +1,422 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONVERSION_H
+#define EIGEN_TENSOR_TENSOR_CONVERSION_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename TargetType, typename XprType>
+struct traits<TensorConversionOp<TargetType, XprType> > {
+  // Type promotion to handle the case where the types of the lhs and the rhs are different.
+  typedef TargetType Scalar;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::Index Index;
+  static constexpr int NumDimensions = traits<XprType>::NumDimensions;
+  static constexpr int Layout = traits<XprType>::Layout;
+  enum { Flags = 0 };
+  typedef typename TypeConversion<Scalar, typename traits<XprType>::PointerType>::type PointerType;
+};
+
+template <typename TargetType, typename XprType>
+struct eval<TensorConversionOp<TargetType, XprType>, Eigen::Dense> {
+  typedef const TensorConversionOp<TargetType, XprType>& type;
+};
+
+}  // end namespace internal
+
+template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int SrcCoeffRatio, int TgtCoeffRatio>
+struct PacketConverter;
+
+template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
+struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, 1> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
+
+  template <int LoadMode, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
+    return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<LoadMode>(index));
+  }
+
+ private:
+  const TensorEvaluator& m_impl;
+};
+
+template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
+struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 2, 1> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
+
+  template <int LoadMode, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
+    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
+
+    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
+    SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
+    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2);
+    return result;
+  }
+
+ private:
+  const TensorEvaluator& m_impl;
+};
+
+template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
+struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 4, 1> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
+
+  template <int LoadMode, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
+    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
+
+    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
+    SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
+    SrcPacket src3 = m_impl.template packet<LoadMode>(index + 2 * SrcPacketSize);
+    SrcPacket src4 = m_impl.template packet<LoadMode>(index + 3 * SrcPacketSize);
+    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2, src3, src4);
+    return result;
+  }
+
+ private:
+  const TensorEvaluator& m_impl;
+};
+
+template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
+struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 8, 1> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
+
+  template <int LoadMode, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
+    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
+
+    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
+    SrcPacket src2 = m_impl.template packet<LoadMode>(index + 1 * SrcPacketSize);
+    SrcPacket src3 = m_impl.template packet<LoadMode>(index + 2 * SrcPacketSize);
+    SrcPacket src4 = m_impl.template packet<LoadMode>(index + 3 * SrcPacketSize);
+    SrcPacket src5 = m_impl.template packet<LoadMode>(index + 4 * SrcPacketSize);
+    SrcPacket src6 = m_impl.template packet<LoadMode>(index + 5 * SrcPacketSize);
+    SrcPacket src7 = m_impl.template packet<LoadMode>(index + 6 * SrcPacketSize);
+    SrcPacket src8 = m_impl.template packet<LoadMode>(index + 7 * SrcPacketSize);
+    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2, src3, src4, src5, src6, src7, src8);
+    return result;
+  }
+
+ private:
+  const TensorEvaluator& m_impl;
+};
+
+template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int TgtCoeffRatio>
+struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, TgtCoeffRatio> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl)
+      : m_impl(impl), m_maxIndex(impl.dimensions().TotalSize()) {}
+
+  template <int LoadMode, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
+    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
+    // Only call m_impl.packet() when we have direct access to the underlying data. This
+    // ensures that we don't compute the subexpression twice. We may however load some
+    // coefficients twice, but in practice this doesn't negatively impact performance.
+    if (m_impl.data() && (index + SrcPacketSize < m_maxIndex)) {
+      // Force unaligned memory loads since we can't ensure alignment anymore
+      return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<Unaligned>(index));
+    } else {
+      const int TgtPacketSize = internal::unpacket_traits<TgtPacket>::size;
+      typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
+      typedef typename internal::unpacket_traits<TgtPacket>::type TgtType;
+      internal::scalar_cast_op<SrcType, TgtType> converter;
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<TgtPacket>::alignment)
+      typename internal::unpacket_traits<TgtPacket>::type values[TgtPacketSize];
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < TgtPacketSize; ++i) {
+        values[i] = converter(m_impl.coeff(index + i));
+      }
+      TgtPacket rslt = internal::pload<TgtPacket>(values);
+      return rslt;
+    }
+  }
+
+ private:
+  const TensorEvaluator& m_impl;
+  const typename TensorEvaluator::Index m_maxIndex;
+};
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor conversion class. This class makes it possible to vectorize
+ * type casting operations when the number of scalars per packet in the source
+ * and the destination type differ
+ */
+template <typename TargetType, typename XprType>
+class TensorConversionOp : public TensorBase<TensorConversionOp<TargetType, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename internal::traits<TensorConversionOp>::Scalar Scalar;
+  typedef typename internal::traits<TensorConversionOp>::StorageKind StorageKind;
+  typedef typename internal::traits<TensorConversionOp>::Index Index;
+  typedef typename internal::ref_selector<TensorConversionOp>::type Nested;
+  typedef Scalar CoeffReturnType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConversionOp(const XprType& xpr) : m_xpr(xpr) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+};
+
+template <bool SameType, typename Eval, typename EvalPointerType>
+struct ConversionSubExprEval {
+  static EIGEN_STRONG_INLINE bool run(Eval& impl, EvalPointerType) {
+    impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+};
+
+template <typename Eval, typename EvalPointerType>
+struct ConversionSubExprEval<true, Eval, EvalPointerType> {
+  static EIGEN_STRONG_INLINE bool run(Eval& impl, EvalPointerType data) { return impl.evalSubExprsIfNeeded(data); }
+};
+
+#ifdef EIGEN_USE_THREADS
+template <bool SameType, typename Eval, typename EvalPointerType, typename EvalSubExprsCallback>
+struct ConversionSubExprEvalAsync {
+  static EIGEN_STRONG_INLINE void run(Eval& impl, EvalPointerType, EvalSubExprsCallback done) {
+    impl.evalSubExprsIfNeededAsync(nullptr, std::move(done));
+  }
+};
+
+template <typename Eval, typename EvalPointerType, typename EvalSubExprsCallback>
+struct ConversionSubExprEvalAsync<true, Eval, EvalPointerType, EvalSubExprsCallback> {
+  static EIGEN_STRONG_INLINE void run(Eval& impl, EvalPointerType data, EvalSubExprsCallback done) {
+    impl.evalSubExprsIfNeededAsync(data, std::move(done));
+  }
+};
+#endif
+
+namespace internal {
+
+template <typename SrcType, typename TargetType, bool IsSameT>
+struct CoeffConv {
+  template <typename ArgType, typename Device>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetType run(const TensorEvaluator<ArgType, Device>& impl,
+                                                              Index index) {
+    internal::scalar_cast_op<SrcType, TargetType> converter;
+    return converter(impl.coeff(index));
+  }
+};
+
+template <typename SrcType, typename TargetType>
+struct CoeffConv<SrcType, TargetType, true> {
+  template <typename ArgType, typename Device>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetType run(const TensorEvaluator<ArgType, Device>& impl,
+                                                              Index index) {
+    return impl.coeff(index);
+  }
+};
+
+template <typename SrcPacket, typename TargetPacket, int LoadMode, bool ActuallyVectorize, bool IsSameT>
+struct PacketConv {
+  typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
+  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
+
+  static constexpr int PacketSize = internal::unpacket_traits<TargetPacket>::size;
+
+  template <typename ArgType, typename Device>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
+                                                                Index index) {
+    internal::scalar_cast_op<SrcType, TargetType> converter;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<TargetPacket>::alignment)
+    std::remove_const_t<TargetType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = converter(impl.coeff(index + i));
+    }
+    TargetPacket rslt = internal::pload<TargetPacket>(values);
+    return rslt;
+  }
+};
+
+template <typename SrcPacket, typename TargetPacket, int LoadMode, bool IsSameT>
+struct PacketConv<SrcPacket, TargetPacket, LoadMode, true, IsSameT> {
+  typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
+  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
+
+  template <typename ArgType, typename Device>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
+                                                                Index index) {
+    const int SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
+    const int TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
+    PacketConverter<TensorEvaluator<ArgType, Device>, SrcPacket, TargetPacket, SrcCoeffRatio, TgtCoeffRatio> converter(
+        impl);
+    return converter.template packet<LoadMode>(index);
+  }
+};
+
+template <typename SrcPacket, typename TargetPacket, int LoadMode>
+struct PacketConv<SrcPacket, TargetPacket, LoadMode, /*ActuallyVectorize=*/false, /*IsSameT=*/true> {
+  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
+  static constexpr int PacketSize = internal::unpacket_traits<TargetPacket>::size;
+
+  template <typename ArgType, typename Device>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
+                                                                Index index) {
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<TargetPacket>::alignment)
+    std::remove_const_t<TargetType> values[PacketSize];
+    for (int i = 0; i < PacketSize; ++i) values[i] = impl.coeff(index + i);
+    return internal::pload<TargetPacket>(values);
+  }
+};
+
+template <typename SrcPacket, typename TargetPacket, int LoadMode>
+struct PacketConv<SrcPacket, TargetPacket, LoadMode, /*ActuallyVectorize=*/true, /*IsSameT=*/true> {
+  template <typename ArgType, typename Device>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
+                                                                Index index) {
+    return impl.template packet<LoadMode>(index);
+  }
+};
+
+}  // namespace internal
+
+// Eval as rvalue
+template <typename TargetType, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorConversionOp<TargetType, ArgType>, Device> {
+  typedef TensorConversionOp<TargetType, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  typedef TargetType Scalar;
+  typedef TargetType CoeffReturnType;
+  typedef internal::remove_all_t<typename internal::traits<ArgType>::Scalar> SrcType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename PacketType<SrcType, Device>::type PacketSourceType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  static constexpr bool IsSameType = std::is_same<TargetType, SrcType>::value;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  enum {
+    IsAligned = false,
+    PacketAccess =
+#ifndef EIGEN_USE_SYCL
+        true,
+#else
+        TensorEvaluator<ArgType, Device>::PacketAccess &
+        internal::type_casting_traits<SrcType, TargetType>::VectorizedCast,
+#endif
+    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    RawAccess = false
+  };
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
+
+  struct TensorConversionOpBlockFactory {
+    template <typename ArgXprType>
+    struct XprType {
+      typedef TensorConversionOp<TargetType, const ArgXprType> type;
+    };
+
+    template <typename ArgXprType>
+    typename XprType<ArgXprType>::type expr(const ArgXprType& expr) const {
+      return typename XprType<ArgXprType>::type(expr);
+    }
+  };
+
+  typedef internal::TensorUnaryExprBlock<TensorConversionOpBlockFactory, ArgTensorBlock> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    return ConversionSubExprEval<IsSameType, TensorEvaluator<ArgType, Device>, EvaluatorPointerType>::run(m_impl, data);
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType data, EvalSubExprsCallback done) {
+    ConversionSubExprEvalAsync<IsSameType, TensorEvaluator<ArgType, Device>, EvaluatorPointerType,
+                               EvalSubExprsCallback>::run(m_impl, data, std::move(done));
+  }
+#endif
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    return internal::CoeffConv<SrcType, TargetType, IsSameType>::run(m_impl, index);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    // If we are not going to do the cast, we just need to check that base
+    // TensorEvaluator has packet access. Otherwise we also need to make sure,
+    // that we have an implementation of vectorized cast.
+    constexpr bool Vectorizable = IsSameType
+                                      ? TensorEvaluator<ArgType, Device>::PacketAccess
+                                      : int(TensorEvaluator<ArgType, Device>::PacketAccess) &
+                                            int(internal::type_casting_traits<SrcType, TargetType>::VectorizedCast);
+
+    return internal::PacketConv<PacketSourceType, PacketReturnType, LoadMode, Vectorizable, IsSameType>::run(m_impl,
+                                                                                                             index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double cast_cost = TensorOpCost::CastCost<SrcType, TargetType>();
+    if (vectorized) {
+      const double SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
+      const double TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
+      return m_impl.costPerCoeff(vectorized) * (SrcCoeffRatio / PacketSize) +
+             TensorOpCost(0, 0, TgtCoeffRatio * (cast_cost / PacketSize));
+    } else {
+      return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, cast_cost);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return m_impl.getResourceRequirements();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    // The forwarded destination buffer is sized for TargetType (the assign
+    // LHS); the child block evaluator below us writes SrcType. When the cast
+    // is non-degenerate the buffer would be misinterpreted by any
+    // block-materializing child's prepareStorage (assert in debug, corruption
+    // in release). Drop the buffer; the child falls back to scratch and
+    // writeBlock still lands the cast values in the LHS.
+    EIGEN_IF_CONSTEXPR (!IsSameType) {
+      desc.DropDestinationBuffer();
+    }
+    return TensorBlock(m_impl.block(desc, scratch), TensorConversionOpBlockFactory());
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+  /// required by sycl in order to extract the sycl accessor
+  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+
+ protected:
+  TensorEvaluator<ArgType, Device> m_impl;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONVERSION_H
diff --git a/contrib/Eigen/src/Tensor/TensorConvolution.h b/contrib/Eigen/src/Tensor/TensorConvolution.h
new file mode 100644
index 0000000..70357aa
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorConvolution.h
@@ -0,0 +1,1103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CONVOLUTION_H
+#define EIGEN_TENSOR_TENSOR_CONVOLUTION_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Index, typename InputDims, int NumKernelDims, int Layout>
+class IndexMapper {
+ public:
+  IndexMapper(const InputDims& input_dims, const array<Index, NumKernelDims>& kernel_dims,
+              const array<Index, NumKernelDims>& indices) {
+    array<Index, NumDims> dimensions = input_dims;
+    for (int i = 0; i < NumKernelDims; ++i) {
+      const Index index = indices[i];
+      const Index input_dim = input_dims[index];
+      const Index kernel_dim = kernel_dims[i];
+      const Index result_dim = input_dim - kernel_dim + 1;
+      dimensions[index] = result_dim;
+    }
+
+    array<Index, NumDims> inputStrides;
+    array<Index, NumDims> outputStrides;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      inputStrides[0] = 1;
+      outputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        inputStrides[i] = inputStrides[i - 1] * input_dims[i - 1];
+        outputStrides[i] = outputStrides[i - 1] * dimensions[i - 1];
+      }
+    } else {
+      inputStrides[NumDims - 1] = 1;
+      outputStrides[NumDims - 1] = 1;
+      for (int i = static_cast<int>(NumDims) - 2; i >= 0; --i) {
+        inputStrides[i] = inputStrides[i + 1] * input_dims[i + 1];
+        outputStrides[i] = outputStrides[i + 1] * dimensions[i + 1];
+      }
+    }
+
+    array<Index, NumDims> gpuInputDimensions;
+    array<Index, NumDims> gpuOutputDimensions;
+    array<Index, NumDims> tmp = dimensions;
+    array<Index, NumDims> ordering;
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    for (int i = 0; i < NumKernelDims; ++i) {
+      const Index index = i + offset;
+      ordering[index] = indices[i];
+      tmp[indices[i]] = -1;
+      gpuInputDimensions[index] = input_dims[indices[i]];
+      gpuOutputDimensions[index] = dimensions[indices[i]];
+    }
+
+    int written = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? NumKernelDims : 0;
+    for (int i = 0; i < NumDims; ++i) {
+      if (tmp[i] >= 0) {
+        ordering[written] = i;
+        gpuInputDimensions[written] = input_dims[i];
+        gpuOutputDimensions[written] = dimensions[i];
+        ++written;
+      }
+    }
+
+    for (int i = 0; i < NumDims; ++i) {
+      m_inputStrides[i] = inputStrides[ordering[i]];
+      m_outputStrides[i] = outputStrides[ordering[i]];
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = 0; i < NumDims; ++i) {
+        if (i > NumKernelDims) {
+          m_gpuInputStrides[i] = m_gpuInputStrides[i - 1] * gpuInputDimensions[i - 1];
+          m_gpuOutputStrides[i] = m_gpuOutputStrides[i - 1] * gpuOutputDimensions[i - 1];
+        } else {
+          m_gpuInputStrides[i] = 1;
+          m_gpuOutputStrides[i] = 1;
+        }
+      }
+    } else {
+      for (int i = NumDims - 1; i >= 0; --i) {
+        if (i + 1 < static_cast<int>(offset)) {
+          m_gpuInputStrides[i] = m_gpuInputStrides[i + 1] * gpuInputDimensions[i + 1];
+          m_gpuOutputStrides[i] = m_gpuOutputStrides[i + 1] * gpuOutputDimensions[i + 1];
+        } else {
+          m_gpuInputStrides[i] = 1;
+          m_gpuOutputStrides[i] = 1;
+        }
+      }
+    }
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputPlaneToTensorInputOffset(Index p) const {
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int d = NumDims - 1; d > NumKernelDims; --d) {
+        const Index idx = p / m_gpuInputStrides[d];
+        inputIndex += idx * m_inputStrides[d];
+        p -= idx * m_gpuInputStrides[d];
+      }
+      EIGEN_IF_CONSTEXPR (NumKernelDims < NumDims) {
+        inputIndex += p * m_inputStrides[NumKernelDims];
+      }
+    } else {
+      std::ptrdiff_t limit = 0;
+      EIGEN_IF_CONSTEXPR (NumKernelDims < NumDims) {
+        limit = NumDims - NumKernelDims - 1;
+      }
+      for (int d = 0; d < limit; ++d) {
+        const Index idx = p / m_gpuInputStrides[d];
+        inputIndex += idx * m_inputStrides[d];
+        p -= idx * m_gpuInputStrides[d];
+      }
+      inputIndex += p * m_inputStrides[limit];
+    }
+    return inputIndex;
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputPlaneToTensorOutputOffset(Index p) const {
+    Index outputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int d = NumDims - 1; d > NumKernelDims; --d) {
+        const Index idx = p / m_gpuOutputStrides[d];
+        outputIndex += idx * m_outputStrides[d];
+        p -= idx * m_gpuOutputStrides[d];
+      }
+      EIGEN_IF_CONSTEXPR (NumKernelDims < NumDims) {
+        outputIndex += p * m_outputStrides[NumKernelDims];
+      }
+    } else {
+      std::ptrdiff_t limit = 0;
+      EIGEN_IF_CONSTEXPR (NumKernelDims < NumDims) {
+        limit = NumDims - NumKernelDims - 1;
+      }
+      for (int d = 0; d < limit; ++d) {
+        const Index idx = p / m_gpuOutputStrides[d];
+        outputIndex += idx * m_outputStrides[d];
+        p -= idx * m_gpuOutputStrides[d];
+      }
+      outputIndex += p * m_outputStrides[limit];
+    }
+    return outputIndex;
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputKernelToTensorInputOffset(Index i) const {
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    return i * m_inputStrides[offset];
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputKernelToTensorOutputOffset(Index i) const {
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    return i * m_outputStrides[offset];
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputKernelToTensorInputOffset(Index i, Index j) const {
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    return i * m_inputStrides[offset] + j * m_inputStrides[offset + 1];
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputKernelToTensorOutputOffset(Index i, Index j) const {
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    return i * m_outputStrides[offset] + j * m_outputStrides[offset + 1];
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputKernelToTensorInputOffset(Index i, Index j, Index k) const {
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    return i * m_inputStrides[offset] + j * m_inputStrides[offset + 1] + k * m_inputStrides[offset + 2];
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputKernelToTensorOutputOffset(Index i, Index j, Index k) const {
+    constexpr size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
+    return i * m_outputStrides[offset] + j * m_outputStrides[offset + 1] + k * m_outputStrides[offset + 2];
+  }
+
+ private:
+  static constexpr int NumDims = internal::array_size<InputDims>::value;
+  array<Index, NumDims> m_inputStrides;
+  array<Index, NumDims> m_outputStrides;
+  array<Index, NumDims> m_gpuInputStrides;
+  array<Index, NumDims> m_gpuOutputStrides;
+};
+
+template <typename Dimensions, typename InputXprType, typename KernelXprType>
+struct traits<TensorConvolutionOp<Dimensions, InputXprType, KernelXprType> > {
+  // Type promotion to handle the case where the types of the lhs and the rhs are different.
+  typedef typename promote_storage_type<typename InputXprType::Scalar, typename KernelXprType::Scalar>::ret Scalar;
+  typedef typename promote_storage_type<typename traits<InputXprType>::StorageKind,
+                                        typename traits<KernelXprType>::StorageKind>::ret StorageKind;
+  typedef typename promote_index_type<typename traits<InputXprType>::Index, typename traits<KernelXprType>::Index>::type
+      Index;
+  static constexpr int NumDimensions = traits<InputXprType>::NumDimensions;
+  static constexpr int Layout = traits<InputXprType>::Layout;
+  typedef std::conditional_t<Pointer_type_promotion<typename InputXprType::Scalar, Scalar>::val,
+                             typename traits<InputXprType>::PointerType, typename traits<KernelXprType>::PointerType>
+      PointerType;
+
+  enum { Flags = 0 };
+};
+
+template <typename Dimensions, typename InputXprType, typename KernelXprType>
+struct eval<TensorConvolutionOp<Dimensions, InputXprType, KernelXprType>, Eigen::Dense> {
+  typedef const TensorConvolutionOp<Dimensions, InputXprType, KernelXprType>& type;
+};
+
+}  // end namespace internal
+
+/** Tensor convolution class.
+ * \ingroup Tensor_Module
+ */
+template <typename Indices, typename InputXprType, typename KernelXprType>
+class TensorConvolutionOp
+    : public TensorBase<TensorConvolutionOp<Indices, InputXprType, KernelXprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorConvolutionOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename internal::promote_storage_type<typename InputXprType::CoeffReturnType,
+                                                  typename KernelXprType::CoeffReturnType>::ret CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorConvolutionOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorConvolutionOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorConvolutionOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConvolutionOp(const InputXprType& input, const KernelXprType& kernel,
+                                                            const Indices& dims)
+      : m_input_xpr(input), m_kernel_xpr(kernel), m_indices(dims) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Indices& indices() const { return m_indices; }
+
+  /** \returns the nested expressions */
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all_t<typename InputXprType::Nested>& inputExpression()
+      const {
+    return m_input_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all_t<typename KernelXprType::Nested>& kernelExpression()
+      const {
+    return m_kernel_xpr;
+  }
+
+ protected:
+  typename InputXprType::Nested m_input_xpr;
+  typename KernelXprType::Nested m_kernel_xpr;
+  const Indices m_indices;
+};
+
+template <typename Indices, typename InputArgType, typename KernelArgType, typename Device>
+struct TensorEvaluator<const TensorConvolutionOp<Indices, InputArgType, KernelArgType>, Device> {
+  typedef TensorConvolutionOp<Indices, InputArgType, KernelArgType> XprType;
+
+  static constexpr int NumDims =
+      internal::array_size<typename TensorEvaluator<InputArgType, Device>::Dimensions>::value;
+  static constexpr int NumKernelDims = internal::array_size<Indices>::value;
+  typedef typename XprType::Index Index;
+  typedef DSizes<Index, NumDims> Dimensions;
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<Scalar, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<InputArgType, Device>::Layout;
+  enum {
+    IsAligned =
+        int(TensorEvaluator<InputArgType, Device>::IsAligned) & int(TensorEvaluator<KernelArgType, Device>::IsAligned),
+    PacketAccess = int(TensorEvaluator<InputArgType, Device>::PacketAccess) &
+                   int(TensorEvaluator<KernelArgType, Device>::PacketAccess),
+    BlockAccess = false,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_inputImpl(op.inputExpression(), device),
+        m_kernelImpl(op.kernelExpression(), device),
+        m_kernelArg(op.kernelExpression()),
+        m_kernel(nullptr),
+        m_local_kernel(false),
+        m_device(device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<InputArgType, Device>::Layout) ==
+                         static_cast<int>(TensorEvaluator<KernelArgType, Device>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    const typename TensorEvaluator<InputArgType, Device>::Dimensions& input_dims = m_inputImpl.dimensions();
+    const typename TensorEvaluator<KernelArgType, Device>::Dimensions& kernel_dims = m_kernelImpl.dimensions();
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputStride[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_inputStride[i] = m_inputStride[i - 1] * input_dims[i - 1];
+      }
+    } else {
+      m_inputStride[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_inputStride[i] = m_inputStride[i + 1] * input_dims[i + 1];
+      }
+    }
+
+    m_dimensions = m_inputImpl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = 0; i < NumKernelDims; ++i) {
+        const Index index = op.indices()[i];
+        const Index input_dim = input_dims[index];
+        const Index kernel_dim = kernel_dims[i];
+        const Index result_dim = input_dim - kernel_dim + 1;
+        m_dimensions[index] = result_dim;
+        if (i > 0) {
+          m_kernelStride[i] = m_kernelStride[i - 1] * kernel_dims[i - 1];
+        } else {
+          m_kernelStride[0] = 1;
+        }
+        m_indexStride[i] = m_inputStride[index];
+      }
+
+      m_outputStride[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_outputStride[i] = m_outputStride[i - 1] * m_dimensions[i - 1];
+      }
+    } else {
+      for (int i = NumKernelDims - 1; i >= 0; --i) {
+        const Index index = op.indices()[i];
+        const Index input_dim = input_dims[index];
+        const Index kernel_dim = kernel_dims[i];
+        const Index result_dim = input_dim - kernel_dim + 1;
+        m_dimensions[index] = result_dim;
+        if (i < NumKernelDims - 1) {
+          m_kernelStride[i] = m_kernelStride[i + 1] * kernel_dims[i + 1];
+        } else {
+          m_kernelStride[NumKernelDims - 1] = 1;
+        }
+        m_indexStride[i] = m_inputStride[index];
+      }
+
+      m_outputStride[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_outputStride[i] = m_outputStride[i + 1] * m_dimensions[i + 1];
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar*) {
+    m_inputImpl.evalSubExprsIfNeeded(nullptr);
+    preloadKernel();
+    return true;
+  }
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_inputImpl.cleanup();
+    if (m_local_kernel) {
+      m_device.deallocate((void*)m_kernel);
+      m_local_kernel = false;
+    }
+    m_kernel = nullptr;
+  }
+
+  void evalTo(typename XprType::Scalar* buffer) {
+    evalSubExprsIfNeeded(nullptr);
+    for (int i = 0; i < dimensions().TotalSize(); ++i) {
+      buffer[i] += coeff(i);
+    }
+    cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    CoeffReturnType result = CoeffReturnType(0);
+    convolve(firstInput(index), 0, NumKernelDims - 1, result);
+    return result;
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(const Index index) const {
+    Index indices[2] = {index, index + PacketSize - 1};
+    Index startInputs[2] = {0, 0};
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx0 = indices[0] / m_outputStride[i];
+        const Index idx1 = indices[1] / m_outputStride[i];
+        startInputs[0] += idx0 * m_inputStride[i];
+        startInputs[1] += idx1 * m_inputStride[i];
+        indices[0] -= idx0 * m_outputStride[i];
+        indices[1] -= idx1 * m_outputStride[i];
+      }
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx0 = indices[0] / m_outputStride[i];
+        const Index idx1 = indices[1] / m_outputStride[i];
+        startInputs[0] += idx0 * m_inputStride[i];
+        startInputs[1] += idx1 * m_inputStride[i];
+        indices[0] -= idx0 * m_outputStride[i];
+        indices[1] -= idx1 * m_outputStride[i];
+      }
+    }
+    startInputs[0] += indices[0];
+    startInputs[1] += indices[1];
+
+    if (startInputs[1] - startInputs[0] == PacketSize - 1) {
+      PacketReturnType result = internal::pset1<PacketReturnType>(0);
+      convolvePacket(startInputs[0], 0, NumKernelDims - 1, result);
+      return result;
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) Scalar data[PacketSize];
+      data[0] = Scalar(0);
+      convolve(startInputs[0], 0, NumKernelDims - 1, data[0]);
+      for (int i = 1; i < PacketSize - 1; ++i) {
+        data[i] = Scalar(0);
+        convolve(firstInput(index + i), 0, NumKernelDims - 1, data[i]);
+      }
+      data[PacketSize - 1] = Scalar(0);
+      convolve(startInputs[1], 0, NumKernelDims - 1, data[PacketSize - 1]);
+      return internal::pload<PacketReturnType>(data);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double kernel_size = m_kernelImpl.dimensions().TotalSize();
+    // We ignore the use of fused multiply-add.
+    const double convolve_compute_cost = TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>();
+    const double firstIndex_compute_cost =
+        NumDims *
+        (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
+    return TensorOpCost(0, 0, firstIndex_compute_cost, vectorized, PacketSize) +
+           kernel_size * (m_inputImpl.costPerCoeff(vectorized) + m_kernelImpl.costPerCoeff(vectorized) +
+                          TensorOpCost(0, 0, convolve_compute_cost, vectorized, PacketSize));
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index firstInput(Index index) const {
+    Index startInput = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_outputStride[i];
+        startInput += idx * m_inputStride[i];
+        index -= idx * m_outputStride[i];
+      }
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_outputStride[i];
+        startInput += idx * m_inputStride[i];
+        index -= idx * m_outputStride[i];
+      }
+    }
+    startInput += index;
+    return startInput;
+  }
+
+  EIGEN_DEVICE_FUNC void convolve(Index firstIndex, Index firstKernel, int DimIndex, CoeffReturnType& accum) const {
+    for (int j = 0; j < m_kernelImpl.dimensions()[DimIndex]; ++j) {
+      const Index input = firstIndex + j * m_indexStride[DimIndex];
+      const Index kernel = firstKernel + j * m_kernelStride[DimIndex];
+      if (DimIndex > 0) {
+        convolve(input, kernel, DimIndex - 1, accum);
+      } else {
+        accum += m_inputImpl.coeff(input) * m_kernel[kernel];
+      }
+    }
+  }
+
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC void convolvePacket(Index firstIndex, Index firstKernel, int DimIndex, Packet& accum) const {
+    for (int j = 0; j < m_kernelImpl.dimensions()[DimIndex]; ++j) {
+      const Index input = firstIndex + j * m_indexStride[DimIndex];
+      const Index kernel = firstKernel + j * m_kernelStride[DimIndex];
+      if (DimIndex > 0) {
+        convolvePacket(input, kernel, DimIndex - 1, accum);
+      } else {
+        accum = internal::pmadd<Packet>(m_inputImpl.template packet<Unaligned>(input),
+                                        internal::pset1<Packet>(m_kernel[kernel]), accum);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void preloadKernel() {
+    // Don't make a local copy of the kernel unless we have to (i.e. it's an
+    // expression that needs to be evaluated)
+    const Scalar* in_place = m_kernelImpl.data();
+    if (in_place) {
+      m_kernel = in_place;
+      m_local_kernel = false;
+    } else {
+      size_t kernel_sz = m_kernelImpl.dimensions().TotalSize() * sizeof(Scalar);
+      Scalar* local = (Scalar*)m_device.allocate_temp(kernel_sz);
+      typedef TensorEvalToOp<const KernelArgType> EvalTo;
+      EvalTo evalToTmp(local, m_kernelArg);
+      const bool Vectorize = internal::IsVectorizable<Device, KernelArgType>::value;
+      internal::TensorExecutor<const EvalTo, Device, Vectorize>::run(evalToTmp, m_device);
+
+      m_kernel = local;
+      m_local_kernel = true;
+    }
+  }
+
+  array<Index, NumDims> m_inputStride;
+  array<Index, NumDims> m_outputStride;
+
+  array<Index, NumKernelDims> m_indexStride;
+  array<Index, NumKernelDims> m_kernelStride;
+  TensorEvaluator<InputArgType, Device> m_inputImpl;
+  TensorEvaluator<KernelArgType, Device> m_kernelImpl;
+  Dimensions m_dimensions;
+
+  KernelArgType m_kernelArg;
+  const Scalar* m_kernel;
+  bool m_local_kernel;
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+// Use an optimized implementation of the evaluation code for GPUs whenever possible.
+#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
+
+template <int StaticKernelSize>
+struct GetKernelSize {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int operator()(const int /*kernelSize*/) const { return StaticKernelSize; }
+};
+template <>
+struct GetKernelSize<Dynamic> {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int operator()(const int kernelSize) const { return kernelSize; }
+};
+
+template <typename InputEvaluator, typename Index, typename InputDims, int StaticKernelSize>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void EigenConvolutionKernel1D(
+    InputEvaluator eval, const internal::IndexMapper<Index, InputDims, 1, InputEvaluator::Layout> indexMapper,
+    const float* __restrict kernel, const int numPlanes, const int numX, const int maxX, const int kernelSize,
+    float* buffer) {
+#if defined(EIGEN_HIPCC)
+  HIP_DYNAMIC_SHARED(float, s)
+#else
+  extern __shared__ float s[];
+#endif
+
+  const int first_x = blockIdx.x * maxX;
+  const int last_x = (first_x + maxX < numX ? first_x + maxX : numX) - 1;
+  const int num_x_input = last_x - first_x + GetKernelSize<StaticKernelSize>()(kernelSize);
+  const int num_x_output = last_x - first_x + 1;
+
+  const int first_plane = blockIdx.y * blockDim.y;
+  const int plane_stride = blockDim.y * gridDim.y;
+
+  for (int p = first_plane + threadIdx.y; p < numPlanes; p += plane_stride) {
+    // Load inputs to shared memory
+    const int plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
+    const int plane_kernel_offset = threadIdx.y * num_x_input;
+#pragma unroll
+    for (int i = threadIdx.x; i < num_x_input; i += blockDim.x) {
+      const int tensor_index = plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(i + first_x);
+      s[i + plane_kernel_offset] = eval.coeff(tensor_index);
+    }
+
+    __syncthreads();
+
+    // Compute the convolution
+    const int plane_output_offset = indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p);
+
+#pragma unroll
+    for (int i = threadIdx.x; i < num_x_output; i += blockDim.x) {
+      const int kernel_offset = plane_kernel_offset + i;
+      float result = 0.0f;
+#pragma unroll
+      for (int k = 0; k < GetKernelSize<StaticKernelSize>()(kernelSize); ++k) {
+        result += s[k + kernel_offset] * kernel[k];
+      }
+      const int tensor_index = plane_output_offset + indexMapper.mapGpuOutputKernelToTensorOutputOffset(i + first_x);
+      buffer[tensor_index] = result;
+    }
+    __syncthreads();
+  }
+}
+
+template <typename InputEvaluator, typename Index, typename InputDims, int StaticKernelSizeX, int StaticKernelSizeY>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void EigenConvolutionKernel2D(
+    InputEvaluator eval, const internal::IndexMapper<Index, InputDims, 2, InputEvaluator::Layout> indexMapper,
+    const float* __restrict kernel, const int numPlanes, const int numX, const int maxX, const int numY, const int maxY,
+    const int kernelSizeX, const int kernelSizeY, float* buffer) {
+#if defined(EIGEN_HIPCC)
+  HIP_DYNAMIC_SHARED(float, s)
+#else
+  extern __shared__ float s[];
+#endif
+
+  const int first_x = blockIdx.x * maxX;
+  const int last_x = (first_x + maxX < numX ? first_x + maxX : numX) - 1;
+  const int num_x_input = last_x - first_x + GetKernelSize<StaticKernelSizeX>()(kernelSizeX);
+  const int num_x_output = last_x - first_x + 1;
+
+  const int first_y = blockIdx.y * maxY;
+  const int last_y = (first_y + maxY < numY ? first_y + maxY : numY) - 1;
+  const int num_y_input = last_y - first_y + GetKernelSize<StaticKernelSizeY>()(kernelSizeY);
+  const int num_y_output = last_y - first_y + 1;
+
+  const int first_plane = blockIdx.z * blockDim.z;
+  const int plane_stride = blockDim.z * gridDim.z;
+
+  for (int p = first_plane + threadIdx.z; p < numPlanes; p += plane_stride) {
+    const int plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
+    const int plane_kernel_offset = threadIdx.z * num_y_input;
+
+// Load inputs to shared memory
+#pragma unroll
+    for (int j = threadIdx.y; j < num_y_input; j += blockDim.y) {
+      const int input_offset = num_x_input * (j + plane_kernel_offset);
+#pragma unroll
+      for (int i = threadIdx.x; i < num_x_input; i += blockDim.x) {
+        const int tensor_index =
+            plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(i + first_x, j + first_y);
+        s[i + input_offset] = eval.coeff(tensor_index);
+      }
+    }
+
+    __syncthreads();
+
+    // Convolution
+    const int plane_output_offset = indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p);
+
+#pragma unroll
+    for (int j = threadIdx.y; j < num_y_output; j += blockDim.y) {
+#pragma unroll
+      for (int i = threadIdx.x; i < num_x_output; i += blockDim.x) {
+        float result = 0.0f;
+#pragma unroll
+        for (int l = 0; l < GetKernelSize<StaticKernelSizeY>()(kernelSizeY); ++l) {
+          const int kernel_offset = kernelSizeX * l;
+          const int input_offset = i + num_x_input * (j + l + plane_kernel_offset);
+#pragma unroll
+          for (int k = 0; k < GetKernelSize<StaticKernelSizeX>()(kernelSizeX); ++k) {
+            result += s[k + input_offset] * kernel[k + kernel_offset];
+          }
+        }
+        const int tensor_index =
+            plane_output_offset + indexMapper.mapGpuOutputKernelToTensorOutputOffset(i + first_x, j + first_y);
+        buffer[tensor_index] = result;
+      }
+    }
+
+    __syncthreads();
+  }
+}
+
+template <typename InputEvaluator, typename Index, typename InputDims>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void EigenConvolutionKernel3D(
+    InputEvaluator eval, const internal::IndexMapper<Index, InputDims, 3, InputEvaluator::Layout> indexMapper,
+    const float* __restrict kernel, const size_t numPlanes, const size_t numX, const size_t maxX, const size_t numY,
+    const size_t maxY, const size_t numZ, const size_t maxZ, const int kernelSizeX, const int kernelSizeY,
+    const int kernelSizeZ, float* buffer) {
+#if defined(EIGEN_HIPCC)
+  HIP_DYNAMIC_SHARED(float, s)
+#else
+  extern __shared__ float s[];
+#endif
+
+  // Load inputs to shared memory
+  const int first_x = blockIdx.x * static_cast<int>(maxX);
+  const int last_x = (first_x + static_cast<int>(maxX) < static_cast<int>(numX) ? first_x + static_cast<int>(maxX)
+                                                                                : static_cast<int>(numX)) -
+                     1;
+  const int num_x_input = last_x - first_x + kernelSizeX;
+
+  const int first_y = blockIdx.y * static_cast<int>(maxY);
+  const int last_y = (first_y + static_cast<int>(maxY) < static_cast<int>(numY) ? first_y + static_cast<int>(maxY)
+                                                                                : static_cast<int>(numY)) -
+                     1;
+  const int num_y_input = last_y - first_y + kernelSizeY;
+
+  const int first_z = blockIdx.z * static_cast<int>(maxZ);
+  const int last_z = (first_z + static_cast<int>(maxZ) < static_cast<int>(numZ) ? first_z + static_cast<int>(maxZ)
+                                                                                : static_cast<int>(numZ)) -
+                     1;
+  const int num_z_input = last_z - first_z + kernelSizeZ;
+
+  for (int p = 0; p < static_cast<int>(numPlanes); ++p) {
+    const int plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
+    const int plane_kernel_offset = 0;
+
+    for (int k = threadIdx.z; k < num_z_input; k += blockDim.z) {
+      for (int j = threadIdx.y; j < num_y_input; j += blockDim.y) {
+        for (int i = threadIdx.x; i < num_x_input; i += blockDim.x) {
+          const int tensor_index = plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(
+                                                            i + first_x, j + first_y, k + first_z);
+          s[i + num_x_input * (j + num_y_input * (k + plane_kernel_offset))] = eval.coeff(tensor_index);
+        }
+      }
+    }
+
+    __syncthreads();
+
+    // Convolution
+    const int num_z_output = last_z - first_z + 1;
+    const int num_y_output = last_y - first_y + 1;
+    const int num_x_output = last_x - first_x + 1;
+    const int plane_output_offset = indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p);
+
+    for (int k = threadIdx.z; k < num_z_output; k += blockDim.z) {
+      for (int j = threadIdx.y; j < num_y_output; j += blockDim.y) {
+        for (int i = threadIdx.x; i < num_x_output; i += blockDim.x) {
+          float result = 0.0f;
+          for (int n = 0; n < kernelSizeZ; ++n) {
+            for (int m = 0; m < kernelSizeY; ++m) {
+              for (int l = 0; l < kernelSizeX; ++l) {
+                result += s[i + l + num_x_input * (j + m + num_y_input * (k + n + plane_kernel_offset))] *
+                          kernel[l + kernelSizeX * (m + kernelSizeY * n)];
+              }
+            }
+          }
+          const int tensor_index = plane_output_offset + indexMapper.mapGpuOutputKernelToTensorOutputOffset(
+                                                             i + first_x, j + first_y, k + first_z);
+          buffer[tensor_index] = result;
+        }
+      }
+    }
+    __syncthreads();
+  }
+}
+
+template <typename Indices, typename InputArgType, typename KernelArgType>
+struct TensorEvaluator<const TensorConvolutionOp<Indices, InputArgType, KernelArgType>, GpuDevice> {
+  typedef TensorConvolutionOp<Indices, InputArgType, KernelArgType> XprType;
+
+  static constexpr int NumDims =
+      internal::array_size<typename TensorEvaluator<InputArgType, GpuDevice>::Dimensions>::value;
+  static constexpr int NumKernelDims = internal::array_size<Indices>::value;
+  typedef typename XprType::Index Index;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename TensorEvaluator<KernelArgType, GpuDevice>::Dimensions KernelDimensions;
+
+  static constexpr int Layout = TensorEvaluator<InputArgType, GpuDevice>::Layout;
+  enum {
+    IsAligned = int(TensorEvaluator<InputArgType, GpuDevice>::IsAligned) &
+                int(TensorEvaluator<KernelArgType, GpuDevice>::IsAligned),
+    PacketAccess = false,
+    BlockAccess = false,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  TensorEvaluator(const XprType& op, const GpuDevice& device)
+      : m_inputImpl(op.inputExpression(), device),
+        m_kernelImpl(op.kernelExpression(), device),
+        m_kernelArg(op.kernelExpression()),
+        m_indices(op.indices()),
+        m_buf(nullptr),
+        m_kernel(nullptr),
+        m_local_kernel(false),
+        m_device(device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<InputArgType, GpuDevice>::Layout) ==
+                         static_cast<int>(TensorEvaluator<KernelArgType, GpuDevice>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    const typename TensorEvaluator<InputArgType, GpuDevice>::Dimensions& input_dims = m_inputImpl.dimensions();
+    const typename TensorEvaluator<KernelArgType, GpuDevice>::Dimensions& kernel_dims = m_kernelImpl.dimensions();
+
+    m_dimensions = m_inputImpl.dimensions();
+    for (int i = 0; i < NumKernelDims; ++i) {
+      const Index index = op.indices()[i];
+      const Index input_dim = input_dims[index];
+      const Index kernel_dim = kernel_dims[i];
+      const Index result_dim = input_dim - kernel_dim + 1;
+      m_dimensions[index] = result_dim;
+    }
+  }
+
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, GpuDevice>::type PacketReturnType;
+  typedef typename InputArgType::Scalar Scalar;
+  static constexpr int PacketSize = internal::unpacket_traits<PacketReturnType>::size;
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* data) {
+    preloadKernel();
+    m_inputImpl.evalSubExprsIfNeeded(nullptr);
+    if (data) {
+      executeEval(data);
+      return false;
+    } else {
+      m_buf = (Scalar*)m_device.allocate(dimensions().TotalSize() * sizeof(Scalar));
+      executeEval(m_buf);
+      return true;
+    }
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_inputImpl.cleanup();
+    if (m_buf) {
+      m_device.deallocate(m_buf);
+      m_buf = nullptr;
+    }
+    if (m_local_kernel) {
+      m_device.deallocate((void*)m_kernel);
+      m_local_kernel = false;
+    }
+    m_kernel = nullptr;
+  }
+
+  EIGEN_STRONG_INLINE void preloadKernel() {
+    // Don't make a local copy of the kernel unless we have to (i.e. it's an
+    // expression that needs to be evaluated)
+    const Scalar* in_place = m_kernelImpl.data();
+    if (in_place) {
+      m_kernel = in_place;
+      m_local_kernel = false;
+    } else {
+      size_t kernel_sz = m_kernelImpl.dimensions().TotalSize() * sizeof(Scalar);
+      Scalar* local = (Scalar*)m_device.allocate(kernel_sz);
+      typedef TensorEvalToOp<const KernelArgType> EvalTo;
+      EvalTo evalToTmp(local, m_kernelArg);
+      const bool PacketAccess = internal::IsVectorizable<GpuDevice, KernelArgType>::value;
+      internal::TensorExecutor<const EvalTo, GpuDevice, PacketAccess>::run(evalToTmp, m_device);
+
+      m_kernel = local;
+      m_local_kernel = true;
+    }
+  }
+
+  static unsigned int ceil(unsigned int num, unsigned int denom) {
+    const unsigned int rounded_toward_zero = num / denom;
+    if (num > rounded_toward_zero * denom) {
+      return rounded_toward_zero + 1;
+    }
+    return rounded_toward_zero;
+  }
+
+  void executeEval(Scalar* data) const {
+    typedef typename TensorEvaluator<InputArgType, GpuDevice>::Dimensions InputDims;
+
+    const int maxSharedMem = m_device.sharedMemPerBlock();
+    const int maxThreadsPerBlock = m_device.maxGpuThreadsPerBlock();
+    const int maxBlocksPerProcessor = m_device.maxGpuThreadsPerMultiProcessor() / maxThreadsPerBlock;
+    const int numMultiProcessors = m_device.getNumGpuMultiProcessors();
+    const int warpSize = 32;
+
+    switch (NumKernelDims) {
+      case 1: {
+        const int kernel_size = m_kernelImpl.dimensions().TotalSize();
+
+        const int numX = dimensions()[m_indices[0]];
+        const int numP = dimensions().TotalSize() / numX;
+        int maxX;
+        dim3 block_size;
+
+        const int single_stride_dim =
+            static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : m_inputImpl.dimensions().rank() - 1;
+        if (m_indices[0] == single_stride_dim) {
+          // Maximize the reuse
+          const int inner_dim = ((maxSharedMem / (sizeof(Scalar)) - kernel_size + 1 + 31) / 32) * 32;
+          maxX = numext::mini<int>(inner_dim, numX);
+          const int maxP = numext::mini<int>(maxSharedMem / ((kernel_size - 1 + maxX) * sizeof(Scalar)), numP);
+          block_size.x = numext::mini(maxThreadsPerBlock, maxX);
+          block_size.y = numext::mini<int>(maxThreadsPerBlock / block_size.x, maxP);
+        } else {
+          // Read as much as possible alongside the inner most dimension, that is the plane
+          const int inner_dim = maxSharedMem / ((warpSize + kernel_size) * sizeof(Scalar));
+          const int maxP = numext::mini<int>(inner_dim, numP);
+          maxX = numext::mini<int>(maxSharedMem / (inner_dim * sizeof(Scalar)) - kernel_size + 1, numX);
+
+          block_size.x = numext::mini(warpSize, maxX);
+          block_size.y = numext::mini<int>(maxThreadsPerBlock / block_size.x, maxP);
+        }
+
+        const int shared_mem = block_size.y * (maxX + kernel_size - 1) * sizeof(Scalar);
+        gpu_assert(shared_mem <= maxSharedMem);
+
+        const int num_x_blocks = ceil(numX, maxX);
+        const int blocksPerProcessor = numext::mini(maxBlocksPerProcessor, maxSharedMem / shared_mem);
+        const int num_y_blocks = ceil(numMultiProcessors * blocksPerProcessor, num_x_blocks);
+
+        dim3 num_blocks(num_x_blocks, numext::mini<int>(num_y_blocks, ceil(numP, block_size.y)));
+
+        const array<Index, 1> indices{m_indices[0]};
+        const array<Index, 1> kernel_dims{m_kernelImpl.dimensions()[0]};
+        internal::IndexMapper<Index, InputDims, 1, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
+        switch (kernel_size) {
+          case 4: {
+            LAUNCH_GPU_KERNEL((EigenConvolutionKernel1D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 4>),
+                              num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP,
+                              numX, maxX, 4, data);
+            break;
+          }
+          case 7: {
+            LAUNCH_GPU_KERNEL((EigenConvolutionKernel1D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 7>),
+                              num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP,
+                              numX, maxX, 7, data);
+            break;
+          }
+          default: {
+            LAUNCH_GPU_KERNEL(
+                (EigenConvolutionKernel1D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, Dynamic>),
+                num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
+                kernel_size, data);
+          }
+        }
+        break;
+      }
+
+      case 2: {
+        constexpr int idxX = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 1;
+        constexpr int idxY = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 0;
+        const int kernel_size_x = m_kernelImpl.dimensions()[idxX];
+        const int kernel_size_y = m_kernelImpl.dimensions()[idxY];
+
+        const int numX = dimensions()[m_indices[idxX]];
+        const int numY = dimensions()[m_indices[idxY]];
+        const int numP = dimensions().TotalSize() / (numX * numY);
+
+        const float scaling_factor =
+            sqrtf(static_cast<float>(maxSharedMem) / (sizeof(Scalar) * kernel_size_y * kernel_size_x));
+
+        // Snap maxX to warp size
+        int inner_dim = ((static_cast<int>(scaling_factor * kernel_size_x) - kernel_size_x + 1 + 32) / 32) * 32;
+        const int maxX = numext::mini<int>(inner_dim, numX);
+        const int maxY =
+            numext::mini<int>(maxSharedMem / (sizeof(Scalar) * (maxX + kernel_size_x - 1)) - kernel_size_y + 1, numY);
+        const int maxP = numext::mini<int>(
+            maxSharedMem / ((kernel_size_x - 1 + maxX) * (kernel_size_y - 1 + maxY) * sizeof(Scalar)), numP);
+
+        dim3 block_size;
+        block_size.x = numext::mini(1024, maxX);
+        block_size.y = numext::mini<int>(1024 / block_size.x, maxY);
+        block_size.z = numext::mini<int>(1024 / (block_size.x * block_size.y), maxP);
+
+        const int shared_mem = block_size.z * (maxX + kernel_size_x - 1) * (maxY + kernel_size_y - 1) * sizeof(Scalar);
+        gpu_assert(shared_mem <= maxSharedMem);
+
+        const int num_x_blocks = ceil(numX, maxX);
+        const int num_y_blocks = ceil(numY, maxY);
+        const int blocksPerProcessor = numext::mini(maxBlocksPerProcessor, maxSharedMem / shared_mem);
+        const int num_z_blocks = ceil(numMultiProcessors * blocksPerProcessor, num_x_blocks * num_y_blocks);
+
+        dim3 num_blocks(num_x_blocks, num_y_blocks, numext::mini<int>(num_z_blocks, ceil(numP, block_size.z)));
+
+        const array<Index, 2> indices{m_indices[idxX], m_indices[idxY]};
+        const array<Index, 2> kernel_dims{m_kernelImpl.dimensions()[idxX], m_kernelImpl.dimensions()[idxY]};
+        internal::IndexMapper<Index, InputDims, 2, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
+        switch (kernel_size_x) {
+          case 4: {
+            switch (kernel_size_y) {
+              case 7: {
+                LAUNCH_GPU_KERNEL(
+                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 4, 7>),
+                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
+                    numY, maxY, 4, 7, data);
+                break;
+              }
+              default: {
+                LAUNCH_GPU_KERNEL(
+                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 4, Dynamic>),
+                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
+                    numY, maxY, 4, kernel_size_y, data);
+                break;
+              }
+            }
+            break;
+          }
+          case 7: {
+            switch (kernel_size_y) {
+              case 4: {
+                LAUNCH_GPU_KERNEL(
+                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 7, 4>),
+                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
+                    numY, maxY, 7, 4, data);
+                break;
+              }
+              default: {
+                LAUNCH_GPU_KERNEL(
+                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 7, Dynamic>),
+                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
+                    numY, maxY, 7, kernel_size_y, data);
+                break;
+              }
+            }
+            break;
+          }
+          default: {
+            LAUNCH_GPU_KERNEL((EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims,
+                                                        Dynamic, Dynamic>),
+                              num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP,
+                              numX, maxX, numY, maxY, kernel_size_x, kernel_size_y, data);
+            break;
+          }
+        }
+        break;
+      }
+
+      case 3: {
+        constexpr int idxX = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 2;
+        constexpr int idxY = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 1;
+        constexpr int idxZ = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 2 : 0;
+
+        const int kernel_size_x = m_kernelImpl.dimensions()[idxX];
+        const int kernel_size_y = m_kernelImpl.dimensions()[idxY];
+        const int kernel_size_z = m_kernelImpl.dimensions()[idxZ];
+
+        const int numX = dimensions()[m_indices[idxX]];
+        const int numY = dimensions()[m_indices[idxY]];
+        const int numZ = dimensions()[m_indices[idxZ]];
+        const int numP = dimensions().TotalSize() / (numX * numY * numZ);
+
+        const int maxX = numext::mini<int>(
+            128, numext::mini<int>(maxSharedMem / (sizeof(Scalar) * kernel_size_y * kernel_size_z) - kernel_size_x + 1,
+                                   numX));
+        const int maxY = numext::mini<int>(
+            128, numext::mini<int>(
+                     maxSharedMem / (sizeof(Scalar) * (maxX + kernel_size_x - 1) * kernel_size_z) - kernel_size_y + 1,
+                     numY));
+        const int maxZ = numext::mini<int>(
+            128, numext::mini<int>(
+                     maxSharedMem / (sizeof(Scalar) * (maxX + kernel_size_x - 1) * (maxY + kernel_size_y - 1)) -
+                         kernel_size_z + 1,
+                     numZ));
+
+        dim3 block_size;
+        block_size.x = numext::mini(32, maxX);
+        block_size.y = numext::mini(32, maxY);
+        block_size.z = numext::mini<int>(1024 / (block_size.x * block_size.y), maxZ);
+        dim3 num_blocks(ceil(numX, maxX), ceil(numY, maxY), ceil(numZ, maxZ));
+
+        const int shared_mem =
+            (maxX + kernel_size_x - 1) * (maxY + kernel_size_y - 1) * (maxZ + kernel_size_z - 1) * sizeof(Scalar);
+        gpu_assert(shared_mem <= maxSharedMem);
+
+        const array<Index, 3> indices{m_indices[idxX], m_indices[idxY], m_indices[idxZ]};
+        const array<Index, 3> kernel_dims{m_kernelImpl.dimensions()[idxX], m_kernelImpl.dimensions()[idxY],
+                                          m_kernelImpl.dimensions()[idxZ]};
+        internal::IndexMapper<Index, InputDims, 3, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
+
+        LAUNCH_GPU_KERNEL((EigenConvolutionKernel3D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims>),
+                          num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX,
+                          maxX, numY, maxY, numZ, maxZ, kernel_size_x, kernel_size_y, kernel_size_z, data);
+        break;
+      }
+
+      default: {
+        EIGEN_STATIC_ASSERT((NumKernelDims >= 1 && NumKernelDims <= 3),
+                            THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    eigen_assert(m_buf);
+    eigen_assert(index < m_dimensions.TotalSize());
+    return m_buf[index];
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(const Index index) const {
+    eigen_assert(m_buf);
+    eigen_assert(index < m_dimensions.TotalSize());
+    return internal::ploadt<PacketReturnType, LoadMode>(m_buf + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // TODO(rmlarsen): For now, this is just a copy of the CPU cost
+    // model.
+    const double kernel_size = m_kernelImpl.dimensions().TotalSize();
+    // We ignore the use of fused multiply-add.
+    const double convolve_compute_cost = TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>();
+    const double firstIndex_compute_cost =
+        NumDims *
+        (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
+    return TensorOpCost(0, 0, firstIndex_compute_cost, vectorized, PacketSize) +
+           kernel_size * (m_inputImpl.costPerCoeff(vectorized) + m_kernelImpl.costPerCoeff(vectorized) +
+                          TensorOpCost(0, 0, convolve_compute_cost, vectorized, PacketSize));
+  }
+
+ private:
+  TensorEvaluator<InputArgType, GpuDevice> m_inputImpl;
+  TensorEvaluator<KernelArgType, GpuDevice> m_kernelImpl;
+  KernelArgType m_kernelArg;
+  Indices m_indices;
+  Dimensions m_dimensions;
+  Scalar* m_buf;
+  const Scalar* m_kernel;
+  bool m_local_kernel;
+
+  const GpuDevice& m_device;
+};
+#endif
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONVOLUTION_H
diff --git a/contrib/Eigen/src/Tensor/TensorConvolutionSycl.h b/contrib/Eigen/src/Tensor/TensorConvolutionSycl.h
new file mode 100644
index 0000000..821b1b5
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorConvolutionSycl.h
@@ -0,0 +1,539 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// SPDX-License-Identifier: MPL-2.0
+
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_TENSOR_TENSOR_CONVOLUTION_SYCL_H
+#define EIGEN_TENSOR_TENSOR_CONVOLUTION_SYCL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+enum class convolution_type { CONV1D, CONV2D, CONV3D };
+template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
+          typename Kernel_accessor, typename Buffer_accessor, convolution_type Conv_Dim>
+struct EigenConvolutionKernel;
+template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
+          typename Kernel_accessor, typename Buffer_accessor>
+struct EigenConvolutionKernel<Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor,
+                              Buffer_accessor, convolution_type::CONV1D> {
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      Local_accessor;
+  Local_accessor local_acc;
+  Evaluator device_evaluator;
+  Kernel_accessor kernel_filter;
+  Buffer_accessor buffer_acc;
+  internal::IndexMapper<Index, InputDims, 1, Evaluator::Layout> indexMapper;
+  const size_t kernelSize;
+  const cl::sycl::range<2> input_range;
+  EigenConvolutionKernel(Local_accessor local_acc_, Evaluator device_evaluator_, Kernel_accessor kernel_filter_,
+                         Buffer_accessor buffer_acc_,
+                         internal::IndexMapper<Index, InputDims, 1, Evaluator::Layout> indexMapper_,
+                         const size_t kernelSize_, const cl::sycl::range<2> input_range_)
+      : local_acc(local_acc_),
+        device_evaluator(device_evaluator_),
+        kernel_filter(kernel_filter_),
+        buffer_acc(buffer_acc_),
+        indexMapper(indexMapper_),
+        kernelSize(kernelSize_),
+        input_range(input_range_) {}
+
+  template <typename BooleanDim2>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool boundary_check(const BooleanDim2 boolean_check) const {
+    return boolean_check[0] && boolean_check[1];
+  }
+  void operator()(cl::sycl::nd_item<2> itemID) const {
+    auto buffer_ptr = buffer_acc;
+    auto kernel_ptr = kernel_filter;
+    // the required row to be calculated for each plane in shared memory
+    const size_t num_input = (itemID.get_local_range()[0] + kernelSize - 1);
+    const size_t plane_kernel_offset = itemID.get_local_id(1) * num_input;
+    const size_t input_offset = itemID.get_group(0) * itemID.get_local_range()[0];
+    const size_t plane_tensor_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(itemID.get_global_id(1));
+    /// fill the shared memory
+    for (size_t i = itemID.get_local_id(0); i < num_input; i += itemID.get_local_range()[0]) {
+      const size_t local_index = i + plane_kernel_offset;
+      const size_t tensor_index =
+          plane_tensor_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(i + input_offset);
+
+      local_acc[local_index] =
+          (((i + input_offset) < (input_range[0] + kernelSize - 1)) && itemID.get_global_id(1) < input_range[1])
+              ? device_evaluator.coeff(tensor_index)
+              : CoeffReturnType(0);
+    }
+
+    itemID.barrier(cl::sycl::access::fence_space::local_space);
+
+    // calculate the convolution // output start x
+    const size_t first_output_start = itemID.get_group(0) * (itemID.get_local_range()[0]);
+    if (boundary_check(itemID.get_global_id() < input_range)) {
+      CoeffReturnType result = static_cast<CoeffReturnType>(0);
+      const size_t index = plane_kernel_offset + itemID.get_local_id(0);
+      for (size_t k = 0; k < kernelSize; ++k) {
+        result += (local_acc[k + index] * kernel_ptr[k]);
+      }
+      const size_t tensor_index =
+          indexMapper.mapGpuOutputPlaneToTensorOutputOffset(itemID.get_global_id(1)) +
+          indexMapper.mapGpuOutputKernelToTensorOutputOffset(itemID.get_local_id(0) + first_output_start);
+      buffer_ptr[tensor_index] = result;
+    }
+  }
+};
+
+template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
+          typename Kernel_accessor, typename Buffer_accessor>
+struct EigenConvolutionKernel<Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor,
+                              Buffer_accessor, convolution_type::CONV2D> {
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      Local_accessor;
+  Local_accessor local_acc;
+  Evaluator device_evaluator;
+  Kernel_accessor kernel_filter;
+  Buffer_accessor buffer_acc;
+  internal::IndexMapper<Index, InputDims, 2, Evaluator::Layout> indexMapper;
+  const cl::sycl::range<2> kernel_size;
+  const cl::sycl::range<3> input_range;
+  EigenConvolutionKernel(Local_accessor local_acc_, Evaluator device_evaluator_, Kernel_accessor kernel_filter_,
+                         Buffer_accessor buffer_acc_,
+                         internal::IndexMapper<Index, InputDims, 2, Evaluator::Layout> indexMapper_,
+                         const cl::sycl::range<2> kernel_size_, const cl::sycl::range<3> input_range_)
+      : local_acc(local_acc_),
+        device_evaluator(device_evaluator_),
+        kernel_filter(kernel_filter_),
+        buffer_acc(buffer_acc_),
+        indexMapper(indexMapper_),
+        kernel_size(kernel_size_),
+        input_range(input_range_) {}
+  template <typename BooleanDim3>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool boundary_check(const BooleanDim3 boolean_check) const {
+    return boolean_check[0] && boolean_check[1] && boolean_check[2];
+  }
+
+  void operator()(cl::sycl::nd_item<3> itemID) const {
+    auto buffer_ptr = buffer_acc;
+    auto kernel_ptr = kernel_filter;
+    // the required row to be calculated for each plane in shared memory
+    const auto num_input = cl::sycl::range<2>{
+        (cl::sycl::range<2>(itemID.get_local_range()[0], itemID.get_local_range()[1]) + kernel_size - 1)};
+
+    const size_t plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(itemID.get_global_id(2));
+    const size_t plane_kernel_offset = itemID.get_local_id(2) * num_input[1];
+
+    const auto input_offset = cl::sycl::range<2>{itemID.get_group(0) * itemID.get_local_range()[0],
+                                                 itemID.get_group(1) * itemID.get_local_range()[1]};
+
+    // fill the local memory
+    bool in_range_dim2 = itemID.get_global_id(2) < input_range[2];
+    for (size_t j = itemID.get_local_id(1); j < num_input[1]; j += itemID.get_local_range()[1]) {
+      const size_t local_input_offset = num_input[0] * (j + plane_kernel_offset);
+      bool in_range_dim1 = ((j + input_offset[1]) < (input_range[1] + kernel_size[1] - 1));
+      for (size_t i = itemID.get_local_id(0); i < num_input[0]; i += itemID.get_local_range()[0]) {
+        const size_t local_index = i + local_input_offset;
+        const size_t tensor_index = plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(
+                                                             i + input_offset[0], j + input_offset[1]);
+        local_acc[local_index] =
+            (((i + input_offset[0]) < (input_range[0] + kernel_size[0] - 1)) && in_range_dim1 && in_range_dim2)
+                ? device_evaluator.coeff(tensor_index)
+                : CoeffReturnType(0);
+      }
+    }
+
+    itemID.barrier(cl::sycl::access::fence_space::local_space);
+
+    // output offset start for each thread
+    const auto output_offset = cl::sycl::range<2>{itemID.get_group(0) * itemID.get_local_range()[0],
+                                                  itemID.get_group(1) * itemID.get_local_range()[1]};
+
+    if (boundary_check(itemID.get_global_id() < input_range)) {
+      CoeffReturnType result = static_cast<CoeffReturnType>(0);
+
+      for (size_t j = 0; j < kernel_size[1]; j++) {
+        size_t kernel_offset = kernel_size[0] * j;
+        const size_t index =
+            (num_input[0] * (plane_kernel_offset + j + itemID.get_local_id(1))) + itemID.get_local_id(0);
+        for (size_t i = 0; i < kernel_size[0]; i++) {
+          result += (local_acc[i + index] * kernel_ptr[i + kernel_offset]);
+        }
+      }
+      const size_t tensor_index =
+          indexMapper.mapGpuOutputPlaneToTensorOutputOffset(itemID.get_global_id(2)) +
+          indexMapper.mapGpuOutputKernelToTensorOutputOffset(itemID.get_local_id(0) + output_offset[0],
+                                                             itemID.get_local_id(1) + output_offset[1]);
+
+      buffer_ptr[tensor_index] = result;
+    }
+  }
+};
+
+template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
+          typename Kernel_accessor, typename Buffer_accessor>
+struct EigenConvolutionKernel<Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor,
+                              Buffer_accessor, convolution_type::CONV3D> {
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      Local_accessor;
+  Local_accessor local_acc;
+  Evaluator device_evaluator;
+  Kernel_accessor kernel_filter;
+  Buffer_accessor buffer_acc;
+  internal::IndexMapper<Index, InputDims, 3, Evaluator::Layout> indexMapper;
+  const cl::sycl::range<3> kernel_size;
+  const cl::sycl::range<3> input_range;
+  const size_t numP;
+
+  EigenConvolutionKernel(Local_accessor local_acc_, Evaluator device_evaluator_, Kernel_accessor kernel_filter_,
+                         Buffer_accessor buffer_acc_,
+                         internal::IndexMapper<Index, InputDims, 3, Evaluator::Layout> indexMapper_,
+                         const cl::sycl::range<3> kernel_size_, const cl::sycl::range<3> input_range_,
+                         const size_t numP_)
+      : local_acc(local_acc_),
+        device_evaluator(device_evaluator_),
+        kernel_filter(kernel_filter_),
+        buffer_acc(buffer_acc_),
+        indexMapper(indexMapper_),
+        kernel_size(kernel_size_),
+        input_range(input_range_),
+        numP(numP_) {}
+  template <typename BooleanDim3>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool boundary_check(const BooleanDim3 boolean_check) const {
+    return boolean_check[0] && boolean_check[1] && boolean_check[2];
+  }
+  void operator()(cl::sycl::nd_item<3> itemID) const {
+    auto buffer_ptr = buffer_acc;
+    auto kernel_ptr = kernel_filter;
+    const auto num_input = cl::sycl::range<3>{itemID.get_local_range() + kernel_size - 1};
+
+    const auto input_offset = cl::sycl::range<3>{itemID.get_group().get_id() * itemID.get_local_range()};
+
+    const auto output_offset =
+        cl::sycl::range<3>{itemID.get_group().get_id() * itemID.get_local_range() + itemID.get_local_id()};
+
+    for (size_t p = 0; p < numP; p++) {
+      /// fill the shared memory
+      const size_t plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
+      for (size_t k = itemID.get_local_id(2); k < num_input[2]; k += itemID.get_local_range()[2]) {
+        size_t local_index_dim2 = num_input[0] * num_input[1] * k;
+        bool cond_k_dim = (k + input_offset[2] < (input_range[2] + kernel_size[2] - 1));
+        for (size_t j = itemID.get_local_id(1); j < num_input[1]; j += itemID.get_local_range()[1]) {
+          bool cond_j_dim = cond_k_dim && (j + input_offset[1] < (input_range[1] + kernel_size[1] - 1));
+          size_t local_index_dim1 = (num_input[0] * j) + local_index_dim2;
+          for (size_t i = itemID.get_local_id(0); i < num_input[0]; i += itemID.get_local_range()[0]) {
+            bool conds = cond_j_dim && (i + input_offset[0] < (input_range[0] + kernel_size[0] - 1));
+            const size_t local_index = local_index_dim1 + i;
+            const size_t tensor_index =
+                plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(
+                                         i + input_offset[0], j + input_offset[1], k + input_offset[2]);
+            local_acc[local_index] = conds ? device_evaluator.coeff(tensor_index) : CoeffReturnType(0);
+          }
+        }
+      }
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+
+      // calculate the convolution
+
+      if (boundary_check(itemID.get_global_id() < input_range)) {
+        CoeffReturnType result = static_cast<CoeffReturnType>(0);
+        for (size_t k = 0; k < kernel_size[2]; k++) {
+          for (size_t j = 0; j < kernel_size[1]; j++) {
+            for (size_t i = 0; i < kernel_size[0]; i++) {
+              const size_t kernel_index = i + kernel_size[0] * (j + kernel_size[1] * k);
+              const size_t local_index =
+                  ((i + itemID.get_local_id(0)) +
+                   num_input[0] * ((j + itemID.get_local_id(1)) + num_input[1] * (k + itemID.get_local_id(2))));
+
+              result += (local_acc[local_index] * kernel_ptr[kernel_index]);
+            }
+          }
+        }
+        const size_t tensor_index =
+            indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p) +
+            indexMapper.mapGpuOutputKernelToTensorOutputOffset(output_offset[0], output_offset[1], output_offset[2]);
+        buffer_ptr[tensor_index] = result;
+      }
+
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+    }
+  }
+};
+
+template <typename Indices, typename InputArgType, typename KernelArgType>
+struct TensorEvaluator<const TensorConvolutionOp<Indices, InputArgType, KernelArgType>, Eigen::SyclDevice> {
+  typedef TensorConvolutionOp<Indices, InputArgType, KernelArgType> XprType;
+
+  static constexpr int NumDims =
+      internal::array_size<typename TensorEvaluator<InputArgType, Eigen::SyclDevice>::Dimensions>::value;
+  static constexpr int NumKernelDims = internal::array_size<Indices>::value;
+  typedef typename XprType::Index Index;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename TensorEvaluator<KernelArgType, Eigen::SyclDevice>::Dimensions KernelDimensions;
+  typedef const Eigen::SyclDevice Device;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Eigen::SyclDevice>::type PacketReturnType;
+  typedef typename InputArgType::Scalar Scalar;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Eigen::SyclDevice> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  typedef StorageMemory<const CoeffReturnType, Eigen::SyclDevice> KernelStorage;
+
+  static constexpr int Layout = TensorEvaluator<InputArgType, Eigen::SyclDevice>::Layout;
+  enum {
+    IsAligned = TensorEvaluator<InputArgType, Eigen::SyclDevice>::IsAligned &
+                TensorEvaluator<KernelArgType, Eigen::SyclDevice>::IsAligned,
+    PacketAccess = false,
+    BlockAccess = false,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  TensorEvaluator(const XprType &op, const Eigen::SyclDevice &device)
+      : m_inputImpl(op.inputExpression(), device),
+        m_kernelArg(op.kernelExpression()),
+        m_kernelImpl(op.kernelExpression(), device),
+        m_indices(op.indices()),
+        m_buf(nullptr),
+        m_kernel(nullptr),
+        m_local_kernel(false),
+        m_device(device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<InputArgType, Eigen::SyclDevice>::Layout) ==
+                         static_cast<int>(TensorEvaluator<KernelArgType, Eigen::SyclDevice>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    const typename TensorEvaluator<InputArgType, Eigen::SyclDevice>::Dimensions &input_dims = m_inputImpl.dimensions();
+    const typename TensorEvaluator<KernelArgType, Eigen::SyclDevice>::Dimensions &kernel_dims =
+        m_kernelImpl.dimensions();
+
+    m_dimensions = m_inputImpl.dimensions();
+    for (int i = 0; i < NumKernelDims; ++i) {
+      const Index index = op.indices()[i];
+      const Index input_dim = input_dims[index];
+      const Index kernel_dim = kernel_dims[i];
+      const Index result_dim = input_dim - kernel_dim + 1;
+      m_dimensions[index] = result_dim;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC const Dimensions &dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    preloadKernel();
+    m_inputImpl.evalSubExprsIfNeeded(nullptr);
+    if (data) {
+      executeEval(data);
+      return false;
+    } else {
+      m_buf = (EvaluatorPointerType)m_device.get(
+          (Scalar *)m_device.allocate_temp(dimensions().TotalSize() * sizeof(Scalar)));
+      executeEval(m_buf);
+      return true;
+    }
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_inputImpl.cleanup();
+    if (m_buf) {
+      m_device.deallocate_temp(m_buf);
+      m_buf = nullptr;
+    }
+    if (m_local_kernel) {
+      m_device.deallocate_temp(m_kernel);
+      m_local_kernel = false;
+    }
+    m_kernel = nullptr;
+  }
+  /// used by sycl in order to build the sycl buffer
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Device &device() const { return m_device; }
+  /// used by sycl in order to build the sycl buffer
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return m_buf; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void preloadKernel() {
+    // Don't make a local copy of the kernel unless we have to (i.e. it's an
+    // expression that needs to be evaluated)
+    typename KernelStorage::Type in_place = m_kernelImpl.data();
+    if (in_place) {
+      m_kernel = in_place;
+      m_local_kernel = false;
+    } else {
+      ptrdiff_t kernel_sz = m_kernelImpl.dimensions().TotalSize() * sizeof(Scalar);
+      EvaluatorPointerType local = (EvaluatorPointerType)m_device.get((Scalar *)m_device.allocate_temp(kernel_sz));
+      typedef TensorEvalToOp<const KernelArgType> EvalTo;
+      EvalTo evalToTmp(m_device.get(local), m_kernelArg);
+      const bool PacketAccess = internal::IsVectorizable<Eigen::SyclDevice, KernelArgType>::value;
+      internal::TensorExecutor<const EvalTo, Eigen::SyclDevice, PacketAccess>::run(evalToTmp, m_device);
+      m_kernel = local;
+      m_local_kernel = true;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void executeEval(EvaluatorPointerType data) const {
+    typedef TensorEvaluator<InputArgType, Eigen::SyclDevice> InputEvaluator;
+    typedef typename InputEvaluator::Dimensions InputDims;
+    switch (NumKernelDims) {
+      case 1: {
+        const size_t numX = dimensions()[m_indices[0]];
+        const size_t numP = dimensions().TotalSize() / numX;
+        const auto input_dim = std::array<size_t, 2>{numX, numP};
+        auto global_range = cl::sycl::range<2>{1, 1};
+        auto local_range = cl::sycl::range<2>{1, 1};
+        const size_t kernel_size = m_kernelImpl.dimensions().TotalSize();
+
+        m_device.parallel_for_setup(input_dim, global_range, local_range);
+        const size_t local_memory_size = (local_range[0] + kernel_size - 1) * (local_range[1]);
+        eigen_assert(static_cast<unsigned long>(local_memory_size) <= m_device.sharedMemPerBlock());
+        const array<Index, 1> indices{{m_indices[0]}};
+        const array<Index, 1> kernel_dims{{m_kernelImpl.dimensions()[0]}};
+        internal::IndexMapper<Index, InputDims, 1, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
+
+        typedef EigenConvolutionKernel<InputEvaluator, CoeffReturnType, Scalar, Index, InputDims,
+                                       typename KernelStorage::Type, EvaluatorPointerType, convolution_type::CONV1D>
+            ConvKernel;
+
+        m_device
+            .template binary_kernel_launcher<CoeffReturnType, ConvKernel>(
+                m_inputImpl, m_kernel, data, cl::sycl::nd_range<2>(global_range, local_range), local_memory_size,
+                indexMapper, kernel_size, cl::sycl::range<2>(input_dim[0], input_dim[1]))
+            .wait();
+        break;
+      }
+
+      case 2: {
+        auto kernel_index = std::array<size_t, 2>{static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 1,
+                                                  static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 0};
+        auto kernel_size = cl::sycl::range<2>{(size_t)m_kernelImpl.dimensions()[kernel_index[0]],
+                                              (size_t)m_kernelImpl.dimensions()[kernel_index[1]]};
+        const size_t numX = dimensions()[m_indices[kernel_index[0]]];
+        const size_t numY = dimensions()[m_indices[kernel_index[1]]];
+        const size_t numP = dimensions().TotalSize() / (numX * numY);
+        auto input_dim = std::array<size_t, 3>{numX, numY, numP};
+
+        auto global_range = cl::sycl::range<3>{1, 1, 1};
+        auto local_range = cl::sycl::range<3>{1, 1, 1};
+
+        m_device.parallel_for_setup(input_dim, global_range, local_range);
+
+        const size_t local_memory_size =
+            (local_range[0] + kernel_size[0] - 1) * (local_range[1] + kernel_size[1] - 1) * local_range[2];
+        eigen_assert(static_cast<unsigned long>(local_memory_size) <= m_device.sharedMemPerBlock());
+        const array<Index, 2> indices{{m_indices[kernel_index[0]], m_indices[kernel_index[1]]}};
+        const array<Index, 2> kernel_dims{
+            {m_kernelImpl.dimensions()[kernel_index[0]], m_kernelImpl.dimensions()[kernel_index[1]]}};
+        internal::IndexMapper<Index, InputDims, 2, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
+        typedef EigenConvolutionKernel<InputEvaluator, CoeffReturnType, Scalar, Index, InputDims,
+                                       typename KernelStorage::Type, EvaluatorPointerType, convolution_type::CONV2D>
+            ConvKernel;
+        m_device
+            .template binary_kernel_launcher<CoeffReturnType, ConvKernel>(
+                m_inputImpl, m_kernel, data, cl::sycl::nd_range<3>(global_range, local_range), local_memory_size,
+                indexMapper, kernel_size, cl::sycl::range<3>{input_dim[0], input_dim[1], input_dim[2]})
+            .wait();
+        break;
+      }
+
+      case 3: {
+        auto kernel_index = std::array<size_t, 3>{static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 2,
+                                                  static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 1,
+                                                  static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 2 : 0};
+
+        auto kernel_size = cl::sycl::range<3>{(size_t)m_kernelImpl.dimensions()[kernel_index[0]],
+                                              (size_t)m_kernelImpl.dimensions()[kernel_index[1]],
+                                              (size_t)m_kernelImpl.dimensions()[kernel_index[2]]};
+
+        const size_t numX = dimensions()[m_indices[kernel_index[0]]];
+        const size_t numY = dimensions()[m_indices[kernel_index[1]]];
+        const size_t numZ = dimensions()[m_indices[kernel_index[2]]];
+        auto input_dim = std::array<size_t, 3>{numX, numY, numZ};
+        const size_t numP = dimensions().TotalSize() / (numX * numY * numZ);
+
+        const array<Index, 3> indices{
+            {m_indices[kernel_index[0]], m_indices[kernel_index[1]], m_indices[kernel_index[2]]}};
+        const array<Index, 3> kernel_dims{{m_kernelImpl.dimensions()[kernel_index[0]],
+                                           m_kernelImpl.dimensions()[kernel_index[1]],
+                                           m_kernelImpl.dimensions()[kernel_index[2]]}};
+
+        internal::IndexMapper<Index, InputDims, 3, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
+
+        auto global_range = cl::sycl::range<3>{1, 1, 1};
+        auto local_range = cl::sycl::range<3>{1, 1, 1};
+
+        m_device.parallel_for_setup(input_dim, global_range, local_range);
+        auto local_memory_range = (local_range + kernel_size - 1);
+        const size_t local_memory_size = local_memory_range[0] * local_memory_range[1] * local_memory_range[2];
+
+        eigen_assert(static_cast<unsigned long>(local_memory_size) <= m_device.sharedMemPerBlock());
+        typedef EigenConvolutionKernel<InputEvaluator, CoeffReturnType, Scalar, Index, InputDims,
+                                       typename KernelStorage::Type, EvaluatorPointerType, convolution_type::CONV3D>
+            ConvKernel;
+        m_device
+            .template binary_kernel_launcher<CoeffReturnType, ConvKernel>(
+                m_inputImpl, m_kernel, data, cl::sycl::nd_range<3>(global_range, local_range), local_memory_size,
+                indexMapper, kernel_size, cl::sycl::range<3>(input_dim[0], input_dim[1], input_dim[2]), numP)
+            .wait();
+        break;
+      }
+
+      default: {
+        EIGEN_STATIC_ASSERT((NumKernelDims >= 1 && NumKernelDims <= 3),
+                            THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    eigen_assert(m_buf != nullptr);
+    eigen_assert(index < m_dimensions.TotalSize());
+    return m_buf[index];
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(const Index index) const {
+    eigen_assert(m_buf != nullptr);
+    eigen_assert(index < m_dimensions.TotalSize());
+    return internal::ploadt<PacketReturnType, LoadMode>(m_buf + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // TODO(rmlarsen): For now, this is just a copy of the CPU cost
+    // model.
+    const double kernel_size = m_kernelImpl.dimensions().TotalSize();
+    // We ignore the use of fused multiply-add.
+    const double convolve_compute_cost = TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>();
+    const double firstIndex_compute_cost =
+        NumDims *
+        (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
+    return TensorOpCost(0, 0, firstIndex_compute_cost, vectorized, PacketSize) +
+           kernel_size * (m_inputImpl.costPerCoeff(vectorized) + m_kernelImpl.costPerCoeff(vectorized) +
+                          TensorOpCost(0, 0, convolve_compute_cost, vectorized, PacketSize));
+  }
+
+ private:
+  // No assignment (copies are needed by the kernels)
+  TensorEvaluator &operator=(const TensorEvaluator &) = delete;
+  TensorEvaluator<InputArgType, Eigen::SyclDevice> m_inputImpl;
+  KernelArgType m_kernelArg;
+  TensorEvaluator<KernelArgType, Eigen::SyclDevice> m_kernelImpl;
+  Indices m_indices;
+  Dimensions m_dimensions;
+  EvaluatorPointerType m_buf;
+  typename KernelStorage::Type m_kernel;
+  bool m_local_kernel;
+  const Eigen::SyclDevice EIGEN_DEVICE_REF m_device;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CONVOLUTION_SYCL_H
diff --git a/contrib/Eigen/src/Tensor/TensorCostModel.h b/contrib/Eigen/src/Tensor/TensorCostModel.h
new file mode 100644
index 0000000..5cb986a
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorCostModel.h
@@ -0,0 +1,251 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_COST_MODEL_H
+#define EIGEN_TENSOR_TENSOR_COST_MODEL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+// Class storing the cost of evaluating a tensor expression in terms of the
+// estimated number of operand bytes loaded, bytes stored, and compute cycles.
+class TensorOpCost {
+ public:
+  // TODO(rmlarsen): Fix the scalar op costs in Eigen proper. Even a simple
+  // model based on minimal reciprocal throughput numbers from Intel or
+  // Agner Fog's tables would be better than what is there now.
+  template <typename ArgType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int MulCost() {
+    return internal::functor_traits<internal::scalar_product_op<ArgType, ArgType> >::Cost;
+  }
+  template <typename ArgType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int AddCost() {
+    return internal::functor_traits<internal::scalar_sum_op<ArgType> >::Cost;
+  }
+  template <typename ArgType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int DivCost() {
+    return internal::functor_traits<internal::scalar_quotient_op<ArgType, ArgType> >::Cost;
+  }
+  template <typename ArgType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int ModCost() {
+    return internal::functor_traits<internal::scalar_mod_op<ArgType> >::Cost;
+  }
+  template <typename SrcType, typename TargetType>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int CastCost() {
+    return internal::functor_traits<internal::scalar_cast_op<SrcType, TargetType> >::Cost;
+  }
+
+  constexpr EIGEN_DEVICE_FUNC TensorOpCost() = default;
+  constexpr EIGEN_DEVICE_FUNC TensorOpCost(double bytes_loaded, double bytes_stored, double compute_cycles)
+      : bytes_loaded_(bytes_loaded), bytes_stored_(bytes_stored), compute_cycles_(compute_cycles) {}
+
+  EIGEN_DEVICE_FUNC TensorOpCost(double bytes_loaded, double bytes_stored, double compute_cycles, bool vectorized,
+                                 double packet_size)
+      : bytes_loaded_(bytes_loaded),
+        bytes_stored_(bytes_stored),
+        compute_cycles_(vectorized ? compute_cycles / packet_size : compute_cycles) {
+    eigen_assert(bytes_loaded >= 0 && (numext::isfinite)(bytes_loaded));
+    eigen_assert(bytes_stored >= 0 && (numext::isfinite)(bytes_stored));
+    eigen_assert(compute_cycles >= 0 && (numext::isfinite)(compute_cycles));
+  }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bytes_loaded() const { return bytes_loaded_; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bytes_stored() const { return bytes_stored_; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double compute_cycles() const { return compute_cycles_; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double total_bytes() const { return bytes_loaded_ + bytes_stored_; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double total_cost(double load_cost, double store_cost,
+                                                                    double compute_cost) const {
+    return load_cost * bytes_loaded_ + store_cost * bytes_stored_ + compute_cost * compute_cycles_;
+  }
+
+  // Drop memory access component. Intended for cases when memory accesses are
+  // sequential or are completely masked by computations.
+  EIGEN_DEVICE_FUNC void dropMemoryCost() {
+    bytes_loaded_ = 0;
+    bytes_stored_ = 0;
+  }
+
+  // TODO(rmlarsen): Define min in terms of total cost, not elementwise.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost cwiseMin(const TensorOpCost& rhs) const {
+    double bytes_loaded = numext::mini(bytes_loaded_, rhs.bytes_loaded());
+    double bytes_stored = numext::mini(bytes_stored_, rhs.bytes_stored());
+    double compute_cycles = numext::mini(compute_cycles_, rhs.compute_cycles());
+    return TensorOpCost(bytes_loaded, bytes_stored, compute_cycles);
+  }
+
+  // TODO(rmlarsen): Define max in terms of total cost, not elementwise.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost cwiseMax(const TensorOpCost& rhs) const {
+    double bytes_loaded = numext::maxi(bytes_loaded_, rhs.bytes_loaded());
+    double bytes_stored = numext::maxi(bytes_stored_, rhs.bytes_stored());
+    double compute_cycles = numext::maxi(compute_cycles_, rhs.compute_cycles());
+    return TensorOpCost(bytes_loaded, bytes_stored, compute_cycles);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost& operator+=(const TensorOpCost& rhs) {
+    bytes_loaded_ += rhs.bytes_loaded();
+    bytes_stored_ += rhs.bytes_stored();
+    compute_cycles_ += rhs.compute_cycles();
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost& operator*=(double rhs) {
+    bytes_loaded_ *= rhs;
+    bytes_stored_ *= rhs;
+    compute_cycles_ *= rhs;
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend TensorOpCost operator+(TensorOpCost lhs, const TensorOpCost& rhs) {
+    lhs += rhs;
+    return lhs;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend TensorOpCost operator*(TensorOpCost lhs, double rhs) {
+    lhs *= rhs;
+    return lhs;
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend TensorOpCost operator*(double lhs, TensorOpCost rhs) {
+    rhs *= lhs;
+    return rhs;
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const TensorOpCost& tc) {
+    return os << "[bytes_loaded = " << tc.bytes_loaded() << ", bytes_stored = " << tc.bytes_stored()
+              << ", compute_cycles = " << tc.compute_cycles() << "]";
+  }
+
+ private:
+  double bytes_loaded_ = 0;
+  double bytes_stored_ = 0;
+  double compute_cycles_ = 0;
+};
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief A cost model used to limit the number of threads used for evaluating
+ * tensor expressions.
+ *
+ * Uses a roofline model: cost = max(memory_time, compute_time) instead of
+ * summing them. This avoids overestimating cost for balanced workloads.
+ * Memory-bound operations are capped at a limited number of threads to
+ * avoid wasting cycles competing for shared memory bandwidth.
+ */
+template <typename Device>
+class TensorCostModel {
+ public:
+  // Scaling from Eigen compute cost to device cycles.
+  static constexpr int kDeviceCyclesPerComputeCycle = 1;
+
+  // Thread overhead in device cycles. ~8us at 3GHz.
+  // Minimum total work to justify thread pool dispatch.
+  static constexpr int kStartupCycles = 25000;
+  // Minimum work per thread to amortize dispatch and synchronization overhead.
+  static constexpr int kPerThreadCycles = 25000;
+  static constexpr int kTaskSize = 40000;
+
+  // Memory bandwidth saturation: on typical multi-socket servers, 2-6 cores
+  // saturate DRAM bandwidth. 4 is a conservative default.
+  static constexpr int kMemBandwidthSaturationThreads = 4;
+
+  // If memory_time / compute_time exceeds this ratio, the op is memory-bound.
+  // With vectorized costs (AVX2, PacketSize=8), typical ratios are:
+  //   Add/Mul (2 loads + 1 store): mem/comp = 6.0
+  //   FMA (3 loads + 1 store):     mem/comp = 4.0
+  //   ReLU max(x,0) (1 load + 1 store): mem/comp = 4.0
+  //   Polynomial 3rd-order (3 loads + 1 store, 6 ops): mem/comp = 1.3
+  //   Exp (1 load + 1 store, ~8 ops): mem/comp = 0.5
+  // Threshold of 2.0 cleanly separates memory-bound (>=4) from compute-bound.
+  static constexpr double kMemBoundThreshold = 2.0;
+
+  // Data sets larger than this are assumed to be DRAM-resident.
+  // Below this threshold, data is likely L2-cache-resident and benefits from
+  // high per-core L2 bandwidth, so no bandwidth saturation cap is applied.
+  static constexpr double kDramThresholdBytes = 1024.0 * 1024.0;
+
+  // Returns the number of threads in [1:max_threads] to use for
+  // evaluating an expression with the given output size and cost per
+  // coefficient.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int numThreads(double output_size, const TensorOpCost& cost_per_coeff,
+                                                              int max_threads) {
+    if (max_threads <= 1) return 1;
+
+    double mem = memoryTime(cost_per_coeff);
+    double comp = computeTime(cost_per_coeff);
+    double per_coeff = numext::maxi(mem, comp);
+    double total = output_size * per_coeff;
+
+    // Not enough total work to justify thread pool dispatch.
+    if (total < kStartupCycles) return 1;
+
+    // Each thread needs at least kPerThreadCycles of work to
+    // amortize dispatch and synchronization overhead.
+    double threads = total / kPerThreadCycles;
+    // Guard against integer overflow.
+    threads = numext::mini<double>(threads, GenericNumTraits<int>::highest());
+    int candidate = numext::mini(max_threads, numext::maxi<int>(1, static_cast<int>(threads)));
+
+    // Memory-bound ops on DRAM-resident data: cap at bandwidth saturation.
+    // Cache-resident data has high per-core L2 bandwidth, so no cap needed.
+    //
+    // The total-traffic proxy below overestimates the working set whenever an
+    // operand is reused (e.g. broadcasted): every output coefficient charges a
+    // fresh load, so a 1xN broadcast can show up as MxN bytes even though the
+    // live data is N. A working-set-aware estimate would need each evaluator to
+    // surface its unique-operand footprint; until that exists we accept a small
+    // bias toward over-capping for reuse-heavy expressions.
+    const int mem_bandwidth_saturation_threads = kMemBandwidthSaturationThreads;
+    if (candidate > mem_bandwidth_saturation_threads) {
+      bool is_memory_bound = (comp > 0) ? (mem / comp > kMemBoundThreshold) : (mem > 0);
+      if (is_memory_bound) {
+        double total_bytes = output_size * cost_per_coeff.total_bytes();
+        if (total_bytes > kDramThresholdBytes) {
+          candidate = numext::mini(candidate, mem_bandwidth_saturation_threads);
+        }
+      }
+    }
+    return candidate;
+  }
+
+  // taskSize assesses parallel task size.
+  // Value of 1.0 means ideal parallel task size. Values < 1.0 mean that task
+  // granularity needs to be increased to mitigate parallelization overheads.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double taskSize(double output_size, const TensorOpCost& cost_per_coeff) {
+    return totalCost(output_size, cost_per_coeff) / kTaskSize;
+  }
+
+  // Roofline model: cost is the max of memory time and compute time.
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double totalCost(double output_size,
+                                                                const TensorOpCost& cost_per_coeff) {
+    double mem_cost = memoryTime(cost_per_coeff);
+    double comp_cost = computeTime(cost_per_coeff);
+    return output_size * numext::maxi(mem_cost, comp_cost);
+  }
+
+ private:
+  // Effective sustained bandwidth cost in cycles/byte.
+  // ~1/16 = 0.0625 cycles/byte represents L3/DRAM streaming bandwidth
+  // on modern CPUs (~16 bytes/cycle single-core sustained throughput).
+  // For L1/L2-resident data, compute typically dominates anyway.
+  static constexpr double kByteCost = 1.0 / 16.0;
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double memoryTime(const TensorOpCost& cost) {
+    return cost.total_bytes() * kByteCost;
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double computeTime(const TensorOpCost& cost) {
+    return cost.compute_cycles() * kDeviceCyclesPerComputeCycle;
+  }
+};
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_COST_MODEL_H
diff --git a/contrib/Eigen/src/Tensor/TensorCustomOp.h b/contrib/Eigen/src/Tensor/TensorCustomOp.h
new file mode 100644
index 0000000..1523f45
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorCustomOp.h
@@ -0,0 +1,356 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_CUSTOM_OP_H
+#define EIGEN_TENSOR_TENSOR_CUSTOM_OP_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename CustomUnaryFunc, typename XprType>
+struct traits<TensorCustomUnaryOp<CustomUnaryFunc, XprType> > {
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::StorageKind StorageKind;
+  typedef typename XprType::Index Index;
+  // The functor's dimensions() determines the output shape, so the rank of the
+  // result may differ from the rank of the input. The argument is spelled
+  // exactly as in the evaluator's call so both resolve to the same overload.
+  using CustomDimensions = remove_all_t<decltype(std::declval<const CustomUnaryFunc&>().dimensions(
+      std::declval<const remove_all_t<typename XprType::Nested>&>()))>;
+  static constexpr ptrdiff_t CustomRank = array_size<CustomDimensions>::value;
+  static_assert(CustomRank >= 0,
+                "The dimensions() method of a custom tensor functor must return a fixed-rank "
+                "array-like type such as DSizes<Index, Rank>.");
+  // Clamped so a failed assertion doesn't cascade into DSizes<Index, -1> errors.
+  static constexpr int NumDimensions = CustomRank < 0 ? 1 : static_cast<int>(CustomRank);
+  static constexpr int Layout = traits<XprType>::Layout;
+  typedef typename traits<XprType>::PointerType PointerType;
+  enum { Flags = 0 };
+};
+
+template <typename CustomUnaryFunc, typename XprType>
+struct eval<TensorCustomUnaryOp<CustomUnaryFunc, XprType>, Eigen::Dense> {
+  typedef const TensorCustomUnaryOp<CustomUnaryFunc, XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor custom class.
+ */
+template <typename CustomUnaryFunc, typename XprType>
+class TensorCustomUnaryOp : public TensorBase<TensorCustomUnaryOp<CustomUnaryFunc, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename internal::traits<TensorCustomUnaryOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename internal::ref_selector<TensorCustomUnaryOp>::non_const_type Nested;
+  typedef typename internal::traits<TensorCustomUnaryOp>::StorageKind StorageKind;
+  typedef typename internal::traits<TensorCustomUnaryOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCustomUnaryOp(const XprType& expr, const CustomUnaryFunc& func)
+      : m_expr(expr), m_func(func) {}
+
+  EIGEN_DEVICE_FUNC const CustomUnaryFunc& func() const { return m_func; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_expr; }
+
+ protected:
+  typename XprType::Nested m_expr;
+  const CustomUnaryFunc m_func;
+};
+
+// Eval as rvalue
+template <typename CustomUnaryFunc, typename XprType, typename Device>
+struct TensorEvaluator<const TensorCustomUnaryOp<CustomUnaryFunc, XprType>, Device> {
+  typedef TensorCustomUnaryOp<CustomUnaryFunc, XprType> ArgType;
+  typedef typename internal::traits<ArgType>::Index Index;
+  static constexpr int NumDims = internal::traits<ArgType>::NumDimensions;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef std::remove_const_t<typename ArgType::Scalar> Scalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<XprType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    // The custom op is eagerly evaluated into a dense buffer (m_result), so
+    // blocks and raw storage can be served straight from it, exactly like
+    // TensorForcedEvalOp. Without these flags a custom op disables tiled
+    // evaluation for any expression containing it and hides its buffer from
+    // consumers with data()-based fast paths.
+    BlockAccess = internal::is_arithmetic<CoeffReturnType>::value,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = true
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  // The functor's dimensions() may return an index type that promotes to Index.
+  EIGEN_STRONG_INLINE TensorEvaluator(const ArgType& op, const Device& device)
+      : m_dimensions(op.func().dimensions(op.expression())), m_op(op), m_device(device), m_result(nullptr) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    if (data) {
+      evalTo(data);
+      return false;
+    } else {
+      m_result = static_cast<EvaluatorPointerType>(
+          m_device.get((CoeffReturnType*)m_device.allocate_temp(dimensions().TotalSize() * sizeof(CoeffReturnType))));
+      evalTo(m_result);
+      return true;
+    }
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    if (m_result) {
+      m_device.deallocate_temp(m_result);
+      m_result = nullptr;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_result[index]; }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // TODO(rmlarsen): Extend CustomOp API to return its cost estimate.
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_result != nullptr);
+    return TensorBlock::materialize(m_result, m_dimensions, desc, scratch);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_result; }
+
+ protected:
+  void evalTo(EvaluatorPointerType data) {
+    TensorMap<Tensor<CoeffReturnType, NumDims, Layout, Index> > result(m_device.get(data), m_dimensions);
+    m_op.func().eval(m_op.expression(), result, m_device);
+  }
+
+  Dimensions m_dimensions;
+  const ArgType m_op;
+  const Device EIGEN_DEVICE_REF m_device;
+  EvaluatorPointerType m_result;
+};
+
+/** \class TensorCustomBinaryOp
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor custom class.
+ *
+ *
+ */
+namespace internal {
+template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
+struct traits<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType> > {
+  typedef typename internal::promote_storage_type<typename LhsXprType::Scalar, typename RhsXprType::Scalar>::ret Scalar;
+  typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
+                                                  typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
+  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
+                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
+  typedef
+      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
+  // The functor's dimensions() determines the output shape, so the rank of the
+  // result may differ from the ranks of the inputs. The arguments are spelled
+  // exactly as in the evaluator's call so both resolve to the same overload.
+  using CustomDimensions = remove_all_t<decltype(std::declval<const CustomBinaryFunc&>().dimensions(
+      std::declval<const remove_all_t<typename LhsXprType::Nested>&>(),
+      std::declval<const remove_all_t<typename RhsXprType::Nested>&>()))>;
+  static constexpr ptrdiff_t CustomRank = array_size<CustomDimensions>::value;
+  static_assert(CustomRank >= 0,
+                "The dimensions() method of a custom tensor functor must return a fixed-rank "
+                "array-like type such as DSizes<Index, Rank>.");
+  // Clamped so a failed assertion doesn't cascade into DSizes<Index, -1> errors.
+  static constexpr int NumDimensions = CustomRank < 0 ? 1 : static_cast<int>(CustomRank);
+  static constexpr int Layout = traits<LhsXprType>::Layout;
+  typedef std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
+                             typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>
+      PointerType;
+  enum { Flags = 0 };
+};
+
+template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
+struct eval<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>, Eigen::Dense> {
+  typedef const TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>& type;
+};
+
+}  // end namespace internal
+
+template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
+class TensorCustomBinaryOp
+    : public TensorBase<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename internal::traits<TensorCustomBinaryOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename internal::traits<TensorCustomBinaryOp>::CoeffReturnType CoeffReturnType;
+  typedef typename internal::ref_selector<TensorCustomBinaryOp>::non_const_type Nested;
+  typedef typename internal::traits<TensorCustomBinaryOp>::StorageKind StorageKind;
+  typedef typename internal::traits<TensorCustomBinaryOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCustomBinaryOp(const LhsXprType& lhs, const RhsXprType& rhs,
+                                                             const CustomBinaryFunc& func)
+
+      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_func(func) {}
+
+  EIGEN_DEVICE_FUNC const CustomBinaryFunc& func() const { return m_func; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
+    return m_lhs_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
+    return m_rhs_xpr;
+  }
+
+ protected:
+  typename LhsXprType::Nested m_lhs_xpr;
+  typename RhsXprType::Nested m_rhs_xpr;
+  const CustomBinaryFunc m_func;
+};
+
+// Eval as rvalue
+template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType, typename Device>
+struct TensorEvaluator<const TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>, Device> {
+  typedef TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType> XprType;
+  typedef typename internal::traits<XprType>::Index Index;
+  static constexpr int NumDims = internal::traits<XprType>::NumDimensions;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+
+  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<LhsXprType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    // See the unary evaluator above: serve blocks and raw storage from the
+    // eagerly materialized buffer, like TensorForcedEvalOp.
+    BlockAccess = internal::is_arithmetic<CoeffReturnType>::value,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = true
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  // The functor's dimensions() may return an index type that promotes to Index.
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_dimensions(op.func().dimensions(op.lhsExpression(), op.rhsExpression())),
+        m_op(op),
+        m_device(device),
+        m_result(nullptr) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    if (data) {
+      evalTo(data);
+      return false;
+    } else {
+      m_result = static_cast<EvaluatorPointerType>(
+          m_device.get((CoeffReturnType*)m_device.allocate_temp(dimensions().TotalSize() * sizeof(CoeffReturnType))));
+      evalTo(m_result);
+      return true;
+    }
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    if (m_result != nullptr) {
+      m_device.deallocate_temp(m_result);
+      m_result = nullptr;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_result[index]; }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // TODO(rmlarsen): Extend CustomOp API to return its cost estimate.
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_result != nullptr);
+    return TensorBlock::materialize(m_result, m_dimensions, desc, scratch);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_result; }
+
+ protected:
+  void evalTo(EvaluatorPointerType data) {
+    // The Output type handed to eval() is a compatibility surface: functors are
+    // compiled against a DenseIndex-typed map, so widen its index type only
+    // when the expressions' promoted Index is strictly wider than DenseIndex.
+    // DenseIndex must stay the first argument: promote_index_type keeps that
+    // one on a tie, which preserves the map type for equal-width distinct
+    // index types such as long long versus long.
+    using MapIndex = typename internal::promote_index_type<DenseIndex, Index>::type;
+    TensorMap<Tensor<CoeffReturnType, NumDims, Layout, MapIndex> > result(m_device.get(data), m_dimensions);
+    m_op.func().eval(m_op.lhsExpression(), m_op.rhsExpression(), result, m_device);
+  }
+
+  Dimensions m_dimensions;
+  const XprType m_op;
+  const Device EIGEN_DEVICE_REF m_device;
+  EvaluatorPointerType m_result;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_CUSTOM_OP_H
diff --git a/contrib/Eigen/src/Tensor/TensorDevice.h b/contrib/Eigen/src/Tensor/TensorDevice.h
new file mode 100644
index 0000000..d9da849
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDevice.h
@@ -0,0 +1,139 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_DEVICE_H
+#define EIGEN_TENSOR_TENSOR_DEVICE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Pseudo expression providing an operator = that will evaluate its argument
+ * on the specified computing 'device' (GPU, thread pool, ...)
+ *
+ * Example:
+ *    C.device(EIGEN_GPU) = A + B;
+ *
+ * TODO: operator *= and /=.
+ */
+template <typename ExpressionType, typename DeviceType>
+class TensorDevice {
+ public:
+  TensorDevice(const DeviceType& device, ExpressionType& expression) : m_device(device), m_expression(expression) {}
+
+  EIGEN_DEFAULT_COPY_CONSTRUCTOR(TensorDevice)
+
+  template <typename OtherDerived>
+  EIGEN_STRONG_INLINE TensorDevice& operator=(const OtherDerived& other) {
+    typedef TensorAssignOp<ExpressionType, const OtherDerived> Assign;
+    Assign assign(m_expression, other);
+    internal::TensorExecutor<const Assign, DeviceType>::run(assign, m_device);
+    return *this;
+  }
+
+  template <typename OtherDerived>
+  EIGEN_STRONG_INLINE TensorDevice& operator+=(const OtherDerived& other) {
+    typedef typename OtherDerived::Scalar Scalar;
+    typedef TensorCwiseBinaryOp<internal::scalar_sum_op<Scalar>, const ExpressionType, const OtherDerived> Sum;
+    Sum sum(m_expression, other);
+    typedef TensorAssignOp<ExpressionType, const Sum> Assign;
+    Assign assign(m_expression, sum);
+    internal::TensorExecutor<const Assign, DeviceType>::run(assign, m_device);
+    return *this;
+  }
+
+  template <typename OtherDerived>
+  EIGEN_STRONG_INLINE TensorDevice& operator-=(const OtherDerived& other) {
+    typedef typename OtherDerived::Scalar Scalar;
+    typedef TensorCwiseBinaryOp<internal::scalar_difference_op<Scalar>, const ExpressionType, const OtherDerived>
+        Difference;
+    Difference difference(m_expression, other);
+    typedef TensorAssignOp<ExpressionType, const Difference> Assign;
+    Assign assign(m_expression, difference);
+    internal::TensorExecutor<const Assign, DeviceType>::run(assign, m_device);
+    return *this;
+  }
+
+ protected:
+  const DeviceType& m_device;
+  ExpressionType& m_expression;
+};
+
+/** \class TensorAsyncDevice
+ * \ingroup Tensor_Module
+ *
+ * \brief Pseudo expression providing an operator = that will evaluate its
+ * argument asynchronously on the specified device. Currently only
+ * ThreadPoolDevice implements proper asynchronous execution, while the default
+ * and GPU devices just run the expression synchronously and call m_done() on
+ * completion.
+ *
+ * Example:
+ *    auto done = []() { ... expression evaluation done ... };
+ *    C.device(thread_pool_device, std::move(done)) = A + B;
+ */
+
+template <typename ExpressionType, typename DeviceType, typename DoneCallback>
+class TensorAsyncDevice {
+ public:
+  TensorAsyncDevice(const DeviceType& device, ExpressionType& expression, DoneCallback done)
+      : m_device(device), m_expression(expression), m_done(std::move(done)) {}
+
+  template <typename OtherDerived>
+  EIGEN_STRONG_INLINE TensorAsyncDevice& operator=(const OtherDerived& other) {
+    typedef TensorAssignOp<ExpressionType, const OtherDerived> Assign;
+    typedef internal::TensorExecutor<const Assign, DeviceType> Executor;
+
+    Assign assign(m_expression, other);
+    Executor::run(assign, m_device);
+    m_done();
+
+    return *this;
+  }
+
+ protected:
+  const DeviceType& m_device;
+  ExpressionType& m_expression;
+  DoneCallback m_done;
+};
+
+#ifdef EIGEN_USE_THREADS
+template <typename ExpressionType, typename DoneCallback>
+class TensorAsyncDevice<ExpressionType, ThreadPoolDevice, DoneCallback> {
+ public:
+  TensorAsyncDevice(const ThreadPoolDevice& device, ExpressionType& expression, DoneCallback done)
+      : m_device(device), m_expression(expression), m_done(std::move(done)) {}
+
+  template <typename OtherDerived>
+  EIGEN_STRONG_INLINE TensorAsyncDevice& operator=(const OtherDerived& other) {
+    typedef TensorAssignOp<ExpressionType, const OtherDerived> Assign;
+    typedef internal::TensorAsyncExecutor<const Assign, ThreadPoolDevice, DoneCallback> Executor;
+
+    // WARNING: After assignment 'm_done' callback will be in undefined state.
+    Assign assign(m_expression, other);
+    Executor::runAsync(assign, m_device, std::move(m_done));
+
+    return *this;
+  }
+
+ protected:
+  const ThreadPoolDevice& m_device;
+  ExpressionType& m_expression;
+  DoneCallback m_done;
+};
+#endif
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_DEVICE_H
diff --git a/contrib/Eigen/src/Tensor/TensorDeviceCuda.h b/contrib/Eigen/src/Tensor/TensorDeviceCuda.h
new file mode 100644
index 0000000..dcfa5eb
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDeviceCuda.h
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_DEVICE_CUDA_H
+#define EIGEN_TENSOR_TENSOR_DEVICE_CUDA_H
+
+#if defined(__clang__) || defined(__GNUC__)
+#warning \
+    "Deprecated header file, please either include the main contrib/Eigen/Tensor header or the respective TensorDeviceGpu.h file"
+#endif
+
+#include "TensorDeviceGpu.h"
+
+#endif  // EIGEN_TENSOR_TENSOR_DEVICE_CUDA_H
diff --git a/contrib/Eigen/src/Tensor/TensorDeviceDefault.h b/contrib/Eigen/src/Tensor/TensorDeviceDefault.h
new file mode 100644
index 0000000..efb4bb4
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDeviceDefault.h
@@ -0,0 +1,114 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_DEVICE_DEFAULT_H
+#define EIGEN_TENSOR_TENSOR_DEVICE_DEFAULT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+// Default device for the machine (typically a single cpu core)
+struct DefaultDevice {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* allocate(size_t num_bytes) const {
+    return internal::aligned_malloc(num_bytes);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void deallocate(void* buffer) const { internal::aligned_free(buffer); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* allocate_temp(size_t num_bytes) const { return allocate(num_bytes); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void deallocate_temp(void* buffer) const { deallocate(buffer); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpy(void* dst, const void* src, size_t n) const {
+    ::memcpy(dst, src, n);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpyHostToDevice(void* dst, const void* src, size_t n) const {
+    memcpy(dst, src, n);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpyDeviceToHost(void* dst, const void* src, size_t n) const {
+    memcpy(dst, src, n);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memset(void* buffer, int c, size_t n) const { ::memset(buffer, c, n); }
+  template <typename T>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void fill(T* begin, T* end, const T& value) const {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+    // std::fill is not a device function, so resort to simple loop.
+    for (T* it = begin; it != end; ++it) {
+      *it = value;
+    }
+#else
+    std::fill(begin, end, value);
+#endif
+  }
+  template <typename Type>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type get(Type data) const {
+    return data;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t numThreads() const {
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+    // Running on the host CPU
+    return 1;
+#elif defined(EIGEN_HIP_DEVICE_COMPILE)
+    // Running on a HIP device
+    return 64;
+#else
+    // Running on a CUDA device
+    return 32;
+#endif
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const {
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
+    // Running on the host CPU
+    return l1CacheSize();
+#elif defined(EIGEN_HIP_DEVICE_COMPILE)
+    // Running on a HIP device
+    return 48 * 1024;  // FIXME: Update this number for HIP.
+#else
+    // Running on a CUDA device, return the amount of shared memory available.
+    return 48 * 1024;
+#endif
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
+    // Running single threaded on the host CPU
+    return l3CacheSize();
+#elif defined(EIGEN_HIP_DEVICE_COMPILE)
+    // Running on a HIP device
+    return firstLevelCacheSize();  // FIXME: Update this number for HIP.
+#else
+    // Running on a CUDA device
+    return firstLevelCacheSize();
+#endif
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void synchronize() const {
+    // Nothing.  Default device operations are synchronous.
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int majorDeviceVersion() const {
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+    // Running single threaded on the host CPU
+    // Should return an enum that encodes the ISA supported by the CPU
+    return 1;
+#elif defined(EIGEN_HIP_DEVICE_COMPILE)
+    // Running on a HIP device
+    // return 1 as major for HIP
+    return 1;
+#else
+    // Running on a CUDA device
+    return EIGEN_CUDA_ARCH / 100;
+#endif
+  }
+};
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_DEVICE_DEFAULT_H
diff --git a/contrib/Eigen/src/Tensor/TensorDeviceGpu.h b/contrib/Eigen/src/Tensor/TensorDeviceGpu.h
new file mode 100644
index 0000000..5443ff8
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDeviceGpu.h
@@ -0,0 +1,409 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#if defined(EIGEN_USE_GPU) && !defined(EIGEN_TENSOR_TENSOR_DEVICE_GPU_H)
+#define EIGEN_TENSOR_TENSOR_DEVICE_GPU_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include "../../../../Eigen/src/Core/util/GpuHipCudaDefines.inc"
+#include "../../../../Eigen/src/Core/util/GpuRuntime.h"
+
+namespace Eigen {
+
+static const int kGpuScratchSize = 1024;
+
+// The device facts Eigen consults, read one at a time. The reason is portability, not speed: the opt-in
+// shared-memory limit and memory-pool support are not fields a gpuDeviceProp_t carries under both backends, while
+// the attribute enumerators exist in each. (Measured on CUDA 13.3, a warm gpuGetDeviceProperties costs 0.3-0.5 us
+// against 1.4-1.5 us for these nine queries, and a cold call of either is dominated by runtime initialization.)
+struct GpuDeviceAttributes {
+  int multiProcessorCount;
+  int maxThreadsPerBlock;
+  int maxThreadsPerMultiProcessor;
+  int sharedMemPerBlock;
+  int sharedMemPerBlockOptin;
+  int computeCapabilityMajor;
+  int computeCapabilityMinor;
+  int warpSize;
+  int memoryPoolsSupported;
+};
+
+// Filled once for every visible device at first use, which is thread-safe by the initialization rules and needs no
+// lock. A few microseconds per device, so there is nothing to gain from filling it per device on demand.
+// Templated on the attribute enum: CUDA spells it cudaDeviceAttr and HIP hipDeviceAttribute_t, and the .inc pair
+// aliases the enumerators but not the type.
+template <typename GpuDeviceAttr>
+inline int GetGpuDeviceAttribute(GpuDeviceAttr attribute, int device) {
+#if !defined(EIGEN_USE_HIP)
+  if (attribute == gpuDevAttrMemoryPoolsSupported) {
+    int driver_version = 0;
+    EIGEN_GPU_RUNTIME_CHECK(cudaDriverGetVersion(&driver_version));
+    // CUDA minor-version compatibility permits drivers that predate this attribute.
+    if (driver_version < 11020) return 0;
+  }
+#endif
+  int value = 0;
+  const gpuError_t error = gpuDeviceGetAttribute(&value, attribute, device);
+#if defined(EIGEN_USE_HIP)
+  // HIP 5.x declares the opt-in enumerator but does not implement the query.
+  if (attribute == gpuDevAttrMaxSharedMemoryPerBlockOptin && error == hipErrorInvalidValue) {
+    (void)hipGetLastError();
+    EIGEN_GPU_RUNTIME_CHECK(gpuDeviceGetAttribute(&value, gpuDevAttrMaxSharedMemoryPerBlock, device));
+    return value;
+  }
+#endif
+  EIGEN_GPU_RUNTIME_CHECK(error);
+  return value;
+}
+
+inline const std::vector<GpuDeviceAttributes>& GetGpuDeviceAttributes() {
+  // The device count is dynamic; keep the cache alive for GpuDevice users in static destructors.
+  static const std::vector<GpuDeviceAttributes>* kAttributes = [] {
+    int num_devices = 0;
+    EIGEN_GPU_RUNTIME_CHECK(gpuGetDeviceCount(&num_devices));
+    auto* attributes = new std::vector<GpuDeviceAttributes>(num_devices);
+    for (int device = 0; device < num_devices; ++device) {
+      (*attributes)[device] = {
+          /*multiProcessorCount=*/GetGpuDeviceAttribute(gpuDevAttrMultiProcessorCount, device),
+          /*maxThreadsPerBlock=*/GetGpuDeviceAttribute(gpuDevAttrMaxThreadsPerBlock, device),
+          /*maxThreadsPerMultiProcessor=*/GetGpuDeviceAttribute(gpuDevAttrMaxThreadsPerMultiProcessor, device),
+          /*sharedMemPerBlock=*/GetGpuDeviceAttribute(gpuDevAttrMaxSharedMemoryPerBlock, device),
+          /*sharedMemPerBlockOptin=*/GetGpuDeviceAttribute(gpuDevAttrMaxSharedMemoryPerBlockOptin, device),
+          /*computeCapabilityMajor=*/GetGpuDeviceAttribute(gpuDevAttrComputeCapabilityMajor, device),
+          /*computeCapabilityMinor=*/GetGpuDeviceAttribute(gpuDevAttrComputeCapabilityMinor, device),
+          /*warpSize=*/GetGpuDeviceAttribute(gpuDevAttrWarpSize, device),
+          /*memoryPoolsSupported=*/GetGpuDeviceAttribute(gpuDevAttrMemoryPoolsSupported, device),
+      };
+    }
+    return attributes;
+  }();
+  return *kAttributes;
+}
+
+inline const GpuDeviceAttributes& GetGpuDeviceAttributes(int device) {
+  const std::vector<GpuDeviceAttributes>& attributes = GetGpuDeviceAttributes();
+  eigen_assert(device >= 0 && device < static_cast<int>(attributes.size()) && "no such GPU device");
+  return attributes[device];
+}
+
+// Attributes for StreamInterface implementations that follow the calling thread's current device.
+// GpuStreamDevice instead queries the device that owns its stream.
+inline const GpuDeviceAttributes& GetCurrentGpuDeviceAttributes() {
+  int device = 0;
+  EIGEN_GPU_RUNTIME_CHECK(gpuGetDevice(&device));
+  return GetGpuDeviceAttributes(device);
+}
+
+// This defines an interface that GPUDevice can take to use
+// HIP / CUDA streams underneath.
+class StreamInterface {
+ public:
+  virtual ~StreamInterface() = default;
+
+  virtual const gpuStream_t& stream() const = 0;
+  virtual const gpuDeviceProp_t& deviceProperties() const = 0;
+
+  // The attributes of the device this interface's stream runs on. The default reports the device the calling
+  // thread is bound to, which is what an implementation that follows the current device wants; one that owns a
+  // device index overrides it, as GpuStreamDevice does, so that the answer follows the stream rather than
+  // whatever device the caller happens to have selected.
+  virtual const GpuDeviceAttributes& deviceAttributes() const { return GetCurrentGpuDeviceAttributes(); }
+
+  // Allocate memory on the actual device where the computation will run
+  virtual void* allocate(size_t num_bytes) const = 0;
+  virtual void deallocate(void* buffer) const = 0;
+
+  // Return a scratchpad buffer of size 1k
+  virtual void* scratchpad() const = 0;
+
+  // Return a semaphore. The semaphore is initially initialized to 0, and
+  // each kernel using it is responsible for resetting to 0 upon completion
+  // to maintain the invariant that the semaphore is always equal to 0 upon
+  // each kernel start.
+  virtual unsigned int* semaphore() const = 0;
+};
+
+class GpuDeviceProperties {
+ public:
+  static const GpuDeviceProperties& instance() {
+    static const GpuDeviceProperties* kInstance = new GpuDeviceProperties();
+
+    return *kInstance;
+  }
+
+  EIGEN_STRONG_INLINE const gpuDeviceProp_t& get(int device) const {
+    eigen_assert(device >= 0 && device < static_cast<int>(device_properties_.size()) && "no such GPU device");
+    return device_properties_[device];
+  }
+
+ private:
+  GpuDeviceProperties() = default;
+
+  static std::vector<gpuDeviceProp_t> GetDeviceProperties() {
+    int num_devices = 0;
+    EIGEN_GPU_RUNTIME_CHECK(gpuGetDeviceCount(&num_devices));
+    std::vector<gpuDeviceProp_t> device_properties(num_devices);
+    for (int i = 0; i < num_devices; ++i) {
+      EIGEN_GPU_RUNTIME_CHECK(gpuGetDeviceProperties(&device_properties[i], i));
+    }
+
+    return device_properties;
+  }
+
+  std::vector<gpuDeviceProp_t> device_properties_ = GetDeviceProperties();
+};
+
+EIGEN_ALWAYS_INLINE const GpuDeviceProperties& GetGpuDeviceProperties() { return GpuDeviceProperties::instance(); }
+
+EIGEN_ALWAYS_INLINE const gpuDeviceProp_t& GetGpuDeviceProperties(int device) {
+  return GetGpuDeviceProperties().get(device);
+}
+
+static const gpuStream_t default_stream = gpuStreamDefault;
+
+class GpuStreamDevice : public StreamInterface {
+ public:
+  // Use the default stream on the current device
+  GpuStreamDevice() : stream_(&default_stream), scratch_(nullptr), semaphore_(nullptr) {
+    EIGEN_GPU_RUNTIME_CHECK(gpuGetDevice(&device_));
+  }
+  // Use the default stream on the specified device
+  GpuStreamDevice(int device) : stream_(&default_stream), device_(device), scratch_(nullptr), semaphore_(nullptr) {}
+  // Use the specified stream. Note that it's the
+  // caller's responsibility to ensure that the stream can run on
+  // the specified device. If no device is specified the code
+  // assumes that the stream is associated to the current gpu device.
+  GpuStreamDevice(const gpuStream_t* stream, int device = -1)
+      : stream_(stream), device_(device), scratch_(nullptr), semaphore_(nullptr) {
+    if (device < 0) {
+      EIGEN_GPU_RUNTIME_CHECK(gpuGetDevice(&device_));
+    } else {
+      int num_devices = 0;
+      EIGEN_GPU_RUNTIME_CHECK(gpuGetDeviceCount(&num_devices));
+      EIGEN_UNUSED_VARIABLE(num_devices);
+      gpu_assert(device < num_devices);
+      device_ = device;
+    }
+  }
+
+  ~GpuStreamDevice() override {
+    if (scratch_) {
+      deallocate(scratch_);
+    }
+  }
+
+  const gpuStream_t& stream() const override { return *stream_; }
+  const gpuDeviceProp_t& deviceProperties() const override { return GetGpuDeviceProperties(device_); }
+  const GpuDeviceAttributes& deviceAttributes() const override { return GetGpuDeviceAttributes(device_); }
+  void* allocate(size_t num_bytes) const override {
+    EIGEN_GPU_RUNTIME_CHECK(gpuSetDevice(device_));
+    void* result = nullptr;
+    EIGEN_GPU_RUNTIME_CHECK(gpuMalloc(&result, num_bytes));
+    gpu_assert(result != nullptr);
+    return result;
+  }
+  void deallocate(void* buffer) const override {
+    EIGEN_GPU_RUNTIME_CHECK(gpuSetDevice(device_));
+    gpu_assert(buffer != nullptr);
+    EIGEN_GPU_RUNTIME_CHECK(gpuFree(buffer));
+  }
+
+  void* scratchpad() const override {
+    if (scratch_ == nullptr) {
+      scratch_ = allocate(kGpuScratchSize + sizeof(unsigned int));
+    }
+    return scratch_;
+  }
+
+  unsigned int* semaphore() const override {
+    if (semaphore_ == nullptr) {
+      char* scratch = static_cast<char*>(scratchpad()) + kGpuScratchSize;
+      semaphore_ = reinterpret_cast<unsigned int*>(scratch);
+      EIGEN_GPU_RUNTIME_CHECK(gpuMemsetAsync(semaphore_, 0, sizeof(unsigned int), *stream_));
+    }
+    return semaphore_;
+  }
+
+ private:
+  const gpuStream_t* stream_;
+  int device_;
+  mutable void* scratch_;
+  mutable unsigned int* semaphore_;
+};
+
+struct GpuDevice {
+  // The StreamInterface is not owned: the caller is
+  // responsible for its initialization and eventual destruction.
+  explicit GpuDevice(const StreamInterface* stream) : stream_(stream), max_blocks_(INT_MAX) { eigen_assert(stream); }
+  // Nothing reads max_blocks_ any more; the executor sizes its grid from the device's own limits.
+  EIGEN_DEPRECATED explicit GpuDevice(const StreamInterface* stream, int num_blocks)
+      : stream_(stream), max_blocks_(num_blocks) {
+    eigen_assert(stream);
+  }
+  // TODO(bsteiner): This is an internal API, we should not expose it.
+  EIGEN_STRONG_INLINE const gpuStream_t& stream() const { return stream_->stream(); }
+
+  EIGEN_STRONG_INLINE void* allocate(size_t num_bytes) const { return stream_->allocate(num_bytes); }
+
+  EIGEN_STRONG_INLINE void deallocate(void* buffer) const { stream_->deallocate(buffer); }
+
+  EIGEN_STRONG_INLINE void* allocate_temp(size_t num_bytes) const { return stream_->allocate(num_bytes); }
+
+  EIGEN_STRONG_INLINE void deallocate_temp(void* buffer) const { stream_->deallocate(buffer); }
+
+  template <typename Type>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type get(Type data) const {
+    return data;
+  }
+
+  EIGEN_STRONG_INLINE void* scratchpad() const { return stream_->scratchpad(); }
+
+  EIGEN_STRONG_INLINE unsigned int* semaphore() const { return stream_->semaphore(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpy(void* dst, const void* src, size_t n) const {
+#ifndef EIGEN_GPU_COMPILE_PHASE
+    EIGEN_GPU_RUNTIME_CHECK(gpuMemcpyAsync(dst, src, n, gpuMemcpyDeviceToDevice, stream_->stream()));
+#else
+    EIGEN_UNUSED_VARIABLE(dst);
+    EIGEN_UNUSED_VARIABLE(src);
+    EIGEN_UNUSED_VARIABLE(n);
+    eigen_assert(false && "The default device should be used instead to generate kernel code");
+#endif
+  }
+
+  EIGEN_STRONG_INLINE void memcpyHostToDevice(void* dst, const void* src, size_t n) const {
+    EIGEN_GPU_RUNTIME_CHECK(gpuMemcpyAsync(dst, src, n, gpuMemcpyHostToDevice, stream_->stream()));
+  }
+
+  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void* dst, const void* src, size_t n) const {
+    EIGEN_GPU_RUNTIME_CHECK(gpuMemcpyAsync(dst, src, n, gpuMemcpyDeviceToHost, stream_->stream()));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memset(void* buffer, int c, size_t n) const {
+#ifndef EIGEN_GPU_COMPILE_PHASE
+    EIGEN_GPU_RUNTIME_CHECK(gpuMemsetAsync(buffer, c, n, stream_->stream()));
+#else
+    EIGEN_UNUSED_VARIABLE(buffer);
+    EIGEN_UNUSED_VARIABLE(c);
+    EIGEN_UNUSED_VARIABLE(n);
+    eigen_assert(false && "The default device should be used instead to generate kernel code");
+#endif
+  }
+
+  template <typename T>
+  EIGEN_STRONG_INLINE void fill(T* begin, T* end, const T& value) const {
+#ifndef EIGEN_GPU_COMPILE_PHASE
+    const size_t count = end - begin;
+    // Split value into bytes and run memset with stride.
+    const int value_size = sizeof(value);
+    char* buffer = (char*)begin;
+    char* value_bytes = (char*)(&value);
+    // If all value bytes are equal, then a single memset can be much faster.
+    bool use_single_memset = true;
+    for (int i = 1; i < value_size; ++i) {
+      if (value_bytes[i] != value_bytes[0]) {
+        use_single_memset = false;
+      }
+    }
+
+    if (use_single_memset) {
+      EIGEN_GPU_RUNTIME_CHECK(gpuMemsetAsync(buffer, value_bytes[0], count * sizeof(T), stream_->stream()));
+    } else {
+      for (int b = 0; b < value_size; ++b) {
+        EIGEN_GPU_RUNTIME_CHECK(gpuMemset2DAsync(buffer + b, value_size, value_bytes[b], 1, count, stream_->stream()));
+      }
+    }
+#else
+    EIGEN_UNUSED_VARIABLE(begin);
+    EIGEN_UNUSED_VARIABLE(end);
+    EIGEN_UNUSED_VARIABLE(value);
+    eigen_assert(false && "The default device should be used instead to generate kernel code");
+#endif
+  }
+
+  // The warp (wavefront) width, which is what "a thread" means to the block-size heuristics that ask.
+  EIGEN_STRONG_INLINE size_t numThreads() const { return static_cast<size_t>(warpSize()); }
+
+  EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const {
+    // FIXME: Return a more accurate cache size.
+    return 48 * 1024;
+  }
+
+  EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
+    // We won't try to take advantage of the l2 cache for the time being, and
+    // there is no l3 cache on hip/cuda devices.
+    return firstLevelCacheSize();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void synchronize() const {
+#ifndef EIGEN_GPU_COMPILE_PHASE
+    EIGEN_GPU_RUNTIME_CHECK(gpuStreamSynchronize(stream_->stream()));
+#else
+    gpu_assert(false && "The default device should be used instead to generate kernel code");
+#endif
+  }
+
+  EIGEN_STRONG_INLINE int getNumGpuMultiProcessors() const { return stream_->deviceProperties().multiProcessorCount; }
+  EIGEN_STRONG_INLINE int maxGpuThreadsPerBlock() const { return stream_->deviceProperties().maxThreadsPerBlock; }
+  EIGEN_STRONG_INLINE int maxGpuThreadsPerMultiProcessor() const {
+    return stream_->deviceProperties().maxThreadsPerMultiProcessor;
+  }
+  EIGEN_STRONG_INLINE int sharedMemPerBlock() const {
+    return static_cast<int>(stream_->deviceProperties().sharedMemPerBlock);
+  }
+  EIGEN_STRONG_INLINE int majorDeviceVersion() const { return stream_->deviceProperties().major; }
+  EIGEN_STRONG_INLINE int minorDeviceVersion() const { return stream_->deviceProperties().minor; }
+
+  // Read from the StreamInterface's attributes rather than from its properties: gpuDeviceProp_t does not carry
+  // the opt-in shared-memory limit or memory-pool support portably. Like the properties above, they describe the
+  // device the stream and its allocations belong to, which need not be the device the calling thread is bound to.
+  EIGEN_STRONG_INLINE int warpSize() const { return stream_->deviceAttributes().warpSize; }
+  // The shared memory a kernel may request with gpuFuncSetAttribute, or the ordinary block limit when HIP does
+  // not implement the opt-in attribute.
+  EIGEN_STRONG_INLINE int sharedMemPerBlockOptin() const { return stream_->deviceAttributes().sharedMemPerBlockOptin; }
+  // Whether gpuMallocAsync and its pool are available on this device and driver.
+  EIGEN_STRONG_INLINE bool memoryPoolsSupported() const {
+    return stream_->deviceAttributes().memoryPoolsSupported != 0;
+  }
+
+  EIGEN_DEPRECATED EIGEN_STRONG_INLINE int maxBlocks() const { return max_blocks_; }
+
+  // This function checks if the GPU runtime recorded an error for the
+  // underlying stream device.
+  inline bool ok() const {
+#ifdef EIGEN_GPUCC
+    gpuError_t error = gpuStreamQuery(stream_->stream());
+    return (error == gpuSuccess) || (error == gpuErrorNotReady);
+#else
+    return false;
+#endif
+  }
+
+ private:
+  const StreamInterface* stream_;
+  int max_blocks_;
+};
+
+// Launches `kernel` on the device's stream through internal::gpu_launch (GpuRuntime.h), which reports a failed
+// launch through EIGEN_GPU_RUNTIME_CHECK. A single statement, so it composes with an unbraced `if`.
+#define LAUNCH_GPU_KERNEL(kernel, gridsize, blocksize, sharedmem, device, ...)                               \
+  do {                                                                                                       \
+    ::Eigen::internal::gpu_launch((kernel), dim3(gridsize), dim3(blocksize), (sharedmem), (device).stream(), \
+                                  __VA_ARGS__);                                                              \
+  } while (0)
+
+}  // end namespace Eigen
+
+// undefine all the gpu* macros we defined at the beginning of the file
+#include "../../../../Eigen/src/Core/util/GpuHipCudaUndefines.inc"
+
+#endif  // EIGEN_TENSOR_TENSOR_DEVICE_GPU_H
diff --git a/contrib/Eigen/src/Tensor/TensorDeviceSycl.h b/contrib/Eigen/src/Tensor/TensorDeviceSycl.h
new file mode 100644
index 0000000..7dbc00b
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDeviceSycl.h
@@ -0,0 +1,568 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// SPDX-License-Identifier: MPL-2.0
+
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#if defined(EIGEN_USE_SYCL) && !defined(EIGEN_TENSOR_TENSOR_DEVICE_SYCL_H)
+#define EIGEN_TENSOR_TENSOR_DEVICE_SYCL_H
+#include <unordered_set>
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace TensorSycl {
+namespace internal {
+
+/// Cache all the device information needed
+struct SyclDeviceInfo {
+  SyclDeviceInfo(cl::sycl::queue queue)
+      : local_mem_type(queue.get_device().template get_info<cl::sycl::info::device::local_mem_type>()),
+        max_work_item_sizes(queue.get_device().template get_info<cl::sycl::info::device::max_work_item_sizes<3>>()),
+        max_mem_alloc_size(queue.get_device().template get_info<cl::sycl::info::device::max_mem_alloc_size>()),
+        max_compute_units(queue.get_device().template get_info<cl::sycl::info::device::max_compute_units>()),
+        max_work_group_size(queue.get_device().template get_info<cl::sycl::info::device::max_work_group_size>()),
+        local_mem_size(queue.get_device().template get_info<cl::sycl::info::device::local_mem_size>()),
+        platform_name(queue.get_device().get_platform().template get_info<cl::sycl::info::platform::name>()),
+        device_name(queue.get_device().template get_info<cl::sycl::info::device::name>()),
+        device_vendor(queue.get_device().template get_info<cl::sycl::info::device::vendor>()) {}
+
+  cl::sycl::info::local_mem_type local_mem_type;
+  cl::sycl::id<3> max_work_item_sizes;
+  unsigned long max_mem_alloc_size;
+  unsigned long max_compute_units;
+  unsigned long max_work_group_size;
+  size_t local_mem_size;
+  std::string platform_name;
+  std::string device_name;
+  std::string device_vendor;
+};
+
+}  // end namespace internal
+}  // end namespace TensorSycl
+
+// All devices (even AMD CPU with intel OpenCL runtime) that support OpenCL and
+// can consume SPIR or SPIRV can use the Eigen SYCL backend and consequently
+// TensorFlow via the Eigen SYCL Backend.
+EIGEN_STRONG_INLINE auto get_sycl_supported_devices() -> decltype(cl::sycl::device::get_devices()) {
+#ifdef EIGEN_SYCL_USE_DEFAULT_SELECTOR
+  return {cl::sycl::device(cl::sycl::default_selector())};
+#else
+  std::vector<cl::sycl::device> supported_devices;
+  auto platform_list = cl::sycl::platform::get_platforms();
+  for (const auto &platform : platform_list) {
+    auto device_list = platform.get_devices();
+    auto platform_name = platform.template get_info<cl::sycl::info::platform::name>();
+    std::transform(platform_name.begin(), platform_name.end(), platform_name.begin(), ::tolower);
+    for (const auto &device : device_list) {
+      auto vendor = device.template get_info<cl::sycl::info::device::vendor>();
+      std::transform(vendor.begin(), vendor.end(), vendor.begin(), ::tolower);
+      bool unsupported_condition = (device.is_cpu() && platform_name.find("amd") != std::string::npos &&
+                                    vendor.find("apu") == std::string::npos) ||
+                                   (platform_name.find("experimental") != std::string::npos) || device.is_host();
+      if (!unsupported_condition) {
+        supported_devices.push_back(device);
+      }
+    }
+  }
+  return supported_devices;
+#endif
+}
+
+class QueueInterface {
+ public:
+  /// Creating device by using cl::sycl::selector or cl::sycl::device.
+  template <typename DeviceOrSelector>
+  explicit QueueInterface(const DeviceOrSelector &dev_or_sel, cl::sycl::async_handler handler,
+                          unsigned num_threads = std::thread::hardware_concurrency())
+      : m_queue{dev_or_sel, handler, {sycl::property::queue::in_order()}},
+        m_thread_pool(num_threads),
+        m_device_info(m_queue) {}
+
+  template <typename DeviceOrSelector>
+  explicit QueueInterface(const DeviceOrSelector &dev_or_sel,
+                          unsigned num_threads = std::thread::hardware_concurrency())
+      : QueueInterface(
+            dev_or_sel, [this](cl::sycl::exception_list l) { this->exception_caught_ = this->sycl_async_handler(l); },
+            num_threads) {}
+
+  explicit QueueInterface(const cl::sycl::queue &q, unsigned num_threads = std::thread::hardware_concurrency())
+      : m_queue(q), m_thread_pool(num_threads), m_device_info(m_queue) {}
+
+  EIGEN_STRONG_INLINE void *allocate(size_t num_bytes) const {
+#if EIGEN_MAX_ALIGN_BYTES > 0
+    return (void *)cl::sycl::aligned_alloc_device(EIGEN_MAX_ALIGN_BYTES, num_bytes, m_queue);
+#else
+    return (void *)cl::sycl::malloc_device(num_bytes, m_queue);
+#endif
+  }
+
+  EIGEN_STRONG_INLINE void *allocate_temp(size_t num_bytes) const {
+    return (void *)cl::sycl::malloc_device<uint8_t>(num_bytes, m_queue);
+  }
+
+  template <typename data_t>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE data_t *get(data_t *data) const {
+    return data;
+  }
+
+  EIGEN_STRONG_INLINE void deallocate_temp(void *p) const { deallocate(p); }
+
+  EIGEN_STRONG_INLINE void deallocate_temp(const void *p) const { deallocate_temp(const_cast<void *>(p)); }
+
+  EIGEN_STRONG_INLINE void deallocate(void *p) const { cl::sycl::free(p, m_queue); }
+
+  /// The memcpyHostToDevice is used to copy the data from host to device
+  /// The destination pointer could be deleted before the copy happened which is
+  /// why a callback function is needed. By default if none is provided, the
+  /// function is blocking.
+  EIGEN_STRONG_INLINE void memcpyHostToDevice(void *dst, const void *src, size_t n,
+                                              std::function<void()> callback) const {
+    auto e = m_queue.memcpy(dst, src, n);
+    synchronize_and_callback(e, callback);
+  }
+
+  /// The memcpyDeviceToHost is used to copy the data from device to host.
+  /// The source pointer could be deleted before the copy happened which is
+  /// why a callback function is needed. By default if none is provided, the
+  /// function is blocking.
+  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void *dst, const void *src, size_t n,
+                                              std::function<void()> callback) const {
+    if (n == 0) {
+      if (callback) callback();
+      return;
+    }
+    auto e = m_queue.memcpy(dst, src, n);
+    synchronize_and_callback(e, callback);
+  }
+
+  /// The memcpy function.
+  /// No callback is required here as both arguments are on the device
+  /// and SYCL can handle the dependency.
+  EIGEN_STRONG_INLINE void memcpy(void *dst, const void *src, size_t n) const {
+    if (n == 0) {
+      return;
+    }
+    m_queue.memcpy(dst, src, n).wait();
+  }
+
+  /// the memset function.
+  /// No callback is required here as both arguments are on the device
+  /// and SYCL can handle the dependency.
+  EIGEN_STRONG_INLINE void memset(void *data, int c, size_t n) const {
+    if (n == 0) {
+      return;
+    }
+    m_queue.memset(data, c, n).wait();
+  }
+
+  template <typename T>
+  EIGEN_STRONG_INLINE void fill(T *begin, T *end, const T &value) const {
+    if (begin == end) {
+      return;
+    }
+    const size_t count = end - begin;
+    m_queue.fill(begin, value, count).wait();
+  }
+
+  template <typename OutScalar, typename sycl_kernel, typename Lhs, typename Rhs, typename OutPtr, typename Range,
+            typename Index, typename... T>
+  EIGEN_ALWAYS_INLINE cl::sycl::event binary_kernel_launcher(const Lhs &lhs, const Rhs &rhs, OutPtr outptr,
+                                                             Range thread_range, Index scratchSize, T... var) const {
+    auto kernel_functor = [=](cl::sycl::handler &cgh) {
+      typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+          LocalAccessor;
+
+      LocalAccessor scratch(cl::sycl::range<1>(scratchSize), cgh);
+      cgh.parallel_for(thread_range, sycl_kernel(scratch, lhs, rhs, outptr, var...));
+    };
+
+    return m_queue.submit(kernel_functor);
+  }
+
+  template <typename OutScalar, typename sycl_kernel, typename InPtr, typename OutPtr, typename Range, typename Index,
+            typename... T>
+  EIGEN_ALWAYS_INLINE cl::sycl::event unary_kernel_launcher(const InPtr &inptr, OutPtr &outptr, Range thread_range,
+                                                            Index scratchSize, T... var) const {
+    auto kernel_functor = [=](cl::sycl::handler &cgh) {
+      typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+          LocalAccessor;
+
+      LocalAccessor scratch(cl::sycl::range<1>(scratchSize), cgh);
+      cgh.parallel_for(thread_range, sycl_kernel(scratch, inptr, outptr, var...));
+    };
+    return m_queue.submit(kernel_functor);
+  }
+
+  template <typename OutScalar, typename sycl_kernel, typename InPtr, typename Range, typename Index, typename... T>
+  EIGEN_ALWAYS_INLINE cl::sycl::event nullary_kernel_launcher(const InPtr &inptr, Range thread_range, Index scratchSize,
+                                                              T... var) const {
+    auto kernel_functor = [=](cl::sycl::handler &cgh) {
+      typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+          LocalAccessor;
+
+      LocalAccessor scratch(cl::sycl::range<1>(scratchSize), cgh);
+      cgh.parallel_for(thread_range, sycl_kernel(scratch, inptr, var...));
+    };
+
+    return m_queue.submit(kernel_functor);
+  }
+
+  EIGEN_STRONG_INLINE void synchronize() const {
+#ifdef EIGEN_EXCEPTIONS
+    m_queue.wait_and_throw();
+#else
+    m_queue.wait();
+#endif
+  }
+
+  template <typename Index>
+  EIGEN_STRONG_INLINE void parallel_for_setup(Index n, Index &tileSize, Index &rng, Index &GRange) const {
+    tileSize = static_cast<Index>(getNearestPowerOfTwoWorkGroupSize());
+    tileSize = std::min(static_cast<Index>(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1),
+                        static_cast<Index>(tileSize));
+    rng = n;
+    if (rng == 0) rng = static_cast<Index>(1);
+    GRange = rng;
+    if (tileSize > GRange)
+      tileSize = GRange;
+    else if (GRange > tileSize) {
+      Index xMode = static_cast<Index>(GRange % tileSize);
+      if (xMode != 0) GRange += static_cast<Index>(tileSize - xMode);
+    }
+  }
+
+  /// This is used to prepare the number of threads and also the number of
+  /// threads per block for sycl kernels
+  template <typename Index>
+  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 2> &input_dim, cl::sycl::range<2> &global_range,
+                                              cl::sycl::range<2> &local_range) const {
+    std::array<Index, 2> input_range = input_dim;
+    Index max_workgroup_Size = static_cast<Index>(getNearestPowerOfTwoWorkGroupSize());
+    max_workgroup_Size = std::min(static_cast<Index>(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1),
+                                  static_cast<Index>(max_workgroup_Size));
+    Index pow_of_2 = static_cast<Index>(std::log2(max_workgroup_Size));
+    local_range[1] = static_cast<Index>(std::pow(2, static_cast<Index>(pow_of_2 / 2)));
+    input_range[1] = input_dim[1];
+    if (input_range[1] == 0) input_range[1] = static_cast<Index>(1);
+    global_range[1] = input_range[1];
+    if (local_range[1] > global_range[1])
+      local_range[1] = global_range[1];
+    else if (global_range[1] > local_range[1]) {
+      Index xMode = static_cast<Index>(global_range[1] % local_range[1]);
+      if (xMode != 0) global_range[1] += static_cast<Index>(local_range[1] - xMode);
+    }
+    local_range[0] = static_cast<Index>(max_workgroup_Size / local_range[1]);
+    input_range[0] = input_dim[0];
+    if (input_range[0] == 0) input_range[0] = static_cast<Index>(1);
+    global_range[0] = input_range[0];
+    if (local_range[0] > global_range[0])
+      local_range[0] = global_range[0];
+    else if (global_range[0] > local_range[0]) {
+      Index xMode = static_cast<Index>(global_range[0] % local_range[0]);
+      if (xMode != 0) global_range[0] += static_cast<Index>(local_range[0] - xMode);
+    }
+  }
+
+  /// This is used to prepare the number of threads and also the number of
+  /// threads per block for sycl kernels
+  template <typename Index>
+  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 3> &input_dim, cl::sycl::range<3> &global_range,
+                                              cl::sycl::range<3> &local_range) const {
+    std::array<Index, 3> input_range = input_dim;
+    Index max_workgroup_Size = static_cast<Index>(getNearestPowerOfTwoWorkGroupSize());
+    max_workgroup_Size = std::min(static_cast<Index>(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1),
+                                  static_cast<Index>(max_workgroup_Size));
+    Index pow_of_2 = static_cast<Index>(std::log2(max_workgroup_Size));
+    local_range[2] = static_cast<Index>(std::pow(2, static_cast<Index>(pow_of_2 / 3)));
+    input_range[2] = input_dim[2];
+    if (input_range[2] == 0) input_range[1] = static_cast<Index>(1);
+    global_range[2] = input_range[2];
+    if (local_range[2] > global_range[2])
+      local_range[2] = global_range[2];
+    else if (global_range[2] > local_range[2]) {
+      Index xMode = static_cast<Index>(global_range[2] % local_range[2]);
+      if (xMode != 0) global_range[2] += static_cast<Index>(local_range[2] - xMode);
+    }
+    pow_of_2 = static_cast<Index>(std::log2(static_cast<Index>(max_workgroup_Size / local_range[2])));
+    local_range[1] = static_cast<Index>(std::pow(2, static_cast<Index>(pow_of_2 / 2)));
+    input_range[1] = input_dim[1];
+    if (input_range[1] == 0) input_range[1] = static_cast<Index>(1);
+    global_range[1] = input_range[1];
+    if (local_range[1] > global_range[1])
+      local_range[1] = global_range[1];
+    else if (global_range[1] > local_range[1]) {
+      Index xMode = static_cast<Index>(global_range[1] % local_range[1]);
+      if (xMode != 0) global_range[1] += static_cast<Index>(local_range[1] - xMode);
+    }
+    local_range[0] = static_cast<Index>(max_workgroup_Size / (local_range[1] * local_range[2]));
+    input_range[0] = input_dim[0];
+    if (input_range[0] == 0) input_range[0] = static_cast<Index>(1);
+    global_range[0] = input_range[0];
+    if (local_range[0] > global_range[0])
+      local_range[0] = global_range[0];
+    else if (global_range[0] > local_range[0]) {
+      Index xMode = static_cast<Index>(global_range[0] % local_range[0]);
+      if (xMode != 0) global_range[0] += static_cast<Index>(local_range[0] - xMode);
+    }
+  }
+
+  EIGEN_STRONG_INLINE bool has_local_memory() const {
+#if !defined(EIGEN_SYCL_LOCAL_MEM) && defined(EIGEN_SYCL_NO_LOCAL_MEM)
+    return false;
+#elif defined(EIGEN_SYCL_LOCAL_MEM) && !defined(EIGEN_SYCL_NO_LOCAL_MEM)
+    return true;
+#else
+    return m_device_info.local_mem_type == cl::sycl::info::local_mem_type::local;
+#endif
+  }
+
+  EIGEN_STRONG_INLINE unsigned long max_buffer_size() const { return m_device_info.max_mem_alloc_size; }
+
+  EIGEN_STRONG_INLINE unsigned long getNumSyclMultiProcessors() const { return m_device_info.max_compute_units; }
+
+  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerBlock() const { return m_device_info.max_work_group_size; }
+
+  EIGEN_STRONG_INLINE cl::sycl::id<3> maxWorkItemSizes() const { return m_device_info.max_work_item_sizes; }
+
+  /// No need for sycl it should act the same as CPU version
+  EIGEN_STRONG_INLINE int majorDeviceVersion() const { return 1; }
+
+  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerMultiProcessor() const {
+    // OpenCL does not have such a concept
+    return 2;
+  }
+
+  EIGEN_STRONG_INLINE size_t sharedMemPerBlock() const { return m_device_info.local_mem_size; }
+
+  // This function returns the nearest power of 2 Work-group size which is <=
+  // maximum device workgroup size.
+  EIGEN_STRONG_INLINE size_t getNearestPowerOfTwoWorkGroupSize() const {
+    return getPowerOfTwo(m_device_info.max_work_group_size, false);
+  }
+
+  EIGEN_STRONG_INLINE std::string getPlatformName() const { return m_device_info.platform_name; }
+
+  EIGEN_STRONG_INLINE std::string getDeviceName() const { return m_device_info.device_name; }
+
+  EIGEN_STRONG_INLINE std::string getDeviceVendor() const { return m_device_info.device_vendor; }
+
+  // This function returns the nearest power of 2
+  // if roundup is true returns result>=wgsize
+  // else it returns result <= wgsize
+  EIGEN_STRONG_INLINE size_t getPowerOfTwo(size_t wGSize, bool roundUp) const {
+    if (roundUp) --wGSize;
+    wGSize |= (wGSize >> 1);
+    wGSize |= (wGSize >> 2);
+    wGSize |= (wGSize >> 4);
+    wGSize |= (wGSize >> 8);
+    wGSize |= (wGSize >> 16);
+#if EIGEN_ARCH_x86_64 || EIGEN_ARCH_ARM64 || EIGEN_OS_WIN64
+    wGSize |= (wGSize >> 32);
+#endif
+    return ((!roundUp) ? (wGSize - (wGSize >> 1)) : ++wGSize);
+  }
+
+  EIGEN_STRONG_INLINE cl::sycl::queue &sycl_queue() const { return m_queue; }
+
+  // This function checks if the runtime recorded an error for the
+  // underlying stream device.
+  EIGEN_STRONG_INLINE bool ok() const {
+    if (!exception_caught_) {
+      synchronize();
+    }
+    return !exception_caught_;
+  }
+
+ protected:
+  void synchronize_and_callback(cl::sycl::event e, const std::function<void()> &callback) const {
+    if (callback) {
+      auto callback_ = [=]() {
+#ifdef EIGEN_EXCEPTIONS
+        cl::sycl::event(e).wait_and_throw();
+#else
+        cl::sycl::event(e).wait();
+#endif
+        callback();
+      };
+      m_thread_pool.Schedule(std::move(callback_));
+    } else {
+#ifdef EIGEN_EXCEPTIONS
+      m_queue.wait_and_throw();
+#else
+      m_queue.wait();
+#endif
+    }
+  }
+
+  bool sycl_async_handler(cl::sycl::exception_list exceptions) const {
+    bool exception_caught = false;
+    for (const auto &e : exceptions) {
+      if (e) {
+        exception_caught = true;
+        EIGEN_THROW_X(e);
+      }
+    }
+    return exception_caught;
+  }
+
+  /// class members:
+  bool exception_caught_ = false;
+  /// sycl queue
+  mutable cl::sycl::queue m_queue;
+  /// The thread pool is used to wait on events and call callbacks
+  /// asynchronously
+  mutable Eigen::ThreadPool m_thread_pool;
+
+  const TensorSycl::internal::SyclDeviceInfo m_device_info;
+};
+
+struct SyclDeviceBase {
+  /// QueueInterface is not owned. it is the caller's responsibility to destroy
+  /// it
+  const QueueInterface *m_queue_stream;
+  explicit SyclDeviceBase(const QueueInterface *queue_stream) : m_queue_stream(queue_stream) {}
+  EIGEN_STRONG_INLINE const QueueInterface *queue_stream() const { return m_queue_stream; }
+};
+
+// Here is a sycl device struct which accept the sycl queue interface
+// as an input
+struct SyclDevice : public SyclDeviceBase {
+  explicit SyclDevice(const QueueInterface *queue_stream) : SyclDeviceBase(queue_stream) {}
+
+  /// This is used to prepare the number of threads and also the number of
+  /// threads per block for sycl kernels
+  template <typename Index>
+  EIGEN_STRONG_INLINE void parallel_for_setup(Index n, Index &tileSize, Index &rng, Index &GRange) const {
+    queue_stream()->parallel_for_setup(n, tileSize, rng, GRange);
+  }
+
+  /// This is used to prepare the number of threads and also the number of
+  /// threads per block for sycl kernels
+  template <typename Index>
+  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 2> &input_dim, cl::sycl::range<2> &global_range,
+                                              cl::sycl::range<2> &local_range) const {
+    queue_stream()->parallel_for_setup(input_dim, global_range, local_range);
+  }
+
+  /// This is used to prepare the number of threads and also the number of
+  /// threads per block for sycl kernels
+  template <typename Index>
+  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 3> &input_dim, cl::sycl::range<3> &global_range,
+                                              cl::sycl::range<3> &local_range) const {
+    queue_stream()->parallel_for_setup(input_dim, global_range, local_range);
+  }
+
+  /// allocate device memory
+  EIGEN_STRONG_INLINE void *allocate(size_t num_bytes) const { return queue_stream()->allocate(num_bytes); }
+
+  EIGEN_STRONG_INLINE void *allocate_temp(size_t num_bytes) const { return queue_stream()->allocate_temp(num_bytes); }
+
+  /// deallocate device memory
+  EIGEN_STRONG_INLINE void deallocate(void *p) const { queue_stream()->deallocate(p); }
+
+  EIGEN_STRONG_INLINE void deallocate_temp(void *buffer) const { queue_stream()->deallocate_temp(buffer); }
+
+  EIGEN_STRONG_INLINE void deallocate_temp(const void *buffer) const { queue_stream()->deallocate_temp(buffer); }
+
+  template <typename data_t>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE data_t *get(data_t *data) const {
+    return data;
+  }
+
+  // some runtime conditions that can be applied here
+  EIGEN_STRONG_INLINE bool isDeviceSuitable() const { return true; }
+
+  /// memcpyHostToDevice
+  template <typename Index>
+  EIGEN_STRONG_INLINE void memcpyHostToDevice(Index *dst, const Index *src, size_t n,
+                                              std::function<void()> callback = {}) const {
+    queue_stream()->memcpyHostToDevice(dst, src, n, callback);
+  }
+  /// memcpyDeviceToHost
+  template <typename Index>
+  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void *dst, const Index *src, size_t n,
+                                              std::function<void()> callback = {}) const {
+    queue_stream()->memcpyDeviceToHost(dst, src, n, callback);
+  }
+  /// the memcpy function
+  template <typename Index>
+  EIGEN_STRONG_INLINE void memcpy(void *dst, const Index *src, size_t n) const {
+    queue_stream()->memcpy(dst, src, n);
+  }
+  /// the memset function
+  EIGEN_STRONG_INLINE void memset(void *data, int c, size_t n) const { queue_stream()->memset(data, c, n); }
+  /// the fill function
+  template <typename T>
+  EIGEN_STRONG_INLINE void fill(T *begin, T *end, const T &value) const {
+    queue_stream()->fill(begin, end, value);
+  }
+  /// returning the sycl queue
+  EIGEN_STRONG_INLINE cl::sycl::queue &sycl_queue() const { return queue_stream()->sycl_queue(); }
+
+  EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const { return 48 * 1024; }
+
+  EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
+    // We won't try to take advantage of the l2 cache for the time being, and
+    // there is no l3 cache on sycl devices.
+    return firstLevelCacheSize();
+  }
+  EIGEN_STRONG_INLINE unsigned long getNumSyclMultiProcessors() const {
+    return queue_stream()->getNumSyclMultiProcessors();
+  }
+  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerBlock() const { return queue_stream()->maxSyclThreadsPerBlock(); }
+  EIGEN_STRONG_INLINE cl::sycl::id<3> maxWorkItemSizes() const { return queue_stream()->maxWorkItemSizes(); }
+  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerMultiProcessor() const {
+    // OpenCL does not have such a concept
+    return queue_stream()->maxSyclThreadsPerMultiProcessor();
+  }
+  EIGEN_STRONG_INLINE size_t sharedMemPerBlock() const { return queue_stream()->sharedMemPerBlock(); }
+  EIGEN_STRONG_INLINE size_t getNearestPowerOfTwoWorkGroupSize() const {
+    return queue_stream()->getNearestPowerOfTwoWorkGroupSize();
+  }
+
+  EIGEN_STRONG_INLINE size_t getPowerOfTwo(size_t val, bool roundUp) const {
+    return queue_stream()->getPowerOfTwo(val, roundUp);
+  }
+  /// No need for sycl it should act the same as CPU version
+  EIGEN_STRONG_INLINE int majorDeviceVersion() const { return queue_stream()->majorDeviceVersion(); }
+
+  EIGEN_STRONG_INLINE void synchronize() const { queue_stream()->synchronize(); }
+
+  // This function checks if the runtime recorded an error for the
+  // underlying stream device.
+  EIGEN_STRONG_INLINE bool ok() const { return queue_stream()->ok(); }
+
+  EIGEN_STRONG_INLINE bool has_local_memory() const { return queue_stream()->has_local_memory(); }
+  EIGEN_STRONG_INLINE long max_buffer_size() const { return queue_stream()->max_buffer_size(); }
+  EIGEN_STRONG_INLINE std::string getPlatformName() const { return queue_stream()->getPlatformName(); }
+  EIGEN_STRONG_INLINE std::string getDeviceName() const { return queue_stream()->getDeviceName(); }
+  EIGEN_STRONG_INLINE std::string getDeviceVendor() const { return queue_stream()->getDeviceVendor(); }
+  template <typename OutScalar, typename KernelType, typename... T>
+  EIGEN_ALWAYS_INLINE cl::sycl::event binary_kernel_launcher(T... var) const {
+    return queue_stream()->template binary_kernel_launcher<OutScalar, KernelType>(var...);
+  }
+  template <typename OutScalar, typename KernelType, typename... T>
+  EIGEN_ALWAYS_INLINE cl::sycl::event unary_kernel_launcher(T... var) const {
+    return queue_stream()->template unary_kernel_launcher<OutScalar, KernelType>(var...);
+  }
+
+  template <typename OutScalar, typename KernelType, typename... T>
+  EIGEN_ALWAYS_INLINE cl::sycl::event nullary_kernel_launcher(T... var) const {
+    return queue_stream()->template nullary_kernel_launcher<OutScalar, KernelType>(var...);
+  }
+};
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_DEVICE_SYCL_H
diff --git a/contrib/Eigen/src/Tensor/TensorDeviceThreadPool.h b/contrib/Eigen/src/Tensor/TensorDeviceThreadPool.h
new file mode 100644
index 0000000..b1d1b81
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDeviceThreadPool.h
@@ -0,0 +1,346 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#if defined(EIGEN_USE_THREADS) && !defined(EIGEN_TENSOR_TENSOR_DEVICE_THREAD_POOL_H)
+#define EIGEN_TENSOR_TENSOR_DEVICE_THREAD_POOL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+// An abstract interface to a device specific memory allocator.
+class Allocator {
+ public:
+  virtual ~Allocator() = default;
+  virtual void* allocate(size_t num_bytes) const = 0;
+  virtual void deallocate(void* buffer) const = 0;
+};
+
+// Build a thread pool device on top of an existing pool of threads.
+struct ThreadPoolDevice {
+  // The ownership of the thread pool remains with the caller.
+  ThreadPoolDevice(ThreadPoolInterface* pool, int num_cores, Allocator* allocator = nullptr)
+      : pool_(pool), num_threads_(num_cores), allocator_(allocator) {}
+
+  EIGEN_STRONG_INLINE void* allocate(size_t num_bytes) const {
+    return allocator_ ? allocator_->allocate(num_bytes) : internal::aligned_malloc(num_bytes);
+  }
+
+  EIGEN_STRONG_INLINE void deallocate(void* buffer) const {
+    if (allocator_) {
+      allocator_->deallocate(buffer);
+    } else {
+      internal::aligned_free(buffer);
+    }
+  }
+
+  EIGEN_STRONG_INLINE void* allocate_temp(size_t num_bytes) const { return allocate(num_bytes); }
+
+  EIGEN_STRONG_INLINE void deallocate_temp(void* buffer) const { deallocate(buffer); }
+
+  template <typename Type>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type get(Type data) const {
+    return data;
+  }
+
+  EIGEN_STRONG_INLINE void memcpy(void* dst, const void* src, size_t n) const {
+#ifdef __ANDROID__
+    ::memcpy(dst, src, n);
+#else
+    // TODO(rmlarsen): Align blocks on cache lines.
+    const size_t kMinBlockSize = 32768;
+    // Pure memory op (zero compute) — the cost model's bandwidth saturation
+    // cap will limit threads appropriately.
+    const size_t num_threads = CostModel::numThreads(n, TensorOpCost(1.0, 1.0, 0), static_cast<int>(numThreads()));
+    if (n <= kMinBlockSize || num_threads < 2) {
+      ::memcpy(dst, src, n);
+    } else {
+      const char* src_ptr = static_cast<const char*>(src);
+      char* dst_ptr = static_cast<char*>(dst);
+      const size_t blocksize = (n + (num_threads - 1)) / num_threads;
+      Barrier barrier(static_cast<int>(num_threads - 1));
+      // Schedule blocks 1..num_threads-1 on worker threads.
+      for (size_t i = 1; i < num_threads; ++i) {
+        pool_->Schedule([n, i, src_ptr, dst_ptr, blocksize, &barrier] {
+          ::memcpy(dst_ptr + i * blocksize, src_ptr + i * blocksize, numext::mini(blocksize, n - (i * blocksize)));
+          barrier.Notify();
+        });
+      }
+      // Run the first block on the calling thread.
+      ::memcpy(dst_ptr, src_ptr, blocksize);
+      barrier.Wait();
+    }
+#endif
+  }
+  EIGEN_STRONG_INLINE void memcpyHostToDevice(void* dst, const void* src, size_t n) const { memcpy(dst, src, n); }
+  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void* dst, const void* src, size_t n) const { memcpy(dst, src, n); }
+
+  EIGEN_STRONG_INLINE void memset(void* buffer, int c, size_t n) const { ::memset(buffer, c, n); }
+
+  template <typename T>
+  EIGEN_STRONG_INLINE void fill(T* begin, T* end, const T& value) const {
+    std::fill(begin, end, value);
+  }
+
+  EIGEN_STRONG_INLINE int numThreads() const { return num_threads_; }
+
+  // Number of threads available in the underlying thread pool. This number can
+  // be different from the value returned by numThreads().
+  EIGEN_STRONG_INLINE int numThreadsInPool() const { return pool_->NumThreads(); }
+
+  EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const { return l1CacheSize(); }
+
+  EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
+    // The l3 cache size is shared between all the cores.
+    return l3CacheSize() / num_threads_;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void synchronize() const {
+    // Nothing.  Threadpool device operations are synchronous.
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int majorDeviceVersion() const {
+    // Should return an enum that encodes the ISA supported by the CPU
+    return 1;
+  }
+
+  // TODO(rmlarsen): Remove this deprecated interface when all users have been converted.
+  template <class Function, class... Args>
+  EIGEN_STRONG_INLINE void enqueueNoNotification(Function&& f, Args&&... args) const {
+    enqueue(std::forward<Function>(f), std::forward<Args>(args)...);
+  }
+
+  template <class Function, class... Args>
+  EIGEN_STRONG_INLINE void enqueue(Function&& f, Args&&... args) const {
+    if (sizeof...(args) > 0) {
+#if EIGEN_COMP_CXXVER >= 20
+      // C++20 pack-expansion init capture decay-copies args into a lambda
+      // small enough to fit in std::function's SBO for typical arg counts.
+      pool_->Schedule([f = std::forward<Function>(f), ... args = std::forward<Args>(args)]() { f(args...); });
+#else
+      // Pre-C++20 fallback: std::bind decay-copies the arguments so they
+      // outlive the deferred call even when the caller passes temporaries.
+      // The closure exceeds std::function's SBO and forces a heap allocation
+      // that the C++20 path above avoids.
+      pool_->Schedule(std::bind(std::forward<Function>(f), std::forward<Args>(args)...));
+#endif
+    } else {
+      pool_->Schedule(std::forward<Function>(f));
+    }
+  }
+
+  // Returns a logical thread index between 0 and pool_->NumThreads() - 1 if
+  // called from one of the threads in pool_. Returns -1 otherwise.
+  EIGEN_STRONG_INLINE int currentThreadId() const { return pool_->CurrentThreadId(); }
+
+  // WARNING: This function is synchronous and will block the calling thread.
+  //
+  // Synchronous parallelFor executes f with [0, n) arguments in parallel and
+  // waits for completion. F accepts a half-open interval [first, last). Block
+  // size is chosen based on the iteration cost and resulting parallel
+  // efficiency. If block_align is not nullptr, it is called to round up the
+  // block size.
+  void parallelFor(Index n, const TensorOpCost& cost, std::function<Index(Index)> block_align,
+                   std::function<void(Index, Index)> f) const {
+    if (EIGEN_PREDICT_FALSE(n <= 0)) {
+      return;
+    }
+    // Compute small problems directly in the caller thread.
+    if (n == 1 || numThreads() == 1 || CostModel::numThreads(n, cost, static_cast<int>(numThreads())) == 1) {
+      f(0, n);
+      return;
+    }
+
+    // Compute block size and total count of blocks.
+    ParallelForBlock block = CalculateParallelForBlock(n, cost, block_align);
+
+    // Recursively divide size into halves until we reach block_size.
+    // Division code rounds mid to block_size, so we are guaranteed to get
+    // block_count leaves that do actual computations.
+    Barrier barrier(static_cast<unsigned int>(block.count));
+    if (block.count <= numThreads()) {
+      // Avoid a thread hop by running the root of the tree and one block on the
+      // main thread.
+      handleRange(0, n, block.size, &barrier, pool_, f);
+    } else {
+      // Execute the root in the thread pool to avoid running work on more than
+      // numThreads() threads.
+      pool_->Schedule([this, n, &block, &barrier, &f]() { handleRange(0, n, block.size, &barrier, pool_, f); });
+    }
+
+    barrier.Wait();
+  }
+
+  // Convenience wrapper for parallelFor that does not align blocks.
+  void parallelFor(Index n, const TensorOpCost& cost, std::function<void(Index, Index)> f) const {
+    parallelFor(n, cost, nullptr, std::move(f));
+  }
+
+  // WARNING: This function is asynchronous and will not block the calling thread.
+  //
+  // Asynchronous parallelFor executes f with [0, n) arguments in parallel
+  // without waiting for completion. When the last block finished, it will call
+  // 'done' callback. F accepts a half-open interval [first, last). Block size
+  // is chosen based on the iteration cost and resulting parallel efficiency. If
+  // block_align is not nullptr, it is called to round up the block size.
+  void parallelForAsync(Index n, const TensorOpCost& cost, std::function<Index(Index)> block_align,
+                        std::function<void(Index, Index)> f, std::function<void()> done) const {
+    // Compute small problems directly in the caller thread.
+    if (n <= 1 || numThreads() == 1 || CostModel::numThreads(n, cost, static_cast<int>(numThreads())) == 1) {
+      f(0, n);
+      done();
+      return;
+    }
+
+    // Compute block size and total count of blocks.
+    ParallelForBlock block = CalculateParallelForBlock(n, cost, block_align);
+
+    ParallelForAsyncContext* const ctx =
+        new ParallelForAsyncContext(block.count, block.size, pool_, std::move(f), std::move(done));
+
+    if (block.count <= numThreads()) {
+      // Avoid a thread hop by running the root of the tree and one block on the
+      // main thread.
+      handleRangeAsync(ctx, 0, n);
+    } else {
+      // Execute the root in the thread pool to avoid running work on more than
+      // numThreads() threads.
+      pool_->Schedule([ctx, n]() { handleRangeAsync(ctx, 0, n); });
+    }
+  }
+
+  // Convenience wrapper for parallelForAsync that does not align blocks.
+  void parallelForAsync(Index n, const TensorOpCost& cost, std::function<void(Index, Index)> f,
+                        std::function<void()> done) const {
+    parallelForAsync(n, cost, nullptr, std::move(f), std::move(done));
+  }
+
+  // Thread pool accessor.
+  ThreadPoolInterface* getPool() const { return pool_; }
+
+  // Allocator accessor.
+  Allocator* allocator() const { return allocator_; }
+
+ private:
+  typedef TensorCostModel<ThreadPoolDevice> CostModel;
+
+  static void handleRange(Index firstIdx, Index lastIdx, Index granularity, Barrier* barrier, ThreadPoolInterface* pool,
+                          const std::function<void(Index, Index)>& f) {
+    while (lastIdx - firstIdx > granularity) {
+      // Split into halves and schedule the second half on a different thread.
+      const Index midIdx = firstIdx + numext::div_ceil((lastIdx - firstIdx) / 2, granularity) * granularity;
+      pool->Schedule([=, &f]() { handleRange(midIdx, lastIdx, granularity, barrier, pool, f); });
+      lastIdx = midIdx;
+    }
+    // Single block or less, execute directly.
+    f(firstIdx, lastIdx);
+    barrier->Notify();
+  }
+
+  // For parallelForAsync we must keep passed in closures on the heap, and
+  // delete them only after `done` callback finished.
+  struct ParallelForAsyncContext {
+    ParallelForAsyncContext(Index block_count, Index block_size, ThreadPoolInterface* p,
+                            std::function<void(Index, Index)> block_f, std::function<void()> done_callback)
+        : count(block_count), granularity(block_size), pool(p), f(std::move(block_f)), done(std::move(done_callback)) {}
+    ~ParallelForAsyncContext() { done(); }
+
+    std::atomic<Index> count;
+    Index granularity;
+    ThreadPoolInterface* pool;
+    std::function<void(Index, Index)> f;
+    std::function<void()> done;
+  };
+
+  // Async counterpart of handleRange: no Barrier, deletes the heap-allocated
+  // context once the final block has run.
+  static void handleRangeAsync(ParallelForAsyncContext* ctx, Index firstIdx, Index lastIdx) {
+    while (lastIdx - firstIdx > ctx->granularity) {
+      const Index midIdx = firstIdx + numext::div_ceil((lastIdx - firstIdx) / 2, ctx->granularity) * ctx->granularity;
+      ctx->pool->Schedule([ctx, midIdx, lastIdx]() { handleRangeAsync(ctx, midIdx, lastIdx); });
+      lastIdx = midIdx;
+    }
+    ctx->f(firstIdx, lastIdx);
+    if (ctx->count.fetch_sub(1) == 1) delete ctx;
+  }
+
+  struct ParallelForBlock {
+    Index size;   // block size
+    Index count;  // number of blocks
+  };
+
+  // Calculates block size based on (1) the iteration cost and (2) parallel
+  // efficiency. We want blocks to be not too small to mitigate parallelization
+  // overheads; not too large to mitigate tail effect and potential load
+  // imbalance and we also want number of blocks to be evenly dividable across
+  // threads.
+  ParallelForBlock CalculateParallelForBlock(const Index n, const TensorOpCost& cost,
+                                             std::function<Index(Index)> block_align) const {
+    const double block_size_f = 1.0 / CostModel::taskSize(1, cost);
+    const Index max_oversharding_factor = 4;
+    Index block_size = numext::mini(
+        n, numext::maxi<Index>(numext::div_ceil<Index>(n, max_oversharding_factor * numThreads()), block_size_f));
+    const Index max_block_size = numext::mini(n, 2 * block_size);
+
+    if (block_align) {
+      Index new_block_size = block_align(block_size);
+      eigen_assert(new_block_size >= block_size);
+      block_size = numext::mini(n, new_block_size);
+    }
+
+    Index block_count = numext::div_ceil(n, block_size);
+
+    // Calculate parallel efficiency as fraction of total CPU time used for
+    // computations:
+    double max_efficiency =
+        static_cast<double>(block_count) / (numext::div_ceil<Index>(block_count, numThreads()) * numThreads());
+
+    // Now try to increase block size up to max_block_size as long as it
+    // doesn't decrease parallel efficiency.
+    for (Index prev_block_count = block_count; max_efficiency < 1.0 && prev_block_count > 1;) {
+      // This is the next block size that divides size into a smaller number
+      // of blocks than the current block_size.
+      Index coarser_block_size = numext::div_ceil(n, prev_block_count - 1);
+      if (block_align) {
+        Index new_block_size = block_align(coarser_block_size);
+        eigen_assert(new_block_size >= coarser_block_size);
+        coarser_block_size = numext::mini(n, new_block_size);
+      }
+      if (coarser_block_size > max_block_size) {
+        break;  // Reached max block size. Stop.
+      }
+      // Recalculate parallel efficiency.
+      const Index coarser_block_count = numext::div_ceil(n, coarser_block_size);
+      eigen_assert(coarser_block_count < prev_block_count);
+      prev_block_count = coarser_block_count;
+      const double coarser_efficiency = static_cast<double>(coarser_block_count) /
+                                        (numext::div_ceil<Index>(coarser_block_count, numThreads()) * numThreads());
+      if (coarser_efficiency + 0.01 >= max_efficiency) {
+        // Taking it.
+        block_size = coarser_block_size;
+        block_count = coarser_block_count;
+        if (max_efficiency < coarser_efficiency) {
+          max_efficiency = coarser_efficiency;
+        }
+      }
+    }
+
+    return {block_size, block_count};
+  }
+
+  ThreadPoolInterface* pool_;
+  int num_threads_;
+  Allocator* allocator_;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_DEVICE_THREAD_POOL_H
diff --git a/contrib/Eigen/src/Tensor/TensorDimensionList.h b/contrib/Eigen/src/Tensor/TensorDimensionList.h
new file mode 100644
index 0000000..634afc9
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDimensionList.h
@@ -0,0 +1,86 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_DIMENSION_LIST_H
+#define EIGEN_TENSOR_TENSOR_DIMENSION_LIST_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \internal
+ *
+ * \ingroup Tensor_Module
+ *
+ * \brief Special case of tensor index list used to list all the dimensions of a tensor of rank n.
+ *
+ * \sa Tensor
+ */
+template <typename Index, std::size_t Rank>
+struct DimensionList {
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const Index operator[](const Index i) const { return i; }
+};
+
+namespace internal {
+
+template <typename Index, std::size_t Rank>
+struct array_size<DimensionList<Index, Rank> > {
+  static constexpr size_t value = Rank;
+};
+template <typename Index, std::size_t Rank>
+struct array_size<const DimensionList<Index, Rank> > {
+  static constexpr size_t value = Rank;
+};
+
+template <DenseIndex n, typename Index, std::size_t Rank>
+constexpr Index array_get(const DimensionList<Index, Rank>&) {
+  return n;
+}
+
+template <typename Index, std::size_t Rank>
+struct index_known_statically_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex) { return true; }
+};
+
+template <typename Index, std::size_t Rank>
+struct all_indices_known_statically_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run() { return true; }
+};
+
+template <typename Index, std::size_t Rank>
+struct indices_statically_known_to_increase_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run() { return true; }
+};
+
+template <typename Index, std::size_t Rank>
+struct index_statically_eq_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i == value; }
+};
+
+template <typename Index, std::size_t Rank>
+struct index_statically_ne_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i != value; }
+};
+
+template <typename Index, std::size_t Rank>
+struct index_statically_gt_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i > value; }
+};
+
+template <typename Index, std::size_t Rank>
+struct index_statically_lt_impl<DimensionList<Index, Rank> > {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i < value; }
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_DIMENSION_LIST_H
diff --git a/contrib/Eigen/src/Tensor/TensorDimensions.h b/contrib/Eigen/src/Tensor/TensorDimensions.h
new file mode 100644
index 0000000..9de06e7
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorDimensions.h
@@ -0,0 +1,326 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_DIMENSIONS_H
+#define EIGEN_TENSOR_TENSOR_DIMENSIONS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+// Boilerplate code
+namespace internal {
+
+template <std::ptrdiff_t n, typename Dimension>
+struct dget;
+
+template <std::ptrdiff_t n, typename T, T first, T... rest>
+struct dget<n, std::integer_sequence<T, first, rest...>> : dget<n - 1, std::integer_sequence<T, rest...>> {};
+
+template <typename T, T first, T... rest>
+struct dget<0, std::integer_sequence<T, first, rest...>> {
+  static constexpr T value = first;
+};
+
+template <typename Index, std::ptrdiff_t NumIndices, std::ptrdiff_t n, bool RowMajor>
+struct fixed_size_tensor_index_linearization_helper {
+  template <typename Dimensions>
+  constexpr EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
+                                                                   const Dimensions& dimensions) {
+    return array_get < RowMajor                             ? n - 1
+           : (NumIndices - n) > (indices) + dget < RowMajor ? n - 1
+                                                            : (NumIndices - n),
+           Dimensions > ::value * fixed_size_tensor_index_linearization_helper<Index, NumIndices, n - 1, RowMajor>::run(
+                                      indices, dimensions);
+  }
+};
+
+template <typename Index, std::ptrdiff_t NumIndices, bool RowMajor>
+struct fixed_size_tensor_index_linearization_helper<Index, NumIndices, 0, RowMajor> {
+  template <typename Dimensions>
+  constexpr EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const&, const Dimensions&) {
+    return 0;
+  }
+};
+
+template <typename Index, std::ptrdiff_t n>
+struct fixed_size_tensor_index_extraction_helper {
+  template <typename Dimensions>
+  constexpr EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(const Index index, const Dimensions& dimensions) {
+    const Index mult = (index == n - 1) ? 1 : 0;
+    return dget<n - 1, Dimensions>::value * mult +
+           fixed_size_tensor_index_extraction_helper<Index, n - 1>::run(index, dimensions);
+  }
+};
+
+template <typename Index>
+struct fixed_size_tensor_index_extraction_helper<Index, 0> {
+  template <typename Dimensions>
+  constexpr EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(const Index, const Dimensions&) {
+    return 0;
+  }
+};
+
+}  // end namespace internal
+
+/** \internal
+ *
+ * \ingroup Tensor_Module
+ *
+ * \brief Fixed dimensions of a Tensor.
+ *
+ * The Sizes class encodes as part of the type the number of dimensions and the
+ * sizes corresponding to each dimension. It uses no storage space since it is
+ * entirely known at compile time.
+ *
+ * \sa Tensor
+ */
+template <std::ptrdiff_t... Indices>
+struct Sizes {
+  typedef std::integer_sequence<std::ptrdiff_t, Indices...> Base;
+  const Base t = Base();
+  static constexpr std::ptrdiff_t total_size = internal::arg_prod(Indices...);
+  static constexpr ptrdiff_t count = sizeof...(Indices);
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t rank() const { return count; }
+
+  static constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t TotalSize() {
+    return internal::arg_prod(Indices...);
+  }
+
+  constexpr EIGEN_DEVICE_FUNC Sizes() = default;
+  template <typename DenseIndex>
+  explicit constexpr EIGEN_DEVICE_FUNC Sizes(const array<DenseIndex, count>& /*indices*/) {
+    // TODO: Add assertion.
+  }
+  template <typename... DenseIndex>
+  constexpr EIGEN_DEVICE_FUNC Sizes(DenseIndex...) {}
+  explicit EIGEN_DEVICE_FUNC Sizes(std::initializer_list<std::ptrdiff_t> /*l*/) {
+    // TODO: Add assertion.
+  }
+
+  template <typename T>
+  Sizes& operator=(const T& /*other*/) {
+    // add assertion failure if the size of other is different
+    return *this;
+  }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t operator[](const std::ptrdiff_t index) const {
+    return internal::fixed_size_tensor_index_extraction_helper<std::ptrdiff_t, count>::run(index, t);
+  }
+
+  template <typename DenseIndex>
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptrdiff_t
+  IndexOfColMajor(const array<DenseIndex, count>& indices) const {
+    return internal::fixed_size_tensor_index_linearization_helper<DenseIndex, count, count, false>::run(indices, t);
+  }
+  template <typename DenseIndex>
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptrdiff_t
+  IndexOfRowMajor(const array<DenseIndex, count>& indices) const {
+    return internal::fixed_size_tensor_index_linearization_helper<DenseIndex, count, count, true>::run(indices, t);
+  }
+};
+
+namespace internal {
+template <std::ptrdiff_t... Indices>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_prod(const Sizes<Indices...>&) {
+  return Sizes<Indices...>::total_size;
+}
+}  // namespace internal
+
+// Boilerplate
+namespace internal {
+template <typename Index, std::ptrdiff_t NumIndices, std::ptrdiff_t n, bool RowMajor>
+struct tensor_index_linearization_helper {
+  static constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
+                                                                   array<Index, NumIndices> const& dimensions) {
+    return array_get < RowMajor ? n
+           : (NumIndices - n - 1) > (indices) + array_get < RowMajor
+               ? n
+               : (NumIndices - n - 1) >
+                     (dimensions)*tensor_index_linearization_helper<Index, NumIndices, n - 1, RowMajor>::run(
+                         indices, dimensions);
+  }
+};
+
+template <typename Index, std::ptrdiff_t NumIndices, bool RowMajor>
+struct tensor_index_linearization_helper<Index, NumIndices, 0, RowMajor> {
+  static constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
+                                                                   array<Index, NumIndices> const&) {
+    return array_get < RowMajor ? 0 : NumIndices - 1 > (indices);
+  }
+};
+}  // end namespace internal
+
+/** \internal
+ *
+ * \ingroup Tensor_Module
+ *
+ * \brief Dynamic dimensions of a Tensor.
+ *
+ * The DSizes class is its dynamic sibling: the number of dimensions is known
+ * at compile time but the sizes are set during execution.
+ *
+ * \sa Tensor
+ */
+template <typename DenseIndex, int NumDims>
+struct DSizes : array<DenseIndex, NumDims> {
+  typedef array<DenseIndex, NumDims> Base;
+  static constexpr int count = NumDims;
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return NumDims; }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex TotalSize() const {
+    return (NumDims == 0) ? 1 : internal::array_prod(*static_cast<const Base*>(this));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DSizes() {
+    for (int i = 0; i < NumDims; ++i) {
+      (*this)[i] = 0;
+    }
+  }
+  EIGEN_DEVICE_FUNC explicit DSizes(const array<DenseIndex, NumDims>& a) : Base(a) {}
+
+  EIGEN_DEVICE_FUNC explicit DSizes(const DenseIndex i0) {
+    eigen_assert(NumDims == 1);
+    (*this)[0] = i0;
+  }
+
+  EIGEN_DEVICE_FUNC DSizes(const DimensionList<DenseIndex, NumDims>& a) {
+    for (int i = 0; i < NumDims; ++i) {
+      (*this)[i] = a[i];
+    }
+  }
+
+  // Enable DSizes index type promotion only if we are promoting to the
+  // larger type, e.g. allow to promote dimensions of type int to long.
+  template <typename OtherIndex,
+            std::enable_if_t<
+                std::is_same<DenseIndex, typename internal::promote_index_type<DenseIndex, OtherIndex>::type>::value,
+                int> = 0>
+  EIGEN_DEVICE_FUNC explicit DSizes(const array<OtherIndex, NumDims>& other) {
+    for (int i = 0; i < NumDims; ++i) {
+      (*this)[i] = static_cast<DenseIndex>(other[i]);
+    }
+  }
+
+  template <typename OtherIndex>
+  EIGEN_DEPRECATED_WITH_REASON("Omit the implementation-only second argument.")
+  EIGEN_DEVICE_FUNC explicit DSizes(
+      const array<OtherIndex, NumDims>& other,
+      std::enable_if_t<
+          std::is_same<DenseIndex, typename internal::promote_index_type<DenseIndex, OtherIndex>::type>::value, void*>)
+      : DSizes(other) {}
+
+  template <typename FirstType, typename... OtherTypes>
+  EIGEN_DEVICE_FUNC explicit DSizes(const Eigen::IndexList<FirstType, OtherTypes...>& dimensions) {
+    for (int i = 0; i < dimensions.count; ++i) {
+      (*this)[i] = dimensions[i];
+    }
+  }
+
+  template <std::ptrdiff_t... Indices>
+  EIGEN_DEVICE_FUNC DSizes(const Sizes<Indices...>& a) {
+    for (int i = 0; i < NumDims; ++i) {
+      (*this)[i] = a[i];
+    }
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit DSizes(DenseIndex firstDimension, DenseIndex secondDimension,
+                                                        IndexTypes... otherDimensions)
+      : Base({{firstDimension, secondDimension, static_cast<DenseIndex>(otherDimensions)...}}) {
+    EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 2 == NumDims, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<DenseIndex>(otherDimensions...));
+  }
+
+  EIGEN_DEVICE_FUNC DSizes& operator=(const array<DenseIndex, NumDims>& other) {
+    *static_cast<Base*>(this) = other;
+    return *this;
+  }
+
+  // A constexpr would be so much better here
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex IndexOfColMajor(const array<DenseIndex, NumDims>& indices) const {
+    return internal::tensor_index_linearization_helper<DenseIndex, NumDims, NumDims - 1, false>::run(
+        indices, *static_cast<const Base*>(this));
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex IndexOfRowMajor(const array<DenseIndex, NumDims>& indices) const {
+    return internal::tensor_index_linearization_helper<DenseIndex, NumDims, NumDims - 1, true>::run(
+        indices, *static_cast<const Base*>(this));
+  }
+};
+
+template <typename IndexType, int NumDims>
+std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dims) {
+  os << "[";
+  for (int i = 0; i < NumDims; ++i) {
+    if (i > 0) os << ", ";
+    os << dims[i];
+  }
+  os << "]";
+  return os;
+}
+
+namespace internal {
+
+template <typename DenseIndex, int NumDims>
+struct array_size<const DSizes<DenseIndex, NumDims>> {
+  static constexpr ptrdiff_t value = NumDims;
+};
+template <typename DenseIndex, int NumDims>
+struct array_size<DSizes<DenseIndex, NumDims>> {
+  static constexpr ptrdiff_t value = NumDims;
+};
+template <std::ptrdiff_t... Indices>
+struct array_size<const Sizes<Indices...>> {
+  static constexpr std::ptrdiff_t value = Sizes<Indices...>::count;
+};
+template <std::ptrdiff_t... Indices>
+struct array_size<Sizes<Indices...>> {
+  static constexpr std::ptrdiff_t value = Sizes<Indices...>::count;
+};
+template <std::ptrdiff_t n, std::ptrdiff_t... Indices>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_get(const Sizes<Indices...>&) {
+  return dget<n, typename Sizes<Indices...>::Base>::value;
+}
+template <std::ptrdiff_t n>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_get(const Sizes<>&) {
+  eigen_assert(false && "should never be called");
+  return -1;
+}
+
+template <typename Dims1, typename Dims2, ptrdiff_t n, ptrdiff_t m>
+struct sizes_match_below_dim {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(const Dims1&, const Dims2&) { return false; }
+};
+template <typename Dims1, typename Dims2, ptrdiff_t n>
+struct sizes_match_below_dim<Dims1, Dims2, n, n> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(const Dims1& dims1, const Dims2& dims2) {
+    return numext::equal_strict(array_get<n - 1>(dims1), array_get<n - 1>(dims2)) &&
+           sizes_match_below_dim<Dims1, Dims2, n - 1, n - 1>::run(dims1, dims2);
+  }
+};
+template <typename Dims1, typename Dims2>
+struct sizes_match_below_dim<Dims1, Dims2, 0, 0> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(const Dims1&, const Dims2&) { return true; }
+};
+
+}  // end namespace internal
+
+template <typename Dims1, typename Dims2>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool dimensions_match(const Dims1& dims1, const Dims2& dims2) {
+  return internal::sizes_match_below_dim<Dims1, Dims2, internal::array_size<Dims1>::value,
+                                         internal::array_size<Dims2>::value>::run(dims1, dims2);
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_DIMENSIONS_H
diff --git a/contrib/Eigen/src/Tensor/TensorEvalTo.h b/contrib/Eigen/src/Tensor/TensorEvalTo.h
new file mode 100644
index 0000000..bd5b78e
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorEvalTo.h
@@ -0,0 +1,178 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_EVAL_TO_H
+#define EIGEN_TENSOR_TENSOR_EVAL_TO_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename XprType, template <class> class MakePointer_>
+struct traits<TensorEvalToOp<XprType, MakePointer_> > {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename MakePointer_<Scalar>::Type PointerType;
+
+  enum { Flags = 0 };
+  template <class T>
+  struct MakePointer {
+    typedef typename MakePointer_<T>::Type Type;
+  };
+};
+
+template <typename XprType, template <class> class MakePointer_>
+struct eval<TensorEvalToOp<XprType, MakePointer_>, Eigen::Dense> {
+  typedef const TensorEvalToOp<XprType, MakePointer_>& type;
+};
+
+}  // end namespace internal
+
+template <typename XprType, template <class> class MakePointer_>
+class TensorEvalToOp : public TensorBase<TensorEvalToOp<XprType, MakePointer_>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorEvalToOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename MakePointer_<CoeffReturnType>::Type PointerType;
+  typedef typename Eigen::internal::ref_selector<TensorEvalToOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorEvalToOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorEvalToOp>::Index Index;
+
+  static constexpr int NumDims = Eigen::internal::traits<TensorEvalToOp>::NumDimensions;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvalToOp(PointerType buffer, const XprType& expr)
+      : m_xpr(expr), m_buffer(buffer) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_DEVICE_FUNC PointerType buffer() const { return m_buffer; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  PointerType m_buffer;
+};
+
+template <typename ArgType, typename Device, template <class> class MakePointer_>
+struct TensorEvaluator<const TensorEvalToOp<ArgType, MakePointer_>, Device> {
+  typedef TensorEvalToOp<ArgType, MakePointer_> XprType;
+  typedef typename ArgType::Scalar Scalar;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  typedef typename XprType::Index Index;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = true,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = true
+  };
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  static constexpr int NumDims = internal::traits<ArgType>::NumDimensions;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
+
+  typedef internal::TensorBlockAssignment<CoeffReturnType, NumDims, typename ArgTensorBlock::XprType, Index>
+      TensorBlockAssignment;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_buffer(device.get(op.buffer())), m_expression(op.expression()) {}
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_impl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType scalar) {
+    EIGEN_UNUSED_VARIABLE(scalar);
+    eigen_assert(scalar == nullptr);
+    return m_impl.evalSubExprsIfNeeded(m_buffer);
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType scalar, EvalSubExprsCallback done) {
+    EIGEN_UNUSED_VARIABLE(scalar);
+    eigen_assert(scalar == nullptr);
+    m_impl.evalSubExprsIfNeededAsync(m_buffer, std::move(done));
+  }
+#endif
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalScalar(Index i) const { m_buffer[i] = m_impl.coeff(i); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalPacket(Index i) const {
+    internal::pstoret<CoeffReturnType, PacketReturnType, Aligned>(
+        m_buffer + i, m_impl.template packet < TensorEvaluator<ArgType, Device>::IsAligned ? Aligned : Unaligned > (i));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return m_impl.getResourceRequirements();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalBlock(TensorBlockDesc& desc, TensorBlockScratch& scratch) {
+    // Add `m_buffer` as destination buffer to the block descriptor.
+    desc.template AddDestinationBuffer<Layout>(
+        /*dst_base=*/m_buffer + desc.offset(),
+        /*dst_strides=*/internal::strides<Layout>(m_impl.dimensions()));
+
+    ArgTensorBlock block = m_impl.block(desc, scratch, /*root_of_expr_ast=*/true);
+
+    // If block was evaluated into a destination buffer, there is no need to do
+    // an assignment.
+    if (block.kind() != internal::TensorBlockKind::kMaterializedInOutput) {
+      TensorBlockAssignment::Run(
+          TensorBlockAssignment::target(desc.dimensions(), internal::strides<Layout>(m_impl.dimensions()), m_buffer,
+                                        desc.offset()),
+          block.expr());
+    }
+    block.cleanup();
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_buffer[index]; }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_buffer + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // We assume that evalPacket or evalScalar is called to perform the
+    // assignment and account for the cost of the write here.
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, sizeof(CoeffReturnType), 0, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_buffer; }
+  ArgType expression() const { return m_expression; }
+
+ private:
+  TensorEvaluator<ArgType, Device> m_impl;
+  EvaluatorPointerType m_buffer;
+  const ArgType m_expression;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_EVAL_TO_H
diff --git a/contrib/Eigen/src/Tensor/TensorEvaluator.h b/contrib/Eigen/src/Tensor/TensorEvaluator.h
new file mode 100644
index 0000000..5fd1917
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorEvaluator.h
@@ -0,0 +1,1119 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_EVALUATOR_H
+#define EIGEN_TENSOR_TENSOR_EVALUATOR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// Whether functor_traits declare the functor repeatable: pure calls that may
+// be re-evaluated freely and invoked from concurrent threads. The primary
+// functor_traits template defaults IsRepeatable to false, but specializations
+// for custom functors routinely omit the member, so absence must also map to
+// the conservative default.
+template <typename Functor, typename = void>
+struct tensor_functor_is_repeatable : std::false_type {};
+
+template <typename Functor>
+struct tensor_functor_is_repeatable<Functor, void_t<decltype(functor_traits<Functor>::IsRepeatable)>>
+    : bool_constant<functor_traits<Functor>::IsRepeatable> {};
+
+}  // namespace internal
+
+// Generic evaluator
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief The tensor evaluator class.
+ *
+ * These classes are responsible for the evaluation of the tensor expression.
+ *
+ * TODO: add support for more types of expressions, in particular expressions
+ * leading to lvalues (slicing, reshaping, etc...)
+ */
+template <typename Derived, typename Device>
+struct TensorEvaluator {
+  typedef typename Derived::Index Index;
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename Derived::Dimensions Dimensions;
+  typedef Derived XprType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename internal::traits<Derived>::template MakePointer<Scalar>::Type TensorPointerType;
+  typedef StorageMemory<Scalar, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  // NumDimensions is -1 for variable dim tensors
+  static constexpr int NumCoords =
+      internal::traits<Derived>::NumDimensions > 0 ? internal::traits<Derived>::NumDimensions : 0;
+  static constexpr int Layout = Derived::Layout;
+
+  enum {
+    IsAligned = Derived::IsAligned,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = internal::is_arithmetic<std::remove_const_t<Scalar>>::value,
+    PreferBlockAccess = false,
+    CoordAccess = NumCoords > 0,
+    RawAccess = true
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumCoords, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumCoords, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const Derived& m, const Device& device)
+      : m_data(device.get(const_cast<TensorPointerType>(m.data()))), m_dims(m.dimensions()), m_device(device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dims; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType dest) {
+    EIGEN_IF_CONSTEXPR (!NumTraits<std::remove_const_t<Scalar>>::RequireInitialization) {
+      if (dest) {
+        m_device.memcpy((void*)(m_device.get(dest)), m_device.get(m_data), m_dims.TotalSize() * sizeof(Scalar));
+        return false;
+      }
+    }
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType dest, EvalSubExprsCallback done) {
+    // TODO(ezhulenev): ThreadPoolDevice memcpy is a blocking operation.
+    done(evalSubExprsIfNeeded(dest));
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    eigen_assert(m_data != nullptr);
+    return m_data[index];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    eigen_assert(m_data != nullptr);
+    return m_data[index];
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_data + index);
+  }
+
+  // Return a packet starting at `index` where `umask` specifies which elements
+  // have to be loaded. Type/size of mask depends on PacketReturnType, e.g. for
+  // Packet16f, `umask` is of type uint16_t and if a bit is 1, corresponding
+  // float element will be loaded, otherwise 0 will be loaded.
+  // Function has been templatized to enable Sfinae.
+  template <typename PacketReturnTypeT>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      std::enable_if_t<internal::unpacket_traits<PacketReturnTypeT>::masked_load_available, PacketReturnTypeT>
+      partialPacket(Index index, typename internal::unpacket_traits<PacketReturnTypeT>::mask_t umask) const {
+    return internal::ploadu<PacketReturnTypeT>(m_data + index, umask);
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    return internal::pstoret<Scalar, PacketReturnType, StoreMode>(m_data + index, x);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(const array<DenseIndex, NumCoords>& coords) const {
+    eigen_assert(m_data != nullptr);
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      return m_data[m_dims.IndexOfColMajor(coords)];
+    } else {
+      return m_data[m_dims.IndexOfRowMajor(coords)];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(const array<DenseIndex, NumCoords>& coords) const {
+    eigen_assert(m_data != nullptr);
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      return m_data[m_dims.IndexOfColMajor(coords)];
+    } else {
+      return m_data[m_dims.IndexOfRowMajor(coords)];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketType<CoeffReturnType, Device>::size);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_data != nullptr);
+    return TensorBlock::materialize(m_data, m_dims, desc, scratch);
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(m_data != nullptr);
+
+    typedef typename TensorBlock::XprType TensorBlockExpr;
+    typedef internal::TensorBlockAssignment<Scalar, NumCoords, TensorBlockExpr, Index> TensorBlockAssign;
+
+    TensorBlockAssign::Run(
+        TensorBlockAssign::target(desc.dimensions(), internal::strides<Layout>(m_dims), m_data, desc.offset()),
+        block.expr());
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_data; }
+
+ protected:
+  EvaluatorPointerType m_data;
+  Dimensions m_dims;
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+namespace internal {
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T loadConstant(const T* address) {
+  return *address;
+}
+// Use the texture cache on CUDA devices whenever possible
+#if defined(EIGEN_CUDA_ARCH)
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float loadConstant(const float* address) {
+  return __ldg(address);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double loadConstant(const double* address) {
+  return __ldg(address);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Eigen::half loadConstant(const Eigen::half* address) {
+  return Eigen::half(half_impl::raw_uint16_to_half(__ldg(&address->x)));
+}
+#endif
+
+}  // namespace internal
+
+// Default evaluator for rvalues
+template <typename Derived, typename Device>
+struct TensorEvaluator<const Derived, Device> {
+  typedef typename Derived::Index Index;
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename Derived::Dimensions Dimensions;
+  typedef const Derived XprType;
+  typedef typename internal::traits<Derived>::template MakePointer<const Scalar>::Type TensorPointerType;
+  typedef StorageMemory<const Scalar, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  // NumDimensions is -1 for variable dim tensors
+  static constexpr int NumCoords =
+      internal::traits<Derived>::NumDimensions > 0 ? internal::traits<Derived>::NumDimensions : 0;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  static constexpr int Layout = Derived::Layout;
+
+  enum {
+    IsAligned = Derived::IsAligned,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = internal::is_arithmetic<ScalarNoConst>::value,
+    PreferBlockAccess = false,
+    CoordAccess = NumCoords > 0,
+    RawAccess = true
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumCoords, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumCoords, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC TensorEvaluator(const Derived& m, const Device& device)
+      : m_data(device.get(m.data())), m_dims(m.dimensions()), m_device(device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dims; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    EIGEN_IF_CONSTEXPR (!NumTraits<std::remove_const_t<Scalar>>::RequireInitialization) {
+      if (data) {
+        m_device.memcpy((void*)(m_device.get(data)), m_device.get(m_data), m_dims.TotalSize() * sizeof(Scalar));
+        return false;
+      }
+    }
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType dest, EvalSubExprsCallback done) {
+    // TODO(ezhulenev): ThreadPoolDevice memcpy is a blocking operation.
+    done(evalSubExprsIfNeeded(dest));
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    eigen_assert(m_data != nullptr);
+    return internal::loadConstant(m_data + index);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return internal::ploadt_ro<PacketReturnType, LoadMode>(m_data + index);
+  }
+
+  // Return a packet starting at `index` where `umask` specifies which elements
+  // have to be loaded. Type/size of mask depends on PacketReturnType, e.g. for
+  // Packet16f, `umask` is of type uint16_t and if a bit is 1, corresponding
+  // float element will be loaded, otherwise 0 will be loaded.
+  // Function has been templatized to enable Sfinae.
+  template <typename PacketReturnTypeT>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+      std::enable_if_t<internal::unpacket_traits<PacketReturnTypeT>::masked_load_available, PacketReturnTypeT>
+      partialPacket(Index index, typename internal::unpacket_traits<PacketReturnTypeT>::mask_t umask) const {
+    return internal::ploadu<PacketReturnTypeT>(m_data + index, umask);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(const array<DenseIndex, NumCoords>& coords) const {
+    eigen_assert(m_data != nullptr);
+    const Index index = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? m_dims.IndexOfColMajor(coords)
+                                                                                 : m_dims.IndexOfRowMajor(coords);
+    return internal::loadConstant(m_data + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketType<CoeffReturnType, Device>::size);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_data != nullptr);
+    return TensorBlock::materialize(m_data, m_dims, desc, scratch);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_data; }
+
+ protected:
+  EvaluatorPointerType m_data;
+  Dimensions m_dims;
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+// -------------------- CwiseNullaryOp --------------------
+
+template <typename NullaryOp, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorCwiseNullaryOp<NullaryOp, ArgType>, Device> {
+  typedef TensorCwiseNullaryOp<NullaryOp, ArgType> XprType;
+
+  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
+      : m_functor(op.functor()), m_argImpl(op.nestedExpression(), device), m_wrapper() {}
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+  typedef std::remove_const_t<CoeffReturnType> ScalarNoConst;
+
+  // Only functors whose functor_traits declare IsRepeatable (e.g. the
+  // scalar_constant_op behind constant(), cwiseMax(Scalar) and clip(), and the
+  // index-seeded random generators) are known to be pure; unannotated custom
+  // functors conservatively default to non-repeatable, since a functor that
+  // carries state between calls cannot be re-evaluated or visited out of order.
+  static constexpr bool RepeatableFunctor = internal::tensor_functor_is_repeatable<NullaryOp>::value;
+
+  // nullary_wrapper dispatches to an indexed operator() whenever one exists,
+  // even if a zero-argument overload is also present.
+  static constexpr bool IndexDependentFunctor =
+      internal::has_unary_operator<NullaryOp, Index>::value || internal::has_binary_operator<NullaryOp, Index>::value;
+
+  // A lazy block rebuilds the nullary expression over the block's local
+  // extent with a copy of the functor, so it is only correct for repeatable
+  // functors evaluated through the zero-argument overload: an index-dependent
+  // functor would see indices restart at the block origin, and a
+  // non-repeatable one would restart its state per block. Repeatable indexed
+  // functors are instead materialized with their true tensor-linear indices.
+  static constexpr bool IndexIndependentFunctor =
+      RepeatableFunctor && !IndexDependentFunctor && internal::has_nullary_operator<NullaryOp, Index>::value;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = true,
+    PacketAccess = internal::functor_traits<NullaryOp>::PacketAccess
+#ifdef EIGEN_USE_SYCL
+                   && (PacketType<CoeffReturnType, Device>::size > 1)
+#endif
+        ,
+    // A nullary leaf can serve any block; without this, a single constant()
+    // in an expression disables tiled evaluation for the whole tree. Never
+    // *prefer* block access on its own account, though. Blocks are declined
+    // when they could change behavior relative to coefficient evaluation. In
+    // particular, non-repeatable functors never serve blocks: even on a
+    // single-threaded device, block traversal permutes their call sequence
+    // relative to linear coefficient order.
+    BlockAccess = NumDims > 0 && internal::is_arithmetic<ScalarNoConst>::value &&
+                  (IndexIndependentFunctor || (IndexDependentFunctor && RepeatableFunctor)),
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  // Lazy block for index-independent functors: rebuilds the nullary
+  // expression over the block extent. The nested map exists only to give the
+  // expression its dimensions; the nullary evaluator never touches its
+  // argument's data.
+  class TensorNullaryBlock {
+   public:
+    typedef TensorMap<const Tensor<ScalarNoConst, NumDims, Layout, Index>> ArgXprType;
+    typedef TensorCwiseNullaryOp<NullaryOp, const ArgXprType> XprType;
+    typedef typename internal::XprScalar<XprType>::type Scalar;
+
+    TensorNullaryBlock(const NullaryOp& functor, const DSizes<Index, NumDims>& dimensions)
+        : m_functor(functor), m_dimensions(dimensions) {}
+
+    constexpr internal::TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
+    XprType expr() const {
+      return XprType(ArgXprType(static_cast<const ScalarNoConst*>(nullptr), m_dimensions), m_functor);
+    }
+    const Scalar* data() const { return nullptr; }
+    void cleanup() {}
+
+   private:
+    NullaryOp m_functor;
+    DSizes<Index, NumDims> m_dimensions;
+  };
+
+  typedef internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> MaterializedTensorBlock;
+  typedef std::conditional_t<IndexIndependentFunctor, TensorNullaryBlock, MaterializedTensorBlock> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_argImpl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) { return true; }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    done(true);
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() {}
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const { return m_wrapper(m_functor, index); }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return m_wrapper.template packetOp<PacketReturnType, Index>(m_functor, index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // NullaryOps (constants, zero, identity, random) generate values from
+    // registers or minimal state — they do not load from memory.  Report
+    // zero bytes_loaded so the cost model correctly classifies expressions
+    // containing many constants (e.g. Horner polynomials) as compute-bound
+    // rather than memory-bound.
+    return TensorOpCost(0, 0, 0, vectorized, PacketType<CoeffReturnType, Device>::size);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  // Fills `count` elements of an inner run, whose tensor-linear indices are
+  // tensor_index .. tensor_index + count - 1. Specialized on the functor's
+  // packet support so that packetOp is only instantiated when it exists.
+  template <typename Self, bool Vectorizable>
+  struct NullaryBlockFill {
+    static EIGEN_STRONG_INLINE void Run(const Self& self, ScalarNoConst* buffer, Index tensor_index, Index count) {
+      for (Index i = 0; i < count; ++i) {
+        buffer[i] = self.m_wrapper(self.m_functor, tensor_index + i);
+      }
+    }
+  };
+
+  template <typename Self>
+  struct NullaryBlockFill<Self, true> {
+    static EIGEN_STRONG_INLINE void Run(const Self& self, ScalarNoConst* buffer, Index tensor_index, Index count) {
+      Index i = 0;
+      for (; i + PacketSize <= count; i += PacketSize) {
+        internal::pstoreu(buffer + i,
+                          self.m_wrapper.template packetOp<PacketReturnType, Index>(self.m_functor, tensor_index + i));
+      }
+      for (; i < count; ++i) {
+        buffer[i] = self.m_wrapper(self.m_functor, tensor_index + i);
+      }
+    }
+  };
+
+  template <typename Self, bool IndexIndependent>
+  struct NullaryBlockImpl {
+    // Index-independent functors: return a lazy block; the consumer folds the
+    // functor into its own (vectorized) evaluation loop.
+    static EIGEN_STRONG_INLINE TensorBlock Run(const Self& self, TensorBlockDesc& desc, TensorBlockScratch&) {
+      return TensorBlock(self.m_functor, desc.dimensions());
+    }
+  };
+
+  template <typename Self>
+  struct NullaryBlockImpl<Self, false> {
+    // Index-dependent functors: materialize the block by calling the functor
+    // with the block elements' true tensor-linear indices, so the values
+    // match linear evaluation semantics. Along the inner dimension a block
+    // row is contiguous in linear-index space, so each run is one
+    // packet-sized sweep.
+    static TensorBlock Run(const Self& self, TensorBlockDesc& desc, TensorBlockScratch& scratch) {
+      constexpr bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+      typedef NullaryBlockFill<Self, bool(PacketAccess)> Fill;
+
+      if (desc.size() == 0) {
+        return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+      }
+
+      // Strides of the full tensor in linear-index space.
+      const Dimensions& dims = self.m_argImpl.dimensions();
+      array<Index, NumDims> tensor_strides;
+      EIGEN_IF_CONSTEXPR (is_col_major) {
+        tensor_strides[0] = 1;
+        for (int i = 1; i < NumDims; ++i) tensor_strides[i] = tensor_strides[i - 1] * dims[i - 1];
+      } else {
+        tensor_strides[NumDims - 1] = 1;
+        for (int i = NumDims - 2; i >= 0; --i) tensor_strides[i] = tensor_strides[i + 1] * dims[i + 1];
+      }
+
+      // Block iteration state, inner-most dimension first.
+      struct BlockIteratorState {
+        Index size;
+        Index count;
+        Index tensor_stride;
+        Index tensor_span;
+      };
+      array<BlockIteratorState, NumDims> it;
+      for (int i = 0; i < NumDims; ++i) {
+        const int dim = is_col_major ? i : NumDims - 1 - i;
+        const Index size = desc.dimension(dim);
+        const Index stride = tensor_strides[dim];
+        it[i] = {/*size=*/size, /*count=*/0, /*tensor_stride=*/stride, /*tensor_span=*/stride * (size - 1)};
+      }
+      eigen_assert(it[0].tensor_stride == 1);
+
+      const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+      ScalarNoConst* block_buffer = block_storage.data();
+
+      const Index inner_size = it[0].size;
+      Index tensor_index = desc.offset();
+      Index offset = 0;
+      for (;;) {
+        Fill::Run(self, block_buffer + offset, tensor_index, inner_size);
+        offset += inner_size;
+
+        // Advance the odometer over the outer dimensions.
+        int i = 1;
+        for (; i < NumDims; ++i) {
+          if (++it[i].count < it[i].size) {
+            tensor_index += it[i].tensor_stride;
+            break;
+          }
+          it[i].count = 0;
+          tensor_index -= it[i].tensor_span;
+        }
+        if (i == NumDims) break;
+      }
+
+      return block_storage.AsTensorMaterializedBlock();
+    }
+  };
+
+  EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                        bool /*root_of_expr_ast*/ = false) const {
+    typedef TensorEvaluator<const TensorCwiseNullaryOp<NullaryOp, ArgType>, Device> Self;
+    return NullaryBlockImpl<Self, IndexIndependentFunctor>::Run(*this, desc, scratch);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ private:
+  const NullaryOp m_functor;
+  TensorEvaluator<ArgType, Device> m_argImpl;
+  const internal::nullary_wrapper<CoeffReturnType, NullaryOp> m_wrapper;
+};
+
+// -------------------- CwiseUnaryOp --------------------
+
+template <typename UnaryOp, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorCwiseUnaryOp<UnaryOp, ArgType>, Device> {
+  typedef TensorCwiseUnaryOp<UnaryOp, ArgType> XprType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess =
+        int(TensorEvaluator<ArgType, Device>::PacketAccess) & int(internal::functor_traits<UnaryOp>::PacketAccess),
+    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
+      : m_device(device), m_functor(op.functor()), m_argImpl(op.nestedExpression(), device) {}
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
+
+  typedef internal::TensorCwiseUnaryBlock<UnaryOp, ArgTensorBlock> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_argImpl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_argImpl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_argImpl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_argImpl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const { return m_functor(m_argImpl.coeff(index)); }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return m_functor.packetOp(m_argImpl.template packet<LoadMode>(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double functor_cost = internal::functor_traits<UnaryOp>::Cost;
+    return m_argImpl.costPerCoeff(vectorized) + TensorOpCost(0, 0, functor_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    static constexpr double functor_cost = internal::functor_traits<UnaryOp>::Cost;
+    return m_argImpl.getResourceRequirements().addCostPerCoeff({0, 0, functor_cost / PacketSize});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    // The forwarded destination buffer is sized for *our* output Scalar (the
+    // assign LHS), but the child block evaluator below us writes ArgScalar.
+    // For functors that change the scalar type (abs(complex)->real,
+    // isnan/isfinite->bool, ...) the buffer would be misinterpreted by any
+    // block-materializing child's prepareStorage (assert in debug, corruption
+    // in release). Drop the buffer in that case; the child falls back to
+    // scratch and writeBlock still lands the converted values in the LHS.
+    constexpr bool ScalarTypesMatch =
+        std::is_same<std::remove_const_t<Scalar>,
+                     std::remove_const_t<typename TensorEvaluator<ArgType, Device>::Scalar>>::value;
+    EIGEN_IF_CONSTEXPR (!ScalarTypesMatch) {
+      desc.DropDestinationBuffer();
+    }
+    return TensorBlock(m_argImpl.block(desc, scratch), m_functor);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ private:
+  const Device EIGEN_DEVICE_REF m_device;
+  const UnaryOp m_functor;
+  TensorEvaluator<ArgType, Device> m_argImpl;
+};
+
+// -------------------- CwiseBinaryOp --------------------
+
+template <typename BinaryOp, typename LeftArgType, typename RightArgType, typename Device>
+struct TensorEvaluator<const TensorCwiseBinaryOp<BinaryOp, LeftArgType, RightArgType>, Device> {
+  typedef TensorCwiseBinaryOp<BinaryOp, LeftArgType, RightArgType> XprType;
+
+  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
+  enum {
+    IsAligned =
+        int(TensorEvaluator<LeftArgType, Device>::IsAligned) & int(TensorEvaluator<RightArgType, Device>::IsAligned),
+    PacketAccess = int(TensorEvaluator<LeftArgType, Device>::PacketAccess) &
+                   int(TensorEvaluator<RightArgType, Device>::PacketAccess) &
+                   int(internal::functor_traits<BinaryOp>::PacketAccess),
+    BlockAccess = int(TensorEvaluator<LeftArgType, Device>::BlockAccess) &
+                  int(TensorEvaluator<RightArgType, Device>::BlockAccess),
+    PreferBlockAccess = int(TensorEvaluator<LeftArgType, Device>::PreferBlockAccess) |
+                        int(TensorEvaluator<RightArgType, Device>::PreferBlockAccess),
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
+      : m_device(device),
+        m_functor(op.functor()),
+        m_leftImpl(op.lhsExpression(), device),
+        m_rightImpl(op.rhsExpression(), device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
+                             static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) ||
+                         internal::traits<XprType>::NumDimensions <= 1),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+    eigen_assert(dimensions_match(m_leftImpl.dimensions(), m_rightImpl.dimensions()));
+  }
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename TensorEvaluator<LeftArgType, Device>::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const LeftArgType, Device>::TensorBlock LeftTensorBlock;
+  typedef typename TensorEvaluator<const RightArgType, Device>::TensorBlock RightTensorBlock;
+
+  typedef internal::TensorCwiseBinaryBlock<BinaryOp, LeftTensorBlock, RightTensorBlock> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
+    // TODO: use right impl instead if right impl dimensions are known at compile time.
+    return m_leftImpl.dimensions();
+  }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_leftImpl.evalSubExprsIfNeeded(nullptr);
+    m_rightImpl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    // TODO(ezhulenev): Evaluate two expression in parallel?
+    m_leftImpl.evalSubExprsIfNeededAsync(
+        nullptr, [this, done](bool) { m_rightImpl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); }); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_leftImpl.cleanup();
+    m_rightImpl.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
+    return m_functor(m_leftImpl.coeff(index), m_rightImpl.coeff(index));
+  }
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return m_functor.packetOp(m_leftImpl.template packet<LoadMode>(index),
+                              m_rightImpl.template packet<LoadMode>(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double functor_cost = internal::functor_traits<BinaryOp>::Cost;
+    return m_leftImpl.costPerCoeff(vectorized) + m_rightImpl.costPerCoeff(vectorized) +
+           TensorOpCost(0, 0, functor_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    static constexpr double functor_cost = internal::functor_traits<BinaryOp>::Cost;
+    return internal::TensorBlockResourceRequirements::merge(m_leftImpl.getResourceRequirements(),
+                                                            m_rightImpl.getResourceRequirements())
+        .addCostPerCoeff({0, 0, functor_cost / PacketSize});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    desc.DropDestinationBuffer();
+    return TensorBlock(m_leftImpl.block(desc, scratch), m_rightImpl.block(desc, scratch), m_functor);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ private:
+  const Device EIGEN_DEVICE_REF m_device;
+  const BinaryOp m_functor;
+  TensorEvaluator<LeftArgType, Device> m_leftImpl;
+  TensorEvaluator<RightArgType, Device> m_rightImpl;
+};
+
+// -------------------- CwiseTernaryOp --------------------
+
+template <typename TernaryOp, typename Arg1Type, typename Arg2Type, typename Arg3Type, typename Device>
+struct TensorEvaluator<const TensorCwiseTernaryOp<TernaryOp, Arg1Type, Arg2Type, Arg3Type>, Device> {
+  typedef TensorCwiseTernaryOp<TernaryOp, Arg1Type, Arg2Type, Arg3Type> XprType;
+
+  static constexpr int Layout = TensorEvaluator<Arg1Type, Device>::Layout;
+  enum {
+    IsAligned = TensorEvaluator<Arg1Type, Device>::IsAligned && TensorEvaluator<Arg2Type, Device>::IsAligned &&
+                TensorEvaluator<Arg3Type, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<Arg1Type, Device>::PacketAccess && TensorEvaluator<Arg2Type, Device>::PacketAccess &&
+                   TensorEvaluator<Arg3Type, Device>::PacketAccess && internal::functor_traits<TernaryOp>::PacketAccess,
+    BlockAccess = TensorEvaluator<Arg1Type, Device>::BlockAccess && TensorEvaluator<Arg2Type, Device>::BlockAccess &&
+                  TensorEvaluator<Arg3Type, Device>::BlockAccess,
+    PreferBlockAccess = TensorEvaluator<Arg1Type, Device>::PreferBlockAccess ||
+                        TensorEvaluator<Arg2Type, Device>::PreferBlockAccess ||
+                        TensorEvaluator<Arg3Type, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
+      : m_functor(op.functor()),
+        m_arg1Impl(op.arg1Expression(), device),
+        m_arg2Impl(op.arg2Expression(), device),
+        m_arg3Impl(op.arg3Expression(), device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<Arg1Type, Device>::Layout) ==
+                             static_cast<int>(TensorEvaluator<Arg3Type, Device>::Layout) ||
+                         internal::traits<XprType>::NumDimensions <= 1),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    EIGEN_STATIC_ASSERT((std::is_same<typename internal::traits<Arg1Type>::StorageKind,
+                                      typename internal::traits<Arg2Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+    EIGEN_STATIC_ASSERT((std::is_same<typename internal::traits<Arg1Type>::StorageKind,
+                                      typename internal::traits<Arg3Type>::StorageKind>::value),
+                        STORAGE_KIND_MUST_MATCH)
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<typename internal::traits<Arg1Type>::Index, typename internal::traits<Arg2Type>::Index>::value),
+        STORAGE_INDEX_MUST_MATCH)
+    EIGEN_STATIC_ASSERT(
+        (std::is_same<typename internal::traits<Arg1Type>::Index, typename internal::traits<Arg3Type>::Index>::value),
+        STORAGE_INDEX_MUST_MATCH)
+
+    eigen_assert(dimensions_match(m_arg1Impl.dimensions(), m_arg2Impl.dimensions()) &&
+                 dimensions_match(m_arg1Impl.dimensions(), m_arg3Impl.dimensions()));
+  }
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename TensorEvaluator<Arg1Type, Device>::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const Arg1Type, Device>::TensorBlock Arg1TensorBlock;
+  typedef typename TensorEvaluator<const Arg2Type, Device>::TensorBlock Arg2TensorBlock;
+  typedef typename TensorEvaluator<const Arg3Type, Device>::TensorBlock Arg3TensorBlock;
+
+  // Rebuilds the ternary expression over the arguments' block expressions,
+  // carrying the functor; mirrors TensorSelectOpBlockFactory.
+  struct TensorCwiseTernaryOpBlockFactory {
+    TernaryOp func;
+
+    template <typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
+    struct XprType {
+      typedef TensorCwiseTernaryOp<TernaryOp, const Arg1XprType, const Arg2XprType, const Arg3XprType> type;
+    };
+
+    template <typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
+    typename XprType<Arg1XprType, Arg2XprType, Arg3XprType>::type expr(const Arg1XprType& arg1, const Arg2XprType& arg2,
+                                                                       const Arg3XprType& arg3) const {
+      return typename XprType<Arg1XprType, Arg2XprType, Arg3XprType>::type(arg1, arg2, arg3, func);
+    }
+  };
+
+  typedef internal::TensorTernaryExprBlock<TensorCwiseTernaryOpBlockFactory, Arg1TensorBlock, Arg2TensorBlock,
+                                           Arg3TensorBlock>
+      TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
+    // TODO: use arg2 or arg3 dimensions if they are known at compile time.
+    return m_arg1Impl.dimensions();
+  }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_arg1Impl.evalSubExprsIfNeeded(nullptr);
+    m_arg2Impl.evalSubExprsIfNeeded(nullptr);
+    m_arg3Impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_arg1Impl.cleanup();
+    m_arg2Impl.cleanup();
+    m_arg3Impl.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
+    return m_functor(m_arg1Impl.coeff(index), m_arg2Impl.coeff(index), m_arg3Impl.coeff(index));
+  }
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return m_functor.packetOp(m_arg1Impl.template packet<LoadMode>(index), m_arg2Impl.template packet<LoadMode>(index),
+                              m_arg3Impl.template packet<LoadMode>(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double functor_cost = internal::functor_traits<TernaryOp>::Cost;
+    return m_arg1Impl.costPerCoeff(vectorized) + m_arg2Impl.costPerCoeff(vectorized) +
+           m_arg3Impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, functor_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    static constexpr double functor_cost = internal::functor_traits<TernaryOp>::Cost;
+    return internal::TensorBlockResourceRequirements::merge(
+               m_arg1Impl.getResourceRequirements(),
+               internal::TensorBlockResourceRequirements::merge(m_arg2Impl.getResourceRequirements(),
+                                                                m_arg3Impl.getResourceRequirements()))
+        .addCostPerCoeff({0, 0, functor_cost / PacketSize});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    // The forwarded destination buffer might alias one of the inputs; drop it
+    // like the binary evaluator does.
+    desc.DropDestinationBuffer();
+    return TensorBlock(m_arg1Impl.block(desc, scratch), m_arg2Impl.block(desc, scratch),
+                       m_arg3Impl.block(desc, scratch), TensorCwiseTernaryOpBlockFactory{m_functor});
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ private:
+  const TernaryOp m_functor;
+  TensorEvaluator<Arg1Type, Device> m_arg1Impl;
+  TensorEvaluator<Arg2Type, Device> m_arg2Impl;
+  TensorEvaluator<Arg3Type, Device> m_arg3Impl;
+};
+
+// -------------------- SelectOp --------------------
+
+template <typename IfArgType, typename ThenArgType, typename ElseArgType, typename Device>
+struct TensorEvaluator<const TensorSelectOp<IfArgType, ThenArgType, ElseArgType>, Device> {
+  typedef TensorSelectOp<IfArgType, ThenArgType, ElseArgType> XprType;
+  typedef typename XprType::Scalar Scalar;
+
+  using TernarySelectOp = internal::scalar_boolean_select_op<typename internal::traits<ThenArgType>::Scalar,
+                                                             typename internal::traits<ElseArgType>::Scalar,
+                                                             typename internal::traits<IfArgType>::Scalar>;
+  static constexpr bool TernaryPacketAccess =
+      TensorEvaluator<ThenArgType, Device>::PacketAccess && TensorEvaluator<ElseArgType, Device>::PacketAccess &&
+      TensorEvaluator<IfArgType, Device>::PacketAccess && internal::functor_traits<TernarySelectOp>::PacketAccess;
+
+  static constexpr int Layout = TensorEvaluator<IfArgType, Device>::Layout;
+  enum {
+    IsAligned = TensorEvaluator<ThenArgType, Device>::IsAligned && TensorEvaluator<ElseArgType, Device>::IsAligned,
+    PacketAccess =
+        (TensorEvaluator<ThenArgType, Device>::PacketAccess && TensorEvaluator<ElseArgType, Device>::PacketAccess) ||
+        TernaryPacketAccess,
+    BlockAccess = TensorEvaluator<IfArgType, Device>::BlockAccess &&
+                  TensorEvaluator<ThenArgType, Device>::BlockAccess &&
+                  TensorEvaluator<ElseArgType, Device>::BlockAccess,
+    PreferBlockAccess = TensorEvaluator<IfArgType, Device>::PreferBlockAccess ||
+                        TensorEvaluator<ThenArgType, Device>::PreferBlockAccess ||
+                        TensorEvaluator<ElseArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
+      : m_condImpl(op.ifExpression(), device),
+        m_thenImpl(op.thenExpression(), device),
+        m_elseImpl(op.elseExpression(), device) {
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<IfArgType, Device>::Layout) ==
+                         static_cast<int>(TensorEvaluator<ThenArgType, Device>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<IfArgType, Device>::Layout) ==
+                         static_cast<int>(TensorEvaluator<ElseArgType, Device>::Layout)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+    eigen_assert(dimensions_match(m_condImpl.dimensions(), m_thenImpl.dimensions()));
+    eigen_assert(dimensions_match(m_thenImpl.dimensions(), m_elseImpl.dimensions()));
+  }
+
+  typedef typename XprType::Index Index;
+  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename TensorEvaluator<IfArgType, Device>::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const IfArgType, Device>::TensorBlock IfArgTensorBlock;
+  typedef typename TensorEvaluator<const ThenArgType, Device>::TensorBlock ThenArgTensorBlock;
+  typedef typename TensorEvaluator<const ElseArgType, Device>::TensorBlock ElseArgTensorBlock;
+
+  struct TensorSelectOpBlockFactory {
+    template <typename IfArgXprType, typename ThenArgXprType, typename ElseArgXprType>
+    struct XprType {
+      typedef TensorSelectOp<const IfArgXprType, const ThenArgXprType, const ElseArgXprType> type;
+    };
+
+    template <typename IfArgXprType, typename ThenArgXprType, typename ElseArgXprType>
+    typename XprType<IfArgXprType, ThenArgXprType, ElseArgXprType>::type expr(const IfArgXprType& if_expr,
+                                                                              const ThenArgXprType& then_expr,
+                                                                              const ElseArgXprType& else_expr) const {
+      return typename XprType<IfArgXprType, ThenArgXprType, ElseArgXprType>::type(if_expr, then_expr, else_expr);
+    }
+  };
+
+  typedef internal::TensorTernaryExprBlock<TensorSelectOpBlockFactory, IfArgTensorBlock, ThenArgTensorBlock,
+                                           ElseArgTensorBlock>
+      TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
+    // TODO: use then or else impl instead if they happen to be known at compile time.
+    return m_condImpl.dimensions();
+  }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_condImpl.evalSubExprsIfNeeded(nullptr);
+    m_thenImpl.evalSubExprsIfNeeded(nullptr);
+    m_elseImpl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_condImpl.evalSubExprsIfNeeded(nullptr, [this, done](bool) {
+      m_thenImpl.evalSubExprsIfNeeded(
+          nullptr, [this, done](bool) { m_elseImpl.evalSubExprsIfNeeded(nullptr, [done](bool) { done(true); }); });
+    });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_condImpl.cleanup();
+    m_thenImpl.cleanup();
+    m_elseImpl.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
+    return m_condImpl.coeff(index) ? m_thenImpl.coeff(index) : m_elseImpl.coeff(index);
+  }
+
+  template <int LoadMode, bool UseTernary = TernaryPacketAccess, std::enable_if_t<!UseTernary, bool> = true>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<Scalar> arr[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (Index i = 0; i < PacketSize; ++i) {
+      arr[i] = m_condImpl.coeff(index + i) ? Scalar(-1) : Scalar(0);
+    }
+    return TernarySelectOp().template packetOp<PacketReturnType>(m_thenImpl.template packet<LoadMode>(index),
+                                                                 m_elseImpl.template packet<LoadMode>(index),
+                                                                 internal::pload<PacketReturnType>(arr));
+  }
+
+  template <int LoadMode, bool UseTernary = TernaryPacketAccess, std::enable_if_t<UseTernary, bool> = true>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
+    return TernarySelectOp().template packetOp<PacketReturnType>(m_thenImpl.template packet<LoadMode>(index),
+                                                                 m_elseImpl.template packet<LoadMode>(index),
+                                                                 m_condImpl.template packet<LoadMode>(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return m_condImpl.costPerCoeff(vectorized) +
+           m_thenImpl.costPerCoeff(vectorized).cwiseMax(m_elseImpl.costPerCoeff(vectorized));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    auto then_req = m_thenImpl.getResourceRequirements();
+    auto else_req = m_elseImpl.getResourceRequirements();
+
+    auto merged_req = internal::TensorBlockResourceRequirements::merge(then_req, else_req);
+    merged_req.cost_per_coeff = then_req.cost_per_coeff.cwiseMax(else_req.cost_per_coeff);
+
+    return internal::TensorBlockResourceRequirements::merge(m_condImpl.getResourceRequirements(), merged_req);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    // It's unsafe to pass destination buffer to underlying expressions, because
+    // output might be aliased with one of the inputs.
+    desc.DropDestinationBuffer();
+
+    return TensorBlock(m_condImpl.block(desc, scratch), m_thenImpl.block(desc, scratch),
+                       m_elseImpl.block(desc, scratch), TensorSelectOpBlockFactory());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return nullptr; }
+
+#ifdef EIGEN_USE_SYCL
+  // binding placeholder accessors to a command group handler for SYCL
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(cl::sycl::handler& cgh) const {
+    m_condImpl.bind(cgh);
+    m_thenImpl.bind(cgh);
+    m_elseImpl.bind(cgh);
+  }
+#endif
+ private:
+  TensorEvaluator<IfArgType, Device> m_condImpl;
+  TensorEvaluator<ThenArgType, Device> m_thenImpl;
+  TensorEvaluator<ElseArgType, Device> m_elseImpl;
+};
+
+}  // end namespace Eigen
+
+#if defined(EIGEN_USE_SYCL) && defined(SYCL_COMPILER_IS_DPCPP)
+template <typename Derived, typename Device>
+struct cl::sycl::is_device_copyable<
+    Eigen::TensorEvaluator<Derived, Device>,
+    std::enable_if_t<!std::is_trivially_copyable<Eigen::TensorEvaluator<Derived, Device>>::value>> : std::true_type {};
+#endif
+
+#endif  // EIGEN_TENSOR_TENSOR_EVALUATOR_H
diff --git a/contrib/Eigen/src/Tensor/TensorExecutor.h b/contrib/Eigen/src/Tensor/TensorExecutor.h
new file mode 100644
index 0000000..6aec270
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorExecutor.h
@@ -0,0 +1,643 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_EXECUTOR_H
+#define EIGEN_TENSOR_TENSOR_EXECUTOR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief The tensor executor class.
+ *
+ * This class is responsible for launching the evaluation of the expression on
+ * the specified computing device.
+ *
+ * Default strategy: the expression is evaluated sequentially with a single cpu
+ * thread, without vectorization and block evaluation.
+ *
+ * @tparam Vectorizable can use packet math (SSE/AVX/etc... registers and
+ *                      instructions)
+ * @tparam Tiling       can use block based tensor evaluation
+ *                      (see TensorBlock.h)
+ */
+template <typename Expression, typename Device, bool Vectorizable, TiledEvaluation Tiling>
+class TensorExecutor {
+ public:
+  typedef typename Expression::Index StorageIndex;
+
+  // Including `contrib/Eigen/Tensor` in different translation units
+  // with/without `EIGEN_USE_THREADS` or `EIGEN_USE_GPU` is a potential ODR
+  // violation. If this template is instantiated with a non-default device, it
+  // means that this header file was included without defining
+  // `EIGEN_USE_THREADS`, `EIGEN_USE_GPU` or `EIGEN_USE_SYCL`.
+  static_assert(std::is_same<Device, DefaultDevice>::value,
+                "Default executor instantiated with non-default device. "
+                "You must #define EIGEN_USE_THREADS, EIGEN_USE_GPU or "
+                "EIGEN_USE_SYCL before including Eigen headers.");
+
+  static EIGEN_STRONG_INLINE void run(const Expression& expr, const Device& device = DefaultDevice()) {
+    TensorEvaluator<Expression, Device> evaluator(expr, device);
+    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+    if (needs_assign) {
+      const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
+      for (StorageIndex i = 0; i < size; ++i) {
+        evaluator.evalScalar(i);
+      }
+    }
+    evaluator.cleanup();
+  }
+};
+
+/**
+ * Default async execution strategy is not implemented. Currently it's only
+ * available for ThreadPoolDevice (see definition below).
+ */
+template <typename Expression, typename Device, typename DoneCallback, bool Vectorizable, TiledEvaluation Tiling>
+class TensorAsyncExecutor {};
+
+/**
+ * Process all the data with a single cpu thread, using vectorized instructions.
+ */
+template <typename Expression>
+class TensorExecutor<Expression, DefaultDevice, /*Vectorizable=*/true,
+                     /*Tiling=*/TiledEvaluation::Off> {
+ public:
+  typedef typename Expression::Index StorageIndex;
+
+  static EIGEN_STRONG_INLINE void run(const Expression& expr, const DefaultDevice& device = DefaultDevice()) {
+    TensorEvaluator<Expression, DefaultDevice> evaluator(expr, device);
+    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+    if (needs_assign) {
+      const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
+      const int PacketSize =
+          unpacket_traits<typename TensorEvaluator<Expression, DefaultDevice>::PacketReturnType>::size;
+
+      // Give compiler a strong possibility to unroll the loop. But don't insist
+      // on unrolling, because if the function is expensive compiler should not
+      // unroll the loop at the expense of inlining.
+      const StorageIndex UnrolledSize = (size / (4 * PacketSize)) * 4 * PacketSize;
+      for (StorageIndex i = 0; i < UnrolledSize; i += 4 * PacketSize) {
+        for (StorageIndex j = 0; j < 4; j++) {
+          evaluator.evalPacket(i + j * PacketSize);
+        }
+      }
+      const StorageIndex VectorizedSize = (size / PacketSize) * PacketSize;
+      for (StorageIndex i = UnrolledSize; i < VectorizedSize; i += PacketSize) {
+        evaluator.evalPacket(i);
+      }
+      for (StorageIndex i = VectorizedSize; i < size; ++i) {
+        evaluator.evalScalar(i);
+      }
+    }
+    evaluator.cleanup();
+  }
+};
+
+/**
+ * Process all the data with a single cpu thread, using blocks of data. By
+ * sizing a block to fit L1 cache we get better cache performance.
+ */
+template <typename Expression, bool Vectorizable>
+class TensorExecutor<Expression, DefaultDevice, Vectorizable,
+                     /*Tiling=*/TiledEvaluation::On> {
+ public:
+  typedef typename traits<Expression>::Scalar Scalar;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  typedef TensorEvaluator<Expression, DefaultDevice> Evaluator;
+  typedef typename traits<Expression>::Index StorageIndex;
+
+  static constexpr int NumDims = traits<Expression>::NumDimensions;
+
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(const Expression& expr,
+                                                        const DefaultDevice& device = DefaultDevice()) {
+    typedef TensorBlockMapper<NumDims, Evaluator::Layout, StorageIndex> TensorBlockMapper;
+
+    typedef internal::TensorBlockDescriptor<NumDims, StorageIndex> TensorBlockDesc;
+    typedef internal::TensorBlockScratchAllocator<DefaultDevice> TensorBlockScratch;
+
+    Evaluator evaluator(expr, device);
+
+    // TODO(ezhulenev): Do not use tiling for small tensors?
+    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+
+    if (needs_assign) {
+      // Query expression tree for desired block size/shape.
+      const TensorBlockResourceRequirements requirements = evaluator.getResourceRequirements();
+
+      const TensorBlockMapper block_mapper(typename TensorBlockDesc::Dimensions(evaluator.dimensions()), requirements);
+
+      // Share scratch memory allocator between all blocks.
+      TensorBlockScratch scratch(device);
+
+      const StorageIndex total_block_count = block_mapper.blockCount();
+      for (StorageIndex i = 0; i < total_block_count; ++i) {
+        TensorBlockDesc desc = block_mapper.blockDescriptor(i);
+        evaluator.evalBlock(desc, scratch);
+        scratch.reset();
+      }
+    }
+    evaluator.cleanup();
+  }
+};
+
+/**
+ * Multicore strategy: the index space is partitioned and each partition is
+ * executed on a single core.
+ *
+ * (1) TensorExecutor will submit work to the ThreadPoolDevice managed thread
+ *     pool, and will block the caller thread until all tasks are finished.
+ *
+ * (2) TensorAsyncExecutor is a non-blocking version, that will submit work to
+ *     the ThreadPoolDevice managed thread pool, and will return immediately.
+ *     It will call 'done' callback after all tasks are finished.
+ */
+#ifdef EIGEN_USE_THREADS
+
+template <typename TensorBlockMapper>
+struct TensorExecutorTilingContext {
+  TensorExecutorTilingContext() = default;
+  TensorExecutorTilingContext(const TensorBlockMapper& b_mapper, const TensorOpCost& b_cost, size_t b_aligned_size)
+      : block_mapper(b_mapper), cost(b_cost), aligned_blocksize(b_aligned_size) {}
+
+  TensorBlockMapper block_mapper;  // navigate through blocks
+  TensorOpCost cost;               // cost of computing a single block
+  size_t aligned_blocksize;        // block size after memory alignment
+};
+
+// Computes block evaluation parameters, and allocates temporary memory buffer
+// for blocks. See TensorExecutor/TensorAsyncExecutor (Tiling=On) below.
+template <typename Evaluator, typename TensorBlockMapper, bool Vectorizable>
+TensorExecutorTilingContext<TensorBlockMapper> GetTensorExecutorTilingContext(const Evaluator& evaluator) {
+  // Query expression tree for desired block size/shape.
+  TensorBlockResourceRequirements requirements = evaluator.getResourceRequirements();
+
+  // Update target block size based on cost model.
+  double taskSize = TensorCostModel<ThreadPoolDevice>::taskSize(1, requirements.cost_per_coeff);
+  requirements.size = static_cast<size_t>(1.0 / taskSize);
+
+  TensorBlockMapper block_mapper(typename TensorBlockMapper::Dimensions(evaluator.dimensions()), requirements);
+
+  size_t block_size = block_mapper.blockTotalSize();
+  const size_t align = numext::maxi(EIGEN_MAX_ALIGN_BYTES, 1);
+  const size_t aligned_blocksize =
+      align * numext::div_ceil<size_t>(block_size * sizeof(typename Evaluator::Scalar), align);
+
+  return {block_mapper, requirements.cost_per_coeff * block_size, aligned_blocksize};
+}
+
+template <typename Evaluator, typename StorageIndex, bool Vectorizable>
+struct EvalRange {
+  static void run(Evaluator* evaluator_in, const StorageIndex firstIdx, const StorageIndex lastIdx) {
+    Evaluator evaluator = *evaluator_in;
+    eigen_assert(lastIdx >= firstIdx);
+    for (StorageIndex i = firstIdx; i < lastIdx; ++i) {
+      evaluator.evalScalar(i);
+    }
+  }
+
+  static StorageIndex alignBlockSize(StorageIndex size) { return size; }
+};
+
+template <typename Evaluator, typename StorageIndex>
+struct EvalRange<Evaluator, StorageIndex, /*Vectorizable*/ true> {
+  static constexpr int PacketSize = unpacket_traits<typename Evaluator::PacketReturnType>::size;
+
+  static void run(Evaluator* evaluator_in, const StorageIndex firstIdx, const StorageIndex lastIdx) {
+    Evaluator evaluator = *evaluator_in;
+    eigen_assert(lastIdx >= firstIdx);
+    StorageIndex i = firstIdx;
+    if (lastIdx - firstIdx >= PacketSize) {
+      eigen_assert(firstIdx % PacketSize == 0);
+      StorageIndex last_chunk_offset = lastIdx - 4 * PacketSize;
+      // Give compiler a strong possibility to unroll the loop. But don't insist
+      // on unrolling, because if the function is expensive compiler should not
+      // unroll the loop at the expense of inlining.
+      for (; i <= last_chunk_offset; i += 4 * PacketSize) {
+        for (StorageIndex j = 0; j < 4; j++) {
+          evaluator.evalPacket(i + j * PacketSize);
+        }
+      }
+      last_chunk_offset = lastIdx - PacketSize;
+      for (; i <= last_chunk_offset; i += PacketSize) {
+        evaluator.evalPacket(i);
+      }
+    }
+    for (; i < lastIdx; ++i) {
+      evaluator.evalScalar(i);
+    }
+  }
+
+  static StorageIndex alignBlockSize(StorageIndex size) {
+    // Align block size to packet size and account for unrolling in run above.
+    if (size >= 16 * PacketSize) {
+      return (size + 4 * PacketSize - 1) & ~(4 * PacketSize - 1);
+    }
+    // Aligning to 4 * PacketSize would increase block size by more than 25%.
+    return (size + PacketSize - 1) & ~(PacketSize - 1);
+  }
+};
+
+// Evaluates a range of blocks for the tiled executors below. Each task copies
+// the evaluator so that concurrent tasks never share per-instance state (e.g.
+// stateful functors reached through coeff()), matching EvalRange for the
+// non-tiled path.
+template <typename Evaluator, typename BlockMapper, typename IndexType>
+struct EvalBlockRange {
+  static void run(Evaluator* evaluator_in, const BlockMapper& block_mapper, const ThreadPoolDevice& device,
+                  IndexType firstBlockIdx, IndexType lastBlockIdx) {
+    typedef TensorBlockScratchAllocator<ThreadPoolDevice> TensorBlockScratch;
+    Evaluator evaluator = *evaluator_in;
+    eigen_assert(lastBlockIdx >= firstBlockIdx);
+    TensorBlockScratch scratch(device);
+
+    for (IndexType block_idx = firstBlockIdx; block_idx < lastBlockIdx; ++block_idx) {
+      auto desc = block_mapper.blockDescriptor(block_idx);
+      evaluator.evalBlock(desc, scratch);
+      scratch.reset();
+    }
+  }
+};
+
+template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
+class TensorExecutor<Expression, ThreadPoolDevice, Vectorizable, Tiling> {
+ public:
+  typedef typename Expression::Index StorageIndex;
+
+  static EIGEN_STRONG_INLINE void run(const Expression& expr, const ThreadPoolDevice& device) {
+    typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
+    typedef EvalRange<Evaluator, StorageIndex, Vectorizable> EvalRange;
+
+    Evaluator evaluator(expr, device);
+    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+    if (needs_assign) {
+      const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
+      device.parallelFor(
+          size, evaluator.costPerCoeff(Vectorizable), EvalRange::alignBlockSize,
+          [&evaluator](StorageIndex firstIdx, StorageIndex lastIdx) { EvalRange::run(&evaluator, firstIdx, lastIdx); });
+    }
+    evaluator.cleanup();
+  }
+};
+
+template <typename Expression, bool Vectorizable>
+class TensorExecutor<Expression, ThreadPoolDevice, Vectorizable,
+                     /*Tiling=*/TiledEvaluation::On> {
+ public:
+  typedef typename traits<Expression>::Index IndexType;
+  typedef typename traits<Expression>::Scalar Scalar;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  static constexpr int NumDims = traits<Expression>::NumDimensions;
+
+  typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
+  typedef TensorBlockMapper<NumDims, Evaluator::Layout, IndexType> BlockMapper;
+  typedef TensorExecutorTilingContext<BlockMapper> TilingContext;
+
+  typedef internal::TensorBlockDescriptor<NumDims, IndexType> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<ThreadPoolDevice> TensorBlockScratch;
+
+  static EIGEN_STRONG_INLINE void run(const Expression& expr, const ThreadPoolDevice& device) {
+    Evaluator evaluator(expr, device);
+
+    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+    if (needs_assign) {
+      const TilingContext tiling =
+          internal::GetTensorExecutorTilingContext<Evaluator, BlockMapper, Vectorizable>(evaluator);
+
+      auto eval_block = [&device, &evaluator, &tiling](IndexType firstBlockIdx, IndexType lastBlockIdx) {
+        EvalBlockRange<Evaluator, BlockMapper, IndexType>::run(&evaluator, tiling.block_mapper, device, firstBlockIdx,
+                                                               lastBlockIdx);
+      };
+
+      // Evaluate small expressions directly as a single block.
+      if (tiling.block_mapper.blockCount() == 1) {
+        TensorBlockScratch scratch(device);
+        TensorBlockDesc desc(0, tiling.block_mapper.blockDimensions());
+        evaluator.evalBlock(desc, scratch);
+      } else {
+        device.parallelFor(tiling.block_mapper.blockCount(), tiling.cost, std::move(eval_block));
+      }
+    }
+    evaluator.cleanup();
+  }
+};
+
+template <typename Expression, typename DoneCallback, bool Vectorizable, TiledEvaluation Tiling>
+class TensorAsyncExecutor<Expression, ThreadPoolDevice, DoneCallback, Vectorizable, Tiling> {
+ public:
+  typedef typename Expression::Index StorageIndex;
+  typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
+
+  static EIGEN_STRONG_INLINE void runAsync(const Expression& expr, const ThreadPoolDevice& device, DoneCallback done) {
+    TensorAsyncExecutorContext* const ctx = new TensorAsyncExecutorContext(expr, device, std::move(done));
+
+    const auto on_eval_subexprs = [ctx, &device](bool need_assign) -> void {
+      if (!need_assign) {
+        delete ctx;
+        return;
+      }
+
+      typedef EvalRange<Evaluator, StorageIndex, Vectorizable> EvalRange;
+      const StorageIndex size = static_cast<StorageIndex>(array_prod(ctx->evaluator.dimensions()));
+      device.parallelForAsync(
+          size, ctx->evaluator.costPerCoeff(Vectorizable), EvalRange::alignBlockSize,
+          [ctx](StorageIndex firstIdx, StorageIndex lastIdx) { EvalRange::run(&ctx->evaluator, firstIdx, lastIdx); },
+          [ctx]() { delete ctx; });
+    };
+
+    ctx->evaluator.evalSubExprsIfNeededAsync(nullptr, on_eval_subexprs);
+  }
+
+ private:
+  struct TensorAsyncExecutorContext {
+    TensorAsyncExecutorContext(const Expression& expr, const ThreadPoolDevice& thread_pool, DoneCallback done)
+        : evaluator(expr, thread_pool), on_done(std::move(done)) {}
+
+    ~TensorAsyncExecutorContext() {
+      evaluator.cleanup();
+      on_done();
+    }
+
+    Evaluator evaluator;
+
+   private:
+    DoneCallback on_done;
+  };
+};
+
+template <typename Expression, typename DoneCallback, bool Vectorizable>
+class TensorAsyncExecutor<Expression, ThreadPoolDevice, DoneCallback, Vectorizable, /*Tileable*/ TiledEvaluation::On> {
+ public:
+  typedef typename traits<Expression>::Index IndexType;
+  typedef typename traits<Expression>::Scalar Scalar;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  static constexpr int NumDims = traits<Expression>::NumDimensions;
+
+  typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
+  typedef TensorBlockMapper<NumDims, Evaluator::Layout, IndexType> BlockMapper;
+  typedef TensorExecutorTilingContext<BlockMapper> TilingContext;
+
+  typedef internal::TensorBlockDescriptor<NumDims, IndexType> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<ThreadPoolDevice> TensorBlockScratch;
+
+  static EIGEN_STRONG_INLINE void runAsync(const Expression& expr, const ThreadPoolDevice& device, DoneCallback done) {
+    TensorAsyncExecutorContext* const ctx = new TensorAsyncExecutorContext(expr, device, std::move(done));
+
+    const auto on_eval_subexprs = [ctx](bool need_assign) -> void {
+      if (!need_assign) {
+        delete ctx;
+        return;
+      }
+
+      ctx->tiling = internal::GetTensorExecutorTilingContext<Evaluator, BlockMapper, Vectorizable>(ctx->evaluator);
+
+      auto eval_block = [ctx](IndexType firstBlockIdx, IndexType lastBlockIdx) {
+        EvalBlockRange<Evaluator, BlockMapper, IndexType>::run(&ctx->evaluator, ctx->tiling.block_mapper, ctx->device,
+                                                               firstBlockIdx, lastBlockIdx);
+      };
+
+      // Evaluate small expressions directly as a single block.
+      if (ctx->tiling.block_mapper.blockCount() == 1) {
+        TensorBlockScratch scratch(ctx->device);
+        TensorBlockDesc desc(0, ctx->tiling.block_mapper.blockDimensions());
+        ctx->evaluator.evalBlock(desc, scratch);
+        delete ctx;
+      } else {
+        ctx->device.parallelForAsync(ctx->tiling.block_mapper.blockCount(), ctx->tiling.cost, eval_block,
+                                     [ctx]() { delete ctx; });
+      }
+    };
+
+    ctx->evaluator.evalSubExprsIfNeededAsync(nullptr, on_eval_subexprs);
+  }
+
+ private:
+  struct TensorAsyncExecutorContext {
+    TensorAsyncExecutorContext(const Expression& expr, const ThreadPoolDevice& thread_pool, DoneCallback done)
+        : device(thread_pool), evaluator(expr, thread_pool), on_done(std::move(done)) {}
+
+    ~TensorAsyncExecutorContext() {
+      evaluator.cleanup();
+      on_done();
+    }
+
+    const ThreadPoolDevice& device;
+    Evaluator evaluator;
+    TilingContext tiling;
+
+   private:
+    DoneCallback on_done;
+  };
+};
+
+#endif  // EIGEN_USE_THREADS
+
+// GPU: the evaluation of the expression is offloaded to a GPU.
+#if defined(EIGEN_USE_GPU)
+
+template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
+class TensorExecutor<Expression, GpuDevice, Vectorizable, Tiling> {
+ public:
+  typedef typename Expression::Index StorageIndex;
+  static void run(const Expression& expr, const GpuDevice& device);
+};
+
+#if defined(EIGEN_GPUCC)
+// Returns 1 if lhs + rhs would overflow, -1 if it would underflow, otherwise 0.
+template <typename Index>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE int sum_will_overflow(Index lhs, Index rhs) {
+  const Index highest = NumTraits<Index>::highest();
+  const Index lowest = NumTraits<Index>::lowest();
+  if (lhs > 0 && rhs > 0) {
+    return lhs > highest - rhs ? 1 : 0;
+  } else if (lhs < 0 && rhs < 0) {
+    return lhs < lowest - rhs ? -1 : 0;
+  } else {
+    return 0;
+  }
+}
+
+// Returns lhs + rhs, saturating to the highest/lowest representable value on
+// overflow/underflow respectively.
+template <typename Index>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index saturate_add(Index lhs, Index rhs) {
+  const Index highest = NumTraits<Index>::highest();
+  const Index lowest = NumTraits<Index>::lowest();
+  int overflow = sum_will_overflow(lhs, rhs);
+  return overflow == 1 ? highest : overflow == -1 ? lowest : lhs + rhs;
+}
+
+// A functor that adds step_size to a given index, saturating to avoid
+// overflow/underflow. If overflow/underflow is not possible, regular addition
+// is used (for efficiency).
+template <typename Index>
+struct SafeStep {
+  // lastIdx is one past the end of the possible indexes.
+  // step_size is the value that will be added to the given index when the
+  // functor is called.
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SafeStep(Index lastIdx, Index step_size)
+      : can_overflow_(sum_will_overflow(lastIdx, step_size)), step_size_(step_size) {}
+
+  // Adds step_size to index, saturating on overflow (if overflow is possible).
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index operator()(Index index) const {
+    return can_overflow_ ? saturate_add(index, step_size_) : index + step_size_;
+  }
+
+ private:
+  const bool can_overflow_;
+  const Index step_size_;
+};
+
+template <typename Evaluator, typename StorageIndex, bool Vectorizable>
+struct EigenMetaKernelEval {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void run(Evaluator& eval, StorageIndex firstIdx, StorageIndex lastIdx,
+                                                        StorageIndex step_size) {
+    SafeStep<StorageIndex> safe_step(lastIdx, step_size);
+    for (StorageIndex i = firstIdx; i < lastIdx; i = safe_step(i)) {
+      eval.evalScalar(i);
+    }
+  }
+};
+
+template <typename Evaluator, typename StorageIndex>
+struct EigenMetaKernelEval<Evaluator, StorageIndex, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void run(Evaluator& eval, StorageIndex firstIdx, StorageIndex lastIdx,
+                                                        StorageIndex step_size) {
+    const StorageIndex PacketSize = unpacket_traits<typename Evaluator::PacketReturnType>::size;
+    const StorageIndex vectorized_size = (lastIdx / PacketSize) * PacketSize;
+    const StorageIndex vectorized_step_size = step_size * PacketSize;
+
+    SafeStep<StorageIndex> safe_vectorized_step(vectorized_size, vectorized_step_size);
+    // Use the vector path
+    for (StorageIndex i = firstIdx * PacketSize; i < vectorized_size; i = safe_vectorized_step(i)) {
+      eval.evalPacket(i);
+    }
+    SafeStep<StorageIndex> safe_step(lastIdx, step_size);
+    for (StorageIndex i = saturate_add(vectorized_size, firstIdx); i < lastIdx; i = safe_step(i)) {
+      eval.evalScalar(i);
+    }
+  }
+};
+
+template <typename Evaluator, typename StorageIndex>
+__global__ void __launch_bounds__(1024) EigenMetaKernel(Evaluator eval, StorageIndex size) {
+  const StorageIndex first_index = blockIdx.x * blockDim.x + threadIdx.x;
+  const StorageIndex step_size = blockDim.x * gridDim.x;
+
+  const bool vectorizable = Evaluator::PacketAccess & Evaluator::IsAligned;
+  EigenMetaKernelEval<Evaluator, StorageIndex, vectorizable>::run(eval, first_index, size, step_size);
+}
+
+/*static*/
+template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
+EIGEN_STRONG_INLINE void TensorExecutor<Expression, GpuDevice, Vectorizable, Tiling>::run(const Expression& expr,
+                                                                                          const GpuDevice& device) {
+  TensorEvaluator<Expression, GpuDevice> evaluator(expr, device);
+  const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+  if (needs_assign) {
+    const int block_size = device.maxGpuThreadsPerBlock();
+    const int max_blocks = static_cast<int>(
+        numext::mini<int64_t>(device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor(),
+                              NumTraits<StorageIndex>::highest()) /
+        block_size);
+    const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
+    // Create at least one block to ensure we don't crash with tensors of size 0.
+    const int num_blocks = numext::maxi<int>(
+        numext::mini<int>(max_blocks, static_cast<int>(numext::div_ceil<StorageIndex>(size, block_size))), 1);
+
+    LAUNCH_GPU_KERNEL((EigenMetaKernel<TensorEvaluator<Expression, GpuDevice>, StorageIndex>), num_blocks, block_size,
+                      0, device, evaluator, size);
+  }
+  evaluator.cleanup();
+}
+
+#endif  // EIGEN_GPUCC
+#endif  // EIGEN_USE_GPU
+
+// SYCL Executor policy
+#ifdef EIGEN_USE_SYCL
+
+template <typename Evaluator>
+struct ExecExprFunctorKernel {
+  typedef typename Evaluator::Index Index;
+  Evaluator evaluator;
+  const Index range;
+  template <typename Scratch>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ExecExprFunctorKernel(const Scratch, Evaluator evaluator_, const Index range_)
+      : evaluator(evaluator_), range(range_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void operator()(cl::sycl::nd_item<1> itemID) const { compute(itemID); }
+  template <bool is_vec = Evaluator::PacketAccess>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<!is_vec> compute(const cl::sycl::nd_item<1>& itemID) const {
+    Index gId = static_cast<Index>(itemID.get_global_linear_id());
+    Index total_threads = itemID.get_global_range(0);
+
+    for (Index i = gId; i < range; i += total_threads) {
+      evaluator.evalScalar(i);
+    }
+  }
+  template <bool is_vec = Evaluator::PacketAccess>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<is_vec> compute(const cl::sycl::nd_item<1>& itemID) const {
+    const Index vectorizedRange = (range / Evaluator::PacketSize) * Evaluator::PacketSize;
+    Index gId = static_cast<Index>(itemID.get_global_linear_id());
+    const Index step = Evaluator::PacketSize * itemID.get_global_range(0);
+    const Index start = Evaluator::PacketSize * gId;
+    for (Index i = start; i < vectorizedRange; i += step) {
+      evaluator.evalPacket(i);
+    }
+    gId += vectorizedRange;
+    for (Index i = gId; i < range; i += itemID.get_global_range(0)) {
+      evaluator.evalScalar(i);
+    }
+  }
+};
+
+template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
+class TensorExecutor<Expression, Eigen::SyclDevice, Vectorizable, Tiling> {
+ public:
+  typedef typename Expression::Index Index;
+  static EIGEN_STRONG_INLINE void run(const Expression& expr, const Eigen::SyclDevice& dev) {
+    typedef Eigen::TensorEvaluator<Expression, Eigen::SyclDevice> Evaluator;
+    Evaluator evaluator(expr, dev);
+    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
+    if (needs_assign) {
+      Index range, GRange, tileSize;
+      Index total_size = ::Eigen::internal::array_prod(evaluator.dimensions());
+      total_size = (total_size == 0) ? 1 : total_size;
+      const int PacketSize = Eigen::PacketType<typename Evaluator::CoeffReturnType, Eigen::SyclDevice>::size;
+      Index vectorizable_threads = static_cast<Index>(total_size / PacketSize);
+      dev.parallel_for_setup(vectorizable_threads, tileSize, range, GRange);
+      range = total_size;
+
+      dev.template nullary_kernel_launcher<typename Evaluator::CoeffReturnType, ExecExprFunctorKernel<Evaluator> >(
+             evaluator, cl::sycl::nd_range<1>(cl::sycl::range<1>(GRange), cl::sycl::range<1>(tileSize)), Index(1),
+             range)
+          .wait();
+    }
+    evaluator.cleanup();
+  }
+};
+
+#endif
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_EXECUTOR_H
diff --git a/contrib/Eigen/src/Tensor/TensorExpr.h b/contrib/Eigen/src/Tensor/TensorExpr.h
new file mode 100644
index 0000000..74f1582
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorExpr.h
@@ -0,0 +1,299 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_EXPR_H
+#define EIGEN_TENSOR_TENSOR_EXPR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename NullaryOp, typename XprType>
+struct traits<TensorCwiseNullaryOp<NullaryOp, XprType> > : traits<XprType> {
+  typedef traits<XprType> XprTraits;
+  typedef typename XprType::Scalar Scalar;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+  enum { Flags = 0 };
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor nullary expression.
+ *
+ * The TensorCwiseNullaryOp class applies a nullary operator to an expression.
+ * This is typically used to generate constants.
+ */
+template <typename NullaryOp, typename XprType>
+class TensorCwiseNullaryOp : public TensorBase<TensorCwiseNullaryOp<NullaryOp, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorCwiseNullaryOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorCwiseNullaryOp>::non_const_type Nested;
+  typedef typename Eigen::internal::traits<TensorCwiseNullaryOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorCwiseNullaryOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseNullaryOp(const XprType& xpr, const NullaryOp& func = NullaryOp())
+      : m_xpr(xpr), m_functor(func) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& nestedExpression() const { return m_xpr; }
+
+  EIGEN_DEVICE_FUNC const NullaryOp& functor() const { return m_functor; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const NullaryOp m_functor;
+};
+
+namespace internal {
+template <typename UnaryOp, typename XprType>
+struct traits<TensorCwiseUnaryOp<UnaryOp, XprType> > : traits<XprType> {
+  // TODO(phli): Add InputScalar, InputPacket.  Check references to
+  // current Scalar/Packet to see if the intent is Input or Output.
+  typedef typename result_of<UnaryOp(typename XprType::Scalar)>::type Scalar;
+  typedef traits<XprType> XprTraits;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename TypeConversion<Scalar, typename XprTraits::PointerType>::type PointerType;
+};
+
+template <typename UnaryOp, typename XprType>
+struct eval<TensorCwiseUnaryOp<UnaryOp, XprType>, Eigen::Dense> {
+  typedef const TensorCwiseUnaryOp<UnaryOp, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor unary expression.
+ *
+ * The TensorCwiseUnaryOp class represents an expression where a unary operator
+ * (e.g. cwiseSqrt) is applied to an expression.
+ */
+template <typename UnaryOp, typename XprType>
+class TensorCwiseUnaryOp : public TensorBase<TensorCwiseUnaryOp<UnaryOp, XprType>, ReadOnlyAccessors> {
+ public:
+  // TODO(phli): Add InputScalar, InputPacket.  Check references to
+  // current Scalar/Packet to see if the intent is Input or Output.
+  typedef typename Eigen::internal::traits<TensorCwiseUnaryOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef Scalar CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorCwiseUnaryOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorCwiseUnaryOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorCwiseUnaryOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
+      : m_xpr(xpr), m_functor(func) {}
+
+  EIGEN_DEVICE_FUNC const UnaryOp& functor() const { return m_functor; }
+
+  /** \returns the nested expression */
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& nestedExpression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const UnaryOp m_functor;
+};
+
+namespace internal {
+template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
+struct traits<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType> > {
+  // Type promotion to handle the case where the types of the lhs and the rhs
+  // are different.
+  // TODO(phli): Add Lhs/RhsScalar, Lhs/RhsPacket.  Check references to
+  // current Scalar/Packet to see if the intent is Inputs or Output.
+  typedef typename result_of<BinaryOp(typename LhsXprType::Scalar, typename RhsXprType::Scalar)>::type Scalar;
+  typedef traits<LhsXprType> XprTraits;
+  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
+                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
+  typedef
+      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename TypeConversion<Scalar,
+                                  std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
+                                                     typename traits<LhsXprType>::PointerType,
+                                                     typename traits<RhsXprType>::PointerType> >::type PointerType;
+  enum { Flags = 0 };
+};
+
+template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
+struct eval<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>, Eigen::Dense> {
+  typedef const TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor binary expression.
+ *
+ * The TensorCwiseBinaryOp class represents an expression where a binary
+ * operator (e.g. addition) is applied to a lhs and a rhs expression.
+ */
+template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
+class TensorCwiseBinaryOp
+    : public TensorBase<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>, ReadOnlyAccessors> {
+ public:
+  // TODO(phli): Add Lhs/RhsScalar, Lhs/RhsPacket.  Check references to
+  // current Scalar/Packet to see if the intent is Inputs or Output.
+  typedef typename Eigen::internal::traits<TensorCwiseBinaryOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef Scalar CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorCwiseBinaryOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorCwiseBinaryOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorCwiseBinaryOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseBinaryOp(const LhsXprType& lhs, const RhsXprType& rhs,
+                                                            const BinaryOp& func = BinaryOp())
+      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_functor(func) {}
+
+  EIGEN_DEVICE_FUNC const BinaryOp& functor() const { return m_functor; }
+
+  /** \returns the nested expressions */
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
+    return m_lhs_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
+    return m_rhs_xpr;
+  }
+
+ protected:
+  typename LhsXprType::Nested m_lhs_xpr;
+  typename RhsXprType::Nested m_rhs_xpr;
+  const BinaryOp m_functor;
+};
+
+namespace internal {
+template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
+struct traits<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType> > {
+  // Type promotion to handle the case where the types of the args are different.
+  typedef typename result_of<TernaryOp(typename Arg1XprType::Scalar, typename Arg2XprType::Scalar,
+                                       typename Arg3XprType::Scalar)>::type Scalar;
+  typedef traits<Arg1XprType> XprTraits;
+  typedef typename traits<Arg1XprType>::StorageKind StorageKind;
+  typedef typename traits<Arg1XprType>::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename TypeConversion<Scalar,
+                                  std::conditional_t<Pointer_type_promotion<typename Arg2XprType::Scalar, Scalar>::val,
+                                                     typename traits<Arg2XprType>::PointerType,
+                                                     typename traits<Arg3XprType>::PointerType> >::type PointerType;
+  enum { Flags = 0 };
+};
+
+template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
+struct eval<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>, Eigen::Dense> {
+  typedef const TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>& type;
+};
+
+}  // end namespace internal
+
+template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
+class TensorCwiseTernaryOp
+    : public TensorBase<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorCwiseTernaryOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef Scalar CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorCwiseTernaryOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorCwiseTernaryOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorCwiseTernaryOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseTernaryOp(const Arg1XprType& arg1, const Arg2XprType& arg2,
+                                                             const Arg3XprType& arg3,
+                                                             const TernaryOp& func = TernaryOp())
+      : m_arg1_xpr(arg1), m_arg2_xpr(arg2), m_arg3_xpr(arg3), m_functor(func) {}
+
+  EIGEN_DEVICE_FUNC const TernaryOp& functor() const { return m_functor; }
+
+  /** \returns the nested expressions */
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename Arg1XprType::Nested>& arg1Expression() const {
+    return m_arg1_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename Arg2XprType::Nested>& arg2Expression() const {
+    return m_arg2_xpr;
+  }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename Arg3XprType::Nested>& arg3Expression() const {
+    return m_arg3_xpr;
+  }
+
+ protected:
+  typename Arg1XprType::Nested m_arg1_xpr;
+  typename Arg2XprType::Nested m_arg2_xpr;
+  typename Arg3XprType::Nested m_arg3_xpr;
+  const TernaryOp m_functor;
+};
+
+namespace internal {
+template <typename IfXprType, typename ThenXprType, typename ElseXprType>
+struct traits<TensorSelectOp<IfXprType, ThenXprType, ElseXprType> > : traits<ThenXprType> {
+  typedef typename traits<ThenXprType>::Scalar Scalar;
+  typedef traits<ThenXprType> XprTraits;
+  typedef typename promote_storage_type<typename traits<ThenXprType>::StorageKind,
+                                        typename traits<ElseXprType>::StorageKind>::ret StorageKind;
+  typedef
+      typename promote_index_type<typename traits<ElseXprType>::Index, typename traits<ThenXprType>::Index>::type Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef std::conditional_t<Pointer_type_promotion<typename ThenXprType::Scalar, Scalar>::val,
+                             typename traits<ThenXprType>::PointerType, typename traits<ElseXprType>::PointerType>
+      PointerType;
+};
+
+template <typename IfXprType, typename ThenXprType, typename ElseXprType>
+struct eval<TensorSelectOp<IfXprType, ThenXprType, ElseXprType>, Eigen::Dense> {
+  typedef const TensorSelectOp<IfXprType, ThenXprType, ElseXprType>& type;
+};
+
+}  // end namespace internal
+
+template <typename IfXprType, typename ThenXprType, typename ElseXprType>
+class TensorSelectOp : public TensorBase<TensorSelectOp<IfXprType, ThenXprType, ElseXprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorSelectOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename internal::promote_storage_type<typename ThenXprType::CoeffReturnType,
+                                                  typename ElseXprType::CoeffReturnType>::ret CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorSelectOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorSelectOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorSelectOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC TensorSelectOp(const IfXprType& a_condition, const ThenXprType& a_then, const ElseXprType& a_else)
+      : m_condition(a_condition), m_then(a_then), m_else(a_else) {}
+
+  EIGEN_DEVICE_FUNC const IfXprType& ifExpression() const { return m_condition; }
+
+  EIGEN_DEVICE_FUNC const ThenXprType& thenExpression() const { return m_then; }
+
+  EIGEN_DEVICE_FUNC const ElseXprType& elseExpression() const { return m_else; }
+
+ protected:
+  typename IfXprType::Nested m_condition;
+  typename ThenXprType::Nested m_then;
+  typename ElseXprType::Nested m_else;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_EXPR_H
diff --git a/contrib/Eigen/src/Tensor/TensorFFT.h b/contrib/Eigen/src/Tensor/TensorFFT.h
new file mode 100644
index 0000000..e7eced6
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorFFT.h
@@ -0,0 +1,740 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Jianwei Cui <thucjw@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_FFT_H
+#define EIGEN_TENSOR_TENSOR_FFT_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <bool IsReal>
+struct MakeComplex {
+  template <typename T>
+  EIGEN_DEVICE_FUNC T operator()(const T& val) const {
+    return val;
+  }
+};
+
+template <>
+struct MakeComplex<true> {
+  template <typename T>
+  EIGEN_DEVICE_FUNC internal::make_complex_t<T> operator()(const T& val) const {
+    return internal::make_complex_t<T>(val, T(0));
+  }
+};
+
+template <int ResultType>
+struct PartOf {
+  template <typename T>
+  T operator()(const T& val) const {
+    return val;
+  }
+};
+
+template <>
+struct PartOf<RealPart> {
+  template <typename T, typename EnableIf = std::enable_if_t<NumTraits<T>::IsComplex>>
+  typename NumTraits<T>::Real operator()(const T& val) const {
+    return Eigen::numext::real(val);
+  }
+};
+
+template <>
+struct PartOf<ImagPart> {
+  template <typename T, typename EnableIf = std::enable_if_t<NumTraits<T>::IsComplex>>
+  typename NumTraits<T>::Real operator()(const T& val) const {
+    return Eigen::numext::imag(val);
+  }
+};
+
+namespace internal {
+template <typename FFT, typename XprType, int FFTResultType, int FFTDir>
+struct traits<TensorFFTOp<FFT, XprType, FFTResultType, FFTDir>> : public traits<XprType> {
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef make_complex_t<Scalar> ComplexScalar;
+  typedef typename XprTraits::Scalar InputScalar;
+  typedef std::conditional_t<FFTResultType == RealPart || FFTResultType == ImagPart, RealScalar, ComplexScalar>
+      OutputScalar;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename traits<XprType>::PointerType PointerType;
+};
+
+template <typename FFT, typename XprType, int FFTResultType, int FFTDirection>
+struct eval<TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection>, Eigen::Dense> {
+  typedef const TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor FFT class.
+ *
+ * \note Input values are required to be finite. Complex multiplications on the
+ * hot path use the naive (a+bi)(c+di) = (ac-bd) + (ad+bc)i form, which differs
+ * from C99 / cppreference complex multiplication for non-finite operands: an
+ * input containing +/-inf or NaN may produce NaN-laden output where the C99
+ * specification would have given a finite or infinite result. Callers that
+ * need NaN/inf propagation per Annex G must filter inputs first.
+ *
+ * TODO:
+ * Add support for multithreaded evaluation
+ * Improve the performance on GPU
+ */
+template <typename FFT, typename XprType, int FFTResultType, int FFTDir>
+class TensorFFTOp : public TensorBase<TensorFFTOp<FFT, XprType, FFTResultType, FFTDir>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorFFTOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  typedef std::conditional_t<FFTResultType == RealPart || FFTResultType == ImagPart, RealScalar, ComplexScalar>
+      OutputScalar;
+  typedef OutputScalar CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorFFTOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorFFTOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorFFTOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFFTOp(const XprType& expr, const FFT& fft) : m_xpr(expr), m_fft(fft) {}
+
+  EIGEN_DEVICE_FUNC const FFT& fft() const { return m_fft; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const FFT m_fft;
+};
+
+// Eval as rvalue
+template <typename FFT, typename ArgType, typename Device, int FFTResultType, int FFTDir>
+struct TensorEvaluator<const TensorFFTOp<FFT, ArgType, FFTResultType, FFTDir>, Device> {
+  typedef TensorFFTOp<FFT, ArgType, FFTResultType, FFTDir> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef internal::make_complex_t<Scalar> ComplexScalar;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
+  typedef internal::traits<XprType> XprTraits;
+  typedef typename XprTraits::Scalar InputScalar;
+  typedef std::conditional_t<FFTResultType == RealPart || FFTResultType == ImagPart, RealScalar, ComplexScalar>
+      OutputScalar;
+  typedef OutputScalar CoeffReturnType;
+  typedef typename PacketType<OutputScalar, Device>::type PacketReturnType;
+  static constexpr int PacketSize = internal::unpacket_traits<PacketReturnType>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = true,
+    // FFT eagerly materializes its result into m_data; once that buffer
+    // exists, exposing block access is just a wrapper around it. Leave
+    // PreferBlockAccess false so the executor still uses the cheaper
+    // packet path by default; this only matters when an outer expression
+    // calls block() directly.
+    BlockAccess = (NumDims > 0),
+    PreferBlockAccess = false,
+    CoordAccess = false,
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef typename internal::TensorMaterializedBlock<std::remove_const_t<CoeffReturnType>, NumDims, Layout, Index>
+      TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_fft(op.fft()), m_impl(op.expression(), device), m_data(nullptr), m_device(device) {
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    for (int i = 0; i < NumDims; ++i) {
+      eigen_assert(input_dims[i] > 0);
+      m_dimensions[i] = input_dims[i];
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_strides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
+      }
+    } else {
+      m_strides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
+      }
+    }
+    m_size = m_dimensions.TotalSize();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    if (data) {
+      evalToBuf(data);
+      return false;
+    } else {
+      m_data = (EvaluatorPointerType)m_device.get(
+          (CoeffReturnType*)(m_device.allocate_temp(sizeof(CoeffReturnType) * m_size)));
+      evalToBuf(m_data);
+      return true;
+    }
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    if (m_data) {
+      m_device.deallocate(m_data);
+      m_data = nullptr;
+    }
+    m_impl.cleanup();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffReturnType coeff(Index index) const { return m_data[index]; }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_data + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_data; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_data != nullptr);
+    return TensorBlock::materialize(m_data, m_dimensions, desc, scratch);
+  }
+
+ private:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalToBuf(EvaluatorPointerType data) {
+    const bool write_to_out = std::is_same<OutputScalar, ComplexScalar>::value;
+    ComplexScalar* buf =
+        write_to_out ? (ComplexScalar*)data : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * m_size);
+
+    constexpr bool is_real_input = std::is_same<InputScalar, RealScalar>::value;
+    if (!is_real_input && m_impl.data() != nullptr) {
+      // Contiguous complex input — copy in one shot instead of N coeff() calls.
+      // `x = x.fft(...)` aliases input and output onto the same storage; in
+      // that case the data is already in `buf` and a memcpy would be self-
+      // overlapping (UB).
+      if (static_cast<const void*>(m_impl.data()) != static_cast<const void*>(buf)) {
+        m_device.memcpy(buf, m_impl.data(), m_size * sizeof(ComplexScalar));
+      }
+    } else {
+      for (Index i = 0; i < m_size; ++i) {
+        buf[i] = MakeComplex<is_real_input>()(m_impl.coeff(i));
+      }
+    }
+
+    for (size_t i = 0; i < m_fft.size(); ++i) {
+      Index dim = m_fft[i];
+      eigen_assert(dim >= 0 && dim < NumDims);
+      Index line_len = m_dimensions[dim];
+      eigen_assert(line_len >= 1);
+      if (line_len == 1) continue;
+      const Index stride = m_strides[dim];
+      const bool is_power_of_two = isPowerOfTwo(line_len);
+      const Index good_composite = is_power_of_two ? 0 : findGoodComposite(line_len);
+      const Index log_len = is_power_of_two ? getLog2(line_len) : getLog2(good_composite);
+      // Real, not ComplexScalar(s, 0): the latter would dispatch through
+      // libgcc __mulsc3/__muldc3 and re-introduce the NaN-check branch.
+      const RealScalar div_factor = (FFTDir == FFT_REVERSE) ? RealScalar(1) / RealScalar(line_len) : RealScalar(1);
+
+      // Scratch line buffer is only needed when we have to gather/scatter
+      // (stride != 1); for stride == 1 the FFT runs in place on `buf`.
+      ComplexScalar* line_buf =
+          (stride == 1) ? nullptr : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * line_len);
+
+      ComplexScalar* a =
+          is_power_of_two ? nullptr : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * good_composite);
+      ComplexScalar* b_fft =
+          is_power_of_two ? nullptr : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * good_composite);
+      ComplexScalar* pos_j_base_powered =
+          is_power_of_two ? nullptr : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * (line_len + 1));
+      if (!is_power_of_two) {
+        // Bluestein chirp factors t_n = exp(sqrt(-1) * pi * n^2 / line_len),
+        // n = 0..line_len. Computed in double for accuracy and cast down.
+        for (Index j = 0; j < line_len + 1; ++j) {
+          double arg = ((EIGEN_PI * j) * j) / line_len;
+          std::complex<double> tmp(numext::cos(arg), numext::sin(arg));
+          pos_j_base_powered[j] = static_cast<ComplexScalar>(tmp);
+        }
+        // The b-sequence and its forward FFT depend only on n, m, and the
+        // FFT direction — compute once and reuse for every line.
+        precompute_bluestein_b(b_fft, line_len, good_composite, log_len, pos_j_base_powered);
+      }
+
+      for (Index partial_index = 0; partial_index < m_size / line_len; ++partial_index) {
+        const Index base_offset = getBaseOffsetFromIndex(partial_index, dim);
+        ComplexScalar* line_ptr = (stride == 1) ? &buf[base_offset] : line_buf;
+
+        if (stride != 1) {
+          Index offset = base_offset;
+          for (Index j = 0; j < line_len; ++j, offset += stride) {
+            line_buf[j] = buf[offset];
+          }
+        }
+
+        if (is_power_of_two) {
+          processDataLineCooleyTukey(line_ptr, line_len, log_len);
+        } else {
+          processDataLineBluestein(line_ptr, line_len, good_composite, log_len, a, b_fft, pos_j_base_powered);
+        }
+
+        if (stride == 1) {
+          if (FFTDir == FFT_REVERSE) {
+            for (Index j = 0; j < line_len; ++j) {
+              line_ptr[j] *= div_factor;
+            }
+          }
+        } else {
+          Index offset = base_offset;
+          for (Index j = 0; j < line_len; ++j, offset += stride) {
+            buf[offset] = (FFTDir == FFT_FORWARD) ? line_buf[j] : line_buf[j] * div_factor;
+          }
+        }
+      }
+      if (line_buf) m_device.deallocate(line_buf);
+      if (!is_power_of_two) {
+        m_device.deallocate(a);
+        m_device.deallocate(b_fft);
+        m_device.deallocate(pos_j_base_powered);
+      }
+    }
+
+    if (!write_to_out) {
+      for (Index i = 0; i < m_size; ++i) {
+        data[i] = PartOf<FFTResultType>()(buf[i]);
+      }
+      m_device.deallocate(buf);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static bool isPowerOfTwo(Index x) {
+    eigen_assert(x > 0);
+    return !(x & (x - 1));
+  }
+
+  // The composite number for padding, used in Bluestein's FFT algorithm
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Index findGoodComposite(Index n) {
+    Index i = 2;
+    while (i < 2 * n - 1) i *= 2;
+    return i;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Index getLog2(Index m) {
+    Index log2m = 0;
+    while (m >>= 1) log2m++;
+    return log2m;
+  }
+
+  // Build the b-sequence and forward-FFT it once per dim. It depends only on
+  // (line_len, good_composite, FFTDir), so the result is shared across all
+  // lines — the main win for batched non-power-of-two transforms.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void precompute_bluestein_b(ComplexScalar* b_fft, Index n, Index m, Index log_m,
+                                                                    const ComplexScalar* pos_j_base_powered) {
+    internal::conj_if<FFTDir == FFT_REVERSE> cj;
+    for (Index i = 0; i < n; ++i) {
+      b_fft[i] = cj(pos_j_base_powered[i]);
+    }
+    for (Index i = n; i < m - n; ++i) {
+      b_fft[i] = ComplexScalar(0, 0);
+    }
+    for (Index i = m - n; i < m; ++i) {
+      b_fft[i] = cj(pos_j_base_powered[m - i]);
+    }
+    scramble_FFT(b_fft, m);
+    compute_1D_Butterfly<FFT_FORWARD>(b_fft, m, log_m);
+  }
+
+  // Call Cooley Tukey algorithm directly; line_len must be a power of 2.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void processDataLineCooleyTukey(ComplexScalar* line_buf, Index line_len,
+                                                                        Index log_len) {
+    eigen_assert(isPowerOfTwo(line_len));
+    scramble_FFT(line_buf, line_len);
+    compute_1D_Butterfly<FFTDir>(line_buf, line_len, log_len);
+  }
+
+  // Bluestein's algorithm: turn an arbitrary-length transform into three
+  // length-m power-of-two transforms (m = good_composite >= 2*line_len). The
+  // forward-FFT of b is taken as input (precomputed once per dim).
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void processDataLineBluestein(ComplexScalar* line_buf, Index line_len,
+                                                                      Index good_composite, Index log_m,
+                                                                      ComplexScalar* a, const ComplexScalar* b_fft,
+                                                                      const ComplexScalar* pos_j_base_powered) {
+    const Index n = line_len;
+    const Index m = good_composite;
+    // Data-side chirp is conjugated for forward, not for reverse — opposite
+    // of the b-sequence conjugation in precompute_bluestein_b.
+    internal::conj_if<FFTDir == FFT_FORWARD> cj;
+
+    for (Index i = 0; i < n; ++i) {
+      a[i] = internal::pmul(line_buf[i], cj(pos_j_base_powered[i]));
+    }
+    for (Index i = n; i < m; ++i) {
+      a[i] = ComplexScalar(0, 0);
+    }
+
+    scramble_FFT(a, m);
+    compute_1D_Butterfly<FFT_FORWARD>(a, m, log_m);
+
+    for (Index i = 0; i < m; ++i) {
+      a[i] = internal::pmul(a[i], b_fft[i]);
+    }
+
+    scramble_FFT(a, m);
+    compute_1D_Butterfly<FFT_REVERSE>(a, m, log_m);
+
+    const RealScalar inv_m = RealScalar(1) / RealScalar(m);
+    for (Index i = 0; i < n; ++i) {
+      line_buf[i] = internal::pmul(a[i] * inv_m, cj(pos_j_base_powered[i]));
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void scramble_FFT(ComplexScalar* data, Index n) {
+    eigen_assert(isPowerOfTwo(n));
+    Index j = 1;
+    for (Index i = 1; i < n; ++i) {
+      if (j > i) {
+        std::swap(data[j - 1], data[i - 1]);
+      }
+      Index m = n >> 1;
+      while (m >= 2 && j > m) {
+        j -= m;
+        m >>= 1;
+      }
+      j += m;
+    }
+  }
+
+  template <int Dir>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_2(ComplexScalar* data) {
+    ComplexScalar tmp = data[1];
+    data[1] = data[0] - data[1];
+    data[0] += tmp;
+  }
+
+  // Closed-form ±i multiplications: (re, im) * (0, ±1) without a generic
+  // complex multiply. Dispatched via mul_pm_i<Dir> at the radix-{4,8} leaves.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static ComplexScalar mul_neg_i(const ComplexScalar& c) {
+    return ComplexScalar(c.imag(), -c.real());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static ComplexScalar mul_pos_i(const ComplexScalar& c) {
+    return ComplexScalar(-c.imag(), c.real());
+  }
+  template <int Dir>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static ComplexScalar mul_pm_i(const ComplexScalar& c) {
+    return (Dir == FFT_FORWARD) ? mul_neg_i(c) : mul_pos_i(c);
+  }
+
+  template <int Dir>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_4(ComplexScalar* data) {
+    ComplexScalar tmp[4];
+    tmp[0] = data[0] + data[1];
+    tmp[1] = data[0] - data[1];
+    tmp[2] = data[2] + data[3];
+    tmp[3] = mul_pm_i<Dir>(data[2] - data[3]);
+    data[0] = tmp[0] + tmp[2];
+    data[1] = tmp[1] + tmp[3];
+    data[2] = tmp[0] - tmp[2];
+    data[3] = tmp[1] - tmp[3];
+  }
+
+  template <int Dir>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_8(ComplexScalar* data) {
+    ComplexScalar tmp_1[8];
+    ComplexScalar tmp_2[8];
+
+    tmp_1[0] = data[0] + data[1];
+    tmp_1[1] = data[0] - data[1];
+    tmp_1[2] = data[2] + data[3];
+    tmp_1[3] = mul_pm_i<Dir>(data[2] - data[3]);
+    tmp_1[4] = data[4] + data[5];
+    tmp_1[5] = data[4] - data[5];
+    tmp_1[6] = data[6] + data[7];
+    tmp_1[7] = mul_pm_i<Dir>(data[6] - data[7]);
+    tmp_2[0] = tmp_1[0] + tmp_1[2];
+    tmp_2[1] = tmp_1[1] + tmp_1[3];
+    tmp_2[2] = tmp_1[0] - tmp_1[2];
+    tmp_2[3] = tmp_1[1] - tmp_1[3];
+    tmp_2[4] = tmp_1[4] + tmp_1[6];
+    // omega_8^1 = (sqrt(2)/2, -sqrt(2)/2) for forward.
+    constexpr RealScalar kSqrt2Div2 = RealScalar(0.7071067811865476);
+    if (Dir == FFT_FORWARD) {
+      tmp_2[5] = internal::pmul(tmp_1[5] + tmp_1[7], ComplexScalar(kSqrt2Div2, -kSqrt2Div2));
+      tmp_2[6] = mul_neg_i(tmp_1[4] - tmp_1[6]);
+      tmp_2[7] = internal::pmul(tmp_1[5] - tmp_1[7], ComplexScalar(-kSqrt2Div2, -kSqrt2Div2));
+    } else {
+      tmp_2[5] = internal::pmul(tmp_1[5] + tmp_1[7], ComplexScalar(kSqrt2Div2, kSqrt2Div2));
+      tmp_2[6] = mul_pos_i(tmp_1[4] - tmp_1[6]);
+      tmp_2[7] = internal::pmul(tmp_1[5] - tmp_1[7], ComplexScalar(-kSqrt2Div2, kSqrt2Div2));
+    }
+    data[0] = tmp_2[0] + tmp_2[4];
+    data[1] = tmp_2[1] + tmp_2[5];
+    data[2] = tmp_2[2] + tmp_2[6];
+    data[3] = tmp_2[3] + tmp_2[7];
+    data[4] = tmp_2[0] - tmp_2[4];
+    data[5] = tmp_2[1] - tmp_2[5];
+    data[6] = tmp_2[2] - tmp_2[6];
+    data[7] = tmp_2[3] - tmp_2[7];
+  }
+
+  template <int Dir>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_1D_merge(ComplexScalar* data, Index n, Index n_power_of_2) {
+    // Original code:
+    // RealScalar wtemp = std::sin(EIGEN_PI/n);
+    // RealScalar wpi =  -std::sin(2 * EIGEN_PI/n);
+    const RealScalar wtemp = m_sin_PI_div_n_LUT[n_power_of_2];
+    const RealScalar wpi =
+        (Dir == FFT_FORWARD) ? m_minus_sin_2_PI_div_n_LUT[n_power_of_2] : -m_minus_sin_2_PI_div_n_LUT[n_power_of_2];
+
+    const ComplexScalar wp(wtemp, wpi);
+    const ComplexScalar wp_one = wp + ComplexScalar(1, 0);
+    const Index n2 = n / 2;
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+    // The class-level PacketReturnType keys off OutputScalar, which can be
+    // real for RealPart/ImagPart modes; resolve the complex packet here so
+    // the merge always vectorizes regardless of the output reduction.
+    using CPacket = typename internal::packet_traits<ComplexScalar>::type;
+    constexpr Index CPacketSize = internal::unpacket_traits<CPacket>::size;
+    // A batch's twiddles are a broadcast of the running factor times a
+    // precomputed ramp wp_one^{0..kBatch-1}: one vector pmul per packet
+    // instead of a scalar cmul per lane plus a round-trip through scratch. The
+    // running factor advances by wp_one^kBatch per batch; kBatch >= 4 keeps
+    // that recurrence at the same stride — and thus the same accumulated
+    // rounding — as the original scalar code.
+    //
+    // Two cases fall through to the scalar loop. A 1-wide complex packet
+    // (CPacketSize == 1: Packet1cd, i.e. SSE2 std::complex<double>) carries no
+    // SIMD parallelism — the "vector" path is then scalar dressed in packet
+    // ops and loses to the hand-unrolled scalar fallback. Packets wider than
+    // kMaxBatch (e.g. RVV with VLEN >= 1024 gives CPacketSize == 16 for
+    // std::complex<float>) overflow the ramp.
+    constexpr Index kMaxBatch = 8;
+    constexpr Index kBatch = (CPacketSize >= 4) ? CPacketSize : Index(4);
+    if (CPacketSize >= 2 && CPacketSize <= kMaxBatch && kBatch <= n2) {
+      // ramp[k] = wp_one^k — built once, reused for every batch and every line.
+      alignas(alignof(CPacket)) ComplexScalar ramp[kMaxBatch];
+      ramp[0] = ComplexScalar(1, 0);
+      for (Index k = 1; k < kBatch; ++k) ramp[k] = internal::pmul(ramp[k - 1], wp_one);
+      const ComplexScalar wp_one_batch = internal::pmul(ramp[kBatch - 1], wp_one);
+      const ComplexScalar wp_one_2batch = internal::pmul(wp_one_batch, wp_one_batch);
+
+      // Two batches are processed per iteration with two independent running
+      // factors, so the w recurrence (one complex pmul of latency) is no
+      // longer the serial bottleneck — each chain advances only once per two
+      // batches and overlaps the butterfly work of the other.
+      ComplexScalar w(1, 0);
+      Index i = 0;
+      for (; i + 2 * kBatch <= n2; i += 2 * kBatch) {
+        const CPacket wv0 = internal::pset1<CPacket>(w);
+        const CPacket wv1 = internal::pset1<CPacket>(internal::pmul(w, wp_one_batch));
+        for (Index k = 0; k < kBatch; k += CPacketSize) {
+          const CPacket rk = internal::pload<CPacket>(ramp + k);
+          const CPacket pa0 = internal::ploadu<CPacket>(data + i + k);
+          const CPacket pb0 = internal::ploadu<CPacket>(data + i + n2 + k);
+          const CPacket pa1 = internal::ploadu<CPacket>(data + i + kBatch + k);
+          const CPacket pb1 = internal::ploadu<CPacket>(data + i + kBatch + n2 + k);
+          const CPacket pt0 = internal::pmul(internal::pmul(wv0, rk), pb0);
+          const CPacket pt1 = internal::pmul(internal::pmul(wv1, rk), pb1);
+          internal::pstoreu(data + i + k, internal::padd(pa0, pt0));
+          internal::pstoreu(data + i + n2 + k, internal::psub(pa0, pt0));
+          internal::pstoreu(data + i + kBatch + k, internal::padd(pa1, pt1));
+          internal::pstoreu(data + i + kBatch + n2 + k, internal::psub(pa1, pt1));
+        }
+        w = internal::pmul(w, wp_one_2batch);
+      }
+      // n2 is a power of two >= kBatch, so this tail runs at most once.
+      for (; i < n2; i += kBatch) {
+        const CPacket wv = internal::pset1<CPacket>(w);
+        for (Index k = 0; k < kBatch; k += CPacketSize) {
+          const CPacket pw = internal::pmul(wv, internal::pload<CPacket>(ramp + k));
+          const CPacket pa = internal::ploadu<CPacket>(data + i + k);
+          const CPacket pb = internal::ploadu<CPacket>(data + i + n2 + k);
+          const CPacket pt = internal::pmul(pw, pb);
+          internal::pstoreu(data + i + k, internal::padd(pa, pt));
+          internal::pstoreu(data + i + n2 + k, internal::psub(pa, pt));
+        }
+      }
+      return;
+    }
+#endif
+
+    // Scalar fallback (GPU build, or RVV with VLEN >= 1024 → CPacketSize > 8).
+    const ComplexScalar wp_one_2 = internal::pmul(wp_one, wp_one);
+    const ComplexScalar wp_one_3 = internal::pmul(wp_one_2, wp_one);
+    const ComplexScalar wp_one_4 = internal::pmul(wp_one_3, wp_one);
+    ComplexScalar w(1.0, 0.0);
+    for (Index i = 0; i < n2; i += 4) {
+      const ComplexScalar w1 = internal::pmul(w, wp_one);
+      const ComplexScalar w2 = internal::pmul(w, wp_one_2);
+      const ComplexScalar w3 = internal::pmul(w, wp_one_3);
+      const ComplexScalar temp0 = internal::pmul(data[i + n2], w);
+      const ComplexScalar temp1 = internal::pmul(data[i + 1 + n2], w1);
+      const ComplexScalar temp2 = internal::pmul(data[i + 2 + n2], w2);
+      const ComplexScalar temp3 = internal::pmul(data[i + 3 + n2], w3);
+      w = internal::pmul(w, wp_one_4);
+
+      data[i + n2] = data[i] - temp0;
+      data[i] += temp0;
+
+      data[i + 1 + n2] = data[i + 1] - temp1;
+      data[i + 1] += temp1;
+
+      data[i + 2 + n2] = data[i + 2] - temp2;
+      data[i + 2] += temp2;
+
+      data[i + 3 + n2] = data[i + 3] - temp3;
+      data[i + 3] += temp3;
+    }
+  }
+
+  template <int Dir>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_1D_Butterfly(ComplexScalar* data, Index n, Index n_power_of_2) {
+    eigen_assert(isPowerOfTwo(n));
+    if (n > 8) {
+      compute_1D_Butterfly<Dir>(data, n / 2, n_power_of_2 - 1);
+      compute_1D_Butterfly<Dir>(data + n / 2, n / 2, n_power_of_2 - 1);
+      butterfly_1D_merge<Dir>(data, n, n_power_of_2);
+    } else if (n == 8) {
+      butterfly_8<Dir>(data);
+    } else if (n == 4) {
+      butterfly_4<Dir>(data);
+    } else if (n == 2) {
+      butterfly_2<Dir>(data);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index getBaseOffsetFromIndex(Index index, Index omitted_dim) const {
+    Index result = 0;
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > omitted_dim; --i) {
+        const Index partial_m_stride = m_strides[i] / m_dimensions[omitted_dim];
+        const Index idx = index / partial_m_stride;
+        index -= idx * partial_m_stride;
+        result += idx * m_strides[i];
+      }
+      result += index;
+    } else {
+      for (Index i = 0; i < omitted_dim; ++i) {
+        const Index partial_m_stride = m_strides[i] / m_dimensions[omitted_dim];
+        const Index idx = index / partial_m_stride;
+        index -= idx * partial_m_stride;
+        result += idx * m_strides[i];
+      }
+      result += index;
+    }
+    // Value of index_coords[omitted_dim] is not determined to this step
+    return result;
+  }
+
+ protected:
+  Index m_size;
+  const FFT EIGEN_DEVICE_REF m_fft;
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_strides;
+  TensorEvaluator<ArgType, Device> m_impl;
+  EvaluatorPointerType m_data;
+  const Device EIGEN_DEVICE_REF m_device;
+
+  // This will support a maximum FFT size of 2^32 for each dimension
+  // m_sin_PI_div_n_LUT[i] = (-2) * std::sin(EIGEN_PI / std::pow(2,i)) ^ 2;
+  const RealScalar m_sin_PI_div_n_LUT[32] = {RealScalar(0.0),
+                                             RealScalar(-2),
+                                             RealScalar(-0.999999999999999),
+                                             RealScalar(-0.292893218813453),
+                                             RealScalar(-0.0761204674887130),
+                                             RealScalar(-0.0192147195967696),
+                                             RealScalar(-0.00481527332780311),
+                                             RealScalar(-0.00120454379482761),
+                                             RealScalar(-3.01181303795779e-04),
+                                             RealScalar(-7.52981608554592e-05),
+                                             RealScalar(-1.88247173988574e-05),
+                                             RealScalar(-4.70619042382852e-06),
+                                             RealScalar(-1.17654829809007e-06),
+                                             RealScalar(-2.94137117780840e-07),
+                                             RealScalar(-7.35342821488550e-08),
+                                             RealScalar(-1.83835707061916e-08),
+                                             RealScalar(-4.59589268710903e-09),
+                                             RealScalar(-1.14897317243732e-09),
+                                             RealScalar(-2.87243293150586e-10),
+                                             RealScalar(-7.18108232902250e-11),
+                                             RealScalar(-1.79527058227174e-11),
+                                             RealScalar(-4.48817645568941e-12),
+                                             RealScalar(-1.12204411392298e-12),
+                                             RealScalar(-2.80511028480785e-13),
+                                             RealScalar(-7.01277571201985e-14),
+                                             RealScalar(-1.75319392800498e-14),
+                                             RealScalar(-4.38298482001247e-15),
+                                             RealScalar(-1.09574620500312e-15),
+                                             RealScalar(-2.73936551250781e-16),
+                                             RealScalar(-6.84841378126949e-17),
+                                             RealScalar(-1.71210344531737e-17),
+                                             RealScalar(-4.28025861329343e-18)};
+
+  // m_minus_sin_2_PI_div_n_LUT[i] = -std::sin(2 * EIGEN_PI / std::pow(2,i));
+  const RealScalar m_minus_sin_2_PI_div_n_LUT[32] = {RealScalar(0.0),
+                                                     RealScalar(0.0),
+                                                     RealScalar(-1.00000000000000e+00),
+                                                     RealScalar(-7.07106781186547e-01),
+                                                     RealScalar(-3.82683432365090e-01),
+                                                     RealScalar(-1.95090322016128e-01),
+                                                     RealScalar(-9.80171403295606e-02),
+                                                     RealScalar(-4.90676743274180e-02),
+                                                     RealScalar(-2.45412285229123e-02),
+                                                     RealScalar(-1.22715382857199e-02),
+                                                     RealScalar(-6.13588464915448e-03),
+                                                     RealScalar(-3.06795676296598e-03),
+                                                     RealScalar(-1.53398018628477e-03),
+                                                     RealScalar(-7.66990318742704e-04),
+                                                     RealScalar(-3.83495187571396e-04),
+                                                     RealScalar(-1.91747597310703e-04),
+                                                     RealScalar(-9.58737990959773e-05),
+                                                     RealScalar(-4.79368996030669e-05),
+                                                     RealScalar(-2.39684498084182e-05),
+                                                     RealScalar(-1.19842249050697e-05),
+                                                     RealScalar(-5.99211245264243e-06),
+                                                     RealScalar(-2.99605622633466e-06),
+                                                     RealScalar(-1.49802811316901e-06),
+                                                     RealScalar(-7.49014056584716e-07),
+                                                     RealScalar(-3.74507028292384e-07),
+                                                     RealScalar(-1.87253514146195e-07),
+                                                     RealScalar(-9.36267570730981e-08),
+                                                     RealScalar(-4.68133785365491e-08),
+                                                     RealScalar(-2.34066892682746e-08),
+                                                     RealScalar(-1.17033446341373e-08),
+                                                     RealScalar(-5.85167231706864e-09),
+                                                     RealScalar(-2.92583615853432e-09)};
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_FFT_H
diff --git a/contrib/Eigen/src/Tensor/TensorFixedSize.h b/contrib/Eigen/src/Tensor/TensorFixedSize.h
new file mode 100644
index 0000000..ccf9d17
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorFixedSize.h
@@ -0,0 +1,218 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_FIXED_SIZE_H
+#define EIGEN_TENSOR_TENSOR_FIXED_SIZE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief The fixed sized version of the tensor class.
+ *
+ * The fixed sized equivalent of
+ * Eigen::Tensor<float, 3> t(3, 5, 7);
+ * is
+ * Eigen::TensorFixedSize<float, Sizes<3,5,7>> t;
+ */
+template <typename Scalar_, typename Dimensions_, int Options_, typename IndexType>
+class TensorFixedSize : public TensorBase<TensorFixedSize<Scalar_, Dimensions_, Options_, IndexType> > {
+ public:
+  typedef TensorFixedSize<Scalar_, Dimensions_, Options_, IndexType> Self;
+  typedef TensorBase<TensorFixedSize<Scalar_, Dimensions_, Options_, IndexType> > Base;
+  typedef typename Eigen::internal::ref_selector<Self>::type Nested;
+  typedef typename internal::traits<Self>::StorageKind StorageKind;
+  typedef typename internal::traits<Self>::Index Index;
+  typedef Scalar_ Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename Base::CoeffReturnType CoeffReturnType;
+
+  static constexpr int Options = Options_;
+  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
+
+  enum {
+    IsAligned = bool(EIGEN_MAX_STATIC_ALIGN_BYTES >= Aligned),
+    PacketAccess = (internal::packet_traits<Scalar>::size > 1),
+    BlockAccess = false,
+    PreferBlockAccess = false,
+    CoordAccess = true,
+    RawAccess = true
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  typedef Dimensions_ Dimensions;
+  static constexpr std::size_t NumIndices = Dimensions::count;
+
+ protected:
+  TensorStorage<Scalar, Dimensions, Options> m_storage;
+
+ public:
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return NumIndices; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(std::size_t n) const { return m_storage.dimensions()[n]; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions dimensions() const { return m_storage.dimensions(); }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_storage.size(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar* data() { return m_storage.data(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_storage.data(); }
+
+  // This makes EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
+  // work, because that uses base().coeffRef() - and we don't yet
+  // implement a similar class hierarchy
+  inline Self& base() { return *this; }
+  inline const Self& base() const { return *this; }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index firstIndex, IndexTypes... otherIndices) const {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return coeff(array<Index, NumIndices>{{firstIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(const array<Index, NumIndices>& indices) const {
+    eigen_internal_assert(checkIndexRange(indices));
+    return m_storage.data()[linearizedIndex(indices)];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const {
+    eigen_internal_assert(index >= 0 && index < size());
+    return m_storage.data()[index];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff() const {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return m_storage.data()[0];
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices) {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return coeffRef(array<Index, NumIndices>{{firstIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) {
+    eigen_internal_assert(checkIndexRange(indices));
+    return m_storage.data()[linearizedIndex(indices)];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
+    eigen_internal_assert(index >= 0 && index < size());
+    return m_storage.data()[index];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef() {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return m_storage.data()[0];
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index firstIndex, IndexTypes... otherIndices) const {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return this->operator()(array<Index, NumIndices>{{firstIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(const array<Index, NumIndices>& indices) const {
+    eigen_assert(checkIndexRange(indices));
+    return coeff(indices);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index index) const {
+    eigen_internal_assert(index >= 0 && index < size());
+    return coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()() const {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return coeff();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator[](Index index) const {
+    // The bracket operator is only for vectors, use the parenthesis operator instead.
+    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return coeff(index);
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index firstIndex, IndexTypes... otherIndices) {
+    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    return operator()(array<Index, NumIndices>{{firstIndex, static_cast<Index>(otherIndices)...}});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(const array<Index, NumIndices>& indices) {
+    eigen_assert(checkIndexRange(indices));
+    return coeffRef(indices);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index index) {
+    eigen_assert(index >= 0 && index < size());
+    return coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()() {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return coeffRef();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator[](Index index) {
+    // The bracket operator is only for vectors, use the parenthesis operator instead.
+    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    return coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize() : m_storage() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(Self&& other) : m_storage(other.m_storage) {}
+
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
+    typedef TensorAssignOp<TensorFixedSize, const OtherDerived> Assign;
+    Assign assign(*this, other.derived());
+    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+  }
+  template <typename OtherDerived>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(const TensorBase<OtherDerived, WriteAccessors>& other) {
+    typedef TensorAssignOp<TensorFixedSize, const OtherDerived> Assign;
+    Assign assign(*this, other.derived());
+    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
+  }
+
+  // FIXME: check that the dimensions of other match the dimensions of *this.
+  // Unfortunately this isn't possible yet when the rhs is an expression.
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorFixedSize)
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool checkIndexRange(const array<Index, NumIndices>& /*indices*/) const {
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index linearizedIndex(const array<Index, NumIndices>& indices) const {
+    EIGEN_IF_CONSTEXPR (Options & RowMajor) {
+      return internal::convert_index<Index>(m_storage.dimensions().IndexOfRowMajor(indices));
+    } else {
+      return internal::convert_index<Index>(m_storage.dimensions().IndexOfColMajor(indices));
+    }
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_FIXED_SIZE_H
diff --git a/contrib/Eigen/src/Tensor/TensorForcedEval.h b/contrib/Eigen/src/Tensor/TensorForcedEval.h
new file mode 100644
index 0000000..0594536
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorForcedEval.h
@@ -0,0 +1,235 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_FORCED_EVAL_H
+#define EIGEN_TENSOR_TENSOR_FORCED_EVAL_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+#include <memory>
+
+namespace Eigen {
+
+namespace internal {
+template <typename XprType>
+struct traits<TensorForcedEvalOp<XprType>> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename traits<XprType>::StorageKind StorageKind;
+  typedef typename traits<XprType>::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+
+  enum { Flags = 0 };
+};
+
+template <typename XprType>
+struct eval<TensorForcedEvalOp<XprType>, Eigen::Dense> {
+  typedef const TensorForcedEvalOp<XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor forced evaluation class.
+ */
+template <typename XprType>
+class TensorForcedEvalOp : public TensorBase<TensorForcedEvalOp<XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorForcedEvalOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorForcedEvalOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorForcedEvalOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorForcedEvalOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorForcedEvalOp(const XprType& expr) : m_xpr(expr) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+};
+
+namespace internal {
+// Returns true iff it actually placement-new'd any elements (so cleanup
+// knows whether destructors must be run — see bug #1530).
+template <typename Device, typename CoeffReturnType>
+struct non_integral_type_placement_new {
+  template <typename StorageType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(Index numValues, StorageType m_buffer) const {
+    EIGEN_IF_CONSTEXPR (NumTraits<CoeffReturnType>::RequireInitialization) {
+      default_construct_elements_of_array(m_buffer, numValues);
+      return true;
+    }
+    return false;
+  }
+};
+
+// SYCL does not support non-integral types
+// having new (m_buffer + i) CoeffReturnType() causes the following compiler error for SYCL Devices
+// no matching function for call to 'operator new'
+template <typename CoeffReturnType>
+struct non_integral_type_placement_new<Eigen::SyclDevice, CoeffReturnType> {
+  template <typename StorageType>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(Index, StorageType) const {
+    return false;
+  }
+};
+}  // end namespace internal
+
+template <typename Device>
+class DeviceTempPointerHolder {
+ public:
+  DeviceTempPointerHolder(const Device& device, size_t size)
+      : device_(device), size_(size), ptr_(device.allocate_temp(size)) {}
+
+  ~DeviceTempPointerHolder() {
+    device_.deallocate_temp(ptr_);
+    size_ = 0;
+    ptr_ = nullptr;
+  }
+
+  void* ptr() { return ptr_; }
+
+ private:
+  Device device_;
+  size_t size_;
+  void* ptr_;
+};
+
+template <typename ArgType_, typename Device>
+struct TensorEvaluator<const TensorForcedEvalOp<ArgType_>, Device> {
+  typedef const internal::remove_all_t<ArgType_> ArgType;
+  typedef TensorForcedEvalOp<ArgType> XprType;
+  typedef typename ArgType::Scalar Scalar;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  typedef typename XprType::Index Index;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  enum {
+    IsAligned = true,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = internal::is_arithmetic<CoeffReturnType>::value,
+    PreferBlockAccess = false,
+    RawAccess = true
+  };
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  static constexpr int NumDims = internal::traits<ArgType>::NumDimensions;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device),
+        m_op(op.expression()),
+        m_device(device),
+        m_buffer_holder(nullptr),
+        m_buffer(nullptr),
+        m_placement_constructed(false) {}
+
+  ~TensorEvaluator() { cleanup(); }
+
+  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_impl.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    const Index numValues = internal::array_prod(m_impl.dimensions());
+    m_buffer_holder = std::make_shared<DeviceTempPointerHolder<Device>>(m_device, numValues * sizeof(CoeffReturnType));
+    m_buffer = static_cast<EvaluatorPointerType>(m_buffer_holder->ptr());
+
+    m_placement_constructed = internal::non_integral_type_placement_new<Device, CoeffReturnType>()(numValues, m_buffer);
+
+    typedef TensorEvalToOp<const std::remove_const_t<ArgType>> EvalTo;
+    EvalTo evalToTmp(m_device.get(m_buffer), m_op);
+
+    internal::TensorExecutor<const EvalTo, std::remove_const_t<Device>,
+                             /*Vectorizable=*/internal::IsVectorizable<Device, const ArgType>::value,
+                             /*Tiling=*/internal::IsTileable<Device, const ArgType>::value>::run(evalToTmp, m_device);
+
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    const Index numValues = internal::array_prod(m_impl.dimensions());
+    m_buffer_holder = std::make_shared<DeviceTempPointerHolder<Device>>(m_device, numValues * sizeof(CoeffReturnType));
+    m_buffer = static_cast<EvaluatorPointerType>(m_buffer_holder->ptr());
+
+    typedef TensorEvalToOp<const std::remove_const_t<ArgType>> EvalTo;
+    EvalTo evalToTmp(m_device.get(m_buffer), m_op);
+
+    auto on_done = std::bind([](EvalSubExprsCallback done_) { done_(true); }, std::move(done));
+    internal::TensorAsyncExecutor<
+        const EvalTo, std::remove_const_t<Device>, decltype(on_done),
+        /*Vectorizable=*/internal::IsVectorizable<Device, const ArgType>::value,
+        /*Tiling=*/internal::IsTileable<Device, const ArgType>::value>::runAsync(evalToTmp, m_device,
+                                                                                 std::move(on_done));
+  }
+#endif
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    if (m_placement_constructed) {
+      internal::destruct_elements_of_array(m_buffer, internal::array_prod(m_impl.dimensions()));
+      m_placement_constructed = false;
+    }
+    m_buffer_holder = nullptr;
+    m_buffer = nullptr;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_buffer[index]; }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_buffer + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_buffer != nullptr);
+    return TensorBlock::materialize(m_buffer, m_impl.dimensions(), desc, scratch);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EvaluatorPointerType data() const { return m_buffer; }
+
+ private:
+  TensorEvaluator<ArgType, Device> m_impl;
+  const ArgType m_op;
+  const Device EIGEN_DEVICE_REF m_device;
+  std::shared_ptr<DeviceTempPointerHolder<Device>> m_buffer_holder;
+  EvaluatorPointerType m_buffer;  // Cached copy of the value stored in m_buffer_holder.
+  bool m_placement_constructed;   // See bug #1530.
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_FORCED_EVAL_H
diff --git a/contrib/Eigen/src/Tensor/TensorForwardDeclarations.h b/contrib/Eigen/src/Tensor/TensorForwardDeclarations.h
new file mode 100644
index 0000000..ec102c8
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorForwardDeclarations.h
@@ -0,0 +1,216 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_FORWARD_DECLARATIONS_H
+#define EIGEN_TENSOR_TENSOR_FORWARD_DECLARATIONS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+// MakePointer class is used as a container of the address space of the pointer
+// on the host and on the device. From the host side it generates the T* pointer
+// and when EIGEN_USE_SYCL is used it constructs a buffer with a map_allocator to
+// T* m_data on the host. It is always called on the device.
+// Specialisation of MakePointer class for creating the sycl buffer with
+// map_allocator.
+template <typename T>
+struct MakePointer {
+  typedef T* Type;
+  typedef const T* ConstType;
+};
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* constCast(const T* data) {
+  return const_cast<T*>(data);
+}
+
+// The StorageMemory class is a container of the device specific pointer
+// used for referring to a Pointer on TensorEvaluator class. While the TensorExpression
+// is a device-agnostic type and need MakePointer class for type conversion,
+// the TensorEvaluator class can be specialized for a device, hence it is possible
+// to construct different types of temporary storage memory in TensorEvaluator
+// for different devices by specializing the following StorageMemory class.
+template <typename T, typename device>
+struct StorageMemory : MakePointer<T> {};
+
+namespace internal {
+template <typename A, typename B>
+struct Pointer_type_promotion {
+  static constexpr bool val = false;
+};
+template <typename A>
+struct Pointer_type_promotion<A, A> {
+  static constexpr bool val = true;
+};
+template <typename A, typename B>
+struct TypeConversion {
+  typedef A* type;
+};
+}  // namespace internal
+
+template <typename PlainObjectType, int Options_ = Unaligned, template <class> class MakePointer_ = MakePointer>
+class TensorMap;
+template <typename Scalar_, int NumIndices_, int Options_ = 0, typename IndexType = DenseIndex>
+class Tensor;
+template <typename Scalar_, typename Dimensions, int Options_ = 0, typename IndexType = DenseIndex>
+class TensorFixedSize;
+template <typename PlainObjectType>
+class TensorRef;
+template <typename Derived, int AccessLevel>
+class TensorBase;
+
+template <typename NullaryOp, typename PlainObjectType>
+class TensorCwiseNullaryOp;
+template <typename UnaryOp, typename XprType>
+class TensorCwiseUnaryOp;
+template <typename BinaryOp, typename LeftXprType, typename RightXprType>
+class TensorCwiseBinaryOp;
+template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
+class TensorCwiseTernaryOp;
+template <typename IfXprType, typename ThenXprType, typename ElseXprType>
+class TensorSelectOp;
+template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_ = MakePointer>
+class TensorReductionOp;
+template <typename XprType>
+class TensorIndexPairOp;
+template <typename ReduceOp, typename Dims, typename XprType>
+class TensorPairReducerOp;
+template <typename Axis, typename LeftXprType, typename RightXprType>
+class TensorConcatenationOp;
+template <typename Dimensions, typename LeftXprType, typename RightXprType, typename OutputKernelType>
+class TensorContractionOp;
+template <typename TargetType, typename XprType>
+class TensorConversionOp;
+template <typename Dimensions, typename InputXprType, typename KernelXprType>
+class TensorConvolutionOp;
+template <typename FFT, typename XprType, int FFTDataType, int FFTDirection>
+class TensorFFTOp;
+template <typename PatchDim, typename XprType>
+class TensorPatchOp;
+template <DenseIndex Rows, DenseIndex Cols, typename XprType>
+class TensorImagePatchOp;
+template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
+class TensorVolumePatchOp;
+template <typename Broadcast, typename XprType>
+class TensorBroadcastingOp;
+template <DenseIndex DimId, typename XprType>
+class TensorChippingOp;
+template <typename NewDimensions, typename XprType>
+class TensorReshapingOp;
+template <typename XprType>
+class TensorLayoutSwapOp;
+template <typename StartIndices, typename Sizes, typename XprType>
+class TensorSlicingOp;
+template <typename ReverseDimensions, typename XprType>
+class TensorReverseOp;
+template <typename Rolls, typename XprType>
+class TensorRollOp;
+template <typename PaddingDimensions, typename XprType>
+class TensorPaddingOp;
+template <typename Shuffle, typename XprType>
+class TensorShufflingOp;
+template <typename Strides, typename XprType>
+class TensorStridingOp;
+template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
+class TensorStridingSlicingOp;
+template <typename Strides, typename XprType>
+class TensorInflationOp;
+template <typename Generator, typename XprType>
+class TensorGeneratorOp;
+template <typename LeftXprType, typename RightXprType>
+class TensorAssignOp;
+template <typename Op, typename XprType>
+class TensorScanOp;
+template <typename Dims, typename XprType>
+class TensorTraceOp;
+
+template <typename CustomUnaryFunc, typename XprType>
+class TensorCustomUnaryOp;
+template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
+class TensorCustomBinaryOp;
+
+template <typename XprType, template <class> class MakePointer_ = MakePointer>
+class TensorEvalToOp;
+template <typename XprType>
+class TensorForcedEvalOp;
+
+template <typename ExpressionType, typename DeviceType>
+class TensorDevice;
+template <typename ExpressionType, typename DeviceType, typename DoneCallback>
+class TensorAsyncDevice;
+template <typename Derived, typename Device>
+struct TensorEvaluator;
+
+struct NoOpOutputKernel;
+
+struct DefaultDevice;
+struct ThreadPoolDevice;
+struct GpuDevice;
+struct SyclDevice;
+
+#ifdef EIGEN_USE_SYCL
+namespace TensorSycl {
+namespace internal {
+template <typename Evaluator, typename Op>
+class GenericNondeterministicReducer;
+}
+}  // namespace TensorSycl
+#endif
+
+enum FFTResultType { RealPart = 0, ImagPart = 1, BothParts = 2 };
+
+enum FFTDirection { FFT_FORWARD = 0, FFT_REVERSE = 1 };
+
+namespace internal {
+
+template <typename Device, typename Expression>
+struct IsVectorizable {
+  static constexpr bool value = TensorEvaluator<Expression, Device>::PacketAccess;
+};
+
+template <typename Expression>
+struct IsVectorizable<GpuDevice, Expression> {
+  static constexpr bool value =
+      TensorEvaluator<Expression, GpuDevice>::PacketAccess && TensorEvaluator<Expression, GpuDevice>::IsAligned;
+};
+
+// Tiled evaluation strategy.
+enum TiledEvaluation {
+  Off = 0,  // tiled evaluation is not supported
+  On = 1,   // still work in progress (see TensorBlock.h)
+};
+
+template <typename Device, typename Expression>
+struct IsTileable {
+  // Check that block evaluation is supported and it's a preferred option (at
+  // least one sub-expression has much faster block evaluation, e.g.
+  // broadcasting).
+  static constexpr bool BlockAccess =
+      TensorEvaluator<Expression, Device>::BlockAccess && TensorEvaluator<Expression, Device>::PreferBlockAccess;
+
+  static constexpr TiledEvaluation value = BlockAccess ? TiledEvaluation::On : TiledEvaluation::Off;
+};
+
+template <typename Expression, typename Device, bool Vectorizable = IsVectorizable<Device, Expression>::value,
+          TiledEvaluation Tiling = IsTileable<Device, Expression>::value>
+class TensorExecutor;
+
+template <typename Expression, typename Device, typename DoneCallback,
+          bool Vectorizable = IsVectorizable<Device, Expression>::value,
+          TiledEvaluation Tiling = IsTileable<Device, Expression>::value>
+class TensorAsyncExecutor;
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_FORWARD_DECLARATIONS_H
diff --git a/contrib/Eigen/src/Tensor/TensorFunctors.h b/contrib/Eigen/src/Tensor/TensorFunctors.h
new file mode 100644
index 0000000..fe7adc7
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorFunctors.h
@@ -0,0 +1,455 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_FUNCTORS_H
+#define EIGEN_TENSOR_TENSOR_FUNCTORS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+/** \internal
+ * \brief Template functor to compute the modulo between an array and a scalar.
+ */
+template <typename Scalar>
+struct scalar_mod_op {
+  EIGEN_DEVICE_FUNC scalar_mod_op(const Scalar& divisor) : m_divisor(divisor) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const { return a % m_divisor; }
+  const Scalar m_divisor;
+};
+template <typename Scalar>
+struct functor_traits<scalar_mod_op<Scalar>> {
+  enum { Cost = scalar_div_cost<Scalar, false>::value, PacketAccess = false };
+};
+
+/** \internal
+ * \brief Template functor to compute the modulo between 2 arrays.
+ */
+template <typename Scalar>
+struct scalar_mod2_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const { return a % b; }
+};
+template <typename Scalar>
+struct functor_traits<scalar_mod2_op<Scalar>> {
+  enum { Cost = scalar_div_cost<Scalar, false>::value, PacketAccess = false };
+};
+
+template <typename Scalar>
+struct scalar_fmod_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const {
+    return numext::fmod(a, b);
+  }
+};
+template <typename Scalar>
+struct functor_traits<scalar_fmod_op<Scalar>> {
+  enum {
+    Cost = 13,  // Reciprocal throughput of FPREM on Haswell.
+    PacketAccess = false
+  };
+};
+
+template <typename Reducer, typename Device>
+struct reducer_traits {
+  enum { Cost = 1, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
+};
+
+// Marks reducers whose partial accumulators may be accumulated independently and combined in any
+// order. That requires reduce(value, accum) to be a pure combine -- so a partial accumulator may
+// be fed back through it -- and that combine to be associative and commutative with initialize()
+// as its identity, since the accumulators receive interleaved, not contiguous, operands.
+//
+// Neither property is implied by PacketAccess: a reducer may support packets yet transform each
+// value it accepts (e.g. a sum-of-squares reducer), in which case merging through reduce() is
+// wrong; and a pure combine may still be order-dependent (e.g. composition). Conservative
+// default; built-in combines opt in below, gated on scalar categories whose semantics Eigen
+// controls.
+template <typename Reducer>
+struct reducer_can_reorder_accumulators : std::false_type {};
+
+// Standard reduction functors
+template <typename T>
+struct SumReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
+    internal::scalar_sum_op<T> sum_op;
+    *accum = sum_op(*accum, t);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
+    (*accum) = padd<Packet>(*accum, p);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    internal::scalar_cast_op<int, T> conv;
+    return conv(0);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return pset1<Packet>(initialize());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
+    return vaccum;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
+    internal::scalar_sum_op<T> sum_op;
+    return sum_op(saccum, predux(vaccum));
+  }
+};
+
+template <typename T, typename Device>
+struct reducer_traits<SumReducer<T>, Device> {
+  enum {
+    Cost = NumTraits<T>::AddCost,
+    PacketAccess = PacketType<T, Device>::HasAdd,
+    IsStateful = false,
+    IsExactlyAssociative = NumTraits<T>::IsInteger
+  };
+};
+
+template <typename T>
+struct MeanReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE MeanReducer() = default;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) {
+    internal::scalar_sum_op<T> sum_op;
+    *accum = sum_op(*accum, t);
+    scalarCount_++;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) {
+    (*accum) = padd<Packet>(*accum, p);
+    packetCount_++;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    internal::scalar_cast_op<int, T> conv;
+    return conv(0);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return pset1<Packet>(initialize());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const {
+    internal::scalar_quotient_op<T> quotient_op;
+    return quotient_op(accum, T(scalarCount_));
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
+    return pdiv(vaccum, pset1<Packet>(T(packetCount_)));
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
+    internal::scalar_sum_op<T> sum_op;
+    internal::scalar_quotient_op<T> quotient_op;
+    return quotient_op(sum_op(saccum, predux(vaccum)), T(scalarCount_ + packetCount_ * unpacket_traits<Packet>::size));
+  }
+
+ protected:
+  DenseIndex scalarCount_ = 0;
+  DenseIndex packetCount_ = 0;
+};
+
+template <typename T, typename Device>
+struct reducer_traits<MeanReducer<T>, Device> {
+  enum {
+    Cost = NumTraits<T>::AddCost,
+    PacketAccess = PacketType<T, Device>::HasAdd && PacketType<T, Device>::HasDiv && !NumTraits<T>::IsInteger,
+    IsStateful = true,
+    IsExactlyAssociative = NumTraits<T>::IsInteger
+  };
+};
+
+template <typename T, bool IsMax = true, bool IsInteger = true>
+struct MinMaxBottomValue {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return Eigen::NumTraits<T>::lowest(); }
+};
+template <typename T>
+struct MinMaxBottomValue<T, true, false> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return -Eigen::NumTraits<T>::infinity(); }
+};
+template <typename T>
+struct MinMaxBottomValue<T, false, true> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return Eigen::NumTraits<T>::highest(); }
+};
+template <typename T>
+struct MinMaxBottomValue<T, false, false> {
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return Eigen::NumTraits<T>::infinity(); }
+};
+
+template <typename T, int NaNPropagation = PropagateFast>
+struct MaxReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
+    scalar_max_op<T, T, NaNPropagation> op;
+    *accum = op(t, *accum);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
+    scalar_max_op<T, T, NaNPropagation> op;
+    (*accum) = op.packetOp(*accum, p);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    return MinMaxBottomValue<T, /*IsMax=*/true, Eigen::NumTraits<T>::IsInteger>::bottom_value();
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return pset1<Packet>(initialize());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
+    return vaccum;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
+    scalar_max_op<T, T, NaNPropagation> op;
+    return op(saccum, op.predux(vaccum));
+  }
+};
+
+template <typename T, typename Device, int NaNPropagation>
+struct reducer_traits<MaxReducer<T, NaNPropagation>, Device> {
+  enum {
+    Cost = NumTraits<T>::AddCost,
+    PacketAccess = PacketType<T, Device>::HasMax,
+    IsStateful = false,
+    IsExactlyAssociative = (NaNPropagation != PropagateFast)
+  };
+};
+
+template <typename T, int NaNPropagation = PropagateFast>
+struct MinReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
+    scalar_min_op<T, T, NaNPropagation> op;
+    *accum = op(t, *accum);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
+    scalar_min_op<T, T, NaNPropagation> op;
+    (*accum) = op.packetOp(*accum, p);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    return MinMaxBottomValue<T, /*IsMax=*/false, Eigen::NumTraits<T>::IsInteger>::bottom_value();
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return pset1<Packet>(initialize());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
+    return vaccum;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
+    scalar_min_op<T, T, NaNPropagation> op;
+    return op(saccum, op.predux(vaccum));
+  }
+};
+
+template <typename T, typename Device, int NaNPropagation>
+struct reducer_traits<MinReducer<T, NaNPropagation>, Device> {
+  enum {
+    Cost = NumTraits<T>::AddCost,
+    PacketAccess = PacketType<T, Device>::HasMin,
+    IsStateful = false,
+    IsExactlyAssociative = (NaNPropagation != PropagateFast)
+  };
+};
+
+template <typename T>
+struct ProdReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
+    internal::scalar_product_op<T> prod_op;
+    (*accum) = prod_op(*accum, t);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
+    (*accum) = pmul<Packet>(*accum, p);
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    internal::scalar_cast_op<int, T> conv;
+    return conv(1);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
+    return pset1<Packet>(initialize());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
+    return vaccum;
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
+    internal::scalar_product_op<T> prod_op;
+    return prod_op(saccum, predux_mul(vaccum));
+  }
+};
+
+template <typename T, typename Device>
+struct reducer_traits<ProdReducer<T>, Device> {
+  enum {
+    Cost = NumTraits<T>::MulCost,
+    PacketAccess = PacketType<T, Device>::HasMul,
+    IsStateful = false,
+    IsExactlyAssociative = true
+  };
+};
+
+// Inputs have already been evaluated when reduce() is called; eager bitwise operations keep scalar reduction loops
+// branch-free.
+struct AndReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(bool t, bool* accum) const { *accum = *accum & t; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool initialize() const { return true; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool finalize(bool accum) const { return accum; }
+};
+
+template <typename Device>
+struct reducer_traits<AndReducer, Device> {
+  enum { Cost = 1, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
+};
+
+struct OrReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(bool t, bool* accum) const { *accum = *accum | t; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool initialize() const { return false; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool finalize(bool accum) const { return accum; }
+};
+
+template <typename Device>
+struct reducer_traits<OrReducer, Device> {
+  enum { Cost = 1, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
+};
+
+// Sum/prod reorder for scalars whose + and * commute; min/max additionally exclude custom scalars,
+// whose generic std::min/std::max keep the first operand when values compare equivalent.
+template <typename T>
+struct reducer_can_reorder_accumulators<SumReducer<T>>
+    : bool_constant<internal::is_arithmetic<T>::value || NumTraits<T>::IsComplex> {};
+template <typename T>
+struct reducer_can_reorder_accumulators<ProdReducer<T>>
+    : bool_constant<internal::is_arithmetic<T>::value || NumTraits<T>::IsComplex> {};
+template <typename T, int NaNPropagation>
+struct reducer_can_reorder_accumulators<MinReducer<T, NaNPropagation>> : internal::is_arithmetic<T> {};
+template <typename T, int NaNPropagation>
+struct reducer_can_reorder_accumulators<MaxReducer<T, NaNPropagation>> : internal::is_arithmetic<T> {};
+template <>
+struct reducer_can_reorder_accumulators<AndReducer> : std::true_type {};
+template <>
+struct reducer_can_reorder_accumulators<OrReducer> : std::true_type {};
+
+// Argmin/Argmax reducers.  Returns the first occurrence if multiple locations
+// contain the same min/max value.
+template <typename T>
+struct ArgMaxPairReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
+    if (t.second < accum->second) {
+      return;
+    } else if (t.second > accum->second || accum->first > t.first) {
+      *accum = t;
+    }
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    return T(0, NumTraits<typename T::second_type>::lowest());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T& accum) const { return accum; }
+};
+
+template <typename T, typename Device>
+struct reducer_traits<ArgMaxPairReducer<T>, Device> {
+  enum { Cost = NumTraits<T>::AddCost, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
+};
+
+template <typename T>
+struct ArgMinPairReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T& t, T* accum) const {
+    if (t.second > accum->second) {
+      return;
+    } else if (t.second < accum->second || accum->first > t.first) {
+      *accum = t;
+    }
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
+    return T(0, NumTraits<typename T::second_type>::highest());
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T& accum) const { return accum; }
+};
+
+template <typename T, typename Device>
+struct reducer_traits<ArgMinPairReducer<T>, Device> {
+  enum { Cost = NumTraits<T>::AddCost, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
+};
+
+template <typename T, typename Index, size_t NumDims>
+class GaussianGenerator {
+ public:
+  static constexpr bool PacketAccess = false;
+
+  EIGEN_DEVICE_FUNC GaussianGenerator(const array<T, NumDims>& means, const array<T, NumDims>& std_devs)
+      : m_means(means) {
+    EIGEN_UNROLL_LOOP
+    for (size_t i = 0; i < NumDims; ++i) {
+      m_two_sigmas[i] = std_devs[i] * std_devs[i] * 2;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC T operator()(const array<Index, NumDims>& coordinates) const {
+    T tmp = T(0);
+    EIGEN_UNROLL_LOOP
+    for (size_t i = 0; i < NumDims; ++i) {
+      T offset = coordinates[i] - m_means[i];
+      tmp += offset * offset / m_two_sigmas[i];
+    }
+    return numext::exp(-tmp);
+  }
+
+ private:
+  array<T, NumDims> m_means;
+  array<T, NumDims> m_two_sigmas;
+};
+
+template <typename T, typename Index, size_t NumDims>
+struct functor_traits<GaussianGenerator<T, Index, NumDims>> {
+  enum {
+    Cost =
+        NumDims * (2 * NumTraits<T>::AddCost + NumTraits<T>::MulCost + functor_traits<scalar_quotient_op<T, T>>::Cost) +
+        functor_traits<scalar_exp_op<T>>::Cost,
+    PacketAccess = GaussianGenerator<T, Index, NumDims>::PacketAccess
+  };
+};
+
+template <typename Scalar>
+struct scalar_clamp_op {
+  EIGEN_DEVICE_FUNC inline scalar_clamp_op(const Scalar& _min, const Scalar& _max) : m_min(_min), m_max(_max) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
+    return numext::mini(numext::maxi(x, m_min), m_max);
+  }
+  template <typename Packet>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& x) const {
+    return internal::pmin(internal::pmax(x, pset1<Packet>(m_min)), pset1<Packet>(m_max));
+  }
+  const Scalar m_min;
+  const Scalar m_max;
+};
+template <typename Scalar>
+struct functor_traits<scalar_clamp_op<Scalar>> {
+  enum {
+    Cost = 2 * NumTraits<Scalar>::AddCost,
+    PacketAccess = (packet_traits<Scalar>::HasMin && packet_traits<Scalar>::HasMax)
+  };
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_FUNCTORS_H
diff --git a/contrib/Eigen/src/Tensor/TensorGenerator.h b/contrib/Eigen/src/Tensor/TensorGenerator.h
new file mode 100644
index 0000000..3928280
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorGenerator.h
@@ -0,0 +1,264 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_GENERATOR_H
+#define EIGEN_TENSOR_TENSOR_GENERATOR_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Generator, typename XprType>
+struct traits<TensorGeneratorOp<Generator, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename Generator, typename XprType>
+struct eval<TensorGeneratorOp<Generator, XprType>, Eigen::Dense> {
+  typedef const TensorGeneratorOp<Generator, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor generator class.
+ */
+template <typename Generator, typename XprType>
+class TensorGeneratorOp : public TensorBase<TensorGeneratorOp<Generator, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorGeneratorOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorGeneratorOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorGeneratorOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorGeneratorOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorGeneratorOp(const XprType& expr, const Generator& generator)
+      : m_xpr(expr), m_generator(generator) {}
+
+  EIGEN_DEVICE_FUNC const Generator& generator() const { return m_generator; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Generator m_generator;
+};
+
+// Eval as rvalue
+template <typename Generator, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorGeneratorOp<Generator, ArgType>, Device> {
+  typedef TensorGeneratorOp<Generator, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
+  static constexpr int NumDims = internal::array_size<Dimensions>::value;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = true,
+    PreferBlockAccess = true,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  typedef internal::TensorIntDivisor<Index> IndexDivisor;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_device(device), m_generator(op.generator()) {
+    TensorEvaluator<ArgType, Device> argImpl(op.expression(), device);
+    m_dimensions = argImpl.dimensions();
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_strides[0] = 1;
+      EIGEN_UNROLL_LOOP
+      for (int i = 1; i < NumDims; ++i) {
+        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
+        if (m_strides[i] != 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
+      }
+    } else {
+      m_strides[NumDims - 1] = 1;
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
+        if (m_strides[i] != 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) { return true; }
+  EIGEN_STRONG_INLINE void cleanup() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    array<Index, NumDims> coords;
+    extract_coordinates(index, coords);
+    return m_generator(coords);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    const int packetSize = PacketType<CoeffReturnType, Device>::size;
+    eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
+
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[packetSize];
+    for (int i = 0; i < packetSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.firstLevelCacheSize();
+    // TODO(ezhulenev): Generator should have a cost.
+    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size);
+  }
+
+  struct BlockIteratorState {
+    Index stride;
+    Index span;
+    Index size;
+    Index count;
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    static constexpr bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    // Compute spatial coordinates for the first block element.
+    array<Index, NumDims> coords;
+    extract_coordinates(desc.offset(), coords);
+    array<Index, NumDims> initial_coords = coords;
+
+    // Offset in the output block buffer.
+    Index offset = 0;
+
+    // Initialize output block iterator state. Dimensions in this array are
+    // always in inner_most -> outer_most order (col major layout).
+    array<BlockIteratorState, NumDims> it;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = is_col_major ? i : NumDims - 1 - i;
+      it[i].size = desc.dimension(dim);
+      it[i].stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].stride);
+      it[i].span = it[i].stride * (it[i].size - 1);
+      it[i].count = 0;
+    }
+    eigen_assert(it[0].stride == 1);
+
+    // Prepare storage for the materialized generator result.
+    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+
+    CoeffReturnType* block_buffer = block_storage.data();
+
+    static constexpr int packet_size = PacketType<CoeffReturnType, Device>::size;
+
+    static constexpr int inner_dim = is_col_major ? 0 : NumDims - 1;
+    const Index inner_dim_size = it[0].size;
+    const Index inner_dim_vectorized = inner_dim_size - packet_size;
+
+    while (it[NumDims - 1].count < it[NumDims - 1].size) {
+      Index i = 0;
+      // Generate data for the vectorized part of the inner-most dimension.
+      for (; i <= inner_dim_vectorized; i += packet_size) {
+        for (Index j = 0; j < packet_size; ++j) {
+          array<Index, NumDims> j_coords = coords;  // Break loop dependence.
+          j_coords[inner_dim] += j;
+          *(block_buffer + offset + i + j) = m_generator(j_coords);
+        }
+        coords[inner_dim] += packet_size;
+      }
+      // Finalize non-vectorized part of the inner-most dimension.
+      for (; i < inner_dim_size; ++i) {
+        *(block_buffer + offset + i) = m_generator(coords);
+        coords[inner_dim]++;
+      }
+      coords[inner_dim] = initial_coords[inner_dim];
+
+      // For the 1d tensor we need to generate only one inner-most dimension.
+      EIGEN_IF_CONSTEXPR (NumDims == 1) break;
+
+      // Update offset.
+      for (i = 1; i < NumDims; ++i) {
+        if (++it[i].count < it[i].size) {
+          offset += it[i].stride;
+          coords[is_col_major ? i : NumDims - 1 - i]++;
+          break;
+        }
+        if (i != NumDims - 1) it[i].count = 0;
+        coords[is_col_major ? i : NumDims - 1 - i] = initial_coords[is_col_major ? i : NumDims - 1 - i];
+        offset -= it[i].span;
+      }
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool) const {
+    // TODO(rmlarsen): This is just a placeholder. Define interface to make
+    // generators return their cost.
+    return TensorOpCost(0, 0, TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>());
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_coordinates(Index index, array<Index, NumDims>& coords) const {
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_fast_strides[i];
+        index -= idx * m_strides[i];
+        coords[i] = idx;
+      }
+      coords[0] = index;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_fast_strides[i];
+        index -= idx * m_strides[i];
+        coords[i] = idx;
+      }
+      coords[NumDims - 1] = index;
+    }
+  }
+
+  const Device EIGEN_DEVICE_REF m_device;
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_strides;
+  array<IndexDivisor, NumDims> m_fast_strides;
+  Generator m_generator;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_GENERATOR_H
diff --git a/contrib/Eigen/src/Tensor/TensorGlobalFunctions.h b/contrib/Eigen/src/Tensor/TensorGlobalFunctions.h
new file mode 100644
index 0000000..6ba80bc
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorGlobalFunctions.h
@@ -0,0 +1,37 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
+#define EIGEN_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \returns an expression of the coefficient-wise betainc(\a x, \a a, \a b) to the given tensors.
+ *
+ * This function computes the regularized incomplete beta function (integral).
+ *
+ */
+template <typename ADerived, typename BDerived, typename XDerived>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>,
+                                                                 const ADerived, const BDerived, const XDerived>
+betainc(const Eigen::TensorBase<ADerived, ReadOnlyAccessors>& a,
+        const Eigen::TensorBase<BDerived, ReadOnlyAccessors>& b,
+        const Eigen::TensorBase<XDerived, ReadOnlyAccessors>& x) {
+  return TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>, const ADerived, const BDerived,
+                              const XDerived>(a.derived(), b.derived(), x.derived(),
+                                              internal::scalar_betainc_op<typename XDerived::Scalar>());
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
diff --git a/contrib/Eigen/src/Tensor/TensorIO.h b/contrib/Eigen/src/Tensor/TensorIO.h
new file mode 100644
index 0000000..55984d6
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorIO.h
@@ -0,0 +1,415 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_IO_H
+#define EIGEN_TENSOR_TENSOR_IO_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+struct TensorIOFormat;
+
+namespace internal {
+template <typename Tensor, std::size_t rank, typename Format, typename EnableIf = void>
+struct TensorPrinter;
+}
+
+template <typename Derived_>
+struct TensorIOFormatBase {
+  using Derived = Derived_;
+  TensorIOFormatBase(const std::vector<std::string>& separator, const std::vector<std::string>& prefix,
+                     const std::vector<std::string>& suffix, int precision = StreamPrecision, int flags = 0,
+                     const std::string& tenPrefix = "", const std::string& tenSuffix = "", const char fill = ' ')
+      : tenPrefix(tenPrefix),
+        tenSuffix(tenSuffix),
+        prefix(prefix),
+        suffix(suffix),
+        separator(separator),
+        fill(fill),
+        precision(precision),
+        flags(flags) {
+    init_spacer();
+  }
+
+  void init_spacer() {
+    if (flags & DontAlignCols) return;
+    spacer.resize(prefix.size());
+    spacer[0] = "";
+    int i = int(tenPrefix.length()) - 1;
+    while (i >= 0 && tenPrefix[i] != '\n') {
+      spacer[0] += ' ';
+      i--;
+    }
+
+    for (std::size_t k = 1; k < prefix.size(); k++) {
+      int j = int(prefix[k].length()) - 1;
+      while (j >= 0 && prefix[k][j] != '\n') {
+        spacer[k] += ' ';
+        j--;
+      }
+    }
+  }
+
+  std::string tenPrefix;
+  std::string tenSuffix;
+  std::vector<std::string> prefix;
+  std::vector<std::string> suffix;
+  std::vector<std::string> separator;
+  char fill;
+  int precision;
+  int flags;
+  std::vector<std::string> spacer{};
+};
+
+struct TensorIOFormatNumpy : public TensorIOFormatBase<TensorIOFormatNumpy> {
+  using Base = TensorIOFormatBase<TensorIOFormatNumpy>;
+  TensorIOFormatNumpy()
+      : Base(/*separator=*/{" ", "\n"}, /*prefix=*/{"", "["}, /*suffix=*/{"", "]"}, /*precision=*/StreamPrecision,
+             /*flags=*/0, /*tenPrefix=*/"[", /*tenSuffix=*/"]") {}
+};
+
+struct TensorIOFormatNative : public TensorIOFormatBase<TensorIOFormatNative> {
+  using Base = TensorIOFormatBase<TensorIOFormatNative>;
+  TensorIOFormatNative()
+      : Base(/*separator=*/{", ", ",\n", "\n"}, /*prefix=*/{"", "{"}, /*suffix=*/{"", "}"},
+             /*precision=*/StreamPrecision, /*flags=*/0, /*tenPrefix=*/"{", /*tenSuffix=*/"}") {}
+};
+
+struct TensorIOFormatPlain : public TensorIOFormatBase<TensorIOFormatPlain> {
+  using Base = TensorIOFormatBase<TensorIOFormatPlain>;
+  TensorIOFormatPlain()
+      : Base(/*separator=*/{" ", "\n", "\n", ""}, /*prefix=*/{""}, /*suffix=*/{""}, /*precision=*/StreamPrecision,
+             /*flags=*/0, /*tenPrefix=*/"", /*tenSuffix=*/"") {}
+};
+
+struct TensorIOFormatLegacy : public TensorIOFormatBase<TensorIOFormatLegacy> {
+  using Base = TensorIOFormatBase<TensorIOFormatLegacy>;
+  TensorIOFormatLegacy()
+      : Base(/*separator=*/{", ", "\n"}, /*prefix=*/{"", "["}, /*suffix=*/{"", "]"}, /*precision=*/StreamPrecision,
+             /*flags=*/0, /*tenPrefix=*/"", /*tenSuffix=*/"") {}
+};
+
+struct TensorIOFormat : public TensorIOFormatBase<TensorIOFormat> {
+  using Base = TensorIOFormatBase<TensorIOFormat>;
+  TensorIOFormat(const std::vector<std::string>& separator, const std::vector<std::string>& prefix,
+                 const std::vector<std::string>& suffix, int precision = StreamPrecision, int flags = 0,
+                 const std::string& tenPrefix = "", const std::string& tenSuffix = "", const char fill = ' ')
+      : Base(separator, prefix, suffix, precision, flags, tenPrefix, tenSuffix, fill) {}
+
+  static inline const TensorIOFormatNumpy Numpy() { return TensorIOFormatNumpy{}; }
+
+  static inline const TensorIOFormatPlain Plain() { return TensorIOFormatPlain{}; }
+
+  static inline const TensorIOFormatNative Native() { return TensorIOFormatNative{}; }
+
+  static inline const TensorIOFormatLegacy Legacy() { return TensorIOFormatLegacy{}; }
+};
+
+template <typename T, int Layout, int rank, typename Format>
+class TensorWithFormat;
+// specialize for Layout=ColMajor, Layout=RowMajor and rank=0.
+template <typename T, int rank, typename Format>
+class TensorWithFormat<T, RowMajor, rank, Format> {
+ public:
+  TensorWithFormat(const T& tensor, const Format& format) : t_tensor(tensor), t_format(format) {}
+
+  friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, RowMajor, rank, Format>& wf) {
+    // Evaluate the expression if needed
+    typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
+    TensorForcedEvalOp<const T> eval = wf.t_tensor.eval();
+    Evaluator tensor(eval, DefaultDevice());
+    tensor.evalSubExprsIfNeeded(nullptr);
+    internal::TensorPrinter<Evaluator, rank, Format>::run(os, tensor, wf.t_format);
+    // Cleanup.
+    tensor.cleanup();
+    return os;
+  }
+
+ protected:
+  T t_tensor;
+  Format t_format;
+};
+
+template <typename T, int rank, typename Format>
+class TensorWithFormat<T, ColMajor, rank, Format> {
+ public:
+  TensorWithFormat(const T& tensor, const Format& format) : t_tensor(tensor), t_format(format) {}
+
+  friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, ColMajor, rank, Format>& wf) {
+    // Switch to RowMajor storage and print afterwards
+    typedef typename T::Index IndexType;
+    std::array<IndexType, rank> shuffle;
+    std::array<IndexType, rank> id;
+    std::iota(id.begin(), id.end(), IndexType(0));
+    std::copy(id.begin(), id.end(), shuffle.rbegin());
+    auto tensor_row_major = wf.t_tensor.swap_layout().shuffle(shuffle);
+
+    // Evaluate the expression if needed
+    typedef TensorEvaluator<const TensorForcedEvalOp<const decltype(tensor_row_major)>, DefaultDevice> Evaluator;
+    TensorForcedEvalOp<const decltype(tensor_row_major)> eval = tensor_row_major.eval();
+    Evaluator tensor(eval, DefaultDevice());
+    tensor.evalSubExprsIfNeeded(nullptr);
+    internal::TensorPrinter<Evaluator, rank, Format>::run(os, tensor, wf.t_format);
+    // Cleanup.
+    tensor.cleanup();
+    return os;
+  }
+
+ protected:
+  T t_tensor;
+  Format t_format;
+};
+
+template <typename T, typename Format>
+class TensorWithFormat<T, ColMajor, 0, Format> {
+ public:
+  TensorWithFormat(const T& tensor, const Format& format) : t_tensor(tensor), t_format(format) {}
+
+  friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, ColMajor, 0, Format>& wf) {
+    // Evaluate the expression if needed
+    typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
+    TensorForcedEvalOp<const T> eval = wf.t_tensor.eval();
+    Evaluator tensor(eval, DefaultDevice());
+    tensor.evalSubExprsIfNeeded(nullptr);
+    internal::TensorPrinter<Evaluator, 0, Format>::run(os, tensor, wf.t_format);
+    // Cleanup.
+    tensor.cleanup();
+    return os;
+  }
+
+ protected:
+  T t_tensor;
+  Format t_format;
+};
+
+namespace internal {
+
+// Default scalar printer.
+template <typename Scalar, typename Format, typename EnableIf = void>
+struct ScalarPrinter {
+  static void run(std::ostream& stream, const Scalar& scalar, const Format&) { stream << scalar; }
+};
+
+template <typename Scalar>
+struct ScalarPrinter<Scalar, TensorIOFormatNumpy, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
+  static void run(std::ostream& stream, const Scalar& scalar, const TensorIOFormatNumpy&) {
+    stream << numext::real(scalar) << "+" << numext::imag(scalar) << "j";
+  }
+};
+
+template <typename Scalar>
+struct ScalarPrinter<Scalar, TensorIOFormatNative, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
+  static void run(std::ostream& stream, const Scalar& scalar, const TensorIOFormatNative&) {
+    stream << "{" << numext::real(scalar) << ", " << numext::imag(scalar) << "}";
+  }
+};
+
+template <typename Tensor, std::size_t rank, typename Format, typename EnableIf>
+struct TensorPrinter {
+  using Scalar = std::remove_const_t<typename Tensor::Scalar>;
+
+  static void run(std::ostream& s, const Tensor& tensor, const Format& fmt) {
+    typedef typename Tensor::Index IndexType;
+
+    eigen_assert(Tensor::Layout == RowMajor);
+    typedef std::conditional_t<std::is_same<Scalar, char>::value || std::is_same<Scalar, unsigned char>::value ||
+                                   std::is_same<Scalar, numext::int8_t>::value ||
+                                   std::is_same<Scalar, numext::uint8_t>::value,
+                               int,
+                               std::conditional_t<std::is_same<Scalar, std::complex<char>>::value ||
+                                                      std::is_same<Scalar, std::complex<unsigned char>>::value ||
+                                                      std::is_same<Scalar, std::complex<numext::int8_t>>::value ||
+                                                      std::is_same<Scalar, std::complex<numext::uint8_t>>::value,
+                                                  std::complex<int>, const Scalar&>>
+        PrintType;
+
+    const IndexType total_size = array_prod(tensor.dimensions());
+
+    std::streamsize explicit_precision;
+    if (fmt.precision == StreamPrecision) {
+      explicit_precision = 0;
+    } else if (fmt.precision == FullPrecision) {
+      EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsInteger) {
+        explicit_precision = 0;
+      } else {
+        explicit_precision = significant_decimals_impl<Scalar>::run();
+      }
+    } else {
+      explicit_precision = fmt.precision;
+    }
+
+    std::streamsize old_precision = 0;
+    if (explicit_precision) old_precision = s.precision(explicit_precision);
+
+    IndexType width = 0;
+    bool align_cols = !(fmt.flags & DontAlignCols);
+    if (align_cols) {
+      // compute the largest width
+      for (IndexType i = 0; i < total_size; i++) {
+        std::stringstream sstr;
+        sstr.copyfmt(s);
+        ScalarPrinter<Scalar, Format>::run(sstr, static_cast<PrintType>(tensor.data()[i]), fmt);
+        width = std::max<IndexType>(width, IndexType(sstr.str().length()));
+      }
+    }
+    s << fmt.tenPrefix;
+    for (IndexType i = 0; i < total_size; i++) {
+      std::array<bool, rank> is_at_end{};
+      std::array<bool, rank> is_at_begin{};
+
+      // is the ith element the end of a coeff (always true), of a row, of a matrix, ...?
+      for (std::size_t k = 0; k < rank; k++) {
+        if ((i + 1) % (std::accumulate(tensor.dimensions().rbegin(), tensor.dimensions().rbegin() + k, 1,
+                                       std::multiplies<IndexType>())) ==
+            0) {
+          is_at_end[k] = true;
+        }
+      }
+
+      // is the ith element the begin of a coeff (always true), of a row, of a matrix, ...?
+      for (std::size_t k = 0; k < rank; k++) {
+        if (i % (std::accumulate(tensor.dimensions().rbegin(), tensor.dimensions().rbegin() + k, 1,
+                                 std::multiplies<IndexType>())) ==
+            0) {
+          is_at_begin[k] = true;
+        }
+      }
+
+      // do we have a line break?
+      bool is_at_begin_after_newline = false;
+      for (std::size_t k = 0; k < rank; k++) {
+        if (is_at_begin[k]) {
+          std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
+          if (fmt.separator[separator_index].find('\n') != std::string::npos) {
+            is_at_begin_after_newline = true;
+          }
+        }
+      }
+
+      bool is_at_end_before_newline = false;
+      for (std::size_t k = 0; k < rank; k++) {
+        if (is_at_end[k]) {
+          std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
+          if (fmt.separator[separator_index].find('\n') != std::string::npos) {
+            is_at_end_before_newline = true;
+          }
+        }
+      }
+
+      std::stringstream suffix, prefix, separator;
+      for (std::size_t k = 0; k < rank; k++) {
+        std::size_t suffix_index = (k < fmt.suffix.size()) ? k : fmt.suffix.size() - 1;
+        if (is_at_end[k]) {
+          suffix << fmt.suffix[suffix_index];
+        }
+      }
+      for (std::size_t k = 0; k < rank; k++) {
+        std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
+        if (is_at_end[k] &&
+            (!is_at_end_before_newline || fmt.separator[separator_index].find('\n') != std::string::npos)) {
+          separator << fmt.separator[separator_index];
+        }
+      }
+      for (std::size_t k = 0; k < rank; k++) {
+        std::size_t spacer_index = (k < fmt.spacer.size()) ? k : fmt.spacer.size() - 1;
+        if (i != 0 && is_at_begin_after_newline && (!is_at_begin[k] || k == 0)) {
+          prefix << fmt.spacer[spacer_index];
+        }
+      }
+      for (int k = rank - 1; k >= 0; k--) {
+        std::size_t prefix_index = (static_cast<std::size_t>(k) < fmt.prefix.size()) ? k : fmt.prefix.size() - 1;
+        if (is_at_begin[k]) {
+          prefix << fmt.prefix[prefix_index];
+        }
+      }
+
+      s << prefix.str();
+      // So we don't mess around with formatting, output scalar to a string stream, and adjust the width/fill manually.
+      std::stringstream sstr;
+      sstr.copyfmt(s);
+      ScalarPrinter<Scalar, Format>::run(sstr, static_cast<PrintType>(tensor.data()[i]), fmt);
+      std::string scalar_str = sstr.str();
+      IndexType scalar_width = scalar_str.length();
+      if (width && scalar_width < width) {
+        std::string filler;
+        for (IndexType j = scalar_width; j < width; ++j) {
+          filler.push_back(fmt.fill);
+        }
+        s << filler;
+      }
+      s << scalar_str;
+      s << suffix.str();
+      if (i < total_size - 1) {
+        s << separator.str();
+      }
+    }
+    s << fmt.tenSuffix;
+    if (explicit_precision) s.precision(old_precision);
+  }
+};
+
+template <typename Tensor, std::size_t rank>
+struct TensorPrinter<Tensor, rank, TensorIOFormatLegacy, std::enable_if_t<rank != 0>> {
+  using Format = TensorIOFormatLegacy;
+  using Scalar = std::remove_const_t<typename Tensor::Scalar>;
+
+  static void run(std::ostream& s, const Tensor& tensor, const Format&) {
+    typedef typename Tensor::Index IndexType;
+    // backwards compatibility case: print tensor after reshaping to matrix of size dim(0) x
+    // (dim(1)*dim(2)*...*dim(rank-1)).
+    const IndexType total_size = internal::array_prod(tensor.dimensions());
+    if (total_size > 0) {
+      const IndexType first_dim = Eigen::internal::array_get<0>(tensor.dimensions());
+      Map<const Array<Scalar, Dynamic, Dynamic, Tensor::Layout>> matrix(tensor.data(), first_dim,
+                                                                        total_size / first_dim);
+      s << matrix;
+      return;
+    }
+  }
+};
+
+template <typename Tensor, typename Format>
+struct TensorPrinter<Tensor, 0, Format> {
+  static void run(std::ostream& s, const Tensor& tensor, const Format& fmt) {
+    using Scalar = std::remove_const_t<typename Tensor::Scalar>;
+
+    std::streamsize explicit_precision;
+    if (fmt.precision == StreamPrecision) {
+      explicit_precision = 0;
+    } else if (fmt.precision == FullPrecision) {
+      EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsInteger) {
+        explicit_precision = 0;
+      } else {
+        explicit_precision = significant_decimals_impl<Scalar>::run();
+      }
+    } else {
+      explicit_precision = fmt.precision;
+    }
+
+    std::streamsize old_precision = 0;
+    if (explicit_precision) old_precision = s.precision(explicit_precision);
+    s << fmt.tenPrefix;
+    ScalarPrinter<Scalar, Format>::run(s, tensor.coeff(0), fmt);
+    s << fmt.tenSuffix;
+    if (explicit_precision) s.precision(old_precision);
+  }
+};
+
+}  // end namespace internal
+template <typename T>
+std::ostream& operator<<(std::ostream& s, const TensorBase<T, ReadOnlyAccessors>& t) {
+  s << t.format(TensorIOFormat::Plain());
+  return s;
+}
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_IO_H
diff --git a/contrib/Eigen/src/Tensor/TensorImagePatch.h b/contrib/Eigen/src/Tensor/TensorImagePatch.h
new file mode 100644
index 0000000..bf8266f
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorImagePatch.h
@@ -0,0 +1,767 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_IMAGE_PATCH_H
+#define EIGEN_TENSOR_TENSOR_IMAGE_PATCH_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <DenseIndex Rows, DenseIndex Cols, typename XprType>
+struct traits<TensorImagePatchOp<Rows, Cols, XprType>> : traits<XprType> {
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions + 1;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <DenseIndex Rows, DenseIndex Cols, typename XprType>
+struct eval<TensorImagePatchOp<Rows, Cols, XprType>, Eigen::Dense> {
+  typedef const TensorImagePatchOp<Rows, Cols, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Patch extraction specialized for image processing.
+ * This assumes that the input has at least 3 dimensions ordered as follows:
+ *  1st dimension: channels (of size d)
+ *  2nd dimension: rows (of size r)
+ *  3rd dimension: columns (of size c)
+ *  There can be additional dimensions such as time (for video) or batch (for
+ * bulk processing) after the first 3.
+ * Calling the image patch code with patch_rows and patch_cols is equivalent
+ * to calling the regular patch extraction code with parameters d, patch_rows,
+ * patch_cols, and 1 for all the additional dimensions.
+ */
+template <DenseIndex Rows, DenseIndex Cols, typename XprType>
+class TensorImagePatchOp : public TensorBase<TensorImagePatchOp<Rows, Cols, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorImagePatchOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorImagePatchOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorImagePatchOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorImagePatchOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorImagePatchOp(const XprType& expr, DenseIndex patch_rows,
+                                                           DenseIndex patch_cols, DenseIndex row_strides,
+                                                           DenseIndex col_strides, DenseIndex in_row_strides,
+                                                           DenseIndex in_col_strides, DenseIndex row_inflate_strides,
+                                                           DenseIndex col_inflate_strides, PaddingType padding_type,
+                                                           Scalar padding_value)
+      : m_xpr(expr),
+        m_patch_rows(patch_rows),
+        m_patch_cols(patch_cols),
+        m_row_strides(row_strides),
+        m_col_strides(col_strides),
+        m_in_row_strides(in_row_strides),
+        m_in_col_strides(in_col_strides),
+        m_row_inflate_strides(row_inflate_strides),
+        m_col_inflate_strides(col_inflate_strides),
+        m_padding_explicit(false),
+        m_padding_top(0),
+        m_padding_bottom(0),
+        m_padding_left(0),
+        m_padding_right(0),
+        m_padding_type(padding_type),
+        m_padding_value(padding_value) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorImagePatchOp(const XprType& expr, DenseIndex patch_rows,
+                                                           DenseIndex patch_cols, DenseIndex row_strides,
+                                                           DenseIndex col_strides, DenseIndex in_row_strides,
+                                                           DenseIndex in_col_strides, DenseIndex row_inflate_strides,
+                                                           DenseIndex col_inflate_strides, DenseIndex padding_top,
+                                                           DenseIndex padding_bottom, DenseIndex padding_left,
+                                                           DenseIndex padding_right, Scalar padding_value)
+      : m_xpr(expr),
+        m_patch_rows(patch_rows),
+        m_patch_cols(patch_cols),
+        m_row_strides(row_strides),
+        m_col_strides(col_strides),
+        m_in_row_strides(in_row_strides),
+        m_in_col_strides(in_col_strides),
+        m_row_inflate_strides(row_inflate_strides),
+        m_col_inflate_strides(col_inflate_strides),
+        m_padding_explicit(true),
+        m_padding_top(padding_top),
+        m_padding_bottom(padding_bottom),
+        m_padding_left(padding_left),
+        m_padding_right(padding_right),
+        m_padding_type(PADDING_VALID),
+        m_padding_value(padding_value) {}
+
+  EIGEN_DEVICE_FUNC DenseIndex patch_rows() const { return m_patch_rows; }
+  EIGEN_DEVICE_FUNC DenseIndex patch_cols() const { return m_patch_cols; }
+  EIGEN_DEVICE_FUNC DenseIndex row_strides() const { return m_row_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex col_strides() const { return m_col_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex in_row_strides() const { return m_in_row_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex in_col_strides() const { return m_in_col_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex row_inflate_strides() const { return m_row_inflate_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex col_inflate_strides() const { return m_col_inflate_strides; }
+  EIGEN_DEVICE_FUNC bool padding_explicit() const { return m_padding_explicit; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_top() const { return m_padding_top; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_bottom() const { return m_padding_bottom; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_left() const { return m_padding_left; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_right() const { return m_padding_right; }
+  EIGEN_DEVICE_FUNC PaddingType padding_type() const { return m_padding_type; }
+  EIGEN_DEVICE_FUNC Scalar padding_value() const { return m_padding_value; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const DenseIndex m_patch_rows;
+  const DenseIndex m_patch_cols;
+  const DenseIndex m_row_strides;
+  const DenseIndex m_col_strides;
+  const DenseIndex m_in_row_strides;
+  const DenseIndex m_in_col_strides;
+  const DenseIndex m_row_inflate_strides;
+  const DenseIndex m_col_inflate_strides;
+  const bool m_padding_explicit;
+  const DenseIndex m_padding_top;
+  const DenseIndex m_padding_bottom;
+  const DenseIndex m_padding_left;
+  const DenseIndex m_padding_right;
+  const PaddingType m_padding_type;
+  const Scalar m_padding_value;
+};
+
+// Eval as rvalue
+template <DenseIndex Rows, DenseIndex Cols, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorImagePatchOp<Rows, Cols, ArgType>, Device> {
+  typedef TensorImagePatchOp<Rows, Cols, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumInputDims =
+      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  static constexpr int NumDims = NumInputDims + 1;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef TensorEvaluator<const TensorImagePatchOp<Rows, Cols, ArgType>, Device> Self;
+  typedef TensorEvaluator<ArgType, Device> Impl;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // block() reads the argument one coefficient at a time through coeff() --
+    // the contract the scalar executors already rely on for every evaluator --
+    // so it requires no capability bit from the argument (same as
+    // TensorReverse).
+    BlockAccess = true,
+    PreferBlockAccess = true,
+    CoordAccess = false,
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef typename internal::TensorMaterializedBlock<Scalar, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_device(device), m_impl(op.expression(), device) {
+    EIGEN_STATIC_ASSERT((NumDims >= 4), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    m_paddingValue = op.padding_value();
+
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+
+    // Caches a few variables.
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputDepth = input_dims[0];
+      m_inputRows = input_dims[1];
+      m_inputCols = input_dims[2];
+    } else {
+      m_inputDepth = input_dims[NumInputDims - 1];
+      m_inputRows = input_dims[NumInputDims - 2];
+      m_inputCols = input_dims[NumInputDims - 3];
+    }
+
+    m_row_strides = op.row_strides();
+    m_col_strides = op.col_strides();
+
+    // Input strides and effective input/patch size
+    m_in_row_strides = op.in_row_strides();
+    m_in_col_strides = op.in_col_strides();
+    m_row_inflate_strides = op.row_inflate_strides();
+    m_col_inflate_strides = op.col_inflate_strides();
+    // The "effective" input rows and input cols are the input rows and cols
+    // after inflating them with zeros.
+    // For example, a 2x3 matrix with row_inflate_strides and
+    // col_inflate_strides of 2 comes from:
+    //   A B C
+    //   D E F
+    //
+    // to a matrix is 3 x 5:
+    //
+    //   A . B . C
+    //   . . . . .
+    //   D . E . F
+
+    m_input_rows_eff = (m_inputRows - 1) * m_row_inflate_strides + 1;
+    m_input_cols_eff = (m_inputCols - 1) * m_col_inflate_strides + 1;
+    m_patch_rows_eff = op.patch_rows() + (op.patch_rows() - 1) * (m_in_row_strides - 1);
+    m_patch_cols_eff = op.patch_cols() + (op.patch_cols() - 1) * (m_in_col_strides - 1);
+
+    if (op.padding_explicit()) {
+      m_outputRows = numext::ceil((m_input_rows_eff + op.padding_top() + op.padding_bottom() - m_patch_rows_eff + 1.f) /
+                                  static_cast<float>(m_row_strides));
+      m_outputCols = numext::ceil((m_input_cols_eff + op.padding_left() + op.padding_right() - m_patch_cols_eff + 1.f) /
+                                  static_cast<float>(m_col_strides));
+      m_rowPaddingTop = op.padding_top();
+      m_colPaddingLeft = op.padding_left();
+    } else {
+      // Computing padding from the type
+      switch (op.padding_type()) {
+        case PADDING_VALID:
+          m_outputRows = numext::ceil((m_input_rows_eff - m_patch_rows_eff + 1.f) / static_cast<float>(m_row_strides));
+          m_outputCols = numext::ceil((m_input_cols_eff - m_patch_cols_eff + 1.f) / static_cast<float>(m_col_strides));
+          // Calculate the padding
+          m_rowPaddingTop =
+              numext::maxi<Index>(0, ((m_outputRows - 1) * m_row_strides + m_patch_rows_eff - m_input_rows_eff) / 2);
+          m_colPaddingLeft =
+              numext::maxi<Index>(0, ((m_outputCols - 1) * m_col_strides + m_patch_cols_eff - m_input_cols_eff) / 2);
+          break;
+        case PADDING_SAME:
+          m_outputRows = numext::ceil(m_input_rows_eff / static_cast<float>(m_row_strides));
+          m_outputCols = numext::ceil(m_input_cols_eff / static_cast<float>(m_col_strides));
+          // Calculate the padding
+          m_rowPaddingTop = ((m_outputRows - 1) * m_row_strides + m_patch_rows_eff - m_input_rows_eff) / 2;
+          m_colPaddingLeft = ((m_outputCols - 1) * m_col_strides + m_patch_cols_eff - m_input_cols_eff) / 2;
+          // The padding size calculation for PADDING_SAME has been updated to
+          // be consistent with how TensorFlow extracts its paddings.
+          m_rowPaddingTop = numext::maxi<Index>(0, m_rowPaddingTop);
+          m_colPaddingLeft = numext::maxi<Index>(0, m_colPaddingLeft);
+          break;
+        default:
+          eigen_assert(false && "unexpected padding");
+          m_outputCols = 0;  // Silence the uninitialized warning.
+          m_outputRows = 0;  // Silence the uninitialized warning.
+      }
+    }
+    eigen_assert(m_outputRows > 0);
+    eigen_assert(m_outputCols > 0);
+
+    // Dimensions for result of extraction.
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      // ColMajor
+      // 0: depth
+      // 1: patch_rows
+      // 2: patch_cols
+      // 3: number of patches
+      // 4 and beyond: anything else (such as batch).
+      m_dimensions[0] = input_dims[0];
+      m_dimensions[1] = op.patch_rows();
+      m_dimensions[2] = op.patch_cols();
+      m_dimensions[3] = m_outputRows * m_outputCols;
+      for (int i = 4; i < NumDims; ++i) {
+        m_dimensions[i] = input_dims[i - 1];
+      }
+    } else {
+      // RowMajor
+      // NumDims-1: depth
+      // NumDims-2: patch_rows
+      // NumDims-3: patch_cols
+      // NumDims-4: number of patches
+      // NumDims-5 and beyond: anything else (such as batch).
+      m_dimensions[NumDims - 1] = input_dims[NumInputDims - 1];
+      m_dimensions[NumDims - 2] = op.patch_rows();
+      m_dimensions[NumDims - 3] = op.patch_cols();
+      m_dimensions[NumDims - 4] = m_outputRows * m_outputCols;
+      for (int i = NumDims - 5; i >= 0; --i) {
+        m_dimensions[i] = input_dims[i];
+      }
+    }
+
+    // Strides for moving the patch in various dimensions.
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_colStride = m_dimensions[1];
+      m_patchStride = m_colStride * m_dimensions[2] * m_dimensions[0];
+      m_otherStride = m_patchStride * m_dimensions[3];
+    } else {
+      m_colStride = m_dimensions[NumDims - 2];
+      m_patchStride = m_colStride * m_dimensions[NumDims - 3] * m_dimensions[NumDims - 1];
+      m_otherStride = m_patchStride * m_dimensions[NumDims - 4];
+    }
+
+    // Strides for navigating through the input tensor.
+    m_rowInputStride = m_inputDepth;
+    m_colInputStride = m_inputDepth * m_inputRows;
+    m_patchInputStride = m_inputDepth * m_inputRows * m_inputCols;
+
+    // Fast representations of different variables.
+    m_fastOtherStride = internal::TensorIntDivisor<Index>(m_otherStride);
+    m_fastPatchStride = internal::TensorIntDivisor<Index>(m_patchStride);
+    m_fastColStride = internal::TensorIntDivisor<Index>(m_colStride);
+    m_fastInflateRowStride = internal::TensorIntDivisor<Index>(m_row_inflate_strides);
+    m_fastInflateColStride = internal::TensorIntDivisor<Index>(m_col_inflate_strides);
+    m_fastInputColsEff = internal::TensorIntDivisor<Index>(m_input_cols_eff);
+
+    // Number of patches in the width dimension.
+    m_fastOutputRows = internal::TensorIntDivisor<Index>(m_outputRows);
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[0]);
+    } else {
+      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[NumDims - 1]);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    // Other ways to index this element.
+    Index otherIndex, patch2DIndex;
+    EIGEN_IF_CONSTEXPR (NumDims == 4) {
+      otherIndex = 0;
+      patch2DIndex = index / m_fastPatchStride;
+    } else {
+      otherIndex = index / m_fastOtherStride;
+      patch2DIndex = (index - otherIndex * m_otherStride) / m_fastPatchStride;
+    }
+
+    // Compute the remainder within the patch once, then derive both
+    // patchOffset and depth from it without an extra division.
+    constexpr int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
+    const Index patchRemainder = index - otherIndex * m_otherStride - patch2DIndex * m_patchStride;
+    const Index patchOffset = patchRemainder / m_fastOutputDepth;
+    const Index depth = patchRemainder - patchOffset * m_dimensions[depth_index];
+
+    // Calculate col index in the input original tensor.
+    const Index colIndex = patch2DIndex / m_fastOutputRows;
+    const Index colOffset = patchOffset / m_fastColStride;
+    const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
+    const Index origInputCol =
+        (m_col_inflate_strides == 1) ? inputCol : ((inputCol >= 0) ? (inputCol / m_fastInflateColStride) : 0);
+    if (inputCol < 0 || inputCol >= m_input_cols_eff ||
+        ((m_col_inflate_strides != 1) && (inputCol != origInputCol * m_col_inflate_strides))) {
+      return Scalar(m_paddingValue);
+    }
+
+    // Calculate row index in the original input tensor.
+    const Index rowIndex = patch2DIndex - colIndex * m_outputRows;
+    const Index rowOffset = patchOffset - colOffset * m_colStride;
+    const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
+    const Index origInputRow =
+        (m_row_inflate_strides == 1) ? inputRow : ((inputRow >= 0) ? (inputRow / m_fastInflateRowStride) : 0);
+    if (inputRow < 0 || inputRow >= m_input_rows_eff ||
+        ((m_row_inflate_strides != 1) && (inputRow != origInputRow * m_row_inflate_strides))) {
+      return Scalar(m_paddingValue);
+    }
+
+    const Index inputIndex =
+        depth + origInputRow * m_rowInputStride + origInputCol * m_colInputStride + otherIndex * m_patchInputStride;
+    return m_impl.coeff(inputIndex);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    constexpr int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
+    const Index lastIdx = index + PacketSize - 1;
+
+    // Decompose index into (otherIndex, patch2DIndex, patchRemainder).
+    // Use multiply+compare instead of a second TensorIntDivisor division
+    // to check whether the last packet element is in the same region.
+    Index otherIndex, patch2DIndex, patchRemainder0, patchRemainder1;
+    EIGEN_IF_CONSTEXPR (NumDims == 4) {
+      otherIndex = 0;
+      patch2DIndex = index / m_fastPatchStride;
+      const Index patchBase = patch2DIndex * m_patchStride;
+      if (lastIdx >= patchBase + m_patchStride) {
+        return packetWithPossibleZero(index);
+      }
+      patchRemainder0 = index - patchBase;
+      patchRemainder1 = lastIdx - patchBase;
+    } else {
+      otherIndex = index / m_fastOtherStride;
+      const Index otherBase = otherIndex * m_otherStride;
+      if (lastIdx >= otherBase + m_otherStride) {
+        return packetWithPossibleZero(index);
+      }
+      const Index patchBase0 = index - otherBase;
+      patch2DIndex = patchBase0 / m_fastPatchStride;
+      const Index patchStart = patch2DIndex * m_patchStride;
+      if (lastIdx - otherBase >= patchStart + m_patchStride) {
+        return packetWithPossibleZero(index);
+      }
+      patchRemainder0 = patchBase0 - patchStart;
+      patchRemainder1 = lastIdx - otherBase - patchStart;
+    }
+
+    // Compute patchOffset for the first element. Defer the second
+    // division until we know we need it.
+    const Index patchOffset0 = patchRemainder0 / m_fastOutputDepth;
+    const Index colIndex = patch2DIndex / m_fastOutputRows;
+
+    // If all packet elements share the same (row, col) within the patch,
+    // the input data is contiguous regardless of dilation/inflation strides.
+    // Check using multiply+compare instead of dividing patchRemainder1.
+    const Index outputDepth = m_dimensions[depth_index];
+    if (patchRemainder1 < (patchOffset0 + 1) * outputDepth) {
+      const Index colOffset = patchOffset0 / m_fastColStride;
+      const Index rowIndex = patch2DIndex - colIndex * m_outputRows;
+      const Index rowOffset = patchOffset0 - colOffset * m_colStride;
+
+      const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
+      const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
+
+      // Check col bounds and inflate alignment.
+      if (inputCol < 0 || inputCol >= m_input_cols_eff) {
+        return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+      }
+      if (m_col_inflate_strides != 1) {
+        const Index origCol = inputCol / m_fastInflateColStride;
+        if (inputCol != origCol * m_col_inflate_strides) {
+          return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+        }
+      }
+
+      // Check row bounds and inflate alignment.
+      if (inputRow < 0 || inputRow >= m_input_rows_eff) {
+        return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+      }
+      if (m_row_inflate_strides != 1) {
+        const Index origRow = inputRow / m_fastInflateRowStride;
+        if (inputRow != origRow * m_row_inflate_strides) {
+          return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+        }
+      }
+
+      // Compute original input coordinates.
+      const Index origInputCol = (m_col_inflate_strides == 1) ? inputCol : inputCol / m_fastInflateColStride;
+      const Index origInputRow = (m_row_inflate_strides == 1) ? inputRow : inputRow / m_fastInflateRowStride;
+
+      const Index depth = patchRemainder0 - patchOffset0 * outputDepth;
+      const Index inputIndex =
+          depth + origInputRow * m_rowInputStride + origInputCol * m_colInputStride + otherIndex * m_patchInputStride;
+      return m_impl.template packet<Unaligned>(inputIndex);
+    }
+
+    // For non-unit strides spanning multiple rows, fall back to scalar.
+    if (m_in_row_strides != 1 || m_in_col_strides != 1 || m_row_inflate_strides != 1 || m_col_inflate_strides != 1) {
+      return packetWithPossibleZero(index);
+    }
+
+    // Unit strides: try to serve the packet from contiguous input.
+    // Now we need the second patchOffset.
+    const Index patchOffset1 = patchRemainder1 / m_fastOutputDepth;
+    const Index colOffset0 = patchOffset0 / m_fastColStride;
+
+    // Check if both ends of the packet are in the same column using
+    // multiply+compare instead of dividing patchOffset1.
+    const Index colBound = (colOffset0 + 1) * m_colStride;
+    const bool sameCol = (patchOffset1 < colBound);
+
+    // Calculate col indices in the original input tensor.
+    const Index inputCol0 = colIndex * m_col_strides + colOffset0 - m_colPaddingLeft;
+    if (sameCol) {
+      if (inputCol0 < 0 || inputCol0 >= m_inputCols) {
+        return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+      }
+
+      const Index rowIndex = patch2DIndex - colIndex * m_outputRows;
+      const Index rowOffset0 = patchOffset0 - colOffset0 * m_colStride;
+      const Index rowOffset1 = patchOffset1 - colOffset0 * m_colStride;
+      eigen_assert(rowOffset0 <= rowOffset1);
+      // Calculate row indices in the original input tensor.
+      const Index inputRow0 = rowIndex * m_row_strides + rowOffset0 - m_rowPaddingTop;
+      const Index inputRow1 = rowIndex * m_row_strides + rowOffset1 - m_rowPaddingTop;
+
+      if (inputRow1 < 0 || inputRow0 >= m_inputRows) {
+        return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+      }
+
+      if (inputRow0 >= 0 && inputRow1 < m_inputRows) {
+        // no padding
+        const Index depth = patchRemainder0 - patchOffset0 * outputDepth;
+        const Index inputIndex =
+            depth + inputRow0 * m_rowInputStride + inputCol0 * m_colInputStride + otherIndex * m_patchInputStride;
+        return m_impl.template packet<Unaligned>(inputIndex);
+      }
+    } else {
+      // Packet spans two columns. Check if both columns are entirely
+      // outside the valid range (all-padding).
+      const Index colOffset1 = patchOffset1 / m_fastColStride;
+      const Index inputCol1 = colIndex * m_col_strides + colOffset1 - m_colPaddingLeft;
+      if (inputCol1 < 0 || inputCol0 >= m_inputCols) {
+        return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+      }
+    }
+
+    return packetWithPossibleZero(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.firstLevelCacheSize();
+    // In-bounds output coefficients read the argument once and every output
+    // coefficient is stored once (padding runs make this a slight
+    // over-estimate). Pass the full cost explicitly rather than adding to
+    // skewed()'s default load+store seed, which would double-count the
+    // baseline byte traffic and halve the tile size.
+    const TensorOpCost cost_per_coeff = m_impl.costPerCoeff(/*vectorized=*/false) + TensorOpCost(0, sizeof(Scalar), 0);
+    return internal::TensorBlockResourceRequirements::withShapeAndSize<Scalar>(
+        internal::TensorBlockShapeType::kSkewedInnerDims, target_size, cost_per_coeff);
+  }
+
+  // Materializes the block by iterating patch/col/row coordinates and either
+  // copying the (always input-contiguous) depth run or filling it with the
+  // padding value. All per-coordinate index math and bounds checks are
+  // amortized over a whole depth run instead of paid per coefficient.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    constexpr bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    if (desc.size() == 0) {
+      return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+    }
+
+    typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    Scalar* block_buffer = block_storage.data();
+
+    // Output coordinates of the block's corner.
+    const DSizes<Index, NumDims> output_strides = internal::strides<Layout>(m_dimensions);
+    array<Index, NumDims> coords;
+    Index remaining = desc.offset();
+    EIGEN_IF_CONSTEXPR (is_col_major) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        coords[i] = remaining / output_strides[i];
+        remaining -= coords[i] * output_strides[i];
+      }
+      coords[0] = remaining;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        coords[i] = remaining / output_strides[i];
+        remaining -= coords[i] * output_strides[i];
+      }
+      coords[NumDims - 1] = remaining;
+    }
+
+    // Output dimensions: depth, patch row/col offset, 2d patch index, rest.
+    const int dd = is_col_major ? 0 : NumDims - 1;
+    const int rd = is_col_major ? 1 : NumDims - 2;
+    const int cd = is_col_major ? 2 : NumDims - 3;
+    const int pd = is_col_major ? 3 : NumDims - 4;
+
+    const Index depth_start = coords[dd];
+    const Index depth_size = desc.dimension(dd);
+    const Index row_start = coords[rd];
+    const Index row_size = desc.dimension(rd);
+    const Index col_start = coords[cd];
+    const Index col_size = desc.dimension(cd);
+    const Index patch_start = coords[pd];
+    const Index patch_size = desc.dimension(pd);
+
+    // Odometer over the remaining (batch etc.) dimensions, tracking the input
+    // offset they contribute.
+    array<Index, NumDims> other_sizes;
+    array<Index, NumDims> other_src_stride;
+    array<Index, NumDims> other_count;
+    int num_other = 0;
+    Index src_other = 0;
+    {
+      Index in_stride = m_patchInputStride;
+      for (int k = 4; k < NumDims; ++k) {
+        const int d = is_col_major ? k : NumDims - 1 - k;
+        other_sizes[num_other] = desc.dimension(d);
+        other_src_stride[num_other] = in_stride;
+        other_count[num_other] = 0;
+        src_other += coords[d] * in_stride;
+        in_stride *= m_dimensions[d];
+        ++num_other;
+      }
+    }
+
+    typedef internal::StridedLinearBufferCopy<Scalar, Index> LinCopy;
+
+    // The loop nest below visits the block in exactly its memory order (the
+    // storage returned by prepareStorage() is dense with the block's own
+    // layout-order strides), so the destination is one running cursor.
+    Index dst = 0;
+    for (;;) {
+      for (Index p = 0; p < patch_size; ++p) {
+        const Index patch2DIndex = patch_start + p;
+        const Index colIndex = patch2DIndex / m_fastOutputRows;
+        const Index rowIndex = patch2DIndex - colIndex * m_outputRows;
+
+        for (Index c = 0; c < col_size; ++c) {
+          const Index colOffset = col_start + c;
+          const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
+          Index origInputCol = inputCol;
+          bool col_valid = inputCol >= 0 && inputCol < m_input_cols_eff;
+          if (col_valid && m_col_inflate_strides != 1) {
+            origInputCol = inputCol / m_fastInflateColStride;
+            col_valid = (inputCol == origInputCol * m_col_inflate_strides);
+          }
+
+          for (Index r = 0; r < row_size; ++r) {
+            const Index rowOffset = row_start + r;
+            bool valid = col_valid;
+            Index origInputRow = 0;
+            if (valid) {
+              const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
+              valid = inputRow >= 0 && inputRow < m_input_rows_eff;
+              if (valid) {
+                origInputRow = inputRow;
+                if (m_row_inflate_strides != 1) {
+                  origInputRow = inputRow / m_fastInflateRowStride;
+                  valid = (inputRow == origInputRow * m_row_inflate_strides);
+                }
+              }
+            }
+            if (valid) {
+              const Index src =
+                  depth_start + origInputRow * m_rowInputStride + origInputCol * m_colInputStride + src_other;
+              for (Index d = 0; d < depth_size; ++d) {
+                block_buffer[dst + d] = m_impl.coeff(src + d);
+              }
+            } else {
+              LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(dst, 1, block_buffer),
+                                                               typename LinCopy::Src(0, 0, &m_paddingValue),
+                                                               depth_size);
+            }
+            dst += depth_size;
+          }
+        }
+      }
+
+      int k = 0;
+      for (; k < num_other; ++k) {
+        if (++other_count[k] < other_sizes[k]) {
+          src_other += other_src_stride[k];
+          break;
+        }
+        other_count[k] = 0;
+        src_other -= other_src_stride[k] * (other_sizes[k] - 1);
+      }
+      if (k == num_other) break;
+    }
+    eigen_assert(dst == desc.size());
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowPaddingTop() const { return m_rowPaddingTop; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colPaddingLeft() const { return m_colPaddingLeft; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputRows() const { return m_outputRows; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputCols() const { return m_outputCols; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userRowStride() const { return m_row_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userColStride() const { return m_col_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInRowStride() const { return m_in_row_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInColStride() const { return m_in_col_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowInflateStride() const { return m_row_inflate_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colInflateStride() const { return m_col_inflate_strides; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    // Estimate for the non-padding code path with CoordAccess=false:
+    // 5 TensorIntDivisor divs (otherStride, patchStride, outputDepth, outputRows, colStride),
+    // 12 muls (index arithmetic), 8 adds/subs (offsets, padding checks).
+    const double compute_cost =
+        5 * TensorOpCost::DivCost<Index>() + 12 * TensorOpCost::MulCost<Index>() + 8 * TensorOpCost::AddCost<Index>();
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetWithPossibleZero(Index index) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  Dimensions m_dimensions;
+
+  Index m_otherStride;
+  Index m_patchStride;
+  Index m_colStride;
+  Index m_row_strides;
+  Index m_col_strides;
+
+  Index m_in_row_strides;
+  Index m_in_col_strides;
+  Index m_row_inflate_strides;
+  Index m_col_inflate_strides;
+
+  Index m_input_rows_eff;
+  Index m_input_cols_eff;
+  Index m_patch_rows_eff;
+  Index m_patch_cols_eff;
+
+  internal::TensorIntDivisor<Index> m_fastOtherStride;
+  internal::TensorIntDivisor<Index> m_fastPatchStride;
+  internal::TensorIntDivisor<Index> m_fastColStride;
+  internal::TensorIntDivisor<Index> m_fastInflateRowStride;
+  internal::TensorIntDivisor<Index> m_fastInflateColStride;
+  internal::TensorIntDivisor<Index> m_fastInputColsEff;
+
+  Index m_rowInputStride;
+  Index m_colInputStride;
+  Index m_patchInputStride;
+
+  Index m_inputDepth;
+  Index m_inputRows;
+  Index m_inputCols;
+
+  Index m_outputRows;
+  Index m_outputCols;
+
+  Index m_rowPaddingTop;
+  Index m_colPaddingLeft;
+
+  internal::TensorIntDivisor<Index> m_fastOutputRows;
+  internal::TensorIntDivisor<Index> m_fastOutputDepth;
+
+  Scalar m_paddingValue;
+
+  const Device EIGEN_DEVICE_REF m_device;
+  TensorEvaluator<ArgType, Device> m_impl;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_IMAGE_PATCH_H
diff --git a/contrib/Eigen/src/Tensor/TensorIndexList.h b/contrib/Eigen/src/Tensor/TensorIndexList.h
new file mode 100644
index 0000000..dcffcfe
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorIndexList.h
@@ -0,0 +1,524 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_INDEX_LIST_H
+#define EIGEN_TENSOR_TENSOR_INDEX_LIST_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <Index n>
+struct type2index {
+  static constexpr Index value = n;
+  EIGEN_DEVICE_FUNC constexpr operator Index() const { return n; }
+  EIGEN_DEVICE_FUNC void set(Index val) {
+    EIGEN_ONLY_USED_FOR_DEBUG(val);
+    eigen_assert(val == n);
+  }
+};
+
+// This can be used with IndexPairList to get compile-time constant pairs,
+// such as IndexPairList<type2indexpair<1,2>, type2indexpair<3,4>>().
+template <Index f, Index s>
+struct type2indexpair {
+  static constexpr Index first = f;
+  static constexpr Index second = s;
+
+  constexpr EIGEN_DEVICE_FUNC operator IndexPair<Index>() const { return IndexPair<Index>(f, s); }
+
+  EIGEN_DEVICE_FUNC void set(const IndexPair<Index>& val) {
+    EIGEN_ONLY_USED_FOR_DEBUG(val);
+    eigen_assert(val.first == f);
+    eigen_assert(val.second == s);
+  }
+};
+
+template <Index n>
+struct NumTraits<type2index<n>> {
+  typedef Index Real;
+  enum { IsComplex = 0, RequireInitialization = false, ReadCost = 1, AddCost = 1, MulCost = 1 };
+
+  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real epsilon() { return 0; }
+  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real dummy_precision() { return 0; }
+  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real highest() { return n; }
+  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real lowest() { return n; }
+};
+
+namespace internal {
+template <typename T>
+EIGEN_DEVICE_FUNC void update_value(T& val, Index new_val) {
+  val = internal::convert_index<T>(new_val);
+}
+template <Index n>
+EIGEN_DEVICE_FUNC void update_value(type2index<n>& val, Index new_val) {
+  val.set(new_val);
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC void update_value(T& val, IndexPair<Index> new_val) {
+  val = new_val;
+}
+template <Index f, Index s>
+EIGEN_DEVICE_FUNC void update_value(type2indexpair<f, s>& val, IndexPair<Index> new_val) {
+  val.set(new_val);
+}
+
+template <typename T>
+struct is_compile_time_constant_impl : std::false_type {};
+
+template <Index f, Index s>
+struct is_compile_time_constant_impl<type2indexpair<f, s>> : std::true_type {};
+
+template <Index idx>
+struct is_compile_time_constant_impl<type2index<idx>> : std::true_type {};
+
+template <typename T>
+using is_compile_time_constant = is_compile_time_constant_impl<std::remove_cv_t<std::remove_reference_t<T>>>;
+
+template <typename... T>
+struct IndexTuple;
+
+template <typename T, typename... O>
+struct IndexTuple<T, O...> {
+  EIGEN_DEVICE_FUNC constexpr IndexTuple() = default;
+  EIGEN_DEVICE_FUNC constexpr IndexTuple(const T& v, const O... o) : head(v), others(o...) {}
+
+  static constexpr int count = 1 + sizeof...(O);
+  T head{};
+  IndexTuple<O...> others{};
+  typedef T Head;
+  typedef IndexTuple<O...> Other;
+};
+
+template <typename T>
+struct IndexTuple<T> {
+  EIGEN_DEVICE_FUNC constexpr IndexTuple() = default;
+  EIGEN_DEVICE_FUNC constexpr IndexTuple(const T& v) : head(v) {}
+
+  constexpr static int count = 1;
+  T head{};
+  typedef T Head;
+};
+
+template <int N, typename... T>
+struct IndexTupleExtractor;
+
+template <int N, typename T, typename... O>
+struct IndexTupleExtractor<N, T, O...> {
+  typedef typename IndexTupleExtractor<N - 1, O...>::ValType ValType;
+
+  EIGEN_DEVICE_FUNC static constexpr ValType& get_val(IndexTuple<T, O...>& val) {
+    return IndexTupleExtractor<N - 1, O...>::get_val(val.others);
+  }
+
+  EIGEN_DEVICE_FUNC static constexpr const ValType& get_val(const IndexTuple<T, O...>& val) {
+    return IndexTupleExtractor<N - 1, O...>::get_val(val.others);
+  }
+  template <typename V>
+  EIGEN_DEVICE_FUNC static void set_val(IndexTuple<T, O...>& val, V& new_val) {
+    IndexTupleExtractor<N - 1, O...>::set_val(val.others, new_val);
+  }
+};
+
+template <typename T, typename... O>
+struct IndexTupleExtractor<0, T, O...> {
+  typedef T ValType;
+
+  EIGEN_DEVICE_FUNC static constexpr ValType& get_val(IndexTuple<T, O...>& val) { return val.head; }
+  EIGEN_DEVICE_FUNC static constexpr const ValType& get_val(const IndexTuple<T, O...>& val) { return val.head; }
+  template <typename V>
+  EIGEN_DEVICE_FUNC static void set_val(IndexTuple<T, O...>& val, V& new_val) {
+    val.head = new_val;
+  }
+};
+
+template <int N, typename T, typename... O>
+EIGEN_DEVICE_FUNC constexpr typename IndexTupleExtractor<N, T, O...>::ValType& array_get(IndexTuple<T, O...>& tuple) {
+  return IndexTupleExtractor<N, T, O...>::get_val(tuple);
+}
+template <int N, typename T, typename... O>
+EIGEN_DEVICE_FUNC constexpr const typename IndexTupleExtractor<N, T, O...>::ValType& array_get(
+    const IndexTuple<T, O...>& tuple) {
+  return IndexTupleExtractor<N, T, O...>::get_val(tuple);
+}
+template <typename T, typename... O>
+struct array_size<IndexTuple<T, O...>> {
+  static constexpr size_t value = IndexTuple<T, O...>::count;
+};
+template <typename T, typename... O>
+struct array_size<const IndexTuple<T, O...>> {
+  static constexpr size_t value = IndexTuple<T, O...>::count;
+};
+
+template <Index Idx, typename ValueT>
+struct tuple_coeff {
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr ValueT get(const Index i, const IndexTuple<T...>& t) {
+    return i == Idx ? array_get<Idx>(t) : tuple_coeff<Idx - 1, ValueT>::get(i, t);
+  }
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static void set(const Index i, IndexTuple<T...>& t, const ValueT& value) {
+    if (i == Idx) {
+      update_value(array_get<Idx>(t), value);
+    } else {
+      tuple_coeff<Idx - 1, ValueT>::set(i, t, value);
+    }
+  }
+
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr bool value_known_statically(const Index i, const IndexTuple<T...>& t) {
+    return ((i == Idx) && is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value) ||
+           tuple_coeff<Idx - 1, ValueT>::value_known_statically(i, t);
+  }
+
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_known_statically(const IndexTuple<T...>& t) {
+    return is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value &&
+           tuple_coeff<Idx - 1, ValueT>::values_up_to_known_statically(t);
+  }
+
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_statically_known_to_increase(const IndexTuple<T...>& t) {
+    return is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value &&
+           is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value &&
+           array_get<Idx>(t) > array_get<Idx - 1>(t) &&
+           tuple_coeff<Idx - 1, ValueT>::values_up_to_statically_known_to_increase(t);
+  }
+};
+
+template <typename ValueT>
+struct tuple_coeff<0, ValueT> {
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr ValueT get(const Index /*i*/, const IndexTuple<T...>& t) {
+    return array_get<0>(t);
+  }
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static void set(const Index i, IndexTuple<T...>& t, const ValueT value) {
+    EIGEN_ONLY_USED_FOR_DEBUG(i);
+    eigen_assert(i == 0);
+    update_value(array_get<0>(t), value);
+  }
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr bool value_known_statically(const Index i, const IndexTuple<T...>&) {
+    return is_compile_time_constant<typename IndexTupleExtractor<0, T...>::ValType>::value && (i == 0);
+  }
+
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_known_statically(const IndexTuple<T...>&) {
+    return is_compile_time_constant<typename IndexTupleExtractor<0, T...>::ValType>::value;
+  }
+
+  template <typename... T>
+  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_statically_known_to_increase(const IndexTuple<T...>&) {
+    return true;
+  }
+};
+}  // namespace internal
+
+/** \internal
+ *
+ * \ingroup Tensor_Module
+ *
+ * \brief Set of classes used to encode a set of Tensor dimensions/indices.
+ *
+ * The indices in the list can be known at compile time or at runtime. A mix
+ * of static and dynamic indices can also be provided if needed. The tensor
+ * code will attempt to take advantage of the indices that are known at
+ * compile time to optimize the code it generates.
+ *
+ * Several examples are provided in the tensor_index_list.cpp file.
+ *
+ * \sa Tensor
+ */
+
+template <typename FirstType, typename... OtherTypes>
+struct IndexList : internal::IndexTuple<FirstType, OtherTypes...> {
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr Index operator[](const Index i) const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::get(i, *this);
+  }
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr Index get(const Index i) const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::get(i, *this);
+  }
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC void set(const Index i, const Index value) {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::set(i, *this, value);
+  }
+
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr std::size_t size() const { return 1 + sizeof...(OtherTypes); }
+
+  EIGEN_DEVICE_FUNC constexpr IndexList(const internal::IndexTuple<FirstType, OtherTypes...>& other)
+      : internal::IndexTuple<FirstType, OtherTypes...>(other) {}
+  EIGEN_DEVICE_FUNC constexpr IndexList(FirstType& first, OtherTypes... other)
+      : internal::IndexTuple<FirstType, OtherTypes...>(first, other...) {}
+  EIGEN_DEVICE_FUNC constexpr IndexList() = default;
+
+  EIGEN_DEVICE_FUNC constexpr bool value_known_statically(const Index i) const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::value_known_statically(i, *this);
+  }
+  EIGEN_DEVICE_FUNC constexpr bool all_values_known_statically() const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::values_up_to_known_statically(*this);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr bool values_statically_known_to_increase() const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::values_up_to_statically_known_to_increase(*this);
+  }
+};
+
+template <typename FirstType, typename... OtherTypes>
+std::ostream& operator<<(std::ostream& os, const IndexList<FirstType, OtherTypes...>& dims) {
+  os << "[";
+  for (size_t i = 0; i < 1 + sizeof...(OtherTypes); ++i) {
+    if (i > 0) os << ", ";
+    os << dims[i];
+  }
+  os << "]";
+  return os;
+}
+
+template <typename FirstType, typename... OtherTypes>
+constexpr IndexList<FirstType, OtherTypes...> make_index_list(FirstType val1, OtherTypes... other_vals) {
+  return IndexList<FirstType, OtherTypes...>(val1, other_vals...);
+}
+
+template <typename FirstType, typename... OtherTypes>
+struct IndexPairList : internal::IndexTuple<FirstType, OtherTypes...> {
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr IndexPair<Index> operator[](const Index i) const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 IndexPair<Index>>::get(i, *this);
+  }
+  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC void set(const Index i, const IndexPair<Index> value) {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 IndexPair<Index>>::set(i, *this, value);
+  }
+
+  EIGEN_DEVICE_FUNC constexpr IndexPairList(const internal::IndexTuple<FirstType, OtherTypes...>& other)
+      : internal::IndexTuple<FirstType, OtherTypes...>(other) {}
+  EIGEN_DEVICE_FUNC constexpr IndexPairList() = default;
+
+  EIGEN_DEVICE_FUNC constexpr bool value_known_statically(const Index i) const {
+    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
+                                 Index>::value_known_statically(i, *this);
+  }
+};
+
+namespace internal {
+
+template <typename FirstType, typename... OtherTypes>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index array_prod(const IndexList<FirstType, OtherTypes...>& sizes) {
+  Index result = 1;
+  EIGEN_UNROLL_LOOP
+  for (size_t i = 0; i < array_size<IndexList<FirstType, OtherTypes...>>::value; ++i) {
+    result *= sizes[i];
+  }
+  return result;
+}
+
+template <typename FirstType, typename... OtherTypes>
+struct array_size<IndexList<FirstType, OtherTypes...>> {
+  static constexpr size_t value = array_size<IndexTuple<FirstType, OtherTypes...>>::value;
+};
+template <typename FirstType, typename... OtherTypes>
+struct array_size<const IndexList<FirstType, OtherTypes...>> {
+  static constexpr size_t value = array_size<IndexTuple<FirstType, OtherTypes...>>::value;
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct array_size<IndexPairList<FirstType, OtherTypes...>> {
+  static constexpr size_t value = 1 + sizeof...(OtherTypes);
+};
+template <typename FirstType, typename... OtherTypes>
+struct array_size<const IndexPairList<FirstType, OtherTypes...>> {
+  static constexpr size_t value = 1 + sizeof...(OtherTypes);
+};
+
+template <Index N, typename FirstType, typename... OtherTypes>
+EIGEN_DEVICE_FUNC constexpr Index array_get(IndexList<FirstType, OtherTypes...>& a) {
+  return IndexTupleExtractor<N, FirstType, OtherTypes...>::get_val(a);
+}
+template <Index N, typename FirstType, typename... OtherTypes>
+EIGEN_DEVICE_FUNC constexpr Index array_get(const IndexList<FirstType, OtherTypes...>& a) {
+  return IndexTupleExtractor<N, FirstType, OtherTypes...>::get_val(a);
+}
+
+template <typename T>
+struct index_known_statically_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_known_statically_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i) {
+    return IndexList<FirstType, OtherTypes...>().value_known_statically(i);
+  }
+};
+
+template <typename T>
+struct all_indices_known_statically_impl {
+  static constexpr bool run() { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct all_indices_known_statically_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run() {
+    return IndexList<FirstType, OtherTypes...>().all_values_known_statically();
+  }
+};
+
+template <typename T>
+struct indices_statically_known_to_increase_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run() { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct indices_statically_known_to_increase_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run() {
+    return Eigen::IndexList<FirstType, OtherTypes...>().values_statically_known_to_increase();
+  }
+};
+
+template <typename Tx>
+struct index_statically_eq_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_statically_eq_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
+    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
+           (IndexList<FirstType, OtherTypes...>().get(i) == value);
+  }
+};
+
+template <typename T>
+struct index_statically_ne_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_statically_ne_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
+    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
+           (IndexList<FirstType, OtherTypes...>().get(i) != value);
+  }
+};
+
+template <typename T>
+struct index_statically_gt_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_statically_gt_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
+    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
+           (IndexList<FirstType, OtherTypes...>().get(i) > value);
+  }
+};
+
+template <typename T>
+struct index_statically_lt_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_statically_lt_impl<IndexList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
+    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
+           (IndexList<FirstType, OtherTypes...>().get(i) < value);
+  }
+};
+
+template <typename Tx>
+struct index_pair_first_statically_eq_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_pair_first_statically_eq_impl<IndexPairList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
+    return IndexPairList<FirstType, OtherTypes...>().value_known_statically(i) &&
+           (IndexPairList<FirstType, OtherTypes...>().operator[](i).first == value);
+  }
+};
+
+template <typename Tx>
+struct index_pair_second_statically_eq_impl {
+  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
+};
+
+template <typename FirstType, typename... OtherTypes>
+struct index_pair_second_statically_eq_impl<IndexPairList<FirstType, OtherTypes...>> {
+  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
+    return IndexPairList<FirstType, OtherTypes...>().value_known_statically(i) &&
+           (IndexPairList<FirstType, OtherTypes...>().operator[](i).second == value);
+  }
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+namespace Eigen {
+namespace internal {
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_known_statically(Index i) {
+  return index_known_statically_impl<std::remove_cv_t<T>>::run(i);
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool all_indices_known_statically() {
+  return all_indices_known_statically_impl<std::remove_cv_t<T>>::run();
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool indices_statically_known_to_increase() {
+  return indices_statically_known_to_increase_impl<std::remove_cv_t<T>>::run();
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_statically_eq(Index i, Index value) {
+  return index_statically_eq_impl<std::remove_cv_t<T>>::run(i, value);
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_statically_ne(Index i, Index value) {
+  return index_statically_ne_impl<std::remove_cv_t<T>>::run(i, value);
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_statically_gt(Index i, Index value) {
+  return index_statically_gt_impl<std::remove_cv_t<T>>::run(i, value);
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_statically_lt(Index i, Index value) {
+  return index_statically_lt_impl<std::remove_cv_t<T>>::run(i, value);
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_pair_first_statically_eq(Index i, Index value) {
+  return index_pair_first_statically_eq_impl<std::remove_cv_t<T>>::run(i, value);
+}
+
+template <typename T>
+static EIGEN_DEVICE_FUNC constexpr bool index_pair_second_statically_eq(Index i, Index value) {
+  return index_pair_second_statically_eq_impl<std::remove_cv_t<T>>::run(i, value);
+}
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_INDEX_LIST_H
diff --git a/contrib/Eigen/src/Tensor/TensorInflation.h b/contrib/Eigen/src/Tensor/TensorInflation.h
new file mode 100644
index 0000000..bc2575c
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorInflation.h
@@ -0,0 +1,371 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Ke Yang <yangke@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_INFLATION_H
+#define EIGEN_TENSOR_TENSOR_INFLATION_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Strides, typename XprType>
+struct traits<TensorInflationOp<Strides, XprType>> : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename Strides, typename XprType>
+struct eval<TensorInflationOp<Strides, XprType>, Eigen::Dense> {
+  typedef const TensorInflationOp<Strides, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor inflation class.
+ */
+template <typename Strides, typename XprType>
+class TensorInflationOp : public TensorBase<TensorInflationOp<Strides, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorInflationOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorInflationOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorInflationOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorInflationOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorInflationOp(const XprType& expr, const Strides& strides)
+      : m_xpr(expr), m_strides(strides) {}
+
+  EIGEN_DEVICE_FUNC const Strides& strides() const { return m_strides; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Strides m_strides;
+};
+
+// Eval as rvalue
+template <typename Strides, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorInflationOp<Strides, ArgType>, Device> {
+  typedef TensorInflationOp<Strides, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = /*TensorEvaluator<ArgType, Device>::IsAligned*/ false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // block() reads the argument through coeff(), and under a ThreadPool the
+    // tiled executor shares this evaluator across concurrent block tasks, so
+    // the argument must be safe to read repeatedly and concurrently. Either bit
+    // establishes that: BlockAccess is what a nullary functor that carries
+    // state between calls clears (the built-in random generators are pure in
+    // seed and index and keep it), and RawAccess means coeff() is a plain
+    // buffer read. Requiring BlockAccess alone would needlessly exclude raw
+    // arguments whose scalar is not arithmetic, such as complex tensors.
+    BlockAccess =
+        (TensorEvaluator<ArgType, Device>::BlockAccess || TensorEvaluator<ArgType, Device>::RawAccess) && NumDims > 0,
+    // The coeff/packet path pays a div/mod walk plus a hole check per output
+    // scalar; the block path is a zero-fill plus a sparse copy of the stride
+    // lattice.
+    PreferBlockAccess = true,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_strides(op.strides()), m_device(device) {
+    m_dimensions = m_impl.dimensions();
+    // Expand each dimension to the inflated dimension.
+    for (int i = 0; i < NumDims; ++i) {
+      m_dimensions[i] = (m_dimensions[i] - 1) * op.strides()[i] + 1;
+    }
+
+    // Remember the strides for fast division.
+    for (int i = 0; i < NumDims; ++i) {
+      m_fastStrides[i] = internal::TensorIntDivisor<Index>(m_strides[i]);
+    }
+
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_outputStrides[0] = 1;
+      m_inputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
+      }
+    } else {  // RowMajor
+      m_outputStrides[NumDims - 1] = 1;
+      m_inputStrides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  // Computes the input index given the output index. Returns true if the output
+  // index doesn't fall into a hole.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool getInputIndex(Index index, Index* inputIndex) const {
+    eigen_assert(index < dimensions().TotalSize());
+    *inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_outputStrides[i];
+        if (idx != idx / m_fastStrides[i] * m_strides[i]) {
+          return false;
+        }
+        *inputIndex += idx / m_strides[i] * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      if (index != index / m_fastStrides[0] * m_strides[0]) {
+        return false;
+      }
+      *inputIndex += index / m_strides[0];
+      return true;
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_outputStrides[i];
+        if (idx != idx / m_fastStrides[i] * m_strides[i]) {
+          return false;
+        }
+        *inputIndex += idx / m_strides[i] * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      if (index != index / m_fastStrides[NumDims - 1] * m_strides[NumDims - 1]) {
+        return false;
+      }
+      *inputIndex += index / m_strides[NumDims - 1];
+    }
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    Index inputIndex = 0;
+    if (getInputIndex(index, &inputIndex)) {
+      return m_impl.coeff(inputIndex);
+    } else {
+      return Scalar(0);
+    }
+  }
+
+  // TODO(yangke): optimize this function so that we can detect and produce
+  // all-zero packets
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.lastLevelCacheSize();
+    // One store per output coefficient for the zero fill, plus a
+    // lattice-density-weighted argument read and overwrite store, so that
+    // ThreadPool scheduling sees the true cost of expensive arguments.
+    const double density = latticeDensity();
+    const TensorOpCost cost_per_coeff =
+        density * m_impl.costPerCoeff(/*vectorized=*/false) +
+        TensorOpCost(/*bytes_loaded=*/0, /*bytes_stored=*/(1.0 + density) * sizeof(CoeffReturnType),
+                     /*compute_cycles=*/0);
+    // withShapeAndSize rather than skewed(), because skewed() seeds a load and
+    // a store per coefficient that this model already accounts for.
+    return internal::TensorBlockResourceRequirements::withShapeAndSize<Scalar>(
+        internal::TensorBlockShapeType::kSkewedInnerDims, target_size, cost_per_coeff);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    constexpr bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    // If one of the dimensions is zero, return empty block view.
+    if (desc.size() == 0) {
+      return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+    }
+
+    // Everything outside the stride lattice is a hole, so zero-fill first and
+    // then copy the covered input values onto the lattice.
+    typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    CoeffReturnType* block_buffer = block_storage.data();
+
+    // Output coordinates of the block's corner.
+    array<Index, NumDims> coords;
+    extract_coordinates(desc.offset(), coords);
+
+    // First lattice point inside the block and the lattice extent, per dim.
+    const DSizes<Index, NumDims>& block_strides = block_storage.strides();
+    array<Index, NumDims> lattice_count;
+    Index dst_offset = 0;
+    Index src_offset = 0;
+    for (int i = 0; i < NumDims; ++i) {
+      const Index stride = m_strides[i];
+      const Index first_input = numext::div_ceil(coords[i], stride);
+      const Index first = first_input * stride;         // output coordinate
+      const Index end = coords[i] + desc.dimension(i);  // exclusive
+      if (first >= end) {
+        // No lattice point along this dimension: the block is all holes.
+        Map<ArrayX<CoeffReturnType>>(block_buffer, desc.size()).setZero();
+        return block_storage.AsTensorMaterializedBlock();
+      }
+      lattice_count[i] = numext::div_ceil(end - first, stride);
+      dst_offset += (first - coords[i]) * block_strides[i];
+      src_offset += first_input * m_inputStrides[i];
+    }
+
+    // The fill is pure waste when the lattice covers every coefficient, which
+    // is the whole block for identity striding.
+    bool dense = true;
+    for (int i = 0; i < NumDims; ++i) dense = dense && (lattice_count[i] == desc.dimension(i));
+    if (!dense) Map<ArrayX<CoeffReturnType>>(block_buffer, desc.size()).setZero();
+
+    // Iterate the lattice (dimensions ordered inner-most to outer-most).
+    array<BlockIteratorState, NumDims> it;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = is_col_major ? i : NumDims - 1 - i;
+      const Index size = lattice_count[dim];
+      const Index dst_stride = block_strides[dim] * m_strides[dim];
+      const Index src_stride = m_inputStrides[dim];
+      it[i] = {/*size=*/size,
+               /*count=*/0,
+               /*dst_stride=*/dst_stride,
+               /*dst_span=*/dst_stride * (size - 1),
+               /*src_stride=*/src_stride,
+               /*src_span=*/src_stride * (size - 1)};
+    }
+
+    const Index inner_size = it[0].size;
+    const Index inner_dst_stride = it[0].dst_stride;
+    // m_inputStrides is 1 on the inner dimension in both layouts, so the
+    // argument is read as a contiguous run.
+    eigen_assert(it[0].src_stride == 1);
+    Index dst = dst_offset;
+    Index src = src_offset;
+    while (it[NumDims - 1].count < it[NumDims - 1].size) {
+      for (Index j = 0; j < inner_size; ++j) {
+        block_buffer[dst + j * inner_dst_stride] = m_impl.coeff(src + j);
+      }
+
+      EIGEN_IF_CONSTEXPR (NumDims == 1) break;
+
+      for (int i = 1; i < NumDims; ++i) {
+        if (++it[i].count < it[i].size) {
+          dst += it[i].dst_stride;
+          src += it[i].src_stride;
+          break;
+        }
+        if (i != NumDims - 1) it[i].count = 0;
+        dst -= it[i].dst_span;
+        src -= it[i].src_span;
+      }
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost = NumDims * (3 * TensorOpCost::DivCost<Index>() + 3 * TensorOpCost::MulCost<Index>() +
+                                           2 * TensorOpCost::AddCost<Index>());
+    if (m_dimensions.TotalSize() == 0) return TensorOpCost();
+    return m_impl.costPerCoeff(vectorized) +
+           TensorOpCost(sizeof(CoeffReturnType) * latticeDensity(), 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ protected:
+  // Fraction of output coefficients that fall on the stride lattice.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double latticeDensity() const {
+    const double output_size = static_cast<double>(m_dimensions.TotalSize());
+    if (output_size == 0) return 0.0;
+    return static_cast<double>(m_impl.dimensions().TotalSize()) / output_size;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_coordinates(Index index, array<Index, NumDims>& coords) const {
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_outputStrides[i];
+        index -= idx * m_outputStrides[i];
+        coords[i] = idx;
+      }
+      coords[0] = index;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_outputStrides[i];
+        index -= idx * m_outputStrides[i];
+        coords[i] = idx;
+      }
+      coords[NumDims - 1] = index;
+    }
+  }
+
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_outputStrides;
+  array<Index, NumDims> m_inputStrides;
+  TensorEvaluator<ArgType, Device> m_impl;
+  const Strides m_strides;
+  array<internal::TensorIntDivisor<Index>, NumDims> m_fastStrides;
+  const Device EIGEN_DEVICE_REF m_device;
+
+ private:
+  struct BlockIteratorState {
+    Index size;
+    Index count;
+    Index dst_stride;
+    Index dst_span;
+    Index src_stride;
+    Index src_span;
+  };
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_INFLATION_H
diff --git a/contrib/Eigen/src/Tensor/TensorInitializer.h b/contrib/Eigen/src/Tensor/TensorInitializer.h
new file mode 100644
index 0000000..be661a3
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorInitializer.h
@@ -0,0 +1,79 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_INITIALIZER_H
+#define EIGEN_TENSOR_TENSOR_INITIALIZER_H
+
+#include <initializer_list>
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Helper template to initialize Tensors from std::initializer_lists.
+ */
+template <typename Derived, int N>
+struct Initializer {
+  typedef std::initializer_list<typename Initializer<Derived, N - 1>::InitList> InitList;
+
+  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
+                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>* indices,
+                  const InitList& vals) {
+    int i = 0;
+    for (const auto& v : vals) {
+      (*indices)[traits<Derived>::NumDimensions - N] = i++;
+      Initializer<Derived, N - 1>::run(tensor, indices, v);
+    }
+  }
+};
+
+template <typename Derived>
+struct Initializer<Derived, 1> {
+  typedef std::initializer_list<typename traits<Derived>::Scalar> InitList;
+
+  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
+                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>* indices,
+                  const InitList& vals) {
+    int i = 0;
+    // TODO: Consider a faster approach than iterating.
+    for (const auto& v : vals) {
+      (*indices)[traits<Derived>::NumDimensions - 1] = i++;
+      tensor.coeffRef(*indices) = v;
+    }
+  }
+};
+
+template <typename Derived>
+struct Initializer<Derived, 0> {
+  typedef typename traits<Derived>::Scalar InitList;
+
+  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
+                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>*, const InitList& v) {
+    tensor.coeffRef(0) = v;
+  }
+};
+
+template <typename Derived, int N>
+void initialize_tensor(TensorEvaluator<Derived, DefaultDevice>& tensor,
+                       const typename Initializer<Derived, traits<Derived>::NumDimensions>::InitList& vals) {
+  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions> indices;
+  Initializer<Derived, traits<Derived>::NumDimensions>::run(tensor, &indices, vals);
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_INITIALIZER_H
diff --git a/contrib/Eigen/src/Tensor/TensorIntDiv.h b/contrib/Eigen/src/Tensor/TensorIntDiv.h
new file mode 100644
index 0000000..73c7adf
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorIntDiv.h
@@ -0,0 +1,252 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_INTDIV_H
+#define EIGEN_TENSOR_TENSOR_INTDIV_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+// Note: result is undefined if val == 0
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<sizeof(T) == 4, int> count_leading_zeros(const T val) {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+  return __clz(val);
+#elif defined(SYCL_DEVICE_ONLY)
+  return cl::sycl::clz(val);
+#elif EIGEN_COMP_MSVC
+  unsigned long index;
+  _BitScanReverse(&index, val);
+  return 31 - index;
+#else
+  EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  return __builtin_clz(static_cast<uint32_t>(val));
+#endif
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<sizeof(T) == 8, int> count_leading_zeros(const T val) {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+  return __clzll(val);
+#elif defined(SYCL_DEVICE_ONLY)
+  return static_cast<int>(cl::sycl::clz(val));
+#elif EIGEN_COMP_MSVC && EIGEN_ARCH_x86_64
+  unsigned long index;
+  _BitScanReverse64(&index, val);
+  return 63 - index;
+#elif EIGEN_COMP_MSVC
+  // MSVC's _BitScanReverse64 is not available for 32bits builds.
+  unsigned int lo = (unsigned int)(val & 0xffffffff);
+  unsigned int hi = (unsigned int)((val >> 32) & 0xffffffff);
+  int n;
+  if (hi == 0)
+    n = 32 + count_leading_zeros<unsigned int>(lo);
+  else
+    n = count_leading_zeros<unsigned int>(hi);
+  return n;
+#else
+  EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  return __builtin_clzll(static_cast<uint64_t>(val));
+#endif
+}
+
+template <typename T>
+struct UnsignedTraits {
+  typedef std::conditional_t<sizeof(T) == 8, uint64_t, uint32_t> type;
+};
+
+template <typename T>
+struct DividerTraits {
+  typedef typename UnsignedTraits<T>::type type;
+  static constexpr int N = sizeof(T) * 8;
+};
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint32_t muluh(const uint32_t a, const T b) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __umulhi(a, b);
+#elif defined(SYCL_DEVICE_ONLY)
+  return cl::sycl::mul_hi(a, static_cast<uint32_t>(b));
+#else
+  return (static_cast<uint64_t>(a) * b) >> 32;
+#endif
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint64_t muluh(const uint64_t a, const T b) {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  return __umul64hi(a, b);
+#elif defined(SYCL_DEVICE_ONLY)
+  return cl::sycl::mul_hi(a, static_cast<uint64_t>(b));
+#elif EIGEN_COMP_MSVC && (EIGEN_ARCH_x86_64 || EIGEN_ARCH_ARM64)
+  return __umulh(a, static_cast<uint64_t>(b));
+#elif EIGEN_HAS_BUILTIN_INT128
+  __uint128_t v = static_cast<__uint128_t>(a) * static_cast<__uint128_t>(b);
+  return static_cast<uint64_t>(v >> 64);
+#else
+  return (TensorUInt128<static_val<0>, uint64_t>(a) * TensorUInt128<static_val<0>, uint64_t>(b)).upper();
+#endif
+}
+
+template <int N, typename T>
+struct DividerHelper {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint32_t computeMultiplier(const int log_div, const T divider) {
+    EIGEN_STATIC_ASSERT(N == 32, YOU_MADE_A_PROGRAMMING_MISTAKE);
+    return static_cast<uint32_t>((static_cast<uint64_t>(1) << (N + log_div)) / divider -
+                                 (static_cast<uint64_t>(1) << N) + 1);
+  }
+};
+
+template <typename T>
+struct DividerHelper<64, T> {
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint64_t computeMultiplier(const int log_div, const T divider) {
+#if EIGEN_HAS_BUILTIN_INT128 && !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
+    return static_cast<uint64_t>((static_cast<__uint128_t>(1) << (64 + log_div)) / static_cast<__uint128_t>(divider) -
+                                 (static_cast<__uint128_t>(1) << 64) + 1);
+#else
+    const uint64_t shift = 1ULL << log_div;
+    TensorUInt128<uint64_t, uint64_t> result =
+        TensorUInt128<uint64_t, static_val<0> >(shift, 0) / TensorUInt128<static_val<0>, uint64_t>(divider) -
+        TensorUInt128<static_val<1>, static_val<0> >(1, 0) + TensorUInt128<static_val<0>, static_val<1> >(1);
+    return static_cast<uint64_t>(result);
+#endif
+  }
+};
+
+/** \internal
+ *
+ * \ingroup Tensor_Module
+ *
+ * \brief Fast integer division by a constant.
+ *
+ * See the paper from Granlund and Montgomery for explanation.
+ *   (at https://doi.org/10.1145/773473.178249)
+ *
+ * \sa Tensor
+ */
+template <typename T, bool div_gt_one = false>
+struct TensorIntDivisor {
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor() = default;
+
+  // Must have 0 < divider < 2^31. This is relaxed to
+  // 0 < divider < 2^63 when using 64-bit indices on platforms that support
+  // the __uint128_t type.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor(const T divider) {
+    const int N = DividerTraits<T>::N;
+    eigen_assert(static_cast<typename UnsignedTraits<T>::type>(divider) < NumTraits<UnsignedType>::highest() / 2);
+    eigen_assert(divider > 0);
+
+    // fast ln2
+    const int leading_zeros = count_leading_zeros(static_cast<UnsignedType>(divider));
+    int log_div = N - leading_zeros;
+    // if divider is a power of two then log_div is 1 more than it should be.
+    if ((static_cast<typename UnsignedTraits<T>::type>(1) << (log_div - 1)) ==
+        static_cast<typename UnsignedTraits<T>::type>(divider))
+      log_div--;
+
+    multiplier = DividerHelper<N, T>::computeMultiplier(log_div, divider);
+    shift1 = log_div > 1 ? 1 : log_div;
+    shift2 = log_div > 1 ? log_div - 1 : 0;
+  }
+
+  // Must have 0 <= numerator. On platforms that don't support the __uint128_t
+  // type numerator should also be less than 2^32-1.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T divide(const T numerator) const {
+    eigen_assert(static_cast<typename UnsignedTraits<T>::type>(numerator) < NumTraits<UnsignedType>::highest() / 2);
+
+    UnsignedType t1 = muluh(multiplier, numerator);
+    UnsignedType t = (static_cast<UnsignedType>(numerator) - t1) >> shift1;
+    return (t1 + t) >> shift2;
+  }
+
+ private:
+  typedef typename DividerTraits<T>::type UnsignedType;
+  UnsignedType multiplier = 0;
+  int32_t shift1 = 0;
+  int32_t shift2 = 0;
+};
+
+// Optimized version for signed 32 bit integers.
+// Derived from Hacker's Delight.
+// Only works for divisors strictly greater than one
+template <>
+class TensorIntDivisor<int32_t, true> {
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor() = default;
+  // Must have 2 <= divider
+  EIGEN_DEVICE_FUNC TensorIntDivisor(int32_t divider) {
+    eigen_assert(divider >= 2);
+    calcMagic(divider);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE int divide(const int32_t n) const {
+#ifdef EIGEN_GPU_COMPILE_PHASE
+    return __umulhi(magic, n) >> shift;
+#elif defined(SYCL_DEVICE_ONLY)
+    return cl::sycl::mul_hi(magic, static_cast<uint32_t>(n)) >> shift;
+#else
+    uint64_t v = static_cast<uint64_t>(magic) * static_cast<uint64_t>(n);
+    return static_cast<uint32_t>(v >> 32) >> shift;
+#endif
+  }
+
+ private:
+  // Compute the magic numbers. See Hacker's Delight section 10 for an in-depth
+  // explanation.
+  EIGEN_DEVICE_FUNC void calcMagic(int32_t d) {
+    const unsigned two31 = 0x80000000;  // 2**31.
+    unsigned ad = d;
+    unsigned t = two31 + (ad >> 31);
+    unsigned anc = t - 1 - t % ad;   // Absolute value of nc.
+    int p = 31;                      // Init. p.
+    unsigned q1 = two31 / anc;       // Init. q1 = 2**p/|nc|.
+    unsigned r1 = two31 - q1 * anc;  // Init. r1 = rem(2**p, |nc|).
+    unsigned q2 = two31 / ad;        // Init. q2 = 2**p/|d|.
+    unsigned r2 = two31 - q2 * ad;   // Init. r2 = rem(2**p, |d|).
+    unsigned delta = 0;
+    do {
+      p = p + 1;
+      q1 = 2 * q1;      // Update q1 = 2**p/|nc|.
+      r1 = 2 * r1;      // Update r1 = rem(2**p, |nc|).
+      if (r1 >= anc) {  // (Must be an unsigned
+        q1 = q1 + 1;    // comparison here).
+        r1 = r1 - anc;
+      }
+      q2 = 2 * q2;     // Update q2 = 2**p/|d|.
+      r2 = 2 * r2;     // Update r2 = rem(2**p, |d|).
+      if (r2 >= ad) {  // (Must be an unsigned
+        q2 = q2 + 1;   // comparison here).
+        r2 = r2 - ad;
+      }
+      delta = ad - r2;
+    } while (q1 < delta || (q1 == delta && r1 == 0));
+
+    magic = (unsigned)(q2 + 1);
+    shift = p - 32;
+  }
+
+  uint32_t magic = 0;
+  int32_t shift = 0;
+};
+
+template <typename T, bool div_gt_one>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator/(const T& numerator, const TensorIntDivisor<T, div_gt_one>& divisor) {
+  return divisor.divide(numerator);
+}
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_INTDIV_H
diff --git a/contrib/Eigen/src/Tensor/TensorLayoutSwap.h b/contrib/Eigen/src/Tensor/TensorLayoutSwap.h
new file mode 100644
index 0000000..bc398d3
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorLayoutSwap.h
@@ -0,0 +1,293 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_LAYOUT_SWAP_H
+#define EIGEN_TENSOR_TENSOR_LAYOUT_SWAP_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename XprType>
+struct traits<TensorLayoutSwapOp<XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = traits<XprType>::NumDimensions;
+  static constexpr int Layout = (traits<XprType>::Layout == ColMajor) ? RowMajor : ColMajor;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename XprType>
+struct eval<TensorLayoutSwapOp<XprType>, Eigen::Dense> {
+  typedef const TensorLayoutSwapOp<XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Swap the layout from col-major to row-major, or row-major
+ * to col-major, and invert the order of the dimensions.
+ *
+ * Beware: the dimensions are reversed by this operation. If you want to
+ * preserve the ordering of the dimensions, you need to combine this
+ * operation with a shuffle.
+ *
+ * \example:
+ * Tensor<float, 2, ColMajor> input(2, 4);
+ * Tensor<float, 2, RowMajor> output = input.swap_layout();
+ * eigen_assert(output.dimension(0) == 4);
+ * eigen_assert(output.dimension(1) == 2);
+ *
+ * array<int, 2> shuffle(1, 0);
+ * output = input.swap_layout().shuffle(shuffle);
+ * eigen_assert(output.dimension(0) == 2);
+ * eigen_assert(output.dimension(1) == 4);
+ *
+ */
+template <typename XprType>
+class TensorLayoutSwapOp : public TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors> {
+ public:
+  typedef TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors> Base;
+  typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorLayoutSwapOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorLayoutSwapOp(const XprType& expr) : m_xpr(expr) {}
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorLayoutSwapOp)
+ protected:
+  typename XprType::Nested m_xpr;
+};
+
+// Eval as rvalue
+template <typename ArgType, typename Device>
+struct TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> {
+  typedef TensorLayoutSwapOp<ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+
+  static constexpr int Layout =
+      (TensorEvaluator<ArgType, Device>::Layout == static_cast<int>(ColMajor)) ? RowMajor : ColMajor;
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // Layout swap is a no-op at the flat-memory level: serve blocks from the
+    // argument's raw data pointer when it has one, and otherwise forward the
+    // block request to the argument with reversed dimensions.
+    BlockAccess =
+        (TensorEvaluator<ArgType, Device>::RawAccess || TensorEvaluator<ArgType, Device>::BlockAccess) && NumDims > 0,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
+  };
+
+  // Blocks are forwarded to the argument only when it cannot hand out a flat
+  // buffer directly (the raw fast path below is cheaper).
+  static constexpr bool ForwardBlocksToArg =
+      TensorEvaluator<ArgType, Device>::BlockAccess && !TensorEvaluator<ArgType, Device>::RawAccess;
+  static constexpr int ArgLayout = TensorEvaluator<ArgType, Device>::Layout;
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  typedef typename TensorEvaluator<ArgType, Device>::TensorBlock ArgTensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {
+    for (int i = 0; i < NumDims; ++i) {
+      m_dimensions[i] = m_impl.dimensions()[NumDims - 1 - i];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) { return m_impl.evalSubExprsIfNeeded(data); }
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_impl.coeff(index); }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return m_impl.template packet<LoadMode>(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return m_impl.costPerCoeff(vectorized);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return getResourceRequirementsImpl(std::integral_constant<bool, ForwardBlocksToArg>());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool root_of_expr_ast = false) const {
+    return blockImpl(desc, scratch, root_of_expr_ast, std::integral_constant<bool, ForwardBlocksToArg>());
+  }
+
+  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return constCast(m_impl.data()); }
+
+  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+
+ protected:
+  // Sizes or strides of this expression in the argument's index order.
+  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE DSizes<Index, NumDims> reversed(const DSizes<Index, NumDims>& sizes) {
+    DSizes<Index, NumDims> result;
+    for (int i = 0; i < NumDims; ++i) result[i] = sizes[NumDims - 1 - i];
+    return result;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirementsImpl(
+      std::true_type /*forward_to_arg*/) const {
+    return m_impl.getResourceRequirements();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirementsImpl(
+      std::false_type /*forward_to_arg*/) const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  // The argument owns a flat buffer this expression is a plain view of.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock blockImpl(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                              bool /*root_of_expr_ast*/,
+                                                              std::false_type /*forward_to_arg*/) const {
+    eigen_assert(m_impl.data() != nullptr);
+    return TensorBlock::materialize(m_impl.data(), m_dimensions, desc, scratch);
+  }
+
+  // Forward the block request to the argument: reversing the descriptor's
+  // dimensions maps this block exactly onto an argument block at the same
+  // flat offset, and the swapped layout makes the two flat buffers identical.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock blockImpl(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                              bool root_of_expr_ast,
+                                                              std::true_type /*forward_to_arg*/) const {
+    const DSizes<Index, NumDims> arg_dims = reversed(desc.dimensions());
+    TensorBlockDesc arg_desc(desc.offset(), arg_dims);
+
+    // A destination buffer describes flat memory, which the layout swap leaves
+    // alone: reversing its strides alongside the dimensions hands the argument
+    // the very same bytes. A strided destination carries no valid dense
+    // expression, so it is only passed on at the root of the expression tree,
+    // where the block is written once and never read back through expr().
+    typedef typename TensorBlockDesc::DestinationBuffer DestinationBuffer;
+    const bool strided_destination = desc.destination().kind() == DestinationBuffer::kStrided;
+    if (desc.destination().kind() == DestinationBuffer::kContiguous || (strided_destination && root_of_expr_ast)) {
+      arg_desc.template AddDestinationBuffer<ArgLayout>(desc.destination().template data<ScalarNoConst>(),
+                                                        reversed(desc.destination().strides()));
+    }
+
+    ArgTensorBlock arg_block = m_impl.block(arg_desc, scratch, root_of_expr_ast);
+
+    if (arg_block.data() != NULL) {
+      // A materialized argument block already stores this block's values in
+      // this block's flat order; re-wrap the buffer with reversed dimensions.
+      const bool materialized_in_output = arg_block.kind() == internal::TensorBlockKind::kMaterializedInOutput;
+      if (materialized_in_output) desc.DropDestinationBuffer();
+      return TensorBlock(arg_block.kind(), arg_block.data(), desc.dimensions(),
+                         /*valid_expr=*/!(materialized_in_output && strided_destination));
+    }
+
+    // A lazy argument block has no buffer to share: materialize it into this
+    // block's storage, evaluating in the argument's (flat-identical) layout.
+    // The storage strides carry whichever destination prepareStorage accepted.
+    typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename ArgTensorBlock::XprType, Index>
+        ArgBlockAssign;
+    typename TensorBlock::Storage storage =
+        TensorBlock::prepareStorage(desc, scratch, /*allow_strided_storage=*/root_of_expr_ast);
+    ArgBlockAssign::Run(ArgBlockAssign::target(arg_dims, reversed(storage.strides()), storage.data()),
+                        arg_block.expr());
+    arg_block.cleanup();
+    return storage.AsTensorMaterializedBlock();
+  }
+
+  TensorEvaluator<ArgType, Device> m_impl;
+  Dimensions m_dimensions;
+};
+
+// Eval as lvalue
+template <typename ArgType, typename Device>
+struct TensorEvaluator<TensorLayoutSwapOp<ArgType>, Device>
+    : public TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> {
+  typedef TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> Base;
+  typedef TensorLayoutSwapOp<ArgType> XprType;
+
+  static constexpr int NumDims = Base::NumDims;
+  static constexpr int Layout = Base::Layout;
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // Writing a block only needs the argument's flat buffer: layout swap does
+    // not touch flat memory, so the block is assigned straight into it. The
+    // argument cannot be forwarded to as it is on the read side, because
+    // TensorBlockAssignment takes the inner dimension from the block
+    // expression's layout but the strides from the target.
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess && NumDims > 0,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false  // to be implemented
+  };
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef typename Base::TensorBlockDesc TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    return this->m_impl.coeffRef(index);
+  }
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    this->m_impl.template writePacket<StoreMode>(index, x);
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(this->m_impl.data() != NULL);
+
+    // Dense strides of the swapped dimensions in this layout are exactly the
+    // argument's flat strides, so the block expression can be assigned
+    // directly into the argument's buffer at the block's flat offset.
+    typedef typename TensorBlock::XprType TensorBlockExpr;
+    typedef internal::TensorBlockAssignment<Scalar, NumDims, TensorBlockExpr, Index> TensorBlockAssign;
+
+    TensorBlockAssign::Run(TensorBlockAssign::target(desc.dimensions(), internal::strides<Layout>(this->dimensions()),
+                                                     this->m_impl.data(), desc.offset()),
+                           block.expr());
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_LAYOUT_SWAP_H
diff --git a/contrib/Eigen/src/Tensor/TensorMacros.h b/contrib/Eigen/src/Tensor/TensorMacros.h
new file mode 100644
index 0000000..1bdf913
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorMacros.h
@@ -0,0 +1,60 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_META_MACROS_H
+#define EIGEN_TENSOR_TENSOR_META_MACROS_H
+
+/** use this macro in sfinae selection in templated functions
+ *
+ *   template<typename T,
+ *            std::enable_if_t< isBanana<T>::value , int > = 0
+ *   >
+ *   void foo(){}
+ *
+ *   becomes =>
+ *
+ *   template<typename T,
+ *           EIGEN_SFINAE_ENABLE_IF( isBanana<T>::value )
+ *   >
+ *   void foo(){}
+ */
+
+#define EIGEN_SFINAE_ENABLE_IF(__condition__) std::enable_if_t<(__condition__), int> = 0
+
+// Define a macro to use a reference on the host but a value on the device
+#if defined(SYCL_DEVICE_ONLY)
+#define EIGEN_DEVICE_REF
+#else
+#define EIGEN_DEVICE_REF &
+#endif
+
+// Define a macro for catching SYCL exceptions if exceptions are enabled
+#define EIGEN_SYCL_TRY_CATCH(X)                                                                                        \
+  do {                                                                                                                 \
+    EIGEN_TRY { X; }                                                                                                   \
+    EIGEN_CATCH(const cl::sycl::exception& e) {                                                                        \
+      EIGEN_THROW_X(std::runtime_error("SYCL exception at " + std::string(__FILE__) + ":" + std::to_string(__LINE__) + \
+                                       "\n" + e.what()));                                                              \
+    }                                                                                                                  \
+  } while (false)
+
+// Define a macro if local memory flags are unset or one of them is set
+// Setting both flags is the same as unsetting them
+#if (!defined(EIGEN_SYCL_LOCAL_MEM) && !defined(EIGEN_SYCL_NO_LOCAL_MEM)) || \
+    (defined(EIGEN_SYCL_LOCAL_MEM) && defined(EIGEN_SYCL_NO_LOCAL_MEM))
+#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON 1
+#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF 1
+#elif defined(EIGEN_SYCL_LOCAL_MEM) && !defined(EIGEN_SYCL_NO_LOCAL_MEM)
+#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON 1
+#elif !defined(EIGEN_SYCL_LOCAL_MEM) && defined(EIGEN_SYCL_NO_LOCAL_MEM)
+#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF 1
+#endif
+
+#endif
diff --git a/contrib/Eigen/src/Tensor/TensorMap.h b/contrib/Eigen/src/Tensor/TensorMap.h
new file mode 100644
index 0000000..7c35633
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorMap.h
@@ -0,0 +1,190 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_MAP_H
+#define EIGEN_TENSOR_TENSOR_MAP_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+// FIXME: Use proper doxygen documentation (e.g. \tparam MakePointer_).
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief A tensor expression mapping an existing array of data.
+ *
+ */
+/// `template <class> class MakePointer_` is added to convert the host pointer to the device pointer.
+/// It is added due to the fact that for our device compiler `T*` is not allowed.
+/// If we wanted to use the same Evaluator functions we have to convert that type to our pointer `T`.
+/// This is done through our `MakePointer_` class. By default the Type in the `MakePointer_<T>` is `T*`.
+/// Therefore, by adding the default value, we managed to convert the type and it does not break any
+/// existing code as its default value is `T*`.
+template <typename PlainObjectType, int Options_, template <class> class MakePointer_>
+class TensorMap : public TensorBase<TensorMap<PlainObjectType, Options_, MakePointer_> > {
+ public:
+  typedef TensorMap<PlainObjectType, Options_, MakePointer_> Self;
+  typedef TensorBase<TensorMap<PlainObjectType, Options_, MakePointer_> > Base;
+#ifdef EIGEN_USE_SYCL
+  typedef std::remove_reference_t<typename Eigen::internal::ref_selector<Self>::type> Nested;
+#else
+  typedef typename Eigen::internal::ref_selector<Self>::type Nested;
+#endif
+  typedef typename internal::traits<PlainObjectType>::StorageKind StorageKind;
+  typedef typename internal::traits<PlainObjectType>::Index Index;
+  typedef typename internal::traits<PlainObjectType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename PlainObjectType::Base::CoeffReturnType CoeffReturnType;
+
+  typedef typename MakePointer_<Scalar>::Type PointerType;
+  typedef typename MakePointer_<Scalar>::ConstType PointerConstType;
+
+  // WARN: PointerType still can be a pointer to const (const Scalar*), for
+  // example in TensorMap<Tensor<const Scalar, ...>> expression. This type of
+  // expression should be illegal, but adding this restriction is not possible
+  // in practice (see https://bitbucket.org/eigen/eigen/pull-requests/488).
+  typedef std::conditional_t<bool(internal::is_lvalue<PlainObjectType>::value),
+                             PointerType,      // use simple pointer in lvalue expressions
+                             PointerConstType  // use const pointer in rvalue expressions
+                             >
+      StoragePointerType;
+
+  // If TensorMap was constructed over rvalue expression (e.g. const Tensor),
+  // we should return a reference to const from operator() (and others), even
+  // if TensorMap itself is not const.
+  typedef std::conditional_t<bool(internal::is_lvalue<PlainObjectType>::value), Scalar&, const Scalar&> StorageRefType;
+
+  static constexpr int Options = Options_;
+
+  static constexpr Index NumIndices = PlainObjectType::NumIndices;
+  typedef typename PlainObjectType::Dimensions Dimensions;
+
+  static constexpr int Layout = PlainObjectType::Layout;
+  enum { IsAligned = ((int(Options_) & Aligned) == Aligned), CoordAccess = true, RawAccess = true };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr) : m_data(dataPtr), m_dimensions() {
+    // The number of dimensions used to construct a tensor must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT((0 == NumIndices || NumIndices == Dynamic), YOU_MADE_A_PROGRAMMING_MISTAKE)
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index firstDimension,
+                                                  IndexTypes... otherDimensions)
+      : m_data(dataPtr), m_dimensions(firstDimension, otherDimensions...) {
+    // The number of dimensions used to construct a tensor must be equal to the rank of the tensor.
+    EIGEN_STATIC_ASSERT((sizeof...(otherDimensions) + 1 == NumIndices || NumIndices == Dynamic),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE)
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr,
+                                                  const array<Index, NumIndices>& dimensions)
+      : m_data(dataPtr), m_dimensions(dimensions) {}
+
+  template <typename Dimensions>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, const Dimensions& dimensions)
+      : m_data(dataPtr), m_dimensions(dimensions) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(PlainObjectType& tensor)
+      : m_data(tensor.data()), m_dimensions(tensor.dimensions()) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return m_dimensions.rank(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(Index n) const { return m_dimensions[n]; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_dimensions.TotalSize(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StoragePointerType data() { return m_data; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StoragePointerType data() const { return m_data; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(const array<Index, NumIndices>& indices) const {
+    EIGEN_IF_CONSTEXPR (PlainObjectType::Options & RowMajor) {
+      const Index index = m_dimensions.IndexOfRowMajor(indices);
+      return m_data[index];
+    } else {
+      const Index index = m_dimensions.IndexOfColMajor(indices);
+      return m_data[index];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()() const {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    return m_data[0];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index index) const {
+    eigen_internal_assert(index >= 0 && index < size());
+    return m_data[index];
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index firstIndex, Index secondIndex,
+                                                                  IndexTypes... otherIndices) const {
+    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    EIGEN_IF_CONSTEXPR (PlainObjectType::Options & RowMajor) {
+      const Index index = m_dimensions.IndexOfRowMajor(
+          array<Index, NumIndices>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+      return m_data[index];
+    } else {
+      const Index index = m_dimensions.IndexOfColMajor(
+          array<Index, NumIndices>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+      return m_data[index];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(const array<Index, NumIndices>& indices) {
+    EIGEN_IF_CONSTEXPR (PlainObjectType::Options & RowMajor) {
+      const Index index = m_dimensions.IndexOfRowMajor(indices);
+      return m_data[index];
+    } else {
+      const Index index = m_dimensions.IndexOfColMajor(indices);
+      return m_data[index];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()() {
+    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE)
+    return m_data[0];
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index index) {
+    eigen_internal_assert(index >= 0 && index < size());
+    return m_data[index];
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index firstIndex, Index secondIndex,
+                                                                  IndexTypes... otherIndices) {
+    static_assert(sizeof...(otherIndices) + 2 == NumIndices || NumIndices == Dynamic,
+                  "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    const std::size_t NumDims = sizeof...(otherIndices) + 2;
+    EIGEN_IF_CONSTEXPR (PlainObjectType::Options & RowMajor) {
+      const Index index = m_dimensions.IndexOfRowMajor(
+          array<Index, NumDims>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+      return m_data[index];
+    } else {
+      const Index index = m_dimensions.IndexOfColMajor(
+          array<Index, NumDims>{{firstIndex, secondIndex, static_cast<Index>(otherIndices)...}});
+      return m_data[index];
+    }
+  }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorMap)
+
+ private:
+  StoragePointerType m_data;
+  Dimensions m_dimensions;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_MAP_H
diff --git a/contrib/Eigen/src/Tensor/TensorMeta.h b/contrib/Eigen/src/Tensor/TensorMeta.h
new file mode 100644
index 0000000..0fc5805
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorMeta.h
@@ -0,0 +1,301 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_META_H
+#define EIGEN_TENSOR_TENSOR_META_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+template <bool cond>
+struct Cond {};
+
+template <typename T1, typename T2>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1& choose(Cond<true>, const T1& first, const T2&) {
+  return first;
+}
+
+template <typename T1, typename T2>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T2& choose(Cond<false>, const T1&, const T2& second) {
+  return second;
+}
+
+template <size_t n>
+struct max_n_1 {
+  static constexpr size_t size = n;
+};
+template <>
+struct max_n_1<0> {
+  static constexpr size_t size = 1;
+};
+
+template <typename T>
+EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr T divup(const T x, const T y) {
+  return Eigen::numext::div_ceil(x, y);
+}
+
+// Default packet types
+template <typename Scalar, typename Device>
+struct PacketType : internal::packet_traits<Scalar> {
+  typedef typename internal::packet_traits<Scalar>::type type;
+};
+
+// For CUDA packet types when using a GpuDevice
+#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPU_COMPILE_PHASE)
+
+typedef ulonglong2 Packet4h2;
+template <>
+struct PacketType<half, GpuDevice> {
+  typedef Packet4h2 type;
+  static constexpr int size = 8;
+  enum {
+    HasAdd = 1,
+    HasSub = 1,
+    HasMul = 1,
+    HasNegate = 1,
+    HasAbs = 1,
+    HasArg = 0,
+    HasAbs2 = 0,
+    HasMin = 1,
+    HasMax = 1,
+    HasConj = 0,
+    HasSetLinear = 0,
+    HasBlend = 0,
+
+    HasDiv = 1,
+    HasSqrt = 1,
+    HasRsqrt = 1,
+    HasExp = 1,
+    HasExpm1 = 0,
+    HasLog = 1,
+    HasLog1p = 0,
+    HasLog10 = 0,
+    HasPow = 1,
+  };
+};
+#endif
+
+#if defined(EIGEN_USE_SYCL)
+
+namespace TensorSycl {
+namespace internal {
+
+template <typename Index, Index A, Index B>
+struct PlusOp {
+  static constexpr Index Value = A + B;
+};
+
+template <typename Index, Index A, Index B>
+struct DivOp {
+  static constexpr Index Value = A / B;
+};
+
+template <typename Index, Index start, Index end, Index step, template <class Indx, Indx...> class StepOp>
+struct static_for {
+  template <typename UnaryOperator>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void loop(UnaryOperator op) {
+    op(start);
+    static_for<Index, StepOp<Index, start, step>::Value, end, step, StepOp>::loop(op);
+  }
+};
+template <typename Index, Index end, Index step, template <class Indx, Indx...> class StepOp>
+struct static_for<Index, end, end, step, StepOp> {
+  template <typename UnaryOperator>
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void loop(UnaryOperator) {}
+};
+
+template <typename OutScalar, typename Device, bool Vectorizable>
+struct Vectorise {
+  static constexpr int PacketSize = 1;
+  typedef OutScalar PacketReturnType;
+};
+
+template <typename OutScalar, typename Device>
+struct Vectorise<OutScalar, Device, true> {
+  static constexpr int PacketSize = Eigen::PacketType<OutScalar, Device>::size;
+  typedef typename Eigen::PacketType<OutScalar, Device>::type PacketReturnType;
+};
+
+static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index roundUp(Index x, Index y) { return ((((x) + (y)-1) / (y)) * (y)); }
+
+}  // namespace internal
+}  // namespace TensorSycl
+
+template <>
+struct PacketType<half, SyclDevice> {
+  typedef half type;
+  static constexpr int size = 1;
+  enum {
+    HasAdd = 0,
+    HasSub = 0,
+    HasMul = 0,
+    HasNegate = 0,
+    HasAbs = 0,
+    HasArg = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 0,
+    HasSetLinear = 0,
+    HasBlend = 0
+  };
+};
+template <typename Scalar>
+struct PacketType<Scalar, SyclDevice> : internal::default_packet_traits {
+  typedef Scalar type;
+  typedef Scalar half;
+  enum {
+    Vectorizable = 0,
+    size = 1,
+    AlignedOnScalar = 0,
+  };
+  enum {
+    HasAdd = 0,
+    HasSub = 0,
+    HasMul = 0,
+    HasNegate = 0,
+    HasAbs = 0,
+    HasAbs2 = 0,
+    HasMin = 0,
+    HasMax = 0,
+    HasConj = 0,
+    HasSetLinear = 0
+  };
+};
+
+template <typename Scalar>
+struct PacketType<Scalar, const SyclDevice> : PacketType<Scalar, SyclDevice> {};
+
+#ifndef EIGEN_DONT_VECTORIZE_SYCL
+#define PACKET_TYPE(CVQual, Type, val, lengths, DEV)                                 \
+  template <>                                                                        \
+  struct PacketType<CVQual Type, DEV> : internal::sycl_packet_traits<val, lengths> { \
+    typedef typename internal::packet_traits<Type>::type type;                       \
+    typedef typename internal::packet_traits<Type>::half half;                       \
+  };
+
+PACKET_TYPE(const, float, 1, 4, SyclDevice)
+PACKET_TYPE(, float, 1, 4, SyclDevice)
+PACKET_TYPE(const, float, 1, 4, const SyclDevice)
+PACKET_TYPE(, float, 1, 4, const SyclDevice)
+
+PACKET_TYPE(const, double, 0, 2, SyclDevice)
+PACKET_TYPE(, double, 0, 2, SyclDevice)
+PACKET_TYPE(const, double, 0, 2, const SyclDevice)
+PACKET_TYPE(, double, 0, 2, const SyclDevice)
+#undef PACKET_TYPE
+
+template <>
+struct PacketType<half, const SyclDevice> : PacketType<half, SyclDevice> {};
+template <>
+struct PacketType<const half, const SyclDevice> : PacketType<half, SyclDevice> {};
+#endif
+#endif
+
+// Pair mimics std::pair but works on e.g. nvcc.
+template <typename U, typename V>
+struct Pair {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+  U first{};
+  V second{};
+
+  typedef U first_type;
+  typedef V second_type;
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Pair() = default;
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Pair(const U& f, const V& s) : first(f), second(s) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(Pair& rhs) {
+    using numext::swap;
+    swap(first, rhs.first);
+    swap(second, rhs.second);
+  }
+};
+
+template <typename U, typename V>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const Pair<U, V>& x, const Pair<U, V>& y) {
+  return x.first == y.first && x.second == y.second;
+}
+
+template <typename U, typename V>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator!=(const Pair<U, V>& x, const Pair<U, V>& y) {
+  return !(x == y);
+}
+
+// Can't use std::pairs on cuda devices
+template <typename Idx>
+struct IndexPair {
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair() = default;
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair(Idx f, Idx s) : first(f), second(s) {}
+
+  EIGEN_DEVICE_FUNC void set(IndexPair<Idx> val) {
+    first = val.first;
+    second = val.second;
+  }
+
+  Idx first = Idx(0);
+  Idx second = Idx(0);
+};
+
+namespace internal {
+
+template <typename IndexType, typename Index, Index First, Index... Is>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, 1 + sizeof...(Is)> customIndices2Array(
+    IndexType& idx, std::integer_sequence<Index, First, Is...>) {
+  return {static_cast<Index>(idx[First]), static_cast<Index>(idx[Is])...};
+}
+template <typename IndexType, typename Index>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, 0> customIndices2Array(IndexType&,
+                                                                                    std::integer_sequence<Index>) {
+  return array<Index, 0>();
+}
+
+/** Make an array (for index/dimensions) out of a custom index */
+template <typename Index, std::size_t NumIndices, typename IndexType>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, NumIndices> customIndices2Array(IndexType& idx) {
+  return customIndices2Array(idx, std::make_integer_sequence<Index, NumIndices>{});
+}
+
+/** \internal Whether converting \a index to \a Index preserves its value.
+ *
+ * The round trip catches truncation and the sign comparison catches a same-width unsigned value reinterpreted as
+ * negative, which round trips exactly. Both tests compare operands of one type, unlike a bound check against
+ * NumTraits<Index>::highest(), which mixes signedness whenever \a T is unsigned. Types that are not built-in
+ * integers reach \a Index through their own conversion operator and are left unchecked.
+ */
+template <typename Index, typename T,
+          std::enable_if_t<std::is_integral<T>::value && std::is_integral<Index>::value, bool> = true>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool index_fits(T index) {
+  return static_cast<T>(static_cast<Index>(index)) == index &&
+         (numext::signbit(static_cast<Index>(index)) == Index(0)) == (numext::signbit(index) == T(0));
+}
+
+template <typename Index, typename T,
+          std::enable_if_t<!(std::is_integral<T>::value && std::is_integral<Index>::value), bool> = true>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool index_fits(const T&) {
+  return true;
+}
+
+/** \internal Whether every index in the pack converts to \a Index without changing value. */
+template <typename Index, typename... IndexTypes>
+constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool indices_fit(IndexTypes... indices) {
+  return all(index_fits<Index>(indices)...);
+}
+
+}  // namespace internal
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_META_H
diff --git a/contrib/Eigen/src/Tensor/TensorMorphing.h b/contrib/Eigen/src/Tensor/TensorMorphing.h
new file mode 100644
index 0000000..eb7a364
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorMorphing.h
@@ -0,0 +1,1195 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_MORPHING_H
+#define EIGEN_TENSOR_TENSOR_MORPHING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename NewDimensions, typename XprType>
+struct traits<TensorReshapingOp<NewDimensions, XprType>> : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = array_size<NewDimensions>::value;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename NewDimensions, typename XprType>
+struct eval<TensorReshapingOp<NewDimensions, XprType>, Eigen::Dense> {
+  typedef const TensorReshapingOp<NewDimensions, XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor reshaping class.
+ */
+template <typename NewDimensions, typename XprType>
+class TensorReshapingOp : public TensorBase<TensorReshapingOp<NewDimensions, XprType>, WriteAccessors> {
+ public:
+  typedef TensorBase<TensorReshapingOp<NewDimensions, XprType>, WriteAccessors> Base;
+  typedef typename Eigen::internal::traits<TensorReshapingOp>::Scalar Scalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorReshapingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorReshapingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorReshapingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReshapingOp(const XprType& expr, const NewDimensions& dims)
+      : m_xpr(expr), m_dims(dims) {}
+
+  EIGEN_DEVICE_FUNC const NewDimensions& dimensions() const { return m_dims; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorReshapingOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const NewDimensions m_dims;
+};
+
+// Eval as rvalue
+template <typename NewDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorReshapingOp<NewDimensions, ArgType>, Device> {
+  typedef TensorReshapingOp<NewDimensions, ArgType> XprType;
+  typedef NewDimensions Dimensions;
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  typedef StorageMemory<std::remove_const_t<CoeffReturnType>, Device> ConstCastStorage;
+
+  static constexpr int NumOutputDims = internal::array_size<Dimensions>::value;
+  static constexpr int NumInputDims =
+      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+
+  enum ReshapingKind {
+    // We do not use layout information to determine reshaping kind.
+    // Depending on the layout `N` can be inner or outer dimension.
+    OneByN = 0,  // expr.reshape(1, N)
+    NByOne = 1,  // expr.reshape(N, 1)
+    Runtime = 2  // Reshape dimensions are dynamic (specified at runtime).
+  };
+
+  // clang-format off
+  static const ReshapingKind kind =
+        (NumOutputDims == 2 && internal::index_statically_eq<NewDimensions>(/*index=*/0, /*value=*/1)) ? OneByN
+      : (NumOutputDims == 2 && internal::index_statically_eq<NewDimensions>(/*index=*/1, /*value=*/1)) ? NByOne
+      : Runtime;
+  // clang-format on
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // For trivial reshapes with raw access to underlying data we will provide
+    // zero overhead block access.
+    // TODO(ezhulenev): Consider adding block access without raw access?
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess && NumInputDims > 0 && NumOutputDims > 0,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumOutputDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumOutputDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_dimensions(op.dimensions()) {
+    // The total size of the reshaped tensor must be equal to the total size
+    // of the input tensor.
+    eigen_assert(internal::array_prod(m_impl.dimensions()) == internal::array_prod(op.dimensions()));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType data, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(data, std::move(done));
+  }
+#endif
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) { return m_impl.evalSubExprsIfNeeded(data); }
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_impl.coeff(index); }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    return m_impl.template packet<LoadMode>(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return m_impl.costPerCoeff(vectorized);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  struct BlockIteratorState {
+    Index stride;
+    Index span;
+    Index size;
+    Index count;
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_impl.data() != nullptr);
+    eigen_assert((kind == Runtime) || (kind == OneByN && desc.dimensions()[0] == 1) ||
+                 (kind == NByOne && desc.dimensions()[1] == 1));
+
+    if (kind == OneByN || kind == NByOne) {
+      // We can guarantee at compile time that block is just a contiguous slice
+      // of the underlying expression memory buffer.
+      return TensorBlock(internal::TensorBlockKind::kView, m_impl.data() + desc.offset(), desc.dimensions());
+    } else {
+      // This will do additional runtime checks, and in the end it might be also
+      // a view, or it might be a block materialized in the temporary buffer.
+      return TensorBlock::materialize(m_impl.data(), m_dimensions, desc, scratch);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return constCast(m_impl.data()); }
+
+  EIGEN_DEVICE_FUNC const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+
+ protected:
+  TensorEvaluator<ArgType, Device> m_impl;
+  NewDimensions m_dimensions;
+};
+
+// Eval as lvalue
+template <typename NewDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<TensorReshapingOp<NewDimensions, ArgType>, Device>
+    : public TensorEvaluator<const TensorReshapingOp<NewDimensions, ArgType>, Device>
+
+{
+  typedef TensorEvaluator<const TensorReshapingOp<NewDimensions, ArgType>, Device> Base;
+  typedef TensorReshapingOp<NewDimensions, ArgType> XprType;
+  typedef NewDimensions Dimensions;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
+  };
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<TensorEvaluator::NumOutputDims, Index> TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    return this->m_impl.coeffRef(index);
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    this->m_impl.template writePacket<StoreMode>(index, x);
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(this->m_impl.data() != nullptr);
+
+    typedef typename TensorBlock::XprType TensorBlockExpr;
+    typedef internal::TensorBlockAssignment<Scalar, TensorEvaluator::NumOutputDims, TensorBlockExpr, Index>
+        TensorBlockAssign;
+
+    TensorBlockAssign::Run(TensorBlockAssign::target(desc.dimensions(), internal::strides<Layout>(this->dimensions()),
+                                                     this->m_impl.data(), desc.offset()),
+                           block.expr());
+  }
+};
+
+/** \class TensorSlicing
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor slicing class.
+ *
+ *
+ */
+namespace internal {
+template <typename StartIndices, typename Sizes, typename XprType>
+struct traits<TensorSlicingOp<StartIndices, Sizes, XprType>> : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = array_size<StartIndices>::value;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename StartIndices, typename Sizes, typename XprType>
+struct eval<TensorSlicingOp<StartIndices, Sizes, XprType>, Eigen::Dense> {
+  typedef const TensorSlicingOp<StartIndices, Sizes, XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+template <typename StartIndices, typename Sizes, typename XprType>
+class TensorSlicingOp : public TensorBase<TensorSlicingOp<StartIndices, Sizes, XprType>> {
+ public:
+  typedef TensorBase<TensorSlicingOp<StartIndices, Sizes, XprType>> Base;
+  typedef typename Eigen::internal::traits<TensorSlicingOp>::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorSlicingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorSlicingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorSlicingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorSlicingOp(const XprType& expr, const StartIndices& indices,
+                                                        const Sizes& sizes)
+      : m_xpr(expr), m_indices(indices), m_sizes(sizes) {}
+
+  EIGEN_DEVICE_FUNC const StartIndices& startIndices() const { return m_indices; }
+  EIGEN_DEVICE_FUNC const Sizes& sizes() const { return m_sizes; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorSlicingOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const StartIndices m_indices;
+  const Sizes m_sizes;
+};
+
+namespace internal {
+
+// FIXME: Figure out the exact threshold.
+template <typename Index, typename Device, bool BlockAccess>
+struct MemcpyTriggerForSlicing {
+  EIGEN_DEVICE_FUNC MemcpyTriggerForSlicing(const Device& device)
+      : threshold_(static_cast<Index>(2 * device.numThreads())) {}
+  EIGEN_DEVICE_FUNC bool operator()(Index total, Index contiguous) const {
+    const bool prefer_block_evaluation = BlockAccess && total > 32 * 1024;
+    return !prefer_block_evaluation && contiguous > threshold_;
+  }
+
+ private:
+  Index threshold_;
+};
+
+// It is very expensive to start the memcpy kernel on GPU: we therefore only
+// use it for large copies.
+#ifdef EIGEN_USE_GPU
+template <typename Index, bool BlockAccess>
+struct MemcpyTriggerForSlicing<Index, GpuDevice, BlockAccess> {
+  EIGEN_DEVICE_FUNC MemcpyTriggerForSlicing(const GpuDevice&) {}
+  EIGEN_DEVICE_FUNC bool operator()(Index, Index contiguous) const { return contiguous > 4 * 1024 * 1024; }
+};
+#endif
+
+// It is very expensive to start the memcpy kernel on GPU: we therefore only
+// use it for large copies.
+#ifdef EIGEN_USE_SYCL
+template <typename Index, bool BlockAccess>
+struct MemcpyTriggerForSlicing<Index, Eigen::SyclDevice, BlockAccess> {
+  EIGEN_DEVICE_FUNC MemcpyTriggerForSlicing(const SyclDevice&) {}
+  EIGEN_DEVICE_FUNC bool operator()(Index, Index contiguous) const { return contiguous > 4 * 1024 * 1024; }
+};
+#endif
+
+}  // namespace internal
+
+// Eval as rvalue
+template <typename StartIndices, typename Sizes, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Device> {
+  typedef TensorSlicingOp<StartIndices, Sizes, ArgType> XprType;
+  static constexpr int NumDims = internal::array_size<Sizes>::value;
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef Sizes Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef StorageMemory<std::remove_const_t<CoeffReturnType>, Device> ConstCastStorage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    // Alignment can't be guaranteed at compile time since it depends on the
+    // slice offsets and sizes.
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
+    PreferBlockAccess = true,
+    CoordAccess = false,
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  // Tensor slicing does not change the block type.
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_device(device), m_dimensions(op.sizes()), m_offsets(op.startIndices()) {
+    m_is_identity = true;
+    for (int i = 0; i < internal::array_size<Dimensions>::value; ++i) {
+      eigen_assert(m_impl.dimensions()[i] >= op.sizes()[i] + op.startIndices()[i]);
+      if (m_impl.dimensions()[i] != op.sizes()[i] || op.startIndices()[i] != 0) {
+        m_is_identity = false;
+      }
+    }
+
+    initStrides(m_impl.dimensions(), op.sizes());
+  }
+
+  template <int ND = NumDims>
+  EIGEN_STRONG_INLINE std::enable_if_t<ND == 0, void> initStrides(
+      const typename TensorEvaluator<ArgType, Device>::Dimensions& /*input_dims*/, const Sizes& /*output_dims*/) {}
+
+  template <int ND = NumDims>
+  EIGEN_STRONG_INLINE std::enable_if_t<(ND > 0), void> initStrides(
+      const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims, const Sizes& output_dims) {
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputStrides[0] = 1;
+      for (int i = 1; i < ND; ++i) {
+        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
+      }
+
+      // Don't initialize m_fastOutputStrides[0] since it won't ever be accessed.
+      m_outputStrides[0] = 1;
+      for (int i = 1; i < ND; ++i) {
+        m_outputStrides[i] = m_outputStrides[i - 1] * output_dims[i - 1];
+        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
+      }
+    } else {
+      m_inputStrides[ND - 1] = 1;
+      for (int i = ND - 2; i >= 0; --i) {
+        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
+      }
+
+      // Don't initialize m_fastOutputStrides[NumDims-1] since it won't ever be accessed.
+      m_outputStrides[ND - 1] = 1;
+      for (int i = ND - 2; i >= 0; --i) {
+        m_outputStrides[i] = m_outputStrides[i + 1] * output_dims[i + 1];
+        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    EIGEN_IF_CONSTEXPR (!NumTraits<std::remove_const_t<Scalar>>::RequireInitialization) {
+      if (data && m_impl.data()) {
+        Index contiguous_values = 1;
+        EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+          for (int i = 0; i < NumDims; ++i) {
+            contiguous_values *= dimensions()[i];
+            if (dimensions()[i] != m_impl.dimensions()[i]) {
+              break;
+            }
+          }
+        } else {
+          for (int i = NumDims - 1; i >= 0; --i) {
+            contiguous_values *= dimensions()[i];
+            if (dimensions()[i] != m_impl.dimensions()[i]) {
+              break;
+            }
+          }
+        }
+        // Use memcpy if it's going to be faster than using the regular evaluation.
+        const internal::MemcpyTriggerForSlicing<Index, Device, BlockAccess> trigger(m_device);
+        if (trigger(internal::array_prod(dimensions()), contiguous_values)) {
+          EvaluatorPointerType src = (EvaluatorPointerType)m_impl.data();
+          for (Index i = 0; i < internal::array_prod(dimensions()); i += contiguous_values) {
+            Index offset = srcCoeff(i);
+            m_device.memcpy((void*)(m_device.get(data + i)), m_device.get(src + offset),
+                            contiguous_values * sizeof(Scalar));
+          }
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType /*data*/, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    if (m_is_identity) {
+      return m_impl.coeff(index);
+    } else {
+      return m_impl.coeff(srcCoeff(index));
+    }
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    const int packetSize = PacketType<CoeffReturnType, Device>::size;
+    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(index + packetSize - 1 < internal::array_prod(dimensions()));
+
+    if (m_is_identity) {
+      return m_impl.template packet<LoadMode>(index);
+    }
+
+    Index inputIndices[] = {0, 0};
+    Index indices[] = {index, index + packetSize - 1};
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx0 = indices[0] / m_fastOutputStrides[i];
+        const Index idx1 = indices[1] / m_fastOutputStrides[i];
+        inputIndices[0] += (idx0 + m_offsets[i]) * m_inputStrides[i];
+        inputIndices[1] += (idx1 + m_offsets[i]) * m_inputStrides[i];
+        indices[0] -= idx0 * m_outputStrides[i];
+        indices[1] -= idx1 * m_outputStrides[i];
+      }
+      inputIndices[0] += (indices[0] + m_offsets[0]);
+      inputIndices[1] += (indices[1] + m_offsets[0]);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx0 = indices[0] / m_fastOutputStrides[i];
+        const Index idx1 = indices[1] / m_fastOutputStrides[i];
+        inputIndices[0] += (idx0 + m_offsets[i]) * m_inputStrides[i];
+        inputIndices[1] += (idx1 + m_offsets[i]) * m_inputStrides[i];
+        indices[0] -= idx0 * m_outputStrides[i];
+        indices[1] -= idx1 * m_outputStrides[i];
+      }
+      inputIndices[0] += (indices[0] + m_offsets[NumDims - 1]);
+      inputIndices[1] += (indices[1] + m_offsets[NumDims - 1]);
+    }
+    if (inputIndices[1] - inputIndices[0] == packetSize - 1) {
+      PacketReturnType rslt = m_impl.template packet<Unaligned>(inputIndices[0]);
+      return rslt;
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[packetSize];
+      values[0] = m_impl.coeff(inputIndices[0]);
+      values[packetSize - 1] = m_impl.coeff(inputIndices[1]);
+      EIGEN_UNROLL_LOOP
+      for (int i = 1; i < packetSize - 1; ++i) {
+        values[i] = coeff(index + i);
+      }
+      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+      return rslt;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, m_is_identity ? 1 : NumDims);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.lastLevelCacheSize();
+    return internal::TensorBlockResourceRequirements::merge(
+        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size), m_impl.getResourceRequirements());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    TensorBlockDesc arg_desc = desc.WithOffset(srcCoeff(desc.offset()));
+    TensorBlock block = m_impl.block(arg_desc, scratch);
+    if (!arg_desc.HasDestinationBuffer()) desc.DropDestinationBuffer();
+    return block;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Storage::Type data() const {
+    typename Storage::Type result = constCast(m_impl.data());
+    if (result) {
+      Index offset = 0;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        for (int i = 0; i < NumDims; ++i) {
+          if (m_dimensions[i] != m_impl.dimensions()[i]) {
+            offset += m_offsets[i] * m_inputStrides[i];
+            for (int j = i + 1; j < NumDims; ++j) {
+              if (m_dimensions[j] > 1) {
+                return nullptr;
+              }
+              offset += m_offsets[j] * m_inputStrides[j];
+            }
+            break;
+          }
+        }
+      } else {
+        for (int i = NumDims - 1; i >= 0; --i) {
+          if (m_dimensions[i] != m_impl.dimensions()[i]) {
+            offset += m_offsets[i] * m_inputStrides[i];
+            for (int j = i - 1; j >= 0; --j) {
+              if (m_dimensions[j] > 1) {
+                return nullptr;
+              }
+              offset += m_offsets[j] * m_inputStrides[j];
+            }
+            break;
+          }
+        }
+      }
+      return result + offset;
+    }
+    return nullptr;
+  }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const { return srcCoeffImpl(index); }
+
+  template <int ND = NumDims>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<ND == 0, Index> srcCoeffImpl(Index /*index*/) const {
+    return 0;
+  }
+
+  template <int ND = NumDims>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<(ND > 0), Index> srcCoeffImpl(Index index) const {
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = ND - 1; i > 0; --i) {
+        const Index idx = index / m_fastOutputStrides[i];
+        inputIndex += (idx + m_offsets[i]) * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inputIndex += (index + m_offsets[0]);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < ND - 1; ++i) {
+        const Index idx = index / m_fastOutputStrides[i];
+        inputIndex += (idx + m_offsets[i]) * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inputIndex += (index + m_offsets[ND - 1]);
+    }
+    return inputIndex;
+  }
+
+  array<Index, NumDims> m_outputStrides;
+  array<internal::TensorIntDivisor<Index>, NumDims> m_fastOutputStrides;
+  array<Index, NumDims> m_inputStrides;
+  TensorEvaluator<ArgType, Device> m_impl;
+  const Device EIGEN_DEVICE_REF m_device;
+  Dimensions m_dimensions;
+  bool m_is_identity;
+  const StartIndices m_offsets;
+};
+
+// Eval as lvalue
+template <typename StartIndices, typename Sizes, typename ArgType, typename Device>
+struct TensorEvaluator<TensorSlicingOp<StartIndices, Sizes, ArgType>, Device>
+    : public TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Device> Base;
+  typedef TensorSlicingOp<StartIndices, Sizes, ArgType> XprType;
+  static constexpr int NumDims = internal::array_size<Sizes>::value;
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef Sizes Dimensions;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
+    PreferBlockAccess = true,
+    CoordAccess = false,
+    RawAccess = (NumDims == 1) & TensorEvaluator<ArgType, Device>::RawAccess
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    if (this->m_is_identity) {
+      return this->m_impl.coeffRef(index);
+    } else {
+      return this->m_impl.coeffRef(this->srcCoeff(index));
+    }
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    if (this->m_is_identity) {
+      this->m_impl.template writePacket<StoreMode>(index, x);
+      return;
+    }
+
+    const int packetSize = PacketType<CoeffReturnType, Device>::size;
+    Index inputIndices[] = {0, 0};
+    Index indices[] = {index, index + packetSize - 1};
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx0 = indices[0] / this->m_fastOutputStrides[i];
+        const Index idx1 = indices[1] / this->m_fastOutputStrides[i];
+        inputIndices[0] += (idx0 + this->m_offsets[i]) * this->m_inputStrides[i];
+        inputIndices[1] += (idx1 + this->m_offsets[i]) * this->m_inputStrides[i];
+        indices[0] -= idx0 * this->m_outputStrides[i];
+        indices[1] -= idx1 * this->m_outputStrides[i];
+      }
+      inputIndices[0] += (indices[0] + this->m_offsets[0]);
+      inputIndices[1] += (indices[1] + this->m_offsets[0]);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx0 = indices[0] / this->m_fastOutputStrides[i];
+        const Index idx1 = indices[1] / this->m_fastOutputStrides[i];
+        inputIndices[0] += (idx0 + this->m_offsets[i]) * this->m_inputStrides[i];
+        inputIndices[1] += (idx1 + this->m_offsets[i]) * this->m_inputStrides[i];
+        indices[0] -= idx0 * this->m_outputStrides[i];
+        indices[1] -= idx1 * this->m_outputStrides[i];
+      }
+      inputIndices[0] += (indices[0] + this->m_offsets[NumDims - 1]);
+      inputIndices[1] += (indices[1] + this->m_offsets[NumDims - 1]);
+    }
+    if (inputIndices[1] - inputIndices[0] == packetSize - 1) {
+      this->m_impl.template writePacket<StoreMode>(inputIndices[0], x);
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      CoeffReturnType values[packetSize];
+      internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+      this->m_impl.coeffRef(inputIndices[0]) = values[0];
+      this->m_impl.coeffRef(inputIndices[1]) = values[packetSize - 1];
+      EIGEN_UNROLL_LOOP
+      for (int i = 1; i < packetSize - 1; ++i) {
+        this->coeffRef(index + i) = values[i];
+      }
+    }
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    TensorBlockDesc arg_desc = desc.WithOffset(this->srcCoeff(desc.offset()));
+    this->m_impl.writeBlock(arg_desc, block);
+  }
+};
+
+namespace internal {
+template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
+struct traits<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>> : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = array_size<StartIndices>::value;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
+struct eval<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>, Eigen::Dense> {
+  typedef const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
+class TensorStridingSlicingOp
+    : public TensorBase<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>> {
+ public:
+  typedef TensorBase<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>> Base;
+  typedef typename internal::traits<TensorStridingSlicingOp>::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename internal::ref_selector<TensorStridingSlicingOp>::type Nested;
+  typedef typename internal::traits<TensorStridingSlicingOp>::StorageKind StorageKind;
+  typedef typename internal::traits<TensorStridingSlicingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorStridingSlicingOp(const XprType& expr, const StartIndices& startIndices,
+                                                                const StopIndices& stopIndices, const Strides& strides)
+      : m_xpr(expr), m_startIndices(startIndices), m_stopIndices(stopIndices), m_strides(strides) {}
+
+  EIGEN_DEVICE_FUNC const StartIndices& startIndices() const { return m_startIndices; }
+  EIGEN_DEVICE_FUNC const StartIndices& stopIndices() const { return m_stopIndices; }
+  EIGEN_DEVICE_FUNC const StartIndices& strides() const { return m_strides; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorStridingSlicingOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const StartIndices m_startIndices;
+  const StopIndices m_stopIndices;
+  const Strides m_strides;
+};
+
+// Eval as rvalue
+template <typename StartIndices, typename StopIndices, typename Strides, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device> {
+  typedef TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType> XprType;
+  static constexpr int NumDims = internal::array_size<Strides>::value;
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  typedef Strides Dimensions;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    // Alignment can't be guaranteed at compile time since it depends on the
+    // slice offsets and sizes.
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // Blocks are materialized from the nested evaluator's raw buffer with one
+    // (possibly strided or reversed) line copy per inner run.
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    PreferBlockAccess = true,
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_device(device), m_strides(op.strides()) {
+    // Handle degenerate intervals by gracefully clamping and allowing m_dimensions to be zero
+    DSizes<Index, NumDims> startIndicesClamped, stopIndicesClamped;
+    for (ptrdiff_t i = 0; i < internal::array_size<Dimensions>::value; ++i) {
+      eigen_assert(m_strides[i] != 0 && "0 stride is invalid");
+      if (m_strides[i] > 0) {
+        startIndicesClamped[i] = clamp(op.startIndices()[i], 0, m_impl.dimensions()[i]);
+        stopIndicesClamped[i] = clamp(op.stopIndices()[i], 0, m_impl.dimensions()[i]);
+      } else {
+        /* implies m_strides[i] < 0 by assert */
+        startIndicesClamped[i] = clamp(op.startIndices()[i], -1, m_impl.dimensions()[i] - 1);
+        stopIndicesClamped[i] = clamp(op.stopIndices()[i], -1, m_impl.dimensions()[i] - 1);
+      }
+      m_startIndices[i] = startIndicesClamped[i];
+    }
+
+    typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
+    const InputDimensions& input_dims = m_impl.dimensions();
+
+    // compute output tensor shape
+    m_is_identity = true;
+    for (int i = 0; i < NumDims; i++) {
+      Index interval = stopIndicesClamped[i] - startIndicesClamped[i];
+      if (interval == 0 || ((interval < 0) != (m_strides[i] < 0))) {
+        m_dimensions[i] = 0;
+      } else {
+        m_dimensions[i] = (interval / m_strides[i]) + (interval % m_strides[i] != 0 ? 1 : 0);
+        eigen_assert(m_dimensions[i] >= 0);
+      }
+      if (m_strides[i] != 1 || interval != m_impl.dimensions()[i]) {
+        m_is_identity = false;
+      }
+    }
+
+    Strides output_dims = m_dimensions;
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputStrides[0] = m_strides[0];
+      m_offsets[0] = startIndicesClamped[0];
+      Index previousDimProduct = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        previousDimProduct *= input_dims[i - 1];
+        m_inputStrides[i] = previousDimProduct * m_strides[i];
+        m_offsets[i] = startIndicesClamped[i] * previousDimProduct;
+      }
+
+      // Don't initialize m_fastOutputStrides[0] since it won't ever be accessed.
+      m_outputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_outputStrides[i] = m_outputStrides[i - 1] * output_dims[i - 1];
+        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
+      }
+    } else {
+      m_inputStrides[NumDims - 1] = m_strides[NumDims - 1];
+      m_offsets[NumDims - 1] = startIndicesClamped[NumDims - 1];
+      Index previousDimProduct = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        previousDimProduct *= input_dims[i + 1];
+        m_inputStrides[i] = previousDimProduct * m_strides[i];
+        m_offsets[i] = startIndicesClamped[i] * previousDimProduct;
+      }
+
+      m_outputStrides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_outputStrides[i] = m_outputStrides[i + 1] * output_dims[i + 1];
+        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    if (m_is_identity) {
+      return m_impl.coeff(index);
+    } else {
+      return m_impl.coeff(srcCoeff(index));
+    }
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(index + PacketSize - 1 < internal::array_prod(dimensions()));
+
+    if (m_is_identity) {
+      return m_impl.template packet<LoadMode>(index);
+    }
+
+    // A packet that stays inside one inner-most slice is an arithmetic
+    // progression in the input: compute the index mapping once per packet and
+    // step by the inner stride, instead of once per coefficient. With inner
+    // stride +/-1 the progression is a contiguous run served by a single
+    // packet load. The two-endpoint distance test used by TensorSlicingOp and
+    // TensorStridingOp is unsound here: with a negative inner stride the
+    // interior of a packet can be permuted even though the endpoints are
+    // PacketSize-1 apart.
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    const Index inner_size = m_dimensions[inner_dim];
+    Index inner_pos;
+    const Index base = srcCoeffInner(index, inner_pos);
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    if (inner_pos + PacketSize <= inner_size) {
+      const Index inner_stride = m_inputStrides[inner_dim];
+      if (inner_stride == 1) {
+        return m_impl.template packet<Unaligned>(base);
+      } else EIGEN_IF_CONSTEXPR (!std::is_same<internal::remove_all_t<Device>, SyclDevice>::value) {
+        // SYCL packets do not implement preverse; use the scalar gather below.
+        if (inner_stride == -1) {
+          return internal::preverse(m_impl.template packet<Unaligned>(base - (PacketSize - 1)));
+        }
+      }
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < PacketSize; ++i) {
+        values[i] = m_impl.coeff(base + i * inner_stride);
+      }
+      return internal::pload<PacketReturnType>(values);
+    }
+
+    // The packet crosses an inner-slice boundary: assemble it scalar by
+    // scalar.
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    return internal::pload<PacketReturnType>(values);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    const bool packets_stay_in_inner =
+        m_is_identity || (m_dimensions[inner_dim] >= PacketSize && m_dimensions[inner_dim] % PacketSize == 0);
+    const Index inner_stride = m_inputStrides[inner_dim];
+    const bool packetizes_arg =
+        m_is_identity || (packets_stay_in_inner &&
+                          (inner_stride == 1 ||
+                           (inner_stride == -1 && !std::is_same<internal::remove_all_t<Device>, SyclDevice>::value)));
+    return m_impl.costPerCoeff(vectorized && packetizes_arg) +
+           TensorOpCost(0, 0, m_is_identity ? 1 : NumDims, vectorized && packets_stay_in_inner, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    // Blocks materialize into scratch and are then re-read by the consumer, so
+    // the round trip must stay cache-resident: L1-sized blocks (as in
+    // TensorShuffling) make the extra pass nearly free, while LLC-sized blocks
+    // cost a measured ~40% on cheap coefficient-wise consumers of a
+    // larger-than-cache slice.
+    const size_t target_size = m_device.firstLevelCacheSize();
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    // A non-unit (or negative) inner stride turns the per-line copies into
+    // gathers or reversed reads the default cost model does not see in bytes
+    // loaded and stored; surface that like TensorReverse does.
+    const double gather_cost = m_inputStrides[inner_dim] == 1 ? 0.0 : 24.0;
+    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size).addCostPerCoeff({0, 0, gather_cost});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool root_of_expr_ast = false) const {
+    eigen_assert(m_impl.data() != nullptr);
+
+    if (m_is_identity) {
+      return TensorBlock::materialize(m_impl.data(), m_impl.dimensions(), desc, scratch);
+    }
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+
+    const typename TensorBlock::Storage block_storage =
+        TensorBlock::prepareStorage(desc, scratch, /*allow_strided_storage=*/root_of_expr_ast);
+
+    // Per output dimension, one step moves the input by the (possibly
+    // negative) dilated stride; the block's first element sits at the mapped
+    // offset of the block descriptor's origin.
+    typename TensorBlockIO::Dimensions input_strides(m_inputStrides);
+    TensorBlockIOSrc src(input_strides, m_impl.data(), srcCoeff(desc.offset()));
+
+    TensorBlockIODst dst(block_storage.dimensions(), block_storage.strides(), block_storage.data());
+
+    TensorBlockIO::Copy(dst, src);
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Storage::Type data() const { return nullptr; }
+
+ protected:
+  // Computes the input index of output index `index` and, as a by-product of
+  // the same fast-divisor walk, the output's inner-dimension coordinate. The
+  // packet paths use the latter to test whether a whole packet stays inside
+  // one inner-most slice without spending an extra division on it.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeffInner(Index index, Index& inner_pos) const {
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_fastOutputStrides[i];
+        inputIndex += idx * m_inputStrides[i] + m_offsets[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inputIndex += index * m_inputStrides[0] + m_offsets[0];
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_fastOutputStrides[i];
+        inputIndex += idx * m_inputStrides[i] + m_offsets[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inputIndex += index * m_inputStrides[NumDims - 1] + m_offsets[NumDims - 1];
+    }
+    inner_pos = index;
+    return inputIndex;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
+    Index inner_pos;
+    return srcCoeffInner(index, inner_pos);
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index clamp(Index value, Index min, Index max) {
+#ifndef SYCL_DEVICE_ONLY
+    return numext::maxi(min, numext::mini(max, value));
+#else
+    return cl::sycl::clamp(value, min, max);
+#endif
+  }
+
+  array<Index, NumDims> m_outputStrides;
+  array<internal::TensorIntDivisor<Index>, NumDims> m_fastOutputStrides;
+  array<Index, NumDims> m_inputStrides;
+  bool m_is_identity;
+  TensorEvaluator<ArgType, Device> m_impl;
+  const Device EIGEN_DEVICE_REF m_device;
+  DSizes<Index, NumDims> m_startIndices;  // clamped startIndices
+  DSizes<Index, NumDims> m_dimensions;
+  DSizes<Index, NumDims> m_offsets;  // offset in a flattened shape
+  const Strides m_strides;
+};
+
+// Eval as lvalue
+template <typename StartIndices, typename StopIndices, typename Strides, typename ArgType, typename Device>
+struct TensorEvaluator<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device>
+    : public TensorEvaluator<const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device> Base;
+  typedef TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType> XprType;
+  static constexpr int NumDims = internal::array_size<Strides>::value;
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // Blocks are scattered into the nested evaluator's raw buffer with one
+    // (possibly strided or reversed) line copy per inner run.
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    PreferBlockAccess = true,
+    CoordAccess = TensorEvaluator<ArgType, Device>::CoordAccess,
+    RawAccess = false
+  };
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef Strides Dimensions;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    if (this->m_is_identity) {
+      return this->m_impl.coeffRef(index);
+    } else {
+      return this->m_impl.coeffRef(this->srcCoeff(index));
+    }
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    EIGEN_STATIC_ASSERT((Base::PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
+    eigen_assert(index + Base::PacketSize - 1 < internal::array_prod(this->dimensions()));
+
+    if (this->m_is_identity) {
+      this->m_impl.template writePacket<StoreMode>(index, x);
+      return;
+    }
+
+    // Mirrors packet() in the rvalue evaluator above: within one inner-most
+    // slice the packet is an arithmetic progression in the input, so the
+    // index mapping is computed once per packet; inner stride +/-1 becomes a
+    // single (possibly reversed) packet store.
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    const Index inner_size = this->m_dimensions[inner_dim];
+    Index inner_pos;
+    const Index base = this->srcCoeffInner(index, inner_pos);
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    CoeffReturnType values[Base::PacketSize];
+    if (inner_pos + Base::PacketSize <= inner_size) {
+      const Index inner_stride = this->m_inputStrides[inner_dim];
+      if (inner_stride == 1) {
+        this->m_impl.template writePacket<Unaligned>(base, x);
+        return;
+      } else EIGEN_IF_CONSTEXPR (!std::is_same<internal::remove_all_t<Device>, SyclDevice>::value) {
+        // SYCL packets do not implement preverse; use the scalar scatter below.
+        if (inner_stride == -1) {
+          this->m_impl.template writePacket<Unaligned>(base - (Base::PacketSize - 1), internal::preverse(x));
+          return;
+        }
+      }
+      internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < Base::PacketSize; ++i) {
+        this->m_impl.coeffRef(base + i * inner_stride) = values[i];
+      }
+      return;
+    }
+
+    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < Base::PacketSize; ++i) {
+      this->coeffRef(index + i) = values[i];
+    }
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(this->m_impl.data() != nullptr);
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+    typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename TensorBlock::XprType, Index>
+        TensorBlockAssignment;
+
+    const Scalar* block_buffer = block.data();
+
+    // Unlike TensorShuffling this op preserves dimension order, so with a unit
+    // inner stride a block expression can be assigned straight into the
+    // destination through the dilated outer strides, skipping the
+    // materialize-into-temp pass below. TensorBlockAssignment requires exactly
+    // that unit inner stride.
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    if (block_buffer == nullptr && this->m_inputStrides[inner_dim] == 1) {
+      const typename TensorBlockIO::Dimensions output_strides(this->m_inputStrides);
+      TensorBlockAssignment::Run(TensorBlockAssignment::target(desc.dimensions(), output_strides, this->m_impl.data(),
+                                                               this->srcCoeff(desc.offset())),
+                                 block.expr());
+      return;
+    }
+
+    const typename TensorBlockIO::Dimensions block_strides = internal::strides<Layout>(desc.dimensions());
+
+    // TODO(ezhulenev): TensorBlockIO should be able to read from any Eigen
+    // expression with coefficient and packet access as `src`.
+    void* mem = nullptr;
+    if (block_buffer == nullptr) {
+      mem = this->m_device.allocate(desc.size() * sizeof(Scalar));
+      ScalarNoConst* buf = static_cast<ScalarNoConst*>(mem);
+
+      TensorBlockAssignment::Run(TensorBlockAssignment::target(desc.dimensions(), block_strides, buf), block.expr());
+
+      block_buffer = buf;
+    }
+
+    TensorBlockIOSrc src(block_strides, block_buffer);
+
+    // Write through the (possibly negative) dilated strides.
+    typename TensorBlockIO::Dimensions output_strides(this->m_inputStrides);
+    TensorBlockIODst dst(desc.dimensions(), output_strides, this->m_impl.data(), this->srcCoeff(desc.offset()));
+
+    TensorBlockIO::Copy(dst, src);
+
+    // Deallocate temporary buffer used for the block materialization.
+    if (mem != nullptr) this->m_device.deallocate(mem);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_MORPHING_H
diff --git a/contrib/Eigen/src/Tensor/TensorPadding.h b/contrib/Eigen/src/Tensor/TensorPadding.h
new file mode 100644
index 0000000..d9fface
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorPadding.h
@@ -0,0 +1,631 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_PADDING_H
+#define EIGEN_TENSOR_TENSOR_PADDING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename PaddingDimensions, typename XprType>
+struct traits<TensorPaddingOp<PaddingDimensions, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename PaddingDimensions, typename XprType>
+struct eval<TensorPaddingOp<PaddingDimensions, XprType>, Eigen::Dense> {
+  typedef const TensorPaddingOp<PaddingDimensions, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor padding class.
+ * At the moment only padding with a constant value is supported.
+ *
+ */
+template <typename PaddingDimensions, typename XprType>
+class TensorPaddingOp : public TensorBase<TensorPaddingOp<PaddingDimensions, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorPaddingOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorPaddingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorPaddingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorPaddingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorPaddingOp(const XprType& expr, const PaddingDimensions& padding_dims,
+                                                        const Scalar padding_value)
+      : m_xpr(expr), m_padding_dims(padding_dims), m_padding_value(padding_value) {}
+
+  EIGEN_DEVICE_FUNC const PaddingDimensions& padding() const { return m_padding_dims; }
+  EIGEN_DEVICE_FUNC Scalar padding_value() const { return m_padding_value; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const PaddingDimensions m_padding_dims;
+  const Scalar m_padding_value;
+};
+
+// Eval as rvalue
+template <typename PaddingDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorPaddingOp<PaddingDimensions, ArgType>, Device> {
+  typedef TensorPaddingOp<PaddingDimensions, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<PaddingDimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = true,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    PreferBlockAccess = true,
+    CoordAccess = true,
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_padding(op.padding()), m_paddingValue(op.padding_value()), m_device(device) {
+    // The padding op doesn't change the rank of the tensor. Directly padding a scalar would lead
+    // to a vector, which doesn't make sense. Instead one should reshape the scalar into a vector
+    // of 1 element first and then pad.
+    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    // Compute dimensions
+    m_dimensions = m_impl.dimensions();
+    for (int i = 0; i < NumDims; ++i) {
+      m_dimensions[i] += m_padding[i].first + m_padding[i].second;
+    }
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputStrides[0] = 1;
+      m_outputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
+        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+      }
+      m_outputStrides[NumDims] = m_outputStrides[NumDims - 1] * m_dimensions[NumDims - 1];
+    } else {
+      m_inputStrides[NumDims - 1] = 1;
+      m_outputStrides[NumDims] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
+        m_outputStrides[i + 1] = m_outputStrides[i + 2] * m_dimensions[i + 1];
+      }
+      m_outputStrides[0] = m_outputStrides[1] * m_dimensions[0];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    eigen_assert(index < dimensions().TotalSize());
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_outputStrides[i];
+        if (isPaddingAtIndexForDim(idx, i)) {
+          return m_paddingValue;
+        }
+        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      if (isPaddingAtIndexForDim(index, 0)) {
+        return m_paddingValue;
+      }
+      inputIndex += (index - m_padding[0].first);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_outputStrides[i + 1];
+        if (isPaddingAtIndexForDim(idx, i)) {
+          return m_paddingValue;
+        }
+        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
+        index -= idx * m_outputStrides[i + 1];
+      }
+      if (isPaddingAtIndexForDim(index, NumDims - 1)) {
+        return m_paddingValue;
+      }
+      inputIndex += (index - m_padding[NumDims - 1].first);
+    }
+    return m_impl.coeff(inputIndex);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      return packetColMajor(index);
+    }
+    return packetRowMajor(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    TensorOpCost cost = m_impl.costPerCoeff(vectorized);
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims; ++i) updateCostPerDimension(cost, i, i == 0);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i >= 0; --i) updateCostPerDimension(cost, i, i == NumDims - 1);
+    }
+    return cost;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.lastLevelCacheSize();
+    return internal::TensorBlockResourceRequirements::merge(
+        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size), m_impl.getResourceRequirements());
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    // If one of the dimensions is zero, return empty block view.
+    if (desc.size() == 0) {
+      return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+    }
+
+    static constexpr bool IsColMajor = Layout == static_cast<int>(ColMajor);
+    constexpr int inner_dim_idx = IsColMajor ? 0 : NumDims - 1;
+
+    Index offset = desc.offset();
+
+    // Compute offsets in the output tensor corresponding to the desc.offset().
+    DSizes<Index, NumDims> output_offsets;
+    for (int i = NumDims - 1; i > 0; --i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      const int stride_dim = IsColMajor ? dim : dim + 1;
+      output_offsets[dim] = offset / m_outputStrides[stride_dim];
+      offset -= output_offsets[dim] * m_outputStrides[stride_dim];
+    }
+    output_offsets[inner_dim_idx] = offset;
+
+    // Offsets in the input corresponding to output offsets.
+    DSizes<Index, NumDims> input_offsets = output_offsets;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      input_offsets[dim] = input_offsets[dim] - m_padding[dim].first;
+    }
+
+    // Compute offset in the input buffer (at this point it might be illegal and
+    // point outside of the input buffer, because we don't check for negative
+    // offsets, it will be autocorrected in the block iteration loop below).
+    Index input_offset = 0;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      input_offset += input_offsets[dim] * m_inputStrides[dim];
+    }
+
+    // Destination buffer and scratch buffer both indexed from 0 and have the
+    // same dimensions as the requested block (for destination buffer this
+    // property is guaranteed by `desc.destination()`).
+    Index output_offset = 0;
+    const DSizes<Index, NumDims> output_strides = internal::strides<Layout>(desc.dimensions());
+
+    // NOTE(ezhulenev): We initialize block iteration state for `NumDims - 1`
+    // dimensions, skipping innermost dimension. In theory it should be possible
+    // to squeeze matching innermost dimensions, however in practice that did
+    // not show any improvements in benchmarks. Also in practice first outer
+    // dimension usually has padding, and will prevent squeezing.
+
+    // Initialize output block iterator state. Dimension in this array are
+    // always in inner_most -> outer_most order (col major layout).
+    array<BlockIteratorState, NumDims - 1> it;
+    for (int i = 0; i < NumDims - 1; ++i) {
+      const int dim = IsColMajor ? i + 1 : NumDims - i - 2;
+      it[i].count = 0;
+      it[i].size = desc.dimension(dim);
+
+      it[i].input_stride = m_inputStrides[dim];
+      it[i].input_span = it[i].input_stride * (it[i].size - 1);
+
+      it[i].output_stride = output_strides[dim];
+      it[i].output_span = it[i].output_stride * (it[i].size - 1);
+    }
+
+    const Index input_inner_dim_size = static_cast<Index>(m_impl.dimensions()[inner_dim_idx]);
+
+    // Total output size.
+    const Index output_size = desc.size();
+
+    // We will fill inner dimension of this size in the output. It might be
+    // larger than the inner dimension in the input, so we might have to pad
+    // before/after we copy values from the input inner dimension.
+    const Index output_inner_dim_size = desc.dimension(inner_dim_idx);
+
+    // How many values to fill with padding BEFORE reading from the input inner
+    // dimension.
+    const Index output_inner_pad_before_size =
+        input_offsets[inner_dim_idx] < 0
+            ? numext::mini(numext::abs(input_offsets[inner_dim_idx]), output_inner_dim_size)
+            : 0;
+
+    // How many values we can actually copy from the input inner dimension.
+    const Index output_inner_copy_size = numext::mini(
+        // Want to copy from input.
+        (output_inner_dim_size - output_inner_pad_before_size),
+        // Can copy from input.
+        numext::maxi(input_inner_dim_size - (input_offsets[inner_dim_idx] + output_inner_pad_before_size), Index(0)));
+
+    eigen_assert(output_inner_copy_size >= 0);
+
+    // How many values to fill with padding AFTER reading from the input inner
+    // dimension.
+    const Index output_inner_pad_after_size =
+        output_inner_dim_size - output_inner_copy_size - output_inner_pad_before_size;
+
+    // Sanity check, sum of all sizes must be equal to the output size.
+    eigen_assert(output_inner_dim_size ==
+                 (output_inner_pad_before_size + output_inner_copy_size + output_inner_pad_after_size));
+
+    // Keep track of current coordinates and padding in the output.
+    DSizes<Index, NumDims> output_coord = output_offsets;
+    DSizes<Index, NumDims> output_padded;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = IsColMajor ? i : NumDims - i - 1;
+      output_padded[dim] = isPaddingAtIndexForDim(output_coord[dim], dim);
+    }
+
+    typedef internal::StridedLinearBufferCopy<ScalarNoConst, Index> LinCopy;
+
+    // Prepare storage for the materialized padding result.
+    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+
+    // TODO(ezhulenev): Squeeze multiple non-padded inner dimensions into a
+    // single logical inner dimension.
+
+    // When possible we squeeze writes for the innermost (only if non-padded)
+    // dimension with the first padded dimension. This allows to reduce the
+    // number of calls to LinCopy and better utilize vector instructions.
+    const bool squeeze_writes = NumDims > 1 &&
+                                // inner dimension is not padded
+                                (input_inner_dim_size == m_dimensions[inner_dim_idx]) &&
+                                // and equal to the block inner dimension
+                                (input_inner_dim_size == output_inner_dim_size);
+
+    constexpr int squeeze_dim = NumDims > 1 ? (IsColMajor ? inner_dim_idx + 1 : inner_dim_idx - 1) : 0;
+
+    // Maximum coordinate on a squeeze dimension that we can write to.
+    const Index squeeze_max_coord =
+        squeeze_writes ? numext::mini(
+                             // max non-padded element in the input
+                             static_cast<Index>(m_dimensions[squeeze_dim] - m_padding[squeeze_dim].second),
+                             // max element in the output buffer
+                             static_cast<Index>(output_offsets[squeeze_dim] + desc.dimension(squeeze_dim)))
+                       : static_cast<Index>(0);
+
+    // Iterate copying data from `m_impl.data()` to the output buffer.
+    for (Index size = 0; size < output_size;) {
+      // Detect if we are in the padded region (exclude innermost dimension).
+      bool is_padded = false;
+      for (int j = 1; j < NumDims; ++j) {
+        const int dim = IsColMajor ? j : NumDims - j - 1;
+        is_padded = output_padded[dim];
+        if (is_padded) break;
+      }
+
+      if (is_padded) {
+        // Fill single innermost dimension with padding value.
+        size += output_inner_dim_size;
+
+        LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(output_offset, 1, block_storage.data()),
+                                                         typename LinCopy::Src(0, 0, &m_paddingValue),
+                                                         output_inner_dim_size);
+
+      } else if (squeeze_writes) {
+        // Squeeze multiple reads from innermost dimensions.
+        const Index squeeze_num = squeeze_max_coord - output_coord[squeeze_dim];
+        size += output_inner_dim_size * squeeze_num;
+
+        // Copy `squeeze_num` inner dimensions from input to output.
+        LinCopy::template Run<LinCopy::Kind::Linear>(typename LinCopy::Dst(output_offset, 1, block_storage.data()),
+                                                     typename LinCopy::Src(input_offset, 1, m_impl.data()),
+                                                     output_inner_dim_size * squeeze_num);
+
+        // Update iteration state for only `squeeze_num - 1` processed inner
+        // dimensions, because we have another iteration state update at the end
+        // of the loop that will update iteration state for the last inner
+        // processed dimension.
+        it[0].count += (squeeze_num - 1);
+        input_offset += it[0].input_stride * (squeeze_num - 1);
+        output_offset += it[0].output_stride * (squeeze_num - 1);
+        output_coord[squeeze_dim] += (squeeze_num - 1);
+
+      } else {
+        // Single read from innermost dimension.
+        size += output_inner_dim_size;
+
+        {  // Fill with padding before copying from input inner dimension.
+          const Index out = output_offset;
+
+          LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(out, 1, block_storage.data()),
+                                                           typename LinCopy::Src(0, 0, &m_paddingValue),
+                                                           output_inner_pad_before_size);
+        }
+
+        {  // Copy data from input inner dimension.
+          const Index out = output_offset + output_inner_pad_before_size;
+          const Index in = input_offset + output_inner_pad_before_size;
+
+          eigen_assert(output_inner_copy_size == 0 || m_impl.data() != nullptr);
+
+          LinCopy::template Run<LinCopy::Kind::Linear>(typename LinCopy::Dst(out, 1, block_storage.data()),
+                                                       typename LinCopy::Src(in, 1, m_impl.data()),
+                                                       output_inner_copy_size);
+        }
+
+        {  // Fill with padding after copying from input inner dimension.
+          const Index out = output_offset + output_inner_pad_before_size + output_inner_copy_size;
+
+          LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(out, 1, block_storage.data()),
+                                                           typename LinCopy::Src(0, 0, &m_paddingValue),
+                                                           output_inner_pad_after_size);
+        }
+      }
+
+      for (int j = 0; j < NumDims - 1; ++j) {
+        const int dim = IsColMajor ? j + 1 : NumDims - j - 2;
+
+        if (++it[j].count < it[j].size) {
+          input_offset += it[j].input_stride;
+          output_offset += it[j].output_stride;
+          output_coord[dim] += 1;
+          output_padded[dim] = isPaddingAtIndexForDim(output_coord[dim], dim);
+          break;
+        }
+        it[j].count = 0;
+        input_offset -= it[j].input_span;
+        output_offset -= it[j].output_span;
+        output_coord[dim] -= it[j].size - 1;
+        output_padded[dim] = isPaddingAtIndexForDim(output_coord[dim], dim);
+      }
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return nullptr; }
+
+ private:
+  struct BlockIteratorState {
+    BlockIteratorState() = default;
+
+    Index count = 0;
+    Index size = 0;
+    Index input_stride = 0;
+    Index input_span = 0;
+    Index output_stride = 0;
+    Index output_span = 0;
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool isPaddingAtIndexForDim(Index index, int dim_index) const {
+    return (!internal::index_pair_first_statically_eq<PaddingDimensions>(dim_index, 0) &&
+            index < m_padding[dim_index].first) ||
+           (!internal::index_pair_second_statically_eq<PaddingDimensions>(dim_index, 0) &&
+            index >= m_dimensions[dim_index] - m_padding[dim_index].second);
+  }
+
+  static EIGEN_DEVICE_FUNC constexpr bool isLeftPaddingCompileTimeZero(int dim_index) {
+    return internal::index_pair_first_statically_eq<PaddingDimensions>(dim_index, 0);
+  }
+
+  static EIGEN_DEVICE_FUNC constexpr bool isRightPaddingCompileTimeZero(int dim_index) {
+    return internal::index_pair_second_statically_eq<PaddingDimensions>(dim_index, 0);
+  }
+
+  void updateCostPerDimension(TensorOpCost& cost, int i, bool first) const {
+    const double in = static_cast<double>(m_impl.dimensions()[i]);
+    const double out = in + m_padding[i].first + m_padding[i].second;
+    if (out == 0) return;
+    const double reduction = in / out;
+    cost *= reduction;
+    if (first) {
+      cost += TensorOpCost(0, 0, 2 * TensorOpCost::AddCost<Index>() + reduction * (1 * TensorOpCost::AddCost<Index>()));
+    } else {
+      cost += TensorOpCost(0, 0,
+                           2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
+                               reduction * (2 * TensorOpCost::MulCost<Index>() + 1 * TensorOpCost::DivCost<Index>()));
+    }
+  }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetColMajor(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    const Index initialIndex = index;
+    Index inputIndex = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = NumDims - 1; i > 0; --i) {
+      const Index firstIdx = index;
+      const Index lastIdx = index + PacketSize - 1;
+      const Index lastPaddedLeft = m_padding[i].first * m_outputStrides[i];
+      const Index firstPaddedRight = (m_dimensions[i] - m_padding[i].second) * m_outputStrides[i];
+      const Index lastPaddedRight = m_outputStrides[i + 1];
+
+      if (!isLeftPaddingCompileTimeZero(i) && lastIdx < lastPaddedLeft) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      } else if (!isRightPaddingCompileTimeZero(i) && firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      } else if ((isLeftPaddingCompileTimeZero(i) && isRightPaddingCompileTimeZero(i)) ||
+                 (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight)) {
+        // all the coefficients are between the 2 padding zones.
+        const Index idx = index / m_outputStrides[i];
+        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      } else {
+        // Every other case
+        return packetWithPossibleZero(initialIndex);
+      }
+    }
+
+    const Index lastIdx = index + PacketSize - 1;
+    const Index firstIdx = index;
+    const Index lastPaddedLeft = m_padding[0].first;
+    const Index firstPaddedRight = m_dimensions[0] - m_padding[0].second;
+    const Index lastPaddedRight = m_outputStrides[1];
+
+    EIGEN_IF_CONSTEXPR (!isLeftPaddingCompileTimeZero(0)) {
+      if (lastIdx < lastPaddedLeft) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      }
+    }
+    EIGEN_IF_CONSTEXPR (!isRightPaddingCompileTimeZero(0)) {
+      if (firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      }
+    }
+    EIGEN_IF_CONSTEXPR (isLeftPaddingCompileTimeZero(0) && isRightPaddingCompileTimeZero(0)) {
+      // all the coefficients are between the 2 padding zones.
+      inputIndex += (index - m_padding[0].first);
+      return m_impl.template packet<Unaligned>(inputIndex);
+    } else if (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight) {
+      // all the coefficients are between the 2 padding zones.
+      inputIndex += (index - m_padding[0].first);
+      return m_impl.template packet<Unaligned>(inputIndex);
+    }
+    // Every other case
+    return packetWithPossibleZero(initialIndex);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetRowMajor(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    const Index initialIndex = index;
+    Index inputIndex = 0;
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < NumDims - 1; ++i) {
+      const Index firstIdx = index;
+      const Index lastIdx = index + PacketSize - 1;
+      const Index lastPaddedLeft = m_padding[i].first * m_outputStrides[i + 1];
+      const Index firstPaddedRight = (m_dimensions[i] - m_padding[i].second) * m_outputStrides[i + 1];
+      const Index lastPaddedRight = m_outputStrides[i];
+
+      if (!isLeftPaddingCompileTimeZero(i) && lastIdx < lastPaddedLeft) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      } else if (!isRightPaddingCompileTimeZero(i) && firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      } else if ((isLeftPaddingCompileTimeZero(i) && isRightPaddingCompileTimeZero(i)) ||
+                 (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight)) {
+        // all the coefficients are between the 2 padding zones.
+        const Index idx = index / m_outputStrides[i + 1];
+        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
+        index -= idx * m_outputStrides[i + 1];
+      } else {
+        // Every other case
+        return packetWithPossibleZero(initialIndex);
+      }
+    }
+
+    const Index lastIdx = index + PacketSize - 1;
+    const Index firstIdx = index;
+    const Index lastPaddedLeft = m_padding[NumDims - 1].first;
+    const Index firstPaddedRight = m_dimensions[NumDims - 1] - m_padding[NumDims - 1].second;
+    const Index lastPaddedRight = m_outputStrides[NumDims - 1];
+
+    EIGEN_IF_CONSTEXPR (!isLeftPaddingCompileTimeZero(NumDims - 1)) {
+      if (lastIdx < lastPaddedLeft) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      }
+    }
+    EIGEN_IF_CONSTEXPR (!isRightPaddingCompileTimeZero(NumDims - 1)) {
+      if (firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
+        // all the coefficients are in the padding zone.
+        return internal::pset1<PacketReturnType>(m_paddingValue);
+      }
+    }
+    EIGEN_IF_CONSTEXPR (isLeftPaddingCompileTimeZero(NumDims - 1) && isRightPaddingCompileTimeZero(NumDims - 1)) {
+      // all the coefficients are between the 2 padding zones.
+      inputIndex += (index - m_padding[NumDims - 1].first);
+      return m_impl.template packet<Unaligned>(inputIndex);
+    } else if (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight) {
+      // all the coefficients are between the 2 padding zones.
+      inputIndex += (index - m_padding[NumDims - 1].first);
+      return m_impl.template packet<Unaligned>(inputIndex);
+    }
+    // Every other case
+    return packetWithPossibleZero(initialIndex);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetWithPossibleZero(Index index) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  Dimensions m_dimensions;
+  array<Index, NumDims + 1> m_outputStrides;
+  array<Index, NumDims> m_inputStrides;
+  TensorEvaluator<ArgType, Device> m_impl;
+  PaddingDimensions m_padding;
+
+  Scalar m_paddingValue;
+
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_PADDING_H
diff --git a/contrib/Eigen/src/Tensor/TensorPatch.h b/contrib/Eigen/src/Tensor/TensorPatch.h
new file mode 100644
index 0000000..39354f9
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorPatch.h
@@ -0,0 +1,377 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_PATCH_H
+#define EIGEN_TENSOR_TENSOR_PATCH_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename PatchDim, typename XprType>
+struct traits<TensorPatchOp<PatchDim, XprType> > : traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions + 1;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename PatchDim, typename XprType>
+struct eval<TensorPatchOp<PatchDim, XprType>, Eigen::Dense> {
+  typedef const TensorPatchOp<PatchDim, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor patch class.
+ */
+template <typename PatchDim, typename XprType>
+class TensorPatchOp : public TensorBase<TensorPatchOp<PatchDim, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorPatchOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorPatchOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorPatchOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorPatchOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorPatchOp(const XprType& expr, const PatchDim& patch_dims)
+      : m_xpr(expr), m_patch_dims(patch_dims) {}
+
+  EIGEN_DEVICE_FUNC const PatchDim& patch_dims() const { return m_patch_dims; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const PatchDim m_patch_dims;
+};
+
+// Eval as rvalue
+template <typename PatchDim, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorPatchOp<PatchDim, ArgType>, Device> {
+  typedef TensorPatchOp<PatchDim, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value + 1;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // block() reads the argument one coefficient at a time through coeff() --
+    // the contract the scalar executors already rely on for every evaluator --
+    // so it requires no capability bit from the argument (same as
+    // TensorReverse).
+    BlockAccess = NumDims > 1,
+    // The coeff/packet path pays a div/mod cascade per element; the block
+    // path copies whole in-bounds boxes patch by patch.
+    PreferBlockAccess = true,
+    CoordAccess = false,
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_device(device) {
+    Index num_patches = 1;
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    const PatchDim& patch_dims = op.patch_dims();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        m_dimensions[i] = patch_dims[i];
+        num_patches *= (input_dims[i] - patch_dims[i] + 1);
+      }
+      m_dimensions[NumDims - 1] = num_patches;
+
+      m_inputStrides[0] = 1;
+      m_patchStrides[0] = 1;
+      for (int i = 1; i < NumDims - 1; ++i) {
+        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
+        m_patchStrides[i] = m_patchStrides[i - 1] * (input_dims[i - 1] - patch_dims[i - 1] + 1);
+      }
+      m_outputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+      }
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        m_dimensions[i + 1] = patch_dims[i];
+        num_patches *= (input_dims[i] - patch_dims[i] + 1);
+      }
+      m_dimensions[0] = num_patches;
+
+      m_inputStrides[NumDims - 2] = 1;
+      m_patchStrides[NumDims - 2] = 1;
+      for (int i = NumDims - 3; i >= 0; --i) {
+        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
+        m_patchStrides[i] = m_patchStrides[i + 1] * (input_dims[i + 1] - patch_dims[i + 1] + 1);
+      }
+      m_outputStrides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    Index output_stride_index = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? NumDims - 1 : 0;
+    // Find the location of the first element of the patch.
+    Index patchIndex = index / m_outputStrides[output_stride_index];
+    // Find the offset of the element wrt the location of the first element.
+    Index patchOffset = index - patchIndex * m_outputStrides[output_stride_index];
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 2; i > 0; --i) {
+        const Index patchIdx = patchIndex / m_patchStrides[i];
+        patchIndex -= patchIdx * m_patchStrides[i];
+        const Index offsetIdx = patchOffset / m_outputStrides[i];
+        patchOffset -= offsetIdx * m_outputStrides[i];
+        inputIndex += (patchIdx + offsetIdx) * m_inputStrides[i];
+      }
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 2; ++i) {
+        const Index patchIdx = patchIndex / m_patchStrides[i];
+        patchIndex -= patchIdx * m_patchStrides[i];
+        const Index offsetIdx = patchOffset / m_outputStrides[i + 1];
+        patchOffset -= offsetIdx * m_outputStrides[i + 1];
+        inputIndex += (patchIdx + offsetIdx) * m_inputStrides[i];
+      }
+    }
+    inputIndex += (patchIndex + patchOffset);
+    return m_impl.coeff(inputIndex);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    Index output_stride_index = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? NumDims - 1 : 0;
+    Index indices[2] = {index, index + PacketSize - 1};
+    Index patchIndices[2] = {indices[0] / m_outputStrides[output_stride_index],
+                             indices[1] / m_outputStrides[output_stride_index]};
+    Index patchOffsets[2] = {indices[0] - patchIndices[0] * m_outputStrides[output_stride_index],
+                             indices[1] - patchIndices[1] * m_outputStrides[output_stride_index]};
+
+    Index inputIndices[2] = {0, 0};
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 2; i > 0; --i) {
+        const Index patchIdx[2] = {patchIndices[0] / m_patchStrides[i], patchIndices[1] / m_patchStrides[i]};
+        patchIndices[0] -= patchIdx[0] * m_patchStrides[i];
+        patchIndices[1] -= patchIdx[1] * m_patchStrides[i];
+
+        const Index offsetIdx[2] = {patchOffsets[0] / m_outputStrides[i], patchOffsets[1] / m_outputStrides[i]};
+        patchOffsets[0] -= offsetIdx[0] * m_outputStrides[i];
+        patchOffsets[1] -= offsetIdx[1] * m_outputStrides[i];
+
+        inputIndices[0] += (patchIdx[0] + offsetIdx[0]) * m_inputStrides[i];
+        inputIndices[1] += (patchIdx[1] + offsetIdx[1]) * m_inputStrides[i];
+      }
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 2; ++i) {
+        const Index patchIdx[2] = {patchIndices[0] / m_patchStrides[i], patchIndices[1] / m_patchStrides[i]};
+        patchIndices[0] -= patchIdx[0] * m_patchStrides[i];
+        patchIndices[1] -= patchIdx[1] * m_patchStrides[i];
+
+        const Index offsetIdx[2] = {patchOffsets[0] / m_outputStrides[i + 1], patchOffsets[1] / m_outputStrides[i + 1]};
+        patchOffsets[0] -= offsetIdx[0] * m_outputStrides[i + 1];
+        patchOffsets[1] -= offsetIdx[1] * m_outputStrides[i + 1];
+
+        inputIndices[0] += (patchIdx[0] + offsetIdx[0]) * m_inputStrides[i];
+        inputIndices[1] += (patchIdx[1] + offsetIdx[1]) * m_inputStrides[i];
+      }
+    }
+    inputIndices[0] += (patchIndices[0] + patchOffsets[0]);
+    inputIndices[1] += (patchIndices[1] + patchOffsets[1]);
+
+    if (inputIndices[1] - inputIndices[0] == PacketSize - 1) {
+      PacketReturnType rslt = m_impl.template packet<Unaligned>(inputIndices[0]);
+      return rslt;
+    } else {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      CoeffReturnType values[PacketSize];
+      values[0] = m_impl.coeff(inputIndices[0]);
+      values[PacketSize - 1] = m_impl.coeff(inputIndices[1]);
+      EIGEN_UNROLL_LOOP
+      for (int i = 1; i < PacketSize - 1; ++i) {
+        values[i] = coeff(index + i);
+      }
+      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+      return rslt;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.firstLevelCacheSize();
+    // Every output coefficient is read once from the argument and stored
+    // once. Pass the full cost explicitly rather than adding to skewed()'s
+    // default load+store seed, which would double-count the baseline byte
+    // traffic and halve the tile size.
+    const TensorOpCost cost_per_coeff =
+        m_impl.costPerCoeff(/*vectorized=*/false) + TensorOpCost(0, sizeof(CoeffReturnType), 0);
+    return internal::TensorBlockResourceRequirements::withShapeAndSize<Scalar>(
+        internal::TensorBlockShapeType::kSkewedInnerDims, target_size, cost_per_coeff);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    constexpr bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    if (desc.size() == 0) {
+      return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+    }
+
+    typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    CoeffReturnType* block_buffer = block_storage.data();
+
+    // Output coordinates of the block's corner.
+    array<Index, NumDims> coords;
+    Index remaining = desc.offset();
+    EIGEN_IF_CONSTEXPR (is_col_major) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        coords[i] = remaining / m_outputStrides[i];
+        remaining -= coords[i] * m_outputStrides[i];
+      }
+      coords[0] = remaining;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        coords[i] = remaining / m_outputStrides[i];
+        remaining -= coords[i] * m_outputStrides[i];
+      }
+      coords[NumDims - 1] = remaining;
+    }
+
+    const int patch_dim = is_col_major ? NumDims - 1 : 0;
+    const int inner_dim = is_col_major ? 0 : NumDims - 1;
+
+    const Index num_patches_in_block = desc.dimension(patch_dim);
+    // The input's inner-most stride is 1 by construction, so the inner run is
+    // contiguous on both sides.
+    const Index inner_size = desc.dimension(inner_dim);
+
+    // The within-patch dimensions between the inner-most one and the patch
+    // index, ordered inner-most to outer-most, plus the input offset the
+    // block's corner contributes on every within-patch dimension.
+    array<Index, NumDims> mid_sizes;
+    array<Index, NumDims> mid_src_stride;
+    array<Index, NumDims> mid_count;
+    int num_mid = 0;
+    Index src_corner = 0;
+    for (int k = 0; k < NumDims - 1; ++k) {
+      const int d = is_col_major ? k : NumDims - 1 - k;  // output dimension
+      const int in_d = is_col_major ? d : d - 1;         // input-strides index
+      src_corner += coords[d] * m_inputStrides[in_d];
+      if (k > 0) {
+        mid_sizes[num_mid] = desc.dimension(d);
+        mid_src_stride[num_mid] = m_inputStrides[in_d];
+        ++num_mid;
+      }
+    }
+
+    // The loop nest below visits the block in exactly its memory order (the
+    // storage returned by prepareStorage() is dense with the block's own
+    // layout-order strides), so the destination is one running cursor.
+    Index dst = 0;
+    for (Index p = 0; p < num_patches_in_block; ++p) {
+      // Input offset of this patch's first element.
+      Index patch_index = coords[patch_dim] + p;
+      Index src_patch = 0;
+      EIGEN_IF_CONSTEXPR (is_col_major) {
+        for (int i = NumDims - 2; i > 0; --i) {
+          const Index idx = patch_index / m_patchStrides[i];
+          patch_index -= idx * m_patchStrides[i];
+          src_patch += idx * m_inputStrides[i];
+        }
+      } else {
+        for (int i = 0; i < NumDims - 2; ++i) {
+          const Index idx = patch_index / m_patchStrides[i];
+          patch_index -= idx * m_patchStrides[i];
+          src_patch += idx * m_inputStrides[i];
+        }
+      }
+      src_patch += patch_index;
+
+      Index src = src_patch + src_corner;
+      for (int k = 0; k < num_mid; ++k) mid_count[k] = 0;
+      for (;;) {
+        for (Index j = 0; j < inner_size; ++j) {
+          block_buffer[dst + j] = m_impl.coeff(src + j);
+        }
+        dst += inner_size;
+        int k = 0;
+        for (; k < num_mid; ++k) {
+          if (++mid_count[k] < mid_sizes[k]) {
+            src += mid_src_stride[k];
+            break;
+          }
+          mid_count[k] = 0;
+          src -= mid_src_stride[k] * (mid_sizes[k] - 1);
+        }
+        if (k == num_mid) break;
+      }
+    }
+    eigen_assert(dst == desc.size());
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost = NumDims * (TensorOpCost::DivCost<Index>() + TensorOpCost::MulCost<Index>() +
+                                           2 * TensorOpCost::AddCost<Index>());
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+ protected:
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_outputStrides;
+  array<Index, NumDims - 1> m_inputStrides;
+  array<Index, NumDims - 1> m_patchStrides;
+
+  TensorEvaluator<ArgType, Device> m_impl;
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_PATCH_H
diff --git a/contrib/Eigen/src/Tensor/TensorRandom.h b/contrib/Eigen/src/Tensor/TensorRandom.h
new file mode 100644
index 0000000..a9ef7cf
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorRandom.h
@@ -0,0 +1,276 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2018 Mehdi Goli <eigen@codeplay.com> Codeplay Software Ltd.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_RANDOM_H
+#define EIGEN_TENSOR_TENSOR_RANDOM_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint64_t get_random_seed() {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+  // We don't support 3d kernels since we currently only use 1 and
+  // 2d kernels.
+  eigen_assert(threadIdx.z == 0);
+  return blockIdx.x * blockDim.x + threadIdx.x + gridDim.x * blockDim.x * (blockIdx.y * blockDim.y + threadIdx.y);
+#else
+  // Rely on Eigen's random implementation.
+  return random<uint64_t>();
+#endif
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE unsigned PCG_XSH_RS_generator(uint64_t* state, uint64_t stream) {
+  // TODO: Unify with the implementation in the non blocking thread pool.
+  uint64_t current = *state;
+  // Update the internal state
+  *state = current * 6364136223846793005ULL + (stream << 1 | 1);
+  // Generate the random output (using the PCG-XSH-RS scheme)
+  return static_cast<unsigned>((current ^ (current >> 22)) >> (22 + (current >> 61)));
+}
+
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint64_t PCG_XSH_RS_state(uint64_t seed) {
+  seed = seed ? seed : get_random_seed();
+  return seed * 6364136223846793005ULL + 0xda3e39cb94b95bdbULL;
+}
+
+// The state that the PCG stream of element `index` starts from: the base state stepped along the SplitMix64 Weyl
+// sequence and mixed (splitmix64_mix, RandomImpl.h), so it is a pure function of (seed, index) and unrelated between
+// neighbouring indices. The mixing matters because PCG_XSH_RS_generator derives its first output from the state it
+// is handed: without it, the low bits of base + index * increment would pass straight into that output.
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint64_t PCG_XSH_RS_state_for_index(uint64_t base_state, uint64_t index) {
+  return splitmix64_mix(base_state + index * 0x9e3779b97f4a7c15ULL);
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T RandomToTypeUniform(uint64_t* state, uint64_t stream) {
+  unsigned rnd = PCG_XSH_RS_generator(state, stream);
+  return static_cast<T>(rnd);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool RandomToTypeUniform<bool>(uint64_t* state, uint64_t stream) {
+  unsigned rnd = PCG_XSH_RS_generator(state, stream);
+  return (rnd & 0x1) != 0;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half RandomToTypeUniform<Eigen::half>(uint64_t* state, uint64_t stream) {
+  // Generate 10 random bits for the mantissa, merge with exponent.
+  unsigned rnd = PCG_XSH_RS_generator(state, stream);
+  const uint16_t half_bits = static_cast<uint16_t>(rnd & 0x3ffu) | (static_cast<uint16_t>(15) << 10);
+  Eigen::half result = Eigen::numext::bit_cast<Eigen::half>(half_bits);
+  return result - Eigen::half(1.0f);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 RandomToTypeUniform<Eigen::bfloat16>(uint64_t* state,
+                                                                                           uint64_t stream) {
+  // Generate 7 random bits for the mantissa, merge with exponent.
+  unsigned rnd = PCG_XSH_RS_generator(state, stream);
+  const uint16_t half_bits = static_cast<uint16_t>(rnd & 0x7fu) | (static_cast<uint16_t>(127) << 7);
+  Eigen::bfloat16 result = Eigen::numext::bit_cast<Eigen::bfloat16>(half_bits);
+  return result - Eigen::bfloat16(1.0f);
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float RandomToTypeUniform<float>(uint64_t* state, uint64_t stream) {
+  typedef union {
+    uint32_t raw;
+    float fp;
+  } internal;
+  internal result;
+  // Generate 23 random bits for the mantissa.
+  const unsigned rnd = PCG_XSH_RS_generator(state, stream);
+  result.raw = rnd & 0x7fffffu;
+  // Set the exponent.
+  result.raw |= (static_cast<uint32_t>(127) << 23);
+  return result.fp - 1.0f;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double RandomToTypeUniform<double>(uint64_t* state, uint64_t stream) {
+  typedef union {
+    uint64_t raw;
+    double dp;
+  } internal;
+  internal result;
+  result.raw = 0;
+  // Generate 52 random bits for the mantissa
+  // First generate the upper 20 bits
+  unsigned rnd1 = PCG_XSH_RS_generator(state, stream) & 0xfffffu;
+  // Then generate the lower 32 bits.
+  unsigned rnd2 = PCG_XSH_RS_generator(state, stream);
+  result.raw = (static_cast<uint64_t>(rnd1) << 32) | rnd2;
+  // Set the exponent
+  result.raw |= (static_cast<uint64_t>(1023) << 52);
+  // Return the final result
+  return result.dp - 1.0;
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<float> RandomToTypeUniform<std::complex<float> >(uint64_t* state,
+                                                                                                    uint64_t stream) {
+  const float real = RandomToTypeUniform<float>(state, stream);
+  const float imag = RandomToTypeUniform<float>(state, stream);
+  return std::complex<float>(real, imag);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<double> RandomToTypeUniform<std::complex<double> >(uint64_t* state,
+                                                                                                      uint64_t stream) {
+  const double real = RandomToTypeUniform<double>(state, stream);
+  const double imag = RandomToTypeUniform<double>(state, stream);
+  return std::complex<double>(real, imag);
+}
+
+// Element i is drawn from its own PCG stream, seeded from (seed, i) by PCG_XSH_RS_state_for_index. The functor
+// therefore holds no evolving state: a fill is the same on every device, thread count and packet width, sharing
+// the functor between threads is race-free, and the copy every GPU thread receives cannot replay the same numbers.
+template <typename T>
+class UniformRandomGenerator {
+ public:
+  static constexpr bool PacketAccess = true;
+
+  // Uses the given "seed" if non-zero, otherwise uses a random seed.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE UniformRandomGenerator(uint64_t seed = 0) : m_state(PCG_XSH_RS_state(seed)) {}
+
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(Index i) const {
+    const uint64_t index = static_cast<uint64_t>(i);
+    uint64_t state = PCG_XSH_RS_state_for_index(m_state, index);
+    return RandomToTypeUniform<T>(&state, index);
+  }
+
+  template <typename Packet, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(Index i) const {
+    const int packetSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) T values[packetSize];
+    EIGEN_UNROLL_LOOP
+    for (int j = 0; j < packetSize; ++j) {
+      values[j] = (*this)(i + j);
+    }
+    return internal::pload<Packet>(values);
+  }
+
+ private:
+  uint64_t m_state;
+};
+
+template <typename Scalar>
+struct functor_traits<UniformRandomGenerator<Scalar> > {
+  enum {
+    // Rough estimate for floating point, multiplied by ceil(sizeof(T) / sizeof(float)).
+    Cost = 12 * NumTraits<Scalar>::AddCost * ((sizeof(Scalar) + sizeof(float) - 1) / sizeof(float)),
+    PacketAccess = UniformRandomGenerator<Scalar>::PacketAccess,
+    // Element i is a pure function of (seed, i), so re-evaluating the expression or visiting the indices in
+    // block order reproduces the same fill. This is what lets the nullary evaluator serve blocks.
+    IsRepeatable = true
+  };
+};
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T RandomToTypeNormal(uint64_t* state, uint64_t stream) {
+  // Use the ratio of uniform method to generate numbers following a normal
+  // distribution. See for example Numerical Recipes chapter 7.3.9 for the
+  // details.
+  T u, v, q;
+  do {
+    u = RandomToTypeUniform<T>(state, stream);
+    v = T(1.7156) * (RandomToTypeUniform<T>(state, stream) - T(0.5));
+    const T x = u - T(0.449871);
+    const T y = numext::abs(v) + T(0.386595);
+    q = x * x + y * (T(0.196) * y - T(0.25472) * x);
+  } while (q > T(0.27597) && (q > T(0.27846) || v * v > T(-4) * numext::log(u) * u * u));
+
+  return v / u;
+}
+
+// For 16-bit types, compute the deviate in float and round once. Running the
+// rejection algorithm above directly in 16-bit arithmetic truncates the tails
+// (|v/u| is limited by the coarse uniform grid) and emits NaN/Inf: the 16-bit
+// uniform draw is exactly 0 with probability 2^-10 (half) / 2^-7 (bfloat16),
+// so log(u) = -inf poisons the acceptance test and v/u returns +/-inf.
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half RandomToTypeNormal<Eigen::half>(uint64_t* state, uint64_t stream) {
+  return Eigen::half(RandomToTypeNormal<float>(state, stream));
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 RandomToTypeNormal<Eigen::bfloat16>(uint64_t* state,
+                                                                                          uint64_t stream) {
+  return Eigen::bfloat16(RandomToTypeNormal<float>(state, stream));
+}
+
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<float> RandomToTypeNormal<std::complex<float> >(uint64_t* state,
+                                                                                                   uint64_t stream) {
+  const float real = RandomToTypeNormal<float>(state, stream);
+  const float imag = RandomToTypeNormal<float>(state, stream);
+  return std::complex<float>(real, imag);
+}
+template <>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<double> RandomToTypeNormal<std::complex<double> >(uint64_t* state,
+                                                                                                     uint64_t stream) {
+  const double real = RandomToTypeNormal<double>(state, stream);
+  const double imag = RandomToTypeNormal<double>(state, stream);
+  return std::complex<double>(real, imag);
+}
+
+// Per-element streams as in UniformRandomGenerator; the rejection loop of RandomToTypeNormal draws as many values
+// as it needs from element i's own stream.
+template <typename T>
+class NormalRandomGenerator {
+ public:
+  static constexpr bool PacketAccess = true;
+
+  // Uses the given "seed" if non-zero, otherwise uses a random seed.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NormalRandomGenerator(uint64_t seed = 0) : m_state(PCG_XSH_RS_state(seed)) {}
+
+  template <typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(Index i) const {
+    const uint64_t index = static_cast<uint64_t>(i);
+    uint64_t state = PCG_XSH_RS_state_for_index(m_state, index);
+    return RandomToTypeNormal<T>(&state, index);
+  }
+
+  template <typename Packet, typename Index>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(Index i) const {
+    const int packetSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) T values[packetSize];
+    EIGEN_UNROLL_LOOP
+    for (int j = 0; j < packetSize; ++j) {
+      values[j] = (*this)(i + j);
+    }
+    return internal::pload<Packet>(values);
+  }
+
+ private:
+  uint64_t m_state;
+};
+
+template <typename Scalar>
+struct functor_traits<NormalRandomGenerator<Scalar> > {
+  enum {
+    // On average, we need to generate about 3 random numbers
+    // 15 mul, 8 add, 1.5 logs
+    Cost = 3 * functor_traits<UniformRandomGenerator<Scalar> >::Cost + 15 * NumTraits<Scalar>::AddCost +
+           8 * NumTraits<Scalar>::AddCost + 3 * functor_traits<scalar_log_op<Scalar> >::Cost / 2,
+    PacketAccess = NormalRandomGenerator<Scalar>::PacketAccess,
+    // Pure in (seed, index) as UniformRandomGenerator is: the rejection loop draws from element i's own stream.
+    IsRepeatable = true
+  };
+};
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_RANDOM_H
diff --git a/contrib/Eigen/src/Tensor/TensorReduction.h b/contrib/Eigen/src/Tensor/TensorReduction.h
new file mode 100644
index 0000000..ff0175d
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorReduction.h
@@ -0,0 +1,1117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2016 Mehdi Goli, Codeplay Software Ltd <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_REDUCTION_H
+#define EIGEN_TENSOR_TENSOR_REDUCTION_H
+
+// clang is incompatible with the CUDA syntax wrt making a kernel a class friend,
+// so we'll use a macro to make clang happy.
+#ifndef KERNEL_FRIEND
+#if defined(__clang__) && (defined(__CUDA__) || defined(__HIP__))
+#define KERNEL_FRIEND friend __global__ EIGEN_HIP_LAUNCH_BOUNDS_1024
+#else
+#define KERNEL_FRIEND friend
+#endif
+#endif
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
+struct traits<TensorReductionOp<Op, Dims, XprType, MakePointer_> > : traits<XprType> {
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::Scalar Scalar;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions - array_size<Dims>::value;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+
+  template <class T>
+  struct MakePointer {
+    typedef typename MakePointer_<T>::Type Type;
+  };
+};
+
+template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
+struct eval<TensorReductionOp<Op, Dims, XprType, MakePointer_>, Eigen::Dense> {
+  typedef const TensorReductionOp<Op, Dims, XprType, MakePointer_>& type;
+};
+
+template <typename OutputDims>
+struct DimInitializer {
+  template <typename InputDims, typename ReducedDims>
+  EIGEN_DEVICE_FUNC static void run(const InputDims& input_dims,
+                                    const array<bool, internal::array_size<InputDims>::value>& reduced,
+                                    OutputDims* output_dims, ReducedDims* reduced_dims) {
+    const int NumInputDims = internal::array_size<InputDims>::value;
+    int outputIndex = 0;
+    int reduceIndex = 0;
+    for (int i = 0; i < NumInputDims; ++i) {
+      if (reduced[i]) {
+        (*reduced_dims)[reduceIndex] = input_dims[i];
+        ++reduceIndex;
+      } else {
+        (*output_dims)[outputIndex] = input_dims[i];
+        ++outputIndex;
+      }
+    }
+  }
+};
+
+template <>
+struct DimInitializer<Sizes<> > {
+  template <typename InputDims, typename Index, size_t Rank>
+  EIGEN_DEVICE_FUNC static void run(const InputDims& input_dims, const array<bool, Rank>&, Sizes<>*,
+                                    array<Index, Rank>* reduced_dims) {
+    const int NumInputDims = internal::array_size<InputDims>::value;
+    for (int i = 0; i < NumInputDims; ++i) {
+      (*reduced_dims)[i] = input_dims[i];
+    }
+  }
+};
+
+template <typename ReducedDims, int NumTensorDims, int Layout>
+struct are_inner_most_dims {
+  static constexpr bool value = false;
+};
+template <typename ReducedDims, int NumTensorDims, int Layout>
+struct preserve_inner_most_dims {
+  static constexpr bool value = false;
+};
+
+template <typename ReducedDims, int NumTensorDims>
+struct are_inner_most_dims<ReducedDims, NumTensorDims, ColMajor> {
+  static constexpr bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
+  static constexpr bool tmp2 = index_statically_eq<ReducedDims>(0, 0);
+  static constexpr bool tmp3 =
+      index_statically_eq<ReducedDims>(array_size<ReducedDims>::value - 1, array_size<ReducedDims>::value - 1);
+  static constexpr bool value = tmp1 & tmp2 & tmp3;
+};
+template <typename ReducedDims, int NumTensorDims>
+struct are_inner_most_dims<ReducedDims, NumTensorDims, RowMajor> {
+  static constexpr bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
+  static constexpr bool tmp2 = index_statically_eq<ReducedDims>(0, NumTensorDims - array_size<ReducedDims>::value);
+  static constexpr bool tmp3 = index_statically_eq<ReducedDims>(array_size<ReducedDims>::value - 1, NumTensorDims - 1);
+  static constexpr bool value = tmp1 & tmp2 & tmp3;
+};
+template <typename ReducedDims, int NumTensorDims>
+struct preserve_inner_most_dims<ReducedDims, NumTensorDims, ColMajor> {
+  static constexpr bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
+  static constexpr bool tmp2 = index_statically_gt<ReducedDims>(0, 0);
+  static constexpr bool value = tmp1 & tmp2;
+};
+template <typename ReducedDims, int NumTensorDims>
+struct preserve_inner_most_dims<ReducedDims, NumTensorDims, RowMajor> {
+  static constexpr bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
+  static constexpr bool tmp2 = index_statically_lt<ReducedDims>(array_size<ReducedDims>::value - 1, NumTensorDims - 1);
+  static constexpr bool value = tmp1 & tmp2;
+};
+
+template <int DimIndex, typename Self, typename Op>
+struct GenericDimReducer {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
+                                                           Op& reducer, typename Self::CoeffReturnType* accum) {
+    EIGEN_STATIC_ASSERT((DimIndex > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    for (int j = 0; j < self.m_reducedDims[DimIndex]; ++j) {
+      const typename Self::Index input = firstIndex + j * self.m_reducedStrides[DimIndex];
+      GenericDimReducer<DimIndex - 1, Self, Op>::reduce(self, input, reducer, accum);
+    }
+  }
+};
+template <typename Self, typename Op>
+struct GenericDimReducer<0, Self, Op> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
+                                                           Op& reducer, typename Self::CoeffReturnType* accum) {
+    for (int j = 0; j < self.m_reducedDims[0]; ++j) {
+      const typename Self::Index input = firstIndex + j * self.m_reducedStrides[0];
+      reducer.reduce(self.m_impl.coeff(input), accum);
+    }
+  }
+};
+template <typename Self, typename Op>
+struct GenericDimReducer<-1, Self, Op> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index index, Op& reducer,
+                                                           typename Self::CoeffReturnType* accum) {
+    reducer.reduce(self.m_impl.coeff(index), accum);
+  }
+};
+
+template <typename Self, typename Op,
+          bool Vectorizable = (Self::InputPacketAccess && Self::ReducerTraits::PacketAccess),
+          bool UseTreeReduction = (!Self::ReducerTraits::IsStateful && !Self::ReducerTraits::IsExactlyAssociative &&
+                                   // GPU threads can quickly run out of stack space
+                                   // for moderately sized inputs.
+                                   !Self::RunningOnGPU)>
+struct InnerMostDimReducer {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
+      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer) {
+    using Index = typename Self::Index;
+    typename Self::CoeffReturnType accum0 = reducer.initialize();
+    Index j = 0;
+    // The accumulators take interleaved operands and are merged by feeding one back through
+    // reduce(), so this needs a pure combine that is also associative and commutative;
+    // reducer_can_reorder_accumulators marks the reducers that guarantee both.
+    EIGEN_IF_CONSTEXPR (reducer_can_reorder_accumulators<Op>::value) {
+      if (numValuesToReduce >= 8) {
+        typename Self::CoeffReturnType accum1 = reducer.initialize(), accum2 = reducer.initialize();
+        typename Self::CoeffReturnType accum3 = reducer.initialize(), accum4 = reducer.initialize();
+        typename Self::CoeffReturnType accum5 = reducer.initialize(), accum6 = reducer.initialize();
+        typename Self::CoeffReturnType accum7 = reducer.initialize();
+        const Index unrolledEnd = numValuesToReduce - numValuesToReduce % 8;
+        for (; j < unrolledEnd; j += 8) {
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 0), &accum0);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 1), &accum1);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 2), &accum2);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 3), &accum3);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 4), &accum4);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 5), &accum5);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 6), &accum6);
+          reducer.reduce(self.m_impl.coeff(firstIndex + j + 7), &accum7);
+        }
+        reducer.reduce(accum1, &accum0);
+        reducer.reduce(accum2, &accum0);
+        reducer.reduce(accum3, &accum0);
+        reducer.reduce(accum4, &accum0);
+        reducer.reduce(accum5, &accum0);
+        reducer.reduce(accum6, &accum0);
+        reducer.reduce(accum7, &accum0);
+      }
+    }
+    for (; j < numValuesToReduce; ++j) {
+      reducer.reduce(self.m_impl.coeff(firstIndex + j), &accum0);
+    }
+    return reducer.finalize(accum0);
+  }
+};
+
+template <typename Self, typename Op>
+struct InnerMostDimReducer<Self, Op, true, false> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
+      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer0) {
+    using Index = typename Self::Index;
+    constexpr Index packetSize = internal::unpacket_traits<typename Self::PacketReturnType>::size;
+    Index start = 0;
+    typename Self::PacketReturnType paccum0 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+    EIGEN_IF_CONSTEXPR (!Self::ReducerTraits::IsStateful) {
+      if (numValuesToReduce >= 4 * packetSize) {
+        const Index VectorizedSize4 = (numValuesToReduce / (4 * packetSize)) * (4 * packetSize);
+        typename Self::PacketReturnType paccum1 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+        typename Self::PacketReturnType paccum2 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+        typename Self::PacketReturnType paccum3 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+        const Index offset0 = firstIndex;
+        const Index offset1 = firstIndex + packetSize;
+        const Index offset2 = firstIndex + 2 * packetSize;
+        const Index offset3 = firstIndex + 3 * packetSize;
+        for (Index j = 0; j < VectorizedSize4; j += 4 * packetSize) {
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset0 + j), &paccum0);
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset1 + j), &paccum1);
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset2 + j), &paccum2);
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset3 + j), &paccum3);
+        }
+        reducer0.reducePacket(paccum1, &paccum0);
+        reducer0.reducePacket(paccum2, &paccum0);
+        reducer0.reducePacket(paccum3, &paccum0);
+        start = VectorizedSize4;
+      }
+    }
+    if (start <= (numValuesToReduce - packetSize)) {
+      const Index VectorizedSize = (numValuesToReduce / packetSize) * packetSize;
+      for (Index j = start; j < VectorizedSize; j += packetSize) {
+        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(firstIndex + j), &paccum0);
+      }
+      start = VectorizedSize;
+    }
+    typename Self::CoeffReturnType accum = reducer0.initialize();
+    for (Index j = start; j < numValuesToReduce; ++j) {
+      reducer0.reduce(self.m_impl.coeff(firstIndex + j), &accum);
+    }
+    return reducer0.finalizeBoth(accum, paccum0);
+  }
+};
+
+#if !defined(EIGEN_HIPCC)
+
+// The following implements tree-based reduction, which improves the accuracy
+// of sum and mean reductions, since each of the n inputs only participates in
+// O(log n) additions.
+template <typename T>
+EIGEN_DEVICE_FUNC inline Index LeafSize() {
+  return 1024;
+}
+template <>
+EIGEN_DEVICE_FUNC inline Index LeafSize<half>() {
+  return 200;
+}
+template <>
+EIGEN_DEVICE_FUNC inline Index LeafSize<bfloat16>() {
+  return 128;
+}
+
+template <typename Self, typename Op>
+struct InnerMostDimReducer<Self, Op, false, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
+      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer) {
+    const Index kLeafSize = LeafSize<typename Self::CoeffReturnType>();
+    typename Self::CoeffReturnType accum = reducer.initialize();
+    if (numValuesToReduce > kLeafSize) {
+      const typename Self::Index half = numValuesToReduce / 2;
+      // Recursively reduce the two halves.
+      reducer.reduce(reduce(self, firstIndex, half, reducer), &accum);
+      reducer.reduce(reduce(self, firstIndex + half, numValuesToReduce - half, reducer), &accum);
+      return reducer.finalize(accum);
+    } else {
+      return InnerMostDimReducer<Self, Op, false, false>::reduce(self, firstIndex, numValuesToReduce, reducer);
+    }
+  }
+};
+
+template <typename Self, typename Op>
+struct InnerMostDimReducer<Self, Op, true, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
+      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer) {
+    const Index kLeafSize = LeafSize<typename Self::CoeffReturnType>();
+    const typename Self::Index packetSize = internal::unpacket_traits<typename Self::PacketReturnType>::size;
+    typename Self::CoeffReturnType accum = reducer.initialize();
+    if (numValuesToReduce > packetSize * kLeafSize) {
+      // Make sure the split point is aligned on a packet boundary.
+      const typename Self::Index split =
+          packetSize *
+          numext::div_ceil(firstIndex + numext::div_ceil(numValuesToReduce, typename Self::Index(2)), packetSize);
+      const typename Self::Index num_left = numext::mini(split - firstIndex, numValuesToReduce);
+      reducer.reduce(reduce(self, firstIndex, num_left, reducer), &accum);
+      if (num_left < numValuesToReduce) {
+        reducer.reduce(reduce(self, split, numValuesToReduce - num_left, reducer), &accum);
+      }
+      return reducer.finalize(accum);
+    } else {
+      return InnerMostDimReducer<Self, Op, true, false>::reduce(self, firstIndex, numValuesToReduce, reducer);
+    }
+  }
+};
+#endif
+
+template <int DimIndex, typename Self, typename Op,
+          bool vectorizable = (Self::InputPacketAccess && Self::ReducerTraits::PacketAccess)>
+struct InnerMostDimPreserver {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self&, typename Self::Index, Op&,
+                                                           typename Self::PacketReturnType*) {
+    eigen_assert(false && "should never be called");
+  }
+};
+
+template <int DimIndex, typename Self, typename Op>
+struct InnerMostDimPreserver<DimIndex, Self, Op, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
+                                                           Op& reducer, typename Self::PacketReturnType* accum) {
+    EIGEN_STATIC_ASSERT((DimIndex > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    for (typename Self::Index j = 0; j < self.m_reducedDims[DimIndex]; ++j) {
+      const typename Self::Index input = firstIndex + j * self.m_reducedStrides[DimIndex];
+      InnerMostDimPreserver<DimIndex - 1, Self, Op>::reduce(self, input, reducer, accum);
+    }
+  }
+};
+
+template <typename Self, typename Op>
+struct InnerMostDimPreserver<0, Self, Op, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
+                                                           Op& reducer0, typename Self::PacketReturnType* accum0) {
+    using Index = typename Self::Index;
+    const Index stride = self.m_reducedStrides[0];
+    const Index size = self.m_reducedDims[0];
+    EIGEN_IF_CONSTEXPR (!Self::ReducerTraits::IsStateful) {
+      if (size >= 16) {
+        const Index unrolled_size4 = (size / 4) * 4;
+        typename Self::PacketReturnType accum1 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+        typename Self::PacketReturnType accum2 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+        typename Self::PacketReturnType accum3 = reducer0.template initializePacket<typename Self::PacketReturnType>();
+        for (Index j = 0; j < unrolled_size4; j += 4) {
+          const Index input0 = firstIndex + j * stride;
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input0), accum0);
+          const Index input1 = firstIndex + (j + 1) * stride;
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input1), &accum1);
+          const Index input2 = firstIndex + (j + 2) * stride;
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input2), &accum2);
+          const Index input3 = firstIndex + (j + 3) * stride;
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input3), &accum3);
+        }
+        reducer0.reducePacket(accum1, accum0);
+        reducer0.reducePacket(accum2, accum0);
+        reducer0.reducePacket(accum3, accum0);
+        for (Index j = unrolled_size4; j < size; ++j) {
+          Index input = firstIndex + j * stride;
+          reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input), accum0);
+        }
+        return;
+      }
+    }
+    for (Index j = 0; j < size; ++j) {
+      Index input = firstIndex + j * stride;
+      reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input), accum0);
+    }
+  }
+};
+template <typename Self, typename Op>
+struct InnerMostDimPreserver<-1, Self, Op, true> {
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self&, typename Self::Index, Op&,
+                                                           typename Self::PacketReturnType*) {
+    eigen_assert(false && "should never be called");
+  }
+};
+
+// Default full reducer
+template <typename Self, typename Op, typename Device,
+          bool Vectorizable = (Self::InputPacketAccess && Self::ReducerTraits::PacketAccess)>
+struct FullReducer {
+  static constexpr bool HasOptimizedImplementation = false;
+
+  static EIGEN_DEVICE_FUNC void run(const Self& self, Op& reducer, const Device&,
+                                    typename Self::EvaluatorPointerType output) {
+    const typename Self::Index num_coeffs = array_prod(self.m_impl.dimensions());
+    *output = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, 0, num_coeffs, reducer);
+  }
+};
+
+#ifdef EIGEN_USE_THREADS
+// Multithreaded full reducer
+template <typename Self, typename Op, bool Vectorizable>
+struct FullReducer<Self, Op, ThreadPoolDevice, Vectorizable> {
+  static constexpr bool HasOptimizedImplementation = !Self::ReducerTraits::IsStateful;
+  static constexpr Index PacketSize = unpacket_traits<typename Self::PacketReturnType>::size;
+
+  // launch one reducer per thread and accumulate the result.
+  static void run(const Self& self, Op& reducer, const ThreadPoolDevice& device,
+                  typename Self::CoeffReturnType* output) {
+    typedef typename Self::Index Index;
+    const Index num_coeffs = array_prod(self.m_impl.dimensions());
+    if (num_coeffs == 0) {
+      *output = reducer.finalize(reducer.initialize());
+      return;
+    }
+    const TensorOpCost cost = self.m_impl.costPerCoeff(Vectorizable) +
+                              TensorOpCost(0, 0, internal::functor_traits<Op>::Cost, Vectorizable, PacketSize);
+    const Index num_threads = TensorCostModel<ThreadPoolDevice>::numThreads(num_coeffs, cost, device.numThreads());
+    if (num_threads == 1) {
+      *output = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, 0, num_coeffs, reducer);
+      return;
+    }
+    const Index blocksize = num_coeffs / num_threads;
+    const Index numblocks = blocksize > 0 ? num_coeffs / blocksize : 0;
+    eigen_assert(num_coeffs >= numblocks * blocksize);
+
+    Barrier barrier(internal::convert_index<unsigned int>(numblocks));
+    MaxSizeVector<typename Self::CoeffReturnType> shards(numblocks, reducer.initialize());
+    for (Index i = 0; i < numblocks; ++i) {
+      auto run_shard = [i, blocksize, &self, &barrier, &shards, &reducer]() {
+        shards[i] = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, i * blocksize, blocksize, reducer);
+        barrier.Notify();
+      };
+      device.enqueue(std::move(run_shard));
+    }
+    typename Self::CoeffReturnType finalShard;
+    if (numblocks * blocksize < num_coeffs) {
+      finalShard = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, numblocks * blocksize,
+                                                                       num_coeffs - numblocks * blocksize, reducer);
+    } else {
+      finalShard = reducer.initialize();
+    }
+    barrier.Wait();
+
+    for (Index i = 0; i < numblocks; ++i) {
+      reducer.reduce(shards[i], &finalShard);
+    }
+    *output = reducer.finalize(finalShard);
+  }
+};
+
+#endif
+
+// Default inner reducer
+template <typename Self, typename Op, typename Device>
+struct InnerReducer {
+  static constexpr bool HasOptimizedImplementation = false;
+
+  EIGEN_DEVICE_FUNC static bool run(const Self&, Op&, const Device&, typename Self::CoeffReturnType*,
+                                    typename Self::Index, typename Self::Index) {
+    eigen_assert(false && "Not implemented");
+    return true;
+  }
+};
+
+// Default outer reducer
+template <typename Self, typename Op, typename Device>
+struct OuterReducer {
+  static constexpr bool HasOptimizedImplementation = false;
+
+  EIGEN_DEVICE_FUNC static bool run(const Self&, Op&, const Device&, typename Self::CoeffReturnType*,
+                                    typename Self::Index, typename Self::Index) {
+    eigen_assert(false && "Not implemented");
+    return true;
+  }
+};
+
+#ifdef EIGEN_USE_SYCL
+// Default Generic reducer
+template <typename Self, typename Op, typename Device>
+struct GenericReducer {
+  static constexpr bool HasOptimizedImplementation = false;
+
+  EIGEN_DEVICE_FUNC static bool run(const Self&, Op&, const Device&, typename Self::CoeffReturnType*,
+                                    typename Self::Index, typename Self::Index) {
+    eigen_assert(false && "Not implemented");
+    return true;
+  }
+};
+#endif
+
+#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
+template <int B, int N, typename S, typename R, typename I_>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernel(R, const S, I_, typename S::CoeffReturnType*,
+                                                                 unsigned int*);
+
+#if defined(EIGEN_GPUCC)
+// The scratch parameter is half* as in the definitions (TensorReductionGpu.h): declared as
+// packet_traits<half>::type*, it is Packet4h2* in the device pass, which makes the name denote two templates there.
+template <typename S, typename R, typename I_>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitFullReduxKernelHalfFloat(R, const S, I_, half*);
+template <int B, int N, typename S, typename R, typename I_>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernelHalfFloat(R, const S, I_, half*, half*);
+template <int NPT, typename S, typename R, typename I_>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernelHalfFloat(R, const S, I_, I_, half*);
+
+#endif
+
+template <int NPT, typename S, typename R, typename I_>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
+
+template <int NPT, typename S, typename R, typename I_>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void OuterReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
+#endif
+
+/**
+ * For SYCL, the return type of the reduction is deduced from the initialize method of the given Op.
+ * This allows the reduction to have a different type for the accumulator than the input data type.
+ * If this is the case, the functor needs to have two reduce methods: one for reducing an element of the input
+ * with the accumulator and the other for reducing two accumulators.
+ * Such a reducer can be useful for instance when the accumulator is a boolean or a bitset that checks for
+ * some properties of the input.
+ */
+template <typename Op, typename CoeffReturnType>
+struct ReductionReturnType {
+#if defined(EIGEN_USE_SYCL)
+  typedef std::remove_const_t<decltype(std::declval<Op>().initialize())> type;
+#else
+  typedef std::remove_const_t<CoeffReturnType> type;
+#endif
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor reduction class.
+ *
+ */
+template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
+class TensorReductionOp : public TensorBase<TensorReductionOp<Op, Dims, XprType, MakePointer_>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorReductionOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorReductionOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorReductionOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorReductionOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReductionOp(const XprType& expr, const Dims& dims)
+      : m_expr(expr), m_dims(dims) {}
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReductionOp(const XprType& expr, const Dims& dims, const Op& reducer)
+      : m_expr(expr), m_dims(dims), m_reducer(reducer) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const XprType& expression() const { return m_expr; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dims& dims() const { return m_dims; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Op& reducer() const { return m_reducer; }
+
+  // Rank 0 guarantees one coefficient, so only rank-0 reductions convert directly to a scalar.
+  template <int NumDims = internal::traits<TensorReductionOp>::NumDimensions, EIGEN_SFINAE_ENABLE_IF(NumDims == 0)>
+  EIGEN_STRONG_INLINE operator CoeffReturnType() const {
+    TensorEvaluator<const TensorReductionOp, DefaultDevice> evaluator(*this, DefaultDevice());
+    evaluator.evalSubExprsIfNeeded(nullptr);
+    const CoeffReturnType result = evaluator.coeff(0);
+    evaluator.cleanup();
+    return result;
+  }
+
+#if !defined(EIGEN_PARSED_BY_DOXYGEN)
+  // Exact-match friends keep mixed-scalar arithmetic from being ambiguous between the tensor
+  // operators and built-in arithmetic on the scalar conversion above. is_scalar_operand keeps
+  // reduction-with-reduction arithmetic on the tensor-tensor path, which the conversion to
+  // Scalar would otherwise make ambiguous as well.
+#define EIGEN_TENSOR_REDUCTION_SCALAR_BINOP(op, name)                                                            \
+  template <typename T, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<T, Scalar>::value))>                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend const TensorCwiseUnaryOp<                                         \
+      internal::bind1st_op<internal::scalar_##name##_op<Scalar> >, const TensorReductionOp>                      \
+  op(const T& lhs, const TensorReductionOp& rhs) {                                                               \
+    return rhs.unaryExpr(internal::bind1st_op<internal::scalar_##name##_op<Scalar> >(static_cast<Scalar>(lhs))); \
+  }                                                                                                              \
+  template <typename T, EIGEN_SFINAE_ENABLE_IF((internal::is_scalar_operand<T, Scalar>::value))>                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend const TensorCwiseUnaryOp<                                         \
+      internal::bind2nd_op<internal::scalar_##name##_op<Scalar> >, const TensorReductionOp>                      \
+  op(const TensorReductionOp& lhs, const T& rhs) {                                                               \
+    return lhs.unaryExpr(internal::bind2nd_op<internal::scalar_##name##_op<Scalar> >(static_cast<Scalar>(rhs))); \
+  }
+
+  EIGEN_TENSOR_REDUCTION_SCALAR_BINOP(operator+, sum)
+  EIGEN_TENSOR_REDUCTION_SCALAR_BINOP(operator-, difference)
+  EIGEN_TENSOR_REDUCTION_SCALAR_BINOP(operator*, product)
+  EIGEN_TENSOR_REDUCTION_SCALAR_BINOP(operator/, quotient)
+#undef EIGEN_TENSOR_REDUCTION_SCALAR_BINOP
+#endif
+
+ protected:
+  typename XprType::Nested m_expr;
+  const Dims m_dims;
+  const Op m_reducer;
+};
+
+template <typename ArgType, typename Device>
+struct TensorReductionEvaluatorBase;
+
+// Eval as rvalue
+template <typename Op, typename Dims, typename ArgType, template <class> class MakePointer_, typename Device>
+struct TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> {
+  typedef internal::reducer_traits<Op, Device> ReducerTraits;
+  typedef Dims ReducedDims;
+  typedef TensorReductionOp<Op, Dims, ArgType, MakePointer_> XprType;
+  typedef typename XprType::Index Index;
+  typedef ArgType ChildType;
+  typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
+  static constexpr int NumInputDims = internal::array_size<InputDimensions>::value;
+  static constexpr int NumReducedDims = internal::array_size<Dims>::value;
+  static constexpr int NumOutputDims = NumInputDims - NumReducedDims;
+  typedef std::conditional_t<NumOutputDims == 0, Sizes<>, DSizes<Index, NumOutputDims> > Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> Self;
+  static constexpr bool InputPacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess;
+  typedef typename internal::ReductionReturnType<Op, typename XprType::CoeffReturnType>::type CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr Index PacketSize = PacketType<CoeffReturnType, Device>::size;
+
+  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  // Subset of strides of the input tensor for the non-reduced dimensions.
+  // Indexed by output dimensions.
+  static constexpr int NumPreservedStrides = max_n_1<NumOutputDims>::size;
+
+  // For full reductions
+#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
+  static constexpr bool RunningOnGPU = std::is_same<Device, Eigen::GpuDevice>::value;
+  static constexpr bool RunningOnSycl = false;
+#elif defined(EIGEN_USE_SYCL)
+  static constexpr bool RunningOnSycl = std::is_same<internal::remove_all_t<Device>, Eigen::SyclDevice>::value;
+  static constexpr bool RunningOnGPU = false;
+#else
+  static constexpr bool RunningOnGPU = false;
+  static constexpr bool RunningOnSycl = false;
+#endif
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = Self::InputPacketAccess && ReducerTraits::PacketAccess,
+    BlockAccess = false,
+    PreferBlockAccess = true,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  static constexpr bool ReducingInnerMostDims = internal::are_inner_most_dims<Dims, NumInputDims, Layout>::value;
+  static constexpr bool PreservingInnerMostDims = internal::preserve_inner_most_dims<Dims, NumInputDims, Layout>::value;
+  static constexpr bool RunningFullReduction = (NumOutputDims == 0);
+
+  EIGEN_STRONG_INLINE TensorReductionEvaluatorBase(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_reducer(op.reducer()), m_result(nullptr), m_device(device) {
+    EIGEN_STATIC_ASSERT((NumInputDims >= NumReducedDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    EIGEN_STATIC_ASSERT((!ReducingInnerMostDims | !PreservingInnerMostDims | (NumReducedDims == NumInputDims)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    // Build the bitmap indicating if an input dimension is reduced or not.
+    for (int i = 0; i < NumInputDims; ++i) {
+      m_reduced[i] = false;
+    }
+    for (int i = 0; i < NumReducedDims; ++i) {
+      eigen_assert(op.dims()[i] >= 0);
+      eigen_assert(op.dims()[i] < NumInputDims);
+      m_reduced[op.dims()[i]] = true;
+    }
+
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    internal::DimInitializer<Dimensions>::run(input_dims, m_reduced, &m_dimensions, &m_reducedDims);
+
+    // Precompute output strides.
+    EIGEN_IF_CONSTEXPR (NumOutputDims > 0) {
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        m_outputStrides[0] = 1;
+        for (int i = 1; i < NumOutputDims; ++i) {
+          m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+          m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i]);
+        }
+      } else {
+        m_outputStrides[static_cast<size_t>(NumOutputDims - 1)] = 1;
+        for (int i = NumOutputDims - 2; i >= 0; --i) {
+          m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+          m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i]);
+        }
+      }
+    }
+
+    // Precompute input strides.
+    EIGEN_IF_CONSTEXPR (NumInputDims > 0) {
+      array<Index, NumInputDims> input_strides;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        input_strides[0] = 1;
+        for (int i = 1; i < NumInputDims; ++i) {
+          input_strides[i] = input_strides[i - 1] * input_dims[i - 1];
+        }
+      } else {
+        input_strides.back() = 1;
+        for (int i = NumInputDims - 2; i >= 0; --i) {
+          input_strides[i] = input_strides[i + 1] * input_dims[i + 1];
+        }
+      }
+
+      int outputIndex = 0;
+      int reduceIndex = 0;
+      for (int i = 0; i < NumInputDims; ++i) {
+        if (m_reduced[i]) {
+          m_reducedStrides[reduceIndex] = input_strides[i];
+          ++reduceIndex;
+        } else {
+          m_preservedStrides[outputIndex] = input_strides[i];
+          m_output_to_input_dim_map[outputIndex] = i;
+          ++outputIndex;
+        }
+      }
+    }
+
+    // Special case for full reductions
+    EIGEN_IF_CONSTEXPR (NumOutputDims == 0) {
+      m_preservedStrides[0] = internal::array_prod(input_dims);
+    }
+
+    m_numValuesToReduce = NumOutputDims == 0 ? internal::array_prod(input_dims)
+                          : (static_cast<int>(Layout) == static_cast<int>(ColMajor))
+                              ? m_preservedStrides[0]
+                              : m_preservedStrides[static_cast<size_t>(NumOutputDims - 1)];
+
+    // Runtime mirror of the static `ReducingInnerMostDims` predicate, set when
+    // the reduce dims aren't statically known (e.g. a plain std::array).
+    m_reducingInnerMostDims = (NumReducedDims > 0);
+    for (int i = 0; i < NumReducedDims && m_reducingInnerMostDims; ++i) {
+      const int axis = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? i : NumInputDims - 1 - i;
+      if (!m_reduced[axis]) m_reducingInnerMostDims = false;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeededCommon(EvaluatorPointerType data) {
+    // Use the FullReducer if possible.
+    EIGEN_IF_CONSTEXPR (RunningFullReduction) {
+      if (RunningOnSycl || (internal::FullReducer<Self, Op, Device>::HasOptimizedImplementation &&
+                            ((RunningOnGPU && (m_device.majorDeviceVersion() >= 3)) || !RunningOnGPU))) {
+        bool need_assign = false;
+        if (!data) {
+          m_result = static_cast<EvaluatorPointerType>(
+              m_device.get((CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType))));
+          data = m_result;
+          need_assign = true;
+        }
+        Op reducer(m_reducer);
+        internal::FullReducer<Self, Op, Device>::run(*this, reducer, m_device, data);
+        return need_assign;
+      }
+    }
+
+    // Attempt to use an optimized reduction.
+    EIGEN_IF_CONSTEXPR (RunningOnGPU || RunningOnSycl) {
+      if ((RunningOnGPU && (m_device.majorDeviceVersion() >= 3)) || (RunningOnSycl)) {
+        bool reducing_inner_dims = true;
+        for (int i = 0; i < NumReducedDims; ++i) {
+          EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+            reducing_inner_dims &= m_reduced[i];
+          } else {
+            reducing_inner_dims &= m_reduced[NumInputDims - 1 - i];
+          }
+        }
+        EIGEN_IF_CONSTEXPR ((internal::InnerReducer<Self, Op, Device>::HasOptimizedImplementation)) {
+          if (reducing_inner_dims || ReducingInnerMostDims) {
+            const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
+            const Index num_coeffs_to_preserve = static_cast<Index>(internal::array_prod(m_dimensions));
+            if (!data) {
+              if ((num_coeffs_to_preserve < 1024 && num_values_to_reduce > num_coeffs_to_preserve &&
+                   num_values_to_reduce > 128) ||
+                  (RunningOnSycl)) {
+                data = static_cast<EvaluatorPointerType>(m_device.get(
+                    (CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType) * num_coeffs_to_preserve)));
+                m_result = data;
+              } else {
+                return true;
+              }
+            }
+            Op reducer(m_reducer);
+            // For SYCL, this always returns false.
+            if (internal::InnerReducer<Self, Op, Device>::run(*this, reducer, m_device, data, num_values_to_reduce,
+                                                              num_coeffs_to_preserve)) {
+              if (m_result) {
+                m_device.deallocate_temp(m_result);
+                m_result = nullptr;
+              }
+              return true;
+            } else {
+              return (m_result != nullptr);
+            }
+          }
+        }
+
+        bool preserving_inner_dims = true;
+        for (int i = 0; i < NumReducedDims; ++i) {
+          EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+            preserving_inner_dims &= m_reduced[NumInputDims - 1 - i];
+          } else {
+            preserving_inner_dims &= m_reduced[i];
+          }
+        }
+        EIGEN_IF_CONSTEXPR ((internal::OuterReducer<Self, Op, Device>::HasOptimizedImplementation)) {
+          if (preserving_inner_dims) {
+            const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
+            const Index num_coeffs_to_preserve = static_cast<Index>(internal::array_prod(m_dimensions));
+            if (!data) {
+              if ((num_coeffs_to_preserve < 1024 && num_values_to_reduce > num_coeffs_to_preserve &&
+                   num_values_to_reduce > 32) ||
+                  (RunningOnSycl)) {
+                data = static_cast<EvaluatorPointerType>(m_device.get(
+                    (CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType) * num_coeffs_to_preserve)));
+                m_result = data;
+              } else {
+                return true;
+              }
+            }
+            Op reducer(m_reducer);
+            // For SYCL, this always returns false.
+            if (internal::OuterReducer<Self, Op, Device>::run(*this, reducer, m_device, data, num_values_to_reduce,
+                                                              num_coeffs_to_preserve)) {
+              if (m_result) {
+                m_device.deallocate_temp(m_result);
+                m_result = nullptr;
+              }
+              return true;
+            } else {
+              return (m_result != nullptr);
+            }
+          }
+        }
+#if defined(EIGEN_USE_SYCL)
+        // If there is no Optimised version for SYCL, the reduction expression
+        // must break into two subexpression and use the SYCL generic Reducer on the device.
+        EIGEN_IF_CONSTEXPR (RunningOnSycl) {
+          const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
+          const Index num_coeffs_to_preserve = static_cast<Index>(internal::array_prod(m_dimensions));
+          if (!data) {
+            data = static_cast<EvaluatorPointerType>(m_device.get(
+                (CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType) * num_coeffs_to_preserve)));
+            m_result = data;
+          }
+          Op reducer(m_reducer);
+          internal::GenericReducer<Self, Op, Device>::run(*this, reducer, m_device, data, num_values_to_reduce,
+                                                          num_coeffs_to_preserve);
+          return (m_result != nullptr);
+        }
+#endif
+      }
+    }
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType data, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [this, data, done](bool) { done(evalSubExprsIfNeededCommon(data)); });
+  }
+#endif
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return evalSubExprsIfNeededCommon(data);
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    m_impl.cleanup();
+    if (m_result) {
+      m_device.deallocate_temp(m_result);
+      m_result = nullptr;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    EIGEN_IF_CONSTEXPR (RunningFullReduction || RunningOnGPU) {
+      if (m_result) {
+        return *(m_result + index);
+      }
+    }
+    Op reducer(m_reducer);
+    EIGEN_IF_CONSTEXPR (ReducingInnerMostDims || RunningFullReduction) {
+      const Index num_values_to_reduce = (static_cast<int>(Layout) == static_cast<int>(ColMajor))
+                                             ? m_preservedStrides[0]
+                                             : m_preservedStrides[NumPreservedStrides - 1];
+      return internal::InnerMostDimReducer<Self, Op>::reduce(*this, firstInput(index), num_values_to_reduce, reducer);
+    } else if (m_reducingInnerMostDims) {
+      return internal::InnerMostDimReducer<Self, Op>::reduce(*this, index * m_numValuesToReduce, m_numValuesToReduce,
+                                                             reducer);
+    } else {
+      typename Self::CoeffReturnType accum = reducer.initialize();
+      internal::GenericDimReducer<NumReducedDims - 1, Self, Op>::reduce(*this, firstInput(index), reducer, &accum);
+      return reducer.finalize(accum);
+    }
+  }
+
+  // TODO(bsteiner): provide a more efficient implementation.
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < Index(internal::array_prod(dimensions())));
+
+    EIGEN_IF_CONSTEXPR (RunningOnGPU) {
+      if (m_result) {
+        return internal::pload<PacketReturnType>(m_result + index);
+      }
+    }
+
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    // Materializing reduction results before storing them avoids a GCC ICE in emit_move_insn. Fixed in GCC 6.5, 7.4,
+    // and 8.1. See issue #1647 and https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85496.
+    EIGEN_IF_CONSTEXPR (ReducingInnerMostDims) {
+      const Index num_values_to_reduce = (static_cast<int>(Layout) == static_cast<int>(ColMajor))
+                                             ? m_preservedStrides[0]
+                                             : m_preservedStrides[NumPreservedStrides - 1];
+      const Index firstIndex = firstInput(index);
+      for (Index i = 0; i < PacketSize; ++i) {
+        Op reducer(m_reducer);
+        const CoeffReturnType value = internal::InnerMostDimReducer<Self, Op>::reduce(
+            *this, firstIndex + i * num_values_to_reduce, num_values_to_reduce, reducer);
+        values[i] = value;
+      }
+    } else EIGEN_IF_CONSTEXPR (PreservingInnerMostDims) {
+      const Index firstIndex = firstInput(index);
+      constexpr int innermost_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumOutputDims - 1;
+      // TBD: extend this to the n innermost dimensions that we preserve.
+      if (((firstIndex % m_dimensions[innermost_dim]) + PacketSize - 1) < m_dimensions[innermost_dim]) {
+        Op reducer(m_reducer);
+        typename Self::PacketReturnType accum = reducer.template initializePacket<typename Self::PacketReturnType>();
+        internal::InnerMostDimPreserver<NumReducedDims - 1, Self, Op>::reduce(*this, firstIndex, reducer, &accum);
+        return reducer.finalizePacket(accum);
+      } else {
+        for (int i = 0; i < PacketSize; ++i) {
+          values[i] = coeff(index + i);
+        }
+      }
+    } else if (m_reducingInnerMostDims) {
+      // Mirror the static `ReducingInnerMostDims` packet path so we don't fall
+      // back to PS coeff() calls that route through the scalar GenericDimReducer.
+      const Index firstIndex = index * m_numValuesToReduce;
+      for (Index i = 0; i < PacketSize; ++i) {
+        Op reducer(m_reducer);
+        const CoeffReturnType value = internal::InnerMostDimReducer<Self, Op>::reduce(
+            *this, firstIndex + i * m_numValuesToReduce, m_numValuesToReduce, reducer);
+        values[i] = value;
+      }
+    } else {
+      for (int i = 0; i < PacketSize; ++i) {
+        values[i] = coeff(index + i);
+      }
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  // Must be called after evalSubExprsIfNeeded().
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    EIGEN_IF_CONSTEXPR (RunningFullReduction) {
+      if (m_result) {
+        return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
+      }
+    }
+    const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
+    const double compute_cost = num_values_to_reduce * internal::functor_traits<Op>::Cost;
+    return m_impl.costPerCoeff(vectorized) * num_values_to_reduce +
+           TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_result; }
+  EIGEN_DEVICE_FUNC const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+  EIGEN_DEVICE_FUNC const Device& device() const { return m_device; }
+
+ private:
+  template <int, typename, typename>
+  friend struct internal::GenericDimReducer;
+  template <typename, typename, bool, bool>
+  friend struct internal::InnerMostDimReducer;
+  template <int, typename, typename, bool>
+  friend struct internal::InnerMostDimPreserver;
+  template <typename S, typename O, typename D, bool V>
+  friend struct internal::FullReducer;
+#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
+  template <int B, int N, typename S, typename R, typename I_>
+  KERNEL_FRIEND void internal::FullReductionKernel(R, const S, I_, typename S::CoeffReturnType*, unsigned int*);
+#if defined(EIGEN_GPUCC)
+  template <typename S, typename R, typename I_>
+  KERNEL_FRIEND void internal::ReductionInitFullReduxKernelHalfFloat(R, const S, I_, half*);
+  template <int B, int N, typename S, typename R, typename I_>
+  KERNEL_FRIEND void internal::FullReductionKernelHalfFloat(R, const S, I_, half*, half*);
+  template <int NPT, typename S, typename R, typename I_>
+  KERNEL_FRIEND void internal::InnerReductionKernelHalfFloat(R, const S, I_, I_, half*);
+#endif
+  template <int NPT, typename S, typename R, typename I_>
+  KERNEL_FRIEND void internal::InnerReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
+
+  template <int NPT, typename S, typename R, typename I_>
+  KERNEL_FRIEND void internal::OuterReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
+#endif
+
+#if defined(EIGEN_USE_SYCL)
+  template <typename Evaluator_, typename Op__>
+  friend class TensorSycl::internal::GenericNondeterministicReducer;
+  // SYCL needs the generic reducer when the reduction is neither inner, outer, nor full.
+  template <typename, typename, typename>
+  friend struct internal::GenericReducer;
+#endif
+
+  template <typename S, typename O, typename D>
+  friend struct internal::InnerReducer;
+
+  // Returns the Index in the input tensor of the first value that needs to be
+  // used to compute the reduction at output index "index".
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index firstInput(Index index) const {
+    EIGEN_IF_CONSTEXPR (ReducingInnerMostDims) {
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        return index * m_preservedStrides[0];
+      } else {
+        return index * m_preservedStrides[NumPreservedStrides - 1];
+      }
+    }
+    // TBD: optimize the case where we preserve the innermost dimensions.
+    Index startInput = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumOutputDims - 1; i > 0; --i) {
+        // This is index_i in the output tensor.
+        const Index idx = index / m_outputStrides[i];
+        startInput += idx * m_preservedStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      EIGEN_IF_CONSTEXPR (PreservingInnerMostDims) {
+        eigen_assert(m_preservedStrides[0] == 1);
+        startInput += index;
+      } else {
+        startInput += index * m_preservedStrides[0];
+      }
+    } else {
+      for (int i = 0; i < NumOutputDims - 1; ++i) {
+        // This is index_i in the output tensor.
+        const Index idx = index / m_outputStrides[i];
+        startInput += idx * m_preservedStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      EIGEN_IF_CONSTEXPR (PreservingInnerMostDims) {
+        eigen_assert(m_preservedStrides[NumPreservedStrides - 1] == 1);
+        startInput += index;
+      } else {
+        startInput += index * m_preservedStrides[NumPreservedStrides - 1];
+      }
+    }
+    return startInput;
+  }
+
+  // Bitmap indicating if an input dimension is reduced or not.
+  array<bool, NumInputDims> m_reduced;
+  // Dimensions of the output of the operation.
+  Dimensions m_dimensions;
+  // Precomputed strides for the output tensor.
+  // Avoid zero-sized arrays, since element access fails to compile on GPU.
+  array<Index, (std::max)(NumOutputDims, 1)> m_outputStrides;
+  array<internal::TensorIntDivisor<Index>, (std::max)(NumOutputDims, 1)> m_fastOutputStrides;
+  array<Index, (std::max)(NumPreservedStrides, 1)> m_preservedStrides;
+  // Map from output to input dimension index.
+  array<Index, (std::max)(NumOutputDims, 1)> m_output_to_input_dim_map;
+  // How many values go into each reduction
+  Index m_numValuesToReduce;
+
+  // Runtime mirror of `ReducingInnerMostDims` (set when Dims is non-static).
+  bool m_reducingInnerMostDims;
+
+  // Subset of strides of the input tensor for the reduced dimensions.
+  // Indexed by reduced dimensions.
+  array<Index, NumReducedDims> m_reducedStrides;
+  // Size of the input dimensions that are reduced.
+  // Indexed by reduced dimensions.
+  array<Index, NumReducedDims> m_reducedDims;
+
+  // Evaluator for the input expression.
+  TensorEvaluator<ArgType, Device> m_impl;
+
+  // Operation to apply for computing the reduction.
+  Op m_reducer;
+
+  EvaluatorPointerType m_result;
+
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+template <typename Op, typename Dims, typename ArgType, template <class> class MakePointer_, typename Device>
+struct TensorEvaluator<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device>
+    : public TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> {
+  typedef TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> Base;
+  EIGEN_STRONG_INLINE TensorEvaluator(const typename Base::XprType& op, const Device& device) : Base(op, device) {}
+};
+
+template <typename Op, typename Dims, typename ArgType, template <class> class MakePointer_>
+struct TensorEvaluator<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Eigen::SyclDevice>
+    : public TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Eigen::SyclDevice> {
+  typedef TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Eigen::SyclDevice>
+      Base;
+  EIGEN_STRONG_INLINE TensorEvaluator(const typename Base::XprType& op, const Eigen::SyclDevice& device)
+      : Base(op, device) {}
+  // The base coeff function uses a recursive method that is not standard layout and cannot be used in
+  // SYCL kernels, so it must be overridden.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Base::CoeffReturnType coeff(typename Base::Index index) const {
+    return *(this->data() + index);
+  }
+  // The base packet function uses a recursive method that is not standard layout and cannot be used in
+  // SYCL kernels, so it must be overridden.
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Base::PacketReturnType packet(typename Base::Index index) const {
+    return internal::pload<typename Base::PacketReturnType>(this->data() + index);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_REDUCTION_H
diff --git a/contrib/Eigen/src/Tensor/TensorReductionGpu.h b/contrib/Eigen/src/Tensor/TensorReductionGpu.h
new file mode 100644
index 0000000..ef17207
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorReductionGpu.h
@@ -0,0 +1,941 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_REDUCTION_GPU_H
+#define EIGEN_TENSOR_TENSOR_REDUCTION_GPU_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
+// Full reducers for GPU, don't vectorize for now
+
+// Reducer function that enables multiple gpu threads to safely accumulate at the same
+// output address. It basically reads the current value of the output variable, and
+// attempts to update it with the new value. If in the meantime another gpu thread
+// updated the content of the output address it will try again.
+template <typename T, typename R>
+__device__ EIGEN_ALWAYS_INLINE void atomicReduce(T* output, T accum, R& reducer) {
+  EIGEN_IF_CONSTEXPR (sizeof(T) == 4) {
+    unsigned int oldval = *reinterpret_cast<unsigned int*>(output);
+    unsigned int newval = oldval;
+    reducer.reduce(accum, reinterpret_cast<T*>(&newval));
+    if (newval == oldval) {
+      return;
+    }
+    unsigned int readback;
+    while ((readback = atomicCAS((unsigned int*)output, oldval, newval)) != oldval) {
+      oldval = readback;
+      newval = oldval;
+      reducer.reduce(accum, reinterpret_cast<T*>(&newval));
+      if (newval == oldval) {
+        return;
+      }
+    }
+  } else EIGEN_IF_CONSTEXPR (sizeof(T) == 8) {
+    unsigned long long oldval = *reinterpret_cast<unsigned long long*>(output);
+    unsigned long long newval = oldval;
+    reducer.reduce(accum, reinterpret_cast<T*>(&newval));
+    if (newval == oldval) {
+      return;
+    }
+    unsigned long long readback;
+    while ((readback = atomicCAS(reinterpret_cast<unsigned long long*>(output), oldval, newval)) != oldval) {
+      oldval = readback;
+      newval = oldval;
+      reducer.reduce(accum, reinterpret_cast<T*>(&newval));
+      if (newval == oldval) {
+        return;
+      }
+    }
+  } else {
+    gpu_assert(0 && "Wordsize not supported");
+  }
+}
+
+// We extend atomicExch to support extra data types
+template <typename Type>
+__device__ inline Type atomicExchCustom(Type* address, Type val) {
+  return atomicExch(address, val);
+}
+
+template <typename T>
+EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR auto reduction_shuffle_mask() {
+#if defined(EIGEN_HIP_DEVICE_COMPILE)
+  return 0xFFFFFFFFFFFFFFFFull;
+#else
+  return 0xFFFFFFFFu;
+#endif
+}
+
+template <typename T>
+__device__ EIGEN_ALWAYS_INLINE T reduction_shuffle_down(T value, int offset) {
+#if defined(EIGEN_HIPCC)
+  return __shfl_down(value, offset, warpSize);
+#else
+  return __shfl_down_sync(reduction_shuffle_mask<T>(), value, offset, warpSize);
+#endif
+}
+
+template <>
+__device__ EIGEN_ALWAYS_INLINE int reduction_shuffle_down<int>(int value, int offset) {
+#if defined(EIGEN_HIPCC)
+  return __shfl_down(value, offset, warpSize);
+#else
+  return __shfl_down_sync(reduction_shuffle_mask<int>(), value, offset, warpSize);
+#endif
+}
+
+template <>
+__device__ EIGEN_ALWAYS_INLINE float reduction_shuffle_down<float>(float value, int offset) {
+#if defined(EIGEN_HIPCC)
+  return __shfl_down(value, offset, warpSize);
+#else
+  return __shfl_down_sync(reduction_shuffle_mask<float>(), value, offset, warpSize);
+#endif
+}
+
+template <>
+__device__ EIGEN_ALWAYS_INLINE double reduction_shuffle_down<double>(double value, int offset) {
+#if defined(EIGEN_HIPCC)
+  return __shfl_down(value, offset, warpSize);
+#else
+  return __shfl_down_sync(reduction_shuffle_mask<double>(), value, offset, warpSize);
+#endif
+}
+
+template <>
+__device__ inline double atomicExchCustom(double* address, double val) {
+  unsigned long long int* address_as_ull = reinterpret_cast<unsigned long long int*>(address);
+  return __longlong_as_double(atomicExch(address_as_ull, __double_as_longlong(val)));
+}
+
+// Half-float reduction specializations.
+template <typename R>
+__device__ inline void atomicReduce(half2* output, half2 accum, R& reducer) {
+  unsigned int oldval = *reinterpret_cast<unsigned int*>(output);
+  unsigned int newval = oldval;
+  reducer.reducePacket(accum, reinterpret_cast<half2*>(&newval));
+  if (newval == oldval) {
+    return;
+  }
+  unsigned int readback;
+  while ((readback = atomicCAS((unsigned int*)output, oldval, newval)) != oldval) {
+    oldval = readback;
+    newval = oldval;
+    reducer.reducePacket(accum, reinterpret_cast<half2*>(&newval));
+    if (newval == oldval) {
+      return;
+    }
+  }
+}
+#ifdef EIGEN_GPU_COMPILE_PHASE
+// reduction should be associative since reduction is not atomic in wide vector but atomic in half2 operations
+template <typename R>
+__device__ inline void atomicReduce(Packet4h2* output, Packet4h2 accum, R& reducer) {
+  half2* houtput = reinterpret_cast<half2*>(output);
+  half2* haccum = reinterpret_cast<half2*>(&accum);
+  for (int i = 0; i < 4; ++i) {
+    atomicReduce(houtput + i, *(haccum + i), reducer);
+  }
+}
+#endif  // EIGEN_GPU_COMPILE_PHASE
+
+template <>
+__device__ inline void atomicReduce(float* output, float accum, SumReducer<float>&) {
+  atomicAdd(output, accum);
+}
+
+template <>
+__device__ inline void atomicReduce(double* output, double accum, SumReducer<double>&) {
+  atomicAdd(output, accum);
+}
+
+template <typename CoeffType, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitKernel(const CoeffType val, Index num_preserved_coeffs,
+                                                                 CoeffType* output) {
+  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+  const Index num_threads = blockDim.x * gridDim.x;
+  for (Index i = thread_id; i < num_preserved_coeffs; i += num_threads) {
+    output[i] = val;
+  }
+}
+
+template <int BlockSize, int NumPerThread, typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernel(Reducer reducer, const Self input, Index num_coeffs,
+                                                                 typename Self::CoeffReturnType* output,
+                                                                 unsigned int* semaphore) {
+  // Initialize the output value
+  const Index first_index = blockIdx.x * BlockSize * NumPerThread + threadIdx.x;
+  if (gridDim.x == 1) {
+    if (first_index == 0) {
+      *output = reducer.initialize();
+    }
+  } else {
+    if (threadIdx.x == 0) {
+      unsigned int block = atomicCAS(semaphore, 0u, 1u);
+      if (block == 0) {
+        // We're the first block to run, initialize the output value
+        atomicExchCustom(output, reducer.initialize());
+        __threadfence();
+        atomicExch(semaphore, 2u);
+      } else {
+        // Wait for the first block to initialize the output value.
+        // Use atomicCAS here to ensure that the reads aren't cached
+        unsigned int val;
+        do {
+          val = atomicCAS(semaphore, 2u, 2u);
+        } while (val < 2u);
+      }
+    }
+  }
+
+  __syncthreads();
+
+  eigen_assert(gridDim.x == 1 || *semaphore >= 2u);
+
+  typename Self::CoeffReturnType accum = reducer.initialize();
+  Index max_iter = numext::mini<Index>(num_coeffs - first_index, NumPerThread * BlockSize);
+  for (Index i = 0; i < max_iter; i += BlockSize) {
+    const Index index = first_index + i;
+    eigen_assert(index < num_coeffs);
+    typename Self::CoeffReturnType val = input.m_impl.coeff(index);
+    reducer.reduce(val, &accum);
+  }
+
+#pragma unroll
+  for (int offset = warpSize / 2; offset > 0; offset /= 2) {
+    reducer.reduce(reduction_shuffle_down(accum, offset), &accum);
+  }
+
+  if ((threadIdx.x & (warpSize - 1)) == 0) {
+    atomicReduce(output, accum, reducer);
+  }
+
+  if (gridDim.x > 1 && threadIdx.x == 0) {
+    // Let the last block reset the semaphore
+    atomicInc(semaphore, gridDim.x + 1);
+#if defined(EIGEN_HIPCC)
+    __threadfence_system();
+#endif
+  }
+}
+
+// Half-float reduction specializations.
+template <typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitFullReduxKernelHalfFloat(Reducer reducer, const Self input,
+                                                                                   Index num_coeffs, half* scratch) {
+  eigen_assert(blockDim.x == 1);
+  eigen_assert(gridDim.x == 1);
+  typedef packet_traits<Eigen::half>::type packet_type;
+  Index packet_remainder = num_coeffs % Index(unpacket_traits<packet_type>::size);
+  if (packet_remainder != 0) {
+    half2* h2scratch = reinterpret_cast<half2*>(scratch);
+    for (Index i = num_coeffs - packet_remainder; i + 2 <= num_coeffs; i += 2) {
+      *h2scratch = __halves2half2(input.coeff(i), input.coeff(i + 1));
+      h2scratch++;
+    }
+    if ((num_coeffs & 1) != 0) {
+      half lastCoeff = input.coeff(num_coeffs - 1);
+      *h2scratch = __halves2half2(lastCoeff, reducer.initialize());
+    }
+  } else {
+    packet_type reduce = reducer.template initializePacket<packet_type>();
+    internal::pstoreu(scratch, reduce);
+  }
+}
+
+template <typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitKernelHalfFloat(Reducer reducer, const Self /*input*/,
+                                                                          Index num_coeffs, half* output) {
+  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+  const Index num_threads = blockDim.x * gridDim.x;
+  typedef typename packet_traits<Eigen::half>::type PacketType;
+
+  const Index num_packets = num_coeffs / Index(unpacket_traits<PacketType>::size);
+  PacketType* p_output = reinterpret_cast<PacketType*>(output);
+  for (Index i = thread_id; i < num_packets; i += num_threads) {
+    p_output[i] = reducer.template initializePacket<PacketType>();
+  }
+  Index packet_remainder = num_coeffs % Index(unpacket_traits<PacketType>::size);
+  if (thread_id < packet_remainder) {
+    output[num_coeffs - packet_remainder + thread_id] = reducer.initialize();
+  }
+}
+
+template <int BlockSize, int NumPerThread, typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernelHalfFloat(Reducer reducer, const Self input,
+                                                                          Index num_coeffs, half* output,
+                                                                          half* scratch) {
+  typedef typename packet_traits<Eigen::half>::type PacketType;
+  const int packet_width = unpacket_traits<PacketType>::size;
+  eigen_assert(NumPerThread % packet_width == 0);
+  const Index first_index = blockIdx.x * BlockSize * NumPerThread + packet_width * threadIdx.x;
+
+  // Initialize the output value if it wasn't initialized by the ReductionInitKernel
+
+  if (gridDim.x == 1) {
+    if (first_index == 0) {
+      int rem = num_coeffs % packet_width;
+      if (rem != 0) {
+        half2* p_scratch = reinterpret_cast<half2*>(scratch);
+        pstoreu(scratch, reducer.template initializePacket<PacketType>());
+        for (int i = 0; i < rem / 2; i++) {
+          *p_scratch = __halves2half2(input.coeff(num_coeffs - packet_width + 2 * i),
+                                      input.coeff(num_coeffs - packet_width + 2 * i + 1));
+          p_scratch++;
+        }
+        if ((num_coeffs & 1) != 0) {
+          half last = input.coeff(num_coeffs - 1);
+          *p_scratch = __halves2half2(last, reducer.initialize());
+        }
+      } else {
+        PacketType reduce = reducer.template initializePacket<PacketType>();
+        pstoreu(scratch, reduce);
+      }
+    }
+    __syncthreads();
+  }
+
+  PacketType accum = reducer.template initializePacket<PacketType>();
+  const Index max_iter =
+      numext::mini<Index>((num_coeffs - first_index) / packet_width, NumPerThread * BlockSize / packet_width);
+  for (Index i = 0; i < max_iter; i += BlockSize) {
+    const Index index = first_index + packet_width * i;
+    eigen_assert(index + packet_width < num_coeffs);
+    PacketType val = input.template packet<Unaligned>(index);
+    reducer.reducePacket(val, &accum);
+  }
+
+#pragma unroll
+  for (int offset = warpSize / 2; offset > 0; offset /= 2) {
+#if defined(EIGEN_HIPCC)
+    PacketType r1;
+    half2* hr = reinterpret_cast<half2*>(&r1);
+    half2* hacc = reinterpret_cast<half2*>(&accum);
+    for (int i = 0; i < packet_width / 2; i++) {
+      // FIXME : remove this workaround once we have native half/half2 support for __shfl_down
+      union {
+        int i;
+        half2 h;
+      } wka_in, wka_out;
+      wka_in.h = hacc[i];
+      wka_out.i = __shfl_down(wka_in.i, offset, warpSize);
+      hr[i] = wka_out.h;
+    }
+    reducer.reducePacket(r1, &accum);
+#else
+    PacketType r1;
+    half2* hr = reinterpret_cast<half2*>(&r1);
+    half2* hacc = reinterpret_cast<half2*>(&accum);
+    for (int i = 0; i < packet_width / 2; i++) {
+      hr[i] = __shfl_down_sync(0xFFFFFFFF, hacc[i], (unsigned)offset, warpSize);
+    }
+    reducer.reducePacket(r1, &accum);
+
+#endif
+  }
+
+  if ((threadIdx.x & (warpSize - 1)) == 0) {
+    atomicReduce(reinterpret_cast<PacketType*>(scratch), accum, reducer);
+  }
+
+  __syncthreads();
+  half2* rv1 = reinterpret_cast<half2*>(scratch);
+  if (packet_width > 2) {
+    reducer.reducePacket(rv1[2], rv1);
+    reducer.reducePacket(rv1[3], rv1 + 1);
+    reducer.reducePacket(rv1[1], rv1);
+  }
+  if (gridDim.x == 1) {
+    if (first_index == 0) {
+      half tmp = __low2half(*rv1);
+      reducer.reduce(__high2half(*rv1), &tmp);
+      *output = tmp;
+    }
+  }
+}
+
+template <typename Op>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionCleanupKernelHalfFloat(Op reducer, half* output, half* scratch) {
+  eigen_assert(threadIdx.x == 1);
+  typedef packet_traits<Eigen::half>::type packet_type;
+  EIGEN_IF_CONSTEXPR (unpacket_traits<packet_type>::size == 1) {
+    *output = *scratch;
+  } else {
+    half2* pscratch = reinterpret_cast<half2*>(scratch);
+    half tmp = __float2half(0.f);
+    for (int i = 0; i < unpacket_traits<packet_type>::size; i += 2) {
+      reducer.reduce(__low2half(*pscratch), &tmp);
+      reducer.reduce(__high2half(*pscratch), &tmp);
+      pscratch++;
+    }
+    *output = tmp;
+  }
+}
+
+template <typename Self, typename Op, typename OutputType, bool PacketAccess, typename Enabled = void>
+struct FullReductionLauncher {
+  static void run(const Self&, Op&, const GpuDevice&, OutputType*, typename Self::Index) {
+    gpu_assert(false && "Should only be called on doubles, floats and half floats");
+  }
+};
+
+// Specialization for float and double
+template <typename Self, typename Op, typename OutputType, bool PacketAccess>
+struct FullReductionLauncher<
+    Self, Op, OutputType, PacketAccess,
+    std::enable_if_t<std::is_same<float, OutputType>::value || std::is_same<double, OutputType>::value, void>> {
+  static void run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
+                  typename Self::Index num_coeffs) {
+    typedef typename Self::Index Index;
+    const int block_size = 256;
+    const int num_per_thread = 128;
+    const int num_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
+
+    unsigned int* semaphore = nullptr;
+    if (num_blocks > 1) {
+      semaphore = device.semaphore();
+    }
+
+    LAUNCH_GPU_KERNEL((FullReductionKernel<block_size, num_per_thread, Self, Op, Index>), num_blocks, block_size, 0,
+                      device, reducer, self, num_coeffs, output, semaphore);
+  }
+};
+
+// Half-float reduction specializations.
+template <typename Self, typename Op>
+struct FullReductionLauncher<Self, Op, Eigen::half, false> {
+  static void run(const Self&, Op&, const GpuDevice&, half*, typename Self::Index) {
+    gpu_assert(false && "Should not be called since there is no packet accessor");
+  }
+};
+
+template <typename Self, typename Op>
+struct FullReductionLauncher<Self, Op, Eigen::half, true> {
+  static void run(const Self& self, Op& reducer, const GpuDevice& device, half* output,
+                  typename Self::Index num_coeffs) {
+    typedef typename Self::Index Index;
+
+    const int block_size = 256;
+    const int num_per_thread = 128;
+    const int num_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
+    half* scratch = static_cast<half*>(device.scratchpad());
+
+    if (num_blocks > 1) {
+      // We initialize the output and the scratchpad outside the reduction kernel when we can't be sure that there
+      // won't be race conditions between multiple thread blocks.
+      LAUNCH_GPU_KERNEL((ReductionInitFullReduxKernelHalfFloat<Self, Op, Index>), 1, 1, 0, device, reducer, self,
+                        num_coeffs, scratch);
+    }
+
+    LAUNCH_GPU_KERNEL((FullReductionKernelHalfFloat<block_size, num_per_thread, Self, Op, Index>), num_blocks,
+                      block_size, 0, device, reducer, self, num_coeffs, output, scratch);
+
+    if (num_blocks > 1) {
+      LAUNCH_GPU_KERNEL((ReductionCleanupKernelHalfFloat<Op>), 1, 1, 0, device, reducer, output, scratch);
+    }
+  }
+};
+
+template <typename Self, typename Op, bool Vectorizable>
+struct FullReducer<Self, Op, GpuDevice, Vectorizable> {
+  // Unfortunately nvidia doesn't support well exotic types such as complex,
+  // so reduce the scope of the optimized version of the code to the simple cases
+  // of doubles, floats and half floats
+  // Half-float reduction specializations.
+  static constexpr bool HasOptimizedImplementation =
+      !Self::ReducerTraits::IsStateful && (std::is_same<typename Self::CoeffReturnType, float>::value ||
+                                           std::is_same<typename Self::CoeffReturnType, double>::value ||
+                                           (std::is_same<typename Self::CoeffReturnType, Eigen::half>::value &&
+                                            reducer_traits<Op, GpuDevice>::PacketAccess));
+
+  template <typename OutputType>
+  static void run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output) {
+    gpu_assert(HasOptimizedImplementation && "Should only be called on doubles, floats or half floats");
+    const Index num_coeffs = array_prod(self.m_impl.dimensions());
+    // Don't crash when we're called with an input tensor of size 0.
+    if (num_coeffs == 0) {
+      return;
+    }
+
+    FullReductionLauncher<Self, Op, OutputType, reducer_traits<Op, GpuDevice>::PacketAccess>::run(self, reducer, device,
+                                                                                                  output, num_coeffs);
+  }
+};
+
+template <int NumPerThread, typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernel(Reducer reducer, const Self input,
+                                                                  Index num_coeffs_to_reduce,
+                                                                  Index num_preserved_coeffs,
+                                                                  typename Self::CoeffReturnType* output) {
+  typedef typename Self::CoeffReturnType Type;
+  eigen_assert(blockDim.y == 1);
+  eigen_assert(blockDim.z == 1);
+  eigen_assert(gridDim.y == 1);
+  eigen_assert(gridDim.z == 1);
+
+  const int unroll_times = 16;
+  eigen_assert(NumPerThread % unroll_times == 0);
+
+  const Index input_col_blocks = numext::div_ceil<Index>(num_coeffs_to_reduce, blockDim.x * NumPerThread);
+  const Index num_input_blocks = input_col_blocks * num_preserved_coeffs;
+
+  const Index num_threads = blockDim.x * gridDim.x;
+  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+
+  // Initialize the output values if they weren't initialized by the ReductionInitKernel
+  if (gridDim.x == 1) {
+    for (Index i = thread_id; i < num_preserved_coeffs; i += num_threads) {
+      output[i] = reducer.initialize();
+    }
+    __syncthreads();
+  }
+
+  for (Index i = blockIdx.x; i < num_input_blocks; i += gridDim.x) {
+    const Index row = i / input_col_blocks;
+
+    // `i`, and so `row`, is uniform across the block: a warp enters this branch as a whole, which the full-mask
+    // shuffle tree below relies on.
+    if (row < num_preserved_coeffs) {
+      const Index col_block = i % input_col_blocks;
+      const Index col_begin = col_block * blockDim.x * NumPerThread + threadIdx.x;
+
+      Type reduced_val = reducer.initialize();
+
+      for (Index j = 0; j < NumPerThread; j += unroll_times) {
+        const Index last_col = col_begin + blockDim.x * (j + unroll_times - 1);
+        if (last_col >= num_coeffs_to_reduce) {
+          for (Index col = col_begin + blockDim.x * j; col < num_coeffs_to_reduce; col += blockDim.x) {
+            const Type val = input.m_impl.coeff(row * num_coeffs_to_reduce + col);
+            reducer.reduce(val, &reduced_val);
+          }
+          break;
+        } else {
+          // Faster version of the loop with no branches after unrolling.
+#pragma unroll
+          for (int k = 0; k < unroll_times; ++k) {
+            const Index col = col_begin + blockDim.x * (j + k);
+            reducer.reduce(input.m_impl.coeff(row * num_coeffs_to_reduce + col), &reduced_val);
+          }
+        }
+      }
+
+#pragma unroll
+      for (int offset = warpSize / 2; offset > 0; offset /= 2) {
+        reducer.reduce(reduction_shuffle_down(reduced_val, offset), &reduced_val);
+      }
+
+      if ((threadIdx.x & (warpSize - 1)) == 0) {
+        atomicReduce(&(output[row]), reduced_val, reducer);
+      }
+    }
+  }
+}
+
+// Half-float reduction specializations.
+
+template <int NumPerThread, typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernelHalfFloat(Reducer reducer, const Self input,
+                                                                           Index num_coeffs_to_reduce,
+                                                                           Index num_preserved_coeffs, half* output) {
+  eigen_assert(blockDim.y == 1);
+  eigen_assert(blockDim.z == 1);
+  eigen_assert(gridDim.y == 1);
+  eigen_assert(gridDim.z == 1);
+
+  typedef typename packet_traits<Eigen::half>::type PacketType;
+  const int packet_width = unpacket_traits<PacketType>::size;
+  const int unroll_times = 16 / packet_width;
+  eigen_assert(NumPerThread % unroll_times == 0);
+  eigen_assert(unroll_times % 2 == 0);
+
+  const Index input_col_blocks = numext::div_ceil<Index>(num_coeffs_to_reduce, blockDim.x * NumPerThread * 2);
+  const Index num_input_blocks = numext::div_ceil<Index>(input_col_blocks * num_preserved_coeffs, 2);
+
+  const Index num_threads = blockDim.x * gridDim.x;
+  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+
+  // Initialize the output values if they weren't initialized by the ReductionInitKernel
+  if (gridDim.x == 1) {
+    Index i = packet_width * thread_id;
+    for (; i + packet_width <= num_preserved_coeffs; i += packet_width * num_threads) {
+      PacketType* poutput = reinterpret_cast<PacketType*>(output + i);
+      *poutput = reducer.template initializePacket<PacketType>();
+    }
+    if (i < num_preserved_coeffs) {
+      output[i] = reducer.initialize();
+    }
+    __syncthreads();
+  }
+
+  for (Index i = blockIdx.x; i < num_input_blocks; i += gridDim.x) {
+    const Index row = 2 * (i / input_col_blocks);  // everybody takes 2 rows
+
+    // Block-uniform, as in InnerReductionKernel: the full-mask shuffles below are safe.
+    if (row + 1 < num_preserved_coeffs) {
+      const Index col_block = i % input_col_blocks;
+      const Index col_begin = packet_width * (col_block * blockDim.x * NumPerThread + threadIdx.x);
+
+      PacketType reduced_val1 = reducer.template initializePacket<PacketType>();
+      PacketType reduced_val2 = reducer.template initializePacket<PacketType>();
+
+      for (Index j = 0; j < NumPerThread; j += unroll_times) {
+        const Index last_col = col_begin + blockDim.x * (j + unroll_times - 1) * packet_width;
+        if (last_col >= num_coeffs_to_reduce) {
+          Index col = col_begin + blockDim.x * j;
+          for (; col + packet_width <= num_coeffs_to_reduce; col += blockDim.x) {
+            const PacketType val1 = input.m_impl.template packet<Unaligned>(row * num_coeffs_to_reduce + col);
+            reducer.reducePacket(val1, &reduced_val1);
+            const PacketType val2 = input.m_impl.template packet<Unaligned>((row + 1) * num_coeffs_to_reduce + col);
+            reducer.reducePacket(val2, &reduced_val2);
+          }
+          if (col < num_coeffs_to_reduce) {
+            PacketType r1 = reducer.template initializePacket<PacketType>();
+            PacketType r2 = reducer.template initializePacket<PacketType>();
+            half2* hr1 = reinterpret_cast<half2*>(&r1);
+            half2* hr2 = reinterpret_cast<half2*>(&r2);
+            while (col + 1 < num_coeffs_to_reduce) {
+              *hr1 = __halves2half2(input.m_impl.coeff(row * num_coeffs_to_reduce + col),
+                                    input.m_impl.coeff(row * num_coeffs_to_reduce + col + 1));
+              *hr2 = __halves2half2(input.m_impl.coeff((row + 1) * num_coeffs_to_reduce + col),
+                                    input.m_impl.coeff((row + 1) * num_coeffs_to_reduce + col + 1));
+              hr1++;
+              hr2++;
+              col += 2;
+            }
+            if (col < num_coeffs_to_reduce) {
+              // Peel;
+              const half last1 = input.m_impl.coeff(row * num_coeffs_to_reduce + col);
+              *hr1 = __halves2half2(last1, reducer.initialize());
+              const half last2 = input.m_impl.coeff((row + 1) * num_coeffs_to_reduce + col);
+              *hr2 = __halves2half2(last2, reducer.initialize());
+            }
+            reducer.reducePacket(r1, &reduced_val1);
+            reducer.reducePacket(r2, &reduced_val2);
+          }
+          break;
+        } else {
+          // Faster version of the loop with no branches after unrolling.
+#pragma unroll
+          for (int k = 0; k < unroll_times; ++k) {
+            const Index col = col_begin + blockDim.x * (j + k) * packet_width;
+            reducer.reducePacket(input.m_impl.template packet<Unaligned>(row * num_coeffs_to_reduce + col),
+                                 &reduced_val1);
+            reducer.reducePacket(input.m_impl.template packet<Unaligned>((row + 1) * num_coeffs_to_reduce + col),
+                                 &reduced_val2);
+          }
+        }
+      }
+
+#pragma unroll
+      for (int offset = warpSize / 2; offset > 0; offset /= 2) {
+#if defined(EIGEN_HIPCC)
+        PacketType r1;
+        PacketType r2;
+        half2* hr1 = reinterpret_cast<half2*>(&r1);
+        half2* hr2 = reinterpret_cast<half2*>(&r2);
+        half2* rv1 = reinterpret_cast<half2*>(&reduced_val1);
+        half2* rv2 = reinterpret_cast<half2*>(&reduced_val2);
+        for (int i = 0; i < packet_width / 2; i++) {
+          // FIXME : remove this workaround once we have native half/half2 support for __shfl_down
+          union {
+            int i;
+            half2 h;
+          } wka_in1, wka_out1;
+          wka_in1.h = rv1[i];
+          wka_out1.i = __shfl_down(wka_in1.i, offset, warpSize);
+          hr1[i] = wka_out1.h;
+
+          union {
+            int i;
+            half2 h;
+          } wka_in2, wka_out2;
+          wka_in2.h = rv2[i];
+          wka_out2.i = __shfl_down(wka_in2.i, offset, warpSize);
+          hr2[i] = wka_out2.h;
+        }
+        reducer.reducePacket(r1, &reduced_val1);
+        reducer.reducePacket(r2, &reduced_val2);
+#else
+        PacketType r1;
+        PacketType r2;
+        half2* hr1 = reinterpret_cast<half2*>(&r1);
+        half2* hr2 = reinterpret_cast<half2*>(&r2);
+        half2* rr1 = reinterpret_cast<half2*>(&reduced_val1);
+        half2* rr2 = reinterpret_cast<half2*>(&reduced_val2);
+        for (int j = 0; j < packet_width / 2; j++) {
+          hr1[j] = __shfl_down_sync(0xFFFFFFFF, rr1[j], (unsigned)offset, warpSize);
+          hr2[j] = __shfl_down_sync(0xFFFFFFFF, rr2[j], (unsigned)offset, warpSize);
+        }
+        reducer.reducePacket(r1, &reduced_val1);
+        reducer.reducePacket(r2, &reduced_val2);
+
+#endif
+      }
+      half2* rv1 = reinterpret_cast<half2*>(&reduced_val1);
+      half2* rv2 = reinterpret_cast<half2*>(&reduced_val2);
+      half2 val;
+      if (packet_width > 2) {
+        reducer.reducePacket(rv1[2], rv1);
+        reducer.reducePacket(rv1[3], rv1 + 1);
+        reducer.reducePacket(rv1[1], rv1);
+        reducer.reducePacket(rv2[2], rv2);
+        reducer.reducePacket(rv2[3], rv2 + 1);
+        reducer.reducePacket(rv2[1], rv2);
+      }
+      half val1 = __low2half(*rv1);
+      reducer.reduce(__high2half(*rv1), &val1);
+      half val2 = __low2half(*rv2);
+      reducer.reduce(__high2half(*rv2), &val2);
+      val = __halves2half2(val1, val2);
+      if ((threadIdx.x & (warpSize - 1)) == 0) {
+        half* loc = output + row;
+        atomicReduce(reinterpret_cast<half2*>(loc), val, reducer);
+      }
+    }
+  }
+}
+
+template <typename Self, typename Op, typename OutputType, bool PacketAccess, typename Enabled = void>
+struct InnerReductionLauncher {
+  static EIGEN_DEVICE_FUNC bool run(const Self&, Op&, const GpuDevice&, OutputType*, typename Self::Index,
+                                    typename Self::Index) {
+    gpu_assert(false && "Should only be called to reduce doubles, floats and half floats on a gpu device");
+    return true;
+  }
+};
+
+// Specialization for float and double
+template <typename Self, typename Op, typename OutputType, bool PacketAccess>
+struct InnerReductionLauncher<
+    Self, Op, OutputType, PacketAccess,
+    std::enable_if_t<std::is_same<float, OutputType>::value || std::is_same<double, OutputType>::value, void>> {
+  static bool run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
+                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
+    typedef typename Self::Index Index;
+
+    const Index num_coeffs = num_coeffs_to_reduce * num_preserved_vals;
+    const int block_size = 256;
+    const int num_per_thread = 128;
+    const int dyn_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
+    const int max_blocks = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / block_size;
+    const int num_blocks = numext::mini<int>(max_blocks, dyn_blocks);
+
+    if (num_blocks > 1) {
+      // We initialize the outputs outside the reduction kernel when we can't be sure that there
+      // won't be race conditions between multiple thread blocks.
+      const int dyn_blocks2 = numext::div_ceil<int>(num_preserved_vals, 1024);
+      const int max_blocks2 = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / 1024;
+      const int num_blocks2 = numext::mini<int>(max_blocks2, dyn_blocks2);
+      LAUNCH_GPU_KERNEL((ReductionInitKernel<OutputType, Index>), num_blocks2, 1024, 0, device, reducer.initialize(),
+                        num_preserved_vals, output);
+    }
+
+    LAUNCH_GPU_KERNEL((InnerReductionKernel<num_per_thread, Self, Op, Index>), num_blocks, block_size, 0, device,
+                      reducer, self, num_coeffs_to_reduce, num_preserved_vals, output);
+
+    return false;
+  }
+};
+
+// Half-float reduction specializations.
+template <typename Self, typename Op>
+struct InnerReductionLauncher<Self, Op, Eigen::half, false> {
+  static bool run(const Self&, Op&, const GpuDevice&, half*, typename Self::Index, typename Self::Index) {
+    gpu_assert(false && "Should not be called since there is no packet accessor");
+    return true;
+  }
+};
+
+template <typename Self, typename Op>
+struct InnerReductionLauncher<Self, Op, Eigen::half, true> {
+  static bool run(const Self& self, Op& reducer, const GpuDevice& device, half* output,
+                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
+    typedef typename Self::Index Index;
+
+    if (num_preserved_vals % 2 != 0) {
+      // Not supported yet, revert to the slower code path
+      return true;
+    }
+
+    const Index num_coeffs = num_coeffs_to_reduce * num_preserved_vals;
+    const int block_size = 128;
+    const int num_per_thread = 64;
+    const int dyn_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
+    const int max_blocks = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / block_size;
+    const int num_blocks = numext::mini<int>(max_blocks, dyn_blocks);
+
+    if (num_blocks > 1) {
+      // We initialize the outputs outside the reduction kernel when we can't be sure that there
+      // won't be race conditions between multiple thread blocks.
+      LAUNCH_GPU_KERNEL((ReductionInitKernelHalfFloat<Self, Op, Index>), 1, 1, 0, device, reducer, self,
+                        num_preserved_vals, output);
+    }
+
+    LAUNCH_GPU_KERNEL((InnerReductionKernelHalfFloat<num_per_thread, Self, Op, Index>), num_blocks, block_size, 0,
+                      device, reducer, self, num_coeffs_to_reduce, num_preserved_vals, output);
+
+    return false;
+  }
+};
+
+template <typename Self, typename Op>
+struct InnerReducer<Self, Op, GpuDevice> {
+  // Unfortunately nvidia doesn't support well exotic types such as complex,
+  // so reduce the scope of the optimized version of the code to the simple case
+  // of floats and half floats.
+  // Half-float reduction specializations.
+  static constexpr bool HasOptimizedImplementation =
+      !Self::ReducerTraits::IsStateful && (std::is_same<typename Self::CoeffReturnType, float>::value ||
+                                           std::is_same<typename Self::CoeffReturnType, double>::value ||
+                                           (std::is_same<typename Self::CoeffReturnType, Eigen::half>::value &&
+                                            reducer_traits<Op, GpuDevice>::PacketAccess));
+
+  template <typename OutputType>
+  static bool run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
+                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
+    gpu_assert(HasOptimizedImplementation && "Should only be called on doubles, floats or half floats");
+    const Index num_coeffs = array_prod(self.m_impl.dimensions());
+    // Don't crash when we're called with an input tensor of size 0.
+    if (num_coeffs == 0) {
+      return true;
+    }
+    // It's faster to use the usual code.
+    if (num_coeffs_to_reduce <= 128) {
+      return true;
+    }
+
+    return InnerReductionLauncher<Self, Op, OutputType, reducer_traits<Op, GpuDevice>::PacketAccess>::run(
+        self, reducer, device, output, num_coeffs_to_reduce, num_preserved_vals);
+  }
+};
+
+template <int NumPerThread, typename Self, typename Reducer, typename Index>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void OuterReductionKernel(Reducer reducer, const Self input,
+                                                                  Index num_coeffs_to_reduce,
+                                                                  Index num_preserved_coeffs,
+                                                                  typename Self::CoeffReturnType* output) {
+  const Index num_threads = blockDim.x * gridDim.x;
+  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+  // Initialize the output values if they weren't initialized by the ReductionInitKernel
+  if (gridDim.x == 1) {
+    for (Index i = thread_id; i < num_preserved_coeffs; i += num_threads) {
+      output[i] = reducer.initialize();
+    }
+    __syncthreads();
+  }
+
+  // Do the reduction.
+  const Index max_iter = num_preserved_coeffs * numext::div_ceil<Index>(num_coeffs_to_reduce, NumPerThread);
+  for (Index i = thread_id; i < max_iter; i += num_threads) {
+    const Index input_col = i % num_preserved_coeffs;
+    const Index input_row = (i / num_preserved_coeffs) * NumPerThread;
+    typename Self::CoeffReturnType reduced_val = reducer.initialize();
+    const Index max_row = numext::mini(input_row + NumPerThread, num_coeffs_to_reduce);
+    for (Index j = input_row; j < max_row; j++) {
+      typename Self::CoeffReturnType val = input.m_impl.coeff(j * num_preserved_coeffs + input_col);
+      reducer.reduce(val, &reduced_val);
+    }
+    atomicReduce(&(output[input_col]), reduced_val, reducer);
+  }
+}
+
+template <typename Self, typename Op>
+struct OuterReducer<Self, Op, GpuDevice> {
+  // Unfortunately nvidia doesn't support well exotic types such as complex,
+  // so reduce the scope of the optimized version of the code to the simple case
+  // of floats and doubles.
+  template <typename T>
+  using IsFloatOrDouble = bool_constant<std::is_same<T, float>::value || std::is_same<T, double>::value>;
+
+  static constexpr bool HasOptimizedImplementation =
+      !Self::ReducerTraits::IsStateful && IsFloatOrDouble<typename Self::CoeffReturnType>::value;
+  template <typename Device, typename OutputType>
+  static
+#if !defined(EIGEN_HIPCC)
+      // FIXME :  leaving this EIGEN_DEVICE_FUNC in, results in the following runtime error
+      //          (in the tensor_reduction_gpu test)
+      //
+      // terminate called after throwing an instance of 'std::runtime_error'
+      //   what():  No device code available for function: _ZN5Eigen8internal20OuterReductionKernelIL...
+      //
+      // don't know why this happens (and why is it a runtime error instead of a compile time error)
+      //
+      // this will be fixed by HIP PR#457
+      EIGEN_DEVICE_FUNC
+#endif
+      bool
+      run(const Self&, Op&, const Device&, OutputType*, typename Self::Index, typename Self::Index) {
+    gpu_assert(false && "Should only be called to reduce doubles or floats on a gpu device");
+    return true;
+  }
+
+  // OuterReductionKernel is generic in CoeffReturnType, so one launch serves both types that
+  // HasOptimizedImplementation admits. The enable_if keeps every other OutputType on the overload above: the
+  // caller's EIGEN_IF_CONSTEXPR is a plain `if` in C++14, so the call is instantiated for those types as well.
+  template <typename OutputType, EIGEN_SFINAE_ENABLE_IF(IsFloatOrDouble<OutputType>::value)>
+  static bool run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
+                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
+    typedef typename Self::Index Index;
+
+    // It's faster to use the usual code.
+    if (num_coeffs_to_reduce <= 32) {
+      return true;
+    }
+
+    // CUDA has native FP64 atomicAdd on every supported architecture (sm_60+). Keep the measured shape band
+    // for the other double reducers and for HIP, where atomicAdd may still use compare-and-swap.
+#if defined(EIGEN_CUDACC)
+    constexpr bool has_native_double_sum = std::is_same<Op, SumReducer<double>>::value;
+#else
+    constexpr bool has_native_double_sum = false;
+#endif
+    if (std::is_same<OutputType, double>::value && !has_native_double_sum) {
+      const Index multi_processors = device.getNumGpuMultiProcessors();
+      if (num_coeffs_to_reduce < 64 || num_preserved_vals < 8 * multi_processors ||
+          num_preserved_vals > 64 * multi_processors) {
+        return true;
+      }
+    }
+
+    const Index num_coeffs = num_coeffs_to_reduce * num_preserved_vals;
+    const int block_size = 256;
+    const int num_per_thread = 16;
+    const int dyn_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
+    const int max_blocks = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / block_size;
+    const int num_blocks = numext::mini<int>(max_blocks, dyn_blocks);
+
+    if (num_blocks > 1) {
+      // We initialize the outputs outside the reduction kernel when we can't be sure that there
+      // won't be race conditions between multiple thread blocks.
+      const int dyn_blocks2 = numext::div_ceil<int>(num_preserved_vals, 1024);
+      const int max_blocks2 = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / 1024;
+      const int num_blocks2 = numext::mini<int>(max_blocks2, dyn_blocks2);
+      LAUNCH_GPU_KERNEL((ReductionInitKernel<OutputType, Index>), num_blocks2, 1024, 0, device, reducer.initialize(),
+                        num_preserved_vals, output);
+    }
+
+    LAUNCH_GPU_KERNEL((OuterReductionKernel<num_per_thread, Self, Op, Index>), num_blocks, block_size, 0, device,
+                      reducer, self, num_coeffs_to_reduce, num_preserved_vals, output);
+
+    return false;
+  }
+};
+
+#endif  // defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
+
+}  // end namespace internal
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_REDUCTION_GPU_H
diff --git a/contrib/Eigen/src/Tensor/TensorReductionSycl.h b/contrib/Eigen/src/Tensor/TensorReductionSycl.h
new file mode 100644
index 0000000..5f16722
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorReductionSycl.h
@@ -0,0 +1,586 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+/*****************************************************************
+ * TensorReductionSycl.h
+ *
+ * \brief:
+ *  This is the specialization of the reduction operation. Two phase reduction approach
+ * is used since the GPU does not have Global Synchronization for global memory among
+ * different work-group/thread block. To solve the problem, we need to create two kernels
+ * to reduce the data, where the first kernel reduce the data locally and each local
+ * workgroup/thread-block save the input data into global memory. In the second phase (global reduction)
+ * one work-group uses one work-group/thread-block to reduces the intermediate data into one single element.
+ * Here is an NVIDIA presentation explaining the optimized two phase reduction algorithm on GPU:
+ * https://developer.download.nvidia.com/assets/cuda/files/reduction.pdf
+ *
+ *****************************************************************/
+
+#ifndef UNSUPPORTED_EIGEN_SRC_TENSOR_TENSOR_REDUCTION_SYCL_HPP
+#define UNSUPPORTED_EIGEN_SRC_TENSOR_TENSOR_REDUCTION_SYCL_HPP
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace TensorSycl {
+namespace internal {
+
+template <typename Op, typename CoeffReturnType, typename Index, bool Vectorizable>
+struct OpDefiner {
+  typedef typename Vectorise<CoeffReturnType, Eigen::SyclDevice, Vectorizable>::PacketReturnType PacketReturnType;
+  typedef Op type;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE type get_op(Op &op) { return op; }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType finalise_op(const PacketReturnType &accumulator,
+                                                                            const Index &) {
+    return accumulator;
+  }
+};
+
+template <typename CoeffReturnType, typename Index>
+struct OpDefiner<Eigen::internal::MeanReducer<CoeffReturnType>, CoeffReturnType, Index, false> {
+  typedef Eigen::internal::SumReducer<CoeffReturnType> type;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE type get_op(Eigen::internal::MeanReducer<CoeffReturnType> &) {
+    return type();
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType finalise_op(const CoeffReturnType &accumulator,
+                                                                           const Index &scale) {
+    ::Eigen::internal::scalar_quotient_op<CoeffReturnType> quotient_op;
+    return quotient_op(accumulator, CoeffReturnType(scale));
+  }
+};
+
+template <typename CoeffReturnType, typename Index>
+struct OpDefiner<Eigen::internal::MeanReducer<CoeffReturnType>, CoeffReturnType, Index, true> {
+  typedef typename Vectorise<CoeffReturnType, Eigen::SyclDevice, true>::PacketReturnType PacketReturnType;
+  typedef Eigen::internal::SumReducer<CoeffReturnType> type;
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE type get_op(Eigen::internal::MeanReducer<CoeffReturnType> &) {
+    return type();
+  }
+
+  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType finalise_op(const PacketReturnType &accumulator,
+                                                                            const Index &scale) {
+    return ::Eigen::internal::pdiv(accumulator, ::Eigen::internal::pset1<PacketReturnType>(CoeffReturnType(scale)));
+  }
+};
+
+template <typename CoeffReturnType, typename OpType, typename InputAccessor, typename OutputAccessor, typename Index,
+          Index local_range>
+struct SecondStepFullReducer {
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      LocalAccessor;
+  typedef OpDefiner<OpType, CoeffReturnType, Index, true> OpDef;
+  typedef typename OpDef::type Op;
+  LocalAccessor scratch;
+  InputAccessor aI;
+  OutputAccessor outAcc;
+  Op op;
+  SecondStepFullReducer(LocalAccessor scratch_, InputAccessor aI_, OutputAccessor outAcc_, OpType op_)
+      : scratch(scratch_), aI(aI_), outAcc(outAcc_), op(OpDef::get_op(op_)) {}
+
+  void operator()(cl::sycl::nd_item<1> itemID) const {
+    // Our empirical research shows that the best performance will be achieved
+    // when there is only one element per thread to reduce in the second step.
+    // in this step the second step reduction time is almost negligible.
+    // Hence, in the second step of reduction the input size is fixed to the
+    // local size, thus, there is only one element read per thread. The
+    // algorithm must be changed if the number of reduce per thread in the
+    // second step is greater than 1. Otherwise, the result will be wrong.
+    const Index localid = itemID.get_local_id(0);
+    auto aInPtr = aI + localid;
+    auto aOutPtr = outAcc;
+    CoeffReturnType *scratchptr = scratch.get_pointer();
+    CoeffReturnType accumulator = *aInPtr;
+
+    scratchptr[localid] = op.finalize(accumulator);
+    for (Index offset = itemID.get_local_range(0) / 2; offset > 0; offset /= 2) {
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+      if (localid < offset) {
+        op.reduce(scratchptr[localid + offset], &accumulator);
+        scratchptr[localid] = op.finalize(accumulator);
+      }
+    }
+    if (localid == 0) *aOutPtr = op.finalize(accumulator);
+  }
+};
+
+// Full reduction first phase. In this version the vectorization is true and the reduction accept
+// any generic reducerOp  e.g( max, min, sum, mean, iamax, iamin, etc ).
+template <typename Evaluator, typename OpType, typename Evaluator::Index local_range>
+class FullReductionKernelFunctor {
+ public:
+  typedef typename Evaluator::CoeffReturnType CoeffReturnType;
+  typedef typename Evaluator::Index Index;
+  typedef OpDefiner<OpType, typename Evaluator::CoeffReturnType, Index,
+                    (Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess)>
+      OpDef;
+
+  typedef typename OpDef::type Op;
+  typedef typename Evaluator::EvaluatorPointerType EvaluatorPointerType;
+  typedef typename Evaluator::PacketReturnType PacketReturnType;
+  typedef std::conditional_t<(Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess), PacketReturnType,
+                             CoeffReturnType>
+      OutType;
+  typedef cl::sycl::accessor<OutType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      LocalAccessor;
+  LocalAccessor scratch;
+  Evaluator evaluator;
+  EvaluatorPointerType final_output;
+  Index rng;
+  Op op;
+
+  FullReductionKernelFunctor(LocalAccessor scratch_, Evaluator evaluator_, EvaluatorPointerType final_output_,
+                             Index rng_, OpType op_)
+      : scratch(scratch_), evaluator(evaluator_), final_output(final_output_), rng(rng_), op(OpDef::get_op(op_)) {}
+
+  void operator()(cl::sycl::nd_item<1> itemID) const { compute_reduction(itemID); }
+
+  template <bool Vect = (Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess)>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<Vect> compute_reduction(
+      const cl::sycl::nd_item<1> &itemID) const {
+    auto output_ptr = final_output;
+    Index VectorizedRange = (rng / Evaluator::PacketSize) * Evaluator::PacketSize;
+    Index globalid = itemID.get_global_id(0);
+    Index localid = itemID.get_local_id(0);
+    Index step = Evaluator::PacketSize * itemID.get_global_range(0);
+    Index start = Evaluator::PacketSize * globalid;
+    // vectorizable parts
+    PacketReturnType packetAccumulator = op.template initializePacket<PacketReturnType>();
+    for (Index i = start; i < VectorizedRange; i += step) {
+      op.template reducePacket<PacketReturnType>(evaluator.impl().template packet<Unaligned>(i), &packetAccumulator);
+    }
+    globalid += VectorizedRange;
+    // non vectorizable parts
+    for (Index i = globalid; i < rng; i += itemID.get_global_range(0)) {
+      op.template reducePacket<PacketReturnType>(
+          ::Eigen::TensorSycl::internal::PacketWrapper<PacketReturnType, Evaluator::PacketSize>::convert_to_packet_type(
+              evaluator.impl().coeff(i), op.initialize()),
+          &packetAccumulator);
+    }
+    scratch[localid] = packetAccumulator =
+        OpDef::finalise_op(op.template finalizePacket<PacketReturnType>(packetAccumulator), rng);
+    // reduction parts // Local size is always power of 2
+    EIGEN_UNROLL_LOOP
+    for (Index offset = local_range / 2; offset > 0; offset /= 2) {
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+      if (localid < offset) {
+        op.template reducePacket<PacketReturnType>(scratch[localid + offset], &packetAccumulator);
+        scratch[localid] = op.template finalizePacket<PacketReturnType>(packetAccumulator);
+      }
+    }
+    if (localid == 0) {
+      output_ptr[itemID.get_group(0)] =
+          op.finalizeBoth(op.initialize(), op.template finalizePacket<PacketReturnType>(packetAccumulator));
+    }
+  }
+
+  template <bool Vect = (Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess)>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!Vect> compute_reduction(
+      const cl::sycl::nd_item<1> &itemID) const {
+    auto output_ptr = final_output;
+    Index globalid = itemID.get_global_id(0);
+    Index localid = itemID.get_local_id(0);
+    // vectorizable parts
+    CoeffReturnType accumulator = op.initialize();
+    // non vectorizable parts
+    for (Index i = globalid; i < rng; i += itemID.get_global_range(0)) {
+      op.reduce(evaluator.impl().coeff(i), &accumulator);
+    }
+    scratch[localid] = accumulator = OpDef::finalise_op(op.finalize(accumulator), rng);
+
+    // reduction parts. the local size is always power of 2
+    EIGEN_UNROLL_LOOP
+    for (Index offset = local_range / 2; offset > 0; offset /= 2) {
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+      if (localid < offset) {
+        op.reduce(scratch[localid + offset], &accumulator);
+        scratch[localid] = op.finalize(accumulator);
+      }
+    }
+    if (localid == 0) {
+      output_ptr[itemID.get_group(0)] = op.finalize(accumulator);
+    }
+  }
+};
+
+template <typename Evaluator, typename OpType>
+class GenericNondeterministicReducer {
+ public:
+  typedef typename Evaluator::CoeffReturnType CoeffReturnType;
+  typedef typename Evaluator::EvaluatorPointerType EvaluatorPointerType;
+  typedef typename Evaluator::Index Index;
+  typedef OpDefiner<OpType, CoeffReturnType, Index, false> OpDef;
+  typedef typename OpDef::type Op;
+  template <typename Scratch>
+  GenericNondeterministicReducer(Scratch, Evaluator evaluator_, EvaluatorPointerType output_accessor_, OpType functor_,
+                                 Index range_, Index num_values_to_reduce_)
+      : evaluator(evaluator_),
+        output_accessor(output_accessor_),
+        functor(OpDef::get_op(functor_)),
+        range(range_),
+        num_values_to_reduce(num_values_to_reduce_) {}
+
+  void operator()(cl::sycl::nd_item<1> itemID) const {
+    // This is to bypass the stateful condition in Eigen meanReducer
+    Op non_const_functor;
+    std::memcpy(&non_const_functor, &functor, sizeof(Op));
+    auto output_accessor_ptr = output_accessor;
+    Index globalid = static_cast<Index>(itemID.get_global_linear_id());
+    if (globalid < range) {
+      CoeffReturnType accum = functor.initialize();
+      Eigen::internal::GenericDimReducer<Evaluator::NumReducedDims - 1, Evaluator, Op>::reduce(
+          evaluator, evaluator.firstInput(globalid), non_const_functor, &accum);
+      output_accessor_ptr[globalid] = OpDef::finalise_op(functor.finalize(accum), num_values_to_reduce);
+    }
+  }
+
+ private:
+  Evaluator evaluator;
+  EvaluatorPointerType output_accessor;
+  Op functor;
+  Index range;
+  Index num_values_to_reduce;
+};
+
+enum class reduction_dim { inner_most, outer_most };
+// Default partial reduction (preserve dimensions).
+template <typename Evaluator, typename OpType, typename PannelParameters, reduction_dim rt>
+struct PartialReductionKernel {
+  typedef typename Evaluator::CoeffReturnType CoeffReturnType;
+  typedef typename Evaluator::EvaluatorPointerType EvaluatorPointerType;
+  typedef typename Evaluator::Index Index;
+  typedef OpDefiner<OpType, CoeffReturnType, Index, false> OpDef;
+  typedef typename OpDef::type Op;
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      ScratchAcc;
+  ScratchAcc scratch;
+  Evaluator evaluator;
+  EvaluatorPointerType output_accessor;
+  Op op;
+  const Index preserve_elements_num_groups;
+  const Index reduce_elements_num_groups;
+  const Index num_coeffs_to_preserve;
+  const Index num_coeffs_to_reduce;
+
+  PartialReductionKernel(ScratchAcc scratch_, Evaluator evaluator_, EvaluatorPointerType output_accessor_, OpType op_,
+                         const Index preserve_elements_num_groups_, const Index reduce_elements_num_groups_,
+                         const Index num_coeffs_to_preserve_, const Index num_coeffs_to_reduce_)
+      : scratch(scratch_),
+        evaluator(evaluator_),
+        output_accessor(output_accessor_),
+        op(OpDef::get_op(op_)),
+        preserve_elements_num_groups(preserve_elements_num_groups_),
+        reduce_elements_num_groups(reduce_elements_num_groups_),
+        num_coeffs_to_preserve(num_coeffs_to_preserve_),
+        num_coeffs_to_reduce(num_coeffs_to_reduce_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void element_wise_reduce(Index globalRId, Index globalPId,
+                                                                 CoeffReturnType &accumulator) const {
+    if (globalPId >= num_coeffs_to_preserve) {
+      return;
+    }
+    Index global_offset = rt == reduction_dim::outer_most ? globalPId + (globalRId * num_coeffs_to_preserve)
+                                                          : globalRId + (globalPId * num_coeffs_to_reduce);
+    Index localOffset = globalRId;
+
+    const Index per_thread_local_stride = PannelParameters::LocalThreadSizeR * reduce_elements_num_groups;
+    const Index per_thread_global_stride =
+        rt == reduction_dim::outer_most ? num_coeffs_to_preserve * per_thread_local_stride : per_thread_local_stride;
+    for (Index i = globalRId; i < num_coeffs_to_reduce; i += per_thread_local_stride) {
+      op.reduce(evaluator.impl().coeff(global_offset), &accumulator);
+      localOffset += per_thread_local_stride;
+      global_offset += per_thread_global_stride;
+    }
+  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
+    const Index linearLocalThreadId = itemID.get_local_id(0);
+    Index pLocalThreadId = rt == reduction_dim::outer_most ? linearLocalThreadId % PannelParameters::LocalThreadSizeP
+                                                           : linearLocalThreadId / PannelParameters::LocalThreadSizeR;
+    Index rLocalThreadId = rt == reduction_dim::outer_most ? linearLocalThreadId / PannelParameters::LocalThreadSizeP
+                                                           : linearLocalThreadId % PannelParameters::LocalThreadSizeR;
+    const Index pGroupId = rt == reduction_dim::outer_most ? itemID.get_group(0) % preserve_elements_num_groups
+                                                           : itemID.get_group(0) / reduce_elements_num_groups;
+    const Index rGroupId = rt == reduction_dim::outer_most ? itemID.get_group(0) / preserve_elements_num_groups
+                                                           : itemID.get_group(0) % reduce_elements_num_groups;
+
+    Index globalPId = pGroupId * PannelParameters::LocalThreadSizeP + pLocalThreadId;
+    const Index globalRId = rGroupId * PannelParameters::LocalThreadSizeR + rLocalThreadId;
+    CoeffReturnType *scratchPtr = scratch.get_pointer();
+    auto outPtr = output_accessor + (reduce_elements_num_groups > 1 ? rGroupId * num_coeffs_to_preserve : 0);
+    CoeffReturnType accumulator = op.initialize();
+
+    element_wise_reduce(globalRId, globalPId, accumulator);
+
+    accumulator = OpDef::finalise_op(op.finalize(accumulator), num_coeffs_to_reduce);
+    scratchPtr[pLocalThreadId + rLocalThreadId * (PannelParameters::LocalThreadSizeP + PannelParameters::BC)] =
+        accumulator;
+    if (rt == reduction_dim::inner_most) {
+      pLocalThreadId = linearLocalThreadId % PannelParameters::LocalThreadSizeP;
+      rLocalThreadId = linearLocalThreadId / PannelParameters::LocalThreadSizeP;
+      globalPId = pGroupId * PannelParameters::LocalThreadSizeP + pLocalThreadId;
+    }
+
+    /* Apply the reduction operation between the current local
+     * id and the one on the other half of the vector. */
+    auto out_scratch_ptr =
+        scratchPtr + (pLocalThreadId + (rLocalThreadId * (PannelParameters::LocalThreadSizeP + PannelParameters::BC)));
+    itemID.barrier(cl::sycl::access::fence_space::local_space);
+    if (rt == reduction_dim::inner_most) {
+      accumulator = *out_scratch_ptr;
+    }
+    // The Local LocalThreadSizeR is always power of 2
+    EIGEN_UNROLL_LOOP
+    for (Index offset = PannelParameters::LocalThreadSizeR >> 1; offset > 0; offset >>= 1) {
+      if (rLocalThreadId < offset) {
+        op.reduce(out_scratch_ptr[(PannelParameters::LocalThreadSizeP + PannelParameters::BC) * offset], &accumulator);
+        // The result has already been divided for mean reducer in the
+        // previous reduction so no need to divide furthermore
+        *out_scratch_ptr = op.finalize(accumulator);
+      }
+      /* All threads collectively read from global memory into local.
+       * The barrier ensures all threads' IO is resolved before
+       * execution continues (strictly speaking, all threads within
+       * a single work-group - there is no co-ordination between
+       * work-groups, only work-items). */
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+    }
+
+    if (rLocalThreadId == 0 && globalPId < num_coeffs_to_preserve) {
+      outPtr[globalPId] = op.finalize(accumulator);
+    }
+  }
+};
+
+template <typename OutScalar, typename Index, typename InputAccessor, typename OutputAccessor, typename OpType>
+struct SecondStepPartialReduction {
+  typedef OpDefiner<OpType, OutScalar, Index, false> OpDef;
+  typedef typename OpDef::type Op;
+  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      ScratchAccessor;
+  InputAccessor input_accessor;
+  OutputAccessor output_accessor;
+  Op op;
+  const Index num_coeffs_to_preserve;
+  const Index num_coeffs_to_reduce;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE SecondStepPartialReduction(ScratchAccessor, InputAccessor input_accessor_,
+                                                                   OutputAccessor output_accessor_, OpType op_,
+                                                                   const Index num_coeffs_to_preserve_,
+                                                                   const Index num_coeffs_to_reduce_)
+      : input_accessor(input_accessor_),
+        output_accessor(output_accessor_),
+        op(OpDef::get_op(op_)),
+        num_coeffs_to_preserve(num_coeffs_to_preserve_),
+        num_coeffs_to_reduce(num_coeffs_to_reduce_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
+    const Index globalId = itemID.get_global_id(0);
+
+    if (globalId >= num_coeffs_to_preserve) return;
+
+    auto in_ptr = input_accessor + globalId;
+
+    OutScalar accumulator = op.initialize();
+    // num_coeffs_to_reduce is not bigger than 256
+    for (Index i = 0; i < num_coeffs_to_reduce; i++) {
+      op.reduce(*in_ptr, &accumulator);
+      in_ptr += num_coeffs_to_preserve;
+    }
+    output_accessor[globalId] = op.finalize(accumulator);
+  }
+};
+
+template <typename Index, Index LTP, Index LTR, bool BC_>
+struct ReductionPannel {
+  static constexpr Index LocalThreadSizeP = LTP;
+  static constexpr Index LocalThreadSizeR = LTR;
+  static constexpr bool BC = BC_;
+};
+
+template <typename Self, typename Op, TensorSycl::internal::reduction_dim rt>
+struct PartialReducerLauncher {
+  typedef typename Self::EvaluatorPointerType EvaluatorPointerType;
+  typedef typename Self::CoeffReturnType CoeffReturnType;
+  typedef typename Self::Storage Storage;
+  typedef typename Self::Index Index;
+  typedef ReductionPannel<typename Self::Index, EIGEN_SYCL_LOCAL_THREAD_DIM0, EIGEN_SYCL_LOCAL_THREAD_DIM1, true>
+      PannelParameters;
+
+  typedef PartialReductionKernel<Self, Op, PannelParameters, rt> SyclReducerKerneType;
+
+  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev, EvaluatorPointerType output,
+                  Index num_coeffs_to_reduce, Index num_coeffs_to_preserve) {
+    Index roundUpP = roundUp(num_coeffs_to_preserve, PannelParameters::LocalThreadSizeP);
+
+    // getPowerOfTwo makes sure local range is power of 2 and <=
+    // maxSyclThreadPerBlock this will help us to avoid extra check on the
+    // kernel
+    static_assert(!((PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR) &
+                    (PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR - 1)),
+                  "The Local thread size must be a power of 2 for the reduction "
+                  "operation");
+
+    constexpr Index localRange = PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR;
+    // In this step, we force the code not to be more than 2-step reduction:
+    // Our empirical research shows that if each thread reduces at least 64
+    // elements individually, we get better performance. However, this can change
+    // on different platforms. In this step we force the code not to be
+    // more than 2-step reduction: Our empirical research shows that for inner_most
+    // dim reducer, it is better to have 8 group in a reduce dimension for sizes
+    // > 1024 to achieve the best performance.
+    const Index reductionPerThread = 64;
+    Index cu = dev.getPowerOfTwo(dev.getNumSyclMultiProcessors(), true);
+    const Index pNumGroups = roundUpP / PannelParameters::LocalThreadSizeP;
+    Index rGroups = (cu + pNumGroups - 1) / pNumGroups;
+    const Index rNumGroups = num_coeffs_to_reduce > reductionPerThread * localRange ? std::min(rGroups, localRange) : 1;
+    const Index globalRange = pNumGroups * rNumGroups * localRange;
+
+    constexpr Index scratchSize =
+        PannelParameters::LocalThreadSizeR * (PannelParameters::LocalThreadSizeP + PannelParameters::BC);
+    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(globalRange), cl::sycl::range<1>(localRange));
+    if (rNumGroups > 1) {
+      CoeffReturnType *temp_pointer = static_cast<CoeffReturnType *>(
+          dev.allocate_temp(num_coeffs_to_preserve * rNumGroups * sizeof(CoeffReturnType)));
+      EvaluatorPointerType temp_accessor = dev.get(temp_pointer);
+      dev.template unary_kernel_launcher<CoeffReturnType, SyclReducerKerneType>(
+             self, temp_accessor, thread_range, scratchSize, reducer, pNumGroups, rNumGroups, num_coeffs_to_preserve,
+             num_coeffs_to_reduce)
+          .wait();
+      typedef SecondStepPartialReduction<CoeffReturnType, Index, EvaluatorPointerType, EvaluatorPointerType, Op>
+          SecondStepPartialReductionKernel;
+      dev.template unary_kernel_launcher<CoeffReturnType, SecondStepPartialReductionKernel>(
+             temp_accessor, output,
+             cl::sycl::nd_range<1>(cl::sycl::range<1>(pNumGroups * localRange), cl::sycl::range<1>(localRange)),
+             Index(1), reducer, num_coeffs_to_preserve, rNumGroups)
+          .wait();
+      self.device().deallocate_temp(temp_pointer);
+    } else {
+      dev.template unary_kernel_launcher<CoeffReturnType, SyclReducerKerneType>(
+             self, output, thread_range, scratchSize, reducer, pNumGroups, rNumGroups, num_coeffs_to_preserve,
+             num_coeffs_to_reduce)
+          .wait();
+    }
+    return false;
+  }
+};
+}  // namespace internal
+}  // namespace TensorSycl
+
+namespace internal {
+
+template <typename Self, typename Op, bool Vectorizable>
+struct FullReducer<Self, Op, Eigen::SyclDevice, Vectorizable> {
+  typedef typename Self::CoeffReturnType CoeffReturnType;
+  typedef typename Self::EvaluatorPointerType EvaluatorPointerType;
+  static constexpr bool HasOptimizedImplementation = true;
+  static constexpr int PacketSize = Self::PacketAccess ? Self::PacketSize : 1;
+  static void run(const Self &self, Op &reducer, const Eigen::SyclDevice &dev, EvaluatorPointerType data) {
+    typedef std::conditional_t<Self::PacketAccess, typename Self::PacketReturnType, CoeffReturnType> OutType;
+    static_assert(!((EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1) &
+                    (EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1 - 1)),
+                  "The Local thread size must be a power of 2 for the reduction "
+                  "operation");
+    constexpr Index local_range = EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1;
+
+    typename Self::Index inputSize = self.impl().dimensions().TotalSize();
+    // In this step we force the code not to be more than 2-step reduction:
+    // Our empirical research shows that if each thread reduces at least 512
+    // elements individually, we get better performance.
+    const Index reductionPerThread = 2048;
+    Index reductionGroup = dev.getPowerOfTwo(
+        (inputSize + (reductionPerThread * local_range - 1)) / (reductionPerThread * local_range), true);
+    const Index num_work_group = std::min(reductionGroup, local_range);
+    const Index global_range = num_work_group * local_range;
+
+    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
+    typedef TensorSycl::internal::FullReductionKernelFunctor<Self, Op, local_range> reduction_kernel_t;
+    if (num_work_group > 1) {
+      CoeffReturnType *temp_pointer =
+          static_cast<CoeffReturnType *>(dev.allocate_temp(num_work_group * sizeof(CoeffReturnType)));
+      typename Self::EvaluatorPointerType tmp_global_accessor = dev.get(temp_pointer);
+      dev.template unary_kernel_launcher<OutType, reduction_kernel_t>(self, tmp_global_accessor, thread_range,
+                                                                      local_range, inputSize, reducer)
+          .wait();
+      typedef TensorSycl::internal::SecondStepFullReducer<CoeffReturnType, Op, EvaluatorPointerType,
+                                                          EvaluatorPointerType, Index, local_range>
+          GenericRKernel;
+      dev.template unary_kernel_launcher<CoeffReturnType, GenericRKernel>(
+             tmp_global_accessor, data,
+             cl::sycl::nd_range<1>(cl::sycl::range<1>(num_work_group), cl::sycl::range<1>(num_work_group)),
+             num_work_group, reducer)
+          .wait();
+      dev.deallocate_temp(temp_pointer);
+    } else {
+      dev.template unary_kernel_launcher<OutType, reduction_kernel_t>(self, data, thread_range, local_range, inputSize,
+                                                                      reducer)
+          .wait();
+    }
+  }
+};
+// vectorizable inner_most most dim preserver
+// col reduction
+template <typename Self, typename Op>
+struct OuterReducer<Self, Op, Eigen::SyclDevice> {
+  static constexpr bool HasOptimizedImplementation = true;
+
+  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev,
+                  typename Self::EvaluatorPointerType output, typename Self::Index num_coeffs_to_reduce,
+                  typename Self::Index num_coeffs_to_preserve) {
+    return ::Eigen::TensorSycl::internal::PartialReducerLauncher<
+        Self, Op, ::Eigen::TensorSycl::internal::reduction_dim::outer_most>::run(self, reducer, dev, output,
+                                                                                 num_coeffs_to_reduce,
+                                                                                 num_coeffs_to_preserve);
+  }
+};
+// row reduction
+template <typename Self, typename Op>
+struct InnerReducer<Self, Op, Eigen::SyclDevice> {
+  static constexpr bool HasOptimizedImplementation = true;
+
+  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev,
+                  typename Self::EvaluatorPointerType output, typename Self::Index num_coeffs_to_reduce,
+                  typename Self::Index num_coeffs_to_preserve) {
+    return ::Eigen::TensorSycl::internal::PartialReducerLauncher<
+        Self, Op, ::Eigen::TensorSycl::internal::reduction_dim::inner_most>::run(self, reducer, dev, output,
+                                                                                 num_coeffs_to_reduce,
+                                                                                 num_coeffs_to_preserve);
+  }
+};
+
+// ArgMax uses this kernel for partial reduction.
+// TODO(@mehdi.goli): Come up with a better kernel.
+// generic partial reduction
+template <typename Self, typename Op>
+struct GenericReducer<Self, Op, Eigen::SyclDevice> {
+  static constexpr bool HasOptimizedImplementation = false;
+  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev,
+                  typename Self::EvaluatorPointerType output, typename Self::Index num_values_to_reduce,
+                  typename Self::Index num_coeffs_to_preserve) {
+    typename Self::Index range, GRange, tileSize;
+    dev.parallel_for_setup(num_coeffs_to_preserve, tileSize, range, GRange);
+
+    dev.template unary_kernel_launcher<typename Self::CoeffReturnType,
+                                       TensorSycl::internal::GenericNondeterministicReducer<Self, Op>>(
+           self, output, cl::sycl::nd_range<1>(cl::sycl::range<1>(GRange), cl::sycl::range<1>(tileSize)), Index(1),
+           reducer, range, (num_values_to_reduce != 0) ? num_values_to_reduce : static_cast<Index>(1))
+        .wait();
+    return false;
+  }
+};
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // UNSUPPORTED_EIGEN_SRC_TENSOR_TENSOR_REDUCTION_SYCL_HPP
diff --git a/contrib/Eigen/src/Tensor/TensorRef.h b/contrib/Eigen/src/Tensor/TensorRef.h
new file mode 100644
index 0000000..81a4f40
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorRef.h
@@ -0,0 +1,400 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_REF_H
+#define EIGEN_TENSOR_TENSOR_REF_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Dimensions, typename Scalar>
+class TensorLazyBaseEvaluator {
+ public:
+  TensorLazyBaseEvaluator() = default;
+  virtual ~TensorLazyBaseEvaluator() = default;
+
+  EIGEN_DEVICE_FUNC virtual const Dimensions& dimensions() const = 0;
+  EIGEN_DEVICE_FUNC virtual const Scalar* data() const = 0;
+
+  EIGEN_DEVICE_FUNC virtual const Scalar coeff(DenseIndex index) const = 0;
+  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex index) = 0;
+
+  void incrRefCount() { ++m_refcount; }
+  void decrRefCount() { --m_refcount; }
+  int refCount() const { return m_refcount; }
+
+ private:
+  TensorLazyBaseEvaluator(const TensorLazyBaseEvaluator& other) = delete;
+  TensorLazyBaseEvaluator& operator=(const TensorLazyBaseEvaluator& other) = delete;
+
+  int m_refcount = 0;
+};
+
+template <typename Dimensions, typename Expr, typename Device>
+class TensorLazyEvaluatorReadOnly
+    : public TensorLazyBaseEvaluator<Dimensions, typename TensorEvaluator<Expr, Device>::Scalar> {
+ public:
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  typedef typename TensorEvaluator<Expr, Device>::Scalar Scalar;
+  typedef StorageMemory<Scalar, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+  typedef TensorEvaluator<Expr, Device> EvalType;
+
+  TensorLazyEvaluatorReadOnly(const Expr& expr, const Device& device) : m_impl(expr, device), m_dummy() {
+    EIGEN_STATIC_ASSERT(
+        internal::array_size<Dimensions>::value == internal::array_size<typename EvalType::Dimensions>::value,
+        "Dimension sizes must match.");
+    const auto& other_dims = m_impl.dimensions();
+    for (std::size_t i = 0; i < m_dims.size(); ++i) {
+      m_dims[i] = other_dims[i];
+    }
+    m_impl.evalSubExprsIfNeeded(nullptr);
+  }
+  virtual ~TensorLazyEvaluatorReadOnly() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC virtual const Dimensions& dimensions() const { return m_dims; }
+  EIGEN_DEVICE_FUNC virtual const Scalar* data() const { return m_impl.data(); }
+
+  EIGEN_DEVICE_FUNC virtual const Scalar coeff(DenseIndex index) const {
+    return m_impl.coeff(internal::convert_index<typename EvalType::Index>(index));
+  }
+  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex /*index*/) {
+    eigen_assert(false && "can't reference the coefficient of a rvalue");
+    return m_dummy;
+  }
+
+ protected:
+  TensorEvaluator<Expr, Device> m_impl;
+  Dimensions m_dims;
+  Scalar m_dummy;
+};
+
+template <typename Dimensions, typename Expr, typename Device>
+class TensorLazyEvaluatorWritable : public TensorLazyEvaluatorReadOnly<Dimensions, Expr, Device> {
+ public:
+  typedef TensorLazyEvaluatorReadOnly<Dimensions, Expr, Device> Base;
+  typedef typename Base::Scalar Scalar;
+  typedef StorageMemory<Scalar, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  TensorLazyEvaluatorWritable(const Expr& expr, const Device& device) : Base(expr, device) {}
+  virtual ~TensorLazyEvaluatorWritable() = default;
+
+  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex index) {
+    return this->m_impl.coeffRef(internal::convert_index<typename Base::EvalType::Index>(index));
+  }
+};
+
+template <typename Dimensions, typename Expr, typename Device, bool IsWritable>
+class TensorLazyEvaluator : public std::conditional_t<IsWritable, TensorLazyEvaluatorWritable<Dimensions, Expr, Device>,
+                                                      TensorLazyEvaluatorReadOnly<Dimensions, const Expr, Device>> {
+ public:
+  typedef std::conditional_t<IsWritable, TensorLazyEvaluatorWritable<Dimensions, Expr, Device>,
+                             TensorLazyEvaluatorReadOnly<Dimensions, const Expr, Device>>
+      Base;
+  typedef typename Base::Scalar Scalar;
+
+  TensorLazyEvaluator(const Expr& expr, const Device& device) : Base(expr, device) {}
+  virtual ~TensorLazyEvaluator() = default;
+};
+
+template <typename Derived>
+class TensorRefBase : public TensorBase<Derived> {
+ public:
+  typedef typename traits<Derived>::PlainObjectType PlainObjectType;
+  typedef typename PlainObjectType::Base Base;
+  typedef typename Eigen::internal::ref_selector<Derived>::type Nested;
+  typedef typename traits<PlainObjectType>::StorageKind StorageKind;
+  typedef typename traits<PlainObjectType>::Index Index;
+  typedef typename traits<PlainObjectType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef typename Base::CoeffReturnType CoeffReturnType;
+  typedef Scalar* PointerType;
+  typedef PointerType PointerArgType;
+
+  static constexpr Index NumIndices = PlainObjectType::NumIndices;
+  typedef typename PlainObjectType::Dimensions Dimensions;
+
+  static constexpr int Layout = PlainObjectType::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = false,
+    BlockAccess = false,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -----------===//
+  typedef TensorBlockNotImplemented TensorBlock;
+  //===------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorRefBase() = default;
+
+  TensorRefBase(const TensorRefBase& other) : TensorBase<Derived>(other), m_evaluator(other.m_evaluator) {
+    eigen_assert(m_evaluator->refCount() > 0);
+    m_evaluator->incrRefCount();
+  }
+
+  TensorRefBase& operator=(const TensorRefBase& other) {
+    if (this != &other) {
+      unrefEvaluator();
+      m_evaluator = other.m_evaluator;
+      eigen_assert(m_evaluator->refCount() > 0);
+      m_evaluator->incrRefCount();
+    }
+    return *this;
+  }
+
+  template <typename Expression,
+            typename EnableIf = std::enable_if_t<!std::is_same<std::decay_t<Expression>, Derived>::value>>
+  EIGEN_STRONG_INLINE TensorRefBase(const Expression& expr)
+      : m_evaluator(new TensorLazyEvaluator<Dimensions, Expression, DefaultDevice,
+                                            /*IsWritable=*/!std::is_const<PlainObjectType>::value &&
+                                                bool(is_lvalue<Expression>::value)>(expr, DefaultDevice())) {
+    m_evaluator->incrRefCount();
+  }
+
+  template <typename Expression,
+            typename EnableIf = std::enable_if_t<!std::is_same<std::decay_t<Expression>, Derived>::value>>
+  EIGEN_STRONG_INLINE TensorRefBase& operator=(const Expression& expr) {
+    unrefEvaluator();
+    m_evaluator = new TensorLazyEvaluator < Dimensions, Expression, DefaultDevice,
+    /*IsWritable=*/!std::is_const<PlainObjectType>::value&& bool(is_lvalue<Expression>::value) >
+        (expr, DefaultDevice());
+    m_evaluator->incrRefCount();
+    return *this;
+  }
+
+  ~TensorRefBase() { unrefEvaluator(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return m_evaluator->dimensions().size(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(Index n) const { return m_evaluator->dimensions()[n]; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_evaluator->dimensions(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_evaluator->dimensions().TotalSize(); }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_evaluator->data(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index index) const { return m_evaluator->coeff(index); }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index firstIndex, IndexTypes... otherIndices) const {
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    const std::size_t num_indices = sizeof...(otherIndices) + 1;
+    const array<Index, num_indices> indices{{firstIndex, static_cast<Index>(otherIndices)...}};
+    return coeff(indices);
+  }
+
+  template <std::size_t NumIndices>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(const array<Index, NumIndices>& indices) const {
+    const Dimensions& dims = this->dimensions();
+    Index index = 0;
+    EIGEN_IF_CONSTEXPR (PlainObjectType::Options & RowMajor) {
+      index += indices[0];
+      for (size_t i = 1; i < NumIndices; ++i) {
+        index = index * dims[i] + indices[i];
+      }
+    } else {
+      index += indices[NumIndices - 1];
+      for (int i = NumIndices - 2; i >= 0; --i) {
+        index = index * dims[i] + indices[i];
+      }
+    }
+    return m_evaluator->coeff(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index index) const { return m_evaluator->coeff(index); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_evaluator->coeffRef(index); }
+
+ protected:
+  TensorLazyBaseEvaluator<Dimensions, Scalar>* evaluator() { return m_evaluator; }
+
+ private:
+  EIGEN_STRONG_INLINE void unrefEvaluator() {
+    if (m_evaluator) {
+      m_evaluator->decrRefCount();
+      if (m_evaluator->refCount() == 0) {
+        delete m_evaluator;
+      }
+    }
+  }
+
+  TensorLazyBaseEvaluator<Dimensions, Scalar>* m_evaluator = nullptr;
+};
+
+}  // namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief A reference to a tensor expression
+ * The expression will be evaluated lazily (as much as possible).
+ *
+ */
+template <typename PlainObjectType>
+class TensorRef : public internal::TensorRefBase<TensorRef<PlainObjectType>> {
+  typedef internal::TensorRefBase<TensorRef<PlainObjectType>> Base;
+
+ public:
+  using Scalar = typename Base::Scalar;
+  using Dimensions = typename Base::Dimensions;
+  // Without this, unqualified Index below does not find the dependent base's typedef and resolves to Eigen::Index,
+  // giving the accessors a different index type than the rest of the class.
+  using Index = typename Base::Index;
+
+  EIGEN_STRONG_INLINE TensorRef() = default;
+
+  EIGEN_STRONG_INLINE TensorRef(const TensorRef& other) = default;
+
+  template <typename Expression>
+  EIGEN_STRONG_INLINE TensorRef(const Expression& expr) : Base(expr) {
+    EIGEN_STATIC_ASSERT(internal::is_lvalue<Expression>::value,
+                        "Expression must be mutable to create a mutable TensorRef<Expression>.  Did you mean "
+                        "TensorRef<const Expression>?)");
+  }
+
+  TensorRef& operator=(const TensorRef& other) { return Base::operator=(other).derived(); }
+
+  template <typename Expression>
+  EIGEN_STRONG_INLINE TensorRef& operator=(const Expression& expr) {
+    EIGEN_STATIC_ASSERT(internal::is_lvalue<Expression>::value,
+                        "Expression must be mutable to create a mutable TensorRef<Expression>.  Did you mean "
+                        "TensorRef<const Expression>?)");
+    return Base::operator=(expr).derived();
+  }
+
+  template <typename... IndexTypes>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices) {
+    eigen_assert(internal::indices_fit<Index>(otherIndices...));
+    const std::size_t num_indices = sizeof...(otherIndices) + 1;
+    const array<Index, num_indices> indices{{firstIndex, static_cast<Index>(otherIndices)...}};
+    return coeffRef(indices);
+  }
+
+  template <std::size_t NumIndices>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) {
+    const Dimensions& dims = this->dimensions();
+    Index index = 0;
+    EIGEN_IF_CONSTEXPR (PlainObjectType::Options & RowMajor) {
+      index += indices[0];
+      for (size_t i = 1; i < NumIndices; ++i) {
+        index = index * dims[i] + indices[i];
+      }
+    } else {
+      index += indices[NumIndices - 1];
+      for (int i = NumIndices - 2; i >= 0; --i) {
+        index = index * dims[i] + indices[i];
+      }
+    }
+    return Base::evaluator()->coeffRef(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return Base::evaluator()->coeffRef(index); }
+};
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief A reference to a constant tensor expression
+ * The expression will be evaluated lazily (as much as possible).
+ *
+ */
+template <typename PlainObjectType>
+class TensorRef<const PlainObjectType> : public internal::TensorRefBase<TensorRef<const PlainObjectType>> {
+  typedef internal::TensorRefBase<TensorRef<const PlainObjectType>> Base;
+
+ public:
+  EIGEN_STRONG_INLINE TensorRef() = default;
+
+  EIGEN_STRONG_INLINE TensorRef(const TensorRef& other) = default;
+
+  template <typename Expression>
+  EIGEN_STRONG_INLINE TensorRef(const Expression& expr) : Base(expr) {}
+
+  TensorRef& operator=(const TensorRef& other) { return Base::operator=(other).derived(); }
+
+  template <typename Expression>
+  EIGEN_STRONG_INLINE TensorRef& operator=(const Expression& expr) {
+    return Base::operator=(expr).derived();
+  }
+};
+
+// evaluator for rvalues
+template <typename Derived, typename Device>
+struct TensorEvaluator<const TensorRef<Derived>, Device> {
+  typedef typename Derived::Index Index;
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename Derived::Dimensions Dimensions;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorRef<Derived>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = false,
+    BlockAccess = false,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const TensorRef<Derived>& m, const Device&) : m_ref(m) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_ref.dimensions(); }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) { return true; }
+
+  EIGEN_STRONG_INLINE void cleanup() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_ref.coeff(index); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_ref.coeffRef(index); }
+
+  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_ref.data(); }
+
+ protected:
+  TensorRef<Derived> m_ref;
+};
+
+// evaluator for lvalues
+template <typename Derived, typename Device>
+struct TensorEvaluator<TensorRef<Derived>, Device> : public TensorEvaluator<const TensorRef<Derived>, Device> {
+  typedef typename Derived::Index Index;
+  typedef typename Derived::Scalar Scalar;
+  typedef typename Derived::Scalar CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef typename Derived::Dimensions Dimensions;
+
+  typedef TensorEvaluator<const TensorRef<Derived>, Device> Base;
+
+  enum { IsAligned = false, PacketAccess = false, BlockAccess = false, PreferBlockAccess = false, RawAccess = false };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(TensorRef<Derived>& m, const Device& d) : Base(m, d) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return this->m_ref.coeffRef(index); }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_REF_H
diff --git a/contrib/Eigen/src/Tensor/TensorReverse.h b/contrib/Eigen/src/Tensor/TensorReverse.h
new file mode 100644
index 0000000..2fc5107
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorReverse.h
@@ -0,0 +1,482 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Navdeep Jaitly <ndjaitly@google.com>
+//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_REVERSE_H
+#define EIGEN_TENSOR_TENSOR_REVERSE_H
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename ReverseDimensions, typename XprType>
+struct traits<TensorReverseOp<ReverseDimensions, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename ReverseDimensions, typename XprType>
+struct eval<TensorReverseOp<ReverseDimensions, XprType>, Eigen::Dense> {
+  typedef const TensorReverseOp<ReverseDimensions, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor reverse elements class.
+ *
+ */
+template <typename ReverseDimensions, typename XprType>
+class TensorReverseOp : public TensorBase<TensorReverseOp<ReverseDimensions, XprType>, WriteAccessors> {
+ public:
+  typedef TensorBase<TensorReverseOp<ReverseDimensions, XprType>, WriteAccessors> Base;
+  typedef typename Eigen::internal::traits<TensorReverseOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorReverseOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorReverseOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorReverseOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReverseOp(const XprType& expr, const ReverseDimensions& reverse_dims)
+      : m_xpr(expr), m_reverse_dims(reverse_dims) {}
+
+  EIGEN_DEVICE_FUNC const ReverseDimensions& reverse() const { return m_reverse_dims; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorReverseOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const ReverseDimensions m_reverse_dims;
+};
+
+// Eval as rvalue
+template <typename ReverseDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device> {
+  typedef TensorReverseOp<ReverseDimensions, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<ReverseDimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = NumDims > 0,
+    PreferBlockAccess = true,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  typedef internal::TensorIntDivisor<Index> IndexDivisor;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
+
+  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_reverse(op.reverse()), m_device(device) {
+    // Reversing a scalar isn't supported yet. It would be a no-op anyway.
+    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    // Compute strides
+    m_dimensions = m_impl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_strides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
+        if (m_strides[i] > 0) m_fastStrides[i] = IndexDivisor(m_strides[i]);
+      }
+    } else {
+      m_strides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
+        if (m_strides[i] > 0) m_fastStrides[i] = IndexDivisor(m_strides[i]);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index reverseIndex(Index index) const {
+    eigen_assert(index < dimensions().TotalSize());
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        Index idx = index / m_fastStrides[i];
+        index -= idx * m_strides[i];
+        if (m_reverse[i]) {
+          idx = m_dimensions[i] - idx - 1;
+        }
+        inputIndex += idx * m_strides[i];
+      }
+      if (m_reverse[0]) {
+        inputIndex += m_dimensions[0] - index - 1;
+      } else {
+        inputIndex += index;
+      }
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        Index idx = index / m_fastStrides[i];
+        index -= idx * m_strides[i];
+        if (m_reverse[i]) {
+          idx = m_dimensions[i] - idx - 1;
+        }
+        inputIndex += idx * m_strides[i];
+      }
+      if (m_reverse[NumDims - 1]) {
+        inputIndex += m_dimensions[NumDims - 1] - index - 1;
+      } else {
+        inputIndex += index;
+      }
+    }
+    return inputIndex;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    return m_impl.coeff(reverseIndex(index));
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    // Fast path: when the whole packet stays inside a single inner-most
+    // slice of the input, replace PacketSize coeff() calls with one packet
+    // load (plus a preverse when the inner dim is reversed).
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    const Index inner_size = m_dimensions[inner_dim];
+    const Index inner_pos = index % inner_size;
+    if (inner_pos + PacketSize <= inner_size) {
+      if (m_reverse[inner_dim]) {
+        const Index input_index = reverseIndex(index + PacketSize - 1);
+        return internal::preverse(m_impl.template packet<Unaligned>(input_index));
+      }
+      return m_impl.template packet<Unaligned>(reverseIndex(index));
+    }
+
+    // Slow path: the packet crosses an inner-slice boundary, so the
+    // contiguous-load trick does not apply.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    return internal::pload<PacketReturnType>(values);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.lastLevelCacheSize();
+    // Block evaluation reads underlying memory in reverse order, and default
+    // cost model does not properly catch this in bytes stored/loaded.
+    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size).addCostPerCoeff({0, 0, 24});
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    // TODO(ezhulenev): If underlying tensor expression supports and prefers
+    // block evaluation we must use it. Currently we use coeff and packet
+    // access into the underlying tensor expression.
+    static const bool isColMajor = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    static constexpr Index inner_dim_idx = isColMajor ? 0 : NumDims - 1;
+    const bool inner_dim_reversed = m_reverse[inner_dim_idx];
+
+    // Offset in the output block.
+    Index block_offset = 0;
+
+    // Offset in the input Tensor.
+    Index input_offset = reverseIndex(desc.offset());
+
+    // Initialize output block iterator state. Dimensions in this array are
+    // always in inner_most -> outer_most order (col major layout).
+    array<BlockIteratorState, NumDims> it;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = isColMajor ? i : NumDims - 1 - i;
+      it[i].size = desc.dimension(dim);
+      it[i].count = 0;
+      it[i].reverse = m_reverse[dim];
+
+      it[i].block_stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].block_stride);
+      it[i].block_span = it[i].block_stride * (it[i].size - 1);
+
+      it[i].input_stride = m_strides[dim];
+      it[i].input_span = it[i].input_stride * (it[i].size - 1);
+
+      if (it[i].reverse) {
+        it[i].input_stride = -1 * it[i].input_stride;
+        it[i].input_span = -1 * it[i].input_span;
+      }
+    }
+
+    // If multiple inner dimensions have the same reverse flag, check if we can
+    // merge them into a single virtual inner dimension.
+    int effective_inner_dim = 0;
+    for (int i = 1; i < NumDims; ++i) {
+      if (it[i].reverse != it[effective_inner_dim].reverse) break;
+      if (it[i].block_stride != it[effective_inner_dim].size) break;
+      if (it[i].block_stride != numext::abs(it[i].input_stride)) break;
+
+      it[i].size = it[effective_inner_dim].size * it[i].size;
+
+      it[i].block_stride = 1;
+      it[i].input_stride = (inner_dim_reversed ? -1 : 1);
+
+      it[i].block_span = it[i].block_stride * (it[i].size - 1);
+      it[i].input_span = it[i].input_stride * (it[i].size - 1);
+
+      effective_inner_dim = i;
+    }
+
+    eigen_assert(it[effective_inner_dim].block_stride == 1);
+    eigen_assert(it[effective_inner_dim].input_stride == (inner_dim_reversed ? -1 : 1));
+
+    const Index inner_dim_size = it[effective_inner_dim].size;
+
+    // Prepare storage for the materialized reverse result.
+    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    CoeffReturnType* block_buffer = block_storage.data();
+
+    while (it[NumDims - 1].count < it[NumDims - 1].size) {
+      // Copy inner-most dimension data from reversed location in input.
+      Index dst = block_offset;
+      Index src = input_offset;
+
+      // NOTE(ezhulenev): Adding vectorized path with internal::preverse showed
+      // worse results in benchmarks than a simple coefficient loop.
+      if (inner_dim_reversed) {
+        for (Index i = 0; i < inner_dim_size; ++i) {
+          block_buffer[dst] = m_impl.coeff(src);
+          ++dst;
+          --src;
+        }
+      } else {
+        for (Index i = 0; i < inner_dim_size; ++i) {
+          block_buffer[dst] = m_impl.coeff(src);
+          ++dst;
+          ++src;
+        }
+      }
+
+      // For the 1d tensor we need to generate only one inner-most dimension.
+      if ((NumDims - effective_inner_dim) == 1) break;
+
+      // Update offset.
+      for (Index i = effective_inner_dim + 1; i < NumDims; ++i) {
+        if (++it[i].count < it[i].size) {
+          block_offset += it[i].block_stride;
+          input_offset += it[i].input_stride;
+          break;
+        }
+        if (i != NumDims - 1) it[i].count = 0;
+        block_offset -= it[i].block_span;
+        input_offset -= it[i].input_span;
+      }
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
+                                     TensorOpCost::DivCost<Index>());
+    for (int i = 0; i < NumDims; ++i) {
+      if (m_reverse[i]) {
+        compute_cost += 2 * TensorOpCost::AddCost<Index>();
+      }
+    }
+    // The inner-slice fast path runs the per-coeff index math once per packet,
+    // so the amortized compute cost matches the vectorized convention.
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return nullptr; }
+
+ protected:
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_strides;
+  array<IndexDivisor, NumDims> m_fastStrides;
+  TensorEvaluator<ArgType, Device> m_impl;
+  ReverseDimensions m_reverse;
+  const Device EIGEN_DEVICE_REF m_device;
+
+ private:
+  struct BlockIteratorState {
+    BlockIteratorState()
+        : size(0), count(0), reverse(false), block_stride(0), block_span(0), input_stride(0), input_span(0) {}
+
+    Index size;
+    Index count;
+    bool reverse;
+    Index block_stride;
+    Index block_span;
+    Index input_stride;
+    Index input_span;
+  };
+};
+
+// Eval as lvalue
+
+template <typename ReverseDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<TensorReverseOp<ReverseDimensions, ArgType>, Device>
+    : public TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device> Base;
+  typedef TensorReverseOp<ReverseDimensions, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<ReverseDimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // writeBlock() assigns the re-reversed block expression straight into the
+    // argument's buffer, so it needs raw storage underneath.
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    // Unlike the rvalue side there is no preference: the reversal cost moves
+    // to the block-expression reads, so writing blocks only pays off when the
+    // right-hand side prefers block evaluation anyway.
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return this->m_dimensions; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) const {
+    return this->m_impl.coeffRef(this->reverseIndex(index));
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    // Deliberately not the rvalue evaluator's requirements. Reading a block
+    // reverses memory as it materializes it straight into the output, which is
+    // why that side asks for a last-level-cache sized, inner-dim-skewed block.
+    // As a write destination we have no such preference: writeBlock() only
+    // copies the block into a strided box. Since merge() lets kSkewedInnerDims
+    // win over kUniformAllDims and keeps the larger size, inheriting them would
+    // silently override the shape the right-hand side asked for -- a shuffle
+    // that permutes the inner dimension requests small uniform tiles precisely
+    // because that is what keeps a transpose cache-resident, and turning those
+    // into one cache-sized skewed strip costs more than the block path wins.
+    // Only impose a lower bound on the block size, so that a right-hand side
+    // without any preference still gets sensibly sized blocks.
+    return internal::TensorBlockResourceRequirements::merge(
+        this->m_impl.getResourceRequirements(),
+        internal::TensorBlockResourceRequirements::uniform<Scalar>(this->m_device.firstLevelCacheSize()));
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    // Fast path, mirroring packet() in the rvalue evaluator: when the whole
+    // packet stays inside a single inner-most slice of the input, replace
+    // PacketSize coeffRef() calls (each paying a full reverseIndex walk) with
+    // one packet store (plus a preverse when the inner dim is reversed).
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    const Index inner_size = this->m_dimensions[inner_dim];
+    const Index inner_pos = index % inner_size;
+    if (inner_pos + PacketSize <= inner_size) {
+      if (this->m_reverse[inner_dim]) {
+        const Index input_index = this->reverseIndex(index + PacketSize - 1);
+        this->m_impl.template writePacket<Unaligned>(input_index, internal::preverse(x));
+      } else {
+        this->m_impl.template writePacket<Unaligned>(this->reverseIndex(index), x);
+      }
+      return;
+    }
+
+    // Slow path: the packet crosses an inner-slice boundary.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) CoeffReturnType values[PacketSize];
+    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      this->coeffRef(index + i) = values[i];
+    }
+  }
+
+  template <typename TensorBlock>
+  EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(this->m_impl.data() != nullptr);
+
+    // The destination of a block is a box in the underlying tensor: on a
+    // reversed dimension the output range [o, o + e) maps to the input range
+    // [n - o - e, n - o), whose corner sits (e - 1) strides below the image of
+    // the block's origin.
+    Index input_corner = this->reverseIndex(desc.offset());
+    for (int i = 0; i < NumDims; ++i) {
+      if (this->m_reverse[i]) input_corner -= (desc.dimension(i) - 1) * this->m_strides[i];
+    }
+
+    // Assigning the block expression reversed along the reversed dimensions
+    // into that box cancels the reversal; the reversed reads vectorize via
+    // the rvalue evaluator's inner-slice fast path while the stores stay
+    // contiguous.
+    typedef TensorReverseOp<const ReverseDimensions, const typename TensorBlock::XprType> RevBlockExpr;
+    const RevBlockExpr reversed_block(block.expr(), this->m_reverse);
+
+    typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, RevBlockExpr, Index> TensorBlockAssign;
+    TensorBlockAssign::Run(TensorBlockAssign::target(desc.dimensions(), DSizes<Index, NumDims>(this->m_strides),
+                                                     this->m_impl.data(), input_corner),
+                           reversed_block);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_REVERSE_H
diff --git a/contrib/Eigen/src/Tensor/TensorRoll.h b/contrib/Eigen/src/Tensor/TensorRoll.h
new file mode 100644
index 0000000..405c9ae
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorRoll.h
@@ -0,0 +1,460 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 Tobias Wood tobias@spinicist.org.uk
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_ROLL_H
+#define EIGEN_TENSOR_TENSOR_ROLL_H
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename RollDimensions, typename XprType>
+struct traits<TensorRollOp<RollDimensions, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename RollDimensions, typename XprType>
+struct eval<TensorRollOp<RollDimensions, XprType>, Eigen::Dense> {
+  typedef const TensorRollOp<RollDimensions, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor roll (circular shift) elements class.
+ *
+ */
+template <typename RollDimensions, typename XprType>
+class TensorRollOp : public TensorBase<TensorRollOp<RollDimensions, XprType>, WriteAccessors> {
+ public:
+  typedef TensorBase<TensorRollOp<RollDimensions, XprType>, WriteAccessors> Base;
+  typedef typename Eigen::internal::traits<TensorRollOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorRollOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorRollOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorRollOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorRollOp(const XprType& expr, const RollDimensions& roll_dims)
+      : m_xpr(expr), m_roll_dims(roll_dims) {}
+
+  EIGEN_DEVICE_FUNC const RollDimensions& roll() const { return m_roll_dims; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorRollOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const RollDimensions m_roll_dims;
+};
+
+// Eval as rvalue
+template <typename RollDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorRollOp<RollDimensions, ArgType>, Device> {
+  typedef TensorRollOp<RollDimensions, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<RollDimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = NumDims > 0,
+    PreferBlockAccess = true,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  typedef internal::TensorIntDivisor<Index> IndexDivisor;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  using TensorBlockDesc = internal::TensorBlockDescriptor<NumDims, Index>;
+  using TensorBlockScratch = internal::TensorBlockScratchAllocator<Device>;
+  using ArgTensorBlock = typename TensorEvaluator<const ArgType, Device>::TensorBlock;
+  using TensorBlock = typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index>;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_rolls(op.roll()), m_device(device) {
+    EIGEN_STATIC_ASSERT((NumDims > 0), Must_Have_At_Least_One_Dimension_To_Roll);
+
+    // Compute strides
+    m_dimensions = m_impl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_strides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
+        if (m_strides[i] > 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
+      }
+    } else {
+      m_strides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
+        if (m_strides[i] > 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index roll(Index const i, Index const r, Index const n) const {
+    auto const tmp = (i + r) % n;
+    if (tmp < 0) {
+      return tmp + n;
+    } else {
+      return tmp;
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, NumDims> rollCoords(array<Index, NumDims> const& coords) const {
+    array<Index, NumDims> rolledCoords;
+    for (int id = 0; id < NumDims; id++) {
+      eigen_assert(coords[id] < m_dimensions[id]);
+      rolledCoords[id] = roll(coords[id], m_rolls[id], m_dimensions[id]);
+    }
+    return rolledCoords;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rollIndex(Index index) const {
+    eigen_assert(index < dimensions().TotalSize());
+    Index rolledIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        Index idx = index / m_fast_strides[i];
+        index -= idx * m_strides[i];
+        rolledIndex += roll(idx, m_rolls[i], m_dimensions[i]) * m_strides[i];
+      }
+      rolledIndex += roll(index, m_rolls[0], m_dimensions[0]);
+    } else {
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        Index idx = index / m_fast_strides[i];
+        index -= idx * m_strides[i];
+        rolledIndex += roll(idx, m_rolls[i], m_dimensions[i]) * m_strides[i];
+      }
+      rolledIndex += roll(index, m_rolls[NumDims - 1], m_dimensions[NumDims - 1]);
+    }
+    return rolledIndex;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    return m_impl.coeff(rollIndex(index));
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    // Fast path: when the entire packet stays inside one inner-most slice
+    // of both the output and the rolled input (no modular wrap on the
+    // inner dim), the PacketSize coeff() calls collapse to a single
+    // contiguous packet load from the underlying tensor.
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    const Index inner_size = m_dimensions[inner_dim];
+    const Index inner_pos = index - (index / inner_size) * inner_size;
+    if (inner_pos + PacketSize <= inner_size) {
+      const Index rolled_inner_pos = roll(inner_pos, m_rolls[inner_dim], inner_size);
+      if (rolled_inner_pos + PacketSize <= inner_size) {
+        return m_impl.template packet<Unaligned>(rollIndex(index));
+      }
+    }
+
+    // Slow path: the packet straddles a slice boundary on either side.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    return internal::pload<PacketReturnType>(values);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.lastLevelCacheSize();
+    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size).addCostPerCoeff({0, 0, 24});
+  }
+
+  struct BlockIteratorState {
+    Index stride;
+    Index span;
+    Index size;
+    Index count;
+  };
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    static const bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    // Compute spatial coordinates for the first block element.
+    array<Index, NumDims> coords;
+    extract_coordinates(desc.offset(), coords);
+    array<Index, NumDims> initial_coords = coords;
+    Index offset = 0;  // Offset in the output block buffer.
+
+    // Initialize output block iterator state. Dimensions in this array are
+    // always in inner_most -> outer_most order (col major layout).
+    array<BlockIteratorState, NumDims> it;
+    for (int i = 0; i < NumDims; ++i) {
+      const int dim = is_col_major ? i : NumDims - 1 - i;
+      it[i].size = desc.dimension(dim);
+      it[i].stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].stride);
+      it[i].span = it[i].stride * (it[i].size - 1);
+      it[i].count = 0;
+    }
+    eigen_assert(it[0].stride == 1);
+
+    // Prepare storage for the materialized generator result.
+    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    CoeffReturnType* block_buffer = block_storage.data();
+
+    static constexpr int inner_dim = is_col_major ? 0 : NumDims - 1;
+    const Index inner_dim_size = it[0].size;
+
+    while (it[NumDims - 1].count < it[NumDims - 1].size) {
+      Index i = 0;
+      for (; i < inner_dim_size; ++i) {
+        auto const rolled = rollCoords(coords);
+        auto const index = is_col_major ? m_dimensions.IndexOfColMajor(rolled) : m_dimensions.IndexOfRowMajor(rolled);
+        *(block_buffer + offset + i) = m_impl.coeff(index);
+        coords[inner_dim]++;
+      }
+      coords[inner_dim] = initial_coords[inner_dim];
+
+      EIGEN_IF_CONSTEXPR (NumDims == 1) break;  // For the 1d tensor we need to generate only one inner-most dimension.
+
+      // Update offset.
+      for (i = 1; i < NumDims; ++i) {
+        if (++it[i].count < it[i].size) {
+          offset += it[i].stride;
+          coords[is_col_major ? i : NumDims - 1 - i]++;
+          break;
+        }
+        if (i != NumDims - 1) it[i].count = 0;
+        coords[is_col_major ? i : NumDims - 1 - i] = initial_coords[is_col_major ? i : NumDims - 1 - i];
+        offset -= it[i].span;
+      }
+    }
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
+                                     TensorOpCost::DivCost<Index>());
+    for (int i = 0; i < NumDims; ++i) {
+      compute_cost += 2 * TensorOpCost::AddCost<Index>();
+    }
+    // The inner-slice fast path runs the per-coeff index math once per packet,
+    // so the amortized compute cost matches the vectorized convention.
+    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return nullptr; }
+
+ protected:
+  Dimensions m_dimensions;
+  array<Index, NumDims> m_strides;
+  array<IndexDivisor, NumDims> m_fast_strides;
+  TensorEvaluator<ArgType, Device> m_impl;
+  RollDimensions m_rolls;
+  const Device EIGEN_DEVICE_REF m_device;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_coordinates(Index index, array<Index, NumDims>& coords) const {
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_fast_strides[i];
+        index -= idx * m_strides[i];
+        coords[i] = idx;
+      }
+      coords[0] = index;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_fast_strides[i];
+        index -= idx * m_strides[i];
+        coords[i] = idx;
+      }
+      coords[NumDims - 1] = index;
+    }
+  }
+};
+
+// Eval as lvalue
+
+template <typename RollDimensions, typename ArgType, typename Device>
+struct TensorEvaluator<TensorRollOp<RollDimensions, ArgType>, Device>
+    : public TensorEvaluator<const TensorRollOp<RollDimensions, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorRollOp<RollDimensions, ArgType>, Device> Base;
+  typedef TensorRollOp<RollDimensions, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<RollDimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // writeBlock() scatters the block into the argument's buffer as bulk
+    // copies of the wrap-around pieces, so it needs raw storage underneath.
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    // The coeff/packet write path pays a full div/mod index walk per scalar;
+    // the block path is a handful of bulk copies. Mirrors the rvalue side.
+    PreferBlockAccess = true,
+    CoordAccess = false,
+    RawAccess = false
+  };
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  using TensorBlockDesc = internal::TensorBlockDescriptor<NumDims, Index>;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return this->m_dimensions; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) const {
+    return this->m_impl.coeffRef(this->rollIndex(index));
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) CoeffReturnType values[PacketSize];
+    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      this->coeffRef(index + i) = values[i];
+    }
+  }
+
+  template <typename TensorBlock>
+  EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    if (desc.size() == 0) return;
+    eigen_assert(this->m_impl.data() != nullptr);
+
+    const DSizes<Index, NumDims> block_strides = internal::strides<Layout>(desc.dimensions());
+
+    // Materialize the block into a temporary buffer if it is lazy.
+    const ScalarNoConst* block_buffer = block.data();
+    void* mem = nullptr;
+    if (block_buffer == nullptr) {
+      mem = this->m_device.allocate(desc.size() * sizeof(Scalar));
+      ScalarNoConst* buf = static_cast<ScalarNoConst*>(mem);
+
+      typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename TensorBlock::XprType, Index>
+          TensorBlockAssignment;
+      TensorBlockAssignment::Run(TensorBlockAssignment::target(desc.dimensions(), block_strides, buf), block.expr());
+
+      block_buffer = buf;
+    }
+
+    // Output coordinates of the block's corner.
+    array<Index, NumDims> coords;
+    this->extract_coordinates(desc.offset(), coords);
+
+    // On each dimension the output range [o, o + e) maps to the input range
+    // starting at (o + r) mod n, wrapping around at most once.
+    struct Segment {
+      Index block_start;
+      Index input_start;
+      Index length;
+    };
+    Segment segments[NumDims][2];
+    int num_segments[NumDims];
+    for (int i = 0; i < NumDims; ++i) {
+      const Index n = this->m_dimensions[i];
+      const Index e = desc.dimension(i);
+      const Index start = this->roll(coords[i], this->m_rolls[i], n);
+      if (start + e <= n) {
+        segments[i][0] = {0, start, e};
+        num_segments[i] = 1;
+      } else {
+        segments[i][0] = {0, start, n - start};
+        segments[i][1] = {n - start, 0, e - (n - start)};
+        num_segments[i] = 2;
+      }
+    }
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+
+    const typename TensorBlockIO::Dimensions input_strides(this->m_strides);
+
+    // Copy every wrap-around piece (the cartesian product of the per-dim
+    // segments) into its destination box.
+    int seg_index[NumDims] = {0};
+    for (;;) {
+      DSizes<Index, NumDims> piece_dims;
+      Index src_offset = 0;
+      Index dst_offset = 0;
+      for (int i = 0; i < NumDims; ++i) {
+        const Segment& seg = segments[i][seg_index[i]];
+        piece_dims[i] = seg.length;
+        src_offset += seg.block_start * block_strides[i];
+        dst_offset += seg.input_start * this->m_strides[i];
+      }
+
+      TensorBlockIOSrc src(block_strides, block_buffer, src_offset);
+      TensorBlockIODst dst(piece_dims, input_strides, this->m_impl.data(), dst_offset);
+      TensorBlockIO::Copy(dst, src);
+
+      int d = 0;
+      while (d < NumDims && ++seg_index[d] == num_segments[d]) {
+        seg_index[d] = 0;
+        ++d;
+      }
+      if (d == NumDims) break;
+    }
+
+    // Deallocate temporary buffer used for the block materialization.
+    if (mem != nullptr) this->m_device.deallocate(mem);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_ROLL_H
diff --git a/contrib/Eigen/src/Tensor/TensorScan.h b/contrib/Eigen/src/Tensor/TensorScan.h
new file mode 100644
index 0000000..2406f94
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorScan.h
@@ -0,0 +1,486 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Igor Babuschkin <igor@babuschk.in>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_SCAN_H
+#define EIGEN_TENSOR_TENSOR_SCAN_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename Op, typename XprType>
+struct traits<TensorScanOp<Op, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename Op, typename XprType>
+struct eval<TensorScanOp<Op, XprType>, Eigen::Dense> {
+  typedef const TensorScanOp<Op, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor scan class.
+ */
+template <typename Op, typename XprType>
+class TensorScanOp : public TensorBase<TensorScanOp<Op, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorScanOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorScanOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorScanOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorScanOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorScanOp(const XprType& expr, const Index& axis, bool exclusive = false,
+                                                     const Op& op = Op())
+      : m_expr(expr), m_axis(axis), m_accumulator(op), m_exclusive(exclusive) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index axis() const { return m_axis; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const XprType& expression() const { return m_expr; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Op accumulator() const { return m_accumulator; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool exclusive() const { return m_exclusive; }
+
+ protected:
+  typename XprType::Nested m_expr;
+  const Index m_axis;
+  const Op m_accumulator;
+  const bool m_exclusive;
+};
+
+namespace internal {
+
+template <typename Self>
+EIGEN_STRONG_INLINE void ReduceScalar(Self& self, Index offset, typename Self::CoeffReturnType* data) {
+  // Compute the scan along the axis, starting at the given offset
+  typename Self::CoeffReturnType accum = self.accumulator().initialize();
+  if (self.stride() == 1) {
+    if (self.exclusive()) {
+      for (Index curr = offset; curr < offset + self.size(); ++curr) {
+        data[curr] = self.accumulator().finalize(accum);
+        self.accumulator().reduce(self.inner().coeff(curr), &accum);
+      }
+    } else {
+      for (Index curr = offset; curr < offset + self.size(); ++curr) {
+        self.accumulator().reduce(self.inner().coeff(curr), &accum);
+        data[curr] = self.accumulator().finalize(accum);
+      }
+    }
+  } else {
+    if (self.exclusive()) {
+      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
+        Index curr = offset + idx3 * self.stride();
+        data[curr] = self.accumulator().finalize(accum);
+        self.accumulator().reduce(self.inner().coeff(curr), &accum);
+      }
+    } else {
+      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
+        Index curr = offset + idx3 * self.stride();
+        self.accumulator().reduce(self.inner().coeff(curr), &accum);
+        data[curr] = self.accumulator().finalize(accum);
+      }
+    }
+  }
+}
+
+template <typename Self>
+EIGEN_STRONG_INLINE void ReducePacket(Self& self, Index offset, typename Self::CoeffReturnType* data) {
+  using Scalar = typename Self::CoeffReturnType;
+  using Packet = typename Self::PacketReturnType;
+  // Compute the scan along the axis, starting at the calculated offset
+  Packet accum = self.accumulator().template initializePacket<Packet>();
+  if (self.stride() == 1) {
+    if (self.exclusive()) {
+      for (Index curr = offset; curr < offset + self.size(); ++curr) {
+        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
+        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
+      }
+    } else {
+      for (Index curr = offset; curr < offset + self.size(); ++curr) {
+        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
+        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
+      }
+    }
+  } else {
+    if (self.exclusive()) {
+      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
+        const Index curr = offset + idx3 * self.stride();
+        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
+        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
+      }
+    } else {
+      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
+        const Index curr = offset + idx3 * self.stride();
+        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
+        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
+      }
+    }
+  }
+}
+
+template <typename Self, bool Vectorize, bool Parallel>
+struct ReduceBlock {
+  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
+    for (Index idx2 = 0; idx2 < self.stride(); idx2++) {
+      // Calculate the starting offset for the scan
+      Index offset = idx1 + idx2;
+      ReduceScalar(self, offset, data);
+    }
+  }
+};
+
+// Specialization for vectorized reduction.
+template <typename Self>
+struct ReduceBlock<Self, /*Vectorize=*/true, /*Parallel=*/false> {
+  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
+    using Packet = typename Self::PacketReturnType;
+    const int PacketSize = internal::unpacket_traits<Packet>::size;
+    Index idx2 = 0;
+    for (; idx2 + PacketSize <= self.stride(); idx2 += PacketSize) {
+      // Calculate the starting offset for the packet scan
+      Index offset = idx1 + idx2;
+      ReducePacket(self, offset, data);
+    }
+    for (; idx2 < self.stride(); idx2++) {
+      // Calculate the starting offset for the scan
+      Index offset = idx1 + idx2;
+      ReduceScalar(self, offset, data);
+    }
+  }
+};
+
+// Single-threaded CPU implementation of scan
+template <typename Self, typename Reducer, typename Device,
+          bool Vectorize = (TensorEvaluator<typename Self::ChildTypeNoConst, Device>::PacketAccess &&
+                            internal::reducer_traits<Reducer, Device>::PacketAccess)>
+struct ScanLauncher {
+  void operator()(Self& self, typename Self::CoeffReturnType* data) const {
+    Index total_size = internal::array_prod(self.dimensions());
+
+    // We fix the index along the scan axis to 0 and perform a
+    // scan per remaining entry. The iteration is split into two nested
+    // loops to avoid an integer division by keeping track of each idx1 and
+    // idx2.
+    for (Index idx1 = 0; idx1 < total_size; idx1 += self.stride() * self.size()) {
+      ReduceBlock<Self, Vectorize, /*Parallel=*/false> block_reducer;
+      block_reducer(self, idx1, data);
+    }
+  }
+};
+
+#ifdef EIGEN_USE_THREADS
+
+// Adjust block_size to avoid false sharing of cachelines among
+// threads. Currently set to twice the cache line size on Intel and ARM
+// processors.
+EIGEN_STRONG_INLINE Index AdjustBlockSize(Index item_size, Index block_size) {
+  constexpr Index kBlockAlignment = 128;
+  const Index items_per_cacheline = numext::maxi<Index>(1, kBlockAlignment / item_size);
+  return items_per_cacheline * numext::div_ceil(block_size, items_per_cacheline);
+}
+
+template <typename Self>
+struct ReduceBlock<Self, /*Vectorize=*/true, /*Parallel=*/true> {
+  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
+    using Scalar = typename Self::CoeffReturnType;
+    using Packet = typename Self::PacketReturnType;
+    const int PacketSize = internal::unpacket_traits<Packet>::size;
+    Index num_scalars = self.stride();
+    Index num_packets = 0;
+    if (self.stride() >= PacketSize) {
+      num_packets = self.stride() / PacketSize;
+      self.device().parallelFor(
+          num_packets,
+          TensorOpCost(PacketSize * self.size(), PacketSize * self.size(), 16 * PacketSize * self.size(), true,
+                       PacketSize),
+          // Make the shard size large enough that two neighboring threads
+          // won't write to the same cacheline of `data`.
+          [=](Index blk_size) { return AdjustBlockSize(PacketSize * sizeof(Scalar), blk_size); },
+          [&](Index first, Index last) {
+            for (Index packet = first; packet < last; ++packet) {
+              const Index idx2 = packet * PacketSize;
+              ReducePacket(self, idx1 + idx2, data);
+            }
+          });
+      num_scalars -= num_packets * PacketSize;
+    }
+    self.device().parallelFor(
+        num_scalars, TensorOpCost(self.size(), self.size(), 16 * self.size()),
+        // Make the shard size large enough that two neighboring threads
+        // won't write to the same cacheline of `data`.
+        [=](Index blk_size) { return AdjustBlockSize(sizeof(Scalar), blk_size); },
+        [&](Index first, Index last) {
+          for (Index scalar = first; scalar < last; ++scalar) {
+            const Index idx2 = num_packets * PacketSize + scalar;
+            ReduceScalar(self, idx1 + idx2, data);
+          }
+        });
+  }
+};
+
+template <typename Self>
+struct ReduceBlock<Self, /*Vectorize=*/false, /*Parallel=*/true> {
+  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
+    using Scalar = typename Self::CoeffReturnType;
+    self.device().parallelFor(
+        self.stride(), TensorOpCost(self.size(), self.size(), 16 * self.size()),
+        // Make the shard size large enough that two neighboring threads
+        // won't write to the same cacheline of `data`.
+        [=](Index blk_size) { return AdjustBlockSize(sizeof(Scalar), blk_size); },
+        [&](Index first, Index last) {
+          for (Index idx2 = first; idx2 < last; ++idx2) {
+            ReduceScalar(self, idx1 + idx2, data);
+          }
+        });
+  }
+};
+
+// Specialization for multi-threaded execution.
+template <typename Self, typename Reducer, bool Vectorize>
+struct ScanLauncher<Self, Reducer, ThreadPoolDevice, Vectorize> {
+  void operator()(Self& self, typename Self::CoeffReturnType* data) const {
+    using Scalar = typename Self::CoeffReturnType;
+    using Packet = typename Self::PacketReturnType;
+    const int PacketSize = internal::unpacket_traits<Packet>::size;
+    const Index total_size = internal::array_prod(self.dimensions());
+    const Index inner_block_size = self.stride() * self.size();
+    bool parallelize_by_outer_blocks = (total_size >= (self.stride() * inner_block_size));
+
+    if ((parallelize_by_outer_blocks && total_size <= 4096) ||
+        (!parallelize_by_outer_blocks && self.stride() < PacketSize)) {
+      ScanLauncher<Self, Reducer, DefaultDevice, Vectorize> launcher;
+      launcher(self, data);
+      return;
+    }
+
+    if (parallelize_by_outer_blocks) {
+      // Parallelize over outer blocks.
+      const Index num_outer_blocks = total_size / inner_block_size;
+      self.device().parallelFor(
+          num_outer_blocks,
+          TensorOpCost(inner_block_size, inner_block_size, 16 * PacketSize * inner_block_size, Vectorize, PacketSize),
+          [=](Index blk_size) { return AdjustBlockSize(inner_block_size * sizeof(Scalar), blk_size); },
+          [&](Index first, Index last) {
+            for (Index idx1 = first; idx1 < last; ++idx1) {
+              ReduceBlock<Self, Vectorize, /*Parallel=*/false> block_reducer;
+              block_reducer(self, idx1 * inner_block_size, data);
+            }
+          });
+    } else {
+      // Parallelize over inner packets/scalars dimensions when the reduction
+      // axis is not an inner dimension.
+      ReduceBlock<Self, Vectorize, /*Parallel=*/true> block_reducer;
+      for (Index idx1 = 0; idx1 < total_size; idx1 += self.stride() * self.size()) {
+        block_reducer(self, idx1, data);
+      }
+    }
+  }
+};
+#endif  // EIGEN_USE_THREADS
+
+#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
+
+// GPU implementation of scan
+// TODO(ibab): This placeholder implementation performs multiple scans in
+// parallel, but it would be better to use a parallel scan algorithm and
+// optimize memory access.
+template <typename Self, typename Reducer>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ScanKernel(Self self, Index total_size,
+                                                        typename Self::CoeffReturnType* data) {
+  // Compute offset as in the CPU version
+  Index val = threadIdx.x + blockIdx.x * blockDim.x;
+  Index offset = (val / self.stride()) * self.stride() * self.size() + val % self.stride();
+
+  if (offset + (self.size() - 1) * self.stride() < total_size) {
+    // Compute the scan along the axis, starting at the calculated offset
+    typename Self::CoeffReturnType accum = self.accumulator().initialize();
+    for (Index idx = 0; idx < self.size(); idx++) {
+      Index curr = offset + idx * self.stride();
+      if (self.exclusive()) {
+        data[curr] = self.accumulator().finalize(accum);
+        self.accumulator().reduce(self.inner().coeff(curr), &accum);
+      } else {
+        self.accumulator().reduce(self.inner().coeff(curr), &accum);
+        data[curr] = self.accumulator().finalize(accum);
+      }
+    }
+  }
+  __syncthreads();
+}
+
+template <typename Self, typename Reducer, bool Vectorize>
+struct ScanLauncher<Self, Reducer, GpuDevice, Vectorize> {
+  void operator()(const Self& self, typename Self::CoeffReturnType* data) const {
+    Index total_size = internal::array_prod(self.dimensions());
+    Index num_blocks = (total_size / self.size() + 63) / 64;
+    Index block_size = 64;
+
+    LAUNCH_GPU_KERNEL((ScanKernel<Self, Reducer>), num_blocks, block_size, 0, self.device(), self, total_size, data);
+  }
+};
+#endif  // EIGEN_USE_GPU && (EIGEN_GPUCC)
+
+}  // namespace internal
+
+// Eval as rvalue
+template <typename Op, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorScanOp<Op, ArgType>, Device> {
+  typedef TensorScanOp<Op, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  typedef const ArgType ChildTypeNoConst;
+  typedef const ArgType ChildType;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  typedef TensorEvaluator<const TensorScanOp<Op, ArgType>, Device> Self;
+  typedef StorageMemory<Scalar, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    // Scan eagerly materializes its result into m_output; once that buffer
+    // exists, exposing block access is just a wrapper around it. Leave
+    // PreferBlockAccess false so the executor still uses the cheaper
+    // raw/packet paths by default; the flag matters only when an outer
+    // expression calls block() directly.
+    BlockAccess = (NumDims > 0),
+    PreferBlockAccess = false,
+    CoordAccess = false,
+    RawAccess = true
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef typename internal::TensorMaterializedBlock<Scalar, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device),
+        m_device(device),
+        m_exclusive(op.exclusive()),
+        m_accumulator(op.accumulator()),
+        m_size(m_impl.dimensions()[op.axis()]),
+        m_stride(1),
+        m_consume_dim(op.axis()),
+        m_output(nullptr) {
+    // Accumulating a scalar isn't supported.
+    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    eigen_assert(op.axis() >= 0 && op.axis() < NumDims);
+
+    // Compute stride of scan axis
+    const Dimensions& dims = m_impl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = 0; i < op.axis(); ++i) {
+        m_stride = m_stride * dims[i];
+      }
+    } else {
+      // dims can only be indexed through unsigned integers,
+      // so use an unsigned type to let the compiler know.
+      // This prevents spurious warnings: "'*((void*)(& evaluator)+64)[18446744073709551615]' may be used uninitialized
+      // in this function"
+      unsigned int axis = internal::convert_index<unsigned int>(op.axis());
+      for (unsigned int i = NumDims - 1; i > axis; --i) {
+        m_stride = m_stride * dims[i];
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index& stride() const { return m_stride; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index& consume_dim() const { return m_consume_dim; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index& size() const { return m_size; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Op& accumulator() const { return m_accumulator; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool exclusive() const { return m_exclusive; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorEvaluator<ArgType, Device>& inner() const { return m_impl; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Device& device() const { return m_device; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    internal::ScanLauncher<Self, Op, Device> launcher;
+    if (data) {
+      launcher(*this, data);
+      return false;
+    }
+
+    const Index total_size = internal::array_prod(dimensions());
+    m_output =
+        static_cast<EvaluatorPointerType>(m_device.get((Scalar*)m_device.allocate_temp(total_size * sizeof(Scalar))));
+    launcher(*this, m_output);
+    return true;
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
+    return internal::ploadt<PacketReturnType, LoadMode>(m_output + index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    return internal::TensorBlockResourceRequirements::any();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    eigen_assert(m_output != nullptr);
+    return TensorBlock::materialize(m_output, m_impl.dimensions(), desc, scratch);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return m_output; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_output[index]; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool) const {
+    return TensorOpCost(sizeof(CoeffReturnType), 0, 0);
+  }
+
+  EIGEN_STRONG_INLINE void cleanup() {
+    if (m_output) {
+      m_device.deallocate_temp(m_output);
+      m_output = nullptr;
+    }
+    m_impl.cleanup();
+  }
+
+ protected:
+  TensorEvaluator<ArgType, Device> m_impl;
+  const Device EIGEN_DEVICE_REF m_device;
+  const bool m_exclusive;
+  Op m_accumulator;
+  const Index m_size;
+  Index m_stride;
+  Index m_consume_dim;
+  EvaluatorPointerType m_output;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_SCAN_H
diff --git a/contrib/Eigen/src/Tensor/TensorScanSycl.h b/contrib/Eigen/src/Tensor/TensorScanSycl.h
new file mode 100644
index 0000000..a4ade6a
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorScanSycl.h
@@ -0,0 +1,508 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+/*****************************************************************
+ * TensorScanSycl.h
+ *
+ * \brief:
+ *  Tensor Scan Sycl implement the extend  version of
+ * "Efficient parallel scan algorithms for GPUs." .for Tensor operations.
+ * The algorithm requires up to 3 stage (consequently 3 kernels) depending on
+ * the size of the tensor. In the first kernel (ScanKernelFunctor), each
+ * threads within the work-group individually reduces the allocated elements per
+ * thread in order to reduces the total number of blocks. In the next step all
+ * thread within the work-group will reduce the associated blocks into the
+ * temporary buffers. In the next kernel(ScanBlockKernelFunctor), the temporary
+ * buffer is given as an input and all the threads within a work-group scan and
+ * reduces the boundaries between the blocks (generated from the previous
+ * kernel). and write the data on the temporary buffer. If the second kernel is
+ * required, the third and final kernel (ScanAdjustmentKernelFunctor) will
+ * adjust the final result into the output buffer.
+ * The original algorithm for the parallel prefix sum can be found here:
+ *
+ * Sengupta, Shubhabrata, Mark Harris, and Michael Garland. "Efficient parallel
+ * scan algorithms for GPUs." NVIDIA, Santa Clara, CA, Tech. Rep. NVR-2008-003
+ *1, no. 1 (2008): 1-17.
+ *****************************************************************/
+
+#ifndef UNSUPPORTED_EIGEN_SRC_TENSOR_TENSOR_SYCL_SYCL_HPP
+#define UNSUPPORTED_EIGEN_SRC_TENSOR_TENSOR_SYCL_SYCL_HPP
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace TensorSycl {
+namespace internal {
+
+#ifndef EIGEN_SYCL_MAX_GLOBAL_RANGE
+#define EIGEN_SYCL_MAX_GLOBAL_RANGE (EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1 * 4)
+#endif
+
+template <typename index_t>
+struct ScanParameters {
+  // must be power of 2
+  static constexpr index_t ScanPerThread = 8;
+  const index_t total_size;
+  const index_t non_scan_size;
+  const index_t scan_size;
+  const index_t non_scan_stride;
+  const index_t scan_stride;
+  const index_t panel_threads;
+  const index_t group_threads;
+  const index_t block_threads;
+  const index_t elements_per_group;
+  const index_t elements_per_block;
+  const index_t loop_range;
+
+  ScanParameters(index_t total_size_, index_t non_scan_size_, index_t scan_size_, index_t non_scan_stride_,
+                 index_t scan_stride_, index_t panel_threads_, index_t group_threads_, index_t block_threads_,
+                 index_t elements_per_group_, index_t elements_per_block_, index_t loop_range_)
+      : total_size(total_size_),
+        non_scan_size(non_scan_size_),
+        scan_size(scan_size_),
+        non_scan_stride(non_scan_stride_),
+        scan_stride(scan_stride_),
+        panel_threads(panel_threads_),
+        group_threads(group_threads_),
+        block_threads(block_threads_),
+        elements_per_group(elements_per_group_),
+        elements_per_block(elements_per_block_),
+        loop_range(loop_range_) {}
+};
+
+enum class scan_step { first, second };
+template <typename Evaluator, typename CoeffReturnType, typename OutAccessor, typename Op, typename Index,
+          scan_step stp>
+struct ScanKernelFunctor {
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      LocalAccessor;
+  static constexpr int PacketSize = ScanParameters<Index>::ScanPerThread / 2;
+
+  LocalAccessor scratch;
+  Evaluator dev_eval;
+  OutAccessor out_ptr;
+  OutAccessor tmp_ptr;
+  const ScanParameters<Index> scanParameters;
+  Op accumulator;
+  const bool inclusive;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ScanKernelFunctor(LocalAccessor scratch_, const Evaluator dev_eval_,
+                                                          OutAccessor out_accessor_, OutAccessor temp_accessor_,
+                                                          const ScanParameters<Index> scanParameters_, Op accumulator_,
+                                                          const bool inclusive_)
+      : scratch(scratch_),
+        dev_eval(dev_eval_),
+        out_ptr(out_accessor_),
+        tmp_ptr(temp_accessor_),
+        scanParameters(scanParameters_),
+        accumulator(accumulator_),
+        inclusive(inclusive_) {}
+
+  template <scan_step sst = stp, typename Input>
+  std::enable_if_t<sst == scan_step::first, CoeffReturnType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE read(
+      const Input &inpt, Index global_id) const {
+    return inpt.coeff(global_id);
+  }
+
+  template <scan_step sst = stp, typename Input>
+  std::enable_if_t<sst != scan_step::first, CoeffReturnType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE read(
+      const Input &inpt, Index global_id) const {
+    return inpt[global_id];
+  }
+
+  template <scan_step sst = stp, typename InclusiveOp>
+  std::enable_if_t<sst == scan_step::first> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE first_step_inclusive_Operation(
+      InclusiveOp inclusive_op) const {
+    inclusive_op();
+  }
+
+  template <scan_step sst = stp, typename InclusiveOp>
+  std::enable_if_t<sst != scan_step::first> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE first_step_inclusive_Operation(
+      InclusiveOp) const {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
+    for (Index loop_offset = 0; loop_offset < scanParameters.loop_range; loop_offset++) {
+      Index data_offset = itemID.get_global_id(0) + (itemID.get_global_range(0) * loop_offset);
+      Index tmp = data_offset % scanParameters.panel_threads;
+      const Index panel_id = data_offset / scanParameters.panel_threads;
+      const Index group_id = tmp / scanParameters.group_threads;
+      tmp = tmp % scanParameters.group_threads;
+      const Index block_id = tmp / scanParameters.block_threads;
+      const Index local_id = tmp % scanParameters.block_threads;
+      // we put one element per packet in scratch_mem
+      const Index scratch_stride = scanParameters.elements_per_block / PacketSize;
+      const Index scratch_offset = (itemID.get_local_id(0) / scanParameters.block_threads) * scratch_stride;
+      CoeffReturnType private_scan[ScanParameters<Index>::ScanPerThread];
+      CoeffReturnType inclusive_scan;
+      // the actual panel size is scan_size * non_scan_size.
+      // elements_per_panel is roundup to power of 2 for binary tree
+      const Index panel_offset = panel_id * scanParameters.scan_size * scanParameters.non_scan_size;
+      const Index group_offset = group_id * scanParameters.non_scan_stride;
+      // This will be effective when the size is bigger than elements_per_block
+      const Index block_offset = block_id * scanParameters.elements_per_block * scanParameters.scan_stride;
+      const Index thread_offset = ScanParameters<Index>::ScanPerThread * local_id * scanParameters.scan_stride;
+      const Index global_offset = panel_offset + group_offset + block_offset + thread_offset;
+      Index next_elements = 0;
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < ScanParameters<Index>::ScanPerThread; i++) {
+        Index global_id = global_offset + next_elements;
+        private_scan[i] = ((((block_id * scanParameters.elements_per_block) +
+                             (ScanParameters<Index>::ScanPerThread * local_id) + i) < scanParameters.scan_size) &&
+                           (global_id < scanParameters.total_size))
+                              ? read(dev_eval, global_id)
+                              : accumulator.initialize();
+        next_elements += scanParameters.scan_stride;
+      }
+      first_step_inclusive_Operation([&]() EIGEN_DEVICE_FUNC {
+        if (inclusive) {
+          inclusive_scan = private_scan[ScanParameters<Index>::ScanPerThread - 1];
+        }
+      });
+      // This for loop must be 2
+      EIGEN_UNROLL_LOOP
+      for (int packetIndex = 0; packetIndex < ScanParameters<Index>::ScanPerThread; packetIndex += PacketSize) {
+        Index private_offset = 1;
+        // build sum in place up the tree
+        EIGEN_UNROLL_LOOP
+        for (Index d = PacketSize >> 1; d > 0; d >>= 1) {
+          EIGEN_UNROLL_LOOP
+          for (Index l = 0; l < d; l++) {
+            Index ai = private_offset * (2 * l + 1) - 1 + packetIndex;
+            Index bi = private_offset * (2 * l + 2) - 1 + packetIndex;
+            CoeffReturnType accum = accumulator.initialize();
+            accumulator.reduce(private_scan[ai], &accum);
+            accumulator.reduce(private_scan[bi], &accum);
+            private_scan[bi] = accumulator.finalize(accum);
+          }
+          private_offset *= 2;
+        }
+        scratch[2 * local_id + (packetIndex / PacketSize) + scratch_offset] =
+            private_scan[PacketSize - 1 + packetIndex];
+        private_scan[PacketSize - 1 + packetIndex] = accumulator.initialize();
+        // traverse down tree & build scan
+        EIGEN_UNROLL_LOOP
+        for (Index d = 1; d < PacketSize; d *= 2) {
+          private_offset >>= 1;
+          EIGEN_UNROLL_LOOP
+          for (Index l = 0; l < d; l++) {
+            Index ai = private_offset * (2 * l + 1) - 1 + packetIndex;
+            Index bi = private_offset * (2 * l + 2) - 1 + packetIndex;
+            CoeffReturnType accum = accumulator.initialize();
+            accumulator.reduce(private_scan[ai], &accum);
+            accumulator.reduce(private_scan[bi], &accum);
+            private_scan[ai] = private_scan[bi];
+            private_scan[bi] = accumulator.finalize(accum);
+          }
+        }
+      }
+
+      Index offset = 1;
+      // build sum in place up the tree
+      for (Index d = scratch_stride >> 1; d > 0; d >>= 1) {
+        // Synchronise
+        itemID.barrier(cl::sycl::access::fence_space::local_space);
+        if (local_id < d) {
+          Index ai = offset * (2 * local_id + 1) - 1 + scratch_offset;
+          Index bi = offset * (2 * local_id + 2) - 1 + scratch_offset;
+          CoeffReturnType accum = accumulator.initialize();
+          accumulator.reduce(scratch[ai], &accum);
+          accumulator.reduce(scratch[bi], &accum);
+          scratch[bi] = accumulator.finalize(accum);
+        }
+        offset *= 2;
+      }
+      // Synchronise
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+      // next step optimisation
+      if (local_id == 0) {
+        if ((scanParameters.elements_per_group / scanParameters.elements_per_block) > 1) {
+          const Index temp_id = panel_id * (scanParameters.elements_per_group / scanParameters.elements_per_block) *
+                                    scanParameters.non_scan_size +
+                                group_id * (scanParameters.elements_per_group / scanParameters.elements_per_block) +
+                                block_id;
+          tmp_ptr[temp_id] = scratch[scratch_stride - 1 + scratch_offset];
+        }
+        // clear the last element
+        scratch[scratch_stride - 1 + scratch_offset] = accumulator.initialize();
+      }
+      // traverse down tree & build scan
+      for (Index d = 1; d < scratch_stride; d *= 2) {
+        offset >>= 1;
+        // Synchronise
+        itemID.barrier(cl::sycl::access::fence_space::local_space);
+        if (local_id < d) {
+          Index ai = offset * (2 * local_id + 1) - 1 + scratch_offset;
+          Index bi = offset * (2 * local_id + 2) - 1 + scratch_offset;
+          CoeffReturnType accum = accumulator.initialize();
+          accumulator.reduce(scratch[ai], &accum);
+          accumulator.reduce(scratch[bi], &accum);
+          scratch[ai] = scratch[bi];
+          scratch[bi] = accumulator.finalize(accum);
+        }
+      }
+      // Synchronise
+      itemID.barrier(cl::sycl::access::fence_space::local_space);
+      // This for loop must be 2
+      EIGEN_UNROLL_LOOP
+      for (int packetIndex = 0; packetIndex < ScanParameters<Index>::ScanPerThread; packetIndex += PacketSize) {
+        EIGEN_UNROLL_LOOP
+        for (Index i = 0; i < PacketSize; i++) {
+          CoeffReturnType accum = private_scan[packetIndex + i];
+          accumulator.reduce(scratch[2 * local_id + (packetIndex / PacketSize) + scratch_offset], &accum);
+          private_scan[packetIndex + i] = accumulator.finalize(accum);
+        }
+      }
+      first_step_inclusive_Operation([&]() EIGEN_DEVICE_FUNC {
+        if (inclusive) {
+          accumulator.reduce(private_scan[ScanParameters<Index>::ScanPerThread - 1], &inclusive_scan);
+          private_scan[0] = accumulator.finalize(inclusive_scan);
+        }
+      });
+      next_elements = 0;
+      // Write the first set of private params.
+      EIGEN_UNROLL_LOOP
+      for (Index i = 0; i < ScanParameters<Index>::ScanPerThread; i++) {
+        Index global_id = global_offset + next_elements;
+        if ((((block_id * scanParameters.elements_per_block) + (ScanParameters<Index>::ScanPerThread * local_id) + i) <
+             scanParameters.scan_size) &&
+            (global_id < scanParameters.total_size)) {
+          Index private_id = (i * !inclusive) + (((i + 1) % ScanParameters<Index>::ScanPerThread) * (inclusive));
+          out_ptr[global_id] = private_scan[private_id];
+        }
+        next_elements += scanParameters.scan_stride;
+      }
+    }  // end for loop
+  }
+};
+
+template <typename CoeffReturnType, typename InAccessor, typename OutAccessor, typename Op, typename Index>
+struct ScanAdjustmentKernelFunctor {
+  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
+      LocalAccessor;
+  static constexpr int PacketSize = ScanParameters<Index>::ScanPerThread / 2;
+  InAccessor in_ptr;
+  OutAccessor out_ptr;
+  const ScanParameters<Index> scanParameters;
+  Op accumulator;
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ScanAdjustmentKernelFunctor(LocalAccessor, InAccessor in_accessor_,
+                                                                    OutAccessor out_accessor_,
+                                                                    const ScanParameters<Index> scanParameters_,
+                                                                    Op accumulator_)
+      : in_ptr(in_accessor_), out_ptr(out_accessor_), scanParameters(scanParameters_), accumulator(accumulator_) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
+    for (Index loop_offset = 0; loop_offset < scanParameters.loop_range; loop_offset++) {
+      Index data_offset = itemID.get_global_id(0) + (itemID.get_global_range(0) * loop_offset);
+      Index tmp = data_offset % scanParameters.panel_threads;
+      const Index panel_id = data_offset / scanParameters.panel_threads;
+      const Index group_id = tmp / scanParameters.group_threads;
+      tmp = tmp % scanParameters.group_threads;
+      const Index block_id = tmp / scanParameters.block_threads;
+      const Index local_id = tmp % scanParameters.block_threads;
+
+      // the actual panel size is scan_size * non_scan_size.
+      // elements_per_panel is roundup to power of 2 for binary tree
+      const Index panel_offset = panel_id * scanParameters.scan_size * scanParameters.non_scan_size;
+      const Index group_offset = group_id * scanParameters.non_scan_stride;
+      // This will be effective when the size is bigger than elements_per_block
+      const Index block_offset = block_id * scanParameters.elements_per_block * scanParameters.scan_stride;
+      const Index thread_offset = ScanParameters<Index>::ScanPerThread * local_id * scanParameters.scan_stride;
+
+      const Index global_offset = panel_offset + group_offset + block_offset + thread_offset;
+      const Index block_size = scanParameters.elements_per_group / scanParameters.elements_per_block;
+      const Index in_id = (panel_id * block_size * scanParameters.non_scan_size) + (group_id * block_size) + block_id;
+      CoeffReturnType adjust_val = in_ptr[in_id];
+
+      Index next_elements = 0;
+      EIGEN_UNROLL_LOOP
+      for (Index i = 0; i < ScanParameters<Index>::ScanPerThread; i++) {
+        Index global_id = global_offset + next_elements;
+        if ((((block_id * scanParameters.elements_per_block) + (ScanParameters<Index>::ScanPerThread * local_id) + i) <
+             scanParameters.scan_size) &&
+            (global_id < scanParameters.total_size)) {
+          CoeffReturnType accum = adjust_val;
+          accumulator.reduce(out_ptr[global_id], &accum);
+          out_ptr[global_id] = accumulator.finalize(accum);
+        }
+        next_elements += scanParameters.scan_stride;
+      }
+    }
+  }
+};
+
+template <typename Index>
+struct ScanInfo {
+  const Index &total_size;
+  const Index &scan_size;
+  const Index &panel_size;
+  const Index &non_scan_size;
+  const Index &scan_stride;
+  const Index &non_scan_stride;
+
+  Index max_elements_per_block;
+  Index block_size;
+  Index panel_threads;
+  Index group_threads;
+  Index block_threads;
+  Index elements_per_group;
+  Index elements_per_block;
+  Index loop_range;
+  Index global_range;
+  Index local_range;
+  const Eigen::SyclDevice &dev;
+  EIGEN_STRONG_INLINE ScanInfo(const Index &total_size_, const Index &scan_size_, const Index &panel_size_,
+                               const Index &non_scan_size_, const Index &scan_stride_, const Index &non_scan_stride_,
+                               const Eigen::SyclDevice &dev_)
+      : total_size(total_size_),
+        scan_size(scan_size_),
+        panel_size(panel_size_),
+        non_scan_size(non_scan_size_),
+        scan_stride(scan_stride_),
+        non_scan_stride(non_scan_stride_),
+        dev(dev_) {
+    // must be power of 2
+    local_range = std::min(Index(dev.getNearestPowerOfTwoWorkGroupSize()),
+                           Index(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1));
+
+    max_elements_per_block = local_range * ScanParameters<Index>::ScanPerThread;
+
+    elements_per_group =
+        dev.getPowerOfTwo(Index(roundUp(Index(scan_size), ScanParameters<Index>::ScanPerThread)), true);
+    const Index elements_per_panel = elements_per_group * non_scan_size;
+    elements_per_block = std::min(Index(elements_per_group), Index(max_elements_per_block));
+    panel_threads = elements_per_panel / ScanParameters<Index>::ScanPerThread;
+    group_threads = elements_per_group / ScanParameters<Index>::ScanPerThread;
+    block_threads = elements_per_block / ScanParameters<Index>::ScanPerThread;
+    block_size = elements_per_group / elements_per_block;
+#ifdef EIGEN_SYCL_MAX_GLOBAL_RANGE
+    const Index max_threads = std::min(Index(panel_threads * panel_size), Index(EIGEN_SYCL_MAX_GLOBAL_RANGE));
+#else
+    const Index max_threads = panel_threads * panel_size;
+#endif
+    global_range = roundUp(max_threads, local_range);
+    loop_range = Index(
+        numext::ceil(double(elements_per_panel * panel_size) / (global_range * ScanParameters<Index>::ScanPerThread)));
+  }
+  inline ScanParameters<Index> get_scan_parameter() {
+    return ScanParameters<Index>(total_size, non_scan_size, scan_size, non_scan_stride, scan_stride, panel_threads,
+                                 group_threads, block_threads, elements_per_group, elements_per_block, loop_range);
+  }
+  inline cl::sycl::nd_range<1> get_thread_range() {
+    return cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
+  }
+};
+
+template <typename EvaluatorPointerType, typename CoeffReturnType, typename Reducer, typename Index>
+struct SYCLAdjustBlockOffset {
+  EIGEN_STRONG_INLINE static void adjust_scan_block_offset(EvaluatorPointerType in_ptr, EvaluatorPointerType out_ptr,
+                                                           Reducer &accumulator, const Index total_size,
+                                                           const Index scan_size, const Index panel_size,
+                                                           const Index non_scan_size, const Index scan_stride,
+                                                           const Index non_scan_stride, const Eigen::SyclDevice &dev) {
+    auto scan_info =
+        ScanInfo<Index>(total_size, scan_size, panel_size, non_scan_size, scan_stride, non_scan_stride, dev);
+
+    typedef ScanAdjustmentKernelFunctor<CoeffReturnType, EvaluatorPointerType, EvaluatorPointerType, Reducer, Index>
+        AdjustFuctor;
+    dev.template unary_kernel_launcher<CoeffReturnType, AdjustFuctor>(in_ptr, out_ptr, scan_info.get_thread_range(),
+                                                                      scan_info.max_elements_per_block,
+                                                                      scan_info.get_scan_parameter(), accumulator)
+        .wait();
+  }
+};
+
+template <typename CoeffReturnType, scan_step stp>
+struct ScanLauncher_impl {
+  template <typename Input, typename EvaluatorPointerType, typename Reducer, typename Index>
+  EIGEN_STRONG_INLINE static void scan_block(Input in_ptr, EvaluatorPointerType out_ptr, Reducer &accumulator,
+                                             const Index total_size, const Index scan_size, const Index panel_size,
+                                             const Index non_scan_size, const Index scan_stride,
+                                             const Index non_scan_stride, const bool inclusive,
+                                             const Eigen::SyclDevice &dev) {
+    auto scan_info =
+        ScanInfo<Index>(total_size, scan_size, panel_size, non_scan_size, scan_stride, non_scan_stride, dev);
+    const Index temp_pointer_size = scan_info.block_size * non_scan_size * panel_size;
+    const Index scratch_size = scan_info.max_elements_per_block / (ScanParameters<Index>::ScanPerThread / 2);
+    CoeffReturnType *temp_pointer =
+        static_cast<CoeffReturnType *>(dev.allocate_temp(temp_pointer_size * sizeof(CoeffReturnType)));
+    EvaluatorPointerType tmp_global_accessor = dev.get(temp_pointer);
+
+    typedef ScanKernelFunctor<Input, CoeffReturnType, EvaluatorPointerType, Reducer, Index, stp> ScanFunctor;
+    dev.template binary_kernel_launcher<CoeffReturnType, ScanFunctor>(
+           in_ptr, out_ptr, tmp_global_accessor, scan_info.get_thread_range(), scratch_size,
+           scan_info.get_scan_parameter(), accumulator, inclusive)
+        .wait();
+
+    if (scan_info.block_size > 1) {
+      ScanLauncher_impl<CoeffReturnType, scan_step::second>::scan_block(
+          tmp_global_accessor, tmp_global_accessor, accumulator, temp_pointer_size, scan_info.block_size, panel_size,
+          non_scan_size, Index(1), scan_info.block_size, false, dev);
+
+      SYCLAdjustBlockOffset<EvaluatorPointerType, CoeffReturnType, Reducer, Index>::adjust_scan_block_offset(
+          tmp_global_accessor, out_ptr, accumulator, total_size, scan_size, panel_size, non_scan_size, scan_stride,
+          non_scan_stride, dev);
+    }
+    dev.deallocate_temp(temp_pointer);
+  }
+};
+
+}  // namespace internal
+}  // namespace TensorSycl
+namespace internal {
+template <typename Self, typename Reducer, bool vectorize>
+struct ScanLauncher<Self, Reducer, Eigen::SyclDevice, vectorize> {
+  typedef typename Self::Index Index;
+  typedef typename Self::CoeffReturnType CoeffReturnType;
+  typedef typename Self::Storage Storage;
+  typedef typename Self::EvaluatorPointerType EvaluatorPointerType;
+  void operator()(Self &self, EvaluatorPointerType data) const {
+    const Index total_size = internal::array_prod(self.dimensions());
+    const Index scan_size = self.size();
+    const Index scan_stride = self.stride();
+    // this is the scan op (can be sum or ...)
+    auto accumulator = self.accumulator();
+    auto inclusive = !self.exclusive();
+    auto consume_dim = self.consume_dim();
+    auto dev = self.device();
+
+    auto dims = self.inner().dimensions();
+
+    Index non_scan_size = 1;
+    Index panel_size = 1;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Self::Layout) == static_cast<int>(ColMajor)) {
+      for (int i = 0; i < consume_dim; i++) {
+        non_scan_size *= dims[i];
+      }
+      for (int i = consume_dim + 1; i < Self::NumDims; i++) {
+        panel_size *= dims[i];
+      }
+    } else {
+      for (int i = Self::NumDims - 1; i > consume_dim; i--) {
+        non_scan_size *= dims[i];
+      }
+      for (int i = consume_dim - 1; i >= 0; i--) {
+        panel_size *= dims[i];
+      }
+    }
+    const Index non_scan_stride = (scan_stride > 1) ? 1 : scan_size;
+    auto eval_impl = self.inner();
+    TensorSycl::internal::ScanLauncher_impl<CoeffReturnType, TensorSycl::internal::scan_step::first>::scan_block(
+        eval_impl, data, accumulator, total_size, scan_size, panel_size, non_scan_size, scan_stride, non_scan_stride,
+        inclusive, dev);
+  }
+};
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // UNSUPPORTED_EIGEN_SRC_TENSOR_TENSOR_SYCL_SYCL_HPP
diff --git a/contrib/Eigen/src/Tensor/TensorShuffling.h b/contrib/Eigen/src/Tensor/TensorShuffling.h
new file mode 100644
index 0000000..8c203e7
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorShuffling.h
@@ -0,0 +1,511 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_SHUFFLING_H
+#define EIGEN_TENSOR_TENSOR_SHUFFLING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Shuffle, typename XprType>
+struct traits<TensorShufflingOp<Shuffle, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename Shuffle, typename XprType>
+struct eval<TensorShufflingOp<Shuffle, XprType>, Eigen::Dense> {
+  typedef const TensorShufflingOp<Shuffle, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor shuffling class.
+ */
+template <typename Shuffle, typename XprType>
+class TensorShufflingOp : public TensorBase<TensorShufflingOp<Shuffle, XprType> > {
+ public:
+  typedef TensorBase<TensorShufflingOp<Shuffle, XprType> > Base;
+  typedef typename Eigen::internal::traits<TensorShufflingOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorShufflingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorShufflingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorShufflingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorShufflingOp(const XprType& expr, const Shuffle& shfl)
+      : m_xpr(expr), m_shuffle(shfl) {}
+
+  EIGEN_DEVICE_FUNC const Shuffle& shufflePermutation() const { return m_shuffle; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorShufflingOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Shuffle m_shuffle;
+};
+
+// Eval as rvalue
+template <typename Shuffle, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> Self;
+  typedef TensorShufflingOp<Shuffle, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    PreferBlockAccess = true,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+
+  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_device(device), m_impl(op.expression(), device) {
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    const Shuffle& shuffle = op.shufflePermutation();
+    m_is_identity = true;
+    for (int i = 0; i < NumDims; ++i) {
+      m_shuffle[i] = static_cast<int>(shuffle[i]);
+      m_dimensions[i] = input_dims[shuffle[i]];
+      m_inverseShuffle[shuffle[i]] = i;
+      if (m_is_identity && shuffle[i] != i) {
+        m_is_identity = false;
+      }
+    }
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_unshuffledInputStrides[0] = 1;
+      m_outputStrides[0] = 1;
+
+      for (int i = 1; i < NumDims; ++i) {
+        m_unshuffledInputStrides[i] = m_unshuffledInputStrides[i - 1] * input_dims[i - 1];
+        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+        m_fastOutputStrides[i] =
+            internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : Index(1));
+      }
+    } else {
+      m_unshuffledInputStrides[NumDims - 1] = 1;
+      m_outputStrides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_unshuffledInputStrides[i] = m_unshuffledInputStrides[i + 1] * input_dims[i + 1];
+        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+        m_fastOutputStrides[i] =
+            internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : Index(1));
+      }
+    }
+
+    for (int i = 0; i < NumDims; ++i) {
+      m_inputStrides[i] = m_unshuffledInputStrides[shuffle[i]];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    if (m_is_identity) {
+      return m_impl.coeff(index);
+    } else {
+      return m_impl.coeff(srcCoeff(index));
+    }
+  }
+
+  // Assembles a packet whose elements all lie in one inner-most run of the
+  // output: the input indices form an arithmetic progression starting at
+  // `base` with step `inner_stride`, so the index mapping is computed once
+  // per packet instead of once per coefficient.
+  template <int LoadMode, typename Self, bool ImplPacketAccess>
+  struct InnerRunLoader {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType Run(const Self& self, Index base,
+                                                                      Index inner_stride) {
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < PacketSize; ++i) {
+        values[i] = self.m_impl.coeff(base + i * inner_stride);
+      }
+      return internal::pload<PacketReturnType>(values);
+    }
+  };
+
+  template <int LoadMode, typename Self>
+  struct InnerRunLoader<LoadMode, Self, true> {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType Run(const Self& self, Index base,
+                                                                      Index inner_stride) {
+      if (inner_stride == 1) {
+        // Inner dimension not shuffled: one contiguous load.
+        return self.m_impl.template packet<Unaligned>(base);
+      }
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < PacketSize; ++i) {
+        values[i] = self.m_impl.coeff(base + i * inner_stride);
+      }
+      return internal::pload<PacketReturnType>(values);
+    }
+  };
+
+  template <int LoadMode, typename Self, bool ImplPacketAccess>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType LoadPacketViaInnerRun(const Self& self, Index index) {
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    Index inner_pos;
+    const Index base = self.srcCoeffInner(index, inner_pos);
+    if (inner_pos + PacketSize <= self.m_dimensions[inner_dim]) {
+      return InnerRunLoader<LoadMode, Self, ImplPacketAccess>::Run(self, base, self.m_inputStrides[inner_dim]);
+    }
+
+    // The packet crosses an inner-run boundary: assemble it scalar by scalar.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = self.coeff(index + i);
+    }
+    return internal::pload<PacketReturnType>(values);
+  }
+
+  template <int LoadMode, typename Self, bool ImplPacketAccess>
+  struct PacketLoader {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType Run(const Self& self, Index index) {
+      if (self.m_is_identity) {
+        EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+        std::remove_const_t<CoeffReturnType> values[PacketSize];
+        EIGEN_UNROLL_LOOP
+        for (int i = 0; i < PacketSize; ++i) {
+          values[i] = self.m_impl.coeff(index + i);
+        }
+        return internal::pload<PacketReturnType>(values);
+      }
+      return LoadPacketViaInnerRun<LoadMode, Self, ImplPacketAccess>(self, index);
+    }
+  };
+
+  template <int LoadMode, typename Self>
+  struct PacketLoader<LoadMode, Self, true> {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType Run(const Self& self, Index index) {
+      if (self.m_is_identity) {
+        return self.m_impl.template packet<LoadMode>(index);
+      }
+      return LoadPacketViaInnerRun<LoadMode, Self, true>(self, index);
+    }
+  };
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+    return PacketLoader<LoadMode, Self, TensorEvaluator<ArgType, Device>::PacketAccess>::Run(*this, index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    static constexpr int inner_dim = Layout == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
+
+    const size_t target_size = m_device.firstLevelCacheSize();
+    const bool inner_dim_shuffled = m_shuffle[inner_dim] != inner_dim;
+
+    // Shuffled inner dimensions lead to a random memory access, which is not
+    // captured by default cost model bytes loaded/stored. We add this cost
+    // explicitly. The number of cycles was picked based on the benchmarks.
+    // TODO(ezhulenev): This number was picked based on very questionable
+    // benchmarks, add benchmarks that are representative of real workloads.
+    using BlockRequirements = internal::TensorBlockResourceRequirements;
+    if (inner_dim_shuffled) {
+      return BlockRequirements::uniform<Scalar>(target_size).addCostPerCoeff({0, 0, NumDims * 28});
+    } else {
+      return BlockRequirements::skewed<Scalar>(target_size);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool root_of_expr_ast = false) const {
+    eigen_assert(m_impl.data() != nullptr);
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+
+    const typename TensorBlock::Storage block_storage =
+        TensorBlock::prepareStorage(desc, scratch, /*allow_strided_storage=*/root_of_expr_ast);
+
+    typename TensorBlockIO::Dimensions input_strides(m_unshuffledInputStrides);
+    TensorBlockIOSrc src(input_strides, m_impl.data(), srcCoeff(desc.offset()));
+
+    TensorBlockIODst dst(block_storage.dimensions(), block_storage.strides(), block_storage.data());
+
+    typename TensorBlockIO::DimensionsMap dst_to_src_dim_map(m_shuffle);
+    TensorBlockIO::Copy(dst, src, dst_to_src_dim_map);
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost = m_is_identity
+                                    ? TensorOpCost::AddCost<Index>()
+                                    : NumDims * (2 * TensorOpCost::AddCost<Index>() +
+                                                 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
+    return m_impl.costPerCoeff(vectorized) +
+           TensorOpCost(0, 0, compute_cost, m_is_identity /* vectorized */, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return nullptr; }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index
+  GetBlockOutputIndex(Index input_index, const DSizes<Index, NumDims>& input_block_strides,
+                      const DSizes<Index, NumDims>& output_block_strides,
+                      const DSizes<internal::TensorIntDivisor<Index>, NumDims>& fast_input_block_strides) const {
+    Index output_index = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = input_index / fast_input_block_strides[i];
+        output_index += idx * output_block_strides[m_inverseShuffle[i]];
+        input_index -= idx * input_block_strides[i];
+      }
+      return output_index + input_index * output_block_strides[m_inverseShuffle[0]];
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = input_index / fast_input_block_strides[i];
+        output_index += idx * output_block_strides[m_inverseShuffle[i]];
+        input_index -= idx * input_block_strides[i];
+      }
+      return output_index + input_index * output_block_strides[m_inverseShuffle[NumDims - 1]];
+    }
+  }
+
+  // Computes the input index of output index `index` and, as a by-product of
+  // the same fast-divisor walk, the output's inner-dimension coordinate. The
+  // packet paths use the latter to test whether a whole packet stays inside
+  // one inner-most run without spending an extra division on it.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeffInner(Index index, Index& inner_pos) const {
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_fastOutputStrides[i];
+        inputIndex += idx * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inner_pos = index;
+      return inputIndex + index * m_inputStrides[0];
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_fastOutputStrides[i];
+        inputIndex += idx * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inner_pos = index;
+      return inputIndex + index * m_inputStrides[NumDims - 1];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
+    Index inner_pos;
+    return srcCoeffInner(index, inner_pos);
+  }
+
+  Dimensions m_dimensions;
+  bool m_is_identity;
+  array<int, NumDims> m_shuffle;
+  array<Index, NumDims> m_inverseShuffle;  // TODO(ezhulenev): Make it int type.
+  array<Index, NumDims> m_outputStrides;
+  array<internal::TensorIntDivisor<Index>, NumDims> m_fastOutputStrides;
+  array<Index, NumDims> m_inputStrides;
+  array<Index, NumDims> m_unshuffledInputStrides;
+
+  const Device EIGEN_DEVICE_REF m_device;
+  TensorEvaluator<ArgType, Device> m_impl;
+};
+
+// Eval as lvalue
+template <typename Shuffle, typename ArgType, typename Device>
+struct TensorEvaluator<TensorShufflingOp<Shuffle, ArgType>, Device>
+    : public TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> {
+  typedef TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> Base;
+
+  typedef TensorShufflingOp<Shuffle, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+
+  enum {
+    IsAligned = false,
+    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
+    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
+    PreferBlockAccess = true,
+    RawAccess = false
+  };
+
+  typedef std::remove_const_t<Scalar> ScalarNoConst;
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
+    return this->m_impl.coeffRef(this->srcCoeff(index));
+  }
+
+  // Contiguous store into an unshuffled inner run; only instantiated when the
+  // nested evaluator has packet access.
+  template <int StoreMode, typename Self, bool ImplPacketAccess>
+  struct InnerRunWriter {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static bool Run(const Self&, Index, const PacketReturnType&) { return false; }
+  };
+
+  template <int StoreMode, typename Self>
+  struct InnerRunWriter<StoreMode, Self, true> {
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static bool Run(const Self& self, Index base, const PacketReturnType& x) {
+      self.m_impl.template writePacket<Unaligned>(base, x);
+      return true;
+    }
+  };
+
+  template <int StoreMode>
+  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    typedef TensorEvaluator<TensorShufflingOp<Shuffle, ArgType>, Device> Self;
+    constexpr bool ImplPacketAccess = bool(TensorEvaluator<ArgType, Device>::PacketAccess);
+
+    // Mirrors the rvalue PacketLoader: within one inner-most run the target
+    // input indices form an arithmetic progression, so the index mapping is
+    // computed once per packet; an unshuffled inner dimension becomes a
+    // single contiguous store.
+    constexpr int inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+    Index inner_pos;
+    const Index base = this->srcCoeffInner(index, inner_pos);
+    if (inner_pos + PacketSize <= this->m_dimensions[inner_dim]) {
+      const Index inner_stride = this->m_inputStrides[inner_dim];
+      if (inner_stride == 1 && InnerRunWriter<StoreMode, Self, ImplPacketAccess>::Run(*this, base, x)) {
+        return;
+      }
+      EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+      std::remove_const_t<CoeffReturnType> values[PacketSize];
+      internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < PacketSize; ++i) {
+        this->m_impl.coeffRef(base + i * inner_stride) = values[i];
+      }
+      return;
+    }
+
+    // The packet crosses an inner-run boundary: scatter scalar by scalar.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      this->coeffRef(index + i) = values[i];
+    }
+  }
+
+  template <typename TensorBlock>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
+    eigen_assert(this->m_impl.data() != nullptr);
+
+    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
+    typedef typename TensorBlockIO::Dst TensorBlockIODst;
+    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
+
+    const Scalar* block_buffer = block.data();
+
+    // TODO(ezhulenev): TensorBlockIO should be able to read from any Eigen
+    // expression with coefficient and packet access as `src`.
+    void* mem = nullptr;
+    if (block_buffer == nullptr) {
+      mem = this->m_device.allocate(desc.size() * sizeof(Scalar));
+      ScalarNoConst* buf = static_cast<ScalarNoConst*>(mem);
+
+      typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename TensorBlock::XprType, Index>
+          TensorBlockAssignment;
+
+      TensorBlockAssignment::Run(
+          TensorBlockAssignment::target(desc.dimensions(), internal::strides<Layout>(desc.dimensions()), buf),
+          block.expr());
+
+      block_buffer = buf;
+    }
+
+    // Read from block.
+    TensorBlockIOSrc src(internal::strides<Layout>(desc.dimensions()), block_buffer);
+
+    // Write to the output buffer.
+    typename TensorBlockIO::Dimensions output_strides(this->m_unshuffledInputStrides);
+    typename TensorBlockIO::Dimensions output_dimensions;
+    for (int i = 0; i < NumDims; ++i) {
+      output_dimensions[this->m_shuffle[i]] = desc.dimension(i);
+    }
+    TensorBlockIODst dst(output_dimensions, output_strides, this->m_impl.data(), this->srcCoeff(desc.offset()));
+
+    // Reorder dimensions according to the shuffle.
+    typename TensorBlockIO::DimensionsMap dst_to_src_dim_map;
+    for (int i = 0; i < NumDims; ++i) {
+      dst_to_src_dim_map[i] = static_cast<int>(this->m_inverseShuffle[i]);
+    }
+    TensorBlockIO::Copy(dst, src, dst_to_src_dim_map);
+
+    // Deallocate temporary buffer used for the block materialization.
+    if (mem != nullptr) this->m_device.deallocate(mem);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_SHUFFLING_H
diff --git a/contrib/Eigen/src/Tensor/TensorStorage.h b/contrib/Eigen/src/Tensor/TensorStorage.h
new file mode 100644
index 0000000..5d9192a
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorStorage.h
@@ -0,0 +1,144 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+// Copyright (C) 2014-2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSORSTORAGE_H
+#define EIGEN_TENSOR_TENSORSTORAGE_H
+
+#ifdef EIGEN_TENSOR_STORAGE_CTOR_PLUGIN
+#define EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN EIGEN_TENSOR_STORAGE_CTOR_PLUGIN;
+#else
+#define EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN
+#endif
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+/** \internal
+ *
+ * \ingroup Tensor_Module
+ *
+ * \brief Stores the data of a tensor
+ *
+ * This class stores the data of fixed-size, dynamic-size or mixed tensors
+ * in a way as compact as possible.
+ *
+ * \sa Tensor
+ */
+template <typename T, typename Dimensions, int Options>
+class TensorStorage;
+
+// Pure fixed-size storage
+template <typename T, typename FixedDimensions, int Options_>
+class TensorStorage {
+ private:
+  static constexpr std::size_t Size = FixedDimensions::total_size;
+
+  // Allocate an array of size at least one to prevent compiler warnings.
+  static constexpr std::size_t MinSize = max_n_1<Size>::size;
+  EIGEN_ALIGN_MAX T m_data[MinSize];
+
+ public:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorStorage() {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* data() { return m_data; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T* data() const { return m_data; }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const FixedDimensions dimensions() const { return FixedDimensions(); }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex size() const { return Size; }
+};
+
+// pure dynamic
+template <typename T, typename IndexType, int NumIndices_, int Options_>
+class TensorStorage<T, DSizes<IndexType, NumIndices_>, Options_> {
+ public:
+  typedef IndexType Index;
+  typedef DSizes<IndexType, NumIndices_> Dimensions;
+  typedef TensorStorage<T, DSizes<IndexType, NumIndices_>, Options_> Self;
+
+  EIGEN_DEVICE_FUNC TensorStorage() : m_data(0), m_dimensions() {
+    EIGEN_IF_CONSTEXPR (NumIndices_ == 0) {
+      m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(1);
+    }
+  }
+  EIGEN_DEVICE_FUNC TensorStorage(Index size, const array<Index, NumIndices_>& dimensions)
+      : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size)), m_dimensions(dimensions) {
+    EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN
+  }
+
+  template <typename... DenseIndex>
+  EIGEN_DEVICE_FUNC TensorStorage(DenseIndex... indices) : m_dimensions(indices...) {
+    m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(internal::array_prod(m_dimensions));
+  }
+
+  EIGEN_DEVICE_FUNC TensorStorage(const Self& other)
+      : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(
+            internal::array_prod(other.m_dimensions))),
+        m_dimensions(other.m_dimensions) {
+    internal::smart_copy(other.m_data, other.m_data + internal::array_prod(other.m_dimensions), m_data);
+  }
+  EIGEN_DEVICE_FUNC Self& operator=(const Self& other) {
+    if (this != &other) {
+      Self tmp(other);
+      this->swap(tmp);
+    }
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC TensorStorage(Self&& other) : TensorStorage() { *this = std::move(other); }
+
+  EIGEN_DEVICE_FUNC Self& operator=(Self&& other) {
+    numext::swap(m_data, other.m_data);
+    numext::swap(m_dimensions, other.m_dimensions);
+    return *this;
+  }
+
+  EIGEN_DEVICE_FUNC ~TensorStorage() {
+    internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data,
+                                                                              internal::array_prod(m_dimensions));
+  }
+  EIGEN_DEVICE_FUNC void swap(Self& other) {
+    numext::swap(m_data, other.m_data);
+    numext::swap(m_dimensions, other.m_dimensions);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_DEVICE_FUNC void resize(Index size, const array<Index, NumIndices_>& nbDimensions) {
+    const Index currentSz = internal::array_prod(m_dimensions);
+    if (size != currentSz) {
+      internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, currentSz);
+      if (size)
+        m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size);
+      else EIGEN_IF_CONSTEXPR (NumIndices_ == 0) {
+        m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(1);
+      } else
+        m_data = 0;
+      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
+    }
+    m_dimensions = nbDimensions;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* data() { return m_data; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T* data() const { return m_data; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_dimensions.TotalSize(); }
+
+ private:
+  T* m_data;
+  Dimensions m_dimensions;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSORSTORAGE_H
diff --git a/contrib/Eigen/src/Tensor/TensorStriding.h b/contrib/Eigen/src/Tensor/TensorStriding.h
new file mode 100644
index 0000000..2433974
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorStriding.h
@@ -0,0 +1,342 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_STRIDING_H
+#define EIGEN_TENSOR_TENSOR_STRIDING_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Strides, typename XprType>
+struct traits<TensorStridingOp<Strides, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <typename Strides, typename XprType>
+struct eval<TensorStridingOp<Strides, XprType>, Eigen::Dense> {
+  typedef const TensorStridingOp<Strides, XprType> EIGEN_DEVICE_REF type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor striding class.
+ */
+template <typename Strides, typename XprType>
+class TensorStridingOp : public TensorBase<TensorStridingOp<Strides, XprType> > {
+ public:
+  typedef TensorBase<TensorStridingOp<Strides, XprType> > Base;
+  typedef typename Eigen::internal::traits<TensorStridingOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorStridingOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorStridingOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorStridingOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorStridingOp(const XprType& expr, const Strides& dims)
+      : m_xpr(expr), m_dims(dims) {}
+
+  EIGEN_DEVICE_FUNC const Strides& strides() const { return m_dims; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+  EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TensorStridingOp)
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Strides m_dims;
+};
+
+// Eval as rvalue
+template <typename Strides, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorStridingOp<Strides, ArgType>, Device> {
+  typedef TensorStridingOp<Strides, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  // Inner-most dimension in storage order: the one a packet runs along.
+  static constexpr int kInnerDim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumDims - 1;
+  // Tag selecting whether the argument can be asked for whole packets.
+  typedef std::integral_constant<bool, TensorEvaluator<ArgType, Device>::PacketAccess> ImplHasPacket;
+  enum {
+    IsAligned = false,
+    // Packets are assembled from inner runs even when the nested evaluator
+    // only exposes coefficient access.
+    PacketAccess = (PacketSize > 1),
+    BlockAccess = false,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {
+    m_dimensions = m_impl.dimensions();
+    m_is_identity = true;
+    for (int i = 0; i < NumDims; ++i) {
+      m_dimensions[i] = Eigen::numext::ceil(static_cast<float>(m_dimensions[i]) / op.strides()[i]);
+      if (op.strides()[i] != 1) m_is_identity = false;
+    }
+
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_outputStrides[0] = 1;
+      m_inputStrides[0] = 1;
+      for (int i = 1; i < NumDims; ++i) {
+        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
+        m_inputStrides[i - 1] *= op.strides()[i - 1];
+      }
+      m_inputStrides[NumDims - 1] *= op.strides()[NumDims - 1];
+    } else {  // RowMajor
+      m_outputStrides[NumDims - 1] = 1;
+      m_inputStrides[NumDims - 1] = 1;
+      for (int i = NumDims - 2; i >= 0; --i) {
+        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
+        m_inputStrides[i + 1] *= op.strides()[i + 1];
+      }
+      m_inputStrides[0] *= op.strides()[0];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    if (m_is_identity) {
+      return m_impl.coeff(index);
+    }
+    return m_impl.coeff(srcCoeff(index));
+  }
+
+  // Reads PacketSize coefficients of the argument starting at `base` and
+  // stepping by `inner_stride`. Callers guarantee those lanes lie in a single
+  // inner-most run, which is what makes the input indices an arithmetic
+  // progression and lets the index mapping be computed once per packet
+  // instead of once per coefficient. The argument's packet() must not be
+  // instantiated when it has no packet access, hence the tag-dispatched pair
+  // rather than a plain branch (C++14 has no if constexpr).
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType loadInnerRun(Index base, Index inner_stride,
+                                                                      std::false_type) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = m_impl.coeff(base + i * inner_stride);
+    }
+    return internal::pload<PacketReturnType>(values);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType loadInnerRun(Index base, Index inner_stride,
+                                                                      std::true_type) const {
+    if (inner_stride == 1) return m_impl.template packet<Unaligned>(base);
+    return loadInnerRun(base, inner_stride, std::false_type());
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+    // Identity striding is just the inner-run case with step one: srcCoeff is
+    // then the identity and the inner input stride is 1.
+    if (m_is_identity) return loadInnerRun(index, 1, ImplHasPacket());
+    Index base;
+    if (packetStaysInInnerRun(index, base)) return loadInnerRun(base, m_inputStrides[kInnerDim], ImplHasPacket());
+
+    // The packet crosses an inner-run boundary, so every lane needs its own
+    // index mapping.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    return internal::pload<PacketReturnType>(values);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost = m_is_identity
+                                    ? TensorOpCost::AddCost<Index>()
+                                    : (NumDims - 1) * (TensorOpCost::AddCost<Index>() + TensorOpCost::MulCost<Index>() +
+                                                       TensorOpCost::DivCost<Index>()) +
+                                          TensorOpCost::MulCost<Index>();
+    // The nested evaluator is served whole packets only when it has packet
+    // access at all, and the inner runs are packet-aligned with an unstrided
+    // inner dimension; everywhere else it is driven coefficient by coefficient
+    // and must be charged at scalar rates. Likewise the once-per-packet index
+    // mapping amortizes only while packets stay inside one inner run; the
+    // cross-run fallback recomputes it per lane. Identity striding satisfies
+    // both conditions, so it needs no special case here.
+    const bool packets_stay_in_inner =
+        m_is_identity || (m_dimensions[kInnerDim] > 0 && m_dimensions[kInnerDim] % PacketSize == 0);
+    const bool packetizes_arg =
+        TensorEvaluator<ArgType, Device>::PacketAccess && packets_stay_in_inner && m_inputStrides[kInnerDim] == 1;
+    return m_impl.costPerCoeff(vectorized && packetizes_arg) +
+           TensorOpCost(0, 0, compute_cost, vectorized && packets_stay_in_inner, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return nullptr; }
+
+ protected:
+  // Computes the input index of output index `index` and, as a by-product of
+  // the same walk, the output's inner-dimension coordinate. The packet paths
+  // use the latter to test whether a whole packet stays inside one inner-most
+  // run without spending an extra division on it.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeffInner(Index index, Index& inner_pos) const {
+    Index inputIndex = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      EIGEN_UNROLL_LOOP
+      for (int i = NumDims - 1; i > 0; --i) {
+        const Index idx = index / m_outputStrides[i];
+        inputIndex += idx * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inner_pos = index;
+      inputIndex += index * m_inputStrides[0];
+    } else {  // RowMajor
+      EIGEN_UNROLL_LOOP
+      for (int i = 0; i < NumDims - 1; ++i) {
+        const Index idx = index / m_outputStrides[i];
+        inputIndex += idx * m_inputStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      inner_pos = index;
+      inputIndex += index * m_inputStrides[NumDims - 1];
+    }
+    return inputIndex;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
+    Index inner_pos;
+    return srcCoeffInner(index, inner_pos);
+  }
+
+  // True when the whole packet at output `index` stays inside one inner-most
+  // run; sets `base` to the input index of its first lane either way.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool packetStaysInInnerRun(Index index, Index& base) const {
+    Index inner_pos;
+    base = srcCoeffInner(index, inner_pos);
+    return inner_pos + PacketSize <= m_dimensions[kInnerDim];
+  }
+
+  Dimensions m_dimensions;
+  bool m_is_identity;
+  array<Index, NumDims> m_outputStrides;
+  array<Index, NumDims> m_inputStrides;
+  TensorEvaluator<ArgType, Device> m_impl;
+};
+
+// Eval as lvalue
+template <typename Strides, typename ArgType, typename Device>
+struct TensorEvaluator<TensorStridingOp<Strides, ArgType>, Device>
+    : public TensorEvaluator<const TensorStridingOp<Strides, ArgType>, Device> {
+  typedef TensorStridingOp<Strides, ArgType> XprType;
+  typedef TensorEvaluator<const XprType, Device> Base;
+  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+
+  typedef typename XprType::Index Index;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    // Packets are scattered into inner runs even when the nested evaluator
+    // only exposes coefficient access.
+    PacketAccess = Base::PacketAccess,
+    PreferBlockAccess = false,
+    CoordAccess = false,  // to be implemented
+    RawAccess = false
+  };
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) const {
+    if (this->m_is_identity) return this->m_impl.coeffRef(index);
+    return this->m_impl.coeffRef(this->srcCoeff(index));
+  }
+
+  // Mirror of the rvalue loadInnerRun: scatters a packet across PacketSize
+  // coefficients starting at `base` and stepping by `inner_stride`.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void storeInnerRun(Index base, Index inner_stride, const PacketReturnType& x,
+                                                           std::false_type) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) Scalar values[PacketSize];
+    internal::pstore<Scalar, PacketReturnType>(values, x);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      this->m_impl.coeffRef(base + i * inner_stride) = values[i];
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void storeInnerRun(Index base, Index inner_stride, const PacketReturnType& x,
+                                                           std::true_type) const {
+    if (inner_stride == 1) {
+      this->m_impl.template writePacket<Unaligned>(base, x);
+      return;
+    }
+    storeInnerRun(base, inner_stride, x, std::false_type());
+  }
+
+  template <int StoreMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
+    eigen_assert(index + PacketSize - 1 < this->dimensions().TotalSize());
+    typedef typename Base::ImplHasPacket ImplHasPacket;
+    if (this->m_is_identity) {
+      storeInnerRun(index, 1, x, ImplHasPacket());
+      return;
+    }
+    Index base;
+    if (this->packetStaysInInnerRun(index, base)) {
+      storeInnerRun(base, this->m_inputStrides[Base::kInnerDim], x, ImplHasPacket());
+      return;
+    }
+
+    // The packet crosses an inner-run boundary, so every lane needs its own
+    // index mapping.
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment) Scalar values[PacketSize];
+    internal::pstore<Scalar, PacketReturnType>(values, x);
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      this->coeffRef(index + i) = values[i];
+    }
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_STRIDING_H
diff --git a/contrib/Eigen/src/Tensor/TensorTrace.h b/contrib/Eigen/src/Tensor/TensorTrace.h
new file mode 100644
index 0000000..f54043c
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorTrace.h
@@ -0,0 +1,285 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gagan Goel <gagan.nith@gmail.com>
+// Copyright (C) 2017 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_TRACE_H
+#define EIGEN_TENSOR_TENSOR_TRACE_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+template <typename Dims, typename XprType>
+struct traits<TensorTraceOp<Dims, XprType> > : public traits<XprType> {
+  typedef typename XprType::Scalar Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions - array_size<Dims>::value;
+  static constexpr int Layout = XprTraits::Layout;
+  enum {
+    // Trace is read-only.
+    Flags = traits<XprType>::Flags & ~LvalueBit
+  };
+};
+
+template <typename Dims, typename XprType>
+struct eval<TensorTraceOp<Dims, XprType>, Eigen::Dense> {
+  typedef const TensorTraceOp<Dims, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Tensor Trace class.
+ */
+template <typename Dims, typename XprType>
+class TensorTraceOp : public TensorBase<TensorTraceOp<Dims, XprType> > {
+ public:
+  typedef typename Eigen::internal::traits<TensorTraceOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorTraceOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorTraceOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorTraceOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorTraceOp(const XprType& expr, const Dims& dims)
+      : m_xpr(expr), m_dims(dims) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dims& dims() const { return m_dims; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all_t<typename XprType::Nested>& expression() const {
+    return m_xpr;
+  }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const Dims m_dims;
+};
+
+// Eval as rvalue
+template <typename Dims, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorTraceOp<Dims, ArgType>, Device> {
+  typedef TensorTraceOp<Dims, ArgType> XprType;
+  static constexpr int NumInputDims =
+      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  static constexpr int NumReducedDims = internal::array_size<Dims>::value;
+  static constexpr int NumOutputDims = NumInputDims - NumReducedDims;
+  typedef typename XprType::Index Index;
+  typedef DSizes<Index, NumOutputDims> Dimensions;
+  typedef typename XprType::Scalar Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = internal::unpacket_traits<PacketReturnType>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    BlockAccess = false,
+    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
+    CoordAccess = false,
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockNotImplemented TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_traceDim(1), m_device(device) {
+    EIGEN_STATIC_ASSERT((NumOutputDims >= 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    EIGEN_STATIC_ASSERT((NumReducedDims >= 2) || ((NumReducedDims == 0) && (NumInputDims == 0)),
+                        YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    for (int i = 0; i < NumInputDims; ++i) {
+      m_reduced[i] = false;
+    }
+
+    const Dims& op_dims = op.dims();
+    for (int i = 0; i < NumReducedDims; ++i) {
+      eigen_assert(op_dims[i] >= 0);
+      eigen_assert(op_dims[i] < NumInputDims);
+      m_reduced[op_dims[i]] = true;
+    }
+
+    // All the dimensions should be distinct to compute the trace
+    int num_distinct_reduce_dims = 0;
+    for (int i = 0; i < NumInputDims; ++i) {
+      if (m_reduced[i]) {
+        ++num_distinct_reduce_dims;
+      }
+    }
+
+    EIGEN_ONLY_USED_FOR_DEBUG(num_distinct_reduce_dims);
+    eigen_assert(num_distinct_reduce_dims == NumReducedDims);
+
+    // Compute the dimensions of the result.
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+
+    int output_index = 0;
+    int reduced_index = 0;
+    for (int i = 0; i < NumInputDims; ++i) {
+      if (m_reduced[i]) {
+        m_reducedDims[reduced_index] = input_dims[i];
+        if (reduced_index > 0) {
+          // All the trace dimensions must have the same size
+          eigen_assert(m_reducedDims[0] == m_reducedDims[reduced_index]);
+        }
+        ++reduced_index;
+      } else {
+        m_dimensions[output_index] = input_dims[i];
+        ++output_index;
+      }
+    }
+
+    EIGEN_IF_CONSTEXPR (NumReducedDims != 0) {
+      m_traceDim = m_reducedDims[0];
+    }
+
+    // Compute the output strides
+    EIGEN_IF_CONSTEXPR (NumOutputDims > 0) {
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        m_outputStrides[0] = 1;
+        for (int i = 1; i < NumOutputDims; ++i) {
+          m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
+        }
+      } else {
+        m_outputStrides.back() = 1;
+        for (int i = NumOutputDims - 2; i >= 0; --i) {
+          m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
+        }
+      }
+    }
+
+    // Compute the input strides
+    EIGEN_IF_CONSTEXPR (NumInputDims > 0) {
+      array<Index, NumInputDims> input_strides;
+      EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+        input_strides[0] = 1;
+        for (int i = 1; i < NumInputDims; ++i) {
+          input_strides[i] = input_strides[i - 1] * input_dims[i - 1];
+        }
+      } else {
+        input_strides.back() = 1;
+        for (int i = NumInputDims - 2; i >= 0; --i) {
+          input_strides[i] = input_strides[i + 1] * input_dims[i + 1];
+        }
+      }
+
+      output_index = 0;
+      reduced_index = 0;
+      for (int i = 0; i < NumInputDims; ++i) {
+        if (m_reduced[i]) {
+          m_reducedStrides[reduced_index] = input_strides[i];
+          ++reduced_index;
+        } else {
+          m_preservedStrides[output_index] = input_strides[i];
+          ++output_index;
+        }
+      }
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    // Initialize the result
+    CoeffReturnType result = internal::cast<int, CoeffReturnType>(0);
+    Index index_stride = 0;
+    for (int i = 0; i < NumReducedDims; ++i) {
+      index_stride += m_reducedStrides[i];
+    }
+
+    // If trace is requested along all dimensions, starting index would be 0
+    Index cur_index = 0;
+    EIGEN_IF_CONSTEXPR (NumOutputDims != 0) {
+      cur_index = firstInput(index);
+    }
+    for (Index i = 0; i < m_traceDim; ++i) {
+      result += m_impl.coeff(cur_index);
+      cur_index += index_stride;
+    }
+
+    return result;
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType result = internal::ploadt<PacketReturnType, LoadMode>(values);
+    return result;
+  }
+
+ protected:
+  // Given the output index, finds the first index in the input tensor used to compute the trace
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index firstInput(Index index) const { return firstInputImpl(index); }
+
+  template <int ND = NumOutputDims>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<ND == 0, Index> firstInputImpl(Index /*index*/) const {
+    return 0;
+  }
+
+  template <int ND = NumOutputDims>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<(ND > 0), Index> firstInputImpl(Index index) const {
+    Index startInput = 0;
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      for (int i = ND - 1; i > 0; --i) {
+        const Index idx = index / m_outputStrides[i];
+        startInput += idx * m_preservedStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      startInput += index * m_preservedStrides[0];
+    } else {
+      for (int i = 0; i < ND - 1; ++i) {
+        const Index idx = index / m_outputStrides[i];
+        startInput += idx * m_preservedStrides[i];
+        index -= idx * m_outputStrides[i];
+      }
+      startInput += index * m_preservedStrides[ND - 1];
+    }
+    return startInput;
+  }
+
+  Dimensions m_dimensions;
+  TensorEvaluator<ArgType, Device> m_impl;
+  // Initialize the size of the trace dimension
+  Index m_traceDim;
+  const Device EIGEN_DEVICE_REF m_device;
+  array<bool, NumInputDims> m_reduced;
+  array<Index, NumReducedDims> m_reducedDims;
+  array<Index, NumOutputDims> m_outputStrides;
+  array<Index, NumReducedDims> m_reducedStrides;
+  array<Index, NumOutputDims> m_preservedStrides;
+};
+
+}  // End namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_TRACE_H
diff --git a/contrib/Eigen/src/Tensor/TensorTraits.h b/contrib/Eigen/src/Tensor/TensorTraits.h
new file mode 100644
index 0000000..6b4d9df
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorTraits.h
@@ -0,0 +1,225 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_TRAITS_H
+#define EIGEN_TENSOR_TENSOR_TRAITS_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+template <int Options>
+struct tensor_alignment_for_options {
+  enum {
+    is_dynamic_size_storage = 1,
+
+    value = (((Options & DontAlign) == 0) && (
+#if EIGEN_MAX_STATIC_ALIGN_BYTES > 0
+                                                 (!is_dynamic_size_storage)
+#else
+                                                 0
+#endif
+                                                 |
+#if EIGEN_MAX_ALIGN_BYTES > 0
+                                                 is_dynamic_size_storage
+#else
+                                                 0
+#endif
+                                                 ))
+  };
+};
+
+template <typename Scalar, int Options>
+struct compute_tensor_flags
+    : std::integral_constant<int, packet_traits<Scalar>::Vectorizable && tensor_alignment_for_options<Options>::value
+                                      ? PacketAccessBit
+                                      : 0> {};
+
+template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
+struct traits<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {
+  typedef Scalar_ Scalar;
+  typedef Dense StorageKind;
+  typedef IndexType_ Index;
+  static constexpr int NumDimensions = NumIndices_;
+  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
+  enum {
+    Options = Options_,
+    Flags = compute_tensor_flags<Scalar_, Options_>::value | (std::is_const<Scalar_>::value ? 0 : LvalueBit)
+  };
+  template <typename T>
+  struct MakePointer {
+    typedef T* Type;
+  };
+  typedef typename MakePointer<Scalar>::Type PointerType;
+};
+
+template <typename Scalar_, typename Dimensions, int Options_, typename IndexType_>
+struct traits<TensorFixedSize<Scalar_, Dimensions, Options_, IndexType_> > {
+  typedef Scalar_ Scalar;
+  typedef Dense StorageKind;
+  typedef IndexType_ Index;
+  static constexpr int NumDimensions = array_size<Dimensions>::value;
+  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
+  enum {
+    Options = Options_,
+    Flags = compute_tensor_flags<Scalar_, Options_>::value | (std::is_const<Scalar_>::value ? 0 : LvalueBit)
+  };
+  template <typename T>
+  struct MakePointer {
+    typedef T* Type;
+  };
+  typedef typename MakePointer<Scalar>::Type PointerType;
+};
+
+template <typename PlainObjectType, int Options_, template <class> class MakePointer_>
+struct traits<TensorMap<PlainObjectType, Options_, MakePointer_> > : public traits<PlainObjectType> {
+  typedef traits<PlainObjectType> BaseTraits;
+  typedef typename BaseTraits::Scalar Scalar;
+  typedef typename BaseTraits::StorageKind StorageKind;
+  typedef typename BaseTraits::Index Index;
+  static constexpr int NumDimensions = BaseTraits::NumDimensions;
+  static constexpr int Layout = BaseTraits::Layout;
+  enum { Options = Options_, Flags = BaseTraits::Flags };
+  template <class T>
+  struct MakePointer {
+    typedef typename MakePointer_<T>::Type Type;
+  };
+  typedef typename MakePointer<Scalar>::Type PointerType;
+};
+
+template <typename PlainObjectType_>
+struct traits<TensorRef<PlainObjectType_> > : public traits<PlainObjectType_> {
+  typedef PlainObjectType_ PlainObjectType;
+  typedef traits<PlainObjectType> BaseTraits;
+  typedef typename BaseTraits::Scalar Scalar;
+  typedef typename BaseTraits::StorageKind StorageKind;
+  typedef typename BaseTraits::Index Index;
+  static constexpr int NumDimensions = BaseTraits::NumDimensions;
+  static constexpr int Layout = BaseTraits::Layout;
+  enum { Options = BaseTraits::Options, Flags = BaseTraits::Flags };
+  typedef typename BaseTraits::PointerType PointerType;
+};
+
+template <typename Scalar_, int NumIndices_, int Options, typename IndexType_>
+struct eval<Tensor<Scalar_, NumIndices_, Options, IndexType_>, Eigen::Dense> {
+  typedef const Tensor<Scalar_, NumIndices_, Options, IndexType_> EIGEN_DEVICE_REF type;
+};
+
+template <typename Scalar_, int NumIndices_, int Options, typename IndexType_>
+struct eval<const Tensor<Scalar_, NumIndices_, Options, IndexType_>, Eigen::Dense> {
+  typedef const Tensor<Scalar_, NumIndices_, Options, IndexType_> EIGEN_DEVICE_REF type;
+};
+
+template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
+struct eval<TensorFixedSize<Scalar_, Dimensions, Options, IndexType_>, Eigen::Dense> {
+  typedef const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> EIGEN_DEVICE_REF type;
+};
+
+template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
+struct eval<const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_>, Eigen::Dense> {
+  typedef const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> EIGEN_DEVICE_REF type;
+};
+
+template <typename PlainObjectType, int Options, template <class> class MakePointer>
+struct eval<TensorMap<PlainObjectType, Options, MakePointer>, Eigen::Dense> {
+  typedef const TensorMap<PlainObjectType, Options, MakePointer> EIGEN_DEVICE_REF type;
+};
+
+template <typename PlainObjectType, int Options, template <class> class MakePointer>
+struct eval<const TensorMap<PlainObjectType, Options, MakePointer>, Eigen::Dense> {
+  typedef const TensorMap<PlainObjectType, Options, MakePointer> EIGEN_DEVICE_REF type;
+};
+
+template <typename PlainObjectType>
+struct eval<TensorRef<PlainObjectType>, Eigen::Dense> {
+  typedef const TensorRef<PlainObjectType> EIGEN_DEVICE_REF type;
+};
+
+template <typename PlainObjectType>
+struct eval<const TensorRef<PlainObjectType>, Eigen::Dense> {
+  typedef const TensorRef<PlainObjectType> EIGEN_DEVICE_REF type;
+};
+
+template <typename T>
+struct tensor_ref_selector {
+  typedef const T EIGEN_DEVICE_REF type;
+  typedef T EIGEN_DEVICE_REF non_const_type;
+};
+
+template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
+struct ref_selector<Tensor<Scalar_, NumIndices_, Options_, IndexType_> >
+    : tensor_ref_selector<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {};
+
+template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
+struct ref_selector<const Tensor<Scalar_, NumIndices_, Options_, IndexType_> >
+    : tensor_ref_selector<const Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {};
+
+template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
+struct ref_selector<TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> >
+    : tensor_ref_selector<TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> > {};
+
+template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
+struct ref_selector<const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> >
+    : tensor_ref_selector<const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> > {};
+
+template <typename PlainObjectType>
+struct ref_selector<TensorRef<PlainObjectType> > : tensor_ref_selector<TensorRef<PlainObjectType> > {};
+
+template <typename PlainObjectType>
+struct ref_selector<const TensorRef<PlainObjectType> > : tensor_ref_selector<const TensorRef<PlainObjectType> > {};
+
+}  // end namespace internal
+
+// Convolutional layers take in an input tensor of shape (D, R, C, B), or (D, C,
+// R, B), and convolve it with a set of filters, which can also be presented as
+// a tensor (D, K, K, M), where M is the number of filters, K is the filter
+// size, and each 3-dimensional tensor of size (D, K, K) is a filter. For
+// simplicity we assume that we always use square filters (which is usually the
+// case in images), hence the two Ks in the tensor dimension.  It also takes in
+// a few additional parameters:
+// Stride (S): The convolution stride is the offset between locations where we
+//             apply the filters.  A larger stride means that the output will be
+//             spatially smaller.
+// Padding (P): The padding we apply to the input tensor along the R and C
+//              dimensions.  This is usually used to make sure that the spatial
+//              dimensions of the output matches our intention.
+//
+// Two types of padding are often used:
+//   SAME: The pad value is computed so that the output will have size
+//         R/S and C/S.
+//   VALID: no padding is carried out.
+// When we do padding, the padded values at the padded locations are usually
+// zero.
+//
+// The output dimensions for convolution, when given all the parameters above,
+// are as follows:
+// When Padding = SAME: the output size is (B, R', C', M), where
+//   R' = ceil(float(R) / float(S))
+//   C' = ceil(float(C) / float(S))
+// where ceil is the ceiling function.  The input tensor is padded with 0 as
+// needed.  The number of padded rows and columns are computed as:
+//   Pr = ((R' - 1) * S + K - R) / 2
+//   Pc = ((C' - 1) * S + K - C) / 2
+// When the stride is 1, we have the simplified case R'=R, C'=C, Pr=Pc=(K-1)/2.
+// This is where SAME comes from - the output has the same size as the input has.
+// When Padding = VALID: the output size is computed as
+//   R' = ceil(float(R - K + 1) / float(S))
+//   C' = ceil(float(C - K + 1) / float(S))
+// and the number of padded rows and columns are computed in the same way as in
+// the SAME case.
+// When the stride is 1, we have the simplified case R'=R-K+1, C'=C-K+1, Pr=0,
+// Pc=0.
+enum PaddingType { PADDING_VALID = 1, PADDING_SAME = 2 };
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_TRAITS_H
diff --git a/contrib/Eigen/src/Tensor/TensorUInt128.h b/contrib/Eigen/src/Tensor/TensorUInt128.h
new file mode 100644
index 0000000..de5f039
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorUInt128.h
@@ -0,0 +1,229 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_UINT128_H
+#define EIGEN_TENSOR_TENSOR_UINT128_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+namespace internal {
+
+template <uint64_t n>
+struct static_val {
+  static constexpr uint64_t value = n;
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE operator uint64_t() const { return n; }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static_val() = default;
+
+  template <typename T>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static_val(const T& v) {
+    EIGEN_UNUSED_VARIABLE(v);
+    eigen_assert(v == n);
+  }
+};
+
+template <typename HIGH = uint64_t, typename LOW = uint64_t>
+struct TensorUInt128 {
+  HIGH high;
+  LOW low;
+
+  template <typename OTHER_HIGH, typename OTHER_LOW>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128(const TensorUInt128<OTHER_HIGH, OTHER_LOW>& other)
+      : high(other.high), low(other.low) {
+    EIGEN_STATIC_ASSERT(sizeof(OTHER_HIGH) <= sizeof(HIGH), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    EIGEN_STATIC_ASSERT(sizeof(OTHER_LOW) <= sizeof(LOW), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  }
+
+  template <typename OTHER_HIGH, typename OTHER_LOW>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128& operator=(const TensorUInt128<OTHER_HIGH, OTHER_LOW>& other) {
+    EIGEN_STATIC_ASSERT(sizeof(OTHER_HIGH) <= sizeof(HIGH), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    EIGEN_STATIC_ASSERT(sizeof(OTHER_LOW) <= sizeof(LOW), YOU_MADE_A_PROGRAMMING_MISTAKE);
+    high = other.high;
+    low = other.low;
+    return *this;
+  }
+
+  template <typename T>
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE explicit TensorUInt128(const T& x) : high(0), low(x) {
+    eigen_assert(
+        (static_cast<std::conditional_t<sizeof(T) == 8, uint64_t, uint32_t>>(x) <= NumTraits<uint64_t>::highest()));
+    eigen_assert(x >= 0);
+  }
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128(HIGH y, LOW x) : high(y), low(x) {}
+
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE operator LOW() const { return low; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LOW lower() const { return low; }
+  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE HIGH upper() const { return high; }
+};
+
+template <typename HL, typename LL, typename HR, typename LR>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator==(const TensorUInt128<HL, LL>& lhs,
+                                                                const TensorUInt128<HR, LR>& rhs) {
+  return (lhs.high == rhs.high) && (lhs.low == rhs.low);
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator!=(const TensorUInt128<HL, LL>& lhs,
+                                                                const TensorUInt128<HR, LR>& rhs) {
+  return (lhs.high != rhs.high) || (lhs.low != rhs.low);
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator>=(const TensorUInt128<HL, LL>& lhs,
+                                                                const TensorUInt128<HR, LR>& rhs) {
+  if (lhs.high != rhs.high) {
+    return lhs.high > rhs.high;
+  }
+  return lhs.low >= rhs.low;
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator<(const TensorUInt128<HL, LL>& lhs,
+                                                               const TensorUInt128<HR, LR>& rhs) {
+  if (lhs.high != rhs.high) {
+    return lhs.high < rhs.high;
+  }
+  return lhs.low < rhs.low;
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128<uint64_t, uint64_t> operator+(
+    const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs) {
+  TensorUInt128<uint64_t, uint64_t> result(lhs.high + rhs.high, lhs.low + rhs.low);
+  if (result.low < rhs.low) {
+    result.high += 1;
+  }
+  return result;
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128<uint64_t, uint64_t> operator-(
+    const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs) {
+  TensorUInt128<uint64_t, uint64_t> result(lhs.high - rhs.high, lhs.low - rhs.low);
+  if (result.low > lhs.low) {
+    result.high -= 1;
+  }
+  return result;
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128<uint64_t, uint64_t> operator*(
+    const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs) {
+  // Split each 128-bit integer into 4 32-bit integers, and then do the
+  // multiplications by hand as follows:
+  //   lhs      a  b  c  d
+  //   rhs      e  f  g  h
+  //           -----------
+  //           ah bh ch dh
+  //           bg cg dg
+  //           cf df
+  //           de
+  // The result is stored in 2 64bit integers, high and low.
+
+  const uint64_t LOW = 0x00000000FFFFFFFFLL;
+  const uint64_t HIGH = 0xFFFFFFFF00000000LL;
+
+  uint64_t d = lhs.low & LOW;
+  uint64_t c = (lhs.low & HIGH) >> 32LL;
+  uint64_t b = lhs.high & LOW;
+  uint64_t a = (lhs.high & HIGH) >> 32LL;
+
+  uint64_t h = rhs.low & LOW;
+  uint64_t g = (rhs.low & HIGH) >> 32LL;
+  uint64_t f = rhs.high & LOW;
+  uint64_t e = (rhs.high & HIGH) >> 32LL;
+
+  // Compute the low 32 bits of low
+  uint64_t acc = d * h;
+  uint64_t low = acc & LOW;
+  //  Compute the high 32 bits of low. Add a carry every time we wrap around
+  acc >>= 32LL;
+  uint64_t carry = 0;
+  uint64_t acc2 = acc + c * h;
+  if (acc2 < acc) {
+    carry++;
+  }
+  acc = acc2 + d * g;
+  if (acc < acc2) {
+    carry++;
+  }
+  low |= (acc << 32LL);
+
+  // Carry forward the high bits of acc to initiate the computation of the
+  // low 32 bits of high
+  acc2 = (acc >> 32LL) | (carry << 32LL);
+  carry = 0;
+
+  acc = acc2 + b * h;
+  if (acc < acc2) {
+    carry++;
+  }
+  acc2 = acc + c * g;
+  if (acc2 < acc) {
+    carry++;
+  }
+  acc = acc2 + d * f;
+  if (acc < acc2) {
+    carry++;
+  }
+  uint64_t high = acc & LOW;
+
+  // Start to compute the high 32 bits of high.
+  acc2 = (acc >> 32LL) | (carry << 32LL);
+
+  acc = acc2 + a * h;
+  acc2 = acc + b * g;
+  acc = acc2 + c * f;
+  acc2 = acc + d * e;
+  high |= (acc2 << 32LL);
+
+  return TensorUInt128<uint64_t, uint64_t>(high, low);
+}
+
+template <typename HL, typename LL, typename HR, typename LR>
+static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128<uint64_t, uint64_t> operator/(
+    const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs) {
+  if (rhs == TensorUInt128<static_val<0>, static_val<1>>(1)) {
+    return TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
+  } else if (lhs < rhs) {
+    return TensorUInt128<uint64_t, uint64_t>(0);
+  } else {
+    // calculate the biggest power of 2 times rhs that's less than or equal to lhs
+    TensorUInt128<uint64_t, uint64_t> power2(1);
+    TensorUInt128<uint64_t, uint64_t> d(rhs);
+    while (lhs >= d) {
+      if (d.high >> 63) break;  // next doubling would overflow 128 bits
+      d = d + d;
+      power2 = power2 + power2;
+    }
+
+    TensorUInt128<uint64_t, uint64_t> tmp(lhs.high, lhs.low);
+    TensorUInt128<uint64_t, uint64_t> result(0);
+    while (power2 != TensorUInt128<static_val<0>, static_val<0>>(0)) {
+      if (tmp >= d) {
+        tmp = tmp - d;
+        result = result + power2;
+      }
+      // Shift right
+      power2 = TensorUInt128<uint64_t, uint64_t>(power2.high >> 1, (power2.low >> 1) | (power2.high << 63));
+      d = TensorUInt128<uint64_t, uint64_t>(d.high >> 1, (d.low >> 1) | (d.high << 63));
+    }
+
+    return result;
+  }
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_UINT128_H
diff --git a/contrib/Eigen/src/Tensor/TensorVolumePatch.h b/contrib/Eigen/src/Tensor/TensorVolumePatch.h
new file mode 100644
index 0000000..018d7fd
--- /dev/null
+++ b/contrib/Eigen/src/Tensor/TensorVolumePatch.h
@@ -0,0 +1,798 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSOR_TENSOR_VOLUME_PATCH_H
+#define EIGEN_TENSOR_TENSOR_VOLUME_PATCH_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
+struct traits<TensorVolumePatchOp<Planes, Rows, Cols, XprType>> : traits<XprType> {
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef traits<XprType> XprTraits;
+  typedef typename XprTraits::StorageKind StorageKind;
+  typedef typename XprTraits::Index Index;
+  static constexpr int NumDimensions = XprTraits::NumDimensions + 1;
+  static constexpr int Layout = XprTraits::Layout;
+  typedef typename XprTraits::PointerType PointerType;
+};
+
+template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
+struct eval<TensorVolumePatchOp<Planes, Rows, Cols, XprType>, Eigen::Dense> {
+  typedef const TensorVolumePatchOp<Planes, Rows, Cols, XprType>& type;
+};
+
+}  // end namespace internal
+
+/**
+ * \ingroup Tensor_Module
+ *
+ * \brief Patch extraction specialized for processing of volumetric data.
+ * This assumes that the input has at least 4 dimensions ordered as follows:
+ *  - channels
+ *  - planes
+ *  - rows
+ *  - columns
+ *  - (optional) additional dimensions such as time or batch size.
+ * Calling the volume patch code with patch_planes, patch_rows, and patch_cols
+ * is equivalent to calling the regular patch extraction code with parameters
+ * d, patch_planes, patch_rows, patch_cols, and 1 for all the additional
+ * dimensions.
+ */
+template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
+class TensorVolumePatchOp : public TensorBase<TensorVolumePatchOp<Planes, Rows, Cols, XprType>, ReadOnlyAccessors> {
+ public:
+  typedef typename Eigen::internal::traits<TensorVolumePatchOp>::Scalar Scalar;
+  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename Eigen::internal::ref_selector<TensorVolumePatchOp>::type Nested;
+  typedef typename Eigen::internal::traits<TensorVolumePatchOp>::StorageKind StorageKind;
+  typedef typename Eigen::internal::traits<TensorVolumePatchOp>::Index Index;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorVolumePatchOp(
+      const XprType& expr, DenseIndex patch_planes, DenseIndex patch_rows, DenseIndex patch_cols,
+      DenseIndex plane_strides, DenseIndex row_strides, DenseIndex col_strides, DenseIndex in_plane_strides,
+      DenseIndex in_row_strides, DenseIndex in_col_strides, DenseIndex plane_inflate_strides,
+      DenseIndex row_inflate_strides, DenseIndex col_inflate_strides, PaddingType padding_type, Scalar padding_value)
+      : m_xpr(expr),
+        m_patch_planes(patch_planes),
+        m_patch_rows(patch_rows),
+        m_patch_cols(patch_cols),
+        m_plane_strides(plane_strides),
+        m_row_strides(row_strides),
+        m_col_strides(col_strides),
+        m_in_plane_strides(in_plane_strides),
+        m_in_row_strides(in_row_strides),
+        m_in_col_strides(in_col_strides),
+        m_plane_inflate_strides(plane_inflate_strides),
+        m_row_inflate_strides(row_inflate_strides),
+        m_col_inflate_strides(col_inflate_strides),
+        m_padding_explicit(false),
+        m_padding_top_z(0),
+        m_padding_bottom_z(0),
+        m_padding_top(0),
+        m_padding_bottom(0),
+        m_padding_left(0),
+        m_padding_right(0),
+        m_padding_type(padding_type),
+        m_padding_value(padding_value) {}
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorVolumePatchOp(
+      const XprType& expr, DenseIndex patch_planes, DenseIndex patch_rows, DenseIndex patch_cols,
+      DenseIndex plane_strides, DenseIndex row_strides, DenseIndex col_strides, DenseIndex in_plane_strides,
+      DenseIndex in_row_strides, DenseIndex in_col_strides, DenseIndex plane_inflate_strides,
+      DenseIndex row_inflate_strides, DenseIndex col_inflate_strides, DenseIndex padding_top_z,
+      DenseIndex padding_bottom_z, DenseIndex padding_top, DenseIndex padding_bottom, DenseIndex padding_left,
+      DenseIndex padding_right, Scalar padding_value)
+      : m_xpr(expr),
+        m_patch_planes(patch_planes),
+        m_patch_rows(patch_rows),
+        m_patch_cols(patch_cols),
+        m_plane_strides(plane_strides),
+        m_row_strides(row_strides),
+        m_col_strides(col_strides),
+        m_in_plane_strides(in_plane_strides),
+        m_in_row_strides(in_row_strides),
+        m_in_col_strides(in_col_strides),
+        m_plane_inflate_strides(plane_inflate_strides),
+        m_row_inflate_strides(row_inflate_strides),
+        m_col_inflate_strides(col_inflate_strides),
+        m_padding_explicit(true),
+        m_padding_top_z(padding_top_z),
+        m_padding_bottom_z(padding_bottom_z),
+        m_padding_top(padding_top),
+        m_padding_bottom(padding_bottom),
+        m_padding_left(padding_left),
+        m_padding_right(padding_right),
+        m_padding_type(PADDING_VALID),
+        m_padding_value(padding_value) {}
+
+  EIGEN_DEVICE_FUNC DenseIndex patch_planes() const { return m_patch_planes; }
+  EIGEN_DEVICE_FUNC DenseIndex patch_rows() const { return m_patch_rows; }
+  EIGEN_DEVICE_FUNC DenseIndex patch_cols() const { return m_patch_cols; }
+  EIGEN_DEVICE_FUNC DenseIndex plane_strides() const { return m_plane_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex row_strides() const { return m_row_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex col_strides() const { return m_col_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex in_plane_strides() const { return m_in_plane_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex in_row_strides() const { return m_in_row_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex in_col_strides() const { return m_in_col_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex plane_inflate_strides() const { return m_plane_inflate_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex row_inflate_strides() const { return m_row_inflate_strides; }
+  EIGEN_DEVICE_FUNC DenseIndex col_inflate_strides() const { return m_col_inflate_strides; }
+  EIGEN_DEVICE_FUNC bool padding_explicit() const { return m_padding_explicit; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_top_z() const { return m_padding_top_z; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_bottom_z() const { return m_padding_bottom_z; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_top() const { return m_padding_top; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_bottom() const { return m_padding_bottom; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_left() const { return m_padding_left; }
+  EIGEN_DEVICE_FUNC DenseIndex padding_right() const { return m_padding_right; }
+  EIGEN_DEVICE_FUNC PaddingType padding_type() const { return m_padding_type; }
+  EIGEN_DEVICE_FUNC Scalar padding_value() const { return m_padding_value; }
+
+  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
+
+ protected:
+  typename XprType::Nested m_xpr;
+  const DenseIndex m_patch_planes;
+  const DenseIndex m_patch_rows;
+  const DenseIndex m_patch_cols;
+  const DenseIndex m_plane_strides;
+  const DenseIndex m_row_strides;
+  const DenseIndex m_col_strides;
+  const DenseIndex m_in_plane_strides;
+  const DenseIndex m_in_row_strides;
+  const DenseIndex m_in_col_strides;
+  const DenseIndex m_plane_inflate_strides;
+  const DenseIndex m_row_inflate_strides;
+  const DenseIndex m_col_inflate_strides;
+  const bool m_padding_explicit;
+  const DenseIndex m_padding_top_z;
+  const DenseIndex m_padding_bottom_z;
+  const DenseIndex m_padding_top;
+  const DenseIndex m_padding_bottom;
+  const DenseIndex m_padding_left;
+  const DenseIndex m_padding_right;
+  const PaddingType m_padding_type;
+  const Scalar m_padding_value;
+};
+
+// Eval as rvalue
+template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename ArgType, typename Device>
+struct TensorEvaluator<const TensorVolumePatchOp<Planes, Rows, Cols, ArgType>, Device> {
+  typedef TensorVolumePatchOp<Planes, Rows, Cols, ArgType> XprType;
+  typedef typename XprType::Index Index;
+  static constexpr int NumInputDims =
+      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
+  static constexpr int NumDims = NumInputDims + 1;
+  typedef DSizes<Index, NumDims> Dimensions;
+  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
+  typedef typename XprType::CoeffReturnType CoeffReturnType;
+  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
+  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
+  typedef StorageMemory<CoeffReturnType, Device> Storage;
+  typedef typename Storage::Type EvaluatorPointerType;
+
+  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
+  enum {
+    IsAligned = false,
+    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
+    // block() reads the argument one coefficient at a time through coeff() --
+    // the contract the scalar executors already rely on for every evaluator --
+    // so it requires no capability bit from the argument (same as
+    // TensorReverse).
+    BlockAccess = true,
+    // The coeff/packet path pays ~10 divisions of index math per element; the
+    // block path amortizes all of it over whole depth runs.
+    PreferBlockAccess = true,
+    CoordAccess = false,
+    RawAccess = false
+  };
+
+  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
+  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  typedef typename internal::TensorMaterializedBlock<Scalar, NumDims, Layout, Index> TensorBlock;
+  //===--------------------------------------------------------------------===//
+
+  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
+      : m_impl(op.expression(), device), m_device(device) {
+    EIGEN_STATIC_ASSERT((NumDims >= 5), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+    m_paddingValue = op.padding_value();
+
+    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
+
+    // Cache a few variables.
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_inputDepth = input_dims[0];
+      m_inputPlanes = input_dims[1];
+      m_inputRows = input_dims[2];
+      m_inputCols = input_dims[3];
+    } else {
+      m_inputDepth = input_dims[NumInputDims - 1];
+      m_inputPlanes = input_dims[NumInputDims - 2];
+      m_inputRows = input_dims[NumInputDims - 3];
+      m_inputCols = input_dims[NumInputDims - 4];
+    }
+
+    m_plane_strides = op.plane_strides();
+    m_row_strides = op.row_strides();
+    m_col_strides = op.col_strides();
+
+    // Input strides and effective input/patch size
+    m_in_plane_strides = op.in_plane_strides();
+    m_in_row_strides = op.in_row_strides();
+    m_in_col_strides = op.in_col_strides();
+    m_plane_inflate_strides = op.plane_inflate_strides();
+    m_row_inflate_strides = op.row_inflate_strides();
+    m_col_inflate_strides = op.col_inflate_strides();
+
+    // The "effective" spatial size after inflating data with zeros.
+    m_input_planes_eff = (m_inputPlanes - 1) * m_plane_inflate_strides + 1;
+    m_input_rows_eff = (m_inputRows - 1) * m_row_inflate_strides + 1;
+    m_input_cols_eff = (m_inputCols - 1) * m_col_inflate_strides + 1;
+    m_patch_planes_eff = op.patch_planes() + (op.patch_planes() - 1) * (m_in_plane_strides - 1);
+    m_patch_rows_eff = op.patch_rows() + (op.patch_rows() - 1) * (m_in_row_strides - 1);
+    m_patch_cols_eff = op.patch_cols() + (op.patch_cols() - 1) * (m_in_col_strides - 1);
+
+    if (op.padding_explicit()) {
+      m_outputPlanes =
+          numext::ceil((m_input_planes_eff + op.padding_top_z() + op.padding_bottom_z() - m_patch_planes_eff + 1.f) /
+                       static_cast<float>(m_plane_strides));
+      m_outputRows = numext::ceil((m_input_rows_eff + op.padding_top() + op.padding_bottom() - m_patch_rows_eff + 1.f) /
+                                  static_cast<float>(m_row_strides));
+      m_outputCols = numext::ceil((m_input_cols_eff + op.padding_left() + op.padding_right() - m_patch_cols_eff + 1.f) /
+                                  static_cast<float>(m_col_strides));
+      m_planePaddingTop = op.padding_top_z();
+      m_rowPaddingTop = op.padding_top();
+      m_colPaddingLeft = op.padding_left();
+    } else {
+      // Computing padding from the type
+      switch (op.padding_type()) {
+        case PADDING_VALID:
+          m_outputPlanes =
+              numext::ceil((m_input_planes_eff - m_patch_planes_eff + 1.f) / static_cast<float>(m_plane_strides));
+          m_outputRows = numext::ceil((m_input_rows_eff - m_patch_rows_eff + 1.f) / static_cast<float>(m_row_strides));
+          m_outputCols = numext::ceil((m_input_cols_eff - m_patch_cols_eff + 1.f) / static_cast<float>(m_col_strides));
+          m_planePaddingTop = 0;
+          m_rowPaddingTop = 0;
+          m_colPaddingLeft = 0;
+          break;
+        case PADDING_SAME: {
+          m_outputPlanes = numext::ceil(m_input_planes_eff / static_cast<float>(m_plane_strides));
+          m_outputRows = numext::ceil(m_input_rows_eff / static_cast<float>(m_row_strides));
+          m_outputCols = numext::ceil(m_input_cols_eff / static_cast<float>(m_col_strides));
+          const Index dz = (m_outputPlanes - 1) * m_plane_strides + m_patch_planes_eff - m_input_planes_eff;
+          const Index dy = (m_outputRows - 1) * m_row_strides + m_patch_rows_eff - m_input_rows_eff;
+          const Index dx = (m_outputCols - 1) * m_col_strides + m_patch_cols_eff - m_input_cols_eff;
+          m_planePaddingTop = dz / 2;
+          m_rowPaddingTop = dy / 2;
+          m_colPaddingLeft = dx / 2;
+          break;
+        }
+        default: {
+          eigen_assert(false && "unexpected padding");
+          return;
+        }
+      }
+    }
+    eigen_assert(m_outputRows > 0);
+    eigen_assert(m_outputCols > 0);
+    eigen_assert(m_outputPlanes > 0);
+
+    // Dimensions for result of extraction.
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      // ColMajor
+      // 0: depth
+      // 1: patch_planes
+      // 2: patch_rows
+      // 3: patch_cols
+      // 4: number of patches
+      // 5 and beyond: anything else (such as batch).
+      m_dimensions[0] = input_dims[0];
+      m_dimensions[1] = op.patch_planes();
+      m_dimensions[2] = op.patch_rows();
+      m_dimensions[3] = op.patch_cols();
+      m_dimensions[4] = m_outputPlanes * m_outputRows * m_outputCols;
+      for (int i = 5; i < NumDims; ++i) {
+        m_dimensions[i] = input_dims[i - 1];
+      }
+    } else {
+      // RowMajor
+      // NumDims-1: depth
+      // NumDims-2: patch_planes
+      // NumDims-3: patch_rows
+      // NumDims-4: patch_cols
+      // NumDims-5: number of patches
+      // NumDims-6 and beyond: anything else (such as batch).
+      m_dimensions[NumDims - 1] = input_dims[NumInputDims - 1];
+      m_dimensions[NumDims - 2] = op.patch_planes();
+      m_dimensions[NumDims - 3] = op.patch_rows();
+      m_dimensions[NumDims - 4] = op.patch_cols();
+      m_dimensions[NumDims - 5] = m_outputPlanes * m_outputRows * m_outputCols;
+      for (int i = NumDims - 6; i >= 0; --i) {
+        m_dimensions[i] = input_dims[i];
+      }
+    }
+
+    // Strides for the output tensor.
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_rowStride = m_dimensions[1];
+      m_colStride = m_dimensions[2] * m_rowStride;
+      m_patchStride = m_colStride * m_dimensions[3] * m_dimensions[0];
+      m_otherStride = m_patchStride * m_dimensions[4];
+    } else {
+      m_rowStride = m_dimensions[NumDims - 2];
+      m_colStride = m_dimensions[NumDims - 3] * m_rowStride;
+      m_patchStride = m_colStride * m_dimensions[NumDims - 4] * m_dimensions[NumDims - 1];
+      m_otherStride = m_patchStride * m_dimensions[NumDims - 5];
+    }
+
+    // Strides for navigating through the input tensor.
+    m_planeInputStride = m_inputDepth;
+    m_rowInputStride = m_inputDepth * m_inputPlanes;
+    m_colInputStride = m_inputDepth * m_inputRows * m_inputPlanes;
+    m_otherInputStride = m_inputDepth * m_inputRows * m_inputCols * m_inputPlanes;
+
+    m_outputPlanesRows = m_outputPlanes * m_outputRows;
+
+    // Fast representations of different variables.
+    m_fastOtherStride = internal::TensorIntDivisor<Index>(m_otherStride);
+
+    m_fastPatchStride = internal::TensorIntDivisor<Index>(m_patchStride);
+    m_fastColStride = internal::TensorIntDivisor<Index>(m_colStride);
+    m_fastRowStride = internal::TensorIntDivisor<Index>(m_rowStride);
+    m_fastInputRowStride = internal::TensorIntDivisor<Index>(m_row_inflate_strides);
+    m_fastInputColStride = internal::TensorIntDivisor<Index>(m_col_inflate_strides);
+    m_fastInputPlaneStride = internal::TensorIntDivisor<Index>(m_plane_inflate_strides);
+    m_fastInputColsEff = internal::TensorIntDivisor<Index>(m_input_cols_eff);
+    m_fastOutputPlanes = internal::TensorIntDivisor<Index>(m_outputPlanes);
+    m_fastOutputPlanesRows = internal::TensorIntDivisor<Index>(m_outputPlanesRows);
+
+    EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[0]);
+    } else {
+      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[NumDims - 1]);
+    }
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
+
+  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
+    m_impl.evalSubExprsIfNeeded(nullptr);
+    return true;
+  }
+
+#ifdef EIGEN_USE_THREADS
+  template <typename EvalSubExprsCallback>
+  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType /*data*/, EvalSubExprsCallback done) {
+    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
+  }
+#endif  // EIGEN_USE_THREADS
+
+  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
+    // Patch index corresponding to the passed in index.
+    const Index patchIndex = index / m_fastPatchStride;
+
+    // Spatial offset within the patch. This has to be translated into 3D
+    // coordinates within the patch.
+    const Index patchOffset = (index - patchIndex * m_patchStride) / m_fastOutputDepth;
+
+    // Batch, etc.
+    const Index otherIndex = (NumDims == 5) ? 0 : index / m_fastOtherStride;
+    const Index patch3DIndex = (NumDims == 5) ? patchIndex : (index - otherIndex * m_otherStride) / m_fastPatchStride;
+
+    // Calculate column index in the input original tensor.
+    const Index colIndex = patch3DIndex / m_fastOutputPlanesRows;
+    const Index colOffset = patchOffset / m_fastColStride;
+    const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
+    const Index origInputCol =
+        (m_col_inflate_strides == 1) ? inputCol : ((inputCol >= 0) ? (inputCol / m_fastInputColStride) : 0);
+    if (inputCol < 0 || inputCol >= m_input_cols_eff ||
+        ((m_col_inflate_strides != 1) && (inputCol != origInputCol * m_col_inflate_strides))) {
+      return Scalar(m_paddingValue);
+    }
+
+    // Calculate row index in the original input tensor.
+    const Index rowIndex = (patch3DIndex - colIndex * m_outputPlanesRows) / m_fastOutputPlanes;
+    const Index rowOffset = (patchOffset - colOffset * m_colStride) / m_fastRowStride;
+    const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
+    const Index origInputRow =
+        (m_row_inflate_strides == 1) ? inputRow : ((inputRow >= 0) ? (inputRow / m_fastInputRowStride) : 0);
+    if (inputRow < 0 || inputRow >= m_input_rows_eff ||
+        ((m_row_inflate_strides != 1) && (inputRow != origInputRow * m_row_inflate_strides))) {
+      return Scalar(m_paddingValue);
+    }
+
+    // Calculate plane index in the original input tensor.
+    const Index planeIndex = patch3DIndex - m_outputPlanes * (colIndex * m_outputRows + rowIndex);
+    const Index planeOffset = patchOffset - colOffset * m_colStride - rowOffset * m_rowStride;
+    const Index inputPlane = planeIndex * m_plane_strides + planeOffset * m_in_plane_strides - m_planePaddingTop;
+    const Index origInputPlane =
+        (m_plane_inflate_strides == 1) ? inputPlane : ((inputPlane >= 0) ? (inputPlane / m_fastInputPlaneStride) : 0);
+    if (inputPlane < 0 || inputPlane >= m_input_planes_eff ||
+        ((m_plane_inflate_strides != 1) && (inputPlane != origInputPlane * m_plane_inflate_strides))) {
+      return Scalar(m_paddingValue);
+    }
+
+    constexpr int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
+    const Index depth = index - (index / m_fastOutputDepth) * m_dimensions[depth_index];
+
+    const Index inputIndex = depth + origInputRow * m_rowInputStride + origInputCol * m_colInputStride +
+                             origInputPlane * m_planeInputStride + otherIndex * m_otherInputStride;
+
+    return m_impl.coeff(inputIndex);
+  }
+
+  template <int LoadMode>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
+    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
+
+    if (m_in_row_strides != 1 || m_in_col_strides != 1 || m_row_inflate_strides != 1 || m_col_inflate_strides != 1 ||
+        m_in_plane_strides != 1 || m_plane_inflate_strides != 1) {
+      return packetWithPossibleZero(index);
+    }
+
+    const Index indices[2] = {index, index + PacketSize - 1};
+    const Index patchIndex = indices[0] / m_fastPatchStride;
+    if (patchIndex != indices[1] / m_fastPatchStride) {
+      return packetWithPossibleZero(index);
+    }
+    const Index otherIndex = (NumDims == 5) ? 0 : indices[0] / m_fastOtherStride;
+    eigen_assert(otherIndex == indices[1] / m_fastOtherStride);
+
+    // Find the offset of the element wrt the location of the first element.
+    Index first_entry = (indices[0] - patchIndex * m_patchStride) / m_fastOutputDepth;
+    Index second_entry = PacketSize == 1 ? first_entry : (indices[1] - patchIndex * m_patchStride) / m_fastOutputDepth;
+
+    const Index patchOffsets[2] = {first_entry, second_entry};
+
+    const Index patch3DIndex =
+        (NumDims == 5) ? patchIndex : (indices[0] - otherIndex * m_otherStride) / m_fastPatchStride;
+    eigen_assert(patch3DIndex == (indices[1] - otherIndex * m_otherStride) / m_fastPatchStride);
+
+    const Index colIndex = patch3DIndex / m_fastOutputPlanesRows;
+    const Index colOffsets[2] = {patchOffsets[0] / m_fastColStride, patchOffsets[1] / m_fastColStride};
+
+    // Calculate col indices in the original input tensor.
+    const Index inputCols[2] = {colIndex * m_col_strides + colOffsets[0] - m_colPaddingLeft,
+                                colIndex * m_col_strides + colOffsets[1] - m_colPaddingLeft};
+    if (inputCols[1] < 0 || inputCols[0] >= m_inputCols) {
+      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+    }
+
+    if (inputCols[0] != inputCols[1]) {
+      return packetWithPossibleZero(index);
+    }
+
+    const Index rowIndex = (patch3DIndex - colIndex * m_outputPlanesRows) / m_fastOutputPlanes;
+    const Index rowOffsets[2] = {(patchOffsets[0] - colOffsets[0] * m_colStride) / m_fastRowStride,
+                                 (patchOffsets[1] - colOffsets[1] * m_colStride) / m_fastRowStride};
+    eigen_assert(rowOffsets[0] <= rowOffsets[1]);
+    // Calculate row indices in the original input tensor.
+    const Index inputRows[2] = {rowIndex * m_row_strides + rowOffsets[0] - m_rowPaddingTop,
+                                rowIndex * m_row_strides + rowOffsets[1] - m_rowPaddingTop};
+
+    if (inputRows[1] < 0 || inputRows[0] >= m_inputRows) {
+      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+    }
+
+    if (inputRows[0] != inputRows[1]) {
+      return packetWithPossibleZero(index);
+    }
+
+    const Index planeIndex = patch3DIndex - m_outputPlanes * (colIndex * m_outputRows + rowIndex);
+    const Index planeOffsets[2] = {patchOffsets[0] - colOffsets[0] * m_colStride - rowOffsets[0] * m_rowStride,
+                                   patchOffsets[1] - colOffsets[1] * m_colStride - rowOffsets[1] * m_rowStride};
+    eigen_assert(planeOffsets[0] <= planeOffsets[1]);
+    const Index inputPlanes[2] = {planeIndex * m_plane_strides + planeOffsets[0] - m_planePaddingTop,
+                                  planeIndex * m_plane_strides + planeOffsets[1] - m_planePaddingTop};
+
+    if (inputPlanes[1] < 0 || inputPlanes[0] >= m_inputPlanes) {
+      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
+    }
+
+    if (inputPlanes[0] >= 0 && inputPlanes[1] < m_inputPlanes) {
+      // no padding
+      constexpr int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
+      const Index depth = index - (index / m_fastOutputDepth) * m_dimensions[depth_index];
+      const Index inputIndex = depth + inputRows[0] * m_rowInputStride + inputCols[0] * m_colInputStride +
+                               m_planeInputStride * inputPlanes[0] + otherIndex * m_otherInputStride;
+      return m_impl.template packet<Unaligned>(inputIndex);
+    }
+
+    return packetWithPossibleZero(index);
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
+    const size_t target_size = m_device.firstLevelCacheSize();
+    // In-bounds output coefficients read the argument once and every output
+    // coefficient is stored once (padding runs make this a slight
+    // over-estimate). Pass the full cost explicitly rather than adding to
+    // skewed()'s default load+store seed, which would double-count the
+    // baseline byte traffic and halve the tile size.
+    const TensorOpCost cost_per_coeff = m_impl.costPerCoeff(/*vectorized=*/false) + TensorOpCost(0, sizeof(Scalar), 0);
+    return internal::TensorBlockResourceRequirements::withShapeAndSize<Scalar>(
+        internal::TensorBlockShapeType::kSkewedInnerDims, target_size, cost_per_coeff);
+  }
+
+  // Materializes the block by iterating patch/col/row/plane coordinates and
+  // either copying the (always input-contiguous) depth run or filling it with
+  // the padding value. All per-coordinate index math and bounds checks are
+  // amortized over a whole depth run instead of paid per coefficient.
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
+                                                          bool /*root_of_expr_ast*/ = false) const {
+    constexpr bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+
+    if (desc.size() == 0) {
+      return TensorBlock(internal::TensorBlockKind::kView, nullptr, desc.dimensions());
+    }
+
+    typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
+    Scalar* block_buffer = block_storage.data();
+
+    // Output coordinates of the block's corner.
+    const DSizes<Index, NumDims> output_strides = internal::strides<Layout>(m_dimensions);
+    array<Index, NumDims> coords;
+    Index remaining = desc.offset();
+    EIGEN_IF_CONSTEXPR (is_col_major) {
+      for (int i = NumDims - 1; i > 0; --i) {
+        coords[i] = remaining / output_strides[i];
+        remaining -= coords[i] * output_strides[i];
+      }
+      coords[0] = remaining;
+    } else {
+      for (int i = 0; i < NumDims - 1; ++i) {
+        coords[i] = remaining / output_strides[i];
+        remaining -= coords[i] * output_strides[i];
+      }
+      coords[NumDims - 1] = remaining;
+    }
+
+    // Output dimensions: depth, patch plane/row/col offset, 3d patch index.
+    const int dd = is_col_major ? 0 : NumDims - 1;
+    const int nd = is_col_major ? 1 : NumDims - 2;
+    const int rd = is_col_major ? 2 : NumDims - 3;
+    const int cd = is_col_major ? 3 : NumDims - 4;
+    const int pd = is_col_major ? 4 : NumDims - 5;
+
+    const Index depth_start = coords[dd];
+    const Index depth_size = desc.dimension(dd);
+    const Index plane_start = coords[nd];
+    const Index plane_size = desc.dimension(nd);
+    const Index row_start = coords[rd];
+    const Index row_size = desc.dimension(rd);
+    const Index col_start = coords[cd];
+    const Index col_size = desc.dimension(cd);
+    const Index patch_start = coords[pd];
+    const Index patch_size = desc.dimension(pd);
+
+    // Odometer over the remaining (batch etc.) dimensions, tracking the input
+    // offset they contribute.
+    array<Index, NumDims> other_sizes;
+    array<Index, NumDims> other_src_stride;
+    array<Index, NumDims> other_count;
+    int num_other = 0;
+    Index src_other = 0;
+    {
+      Index in_stride = m_otherInputStride;
+      for (int k = 5; k < NumDims; ++k) {
+        const int d = is_col_major ? k : NumDims - 1 - k;
+        other_sizes[num_other] = desc.dimension(d);
+        other_src_stride[num_other] = in_stride;
+        other_count[num_other] = 0;
+        src_other += coords[d] * in_stride;
+        in_stride *= m_dimensions[d];
+        ++num_other;
+      }
+    }
+
+    typedef internal::StridedLinearBufferCopy<Scalar, Index> LinCopy;
+
+    // The loop nest below visits the block in exactly its memory order (the
+    // storage returned by prepareStorage() is dense with the block's own
+    // layout-order strides), so the destination is one running cursor.
+    Index dst = 0;
+    for (;;) {
+      for (Index p = 0; p < patch_size; ++p) {
+        const Index patch3DIndex = patch_start + p;
+        const Index colIndex = patch3DIndex / m_fastOutputPlanesRows;
+        const Index rowIndex = (patch3DIndex - colIndex * m_outputPlanesRows) / m_fastOutputPlanes;
+        const Index planeIndex = patch3DIndex - m_outputPlanes * (colIndex * m_outputRows + rowIndex);
+
+        for (Index c = 0; c < col_size; ++c) {
+          const Index colOffset = col_start + c;
+          const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
+          Index origInputCol = inputCol;
+          bool col_valid = inputCol >= 0 && inputCol < m_input_cols_eff;
+          if (col_valid && m_col_inflate_strides != 1) {
+            origInputCol = inputCol / m_fastInputColStride;
+            col_valid = (inputCol == origInputCol * m_col_inflate_strides);
+          }
+
+          for (Index r = 0; r < row_size; ++r) {
+            const Index rowOffset = row_start + r;
+            bool row_valid = col_valid;
+            Index origInputRow = 0;
+            if (row_valid) {
+              const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
+              row_valid = inputRow >= 0 && inputRow < m_input_rows_eff;
+              if (row_valid) {
+                origInputRow = inputRow;
+                if (m_row_inflate_strides != 1) {
+                  origInputRow = inputRow / m_fastInputRowStride;
+                  row_valid = (inputRow == origInputRow * m_row_inflate_strides);
+                }
+              }
+            }
+
+            for (Index n = 0; n < plane_size; ++n) {
+              const Index planeOffset = plane_start + n;
+              bool valid = row_valid;
+              Index origInputPlane = 0;
+              if (valid) {
+                const Index inputPlane =
+                    planeIndex * m_plane_strides + planeOffset * m_in_plane_strides - m_planePaddingTop;
+                valid = inputPlane >= 0 && inputPlane < m_input_planes_eff;
+                if (valid) {
+                  origInputPlane = inputPlane;
+                  if (m_plane_inflate_strides != 1) {
+                    origInputPlane = inputPlane / m_fastInputPlaneStride;
+                    valid = (inputPlane == origInputPlane * m_plane_inflate_strides);
+                  }
+                }
+              }
+
+              if (valid) {
+                const Index src = depth_start + origInputPlane * m_planeInputStride + origInputRow * m_rowInputStride +
+                                  origInputCol * m_colInputStride + src_other;
+                for (Index d = 0; d < depth_size; ++d) {
+                  block_buffer[dst + d] = m_impl.coeff(src + d);
+                }
+              } else {
+                LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(dst, 1, block_buffer),
+                                                                 typename LinCopy::Src(0, 0, &m_paddingValue),
+                                                                 depth_size);
+              }
+              dst += depth_size;
+            }
+          }
+        }
+      }
+
+      int k = 0;
+      for (; k < num_other; ++k) {
+        if (++other_count[k] < other_sizes[k]) {
+          src_other += other_src_stride[k];
+          break;
+        }
+        other_count[k] = 0;
+        src_other -= other_src_stride[k] * (other_sizes[k] - 1);
+      }
+      if (k == num_other) break;
+    }
+    eigen_assert(dst == desc.size());
+
+    return block_storage.AsTensorMaterializedBlock();
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
+    const double compute_cost =
+        10 * TensorOpCost::DivCost<Index>() + 21 * TensorOpCost::MulCost<Index>() + 8 * TensorOpCost::AddCost<Index>();
+    return TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
+  }
+
+  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
+
+  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index planePaddingTop() const { return m_planePaddingTop; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowPaddingTop() const { return m_rowPaddingTop; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colPaddingLeft() const { return m_colPaddingLeft; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputPlanes() const { return m_outputPlanes; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputRows() const { return m_outputRows; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputCols() const { return m_outputCols; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userPlaneStride() const { return m_plane_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userRowStride() const { return m_row_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userColStride() const { return m_col_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInPlaneStride() const { return m_in_plane_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInRowStride() const { return m_in_row_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInColStride() const { return m_in_col_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index planeInflateStride() const { return m_plane_inflate_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowInflateStride() const { return m_row_inflate_strides; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colInflateStride() const { return m_col_inflate_strides; }
+
+ protected:
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetWithPossibleZero(Index index) const {
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<PacketReturnType>::alignment)
+    std::remove_const_t<CoeffReturnType> values[PacketSize];
+    EIGEN_UNROLL_LOOP
+    for (int i = 0; i < PacketSize; ++i) {
+      values[i] = coeff(index + i);
+    }
+    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
+    return rslt;
+  }
+
+  Dimensions m_dimensions;
+
+  // Parameters passed to the constructor.
+  Index m_plane_strides;
+  Index m_row_strides;
+  Index m_col_strides;
+
+  Index m_outputPlanes;
+  Index m_outputRows;
+  Index m_outputCols;
+
+  Index m_planePaddingTop;
+  Index m_rowPaddingTop;
+  Index m_colPaddingLeft;
+
+  Index m_in_plane_strides;
+  Index m_in_row_strides;
+  Index m_in_col_strides;
+
+  Index m_plane_inflate_strides;
+  Index m_row_inflate_strides;
+  Index m_col_inflate_strides;
+
+  // Cached input size.
+  Index m_inputDepth;
+  Index m_inputPlanes;
+  Index m_inputRows;
+  Index m_inputCols;
+
+  // Other cached variables.
+  Index m_outputPlanesRows;
+
+  // Effective input/patch post-inflation size.
+  Index m_input_planes_eff;
+  Index m_input_rows_eff;
+  Index m_input_cols_eff;
+  Index m_patch_planes_eff;
+  Index m_patch_rows_eff;
+  Index m_patch_cols_eff;
+
+  // Strides for the output tensor.
+  Index m_otherStride;
+  Index m_patchStride;
+  Index m_rowStride;
+  Index m_colStride;
+
+  // Strides for the input tensor.
+  Index m_planeInputStride;
+  Index m_rowInputStride;
+  Index m_colInputStride;
+  Index m_otherInputStride;
+
+  internal::TensorIntDivisor<Index> m_fastOtherStride;
+  internal::TensorIntDivisor<Index> m_fastPatchStride;
+  internal::TensorIntDivisor<Index> m_fastColStride;
+  internal::TensorIntDivisor<Index> m_fastRowStride;
+  internal::TensorIntDivisor<Index> m_fastInputPlaneStride;
+  internal::TensorIntDivisor<Index> m_fastInputRowStride;
+  internal::TensorIntDivisor<Index> m_fastInputColStride;
+  internal::TensorIntDivisor<Index> m_fastInputColsEff;
+  internal::TensorIntDivisor<Index> m_fastOutputPlanesRows;
+  internal::TensorIntDivisor<Index> m_fastOutputPlanes;
+  internal::TensorIntDivisor<Index> m_fastOutputDepth;
+
+  Scalar m_paddingValue;
+
+  TensorEvaluator<ArgType, Device> m_impl;
+  const Device EIGEN_DEVICE_REF m_device;
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSOR_TENSOR_VOLUME_PATCH_H
diff --git a/contrib/Eigen/src/TensorSymmetry/DynamicSymmetry.h b/contrib/Eigen/src/TensorSymmetry/DynamicSymmetry.h
new file mode 100644
index 0000000..b548506
--- /dev/null
+++ b/contrib/Eigen/src/TensorSymmetry/DynamicSymmetry.h
@@ -0,0 +1,297 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSORSYMMETRY_DYNAMICSYMMETRY_H
+#define EIGEN_TENSORSYMMETRY_DYNAMICSYMMETRY_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+class DynamicSGroup {
+ public:
+  inline explicit DynamicSGroup() : m_numIndices(1), m_elements(), m_generators(), m_globalFlags(0) {
+    m_elements.push_back(ge(Generator(0, 0, 0)));
+  }
+  inline DynamicSGroup(const DynamicSGroup& o)
+      : m_numIndices(o.m_numIndices),
+        m_elements(o.m_elements),
+        m_generators(o.m_generators),
+        m_globalFlags(o.m_globalFlags) {}
+  inline DynamicSGroup(DynamicSGroup&& o)
+      : m_numIndices(o.m_numIndices), m_elements(), m_generators(o.m_generators), m_globalFlags(o.m_globalFlags) {
+    std::swap(m_elements, o.m_elements);
+  }
+  inline DynamicSGroup& operator=(const DynamicSGroup& o) {
+    m_numIndices = o.m_numIndices;
+    m_elements = o.m_elements;
+    m_generators = o.m_generators;
+    m_globalFlags = o.m_globalFlags;
+    return *this;
+  }
+  inline DynamicSGroup& operator=(DynamicSGroup&& o) {
+    m_numIndices = o.m_numIndices;
+    std::swap(m_elements, o.m_elements);
+    m_generators = o.m_generators;
+    m_globalFlags = o.m_globalFlags;
+    return *this;
+  }
+
+  void add(int one, int two, int flags = 0);
+
+  template <typename Gen_>
+  inline void add(Gen_) {
+    add(Gen_::One, Gen_::Two, Gen_::Flags);
+  }
+  inline void addSymmetry(int one, int two) { add(one, two, 0); }
+  inline void addAntiSymmetry(int one, int two) { add(one, two, NegationFlag); }
+  inline void addHermiticity(int one, int two) { add(one, two, ConjugationFlag); }
+  inline void addAntiHermiticity(int one, int two) { add(one, two, NegationFlag | ConjugationFlag); }
+
+  template <typename Op, typename RV, typename Index, std::size_t N, typename... Args>
+  inline RV apply(const std::array<Index, N>& idx, RV initial, Args&&... args) const {
+    eigen_assert(N >= m_numIndices &&
+                 "Can only apply symmetry group to objects that have at least the required amount of indices.");
+    for (std::size_t i = 0; i < size(); i++)
+      initial = Op::run(h_permute(i, idx, std::make_integer_sequence<int, N>{}), m_elements[i].flags, initial,
+                        std::forward<Args>(args)...);
+    return initial;
+  }
+
+  template <typename Op, typename RV, typename Index, typename... Args>
+  inline RV apply(const std::vector<Index>& idx, RV initial, Args&&... args) const {
+    eigen_assert(idx.size() >= m_numIndices &&
+                 "Can only apply symmetry group to objects that have at least the required amount of indices.");
+    for (std::size_t i = 0; i < size(); i++)
+      initial = Op::run(h_permute(i, idx), m_elements[i].flags, initial, std::forward<Args>(args)...);
+    return initial;
+  }
+
+  inline int globalFlags() const { return m_globalFlags; }
+  inline std::size_t size() const { return m_elements.size(); }
+
+  template <typename Tensor_, typename... IndexTypes>
+  inline internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup> operator()(Tensor_& tensor,
+                                                                                   typename Tensor_::Index firstIndex,
+                                                                                   IndexTypes... otherIndices) const {
+    static_assert(sizeof...(otherIndices) + 1 == Tensor_::NumIndices,
+                  "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
+    return operator()(tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices>{{firstIndex, otherIndices...}});
+  }
+
+  template <typename Tensor_>
+  inline internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup> operator()(
+      Tensor_& tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices> const& indices) const {
+    return internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup>(tensor, *this, indices);
+  }
+
+ private:
+  struct GroupElement {
+    std::vector<int> representation;
+    int flags;
+    bool isId() const {
+      for (std::size_t i = 0; i < representation.size(); i++)
+        if (i != (size_t)representation[i]) return false;
+      return true;
+    }
+  };
+  struct Generator {
+    int one;
+    int two;
+    int flags;
+    constexpr Generator(int one_, int two_, int flags_) : one(one_), two(two_), flags(flags_) {}
+  };
+
+  std::size_t m_numIndices;
+  std::vector<GroupElement> m_elements;
+  std::vector<Generator> m_generators;
+  int m_globalFlags;
+
+  template <typename Index, std::size_t N, int... n>
+  inline std::array<Index, N> h_permute(std::size_t which, const std::array<Index, N>& idx,
+                                        std::integer_sequence<int, n...>) const {
+    return std::array<Index, N>{{idx[n >= m_numIndices ? n : m_elements[which].representation[n]]...}};
+  }
+
+  template <typename Index>
+  inline std::vector<Index> h_permute(std::size_t which, const std::vector<Index>& idx) const {
+    std::vector<Index> result;
+    result.reserve(idx.size());
+    for (auto k : m_elements[which].representation) result.push_back(idx[k]);
+    for (std::size_t i = m_numIndices; i < idx.size(); i++) result.push_back(idx[i]);
+    return result;
+  }
+
+  inline GroupElement ge(Generator const& g) const {
+    GroupElement result;
+    result.representation.reserve(m_numIndices);
+    result.flags = g.flags;
+    for (std::size_t k = 0; k < m_numIndices; k++) {
+      if (k == (std::size_t)g.one)
+        result.representation.push_back(g.two);
+      else if (k == (std::size_t)g.two)
+        result.representation.push_back(g.one);
+      else
+        result.representation.push_back(int(k));
+    }
+    return result;
+  }
+
+  GroupElement mul(GroupElement, GroupElement) const;
+  inline GroupElement mul(Generator g1, GroupElement g2) const { return mul(ge(g1), g2); }
+
+  inline GroupElement mul(GroupElement g1, Generator g2) const { return mul(g1, ge(g2)); }
+
+  inline GroupElement mul(Generator g1, Generator g2) const { return mul(ge(g1), ge(g2)); }
+
+  inline int findElement(GroupElement e) const {
+    for (auto ee : m_elements) {
+      if (ee.representation == e.representation) return ee.flags ^ e.flags;
+    }
+    return -1;
+  }
+
+  void updateGlobalFlags(int flagDiffOfSameGenerator);
+};
+
+// dynamic symmetry group that auto-adds the template parameters in the constructor
+template <typename... Gen>
+class DynamicSGroupFromTemplateArgs : public DynamicSGroup {
+ public:
+  inline DynamicSGroupFromTemplateArgs() : DynamicSGroup() { add_all(internal::type_list<Gen...>()); }
+  inline DynamicSGroupFromTemplateArgs(DynamicSGroupFromTemplateArgs const& other) = default;
+  inline DynamicSGroupFromTemplateArgs(DynamicSGroupFromTemplateArgs&& other) : DynamicSGroup(other) {}
+  inline DynamicSGroupFromTemplateArgs<Gen...>& operator=(const DynamicSGroupFromTemplateArgs<Gen...>& o) {
+    DynamicSGroup::operator=(o);
+    return *this;
+  }
+  inline DynamicSGroupFromTemplateArgs<Gen...>& operator=(DynamicSGroupFromTemplateArgs<Gen...>&& o) {
+    DynamicSGroup::operator=(o);
+    return *this;
+  }
+
+ private:
+  template <typename Gen1, typename... GenNext>
+  inline void add_all(internal::type_list<Gen1, GenNext...>) {
+    add(Gen1());
+    add_all(internal::type_list<GenNext...>());
+  }
+
+  inline void add_all(internal::type_list<>) {}
+};
+
+inline DynamicSGroup::GroupElement DynamicSGroup::mul(GroupElement g1, GroupElement g2) const {
+  eigen_internal_assert(g1.representation.size() == m_numIndices);
+  eigen_internal_assert(g2.representation.size() == m_numIndices);
+
+  GroupElement result;
+  result.representation.reserve(m_numIndices);
+  for (std::size_t i = 0; i < m_numIndices; i++) {
+    int v = g2.representation[g1.representation[i]];
+    eigen_assert(v >= 0);
+    result.representation.push_back(v);
+  }
+  result.flags = g1.flags ^ g2.flags;
+  return result;
+}
+
+inline void DynamicSGroup::add(int one, int two, int flags) {
+  eigen_assert(one >= 0);
+  eigen_assert(two >= 0);
+  eigen_assert(one != two);
+
+  if ((std::size_t)one >= m_numIndices || (std::size_t)two >= m_numIndices) {
+    std::size_t newNumIndices = (one > two) ? one : two + 1;
+    for (auto& gelem : m_elements) {
+      gelem.representation.reserve(newNumIndices);
+      for (std::size_t i = m_numIndices; i < newNumIndices; i++) gelem.representation.push_back(static_cast<int>(i));
+    }
+    m_numIndices = newNumIndices;
+  }
+
+  Generator g{one, two, flags};
+  GroupElement e = ge(g);
+
+  /* special case for first generator */
+  if (m_elements.size() == 1) {
+    while (!e.isId()) {
+      m_elements.push_back(e);
+      e = mul(e, g);
+    }
+
+    if (e.flags > 0) updateGlobalFlags(e.flags);
+
+    // only add in case we didn't have identity
+    if (m_elements.size() > 1) m_generators.push_back(g);
+    return;
+  }
+
+  int p = findElement(e);
+  if (p >= 0) {
+    updateGlobalFlags(p);
+    return;
+  }
+
+  std::size_t coset_order = m_elements.size();
+  m_elements.push_back(e);
+  for (std::size_t i = 1; i < coset_order; i++) m_elements.push_back(mul(m_elements[i], e));
+  m_generators.push_back(g);
+
+  std::size_t coset_rep = coset_order;
+  do {
+    for (auto gen : m_generators) {
+      e = mul(m_elements[coset_rep], gen);
+      p = findElement(e);
+      if (p < 0) {
+        // element not yet in group
+        m_elements.push_back(e);
+        for (std::size_t i = 1; i < coset_order; i++) m_elements.push_back(mul(m_elements[i], e));
+      } else if (p > 0) {
+        updateGlobalFlags(p);
+      }
+    }
+    coset_rep += coset_order;
+  } while (coset_rep < m_elements.size());
+}
+
+inline void DynamicSGroup::updateGlobalFlags(int flagDiffOfSameGenerator) {
+  switch (flagDiffOfSameGenerator) {
+    case 0:
+    default:
+      // nothing happened
+      break;
+    case NegationFlag:
+      // every element is its own negative => whole tensor is zero
+      m_globalFlags |= GlobalZeroFlag;
+      break;
+    case ConjugationFlag:
+      // every element is its own conjugate => whole tensor is real
+      m_globalFlags |= GlobalRealFlag;
+      break;
+    case (NegationFlag | ConjugationFlag):
+      // every element is its own negative conjugate => whole tensor is imaginary
+      m_globalFlags |= GlobalImagFlag;
+      break;
+      /* NOTE:
+       *   since GlobalZeroFlag == GlobalRealFlag | GlobalImagFlag, if one generator
+       *   causes the tensor to be real and the next one to be imaginary, this will
+       *   trivially give the correct result
+       */
+  }
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSORSYMMETRY_DYNAMICSYMMETRY_H
+
+/*
+ * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
+ */
diff --git a/contrib/Eigen/src/TensorSymmetry/InternalHeaderCheck.h b/contrib/Eigen/src/TensorSymmetry/InternalHeaderCheck.h
new file mode 100644
index 0000000..547afdc
--- /dev/null
+++ b/contrib/Eigen/src/TensorSymmetry/InternalHeaderCheck.h
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSORSYMMETRY_MODULE_H
+#error "Please include contrib/Eigen/TensorSymmetry instead of including headers inside the src directory directly."
+#endif
diff --git a/contrib/Eigen/src/TensorSymmetry/StaticSymmetry.h b/contrib/Eigen/src/TensorSymmetry/StaticSymmetry.h
new file mode 100644
index 0000000..aef04e4
--- /dev/null
+++ b/contrib/Eigen/src/TensorSymmetry/StaticSymmetry.h
@@ -0,0 +1,218 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSORSYMMETRY_STATICSYMMETRY_H
+#define EIGEN_TENSORSYMMETRY_STATICSYMMETRY_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+template <typename indices_, int flags_>
+struct tensor_static_symgroup_element {
+  typedef indices_ indices;
+  constexpr static int flags = flags_;
+};
+
+template <typename Gen, int... indices>
+constexpr std::integer_sequence<int,
+                                ((indices == Gen::One) ? Gen::Two : ((indices == Gen::Two) ? Gen::One : indices))...>
+tensor_static_symgroup_swapped_indices(std::integer_sequence<int, indices...>) {
+  return {};
+}
+
+template <typename Gen, int N>
+struct tensor_static_symgroup_element_ctor {
+  typedef tensor_static_symgroup_element<
+      decltype(tensor_static_symgroup_swapped_indices<Gen>(std::make_integer_sequence<int, N>{})), Gen::Flags>
+      type;
+};
+
+template <int N>
+struct tensor_static_symgroup_identity_ctor {
+  typedef tensor_static_symgroup_element<std::make_integer_sequence<int, N>, 0> type;
+};
+
+template <typename iib>
+struct tensor_static_symgroup_multiply_helper {
+  template <int... iia>
+  constexpr static std::integer_sequence<int, get<iia, iib>::value...> helper(std::integer_sequence<int, iia...>) {
+    return {};
+  }
+};
+
+template <typename A, typename B>
+struct tensor_static_symgroup_multiply {
+ private:
+  typedef typename A::indices iia;
+  typedef typename B::indices iib;
+  constexpr static int ffa = A::flags;
+  constexpr static int ffb = B::flags;
+
+ public:
+  static_assert(iia::size() == iib::size(), "Cannot multiply symmetry elements with different number of indices.");
+
+  typedef tensor_static_symgroup_element<decltype(tensor_static_symgroup_multiply_helper<iib>::helper(iia())),
+                                         ffa ^ ffb>
+      type;
+};
+
+template <typename A, typename B>
+struct tensor_static_symgroup_equality {
+  typedef typename A::indices iia;
+  typedef typename B::indices iib;
+  constexpr static int ffa = A::flags;
+  constexpr static int ffb = B::flags;
+  static_assert(iia::size() == iib::size(), "Cannot compare symmetry elements with different number of indices.");
+
+  constexpr static bool value = std::is_same<iia, iib>::value;
+
+ private:
+  /* this should be zero if they are identical, or else the tensor
+   * will be forced to be pure real, pure imaginary or even pure zero
+   */
+  constexpr static int flags_cmp_ = ffa ^ ffb;
+
+  /* either they are not equal, then we don't care whether the flags
+   * match, or they are equal, and then we have to check
+   */
+  constexpr static bool is_zero = value && flags_cmp_ == NegationFlag;
+  constexpr static bool is_real = value && flags_cmp_ == ConjugationFlag;
+  constexpr static bool is_imag = value && flags_cmp_ == (NegationFlag | ConjugationFlag);
+
+ public:
+  constexpr static int global_flags =
+      (is_real ? GlobalRealFlag : 0) | (is_imag ? GlobalImagFlag : 0) | (is_zero ? GlobalZeroFlag : 0);
+};
+
+template <std::size_t NumIndices, typename... Gen>
+struct tensor_static_symgroup {
+  typedef StaticSGroup<Gen...> type;
+  constexpr static std::size_t size = type::static_size;
+};
+
+template <typename Index, std::size_t N, int... ii, int... jj>
+constexpr static std::array<Index, N> tensor_static_symgroup_index_permute(const std::array<Index, N>& idx,
+                                                                           std::integer_sequence<int, ii...>,
+                                                                           std::integer_sequence<int, jj...>) {
+  return {{idx[ii]..., idx[sizeof...(ii) + jj]...}};
+}
+
+template <typename Index, int... ii>
+static inline std::vector<Index> tensor_static_symgroup_index_permute(const std::vector<Index>& idx,
+                                                                      std::integer_sequence<int, ii...>) {
+  std::vector<Index> result{{idx[ii]...}};
+  std::size_t target_size = idx.size();
+  for (std::size_t i = result.size(); i < target_size; i++) result.push_back(idx[i]);
+  return result;
+}
+
+template <typename T>
+struct tensor_static_symgroup_do_apply;
+
+template <typename first, typename... next>
+struct tensor_static_symgroup_do_apply<internal::type_list<first, next...>> {
+  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, std::size_t NumIndices,
+            typename... Args>
+  static inline RV run(const std::array<Index, NumIndices>& idx, RV initial, Args&&... args) {
+    static_assert(NumIndices >= SGNumIndices,
+                  "Can only apply symmetry group to objects that have at least the required amount of indices.");
+    initial = Op::run(tensor_static_symgroup_index_permute(
+                          idx, typename first::indices(), std::make_integer_sequence<int, NumIndices - SGNumIndices>{}),
+                      first::flags, initial, std::forward<Args>(args)...);
+    return tensor_static_symgroup_do_apply<internal::type_list<next...>>::template run<Op, RV, SGNumIndices>(
+        idx, initial, args...);
+  }
+
+  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, typename... Args>
+  static inline RV run(const std::vector<Index>& idx, RV initial, Args&&... args) {
+    eigen_assert(idx.size() >= SGNumIndices &&
+                 "Can only apply symmetry group to objects that have at least the required amount of indices.");
+    initial = Op::run(tensor_static_symgroup_index_permute(idx, typename first::indices()), first::flags, initial,
+                      std::forward<Args>(args)...);
+    return tensor_static_symgroup_do_apply<internal::type_list<next...>>::template run<Op, RV, SGNumIndices>(
+        idx, initial, args...);
+  }
+};
+
+template <>
+struct tensor_static_symgroup_do_apply<internal::type_list<>> {
+  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, std::size_t NumIndices,
+            typename... Args>
+  static inline RV run(const std::array<Index, NumIndices>&, RV initial, Args&&...) {
+    // do nothing
+    return initial;
+  }
+
+  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, typename... Args>
+  static inline RV run(const std::vector<Index>&, RV initial, Args&&...) {
+    // do nothing
+    return initial;
+  }
+};
+
+}  // end namespace internal
+
+template <typename... Gen>
+class StaticSGroup {
+  constexpr static std::size_t NumIndices = internal::tensor_symmetry_num_indices<Gen...>::value;
+  typedef internal::group_theory::enumerate_group_elements<
+      internal::tensor_static_symgroup_multiply, internal::tensor_static_symgroup_equality,
+      typename internal::tensor_static_symgroup_identity_ctor<NumIndices>::type,
+      internal::type_list<typename internal::tensor_static_symgroup_element_ctor<Gen, NumIndices>::type...>>
+      group_elements;
+  typedef typename group_elements::type ge;
+
+ public:
+  constexpr StaticSGroup() = default;
+  constexpr StaticSGroup(const StaticSGroup<Gen...>&) = default;
+  constexpr StaticSGroup(StaticSGroup<Gen...>&&) = default;
+
+  template <typename Op, typename RV, typename Index, std::size_t N, typename... Args>
+  static inline RV apply(const std::array<Index, N>& idx, RV initial, Args&&... args) {
+    return internal::tensor_static_symgroup_do_apply<ge>::template run<Op, RV, NumIndices>(idx, initial, args...);
+  }
+
+  template <typename Op, typename RV, typename Index, typename... Args>
+  static inline RV apply(const std::vector<Index>& idx, RV initial, Args&&... args) {
+    eigen_assert(idx.size() == NumIndices);
+    return internal::tensor_static_symgroup_do_apply<ge>::template run<Op, RV, NumIndices>(idx, initial, args...);
+  }
+
+  constexpr static std::size_t static_size = ge::count;
+
+  constexpr static std::size_t size() { return ge::count; }
+  constexpr static int globalFlags() { return group_elements::global_flags; }
+
+  template <typename Tensor_, typename... IndexTypes>
+  inline internal::tensor_symmetry_value_setter<Tensor_, StaticSGroup<Gen...>> operator()(
+      Tensor_& tensor, typename Tensor_::Index firstIndex, IndexTypes... otherIndices) const {
+    static_assert(sizeof...(otherIndices) + 1 == Tensor_::NumIndices,
+                  "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
+    return operator()(tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices>{{firstIndex, otherIndices...}});
+  }
+
+  template <typename Tensor_>
+  inline internal::tensor_symmetry_value_setter<Tensor_, StaticSGroup<Gen...>> operator()(
+      Tensor_& tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices> const& indices) const {
+    return internal::tensor_symmetry_value_setter<Tensor_, StaticSGroup<Gen...>>(tensor, *this, indices);
+  }
+};
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSORSYMMETRY_STATICSYMMETRY_H
+
+/*
+ * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
+ */
diff --git a/contrib/Eigen/src/TensorSymmetry/Symmetry.h b/contrib/Eigen/src/TensorSymmetry/Symmetry.h
new file mode 100644
index 0000000..26a874b
--- /dev/null
+++ b/contrib/Eigen/src/TensorSymmetry/Symmetry.h
@@ -0,0 +1,335 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSORSYMMETRY_SYMMETRY_H
+#define EIGEN_TENSORSYMMETRY_SYMMETRY_H
+
+// IWYU pragma: private
+#include "./InternalHeaderCheck.h"
+
+namespace Eigen {
+
+enum { NegationFlag = 0x01, ConjugationFlag = 0x02 };
+
+enum { GlobalRealFlag = 0x01, GlobalImagFlag = 0x02, GlobalZeroFlag = 0x03 };
+
+namespace internal {
+
+template <std::size_t NumIndices, typename... Sym>
+struct tensor_symmetry_pre_analysis;
+template <std::size_t NumIndices, typename... Sym>
+struct tensor_static_symgroup;
+template <bool instantiate, std::size_t NumIndices, typename... Sym>
+struct tensor_static_symgroup_if;
+template <typename Tensor_>
+struct tensor_symmetry_calculate_flags;
+template <typename Tensor_>
+struct tensor_symmetry_assign_value;
+template <typename... Sym>
+struct tensor_symmetry_num_indices;
+
+}  // end namespace internal
+
+template <int One_, int Two_>
+struct Symmetry {
+  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
+  constexpr static int One = One_;
+  constexpr static int Two = Two_;
+  constexpr static int Flags = 0;
+};
+
+template <int One_, int Two_>
+struct AntiSymmetry {
+  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
+  constexpr static int One = One_;
+  constexpr static int Two = Two_;
+  constexpr static int Flags = NegationFlag;
+};
+
+template <int One_, int Two_>
+struct Hermiticity {
+  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
+  constexpr static int One = One_;
+  constexpr static int Two = Two_;
+  constexpr static int Flags = ConjugationFlag;
+};
+
+template <int One_, int Two_>
+struct AntiHermiticity {
+  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
+  constexpr static int One = One_;
+  constexpr static int Two = Two_;
+  constexpr static int Flags = ConjugationFlag | NegationFlag;
+};
+
+/** \class DynamicSGroup
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Dynamic symmetry group
+ *
+ * The %DynamicSGroup class represents a symmetry group that need not be known at
+ * compile time. It is useful if one wants to support arbitrary run-time definable
+ * symmetries for tensors, but it is also instantiated if a symmetry group is defined
+ * at compile time that would be either too large for the compiler to reasonably
+ * generate (using templates to calculate this at compile time is very inefficient)
+ * or that the compiler could generate the group but that it wouldn't make sense to
+ * unroll the loop for setting coefficients anymore.
+ */
+class DynamicSGroup;
+
+/** \internal
+ *
+ * \class DynamicSGroupFromTemplateArgs
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Dynamic symmetry group, initialized from template arguments
+ *
+ * This class is a child class of DynamicSGroup. It uses the template arguments
+ * specified to initialize itself.
+ */
+template <typename... Gen>
+class DynamicSGroupFromTemplateArgs;
+
+/** \class StaticSGroup
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Static symmetry group
+ *
+ * This class represents a symmetry group that is known and resolved completely
+ * at compile time. Ideally, no run-time penalty is incurred compared to the
+ * manual unrolling of the symmetry.
+ *
+ * <b><i>CAUTION:</i></b>
+ *
+ * Do not use this class directly for large symmetry groups. The compiler
+ * may run into a limit, or segfault or in the very least will take a very,
+ * very, very long time to compile the code. Use the SGroup class instead
+ * if you want a static group. That class contains logic that will
+ * automatically select the DynamicSGroup class instead if the symmetry
+ * group becomes too large. (In that case, unrolling may not even be
+ * beneficial.)
+ */
+template <typename... Gen>
+class StaticSGroup;
+
+/** \class SGroup
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Symmetry group, initialized from template arguments
+ *
+ * This class represents a symmetry group whose generators are already
+ * known at compile time. It may or may not be resolved at compile time,
+ * depending on the estimated size of the group.
+ *
+ * \sa StaticSGroup
+ * \sa DynamicSGroup
+ */
+template <typename... Gen>
+class SGroup : public internal::tensor_symmetry_pre_analysis<internal::tensor_symmetry_num_indices<Gen...>::value,
+                                                             Gen...>::root_type {
+ public:
+  constexpr static std::size_t NumIndices = internal::tensor_symmetry_num_indices<Gen...>::value;
+  typedef typename internal::tensor_symmetry_pre_analysis<NumIndices, Gen...>::root_type Base;
+
+  // make standard constructors + assignment operators public
+  inline SGroup() = default;
+  inline SGroup(const SGroup<Gen...>& other) = default;
+  inline SGroup(SGroup<Gen...>&& other) : Base(other) {}
+  inline SGroup<Gen...>& operator=(const SGroup<Gen...>& other) {
+    Base::operator=(other);
+    return *this;
+  }
+  inline SGroup<Gen...>& operator=(SGroup<Gen...>&& other) {
+    Base::operator=(other);
+    return *this;
+  }
+
+  // all else is defined in the base class
+};
+
+namespace internal {
+
+template <typename... Sym>
+struct tensor_symmetry_num_indices {
+  constexpr static std::size_t value = 1;
+};
+
+template <int One_, int Two_, typename... Sym>
+struct tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {
+ private:
+  constexpr static std::size_t One = static_cast<std::size_t>(One_);
+  constexpr static std::size_t Two = static_cast<std::size_t>(Two_);
+  constexpr static std::size_t Three = tensor_symmetry_num_indices<Sym...>::value;
+
+  constexpr static std::size_t maxOneTwoPlusOne = ((One > Two) ? One : Two) + 1;
+
+ public:
+  constexpr static std::size_t value = (maxOneTwoPlusOne > Three) ? maxOneTwoPlusOne : Three;
+};
+
+template <int One_, int Two_, typename... Sym>
+struct tensor_symmetry_num_indices<AntiSymmetry<One_, Two_>, Sym...>
+    : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};
+template <int One_, int Two_, typename... Sym>
+struct tensor_symmetry_num_indices<Hermiticity<One_, Two_>, Sym...>
+    : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};
+template <int One_, int Two_, typename... Sym>
+struct tensor_symmetry_num_indices<AntiHermiticity<One_, Two_>, Sym...>
+    : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};
+
+/** \internal
+ *
+ * \class tensor_symmetry_pre_analysis
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Pre-select whether to use a static or dynamic symmetry group
+ *
+ * When a symmetry group could in principle be determined at compile time,
+ * this template implements the logic whether to actually do that or whether
+ * to rather defer that to runtime.
+ *
+ * The logic is as follows:
+ * <dl>
+ * <dt><b>No generators (trivial symmetry):</b></dt>
+ * <dd>Use a trivial static group. Ideally, this has no performance impact
+ *     compared to not using symmetry at all. In practice, this might not
+ *     be the case.</dd>
+ * <dt><b>More than 4 generators:</b></dt>
+ * <dd>Calculate the group at run time, it is likely far too large for the
+ *     compiler to be able to properly generate it in a realistic time.</dd>
+ * <dt><b>Up to and including 4 generators:</b></dt>
+ * <dd>Actually enumerate all group elements, but then check how many there
+ *     are. If there are more than 16, it is unlikely that unrolling the
+ *     loop (as is done in the static compile-time case) is sensible, so
+ *     use a dynamic group instead. If there are at most 16 elements, actually
+ *     use that static group. Note that the largest group with 4 generators
+ *     still compiles with reasonable resources.</dd>
+ * </dl>
+ *
+ * Note: Example compile time performance with g++-4.6 on an Intel Core i5-3470
+ *       with 16 GiB RAM (all generators non-redundant and the subgroups don't
+ *       factorize):
+ *
+ *          # Generators          -O0 -ggdb               -O2
+ *          -------------------------------------------------------------------
+ *          1                 0.5 s  /   250 MiB     0.45s /   230 MiB
+ *          2                 0.5 s  /   260 MiB     0.5 s /   250 MiB
+ *          3                 0.65s  /   310 MiB     0.62s /   310 MiB
+ *          4                 2.2 s  /   860 MiB     1.7 s /   770 MiB
+ *          5               130   s  / 13000 MiB   120   s / 11000 MiB
+ *
+ * It is clear that everything is still very efficient up to 4 generators, then
+ * the memory and CPU requirements become unreasonable. Thus we only instantiate
+ * the template group theory logic if the number of generators supplied is 4 or
+ * lower, otherwise this will be forced to be done during runtime, where the
+ * algorithm is reasonably fast.
+ */
+template <std::size_t NumIndices>
+struct tensor_symmetry_pre_analysis<NumIndices> {
+  typedef StaticSGroup<> root_type;
+};
+
+template <std::size_t NumIndices, typename Gen_, typename... Gens_>
+struct tensor_symmetry_pre_analysis<NumIndices, Gen_, Gens_...> {
+  constexpr static std::size_t max_static_generators = 4;
+  constexpr static std::size_t max_static_elements = 16;
+  typedef tensor_static_symgroup_if<(sizeof...(Gens_) + 1 <= max_static_generators), NumIndices, Gen_, Gens_...> helper;
+  constexpr static std::size_t possible_size = helper::size;
+
+  typedef std::conditional_t<possible_size == 0 || possible_size >= max_static_elements,
+                             DynamicSGroupFromTemplateArgs<Gen_, Gens_...>, typename helper::type>
+      root_type;
+};
+
+template <bool instantiate, std::size_t NumIndices, typename... Gens>
+struct tensor_static_symgroup_if {
+  constexpr static std::size_t size = 0;
+  typedef void type;
+};
+
+template <std::size_t NumIndices, typename... Gens>
+struct tensor_static_symgroup_if<true, NumIndices, Gens...> : tensor_static_symgroup<NumIndices, Gens...> {};
+
+template <typename Tensor_>
+struct tensor_symmetry_assign_value {
+  typedef typename Tensor_::Index Index;
+  typedef typename Tensor_::Scalar Scalar;
+  constexpr static std::size_t NumIndices = Tensor_::NumIndices;
+
+  static inline int run(const std::array<Index, NumIndices>& transformed_indices, int transformation_flags, int dummy,
+                        Tensor_& tensor, const Scalar& value_) {
+    Scalar value(value_);
+    if (transformation_flags & ConjugationFlag) value = numext::conj(value);
+    if (transformation_flags & NegationFlag) value = -value;
+    tensor.coeffRef(transformed_indices) = value;
+    return dummy;
+  }
+};
+
+template <typename Tensor_>
+struct tensor_symmetry_calculate_flags {
+  typedef typename Tensor_::Index Index;
+  constexpr static std::size_t NumIndices = Tensor_::NumIndices;
+
+  static inline int run(const std::array<Index, NumIndices>& transformed_indices, int transform_flags,
+                        int current_flags, const std::array<Index, NumIndices>& orig_indices) {
+    if (transformed_indices == orig_indices) {
+      if (transform_flags & (ConjugationFlag | NegationFlag))
+        return current_flags | GlobalImagFlag;  // anti-hermitian diagonal
+      else if (transform_flags & ConjugationFlag)
+        return current_flags | GlobalRealFlag;  // hermitian diagonal
+      else if (transform_flags & NegationFlag)
+        return current_flags | GlobalZeroFlag;  // anti-symmetric diagonal
+    }
+    return current_flags;
+  }
+};
+
+template <typename Tensor_, typename Symmetry_, int Flags = 0>
+class tensor_symmetry_value_setter {
+ public:
+  typedef typename Tensor_::Index Index;
+  typedef typename Tensor_::Scalar Scalar;
+  constexpr static std::size_t NumIndices = Tensor_::NumIndices;
+
+  inline tensor_symmetry_value_setter(Tensor_& tensor, Symmetry_ const& symmetry,
+                                      std::array<Index, NumIndices> const& indices)
+      : m_tensor(tensor), m_symmetry(symmetry), m_indices(indices) {}
+
+  inline tensor_symmetry_value_setter<Tensor_, Symmetry_, Flags>& operator=(Scalar const& value) {
+    doAssign(value);
+    return *this;
+  }
+
+ private:
+  Tensor_& m_tensor;
+  Symmetry_ m_symmetry;
+  std::array<Index, NumIndices> m_indices;
+
+  inline void doAssign(Scalar const& value) {
+#ifdef EIGEN_TENSOR_SYMMETRY_CHECK_VALUES
+    int value_flags = m_symmetry.template apply<internal::tensor_symmetry_calculate_flags<Tensor_>, int>(
+        m_indices, m_symmetry.globalFlags(), m_indices);
+    if (value_flags & GlobalRealFlag) eigen_assert(numext::imag(value) == 0);
+    if (value_flags & GlobalImagFlag) eigen_assert(numext::real(value) == 0);
+#endif
+    m_symmetry.template apply<internal::tensor_symmetry_assign_value<Tensor_>, int>(m_indices, 0, m_tensor, value);
+  }
+};
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSORSYMMETRY_SYMMETRY_H
+
+/*
+ * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
+ */
diff --git a/contrib/Eigen/src/TensorSymmetry/util/TemplateGroupTheory.h b/contrib/Eigen/src/TensorSymmetry/util/TemplateGroupTheory.h
new file mode 100644
index 0000000..b704cf4
--- /dev/null
+++ b/contrib/Eigen/src/TensorSymmetry/util/TemplateGroupTheory.h
@@ -0,0 +1,491 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H
+#define EIGEN_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H
+
+// IWYU pragma: private
+#include "../InternalHeaderCheck.h"
+
+namespace Eigen {
+
+namespace internal {
+
+namespace group_theory {
+
+/** \internal
+ * \file src/TensorSymmetry/util/TemplateGroupTheory.h
+ * This file contains C++ templates that implement group theory algorithms.
+ *
+ * The algorithms allow for a compile-time analysis of finite groups.
+ *
+ * Currently only Dimino's algorithm is implemented, which returns a list
+ * of all elements in a group given a set of (possibly redundant) generators.
+ * (One could also do that with the so-called orbital algorithm, but that
+ * is much more expensive and usually has no advantages.)
+ */
+
+/**********************************************************************
+ *                "Ok kid, here is where it gets complicated."
+ *                         - Amelia Pond in the "Doctor Who" episode
+ *                           "The Big Bang"
+ *
+ * Dimino's algorithm
+ * ==================
+ *
+ * The following is Dimino's algorithm in sequential form:
+ *
+ * Input: identity element, list of generators, equality check,
+ *        multiplication operation
+ * Output: list of group elements
+ *
+ * 1. add identity element
+ * 2. remove identities from list of generators
+ * 3. add all powers of first generator that aren't the
+ *    identity element
+ * 4. go through all remaining generators:
+ *        a. if generator is already in the list of elements
+ *                -> do nothing
+ *        b. otherwise
+ *                i.   remember current # of elements
+ *                     (i.e. the size of the current subgroup)
+ *                ii.  add all current elements (which includes
+ *                     the identity) each multiplied from right
+ *                     with the current generator to the group
+ *                iii. add all remaining cosets that are generated
+ *                     by products of the new generator with itself
+ *                     and all other generators seen so far
+ *
+ * In functional form, this is implemented as a long set of recursive
+ * templates that have a complicated relationship.
+ *
+ * The main interface for Dimino's algorithm is the template
+ * enumerate_group_elements. All lists are implemented as variadic
+ * type_list<typename...> and std::integer_sequence<int, ...>
+ * templates.
+ *
+ * 'Calling' templates is usually done via typedefs.
+ *
+ * This algorithm is an extended version of the basic version. The
+ * extension consists in the fact that each group element has a set
+ * of flags associated with it. Multiplication of two group elements
+ * with each other results in a group element whose flags are the
+ * XOR of the flags of the previous elements. Each time the algorithm
+ * notices that a group element it just calculated is already in the
+ * list of current elements, the flags of both will be compared and
+ * added to the so-called 'global flags' of the group.
+ *
+ * The rationale behind this extension is that this allows not only
+ * for the description of symmetries between tensor indices, but
+ * also allows for the description of hermiticity, antisymmetry and
+ * antihermiticity. Negation and conjugation each are specific bit
+ * in the flags value and if two different ways to reach a group
+ * element lead to two different flags, this poses a constraint on
+ * the allowed values of the resulting tensor. For example, if a
+ * group element is reached both with and without the conjugation
+ * flags, it is clear that the resulting tensor has to be real.
+ *
+ * Note that this flag mechanism is quite generic and may have other
+ * uses beyond tensor properties.
+ *
+ * IMPORTANT:
+ *     This algorithm assumes the group to be finite. If you try to
+ *     run it with a group that's infinite, the algorithm will only
+ *     terminate once you hit a compiler limit (max template depth).
+ *     Also note that trying to use this implementation to create a
+ *     very large group will probably either make you hit the same
+ *     limit, cause the compiler to segfault or at the very least
+ *     take a *really* long time (hours, days, weeks - sic!) to
+ *     compile. It is not recommended to plug in more than 4
+ *     generators, unless they are independent of each other.
+ */
+
+/** \internal
+ *
+ * \class strip_identities
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Cleanse a list of group elements of the identity element
+ *
+ * This template is used to make a first pass through all initial
+ * generators of Dimino's algorithm and remove the identity
+ * elements.
+ *
+ * \sa enumerate_group_elements
+ */
+template <template <typename, typename> class Equality, typename id, typename L>
+struct strip_identities;
+
+template <template <typename, typename> class Equality, typename id, typename t, typename... ts>
+struct strip_identities<Equality, id, type_list<t, ts...>> {
+  typedef std::conditional_t<
+      Equality<id, t>::value, typename strip_identities<Equality, id, type_list<ts...>>::type,
+      typename concat<type_list<t>, typename strip_identities<Equality, id, type_list<ts...>>::type>::type>
+      type;
+  constexpr static int global_flags =
+      Equality<id, t>::global_flags | strip_identities<Equality, id, type_list<ts...>>::global_flags;
+};
+
+template <template <typename, typename> class Equality, typename id>
+struct strip_identities<Equality, id, type_list<>> {
+  typedef type_list<> type;
+  constexpr static int global_flags = 0;
+};
+
+/** \internal
+ *
+ * \class dimino_first_step_elements_helper
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Recursive template that adds powers of the first generator to the list of group elements
+ *
+ * This template calls itself recursively to add powers of the first
+ * generator to the list of group elements. It stops if it reaches
+ * the identity element again.
+ *
+ * \sa enumerate_group_elements, dimino_first_step_elements
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename g, typename current_element, typename elements,
+          bool dont_add_current_element  // = false
+          >
+struct dimino_first_step_elements_helper
+#ifndef EIGEN_PARSED_BY_DOXYGEN
+    :  // recursive inheritance is too difficult for Doxygen
+       public dimino_first_step_elements_helper<Multiply, Equality, id, g, typename Multiply<current_element, g>::type,
+                                                typename concat<elements, type_list<current_element>>::type,
+                                                Equality<typename Multiply<current_element, g>::type, id>::value> {
+};
+
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename g, typename current_element, typename elements>
+struct dimino_first_step_elements_helper<Multiply, Equality, id, g, current_element, elements, true>
+#endif  // EIGEN_PARSED_BY_DOXYGEN
+{
+  typedef elements type;
+  constexpr static int global_flags = Equality<current_element, id>::global_flags;
+};
+
+/** \internal
+ *
+ * \class dimino_first_step_elements
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Add all powers of the first generator to the list of group elements
+ *
+ * This template takes the first non-identity generator and generates the initial
+ * list of elements which consists of all powers of that generator. For a group
+ * with just one generator, it would be enumerated after this.
+ *
+ * \sa enumerate_group_elements
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename generators>
+struct dimino_first_step_elements {
+  typedef typename get<0, generators>::type first_generator;
+  typedef typename skip<1, generators>::type next_generators;
+  typedef type_list<first_generator> generators_done;
+
+  typedef dimino_first_step_elements_helper<Multiply, Equality, id, first_generator, first_generator, type_list<id>,
+                                            false>
+      helper;
+  typedef typename helper::type type;
+  constexpr static int global_flags = helper::global_flags;
+};
+
+/** \internal
+ *
+ * \class dimino_get_coset_elements
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Generate all elements of a specific coset
+ *
+ * This template generates all the elements of a specific coset by
+ * multiplying all elements in the given subgroup with the new
+ * coset representative. Note that the first element of the
+ * subgroup is always the identity element, so the first element of
+ * the result of this template is going to be the coset
+ * representative itself.
+ *
+ * Note that this template accepts an additional boolean parameter
+ * that specifies whether to actually generate the coset (true) or
+ * just return an empty list (false).
+ *
+ * \sa enumerate_group_elements, dimino_add_cosets_for_rep
+ */
+template <template <typename, typename> class Multiply, typename sub_group_elements, typename new_coset_rep,
+          bool generate_coset  // = true
+          >
+struct dimino_get_coset_elements {
+  typedef typename apply_op_from_right<Multiply, new_coset_rep, sub_group_elements>::type type;
+};
+
+template <template <typename, typename> class Multiply, typename sub_group_elements, typename new_coset_rep>
+struct dimino_get_coset_elements<Multiply, sub_group_elements, new_coset_rep, false> {
+  typedef type_list<> type;
+};
+
+/** \internal
+ *
+ * \class dimino_add_cosets_for_rep
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Recursive template for adding coset spaces
+ *
+ * This template multiplies the coset representative with a generator
+ * from the list of previous generators. If the new element is not in
+ * the group already, it adds the corresponding coset. Finally it
+ * proceeds to call itself with the next generator from the list.
+ *
+ * \sa enumerate_group_elements, dimino_add_all_coset_spaces
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename sub_group_elements, typename elements, typename generators, typename rep_element, int sub_group_size>
+struct dimino_add_cosets_for_rep;
+
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename sub_group_elements, typename elements, typename g, typename... gs, typename rep_element,
+          int sub_group_size>
+struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, type_list<g, gs...>, rep_element,
+                                 sub_group_size> {
+  typedef typename Multiply<rep_element, g>::type new_coset_rep;
+  typedef contained_in_list_gf<Equality, new_coset_rep, elements> _cil;
+  constexpr static bool add_coset = !_cil::value;
+
+  typedef
+      typename dimino_get_coset_elements<Multiply, sub_group_elements, new_coset_rep, add_coset>::type coset_elements;
+
+  typedef dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements,
+                                    typename concat<elements, coset_elements>::type, type_list<gs...>, rep_element,
+                                    sub_group_size>
+      _helper;
+
+  typedef typename _helper::type type;
+  constexpr static int global_flags = _cil::global_flags | _helper::global_flags;
+
+  /* Note that we don't have to update global flags here, since
+   * we will only add these elements if they are not part of
+   * the group already. But that only happens if the coset rep
+   * is not already in the group, so the check for the coset rep
+   * will catch this.
+   */
+};
+
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename sub_group_elements, typename elements, typename rep_element, int sub_group_size>
+struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, type_list<>, rep_element,
+                                 sub_group_size> {
+  typedef elements type;
+  constexpr static int global_flags = 0;
+};
+
+/** \internal
+ *
+ * \class dimino_add_all_coset_spaces
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Recursive template for adding all coset spaces for a new generator
+ *
+ * This template tries to go through the list of generators (with
+ * the help of the dimino_add_cosets_for_rep template) as long as
+ * it still finds elements that are not part of the group and add
+ * the corresponding cosets.
+ *
+ * \sa enumerate_group_elements, dimino_add_cosets_for_rep
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename sub_group_elements, typename elements, typename generators, int sub_group_size, int rep_pos,
+          bool stop_condition  // = false
+          >
+struct dimino_add_all_coset_spaces {
+  typedef typename get<rep_pos, elements>::type rep_element;
+  typedef dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, generators, rep_element,
+                                    sub_group_elements::count>
+      _ac4r;
+  typedef typename _ac4r::type new_elements;
+
+  constexpr static int new_rep_pos = rep_pos + sub_group_elements::count;
+  constexpr static bool new_stop_condition = new_rep_pos >= new_elements::count;
+
+  typedef dimino_add_all_coset_spaces<Multiply, Equality, id, sub_group_elements, new_elements, generators,
+                                      sub_group_size, new_rep_pos, new_stop_condition>
+      _helper;
+
+  typedef typename _helper::type type;
+  constexpr static int global_flags = _helper::global_flags | _ac4r::global_flags;
+};
+
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename sub_group_elements, typename elements, typename generators, int sub_group_size, int rep_pos>
+struct dimino_add_all_coset_spaces<Multiply, Equality, id, sub_group_elements, elements, generators, sub_group_size,
+                                   rep_pos, true> {
+  typedef elements type;
+  constexpr static int global_flags = 0;
+};
+
+/** \internal
+ *
+ * \class dimino_add_generator
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Enlarge the group by adding a new generator.
+ *
+ * It accepts a boolean parameter that determines if the generator is redundant,
+ * i.e. was already seen in the group. In that case, it reduces to a no-op.
+ *
+ * \sa enumerate_group_elements, dimino_add_all_coset_spaces
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename elements, typename generators_done, typename current_generator,
+          bool redundant  // = false
+          >
+struct dimino_add_generator {
+  /* this template is only called if the generator is not redundant
+   * => all elements of the group multiplied with the new generator
+   *    are going to be new elements of the most trivial coset space
+   */
+  typedef typename apply_op_from_right<Multiply, current_generator, elements>::type multiplied_elements;
+  typedef typename concat<elements, multiplied_elements>::type new_elements;
+
+  constexpr static int rep_pos = elements::count;
+
+  typedef dimino_add_all_coset_spaces<
+      Multiply, Equality, id,
+      elements,  // elements of previous subgroup
+      new_elements, typename concat<generators_done, type_list<current_generator>>::type,
+      elements::count,  // size of previous subgroup
+      rep_pos,
+      false  // don't stop (because rep_pos >= new_elements::count is always false at this point)
+      >
+      _helper;
+  typedef typename _helper::type type;
+  constexpr static int global_flags = _helper::global_flags;
+};
+
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename elements, typename generators_done, typename current_generator>
+struct dimino_add_generator<Multiply, Equality, id, elements, generators_done, current_generator, true> {
+  // redundant case
+  typedef elements type;
+  constexpr static int global_flags = 0;
+};
+
+/** \internal
+ *
+ * \class dimino_add_remaining_generators
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Recursive template that adds all remaining generators to a group
+ *
+ * Loop through the list of generators that remain and successively
+ * add them to the group.
+ *
+ * \sa enumerate_group_elements, dimino_add_generator
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename generators_done, typename remaining_generators, typename elements>
+struct dimino_add_remaining_generators {
+  typedef typename get<0, remaining_generators>::type first_generator;
+  typedef typename skip<1, remaining_generators>::type next_generators;
+
+  typedef contained_in_list_gf<Equality, first_generator, elements> _cil;
+
+  typedef dimino_add_generator<Multiply, Equality, id, elements, generators_done, first_generator, _cil::value> _helper;
+
+  typedef typename _helper::type new_elements;
+
+  typedef dimino_add_remaining_generators<Multiply, Equality, id,
+                                          typename concat<generators_done, type_list<first_generator>>::type,
+                                          next_generators, new_elements>
+      _next_iter;
+
+  typedef typename _next_iter::type type;
+  constexpr static int global_flags = _cil::global_flags | _helper::global_flags | _next_iter::global_flags;
+};
+
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename generators_done, typename elements>
+struct dimino_add_remaining_generators<Multiply, Equality, id, generators_done, type_list<>, elements> {
+  typedef elements type;
+  constexpr static int global_flags = 0;
+};
+
+/** \internal
+ *
+ * \class enumerate_group_elements_noid
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Helper template that implements group element enumeration
+ *
+ * This is a helper template that implements the actual enumeration
+ * of group elements. This has been split so that the list of
+ * generators can be cleansed of the identity element before
+ * performing the actual operation.
+ *
+ * \sa enumerate_group_elements
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename generators, int initial_global_flags = 0>
+struct enumerate_group_elements_noid {
+  typedef dimino_first_step_elements<Multiply, Equality, id, generators> first_step;
+
+  typedef dimino_add_remaining_generators<Multiply, Equality, id, typename first_step::generators_done,
+                                          typename first_step::next_generators,  // remaining_generators
+                                          typename first_step::type              // first_step elements
+                                          >
+      _helper;
+
+  typedef typename _helper::type type;
+  constexpr static int global_flags = initial_global_flags | first_step::global_flags | _helper::global_flags;
+};
+
+// in case when no generators are specified
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          int initial_global_flags>
+struct enumerate_group_elements_noid<Multiply, Equality, id, type_list<>, initial_global_flags> {
+  typedef type_list<id> type;
+  constexpr static int global_flags = initial_global_flags;
+};
+
+/** \internal
+ *
+ * \class enumerate_group_elements
+ * \ingroup TensorSymmetry_Module
+ *
+ * \brief Enumerate all elements in a finite group
+ *
+ * This template enumerates all elements in a finite group. It accepts
+ * the following template parameters:
+ *
+ * \tparam Multiply      The multiplication operation that multiplies two group elements
+ *                       with each other.
+ * \tparam Equality      The equality check operation that checks if two group elements
+ *                       are equal to another.
+ * \tparam id            The identity element
+ * \tparam Generators_   A list of (possibly redundant) generators of the group
+ */
+template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
+          typename Generators_>
+struct enumerate_group_elements
+    : public enumerate_group_elements_noid<Multiply, Equality, id,
+                                           typename strip_identities<Equality, id, Generators_>::type,
+                                           strip_identities<Equality, id, Generators_>::global_flags> {};
+
+}  // end namespace group_theory
+
+}  // end namespace internal
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H
+
+/*
+ * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
+ */
diff --git a/contrib/README.txt b/contrib/README.txt
new file mode 100644
index 0000000..f19488a
--- /dev/null
+++ b/contrib/README.txt
@@ -0,0 +1,57 @@
+This directory hosts modules that satisfy a looser API-stability contract
+than the rest of Eigen. Most of the content here is mature and widely
+depended on (Tensor, AutoDiff, FFT, MatrixFunctions, Polynomials, Splines,
+NNLS, the GPU host-dispatch layer, ...), but the interfaces may evolve
+between minor releases and a small subset is genuinely experimental.
+
+Up to and including Eigen 4.x this directory was named "unsupported/".
+The tree was renamed to "contrib/" in Eigen 5.x; legacy
+<unsupported/Eigen/...> include paths continue to work via forwarding
+header shims under ../unsupported/.
+
+In order to use a contrib module either:
+
+ - add path_to_eigen/contrib to your include path and do:
+   #include <Eigen/ModuleHeader>
+
+ - or directly:
+   #include <contrib/Eigen/ModuleHeader>
+
+
+If you are interested in contributing to one of them, or have other stuff
+you would like to share, feel free to contact us via the upstream project
+on GitLab: https://gitlab.com/libeigen/eigen.
+
+Any kind of contributions are much appreciated, even very preliminary ones.
+However, it:
+ - must rely on Eigen,
+ - must be highly related to math,
+ - should have some general purpose in the sense that it could
+   potentially become a core Eigen module (or be merged into another one).
+
+In doubt feel free to contact us. For instance, if your addon is very
+specific but shows an interesting way of using Eigen, it could make for a
+nice demo.
+
+
+This directory is organized as follow:
+
+contrib/Eigen/ModuleHeader1
+contrib/Eigen/ModuleHeader2
+contrib/Eigen/...
+contrib/Eigen/src/Module1/SourceFile1.h
+contrib/Eigen/src/Module1/SourceFile2.h
+contrib/Eigen/src/Module1/...
+contrib/Eigen/src/Module2/SourceFile1.h
+contrib/Eigen/src/Module2/SourceFile2.h
+contrib/Eigen/src/Module2/...
+contrib/Eigen/src/...
+contrib/doc/snippets/.cpp   <- code snippets for the doc
+contrib/doc/examples/.cpp   <- examples for the doc
+contrib/doc/TutorialModule1.dox
+contrib/doc/TutorialModule2.dox
+contrib/doc/...
+contrib/test/.cpp           <- unit test files
+
+The documentation is generated at the same time as the main Eigen
+documentation. The .html files are generated in: build_dir/doc/html/contrib/
diff --git a/contrib/benchmarks/AutoDiff/CMakeLists.txt b/contrib/benchmarks/AutoDiff/CMakeLists.txt
new file mode 100644
index 0000000..00230d9
--- /dev/null
+++ b/contrib/benchmarks/AutoDiff/CMakeLists.txt
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_autodiff bench_autodiff.cpp)
diff --git a/contrib/benchmarks/AutoDiff/bench_autodiff.cpp b/contrib/benchmarks/AutoDiff/bench_autodiff.cpp
new file mode 100644
index 0000000..651acd1
--- /dev/null
+++ b/contrib/benchmarks/AutoDiff/bench_autodiff.cpp
@@ -0,0 +1,179 @@
+// Benchmarks for Eigen AutoDiff module.
+// Compares AutoDiff Jacobian computation against NumericalDiff and hand-coded Jacobians.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/AutoDiff>
+#include <contrib/Eigen/NumericalDiff>
+
+using namespace Eigen;
+
+// --- Small functor: Rosenbrock-like (2 inputs -> 2 outputs) ---
+struct SmallFunctor {
+  typedef Matrix<double, 2, 1> InputType;
+  typedef Matrix<double, 2, 1> ValueType;
+  typedef Matrix<double, 2, 2> JacobianType;
+
+  enum { InputsAtCompileTime = 2, ValuesAtCompileTime = 2 };
+
+  template <typename T>
+  void operator()(const Matrix<T, 2, 1>& x, Matrix<T, 2, 1>* v) const {
+    (*v)(0) = T(1) - x(0);
+    (*v)(1) = T(10) * (x(1) - x(0) * x(0));
+  }
+};
+
+// --- Medium functor: chain of operations (6 inputs -> 6 outputs) ---
+struct MediumFunctor {
+  typedef Matrix<double, 6, 1> InputType;
+  typedef Matrix<double, 6, 1> ValueType;
+  typedef Matrix<double, 6, 6> JacobianType;
+
+  enum { InputsAtCompileTime = 6, ValuesAtCompileTime = 6 };
+
+  template <typename T>
+  void operator()(const Matrix<T, 6, 1>& x, Matrix<T, 6, 1>* v) const {
+    (*v)(0) = sin(x(0)) * cos(x(1)) + x(2) * x(2);
+    (*v)(1) = exp(x(1) * T(0.1)) + x(3);
+    (*v)(2) = x(0) * x(2) - x(4) * x(5);
+    (*v)(3) = sqrt(x(3) * x(3) + T(1)) + x(0);
+    (*v)(4) = x(4) * x(4) + x(5) * x(5) + x(0) * x(1);
+    (*v)(5) = log(x(2) * x(2) + T(1)) + x(3) * x(4);
+  }
+};
+
+// --- Dynamic-size functor (N inputs -> N outputs) ---
+struct DynamicFunctor {
+  typedef Matrix<double, Dynamic, 1> InputType;
+  typedef Matrix<double, Dynamic, 1> ValueType;
+  typedef Matrix<double, Dynamic, Dynamic> JacobianType;
+
+  const int n_;
+  DynamicFunctor(int n) : n_(n) {}
+
+  enum { InputsAtCompileTime = Dynamic, ValuesAtCompileTime = Dynamic };
+
+  int inputs() const { return n_; }
+  int values() const { return n_; }
+
+  template <typename T>
+  void operator()(const Matrix<T, Dynamic, 1>& x, Matrix<T, Dynamic, 1>* v) const {
+    v->resize(n_);
+    (*v)(0) = T(1) - x(0);
+    for (int i = 1; i < n_; ++i) {
+      (*v)(i) = T(10) * (x(i) - x(i - 1) * x(i - 1));
+    }
+  }
+};
+
+// Wrapper for NumericalDiff compatibility.
+struct SmallFunctorND : SmallFunctor {
+  typedef double Scalar;
+  int inputs() const { return 2; }
+  int values() const { return 2; }
+  int operator()(const InputType& x, ValueType& v) const {
+    SmallFunctor::operator()(x, &v);
+    return 0;
+  }
+};
+
+struct MediumFunctorND : MediumFunctor {
+  typedef double Scalar;
+  int inputs() const { return 6; }
+  int values() const { return 6; }
+  int operator()(const InputType& x, ValueType& v) const {
+    MediumFunctor::operator()(x, &v);
+    return 0;
+  }
+};
+
+// --- AutoDiff Jacobian benchmarks ---
+template <typename Functor>
+static void BM_AutoDiffJacobian(benchmark::State& state, Functor func) {
+  AutoDiffJacobian<Functor> adf(func);
+  typename Functor::InputType x = Functor::InputType::Random();
+  typename Functor::ValueType v;
+  typename Functor::JacobianType jac;
+
+  for (auto _ : state) {
+    adf(x, &v, &jac);
+    benchmark::DoNotOptimize(jac.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// --- Dynamic AutoDiff Jacobian ---
+static void BM_AutoDiffJacobian_Dynamic(benchmark::State& state) {
+  int n = state.range(0);
+  DynamicFunctor func(n);
+  AutoDiffJacobian<DynamicFunctor> adf(func);
+
+  VectorXd x = VectorXd::Random(n);
+  VectorXd v(n);
+  MatrixXd jac(n, n);
+
+  for (auto _ : state) {
+    adf(x, &v, &jac);
+    benchmark::DoNotOptimize(jac.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// --- NumericalDiff benchmarks ---
+template <typename Functor>
+static void BM_NumericalDiffJacobian(benchmark::State& state, Functor func) {
+  NumericalDiff<Functor> ndf(func);
+  typename Functor::InputType x = Functor::InputType::Random();
+  typename Functor::JacobianType jac;
+
+  for (auto _ : state) {
+    ndf.df(x, jac);
+    benchmark::DoNotOptimize(jac.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// --- Hand-coded Jacobian (Rosenbrock) for comparison ---
+static void BM_HandCoded_Small(benchmark::State& state) {
+  Vector2d x = Vector2d::Random();
+  Matrix2d jac;
+
+  for (auto _ : state) {
+    jac(0, 0) = -1;
+    jac(0, 1) = 0;
+    jac(1, 0) = -20 * x(0);
+    jac(1, 1) = 10;
+    benchmark::DoNotOptimize(jac.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// --- Scalar AutoDiff evaluation (no Jacobian, just forward pass) ---
+static void BM_AutoDiffScalar_Eval(benchmark::State& state) {
+  int n = state.range(0);
+  using ADScalar = AutoDiffScalar<VectorXd>;
+  VectorXd x = VectorXd::Random(n);
+
+  for (auto _ : state) {
+    ADScalar sum(0.0, VectorXd::Zero(n));
+    for (int i = 0; i < n; ++i) {
+      ADScalar xi(x(i), n, i);
+      sum += xi * xi + sin(xi);
+    }
+    benchmark::DoNotOptimize(sum.value());
+    benchmark::DoNotOptimize(sum.derivatives().data());
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_CAPTURE(BM_AutoDiffJacobian, Small, SmallFunctor());
+BENCHMARK_CAPTURE(BM_AutoDiffJacobian, Medium, MediumFunctor());
+BENCHMARK(BM_AutoDiffJacobian_Dynamic)->Arg(2)->Arg(6)->Arg(20)->Arg(50)->Arg(100);
+
+BENCHMARK_CAPTURE(BM_NumericalDiffJacobian, Small, SmallFunctorND());
+BENCHMARK_CAPTURE(BM_NumericalDiffJacobian, Medium, MediumFunctorND());
+
+BENCHMARK(BM_HandCoded_Small);
+BENCHMARK(BM_AutoDiffScalar_Eval)->Arg(2)->Arg(6)->Arg(20)->Arg(50)->Arg(100);
diff --git a/contrib/benchmarks/CMakeLists.txt b/contrib/benchmarks/CMakeLists.txt
new file mode 100644
index 0000000..2bc57a4
--- /dev/null
+++ b/contrib/benchmarks/CMakeLists.txt
@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.10)
+project(EigenContribBenchmarks CXX)
+
+find_package(benchmark REQUIRED)
+find_package(Threads REQUIRED)
+
+set(EIGEN_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
+
+# Helper: add a Google Benchmark target (mirrors benchmarks/CMakeLists.txt).
+#   eigen_add_benchmark(name source [LIBRARIES lib1 lib2 ...] [DEFINITIONS def1 def2 ...])
+function(eigen_add_benchmark name source)
+  cmake_parse_arguments(BENCH "" "" "LIBRARIES;DEFINITIONS" ${ARGN})
+  if(NOT IS_ABSOLUTE "${source}")
+    set(source "${CMAKE_CURRENT_SOURCE_DIR}/${source}")
+  endif()
+  add_executable(${name} ${source})
+  target_include_directories(${name} PRIVATE ${EIGEN_SOURCE_DIR})
+  target_link_libraries(${name} PRIVATE benchmark::benchmark benchmark::benchmark_main
+                                        Threads::Threads)
+  if(BENCH_LIBRARIES)
+    target_link_libraries(${name} PRIVATE ${BENCH_LIBRARIES})
+  endif()
+  target_compile_options(${name} PRIVATE -O3 -DNDEBUG)
+  if(BENCH_DEFINITIONS)
+    target_compile_definitions(${name} PRIVATE ${BENCH_DEFINITIONS})
+  endif()
+endfunction()
+
+add_subdirectory(Tensor)
+add_subdirectory(MatrixFunctions)
+add_subdirectory(SpecialFunctions)
+add_subdirectory(AutoDiff)
+add_subdirectory(Splines)
+add_subdirectory(Polynomials)
+add_subdirectory(KroneckerProduct)
+add_subdirectory(StructuredMatrices)
+
+# GPU benchmarks have their own CMake project (needs CUDAToolkit).
+# They can also be built standalone: cmake -B build -S contrib/benchmarks/GPU
+find_package(CUDAToolkit QUIET)
+if(CUDAToolkit_FOUND)
+  add_subdirectory(GPU)
+endif()
diff --git a/contrib/benchmarks/GPU/CMakeLists.txt b/contrib/benchmarks/GPU/CMakeLists.txt
new file mode 100644
index 0000000..b53c2a4
--- /dev/null
+++ b/contrib/benchmarks/GPU/CMakeLists.txt
@@ -0,0 +1,107 @@
+# GPU benchmarks require CUDA runtime + cuSOLVER.
+# Build separately from the main benchmark tree since they need CUDA toolchain.
+#
+# Usage:
+#   cmake -G Ninja -B build-bench-gpu -S contrib/benchmarks/GPU \
+#         -DCMAKE_CUDA_ARCHITECTURES=89
+#   cmake --build build-bench-gpu
+#
+# Profiling:
+#   nsys profile --trace=cuda ./build-bench-gpu/bench_solvers
+#   ncu --set full -o profile ./build-bench-gpu/bench_solvers --benchmark_filter=BM_GpuLLT_Compute/4096
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.18)
+project(EigenGpuBenchmarks CXX CUDA)
+
+find_package(benchmark REQUIRED)
+find_package(CUDAToolkit REQUIRED)
+
+set(EIGEN_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../..")
+
+function(eigen_add_gpu_benchmark name source)
+  cmake_parse_arguments(BENCH "" "" "LIBRARIES;DEFINITIONS" ${ARGN})
+  if(NOT IS_ABSOLUTE "${source}")
+    set(source "${CMAKE_CURRENT_SOURCE_DIR}/${source}")
+  endif()
+  add_executable(${name} ${source})
+  target_compile_features(${name} PRIVATE cxx_std_14)
+  target_include_directories(${name} PRIVATE
+    ${EIGEN_SOURCE_DIR}
+    ${CUDAToolkit_INCLUDE_DIRS})
+  target_link_libraries(${name} PRIVATE
+    benchmark::benchmark benchmark::benchmark_main
+    CUDA::cudart CUDA::cusolver CUDA::cublas)
+  if(BENCH_LIBRARIES)
+    target_link_libraries(${name} PRIVATE ${BENCH_LIBRARIES})
+  endif()
+  # Note: do NOT set -DNDEBUG here. EIGEN_CUDA_RUNTIME_CHECK uses eigen_assert,
+  # which is a no-op under NDEBUG, silently skipping cudaStreamSynchronize calls.
+  target_compile_options(${name} PRIVATE -O3)
+  target_compile_definitions(${name} PRIVATE EIGEN_USE_GPU)
+  if(BENCH_DEFINITIONS)
+    target_compile_definitions(${name} PRIVATE ${BENCH_DEFINITIONS})
+  endif()
+endfunction()
+
+# Solver benchmarks: LLT/LU compute + solve, host vs device paths, CPU baselines.
+eigen_add_gpu_benchmark(bench_solvers bench_solvers.cpp)
+eigen_add_gpu_benchmark(bench_solvers_float bench_solvers.cpp DEFINITIONS SCALAR=float)
+
+# GEMM benchmarks: cublasLtMatmul (with plan cache) vs raw cublasGemmEx across sizes.
+eigen_add_gpu_benchmark(bench_gemm bench_gemm.cpp LIBRARIES CUDA::cublasLt)
+eigen_add_gpu_benchmark(bench_gemm_float bench_gemm.cpp LIBRARIES CUDA::cublasLt DEFINITIONS SCALAR=float)
+
+# Overhead micro-benchmarks: per-call allocation, hidden syncs, host-side copies.
+eigen_add_gpu_benchmark(bench_overhead bench_overhead.cpp LIBRARIES CUDA::cublasLt CUDA::cusparse)
+
+# Unified/zero-copy memory: storage strategies for integrated GPUs (Jetson).
+eigen_add_gpu_benchmark(bench_unified_memory bench_unified_memory.cpp)
+eigen_add_gpu_benchmark(bench_unified_memory_float bench_unified_memory.cpp DEFINITIONS SCALAR=float)
+
+# Chaining benchmarks: async pipeline efficiency, host-roundtrip vs device chain.
+eigen_add_gpu_benchmark(bench_chaining bench_chaining.cpp)
+eigen_add_gpu_benchmark(bench_chaining_float bench_chaining.cpp DEFINITIONS SCALAR=float)
+
+# Batching benchmarks: multi-stream concurrency for many small systems.
+eigen_add_gpu_benchmark(bench_batching bench_batching.cpp)
+eigen_add_gpu_benchmark(bench_batching_float bench_batching.cpp DEFINITIONS SCALAR=float)
+
+# FFT benchmarks: 1D/2D C2C, R2C, C2R throughput and plan reuse.
+eigen_add_gpu_benchmark(bench_fft bench_fft.cpp LIBRARIES CUDA::cufft)
+eigen_add_gpu_benchmark(bench_fft_double bench_fft.cpp LIBRARIES CUDA::cufft DEFINITIONS SCALAR=double)
+
+# CG sync overhead benchmark: host vs device pointer mode for reductions.
+# Uses CUDA kernels for device scalar arithmetic.
+add_executable(bench_cg_sync bench_cg_sync.cu)
+target_include_directories(bench_cg_sync PRIVATE
+  ${EIGEN_SOURCE_DIR}
+  ${CUDAToolkit_INCLUDE_DIRS})
+target_link_libraries(bench_cg_sync PRIVATE
+  benchmark::benchmark benchmark::benchmark_main
+  CUDA::cudart CUDA::cusolver CUDA::cublas CUDA::cusparse CUDA::npps CUDA::nppc)
+target_compile_options(bench_cg_sync PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-O3 --expt-relaxed-constexpr>)
+target_compile_definitions(bench_cg_sync PRIVATE EIGEN_USE_GPU)
+
+# GPU CG vs CPU CG comparison benchmark.
+add_executable(bench_cg_vs_cpu bench_cg_vs_cpu.cu)
+target_include_directories(bench_cg_vs_cpu PRIVATE
+  ${EIGEN_SOURCE_DIR}
+  ${CUDAToolkit_INCLUDE_DIRS})
+target_link_libraries(bench_cg_vs_cpu PRIVATE
+  benchmark::benchmark benchmark::benchmark_main
+  CUDA::cudart CUDA::cusolver CUDA::cublas CUDA::cusparse CUDA::npps CUDA::nppc)
+target_compile_options(bench_cg_vs_cpu PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-O3 --expt-relaxed-constexpr>)
+target_compile_definitions(bench_cg_vs_cpu PRIVATE EIGEN_USE_GPU)
+
+# Bundle Adjustment benchmark: GPU CG vs CPU CG on real BAL datasets.
+add_executable(bench_ba bench_ba.cu)
+target_include_directories(bench_ba PRIVATE
+  ${EIGEN_SOURCE_DIR}
+  ${CUDAToolkit_INCLUDE_DIRS})
+target_link_libraries(bench_ba PRIVATE
+  benchmark::benchmark
+  CUDA::cudart CUDA::cusolver CUDA::cublas CUDA::cusparse CUDA::npps CUDA::nppc)
+target_compile_options(bench_ba PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-O3 --expt-relaxed-constexpr>)
+target_compile_definitions(bench_ba PRIVATE EIGEN_USE_GPU)
diff --git a/contrib/benchmarks/GPU/ba_results.md b/contrib/benchmarks/GPU/ba_results.md
new file mode 100644
index 0000000..826dc46
--- /dev/null
+++ b/contrib/benchmarks/GPU/ba_results.md
@@ -0,0 +1,154 @@
+<!--
+SPDX-FileCopyrightText: The Eigen Authors
+SPDX-License-Identifier: MPL-2.0
+-->
+
+# Bundle Adjustment: GPU CG vs CPU CG Results
+
+Benchmark of Eigen's GPU CG pipeline on normal equations arising from bundle
+adjustment (BAL datasets). Compares CPU `ConjugateGradient` (Jacobi preconditioner)
+against GPU CG using `DeviceMatrix` + `GpuSparseContext` + `DeviceScalar`.
+
+## Hardware
+
+- **CPU**: Intel Core i7-13700HX (Raptor Lake, 12 cores / 24 threads, single thread for Eigen CG)
+- **GPU**: NVIDIA GeForce RTX 4070 Laptop GPU (Ada Lovelace, 4608 CUDA cores, 8 GB GDDR6)
+- **CUDA**: 13.2 / Driver 595.79
+- **OS**: Ubuntu 24.04 (WSL2, kernel 6.6.87)
+
+## Software
+
+- Eigen: `eigen-gpu-cg` branch
+- Google Benchmark 1.9.1
+- Compiler: nvcc 13.2 + g++ 13.3
+- Normal equations: H = J^T*J + I (Levenberg-Marquardt damping lambda=1.0)
+- CG tolerance: 1e-8, max iterations: 10000
+
+## Method
+
+For each BAL problem file:
+1. Parse the BAL file (cameras, 3D points, 2D observations)
+2. Compute the full Jacobian J using the BAL camera model (Rodrigues rotation +
+   perspective projection + radial distortion) with central finite differences
+3. Form the normal equations H = J^T*J + lambda*I (sparse, symmetric positive definite)
+4. Solve H*dx = -J^T*r using CG with Jacobi preconditioner on CPU and GPU
+5. Report wall-clock time (mean of 3 repetitions)
+
+GPU CG uses: `GpuSparseContext` for SpMV, `DeviceMatrix` for vectors,
+`DeviceScalar` with `CUBLAS_POINTER_MODE_DEVICE` for dot/norm reductions,
+in-place `cwiseProduct` via NPP for Jacobi preconditioner application,
+device-pointer-mode `scal` to avoid host sync on the beta update.
+
+## Results
+
+### Summary table
+
+| Dataset | Cameras | Points | Obs | H size | H nnz | CG iters | CPU CG (ms) | GPU CG (ms) | Speedup |
+|---------|---------|--------|-----|--------|-------|----------|-------------|-------------|---------|
+| Ladybug-49 | 49 | 7,776 | 31,843 | 23,769 | 1.8M | 4,421 | 4,006 | 1,152 | **3.5x** |
+| Ladybug-138 | 138 | 19,878 | 85,217 | 60,876 | 4.8M | 7,008 | 21,498 | 3,553 | **6.1x** |
+| Ladybug-646 | 646 | 73,584 | 327,297 | 226,566 | 18.4M | 10,000* | 123,727 | 14,268 | **8.7x** |
+| Dubrovnik-356 | 356 | 226,730 | 1,255,268 | 683,394 | 69.8M | 4,308 | 216,149 | 24,493 | **8.8x** |
+
+\* Hit 10,000 iteration cap (poorly conditioned problem). Both CPU and GPU
+hit the same cap, so timing comparison remains valid.
+
+### Profile breakdown (Ladybug-138, nsys)
+
+GPU kernel time is dominated by SpMV (91%). The remaining 9% is BLAS-1
+operations (dot, axpy, scal) and NPP element-wise ops (cwiseProduct).
+
+| Kernel | Time (ms) | % | Calls |
+|--------|-----------|---|-------|
+| cuSPARSE csrmv (SpMV) | 2507 | 91.3% | 7,006 |
+| cuBLAS dot | 92 | 3.4% | 21,020 |
+| cuBLAS axpy (device ptr) | 27 | 1.0% | 14,012 |
+| cuSPARSE partition | 19 | 0.7% | 7,006 |
+| NPP cwiseProduct | 16 + 13 | 1.1% | 14,011 + 7,006 |
+| cuBLAS axpy (host ptr) | 12 | 0.5% | 7,005 |
+| cuBLAS scal (device ptr) | 11 | 0.4% | 7,005 |
+| NPP scalar ops | 7 | 0.2% | 7,006 |
+
+### Optimizations applied
+
+Three profiling-driven optimizations reduced GPU CG time by **1.8x**
+(6.5s → 3.6s on Ladybug-138):
+
+1. **In-place `cwiseProduct`**: The Jacobi preconditioner apply
+   (`z = invdiag .* residual`) was allocating a new DeviceMatrix every
+   iteration. Added `z.cwiseProduct(ctx, a, b)` that reuses `z`'s buffer.
+   Reduced `cudaMalloc` calls from 7,053 to 23 (saving 2.3s).
+
+2. **`squaredNorm` via `dot(x,x)`**: cuBLAS `nrm2` uses a numerically
+   careful scaled-sum-of-squares algorithm (29µs/call). Replaced with
+   `dot(x,x)` (6.4µs/call) — 4.5x faster per call, saving ~320ms.
+
+3. **Device-pointer `scal`**: `p *= beta` was converting `DeviceScalar`
+   beta to host (triggering a stream sync), then calling host-pointer-mode
+   scal. Added `operator*=(DeviceScalar)` that uses device-pointer-mode
+   scal, eliminating one sync per iteration. Halved `cudaStreamSynchronize`
+   calls from 14K to 7K.
+
+### Observations
+
+1. **GPU speedup scales with problem size**: from 3.5x on small problems
+   (24K variables) to 8.8x on large problems (683K variables). This is
+   expected — larger problems have more parallelism for the GPU to exploit.
+
+2. **Iteration counts match**: CPU and GPU CG converge in the same number
+   of iterations (within 1%), confirming numerical equivalence.
+
+3. **Bottleneck is SpMV**: CG iteration time is dominated (91%) by the
+   sparse matrix-vector product on H. Further speedup requires either
+   faster SpMV (e.g., block-sparse formats) or algorithmic improvements
+   (Schur complement, better preconditioners).
+
+4. **Remaining overhead**: CUDA API calls (cudaMemcpyAsync for 8-byte
+   DeviceScalar transfers) account for ~50% of non-kernel time. Batching
+   multiple scalar reductions into a single transfer would help.
+
+5. **Jacobi preconditioner is weak for BA**: The Ladybug-646 problem does
+   not converge in 10K iterations. Ceres uses block Jacobi or Schur
+   complement preconditioners that would also benefit from GPU acceleration.
+
+### Scaling plot data
+
+```text
+# n        nnz_H       cpu_ms    gpu_ms    speedup
+23769      1793475     4006      1152      3.48
+60876      4791762     21498     3553      6.05
+226566     18387948    123727    14268     8.67
+683394     69827066    216149    24493     8.82
+```
+
+## BAL datasets
+
+Downloaded from http://grail.cs.washington.edu/projects/bal/
+
+| File | Source |
+|------|--------|
+| problem-49-7776-pre.txt | Ladybug sequence |
+| problem-138-19878-pre.txt | Ladybug sequence |
+| problem-646-73584-pre.txt | Ladybug sequence |
+| problem-356-226730-pre.txt | Dubrovnik reconstruction |
+
+## Reproducing
+
+```bash
+# Build
+cmake -G Ninja -B build-bench-gpu -S contrib/benchmarks/GPU -DCMAKE_CUDA_ARCHITECTURES=89
+cmake --build build-bench-gpu --target bench_ba
+
+# Download BAL datasets
+wget http://grail.cs.washington.edu/projects/bal/data/ladybug/problem-49-7776-pre.txt.bz2
+wget http://grail.cs.washington.edu/projects/bal/data/ladybug/problem-138-19878-pre.txt.bz2
+wget http://grail.cs.washington.edu/projects/bal/data/ladybug/problem-646-73584-pre.txt.bz2
+wget http://grail.cs.washington.edu/projects/bal/data/dubrovnik/problem-356-226730-pre.txt.bz2
+bunzip2 *.bz2
+
+# Run (one at a time)
+BAL_FILE=problem-49-7776-pre.txt ./build-bench-gpu/bench_ba --benchmark_repetitions=3
+BAL_FILE=problem-138-19878-pre.txt ./build-bench-gpu/bench_ba --benchmark_repetitions=3
+BAL_FILE=problem-646-73584-pre.txt ./build-bench-gpu/bench_ba --benchmark_repetitions=3
+BAL_FILE=problem-356-226730-pre.txt ./build-bench-gpu/bench_ba --benchmark_repetitions=3
+```
diff --git a/contrib/benchmarks/GPU/bench_ba.cu b/contrib/benchmarks/GPU/bench_ba.cu
new file mode 100644
index 0000000..f2f3af9
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_ba.cu
@@ -0,0 +1,504 @@
+// Bundle Adjustment benchmark: GPU CG vs CPU CG on real BAL datasets.
+//
+// Tests Eigen's GPU CG pipeline (gpu::DeviceMatrix + gpu::SparseContext + DeviceScalar)
+// on the normal equations (J^T*J) arising from bundle adjustment problems.
+//
+// Reads a BAL (Bundle Adjustment in the Large) format file, computes the
+// Jacobian and residual, forms the normal equations H = J^T*J + lambda*I,
+// then solves H*dx = -J^T*r with both CPU and GPU conjugate gradients.
+//
+// BAL format: http://grail.cs.washington.edu/projects/bal/
+//
+// Usage:
+//   cmake --build build-bench-gpu --target bench_gpu_ba
+//
+//   # Download a BAL dataset (bz2-compressed):
+//   wget http://grail.cs.washington.edu/projects/bal/data/ladybug/problem-49-7776-pre.txt.bz2
+//   bunzip2 problem-49-7776-pre.txt.bz2
+//
+//   # Run on a specific problem:
+//   BAL_FILE=problem-49-7776-pre.txt ./build-bench-gpu/bench_gpu_ba
+//
+//   # Append results to the log:
+//   BAL_FILE=problem-49-7776-pre.txt ./build-bench-gpu/bench_gpu_ba \
+//     --benchmark_format=console 2>&1 | tee -a benchmarks/GPU/ba_results.log
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <Eigen/Sparse>
+#include <Eigen/IterativeLinearSolvers>
+#include <contrib/Eigen/GPU>
+
+#include <cmath>
+#include <cstdio>
+#include <fstream>
+#include <string>
+#include <vector>
+
+using namespace Eigen;
+
+// ============================================================================
+// BAL problem data
+// ============================================================================
+
+struct BALProblem {
+  int num_cameras = 0;
+  int num_points = 0;
+  int num_observations = 0;
+
+  // Observations: (camera_idx, point_idx, observed_x, observed_y).
+  std::vector<int> camera_index;
+  std::vector<int> point_index;
+  std::vector<double> observations_x;
+  std::vector<double> observations_y;
+
+  // Camera parameters: 9 per camera (Rodrigues r[3], translation t[3], f, k1, k2).
+  std::vector<double> cameras;  // [num_cameras * 9]
+
+  // 3D points: 3 per point.
+  std::vector<double> points;  // [num_points * 3]
+
+  const double* camera(int i) const { return &cameras[i * 9]; }
+  const double* point(int i) const { return &points[i * 3]; }
+
+  bool load(const std::string& filename) {
+    std::ifstream in(filename);
+    if (!in) {
+      fprintf(stderr, "ERROR: Cannot open BAL file: %s\n", filename.c_str());
+      return false;
+    }
+
+    in >> num_cameras >> num_points >> num_observations;
+    if (!in || num_cameras <= 0 || num_points <= 0 || num_observations <= 0) {
+      fprintf(stderr, "ERROR: Invalid BAL header in %s\n", filename.c_str());
+      return false;
+    }
+
+    camera_index.resize(num_observations);
+    point_index.resize(num_observations);
+    observations_x.resize(num_observations);
+    observations_y.resize(num_observations);
+    for (int i = 0; i < num_observations; ++i) {
+      in >> camera_index[i] >> point_index[i] >> observations_x[i] >> observations_y[i];
+    }
+
+    cameras.resize(num_cameras * 9);
+    for (int i = 0; i < num_cameras * 9; ++i) {
+      in >> cameras[i];
+    }
+
+    points.resize(num_points * 3);
+    for (int i = 0; i < num_points * 3; ++i) {
+      in >> points[i];
+    }
+
+    if (!in) {
+      fprintf(stderr, "ERROR: Truncated BAL file: %s\n", filename.c_str());
+      return false;
+    }
+
+    fprintf(stderr, "Loaded BAL: %d cameras, %d points, %d observations\n", num_cameras, num_points, num_observations);
+    return true;
+  }
+};
+
+// ============================================================================
+// Camera projection model (BAL convention)
+// ============================================================================
+
+// Rodrigues rotation: rotate point X by axis-angle vector omega.
+static void rodrigues_rotate(const double* omega, const double* X, double* result) {
+  double theta2 = omega[0] * omega[0] + omega[1] * omega[1] + omega[2] * omega[2];
+  if (theta2 > 1e-30) {
+    double theta = std::sqrt(theta2);
+    double costh = std::cos(theta);
+    double sinth = std::sin(theta);
+    double k = (1.0 - costh) / theta2;
+
+    // Cross product omega x X.
+    double wx = omega[1] * X[2] - omega[2] * X[1];
+    double wy = omega[2] * X[0] - omega[0] * X[2];
+    double wz = omega[0] * X[1] - omega[1] * X[0];
+
+    // Dot product omega . X.
+    double dot = omega[0] * X[0] + omega[1] * X[1] + omega[2] * X[2];
+
+    result[0] = X[0] * costh + wx * (sinth / theta) + omega[0] * dot * k;
+    result[1] = X[1] * costh + wy * (sinth / theta) + omega[1] * dot * k;
+    result[2] = X[2] * costh + wz * (sinth / theta) + omega[2] * dot * k;
+  } else {
+    // Small angle: R ≈ I + [omega]×.
+    result[0] = X[0] + omega[1] * X[2] - omega[2] * X[1];
+    result[1] = X[1] + omega[2] * X[0] - omega[0] * X[2];
+    result[2] = X[2] + omega[0] * X[1] - omega[1] * X[0];
+  }
+}
+
+// Project a 3D point through a camera, returning the 2D residual.
+// camera: [r0,r1,r2, t0,t1,t2, f, k1, k2]
+// point:  [X, Y, Z]
+// observed: [ox, oy]
+// residual: [rx, ry] = projected - observed
+static void project(const double* camera, const double* point, const double* observed, double* residual) {
+  // Rotate.
+  double P[3];
+  rodrigues_rotate(camera, point, P);
+
+  // Translate.
+  P[0] += camera[3];
+  P[1] += camera[4];
+  P[2] += camera[5];
+
+  // Normalize (BAL convention: negative z).
+  double xp = -P[0] / P[2];
+  double yp = -P[1] / P[2];
+
+  // Radial distortion.
+  double r2 = xp * xp + yp * yp;
+  double distortion = 1.0 + camera[7] * r2 + camera[8] * r2 * r2;
+
+  // Apply focal length.
+  double predicted_x = camera[6] * distortion * xp;
+  double predicted_y = camera[6] * distortion * yp;
+
+  residual[0] = predicted_x - observed[0];
+  residual[1] = predicted_y - observed[1];
+}
+
+// ============================================================================
+// Jacobian computation (numerical differentiation)
+// ============================================================================
+
+// Compute the 2x9 Jacobian block w.r.t. camera params and 2x3 block w.r.t.
+// point coords for a single observation, using central finite differences.
+static void compute_jacobian_block(const double* camera, const double* point, const double* observed,
+                                   double* J_cam,    // 2x9, row-major
+                                   double* J_point)  // 2x3, row-major
+{
+  constexpr double eps = 1e-8;
+
+  // Camera parameters (9).
+  double cam_pert[9];
+  std::copy(camera, camera + 9, cam_pert);
+  for (int j = 0; j < 9; ++j) {
+    double orig = cam_pert[j];
+    double rp[2], rm[2];
+
+    cam_pert[j] = orig + eps;
+    project(cam_pert, point, observed, rp);
+    cam_pert[j] = orig - eps;
+    project(cam_pert, point, observed, rm);
+    cam_pert[j] = orig;
+
+    J_cam[0 * 9 + j] = (rp[0] - rm[0]) / (2.0 * eps);
+    J_cam[1 * 9 + j] = (rp[1] - rm[1]) / (2.0 * eps);
+  }
+
+  // Point coordinates (3).
+  double pt_pert[3];
+  std::copy(point, point + 3, pt_pert);
+  for (int j = 0; j < 3; ++j) {
+    double orig = pt_pert[j];
+    double rp[2], rm[2];
+
+    pt_pert[j] = orig + eps;
+    project(camera, pt_pert, observed, rp);
+    pt_pert[j] = orig - eps;
+    project(camera, pt_pert, observed, rm);
+    pt_pert[j] = orig;
+
+    J_point[0 * 3 + j] = (rp[0] - rm[0]) / (2.0 * eps);
+    J_point[1 * 3 + j] = (rp[1] - rm[1]) / (2.0 * eps);
+  }
+}
+
+// ============================================================================
+// Build normal equations: H = J^T*J + lambda*I, g = -J^T*r
+// ============================================================================
+
+struct NormalEquations {
+  SparseMatrix<double, ColMajor, int> H;
+  VectorXd g;
+  VectorXd residual;
+  double residual_norm;
+  int jacobian_rows;
+  int jacobian_cols;
+  long jacobian_nnz;
+};
+
+static NormalEquations build_normal_equations(const BALProblem& problem, double lambda = 1.0) {
+  const int num_cam_params = problem.num_cameras * 9;
+  const int num_pt_params = problem.num_points * 3;
+  const int num_params = num_cam_params + num_pt_params;
+  const int num_residuals = problem.num_observations * 2;
+
+  fprintf(stderr, "Building Jacobian: %d x %d, %ld nonzeros\n", num_residuals, num_params,
+          (long)problem.num_observations * 24);
+
+  // Build J as a triplet list.
+  using Triplet = Eigen::Triplet<double>;
+  std::vector<Triplet> triplets;
+  triplets.reserve(problem.num_observations * 24);  // 2 rows × 12 nonzeros = 24 entries per obs
+
+  VectorXd residual(num_residuals);
+
+  for (int obs = 0; obs < problem.num_observations; ++obs) {
+    int ci = problem.camera_index[obs];
+    int pi = problem.point_index[obs];
+    double observed[2] = {problem.observations_x[obs], problem.observations_y[obs]};
+
+    // Compute residual.
+    double r[2];
+    project(problem.camera(ci), problem.point(pi), observed, r);
+    residual[obs * 2 + 0] = r[0];
+    residual[obs * 2 + 1] = r[1];
+
+    // Compute Jacobian blocks.
+    double J_cam[18], J_pt[6];  // 2x9 and 2x3
+    compute_jacobian_block(problem.camera(ci), problem.point(pi), observed, J_cam, J_pt);
+
+    // Insert camera block: rows [2*obs, 2*obs+1], cols [9*ci, 9*ci+8].
+    for (int row = 0; row < 2; ++row) {
+      for (int col = 0; col < 9; ++col) {
+        double val = J_cam[row * 9 + col];
+        if (val != 0.0) {
+          triplets.emplace_back(obs * 2 + row, ci * 9 + col, val);
+        }
+      }
+    }
+
+    // Insert point block: rows [2*obs, 2*obs+1], cols [num_cam_params + 3*pi, ...].
+    for (int row = 0; row < 2; ++row) {
+      for (int col = 0; col < 3; ++col) {
+        double val = J_pt[row * 3 + col];
+        if (val != 0.0) {
+          triplets.emplace_back(obs * 2 + row, num_cam_params + pi * 3 + col, val);
+        }
+      }
+    }
+  }
+
+  // Build sparse Jacobian.
+  SparseMatrix<double, ColMajor, int> J(num_residuals, num_params);
+  J.setFromTriplets(triplets.begin(), triplets.end());
+
+  fprintf(stderr, "Jacobian: %dx%d, nnz=%ld\n", (int)J.rows(), (int)J.cols(), (long)J.nonZeros());
+
+  // Form normal equations: H = J^T*J + lambda*I.
+  SparseMatrix<double, ColMajor, int> H = (J.transpose() * J).pruned();
+
+  // Add Levenberg-Marquardt damping.
+  for (int i = 0; i < num_params; ++i) {
+    H.coeffRef(i, i) += lambda;
+  }
+  H.makeCompressed();
+
+  // Gradient: g = -J^T * r.
+  VectorXd g = -(J.transpose() * residual);
+
+  double rnorm = residual.norm();
+  fprintf(stderr, "Normal equations: H is %dx%d, nnz=%ld, |r|=%.6e\n", (int)H.rows(), (int)H.cols(), (long)H.nonZeros(),
+          rnorm);
+
+  return {std::move(H), std::move(g), std::move(residual), rnorm, num_residuals, num_params, (long)J.nonZeros()};
+}
+
+// ============================================================================
+// Global problem state (loaded once before benchmarks run)
+// ============================================================================
+
+static BALProblem g_problem;
+static NormalEquations g_neq;
+static bool g_loaded = false;
+
+static void ensure_loaded() {
+  if (g_loaded) return;
+
+  const char* bal_file = std::getenv("BAL_FILE");
+  if (!bal_file) {
+    fprintf(stderr,
+            "ERROR: Set BAL_FILE environment variable to a BAL problem file.\n"
+            "  Download from: http://grail.cs.washington.edu/projects/bal/\n"
+            "  Example:\n"
+            "    wget http://grail.cs.washington.edu/projects/bal/data/ladybug/"
+            "problem-49-7776-pre.txt.bz2\n"
+            "    bunzip2 problem-49-7776-pre.txt.bz2\n"
+            "    BAL_FILE=problem-49-7776-pre.txt ./build-bench-gpu/bench_gpu_ba\n");
+    std::exit(1);
+  }
+
+  if (!g_problem.load(bal_file)) {
+    std::exit(1);
+  }
+
+  g_neq = build_normal_equations(g_problem);
+  g_loaded = true;
+}
+
+// ============================================================================
+// CPU CG benchmark
+// ============================================================================
+
+static void BM_BA_CPU_CG(benchmark::State& state) {
+  ensure_loaded();
+  const auto& H = g_neq.H;
+  const auto& g = g_neq.g;
+
+  ConjugateGradient<SparseMatrix<double, ColMajor, int>, Lower | Upper> cg;
+  cg.setMaxIterations(10000);
+  cg.setTolerance(1e-8);
+  cg.compute(H);
+
+  int last_iters = 0;
+  double last_error = 0;
+  for (auto _ : state) {
+    VectorXd dx = cg.solve(g);
+    benchmark::DoNotOptimize(dx.data());
+    last_iters = cg.iterations();
+    last_error = cg.error();
+  }
+
+  state.counters["n"] = H.rows();
+  state.counters["nnz"] = H.nonZeros();
+  state.counters["iters"] = last_iters;
+  state.counters["error"] = last_error;
+  state.counters["cameras"] = g_problem.num_cameras;
+  state.counters["points"] = g_problem.num_points;
+  state.counters["observations"] = g_problem.num_observations;
+}
+
+// ============================================================================
+// GPU CG benchmark (with Jacobi preconditioner)
+// ============================================================================
+
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    cudaMalloc(&p, 1);
+    cudaFree(p);
+    done = true;
+  }
+}
+
+static void BM_BA_GPU_CG(benchmark::State& state) {
+  ensure_loaded();
+  cuda_warmup();
+
+  const auto& H = g_neq.H;
+  const auto& g = g_neq.g;
+  const Index n = H.rows();
+
+  // Extract inverse diagonal (Jacobi preconditioner).
+  using SpMat = SparseMatrix<double, ColMajor, int>;
+  VectorXd invdiag(n);
+  for (Index j = 0; j < H.outerSize(); ++j) {
+    SpMat::InnerIterator it(H, j);
+    while (it && it.index() != j) ++it;
+    if (it && it.index() == j && it.value() != 0.0)
+      invdiag(j) = 1.0 / it.value();
+    else
+      invdiag(j) = 1.0;
+  }
+
+  // Set up GPU context and upload data.
+  gpu::Context ctx;
+  gpu::Context::setThreadLocal(&ctx);
+  gpu::SparseContext<double> spmv_ctx(ctx);
+  auto mat = spmv_ctx.deviceView(H);
+  auto d_invdiag = gpu::DeviceMatrix<double>::fromHost(invdiag, ctx.stream());
+  auto d_g = gpu::DeviceMatrix<double>::fromHost(g, ctx.stream());
+
+  int last_iters = 0;
+  double last_error = 0;
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<double> d_x(n, 1);
+    d_x.setZero(ctx);
+    gpu::DeviceMatrix<double> residual(n, 1);
+    residual.copyFrom(ctx, d_g);
+
+    double rhsNorm2 = d_g.squaredNorm(ctx);
+    double threshold = 1e-8 * 1e-8 * rhsNorm2;
+    double residualNorm2 = residual.squaredNorm(ctx);
+
+    gpu::DeviceMatrix<double> p = d_invdiag.cwiseProduct(ctx, residual);
+    gpu::DeviceMatrix<double> z(n, 1), tmp(n, 1);
+
+    auto absNew = residual.dot(ctx, p);
+    Index i = 0;
+    Index maxIters = 10000;
+    while (i < maxIters) {
+      tmp.noalias() = mat * p;
+      auto alpha = absNew / p.dot(ctx, tmp);
+      d_x += alpha * p;
+      residual -= alpha * tmp;
+
+      residualNorm2 = residual.squaredNorm(ctx);
+      if (residualNorm2 < threshold) break;
+
+      z.cwiseProduct(ctx, d_invdiag, residual);  // in-place, no allocation
+      auto absOld = std::move(absNew);
+      absNew = residual.dot(ctx, z);
+      auto beta = absNew / absOld;
+
+      p *= beta;  // device-pointer scal, no host sync
+      p += z;
+      i++;
+    }
+    benchmark::DoNotOptimize(d_x.data());
+    last_iters = i;
+    last_error = std::sqrt(residualNorm2 / rhsNorm2);
+  }
+
+  gpu::Context::setThreadLocal(nullptr);
+
+  state.counters["n"] = n;
+  state.counters["nnz"] = H.nonZeros();
+  state.counters["iters"] = last_iters;
+  state.counters["error"] = last_error;
+  state.counters["cameras"] = g_problem.num_cameras;
+  state.counters["points"] = g_problem.num_points;
+  state.counters["observations"] = g_problem.num_observations;
+}
+
+// ============================================================================
+// Register benchmarks
+// ============================================================================
+
+BENCHMARK(BM_BA_CPU_CG)->Unit(benchmark::kMillisecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_BA_GPU_CG)->Unit(benchmark::kMillisecond)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ============================================================================
+// Custom main: print summary after benchmarks
+// ============================================================================
+
+int main(int argc, char** argv) {
+  benchmark::Initialize(&argc, argv);
+
+  // Print problem info before benchmarks.
+  const char* bal_file = std::getenv("BAL_FILE");
+  if (bal_file) {
+    ensure_loaded();
+    fprintf(stderr,
+            "\n"
+            "=== Bundle Adjustment GPU CG Benchmark ===\n"
+            "BAL file:      %s\n"
+            "Cameras:       %d\n"
+            "Points:        %d\n"
+            "Observations:  %d\n"
+            "J size:        %d x %d, nnz=%ld\n"
+            "H size:        %d x %d, nnz=%ld\n"
+            "|residual|:    %.6e\n"
+            "==========================================\n\n",
+            bal_file, g_problem.num_cameras, g_problem.num_points, g_problem.num_observations, g_neq.jacobian_rows,
+            g_neq.jacobian_cols, g_neq.jacobian_nnz, (int)g_neq.H.rows(), (int)g_neq.H.cols(), (long)g_neq.H.nonZeros(),
+            g_neq.residual_norm);
+  }
+
+  benchmark::RunSpecifiedBenchmarks();
+  benchmark::Shutdown();
+  return 0;
+}
diff --git a/contrib/benchmarks/GPU/bench_batching.cpp b/contrib/benchmarks/GPU/bench_batching.cpp
new file mode 100644
index 0000000..d1fa0e3
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_batching.cpp
@@ -0,0 +1,270 @@
+// GPU batching benchmarks: multi-stream concurrency for many small solves.
+//
+// Each gpu::LLT/gpu::LU owns its own CUDA stream. This benchmark measures how
+// well multiple solver instances overlap on the GPU, which is critical for
+// workloads like robotics (many small systems) and SLAM (batched poses).
+//
+// Compares:
+//   1. Sequential: one solver handles all systems one by one
+//   2. Batched: N solvers on N streams, all launched before any sync
+//   3. CPU baseline: Eigen LLT on host
+//
+// For Nsight Systems: batched mode should show overlapping kernels on
+// different streams in the timeline view.
+//
+//   nsys profile --trace=cuda ./bench_batching
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <Eigen/Cholesky>
+#include <contrib/Eigen/GPU>
+
+#include <memory>
+#include <vector>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+
+using Scalar = SCALAR;
+using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+static Mat make_spd(Index n) {
+  Mat M = Mat::Random(n, n);
+  return M.adjoint() * M + Mat::Identity(n, n) * static_cast<Scalar>(n);
+}
+
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&p, 1));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaFree(p));
+    done = true;
+  }
+}
+
+// --------------------------------------------------------------------------
+// Sequential: one solver, N systems solved one after another
+// --------------------------------------------------------------------------
+
+static void BM_Batch_Sequential(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int batch_size = static_cast<int>(state.range(1));
+
+  // Pre-generate all SPD matrices and RHS vectors.
+  std::vector<Mat> As(batch_size);
+  std::vector<Mat> Bs(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    As[i] = make_spd(n);
+    Bs[i] = Mat::Random(n, 1);
+  }
+
+  gpu::LLT<Scalar> llt;
+
+  for (auto _ : state) {
+    std::vector<Mat> results(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      llt.compute(As[i]);
+      results[i] = llt.solve(Bs[i]);
+    }
+    benchmark::DoNotOptimize(results.back().data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["batch"] = batch_size;
+  state.counters["total_solves"] = batch_size;
+}
+
+// --------------------------------------------------------------------------
+// Sequential with DeviceMatrix (avoid re-upload of A each iteration)
+// --------------------------------------------------------------------------
+
+static void BM_Batch_Sequential_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int batch_size = static_cast<int>(state.range(1));
+
+  std::vector<Mat> As(batch_size);
+  std::vector<Mat> Bs(batch_size);
+  std::vector<gpu::DeviceMatrix<Scalar>> d_As(batch_size);
+  std::vector<gpu::DeviceMatrix<Scalar>> d_Bs(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    As[i] = make_spd(n);
+    Bs[i] = Mat::Random(n, 1);
+    d_As[i] = gpu::DeviceMatrix<Scalar>::fromHost(As[i]);
+    d_Bs[i] = gpu::DeviceMatrix<Scalar>::fromHost(Bs[i]);
+  }
+
+  gpu::LLT<Scalar> llt;
+
+  for (auto _ : state) {
+    std::vector<Mat> results(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      llt.compute(d_As[i]);
+      gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_Bs[i]);
+      results[i] = d_X.toHost();
+    }
+    benchmark::DoNotOptimize(results.back().data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["batch"] = batch_size;
+  state.counters["total_solves"] = batch_size;
+}
+
+// --------------------------------------------------------------------------
+// Batched: N solvers on N streams, overlapping execution
+// --------------------------------------------------------------------------
+
+static void BM_Batch_MultiStream(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int batch_size = static_cast<int>(state.range(1));
+
+  std::vector<Mat> As(batch_size);
+  std::vector<Mat> Bs(batch_size);
+  std::vector<gpu::DeviceMatrix<Scalar>> d_As(batch_size);
+  std::vector<gpu::DeviceMatrix<Scalar>> d_Bs(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    As[i] = make_spd(n);
+    Bs[i] = Mat::Random(n, 1);
+    d_As[i] = gpu::DeviceMatrix<Scalar>::fromHost(As[i]);
+    d_Bs[i] = gpu::DeviceMatrix<Scalar>::fromHost(Bs[i]);
+  }
+
+  // N solvers = N independent CUDA streams.
+  std::vector<std::unique_ptr<gpu::LLT<Scalar>>> solvers(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    solvers[i] = std::make_unique<gpu::LLT<Scalar>>();
+  }
+
+  for (auto _ : state) {
+    // Phase 1: launch all factorizations (async, different streams).
+    for (int i = 0; i < batch_size; ++i) {
+      solvers[i]->compute(d_As[i]);
+    }
+
+    // Phase 2: launch all solves (async, different streams).
+    std::vector<gpu::DeviceMatrix<Scalar>> d_Xs(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      d_Xs[i] = solvers[i]->solve(d_Bs[i]);
+    }
+
+    // Phase 3: download all results.
+    std::vector<Mat> results(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      results[i] = d_Xs[i].toHost();
+    }
+    benchmark::DoNotOptimize(results.back().data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["batch"] = batch_size;
+  state.counters["streams"] = batch_size;
+  state.counters["total_solves"] = batch_size;
+}
+
+// --------------------------------------------------------------------------
+// Batched with async download (overlap D2H with computation)
+// --------------------------------------------------------------------------
+
+static void BM_Batch_MultiStream_AsyncDownload(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int batch_size = static_cast<int>(state.range(1));
+
+  std::vector<Mat> As(batch_size);
+  std::vector<Mat> Bs(batch_size);
+  std::vector<gpu::DeviceMatrix<Scalar>> d_As(batch_size);
+  std::vector<gpu::DeviceMatrix<Scalar>> d_Bs(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    As[i] = make_spd(n);
+    Bs[i] = Mat::Random(n, 1);
+    d_As[i] = gpu::DeviceMatrix<Scalar>::fromHost(As[i]);
+    d_Bs[i] = gpu::DeviceMatrix<Scalar>::fromHost(Bs[i]);
+  }
+
+  std::vector<std::unique_ptr<gpu::LLT<Scalar>>> solvers(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    solvers[i] = std::make_unique<gpu::LLT<Scalar>>();
+  }
+
+  for (auto _ : state) {
+    // Launch all compute + solve.
+    std::vector<gpu::DeviceMatrix<Scalar>> d_Xs(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      solvers[i]->compute(d_As[i]);
+      d_Xs[i] = solvers[i]->solve(d_Bs[i]);
+    }
+
+    // Enqueue all async downloads.
+    std::vector<gpu::HostTransfer<Scalar>> transfers;
+    transfers.reserve(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      transfers.push_back(d_Xs[i].toHostAsync());
+    }
+
+    // Collect all results.
+    for (int i = 0; i < batch_size; ++i) {
+      benchmark::DoNotOptimize(transfers[i].get().data());
+    }
+  }
+
+  state.counters["n"] = n;
+  state.counters["batch"] = batch_size;
+  state.counters["streams"] = batch_size;
+  state.counters["total_solves"] = batch_size;
+}
+
+// --------------------------------------------------------------------------
+// CPU baseline: Eigen LLT on host, sequential
+// --------------------------------------------------------------------------
+
+static void BM_Batch_CPU(benchmark::State& state) {
+  const Index n = state.range(0);
+  const int batch_size = static_cast<int>(state.range(1));
+
+  std::vector<Mat> As(batch_size);
+  std::vector<Mat> Bs(batch_size);
+  for (int i = 0; i < batch_size; ++i) {
+    As[i] = make_spd(n);
+    Bs[i] = Mat::Random(n, 1);
+  }
+
+  for (auto _ : state) {
+    std::vector<Mat> results(batch_size);
+    for (int i = 0; i < batch_size; ++i) {
+      LLT<Mat> llt(As[i]);
+      results[i] = llt.solve(Bs[i]);
+    }
+    benchmark::DoNotOptimize(results.back().data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["batch"] = batch_size;
+  state.counters["total_solves"] = batch_size;
+}
+
+// --------------------------------------------------------------------------
+// Registration
+// --------------------------------------------------------------------------
+
+// clang-format off
+// Args: {matrix_size, batch_size}
+// Small matrices with large batches are the interesting case for multi-stream.
+BENCHMARK(BM_Batch_Sequential)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Batch_Sequential_Device)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Batch_MultiStream)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Batch_MultiStream_AsyncDownload)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Batch_CPU)->ArgsProduct({{16, 32, 64, 128, 256, 512}, {1, 4, 16, 64}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+
+// Also run larger sizes with moderate batching.
+BENCHMARK(BM_Batch_MultiStream)->ArgsProduct({{1024, 2048}, {1, 4, 8}})->Args({512, 8})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Batch_MultiStream_AsyncDownload)->ArgsProduct({{1024, 2048}, {1, 4, 8}})->Args({512, 8})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+// clang-format on
diff --git a/contrib/benchmarks/GPU/bench_cg_sync.cu b/contrib/benchmarks/GPU/bench_cg_sync.cu
new file mode 100644
index 0000000..3eba481
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_cg_sync.cu
@@ -0,0 +1,294 @@
+// Benchmark: GPU Conjugate Gradient via gpu::DeviceMatrix operators.
+//
+// Shows the path to running Eigen's CG on GPU with minimal code changes.
+// The gpu::DeviceMatrix benchmark mirrors Eigen's conjugate_gradient() line-by-line.
+// A raw cuBLAS device-pointer-mode implementation is included as a lower bound.
+//
+// The only change needed in Eigen's CG template to support gpu::DeviceMatrix:
+//   Line 34:  typedef Dest VectorType;  (instead of Matrix<Scalar, Dynamic, 1>)
+//
+// Usage:
+//   cmake --build build-bench-gpu --target bench_gpu_cg_sync
+//   ./build-bench-gpu/bench_gpu_cg_sync
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+#include <cusparse.h>
+
+using namespace Eigen;
+
+using Scalar = double;
+using RealScalar = double;
+using Vec = Matrix<Scalar, Dynamic, 1>;
+using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+
+static SpMat make_spd(Index n) {
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 3));
+  for (Index i = 0; i < n; ++i) {
+    A.insert(i, i) = 4.0;
+    if (i > 0) A.insert(i, i - 1) = -1.0;
+    if (i < n - 1) A.insert(i, i + 1) = -1.0;
+  }
+  A.makeCompressed();
+  return A;
+}
+
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    cudaMalloc(&p, 1);
+    cudaFree(p);
+    done = true;
+  }
+}
+
+// ==========================================================================
+// GPU CG using gpu::DeviceMatrix operators — mirrors Eigen's conjugate_gradient()
+// ==========================================================================
+//
+// Compare with Eigen/src/IterativeLinearSolvers/ConjugateGradient.h lines 29-84.
+// Left column: Eigen CG code.  Right column: this benchmark.
+//
+//   Eigen CG                              GPU CG (this benchmark)
+//   --------                              -----------------------
+//   VectorType residual = rhs - mat * x;  residual.copyFrom(ctx, rhs);  [x=0 so r=b]
+//   RealScalar rhsNorm2 = rhs.sqNorm();   RealScalar rhsNorm2 = rhs.squaredNorm();
+//   ...
+//   tmp.noalias() = mat * p;              tmp.noalias() = mat * p;  [identical]
+//   Scalar alpha = absNew / p.dot(tmp);   Scalar alpha = absNew / p.dot(tmp);  [identical]
+//   x += alpha * p;                       x += alpha * p;  [identical]
+//   residual -= alpha * tmp;              residual -= alpha * tmp;  [identical]
+//   residualNorm2 = residual.sqNorm();    residualNorm2 = residual.squaredNorm();  [identical]
+//   ...
+//   p = z + beta * p;                     p *= beta; p += z;  [equivalent, no alloc]
+
+static void BM_CG_DeviceMatrixOps(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+
+  SpMat A = make_spd(n);
+  Vec b = Vec::Random(n);
+
+  // One shared context: SpMV + BLAS-1 on same stream, zero event overhead.
+  gpu::Context ctx;
+  gpu::Context::setThreadLocal(&ctx);
+  gpu::SparseContext<Scalar> spmv(ctx);
+  auto mat = spmv.deviceView(A);
+
+  // Upload RHS once.
+  auto rhs = gpu::DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+
+  for (auto _ : state) {
+    // --- Eigen CG lines 34-63: initialization ---
+    //   typedef Dest VectorType;                               // GPU CHANGE: was Matrix<Scalar,Dynamic,1>
+    //   VectorType residual = rhs - mat * x;                   // x=0, so residual = rhs
+    gpu::DeviceMatrix<Scalar> x(n, 1);
+    x.setZero();
+    gpu::DeviceMatrix<Scalar> residual(n, 1);
+    residual.copyFrom(ctx, rhs);
+
+    //   RealScalar rhsNorm2 = rhs.squaredNorm();
+    RealScalar rhsNorm2 = rhs.squaredNorm();
+    if (rhsNorm2 == 0) continue;
+
+    RealScalar tol = 1e-10;
+    const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
+    RealScalar threshold = numext::maxi(RealScalar(tol * tol * rhsNorm2), considerAsZero);
+
+    //   RealScalar residualNorm2 = residual.squaredNorm();
+    RealScalar residualNorm2 = residual.squaredNorm();
+    if (residualNorm2 < threshold) continue;
+
+    //   VectorType p(n);
+    //   p = precond.solve(residual);                           // no preconditioner: p = residual
+    gpu::DeviceMatrix<Scalar> p(n, 1);
+    p.copyFrom(ctx, residual);
+
+    //   VectorType z(n), tmp(n);
+    gpu::DeviceMatrix<Scalar> z(n, 1), tmp(n, 1);
+
+    //   auto absNew = numext::real(residual.dot(p));
+    //   gpu::DeviceScalar — stays on device, no sync.
+    auto absNew = residual.dot(p);  // gpu::DeviceScalar, no sync
+
+    //   while (i < maxIters) {
+    Index maxIters = 200;
+    Index i = 0;
+    while (i < maxIters) {
+      //     tmp.noalias() = mat * p;
+      tmp.noalias() = mat * p;  // SpMV, device-resident
+
+      //     auto alpha = absNew / p.dot(tmp);
+      //   gpu::DeviceScalar / gpu::DeviceScalar → device kernel, no sync!
+      auto alpha = absNew / p.dot(tmp);  // gpu::DeviceScalar, no sync
+
+      //     x += alpha * p;
+      //   gpu::DeviceScalar * gpu::DeviceMatrix → device-pointer axpy, no sync!
+      x += alpha * p;
+
+      //     residual -= alpha * tmp;
+      residual -= alpha * tmp;  // device-pointer axpy, no sync
+
+      //     residualNorm2 = residual.squaredNorm();
+      residualNorm2 = residual.squaredNorm();  // THE one sync per iteration
+
+      //     if (residualNorm2 < threshold) break;
+      if (residualNorm2 < threshold) break;
+
+      //     z = precond.solve(residual);
+      z.copyFrom(ctx, residual);  // no preconditioner
+
+      //     auto absOld = std::move(absNew);
+      auto absOld = std::move(absNew);  // no sync, no alloc
+
+      //     absNew = numext::real(residual.dot(z));
+      absNew = residual.dot(z);  // gpu::DeviceScalar, no sync
+
+      //     auto beta = absNew / absOld;
+      //   gpu::DeviceScalar / gpu::DeviceScalar → device kernel, no sync!
+      auto beta = absNew / absOld;  // gpu::DeviceScalar, no sync
+
+      //     p = z + beta * p;
+      p *= beta;  // device-pointer scal, no host sync
+      p += z;
+
+      i++;
+    }
+  }
+
+  gpu::Context::setThreadLocal(nullptr);
+  state.SetItemsProcessed(state.iterations() * 200);
+}
+
+BENCHMARK(BM_CG_DeviceMatrixOps)->RangeMultiplier(4)->Range(1 << 10, 1 << 20)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ==========================================================================
+// Raw cuBLAS device-pointer-mode CG (1 sync/iter) — performance lower bound
+// ==========================================================================
+
+__global__ void scalar_div_kernel(const Scalar* a, const Scalar* b, Scalar* out) { *out = *a / *b; }
+__global__ void scalar_neg_kernel(const Scalar* in, Scalar* out) { *out = -(*in); }
+
+static void BM_CG_DevicePointerMode(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int maxIters = 200;
+
+  SpMat A = make_spd(n);
+  Vec b = Vec::Random(n);
+
+  cudaStream_t stream;
+  cudaStreamCreate(&stream);
+  cublasHandle_t cublas;
+  cublasCreate(&cublas);
+  cublasSetStream(cublas, stream);
+
+  cusparseHandle_t cusparse;
+  cusparseCreate(&cusparse);
+  cusparseSetStream(cusparse, stream);
+
+  gpu::internal::DeviceBuffer d_outer((n + 1) * sizeof(int));
+  gpu::internal::DeviceBuffer d_inner(A.nonZeros() * sizeof(int));
+  gpu::internal::DeviceBuffer d_vals(A.nonZeros() * sizeof(Scalar));
+  cudaMemcpy(d_outer.get(), A.outerIndexPtr(), (n + 1) * sizeof(int), cudaMemcpyHostToDevice);
+  cudaMemcpy(d_inner.get(), A.innerIndexPtr(), A.nonZeros() * sizeof(int), cudaMemcpyHostToDevice);
+  cudaMemcpy(d_vals.get(), A.valuePtr(), A.nonZeros() * sizeof(Scalar), cudaMemcpyHostToDevice);
+
+  cusparseSpMatDescr_t matA;
+  cusparseCreateCsc(&matA, n, n, A.nonZeros(), d_outer.get(), d_inner.get(), d_vals.get(), CUSPARSE_INDEX_32I,
+                    CUSPARSE_INDEX_32I, CUSPARSE_INDEX_BASE_ZERO, CUDA_R_64F);
+
+  gpu::internal::DeviceBuffer d_tmp_buf(n * sizeof(Scalar));
+  cusparseDnVecDescr_t tmp_x, tmp_y;
+  cusparseCreateDnVec(&tmp_x, n, d_tmp_buf.get(), CUDA_R_64F);
+  cusparseCreateDnVec(&tmp_y, n, d_tmp_buf.get(), CUDA_R_64F);
+  Scalar spmv_alpha = 1.0, spmv_beta = 0.0;
+  size_t ws_size = 0;
+  cusparseSpMV_bufferSize(cusparse, CUSPARSE_OPERATION_NON_TRANSPOSE, &spmv_alpha, matA, tmp_x, &spmv_beta, tmp_y,
+                          CUDA_R_64F, CUSPARSE_SPMV_ALG_DEFAULT, &ws_size);
+  gpu::internal::DeviceBuffer d_workspace(ws_size);
+  cusparseDestroyDnVec(tmp_x);
+  cusparseDestroyDnVec(tmp_y);
+
+  gpu::internal::DeviceBuffer d_x(n * sizeof(Scalar)), d_r(n * sizeof(Scalar));
+  gpu::internal::DeviceBuffer d_p(n * sizeof(Scalar)), d_tmp(n * sizeof(Scalar));
+  gpu::internal::DeviceBuffer d_b(n * sizeof(Scalar));
+  gpu::internal::DeviceBuffer d_absNew(sizeof(Scalar)), d_absOld(sizeof(Scalar));
+  gpu::internal::DeviceBuffer d_pdot(sizeof(Scalar)), d_alpha(sizeof(Scalar));
+  gpu::internal::DeviceBuffer d_neg_alpha(sizeof(Scalar)), d_beta(sizeof(Scalar));
+  gpu::internal::DeviceBuffer d_rnorm(sizeof(RealScalar));
+
+  cudaMemcpy(d_b.get(), b.data(), n * sizeof(Scalar), cudaMemcpyHostToDevice);
+
+  auto spmv = [&](Scalar* x_ptr, Scalar* y_ptr) {
+    cusparseDnVecDescr_t vx, vy;
+    cusparseCreateDnVec(&vx, n, x_ptr, CUDA_R_64F);
+    cusparseCreateDnVec(&vy, n, y_ptr, CUDA_R_64F);
+    cusparseSpMV(cusparse, CUSPARSE_OPERATION_NON_TRANSPOSE, &spmv_alpha, matA, vx, &spmv_beta, vy, CUDA_R_64F,
+                 CUSPARSE_SPMV_ALG_DEFAULT, d_workspace.get());
+    cusparseDestroyDnVec(vx);
+    cusparseDestroyDnVec(vy);
+  };
+
+  for (auto _ : state) {
+    cudaMemsetAsync(static_cast<Scalar*>(d_x.get()), 0, n * sizeof(Scalar), stream);
+    cudaMemcpyAsync(d_r.get(), d_b.get(), n * sizeof(Scalar), cudaMemcpyDeviceToDevice, stream);
+    cudaMemcpyAsync(d_p.get(), d_b.get(), n * sizeof(Scalar), cudaMemcpyDeviceToDevice, stream);
+
+    cublasSetPointerMode(cublas, CUBLAS_POINTER_MODE_DEVICE);
+    cublasDdot(cublas, n, static_cast<Scalar*>(d_r.get()), 1, static_cast<Scalar*>(d_p.get()), 1,
+               static_cast<Scalar*>(d_absNew.get()));
+
+    for (int i = 0; i < maxIters; ++i) {
+      spmv(static_cast<Scalar*>(d_p.get()), static_cast<Scalar*>(d_tmp.get()));
+
+      cublasDdot(cublas, n, static_cast<Scalar*>(d_p.get()), 1, static_cast<Scalar*>(d_tmp.get()), 1,
+                 static_cast<Scalar*>(d_pdot.get()));
+
+      scalar_div_kernel<<<1, 1, 0, stream>>>(static_cast<Scalar*>(d_absNew.get()), static_cast<Scalar*>(d_pdot.get()),
+                                             static_cast<Scalar*>(d_alpha.get()));
+      scalar_neg_kernel<<<1, 1, 0, stream>>>(static_cast<Scalar*>(d_alpha.get()),
+                                             static_cast<Scalar*>(d_neg_alpha.get()));
+
+      cublasDaxpy(cublas, n, static_cast<Scalar*>(d_alpha.get()), static_cast<Scalar*>(d_p.get()), 1,
+                  static_cast<Scalar*>(d_x.get()), 1);
+      cublasDaxpy(cublas, n, static_cast<Scalar*>(d_neg_alpha.get()), static_cast<Scalar*>(d_tmp.get()), 1,
+                  static_cast<Scalar*>(d_r.get()), 1);
+
+      cublasDnrm2(cublas, n, static_cast<Scalar*>(d_r.get()), 1, static_cast<RealScalar*>(d_rnorm.get()));
+
+      RealScalar rnorm;
+      cudaMemcpyAsync(&rnorm, d_rnorm.get(), sizeof(RealScalar), cudaMemcpyDeviceToHost, stream);
+      cudaStreamSynchronize(stream);
+      if (rnorm * rnorm < 1e-20) break;
+
+      cudaMemcpyAsync(d_absOld.get(), d_absNew.get(), sizeof(Scalar), cudaMemcpyDeviceToDevice, stream);
+      cublasDdot(cublas, n, static_cast<Scalar*>(d_r.get()), 1, static_cast<Scalar*>(d_r.get()), 1,
+                 static_cast<Scalar*>(d_absNew.get()));
+
+      scalar_div_kernel<<<1, 1, 0, stream>>>(static_cast<Scalar*>(d_absNew.get()), static_cast<Scalar*>(d_absOld.get()),
+                                             static_cast<Scalar*>(d_beta.get()));
+
+      cublasDscal(cublas, n, static_cast<Scalar*>(d_beta.get()), static_cast<Scalar*>(d_p.get()), 1);
+      cublasSetPointerMode(cublas, CUBLAS_POINTER_MODE_HOST);
+      Scalar one = 1.0;
+      cublasDaxpy(cublas, n, &one, static_cast<Scalar*>(d_r.get()), 1, static_cast<Scalar*>(d_p.get()), 1);
+      cublasSetPointerMode(cublas, CUBLAS_POINTER_MODE_DEVICE);
+    }
+    cudaStreamSynchronize(stream);
+  }
+
+  state.SetItemsProcessed(state.iterations() * maxIters);
+  cusparseDestroySpMat(matA);
+  cusparseDestroy(cusparse);
+  cublasDestroy(cublas);
+  cudaStreamDestroy(stream);
+}
+
+BENCHMARK(BM_CG_DevicePointerMode)->RangeMultiplier(4)->Range(1 << 10, 1 << 20)->UseRealTime()->MinWarmUpTime(0.5);
diff --git a/contrib/benchmarks/GPU/bench_cg_vs_cpu.cu b/contrib/benchmarks/GPU/bench_cg_vs_cpu.cu
new file mode 100644
index 0000000..ea94211
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_cg_vs_cpu.cu
@@ -0,0 +1,218 @@
+// Benchmark: GPU CG vs CPU CG on realistic sparse systems.
+//
+// Tests 2D Laplacian (5-point stencil) and 3D Laplacian (7-point stencil)
+// in both float and double precision.
+//
+// Usage:
+//   cmake --build build-bench-gpu --target bench_gpu_cg_vs_cpu
+//   ./build-bench-gpu/bench_gpu_cg_vs_cpu
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <Eigen/Sparse>
+#include <Eigen/IterativeLinearSolvers>
+#include <contrib/Eigen/GPU>
+
+using namespace Eigen;
+
+// ---- Sparse matrix generators -----------------------------------------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_laplacian_2d(int grid_n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  const int n = grid_n * grid_n;
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 5));
+  for (int i = 0; i < grid_n; ++i) {
+    for (int j = 0; j < grid_n; ++j) {
+      int idx = i * grid_n + j;
+      A.insert(idx, idx) = Scalar(4);
+      if (i > 0) A.insert(idx, idx - grid_n) = Scalar(-1);
+      if (i < grid_n - 1) A.insert(idx, idx + grid_n) = Scalar(-1);
+      if (j > 0) A.insert(idx, idx - 1) = Scalar(-1);
+      if (j < grid_n - 1) A.insert(idx, idx + 1) = Scalar(-1);
+    }
+  }
+  A.makeCompressed();
+  return A;
+}
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_laplacian_3d(int grid_n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  const int n = grid_n * grid_n * grid_n;
+  const int n2 = grid_n * grid_n;
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 7));
+  for (int i = 0; i < grid_n; ++i) {
+    for (int j = 0; j < grid_n; ++j) {
+      for (int k = 0; k < grid_n; ++k) {
+        int idx = i * n2 + j * grid_n + k;
+        A.insert(idx, idx) = Scalar(6);
+        if (i > 0) A.insert(idx, idx - n2) = Scalar(-1);
+        if (i < grid_n - 1) A.insert(idx, idx + n2) = Scalar(-1);
+        if (j > 0) A.insert(idx, idx - grid_n) = Scalar(-1);
+        if (j < grid_n - 1) A.insert(idx, idx + grid_n) = Scalar(-1);
+        if (k > 0) A.insert(idx, idx - 1) = Scalar(-1);
+        if (k < grid_n - 1) A.insert(idx, idx + 1) = Scalar(-1);
+      }
+    }
+  }
+  A.makeCompressed();
+  return A;
+}
+
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    cudaMalloc(&p, 1);
+    cudaFree(p);
+    done = true;
+  }
+}
+
+// ---- CPU CG -----------------------------------------------------------------
+
+template <typename Scalar, typename MatGen>
+void run_cpu_cg(benchmark::State& state, MatGen make_matrix) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  const int grid_n = state.range(0);
+  SpMat A = make_matrix(grid_n);
+  Vec b = Vec::Random(A.rows());
+
+  ConjugateGradient<SpMat, Lower | Upper> cg;
+  cg.setMaxIterations(10000);
+  cg.setTolerance(RealScalar(1e-8));
+  cg.compute(A);
+
+  int last_iters = 0;
+  for (auto _ : state) {
+    Vec x = cg.solve(b);
+    benchmark::DoNotOptimize(x.data());
+    last_iters = cg.iterations();
+  }
+  state.counters["n"] = A.rows();
+  state.counters["nnz"] = A.nonZeros();
+  state.counters["iters"] = last_iters;
+  state.counters["error"] = cg.error();
+}
+
+// ---- GPU CG -----------------------------------------------------------------
+
+template <typename Scalar, typename MatGen>
+void run_gpu_cg(benchmark::State& state, MatGen make_matrix) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  cuda_warmup();
+  const int grid_n = state.range(0);
+  SpMat A = make_matrix(grid_n);
+  const Index n = A.rows();
+  Vec b = Vec::Random(n);
+
+  // Extract inverse diagonal.
+  Vec invdiag(n);
+  for (Index j = 0; j < A.outerSize(); ++j) {
+    typename SpMat::InnerIterator it(A, j);
+    while (it && it.index() != j) ++it;
+    if (it && it.index() == j && it.value() != Scalar(0))
+      invdiag(j) = Scalar(1) / it.value();
+    else
+      invdiag(j) = Scalar(1);
+  }
+
+  gpu::Context ctx;
+  gpu::Context::setThreadLocal(&ctx);
+  gpu::SparseContext<Scalar> spmv_ctx(ctx);
+  auto mat = spmv_ctx.deviceView(A);
+  auto d_invdiag = gpu::DeviceMatrix<Scalar>::fromHost(invdiag, ctx.stream());
+  auto d_b = gpu::DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+
+  int last_iters = 0;
+  RealScalar last_error = 0;
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<Scalar> d_x(n, 1);
+    d_x.setZero(ctx);
+    gpu::DeviceMatrix<Scalar> residual(n, 1);
+    residual.copyFrom(ctx, d_b);
+
+    RealScalar rhsNorm2 = d_b.squaredNorm(ctx);
+    RealScalar tol = RealScalar(1e-8);
+    RealScalar threshold = tol * tol * rhsNorm2;
+    RealScalar residualNorm2 = residual.squaredNorm(ctx);
+
+    gpu::DeviceMatrix<Scalar> p = d_invdiag.cwiseProduct(ctx, residual);
+    gpu::DeviceMatrix<Scalar> z(n, 1), tmp(n, 1);
+
+    auto absNew = residual.dot(ctx, p);
+    Index i = 0;
+    Index maxIters = 10000;
+    while (i < maxIters) {
+      tmp.noalias() = mat * p;
+      auto alpha = absNew / p.dot(ctx, tmp);
+      d_x += alpha * p;
+      residual -= alpha * tmp;
+
+      residualNorm2 = residual.squaredNorm(ctx);
+      if (residualNorm2 < threshold) break;
+
+      z.cwiseProduct(ctx, d_invdiag, residual);
+      auto absOld = std::move(absNew);
+      absNew = residual.dot(ctx, z);
+      auto beta = absNew / absOld;
+
+      p *= beta;
+      p += z;
+      i++;
+    }
+    benchmark::DoNotOptimize(d_x.data());
+    last_iters = i;
+    last_error = numext::sqrt(residualNorm2 / rhsNorm2);
+  }
+
+  gpu::Context::setThreadLocal(nullptr);
+  state.counters["n"] = n;
+  state.counters["nnz"] = A.nonZeros();
+  state.counters["iters"] = last_iters;
+  state.counters["error"] = last_error;
+}
+
+// ---- 2D Laplacian, double ---------------------------------------------------
+
+static void BM_CG_CPU_2D_double(benchmark::State& state) { run_cpu_cg<double>(state, make_laplacian_2d<double>); }
+static void BM_CG_GPU_2D_double(benchmark::State& state) { run_gpu_cg<double>(state, make_laplacian_2d<double>); }
+
+BENCHMARK(BM_CG_CPU_2D_double)->ArgsProduct({{32, 64, 128, 256, 512}})->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_CG_GPU_2D_double)->ArgsProduct({{32, 64, 128, 256, 512}})->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---- 2D Laplacian, float ----------------------------------------------------
+
+static void BM_CG_CPU_2D_float(benchmark::State& state) { run_cpu_cg<float>(state, make_laplacian_2d<float>); }
+static void BM_CG_GPU_2D_float(benchmark::State& state) { run_gpu_cg<float>(state, make_laplacian_2d<float>); }
+
+BENCHMARK(BM_CG_CPU_2D_float)->ArgsProduct({{32, 64, 128, 256, 512}})->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_CG_GPU_2D_float)->ArgsProduct({{32, 64, 128, 256, 512}})->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---- 3D Laplacian, double ---------------------------------------------------
+
+static void BM_CG_CPU_3D_double(benchmark::State& state) { run_cpu_cg<double>(state, make_laplacian_3d<double>); }
+static void BM_CG_GPU_3D_double(benchmark::State& state) { run_gpu_cg<double>(state, make_laplacian_3d<double>); }
+
+BENCHMARK(BM_CG_CPU_3D_double)->ArgsProduct({{16, 32, 48, 64}})->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_CG_GPU_3D_double)->ArgsProduct({{16, 32, 48, 64}})->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---- 3D Laplacian, float ----------------------------------------------------
+
+static void BM_CG_CPU_3D_float(benchmark::State& state) { run_cpu_cg<float>(state, make_laplacian_3d<float>); }
+static void BM_CG_GPU_3D_float(benchmark::State& state) { run_gpu_cg<float>(state, make_laplacian_3d<float>); }
+
+BENCHMARK(BM_CG_CPU_3D_float)->ArgsProduct({{16, 32, 48, 64}})->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_CG_GPU_3D_float)->ArgsProduct({{16, 32, 48, 64}})->UseRealTime()->MinWarmUpTime(0.5);
diff --git a/contrib/benchmarks/GPU/bench_chaining.cpp b/contrib/benchmarks/GPU/bench_chaining.cpp
new file mode 100644
index 0000000..1a47df7
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_chaining.cpp
@@ -0,0 +1,234 @@
+// GPU chaining benchmarks: measure async pipeline efficiency.
+//
+// Compares:
+//   1. Host round-trip per solve (baseline)
+//   2. DeviceMatrix chaining (no host round-trip between solves)
+//   3. Varying chain lengths (1, 2, 4, 8 consecutive solves)
+//
+// For Nsight Systems: look for gaps between kernel launches in the timeline.
+// Host round-trip creates visible idle gaps; chaining should show back-to-back kernels.
+//
+//   nsys profile --trace=cuda,nvtx ./bench_chaining
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <Eigen/Cholesky>
+#include <contrib/Eigen/GPU>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+
+using Scalar = SCALAR;
+using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+static Mat make_spd(Index n) {
+  Mat M = Mat::Random(n, n);
+  return M.adjoint() * M + Mat::Identity(n, n) * static_cast<Scalar>(n);
+}
+
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&p, 1));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaFree(p));
+    done = true;
+  }
+}
+
+// --------------------------------------------------------------------------
+// Baseline: host round-trip between every solve
+// --------------------------------------------------------------------------
+
+static void BM_Chain_HostRoundtrip(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int chain_len = static_cast<int>(state.range(1));
+
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, 1);
+  gpu::LLT<Scalar> llt(A);
+
+  for (auto _ : state) {
+    Mat X = B;
+    for (int i = 0; i < chain_len; ++i) {
+      X = llt.solve(X);  // host → device → host each time
+    }
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["chain"] = chain_len;
+  state.counters["solves/iter"] = chain_len;
+}
+
+// --------------------------------------------------------------------------
+// DeviceMatrix chaining: no host round-trip between solves
+// --------------------------------------------------------------------------
+
+static void BM_Chain_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int chain_len = static_cast<int>(state.range(1));
+
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, 1);
+  gpu::LLT<Scalar> llt(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+    for (int i = 1; i < chain_len; ++i) {
+      d_X = llt.solve(d_X);  // device → device, fully async
+    }
+    Mat X = d_X.toHost();  // single sync at end
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["chain"] = chain_len;
+  state.counters["solves/iter"] = chain_len;
+}
+
+// --------------------------------------------------------------------------
+// DeviceMatrix chaining with async download (overlap D2H with next iteration)
+//
+// Double-buffered: each loop body issues iteration N+1's chain *before*
+// draining iteration N's D2H, so the host wait overlaps with on-device
+// compute instead of stalling the pipeline.
+// --------------------------------------------------------------------------
+
+static void BM_Chain_DeviceAsync(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int chain_len = static_cast<int>(state.range(1));
+
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, 1);
+  gpu::LLT<Scalar> llt(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  auto run_chain = [&]() {
+    gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+    for (int i = 1; i < chain_len; ++i) {
+      d_X = llt.solve(d_X);
+    }
+    return d_X.toHostAsync();
+  };
+
+  // Prime the pipeline so each timed iteration overlaps a fresh chain
+  // with the previous iteration's D2H.
+  auto prev = run_chain();
+
+  for (auto _ : state) {
+    auto next = run_chain();  // kick off N+1 while D2H of N is in flight
+    Mat X = prev.get();       // drain N (overlaps with `next` compute)
+    benchmark::DoNotOptimize(X.data());
+    prev = std::move(next);
+  }
+
+  // Drain the trailing transfer outside the timed region.
+  prev.get();
+
+  state.counters["n"] = n;
+  state.counters["chain"] = chain_len;
+  state.counters["solves/iter"] = chain_len;
+}
+
+// --------------------------------------------------------------------------
+// Pure GPU chain (no download — measures kernel-only throughput)
+// --------------------------------------------------------------------------
+
+static void BM_Chain_DeviceNoDownload(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int chain_len = static_cast<int>(state.range(1));
+
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, 1);
+  gpu::LLT<Scalar> llt(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+    for (int i = 1; i < chain_len; ++i) {
+      d_X = llt.solve(d_X);
+    }
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(llt.stream()));
+    benchmark::DoNotOptimize(d_X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["chain"] = chain_len;
+  state.counters["solves/iter"] = chain_len;
+}
+
+// --------------------------------------------------------------------------
+// Compute + solve chain (full pipeline: factorize, then chain solves)
+// --------------------------------------------------------------------------
+
+static void BM_FullPipeline_Host(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int chain_len = static_cast<int>(state.range(1));
+
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, 1);
+
+  for (auto _ : state) {
+    gpu::LLT<Scalar> llt(A);
+    Mat X = B;
+    for (int i = 0; i < chain_len; ++i) {
+      X = llt.solve(X);
+    }
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["chain"] = chain_len;
+}
+
+static void BM_FullPipeline_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const int chain_len = static_cast<int>(state.range(1));
+
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, 1);
+
+  for (auto _ : state) {
+    auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+    auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+    gpu::LLT<Scalar> llt;
+    llt.compute(d_A);
+    gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+    for (int i = 1; i < chain_len; ++i) {
+      d_X = llt.solve(d_X);
+    }
+    Mat X = d_X.toHost();
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["chain"] = chain_len;
+}
+
+// --------------------------------------------------------------------------
+// Registration
+// --------------------------------------------------------------------------
+
+// clang-format off
+// Args: {matrix_size, chain_length}
+BENCHMARK(BM_Chain_HostRoundtrip)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Chain_Device)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Chain_DeviceAsync)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_Chain_DeviceNoDownload)->ArgsProduct({{64, 256, 1024, 4096}, {1, 2, 4, 8}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+
+BENCHMARK(BM_FullPipeline_Host)->ArgsProduct({{256, 1024, 4096}, {1, 4}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_FullPipeline_Device)->ArgsProduct({{256, 1024, 4096}, {1, 4}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+// clang-format on
diff --git a/contrib/benchmarks/GPU/bench_fft.cpp b/contrib/benchmarks/GPU/bench_fft.cpp
new file mode 100644
index 0000000..e1cfd26
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_fft.cpp
@@ -0,0 +1,188 @@
+// GPU FFT benchmarks: GpuFFT 1D and 2D throughput.
+//
+// Measures forward and inverse FFT performance across a range of sizes,
+// including plan-amortized (reuse) and cold-start (new plan) scenarios.
+//
+// Usage:
+//   cmake --build build-bench-gpu --target bench_fft bench_fft_double
+//   ./build-bench-gpu/bench_fft
+//   ./build-bench-gpu/bench_fft_double
+//
+// Profiling:
+//   nsys profile --trace=cuda ./build-bench-gpu/bench_fft
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <contrib/Eigen/GPU>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR float
+#endif
+
+using Scalar = SCALAR;
+using Complex = std::complex<Scalar>;
+using CVec = Matrix<Complex, Dynamic, 1>;
+using RVec = Matrix<Scalar, Dynamic, 1>;
+using CMat = Matrix<Complex, Dynamic, Dynamic>;
+
+// CUDA warm-up: ensure the GPU is initialized before timing.
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&p, 1));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaFree(p));
+    done = true;
+  }
+}
+
+// --------------------------------------------------------------------------
+// 1D C2C Forward
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_1D_C2C_Fwd(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  CVec x = CVec::Random(n);
+  gpu::FFT<Scalar> fft;
+
+  // Warm up plan.
+  CVec tmp = fft.fwd(x);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(fft.fwd(x));
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+  state.SetBytesProcessed(state.iterations() * n * sizeof(Complex) * 2);  // read + write
+}
+
+BENCHMARK(BM_GpuFFT_1D_C2C_Fwd)->RangeMultiplier(4)->Range(1 << 10, 1 << 22)->UseRealTime()->MinWarmUpTime(0.5);
+
+// --------------------------------------------------------------------------
+// 1D C2C Inverse
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_1D_C2C_Inv(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  CVec x = CVec::Random(n);
+  gpu::FFT<Scalar> fft;
+  CVec X = fft.fwd(x);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(fft.inv(X));
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+  state.SetBytesProcessed(state.iterations() * n * sizeof(Complex) * 2);
+}
+
+BENCHMARK(BM_GpuFFT_1D_C2C_Inv)->RangeMultiplier(4)->Range(1 << 10, 1 << 22)->UseRealTime()->MinWarmUpTime(0.5);
+
+// --------------------------------------------------------------------------
+// 1D R2C Forward
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_1D_R2C_Fwd(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  RVec r = RVec::Random(n);
+  gpu::FFT<Scalar> fft;
+
+  // Warm up plan.
+  CVec tmp = fft.fwd(r);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(fft.fwd(r));
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+  state.SetBytesProcessed(state.iterations() * (n * sizeof(Scalar) + (n / 2 + 1) * sizeof(Complex)));
+}
+
+BENCHMARK(BM_GpuFFT_1D_R2C_Fwd)->RangeMultiplier(4)->Range(1 << 10, 1 << 22)->UseRealTime()->MinWarmUpTime(0.5);
+
+// --------------------------------------------------------------------------
+// 1D C2R Inverse
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_1D_C2R_Inv(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  RVec r = RVec::Random(n);
+  gpu::FFT<Scalar> fft;
+  CVec R = fft.fwd(r);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(fft.invReal(R, n));
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+  state.SetBytesProcessed(state.iterations() * ((n / 2 + 1) * sizeof(Complex) + n * sizeof(Scalar)));
+}
+
+BENCHMARK(BM_GpuFFT_1D_C2R_Inv)->RangeMultiplier(4)->Range(1 << 10, 1 << 22)->UseRealTime()->MinWarmUpTime(0.5);
+
+// --------------------------------------------------------------------------
+// 2D C2C Forward
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_2D_C2C_Fwd(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);  // square n x n
+  CMat A = CMat::Random(n, n);
+  gpu::FFT<Scalar> fft;
+
+  // Warm up plan.
+  CMat tmp = fft.fwd2(A);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(fft.fwd2(A));
+  }
+  state.SetItemsProcessed(state.iterations() * n * n);
+  state.SetBytesProcessed(state.iterations() * n * n * sizeof(Complex) * 2);
+}
+
+BENCHMARK(BM_GpuFFT_2D_C2C_Fwd)->RangeMultiplier(2)->Range(64, 4096)->UseRealTime()->MinWarmUpTime(0.5);
+
+// --------------------------------------------------------------------------
+// 2D C2C Roundtrip (fwd + inv)
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_2D_C2C_Roundtrip(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  CMat A = CMat::Random(n, n);
+  gpu::FFT<Scalar> fft;
+
+  // Warm up plans.
+  CMat tmp = fft.inv2(fft.fwd2(A));
+
+  for (auto _ : state) {
+    CMat B = fft.fwd2(A);
+    benchmark::DoNotOptimize(fft.inv2(B));
+  }
+  state.SetItemsProcessed(state.iterations() * n * n * 2);  // fwd + inv
+  state.SetBytesProcessed(state.iterations() * n * n * sizeof(Complex) * 4);
+}
+
+BENCHMARK(BM_GpuFFT_2D_C2C_Roundtrip)->RangeMultiplier(2)->Range(64, 4096)->UseRealTime()->MinWarmUpTime(0.5);
+
+// --------------------------------------------------------------------------
+// 1D Cold start (includes plan creation)
+// --------------------------------------------------------------------------
+
+static void BM_GpuFFT_1D_ColdStart(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  CVec x = CVec::Random(n);
+
+  for (auto _ : state) {
+    gpu::FFT<Scalar> fft;  // new object = new plans
+    benchmark::DoNotOptimize(fft.fwd(x));
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+}
+
+BENCHMARK(BM_GpuFFT_1D_ColdStart)->RangeMultiplier(4)->Range(1 << 10, 1 << 20)->UseRealTime()->MinWarmUpTime(0.5);
diff --git a/contrib/benchmarks/GPU/bench_gemm.cpp b/contrib/benchmarks/GPU/bench_gemm.cpp
new file mode 100644
index 0000000..87aa974
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_gemm.cpp
@@ -0,0 +1,179 @@
+// GEMM dispatch benchmark: measure DeviceMatrix GEMM throughput across sizes.
+//
+// Compares cublasLtMatmul with plan cache against a raw cublasGemmEx call
+// (no descriptor overhead) to verify no regression.
+//
+// Usage:
+//   cmake --build build-bench-gpu --target bench_gemm
+//   ./build-bench-gpu/bench_gemm
+//
+// Profiling:
+//   nsys profile --trace=cuda ./build-bench-gpu/bench_gemm
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+// EIGEN_USE_GPU is set by the CMake target (eigen_add_gpu_benchmark).
+#include <contrib/Eigen/GPU>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+
+using Scalar = SCALAR;
+using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    cudaMalloc(&p, 256);
+    cudaFree(p);
+    // Force context creation and JIT.
+    gpu::Context ctx;
+    Mat A = Mat::Random(64, 64);
+    Mat B = Mat::Random(64, 64);
+    auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A, ctx.stream());
+    auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B, ctx.stream());
+    gpu::DeviceMatrix<Scalar> d_C;
+    d_C.device(ctx) = d_A * d_B;
+    if (cudaDeviceSynchronize() != cudaSuccess) abort();
+    done = true;
+  }
+}
+
+// --------------------------------------------------------------------------
+// DeviceMatrix GEMM (uses cublasLtMatmul with plan cache)
+// --------------------------------------------------------------------------
+
+static void BM_DeviceMatrix_Gemm(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+
+  gpu::Context ctx;
+  Mat hostA = Mat::Random(n, n);
+  Mat hostB = Mat::Random(n, n);
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(hostA, ctx.stream());
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(hostB, ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_C;
+
+  // Warmup: run a few GEMMs to stabilize clocks and populate plan cache.
+  for (int i = 0; i < 5; ++i) {
+    d_C.device(ctx) = d_A * d_B;
+  }
+  if (cudaDeviceSynchronize() != cudaSuccess) abort();
+
+  for (auto _ : state) {
+    d_C.device(ctx) = d_A * d_B;
+    if (cudaDeviceSynchronize() != cudaSuccess) abort();
+  }
+
+  double flops = 2.0 * n * n * n;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// --------------------------------------------------------------------------
+// Raw cublasGemmEx (direct call, no descriptor overhead)
+// --------------------------------------------------------------------------
+
+static void BM_Raw_CublasGemmEx(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+
+  gpu::Context ctx;
+  Mat hostA = Mat::Random(n, n);
+  Mat hostB = Mat::Random(n, n);
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(hostA, ctx.stream());
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(hostB, ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_C(n, n);
+
+  constexpr cudaDataType_t dtype = gpu::internal::cuda_data_type<Scalar>::value;
+  constexpr cublasComputeType_t compute = gpu::internal::cuda_compute_type<Scalar>::value;
+  Scalar alpha = Scalar(1);
+  Scalar beta = Scalar(0);
+  const int ni = static_cast<int>(n);
+
+  constexpr cublasGemmAlgo_t algo = gpu::internal::cuda_gemm_algo();
+
+  // Warmup.
+  for (int i = 0; i < 5; ++i) {
+    cublasStatus_t s = cublasGemmEx(ctx.cublasHandle(), CUBLAS_OP_N, CUBLAS_OP_N, ni, ni, ni, &alpha, d_A.data(), dtype,
+                                    ni, d_B.data(), dtype, ni, &beta, d_C.data(), dtype, ni, compute, algo);
+    if (s != CUBLAS_STATUS_SUCCESS) {
+      state.SkipWithError("cublasGemmEx failed");
+      return;
+    }
+  }
+  if (cudaDeviceSynchronize() != cudaSuccess) abort();
+
+  for (auto _ : state) {
+    cublasStatus_t s = cublasGemmEx(ctx.cublasHandle(), CUBLAS_OP_N, CUBLAS_OP_N, ni, ni, ni, &alpha, d_A.data(), dtype,
+                                    ni, d_B.data(), dtype, ni, &beta, d_C.data(), dtype, ni, compute, algo);
+    if (s != CUBLAS_STATUS_SUCCESS) {
+      state.SkipWithError("cublasGemmEx failed");
+      return;
+    }
+    if (cudaDeviceSynchronize() != cudaSuccess) abort();
+  }
+
+  double flops = 2.0 * n * n * n;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// --------------------------------------------------------------------------
+// DeviceMatrix GEMM with transpose: C = A^T * B
+// --------------------------------------------------------------------------
+
+static void BM_DeviceMatrix_Gemm_TransA(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+
+  gpu::Context ctx;
+  Mat hostA = Mat::Random(n, n);
+  Mat hostB = Mat::Random(n, n);
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(hostA, ctx.stream());
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(hostB, ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_C;
+
+  for (int i = 0; i < 5; ++i) {
+    d_C.device(ctx) = d_A.transpose() * d_B;
+  }
+  if (cudaDeviceSynchronize() != cudaSuccess) abort();
+
+  for (auto _ : state) {
+    d_C.device(ctx) = d_A.transpose() * d_B;
+    if (cudaDeviceSynchronize() != cudaSuccess) abort();
+  }
+
+  double flops = 2.0 * n * n * n;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// Square GEMM: range of sizes from small (where descriptor overhead matters)
+// to large (where compute dominates).
+BENCHMARK(BM_DeviceMatrix_Gemm)
+    ->ArgsProduct({{16, 32, 64, 128, 256, 512, 1024, 2048, 4096}})
+    ->Unit(benchmark::kMicrosecond)
+    ->UseRealTime()
+    ->MinWarmUpTime(0.5);
+
+BENCHMARK(BM_Raw_CublasGemmEx)
+    ->ArgsProduct({{16, 32, 64, 128, 256, 512, 1024, 2048, 4096}})
+    ->Unit(benchmark::kMicrosecond)
+    ->UseRealTime()
+    ->MinWarmUpTime(0.5);
+
+BENCHMARK(BM_DeviceMatrix_Gemm_TransA)
+    ->ArgsProduct({{16, 32, 64, 128, 256, 512, 1024, 2048, 4096}})
+    ->Unit(benchmark::kMicrosecond)
+    ->UseRealTime()
+    ->MinWarmUpTime(0.5);
diff --git a/contrib/benchmarks/GPU/bench_overhead.cpp b/contrib/benchmarks/GPU/bench_overhead.cpp
new file mode 100644
index 0000000..b5d42ba
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_overhead.cpp
@@ -0,0 +1,351 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Micro-benchmarks for per-call overhead in the GPU module's core layer:
+// allocation traffic, hidden host synchronization, and host-side copies.
+// Each benchmark pairs the current API path against a hand-rolled baseline
+// that shows what the same operation costs without the overhead, so the gap
+// is directly attributable.
+//
+//   FromHost / FromHostAsync    — extra host-side PlainMatrix copy in fromHost()
+//   GemmFreshDst / PreallocDst  — cudaMalloc/cudaFree per GEMM temporary
+//   DotDeviceScalar / DotRaw    — DeviceScalar wrapper cost per reduction
+//   OneShotLltExpr / CachedLlt / RawPotrs — expression-solve sync + allocs
+//   CudaMalloc / CudaMallocAsync — stream-ordered allocation as a remedy
+//   SmallBuffer* / PoolAllocFree — small DeviceBuffer round trip (idle, behind in-flight work) and the pool itself
+//
+// Build (standalone project, see CMakeLists.txt in this directory):
+//   cmake -G Ninja -B build-bench-gpu -S contrib/benchmarks/GPU \
+//         -DCMAKE_CUDA_ARCHITECTURES=89
+//   cmake --build build-bench-gpu --target bench_overhead
+//   ./build-bench-gpu/bench_overhead
+
+#ifndef EIGEN_USE_GPU
+#define EIGEN_USE_GPU
+#endif
+#include <Eigen/Cholesky>
+#include <Eigen/SparseCore>
+#include <contrib/Eigen/GPU>
+
+#include <benchmark/benchmark.h>
+#include <cuda_runtime.h>
+#include <cusolverDn.h>
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+using Scalar = SCALAR;
+
+using Eigen::Index;
+namespace gpu = Eigen::gpu;
+using DeviceMatrix = gpu::DeviceMatrix<Scalar>;
+using HostMatrix = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+
+namespace {
+
+HostMatrix spdMatrix(Index n) {
+  HostMatrix A = HostMatrix::Random(n, n);
+  HostMatrix S = A * A.transpose() + HostMatrix::Identity(n, n) * Scalar(n);
+  return S;
+}
+
+void syncStream(cudaStream_t s) { EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(s)); }
+
+}  // namespace
+
+// ---------------------------------------------------------------------------
+// 1. Host->device upload: fromHost(MatrixBase) evaluates the input into a
+//    fresh PlainMatrix even when it is already a plain contiguous matrix,
+//    adding a full host-side copy before the H2D transfer. Baseline uploads
+//    straight from the existing host buffer.
+// ---------------------------------------------------------------------------
+
+static void BM_FromHost(benchmark::State& state) {
+  const Index n = state.range(0);
+  HostMatrix A = HostMatrix::Random(n, n);
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  for (auto _ : state) {
+    DeviceMatrix d_A = DeviceMatrix::fromHost(A, ctx.stream());
+    benchmark::DoNotOptimize(d_A.data());
+  }
+  state.SetBytesProcessed(state.iterations() * n * n * sizeof(Scalar));
+}
+BENCHMARK(BM_FromHost)->Arg(256)->Arg(1024)->Arg(4096)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_FromHostRawPointer(benchmark::State& state) {
+  const Index n = state.range(0);
+  HostMatrix A = HostMatrix::Random(n, n);
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  for (auto _ : state) {
+    DeviceMatrix d_A = DeviceMatrix::fromHostAsync(A.data(), n, n, ctx.stream());
+    syncStream(ctx.stream());
+    benchmark::DoNotOptimize(d_A.data());
+  }
+  state.SetBytesProcessed(state.iterations() * n * n * sizeof(Scalar));
+}
+BENCHMARK(BM_FromHostRawPointer)->Arg(256)->Arg(1024)->Arg(4096)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// 2. GEMM destination allocation: assigning into a fresh (or wrong-shaped)
+//    DeviceMatrix triggers cudaMalloc in resize() and cudaFree in the
+//    destructor on every iteration; a pre-allocated same-shape destination
+//    skips both.
+// ---------------------------------------------------------------------------
+
+static void BM_GemmFreshDst(benchmark::State& state) {
+  const Index n = state.range(0);
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  DeviceMatrix d_A = DeviceMatrix::fromHost(HostMatrix::Random(n, n), ctx.stream());
+  DeviceMatrix d_B = DeviceMatrix::fromHost(HostMatrix::Random(n, n), ctx.stream());
+  for (auto _ : state) {
+    DeviceMatrix d_C;  // fresh: resize() -> cudaMalloc; dtor -> cudaFree
+    d_C.device(ctx) = d_A * d_B;
+    syncStream(ctx.stream());
+  }
+}
+BENCHMARK(BM_GemmFreshDst)->Arg(64)->Arg(256)->Arg(1024)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_GemmPreallocDst(benchmark::State& state) {
+  const Index n = state.range(0);
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  DeviceMatrix d_A = DeviceMatrix::fromHost(HostMatrix::Random(n, n), ctx.stream());
+  DeviceMatrix d_B = DeviceMatrix::fromHost(HostMatrix::Random(n, n), ctx.stream());
+  DeviceMatrix d_C(n, n);
+  for (auto _ : state) {
+    d_C.device(ctx) = d_A * d_B;
+    syncStream(ctx.stream());
+  }
+}
+BENCHMARK(BM_GemmPreallocDst)->Arg(64)->Arg(256)->Arg(1024)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// 3. BLAS-1 reduction wrapper: dot() constructs a DeviceScalar initialized to
+//    zero (a small H2D upload that the following cublasXdot immediately
+//    overwrites) and toggles the cuBLAS pointer mode with three API calls.
+//    Baseline: cublasDdot into a pre-allocated device slot with pointer mode
+//    set once. Both enqueue only (no readback); sync once per iteration.
+// ---------------------------------------------------------------------------
+
+static void BM_DotDeviceScalar(benchmark::State& state) {
+  const Index n = state.range(0);
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  DeviceMatrix d_x = DeviceMatrix::fromHost(HostMatrix::Random(n, 1), ctx.stream());
+  DeviceMatrix d_y = DeviceMatrix::fromHost(HostMatrix::Random(n, 1), ctx.stream());
+  for (auto _ : state) {
+    gpu::DeviceScalar<Scalar> r = d_x.dot(ctx, d_y);
+    benchmark::DoNotOptimize(r.devicePtr());
+    syncStream(ctx.stream());
+  }
+}
+BENCHMARK(BM_DotDeviceScalar)->Arg(1 << 12)->Arg(1 << 20)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_DotRawCublas(benchmark::State& state) {
+  const Index n = state.range(0);
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  DeviceMatrix d_x = DeviceMatrix::fromHost(HostMatrix::Random(n, 1), ctx.stream());
+  DeviceMatrix d_y = DeviceMatrix::fromHost(HostMatrix::Random(n, 1), ctx.stream());
+  Scalar* d_result = nullptr;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&d_result, sizeof(Scalar)));
+  EIGEN_CUBLAS_CHECK(cublasSetPointerMode(ctx.cublasHandle(), CUBLAS_POINTER_MODE_DEVICE));
+  for (auto _ : state) {
+    EIGEN_CUBLAS_CHECK(
+        gpu::internal::cublasXdot(ctx.cublasHandle(), static_cast<int>(n), d_x.data(), 1, d_y.data(), 1, d_result));
+    syncStream(ctx.stream());
+  }
+  EIGEN_CUBLAS_CHECK(cublasSetPointerMode(ctx.cublasHandle(), CUBLAS_POINTER_MODE_HOST));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaFree(d_result));
+}
+BENCHMARK(BM_DotRawCublas)->Arg(1 << 12)->Arg(1 << 20)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// 4. Cholesky solve paths.
+//    OneShotLltExpr: d_X = d_A.llt().solve(d_B) — re-factorizes, allocates
+//      d_factor/workspace/pinned-info per call, and ends in a mandatory
+//      cudaStreamSynchronize inside the dispatch.
+//    CachedLltSolve: gpu::LLT computed once; solve() still allocates a fresh
+//      RHS DeviceBuffer per call and syncs info on the first call.
+//    RawPotrs: baseline — potrs into pre-allocated buffers, nothing else.
+//    The gap between CachedLltSolve and RawPotrs is the per-solve overhead
+//    attributable to the wrapper (allocation + event bookkeeping).
+// ---------------------------------------------------------------------------
+
+static void BM_OneShotLltExpr(benchmark::State& state) {
+  const Index n = state.range(0);
+  const Index nrhs = 8;
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  DeviceMatrix d_A = DeviceMatrix::fromHost(spdMatrix(n), ctx.stream());
+  DeviceMatrix d_B = DeviceMatrix::fromHost(HostMatrix::Random(n, nrhs), ctx.stream());
+  DeviceMatrix d_X(n, nrhs);
+  for (auto _ : state) {
+    d_X.device(ctx) = d_A.llt().solve(d_B);
+    syncStream(ctx.stream());
+  }
+}
+BENCHMARK(BM_OneShotLltExpr)->Arg(256)->Arg(1024)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_CachedLltSolve(benchmark::State& state) {
+  const Index n = state.range(0);
+  const Index nrhs = 8;
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  DeviceMatrix d_A = DeviceMatrix::fromHost(spdMatrix(n), ctx.stream());
+  DeviceMatrix d_B = DeviceMatrix::fromHost(HostMatrix::Random(n, nrhs), ctx.stream());
+  gpu::LLT<Scalar> llt;
+  llt.compute(d_A);
+  benchmark::DoNotOptimize(llt.info());  // factor + first-solve sync out of the loop
+  for (auto _ : state) {
+    DeviceMatrix d_X = llt.solve(d_B);
+    syncStream(llt.stream());
+    benchmark::DoNotOptimize(d_X.data());
+  }
+}
+BENCHMARK(BM_CachedLltSolve)->Arg(256)->Arg(1024)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_RawPotrs(benchmark::State& state) {
+  const Index n = state.range(0);
+  const Index nrhs = 8;
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  cusolverDnHandle_t solver = ctx.cusolverHandle();
+
+  // Factor once with the module (correctness is not under test here), then
+  // extract the factor into a raw buffer for repeated potrs calls.
+  HostMatrix A = spdMatrix(n);
+  Eigen::LLT<HostMatrix> hostLlt(A);
+  HostMatrix L = HostMatrix(hostLlt.matrixL());
+  DeviceMatrix d_L = DeviceMatrix::fromHost(L, ctx.stream());
+  DeviceMatrix d_B = DeviceMatrix::fromHost(HostMatrix::Random(n, nrhs), ctx.stream());
+  DeviceMatrix d_X(n, nrhs);
+
+  gpu::internal::CusolverParams params;
+  int* d_info = nullptr;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&d_info, sizeof(int)));
+  constexpr cudaDataType_t dtype = gpu::internal::cuda_data_type<Scalar>::value;
+
+  for (auto _ : state) {
+    EIGEN_CUDA_RUNTIME_CHECK(
+        cudaMemcpyAsync(d_X.data(), d_B.data(), sizeof(Scalar) * n * nrhs, cudaMemcpyDeviceToDevice, ctx.stream()));
+    EIGEN_CUSOLVER_CHECK(cusolverDnXpotrs(solver, params.p, CUBLAS_FILL_MODE_LOWER, n, nrhs, dtype, d_L.data(), n,
+                                          dtype, d_X.data(), n, d_info));
+    syncStream(ctx.stream());
+  }
+  EIGEN_CUDA_RUNTIME_CHECK(cudaFree(d_info));
+}
+BENCHMARK(BM_RawPotrs)->Arg(256)->Arg(1024)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// 4b. Device-resident SpMV in a loop (the CG hot path): measures per-call
+//     cuSPARSE descriptor/bufferSize overhead on the cached deviceView path.
+// ---------------------------------------------------------------------------
+
+static void BM_DeviceSpMV(benchmark::State& state) {
+  const Index n = state.range(0);
+  using SpMat = Eigen::SparseMatrix<Scalar, Eigen::ColMajor, int>;
+  SpMat A(n, n);
+  // 1D Laplacian stencil.
+  A.reserve(Eigen::VectorXi::Constant(n, 3));
+  for (Index i = 0; i < n; ++i) {
+    A.insert(i, i) = Scalar(2);
+    if (i > 0) A.insert(i - 1, i) = Scalar(-1);
+    if (i + 1 < n) A.insert(i + 1, i) = Scalar(-1);
+  }
+  A.makeCompressed();
+
+  gpu::Context& gctx = gpu::Context::threadLocal();
+  gpu::SparseContext<Scalar> ctx(gctx);
+  auto view = ctx.deviceView(A);
+  DeviceMatrix d_x = DeviceMatrix::fromHost(HostMatrix::Random(n, 1), gctx.stream());
+  DeviceMatrix d_y(n, 1);
+  for (auto _ : state) {
+    d_y = view * d_x;
+    syncStream(gctx.stream());
+  }
+}
+BENCHMARK(BM_DeviceSpMV)->Arg(1 << 12)->Arg(1 << 20)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// 5. Allocator microbenchmark: cudaMalloc/cudaFree (what DeviceMatrix uses
+//    today) vs cudaMallocAsync/cudaFreeAsync (stream-ordered pool). Supports
+//    the proposal to switch DeviceMatrix storage to stream-ordered allocation.
+// ---------------------------------------------------------------------------
+
+static void BM_CudaMallocFree(benchmark::State& state) {
+  const size_t bytes = static_cast<size_t>(state.range(0));
+  for (auto _ : state) {
+    void* p = nullptr;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&p, bytes));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaFree(p));
+  }
+}
+BENCHMARK(BM_CudaMallocFree)->Arg(1 << 10)->Arg(1 << 20)->Arg(1 << 26)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_CudaMallocAsyncFree(benchmark::State& state) {
+  const size_t bytes = static_cast<size_t>(state.range(0));
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  int pools_supported = 0;
+  int device = 0;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaGetDevice(&device));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceGetAttribute(&pools_supported, cudaDevAttrMemoryPoolsSupported, device));
+  if (!pools_supported) {
+    state.SkipWithError("cudaMallocAsync not supported on this device");
+    return;
+  }
+  for (auto _ : state) {
+    void* p = nullptr;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMallocAsync(&p, bytes, ctx.stream()));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaFreeAsync(p, ctx.stream()));
+  }
+  syncStream(ctx.stream());
+}
+BENCHMARK(BM_CudaMallocAsyncFree)->Arg(1 << 10)->Arg(1 << 20)->Arg(1 << 26)->UseRealTime()->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// 6. Small buffers: a DeviceBuffer below DeviceBufferPool's threshold takes
+//    the stream-ordered allocator where memory pools exist and the thread-local
+//    pool otherwise; PoolAllocFree drives the pool directly, paying one event
+//    record per release and one query per reuse. Behind an in-flight kernel a
+//    release trails that kernel, so a reuse finds it retired or falls through
+//    to the allocator (see CudaMallocAsyncFree).
+// ---------------------------------------------------------------------------
+
+static void BM_SmallBufferAllocFree(benchmark::State& state) {
+  const size_t bytes = static_cast<size_t>(state.range(0));
+  for (auto _ : state) {
+    gpu::internal::DeviceBuffer b(bytes);
+    benchmark::DoNotOptimize(b.get());
+  }
+}
+BENCHMARK(BM_SmallBufferAllocFree)->Arg(8)->Arg(64)->Arg(256)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_PoolAllocFree(benchmark::State& state) {
+  const size_t bytes = static_cast<size_t>(state.range(0));
+  auto& pool = gpu::internal::DeviceBufferPool<>::threadLocal();
+  for (auto _ : state) {
+    void* p = pool.allocate(bytes);
+    benchmark::DoNotOptimize(p);
+    pool.deallocate(p, bytes);
+  }
+}
+BENCHMARK(BM_PoolAllocFree)->Arg(8)->Arg(256)->UseRealTime()->MinWarmUpTime(0.5);
+
+static void BM_SmallBufferAllocFreeBusyStream(benchmark::State& state) {
+  const size_t bytes = static_cast<size_t>(state.range(0));
+  gpu::Context& ctx = gpu::Context::threadLocal();
+  const Index n = Index(1) << 22;
+  DeviceMatrix d_x = DeviceMatrix::fromHost(HostMatrix::Random(n, 1));
+  DeviceMatrix d_y = DeviceMatrix::fromHost(HostMatrix::Random(n, 1));
+  for (auto _ : state) {
+    // ~1 ms of work ahead of each release, as in an iterative solver loop.
+    gpu::DeviceScalar<Scalar> r = d_x.dot(ctx, d_y);
+    gpu::internal::DeviceBuffer b(bytes);
+    benchmark::DoNotOptimize(b.get());
+    benchmark::DoNotOptimize(r.devicePtr());
+  }
+  syncStream(ctx.stream());
+}
+BENCHMARK(BM_SmallBufferAllocFreeBusyStream)->Arg(8)->Arg(64)->UseRealTime()->MinWarmUpTime(0.5);
diff --git a/contrib/benchmarks/GPU/bench_solvers.cpp b/contrib/benchmarks/GPU/bench_solvers.cpp
new file mode 100644
index 0000000..014b5f7
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_solvers.cpp
@@ -0,0 +1,298 @@
+// GPU solver benchmarks: gpu::LLT and gpu::LU compute + solve throughput.
+//
+// Measures factorization and solve performance for the host-matrix and
+// DeviceMatrix code paths across a range of matrix sizes.
+//
+// For Nsight Systems profiling:
+//   nsys profile --trace=cuda,nvtx ./bench_solvers
+//
+// For Nsight Compute kernel analysis:
+//   ncu --set full -o profile ./bench_solvers --benchmark_filter=BM_GpuLLT_Compute/4096
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+
+#include <Eigen/Cholesky>
+#include <contrib/Eigen/GPU>
+#include <Eigen/LU>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+
+using Scalar = SCALAR;
+using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+// --------------------------------------------------------------------------
+// Helpers
+// --------------------------------------------------------------------------
+
+static Mat make_spd(Index n) {
+  Mat M = Mat::Random(n, n);
+  return M.adjoint() * M + Mat::Identity(n, n) * static_cast<Scalar>(n);
+}
+
+// CUDA warm-up: ensure the GPU is initialized before timing.
+static void cuda_warmup() {
+  static bool done = false;
+  if (!done) {
+    void* p;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&p, 1));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaFree(p));
+    done = true;
+  }
+}
+
+// --------------------------------------------------------------------------
+// GpuLLT benchmarks
+// --------------------------------------------------------------------------
+
+// Factorize from host matrix (includes H2D upload).
+static void BM_GpuLLT_Compute_Host(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  Mat A = make_spd(n);
+  gpu::LLT<Scalar> llt;
+
+  for (auto _ : state) {
+    llt.compute(A);
+    if (llt.info() != Success) state.SkipWithError("factorization failed");
+  }
+
+  double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// Factorize from DeviceMatrix (D2D copy path).
+static void BM_GpuLLT_Compute_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  Mat A = make_spd(n);
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  gpu::LLT<Scalar> llt;
+
+  for (auto _ : state) {
+    llt.compute(d_A);
+    if (llt.info() != Success) state.SkipWithError("factorization failed");
+  }
+
+  double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// Factorize from DeviceMatrix (move path, no copy).
+static void BM_GpuLLT_Compute_DeviceMove(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  Mat A = make_spd(n);
+  gpu::LLT<Scalar> llt;
+
+  for (auto _ : state) {
+    auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+    llt.compute(std::move(d_A));
+    if (llt.info() != Success) state.SkipWithError("factorization failed");
+  }
+
+  double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// Solve from host matrix (H2D + potrs + D2H).
+static void BM_GpuLLT_Solve_Host(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const Index nrhs = state.range(1);
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, nrhs);
+  gpu::LLT<Scalar> llt(A);
+
+  for (auto _ : state) {
+    Mat X = llt.solve(B);
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["nrhs"] = nrhs;
+}
+
+// Solve from DeviceMatrix (D2D + potrs, async, toHost at end).
+static void BM_GpuLLT_Solve_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const Index nrhs = state.range(1);
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, nrhs);
+  gpu::LLT<Scalar> llt(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+    Mat X = d_X.toHost();
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["nrhs"] = nrhs;
+}
+
+// Solve staying entirely on device (no toHost — measures pure GPU time).
+static void BM_GpuLLT_Solve_DeviceOnly(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const Index nrhs = state.range(1);
+  Mat A = make_spd(n);
+  Mat B = Mat::Random(n, nrhs);
+  gpu::LLT<Scalar> llt(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+    // Force completion without D2H transfer.
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(llt.stream()));
+    benchmark::DoNotOptimize(d_X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["nrhs"] = nrhs;
+}
+
+// --------------------------------------------------------------------------
+// GpuLU benchmarks
+// --------------------------------------------------------------------------
+
+static void BM_GpuLU_Compute_Host(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n);
+  gpu::LU<Scalar> lu;
+
+  for (auto _ : state) {
+    lu.compute(A);
+    if (lu.info() != Success) state.SkipWithError("factorization failed");
+  }
+
+  double flops = 2.0 / 3.0 * static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n);
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+static void BM_GpuLU_Compute_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n);
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  gpu::LU<Scalar> lu;
+
+  for (auto _ : state) {
+    lu.compute(d_A);
+    if (lu.info() != Success) state.SkipWithError("factorization failed");
+  }
+
+  double flops = 2.0 / 3.0 * static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n);
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+static void BM_GpuLU_Solve_Host(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const Index nrhs = state.range(1);
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, nrhs);
+  gpu::LU<Scalar> lu(A);
+
+  for (auto _ : state) {
+    Mat X = lu.solve(B);
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["nrhs"] = nrhs;
+}
+
+static void BM_GpuLU_Solve_Device(benchmark::State& state) {
+  cuda_warmup();
+  const Index n = state.range(0);
+  const Index nrhs = state.range(1);
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, nrhs);
+  gpu::LU<Scalar> lu(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  for (auto _ : state) {
+    gpu::DeviceMatrix<Scalar> d_X = lu.solve(d_B);
+    Mat X = d_X.toHost();
+    benchmark::DoNotOptimize(X.data());
+  }
+
+  state.counters["n"] = n;
+  state.counters["nrhs"] = nrhs;
+}
+
+// --------------------------------------------------------------------------
+// CPU baselines for comparison
+// --------------------------------------------------------------------------
+
+static void BM_CpuLLT_Compute(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = make_spd(n);
+  LLT<Mat> llt;
+
+  for (auto _ : state) {
+    llt.compute(A);
+    benchmark::DoNotOptimize(llt.matrixLLT().data());
+  }
+
+  double flops = static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n) / 3.0;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+static void BM_CpuLU_Compute(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n);
+  PartialPivLU<Mat> lu;
+
+  for (auto _ : state) {
+    lu.compute(A);
+    benchmark::DoNotOptimize(lu.matrixLU().data());
+  }
+
+  double flops = 2.0 / 3.0 * static_cast<double>(n) * static_cast<double>(n) * static_cast<double>(n);
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["n"] = n;
+}
+
+// --------------------------------------------------------------------------
+// Registration
+// --------------------------------------------------------------------------
+
+// clang-format off
+BENCHMARK(BM_GpuLLT_Compute_Host)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLLT_Compute_Device)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLLT_Compute_DeviceMove)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLLT_Solve_Host)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLLT_Solve_Device)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLLT_Solve_DeviceOnly)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+
+BENCHMARK(BM_GpuLU_Compute_Host)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLU_Compute_Device)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLU_Solve_Host)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_GpuLU_Solve_Device)->ArgsProduct({{64, 256, 1024, 4096}, {1, 16}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+
+BENCHMARK(BM_CpuLLT_Compute)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+BENCHMARK(BM_CpuLU_Compute)->ArgsProduct({{64, 128, 256, 512, 1024, 2048, 4096}})->Unit(benchmark::kMicrosecond)->UseRealTime()->MinWarmUpTime(0.5);
+// clang-format on
diff --git a/contrib/benchmarks/GPU/bench_unified_memory.cpp b/contrib/benchmarks/GPU/bench_unified_memory.cpp
new file mode 100644
index 0000000..dc643a5
--- /dev/null
+++ b/contrib/benchmarks/GPU/bench_unified_memory.cpp
@@ -0,0 +1,453 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Compares the host-to-device storage strategies available to DeviceMatrix on
+// an integrated GPU, where the "copy" moves bytes from one region of DRAM to
+// another region of the same DRAM.
+//
+// DeviceMatrix currently always allocates with cudaMalloc and reaches host data
+// through cudaMemcpy. On a discrete GPU that is the only option. On a device
+// reporting cudaDeviceProp::integrated the copy is avoidable, but only if the
+// alternative storage is also fast to compute on -- mapped host memory is not
+// cached in the GPU's L2 on Tegra, so a cheaper upload can cost more than it
+// saves once a kernel reads the data. Every strategy is therefore measured
+// twice: what it costs to get the data in place, and what a GEMM reading it
+// then achieves.
+//
+//   Upload_*     cost to make an existing host matrix readable by cuBLAS
+//   Gemm_*       GEMM throughput with both operands in that storage
+//   Download_*   cost to make a device-written result readable by the host
+//   RoundTrip_*  upload + GEMM + download, the figure that decides the design
+//
+// Strategies:
+//   DeviceMalloc   cudaMalloc + cudaMemcpy from pageable host memory (today)
+//   Pinned         cudaMalloc + cudaMemcpy staged through cudaMallocHost
+//   Managed        cudaMallocManaged + host memcpy
+//   ManagedInPlace cudaMallocManaged, matrix built in place -- no copy at all
+//   Mapped         cudaHostAlloc(cudaHostAllocMapped) + memcpy, zero-copy
+//   Registered     cudaHostRegister over the host matrix's own storage
+//
+// Build (standalone project, see CMakeLists.txt in this directory):
+//   cmake -G Ninja -B build-bench-gpu -S contrib/benchmarks/GPU \
+//         -DCMAKE_CUDA_ARCHITECTURES=87
+//   cmake --build build-bench-gpu --target bench_unified_memory
+//   ./build-bench-gpu/bench_unified_memory
+
+#ifndef EIGEN_USE_GPU
+#define EIGEN_USE_GPU
+#endif
+#include <Eigen/Core>
+#include <contrib/Eigen/GPU>
+
+#include <benchmark/benchmark.h>
+#include <cublas_v2.h>
+#include <cuda_runtime.h>
+
+#include <cstring>
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+using Scalar = SCALAR;
+
+using Eigen::Index;
+namespace gpu = Eigen::gpu;
+using HostMatrix = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+using HostMap = Eigen::Map<HostMatrix>;
+
+namespace {
+
+// cuBLAS handle and stream shared by every case, created once.
+struct Blas {
+  Blas() {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&stream));
+    cublasCreate(&handle);
+    cublasSetStream(handle, stream);
+  }
+  ~Blas() {
+    cublasDestroy(handle);
+    (void)cudaStreamDestroy(stream);
+  }
+  cublasHandle_t handle;
+  cudaStream_t stream;
+};
+
+Blas& blas() {
+  static Blas b;
+  return b;
+}
+
+void gemm(Index n, const Scalar* a, const Scalar* b, Scalar* c) {
+  const Scalar alpha = 1, beta = 0;
+  const int m = gpu::internal::to_blas_int(n);
+  if (std::is_same<Scalar, double>::value) {
+    cublasDgemm(blas().handle, CUBLAS_OP_N, CUBLAS_OP_N, m, m, m, reinterpret_cast<const double*>(&alpha),
+                reinterpret_cast<const double*>(a), m, reinterpret_cast<const double*>(b), m,
+                reinterpret_cast<const double*>(&beta), reinterpret_cast<double*>(c), m);
+  } else {
+    cublasSgemm(blas().handle, CUBLAS_OP_N, CUBLAS_OP_N, m, m, m, reinterpret_cast<const float*>(&alpha),
+                reinterpret_cast<const float*>(a), m, reinterpret_cast<const float*>(b), m,
+                reinterpret_cast<const float*>(&beta), reinterpret_cast<float*>(c), m);
+  }
+}
+
+// The six storage strategies, behind one interface. host() is null when the
+// strategy has no host-addressable view of the allocation.
+enum class Storage { DeviceMalloc, Pinned, Managed, Mapped, Registered };
+
+class Buffer {
+ public:
+  Buffer(Storage s, size_t bytes) : storage_(s), bytes_(bytes) {
+    switch (storage_) {
+      case Storage::DeviceMalloc:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&device_, bytes));
+        break;
+      case Storage::Pinned:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMalloc(&device_, bytes));
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMallocHost(&host_, bytes));
+        break;
+      case Storage::Managed:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMallocManaged(&device_, bytes));
+        host_ = device_;
+        break;
+      case Storage::Mapped:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaHostAlloc(&host_, bytes, cudaHostAllocMapped));
+        EIGEN_CUDA_RUNTIME_CHECK(cudaHostGetDevicePointer(&device_, host_, 0));
+        break;
+      case Storage::Registered:
+        // Registration targets caller-owned storage; adopt() supplies it.
+        break;
+    }
+  }
+
+  // Register an existing host allocation in place. Timed separately, because
+  // the page-table work scales with the allocation and dominates for one-shot
+  // use while amortizing to nothing for a matrix uploaded repeatedly.
+  void adopt(void* host_storage) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaHostRegister(host_storage, bytes_, cudaHostRegisterMapped));
+    host_ = host_storage;
+    registered_ = true;
+    EIGEN_CUDA_RUNTIME_CHECK(cudaHostGetDevicePointer(&device_, host_, 0));
+  }
+
+  ~Buffer() {
+    switch (storage_) {
+      case Storage::DeviceMalloc:
+        (void)cudaFree(device_);
+        break;
+      case Storage::Pinned:
+        (void)cudaFree(device_);
+        (void)cudaFreeHost(host_);
+        break;
+      case Storage::Managed:
+        (void)cudaFree(device_);
+        break;
+      case Storage::Mapped:
+        (void)cudaFreeHost(host_);
+        break;
+      case Storage::Registered:
+        if (registered_) (void)cudaHostUnregister(host_);
+        break;
+    }
+  }
+
+  Buffer(const Buffer&) = delete;
+  Buffer& operator=(const Buffer&) = delete;
+
+  Scalar* device() const { return static_cast<Scalar*>(device_); }
+  Scalar* host() const { return static_cast<Scalar*>(host_); }
+
+  // Make `src` readable by a kernel through device(). This is the operation
+  // the upload benchmarks time.
+  void upload(const Scalar* src) {
+    switch (storage_) {
+      case Storage::DeviceMalloc:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(device_, src, bytes_, cudaMemcpyHostToDevice, blas().stream));
+        EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+        break;
+      case Storage::Pinned:
+        std::memcpy(host_, src, bytes_);
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(device_, host_, bytes_, cudaMemcpyHostToDevice, blas().stream));
+        EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+        break;
+      case Storage::Managed:
+      case Storage::Mapped:
+        std::memcpy(host_, src, bytes_);
+        break;
+      case Storage::Registered:
+        // The data is already there; registration made it visible.
+        break;
+    }
+  }
+
+  // Make a device-written result readable through host(), into `dst`.
+  void download(Scalar* dst) {
+    switch (storage_) {
+      case Storage::DeviceMalloc:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(dst, device_, bytes_, cudaMemcpyDeviceToHost, blas().stream));
+        EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+        break;
+      case Storage::Pinned:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaMemcpyAsync(host_, device_, bytes_, cudaMemcpyDeviceToHost, blas().stream));
+        EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+        std::memcpy(dst, host_, bytes_);
+        break;
+      case Storage::Managed:
+        // concurrentManagedAccess is 0 on Tegra: the host may not read a
+        // managed allocation while device work is outstanding.
+        EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+        std::memcpy(dst, host_, bytes_);
+        break;
+      case Storage::Mapped:
+      case Storage::Registered:
+        EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+        std::memcpy(dst, host_, bytes_);
+        break;
+    }
+  }
+
+ private:
+  Storage storage_;
+  size_t bytes_ = 0;
+  void* device_ = nullptr;
+  void* host_ = nullptr;
+  bool registered_ = false;
+};
+
+size_t byteCount(Index n) { return static_cast<size_t>(n) * static_cast<size_t>(n) * sizeof(Scalar); }
+
+void setBytesCounter(benchmark::State& state, Index n, int64_t buffers) {
+  state.SetBytesProcessed(state.iterations() * buffers * static_cast<int64_t>(byteCount(n)));
+}
+
+// Google Benchmark finishes rate counters against CPU time unless the benchmark
+// opts into UseRealTime(). Every case here blocks in cudaStreamSynchronize, so
+// CPU time is a small and size-dependent fraction of wall time (0.2% at n=4096
+// on Orin) and a counter computed from it overstates throughput by that factor.
+// All registrations below call UseRealTime(); see the note in CMakeLists.txt.
+void setFlopsCounter(benchmark::State& state, Index n) {
+  const double flops = 2.0 * double(n) * double(n) * double(n);
+  state.counters["GFLOPS"] = benchmark::Counter(flops * double(state.iterations()), benchmark::Counter::kIsRate,
+                                                benchmark::Counter::OneK::kIs1000);
+}
+
+}  // namespace
+
+// ---------------------------------------------------------------------------
+// Upload: cost of making an existing host matrix readable by cuBLAS.
+// ---------------------------------------------------------------------------
+
+void uploadBench(benchmark::State& state, Storage storage) {
+  const Index n = state.range(0);
+  const HostMatrix src = HostMatrix::Random(n, n);
+  Buffer buf(storage, byteCount(n));
+  if (storage == Storage::Registered) buf.adopt(const_cast<Scalar*>(src.data()));
+  for (auto _ : state) {
+    buf.upload(src.data());
+    benchmark::DoNotOptimize(buf.device());
+  }
+  setBytesCounter(state, n, 1);
+}
+
+#define UPLOAD_CASE(Name, Enum)                                                                \
+  static void BM_Upload_##Name(benchmark::State& state) { uploadBench(state, Storage::Enum); } \
+  BENCHMARK(BM_Upload_##Name)                                                                  \
+      ->Arg(256)                                                                               \
+      ->Arg(1024)                                                                              \
+      ->Arg(4096)                                                                              \
+      ->Unit(benchmark::kMicrosecond)                                                          \
+      ->UseRealTime()                                                                          \
+      ->MinWarmUpTime(0.5)
+
+UPLOAD_CASE(DeviceMalloc, DeviceMalloc);
+UPLOAD_CASE(Pinned, Pinned);
+UPLOAD_CASE(Managed, Managed);
+UPLOAD_CASE(Mapped, Mapped);
+UPLOAD_CASE(Registered, Registered);
+
+// The page-table cost that Upload_Registered amortizes away. Registering a
+// 4096x4096 double matrix touches 32K pages; whether that is worth paying
+// depends entirely on how often the same buffer is reused.
+static void BM_HostRegisterCost(benchmark::State& state) {
+  const Index n = state.range(0);
+  HostMatrix src = HostMatrix::Random(n, n);
+  for (auto _ : state) {
+    EIGEN_CUDA_RUNTIME_CHECK(cudaHostRegister(src.data(), byteCount(n), cudaHostRegisterMapped));
+    EIGEN_CUDA_RUNTIME_CHECK(cudaHostUnregister(src.data()));
+  }
+  setBytesCounter(state, n, 1);
+}
+BENCHMARK(BM_HostRegisterCost)
+    ->Arg(256)
+    ->Arg(1024)
+    ->Arg(4096)
+    ->Unit(benchmark::kMicrosecond)
+    ->UseRealTime()
+    ->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// GEMM throughput with both operands in each storage class. The destination is
+// always ordinary device memory, isolating the cost of *reading* the operands.
+// ---------------------------------------------------------------------------
+
+void gemmBench(benchmark::State& state, Storage storage) {
+  const Index n = state.range(0);
+  const HostMatrix ha = HostMatrix::Random(n, n);
+  const HostMatrix hb = HostMatrix::Random(n, n);
+  Buffer a(storage, byteCount(n)), b(storage, byteCount(n));
+  Buffer c(Storage::DeviceMalloc, byteCount(n));
+  if (storage == Storage::Registered) {
+    a.adopt(const_cast<Scalar*>(ha.data()));
+    b.adopt(const_cast<Scalar*>(hb.data()));
+  } else {
+    a.upload(ha.data());
+    b.upload(hb.data());
+  }
+  for (auto _ : state) {
+    gemm(n, a.device(), b.device(), c.device());
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+  }
+  setFlopsCounter(state, n);
+}
+
+#define GEMM_CASE(Name, Enum)                                                              \
+  static void BM_Gemm_##Name(benchmark::State& state) { gemmBench(state, Storage::Enum); } \
+  BENCHMARK(BM_Gemm_##Name)                                                                \
+      ->Arg(256)                                                                           \
+      ->Arg(1024)                                                                          \
+      ->Arg(4096)                                                                          \
+      ->Unit(benchmark::kMicrosecond)                                                      \
+      ->UseRealTime()                                                                      \
+      ->MinWarmUpTime(0.5)
+
+GEMM_CASE(DeviceMalloc, DeviceMalloc);
+GEMM_CASE(Managed, Managed);
+GEMM_CASE(Mapped, Mapped);
+GEMM_CASE(Registered, Registered);
+
+// ---------------------------------------------------------------------------
+// Download: cost of making a device-written result readable by the host.
+// ---------------------------------------------------------------------------
+
+void downloadBench(benchmark::State& state, Storage storage) {
+  const Index n = state.range(0);
+  HostMatrix dst(n, n);
+  Buffer buf(storage, byteCount(n));
+  if (storage == Storage::Registered) buf.adopt(dst.data());
+  EIGEN_CUDA_RUNTIME_CHECK(cudaMemsetAsync(buf.device(), 0, byteCount(n), blas().stream));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+  for (auto _ : state) {
+    buf.download(dst.data());
+    benchmark::DoNotOptimize(dst.data());
+  }
+  setBytesCounter(state, n, 1);
+}
+
+#define DOWNLOAD_CASE(Name, Enum)                                                                  \
+  static void BM_Download_##Name(benchmark::State& state) { downloadBench(state, Storage::Enum); } \
+  BENCHMARK(BM_Download_##Name)                                                                    \
+      ->Arg(256)                                                                                   \
+      ->Arg(1024)                                                                                  \
+      ->Arg(4096)                                                                                  \
+      ->Unit(benchmark::kMicrosecond)                                                              \
+      ->UseRealTime()                                                                              \
+      ->MinWarmUpTime(0.5)
+
+DOWNLOAD_CASE(DeviceMalloc, DeviceMalloc);
+DOWNLOAD_CASE(Pinned, Pinned);
+DOWNLOAD_CASE(Managed, Managed);
+DOWNLOAD_CASE(Mapped, Mapped);
+
+// ---------------------------------------------------------------------------
+// End-to-end: upload two operands, GEMM, download the result. This is the
+// number that decides which storage DeviceMatrix should use on an integrated
+// GPU -- a strategy can win the upload and still lose here.
+// ---------------------------------------------------------------------------
+
+void roundTripBench(benchmark::State& state, Storage storage) {
+  const Index n = state.range(0);
+  const HostMatrix ha = HostMatrix::Random(n, n);
+  const HostMatrix hb = HostMatrix::Random(n, n);
+  HostMatrix hc(n, n);
+  Buffer a(storage, byteCount(n)), b(storage, byteCount(n)), c(storage, byteCount(n));
+  if (storage == Storage::Registered) {
+    a.adopt(const_cast<Scalar*>(ha.data()));
+    b.adopt(const_cast<Scalar*>(hb.data()));
+    c.adopt(hc.data());
+  }
+  for (auto _ : state) {
+    a.upload(ha.data());
+    b.upload(hb.data());
+    gemm(n, a.device(), b.device(), c.device());
+    c.download(hc.data());
+  }
+  setFlopsCounter(state, n);
+}
+
+#define ROUNDTRIP_CASE(Name, Enum)                                                                   \
+  static void BM_RoundTrip_##Name(benchmark::State& state) { roundTripBench(state, Storage::Enum); } \
+  BENCHMARK(BM_RoundTrip_##Name)                                                                     \
+      ->Arg(256)                                                                                     \
+      ->Arg(1024)                                                                                    \
+      ->Arg(4096)                                                                                    \
+      ->Unit(benchmark::kMicrosecond)                                                                \
+      ->UseRealTime()                                                                                \
+      ->MinWarmUpTime(0.5)
+
+ROUNDTRIP_CASE(DeviceMalloc, DeviceMalloc);
+ROUNDTRIP_CASE(Pinned, Pinned);
+ROUNDTRIP_CASE(Managed, Managed);
+ROUNDTRIP_CASE(Mapped, Mapped);
+ROUNDTRIP_CASE(Registered, Registered);
+
+// ---------------------------------------------------------------------------
+// The bound the others are chasing: operands built directly in managed memory
+// through an Eigen::Map, so no strategy has anything to copy on the way in.
+// ---------------------------------------------------------------------------
+
+static void BM_RoundTrip_ManagedInPlace(benchmark::State& state) {
+  const Index n = state.range(0);
+  Buffer a(Storage::Managed, byteCount(n)), b(Storage::Managed, byteCount(n)), c(Storage::Managed, byteCount(n));
+  HostMap(a.host(), n, n) = HostMatrix::Random(n, n);
+  HostMap(b.host(), n, n) = HostMatrix::Random(n, n);
+  for (auto _ : state) {
+    gemm(n, a.device(), b.device(), c.device());
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(blas().stream));
+    benchmark::DoNotOptimize(HostMap(c.host(), n, n).coeff(0, 0));
+  }
+  setFlopsCounter(state, n);
+}
+BENCHMARK(BM_RoundTrip_ManagedInPlace)
+    ->Arg(256)
+    ->Arg(1024)
+    ->Arg(4096)
+    ->Unit(benchmark::kMicrosecond)
+    ->UseRealTime()
+    ->MinWarmUpTime(0.5);
+
+// ---------------------------------------------------------------------------
+// Reported once so the results carry the device's own answer to "is this an
+// integrated part, and what is it allowed to do with managed memory".
+// ---------------------------------------------------------------------------
+
+static void BM_ReportDeviceProperties(benchmark::State& state) {
+  int dev = 0;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaGetDevice(&dev));
+  cudaDeviceProp prop{};
+  EIGEN_CUDA_RUNTIME_CHECK(cudaGetDeviceProperties(&prop, dev));
+  for (auto _ : state) benchmark::DoNotOptimize(dev);
+  state.counters["integrated"] = prop.integrated;
+  state.counters["canMapHostMemory"] = prop.canMapHostMemory;
+  state.counters["managedMemory"] = prop.managedMemory;
+  state.counters["concurrentManagedAccess"] = prop.concurrentManagedAccess;
+  state.counters["pageableMemoryAccess"] = prop.pageableMemoryAccess;
+  state.counters["multiProcessorCount"] = prop.multiProcessorCount;
+}
+BENCHMARK(BM_ReportDeviceProperties)->Iterations(1);
diff --git a/contrib/benchmarks/KroneckerProduct/CMakeLists.txt b/contrib/benchmarks/KroneckerProduct/CMakeLists.txt
new file mode 100644
index 0000000..b72f8ca
--- /dev/null
+++ b/contrib/benchmarks/KroneckerProduct/CMakeLists.txt
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_kronecker bench_kronecker.cpp)
diff --git a/contrib/benchmarks/KroneckerProduct/bench_kronecker.cpp b/contrib/benchmarks/KroneckerProduct/bench_kronecker.cpp
new file mode 100644
index 0000000..ce5f90b
--- /dev/null
+++ b/contrib/benchmarks/KroneckerProduct/bench_kronecker.cpp
@@ -0,0 +1,72 @@
+// Benchmarks for Kronecker product (dense and sparse).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <Eigen/Sparse>
+#include <contrib/Eigen/KroneckerProduct>
+
+using namespace Eigen;
+
+typedef double Scalar;
+typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+typedef SparseMatrix<Scalar> SpMat;
+
+// --- Dense Kronecker product ---
+static void BM_KroneckerDense(benchmark::State& state) {
+  int na = state.range(0);
+  int nb = state.range(1);
+
+  Mat A = Mat::Random(na, na);
+  Mat B = Mat::Random(nb, nb);
+
+  for (auto _ : state) {
+    Mat C = kroneckerProduct(A, B).eval();
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  int outSize = na * nb;
+  state.counters["output_size"] = outSize;
+}
+
+// --- Sparse Kronecker product ---
+static void BM_KroneckerSparse(benchmark::State& state) {
+  int na = state.range(0);
+  int nb = state.range(1);
+
+  // Create sparse identity-like matrices with some fill.
+  SpMat A(na, na);
+  SpMat B(nb, nb);
+
+  std::vector<Triplet<Scalar>> tripsA, tripsB;
+  for (int i = 0; i < na; ++i) {
+    tripsA.emplace_back(i, i, 2.0);
+    if (i + 1 < na) {
+      tripsA.emplace_back(i, i + 1, -1.0);
+      tripsA.emplace_back(i + 1, i, -1.0);
+    }
+  }
+  for (int i = 0; i < nb; ++i) {
+    tripsB.emplace_back(i, i, 2.0);
+    if (i + 1 < nb) {
+      tripsB.emplace_back(i, i + 1, -1.0);
+      tripsB.emplace_back(i + 1, i, -1.0);
+    }
+  }
+  A.setFromTriplets(tripsA.begin(), tripsA.end());
+  B.setFromTriplets(tripsB.begin(), tripsB.end());
+
+  for (auto _ : state) {
+    SpMat C = kroneckerProduct(A, B).eval();
+    benchmark::DoNotOptimize(C.valuePtr());
+    benchmark::ClobberMemory();
+  }
+  state.counters["output_size"] = na * nb;
+}
+
+#define KRONECKER_SIZES ->ArgsProduct({{4, 8, 16}, {4, 8, 16}})
+#define KRONECKER_SPARSE_SIZES ->ArgsProduct({{16, 32, 64, 128}, {16, 32, 64, 128}})
+
+BENCHMARK(BM_KroneckerDense) KRONECKER_SIZES;
+BENCHMARK(BM_KroneckerSparse) KRONECKER_SPARSE_SIZES;
diff --git a/contrib/benchmarks/MatrixFunctions/CMakeLists.txt b/contrib/benchmarks/MatrixFunctions/CMakeLists.txt
new file mode 100644
index 0000000..9b0ea7c
--- /dev/null
+++ b/contrib/benchmarks/MatrixFunctions/CMakeLists.txt
@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_matrix_exponential bench_matrix_exponential.cpp)
+eigen_add_benchmark(bench_matrix_logarithm bench_matrix_logarithm.cpp)
+eigen_add_benchmark(bench_matrix_power bench_matrix_power.cpp)
diff --git a/contrib/benchmarks/MatrixFunctions/bench_matrix_exponential.cpp b/contrib/benchmarks/MatrixFunctions/bench_matrix_exponential.cpp
new file mode 100644
index 0000000..974ab43
--- /dev/null
+++ b/contrib/benchmarks/MatrixFunctions/bench_matrix_exponential.cpp
@@ -0,0 +1,57 @@
+// Benchmarks for matrix exponential.
+// Critical for Sophus Lie group operations (SLAM, visual odometry).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/MatrixFunctions>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+
+typedef SCALAR Scalar;
+
+static void BM_MatrixExp(benchmark::State& state) {
+  int n = state.range(0);
+  Scalar scale = Scalar(state.range(1));
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+
+  // The larger scale exercises the scale-and-square path, including the
+  // coefficient-wise exact power-of-two scale-down.
+  MatrixType A = scale * MatrixType::Random(n, n) / Scalar(n);
+  MatrixType result(n, n);
+
+  for (auto _ : state) {
+    result = A.exp();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// Fixed-size specializations for Lie group sizes.
+template <int N>
+static void BM_MatrixExp_Fixed(benchmark::State& state) {
+  typedef Matrix<Scalar, N, N> MatrixType;
+
+  MatrixType A = MatrixType::Random() / Scalar(N);
+  MatrixType result;
+
+  for (auto _ : state) {
+    result = A.exp();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// Dynamic sizes: Lie groups (2,3,4) plus larger, both well-scaled and through
+// the scale-and-square path.
+BENCHMARK(BM_MatrixExp)->ArgsProduct({{2, 3, 4, 8, 16, 32, 64, 128}, {1, 64}});
+
+// Fixed-size Lie group dimensions.
+BENCHMARK(BM_MatrixExp_Fixed<2>);
+BENCHMARK(BM_MatrixExp_Fixed<3>);
+BENCHMARK(BM_MatrixExp_Fixed<4>);
diff --git a/contrib/benchmarks/MatrixFunctions/bench_matrix_logarithm.cpp b/contrib/benchmarks/MatrixFunctions/bench_matrix_logarithm.cpp
new file mode 100644
index 0000000..352415a
--- /dev/null
+++ b/contrib/benchmarks/MatrixFunctions/bench_matrix_logarithm.cpp
@@ -0,0 +1,53 @@
+// Benchmarks for matrix logarithm.
+// Inverse of matrix exponential, used for Lie group log maps.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/MatrixFunctions>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR double
+#endif
+
+typedef SCALAR Scalar;
+
+static void BM_MatrixLog(benchmark::State& state) {
+  int n = state.range(0);
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+
+  // Generate a matrix close to identity for stable log computation.
+  MatrixType A = MatrixType::Identity(n, n) + MatrixType::Random(n, n) / Scalar(n * 2);
+  // Ensure A is in the principal branch by computing exp(small matrix).
+  A = (MatrixType::Random(n, n) / Scalar(n * 4)).exp();
+  MatrixType result(n, n);
+
+  for (auto _ : state) {
+    result = A.log();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+template <int N>
+static void BM_MatrixLog_Fixed(benchmark::State& state) {
+  typedef Matrix<Scalar, N, N> MatrixType;
+
+  MatrixType A = (MatrixType::Random() / Scalar(N * 4)).exp();
+  MatrixType result;
+
+  for (auto _ : state) {
+    result = A.log();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK(BM_MatrixLog)->Arg(2)->Arg(3)->Arg(4)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+BENCHMARK(BM_MatrixLog_Fixed<2>);
+BENCHMARK(BM_MatrixLog_Fixed<3>);
+BENCHMARK(BM_MatrixLog_Fixed<4>);
diff --git a/contrib/benchmarks/MatrixFunctions/bench_matrix_power.cpp b/contrib/benchmarks/MatrixFunctions/bench_matrix_power.cpp
new file mode 100644
index 0000000..1f1c98a
--- /dev/null
+++ b/contrib/benchmarks/MatrixFunctions/bench_matrix_power.cpp
@@ -0,0 +1,97 @@
+// Benchmarks for matrix power functions: sqrt, pow, cos, sin, cosh, sinh.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/MatrixFunctions>
+
+using namespace Eigen;
+
+typedef double Scalar;
+typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+static void BM_MatrixSqrt(benchmark::State& state) {
+  int n = state.range(0);
+  // SPD matrix has well-defined sqrt.
+  Mat tmp = Mat::Random(n, n);
+  Mat A = tmp * tmp.transpose() + Mat::Identity(n, n);
+  Mat result(n, n);
+
+  for (auto _ : state) {
+    result = A.sqrt();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+static void BM_MatrixPow(benchmark::State& state) {
+  int n = state.range(0);
+  Mat tmp = Mat::Random(n, n);
+  Mat A = tmp * tmp.transpose() + Mat::Identity(n, n);
+  Mat result(n, n);
+  Scalar p = 2.5;
+
+  for (auto _ : state) {
+    result = A.pow(p);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+static void BM_MatrixCos(benchmark::State& state) {
+  int n = state.range(0);
+  Mat A = Mat::Random(n, n) / Scalar(n);
+  Mat result(n, n);
+
+  for (auto _ : state) {
+    result = A.cos();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+static void BM_MatrixSin(benchmark::State& state) {
+  int n = state.range(0);
+  Mat A = Mat::Random(n, n) / Scalar(n);
+  Mat result(n, n);
+
+  for (auto _ : state) {
+    result = A.sin();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+static void BM_MatrixCosh(benchmark::State& state) {
+  int n = state.range(0);
+  Mat A = Mat::Random(n, n) / Scalar(n);
+  Mat result(n, n);
+
+  for (auto _ : state) {
+    result = A.cosh();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+static void BM_MatrixSinh(benchmark::State& state) {
+  int n = state.range(0);
+  Mat A = Mat::Random(n, n) / Scalar(n);
+  Mat result(n, n);
+
+  for (auto _ : state) {
+    result = A.sinh();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+#define MAT_POWER_SIZES ->Arg(4)->Arg(8)->Arg(16)->Arg(32)->Arg(64)
+
+BENCHMARK(BM_MatrixSqrt) MAT_POWER_SIZES;
+BENCHMARK(BM_MatrixPow) MAT_POWER_SIZES;
+BENCHMARK(BM_MatrixCos) MAT_POWER_SIZES;
+BENCHMARK(BM_MatrixSin) MAT_POWER_SIZES;
+BENCHMARK(BM_MatrixCosh) MAT_POWER_SIZES;
+BENCHMARK(BM_MatrixSinh) MAT_POWER_SIZES;
diff --git a/contrib/benchmarks/Polynomials/CMakeLists.txt b/contrib/benchmarks/Polynomials/CMakeLists.txt
new file mode 100644
index 0000000..4e940b1
--- /dev/null
+++ b/contrib/benchmarks/Polynomials/CMakeLists.txt
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_polynomialsolver bench_polynomialsolver.cpp)
diff --git a/contrib/benchmarks/Polynomials/bench_polynomialsolver.cpp b/contrib/benchmarks/Polynomials/bench_polynomialsolver.cpp
new file mode 100644
index 0000000..dddaf4f
--- /dev/null
+++ b/contrib/benchmarks/Polynomials/bench_polynomialsolver.cpp
@@ -0,0 +1,68 @@
+// Benchmarks for PolynomialSolver::compute on batches of random polynomials.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/Polynomials>
+
+#include <complex>
+#include <vector>
+
+using namespace Eigen;
+
+namespace {
+
+constexpr int kBatch = 64;
+
+// Largest componentwise backward error |p(z)| / sum_k |a_k| |z|^k over the roots, in units of eps, evaluated in
+// long double so that the check does not share the solver's rounding.
+template <typename Scalar, int Deg, typename Polynomial>
+double maxBackwardError(const PolynomialSolver<Scalar, Deg>& solver, const Polynomial& poly) {
+  using Real = typename NumTraits<Scalar>::Real;
+  double worst = 0;
+  for (Index i = 0; i < solver.roots().size(); ++i) {
+    const std::complex<long double> z(solver.roots()[i].real(), solver.roots()[i].imag());
+    std::complex<long double> value(0);
+    long double magnitude = 0;
+    for (Index k = poly.size() - 1; k >= 0; --k) {
+      value = value * z + std::complex<long double>(poly[k]);
+      magnitude = magnitude * std::abs(z) + std::abs(std::complex<long double>(poly[k]));
+    }
+    worst = std::max(worst, double(std::abs(value) / magnitude / NumTraits<Real>::epsilon()));
+  }
+  return worst;
+}
+
+template <typename Scalar, int Deg>
+static void BM_PolynomialSolver(benchmark::State& state) {
+  const Index degree = Deg == Dynamic ? Index(state.range(0)) : Index(Deg);
+  using Polynomial = Matrix<Scalar, Deg == Dynamic ? Dynamic : Deg + 1, 1>;
+  std::srand(1);
+  std::vector<Polynomial, aligned_allocator<Polynomial>> polys;
+  for (int b = 0; b < kBatch; ++b) polys.push_back(Polynomial::Random(degree + 1));
+  PolynomialSolver<Scalar, Deg> solver;
+  for (const Polynomial& poly : polys) {
+    solver.compute(poly);
+    // A backward-stable root finder stays within a small multiple of degree * eps.
+    if (!(maxBackwardError(solver, poly) <= 1024.0 * double(degree))) {
+      state.SkipWithError("root backward error too large");
+      return;
+    }
+  }
+  for (auto _ : state) {
+    for (const Polynomial& poly : polys) {
+      solver.compute(poly);
+      benchmark::DoNotOptimize(solver.roots().data());
+    }
+  }
+  state.counters["polys/s"] = benchmark::Counter(kBatch, benchmark::Counter::kIsIterationInvariantRate);
+}
+
+}  // namespace
+
+BENCHMARK_TEMPLATE(BM_PolynomialSolver, float, Dynamic)->Arg(5)->Arg(10)->Arg(20)->Arg(50);
+BENCHMARK_TEMPLATE(BM_PolynomialSolver, double, Dynamic)->Arg(5)->Arg(10)->Arg(20)->Arg(50)->Arg(100);
+BENCHMARK_TEMPLATE(BM_PolynomialSolver, std::complex<double>, Dynamic)->Arg(5)->Arg(20);
+BENCHMARK_TEMPLATE(BM_PolynomialSolver, double, 5);
+BENCHMARK_TEMPLATE(BM_PolynomialSolver, std::complex<double>, 5);
diff --git a/contrib/benchmarks/SpecialFunctions/CMakeLists.txt b/contrib/benchmarks/SpecialFunctions/CMakeLists.txt
new file mode 100644
index 0000000..c8e9934
--- /dev/null
+++ b/contrib/benchmarks/SpecialFunctions/CMakeLists.txt
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_special_functions bench_special_functions.cpp)
diff --git a/contrib/benchmarks/SpecialFunctions/bench_special_functions.cpp b/contrib/benchmarks/SpecialFunctions/bench_special_functions.cpp
new file mode 100644
index 0000000..6460f84
--- /dev/null
+++ b/contrib/benchmarks/SpecialFunctions/bench_special_functions.cpp
@@ -0,0 +1,131 @@
+// Benchmarks for special functions beyond what bench_cwise_math.cpp covers.
+// Includes Bessel functions, two-argument functions (igamma, betainc),
+// and additional functions (lgamma, digamma, zeta, polygamma).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/SpecialFunctions>
+
+using namespace Eigen;
+
+// Macro for unary special functions on arrays.
+#define BENCH_SPECIAL_UNARY(NAME, EXPR, LO, HI)                                                          \
+  template <typename Scalar>                                                                             \
+  static void BM_##NAME(benchmark::State& state) {                                                       \
+    const Index n = state.range(0);                                                                      \
+    using Arr = Array<Scalar, Dynamic, 1>;                                                               \
+    Arr a = (Arr::Random(n) + Scalar(1)) * Scalar((double(HI) - double(LO)) / 2.0) + Scalar(LO);         \
+    Arr b(n);                                                                                            \
+    for (auto _ : state) {                                                                               \
+      b = EXPR;                                                                                          \
+      benchmark::DoNotOptimize(b.data());                                                                \
+    }                                                                                                    \
+    state.counters["Elements/s"] = benchmark::Counter(n, benchmark::Counter::kIsIterationInvariantRate); \
+    state.SetBytesProcessed(state.iterations() * n * sizeof(Scalar) * 2);                                \
+  }
+
+// Macro for binary special functions on arrays.
+#define BENCH_SPECIAL_BINARY(NAME, EXPR, LO_A, HI_A, LO_B, HI_B)                                         \
+  template <typename Scalar>                                                                             \
+  static void BM_##NAME(benchmark::State& state) {                                                       \
+    const Index n = state.range(0);                                                                      \
+    using Arr = Array<Scalar, Dynamic, 1>;                                                               \
+    Arr a = (Arr::Random(n) + Scalar(1)) * Scalar((double(HI_A) - double(LO_A)) / 2.0) + Scalar(LO_A);   \
+    Arr b = (Arr::Random(n) + Scalar(1)) * Scalar((double(HI_B) - double(LO_B)) / 2.0) + Scalar(LO_B);   \
+    Arr c(n);                                                                                            \
+    for (auto _ : state) {                                                                               \
+      c = EXPR;                                                                                          \
+      benchmark::DoNotOptimize(c.data());                                                                \
+    }                                                                                                    \
+    state.counters["Elements/s"] = benchmark::Counter(n, benchmark::Counter::kIsIterationInvariantRate); \
+    state.SetBytesProcessed(state.iterations() * n * sizeof(Scalar) * 3);                                \
+  }
+
+// --- Unary special functions ---
+BENCH_SPECIAL_UNARY(Lgamma, Eigen::lgamma(a), 0.1, 20)
+BENCH_SPECIAL_UNARY(Digamma, Eigen::digamma(a), 0.1, 20)
+
+// --- Bessel functions (first kind) ---
+BENCH_SPECIAL_UNARY(BesselI0, Eigen::bessel_i0(a), 0, 10)
+BENCH_SPECIAL_UNARY(BesselI1, Eigen::bessel_i1(a), 0, 10)
+BENCH_SPECIAL_UNARY(BesselI0e, Eigen::bessel_i0e(a), 0, 100)
+BENCH_SPECIAL_UNARY(BesselI1e, Eigen::bessel_i1e(a), 0, 100)
+BENCH_SPECIAL_UNARY(BesselJ0, Eigen::bessel_j0(a), 0, 20)
+BENCH_SPECIAL_UNARY(BesselJ1, Eigen::bessel_j1(a), 0, 20)
+
+// --- Bessel functions (second kind) ---
+BENCH_SPECIAL_UNARY(BesselY0, Eigen::bessel_y0(a), 0.1, 20)
+BENCH_SPECIAL_UNARY(BesselY1, Eigen::bessel_y1(a), 0.1, 20)
+BENCH_SPECIAL_UNARY(BesselK0, Eigen::bessel_k0(a), 0.1, 20)
+BENCH_SPECIAL_UNARY(BesselK1, Eigen::bessel_k1(a), 0.1, 20)
+BENCH_SPECIAL_UNARY(BesselK0e, Eigen::bessel_k0e(a), 0.1, 100)
+BENCH_SPECIAL_UNARY(BesselK1e, Eigen::bessel_k1e(a), 0.1, 100)
+
+// --- Two-argument functions ---
+BENCH_SPECIAL_BINARY(Igamma, Eigen::igamma(a, b), 0.1, 10, 0.1, 10)
+BENCH_SPECIAL_BINARY(Igammac, Eigen::igammac(a, b), 0.1, 10, 0.1, 10)
+BENCH_SPECIAL_BINARY(Zeta, Eigen::zeta(a, b), 1.1, 10, 0.1, 10)
+BENCH_SPECIAL_BINARY(Polygamma, Eigen::polygamma(a, b), 1, 4, 0.1, 10)
+
+// --- Ternary: betainc ---
+template <typename Scalar>
+static void BM_Betainc(benchmark::State& state) {
+  const Index n = state.range(0);
+  using Arr = Array<Scalar, Dynamic, 1>;
+  Arr a = (Arr::Random(n) + Scalar(1)) * Scalar(2.5) + Scalar(0.5);  // [0.5, 5.5]
+  Arr b = (Arr::Random(n) + Scalar(1)) * Scalar(2.5) + Scalar(0.5);
+  Arr x = (Arr::Random(n) + Scalar(1)) * Scalar(0.5);  // [0, 1]
+  Arr result(n);
+  for (auto _ : state) {
+    result = Eigen::betainc(a, b, x);
+    benchmark::DoNotOptimize(result.data());
+  }
+  state.counters["Elements/s"] = benchmark::Counter(n, benchmark::Counter::kIsIterationInvariantRate);
+  state.SetBytesProcessed(state.iterations() * n * sizeof(Scalar) * 4);
+}
+
+#define SPECIAL_SIZES ->Arg(256)->Arg(4096)->Arg(65536)->Arg(1048576)
+
+// --- Register float ---
+BENCHMARK(BM_Lgamma<float>) SPECIAL_SIZES->Name("Lgamma_float");
+BENCHMARK(BM_Digamma<float>) SPECIAL_SIZES->Name("Digamma_float");
+BENCHMARK(BM_BesselI0<float>) SPECIAL_SIZES->Name("BesselI0_float");
+BENCHMARK(BM_BesselI1<float>) SPECIAL_SIZES->Name("BesselI1_float");
+BENCHMARK(BM_BesselI0e<float>) SPECIAL_SIZES->Name("BesselI0e_float");
+BENCHMARK(BM_BesselI1e<float>) SPECIAL_SIZES->Name("BesselI1e_float");
+BENCHMARK(BM_BesselJ0<float>) SPECIAL_SIZES->Name("BesselJ0_float");
+BENCHMARK(BM_BesselJ1<float>) SPECIAL_SIZES->Name("BesselJ1_float");
+BENCHMARK(BM_BesselY0<float>) SPECIAL_SIZES->Name("BesselY0_float");
+BENCHMARK(BM_BesselY1<float>) SPECIAL_SIZES->Name("BesselY1_float");
+BENCHMARK(BM_BesselK0<float>) SPECIAL_SIZES->Name("BesselK0_float");
+BENCHMARK(BM_BesselK1<float>) SPECIAL_SIZES->Name("BesselK1_float");
+BENCHMARK(BM_BesselK0e<float>) SPECIAL_SIZES->Name("BesselK0e_float");
+BENCHMARK(BM_BesselK1e<float>) SPECIAL_SIZES->Name("BesselK1e_float");
+BENCHMARK(BM_Igamma<float>) SPECIAL_SIZES->Name("Igamma_float");
+BENCHMARK(BM_Igammac<float>) SPECIAL_SIZES->Name("Igammac_float");
+BENCHMARK(BM_Betainc<float>) SPECIAL_SIZES->Name("Betainc_float");
+BENCHMARK(BM_Zeta<float>) SPECIAL_SIZES->Name("Zeta_float");
+BENCHMARK(BM_Polygamma<float>) SPECIAL_SIZES->Name("Polygamma_float");
+
+// --- Register double ---
+BENCHMARK(BM_Lgamma<double>) SPECIAL_SIZES->Name("Lgamma_double");
+BENCHMARK(BM_Digamma<double>) SPECIAL_SIZES->Name("Digamma_double");
+BENCHMARK(BM_BesselI0<double>) SPECIAL_SIZES->Name("BesselI0_double");
+BENCHMARK(BM_BesselI1<double>) SPECIAL_SIZES->Name("BesselI1_double");
+BENCHMARK(BM_BesselI0e<double>) SPECIAL_SIZES->Name("BesselI0e_double");
+BENCHMARK(BM_BesselI1e<double>) SPECIAL_SIZES->Name("BesselI1e_double");
+BENCHMARK(BM_BesselJ0<double>) SPECIAL_SIZES->Name("BesselJ0_double");
+BENCHMARK(BM_BesselJ1<double>) SPECIAL_SIZES->Name("BesselJ1_double");
+BENCHMARK(BM_BesselY0<double>) SPECIAL_SIZES->Name("BesselY0_double");
+BENCHMARK(BM_BesselY1<double>) SPECIAL_SIZES->Name("BesselY1_double");
+BENCHMARK(BM_BesselK0<double>) SPECIAL_SIZES->Name("BesselK0_double");
+BENCHMARK(BM_BesselK1<double>) SPECIAL_SIZES->Name("BesselK1_double");
+BENCHMARK(BM_BesselK0e<double>) SPECIAL_SIZES->Name("BesselK0e_double");
+BENCHMARK(BM_BesselK1e<double>) SPECIAL_SIZES->Name("BesselK1e_double");
+BENCHMARK(BM_Igamma<double>) SPECIAL_SIZES->Name("Igamma_double");
+BENCHMARK(BM_Igammac<double>) SPECIAL_SIZES->Name("Igammac_double");
+BENCHMARK(BM_Betainc<double>) SPECIAL_SIZES->Name("Betainc_double");
+BENCHMARK(BM_Zeta<double>) SPECIAL_SIZES->Name("Zeta_double");
+BENCHMARK(BM_Polygamma<double>) SPECIAL_SIZES->Name("Polygamma_double");
diff --git a/contrib/benchmarks/Splines/CMakeLists.txt b/contrib/benchmarks/Splines/CMakeLists.txt
new file mode 100644
index 0000000..2fa9d2a
--- /dev/null
+++ b/contrib/benchmarks/Splines/CMakeLists.txt
@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_splines bench_splines.cpp)
diff --git a/contrib/benchmarks/Splines/bench_splines.cpp b/contrib/benchmarks/Splines/bench_splines.cpp
new file mode 100644
index 0000000..ac4a7af
--- /dev/null
+++ b/contrib/benchmarks/Splines/bench_splines.cpp
@@ -0,0 +1,96 @@
+// Benchmarks for Eigen Spline module.
+// Tests fitting, evaluation, and derivative computation.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/Splines>
+
+using namespace Eigen;
+
+typedef double Scalar;
+
+// --- Spline fitting (interpolation) ---
+template <int Dim, int Degree>
+static void BM_SplineFit(benchmark::State& state) {
+  const int n = state.range(0);
+
+  typedef Spline<Scalar, Dim> SplineType;
+  typedef typename SplineType::PointType PointType;
+
+  // Generate random points.
+  Matrix<Scalar, Dim, Dynamic> pts(Dim, n);
+  pts.setRandom();
+
+  for (auto _ : state) {
+    SplineType spline = SplineFitting<SplineType>::Interpolate(pts, Degree);
+    benchmark::DoNotOptimize(spline.knots().data());
+    benchmark::ClobberMemory();
+  }
+}
+
+// --- Spline evaluation ---
+template <int Dim, int Degree>
+static void BM_SplineEval(benchmark::State& state) {
+  const int n = state.range(0);  // number of control points for fitting
+  const int neval = 1000;        // number of evaluation points
+
+  typedef Spline<Scalar, Dim> SplineType;
+
+  Matrix<Scalar, Dim, Dynamic> pts(Dim, n);
+  pts.setRandom();
+  SplineType spline = SplineFitting<SplineType>::Interpolate(pts, Degree);
+
+  // Generate evaluation parameters in [0, 1].
+  VectorXd u = VectorXd::LinSpaced(neval, 0, 1);
+
+  for (auto _ : state) {
+    for (int i = 0; i < neval; ++i) {
+      auto pt = spline(u(i));
+      benchmark::DoNotOptimize(pt.data());
+    }
+    benchmark::ClobberMemory();
+  }
+  state.counters["Evals/s"] = benchmark::Counter(neval, benchmark::Counter::kIsIterationInvariantRate);
+}
+
+// --- Spline derivative evaluation ---
+template <int Dim, int Degree>
+static void BM_SplineDerivatives(benchmark::State& state) {
+  const int n = state.range(0);
+  const int neval = 1000;
+
+  typedef Spline<Scalar, Dim> SplineType;
+
+  Matrix<Scalar, Dim, Dynamic> pts(Dim, n);
+  pts.setRandom();
+  SplineType spline = SplineFitting<SplineType>::Interpolate(pts, Degree);
+
+  VectorXd u = VectorXd::LinSpaced(neval, 0, 1);
+
+  for (auto _ : state) {
+    for (int i = 0; i < neval; ++i) {
+      auto derivs = spline.derivatives(u(i), 1);
+      benchmark::DoNotOptimize(derivs.data());
+    }
+    benchmark::ClobberMemory();
+  }
+  state.counters["Evals/s"] = benchmark::Counter(neval, benchmark::Counter::kIsIterationInvariantRate);
+}
+
+#define SPLINE_SIZES ->Arg(10)->Arg(50)->Arg(200)->Arg(1000)
+
+// 2D cubic splines
+BENCHMARK(BM_SplineFit<2, 3>) SPLINE_SIZES->Name("SplineFit_2D_Cubic");
+BENCHMARK(BM_SplineEval<2, 3>) SPLINE_SIZES->Name("SplineEval_2D_Cubic");
+BENCHMARK(BM_SplineDerivatives<2, 3>) SPLINE_SIZES->Name("SplineDerivatives_2D_Cubic");
+
+// 3D cubic splines
+BENCHMARK(BM_SplineFit<3, 3>) SPLINE_SIZES->Name("SplineFit_3D_Cubic");
+BENCHMARK(BM_SplineEval<3, 3>) SPLINE_SIZES->Name("SplineEval_3D_Cubic");
+BENCHMARK(BM_SplineDerivatives<3, 3>) SPLINE_SIZES->Name("SplineDerivatives_3D_Cubic");
+
+// 2D quintic splines
+BENCHMARK(BM_SplineFit<2, 5>) SPLINE_SIZES->Name("SplineFit_2D_Quintic");
+BENCHMARK(BM_SplineEval<2, 5>) SPLINE_SIZES->Name("SplineEval_2D_Quintic");
diff --git a/contrib/benchmarks/StructuredMatrices/CMakeLists.txt b/contrib/benchmarks/StructuredMatrices/CMakeLists.txt
new file mode 100644
index 0000000..aa3f795
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/CMakeLists.txt
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_structured_circulant bench_structured_circulant.cpp)
+eigen_add_benchmark(bench_structured_toeplitz bench_structured_toeplitz.cpp)
+eigen_add_benchmark(bench_structured_hankel bench_structured_hankel.cpp)
+eigen_add_benchmark(bench_structured_levinson bench_structured_levinson.cpp)
+eigen_add_benchmark(bench_structured_transpose bench_structured_transpose.cpp)
+eigen_add_benchmark(bench_structured_kronecker bench_structured_kronecker.cpp)
+eigen_add_benchmark(bench_structured_dplr bench_structured_dplr.cpp)
+eigen_add_benchmark(bench_structured_vandermonde bench_structured_vandermonde.cpp)
+eigen_add_benchmark(bench_structured_cauchy bench_structured_cauchy.cpp)
+eigen_add_benchmark(bench_structured_dpr1 bench_structured_dpr1.cpp)
+eigen_add_benchmark(bench_structured_bccb bench_structured_bccb.cpp)
+eigen_add_benchmark(bench_structured_bccb_solve bench_structured_bccb_solve.cpp)
+eigen_add_benchmark(bench_structured_circulant_solve bench_structured_circulant_solve.cpp)
+eigen_add_benchmark(bench_structured_circulant_inverse bench_structured_circulant_inverse.cpp)
+eigen_add_benchmark(bench_structured_materialize bench_structured_materialize.cpp)
+eigen_add_benchmark(bench_structured_kronecker_spectral bench_structured_kronecker_spectral.cpp)
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_bccb.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_bccb.cpp
new file mode 100644
index 0000000..30d71f8
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_bccb.cpp
@@ -0,0 +1,96 @@
+// Benchmarks for the Bccb operator: the O(N log N) 2-D-FFT-based product and
+// direct solve against their dense counterparts (GEMV, and a solve with a
+// precomputed PartialPivLU factorization -- the analogue of Bccb's symbol,
+// which is precomputed at construction). The generating array is n x n, so the
+// operator is N x N with N = n^2; the dense variants stop at n = 64 (N = 4096)
+// to keep the dense matrix and its factorization affordable.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <Eigen/LU>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+// Diagonally dominant generating array: keeps the symbol away from zero, so the
+// solves are well conditioned.
+static Mat generatingArray(Index n) {
+  Mat G = Mat::Random(n, n);
+  G(0, 0) += double(2 * n * n);
+  return G;
+}
+
+// The dense representation, built entry-wise: entry (i,j) with i = b1*n2 + i2,
+// j = c1*n2 + j2 is G((i2-j2) mod n2, (b1-c1) mod n1).
+static Mat denseBccb(const Mat& G) {
+  const Index n2 = G.rows(), n1 = G.cols(), N = n1 * n2;
+  Mat dense(N, N);
+  for (Index j = 0; j < N; ++j)
+    for (Index i = 0; i < N; ++i) {
+      Index k2 = i % n2 - j % n2;
+      if (k2 < 0) k2 += n2;
+      Index k1 = i / n2 - j / n2;
+      if (k1 < 0) k1 += n1;
+      dense(i, j) = G(k2, k1);
+    }
+  return dense;
+}
+
+// --- product: y = C * x ---
+static void BM_BccbProduct(benchmark::State& state) {
+  const Index n = state.range(0), N = n * n;
+  Mat G = generatingArray(n);
+  Bccb<double> C(G);
+  Vec x = Vec::Random(N), y(N);
+  for (auto _ : state) {
+    y.noalias() = C * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+// 97 is prime in both block dimensions: the product pins the padded embedding
+// (the exact-size transform would run kissfft's quadratic generic butterfly).
+BENCHMARK(BM_BccbProduct)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(97)->Arg(128);
+
+static void BM_DenseProduct(benchmark::State& state) {
+  const Index n = state.range(0), N = n * n;
+  Mat dense = denseBccb(generatingArray(n));
+  Vec x = Vec::Random(N), y(N);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_DenseProduct)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+// --- solve: x = C^{-1} * b, both sides reusing their precomputed factorization
+// (the 2-D DFT symbol for Bccb, the LU factors for the dense matrix) ---
+static void BM_BccbSolve(benchmark::State& state) {
+  const Index n = state.range(0), N = n * n;
+  Mat G = generatingArray(n);
+  Bccb<double> C(G);
+  Vec b = Vec::Random(N), x(N);
+  for (auto _ : state) {
+    x = C.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+// All 5-smooth: solve transforms at the exact size, so a prime dimension would
+// only time kissfft's generic butterfly instead of the operator.
+BENCHMARK(BM_BccbSolve)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(96)->Arg(128);
+
+static void BM_DenseSolve(benchmark::State& state) {
+  const Index n = state.range(0), N = n * n;
+  Mat dense = denseBccb(generatingArray(n));
+  PartialPivLU<Mat> lu(dense);
+  Vec b = Vec::Random(N), x(N);
+  for (auto _ : state) {
+    x = lu.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_DenseSolve)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_bccb_solve.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_bccb_solve.cpp
new file mode 100644
index 0000000..d5030ac
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_bccb_solve.cpp
@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/StructuredMatrices>
+
+using Eigen::Bccb;
+using Eigen::Dynamic;
+using Eigen::Index;
+using Eigen::Matrix;
+
+template <typename Scalar>
+static void BM_BccbSolveReciprocals(benchmark::State& state) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+  const Index n = state.range(0), nrhs = state.range(1), kind = state.range(2);
+  Mat generator = Mat::Zero(n, n);
+  if (kind == 0) {
+    for (Index k = 0; k < n * n; ++k) generator(k) = Scalar(RealScalar(k % 17 - 8) / RealScalar(16));
+    generator(0, 0) += Scalar(2 * n * n);
+  } else if (kind == 1) {
+    generator(0, 0) = Scalar(1);  // Real symbol: exercises the scalar fallback.
+  } else {
+    generator.setConstant(Scalar(1));  // Only the DC mode survives the threshold.
+  }
+  const Bccb<Scalar> op(generator);
+  Mat expected(n * n, nrhs);
+  for (Index k = 0; k < expected.size(); ++k)
+    expected(k) = kind == 2 ? Scalar(1) : Scalar(RealScalar(k % 13 - 6) / RealScalar(8));
+  const Mat rhs = op * expected;
+  Mat solution = op.solve(rhs);
+  // The round trip through these well-conditioned operators costs O(log N) eps.
+  if (!solution.allFinite() ||
+      (solution - expected).norm() > RealScalar(128) * Eigen::NumTraits<RealScalar>::epsilon() * expected.norm()) {
+    state.SkipWithError("Bccb solve round-trip check failed");
+    return;
+  }
+  for (auto _ : state) {
+    solution = op.solve(rhs);
+    benchmark::DoNotOptimize(solution.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_TEMPLATE(BM_BccbSolveReciprocals, float)->ArgsProduct({{5, 8, 32, 128}, {1, 8}, {0, 1, 2}});
+BENCHMARK_TEMPLATE(BM_BccbSolveReciprocals, double)->ArgsProduct({{5, 8, 32, 128}, {1, 8}, {0, 1, 2}});
+BENCHMARK_TEMPLATE(BM_BccbSolveReciprocals, std::complex<float>)->ArgsProduct({{5, 8, 32, 128}, {1, 8}, {0, 1, 2}});
+BENCHMARK_TEMPLATE(BM_BccbSolveReciprocals, std::complex<double>)->ArgsProduct({{5, 8, 32, 128}, {1, 8}, {0, 1, 2}});
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_cauchy.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_cauchy.cpp
new file mode 100644
index 0000000..0bcfea9
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_cauchy.cpp
@@ -0,0 +1,183 @@
+// Benchmarks for the Cauchy operator: the O(mn)-flop, O(m+n)-storage direct
+// product against its dense equivalents (with and without materializing the
+// matrix first), and the O(n^2) GKO pivoted solver (CauchyLU) against the
+// O(n^3) dense PartialPivLU of the materialized matrix.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <Eigen/LU>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+// After reversing its rows, this Cauchy matrix has diagonal 4n and off-diagonal
+// row sums below 2 H_n. It is well conditioned while still exercising row
+// pivoting in CauchyLU.
+static void wellConditionedNodes(Index n, Vec& x, Vec& y) {
+  x.resize(n);
+  y.resize(n);
+  const double delta = 1.0 / (4.0 * static_cast<double>(n));
+  for (Index i = 0; i < n; ++i) {
+    x[i] = static_cast<double>(n - 1 - i);
+    y[i] = static_cast<double>(i) - delta;
+  }
+}
+
+static Mat denseCauchy(const Vec& x, const Vec& y) {
+  Mat dense(x.size(), y.size());
+  for (Index j = 0; j < y.size(); ++j)
+    for (Index i = 0; i < x.size(); ++i) dense(i, j) = 1.0 / (x[i] - y[j]);
+  return dense;
+}
+
+static Vec benchmarkVector(Index n) { return Vec::LinSpaced(n, -1.0, 1.0); }
+
+static bool productIsAccurate(const Vec& product, const Vec& x, const Vec& y, const Vec& vector) {
+  if (!product.allFinite()) return false;
+  Vec reference = Vec::Zero(x.size());
+  for (Index i = 0; i < x.size(); ++i)
+    for (Index j = 0; j < y.size(); ++j) reference[i] += vector[j] / (x[i] - y[j]);
+  const double tolerance = 64.0 * static_cast<double>(y.size()) * NumTraits<double>::epsilon();
+  return (product - reference).norm() <= tolerance * (reference.norm() + 1.0);
+}
+
+static bool solveIsAccurate(const Mat& matrix, const Vec& solution, const Vec& rhs) {
+  if (!solution.allFinite()) return false;
+  const Vec residual = matrix * solution - rhs;
+  if (!residual.allFinite()) return false;
+  const double scale = matrix.norm() * solution.norm() + rhs.norm();
+  const double tolerance = 512.0 * static_cast<double>(matrix.rows()) * NumTraits<double>::epsilon();
+  return residual.norm() <= tolerance * scale;
+}
+
+// --- Matrix-vector product w = C * v ---
+static void BM_CauchyProduct(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec x, y;
+  wellConditionedNodes(n, x, y);
+  Cauchy<double> C(x, y);  // O(n) storage; entries generated on the fly
+  Vec v = benchmarkVector(n), w(n);
+  {
+    const Vec product = C * v;
+    if (!productIsAccurate(product, x, y, v)) {
+      state.SkipWithError("Cauchy product validation failed");
+      return;
+    }
+  }
+  for (auto _ : state) {
+    w.noalias() = C * v;
+    benchmark::DoNotOptimize(w.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_CauchyProduct)->Arg(64)->Arg(256)->Arg(1024);
+
+static void BM_DenseCauchyProduct(benchmark::State& state) {
+  // The dense product once the matrix has been materialized (O(n^2) storage).
+  const Index n = state.range(0);
+  Vec x, y;
+  wellConditionedNodes(n, x, y);
+  Mat dense = denseCauchy(x, y);
+  Vec v = benchmarkVector(n), w(n);
+  {
+    const Vec product = dense * v;
+    if (!productIsAccurate(product, x, y, v)) {
+      state.SkipWithError("dense product validation failed");
+      return;
+    }
+  }
+  for (auto _ : state) {
+    w.noalias() = dense * v;
+    benchmark::DoNotOptimize(w.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DenseCauchyProduct)->Arg(64)->Arg(256)->Arg(1024);
+
+static void BM_DenseCauchyMaterializeProduct(benchmark::State& state) {
+  // The dense equivalent when the matrix is not kept around: materialize from
+  // the node vectors, then multiply.
+  const Index n = state.range(0);
+  Vec x, y;
+  wellConditionedNodes(n, x, y);
+  Cauchy<double> C(x, y);
+  Vec v = benchmarkVector(n), w(n);
+  {
+    const Mat dense = C;
+    const Vec product = dense * v;
+    if (!productIsAccurate(product, x, y, v)) {
+      state.SkipWithError("materialized product validation failed");
+      return;
+    }
+  }
+  for (auto _ : state) {
+    Mat dense = C;
+    w.noalias() = dense * v;
+    benchmark::DoNotOptimize(w.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DenseCauchyMaterializeProduct)->Arg(64)->Arg(256)->Arg(1024);
+
+// --- Square solve C * u = b from the node vectors ---
+static void BM_CauchyLUSolve(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec x, y;
+  wellConditionedNodes(n, x, y);
+  Cauchy<double> C(x, y);
+  Vec b(n);
+  {
+    const Vec expected = benchmarkVector(n);
+    const Mat dense = C;
+    b = dense * expected;
+    CauchyLU<double> check(C);
+    if (check.info() != Success) {
+      state.SkipWithError("CauchyLU factorization failed");
+      return;
+    }
+    const Vec solution = check.solve(b);
+    if (!solveIsAccurate(dense, solution, b)) {
+      state.SkipWithError("CauchyLU validation failed");
+      return;
+    }
+  }
+  Vec u(n);
+  for (auto _ : state) {
+    CauchyLU<double> lu(C);  // O(n^2) pivoted factorization (GKO)
+    u = lu.solve(b);
+    benchmark::DoNotOptimize(u.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_CauchyLUSolve)->Arg(64)->Arg(256)->Arg(1024);
+
+static void BM_DensePartialPivLUSolve(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec x, y;
+  wellConditionedNodes(n, x, y);
+  Mat dense = denseCauchy(x, y);
+  Vec b(n);
+  {
+    const Vec expected = benchmarkVector(n);
+    b = dense * expected;
+    PartialPivLU<Mat> check(dense);
+    const Vec solution = check.solve(b);
+    if (!solveIsAccurate(dense, solution, b)) {
+      state.SkipWithError("PartialPivLU validation failed");
+      return;
+    }
+  }
+  Vec u(n);
+  for (auto _ : state) {
+    PartialPivLU<Mat> lu(dense);  // O(n^3) pivoted factorization
+    u = lu.solve(b);
+    benchmark::DoNotOptimize(u.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DensePartialPivLUSolve)->Arg(64)->Arg(256)->Arg(1024);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_circulant.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_circulant.cpp
new file mode 100644
index 0000000..8e9801e
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_circulant.cpp
@@ -0,0 +1,232 @@
+// Benchmarks for the Circulant operator's public operations: the fast product
+// across its three dispatch tiers (scalar, segment, FFT; 5-smooth and prime
+// transform sizes), the direct solve, and the closed-form factorizations
+// (determinant, rank, inverse, eigendecomposition, SVD), each against the dense
+// alternative where one exists. The near-overflow product pins the power-of-two
+// scaled FFT path, which is tuned to cost nothing for moderate magnitudes.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Dense>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+typedef Matrix<std::complex<double>, Dynamic, 1> CVec;
+
+// Diagonally dominant generator: keeps the operator safely invertible for the
+// solve/inverse/determinant benchmarks.
+static Vec wellConditionedGenerator(Index n) {
+  Vec c = Vec::Random(n);
+  c[0] += 2.0 * double(n);
+  return c;
+}
+
+// --- Construction: the one-time symbol FFT (5-smooth vs prime sizes) ---
+static void BM_CirculantConstruct(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n);
+  for (auto _ : state) {
+    Circulant<double> C(c);
+    benchmark::DoNotOptimize(C);
+  }
+}
+BENCHMARK(BM_CirculantConstruct)->Arg(96)->Arg(97)->Arg(1024)->Arg(4096);
+
+// --- Product y = C * x across the dispatch tiers ---
+// 8: scalar loop; 32: segment tier boundary; 96/1024/4096: FFT (5-smooth);
+// 97: FFT at a prime size (no 5-smooth padding for a circulant).
+static void BM_CirculantProduct(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), x = Vec::Random(n), y(n);
+  Circulant<double> C(c);
+  for (auto _ : state) {
+    y.noalias() = C * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_CirculantProduct)->Arg(8)->Arg(32)->Arg(96)->Arg(97)->Arg(1024)->Arg(4096);
+
+static void BM_CirculantProductDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), x = Vec::Random(n), y(n);
+  Mat dense = Circulant<double>(c);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_CirculantProductDense)->Arg(96)->Arg(1024)->Arg(4096);
+
+static void BM_CirculantProductComplex(benchmark::State& state) {
+  const Index n = state.range(0);
+  CVec c = CVec::Random(n), x = CVec::Random(n), y(n);
+  Circulant<std::complex<double>> C(c);
+  for (auto _ : state) {
+    y.noalias() = C * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_CirculantProductComplex)->Arg(96)->Arg(4096);
+
+// Multi-column right-hand sides: one FFT round trip per column.
+static void BM_CirculantProductMultiRhs(benchmark::State& state) {
+  const Index n = state.range(0), k = state.range(1);
+  Vec c = Vec::Random(n);
+  Mat X = Mat::Random(n, k), Y(n, k);
+  Circulant<double> C(c);
+  for (auto _ : state) {
+    Y.noalias() = C * X;
+    benchmark::DoNotOptimize(Y.data());
+  }
+}
+BENCHMARK(BM_CirculantProductMultiRhs)->ArgsProduct({{96, 4096}, {8}});
+
+// Near-overflow magnitudes engage the exact power-of-two scaling inside the FFT
+// path; regression guard for that machinery staying cheap.
+static void BM_CirculantProductNearOverflow(benchmark::State& state) {
+  const Index n = state.range(0);
+  const double huge = (std::numeric_limits<double>::max)() / 16.0;
+  Vec c = Vec::Random(n), x = Vec::Constant(n, huge), y(n);
+  Circulant<double> C(Vec(c / double(n)));  // keep the products representable
+  for (auto _ : state) {
+    y.noalias() = C * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_CirculantProductNearOverflow)->Arg(4096);
+
+// --- Solve (direct, in the Fourier domain) vs a dense LU solve ---
+static void BM_CirculantSolve(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = wellConditionedGenerator(n), b = Vec::Random(n);
+  Circulant<double> C(c);
+  for (auto _ : state) {
+    Vec x = C.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_CirculantSolve)->Arg(96)->Arg(1024)->Arg(4096);
+
+// The dense path pays the O(n^3) factorization on every call, which is the
+// honest end-to-end comparison starting from a formed operator.
+static void BM_CirculantSolveDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = wellConditionedGenerator(n), b = Vec::Random(n);
+  Mat dense = Circulant<double>(c);
+  for (auto _ : state) {
+    Vec x = PartialPivLU<Mat>(dense).solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_CirculantSolveDense)->Arg(96)->Arg(1024);
+
+// --- Determinant (balanced product of the symbol entries) vs dense LU ---
+static void BM_CirculantDeterminant(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(wellConditionedGenerator(n));
+  for (auto _ : state) {
+    double d = C.determinant();
+    benchmark::DoNotOptimize(d);
+  }
+}
+BENCHMARK(BM_CirculantDeterminant)->Arg(1024)->Arg(4096);
+
+static void BM_CirculantDeterminantDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat dense = Circulant<double>(wellConditionedGenerator(n));
+  for (auto _ : state) {
+    double d = PartialPivLU<Mat>(dense).determinant();
+    benchmark::DoNotOptimize(d);
+  }
+}
+BENCHMARK(BM_CirculantDeterminantDense)->Arg(256);
+
+// --- Rank (rescaled symbol moduli against the SVD-style threshold) ---
+static void BM_CirculantRank(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(wellConditionedGenerator(n));
+  for (auto _ : state) {
+    Index r = C.rank();
+    benchmark::DoNotOptimize(r);
+  }
+}
+BENCHMARK(BM_CirculantRank)->Arg(1024)->Arg(4096);
+
+// --- Inverse operator (reciprocal symbol + one inverse FFT) ---
+static void BM_CirculantInverse(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(wellConditionedGenerator(n));
+  for (auto _ : state) {
+    Circulant<double> Ci = C.inverse();
+    benchmark::DoNotOptimize(Ci);
+  }
+}
+BENCHMARK(BM_CirculantInverse)->Arg(256)->Arg(1024)->Arg(4096);
+
+// --- Eigendecomposition: closed form vs the dense (non-symmetric) solver ---
+static void BM_CirculantEigenvalues(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(Vec(Vec::Random(n)));
+  for (auto _ : state) {
+    CVec ev = C.eigenvalues();
+    benchmark::DoNotOptimize(ev.data());
+  }
+}
+BENCHMARK(BM_CirculantEigenvalues)->Arg(1024)->Arg(4096);
+
+// Materializes the dense n x n Fourier eigenvector matrix.
+static void BM_CirculantEigenvectors(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(Vec(Vec::Random(n)));
+  for (auto _ : state) {
+    auto V = C.eigenvectors();
+    benchmark::DoNotOptimize(V.data());
+  }
+}
+BENCHMARK(BM_CirculantEigenvectors)->Arg(64)->Arg(256);
+
+static void BM_CirculantEigenDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat dense = Circulant<double>(Vec(Vec::Random(n)));
+  for (auto _ : state) {
+    EigenSolver<Mat> es(dense);
+    benchmark::DoNotOptimize(es.eigenvalues().data());
+  }
+}
+BENCHMARK(BM_CirculantEigenDense)->Arg(256);
+
+// --- SVD: closed form (moduli/phases of the symbol) vs dense BDCSVD ---
+static void BM_CirculantSingularValues(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(Vec(Vec::Random(n)));
+  for (auto _ : state) {
+    Vec sv = C.singularValues();
+    benchmark::DoNotOptimize(sv.data());
+  }
+}
+BENCHMARK(BM_CirculantSingularValues)->Arg(1024)->Arg(4096);
+
+// Materializes the dense n x n left singular vector matrix.
+static void BM_CirculantMatrixU(benchmark::State& state) {
+  const Index n = state.range(0);
+  Circulant<double> C(Vec(Vec::Random(n)));
+  for (auto _ : state) {
+    auto U = C.matrixU();
+    benchmark::DoNotOptimize(U.data());
+  }
+}
+BENCHMARK(BM_CirculantMatrixU)->Arg(64)->Arg(256);
+
+static void BM_CirculantSvdDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat dense = Circulant<double>(Vec(Vec::Random(n)));
+  for (auto _ : state) {
+    BDCSVD<Mat, ComputeThinU | ComputeThinV> svd(dense);
+    benchmark::DoNotOptimize(svd.singularValues().data());
+  }
+}
+BENCHMARK(BM_CirculantSvdDense)->Arg(256);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_circulant_inverse.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_circulant_inverse.cpp
new file mode 100644
index 0000000..957694a
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_circulant_inverse.cpp
@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/StructuredMatrices>
+
+using Eigen::Dynamic;
+using Eigen::Index;
+using Eigen::Matrix;
+
+template <typename Scalar>
+static void BM_CirculantInverseReciprocals(benchmark::State& state) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+  using Operator = Eigen::Circulant<Scalar>;
+  using Generator = typename Operator::GeneratorType;
+  const Index size = state.range(0), kind = state.range(1);
+  Generator generator = Generator::Zero(size);
+  if (kind == 0) {
+    for (Index k = 0; k < size; ++k) generator(k) = Scalar(RealScalar(k % 17 - 8) / RealScalar(16));
+    generator(0) += Scalar(2 * size);
+  } else {
+    generator(0) = Scalar(1);  // Real symbol: exercises the scalar fallback.
+  }
+  const Operator op(generator);
+  Vec expected(size);
+  for (Index k = 0; k < size; ++k) expected(k) = Scalar(RealScalar(k % 13 - 6) / RealScalar(8));
+  const Vec rhs = op * expected;
+  Operator inverse = op.inverse();
+  const Vec actual = inverse * rhs;
+  if (!actual.allFinite() ||
+      (actual - expected).norm() > RealScalar(128) * Eigen::NumTraits<RealScalar>::epsilon() * expected.norm()) {
+    state.SkipWithError("Circulant inverse round-trip check failed");
+    return;
+  }
+  for (auto _ : state) {
+    inverse = op.inverse();
+    benchmark::DoNotOptimize(inverse);
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_TEMPLATE(BM_CirculantInverseReciprocals, float)->ArgsProduct({{25, 64, 1024, 16384}, {0, 1}});
+BENCHMARK_TEMPLATE(BM_CirculantInverseReciprocals, double)->ArgsProduct({{25, 64, 1024, 16384}, {0, 1}});
+BENCHMARK_TEMPLATE(BM_CirculantInverseReciprocals, std::complex<float>)->ArgsProduct({{25, 64, 1024, 16384}, {0, 1}});
+BENCHMARK_TEMPLATE(BM_CirculantInverseReciprocals, std::complex<double>)->ArgsProduct({{25, 64, 1024, 16384}, {0, 1}});
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_circulant_solve.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_circulant_solve.cpp
new file mode 100644
index 0000000..50c566c
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_circulant_solve.cpp
@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/StructuredMatrices>
+
+using Eigen::Circulant;
+using Eigen::Dynamic;
+using Eigen::Index;
+using Eigen::Matrix;
+
+template <typename Scalar>
+static void BM_CirculantSolveReciprocals(benchmark::State& state) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+  const Index n = state.range(0), nrhs = state.range(1), kind = state.range(2);
+  Matrix<Scalar, Dynamic, 1> generator = Matrix<Scalar, Dynamic, 1>::Zero(n);
+  if (kind == 0) {
+    for (Index k = 0; k < n; ++k) generator(k) = Scalar(RealScalar(k % 17 - 8) / RealScalar(16));
+    generator(0, 0) += Scalar(2 * n);
+  } else if (kind == 1) {
+    generator(0, 0) = Scalar(1);  // Real symbol: exercises the scalar fallback.
+  } else {
+    generator.setConstant(Scalar(1));  // Only the DC mode survives the threshold.
+  }
+  const Circulant<Scalar> op(generator);
+  Mat expected(n, nrhs);
+  for (Index k = 0; k < expected.size(); ++k)
+    expected(k) = kind == 2 ? Scalar(1) : Scalar(RealScalar(k % 13 - 6) / RealScalar(8));
+  const Mat rhs = op * expected;
+  Mat solution = op.solve(rhs);
+  // The round trip through these well-conditioned operators costs O(log N) eps.
+  if (!solution.allFinite() ||
+      (solution - expected).norm() > RealScalar(128) * Eigen::NumTraits<RealScalar>::epsilon() * expected.norm()) {
+    state.SkipWithError("Circulant solve round-trip check failed");
+    return;
+  }
+  for (auto _ : state) {
+    solution = op.solve(rhs);
+    benchmark::DoNotOptimize(solution.data());
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK_TEMPLATE(BM_CirculantSolveReciprocals, float)->ArgsProduct({{15, 64, 1024, 16384}, {1, 8}, {0, 1, 2}});
+BENCHMARK_TEMPLATE(BM_CirculantSolveReciprocals, double)->ArgsProduct({{15, 64, 1024, 16384}, {1, 8}, {0, 1, 2}});
+BENCHMARK_TEMPLATE(BM_CirculantSolveReciprocals, std::complex<float>)
+    ->ArgsProduct({{15, 64, 1024, 16384}, {1, 8}, {0, 1, 2}});
+BENCHMARK_TEMPLATE(BM_CirculantSolveReciprocals, std::complex<double>)
+    ->ArgsProduct({{15, 64, 1024, 16384}, {1, 8}, {0, 1, 2}});
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_dplr.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_dplr.cpp
new file mode 100644
index 0000000..706da5b
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_dplr.cpp
@@ -0,0 +1,72 @@
+// Benchmarks for the DiagonalPlusLowRank operator: the implicit O(nk) product
+// and the O(nk^2 + k^3) Woodbury solve against their dense equivalents (the
+// O(n^2) materialized product and the O(n^3) LU factor-and-solve). The solve
+// benchmarks time factorization plus one right-hand side on both sides, the
+// use case the Woodbury identity accelerates.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <Eigen/LU>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+// Well-conditioned operator: diagonal bounded away from zero and a contractive
+// correction, so the capacitance matrix is safely invertible.
+static DiagonalPlusLowRank<double> makeOperator(Index n, Index k) {
+  Vec d = Vec::Random(n).array() + 3.0;
+  Mat U = 0.5 * Mat::Random(n, k);
+  Mat V = 0.5 * Mat::Random(n, k);
+  return DiagonalPlusLowRank<double>(d, U, V);
+}
+
+// --- Matrix-vector product: implicit O(nk) vs. materialized dense O(n^2) ---
+static void BM_DplrProduct(benchmark::State& state) {
+  const Index n = state.range(0), k = state.range(1);
+  DiagonalPlusLowRank<double> A = makeOperator(n, k);
+  Vec x = Vec::Random(n), y(n);
+  for (auto _ : state) {
+    y.noalias() = A * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_DplrProduct)->ArgsProduct({{256, 1024, 4096}, {4, 32}});
+
+static void BM_DenseProduct(benchmark::State& state) {
+  const Index n = state.range(0), k = state.range(1);
+  Mat dense = makeOperator(n, k);
+  Vec x = Vec::Random(n), y(n);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_DenseProduct)->ArgsProduct({{256, 1024, 4096}, {4, 32}});
+
+// --- Solve: Woodbury (k x k capacitance LU) vs. dense n x n LU ---
+static void BM_DplrSolve(benchmark::State& state) {
+  const Index n = state.range(0), k = state.range(1);
+  DiagonalPlusLowRank<double> A = makeOperator(n, k);
+  Vec b = Vec::Random(n), x(n);
+  for (auto _ : state) {
+    x = A.solve(b);  // factors the k x k capacitance matrix each iteration
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_DplrSolve)->ArgsProduct({{256, 1024, 4096}, {4, 32}});
+
+static void BM_DenseLuSolve(benchmark::State& state) {
+  const Index n = state.range(0), k = state.range(1);
+  Mat dense = makeOperator(n, k);
+  Vec b = Vec::Random(n), x(n);
+  for (auto _ : state) {
+    x = dense.partialPivLu().solve(b);  // factors the n x n matrix each iteration
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_DenseLuSolve)->ArgsProduct({{256, 1024, 4096}, {4, 32}});
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_dpr1.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_dpr1.cpp
new file mode 100644
index 0000000..8831771
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_dpr1.cpp
@@ -0,0 +1,121 @@
+// Benchmarks for DPR1EigenSolver, the direct O(n^2) secular-equation
+// eigensolver for real symmetric diagonal-plus-rank-one matrices
+// D + rho*z*z^T, against the dense O(n^3) SelfAdjointEigenSolver applied to
+// the materialized matrix. The dense matrix is formed outside the timed loop,
+// so the dense side is not even charged for materialization.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Dense>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+struct DPR1Problem {
+  explicit DPR1Problem(Index n) : d(n), z(n), rho(2.0) {
+    for (Index i = 0; i < n; ++i) {
+      d[i] = 2.0 * double((37 * i) % n) / double(n - 1) - 1.0;
+      z[i] = 2.0 * (double((53 * i + 1) % n) + 0.5) / double(n) - 1.0;
+    }
+    dense = Mat(d.asDiagonal()) + rho * z * z.transpose();
+  }
+
+  Vec d;
+  Vec z;
+  double rho;
+  Mat dense;
+};
+
+static bool validEigenvectors(const DPR1Problem& problem, const Vec& eigenvalues, const Mat& eigenvectors, double tol,
+                              double scale) {
+  const Index n = problem.d.size();
+  const double residual = (problem.dense * eigenvectors - eigenvectors * eigenvalues.asDiagonal()).norm();
+  const double orthogonality = (eigenvectors.transpose() * eigenvectors - Mat::Identity(n, n)).norm();
+  return residual <= tol * scale * numext::sqrt(double(n)) && orthogonality <= tol;
+}
+
+static bool preflight(const DPR1Problem& problem, int options) {
+  const Index n = problem.d.size();
+  const double scale = problem.d.cwiseAbs().maxCoeff() + numext::abs(problem.rho) * problem.z.squaredNorm();
+  const double tol = 100.0 * double(n) * NumTraits<double>::epsilon();
+  const bool computeVectors = (options & ComputeEigenvectors) == ComputeEigenvectors;
+
+  DPR1EigenSolver<double> dpr1(problem.d, problem.rho, problem.z, options);
+  SelfAdjointEigenSolver<Mat> dense(problem.dense, options);
+  if (dpr1.info() != Success || dense.info() != Success || !dpr1.eigenvalues().allFinite() ||
+      !dense.eigenvalues().allFinite()) {
+    return false;
+  }
+  if ((dpr1.eigenvalues() - dense.eigenvalues()).cwiseAbs().maxCoeff() > tol * scale) return false;
+  if (!computeVectors) return true;
+  return validEigenvectors(problem, dpr1.eigenvalues(), dpr1.eigenvectors(), tol, scale) &&
+         validEigenvectors(problem, dense.eigenvalues(), dense.eigenvectors(), tol, scale);
+}
+
+// --- full decomposition: eigenvalues + orthogonal eigenvectors ---
+static void BM_DPR1EigenSolver(benchmark::State& state) {
+  const Index n = state.range(0);
+  const DPR1Problem problem(n);
+  if (!preflight(problem, ComputeEigenvectors)) {
+    state.SkipWithError("DPR1 benchmark preflight failed");
+    return;
+  }
+  for (auto _ : state) {
+    DPR1EigenSolver<double> es(problem.d, problem.rho, problem.z);
+    benchmark::DoNotOptimize(es.eigenvalues().data());
+    benchmark::DoNotOptimize(es.eigenvectors().data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DPR1EigenSolver)->Arg(32)->Arg(128)->Arg(512)->Arg(1024);
+
+static void BM_DenseSelfAdjointEigenSolver(benchmark::State& state) {
+  const Index n = state.range(0);
+  const DPR1Problem problem(n);
+  if (!preflight(problem, ComputeEigenvectors)) {
+    state.SkipWithError("dense benchmark preflight failed");
+    return;
+  }
+  for (auto _ : state) {
+    SelfAdjointEigenSolver<Mat> es(problem.dense);
+    benchmark::DoNotOptimize(es.eigenvalues().data());
+    benchmark::DoNotOptimize(es.eigenvectors().data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DenseSelfAdjointEigenSolver)->Arg(32)->Arg(128)->Arg(512)->Arg(1024);
+
+// --- eigenvalues only ---
+static void BM_DPR1EigenSolverValuesOnly(benchmark::State& state) {
+  const Index n = state.range(0);
+  const DPR1Problem problem(n);
+  if (!preflight(problem, EigenvaluesOnly)) {
+    state.SkipWithError("DPR1 values-only benchmark preflight failed");
+    return;
+  }
+  for (auto _ : state) {
+    DPR1EigenSolver<double> es(problem.d, problem.rho, problem.z, EigenvaluesOnly);
+    benchmark::DoNotOptimize(es.eigenvalues().data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DPR1EigenSolverValuesOnly)->Arg(32)->Arg(128)->Arg(512)->Arg(1024);
+
+static void BM_DenseSelfAdjointEigenSolverValuesOnly(benchmark::State& state) {
+  const Index n = state.range(0);
+  const DPR1Problem problem(n);
+  if (!preflight(problem, EigenvaluesOnly)) {
+    state.SkipWithError("dense values-only benchmark preflight failed");
+    return;
+  }
+  for (auto _ : state) {
+    SelfAdjointEigenSolver<Mat> es(problem.dense, EigenvaluesOnly);
+    benchmark::DoNotOptimize(es.eigenvalues().data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_DenseSelfAdjointEigenSolverValuesOnly)->Arg(32)->Arg(128)->Arg(512)->Arg(1024);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_hankel.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_hankel.cpp
new file mode 100644
index 0000000..6394a66
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_hankel.cpp
@@ -0,0 +1,119 @@
+// Benchmarks for the fast Hankel matrix-vector product: the structured operator
+// (O(n log n) via a cached DFT symbol, with direct O(n) dispatch for single-row
+// and single-column shapes) against the equivalent dense GEMV. The *Dense
+// variants evaluate the same product through a materialized dense matrix.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+// --- Square n x n product: FFT-based operator vs dense GEMV ---
+static void BM_HankelProduct(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec h = Vec::Random(2 * n - 1);
+  Hankel<double> H(h.head(n), h.tail(n));  // the FFT symbol is paid once, here
+  Vec x = Vec::Random(n), y(n);
+  for (auto _ : state) {
+    y.noalias() = H * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_HankelProduct)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+static void BM_HankelProductDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec h = Vec::Random(2 * n - 1);
+  Mat dense = Hankel<double>(h.head(n), h.tail(n));
+  Vec x = Vec::Random(n), y(n);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_HankelProductDense)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+// --- Skinny 1 x n: dispatched to a direct O(n) dot-product kernel, not the FFT
+// (whose O(n log n) cost plus setup is asymptotically worse than direct here) ---
+static void BM_HankelProductSkinnyRow(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec h = Vec::Random(n);  // generating sequence of the 1 x n operator
+  Hankel<double> H(h.head(1), h.tail(n));
+  Vec x = Vec::Random(n);
+  Matrix<double, 1, 1> y;
+  for (auto _ : state) {
+    y.noalias() = H * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_HankelProductSkinnyRow)->Arg(4096)->Arg(65536)->Arg(1048576);
+
+static void BM_HankelProductSkinnyRowDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec h = Vec::Random(n);
+  Mat dense = Hankel<double>(h.head(1), h.tail(n));
+  Vec x = Vec::Random(n);
+  Matrix<double, 1, 1> y;
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_HankelProductSkinnyRowDense)->Arg(4096)->Arg(65536)->Arg(1048576);
+
+// --- Skinny n x 1: a single axpy of the generating sequence ---
+static void BM_HankelProductSkinnyCol(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec h = Vec::Random(n);  // generating sequence of the n x 1 operator
+  Hankel<double> H(h.head(n), h.tail(1));
+  Matrix<double, 1, 1> x = Matrix<double, 1, 1>::Random();
+  Vec y(n);
+  for (auto _ : state) {
+    y.noalias() = H * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_HankelProductSkinnyCol)->Arg(4096)->Arg(65536)->Arg(1048576);
+
+static void BM_HankelProductSkinnyColDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec h = Vec::Random(n);
+  Mat dense = Hankel<double>(h.head(n), h.tail(1));
+  Matrix<double, 1, 1> x = Matrix<double, 1, 1>::Random();
+  Vec y(n);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_HankelProductSkinnyColDense)->Arg(4096)->Arg(65536)->Arg(1048576);
+
+template <typename Scalar>
+static void BM_HankelTranspose(benchmark::State& state) {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  const Index m = state.range(0), n = state.range(1);
+  const Vector h = Vector::Random(m + n - 1);
+  const Hankel<Scalar> op(h.head(m), h.tail(n));
+  const auto symbol = op.symbol();
+  const auto roundTrip = op.transpose().transpose().symbol();
+  const Real error = (roundTrip - symbol).norm() / symbol.norm();
+  if (!(error <= Real(16) * NumTraits<Real>::epsilon())) {
+    state.SkipWithError("incorrect transpose symbol");
+    return;
+  }
+  state.counters["relative_error"] = double(error);
+  for (auto _ : state) {
+    auto transposed = op.transpose();
+    benchmark::DoNotOptimize(transposed);
+  }
+}
+BENCHMARK_TEMPLATE(BM_HankelTranspose, float)->Args({48, 33})->Args({256, 512})->Args({2048, 1024});
+BENCHMARK_TEMPLATE(BM_HankelTranspose, double)->Args({48, 33})->Args({256, 512})->Args({2048, 1024});
+BENCHMARK_TEMPLATE(BM_HankelTranspose, std::complex<double>)->Args({48, 33})->Args({256, 512})->Args({2048, 1024});
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_kronecker.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_kronecker.cpp
new file mode 100644
index 0000000..ca9590a
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_kronecker.cpp
@@ -0,0 +1,355 @@
+// Benchmarks for the implicit Kronecker operator: applying and solving with
+// A (x) B through the vec identity (A (x) B) vec(X) = vec(B X A^T) [Van Loan
+// 2000] against materializing the dense Kronecker product. With n x n factors
+// the implicit product costs O(n^3) and touches O(n^2) memory, while the dense
+// operator costs O(n^4) to apply (plus O(n^4) to form and store); the direct
+// solve factors two n x n matrices instead of one n^2 x n^2 matrix.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <Eigen/LU>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+typedef DiagonalMatrix<double, Dynamic> Diag;
+
+// --- Matrix-vector product y = (A (x) B) * x, n x n factors ---
+static void BM_KroneckerProductImplicit(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n), B = Mat::Random(n, n);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductImplicit)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+static void BM_KroneckerProductDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n), B = Mat::Random(n, n);
+  Mat dense = KroneckerOperator<Mat, Mat>(A, B);  // materialized once, outside the loop
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductDense)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+// Forming the dense Kronecker product: the up-front cost (and O(n^4) storage)
+// the implicit operator avoids entirely.
+static void BM_KroneckerMaterializeDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n), B = Mat::Random(n, n);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense(n * n, n * n);
+  for (auto _ : state) {
+    dense = K;
+    benchmark::DoNotOptimize(dense.data());
+  }
+}
+BENCHMARK(BM_KroneckerMaterializeDense)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+// --- Multiple right-hand sides ---
+// Both the product and the direct solve walk the right-hand side column by
+// column through the vec identity, so these cover the path where the per-column
+// vec-trick workspaces are reused instead of reallocated.
+static void BM_KroneckerProductImplicitMultiRhs(benchmark::State& state) {
+  const Index n = state.range(0), nrhs = state.range(1);
+  Mat A = Mat::Random(n, n), B = Mat::Random(n, n);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat X = Mat::Random(n * n, nrhs), Y(n * n, nrhs);
+  for (auto _ : state) {
+    Y.noalias() = K * X;
+    benchmark::DoNotOptimize(Y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductImplicitMultiRhs)->ArgsProduct({{8, 16, 32}, {8, 64}});
+
+static void BM_KroneckerSolveImplicitMultiRhs(benchmark::State& state) {
+  const Index n = state.range(0), nrhs = state.range(1);
+  Mat A = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  Mat B = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat rhs = Mat::Random(n * n, nrhs), X(n * n, nrhs);
+  for (auto _ : state) {
+    X = K.solve(rhs);
+    benchmark::DoNotOptimize(X.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveImplicitMultiRhs)->ArgsProduct({{8, 16, 32}, {8, 64}});
+
+// --- Identity and diagonal factors ---
+// The I (x) A and A (x) I operators of finite-difference discretizations. With
+// the identity stored as a dense factor the vec trick still pays a full GEMM
+// for the identity side; stored as a DiagonalMatrix (unit diagonal) that side
+// degenerates to a diagonal scaling, leaving one GEMM of the other factor.
+static void BM_KroneckerProductIdentityLeftDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n), Id = Mat::Identity(n, n);
+  KroneckerOperator<Mat, Mat> K(Id, A);  // I_n (x) A, identity as a dense factor
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityLeftDense)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+static void BM_KroneckerProductIdentityLeftDiag(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n);
+  KroneckerOperator<Diag, Mat> K(Vec::Ones(n).asDiagonal(), A);  // I_n (x) A, diagonal identity
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityLeftDiag)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+static void BM_KroneckerProductIdentityRightDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n), Id = Mat::Identity(n, n);
+  KroneckerOperator<Mat, Mat> K(A, Id);  // A (x) I_n, identity as a dense factor
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityRightDense)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+static void BM_KroneckerProductIdentityRightDiag(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n);
+  KroneckerOperator<Mat, Diag> K(A, Vec::Ones(n).asDiagonal());  // A (x) I_n, diagonal identity
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityRightDiag)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
+
+// Solving (D (x) B) x = b: a densely stored diagonal factor costs a full LU
+// per solve call; the DiagonalMatrix factor is normalized once and divided
+// entrywise, leaving the single LU of the dense factor.
+static void BM_KroneckerSolveDiagFactorDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec d = Vec::Random(n) + Vec::Constant(n, 2.0);
+  Mat Dd = d.asDiagonal();
+  Mat B = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  KroneckerOperator<Mat, Mat> K(Dd, B);
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    x = K.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveDiagFactorDense)->Arg(8)->Arg(16)->Arg(32);
+
+static void BM_KroneckerSolveDiagFactorDiag(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec d = Vec::Random(n) + Vec::Constant(n, 2.0);
+  Mat B = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  KroneckerOperator<Diag, Mat> K(d.asDiagonal(), B);
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    x = K.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveDiagFactorDiag)->Arg(8)->Arg(16)->Arg(32);
+
+// --- Direct solve (A (x) B) x = b, n x n invertible factors ---
+// The dense product is materialized once outside the timed loop. Each iteration
+// then factorizes two n x n matrices for the implicit operator, versus one
+// n^2 x n^2 matrix for the dense baseline.
+static void BM_KroneckerSolveImplicit(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  Mat B = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    x = K.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveImplicit)->Arg(8)->Arg(16)->Arg(32);
+
+static void BM_KroneckerSolveDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Mat A = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  Mat B = Mat::Random(n, n) + 2.0 * double(n) * Mat::Identity(n, n);
+  Mat dense = KroneckerOperator<Mat, Mat>(A, B);  // materialized once, outside the loop
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    x = dense.partialPivLu().solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveDense)->Arg(8)->Arg(16)->Arg(32);
+
+// ---- Sparse factors -----------------------------------------------------------
+// I_n (x) A and A (x) I_n for a tridiagonal sparse A of order n: the
+// sparse-factor operator against the materialized sparse Kronecker product, for
+// the matrix-vector product and the one-shot direct solve (SparseLU per call).
+
+using SpMat = SparseMatrix<double>;
+
+static SpMat tridiagonal(Index n) {
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 3));
+  for (Index j = 0; j < n; ++j) {
+    if (j > 0) A.insert(j - 1, j) = -1.0;
+    A.insert(j, j) = 2.0;
+    if (j + 1 < n) A.insert(j + 1, j) = -1.0;
+  }
+  A.makeCompressed();
+  return A;
+}
+
+static void BM_KroneckerProductIdentityLeftSparse(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  auto K = makeKroneckerOperator(Vec::Ones(n).asDiagonal(), A);
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityLeftSparse)->Arg(64)->Arg(128)->Arg(256)->Arg(512);
+
+static void BM_KroneckerProductIdentityLeftSparseMaterialized(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  SpMat K;
+  K = makeKroneckerOperator(Vec::Ones(n).asDiagonal(), A);  // materialized once, outside the loop
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityLeftSparseMaterialized)->Arg(64)->Arg(128)->Arg(256)->Arg(512);
+
+static void BM_KroneckerProductIdentityRightSparse(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  auto K = makeKroneckerOperator(A, Vec::Ones(n).asDiagonal());
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityRightSparse)->Arg(64)->Arg(128)->Arg(256)->Arg(512);
+
+static void BM_KroneckerProductIdentityRightSparseMaterialized(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  SpMat K;
+  K = makeKroneckerOperator(A, Vec::Ones(n).asDiagonal());
+  Vec x = Vec::Random(n * n), y(n * n);
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductIdentityRightSparseMaterialized)->Arg(64)->Arg(128)->Arg(256)->Arg(512);
+
+static void BM_KroneckerMaterializeSparse(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  auto K = makeKroneckerOperator(Vec::Ones(n).asDiagonal(), A);
+  SpMat M;
+  for (auto _ : state) {
+    M = K;
+    benchmark::DoNotOptimize(M.valuePtr());
+  }
+}
+BENCHMARK(BM_KroneckerMaterializeSparse)->Arg(64)->Arg(128)->Arg(256)->Arg(512);
+
+static void BM_KroneckerSolveIdentityLeftSparse(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  auto K = makeKroneckerOperator(Vec::Ones(n).asDiagonal(), A);
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    x = K.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveIdentityLeftSparse)->Arg(64)->Arg(128)->Arg(256);
+
+static void BM_KroneckerSolveIdentityLeftSparseMaterialized(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  SpMat K;
+  K = makeKroneckerOperator(Vec::Ones(n).asDiagonal(), A);
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    SparseLU<SpMat> lu(K);
+    x = lu.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveIdentityLeftSparseMaterialized)->Arg(64)->Arg(128)->Arg(256);
+
+static void BM_KroneckerSolveIdentityRightSparse(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  auto K = makeKroneckerOperator(A, Vec::Ones(n).asDiagonal());
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    x = K.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveIdentityRightSparse)->Arg(64)->Arg(128)->Arg(256);
+
+static void BM_KroneckerSolveIdentityRightSparseMaterialized(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A = tridiagonal(n);
+  SpMat K;
+  K = makeKroneckerOperator(A, Vec::Ones(n).asDiagonal());
+  Vec b = Vec::Random(n * n), x(n * n);
+  for (auto _ : state) {
+    SparseLU<SpMat> lu(K);
+    x = lu.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_KroneckerSolveIdentityRightSparseMaterialized)->Arg(64)->Arg(128)->Arg(256);
+
+static void BM_KroneckerProductNonFiniteSparse(benchmark::State& state) {
+  const Index n = state.range(0);
+  SpMat A(n, n);
+  for (Index i = 1; i < n; ++i) A.insert(i, i) = 2.0;
+  Mat B = Mat::Identity(2, 2);
+  B(0, 0) = NumTraits<double>::infinity();
+  auto K = makeKroneckerOperator(B, A);
+  Vec x = Vec::Ones(2 * n), y = K * x;
+  Vec expected = Vec::Constant(2 * n, 2.0);
+  expected.head(n).setConstant(NumTraits<double>::infinity());
+  expected[0] = expected[n] = 0.0;  // The empty sparse row annihilates Inf.
+  if (!(y.array() == expected.array()).all()) {
+    state.SkipWithError("non-finite product did not preserve structural zeros");
+    return;
+  }
+  for (auto _ : state) {
+    y.noalias() = K * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_KroneckerProductNonFiniteSparse)->Arg(64)->Arg(128)->Arg(256)->Arg(512);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_kronecker_spectral.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_kronecker_spectral.cpp
new file mode 100644
index 0000000..66d5521
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_kronecker_spectral.cpp
@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+template <typename Scalar>
+void BM_KroneckerLeastSquaresMultiRhs(benchmark::State& state) {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  const Index n = state.range(0), nrhs = state.range(1);
+  Mat a = Mat::Random(n + 1, n), b = Mat::Random(n, n);
+  a.topRows(n).diagonal().array() += Real(2 * n);
+  b.diagonal().array() += Real(2 * n);
+  const auto op = makeKroneckerOperator(a, b);
+  const Mat expected = Mat::Random(n * n, nrhs);
+  const Mat rhs = op * expected;
+  Mat x = op.leastSquaresSolve(rhs);
+  const Real error = (x - expected).norm() / expected.norm();
+  if (!(error <= Real(100 * n) * NumTraits<Real>::epsilon())) {
+    state.SkipWithError("incorrect least-squares solution");
+    return;
+  }
+  state.counters["relative_error"] = double(error);
+  for (auto _ : state) {
+    x = op.leastSquaresSolve(rhs);
+    benchmark::DoNotOptimize(x.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK_TEMPLATE(BM_KroneckerLeastSquaresMultiRhs, double)->ArgsProduct({{8, 16, 32}, {1, 8, 64}});
+BENCHMARK_TEMPLATE(BM_KroneckerLeastSquaresMultiRhs, std::complex<double>)->ArgsProduct({{8, 16}, {1, 8, 64}});
+
+template <typename Scalar>
+void BM_KroneckerRank(benchmark::State& state) {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  const Index n = state.range(0);
+  Mat a = Mat::Random(n, n), b = Mat::Random(n, n);
+  a.diagonal().array() += Real(2 * n);
+  b.diagonal().array() += Real(2 * n);
+  const auto op = makeKroneckerOperator(a, b);
+  if (op.rank() != n * n) {
+    state.SkipWithError("incorrect rank");
+    return;
+  }
+  for (auto _ : state) benchmark::DoNotOptimize(op.rank());
+}
+BENCHMARK_TEMPLATE(BM_KroneckerRank, double)->Arg(8)->Arg(16)->Arg(32);
+BENCHMARK_TEMPLATE(BM_KroneckerRank, std::complex<double>)->Arg(8)->Arg(16);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_levinson.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_levinson.cpp
new file mode 100644
index 0000000..6a15e07
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_levinson.cpp
@@ -0,0 +1,89 @@
+// Benchmarks for the LookAheadLevinson direct Toeplitz solver: factorization and
+// cached solves on well-conditioned systems, the look-ahead path on a shifted
+// KMS family whose leading submatrices are singular (forcing block steps), and
+// the dense LU alternative.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Dense>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+// Diagonally dominant generators: the classical Levinson recursion runs with no
+// look-ahead blocks.
+static void wellConditionedToeplitz(Index n, Vec& c, Vec& r) {
+  c = Vec::Random(n);
+  r = Vec::Random(n);
+  r[0] = c[0] += 2.0 * double(n);
+}
+
+// Shifted Kac-Murdock-Szego family: leading submatrices T_k with k = 1, 4, 7,
+// ... are singular, so every third step is a look-ahead block (n must be a
+// multiple of 3 for T_n itself to be non-singular).
+static void shiftedKmsToeplitz(Index n, Vec& c, Vec& r) {
+  c.resize(n);
+  r.resize(n);
+  c[0] = r[0] = 1e-14;
+  for (Index i = 1; i < n; ++i) c[i] = r[i] = std::pow(0.5, double(i - 1));
+}
+
+// --- Factorization ---
+static void BM_LevinsonCompute(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c, r;
+  wellConditionedToeplitz(n, c, r);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    LookAheadLevinson<double> lev(T);
+    benchmark::DoNotOptimize(lev);
+  }
+}
+BENCHMARK(BM_LevinsonCompute)->Arg(32)->Arg(256)->Arg(1024);
+
+// --- Solve from a cached factorization ---
+static void BM_LevinsonSolve(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c, r;
+  wellConditionedToeplitz(n, c, r);
+  Toeplitz<double> T(c, r);
+  LookAheadLevinson<double> lev(T);
+  Vec b = Vec::Random(n);
+  for (auto _ : state) {
+    Vec x = lev.solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_LevinsonSolve)->Arg(32)->Arg(256)->Arg(1024);
+
+// --- Look-ahead path: factorization dominated by block steps ---
+static void BM_LevinsonComputeLookAhead(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c, r;
+  shiftedKmsToeplitz(n, c, r);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    LookAheadLevinson<double> lev;
+    lev.setMaxBlockSize(3).compute(T);
+    benchmark::DoNotOptimize(lev);
+  }
+}
+BENCHMARK(BM_LevinsonComputeLookAhead)->Arg(30)->Arg(240)->Arg(1023);
+
+// --- Dense alternative: LU factorization + solve on every call ---
+static void BM_LevinsonSolveDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c, r;
+  wellConditionedToeplitz(n, c, r);
+  Mat dense = Toeplitz<double>(c, r);
+  Vec b = Vec::Random(n);
+  for (auto _ : state) {
+    Vec x = PartialPivLU<Mat>(dense).solve(b);
+    benchmark::DoNotOptimize(x.data());
+  }
+}
+BENCHMARK(BM_LevinsonSolveDense)->Arg(256)->Arg(1024);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_materialize.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_materialize.cpp
new file mode 100644
index 0000000..60d4c0c
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_materialize.cpp
@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+template <int Options, typename Op>
+void materialize(benchmark::State& state, const Op& op) {
+  using Scalar = typename Op::Scalar;
+  Matrix<Scalar, Dynamic, Dynamic, Options> dst(op.rows(), op.cols());
+  dst = op;
+  for (Index j = 0; j < op.cols(); ++j)
+    for (Index i = 0; i < op.rows(); ++i)
+      if (dst(i, j) != op.coeff(i, j)) {
+        state.SkipWithError("incorrect materialization");
+        return;
+      }
+  if (state.range(2) == 0) {
+    for (auto _ : state) {
+      dst = op;
+      benchmark::DoNotOptimize(dst.data());
+      benchmark::ClobberMemory();
+    }
+  } else {
+    for (auto _ : state) {
+      dst += op;
+      dst -= op;
+      benchmark::DoNotOptimize(dst.data());
+      benchmark::ClobberMemory();
+    }
+  }
+}
+
+template <typename Scalar, int Options>
+void BM_CirculantMaterialize(benchmark::State& state) {
+  Matrix<Scalar, Dynamic, 1> c = Matrix<Scalar, Dynamic, 1>::Random(state.range(0));
+  materialize<Options>(state, makeCirculant(c));
+}
+
+template <typename Scalar, int Options>
+void BM_ToeplitzMaterialize(benchmark::State& state) {
+  Matrix<Scalar, Dynamic, 1> c = Matrix<Scalar, Dynamic, 1>::Random(state.range(0));
+  Matrix<Scalar, Dynamic, 1> r = Matrix<Scalar, Dynamic, 1>::Random(state.range(1));
+  materialize<Options>(state, makeToeplitz(c, r));
+}
+
+template <typename Scalar, int Options>
+void BM_HankelMaterialize(benchmark::State& state) {
+  Matrix<Scalar, Dynamic, 1> c = Matrix<Scalar, Dynamic, 1>::Random(state.range(0));
+  Matrix<Scalar, Dynamic, 1> r = Matrix<Scalar, Dynamic, 1>::Random(state.range(1));
+  materialize<Options>(state, makeHankel(c, r));
+}
+
+#define STRUCTURED_MATERIALIZE_CASES(Name, Scalar, Options, Wide) \
+  BENCHMARK_TEMPLATE(Name, Scalar, Options)                       \
+      ->Args({32, 32, 0})                                         \
+      ->Args({256, 256, 0})                                       \
+      ->Args({127, Wide, 0})                                      \
+      ->Args({256, 256, 1})
+#define STRUCTURED_MATERIALIZE_TYPES(Name, Wide)                            \
+  STRUCTURED_MATERIALIZE_CASES(Name, double, ColMajor, Wide);               \
+  STRUCTURED_MATERIALIZE_CASES(Name, double, RowMajor, Wide);               \
+  STRUCTURED_MATERIALIZE_CASES(Name, std::complex<double>, ColMajor, Wide); \
+  STRUCTURED_MATERIALIZE_CASES(Name, std::complex<double>, RowMajor, Wide)
+
+STRUCTURED_MATERIALIZE_TYPES(BM_CirculantMaterialize, 127);
+STRUCTURED_MATERIALIZE_TYPES(BM_ToeplitzMaterialize, 257);
+STRUCTURED_MATERIALIZE_TYPES(BM_HankelMaterialize, 257);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_toeplitz.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_toeplitz.cpp
new file mode 100644
index 0000000..bc39bef
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_toeplitz.cpp
@@ -0,0 +1,98 @@
+// Benchmarks for the Toeplitz operator's products across its dispatch tiers and
+// shapes (square, tall, wide; 5-smooth and prime embedding sizes) against the
+// dense product, plus the one-time circulant-embedding construction.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Dense>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+typedef Matrix<std::complex<double>, Dynamic, 1> CVec;
+
+// --- Construction: the one-time embedding symbol FFT ---
+// 97 exercises the 5-smooth padding of the embedding (2*97-1 = 193 is prime).
+static void BM_ToeplitzConstruct(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  for (auto _ : state) {
+    Toeplitz<double> T(c, r);
+    benchmark::DoNotOptimize(T);
+  }
+}
+BENCHMARK(BM_ToeplitzConstruct)->Arg(96)->Arg(97)->Arg(1024)->Arg(4096);
+
+// --- Square product y = T * x across the dispatch tiers ---
+// 8: scalar loop; 32: segment tier boundary; larger: FFT via the embedding.
+static void BM_ToeplitzProduct(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), r = Vec::Random(n), x = Vec::Random(n), y(n);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    y.noalias() = T * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_ToeplitzProduct)->Arg(8)->Arg(32)->Arg(96)->Arg(1024)->Arg(4096);
+
+static void BM_ToeplitzProductDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), r = Vec::Random(n), x = Vec::Random(n), y(n);
+  Mat dense = Toeplitz<double>(c, r);
+  for (auto _ : state) {
+    y.noalias() = dense * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_ToeplitzProductDense)->Arg(96)->Arg(1024)->Arg(4096);
+
+// --- Rectangular products: tall (2n x n) and wide (n x 2n) ---
+static void BM_ToeplitzProductTall(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(2 * n), r = Vec::Random(n), x = Vec::Random(n), y(2 * n);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    y.noalias() = T * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_ToeplitzProductTall)->Arg(96)->Arg(1024)->Arg(4096);
+
+static void BM_ToeplitzProductWide(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), r = Vec::Random(2 * n), x = Vec::Random(2 * n), y(n);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    y.noalias() = T * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_ToeplitzProductWide)->Arg(96)->Arg(1024)->Arg(4096);
+
+static void BM_ToeplitzProductComplex(benchmark::State& state) {
+  const Index n = state.range(0);
+  CVec c = CVec::Random(n), r = CVec::Random(n), x = CVec::Random(n), y(n);
+  Toeplitz<std::complex<double>> T(c, r);
+  for (auto _ : state) {
+    y.noalias() = T * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_ToeplitzProductComplex)->Arg(96)->Arg(4096);
+
+// Multi-column right-hand sides: one FFT round trip per column.
+static void BM_ToeplitzProductMultiRhs(benchmark::State& state) {
+  const Index n = state.range(0), k = state.range(1);
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  Mat X = Mat::Random(n, k), Y(n, k);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    Y.noalias() = T * X;
+    benchmark::DoNotOptimize(Y.data());
+  }
+}
+BENCHMARK(BM_ToeplitzProductMultiRhs)->ArgsProduct({{96, 4096}, {8}});
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_transpose.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_transpose.cpp
new file mode 100644
index 0000000..069659b
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_transpose.cpp
@@ -0,0 +1,98 @@
+// Benchmarks for the structured operators' transposition family: transpose(),
+// conjugate() and adjoint() reuse the operator's cached DFT symbol (an O(n)
+// permutation / conjugation) instead of recomputing an FFT. The *Recomputed
+// variants build the same operator through the public constructor, which pays
+// the FFT, to quantify the reuse.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+
+// The generating column of C^T: the index-reversed column of C (what transpose()
+// computes internally before attaching the reused symbol).
+static Vec reversedGenerator(const Vec& c) {
+  const Index n = c.size();
+  Vec rev(n);
+  rev[0] = c[0];
+  if (n > 1) rev.tail(n - 1) = c.tail(n - 1).reverse();
+  return rev;
+}
+
+// --- Circulant transpose: construction only ---
+static void BM_CirculantTransposeCached(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n);
+  Circulant<double> C(c);
+  for (auto _ : state) {
+    Circulant<double> Ct = C.transpose();  // symbol reuse: no FFT
+    benchmark::DoNotOptimize(Ct);
+  }
+}
+BENCHMARK(BM_CirculantTransposeCached)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+static void BM_CirculantTransposeRecomputed(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n);
+  Vec rev = reversedGenerator(c);
+  for (auto _ : state) {
+    Circulant<double> Ct(rev);  // public constructor: recomputes the symbol by FFT
+    benchmark::DoNotOptimize(Ct);
+  }
+}
+BENCHMARK(BM_CirculantTransposeRecomputed)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+// --- Circulant transpose: end-to-end transposed product y = C^T * x ---
+static void BM_CirculantTransposeProductCached(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), x = Vec::Random(n), y(n);
+  Circulant<double> C(c);
+  for (auto _ : state) {
+    y.noalias() = C.transpose() * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_CirculantTransposeProductCached)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+static void BM_CirculantTransposeProductRecomputed(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), x = Vec::Random(n), y(n);
+  Vec rev = reversedGenerator(c);
+  for (auto _ : state) {
+    Circulant<double> Ct(rev);
+    y.noalias() = Ct * x;
+    benchmark::DoNotOptimize(y.data());
+  }
+}
+BENCHMARK(BM_CirculantTransposeProductRecomputed)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+// --- Toeplitz adjoint: construction only ---
+static void BM_ToeplitzAdjointCached(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  Toeplitz<double> T(c, r);
+  for (auto _ : state) {
+    Toeplitz<double> Ta = T.adjoint();  // symbol reuse: no FFT
+    benchmark::DoNotOptimize(Ta);
+  }
+}
+BENCHMARK(BM_ToeplitzAdjointCached)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
+
+static void BM_ToeplitzAdjointRecomputed(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  // The adjoint's generators (real scalars, so conjugation is the identity).
+  Vec ca(n);
+  ca[0] = c[0];
+  if (n > 1) ca.tail(n - 1) = r.tail(n - 1);
+  for (auto _ : state) {
+    Toeplitz<double> Ta(ca, c);  // public constructor: recomputes the embedding symbol
+    benchmark::DoNotOptimize(Ta);
+  }
+}
+BENCHMARK(BM_ToeplitzAdjointRecomputed)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384);
diff --git a/contrib/benchmarks/StructuredMatrices/bench_structured_vandermonde.cpp b/contrib/benchmarks/StructuredMatrices/bench_structured_vandermonde.cpp
new file mode 100644
index 0000000..2704ae6
--- /dev/null
+++ b/contrib/benchmarks/StructuredMatrices/bench_structured_vandermonde.cpp
@@ -0,0 +1,148 @@
+// Benchmarks for the Vandermonde operator: the O(mn)-flops / O(m)-storage
+// Horner product against the equivalent dense GEMV on the materialized matrix
+// (comparable O(mn) arithmetic, O(mn) storage), and the O(n^2)
+// Björck-Pereyra square solve against a dense PartialPivLU factor-and-solve
+// (O(n^3)). These cases cover nominal real-input performance. Both solve
+// variants time the full pipeline from the stored representation to the
+// solution; the dense one is additionally handed the materialized matrix for
+// free (built outside the loop).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <Eigen/Core>
+#include <Eigen/LU>
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+typedef Matrix<double, Dynamic, 1> Vec;
+typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+// Chebyshev nodes in (-1, 1): deterministic, bounded, and distinct (no
+// Björck-Pereyra division by zero or exact-zero LU pivot).
+static Vec chebyshevNodes(Index n) {
+  Vec x(n);
+  for (Index i = 0; i < n; ++i) x[i] = std::cos(EIGEN_PI * double(2 * i + 1) / double(2 * n));
+  return x;
+}
+
+static Vec polynomialCoefficients(Index n) {
+  Vec a(n);
+  for (Index i = 0; i < n; ++i) a[i] = std::cos(0.25 * double(i + 1)) / double(i + 1);
+  return a;
+}
+
+// Long-double Horner reference used only before timing. The dimension-scaled
+// bound accounts for at most n multiply-adds in each polynomial evaluation.
+static bool validateProduct(benchmark::State& state, const Vec& x, const Vec& a, const Vec& actual) {
+  Vec expected(x.size());
+  for (Index i = 0; i < x.size(); ++i) {
+    long double acc = static_cast<long double>(a[a.size() - 1]);
+    for (Index j = a.size() - 2; j >= 0; --j)
+      acc = acc * static_cast<long double>(x[i]) + static_cast<long double>(a[j]);
+    expected[i] = static_cast<double>(acc);
+  }
+  const double tol = 64.0 * double(a.size()) * NumTraits<double>::epsilon();
+  if (!actual.allFinite() || (actual - expected).norm() > tol * numext::maxi(1.0, expected.norm())) {
+    state.SkipWithError("Vandermonde product failed validation");
+    return false;
+  }
+  return true;
+}
+
+// The large Chebyshev-node systems are extremely ill-conditioned, so a random
+// right-hand side has no meaningful double-precision monomial solution. The
+// exact constant polynomial f_i=1 gives both algorithms the finite,
+// independently known solution a=e_0 and keeps this a reproducible nominal-path
+// benchmark. Validate the solution once before entering either timed loop.
+static bool validateConstantSolve(benchmark::State& state, const Vec& actual) {
+  Vec expected = Vec::Zero(actual.size());
+  expected[0] = 1.0;
+  const double tol = 64.0 * double(actual.size()) * NumTraits<double>::epsilon();
+  if (!actual.allFinite() || (actual - expected).norm() > tol) {
+    state.SkipWithError("Vandermonde solve failed validation");
+    return false;
+  }
+  return true;
+}
+
+// --- Product y = V * a: Horner rule on the nodes ---
+static void BM_VandermondeProduct(benchmark::State& state) {
+  const Index m = state.range(0), n = state.range(1);
+  Vec x = chebyshevNodes(m), a = polynomialCoefficients(n), y(m);
+  Vandermonde<double> V(x, n);
+  Vec check = V * a;
+  if (!validateProduct(state, x, a, check)) return;
+  for (auto _ : state) {
+    y.noalias() = V * a;
+    benchmark::DoNotOptimize(y.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_VandermondeProduct)
+    ->Args({64, 64})
+    ->Args({256, 256})
+    ->Args({1024, 1024})
+    ->Args({4096, 4096})
+    ->Args({4096, 256})
+    ->Args({256, 4096})
+    ->ArgNames({"m", "n"});
+
+// --- Product y = dense * a: GEMV on the pre-materialized matrix ---
+static void BM_VandermondeProductDense(benchmark::State& state) {
+  const Index m = state.range(0), n = state.range(1);
+  Vec x = chebyshevNodes(m), a = polynomialCoefficients(n), y(m);
+  Vandermonde<double> V(x, n);
+  Mat dense = V;  // materialized once, outside the timed loop
+  Vec check = dense * a;
+  if (!validateProduct(state, x, a, check)) return;
+  for (auto _ : state) {
+    y.noalias() = dense * a;
+    benchmark::DoNotOptimize(y.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_VandermondeProductDense)
+    ->Args({64, 64})
+    ->Args({256, 256})
+    ->Args({1024, 1024})
+    ->Args({4096, 4096})
+    ->Args({4096, 256})
+    ->Args({256, 4096})
+    ->ArgNames({"m", "n"});
+
+// --- Square solve V * a = f: Björck-Pereyra divided-difference recurrences ---
+static void BM_BjorckPereyraSolve(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec x = chebyshevNodes(n), f = Vec::Ones(n), a(n);
+  Vandermonde<double> V(x);
+  BjorckPereyra<double> bpCheck(V);
+  Vec check = bpCheck.solve(f);
+  if (!validateConstantSolve(state, check)) return;
+  for (auto _ : state) {
+    BjorckPereyra<double> bp(V);  // compute() includes the O(n^2) duplicate scan
+    a = bp.solve(f);
+    benchmark::DoNotOptimize(a.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_BjorckPereyraSolve)->Arg(16)->Arg(64)->Arg(256)->Arg(1024);
+
+// --- Square solve dense * a = f: PartialPivLU on the pre-materialized matrix ---
+static void BM_VandermondeSolveDense(benchmark::State& state) {
+  const Index n = state.range(0);
+  Vec x = chebyshevNodes(n), f = Vec::Ones(n), a(n);
+  Vandermonde<double> V(x);
+  Mat dense = V;  // materialized once, outside the timed loop
+  PartialPivLU<Mat> luCheck(dense);
+  Vec check = luCheck.solve(f);
+  if (!validateConstantSolve(state, check)) return;
+  for (auto _ : state) {
+    PartialPivLU<Mat> lu(dense);  // the O(n^3) elimination
+    a = lu.solve(f);
+    benchmark::DoNotOptimize(a.data());
+    benchmark::ClobberMemory();
+  }
+}
+BENCHMARK(BM_VandermondeSolveDense)->Arg(16)->Arg(64)->Arg(256)->Arg(1024);
diff --git a/contrib/benchmarks/Tensor/CMakeLists.txt b/contrib/benchmarks/Tensor/CMakeLists.txt
new file mode 100644
index 0000000..f3d3262
--- /dev/null
+++ b/contrib/benchmarks/Tensor/CMakeLists.txt
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+eigen_add_benchmark(bench_contraction bench_contraction.cpp)
+eigen_add_benchmark(bench_convolution bench_convolution.cpp)
+eigen_add_benchmark(bench_reduction bench_reduction.cpp)
+eigen_add_benchmark(bench_broadcasting bench_broadcasting.cpp)
+eigen_add_benchmark(bench_shuffling bench_shuffling.cpp)
+eigen_add_benchmark(bench_block_view bench_block_view.cpp)
+eigen_add_benchmark(bench_block_view_compositions bench_block_view_compositions.cpp)
+eigen_add_benchmark(bench_tensor_fft bench_tensor_fft.cpp)
+eigen_add_benchmark(bench_morphing bench_morphing.cpp)
+eigen_add_benchmark(bench_coefficient_wise bench_coefficient_wise.cpp)
+eigen_add_benchmark(bench_image_patch bench_image_patch.cpp)
+eigen_add_benchmark(bench_patch bench_patch.cpp)
+eigen_add_benchmark(bench_reverse bench_reverse.cpp)
+eigen_add_benchmark(bench_roll bench_roll.cpp)
+eigen_add_benchmark(bench_layout_swap bench_layout_swap.cpp)
+eigen_add_benchmark(bench_inflation bench_inflation.cpp)
+eigen_add_benchmark(bench_chained_expressions bench_chained_expressions.cpp)
+eigen_add_benchmark(bench_threadpool_device bench_threadpool_device.cpp)
+eigen_add_benchmark(bench_concatenation bench_concatenation.cpp)
+eigen_add_benchmark(bench_custom_op bench_custom_op.cpp)
+eigen_add_benchmark(bench_striding bench_striding.cpp)
diff --git a/contrib/benchmarks/Tensor/bench_block_view.cpp b/contrib/benchmarks/Tensor/bench_block_view.cpp
new file mode 100644
index 0000000..06469b0
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_block_view.cpp
@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Index;
+using Eigen::internal::TiledEvaluation;
+
+template <typename Scalar, int Layout, bool Shuffle>
+static void BM_BlockView(benchmark::State& state) {
+  const Index n = state.range(0);
+  const bool tiled = state.range(1) != 0;
+  using Tensor = Eigen::Tensor<Scalar, 2, Layout>;
+  Tensor input(n, n), bias(n, n), output(n, n);
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = 0; i < n; ++i) {
+      input(i, j) = Scalar((i * 17 + j * 31) % 1024) * Scalar(0.25);
+      bias(i, j) = Scalar((i * 7 + j * 11) % 256) * Scalar(0.125);
+    }
+  }
+  auto measure = [&](const auto& expression) {
+    using Expression = Eigen::internal::remove_all_t<decltype(expression)>;
+    using Assign = Eigen::TensorAssignOp<Tensor, const Expression>;
+    using Device = Eigen::DefaultDevice;
+    constexpr bool Vectorizable = Eigen::internal::IsVectorizable<Device, const Assign>::value;
+    using Tiled = Eigen::internal::TensorExecutor<const Assign, Device, Vectorizable, TiledEvaluation::On>;
+    using Untiled = Eigen::internal::TensorExecutor<const Assign, Device, Vectorizable, TiledEvaluation::Off>;
+    const Assign assign(output, expression);
+    if (tiled) {
+      Tiled::run(assign);
+    } else {
+      Untiled::run(assign);
+    }
+    for (Index j = 0; j < n; ++j) {
+      for (Index i = 0; i < n; ++i) {
+        const Scalar expected = (Shuffle ? input(j, i) : input(i, j)) + bias(i, j);
+        if (output(i, j) != expected) {
+          state.SkipWithError("incorrect block result");
+          return;
+        }
+      }
+    }
+    if (tiled) {
+      for (auto unused : state) {
+        Tiled::run(assign);
+        benchmark::DoNotOptimize(output.data());
+        benchmark::ClobberMemory();
+      }
+    } else {
+      for (auto unused : state) {
+        Untiled::run(assign);
+        benchmark::DoNotOptimize(output.data());
+        benchmark::ClobberMemory();
+      }
+    }
+  };
+  EIGEN_IF_CONSTEXPR (Shuffle) {
+    const Eigen::array<int, 2> transpose{{1, 0}};
+    measure(input.shuffle(transpose) + bias);
+  } else {
+    // Identity broadcasting selects contiguous blocks for the control case.
+    const Eigen::array<Index, 2> broadcast{{1, 1}};
+    measure(input.broadcast(broadcast) + bias);
+  }
+  state.SetItemsProcessed(state.iterations() * n * n);
+}
+
+#define REGISTER_BLOCK_VIEW(Scalar, Layout, Shuffle)        \
+  BENCHMARK_TEMPLATE(BM_BlockView, Scalar, Layout, Shuffle) \
+      ->ArgsProduct({{64, 96, 112, 128, 192, 256, 257, 384, 512, 1024}, {0, 1}})
+
+REGISTER_BLOCK_VIEW(float, Eigen::ColMajor, true);
+REGISTER_BLOCK_VIEW(float, Eigen::RowMajor, true);
+REGISTER_BLOCK_VIEW(double, Eigen::ColMajor, true);
+REGISTER_BLOCK_VIEW(double, Eigen::RowMajor, true);
+REGISTER_BLOCK_VIEW(float, Eigen::ColMajor, false);
+REGISTER_BLOCK_VIEW(float, Eigen::RowMajor, false);
+
+#undef REGISTER_BLOCK_VIEW
diff --git a/contrib/benchmarks/Tensor/bench_block_view_compositions.cpp b/contrib/benchmarks/Tensor/bench_block_view_compositions.cpp
new file mode 100644
index 0000000..6100a67
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_block_view_compositions.cpp
@@ -0,0 +1,140 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Index;
+
+enum BlockViewComposition {
+  ShuffleAdd,
+  ShuffleAffine,
+  ShuffleSelect,
+  SwapAffine,
+  CropBroadcast,
+  BroadcastAffine,
+  BroadcastBelow
+};
+
+static const char* composition_name(int composition) {
+  static const char* names[] = {"shuffle_add",    "shuffle_affine",   "shuffle_select", "swap_affine",
+                                "crop_broadcast", "broadcast_affine", "broadcast_below"};
+  return names[composition];
+}
+
+template <typename Scalar, int Layout, typename Measure>
+static void block_view_composition(Index rows, Index cols, int composition, const Measure& measure) {
+  using Tensor = Eigen::Tensor<Scalar, 2, Layout>;
+  const bool shuffled = composition <= SwapAffine;
+  Tensor input(shuffled ? cols : rows, shuffled ? rows : cols), b(rows, cols), c(rows, cols), d(rows, cols);
+  Tensor tile(rows / 2, cols / 2), tile_b(rows / 2, cols / 2), tile_c(rows / 2, cols / 2);
+  Eigen::Tensor<bool, 2, Layout> mask(rows, cols);
+  const auto fill = [](auto& tensor, Index multiplier) {
+    for (Index j = 0; j < tensor.dimension(1); ++j)
+      for (Index i = 0; i < tensor.dimension(0); ++i) tensor(i, j) = Scalar((i * multiplier + j * 7) % 23) - Scalar(11);
+  };
+  fill(input, 3);
+  fill(b, 5);
+  fill(c, 7);
+  fill(d, 11);
+  fill(tile, 3);
+  fill(tile_b, 5);
+  fill(tile_c, 7);
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) mask(i, j) = (i + j) % 3 != 0;
+
+  const Eigen::array<int, 2> transpose{{1, 0}};
+  const Eigen::array<Index, 2> repeats{{2, 2}}, offsets{{rows / 4, cols / 4}}, sizes{{rows / 2, cols / 2}};
+  Tensor output(rows, cols);
+  switch (composition) {
+    case ShuffleAdd:
+      measure(output, input.shuffle(transpose) + b, [&](Index i, Index j) { return input(j, i) + b(i, j); });
+      break;
+    case ShuffleAffine:
+      measure(output, ((input.shuffle(transpose) + b) * c + d).cwiseMax(Scalar(0)), [&](Index i, Index j) {
+        return Eigen::numext::maxi(Scalar(0), (input(j, i) + b(i, j)) * c(i, j) + d(i, j));
+      });
+      break;
+    case ShuffleSelect:
+      measure(output, mask.select(input.shuffle(transpose) + b * c, d),
+              [&](Index i, Index j) { return mask(i, j) ? input(j, i) + b(i, j) * c(i, j) : d(i, j); });
+      break;
+    case SwapAffine: {
+      Eigen::Tensor<Scalar, 2, Layout == Eigen::ColMajor ? Eigen::RowMajor : Eigen::ColMajor> swapped(cols, rows);
+      measure(swapped, (input.shuffle(transpose) + b * c).swap_layout(),
+              [&](Index j, Index i) { return input(j, i) + b(i, j) * c(i, j); });
+      break;
+    }
+    case CropBroadcast:
+      measure(output, (input + b * c).slice(offsets, sizes).broadcast(repeats), [&](Index i, Index j) {
+        const Index row = offsets[0] + i % sizes[0], col = offsets[1] + j % sizes[1];
+        return input(row, col) + b(row, col) * c(row, col);
+      });
+      break;
+    case BroadcastAffine:
+      measure(output, tile.broadcast(repeats) + b * c,
+              [&](Index i, Index j) { return tile(i % sizes[0], j % sizes[1]) + b(i, j) * c(i, j); });
+      break;
+    case BroadcastBelow:
+      measure(output, (tile + tile_b * tile_c).broadcast(repeats), [&](Index i, Index j) {
+        const Index row = i % sizes[0], col = j % sizes[1];
+        return tile(row, col) + tile_b(row, col) * tile_c(row, col);
+      });
+      break;
+  }
+}
+
+template <typename Scalar, int Layout>
+static void BM_BlockViewCompositions(benchmark::State& state) {
+  const Index rows = state.range(0), cols = state.range(1);
+  const int composition = static_cast<int>(state.range(2));
+  const bool public_assignment = state.range(3) != 0;
+  const auto measure = [&](auto& output, const auto& expression, const auto& expected) {
+    using Output = Eigen::internal::remove_all_t<decltype(output)>;
+    using Expression = Eigen::internal::remove_all_t<decltype(expression)>;
+    using Assign = Eigen::TensorAssignOp<Output, const Expression>;
+    using Device = Eigen::DefaultDevice;
+    static_assert(Eigen::internal::IsTileable<Device, const Assign>::value == Eigen::internal::TiledEvaluation::On,
+                  "Composite assignments must select block evaluation");
+    constexpr bool Vectorizable = Eigen::internal::IsVectorizable<Device, const Assign>::value;
+    using Untiled =
+        Eigen::internal::TensorExecutor<const Assign, Device, Vectorizable, Eigen::internal::TiledEvaluation::Off>;
+    const Assign assign(output, expression);
+    const auto evaluate = [&]() {
+      if (public_assignment)
+        output = expression;
+      else
+        Untiled::run(assign);
+    };
+    evaluate();
+    for (Index j = 0; j < output.dimension(1); ++j) {
+      for (Index i = 0; i < output.dimension(0); ++i) {
+        if (output(i, j) != expected(i, j)) {
+          state.SkipWithError("incorrect composite result");
+          return;
+        }
+      }
+    }
+    for (auto unused : state) {
+      evaluate();
+      benchmark::DoNotOptimize(output.data());
+      benchmark::ClobberMemory();
+    }
+  };
+  block_view_composition<Scalar, Layout>(rows, cols, composition, measure);
+  state.SetLabel(composition_name(composition));
+  state.SetItemsProcessed(state.iterations() * rows * cols);
+}
+
+#define COMPOSITION_SHAPE(Rows, Cols) ->ArgsProduct({{Rows}, {Cols}, {0, 1, 2, 3, 4, 5, 6}, {0, 1}})
+#define REGISTER_COMPOSITIONS(Scalar, Layout)                  \
+  BENCHMARK_TEMPLATE(BM_BlockViewCompositions, Scalar, Layout) \
+  COMPOSITION_SHAPE(64, 64) COMPOSITION_SHAPE(256, 256) COMPOSITION_SHAPE(258, 194) COMPOSITION_SHAPE(1024, 1024)
+
+REGISTER_COMPOSITIONS(float, Eigen::ColMajor);
+REGISTER_COMPOSITIONS(float, Eigen::RowMajor);
+REGISTER_COMPOSITIONS(double, Eigen::ColMajor);
+REGISTER_COMPOSITIONS(double, Eigen::RowMajor);
+
+#undef REGISTER_COMPOSITIONS
+#undef COMPOSITION_SHAPE
diff --git a/contrib/benchmarks/Tensor/bench_broadcasting.cpp b/contrib/benchmarks/Tensor/bench_broadcasting.cpp
new file mode 100644
index 0000000..f79258a
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_broadcasting.cpp
@@ -0,0 +1,336 @@
+// Benchmarks for Eigen Tensor broadcasting.
+// Tests broadcasting along various dimensions and ranks.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Broadcast row vector {1,N} -> {M,N} ---
+static void BM_BroadcastRow(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> row(1, N);
+  Tensor<Scalar, 2> result(M, N);
+  row.setRandom();
+
+  Eigen::array<int, 2> bcast = {M, 1};
+
+  for (auto _ : state) {
+    result = row.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Broadcast col vector {M,1} -> {M,N} ---
+static void BM_BroadcastCol(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> col(M, 1);
+  Tensor<Scalar, 2> result(M, N);
+  col.setRandom();
+
+  Eigen::array<int, 2> bcast = {1, N};
+
+  for (auto _ : state) {
+    result = col.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Broadcast + element-wise add (bias addition pattern) ---
+static void BM_BroadcastAdd(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> bias(1, N);
+  Tensor<Scalar, 2> result(M, N);
+  mat.setRandom();
+  bias.setRandom();
+
+  Eigen::array<int, 2> bcast = {M, 1};
+
+  for (auto _ : state) {
+    result = mat + bias.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+}
+
+// --- Broadcast + scalar clamp (bias addition + clamp pattern) ---
+// cwiseMax(Scalar) / cwiseMin(Scalar) build constant() leaves (unlike
+// clip(), which is a single unary functor). Constants used to disable tiled
+// evaluation for the whole expression.
+static void BM_BroadcastClamp(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> bias(1, N);
+  Tensor<Scalar, 2> result(M, N);
+  mat.setRandom();
+  bias.setRandom();
+
+  Eigen::array<int, 2> bcast = {M, 1};
+
+  for (auto _ : state) {
+    result = (mat + bias.broadcast(bcast)).cwiseMax(Scalar(-0.5)).cwiseMin(Scalar(0.5));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  // Validate outside the timed loop.
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      const Scalar expected = std::min(Scalar(0.5), std::max(Scalar(-0.5), mat(i, j) + bias(0, j)));
+      if (result(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+}
+
+// --- Outer-dimension broadcast + clip ---
+// Broadcasting a large plane along the outer-most dimension has a reuse
+// distance of the whole plane: the untiled path streams the plane from
+// memory B times, while tiled evaluation reuses cache-resident pieces
+// across the broadcast factor. The cwiseMax/cwiseMin constants decide
+// which of the two paths runs, so before nullary block support they forced
+// the memory-bound path.
+static void BM_OuterBroadcastClamp(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int B = state.range(2);
+
+  Tensor<Scalar, 3> plane(D0, D1, 1);
+  Tensor<Scalar, 3> result(D0, D1, B);
+  plane.setRandom();
+
+  Eigen::array<int, 3> bcast = {1, 1, B};
+
+  for (auto _ : state) {
+    result = plane.broadcast(bcast).cwiseMax(Scalar(-0.5)).cwiseMin(Scalar(0.5));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < D0; ++i) {
+    for (int j = 0; j < D1; ++j) {
+      const Scalar expected = std::min(Scalar(0.5), std::max(Scalar(-0.5), plane(i, j, 0)));
+      for (int k = 0; k < B; ++k) {
+        if (result(i, j, k) != expected) {
+          state.SkipWithError("validation failed");
+          return;
+        }
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * B * sizeof(Scalar));
+}
+
+// --- Transpose (shuffle) + scalar clamp ---
+// A shuffled inner dimension makes the linear path a per-element gather with
+// a full index-remapping walk, while the block path runs a cache-blocked
+// transpose through TensorBlockIO. The cwiseMax/cwiseMin constants decide
+// which path runs, so before nullary block support they forced the gather.
+static void BM_ShuffleClamp(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> result(N, M);
+  mat.setRandom();
+
+  Eigen::array<int, 2> transpose = {1, 0};
+
+  for (auto _ : state) {
+    result = mat.shuffle(transpose).cwiseMax(Scalar(-0.5)).cwiseMin(Scalar(0.5));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      const Scalar expected = std::min(Scalar(0.5), std::max(Scalar(-0.5), mat(j, i)));
+      if (result(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Pad + scalar clamp (convolution-style padding + clamp) ---
+static void BM_PadClamp(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int P = state.range(2);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> result(M + 2 * P, N + 2 * P);
+  mat.setRandom();
+
+  Eigen::array<std::pair<int, int>, 2> paddings;
+  paddings[0] = {P, P};
+  paddings[1] = {P, P};
+
+  for (auto _ : state) {
+    result = mat.pad(paddings).cwiseMax(Scalar(-0.5)).cwiseMin(Scalar(0.5));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M + 2 * P; ++i) {
+    for (int j = 0; j < N + 2 * P; ++j) {
+      const bool interior = i >= P && i < M + P && j >= P && j < N + P;
+      const Scalar padded = interior ? mat(i - P, j - P) : Scalar(0);
+      const Scalar expected = std::min(Scalar(0.5), std::max(Scalar(-0.5), padded));
+      if (result(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * (M + 2 * P) * (N + 2 * P) * sizeof(Scalar));
+}
+
+// --- Constant multiply without any block-preferring node (control) ---
+// No node prefers block access here, so this expression stays on the linear
+// vectorized path; it pins that nullary block support does not change it.
+static void BM_ConstantMul(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> result(M, N);
+  mat.setRandom();
+
+  for (auto _ : state) {
+    result = mat * mat.constant(Scalar(3));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (result(i, j) != Scalar(3) * mat(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+}
+
+// --- Rank-4 broadcast (batch x channels x 1 x 1) -> (batch x channels x H x W) ---
+static void BM_BroadcastRank4(benchmark::State& state) {
+  const int batch = state.range(0);
+  const int C = state.range(1);
+  const int H = state.range(2);
+
+  Tensor<Scalar, 4> bias(batch, C, 1, 1);
+  Tensor<Scalar, 4> result(batch, C, H, H);
+  bias.setRandom();
+
+  Eigen::array<int, 4> bcast = {1, 1, H, H};
+
+  for (auto _ : state) {
+    result = bias.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * batch * C * H * H * sizeof(Scalar));
+}
+
+// --- ThreadPool variants ---
+
+static void BM_BroadcastRow_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> row(1, N);
+  Tensor<Scalar, 2> result(M, N);
+  row.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Eigen::array<int, 2> bcast = {M, 1};
+
+  for (auto _ : state) {
+    result.device(dev) = row.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+  state.counters["threads"] = threads;
+}
+
+static void BM_BroadcastAdd_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> bias(1, N);
+  Tensor<Scalar, 2> result(M, N);
+  mat.setRandom();
+  bias.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Eigen::array<int, 2> bcast = {M, 1};
+
+  for (auto _ : state) {
+    result.device(dev) = mat + bias.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// {m, n} and {batch, c, h}: pure Cartesian products.
+#define BROADCAST_SIZES ->ArgsProduct({{64, 256, 1024}, {64, 256, 1024}})
+#define BROADCAST_RANK4_SIZES ->ArgsProduct({{1, 8}, {64, 256}, {16, 32}})
+
+// {size, size, threads}: explicit because size is repeated.
+// clang-format off
+#define BROADCAST_THREADPOOL_SIZES \
+  ->Args({256, 256, 1})->Args({256, 256, 2})->Args({256, 256, 4}) \
+  ->Args({256, 256, 8})->Args({256, 256, 12})->Args({256, 256, 16}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 2})->Args({1024, 1024, 4}) \
+  ->Args({1024, 1024, 8})->Args({1024, 1024, 12})->Args({1024, 1024, 16})
+// clang-format on
+
+BENCHMARK(BM_BroadcastRow) BROADCAST_SIZES;
+BENCHMARK(BM_BroadcastCol) BROADCAST_SIZES;
+BENCHMARK(BM_BroadcastAdd) BROADCAST_SIZES;
+BENCHMARK(BM_BroadcastClamp) BROADCAST_SIZES;
+BENCHMARK(BM_OuterBroadcastClamp)->ArgsProduct({{512, 1024}, {512, 1024}, {8}});
+BENCHMARK(BM_ShuffleClamp)->ArgsProduct({{256, 1024, 4096}, {256, 1024, 4096}});
+BENCHMARK(BM_PadClamp)->ArgsProduct({{256, 1024}, {256, 1024}, {1, 4}});
+BENCHMARK(BM_ConstantMul) BROADCAST_SIZES;
+BENCHMARK(BM_BroadcastRank4) BROADCAST_RANK4_SIZES;
+BENCHMARK(BM_BroadcastRow_ThreadPool) BROADCAST_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_BroadcastAdd_ThreadPool) BROADCAST_THREADPOOL_SIZES->UseRealTime();
diff --git a/contrib/benchmarks/Tensor/bench_chained_expressions.cpp b/contrib/benchmarks/Tensor/bench_chained_expressions.cpp
new file mode 100644
index 0000000..fb43683
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_chained_expressions.cpp
@@ -0,0 +1,161 @@
+// Benchmarks for chained tensor expressions with ThreadPool.
+// Tests realistic compound expressions spanning memory-bound to compute-bound.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Pure memory-bound baseline (dst = src) ---
+static void BM_Copy_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> src(M, N);
+  Tensor<Scalar, 2> dst(M, N);
+  src.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    dst.device(dev) = src;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// --- Near-memory-bound: bias + ReLU ---
+// Pattern: (x + bias.broadcast()).cwiseMax(0)
+static void BM_BiasReLU_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> x(M, N);
+  Tensor<Scalar, 2> bias(1, N);
+  Tensor<Scalar, 2> result(M, N);
+  x.setRandom();
+  bias.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Eigen::array<int, 2> bcast = {M, 1};
+
+  for (auto _ : state) {
+    result.device(dev) = (x + bias.broadcast(bcast)).cwiseMax(Scalar(0));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// --- Compute-bound: Horner polynomial ((a*x+b)*x+c)*x+d ---
+static void BM_Polynomial_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> x(M, N);
+  Tensor<Scalar, 2> result(M, N);
+  x.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  const Scalar a = 0.5f, b = 1.2f, c = -0.3f, d = 0.7f;
+
+  for (auto _ : state) {
+    result.device(dev) = ((x.constant(a) * x + x.constant(b)) * x + x.constant(c)) * x + x.constant(d);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// --- Compute-bound: exp (expensive transcendental) ---
+static void BM_ExpNormalize_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> x(M, N);
+  Tensor<Scalar, 2> result(M, N);
+  x.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    result.device(dev) = x.exp();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// --- Batch normalization: gamma * (x - mean) / sqrt(var + eps) + beta ---
+static void BM_BatchNorm_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> x(M, N);
+  Tensor<Scalar, 2> result(M, N);
+  Tensor<Scalar, 2> gamma(1, N);
+  Tensor<Scalar, 2> beta(1, N);
+  Tensor<Scalar, 2> mean(1, N);
+  Tensor<Scalar, 2> var(1, N);
+  x.setRandom();
+  gamma.setRandom();
+  beta.setRandom();
+  mean.setRandom();
+  var.setRandom();
+  var = var.abs() + var.constant(Scalar(0.1));
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Eigen::array<int, 2> bcast = {M, 1};
+  const Scalar eps = 1e-5f;
+
+  for (auto _ : state) {
+    result.device(dev) =
+        gamma.broadcast(bcast) * (x - mean.broadcast(bcast)) * (var.broadcast(bcast) + x.constant(eps)).rsqrt() +
+        beta.broadcast(bcast);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// clang-format off
+#define CHAINED_SIZES \
+  ->Args({256, 256, 1})->Args({256, 256, 2})->Args({256, 256, 4}) \
+  ->Args({256, 256, 8})->Args({256, 256, 12})->Args({256, 256, 16}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 2})->Args({1024, 1024, 4}) \
+  ->Args({1024, 1024, 8})->Args({1024, 1024, 12})->Args({1024, 1024, 16}) \
+  ->Args({4096, 4096, 1})->Args({4096, 4096, 2})->Args({4096, 4096, 4}) \
+  ->Args({4096, 4096, 8})->Args({4096, 4096, 12})->Args({4096, 4096, 16})
+// clang-format on
+
+BENCHMARK(BM_Copy_ThreadPool) CHAINED_SIZES->UseRealTime();
+BENCHMARK(BM_BiasReLU_ThreadPool) CHAINED_SIZES->UseRealTime();
+BENCHMARK(BM_Polynomial_ThreadPool) CHAINED_SIZES->UseRealTime();
+BENCHMARK(BM_ExpNormalize_ThreadPool) CHAINED_SIZES->UseRealTime();
+BENCHMARK(BM_BatchNorm_ThreadPool) CHAINED_SIZES->UseRealTime();
diff --git a/contrib/benchmarks/Tensor/bench_coefficient_wise.cpp b/contrib/benchmarks/Tensor/bench_coefficient_wise.cpp
new file mode 100644
index 0000000..4c68b9d
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_coefficient_wise.cpp
@@ -0,0 +1,281 @@
+// Benchmarks for Eigen Tensor coefficient-wise operations.
+// Covers activation functions, normalization, and element-wise arithmetic.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/SpecialFunctions>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// Macro to define a benchmark for a unary tensor operation.
+#define BENCH_TENSOR_UNARY(NAME, EXPR)                                        \
+  static void BM_##NAME(benchmark::State& state) {                            \
+    const int M = state.range(0);                                             \
+    const int N = state.range(1);                                             \
+    Tensor<Scalar, 2> a(M, N);                                                \
+    a.setRandom();                                                            \
+    Tensor<Scalar, 2> b(M, N);                                                \
+    for (auto _ : state) {                                                    \
+      b = EXPR;                                                               \
+      benchmark::DoNotOptimize(b.data());                                     \
+      benchmark::ClobberMemory();                                             \
+    }                                                                         \
+    state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2); \
+  }
+
+// Macro for ThreadPool variant of a unary tensor operation.
+#define BENCH_TENSOR_UNARY_THREADPOOL(NAME, EXPR)                             \
+  static void BM_##NAME##_ThreadPool(benchmark::State& state) {               \
+    const int M = state.range(0);                                             \
+    const int N = state.range(1);                                             \
+    const int threads = state.range(2);                                       \
+    Tensor<Scalar, 2> a(M, N);                                                \
+    a.setRandom();                                                            \
+    Tensor<Scalar, 2> b(M, N);                                                \
+    ThreadPool tp(threads);                                                   \
+    ThreadPoolDevice dev(&tp, threads);                                       \
+    for (auto _ : state) {                                                    \
+      b.device(dev) = EXPR;                                                   \
+      benchmark::DoNotOptimize(b.data());                                     \
+      benchmark::ClobberMemory();                                             \
+    }                                                                         \
+    state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2); \
+    state.counters["threads"] = threads;                                      \
+  }
+
+BENCH_TENSOR_UNARY(Exp, a.exp())
+BENCH_TENSOR_UNARY(Log, a.abs().log())
+BENCH_TENSOR_UNARY(Tanh, a.tanh())
+BENCH_TENSOR_UNARY(Sigmoid, a.sigmoid())
+BENCH_TENSOR_UNARY(ReLU, a.cwiseMax(Scalar(0)))
+BENCH_TENSOR_UNARY(Sqrt, a.abs().sqrt())
+
+BENCH_TENSOR_UNARY_THREADPOOL(Tanh, a.tanh())
+BENCH_TENSOR_UNARY_THREADPOOL(ReLU, a.cwiseMax(Scalar(0)))
+
+// --- Element-wise binary operations ---
+static void BM_Add(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> a(M, N);
+  Tensor<Scalar, 2> b(M, N);
+  Tensor<Scalar, 2> c(M, N);
+  a.setRandom();
+  b.setRandom();
+
+  for (auto _ : state) {
+    c = a + b;
+    benchmark::DoNotOptimize(c.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 3);
+}
+
+static void BM_Mul(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> a(M, N);
+  Tensor<Scalar, 2> b(M, N);
+  Tensor<Scalar, 2> c(M, N);
+  a.setRandom();
+  b.setRandom();
+
+  for (auto _ : state) {
+    c = a * b;
+    benchmark::DoNotOptimize(c.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 3);
+}
+
+// --- Fused multiply-add ---
+static void BM_FMA(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> a(M, N);
+  Tensor<Scalar, 2> b(M, N);
+  Tensor<Scalar, 2> c(M, N);
+  Tensor<Scalar, 2> d(M, N);
+  a.setRandom();
+  b.setRandom();
+  c.setRandom();
+
+  for (auto _ : state) {
+    d = a * b + c;
+    benchmark::DoNotOptimize(d.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 4);
+}
+
+// --- Ternary op (betainc) with broadcast parameters ---
+// The ternary node's block support decides whether the parameter broadcasts
+// run tiled (bulk row copies) or on the per-packet index-remapping path.
+static void BM_BetaincBroadcast(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> a_row(1, N);
+  Tensor<Scalar, 2> b_row(1, N);
+  Tensor<Scalar, 2> x(M, N);
+  a_row.setRandom();
+  b_row.setRandom();
+  x.setRandom();
+  // betainc requires a > 0, b > 0 and x in [0, 1].
+  a_row = a_row.abs() + a_row.constant(Scalar(0.5));
+  b_row = b_row.abs() + b_row.constant(Scalar(0.5));
+  x = (x + x.constant(Scalar(1))) * x.constant(Scalar(0.5));
+
+  Eigen::array<Index, 2> bcast = {M, 1};
+
+  Tensor<Scalar, 2> result(M, N);
+  for (auto _ : state) {
+    result = Eigen::betainc(a_row.broadcast(bcast), b_row.broadcast(bcast), x);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  // Validate samples against scalar evaluation outside the timed loop.
+  const Eigen::array<int, 3> sample_rows = {0, M / 2, M - 1};
+  for (int i : sample_rows) {
+    for (int j = 0; j < N; ++j) {
+      const Scalar ref = numext::betainc(a_row(0, j), b_row(0, j), x(i, j));
+      if (result(i, j) != ref) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 4);
+}
+
+// --- ThreadPool binary operations ---
+static void BM_Add_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> a(M, N);
+  Tensor<Scalar, 2> b(M, N);
+  Tensor<Scalar, 2> c(M, N);
+  a.setRandom();
+  b.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    c.device(dev) = a + b;
+    benchmark::DoNotOptimize(c.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 3);
+  state.counters["threads"] = threads;
+}
+
+static void BM_Mul_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> a(M, N);
+  Tensor<Scalar, 2> b(M, N);
+  Tensor<Scalar, 2> c(M, N);
+  a.setRandom();
+  b.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    c.device(dev) = a * b;
+    benchmark::DoNotOptimize(c.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 3);
+  state.counters["threads"] = threads;
+}
+
+static void BM_FMA_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> a(M, N);
+  Tensor<Scalar, 2> b(M, N);
+  Tensor<Scalar, 2> c(M, N);
+  Tensor<Scalar, 2> d(M, N);
+  a.setRandom();
+  b.setRandom();
+  c.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    d.device(dev) = a * b + c;
+    benchmark::DoNotOptimize(d.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 4);
+  state.counters["threads"] = threads;
+}
+
+// --- Rank-4 coefficient-wise (CNN feature maps) ---
+static void BM_ReLU_Rank4(benchmark::State& state) {
+  const int batch = state.range(0);
+  const int C = state.range(1);
+  const int H = state.range(2);
+
+  Tensor<Scalar, 4> a(batch, C, H, H);
+  Tensor<Scalar, 4> b(batch, C, H, H);
+  a.setRandom();
+
+  for (auto _ : state) {
+    b = a.cwiseMax(Scalar(0));
+    benchmark::DoNotOptimize(b.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * batch * C * H * H * sizeof(Scalar) * 2);
+}
+
+// clang-format off
+#define CWISE_SIZES \
+  ->Args({256, 256})->Args({1024, 1024})
+
+#define CWISE_THREADPOOL_SIZES \
+  ->Args({256, 256, 1})->Args({256, 256, 2})->Args({256, 256, 4}) \
+  ->Args({256, 256, 8})->Args({256, 256, 12})->Args({256, 256, 16}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 2})->Args({1024, 1024, 4}) \
+  ->Args({1024, 1024, 8})->Args({1024, 1024, 12})->Args({1024, 1024, 16})
+
+#define RANK4_SIZES \
+  ->Args({32, 64, 16})->Args({8, 128, 32})->Args({1, 256, 64})
+// clang-format on
+
+BENCHMARK(BM_Exp) CWISE_SIZES;
+BENCHMARK(BM_Log) CWISE_SIZES;
+BENCHMARK(BM_Tanh) CWISE_SIZES;
+BENCHMARK(BM_Sigmoid) CWISE_SIZES;
+BENCHMARK(BM_ReLU) CWISE_SIZES;
+BENCHMARK(BM_Sqrt) CWISE_SIZES;
+BENCHMARK(BM_Add) CWISE_SIZES;
+BENCHMARK(BM_Mul) CWISE_SIZES;
+BENCHMARK(BM_FMA) CWISE_SIZES;
+BENCHMARK(BM_BetaincBroadcast) CWISE_SIZES;
+BENCHMARK(BM_ReLU_Rank4) RANK4_SIZES;
+BENCHMARK(BM_Add_ThreadPool) CWISE_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_Mul_ThreadPool) CWISE_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_FMA_ThreadPool) CWISE_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_Tanh_ThreadPool) CWISE_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_ReLU_ThreadPool) CWISE_THREADPOOL_SIZES->UseRealTime();
diff --git a/contrib/benchmarks/Tensor/bench_concatenation.cpp b/contrib/benchmarks/Tensor/bench_concatenation.cpp
new file mode 100644
index 0000000..5c9d675
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_concatenation.cpp
@@ -0,0 +1,388 @@
+// Benchmarks for Eigen Tensor concatenation: standalone assigns and
+// compound expressions that read from a concatenation. Tests both the
+// outer-axis path (each operand slab is a single contiguous run, so
+// TensorBlockIO collapses to one memcpy per slab) and the inner-axis
+// path (the slab walk per row is short).
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Standalone concat along axis 0 (innermost for ColMajor) ---
+static void BM_Concat2D_Axis0(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> dst(2 * M, N);
+  A.setRandom();
+  B.setRandom();
+
+  for (auto _ : state) {
+    dst = A.concatenate(B, 0);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * 2 * M * N * sizeof(Scalar) * 2);
+}
+
+// --- Standalone concat along axis 1 (outermost for ColMajor 2D) ---
+static void BM_Concat2D_Axis1(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> dst(M, 2 * N);
+  A.setRandom();
+  B.setRandom();
+
+  for (auto _ : state) {
+    dst = A.concatenate(B, 1);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * 2 * N * sizeof(Scalar) * 2);
+}
+
+// --- Standalone concat 3D along axis 2 (outermost for ColMajor) ---
+static void BM_Concat3D_OuterAxis(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  Tensor<Scalar, 3> B(D0, D1, D2);
+  Tensor<Scalar, 3> dst(D0, D1, 2 * D2);
+  A.setRandom();
+  B.setRandom();
+
+  for (auto _ : state) {
+    dst = A.concatenate(B, 2);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * 2 * D2 * sizeof(Scalar) * 2);
+}
+
+// --- Compound: (concat(A, B) + C) — concat feeds cwise binary ---
+static void BM_Concat2D_Plus(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> C(2 * M, N);
+  Tensor<Scalar, 2> dst(2 * M, N);
+  A.setRandom();
+  B.setRandom();
+  C.setRandom();
+
+  for (auto _ : state) {
+    dst = A.concatenate(B, 0) + C;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * 2 * M * N * sizeof(Scalar) * 3);
+}
+
+// --- Compound: ((concat(A, B) + C) * D).sqrt() — concat in longer chain ---
+static void BM_Concat2D_Chain(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> C(2 * M, N);
+  Tensor<Scalar, 2> D(2 * M, N);
+  Tensor<Scalar, 2> dst(2 * M, N);
+  A.setRandom();
+  B.setRandom();
+  C.setRandom();
+  C = C.abs();
+  D.setRandom();
+  D = D.abs();
+
+  for (auto _ : state) {
+    dst = ((A.concatenate(B, 0) + C) * D).sqrt();
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * 2 * M * N * sizeof(Scalar) * 4);
+}
+
+// --- Compound: (concat(A, B) along axis 1 + C) — outer-axis concat feeds a
+// cwise binary. Each operand slab is a contiguous run, so block evaluation
+// returns it as a zero-copy view and the chain stays fully streaming
+// (no scratch round-trip), unlike the inner-axis BM_Concat2D_Plus. ---
+static void BM_Concat2D_Axis1_Plus(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> C(M, 2 * N);
+  Tensor<Scalar, 2> dst(M, 2 * N);
+  A.setRandom();
+  B.setRandom();
+  C.setRandom();
+
+  for (auto _ : state) {
+    dst = A.concatenate(B, 1) + C;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * 2 * N * sizeof(Scalar) * 3);
+}
+
+// --- Compound: ((concat(A, B) along axis 1 + C) * D).sqrt() — outer-axis
+// analogue of BM_Concat2D_Chain. The zero-copy view path keeps this case off
+// the materialize-then-reread trade-off that BM_Concat2D_Chain pays. ---
+static void BM_Concat2D_Axis1_Chain(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> C(M, 2 * N);
+  Tensor<Scalar, 2> D(M, 2 * N);
+  Tensor<Scalar, 2> dst(M, 2 * N);
+  A.setRandom();
+  B.setRandom();
+  C.setRandom();
+  C = C.abs();
+  D.setRandom();
+  D = D.abs();
+
+  for (auto _ : state) {
+    dst = ((A.concatenate(B, 1) + C) * D).sqrt();
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * 2 * N * sizeof(Scalar) * 4);
+}
+
+// --- Compound: concat of two raw tensors with an outer reduction-ish op ---
+// .square() forces another cwise pass after the concat.
+static void BM_Concat3D_OuterAxis_Square(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  Tensor<Scalar, 3> B(D0, D1, D2);
+  Tensor<Scalar, 3> dst(D0, D1, 2 * D2);
+  A.setRandom();
+  B.setRandom();
+
+  for (auto _ : state) {
+    dst = A.concatenate(B, 2).square();
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * 2 * D2 * sizeof(Scalar) * 2);
+}
+
+// --- Threaded standalone concat ---
+static void BM_Concat2D_Axis1_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> dst(M, 2 * N);
+  A.setRandom();
+  B.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    dst.device(dev) = A.concatenate(B, 1);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * 2 * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// --- Threaded compound: (concat(A, B) + C) * D ---
+static void BM_Concat2D_Chain_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> C(2 * M, N);
+  Tensor<Scalar, 2> D(2 * M, N);
+  Tensor<Scalar, 2> dst(2 * M, N);
+  A.setRandom();
+  B.setRandom();
+  C.setRandom();
+  D.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    dst.device(dev) = (A.concatenate(B, 0) + C) * D;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * 2 * M * N * sizeof(Scalar) * 4);
+  state.counters["threads"] = threads;
+}
+
+// --- Threaded outer-axis compound: (concat(A, B) along axis 1 + C) * D ---
+static void BM_Concat2D_Axis1_Chain_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> C(M, 2 * N);
+  Tensor<Scalar, 2> D(M, 2 * N);
+  Tensor<Scalar, 2> dst(M, 2 * N);
+  A.setRandom();
+  B.setRandom();
+  C.setRandom();
+  D.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    dst.device(dev) = (A.concatenate(B, 1) + C) * D;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * 2 * N * sizeof(Scalar) * 4);
+  state.counters["threads"] = threads;
+}
+
+// --- Writes through a concatenation destination (lvalue writeBlock path) ---
+static void BM_ConcatWrite2D_Axis0(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> src(2 * M, N);
+  src.setRandom();
+  A.setZero();
+  B.setZero();
+
+  for (auto _ : state) {
+    A.concatenate(B, 0) = src;
+    benchmark::DoNotOptimize(A.data());
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (A(i, j) != src(i, j) || B(i, j) != src(M + i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * 2ll * M * N * sizeof(Scalar) * 2);
+}
+
+static void BM_ConcatWrite2D_Axis1(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> src(M, 2 * N);
+  src.setRandom();
+  A.setZero();
+  B.setZero();
+
+  for (auto _ : state) {
+    A.concatenate(B, 1) = src;
+    benchmark::DoNotOptimize(A.data());
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (A(i, j) != src(i, j) || B(i, j) != src(i, N + j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * 2ll * M * N * sizeof(Scalar) * 2);
+}
+
+// Lazy right-hand-side blocks: writeBlock materializes the cwise expression
+// into a temporary before splitting it at the axis.
+static void BM_ConcatWrite2D_Axis1_Plus(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  Tensor<Scalar, 2> src(M, 2 * N);
+  src.setRandom();
+  A.setZero();
+  B.setZero();
+
+  for (auto _ : state) {
+    A.concatenate(B, 1) = src + src.constant(1.0f);
+    benchmark::DoNotOptimize(A.data());
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (A(i, j) != src(i, j) + 1.0f || B(i, j) != src(i, N + j) + 1.0f) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * 2ll * M * N * sizeof(Scalar) * 2);
+}
+
+// clang-format off
+#define CONCAT2D_SIZES \
+  ->Args({256, 256})->Args({1024, 1024})->Args({4096, 4096})
+#define CONCAT3D_SIZES \
+  ->Args({64, 64, 64})->Args({128, 128, 128})->Args({256, 256, 64})
+#define CONCAT2D_THREAD_SIZES \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 4})->Args({1024, 1024, 8}) \
+  ->Args({4096, 4096, 1})->Args({4096, 4096, 4})->Args({4096, 4096, 8})
+// clang-format on
+
+BENCHMARK(BM_Concat2D_Axis0) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Axis1) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat3D_OuterAxis) CONCAT3D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Plus) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Chain) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Axis1_Plus) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Axis1_Chain) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat3D_OuterAxis_Square) CONCAT3D_SIZES->UseRealTime();
+BENCHMARK(BM_ConcatWrite2D_Axis0) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_ConcatWrite2D_Axis1) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_ConcatWrite2D_Axis1_Plus) CONCAT2D_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Axis1_ThreadPool) CONCAT2D_THREAD_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Chain_ThreadPool) CONCAT2D_THREAD_SIZES->UseRealTime();
+BENCHMARK(BM_Concat2D_Axis1_Chain_ThreadPool) CONCAT2D_THREAD_SIZES->UseRealTime();
+
+BENCHMARK_MAIN();
diff --git a/contrib/benchmarks/Tensor/bench_contraction.cpp b/contrib/benchmarks/Tensor/bench_contraction.cpp
new file mode 100644
index 0000000..cd36154
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_contraction.cpp
@@ -0,0 +1,150 @@
+// Benchmarks for Eigen Tensor contraction (generalized GEMM).
+// Tests single-threaded (DefaultDevice) and multi-threaded (ThreadPoolDevice) variants.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR float
+#endif
+
+typedef SCALAR Scalar;
+
+// --- DefaultDevice contraction (rank-2, equivalent to matrix multiply) ---
+static void BM_Contraction(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int K = state.range(2);
+
+  Tensor<Scalar, 2> A(M, K);
+  Tensor<Scalar, 2> B(K, N);
+  Tensor<Scalar, 2> C(M, N);
+  A.setRandom();
+  B.setRandom();
+
+  using ContractDims = Tensor<Scalar, 2>::DimensionPair;
+  Eigen::array<ContractDims, 1> contract_dims = {ContractDims(1, 0)};
+
+  for (auto _ : state) {
+    C = A.contract(B, contract_dims);
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["GFLOPS"] =
+      benchmark::Counter(2.0 * M * N * K, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- ThreadPoolDevice contraction ---
+static void BM_Contraction_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int K = state.range(2);
+  const int threads = state.range(3);
+
+  Tensor<Scalar, 2> A(M, K);
+  Tensor<Scalar, 2> B(K, N);
+  Tensor<Scalar, 2> C(M, N);
+  A.setRandom();
+  B.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  using ContractDims = Tensor<Scalar, 2>::DimensionPair;
+  Eigen::array<ContractDims, 1> contract_dims = {ContractDims(1, 0)};
+
+  for (auto _ : state) {
+    C.device(dev) = A.contract(B, contract_dims);
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["GFLOPS"] =
+      benchmark::Counter(2.0 * M * N * K, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["threads"] = threads;
+}
+
+// --- Rank-3 batch contraction ---
+// Contracts A(batch, M, K) with B(batch, K, N) over batch dim (0<->0)
+// and K dim (2<->1), producing C(M, N). This sums over both the batch
+// and inner dimensions: C(m, n) = sum_b sum_k A(b, m, k) * B(b, k, n).
+static void BM_BatchContraction(benchmark::State& state) {
+  const int batch = state.range(0);
+  const int M = state.range(1);
+  const int N = state.range(2);
+  const int K = state.range(3);
+
+  Tensor<Scalar, 3> A(batch, M, K);
+  Tensor<Scalar, 3> B(batch, K, N);
+  Tensor<Scalar, 2> C(M, N);
+  A.setRandom();
+  B.setRandom();
+
+  using ContractDims = Tensor<Scalar, 3>::DimensionPair;
+  Eigen::array<ContractDims, 2> contract_dims = {ContractDims(0, 0), ContractDims(2, 1)};
+
+  for (auto _ : state) {
+    C = A.contract(B, contract_dims);
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["GFLOPS"] = benchmark::Counter(2.0 * batch * M * N * K, benchmark::Counter::kIsIterationInvariantRate,
+                                                benchmark::Counter::kIs1000);
+}
+
+// --- RowMajor contraction ---
+static void BM_Contraction_RowMajor(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int K = state.range(2);
+
+  Tensor<Scalar, 2, RowMajor> A(M, K);
+  Tensor<Scalar, 2, RowMajor> B(K, N);
+  Tensor<Scalar, 2, RowMajor> C(M, N);
+  A.setRandom();
+  B.setRandom();
+
+  using ContractDims = Tensor<Scalar, 2, RowMajor>::DimensionPair;
+  Eigen::array<ContractDims, 1> contract_dims = {ContractDims(1, 0)};
+
+  for (auto _ : state) {
+    C = A.contract(B, contract_dims);
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["GFLOPS"] =
+      benchmark::Counter(2.0 * M * N * K, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// clang-format off
+#define CONTRACTION_SIZES \
+  ->Args({32, 32, 32})->Args({64, 64, 64})->Args({128, 128, 128}) \
+  ->Args({256, 256, 256})->Args({512, 512, 512})->Args({1024, 1024, 1024}) \
+  ->Args({256, 256, 1024})->Args({1024, 64, 64})
+
+#define CONTRACTION_THREADPOOL_SIZES \
+  ->Args({64, 64, 64, 1})->Args({64, 64, 64, 2})->Args({64, 64, 64, 4}) \
+  ->Args({64, 64, 64, 8})->Args({64, 64, 64, 16}) \
+  ->Args({256, 256, 256, 1})->Args({256, 256, 256, 2})->Args({256, 256, 256, 4}) \
+  ->Args({256, 256, 256, 8})->Args({256, 256, 256, 16}) \
+  ->Args({512, 512, 512, 1})->Args({512, 512, 512, 2})->Args({512, 512, 512, 4}) \
+  ->Args({512, 512, 512, 8})->Args({512, 512, 512, 16}) \
+  ->Args({1024, 1024, 1024, 1})->Args({1024, 1024, 1024, 2})->Args({1024, 1024, 1024, 4}) \
+  ->Args({1024, 1024, 1024, 8})->Args({1024, 1024, 1024, 16})
+
+#define BATCH_SIZES \
+  ->Args({1, 64, 64, 64})->Args({1, 256, 256, 256}) \
+  ->Args({8, 64, 64, 64})->Args({8, 256, 256, 256}) \
+  ->Args({32, 64, 64, 64})->Args({32, 256, 256, 256})
+// clang-format on
+
+BENCHMARK(BM_Contraction) CONTRACTION_SIZES;
+BENCHMARK(BM_Contraction_RowMajor) CONTRACTION_SIZES;
+BENCHMARK(BM_Contraction_ThreadPool) CONTRACTION_THREADPOOL_SIZES;
+BENCHMARK(BM_BatchContraction) BATCH_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_convolution.cpp b/contrib/benchmarks/Tensor/bench_convolution.cpp
new file mode 100644
index 0000000..0c87588
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_convolution.cpp
@@ -0,0 +1,131 @@
+// Benchmarks for Eigen Tensor convolution (1D and 2D).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- 1D convolution ---
+static void BM_Convolve1D(benchmark::State& state) {
+  const int input_size = state.range(0);
+  const int kernel_size = state.range(1);
+
+  Tensor<Scalar, 1> input(input_size);
+  Tensor<Scalar, 1> kernel(kernel_size);
+  input.setRandom();
+  kernel.setRandom();
+
+  Eigen::array<int, 1> dims = {0};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 1> result = input.convolve(kernel, dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  double flops = 2.0 * (input_size - kernel_size + 1) * kernel_size;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- 2D convolution ---
+static void BM_Convolve2D(benchmark::State& state) {
+  const int H = state.range(0);
+  const int W = state.range(1);
+  const int kH = state.range(2);
+  const int kW = state.range(3);
+
+  Tensor<Scalar, 2> input(H, W);
+  Tensor<Scalar, 2> kernel(kH, kW);
+  input.setRandom();
+  kernel.setRandom();
+
+  Eigen::array<int, 2> dims = {0, 1};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> result = input.convolve(kernel, dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  double flops = 2.0 * (H - kH + 1) * (W - kW + 1) * kH * kW;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- 2D convolution with channels (rank-3: C x H x W, convolve on H,W) ---
+static void BM_Convolve2D_Channels(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int kH = state.range(2);
+
+  Tensor<Scalar, 3> input(C, H, H);
+  Tensor<Scalar, 2> kernel(kH, kH);
+  input.setRandom();
+  kernel.setRandom();
+
+  Eigen::array<int, 2> dims = {1, 2};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 3> result = input.convolve(kernel, dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  int outH = H - kH + 1;
+  double flops = 2.0 * C * outH * outH * kH * kH;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- 2D convolution with ThreadPool ---
+static void BM_Convolve2D_ThreadPool(benchmark::State& state) {
+  const int H = state.range(0);
+  const int kH = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> input(H, H);
+  Tensor<Scalar, 2> kernel(kH, kH);
+  Tensor<Scalar, 2> result(H - kH + 1, H - kH + 1);
+  input.setRandom();
+  kernel.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Eigen::array<int, 2> dims = {0, 1};
+
+  for (auto _ : state) {
+    result.device(dev) = input.convolve(kernel, dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  int outH = H - kH + 1;
+  double flops = 2.0 * outH * outH * kH * kH;
+  state.counters["GFLOPS"] =
+      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+  state.counters["threads"] = threads;
+}
+
+// {input, kernel}, {channels, hw, k}, {hw, k, threads}: pure Cartesian products.
+#define CONV1D_SIZES ->ArgsProduct({{128, 512, 2048}, {3, 5, 11}})
+#define CONV2D_CHANNEL_SIZES ->ArgsProduct({{3, 64, 128}, {16, 32, 56}, {3, 5}})
+#define CONV2D_THREADPOOL_SIZES ->ArgsProduct({{64, 128, 224}, {3, 5}, {2, 4, 8}})
+
+// {hw, hw, k, k}: explicit because hw and k are repeated.
+// clang-format off
+#define CONV2D_SIZES \
+  ->Args({32, 32, 3, 3})->Args({32, 32, 5, 5})->Args({32, 32, 7, 7}) \
+  ->Args({64, 64, 3, 3})->Args({64, 64, 5, 5})->Args({64, 64, 7, 7}) \
+  ->Args({128, 128, 3, 3})->Args({128, 128, 5, 5})->Args({128, 128, 7, 7}) \
+  ->Args({224, 224, 3, 3})->Args({224, 224, 5, 5})->Args({224, 224, 7, 7})
+// clang-format on
+
+BENCHMARK(BM_Convolve1D) CONV1D_SIZES;
+BENCHMARK(BM_Convolve2D) CONV2D_SIZES;
+BENCHMARK(BM_Convolve2D_Channels) CONV2D_CHANNEL_SIZES;
+BENCHMARK(BM_Convolve2D_ThreadPool) CONV2D_THREADPOOL_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_custom_op.cpp b/contrib/benchmarks/Tensor/bench_custom_op.cpp
new file mode 100644
index 0000000..97d3096
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_custom_op.cpp
@@ -0,0 +1,88 @@
+// Benchmarks for compositions over Eigen Tensor custom ops.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// A trivial custom op (scale by 2) with the same output dimensions as its
+// input. The interesting part is not the op itself but how its materialized
+// result composes with downstream expressions.
+struct ScaleByTwo {
+  DSizes<DenseIndex, 2> dimensions(const Tensor<Scalar, 2>& input) const { return input.dimensions(); }
+
+  template <typename Output, typename Device>
+  void eval(const Tensor<Scalar, 2>& input, Output& output, const Device& device) const {
+    output.device(device) = input * Scalar(2);
+  }
+};
+
+// Custom op consumed by a transpose. With block access on the custom-op
+// evaluator the shuffle runs as a cache-blocked TensorBlockIO transpose over
+// the custom op's raw buffer; without it, as a per-element gather.
+static void BM_CustomOpShuffle(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> mat(M, N);
+  Tensor<Scalar, 2> result(N, M);
+  mat.setRandom();
+
+  Eigen::array<int, 2> transpose = {1, 0};
+
+  for (auto _ : state) {
+    result = mat.customOp(ScaleByTwo()).shuffle(transpose);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  // Validate outside the timed loop.
+  for (int i = 0; i < N; ++i) {
+    for (int j = 0; j < M; ++j) {
+      if (result(i, j) != Scalar(2) * mat(j, i)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// Custom op consumed by a contiguous slice. With raw access on the custom-op
+// evaluator the slice hits its memcpy fast path.
+static void BM_CustomOpSlice(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> mat(M, N);
+  mat.setRandom();
+
+  const Eigen::array<Index, 2> offsets = {0, N / 4};
+  const Eigen::array<Index, 2> extents = {M, N / 2};
+
+  Tensor<Scalar, 2> result;
+  for (auto _ : state) {
+    result = mat.customOp(ScaleByTwo()).slice(offsets, extents);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (Index i = 0; i < extents[0]; ++i) {
+    for (Index j = 0; j < extents[1]; ++j) {
+      if (result(i, j) != Scalar(2) * mat(i, N / 4 + j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * extents[0] * extents[1] * sizeof(Scalar));
+}
+
+#define CUSTOM_OP_SIZES ->ArgsProduct({{256, 1024, 4096}, {256, 1024}})
+
+BENCHMARK(BM_CustomOpShuffle) CUSTOM_OP_SIZES;
+BENCHMARK(BM_CustomOpSlice) CUSTOM_OP_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_image_patch.cpp b/contrib/benchmarks/Tensor/bench_image_patch.cpp
new file mode 100644
index 0000000..925d80e
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_image_patch.cpp
@@ -0,0 +1,225 @@
+// Benchmarks for Eigen TensorImagePatch extraction.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Basic image patch extraction with PADDING_VALID ---
+static void BM_ImagePatch_Valid(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int W = state.range(2);
+  const int kH = state.range(3);
+  const int kW = state.range(4);
+
+  Tensor<Scalar, 4> input(C, H, W, 1);
+  input.setRandom();
+  const int outH = H - kH + 1;
+  const int outW = W - kW + 1;
+  Tensor<Scalar, 5> result(C, kH, kW, outH * outW, 1);
+
+  for (auto _ : state) {
+    result = input.extract_image_patches(kH, kW, 1, 1, 1, 1, PADDING_VALID);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(C) * outH * outW * kH * kW * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+}
+
+// --- Basic image patch extraction with PADDING_SAME ---
+static void BM_ImagePatch_Same(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int W = state.range(2);
+  const int kH = state.range(3);
+  const int kW = state.range(4);
+
+  Tensor<Scalar, 4> input(C, H, W, 1);
+  input.setRandom();
+  const int outH = H;
+  const int outW = W;
+  Tensor<Scalar, 5> result(C, kH, kW, outH * outW, 1);
+
+  for (auto _ : state) {
+    result = input.extract_image_patches(kH, kW, 1, 1, 1, 1, PADDING_SAME);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(C) * H * W * kH * kW * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+}
+
+// --- Image patch with strides (simulates strided convolution) ---
+static void BM_ImagePatch_Strided(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int kH = state.range(2);
+  const int stride = state.range(3);
+
+  Tensor<Scalar, 4> input(C, H, H, 1);
+  input.setRandom();
+  const int outH = (H + stride - 1) / stride;
+  Tensor<Scalar, 5> result(C, kH, kH, outH * outH, 1);
+
+  for (auto _ : state) {
+    result = input.extract_image_patches(kH, kH, stride, stride, 1, 1, PADDING_SAME);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(C) * outH * outH * kH * kH * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+}
+
+// --- Image patch with dilation (atrous/dilated convolution) ---
+static void BM_ImagePatch_Dilated(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int kH = state.range(2);
+  const int dilation = state.range(3);
+
+  Tensor<Scalar, 4> input(C, H, H, 1);
+  input.setRandom();
+  const int outH = H;
+  Tensor<Scalar, 5> result(C, kH, kH, outH * outH, 1);
+
+  for (auto _ : state) {
+    result = input.extract_image_patches(kH, kH, 1, 1, dilation, dilation, PADDING_SAME);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(C) * H * H * kH * kH * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+}
+
+// --- Image patch with explicit padding ---
+static void BM_ImagePatch_ExplicitPadding(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int W = state.range(2);
+  const int kH = state.range(3);
+
+  const int pad = kH / 2;
+
+  Tensor<Scalar, 4> input(C, H, W, 1);
+  input.setRandom();
+  const int outH = H + 2 * pad - kH + 1;
+  const int outW = W + 2 * pad - kH + 1;
+  Tensor<Scalar, 5> result(C, kH, kH, outH * outW, 1);
+
+  for (auto _ : state) {
+    result = input.extract_image_patches(kH, kH, 1, 1, 1, 1, 1, 1, pad, pad, pad, pad, Scalar(0));
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(C) * outH * outW * kH * kH * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+}
+
+// --- Batched image patch (multiple images) ---
+static void BM_ImagePatch_Batched(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int kH = state.range(2);
+  const int batch = state.range(3);
+
+  Tensor<Scalar, 4> input(C, H, H, batch);
+  input.setRandom();
+  const int outH = H;
+  Tensor<Scalar, 5> result(C, kH, kH, outH * outH, batch);
+
+  for (auto _ : state) {
+    result = input.extract_image_patches(kH, kH, 1, 1, 1, 1, PADDING_SAME);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(batch) * C * H * H * kH * kH * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+}
+
+// --- ThreadPool variant ---
+static void BM_ImagePatch_ThreadPool(benchmark::State& state) {
+  const int C = state.range(0);
+  const int H = state.range(1);
+  const int kH = state.range(2);
+  const int threads = state.range(3);
+
+  Tensor<Scalar, 4> input(C, H, H, 1);
+  input.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  const int outH = H;
+  Tensor<Scalar, 5> result(C, kH, kH, outH * outH, 1);
+
+  for (auto _ : state) {
+    result.device(dev) = input.extract_image_patches(kH, kH, 1, 1, 1, 1, PADDING_SAME);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+
+  const double bytes = static_cast<double>(C) * H * H * kH * kH * sizeof(Scalar);
+  state.SetBytesProcessed(state.iterations() * bytes);
+  state.counters["threads"] = threads;
+}
+
+// --- Size configurations ---
+
+// channels, H, W, kH, kW (H==W and kH==kW); explicit because of duplicated dims.
+// clang-format off
+#define PATCH_SIZES \
+  ->Args({3, 32, 32, 3, 3})->Args({3, 32, 32, 5, 5})->Args({3, 32, 32, 7, 7}) \
+  ->Args({3, 64, 64, 3, 3})->Args({3, 64, 64, 5, 5})->Args({3, 64, 64, 7, 7}) \
+  ->Args({3, 128, 128, 3, 3})->Args({3, 128, 128, 5, 5})->Args({3, 128, 128, 7, 7}) \
+  ->Args({32, 32, 32, 3, 3})->Args({32, 32, 32, 5, 5})->Args({32, 32, 32, 7, 7}) \
+  ->Args({32, 64, 64, 3, 3})->Args({32, 64, 64, 5, 5})->Args({32, 64, 64, 7, 7}) \
+  ->Args({32, 128, 128, 3, 3})->Args({32, 128, 128, 5, 5})->Args({32, 128, 128, 7, 7}) \
+  ->Args({64, 32, 32, 3, 3})->Args({64, 32, 32, 5, 5})->Args({64, 32, 32, 7, 7}) \
+  ->Args({64, 64, 64, 3, 3})->Args({64, 64, 64, 5, 5})->Args({64, 64, 64, 7, 7}) \
+  ->Args({64, 128, 128, 3, 3})->Args({64, 128, 128, 5, 5})->Args({64, 128, 128, 7, 7})
+
+// channels, H, W, kH (H==W); explicit because of duplicated H/W dim.
+#define EXPLICIT_PADDING_SIZES \
+  ->Args({3, 32, 32, 3})->Args({3, 32, 32, 5})->Args({3, 64, 64, 3})->Args({3, 64, 64, 5}) \
+  ->Args({3, 128, 128, 3})->Args({3, 128, 128, 5})->Args({64, 32, 32, 3})->Args({64, 32, 32, 5}) \
+  ->Args({64, 64, 64, 3})->Args({64, 64, 64, 5})->Args({64, 128, 128, 3})->Args({64, 128, 128, 5})
+
+// {channels, spatial, kernel, stride/dilation/threads/batch}: pure Cartesian products.
+#define STRIDED_SIZES ->ArgsProduct({{3, 64}, {56, 112, 224}, {3, 5}, {1, 2}})
+#define DILATED_SIZES ->ArgsProduct({{3, 64}, {32, 64}, {3, 5}, {2, 4}})
+#define BATCHED_SIZES ->ArgsProduct({{3, 64}, {32, 56}, {3, 5}, {4, 16, 32}})
+#define THREAD_POOL_SIZES ->ArgsProduct({{64, 128}, {56, 112}, {3, 5}, {2, 4, 8}})
+
+// Realistic CNN layer configurations: channels, spatial_size, kernel, stride.
+// AlexNet conv1; VGG, VGG deeper x2; ResNet, ResNet downsample, ResNet deeper x2;
+// MobileNet depthwise; Inception 1x1 (degenerate patch).
+#define IMAGENET_SIZES \
+  ->Args({3, 227, 11, 4}) \
+  ->Args({64, 224, 3, 1})->Args({128, 112, 3, 1})->Args({256, 56, 3, 1}) \
+  ->Args({64, 56, 3, 1})->Args({128, 56, 3, 2})->Args({256, 28, 3, 1})->Args({512, 14, 3, 1}) \
+  ->Args({32, 112, 3, 1})->Args({192, 28, 1, 1})
+// clang-format on
+
+BENCHMARK(BM_ImagePatch_Valid) PATCH_SIZES;
+BENCHMARK(BM_ImagePatch_Same) PATCH_SIZES;
+BENCHMARK(BM_ImagePatch_Strided) STRIDED_SIZES;
+BENCHMARK(BM_ImagePatch_Dilated) DILATED_SIZES;
+BENCHMARK(BM_ImagePatch_ExplicitPadding) EXPLICIT_PADDING_SIZES;
+BENCHMARK(BM_ImagePatch_Batched) BATCHED_SIZES;
+BENCHMARK(BM_ImagePatch_Strided) IMAGENET_SIZES->Name("BM_ImagePatch_ImageNet");
+BENCHMARK(BM_ImagePatch_ThreadPool) THREAD_POOL_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_inflation.cpp b/contrib/benchmarks/Tensor/bench_inflation.cpp
new file mode 100644
index 0000000..21a12be
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_inflation.cpp
@@ -0,0 +1,131 @@
+// Benchmarks for Eigen TensorInflation (zero-interleaved upsampling views).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Inflate only the inner-most (contiguous) dimension. ---
+static void BM_Inflate2D_Inner(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {S, 1};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.inflate(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      const Scalar expected = (i % S == 0) ? A(i / S, j) : Scalar(0);
+      if (B(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Inflate only an outer dimension. Inner dim stays contiguous. ---
+static void BM_Inflate2D_Outer(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {1, S};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.inflate(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      const Scalar expected = (j % S == 0) ? A(i, j / S) : Scalar(0);
+      if (B(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Inflate every dimension. ---
+static void BM_Inflate2D_All(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {S, S};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.inflate(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      const Scalar expected = (i % S == 0 && j % S == 0) ? A(i / S, j / S) : Scalar(0);
+      if (B(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Expression-sourced inflation (no raw buffer behind the argument) ---
+static void BM_Inflate2D_Expr(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {S, S};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = (A + A.constant(Scalar(1))).inflate(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      const Scalar expected = (i % S == 0 && j % S == 0) ? A(i / S, j / S) + Scalar(1) : Scalar(0);
+      if (B(i, j) != expected) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// clang-format off
+#define INFLATE_SIZES ->ArgsProduct({{256, 1024}, {1024}, {2, 4}})
+// clang-format on
+
+BENCHMARK(BM_Inflate2D_Inner) INFLATE_SIZES;
+BENCHMARK(BM_Inflate2D_Outer) INFLATE_SIZES;
+BENCHMARK(BM_Inflate2D_All) INFLATE_SIZES;
+BENCHMARK(BM_Inflate2D_Expr) INFLATE_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_layout_swap.cpp b/contrib/benchmarks/Tensor/bench_layout_swap.cpp
new file mode 100644
index 0000000..e330d36
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_layout_swap.cpp
@@ -0,0 +1,194 @@
+// Benchmarks for Eigen TensorLayoutSwap.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+static void BM_LayoutSwap_2D(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2, ColMajor> A(M, N);
+  A.setRandom();
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2, RowMajor> B = A.swap_layout();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  // 1 read (A) + 1 write (B).
+  state.SetBytesProcessed(state.iterations() * 2ll * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+static void BM_LayoutSwap_3D(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3, ColMajor> A(D0, D1, D2);
+  A.setRandom();
+
+  for (auto _ : state) {
+    Tensor<Scalar, 3, RowMajor> B = A.swap_layout();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  // 1 read (A) + 1 write (B).
+  state.SetBytesProcessed(state.iterations() * 2ll * static_cast<int64_t>(D0) * D1 * D2 * sizeof(Scalar));
+}
+
+// Composing swap_layout with a coefficient-wise op forces evaluation through
+// the executor and exercises any subsequent block consumers.
+static void BM_LayoutSwap_Composed(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2, ColMajor> A(M, N);
+  Tensor<Scalar, 2, ColMajor> B(M, N);
+  A.setRandom();
+  B.setRandom();
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2, RowMajor> C = (A + B).swap_layout();
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  // 2 reads (A, B) + 1 write (C).
+  state.SetBytesProcessed(state.iterations() * 3ll * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// A transpose shuffle composed with swap_layout converts a matrix to the
+// opposite storage order while keeping its logical indexing: B(i,j) == A(i,j).
+// The shuffle serves materialized blocks that the swap re-wraps.
+static void BM_LayoutSwap_Shuffle2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+
+  Tensor<Scalar, 2, ColMajor> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> transpose = {1, 0};
+
+  Tensor<Scalar, 2, RowMajor> B;
+  for (auto _ : state) {
+    B = A.shuffle(transpose).swap_layout();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < M; ++i) {
+    for (Index j = 0; j < N; ++j) {
+      if (B(i, j) != A(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  // 1 read (A) + 1 write (B).
+  state.SetBytesProcessed(state.iterations() * 2ll * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+static void BM_LayoutSwap_Shuffle3D(benchmark::State& state) {
+  const Index D0 = state.range(0);
+  const Index D1 = state.range(1);
+  const Index D2 = state.range(2);
+
+  Tensor<Scalar, 3, ColMajor> A(D0, D1, D2);
+  A.setRandom();
+  Eigen::array<Index, 3> perm = {2, 0, 1};
+  const Tensor<Scalar, 3, ColMajor> ref = A.shuffle(perm);
+
+  Tensor<Scalar, 3, RowMajor> B;
+  for (auto _ : state) {
+    B = A.shuffle(perm).swap_layout();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < ref.dimension(0); ++i) {
+    for (Index j = 0; j < ref.dimension(1); ++j) {
+      for (Index k = 0; k < ref.dimension(2); ++k) {
+        if (B(k, j, i) != ref(i, j, k)) {
+          state.SkipWithError("validation failed");
+          return;
+        }
+      }
+    }
+  }
+  // 1 read (A) + 1 write (B).
+  state.SetBytesProcessed(state.iterations() * 2ll * static_cast<int64_t>(D0) * D1 * D2 * sizeof(Scalar));
+}
+
+// A cwise op on top of the shuffle serves lazy blocks that the layout swap
+// materializes itself.
+static void BM_LayoutSwap_ShuffleCwise2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+
+  Tensor<Scalar, 2, ColMajor> A(M, N);
+  Tensor<Scalar, 2, ColMajor> bias(N, M);
+  A.setRandom();
+  bias.setRandom();
+  Eigen::array<Index, 2> transpose = {1, 0};
+
+  Tensor<Scalar, 2, RowMajor> B;
+  for (auto _ : state) {
+    B = (A.shuffle(transpose) + bias).swap_layout();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < M; ++i) {
+    for (Index j = 0; j < N; ++j) {
+      if (B(i, j) != A(i, j) + bias(j, i)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  // 2 reads (A, bias) + 1 write (B).
+  state.SetBytesProcessed(state.iterations() * 3ll * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// Write through a layout-swapped destination from a block-preferring source.
+static void BM_LayoutSwap_Write2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+
+  Tensor<Scalar, 2, ColMajor> A(M, N);
+  Tensor<Scalar, 2, ColMajor> bias(N, M);
+  A.setRandom();
+  bias.setRandom();
+  Eigen::array<Index, 2> transpose = {1, 0};
+
+  Tensor<Scalar, 2, RowMajor> C(M, N);
+  C.setZero();
+  for (auto _ : state) {
+    C.swap_layout() = A.shuffle(transpose) + bias;
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < M; ++i) {
+    for (Index j = 0; j < N; ++j) {
+      if (C(i, j) != A(i, j) + bias(j, i)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  // 2 reads (A, bias) + 1 write (C).
+  state.SetBytesProcessed(state.iterations() * 3ll * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// {n, n} and {n, n, n}: explicit because dims are repeated.
+#define LAYOUT_SWAP_SIZES ->Args({64, 64})->Args({256, 256})->Args({1024, 1024})
+#define LAYOUT_SWAP_3D_SIZES ->Args({32, 32, 32})->Args({64, 64, 64})->Args({128, 128, 128})
+
+BENCHMARK(BM_LayoutSwap_2D) LAYOUT_SWAP_SIZES;
+BENCHMARK(BM_LayoutSwap_3D) LAYOUT_SWAP_3D_SIZES;
+BENCHMARK(BM_LayoutSwap_Composed) LAYOUT_SWAP_SIZES;
+BENCHMARK(BM_LayoutSwap_Shuffle2D) LAYOUT_SWAP_SIZES;
+BENCHMARK(BM_LayoutSwap_Shuffle3D) LAYOUT_SWAP_3D_SIZES;
+BENCHMARK(BM_LayoutSwap_ShuffleCwise2D) LAYOUT_SWAP_SIZES;
+BENCHMARK(BM_LayoutSwap_Write2D) LAYOUT_SWAP_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_morphing.cpp b/contrib/benchmarks/Tensor/bench_morphing.cpp
new file mode 100644
index 0000000..c33325f
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_morphing.cpp
@@ -0,0 +1,325 @@
+// Benchmarks for Eigen Tensor morphing operations: reshape, slice, chip, pad, strided slice.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Reshape (zero-cost if no evaluation needed; force eval via assignment) ---
+static void BM_Reshape(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  Eigen::array<Index, 1> new_shape = {M * N};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 1> B = A.reshape(new_shape);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Slice ---
+static void BM_Slice(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  int sliceM = M / 2;
+  int sliceN = N / 2;
+  Eigen::array<Index, 2> offsets = {0, 0};
+  Eigen::array<Index, 2> extents = {sliceM, sliceN};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.slice(offsets, extents);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * sliceM * sliceN * sizeof(Scalar));
+}
+
+// --- Chip (extract a sub-tensor along one dimension) ---
+static void BM_Chip(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.chip(0, 0);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * D1 * D2 * sizeof(Scalar));
+}
+
+// --- Pad ---
+static void BM_Pad(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int padSize = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  Eigen::array<std::pair<int, int>, 2> paddings;
+  paddings[0] = {padSize, padSize};
+  paddings[1] = {padSize, padSize};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.pad(paddings);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  int outM = M + 2 * padSize;
+  int outN = N + 2 * padSize;
+  state.SetBytesProcessed(state.iterations() * outM * outN * sizeof(Scalar));
+}
+
+// --- Strided slice ---
+// Covers the packet fast paths of the strided-slice evaluator: contiguous
+// inner loads (inner stride 1), reversed inner loads (inner stride -1), and
+// the scalar gather fallback (non-unit inner stride).
+static void BM_StridedSliceRead(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const Index s0 = state.range(2);
+  const Index s1 = state.range(3);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  const Eigen::array<Index, 2> start = {s0 > 0 ? 1 : M - 2, s1 > 0 ? 1 : N - 2};
+  const Eigen::array<Index, 2> stop = {s0 > 0 ? M - 1 : 0, s1 > 0 ? N - 1 : 0};
+  const Eigen::array<Index, 2> strides = {s0, s1};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.stridedSlice(start, stop, strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+
+  // Validate outside the timed loop.
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      if (B(i, j) != A(start[0] + i * s0, start[1] + j * s1)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * B.size() * sizeof(Scalar));
+}
+
+// Strided slice feeding a packet-math kernel the compiler cannot rescue by
+// auto-vectorizing the scalar loop.
+static void BM_StridedSliceExp(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const Index s0 = state.range(2);
+  const Index s1 = state.range(3);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  const Eigen::array<Index, 2> start = {s0 > 0 ? 1 : M - 2, s1 > 0 ? 1 : N - 2};
+  const Eigen::array<Index, 2> stop = {s0 > 0 ? M - 1 : 0, s1 > 0 ? N - 1 : 0};
+  const Eigen::array<Index, 2> strides = {s0, s1};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.stridedSlice(start, stop, strides).exp();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      const Scalar expected = std::exp(A(start[0] + i * s0, start[1] + j * s1));
+      if (std::abs(B(i, j) - expected) > 1e-4f * std::abs(expected)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * B.size() * sizeof(Scalar));
+}
+
+static void BM_StridedSliceWrite(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const Index s0 = state.range(2);
+  const Index s1 = state.range(3);
+
+  const Eigen::array<Index, 2> start = {s0 > 0 ? 1 : M - 2, s1 > 0 ? 1 : N - 2};
+  const Eigen::array<Index, 2> stop = {s0 > 0 ? M - 1 : 0, s1 > 0 ? N - 1 : 0};
+  const Eigen::array<Index, 2> strides = {s0, s1};
+
+  Tensor<Scalar, 2> B(M, N);
+  B.setZero();
+  // Size the source from the slice itself, so it tracks the stride sweep.
+  Tensor<Scalar, 2> A = B.stridedSlice(start, stop, strides);
+  A.setRandom();
+
+  for (auto _ : state) {
+    B.stridedSlice(start, stop, strides) = A;
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (Index i = 0; i < A.dimension(0); ++i) {
+    for (Index j = 0; j < A.dimension(1); ++j) {
+      if (B(start[0] + i * s0, start[1] + j * s1) != A(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * A.size() * sizeof(Scalar));
+}
+
+// Expression assigned through a strided-slice destination. The rhs block has
+// no raw buffer, so this exercises the expression side of writeBlock: direct
+// assignment into the destination for a unit inner stride, and the
+// materialize-into-temp path otherwise.
+static void BM_StridedSliceWriteExp(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const Index s0 = state.range(2);
+  const Index s1 = state.range(3);
+
+  const Eigen::array<Index, 2> start = {s0 > 0 ? 1 : M - 2, s1 > 0 ? 1 : N - 2};
+  const Eigen::array<Index, 2> stop = {s0 > 0 ? M - 1 : 0, s1 > 0 ? N - 1 : 0};
+  const Eigen::array<Index, 2> strides = {s0, s1};
+
+  Tensor<Scalar, 2> B(M, N);
+  B.setZero();
+  // Size the source from the slice itself, so it tracks the stride sweep.
+  Tensor<Scalar, 2> A = B.stridedSlice(start, stop, strides);
+  A.setRandom();
+
+  for (auto _ : state) {
+    B.stridedSlice(start, stop, strides) = A.exp();
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (Index i = 0; i < A.dimension(0); ++i) {
+    for (Index j = 0; j < A.dimension(1); ++j) {
+      const Scalar expected = std::exp(A(i, j));
+      if (std::abs(B(start[0] + i * s0, start[1] + j * s1) - expected) > 1e-4f * std::abs(expected)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * A.size() * sizeof(Scalar));
+}
+
+// --- ThreadPool variants ---
+
+static void BM_Slice_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  int sliceM = M / 2;
+  int sliceN = N / 2;
+  Eigen::array<Index, 2> offsets = {0, 0};
+  Eigen::array<Index, 2> extents = {sliceM, sliceN};
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Tensor<Scalar, 2> B(sliceM, sliceN);
+
+  for (auto _ : state) {
+    B.device(dev) = A.slice(offsets, extents);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * sliceM * sliceN * sizeof(Scalar));
+  state.counters["threads"] = threads;
+}
+
+static void BM_Pad_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  Eigen::array<std::pair<int, int>, 2> paddings;
+  paddings[0] = {4, 4};
+  paddings[1] = {4, 4};
+
+  int outM = M + 8;
+  int outN = N + 8;
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Tensor<Scalar, 2> B(outM, outN);
+
+  for (auto _ : state) {
+    B.device(dev) = A.pad(paddings);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * outM * outN * sizeof(Scalar));
+  state.counters["threads"] = threads;
+}
+
+// clang-format off
+#define MORPH_SIZES \
+  ->Args({256, 256})->Args({1024, 1024})
+
+#define CHIP_SIZES \
+  ->Args({32, 256, 256})->Args({64, 128, 128})->Args({8, 512, 512})
+
+#define PAD_SIZES \
+  ->Args({256, 256, 1})->Args({256, 256, 4})->Args({256, 256, 16}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 4})->Args({1024, 1024, 16})
+
+#define STRIDED_SLICE_SIZES \
+  ->Args({256, 256, 1, 1})->Args({1024, 1024, 1, 1})   /* contiguous inner */ \
+  ->Args({256, 256, -1, -1})->Args({1024, 1024, -1, -1}) /* reversed inner */ \
+  ->Args({256, 256, 2, 2})->Args({1024, 1024, 2, 2})   /* gather fallback */
+
+#define MORPH_THREADPOOL_SIZES \
+  ->Args({256, 256, 1})->Args({256, 256, 2})->Args({256, 256, 4}) \
+  ->Args({256, 256, 8})->Args({256, 256, 12})->Args({256, 256, 16}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 2})->Args({1024, 1024, 4}) \
+  ->Args({1024, 1024, 8})->Args({1024, 1024, 12})->Args({1024, 1024, 16})
+// clang-format on
+
+BENCHMARK(BM_Reshape) MORPH_SIZES;
+BENCHMARK(BM_Slice) MORPH_SIZES;
+BENCHMARK(BM_Chip) CHIP_SIZES;
+BENCHMARK(BM_Pad) PAD_SIZES;
+BENCHMARK(BM_StridedSliceRead) STRIDED_SLICE_SIZES;
+BENCHMARK(BM_StridedSliceExp) STRIDED_SLICE_SIZES;
+BENCHMARK(BM_StridedSliceWrite) STRIDED_SLICE_SIZES;
+BENCHMARK(BM_StridedSliceWriteExp) STRIDED_SLICE_SIZES;
+BENCHMARK(BM_Slice_ThreadPool) MORPH_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_Pad_ThreadPool) MORPH_THREADPOOL_SIZES->UseRealTime();
diff --git a/contrib/benchmarks/Tensor/bench_patch.cpp b/contrib/benchmarks/Tensor/bench_patch.cpp
new file mode 100644
index 0000000..31d83ab
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_patch.cpp
@@ -0,0 +1,119 @@
+// Benchmarks for Eigen TensorPatch and TensorVolumePatch.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// Validates `result` against the expression's scalar coeff() path, which does
+// not depend on block evaluation.
+template <typename ResultTensor, typename Expr>
+static bool ValidateAgainstCoeff(benchmark::State& state, const ResultTensor& result, const Expr& expr) {
+  TensorEvaluator<const Expr, DefaultDevice> eval(expr, DefaultDevice());
+  eval.evalSubExprsIfNeeded(nullptr);
+  bool ok = true;
+  for (Index i = 0; i < result.size(); ++i) {
+    if (result.coeff(i) != eval.coeff(i)) {
+      state.SkipWithError("validation failed");
+      ok = false;
+      break;
+    }
+  }
+  eval.cleanup();
+  return ok;
+}
+
+// --- Generic sliding-window patches on a 2D tensor ---
+static void BM_Patch2D(benchmark::State& state) {
+  const Index N = state.range(0);
+  const Index K = state.range(1);
+
+  Tensor<Scalar, 2> input(N, N);
+  input.setRandom();
+  Eigen::array<Index, 2> patch_dims = {K, K};
+  const auto patches = input.extract_patches(patch_dims);
+
+  Tensor<Scalar, 3> result;
+  for (auto _ : state) {
+    result = patches;
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  if (!ValidateAgainstCoeff(state, result, patches)) return;
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(result.size()) * sizeof(Scalar));
+}
+
+// --- Generic sliding-window patches on a 3D tensor ---
+static void BM_Patch3D(benchmark::State& state) {
+  const Index N = state.range(0);
+  const Index K = state.range(1);
+
+  Tensor<Scalar, 3> input(N, N, N);
+  input.setRandom();
+  Eigen::array<Index, 3> patch_dims = {K, K, K};
+  const auto patches = input.extract_patches(patch_dims);
+
+  Tensor<Scalar, 4> result;
+  for (auto _ : state) {
+    result = patches;
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  if (!ValidateAgainstCoeff(state, result, patches)) return;
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(result.size()) * sizeof(Scalar));
+}
+
+// --- Volume patches, no padding ---
+static void BM_VolumePatch_Valid(benchmark::State& state) {
+  const Index C = state.range(0);
+  const Index N = state.range(1);
+  const Index K = state.range(2);
+
+  Tensor<Scalar, 5> input(C, N, N, N, 1);
+  input.setRandom();
+  const auto patches = input.extract_volume_patches(K, K, K, 1, 1, 1, PADDING_VALID);
+
+  Tensor<Scalar, 6> result;
+  for (auto _ : state) {
+    result = patches;
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  if (!ValidateAgainstCoeff(state, result, patches)) return;
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(result.size()) * sizeof(Scalar));
+}
+
+// --- Volume patches, strided with same padding (blocks contain padding) ---
+static void BM_VolumePatch_Same(benchmark::State& state) {
+  const Index C = state.range(0);
+  const Index N = state.range(1);
+  const Index K = state.range(2);
+
+  Tensor<Scalar, 5> input(C, N, N, N, 1);
+  input.setRandom();
+  const auto patches = input.extract_volume_patches(K, K, K, 2, 2, 2, PADDING_SAME);
+
+  Tensor<Scalar, 6> result;
+  for (auto _ : state) {
+    result = patches;
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  if (!ValidateAgainstCoeff(state, result, patches)) return;
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(result.size()) * sizeof(Scalar));
+}
+
+// clang-format off
+#define PATCH2D_SIZES ->ArgsProduct({{128, 256}, {4, 8}})
+#define PATCH3D_SIZES ->ArgsProduct({{24, 32}, {2, 4}})
+#define VOLUME_SIZES ->ArgsProduct({{4, 16}, {32}, {3}})
+// clang-format on
+
+BENCHMARK(BM_Patch2D) PATCH2D_SIZES;
+BENCHMARK(BM_Patch3D) PATCH3D_SIZES;
+BENCHMARK(BM_VolumePatch_Valid) VOLUME_SIZES;
+BENCHMARK(BM_VolumePatch_Same) VOLUME_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_reduction.cpp b/contrib/benchmarks/Tensor/bench_reduction.cpp
new file mode 100644
index 0000000..17d6c2f
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_reduction.cpp
@@ -0,0 +1,131 @@
+// Benchmarks for Eigen Tensor reductions (sum, maximum, mean).
+// Tests full and partial reductions, inner vs outer dimension, DefaultDevice and ThreadPoolDevice.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR float
+#endif
+
+typedef SCALAR Scalar;
+
+// --- Full reduction (rank-2) ---
+template <typename ReduceOp>
+static void BM_FullReduction(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  for (auto _ : state) {
+    Tensor<Scalar, 0> result = A.reduce(Eigen::array<int, 2>{0, 1}, ReduceOp());
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Partial reduction along dim 0 (inner dim, ColMajor) ---
+static void BM_ReduceInner(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  Eigen::array<int, 1> reduce_dims = {0};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 1> result = A.sum(reduce_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Partial reduction along dim 1 (outer dim, ColMajor) ---
+static void BM_ReduceOuter(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  Eigen::array<int, 1> reduce_dims = {1};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 1> result = A.sum(reduce_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+}
+
+// --- Rank-4 partial reduction (batch x channels x H x W), reduce along spatial dims ---
+static void BM_ReduceSpatial(benchmark::State& state) {
+  const int batch = state.range(0);
+  const int C = state.range(1);
+  const int H = state.range(2);
+
+  Tensor<Scalar, 4> A(batch, C, H, H);
+  A.setRandom();
+
+  Eigen::array<int, 2> reduce_dims = {2, 3};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> result = A.sum(reduce_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * batch * C * H * H * sizeof(Scalar));
+}
+
+// --- Full reduction with ThreadPoolDevice ---
+static void BM_FullReduction_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 0> result;
+  A.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  for (auto _ : state) {
+    result.device(dev) = A.sum();
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
+  state.counters["threads"] = threads;
+}
+
+// clang-format off
+#define REDUCTION_SIZES \
+  ->Args({64, 64})->Args({256, 256})->Args({1024, 1024})
+
+#define THREADPOOL_REDUCTION_SIZES \
+  ->Args({256, 256, 2})->Args({256, 256, 4})->Args({256, 256, 8}) \
+  ->Args({1024, 1024, 2})->Args({1024, 1024, 4})->Args({1024, 1024, 8})
+
+// {batch, channels, h}: pure Cartesian product.
+#define SPATIAL_SIZES ->ArgsProduct({{1, 8, 32}, {64, 128}, {16, 32}})
+// clang-format on
+
+BENCHMARK(BM_FullReduction<internal::SumReducer<Scalar>>) REDUCTION_SIZES->Name("SumReduction");
+BENCHMARK(BM_FullReduction<internal::MaxReducer<Scalar>>) REDUCTION_SIZES->Name("MaxReduction_Full");
+BENCHMARK(BM_ReduceInner) REDUCTION_SIZES;
+BENCHMARK(BM_ReduceOuter) REDUCTION_SIZES;
+BENCHMARK(BM_ReduceSpatial) SPATIAL_SIZES;
+BENCHMARK(BM_FullReduction_ThreadPool) THREADPOOL_REDUCTION_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_reverse.cpp b/contrib/benchmarks/Tensor/bench_reverse.cpp
new file mode 100644
index 0000000..f5b32b6
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_reverse.cpp
@@ -0,0 +1,290 @@
+// Benchmarks for Eigen TensorReverse.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Reverse only the inner-most (contiguous) dimension. SIMD preverse case. ---
+static void BM_Reverse_Inner(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  array<bool, 2> dim_rev = {true, false};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.reverse(dim_rev);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- Reverse only an outer dimension. Inner dim stays contiguous. ---
+static void BM_Reverse_Outer(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  array<bool, 2> dim_rev = {false, true};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.reverse(dim_rev);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- Reverse every dimension. ---
+static void BM_Reverse_All(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  array<bool, 2> dim_rev = {true, true};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.reverse(dim_rev);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- 3D reverse with the inner dim reversed (typical CNN-style layout). ---
+static void BM_Reverse_3D_Inner(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+
+  array<bool, 3> dim_rev = {true, false, false};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 3> B = A.reverse(dim_rev);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(D0) * D1 * D2 * sizeof(Scalar));
+}
+
+// Sweep sizes that span L1 (~32 KB), L2 (~256 KB), and LLC (~MBs) for float
+// tensors. Bytes per element = 4, so per-side sizes:
+//   64x64    = 16 KB (L1)
+//   256x256  = 256 KB (L2)
+//   1024x1024 = 4 MB (LLC / DRAM)
+// --- Writes through a reversed destination (lvalue writePacket path) ---
+static void BM_ReverseWrite_Inner(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> src(M, N);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  array<bool, 2> dim_rev = {true, false};
+
+  for (auto _ : state) {
+    dst.reverse(dim_rev) = src;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  // Validate outside the timed loop.
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(M - 1 - i, j) != src(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+static void BM_ReverseWrite_Outer(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> src(M, N);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  array<bool, 2> dim_rev = {false, true};
+
+  for (auto _ : state) {
+    dst.reverse(dim_rev) = src;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(i, N - 1 - j) != src(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- Writes into a reversed destination from a block-preferring source. The
+// shuffle routes the assignment through the tiled executor, so the reverse
+// destination serves it via writeBlock instead of per-packet index math. ---
+static void BM_ReverseWrite_FromShuffle_Inner(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> src(N, M);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  Eigen::array<Index, 2> transpose = {1, 0};
+  array<bool, 2> dim_rev = {true, false};
+
+  for (auto _ : state) {
+    dst.reverse(dim_rev) = src.shuffle(transpose);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(M - 1 - i, j) != src(j, i)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+static void BM_ReverseWrite_FromShuffle_Outer(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> src(N, M);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  Eigen::array<Index, 2> transpose = {1, 0};
+  array<bool, 2> dim_rev = {false, true};
+
+  for (auto _ : state) {
+    dst.reverse(dim_rev) = src.shuffle(transpose);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(i, N - 1 - j) != src(j, i)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// A broadcast right-hand side is the motivating case for the reverse
+// destination's writeBlock: broadcast's packet path pays heavy per-packet
+// index math, while its block path is a bulk copy.
+static void BM_ReverseWrite_FromBroadcast(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> src(M / 4, N);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  Eigen::array<Index, 2> bcast = {4, 1};
+  array<bool, 2> dim_rev = {true, false};
+
+  for (auto _ : state) {
+    dst.reverse(dim_rev) = src.broadcast(bcast);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(M - 1 - i, j) != src(i % (M / 4), j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// Lazy right-hand-side blocks: writeBlock evaluates the re-reversed cwise
+// expression straight into the destination box.
+static void BM_ReverseWrite_FromShuffleExpr(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> src(N, M);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  Eigen::array<Index, 2> transpose = {1, 0};
+  array<bool, 2> dim_rev = {true, false};
+
+  for (auto _ : state) {
+    dst.reverse(dim_rev) = src.shuffle(transpose) + src.shuffle(transpose).constant(1.0f);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(M - 1 - i, j) != src(j, i) + 1.0f) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// clang-format off
+#define REVERSE_SIZES \
+  ->Args({64, 64})->Args({256, 256})->Args({1024, 1024})
+
+// 128 KB / 1 MB / 8 MB
+#define REVERSE_3D_SIZES \
+  ->Args({32, 32, 32})->Args({64, 64, 64})->Args({128, 128, 128})
+// clang-format on
+
+BENCHMARK(BM_Reverse_Inner) REVERSE_SIZES;
+BENCHMARK(BM_Reverse_Outer) REVERSE_SIZES;
+BENCHMARK(BM_Reverse_All) REVERSE_SIZES;
+BENCHMARK(BM_Reverse_3D_Inner) REVERSE_3D_SIZES;
+BENCHMARK(BM_ReverseWrite_Inner) REVERSE_SIZES;
+BENCHMARK(BM_ReverseWrite_Outer) REVERSE_SIZES;
+BENCHMARK(BM_ReverseWrite_FromShuffle_Inner) REVERSE_SIZES;
+BENCHMARK(BM_ReverseWrite_FromShuffle_Outer) REVERSE_SIZES;
+BENCHMARK(BM_ReverseWrite_FromBroadcast) REVERSE_SIZES;
+BENCHMARK(BM_ReverseWrite_FromShuffleExpr) REVERSE_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_roll.cpp b/contrib/benchmarks/Tensor/bench_roll.cpp
new file mode 100644
index 0000000..603cc13
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_roll.cpp
@@ -0,0 +1,200 @@
+// Benchmarks for Eigen TensorRoll.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Roll only the inner-most (contiguous) dimension. ---
+static void BM_Roll_Inner(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int shift = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  array<Index, 2> rolls = {shift, 0};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.roll(rolls);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- Roll only an outer dimension. Inner dim stays contiguous. ---
+static void BM_Roll_Outer(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int shift = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  array<Index, 2> rolls = {0, shift};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.roll(rolls);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- Roll every dimension. ---
+static void BM_Roll_All(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int shift = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+
+  array<Index, 2> rolls = {shift, shift};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 2> B = A.roll(rolls);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// --- 3D roll with the inner dim shifted. ---
+static void BM_Roll_3D_Inner(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+
+  array<Index, 3> rolls = {D0 / 4, 0, 0};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 3> B = A.roll(rolls);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(D0) * D1 * D2 * sizeof(Scalar));
+}
+
+// --- Writes through a rolled destination (lvalue writeBlock path, which
+// scatters each block into its wrap-around pieces) ---
+static void BM_RollWrite_Inner(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int shift = state.range(2);
+
+  Tensor<Scalar, 2> src(M, N);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  array<Index, 2> rolls = {shift, 0};
+
+  for (auto _ : state) {
+    dst.roll(rolls) = src;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst((i + shift) % M, j) != src(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+static void BM_RollWrite_Outer(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int shift = state.range(2);
+
+  Tensor<Scalar, 2> src(M, N);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  array<Index, 2> rolls = {0, shift};
+
+  for (auto _ : state) {
+    dst.roll(rolls) = src;
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst(i, (j + shift) % N) != src(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// Lazy right-hand-side blocks: writeBlock materializes the cwise expression
+// into a temporary before scattering the pieces.
+static void BM_RollWrite_Expr(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int shift = state.range(2);
+
+  Tensor<Scalar, 2> src(M, N);
+  src.setRandom();
+  Tensor<Scalar, 2> dst(M, N);
+  dst.setZero();
+
+  array<Index, 2> rolls = {shift, shift};
+
+  for (auto _ : state) {
+    dst.roll(rolls) = src + src.constant(1.0f);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+  for (int i = 0; i < M; ++i) {
+    for (int j = 0; j < N; ++j) {
+      if (dst((i + shift) % M, (j + shift) % N) != src(i, j) + 1.0f) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * static_cast<int64_t>(M) * N * sizeof(Scalar));
+}
+
+// clang-format off
+#define ROLL_SIZES \
+  ->Args({64, 64, 1})->Args({64, 64, 13}) \
+  ->Args({256, 256, 1})->Args({256, 256, 13}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 13})
+
+// Transition sizes around the tiled-evaluation crossover (~8x8) for the
+// write benchmarks: below it the fixed tiled-executor setup cost dominates.
+#define ROLL_WRITE_SIZES \
+  ->Args({2, 2, 1})->Args({4, 4, 1})->Args({8, 8, 1})->Args({16, 16, 3})->Args({32, 32, 3}) \
+  ->Args({64, 64, 1})->Args({64, 64, 13}) \
+  ->Args({256, 256, 1})->Args({256, 256, 13}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 13})
+
+#define ROLL_3D_SIZES \
+  ->Args({32, 32, 32})->Args({64, 64, 64})->Args({128, 128, 128})
+// clang-format on
+
+BENCHMARK(BM_Roll_Inner) ROLL_SIZES;
+BENCHMARK(BM_Roll_Outer) ROLL_SIZES;
+BENCHMARK(BM_Roll_All) ROLL_SIZES;
+BENCHMARK(BM_Roll_3D_Inner) ROLL_3D_SIZES;
+BENCHMARK(BM_RollWrite_Inner) ROLL_WRITE_SIZES;
+BENCHMARK(BM_RollWrite_Outer) ROLL_WRITE_SIZES;
+BENCHMARK(BM_RollWrite_Expr) ROLL_WRITE_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_shuffling.cpp b/contrib/benchmarks/Tensor/bench_shuffling.cpp
new file mode 100644
index 0000000..21e9b89
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_shuffling.cpp
@@ -0,0 +1,276 @@
+// Benchmarks for Eigen Tensor shuffling (transpose / permutation).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Rank-2 transpose ---
+static void BM_Shuffle2D(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(N, M);
+  A.setRandom();
+
+  Eigen::array<int, 2> perm = {1, 0};
+
+  for (auto _ : state) {
+    B = A.shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+}
+
+// --- Identity shuffle (no permutation, measures overhead) ---
+static void BM_ShuffleIdentity(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(M, N);
+  A.setRandom();
+
+  Eigen::array<int, 2> perm = {0, 1};
+
+  for (auto _ : state) {
+    B = A.shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+}
+
+// --- Rank-3 permutation ---
+static void BM_Shuffle3D(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+
+  // Permutation (2, 0, 1)
+  Eigen::array<int, 3> perm = {2, 0, 1};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 3> B = A.shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * D2 * sizeof(Scalar) * 2);
+}
+
+// --- Rank-4 permutation (NCHW -> NHWC layout conversion) ---
+static void BM_Shuffle4D_NCHW_to_NHWC(benchmark::State& state) {
+  const int N = state.range(0);
+  const int C = state.range(1);
+  const int H = state.range(2);
+
+  Tensor<Scalar, 4> A(N, C, H, H);
+  A.setRandom();
+
+  // NCHW -> NHWC: permute (0, 2, 3, 1)
+  Eigen::array<int, 4> perm = {0, 2, 3, 1};
+
+  for (auto _ : state) {
+    Tensor<Scalar, 4> B = A.shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * N * C * H * H * sizeof(Scalar) * 2);
+}
+
+// --- Expression-sourced shuffles (packet path) ---
+// An expression argument has no raw buffer, so the shuffle cannot use its
+// block path and serves packets instead. Permutations that preserve the
+// inner dimension load whole packets from one inner run; inner-shuffled
+// permutations gather, but still compute the index mapping once per packet.
+static void BM_ShuffleExprInnerPreserved(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+
+  // Permutation (0, 2, 1): the inner (first, ColMajor) dimension stays.
+  Eigen::array<int, 3> perm = {0, 2, 1};
+
+  Tensor<Scalar, 3> B;
+  for (auto _ : state) {
+    B = (A + A.constant(Scalar(1))).shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+
+  // Validate outside the timed loop.
+  for (int i = 0; i < D0; ++i) {
+    for (int j = 0; j < D2; ++j) {
+      for (int k = 0; k < D1; ++k) {
+        if (B(i, j, k) != A(i, k, j) + Scalar(1)) {
+          state.SkipWithError("validation failed");
+          return;
+        }
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * D2 * sizeof(Scalar) * 2);
+}
+
+static void BM_ShuffleExprInnerShuffled(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+
+  // Permutation (2, 0, 1): the inner dimension changes.
+  Eigen::array<int, 3> perm = {2, 0, 1};
+
+  Tensor<Scalar, 3> B;
+  for (auto _ : state) {
+    B = (A + A.constant(Scalar(1))).shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < D2; ++i) {
+    for (int j = 0; j < D0; ++j) {
+      for (int k = 0; k < D1; ++k) {
+        if (B(i, j, k) != A(j, k, i) + Scalar(1)) {
+          state.SkipWithError("validation failed");
+          return;
+        }
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * D2 * sizeof(Scalar) * 2);
+}
+
+// Lvalue: packet writes through a shuffled destination.
+static void BM_ShuffleWrite(benchmark::State& state) {
+  const int D0 = state.range(0);
+  const int D1 = state.range(1);
+  const int D2 = state.range(2);
+
+  // Destination shuffled with inner-preserving permutation (0, 2, 1).
+  Eigen::array<int, 3> perm = {0, 2, 1};
+
+  Tensor<Scalar, 3> src(D0, D2, D1);
+  src.setRandom();
+  Tensor<Scalar, 3> dst(D0, D1, D2);
+  dst.setZero();
+  Eigen::array<Index, 3> no_strides = {1, 1, 1};
+
+  for (auto _ : state) {
+    // Unit striding disables block evaluation while preserving packet access,
+    // forcing the shuffled lvalue's writePacket path.
+    dst.shuffle(perm) = src.stride(no_strides);
+    benchmark::DoNotOptimize(dst.data());
+    benchmark::ClobberMemory();
+  }
+
+  for (int i = 0; i < D0; ++i) {
+    for (int j = 0; j < D2; ++j) {
+      for (int k = 0; k < D1; ++k) {
+        if (dst(i, k, j) != src(i, j, k)) {
+          state.SkipWithError("validation failed");
+          return;
+        }
+      }
+    }
+  }
+  state.SetBytesProcessed(state.iterations() * D0 * D1 * D2 * sizeof(Scalar) * 2);
+}
+
+// --- ThreadPool variants ---
+
+static void BM_Shuffle2D_ThreadPool(benchmark::State& state) {
+  const int M = state.range(0);
+  const int N = state.range(1);
+  const int threads = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  Tensor<Scalar, 2> B(N, M);
+  A.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  Eigen::array<int, 2> perm = {1, 0};
+
+  for (auto _ : state) {
+    B.device(dev) = A.shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+static void BM_Shuffle4D_NCHW_to_NHWC_ThreadPool(benchmark::State& state) {
+  const int N = state.range(0);
+  const int C = state.range(1);
+  const int H = state.range(2);
+  const int threads = state.range(3);
+
+  Tensor<Scalar, 4> A(N, C, H, H);
+  Tensor<Scalar, 4> B(N, H, H, C);
+  A.setRandom();
+
+  ThreadPool tp(threads);
+  ThreadPoolDevice dev(&tp, threads);
+
+  // NCHW -> NHWC: permute (0, 2, 3, 1)
+  Eigen::array<int, 4> perm = {0, 2, 3, 1};
+
+  for (auto _ : state) {
+    B.device(dev) = A.shuffle(perm);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  state.SetBytesProcessed(state.iterations() * N * C * H * H * sizeof(Scalar) * 2);
+  state.counters["threads"] = threads;
+}
+
+// clang-format off
+#define SHUFFLE_2D_SIZES \
+  ->Args({256, 256})->Args({1024, 1024}) \
+  ->Args({64, 4096})->Args({4096, 64})
+
+#define SHUFFLE_3D_SIZES \
+  ->Args({64, 64, 64})->Args({128, 128, 64})->Args({32, 256, 256})
+
+// {batch, channels, h}: pure Cartesian product.
+#define SHUFFLE_4D_SIZES ->ArgsProduct({{1, 8}, {3, 64}, {32, 64}})
+
+#define SHUFFLE_2D_THREADPOOL_SIZES \
+  ->Args({256, 256, 1})->Args({256, 256, 2})->Args({256, 256, 4}) \
+  ->Args({256, 256, 8})->Args({256, 256, 12})->Args({256, 256, 16}) \
+  ->Args({1024, 1024, 1})->Args({1024, 1024, 2})->Args({1024, 1024, 4}) \
+  ->Args({1024, 1024, 8})->Args({1024, 1024, 12})->Args({1024, 1024, 16})
+
+// {batch, channels, h, threads}: pure Cartesian product.
+#define SHUFFLE_4D_THREADPOOL_SIZES ->ArgsProduct({{1, 8}, {64}, {32, 64}, {1, 2, 4, 8, 12, 16}})
+// clang-format on
+
+BENCHMARK(BM_Shuffle2D) SHUFFLE_2D_SIZES;
+BENCHMARK(BM_ShuffleIdentity) SHUFFLE_2D_SIZES;
+BENCHMARK(BM_Shuffle3D) SHUFFLE_3D_SIZES;
+BENCHMARK(BM_ShuffleExprInnerPreserved) SHUFFLE_3D_SIZES;
+BENCHMARK(BM_ShuffleExprInnerShuffled) SHUFFLE_3D_SIZES;
+BENCHMARK(BM_ShuffleWrite) SHUFFLE_3D_SIZES;
+BENCHMARK(BM_Shuffle4D_NCHW_to_NHWC) SHUFFLE_4D_SIZES;
+BENCHMARK(BM_Shuffle2D_ThreadPool) SHUFFLE_2D_THREADPOOL_SIZES->UseRealTime();
+BENCHMARK(BM_Shuffle4D_NCHW_to_NHWC_ThreadPool) SHUFFLE_4D_THREADPOOL_SIZES->UseRealTime();
diff --git a/contrib/benchmarks/Tensor/bench_striding.cpp b/contrib/benchmarks/Tensor/bench_striding.cpp
new file mode 100644
index 0000000..6b9efc0
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_striding.cpp
@@ -0,0 +1,215 @@
+// Benchmarks for Eigen Tensor striding (subsampling views).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+typedef float Scalar;
+
+// --- Rank-2 read, outer dimension strided (inner runs stay contiguous) ---
+static void BM_StrideReadOuter2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {1, S};  // ColMajor: dimension 0 is inner.
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.stride(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      if (B(i, j) != A(i, j * S)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Rank-2 read, inner dimension strided (gather within inner runs) ---
+static void BM_StrideReadInner2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {S, 1};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.stride(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      if (B(i, j) != A(i * S, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Identity striding (all strides 1, measures overhead) ---
+static void BM_StrideIdentity2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {1, 1};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = A.stride(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      if (B(i, j) != A(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Rank-3 read, all dimensions strided ---
+static void BM_StrideRead3D(benchmark::State& state) {
+  const Index D0 = state.range(0);
+  const Index D1 = state.range(1);
+  const Index D2 = state.range(2);
+
+  Tensor<Scalar, 3> A(D0, D1, D2);
+  A.setRandom();
+  Eigen::array<Index, 3> strides = {2, 2, 2};
+
+  Tensor<Scalar, 3> B;
+  for (auto _ : state) {
+    B = A.stride(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      for (Index k = 0; k < B.dimension(2); ++k) {
+        if (B(i, j, k) != A(i * 2, j * 2, k * 2)) {
+          state.SkipWithError("validation failed");
+          return;
+        }
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Expression-sourced read (no raw buffer behind the striding) ---
+static void BM_StrideExprInner2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, N);
+  A.setRandom();
+  Eigen::array<Index, 2> strides = {S, 1};
+
+  Tensor<Scalar, 2> B;
+  for (auto _ : state) {
+    B = (A + A.constant(Scalar(1))).stride(strides);
+    benchmark::DoNotOptimize(B.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < B.dimension(0); ++i) {
+    for (Index j = 0; j < B.dimension(1); ++j) {
+      if (B(i, j) != A(i * S, j) + Scalar(1)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * B.size());
+}
+
+// --- Rank-2 write through a strided destination ---
+static void BM_StrideWriteOuter2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A(M, (N + S - 1) / S);
+  A.setRandom();
+  Tensor<Scalar, 2> C(M, N);
+  C.setZero();
+  Eigen::array<Index, 2> strides = {1, S};
+
+  for (auto _ : state) {
+    C.stride(strides) = A;
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < A.dimension(0); ++i) {
+    for (Index j = 0; j < A.dimension(1); ++j) {
+      if (C(i, j * S) != A(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * A.size());
+}
+
+static void BM_StrideWriteInner2D(benchmark::State& state) {
+  const Index M = state.range(0);
+  const Index N = state.range(1);
+  const Index S = state.range(2);
+
+  Tensor<Scalar, 2> A((M + S - 1) / S, N);
+  A.setRandom();
+  Tensor<Scalar, 2> C(M, N);
+  C.setZero();
+  Eigen::array<Index, 2> strides = {S, 1};
+
+  for (auto _ : state) {
+    C.stride(strides) = A;
+    benchmark::DoNotOptimize(C.data());
+    benchmark::ClobberMemory();
+  }
+  for (Index i = 0; i < A.dimension(0); ++i) {
+    for (Index j = 0; j < A.dimension(1); ++j) {
+      if (C(i * S, j) != A(i, j)) {
+        state.SkipWithError("validation failed");
+        return;
+      }
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * A.size());
+}
+
+// clang-format off
+#define STRIDE_2D_SIZES ->ArgsProduct({{256, 1024}, {1024}, {2, 4}})
+#define STRIDE_2D_PLAIN_SIZES ->Args({256, 1024})->Args({1024, 1024})
+#define STRIDE_3D_SIZES ->Args({64, 64, 64})->Args({128, 128, 64})
+// clang-format on
+
+BENCHMARK(BM_StrideReadOuter2D) STRIDE_2D_SIZES;
+BENCHMARK(BM_StrideReadInner2D) STRIDE_2D_SIZES;
+BENCHMARK(BM_StrideIdentity2D) STRIDE_2D_PLAIN_SIZES;
+BENCHMARK(BM_StrideRead3D) STRIDE_3D_SIZES;
+BENCHMARK(BM_StrideExprInner2D) STRIDE_2D_SIZES;
+BENCHMARK(BM_StrideWriteOuter2D) STRIDE_2D_SIZES;
+BENCHMARK(BM_StrideWriteInner2D) STRIDE_2D_SIZES;
diff --git a/contrib/benchmarks/Tensor/bench_tensor_fft.cpp b/contrib/benchmarks/Tensor/bench_tensor_fft.cpp
new file mode 100644
index 0000000..193b1ab
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_tensor_fft.cpp
@@ -0,0 +1,171 @@
+// Benchmarks for Eigen Tensor FFT.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <benchmark/benchmark.h>
+#include <contrib/Eigen/Tensor>
+
+using namespace Eigen;
+
+#ifndef SCALAR
+#define SCALAR float
+#endif
+
+typedef SCALAR Scalar;
+
+// 5*N*log2(N) is the conventional flop count for a length-N complex FFT.
+static double FFTFlops(double n) { return 5.0 * n * std::log2(n); }
+
+// --- 1D FFT (real input, complex output) ---
+static void BM_TensorFFT_1D(benchmark::State& state) {
+  const int N = state.range(0);
+  Tensor<Scalar, 1> input(N);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 1> result(N);
+  Eigen::array<int, 1> fft_dims = {0};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] =
+      benchmark::Counter(FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- 1D FFT (complex input, complex output) ---
+static void BM_TensorFFT_1D_C2C(benchmark::State& state) {
+  const int N = state.range(0);
+  Tensor<std::complex<Scalar>, 1> input(N);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 1> result(N);
+  Eigen::array<int, 1> fft_dims = {0};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] =
+      benchmark::Counter(FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- 1D inverse FFT ---
+static void BM_TensorIFFT_1D(benchmark::State& state) {
+  const int N = state.range(0);
+  Tensor<std::complex<Scalar>, 1> input(N);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 1> result(N);
+  Eigen::array<int, 1> fft_dims = {0};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_REVERSE>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] =
+      benchmark::Counter(FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- 2D FFT (square) ---
+static void BM_TensorFFT_2D(benchmark::State& state) {
+  const int N = state.range(0);
+  Tensor<Scalar, 2> input(N, N);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 2> result(N, N);
+  Eigen::array<int, 2> fft_dims = {0, 1};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  // A length-N 2D FFT is 2N length-N 1D FFTs.
+  state.counters["MFLOPS"] = benchmark::Counter(2.0 * N * FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate,
+                                                benchmark::Counter::kIs1000);
+}
+
+// --- Batched 1D FFT along contiguous (innermost) dim ---
+// Many parallel transforms; tests per-line setup overhead amortization.
+static void BM_TensorFFT_Batched_Inner(benchmark::State& state) {
+  const int N = state.range(0);
+  const int batch = state.range(1);
+  // ColMajor: dim 0 is innermost (stride 1).
+  Tensor<std::complex<Scalar>, 2> input(N, batch);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 2> result(N, batch);
+  Eigen::array<int, 1> fft_dims = {0};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] = benchmark::Counter(batch * FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate,
+                                                benchmark::Counter::kIs1000);
+}
+
+// --- Batched 1D FFT along strided (outer) dim ---
+// Stride != 1; exercises the gather/scatter copy path in evalToBuf.
+static void BM_TensorFFT_Batched_Outer(benchmark::State& state) {
+  const int N = state.range(0);
+  const int batch = state.range(1);
+  // ColMajor: dim 1 is outermost (stride = batch_inner).
+  Tensor<std::complex<Scalar>, 2> input(batch, N);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 2> result(batch, N);
+  Eigen::array<int, 1> fft_dims = {1};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] = benchmark::Counter(batch * FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate,
+                                                benchmark::Counter::kIs1000);
+}
+
+// --- 1D Bluestein (non-power-of-2) ---
+static void BM_TensorFFT_1D_Bluestein(benchmark::State& state) {
+  const int N = state.range(0);
+  Tensor<std::complex<Scalar>, 1> input(N);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 1> result(N);
+  Eigen::array<int, 1> fft_dims = {0};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] =
+      benchmark::Counter(FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
+}
+
+// --- Batched Bluestein (non-power-of-2, contiguous inner dim) ---
+// Same b-sequence FFT shared by every line; tests the per-dim caching path.
+static void BM_TensorFFT_Bluestein_Batched(benchmark::State& state) {
+  const int N = state.range(0);
+  const int batch = state.range(1);
+  Tensor<std::complex<Scalar>, 2> input(N, batch);
+  input.setRandom();
+  Tensor<std::complex<Scalar>, 2> result(N, batch);
+  Eigen::array<int, 1> fft_dims = {0};
+  for (auto _ : state) {
+    result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
+    benchmark::DoNotOptimize(result.data());
+    benchmark::ClobberMemory();
+  }
+  state.counters["MFLOPS"] = benchmark::Counter(batch * FFTFlops(N), benchmark::Counter::kIsIterationInvariantRate,
+                                                benchmark::Counter::kIs1000);
+}
+
+// clang-format off
+#define POW2_SIZES      ->Arg(64)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384)->Arg(65536)
+#define POW2_2D         ->Arg(64)->Arg(256)->Arg(1024)
+#define BLUESTEIN       ->Arg(100)->Arg(1000)->Arg(4099)
+#define BATCH_SIZES     ->Args({64,64})->Args({256,64})->Args({1024,64})->Args({4096,64})
+#define BLUESTEIN_BATCH ->Args({100,64})->Args({1000,64})->Args({4099,32})
+// clang-format on
+
+BENCHMARK(BM_TensorFFT_1D) POW2_SIZES;
+BENCHMARK(BM_TensorFFT_1D_C2C) POW2_SIZES;
+BENCHMARK(BM_TensorIFFT_1D) POW2_SIZES;
+BENCHMARK(BM_TensorFFT_2D) POW2_2D;
+BENCHMARK(BM_TensorFFT_Batched_Inner) BATCH_SIZES;
+BENCHMARK(BM_TensorFFT_Batched_Outer) BATCH_SIZES;
+BENCHMARK(BM_TensorFFT_1D_Bluestein) BLUESTEIN;
+BENCHMARK(BM_TensorFFT_Bluestein_Batched) BLUESTEIN_BATCH;
diff --git a/contrib/benchmarks/Tensor/bench_threadpool_device.cpp b/contrib/benchmarks/Tensor/bench_threadpool_device.cpp
new file mode 100644
index 0000000..3aba55a
--- /dev/null
+++ b/contrib/benchmarks/Tensor/bench_threadpool_device.cpp
@@ -0,0 +1,133 @@
+// Microbenchmarks for ThreadPoolDevice scheduling overhead.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <mutex>
+
+#include <benchmark/benchmark.h>
+#include <Eigen/ThreadPool>
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Index;
+using Eigen::TensorOpCost;
+using Eigen::ThreadPool;
+using Eigen::ThreadPoolDevice;
+
+// Returns a per-thread-count singleton device, lazily created on first use.
+// Pools are reused across benchmark iterations so thread-creation cost does
+// not enter the measurement, and varying thread counts across benchmarks is
+// supported without later calls silently colliding with the first one.
+static ThreadPoolDevice& device(int threads) {
+  static std::mutex mu;
+  static std::map<int, std::unique_ptr<ThreadPool>> pools;
+  static std::map<int, std::unique_ptr<ThreadPoolDevice>> devs;
+  std::lock_guard<std::mutex> lock(mu);
+  auto it = devs.find(threads);
+  if (it != devs.end()) return *it->second;
+  auto pool = std::unique_ptr<ThreadPool>(new ThreadPool(threads));
+  auto* dev = new ThreadPoolDevice(pool.get(), threads);
+  pools.emplace(threads, std::move(pool));
+  devs.emplace(threads, std::unique_ptr<ThreadPoolDevice>(dev));
+  return *dev;
+}
+
+// ---- enqueue overhead: empty lambda, wait via shared counter -------------
+static void BM_EnqueueEmpty(benchmark::State& state) {
+  const int threads = state.range(0);
+  auto& dev = device(threads);
+  const int batch = 1024;
+  for (auto _ : state) {
+    std::atomic<int> remaining{batch};
+    for (int i = 0; i < batch; ++i) {
+      dev.enqueue([&remaining] { remaining.fetch_sub(1, std::memory_order_release); });
+    }
+    while (remaining.load(std::memory_order_acquire) != 0) {
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * batch);
+  state.counters["threads"] = threads;
+}
+BENCHMARK(BM_EnqueueEmpty)->Arg(8)->UseRealTime();
+
+// ---- parallelFor with tiny per-element cost: dispatch overhead dominates --
+static void BM_ParallelForTiny(benchmark::State& state) {
+  const Index n = state.range(0);
+  const int threads = state.range(1);
+  auto& dev = device(threads);
+  // Cost just large enough that the cost model decides to parallelize.
+  const TensorOpCost cost(/*bytes_loaded=*/4, /*bytes_stored=*/4, /*compute_cycles=*/4);
+  std::atomic<Index> sink{0};
+  for (auto _ : state) {
+    dev.parallelFor(n, cost,
+                    [&sink](Index first, Index last) { sink.fetch_add(last - first, std::memory_order_relaxed); });
+  }
+  benchmark::DoNotOptimize(sink.load());
+  state.SetItemsProcessed(state.iterations() * n);
+  state.counters["threads"] = threads;
+}
+BENCHMARK(BM_ParallelForTiny)->Args({256, 8})->Args({4096, 8})->Args({65536, 8})->Args({1048576, 8})->UseRealTime();
+
+// ---- parallelFor with realistic per-element compute work ------------------
+static void BM_ParallelForCompute(benchmark::State& state) {
+  const Index n = state.range(0);
+  const int threads = state.range(1);
+  auto& dev = device(threads);
+  const TensorOpCost cost(/*bytes_loaded=*/8, /*bytes_stored=*/8, /*compute_cycles=*/32);
+  std::vector<double> data(n, 1.0);
+  for (auto _ : state) {
+    dev.parallelFor(n, cost, [&data](Index first, Index last) {
+      for (Index i = first; i < last; ++i) {
+        data[i] = data[i] * 1.0000001 + 1e-12;
+      }
+    });
+    benchmark::DoNotOptimize(data.data());
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+  state.counters["threads"] = threads;
+}
+BENCHMARK(BM_ParallelForCompute)->Args({4096, 8})->Args({65536, 8})->Args({1048576, 8})->UseRealTime();
+
+// ---- parallelForAsync: measures async dispatch + heap context overhead ----
+static void BM_ParallelForAsync(benchmark::State& state) {
+  const Index n = state.range(0);
+  const int threads = state.range(1);
+  auto& dev = device(threads);
+  const TensorOpCost cost(8, 8, 4);
+  for (auto _ : state) {
+    std::atomic<int> done_flag{0};
+    dev.parallelForAsync(
+        n, cost, [](Index, Index) {}, [&done_flag] { done_flag.store(1, std::memory_order_release); });
+    while (done_flag.load(std::memory_order_acquire) == 0) {
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * n);
+  state.counters["threads"] = threads;
+}
+BENCHMARK(BM_ParallelForAsync)->Args({4096, 8})->Args({65536, 8})->Args({1048576, 8})->UseRealTime();
+
+// ---- ThreadPoolDevice::memcpy at various sizes ----------------------------
+static void BM_DeviceMemcpy(benchmark::State& state) {
+  const size_t bytes = state.range(0);
+  const int threads = state.range(1);
+  auto& dev = device(threads);
+  std::vector<char> src(bytes), dst(bytes);
+  for (auto _ : state) {
+    dev.memcpy(dst.data(), src.data(), bytes);
+    benchmark::DoNotOptimize(dst.data());
+  }
+  state.SetBytesProcessed(state.iterations() * bytes);
+  state.counters["threads"] = threads;
+}
+BENCHMARK(BM_DeviceMemcpy)
+    ->Args({16 << 10, 8})
+    ->Args({256 << 10, 8})
+    ->Args({4 << 20, 8})
+    ->Args({64 << 20, 8})
+    ->UseRealTime();
+
+BENCHMARK_MAIN();
diff --git a/contrib/doc/AutoDiff.dox b/contrib/doc/AutoDiff.dox
new file mode 100644
index 0000000..dfda1cf
--- /dev/null
+++ b/contrib/doc/AutoDiff.dox
@@ -0,0 +1,37 @@
+namespace Eigen {
+
+/** \page AutoDiffExamples AutoDiff examples
+
+This page shows basic uses of the \ref AutoDiff_Module.
+
+\section AutoDiffScalarExample Tracking first derivatives
+
+AutoDiffScalar stores a scalar value together with its derivatives. The derivative vector size is the number of
+independent variables. A common pattern is to seed each independent variable with one unit vector:
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr><td>
+\include AutoDiffScalarExample.cpp
+</td>
+<td>
+\verbinclude AutoDiffScalarExample.out
+</td></tr></table>
+
+\section AutoDiffJacobianExample Computing a Jacobian
+
+AutoDiffJacobian wraps a functor whose operator() is templated on the scalar type. Calling it with a Jacobian pointer
+evaluates the functor with active AutoDiffScalar inputs and fills both the value and Jacobian:
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr><td>
+\include AutoDiffJacobianExample.cpp
+</td>
+<td>
+\verbinclude AutoDiffJacobianExample.out
+</td></tr></table>
+
+*/
+
+}
diff --git a/contrib/doc/CMakeLists.txt b/contrib/doc/CMakeLists.txt
new file mode 100644
index 0000000..b1d43d4
--- /dev/null
+++ b/contrib/doc/CMakeLists.txt
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL TRUE)
+
+add_subdirectory(examples)
+add_subdirectory(snippets)
diff --git a/contrib/doc/Overview.dox b/contrib/doc/Overview.dox
new file mode 100644
index 0000000..14228d1
--- /dev/null
+++ b/contrib/doc/Overview.dox
@@ -0,0 +1,32 @@
+/// \brief Namespace containing all symbols from the %Eigen library.
+namespace Eigen {
+
+/** \mainpage notitle
+
+This is the API documentation for %Eigen's contrib modules.
+
+These modules are contributions from various users. They are provided "as is", without any support.
+
+Click on the \e Modules tab at the top of this page to get a list of all contrib modules.
+
+Don't miss the <a href="../index.html">official Eigen documentation</a>.
+
+ \subpage AutoDiffExamples "AutoDiff examples"
+
+ \subpage SYCL_EIGEN "SYCL backend for Eigen"
+
+*/
+
+/*
+
+\defgroup Contributed_modules Contributed modules
+
+The contrib modules are contributions from various users. They are
+provided "as is", without any support. Nevertheless, some of them are
+subject to be included in %Eigen in the future.
+
+*/
+
+/// \internal \brief Namespace containing low-level routines from the %Eigen library.
+namespace internal {}
+}
diff --git a/unsupported/doc/SYCL.dox b/contrib/doc/SYCL.dox
similarity index 100%
rename from unsupported/doc/SYCL.dox
rename to contrib/doc/SYCL.dox
diff --git a/unsupported/doc/eigendoxy_layout.xml.in b/contrib/doc/eigendoxy_layout.xml.in
similarity index 100%
rename from unsupported/doc/eigendoxy_layout.xml.in
rename to contrib/doc/eigendoxy_layout.xml.in
diff --git a/contrib/doc/examples/AutoDiffJacobianExample.cpp b/contrib/doc/examples/AutoDiffJacobianExample.cpp
new file mode 100644
index 0000000..45b4bcb
--- /dev/null
+++ b/contrib/doc/examples/AutoDiffJacobianExample.cpp
@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <Eigen/Dense>
+#include <cmath>
+#include <iostream>
+#include <contrib/Eigen/AutoDiff>
+
+struct ExampleFunctor {
+  typedef Eigen::Vector2d InputType;
+  typedef Eigen::Vector2d ValueType;
+
+  template <typename Scalar>
+  void operator()(const Eigen::Matrix<Scalar, 2, 1>& x, Eigen::Matrix<Scalar, 2, 1>* y) const {
+    using std::sin;
+    (*y)[0] = x[0] * x[0] + x[1];
+    (*y)[1] = x[0] * sin(x[1]);
+  }
+};
+
+int main() {
+  Eigen::AutoDiffJacobian<ExampleFunctor> functor;
+  Eigen::Vector2d x;
+  Eigen::Vector2d y;
+  Eigen::AutoDiffJacobian<ExampleFunctor>::JacobianType jacobian;
+
+  x << 2.0, 0.5;
+  functor(x, &y, &jacobian);
+
+  std::cout << "value:\n" << y << "\n\n";
+  std::cout << "jacobian:\n" << jacobian << "\n";
+}
diff --git a/contrib/doc/examples/AutoDiffScalarExample.cpp b/contrib/doc/examples/AutoDiffScalarExample.cpp
new file mode 100644
index 0000000..99f0690
--- /dev/null
+++ b/contrib/doc/examples/AutoDiffScalarExample.cpp
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <Eigen/Dense>
+#include <cmath>
+#include <iostream>
+#include <contrib/Eigen/AutoDiff>
+
+template <typename Scalar>
+Scalar f(const Scalar& x, const Scalar& y) {
+  using std::sin;
+  return x * x * y + sin(y);
+}
+
+int main() {
+  typedef Eigen::AutoDiffScalar<Eigen::Vector2d> ADScalar;
+
+  ADScalar x(2.0, Eigen::Vector2d::UnitX());
+  ADScalar y(0.5, Eigen::Vector2d::UnitY());
+  ADScalar z = f(x, y);
+
+  std::cout << "f(x,y) = " << z.value() << "\n";
+  std::cout << "df/dx  = " << z.derivatives()[0] << "\n";
+  std::cout << "df/dy  = " << z.derivatives()[1] << "\n";
+}
diff --git a/contrib/doc/examples/BVH_Example.cpp b/contrib/doc/examples/BVH_Example.cpp
new file mode 100644
index 0000000..9768c59
--- /dev/null
+++ b/contrib/doc/examples/BVH_Example.cpp
@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <Eigen/StdVector>
+#include <contrib/Eigen/BVH>
+#include <iostream>
+
+using namespace Eigen;
+typedef AlignedBox<double, 2> Box2d;
+
+namespace Eigen {
+Box2d bounding_box(const Vector2d &v) { return Box2d(v, v); }  // compute the bounding box of a single point
+}  // namespace Eigen
+
+struct PointPointMinimizer  // how to compute squared distances between points and rectangles
+{
+  PointPointMinimizer() : calls(0) {}
+  typedef double Scalar;
+
+  double minimumOnVolumeVolume(const Box2d &r1, const Box2d &r2) {
+    ++calls;
+    return r1.squaredExteriorDistance(r2);
+  }
+  double minimumOnVolumeObject(const Box2d &r, const Vector2d &v) {
+    ++calls;
+    return r.squaredExteriorDistance(v);
+  }
+  double minimumOnObjectVolume(const Vector2d &v, const Box2d &r) {
+    ++calls;
+    return r.squaredExteriorDistance(v);
+  }
+  double minimumOnObjectObject(const Vector2d &v1, const Vector2d &v2) {
+    ++calls;
+    return (v1 - v2).squaredNorm();
+  }
+
+  int calls;
+};
+
+int main() {
+  typedef std::vector<Vector2d, aligned_allocator<Vector2d> > StdVectorOfVector2d;
+  StdVectorOfVector2d redPoints, bluePoints;
+  for (int i = 0; i < 100; ++i) {  // initialize random set of red points and blue points
+    redPoints.push_back(Vector2d::Random());
+    bluePoints.push_back(Vector2d::Random());
+  }
+
+  PointPointMinimizer minimizer;
+  double minDistSq = std::numeric_limits<double>::max();
+
+  // brute force to find closest red-blue pair
+  for (int i = 0; i < (int)redPoints.size(); ++i)
+    for (int j = 0; j < (int)bluePoints.size(); ++j)
+      minDistSq = std::min(minDistSq, minimizer.minimumOnObjectObject(redPoints[i], bluePoints[j]));
+  std::cout << "Brute force distance = " << sqrt(minDistSq) << ", calls = " << minimizer.calls << std::endl;
+
+  // using BVH to find closest red-blue pair
+  minimizer.calls = 0;
+  KdBVH<double, 2, Vector2d> redTree(redPoints.begin(), redPoints.end()),
+      blueTree(bluePoints.begin(), bluePoints.end());    // construct the trees
+  minDistSq = BVMinimize(redTree, blueTree, minimizer);  // actual BVH minimization call
+  std::cout << "BVH distance         = " << sqrt(minDistSq) << ", calls = " << minimizer.calls << std::endl;
+
+  return 0;
+}
diff --git a/contrib/doc/examples/CMakeLists.txt b/contrib/doc/examples/CMakeLists.txt
new file mode 100644
index 0000000..a684712
--- /dev/null
+++ b/contrib/doc/examples/CMakeLists.txt
@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+file(GLOB examples_SRCS "*.cpp")
+
+add_custom_target(contrib_examples)
+
+foreach(example_src ${examples_SRCS})
+  get_filename_component(example ${example_src} NAME_WE)
+  add_executable(example_${example} ${example_src})
+  if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
+    target_link_libraries(example_${example} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
+  endif()
+  target_link_libraries(example_${example}  Eigen3::Eigen)
+  add_custom_command(
+    TARGET example_${example}
+    POST_BUILD
+    COMMAND example_${example}
+    ARGS >${CMAKE_CURRENT_BINARY_DIR}/${example}.out
+  )
+  add_dependencies(contrib_examples example_${example})
+endforeach(example_src)
+
+if(EIGEN_TEST_SYCL)
+  add_subdirectory(SYCL)
+endif(EIGEN_TEST_SYCL)
diff --git a/contrib/doc/examples/EulerAngles.cpp b/contrib/doc/examples/EulerAngles.cpp
new file mode 100644
index 0000000..5fb6dee
--- /dev/null
+++ b/contrib/doc/examples/EulerAngles.cpp
@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/EulerAngles>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  // A common Euler system by many armies around the world,
+  //  where the first one is the azimuth(the angle from the north -
+  //   the same angle that is show in compass)
+  //  and the second one is elevation(the angle from the horizon)
+  //  and the third one is roll(the angle between the horizontal body
+  //   direction and the plane ground surface)
+  // Keep remembering we're using radian angles here!
+  typedef EulerSystem<-EULER_Z, EULER_Y, EULER_X> MyArmySystem;
+  typedef EulerAngles<double, MyArmySystem> MyArmyAngles;
+
+  MyArmyAngles vehicleAngles(3.14 /*PI*/ / 2, /* heading to east, notice that this angle is counter-clockwise */
+                             -0.3,            /* going down from a mountain */
+                             0.1);            /* slightly rolled to the right */
+
+  // Some Euler angles representation that our plane use.
+  EulerAnglesZYZd planeAngles(0.78474, 0.5271, -0.513794);
+
+  MyArmyAngles planeAnglesInMyArmyAngles(planeAngles);
+
+  std::cout << "vehicle angles(MyArmy):     " << vehicleAngles << std::endl;
+  std::cout << "plane angles(ZYZ):        " << planeAngles << std::endl;
+  std::cout << "plane angles(MyArmy):     " << planeAnglesInMyArmyAngles << std::endl;
+
+  // Now lets rotate the plane a little bit
+  std::cout << "==========================================================\n";
+  std::cout << "rotating plane now!\n";
+  std::cout << "==========================================================\n";
+
+  Quaterniond planeRotated = AngleAxisd(-0.342, Vector3d::UnitY()) * planeAngles;
+
+  planeAngles = planeRotated;
+  planeAnglesInMyArmyAngles = planeRotated;
+
+  std::cout << "new plane angles(ZYZ):     " << planeAngles << std::endl;
+  std::cout << "new plane angles(MyArmy): " << planeAnglesInMyArmyAngles << std::endl;
+
+  return 0;
+}
diff --git a/contrib/doc/examples/FFT.cpp b/contrib/doc/examples/FFT.cpp
new file mode 100644
index 0000000..220ad34
--- /dev/null
+++ b/contrib/doc/examples/FFT.cpp
@@ -0,0 +1,105 @@
+//  To use the simple FFT implementation
+//  g++ -o demofft -I.. -Wall -O3 FFT.cpp
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+//  To use the FFTW implementation
+//  g++ -o demofft -I.. -DUSE_FFTW -Wall -O3 FFT.cpp -lfftw3 -lfftw3f -lfftw3l
+
+#ifdef USE_FFTW
+#include <fftw3.h>
+#endif
+
+#include <vector>
+#include <complex>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+#include <Eigen/Core>
+#include <contrib/Eigen/FFT>
+
+using namespace std;
+using namespace Eigen;
+
+template <typename T>
+T mag2(T a) {
+  return a * a;
+}
+template <typename T>
+T mag2(std::complex<T> a) {
+  return norm(a);
+}
+
+template <typename T>
+T mag2(const std::vector<T>& vec) {
+  T out = 0;
+  for (size_t k = 0; k < vec.size(); ++k) out += mag2(vec[k]);
+  return out;
+}
+
+template <typename T>
+T mag2(const std::vector<std::complex<T> >& vec) {
+  T out = 0;
+  for (size_t k = 0; k < vec.size(); ++k) out += mag2(vec[k]);
+  return out;
+}
+
+template <typename T>
+vector<T> operator-(const vector<T>& a, const vector<T>& b) {
+  vector<T> c(a);
+  for (size_t k = 0; k < b.size(); ++k) c[k] -= b[k];
+  return c;
+}
+
+template <typename T>
+void RandomFill(std::vector<T>& vec) {
+  for (size_t k = 0; k < vec.size(); ++k) vec[k] = T(rand()) / T(RAND_MAX) - T(.5);
+}
+
+template <typename T>
+void RandomFill(std::vector<std::complex<T> >& vec) {
+  for (size_t k = 0; k < vec.size(); ++k)
+    vec[k] = std::complex<T>(T(rand()) / T(RAND_MAX) - T(.5), T(rand()) / T(RAND_MAX) - T(.5));
+}
+
+template <typename T_time, typename T_freq>
+void fwd_inv(size_t nfft) {
+  typedef typename NumTraits<T_freq>::Real Scalar;
+  vector<T_time> timebuf(nfft);
+  RandomFill(timebuf);
+
+  vector<T_freq> freqbuf;
+  static FFT<Scalar> fft;
+  fft.fwd(freqbuf, timebuf);
+
+  vector<T_time> timebuf2;
+  fft.inv(timebuf2, freqbuf);
+
+  T_time rmse = mag2(timebuf - timebuf2) / mag2(timebuf);
+  cout << "roundtrip rmse: " << rmse << endl;
+}
+
+template <typename T_scalar>
+void two_demos(int nfft) {
+  cout << "     scalar ";
+  fwd_inv<T_scalar, std::complex<T_scalar> >(nfft);
+  cout << "    complex ";
+  fwd_inv<std::complex<T_scalar>, std::complex<T_scalar> >(nfft);
+}
+
+void demo_all_types(int nfft) {
+  cout << "nfft=" << nfft << endl;
+  cout << "   float" << endl;
+  two_demos<float>(nfft);
+  cout << "   double" << endl;
+  two_demos<double>(nfft);
+  cout << "   long double" << endl;
+  two_demos<long double>(nfft);
+}
+
+int main() {
+  demo_all_types(2 * 3 * 4 * 5 * 7);
+  demo_all_types(2 * 9 * 16 * 25);
+  demo_all_types(1024);
+  return 0;
+}
diff --git a/contrib/doc/examples/MatrixExponential.cpp b/contrib/doc/examples/MatrixExponential.cpp
new file mode 100644
index 0000000..25143d2
--- /dev/null
+++ b/contrib/doc/examples/MatrixExponential.cpp
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  const double pi = std::acos(-1.0);
+
+  MatrixXd A(3, 3);
+  A << 0, -pi / 4, 0, pi / 4, 0, 0, 0, 0, 0;
+  std::cout << "The matrix A is:\n" << A << "\n\n";
+  std::cout << "The matrix exponential of A is:\n" << A.exp() << "\n\n";
+}
diff --git a/contrib/doc/examples/MatrixFunction.cpp b/contrib/doc/examples/MatrixFunction.cpp
new file mode 100644
index 0000000..aeac506
--- /dev/null
+++ b/contrib/doc/examples/MatrixFunction.cpp
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+std::complex<double> expfn(std::complex<double> x, int) { return std::exp(x); }
+
+int main() {
+  const double pi = std::acos(-1.0);
+
+  MatrixXd A(3, 3);
+  A << 0, -pi / 4, 0, pi / 4, 0, 0, 0, 0, 0;
+
+  std::cout << "The matrix A is:\n" << A << "\n\n";
+  std::cout << "The matrix exponential of A is:\n" << A.matrixFunction(expfn) << "\n\n";
+}
diff --git a/contrib/doc/examples/MatrixLogarithm.cpp b/contrib/doc/examples/MatrixLogarithm.cpp
new file mode 100644
index 0000000..dee2471
--- /dev/null
+++ b/contrib/doc/examples/MatrixLogarithm.cpp
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  using std::sqrt;
+  MatrixXd A(3, 3);
+  A << 0.5 * sqrt(2), -0.5 * sqrt(2), 0, 0.5 * sqrt(2), 0.5 * sqrt(2), 0, 0, 0, 1;
+  std::cout << "The matrix A is:\n" << A << "\n\n";
+  std::cout << "The matrix logarithm of A is:\n" << A.log() << "\n";
+}
diff --git a/contrib/doc/examples/MatrixPower.cpp b/contrib/doc/examples/MatrixPower.cpp
new file mode 100644
index 0000000..da776a1
--- /dev/null
+++ b/contrib/doc/examples/MatrixPower.cpp
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  const double pi = std::acos(-1.0);
+  Matrix3d A;
+  A << cos(1), -sin(1), 0, sin(1), cos(1), 0, 0, 0, 1;
+  std::cout << "The matrix A is:\n"
+            << A
+            << "\n\n"
+               "The matrix power A^(pi/4) is:\n"
+            << A.pow(pi / 4) << std::endl;
+  return 0;
+}
diff --git a/contrib/doc/examples/MatrixPower_optimal.cpp b/contrib/doc/examples/MatrixPower_optimal.cpp
new file mode 100644
index 0000000..fba0b86
--- /dev/null
+++ b/contrib/doc/examples/MatrixPower_optimal.cpp
@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  Matrix4cd A = Matrix4cd::Random();
+  MatrixPower<Matrix4cd> Apow(A);
+
+  std::cout << "The matrix A is:\n"
+            << A
+            << "\n\n"
+               "A^3.1 is:\n"
+            << Apow(3.1)
+            << "\n\n"
+               "A^3.3 is:\n"
+            << Apow(3.3)
+            << "\n\n"
+               "A^3.7 is:\n"
+            << Apow(3.7)
+            << "\n\n"
+               "A^3.9 is:\n"
+            << Apow(3.9) << std::endl;
+  return 0;
+}
diff --git a/contrib/doc/examples/MatrixSine.cpp b/contrib/doc/examples/MatrixSine.cpp
new file mode 100644
index 0000000..5abeaad
--- /dev/null
+++ b/contrib/doc/examples/MatrixSine.cpp
@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  MatrixXd A = MatrixXd::Random(3, 3);
+  std::cout << "A = \n" << A << "\n\n";
+
+  MatrixXd sinA = A.sin();
+  std::cout << "sin(A) = \n" << sinA << "\n\n";
+
+  MatrixXd cosA = A.cos();
+  std::cout << "cos(A) = \n" << cosA << "\n\n";
+
+  // The matrix functions satisfy sin^2(A) + cos^2(A) = I,
+  // like the scalar functions.
+  std::cout << "sin^2(A) + cos^2(A) = \n" << sinA * sinA + cosA * cosA << "\n\n";
+}
diff --git a/contrib/doc/examples/MatrixSinh.cpp b/contrib/doc/examples/MatrixSinh.cpp
new file mode 100644
index 0000000..d9b0816
--- /dev/null
+++ b/contrib/doc/examples/MatrixSinh.cpp
@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  MatrixXf A = MatrixXf::Random(3, 3);
+  std::cout << "A = \n" << A << "\n\n";
+
+  MatrixXf sinhA = A.sinh();
+  std::cout << "sinh(A) = \n" << sinhA << "\n\n";
+
+  MatrixXf coshA = A.cosh();
+  std::cout << "cosh(A) = \n" << coshA << "\n\n";
+
+  // The matrix functions satisfy cosh^2(A) - sinh^2(A) = I,
+  // like the scalar functions.
+  std::cout << "cosh^2(A) - sinh^2(A) = \n" << coshA * coshA - sinhA * sinhA << "\n\n";
+}
diff --git a/contrib/doc/examples/MatrixSquareRoot.cpp b/contrib/doc/examples/MatrixSquareRoot.cpp
new file mode 100644
index 0000000..2f054ff
--- /dev/null
+++ b/contrib/doc/examples/MatrixSquareRoot.cpp
@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/MatrixFunctions>
+#include <iostream>
+
+using namespace Eigen;
+
+int main() {
+  const double pi = std::acos(-1.0);
+
+  MatrixXd A(2, 2);
+  A << cos(pi / 3), -sin(pi / 3), sin(pi / 3), cos(pi / 3);
+  std::cout << "The matrix A is:\n" << A << "\n\n";
+  std::cout << "The matrix square root of A is:\n" << A.sqrt() << "\n\n";
+  std::cout << "The square of the last matrix is:\n" << A.sqrt() * A.sqrt() << "\n";
+}
diff --git a/contrib/doc/examples/PolynomialSolver1.cpp b/contrib/doc/examples/PolynomialSolver1.cpp
new file mode 100644
index 0000000..911e059
--- /dev/null
+++ b/contrib/doc/examples/PolynomialSolver1.cpp
@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/Polynomials>
+#include <vector>
+#include <iostream>
+
+using namespace Eigen;
+using namespace std;
+
+int main() {
+  typedef Matrix<double, 5, 1> Vector5d;
+
+  Vector5d roots = Vector5d::Random();
+  cout << "Roots: " << roots.transpose() << endl;
+  Eigen::Matrix<double, 6, 1> polynomial;
+  roots_to_monicPolynomial(roots, polynomial);
+
+  PolynomialSolver<double, 5> psolve(polynomial);
+  cout << "Complex roots: " << psolve.roots().transpose() << endl;
+
+  std::vector<double> realRoots;
+  psolve.realRoots(realRoots);
+  Map<Vector5d> mapRR(&realRoots[0]);
+  cout << "Real roots: " << mapRR.transpose() << endl;
+
+  cout << endl;
+  cout << "A float polynomial with almost conjugate roots of almost the same modulus: " << endl;
+  cout << "--------------------------------------------------------------------------" << endl;
+  Eigen::Matrix<float, 7, 1> hardCase_polynomial;
+  hardCase_polynomial << -0.957, 0.9219, 0.3516, 0.9453, -0.4023, -0.5508, -0.03125;
+  cout << "Hard case polynomial defined by floats: " << hardCase_polynomial.transpose() << endl;
+  PolynomialSolver<float, 6> psolvef(hardCase_polynomial);
+  cout << "Complex roots: " << psolvef.roots().transpose() << endl;
+  Eigen::Matrix<float, 6, 1> evals;
+  for (int i = 0; i < 6; ++i) {
+    evals[i] = std::abs(poly_eval(hardCase_polynomial, psolvef.roots()[i]));
+  }
+  cout << "Norms of the evaluations of the polynomial at the roots: " << evals.transpose() << endl << endl;
+
+  cout << "The same polynomial solved with doubles: " << endl;
+  cout << "----------------------------------------" << endl;
+  PolynomialSolver<double, 6> psolve6d(hardCase_polynomial.cast<double>());
+  cout << "Complex roots: " << psolve6d.roots().transpose() << endl;
+  for (int i = 0; i < 6; ++i) {
+    std::complex<float> castedRoot(psolve6d.roots()[i].real(), psolve6d.roots()[i].imag());
+    evals[i] = std::abs(poly_eval(hardCase_polynomial, castedRoot));
+  }
+  cout << "Norms of the evaluations of the polynomial at the roots: " << evals.transpose() << endl << endl;
+
+  cout.precision(10);
+  cout << "The last root in float then in double: " << psolvef.roots()[5] << "\t" << psolve6d.roots()[5] << endl;
+  std::complex<float> castedRoot(psolve6d.roots()[5].real(), psolve6d.roots()[5].imag());
+  cout << "Norm of the difference: " << std::abs(psolvef.roots()[5] - castedRoot) << endl;
+}
diff --git a/contrib/doc/examples/PolynomialUtils1.cpp b/contrib/doc/examples/PolynomialUtils1.cpp
new file mode 100644
index 0000000..c8d1fd2
--- /dev/null
+++ b/contrib/doc/examples/PolynomialUtils1.cpp
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <contrib/Eigen/Polynomials>
+#include <iostream>
+
+using namespace Eigen;
+using namespace std;
+
+int main() {
+  Vector4d roots = Vector4d::Random();
+  cout << "Roots: " << roots.transpose() << endl;
+  Eigen::Matrix<double, 5, 1> polynomial;
+  roots_to_monicPolynomial(roots, polynomial);
+  cout << "Polynomial: ";
+  for (int i = 0; i < 4; ++i) {
+    cout << polynomial[i] << ".x^" << i << "+ ";
+  }
+  cout << polynomial[4] << ".x^4" << endl;
+  Vector4d evaluation;
+  for (int i = 0; i < 4; ++i) {
+    evaluation[i] = poly_eval(polynomial, roots[i]);
+  }
+  cout << "Evaluation of the polynomial at the roots: " << evaluation.transpose();
+}
diff --git a/contrib/doc/examples/SYCL/CMakeLists.txt b/contrib/doc/examples/SYCL/CMakeLists.txt
new file mode 100644
index 0000000..2522488
--- /dev/null
+++ b/contrib/doc/examples/SYCL/CMakeLists.txt
@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+FILE(GLOB examples_SRCS "*.cpp")
+
+set(EIGEN_SYCL ON)
+list(APPEND CMAKE_EXE_LINKER_FLAGS -pthread)
+set(CMAKE_CXX_STANDARD 17)
+if(EIGEN_SYCL_ComputeCpp)
+  if(MSVC)
+    list(APPEND COMPUTECPP_USER_FLAGS -DWIN32)
+  else()
+    list(APPEND COMPUTECPP_USER_FLAGS -Wall)
+  endif()
+  # The following flags are not supported by Clang and can cause warnings
+  # if used with -Werror so they are removed here.
+  if(COMPUTECPP_USE_COMPILER_DRIVER)
+    set(CMAKE_CXX_COMPILER ${ComputeCpp_DEVICE_COMPILER_EXECUTABLE})
+    string(REPLACE "-Wlogical-op" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+    string(REPLACE "-Wno-psabi" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+  endif()
+  list(APPEND COMPUTECPP_USER_FLAGS
+      -DEIGEN_NO_ASSERTION_CHECKING=1
+      -no-serial-memop
+      -Xclang
+      -cl-mad-enable)
+endif(EIGEN_SYCL_ComputeCpp)
+
+FOREACH(example_src ${examples_SRCS})
+  GET_FILENAME_COMPONENT(example ${example_src} NAME_WE)
+  ei_add_test_internal(${example} example_${example})
+  ADD_DEPENDENCIES(contrib_examples example_${example})
+ENDFOREACH(example_src)
+set(EIGEN_SYCL OFF)
diff --git a/contrib/doc/examples/SYCL/CwiseMul.cpp b/contrib/doc/examples/SYCL/CwiseMul.cpp
new file mode 100644
index 0000000..63d698a
--- /dev/null
+++ b/contrib/doc/examples/SYCL/CwiseMul.cpp
@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <iostream>
+#define EIGEN_USE_SYCL
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+int main() {
+  using DataType = float;
+  using IndexType = int64_t;
+  constexpr auto DataLayout = Eigen::RowMajor;
+
+  auto devices = Eigen::get_sycl_supported_devices();
+  const auto device_selector = *devices.begin();
+  Eigen::QueueInterface queueInterface(device_selector);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+
+  // create the tensors to be used in the operation
+  IndexType sizeDim1 = 3;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 3;
+  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+
+  // initialize the tensors with the data we want manipulate to
+  Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
+
+  // set up some random data in the tensors to be multiplied
+  in1 = in1.random();
+  in2 = in2.random();
+
+  // allocate memory for the tensors
+  DataType* gpu_in1_data = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
+  DataType* gpu_in2_data = static_cast<DataType*>(sycl_device.allocate(in2.size() * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+
+  //
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
+
+  // copy the memory to the device and do the c=a*b calculation
+  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.size()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.size()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = gpu_in1 * gpu_in2;
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+
+  // print out the results
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        std::cout << "device_out"
+                  << "(" << i << ", " << j << ", " << k << ") : " << out(i, j, k) << " vs host_out"
+                  << "(" << i << ", " << j << ", " << k << ") : " << in1(i, j, k) * in2(i, j, k) << "\n";
+      }
+    }
+  }
+  printf("c=a*b Done\n");
+}
diff --git a/contrib/doc/snippets/CMakeLists.txt b/contrib/doc/snippets/CMakeLists.txt
new file mode 100644
index 0000000..6b2268a
--- /dev/null
+++ b/contrib/doc/snippets/CMakeLists.txt
@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+file(GLOB snippets_SRCS "*.cpp")
+
+add_custom_target(contrib_snippets)
+
+foreach(snippet_src ${snippets_SRCS})
+  get_filename_component(snippet ${snippet_src} NAME_WE)
+  set(compile_snippet_target compile_${snippet})
+  set(compile_snippet_src ${compile_snippet_target}.cpp)
+  file(READ ${snippet_src} snippet_source_code)
+  configure_file(${PROJECT_SOURCE_DIR}/doc/snippets/compile_snippet.cpp.in
+                 ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src})
+  add_executable(${compile_snippet_target}
+                 ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src})
+  if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
+    target_link_libraries(${compile_snippet_target} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
+  endif()
+  add_custom_command(
+    TARGET ${compile_snippet_target}
+    POST_BUILD
+    COMMAND ${compile_snippet_target}
+    ARGS >${CMAKE_CURRENT_BINARY_DIR}/${snippet}.out
+  )
+  add_dependencies(contrib_snippets ${compile_snippet_target})
+  set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src}
+                              PROPERTIES OBJECT_DEPENDS ${snippet_src})
+endforeach(snippet_src)
diff --git a/contrib/test/BVH.cpp b/contrib/test/BVH.cpp
new file mode 100644
index 0000000..5a5399b
--- /dev/null
+++ b/contrib/test/BVH.cpp
@@ -0,0 +1,248 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/StdVector>
+#include <Eigen/Geometry>
+#include <contrib/Eigen/BVH>
+
+namespace Eigen {
+
+template <typename Scalar, int Dim>
+AlignedBox<Scalar, Dim> bounding_box(const Matrix<Scalar, Dim, 1> &v) {
+  return AlignedBox<Scalar, Dim>(v);
+}
+
+}  // namespace Eigen
+
+template <int Dim>
+struct Ball {
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(double, Dim)
+
+  typedef Matrix<double, Dim, 1> VectorType;
+
+  Ball() {}
+  Ball(const VectorType &c, double r) : center(c), radius(r) {}
+
+  VectorType center;
+  double radius;
+};
+template <int Dim>
+AlignedBox<double, Dim> bounding_box(const Ball<Dim> &b) {
+  return AlignedBox<double, Dim>(b.center.array() - b.radius, b.center.array() + b.radius);
+}
+
+inline double SQR(double x) { return x * x; }
+
+template <int Dim>
+struct BallPointStuff  // this class provides functions to be both an intersector and a minimizer, both for a ball and a
+                       // point and for two trees
+{
+  typedef double Scalar;
+  typedef Matrix<double, Dim, 1> VectorType;
+  typedef Ball<Dim> BallType;
+  typedef AlignedBox<double, Dim> BoxType;
+
+  BallPointStuff() : calls(0), count(0) {}
+  BallPointStuff(const VectorType &inP) : p(inP), calls(0), count(0) {}
+
+  bool intersectVolume(const BoxType &r) {
+    ++calls;
+    return r.contains(p);
+  }
+  bool intersectObject(const BallType &b) {
+    ++calls;
+    if ((b.center - p).squaredNorm() < SQR(b.radius)) ++count;
+    return false;  // continue
+  }
+
+  bool intersectVolumeVolume(const BoxType &r1, const BoxType &r2) {
+    ++calls;
+    return !(r1.intersection(r2)).isNull();
+  }
+  bool intersectVolumeObject(const BoxType &r, const BallType &b) {
+    ++calls;
+    return r.squaredExteriorDistance(b.center) < SQR(b.radius);
+  }
+  bool intersectObjectVolume(const BallType &b, const BoxType &r) {
+    ++calls;
+    return r.squaredExteriorDistance(b.center) < SQR(b.radius);
+  }
+  bool intersectObjectObject(const BallType &b1, const BallType &b2) {
+    ++calls;
+    if ((b1.center - b2.center).norm() < b1.radius + b2.radius) ++count;
+    return false;
+  }
+  bool intersectVolumeObject(const BoxType &r, const VectorType &v) {
+    ++calls;
+    return r.contains(v);
+  }
+  bool intersectObjectObject(const BallType &b, const VectorType &v) {
+    ++calls;
+    if ((b.center - v).squaredNorm() < SQR(b.radius)) ++count;
+    return false;
+  }
+
+  double minimumOnVolume(const BoxType &r) {
+    ++calls;
+    return r.squaredExteriorDistance(p);
+  }
+  double minimumOnObject(const BallType &b) {
+    ++calls;
+    return (std::max)(0., (b.center - p).squaredNorm() - SQR(b.radius));
+  }
+  double minimumOnVolumeVolume(const BoxType &r1, const BoxType &r2) {
+    ++calls;
+    return r1.squaredExteriorDistance(r2);
+  }
+  double minimumOnVolumeObject(const BoxType &r, const BallType &b) {
+    ++calls;
+    return SQR((std::max)(0., r.exteriorDistance(b.center) - b.radius));
+  }
+  double minimumOnObjectVolume(const BallType &b, const BoxType &r) {
+    ++calls;
+    return SQR((std::max)(0., r.exteriorDistance(b.center) - b.radius));
+  }
+  double minimumOnObjectObject(const BallType &b1, const BallType &b2) {
+    ++calls;
+    return SQR((std::max)(0., (b1.center - b2.center).norm() - b1.radius - b2.radius));
+  }
+  double minimumOnVolumeObject(const BoxType &r, const VectorType &v) {
+    ++calls;
+    return r.squaredExteriorDistance(v);
+  }
+  double minimumOnObjectObject(const BallType &b, const VectorType &v) {
+    ++calls;
+    return SQR((std::max)(0., (b.center - v).norm() - b.radius));
+  }
+
+  VectorType p;
+  int calls;
+  int count;
+};
+
+template <int Dim>
+struct TreeTest {
+  typedef Matrix<double, Dim, 1> VectorType;
+  typedef std::vector<VectorType, aligned_allocator<VectorType> > VectorTypeList;
+  typedef Ball<Dim> BallType;
+  typedef std::vector<BallType, aligned_allocator<BallType> > BallTypeList;
+  typedef AlignedBox<double, Dim> BoxType;
+
+  void testIntersect1() {
+    BallTypeList b;
+    for (int i = 0; i < 500; ++i) {
+      b.push_back(BallType(VectorType::Random(), 0.5 * internal::random(0., 1.)));
+    }
+    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
+
+    VectorType pt = VectorType::Random();
+    BallPointStuff<Dim> i1(pt), i2(pt);
+
+    for (int i = 0; i < (int)b.size(); ++i) i1.intersectObject(b[i]);
+
+    BVIntersect(tree, i2);
+
+    VERIFY(i1.count == i2.count);
+  }
+
+  void testMinimize1() {
+    BallTypeList b;
+    for (int i = 0; i < 500; ++i) {
+      b.push_back(BallType(VectorType::Random(), 0.01 * internal::random(0., 1.)));
+    }
+    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
+
+    VectorType pt = VectorType::Random();
+    BallPointStuff<Dim> i1(pt), i2(pt);
+
+    double m1 = (std::numeric_limits<double>::max)(), m2 = m1;
+
+    for (int i = 0; i < (int)b.size(); ++i) m1 = (std::min)(m1, i1.minimumOnObject(b[i]));
+
+    m2 = BVMinimize(tree, i2);
+
+    VERIFY_IS_APPROX(m1, m2);
+  }
+
+  void testIntersect2() {
+    BallTypeList b;
+    VectorTypeList v;
+
+    for (int i = 0; i < 50; ++i) {
+      b.push_back(BallType(VectorType::Random(), 0.5 * internal::random(0., 1.)));
+      for (int j = 0; j < 3; ++j) v.push_back(VectorType::Random());
+    }
+
+    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
+    KdBVH<double, Dim, VectorType> vTree(v.begin(), v.end());
+
+    BallPointStuff<Dim> i1, i2;
+
+    for (int i = 0; i < (int)b.size(); ++i)
+      for (int j = 0; j < (int)v.size(); ++j) i1.intersectObjectObject(b[i], v[j]);
+
+    BVIntersect(tree, vTree, i2);
+
+    VERIFY(i1.count == i2.count);
+  }
+
+  void testMinimize2() {
+    BallTypeList b;
+    VectorTypeList v;
+
+    for (int i = 0; i < 50; ++i) {
+      b.push_back(BallType(VectorType::Random(), 1e-7 + 1e-6 * internal::random(0., 1.)));
+      for (int j = 0; j < 3; ++j) v.push_back(VectorType::Random());
+    }
+
+    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
+    KdBVH<double, Dim, VectorType> vTree(v.begin(), v.end());
+
+    BallPointStuff<Dim> i1, i2;
+
+    double m1 = (std::numeric_limits<double>::max)(), m2 = m1;
+
+    for (int i = 0; i < (int)b.size(); ++i)
+      for (int j = 0; j < (int)v.size(); ++j) m1 = (std::min)(m1, i1.minimumOnObjectObject(b[i], v[j]));
+
+    m2 = BVMinimize(tree, vTree, i2);
+
+    VERIFY_IS_APPROX(m1, m2);
+  }
+};
+
+EIGEN_DECLARE_TEST(BVH) {
+  for (int i = 0; i < g_repeat; i++) {
+#ifdef EIGEN_TEST_PART_1
+    TreeTest<2> test2;
+    CALL_SUBTEST(test2.testIntersect1());
+    CALL_SUBTEST(test2.testMinimize1());
+    CALL_SUBTEST(test2.testIntersect2());
+    CALL_SUBTEST(test2.testMinimize2());
+#endif
+
+#ifdef EIGEN_TEST_PART_2
+    TreeTest<3> test3;
+    CALL_SUBTEST(test3.testIntersect1());
+    CALL_SUBTEST(test3.testMinimize1());
+    CALL_SUBTEST(test3.testIntersect2());
+    CALL_SUBTEST(test3.testMinimize2());
+#endif
+
+#ifdef EIGEN_TEST_PART_3
+    TreeTest<4> test4;
+    CALL_SUBTEST(test4.testIntersect1());
+    CALL_SUBTEST(test4.testMinimize1());
+    CALL_SUBTEST(test4.testIntersect2());
+    CALL_SUBTEST(test4.testMinimize2());
+#endif
+  }
+}
diff --git a/contrib/test/CMakeLists.txt b/contrib/test/CMakeLists.txt
new file mode 100644
index 0000000..61ea341
--- /dev/null
+++ b/contrib/test/CMakeLists.txt
@@ -0,0 +1,277 @@
+# The file split_test_helper.h was generated at first run,
+# it is now included in test/
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
+  file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
+endif()
+
+set_property(GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT "Contrib")
+add_custom_target(BuildContrib)
+
+include_directories(../../test ../../contrib
+                    ${CMAKE_CURRENT_BINARY_DIR}/../../test)
+
+find_package (Threads)
+
+find_package(GoogleHash)
+if(GoogleHash_FOUND)
+  add_definitions("-DEIGEN_GOOGLEHASH_SUPPORT")
+  include_directories(${GOOGLEHASH_INCLUDES})
+  ei_add_property(EIGEN_TESTED_BACKENDS  "GoogleHash, ")
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS  "GoogleHash, ")
+endif()
+
+
+find_package(Adolc)
+if(Adolc_FOUND)
+  include_directories(${ADOLC_INCLUDES})
+  ei_add_property(EIGEN_TESTED_BACKENDS "Adolc, ")
+  ei_add_test(forward_adolc "" ${ADOLC_LIBRARIES})
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "Adolc, ")
+endif()
+
+# this test seems to never have been successful on x87, so is considered to contain a FP-related bug.
+# see thread: "non-linear optimization test summary"
+ei_add_test(NonLinearOptimization)
+
+ei_add_test(NumericalDiff)
+ei_add_test(structured_dpr1)
+ei_add_test(autodiff_scalar)
+ei_add_test(autodiff)
+
+ei_add_test(BVH)
+
+ei_add_test(matrix_exponential)
+ei_add_test(matrix_function)
+ei_add_test(matrix_power)
+ei_add_test(matrix_square_root)
+ei_add_test(alignedvector3)
+
+ei_add_test(FFT)
+ei_add_test(structured_bccb)
+
+ei_add_test(EulerAngles)
+
+find_package(MPREAL)
+if(MPREAL_FOUND)
+  ei_add_property(EIGEN_TESTED_BACKENDS "MPFR C++, ")
+  include_directories(${MPREAL_INCLUDES})
+  ei_add_test(mpreal_support "" "${MPREAL_LIBRARIES}" )
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "MPFR C++, ")
+endif()
+
+ei_add_test(NNLS)
+ei_add_test(structured_cauchy)
+
+ei_add_test(sparse_extra   "" "")
+
+find_package(FFTW)
+if(FFTW_FOUND)
+  ei_add_property(EIGEN_TESTED_BACKENDS "fftw, ")
+  include_directories( ${FFTW_INCLUDES} )
+  # The concurrent-transform subtest needs std::thread.
+  if(FFTWL_LIB)
+    ei_add_test(FFTW  "-DEIGEN_HAS_FFTWL -pthread" "${FFTW_LIBRARIES};${CMAKE_THREAD_LIBS_INIT}" )
+  else()
+    ei_add_test(FFTW  "-pthread" "${FFTW_LIBRARIES};${CMAKE_THREAD_LIBS_INIT}" )
+  endif()
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "fftw, ")
+endif()
+
+find_path(POCKETFFT  pocketfft_hdronly.h)
+if(POCKETFFT)
+  ei_add_property(EIGEN_TESTED_BACKENDS "pocketfft, ")
+  include_directories( ${POCKETFFT} )
+  ei_add_test(pocketfft "-pthread" "${CMAKE_THREAD_LIBS_INIT}" )
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "pocketfft, ")
+endif()
+
+if( NOT DUCC_ROOT AND ENV{DUCC_ROOT} )
+  set( DUCC_ROOT $ENV{DUCC_ROOT} )
+endif()
+find_path(DUCCFFT
+  NAMES "src/ducc0/fft/fft.h"
+  PATHS ${DUCC_ROOT})
+message(INFO " ${DUCC_ROOT} ${DUCCFFT}")
+if(DUCCFFT)
+  ei_add_property(EIGEN_TESTED_BACKENDS "duccfft, ")
+  include_directories( "${DUCCFFT}/src" )
+  add_library(ducc_lib "${DUCCFFT}/src/ducc0/infra/string_utils.cc" "${DUCCFFT}/src/ducc0/infra/threading.cc")
+  target_compile_definitions(ducc_lib PUBLIC "DUCC0_NO_THREADING=1")
+  ei_add_test(duccfft "-DEIGEN_DUCCFFT_DEFAULT -DDUCC0_NO_THREADING=1" "ducc_lib" )
+  set_target_properties(ducc_lib duccfft PROPERTIES CXX_STANDARD 17)
+else()
+  ei_add_property(EIGEN_MISSING_BACKENDS "duccfft, ")
+endif()
+
+
+option(EIGEN_TEST_OPENGL "Enable OpenGL support in unit tests" OFF)
+if(EIGEN_TEST_OPENGL)
+  find_package(OpenGL)
+  find_package(GLUT)
+  find_package(GLEW)
+  if(OPENGL_FOUND AND GLUT_FOUND AND GLEW_FOUND)
+    include_directories(${OPENGL_INCLUDE_DIR} ${GLUT_INCLUDE_DIR} ${GLEW_INCLUDE_DIRS})
+    ei_add_property(EIGEN_TESTED_BACKENDS "OpenGL, ")
+    set(EIGEN_GL_LIB ${GLUT_LIBRARIES} ${GLEW_LIBRARIES} ${OPENGL_LIBRARIES})
+    ei_add_test(openglsupport  "" "${EIGEN_GL_LIB}" )
+  else()
+    ei_add_property(EIGEN_MISSING_BACKENDS "OpenGL, ")
+  endif()
+else()
+    ei_add_property(EIGEN_MISSING_BACKENDS "OpenGL, ")
+endif()
+
+ei_add_test(structured_vandermonde)
+ei_add_test(structured_vandermonde_int_index)
+ei_add_test(polynomialsolver)
+ei_add_test(polynomialutils)
+ei_add_test(splines)
+ei_add_test(structured_dplr)
+ei_add_test(levenberg_marquardt)
+ei_add_test(kronecker_product)
+ei_add_test(structured_matrices)
+ei_add_test(structured_kronecker)
+ei_add_test(bessel_functions)
+ei_add_test(special_functions)
+ei_add_test(special_packetmath "-DEIGEN_FAST_MATH=1")
+
+if(EIGEN_TEST_SYCL)
+  set(EIGEN_SYCL ON)
+  include(SyclConfigureTesting)
+
+  ei_add_test(tensor_sycl)
+  ei_add_test(tensor_image_op_sycl)
+  ei_add_test(tensor_math_sycl)
+  ei_add_test(tensor_forced_eval_sycl)
+  ei_add_test(tensor_broadcast_sycl)
+  ei_add_test(tensor_device_sycl)
+  ei_add_test(tensor_reduction_sycl)
+  ei_add_test(tensor_morphing_sycl)
+  ei_add_test(tensor_shuffling_sycl)
+  ei_add_test(tensor_padding_sycl)
+  ei_add_test(tensor_builtins_sycl)
+  ei_add_test(tensor_contract_sycl)
+  ei_add_test(tensor_concatenation_sycl)
+  ei_add_test(tensor_reverse_sycl)
+  ei_add_test(tensor_convolution_sycl)
+  ei_add_test(tensor_striding_sycl)
+  ei_add_test(tensor_chipping_sycl)
+  ei_add_test(tensor_layout_swap_sycl)
+  ei_add_test(tensor_inflation_sycl)
+  ei_add_test(tensor_random_sycl)
+  ei_add_test(tensor_generator_sycl)
+  ei_add_test(tensor_patch_sycl)
+  ei_add_test(tensor_image_patch_sycl)
+  ei_add_test(tensor_volume_patch_sycl)
+  ei_add_test(tensor_argmax_sycl)
+  ei_add_test(tensor_custom_op_sycl)
+  ei_add_test(tensor_scan_sycl)
+  ei_add_test(tensor_of_float16_sycl)
+  set(EIGEN_SYCL OFF)
+endif()
+
+ei_add_test(tensor_argmax)
+ei_add_test(tensor_assign)
+ei_add_test(tensor_block_access)
+ei_add_test(tensor_block_eval)
+ei_add_test(tensor_block_view "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_block_io)
+ei_add_test(tensor_broadcasting)
+ei_add_test(tensor_casts)
+ei_add_test(tensor_chipping)
+ei_add_test(tensor_comparisons)
+ei_add_test(tensor_concatenation)
+ei_add_test(tensor_const)
+ei_add_test(tensor_contraction)
+ei_add_test(tensor_cost_model)
+ei_add_test(tensor_convolution)
+ei_add_test(tensor_custom_index)
+ei_add_test(tensor_custom_op)
+ei_add_test(tensor_dimension)
+ei_add_test(tensor_empty)
+ei_add_test(tensor_executor "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_expr)
+ei_add_test(tensor_fft)
+ei_add_test(tensor_fixed_size)
+ei_add_test(tensor_forced_eval)
+ei_add_test(tensor_generator)
+ei_add_test(tensor_ifft)
+ei_add_test(tensor_image_patch)
+ei_add_test(tensor_index_list)
+ei_add_test(tensor_inflation "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_intdiv)
+ei_add_test(tensor_io)
+ei_add_test(tensor_layout_swap)
+ei_add_test(tensor_lvalue)
+ei_add_test(tensor_map)
+ei_add_test(tensor_math)
+ei_add_test(tensor_mixed_indices)
+ei_add_test(tensor_morphing)
+ei_add_test(tensor_move)
+ei_add_test(tensor_notification "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_of_complex)
+ei_add_test(tensor_of_const_values)
+ei_add_test(tensor_of_strings)
+ei_add_test(tensor_padding)
+ei_add_test(tensor_patch)
+ei_add_test(tensor_random)
+ei_add_test(tensor_reinclude "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_reverse)
+ei_add_test(tensor_reduction)
+ei_add_test(tensor_ref)
+ei_add_test(tensor_roll)
+ei_add_test(tensor_roundings)
+ei_add_test(tensor_scan)
+ei_add_test(tensor_shuffling)
+ei_add_test(tensor_simple)
+ei_add_test(tensor_special_members)
+ei_add_test(tensor_striding)
+ei_add_test(tensor_sugar)
+ei_add_test(tensor_thread_local "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_thread_pool "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(tensor_trace)
+ei_add_test(tensor_volume_patch)
+ei_add_test(tensor_symmetry)
+if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8" AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  # This test requires __uint128_t which is only available on 64bit systems
+  ei_add_test(tensor_uint128)
+endif()
+
+# CUDA and HIP tests. The options, the toolkit and the language are set up once in the top-level CMakeLists
+# through cmake/EigenGpuTesting.cmake.
+if(EIGEN_GPU_TEST_MODE MATCHES "^(cuda|hip)")
+  set(EIGEN_ADD_TEST_FILENAME_EXTENSION "cu")
+
+  if(EIGEN_GPU_TEST_MODE MATCHES "^cuda")
+    # complex is not yet supported by HIP.
+    ei_add_test(tensor_complex_gpu)
+    ei_add_test(tensor_complex_cwise_ops_gpu)
+  endif()
+  ei_add_test(tensor_reduction_gpu)
+  ei_add_test(tensor_argmax_gpu)
+  ei_add_test(tensor_cast_float16_gpu)
+  ei_add_test(tensor_scan_gpu)
+  ei_add_test(tensor_device)
+  ei_add_test(tensor_gpu_device_attributes)
+  ei_add_test(tensor_gpu)
+  ei_add_test(tensor_gpu_runtime_check)
+  ei_add_test(tensor_gpu_runtime_check_ndebug)
+  ei_add_test(tensor_contract_gpu)
+  ei_add_test(tensor_of_float16_gpu)
+  ei_add_test(tensor_of_bfloat16_gpu)
+  ei_add_test(tensor_random_gpu)
+
+  unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
+
+  # The GPU module's own tests (cuSOLVER, cuDSS) are CUDA-only.
+  if(EIGEN_GPU_TEST_MODE MATCHES "^cuda")
+    add_subdirectory(GPU)
+  endif()
+endif()
diff --git a/contrib/test/EulerAngles.cpp b/contrib/test/EulerAngles.cpp
new file mode 100644
index 0000000..150e7d2
--- /dev/null
+++ b/contrib/test/EulerAngles.cpp
@@ -0,0 +1,315 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+EIGEN_DISABLE_DEPRECATED_WARNING
+
+#include <contrib/Eigen/EulerAngles>
+
+using namespace Eigen;
+
+// Unfortunately, we need to specialize it in order to work. (We could add it in main.h test framework)
+template <typename Scalar, class System>
+bool verifyIsApprox(const Eigen::EulerAngles<Scalar, System>& a, const Eigen::EulerAngles<Scalar, System>& b) {
+  return verifyIsApprox(a.angles(), b.angles());
+}
+
+// Verify that x is in the approxed range [a, b]
+#define VERIFY_APPROXED_RANGE(a, x, b)   \
+  do {                                   \
+    VERIFY_IS_APPROX_OR_LESS_THAN(a, x); \
+    VERIFY_IS_APPROX_OR_LESS_THAN(x, b); \
+  } while (0)
+
+const char X = EULER_X;
+const char Y = EULER_Y;
+const char Z = EULER_Z;
+
+template <typename Scalar, class EulerSystem>
+void verify_euler(const EulerAngles<Scalar, EulerSystem>& e) {
+  typedef EulerAngles<Scalar, EulerSystem> EulerAnglesType;
+  typedef Matrix<Scalar, 3, 3> Matrix3;
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Quaternion<Scalar> QuaternionType;
+  typedef AngleAxis<Scalar> AngleAxisType;
+
+  const Scalar ONE = Scalar(1);
+  const Scalar HALF_PI = Scalar(EIGEN_PI / 2);
+  const Scalar PI = Scalar(EIGEN_PI);
+
+  // It's very important calc the acceptable precision depending on the distance from the pole.
+  const Scalar longitudeRadius = std::abs(EulerSystem::IsTaitBryan ? std::cos(e.beta()) : std::sin(e.beta()));
+  Scalar precision = test_precision<Scalar>() / longitudeRadius;
+
+  Scalar betaRangeStart, betaRangeEnd;
+  if (EulerSystem::IsTaitBryan) {
+    betaRangeStart = -HALF_PI;
+    betaRangeEnd = HALF_PI;
+  } else {
+    if (!EulerSystem::IsBetaOpposite) {
+      betaRangeStart = 0;
+      betaRangeEnd = PI;
+    } else {
+      betaRangeStart = -PI;
+      betaRangeEnd = 0;
+    }
+  }
+
+  const Vector3 I_ = EulerAnglesType::AlphaAxisVector();
+  const Vector3 J_ = EulerAnglesType::BetaAxisVector();
+  const Vector3 K_ = EulerAnglesType::GammaAxisVector();
+
+  // Is approx checks
+  VERIFY(e.isApprox(e));
+  VERIFY_IS_APPROX(e, e);
+  VERIFY_IS_NOT_APPROX(e, EulerAnglesType(e.alpha() + ONE, e.beta() + ONE, e.gamma() + ONE));
+
+  const Matrix3 m(e);
+  VERIFY_IS_APPROX(Scalar(m.determinant()), ONE);
+
+  EulerAnglesType ebis(m);
+
+  // When no roll(acting like polar representation), we have the best precision.
+  // One of those cases is when the Euler angles are on the pole, and because it's singular case,
+  //  the computation returns no roll.
+  if (ebis.beta() == 0) precision = test_precision<Scalar>();
+
+  // Check that eabis in range
+  VERIFY_APPROXED_RANGE(-PI, ebis.alpha(), PI);
+  VERIFY_APPROXED_RANGE(betaRangeStart, ebis.beta(), betaRangeEnd);
+  VERIFY_APPROXED_RANGE(-PI, ebis.gamma(), PI);
+
+  const Matrix3 mbis(AngleAxisType(ebis.alpha(), I_) * AngleAxisType(ebis.beta(), J_) *
+                     AngleAxisType(ebis.gamma(), K_));
+  VERIFY_IS_APPROX(Scalar(mbis.determinant()), ONE);
+  VERIFY_IS_APPROX(mbis, ebis.toRotationMatrix());
+  /*std::cout << "===================\n" <<
+    "e: " << e << std::endl <<
+    "eabis: " << eabis.transpose() << std::endl <<
+    "m: " << m << std::endl <<
+    "mbis: " << mbis << std::endl <<
+    "X: " << (m * Vector3::UnitX()).transpose() << std::endl <<
+    "X: " << (mbis * Vector3::UnitX()).transpose() << std::endl;*/
+  VERIFY(m.isApprox(mbis, precision));
+
+  // Test if ea and eabis are the same
+  // Need to check both singular and non-singular cases
+  // There are two singular cases.
+  // 1. When I==K and sin(ea(1)) == 0
+  // 2. When I!=K and cos(ea(1)) == 0
+
+  // TODO: Make this test work well, and use range saturation function.
+  /*// If I==K, and ea[1]==0, then there no unique solution.
+  // The remark apply in the case where I!=K, and |ea[1]| is close to +-pi/2.
+  if( (i!=k || ea[1]!=0) && (i==k || !internal::isApprox(abs(ea[1]),Scalar(EIGEN_PI/2),test_precision<Scalar>())) )
+      VERIFY_IS_APPROX(ea, eabis);*/
+
+  // Quaternions
+  const QuaternionType q(e);
+  ebis = q;
+  const QuaternionType qbis(ebis);
+  VERIFY(internal::isApprox<Scalar>(std::abs(q.dot(qbis)), ONE, precision));
+  // VERIFY_IS_APPROX(eabis, eabis2);// Verify that the euler angles are still the same
+
+  // A suggestion for simple product test when will be supported.
+  /*EulerAnglesType e2(PI/2, PI/2, PI/2);
+  Matrix3 m2(e2);
+  VERIFY_IS_APPROX(e*e2, m*m2);*/
+}
+
+template <signed char A, signed char B, signed char C, typename Scalar>
+void verify_euler_vec(const Matrix<Scalar, 3, 1>& ea) {
+  verify_euler(EulerAngles<Scalar, EulerSystem<A, B, C> >(ea[0], ea[1], ea[2]));
+}
+
+template <signed char A, signed char B, signed char C, typename Scalar>
+void verify_euler_all_neg(const Matrix<Scalar, 3, 1>& ea) {
+  verify_euler_vec<+A, +B, +C>(ea);
+  verify_euler_vec<+A, +B, -C>(ea);
+  verify_euler_vec<+A, -B, +C>(ea);
+  verify_euler_vec<+A, -B, -C>(ea);
+
+  verify_euler_vec<-A, +B, +C>(ea);
+  verify_euler_vec<-A, +B, -C>(ea);
+  verify_euler_vec<-A, -B, +C>(ea);
+  verify_euler_vec<-A, -B, -C>(ea);
+}
+
+template <typename Scalar>
+void check_all_var(const Matrix<Scalar, 3, 1>& ea) {
+  verify_euler_all_neg<X, Y, Z>(ea);
+  verify_euler_all_neg<X, Y, X>(ea);
+  verify_euler_all_neg<X, Z, Y>(ea);
+  verify_euler_all_neg<X, Z, X>(ea);
+
+  verify_euler_all_neg<Y, Z, X>(ea);
+  verify_euler_all_neg<Y, Z, Y>(ea);
+  verify_euler_all_neg<Y, X, Z>(ea);
+  verify_euler_all_neg<Y, X, Y>(ea);
+
+  verify_euler_all_neg<Z, X, Y>(ea);
+  verify_euler_all_neg<Z, X, Z>(ea);
+  verify_euler_all_neg<Z, Y, X>(ea);
+  verify_euler_all_neg<Z, Y, Z>(ea);
+}
+
+template <typename Scalar>
+void check_singular_cases(const Scalar& singularBeta) {
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  const Scalar PI = Scalar(EIGEN_PI);
+
+  for (Scalar epsilon = NumTraits<Scalar>::epsilon(); epsilon < 1; epsilon *= Scalar(1.2)) {
+    check_all_var(Vector3(PI / 4, singularBeta, PI / 3));
+    check_all_var(Vector3(PI / 4, singularBeta - epsilon, PI / 3));
+    check_all_var(Vector3(PI / 4, singularBeta - Scalar(1.5) * epsilon, PI / 3));
+    check_all_var(Vector3(PI / 4, singularBeta - 2 * epsilon, PI / 3));
+    check_all_var(Vector3(PI * Scalar(0.8), singularBeta - epsilon, Scalar(0.9) * PI));
+    check_all_var(Vector3(PI * Scalar(-0.9), singularBeta + epsilon, PI * Scalar(0.3)));
+    check_all_var(Vector3(PI * Scalar(-0.6), singularBeta + Scalar(1.5) * epsilon, PI * Scalar(0.3)));
+    check_all_var(Vector3(PI * Scalar(-0.5), singularBeta + 2 * epsilon, PI * Scalar(0.4)));
+    check_all_var(Vector3(PI * Scalar(0.9), singularBeta + epsilon, Scalar(0.8) * PI));
+  }
+
+  // This one for sanity, it had a problem with near pole cases in float scalar.
+  check_all_var(Vector3(PI * Scalar(0.8), singularBeta - Scalar(1E-6), Scalar(0.9) * PI));
+}
+
+template <typename Scalar>
+void eulerangles_manual() {
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+  const Vector3 Zero = Vector3::Zero();
+  const Scalar PI = Scalar(EIGEN_PI);
+
+  check_all_var(Zero);
+
+  // singular cases
+  check_singular_cases(PI / 2);
+  check_singular_cases(-PI / 2);
+
+  check_singular_cases(Scalar(0));
+  check_singular_cases(Scalar(-0));
+
+  check_singular_cases(PI);
+  check_singular_cases(-PI);
+
+  // non-singular cases
+  VectorX alpha = VectorX::LinSpaced(20, Scalar(-0.99) * PI, PI);
+  VectorX beta = VectorX::LinSpaced(20, Scalar(-0.49) * PI, Scalar(0.49) * PI);
+  VectorX gamma = VectorX::LinSpaced(20, Scalar(-0.99) * PI, PI);
+  for (int i = 0; i < alpha.size(); ++i) {
+    for (int j = 0; j < beta.size(); ++j) {
+      for (int k = 0; k < gamma.size(); ++k) {
+        check_all_var(Vector3(alpha(i), beta(j), gamma(k)));
+      }
+    }
+  }
+}
+
+template <typename Scalar>
+void eulerangles_rand() {
+  typedef Matrix<Scalar, 3, 3> Matrix3;
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Array<Scalar, 3, 1> Array3;
+  typedef Quaternion<Scalar> Quaternionx;
+  typedef AngleAxis<Scalar> AngleAxisType;
+
+  Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+  Quaternionx q1;
+  q1 = AngleAxisType(a, Vector3::Random().normalized());
+  Matrix3 m;
+  m = q1;
+
+  Vector3 ea = m.eulerAngles(0, 1, 2);
+  check_all_var(ea);
+  ea = m.eulerAngles(0, 1, 0);
+  check_all_var(ea);
+
+  // Check with purely random Quaternion:
+  q1.coeffs() = Quaternionx::Coefficients::Random().normalized();
+  m = q1;
+  ea = m.eulerAngles(0, 1, 2);
+  check_all_var(ea);
+  ea = m.eulerAngles(0, 1, 0);
+  check_all_var(ea);
+
+  // Check with random angles in range [0:pi]x[-pi:pi]x[-pi:pi].
+  ea = (Array3::Random() + Array3(1, 0, 0)) * Scalar(EIGEN_PI) * Array3(0.5, 1, 1);
+  check_all_var(ea);
+
+  ea[2] = ea[0] = internal::random<Scalar>(0, Scalar(EIGEN_PI));
+  check_all_var(ea);
+
+  ea[0] = ea[1] = internal::random<Scalar>(0, Scalar(EIGEN_PI));
+  check_all_var(ea);
+
+  ea[1] = 0;
+  check_all_var(ea);
+
+  ea.head(2).setZero();
+  check_all_var(ea);
+
+  ea.setZero();
+  check_all_var(ea);
+}
+
+template <typename Scalar>
+void eulerangles_gimbal_lock_regression() {
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  const Scalar deg = Scalar(EIGEN_PI) / Scalar(180);
+
+  check_all_var(Vector3(Scalar(10) * deg, Scalar(90) * deg, Scalar(30) * deg));
+  check_all_var(Vector3(Scalar(10) * deg, Scalar(-90) * deg, Scalar(30) * deg));
+  check_all_var(Vector3(Scalar(10) * deg, Scalar(60) * deg, Scalar(30) * deg));
+  check_all_var(Vector3(Scalar(10) * deg, Scalar(89.5) * deg, Scalar(30) * deg));
+  check_all_var(Vector3(Scalar(10) * deg, Scalar(-89.5) * deg, Scalar(30) * deg));
+}
+
+void eulerangles_gimbal_lock_reproducer() {
+  Quaterniond q;
+  q.coeffs() << numext::bit_cast<double>(numext::uint64_t(0x3FDFFFFFC0000000ull)),
+      numext::bit_cast<double>(numext::uint64_t(0x3FE0000000000001ull)),
+      numext::bit_cast<double>(numext::uint64_t(0xBFE0000000000000ull)),
+      numext::bit_cast<double>(numext::uint64_t(0x3FDFFFFFBFFFFFFEull));
+
+  const Matrix3d m(q);
+  const EulerAnglesYXZd e(q);
+
+  VERIFY_IS_APPROX(e.angles(), m.canonicalEulerAngles(1, 0, 2));
+  // Angle tolerances are ill-conditioned at gimbal lock; this checks the
+  // reconstructed matrix with a fixed absolute tolerance instead.
+  VERIFY((m - e.toRotationMatrix()).norm() < 1e-6);
+}
+
+EIGEN_DECLARE_TEST(EulerAngles) {
+  // Simple cast test
+  EulerAnglesXYZd onesEd(1, 1, 1);
+  EulerAnglesXYZf onesEf = onesEd.cast<float>();
+  VERIFY_IS_APPROX(onesEd, onesEf.cast<double>());
+
+  // Simple Construction from Vector3 test
+  VERIFY_IS_APPROX(onesEd, EulerAnglesXYZd(Vector3d::Ones()));
+
+  CALL_SUBTEST_1(eulerangles_manual<float>());
+  CALL_SUBTEST_2(eulerangles_manual<double>());
+
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_3(eulerangles_rand<float>());
+    CALL_SUBTEST_4(eulerangles_rand<double>());
+  }
+
+  CALL_SUBTEST_5(eulerangles_gimbal_lock_regression<float>());
+  CALL_SUBTEST_5(eulerangles_gimbal_lock_regression<double>());
+  CALL_SUBTEST_5(eulerangles_gimbal_lock_reproducer());
+
+  // TODO: Add tests for auto diff
+  // TODO: Add tests for complex numbers
+}
diff --git a/contrib/test/FFT.cpp b/contrib/test/FFT.cpp
new file mode 100644
index 0000000..aa2d0a3
--- /dev/null
+++ b/contrib/test/FFT.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_FFT_DEFAULT 1
+#include "fft_test_shared.h"
diff --git a/contrib/test/FFTW.cpp b/contrib/test/FFTW.cpp
new file mode 100644
index 0000000..c776d4d
--- /dev/null
+++ b/contrib/test/FFTW.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_FFTW_DEFAULT 1
+#include "fft_test_shared.h"
diff --git a/contrib/test/GPU/CMakeLists.txt b/contrib/test/GPU/CMakeLists.txt
new file mode 100644
index 0000000..b0f9437
--- /dev/null
+++ b/contrib/test/GPU/CMakeLists.txt
@@ -0,0 +1,140 @@
+# GPU module tests. Included from contrib/test/CMakeLists.txt when the CUDA tests are on; the toolkit is
+# found once at the top level, by cmake/EigenGpuTesting.cmake.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+
+# These tests compile the GPU headers against the test harness, where
+# eigen_assert throws. A noexcept function that reaches such an assert therefore
+# calls std::terminate; the headers destroy CUDA events unchecked in their
+# noexcept move assignments for exactly that reason. Both compilers already
+# diagnose the pattern by default, under their own spelling; promoting it to an
+# error keeps it from returning unnoticed. The move assignments are templates,
+# so this binds the instantiations the tests below create, not the definitions.
+set(EIGEN_GPU_TEST_CXX_FLAGS "")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  set(EIGEN_GPU_TEST_CXX_FLAGS "-Werror=terminate")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set(EIGEN_GPU_TEST_CXX_FLAGS "-Werror=exceptions")
+endif()
+
+# ei_add_gpu_test(<name> [EXTRA_LIBS <lib>...] [EXTRA_INCLUDES <dir>...] [EXTRA_DEFINES <def>...])
+#
+# Thin wrapper around ei_add_test for GPU module tests. Delegates to
+# ei_add_test so CALL_SUBTEST_N splitting and EIGEN_TEST_MAX_SIZE handling
+# work the same way as the rest of the test suite, then layers on the
+# GPU-specific properties (EXTRA_{LIBS,INCLUDES,DEFINES}, the
+# "Official;gpu" labels, SKIP_RETURN_CODE=77, buildtests_gpu dependency).
+#
+# GPU module tests are plain .cpp (host-compiled) by design: they
+# orchestrate NVIDIA library calls and never launch kernels themselves,
+# which avoids NVCC instantiating Eigen CPU packet ops for CUDA vector
+# types. That keeps them outside ei_add_test's "is_gpu_test" path (which
+# triggers on EIGEN_ADD_TEST_FILENAME_EXTENSION=cu), so we set the
+# SKIP_RETURN_CODE and labels ourselves.
+function(ei_add_gpu_test test_name)
+  cmake_parse_arguments(ARG "" "" "EXTRA_LIBS;EXTRA_INCLUDES;EXTRA_DEFINES" ${ARGN})
+
+  # Delegate to ei_add_test. The third arg is a semicolon-separated library
+  # list; CUDA::cudart_static is always needed for any host test that
+  # touches a device-allocated buffer.
+  ei_add_test(${test_name} "${EIGEN_GPU_TEST_CXX_FLAGS}" "CUDA::cudart_static;${ARG_EXTRA_LIBS}")
+
+  # Discover targets ei_add_test created. The scan mirrors ei_add_test's own
+  # scan so we see the same set of suffixes: one target per distinct
+  # CALL_SUBTEST_N on EIGEN_SPLIT_LARGE_TESTS, else a single target.
+  file(READ "${test_name}.cpp" _src)
+  string(REGEX MATCHALL "CALL_SUBTEST_[0-9]+" _matches "${_src}")
+  string(REGEX REPLACE "CALL_SUBTEST_" "" _suffixes "${_matches}")
+  list(REMOVE_DUPLICATES _suffixes)
+  set(_targets)
+  if(EIGEN_SPLIT_LARGE_TESTS AND _suffixes)
+    foreach(s ${_suffixes})
+      list(APPEND _targets "${test_name}_${s}")
+    endforeach()
+  else()
+    list(APPEND _targets "${test_name}")
+  endif()
+
+  foreach(t ${_targets})
+    # SYSTEM for the toolkit and backend headers: the -Werror above is aimed at
+    # Eigen's own noexcept functions, not at whatever those ship.
+    target_include_directories(${t} SYSTEM PRIVATE
+      "${CUDAToolkit_INCLUDE_DIRS}"
+      ${ARG_EXTRA_INCLUDES})
+    target_include_directories(${t} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
+    if(ARG_EXTRA_DEFINES)
+      target_compile_definitions(${t} PRIVATE ${ARG_EXTRA_DEFINES})
+    endif()
+    add_dependencies(buildtests_gpu ${t})
+    set_property(TEST ${t} APPEND PROPERTY LABELS "Official;gpu")
+    set_property(TEST ${t} PROPERTY SKIP_RETURN_CODE 77)
+  endforeach()
+endfunction()
+
+# Compile-time GPU type-trait surface (static_assert only; links like device_matrix
+# because it pulls the full <contrib/Eigen/GPU> umbrella).
+ei_add_gpu_test(device_traits
+  EXTRA_LIBS CUDA::cublas CUDA::cusolver CUDA::npps CUDA::nppc)
+
+# DeviceMatrix core: CUDA runtime + cuBLAS + cuSOLVER (for BLAS-1 ops via GpuContext).
+ei_add_gpu_test(device_matrix
+  EXTRA_LIBS CUDA::cublas CUDA::cusolver CUDA::npps CUDA::nppc)
+ei_add_gpu_test(cublas_64bit EXTRA_LIBS CUDA::cublas)
+
+# DeviceBufferPool release ordering: CUDA runtime only, plus std::thread for the stream gate.
+find_package(Threads REQUIRED)
+ei_add_gpu_test(device_buffer_pool EXTRA_LIBS Threads::Threads)
+
+# cuBLAS integration. OFF by default; later MRs in the stack opt in.
+option(EIGEN_TEST_CUBLAS "Test cuBLAS integration" OFF)
+if(EIGEN_TEST_CUBLAS AND TARGET CUDA::cublas)
+  ei_add_gpu_test(cublas EXTRA_LIBS CUDA::cublas CUDA::cusolver)
+endif()
+
+# cuSOLVER dense factorizations (LLT, LU, QR, SVD, self-adjoint eigensolver).
+option(EIGEN_TEST_CUSOLVER "Test cuSOLVER integration" OFF)
+if(EIGEN_TEST_CUSOLVER AND TARGET CUDA::cusolver)
+  find_package(Threads REQUIRED)
+  ei_add_gpu_test(cusolver_llt EXTRA_LIBS CUDA::cusolver CUDA::cublas Threads::Threads)
+  foreach(_cusolver_test IN ITEMS cusolver_lu cusolver_qr cusolver_svd cusolver_eigen)
+    ei_add_gpu_test(${_cusolver_test} EXTRA_LIBS CUDA::cusolver CUDA::cublas)
+  endforeach()
+endif()
+
+# cuFFT (part of the CUDA toolkit, no separate option needed).
+if(TARGET CUDA::cufft)
+  ei_add_gpu_test(cufft EXTRA_LIBS CUDA::cufft CUDA::cublas)
+endif()
+
+# cuSPARSE SpMV (part of the CUDA toolkit), its BSR counterpart (skips itself
+# below cuSPARSE 12.6.3), and the end-to-end CG test that exercises
+# Eigen::ConjugateGradient with DeviceMatrix + device-resident SpMV.
+if(TARGET CUDA::cusparse)
+  ei_add_gpu_test(cusparse_spmv
+    EXTRA_LIBS CUDA::cusparse CUDA::cublas CUDA::cusolver)
+  ei_add_gpu_test(cusparse_bsr
+    EXTRA_LIBS CUDA::cusparse CUDA::cublas CUDA::cusolver)
+  ei_add_gpu_test(cg
+    EXTRA_LIBS CUDA::cusparse CUDA::cublas CUDA::cusolver CUDA::npps CUDA::nppc)
+endif()
+
+# cuDSS sparse direct solvers -- distributed separately from the CUDA Toolkit.
+option(EIGEN_TEST_CUDSS "Test cuDSS sparse solver integration" OFF)
+if(EIGEN_TEST_CUDSS)
+  find_path(CUDSS_INCLUDE_DIR cudss.h
+    HINTS ${CUDSS_DIR}/include ${CUDAToolkit_INCLUDE_DIRS} /usr/include)
+  find_library(CUDSS_LIBRARY cudss
+    HINTS ${CUDSS_DIR}/lib ${CUDSS_DIR}/lib64 ${CUDA_TOOLKIT_ROOT_DIR}/lib64 /usr/lib/x86_64-linux-gnu)
+  if(CUDSS_INCLUDE_DIR AND CUDSS_LIBRARY)
+    message(STATUS "cuDSS found: ${CUDSS_LIBRARY}")
+    foreach(_cudss_test IN ITEMS cudss_llt cudss_ldlt cudss_lu)
+      ei_add_gpu_test(${_cudss_test}
+        EXTRA_LIBS CUDA::cusolver CUDA::cublas ${CUDSS_LIBRARY}
+        EXTRA_INCLUDES ${CUDSS_INCLUDE_DIR}
+        EXTRA_DEFINES EIGEN_CUDSS=1)
+    endforeach()
+  else()
+    message(WARNING "EIGEN_TEST_CUDSS=ON but cuDSS not found. Set CUDSS_DIR.")
+  endif()
+endif()
diff --git a/contrib/test/GPU/cg.cpp b/contrib/test/GPU/cg.cpp
new file mode 100644
index 0000000..4383ec2
--- /dev/null
+++ b/contrib/test/GPU/cg.cpp
@@ -0,0 +1,231 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// End-to-end test: CG algorithm running on GPU via gpu::DeviceMatrix.
+//
+// Uses DeviceSparseView for SpMV, gpu::DeviceMatrix for vectors, DeviceScalar
+// for deferred reductions. Verifies correctness against CPU ConjugateGradient.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <Eigen/IterativeLinearSolvers>
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Helper: build a sparse SPD matrix --------------------------------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_spd(Index n, double density = 0.1) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat R(n, n);
+  R.reserve(VectorXi::Constant(n, static_cast<int>(n * density) + 1));
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = 0; i < n; ++i) {
+      if (i == j || (std::rand() / double(RAND_MAX)) < density) {
+        R.insert(i, j) = Scalar(std::rand() / double(RAND_MAX) - 0.5);
+      }
+    }
+  }
+  R.makeCompressed();
+  SpMat A = R.adjoint() * R;
+  for (Index i = 0; i < n; ++i) A.coeffRef(i, i) += Scalar(RealScalar(n));
+  A.makeCompressed();
+  return A;
+}
+
+// ---- GPU CG without preconditioner ------------------------------------------
+
+template <typename Scalar>
+void test_gpu_cg(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  // CPU reference (identity preconditioner to match GPU).
+  ConjugateGradient<SpMat, Lower | Upper, IdentityPreconditioner> cpu_cg;
+  cpu_cg.setMaxIterations(1000);
+  cpu_cg.setTolerance(RealScalar(1e-8));
+  cpu_cg.compute(A);
+  Vec x_cpu = cpu_cg.solve(b);
+  VERIFY_IS_EQUAL(cpu_cg.info(), Success);
+
+  // GPU CG: mirrors Eigen's conjugate_gradient() using gpu::DeviceMatrix ops.
+  gpu::Context ctx;
+  gpu::Context::setThreadLocal(&ctx);
+  gpu::SparseContext<Scalar> spmv_ctx(ctx);
+  auto mat = spmv_ctx.deviceView(A);
+
+  auto d_b = gpu::DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_x(n, 1);
+  d_x.setZero(ctx);
+
+  // r = b (since x=0)
+  gpu::DeviceMatrix<Scalar> residual(n, 1);
+  residual.copyFrom(ctx, d_b);
+
+  RealScalar rhsNorm2 = d_b.squaredNorm(ctx);
+  RealScalar tol = RealScalar(1e-8);
+  RealScalar threshold = tol * tol * rhsNorm2;
+  RealScalar residualNorm2 = residual.squaredNorm(ctx);
+
+  // p = r (no preconditioner)
+  gpu::DeviceMatrix<Scalar> p(n, 1);
+  p.copyFrom(ctx, residual);
+  gpu::DeviceMatrix<Scalar> z(n, 1), tmp(n, 1);
+
+  auto absNew = residual.dot(ctx, p);
+  Index maxIters = 1000;
+  Index i = 0;
+  while (i < maxIters) {
+    tmp.noalias() = mat * p;
+
+    auto alpha = absNew / p.dot(ctx, tmp);
+    d_x += alpha * p;
+    residual -= alpha * tmp;
+
+    residualNorm2 = residual.squaredNorm(ctx);
+    if (residualNorm2 < threshold) break;
+
+    // z = r (no preconditioner)
+    z.copyFrom(ctx, residual);
+
+    auto absOld = std::move(absNew);
+    absNew = residual.dot(ctx, z);
+    auto beta = absNew / absOld;
+
+    p *= beta;
+    p += z;
+    i++;
+  }
+
+  gpu::Context::setThreadLocal(nullptr);
+
+  Vec x_gpu = d_x.toHost(ctx.stream());
+
+  // Verify residual.
+  Vec r = A * x_gpu - b;
+  RealScalar relres = r.norm() / b.norm();
+  VERIFY(relres < RealScalar(1e-6));
+
+  // Compare with CPU.
+  RealScalar sol_tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((x_gpu - x_cpu).norm() / (x_cpu.norm() + RealScalar(1)) < sol_tol);
+}
+
+// ---- GPU CG with Jacobi preconditioner --------------------------------------
+
+template <typename Scalar>
+void test_gpu_cg_jacobi(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  // CPU reference.
+  ConjugateGradient<SpMat, Lower | Upper> cpu_cg;
+  cpu_cg.setMaxIterations(1000);
+  cpu_cg.setTolerance(RealScalar(1e-8));
+  cpu_cg.compute(A);
+  Vec x_cpu = cpu_cg.solve(b);
+
+  // Extract inverse diagonal.
+  Vec invdiag(n);
+  for (Index j = 0; j < A.outerSize(); ++j) {
+    typename SpMat::InnerIterator it(A, j);
+    while (it && it.index() != j) ++it;
+    if (it && it.index() == j && it.value() != Scalar(0))
+      invdiag(j) = Scalar(1) / it.value();
+    else
+      invdiag(j) = Scalar(1);
+  }
+
+  // GPU CG with Jacobi preconditioner.
+  gpu::Context ctx;
+  gpu::Context::setThreadLocal(&ctx);
+  gpu::SparseContext<Scalar> spmv_ctx(ctx);
+  auto mat = spmv_ctx.deviceView(A);
+  auto d_invdiag = gpu::DeviceMatrix<Scalar>::fromHost(invdiag, ctx.stream());
+
+  auto d_b = gpu::DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_x(n, 1);
+  d_x.setZero(ctx);
+
+  gpu::DeviceMatrix<Scalar> residual(n, 1);
+  residual.copyFrom(ctx, d_b);
+
+  RealScalar rhsNorm2 = d_b.squaredNorm(ctx);
+  RealScalar tol = RealScalar(1e-8);
+  RealScalar threshold = tol * tol * rhsNorm2;
+  RealScalar residualNorm2 = residual.squaredNorm(ctx);
+
+  // p = precond.solve(r) = invdiag .* r
+  gpu::DeviceMatrix<Scalar> p = d_invdiag.cwiseProduct(ctx, residual);
+  gpu::DeviceMatrix<Scalar> z(n, 1), tmp(n, 1);
+
+  auto absNew = residual.dot(ctx, p);
+  Index maxIters = 1000;
+  Index i = 0;
+  while (i < maxIters) {
+    tmp.noalias() = mat * p;
+
+    auto alpha = absNew / p.dot(ctx, tmp);
+    d_x += alpha * p;
+    residual -= alpha * tmp;
+
+    residualNorm2 = residual.squaredNorm(ctx);
+    if (residualNorm2 < threshold) break;
+
+    // z = precond.solve(r) = invdiag .* r
+    z.cwiseProduct(ctx, d_invdiag, residual);
+
+    auto absOld = std::move(absNew);
+    absNew = residual.dot(ctx, z);
+    auto beta = absNew / absOld;
+
+    p *= beta;
+    p += z;
+    i++;
+  }
+
+  gpu::Context::setThreadLocal(nullptr);
+
+  Vec x_gpu = d_x.toHost(ctx.stream());
+
+  Vec r = A * x_gpu - b;
+  RealScalar relres = r.norm() / b.norm();
+  VERIFY(relres < RealScalar(1e-6));
+
+  RealScalar sol_tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((x_gpu - x_cpu).norm() / (x_cpu.norm() + RealScalar(1)) < sol_tol);
+}
+
+EIGEN_DECLARE_TEST(gpu_cg) {
+  gpu_test::require_cusparse_context();
+
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_gpu_cg<double>(64));
+  CALL_SUBTEST_1(test_gpu_cg<double>(256));
+  CALL_SUBTEST_1(test_gpu_cg_jacobi<double>(64));
+  CALL_SUBTEST_1(test_gpu_cg_jacobi<double>(256));
+  CALL_SUBTEST_2(test_gpu_cg<float>(64));
+  CALL_SUBTEST_2(test_gpu_cg<float>(256));
+  CALL_SUBTEST_2(test_gpu_cg_jacobi<float>(64));
+  CALL_SUBTEST_2(test_gpu_cg_jacobi<float>(256));
+}
diff --git a/contrib/test/GPU/cublas.cpp b/contrib/test/GPU/cublas.cpp
new file mode 100644
index 0000000..3258f6c
--- /dev/null
+++ b/contrib/test/GPU/cublas.cpp
@@ -0,0 +1,810 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for cuBLAS GEMM dispatch via DeviceMatrix expression syntax.
+// Covers: d_C = d_A * d_B, adjoint, transpose, scaled, +=, .device(ctx).
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <contrib/Eigen/GPU>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Basic GEMM: C = A * B -------------------------------------------------
+
+template <typename Scalar>
+void test_gemm_basic(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  // Expression: d_C = d_A * d_B
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM with adjoint: C = A^H * B ----------------------------------------
+
+template <typename Scalar>
+void test_gemm_adjoint_lhs(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(k, m);  // A is k×m, A^H is m×k
+  Mat B = Mat::Random(k, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A.adjoint() * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A.adjoint() * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM with transpose: C = A * B^T --------------------------------------
+
+template <typename Scalar>
+void test_gemm_transpose_rhs(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(n, k);  // B is n×k, B^T is k×n
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A * d_B.transpose();
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * B.transpose();
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM with view/view operands: C = alpha * A^T * B^H -------------------
+
+template <typename Scalar>
+void test_gemm_view_pairs(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(k, m);  // A^T is m x k
+  Mat B = Mat::Random(n, k);  // B^H is k x n
+  Scalar alpha = Scalar(2);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = (alpha * d_A.transpose()) * d_B.adjoint();
+
+  Mat C = d_C.toHost();
+  Mat C_ref = (alpha * A.transpose()) * B.adjoint();
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM with scaled: C = alpha * A * B ------------------------------------
+
+template <typename Scalar>
+void test_gemm_scaled(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+  Scalar alpha = Scalar(2.5);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = alpha * d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = alpha * A * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM accumulate: C += A * B (beta=1) -----------------------------------
+
+template <typename Scalar>
+void test_gemm_accumulate(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+  Mat C_init = Mat::Random(m, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+  auto d_C = gpu::DeviceMatrix<Scalar>::fromHost(C_init);
+
+  d_C += d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = C_init + A * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM accumulate into empty destination ---------------------------------
+
+template <typename Scalar>
+void test_gemm_accumulate_empty(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+  gpu::DeviceMatrix<Scalar> d_C;
+
+  d_C += d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM subtract: C -= A * B (beta=1, alpha=-1) --------------------------
+
+template <typename Scalar>
+void test_gemm_subtract(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+  Mat C_init = Mat::Random(m, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+  auto d_C = gpu::DeviceMatrix<Scalar>::fromHost(C_init);
+
+  gpu::Context ctx;
+  d_C.device(ctx) -= d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = C_init - A * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM subtract from empty destination -----------------------------------
+
+template <typename Scalar>
+void test_gemm_subtract_empty(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C.device(ctx) -= d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = -(A * B);
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM with scaled RHS: C = A * (alpha * B) -----------------------------
+
+template <typename Scalar>
+void test_gemm_scaled_rhs(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+  Scalar alpha = Scalar(3.0);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A * (alpha * d_B);
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * (alpha * B);
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM dimension mismatch must assert ------------------------------------
+// Note: we do NOT use VERIFY_RAISES_ASSERT here because it relies on
+// setjmp/longjmp which skips RAII destructors for DeviceMatrix (GPU memory)
+// and cuBLAS/cuSOLVER handles, corrupting state for subsequent tests.
+
+// ---- GEMM with explicit gpu::Context ------------------------------------------
+
+template <typename Scalar>
+void test_gemm_explicit_context(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C.device(ctx) = d_A * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * B;
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM cross-context reuse of the same destination -----------------------
+
+template <typename Scalar>
+void test_gemm_cross_context_reuse(Index n) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, n);
+  Mat D = Mat::Random(n, n);
+  Mat E = Mat::Random(n, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+  auto d_D = gpu::DeviceMatrix<Scalar>::fromHost(D);
+  auto d_E = gpu::DeviceMatrix<Scalar>::fromHost(E);
+
+  gpu::Context ctx1;
+  gpu::Context ctx2;
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C.device(ctx1) = d_A * d_B;
+  d_C.device(ctx2) += d_D * d_E;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * B + D * E;
+
+  RealScalar tol = RealScalar(2) * RealScalar(n) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM cross-context resize of the destination ---------------------------
+
+template <typename Scalar>
+void test_gemm_cross_context_resize() {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(64, 64);
+  Mat B = Mat::Random(64, 64);
+  Mat D = Mat::Random(32, 16);
+  Mat E = Mat::Random(16, 8);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+  auto d_D = gpu::DeviceMatrix<Scalar>::fromHost(D);
+  auto d_E = gpu::DeviceMatrix<Scalar>::fromHost(E);
+
+  gpu::Context ctx1;
+  gpu::Context ctx2;
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C.device(ctx1) = d_A * d_B;
+  d_C.device(ctx2) = d_D * d_E;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = D * E;
+
+  RealScalar tol = RealScalar(16) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- GEMM chaining: C = (A * B) then D = C * E -----------------------------
+
+template <typename Scalar>
+void test_gemm_chain(Index n) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, n);
+  Mat E = Mat::Random(n, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+  auto d_E = gpu::DeviceMatrix<Scalar>::fromHost(E);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A * d_B;
+  gpu::DeviceMatrix<Scalar> d_D;
+  d_D = d_C * d_E;
+
+  Mat D = d_D.toHost();
+  Mat D_ref = (A * B) * E;
+
+  RealScalar tol = RealScalar(2) * RealScalar(n) * NumTraits<Scalar>::epsilon() * D_ref.norm();
+  VERIFY((D - D_ref).norm() < tol);
+}
+
+// ---- LLT solve expression: d_X = d_A.llt().solve(d_B) ----------------------
+
+template <typename MatrixType>
+MatrixType make_spd(Index n) {
+  using Scalar = typename MatrixType::Scalar;
+  MatrixType M = MatrixType::Random(n, n);
+  return M.adjoint() * M + MatrixType::Identity(n, n) * static_cast<Scalar>(n);
+}
+
+template <typename Scalar>
+void test_llt_solve_expr(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = make_spd<Mat>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_A.llt().solve(d_B);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (A * X - B).norm() / B.norm();
+  VERIFY(residual < RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- LLT solve with explicit context ----------------------------------------
+
+template <typename Scalar>
+void test_llt_solve_expr_context(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = make_spd<Mat>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X.device(ctx) = d_A.llt().solve(d_B);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (A * X - B).norm() / B.norm();
+  VERIFY(residual < RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- LU solve expression: d_X = d_A.lu().solve(d_B) ------------------------
+
+template <typename Scalar>
+void test_lu_solve_expr(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_A.lu().solve(d_B);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+  VERIFY(residual < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- GEMM + solver chain: C = A * B, X = C.llt().solve(D) ------------------
+
+template <typename Scalar>
+void test_gemm_then_solve(Index n) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat D = Mat::Random(n, 1);
+
+  // Make SPD: C = A^H * A + n*I
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A.adjoint() * d_A;
+
+  // Add n*I on host (no element-wise ops on DeviceMatrix yet).
+  Mat C = d_C.toHost();
+  C += Mat::Identity(n, n) * static_cast<Scalar>(n);
+  d_C = gpu::DeviceMatrix<Scalar>::fromHost(C);
+
+  auto d_D = gpu::DeviceMatrix<Scalar>::fromHost(D);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_C.llt().solve(d_D);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (C * X - D).norm() / D.norm();
+  VERIFY(residual < RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- LLT solve with Upper triangle -----------------------------------------
+
+template <typename Scalar>
+void test_llt_solve_upper(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = make_spd<Mat>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_A.template llt<Upper>().solve(d_B);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (A * X - B).norm() / B.norm();
+  VERIFY(residual < RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- LU solve with explicit context -----------------------------------------
+
+template <typename Scalar>
+void test_lu_solve_expr_context(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X.device(ctx) = d_A.lu().solve(d_B);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+  VERIFY(residual < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- Zero-nrhs solver expressions ------------------------------------------
+
+template <typename Scalar>
+void test_llt_solve_zero_nrhs(Index n) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+
+  Mat A = make_spd<Mat>(n);
+  Mat B = Mat::Random(n, 0);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_A.llt().solve(d_B);
+
+  VERIFY_IS_EQUAL(d_X.rows(), n);
+  VERIFY_IS_EQUAL(d_X.cols(), 0);
+}
+
+template <typename Scalar>
+void test_lu_solve_zero_nrhs(Index n) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, 0);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_A.lu().solve(d_B);
+
+  VERIFY_IS_EQUAL(d_X.rows(), n);
+  VERIFY_IS_EQUAL(d_X.cols(), 0);
+}
+
+// ---- TRSM: triangularView<UpLo>().solve(B) ----------------------------------
+
+template <typename Scalar, int UpLo>
+void test_trsm(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // Build a well-conditioned triangular matrix.
+  Mat A = Mat::Random(n, n);
+  A.diagonal().array() += static_cast<Scalar>(n);  // ensure non-singular
+  if (UpLo == Lower)
+    A = A.template triangularView<Lower>();
+  else
+    A = A.template triangularView<Upper>();
+
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_X;
+  d_X = d_A.template triangularView<UpLo>().solve(d_B);
+
+  Mat X = d_X.toHost();
+  RealScalar residual = (A * X - B).norm() / B.norm();
+  VERIFY(residual < RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- SYMM/HEMM: selfadjointView<UpLo>() * B --------------------------------
+
+template <typename Scalar, int UpLo>
+void test_symm(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = make_spd<Mat>(n);  // SPD is also self-adjoint
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C = d_A.template selfadjointView<UpLo>() * d_B;
+
+  Mat C = d_C.toHost();
+  Mat C_ref = A * B;  // A is symmetric, so full multiply == symm
+
+  RealScalar tol = RealScalar(n) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C - C_ref).norm() < tol);
+}
+
+// ---- SYRK/HERK: rankUpdate(A) → C = A * A^H --------------------------------
+
+template <typename Scalar>
+void test_syrk(Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, k);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+
+  gpu::DeviceMatrix<Scalar> d_C;
+  d_C.template selfadjointView<Lower>().rankUpdate(d_A);
+
+  Mat C = d_C.toHost();
+  // Only lower triangle is meaningful for SYRK. Compare lower triangle.
+  Mat C_ref = A * A.adjoint();
+
+  // Extract lower triangle for comparison.
+  Mat C_lower = C.template triangularView<Lower>();
+  Mat C_ref_lower = C_ref.template triangularView<Lower>();
+
+  RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * C_ref.norm();
+  VERIFY((C_lower - C_ref_lower).norm() < tol);
+}
+
+// ---- Expression sugar: copy-init, operator-=, scalar operators --------------
+
+template <typename Scalar>
+void test_expression_sugar(Index m, Index n, Index k) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+  Mat C0 = Mat::Random(m, n);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  const RealScalar tol = RealScalar(k) * NumTraits<Scalar>::epsilon() * RealScalar(A.norm() * B.norm());
+
+  // Copy-initialization straight from a GEMM expression (README headline syntax).
+  gpu::DeviceMatrix<Scalar> d_C = d_A * d_B;
+  VERIFY((d_C.toHost() - A * B).norm() < tol);
+
+  // Plain operator-= on GEMM (no .device(ctx) needed).
+  auto d_E = gpu::DeviceMatrix<Scalar>::fromHost(C0);
+  d_E -= d_A * d_B;
+  VERIFY((d_E.toHost() - (C0 - A * B)).norm() < tol);
+
+  // Scalar sugar: int literals, matrix * scalar, division, unary minus.
+  Mat S = Mat::Random(m, n);
+  auto d_S = gpu::DeviceMatrix<Scalar>::fromHost(S);
+  gpu::DeviceMatrix<Scalar> d_F = 2 * d_S;
+  VERIFY_IS_APPROX(d_F.toHost(), Mat(Scalar(2) * S));
+
+  gpu::DeviceMatrix<Scalar> d_G = d_S * Scalar(3);
+  VERIFY_IS_APPROX(d_G.toHost(), Mat(Scalar(3) * S));
+
+  gpu::DeviceMatrix<Scalar> d_H = d_S / 2;
+  VERIFY_IS_APPROX(d_H.toHost(), Mat(S / Scalar(2)));
+
+  gpu::DeviceMatrix<Scalar> d_I = -d_S;
+  VERIFY_IS_APPROX(d_I.toHost(), Mat(-S));
+
+  // Scaled ± Scaled and Scaled ± Matrix combinations (geam quadrant).
+  Mat T = Mat::Random(m, n);
+  auto d_T = gpu::DeviceMatrix<Scalar>::fromHost(T);
+  gpu::DeviceMatrix<Scalar> d_J = 2 * d_S - d_T;
+  VERIFY_IS_APPROX(d_J.toHost(), Mat(Scalar(2) * S - T));
+
+  gpu::DeviceMatrix<Scalar> d_K = 2 * d_S + 3 * d_T;
+  VERIFY_IS_APPROX(d_K.toHost(), Mat(Scalar(2) * S + Scalar(3) * T));
+
+  gpu::DeviceMatrix<Scalar> d_L = -(2 * d_S) - 3 * d_T;
+  VERIFY_IS_APPROX(d_L.toHost(), Mat(Scalar(-2) * S - Scalar(3) * T));
+
+  // In-place rescale via assignment (geam with beta=0, aliasing-safe).
+  d_L = Scalar(0.5) * d_L;
+  VERIFY_IS_APPROX(d_L.toHost(), Mat(Scalar(-1) * S - Scalar(1.5) * T));
+
+  // .device(ctx) with geam expressions.
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_M;
+  d_M.device(ctx) = d_S + 2 * d_T;
+  VERIFY_IS_APPROX(d_M.toHost(), Mat(S + Scalar(2) * T));
+}
+
+template <typename Scalar>
+void test_solve_expr_copy_init(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = make_spd<Mat>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  // Copy-initialization from one-shot solver expressions.
+  gpu::DeviceMatrix<Scalar> d_X = d_A.llt().solve(d_B);
+  Mat X = d_X.toHost();
+  VERIFY((A * X - B).norm() / B.norm() < RealScalar(n) * NumTraits<Scalar>::epsilon());
+
+  gpu::DeviceMatrix<Scalar> d_Y = d_A.lu().solve(d_B);
+  Mat Y = d_Y.toHost();
+  VERIFY((A * Y - B).norm() / B.norm() < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_expression_sugar<Scalar>(64, 48, 32));
+  CALL_SUBTEST(test_solve_expr_copy_init<Scalar>(64, 4));
+
+  CALL_SUBTEST(test_gemm_basic<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_basic<Scalar>(128, 64, 32));
+  CALL_SUBTEST(test_gemm_basic<Scalar>(1, 1, 1));
+  CALL_SUBTEST(test_gemm_basic<Scalar>(256, 256, 256));
+
+  CALL_SUBTEST(test_gemm_adjoint_lhs<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_adjoint_lhs<Scalar>(128, 32, 64));
+
+  CALL_SUBTEST(test_gemm_transpose_rhs<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_transpose_rhs<Scalar>(128, 32, 64));
+  CALL_SUBTEST(test_gemm_view_pairs<Scalar>(64, 32, 48));
+
+  CALL_SUBTEST(test_gemm_scaled<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_scaled_rhs<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_accumulate<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_accumulate_empty<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_subtract<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_subtract_empty<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_explicit_context<Scalar>(64, 64, 64));
+  CALL_SUBTEST(test_gemm_cross_context_reuse<Scalar>(64));
+  CALL_SUBTEST(test_gemm_cross_context_resize<Scalar>());
+  CALL_SUBTEST(test_gemm_chain<Scalar>(64));
+
+  // Solver expressions — zero-size edge cases (use dedicated tests, not residual-based)
+
+  // Solver expressions
+  CALL_SUBTEST(test_llt_solve_expr<Scalar>(64, 1));
+  CALL_SUBTEST(test_llt_solve_expr<Scalar>(64, 4));
+  CALL_SUBTEST(test_llt_solve_expr<Scalar>(256, 8));
+  CALL_SUBTEST(test_llt_solve_expr_context<Scalar>(64, 4));
+  CALL_SUBTEST(test_llt_solve_upper<Scalar>(64, 4));
+  CALL_SUBTEST(test_lu_solve_expr<Scalar>(64, 1));
+  CALL_SUBTEST(test_lu_solve_expr<Scalar>(64, 4));
+  CALL_SUBTEST(test_lu_solve_expr<Scalar>(256, 8));
+  CALL_SUBTEST(test_lu_solve_expr_context<Scalar>(64, 4));
+  CALL_SUBTEST(test_llt_solve_zero_nrhs<Scalar>(64));
+  CALL_SUBTEST(test_llt_solve_zero_nrhs<Scalar>(0));
+  CALL_SUBTEST(test_lu_solve_zero_nrhs<Scalar>(64));
+  CALL_SUBTEST(test_lu_solve_zero_nrhs<Scalar>(0));
+  CALL_SUBTEST(test_gemm_then_solve<Scalar>(64));
+
+  // TRSM
+  CALL_SUBTEST((test_trsm<Scalar, Lower>(64, 1)));
+  CALL_SUBTEST((test_trsm<Scalar, Lower>(64, 4)));
+  CALL_SUBTEST((test_trsm<Scalar, Upper>(64, 4)));
+  CALL_SUBTEST((test_trsm<Scalar, Lower>(256, 8)));
+
+  // SYMM/HEMM
+  CALL_SUBTEST((test_symm<Scalar, Lower>(64, 4)));
+  CALL_SUBTEST((test_symm<Scalar, Upper>(64, 4)));
+  CALL_SUBTEST((test_symm<Scalar, Lower>(128, 8)));
+
+  // SYRK/HERK
+  CALL_SUBTEST(test_syrk<Scalar>(64, 64));
+  CALL_SUBTEST(test_syrk<Scalar>(64, 32));
+  CALL_SUBTEST(test_syrk<Scalar>(128, 64));
+}
+
+// ---- Solver failure mode tests (not templated on Scalar) --------------------
+// Use the cached GpuLLT/GpuLU API which reports failure via info() rather than
+// the expression API which asserts inside dispatch (incompatible with
+// VERIFY_RAISES_ASSERT due to longjmp skipping RAII destructors).
+
+void test_llt_not_spd() {
+  // Negative definite matrix — LLT factorization must fail.
+  MatrixXd A = -MatrixXd::Identity(8, 8);
+  gpu::LLT<double> llt(A);
+  VERIFY_IS_EQUAL(llt.info(), NumericalIssue);
+}
+
+void test_lu_singular() {
+  // Zero matrix — LU factorization must detect singularity.
+  MatrixXd A = MatrixXd::Zero(8, 8);
+  gpu::LU<double> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), NumericalIssue);
+}
+
+EIGEN_DECLARE_TEST(gpu_cublas) {
+  gpu_test::require_cuda_device();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_llt_not_spd());
+  CALL_SUBTEST_5(test_lu_singular());
+}
diff --git a/contrib/test/GPU/cublas_64bit.cpp b/contrib/test/GPU/cublas_64bit.cpp
new file mode 100644
index 0000000..3610228
--- /dev/null
+++ b/contrib/test/GPU/cublas_64bit.cpp
@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Compile- and host-time checks for the cuBLAS 64-bit dimension adapters.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <contrib/Eigen/GPU>
+
+using namespace Eigen;
+
+using CublasXgemmFloat = cublasStatus_t (*)(cublasHandle_t, cublasOperation_t, cublasOperation_t, int64_t, int64_t,
+                                            int64_t, const float*, const float*, int64_t, const float*, int64_t,
+                                            const float*, float*, int64_t);
+
+static_assert(
+    std::is_same<decltype(static_cast<CublasXgemmFloat>(&gpu::internal::cublasXgemm)), CublasXgemmFloat>::value,
+    "cublasXgemm dimensions must remain 64-bit");
+
+#if defined(CUBLAS_VERSION) && CUBLAS_VERSION >= 120000
+static_assert(std::is_same<decltype(gpu::internal::to_blas_dim(int64_t{})), int64_t>::value,
+              "cuBLAS 12 and newer must preserve 64-bit dimensions");
+#else
+static_assert(std::is_same<decltype(gpu::internal::to_blas_dim(int64_t{})), int>::value,
+              "pre-12 cuBLAS must narrow dimensions to int");
+#endif
+
+void test_cublas_64bit_dimension_contract() {
+  constexpr int64_t kLargeDim = int64_t{1} << 32;
+  VERIFY_IS_EQUAL(gpu::internal::blas1_size(Index{1} << 16, Index{1} << 16), kLargeDim);
+
+#if defined(CUBLAS_VERSION) && CUBLAS_VERSION >= 120000
+  VERIFY_IS_EQUAL(gpu::internal::to_blas_dim(kLargeDim), kLargeDim);
+#endif
+
+  CublasXgemmFloat volatile gemm = static_cast<CublasXgemmFloat>(&gpu::internal::cublasXgemm);
+  VERIFY(gemm != nullptr);
+}
+
+EIGEN_DECLARE_TEST(gpu_cublas_64bit) { CALL_SUBTEST(test_cublas_64bit_dimension_contract()); }
diff --git a/contrib/test/GPU/cudss_ldlt.cpp b/contrib/test/GPU/cudss_ldlt.cpp
new file mode 100644
index 0000000..51ba049
--- /dev/null
+++ b/contrib/test/GPU/cudss_ldlt.cpp
@@ -0,0 +1,218 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuSparseLDLT: GPU sparse LDL^T via cuDSS.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Helper: build a random sparse symmetric indefinite matrix ---------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_symmetric_indefinite(Index n, double density = 0.1) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // Diagonal has mixed signs for indefiniteness. For complex Scalar:
+  // off-diagonals carry nonzero imaginary parts so the Hermitian path is
+  // genuinely exercised; diagonal stays real so A = R + R.adjoint() has a
+  // real diagonal explicitly (R + R.adjoint() at i,i = 2*Re(R_ii) regardless).
+  SpMat R(n, n);
+  R.reserve(VectorXi::Constant(n, static_cast<int>(n * density) + 1));
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = 0; i < n; ++i) {
+      if (i == j || (std::rand() / double(RAND_MAX)) < density) {
+        const RealScalar re = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        const RealScalar im = (i == j) ? RealScalar(0) : RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        R.insert(i, j) = gpu_test::make_test_value<Scalar>(re, im);
+      }
+    }
+  }
+  R.makeCompressed();
+
+  // A = R + R^H (symmetric), then add diagonal with alternating signs for indefiniteness.
+  SpMat A = R + SparseMatrix<Scalar, ColMajor, int>(R.adjoint());
+  for (Index i = 0; i < n; ++i) {
+    Scalar diag_val = Scalar((i % 2 == 0) ? n : -n);
+    A.coeffRef(i, i) += diag_val;
+  }
+  A.makeCompressed();
+  return A;
+}
+
+// ---- Solve and check residual -----------------------------------------------
+
+template <typename Scalar>
+void test_solve(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_symmetric_indefinite<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLDLT<Scalar> ldlt(A);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+
+  Vec x = ldlt.solve(b);
+  VERIFY_IS_EQUAL(x.rows(), n);
+
+  Vec r = A * x - b;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(r.norm() / b.norm() < tol);
+}
+
+// ---- Multiple RHS -----------------------------------------------------------
+
+template <typename Scalar>
+void test_multiple_rhs(Index n, Index nrhs) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_symmetric_indefinite<Scalar>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  gpu::SparseLDLT<Scalar> ldlt(A);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+
+  Mat X = ldlt.solve(B);
+  VERIFY_IS_EQUAL(X.rows(), n);
+  VERIFY_IS_EQUAL(X.cols(), nrhs);
+
+  Mat R = A * X - B;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(R.norm() / B.norm() < tol);
+}
+
+// ---- Refactorize ------------------------------------------------------------
+
+template <typename Scalar>
+void test_refactorize(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_symmetric_indefinite<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLDLT<Scalar> ldlt;
+  ldlt.analyzePattern(A);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+
+  ldlt.factorize(A);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+  Vec x1 = ldlt.solve(b);
+
+  // Modify values, keep pattern.
+  SpMat A2 = A;
+  for (Index i = 0; i < n; ++i) A2.coeffRef(i, i) *= Scalar(RealScalar(2));
+
+  ldlt.factorize(A2);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+  Vec x2 = ldlt.solve(b);
+
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((A * x1 - b).norm() / b.norm() < tol);
+  VERIFY((A2 * x2 - b).norm() / b.norm() < tol);
+  // Diagonal scaled 2x; x1 and x2 must differ by a substantial fraction.
+  VERIFY((x1 - x2).norm() > RealScalar(0.01) * x1.norm());
+}
+
+// ---- Solver configuration ---------------------------------------------------
+
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+template <typename Scalar>
+void test_config(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_symmetric_indefinite<Scalar>(n);
+  Vec b = Vec::Random(n);
+  const RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  // Every reordering algorithm valid for symmetric matrices must yield a
+  // correct factorization.
+  const gpu::SparseReordering orderings[] = {gpu::SparseReordering::Default, gpu::SparseReordering::Amd,
+                                             gpu::SparseReordering::NestedDissection, gpu::SparseReordering::Natural};
+  for (gpu::SparseReordering r : orderings) {
+    gpu::SparseSolverConfig cfg;
+    cfg.reordering = r;
+    gpu::SparseLDLT<Scalar> ldlt;
+    ldlt.setConfig(cfg);
+    VERIFY(ldlt.config().reordering == r);
+    ldlt.compute(A);
+    VERIFY_IS_EQUAL(ldlt.info(), Success);
+    Vec x = ldlt.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+
+  // Diagonal pivoting (symmetric indefinite) with iterative refinement.
+  {
+    gpu::SparseSolverConfig cfg;
+    cfg.reordering = gpu::SparseReordering::Amd;
+    cfg.pivoting = gpu::SparsePivoting::Diagonal;
+    cfg.refinementSteps = 2;
+    gpu::SparseLDLT<Scalar> ldlt;
+    ldlt.setConfig(cfg);
+    ldlt.compute(A);
+    VERIFY_IS_EQUAL(ldlt.info(), Success);
+    Vec x = ldlt.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+}
+
+#endif  // EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+// ---- Empty ------------------------------------------------------------------
+
+template <typename Scalar>
+void test_empty() {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  SpMat A(0, 0);
+  A.makeCompressed();
+  gpu::SparseLDLT<Scalar> ldlt(A);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+  VERIFY_IS_EQUAL(ldlt.rows(), 0);
+  VERIFY_IS_EQUAL(ldlt.cols(), 0);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_solve<Scalar>(64));
+  CALL_SUBTEST(test_solve<Scalar>(256));
+  CALL_SUBTEST(test_multiple_rhs<Scalar>(64, 4));
+  CALL_SUBTEST(test_refactorize<Scalar>(64));
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+  CALL_SUBTEST(test_config<Scalar>(64));
+#endif
+}
+
+EIGEN_DECLARE_TEST(gpu_cudss_ldlt) {
+  gpu_test::require_cudss_context();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_empty<float>());
+  CALL_SUBTEST_5(test_empty<double>());
+  CALL_SUBTEST_5(test_empty<std::complex<float>>());
+  CALL_SUBTEST_5(test_empty<std::complex<double>>());
+}
diff --git a/contrib/test/GPU/cudss_llt.cpp b/contrib/test/GPU/cudss_llt.cpp
new file mode 100644
index 0000000..3e1eeab
--- /dev/null
+++ b/contrib/test/GPU/cudss_llt.cpp
@@ -0,0 +1,328 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuSparseLLT: GPU sparse Cholesky via cuDSS.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Helper: build a random sparse SPD matrix -------------------------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_spd(Index n, double density = 0.1) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // Off-diagonal entries carry nonzero imaginary parts for complex Scalar so
+  // the cuDSS HPD path (CUDSS_MTYPE_HPD) is genuinely exercised; A = R^H * R
+  // is Hermitian regardless of R, and the +nI shift keeps the diagonal real.
+  SpMat R(n, n);
+  R.reserve(VectorXi::Constant(n, static_cast<int>(n * density) + 1));
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = 0; i < n; ++i) {
+      if (i == j || (std::rand() / double(RAND_MAX)) < density) {
+        const RealScalar re = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        const RealScalar im = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        R.insert(i, j) = gpu_test::make_test_value<Scalar>(re, im);
+      }
+    }
+  }
+  R.makeCompressed();
+
+  // A = R^H * R + n * I  (guaranteed SPD).
+  SpMat A = R.adjoint() * R;
+  for (Index i = 0; i < n; ++i) A.coeffRef(i, i) += Scalar(RealScalar(n));
+  A.makeCompressed();
+  return A;
+}
+
+// ---- Solve and check residual -----------------------------------------------
+
+template <typename Scalar>
+void test_solve(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLLT<Scalar> llt(A);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+
+  Vec x = llt.solve(b);
+  VERIFY_IS_EQUAL(x.rows(), n);
+
+  // Check residual: ||Ax - b|| / ||b||.
+  Vec r = A * x - b;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(r.norm() / b.norm() < tol);
+}
+
+// ---- Compare with CPU SimplicialLLT -----------------------------------------
+
+template <typename Scalar>
+void test_vs_cpu(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLLT<Scalar> gpu_llt(A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Success);
+  Vec x_gpu = gpu_llt.solve(b);
+
+  SimplicialLLT<SpMat> cpu_llt(A);
+  VERIFY_IS_EQUAL(cpu_llt.info(), Success);
+  Vec x_cpu = cpu_llt.solve(b);
+
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((x_gpu - x_cpu).norm() / x_cpu.norm() < tol);
+}
+
+// ---- Multiple RHS -----------------------------------------------------------
+
+template <typename Scalar>
+void test_multiple_rhs(Index n, Index nrhs) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  gpu::SparseLLT<Scalar> llt(A);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+
+  Mat X = llt.solve(B);
+  VERIFY_IS_EQUAL(X.rows(), n);
+  VERIFY_IS_EQUAL(X.cols(), nrhs);
+
+  Mat R = A * X - B;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(R.norm() / B.norm() < tol);
+}
+
+// ---- Separate analyze + factorize (refactorization) -------------------------
+
+template <typename Scalar>
+void test_refactorize(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLLT<Scalar> llt;
+  llt.analyzePattern(A);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+
+  // First factorize + solve.
+  llt.factorize(A);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+  Vec x1 = llt.solve(b);
+
+  // Modify values (keep same pattern): scale diagonal.
+  SpMat A2 = A;
+  for (Index i = 0; i < n; ++i) A2.coeffRef(i, i) *= Scalar(RealScalar(2));
+
+  // Refactorize with same pattern.
+  llt.factorize(A2);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+  Vec x2 = llt.solve(b);
+
+  // Both solutions should satisfy their respective systems.
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((A * x1 - b).norm() / b.norm() < tol);
+  VERIFY((A2 * x2 - b).norm() / b.norm() < tol);
+
+  // Solutions should differ meaningfully: diagonal was scaled 2x, so x1 vs x2
+  // should differ by a substantial fraction of x1's magnitude. A near-epsilon
+  // bound here would pass even if refactorize silently reused the stale factor.
+  VERIFY((x1 - x2).norm() > RealScalar(0.01) * x1.norm());
+}
+
+// ---- Solver configuration ---------------------------------------------------
+
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+template <typename Scalar>
+void test_config(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+  const RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  // Every reordering algorithm valid for symmetric matrices must yield a
+  // correct factorization.
+  const gpu::SparseReordering orderings[] = {gpu::SparseReordering::Default, gpu::SparseReordering::Amd,
+                                             gpu::SparseReordering::NestedDissection, gpu::SparseReordering::Natural};
+  for (gpu::SparseReordering r : orderings) {
+    gpu::SparseSolverConfig cfg;
+    cfg.reordering = r;
+    gpu::SparseLLT<Scalar> llt;
+    llt.setConfig(cfg);
+    VERIFY(llt.config().reordering == r);
+    llt.compute(A);
+    VERIFY_IS_EQUAL(llt.info(), Success);
+    Vec x = llt.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+
+  // Iterative refinement during solve().
+  {
+    gpu::SparseSolverConfig cfg;
+    cfg.refinementSteps = 2;
+    gpu::SparseLLT<Scalar> llt;
+    llt.setConfig(cfg);
+    llt.compute(A);
+    VERIFY_IS_EQUAL(llt.info(), Success);
+    Vec x = llt.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+
+  // The "let cuDSS decide" sentinel for the hybrid device budget is negative,
+  // as it is in cuDSS itself, so that a budget of zero bytes stays a budget a
+  // caller can ask for rather than a second spelling of the default.
+  {
+    gpu::SparseSolverConfig cfg;
+    VERIFY(cfg.isDefault());
+    VERIFY(cfg.hybridMemoryDeviceLimit < 0);
+    cfg.hybridMemoryDeviceLimit = 0;
+    VERIFY(!cfg.isDefault());
+  }
+
+  // Hybrid memory mode, with the budget left to cuDSS and pinned explicitly.
+  // Zero is deliberately not exercised end to end: cuDSS then has no device
+  // memory to factor in and fails the factorization, which EIGEN_CUDSS_CHECK
+  // turns into an assertion rather than an info() code.
+  const int64_t limits[] = {-1, int64_t(1) << 26};
+  for (int64_t limit : limits) {
+    gpu::SparseSolverConfig cfg;
+    cfg.hybridMemory = true;
+    cfg.hybridMemoryDeviceLimit = limit;
+    gpu::SparseLLT<Scalar> llt;
+    llt.setConfig(cfg);
+    VERIFY_IS_EQUAL(llt.config().hybridMemoryDeviceLimit, limit);
+    llt.compute(A);
+    VERIFY_IS_EQUAL(llt.info(), Success);
+    Vec x = llt.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+}
+
+#endif  // EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+// ---- Empty matrix -----------------------------------------------------------
+
+template <typename Scalar>
+void test_empty() {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  SpMat A(0, 0);
+  A.makeCompressed();
+  gpu::SparseLLT<Scalar> llt(A);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+  VERIFY_IS_EQUAL(llt.rows(), 0);
+  VERIFY_IS_EQUAL(llt.cols(), 0);
+}
+
+// ---- Upper triangle ---------------------------------------------------------
+
+template <typename Scalar>
+void test_upper(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_spd<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLLT<Scalar, Upper> llt(A);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+
+  Vec x = llt.solve(b);
+  Vec r = A * x - b;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(r.norm() / b.norm() < tol);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_solve<Scalar>(64));
+  CALL_SUBTEST(test_solve<Scalar>(256));
+  CALL_SUBTEST(test_vs_cpu<Scalar>(64));
+  CALL_SUBTEST(test_multiple_rhs<Scalar>(64, 4));
+  CALL_SUBTEST(test_refactorize<Scalar>(64));
+  CALL_SUBTEST(test_upper<Scalar>(64));
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+  CALL_SUBTEST(test_config<Scalar>(64));
+#endif
+}
+
+// ---- Device-resident solve + Context binding -----------------------------------
+
+template <typename Scalar>
+void test_device_solve_context(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  SpMat A = make_spd<Scalar>(n);
+  Mat B = Mat::Random(n, 3);
+
+  gpu::Context gctx;
+  gpu::SparseLLT<Scalar> llt(gctx, A);
+  VERIFY(llt.info() == Success);
+  VERIFY(llt.stream() == gctx.stream());
+
+  Mat X_host = llt.solve(B);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+  VERIFY_IS_APPROX(d_X.toHost(), X_host);
+
+  // Second device solve reuses the cached dense descriptors.
+  gpu::DeviceMatrix<Scalar> d_X2 = llt.solve(d_B);
+  VERIFY_IS_APPROX(d_X2.toHost(), X_host);
+}
+
+void test_default_stream_context() {
+  gpu::Context gctx(/*stream=*/nullptr);
+  gpu::SparseLLT<float> llt(gctx);
+  VERIFY_IS_EQUAL(llt.stream(), gctx.stream());
+  VERIFY_IS_EQUAL(llt.stream(), static_cast<cudaStream_t>(nullptr));
+}
+
+EIGEN_DECLARE_TEST(gpu_cudss_llt) {
+  gpu_test::require_cudss_context();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_empty<float>());
+  CALL_SUBTEST_5(test_empty<double>());
+  CALL_SUBTEST_5(test_empty<std::complex<float>>());
+  CALL_SUBTEST_5(test_empty<std::complex<double>>());
+  CALL_SUBTEST_5(test_device_solve_context<float>(64));
+  CALL_SUBTEST_5(test_device_solve_context<double>(64));
+  CALL_SUBTEST_5(test_default_stream_context());
+}
diff --git a/contrib/test/GPU/cudss_lu.cpp b/contrib/test/GPU/cudss_lu.cpp
new file mode 100644
index 0000000..b108674
--- /dev/null
+++ b/contrib/test/GPU/cudss_lu.cpp
@@ -0,0 +1,256 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuSparseLU: GPU sparse LU via cuDSS.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Helper: build a random sparse non-singular general matrix ---------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_general(Index n, double density = 0.1) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat R(n, n);
+  R.reserve(VectorXi::Constant(n, static_cast<int>(n * density) + 1));
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = 0; i < n; ++i) {
+      if (i == j || (std::rand() / double(RAND_MAX)) < density) {
+        const RealScalar re = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        const RealScalar im = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        R.insert(i, j) = gpu_test::make_test_value<Scalar>(re, im);
+      }
+    }
+  }
+  // Add strong diagonal for non-singularity.
+  for (Index i = 0; i < n; ++i) R.coeffRef(i, i) += Scalar(RealScalar(n));
+  R.makeCompressed();
+  return R;
+}
+
+// ---- Solve and check residual -----------------------------------------------
+
+template <typename Scalar>
+void test_solve(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_general<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  Vec x = lu.solve(b);
+  VERIFY_IS_EQUAL(x.rows(), n);
+
+  Vec r = A * x - b;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(r.norm() / b.norm() < tol);
+}
+
+// ---- Multiple RHS -----------------------------------------------------------
+
+template <typename Scalar>
+void test_multiple_rhs(Index n, Index nrhs) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_general<Scalar>(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  gpu::SparseLU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  Mat X = lu.solve(B);
+  VERIFY_IS_EQUAL(X.rows(), n);
+  VERIFY_IS_EQUAL(X.cols(), nrhs);
+
+  Mat R = A * X - B;
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(R.norm() / B.norm() < tol);
+}
+
+// ---- Refactorize ------------------------------------------------------------
+
+template <typename Scalar>
+void test_refactorize(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_general<Scalar>(n);
+  Vec b = Vec::Random(n);
+
+  gpu::SparseLU<Scalar> lu;
+  lu.analyzePattern(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  lu.factorize(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+  Vec x1 = lu.solve(b);
+
+  // Modify values, keep pattern.
+  SpMat A2 = A;
+  for (Index i = 0; i < n; ++i) A2.coeffRef(i, i) *= Scalar(RealScalar(2));
+
+  lu.factorize(A2);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+  Vec x2 = lu.solve(b);
+
+  RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((A * x1 - b).norm() / b.norm() < tol);
+  VERIFY((A2 * x2 - b).norm() / b.norm() < tol);
+  // Diagonal scaled 2x; x1 and x2 must differ by a substantial fraction.
+  VERIFY((x1 - x2).norm() > RealScalar(0.01) * x1.norm());
+}
+
+// ---- Solver configuration ---------------------------------------------------
+
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+template <typename Scalar>
+void test_config(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_general<Scalar>(n);
+  Vec b = Vec::Random(n);
+  const RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  // Every reordering algorithm valid for general matrices must yield a
+  // correct factorization.
+  const gpu::SparseReordering orderings[] = {gpu::SparseReordering::Default,          gpu::SparseReordering::BtfColamd,
+                                             gpu::SparseReordering::Colamd,           gpu::SparseReordering::Amd,
+                                             gpu::SparseReordering::NestedDissection, gpu::SparseReordering::Natural};
+  for (gpu::SparseReordering r : orderings) {
+    gpu::SparseSolverConfig cfg;
+    cfg.reordering = r;
+    gpu::SparseLU<Scalar> lu;
+    lu.setConfig(cfg);
+    VERIFY(lu.config().reordering == r);
+    lu.compute(A);
+    VERIFY_IS_EQUAL(lu.info(), Success);
+    Vec x = lu.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+
+  // Robustness-oriented knobs: matching, pivot threshold, iterative
+  // refinement.
+  {
+    gpu::SparseSolverConfig cfg;
+    cfg.matching = gpu::SparseMatching::MaxDiagProduct;
+    cfg.pivotThreshold = 1.0;
+    cfg.refinementSteps = 2;
+    gpu::SparseLU<Scalar> lu;
+    lu.setConfig(cfg);
+    lu.compute(A);
+    VERIFY_IS_EQUAL(lu.info(), Success);
+    Vec x = lu.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+
+  // Hybrid host/device memory mode.
+  {
+    gpu::SparseSolverConfig cfg;
+    cfg.hybridMemory = true;
+    gpu::SparseLU<Scalar> lu;
+    lu.setConfig(cfg);
+    lu.compute(A);
+    VERIFY_IS_EQUAL(lu.info(), Success);
+    Vec x = lu.solve(b);
+    VERIFY((A * x - b).norm() / b.norm() < tol);
+  }
+}
+
+#else  // !EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+// This cuDSS names none of the algorithms SparseSolverConfig forwards, so their
+// enumerators are not declared here at all and only the remaining knobs can be
+// set. Those cannot be honored either: setConfig() must refuse them rather than
+// solve with the defaults they meant to replace, while a default config still
+// works.
+template <typename Scalar>
+void test_config_unsupported(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_general<Scalar>(n);
+  Vec b = Vec::Random(n);
+  const RealScalar tol = RealScalar(100) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  gpu::SparseSolverConfig cfg;
+  cfg.refinementSteps = 2;
+  gpu::SparseLU<Scalar> lu;
+  // Safe here where the module otherwise avoids VERIFY_RAISES_ASSERT: the
+  // assert fires before any GPU work is queued, and lu outlives the throw.
+  VERIFY_RAISES_ASSERT(lu.setConfig(cfg));
+
+  gpu::SparseSolverConfig default_cfg;
+  lu.setConfig(default_cfg);
+  lu.compute(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+  Vec x = lu.solve(b);
+  VERIFY((A * x - b).norm() / b.norm() < tol);
+}
+
+#endif  // EIGEN_HAS_CUDSS_SOLVER_CONFIG
+
+// ---- Empty ------------------------------------------------------------------
+
+template <typename Scalar>
+void test_empty() {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  SpMat A(0, 0);
+  A.makeCompressed();
+  gpu::SparseLU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+  VERIFY_IS_EQUAL(lu.rows(), 0);
+  VERIFY_IS_EQUAL(lu.cols(), 0);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_solve<Scalar>(64));
+  CALL_SUBTEST(test_solve<Scalar>(256));
+  CALL_SUBTEST(test_multiple_rhs<Scalar>(64, 4));
+  CALL_SUBTEST(test_refactorize<Scalar>(64));
+#if EIGEN_HAS_CUDSS_SOLVER_CONFIG
+  CALL_SUBTEST(test_config<Scalar>(64));
+#else
+  CALL_SUBTEST(test_config_unsupported<Scalar>(64));
+#endif
+}
+
+EIGEN_DECLARE_TEST(gpu_cudss_lu) {
+  gpu_test::require_cudss_context();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_empty<float>());
+  CALL_SUBTEST_5(test_empty<double>());
+  CALL_SUBTEST_5(test_empty<std::complex<float>>());
+  CALL_SUBTEST_5(test_empty<std::complex<double>>());
+}
diff --git a/contrib/test/GPU/cufft.cpp b/contrib/test/GPU/cufft.cpp
new file mode 100644
index 0000000..abdc9d3
--- /dev/null
+++ b/contrib/test/GPU/cufft.cpp
@@ -0,0 +1,312 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuFFT: GPU FFT via cuFFT.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- 1D C2C roundtrip: inv(fwd(x)) ≈ x -------------------------------------
+
+template <typename Scalar>
+void test_c2c_roundtrip(Index n) {
+  using Complex = std::complex<Scalar>;
+  using Vec = Matrix<Complex, Dynamic, 1>;
+  using RealScalar = Scalar;
+
+  Vec x = Vec::Random(n);
+
+  gpu::FFT<Scalar> fft;
+  Vec X = fft.fwd(x);
+  VERIFY_IS_EQUAL(X.size(), n);
+
+  Vec y = fft.inv(X);
+  VERIFY_IS_EQUAL(y.size(), n);
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y - x).norm() / x.norm() < tol);
+}
+
+// ---- 1D C2C known signal: FFT of constant = delta --------------------------
+
+template <typename Scalar>
+void test_c2c_constant() {
+  using Complex = std::complex<Scalar>;
+  using Vec = Matrix<Complex, Dynamic, 1>;
+  using RealScalar = Scalar;
+
+  const int n = 64;
+  Vec x = Vec::Constant(n, Complex(3.0, 0.0));
+
+  gpu::FFT<Scalar> fft;
+  Vec X = fft.fwd(x);
+
+  // FFT of constant c: X[0] = c*n, X[k] = 0 for k > 0.
+  RealScalar tol = RealScalar(10) * NumTraits<Scalar>::epsilon() * RealScalar(n);
+  VERIFY(std::abs(X(0) - Complex(3.0 * n, 0.0)) < tol);
+  for (int k = 1; k < n; ++k) {
+    VERIFY(std::abs(X(k)) < tol);
+  }
+}
+
+// ---- 1D R2C/C2R roundtrip: invReal(fwd(r), n) ≈ r --------------------------
+
+template <typename Scalar>
+void test_r2c_roundtrip(Index n) {
+  using Complex = std::complex<Scalar>;
+  using CVec = Matrix<Complex, Dynamic, 1>;
+  using RVec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = Scalar;
+
+  RVec r = RVec::Random(n);
+
+  gpu::FFT<Scalar> fft;
+  CVec R = fft.fwd(r);
+
+  // R2C returns n/2+1 complex values.
+  VERIFY_IS_EQUAL(R.size(), n / 2 + 1);
+
+  RVec s = fft.invReal(R, n);
+  VERIFY_IS_EQUAL(s.size(), n);
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((s - r).norm() / r.norm() < tol);
+}
+
+// ---- 2D C2C roundtrip: inv2(fwd2(A)) ≈ A ---------------------------------
+
+template <typename Scalar>
+void test_2d_roundtrip(Index rows, Index cols) {
+  using Complex = std::complex<Scalar>;
+  using Mat = Matrix<Complex, Dynamic, Dynamic>;
+  using RealScalar = Scalar;
+
+  Mat A = Mat::Random(rows, cols);
+
+  gpu::FFT<Scalar> fft;
+  Mat B = fft.fwd2(A);
+  VERIFY_IS_EQUAL(B.rows(), rows);
+  VERIFY_IS_EQUAL(B.cols(), cols);
+
+  Mat C = fft.inv2(B);
+  VERIFY_IS_EQUAL(C.rows(), rows);
+  VERIFY_IS_EQUAL(C.cols(), cols);
+
+  RealScalar tol = RealScalar(10) * RealScalar(rows * cols) * NumTraits<Scalar>::epsilon();
+  VERIFY((C - A).norm() / A.norm() < tol);
+}
+
+// ---- 2D C2C known signal: constant matrix -----------------------------------
+
+template <typename Scalar>
+void test_2d_constant() {
+  using Complex = std::complex<Scalar>;
+  using Mat = Matrix<Complex, Dynamic, Dynamic>;
+  using RealScalar = Scalar;
+
+  const int rows = 16, cols = 32;
+  Mat A = Mat::Constant(rows, cols, Complex(2.0, 0.0));
+
+  gpu::FFT<Scalar> fft;
+  Mat B = fft.fwd2(A);
+
+  // 2D FFT of constant c: B(0,0) = c*rows*cols, all others = 0.
+  RealScalar tol = RealScalar(10) * NumTraits<Scalar>::epsilon() * RealScalar(rows * cols);
+  VERIFY(std::abs(B(0, 0) - Complex(2.0 * rows * cols, 0.0)) < tol);
+  for (int j = 0; j < cols; ++j) {
+    for (int i = 0; i < rows; ++i) {
+      if (i == 0 && j == 0) continue;
+      VERIFY(std::abs(B(i, j)) < tol);
+    }
+  }
+}
+
+// ---- Plan reuse: repeated calls should work ---------------------------------
+
+template <typename Scalar>
+void test_plan_reuse() {
+  using Complex = std::complex<Scalar>;
+  using Vec = Matrix<Complex, Dynamic, 1>;
+  using RealScalar = Scalar;
+
+  gpu::FFT<Scalar> fft;
+  for (int trial = 0; trial < 5; ++trial) {
+    Vec x = Vec::Random(128);
+    Vec X = fft.fwd(x);
+    Vec y = fft.inv(X);
+    RealScalar tol = RealScalar(10) * RealScalar(128) * NumTraits<Scalar>::epsilon();
+    VERIFY((y - x).norm() / x.norm() < tol);
+  }
+}
+
+void test_device_invalid_fft_size() {
+  using Complex = std::complex<float>;
+  gpu::FFT<float> fft;
+  gpu::DeviceMatrix<Complex> input;
+  gpu::DeviceMatrix<float> output;
+  VERIFY_RAISES_ASSERT(fft.invReal(input, output, Index(-1)));
+}
+
+// ---- LRU eviction + user-configurable capacity ------------------------------
+// Constructs an FFT with an explicit small plan-cache capacity (also exercising
+// the user-configurable constructor), pushes 2 * capacity distinct shapes
+// through it so the cache is forced to evict and recreate plans, verifies the
+// cache stays clamped at capacity, then revisits the first (now-evicted) shape.
+// Two correctness conditions: every transform stays numerically correct, and
+// cufftDestroy on eviction leaves no dangling state on the stream.
+
+template <typename Scalar>
+void test_plan_cache_eviction() {
+  using Complex = std::complex<Scalar>;
+  using Vec = Matrix<Complex, Dynamic, 1>;
+  using RealScalar = Scalar;
+
+  constexpr std::size_t capacity = 4;
+  gpu::FFT<Scalar> fft(capacity);
+  VERIFY_IS_EQUAL(fft.plan_cache_capacity(), capacity);
+  VERIFY_IS_EQUAL(fft.plan_cache_size(), std::size_t(0));
+
+  const int num_shapes = static_cast<int>(2 * capacity);
+  for (int k = 0; k < num_shapes; ++k) {
+    const Index n = 32 + 16 * k;  // 32, 48, 64, ... all distinct.
+    Vec x = Vec::Random(n);
+    Vec X = fft.fwd(x);
+    Vec y = fft.inv(X);
+    RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+    VERIFY((y - x).norm() / x.norm() < tol);
+  }
+  // Cache should be clamped at capacity, never exceeding it.
+  VERIFY_IS_EQUAL(fft.plan_cache_size(), capacity);
+
+  // Smallest shape has been evicted by now; re-creating it must succeed.
+  Vec x = Vec::Random(32);
+  Vec X = fft.fwd(x);
+  Vec y = fft.inv(X);
+  RealScalar tol = RealScalar(10) * RealScalar(32) * NumTraits<Scalar>::epsilon();
+  VERIFY((y - x).norm() / x.norm() < tol);
+  VERIFY_IS_EQUAL(fft.plan_cache_size(), capacity);
+}
+
+// ---- Empty ------------------------------------------------------------------
+
+template <typename Scalar>
+void test_empty() {
+  using Complex = std::complex<Scalar>;
+  using Vec = Matrix<Complex, Dynamic, 1>;
+
+  gpu::FFT<Scalar> fft;
+  Vec x(0);
+  Vec X = fft.fwd(x);
+  VERIFY_IS_EQUAL(X.size(), 0);
+  Vec y = fft.inv(X);
+  VERIFY_IS_EQUAL(y.size(), 0);
+}
+
+// ---- Explicit-Context ctor: stream and cuBLAS plumbing ----------------------
+// Verifies that FFT(Context&) actually binds to the supplied Context's stream
+// and cuBLAS handle (rather than falling back to Context::threadLocal()), and
+// that fwd/inv exercise both: fwd schedules the cuFFT plan on ctx.stream(),
+// inv additionally scales via ctx.cublasHandle().
+
+template <typename Scalar>
+void test_explicit_context(Index n) {
+  using Complex = std::complex<Scalar>;
+  using Vec = Matrix<Complex, Dynamic, 1>;
+  using RealScalar = Scalar;
+
+  // A fresh Context owns a distinct stream from the thread-local default.
+  gpu::Context ctx;
+  VERIFY(ctx.stream() != gpu::Context::threadLocal().stream());
+
+  gpu::FFT<Scalar> fft(ctx);
+  VERIFY(fft.stream() == ctx.stream());
+  VERIFY(&fft.context() == &ctx);
+
+  Vec x = Vec::Random(n);
+  Vec X = fft.fwd(x);
+  Vec y = fft.inv(X);
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y - x).norm() / x.norm() < tol);
+}
+
+// ---- Device-resident transforms -------------------------------------------------
+
+template <typename Scalar>
+void test_device_transforms(Index n) {
+  using Complex = std::complex<Scalar>;
+  using CVec = Matrix<Complex, Dynamic, 1>;
+  using RVec = Matrix<Scalar, Dynamic, 1>;
+
+  gpu::Context ctx;
+  gpu::FFT<Scalar> fft(ctx);
+
+  // 1D C2C: device path matches the host path; roundtrip returns the input.
+  CVec x = CVec::Random(n);
+  CVec X_host = fft.fwd(x);
+  auto d_x = gpu::DeviceMatrix<Complex>::fromHost(x, ctx.stream());
+  gpu::DeviceMatrix<Complex> d_X, d_y;
+  fft.fwd(d_x, d_X);
+  VERIFY_IS_APPROX(d_X.toHost(), X_host);
+  fft.inv(d_X, d_y);
+  VERIFY_IS_APPROX(d_y.toHost(), x);
+
+  // 1D R2C / C2R roundtrip; the C2R input is preserved (staged via scratch).
+  RVec r = RVec::Random(n);
+  auto d_r = gpu::DeviceMatrix<Scalar>::fromHost(r, ctx.stream());
+  gpu::DeviceMatrix<Complex> d_R;
+  fft.fwd(d_r, d_R);
+  VERIFY_IS_EQUAL(d_R.rows(), n / 2 + 1);
+  Matrix<Complex, Dynamic, Dynamic> R_before = d_R.toHost();
+  gpu::DeviceMatrix<Scalar> d_s;
+  fft.invReal(d_R, d_s, n);
+  VERIFY_IS_APPROX(d_s.toHost(), r);
+  VERIFY_IS_APPROX(d_R.toHost(), R_before);
+
+  // 2D C2C roundtrip.
+  using CMat = Matrix<Complex, Dynamic, Dynamic>;
+  CMat A = CMat::Random(n / 2, n / 4 + 1);
+  auto d_A = gpu::DeviceMatrix<Complex>::fromHost(A, ctx.stream());
+  gpu::DeviceMatrix<Complex> d_B, d_C;
+  fft.fwd2(d_A, d_B);
+  fft.inv2(d_B, d_C);
+  VERIFY_IS_APPROX(d_C.toHost(), A);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_device_transforms<Scalar>(64));
+  CALL_SUBTEST(test_c2c_roundtrip<Scalar>(64));
+  CALL_SUBTEST(test_c2c_roundtrip<Scalar>(256));
+  CALL_SUBTEST(test_c2c_roundtrip<Scalar>(1000));  // non-power-of-2
+  CALL_SUBTEST(test_c2c_constant<Scalar>());
+  CALL_SUBTEST(test_r2c_roundtrip<Scalar>(64));
+  CALL_SUBTEST(test_r2c_roundtrip<Scalar>(256));
+  CALL_SUBTEST(test_2d_roundtrip<Scalar>(32, 32));
+  CALL_SUBTEST(test_2d_roundtrip<Scalar>(16, 64));  // non-square
+  CALL_SUBTEST(test_2d_constant<Scalar>());
+  CALL_SUBTEST(test_plan_reuse<Scalar>());
+  CALL_SUBTEST(test_plan_cache_eviction<Scalar>());
+  CALL_SUBTEST(test_empty<Scalar>());
+  CALL_SUBTEST(test_explicit_context<Scalar>(64));
+}
+
+EIGEN_DECLARE_TEST(gpu_cufft) {
+  gpu_test::require_cufft_context();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_1(test_device_invalid_fft_size());
+  CALL_SUBTEST_2(test_scalar<double>());
+}
diff --git a/contrib/test/GPU/cusolver_eigen.cpp b/contrib/test/GPU/cusolver_eigen.cpp
new file mode 100644
index 0000000..c93f3e9
--- /dev/null
+++ b/contrib/test/GPU/cusolver_eigen.cpp
@@ -0,0 +1,342 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuSelfAdjointEigenSolver: GPU symmetric/Hermitian eigenvalue
+// decomposition via cuSOLVER.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Eigenvalues>
+#include <contrib/Eigen/GPU>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Reconstruction: V * diag(W) * V^H ≈ A ---------------------------------
+
+template <typename Scalar>
+void test_eigen_reconstruction(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // Build a symmetric/Hermitian matrix.
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  gpu::SelfAdjointEigenSolver<Scalar> es(A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+
+  auto W = es.eigenvalues();
+  Mat V = es.eigenvectors();
+
+  VERIFY_IS_EQUAL(W.size(), n);
+  VERIFY_IS_EQUAL(V.rows(), n);
+  VERIFY_IS_EQUAL(V.cols(), n);
+
+  // Reconstruct: A_hat = V * diag(W) * V^H.
+  Mat A_hat = V * W.asDiagonal() * V.adjoint();
+  RealScalar tol = RealScalar(8) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * A.norm();
+  VERIFY((A_hat - A).norm() < tol);
+
+  // Orthogonality: V^H * V ≈ I.
+  Mat VhV = V.adjoint() * V;
+  Mat eye = Mat::Identity(n, n);
+  VERIFY((VhV - eye).norm() < tol);
+}
+
+// ---- Eigenvalues match CPU SelfAdjointEigenSolver ---------------------------
+
+template <typename Scalar>
+void test_eigen_values(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  gpu::SelfAdjointEigenSolver<Scalar> gpu_es(A);
+  VERIFY_IS_EQUAL(gpu_es.info(), Success);
+  auto W_gpu = gpu_es.eigenvalues();
+
+  SelfAdjointEigenSolver<Mat> cpu_es(A);
+  auto W_cpu = cpu_es.eigenvalues();
+
+  RealScalar tol =
+      RealScalar(2) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * W_cpu.cwiseAbs().maxCoeff();
+  VERIFY((W_gpu - W_cpu).norm() < tol);
+}
+
+// ---- Eigenvalues-only mode --------------------------------------------------
+
+template <typename Scalar>
+void test_eigen_values_only(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  gpu::SelfAdjointEigenSolver<Scalar> gpu_es(A, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(gpu_es.info(), Success);
+  auto W_gpu = gpu_es.eigenvalues();
+
+  SelfAdjointEigenSolver<Mat> cpu_es(A, EigenvaluesOnly);
+  auto W_cpu = cpu_es.eigenvalues();
+
+  RealScalar tol =
+      RealScalar(2) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * W_cpu.cwiseAbs().maxCoeff();
+  VERIFY((W_gpu - W_cpu).norm() < tol);
+}
+
+// ---- DeviceMatrix input path ------------------------------------------------
+
+template <typename Scalar>
+void test_eigen_device_matrix(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  gpu::SelfAdjointEigenSolver<Scalar> es;
+  es.compute(d_A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+
+  auto W_gpu = es.eigenvalues();
+  Mat V = es.eigenvectors();
+
+  // Verify reconstruction.
+  Mat A_hat = V * W_gpu.asDiagonal() * V.adjoint();
+  RealScalar tol = RealScalar(8) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * A.norm();
+  VERIFY((A_hat - A).norm() < tol);
+}
+
+// ---- Recompute (reuse solver object) ----------------------------------------
+
+template <typename Scalar>
+void test_eigen_recompute(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  gpu::SelfAdjointEigenSolver<Scalar> es;
+
+  for (int trial = 0; trial < 3; ++trial) {
+    Mat R = Mat::Random(n, n);
+    Mat A = R + R.adjoint();
+    es.compute(A);
+    VERIFY_IS_EQUAL(es.info(), Success);
+
+    auto W = es.eigenvalues();
+    Mat V = es.eigenvectors();
+    Mat A_hat = V * W.asDiagonal() * V.adjoint();
+    RealScalar tol = RealScalar(8) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * A.norm();
+    VERIFY((A_hat - A).norm() < tol);
+  }
+}
+
+// ---- Repeated eigenvalues ---------------------------------------------------
+//
+// Builds A with a degenerate eigenvalue cluster. Eigenvectors within the cluster
+// are not uniquely determined, but eigenvalues, reconstruction, and orthogonality
+// must still hold.
+
+template <typename Scalar>
+void test_eigen_repeated_values(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Vec = Matrix<typename NumTraits<Scalar>::Real, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // Build a unitary V via QR of a random matrix.
+  Mat seed = Mat::Random(n, n);
+  Mat V = HouseholderQR<Mat>(seed).householderQ();
+
+  // Spectrum: a 4-fold cluster at value 1, then increasing distinct values.
+  Vec eigs(n);
+  for (Index i = 0; i < n; ++i) {
+    eigs(i) = (i < 4) ? RealScalar(1) : RealScalar(i);
+  }
+  Mat A = V * eigs.asDiagonal() * V.adjoint();
+  Mat A_sym = (A + A.adjoint()) * RealScalar(0.5);  // symmetrize numerically
+
+  gpu::SelfAdjointEigenSolver<Scalar> es(A_sym);
+  VERIFY_IS_EQUAL(es.info(), Success);
+
+  // Eigenvalues must match the constructed spectrum (cuSOLVER returns ascending).
+  Vec W_gpu = es.eigenvalues();
+  Vec W_expected = eigs;
+  std::sort(W_expected.data(), W_expected.data() + n);
+
+  RealScalar tol_w =
+      RealScalar(2) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * W_expected.cwiseAbs().maxCoeff();
+  VERIFY((W_gpu - W_expected).norm() < tol_w);
+
+  // Reconstruction must hold even with a degenerate cluster (eigenvectors form a
+  // valid orthonormal basis for the cluster's invariant subspace).
+  Mat V_gpu = es.eigenvectors();
+  Mat A_hat = V_gpu * W_gpu.asDiagonal() * V_gpu.adjoint();
+  RealScalar tol = RealScalar(20) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * A.norm();
+  VERIFY((A_hat - A_sym).norm() < tol);
+
+  // Orthogonality of computed eigenvectors must hold.
+  VERIFY((V_gpu.adjoint() * V_gpu - Mat::Identity(n, n)).norm() < tol);
+}
+
+// ---- Device-side accessors --------------------------------------------------
+//
+// d_eigenvalues / d_eigenvectors return non-owning views over the solver's
+// internal d_W_ / d_A_ buffers. Verify they agree with the host accessors and
+// that repeated invocations leave the solver state intact.
+
+template <typename Scalar>
+void test_eigen_device_accessors(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  gpu::SelfAdjointEigenSolver<Scalar> es(A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+
+  auto d_W = es.d_eigenvalues();
+  auto d_V = es.d_eigenvectors();
+
+  VERIFY_IS_APPROX(d_W.toHost(), es.eigenvalues());
+  VERIFY_IS_APPROX(d_V.toHost(), es.eigenvectors());
+
+  // Re-fetch must keep working (view destruction must not free the underlying buffers).
+  (void)es.d_eigenvalues();
+  (void)es.d_eigenvectors();
+  VERIFY_IS_APPROX(es.eigenvalues(), d_W.toHost());
+  VERIFY_IS_APPROX(es.eigenvectors(), d_V.toHost());
+}
+
+// ---- Chain device views into a downstream cuBLAS GEMM (no D2D copy) ---------
+
+template <typename Scalar>
+void test_eigen_chain_orthogonality(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  gpu::SelfAdjointEigenSolver<Scalar> es(A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+
+  // V^H * V = I — V is the device view of d_A_; the GEMM consumes the view
+  // without an intervening D2D copy.
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_VtV;
+  {
+    auto d_V = es.d_eigenvectors();
+    d_VtV.device(ctx) = d_V.adjoint() * d_V;
+  }
+  Mat VtV = d_VtV.toHost();
+  RealScalar tol = RealScalar(20) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((VtV - Mat::Identity(n, n)).norm() < tol);
+
+  // After view destruction, the solver's state must remain valid.
+  Mat V_again = es.eigenvectors();
+  VERIFY_IS_EQUAL(V_again.rows(), n);
+}
+
+// ---- Move support -------------------------------------------------------------
+
+template <typename Scalar>
+void test_eigen_move(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat R = Mat::Random(n, n);
+  Mat A = R + R.adjoint();
+
+  gpu::SelfAdjointEigenSolver<Scalar> es(A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+
+  gpu::SelfAdjointEigenSolver<Scalar> moved(std::move(es));
+  VERIFY_IS_EQUAL(moved.info(), Success);
+  Mat V = moved.eigenvectors();
+  auto W = moved.eigenvalues();
+  RealScalar tol = RealScalar(8) * static_cast<RealScalar>(n) * NumTraits<Scalar>::epsilon() * A.norm();
+  VERIFY((V * W.asDiagonal() * V.adjoint() - A).norm() < tol);
+
+  // Overwrite a Context-bound solver without querying its pending status
+  // first. Move assignment must retire its asynchronous info copy before
+  // releasing the pinned host destination.
+  Mat pending_random = Mat::Random(n, n);
+  Mat pending_input = pending_random + pending_random.adjoint();
+  gpu::Context ctx;
+  gpu::SelfAdjointEigenSolver<Scalar> assigned(ctx, pending_input);
+  assigned = std::move(moved);
+  VERIFY_IS_EQUAL(assigned.info(), Success);
+  V = assigned.eigenvectors();
+  W = assigned.eigenvalues();
+  VERIFY((V * W.asDiagonal() * V.adjoint() - A).norm() < tol);
+
+  // The borrowed Context remains usable after its old solver state is retired.
+  gpu::SelfAdjointEigenSolver<Scalar> context_solver(ctx, pending_input);
+  VERIFY_IS_EQUAL(context_solver.info(), Success);
+}
+
+// ---- Empty matrix -----------------------------------------------------------
+
+void test_eigen_empty() {
+  ArrayXXd empty(0, 0);
+  gpu::SelfAdjointEigenSolver<double> es(empty);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  VERIFY_IS_EQUAL(es.rows(), 0);
+  VERIFY_IS_EQUAL(es.cols(), 0);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  // Reconstruction + orthogonality.
+  CALL_SUBTEST(test_eigen_reconstruction<Scalar>(64));
+  CALL_SUBTEST(test_eigen_reconstruction<Scalar>(128));
+
+  // Eigenvalues match CPU.
+  CALL_SUBTEST(test_eigen_values<Scalar>(64));
+  CALL_SUBTEST(test_eigen_values<Scalar>(128));
+
+  // Values-only mode.
+  CALL_SUBTEST(test_eigen_values_only<Scalar>(64));
+
+  // DeviceMatrix input.
+  CALL_SUBTEST(test_eigen_device_matrix<Scalar>(64));
+
+  // Recompute.
+  CALL_SUBTEST(test_eigen_recompute<Scalar>(32));
+
+  // Repeated eigenvalues (degenerate cluster).
+  CALL_SUBTEST(test_eigen_repeated_values<Scalar>(64));
+
+  // Device accessors.
+  CALL_SUBTEST(test_eigen_device_accessors<Scalar>(64));
+
+  // Chain device view into a downstream GEMM.
+  CALL_SUBTEST(test_eigen_chain_orthogonality<Scalar>(64));
+
+  // Move constructor/assignment.
+  CALL_SUBTEST(test_eigen_move<Scalar>(32));
+}
+
+EIGEN_DECLARE_TEST(gpu_cusolver_eigen) {
+  gpu_test::require_cuda_device();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_eigen_empty());
+}
diff --git a/contrib/test/GPU/cusolver_llt.cpp b/contrib/test/GPU/cusolver_llt.cpp
new file mode 100644
index 0000000..f70b6db
--- /dev/null
+++ b/contrib/test/GPU/cusolver_llt.cpp
@@ -0,0 +1,364 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuLLT: GPU Cholesky (LL^T) using cuSOLVER.
+// Covers cusolverDnXpotrf (factorization) and cusolverDnXpotrs (solve)
+// for float, double, complex<float>, complex<double>, Lower and Upper.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Cholesky>
+#include <contrib/Eigen/GPU>
+#include <atomic>
+#include <chrono>
+#include <thread>
+
+#include "./gpu_test_helpers.h"
+
+// Identifier convention throughout this file:
+//   h_ prefix for host-resident Eigen::Matrix values
+//   d_ prefix for device-resident Eigen::gpu::DeviceMatrix values
+// We also keep namespaces explicit (Eigen::, Eigen::gpu::) so the CPU vs GPU
+// path is obvious at every call site.
+
+// Build a random symmetric positive-definite matrix: A = M^H*M + n*I.
+template <typename MatrixType>
+MatrixType make_spd(Eigen::Index n) {
+  using Scalar = typename MatrixType::Scalar;
+  MatrixType M = MatrixType::Random(n, n);
+  return M.adjoint() * M + MatrixType::Identity(n, n) * static_cast<Scalar>(n);
+}
+
+struct HostInputGate {
+  std::atomic<bool> entered{false};
+  std::atomic<bool> release{false};
+};
+
+static void CUDART_CB wait_for_host_input_gate(void* data) {
+  HostInputGate* gate = static_cast<HostInputGate*>(data);
+  gate->entered.store(true, std::memory_order_release);
+  while (!gate->release.load(std::memory_order_acquire)) std::this_thread::yield();
+}
+
+// Test factorization: L*L^H must reconstruct A to within floating-point tolerance.
+template <typename Scalar, int UpLo>
+void test_potrf(Eigen::Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  MatrixType h_A = make_spd<MatrixType>(n);
+
+  // GPU factorization under test: factor stays on device.
+  Eigen::gpu::LLT<Scalar, UpLo> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  // CPU LLT is the oracle. GpuLLT does not expose the device-resident factor,
+  // so we validate correctness via the CPU-reconstructed matrix.
+  Eigen::LLT<MatrixType, UpLo> cpu_llt(h_A);
+  VERIFY_IS_EQUAL(cpu_llt.info(), Eigen::Success);
+  MatrixType h_A_reconstructed = cpu_llt.reconstructedMatrix();
+
+  RealScalar tol = RealScalar(4) * RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon() * h_A.norm();
+  VERIFY((h_A_reconstructed - h_A).norm() < tol);
+
+  // Cross-check: GPU and CPU solves must agree on the same RHS. `solve(Matrix)`
+  // uploads/downloads internally, so both outputs end up on the host.
+  MatrixType h_b = MatrixType::Random(n, 1);
+  MatrixType h_x_gpu = gpu_llt.solve(h_b);
+  MatrixType h_x_cpu = cpu_llt.solve(h_b);
+  VERIFY((h_x_gpu - h_x_cpu).norm() < tol);
+}
+
+// Test solve: residual ||A*X - B|| / ||B|| must be small.
+template <typename Scalar, int UpLo>
+void test_potrs(Eigen::Index n, Eigen::Index nrhs) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  MatrixType h_A = make_spd<MatrixType>(n);
+  MatrixType h_B = MatrixType::Random(n, nrhs);
+
+  Eigen::gpu::LLT<Scalar, UpLo> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  MatrixType h_X = gpu_llt.solve(h_B);
+
+  RealScalar residual = (h_A * h_X - h_B).norm() / h_B.norm();
+  RealScalar tol = RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon();
+  VERIFY(residual < tol);
+}
+
+// Test that multiple solves against the same factor all produce correct results.
+// This exercises the key design property: L stays on device across calls.
+template <typename Scalar>
+void test_multiple_solves(Eigen::Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  MatrixType h_A = make_spd<MatrixType>(n);
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  RealScalar tol = RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon();
+  for (int k = 0; k < 5; ++k) {
+    MatrixType h_B = MatrixType::Random(n, 3);
+    MatrixType h_X = gpu_llt.solve(h_B);
+    RealScalar residual = (h_A * h_X - h_B).norm() / h_B.norm();
+    VERIFY(residual < tol);
+  }
+}
+
+// Test that GpuLLT correctly detects a non-SPD matrix.
+void test_not_spd() {
+  Eigen::MatrixXd h_A = -Eigen::MatrixXd::Identity(8, 8);  // negative definite
+  Eigen::gpu::LLT<double> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::NumericalIssue);
+}
+
+// solve(DeviceMatrix) must not silently return garbage when the factorization
+// failed: it must sync the info word and assert just like solve(MatrixBase).
+void test_not_spd_device_solve_asserts() {
+  Eigen::MatrixXd h_A = -Eigen::MatrixXd::Identity(8, 8);
+  Eigen::MatrixXd h_B = Eigen::MatrixXd::Random(8, 4);
+  Eigen::gpu::LLT<double> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::NumericalIssue);
+  auto d_B = Eigen::gpu::DeviceMatrix<double>::fromHost(h_B);
+  VERIFY_RAISES_ASSERT(gpu_llt.solve(d_B));
+}
+
+// ---- DeviceMatrix-native API --------------------------------------------
+// These tests exercise the device-resident path: compute(DeviceMatrix) +
+// solve(DeviceMatrix) -> DeviceMatrix, with the user explicitly managing
+// upload/download. The tests above use the host-Matrix overloads which do
+// the transfers internally; this section covers the no-implicit-transfer
+// surface that keeps data on device across a chain of calls.
+
+// compute(DeviceMatrix) + solve(DeviceMatrix) → toHost
+template <typename Scalar, int UpLo>
+void test_device_matrix_solve(Eigen::Index n, Eigen::Index nrhs) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  MatrixType h_A = make_spd<MatrixType>(n);
+  MatrixType h_B = MatrixType::Random(n, nrhs);
+
+  auto d_A = Eigen::gpu::DeviceMatrix<Scalar>::fromHost(h_A);
+  auto d_B = Eigen::gpu::DeviceMatrix<Scalar>::fromHost(h_B);
+
+  Eigen::gpu::LLT<Scalar, UpLo> gpu_llt;
+  gpu_llt.compute(d_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  Eigen::gpu::DeviceMatrix<Scalar> d_X = gpu_llt.solve(d_B);
+  MatrixType h_X = d_X.toHost();
+
+  RealScalar residual = (h_A * h_X - h_B).norm() / h_B.norm();
+  VERIFY(residual < RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon());
+}
+
+// compute(DeviceMatrix&&) — move path
+template <typename Scalar>
+void test_device_matrix_move_compute(Eigen::Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  MatrixType h_A = make_spd<MatrixType>(n);
+  MatrixType h_B = MatrixType::Random(n, 1);
+
+  auto d_A = Eigen::gpu::DeviceMatrix<Scalar>::fromHost(h_A);
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt;
+  gpu_llt.compute(std::move(d_A));
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  // d_A should be empty after move.
+  VERIFY(d_A.empty());
+
+  MatrixType h_X = gpu_llt.solve(h_B);
+  RealScalar residual = (h_A * h_X - h_B).norm() / h_B.norm();
+  VERIFY(residual < RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon());
+}
+
+// Full async chain: compute → solve → solve again with result as RHS → toHost
+template <typename Scalar>
+void test_chaining(Eigen::Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  MatrixType h_A = make_spd<MatrixType>(n);
+  MatrixType h_B = MatrixType::Random(n, 3);
+
+  auto d_A = Eigen::gpu::DeviceMatrix<Scalar>::fromHost(h_A);
+  auto d_B = Eigen::gpu::DeviceMatrix<Scalar>::fromHost(h_B);
+
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt;
+  gpu_llt.compute(d_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  // Chain: solve → use result as RHS for another solve. Everything stays on
+  // device until the final toHost() below; that's the only sync point.
+  Eigen::gpu::DeviceMatrix<Scalar> d_X = gpu_llt.solve(d_B);
+  Eigen::gpu::DeviceMatrix<Scalar> d_Y = gpu_llt.solve(d_X);
+
+  MatrixType h_Y = d_Y.toHost();
+
+  // Verify: Y = A^{-2} * B using CPU oracle.
+  MatrixType h_X_ref = Eigen::LLT<MatrixType, Eigen::Lower>(h_A).solve(h_B);
+  MatrixType h_Y_ref = Eigen::LLT<MatrixType, Eigen::Lower>(h_A).solve(h_X_ref);
+
+  RealScalar tol = RealScalar(4) * RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon() * h_Y_ref.norm();
+  VERIFY((h_Y - h_Y_ref).norm() < tol);
+}
+
+// ---- Context binding + in-place (rvalue) solve --------------------------------
+
+template <typename Scalar>
+void test_context_bound_solver(Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat M = Mat::Random(n, n);
+  Mat A = M.adjoint() * M + Mat::Identity(n, n) * Scalar(n);
+  Mat B = Mat::Random(n, nrhs);
+
+  gpu::Context ctx;
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A, ctx.stream());
+  gpu::LLT<Scalar> llt(ctx, d_A);
+  VERIFY(llt.info() == Success);
+  VERIFY(llt.stream() == ctx.stream());
+
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B, ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_X = llt.solve(d_B);
+  Mat X = d_X.toHost();
+  VERIFY((A * X - B).norm() / B.norm() < RealScalar(n) * NumTraits<Scalar>::epsilon());
+
+  // In-place rvalue solve: consumes the RHS, no copy/allocation.
+  gpu::DeviceMatrix<Scalar> d_X2 = llt.solve(std::move(d_B));
+  Mat X2 = d_X2.toHost();
+  VERIFY((A * X2 - B).norm() / B.norm() < RealScalar(n) * NumTraits<Scalar>::epsilon());
+  VERIFY(d_B.data() == nullptr);  // moved-from
+}
+
+// ---- Non-plain host input ---------------------------------------------------
+
+// compute() binds plain contiguous column-major input in place through Ref and
+// evaluates anything else into a temporary. An SPD matrix is symmetric, so a
+// row-major copy is byte-identical and would not detect a layout mistake; a
+// block whose outerStride() differs from rows() would.
+template <typename Scalar>
+void test_non_plain_input(Eigen::Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  const MatrixType h_A = make_spd<MatrixType>(n);
+  const MatrixType h_B = MatrixType::Random(n, 3);
+  const RealScalar tol = RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon();
+
+  MatrixType h_padded = MatrixType::Random(n + 3, n + 5);
+  h_padded.block(2, 1, n, n) = h_A;
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt_block(h_padded.block(2, 1, n, n));
+  VERIFY_IS_EQUAL(gpu_llt_block.info(), Eigen::Success);
+  MatrixType h_X_block = gpu_llt_block.solve(h_B);
+  VERIFY((h_A * h_X_block - h_B).norm() / h_B.norm() < tol);
+
+  // Unevaluated expression; 2*A is still SPD.
+  const MatrixType h_A2 = Scalar(2) * h_A;
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt_expr(Scalar(2) * h_A);
+  VERIFY_IS_EQUAL(gpu_llt_expr.info(), Eigen::Success);
+  MatrixType h_X_expr = gpu_llt_expr.solve(h_B);
+  VERIFY((h_A2 * h_X_expr - h_B).norm() / h_B.norm() < tol);
+
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt_array(h_A.array());
+  VERIFY_IS_EQUAL(gpu_llt_array.info(), Eigen::Success);
+  MatrixType h_X_array = gpu_llt_array.solve(h_B);
+  VERIFY((h_A * h_X_array - h_B).norm() / h_B.norm() < tol);
+
+  // Strided right-hand side: solve() binds B through Ref as well.
+  MatrixType h_padded_B = MatrixType::Random(n + 2, h_B.cols() + 4);
+  h_padded_B.block(1, 3, n, h_B.cols()) = h_B;
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+  MatrixType h_X_rhs = gpu_llt.solve(h_padded_B.block(1, 3, n, h_B.cols()));
+  VERIFY((h_A * h_X_rhs - h_B).norm() / h_B.norm() < tol);
+}
+
+template <typename Scalar>
+void test_pinned_host_input_lifetime(Eigen::Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>;
+  using RealScalar = typename Eigen::NumTraits<Scalar>::Real;
+
+  const MatrixType h_A = make_spd<MatrixType>(n);
+  const MatrixType h_B = MatrixType::Random(n, 3);
+  const RealScalar tol = RealScalar(n) * Eigen::NumTraits<Scalar>::epsilon();
+
+  Eigen::gpu::LLT<Scalar, Eigen::Lower> gpu_llt(h_A);
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+
+  Scalar* pinned_data = nullptr;
+  EIGEN_CUDA_RUNTIME_CHECK(
+      cudaMallocHost(reinterpret_cast<void**>(&pinned_data), static_cast<size_t>(h_A.size()) * sizeof(Scalar)));
+  Eigen::Map<MatrixType> pinned_A(pinned_data, n, n);
+  pinned_A = h_A;
+
+  HostInputGate gate;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaLaunchHostFunc(gpu_llt.stream(), wait_for_host_input_gate, &gate));
+  std::thread release_thread([&gate]() {
+    while (!gate.entered.load(std::memory_order_acquire)) std::this_thread::yield();
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    gate.release.store(true, std::memory_order_release);
+  });
+
+  // The gate keeps the page-locked source live but unavailable to the DMA
+  // until after an unfenced compute() would have returned.
+  gpu_llt.compute(pinned_A);
+  pinned_A.setZero();
+  release_thread.join();
+
+  VERIFY_IS_EQUAL(gpu_llt.info(), Eigen::Success);
+  MatrixType h_X = gpu_llt.solve(h_B);
+  VERIFY((h_A * h_X - h_B).norm() / h_B.norm() < tol);
+  EIGEN_CUDA_RUNTIME_CHECK(cudaFreeHost(pinned_data));
+}
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_context_bound_solver<Scalar>(64, 4));
+  CALL_SUBTEST((test_potrf<Scalar, Eigen::Lower>(1)));
+  CALL_SUBTEST((test_potrf<Scalar, Eigen::Lower>(64)));
+  CALL_SUBTEST((test_potrf<Scalar, Eigen::Lower>(256)));
+  CALL_SUBTEST((test_potrf<Scalar, Eigen::Upper>(64)));
+  CALL_SUBTEST((test_potrf<Scalar, Eigen::Upper>(256)));
+
+  CALL_SUBTEST((test_potrs<Scalar, Eigen::Lower>(64, 1)));
+  CALL_SUBTEST((test_potrs<Scalar, Eigen::Lower>(64, 4)));
+  CALL_SUBTEST((test_potrs<Scalar, Eigen::Lower>(256, 8)));
+  CALL_SUBTEST((test_potrs<Scalar, Eigen::Upper>(64, 1)));
+  CALL_SUBTEST((test_potrs<Scalar, Eigen::Upper>(256, 4)));
+
+  CALL_SUBTEST(test_multiple_solves<Scalar>(128));
+
+  CALL_SUBTEST((test_device_matrix_solve<Scalar, Eigen::Lower>(64, 4)));
+  CALL_SUBTEST((test_device_matrix_solve<Scalar, Eigen::Upper>(128, 1)));
+  CALL_SUBTEST(test_device_matrix_move_compute<Scalar>(64));
+  CALL_SUBTEST(test_chaining<Scalar>(64));
+
+  CALL_SUBTEST(test_non_plain_input<Scalar>(64));
+  CALL_SUBTEST(test_pinned_host_input_lifetime<Scalar>(64));
+}
+
+EIGEN_DECLARE_TEST(gpu_cusolver_llt) {
+  gpu_test::require_cuda_device();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_not_spd());
+  CALL_SUBTEST_5(test_not_spd_device_solve_asserts());
+}
diff --git a/contrib/test/GPU/cusolver_lu.cpp b/contrib/test/GPU/cusolver_lu.cpp
new file mode 100644
index 0000000..8c0b776
--- /dev/null
+++ b/contrib/test/GPU/cusolver_lu.cpp
@@ -0,0 +1,237 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuLU: GPU partial-pivoting LU decomposition via cuSOLVER.
+// Covers cusolverDnXgetrf (factorization) and cusolverDnXgetrs (solve)
+// for float, double, complex<float>, complex<double>.
+//
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <contrib/Eigen/GPU>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Test factorization + NoTrans solve: residual ||A*X - B|| / ||B|| -------
+
+template <typename Scalar>
+void test_getrf(Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  MatrixType A = MatrixType::Random(n, n);
+  MatrixType B = MatrixType::Random(n, 4);
+
+  gpu::LU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  MatrixType X = lu.solve(B);
+  // Backward error bound for LU: ||A*X - B|| <= O(n*u) * ||A|| * ||X||.
+  // Normalize by ||A||*||X|| rather than ||B|| to be condition-number agnostic.
+  RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+  VERIFY(residual < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- Test solve: A^T*X = B and A^H*X = B ------------------------------------
+
+template <typename Scalar>
+void test_getrs_trans(Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  MatrixType A = MatrixType::Random(n, n);
+  MatrixType B = MatrixType::Random(n, 3);
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  gpu::LU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  MatrixType Xt = lu.solve(B, gpu::GpuOp::Trans);
+  VERIFY((A.transpose() * Xt - B).norm() / (A.norm() * Xt.norm()) < tol);
+
+  MatrixType Xc = lu.solve(B, gpu::GpuOp::ConjTrans);
+  VERIFY((A.adjoint() * Xc - B).norm() / (A.norm() * Xc.norm()) < tol);
+}
+
+// ---- Test multiple solves reuse the device-resident LU ----------------------
+
+template <typename Scalar>
+void test_multiple_solves(Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  MatrixType A = MatrixType::Random(n, n);
+  gpu::LU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  for (int k = 0; k < 5; ++k) {
+    MatrixType B = MatrixType::Random(n, 3);
+    MatrixType X = lu.solve(B);
+    VERIFY((A * X - B).norm() / (A.norm() * X.norm()) < tol);
+  }
+}
+
+// ---- Singular matrix detection ----------------------------------------------
+
+void test_singular() {
+  MatrixXd A = MatrixXd::Zero(8, 8);
+  gpu::LU<double> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), NumericalIssue);
+}
+
+// solve(DeviceMatrix) must not silently return garbage when the factorization
+// failed: it must sync the info word and assert just like solve(MatrixBase).
+void test_singular_device_solve_asserts() {
+  MatrixXd A = MatrixXd::Zero(8, 8);
+  MatrixXd B = MatrixXd::Random(8, 4);
+  gpu::LU<double> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), NumericalIssue);
+  auto d_B = gpu::DeviceMatrix<double>::fromHost(B);
+  VERIFY_RAISES_ASSERT(lu.solve(d_B));
+}
+
+// ---- DeviceMatrix integration tests -----------------------------------------
+
+template <typename Scalar>
+void test_device_matrix_move_compute(Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  MatrixType A = MatrixType::Random(n, n);
+  MatrixType B = MatrixType::Random(n, 1);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  gpu::LU<Scalar> lu;
+  lu.compute(std::move(d_A));
+  VERIFY_IS_EQUAL(lu.info(), Success);
+  VERIFY(d_A.empty());
+
+  MatrixType X = lu.solve(B);
+  RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+  VERIFY(residual < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+template <typename Scalar>
+void test_chaining(Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  MatrixType A = MatrixType::Random(n, n);
+  MatrixType B = MatrixType::Random(n, 3);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::LU<Scalar> lu;
+  lu.compute(d_A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+
+  // Chain: solve → use result as RHS
+  gpu::DeviceMatrix<Scalar> d_X = lu.solve(d_B);
+  gpu::DeviceMatrix<Scalar> d_Y = lu.solve(d_X);
+  MatrixType X = d_X.toHost();
+  MatrixType Y = d_Y.toHost();
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((A * X - B).norm() / (A.norm() * X.norm()) < tol);
+  VERIFY((A * Y - X).norm() / (A.norm() * Y.norm()) < tol);
+}
+
+// ---- Non-plain host input ---------------------------------------------------
+
+// compute() binds plain contiguous column-major input in place through Ref and
+// evaluates anything else into a temporary. Cover the inputs that take the
+// second path and require the same factorization as the plain original. A is
+// deliberately not symmetric, so a layout mistake factors A^T and the residual
+// does not converge.
+template <typename Scalar>
+void test_non_plain_input(Index n) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using RowMajorMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  const MatrixType A = MatrixType::Random(n, n) + MatrixType::Identity(n, n) * Scalar(n);
+  const MatrixType B = MatrixType::Random(n, 3);
+  const RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  const RowMajorMatrix A_row = A;
+  gpu::LU<Scalar> lu_row(A_row);
+  VERIFY_IS_EQUAL(lu_row.info(), Success);
+  MatrixType X_row = lu_row.solve(B);
+  VERIFY((A * X_row - B).norm() / (A.norm() * X_row.norm()) < tol);
+
+  // outerStride() != rows(): binding in place would read the surrounding data.
+  MatrixType padded = MatrixType::Random(n + 3, n + 5);
+  padded.block(2, 1, n, n) = A;
+  gpu::LU<Scalar> lu_block(padded.block(2, 1, n, n));
+  VERIFY_IS_EQUAL(lu_block.info(), Success);
+  MatrixType X_block = lu_block.solve(B);
+  VERIFY((A * X_block - B).norm() / (A.norm() * X_block.norm()) < tol);
+
+  MatrixType reversed_storage(n, n);
+  for (Index col = 0; col < n; ++col) reversed_storage.col(n - 1 - col) = A.col(col);
+  using NegativeStrideMap = Eigen::Map<const MatrixType, Eigen::Unaligned, Eigen::OuterStride<Dynamic>>;
+  const NegativeStrideMap negative_stride(reversed_storage.data() + (n - 1) * n, n, n, Eigen::OuterStride<Dynamic>(-n));
+  gpu::LU<Scalar> lu_negative_stride(negative_stride);
+  VERIFY_IS_EQUAL(lu_negative_stride.info(), Success);
+  MatrixType X_negative_stride = lu_negative_stride.solve(B);
+  VERIFY((A * X_negative_stride - B).norm() / (A.norm() * X_negative_stride.norm()) < tol);
+
+  // Unevaluated expression.
+  gpu::LU<Scalar> lu_expr(A.transpose());
+  VERIFY_IS_EQUAL(lu_expr.info(), Success);
+  MatrixType X_expr = lu_expr.solve(B);
+  VERIFY((A.transpose() * X_expr - B).norm() / (A.norm() * X_expr.norm()) < tol);
+
+  gpu::LU<Scalar> lu_array(A.array());
+  VERIFY_IS_EQUAL(lu_array.info(), Success);
+  MatrixType X_array = lu_array.solve(B);
+  VERIFY((A * X_array - B).norm() / (A.norm() * X_array.norm()) < tol);
+
+  // Strided right-hand side: solve() binds B through Ref as well.
+  MatrixType padded_B = MatrixType::Random(n + 2, B.cols() + 4);
+  padded_B.block(1, 3, n, B.cols()) = B;
+  gpu::LU<Scalar> lu(A);
+  VERIFY_IS_EQUAL(lu.info(), Success);
+  MatrixType X_rhs = lu.solve(padded_B.block(1, 3, n, B.cols()));
+  VERIFY((A * X_rhs - B).norm() / (A.norm() * X_rhs.norm()) < tol);
+}
+
+// ---- Per-scalar driver -------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_getrf<Scalar>(1));
+  CALL_SUBTEST(test_getrf<Scalar>(64));
+  CALL_SUBTEST(test_getrf<Scalar>(256));
+
+  CALL_SUBTEST(test_getrs_trans<Scalar>(64));
+  CALL_SUBTEST(test_getrs_trans<Scalar>(128));
+
+  CALL_SUBTEST(test_multiple_solves<Scalar>(128));
+
+  CALL_SUBTEST(test_device_matrix_move_compute<Scalar>(64));
+  CALL_SUBTEST(test_chaining<Scalar>(64));
+
+  CALL_SUBTEST(test_non_plain_input<Scalar>(64));
+}
+
+EIGEN_DECLARE_TEST(gpu_cusolver_lu) {
+  gpu_test::require_cuda_device();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_singular());
+  CALL_SUBTEST_5(test_singular_device_solve_asserts());
+}
diff --git a/contrib/test/GPU/cusolver_qr.cpp b/contrib/test/GPU/cusolver_qr.cpp
new file mode 100644
index 0000000..c1baaa6
--- /dev/null
+++ b/contrib/test/GPU/cusolver_qr.cpp
@@ -0,0 +1,279 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuQR: GPU QR decomposition via cuSOLVER.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/QR>
+#include <Eigen/SVD>
+#include <contrib/Eigen/GPU>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Solve square system: A * X = B -----------------------------------------
+
+template <typename Scalar>
+void test_qr_solve_square(Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, nrhs);
+
+  gpu::QR<Scalar> qr(A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  Mat X = qr.solve(B);
+  RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+  VERIFY(residual < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- Solve overdetermined system: m > n (least-squares) ---------------------
+
+template <typename Scalar>
+void test_qr_solve_overdetermined(Index m, Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m >= n);
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  gpu::QR<Scalar> qr(A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  Mat X = qr.solve(B);
+  VERIFY_IS_EQUAL(X.rows(), n);
+  VERIFY_IS_EQUAL(X.cols(), nrhs);
+
+  // For an overdetermined system the residual r = A X - B is generally large
+  // (O(||B||) when B is not in col(A)). What backward-stable least-squares
+  // makes small is the gradient of the LS objective, A^H r, which is zero at
+  // the optimum. Higham's bound for QR-based LS gives ||A^H r|| <= O(m * eps)
+  // * ||A|| * (||A|| ||X|| + ||B||), regardless of kappa(A).
+  Mat X_cpu = HouseholderQR<Mat>(A).solve(B);
+  RealScalar tol = RealScalar(10) * RealScalar(m) * NumTraits<Scalar>::epsilon();
+  RealScalar A_norm = A.norm();
+  RealScalar denom_gpu = A_norm * (A_norm * X.norm() + B.norm());
+  RealScalar denom_cpu = A_norm * (A_norm * X_cpu.norm() + B.norm());
+  VERIFY((A.adjoint() * (A * X - B)).norm() / denom_gpu < tol);
+  VERIFY((A.adjoint() * (A * X_cpu - B)).norm() / denom_cpu < tol);
+}
+
+// ---- Solve with DeviceMatrix input ------------------------------------------
+
+template <typename Scalar>
+void test_qr_solve_device(Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  Mat B = Mat::Random(n, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::QR<Scalar> qr;
+  qr.compute(d_A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  gpu::DeviceMatrix<Scalar> d_X = qr.solve(d_B);
+  Mat X = d_X.toHost();
+
+  RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+  VERIFY(residual < RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+// ---- Solve overdetermined via device path -----------------------------------
+
+template <typename Scalar>
+void test_qr_solve_overdetermined_device(Index m, Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m >= n);
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::QR<Scalar> qr;
+  qr.compute(d_A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  gpu::DeviceMatrix<Scalar> d_X = qr.solve(d_B);
+  VERIFY_IS_EQUAL(d_X.rows(), n);
+  VERIFY_IS_EQUAL(d_X.cols(), nrhs);
+
+  Mat X = d_X.toHost();
+  Mat X_cpu = HouseholderQR<Mat>(A).solve(B);
+  // See test_qr_solve_overdetermined: backward error for LS is bounded on
+  // the gradient A^H r, not on r itself.
+  RealScalar tol = RealScalar(10) * RealScalar(m) * NumTraits<Scalar>::epsilon();
+  RealScalar A_norm = A.norm();
+  RealScalar denom_gpu = A_norm * (A_norm * X.norm() + B.norm());
+  RealScalar denom_cpu = A_norm * (A_norm * X_cpu.norm() + B.norm());
+  VERIFY((A.adjoint() * (A * X - B)).norm() / denom_gpu < tol);
+  VERIFY((A.adjoint() * (A * X_cpu - B)).norm() / denom_cpu < tol);
+}
+
+// ---- Solve underdetermined system: m < n (minimum norm) ---------------------
+
+template <typename Scalar>
+void test_qr_solve_underdetermined(Index m, Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m < n);
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  gpu::QR<Scalar> qr(A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  Mat X = qr.solve(B);
+  VERIFY_IS_EQUAL(X.rows(), n);
+  VERIFY_IS_EQUAL(X.cols(), nrhs);
+
+  // The minimum-norm solution exactly satisfies A X = B (m equations, n > m
+  // unknowns). Backward error is O(m * eps) * ||A|| * ||X||.
+  RealScalar tol = RealScalar(20) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((A * X - B).norm() / (A.norm() * X.norm() + B.norm()) < tol);
+
+  // Min-norm property: X ⟂ null(A), so X ∈ row space(A) = col space(A^H).
+  // ||X|| <= ||X_any|| for any other solution. Compare to the SVD min-norm reference.
+  Mat X_svd = BDCSVD<Mat, ComputeThinU | ComputeThinV>(A).solve(B);
+  // Both should have the same norm (up to rounding).
+  VERIFY(numext::abs(X.norm() - X_svd.norm()) / X_svd.norm() <
+         RealScalar(50) * RealScalar(n) * NumTraits<Scalar>::epsilon());
+}
+
+template <typename Scalar>
+void test_qr_solve_underdetermined_device(Index m, Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m < n);
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  auto d_A = gpu::DeviceMatrix<Scalar>::fromHost(A);
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B);
+
+  gpu::QR<Scalar> qr;
+  qr.compute(d_A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  gpu::DeviceMatrix<Scalar> d_X = qr.solve(d_B);
+  VERIFY_IS_EQUAL(d_X.rows(), n);
+  VERIFY_IS_EQUAL(d_X.cols(), nrhs);
+
+  Mat X = d_X.toHost();
+  RealScalar tol = RealScalar(20) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((A * X - B).norm() / (A.norm() * X.norm() + B.norm()) < tol);
+}
+
+// ---- matrixR() returns the upper-triangular factor --------------------------
+
+template <typename Scalar>
+void test_qr_matrixR(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m >= n);
+  Mat A = Mat::Random(m, n);
+  gpu::QR<Scalar> qr(A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  Mat R = qr.matrixR();
+  VERIFY_IS_EQUAL(R.rows(), n);
+  VERIFY_IS_EQUAL(R.cols(), n);
+
+  // Verify R is upper-triangular (lower triangle exactly zero).
+  for (Index j = 0; j < n; ++j) {
+    for (Index i = j + 1; i < n; ++i) {
+      VERIFY_IS_EQUAL(R(i, j), Scalar(0));
+    }
+  }
+
+  // Verify that the diagonal of R matches the absolute values of CPU R diagonal
+  // up to sign (Householder QR has free diagonal sign).
+  Mat R_cpu = HouseholderQR<Mat>(A).matrixQR().topRows(n).template triangularView<Upper>();
+  RealScalar tol = RealScalar(20) * RealScalar(m) * NumTraits<Scalar>::epsilon() * A.norm();
+  for (Index i = 0; i < n; ++i) {
+    VERIFY(numext::abs(numext::abs(R(i, i)) - numext::abs(R_cpu(i, i))) < tol);
+  }
+}
+
+// ---- Multiple solves reuse the factorization --------------------------------
+
+template <typename Scalar>
+void test_qr_multiple_solves(Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(n, n);
+  gpu::QR<Scalar> qr(A);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  for (int k = 0; k < 5; ++k) {
+    Mat B = Mat::Random(n, 3);
+    Mat X = qr.solve(B);
+    RealScalar residual = (A * X - B).norm() / (A.norm() * X.norm());
+    VERIFY(residual < tol);
+  }
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_qr_solve_square<Scalar>(1, 1));
+  CALL_SUBTEST(test_qr_solve_square<Scalar>(64, 1));
+  CALL_SUBTEST(test_qr_solve_square<Scalar>(64, 4));
+  CALL_SUBTEST(test_qr_solve_square<Scalar>(256, 8));
+
+  CALL_SUBTEST(test_qr_solve_overdetermined<Scalar>(128, 64, 4));
+  CALL_SUBTEST(test_qr_solve_overdetermined<Scalar>(256, 128, 1));
+
+  CALL_SUBTEST(test_qr_solve_underdetermined<Scalar>(64, 128, 4));
+  CALL_SUBTEST(test_qr_solve_underdetermined<Scalar>(64, 128, 1));
+  CALL_SUBTEST(test_qr_solve_underdetermined_device<Scalar>(64, 128, 4));
+
+  CALL_SUBTEST(test_qr_matrixR<Scalar>(64, 64));
+  CALL_SUBTEST(test_qr_matrixR<Scalar>(128, 64));
+
+  CALL_SUBTEST(test_qr_solve_device<Scalar>(64, 4));
+  CALL_SUBTEST(test_qr_solve_overdetermined_device<Scalar>(128, 64, 4));
+  CALL_SUBTEST(test_qr_multiple_solves<Scalar>(64));
+}
+
+void test_qr_empty() {
+  ArrayXXd empty(0, 0);
+  gpu::QR<double> qr(empty);
+  VERIFY_IS_EQUAL(qr.info(), Success);
+  VERIFY_IS_EQUAL(qr.rows(), 0);
+  VERIFY_IS_EQUAL(qr.cols(), 0);
+}
+
+EIGEN_DECLARE_TEST(gpu_cusolver_qr) {
+  gpu_test::require_cuda_device();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_qr_empty());
+}
diff --git a/contrib/test/GPU/cusolver_svd.cpp b/contrib/test/GPU/cusolver_svd.cpp
new file mode 100644
index 0000000..3b34a03
--- /dev/null
+++ b/contrib/test/GPU/cusolver_svd.cpp
@@ -0,0 +1,494 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for GpuSVD: GPU SVD via cuSOLVER.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/SVD>
+#include <contrib/Eigen/GPU>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- SVD reconstruction: U * diag(S) * VT ≈ A ------------------------------
+
+template <typename Scalar, unsigned int Options>
+void test_svd_reconstruction(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  gpu::SVD<Scalar> svd(A, Options);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  auto S = svd.singularValues();
+  Mat U = svd.matrixU();
+  Mat VT = svd.matrixVT();
+
+  const Index k = (std::min)(m, n);
+
+  // Reconstruct: A_hat = U[:,:k] * diag(S) * VT[:k,:].
+  Mat A_hat = U.leftCols(k) * S.asDiagonal() * VT.topRows(k);
+  RealScalar tol = RealScalar(5) * std::sqrt(static_cast<RealScalar>(k)) * NumTraits<Scalar>::epsilon() * A.norm();
+  VERIFY((A_hat - A).norm() < tol);
+
+  // Orthogonality: U^H * U ≈ I.
+  Mat UtU = U.adjoint() * U;
+  Mat I_u = Mat::Identity(U.cols(), U.cols());
+  VERIFY((UtU - I_u).norm() < tol);
+
+  // Orthogonality: VT * VT^H ≈ I.
+  Mat VtVh = VT * VT.adjoint();
+  Mat I_v = Mat::Identity(VT.rows(), VT.rows());
+  VERIFY((VtVh - I_v).norm() < tol);
+}
+
+// ---- Singular values match CPU BDCSVD ---------------------------------------
+
+template <typename Scalar>
+void test_svd_singular_values(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  gpu::SVD<Scalar> svd(A, 0);  // values only
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  auto S_gpu = svd.singularValues();
+  auto S_cpu = BDCSVD<Mat>(A).singularValues();
+
+  // Weyl's perturbation bound (Higham, Accuracy and Stability of Numerical
+  // Algorithms, 2nd ed., §10.2.3): |σ_i(A) - σ_i(A+δA)| ≤ ||δA||. Both cuSOLVER
+  // and BDCSVD have backward error ||δA|| / ||A|| ≤ p(m,n) · u; the difference
+  // of the two computed singular value vectors is bounded by 2·p(m,n)·u·S_max,
+  // and √(min) · ||·||_∞ ≥ ||·||_2. Across 5k trials per case in
+  // {float, double, complex<float>, complex<double>} × {(64,64), (128,64)},
+  // worst observed err / (√min · u · S_max) is ≈ 6.2; we use 12 for headroom
+  // against future runs hitting the tail of the distribution.
+  RealScalar tol =
+      RealScalar(12) * std::sqrt(static_cast<RealScalar>((std::min)(m, n))) * NumTraits<Scalar>::epsilon() * S_cpu(0);
+  VERIFY((S_gpu - S_cpu).norm() < tol);
+}
+
+// ---- Solve: pseudoinverse ---------------------------------------------------
+
+template <typename Scalar>
+void test_svd_solve(Index m, Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  gpu::SVD<Scalar> svd(A, ComputeThinU | ComputeThinV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  Mat X = svd.solve(B);
+  VERIFY_IS_EQUAL(X.rows(), n);
+  VERIFY_IS_EQUAL(X.cols(), nrhs);
+
+  // Compare with CPU BDCSVD solve. Wedin's perturbation theorem (Higham,
+  // Accuracy and Stability of Numerical Algorithms, 2nd ed., §20.1) bounds
+  // the forward error of a backward-stable SVD-based pseudoinverse solve by
+  // c · κ(A) · u with c = O(1). Comparing two such solvers doubles the
+  // constant. Across 6k trials over {float, double, complex<float>,
+  // complex<double>} and {square, over-/underdetermined} shapes, the worst
+  // observed err / (κ · u) is 5.3.
+  auto cpu_svd = BDCSVD<Mat, ComputeThinU | ComputeThinV>(A);
+  Mat X_cpu = cpu_svd.solve(B);
+  auto S = cpu_svd.singularValues();
+  const RealScalar cond = S(0) / S(S.size() - 1);
+  const RealScalar tol = RealScalar(8) * cond * NumTraits<Scalar>::epsilon();
+  VERIFY((X - X_cpu).norm() / X_cpu.norm() < tol);
+}
+
+// ---- Solve: Context-bound ---------------------------------------------------
+// A Context-bound SVD shares the Context's stream and cuBLASLt plan cache /
+// workspace; its pseudoinverse solve must agree with the standalone solver.
+
+template <typename Scalar>
+void test_svd_solve_context(Index m, Index n, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  gpu::Context ctx;
+  gpu::SVD<Scalar> svd(ctx, A, ComputeThinU | ComputeThinV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+  Mat X = svd.solve(B);
+
+  gpu::SVD<Scalar> svd_standalone(A, ComputeThinU | ComputeThinV);
+  Mat X_ref = svd_standalone.solve(B);
+
+  // Same algorithm on both paths; only the cuBLASLt plan selection may
+  // differ, so bound the difference by κ(A)·u as in test_svd_solve.
+  auto S = svd_standalone.singularValues();
+  const RealScalar cond = S(0) / S(S.size() - 1);
+  const RealScalar tol = RealScalar(8) * cond * NumTraits<Scalar>::epsilon();
+  VERIFY((X - X_ref).norm() / X_ref.norm() < tol);
+}
+
+// ---- Solve: truncated -------------------------------------------------------
+
+template <typename Scalar>
+void test_svd_solve_truncated(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, 1);
+  const Index k = (std::min)(m, n);
+  const Index trunc = k / 2;
+  eigen_assert(trunc > 0);
+
+  gpu::SVD<Scalar> svd(A, ComputeThinU | ComputeThinV);
+  Mat X_trunc = svd.solve(B, trunc);
+
+  // Build CPU reference: truncated pseudoinverse.
+  auto cpu_svd = BDCSVD<Mat, ComputeThinU | ComputeThinV>(A);
+  auto S = cpu_svd.singularValues();
+  Mat U = cpu_svd.matrixU();
+  Mat V = cpu_svd.matrixV();
+
+  // D_ii = 1/S_i for i < trunc, 0 otherwise.
+  Matrix<RealScalar, Dynamic, 1> D = Matrix<RealScalar, Dynamic, 1>::Zero(k);
+  for (Index i = 0; i < trunc; ++i) D(i) = RealScalar(1) / S(i);
+  Mat X_ref = V * D.asDiagonal() * U.adjoint() * B;
+
+  RealScalar tol = RealScalar(100) * RealScalar(k) * NumTraits<Scalar>::epsilon();
+  VERIFY((X_trunc - X_ref).norm() / X_ref.norm() < tol);
+}
+
+// ---- Solve: Tikhonov regularized --------------------------------------------
+
+template <typename Scalar>
+void test_svd_solve_regularized(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, 1);
+  RealScalar lambda = RealScalar(0.1);
+  const Index k = (std::min)(m, n);
+
+  gpu::SVD<Scalar> svd(A, ComputeThinU | ComputeThinV);
+  Mat X_reg = svd.solve(B, lambda);
+
+  // CPU reference: D_ii = S_i / (S_i^2 + lambda^2).
+  auto cpu_svd = BDCSVD<Mat, ComputeThinU | ComputeThinV>(A);
+  auto S = cpu_svd.singularValues();
+  Mat U = cpu_svd.matrixU();
+  Mat V = cpu_svd.matrixV();
+
+  Matrix<RealScalar, Dynamic, 1> D(k);
+  for (Index i = 0; i < k; ++i) D(i) = S(i) / (S(i) * S(i) + lambda * lambda);
+  Mat X_ref = V * D.asDiagonal() * U.adjoint() * B;
+
+  RealScalar tol = RealScalar(100) * RealScalar(k) * NumTraits<Scalar>::epsilon();
+  VERIFY((X_reg - X_ref).norm() / X_ref.norm() < tol);
+}
+
+// ---- Solve: rank-deficient (exercise drop_threshold pseudoinverse) ----------
+
+template <typename Scalar>
+void test_svd_solve_rank_deficient(Index m, Index n, Index r) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Vec = Matrix<typename NumTraits<Scalar>::Real, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(r > 0 && r < (std::min)(m, n));
+
+  // Build A of rank exactly r: A = U[:,:r] * diag(s) * V[:,:r]^H.
+  Mat U_seed = Mat::Random(m, m);
+  Mat U_full = HouseholderQR<Mat>(U_seed).householderQ();
+  Mat V_seed = Mat::Random(n, n);
+  Mat V_full = HouseholderQR<Mat>(V_seed).householderQ();
+  Vec sigma(r);
+  for (Index i = 0; i < r; ++i) sigma(i) = RealScalar(1) + RealScalar(i);  // distinct, well-spaced
+  Mat A = U_full.leftCols(r) * sigma.asDiagonal() * V_full.leftCols(r).adjoint();
+
+  Mat B = Mat::Random(m, 1);
+
+  gpu::SVD<Scalar> svd(A, ComputeThinU | ComputeThinV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+  Mat X_gpu = svd.solve(B);
+
+  // Reference: CPU BDCSVD with the same drop_threshold semantics (its default solve()
+  // also drops near-zero singular values relative to S(0) * (m, n)_max * epsilon).
+  Mat X_cpu = BDCSVD<Mat, ComputeThinU | ComputeThinV>(A).solve(B);
+
+  // Both should produce the minimum-norm least-squares solution; compare via the
+  // "useful" residual A^H r: zero up to the rank-r component plus rounding.
+  RealScalar tol = RealScalar(50) * RealScalar((std::max)(m, n)) * NumTraits<Scalar>::epsilon();
+  VERIFY((X_gpu - X_cpu).norm() / X_cpu.norm() < tol);
+
+  // Norm of X should also be minimum (X has no component in null(A) up to rounding).
+  VERIFY(numext::abs(X_gpu.norm() - X_cpu.norm()) / X_cpu.norm() < tol);
+}
+
+// ---- Reconstruction: full U / full V on a wide matrix (m < n) ---------------
+//
+// Exercises the transposed-internal-representation path through gesvd combined
+// with the matrixU/matrixVT swap logic.
+
+template <typename Scalar>
+void test_svd_reconstruction_full_wide(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m < n);
+  Mat A = Mat::Random(m, n);
+  gpu::SVD<Scalar> svd(A, ComputeFullU | ComputeFullV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  auto S = svd.singularValues();
+  Mat U = svd.matrixU();    // m × m
+  Mat VT = svd.matrixVT();  // n × n
+  Mat V = svd.matrixV();    // n × n (matrixV alias should match matrixVT().adjoint())
+
+  VERIFY_IS_EQUAL(U.rows(), m);
+  VERIFY_IS_EQUAL(U.cols(), m);
+  VERIFY_IS_EQUAL(VT.rows(), n);
+  VERIFY_IS_EQUAL(VT.cols(), n);
+  VERIFY_IS_EQUAL(V.rows(), n);
+  VERIFY_IS_EQUAL(V.cols(), n);
+  VERIFY_IS_APPROX(V, VT.adjoint());
+
+  const Index k = (std::min)(m, n);
+  Mat A_hat = U.leftCols(k) * S.asDiagonal() * VT.topRows(k);
+  RealScalar tol = RealScalar(5) * std::sqrt(static_cast<RealScalar>(k)) * NumTraits<Scalar>::epsilon() * A.norm();
+  VERIFY((A_hat - A).norm() < tol);
+
+  Mat UtU = U.adjoint() * U;
+  VERIFY((UtU - Mat::Identity(m, m)).norm() < tol);
+  Mat VtVh = VT * VT.adjoint();
+  VERIFY((VtVh - Mat::Identity(n, n)).norm() < tol);
+}
+
+// ---- Device-side accessors --------------------------------------------------
+//
+// Verify that d_singularValues / d_matrixU / d_matrixVT return views over the
+// SVD's internal storage that agree with the host accessors after toHost().
+
+template <typename Scalar>
+void test_svd_device_accessors(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  gpu::SVD<Scalar> svd(A, ComputeThinU | ComputeThinV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  auto d_S = svd.d_singularValues();
+  auto d_U = svd.d_matrixU();
+  auto d_VT = svd.d_matrixVT();
+
+  Matrix<RealScalar, Dynamic, 1> S_host = d_S.toHost();
+  Mat U_host = d_U.toHost();
+  Mat VT_host = d_VT.toHost();
+
+  VERIFY_IS_APPROX(S_host, svd.singularValues());
+  VERIFY_IS_APPROX(U_host, svd.matrixU());
+  VERIFY_IS_APPROX(VT_host, svd.matrixVT());
+
+  // Multiple invocations must keep returning views without disturbing the SVD's state:
+  // call again, then verify the SVD's host accessors still produce correct results.
+  (void)svd.d_matrixU();
+  (void)svd.d_matrixVT();
+  VERIFY_IS_APPROX(svd.matrixU(), U_host);
+  VERIFY_IS_APPROX(svd.matrixVT(), VT_host);
+}
+
+template <typename Scalar>
+void test_svd_device_accessors_full_wide(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  eigen_assert(m < n);
+  Mat A = Mat::Random(m, n);
+  gpu::SVD<Scalar> svd(A, ComputeFullU | ComputeFullV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  auto d_S = svd.d_singularValues();
+  auto d_U = svd.d_matrixU();
+  auto d_VT = svd.d_matrixVT();
+
+  VERIFY_IS_EQUAL(d_U.rows(), m);
+  VERIFY_IS_EQUAL(d_U.cols(), m);
+  VERIFY_IS_EQUAL(d_VT.rows(), n);
+  VERIFY_IS_EQUAL(d_VT.cols(), n);
+
+  Matrix<RealScalar, Dynamic, 1> S_host = d_S.toHost();
+  Mat U_host = d_U.toHost();
+  Mat VT_host = d_VT.toHost();
+
+  VERIFY_IS_APPROX(S_host, svd.singularValues());
+  VERIFY_IS_APPROX(U_host, svd.matrixU());
+  VERIFY_IS_APPROX(VT_host, svd.matrixVT());
+}
+
+// ---- Chain device views into a downstream cuBLAS GEMM (no D2D copy) ---------
+//
+// d_matrixU() returns a non-owning view over the SVD's internal d_U_ buffer.
+// Feeding the view straight into a Context-driven GEMM exercises cross-stream
+// event sync and confirms the borrow-deleter does not double-free on temporary
+// destruction.
+
+template <typename Scalar>
+void test_svd_chain_orthogonality(Index m, Index n) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Mat A = Mat::Random(m, n);
+  gpu::SVD<Scalar> svd(A, ComputeThinU | ComputeThinV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  const Index k = (std::min)(m, n);
+
+  // U^H * U = I_k, all on device, no host roundtrip on U.
+  gpu::Context ctx;
+  gpu::DeviceMatrix<Scalar> d_UtU;
+  {
+    auto d_U = svd.d_matrixU();
+    d_UtU.device(ctx) = d_U.adjoint() * d_U;
+  }
+  Mat UtU = d_UtU.toHost();
+  RealScalar tol = RealScalar(20) * std::sqrt(static_cast<RealScalar>(k)) * NumTraits<Scalar>::epsilon();
+  VERIFY((UtU - Mat::Identity(k, k)).norm() < tol);
+
+  // VT * VT^H = I_k.
+  gpu::DeviceMatrix<Scalar> d_VVt;
+  {
+    auto d_VT = svd.d_matrixVT();
+    d_VVt.device(ctx) = d_VT * d_VT.adjoint();
+  }
+  Mat VVt = d_VVt.toHost();
+  VERIFY((VVt - Mat::Identity(k, k)).norm() < tol);
+
+  // After view destruction, SVD's state must remain valid (the deleter is a no-op
+  // for views, so the underlying d_U_ / d_VT_ are not freed).
+  Mat U_again = svd.matrixU();
+  Mat VT_again = svd.matrixVT();
+  VERIFY_IS_EQUAL(U_again.rows(), m);
+  VERIFY_IS_EQUAL(VT_again.cols(), n);
+}
+
+// ---- Empty matrix -----------------------------------------------------------
+
+void test_svd_empty() {
+  ArrayXXd empty(0, 0);
+  gpu::SVD<double> svd(empty, 0);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+  VERIFY_IS_EQUAL(svd.rows(), 0);
+  VERIFY_IS_EQUAL(svd.cols(), 0);
+
+  svd.compute(MatrixXd::Random(4, 6), ComputeThinU | ComputeThinV);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+
+  svd.compute(MatrixXd(0, 7), 0);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+  VERIFY_IS_EQUAL(svd.rows(), 0);
+  VERIFY_IS_EQUAL(svd.cols(), 7);
+  VERIFY_IS_EQUAL(svd.singularValues().size(), 0);
+
+  svd.compute(MatrixXd(5, 0), 0);
+  VERIFY_IS_EQUAL(svd.info(), Success);
+  VERIFY_IS_EQUAL(svd.rows(), 5);
+  VERIFY_IS_EQUAL(svd.cols(), 0);
+  VERIFY_IS_EQUAL(svd.singularValues().size(), 0);
+}
+
+// ---- Device-resident solve ----------------------------------------------------
+
+template <typename Scalar>
+void test_device_solve(Index m, Index n, Index nrhs) {
+  using Mat = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+
+  Mat A = Mat::Random(m, n);
+  Mat B = Mat::Random(m, nrhs);
+
+  gpu::SVD<Scalar> svd(A);
+  VERIFY(svd.info() == Success);
+  Mat X_host = svd.solve(B);
+
+  auto d_B = gpu::DeviceMatrix<Scalar>::fromHost(B, svd.stream());
+  gpu::DeviceMatrix<Scalar> d_X = svd.solve(d_B);
+  VERIFY_IS_APPROX(d_X.toHost(), X_host);
+
+  // Second device solve reuses the cached inverse diagonal (no host sync).
+  gpu::DeviceMatrix<Scalar> d_X2 = svd.solve(d_B);
+  VERIFY_IS_APPROX(d_X2.toHost(), X_host);
+
+  // Truncated variant matches its host counterpart too.
+  const Index trunc = (std::min)(m, n) / 2 + 1;
+  Mat Xt_host = svd.solve(B, trunc);
+  gpu::DeviceMatrix<Scalar> d_Xt = svd.solve(d_B, trunc);
+  VERIFY_IS_APPROX(d_Xt.toHost(), Xt_host);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_device_solve<Scalar>(64, 48, 4));
+  CALL_SUBTEST(test_device_solve<Scalar>(48, 64, 3));
+  // Reconstruction + orthogonality (thin and full, identical test logic).
+  CALL_SUBTEST((test_svd_reconstruction<Scalar, ComputeThinU | ComputeThinV>(64, 64)));
+  CALL_SUBTEST((test_svd_reconstruction<Scalar, ComputeThinU | ComputeThinV>(128, 64)));
+  CALL_SUBTEST((test_svd_reconstruction<Scalar, ComputeThinU | ComputeThinV>(64, 128)));  // wide (m < n)
+  CALL_SUBTEST((test_svd_reconstruction<Scalar, ComputeFullU | ComputeFullV>(64, 64)));
+  CALL_SUBTEST((test_svd_reconstruction<Scalar, ComputeFullU | ComputeFullV>(128, 64)));
+
+  // Singular values.
+  CALL_SUBTEST(test_svd_singular_values<Scalar>(64, 64));
+  CALL_SUBTEST(test_svd_singular_values<Scalar>(128, 64));
+
+  // Solve.
+  CALL_SUBTEST(test_svd_solve<Scalar>(64, 64, 4));
+  CALL_SUBTEST(test_svd_solve<Scalar>(128, 64, 4));
+  CALL_SUBTEST(test_svd_solve<Scalar>(64, 128, 4));  // wide (m < n)
+  CALL_SUBTEST(test_svd_solve_context<Scalar>(64, 48, 3));
+
+  // Truncated and regularized solve.
+  CALL_SUBTEST(test_svd_solve_truncated<Scalar>(64, 64));
+  CALL_SUBTEST(test_svd_solve_regularized<Scalar>(64, 64));
+
+  // Rank-deficient solve (exercises drop_threshold pseudoinverse).
+  CALL_SUBTEST(test_svd_solve_rank_deficient<Scalar>(64, 64, 32));
+  CALL_SUBTEST(test_svd_solve_rank_deficient<Scalar>(96, 64, 16));
+  CALL_SUBTEST(test_svd_solve_rank_deficient<Scalar>(64, 96, 16));
+
+  // Wide matrix with full U/V (transposed-internal path).
+  CALL_SUBTEST((test_svd_reconstruction_full_wide<Scalar>(64, 96)));
+
+  // Device accessors.
+  CALL_SUBTEST(test_svd_device_accessors<Scalar>(64, 64));
+  CALL_SUBTEST(test_svd_device_accessors<Scalar>(96, 64));
+  CALL_SUBTEST(test_svd_device_accessors<Scalar>(64, 96));
+  CALL_SUBTEST(test_svd_device_accessors_full_wide<Scalar>(64, 96));
+
+  // Chain device views into a downstream GEMM (orthogonality check).
+  CALL_SUBTEST(test_svd_chain_orthogonality<Scalar>(64, 64));
+  CALL_SUBTEST(test_svd_chain_orthogonality<Scalar>(96, 64));
+}
+
+EIGEN_DECLARE_TEST(gpu_cusolver_svd) {
+  gpu_test::require_cuda_device();
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  CALL_SUBTEST_5(test_svd_empty());
+}
diff --git a/contrib/test/GPU/cusparse_bsr.cpp b/contrib/test/GPU/cusparse_bsr.cpp
new file mode 100644
index 0000000..5d9a892
--- /dev/null
+++ b/contrib/test/GPU/cusparse_bsr.cpp
@@ -0,0 +1,302 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for gpu::SparseContext with BlockSparseMatrix input: GPU BSR SpMV/SpMM
+// via cuSPARSE.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+#if EIGEN_HAS_CUSPARSE_BSR
+
+template <typename Scalar, int Options, int B>
+using Bsm = BlockSparseMatrix<Scalar, Options, B, B, int>;
+
+// Random block pattern with random dense blocks; Random() fills both parts of
+// a complex scalar, so conjugation is observable.
+template <typename Scalar, int Options, int B>
+Bsm<Scalar, Options, B> make_block_sparse(Index block_rows, Index block_cols, double density = 0.3) {
+  using Triplet = typename Bsm<Scalar, Options, B>::TripletType;
+  using Block = typename Bsm<Scalar, Options, B>::BlockType;
+  std::vector<Triplet> triplets;
+  for (Index bi = 0; bi < block_rows; ++bi) {
+    for (Index bj = 0; bj < block_cols; ++bj) {
+      if (internal::random<double>(0.0, 1.0) < density) triplets.emplace_back(int(bi), int(bj), Block::Random());
+    }
+  }
+  Bsm<Scalar, Options, B> A(block_rows, block_cols);
+  A.setFromTriplets(triplets.begin(), triplets.end());
+  return A;
+}
+
+// Relative bound for a product by A: each entry sums at most
+// max(A.rows(), A.cols()) terms, so 10 * max(A.rows(), A.cols()) * eps covers
+// the accumulation error.
+template <typename Lhs, typename Rhs, typename MatrixType>
+void verify_product(const Lhs& gpu, const Rhs& cpu, const MatrixType& A) {
+  using Scalar = typename Lhs::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  const RealScalar tol = RealScalar(10) * RealScalar((std::max)(A.rows(), A.cols())) * NumTraits<Scalar>::epsilon();
+  VERIFY_IS_EQUAL(gpu.rows(), cpu.rows());
+  VERIFY_IS_EQUAL(gpu.cols(), cpu.cols());
+  VERIFY((gpu - cpu).norm() / (cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- Host SpMV: y = op(A) * x for every op -----------------------------------
+
+template <typename Scalar, int Options, int B>
+void test_bsr_spmv(Index block_rows, Index block_cols) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+
+  const Bsm<Scalar, Options, B> A = make_block_sparse<Scalar, Options, B>(block_rows, block_cols);
+  const Vec x = Vec::Random(A.cols());
+  const Vec xt = Vec::Random(A.rows());
+
+  gpu::SparseContext<Scalar> ctx;
+  const Vec y = ctx.multiply(A, x);
+  verify_product(y, Vec(A * x), A);
+  const Vec yt = ctx.multiplyT(A, xt);
+  verify_product(yt, Vec(A.transpose() * xt), A);
+  const Vec yh = ctx.multiplyAdjoint(A, xt);
+  verify_product(yh, Vec(A.adjoint() * xt), A);
+}
+
+// ---- Host SpMV in place: y = alpha * op(A) * x + beta * y ---------------------
+
+template <typename Scalar, int Options, int B>
+void test_bsr_spmv_alpha_beta(Index block_rows, Index block_cols) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+
+  const Bsm<Scalar, Options, B> A = make_block_sparse<Scalar, Options, B>(block_rows, block_cols);
+  const Scalar alpha(2);
+  const Scalar beta(3);
+  gpu::SparseContext<Scalar> ctx;
+
+  const Vec x = Vec::Random(A.cols());
+  const Vec y_init = Vec::Random(A.rows());
+  Vec y = y_init;
+  ctx.multiply(A, x, y, alpha, beta);
+  verify_product(y, Vec(alpha * (A * x) + beta * y_init), A);
+
+  const Vec xt = Vec::Random(A.rows());
+  const Vec yt_init = Vec::Random(A.cols());
+  Vec yt = yt_init;
+  ctx.multiply(A, xt, yt, alpha, beta, gpu::GpuOp::ConjTrans);
+  verify_product(yt, Vec(alpha * (A.adjoint() * xt) + beta * yt_init), A);
+}
+
+// ---- Host SpMM: Y = op(A) * X -------------------------------------------------
+
+template <typename Scalar, int Options, int B>
+void test_bsr_spmm(Index block_rows, Index block_cols, Index nrhs) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  const Bsm<Scalar, Options, B> A = make_block_sparse<Scalar, Options, B>(block_rows, block_cols);
+  const Mat X = Mat::Random(A.cols(), nrhs);
+  const Mat Xt = Mat::Random(A.rows(), nrhs);
+
+  gpu::SparseContext<Scalar> ctx;
+  verify_product(ctx.multiplyMat(A, X), Mat(A * X), A);
+  verify_product(ctx.multiplyMat(A, Xt, gpu::GpuOp::Trans), Mat(A.transpose() * Xt), A);
+  verify_product(ctx.multiplyMat(A, Xt, gpu::GpuOp::ConjTrans), Mat(A.adjoint() * Xt), A);
+}
+
+// ---- DeviceMatrix in/out with an explicit op ----------------------------------
+
+template <typename Scalar, int Options, int B>
+void test_bsr_device_multiply(Index block_rows, Index block_cols) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+
+  const Bsm<Scalar, Options, B> A = make_block_sparse<Scalar, Options, B>(block_rows, block_cols);
+  gpu::Context gctx;
+  gpu::SparseContext<Scalar> ctx(gctx);
+
+  const Vec x = Vec::Random(A.cols());
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y;
+  ctx.multiply(A, d_x, d_y);
+  verify_product(d_y.toHost(gctx.stream()), Vec(A * x), A);
+
+  const Vec xt = Vec::Random(A.rows());
+  auto d_xt = gpu::DeviceMatrix<Scalar>::fromHost(xt, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_yt;
+  ctx.multiply(A, d_xt, d_yt, Scalar(1), Scalar(0), gpu::GpuOp::Trans);
+  verify_product(d_yt.toHost(gctx.stream()), Vec(A.transpose() * xt), A);
+  ctx.multiply(A, d_xt, d_yt, Scalar(1), Scalar(0), gpu::GpuOp::ConjTrans);
+  verify_product(d_yt.toHost(gctx.stream()), Vec(A.adjoint() * xt), A);
+}
+
+// ---- deviceView: upload once, SpMV and SpMM by expression ----------------------
+
+template <typename Scalar, int Options, int B>
+void test_bsr_device_view(Index block_rows, Index block_cols, Index nrhs) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  const Bsm<Scalar, Options, B> A = make_block_sparse<Scalar, Options, B>(block_rows, block_cols);
+  gpu::Context gctx;
+  gpu::SparseContext<Scalar> ctx(gctx);
+  auto view = ctx.deviceView(A);
+  VERIFY(view.generation() == ctx.uploadGeneration());
+  VERIFY_IS_EQUAL(view.rows(), A.rows());
+  VERIFY_IS_EQUAL(view.cols(), A.cols());
+
+  const Vec x = Vec::Random(A.cols());
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y = view * d_x;
+  verify_product(d_y.toHost(gctx.stream()), Vec(A * x), A);
+
+  const Mat X = Mat::Random(A.cols(), nrhs);
+  auto d_X = gpu::DeviceMatrix<Scalar>::fromHost(X, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_Y;
+  d_Y.noalias() = view * d_X;
+  verify_product(d_Y.toHost(gctx.stream()), Mat(A * X), A);
+
+  // cuSPARSE runs no transposed BSR product; the exec entry points reject any
+  // other op against a BSR upload before queuing work.
+  VERIFY_RAISES_ASSERT(ctx.spmv_device_exec(d_x, d_y, Scalar(1), Scalar(0), gpu::GpuOp::Trans));
+  VERIFY_RAISES_ASSERT(ctx.spmm_device_exec(d_X, d_Y, Scalar(1), Scalar(0), gpu::GpuOp::Trans));
+}
+
+// ---- Descriptor cache across formats ------------------------------------------
+
+// A CSC matrix with the same shape and nonzero count as a BSR one must not
+// reuse its descriptor: S = (A^T as scalar sparse) has both, and a different
+// value for every x unless A is symmetric.
+template <typename Scalar, int Options, int B>
+void test_bsr_format_switch(Index block_n) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+
+  const Bsm<Scalar, Options, B> A = make_block_sparse<Scalar, Options, B>(block_n, block_n);
+  const SpMat S = SpMat(A.transpose().toSparse());
+  VERIFY_IS_EQUAL(S.nonZeros(), A.nonZeros());
+  const Vec x = Vec::Random(A.cols());
+
+  gpu::SparseContext<Scalar> ctx;
+  verify_product(ctx.multiply(A, x), Vec(A * x), A);
+  verify_product(ctx.multiply(S, x), Vec(S * x), A);
+  verify_product(ctx.multiply(A, x), Vec(A * x), A);
+}
+
+// ---- Pattern rewrite at unchanged host pointers -------------------------------
+
+// The index arrays are re-uploaded on every host-input call, so rewriting the
+// block-column indices in place is picked up. Blocks sit at (i, i) in an
+// n x (n + 1) grid and move to (i, i + 1), which keeps every block row sorted.
+template <typename Scalar, int Options, int B>
+void test_bsr_pattern_rewrite(Index n) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Triplet = typename Bsm<Scalar, Options, B>::TripletType;
+  using Block = typename Bsm<Scalar, Options, B>::BlockType;
+
+  std::vector<Triplet> triplets;
+  for (Index i = 0; i < n; ++i) triplets.emplace_back(int(i), int(i), Block::Random());
+  Bsm<Scalar, Options, B> A(n, n + 1);
+  A.setFromTriplets(triplets.begin(), triplets.end());
+  const Vec x = Vec::Random(A.cols());
+
+  gpu::SparseContext<Scalar> ctx;
+  verify_product(ctx.multiply(A, x), Vec(A * x), A);
+
+  // RowMajor: inner index = block column, shift it. ColMajor: inner index =
+  // block row; shifting the *outer* boundaries instead moves block i to
+  // column i + 1, so both orders end at the same pattern.
+  if (Options & RowMajor) {
+    for (Index k = 0; k < A.nonZeroBlocks(); ++k) A.innerIndexPtr()[k] += 1;
+  } else {
+    for (Index j = n; j >= 1; --j) A.outerIndexPtr()[j] = A.outerIndexPtr()[j - 1];
+    A.outerIndexPtr()[0] = 0;
+    A.outerIndexPtr()[n + 1] = int(n);
+  }
+  VERIFY_IS_EQUAL(A.nonZeroBlocks(), n);
+  verify_product(ctx.multiply(A, x), Vec(A * x), A);
+}
+
+// ---- Empty matrices ------------------------------------------------------------
+
+template <typename Scalar, int Options, int B>
+void test_bsr_empty() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  gpu::Context gctx;
+  gpu::SparseContext<Scalar> ctx(gctx);
+
+  const Bsm<Scalar, Options, B> A0(0, 0);
+  VERIFY_IS_EQUAL(ctx.multiply(A0, Vec(0)).size(), 0);
+  VERIFY_IS_EQUAL(ctx.multiplyMat(A0, Mat(0, 3)).cols(), 3);
+
+  // Nonzero dimensions, no stored blocks: y <- beta * y on the host and
+  // y <- 0 on the device.
+  const Bsm<Scalar, Options, B> A(3, 2);
+  const Vec x = Vec::Random(A.cols());
+  const Vec y_init = Vec::Random(A.rows());
+  Vec y = y_init;
+  ctx.multiply(A, x, y, Scalar(1), Scalar(2));
+  VERIFY_IS_APPROX(y, Vec(Scalar(2) * y_init));
+  VERIFY(ctx.multiply(A, x).isZero());
+
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y;
+  ctx.multiply(A, d_x, d_y);
+  VERIFY_IS_EQUAL(d_y.rows(), A.rows());
+  VERIFY(d_y.toHost(gctx.stream()).isZero());
+}
+
+// ---- Driver ---------------------------------------------------------------------
+
+template <typename Scalar, int Options, int B>
+void test_order() {
+  CALL_SUBTEST((test_bsr_spmv<Scalar, Options, B>(7, 5)));
+  CALL_SUBTEST((test_bsr_spmv_alpha_beta<Scalar, Options, B>(5, 7)));
+  CALL_SUBTEST((test_bsr_spmm<Scalar, Options, B>(6, 4, 3)));
+  CALL_SUBTEST((test_bsr_device_multiply<Scalar, Options, B>(4, 6)));
+  CALL_SUBTEST((test_bsr_device_view<Scalar, Options, B>(6, 6, 4)));
+  CALL_SUBTEST((test_bsr_format_switch<Scalar, Options, B>(5)));
+  CALL_SUBTEST((test_bsr_pattern_rewrite<Scalar, Options, B>(4)));
+  CALL_SUBTEST((test_bsr_empty<Scalar, Options, B>()));
+}
+
+template <typename Scalar>
+void test_scalar() {
+  // RowMajor binds without a host copy for NoTrans, ColMajor for Trans; the
+  // other op / order combinations take the transposing copy.
+  test_order<Scalar, RowMajor, 2>();
+  test_order<Scalar, ColMajor, 2>();
+  test_order<Scalar, RowMajor, 3>();
+  test_order<Scalar, ColMajor, 3>();
+}
+
+#endif  // EIGEN_HAS_CUSPARSE_BSR
+
+EIGEN_DECLARE_TEST(gpu_cusparse_bsr) {
+#if EIGEN_HAS_CUSPARSE_BSR
+  gpu_test::require_cusparse_context();
+
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+  // Block size 4, in one scalar type to bound compile time.
+  CALL_SUBTEST_5((test_order<double, RowMajor, 4>()));
+  CALL_SUBTEST_5((test_order<double, ColMajor, 4>()));
+#else
+  std::cout << "SKIP: BSR products need cuSPARSE >= 12.6.3 (CUDA 13.0 Update 1); this build has CUSPARSE_VERSION "
+            << CUSPARSE_VERSION << std::endl;
+  std::exit(77);
+#endif
+}
diff --git a/contrib/test/GPU/cusparse_spmv.cpp b/contrib/test/GPU/cusparse_spmv.cpp
new file mode 100644
index 0000000..ef62165
--- /dev/null
+++ b/contrib/test/GPU/cusparse_spmv.cpp
@@ -0,0 +1,511 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for gpu::SparseContext: GPU SpMV/SpMM via cuSPARSE.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+#include "gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Helper: build a random sparse matrix -----------------------------------
+
+template <typename Scalar>
+SparseMatrix<Scalar, ColMajor, int> make_sparse(Index rows, Index cols, double density = 0.1) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat R(rows, cols);
+  R.reserve(VectorXi::Constant(cols, static_cast<int>(rows * density) + 1));
+  for (Index j = 0; j < cols; ++j) {
+    for (Index i = 0; i < rows; ++i) {
+      if ((std::rand() / double(RAND_MAX)) < density) {
+        const RealScalar re = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        const RealScalar im = RealScalar(std::rand() / double(RAND_MAX) - 0.5);
+        R.insert(i, j) = gpu_test::make_test_value<Scalar>(re, im);
+      }
+    }
+  }
+  R.makeCompressed();
+  return R;
+}
+
+// ---- SpMV: y = A * x -------------------------------------------------------
+
+template <typename Scalar>
+void test_spmv(Index rows, Index cols) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(rows, cols);
+  Vec x = Vec::Random(cols);
+
+  gpu::SparseContext<Scalar> ctx;
+  Vec y_gpu = ctx.multiply(A, x);
+  Vec y_cpu = A * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar((std::max)(rows, cols)) * NumTraits<Scalar>::epsilon();
+  VERIFY_IS_EQUAL(y_gpu.size(), rows);
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- SpMV with alpha/beta: y = alpha*A*x + beta*y ---------------------------
+
+template <typename Scalar>
+void test_spmv_alpha_beta(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Vec x = Vec::Random(n);
+  Vec y_init = Vec::Random(n);
+
+  Scalar alpha(2);
+  Scalar beta(3);
+
+  Vec y_cpu = alpha * (A * x) + beta * y_init;
+
+  gpu::SparseContext<Scalar> ctx;
+  Vec y_gpu = y_init;
+  ctx.multiply(A, x, y_gpu, alpha, beta);
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- Transpose: y = A^T * x ------------------------------------------------
+
+template <typename Scalar>
+void test_spmv_transpose(Index rows, Index cols) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(rows, cols);
+  Vec x = Vec::Random(rows);
+
+  gpu::SparseContext<Scalar> ctx;
+  Vec y_gpu = ctx.multiplyT(A, x);
+  Vec y_cpu = A.transpose() * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar((std::max)(rows, cols)) * NumTraits<Scalar>::epsilon();
+  VERIFY_IS_EQUAL(y_gpu.size(), cols);
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- SpMV adjoint: y = A^H * x ----------------------------------------------
+
+template <typename Scalar>
+void test_spmv_adjoint(Index rows, Index cols) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(rows, cols);
+  Vec x = Vec::Random(rows);
+
+  gpu::SparseContext<Scalar> ctx;
+  Vec y_gpu = ctx.multiplyAdjoint(A, x);
+  Vec y_cpu = A.adjoint() * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar((std::max)(rows, cols)) * NumTraits<Scalar>::epsilon();
+  VERIFY_IS_EQUAL(y_gpu.size(), cols);
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- SpMM: Y = A * X (multiple RHS) ----------------------------------------
+
+template <typename Scalar>
+void test_spmm(Index rows, Index cols, Index nrhs) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(rows, cols);
+  Mat X = Mat::Random(cols, nrhs);
+
+  gpu::SparseContext<Scalar> ctx;
+  Mat Y_gpu = ctx.multiplyMat(A, X);
+  Mat Y_cpu = A * X;
+
+  RealScalar tol = RealScalar(10) * RealScalar((std::max)(rows, cols)) * NumTraits<Scalar>::epsilon();
+  VERIFY_IS_EQUAL(Y_gpu.rows(), rows);
+  VERIFY_IS_EQUAL(Y_gpu.cols(), nrhs);
+  VERIFY((Y_gpu - Y_cpu).norm() / (Y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- SpMM transpose: Y = A^T * X --------------------------------------------
+
+template <typename Scalar>
+void test_spmm_transpose(Index rows, Index cols, Index nrhs) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(rows, cols);
+  Mat X = Mat::Random(rows, nrhs);
+
+  gpu::SparseContext<Scalar> ctx;
+  Mat Y_gpu = ctx.multiplyMat(A, X, gpu::GpuOp::Trans);
+  Mat Y_cpu = A.transpose() * X;
+
+  RealScalar tol = RealScalar(10) * RealScalar((std::max)(rows, cols)) * NumTraits<Scalar>::epsilon();
+  VERIFY_IS_EQUAL(Y_gpu.rows(), cols);
+  VERIFY_IS_EQUAL(Y_gpu.cols(), nrhs);
+  VERIFY((Y_gpu - Y_cpu).norm() / (Y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- Pattern replacement at unchanged host pointers -------------------------
+
+// Regression test: assigning a different same-shape/same-nnz sparsity pattern
+// to the same SparseMatrix reuses its index allocations, so every host
+// pointer the context saw before is unchanged. A structure cache keyed on
+// pointer identity silently keeps the stale device indices and computes with
+// the old pattern (here: returns x itself instead of the permuted x).
+template <typename Scalar>
+void test_pattern_replacement(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A(n, n);
+  A.setIdentity();
+  A.makeCompressed();
+  Vec x = Vec::Random(n);
+
+  gpu::SparseContext<Scalar> ctx;
+  Vec y1 = ctx.multiply(A, x);
+  RealScalar tol = NumTraits<Scalar>::epsilon();
+  VERIFY((y1 - x).norm() < tol);
+
+  // Warm-up repeat: arms any structure cache keyed on the host arrays before
+  // the pattern is replaced.
+  Vec y1b = ctx.multiply(A, x);
+  VERIFY((y1b - x).norm() < tol);
+
+  // Value-only update at unchanged structure is picked up (values are
+  // re-uploaded on every host-input call).
+  A.coeffRef(0, 0) = Scalar(2);
+  Vec y1c = ctx.multiply(A, x);
+  Vec y1c_ref = A * x;
+  VERIFY((y1c - y1c_ref).norm() < tol);
+
+  // Replace the pattern with a cyclic permutation: one entry per column at
+  // row (j+1) % n, all values 1, so shape and nnz match the identity and the
+  // result differs from x only through the *index* arrays.
+  const int* inner_before = A.innerIndexPtr();
+  SpMat P(n, n);
+  P.reserve(VectorXi::Constant(n, 1));
+  for (Index j = 0; j < n; ++j) P.insert((j + 1) % n, j) = Scalar(1);
+  P.makeCompressed();
+  A = P;
+  // Precondition this regression relies on: the assignment reused A's index
+  // storage. If SparseMatrix assignment ever stops doing so, rewrite the
+  // pattern in place (e.g. through innerIndexPtr()) to keep the coverage.
+  VERIFY(A.innerIndexPtr() == inner_before);
+
+  Vec y2 = ctx.multiply(A, x);
+  Vec y2_ref = A * x;
+  VERIFY((y2 - y2_ref).norm() < tol);
+}
+
+// ---- Context reuse ----------------------------------------------------------
+
+template <typename Scalar>
+void test_reuse(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  gpu::SparseContext<Scalar> ctx;
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  for (int trial = 0; trial < 3; ++trial) {
+    SpMat A = make_sparse<Scalar>(n, n);
+    Vec x = Vec::Random(n);
+    Vec y_gpu = ctx.multiply(A, x);
+    Vec y_cpu = A * x;
+    VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+  }
+}
+
+// ---- Empty ------------------------------------------------------------------
+
+template <typename Scalar>
+void test_empty() {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+
+  SpMat A(0, 0);
+  A.makeCompressed();
+  Vec x(0);
+
+  gpu::SparseContext<Scalar> ctx;
+  Vec y = ctx.multiply(A, x);
+  VERIFY_IS_EQUAL(y.size(), 0);
+}
+
+// ---- gpu::DeviceMatrix SpMV (no host roundtrip) ----------------------------------
+
+template <typename Scalar>
+void test_spmv_device(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Vec x = Vec::Random(n);
+
+  // Use shared gpu::Context for same-stream execution.
+  gpu::Context gpu_ctx;
+  gpu::SparseContext<Scalar> ctx(gpu_ctx);
+
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gpu_ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y;
+
+  ctx.multiply(A, d_x, d_y);
+
+  Vec y_gpu = d_y.toHost(gpu_ctx.stream());
+  Vec y_cpu = A * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- Expression syntax: d_y = d_A * d_x ------------------------------------
+
+template <typename Scalar>
+void test_spmv_expr(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Vec x = Vec::Random(n);
+
+  gpu::Context gpu_ctx;
+  gpu::SparseContext<Scalar> ctx(gpu_ctx);
+
+  // Upload sparse matrix and create device view.
+  auto d_A = ctx.deviceView(A);
+
+  // Upload x.
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gpu_ctx.stream());
+
+  // Expression syntax: d_y = d_A * d_x
+  gpu::DeviceMatrix<Scalar> d_y;
+  d_y = d_A * d_x;
+
+  // Also test with noalias():
+  gpu::DeviceMatrix<Scalar> d_tmp;
+  d_tmp.noalias() = d_A * d_x;
+
+  Vec y_gpu = d_y.toHost(gpu_ctx.stream());
+  Vec tmp_gpu = d_tmp.toHost(gpu_ctx.stream());
+  Vec y_cpu = A * x;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+  VERIFY((tmp_gpu - y_cpu).norm() / (y_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- deviceView overwrite: second view replaces first -----------------------
+
+template <typename Scalar>
+void test_deviceview_overwrite(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A1 = make_sparse<Scalar>(n, n);
+  SpMat A2 = make_sparse<Scalar>(n, n);  // different random matrix
+
+  Vec x = Vec::Random(n);
+
+  gpu::Context gpu_ctx;
+  gpu::SparseContext<Scalar> ctx(gpu_ctx);
+
+  // First view: A1.
+  auto d_A1 = ctx.deviceView(A1);
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gpu_ctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y1;
+  d_y1 = d_A1 * d_x;
+  Vec y1_gpu = d_y1.toHost(gpu_ctx.stream());
+  Vec y1_cpu = A1 * x;
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((y1_gpu - y1_cpu).norm() / (y1_cpu.norm() + RealScalar(1)) < tol);
+
+  // Second view overwrites first: now uses A2.
+  auto d_A2 = ctx.deviceView(A2);
+  gpu::DeviceMatrix<Scalar> d_y2;
+  d_y2 = d_A2 * d_x;
+  Vec y2_gpu = d_y2.toHost(gpu_ctx.stream());
+  Vec y2_cpu = A2 * x;
+  VERIFY((y2_gpu - y2_cpu).norm() / (y2_cpu.norm() + RealScalar(1)) < tol);
+}
+
+// ---- Device-resident SpMM + GpuOp device multiply -----------------------------
+
+template <typename Scalar>
+void test_device_spmm(Index n, Index nrhs) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Mat X = Mat::Random(n, nrhs);
+
+  gpu::Context gctx;
+  gpu::SparseContext<Scalar> ctx(gctx);
+  auto view = ctx.deviceView(A);
+  VERIFY(view.generation() == ctx.uploadGeneration());
+
+  auto d_X = gpu::DeviceMatrix<Scalar>::fromHost(X, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_Y = view * d_X;  // nrhs > 1 -> SpMM
+  Mat Y_ref = A * X;
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((d_Y.toHost() - Y_ref).norm() / (Y_ref.norm() + RealScalar(1)) < tol);
+}
+
+template <typename Scalar>
+void test_device_multiply_gpuop(Index n) {
+  using SpMat = SparseMatrix<Scalar, ColMajor, int>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  SpMat A = make_sparse<Scalar>(n, n);
+  Vec x = Vec::Random(n);
+
+  gpu::Context gctx;
+  gpu::SparseContext<Scalar> ctx(gctx);
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y;
+  ctx.multiply(A, d_x, d_y, Scalar(1), Scalar(0), gpu::GpuOp::Trans);
+  Vec y_ref = A.transpose() * x;
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((d_y.toHost() - y_ref).norm() / (y_ref.norm() + RealScalar(1)) < tol);
+}
+
+// ---- BlockSparseMatrix input -------------------------------------------------
+
+// Regression coverage for the CSC fallback: a ColMajor 1 x 1 or rectangular
+// BlockSparseMatrix reached deviceView() through the implicit SparseMatrix
+// conversion before the BSR overloads existed and must keep working on every
+// toolkit. Square blocks of size >= 2 take BSR where EIGEN_HAS_CUSPARSE_BSR is 1.
+template <typename Scalar, int Options, int BlockRows, int BlockCols>
+void test_block_sparse_input(Index block_rows, Index block_cols) {
+  using Bsm = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, int>;
+  using Block = typename Bsm::BlockType;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  std::vector<typename Bsm::TripletType> triplets;
+  for (Index bi = 0; bi < block_rows; ++bi) {
+    for (Index bj = 0; bj < block_cols; ++bj) {
+      if (internal::random<double>(0.0, 1.0) < 0.4) triplets.emplace_back(int(bi), int(bj), Block::Random());
+    }
+  }
+  Bsm A(block_rows, block_cols);
+  A.setFromTriplets(triplets.begin(), triplets.end());
+  const Vec x = Vec::Random(A.cols());
+  const Vec xt = Vec::Random(A.rows());
+  const Mat X = Mat::Random(A.cols(), 3);
+  const RealScalar tol = RealScalar(10) * RealScalar((std::max)(A.rows(), A.cols())) * NumTraits<Scalar>::epsilon();
+  auto verify_close = [tol](const auto& result, const auto& ref) {
+    VERIFY((result - ref).norm() / (ref.norm() + RealScalar(1)) < tol);
+  };
+
+  gpu::Context gctx;
+  gpu::SparseContext<Scalar> ctx(gctx);
+  const Vec y_ref = A * x;
+  verify_close(ctx.multiply(A, x), y_ref);
+  const Vec yt_ref = A.transpose() * xt;
+  verify_close(ctx.multiplyT(A, xt), yt_ref);
+  Vec y_acc = Vec::Random(A.cols());
+  const Vec y_acc_ref = Scalar(2) * yt_ref + Scalar(3) * y_acc;
+  ctx.multiply(A, xt, y_acc, Scalar(2), Scalar(3), gpu::GpuOp::Trans);
+  verify_close(y_acc, y_acc_ref);
+  // As for test_spmv_adjoint below: shapes on the CSC path cannot form A^H * x
+  // for complex scalars on cuSPARSE < 12, where SparseContext asserts.
+#if !defined(CUSPARSE_VERSION) || CUSPARSE_VERSION >= 12000
+  constexpr bool kTestAdjoint = true;
+#else
+  constexpr bool kTestAdjoint = !NumTraits<Scalar>::IsComplex;
+#endif
+  if (kTestAdjoint) verify_close(ctx.multiplyAdjoint(A, xt), Vec(A.adjoint() * xt));
+  verify_close(ctx.multiplyMat(A, X), Mat(A * X));
+
+  auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, gctx.stream());
+  gpu::DeviceMatrix<Scalar> d_y;
+  ctx.multiply(A, d_x, d_y);
+  verify_close(d_y.toHost(gctx.stream()), y_ref);
+
+  auto view = ctx.deviceView(A);
+  VERIFY_IS_EQUAL(view.rows(), A.rows());
+  VERIFY_IS_EQUAL(view.cols(), A.cols());
+  gpu::DeviceMatrix<Scalar> d_y2 = view * d_x;
+  verify_close(d_y2.toHost(gctx.stream()), y_ref);
+}
+
+template <typename Scalar>
+void test_block_sparse_inputs() {
+  CALL_SUBTEST((test_block_sparse_input<Scalar, ColMajor, 1, 1>(5, 4)));
+  CALL_SUBTEST((test_block_sparse_input<Scalar, RowMajor, 1, 1>(4, 5)));
+  CALL_SUBTEST((test_block_sparse_input<Scalar, ColMajor, 2, 3>(4, 3)));
+  CALL_SUBTEST((test_block_sparse_input<Scalar, RowMajor, 2, 3>(3, 4)));
+  CALL_SUBTEST((test_block_sparse_input<Scalar, ColMajor, 3, 3>(4, 4)));
+  CALL_SUBTEST((test_block_sparse_input<Scalar, RowMajor, 3, 3>(4, 4)));
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  CALL_SUBTEST(test_block_sparse_inputs<Scalar>());
+  CALL_SUBTEST(test_device_spmm<Scalar>(64, 5));
+  CALL_SUBTEST(test_device_multiply_gpuop<Scalar>(64));
+  CALL_SUBTEST(test_spmv<Scalar>(64, 64));
+  CALL_SUBTEST(test_spmv<Scalar>(128, 64));  // non-square
+  CALL_SUBTEST(test_spmv<Scalar>(64, 128));  // wide
+  CALL_SUBTEST(test_spmv_alpha_beta<Scalar>(64));
+  CALL_SUBTEST(test_spmv_transpose<Scalar>(128, 64));
+  // cuSPARSE < 12 cannot represent A^H * x for complex scalars with the
+  // CSR-of-A^T trick used by SparseContext; SparseContext asserts in that
+  // case. Real-scalar ConjTrans is demoted to Trans and works fine.
+#if !defined(CUSPARSE_VERSION) || CUSPARSE_VERSION >= 12000
+  CALL_SUBTEST(test_spmv_adjoint<Scalar>(128, 64));
+#else
+  if (!NumTraits<Scalar>::IsComplex) CALL_SUBTEST(test_spmv_adjoint<Scalar>(128, 64));
+#endif
+  CALL_SUBTEST(test_spmm<Scalar>(64, 64, 4));
+  CALL_SUBTEST(test_spmm_transpose<Scalar>(128, 64, 4));
+  CALL_SUBTEST(test_pattern_replacement<Scalar>(64));
+  CALL_SUBTEST(test_reuse<Scalar>(64));
+  CALL_SUBTEST(test_empty<Scalar>());
+  CALL_SUBTEST(test_spmv_device<Scalar>(64));
+  CALL_SUBTEST(test_spmv_expr<Scalar>(64));
+  CALL_SUBTEST(test_deviceview_overwrite<Scalar>(64));
+}
+
+EIGEN_DECLARE_TEST(gpu_cusparse_spmv) {
+  gpu_test::require_cusparse_context();
+
+  // Split by scalar so each part compiles in parallel.
+  CALL_SUBTEST_1(test_scalar<float>());
+  CALL_SUBTEST_2(test_scalar<double>());
+  CALL_SUBTEST_3(test_scalar<std::complex<float>>());
+  CALL_SUBTEST_4(test_scalar<std::complex<double>>());
+}
diff --git a/contrib/test/GPU/device_buffer_pool.cpp b/contrib/test/GPU/device_buffer_pool.cpp
new file mode 100644
index 0000000..e0591bd
--- /dev/null
+++ b/contrib/test/GPU/device_buffer_pool.cpp
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for internal::DeviceBufferPool: a released block is recycled only once
+// the device has retired the work enqueued before the release. The pool is
+// driven directly, since DeviceBuffer only routes through it on devices without
+// memory pools.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <contrib/Eigen/GPU>
+#include <atomic>
+#include <chrono>
+#include <thread>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+namespace {
+
+using Pool = gpu::internal::DeviceBufferPool<>;
+constexpr size_t kBytes = Pool::kSmallBufferThreshold / 4;
+
+void spin_until(const std::atomic<bool>& flag) {
+  while (!flag.load(std::memory_order_acquire)) std::this_thread::yield();
+}
+
+// A host function parked on a blocking stream keeps everything ordered after
+// it, including the pool's release events on the legacy default stream,
+// pending until the gate opens.
+struct StreamGate {
+  std::atomic<bool> entered{false};
+  std::atomic<bool> release{false};
+};
+
+void CUDART_CB wait_for_gate(void* data) {
+  StreamGate* gate = static_cast<StreamGate*>(data);
+  gate->entered.store(true, std::memory_order_release);
+  spin_until(gate->release);
+}
+
+// An idle device recycles a released block on the next allocation that fits.
+void test_idle_reuse() {
+  Pool& pool = Pool::threadLocal();
+  void* const p = pool.allocate(kBytes);
+  VERIFY(p != nullptr);
+  pool.deallocate(p, kBytes);
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceSynchronize());
+  void* const q = pool.allocate(kBytes);
+  VERIFY_IS_EQUAL(q, p);
+  pool.deallocate(q, kBytes);
+}
+
+// A block released while a blocking stream is still busy stays out of
+// circulation until that stream drains; afterwards it is recycled again.
+void test_reuse_waits_for_in_flight_work() {
+  Pool& pool = Pool::threadLocal();
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceSynchronize());
+  cudaStream_t stream = nullptr;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&stream));
+
+  void* const p = pool.allocate(kBytes);
+
+  StreamGate gate;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaLaunchHostFunc(stream, wait_for_gate, &gate));
+  std::thread release_thread([&gate]() {
+    spin_until(gate.entered);
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    gate.release.store(true, std::memory_order_release);
+  });
+
+  // Released while `stream` is parked: the release event cannot have completed.
+  pool.deallocate(p, kBytes);
+  void* const q = pool.allocate(kBytes);
+  VERIFY(q != p);
+
+  release_thread.join();
+  EIGEN_CUDA_RUNTIME_CHECK(cudaDeviceSynchronize());
+
+  // Both blocks are free and retired; the older release is recycled first.
+  pool.deallocate(q, kBytes);
+  void* const r = pool.allocate(kBytes);
+  VERIFY_IS_EQUAL(r, p);
+  pool.deallocate(r, kBytes);
+
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(stream));
+}
+
+}  // namespace
+
+EIGEN_DECLARE_TEST(gpu_device_buffer_pool) {
+  gpu_test::require_cuda_device();
+  CALL_SUBTEST_1(test_idle_reuse());
+  CALL_SUBTEST_1(test_reuse_waits_for_in_flight_work());
+}
diff --git a/contrib/test/GPU/device_matrix.cpp b/contrib/test/GPU/device_matrix.cpp
new file mode 100644
index 0000000..6be1af7
--- /dev/null
+++ b/contrib/test/GPU/device_matrix.cpp
@@ -0,0 +1,598 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for gpu::DeviceMatrix and HostTransfer: typed RAII GPU memory wrapper.
+// No cuSOLVER dependency — only CUDA runtime.
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <Eigen/Sparse>
+#include <contrib/Eigen/GPU>
+
+#include "./gpu_test_helpers.h"
+
+using namespace Eigen;
+
+// ---- Default construction ---------------------------------------------------
+
+void test_default_construct() {
+  gpu::DeviceMatrix<double> dm;
+  VERIFY(dm.empty());
+  VERIFY_IS_EQUAL(dm.rows(), 0);
+  VERIFY_IS_EQUAL(dm.cols(), 0);
+  VERIFY(dm.data() == nullptr);
+  VERIFY_IS_EQUAL(dm.sizeInBytes(), size_t(0));
+}
+
+// ---- Allocate uninitialized -------------------------------------------------
+
+template <typename Scalar>
+void test_allocate(Index rows, Index cols) {
+  gpu::DeviceMatrix<Scalar> dm(rows, cols);
+  VERIFY(!dm.empty());
+  VERIFY_IS_EQUAL(dm.rows(), rows);
+  VERIFY_IS_EQUAL(dm.cols(), cols);
+  VERIFY(dm.data() != nullptr);
+  VERIFY_IS_EQUAL(dm.sizeInBytes(), size_t(rows) * size_t(cols) * sizeof(Scalar));
+}
+
+// ---- fromHost / toHost roundtrip (synchronous) ------------------------------
+
+template <typename Scalar>
+void test_roundtrip(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(rows, cols);
+
+  auto dm = gpu::DeviceMatrix<Scalar>::fromHost(host);
+  VERIFY_IS_EQUAL(dm.rows(), rows);
+  VERIFY_IS_EQUAL(dm.cols(), cols);
+  VERIFY(!dm.empty());
+
+  MatrixType result = dm.toHost();
+  VERIFY_IS_EQUAL(result.rows(), rows);
+  VERIFY_IS_EQUAL(result.cols(), cols);
+  VERIFY_IS_APPROX(result, host);
+}
+
+// ---- fromHost with a non-contiguous source ----------------------------------
+
+// fromHost() binds its argument through Ref<const PlainMatrix>, whose default
+// OuterStride<> matches any outer stride: a block of a larger matrix binds in
+// place and keeps the parent's stride instead of being materialized. Uploading
+// rows*cols contiguous elements from that pointer reads across column
+// boundaries, so the upload must honour outerStride().
+template <typename Scalar>
+void test_fromhost_strided(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using RowMajorMatrix = Eigen::Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+  using ArrayType = Eigen::Array<Scalar, Dynamic, Dynamic, ColMajor>;
+
+  const MatrixType host = MatrixType::Random(rows, cols);
+
+  // outerStride() != rows(): binds in place with the parent's stride.
+  MatrixType padded = MatrixType::Random(rows + 3, cols + 5);
+  padded.block(1, 2, rows, cols) = host;
+  VERIFY_IS_APPROX(gpu::DeviceMatrix<Scalar>::fromHost(padded.block(1, 2, rows, cols)).toHost(), host);
+
+  // Eigen permits a negative outer stride, which cudaMemcpy2DAsync cannot
+  // represent as a source pitch. Store the columns in reverse physical order
+  // so the negatively-strided logical view is equal to host.
+  MatrixType reversed_storage(rows, cols);
+  for (Index col = 0; col < cols; ++col) reversed_storage.col(cols - 1 - col) = host.col(col);
+  using NegativeStrideMap = Eigen::Map<const MatrixType, Eigen::Unaligned, Eigen::OuterStride<Dynamic>>;
+  const NegativeStrideMap negative_stride(reversed_storage.data() + (cols - 1) * rows, rows, cols,
+                                          Eigen::OuterStride<Dynamic>(-rows));
+  VERIFY_IS_APPROX(gpu::DeviceMatrix<Scalar>::fromHost(negative_stride).toHost(), host);
+
+  // Row-major and unevaluated expressions materialize into Ref's own storage,
+  // which is contiguous; pinned here so the two paths stay covered together.
+  const RowMajorMatrix row_major = host;
+  VERIFY_IS_APPROX(gpu::DeviceMatrix<Scalar>::fromHost(row_major).toHost(), host);
+  VERIFY_IS_APPROX(gpu::DeviceMatrix<Scalar>::fromHost(Scalar(2) * host).toHost(), MatrixType(Scalar(2) * host));
+
+  // Array expressions are dense inputs too.
+  const ArrayType array = host.array();
+  VERIFY_IS_APPROX(gpu::DeviceMatrix<Scalar>::fromHost(array).toHost(), host);
+}
+
+// ---- fromHostAsync / toHostAsync roundtrip -----------------------------------
+
+template <typename Scalar>
+void test_roundtrip_async(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(rows, cols);
+
+  cudaStream_t stream;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&stream));
+
+  // Async upload from raw pointer.
+  auto dm = gpu::DeviceMatrix<Scalar>::fromHostAsync(host.data(), rows, cols, stream);
+  VERIFY_IS_EQUAL(dm.rows(), rows);
+  VERIFY_IS_EQUAL(dm.cols(), cols);
+
+  // Async download via HostTransfer future.
+  auto transfer = dm.toHostAsync(stream);
+
+  // get() blocks and returns the matrix.
+  MatrixType result = transfer.get();
+  VERIFY_IS_APPROX(result, host);
+
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(stream));
+
+  cudaStream_t producer_stream;
+  cudaStream_t consumer_stream;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&producer_stream));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&consumer_stream));
+
+  auto cross_stream_dm = gpu::DeviceMatrix<Scalar>::fromHostAsync(host.data(), rows, cols, producer_stream);
+  auto cross_stream_transfer = cross_stream_dm.toHostAsync(consumer_stream);
+  MatrixType cross_stream_result = cross_stream_transfer.get();
+  VERIFY_IS_APPROX(cross_stream_result, host);
+
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(consumer_stream));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(producer_stream));
+}
+
+// ---- HostTransfer::ready() and idempotent get() -----------------------------
+
+void test_host_transfer_ready() {
+  using MatrixType = Eigen::Matrix<double, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(100, 100);
+
+  auto dm = gpu::DeviceMatrix<double>::fromHost(host);
+  auto transfer = dm.toHostAsync();
+
+  // After get(), ready() must return true.
+  MatrixType result = transfer.get();
+  VERIFY(transfer.ready());
+  VERIFY_IS_APPROX(result, host);
+
+  // get() is idempotent.
+  MatrixType& result2 = transfer.get();
+  VERIFY_IS_APPROX(result2, host);
+}
+
+// ---- HostTransfer move ------------------------------------------------------
+
+void test_host_transfer_move() {
+  using MatrixType = Eigen::Matrix<double, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(50, 50);
+
+  auto dm = gpu::DeviceMatrix<double>::fromHost(host);
+  auto transfer = dm.toHostAsync();
+
+  gpu::HostTransfer<double> moved(std::move(transfer));
+  MatrixType result = moved.get();
+  VERIFY_IS_APPROX(result, host);
+}
+
+// ---- HostTransfer move assign -----------------------------------------------
+
+// Move assignment destroys the destination's own transfer event before adopting
+// the source's; move construction never reaches that branch because it starts
+// from no event at all. Both destinations below hold a live event_, one already
+// consumed by get() and one not, so the branch runs in both synced_ states.
+void test_host_transfer_move_assign() {
+  using MatrixType = Eigen::Matrix<double, Dynamic, Dynamic>;
+  MatrixType host_a = MatrixType::Random(50, 50);
+  MatrixType host_b = MatrixType::Random(50, 50);
+
+  cudaStream_t stream;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&stream));
+
+  auto dm_a = gpu::DeviceMatrix<double>::fromHost(host_a, stream);
+  auto dm_b = gpu::DeviceMatrix<double>::fromHost(host_b, stream);
+
+  // Destination already consumed: get() leaves event_ live and synced_ set.
+  {
+    auto dest = dm_a.toHostAsync(stream);
+    VERIFY_IS_APPROX(dest.get(), host_a);
+
+    auto src = dm_b.toHostAsync(stream);
+    dest = std::move(src);
+
+    // The adopted transfer still completes and yields the source's data.
+    VERIFY_IS_APPROX(dest.get(), host_b);
+    // The moved-from future owns no event and answers ready() without CUDA.
+    VERIFY(src.ready());
+  }
+
+  // Destination never consumed: event_ live and synced_ still false. Sync first
+  // so no copy is in flight into the staging buffer the assignment frees.
+  {
+    auto dest = dm_a.toHostAsync(stream);
+    auto src = dm_b.toHostAsync(stream);
+    EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(stream));
+
+    dest = std::move(src);
+    VERIFY_IS_APPROX(dest.get(), host_b);
+    VERIFY(src.ready());
+  }
+
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(stream));
+}
+
+// ---- clone() produces independent copy --------------------------------------
+
+template <typename Scalar>
+void test_clone(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(rows, cols);
+
+  auto dm = gpu::DeviceMatrix<Scalar>::fromHost(host);
+  auto cloned = dm.clone();
+
+  // Overwrite original with different data.
+  MatrixType other = MatrixType::Random(rows, cols);
+  dm = gpu::DeviceMatrix<Scalar>::fromHost(other);
+
+  // Clone still holds the original data.
+  MatrixType clone_result = cloned.toHost();
+  VERIFY_IS_APPROX(clone_result, host);
+
+  // Original holds the new data.
+  MatrixType dm_result = dm.toHost();
+  VERIFY_IS_APPROX(dm_result, other);
+}
+
+// ---- Move construct ---------------------------------------------------------
+
+template <typename Scalar>
+void test_move_construct(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(rows, cols);
+
+  auto dm = gpu::DeviceMatrix<Scalar>::fromHost(host);
+  gpu::DeviceMatrix<Scalar> moved(std::move(dm));
+
+  VERIFY(dm.empty());
+  VERIFY(dm.data() == nullptr);
+
+  VERIFY_IS_EQUAL(moved.rows(), rows);
+  VERIFY_IS_EQUAL(moved.cols(), cols);
+  MatrixType result = moved.toHost();
+  VERIFY_IS_APPROX(result, host);
+}
+
+// ---- Move assign ------------------------------------------------------------
+
+template <typename Scalar>
+void test_move_assign(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  MatrixType host = MatrixType::Random(rows, cols);
+
+  auto dm = gpu::DeviceMatrix<Scalar>::fromHost(host);
+  gpu::DeviceMatrix<Scalar> dest;
+  dest = std::move(dm);
+
+  VERIFY(dm.empty());
+  VERIFY_IS_EQUAL(dest.rows(), rows);
+  MatrixType result = dest.toHost();
+  VERIFY_IS_APPROX(result, host);
+}
+
+// ---- Move assign over a live ready event ------------------------------------
+
+// A destination produced asynchronously owns a ready event, which the
+// assignment must destroy before adopting the source's. test_move_assign()
+// cannot reach that branch: its destination is default-constructed and its
+// source comes from the synchronous fromHost(), so neither records an event.
+template <typename Scalar>
+void test_move_assign_async(Index rows, Index cols) {
+  using MatrixType = Eigen::Matrix<Scalar, Dynamic, Dynamic>;
+  MatrixType host_a = MatrixType::Random(rows, cols);
+  MatrixType host_b = MatrixType::Random(rows, cols);
+
+  cudaStream_t producer_stream;
+  cudaStream_t consumer_stream;
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&producer_stream));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamCreate(&consumer_stream));
+
+  // Destination: upload finished, but its ready event is still live. Draining
+  // the stream keeps the assignment from freeing a buffer still being written.
+  auto dest = gpu::DeviceMatrix<Scalar>::fromHostAsync(host_a.data(), rows, cols, producer_stream);
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamSynchronize(producer_stream));
+
+  // Source: upload still in flight, so the adopted event has real work behind it.
+  auto src = gpu::DeviceMatrix<Scalar>::fromHostAsync(host_b.data(), rows, cols, producer_stream);
+  dest = std::move(src);
+
+  VERIFY(src.empty());
+  VERIFY(src.data() == nullptr);
+  VERIFY_IS_EQUAL(dest.rows(), rows);
+  VERIFY_IS_EQUAL(dest.cols(), cols);
+
+  // Reading back on the other stream waits on the adopted event, so an event
+  // lost or left behind by the assignment shows up as wrong data.
+  MatrixType result = dest.toHost(consumer_stream);
+  VERIFY_IS_APPROX(result, host_b);
+
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(consumer_stream));
+  EIGEN_CUDA_RUNTIME_CHECK(cudaStreamDestroy(producer_stream));
+}
+
+// ---- resize() ---------------------------------------------------------------
+
+void test_resize() {
+  gpu::DeviceMatrix<double> dm(10, 20);
+  VERIFY_IS_EQUAL(dm.rows(), 10);
+  VERIFY_IS_EQUAL(dm.cols(), 20);
+
+  dm.resize(50, 30);
+  VERIFY_IS_EQUAL(dm.rows(), 50);
+  VERIFY_IS_EQUAL(dm.cols(), 30);
+  VERIFY(dm.data() != nullptr);
+
+  // Resize to same dimensions is a no-op.
+  double* ptr_before = dm.data();
+  dm.resize(50, 30);
+  VERIFY(dm.data() == ptr_before);
+}
+
+// ---- Empty / 0x0 matrix -----------------------------------------------------
+
+void test_empty() {
+  using MatrixType = Eigen::Matrix<double, Dynamic, Dynamic>;
+  MatrixType empty_mat(0, 0);
+
+  auto dm = gpu::DeviceMatrix<double>::fromHost(empty_mat);
+  VERIFY(dm.empty());
+  VERIFY_IS_EQUAL(dm.rows(), 0);
+  VERIFY_IS_EQUAL(dm.cols(), 0);
+
+  MatrixType result = dm.toHost();
+  VERIFY_IS_EQUAL(result.rows(), 0);
+  VERIFY_IS_EQUAL(result.cols(), 0);
+}
+
+// ---- Per-scalar driver ------------------------------------------------------
+
+template <typename Scalar>
+void test_scalar() {
+  // Square.
+  CALL_SUBTEST(test_roundtrip<Scalar>(1, 1));
+  CALL_SUBTEST(test_roundtrip<Scalar>(64, 64));
+  CALL_SUBTEST(test_roundtrip<Scalar>(256, 256));
+
+  // Rectangular.
+  CALL_SUBTEST(test_roundtrip<Scalar>(100, 7));
+  CALL_SUBTEST(test_roundtrip<Scalar>(7, 100));
+
+  // Async roundtrip.
+  CALL_SUBTEST(test_roundtrip_async<Scalar>(64, 64));
+  CALL_SUBTEST(test_roundtrip_async<Scalar>(100, 7));
+
+  // Non-contiguous / non-column-major sources.
+  CALL_SUBTEST(test_fromhost_strided<Scalar>(8, 8));
+  CALL_SUBTEST(test_fromhost_strided<Scalar>(64, 17));
+
+  CALL_SUBTEST(test_clone<Scalar>(64, 64));
+  CALL_SUBTEST(test_move_construct<Scalar>(64, 64));
+  CALL_SUBTEST(test_move_assign<Scalar>(64, 64));
+  CALL_SUBTEST(test_move_assign_async<Scalar>(64, 64));
+}
+
+// ---- BLAS-1: dot product ----------------------------------------------------
+
+template <typename Scalar>
+void test_blas1(Index n) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  // All BLAS-1 ops share one gpu::Context — same stream, zero event overhead.
+  gpu::Context ctx;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  // addScaled (axpy)
+  {
+    Vec x = Vec::Random(n);
+    Vec y = Vec::Random(n);
+    Scalar alpha(2.5);
+    Vec y_ref = y + alpha * x;
+    auto d_y = gpu::DeviceMatrix<Scalar>::fromHost(y, ctx.stream());
+    auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    d_y.addScaled(ctx, alpha, d_x);
+    Vec y_gpu = d_y.toHost(ctx.stream());
+    VERIFY((y_gpu - y_ref).norm() < tol * y_ref.norm() + tol);
+  }
+
+  // scale (scal)
+  {
+    Vec x = Vec::Random(n);
+    Scalar alpha(3.0);
+    Vec x_ref = alpha * x;
+    auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    d_x.scale(ctx, alpha);
+    Vec x_gpu = d_x.toHost(ctx.stream());
+    VERIFY((x_gpu - x_ref).norm() < tol * x_ref.norm() + tol);
+  }
+
+  // copyFrom
+  {
+    Vec x = Vec::Random(n);
+    auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    gpu::DeviceMatrix<Scalar> d_y;
+    d_y.copyFrom(ctx, d_x);
+    Vec y = d_y.toHost(ctx.stream());
+    VERIFY_IS_APPROX(y, x);
+  }
+
+  // setZero
+  {
+    Vec x = Vec::Random(n);
+    auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x, ctx.stream());
+    d_x.setZero(ctx);
+    Vec result = d_x.toHost(ctx.stream());
+    VERIFY_IS_EQUAL(result, Vec::Zero(n));
+  }
+}
+
+// ---- BLAS-1 operator overloads (CG-style) -----------------------------------
+
+template <typename Scalar>
+void test_cg_operators(Index n) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+
+  Vec x = Vec::Random(n);
+  Vec p = Vec::Random(n);
+  Vec tmp = Vec::Random(n);
+  Vec z = Vec::Random(n);
+  Scalar alpha(2.5);
+  Scalar beta(0.7);
+
+  // Test: x += alpha * p
+  {
+    Vec x_ref = x + alpha * p;
+    auto d_x = gpu::DeviceMatrix<Scalar>::fromHost(x);
+    auto d_p = gpu::DeviceMatrix<Scalar>::fromHost(p);
+    d_x += alpha * d_p;
+    Vec x_gpu = d_x.toHost();
+    VERIFY((x_gpu - x_ref).norm() < tol * x_ref.norm() + tol);
+  }
+
+  // Test: r -= alpha * tmp
+  {
+    Vec r = Vec::Random(n);
+    Vec r_ref = r - alpha * tmp;
+    auto d_r = gpu::DeviceMatrix<Scalar>::fromHost(r);
+    auto d_tmp = gpu::DeviceMatrix<Scalar>::fromHost(tmp);
+    d_r -= alpha * d_tmp;
+    Vec r_gpu = d_r.toHost();
+    VERIFY((r_gpu - r_ref).norm() < tol * r_ref.norm() + tol);
+  }
+
+  // Test: p = z + beta * p  (cuBLAS geam)
+  {
+    Vec p_copy = p;
+    Vec p_ref = z + beta * p_copy;
+    auto d_p = gpu::DeviceMatrix<Scalar>::fromHost(p_copy);
+    auto d_z = gpu::DeviceMatrix<Scalar>::fromHost(z);
+    d_p = d_z + beta * d_p;
+    Vec p_gpu = d_p.toHost();
+    VERIFY((p_gpu - p_ref).norm() < tol * p_ref.norm() + tol);
+  }
+
+  // Test: operator+= and operator-= with gpu::DeviceMatrix (no scalar)
+  {
+    Vec a = Vec::Random(n);
+    Vec b = Vec::Random(n);
+    Vec a_ref = a + b;
+    auto d_a = gpu::DeviceMatrix<Scalar>::fromHost(a);
+    auto d_b = gpu::DeviceMatrix<Scalar>::fromHost(b);
+    d_a += d_b;
+    VERIFY((d_a.toHost() - a_ref).norm() < tol * a_ref.norm() + tol);
+  }
+}
+
+// ---- gpu::DeviceScalar: deferred sync -------------------------------------------
+
+template <typename Scalar>
+void test_device_scalar() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  const Index n = 256;
+  Vec a = Vec::Random(n);
+  Vec b = Vec::Random(n);
+
+  gpu::Context ctx;
+  auto d_a = gpu::DeviceMatrix<Scalar>::fromHost(a, ctx.stream());
+  auto d_b = gpu::DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+
+  // dot() returns gpu::DeviceScalar — implicit conversion to Scalar syncs.
+  Scalar gpu_dot = d_a.dot(ctx, d_b);
+  Scalar cpu_dot = a.dot(b);
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY(numext::abs(gpu_dot - cpu_dot) < tol * numext::abs(cpu_dot) + tol);
+
+  // squaredNorm() returns host RealScalar directly (syncs internally).
+  RealScalar gpu_sqnorm = d_a.squaredNorm(ctx);
+  RealScalar cpu_sqnorm = a.squaredNorm();
+  VERIFY(numext::abs(gpu_sqnorm - cpu_sqnorm) < tol * cpu_sqnorm + tol);
+
+  // norm() returns gpu::DeviceScalar<RealScalar> — implicit conversion syncs.
+  RealScalar gpu_norm = d_a.norm(ctx);
+  RealScalar cpu_norm = a.norm();
+  VERIFY(numext::abs(gpu_norm - cpu_norm) < tol * cpu_norm + tol);
+
+  // Convenience overloads (thread-local context).
+  gpu::Context::setThreadLocal(&ctx);
+  Scalar gpu_dot2 = d_a.dot(d_b);
+  VERIFY(numext::abs(gpu_dot2 - cpu_dot) < tol * numext::abs(cpu_dot) + tol);
+  gpu::Context::setThreadLocal(nullptr);
+
+  // Empty vectors: dot and norm must return zero.
+  {
+    gpu::DeviceMatrix<Scalar> d_empty(0, 1);
+    gpu::DeviceMatrix<Scalar> d_empty2(0, 1);
+    Scalar empty_dot = d_empty.dot(ctx, d_empty2);
+    VERIFY_IS_EQUAL(empty_dot, Scalar(0));
+    RealScalar empty_sqnorm = d_empty.squaredNorm(ctx);
+    VERIFY_IS_EQUAL(empty_sqnorm, RealScalar(0));
+    RealScalar empty_norm = d_empty.norm(ctx);
+    VERIFY_IS_EQUAL(empty_norm, RealScalar(0));
+  }
+}
+
+// ---- cwiseProduct -----------------------------------------------------------
+
+template <typename Scalar>
+void test_cwiseProduct() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  const Index n = 256;
+  Vec a = Vec::Random(n);
+  Vec b = Vec::Random(n);
+  Vec ref = a.array() * b.array();
+
+  gpu::Context ctx;
+  auto d_a = gpu::DeviceMatrix<Scalar>::fromHost(a, ctx.stream());
+  auto d_b = gpu::DeviceMatrix<Scalar>::fromHost(b, ctx.stream());
+  auto d_c = d_a.cwiseProduct(ctx, d_b);
+  Vec result = d_c.toHost(ctx.stream());
+
+  RealScalar tol = RealScalar(10) * RealScalar(n) * NumTraits<Scalar>::epsilon();
+  VERIFY((result - ref).norm() < tol * ref.norm() + tol);
+}
+
+EIGEN_DECLARE_TEST(gpu_device_matrix) {
+  gpu_test::require_cuda_device();
+  CALL_SUBTEST(test_default_construct());
+  CALL_SUBTEST(test_empty());
+  CALL_SUBTEST(test_resize());
+  CALL_SUBTEST(test_host_transfer_ready());
+  CALL_SUBTEST(test_host_transfer_move());
+  CALL_SUBTEST(test_host_transfer_move_assign());
+  CALL_SUBTEST((test_allocate<float>(100, 50)));
+  CALL_SUBTEST((test_allocate<double>(100, 50)));
+  CALL_SUBTEST(test_scalar<float>());
+  CALL_SUBTEST(test_scalar<double>());
+  CALL_SUBTEST(test_scalar<std::complex<float>>());
+  CALL_SUBTEST(test_scalar<std::complex<double>>());
+  CALL_SUBTEST(test_blas1<float>(256));
+  CALL_SUBTEST(test_blas1<double>(256));
+  CALL_SUBTEST(test_blas1<std::complex<float>>(256));
+  CALL_SUBTEST(test_blas1<std::complex<double>>(256));
+  CALL_SUBTEST(test_cg_operators<float>(256));
+  CALL_SUBTEST(test_cg_operators<double>(256));
+  CALL_SUBTEST(test_cg_operators<std::complex<float>>(256));
+  CALL_SUBTEST(test_cg_operators<std::complex<double>>(256));
+  CALL_SUBTEST(test_device_scalar<float>());
+  CALL_SUBTEST(test_device_scalar<double>());
+  CALL_SUBTEST(test_device_scalar<std::complex<float>>());
+  CALL_SUBTEST(test_device_scalar<std::complex<double>>());
+  CALL_SUBTEST(test_cwiseProduct<float>());
+  CALL_SUBTEST(test_cwiseProduct<double>());
+}
diff --git a/contrib/test/GPU/device_traits.cpp b/contrib/test/GPU/device_traits.cpp
new file mode 100644
index 0000000..3e170a0
--- /dev/null
+++ b/contrib/test/GPU/device_traits.cpp
@@ -0,0 +1,145 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Compile-time tests for the contrib GPU type-trait surface: name-keyed
+// predicates plus the device_expr_traits query aliases (scalar_type_t, is_device_expr_v, trans_op).
+
+#define EIGEN_USE_GPU
+#include "main.h"
+#include <type_traits>
+#include <contrib/Eigen/GPU>
+
+using namespace Eigen;
+
+namespace {
+using TraitDeviceMatrix = gpu::DeviceMatrix<double>;
+using TraitAdjointView = gpu::AdjointView<double>;
+using TraitTransposeView = gpu::TransposeView<double>;
+using TraitScaledMatrix = gpu::Scaled<TraitDeviceMatrix>;
+using TraitGemmExpr = gpu::GemmExpr<TraitDeviceMatrix, TraitDeviceMatrix>;
+using TraitTriangularView = gpu::TriangularView<double, Lower>;
+using TraitTrsmExpr = gpu::TrsmExpr<double, Lower>;
+using TraitSelfAdjointView = gpu::SelfAdjointView<double, Lower>;
+using TraitConstSelfAdjointView = gpu::ConstSelfAdjointView<double, Lower>;
+using TraitSymmExpr = gpu::SymmExpr<double, Lower>;
+using TraitSyrkExpr = gpu::SyrkExpr<double, Lower>;
+using TraitLltSolveExpr = gpu::LltSolveExpr<double, Lower>;
+using TraitLuSolveExpr = gpu::LuSolveExpr<double>;
+using TraitLltView = gpu::LLTView<double, Lower>;
+using TraitLuView = gpu::LUView<double>;
+using TraitDeviceAddExpr = gpu::DeviceAddExpr<double>;
+using TraitDeviceScaledDevice = gpu::DeviceScaledDevice<double>;
+using TraitDeviceScalar = gpu::DeviceScalar<double>;
+using TraitDeviceBuffer = gpu::internal::DeviceBuffer;
+
+#define EIGEN_GPU_STATIC_ASSERT_TRAIT(Trait, Require, RequireAll, Type, NegativeType)       \
+  static_assert(gpu::Trait<Type>::value, #Trait " should accept the exact type");           \
+  static_assert(gpu::Trait<const Type&>::value, #Trait " should decay const references");   \
+  static_assert(gpu::Trait##_v<Type&&>, #Trait "_v should decay rvalue references");        \
+  static_assert(!gpu::Trait<NegativeType>::value, #Trait " should reject unrelated types"); \
+  static_assert(std::is_same<gpu::Require<Type>, int>::value, #Require " should compile");  \
+  static_assert(std::is_same<gpu::RequireAll<Type, const Type&>, int>::value, #RequireAll " should compile")
+
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_device_matrix, require_device_matrix, require_all_device_matrix, TraitDeviceMatrix,
+                              TraitAdjointView);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_adjoint_view, require_adjoint_view, require_all_adjoint_view, TraitAdjointView,
+                              TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_transpose_view, require_transpose_view, require_all_transpose_view, TraitTransposeView,
+                              TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_gemm_expr, require_gemm_expr, require_all_gemm_expr, TraitGemmExpr, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_triangular_view, require_triangular_view, require_all_triangular_view,
+                              TraitTriangularView, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_trsm_expr, require_trsm_expr, require_all_trsm_expr, TraitTrsmExpr, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_selfadjoint_view, require_selfadjoint_view, require_all_selfadjoint_view,
+                              TraitSelfAdjointView, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_const_selfadjoint_view, require_const_selfadjoint_view,
+                              require_all_const_selfadjoint_view, TraitConstSelfAdjointView, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_symm_expr, require_symm_expr, require_all_symm_expr, TraitSymmExpr, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_syrk_expr, require_syrk_expr, require_all_syrk_expr, TraitSyrkExpr, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_llt_solve_expr, require_llt_solve_expr, require_all_llt_solve_expr, TraitLltSolveExpr,
+                              TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_lu_solve_expr, require_lu_solve_expr, require_all_lu_solve_expr, TraitLuSolveExpr,
+                              TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_llt_view, require_llt_view, require_all_llt_view, TraitLltView, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_lu_view, require_lu_view, require_all_lu_view, TraitLuView, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_device_add_expr, require_device_add_expr, require_all_device_add_expr,
+                              TraitDeviceAddExpr, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_device_scaled_device, require_device_scaled_device, require_all_device_scaled_device,
+                              TraitDeviceScaledDevice, TraitDeviceMatrix);
+EIGEN_GPU_STATIC_ASSERT_TRAIT(is_device_scalar, require_device_scalar, require_all_device_scalar, TraitDeviceScalar,
+                              TraitDeviceMatrix);
+
+#undef EIGEN_GPU_STATIC_ASSERT_TRAIT
+
+// is_device_buffer has no require_all_ variant, so it is checked directly.
+static_assert(gpu::is_device_buffer_v<TraitDeviceBuffer>, "internal::DeviceBuffer is a device buffer");
+static_assert(gpu::is_device_buffer_v<const TraitDeviceBuffer&>, "is_device_buffer_v should decay cv/ref");
+static_assert(!gpu::is_device_buffer_v<TraitDeviceMatrix>, "a DeviceMatrix is not a DeviceBuffer");
+static_assert(std::is_same<gpu::require_device_buffer<TraitDeviceBuffer>, int>::value,
+              "require_device_buffer should compile");
+
+// is_scaled is name-keyed; is_scaled_leaf / is_scaled_gemm compose it with a
+// predicate over Scaled::Inner. None of the three has a require_all_ variant.
+static_assert(gpu::is_scaled_v<TraitScaledMatrix>, "Scaled is a scaled node");
+static_assert(gpu::is_scaled_v<const TraitScaledMatrix&>, "is_scaled_v should decay cv/ref");
+static_assert(!gpu::is_scaled_v<TraitDeviceMatrix>, "a DeviceMatrix is not a scaled node");
+static_assert(std::is_same<gpu::require_scaled<TraitScaledMatrix>, int>::value, "require_scaled should compile");
+
+// Scaled names its operand, which is what the two composed predicates read.
+static_assert(std::is_same<TraitScaledMatrix::Inner, TraitDeviceMatrix>::value, "Scaled exposes its inner type");
+static_assert(std::is_same<gpu::Scaled<const TraitDeviceMatrix&>::Inner, TraitDeviceMatrix>::value,
+              "Scaled::Inner decays the operand");
+
+static_assert(gpu::is_scaled_leaf_v<TraitScaledMatrix>, "Scaled<DeviceMatrix> is a scaled leaf");
+static_assert(gpu::is_scaled_leaf_v<TraitScaledMatrix&&>, "is_scaled_leaf_v should decay refs");
+static_assert(gpu::is_scaled_leaf_v<gpu::Scaled<const TraitDeviceMatrix&>>,
+              "a scaled leaf is still a leaf through Scaled::Inner's decay");
+static_assert(!gpu::is_scaled_leaf_v<gpu::Scaled<TraitAdjointView>>, "Scaled over a view is not a scaled leaf");
+static_assert(!gpu::is_scaled_leaf_v<gpu::Scaled<TraitTransposeView>>, "Scaled over a view is not a scaled leaf");
+static_assert(!gpu::is_scaled_leaf_v<gpu::Scaled<TraitGemmExpr>>, "Scaled over a composite is not a scaled leaf");
+static_assert(!gpu::is_scaled_leaf_v<TraitDeviceMatrix>, "a bare leaf is not a scaled leaf");
+
+static_assert(gpu::is_scaled_gemm_v<gpu::Scaled<TraitGemmExpr>>, "Scaled<GemmExpr> is a scaled product");
+static_assert(!gpu::is_scaled_gemm_v<TraitGemmExpr>, "a bare GemmExpr is not a scaled product");
+static_assert(!gpu::is_scaled_gemm_v<TraitScaledMatrix>, "Scaled<leaf> is not a scaled product");
+static_assert(!gpu::is_scaled_gemm_v<gpu::Scaled<TraitAdjointView>>, "Scaled<view> is not a scaled product");
+
+// The gate short-circuits: a non-Scaled operand must answer false, not fail to
+// compile on the missing ::Inner member.
+static_assert(!gpu::is_scaled_leaf_v<TraitAdjointView>, "a view has no ::Inner and is not a scaled leaf");
+static_assert(!gpu::is_scaled_gemm_v<TraitDeviceScalar>, "a device scalar has no ::Inner and is not a scaled product");
+
+static_assert(gpu::is_gemm_like_v<TraitGemmExpr>, "a GemmExpr is gemm-like");
+static_assert(gpu::is_gemm_like_v<gpu::Scaled<TraitGemmExpr>>, "Scaled<GemmExpr> is gemm-like");
+static_assert(!gpu::is_gemm_like_v<TraitDeviceMatrix>, "a leaf is not gemm-like");
+static_assert(!gpu::is_gemm_like_v<TraitDeviceAddExpr>, "a sum is not gemm-like");
+
+// A factorization handle of either kind satisfies the combined operator gate.
+static_assert(gpu::is_factor_expr_v<TraitLuView>, "LUView is a factorization handle");
+static_assert(gpu::is_factor_expr_v<TraitLltView>, "LLTView is a factorization handle");
+static_assert(!gpu::is_factor_expr_v<TraitDeviceMatrix>, "a leaf is not a factorization handle");
+
+// Query aliases over device_expr_traits (specializations from DeviceExpr.h).
+static_assert(gpu::is_device_expr_v<TraitDeviceMatrix>, "a leaf is a device-expression operand");
+static_assert(gpu::is_device_expr_v<const TraitAdjointView&>, "an adjoint view is a device-expression operand");
+static_assert(gpu::is_device_expr_v<TraitTransposeView&&>, "a transpose view is a device-expression operand");
+static_assert(gpu::is_device_expr_v<TraitScaledMatrix>, "a scaled leaf is a device-expression operand");
+static_assert(!gpu::is_device_expr_v<TraitGemmExpr>, "a GemmExpr is dispatched, not an operand");
+static_assert(std::is_same<gpu::scalar_type_t<const TraitScaledMatrix&>, double>::value,
+              "scalar_type_t decays cv/ref and folds the operand scalar");
+static_assert(std::is_same<gpu::scalar_type_t<TraitAdjointView>, double>::value, "scalar_type_t reads the view scalar");
+static_assert(gpu::trans_op<TraitDeviceMatrix> == gpu::GpuOp::NoTrans, "a leaf is NoTrans");
+static_assert(gpu::trans_op<TraitAdjointView> == gpu::GpuOp::ConjTrans, "an adjoint view is ConjTrans");
+static_assert(gpu::trans_op<TraitTransposeView> == gpu::GpuOp::Trans, "a transpose view is Trans");
+static_assert(std::is_same<gpu::require_all_device_expr<TraitDeviceMatrix, const TraitAdjointView&, TraitScaledMatrix>,
+                           int>::value,
+              "require_all_device_expr should compile for device-expression operands");
+}  // namespace
+
+EIGEN_DECLARE_TEST(device_traits) {}
diff --git a/contrib/test/GPU/gpu_test_helpers.h b/contrib/test/GPU/gpu_test_helpers.h
new file mode 100644
index 0000000..968cddc
--- /dev/null
+++ b/contrib/test/GPU/gpu_test_helpers.h
@@ -0,0 +1,96 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Helpers shared across GPU library tests:
+//   * runtime probes that exit(77) (CI skip) when a library is unavailable
+//   * a small make_test_value() that constructs a Scalar with an imaginary
+//     component for complex types so the complex code paths are genuinely
+//     exercised — without this, Scalar(real_value) silently zeros the imag.
+
+#ifndef EIGEN_UNSUPPORTED_TEST_GPU_TEST_HELPERS_H
+#define EIGEN_UNSUPPORTED_TEST_GPU_TEST_HELPERS_H
+
+#include <Eigen/Core>
+#include <cstdlib>
+#include <iostream>
+#include <type_traits>
+
+namespace gpu_test {
+
+template <typename Scalar, typename RealScalar>
+inline std::enable_if_t<Eigen::NumTraits<Scalar>::IsComplex, Scalar> make_test_value(RealScalar re, RealScalar im) {
+  return Scalar(re, im);
+}
+template <typename Scalar, typename RealScalar>
+inline std::enable_if_t<!Eigen::NumTraits<Scalar>::IsComplex, Scalar> make_test_value(RealScalar re,
+                                                                                      RealScalar /*im*/) {
+  return Scalar(re);
+}
+
+#ifdef CUDART_VERSION
+// The CUDA runtime loads without a driver, so a GPU test binary starts happily on
+// a machine with no device and only fails at its first allocation -- as an abort
+// out of EIGEN_CUDA_RUNTIME_CHECK, not a skip. Probe the device count first so
+// those runs report as skipped, the way the per-library probes below do.
+inline void require_cuda_device() {
+  int count = 0;
+  const cudaError_t status = cudaGetDeviceCount(&count);
+  if (status != cudaSuccess || count == 0) {
+    std::cout << "SKIP: GPU tests require a CUDA device. cudaGetDeviceCount reported " << cudaGetErrorString(status)
+              << " with " << count << " device(s)." << std::endl;
+    std::exit(77);
+  }
+}
+#endif
+
+#ifdef CUDSS_VERSION
+inline void require_cudss_context() {
+  cudssHandle_t handle = nullptr;
+  const cudssStatus_t status = cudssCreate(&handle);
+  if (status != CUDSS_STATUS_SUCCESS) {
+    std::cout << "SKIP: cuDSS tests require an initialized cuDSS context. cudssCreate failed with status "
+              << static_cast<int>(status) << std::endl;
+    std::exit(77);
+  }
+  EIGEN_CUDSS_CHECK(cudssDestroy(handle));
+}
+#endif
+
+#ifdef CUSPARSE_VERSION
+inline void require_cusparse_context() {
+  cusparseHandle_t handle = nullptr;
+  const cusparseStatus_t status = cusparseCreate(&handle);
+  if (status != CUSPARSE_STATUS_SUCCESS) {
+    std::cout << "SKIP: cuSPARSE tests require an initialized cuSPARSE context. cusparseCreate failed with status "
+              << static_cast<int>(status) << std::endl;
+    std::exit(77);
+  }
+  EIGEN_CUSPARSE_CHECK(cusparseDestroy(handle));
+}
+#endif
+
+#ifdef CUFFT_VERSION
+inline void require_cufft_context() {
+  cufftHandle plan = 0;
+  // cufftCreate allocates a plan handle without configuring it; succeeds only
+  // when the cuFFT runtime is loadable.
+  const cufftResult status = cufftCreate(&plan);
+  if (status != CUFFT_SUCCESS) {
+    std::cout << "SKIP: cuFFT tests require a working cuFFT runtime. cufftCreate failed with status "
+              << static_cast<int>(status) << std::endl;
+    std::exit(77);
+  }
+  EIGEN_CUFFT_CHECK(cufftDestroy(plan));
+}
+#endif
+
+}  // namespace gpu_test
+
+#endif  // EIGEN_UNSUPPORTED_TEST_GPU_TEST_HELPERS_H
diff --git a/contrib/test/NNLS.cpp b/contrib/test/NNLS.cpp
new file mode 100644
index 0000000..1101310
--- /dev/null
+++ b/contrib/test/NNLS.cpp
@@ -0,0 +1,535 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) Essex Edwards <essex.edwards@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_RUNTIME_NO_MALLOC
+
+#include "main.h"
+#include <contrib/Eigen/NNLS>
+
+/// Check that 'x' solves the NNLS optimization problem `min ||A*x-b|| s.t. 0 <= x`.
+/// The \p tolerance parameter is the absolute tolerance on the gradient, A'*(A*x-b).
+template <typename MatrixType, typename VectorB, typename VectorX, typename Scalar>
+void verify_nnls_optimality(const MatrixType &A, const VectorB &b, const VectorX &x, const Scalar tolerance) {
+  // The NNLS optimality conditions are:
+  //
+  // * 0 = A'*A*x - A'*b - lambda
+  // * 0 <= x[i] \forall i
+  // * 0 <= lambda[i] \forall i
+  // * 0 = x[i]*lambda[i] \forall i
+  //
+  // we don't know lambda, but by assuming the first optimality condition is true,
+  // we can derive it and then check the others conditions.
+  const VectorX lambda = A.transpose() * (A * x - b);
+
+  // NNLS solutions are EXACTLY not negative.
+  VERIFY_LE(0, x.minCoeff());
+
+  // Exact lambda would be non-negative, but computed lambda might leak a little
+  VERIFY_LE(-tolerance, lambda.minCoeff());
+
+  // x[i]*lambda[i] == 0 <~~> (x[i]==0) || (lambda[i] is small)
+  VERIFY(((x.array() == Scalar(0)) || (lambda.array() <= tolerance)).all());
+}
+
+template <typename MatrixType, typename VectorB, typename VectorX>
+void test_nnls_known_solution(const MatrixType &A, const VectorB &b, const VectorX &x_expected) {
+  using Scalar = typename MatrixType::Scalar;
+
+  using std::sqrt;
+  const Scalar tolerance = sqrt(Eigen::GenericNumTraits<Scalar>::epsilon());
+  Index max_iter = 5 * A.cols();  // A heuristic guess.
+  NNLS<MatrixType> nnls(A, max_iter, tolerance);
+  const VectorX x = nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY_IS_APPROX(x, x_expected);
+  verify_nnls_optimality(A, b, x, tolerance);
+}
+
+template <typename MatrixType>
+void test_nnls_random_problem(const MatrixType &) {
+  //
+  // SETUP
+  //
+
+  Index cols = MatrixType::ColsAtCompileTime;
+  if (cols == Dynamic) cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  Index rows = MatrixType::RowsAtCompileTime;
+  if (rows == Dynamic) rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
+  VERIFY_LE(cols, rows);  // To have a unique LS solution: cols <= rows.
+
+  // Make some sort of random test problem from a wide range of scales and condition numbers.
+  using std::pow;
+  using Scalar = typename MatrixType::Scalar;
+  const Scalar sqrtConditionNumber = pow(Scalar(10), internal::random<Scalar>(Scalar(0), Scalar(2)));
+  const Scalar scaleA = pow(Scalar(10), internal::random<Scalar>(Scalar(-3), Scalar(3)));
+  const Scalar minSingularValue = scaleA / sqrtConditionNumber;
+  const Scalar maxSingularValue = scaleA * sqrtConditionNumber;
+  MatrixType A(rows, cols);
+  generateRandomMatrixSvs(setupRangeSvs<Matrix<Scalar, Dynamic, 1>>(cols, minSingularValue, maxSingularValue), rows,
+                          cols, A);
+
+  // Make a random RHS also with a random scaling.
+  using VectorB = decltype(A.col(0).eval());
+  const Scalar scaleB = pow(Scalar(10), internal::random<Scalar>(Scalar(-3), Scalar(3)));
+  const VectorB b = scaleB * VectorB::Random(A.rows());
+
+  //
+  // ACT
+  //
+
+  using Scalar = typename MatrixType::Scalar;
+  using std::sqrt;
+  const Scalar tolerance =
+      sqrt(Eigen::GenericNumTraits<Scalar>::epsilon()) * b.cwiseAbs().maxCoeff() * A.cwiseAbs().maxCoeff();
+  Index max_iter = 5 * A.cols();  // A heuristic guess.
+  NNLS<MatrixType> nnls(A, max_iter, tolerance);
+  const typename NNLS<MatrixType>::SolutionVectorType &x = nnls.solve(b);
+
+  //
+  // VERIFY
+  //
+
+  // In fact, NNLS can fail on some problems, but they are rare in practice.
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  verify_nnls_optimality(A, b, x, tolerance);
+}
+
+void test_nnls_handles_zero_rhs() {
+  //
+  // SETUP
+  //
+  const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
+  const MatrixXd A = MatrixXd::Random(rows, cols);
+  const VectorXd b = VectorXd::Zero(rows);
+
+  //
+  // ACT
+  //
+  NNLS<MatrixXd> nnls(A);
+  const VectorXd x = nnls.solve(b);
+
+  //
+  // VERIFY
+  //
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY_LE(nnls.iterations(), 1);  // 0 or 1 would be be fine for an edge case like this.
+  VERIFY_IS_EQUAL(x, VectorXd::Zero(cols));
+}
+
+void test_nnls_handles_Mx0_matrix() {
+  //
+  // SETUP
+  //
+  const Index rows = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  const MatrixXd A(rows, 0);
+  const VectorXd b = VectorXd::Random(rows);
+
+  //
+  // ACT
+  //
+  NNLS<MatrixXd> nnls(A);
+  const VectorXd x = nnls.solve(b);
+
+  //
+  // VERIFY
+  //
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY_LE(nnls.iterations(), 0);
+  VERIFY_IS_EQUAL(x.size(), 0);
+}
+
+void test_nnls_handles_0x0_matrix() {
+  //
+  // SETUP
+  //
+  const MatrixXd A(0, 0);
+  const VectorXd b(0);
+
+  //
+  // ACT
+  //
+  NNLS<MatrixXd> nnls(A);
+  const VectorXd x = nnls.solve(b);
+
+  //
+  // VERIFY
+  //
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY_LE(nnls.iterations(), 0);
+  VERIFY_IS_EQUAL(x.size(), 0);
+}
+
+void test_nnls_handles_0xN_matrix() {
+  const MatrixXd A(0, 3);
+  const VectorXd b(0);
+
+  NNLS<MatrixXd> nnls(A, 0, 0.0);
+  const VectorXd x = nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY_IS_EQUAL(nnls.iterations(), 0);
+  VERIFY_IS_EQUAL(x, VectorXd::Zero(3));
+}
+
+void test_nnls_handles_dependent_columns() {
+  //
+  // SETUP
+  //
+  const Index rank = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE / 2);
+  const Index cols = 2 * rank;
+  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
+  const MatrixXd A = MatrixXd::Random(rows, rank) * MatrixXd::Random(rank, cols);
+  const VectorXd b = VectorXd::Random(rows);
+
+  //
+  // ACT
+  //
+  // The default-constructed solver stops when the gradient falls below
+  // dummy_precision(); the independent A^T*(A*x-b) recomputation in the check
+  // can exceed that by a small factor, larger here because the dependent
+  // columns make the problem degenerate.
+  const double tolerance = 32 * NumTraits<double>::dummy_precision();
+  NNLS<MatrixXd> nnls(A);
+  const VectorXd &x = nnls.solve(b);
+
+  //
+  // VERIFY
+  //
+  // What should happen when the input 'A' has dependent columns?
+  // We might still succeed. Or we might not converge.
+  // Either outcome is fine. If Success is indicated,
+  // then 'x' must actually be a solution vector.
+
+  if (nnls.info() == ComputationInfo::Success) {
+    verify_nnls_optimality(A, b, x, tolerance);
+  }
+}
+
+void test_nnls_handles_wide_matrix() {
+  //
+  // SETUP
+  //
+  const Index cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
+  const Index rows = internal::random<Index>(2, cols - 1);
+  const MatrixXd A = MatrixXd::Random(rows, cols);
+  const VectorXd b = VectorXd::Random(rows);
+
+  //
+  // ACT
+  //
+  // As above, the check tolerance tracks the solver's dummy_precision() stopping
+  // criterion plus the small slack from recomputing the gradient independently.
+  const double tolerance = 2 * NumTraits<double>::dummy_precision();
+  NNLS<MatrixXd> nnls(A);
+  const VectorXd &x = nnls.solve(b);
+
+  //
+  // VERIFY
+  //
+  // What should happen when the input 'A' is wide?
+  // The unconstrained least-squares problem has infinitely many solutions.
+  // Subject the the non-negativity constraints,
+  // the solution might actually be unique (e.g. it is [0,0,..,0]).
+  // So, NNLS might succeed or it might fail.
+  // Either outcome is fine. If Success is indicated,
+  // then 'x' must actually be a solution vector.
+
+  if (nnls.info() == ComputationInfo::Success) {
+    verify_nnls_optimality(A, b, x, tolerance);
+  }
+}
+
+void test_nnls_wide_matrix_at_row_capacity() {
+  Matrix<double, 2, 3> A;
+  A << 1, 0, -1, 0, 1, -1;
+  Vector2d b;
+  b << 1, 2;
+
+  NNLS<Matrix<double, 2, 3>> nnls(A, 2);
+  const Vector3d &x = nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY_IS_EQUAL(nnls.iterations(), 2);
+  verify_nnls_optimality(A, b, x, nnls.tolerance());
+}
+
+void test_nnls_does_not_report_false_success_at_row_capacity() {
+  Matrix<double, 2, 4> A;
+  A << 9000, 9000, -3000, 1e-11, 9000, 9000, -3000, -1e-11;
+  Vector2d b;
+  b << -2, -3;
+
+  NNLS<Matrix<double, 2, 4>> nnls(A);
+  nnls.solve(b);
+
+  // The passive QR basis becomes numerically dependent. Its feasible iterate is
+  // not optimal, so reaching the row capacity must not be reported as success.
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::NumericalIssue);
+  VERIFY_IS_EQUAL(nnls.iterations(), 2);
+}
+
+void test_nnls_reports_nonfinite_inactive_solution() {
+  const Matrix<double, 3, 2> A = Matrix<double, 3, 2>::Zero();
+  Vector3d b;
+  b << 1, 0, 0;
+
+  NNLS<Matrix<double, 3, 2>> nnls(A, -1, 0.0);
+  nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::NumericalIssue);
+}
+
+// 4x2 problem, unconstrained solution positive
+void test_nnls_known_1() {
+  Matrix<double, 4, 2> A(4, 2);
+  Matrix<double, 4, 1> b(4);
+  Matrix<double, 2, 1> x(2);
+  A << 1, 1, 2, 4, 3, 9, 4, 16;
+  b << 0.6, 2.2, 4.8, 8.4;
+  x << 0.1, 0.5;
+
+  return test_nnls_known_solution(A, b, x);
+}
+
+// 4x3 problem, unconstrained solution positive
+void test_nnls_known_2() {
+  Matrix<double, 4, 3> A(4, 3);
+  Matrix<double, 4, 1> b(4);
+  Matrix<double, 3, 1> x(3);
+
+  A << 1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64;
+  b << 0.73, 3.24, 8.31, 16.72;
+  x << 0.1, 0.5, 0.13;
+
+  test_nnls_known_solution(A, b, x);
+}
+
+// Simple 4x4 problem, unconstrained solution non-negative
+void test_nnls_known_3() {
+  Matrix<double, 4, 4> A(4, 4);
+  Matrix<double, 4, 1> b(4);
+  Matrix<double, 4, 1> x(4);
+
+  A << 1, 1, 1, 1, 2, 4, 8, 16, 3, 9, 27, 81, 4, 16, 64, 256;
+  b << 0.73, 3.24, 8.31, 16.72;
+  x << 0.1, 0.5, 0.13, 0;
+
+  test_nnls_known_solution(A, b, x);
+}
+
+// Simple 4x3 problem, unconstrained solution non-negative
+void test_nnls_known_4() {
+  Matrix<double, 4, 3> A(4, 3);
+  Matrix<double, 4, 1> b(4);
+  Matrix<double, 3, 1> x(3);
+
+  A << 1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64;
+  b << 0.23, 1.24, 3.81, 8.72;
+  x << 0.1, 0, 0.13;
+
+  test_nnls_known_solution(A, b, x);
+}
+
+// Simple 4x3 problem, unconstrained solution indefinite
+void test_nnls_known_5() {
+  Matrix<double, 4, 3> A(4, 3);
+  Matrix<double, 4, 1> b(4);
+  Matrix<double, 3, 1> x(3);
+
+  A << 1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64;
+  b << 0.13, 0.84, 2.91, 7.12;
+  // Solution obtained by original nnls() implementation in Fortran
+  x << 0.0, 0.0, 0.1106544;
+
+  test_nnls_known_solution(A, b, x);
+}
+
+void test_nnls_small_reference_problems() {
+  test_nnls_known_1();
+  test_nnls_known_2();
+  test_nnls_known_3();
+  test_nnls_known_4();
+  test_nnls_known_5();
+}
+
+void test_nnls_with_half_precision() {
+  // The random matrix generation tools don't work with `half`,
+  // so here's a simpler setup mostly just to check that NNLS compiles & runs with custom scalar types.
+
+  using Mat = Matrix<half, 8, 2>;
+  using VecB = Matrix<half, 8, 1>;
+  using VecX = Matrix<half, 2, 1>;
+  Mat A = Mat::Random();  // full-column rank with high probability.
+  VecB b = VecB::Random();
+
+  NNLS<Mat> nnls(A, 20, half(1e-2f));
+  const VecX x = nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  // The half-precision QR and the half(1e-2) solver tolerance leak a few tens of eps of gradient.
+  verify_nnls_optimality(A, b, x, half(64) * NumTraits<half>::epsilon());
+}
+
+void test_nnls_special_case_solves_in_zero_iterations() {
+  // The particular NNLS algorithm that is implemented starts with all variables
+  // in the active set.
+  // This test builds a system where all constraints are active at the solution,
+  // so that initial guess is already correct.
+  //
+  // If the implementation changes to another algorithm that does not have this property,
+  // then this test will need to change (e.g. starting from all constraints inactive,
+  // or using ADMM, or an interior point solver).
+
+  const Index n = 10;
+  const Index m = 3 * n;
+  const VectorXd b = VectorXd::Random(m);
+  // With high probability, this is full column rank, which we need for uniqueness.
+  MatrixXd A = MatrixXd::Random(m, n);
+  // Make every column of `A` such that adding it to the active set only /increases/ the objective,
+  // this ensuring the NNLS solution is all zeros.
+  const VectorXd alignment = -(A.transpose() * b).cwiseSign();
+  A = A * alignment.asDiagonal();
+
+  NNLS<MatrixXd> nnls(A);
+  nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY(nnls.iterations() == 0);
+}
+
+void test_nnls_special_case_solves_in_n_iterations() {
+  // The particular NNLS algorithm that is implemented starts with all variables
+  // in the active set and then adds one variable to the inactive set each iteration.
+  // This test builds a system where all variables are inactive at the solution,
+  // so it should take 'n' iterations to get there.
+  //
+  // If the implementation changes to another algorithm that does not have this property,
+  // then this test will need to change (e.g. starting from all constraints inactive,
+  // or using ADMM, or an interior point solver).
+
+  const Index n = 10;
+  const Index m = 3 * n;
+  // With high probability, this is full column rank, which we need for uniqueness.
+  const MatrixXd A = MatrixXd::Random(m, n);
+  const VectorXd x = VectorXd::Random(n).cwiseAbs().array() + 1;  // all positive.
+  const VectorXd b = A * x;
+
+  NNLS<MatrixXd> nnls(A);
+  nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+  VERIFY(nnls.iterations() == n);
+}
+
+void test_nnls_returns_NoConvergence_when_maxIterations_is_too_low() {
+  // Using the special case that takes `n` iterations,
+  // from `test_nnls_special_case_solves_in_n_iterations`,
+  // we can set max iterations too low and that should cause the solve to fail.
+
+  const Index n = 10;
+  const Index m = 3 * n;
+  // With high probability, this is full column rank, which we need for uniqueness.
+  const MatrixXd A = MatrixXd::Random(m, n);
+  const VectorXd x = VectorXd::Random(n).cwiseAbs().array() + 1;  // all positive.
+  const VectorXd b = A * x;
+
+  NNLS<MatrixXd> nnls(A);
+  const Index max_iters = n - 1;
+  nnls.setMaxIterations(max_iters);
+  nnls.solve(b);
+
+  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::NoConvergence);
+  VERIFY(nnls.iterations() == max_iters);
+}
+
+void test_nnls_default_maxIterations_is_twice_column_count() {
+  const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
+  const MatrixXd A = MatrixXd::Random(rows, cols);
+
+  NNLS<MatrixXd> nnls(A);
+
+  VERIFY_IS_EQUAL(nnls.maxIterations(), 2 * cols);
+}
+
+void test_nnls_does_not_allocate_during_solve() {
+  const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
+  const MatrixXd A = MatrixXd::Random(rows, cols);
+  const VectorXd b = VectorXd::Random(rows);
+
+  NNLS<MatrixXd> nnls(A);
+
+  internal::set_is_malloc_allowed(false);
+  nnls.solve(b);
+  internal::set_is_malloc_allowed(true);
+}
+
+void test_nnls_repeated_calls_to_compute_and_solve() {
+  const Index cols2 = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  const Index rows2 = internal::random<Index>(cols2, EIGEN_TEST_MAX_SIZE);
+  const MatrixXd A2 = MatrixXd::Random(rows2, cols2);
+  const VectorXd b2 = VectorXd::Random(rows2);
+
+  NNLS<MatrixXd> nnls;
+
+  for (int i = 0; i < 4; ++i) {
+    const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+    const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
+    const MatrixXd A = MatrixXd::Random(rows, cols);
+
+    nnls.compute(A);
+    VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+
+    for (int j = 0; j < 3; ++j) {
+      const VectorXd b = VectorXd::Random(rows);
+      const VectorXd x = nnls.solve(b);
+      VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
+      verify_nnls_optimality(A, b, x, 1e-4);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(NNLS) {
+  // Small matrices with known solutions:
+  CALL_SUBTEST_1(test_nnls_small_reference_problems());
+  CALL_SUBTEST_1(test_nnls_handles_Mx0_matrix());
+  CALL_SUBTEST_1(test_nnls_handles_0x0_matrix());
+  CALL_SUBTEST_1(test_nnls_handles_0xN_matrix());
+  CALL_SUBTEST_6(test_nnls_wide_matrix_at_row_capacity());
+  CALL_SUBTEST_6(test_nnls_does_not_report_false_success_at_row_capacity());
+  CALL_SUBTEST_6(test_nnls_reports_nonfinite_inactive_solution());
+
+  for (int i = 0; i < g_repeat; i++) {
+    // Essential NNLS properties, across different types.
+    CALL_SUBTEST_2(test_nnls_random_problem(MatrixXf()));
+    CALL_SUBTEST_3(test_nnls_random_problem(MatrixXd()));
+    CALL_SUBTEST_4(test_nnls_random_problem(Matrix<double, 12, 5>()));
+    CALL_SUBTEST_5(test_nnls_with_half_precision());
+
+    // Robustness tests:
+    CALL_SUBTEST_6(test_nnls_handles_zero_rhs());
+    CALL_SUBTEST_6(test_nnls_handles_dependent_columns());
+    CALL_SUBTEST_6(test_nnls_handles_wide_matrix());
+
+    // Properties specific to the implementation,
+    // not NNLS in general.
+    CALL_SUBTEST_7(test_nnls_special_case_solves_in_zero_iterations());
+    CALL_SUBTEST_7(test_nnls_special_case_solves_in_n_iterations());
+    CALL_SUBTEST_7(test_nnls_returns_NoConvergence_when_maxIterations_is_too_low());
+    CALL_SUBTEST_7(test_nnls_default_maxIterations_is_twice_column_count());
+    CALL_SUBTEST_8(test_nnls_repeated_calls_to_compute_and_solve());
+
+    // This test fails. It hits allocations in HouseholderSequence.h
+    // test_nnls_does_not_allocate_during_solve();
+  }
+}
diff --git a/contrib/test/NonLinearOptimization.cpp b/contrib/test/NonLinearOptimization.cpp
new file mode 100644
index 0000000..0ee6f7b
--- /dev/null
+++ b/contrib/test/NonLinearOptimization.cpp
@@ -0,0 +1,1291 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// SPDX-License-Identifier: MPL-2.0
+
+#include <stdio.h>
+
+#include "main.h"
+#include <contrib/Eigen/NonLinearOptimization>
+
+// This disables some useless Warnings on MSVC.
+// It is intended to be done for this test only.
+#include <Eigen/src/Core/util/DisableStupidWarnings.h>
+
+// tolerance for checking number of iterations
+#define LM_EVAL_COUNT_TOL 2
+
+#define LM_CHECK_N_ITERS(SOLVER, NFEV, NJEV)         \
+  {                                                  \
+    VERIFY(SOLVER.nfev <= NFEV * LM_EVAL_COUNT_TOL); \
+    VERIFY(SOLVER.njev <= NJEV * LM_EVAL_COUNT_TOL); \
+  }
+
+int fcn_chkder(const VectorXd &x, VectorXd &fvec, MatrixXd &fjac, int iflag) {
+  /*      subroutine fcn for chkder example. */
+
+  int i;
+  assert(15 == fvec.size());
+  assert(3 == x.size());
+  double tmp1, tmp2, tmp3, tmp4;
+  static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
+                               3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
+
+  if (iflag == 0) return 0;
+
+  if (iflag != 2)
+    for (i = 0; i < 15; i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+      tmp3 = tmp1;
+      if (i >= 8) tmp3 = tmp2;
+      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
+    }
+  else {
+    for (i = 0; i < 15; i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+
+      /* error introduced into next statement for illustration. */
+      /* corrected statement should read    tmp3 = tmp1 . */
+
+      tmp3 = tmp2;
+      if (i >= 8) tmp3 = tmp2;
+      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
+      tmp4 = tmp4 * tmp4;
+      fjac(i, 0) = -1.;
+      fjac(i, 1) = tmp1 * tmp2 / tmp4;
+      fjac(i, 2) = tmp1 * tmp3 / tmp4;
+    }
+  }
+  return 0;
+}
+
+void testChkder() {
+  const int m = 15, n = 3;
+  VectorXd x(n), fvec(m), xp, fvecp(m), err;
+  MatrixXd fjac(m, n);
+  VectorXi ipvt;
+
+  /*      the following values should be suitable for */
+  /*      checking the jacobian matrix. */
+  x << 9.2e-1, 1.3e-1, 5.4e-1;
+
+  internal::chkder(x, fvec, fjac, xp, fvecp, 1, err);
+  fcn_chkder(x, fvec, fjac, 1);
+  fcn_chkder(x, fvec, fjac, 2);
+  fcn_chkder(xp, fvecp, fjac, 1);
+  internal::chkder(x, fvec, fjac, xp, fvecp, 2, err);
+
+  fvecp -= fvec;
+
+  // check those
+  VectorXd fvec_ref(m), fvecp_ref(m), err_ref(m);
+  fvec_ref << -1.181606, -1.429655, -1.606344, -1.745269, -1.840654, -1.921586, -1.984141, -2.022537, -2.468977,
+      -2.827562, -3.473582, -4.437612, -6.047662, -9.267761, -18.91806;
+  fvecp_ref << -7.724666e-09, -3.432406e-09, -2.034843e-10, 2.313685e-09, 4.331078e-09, 5.984096e-09, 7.363281e-09,
+      8.53147e-09, 1.488591e-08, 2.33585e-08, 3.522012e-08, 5.301255e-08, 8.26666e-08, 1.419747e-07, 3.19899e-07;
+  err_ref << 0.1141397, 0.09943516, 0.09674474, 0.09980447, 0.1073116, 0.1220445, 0.1526814, 1, 1, 1, 1, 1, 1, 1, 1;
+
+  VERIFY_IS_APPROX(fvec, fvec_ref);
+  VERIFY_IS_APPROX(fvecp, fvecp_ref);
+  VERIFY_IS_APPROX(err, err_ref);
+}
+
+// Generic functor
+template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
+struct Functor {
+  typedef Scalar_ Scalar;
+  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
+  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
+
+  const int m_inputs, m_values;
+
+  Functor() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
+  Functor(int inputs, int values) : m_inputs(inputs), m_values(values) {}
+
+  int inputs() const { return m_inputs; }
+  int values() const { return m_values; }
+
+  // you should define that in the subclass :
+  //  void operator() (const InputType& x, ValueType* v, JacobianType* _j=0) const;
+};
+
+using LmFunctorBase = Functor<double>;
+#include "lm_test_functors.h"
+
+void testLmder1() {
+  int n = 3, info;
+
+  VectorXd x;
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmder_functor functor;
+  LevenbergMarquardt<lmder_functor> lm(functor);
+  info = lm.lmder1(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 6, 5);
+
+  // check norm
+  VERIFY_IS_APPROX(lm.fvec.blueNorm(), 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testLmder() {
+  const int m = 15, n = 3;
+  int info;
+  double fnorm, covfac;
+  VectorXd x;
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmder_functor functor;
+  LevenbergMarquardt<lmder_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return values
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 6, 5);
+
+  // check norm
+  fnorm = lm.fvec.blueNorm();
+  VERIFY_IS_APPROX(fnorm, 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+
+  // check covariance
+  covfac = fnorm * fnorm / (m - n);
+  internal::covar(lm.fjac, lm.permutation.indices());  // TODO : move this as a function of lm
+
+  MatrixXd cov_ref(n, n);
+  cov_ref << 0.0001531202, 0.002869941, -0.002656662, 0.002869941, 0.09480935, -0.09098995, -0.002656662, -0.09098995,
+      0.08778727;
+
+  //  std::cout << fjac*covfac << std::endl;
+
+  MatrixXd cov;
+  cov = covfac * lm.fjac.topLeftCorner<n, n>();
+  VERIFY_IS_APPROX(cov, cov_ref);
+  // TODO: why isn't this allowed ? :
+  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
+}
+
+struct hybrj_functor : Functor<double> {
+  hybrj_functor(void) : Functor<double>(9, 9) {}
+
+  int operator()(const VectorXd &x, VectorXd &fvec) {
+    double temp, temp1, temp2;
+    const VectorXd::Index n = x.size();
+    assert(fvec.size() == n);
+    for (VectorXd::Index k = 0; k < n; k++) {
+      temp = (3. - 2. * x[k]) * x[k];
+      temp1 = 0.;
+      if (k) temp1 = x[k - 1];
+      temp2 = 0.;
+      if (k != n - 1) temp2 = x[k + 1];
+      fvec[k] = temp - temp1 - 2. * temp2 + 1.;
+    }
+    return 0;
+  }
+  int df(const VectorXd &x, MatrixXd &fjac) {
+    const VectorXd::Index n = x.size();
+    assert(fjac.rows() == n);
+    assert(fjac.cols() == n);
+    for (VectorXd::Index k = 0; k < n; k++) {
+      for (VectorXd::Index j = 0; j < n; j++) fjac(k, j) = 0.;
+      fjac(k, k) = 3. - 4. * x[k];
+      if (k) fjac(k, k - 1) = -1.;
+      if (k != n - 1) fjac(k, k + 1) = -2.;
+    }
+    return 0;
+  }
+};
+
+void testHybrj1() {
+  const int n = 9;
+  int info;
+  VectorXd x(n);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, -1.);
+
+  // do the computation
+  hybrj_functor functor;
+  HybridNonLinearSolver<hybrj_functor> solver(functor);
+  info = solver.hybrj1(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(solver, 11, 1);
+
+  // check norm
+  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testHybrj() {
+  const int n = 9;
+  int info;
+  VectorXd x(n);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, -1.);
+
+  // do the computation
+  hybrj_functor functor;
+  HybridNonLinearSolver<hybrj_functor> solver(functor);
+  solver.diag.setConstant(n, 1.);
+  solver.useExternalScaling = true;
+  info = solver.solve(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(solver, 11, 1);
+
+  // check norm
+  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+struct hybrd_functor : Functor<double> {
+  hybrd_functor(void) : Functor<double>(9, 9) {}
+  int operator()(const VectorXd &x, VectorXd &fvec) const {
+    double temp, temp1, temp2;
+    const VectorXd::Index n = x.size();
+
+    assert(fvec.size() == n);
+    for (VectorXd::Index k = 0; k < n; k++) {
+      temp = (3. - 2. * x[k]) * x[k];
+      temp1 = 0.;
+      if (k) temp1 = x[k - 1];
+      temp2 = 0.;
+      if (k != n - 1) temp2 = x[k + 1];
+      fvec[k] = temp - temp1 - 2. * temp2 + 1.;
+    }
+    return 0;
+  }
+};
+
+void testHybrd1() {
+  int n = 9, info;
+  VectorXd x(n);
+
+  /* the following starting values provide a rough solution. */
+  x.setConstant(n, -1.);
+
+  // do the computation
+  hybrd_functor functor;
+  HybridNonLinearSolver<hybrd_functor> solver(functor);
+  info = solver.hybrd1(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  VERIFY(solver.nfev <= 20 * LM_EVAL_COUNT_TOL);
+
+  // check norm
+  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testHybrd() {
+  const int n = 9;
+  int info;
+  VectorXd x;
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, -1.);
+
+  // do the computation
+  hybrd_functor functor;
+  HybridNonLinearSolver<hybrd_functor> solver(functor);
+  solver.parameters.nb_of_subdiagonals = 1;
+  solver.parameters.nb_of_superdiagonals = 1;
+  solver.diag.setConstant(n, 1.);
+  solver.useExternalScaling = true;
+  info = solver.solveNumericalDiff(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  VERIFY(solver.nfev <= 14 * LM_EVAL_COUNT_TOL);
+
+  // check norm
+  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+struct lmstr_functor : Functor<double> {
+  lmstr_functor(void) : Functor<double>(3, 15) {}
+  int operator()(const VectorXd &x, VectorXd &fvec) {
+    /*  subroutine fcn for lmstr1 example. */
+    double tmp1, tmp2, tmp3;
+    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
+                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
+
+    assert(15 == fvec.size());
+    assert(3 == x.size());
+
+    for (int i = 0; i < 15; i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+      tmp3 = (i >= 8) ? tmp2 : tmp1;
+      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
+    }
+    return 0;
+  }
+  int df(const VectorXd &x, VectorXd &jac_row, VectorXd::Index rownb) {
+    assert(x.size() == 3);
+    assert(jac_row.size() == x.size());
+    double tmp1, tmp2, tmp3, tmp4;
+
+    VectorXd::Index i = rownb - 2;
+    tmp1 = i + 1;
+    tmp2 = 16 - i - 1;
+    tmp3 = (i >= 8) ? tmp2 : tmp1;
+    tmp4 = (x[1] * tmp2 + x[2] * tmp3);
+    tmp4 = tmp4 * tmp4;
+    jac_row[0] = -1;
+    jac_row[1] = tmp1 * tmp2 / tmp4;
+    jac_row[2] = tmp1 * tmp3 / tmp4;
+    return 0;
+  }
+};
+
+void testLmstr1() {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmstr_functor functor;
+  LevenbergMarquardt<lmstr_functor> lm(functor);
+  info = lm.lmstr1(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 6, 5);
+
+  // check norm
+  VERIFY_IS_APPROX(lm.fvec.blueNorm(), 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testLmstr() {
+  const int n = 3;
+  int info;
+  double fnorm;
+  VectorXd x(n);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmstr_functor functor;
+  LevenbergMarquardt<lmstr_functor> lm(functor);
+  info = lm.minimizeOptimumStorage(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return values
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 6, 5);
+
+  // check norm
+  fnorm = lm.fvec.blueNorm();
+  VERIFY_IS_APPROX(fnorm, 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testLmdif1() {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n), fvec(15);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmdif_functor functor;
+  DenseIndex nfev = -1;  // initialize to avoid maybe-uninitialized warning
+  info = LevenbergMarquardt<lmdif_functor>::lmdif1(functor, x, &nfev);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  VERIFY(nfev <= 26 * LM_EVAL_COUNT_TOL);
+
+  // check norm
+  functor(x, fvec);
+  VERIFY_IS_APPROX(fvec.blueNorm(), 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.0824106, 1.1330366, 2.3436947;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testLmdif() {
+  const int m = 15, n = 3;
+  int info;
+  double fnorm, covfac;
+  VectorXd x(n);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmdif_functor functor;
+  NumericalDiff<lmdif_functor> numDiff(functor);
+  LevenbergMarquardt<NumericalDiff<lmdif_functor> > lm(numDiff);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return values
+  // VERIFY_IS_EQUAL(info, 1);
+  VERIFY(lm.nfev <= 26 * LM_EVAL_COUNT_TOL);
+
+  // check norm
+  fnorm = lm.fvec.blueNorm();
+  VERIFY_IS_APPROX(fnorm, 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+
+  // check covariance
+  covfac = fnorm * fnorm / (m - n);
+  internal::covar(lm.fjac, lm.permutation.indices());  // TODO : move this as a function of lm
+
+  MatrixXd cov_ref(n, n);
+  cov_ref << 0.0001531202, 0.002869942, -0.002656662, 0.002869942, 0.09480937, -0.09098997, -0.002656662, -0.09098997,
+      0.08778729;
+
+  //  std::cout << fjac*covfac << std::endl;
+
+  MatrixXd cov;
+  cov = covfac * lm.fjac.topLeftCorner<n, n>();
+  VERIFY_IS_APPROX(cov, cov_ref);
+  // TODO: why isn't this allowed ? :
+  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/chwirut2.shtml
+void testNistChwirut2(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 0.1, 0.01, 0.02;
+  // do the computation
+  chwirut2_functor functor;
+  LevenbergMarquardt<chwirut2_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 10, 8);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.1304802941E+02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
+  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
+  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
+
+  /*
+   * Second try
+   */
+  x << 0.15, 0.008, 0.010;
+  // do the computation
+  lm.resetParameters();
+  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
+  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 7, 6);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.1304802941E+02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
+  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
+  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/misra1a.shtml
+void testNistMisra1a(void) {
+  const int n = 2;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 500., 0.0001;
+  // do the computation
+  misra1a_functor functor;
+  LevenbergMarquardt<misra1a_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 19, 15);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.2455138894E-01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
+  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
+
+  /*
+   * Second try
+   */
+  x << 250., 0.0005;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 5, 4);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.2455138894E-01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
+  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/hahn1.shtml
+void testNistHahn1(void) {
+  const int n = 7;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 10., -1., .05, -.00001, -.05, .001, -.000001;
+  // do the computation
+  hahn1_functor functor;
+  LevenbergMarquardt<hahn1_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 11, 10);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.5324382854E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.0776351733E+00);
+  VERIFY_IS_APPROX(x[1], -1.2269296921E-01);
+  VERIFY_IS_APPROX(x[2], 4.0863750610E-03);
+  VERIFY_IS_APPROX(x[3], -1.426264e-06);  // should be : -1.4262662514E-06
+  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
+  VERIFY_IS_APPROX(x[5], 2.4053735503E-04);
+  VERIFY_IS_APPROX(x[6], -1.2314450199E-07);
+
+  /*
+   * Second try
+   */
+  x << .1, -.1, .005, -.000001, -.005, .0001, -.0000001;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 11, 10);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.5324382854E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.077640);       // should be :  1.0776351733E+00
+  VERIFY_IS_APPROX(x[1], -0.1226933);     // should be : -1.2269296921E-01
+  VERIFY_IS_APPROX(x[2], 0.004086383);    // should be : 4.0863750610E-03
+  VERIFY_IS_APPROX(x[3], -1.426277e-06);  // should be : -1.4262662514E-06
+  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
+  VERIFY_IS_APPROX(x[5], 0.00024053772);  // should be : 2.4053735503E-04
+  VERIFY_IS_APPROX(x[6], -1.231450e-07);  // should be : -1.2314450199E-07
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/misra1d.shtml
+void testNistMisra1d(void) {
+  const int n = 2;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 500., 0.0001;
+  // do the computation
+  misra1d_functor functor;
+  LevenbergMarquardt<misra1d_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 3);
+  LM_CHECK_N_ITERS(lm, 9, 7);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6419295283E-02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
+  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
+
+  /*
+   * Second try
+   */
+  x << 450., 0.0003;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 4, 3);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6419295283E-02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
+  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/lanczos1.shtml
+void testNistLanczos1(void) {
+  const int n = 6;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1.2, 0.3, 5.6, 5.5, 6.5, 7.6;
+  // do the computation
+  lanczos1_functor functor;
+  LevenbergMarquardt<lanczos1_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 2);
+  LM_CHECK_N_ITERS(lm, 79, 72);
+  // check norm^2
+  // std::cout.precision(30);
+  // std::cout << lm.fvec.squaredNorm() << "\n";
+  VERIFY(lm.fvec.squaredNorm() <= 1.44E-25);
+  // check x
+  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
+  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
+  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
+  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
+  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
+  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
+
+  /*
+   * Second try
+   */
+  x << 0.5, 0.7, 3.6, 4.2, 4., 6.3;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 2);
+  LM_CHECK_N_ITERS(lm, 9, 8);
+  // check norm^2
+  VERIFY(lm.fvec.squaredNorm() <= 1.44E-25);
+  // check x
+  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
+  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
+  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
+  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
+  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
+  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky2.shtml
+void testNistRat42(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 100., 1., 0.1;
+  // do the computation
+  rat42_functor functor;
+  LevenbergMarquardt<rat42_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 10, 8);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.0565229338E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
+  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
+  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
+
+  /*
+   * Second try
+   */
+  x << 75., 2.5, 0.07;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 6, 5);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.0565229338E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
+  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
+  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/mgh10.shtml
+void testNistMGH10(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 2., 400000., 25000.;
+  // do the computation
+  MGH10_functor functor;
+  LevenbergMarquardt<MGH10_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 2);
+  LM_CHECK_N_ITERS(lm, 284, 249);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7945855171E+01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
+  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
+  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
+
+  /*
+   * Second try
+   */
+  x << 0.02, 4000., 250.;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 3);
+  LM_CHECK_N_ITERS(lm, 126, 116);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7945855171E+01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
+  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
+  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/boxbod.shtml
+void testNistBoxBOD(void) {
+  const int n = 2;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1., 1.;
+  // do the computation
+  BoxBOD_functor functor;
+  LevenbergMarquardt<BoxBOD_functor> lm(functor);
+  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
+  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
+  lm.parameters.factor = 10.;
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 31, 25);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.1680088766E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
+  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
+
+  /*
+   * Second try
+   */
+  x << 100., 0.75;
+  // do the computation
+  lm.resetParameters();
+  lm.parameters.ftol = NumTraits<double>::epsilon();
+  lm.parameters.xtol = NumTraits<double>::epsilon();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 20, 14);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.1680088766E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
+  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/mgh17.shtml
+void testNistMGH17(void) {
+  const int n = 5;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 50., 150., -100., 1., 2.;
+  // do the computation
+  MGH17_functor functor;
+  LevenbergMarquardt<MGH17_functor> lm(functor);
+  lm.parameters.ftol = NumTraits<double>::epsilon();
+  lm.parameters.xtol = NumTraits<double>::epsilon();
+  lm.parameters.maxfev = 1000;
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.4648946975E-05);
+  // check x
+  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
+  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
+  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
+  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
+  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
+
+  // check return value
+  // VERIFY_IS_EQUAL(info, 2);
+  LM_CHECK_N_ITERS(lm, 602, 545);
+
+  /*
+   * Second try
+   */
+  x << 0.5, 1.5, -1, 0.01, 0.02;
+  // do the computation
+  lm.resetParameters();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 18, 15);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.4648946975E-05);
+  // check x
+  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
+  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
+  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
+  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
+  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/mgh09.shtml
+void testNistMGH09(void) {
+  const int n = 4;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 25., 39, 41.5, 39.;
+  // do the computation
+  MGH09_functor functor;
+  LevenbergMarquardt<MGH09_functor> lm(functor);
+  lm.parameters.maxfev = 1000;
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 490, 376);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 3.0750560385E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], 0.1928077089);   // should be 1.9280693458E-01
+  VERIFY_IS_APPROX(x[1], 0.19126423573);  // should be 1.9128232873E-01
+  VERIFY_IS_APPROX(x[2], 0.12305309914);  // should be 1.2305650693E-01
+  VERIFY_IS_APPROX(x[3], 0.13605395375);  // should be 1.3606233068E-01
+
+  /*
+   * Second try
+   */
+  x << 0.25, 0.39, 0.415, 0.39;
+  // do the computation
+  lm.resetParameters();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 18, 16);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 3.0750560385E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], 0.19280781);  // should be 1.9280693458E-01
+  VERIFY_IS_APPROX(x[1], 0.19126265);  // should be 1.9128232873E-01
+  VERIFY_IS_APPROX(x[2], 0.12305280);  // should be 1.2305650693E-01
+  VERIFY_IS_APPROX(x[3], 0.13605322);  // should be 1.3606233068E-01
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/bennett5.shtml
+void testNistBennett5(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << -2000., 50., 0.8;
+  // do the computation
+  Bennett5_functor functor;
+  LevenbergMarquardt<Bennett5_functor> lm(functor);
+  lm.parameters.maxfev = 1000;
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 758, 744);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.2404744073E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], -2.5235058043E+03);
+  VERIFY_IS_APPROX(x[1], 4.6736564644E+01);
+  VERIFY_IS_APPROX(x[2], 9.3218483193E-01);
+  /*
+   * Second try
+   */
+  x << -1500., 45., 0.85;
+  // do the computation
+  lm.resetParameters();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 203, 192);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.2404744073E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], -2523.3007865);  // should be -2.5235058043E+03
+  VERIFY_IS_APPROX(x[1], 46.735705771);   // should be 4.6736564644E+01);
+  VERIFY_IS_APPROX(x[2], 0.93219881891);  // should be 9.3218483193E-01);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/thurber.shtml
+void testNistThurber(void) {
+  const int n = 7;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1000, 1000, 400, 40, 0.7, 0.3, 0.0;
+  // do the computation
+  thurber_functor functor;
+  LevenbergMarquardt<thurber_functor> lm(functor);
+  lm.parameters.ftol = 1.E4 * NumTraits<double>::epsilon();
+  lm.parameters.xtol = 1.E4 * NumTraits<double>::epsilon();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 39, 36);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6427082397E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
+  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
+  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
+  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
+  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
+  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
+  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
+
+  /*
+   * Second try
+   */
+  x << 1300, 1500, 500, 75, 1, 0.4, 0.05;
+  // do the computation
+  lm.resetParameters();
+  lm.parameters.ftol = 1.E4 * NumTraits<double>::epsilon();
+  lm.parameters.xtol = 1.E4 * NumTraits<double>::epsilon();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 29, 28);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6427082397E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
+  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
+  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
+  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
+  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
+  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
+  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky3.shtml
+void testNistRat43(void) {
+  const int n = 4;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 100., 10., 1., 1.;
+  // do the computation
+  rat43_functor functor;
+  LevenbergMarquardt<rat43_functor> lm(functor);
+  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
+  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 27, 20);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7864049080E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
+  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
+  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
+  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
+
+  /*
+   * Second try
+   */
+  x << 700., 5., 0.75, 1.3;
+  // do the computation
+  lm.resetParameters();
+  lm.parameters.ftol = 1.E5 * NumTraits<double>::epsilon();
+  lm.parameters.xtol = 1.E5 * NumTraits<double>::epsilon();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 9, 8);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7864049080E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
+  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
+  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
+  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/eckerle4.shtml
+void testNistEckerle4(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1., 10., 500.;
+  // do the computation
+  eckerle4_functor functor;
+  LevenbergMarquardt<eckerle4_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 18, 15);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.4635887487E-03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.5543827178);
+  VERIFY_IS_APPROX(x[1], 4.0888321754);
+  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
+
+  /*
+   * Second try
+   */
+  x << 1.5, 5., 450.;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  LM_CHECK_N_ITERS(lm, 7, 6);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.4635887487E-03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.5543827178);
+  VERIFY_IS_APPROX(x[1], 4.0888321754);
+  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
+}
+
+// r1mpyq() indexed its argument through a raw pointer with a hard-coded
+// column-major layout, so it corrupted the accumulated orthogonal factor
+// whenever Matrix<Scalar, Dynamic, Dynamic> is row major, which is what
+// EIGEN_DEFAULT_TO_ROW_MAJOR makes it.
+template <typename StorageType>
+void checkR1mpyq(const MatrixXd &a, const MatrixXd &expected, const std::vector<JacobiRotation<double> > &v_givens,
+                 const std::vector<JacobiRotation<double> > &w_givens) {
+  StorageType stored = a;
+  internal::r1mpyq<double>(stored, v_givens, w_givens);
+  VERIFY_IS_APPROX(MatrixXd(stored), expected);
+}
+
+void testR1mpyq() {
+  const Index n = 5;
+
+  MatrixXd a(n, n);
+  for (Index i = 0; i < n; ++i)
+    for (Index j = 0; j < n; ++j) a(i, j) = 1. + double(i) + 10. * double(j);
+
+  std::vector<JacobiRotation<double> > v_givens(n), w_givens(n);
+  for (Index j = 0; j + 1 < n; ++j) {
+    v_givens[j].makeGivens(1. + double(j), 2. - .5 * double(j));
+    w_givens[j].makeGivens(.5 * double(j) - 1., 3. + double(j));
+  }
+
+  // The MINPACK recurrence, spelled out independently of Eigen's rotation
+  // conventions and of any storage order.
+  MatrixXd expected = a;
+  for (Index j = n - 2; j >= 0; --j)
+    for (Index i = 0; i < n; ++i) {
+      const double temp = v_givens[j].c() * expected(i, j) - v_givens[j].s() * expected(i, n - 1);
+      expected(i, n - 1) = v_givens[j].s() * expected(i, j) + v_givens[j].c() * expected(i, n - 1);
+      expected(i, j) = temp;
+    }
+  for (Index j = 0; j + 1 < n; ++j)
+    for (Index i = 0; i < n; ++i) {
+      const double temp = w_givens[j].c() * expected(i, j) + w_givens[j].s() * expected(i, n - 1);
+      expected(i, n - 1) = -w_givens[j].s() * expected(i, j) + w_givens[j].c() * expected(i, n - 1);
+      expected(i, j) = temp;
+    }
+
+  checkR1mpyq<Matrix<double, Dynamic, Dynamic, ColMajor> >(a, expected, v_givens, w_givens);
+  checkR1mpyq<Matrix<double, Dynamic, Dynamic, RowMajor> >(a, expected, v_givens, w_givens);
+
+  // HybridNonLinearSolver also rotates qtf, which it passes as a single row.
+  VectorXd qtf = a.row(0).transpose();
+  Transpose<VectorXd> qtf_row = qtf.transpose();
+  internal::r1mpyq<double>(qtf_row, v_givens, w_givens);
+  VERIFY_IS_APPROX(qtf.transpose(), expected.row(0));
+}
+
+EIGEN_DECLARE_TEST(NonLinearOptimization) {
+  CALL_SUBTEST /*_2*/ (testR1mpyq());
+
+  // Tests using the examples provided by (c)minpack
+  CALL_SUBTEST /*_1*/ (testChkder());
+  CALL_SUBTEST /*_1*/ (testLmder1());
+  CALL_SUBTEST /*_1*/ (testLmder());
+  CALL_SUBTEST /*_2*/ (testHybrj1());
+  CALL_SUBTEST /*_2*/ (testHybrj());
+  CALL_SUBTEST /*_2*/ (testHybrd1());
+  CALL_SUBTEST /*_2*/ (testHybrd());
+  CALL_SUBTEST /*_3*/ (testLmstr1());
+  CALL_SUBTEST /*_3*/ (testLmstr());
+  CALL_SUBTEST /*_3*/ (testLmdif1());
+  CALL_SUBTEST /*_3*/ (testLmdif());
+
+  // NIST tests, level of difficulty = "Lower"
+  CALL_SUBTEST /*_4*/ (testNistMisra1a());
+  CALL_SUBTEST /*_4*/ (testNistChwirut2());
+
+  // NIST tests, level of difficulty = "Average"
+  CALL_SUBTEST /*_5*/ (testNistHahn1());
+  CALL_SUBTEST /*_6*/ (testNistMisra1d());
+  CALL_SUBTEST /*_7*/ (testNistMGH17());
+  CALL_SUBTEST /*_8*/ (testNistLanczos1());
+
+  //     // NIST tests, level of difficulty = "Higher"
+  CALL_SUBTEST /*_9*/ (testNistRat42());
+  //     CALL_SUBTEST/*_10*/(testNistMGH10());
+  CALL_SUBTEST /*_11*/ (testNistBoxBOD());
+  //     CALL_SUBTEST/*_12*/(testNistMGH09());
+  CALL_SUBTEST /*_13*/ (testNistBennett5());
+  CALL_SUBTEST /*_14*/ (testNistThurber());
+  CALL_SUBTEST /*_15*/ (testNistRat43());
+  CALL_SUBTEST /*_16*/ (testNistEckerle4());
+}
+
+/*
+ * Can be useful for debugging...
+  printf("info, nfev : %d, %d\n", info, lm.nfev);
+  printf("info, nfev, njev : %d, %d, %d\n", info, solver.nfev, solver.njev);
+  printf("info, nfev : %d, %d\n", info, solver.nfev);
+  printf("x[0] : %.32g\n", x[0]);
+  printf("x[1] : %.32g\n", x[1]);
+  printf("x[2] : %.32g\n", x[2]);
+  printf("x[3] : %.32g\n", x[3]);
+  printf("fvec.blueNorm() : %.32g\n", solver.fvec.blueNorm());
+  printf("fvec.blueNorm() : %.32g\n", lm.fvec.blueNorm());
+
+  printf("info, nfev, njev : %d, %d, %d\n", info, lm.nfev, lm.njev);
+  printf("fvec.squaredNorm() : %.13g\n", lm.fvec.squaredNorm());
+  std::cout << x << std::endl;
+  std::cout.precision(9);
+  std::cout << x[0] << std::endl;
+  std::cout << x[1] << std::endl;
+  std::cout << x[2] << std::endl;
+  std::cout << x[3] << std::endl;
+*/
diff --git a/contrib/test/NumericalDiff.cpp b/contrib/test/NumericalDiff.cpp
new file mode 100644
index 0000000..f985d4d
--- /dev/null
+++ b/contrib/test/NumericalDiff.cpp
@@ -0,0 +1,154 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// SPDX-License-Identifier: MPL-2.0
+
+#include <stdio.h>
+
+#include "main.h"
+#include <contrib/Eigen/NumericalDiff>
+
+// Generic functor
+template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
+struct Functor {
+  typedef Scalar_ Scalar;
+  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
+  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
+
+  int m_inputs, m_values;
+
+  Functor() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
+  Functor(int inputs_, int values_) : m_inputs(inputs_), m_values(values_) {}
+
+  int inputs() const { return m_inputs; }
+  int values() const { return m_values; }
+};
+
+struct my_functor : Functor<double> {
+  my_functor(void) : Functor<double>(3, 15) {}
+  int operator()(const VectorXd &x, VectorXd &fvec) const {
+    double tmp1, tmp2, tmp3;
+    double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
+                    3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
+
+    for (int i = 0; i < values(); i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+      tmp3 = (i >= 8) ? tmp2 : tmp1;
+      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
+    }
+    return 0;
+  }
+
+  int actual_df(const VectorXd &x, MatrixXd &fjac) const {
+    double tmp1, tmp2, tmp3, tmp4;
+    for (int i = 0; i < values(); i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+      tmp3 = (i >= 8) ? tmp2 : tmp1;
+      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
+      tmp4 = tmp4 * tmp4;
+      fjac(i, 0) = -1;
+      fjac(i, 1) = tmp1 * tmp2 / tmp4;
+      fjac(i, 2) = tmp1 * tmp3 / tmp4;
+    }
+    return 0;
+  }
+};
+
+// Scaling by a power of two is exact, so the difference quotients of this map equal the scales
+// iff each divisor is the representable step actually applied to x.
+struct pow2_scaling_functor : Functor<double> {
+  pow2_scaling_functor() : Functor<double>(7, 7), scale(7) { scale << 0.25, 1.0, 8.0, -2.0, 0.5, 4.0, -0.125; }
+  int operator()(const VectorXd &x, VectorXd &fvec) const {
+    fvec = scale.cwiseProduct(x);
+    return 0;
+  }
+  VectorXd scale;
+};
+
+void test_forward() {
+  VectorXd x(3);
+  MatrixXd jac(15, 3);
+  MatrixXd actual_jac(15, 3);
+  my_functor functor;
+
+  x << 0.082, 1.13, 2.35;
+
+  // real one
+  functor.actual_df(x, actual_jac);
+  //    std::cout << actual_jac << std::endl << std::endl;
+
+  // using NumericalDiff
+  NumericalDiff<my_functor> numDiff(functor);
+  numDiff.df(x, jac);
+  //    std::cout << jac << std::endl;
+
+  VERIFY_IS_APPROX(jac, actual_jac);
+}
+
+void test_central() {
+  VectorXd x(3);
+  MatrixXd jac(15, 3);
+  MatrixXd actual_jac(15, 3);
+  my_functor functor;
+
+  x << 0.082, 1.13, 2.35;
+
+  // real one
+  functor.actual_df(x, actual_jac);
+
+  // using NumericalDiff
+  NumericalDiff<my_functor, Central> numDiff(functor);
+  numDiff.df(x, jac);
+
+  VERIFY_IS_APPROX(jac, actual_jac);
+}
+
+void test_small() {
+  VectorXd x(3);
+  MatrixXd jac(15, 3);
+  MatrixXd actual_jac(15, 3);
+  my_functor functor;
+
+  x << 0.082, 1.13, 1e-8;
+
+  // real one
+  functor.actual_df(x, actual_jac);
+
+  // using NumericalDiff
+  NumericalDiff<my_functor, Central> numDiff(functor);
+  numDiff.df(x, jac);
+
+  VERIFY_IS_APPROX(jac, actual_jac);
+}
+
+template <NumericalDiffMode Mode>
+void test_step_alignment(double epsfcn) {
+  pow2_scaling_functor functor;
+  NumericalDiff<pow2_scaling_functor, Mode> numDiff(functor, epsfcn);
+
+  // Non-dyadic coordinates, so that x + h rounds; the first two take the absolute step eps, and the
+  // last two are negative with |x| at or just above a power of two, where x - h is a rounding tie.
+  VectorXd x(7);
+  x << 0.0, 0.082, 1.13, -2350.7, 7.7e8 + 0.3, -1.0 - std::ldexp(1.0, -27), -1.0;
+  MatrixXd jac(7, 7);
+  numDiff.df(x, jac);
+
+  MatrixXd expected = functor.scale.asDiagonal();
+  VERIFY_IS_EQUAL(jac, expected);
+}
+
+EIGEN_DECLARE_TEST(NumericalDiff) {
+  CALL_SUBTEST(test_forward());
+  CALL_SUBTEST(test_central());
+  CALL_SUBTEST(test_small());
+  CALL_SUBTEST(test_step_alignment<Forward>(0.0));
+  CALL_SUBTEST(test_step_alignment<Central>(0.0));
+  // A non-dyadic eps also misaligns the absolute step taken for |x| < 1.
+  CALL_SUBTEST(test_step_alignment<Forward>(1e-10));
+  CALL_SUBTEST(test_step_alignment<Central>(1e-10));
+}
diff --git a/contrib/test/alignedvector3.cpp b/contrib/test/alignedvector3.cpp
new file mode 100644
index 0000000..6f885c3
--- /dev/null
+++ b/contrib/test/alignedvector3.cpp
@@ -0,0 +1,107 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_NO_STATIC_ASSERT
+
+#include "main.h"
+#include <contrib/Eigen/AlignedVector3>
+
+namespace Eigen {
+
+template <typename T, typename Derived>
+T test_relative_error(const AlignedVector3<T> &a, const MatrixBase<Derived> &b) {
+  return test_relative_error(a.coeffs().template head<3>(), b);
+}
+
+}  // namespace Eigen
+
+template <typename Scalar>
+void alignedvector3() {
+  Scalar s1 = internal::random<Scalar>();
+  Scalar s2 = internal::random<Scalar>();
+  typedef Matrix<Scalar, 3, 1> RefType;
+  typedef Matrix<Scalar, 3, 3> Mat33;
+  typedef AlignedVector3<Scalar> FastType;
+  RefType r1(RefType::Random()), r2(RefType::Random()), r3(RefType::Random()), r4(RefType::Random()),
+      r5(RefType::Random());
+  FastType f1(r1), f2(r2), f3(r3), f4(r4), f5(r5);
+  Mat33 m1(Mat33::Random());
+
+  VERIFY_IS_APPROX(f1, r1);
+  VERIFY_IS_APPROX(f4, r4);
+
+  VERIFY_IS_APPROX(f4 + f1, r4 + r1);
+  VERIFY_IS_APPROX(f4 - f1, r4 - r1);
+  VERIFY_IS_APPROX(f4 + f1 - f2, r4 + r1 - r2);
+  VERIFY_IS_APPROX(f4 += f3, r4 += r3);
+  VERIFY_IS_APPROX(f4 -= f5, r4 -= r5);
+  VERIFY_IS_APPROX(f4 -= f5 + f1, r4 -= r5 + r1);
+  VERIFY_IS_APPROX(f5 + f1 - s1 * f2, r5 + r1 - s1 * r2);
+  VERIFY_IS_APPROX(f5 + f1 / s2 - s1 * f2, r5 + r1 / s2 - s1 * r2);
+
+  VERIFY_IS_APPROX(m1 * f4, m1 * r4);
+  VERIFY_IS_APPROX(f4.transpose() * m1, r4.transpose() * m1);
+
+  VERIFY_IS_APPROX(f2.dot(f3), r2.dot(r3));
+  VERIFY_IS_APPROX(f2.cross(f3), r2.cross(r3));
+  VERIFY_IS_APPROX(f2.norm(), r2.norm());
+
+  VERIFY_IS_APPROX(f2.normalized(), r2.normalized());
+
+  VERIFY_IS_APPROX((f2 + f1).normalized(), (r2 + r1).normalized());
+
+  f2.normalize();
+  r2.normalize();
+  VERIFY_IS_APPROX(f2, r2);
+
+  {
+    FastType f6 = RefType::Zero();
+    FastType f7 = FastType::Zero();
+    VERIFY_IS_APPROX(f6, f7);
+    f6 = r4 + r1;
+    VERIFY_IS_APPROX(f6, r4 + r1);
+    f6 -= Scalar(2) * r4;
+    VERIFY_IS_APPROX(f6, r1 - r4);
+  }
+
+  FastType f8, f9(0, 0, 0);
+  VERIFY_IS_APPROX(f9 - f1, -f1);
+
+  {
+    // Compound assignment must return *this by reference so that the result can be
+    // chained or bound to a reference (regression test for !2684).
+    FastType f10(r1);
+    RefType r10(r1);
+    VERIFY_IS_APPROX((f10 += f2) += f3, (r10 += r2) += r3);
+    VERIFY_IS_APPROX(f10, r10);
+    VERIFY_IS_APPROX((f10 -= f2) -= f3, (r10 -= r2) -= r3);
+    VERIFY_IS_APPROX(f10, r10);
+    VERIFY_IS_APPROX((f10 *= s1) *= s2, (r10 *= s1) *= s2);
+    VERIFY_IS_APPROX(f10, r10);
+    VERIFY_IS_APPROX((f10 /= s1) /= s2, (r10 /= s1) /= s2);
+    VERIFY_IS_APPROX(f10, r10);
+    // This file defines EIGEN_NO_STATIC_ASSERT, so check the return types at runtime.
+    VERIFY((std::is_same<decltype(f10 += f2), FastType &>::value));
+    VERIFY((std::is_same<decltype(f10 -= f2), FastType &>::value));
+    VERIFY((std::is_same<decltype(f10 *= s1), FastType &>::value));
+    VERIFY((std::is_same<decltype(f10 /= s1), FastType &>::value));
+  }
+
+  std::stringstream ss1, ss2;
+  ss1 << f1;
+  ss2 << r1;
+  VERIFY(ss1.str() == ss2.str());
+}
+
+EIGEN_DECLARE_TEST(alignedvector3) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST(alignedvector3<float>());
+  }
+}
diff --git a/contrib/test/autodiff.cpp b/contrib/test/autodiff.cpp
new file mode 100644
index 0000000..02ffa2f
--- /dev/null
+++ b/contrib/test/autodiff.cpp
@@ -0,0 +1,392 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/Jacobi>
+#include <contrib/Eigen/AutoDiff>
+
+template <typename Scalar>
+EIGEN_DONT_INLINE Scalar foo(const Scalar& x, const Scalar& y) {
+  using namespace std;
+  //   return x+std::sin(y);
+  EIGEN_ASM_COMMENT("mybegin");
+  // pow(float, int) promotes to pow(double, double)
+  return x * 2 - 1 + static_cast<Scalar>(pow(1 + x, 2)) + 2 * sqrt(y * y + 0) - 4 * sin(0 + x) + 2 * cos(y + 0) -
+         exp(Scalar(-0.5) * x * x + 0);
+  // return x+2*y*x;//x*2 -std::pow(x,2);//(2*y/x);// - y*2;
+  EIGEN_ASM_COMMENT("myend");
+}
+
+template <typename Vector>
+EIGEN_DONT_INLINE typename Vector::Scalar foo(const Vector& p) {
+  typedef typename Vector::Scalar Scalar;
+  return (p - Vector(Scalar(-1), Scalar(1.))).norm() + (p.array() * p.array()).sum() + p.dot(p);
+}
+
+template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
+struct TestFunc1 {
+  typedef Scalar_ Scalar;
+  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
+  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
+
+  int m_inputs, m_values;
+
+  TestFunc1() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
+  TestFunc1(int inputs_, int values_) : m_inputs(inputs_), m_values(values_) {}
+
+  int inputs() const { return InputsAtCompileTime == Dynamic ? m_inputs : InputsAtCompileTime; }
+  int values() const { return ValuesAtCompileTime == Dynamic ? m_values : ValuesAtCompileTime; }
+
+  template <typename T>
+  void operator()(const Matrix<T, InputsAtCompileTime, 1>& x, Matrix<T, ValuesAtCompileTime, 1>* _v) const {
+    Matrix<T, ValuesAtCompileTime, 1>& v = *_v;
+
+    v[0] = 2 * x[0] * x[0] + x[0] * x[1];
+    v[1] = 3 * x[1] * x[0] + 0.5 * x[1] * x[1];
+    if (inputs() > 2) {
+      v[0] += 0.5 * x[2];
+      v[1] += x[2];
+    }
+    if (values() > 2) {
+      v[2] = 3 * x[1] * x[0] * x[0];
+    }
+    if (inputs() > 2 && values() > 2) v[2] *= x[2];
+  }
+
+  void operator()(const InputType& x, ValueType* v, JacobianType* _j) const {
+    (*this)(x, v);
+
+    if (_j) {
+      JacobianType& j = *_j;
+
+      j(0, 0) = 4 * x[0] + x[1];
+      j(1, 0) = 3 * x[1];
+
+      j(0, 1) = x[0];
+      j(1, 1) = 3 * x[0] + 2 * 0.5 * x[1];
+
+      if (inputs() > 2) {
+        j(0, 2) = 0.5;
+        j(1, 2) = 1;
+      }
+      if (values() > 2) {
+        j(2, 0) = 3 * x[1] * 2 * x[0];
+        j(2, 1) = 3 * x[0] * x[0];
+      }
+      if (inputs() > 2 && values() > 2) {
+        j(2, 0) *= x[2];
+        j(2, 1) *= x[2];
+
+        j(2, 2) = 3 * x[1] * x[0] * x[0];
+      }
+    }
+  }
+};
+
+template <typename Scalar>
+struct integratorFunctor {
+  typedef Matrix<Scalar, 2, 1> InputType;
+  typedef Matrix<Scalar, 2, 1> ValueType;
+
+  /*
+   * Implementation starts here.
+   */
+  integratorFunctor(const Scalar gain) : _gain(gain) {}
+  integratorFunctor(const integratorFunctor& f) : _gain(f._gain) {}
+  const Scalar _gain;
+
+  template <typename T1, typename T2>
+  void operator()(const T1& input, T2* output, const Scalar dt) const {
+    T2& o = *output;
+
+    /* Integrator to test the AD. */
+    o[0] = input[0] + input[1] * dt * _gain;
+    o[1] = input[1] * _gain;
+  }
+
+  /* Only needed for the test */
+  template <typename T1, typename T2, typename T3>
+  void operator()(const T1& input, T2* output, T3* jacobian, const Scalar dt) const {
+    T2& o = *output;
+
+    /* Integrator to test the AD. */
+    o[0] = input[0] + input[1] * dt * _gain;
+    o[1] = input[1] * _gain;
+
+    if (jacobian) {
+      T3& j = *jacobian;
+
+      j(0, 0) = 1;
+      j(0, 1) = dt * _gain;
+      j(1, 0) = 0;
+      j(1, 1) = _gain;
+    }
+  }
+};
+
+template <typename Func>
+void forward_jacobian_with_scalar_arg(const Func& f) {
+  typedef typename Func::ValueType::Scalar Scalar;
+  typedef typename Func::ValueType ValueType;
+  typedef typename Func::InputType InputType;
+  typedef typename AutoDiffJacobian<Func>::JacobianType JacobianType;
+
+  InputType x = InputType::Random(InputType::RowsAtCompileTime);
+  ValueType y, yref;
+  JacobianType j, jref;
+
+  const Scalar dt = internal::random<double>();
+
+  jref.setZero();
+  yref.setZero();
+  f(x, &yref, &jref, dt);
+
+  // std::cerr << "y, yref, jref: " << "\n";
+  // std::cerr << y.transpose() << "\n\n";
+  // std::cerr << yref << "\n\n";
+  // std::cerr << jref << "\n\n";
+
+  AutoDiffJacobian<Func> autoj(f);
+  autoj(x, &y, &j, dt);
+
+  // std::cerr << "y j (via autodiff): " << "\n";
+  // std::cerr << y.transpose() << "\n\n";
+  // std::cerr << j << "\n\n";
+
+  VERIFY_IS_APPROX(y, yref);
+  VERIFY_IS_APPROX(j, jref);
+}
+
+template <typename Func>
+void forward_jacobian(const Func& f) {
+  typename Func::InputType x = Func::InputType::Random(f.inputs());
+  typename Func::ValueType y(f.values()), yref(f.values());
+  typename Func::JacobianType j(f.values(), f.inputs()), jref(f.values(), f.inputs());
+
+  jref.setZero();
+  yref.setZero();
+  f(x, &yref, &jref);
+
+  j.setZero();
+  y.setZero();
+  AutoDiffJacobian<Func> autoj(f);
+  autoj(x, &y, &j);
+
+  VERIFY_IS_APPROX(y, yref);
+  VERIFY_IS_APPROX(j, jref);
+}
+
+// TODO also check actual derivatives!
+template <int>
+void test_autodiff_scalar() {
+  Vector2f p = Vector2f::Random();
+  typedef AutoDiffScalar<Vector2f> AD;
+  AD ax(p.x(), Vector2f::UnitX());
+  AD ay(p.y(), Vector2f::UnitY());
+  AD res = foo<AD>(ax, ay);
+  VERIFY_IS_APPROX(res.value(), foo(p.x(), p.y()));
+}
+
+// TODO also check actual derivatives!
+template <int>
+void test_autodiff_vector() {
+  Vector2f p = Vector2f::Random();
+  typedef AutoDiffScalar<Vector2f> AD;
+  typedef Matrix<AD, 2, 1> VectorAD;
+  VectorAD ap = p.cast<AD>();
+  ap.x().derivatives() = Vector2f::UnitX();
+  ap.y().derivatives() = Vector2f::UnitY();
+
+  AD res = foo<VectorAD>(ap);
+  VERIFY_IS_APPROX(res.value(), foo(p));
+}
+
+template <int>
+void test_autodiff_jacobian() {
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 2, 2>())));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 2, 3>())));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 3, 2>())));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 3, 3>())));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double>(2, 2))));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double>(2, 3))));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double>(3, 2))));
+  CALL_SUBTEST((forward_jacobian(TestFunc1<double>(3, 3))));
+  CALL_SUBTEST((forward_jacobian_with_scalar_arg(integratorFunctor<double>(10))));
+}
+
+template <int>
+void test_autodiff_hessian() {
+  typedef AutoDiffScalar<VectorXd> AD;
+  typedef Matrix<AD, Eigen::Dynamic, 1> VectorAD;
+  typedef AutoDiffScalar<VectorAD> ADD;
+  typedef Matrix<ADD, Eigen::Dynamic, 1> VectorADD;
+  VectorADD x(2);
+  double s1 = internal::random<double>(), s2 = internal::random<double>(), s3 = internal::random<double>(),
+         s4 = internal::random<double>();
+  x(0).value() = s1;
+  x(1).value() = s2;
+
+  // set unit vectors for the derivative directions (partial derivatives of the input vector)
+  x(0).derivatives().resize(2);
+  x(0).derivatives().setZero();
+  x(0).derivatives()(0) = 1;
+  x(1).derivatives().resize(2);
+  x(1).derivatives().setZero();
+  x(1).derivatives()(1) = 1;
+
+  // repeat partial derivatives for the inner AutoDiffScalar
+  x(0).value().derivatives() = VectorXd::Unit(2, 0);
+  x(1).value().derivatives() = VectorXd::Unit(2, 1);
+
+  // set the hessian matrix to zero
+  for (int idx = 0; idx < 2; idx++) {
+    x(0).derivatives()(idx).derivatives() = VectorXd::Zero(2);
+    x(1).derivatives()(idx).derivatives() = VectorXd::Zero(2);
+  }
+
+  ADD y = sin(AD(s3) * x(0) + AD(s4) * x(1));
+
+  VERIFY_IS_APPROX(y.value().derivatives()(0), y.derivatives()(0).value());
+  VERIFY_IS_APPROX(y.value().derivatives()(1), y.derivatives()(1).value());
+  VERIFY_IS_APPROX(y.value().derivatives()(0), s3 * std::cos(s1 * s3 + s2 * s4));
+  VERIFY_IS_APPROX(y.value().derivatives()(1), s4 * std::cos(s1 * s3 + s2 * s4));
+  VERIFY_IS_APPROX(y.derivatives()(0).derivatives(), -std::sin(s1 * s3 + s2 * s4) * Vector2d(s3 * s3, s4 * s3));
+  VERIFY_IS_APPROX(y.derivatives()(1).derivatives(), -std::sin(s1 * s3 + s2 * s4) * Vector2d(s3 * s4, s4 * s4));
+
+  ADD z = x(0) * x(1);
+  VERIFY_IS_APPROX(z.derivatives()(0).derivatives(), Vector2d(0, 1));
+  VERIFY_IS_APPROX(z.derivatives()(1).derivatives(), Vector2d(1, 0));
+}
+
+double bug_1222() {
+  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;
+  const double _cv1_3 = 1.0;
+  const AD chi_3 = 1.0;
+  // this line did not work, because operator+ returns ADS<DerType&>, which then cannot be converted to ADS<DerType>
+  const AD denom = chi_3 + _cv1_3;
+  return denom.value();
+}
+
+double bug_1223() {
+  using std::min;
+  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;
+
+  const double _cv1_3 = 1.0;
+  const AD chi_3 = 1.0;
+  const AD denom = 1.0;
+
+// failed because implementation of min attempts to construct ADS<DerType&> via constructor AutoDiffScalar(const Real&
+// value) without initializing m_derivatives (which is a reference in this case)
+#define EIGEN_TEST_SPACE
+  const AD t = min EIGEN_TEST_SPACE(denom / chi_3, 1.0);
+
+  const AD t2 = min EIGEN_TEST_SPACE(denom / (chi_3 * _cv1_3), 1.0);
+
+  return t.value() + t2.value();
+}
+
+// regression test for some compilation issues with specializations of ScalarBinaryOpTraits
+void bug_1260() {
+  Matrix4d A = Matrix4d::Ones();
+  Vector4d v = Vector4d::Ones();
+  A* v;
+}
+
+// check a compilation issue with numext::max
+double bug_1261() {
+  typedef AutoDiffScalar<Matrix2d> AD;
+  typedef Matrix<AD, 2, 1> VectorAD;
+
+  VectorAD v(0., 0.);
+  const AD maxVal = v.maxCoeff();
+  const AD minVal = v.minCoeff();
+  return maxVal.value() + minVal.value();
+}
+
+double bug_1264() {
+  typedef AutoDiffScalar<Vector2d> AD;
+  const AD s = 0.;
+  const Matrix<AD, 3, 1> v1(0., 0., 0.);
+  const Matrix<AD, 3, 1> v2 = (s + 3.0) * v1;
+  return v2(0).value();
+}
+
+// check with expressions on constants
+double bug_1281() {
+  int n = 2;
+  typedef AutoDiffScalar<VectorXd> AD;
+  const AD c = 1.;
+  AD x0(2, n, 0);
+  AD y1 = (AD(c) + AD(c)) * x0;
+  y1 = x0 * (AD(c) + AD(c));
+  AD y2 = (-AD(c)) + x0;
+  y2 = x0 + (-AD(c));
+  AD y3 = (AD(c) * (-AD(c)) + AD(c)) * x0;
+  y3 = x0 * (AD(c) * (-AD(c)) + AD(c));
+  return (y1 + y2 + y3).value();
+}
+
+// LLT stores the 1-norm of its input for rcond(); the sum of AutoDiffScalars is an expression, so
+// the norm must materialize its column totals before comparing them.
+void test_autodiff_selfadjoint_l1norm() {
+  typedef AutoDiffScalar<Vector2d> AD;
+  Matrix<AD, 8, 8> m = Matrix<AD, 8, 8>::Identity();
+  m(3, 3) = AD(2, Vector2d(1, 0));
+  AD norm = m.selfadjointView<Lower>().l1Norm();
+  VERIFY_IS_EQUAL(norm.value(), 2.0);
+  VERIFY_IS_EQUAL(norm.derivatives()(0), 1.0);
+  LLT<Matrix<AD, 8, 8>> llt(m);
+  VERIFY(llt.info() == Success);
+}
+
+template <typename Derivatives>
+void test_autodiff_makegivens() {
+  using AD = AutoDiffScalar<Derivatives>;
+  // Exercise both ratio branches and compare analytical first derivatives.
+  for (int swap = 0; swap < 2; ++swap) {
+    const double x = swap ? 4.0 : 3.0;
+    const double y = swap ? 3.0 : 4.0;
+    const AD p(x, Derivatives(Vector2d::UnitX()));
+    const AD q(y, Derivatives(Vector2d::UnitY()));
+    AD r;
+    JacobiRotation<AD> rotation;
+    rotation.makeGivens(p, q, &r);
+    VERIFY_IS_APPROX(rotation.c().value(), x / 5.0);
+    VERIFY_IS_APPROX(rotation.s().value(), -y / 5.0);
+    VERIFY_IS_APPROX(r.value(), 5.0);
+    VERIFY_IS_APPROX(r.derivatives(), Vector2d(x / 5.0, y / 5.0));
+    VERIFY_IS_APPROX(rotation.c().derivatives(), Vector2d(y * y / 125.0, -x * y / 125.0));
+    VERIFY_IS_APPROX(rotation.s().derivatives(), Vector2d(x * y / 125.0, -x * x / 125.0));
+    JacobiRotation<AD> without_norm;
+    without_norm.makeGivens(p, q);
+    VERIFY_IS_APPROX(without_norm.c().derivatives(), rotation.c().derivatives());
+    VERIFY_IS_APPROX(without_norm.s().derivatives(), rotation.s().derivatives());
+  }
+}
+
+EIGEN_DECLARE_TEST(autodiff) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(test_autodiff_scalar<1>());
+    CALL_SUBTEST_2(test_autodiff_vector<1>());
+    CALL_SUBTEST_3(test_autodiff_jacobian<1>());
+    CALL_SUBTEST_4(test_autodiff_hessian<1>());
+  }
+
+  CALL_SUBTEST_5(bug_1222());
+  CALL_SUBTEST_5(bug_1223());
+  CALL_SUBTEST_5(bug_1260());
+  CALL_SUBTEST_5(bug_1261());
+  CALL_SUBTEST_5(bug_1281());
+  CALL_SUBTEST_5(test_autodiff_selfadjoint_l1norm());
+  CALL_SUBTEST_6(test_autodiff_makegivens<Vector2d>());
+  CALL_SUBTEST_6(test_autodiff_makegivens<VectorXd>());
+}
diff --git a/contrib/test/autodiff_scalar.cpp b/contrib/test/autodiff_scalar.cpp
new file mode 100644
index 0000000..b9fe84f
--- /dev/null
+++ b/contrib/test/autodiff_scalar.cpp
@@ -0,0 +1,120 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christoph Hertzberg <chtz@informatik.uni-bremen.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <contrib/Eigen/AutoDiff>
+
+/*
+ * In this file scalar derivations are tested for correctness.
+ * TODO add more tests!
+ */
+
+template <typename Scalar>
+void check_atan2() {
+  typedef Matrix<Scalar, 1, 1> Deriv1;
+  typedef AutoDiffScalar<Deriv1> AD;
+
+  AD x(internal::random<Scalar>(-3.0, 3.0), Deriv1::UnitX());
+
+  using std::exp;
+  Scalar r = exp(internal::random<Scalar>(-10, 10));
+
+  AD s = sin(x), c = cos(x);
+  AD res = atan2(r * s, r * c);
+
+  VERIFY_IS_APPROX(res.value(), x.value());
+  VERIFY_IS_APPROX(res.derivatives(), x.derivatives());
+
+  res = atan2(r * s + 0, r * c + 0);
+  VERIFY_IS_APPROX(res.value(), x.value());
+  VERIFY_IS_APPROX(res.derivatives(), x.derivatives());
+}
+
+template <typename Scalar>
+void check_hyperbolic_functions() {
+  using std::cosh;
+  using std::sinh;
+  using std::tanh;
+  typedef Matrix<Scalar, 1, 1> Deriv1;
+  typedef AutoDiffScalar<Deriv1> AD;
+  Deriv1 p = Deriv1::Random();
+  AD val(p.x(), Deriv1::UnitX());
+
+  Scalar cosh_px = std::cosh(p.x());
+  AD res1 = tanh(val);
+  VERIFY_IS_APPROX(res1.value(), std::tanh(p.x()));
+  VERIFY_IS_APPROX(res1.derivatives().x(), Scalar(1.0) / (cosh_px * cosh_px));
+
+  AD res2 = sinh(val);
+  VERIFY_IS_APPROX(res2.value(), std::sinh(p.x()));
+  VERIFY_IS_APPROX(res2.derivatives().x(), cosh_px);
+
+  AD res3 = cosh(val);
+  VERIFY_IS_APPROX(res3.value(), cosh_px);
+  VERIFY_IS_APPROX(res3.derivatives().x(), std::sinh(p.x()));
+
+  // Check constant values.
+  const Scalar sample_point = Scalar(1) / Scalar(3);
+  val = AD(sample_point, Deriv1::UnitX());
+  res1 = tanh(val);
+  VERIFY_IS_APPROX(res1.derivatives().x(), Scalar(0.896629559604914));
+
+  res2 = sinh(val);
+  VERIFY_IS_APPROX(res2.derivatives().x(), Scalar(1.056071867829939));
+
+  res3 = cosh(val);
+  VERIFY_IS_APPROX(res3.derivatives().x(), Scalar(0.339540557256150));
+}
+
+template <typename Scalar>
+void check_limits_specialization() {
+  typedef Eigen::Matrix<Scalar, 1, 1> Deriv;
+  typedef Eigen::AutoDiffScalar<Deriv> AD;
+
+  typedef std::numeric_limits<AD> A;
+  typedef std::numeric_limits<Scalar> B;
+
+  // workaround "unused typedef" warning:
+  VERIFY(!bool(std::is_same<B, A>::value));
+
+  VERIFY(bool(std::is_base_of<B, A>::value));
+}
+
+// Regression for issue #1870: min(ADS, ADS) and max(ADS, ADS) must agree on
+// which argument wins on a tie.  Previously min returned the second argument
+// while max returned the first, so the two could yield different derivatives
+// for inputs with equal values but different derivative vectors.
+template <typename Scalar>
+void check_min_max_equal_values() {
+  typedef Eigen::Matrix<Scalar, 2, 1> Deriv2;
+  typedef Eigen::AutoDiffScalar<Deriv2> AD;
+
+  AD a(Scalar(1), Deriv2(Scalar(1), Scalar(0)));
+  AD b(Scalar(1), Deriv2(Scalar(0), Scalar(1)));
+
+  // Parenthesized form avoids the min/max macros installed by test/main.h
+  // and lets ADL pick up the AutoDiffScalar overloads.
+  VERIFY_IS_EQUAL((min)(a, b).derivatives(), a.derivatives());
+  VERIFY_IS_EQUAL((max)(a, b).derivatives(), a.derivatives());
+  VERIFY_IS_EQUAL((min)(b, a).derivatives(), b.derivatives());
+  VERIFY_IS_EQUAL((max)(b, a).derivatives(), b.derivatives());
+}
+
+EIGEN_DECLARE_TEST(autodiff_scalar) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(check_atan2<float>());
+    CALL_SUBTEST_2(check_atan2<double>());
+    CALL_SUBTEST_3(check_hyperbolic_functions<float>());
+    CALL_SUBTEST_4(check_hyperbolic_functions<double>());
+    CALL_SUBTEST_5(check_limits_specialization<double>());
+    CALL_SUBTEST_6(check_min_max_equal_values<float>());
+    CALL_SUBTEST_7(check_min_max_equal_values<double>());
+  }
+}
diff --git a/contrib/test/bessel_functions.cpp b/contrib/test/bessel_functions.cpp
new file mode 100644
index 0000000..9202973
--- /dev/null
+++ b/contrib/test/bessel_functions.cpp
@@ -0,0 +1,303 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "../Eigen/SpecialFunctions"
+
+template <typename X, typename Y>
+void verify_component_wise(const X& x, const Y& y) {
+  for (Index i = 0; i < x.size(); ++i) {
+    if ((numext::isfinite)(y(i))) {
+      VERIFY_IS_APPROX(x(i), y(i));
+    } else if ((numext::isnan)(y(i)))
+      VERIFY((numext::isnan)(x(i)));
+    else
+      VERIFY_IS_EQUAL(x(i), y(i));
+  }
+}
+
+template <typename ArrayType>
+void array_bessel_functions() {
+  // Test Bessel function i0. Reference results obtained with SciPy.
+  {
+    ArrayType x(21);
+    ArrayType expected(21);
+    ArrayType res(21);
+
+    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
+        16.0, 18.0, 20.0;
+
+    expected << 4.35582826e+07, 6.21841242e+06, 8.93446228e+05, 1.29418563e+05, 1.89489253e+04, 2.81571663e+03,
+        4.27564116e+02, 6.72344070e+01, 1.13019220e+01, 2.27958530e+00, 1.00000000e+00, 2.27958530e+00, 1.13019220e+01,
+        6.72344070e+01, 4.27564116e+02, 2.81571663e+03, 1.89489253e+04, 1.29418563e+05, 8.93446228e+05, 6.21841242e+06,
+        4.35582826e+07;
+
+    CALL_SUBTEST(res = bessel_i0(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function i0e. Reference results obtained with SciPy.
+  {
+    ArrayType x(21);
+    ArrayType expected(21);
+    ArrayType res(21);
+
+    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
+        16.0, 18.0, 20.0;
+
+    expected << 0.0897803118848, 0.0947062952128, 0.100544127361, 0.107615251671, 0.116426221213, 0.127833337163,
+        0.143431781857, 0.16665743264, 0.207001921224, 0.308508322554, 1.0, 0.308508322554, 0.207001921224,
+        0.16665743264, 0.143431781857, 0.127833337163, 0.116426221213, 0.107615251671, 0.100544127361, 0.0947062952128,
+        0.0897803118848;
+
+    CALL_SUBTEST(res = bessel_i0e(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function i1. Reference results obtained with SciPy.
+  {
+    ArrayType x(21);
+    ArrayType expected(21);
+    ArrayType res(21);
+
+    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
+        16.0, 18.0, 20.0;
+
+    expected << -4.24549734e+07, -6.04313324e+06, -8.65059436e+05, -1.24707259e+05, -1.81413488e+04, -2.67098830e+03,
+        -3.99873137e+02, -6.13419368e+01, -9.75946515e+00, -1.59063685e+00, 0.00000000e+00, 1.59063685e+00,
+        9.75946515e+00, 6.13419368e+01, 3.99873137e+02, 2.67098830e+03, 1.81413488e+04, 1.24707259e+05, 8.65059436e+05,
+        6.04313324e+06, 4.24549734e+07;
+
+    CALL_SUBTEST(res = bessel_i1(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function i1e. Reference results obtained with SciPy.
+  {
+    ArrayType x(21);
+    ArrayType expected(21);
+    ArrayType res(21);
+
+    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
+        16.0, 18.0, 20.0;
+
+    expected << -0.0875062221833, -0.092036796872, -0.0973496147565, -0.103697667463, -0.11146429929, -0.121262681384,
+        -0.134142493293, -0.152051459309, -0.178750839502, -0.215269289249, 0.0, 0.215269289249, 0.178750839502,
+        0.152051459309, 0.134142493293, 0.121262681384, 0.11146429929, 0.103697667463, 0.0973496147565, 0.092036796872,
+        0.0875062221833;
+
+    CALL_SUBTEST(res = bessel_i1e(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function j0. Reference results obtained with SciPy.
+  {
+    ArrayType x(77);
+    ArrayType expected(77);
+    ArrayType res(77);
+
+    x << -38., -37., -36., -35., -34., -33., -32., -31., -30., -29., -28., -27., -26., -25., -24., -23., -22., -21.,
+        -20., -19., -18., -17., -16., -15., -14., -13., -12., -11., -10., -9., -8., -7., -6., -5., -4., -3., -2., -1.,
+        0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23.,
+        24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38.;
+
+    expected << 0.11433274, 0.01086237, -0.10556738, -0.12684568, -0.03042119, 0.09727067, 0.13807901, 0.05120815,
+        -0.08636798, -0.14784876, -0.07315701, 0.07274192, 0.15599932, 0.09626678, -0.05623027, -0.16241278,
+        -0.12065148, 0.03657907, 0.16702466, 0.14662944, -0.01335581, -0.16985425, -0.17489907, -0.01422447, 0.17107348,
+        0.2069261, 0.04768931, -0.1711903, -0.24593576, -0.09033361, 0.17165081, 0.30007927, 0.15064526, -0.17759677,
+        -0.39714981, -0.26005195, 0.22389078, 0.76519769, 1., 0.76519769, 0.22389078, -0.26005195, -0.39714981,
+        -0.17759677, 0.15064526, 0.30007927, 0.17165081, -0.09033361, -0.24593576, -0.1711903, 0.04768931, 0.2069261,
+        0.17107348, -0.01422447, -0.17489907, -0.16985425, -0.01335581, 0.14662944, 0.16702466, 0.03657907, -0.12065148,
+        -0.16241278, -0.05623027, 0.09626678, 0.15599932, 0.07274192, -0.07315701, -0.14784876, -0.08636798, 0.05120815,
+        0.13807901, 0.09727067, -0.03042119, -0.12684568, -0.10556738, 0.01086237, 0.11433274;
+
+    CALL_SUBTEST(res = bessel_j0(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function j1. Reference results obtained with SciPy.
+  {
+    ArrayType x(81);
+    ArrayType expected(81);
+    ArrayType res(81);
+
+    x << -40., -39., -38., -37., -36., -35., -34., -33., -32., -31., -30., -29., -28., -27., -26., -25., -24., -23.,
+        -22., -21., -20., -19., -18., -17., -16., -15., -14., -13., -12., -11., -10., -9., -8., -7., -6., -5., -4., -3.,
+        -2., -1., 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21.,
+        22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << -0.12603832, -0.0640561, 0.05916189, 0.13058004, 0.08232981, -0.04399094, -0.13297118, -0.10061965,
+        0.02658903, 0.13302432, 0.11875106, -0.0069342, -0.13055149, -0.13658472, -0.01504573, 0.12535025, 0.15403807,
+        0.03951932, -0.11717779, -0.17112027, -0.06683312, 0.10570143, 0.18799489, 0.09766849, -0.09039718, -0.20510404,
+        -0.13337515, 0.07031805, 0.2234471, 0.1767853, -0.04347275, -0.24531179, -0.23463635, 0.00468282, 0.27668386,
+        0.32757914, 0.06604333, -0.33905896, -0.57672481, -0.44005059, 0., 0.44005059, 0.57672481, 0.33905896,
+        -0.06604333, -0.32757914, -0.27668386, -0.00468282, 0.23463635, 0.24531179, 0.04347275, -0.1767853, -0.2234471,
+        -0.07031805, 0.13337515, 0.20510404, 0.09039718, -0.09766849, -0.18799489, -0.10570143, 0.06683312, 0.17112027,
+        0.11717779, -0.03951932, -0.15403807, -0.12535025, 0.01504573, 0.13658472, 0.13055149, 0.0069342, -0.11875106,
+        -0.13302432, -0.02658903, 0.10061965, 0.13297118, 0.04399094, -0.08232981, -0.13058004, -0.05916189, 0.0640561,
+        0.12603832;
+
+    CALL_SUBTEST(res = bessel_j1(x); verify_component_wise(res, expected););
+  }
+  // Test Bessel function k0e. Reference results obtained with SciPy.
+  {
+    ArrayType x(42);
+    ArrayType expected(42);
+    ArrayType res(42);
+
+    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
+        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << 1.97933385, 1.52410939, 1.14446308, 0.84156822, 0.6977616, 0.60929767, 0.54780756, 0.50186313,
+        0.4658451, 0.43662302, 0.41229555, 0.39163193, 0.3737955, 0.35819488, 0.34439865, 0.33208364, 0.32100235,
+        0.31096159, 0.30180802, 0.29341821, 0.28569149, 0.27854488, 0.2719092, 0.26572635, 0.25994703, 0.25452917,
+        0.2494366, 0.24463801, 0.24010616, 0.23581722, 0.23175022, 0.22788667, 0.22421014, 0.22070602, 0.21736123,
+        0.21416406, 0.21110397, 0.20817141, 0.20535778, 0.20265524, 0.20005668, 0.19755558;
+
+    CALL_SUBTEST(res = bessel_k0e(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function k0. Reference results obtained with SciPy.
+  {
+    ArrayType x(42);
+    ArrayType expected(42);
+    ArrayType res(42);
+
+    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
+        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << 1.54150675, 0.92441907, 4.21024438e-01, 1.13893873e-01, 3.47395044e-02, 1.11596761e-02, 3.69109833e-03,
+        1.24399433e-03, 4.24795742e-04, 1.46470705e-04, 5.08813130e-05, 1.77800623e-05, 6.24302055e-06, 2.20082540e-06,
+        7.78454386e-07, 2.76137082e-07, 9.81953648e-08, 3.49941166e-08, 1.24946640e-08, 4.46875334e-09, 1.60067129e-09,
+        5.74123782e-10, 2.06176797e-10, 7.41235161e-11, 2.66754511e-11, 9.60881878e-12, 3.46416156e-12, 1.24987740e-12,
+        4.51286453e-13, 1.63053459e-13, 5.89495073e-14, 2.13247750e-14, 7.71838266e-15, 2.79505752e-15, 1.01266123e-15,
+        3.67057597e-16, 1.33103515e-16, 4.82858338e-17, 1.75232770e-17, 6.36161716e-18, 2.31029936e-18, 8.39286110e-19;
+
+    CALL_SUBTEST(res = bessel_k0(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function k1. Reference results obtained with SciPy.
+  {
+    ArrayType x(42);
+    ArrayType expected(42);
+    ArrayType res(42);
+
+    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
+        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << 3.74702597, 1.65644112, 6.01907230e-01, 1.39865882e-01, 4.01564311e-02, 1.24834989e-02, 4.04461345e-03,
+        1.34391972e-03, 4.54182487e-04, 1.55369212e-04, 5.36370164e-05, 1.86487735e-05, 6.52086067e-06, 2.29075746e-06,
+        8.07858841e-07, 2.85834365e-07, 1.01417294e-07, 3.60715712e-08, 1.28570417e-08, 4.59124963e-09, 1.64226697e-09,
+        5.88305797e-10, 2.11029922e-10, 7.57898116e-11, 2.72493059e-11, 9.80699893e-12, 3.53277807e-12, 1.27369078e-12,
+        4.59568940e-13, 1.65940011e-13, 5.99574032e-14, 2.16773200e-14, 7.84189960e-15, 2.83839927e-15, 1.02789171e-15,
+        3.72416929e-16, 1.34991783e-16, 4.89519373e-17, 1.77585196e-17, 6.44478588e-18, 2.33973340e-18, 8.49713195e-19;
+
+    CALL_SUBTEST(res = bessel_k1(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function k1e. Reference results obtained with SciPy.
+  {
+    ArrayType x(42);
+    ArrayType expected(42);
+    ArrayType res(42);
+
+    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
+        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << 4.81127659, 2.73100971, 1.63615349, 1.03347685, 0.80656348, 0.68157595, 0.60027386, 0.54217591,
+        0.49807158, 0.46314909, 0.43462525, 0.41076657, 0.39043094, 0.37283175, 0.35740757, 0.34374563, 0.33153489,
+        0.32053597, 0.31056123, 0.30146131, 0.29311559, 0.2854255, 0.27830958, 0.27169987, 0.26553913, 0.25977879,
+        0.25437733, 0.249299, 0.24451285, 0.23999191, 0.2357126, 0.23165413, 0.22779816, 0.22412841, 0.22063036,
+        0.21729103, 0.21409878, 0.21104314, 0.20811462, 0.20530466, 0.20260547, 0.20000997;
+
+    CALL_SUBTEST(res = bessel_k1e(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function y0. Reference results obtained with SciPy.
+  {
+    ArrayType x(42);
+    ArrayType expected(42);
+    ArrayType res(42);
+
+    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
+        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << -0.93157302, -0.44451873, 0.08825696, 0.51037567, 0.37685001, -0.01694074, -0.30851763, -0.28819468,
+        -0.02594974, 0.22352149, 0.2499367, 0.05567117, -0.16884732, -0.22523731, -0.07820786, 0.12719257, 0.2054643,
+        0.095811, -0.0926372, -0.18755216, -0.10951969, 0.0626406, 0.17020176, 0.1198876, -0.03598179, -0.15283403,
+        -0.12724943, 0.01204463, 0.13521498, 0.13183647, 0.00948116, -0.11729573, -0.13383266, -0.02874248, 0.09913483,
+        0.13340405, 0.04579799, -0.08085609, -0.13071488, -0.06066076, 0.06262353, 0.12593642;
+
+    CALL_SUBTEST(res = bessel_y0(x); verify_component_wise(res, expected););
+  }
+
+  // Test Bessel function y1. Reference results obtained with SciPy.
+  {
+    ArrayType x(42);
+    ArrayType expected(42);
+    ArrayType res(42);
+
+    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
+        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
+
+    expected << -2.70410523, -1.47147239, -0.78121282, -0.10703243, 0.32467442, 0.39792571, 0.14786314, -0.17501034,
+        -0.30266724, -0.15806046, 0.10431458, 0.24901542, 0.16370554, -0.05709922, -0.21008141, -0.16664484, 0.02107363,
+        0.17797517, 0.16720504, 0.00815513, -0.14956011, -0.16551161, -0.03253926, 0.12340586, 0.1616692, 0.05305978,
+        -0.09882996, -0.15579655, -0.07025124, 0.07552213, 0.14803412, 0.08442557, -0.05337283, -0.13854483,
+        -0.09578012, 0.03238588, 0.12751273, 0.10445477, -0.01262946, -0.11514066, -0.11056411, -0.00579351;
+
+    CALL_SUBTEST(res = bessel_y1(x); verify_component_wise(res, expected););
+  }
+}
+
+// exp(|x|) overflows above |x| ~ 88.7228 (float) / ~709.7827 (double), while i0/i1 stay finite up to
+// |x| ~ 91.9008 / ~713.9869, so these arguments exercise the intermediate-overflow path.
+// Reference values computed with mpmath at 40 digits.
+template <typename ArrayType>
+void test_bessel_i_large_finite(const typename ArrayType::Scalar (&x_val)[2],
+                                const typename ArrayType::Scalar (&i0_truth)[2],
+                                const typename ArrayType::Scalar (&i1_truth)[2]) {
+  ArrayType x(4);
+  x << x_val[0], -x_val[0], x_val[1], -x_val[1];
+  ArrayType i0_res = bessel_i0(x);
+  ArrayType i1_res = bessel_i1(x);
+  for (Index i = 0; i < x.size(); ++i) {
+    VERIFY((numext::isfinite)(i0_res(i)));
+    VERIFY((numext::isfinite)(i1_res(i)));
+    // The vectorized and scalar paths must agree.
+    VERIFY_IS_APPROX(numext::bessel_i0(x(i)), i0_res(i));
+    VERIFY_IS_APPROX(numext::bessel_i1(x(i)), i1_res(i));
+  }
+  // i0 is even, i1 is odd.
+  VERIFY_IS_APPROX(i0_res(0), i0_truth[0]);
+  VERIFY_IS_APPROX(i0_res(1), i0_truth[0]);
+  VERIFY_IS_APPROX(i0_res(2), i0_truth[1]);
+  VERIFY_IS_APPROX(i0_res(3), i0_truth[1]);
+  VERIFY_IS_APPROX(i1_res(0), i1_truth[0]);
+  VERIFY_IS_APPROX(i1_res(1), -i1_truth[0]);
+  VERIFY_IS_APPROX(i1_res(2), i1_truth[1]);
+  VERIFY_IS_APPROX(i1_res(3), -i1_truth[1]);
+}
+
+void test_bessel_i_large_finite_float() {
+  const float x[2] = {90.0f, 91.0f};
+  const float i0_truth[2] = {5.1392383455086638e+37f, 1.3892714060989622e+38f};
+  const float i1_truth[2] = {5.1106068152565982e+37f, 1.3816168414593216e+38f};
+  test_bessel_i_large_finite<ArrayXf>(x, i0_truth, i1_truth);
+}
+
+void test_bessel_i_large_finite_double() {
+  const double x[2] = {712.0, 713.0};
+  const double i0_truth[2] = {2.4684110577627524e+307, 6.7051282636709964e+307};
+  const double i1_truth[2] = {2.4666770135246152e+307, 6.7004245591864022e+307};
+  test_bessel_i_large_finite<ArrayXd>(x, i0_truth, i1_truth);
+}
+
+EIGEN_DECLARE_TEST(bessel_functions) {
+  CALL_SUBTEST_1(array_bessel_functions<ArrayXf>());
+  CALL_SUBTEST_1(test_bessel_i_large_finite_float());
+  CALL_SUBTEST_2(array_bessel_functions<ArrayXd>());
+  CALL_SUBTEST_2(test_bessel_i_large_finite_double());
+}
diff --git a/contrib/test/duccfft.cpp b/contrib/test/duccfft.cpp
new file mode 100644
index 0000000..2bcf077
--- /dev/null
+++ b/contrib/test/duccfft.cpp
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_DUCCFFT_DEFAULT 1
+#include <ducc0/fft/fft.h>         // Needs to be included before main.h
+#include <ducc0/fft/fftnd_impl.h>  // Same requirement
+#include "fft_test_shared.h"
diff --git a/contrib/test/fft_test_shared.h b/contrib/test/fft_test_shared.h
new file mode 100644
index 0000000..12e8044
--- /dev/null
+++ b/contrib/test/fft_test_shared.h
@@ -0,0 +1,690 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Mark Borgerding mark a borgerding net
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_UNSUPPORTED_TEST_FFT_TEST_SHARED_H
+#define EIGEN_UNSUPPORTED_TEST_FFT_TEST_SHARED_H
+
+// Enable runtime malloc tracking so test_inplace_complex<>() can assert the
+// in-place scratch comes from the stack.  Allocation defaults to allowed; the
+// tracking only fires inside explicit set_is_malloc_allowed(false) windows.
+#define EIGEN_RUNTIME_NO_MALLOC
+
+#include "main.h"
+
+#include <thread>
+#include <contrib/Eigen/FFT>
+
+template <typename T>
+inline std::complex<T> RandomCpx() {
+  return std::complex<T>((T)(rand() / (T)RAND_MAX - .5), (T)(rand() / (T)RAND_MAX - .5));
+}
+
+using namespace std;
+using namespace Eigen;
+
+template <typename T>
+inline complex<long double> promote(complex<T> x) {
+  return complex<long double>((long double)x.real(), (long double)x.imag());
+}
+
+inline complex<long double> promote(float x) { return complex<long double>((long double)x); }
+inline complex<long double> promote(double x) { return complex<long double>((long double)x); }
+inline complex<long double> promote(long double x) { return complex<long double>((long double)x); }
+
+template <typename VT1, typename VT2>
+long double fft_rmse(const VT1& fftbuf, const VT2& timebuf) {
+  long double totalpower = 0;
+  long double difpower = 0;
+  long double pi = acos((long double)-1);
+  for (size_t k0 = 0; k0 < (size_t)fftbuf.size(); ++k0) {
+    complex<long double> acc = 0;
+    long double phinc = (long double)(-2.) * k0 * pi / timebuf.size();
+    for (size_t k1 = 0; k1 < (size_t)timebuf.size(); ++k1) {
+      acc += promote(timebuf[k1]) * exp(complex<long double>(0, k1 * phinc));
+    }
+    totalpower += numext::abs2(acc);
+    complex<long double> x = promote(fftbuf[k0]);
+    complex<long double> dif = acc - x;
+    difpower += numext::abs2(dif);
+    // cerr << k0 << "\t" << acc << "\t" <<  x << "\t" << sqrt(numext::abs2(dif)) << endl;
+  }
+  // cerr << "rmse:" << sqrt(difpower/totalpower) << endl;
+  return sqrt(difpower / totalpower);
+}
+
+template <typename VT1, typename VT2>
+long double dif_rmse(const VT1 buf1, const VT2 buf2) {
+  long double totalpower = 0;
+  long double difpower = 0;
+  size_t n = (min)(buf1.size(), buf2.size());
+  for (size_t k = 0; k < n; ++k) {
+    totalpower += (long double)((numext::abs2(buf1[k]) + numext::abs2(buf2[k])) / 2);
+    difpower += (long double)(numext::abs2(buf1[k] - buf2[k]));
+  }
+  return sqrt(difpower / totalpower);
+}
+
+enum {
+  StdVectorContainer,
+  EigenVectorContainer,
+  EigenRowVectorContainer,
+  EigenArrayXContainer,
+  EigenRowArrayXContainer
+};
+
+template <int Container, typename Scalar>
+struct VectorType;
+
+template <typename Scalar>
+struct VectorType<StdVectorContainer, Scalar> {
+  typedef vector<Scalar> type;
+};
+
+template <typename Scalar>
+struct VectorType<EigenVectorContainer, Scalar> {
+  typedef Matrix<Scalar, Dynamic, 1> type;
+};
+
+template <typename Scalar>
+struct VectorType<EigenRowVectorContainer, Scalar> {
+  typedef Matrix<Scalar, 1, Dynamic> type;
+};
+
+template <typename Scalar>
+struct VectorType<EigenArrayXContainer, Scalar> {
+  typedef Array<Scalar, Dynamic, 1> type;
+};
+
+template <typename Scalar>
+struct VectorType<EigenRowArrayXContainer, Scalar> {
+  typedef Array<Scalar, 1, Dynamic> type;
+};
+
+template <int ScalarContainer, int ComplexContainer, typename T>
+void test_scalar_generic(int nfft) {
+  typedef typename FFT<T>::Complex Complex;
+  typedef typename FFT<T>::Scalar Scalar;
+  typedef typename VectorType<ScalarContainer, Scalar>::type ScalarVector;
+  typedef typename VectorType<ComplexContainer, Complex>::type ComplexVector;
+
+  FFT<T> fft;
+  ScalarVector tbuf(nfft);
+  ComplexVector freqBuf;
+  for (int k = 0; k < nfft; ++k) tbuf[k] = (T)(rand() / (double)RAND_MAX - .5);
+
+  // make sure it DOESN'T give the right full spectrum answer
+  // if we've asked for half-spectrum
+  fft.SetFlag(fft.HalfSpectrum);
+  fft.fwd(freqBuf, tbuf);
+  VERIFY((size_t)freqBuf.size() == (size_t)((nfft >> 1) + 1));
+  VERIFY(T(fft_rmse(freqBuf, tbuf)) < test_precision<T>());  // gross check
+
+  fft.ClearFlag(fft.HalfSpectrum);
+  fft.fwd(freqBuf, tbuf);
+  VERIFY((size_t)freqBuf.size() == (size_t)nfft);
+  VERIFY(T(fft_rmse(freqBuf, tbuf)) < test_precision<T>());  // gross check
+
+  if (nfft & 1) return;  // odd FFTs get the wrong size inverse FFT
+
+  ScalarVector tbuf2;
+  fft.inv(tbuf2, freqBuf);
+  VERIFY(T(dif_rmse(tbuf, tbuf2)) < test_precision<T>());  // gross check
+
+  // verify that the Unscaled flag takes effect
+  ScalarVector tbuf3;
+  fft.SetFlag(fft.Unscaled);
+
+  fft.inv(tbuf3, freqBuf);
+
+  for (int k = 0; k < nfft; ++k) tbuf3[k] *= T(1. / nfft);
+
+  // for (size_t i=0;i<(size_t) tbuf.size();++i)
+  //     cout << "freqBuf=" << freqBuf[i] << " in2=" << tbuf3[i] << " -  in=" << tbuf[i] << " => " << (tbuf3[i] -
+  //     tbuf[i] ) <<  endl;
+
+  VERIFY(T(dif_rmse(tbuf, tbuf3)) < test_precision<T>());  // gross check
+
+  // verify that ClearFlag works
+  fft.ClearFlag(fft.Unscaled);
+  fft.inv(tbuf2, freqBuf);
+  VERIFY(T(dif_rmse(tbuf, tbuf2)) < test_precision<T>());  // gross check
+}
+
+template <typename T>
+void test_scalar(int nfft) {
+  // std:vector is a special case that does not interact with DenseBase types
+  test_scalar_generic<StdVectorContainer, StdVectorContainer, T>(nfft);
+
+  // All Dense types as dst and src in various combinations
+  test_scalar_generic<EigenVectorContainer, EigenVectorContainer, T>(nfft);
+  test_scalar_generic<EigenVectorContainer, EigenRowVectorContainer, T>(nfft);
+  test_scalar_generic<EigenVectorContainer, EigenArrayXContainer, T>(nfft);
+  test_scalar_generic<EigenVectorContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_scalar_generic<EigenRowVectorContainer, EigenVectorContainer, T>(nfft);
+  test_scalar_generic<EigenRowVectorContainer, EigenRowVectorContainer, T>(nfft);
+  test_scalar_generic<EigenRowVectorContainer, EigenArrayXContainer, T>(nfft);
+  test_scalar_generic<EigenRowVectorContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_scalar_generic<EigenArrayXContainer, EigenVectorContainer, T>(nfft);
+  test_scalar_generic<EigenArrayXContainer, EigenRowVectorContainer, T>(nfft);
+  test_scalar_generic<EigenArrayXContainer, EigenArrayXContainer, T>(nfft);
+  test_scalar_generic<EigenArrayXContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_scalar_generic<EigenRowArrayXContainer, EigenVectorContainer, T>(nfft);
+  test_scalar_generic<EigenRowArrayXContainer, EigenRowVectorContainer, T>(nfft);
+  test_scalar_generic<EigenRowArrayXContainer, EigenArrayXContainer, T>(nfft);
+  test_scalar_generic<EigenRowArrayXContainer, EigenRowArrayXContainer, T>(nfft);
+}
+
+template <int ContainerA, int ContainerB, typename T>
+void test_complex_generic(int nfft) {
+  typedef typename FFT<T>::Complex Complex;
+  typedef typename VectorType<ContainerA, Complex>::type ComplexVectorA;
+  typedef typename VectorType<ContainerB, Complex>::type ComplexVectorB;
+
+  FFT<T> fft;
+
+  ComplexVectorB inbuf(nfft);
+  ComplexVectorA outbuf;
+  ComplexVectorB buf3;
+  for (int k = 0; k < nfft; ++k)
+    inbuf[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
+  fft.fwd(outbuf, inbuf);
+
+  VERIFY(T(fft_rmse(outbuf, inbuf)) < test_precision<T>());  // gross check
+  fft.inv(buf3, outbuf);
+
+  VERIFY(T(dif_rmse(inbuf, buf3)) < test_precision<T>());  // gross check
+
+  // verify that the Unscaled flag takes effect
+  ComplexVectorA buf4;
+  fft.SetFlag(fft.Unscaled);
+  fft.inv(buf4, outbuf);
+  for (int k = 0; k < nfft; ++k) buf4[k] *= T(1. / nfft);
+  VERIFY(T(dif_rmse(inbuf, buf4)) < test_precision<T>());  // gross check
+
+  // verify that ClearFlag works
+  fft.ClearFlag(fft.Unscaled);
+  fft.inv(buf3, outbuf);
+  VERIFY(T(dif_rmse(inbuf, buf3)) < test_precision<T>());  // gross check
+}
+
+template <typename T>
+void test_complex_strided(int nfft) {
+  typedef typename FFT<T>::Complex Complex;
+  typedef typename Eigen::Vector<Complex, Dynamic> ComplexVector;
+  constexpr int kInputStride = 3;
+  constexpr int kOutputStride = 7;
+  constexpr int kInvOutputStride = 13;
+
+  FFT<T> fft;
+
+  ComplexVector inbuf(nfft * kInputStride);
+  inbuf.setRandom();
+  ComplexVector outbuf(nfft * kOutputStride);
+  outbuf.setRandom();
+  ComplexVector invoutbuf(nfft * kInvOutputStride);
+  invoutbuf.setRandom();
+
+  using StridedComplexVector = Map<ComplexVector, /*MapOptions=*/0, InnerStride<Dynamic>>;
+  StridedComplexVector input(inbuf.data(), nfft, InnerStride<Dynamic>(kInputStride));
+  StridedComplexVector output(outbuf.data(), nfft, InnerStride<Dynamic>(kOutputStride));
+  StridedComplexVector inv_output(invoutbuf.data(), nfft, InnerStride<Dynamic>(kInvOutputStride));
+
+  for (int k = 0; k < nfft; ++k)
+    input[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
+  fft.fwd(output, input);
+
+  VERIFY(T(fft_rmse(output, input)) < test_precision<T>());  // gross check
+  fft.inv(inv_output, output);
+  VERIFY(T(dif_rmse(inv_output, input)) < test_precision<T>());  // gross check
+}
+
+template <typename T>
+void test_complex(int nfft) {
+  // std:vector is a special case that does not interact with DenseBase types
+  test_complex_generic<StdVectorContainer, StdVectorContainer, T>(nfft);
+
+  // All Dense types as dst and src in various combinations
+  test_complex_generic<EigenVectorContainer, EigenVectorContainer, T>(nfft);
+  test_complex_generic<EigenVectorContainer, EigenRowVectorContainer, T>(nfft);
+  test_complex_generic<EigenVectorContainer, EigenArrayXContainer, T>(nfft);
+  test_complex_generic<EigenVectorContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_complex_generic<EigenRowVectorContainer, EigenVectorContainer, T>(nfft);
+  test_complex_generic<EigenRowVectorContainer, EigenRowVectorContainer, T>(nfft);
+  test_complex_generic<EigenRowVectorContainer, EigenArrayXContainer, T>(nfft);
+  test_complex_generic<EigenRowVectorContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_complex_generic<EigenArrayXContainer, EigenVectorContainer, T>(nfft);
+  test_complex_generic<EigenArrayXContainer, EigenRowVectorContainer, T>(nfft);
+  test_complex_generic<EigenArrayXContainer, EigenArrayXContainer, T>(nfft);
+  test_complex_generic<EigenArrayXContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_complex_generic<EigenRowArrayXContainer, EigenVectorContainer, T>(nfft);
+  test_complex_generic<EigenRowArrayXContainer, EigenRowVectorContainer, T>(nfft);
+  test_complex_generic<EigenRowArrayXContainer, EigenArrayXContainer, T>(nfft);
+  test_complex_generic<EigenRowArrayXContainer, EigenRowArrayXContainer, T>(nfft);
+
+  test_complex_strided<T>(nfft);
+}
+
+template <typename T, int nrows, int ncols>
+void test_complex2d() {
+  typedef typename Eigen::FFT<T>::Complex Complex;
+  FFT<T> fft;
+  Eigen::Matrix<Complex, nrows, ncols> src, src2, dst, dst2;
+
+  src = Eigen::Matrix<Complex, nrows, ncols>::Random();
+  // src =  Eigen::Matrix<Complex,nrows,ncols>::Identity();
+
+  for (int k = 0; k < ncols; k++) {
+    Eigen::Matrix<Complex, nrows, 1> tmpOut;
+    fft.fwd(tmpOut, src.col(k));
+    dst2.col(k) = tmpOut;
+  }
+
+  for (int k = 0; k < nrows; k++) {
+    Eigen::Matrix<Complex, 1, ncols> tmpOut;
+    fft.fwd(tmpOut, dst2.row(k));
+    dst2.row(k) = tmpOut;
+  }
+
+  fft.fwd2(dst.data(), src.data(), ncols, nrows);
+  fft.inv2(src2.data(), dst.data(), ncols, nrows);
+  VERIFY((src - src2).norm() < test_precision<T>());
+  VERIFY((dst - dst2).norm() < test_precision<T>());
+}
+
+// Regression for issue #868: fft.fwd(buf, buf) / fft.inv(buf, buf) with the
+// same buffer as input and output must produce the out-of-place result.
+// Also pins down that the in-place scratch comes from the stack for typical
+// sizes so EIGEN_RUNTIME_NO_MALLOC users aren't forced to heap-allocate.
+template <typename T>
+void test_inplace_complex(int nfft) {
+  typedef typename FFT<T>::Complex Complex;
+  typedef Matrix<Complex, Dynamic, 1> ComplexVector;
+
+  ComplexVector in(nfft);
+  for (int k = 0; k < nfft; ++k)
+    in[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
+
+  FFT<T> fft;
+  ComplexVector out_ref;
+  fft.fwd(out_ref, in);
+  ComplexVector inv_ref;
+  fft.inv(inv_ref, out_ref);
+
+  ComplexVector inout_fwd = in;
+  ComplexVector inout_inv = out_ref;
+
+  Eigen::internal::set_is_malloc_allowed(false);
+  fft.fwd(inout_fwd, inout_fwd);
+  fft.inv(inout_inv, inout_inv);
+  Eigen::internal::set_is_malloc_allowed(true);
+
+  VERIFY((out_ref - inout_fwd).cwiseAbs().maxCoeff() < test_precision<T>());
+  VERIFY((inv_ref - inout_inv).cwiseAbs().maxCoeff() < test_precision<T>());
+}
+
+// Regression for issue #675: zero-padding a fixed-size vector must not assume
+// a column block in the temporary contiguous FFT input.
+template <typename T>
+void test_fwd_padding(int nfft) {
+  typedef typename FFT<T>::Complex Complex;
+  typedef Matrix<T, 10, 1> FixedRealColumn;
+  typedef Matrix<T, 1, 10> FixedRealRow;
+  typedef Matrix<Complex, 10, 1> FixedComplexColumn;
+  typedef Matrix<Complex, 1, 10> FixedComplexRow;
+  typedef Matrix<T, Dynamic, 1> RealVector;
+  typedef Matrix<Complex, Dynamic, 1> ComplexVector;
+
+  FixedRealColumn real_column;
+  FixedComplexColumn complex_column;
+  for (int k = 0; k < real_column.size(); ++k) {
+    real_column[k] = (T)(rand() / (double)RAND_MAX - .5);
+    complex_column[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
+  }
+  FixedRealRow real_row = real_column.transpose();
+  FixedComplexRow complex_row = complex_column.transpose();
+
+  RealVector real_padded = RealVector::Zero(nfft);
+  real_padded.head(real_column.size()) = real_column;
+  ComplexVector complex_padded = ComplexVector::Zero(nfft);
+  complex_padded.head(complex_column.size()) = complex_column;
+
+  FFT<T> fft;
+  ComplexVector expected;
+  ComplexVector actual;
+
+  fft.fwd(expected, real_padded);
+  fft.fwd(actual, real_column, nfft);
+  VERIFY_IS_APPROX(actual, expected);
+  fft.fwd(actual, real_row, nfft);
+  VERIFY_IS_APPROX(actual, expected);
+
+  fft.fwd(expected, complex_padded);
+  fft.fwd(actual, complex_column, nfft);
+  VERIFY_IS_APPROX(actual, expected);
+  fft.fwd(actual, complex_row, nfft);
+  VERIFY_IS_APPROX(actual, expected);
+
+  fft.SetFlag(fft.HalfSpectrum);
+  fft.fwd(expected, real_padded);
+  fft.fwd(actual, real_column, nfft);
+  VERIFY_IS_APPROX(actual, expected);
+  fft.fwd(actual, real_row, nfft);
+  VERIFY_IS_APPROX(actual, expected);
+}
+
+inline void test_return_by_value(int len) {
+  VectorXf in;
+  VectorXf in1;
+  in.setRandom(len);
+  VectorXcf out1, out2;
+  FFT<float> fft;
+
+  fft.SetFlag(fft.HalfSpectrum);
+
+  fft.fwd(out1, in);
+  out2 = fft.fwd(in);
+  VERIFY((out1 - out2).norm() < test_precision<float>());
+  in1 = fft.inv(out1);
+  VERIFY((in1 - in).norm() < test_precision<float>());
+}
+
+// Regression for issue #1537: reusing the same FFT object across real-input
+// and complex-input transforms of the same size must produce correct results.
+// Before the fix, the FFTW backend's plan cache keyed only on (nfft, inverse,
+// inplace, aligned), so an r2c plan could be returned for a c2c call (or
+// vice versa).
+template <typename T>
+void test_reuse_real_and_complex(int nfft) {
+  typedef typename FFT<T>::Complex Complex;
+  typedef Matrix<T, Dynamic, 1> ScalarVector;
+  typedef Matrix<Complex, Dynamic, 1> ComplexVector;
+
+  ScalarVector real_in(nfft);
+  ComplexVector complex_in(nfft);
+  for (int k = 0; k < nfft; ++k) {
+    real_in[k] = (T)(rand() / (double)RAND_MAX - .5);
+    complex_in[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
+  }
+
+  FFT<T> fft;
+  ComplexVector r2c_out;
+  ComplexVector c2c_out;
+
+  fft.fwd(r2c_out, real_in);
+  fft.fwd(c2c_out, complex_in);
+  VERIFY(T(fft_rmse(r2c_out, real_in)) < test_precision<T>());
+  VERIFY(T(fft_rmse(c2c_out, complex_in)) < test_precision<T>());
+
+  // Repeat with the reverse first-call ordering so the cache miss happens on
+  // the opposite transform kind; this catches the symmetric c2c-then-r2c case.
+  fft.fwd(c2c_out, complex_in);
+  fft.fwd(r2c_out, real_in);
+  VERIFY(T(fft_rmse(r2c_out, real_in)) < test_precision<T>());
+  VERIFY(T(fft_rmse(c2c_out, complex_in)) < test_precision<T>());
+
+  // Round-trip fwd->inv on the same shared FFT object exercises the c2r and
+  // c2c inverse plans alongside the forward plans cached above.
+  ScalarVector real_round;
+  ComplexVector complex_round;
+  fft.inv(real_round, r2c_out);
+  VERIFY(T(dif_rmse(real_in, real_round)) < test_precision<T>());
+  fft.inv(complex_round, c2c_out);
+  VERIFY(T(dif_rmse(complex_in, complex_round)) < test_precision<T>());
+}
+
+// Regression test for issue #690: a dynamically sized matrix is only known to
+// hold a single row or column at run time, so it must be accepted like any
+// other one-dimensional operand, with the destination keeping its shape.
+template <typename T>
+void test_dynamic_matrix_operands(int nfft) {
+  using Complex = typename FFT<T>::Complex;
+  using DynMatrix = Matrix<T, Dynamic, Dynamic>;
+  using DynCMatrix = Matrix<Complex, Dynamic, Dynamic>;
+
+  FFT<T> fft;
+  Matrix<T, Dynamic, 1> reference(nfft);
+  for (int k = 0; k < nfft; ++k) reference[k] = T(rand() / (double)RAND_MAX - .5);
+  Matrix<Complex, Dynamic, 1> reference_freq;
+  fft.fwd(reference_freq, reference);
+
+  // A 1-by-n source produces a 1-by-n spectrum with the same values.
+  DynMatrix row_src(1, nfft);
+  row_src.row(0) = reference.transpose();
+  DynCMatrix row_freq;
+  fft.fwd(row_freq, row_src);
+  VERIFY_IS_EQUAL(row_freq.rows(), 1);
+  VERIFY_IS_EQUAL(row_freq.cols(), Index(nfft));
+  VERIFY(T(dif_rmse(row_freq.reshaped(), reference_freq)) < test_precision<T>());
+
+  // ... and round trips back through the inverse transform.
+  DynMatrix row_back;
+  fft.inv(row_back, row_freq);
+  VERIFY_IS_EQUAL(row_back.rows(), 1);
+  VERIFY_IS_EQUAL(row_back.cols(), Index(nfft));
+  VERIFY(T(dif_rmse(row_back.reshaped(), reference)) < test_precision<T>());
+
+  // An n-by-1 source keeps the column shape.
+  DynMatrix col_src(nfft, 1);
+  col_src.col(0) = reference;
+  DynCMatrix col_freq;
+  fft.fwd(col_freq, col_src);
+  VERIFY_IS_EQUAL(col_freq.rows(), Index(nfft));
+  VERIFY_IS_EQUAL(col_freq.cols(), 1);
+  VERIFY(T(dif_rmse(col_freq.reshaped(), reference_freq)) < test_precision<T>());
+
+  // A destination whose orientation is fixed at compile time keeps it.
+  Matrix<Complex, 1, Dynamic> row_vector_freq;
+  fft.fwd(row_vector_freq, reference);
+  VERIFY_IS_EQUAL(row_vector_freq.rows(), 1);
+  VERIFY(T(dif_rmse(row_vector_freq.reshaped(), reference_freq)) < test_precision<T>());
+}
+
+// A matrix with only one dynamic dimension is one-dimensional at run time in exactly one
+// orientation: the fixed dimension, when it is not one, has to be the long one. Such an operand
+// is as acceptable as a fully dynamic one, and it pins the orientation of a destination.
+template <typename T, int N>
+void test_partially_dynamic_matrix_operands() {
+  using Complex = typename FFT<T>::Complex;
+
+  FFT<T> fft;
+  Matrix<T, N, 1> reference;
+  for (int k = 0; k < N; ++k) reference[k] = T(rand() / (double)RAND_MAX - .5);
+  Matrix<Complex, N, 1> reference_freq;
+  fft.fwd(reference_freq, reference);
+
+  // A dynamic row count with N columns can only be a row.
+  Matrix<T, Dynamic, N> row_src(1, N);
+  row_src.row(0) = reference.transpose();
+  Matrix<Complex, Dynamic, N> row_freq;
+  fft.fwd(row_freq, row_src);
+  VERIFY_IS_EQUAL(row_freq.rows(), 1);
+  VERIFY(T(dif_rmse(row_freq.reshaped(), reference_freq)) < test_precision<T>());
+
+  Matrix<T, Dynamic, N> row_back;
+  fft.inv(row_back, row_freq);
+  VERIFY_IS_EQUAL(row_back.rows(), 1);
+  VERIFY(T(dif_rmse(row_back.reshaped(), reference)) < test_precision<T>());
+
+  // A dynamic column count with N rows can only be a column.
+  Matrix<T, N, Dynamic> col_src(N, 1);
+  col_src.col(0) = reference;
+  Matrix<Complex, N, Dynamic> col_freq;
+  fft.fwd(col_freq, col_src);
+  VERIFY_IS_EQUAL(col_freq.cols(), 1);
+  VERIFY(T(dif_rmse(col_freq.reshaped(), reference_freq)) < test_precision<T>());
+
+  Matrix<T, N, Dynamic> col_back;
+  fft.inv(col_back, col_freq);
+  VERIFY_IS_EQUAL(col_back.cols(), 1);
+  VERIFY(T(dif_rmse(col_back.reshaped(), reference)) < test_precision<T>());
+}
+
+// Once matrices are accepted, a unit inner stride no longer means the operand is packed: a view
+// holding a single row of a wider buffer steps along its outer stride instead.
+template <typename T>
+void test_strided_row_operands(int nfft) {
+  using Complex = typename FFT<T>::Complex;
+  using DynMatrix = Matrix<T, Dynamic, Dynamic>;
+  using DynCMatrix = Matrix<Complex, Dynamic, Dynamic>;
+  const Index stride = 3;
+
+  FFT<T> fft;
+  Matrix<T, Dynamic, 1> reference(nfft);
+  for (int k = 0; k < nfft; ++k) reference[k] = T(rand() / (double)RAND_MAX - .5);
+  Matrix<Complex, Dynamic, 1> reference_freq;
+  fft.fwd(reference_freq, reference);
+
+  // Strided source.
+  DynMatrix storage = DynMatrix::Zero(stride, nfft);
+  Map<DynMatrix, 0, OuterStride<>> src(storage.data(), 1, nfft, OuterStride<>(stride));
+  src.row(0) = reference.transpose();
+  Matrix<Complex, Dynamic, 1> freq;
+  fft.fwd(freq, src);
+  VERIFY(T(dif_rmse(freq, reference_freq)) < test_precision<T>());
+
+  // Strided destination, and back again as a strided source.
+  DynCMatrix freq_storage = DynCMatrix::Zero(stride, nfft);
+  Map<DynCMatrix, 0, OuterStride<>> freq_dst(freq_storage.data(), 1, nfft, OuterStride<>(stride));
+  fft.fwd(freq_dst, reference);
+  VERIFY(T(dif_rmse(freq_storage.row(0), reference_freq)) < test_precision<T>());
+
+  Matrix<T, Dynamic, 1> back;
+  fft.inv(back, freq_dst);
+  VERIFY(T(dif_rmse(back, reference)) < test_precision<T>());
+}
+#if defined EIGEN_FFTW_DEFAULT
+// Distinct FFT objects must be usable from distinct threads concurrently.
+// FFTW's planner is not thread-safe, so the FFTW backend serializes plan
+// creation and destruction internally (issue #1483); each thread here creates
+// fresh plans of many sizes while verifying its round trips.
+void test_concurrent_transforms() {
+  const int num_threads = 8;
+  const int num_ffts = 24;
+  std::vector<int> failures(num_threads, 0);
+  std::vector<std::thread> workers;
+  for (int t = 0; t < num_threads; ++t) {
+    workers.emplace_back([t, &failures] {
+      for (int k = 0; k < num_ffts; ++k) {
+        const int nfft = 16 + 3 * ((t + k) % 40);
+        Eigen::FFT<double> fft;
+        std::vector<std::complex<double>> src(nfft), freq, back;
+        for (int i = 0; i < nfft; ++i) src[i] = {std::cos(0.3 * i * (t + 1)), std::sin(0.7 * i + k)};
+        fft.fwd(freq, src);
+        fft.inv(back, freq);
+        double max_err = 0;
+        for (int i = 0; i < nfft; ++i) max_err = numext::maxi(max_err, std::abs(back[i] - src[i]));
+        // VERIFY is not thread-safe; record and check after joining.
+        if (!(max_err < 100 * nfft * NumTraits<double>::epsilon())) ++failures[t];
+      }
+    });
+  }
+  for (std::size_t t = 0; t < workers.size(); ++t) workers[t].join();
+  for (int t = 0; t < num_threads; ++t) VERIFY_IS_EQUAL(failures[t], 0);
+}
+#endif  // EIGEN_FFTW_DEFAULT
+
+EIGEN_DECLARE_TEST(FFTW) {
+  CALL_SUBTEST(test_dynamic_matrix_operands<float>(32));
+  CALL_SUBTEST(test_dynamic_matrix_operands<double>(32));
+  CALL_SUBTEST(test_dynamic_matrix_operands<double>(2 * 3 * 4 * 5));
+  CALL_SUBTEST((test_partially_dynamic_matrix_operands<float, 32>()));
+  CALL_SUBTEST((test_partially_dynamic_matrix_operands<double, 32>()));
+  CALL_SUBTEST((test_partially_dynamic_matrix_operands<double, 2 * 3 * 4 * 5>()));
+  CALL_SUBTEST(test_strided_row_operands<float>(32));
+  CALL_SUBTEST(test_strided_row_operands<double>(32));
+  CALL_SUBTEST(test_strided_row_operands<double>(2 * 3 * 4 * 5));
+  CALL_SUBTEST(test_return_by_value(32));
+  // Regression test for #1537 -- reuse one FFT object for both real and
+  // complex inputs of the same size.
+  CALL_SUBTEST(test_reuse_real_and_complex<float>(32));
+  CALL_SUBTEST(test_reuse_real_and_complex<double>(32));
+  CALL_SUBTEST(test_reuse_real_and_complex<float>(256));
+  CALL_SUBTEST(test_reuse_real_and_complex<double>(256));
+  CALL_SUBTEST(test_inplace_complex<float>(32));
+  CALL_SUBTEST(test_inplace_complex<double>(32));
+  CALL_SUBTEST(test_inplace_complex<float>(256));
+  CALL_SUBTEST(test_inplace_complex<double>(256));
+  CALL_SUBTEST(test_fwd_padding<float>(16));
+  CALL_SUBTEST(test_fwd_padding<double>(16));
+  CALL_SUBTEST(test_complex<float>(32));
+  CALL_SUBTEST(test_complex<double>(32));
+  CALL_SUBTEST(test_complex<float>(256));
+  CALL_SUBTEST(test_complex<double>(256));
+  CALL_SUBTEST(test_complex<float>(3 * 8));
+  CALL_SUBTEST(test_complex<double>(3 * 8));
+  CALL_SUBTEST(test_complex<float>(5 * 32));
+  CALL_SUBTEST(test_complex<double>(5 * 32));
+  CALL_SUBTEST(test_complex<float>(2 * 3 * 4));
+  CALL_SUBTEST(test_complex<double>(2 * 3 * 4));
+  CALL_SUBTEST(test_complex<float>(2 * 3 * 4 * 5));
+  CALL_SUBTEST(test_complex<double>(2 * 3 * 4 * 5));
+  CALL_SUBTEST(test_complex<float>(2 * 3 * 4 * 5 * 7));
+  CALL_SUBTEST(test_complex<double>(2 * 3 * 4 * 5 * 7));
+
+  CALL_SUBTEST(test_scalar<float>(32));
+  CALL_SUBTEST(test_scalar<double>(32));
+  CALL_SUBTEST(test_scalar<float>(45));
+  CALL_SUBTEST(test_scalar<double>(45));
+  CALL_SUBTEST(test_scalar<float>(50));
+  CALL_SUBTEST(test_scalar<double>(50));
+  CALL_SUBTEST(test_scalar<float>(256));
+  CALL_SUBTEST(test_scalar<double>(256));
+  CALL_SUBTEST(test_scalar<float>(2 * 3 * 4 * 5 * 7));
+  CALL_SUBTEST(test_scalar<double>(2 * 3 * 4 * 5 * 7));
+
+#if defined EIGEN_HAS_FFTWL || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT
+  CALL_SUBTEST(test_complex<long double>(32));
+  CALL_SUBTEST(test_complex<long double>(256));
+  CALL_SUBTEST(test_complex<long double>(3 * 8));
+  CALL_SUBTEST(test_complex<long double>(5 * 32));
+  CALL_SUBTEST(test_complex<long double>(2 * 3 * 4));
+  CALL_SUBTEST(test_complex<long double>(2 * 3 * 4 * 5));
+  CALL_SUBTEST(test_complex<long double>(2 * 3 * 4 * 5 * 7));
+
+  CALL_SUBTEST(test_scalar<long double>(32));
+  CALL_SUBTEST(test_scalar<long double>(45));
+  CALL_SUBTEST(test_scalar<long double>(50));
+  CALL_SUBTEST(test_scalar<long double>(256));
+  CALL_SUBTEST(test_scalar<long double>(2 * 3 * 4 * 5 * 7));
+
+  CALL_SUBTEST((test_complex2d<long double, 2 * 3 * 4, 2 * 3 * 4>()));
+  CALL_SUBTEST((test_complex2d<long double, 3 * 4 * 5, 3 * 4 * 5>()));
+  CALL_SUBTEST((test_complex2d<long double, 24, 60>()));
+  CALL_SUBTEST((test_complex2d<long double, 60, 24>()));
+// fail to build since Eigen limit the stack allocation size,too big here.
+// CALL_SUBTEST( ( test_complex2d<long double, 256, 256> () ) );
+#endif
+#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
+    defined EIGEN_MKL_DEFAULT
+  CALL_SUBTEST((test_complex2d<float, 24, 24>()));
+  CALL_SUBTEST((test_complex2d<float, 60, 60>()));
+  CALL_SUBTEST((test_complex2d<float, 24, 60>()));
+  CALL_SUBTEST((test_complex2d<float, 60, 24>()));
+#endif
+#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
+    defined EIGEN_MKL_DEFAULT
+  CALL_SUBTEST((test_complex2d<double, 24, 24>()));
+  CALL_SUBTEST((test_complex2d<double, 60, 60>()));
+  CALL_SUBTEST((test_complex2d<double, 24, 60>()));
+  CALL_SUBTEST((test_complex2d<double, 60, 24>()));
+#endif
+
+#if defined EIGEN_FFTW_DEFAULT
+  CALL_SUBTEST(test_concurrent_transforms());
+#endif
+}
+
+#endif  // EIGEN_UNSUPPORTED_TEST_FFT_TEST_SHARED_H
diff --git a/contrib/test/forward_adolc.cpp b/contrib/test/forward_adolc.cpp
new file mode 100644
index 0000000..1f27798
--- /dev/null
+++ b/contrib/test/forward_adolc.cpp
@@ -0,0 +1,127 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/Dense>
+
+#define NUMBER_DIRECTIONS 16
+#include <contrib/Eigen/AdolcForward>
+
+template <typename Vector>
+EIGEN_DONT_INLINE typename Vector::Scalar foo(const Vector& p) {
+  typedef typename Vector::Scalar Scalar;
+  return (p - Vector(Scalar(-1), Scalar(1.))).norm() + (p.array().sqrt().abs() * p.array().sin()).sum() + p.dot(p);
+}
+
+template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
+struct TestFunc1 {
+  typedef Scalar_ Scalar;
+  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
+  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
+  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
+
+  int m_inputs, m_values;
+
+  TestFunc1() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
+  TestFunc1(int inputs_, int values_) : m_inputs(inputs_), m_values(values_) {}
+
+  int inputs() const { return m_inputs; }
+  int values() const { return m_values; }
+
+  template <typename T>
+  void operator()(const Matrix<T, InputsAtCompileTime, 1>& x, Matrix<T, ValuesAtCompileTime, 1>* _v) const {
+    Matrix<T, ValuesAtCompileTime, 1>& v = *_v;
+
+    v[0] = 2 * x[0] * x[0] + x[0] * x[1];
+    v[1] = 3 * x[1] * x[0] + 0.5 * x[1] * x[1];
+    if (inputs() > 2) {
+      v[0] += 0.5 * x[2];
+      v[1] += x[2];
+    }
+    if (values() > 2) {
+      v[2] = 3 * x[1] * x[0] * x[0];
+    }
+    if (inputs() > 2 && values() > 2) v[2] *= x[2];
+  }
+
+  void operator()(const InputType& x, ValueType* v, JacobianType* _j) const {
+    (*this)(x, v);
+
+    if (_j) {
+      JacobianType& j = *_j;
+
+      j(0, 0) = 4 * x[0] + x[1];
+      j(1, 0) = 3 * x[1];
+
+      j(0, 1) = x[0];
+      j(1, 1) = 3 * x[0] + 2 * 0.5 * x[1];
+
+      if (inputs() > 2) {
+        j(0, 2) = 0.5;
+        j(1, 2) = 1;
+      }
+      if (values() > 2) {
+        j(2, 0) = 3 * x[1] * 2 * x[0];
+        j(2, 1) = 3 * x[0] * x[0];
+      }
+      if (inputs() > 2 && values() > 2) {
+        j(2, 0) *= x[2];
+        j(2, 1) *= x[2];
+
+        j(2, 2) = 3 * x[1] * x[0] * x[0];
+      }
+    }
+  }
+};
+
+template <typename Func>
+void adolc_forward_jacobian(const Func& f) {
+  typename Func::InputType x = Func::InputType::Random(f.inputs());
+  typename Func::ValueType y(f.values()), yref(f.values());
+  typename Func::JacobianType j(f.values(), f.inputs()), jref(f.values(), f.inputs());
+
+  jref.setZero();
+  yref.setZero();
+  f(x, &yref, &jref);
+  //     std::cerr << y.transpose() << "\n\n";;
+  //     std::cerr << j << "\n\n";;
+
+  j.setZero();
+  y.setZero();
+  AdolcForwardJacobian<Func> autoj(f);
+  autoj(x, &y, &j);
+  //     std::cerr << y.transpose() << "\n\n";;
+  //     std::cerr << j << "\n\n";;
+
+  VERIFY_IS_APPROX(y, yref);
+  VERIFY_IS_APPROX(j, jref);
+}
+
+EIGEN_DECLARE_TEST(forward_adolc) {
+  adtl::setNumDir(NUMBER_DIRECTIONS);
+
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 2, 2>())));
+    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 2, 3>())));
+    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 3, 2>())));
+    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 3, 3>())));
+    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double>(3, 3))));
+  }
+
+  {
+    // simple instantiation tests
+    Matrix<adtl::adouble, 2, 1> x;
+    foo(x);
+    Matrix<adtl::adouble, Dynamic, Dynamic> A(4, 4);
+    ;
+    A.selfadjointView<Lower>().eigenvalues();
+  }
+}
diff --git a/contrib/test/kronecker_product.cpp b/contrib/test/kronecker_product.cpp
new file mode 100644
index 0000000..2cc309e
--- /dev/null
+++ b/contrib/test/kronecker_product.cpp
@@ -0,0 +1,256 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Kolja Brix <brix@igpm.rwth-aachen.de>
+// Copyright (C) 2011 Andreas Platen <andiplaten@gmx.de>
+// Copyright (C) 2012 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifdef EIGEN_TEST_PART_1
+
+#include "sparse.h"
+#include <Eigen/SparseExtra>
+#include <Eigen/KroneckerProduct>
+
+template <typename MatrixType>
+void check_dimension(const MatrixType& ab, const int rows, const int cols) {
+  VERIFY_IS_EQUAL(ab.rows(), rows);
+  VERIFY_IS_EQUAL(ab.cols(), cols);
+}
+
+template <typename MatrixType>
+void check_kronecker_product(const MatrixType& ab) {
+  VERIFY_IS_EQUAL(ab.rows(), 6);
+  VERIFY_IS_EQUAL(ab.cols(), 6);
+  VERIFY_IS_EQUAL(ab.size(), 36);
+  VERIFY_IS_APPROX(ab.coeff(0, 0), -0.4017367630386106);
+  VERIFY_IS_APPROX(ab.coeff(0, 1), 0.1056863433932735);
+  VERIFY_IS_APPROX(ab.coeff(0, 2), -0.7255206194554212);
+  VERIFY_IS_APPROX(ab.coeff(0, 3), 0.1908653336744706);
+  VERIFY_IS_APPROX(ab.coeff(0, 4), 0.350864567234111);
+  VERIFY_IS_APPROX(ab.coeff(0, 5), -0.0923032108308013);
+  VERIFY_IS_APPROX(ab.coeff(1, 0), 0.415417514804677);
+  VERIFY_IS_APPROX(ab.coeff(1, 1), -0.2369227701722048);
+  VERIFY_IS_APPROX(ab.coeff(1, 2), 0.7502275131458511);
+  VERIFY_IS_APPROX(ab.coeff(1, 3), -0.4278731019742696);
+  VERIFY_IS_APPROX(ab.coeff(1, 4), -0.3628129162264507);
+  VERIFY_IS_APPROX(ab.coeff(1, 5), 0.2069210808481275);
+  VERIFY_IS_APPROX(ab.coeff(2, 0), 0.05465890160863986);
+  VERIFY_IS_APPROX(ab.coeff(2, 1), -0.2634092511419858);
+  VERIFY_IS_APPROX(ab.coeff(2, 2), 0.09871180285793758);
+  VERIFY_IS_APPROX(ab.coeff(2, 3), -0.4757066334017702);
+  VERIFY_IS_APPROX(ab.coeff(2, 4), -0.04773740823058334);
+  VERIFY_IS_APPROX(ab.coeff(2, 5), 0.2300535609645254);
+  VERIFY_IS_APPROX(ab.coeff(3, 0), -0.8172945853260133);
+  VERIFY_IS_APPROX(ab.coeff(3, 1), 0.2150086428359221);
+  VERIFY_IS_APPROX(ab.coeff(3, 2), 0.5825113847292743);
+  VERIFY_IS_APPROX(ab.coeff(3, 3), -0.1532433770097174);
+  VERIFY_IS_APPROX(ab.coeff(3, 4), -0.329383387282399);
+  VERIFY_IS_APPROX(ab.coeff(3, 5), 0.08665207912033064);
+  VERIFY_IS_APPROX(ab.coeff(4, 0), 0.8451267514863225);
+  VERIFY_IS_APPROX(ab.coeff(4, 1), -0.481996458918977);
+  VERIFY_IS_APPROX(ab.coeff(4, 2), -0.6023482390791535);
+  VERIFY_IS_APPROX(ab.coeff(4, 3), 0.3435339347164565);
+  VERIFY_IS_APPROX(ab.coeff(4, 4), 0.3406002157428891);
+  VERIFY_IS_APPROX(ab.coeff(4, 5), -0.1942526344200915);
+  VERIFY_IS_APPROX(ab.coeff(5, 0), 0.1111982482925399);
+  VERIFY_IS_APPROX(ab.coeff(5, 1), -0.5358806424754169);
+  VERIFY_IS_APPROX(ab.coeff(5, 2), -0.07925446559335647);
+  VERIFY_IS_APPROX(ab.coeff(5, 3), 0.3819388757769038);
+  VERIFY_IS_APPROX(ab.coeff(5, 4), 0.04481475387219876);
+  VERIFY_IS_APPROX(ab.coeff(5, 5), -0.2159688616158057);
+}
+
+template <typename MatrixType>
+void check_sparse_kronecker_product(const MatrixType& ab) {
+  VERIFY_IS_EQUAL(ab.rows(), 12);
+  VERIFY_IS_EQUAL(ab.cols(), 10);
+  VERIFY_IS_EQUAL(ab.nonZeros(), 3 * 2);
+  VERIFY_IS_APPROX(ab.coeff(3, 0), -0.04);
+  VERIFY_IS_APPROX(ab.coeff(5, 1), 0.05);
+  VERIFY_IS_APPROX(ab.coeff(0, 6), -0.08);
+  VERIFY_IS_APPROX(ab.coeff(2, 7), 0.10);
+  VERIFY_IS_APPROX(ab.coeff(6, 8), 0.12);
+  VERIFY_IS_APPROX(ab.coeff(8, 9), -0.15);
+}
+
+EIGEN_DECLARE_TEST(kronecker_product) {
+  // DM = dense matrix; SM = sparse matrix
+
+  Matrix<double, 2, 3> DM_a;
+  SparseMatrix<double> SM_a(2, 3);
+  SM_a.insert(0, 0) = DM_a.coeffRef(0, 0) = -0.4461540300782201;
+  SM_a.insert(0, 1) = DM_a.coeffRef(0, 1) = -0.8057364375283049;
+  SM_a.insert(0, 2) = DM_a.coeffRef(0, 2) = 0.3896572459516341;
+  SM_a.insert(1, 0) = DM_a.coeffRef(1, 0) = -0.9076572187376921;
+  SM_a.insert(1, 1) = DM_a.coeffRef(1, 1) = 0.6469156566545853;
+  SM_a.insert(1, 2) = DM_a.coeffRef(1, 2) = -0.3658010398782789;
+
+  MatrixXd DM_b(3, 2);
+  SparseMatrix<double> SM_b(3, 2);
+  SM_b.insert(0, 0) = DM_b.coeffRef(0, 0) = 0.9004440976767099;
+  SM_b.insert(0, 1) = DM_b.coeffRef(0, 1) = -0.2368830858139832;
+  SM_b.insert(1, 0) = DM_b.coeffRef(1, 0) = -0.9311078389941825;
+  SM_b.insert(1, 1) = DM_b.coeffRef(1, 1) = 0.5310335762980047;
+  SM_b.insert(2, 0) = DM_b.coeffRef(2, 0) = -0.1225112806872035;
+  SM_b.insert(2, 1) = DM_b.coeffRef(2, 1) = 0.5903998022741264;
+
+  SparseMatrix<double, RowMajor> SM_row_a(SM_a), SM_row_b(SM_b);
+
+  // test DM_fixedSize = kroneckerProduct(DM_block,DM)
+  Matrix<double, 6, 6> DM_fix_ab = kroneckerProduct(DM_a.topLeftCorner<2, 3>(), DM_b);
+
+  CALL_SUBTEST(check_kronecker_product(DM_fix_ab));
+  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a.topLeftCorner<2, 3>(), DM_b)));
+
+  // test DM_block = kroneckerProduct(DM,DM)
+  MatrixXd DM_block_ab(10, 15);
+  DM_block_ab.block<6, 6>(2, 5) = kroneckerProduct(DM_a, DM_b);
+  CALL_SUBTEST(check_kronecker_product(DM_block_ab.block<6, 6>(2, 5)));
+
+  // test DM = kroneckerProduct(DM,DM)
+  MatrixXd DM_ab = kroneckerProduct(DM_a, DM_b);
+  CALL_SUBTEST(check_kronecker_product(DM_ab));
+  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a, DM_b)));
+
+  // test SM = kroneckerProduct(SM,DM)
+  SparseMatrix<double> SM_ab = kroneckerProduct(SM_a, DM_b);
+  CALL_SUBTEST(check_kronecker_product(SM_ab));
+  SparseMatrix<double, RowMajor> SM_ab2 = kroneckerProduct(SM_a, DM_b);
+  CALL_SUBTEST(check_kronecker_product(SM_ab2));
+  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(SM_a, DM_b)));
+
+  // test SM = kroneckerProduct(DM,SM)
+  SM_ab.setZero();
+  SM_ab.insert(0, 0) = 37.0;
+  SM_ab = kroneckerProduct(DM_a, SM_b);
+  CALL_SUBTEST(check_kronecker_product(SM_ab));
+  SM_ab2.setZero();
+  SM_ab2.insert(0, 0) = 37.0;
+  SM_ab2 = kroneckerProduct(DM_a, SM_b);
+  CALL_SUBTEST(check_kronecker_product(SM_ab2));
+  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a, SM_b)));
+
+  // test SM = kroneckerProduct(SM,SM)
+  SM_ab.resize(2, 33);
+  SM_ab.insert(0, 0) = 37.0;
+  SM_ab = kroneckerProduct(SM_a, SM_b);
+  CALL_SUBTEST(check_kronecker_product(SM_ab));
+  SM_ab2.resize(5, 11);
+  SM_ab2.insert(0, 0) = 37.0;
+  SM_ab2 = kroneckerProduct(SM_a, SM_b);
+  CALL_SUBTEST(check_kronecker_product(SM_ab2));
+  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(SM_a, SM_b)));
+
+  // test SM = kroneckerProduct(SM,SM) with sparse pattern
+  SM_a.resize(4, 5);
+  SM_b.resize(3, 2);
+  SM_a.resizeNonZeros(0);
+  SM_b.resizeNonZeros(0);
+  SM_a.insert(1, 0) = -0.1;
+  SM_a.insert(0, 3) = -0.2;
+  SM_a.insert(2, 4) = 0.3;
+  SM_a.finalize();
+
+  SM_b.insert(0, 0) = 0.4;
+  SM_b.insert(2, 1) = -0.5;
+  SM_b.finalize();
+  SM_ab.resize(1, 1);
+  SM_ab.insert(0, 0) = 37.0;
+  SM_ab = kroneckerProduct(SM_a, SM_b);
+  CALL_SUBTEST(check_sparse_kronecker_product(SM_ab));
+
+  // test dimension of result of DM = kroneckerProduct(DM,DM)
+  MatrixXd DM_a2 = Eigen::MatrixXd::Random(2, 1);
+  MatrixXd DM_b2 = Eigen::MatrixXd::Random(5, 4);
+  MatrixXd DM_ab2 = kroneckerProduct(DM_a2, DM_b2);
+  CALL_SUBTEST(check_dimension(DM_ab2, 2 * 5, 1 * 4));
+  DM_a2 = Eigen::MatrixXd::Random(10, 9);
+  DM_b2 = Eigen::MatrixXd::Random(4, 8);
+  DM_ab2 = kroneckerProduct(DM_a2, DM_b2);
+  CALL_SUBTEST(check_dimension(DM_ab2, 10 * 4, 9 * 8));
+
+  // test linear coefficient access for vector results
+  Vector2i vector_a;
+  vector_a << 10, 20;
+  Vector3i vector_b;
+  vector_b << 1, 2, 3;
+  Matrix<int, 6, 1> vector_ab = kroneckerProduct(vector_a, vector_b);
+  for (Index i = 0; i < vector_ab.size(); ++i)
+    VERIFY_IS_EQUAL(kroneckerProduct(vector_a, vector_b).coeff(i), vector_ab.coeff(i));
+
+  RowVector2i row_vector_a;
+  row_vector_a << 10, 20;
+  Matrix<int, 1, 3> row_vector_b;
+  row_vector_b << 1, 2, 3;
+  Matrix<int, 1, 6> row_vector_ab = kroneckerProduct(row_vector_a, row_vector_b);
+  for (Index i = 0; i < row_vector_ab.size(); ++i)
+    VERIFY_IS_EQUAL(kroneckerProduct(row_vector_a, row_vector_b).coeff(i), row_vector_ab.coeff(i));
+
+  for (int i = 0; i < g_repeat; i++) {
+    double density = Eigen::internal::random<double>(0.01, 0.5);
+    int ra = Eigen::internal::random<int>(1, 50);
+    int ca = Eigen::internal::random<int>(1, 50);
+    int rb = Eigen::internal::random<int>(1, 50);
+    int cb = Eigen::internal::random<int>(1, 50);
+    SparseMatrix<float, ColMajor> sA(ra, ca), sB(rb, cb), sC;
+    SparseMatrix<float, RowMajor> sC2;
+    MatrixXf dA(ra, ca), dB(rb, cb), dC;
+    initSparse(density, dA, sA);
+    initSparse(density, dB, sB);
+
+    sC = kroneckerProduct(sA, sB);
+    dC = kroneckerProduct(dA, dB);
+    VERIFY_IS_APPROX(MatrixXf(sC), dC);
+
+    sC = kroneckerProduct(sA.transpose(), sB);
+    dC = kroneckerProduct(dA.transpose(), dB);
+    VERIFY_IS_APPROX(MatrixXf(sC), dC);
+
+    sC = kroneckerProduct(sA.transpose(), sB.transpose());
+    dC = kroneckerProduct(dA.transpose(), dB.transpose());
+    VERIFY_IS_APPROX(MatrixXf(sC), dC);
+
+    sC = kroneckerProduct(sA, sB.transpose());
+    dC = kroneckerProduct(dA, dB.transpose());
+    VERIFY_IS_APPROX(MatrixXf(sC), dC);
+
+    sC2 = kroneckerProduct(sA, sB);
+    dC = kroneckerProduct(dA, dB);
+    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
+
+    sC2 = kroneckerProduct(dA, sB);
+    dC = kroneckerProduct(dA, dB);
+    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
+
+    sC2 = kroneckerProduct(sA, dB);
+    dC = kroneckerProduct(dA, dB);
+    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
+
+    sC2 = kroneckerProduct(2 * sA, sB);
+    dC = kroneckerProduct(2 * dA, dB);
+    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
+  }
+}
+
+#endif
+
+#ifdef EIGEN_TEST_PART_2
+
+// simply check that for a dense kronecker product, sparse module is not needed
+#include "main.h"
+#include <Eigen/KroneckerProduct>
+
+EIGEN_DECLARE_TEST(kronecker_product) {
+  MatrixXd a(2, 2), b(3, 3), c;
+  a.setRandom();
+  b.setRandom();
+  c = kroneckerProduct(a, b);
+  VERIFY_IS_APPROX(c.block(3, 3, 3, 3), a(1, 1) * b);
+}
+
+#endif
diff --git a/contrib/test/levenberg_marquardt.cpp b/contrib/test/levenberg_marquardt.cpp
new file mode 100644
index 0000000..02e717c
--- /dev/null
+++ b/contrib/test/levenberg_marquardt.cpp
@@ -0,0 +1,1014 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// Copyright (C) 2012 desire Nuentsa <desire.nuentsa_wakam@inria.fr
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// FIXME: These tests all check for hard-coded values. Ideally, parameters and start estimates should be randomized.
+
+#include <stdio.h>
+
+#include "main.h"
+#include <contrib/Eigen/LevenbergMarquardt>
+
+// This disables some useless Warnings on MSVC.
+// It is intended to be done for this test only.
+#include <Eigen/src/Core/util/DisableStupidWarnings.h>
+
+using std::sqrt;
+
+using LmFunctorBase = DenseFunctor<double>;
+#include "lm_test_functors.h"
+
+// tolerance for checking number of iterations
+#define LM_EVAL_COUNT_TOL 2
+
+void testLmder1() {
+  int n = 3, info;
+
+  VectorXd x;
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmder_functor functor;
+  LevenbergMarquardt<lmder_functor> lm(functor);
+  info = lm.lmder1(x);
+  EIGEN_UNUSED_VARIABLE(info);  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 6);
+  // VERIFY_IS_EQUAL(lm.njev(), 5);
+
+  // check norm
+  VERIFY_IS_APPROX(lm.fvec().blueNorm(), 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testLmder() {
+  const int m = 15, n = 3;
+  int info;
+  double fnorm, covfac;
+  VectorXd x;
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmder_functor functor;
+  LevenbergMarquardt<lmder_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return values
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 6);
+  // VERIFY_IS_EQUAL(lm.njev(), 5);
+
+  // check norm
+  fnorm = lm.fvec().blueNorm();
+  VERIFY_IS_APPROX(fnorm, 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+
+  // check covariance
+  covfac = fnorm * fnorm / (m - n);
+  internal::covar(lm.matrixR(), lm.permutation().indices());  // TODO : move this as a function of lm
+
+  MatrixXd cov_ref(n, n);
+  cov_ref << 0.0001531202, 0.002869941, -0.002656662, 0.002869941, 0.09480935, -0.09098995, -0.002656662, -0.09098995,
+      0.08778727;
+
+  //  std::cout << fjac*covfac << std::endl;
+
+  MatrixXd cov;
+  cov = covfac * lm.matrixR().topLeftCorner<n, n>();
+  VERIFY_IS_APPROX(cov, cov_ref);
+  // TODO: why isn't this allowed ? :
+  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
+}
+
+void testLmdif1() {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n), fvec(15);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmdif_functor functor;
+  DenseIndex nfev;
+  info = LevenbergMarquardt<lmdif_functor>::lmdif1(functor, x, &nfev);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  //   VERIFY_IS_EQUAL(nfev, 26);
+
+  // check norm
+  functor(x, fvec);
+  VERIFY_IS_APPROX(fvec.blueNorm(), 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.0824106, 1.1330366, 2.3436947;
+  VERIFY_IS_APPROX(x, x_ref);
+}
+
+void testLmdif() {
+  const int m = 15, n = 3;
+  int info;
+  double fnorm, covfac;
+  VectorXd x(n);
+
+  /* the following starting values provide a rough fit. */
+  x.setConstant(n, 1.);
+
+  // do the computation
+  lmdif_functor functor;
+  NumericalDiff<lmdif_functor> numDiff(functor);
+  LevenbergMarquardt<NumericalDiff<lmdif_functor> > lm(numDiff);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return values
+  // VERIFY_IS_EQUAL(info, 1);
+  //   VERIFY_IS_EQUAL(lm.nfev(), 26);
+
+  // check norm
+  fnorm = lm.fvec().blueNorm();
+  VERIFY_IS_APPROX(fnorm, 0.09063596);
+
+  // check x
+  VectorXd x_ref(n);
+  x_ref << 0.08241058, 1.133037, 2.343695;
+  VERIFY_IS_APPROX(x, x_ref);
+
+  // check covariance
+  covfac = fnorm * fnorm / (m - n);
+  internal::covar(lm.matrixR(), lm.permutation().indices());  // TODO : move this as a function of lm
+
+  MatrixXd cov_ref(n, n);
+  cov_ref << 0.0001531202, 0.002869942, -0.002656662, 0.002869942, 0.09480937, -0.09098997, -0.002656662, -0.09098997,
+      0.08778729;
+
+  //  std::cout << fjac*covfac << std::endl;
+
+  MatrixXd cov;
+  cov = covfac * lm.matrixR().topLeftCorner<n, n>();
+  VERIFY_IS_APPROX(cov, cov_ref);
+  // TODO: why isn't this allowed ? :
+  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/chwirut2.shtml
+void testNistChwirut2(void) {
+  const int n = 3;
+  LevenbergMarquardtSpace::Status info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 0.1, 0.01, 0.02;
+  // do the computation
+  chwirut2_functor functor;
+  LevenbergMarquardt<chwirut2_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  //   VERIFY_IS_EQUAL(lm.nfev(), 10);
+  // VERIFY_IS_EQUAL(lm.njev(), 8);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.1304802941E+02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
+  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
+  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
+
+  /*
+   * Second try
+   */
+  x << 0.15, 0.008, 0.010;
+  // do the computation
+  lm.resetParameters();
+  lm.setFtol(1.E6 * NumTraits<double>::epsilon());
+  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  //   VERIFY_IS_EQUAL(lm.nfev(), 7);
+  // VERIFY_IS_EQUAL(lm.njev(), 6);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.1304802941E+02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
+  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
+  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/misra1a.shtml
+void testNistMisra1a(void) {
+  const int n = 2;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 500., 0.0001;
+  // do the computation
+  misra1a_functor functor;
+  LevenbergMarquardt<misra1a_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 19);
+  // VERIFY_IS_EQUAL(lm.njev(), 15);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.2455138894E-01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
+  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
+
+  /*
+   * Second try
+   */
+  x << 250., 0.0005;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 5);
+  // VERIFY_IS_EQUAL(lm.njev(), 4);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.2455138894E-01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
+  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/hahn1.shtml
+void testNistHahn1(void) {
+  const int n = 7;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 10., -1., .05, -.00001, -.05, .001, -.000001;
+  // do the computation
+  hahn1_functor functor;
+  LevenbergMarquardt<hahn1_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 11);
+  // VERIFY_IS_EQUAL(lm.njev(), 10);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.5324382854E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.0776351733E+00);
+  VERIFY_IS_APPROX(x[1], -1.2269296921E-01);
+  VERIFY_IS_APPROX(x[2], 4.0863750610E-03);
+  VERIFY_IS_APPROX(x[3], -1.426264e-06);  // should be : -1.4262662514E-06
+  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
+  VERIFY_IS_APPROX(x[5], 2.4053735503E-04);
+  VERIFY_IS_APPROX(x[6], -1.2314450199E-07);
+
+  /*
+   * Second try
+   */
+  x << .1, -.1, .005, -.000001, -.005, .0001, -.0000001;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  //   VERIFY_IS_EQUAL(lm.nfev(), 11);
+  // VERIFY_IS_EQUAL(lm.njev(), 10);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.5324382854E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.077640);       // should be :  1.0776351733E+00
+  VERIFY_IS_APPROX(x[1], -0.1226933);     // should be : -1.2269296921E-01
+  VERIFY_IS_APPROX(x[2], 0.004086383);    // should be : 4.0863750610E-03
+  VERIFY_IS_APPROX(x[3], -1.426277e-06);  // should be : -1.4262662514E-06
+  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
+  VERIFY_IS_APPROX(x[5], 0.00024053772);  // should be : 2.4053735503E-04
+  VERIFY_IS_APPROX(x[6], -1.231450e-07);  // should be : -1.2314450199E-07
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/misra1d.shtml
+void testNistMisra1d(void) {
+  const int n = 2;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 500., 0.0001;
+  // do the computation
+  misra1d_functor functor;
+  LevenbergMarquardt<misra1d_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 9);
+  // VERIFY_IS_EQUAL(lm.njev(), 7);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6419295283E-02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
+  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
+
+  /*
+   * Second try
+   */
+  x << 450., 0.0003;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 4);
+  // VERIFY_IS_EQUAL(lm.njev(), 3);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6419295283E-02);
+  // check x
+  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
+  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/lanczos1.shtml
+void testNistLanczos1(void) {
+  const int n = 6;
+  LevenbergMarquardtSpace::Status info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1.2, 0.3, 5.6, 5.5, 6.5, 7.6;
+  // do the computation
+  lanczos1_functor functor;
+  LevenbergMarquardt<lanczos1_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeErrorTooSmall);
+  // VERIFY_IS_EQUAL(lm.nfev(), 79);
+  // VERIFY_IS_EQUAL(lm.njev(), 72);
+  // check norm^2
+  VERIFY(lm.fvec().squaredNorm() <= 1.44E-25);
+  // check x
+  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
+  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
+  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
+  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
+  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
+  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
+
+  /*
+   * Second try
+   */
+  x << 0.5, 0.7, 3.6, 4.2, 4., 6.3;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeErrorTooSmall);
+  // VERIFY_IS_EQUAL(lm.nfev(), 9);
+  // VERIFY_IS_EQUAL(lm.njev(), 8);
+  // check norm^2
+  VERIFY(lm.fvec().squaredNorm() <= 1.44E-25);
+  // check x
+  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
+  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
+  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
+  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
+  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
+  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky2.shtml
+void testNistRat42(void) {
+  const int n = 3;
+  LevenbergMarquardtSpace::Status info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 100., 1., 0.1;
+  // do the computation
+  rat42_functor functor;
+  LevenbergMarquardt<rat42_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
+  // VERIFY_IS_EQUAL(lm.nfev(), 10);
+  // VERIFY_IS_EQUAL(lm.njev(), 8);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.0565229338E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
+  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
+  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
+
+  /*
+   * Second try
+   */
+  x << 75., 2.5, 0.07;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
+  // VERIFY_IS_EQUAL(lm.nfev(), 6);
+  // VERIFY_IS_EQUAL(lm.njev(), 5);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.0565229338E+00);
+  // check x
+  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
+  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
+  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/mgh10.shtml
+void testNistMGH10(void) {
+  const int n = 3;
+  LevenbergMarquardtSpace::Status info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 2., 400000., 25000.;
+  // do the computation
+  MGH10_functor functor;
+  LevenbergMarquardt<MGH10_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);  // ++g_test_level;
+  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
+  // --g_test_level;
+  // was: VERIFY_IS_EQUAL(info, 1);
+
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7945855171E+01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
+  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
+  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
+
+  // check return value
+
+  // ++g_test_level;
+  // VERIFY_IS_EQUAL(lm.nfev(), 284 );
+  // VERIFY_IS_EQUAL(lm.njev(), 249 );
+  // --g_test_level;
+  VERIFY(lm.nfev() < 284 * LM_EVAL_COUNT_TOL);
+  VERIFY(lm.njev() < 249 * LM_EVAL_COUNT_TOL);
+
+  /*
+   * Second try
+   */
+  x << 0.02, 4000., 250.;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);  // ++g_test_level;
+  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
+  // // was: VERIFY_IS_EQUAL(info, 1);
+  // --g_test_level;
+
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7945855171E+01);
+  // check x
+  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
+  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
+  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
+
+  // check return value
+  // ++g_test_level;
+  // VERIFY_IS_EQUAL(lm.nfev(), 126);
+  // VERIFY_IS_EQUAL(lm.njev(), 116);
+  // --g_test_level;
+  VERIFY(lm.nfev() < 126 * LM_EVAL_COUNT_TOL);
+  VERIFY(lm.njev() < 116 * LM_EVAL_COUNT_TOL);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/boxbod.shtml
+void testNistBoxBOD(void) {
+  const int n = 2;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1., 1.;
+  // do the computation
+  BoxBOD_functor functor;
+  LevenbergMarquardt<BoxBOD_functor> lm(functor);
+  lm.setFtol(1.E6 * NumTraits<double>::epsilon());
+  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
+  lm.setFactor(10);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.1680088766E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
+  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
+
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY(lm.nfev() < 31); // 31
+  // VERIFY(lm.njev() < 25); // 25
+
+  /*
+   * Second try
+   */
+  x << 100., 0.75;
+  // do the computation
+  lm.resetParameters();
+  lm.setFtol(NumTraits<double>::epsilon());
+  lm.setXtol(NumTraits<double>::epsilon());
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // ++g_test_level;
+  // VERIFY_IS_EQUAL(lm.nfev(), 16 );
+  // VERIFY_IS_EQUAL(lm.njev(), 15 );
+  // --g_test_level;
+  VERIFY(lm.nfev() < 16 * LM_EVAL_COUNT_TOL);
+  VERIFY(lm.njev() < 15 * LM_EVAL_COUNT_TOL);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.1680088766E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
+  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/mgh17.shtml
+void testNistMGH17(void) {
+  const int n = 5;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 50., 150., -100., 1., 2.;
+  // do the computation
+  MGH17_functor functor;
+  LevenbergMarquardt<MGH17_functor> lm(functor);
+  lm.setFtol(NumTraits<double>::epsilon());
+  lm.setXtol(NumTraits<double>::epsilon());
+  lm.setMaxfev(1000);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.4648946975E-05);
+  // check x
+  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
+  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
+  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
+  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
+  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
+
+  // check return value
+  //   VERIFY_IS_EQUAL(info, 2);  //FIXME Use (lm.info() == Success)
+  // VERIFY(lm.nfev() < 700 ); // 602
+  // VERIFY(lm.njev() < 600 ); // 545
+
+  /*
+   * Second try
+   */
+  x << 0.5, 1.5, -1, 0.01, 0.02;
+  // do the computation
+  lm.resetParameters();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 18);
+  // VERIFY_IS_EQUAL(lm.njev(), 15);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.4648946975E-05);
+  // check x
+  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
+  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
+  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
+  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
+  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/mgh09.shtml
+void testNistMGH09(void) {
+  const int n = 4;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 25., 39, 41.5, 39.;
+  // do the computation
+  MGH09_functor functor;
+  LevenbergMarquardt<MGH09_functor> lm(functor);
+  lm.setMaxfev(1000);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 3.0750560385E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], 0.1928077089);   // should be 1.9280693458E-01
+  VERIFY_IS_APPROX(x[1], 0.19126423573);  // should be 1.9128232873E-01
+  VERIFY_IS_APPROX(x[2], 0.12305309914);  // should be 1.2305650693E-01
+  VERIFY_IS_APPROX(x[3], 0.13605395375);  // should be 1.3606233068E-01
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY(lm.nfev() < 510 ); // 490
+  // VERIFY(lm.njev() < 400 ); // 376
+
+  /*
+   * Second try
+   */
+  x << 0.25, 0.39, 0.415, 0.39;
+  // do the computation
+  lm.resetParameters();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 18);
+  // VERIFY_IS_EQUAL(lm.njev(), 16);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 3.0750560385E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], 0.19280781);  // should be 1.9280693458E-01
+  VERIFY_IS_APPROX(x[1], 0.19126265);  // should be 1.9128232873E-01
+  VERIFY_IS_APPROX(x[2], 0.12305280);  // should be 1.2305650693E-01
+  VERIFY_IS_APPROX(x[3], 0.13605322);  // should be 1.3606233068E-01
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/bennett5.shtml
+void testNistBennett5(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << -2000., 50., 0.8;
+  // do the computation
+  Bennett5_functor functor;
+  LevenbergMarquardt<Bennett5_functor> lm(functor);
+  lm.setMaxfev(1000);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 758);
+  // VERIFY_IS_EQUAL(lm.njev(), 744);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.2404744073E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], -2.5235058043E+03);
+  VERIFY_IS_APPROX(x[1], 4.6736564644E+01);
+  VERIFY_IS_APPROX(x[2], 9.3218483193E-01);
+  /*
+   * Second try
+   */
+  x << -1500., 45., 0.85;
+  // do the computation
+  lm.resetParameters();
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 203);
+  // VERIFY_IS_EQUAL(lm.njev(), 192);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.2404744073E-04);
+  // check x
+  VERIFY_IS_APPROX(x[0], -2523.3007865);  // should be -2.5235058043E+03
+  VERIFY_IS_APPROX(x[1], 46.735705771);   // should be 4.6736564644E+01);
+  VERIFY_IS_APPROX(x[2], 0.93219881891);  // should be 9.3218483193E-01);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/thurber.shtml
+void testNistThurber(void) {
+  const int n = 7;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1000, 1000, 400, 40, 0.7, 0.3, 0.0;
+  // do the computation
+  thurber_functor functor;
+  LevenbergMarquardt<thurber_functor> lm(functor);
+  lm.setFtol(1.E4 * NumTraits<double>::epsilon());
+  lm.setXtol(1.E4 * NumTraits<double>::epsilon());
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 39);
+  // VERIFY_IS_EQUAL(lm.njev(), 36);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6427082397E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
+  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
+  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
+  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
+  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
+  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
+  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
+
+  /*
+   * Second try
+   */
+  x << 1300, 1500, 500, 75, 1, 0.4, 0.05;
+  // do the computation
+  lm.resetParameters();
+  lm.setFtol(1.E4 * NumTraits<double>::epsilon());
+  lm.setXtol(1.E4 * NumTraits<double>::epsilon());
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 29);
+  // VERIFY_IS_EQUAL(lm.njev(), 28);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6427082397E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
+  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
+  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
+  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
+  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
+  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
+  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky3.shtml
+void testNistRat43(void) {
+  const int n = 4;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 100., 10., 1., 1.;
+  // do the computation
+  rat43_functor functor;
+  LevenbergMarquardt<rat43_functor> lm(functor);
+  lm.setFtol(1.E6 * NumTraits<double>::epsilon());
+  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 27);
+  // VERIFY_IS_EQUAL(lm.njev(), 20);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7864049080E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
+  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
+  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
+  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
+
+  /*
+   * Second try
+   */
+  x << 700., 5., 0.75, 1.3;
+  // do the computation
+  lm.resetParameters();
+  lm.setFtol(1.E5 * NumTraits<double>::epsilon());
+  lm.setXtol(1.E5 * NumTraits<double>::epsilon());
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 9);
+  // VERIFY_IS_EQUAL(lm.njev(), 8);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7864049080E+03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
+  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
+  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
+  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
+}
+
+// http://www.itl.nist.gov/div898/strd/nls/data/eckerle4.shtml
+void testNistEckerle4(void) {
+  const int n = 3;
+  int info;
+
+  VectorXd x(n);
+
+  /*
+   * First try
+   */
+  x << 1., 10., 500.;
+  // do the computation
+  eckerle4_functor functor;
+  LevenbergMarquardt<eckerle4_functor> lm(functor);
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 18);
+  // VERIFY_IS_EQUAL(lm.njev(), 15);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.4635887487E-03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.5543827178);
+  VERIFY_IS_APPROX(x[1], 4.0888321754);
+  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
+
+  /*
+   * Second try
+   */
+  x << 1.5, 5., 450.;
+  // do the computation
+  info = lm.minimize(x);
+  EIGEN_UNUSED_VARIABLE(info);
+  // check return value
+  // VERIFY_IS_EQUAL(info, 1);
+  // VERIFY_IS_EQUAL(lm.nfev(), 7);
+  // VERIFY_IS_EQUAL(lm.njev(), 6);
+  // check norm^2
+  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.4635887487E-03);
+  // check x
+  VERIFY_IS_APPROX(x[0], 1.5543827178);
+  VERIFY_IS_APPROX(x[1], 4.0888321754);
+  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
+}
+
+// lmqrsolv() must minimize ||[R; D] z - [qtb; 0]|| and leave the eliminated
+// factor in the strict lower triangle of s for lmpar2(). Issue #657: the QR is
+// rank-revealing, so R carries zeros above the diagonal, and the Givens
+// rotation that eliminates a row of D acts on the whole row: it rotates sdiag
+// against those zeros and fills them in.
+void testLmqrsolv() {
+  const Index n = 6;
+
+  // An upper triangular factor with zeros above the diagonal.
+  MatrixXd r = MatrixXd::Zero(n, n);
+  for (Index i = 0; i < n; ++i)
+    for (Index j = i; j < n; ++j)
+      r(i, j) = ((i == 0 && j == 3) || (i == 1 && j == 4)) ? 0.0 : 1.0 + 0.5 * double(i + 1) * double(j + 1);
+
+  VectorXd diag(n), qtb(n);
+  for (Index i = 0; i < n; ++i) {
+    diag(i) = 0.5 + 0.25 * double(i);
+    qtb(i) = 1.0 - 0.3 * double(i);
+  }
+
+  PermutationMatrix<Dynamic, Dynamic, int> perm(n);
+  perm.setIdentity();
+
+  MatrixXd s = r;
+  VectorXd x(n), sdiag(n);
+  internal::lmqrsolv(s, perm, diag, qtb, x, sdiag);
+
+  MatrixXd augmented(2 * n, n);
+  augmented.topRows(n) = r;
+  augmented.bottomRows(n) = diag.asDiagonal();
+  VectorXd rhs = VectorXd::Zero(2 * n);
+  rhs.head(n) = qtb;
+  VERIFY_IS_APPROX(x, augmented.colPivHouseholderQr().solve(rhs));
+
+  // The upper triangle and the diagonal of s are restored. lmpar2() reads the
+  // eliminated factor S out of the strict lower triangle of s, transposed, with
+  // its diagonal in sdiag; S is the triangular factor of [R; D].
+  VERIFY_IS_APPROX(MatrixXd(s.triangularView<Upper>()), r);
+  MatrixXd eliminated = MatrixXd(s.triangularView<StrictlyLower>()).transpose();
+  eliminated.diagonal() = sdiag;
+  VERIFY_IS_APPROX(MatrixXd(eliminated.transpose() * eliminated),
+                   MatrixXd(r.transpose() * r + MatrixXd(diag.cwiseAbs2().asDiagonal())));
+}
+
+// Exponential decay with two exactly collinear offsets x2 and x3, so the
+// Jacobian is rank deficient and the triangular factor of its sparse QR loses
+// its last diagonal entry. Issue #657: the sparse solver then asserted inside
+// Eigen::internal::sparse_solve_triangular_selector.
+struct collinear_offsets_functor : SparseFunctor<double, int> {
+  collinear_offsets_functor(int m) : SparseFunctor<double, int>(4, m), m_t(m), m_y(m) {
+    for (int i = 0; i < m; ++i) {
+      m_t(i) = 0.05 * i;
+      m_y(i) = 2.5 * std::exp(-0.7 * m_t(i)) + 0.3;
+    }
+  }
+  int operator()(const VectorXd &x, VectorXd &fvec) {
+    for (int i = 0; i < values(); ++i) fvec(i) = x(0) * std::exp(-x(1) * m_t(i)) + x(2) + x(3) - m_y(i);
+    return 0;
+  }
+  int df(const VectorXd &x, JacobianType &jac) {
+    std::vector<Triplet<double> > triplets;
+    for (int i = 0; i < values(); ++i) {
+      const double e = std::exp(-x(1) * m_t(i));
+      triplets.push_back(Triplet<double>(i, 0, e));
+      triplets.push_back(Triplet<double>(i, 1, -x(0) * m_t(i) * e));
+      triplets.push_back(Triplet<double>(i, 2, 1.0));
+      triplets.push_back(Triplet<double>(i, 3, 1.0));
+    }
+    jac.resize(values(), inputs());
+    jac.setFromTriplets(triplets.begin(), triplets.end());
+    return 0;
+  }
+  VectorXd m_t, m_y;
+};
+
+void testSparseFunctor() {
+  collinear_offsets_functor functor(30);
+  LevenbergMarquardt<collinear_offsets_functor> lm(functor);
+  VectorXd x(4);
+  x << 5.0, 5.0, 5.0, 5.0;
+  const LevenbergMarquardtSpace::Status info = lm.minimize(x);
+  VERIFY(info > LevenbergMarquardtSpace::ImproperInputParameters &&
+         info < LevenbergMarquardtSpace::TooManyFunctionEvaluation);
+
+  // x2 and x3 are determined only through their sum.
+  VERIFY_IS_APPROX(x(0), 2.5);
+  VERIFY_IS_APPROX(x(1), 0.7);
+  VERIFY_IS_APPROX(x(2) + x(3), 0.3);
+  VERIFY(lm.fnorm() <= 1e3 * NumTraits<double>::epsilon() * functor.m_y.norm());
+}
+
+EIGEN_DECLARE_TEST(levenberg_marquardt) {
+  CALL_SUBTEST(testLmqrsolv());
+  CALL_SUBTEST(testSparseFunctor());
+
+  // Tests using the examples provided by (c)minpack
+  CALL_SUBTEST(testLmder1());
+  CALL_SUBTEST(testLmder());
+  CALL_SUBTEST(testLmdif1());
+  //     CALL_SUBTEST(testLmstr1());
+  //     CALL_SUBTEST(testLmstr());
+  CALL_SUBTEST(testLmdif());
+
+  // NIST tests, level of difficulty = "Lower"
+  CALL_SUBTEST(testNistMisra1a());
+  CALL_SUBTEST(testNistChwirut2());
+
+  // NIST tests, level of difficulty = "Average"
+  CALL_SUBTEST(testNistHahn1());
+  CALL_SUBTEST(testNistMisra1d());
+  CALL_SUBTEST(testNistMGH17());
+  CALL_SUBTEST(testNistLanczos1());
+
+  //     // NIST tests, level of difficulty = "Higher"
+  CALL_SUBTEST(testNistRat42());
+  CALL_SUBTEST(testNistMGH10());
+  CALL_SUBTEST(testNistBoxBOD());
+  //     CALL_SUBTEST(testNistMGH09());
+  CALL_SUBTEST(testNistBennett5());
+  CALL_SUBTEST(testNistThurber());
+  CALL_SUBTEST(testNistRat43());
+  CALL_SUBTEST(testNistEckerle4());
+}
diff --git a/contrib/test/lm_test_functors.h b/contrib/test/lm_test_functors.h
new file mode 100644
index 0000000..8130eda
--- /dev/null
+++ b/contrib/test/lm_test_functors.h
@@ -0,0 +1,619 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_LM_TEST_FUNCTORS_H
+#define EIGEN_TEST_LM_TEST_FUNCTORS_H
+
+// Residual functors for the MINPACK examples and the NIST StRD nonlinear regression problems, shared by
+// NonLinearOptimization.cpp and levenberg_marquardt.cpp. The including file defines LmFunctorBase as the
+// functor base class of the module under test; both modules define Eigen::LevenbergMarquardt, so this
+// header includes neither.
+
+struct lmder_functor : LmFunctorBase {
+  lmder_functor(void) : LmFunctorBase(3, 15) {}
+  int operator()(const VectorXd &x, VectorXd &fvec) const {
+    double tmp1, tmp2, tmp3;
+    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
+                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
+
+    for (int i = 0; i < values(); i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+      tmp3 = (i >= 8) ? tmp2 : tmp1;
+      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
+    }
+    return 0;
+  }
+
+  int df(const VectorXd &x, MatrixXd &fjac) const {
+    double tmp1, tmp2, tmp3, tmp4;
+    for (int i = 0; i < values(); i++) {
+      tmp1 = i + 1;
+      tmp2 = 16 - i - 1;
+      tmp3 = (i >= 8) ? tmp2 : tmp1;
+      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
+      tmp4 = tmp4 * tmp4;
+      fjac(i, 0) = -1;
+      fjac(i, 1) = tmp1 * tmp2 / tmp4;
+      fjac(i, 2) = tmp1 * tmp3 / tmp4;
+    }
+    return 0;
+  }
+};
+
+struct lmdif_functor : LmFunctorBase {
+  lmdif_functor(void) : LmFunctorBase(3, 15) {}
+  int operator()(const VectorXd &x, VectorXd &fvec) const {
+    int i;
+    double tmp1, tmp2, tmp3;
+    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
+                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34e0, 2.1e0,  4.39e0};
+
+    assert(x.size() == 3);
+    assert(fvec.size() == 15);
+    for (i = 0; i < 15; i++) {
+      tmp1 = i + 1;
+      tmp2 = 15 - i;
+      tmp3 = tmp1;
+
+      if (i >= 8) tmp3 = tmp2;
+      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
+    }
+    return 0;
+  }
+};
+
+struct chwirut2_functor : LmFunctorBase {
+  chwirut2_functor(void) : LmFunctorBase(3, 54) {}
+  static const double m_x[54];
+  static const double m_y[54];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    int i;
+
+    assert(b.size() == 3);
+    assert(fvec.size() == 54);
+    for (i = 0; i < 54; i++) {
+      double x = m_x[i];
+      fvec[i] = exp(-b[0] * x) / (b[1] + b[2] * x) - m_y[i];
+    }
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 3);
+    assert(fjac.rows() == 54);
+    assert(fjac.cols() == 3);
+    for (int i = 0; i < 54; i++) {
+      double x = m_x[i];
+      double factor = 1. / (b[1] + b[2] * x);
+      double e = exp(-b[0] * x);
+      fjac(i, 0) = -x * e * factor;
+      fjac(i, 1) = -e * factor * factor;
+      fjac(i, 2) = -x * e * factor * factor;
+    }
+    return 0;
+  }
+};
+const double chwirut2_functor::m_x[54] = {
+    0.500E0, 1.000E0, 1.750E0, 3.750E0, 5.750E0, 0.875E0, 2.250E0, 3.250E0, 5.250E0, 0.750E0, 1.750E0,
+    2.750E0, 4.750E0, 0.625E0, 1.250E0, 2.250E0, 4.250E0, .500E0,  3.000E0, .750E0,  3.000E0, 1.500E0,
+    6.000E0, 3.000E0, 6.000E0, 1.500E0, 3.000E0, .500E0,  2.000E0, 4.000E0, .750E0,  2.000E0, 5.000E0,
+    .750E0,  2.250E0, 3.750E0, 5.750E0, 3.000E0, .750E0,  2.500E0, 4.000E0, .750E0,  2.500E0, 4.000E0,
+    .750E0,  2.500E0, 4.000E0, .500E0,  6.000E0, 3.000E0, .500E0,  2.750E0, .500E0,  1.750E0};
+const double chwirut2_functor::m_y[54] = {
+    92.9000E0, 57.1000E0, 31.0500E0, 11.5875E0, 8.0250E0,  63.6000E0, 21.4000E0, 14.2500E0, 8.4750E0,
+    63.8000E0, 26.8000E0, 16.4625E0, 7.1250E0,  67.3000E0, 41.0000E0, 21.1500E0, 8.1750E0,  81.5000E0,
+    13.1200E0, 59.9000E0, 14.6200E0, 32.9000E0, 5.4400E0,  12.5600E0, 5.4400E0,  32.0000E0, 13.9500E0,
+    75.8000E0, 20.0000E0, 10.4200E0, 59.5000E0, 21.6700E0, 8.5500E0,  62.0000E0, 20.2000E0, 7.7600E0,
+    3.7500E0,  11.8100E0, 54.7000E0, 23.7000E0, 11.5500E0, 61.3000E0, 17.7000E0, 8.7400E0,  59.2000E0,
+    16.3000E0, 8.6200E0,  81.0000E0, 4.8700E0,  14.6200E0, 81.7000E0, 17.1700E0, 81.3000E0, 28.9000E0};
+
+struct misra1a_functor : LmFunctorBase {
+  misra1a_functor(void) : LmFunctorBase(2, 14) {}
+  static const double m_x[14];
+  static const double m_y[14];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 2);
+    assert(fvec.size() == 14);
+    for (int i = 0; i < 14; i++) {
+      fvec[i] = b[0] * (1. - exp(-b[1] * m_x[i])) - m_y[i];
+    }
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 2);
+    assert(fjac.rows() == 14);
+    assert(fjac.cols() == 2);
+    for (int i = 0; i < 14; i++) {
+      fjac(i, 0) = (1. - exp(-b[1] * m_x[i]));
+      fjac(i, 1) = (b[0] * m_x[i] * exp(-b[1] * m_x[i]));
+    }
+    return 0;
+  }
+};
+const double misra1a_functor::m_x[14] = {77.6E0,  114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0,
+                                         378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0};
+const double misra1a_functor::m_y[14] = {10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0,
+                                         44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0};
+
+struct hahn1_functor : LmFunctorBase {
+  hahn1_functor(void) : LmFunctorBase(7, 236) {}
+  static const double m_x[236];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    static const double m_y[236] = {
+        .591E0,   1.547E0,  2.902E0,  2.894E0,  4.703E0,  6.307E0,  7.03E0,   7.898E0,  9.470E0,  9.484E0,  10.072E0,
+        10.163E0, 11.615E0, 12.005E0, 12.478E0, 12.982E0, 12.970E0, 13.926E0, 14.452E0, 14.404E0, 15.190E0, 15.550E0,
+        15.528E0, 15.499E0, 16.131E0, 16.438E0, 16.387E0, 16.549E0, 16.872E0, 16.830E0, 16.926E0, 16.907E0, 16.966E0,
+        17.060E0, 17.122E0, 17.311E0, 17.355E0, 17.668E0, 17.767E0, 17.803E0, 17.765E0, 17.768E0, 17.736E0, 17.858E0,
+        17.877E0, 17.912E0, 18.046E0, 18.085E0, 18.291E0, 18.357E0, 18.426E0, 18.584E0, 18.610E0, 18.870E0, 18.795E0,
+        19.111E0, .367E0,   .796E0,   0.892E0,  1.903E0,  2.150E0,  3.697E0,  5.870E0,  6.421E0,  7.422E0,  9.944E0,
+        11.023E0, 11.87E0,  12.786E0, 14.067E0, 13.974E0, 14.462E0, 14.464E0, 15.381E0, 15.483E0, 15.59E0,  16.075E0,
+        16.347E0, 16.181E0, 16.915E0, 17.003E0, 16.978E0, 17.756E0, 17.808E0, 17.868E0, 18.481E0, 18.486E0, 19.090E0,
+        16.062E0, 16.337E0, 16.345E0, 16.388E0, 17.159E0, 17.116E0, 17.164E0, 17.123E0, 17.979E0, 17.974E0, 18.007E0,
+        17.993E0, 18.523E0, 18.669E0, 18.617E0, 19.371E0, 19.330E0, 0.080E0,  0.248E0,  1.089E0,  1.418E0,  2.278E0,
+        3.624E0,  4.574E0,  5.556E0,  7.267E0,  7.695E0,  9.136E0,  9.959E0,  9.957E0,  11.600E0, 13.138E0, 13.564E0,
+        13.871E0, 13.994E0, 14.947E0, 15.473E0, 15.379E0, 15.455E0, 15.908E0, 16.114E0, 17.071E0, 17.135E0, 17.282E0,
+        17.368E0, 17.483E0, 17.764E0, 18.185E0, 18.271E0, 18.236E0, 18.237E0, 18.523E0, 18.627E0, 18.665E0, 19.086E0,
+        0.214E0,  0.943E0,  1.429E0,  2.241E0,  2.951E0,  3.782E0,  4.757E0,  5.602E0,  7.169E0,  8.920E0,  10.055E0,
+        12.035E0, 12.861E0, 13.436E0, 14.167E0, 14.755E0, 15.168E0, 15.651E0, 15.746E0, 16.216E0, 16.445E0, 16.965E0,
+        17.121E0, 17.206E0, 17.250E0, 17.339E0, 17.793E0, 18.123E0, 18.49E0,  18.566E0, 18.645E0, 18.706E0, 18.924E0,
+        19.1E0,   0.375E0,  0.471E0,  1.504E0,  2.204E0,  2.813E0,  4.765E0,  9.835E0,  10.040E0, 11.946E0, 12.596E0,
+        13.303E0, 13.922E0, 14.440E0, 14.951E0, 15.627E0, 15.639E0, 15.814E0, 16.315E0, 16.334E0, 16.430E0, 16.423E0,
+        17.024E0, 17.009E0, 17.165E0, 17.134E0, 17.349E0, 17.576E0, 17.848E0, 18.090E0, 18.276E0, 18.404E0, 18.519E0,
+        19.133E0, 19.074E0, 19.239E0, 19.280E0, 19.101E0, 19.398E0, 19.252E0, 19.89E0,  20.007E0, 19.929E0, 19.268E0,
+        19.324E0, 20.049E0, 20.107E0, 20.062E0, 20.065E0, 19.286E0, 19.972E0, 20.088E0, 20.743E0, 20.83E0,  20.935E0,
+        21.035E0, 20.93E0,  21.074E0, 21.085E0, 20.935E0};
+
+    //        int called=0; printf("call hahn1_functor with  iflag=%d, called=%d\n", iflag, called); if (iflag==1)
+    //        called++;
+
+    assert(b.size() == 7);
+    assert(fvec.size() == 236);
+    for (int i = 0; i < 236; i++) {
+      double x = m_x[i], xx = x * x, xxx = xx * x;
+      fvec[i] = (b[0] + b[1] * x + b[2] * xx + b[3] * xxx) / (1. + b[4] * x + b[5] * xx + b[6] * xxx) - m_y[i];
+    }
+    return 0;
+  }
+
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 7);
+    assert(fjac.rows() == 236);
+    assert(fjac.cols() == 7);
+    for (int i = 0; i < 236; i++) {
+      double x = m_x[i], xx = x * x, xxx = xx * x;
+      double fact = 1. / (1. + b[4] * x + b[5] * xx + b[6] * xxx);
+      fjac(i, 0) = 1. * fact;
+      fjac(i, 1) = x * fact;
+      fjac(i, 2) = xx * fact;
+      fjac(i, 3) = xxx * fact;
+      fact = -(b[0] + b[1] * x + b[2] * xx + b[3] * xxx) * fact * fact;
+      fjac(i, 4) = x * fact;
+      fjac(i, 5) = xx * fact;
+      fjac(i, 6) = xxx * fact;
+    }
+    return 0;
+  }
+};
+const double hahn1_functor::m_x[236] = {
+    24.41E0,  34.82E0,  44.09E0,  45.07E0,  54.98E0,  65.51E0,  70.53E0,  75.70E0,  89.57E0,  91.14E0,  96.40E0,
+    97.19E0,  114.26E0, 120.25E0, 127.08E0, 133.55E0, 133.61E0, 158.67E0, 172.74E0, 171.31E0, 202.14E0, 220.55E0,
+    221.05E0, 221.39E0, 250.99E0, 268.99E0, 271.80E0, 271.97E0, 321.31E0, 321.69E0, 330.14E0, 333.03E0, 333.47E0,
+    340.77E0, 345.65E0, 373.11E0, 373.79E0, 411.82E0, 419.51E0, 421.59E0, 422.02E0, 422.47E0, 422.61E0, 441.75E0,
+    447.41E0, 448.7E0,  472.89E0, 476.69E0, 522.47E0, 522.62E0, 524.43E0, 546.75E0, 549.53E0, 575.29E0, 576.00E0,
+    625.55E0, 20.15E0,  28.78E0,  29.57E0,  37.41E0,  39.12E0,  50.24E0,  61.38E0,  66.25E0,  73.42E0,  95.52E0,
+    107.32E0, 122.04E0, 134.03E0, 163.19E0, 163.48E0, 175.70E0, 179.86E0, 211.27E0, 217.78E0, 219.14E0, 262.52E0,
+    268.01E0, 268.62E0, 336.25E0, 337.23E0, 339.33E0, 427.38E0, 428.58E0, 432.68E0, 528.99E0, 531.08E0, 628.34E0,
+    253.24E0, 273.13E0, 273.66E0, 282.10E0, 346.62E0, 347.19E0, 348.78E0, 351.18E0, 450.10E0, 450.35E0, 451.92E0,
+    455.56E0, 552.22E0, 553.56E0, 555.74E0, 652.59E0, 656.20E0, 14.13E0,  20.41E0,  31.30E0,  33.84E0,  39.70E0,
+    48.83E0,  54.50E0,  60.41E0,  72.77E0,  75.25E0,  86.84E0,  94.88E0,  96.40E0,  117.37E0, 139.08E0, 147.73E0,
+    158.63E0, 161.84E0, 192.11E0, 206.76E0, 209.07E0, 213.32E0, 226.44E0, 237.12E0, 330.90E0, 358.72E0, 370.77E0,
+    372.72E0, 396.24E0, 416.59E0, 484.02E0, 495.47E0, 514.78E0, 515.65E0, 519.47E0, 544.47E0, 560.11E0, 620.77E0,
+    18.97E0,  28.93E0,  33.91E0,  40.03E0,  44.66E0,  49.87E0,  55.16E0,  60.90E0,  72.08E0,  85.15E0,  97.06E0,
+    119.63E0, 133.27E0, 143.84E0, 161.91E0, 180.67E0, 198.44E0, 226.86E0, 229.65E0, 258.27E0, 273.77E0, 339.15E0,
+    350.13E0, 362.75E0, 371.03E0, 393.32E0, 448.53E0, 473.78E0, 511.12E0, 524.70E0, 548.75E0, 551.64E0, 574.02E0,
+    623.86E0, 21.46E0,  24.33E0,  33.43E0,  39.22E0,  44.18E0,  55.02E0,  94.33E0,  96.44E0,  118.82E0, 128.48E0,
+    141.94E0, 156.92E0, 171.65E0, 190.00E0, 223.26E0, 223.88E0, 231.50E0, 265.05E0, 269.44E0, 271.78E0, 273.46E0,
+    334.61E0, 339.79E0, 349.52E0, 358.18E0, 377.98E0, 394.77E0, 429.66E0, 468.22E0, 487.27E0, 519.54E0, 523.03E0,
+    612.99E0, 638.59E0, 641.36E0, 622.05E0, 631.50E0, 663.97E0, 646.9E0,  748.29E0, 749.21E0, 750.14E0, 647.04E0,
+    646.89E0, 746.9E0,  748.43E0, 747.35E0, 749.27E0, 647.61E0, 747.78E0, 750.51E0, 851.37E0, 845.97E0, 847.54E0,
+    849.93E0, 851.61E0, 849.75E0, 850.98E0, 848.23E0};
+
+struct misra1d_functor : LmFunctorBase {
+  misra1d_functor(void) : LmFunctorBase(2, 14) {}
+  static const double x[14];
+  static const double y[14];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 2);
+    assert(fvec.size() == 14);
+    for (int i = 0; i < 14; i++) {
+      fvec[i] = b[0] * b[1] * x[i] / (1. + b[1] * x[i]) - y[i];
+    }
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 2);
+    assert(fjac.rows() == 14);
+    assert(fjac.cols() == 2);
+    for (int i = 0; i < 14; i++) {
+      double den = 1. + b[1] * x[i];
+      fjac(i, 0) = b[1] * x[i] / den;
+      fjac(i, 1) = b[0] * x[i] * (den - b[1] * x[i]) / den / den;
+    }
+    return 0;
+  }
+};
+const double misra1d_functor::x[14] = {77.6E0,  114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0,
+                                       378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0};
+const double misra1d_functor::y[14] = {10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0,
+                                       44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0};
+
+struct lanczos1_functor : LmFunctorBase {
+  lanczos1_functor(void) : LmFunctorBase(6, 24) {}
+  static const double x[24];
+  static const double y[24];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 6);
+    assert(fvec.size() == 24);
+    for (int i = 0; i < 24; i++)
+      fvec[i] = b[0] * exp(-b[1] * x[i]) + b[2] * exp(-b[3] * x[i]) + b[4] * exp(-b[5] * x[i]) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 6);
+    assert(fjac.rows() == 24);
+    assert(fjac.cols() == 6);
+    for (int i = 0; i < 24; i++) {
+      fjac(i, 0) = exp(-b[1] * x[i]);
+      fjac(i, 1) = -b[0] * x[i] * exp(-b[1] * x[i]);
+      fjac(i, 2) = exp(-b[3] * x[i]);
+      fjac(i, 3) = -b[2] * x[i] * exp(-b[3] * x[i]);
+      fjac(i, 4) = exp(-b[5] * x[i]);
+      fjac(i, 5) = -b[4] * x[i] * exp(-b[5] * x[i]);
+    }
+    return 0;
+  }
+};
+const double lanczos1_functor::x[24] = {0.000000000000E+00, 5.000000000000E-02, 1.000000000000E-01, 1.500000000000E-01,
+                                        2.000000000000E-01, 2.500000000000E-01, 3.000000000000E-01, 3.500000000000E-01,
+                                        4.000000000000E-01, 4.500000000000E-01, 5.000000000000E-01, 5.500000000000E-01,
+                                        6.000000000000E-01, 6.500000000000E-01, 7.000000000000E-01, 7.500000000000E-01,
+                                        8.000000000000E-01, 8.500000000000E-01, 9.000000000000E-01, 9.500000000000E-01,
+                                        1.000000000000E+00, 1.050000000000E+00, 1.100000000000E+00, 1.150000000000E+00};
+const double lanczos1_functor::y[24] = {2.513400000000E+00, 2.044333373291E+00, 1.668404436564E+00, 1.366418021208E+00,
+                                        1.123232487372E+00, 9.268897180037E-01, 7.679338563728E-01, 6.388775523106E-01,
+                                        5.337835317402E-01, 4.479363617347E-01, 3.775847884350E-01, 3.197393199326E-01,
+                                        2.720130773746E-01, 2.324965529032E-01, 1.996589546065E-01, 1.722704126914E-01,
+                                        1.493405660168E-01, 1.300700206922E-01, 1.138119324644E-01, 1.000415587559E-01,
+                                        8.833209084540E-02, 7.833544019350E-02, 6.976693743449E-02, 6.239312536719E-02};
+
+struct rat42_functor : LmFunctorBase {
+  rat42_functor(void) : LmFunctorBase(3, 9) {}
+  static const double x[9];
+  static const double y[9];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 3);
+    assert(fvec.size() == 9);
+    for (int i = 0; i < 9; i++) {
+      fvec[i] = b[0] / (1. + exp(b[1] - b[2] * x[i])) - y[i];
+    }
+    return 0;
+  }
+
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 3);
+    assert(fjac.rows() == 9);
+    assert(fjac.cols() == 3);
+    for (int i = 0; i < 9; i++) {
+      double e = exp(b[1] - b[2] * x[i]);
+      fjac(i, 0) = 1. / (1. + e);
+      fjac(i, 1) = -b[0] * e / (1. + e) / (1. + e);
+      fjac(i, 2) = +b[0] * e * x[i] / (1. + e) / (1. + e);
+    }
+    return 0;
+  }
+};
+const double rat42_functor::x[9] = {9.000E0,  14.000E0, 21.000E0, 28.000E0, 42.000E0,
+                                    57.000E0, 63.000E0, 70.000E0, 79.000E0};
+const double rat42_functor::y[9] = {8.930E0,  10.800E0, 18.590E0, 22.330E0, 39.350E0,
+                                    56.110E0, 61.730E0, 64.620E0, 67.080E0};
+
+struct MGH10_functor : LmFunctorBase {
+  MGH10_functor(void) : LmFunctorBase(3, 16) {}
+  static const double x[16];
+  static const double y[16];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 3);
+    assert(fvec.size() == 16);
+    for (int i = 0; i < 16; i++) fvec[i] = b[0] * exp(b[1] / (x[i] + b[2])) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 3);
+    assert(fjac.rows() == 16);
+    assert(fjac.cols() == 3);
+    for (int i = 0; i < 16; i++) {
+      double factor = 1. / (x[i] + b[2]);
+      double e = exp(b[1] * factor);
+      fjac(i, 0) = e;
+      fjac(i, 1) = b[0] * factor * e;
+      fjac(i, 2) = -b[1] * b[0] * factor * factor * e;
+    }
+    return 0;
+  }
+};
+const double MGH10_functor::x[16] = {5.000000E+01, 5.500000E+01, 6.000000E+01, 6.500000E+01, 7.000000E+01, 7.500000E+01,
+                                     8.000000E+01, 8.500000E+01, 9.000000E+01, 9.500000E+01, 1.000000E+02, 1.050000E+02,
+                                     1.100000E+02, 1.150000E+02, 1.200000E+02, 1.250000E+02};
+const double MGH10_functor::y[16] = {3.478000E+04, 2.861000E+04, 2.365000E+04, 1.963000E+04, 1.637000E+04, 1.372000E+04,
+                                     1.154000E+04, 9.744000E+03, 8.261000E+03, 7.030000E+03, 6.005000E+03, 5.147000E+03,
+                                     4.427000E+03, 3.820000E+03, 3.307000E+03, 2.872000E+03};
+
+struct BoxBOD_functor : LmFunctorBase {
+  BoxBOD_functor(void) : LmFunctorBase(2, 6) {}
+  static const double x[6];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    static const double y[6] = {109., 149., 149., 191., 213., 224.};
+    assert(b.size() == 2);
+    assert(fvec.size() == 6);
+    for (int i = 0; i < 6; i++) fvec[i] = b[0] * (1. - exp(-b[1] * x[i])) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 2);
+    assert(fjac.rows() == 6);
+    assert(fjac.cols() == 2);
+    for (int i = 0; i < 6; i++) {
+      double e = exp(-b[1] * x[i]);
+      fjac(i, 0) = 1. - e;
+      fjac(i, 1) = b[0] * x[i] * e;
+    }
+    return 0;
+  }
+};
+const double BoxBOD_functor::x[6] = {1., 2., 3., 5., 7., 10.};
+
+struct MGH17_functor : LmFunctorBase {
+  MGH17_functor(void) : LmFunctorBase(5, 33) {}
+  static const double x[33];
+  static const double y[33];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 5);
+    assert(fvec.size() == 33);
+    for (int i = 0; i < 33; i++) fvec[i] = b[0] + b[1] * exp(-b[3] * x[i]) + b[2] * exp(-b[4] * x[i]) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 5);
+    assert(fjac.rows() == 33);
+    assert(fjac.cols() == 5);
+    for (int i = 0; i < 33; i++) {
+      fjac(i, 0) = 1.;
+      fjac(i, 1) = exp(-b[3] * x[i]);
+      fjac(i, 2) = exp(-b[4] * x[i]);
+      fjac(i, 3) = -x[i] * b[1] * exp(-b[3] * x[i]);
+      fjac(i, 4) = -x[i] * b[2] * exp(-b[4] * x[i]);
+    }
+    return 0;
+  }
+};
+const double MGH17_functor::x[33] = {0.000000E+00, 1.000000E+01, 2.000000E+01, 3.000000E+01, 4.000000E+01, 5.000000E+01,
+                                     6.000000E+01, 7.000000E+01, 8.000000E+01, 9.000000E+01, 1.000000E+02, 1.100000E+02,
+                                     1.200000E+02, 1.300000E+02, 1.400000E+02, 1.500000E+02, 1.600000E+02, 1.700000E+02,
+                                     1.800000E+02, 1.900000E+02, 2.000000E+02, 2.100000E+02, 2.200000E+02, 2.300000E+02,
+                                     2.400000E+02, 2.500000E+02, 2.600000E+02, 2.700000E+02, 2.800000E+02, 2.900000E+02,
+                                     3.000000E+02, 3.100000E+02, 3.200000E+02};
+const double MGH17_functor::y[33] = {8.440000E-01, 9.080000E-01, 9.320000E-01, 9.360000E-01, 9.250000E-01, 9.080000E-01,
+                                     8.810000E-01, 8.500000E-01, 8.180000E-01, 7.840000E-01, 7.510000E-01, 7.180000E-01,
+                                     6.850000E-01, 6.580000E-01, 6.280000E-01, 6.030000E-01, 5.800000E-01, 5.580000E-01,
+                                     5.380000E-01, 5.220000E-01, 5.060000E-01, 4.900000E-01, 4.780000E-01, 4.670000E-01,
+                                     4.570000E-01, 4.480000E-01, 4.380000E-01, 4.310000E-01, 4.240000E-01, 4.200000E-01,
+                                     4.140000E-01, 4.110000E-01, 4.060000E-01};
+
+struct MGH09_functor : LmFunctorBase {
+  MGH09_functor(void) : LmFunctorBase(4, 11) {}
+  static const double _x[11];
+  static const double y[11];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 4);
+    assert(fvec.size() == 11);
+    for (int i = 0; i < 11; i++) {
+      double x = _x[i], xx = x * x;
+      fvec[i] = b[0] * (xx + x * b[1]) / (xx + x * b[2] + b[3]) - y[i];
+    }
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 4);
+    assert(fjac.rows() == 11);
+    assert(fjac.cols() == 4);
+    for (int i = 0; i < 11; i++) {
+      double x = _x[i], xx = x * x;
+      double factor = 1. / (xx + x * b[2] + b[3]);
+      fjac(i, 0) = (xx + x * b[1]) * factor;
+      fjac(i, 1) = b[0] * x * factor;
+      fjac(i, 2) = -b[0] * (xx + x * b[1]) * x * factor * factor;
+      fjac(i, 3) = -b[0] * (xx + x * b[1]) * factor * factor;
+    }
+    return 0;
+  }
+};
+const double MGH09_functor::_x[11] = {4.,           2.,     1.,           5.E-1,        2.5E-01,     1.670000E-01,
+                                      1.250000E-01, 1.E-01, 8.330000E-02, 7.140000E-02, 6.250000E-02};
+const double MGH09_functor::y[11] = {1.957000E-01, 1.947000E-01, 1.735000E-01, 1.600000E-01, 8.440000E-02, 6.270000E-02,
+                                     4.560000E-02, 3.420000E-02, 3.230000E-02, 2.350000E-02, 2.460000E-02};
+
+struct Bennett5_functor : LmFunctorBase {
+  Bennett5_functor(void) : LmFunctorBase(3, 154) {}
+  static const double x[154];
+  static const double y[154];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 3);
+    assert(fvec.size() == 154);
+    for (int i = 0; i < 154; i++) fvec[i] = b[0] * pow(b[1] + x[i], -1. / b[2]) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 3);
+    assert(fjac.rows() == 154);
+    assert(fjac.cols() == 3);
+    for (int i = 0; i < 154; i++) {
+      double e = pow(b[1] + x[i], -1. / b[2]);
+      fjac(i, 0) = e;
+      fjac(i, 1) = -b[0] * e / b[2] / (b[1] + x[i]);
+      fjac(i, 2) = b[0] * e * log(b[1] + x[i]) / b[2] / b[2];
+    }
+    return 0;
+  }
+};
+const double Bennett5_functor::x[154] = {
+    7.447168E0,  8.102586E0,  8.452547E0,  8.711278E0,  8.916774E0,  9.087155E0,  9.232590E0,  9.359535E0,  9.472166E0,
+    9.573384E0,  9.665293E0,  9.749461E0,  9.827092E0,  9.899128E0,  9.966321E0,  10.029280E0, 10.088510E0, 10.144430E0,
+    10.197380E0, 10.247670E0, 10.295560E0, 10.341250E0, 10.384950E0, 10.426820E0, 10.467000E0, 10.505640E0, 10.542830E0,
+    10.578690E0, 10.613310E0, 10.646780E0, 10.679150E0, 10.710520E0, 10.740920E0, 10.770440E0, 10.799100E0, 10.826970E0,
+    10.854080E0, 10.880470E0, 10.906190E0, 10.931260E0, 10.955720E0, 10.979590E0, 11.002910E0, 11.025700E0, 11.047980E0,
+    11.069770E0, 11.091100E0, 11.111980E0, 11.132440E0, 11.152480E0, 11.172130E0, 11.191410E0, 11.210310E0, 11.228870E0,
+    11.247090E0, 11.264980E0, 11.282560E0, 11.299840E0, 11.316820E0, 11.333520E0, 11.349940E0, 11.366100E0, 11.382000E0,
+    11.397660E0, 11.413070E0, 11.428240E0, 11.443200E0, 11.457930E0, 11.472440E0, 11.486750E0, 11.500860E0, 11.514770E0,
+    11.528490E0, 11.542020E0, 11.555380E0, 11.568550E0, 11.581560E0, 11.594420E0, 11.607121E0, 11.619640E0, 11.632000E0,
+    11.644210E0, 11.656280E0, 11.668200E0, 11.679980E0, 11.691620E0, 11.703130E0, 11.714510E0, 11.725760E0, 11.736880E0,
+    11.747890E0, 11.758780E0, 11.769550E0, 11.780200E0, 11.790730E0, 11.801160E0, 11.811480E0, 11.821700E0, 11.831810E0,
+    11.841820E0, 11.851730E0, 11.861550E0, 11.871270E0, 11.880890E0, 11.890420E0, 11.899870E0, 11.909220E0, 11.918490E0,
+    11.927680E0, 11.936780E0, 11.945790E0, 11.954730E0, 11.963590E0, 11.972370E0, 11.981070E0, 11.989700E0, 11.998260E0,
+    12.006740E0, 12.015150E0, 12.023490E0, 12.031760E0, 12.039970E0, 12.048100E0, 12.056170E0, 12.064180E0, 12.072120E0,
+    12.080010E0, 12.087820E0, 12.095580E0, 12.103280E0, 12.110920E0, 12.118500E0, 12.126030E0, 12.133500E0, 12.140910E0,
+    12.148270E0, 12.155570E0, 12.162830E0, 12.170030E0, 12.177170E0, 12.184270E0, 12.191320E0, 12.198320E0, 12.205270E0,
+    12.212170E0, 12.219030E0, 12.225840E0, 12.232600E0, 12.239320E0, 12.245990E0, 12.252620E0, 12.259200E0, 12.265750E0,
+    12.272240E0};
+const double Bennett5_functor::y[154] = {
+    -34.834702E0, -34.393200E0, -34.152901E0, -33.979099E0, -33.845901E0, -33.732899E0, -33.640301E0, -33.559200E0,
+    -33.486801E0, -33.423100E0, -33.365101E0, -33.313000E0, -33.260899E0, -33.217400E0, -33.176899E0, -33.139198E0,
+    -33.101601E0, -33.066799E0, -33.035000E0, -33.003101E0, -32.971298E0, -32.942299E0, -32.916302E0, -32.890202E0,
+    -32.864101E0, -32.841000E0, -32.817799E0, -32.797501E0, -32.774300E0, -32.757000E0, -32.733799E0, -32.716400E0,
+    -32.699100E0, -32.678799E0, -32.661400E0, -32.644001E0, -32.626701E0, -32.612202E0, -32.597698E0, -32.583199E0,
+    -32.568699E0, -32.554298E0, -32.539799E0, -32.525299E0, -32.510799E0, -32.499199E0, -32.487598E0, -32.473202E0,
+    -32.461601E0, -32.435501E0, -32.435501E0, -32.426800E0, -32.412300E0, -32.400799E0, -32.392101E0, -32.380501E0,
+    -32.366001E0, -32.357300E0, -32.348598E0, -32.339901E0, -32.328400E0, -32.319698E0, -32.311001E0, -32.299400E0,
+    -32.290699E0, -32.282001E0, -32.273300E0, -32.264599E0, -32.256001E0, -32.247299E0, -32.238602E0, -32.229900E0,
+    -32.224098E0, -32.215401E0, -32.203800E0, -32.198002E0, -32.189400E0, -32.183601E0, -32.174900E0, -32.169102E0,
+    -32.163300E0, -32.154598E0, -32.145901E0, -32.140099E0, -32.131401E0, -32.125599E0, -32.119801E0, -32.111198E0,
+    -32.105400E0, -32.096699E0, -32.090900E0, -32.088001E0, -32.079300E0, -32.073502E0, -32.067699E0, -32.061901E0,
+    -32.056099E0, -32.050301E0, -32.044498E0, -32.038799E0, -32.033001E0, -32.027199E0, -32.024300E0, -32.018501E0,
+    -32.012699E0, -32.004002E0, -32.001099E0, -31.995300E0, -31.989500E0, -31.983700E0, -31.977900E0, -31.972099E0,
+    -31.969299E0, -31.963501E0, -31.957701E0, -31.951900E0, -31.946100E0, -31.940300E0, -31.937401E0, -31.931601E0,
+    -31.925800E0, -31.922899E0, -31.917101E0, -31.911301E0, -31.908400E0, -31.902599E0, -31.896900E0, -31.893999E0,
+    -31.888201E0, -31.885300E0, -31.882401E0, -31.876600E0, -31.873699E0, -31.867901E0, -31.862101E0, -31.859200E0,
+    -31.856300E0, -31.850500E0, -31.844700E0, -31.841801E0, -31.838900E0, -31.833099E0, -31.830200E0, -31.827299E0,
+    -31.821600E0, -31.818701E0, -31.812901E0, -31.809999E0, -31.807100E0, -31.801300E0, -31.798401E0, -31.795500E0,
+    -31.789700E0, -31.786800E0};
+
+struct thurber_functor : LmFunctorBase {
+  thurber_functor(void) : LmFunctorBase(7, 37) {}
+  static const double _x[37];
+  static const double _y[37];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    //        int called=0; printf("call hahn1_functor with  iflag=%d, called=%d\n", iflag, called); if (iflag==1)
+    //        called++;
+    assert(b.size() == 7);
+    assert(fvec.size() == 37);
+    for (int i = 0; i < 37; i++) {
+      double x = _x[i], xx = x * x, xxx = xx * x;
+      fvec[i] = (b[0] + b[1] * x + b[2] * xx + b[3] * xxx) / (1. + b[4] * x + b[5] * xx + b[6] * xxx) - _y[i];
+    }
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 7);
+    assert(fjac.rows() == 37);
+    assert(fjac.cols() == 7);
+    for (int i = 0; i < 37; i++) {
+      double x = _x[i], xx = x * x, xxx = xx * x;
+      double fact = 1. / (1. + b[4] * x + b[5] * xx + b[6] * xxx);
+      fjac(i, 0) = 1. * fact;
+      fjac(i, 1) = x * fact;
+      fjac(i, 2) = xx * fact;
+      fjac(i, 3) = xxx * fact;
+      fact = -(b[0] + b[1] * x + b[2] * xx + b[3] * xxx) * fact * fact;
+      fjac(i, 4) = x * fact;
+      fjac(i, 5) = xx * fact;
+      fjac(i, 6) = xxx * fact;
+    }
+    return 0;
+  }
+};
+const double thurber_functor::_x[37] = {-3.067E0, -2.981E0, -2.921E0, -2.912E0, -2.840E0, -2.797E0, -2.702E0, -2.699E0,
+                                        -2.633E0, -2.481E0, -2.363E0, -2.322E0, -1.501E0, -1.460E0, -1.274E0, -1.212E0,
+                                        -1.100E0, -1.046E0, -0.915E0, -0.714E0, -0.566E0, -0.545E0, -0.400E0, -0.309E0,
+                                        -0.109E0, -0.103E0, 0.010E0,  0.119E0,  0.377E0,  0.790E0,  0.963E0,  1.006E0,
+                                        1.115E0,  1.572E0,  1.841E0,  2.047E0,  2.200E0};
+const double thurber_functor::_y[37] = {
+    80.574E0,   84.248E0,   87.264E0,   87.195E0,   89.076E0,   89.608E0,   89.868E0,   90.101E0,
+    92.405E0,   95.854E0,   100.696E0,  101.060E0,  401.672E0,  390.724E0,  567.534E0,  635.316E0,
+    733.054E0,  759.087E0,  894.206E0,  990.785E0,  1090.109E0, 1080.914E0, 1122.643E0, 1178.351E0,
+    1260.531E0, 1273.514E0, 1288.339E0, 1327.543E0, 1353.863E0, 1414.509E0, 1425.208E0, 1421.384E0,
+    1442.962E0, 1464.350E0, 1468.705E0, 1447.894E0, 1457.628E0};
+
+struct rat43_functor : LmFunctorBase {
+  rat43_functor(void) : LmFunctorBase(4, 15) {}
+  static const double x[15];
+  static const double y[15];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 4);
+    assert(fvec.size() == 15);
+    for (int i = 0; i < 15; i++) fvec[i] = b[0] * pow(1. + exp(b[1] - b[2] * x[i]), -1. / b[3]) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 4);
+    assert(fjac.rows() == 15);
+    assert(fjac.cols() == 4);
+    for (int i = 0; i < 15; i++) {
+      double e = exp(b[1] - b[2] * x[i]);
+      double power = -1. / b[3];
+      fjac(i, 0) = pow(1. + e, power);
+      fjac(i, 1) = power * b[0] * e * pow(1. + e, power - 1.);
+      fjac(i, 2) = -power * b[0] * e * x[i] * pow(1. + e, power - 1.);
+      fjac(i, 3) = b[0] * power * power * log(1. + e) * pow(1. + e, power);
+    }
+    return 0;
+  }
+};
+const double rat43_functor::x[15] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.};
+const double rat43_functor::y[15] = {16.08,  33.83,  65.80,  97.20,  191.55, 326.20, 386.87, 520.53,
+                                     590.03, 651.92, 724.93, 699.56, 689.96, 637.56, 717.41};
+
+struct eckerle4_functor : LmFunctorBase {
+  eckerle4_functor(void) : LmFunctorBase(3, 35) {}
+  static const double x[35];
+  static const double y[35];
+  int operator()(const VectorXd &b, VectorXd &fvec) {
+    assert(b.size() == 3);
+    assert(fvec.size() == 35);
+    for (int i = 0; i < 35; i++)
+      fvec[i] = b[0] / b[1] * exp(-0.5 * (x[i] - b[2]) * (x[i] - b[2]) / (b[1] * b[1])) - y[i];
+    return 0;
+  }
+  int df(const VectorXd &b, MatrixXd &fjac) {
+    assert(b.size() == 3);
+    assert(fjac.rows() == 35);
+    assert(fjac.cols() == 3);
+    for (int i = 0; i < 35; i++) {
+      double b12 = b[1] * b[1];
+      double e = exp(-0.5 * (x[i] - b[2]) * (x[i] - b[2]) / b12);
+      fjac(i, 0) = e / b[1];
+      fjac(i, 1) = ((x[i] - b[2]) * (x[i] - b[2]) / b12 - 1.) * b[0] * e / b12;
+      fjac(i, 2) = (x[i] - b[2]) * e * b[0] / b[1] / b12;
+    }
+    return 0;
+  }
+};
+const double eckerle4_functor::x[35] = {400.0, 405.0, 410.0, 415.0, 420.0, 425.0, 430.0, 435.0, 436.5,
+                                        438.0, 439.5, 441.0, 442.5, 444.0, 445.5, 447.0, 448.5, 450.0,
+                                        451.5, 453.0, 454.5, 456.0, 457.5, 459.0, 460.5, 462.0, 463.5,
+                                        465.0, 470.0, 475.0, 480.0, 485.0, 490.0, 495.0, 500.0};
+const double eckerle4_functor::y[35] = {0.0001575, 0.0001699, 0.0002350, 0.0003102, 0.0004917, 0.0008710, 0.0017418,
+                                        0.0046400, 0.0065895, 0.0097302, 0.0149002, 0.0237310, 0.0401683, 0.0712559,
+                                        0.1264458, 0.2073413, 0.2902366, 0.3445623, 0.3698049, 0.3668534, 0.3106727,
+                                        0.2078154, 0.1164354, 0.0616764, 0.0337200, 0.0194023, 0.0117831, 0.0074357,
+                                        0.0022732, 0.0008800, 0.0004579, 0.0002345, 0.0001586, 0.0001143, 0.0000710};
+
+#endif  // EIGEN_TEST_LM_TEST_FUNCTORS_H
diff --git a/contrib/test/matrix_exponential.cpp b/contrib/test/matrix_exponential.cpp
new file mode 100644
index 0000000..0dd26a8
--- /dev/null
+++ b/contrib/test/matrix_exponential.cpp
@@ -0,0 +1,186 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "matrix_functions.h"
+#include "CustomComplex.h"
+
+double binom(int n, int k) {
+  double res = 1;
+  for (int i = 0; i < k; i++) res = res * (n - k + i + 1) / (i + 1);
+  return res;
+}
+
+template <typename T>
+T expfn(T x, int) {
+  return std::exp(x);
+}
+
+template <typename T>
+void test2dRotation(T tol) {
+  Matrix<T, 2, 2> A, B, C;
+  T angle;
+
+  A << 0, 1, -1, 0;
+  for (int i = 0; i <= 20; i++) {
+    angle = static_cast<T>(pow(10, i / 5. - 2));
+    B << std::cos(angle), std::sin(angle), -std::sin(angle), std::cos(angle);
+
+    C = (angle * A).matrixFunction(expfn);
+    std::cout << "test2dRotation: i = " << i << "   error funm = " << relerr(C, B);
+    VERIFY(C.isApprox(B, tol));
+
+    C = (angle * A).exp();
+    std::cout << "   error expm = " << relerr(C, B) << "\n";
+    VERIFY(C.isApprox(B, tol));
+  }
+}
+
+template <typename T>
+void test2dHyperbolicRotation(T tol) {
+  Matrix<std::complex<T>, 2, 2> A, B, C;
+  std::complex<T> imagUnit(0, 1);
+  T angle, ch, sh;
+
+  for (int i = 0; i <= 20; i++) {
+    angle = static_cast<T>((i - 10) / 2.0);
+    ch = std::cosh(angle);
+    sh = std::sinh(angle);
+    A << 0, angle * imagUnit, -angle * imagUnit, 0;
+    B << ch, sh * imagUnit, -sh * imagUnit, ch;
+
+    C = A.matrixFunction(expfn);
+    std::cout << "test2dHyperbolicRotation: i = " << i << "   error funm = " << relerr(C, B);
+    VERIFY(C.isApprox(B, tol));
+
+    C = A.exp();
+    std::cout << "   error expm = " << relerr(C, B) << "\n";
+    VERIFY(C.isApprox(B, tol));
+  }
+}
+
+template <typename T>
+void testPascal(T tol) {
+  for (int size = 1; size < 20; size++) {
+    Matrix<T, Dynamic, Dynamic> A(size, size), B(size, size), C(size, size);
+    A.setZero();
+    for (int i = 0; i < size - 1; i++) A(i + 1, i) = static_cast<T>(i + 1);
+    B.setZero();
+    for (int i = 0; i < size; i++)
+      for (int j = 0; j <= i; j++) B(i, j) = static_cast<T>(binom(i, j));
+
+    C = A.matrixFunction(expfn);
+    std::cout << "testPascal: size = " << size << "   error funm = " << relerr(C, B);
+    VERIFY(C.isApprox(B, tol));
+
+    C = A.exp();
+    std::cout << "   error expm = " << relerr(C, B) << "\n";
+    VERIFY(C.isApprox(B, tol));
+  }
+}
+
+template <typename MatrixType>
+void randomTest(const MatrixType& m,
+                const typename NumTraits<typename internal::traits<MatrixType>::Scalar>::Real& tol) {
+  /* this test covers the following files:
+     Inverse.h
+  */
+  typename MatrixType::Index rows = m.rows();
+  typename MatrixType::Index cols = m.cols();
+  MatrixType m1(rows, cols), m2(rows, cols), identity = MatrixType::Identity(rows, cols);
+
+  for (int i = 0; i < g_repeat; i++) {
+    m1 = MatrixType::Random(rows, cols);
+
+    m2 = m1.matrixFunction(expfn) * (-m1).matrixFunction(expfn);
+    std::cout << "randomTest: error funm = " << relerr(identity, m2);
+    VERIFY(identity.isApprox(m2, tol));
+
+    m2 = m1.exp() * (-m1).exp();
+    std::cout << "   error expm = " << relerr(identity, m2) << "\n";
+    VERIFY(identity.isApprox(m2, tol));
+  }
+}
+
+template <int Options>
+void testComplexScalingPath() {
+  using Scalar = std::complex<double>;
+  using MatrixType = Matrix<Scalar, 3, 3, Options>;
+  MatrixType A = MatrixType::Zero();
+  A.diagonal() << Scalar(-1.0, 64.0), Scalar(0.5, -32.0), Scalar(-0.25, 16.0);
+
+  MatrixType expected = MatrixType::Zero();
+  for (Index i = 0; i < A.rows(); ++i) expected(i, i) = std::exp(A(i, i));
+
+  const double tol = 100.0 * NumTraits<double>::epsilon();
+  VERIFY(A.exp().isApprox(expected, tol));
+}
+
+void testCustomComplexScalingPath() {
+  using Scalar = CustomComplex<double>;
+  using MatrixType = Matrix<Scalar, 3, 3>;
+  static_assert(!internal::complex_array_access<Scalar>::value, "test must exercise the scalar scaling fallback");
+
+  MatrixType A = MatrixType::Zero();
+  A.diagonal() << Scalar(-1.0, 64.0), Scalar(0.5, -32.0), Scalar(-0.25, 16.0);
+
+  const int squarings = 4;
+  const MatrixType scaled = internal::matrix_exp_scale<MatrixType>(A, squarings);
+  for (Index i = 0; i < A.size(); ++i) {
+    using std::ldexp;
+    VERIFY_IS_EQUAL(numext::real(scaled(i)), ldexp(numext::real(A(i)), -squarings));
+    VERIFY_IS_EQUAL(numext::imag(scaled(i)), ldexp(numext::imag(A(i)), -squarings));
+  }
+}
+
+template <typename Scalar>
+void testAtomicTaylorConvergence() {
+  using MatrixType = Matrix<Scalar, 2, 2>;
+  // The eigenvalues +-a are 1/16 apart, within matrix_function_separation, so A is a single atomic block.
+  const Scalar a = Scalar(1) / Scalar(32);
+  MatrixType A;
+  A << a, 1, 0, -a;
+  // A^2 = a^2 I, hence exp(A) = cosh(a) I + sinh(a)/a A. Reference: MPFR, 256 bits.
+  MatrixType expected;
+  expected << Scalar(1.031743407499102670938747815281507144194498326641816096008L),
+      Scalar(1.000162768364137425450217952562469769436361163924174806184L), Scalar(0),
+      Scalar(0.969233234476344081848109193246352783604725753896555170622L);
+  const MatrixType actual = A.matrixFunction(expfn);
+  const Scalar bound = 8 * NumTraits<Scalar>::epsilon() * expected.cwiseAbs().maxCoeff();
+  VERIFY(actual.allFinite());
+  VERIFY((actual - expected).cwiseAbs().maxCoeff() <= bound);
+}
+
+EIGEN_DECLARE_TEST(matrix_exponential) {
+  CALL_SUBTEST_1(testAtomicTaylorConvergence<float>());
+  CALL_SUBTEST_2(testAtomicTaylorConvergence<double>());
+  CALL_SUBTEST_9(testAtomicTaylorConvergence<long double>());
+  // matrixFunction() dominates the largest cases. The factors retain at least 1.6x headroom over the largest relative
+  // errors observed in extended GCC and Clang test runs.
+  CALL_SUBTEST_2(test2dRotation<double>(256 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(test2dRotation<float>(128 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_8(test2dRotation<long double>(256 * NumTraits<long double>::epsilon()));
+  CALL_SUBTEST_2(test2dHyperbolicRotation<double>(32 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(test2dHyperbolicRotation<float>(32 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_8(test2dHyperbolicRotation<long double>(32 * NumTraits<long double>::epsilon()));
+  CALL_SUBTEST_6(testPascal<float>(4 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_5(testPascal<double>(4 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_2(randomTest(Matrix2d(), 384 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_7(randomTest(Matrix<double, 3, 3, RowMajor>(), 384 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_3(randomTest(Matrix4cd(), 384 * NumTraits<std::complex<double>>::epsilon()));
+  CALL_SUBTEST_3((testComplexScalingPath<ColMajor>()));
+  CALL_SUBTEST_3((testComplexScalingPath<RowMajor>()));
+  CALL_SUBTEST_3(testCustomComplexScalingPath());
+  CALL_SUBTEST_4(randomTest(MatrixXd(8, 8), 384 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(randomTest(Matrix2f(), 384 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_5(randomTest(Matrix3cf(), 384 * NumTraits<std::complex<float>>::epsilon()));
+  CALL_SUBTEST_1(randomTest(Matrix4f(), 384 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_6(randomTest(MatrixXf(8, 8), 384 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_9(randomTest(Matrix<long double, Dynamic, Dynamic>(7, 7), 384 * NumTraits<long double>::epsilon()));
+}
diff --git a/contrib/test/matrix_function.cpp b/contrib/test/matrix_function.cpp
new file mode 100644
index 0000000..0e495ce
--- /dev/null
+++ b/contrib/test/matrix_function.cpp
@@ -0,0 +1,226 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <contrib/Eigen/MatrixFunctions>
+
+// Returns a matrix with eigenvalues clustered around 0, 1 and 2.
+template <typename MatrixType>
+MatrixType randomMatrixWithRealEivals(const Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  MatrixType diag = MatrixType::Zero(size, size);
+  for (Index i = 0; i < size; ++i) {
+    diag(i, i) =
+        Scalar(RealScalar(internal::random<int>(0, 2))) + internal::random<Scalar>() * Scalar(RealScalar(0.01));
+  }
+  MatrixType A = MatrixType::Random(size, size);
+  HouseholderQR<MatrixType> QRofA(A);
+  return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
+}
+
+template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
+struct randomMatrixWithImagEivals {
+  // Returns a matrix with eigenvalues clustered around 0 and +/- i.
+  static MatrixType run(const Index size);
+};
+
+// Partial specialization for real matrices
+template <typename MatrixType>
+struct randomMatrixWithImagEivals<MatrixType, 0> {
+  static MatrixType run(const Index size) {
+    typedef typename MatrixType::Scalar Scalar;
+    MatrixType diag = MatrixType::Zero(size, size);
+    Index i = 0;
+    while (i < size) {
+      Index randomInt = internal::random<Index>(-1, 1);
+      if (randomInt == 0 || i == size - 1) {
+        diag(i, i) = internal::random<Scalar>() * Scalar(0.01);
+        ++i;
+      } else {
+        Scalar alpha = Scalar(randomInt) + internal::random<Scalar>() * Scalar(0.01);
+        diag(i, i + 1) = alpha;
+        diag(i + 1, i) = -alpha;
+        i += 2;
+      }
+    }
+    MatrixType A = MatrixType::Random(size, size);
+    HouseholderQR<MatrixType> QRofA(A);
+    return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
+  }
+};
+
+// Partial specialization for complex matrices
+template <typename MatrixType>
+struct randomMatrixWithImagEivals<MatrixType, 1> {
+  static MatrixType run(const Index size) {
+    typedef typename MatrixType::Scalar Scalar;
+    typedef typename MatrixType::RealScalar RealScalar;
+    const Scalar imagUnit(0, 1);
+    MatrixType diag = MatrixType::Zero(size, size);
+    for (Index i = 0; i < size; ++i) {
+      diag(i, i) = Scalar(RealScalar(internal::random<Index>(-1, 1))) * imagUnit +
+                   internal::random<Scalar>() * Scalar(RealScalar(0.01));
+    }
+    MatrixType A = MatrixType::Random(size, size);
+    HouseholderQR<MatrixType> QRofA(A);
+    return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
+  }
+};
+
+template <typename MatrixType>
+void testMatrixExponential(const MatrixType& A) {
+  typedef typename internal::traits<MatrixType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> ComplexScalar;
+
+  VERIFY_IS_APPROX(A.exp(), A.matrixFunction(internal::stem_function_exp<ComplexScalar>));
+}
+
+template <typename MatrixType>
+void testMatrixLogarithm(const MatrixType& A) {
+  typedef typename internal::traits<MatrixType>::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  MatrixType scaledA;
+  RealScalar maxImagPartOfSpectrum = A.eigenvalues().imag().cwiseAbs().maxCoeff();
+  if (maxImagPartOfSpectrum >= RealScalar(0.9L * EIGEN_PI))
+    scaledA = A * RealScalar(0.9L * EIGEN_PI) / maxImagPartOfSpectrum;
+  else
+    scaledA = A;
+
+  // identity X.exp().log() = X only holds if Im(lambda) < pi for all eigenvalues of X
+  MatrixType expA = scaledA.exp();
+  MatrixType logExpA = expA.log();
+  // The round trip loses accuracy proportional to the magnitude of the intermediate exp(A), which is unbounded
+  // relative to A itself once A is close to zero.
+  VERIFY_IS_APPROX_SCALED(logExpA, scaledA, max_abs_coeff(expA));
+}
+
+template <typename MatrixType>
+void testHyperbolicFunctions(const MatrixType& A) {
+  // exp(A) and exp(-A) can cancel, so compare against the magnitude of the terms rather than of the result.
+  const MatrixType expA = A.exp();
+  const MatrixType expmA = (-A).exp();
+  const typename NumTraits<typename MatrixType::Scalar>::Real scale =
+      numext::maxi(max_abs_coeff(expA), max_abs_coeff(expmA));
+  VERIFY_IS_APPROX_SCALED(A.sinh(), (expA - expmA) / 2, scale);
+  VERIFY_IS_APPROX_SCALED(A.cosh(), (expA + expmA) / 2, scale);
+}
+
+template <typename MatrixType>
+void testGonioFunctions(const MatrixType& A) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> ComplexScalar;
+  typedef Matrix<ComplexScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime, MatrixType::Options>
+      ComplexMatrix;
+
+  ComplexScalar imagUnit(0, 1);
+  ComplexScalar two(2, 0);
+
+  ComplexMatrix Ac = A.template cast<ComplexScalar>();
+
+  ComplexMatrix exp_iA = (imagUnit * Ac).exp();
+  ComplexMatrix exp_miA = (-imagUnit * Ac).exp();
+
+  // As in testHyperbolicFunctions, the two exponentials can cancel.
+  const RealScalar scale = numext::maxi(max_abs_coeff(exp_iA), max_abs_coeff(exp_miA));
+
+  ComplexMatrix sinAc = A.sin().template cast<ComplexScalar>();
+  VERIFY_IS_APPROX_SCALED(sinAc, (exp_iA - exp_miA) / (two * imagUnit), scale);
+  ComplexMatrix result(A.rows(), A.cols());
+  MatrixBase<ComplexMatrix>& destination = result;
+  Ac.sin().evalTo(destination);
+  VERIFY_IS_APPROX_SCALED(result, (exp_iA - exp_miA) / (two * imagUnit), scale);
+
+  ComplexMatrix cosAc = A.cos().template cast<ComplexScalar>();
+  VERIFY_IS_APPROX_SCALED(cosAc, (exp_iA + exp_miA) / 2, scale);
+}
+
+template <typename MatrixType>
+void testMatrix(const MatrixType& A) {
+  testMatrixExponential(A);
+  testMatrixLogarithm(A);
+  testHyperbolicFunctions(A);
+  testGonioFunctions(A);
+}
+
+template <typename MatrixType>
+void testMatrixType(const MatrixType& m) {
+  // Matrices with clustered eigenvalue lead to different code paths
+  // in MatrixFunction.h and are thus useful for testing.
+
+  const Index size = m.rows();
+  for (int i = 0; i < g_repeat; i++) {
+    testMatrix(MatrixType::Random(size, size).eval());
+    testMatrix(randomMatrixWithRealEivals<MatrixType>(size));
+    testMatrix(randomMatrixWithImagEivals<MatrixType>::run(size));
+  }
+}
+
+template <typename MatrixType>
+void testMapRef(const MatrixType& A) {
+  // Test if passing Ref and Map objects is possible
+  // (Regression test for Bug #1796)
+  Index size = A.rows();
+  MatrixType X;
+  X.setRandom(size, size);
+  MatrixType Y(size, size);
+  Ref<MatrixType> R(Y);
+  Ref<const MatrixType> Rc(X);
+  Map<MatrixType> M(Y.data(), size, size);
+  Map<const MatrixType> Mc(X.data(), size, size);
+
+  X = X * X;  // make sure sqrt is possible
+  Y = X.sqrt();
+  R = Rc.sqrt();
+  M = Mc.sqrt();
+  Y = X.exp();
+  R = Rc.exp();
+  M = Mc.exp();
+  X = Y;  // make sure log is possible
+  Y = X.log();
+  R = Rc.log();
+  M = Mc.log();
+
+  Y = X.cos() + Rc.cos() + Mc.cos();
+  Y = X.sin() + Rc.sin() + Mc.sin();
+
+  Y = X.cosh() + Rc.cosh() + Mc.cosh();
+  Y = X.sinh() + Rc.sinh() + Mc.sinh();
+}
+
+template <typename MatrixType>
+void testMatrixLogarithmSingular() {
+  // Regression test for bug #1613: log() of a singular matrix used to
+  // hang because sqrt(0) = 0 is a fixed point of the inverse-scaling loop
+  // in matrix_log_compute_big(). The implementation now returns NaN.
+  MatrixType A = MatrixType::Zero(5, 5);
+  VERIFY(A.log().array().isNaN().all());
+}
+
+EIGEN_DECLARE_TEST(matrix_function) {
+  CALL_SUBTEST_1(testMatrixType(Matrix<float, 1, 1>()));
+  CALL_SUBTEST_2(testMatrixType(Matrix3cf()));
+  CALL_SUBTEST_3(testMatrixType(MatrixXf(8, 8)));
+  CALL_SUBTEST_4(testMatrixType(Matrix2d()));
+  CALL_SUBTEST_5(testMatrixType(Matrix<double, 5, 5, RowMajor>()));
+  CALL_SUBTEST_6(testMatrixType(Matrix4cd()));
+  CALL_SUBTEST_7(testMatrixType(MatrixXd(13, 13)));
+
+  CALL_SUBTEST_1(testMapRef(Matrix<float, 1, 1>()));
+  CALL_SUBTEST_2(testMapRef(Matrix3cf()));
+  CALL_SUBTEST_3(testMapRef(MatrixXf(8, 8)));
+  CALL_SUBTEST_7(testMapRef(MatrixXd(13, 13)));
+
+  CALL_SUBTEST_3(testMatrixLogarithmSingular<MatrixXf>());
+  CALL_SUBTEST_7(testMatrixLogarithmSingular<MatrixXd>());
+}
diff --git a/contrib/test/matrix_functions.h b/contrib/test/matrix_functions.h
new file mode 100644
index 0000000..8d57aec
--- /dev/null
+++ b/contrib/test/matrix_functions.h
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009-2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_UNSUPPORTED_TEST_MATRIX_FUNCTIONS_H
+#define EIGEN_UNSUPPORTED_TEST_MATRIX_FUNCTIONS_H
+
+#include "main.h"
+#include <contrib/Eigen/MatrixFunctions>
+
+// For complex matrices, any matrix is fine.
+template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
+struct processTriangularMatrix {
+  static void run(MatrixType&, MatrixType&, const MatrixType&) {}
+};
+
+// For real matrices, ensure all eigenvalues have positive real parts (needed for
+// the matrix logarithm and fractional powers to stay off the branch cut on the
+// negative real axis) and cap the condition number. The quasi-triangular Schur
+// factor T is modified block by block: a 2x2 block must stay a genuine complex
+// conjugate pair, so it is negated and scaled as a unit. Touching a single
+// diagonal entry of a 2x2 block could flip its discriminant and split it into
+// real -- possibly negative -- eigenvalues, which would reintroduce the branch
+// cut this routine is meant to avoid.
+template <typename MatrixType>
+struct processTriangularMatrix<MatrixType, 0> {
+  typedef typename MatrixType::Scalar Scalar;
+  static void run(MatrixType& m, MatrixType& T, const MatrixType& U) {
+    using std::abs;
+    using std::sqrt;
+    const Index size = m.cols();
+
+    // First pass: give every eigenvalue a positive real part and record the
+    // largest eigenvalue magnitude.
+    Scalar maxMag(0);
+    for (Index i = 0; i < size; ++i) {
+      if (i == size - 1 || numext::is_exactly_zero(T.coeff(i + 1, i))) {
+        // 1x1 block (real eigenvalue): make it positive.
+        T.coeffRef(i, i) = abs(T.coeff(i, i));
+        maxMag = (std::max)(maxMag, T.coeff(i, i));
+      } else {
+        // 2x2 block (complex conjugate pair a ± bi, real part
+        // a = (T(i,i) + T(i+1,i+1)) / 2). Negate the whole block when its real
+        // part is negative; this keeps it a valid conjugate pair while moving it
+        // off the branch cut. Checking a single diagonal entry (as before) misses
+        // blocks whose real part is negative only because the other entry is.
+        if (T.coeff(i, i) + T.coeff(i + 1, i + 1) < Scalar(0)) {
+          T.template block<2, 2>(i, i) *= Scalar(-1);
+        }
+        // |eigenvalue|^2 equals the block determinant a^2 + b^2.
+        const Scalar det = T.template block<2, 2>(i, i).determinant();
+        maxMag = (std::max)(maxMag, sqrt(abs(det)));
+        ++i;
+      }
+    }
+
+    // Second pass: lift eigenvalues that are too small to cap the condition
+    // number; tests lose too many digits on ill-conditioned matrices. A 2x2 block
+    // is scaled as a unit so it remains a conjugate pair.
+    if (maxMag > Scalar(0)) {
+      const Scalar minAllowed = maxMag / Scalar(100);
+      for (Index i = 0; i < size; ++i) {
+        if (i == size - 1 || numext::is_exactly_zero(T.coeff(i + 1, i))) {
+          if (T.coeff(i, i) < minAllowed) T.coeffRef(i, i) = minAllowed;
+        } else {
+          const Scalar det = T.template block<2, 2>(i, i).determinant();
+          const Scalar mag = sqrt(abs(det));
+          if (mag > Scalar(0) && mag < minAllowed) {
+            const Scalar s = minAllowed / mag;
+            T.template block<2, 2>(i, i) *= s;
+          }
+          ++i;
+        }
+      }
+    }
+    m = U * T * U.transpose();
+  }
+};
+
+template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
+struct generateTestMatrix;
+
+template <typename MatrixType>
+struct generateTestMatrix<MatrixType, 0> {
+  static void run(MatrixType& result, typename MatrixType::Index size) {
+    result = MatrixType::Random(size, size);
+    RealSchur<MatrixType> schur(result);
+    MatrixType T = schur.matrixT();
+    processTriangularMatrix<MatrixType>::run(result, T, schur.matrixU());
+  }
+};
+
+template <typename MatrixType>
+struct generateTestMatrix<MatrixType, 1> {
+  static void run(MatrixType& result, typename MatrixType::Index size) { result = MatrixType::Random(size, size); }
+};
+
+template <typename Derived, typename OtherDerived>
+typename Derived::RealScalar relerr(const MatrixBase<Derived>& A, const MatrixBase<OtherDerived>& B) {
+  return std::sqrt((A - B).cwiseAbs2().sum() / (std::min)(A.cwiseAbs2().sum(), B.cwiseAbs2().sum()));
+}
+
+#endif  // EIGEN_UNSUPPORTED_TEST_MATRIX_FUNCTIONS_H
diff --git a/contrib/test/matrix_power.cpp b/contrib/test/matrix_power.cpp
new file mode 100644
index 0000000..6e1be35
--- /dev/null
+++ b/contrib/test/matrix_power.cpp
@@ -0,0 +1,220 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012, 2013 Chen-Pang He <jdh8@ms63.hinet.net>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "matrix_functions.h"
+
+template <typename T>
+void test2dRotation(const T& tol) {
+  Matrix<T, 2, 2> A, B, C;
+  T angle, c, s;
+
+  A << 0, 1, -1, 0;
+  MatrixPower<Matrix<T, 2, 2>> Apow(A);
+
+  for (int i = 0; i <= 20; ++i) {
+    angle = std::pow(T(10), T(i - 10) / T(5.));
+    c = std::cos(angle);
+    s = std::sin(angle);
+    B << c, s, -s, c;
+
+    C = Apow(std::ldexp(angle, 1) / T(EIGEN_PI));
+    std::cout << "test2dRotation: i = " << i << "   error powerm = " << relerr(C, B) << '\n';
+    VERIFY(C.isApprox(B, tol));
+  }
+}
+
+template <typename T>
+void test2dHyperbolicRotation(const T& tol) {
+  Matrix<std::complex<T>, 2, 2> A, B, C;
+  T angle, ch = std::cosh((T)1);
+  std::complex<T> ish(0, std::sinh((T)1));
+
+  A << ch, ish, -ish, ch;
+  MatrixPower<Matrix<std::complex<T>, 2, 2>> Apow(A);
+
+  for (int i = 0; i <= 20; ++i) {
+    angle = std::ldexp(static_cast<T>(i - 10), -1);
+    ch = std::cosh(angle);
+    ish = std::complex<T>(0, std::sinh(angle));
+    B << ch, ish, -ish, ch;
+
+    C = Apow(angle);
+    std::cout << "test2dHyperbolicRotation: i = " << i << "   error powerm = " << relerr(C, B) << '\n';
+    VERIFY(C.isApprox(B, tol));
+  }
+}
+
+template <typename T>
+void test3dRotation(const T& tol) {
+  Matrix<T, 3, 1> v;
+  T angle;
+
+  for (int i = 0; i <= 20; ++i) {
+    v = Matrix<T, 3, 1>::Random();
+    v.normalize();
+    angle = std::pow(T(10), T(i - 10) / T(5.));
+    VERIFY(AngleAxis<T>(angle, v).matrix().isApprox(AngleAxis<T>(1, v).matrix().pow(angle), tol));
+  }
+}
+
+template <typename MatrixType>
+void testGeneral(const MatrixType& m, const typename MatrixType::RealScalar& tol) {
+  typedef typename MatrixType::RealScalar RealScalar;
+  MatrixType m1, m2, m3, m4, m5;
+  RealScalar x, y;
+
+  // The identities A^(xy) = (A^x)^y and (cA)^y = c^y * A^y involve two
+  // independent Schur decompositions. Each decomposition + Pade + squaring
+  // chain introduces rounding that scales with matrix dimension.
+  RealScalar tol2 = tol * RealScalar(m.rows() * m.rows());
+
+  for (int i = 0; i < g_repeat; ++i) {
+    generateTestMatrix<MatrixType>::run(m1, m.rows());
+    MatrixPower<MatrixType> mpow(m1);
+
+    x = internal::random<RealScalar>();
+    y = internal::random<RealScalar>();
+    m2 = mpow(x);
+    m3 = mpow(y);
+
+    m4 = mpow(x + y);
+    m5.noalias() = m2 * m3;
+    VERIFY(m4.isApprox(m5, tol));
+
+    m4 = mpow(x * y);
+    m5 = m2.pow(y);
+    VERIFY(m4.isApprox(m5, tol2));
+
+    m4 = (std::abs(x) * m1).pow(y);
+    m5 = std::pow(std::abs(x), y) * m3;
+    VERIFY(m4.isApprox(m5, tol2));
+  }
+}
+
+template <typename MatrixType>
+void testSingular(const MatrixType& m_const, const typename MatrixType::RealScalar& tol) {
+  // we need to pass by reference in order to prevent errors with
+  // MSVC for aligned data types ...
+  MatrixType& m = const_cast<MatrixType&>(m_const);
+
+  typedef typename MatrixType::RealScalar RealScalar;
+  const int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex;
+  typedef std::conditional_t<IsComplex, TriangularView<MatrixType, Upper>, const MatrixType&> TriangularType;
+  std::conditional_t<IsComplex, ComplexSchur<MatrixType>, RealSchur<MatrixType>> schur;
+  MatrixType T;
+
+  // MatrixPower uses its own Schur decomposition while the reference uses
+  // repeated sqrt of the caller-provided Schur form, so errors compound
+  // from two independent algorithm paths and scale with matrix dimension.
+  RealScalar tol2 = tol * RealScalar(m.rows() * m.rows());
+
+  for (int i = 0; i < g_repeat; ++i) {
+    m.setRandom();
+    m.col(0).fill(0);
+
+    schur.compute(m);
+    T = schur.matrixT();
+    const MatrixType& U = schur.matrixU();
+    processTriangularMatrix<MatrixType>::run(m, T, U);
+    MatrixPower<MatrixType> mpow(m);
+
+    T = T.sqrt();
+    VERIFY(mpow(0.5L).isApprox(U * (TriangularType(T) * U.adjoint()), tol2));
+
+    T = T.sqrt();
+    VERIFY(mpow(0.25L).isApprox(U * (TriangularType(T) * U.adjoint()), tol2));
+
+    T = T.sqrt();
+    VERIFY(mpow(0.125L).isApprox(U * (TriangularType(T) * U.adjoint()), tol2));
+  }
+}
+
+template <typename MatrixType>
+void testLogThenExp(const MatrixType& m_const, const typename MatrixType::RealScalar& tol) {
+  // we need to pass by reference in order to prevent errors with
+  // MSVC for aligned data types ...
+  MatrixType& m = const_cast<MatrixType&>(m_const);
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  Scalar x;
+
+  // Computing exp(x*log(m)) chains three separate Pade-based algorithms
+  // (matrix log, scaling, matrix exp). The accumulated error far exceeds
+  // what a single matrix power computation achieves.
+  const Index n = m.rows();
+  RealScalar tol2 = (std::max)(tol * RealScalar(n * n), test_precision<RealScalar>() * RealScalar(n * n));
+
+  for (int i = 0; i < g_repeat; ++i) {
+    generateTestMatrix<MatrixType>::run(m, m.rows());
+    x = internal::random<Scalar>();
+    VERIFY(m.pow(x).isApprox((x * m.log()).exp(), tol2));
+  }
+}
+
+typedef Matrix<double, 3, 3, RowMajor> Matrix3dRowMajor;
+typedef Matrix<long double, 3, 3> Matrix3e;
+typedef Matrix<long double, Dynamic, Dynamic> MatrixXe;
+
+EIGEN_DECLARE_TEST(matrix_power) {
+  // Factors are the smallest powers of two above the worst relative error seen over ~50k randomized trials per
+  // instantiation (4x that maximum). testGeneral is dominated by the A^(x+y) = A^x A^y and (A^x)^y identities,
+  // whose error has a heavy tail for near-defective random matrices, so those factors are large. testLogThenExp's
+  // bound is floored by test_precision * n^2, so its factor only documents the typical error.
+  CALL_SUBTEST_2(test2dRotation<double>(128 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(test2dRotation<float>(256 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_9(test2dRotation<long double>(128 * NumTraits<long double>::epsilon()));
+  CALL_SUBTEST_2(test2dHyperbolicRotation<double>(32 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(test2dHyperbolicRotation<float>(64 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_9(test2dHyperbolicRotation<long double>(64 * NumTraits<long double>::epsilon()));
+
+  CALL_SUBTEST_10(test3dRotation<double>(512 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_11(test3dRotation<float>(512 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_12(test3dRotation<long double>(512 * NumTraits<long double>::epsilon()));
+
+  CALL_SUBTEST_2(testGeneral(Matrix2d(), 2048 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_7(testGeneral(Matrix3dRowMajor(), 4096 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_3(testGeneral(Matrix4cd(), 4096 * NumTraits<std::complex<double>>::epsilon()));
+  CALL_SUBTEST_4(testGeneral(MatrixXd(8, 8), 16384 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(testGeneral(Matrix2f(), 2048 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_5(testGeneral(Matrix3cf(), 1024 * NumTraits<std::complex<float>>::epsilon()));
+  CALL_SUBTEST_8(testGeneral(Matrix4f(), 16384 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_6(testGeneral(MatrixXf(2, 2), 2048 * NumTraits<float>::epsilon()));  // see bug 614
+  CALL_SUBTEST_9(testGeneral(MatrixXe(7, 7), 16384 * NumTraits<long double>::epsilon()));
+  CALL_SUBTEST_10(testGeneral(Matrix3d(), 32768 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_11(testGeneral(Matrix3f(), 32768 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_12(testGeneral(Matrix3e(), 4096 * NumTraits<long double>::epsilon()));
+
+  CALL_SUBTEST_2(testSingular(Matrix2d(), 8 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_7(testSingular(Matrix3dRowMajor(), 512 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_3(testSingular(Matrix4cd(), 8 * NumTraits<std::complex<double>>::epsilon()));
+  CALL_SUBTEST_4(testSingular(MatrixXd(8, 8), 128 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(testSingular(Matrix2f(), 8 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_5(testSingular(Matrix3cf(), 8 * NumTraits<std::complex<float>>::epsilon()));
+  CALL_SUBTEST_8(testSingular(Matrix4f(), 256 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_6(testSingular(MatrixXf(2, 2), 8 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_9(testSingular(MatrixXe(7, 7), 256 * NumTraits<long double>::epsilon()));
+  CALL_SUBTEST_10(testSingular(Matrix3d(), 1024 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_11(testSingular(Matrix3f(), 2048 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_12(testSingular(Matrix3e(), 1024 * NumTraits<long double>::epsilon()));
+
+  CALL_SUBTEST_2(testLogThenExp(Matrix2d(), 128 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_7(testLogThenExp(Matrix3dRowMajor(), 128 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_3(testLogThenExp(Matrix4cd(), 8 * NumTraits<std::complex<double>>::epsilon()));
+  CALL_SUBTEST_4(testLogThenExp(MatrixXd(8, 8), 64 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_1(testLogThenExp(Matrix2f(), 64 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_5(testLogThenExp(Matrix3cf(), 8 * NumTraits<std::complex<float>>::epsilon()));
+  CALL_SUBTEST_8(testLogThenExp(Matrix4f(), 64 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_6(testLogThenExp(MatrixXf(2, 2), 64 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_9(testLogThenExp(MatrixXe(7, 7), 64 * NumTraits<long double>::epsilon()));
+  CALL_SUBTEST_10(testLogThenExp(Matrix3d(), 128 * NumTraits<double>::epsilon()));
+  CALL_SUBTEST_11(testLogThenExp(Matrix3f(), 128 * NumTraits<float>::epsilon()));
+  CALL_SUBTEST_12(testLogThenExp(Matrix3e(), 128 * NumTraits<long double>::epsilon()));
+}
diff --git a/contrib/test/matrix_square_root.cpp b/contrib/test/matrix_square_root.cpp
new file mode 100644
index 0000000..ca7682a
--- /dev/null
+++ b/contrib/test/matrix_square_root.cpp
@@ -0,0 +1,34 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "matrix_functions.h"
+
+template <typename MatrixType>
+void testMatrixSqrt(const MatrixType& m) {
+  MatrixType A;
+  generateTestMatrix<MatrixType>::run(A, m.rows());
+  MatrixType sqrtA = A.sqrt();
+  VERIFY_IS_APPROX(sqrtA * sqrtA, A);
+  MatrixType result(m.rows(), m.cols());
+  MatrixBase<MatrixType>& destination = result;
+  A.sqrt().evalTo(destination);
+  VERIFY_IS_APPROX(result, sqrtA);
+}
+
+EIGEN_DECLARE_TEST(matrix_square_root) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(testMatrixSqrt(Matrix3cf()));
+    CALL_SUBTEST_2(testMatrixSqrt(MatrixXcd(12, 12)));
+    CALL_SUBTEST_3(testMatrixSqrt(Matrix4f()));
+    CALL_SUBTEST_4(testMatrixSqrt(Matrix<double, Dynamic, Dynamic, RowMajor>(9, 9)));
+    CALL_SUBTEST_5(testMatrixSqrt(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_5(testMatrixSqrt(Matrix<std::complex<float>, 1, 1>()));
+  }
+}
diff --git a/contrib/test/mklfft.cpp b/contrib/test/mklfft.cpp
new file mode 100644
index 0000000..5cdb5cc
--- /dev/null
+++ b/contrib/test/mklfft.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_MKL_DEFAULT 1
+#include "fft_test_shared.h"
diff --git a/contrib/test/mpreal_support.cpp b/contrib/test/mpreal_support.cpp
new file mode 100644
index 0000000..754b2ae
--- /dev/null
+++ b/contrib/test/mpreal_support.cpp
@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <mpreal.h>  // Must be included before main.h.
+#include "main.h"
+#include <Eigen/MPRealSupport>
+#include <Eigen/LU>
+#include <Eigen/Eigenvalues>
+#include <sstream>
+
+using namespace mpfr;
+using namespace Eigen;
+
+EIGEN_DECLARE_TEST(mpreal_support) {
+  // set precision to 256 bits (double has only 53 bits)
+  mpreal::set_default_prec(256);
+  typedef Matrix<mpreal, Eigen::Dynamic, Eigen::Dynamic> MatrixXmp;
+  typedef Matrix<std::complex<mpreal>, Eigen::Dynamic, Eigen::Dynamic> MatrixXcmp;
+
+  std::cerr << "epsilon =         " << NumTraits<mpreal>::epsilon() << "\n";
+  std::cerr << "dummy_precision = " << NumTraits<mpreal>::dummy_precision() << "\n";
+  std::cerr << "highest =         " << NumTraits<mpreal>::highest() << "\n";
+  std::cerr << "lowest =          " << NumTraits<mpreal>::lowest() << "\n";
+  std::cerr << "digits10 =        " << NumTraits<mpreal>::digits10() << "\n";
+  std::cerr << "max_digits10 =    " << NumTraits<mpreal>::max_digits10() << "\n";
+
+  for (int i = 0; i < g_repeat; i++) {
+    int s = Eigen::internal::random<int>(1, 100);
+    MatrixXmp A = MatrixXmp::Random(s, s);
+    MatrixXmp B = MatrixXmp::Random(s, s);
+    MatrixXmp S = A.adjoint() * A;
+    MatrixXmp X;
+    MatrixXcmp Ac = MatrixXcmp::Random(s, s);
+    MatrixXcmp Bc = MatrixXcmp::Random(s, s);
+    MatrixXcmp Sc = Ac.adjoint() * Ac;
+    MatrixXcmp Xc;
+
+    // Basic stuffs
+    VERIFY_IS_APPROX(A.real(), A);
+    VERIFY(Eigen::internal::isApprox(A.array().abs2().sum(), A.squaredNorm()));
+    VERIFY_IS_APPROX(A.array().exp(), exp(A.array()));
+    VERIFY_IS_APPROX(A.array().abs2().sqrt(), A.array().abs());
+    VERIFY_IS_APPROX(A.array().sin(), sin(A.array()));
+    VERIFY_IS_APPROX(A.array().cos(), cos(A.array()));
+
+    // Cholesky
+    X = S.selfadjointView<Lower>().llt().solve(B);
+    VERIFY_IS_APPROX((S.selfadjointView<Lower>() * X).eval(), B);
+
+    Xc = Sc.selfadjointView<Lower>().llt().solve(Bc);
+    VERIFY_IS_APPROX((Sc.selfadjointView<Lower>() * Xc).eval(), Bc);
+
+    // partial LU
+    X = A.lu().solve(B);
+    VERIFY_IS_APPROX((A * X).eval(), B);
+
+    // symmetric eigenvalues
+    SelfAdjointEigenSolver<MatrixXmp> eig(S);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    VERIFY(
+        (S.selfadjointView<Lower>() * eig.eigenvectors())
+            .isApprox(eig.eigenvectors() * eig.eigenvalues().asDiagonal(), NumTraits<mpreal>::dummy_precision() * 1e3));
+  }
+
+  {
+    MatrixXmp A(8, 3);
+    A.setRandom();
+    // test output (interesting things happen in this code)
+    std::stringstream stream;
+    stream << A;
+  }
+}
diff --git a/contrib/test/openglsupport.cpp b/contrib/test/openglsupport.cpp
new file mode 100644
index 0000000..97c1c2f
--- /dev/null
+++ b/contrib/test/openglsupport.cpp
@@ -0,0 +1,595 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include <main.h>
+#include <iostream>
+#include <string>
+
+#if defined(__APPLE_CC__)
+// Prevent deprecation warnings caused by GLEW on MacOS.
+#define GL_SILENCE_DEPRECATION 1
+#endif
+#include <GL/glew.h>
+#include <Eigen/OpenGLSupport>
+#if defined(__APPLE_CC__)
+#include <GLUT/glut.h>
+#else
+#include <GL/freeglut.h>
+#endif
+
+using namespace Eigen;
+
+#define VERIFY_MATRIX(CODE, REF)                 \
+  {                                              \
+    glMatrixMode(GL_MODELVIEW);                  \
+    glLoadIdentity();                            \
+    CODE;                                        \
+    Matrix<float, 4, 4, ColMajor> m;             \
+    m.setZero();                                 \
+    glGet(GL_MODELVIEW_MATRIX, m);               \
+    if (!(REF).cast<float>().isApprox(m)) {      \
+      std::cerr << "Expected:\n"                 \
+                << ((REF).cast<float>()) << "\n" \
+                << "got\n"                       \
+                << m << "\n\n";                  \
+    }                                            \
+    VERIFY_IS_APPROX((REF).cast<float>(), m);    \
+  }
+
+#define VERIFY_UNIFORM(SUFFIX, NAME, TYPE)                     \
+  {                                                            \
+    TYPE value;                                                \
+    value.setRandom();                                         \
+    TYPE data;                                                 \
+    int loc = glGetUniformLocation(prg_id, #NAME);             \
+    VERIFY((loc != -1) && "uniform not found");                \
+    glUniform(loc, value);                                     \
+    EIGEN_CAT(glGetUniform, SUFFIX)(prg_id, loc, data.data()); \
+    if (!value.isApprox(data)) {                               \
+      std::cerr << "Expected:\n"                               \
+                << value << "\n"                               \
+                << "got\n"                                     \
+                << data << "\n\n";                             \
+    }                                                          \
+    VERIFY_IS_APPROX(value, data);                             \
+  }
+
+#define VERIFY_UNIFORMi(NAME, TYPE)                                        \
+  {                                                                        \
+    TYPE value = TYPE::Random().eval().cast<float>().cast<TYPE::Scalar>(); \
+    TYPE data;                                                             \
+    int loc = glGetUniformLocation(prg_id, #NAME);                         \
+    VERIFY((loc != -1) && "uniform not found");                            \
+    glUniform(loc, value);                                                 \
+    glGetUniformiv(prg_id, loc, (GLint*)data.data());                      \
+    if (!value.isApprox(data)) {                                           \
+      std::cerr << "Expected:\n"                                           \
+                << value << "\n"                                           \
+                << "got\n"                                                 \
+                << data << "\n\n";                                         \
+    }                                                                      \
+    VERIFY_IS_APPROX(value, data);                                         \
+  }
+
+void printProgramInfoLog(GLuint objectID) {
+  int infologLength, charsWritten;
+  GLchar* infoLog;
+  glGetProgramiv(objectID, GL_INFO_LOG_LENGTH, &infologLength);
+  if (infologLength > 0) {
+    infoLog = new GLchar[infologLength];
+    glGetProgramInfoLog(objectID, infologLength, &charsWritten, infoLog);
+    if (charsWritten > 0) std::cerr << "Program info : \n" << infoLog << std::endl;
+    delete[] infoLog;
+  }
+}
+
+void printShaderInfoLog(GLuint objectID) {
+  int infologLength, charsWritten;
+  GLchar* infoLog;
+  glGetShaderiv(objectID, GL_INFO_LOG_LENGTH, &infologLength);
+  if (infologLength > 0) {
+    infoLog = new GLchar[infologLength];
+    glGetShaderInfoLog(objectID, infologLength, &charsWritten, infoLog);
+    if (charsWritten > 0) std::cerr << "Shader info : \n" << infoLog << std::endl;
+    delete[] infoLog;
+  }
+}
+
+GLint createProgram(const char* vtx, const char* frg, bool print_errors = true) {
+  GLint prg_id = glCreateProgram();
+  GLint vtx_id = glCreateShader(GL_VERTEX_SHADER);
+  GLint frg_id = glCreateShader(GL_FRAGMENT_SHADER);
+  GLint ok;
+
+  glShaderSource(vtx_id, 1, &vtx, 0);
+  glCompileShader(vtx_id);
+  glGetShaderiv(vtx_id, GL_COMPILE_STATUS, &ok);
+  if (!ok) {
+    if (print_errors) {
+      std::cerr << "vtx compilation failed\n";
+      std::cerr << "Source:\n" << vtx << "\n";
+      printShaderInfoLog(vtx_id);
+    }
+    glDeleteShader(vtx_id);
+    return GL_ZERO;
+  }
+
+  glShaderSource(frg_id, 1, &frg, 0);
+  glCompileShader(frg_id);
+  glGetShaderiv(frg_id, GL_COMPILE_STATUS, &ok);
+  if (!ok) {
+    if (print_errors) {
+      std::cerr << "frg compilation failed.\n";
+      std::cerr << "Source:\n" << frg << "\n";
+      printShaderInfoLog(frg_id);
+    }
+    glDeleteShader(vtx_id);
+    glDeleteShader(frg_id);
+    return GL_ZERO;
+  }
+
+  glAttachShader(prg_id, vtx_id);
+  glAttachShader(prg_id, frg_id);
+  glLinkProgram(prg_id);
+
+  // Delete shaders once linked.
+  glDeleteShader(vtx_id);
+  glDeleteShader(frg_id);
+  glGetProgramiv(prg_id, GL_LINK_STATUS, &ok);
+  if (!ok) {
+    if (print_errors) {
+      std::cerr << "linking failed.\n";
+      printProgramInfoLog(prg_id);
+    }
+    glDeleteProgram(prg_id);
+    return GL_ZERO;
+  }
+
+  glUseProgram(prg_id);
+  return prg_id;
+}
+
+GLint createProgram(const std::string& vtx, const std::string& frg, bool print_errors = true) {
+  return createProgram(vtx.c_str(), frg.c_str(), print_errors);
+}
+
+std::string getGlslVersionString(int gl_major_version, int gl_minor_version) {
+  switch (gl_major_version) {
+    case 2:
+      switch (gl_minor_version) {
+        case 0:
+          return "#version 110";
+        case 1:
+          return "#version 120";
+      }
+      break;
+    case 3:
+      switch (gl_minor_version) {
+        case 0:
+          return "#version 130";
+        case 1:
+          return "#version 140";
+        case 2:
+          return "#version 150";
+        case 3:
+          return "#version 330";
+      }
+      break;
+    case 4:
+      switch (gl_minor_version) {
+        case 0:
+          return "#version 400";
+        case 1:
+          return "#version 410";
+        case 2:
+          return "#version 420";
+        case 3:
+          return "#version 430";
+        case 4:
+          return "#version 440";
+        case 5:
+          return "#version 450";
+        case 6:
+          return "#version 460";
+      }
+      break;
+  }
+  return "";
+}
+
+void find_and_replace(std::string& str, const std::string& find, const std::string& replace) {
+  size_t loc = 0;
+  size_t flen = find.length();
+  size_t rlen = replace.length();
+  while ((loc = str.find(find, loc)) != std::string::npos) {
+    str.replace(loc, flen, replace);
+    loc += rlen;
+  }
+}
+
+// Finds and replaces a set of substrings in a string.
+std::string format(const std::string& str, const std::vector<std::string>& find,
+                   const std::vector<std::string>& replace) {
+  std::string out = str;
+  for (std::size_t i = 0; i < find.size(); ++i) {
+    find_and_replace(out, find[i], replace[i]);
+  }
+  return out;
+}
+
+// GLUT display function that runs test.  Must be run within the display loop
+// in order to properly destroy resources.
+void openglsupport_test_loop() {
+  // Get context info.
+  const GLubyte* gl_version_string = glGetString(GL_VERSION);
+  std::cerr << "GL version: " << gl_version_string << std::endl;
+  std::cerr << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
+  // Parse version from string since GL_MAJOR_VERSION is only supported in GL 3.0+.
+  // Version string guaranteed to be <major>.<minor><vendor extension>.
+  GLint gl_major_version = gl_version_string[0] - '0';
+  GLint gl_minor_version = gl_version_string[2] - '0';
+  bool legacy_gl = gl_major_version < 3 || (gl_major_version == 3 && gl_minor_version < 2);
+
+  // Fixed-function pipeline removed in OpenGL 3.2.
+  if (legacy_gl) {
+    // Draw a basic triangle.
+    Vector3f v3f;
+    Matrix3f rot;
+    glBegin(GL_POINTS);
+    {
+      glVertex(v3f);
+      glVertex(2 * v3f + v3f);
+      glVertex(rot * v3f);
+    }
+    glEnd();
+
+    // 4x4 matrices
+    Matrix4f mf44;
+    mf44.setRandom();
+    VERIFY_MATRIX(glLoadMatrix(mf44), mf44);
+    VERIFY_MATRIX(glMultMatrix(mf44), mf44);
+    Matrix4d md44;
+    md44.setRandom();
+    VERIFY_MATRIX(glLoadMatrix(md44), md44);
+    VERIFY_MATRIX(glMultMatrix(md44), md44);
+
+    // Quaternion
+    Quaterniond qd(AngleAxisd(internal::random<double>(), Vector3d::Random()));
+    VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
+
+    Quaternionf qf(AngleAxisf(internal::random<double>(), Vector3f::Random()));
+    VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
+
+    // 3D Transform
+    Transform<float, 3, AffineCompact> acf3;
+    acf3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(acf3), Projective3f(acf3).matrix());
+    VERIFY_MATRIX(glMultMatrix(acf3), Projective3f(acf3).matrix());
+
+    Transform<float, 3, Affine> af3(acf3);
+    VERIFY_MATRIX(glLoadMatrix(af3), Projective3f(af3).matrix());
+    VERIFY_MATRIX(glMultMatrix(af3), Projective3f(af3).matrix());
+
+    Transform<float, 3, Projective> pf3;
+    pf3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(pf3), Projective3f(pf3).matrix());
+    VERIFY_MATRIX(glMultMatrix(pf3), Projective3f(pf3).matrix());
+
+    Transform<double, 3, AffineCompact> acd3;
+    acd3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(acd3), Projective3d(acd3).matrix());
+    VERIFY_MATRIX(glMultMatrix(acd3), Projective3d(acd3).matrix());
+
+    Transform<double, 3, Affine> ad3(acd3);
+    VERIFY_MATRIX(glLoadMatrix(ad3), Projective3d(ad3).matrix());
+    VERIFY_MATRIX(glMultMatrix(ad3), Projective3d(ad3).matrix());
+
+    Transform<double, 3, Projective> pd3;
+    pd3.matrix().setRandom();
+    VERIFY_MATRIX(glLoadMatrix(pd3), Projective3d(pd3).matrix());
+    VERIFY_MATRIX(glMultMatrix(pd3), Projective3d(pd3).matrix());
+
+    // translations (2D and 3D)
+    {
+      Vector2f vf2;
+      vf2.setRandom();
+      Vector3f vf23;
+      vf23 << vf2, 0;
+      VERIFY_MATRIX(glTranslate(vf2), Projective3f(Translation3f(vf23)).matrix());
+      Vector2d vd2;
+      vd2.setRandom();
+      Vector3d vd23;
+      vd23 << vd2, 0;
+      VERIFY_MATRIX(glTranslate(vd2), Projective3d(Translation3d(vd23)).matrix());
+
+      Vector3f vf3;
+      vf3.setRandom();
+      VERIFY_MATRIX(glTranslate(vf3), Projective3f(Translation3f(vf3)).matrix());
+      Vector3d vd3;
+      vd3.setRandom();
+      VERIFY_MATRIX(glTranslate(vd3), Projective3d(Translation3d(vd3)).matrix());
+
+      Translation<float, 3> tf3;
+      tf3.vector().setRandom();
+      VERIFY_MATRIX(glTranslate(tf3), Projective3f(tf3).matrix());
+
+      Translation<double, 3> td3;
+      td3.vector().setRandom();
+      VERIFY_MATRIX(glTranslate(td3), Projective3d(td3).matrix());
+    }
+
+    // scaling (2D and 3D)
+    {
+      Vector2f vf2;
+      vf2.setRandom();
+      Vector3f vf23;
+      vf23 << vf2, 1;
+      VERIFY_MATRIX(glScale(vf2), Projective3f(Scaling(vf23)).matrix());
+      Vector2d vd2;
+      vd2.setRandom();
+      Vector3d vd23;
+      vd23 << vd2, 1;
+      VERIFY_MATRIX(glScale(vd2), Projective3d(Scaling(vd23)).matrix());
+
+      Vector3f vf3;
+      vf3.setRandom();
+      VERIFY_MATRIX(glScale(vf3), Projective3f(Scaling(vf3)).matrix());
+      Vector3d vd3;
+      vd3.setRandom();
+      VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
+
+      UniformScaling<float> usf(internal::random<float>());
+      VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
+
+      UniformScaling<double> usd(internal::random<double>());
+      VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
+    }
+  } else {
+    std::cerr << "Warning: fixed-function pipeline was not tested.\n";
+  }
+
+  // Dynamic shader substitution variables.
+  // Modern shaders require a version string, and newer runtimes fail to
+  // compile old GLSL versions. Thus, we dynamically set the GLSL version
+  // string based on runtime. Also, pre OpenGL 3.0, the output gl_FragColor was
+  // built-in. This was deprecated in OpenGL 3.0, requiring us to explicitly
+  // define the output variable.
+  std::vector<std::string> glsl_vars;
+  glsl_vars.push_back("${GLSL_VERSION}");
+  glsl_vars.push_back("${FRAG_OUTPUT_DECLARATION}");
+  glsl_vars.push_back("${FRAG_OUTPUT_VARIABLE}");
+
+  std::vector<std::string> glsl_vals;
+  glsl_vals.push_back(getGlslVersionString(gl_major_version, gl_minor_version));
+  if (gl_major_version >= 3) {
+    glsl_vals.push_back("out vec4 fragColor;");
+    glsl_vals.push_back("fragColor");
+  } else {
+    glsl_vals.push_back("");
+    glsl_vals.push_back("gl_FragColor");
+  }
+
+  // uniform
+  {
+    // vertex shader.
+    std::string vtx = format(
+        "${GLSL_VERSION}\n"
+        "void main(void) {\n"
+        "  gl_Position = vec4(0,0,0,1);\n"
+        "}\n",
+        glsl_vars, glsl_vals);
+
+#ifdef GL_VERSION_2_0
+    if (GLEW_VERSION_2_0 && GL_VERSION_2_0) {
+      std::string frg = format(
+          "${GLSL_VERSION}\n"
+          "uniform vec2 v2f;\n"
+          "uniform vec3 v3f;\n"
+          "uniform vec4 v4f;\n"
+          "uniform ivec2 v2i;\n"
+          "uniform ivec3 v3i;\n"
+          "uniform ivec4 v4i;\n"
+          "uniform mat2 m2f;\n"
+          "uniform mat3 m3f;\n"
+          "uniform mat4 m4f;\n"
+          "${FRAG_OUTPUT_DECLARATION}\n"
+          "void main(void) { \n"
+          "  ${FRAG_OUTPUT_VARIABLE} = "
+          "vec4(v2f[0]+v3f[0]+v4f[0])+vec4(v2i[0]+v3i[0]+v4i[0])+vec4(m2f[0][0]+m3f[0][0]+m4f[0][0]);\n"
+          "}\n",
+          glsl_vars, glsl_vals);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
+      VERIFY_UNIFORM(fv, v2f, Vector2f);
+      VERIFY_UNIFORM(fv, v3f, Vector3f);
+      VERIFY_UNIFORM(fv, v4f, Vector4f);
+      VERIFY_UNIFORMi(v2i, Vector2i);
+      VERIFY_UNIFORMi(v3i, Vector3i);
+      VERIFY_UNIFORMi(v4i, Vector4i);
+      VERIFY_UNIFORM(fv, m2f, Matrix2f);
+      VERIFY_UNIFORM(fv, m3f, Matrix3f);
+      VERIFY_UNIFORM(fv, m4f, Matrix4f);
+      glDeleteProgram(prg_id);
+    } else
+#endif
+      std::cerr << "Warning: opengl 2.0 was not tested.\n";
+
+#ifdef GL_VERSION_2_1
+    if (GLEW_VERSION_2_1 && GL_VERSION_2_1 &&
+        (gl_major_version > 2 || (gl_major_version == 2 && gl_minor_version >= 1))) {
+      std::string frg = format(
+          "${GLSL_VERSION}\n"
+          "uniform mat2x3 m23f;\n"
+          "uniform mat3x2 m32f;\n"
+          "uniform mat2x4 m24f;\n"
+          "uniform mat4x2 m42f;\n"
+          "uniform mat3x4 m34f;\n"
+          "uniform mat4x3 m43f;\n"
+          "${FRAG_OUTPUT_DECLARATION}\n"
+          "void main(void) {\n"
+          "  ${FRAG_OUTPUT_VARIABLE} = vec4(m23f[0][0]+m32f[0][0]+m24f[0][0]+m42f[0][0]+m34f[0][0]+m43f[0][0]);\n"
+          "}\n",
+          glsl_vars, glsl_vals);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
+      typedef Matrix<float, 2, 3> Matrix23f;
+      typedef Matrix<float, 3, 2> Matrix32f;
+      typedef Matrix<float, 2, 4> Matrix24f;
+      typedef Matrix<float, 4, 2> Matrix42f;
+      typedef Matrix<float, 3, 4> Matrix34f;
+      typedef Matrix<float, 4, 3> Matrix43f;
+
+      VERIFY_UNIFORM(fv, m23f, Matrix23f);
+      VERIFY_UNIFORM(fv, m32f, Matrix32f);
+      VERIFY_UNIFORM(fv, m24f, Matrix24f);
+      VERIFY_UNIFORM(fv, m42f, Matrix42f);
+      VERIFY_UNIFORM(fv, m34f, Matrix34f);
+      VERIFY_UNIFORM(fv, m43f, Matrix43f);
+      glDeleteProgram(prg_id);
+    } else
+#endif
+      std::cerr << "Warning: opengl 2.1 was not tested.\n";
+
+#ifdef GL_VERSION_3_0
+    if (GLEW_VERSION_3_0 && GL_VERSION_3_0 && gl_major_version >= 3) {
+      std::string frg = format(
+          "${GLSL_VERSION}\n"
+          "uniform uvec2 v2ui;\n"
+          "uniform uvec3 v3ui;\n"
+          "uniform uvec4 v4ui;\n"
+          "${FRAG_OUTPUT_DECLARATION}\n"
+          "void main(void) {\n"
+          "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2ui[0]+v3ui[0]+v4ui[0]);\n"
+          "}\n",
+          glsl_vars, glsl_vals);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
+      typedef Matrix<unsigned int, 2, 1> Vector2ui;
+      typedef Matrix<unsigned int, 3, 1> Vector3ui;
+      typedef Matrix<unsigned int, 4, 1> Vector4ui;
+
+      VERIFY_UNIFORMi(v2ui, Vector2ui);
+      VERIFY_UNIFORMi(v3ui, Vector3ui);
+      VERIFY_UNIFORMi(v4ui, Vector4ui);
+      glDeleteProgram(prg_id);
+    } else
+#endif
+      std::cerr << "Warning: opengl 3.0 was not tested.\n";
+
+    // dvecn supported if >= 4.1 or ARB_vertex_attrib_64bit
+    bool has_fp64_native = (gl_major_version == 4 && gl_minor_version >= 1);
+    bool has_fp64_extension = false;
+#ifdef GLEW_ARB_gpu_shader_fp64
+    if (GLEW_ARB_gpu_shader_fp64) {
+      // Check that extension can actually be compiled.
+      if (has_fp64_extension) {
+        std::string frg = format(
+            "${GLSL_VERSION}\n"
+            "#extension GL_ARB_gpu_shader_fp64 : enable\n"
+            "uniform dvec2 dv2;\n"
+            "${FRAG_OUTPUT_DECLARATION}\n"
+            "void main(void) {\n"
+            "  ${FRAG_OUTPUT_VARIABLE} = vec4(dv2.x, dv2.y, dv2.x, dv2.y);\n"
+            "}\n",
+            glsl_vars, glsl_vals);
+        GLint prg_id = createProgram(vtx, frg, /*print_errors=*/false);
+        if (prg_id) {
+          has_fp64_extension = true;
+          glDeleteProgram(prg_id);
+        }
+      }
+    }
+#endif
+
+    if (has_fp64_native || has_fp64_extension) {
+      std::vector<std::string> glsl_vars_with_extension = glsl_vars;
+      glsl_vars_with_extension.push_back("${GLSL_EXTENSIONS}");
+      std::vector<std::string> glsl_vals_with_extension = glsl_vals;
+      if (has_fp64_extension) {
+        glsl_vals_with_extension.push_back("#extension GL_ARB_gpu_shader_fp64 : enable");
+      } else {
+        glsl_vals_with_extension.push_back("");
+      }
+
+      std::string frg = format(
+          "${GLSL_VERSION}\n"
+          "${GLSL_EXTENSIONS}\n"
+          "uniform dvec2 v2d;\n"
+          "uniform dvec3 v3d;\n"
+          "uniform dvec4 v4d;\n"
+          "${FRAG_OUTPUT_DECLARATION}\n"
+          "void main(void) {\n"
+          "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2d[0]+v3d[0]+v4d[0]);\n"
+          "}\n",
+          glsl_vars_with_extension, glsl_vals_with_extension);
+
+      GLint prg_id = createProgram(vtx, frg);
+      VERIFY(prg_id > 0 && "Failed to create program.");
+      VERIFY_UNIFORM(dv, v2d, Vector2d);
+      VERIFY_UNIFORM(dv, v3d, Vector3d);
+      VERIFY_UNIFORM(dv, v4d, Vector4d);
+      glDeleteProgram(prg_id);
+    } else
+      std::cerr << "Warning: dvec (fp64) was not tested.\n";
+  }
+
+  // Exit loop - Leaving main loop is supported by freeglut, otherwise we
+  // are forced to exit.
+#ifdef FREEGLUT
+  glutLeaveMainLoop();
+  // Trigger another display loop iteration. Otherwise, it just hangs.
+  glutPostRedisplay();
+#else
+  exit(0);
+#endif
+}
+
+EIGEN_DECLARE_TEST(openglsupport) {
+  int argc = 0;
+  glutInit(&argc, 0);
+
+  GLint glut_display_mode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
+
+#ifndef EIGEN_LEGACY_OPENGL
+  // Initialize 3.2+ OpenGL context.
+#if defined(__APPLE_CC__)
+  glut_display_mode |= GLUT_3_2_CORE_PROFILE;
+#elif defined(FREEGLUT)
+  glutInitContextVersion(3, 2);
+  glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
+  glutInitContextProfile(GLUT_CORE_PROFILE);
+#endif
+#endif
+
+  glutInitDisplayMode(glut_display_mode);
+  glutInitWindowPosition(0, 0);
+  glutInitWindowSize(10, 10);
+
+  int window = glutCreateWindow("Eigen");
+  if (window <= 0) {
+    std::cerr << "Error: Unable to create GLUT Window.\n";
+    exit(1);
+  }
+
+  glewExperimental = GL_TRUE;
+  if (glewInit() != GLEW_OK) {
+    std::cerr << "Warning: Failed to initialize GLEW.\n";
+    exit(1);
+  }
+
+  // Run test in display, otherwise GLUT fails to clean up and leads to memory
+  // access errors on exit.
+  glutDisplayFunc(openglsupport_test_loop);
+  glutMainLoop();
+  glutDestroyWindow(window);
+}
diff --git a/contrib/test/pocketfft.cpp b/contrib/test/pocketfft.cpp
new file mode 100644
index 0000000..d707b48
--- /dev/null
+++ b/contrib/test/pocketfft.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_POCKETFFT_DEFAULT 1
+#include "fft_test_shared.h"
diff --git a/contrib/test/polynomialsolver.cpp b/contrib/test/polynomialsolver.cpp
new file mode 100644
index 0000000..0708b8c
--- /dev/null
+++ b/contrib/test/polynomialsolver.cpp
@@ -0,0 +1,445 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <contrib/Eigen/Polynomials>
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+namespace Eigen {
+namespace internal {
+template <int Size>
+struct increment_if_fixed_size : std::integral_constant<int, (Size == Dynamic) ? Dynamic : Size + 1> {};
+}  // namespace internal
+}  // namespace Eigen
+
+template <typename PolynomialType>
+PolynomialType polyder(const PolynomialType& p) {
+  typedef typename PolynomialType::Scalar Scalar;
+  PolynomialType res(p.size());
+  for (Index i = 1; i < p.size(); ++i) res[i - 1] = p[i] * Scalar(i);
+  res[p.size() - 1] = 0.;
+  return res;
+}
+
+template <int Deg, typename POLYNOMIAL, typename SOLVER>
+bool aux_evalSolver(const POLYNOMIAL& pols, SOLVER& psolve) {
+  typedef typename POLYNOMIAL::Scalar Scalar;
+  typedef typename POLYNOMIAL::RealScalar RealScalar;
+
+  typedef typename SOLVER::RootsType RootsType;
+  typedef Matrix<RealScalar, Deg, 1> EvalRootsType;
+
+  const Index deg = pols.size() - 1;
+
+  // Test template constructor from coefficient vector
+  SOLVER solve_constr(pols);
+
+  psolve.compute(pols);
+  const RootsType& roots(psolve.roots());
+  EvalRootsType evr(deg);
+  POLYNOMIAL pols_der = polyder(pols);
+  EvalRootsType der(deg);
+  for (int i = 0; i < roots.size(); ++i) {
+    evr[i] = std::abs(poly_eval(pols, roots[i]));
+    der[i] = numext::maxi(RealScalar(1.), std::abs(poly_eval(pols_der, roots[i])));
+  }
+
+  // we need to divide by the magnitude of the derivative because
+  // with a high derivative is very small error in the value of the root
+  // yiels a very large error in the polynomial evaluation.
+  bool evalToZero = (evr.cwiseQuotient(der)).isZero(test_precision<Scalar>());
+  if (!evalToZero) {
+    cerr << "WRONG root: " << endl;
+    cerr << "Polynomial: " << pols.transpose() << endl;
+    cerr << "Roots found: " << roots.transpose() << endl;
+    cerr << "Abs value of the polynomial at the roots: " << evr.transpose() << endl;
+    cerr << endl;
+  }
+
+  std::vector<RealScalar> rootModuli(roots.size());
+  Map<EvalRootsType> aux(&rootModuli[0], roots.size());
+  aux = roots.array().abs();
+  std::sort(rootModuli.begin(), rootModuli.end());
+  bool distinctModuli = true;
+  for (size_t i = 1; i < rootModuli.size() && distinctModuli; ++i) {
+    if (internal::isApprox(rootModuli[i], rootModuli[i - 1])) {
+      distinctModuli = false;
+    }
+  }
+  VERIFY(evalToZero || !distinctModuli);
+
+  return distinctModuli;
+}
+
+template <int Deg, typename POLYNOMIAL>
+void evalSolver(const POLYNOMIAL& pols) {
+  typedef typename POLYNOMIAL::Scalar Scalar;
+
+  typedef PolynomialSolver<Scalar, Deg> PolynomialSolverType;
+
+  PolynomialSolverType psolve;
+  aux_evalSolver<Deg, POLYNOMIAL, PolynomialSolverType>(pols, psolve);
+}
+
+template <typename Solver>
+void verify_polynomialsolver_sugar(const Solver& solver, typename Solver::RealScalar threshold) {
+  using Real = typename Solver::RealScalar;
+  const auto& computed = solver.roots();
+  Index greatest, smallest;
+  computed.cwiseAbs2().maxCoeff(&greatest);
+  computed.cwiseAbs2().minCoeff(&smallest);
+  VERIFY_IS_EQUAL(solver.greatestRoot(), computed[greatest]);
+  VERIFY_IS_EQUAL(solver.smallestRoot(), computed[smallest]);
+
+  std::vector<Real> expectedRealRoots, expectedRealExtrema;
+  for (Index i = 0; i < computed.size(); ++i) {
+    // realRoots uses a strict threshold; the extremal queries include its boundary.
+    if (numext::abs(computed[i].imag()) < threshold) expectedRealRoots.push_back(computed[i].real());
+    if (numext::abs(computed[i].imag()) <= threshold) expectedRealExtrema.push_back(computed[i].real());
+  }
+  std::vector<Real> actualRealRoots;
+  solver.realRoots(actualRealRoots, threshold);
+  VERIFY_IS_EQUAL(actualRealRoots.size(), expectedRealRoots.size());
+  for (size_t i = 0; i < expectedRealRoots.size(); ++i) VERIFY_IS_EQUAL(actualRealRoots[i], expectedRealRoots[i]);
+
+  const bool expectedHasRealRoot = !expectedRealExtrema.empty();
+  const auto absLess = [](Real a, Real b) { return numext::abs(a) < numext::abs(b); };
+  bool hasRealRoot;
+  Real result = solver.absGreatestRealRoot(hasRealRoot, threshold);
+  VERIFY_IS_EQUAL(hasRealRoot, expectedHasRealRoot);
+  if (hasRealRoot)
+    VERIFY_IS_EQUAL(result, *std::max_element(expectedRealExtrema.begin(), expectedRealExtrema.end(), absLess));
+  result = solver.absSmallestRealRoot(hasRealRoot, threshold);
+  VERIFY_IS_EQUAL(hasRealRoot, expectedHasRealRoot);
+  if (hasRealRoot)
+    VERIFY_IS_EQUAL(result, *std::min_element(expectedRealExtrema.begin(), expectedRealExtrema.end(), absLess));
+  result = solver.greatestRealRoot(hasRealRoot, threshold);
+  VERIFY_IS_EQUAL(hasRealRoot, expectedHasRealRoot);
+  if (hasRealRoot) VERIFY_IS_EQUAL(result, *std::max_element(expectedRealExtrema.begin(), expectedRealExtrema.end()));
+  result = solver.smallestRealRoot(hasRealRoot, threshold);
+  VERIFY_IS_EQUAL(hasRealRoot, expectedHasRealRoot);
+  if (hasRealRoot) VERIFY_IS_EQUAL(result, *std::min_element(expectedRealExtrema.begin(), expectedRealExtrema.end()));
+}
+
+template <int Deg, typename POLYNOMIAL, typename REAL_ROOTS>
+void evalSolverSugarFunction(const POLYNOMIAL& pols, const REAL_ROOTS& real_roots) {
+  using Scalar = typename POLYNOMIAL::Scalar;
+  using RealScalar = typename POLYNOMIAL::RealScalar;
+  using PolynomialSolverType = PolynomialSolver<Scalar, Deg>;
+
+  PolynomialSolverType psolve;
+  if (aux_evalSolver<Deg, POLYNOMIAL, PolynomialSolverType>(pols, psolve)) {
+    // First-order root displacement estimate: delta * sum_k |r_j|^k / |p'(r_j)| for a monic polynomial,
+    // p'(r_j) = prod_{k != j} (r_j - r_k). Use delta = 32 eps max_k |a_k| for the companion eigenvalue error.
+    const RealScalar coefficientError = RealScalar(32) * NumTraits<RealScalar>::epsilon() * pols.cwiseAbs().maxCoeff();
+    Matrix<RealScalar, Dynamic, 1> tolerance(real_roots.size());
+    for (Index j = 0; j < real_roots.size(); ++j) {
+      const RealScalar root = real_roots[j];
+      RealScalar powerSum = RealScalar(0), power = RealScalar(1), derivative = RealScalar(1);
+      for (Index k = 0; k < pols.size(); ++k) {
+        powerSum += power;
+        power *= numext::abs(root);
+      }
+      for (Index k = 0; k < real_roots.size(); ++k) {
+        if (k != j) derivative *= numext::abs(root - real_roots[k]);
+      }
+      tolerance[j] = coefficientError * powerSum / derivative;
+    }
+    // A broad cluster tolerance must not hide a missing, well-conditioned root.
+    for (Index j = 0; j < real_roots.size(); ++j) {
+      VERIFY((numext::isfinite)(tolerance[j]));
+      VERIFY((psolve.roots().array() - real_roots[j]).abs().minCoeff() <= tolerance[j]);
+    }
+    for (Index i = 0; i < psolve.roots().size(); ++i) {
+      bool found = false;
+      for (Index j = 0; j < real_roots.size() && !found; ++j) {
+        VERIFY((numext::isfinite)(tolerance[j]));
+        if (numext::abs(psolve.roots()[i] - real_roots[j]) <= tolerance[j]) found = true;
+      }
+      VERIFY(found);
+    }
+  }
+  verify_polynomialsolver_sugar(psolve, numext::sqrt(test_precision<RealScalar>()));
+}
+
+void polynomialsolver_sugar_cluster() {
+  Matrix<float, 7, 1> roots;
+  roots << -0.8f, 0.2f, 0.2001f, 0.5f, 0.7f, 0.9f, 1.0f;
+  Matrix<float, 8, 1> poly;
+  roots_to_monicPolynomial(roots, poly);
+  evalSolverSugarFunction<7>(poly, roots);
+}
+
+void polynomialsolver_sugar_filtering() {
+  Vector4d poly;
+  poly << 0, 1, 0, 1;
+  PolynomialSolver<double, 3> solver(poly);
+  verify_polynomialsolver_sugar(solver, 0.0);
+  verify_polynomialsolver_sugar(solver, 0.5);
+  verify_polynomialsolver_sugar(solver, 1.0);
+  verify_polynomialsolver_sugar(solver, 2.0);
+  Vector3d noRealRoots;
+  noRealRoots << 1, 0, 1;
+  PolynomialSolver<double, 2> complexSolver(noRealRoots);
+  verify_polynomialsolver_sugar(complexSolver, 0.5);
+}
+
+template <typename Scalar_, int Deg_>
+void polynomialsolver(int deg) {
+  typedef typename NumTraits<Scalar_>::Real RealScalar;
+  typedef internal::increment_if_fixed_size<Deg_> Dim;
+  typedef Matrix<Scalar_, Dim::value, 1> PolynomialType;
+  typedef Matrix<Scalar_, Deg_, 1> EvalRootsType;
+  typedef Matrix<RealScalar, Deg_, 1> RealRootsType;
+
+  cout << "Standard cases" << endl;
+  PolynomialType pols = PolynomialType::Random(deg + 1);
+  evalSolver<Deg_, PolynomialType>(pols);
+
+  cout << "Hard cases" << endl;
+  Scalar_ multipleRoot = internal::random<Scalar_>();
+  EvalRootsType allRoots = EvalRootsType::Constant(deg, multipleRoot);
+  roots_to_monicPolynomial(allRoots, pols);
+  evalSolver<Deg_, PolynomialType>(pols);
+
+  // The companion matrix eigenvalue approach has limited accuracy for float at
+  // high degrees. The PolynomialSolver documentation itself warns: "With 32bit
+  // (float) floating types this problem shows up frequently." Skip the sugar
+  // function test (which requires exact root matching) for float beyond degree 8.
+  if (deg <= 8 || sizeof(RealScalar) > sizeof(float)) {
+    cout << "Test sugar" << endl;
+    RealRootsType realRoots = RealRootsType::Random(deg);
+    // sort by ascending absolute value to mitigate precision lost during polynomial expansion
+    std::sort(realRoots.begin(), realRoots.end(),
+              [](RealScalar a, RealScalar b) { return numext::abs(a) < numext::abs(b); });
+    roots_to_monicPolynomial(realRoots, pols);
+    evalSolverSugarFunction<Deg_>(pols, realRoots);
+  }
+}
+
+// Componentwise backward error |p(z)| / sum_k |a_k| |z|^k of a computed root, evaluated in WideReal so that the check
+// does not share the solver's rounding.
+template <typename WideReal, typename PolynomialType, typename RootType>
+WideReal root_backward_error(const PolynomialType& pols, const RootType& root) {
+  const std::complex<WideReal> z(WideReal(numext::real(root)), WideReal(numext::imag(root)));
+  std::complex<WideReal> value(0);
+  WideReal magnitude(0);
+  for (Index k = pols.size() - 1; k >= 0; --k) {
+    const std::complex<WideReal> coefficient(WideReal(numext::real(pols[k])), WideReal(numext::imag(pols[k])));
+    value = value * z + coefficient;
+    magnitude = magnitude * numext::abs(z) + numext::abs(coefficient);
+  }
+  return numext::abs(value) / magnitude;
+}
+
+// Every refined root must be an exact root of a nearby polynomial, and, where first-order perturbation theory applies,
+// within its condition bound of the same polynomial's roots solved in WideScalar. The roots of a real polynomial must
+// be real or exact conjugate pairs.
+template <typename Scalar, typename WideScalar, int Deg>
+void polynomialsolver_refinement_accuracy(int deg) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using WideReal = typename NumTraits<WideScalar>::Real;
+  using PolynomialType = Matrix<Scalar, internal::increment_if_fixed_size<Deg>::value, 1>;
+  using RootsType = Matrix<Scalar, Deg, 1>;
+  const RootsType roots = RootsType::Random(deg);
+  PolynomialType pols;
+  roots_to_monicPolynomial(roots, pols);
+  PolynomialSolver<Scalar, Deg> solver(pols);
+  const WideReal eps = WideReal(NumTraits<RealScalar>::epsilon());
+
+  // A Newton correction below one ulp bounds |p(z)| by eps |z p'(z)| <= deg eps sum_k |a_k| |z|^k; sampled roots of
+  // float and double polynomials up to degree 50 stay below 6 eps.
+  for (Index i = 0; i < deg; ++i)
+    VERIFY(root_backward_error<WideReal>(pols, solver.roots()[i]) <= WideReal(4 * deg) * eps);
+
+  if (!NumTraits<Scalar>::IsComplex) {
+    for (Index i = 0; i < deg; ++i) {
+      if (numext::imag(solver.roots()[i]) == RealScalar(0)) continue;
+      bool paired = false;
+      for (Index j = 0; j < deg && !paired; ++j)
+        paired = j != i && solver.roots()[j] == numext::conj(solver.roots()[i]);
+      VERIFY(paired);
+    }
+  }
+
+  // A coefficient perturbation of size delta moves a simple root r_j by at most
+  // delta * sum_k |r_j|^k / prod_{k != j} |r_j - r_k| to first order, valid while that is small against the gap to the
+  // nearest other root. Each such root must have a computed root within 16 times the bound at delta = eps max_k |a_k|.
+  const PolynomialSolver<WideScalar, Deg> reference(pols.template cast<WideScalar>().eval());
+  const WideReal delta = eps * WideReal(pols.cwiseAbs().maxCoeff());
+  for (Index j = 0; j < deg; ++j) {
+    const std::complex<WideReal> r = reference.roots()[j];
+    WideReal powerSum(0), power(1), derivative(1), gap = NumTraits<WideReal>::highest();
+    for (Index k = 0; k <= deg; ++k) {
+      powerSum += power;
+      power *= numext::abs(r);
+    }
+    for (Index k = 0; k < deg; ++k) {
+      if (k == j) continue;
+      const WideReal d = numext::abs(r - std::complex<WideReal>(reference.roots()[k]));
+      derivative *= d;
+      gap = numext::mini(gap, d);
+    }
+    const WideReal bound = WideReal(16) * delta * powerSum / derivative;
+    if (!(WideReal(4) * bound < gap)) continue;
+    WideReal distance = NumTraits<WideReal>::highest();
+    for (Index i = 0; i < deg; ++i) {
+      const std::complex<WideReal> z(WideReal(numext::real(solver.roots()[i])),
+                                     WideReal(numext::imag(solver.roots()[i])));
+      distance = numext::mini(distance, numext::abs(z - r));
+    }
+    VERIFY(distance <= bound);
+  }
+}
+
+// At |z| = 3 rounding dominates the residual of the pair 0.1 +- 3i, which is still an accurate root; comparing that
+// residual with the one at the real part 0.1 once reported the pair as a double real root.
+void polynomialsolver_complex_pair_kept() {
+  Matrix<std::complex<float>, 12, 1> roots;
+  roots << std::complex<float>(0.1f, 3.0f), std::complex<float>(0.1f, -3.0f), 0.2f, -0.2f, 0.4f, -0.4f, 0.6f, -0.6f,
+      0.8f, -0.8f, 1.0f, -1.0f;
+  Matrix<std::complex<float>, 13, 1> complexPolynomial;
+  roots_to_monicPolynomial(roots, complexPolynomial);
+  const Matrix<float, 13, 1> pols = complexPolynomial.real();
+  PolynomialSolver<float, 12> solver(pols);
+  Index farFromAxis = 0;
+  for (Index i = 0; i < 12; ++i) {
+    VERIFY(root_backward_error<double>(pols, solver.roots()[i]) <= 48 * double(NumTraits<float>::epsilon()));
+    if (numext::abs(numext::imag(solver.roots()[i])) > 1.0f) ++farFromAxis;
+  }
+  VERIFY_IS_EQUAL(farFromAxis, Index(2));
+}
+
+// The companion eigenvalue of a root at 1e-12 carries an absolute error of order eps, a backward error of about
+// 3e3 eps; refinement restores the root's full relative accuracy.
+void polynomialsolver_tiny_root() {
+  Matrix<double, 5, 1> roots;
+  roots << 1e-12, 0.25, -0.5, 0.75, -1.0;
+  Matrix<double, 6, 1> pols;
+  roots_to_monicPolynomial(roots, pols);
+  PolynomialSolver<double, 5> solver(pols);
+  const double eps = NumTraits<double>::epsilon();
+  bool found = false;
+  for (Index i = 0; i < 5; ++i) {
+    VERIFY(root_backward_error<long double>(pols, solver.roots()[i]) <= static_cast<long double>(20 * eps));
+    found = found || numext::abs(solver.roots()[i] - std::complex<double>(1e-12)) <= 16 * eps * 1e-12;
+  }
+  VERIFY(found);
+}
+
+template <typename Polynomial, typename Roots>
+void polynomialsolver_verify_root_set(const Polynomial& poly, const Roots& expected) {
+  using Scalar = typename Polynomial::Scalar;
+  using Real = typename NumTraits<Scalar>::Real;
+  const PolynomialSolver<Scalar, Roots::RowsAtCompileTime> solver(poly);
+  Array<bool, Dynamic, 1> matched = Array<bool, Dynamic, 1>::Constant(expected.size(), false);
+  VERIFY_IS_EQUAL(solver.roots().size(), expected.size());
+  // These exactly represented polynomials have well-separated simple roots or exact roots at zero.
+  const Real tolerance = Real(64) * NumTraits<Real>::epsilon();
+  for (Index i = 0; i < expected.size(); ++i) {
+    Index match = expected.size();
+    for (Index j = 0; j < expected.size(); ++j) {
+      if (!matched[j] && numext::abs(solver.roots()[i] - expected[j]) <= tolerance) {
+        match = j;
+        break;
+      }
+    }
+    VERIFY(match < expected.size());
+    matched[match] = true;
+  }
+}
+
+template <typename Scalar>
+void polynomialsolver_real_part_is_another_root() {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Complex = std::complex<Real>;
+  Matrix<Scalar, 4, 1> poly;
+  Matrix<Complex, 3, 1> expected;
+  poly << 0, 1, 0, 1;
+  expected << Complex(0), Complex(0, 1), Complex(0, -1);
+  polynomialsolver_verify_root_set(poly, expected);
+  poly << -2, 4, -3, 1;
+  expected << Complex(1), Complex(1, 1), Complex(1, -1);
+  polynomialsolver_verify_root_set(poly, expected);
+
+  Matrix<Scalar, Dynamic, 1> repeated(5);
+  Matrix<Complex, Dynamic, 1> repeatedExpected(4);
+  repeated << 0, 0, 1, 0, 1;
+  repeatedExpected << Complex(0), Complex(0), Complex(0, 1), Complex(0, -1);
+  polynomialsolver_verify_root_set(repeated, repeatedExpected);
+}
+
+template <typename Scalar>
+void polynomialsolver_scaled_quadratic() {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Complex = std::complex<Real>;
+  Matrix<Scalar, 3, 1> poly;
+  Matrix<Complex, 2, 1> expected;
+  expected << Complex(0, 1), Complex(0, -1);
+  const Real scales[] = {Real(1), NumTraits<Real>::highest() * Real(0.75), (std::numeric_limits<Real>::min)()};
+  for (Real scale : scales) {
+    poly << Scalar(scale), Scalar(0), Scalar(scale);
+    polynomialsolver_verify_root_set(poly, expected);
+  }
+}
+
+template <int Degree>
+void polynomialsolver_real_starts_for_complex_pair() {
+  Matrix<double, 7, 1> poly;
+  poly << 0.015754773452117808, -0.2921305061016638, 1.8654828811488313, -4.9912618133859823, 6.4755674799802918,
+      -4.0734106361481288, 1;
+  PolynomialSolver<double, Degree> solver(poly);
+  // A nearly double nonreal pair initially appears as two real eigenvalues. Unconverged real-axis refinement
+  // used to increase the maximum componentwise backward error from 2.2 eps to 3.1e5 eps.
+  const long double tolerance = 32 * static_cast<long double>(NumTraits<double>::epsilon());
+  for (Index i = 0; i < solver.roots().size(); ++i)
+    VERIFY(root_backward_error<long double>(poly, solver.roots()[i]) <= tolerance);
+}
+
+EIGEN_DECLARE_TEST(polynomialsolver) {
+  CALL_SUBTEST_7(polynomialsolver_sugar_cluster());
+  CALL_SUBTEST_13(polynomialsolver_sugar_filtering());
+  CALL_SUBTEST_18(polynomialsolver_real_starts_for_complex_pair<6>());
+  CALL_SUBTEST_18(polynomialsolver_real_starts_for_complex_pair<Dynamic>());
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1((polynomialsolver<float, 1>(1)));
+    CALL_SUBTEST_2((polynomialsolver<double, 2>(2)));
+    CALL_SUBTEST_3((polynomialsolver<double, 3>(3)));
+    CALL_SUBTEST_4((polynomialsolver<float, 4>(4)));
+    CALL_SUBTEST_5((polynomialsolver<double, 5>(5)));
+    CALL_SUBTEST_6((polynomialsolver<float, 6>(6)));
+    CALL_SUBTEST_7((polynomialsolver<float, 7>(7)));
+    CALL_SUBTEST_8((polynomialsolver<double, 8>(8)));
+
+    CALL_SUBTEST_9((polynomialsolver<float, Dynamic>(internal::random<int>(9, 13))));
+    CALL_SUBTEST_10((polynomialsolver<double, Dynamic>(internal::random<int>(9, 13))));
+    CALL_SUBTEST_11((polynomialsolver<float, Dynamic>(1)));
+    CALL_SUBTEST_12((polynomialsolver<std::complex<double>, Dynamic>(internal::random<int>(2, 13))));
+
+    CALL_SUBTEST_13((polynomialsolver_refinement_accuracy<float, double, 4>(4)));
+    CALL_SUBTEST_19((polynomialsolver_refinement_accuracy<float, double, 6>(6)));
+    CALL_SUBTEST_20((polynomialsolver_refinement_accuracy<float, double, 7>(7)));
+    CALL_SUBTEST_14((polynomialsolver_refinement_accuracy<float, double, Dynamic>(internal::random<int>(8, 13))));
+    CALL_SUBTEST_21((polynomialsolver_refinement_accuracy<std::complex<float>, std::complex<double>, Dynamic>(
+        internal::random<int>(2, 13))));
+    CALL_SUBTEST_22((polynomialsolver_refinement_accuracy<double, long double, Dynamic>(internal::random<int>(2, 20))));
+  }
+  CALL_SUBTEST_15(polynomialsolver_complex_pair_kept());
+  CALL_SUBTEST_15(polynomialsolver_tiny_root());
+  CALL_SUBTEST_16(polynomialsolver_real_part_is_another_root<float>());
+  CALL_SUBTEST_23(polynomialsolver_real_part_is_another_root<double>());
+  CALL_SUBTEST_24(polynomialsolver_real_part_is_another_root<std::complex<double>>());
+  CALL_SUBTEST_17(polynomialsolver_scaled_quadratic<float>());
+  CALL_SUBTEST_17(polynomialsolver_scaled_quadratic<double>());
+  CALL_SUBTEST_25(polynomialsolver_scaled_quadratic<std::complex<double>>());
+}
diff --git a/contrib/test/polynomialutils.cpp b/contrib/test/polynomialutils.cpp
new file mode 100644
index 0000000..fbf6978
--- /dev/null
+++ b/contrib/test/polynomialutils.cpp
@@ -0,0 +1,101 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <contrib/Eigen/Polynomials>
+#include <iostream>
+
+using namespace std;
+
+namespace Eigen {
+namespace internal {
+template <int Size>
+struct increment_if_fixed_size : std::integral_constant<int, (Size == Dynamic) ? Dynamic : Size + 1> {};
+}  // namespace internal
+}  // namespace Eigen
+
+template <typename Scalar_, int Deg_>
+void realRoots_to_monicPolynomial_test(int deg) {
+  typedef internal::increment_if_fixed_size<Deg_> Dim;
+  typedef Matrix<Scalar_, Dim::value, 1> PolynomialType;
+  typedef Matrix<Scalar_, Deg_, 1> EvalRootsType;
+
+  PolynomialType pols(deg + 1);
+  EvalRootsType roots = EvalRootsType::Random(deg);
+  roots_to_monicPolynomial(roots, pols);
+
+  EvalRootsType evr(deg);
+  for (int i = 0; i < roots.size(); ++i) {
+    evr[i] = std::abs(poly_eval(pols, roots[i]));
+  }
+
+  bool evalToZero = evr.isZero(test_precision<Scalar_>());
+  if (!evalToZero) {
+    cerr << evr.transpose() << endl;
+  }
+  VERIFY(evalToZero);
+}
+
+template <typename Scalar_>
+void realRoots_to_monicPolynomial_scalar() {
+  CALL_SUBTEST_2((realRoots_to_monicPolynomial_test<Scalar_, 2>(2)));
+  CALL_SUBTEST_3((realRoots_to_monicPolynomial_test<Scalar_, 3>(3)));
+  CALL_SUBTEST_4((realRoots_to_monicPolynomial_test<Scalar_, 4>(4)));
+  CALL_SUBTEST_5((realRoots_to_monicPolynomial_test<Scalar_, 5>(5)));
+  CALL_SUBTEST_6((realRoots_to_monicPolynomial_test<Scalar_, 6>(6)));
+  CALL_SUBTEST_7((realRoots_to_monicPolynomial_test<Scalar_, 7>(7)));
+  CALL_SUBTEST_8((realRoots_to_monicPolynomial_test<Scalar_, 17>(17)));
+
+  CALL_SUBTEST_9((realRoots_to_monicPolynomial_test<Scalar_, Dynamic>(internal::random<int>(18, 26))));
+}
+
+template <typename Scalar_, int Deg_>
+void CauchyBounds(int deg) {
+  typedef internal::increment_if_fixed_size<Deg_> Dim;
+  typedef Matrix<Scalar_, Dim::value, 1> PolynomialType;
+  typedef Matrix<Scalar_, Deg_, 1> EvalRootsType;
+
+  PolynomialType pols(deg + 1);
+  EvalRootsType roots = EvalRootsType::Random(deg);
+  roots_to_monicPolynomial(roots, pols);
+  Scalar_ M = cauchy_max_bound(pols);
+  Scalar_ m = cauchy_min_bound(pols);
+  Scalar_ Max = roots.array().abs().maxCoeff();
+  Scalar_ min = roots.array().abs().minCoeff();
+  bool eval = (M >= Max) && (m <= min);
+  if (!eval) {
+    cerr << "Roots: " << roots << endl;
+    cerr << "Bounds: (" << m << ", " << M << ")" << endl;
+    cerr << "Min,Max: (" << min << ", " << Max << ")" << endl;
+  }
+  VERIFY(eval);
+}
+
+template <typename Scalar_>
+void CauchyBounds_scalar() {
+  CALL_SUBTEST_2((CauchyBounds<Scalar_, 2>(2)));
+  CALL_SUBTEST_3((CauchyBounds<Scalar_, 3>(3)));
+  CALL_SUBTEST_4((CauchyBounds<Scalar_, 4>(4)));
+  CALL_SUBTEST_5((CauchyBounds<Scalar_, 5>(5)));
+  CALL_SUBTEST_6((CauchyBounds<Scalar_, 6>(6)));
+  CALL_SUBTEST_7((CauchyBounds<Scalar_, 7>(7)));
+  CALL_SUBTEST_8((CauchyBounds<Scalar_, 17>(17)));
+
+  CALL_SUBTEST_9((CauchyBounds<Scalar_, Dynamic>(internal::random<int>(18, 26))));
+}
+
+EIGEN_DECLARE_TEST(polynomialutils) {
+  for (int i = 0; i < g_repeat; i++) {
+    realRoots_to_monicPolynomial_scalar<double>();
+    realRoots_to_monicPolynomial_scalar<float>();
+    CauchyBounds_scalar<double>();
+    CauchyBounds_scalar<float>();
+  }
+}
diff --git a/contrib/test/sparse_extra.cpp b/contrib/test/sparse_extra.cpp
new file mode 100644
index 0000000..b62798d
--- /dev/null
+++ b/contrib/test/sparse_extra.cpp
@@ -0,0 +1,250 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2010 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include <cstdlib>
+#include <string>
+
+#include "sparse.h"
+
+#ifdef min
+#undef min
+#endif
+
+#ifdef max
+#undef max
+#endif
+
+#include <Eigen/SparseExtra>
+
+// Read from an environment variable TEST_TMPDIR, if available,
+// and append the provided filename. Defaults to local directory.
+std::string GetTestTempFilename(const char* filename) {
+  const char* test_tmpdir = std::getenv("TEST_TMPDIR");
+  if (test_tmpdir == nullptr) {
+    return std::string(filename);
+  }
+  return std::string(test_tmpdir) + std::string("/") + std::string(filename);
+}
+
+template <typename SetterType, typename DenseType, typename Scalar, int Options>
+bool test_random_setter(SparseMatrix<Scalar, Options>& sm, const DenseType& ref,
+                        const std::vector<Vector2i>& nonzeroCoords) {
+  {
+    sm.setZero();
+    SetterType w(sm);
+    std::vector<Vector2i> remaining = nonzeroCoords;
+    while (!remaining.empty()) {
+      int i = internal::random<int>(0, static_cast<int>(remaining.size()) - 1);
+      w(remaining[i].x(), remaining[i].y()) = ref.coeff(remaining[i].x(), remaining[i].y());
+      remaining[i] = remaining.back();
+      remaining.pop_back();
+    }
+  }
+  return sm.isApprox(ref);
+}
+
+template <typename SparseMatrixType>
+void sparse_extra(const SparseMatrixType& ref) {
+  const Index rows = ref.rows();
+  const Index cols = ref.cols();
+  typedef typename SparseMatrixType::Scalar Scalar;
+
+  double density = (std::max)(8. / (rows * cols), 0.01);
+  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
+
+  SparseMatrixType m(rows, cols);
+  DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
+
+  std::vector<Vector2i> zeroCoords;
+  std::vector<Vector2i> nonzeroCoords;
+  initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
+
+  if (zeroCoords.size() == 0 || nonzeroCoords.size() == 0) return;
+
+  // random setter
+  //   {
+  //     m.setZero();
+  //     VERIFY_IS_NOT_APPROX(m, refMat);
+  //     SparseSetter<SparseMatrixType, RandomAccessPattern> w(m);
+  //     std::vector<Vector2i> remaining = nonzeroCoords;
+  //     while(!remaining.empty())
+  //     {
+  //       int i = internal::random<int>(0,remaining.size()-1);
+  //       w->coeffRef(remaining[i].x(),remaining[i].y()) = refMat.coeff(remaining[i].x(),remaining[i].y());
+  //       remaining[i] = remaining.back();
+  //       remaining.pop_back();
+  //     }
+  //   }
+  //   VERIFY_IS_APPROX(m, refMat);
+
+  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, StdMapTraits> >(m, refMat, nonzeroCoords)));
+  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, StdUnorderedMapTraits> >(m, refMat, nonzeroCoords)));
+#ifdef EIGEN_GOOGLEHASH_SUPPORT
+  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, GoogleDenseHashMapTraits> >(m, refMat, nonzeroCoords)));
+  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, GoogleSparseHashMapTraits> >(m, refMat, nonzeroCoords)));
+#endif
+
+  // test RandomSetter
+  /*{
+    SparseMatrixType m1(rows,cols), m2(rows,cols);
+    DenseMatrix refM1 = DenseMatrix::Zero(rows, rows);
+    initSparse<Scalar>(density, refM1, m1);
+    {
+      Eigen::RandomSetter<SparseMatrixType > setter(m2);
+      for (int j=0; j<m1.outerSize(); ++j)
+        for (typename SparseMatrixType::InnerIterator i(m1,j); i; ++i)
+          setter(i.index(), j) = i.value();
+    }
+    VERIFY_IS_APPROX(m1, m2);
+  }*/
+}
+
+template <typename SparseMatrixType>
+void check_marketio() {
+  typedef Matrix<typename SparseMatrixType::Scalar, Dynamic, Dynamic> DenseMatrix;
+  Index rows = internal::random<Index>(1, 100);
+  Index cols = internal::random<Index>(1, 100);
+  SparseMatrixType m1, m2;
+  m1 = DenseMatrix::Random(rows, cols).sparseView();
+  std::string filename = GetTestTempFilename("sparse_extra.mtx");
+  saveMarket(m1, filename);
+  loadMarket(m2, filename);
+  VERIFY_IS_EQUAL(DenseMatrix(m1), DenseMatrix(m2));
+}
+
+template <typename VectorType>
+void check_marketio_vector() {
+  Index size = internal::random<Index>(1, 100);
+  VectorType v1, v2;
+  v1 = VectorType::Random(size);
+  std::string filename = GetTestTempFilename("vector_extra.mtx");
+  saveMarketVector(v1, filename);
+  loadMarketVector(v2, filename);
+  VERIFY_IS_EQUAL(v1, v2);
+}
+
+template <typename DenseMatrixType>
+void check_marketio_dense() {
+  Index rows = DenseMatrixType::MaxRowsAtCompileTime;
+  if (DenseMatrixType::MaxRowsAtCompileTime == Dynamic) {
+    rows = internal::random<Index>(1, 100);
+  } else if (DenseMatrixType::RowsAtCompileTime == Dynamic) {
+    rows = internal::random<Index>(1, DenseMatrixType::MaxRowsAtCompileTime);
+  }
+
+  Index cols = DenseMatrixType::MaxColsAtCompileTime;
+  if (DenseMatrixType::MaxColsAtCompileTime == Dynamic) {
+    cols = internal::random<Index>(1, 100);
+  } else if (DenseMatrixType::ColsAtCompileTime == Dynamic) {
+    cols = internal::random<Index>(1, DenseMatrixType::MaxColsAtCompileTime);
+  }
+
+  DenseMatrixType m1, m2;
+  m1 = DenseMatrixType::Random(rows, cols);
+  std::string filename = GetTestTempFilename("dense_extra.mtx");
+  saveMarketDense(m1, filename);
+  loadMarketDense(m2, filename);
+  VERIFY_IS_EQUAL(m1, m2);
+}
+
+template <typename Scalar>
+void check_sparse_inverse() {
+  typedef SparseMatrix<Scalar> MatrixType;
+  typedef SparseMatrix<Scalar, RowMajor> RowMatrixType;
+
+  Matrix<Scalar, -1, -1> A;
+  A.resize(1000, 1000);
+  A.fill(0);
+  A.setIdentity();
+  A.col(0).array() += 1;
+  A.row(0).array() += 2;
+  A.col(2).array() += 3;
+  A.row(7).array() += 3;
+  A.col(9).array() += 3;
+  A.block(3, 4, 4, 2).array() += 9;
+  A.middleRows(10, 50).array() += 3;
+  A.middleCols(50, 50).array() += 40;
+  A.block(500, 300, 40, 20).array() += 10;
+  A.transposeInPlace();
+
+  Eigen::SparseLU<MatrixType> slu;
+  slu.compute(A.sparseView());
+  Matrix<Scalar, -1, -1> Id(A.rows(), A.cols());
+  Id.setIdentity();
+  Matrix<Scalar, -1, -1> inv = slu.solve(Id);
+
+  const MatrixType sparseInv = Eigen::SparseInverse<Scalar>().compute(A.sparseView()).inverse();
+
+  // The two inverses are computed independently (SparseLU solve against the identity vs the Takahashi
+  // recurrence), so entrywise and summed deviations scale with n * eps for this 1000x1000 matrix. The input is
+  // deterministic, but the deviation still moves by a factor of three with the accumulation order that the compiler,
+  // the ISA and the buffer alignment happen to produce, so these factors are the smallest powers of two at or above
+  // the long-standing 1e-11 and 1e-10 bounds rather than a tight fit to a single host.
+  Scalar sumdiff = 0;  // Check the diff only of the non-zero elements
+  for (Eigen::Index j = 0; j < A.cols(); j++) {
+    for (typename MatrixType::InnerIterator iter(sparseInv, j); iter; ++iter) {
+      const Scalar diff = std::abs(inv(iter.row(), iter.col()) - iter.value());
+      VERIFY_IS_APPROX_OR_LESS_THAN(diff, Scalar(65536) * NumTraits<Scalar>::epsilon());
+
+      if (iter.value() != 0) {
+        sumdiff += diff;
+      }
+    }
+  }
+
+  VERIFY_IS_APPROX_OR_LESS_THAN(sumdiff, Scalar(524288) * NumTraits<Scalar>::epsilon());
+
+  RowMatrixType DU = slu.matrixU().toSparse();
+  Matrix<Scalar, Dynamic, 1> invD = DU.diagonal().cwiseInverse();
+  RowMatrixType scaled_before_view = (invD.asDiagonal() * DU).template triangularView<StrictlyUpper>();
+  RowMatrixType view_before_scaled = invD.asDiagonal() * DU.template triangularView<StrictlyUpper>();
+  VERIFY_IS_APPROX(scaled_before_view, view_before_scaled);
+}
+
+EIGEN_DECLARE_TEST(sparse_extra) {
+  for (int i = 0; i < g_repeat; i++) {
+    int s = Eigen::internal::random<int>(1, 50);
+    CALL_SUBTEST_1(sparse_extra(SparseMatrix<double>(8, 8)));
+    CALL_SUBTEST_2(sparse_extra(SparseMatrix<std::complex<double> >(s, s)));
+    CALL_SUBTEST_1(sparse_extra(SparseMatrix<double>(s, s)));
+
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<float, ColMajor, int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<double, ColMajor, int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<float>, ColMajor, int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<double>, ColMajor, int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<float, ColMajor, long int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<double, ColMajor, long int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<float>, ColMajor, long int> >()));
+    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<double>, ColMajor, long int> >()));
+
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<float, Dynamic, Dynamic> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<float, Dynamic, Dynamic, RowMajor> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, Dynamic, Dynamic> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<std::complex<float>, Dynamic, Dynamic> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<std::complex<double>, Dynamic, Dynamic> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<float, Dynamic, 3> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, 3, Dynamic> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, 3, 4> >()));
+    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, Dynamic, Dynamic, ColMajor, 5, 5> >()));
+
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<float, 1, Dynamic> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<double, 1, Dynamic> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<float>, 1, Dynamic> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<double>, 1, Dynamic> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<float, Dynamic, 1> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<double, Dynamic, 1> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<float>, Dynamic, 1> >()));
+    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<double>, Dynamic, 1> >()));
+
+    CALL_SUBTEST_6((check_sparse_inverse<double>()));
+
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+  }
+}
diff --git a/contrib/test/special_functions.cpp b/contrib/test/special_functions.cpp
new file mode 100644
index 0000000..1b2efb2
--- /dev/null
+++ b/contrib/test/special_functions.cpp
@@ -0,0 +1,623 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include <limits.h>
+#include "main.h"
+#include "../Eigen/SpecialFunctions"
+
+// Workaround to allow "implicit" conversions from double to Scalar via comma-initialization.
+template <typename Derived>
+Eigen::CommaInitializer<Derived> operator<<(Eigen::DenseBase<Derived>& dense, double v) {
+  return (dense << static_cast<typename Derived::Scalar>(v));
+}
+
+template <typename XprType>
+Eigen::CommaInitializer<XprType>& operator,(Eigen::CommaInitializer<XprType>& ci, double v) {
+  return (ci, static_cast<typename XprType::Scalar>(v));
+}
+
+template <typename X, typename Y>
+void verify_component_wise(const X& x, const Y& y) {
+  for (Index i = 0; i < x.size(); ++i) {
+    if ((numext::isfinite)(y(i)))
+      VERIFY_IS_APPROX(x(i), y(i));
+    else if ((numext::isnan)(y(i)))
+      VERIFY((numext::isnan)(x(i)));
+    else
+      VERIFY_IS_EQUAL(x(i), y(i));
+  }
+}
+
+template <typename ArrayType>
+void array_special_functions() {
+  using std::abs;
+  using std::sqrt;
+  typedef typename ArrayType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  Scalar plusinf = std::numeric_limits<Scalar>::infinity();
+  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
+
+  Index rows = internal::random<Index>(1, 30);
+  Index cols = 1;
+
+  // API
+  {
+    ArrayType m1 = ArrayType::Random(rows, cols);
+    VERIFY_IS_APPROX(m1.lgamma(), lgamma(m1));
+    VERIFY_IS_APPROX(m1.digamma(), digamma(m1));
+    VERIFY_IS_APPROX(m1.erf(), erf(m1));
+    VERIFY_IS_APPROX(m1.erfc(), erfc(m1));
+  }
+
+  // check special functions (comparing against numpy implementation)
+  if (!NumTraits<Scalar>::IsComplex) {
+    {
+      ArrayType m1 = ArrayType::Random(rows, cols);
+      ArrayType m2 = ArrayType::Random(rows, cols);
+
+      // Test various properties of igamma & igammac.  These are normalized
+      // gamma integrals where
+      //   igammac(a, x) = Gamma(a, x) / Gamma(a)
+      //   igamma(a, x) = gamma(a, x) / Gamma(a)
+      // where Gamma and gamma are considered the standard unnormalized
+      // upper and lower incomplete gamma functions, respectively.
+      ArrayType a = m1.abs() + Scalar(2);
+      ArrayType x = m2.abs() + Scalar(2);
+      ArrayType zero = ArrayType::Zero(rows, cols);
+      ArrayType one = ArrayType::Constant(rows, cols, Scalar(1.0));
+      ArrayType a_m1 = a - one;
+      ArrayType Gamma_a_x = Eigen::igammac(a, x) * a.lgamma().exp();
+      ArrayType Gamma_a_m1_x = Eigen::igammac(a_m1, x) * a_m1.lgamma().exp();
+      ArrayType gamma_a_x = Eigen::igamma(a, x) * a.lgamma().exp();
+      ArrayType gamma_a_m1_x = Eigen::igamma(a_m1, x) * a_m1.lgamma().exp();
+
+      // Gamma(a, 0) == Gamma(a)
+      VERIFY_IS_APPROX(Eigen::igammac(a, zero), one);
+
+      // Gamma(a, x) + gamma(a, x) == Gamma(a)
+      VERIFY_IS_APPROX(Gamma_a_x + gamma_a_x, a.lgamma().exp());
+
+      // Gamma(a, x) == (a - 1) * Gamma(a-1, x) + x^(a-1) * exp(-x)
+      VERIFY_IS_APPROX(Gamma_a_x, (a - Scalar(1)) * Gamma_a_m1_x + x.pow(a - Scalar(1)) * (-x).exp());
+
+      // gamma(a, x) == (a - 1) * gamma(a-1, x) - x^(a-1) * exp(-x)
+      VERIFY_IS_APPROX(gamma_a_x, (a - Scalar(1)) * gamma_a_m1_x - x.pow(a - Scalar(1)) * (-x).exp());
+    }
+    {
+      // Verify for large a and x that values are between 0 and 1.
+      ArrayType m1 = ArrayType::Random(rows, cols);
+      ArrayType m2 = ArrayType::Random(rows, cols);
+      int max_exponent = std::numeric_limits<Scalar>::max_exponent10;
+      ArrayType a = m1.abs() * Scalar(pow(10., max_exponent - 1));
+      ArrayType x = m2.abs() * Scalar(pow(10., max_exponent - 1));
+      for (int i = 0; i < a.size(); ++i) {
+        Scalar igam = numext::igamma(a(i), x(i));
+        VERIFY(0 <= igam);
+        VERIFY(igam <= 1);
+      }
+    }
+
+    {
+      // Check exact values of igamma and igammac against a third party calculation.
+      Scalar a_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
+      Scalar x_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
+
+      // location i*6+j corresponds to a_s[i], x_s[j].
+      Scalar igamma_s[][6] = {
+          {Scalar(0.0), nan, nan, nan, nan, nan},
+          {Scalar(0.0), Scalar(0.6321205588285578), Scalar(0.7768698398515702), Scalar(0.9816843611112658),
+           Scalar(9.999500016666262e-05), Scalar(1.0)},
+          {Scalar(0.0), Scalar(0.4275932955291202), Scalar(0.608374823728911), Scalar(0.9539882943107686),
+           Scalar(7.522076445089201e-07), Scalar(1.0)},
+          {Scalar(0.0), Scalar(0.01898815687615381), Scalar(0.06564245437845008), Scalar(0.5665298796332909),
+           Scalar(4.166333347221828e-18), Scalar(1.0)},
+          {Scalar(0.0), Scalar(0.9999780593618628), Scalar(0.9999899967080838), Scalar(0.9999996219837988),
+           Scalar(0.9991370418689945), Scalar(1.0)},
+          {Scalar(0.0), Scalar(0.0), Scalar(0.0), Scalar(0.0), Scalar(0.0), Scalar(0.5042041932513908)}};
+      Scalar igammac_s[][6] = {
+          {nan, nan, nan, nan, nan, nan},
+          {Scalar(1.0), Scalar(0.36787944117144233), Scalar(0.22313016014842982), Scalar(0.018315638888734182),
+           Scalar(0.9999000049998333), Scalar(0.0)},
+          {Scalar(1.0), Scalar(0.5724067044708798), Scalar(0.3916251762710878), Scalar(0.04601170568923136),
+           Scalar(0.9999992477923555), Scalar(0.0)},
+          {Scalar(1.0), Scalar(0.9810118431238462), Scalar(0.9343575456215499), Scalar(0.4334701203667089), Scalar(1.0),
+           Scalar(0.0)},
+          {Scalar(1.0), Scalar(2.1940638138146658e-05), Scalar(1.0003291916285e-05), Scalar(3.7801620118431334e-07),
+           Scalar(0.0008629581310054535), Scalar(0.0)},
+          {Scalar(1.0), Scalar(1.0), Scalar(1.0), Scalar(1.0), Scalar(1.0), Scalar(0.49579580674813944)}};
+
+      for (int i = 0; i < 6; ++i) {
+        for (int j = 0; j < 6; ++j) {
+          if ((std::isnan)(igamma_s[i][j])) {
+            VERIFY((std::isnan)(numext::igamma(a_s[i], x_s[j])));
+          } else {
+            VERIFY_IS_APPROX(numext::igamma(a_s[i], x_s[j]), igamma_s[i][j]);
+          }
+
+          if ((std::isnan)(igammac_s[i][j])) {
+            VERIFY((std::isnan)(numext::igammac(a_s[i], x_s[j])));
+          } else {
+            VERIFY_IS_APPROX(numext::igammac(a_s[i], x_s[j]), igammac_s[i][j]);
+          }
+        }
+      }
+    }
+  }
+
+  // Check the ndtri function against scipy.special.ndtri
+  {
+    ArrayType x(11), res(11), ref(11);
+    x << 0.5, 0.2, 0.8, 0.9, 0.1, 0.99, 0.01, 0, 1, -0.01, 1.01;
+    ref << 0., -0.8416212335729142, 0.8416212335729142, 1.2815515655446004, -1.2815515655446004, 2.3263478740408408,
+        -2.3263478740408408, -plusinf, plusinf, nan, nan;
+    CALL_SUBTEST(verify_component_wise(ref, ref););
+    CALL_SUBTEST(res = x.ndtri(); verify_component_wise(res, ref););
+    CALL_SUBTEST(res = ndtri(x); verify_component_wise(res, ref););
+
+    // ndtri(normal_cdf(x)) ~= x
+    CALL_SUBTEST(ArrayType m1 = ArrayType::Random(32); using std::sqrt;
+
+                 ArrayType cdf_val = (m1 / Scalar(sqrt(2.))).erf(); cdf_val = (cdf_val + Scalar(1)) / Scalar(2);
+                 verify_component_wise(cdf_val.ndtri(), m1););
+  }
+
+  // Check the zeta function against scipy.special.zeta
+  {
+    ArrayType x(11), q(11), res(11), ref(11);
+    x << 1.5, 4, 10.5, 10000.5, 3, 1, 0.9, 2, 3, 4, 2000;
+    q << 2, 1.5, 3, 1.0001, -2.5, 1.2345, 1.2345, -1, -2, -3, 2000;
+    ref << 1.61237534869, 0.234848505667, 1.03086757337e-5, 0.367879440865, 0.054102025820864097, plusinf, nan, plusinf,
+        nan, plusinf, 0;
+    CALL_SUBTEST(verify_component_wise(ref, ref););
+    CALL_SUBTEST(res = x.zeta(q); verify_component_wise(res, ref););
+    CALL_SUBTEST(res = zeta(x, q); verify_component_wise(res, ref););
+  }
+
+  // digamma
+  {
+    ArrayType x(10), res(10), ref(10);
+    x << 1, 1.5, 4, -10.5, 10000.5, 0.0, -0.0, -1, -2, -3;
+    ref << -0.5772156649015329, 0.03648997397857645, 1.2561176684318, 2.398239129535781, 9.210340372392849, -plusinf,
+        plusinf, nan, nan, nan;
+    CALL_SUBTEST(verify_component_wise(ref, ref););
+
+    CALL_SUBTEST(res = x.digamma(); verify_component_wise(res, ref););
+    CALL_SUBTEST(res = digamma(x); verify_component_wise(res, ref););
+  }
+
+  {
+    ArrayType n(16), x(16), res(16), ref(16);
+    n << 1, 1, 1, 1.5, 17, 31, 28, 8, 42, 147, 170, -1, 0, 1, 2, 3;
+    x << 2, 3, 25.5, 1.5, 4.7, 11.8, 17.7, 30.2, 15.8, 54.1, 64, -1, -2, -3, -4, -5;
+    ref << 0.644934066848, 0.394934066848, 0.0399946696496, nan, 293.334565435, 0.445487887616, -2.47810300902e-07,
+        -8.29668781082e-09, -0.434562276666, 0.567742190178, -0.0108615497927, nan, nan, plusinf, nan, plusinf;
+    CALL_SUBTEST(verify_component_wise(ref, ref););
+
+    if (sizeof(RealScalar) >= 8) {  // double
+      // Reason for commented line: http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1232
+      //       CALL_SUBTEST( res = x.polygamma(n); verify_component_wise(res, ref); );
+      CALL_SUBTEST(res = polygamma(n, x); verify_component_wise(res, ref););
+    } else {
+      //       CALL_SUBTEST( res = x.polygamma(n); verify_component_wise(res.head(8), ref.head(8)); );
+      CALL_SUBTEST(res = polygamma(n, x); verify_component_wise(res.head(8), ref.head(8)););
+    }
+  }
+
+  {
+    // Inputs and ground truth generated with scipy via:
+    //   a = np.logspace(-3, 3, 5) - 1e-3
+    //   b = np.logspace(-3, 3, 5) - 1e-3
+    //   x = np.linspace(-0.1, 1.1, 5)
+    //   (full_a, full_b, full_x) = np.vectorize(lambda a, b, x: (a, b, x))(*np.ix_(a, b, x))
+    //   full_a = full_a.flatten().tolist()
+    //   full_b = full_b.flatten().tolist()
+    //   full_x = full_x.flatten().tolist()
+    //   v = scipy.special.betainc(full_a, full_b, full_x).flatten().tolist()
+    // Note in Eigen, we call betainc with arguments in the order (a, b, x);
+    ArrayType a(125);
+    ArrayType b(125);
+    ArrayType x(125);
+    ArrayType v(125);
+    ArrayType res(125);
+
+    a << 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+        0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999,
+        0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999,
+        999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999,
+        999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999;
+
+    b << 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+        31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999,
+        0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+        31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999,
+        0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999,
+        999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999,
+        999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379,
+        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999,
+        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999,
+        999.999, 999.999, 999.999;
+
+    x << -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1,
+        0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2,
+        0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5,
+        0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8,
+        1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1,
+        -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1;
+
+    v << nan, nan, nan, nan, nan, nan, 1.0, 1.0, 1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 1.0,
+        1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan, 0.47972119876364683, 0.4999999999999997, 0.5202788012363533, nan,
+        nan, 0.9518683957740043, 0.9789663010413745, 0.993172918807344, nan, nan, 0.999995949033062, 0.99999999999937,
+        1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan, 0.0068270811926558735, 0.0210336989586256,
+        0.048131604225995696, nan, nan, 0.20014344256217687, 0.5000000000000002, 0.7998565574378237, nan, nan,
+        0.9991401428435834, 0.9999999996984031, 1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan,
+        1.0646600232370862e-25, 6.30172287782625e-13, 4.050966937974916e-06, nan, nan, 7.864342668429712e-23,
+        3.015969667594142e-10, 0.0008598571564165379, nan, nan, 6.031987710123845e-08, 0.5000000000000001,
+        0.9999999396801229, nan, nan, 1.0, 1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan, 0.0, 7.029920380993552e-306,
+        2.245072820861537e-101, nan, nan, 0.0, 9.275871147875753e-302, 1.223291302616039e-97, nan, nan, 0.0,
+        3.089139308197642e-252, 2.9303043666230076e-60, nan, nan, 2.248913486881819e-196, 0.5000000000000036, 1.0, nan;
+
+    CALL_SUBTEST(res = betainc(a, b, x); verify_component_wise(res, v););
+  }
+
+  // Test various properties of betainc
+  {
+    ArrayType m1 = ArrayType::Random(32);
+    ArrayType m2 = ArrayType::Random(32);
+    ArrayType m3 = ArrayType::Random(32);
+    ArrayType one = ArrayType::Constant(32, Scalar(1.0));
+    const Scalar eps = std::numeric_limits<Scalar>::epsilon();
+    ArrayType a = (m1 * Scalar(4)).exp();
+    ArrayType b = (m2 * Scalar(4)).exp();
+    ArrayType x = m3.abs();
+
+    // betainc(a, 1, x) == x**a
+    CALL_SUBTEST(ArrayType test = betainc(a, one, x); ArrayType expected = x.pow(a);
+                 verify_component_wise(test, expected););
+
+    // betainc(1, b, x) == 1 - (1 - x)**b
+    CALL_SUBTEST(ArrayType test = betainc(one, b, x); ArrayType expected = one - (one - x).pow(b);
+                 verify_component_wise(test, expected););
+
+    // betainc(a, b, x) == 1 - betainc(b, a, 1-x)
+    CALL_SUBTEST(ArrayType test = betainc(a, b, x) + betainc(b, a, one - x); ArrayType expected = one;
+                 verify_component_wise(test, expected););
+
+    // betainc(a+1, b, x) = betainc(a, b, x) - x**a * (1 - x)**b / (a * beta(a, b))
+    CALL_SUBTEST(
+        ArrayType num = x.pow(a) * (one - x).pow(b);
+        ArrayType denom = a * (a.lgamma() + b.lgamma() - (a + b).lgamma()).exp();
+        // Add eps to rhs and lhs so that component-wise test doesn't result in
+        // nans when both outputs are zeros.
+        ArrayType expected = betainc(a, b, x) - num / denom + eps;
+        ArrayType test = betainc(a + one, b, x) + eps; if (sizeof(Scalar) >= 8) {  // double
+          verify_component_wise(test, expected);
+        } else {
+          // Reason for limited test: http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1232
+          verify_component_wise(test.head(8), expected.head(8));
+        });
+
+    // betainc(a, b+1, x) = betainc(a, b, x) + x**a * (1 - x)**b / (b * beta(a, b))
+    CALL_SUBTEST(
+        // Add eps to rhs and lhs so that component-wise test doesn't result in
+        // nans when both outputs are zeros.
+        ArrayType num = x.pow(a) * (one - x).pow(b);
+        ArrayType denom = b * (a.lgamma() + b.lgamma() - (a + b).lgamma()).exp();
+        ArrayType expected = betainc(a, b, x) + num / denom + eps; ArrayType test = betainc(a, b + one, x) + eps;
+        verify_component_wise(test, expected););
+  }
+
+  /* Code to generate the data for the following two test cases.
+  N = 5
+  np.random.seed(3)
+
+  a = np.logspace(-2, 3, 6)
+  a = np.ravel(np.tile(np.reshape(a, [-1, 1]), [1, N]))
+  x = np.random.gamma(a, 1.0)
+  x = np.maximum(x, np.finfo(np.float32).tiny)
+
+  def igamma(a, x):
+    return mpmath.gammainc(a, 0, x, regularized=True)
+
+  def igamma_der_a(a, x):
+    res = mpmath.diff(lambda a_prime: igamma(a_prime, x), a)
+    return np.float64(res)
+
+  def gamma_sample_der_alpha(a, x):
+    igamma_x = igamma(a, x)
+    def igammainv_of_igamma(a_prime):
+      return mpmath.findroot(lambda x_prime: igamma(a_prime, x_prime) -
+          igamma_x, x, solver='newton')
+    return np.float64(mpmath.diff(igammainv_of_igamma, a))
+
+  v_igamma_der_a = np.vectorize(igamma_der_a)(a, x)
+  v_gamma_sample_der_alpha = np.vectorize(gamma_sample_der_alpha)(a, x)
+*/
+
+  // Test igamma_der_a
+  {
+    ArrayType a(30);
+    ArrayType x(30);
+    ArrayType res(30);
+    ArrayType v(30);
+
+    a << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0, 10.0, 10.0,
+        100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
+
+    x << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
+        5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
+        1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
+        10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
+        968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
+
+    v << -32.7256441441, -36.4394150514, -9.66467612263, -36.4394150514, -36.4394150514, -1.0891900302, -2.66351229645,
+        -2.48666868596, -0.929700494428, -3.56327722764, -0.455320135314, -0.391437214323, -0.491352055991,
+        -0.350454834292, -0.471773162921, -0.104084440522, -0.0723646747909, -0.0992828975532, -0.121638215446,
+        -0.122619605294, -0.0317670267286, -0.0359974812869, -0.0154359225363, -0.0375775365921, -0.00794899153653,
+        -0.00777303219211, -0.00796085782042, -0.0125850719397, -0.00455500206958, -0.00476436993148;
+
+    CALL_SUBTEST(res = igamma_der_a(a, x); verify_component_wise(res, v););
+  }
+
+  // Test gamma_sample_der_alpha
+  {
+    ArrayType alpha(30);
+    ArrayType sample(30);
+    ArrayType res(30);
+    ArrayType v(30);
+
+    alpha << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0, 10.0,
+        10.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
+
+    sample << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
+        5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
+        1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
+        10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
+        968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
+
+    v << 7.42424742367e-23, 1.02004297287e-34, 0.0130155240738, 1.02004297287e-34, 1.02004297287e-34, 1.96505168277e-13,
+        0.525575786243, 0.713903991771, 2.32077561808e-14, 0.000179348049886, 0.635500453302, 1.27561284917,
+        0.878125852156, 0.41565819538, 1.03606488534, 0.885964824887, 1.16424049334, 1.10764479598, 1.04590810812,
+        1.04193666963, 0.965193152414, 0.976217589464, 0.93008035061, 0.98153216096, 0.909196397698, 0.98434963993,
+        0.984738050206, 1.00106492525, 0.97734200649, 1.02198794179;
+
+    CALL_SUBTEST(res = gamma_sample_der_alpha(alpha, sample); verify_component_wise(res, v););
+  }
+}
+
+template <typename Scalar>
+void scalar_ndtri() {
+  const Scalar sign_mask = internal::psignmask<Scalar>();
+  VERIFY_IS_EQUAL(sign_mask, Scalar(0));
+  VERIFY((std::signbit)(sign_mask));
+
+  const Scalar packet_inf = internal::pinf<Scalar>();
+  const Scalar packet_nan = internal::pnan<Scalar>();
+  VERIFY((numext::isinf)(packet_inf));
+  VERIFY(packet_inf > Scalar(0));
+  VERIFY((numext::isnan)(packet_nan));
+
+  const Scalar expected_quartile = Scalar(0.6744897501960817432L);
+  const Scalar lower_quartile = numext::ndtri(Scalar(0.25L));
+  const Scalar upper_quartile = numext::ndtri(Scalar(0.75L));
+  VERIFY_IS_APPROX(lower_quartile, -expected_quartile);
+  VERIFY_IS_APPROX(upper_quartile, expected_quartile);
+
+  // These exactly complementary binary values exercise the scalar flipsign path in the tail approximation.
+  const Scalar lower_tail = numext::ndtri(Scalar(0.125L));
+  const Scalar upper_tail = numext::ndtri(Scalar(0.875L));
+  VERIFY(lower_tail < Scalar(0));
+  VERIFY(upper_tail > Scalar(0));
+  VERIFY_IS_APPROX(lower_tail, -upper_tail);
+
+  VERIFY_IS_EQUAL(numext::ndtri(Scalar(0.5L)), Scalar(0));
+  const Scalar negative_inf = numext::ndtri(Scalar(0));
+  const Scalar positive_inf = numext::ndtri(Scalar(1));
+  VERIFY((numext::isinf)(negative_inf));
+  VERIFY((numext::isinf)(positive_inf));
+  VERIFY(negative_inf < Scalar(0));
+  VERIFY(positive_inf > Scalar(0));
+}
+
+// A scalar type without a vectorized erf/erfc implementation must defer to
+// std::erf/std::erfc instead of the float/double-tuned polynomials.
+template <typename Scalar>
+void scalar_erf_erfc() {
+  EIGEN_USING_STD(erf);
+  EIGEN_USING_STD(erfc);
+  // Approximate comparison: the compiler may constant-fold one side to the
+  // correctly rounded value while the other runs the libm implementation.
+  for (Scalar x : {Scalar(-2.5L), Scalar(-0.5L), Scalar(0.0L), Scalar(0.25L), Scalar(3.0L)}) {
+    VERIFY_IS_APPROX(numext::erf(x), Scalar(erf(x)));
+    VERIFY_IS_APPROX(numext::erfc(x), Scalar(erfc(x)));
+  }
+}
+
+namespace custom_scalar {
+// Minimal custom real scalar providing erf/erfc via argument-dependent lookup,
+// the way multiprecision types do. numext::erf/erfc must route to these instead
+// of the float/double-tuned polynomials (issue #3023).
+struct CustomReal {
+  double value;
+  CustomReal() : value(0) {}
+  explicit CustomReal(double v) : value(v) {}
+};
+inline CustomReal erf(const CustomReal& x) { return CustomReal(std::erf(x.value)); }
+inline CustomReal erfc(const CustomReal& x) { return CustomReal(std::erfc(x.value)); }
+
+// The shape of boost::numeric::interval: neither erf nor erfc. Eigen's
+// approximations are not valid for such a type, so it must not be routed into
+// them; see failtest/erf_no_scalar_overload.cpp for the resulting error.
+struct NoErfReal {
+  double value;
+};
+}  // namespace custom_scalar
+
+namespace Eigen {
+template <>
+struct NumTraits<custom_scalar::CustomReal> : NumTraits<double> {
+  using Real = custom_scalar::CustomReal;
+  using NonInteger = custom_scalar::CustomReal;
+  using Nested = custom_scalar::CustomReal;
+};
+}  // namespace Eigen
+
+void custom_scalar_erf_erfc() {
+  using custom_scalar::CustomReal;
+  using custom_scalar::NoErfReal;
+  // Pin the routing decision in both directions.
+  STATIC_CHECK((internal::has_erf<CustomReal>::value));
+  STATIC_CHECK((internal::has_erfc<CustomReal>::value));
+  STATIC_CHECK((internal::has_erf<long double>::value));
+  STATIC_CHECK((internal::has_erfc<long double>::value));
+  STATIC_CHECK((!internal::has_erf<NoErfReal>::value));
+  STATIC_CHECK((!internal::has_erfc<NoErfReal>::value));
+
+  Eigen::Array<CustomReal, 4, 1> x;
+  x(0) = CustomReal(-2.5);
+  x(1) = CustomReal(-0.5);
+  x(2) = CustomReal(0.25);
+  x(3) = CustomReal(3.0);
+  Eigen::Array<CustomReal, 4, 1> e = x.erf();
+  Eigen::Array<CustomReal, 4, 1> c = x.erfc();
+  // The polynomial paths cannot even be instantiated for CustomReal, so
+  // compiling proves the routing; the value check guards the plumbing.
+  for (int i = 0; i < 4; ++i) {
+    VERIFY_IS_APPROX(e(i).value, std::erf(x(i).value));
+    VERIFY_IS_APPROX(c(i).value, std::erfc(x(i).value));
+  }
+}
+
+template <typename Scalar>
+void test_special_functions_edge_cases() {
+  const Scalar plusinf = std::numeric_limits<Scalar>::infinity();
+  const Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
+  const Scalar max_val = (std::numeric_limits<Scalar>::max)();
+  const Scalar denorm_min = std::numeric_limits<Scalar>::denorm_min();
+  const Scalar min_val = (std::numeric_limits<Scalar>::min)();
+
+  // Test scalar digamma edge cases
+  VERIFY_IS_EQUAL(numext::digamma(Scalar(0.0)), -plusinf);
+  VERIFY_IS_EQUAL(numext::digamma(Scalar(-0.0)), plusinf);
+  VERIFY((numext::isnan)(numext::digamma(Scalar(-1.0))));
+  VERIFY((numext::isnan)(numext::digamma(Scalar(-2.0))));
+  VERIFY_IS_EQUAL(numext::digamma(plusinf), plusinf);
+  VERIFY((numext::isnan)(numext::digamma(-plusinf)));
+  VERIFY((numext::isnan)(numext::digamma(nan)));
+
+  // Test polygamma at (0, 0)
+  VERIFY_IS_EQUAL(numext::polygamma(Scalar(0.0), Scalar(0.0)), -plusinf);
+  VERIFY_IS_EQUAL(numext::polygamma(Scalar(0.0), Scalar(-0.0)), plusinf);
+
+  // Test scalar erf/erfc edge cases
+  VERIFY_IS_EQUAL(numext::erf(Scalar(0.0)), Scalar(0.0));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(-0.0)), Scalar(-0.0));
+  VERIFY((std::signbit)(numext::erf(Scalar(-0.0))));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(10.0)), Scalar(1.0));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(-10.0)), Scalar(-1.0));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(28.0)), Scalar(1.0));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(-28.0)), Scalar(-1.0));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(100.0)), Scalar(1.0));
+  VERIFY_IS_EQUAL(numext::erf(Scalar(-100.0)), Scalar(-1.0));
+  VERIFY_IS_EQUAL(numext::erf(max_val), Scalar(1.0));
+  VERIFY_IS_EQUAL(numext::erf(-max_val), Scalar(-1.0));
+  VERIFY_IS_EQUAL(numext::erf(plusinf), Scalar(1.0));
+  VERIFY_IS_EQUAL(numext::erf(-plusinf), Scalar(-1.0));
+  VERIFY((numext::isnan)(numext::erf(nan)));
+
+  VERIFY_IS_EQUAL(numext::erfc(Scalar(0.0)), Scalar(1.0));
+  VERIFY_IS_EQUAL(numext::erfc(Scalar(28.0)), Scalar(0.0));
+  VERIFY_IS_EQUAL(numext::erfc(Scalar(-28.0)), Scalar(2.0));
+  VERIFY_IS_EQUAL(numext::erfc(Scalar(100.0)), Scalar(0.0));
+  VERIFY_IS_EQUAL(numext::erfc(Scalar(-100.0)), Scalar(2.0));
+  VERIFY_IS_EQUAL(numext::erfc(max_val), Scalar(0.0));
+  VERIFY_IS_EQUAL(numext::erfc(-max_val), Scalar(2.0));
+  VERIFY_IS_EQUAL(numext::erfc(plusinf), Scalar(0.0));
+  VERIFY_IS_EQUAL(numext::erfc(-plusinf), Scalar(2.0));
+  VERIFY((numext::isnan)(numext::erfc(nan)));
+
+  if (sizeof(Scalar) >= 8) {
+    VERIFY_IS_EQUAL(numext::erf(Scalar(1e200)), Scalar(1.0));
+    VERIFY_IS_EQUAL(numext::erf(Scalar(-1e200)), Scalar(-1.0));
+    VERIFY_IS_EQUAL(numext::erfc(Scalar(1e200)), Scalar(0.0));
+    VERIFY_IS_EQUAL(numext::erfc(Scalar(-1e200)), Scalar(2.0));
+  } else {
+    VERIFY_IS_EQUAL(numext::erf(Scalar(1e30f)), Scalar(1.0));
+    VERIFY_IS_EQUAL(numext::erf(Scalar(-1e30f)), Scalar(-1.0));
+    VERIFY_IS_EQUAL(numext::erfc(Scalar(1e30f)), Scalar(0.0));
+    VERIFY_IS_EQUAL(numext::erfc(Scalar(-1e30f)), Scalar(2.0));
+  }
+
+  // Denormals / subnormals
+  if (denorm_min > Scalar(0)) {
+    VERIFY(numext::erf(denorm_min) > Scalar(0));
+    VERIFY(numext::erf(-denorm_min) < Scalar(0));
+  }
+  VERIFY(numext::erf(min_val) > Scalar(0));
+  VERIFY(numext::erf(-min_val) < Scalar(0));
+
+  // Array / vectorized edge cases
+  using ArrayType = Array<Scalar, Dynamic, 1>;
+  ArrayType x(14), erf_ref(14), erfc_ref(14);
+  Scalar large_val = (sizeof(Scalar) >= 8) ? Scalar(1e200) : Scalar(1e30f);
+  x << Scalar(0.0), Scalar(-0.0), denorm_min, min_val, Scalar(2.0), Scalar(-2.0), Scalar(28.0), Scalar(-28.0),
+      large_val, -large_val, max_val, -max_val, plusinf, -plusinf;
+  erf_ref << Scalar(0.0), Scalar(-0.0), numext::erf(denorm_min), numext::erf(min_val), Scalar(std::erf(2.0)),
+      Scalar(std::erf(-2.0)), Scalar(1.0), Scalar(-1.0), Scalar(1.0), Scalar(-1.0), Scalar(1.0), Scalar(-1.0),
+      Scalar(1.0), Scalar(-1.0);
+  erfc_ref << Scalar(1.0), Scalar(1.0), numext::erfc(denorm_min), numext::erfc(min_val), Scalar(std::erfc(2.0)),
+      Scalar(std::erfc(-2.0)), Scalar(0.0), Scalar(2.0), Scalar(0.0), Scalar(2.0), Scalar(0.0), Scalar(2.0),
+      Scalar(0.0), Scalar(2.0);
+
+  ArrayType erf_res = x.erf();
+  verify_component_wise(erf_res, erf_ref);
+  erf_res = erf(x);
+  verify_component_wise(erf_res, erf_ref);
+
+  ArrayType erfc_res = x.erfc();
+  verify_component_wise(erfc_res, erfc_ref);
+  erfc_res = erfc(x);
+  verify_component_wise(erfc_res, erfc_ref);
+
+  // Array with NaN
+  ArrayType x_nan(3), erf_nan_ref(3);
+  x_nan << Scalar(1.0), nan, Scalar(-1.0);
+  erf_nan_ref << Scalar(std::erf(1.0)), nan, Scalar(std::erf(-1.0));
+  ArrayType erf_nan_res = x_nan.erf();
+  verify_component_wise(erf_nan_res, erf_nan_ref);
+}
+
+EIGEN_DECLARE_TEST(special_functions) {
+  CALL_SUBTEST_1(array_special_functions<ArrayXf>());
+  CALL_SUBTEST_1(test_special_functions_edge_cases<float>());
+  CALL_SUBTEST_2(array_special_functions<ArrayXd>());
+  CALL_SUBTEST_2(test_special_functions_edge_cases<double>());
+  CALL_SUBTEST_3(scalar_ndtri<long double>());
+  CALL_SUBTEST_4(scalar_erf_erfc<long double>());
+  CALL_SUBTEST_5(custom_scalar_erf_erfc());
+  // TODO(cantonios): half/bfloat16 don't have enough precision to reproduce results above.
+  // CALL_SUBTEST_4(array_special_functions<ArrayX<Eigen::half>>());
+  // CALL_SUBTEST_5(array_special_functions<ArrayX<Eigen::bfloat16>>());
+}
diff --git a/contrib/test/special_packetmath.cpp b/contrib/test/special_packetmath.cpp
new file mode 100644
index 0000000..516e52b
--- /dev/null
+++ b/contrib/test/special_packetmath.cpp
@@ -0,0 +1,358 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include <limits>
+#include "packetmath_test_shared.h"
+#include "fp_control.h"
+#include "../Eigen/SpecialFunctions"
+
+using internal::unpacket_traits;
+
+#if EIGEN_ARCH_ARM && defined(EIGEN_VECTORIZE_NEON)
+template <typename Scalar, typename Packet>
+void packet_erf_subnormals() {
+  using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  constexpr int PacketSize = unpacket_traits<Packet>::size;
+  constexpr Bits Sign = Bits(1) << (8 * sizeof(Scalar) - 1);
+  constexpr Bits MinNormal = Bits(1) << (std::numeric_limits<Scalar>::digits - 1);
+  const Bits samples[] = {Bits(1), Bits(2), Bits(3), Bits(MinNormal / 2), Bits(MinNormal - 1)};
+  // In this interval the cubic term of erf is negligible even relative to one subnormal ULP.
+  const double slope = 2.0 / std::sqrt(std::acos(-1.0));
+  for (Bits n : samples) {
+    for (Bits sign : {Bits(0), Sign}) {
+      for (int lane = 0; lane < PacketSize; ++lane) {
+        Scalar input[PacketSize], output[PacketSize];
+        for (int i = 0; i < PacketSize; ++i) input[i] = Scalar(0.5);
+        input[lane] = numext::bit_cast<Scalar>(Bits(sign | n));
+        internal::pstoreu(output, internal::perf(internal::ploadu<Packet>(input)));
+        const Bits actual = numext::bit_cast<Bits>(output[lane]);
+        const Bits expected = Bits(std::floor(double(n) * slope + 0.5));
+        VERIFY_IS_EQUAL(Bits(actual & Sign), sign);
+        const int error = int(actual & (Sign - 1)) - int(expected);
+        VERIFY(std::abs(error) <= (sizeof(Scalar) == sizeof(float) ? 1 : 0));
+        if (n == 1) VERIFY_IS_EQUAL(actual, Bits(sign | n));
+        for (int i = 0; i < PacketSize; ++i) {
+          if (i != lane) VERIFY_IS_APPROX(output[i], Scalar(std::erf(0.5)));
+        }
+      }
+    }
+  }
+
+  // Recovering one lane must not change zeros, infinities, or NaNs in its neighbors.
+  const Scalar neighbors[] = {Scalar(0), numext::bit_cast<Scalar>(Sign), std::numeric_limits<Scalar>::infinity(),
+                              std::numeric_limits<Scalar>::quiet_NaN()};
+  for (Scalar neighbor : neighbors) {
+    Scalar values[PacketSize], before[PacketSize], after[PacketSize];
+    for (int i = 0; i < PacketSize; ++i) values[i] = neighbor;
+    internal::pstoreu(before, internal::perf(internal::ploadu<Packet>(values)));
+    if ((numext::bit_cast<Bits>(neighbor) & (Sign - 1)) == 0) {
+      for (int i = 0; i < PacketSize; ++i)
+        VERIFY_IS_EQUAL(numext::bit_cast<Bits>(before[i]), numext::bit_cast<Bits>(neighbor));
+    }
+    values[0] = numext::bit_cast<Scalar>(Bits(1));
+    internal::pstoreu(after, internal::perf(internal::ploadu<Packet>(values)));
+    VERIFY_IS_EQUAL(numext::bit_cast<Bits>(after[0]), Bits(1));
+    for (int i = 1; i < PacketSize; ++i)
+      VERIFY_IS_EQUAL(numext::bit_cast<Bits>(after[i]), numext::bit_cast<Bits>(before[i]));
+  }
+
+  // Check the public evaluator with packet bodies and an ordinary scalar tail, also while scalar arithmetic flushes.
+  Array<Scalar, Dynamic, 1> input(3 * internal::packet_traits<Scalar>::size + 1), output(input.size());
+  for (Index i = 0; i + 1 < input.size(); ++i)
+    input(i) = numext::bit_cast<Scalar>(Bits(Bits(1) | (i % 2 ? Sign : Bits(0))));
+  input(input.size() - 1) = Scalar(0.5);
+  output = input.erf();
+  for (Index i = 0; i + 1 < input.size(); ++i)
+    VERIFY_IS_EQUAL(numext::bit_cast<Bits>(output(i)), numext::bit_cast<Bits>(input(i)));
+  VERIFY_IS_APPROX(output(output.size() - 1), Scalar(std::erf(0.5)));
+}
+
+void neon_erf_subnormals_float() {
+  packet_erf_subnormals<float, internal::Packet2f>();
+  packet_erf_subnormals<float, internal::Packet4f>();
+
+  // Rounded values straddling the subnormal/normal output boundary and the largest subnormal input.
+  const numext::uint32_t inputs[] = {0x00716fe1u, 0x00716fe2u, 0x00716fe3u, 0x007fffffu};
+  const numext::uint32_t expected[] = {0x007fffffu, 0x00800000u, 0x00800001u, 0x00906eb9u};
+  float input[4], output[4];
+  for (int i = 0; i < 4; ++i) input[i] = numext::bit_cast<float>(inputs[i]);
+  internal::pstoreu(output, internal::perf(internal::ploadu<internal::Packet4f>(input)));
+  for (int i = 0; i < 4; ++i) {
+    const int error = int(numext::bit_cast<numext::uint32_t>(output[i])) - int(expected[i]);
+    VERIFY(std::abs(error) <= 1);
+  }
+}
+
+void neon_erf_subnormals_bfloat16() {
+  packet_erf_subnormals<bfloat16, internal::Packet4bf>();
+  // Exhaustive bfloat16 subnormals, with both signs, checked without floating-point subnormal conversions.
+  for (unsigned int n = 1; n < 128; ++n) {
+    const numext::uint16_t expectedBits =
+        numext::uint16_t(std::floor(double(n) * (2.0 / std::sqrt(std::acos(-1.0))) + 0.5));
+    bfloat16 values[4], result[4];
+    for (int i = 0; i < 4; ++i) values[i] = numext::bit_cast<bfloat16>(numext::uint16_t(n | (i % 2 ? 0x8000 : 0)));
+    internal::pstoreu(result, internal::perf(internal::ploadu<internal::Packet4bf>(values)));
+    for (int i = 0; i < 4; ++i)
+      VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(result[i]),
+                      numext::uint16_t(expectedBits | (i % 2 ? 0x8000 : 0)));
+  }
+}
+#endif
+
+#if EIGEN_ARCH_ARM
+// Note: 32-bit arm always flushes subnormals to zero.
+#define MAYBE_FLUSH(op)                                                      \
+  [](Scalar x) {                                                             \
+    Scalar y = static_cast<Scalar>(op(x));                                   \
+    if (Eigen::numext::abs(y) < (std::numeric_limits<decltype(y)>::min)()) { \
+      y = y * decltype(y)(0); /* Preserve sign. */                           \
+    }                                                                        \
+    return y;                                                                \
+  }
+#else
+#define MAYBE_FLUSH(op) op
+#endif
+
+template <typename Scalar, typename Packet>
+void packetmath_real() {
+  using std::abs;
+  typedef internal::packet_traits<Scalar> PacketTraits;
+  const int PacketSize = internal::unpacket_traits<Packet>::size;
+
+  const int size = PacketSize * 4;
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[PacketSize * 4] = {};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[PacketSize * 4] = {};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[PacketSize * 4] = {};
+
+  {
+    data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
+    test::packet_helper<internal::packet_traits<Scalar>::HasLGamma, Packet> h;
+    h.store(data2, internal::plgamma(h.load(data1)));
+    VERIFY((numext::isnan)(data2[0]));
+  }
+  if (internal::packet_traits<Scalar>::HasErf) {
+    data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
+    data1[1] = std::numeric_limits<Scalar>::infinity();
+    data1[2] = -std::numeric_limits<Scalar>::infinity();
+    data1[3] = (std::numeric_limits<Scalar>::max)();
+    if (size >= 8) {
+      data1[4] = -(std::numeric_limits<Scalar>::max)();
+      if (sizeof(Scalar) >= 8) {
+        data1[5] = Scalar(1e200);
+        data1[6] = Scalar(-1e200);
+      } else {
+        data1[5] = Scalar(1e30f);
+        data1[6] = Scalar(-1e30f);
+      }
+      data1[7] = std::numeric_limits<Scalar>::denorm_min();
+    }
+    test::packet_helper<internal::packet_traits<Scalar>::HasErf, Packet> h;
+    for (int i = 0; i < size; i += PacketSize) {
+      h.store(data2 + i, internal::perf(h.load(data1 + i)));
+    }
+    VERIFY((numext::isnan)(data2[0]));
+    VERIFY_IS_EQUAL(data2[1], Scalar(1));
+    VERIFY_IS_EQUAL(data2[2], Scalar(-1));
+    VERIFY_IS_EQUAL(data2[3], Scalar(1));
+    if (size >= 8) {
+      VERIFY_IS_EQUAL(data2[4], Scalar(-1));
+      VERIFY_IS_EQUAL(data2[5], Scalar(1));
+      VERIFY_IS_EQUAL(data2[6], Scalar(-1));
+      if (data1[7] > Scalar(0)) {
+        VERIFY((data2[7] > Scalar(0)));
+      }
+    }
+  }
+  if (internal::packet_traits<Scalar>::HasErfc) {
+    data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
+    data1[1] = std::numeric_limits<Scalar>::infinity();
+    data1[2] = -std::numeric_limits<Scalar>::infinity();
+    data1[3] = (std::numeric_limits<Scalar>::max)();
+    if (size >= 8) {
+      data1[4] = -(std::numeric_limits<Scalar>::max)();
+      if (sizeof(Scalar) >= 8) {
+        data1[5] = Scalar(1e200);
+        data1[6] = Scalar(-1e200);
+      } else {
+        data1[5] = Scalar(1e30f);
+        data1[6] = Scalar(-1e30f);
+      }
+    }
+    test::packet_helper<internal::packet_traits<Scalar>::HasErfc, Packet> h;
+    for (int i = 0; i < size; i += PacketSize) {
+      h.store(data2 + i, internal::perfc(h.load(data1 + i)));
+    }
+    VERIFY((numext::isnan)(data2[0]));
+    VERIFY_IS_EQUAL(data2[1], Scalar(0));
+    VERIFY_IS_EQUAL(data2[2], Scalar(2));
+    VERIFY_IS_EQUAL(data2[3], Scalar(0));
+    if (size >= 8) {
+      VERIFY_IS_EQUAL(data2[4], Scalar(2));
+      VERIFY_IS_EQUAL(data2[5], Scalar(0));
+      VERIFY_IS_EQUAL(data2[6], Scalar(2));
+    }
+  }
+  {
+    for (int i = 0; i < size; ++i) {
+      data1[i] = internal::random<Scalar>(Scalar(0), Scalar(1));
+    }
+    CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasNdtri, numext::ndtri, internal::pndtri);
+  }
+
+  // For bessel_i*e and bessel_j*, the valid range is negative reals.
+  {
+    const int max_exponent = numext::mini(std::numeric_limits<Scalar>::max_exponent10 - 1, 6);
+    for (int i = 0; i < size; ++i) {
+      data1[i] = internal::random<Scalar>(Scalar(-1), Scalar(1)) *
+                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-max_exponent), Scalar(max_exponent))));
+      data2[i] = internal::random<Scalar>(Scalar(-1), Scalar(1)) *
+                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-max_exponent), Scalar(max_exponent))));
+    }
+
+    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0e, internal::pbessel_i0e);
+    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1e, internal::pbessel_i1e);
+    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j0, internal::pbessel_j0);
+    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j1, internal::pbessel_j1);
+  }
+
+  // Use a smaller data range for the bessel_i* as these can become very large.
+  // Following #1693, we also restrict this range further to avoid inf's due to
+  // differences in pexp and exp.
+  for (int i = 0; i < size; ++i) {
+    data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
+    data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
+  }
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0, internal::pbessel_i0);
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1, internal::pbessel_i1);
+
+  // Boundary values for which a naive i0(x) = exp(|x|) * i0e(x) overflows even though the result is
+  // finite.  CHECK_CWISE1_IF cannot detect that on its own: its reference is the scalar path through
+  // the same generic_i0, so both sides would be +inf and compare equal.  Check finiteness explicitly.
+  if (PacketTraits::HasBessel &&
+      (internal::is_same<Scalar, float>::value || internal::is_same<Scalar, double>::value)) {
+    Scalar boundary = internal::is_same<Scalar, float>::value ? Scalar(90) : Scalar(713);
+    for (int i = 0; i < size; ++i) {
+      data1[i] = (i % 2 == 0) ? boundary : -boundary;
+    }
+    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0, internal::pbessel_i0);
+    for (int i = 0; i < PacketSize; ++i) VERIFY((numext::isfinite)(data2[i]));
+    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1, internal::pbessel_i1);
+    for (int i = 0; i < PacketSize; ++i) VERIFY((numext::isfinite)(data2[i]));
+  }
+
+  // y_i, and k_i are valid for x > 0.
+  {
+    const int max_exponent = numext::mini(std::numeric_limits<Scalar>::max_exponent10 - 1, 5);
+    for (int i = 0; i < size; ++i) {
+      data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-2), Scalar(max_exponent))));
+      data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-2), Scalar(max_exponent))));
+    }
+  }
+
+  // TODO(srvasude): Re-enable this test once properly investigated why the
+  // scalar and vector paths differ.
+  // CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y0, internal::pbessel_y0);
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y1, internal::pbessel_y1);
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0e, internal::pbessel_k0e);
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1e, internal::pbessel_k1e);
+
+  // Following #1693, we restrict the range for exp to avoid zeroing out too
+  // fast.
+  for (int i = 0; i < size; ++i) {
+    data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
+    data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
+  }
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0, internal::pbessel_k0);
+  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1, internal::pbessel_k1);
+
+  for (int i = 0; i < size; ++i) {
+    data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+               Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-1), Scalar(2))));
+    data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
+               Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-1), Scalar(2))));
+  }
+
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLGamma, std::lgamma, internal::plgamma);
+  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasErf, std::erf, internal::perf);
+  if (PacketTraits::HasErfc) {
+    constexpr uint64_t kMaxSubnormalUlps = 4;
+    test::packet_helper<PacketTraits::HasErfc, Packet> h;
+    const auto check_erfc = [&]() {
+      for (int i = 0; i < PacketSize; ++i) ref[i] = Scalar(MAYBE_FLUSH(std::erfc)(data1[i]));
+      h.store(data2, internal::perfc(h.load(data1)));
+      for (int i = 0; i < PacketSize; ++i) {
+        if (numext::abs(ref[i]) < (std::numeric_limits<Scalar>::min)()) {
+          // Subnormal spacing is denorm_min, so a relative tolerance can demand exact rounding.
+          // Allow four ULPs for the approximation and libm reference together (checked against MPFR).
+          VERIFY(test::areWithinUlps(ref + i, data2 + i, 1, kMaxSubnormalUlps) && "internal::perfc");
+        } else {
+          VERIFY(test::areApprox(ref + i, data2 + i, 1) && "internal::perfc");
+        }
+      }
+    };
+    check_erfc();
+
+    if (g_first_pass) {
+      // #3131: glibc differs by one ULP from MPFR160 at these inputs, including zero/denorm_min pairs.
+      const Scalar inputs[] = {Scalar(9.835620880126953125), Scalar(10.054194450378418), Scalar(27.226017111108366)};
+      for (Scalar x : inputs) {
+        for (int i = 0; i < PacketSize; ++i) data1[i] = x;
+        check_erfc();
+      }
+
+      // erfc(x) ~ exp(-x*x)/(sqrt(pi)*x): straddle the normal/subnormal and subnormal/zero boundaries.
+      const double lo = std::sqrt(-std::log(double((std::numeric_limits<Scalar>::min)()))) - 1;
+      const double hi = std::sqrt(-std::log(double(std::numeric_limits<Scalar>::denorm_min()))) + 1;
+      for (int sample = 0; sample < 128; ++sample) {
+        for (int i = 0; i < PacketSize; ++i)
+          data1[i] = Scalar(lo + (hi - lo) * (sample * PacketSize + i) / (128 * PacketSize - 1));
+        check_erfc();
+      }
+    }
+  }
+}
+
+namespace Eigen {
+namespace test {
+
+template <typename Scalar, typename PacketType, bool IsComplex, bool IsInteger>
+struct runall {
+  static void run() { packetmath_real<Scalar, PacketType>(); }
+};
+
+}  // namespace test
+}  // namespace Eigen
+
+EIGEN_DECLARE_TEST(special_packetmath) {
+#if EIGEN_ARCH_ARM && defined(EIGEN_VECTORIZE_NEON)
+  CALL_SUBTEST_1(neon_erf_subnormals_float());
+  CALL_SUBTEST_4(neon_erf_subnormals_bfloat16());
+  {
+    const Eigen::ScopedFlushToZero flush_to_zero;
+    CALL_SUBTEST_1(neon_erf_subnormals_float());
+    CALL_SUBTEST_4(neon_erf_subnormals_bfloat16());
+  }
+#endif
+  g_first_pass = true;
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(test::runner<float>::run());
+    CALL_SUBTEST_2(test::runner<double>::run());
+    CALL_SUBTEST_3(test::runner<Eigen::half>::run());
+    CALL_SUBTEST_4(test::runner<Eigen::bfloat16>::run());
+    g_first_pass = false;
+  }
+}
diff --git a/contrib/test/splines.cpp b/contrib/test/splines.cpp
new file mode 100644
index 0000000..a6cd449
--- /dev/null
+++ b/contrib/test/splines.cpp
@@ -0,0 +1,245 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2010-2011 Hauke Heibel <heibel@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <contrib/Eigen/Splines>
+
+namespace Eigen {
+
+// lets do some explicit instantiations and thus
+// force the compilation of all spline functions...
+template class Spline<double, 2, Dynamic>;
+template class Spline<double, 3, Dynamic>;
+
+template class Spline<double, 2, 2>;
+template class Spline<double, 2, 3>;
+template class Spline<double, 2, 4>;
+template class Spline<double, 2, 5>;
+
+template class Spline<float, 2, Dynamic>;
+template class Spline<float, 3, Dynamic>;
+
+template class Spline<float, 3, 2>;
+template class Spline<float, 3, 3>;
+template class Spline<float, 3, 4>;
+template class Spline<float, 3, 5>;
+
+}  // namespace Eigen
+
+Spline<double, 2, Dynamic> closed_spline2d() {
+  RowVectorXd knots(12);
+  knots << 0, 0, 0, 0, 0.867193179093898, 1.660330955342408, 2.605084834823134, 3.484154586374428, 4.252699478956276,
+      4.252699478956276, 4.252699478956276, 4.252699478956276;
+
+  MatrixXd ctrls(8, 2);
+  ctrls << -0.370967741935484, 0.236842105263158, -0.231401860693277, 0.442245185027632, 0.344361228532831,
+      0.773369994120753, 0.828990216203802, 0.106550882647595, 0.407270163678382, -1.043452922172848,
+      -0.488467813584053, -0.390098582530090, -0.494657189446427, 0.054804824897884, -0.370967741935484,
+      0.236842105263158;
+  ctrls.transposeInPlace();
+
+  return Spline<double, 2, Dynamic>(knots, ctrls);
+}
+
+/* create a reference spline */
+Spline<double, 3, Dynamic> spline3d() {
+  RowVectorXd knots(11);
+  knots << 0, 0, 0, 0.118997681558377, 0.162611735194631, 0.498364051982143, 0.655098003973841, 0.679702676853675,
+      1.000000000000000, 1.000000000000000, 1.000000000000000;
+
+  MatrixXd ctrls(8, 3);
+  ctrls << 0.959743958516081, 0.340385726666133, 0.585267750979777, 0.223811939491137, 0.751267059305653,
+      0.255095115459269, 0.505957051665142, 0.699076722656686, 0.890903252535799, 0.959291425205444, 0.547215529963803,
+      0.138624442828679, 0.149294005559057, 0.257508254123736, 0.840717255983663, 0.254282178971531, 0.814284826068816,
+      0.243524968724989, 0.929263623187228, 0.349983765984809, 0.196595250431208, 0.251083857976031, 0.616044676146639,
+      0.473288848902729;
+  ctrls.transposeInPlace();
+
+  return Spline<double, 3, Dynamic>(knots, ctrls);
+}
+
+/* compares evaluations against known results */
+void eval_spline3d() {
+  Spline3d spline = spline3d();
+
+  RowVectorXd u(10);
+  u << 0.351659507062997, 0.830828627896291, 0.585264091152724, 0.549723608291140, 0.917193663829810, 0.285839018820374,
+      0.757200229110721, 0.753729094278495, 0.380445846975357, 0.567821640725221;
+
+  MatrixXd pts(10, 3);
+  pts << 0.707620811535916, 0.510258911240815, 0.417485437023409, 0.603422256426978, 0.529498282727551,
+      0.270351549348981, 0.228364197569334, 0.423745615677815, 0.637687289287490, 0.275556796335168, 0.350856706427970,
+      0.684295784598905, 0.514519311047655, 0.525077224890754, 0.351628308305896, 0.724152914315666, 0.574461155457304,
+      0.469860285484058, 0.529365063753288, 0.613328702656816, 0.237837040141739, 0.522469395136878, 0.619099658652895,
+      0.237139665242069, 0.677357023849552, 0.480655768435853, 0.422227610314397, 0.247046593173758, 0.380604672404750,
+      0.670065791405019;
+  pts.transposeInPlace();
+
+  for (int i = 0; i < u.size(); ++i) {
+    Vector3d pt = spline(u(i));
+    // The reference points are tabulated to 15 significant digits, so agreement is limited to a small multiple of eps.
+    VERIFY((pt - pts.col(i)).norm() < 64 * NumTraits<double>::epsilon());
+  }
+}
+
+/* compares evaluations on corner cases */
+void eval_spline3d_onbrks() {
+  Spline3d spline = spline3d();
+
+  RowVectorXd u = spline.knots();
+
+  MatrixXd pts(11, 3);
+  pts << 0.959743958516081, 0.340385726666133, 0.585267750979777, 0.959743958516081, 0.340385726666133,
+      0.585267750979777, 0.959743958516081, 0.340385726666133, 0.585267750979777, 0.430282980289940, 0.713074680056118,
+      0.720373307943349, 0.558074875553060, 0.681617921034459, 0.804417124839942, 0.407076008291750, 0.349707710518163,
+      0.617275937419545, 0.240037008286602, 0.738739390398014, 0.324554153129411, 0.302434111480572, 0.781162443963899,
+      0.240177089094644, 0.251083857976031, 0.616044676146639, 0.473288848902729, 0.251083857976031, 0.616044676146639,
+      0.473288848902729, 0.251083857976031, 0.616044676146639, 0.473288848902729;
+  pts.transposeInPlace();
+
+  for (int i = 0; i < u.size(); ++i) {
+    Vector3d pt = spline(u(i));
+    VERIFY((pt - pts.col(i)).norm() < 16 * NumTraits<double>::epsilon());
+  }
+}
+
+void eval_closed_spline2d() {
+  Spline2d spline = closed_spline2d();
+
+  RowVectorXd u(12);
+  u << 0, 0.332457030395796, 0.356467130532952, 0.453562180176215, 0.648017921874804, 0.973770235555003,
+      1.882577647219307, 2.289408593930498, 3.511951429883045, 3.884149321369450, 4.236261590369414, 4.252699478956276;
+
+  MatrixXd pts(12, 2);
+  pts << -0.370967741935484, 0.236842105263158, -0.152576775123250, 0.448975001279334, -0.133417538277668,
+      0.461615613865667, -0.053199060826740, 0.507630360006299, 0.114249591147281, 0.570414135097409, 0.377810316891987,
+      0.560497102875315, 0.665052120135908, -0.157557441109611, 0.516006487053228, -0.559763292174825,
+      -0.379486035348887, -0.331959640488223, -0.462034726249078, -0.039105670080824, -0.378730600917982,
+      0.225127015099919, -0.370967741935484, 0.236842105263158;
+  pts.transposeInPlace();
+
+  for (int i = 0; i < u.size(); ++i) {
+    Vector2d pt = spline(u(i));
+    VERIFY((pt - pts.col(i)).norm() < 16 * NumTraits<double>::epsilon());
+  }
+}
+
+void check_global_interpolation2d() {
+  typedef Spline2d::PointType PointType;
+  typedef Spline2d::KnotVectorType KnotVectorType;
+  typedef Spline2d::ControlPointVectorType ControlPointVectorType;
+
+  ControlPointVectorType points = ControlPointVectorType::Random(2, 100);
+
+  KnotVectorType chord_lengths;  // knot parameters
+  Eigen::ChordLengths(points, chord_lengths);
+
+  // interpolation without knot parameters
+  {
+    const Spline2d spline = SplineFitting<Spline2d>::Interpolate(points, 3);
+
+    for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
+      PointType pt = spline(chord_lengths(i));
+      PointType ref = points.col(i);
+      VERIFY((pt - ref).matrix().norm() < 32 * NumTraits<double>::epsilon());
+    }
+  }
+
+  // interpolation with given knot parameters
+  {
+    const Spline2d spline = SplineFitting<Spline2d>::Interpolate(points, 3, chord_lengths);
+
+    for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
+      PointType pt = spline(chord_lengths(i));
+      PointType ref = points.col(i);
+      VERIFY((pt - ref).matrix().norm() < 32 * NumTraits<double>::epsilon());
+    }
+  }
+}
+
+// Regression test for issue #764: KnotAveraging hard-coded 0/1 boundary knots,
+// producing a non-monotone knot vector for parameters outside [0, 1].
+void check_global_interpolation2d_arbitrary_range() {
+  typedef Spline2d::PointType PointType;
+  typedef Spline2d::KnotVectorType KnotVectorType;
+  typedef Spline2d::ControlPointVectorType ControlPointVectorType;
+
+  // The issue's example: parameters [2,3,4,5] with degree 1 must yield the
+  // clamped knot vector [2,2,3,4,5,5], not [0,0,3,4,1,1].
+  {
+    KnotVectorType parameters(4), knots, expected(6);
+    parameters << 2, 3, 4, 5;
+    expected << 2, 2, 3, 4, 5, 5;
+    Eigen::KnotAveraging(parameters, 1, knots);
+    VERIFY_IS_EQUAL(knots.size(), expected.size());
+    VERIFY((knots - expected).matrix().norm() == 0.0);
+  }
+
+  // Interpolation with knot parameters spanning [2, 5] must pass through the
+  // data points, exactly like the normalized [0, 1] parameterization.
+  {
+    ControlPointVectorType points = ControlPointVectorType::Random(2, 100);
+
+    KnotVectorType chord_lengths;
+    Eigen::ChordLengths(points, chord_lengths);
+    KnotVectorType parameters = 2.0 + 3.0 * chord_lengths;
+
+    const Spline2d spline = SplineFitting<Spline2d>::Interpolate(points, 3, parameters);
+
+    for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
+      PointType pt = spline(parameters(i));
+      PointType ref = points.col(i);
+      VERIFY((pt - ref).matrix().norm() < 32 * NumTraits<double>::epsilon());
+    }
+  }
+}
+
+void check_global_interpolation_with_derivatives2d() {
+  typedef Spline2d::PointType PointType;
+  typedef Spline2d::KnotVectorType KnotVectorType;
+
+  const Eigen::DenseIndex numPoints = 100;
+  const unsigned int dimension = 2;
+  const unsigned int degree = 3;
+
+  ArrayXXd points = ArrayXXd::Random(dimension, numPoints);
+
+  KnotVectorType knots;
+  Eigen::ChordLengths(points, knots);
+
+  ArrayXXd derivatives = ArrayXXd::Random(dimension, numPoints);
+  VectorXd derivativeIndices(numPoints);
+
+  for (Eigen::DenseIndex i = 0; i < numPoints; ++i) derivativeIndices(i) = static_cast<double>(i);
+
+  const Spline2d spline =
+      SplineFitting<Spline2d>::InterpolateWithDerivatives(points, derivatives, derivativeIndices, degree);
+
+  for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
+    PointType point = spline(knots(i));
+    PointType referencePoint = points.col(i);
+    VERIFY_IS_APPROX(point, referencePoint);
+    PointType derivative = spline.derivatives(knots(i), 1).col(1);
+    PointType referenceDerivative = derivatives.col(i);
+    VERIFY_IS_APPROX(derivative, referenceDerivative);
+  }
+}
+
+EIGEN_DECLARE_TEST(splines) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST(eval_spline3d());
+    CALL_SUBTEST(eval_spline3d_onbrks());
+    CALL_SUBTEST(eval_closed_spline2d());
+    CALL_SUBTEST(check_global_interpolation2d());
+    CALL_SUBTEST(check_global_interpolation2d_arbitrary_range());
+    CALL_SUBTEST(check_global_interpolation_with_derivatives2d());
+  }
+}
diff --git a/contrib/test/structured_bccb.cpp b/contrib/test/structured_bccb.cpp
new file mode 100644
index 0000000..e732513
--- /dev/null
+++ b/contrib/test/structured_bccb.cpp
@@ -0,0 +1,1136 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Dense inverse DFT matrix, used to synthesize generators independently of the
+// FFT implementation under test.
+template <typename RealScalar>
+Matrix<std::complex<RealScalar>, Dynamic, Dynamic> inverse_dft_matrix(Index n) {
+  typedef std::complex<RealScalar> Complex;
+  Matrix<Complex, Dynamic, Dynamic> F(n, n);
+  for (Index a = 0; a < n; ++a)
+    for (Index c = 0; c < n; ++c)
+      F(a, c) =
+          std::polar(RealScalar(1) / RealScalar(n), RealScalar(2 * EIGEN_PI) * RealScalar((a * c) % n) / RealScalar(n));
+  return F;
+}
+
+// Reference dense BCCB built entry-wise from the generating array, independently
+// of the operator under test: entry (i,j) with i = b1*n2+i2, j = c1*n2+j2 is
+// G((i2-j2) mod n2, (b1-c1) mod n1).
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_bccb(const Matrix<Scalar, Dynamic, Dynamic>& G) {
+  const Index n2 = G.rows(), n1 = G.cols(), N = n1 * n2;
+  Matrix<Scalar, Dynamic, Dynamic> dense(N, N);
+  for (Index j = 0; j < N; ++j)
+    for (Index i = 0; i < N; ++i) {
+      Index k2 = i % n2 - j % n2;
+      if (k2 < 0) k2 += n2;
+      Index k1 = i / n2 - j / n2;
+      if (k1 < 0) k1 += n1;
+      dense(i, j) = G(k2, k1);
+    }
+  return dense;
+}
+
+template <typename Scalar>
+void test_bccb_product(Index n2, Index n1) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+  VERIFY_IS_EQUAL(C.rows(), N);
+
+  Mat Cd = C;
+  VERIFY_IS_APPROX(Cd, dense);
+  Mat accumulated = Mat::Random(N, N);
+  const Mat initial = accumulated;
+  accumulated += C;
+  VERIFY_IS_APPROX(accumulated, (initial + dense).eval());
+  accumulated = initial;
+  accumulated -= C;
+  VERIFY_IS_APPROX(accumulated, (initial - dense).eval());
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, N - 1), j = internal::random<Index>(0, N - 1);
+    VERIFY_IS_APPROX(C.coeff(i, j), dense(i, j));
+  }
+
+  Vec x = Vec::Random(N);
+  VERIFY_IS_APPROX((C * x).eval(), (dense * x).eval());
+
+  Mat X = Mat::Random(N, 3);
+  VERIFY_IS_APPROX((C * X).eval(), (dense * X).eval());
+
+  // Accumulation form exercised by the iterative solvers.
+  Vec y = Vec::Random(N);
+  Vec y0 = y;
+  y.noalias() += C * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+}
+
+template <typename Scalar>
+void test_bccb_transpose(Index n2, Index n1) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+
+  Mat Td = C.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = C.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Kd = C.conjugate();
+  VERIFY_IS_APPROX(Kd, Mat(dense.conjugate()));
+
+  Vec x = Vec::Random(N);
+  VERIFY_IS_APPROX((C.transpose() * x).eval(), (dense.transpose() * x).eval());
+  VERIFY_IS_APPROX((C.adjoint() * x).eval(), (dense.adjoint() * x).eval());
+
+  // Exact round trips: generators and symbols are pure permutations/conjugations.
+  Bccb<Scalar> Ctt = C.transpose().transpose();
+  VERIFY_IS_EQUAL(Ctt.generator(), G);
+  VERIFY_IS_EQUAL(Ctt.symbol(), C.symbol());
+  Bccb<Scalar> Caa = C.adjoint().adjoint();
+  VERIFY_IS_EQUAL(Caa.generator(), G);
+  VERIFY_IS_EQUAL(Caa.symbol(), C.symbol());
+}
+
+// transpose()/conjugate()/adjoint() return owning temporaries, so the product
+// expression must nest the structured operand by value: a delayed-evaluated
+// expression has to outlive the temporary operator it was built from. The static
+// check pins the value nesting; the behavioral check would read freed memory if
+// the product held a reference instead.
+template <typename Scalar>
+void test_bccb_delayed_product(Index n2, Index n1) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<Bccb<Scalar>>::type>::value);
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+  Vec x = Vec::Random(N);
+
+  auto expr = C.adjoint() * x;        // the adjoint temporary dies with the full expression
+  Vec scribble = Vec::Random(2 * N);  // reuses the temporary's freed heap storage
+  Vec y = expr;
+  VERIFY_IS_APPROX(y, (dense.adjoint() * x).eval());
+  VERIFY_IS_EQUAL(scribble.size(), 2 * N);  // keep the scribble alive across the evaluation
+}
+
+// The products carry the default product tag, so plain assignment materializes
+// a temporary exactly like a dense product: x = C * x and x += C * x get the
+// ordinary dense-product aliasing semantics.
+template <typename Scalar>
+void test_bccb_aliased_product(Index n2, Index n1) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+
+  Vec x = Vec::Random(N);
+  Vec y = x;
+  y = C * y;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  y = x;
+  y += C * y;
+  VERIFY_IS_APPROX(y, (x + dense * x).eval());
+
+  y = x;
+  y -= C * y;
+  VERIFY_IS_APPROX(y, (x - dense * x).eval());
+
+  Mat X = Mat::Random(N, 3);
+  Mat Y = X;
+  Y = C * Y;
+  VERIFY_IS_APPROX(Y, (dense * X).eval());
+}
+
+// Aliasing beyond the same-object case: the default-product temporary must also
+// resolve right-hand-side expressions that reference the destination and
+// overlapping views of one buffer, neither of which is_same_dense can see.
+template <typename Scalar>
+void test_bccb_aliased_expression(Index n2, Index n1) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+
+  // Right-hand-side expression referencing the destination.
+  Vec x = Vec::Random(N), x0 = x;
+  x = C * (x + Vec::Ones(N));
+  VERIFY_IS_APPROX(x, (dense * (x0 + Vec::Ones(N))).eval());
+
+  // Overlapping (shifted) segments of one buffer.
+  Vec buf = Vec::Random(N + 1);
+  Vec expected = dense * buf.tail(N);
+  buf.head(N) = C * buf.tail(N);
+  VERIFY_IS_APPROX(buf.head(N).eval(), expected);
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex product
+// scalar, so alpha and the accumulation must run in the promoted type rather than
+// the operator scalar.
+template <typename RealScalar>
+void test_bccb_mixed_scalar(Index n2, Index n1) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> RMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RMat G = RMat::Random(n2, n1);
+  Bccb<RealScalar> C(G);
+  CMat dense = reference_bccb<RealScalar>(G).template cast<Complex>();
+  const Index N = n1 * n2;
+
+  CVec x = CVec::Random(N);
+  CVec y = C * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  CVec y0 = CVec::Random(N);
+  y = y0;
+  y.noalias() += C * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+
+  CMat Gc = CMat::Random(n2, n1);
+  Bccb<Complex> Cc(Gc);
+  CMat denseC = reference_bccb<Complex>(Gc);
+  RVec xr = RVec::Random(N);
+  CVec z = Cc * xr;
+  VERIFY_IS_APPROX(z, (denseC * xr).eval());
+}
+
+// Non-5-smooth block dimensions: products transform on the padded per-axis
+// circulant-embedding grid (kissfft's generic butterfly is quadratic in prime
+// factors), while the spectral operations keep the exact-size symbol. Cover
+// each padded combination -- n2 awkward, n1 awkward, both -- against the dense
+// reference, including the transposition family (which reuses the padded
+// symbol through the reversal/conjugation rules), solve, and inverse (which
+// rebuilds the padded symbol for the inverse operator).
+template <typename Scalar>
+void test_bccb_prime_dimensions(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  const Index N = n1 * n2;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+
+  Vec x = Vec::Random(N);
+  VERIFY_IS_APPROX((C * x).eval(), (dense * x).eval());
+  Mat X = Mat::Random(N, 3);
+  VERIFY_IS_APPROX((C * X).eval(), (dense * X).eval());
+
+  VERIFY_IS_APPROX((C.transpose() * x).eval(), (dense.transpose() * x).eval());
+  VERIFY_IS_APPROX((C.adjoint() * x).eval(), (dense.adjoint() * x).eval());
+  VERIFY_IS_APPROX((C.conjugate() * x).eval(), (dense.conjugate() * x).eval());
+
+  // Exact symbol round trip through the transposition family: both cached
+  // symbols are pure permutations/conjugations of the originals.
+  Bccb<Scalar> Ctt = C.transpose().transpose();
+  VERIFY_IS_EQUAL(Ctt.generator(), G);
+  VERIFY_IS_EQUAL(Ctt.symbol(), C.symbol());
+
+  // Solve (exact-size spectral path) and inverse (whose product rebuilds the
+  // padded symbol): diagonal dominance keeps the symbol away from zero.
+  Mat Gd = Mat::Random(n2, n1);
+  Gd(0, 0) += Scalar(RealScalar(2 * N));
+  Bccb<Scalar> Cd(Gd);
+  Mat densed = reference_bccb<Scalar>(Gd);
+  Vec b = Vec::Random(N);
+  Vec xs = Cd.solve(b);
+  VERIFY_IS_APPROX((densed * xs).eval(), b);
+  VERIFY_IS_APPROX((Cd.inverse() * b).eval(), xs);
+}
+
+// Dynamic dimension mismatches must trip the runtime assertion when the product
+// or solve expression is built. (Incompatible *fixed* sizes are rejected at
+// compile time by a static assertion in operator* / solve, which a runtime test
+// cannot exercise.)
+void test_bccb_dimension_asserts() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(3, 4);
+  Bccb<double> C(G);
+  Vec bad = Vec::Random(11);
+  VERIFY_RAISES_ASSERT(C * bad);
+  VERIFY_RAISES_ASSERT(C.solve(bad));
+}
+
+template <typename Scalar>
+void test_bccb_solve(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Diagonal dominance (through the (0,0) generator entry) keeps the symbol away
+  // from zero, so the direct 2-D FFT solve is exact up to roundoff.
+  Mat G = Mat::Random(n2, n1);
+  G(0, 0) += Scalar(RealScalar(2 * n1 * n2));
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+
+  Vec b = Vec::Random(N);
+  Vec x = C.solve(b);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+
+  Mat B = Mat::Random(N, 3);
+  Mat Xs = C.solve(B);
+  VERIFY_IS_APPROX((dense * Xs).eval(), B);
+}
+
+// Rank-deficient BCCB synthesized by zeroing 2-D symbol entries: the rank counts
+// the surviving entries and solve() matches the SVD pseudo-inverse.
+template <typename Scalar>
+void test_bccb_rank_deficient(Index n2, Index n1, Index defect) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  const Index N = n1 * n2;
+  CMat S = CMat::Random(n2, n1);
+  S.array() += Complex(2);  // keep the surviving moduli away from the threshold
+  for (Index k = 0; k < defect; ++k) S((2 * k + 1) % n2, (3 * k) % n1) = Complex(0);
+
+  const CMat F2 = inverse_dft_matrix<RealScalar>(n2), F1 = inverse_dft_matrix<RealScalar>(n1);
+  Mat G = (F2 * S * F1.transpose()).eval();  // Scalar is complex here
+  Bccb<Scalar> C(G);
+  VERIFY_IS_EQUAL(C.rank(), N - defect);
+
+  Mat dense = reference_bccb<Scalar>(G);
+  JacobiSVD<Mat> svd(dense, ComputeThinU | ComputeThinV);
+  Vec b = Vec::Random(N);
+  VERIFY_IS_APPROX(C.solve(b), svd.solve(b).eval());
+}
+
+template <typename Scalar>
+void test_bccb_zero(Index n2, Index n1) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Bccb<Scalar> C(Mat(Mat::Zero(n2, n1)));
+  VERIFY_IS_EQUAL(C.rank(), 0);
+  VERIFY(C.singularValues().isZero());
+  Vec b = Vec::Random(n1 * n2);
+  VERIFY(C.solve(b).isZero());
+}
+
+void test_bccb_nan_propagation(Index n2, Index n1) {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  G(n2 / 2, n1 / 2) = std::numeric_limits<double>::quiet_NaN();
+  Bccb<double> C(G);
+  VERIFY_IS_EQUAL(C.rank(), n1 * n2);
+  Vec b = Vec::Random(n1 * n2);
+  Vec x = C.solve(b);
+  VERIFY(!(x.array() == x.array()).all());
+}
+
+// Inputs at the very top (and bottom) of the exponent range: the transforms sum
+// up to N terms, so without scaling the FFT intermediates overflow even though
+// every entry of the true result is representable. The apply path rescales the
+// symbol and each right-hand-side column by exact powers of two and folds the
+// exponent back at the end.
+void test_bccb_finite_overflow() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  const double huge = (std::numeric_limits<double>::max)() / 16;
+  // The 2-D FFT round trip costs a few ulps per entry; a norm-based comparison
+  // would itself overflow at these magnitudes, hence the entrywise bound.
+  const double kFftRoundTripTol = 100 * NumTraits<double>::epsilon();
+
+  // Reviewer repro: a 36x36 identity BCCB applied to a vector of DBL_MAX/16
+  // must return the vector, not 36 NaNs.
+  Mat G = Mat::Zero(6, 6);
+  G(0, 0) = 1.0;
+  Bccb<double> C(G);
+  Vec x = Vec::Constant(36, huge);
+  Vec y = C * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).array().abs() <= kFftRoundTripTol * x.array().abs()).all());
+
+  // A huge generator makes a huge symbol: the scaling must come from the symbol
+  // side as well.
+  Mat Gh = Mat::Zero(6, 6);
+  Gh(0, 0) = huge;  // C == huge * Identity
+  Bccb<double> Ch(Gh);
+  Vec ones = Vec::Ones(36);
+  Vec z = Ch * ones;
+  VERIFY(z.allFinite());
+  VERIFY(((z.array() - huge).abs() <= kFftRoundTripTol * huge).all());
+
+  // The inverse symbol of a tiny operator is huge; solve() shares the scaled
+  // apply path.
+  Mat Gt = Mat::Zero(6, 6);
+  Gt(0, 0) = 1.0 / huge;
+  Bccb<double> Ct(Gt);
+  Vec w = Ct.solve(ones);
+  VERIFY(w.allFinite());
+  VERIFY(((w.array() - huge).abs() <= kFftRoundTripTol * huge).all());
+
+  // An exactly zero column maps to an exactly zero column (short-circuited
+  // before any scaling), while nonzero columns are still transformed.
+  Mat B(36, 2);
+  B.col(0).setConstant(huge);
+  B.col(1).setZero();
+  Mat Y = C * B;
+  VERIFY(Y.col(1).isZero());
+  VERIFY(((Y.col(0) - x).array().abs() <= kFftRoundTripTol * x.array().abs()).all());
+
+  // A genuine NaN among huge inputs keeps propagating; such right-hand sides
+  // take the direct kernel (see test_bccb_nonfinite_product for the entrywise
+  // semantics).
+  Vec xn = x;
+  xn[7] = std::numeric_limits<double>::quiet_NaN();
+  Vec yn = C * xn;
+  VERIFY(!(yn.array() == yn.array()).all());
+}
+
+// The scaling exponents are derived from component-wise magnitudes: a finite
+// complex value near the overflow threshold has a non-representable modulus,
+// which would otherwise disable the scaling and turn an exactly representable
+// product into NaN.
+template <typename RealScalar>
+void test_bccb_fft_complex_boundary(Index n2, Index n1) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> RMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  const RealScalar kFftRoundTripTol = RealScalar(100) * NumTraits<RealScalar>::epsilon();
+  const RealScalar big = RealScalar(0.75) * (std::numeric_limits<RealScalar>::max)();
+  const Index N = n1 * n2;
+
+  // Identity BCCB with a complex generator: the product returns the right-hand
+  // side unchanged even though |x_k| overflows.
+  CMat G = CMat::Zero(n2, n1);
+  G(0, 0) = Complex(1);
+  Bccb<Complex> C(G);
+  CVec x = CVec::Constant(N, Complex(big, big));
+  CVec y = C * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / big).maxCoeff() <= kFftRoundTripTol);
+
+  // A real identity operator applied to the same complex right-hand side takes
+  // the mixed-scalar product path.
+  RMat Gr = RMat::Zero(n2, n1);
+  Gr(0, 0) = RealScalar(1);
+  Bccb<RealScalar> Cr(Gr);
+  y = Cr * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / big).maxCoeff() <= kFftRoundTripTol);
+}
+
+// Entrywise IEEE comparison for the non-finite tests: NaNs match NaNs,
+// infinities match by value (sign included), finite entries match to roundoff.
+// VERIFY_IS_APPROX would reject any output containing NaN.
+template <typename D1, typename D2>
+bool ieee_entrywise_match(const D1& a, const D2& b) {
+  if (a.rows() != b.rows() || a.cols() != b.cols()) return false;
+  for (Index j = 0; j < a.cols(); ++j)
+    for (Index i = 0; i < a.rows(); ++i) {
+      const typename D1::Scalar x = a(i, j), y = b(i, j);
+      if (x == y) continue;                                    // finite match or same-signed infinities
+      if ((numext::isnan)(x) && (numext::isnan)(y)) continue;  // both NaN
+      if (!test_isApprox(x, y)) return false;                  // finite roundoff
+    }
+  return true;
+}
+
+// Scalar-loop product: the mathematically transparent IEEE reference for the
+// non-finite tests. Eigen's own vectorized complex kernels can smear a single
+// infinity into NaN (Inf - Inf across the split real/imaginary accumulators), so
+// the dense product is not a faithful entrywise reference for non-finite data.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, 1> reference_product_ieee(const Matrix<Scalar, Dynamic, Dynamic>& A,
+                                                  const Matrix<Scalar, Dynamic, 1>& x) {
+  Matrix<Scalar, Dynamic, 1> y(A.rows());
+  for (Index i = 0; i < A.rows(); ++i) {
+    Scalar acc(0);
+    for (Index j = 0; j < A.cols(); ++j) acc += A(i, j) * x[j];
+    y[i] = acc;
+  }
+  return y;
+}
+
+// A single Inf or NaN in the data must propagate like the reference product --
+// through the dot products that touch it -- instead of being smeared into NaNs
+// across the whole output by the transforms.
+template <typename Scalar>
+void test_bccb_nonfinite_product(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  const RealScalar inf = std::numeric_limits<RealScalar>::infinity();
+  const RealScalar nan = std::numeric_limits<RealScalar>::quiet_NaN();
+  const Index N = n1 * n2;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+
+  // Inf in the right-hand side.
+  Vec x = Vec::Random(N);
+  x[N / 2] = Scalar(inf);
+  VERIFY(ieee_entrywise_match((C * x).eval(), reference_product_ieee(dense, x)));
+
+  // NaN in the right-hand side.
+  Vec xn = Vec::Random(N);
+  xn[N - 1] = Scalar(nan);
+  VERIFY(ieee_entrywise_match((C * xn).eval(), reference_product_ieee(dense, xn)));
+
+  // Mixed multi-column right-hand side: the non-finite column falls back to the
+  // direct kernel individually while the finite column keeps the FFT path.
+  Mat Xm(N, 2);
+  Xm.col(0) = Vec::Random(N);
+  Xm.col(1) = x;
+  Mat Ym = C * Xm;
+  VERIFY_IS_APPROX(Ym.col(0).eval(), (dense * Xm.col(0)).eval());
+  VERIFY(ieee_entrywise_match(Ym.col(1).eval(), reference_product_ieee(dense, Vec(Xm.col(1)))));
+
+  // A zero column carrying a single NaN must not take the zero-column shortcut:
+  // the fast-max routing scan can miss a NaN among zeros (an Inf always
+  // surfaces), so the shortcut rechecks exactly and such a column falls back.
+  Vec xz = Vec::Zero(N);
+  xz[0] = Scalar(nan);
+  VERIFY(ieee_entrywise_match((C * xz).eval(), reference_product_ieee(dense, xz)));
+
+  // Inf in the generating array: the operator itself is non-finite, whatever the
+  // right-hand side.
+  Mat G2 = Mat::Random(n2, n1);
+  G2(n2 / 2, n1 / 2) = Scalar(-inf);
+  Bccb<Scalar> C2(G2);
+  Mat dense2 = reference_bccb<Scalar>(G2);
+  Vec x2 = Vec::Random(N);
+  VERIFY(ieee_entrywise_match((C2 * x2).eval(), reference_product_ieee(dense2, x2)));
+
+  // Non-finite right-hand sides of solve() apply the pseudo-inverse -- itself a
+  // BCCB operator -- through the direct kernel, so the Inf propagates entrywise
+  // instead of NaN-ing the whole output through the transforms. The operator is
+  // diagonally dominant, so no symbol entry is thresholded and the pseudo-inverse
+  // coincides with inverse(), whose dense form serves as the reference matrix.
+  Mat Gd = Mat::Random(n2, n1);
+  Gd(0, 0) += Scalar(RealScalar(2 * N));
+  Bccb<Scalar> Cd(Gd);
+  Mat pinv = Mat(Cd.inverse());
+  Vec binf = Vec::Random(N);
+  binf[N / 3] = Scalar(inf);
+  VERIFY(ieee_entrywise_match(Cd.solve(binf), reference_product_ieee(pinv, binf)));
+}
+
+// An all-zero right-hand side must not short-circuit to an exact zero when the
+// operator holds non-finite data: every row of a BCCB touches every generator
+// entry, so each result entry is a dot product with an Inf coefficient times
+// zero -- NaN under IEEE, not zero.
+void test_bccb_nonfinite_zero_rhs(Index n2, Index n1) {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const Index N = n1 * n2;
+
+  Mat G = Mat::Random(n2, n1);
+  G(n2 / 2, n1 / 2) = std::numeric_limits<double>::infinity();
+  Bccb<double> C(G);
+  Mat dense = reference_bccb<double>(G);
+
+  const Vec z = Vec::Zero(N);
+  Vec y = C * z;
+  VERIFY(y.hasNaN());
+  VERIFY(ieee_entrywise_match(y, reference_product_ieee(dense, z)));
+
+  // The same holds for solve(): the symbol of a non-finite operator holds NaN,
+  // so the pseudo-inverse applied to a zero right-hand side is NaN, not zero.
+  Vec xs = C.solve(z);
+  VERIFY(xs.hasNaN());
+}
+
+// Spectra with a wide dynamic range: the determinant is representable, but a
+// plain product of the eigenvalues in FFT order overflows to infinity (or
+// underflows to an exact zero) partway through. Pins the balanced accumulation
+// in determinant().
+void test_bccb_determinant_scaled() {
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  const Index n2 = 25, n1 = 40;  // N = 1000
+
+  // Symbol magnitudes `lead` on the first nLead column-major-flattened indices
+  // (the accumulation order of determinant()) and `rest` elsewhere, so the
+  // naive running product leaves the representable range partway through while
+  // the true determinant lead^nLead * rest^(N - nLead) is representable. The
+  // generator is recovered through the dense inverse 2-D DFT matrices,
+  // independently of the implementation under test.
+  auto makeOperator = [n2, n1](double lead, double rest) {
+    constexpr Index nLead = 653;
+    CMat S(n2, n1);
+    for (Index k1 = 0; k1 < n1; ++k1)
+      for (Index k2 = 0; k2 < n2; ++k2) S(k2, k1) = Complex(k1 * n2 + k2 < nLead ? lead : rest);
+    const CMat F2 = inverse_dft_matrix<double>(n2), F1 = inverse_dft_matrix<double>(n1);
+    return Bccb<Complex>((F2 * S * F1.transpose()).eval());
+  };
+
+  // The spectrum is only reproduced up to the FFT round trip's forward error,
+  // and the determinant multiplies ~1e3 such factors.
+  const double kSpectrumRoundTripTol = 1e8 * NumTraits<double>::epsilon();
+  {
+    // det = 10^653 * 10^-347 = 1e306; the naive partial product reaches 1e327.
+    Bccb<Complex> C = makeOperator(10.0, 0.1);
+    const Complex det = C.determinant();
+    VERIFY((numext::isfinite)(numext::abs(det)));
+    VERIFY(numext::abs(det / 1e306 - Complex(1)) <= kSpectrumRoundTripTol);
+  }
+  {
+    // det = 10^-653 * 10^347 = 1e-306; the naive partial product reaches
+    // 1e-327, well below the smallest subnormal, and flushes to an exact zero.
+    Bccb<Complex> C = makeOperator(0.1, 10.0);
+    const Complex det = C.determinant();
+    VERIFY(det != Complex(0));
+    VERIFY(numext::abs(det / 1e-306 - Complex(1)) <= kSpectrumRoundTripTol);
+  }
+  {
+    // A genuinely overflowing determinant must still saturate to infinity.
+    typedef Matrix<double, Dynamic, Dynamic> Mat;
+    Mat G = Mat::Zero(6, 6);
+    G(0, 0) = 1e308;  // the symbol is 1e308 everywhere: det = 10^11088
+    Bccb<double> C(G);
+    VERIFY((numext::isinf)(C.determinant()));
+  }
+}
+
+// The rank decision at the clamped threshold (the smallest normal number): a
+// smallest-normal symbol entry is still inverted -- the comparison is strict,
+// matching SVDBase::rank(), which likewise reports rank one -- a subnormal entry
+// is treated as an exact zero, and non-finite entries count as non-zero.
+void test_bccb_rank_boundaries() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  const double mn = (std::numeric_limits<double>::min)();
+  const Vec b = Vec::Ones(1);
+  {
+    Bccb<double> C(Mat(Mat::Constant(1, 1, mn)));
+    VERIFY_IS_EQUAL(C.rank(), 1);
+    Vec x = C.solve(b);
+    VERIFY((numext::isfinite)(x[0]));
+    VERIFY_IS_APPROX(x[0], 1.0 / mn);
+  }
+  {
+    Bccb<double> C(Mat(Mat::Constant(1, 1, mn / 2)));  // subnormal
+    VERIFY_IS_EQUAL(C.rank(), 0);
+    VERIFY(C.solve(b).isZero());
+  }
+  {
+    Bccb<double> C(Mat(Mat::Constant(1, 1, std::numeric_limits<double>::infinity())));
+    VERIFY_IS_EQUAL(C.rank(), 1);
+    VERIFY((numext::isinf)(C.determinant()));
+  }
+}
+
+// A finite complex symbol entry near the overflow threshold has a
+// non-representable modulus. The rank threshold used to be computed from the raw
+// moduli, turning it into infinity: the rank was under-reported and solve()
+// zeroed valid Fourier modes. Both are now evaluated in an exactly rescaled
+// frame.
+void test_bccb_rank_complex_boundary() {
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  const double mx = (std::numeric_limits<double>::max)();
+
+  // n2 = 2, n1 = 1: the symbol is exactly [g0 + g1, g0 - g1], so pick the
+  // generator from the desired spectrum. |s0| overflows while both of its
+  // components are finite.
+  const Complex s0(0.75 * mx, 0.75 * mx), s1(1e300, 0.0);
+  CMat G(2, 1);
+  G(0, 0) = (s0 + s1) * 0.5;
+  G(1, 0) = (s0 - s1) * 0.5;
+  Bccb<Complex> C(G);
+  VERIFY_IS_EQUAL(C.rank(), 2);
+
+  // The second Fourier mode must be inverted, not zeroed: a product of a small
+  // vector solves back to that vector (the accuracy is limited by the condition
+  // number |s0| / |s1| ~ 2.5e8).
+  CVec x0(2);
+  x0[0] = Complex(1e-10, -2e-10);
+  x0[1] = Complex(-3e-10, 1e-10);
+  CVec b = C * x0;
+  VERIFY(b.allFinite());
+  CVec x = C.solve(b);
+  VERIFY(((x - x0).cwiseAbs().maxCoeff() / x0.cwiseAbs().maxCoeff()) <= 1e-6);
+
+  // A genuinely negligible second entry still truncates in the scaled frame.
+  CMat G2(2, 1);
+  G2(0, 0) = (s0 + Complex(1)) * 0.5;
+  G2(1, 0) = (s0 - Complex(1)) * 0.5;
+  VERIFY_IS_EQUAL(Bccb<Complex>(G2).rank(), 1);
+}
+
+// A single 2^-e frame factor is itself subnormal once the frame exceeds the
+// exponent range, and reads as zero under flush-to-zero: every scaled modulus
+// and the threshold collapse together, the rank is over-reported, and solve()
+// inverts a mode it should have truncated. Hence the two exact factors.
+void test_bccb_rank_flush_to_zero() {
+  ScopedFlushToZero flush_to_zero;
+  if (!flush_to_zero.isSupported()) return;
+
+  using Complex = std::complex<double>;
+  using CMat = Matrix<Complex, Dynamic, Dynamic>;
+  const double mx = (std::numeric_limits<double>::max)();
+
+  // Spectrum [s0, 1] with |s0| at the overflow boundary: the second mode is
+  // negligible against it, so the operator is rank one.
+  const Complex s0(0.75 * mx, 0.75 * mx);
+  CMat G(2, 1);
+  G(0, 0) = (s0 + Complex(1)) * 0.5;
+  G(1, 0) = (s0 - Complex(1)) * 0.5;
+  VERIFY_IS_EQUAL(Bccb<Complex>(G).rank(), 1);
+}
+
+template <typename Scalar>
+void test_bccb_eigen(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  CMat denseC = reference_bccb<Scalar>(G).template cast<Complex>();
+  const Index N = n1 * n2;
+
+  Matrix<Complex, Dynamic, 1> lam = C.eigenvalues();
+  CMat V = C.eigenvectors();
+  VERIFY_IS_APPROX((denseC * V).eval(), (V * lam.asDiagonal()).eval());
+  VERIFY_IS_APPROX((V.adjoint() * V).eval(), CMat(CMat::Identity(N, N)));
+}
+
+template <typename Scalar>
+void test_bccb_svd(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  Mat G = Mat::Random(n2, n1);
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+
+  Matrix<RealScalar, Dynamic, 1> sv = C.singularValues();
+  JacobiSVD<Mat> svd(dense);
+  VERIFY_IS_APPROX(sv, svd.singularValues());
+
+  CMat U = C.matrixU(), V = C.matrixV();
+  VERIFY_IS_APPROX((U * sv.template cast<Complex>().asDiagonal() * V.adjoint()).eval(),
+                   CMat(dense.template cast<Complex>()));
+  VERIFY_IS_APPROX((U.adjoint() * U).eval(), CMat(CMat::Identity(N, N)));
+  VERIFY_IS_APPROX((V.adjoint() * V).eval(), CMat(CMat::Identity(N, N)));
+}
+
+template <typename Scalar>
+void test_bccb_inverse(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  G(0, 0) += Scalar(RealScalar(2 * n1 * n2));  // safely invertible, tame determinant scale
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  const Index N = n1 * n2;
+
+  Mat inv = C.inverse();
+  VERIFY_IS_APPROX((inv * dense).eval(), Mat(Mat::Identity(N, N)));
+
+  Vec b = Vec::Random(N);
+  VERIFY_IS_APPROX((C.inverse() * b).eval(), C.solve(b));
+}
+
+template <typename Scalar>
+void test_bccb_determinant(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat G = Mat::Random(n2, n1);
+  G(0, 0) += Scalar(RealScalar(2 * n1 * n2));
+  Bccb<Scalar> C(G);
+  Mat dense = reference_bccb<Scalar>(G);
+  VERIFY_IS_APPROX(C.determinant(), dense.determinant());
+}
+
+template <typename Scalar>
+void test_bccb_matrix_free_cg(Index n2, Index n1) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Symmetrizing the generator under the two-dimensional index reversal makes
+  // the BCCB matrix symmetric; diagonal dominance then makes it positive
+  // definite.
+  Mat G = Mat::Random(n2, n1);
+  Mat Gs = G;
+  for (Index k1 = 0; k1 < n1; ++k1)
+    for (Index k2 = 0; k2 < n2; ++k2) Gs(k2, k1) = (G(k2, k1) + G((n2 - k2) % n2, (n1 - k1) % n1)) / Scalar(2);
+  Gs(0, 0) += Scalar(RealScalar(2 * n1 * n2));
+  Bccb<Scalar> C(Gs);
+  Mat dense = reference_bccb<Scalar>(Gs);
+  VERIFY_IS_APPROX(dense, Mat(dense.transpose()));
+
+  const Index N = n1 * n2;
+  Vec b = Vec::Random(N);
+  ConjugateGradient<Bccb<Scalar>, Lower | Upper, IdentityPreconditioner> cg;
+  cg.compute(C);
+  Vec x = cg.solve(b);
+  VERIFY(cg.info() == Success);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+}
+
+template <typename Scalar, int N2, int N1>
+void test_bccb_fixed() {
+  typedef Matrix<Scalar, N2, N1> GenMat;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  GenMat G = GenMat::Random();
+  Bccb<Scalar, N2, N1> C(G);
+  STATIC_CHECK((Bccb<Scalar, N2, N1>::RowsAtCompileTime == N1 * N2));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeBccb(G))>::RowsAtCompileTime == N1 * N2));
+
+  Mat dense = reference_bccb<Scalar>(Mat(G));
+  Matrix<Scalar, N1 * N2, N1 * N2> Cd = C;
+  VERIFY_IS_APPROX(Mat(Cd), dense);
+
+  Matrix<Scalar, N1 * N2, 1> x = Matrix<Scalar, N1 * N2, 1>::Random();
+  Matrix<Scalar, N1 * N2, 1> y = C * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+}
+
+template <typename RealScalar>
+void test_structured_symbol_reciprocals() {
+  using Complex = std::complex<RealScalar>;
+  using CVector = Matrix<Complex, Dynamic, 1>;
+  using RVector = Matrix<RealScalar, Dynamic, 1>;
+  constexpr Index kPacketSize = internal::packet_traits<Complex>::size;
+  const Index count = 3 * kPacketSize + 1;
+  const RealScalar epsilon = NumTraits<RealScalar>::epsilon();
+  const RealScalar lower = numext::ldexp(RealScalar(1), std::numeric_limits<RealScalar>::min_exponent / 2);
+  const RealScalar upper = numext::ldexp(RealScalar(1), std::numeric_limits<RealScalar>::max_exponent / 2 - 1);
+  const RealScalar minimum = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar maximum = (std::numeric_limits<RealScalar>::max)();
+  const RealScalar infinity = NumTraits<RealScalar>::infinity();
+  const RealScalar nan = NumTraits<RealScalar>::quiet_NaN();
+  const RealScalar values[] = {RealScalar(0),
+                               -RealScalar(0),
+                               RealScalar(1),
+                               RealScalar(-1),
+                               lower / 2,
+                               lower,
+                               upper,
+                               upper * 2,
+                               minimum,
+                               minimum / 2,
+                               std::numeric_limits<RealScalar>::denorm_min(),
+                               RealScalar(0.75) * maximum,
+                               infinity,
+                               nan};
+  CVector symbol(count + 2), inverse(count + 2), unthresholded(count + 2);
+  RVector moduli(count + 2);
+  // Slide each special value through every lane, with unaligned inputs and a scalar tail.
+  for (Index offset = 0; offset <= 1; ++offset) {
+    for (Index lane = 0; lane < kPacketSize; ++lane) {
+      for (RealScalar real : values) {
+        for (RealScalar imag : values) {
+          symbol.setConstant(Complex(3, 4));
+          moduli.setOnes();
+          symbol(offset + lane) = Complex(real, imag);
+          symbol(offset + count - 1) = Complex(real, imag);
+          inverse.setConstant(Complex(9));
+          internal::structured_symbol_reciprocal<RealScalar>(symbol.data() + offset, moduli.data() + offset,
+                                                             RealScalar(1), inverse.data() + offset, count);
+          unthresholded = symbol;
+          internal::structured_symbol_reciprocal(unthresholded.data() + offset, count);
+          VERIFY_IS_EQUAL(unthresholded(offset + count), symbol(offset + count));
+          if (offset) VERIFY_IS_EQUAL(unthresholded(0), symbol(0));
+          VERIFY_IS_EQUAL(inverse(offset + count), Complex(9));
+          if (offset) VERIFY_IS_EQUAL(inverse(0), Complex(9));
+          for (Index k = offset; k < offset + count; ++k) {
+            const Complex expected = internal::structured_scaled_reciprocal(symbol(k));
+            for (const CVector* result : {&inverse, &unthresholded}) {
+              for (Index component = 0; component < 2; ++component) {
+                const RealScalar actual = component ? (*result)(k).imag() : (*result)(k).real();
+                const RealScalar reference = component ? expected.imag() : expected.real();
+                if ((numext::isnan)(reference)) {
+                  VERIFY((numext::isnan)(actual));
+                } else if ((numext::isinf)(reference) || reference == RealScalar(0)) {
+                  VERIFY_IS_EQUAL(actual, reference);
+                  VERIFY_IS_EQUAL(std::signbit(actual), std::signbit(reference));
+                } else {
+                  VERIFY((numext::isfinite)(actual));
+                  VERIFY(numext::abs(actual / reference - RealScalar(1)) <= RealScalar(8) * epsilon);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Positive denominator: two squares, their sum and a division, plus reference rounding.
+  for (Index trial = 0; trial < 100; ++trial) {
+    for (Index k = 0; k < count; ++k) {
+      const int exponent = internal::random<int>(std::numeric_limits<RealScalar>::min_exponent / 2,
+                                                 std::numeric_limits<RealScalar>::max_exponent / 2 - 1);
+      const RealScalar re = numext::ldexp(internal::random<RealScalar>(RealScalar(0.5), RealScalar(1)), exponent);
+      const RealScalar im = numext::ldexp(internal::random<RealScalar>(RealScalar(-1), RealScalar(-0.5)), exponent);
+      symbol(k) = Complex(re, im);
+    }
+    moduli.setOnes();
+    internal::structured_symbol_reciprocal<RealScalar>(symbol.data(), moduli.data(), RealScalar(1), inverse.data(),
+                                                       count);
+    for (Index k = 0; k < count; ++k) {
+      const long double re = static_cast<long double>(symbol(k).real());
+      const long double im = static_cast<long double>(symbol(k).imag());
+      const long double scale = (std::max)(std::abs(re), std::abs(im));
+      const long double a = re / scale, b = im / scale;
+      const long double denom = a * a + b * b;
+      const long double expected[] = {(a / denom) / scale, (-b / denom) / scale};
+      for (Index component = 0; component < 2; ++component) {
+        const long double actual = static_cast<long double>(component ? inverse(k).imag() : inverse(k).real());
+        VERIFY(std::abs(actual / expected[component] - 1) <= 8 * static_cast<long double>(epsilon));
+      }
+    }
+  }
+
+  symbol.setConstant(Complex(3, 4));
+  moduli.setOnes();
+  for (Index k = 0; k < count; k += 2) {
+    symbol(k) = Complex(0);
+    moduli(k) = RealScalar(0);
+  }
+  std::fenv_t saved_environment;
+  const bool environment_saved = std::feholdexcept(&saved_environment) == 0;
+  internal::structured_symbol_reciprocal<RealScalar>(symbol.data(), moduli.data(), RealScalar(1), inverse.data(),
+                                                     count);
+  if (environment_saved) {
+    const int exceptions = std::fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
+    std::fesetenv(&saved_environment);
+    VERIFY_IS_EQUAL(exceptions, 0);
+  }
+  for (Index k = 0; k < count; ++k) {
+    if (k % 2 == 0) {
+      VERIFY_IS_EQUAL(inverse(k), Complex(0));
+      VERIFY(!std::signbit(inverse(k).real()));
+      VERIFY(!std::signbit(inverse(k).imag()));
+    } else {
+      const Complex expected(RealScalar(3) / RealScalar(25), -RealScalar(4) / RealScalar(25));
+      VERIFY(numext::abs(inverse(k) - expected) <= RealScalar(8) * epsilon);
+    }
+  }
+  // NaN moduli, like exact equality above, must remain in the inverted set.
+  symbol.setConstant(Complex(3, 4));
+  moduli.setConstant(nan);
+  internal::structured_symbol_reciprocal<RealScalar>(symbol.data(), moduli.data(), RealScalar(1), inverse.data(),
+                                                     count);
+  VERIFY((inverse.head(count).array().abs() > RealScalar(0)).all());
+  internal::structured_symbol_reciprocal<RealScalar>(nullptr, nullptr, RealScalar(1), nullptr, 0);
+  internal::structured_symbol_reciprocal<RealScalar>(nullptr, 0);
+}
+
+template <typename RealScalar>
+void test_structured_packet_reciprocals() {
+  using Complex = std::complex<RealScalar>;
+  using CMatrix = Matrix<Complex, Dynamic, Dynamic>;
+  CMatrix generator = CMatrix::Zero(3, 5);
+  generator(0, 0) = Complex(3, 4);  // Constant non-real symbol exercises packets and the tail.
+  const Bccb<Complex> op(generator);
+  const CMatrix expected = CMatrix::Random(15, 2);
+  const CMatrix rhs = generator(0, 0) * expected;
+  CMatrix actual = op.solve(rhs);
+  VERIFY(actual.allFinite());
+  // Forward/inverse 3-by-5 transforms and one reciprocal contribute rounding.
+  VERIFY((actual - expected).norm() <= RealScalar(64) * NumTraits<RealScalar>::epsilon() * expected.norm());
+  Matrix<Complex, Dynamic, 1> column = Matrix<Complex, Dynamic, 1>::Zero(15);
+  column(0) = generator(0, 0);
+  const Circulant<Complex> circulant(column);
+  actual = circulant.solve(rhs);
+  VERIFY(actual.allFinite());
+  VERIFY((actual - expected).norm() <= RealScalar(64) * NumTraits<RealScalar>::epsilon() * expected.norm());
+  actual = circulant.inverse() * rhs;
+  VERIFY(actual.allFinite());
+  VERIFY((actual - expected).norm() <= RealScalar(64) * NumTraits<RealScalar>::epsilon() * expected.norm());
+}
+
+template <typename RealScalar>
+void test_circulant_inverse_modes() {
+  using Complex = std::complex<RealScalar>;
+  using CVector = Matrix<Complex, Dynamic, 1>;
+  const RealScalar epsilon = NumTraits<RealScalar>::epsilon();
+  // The small mode is representable but below the solve's rank threshold.
+  CVector column(2);
+  column << Complex(1), Complex(1 - epsilon);
+  const Circulant<Complex> circulant(column);
+  VERIFY_IS_EQUAL(circulant.rank(), 1);
+  const Complex circulant_mode = circulant.inverse().symbol()(1);
+  VERIFY(numext::abs(circulant_mode * epsilon - Complex(1)) <= RealScalar(8) * epsilon);
+
+  // 1/(a+ia) = (0.5/a)(1-i), even when an unscaled denominator overflows.
+  const RealScalar a = RealScalar(0.75) * (std::numeric_limits<RealScalar>::max)();
+  for (Index n : {Index(1), Index(48)}) {
+    column.setZero(n);
+    column(0) = Complex(a, a);
+    const CVector circulant_inverse = Circulant<Complex>(column).inverse().symbol();
+    VERIFY(circulant_inverse.allFinite());
+    volatile RealScalar minimum = (std::numeric_limits<RealScalar>::min)();
+    if (!numext::is_exactly_zero(minimum * RealScalar(0.5))) {
+      for (Index k = 0; k < n; ++k) {
+        VERIFY(numext::abs(circulant_inverse(k).real() * a - RealScalar(0.5)) <= RealScalar(64) * epsilon);
+        VERIFY(numext::abs(circulant_inverse(k).imag() * a + RealScalar(0.5)) <= RealScalar(64) * epsilon);
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(structured_bccb) {
+  STATIC_CHECK((!internal::structured_reciprocal_packet_traits<long double>::Vectorizable));
+#ifdef EIGEN_VECTORIZE_SSE2
+  STATIC_CHECK((internal::structured_reciprocal_packet_traits<float>::Vectorizable));
+  STATIC_CHECK((internal::structured_reciprocal_packet_traits<double>::Vectorizable));
+#else
+  STATIC_CHECK((!internal::structured_reciprocal_packet_traits<float>::Vectorizable));
+  STATIC_CHECK((!internal::structured_reciprocal_packet_traits<double>::Vectorizable));
+#endif
+  for (int i = 0; i < g_repeat; ++i) {
+    // Products, dense assignment, coefficient access: scalar tier (N <= 32) and
+    // 2-D FFT tier, including single-row/column-of-blocks degenerate shapes.
+    CALL_SUBTEST_1((test_bccb_product<double>(1, 1)));
+    CALL_SUBTEST_1((test_bccb_product<double>(3, 4)));
+    CALL_SUBTEST_1((test_bccb_product<double>(5, 5)));
+    CALL_SUBTEST_1((test_bccb_product<double>(8, 6)));
+    CALL_SUBTEST_1((test_bccb_product<double>(7, 5)));  // odd prime dimensions
+    CALL_SUBTEST_1((test_bccb_product<double>(1, 40)));
+    CALL_SUBTEST_1((test_bccb_product<double>(40, 1)));
+    CALL_SUBTEST_1((test_bccb_product<float>(6, 8)));
+    CALL_SUBTEST_1((test_bccb_product<std::complex<double>>(4, 3)));
+    CALL_SUBTEST_1((test_bccb_product<std::complex<double>>(9, 6)));
+    CALL_SUBTEST_1((test_bccb_product<std::complex<float>>(6, 7)));
+
+    // Transposition family with exact symbol round trips.
+    CALL_SUBTEST_2((test_bccb_transpose<double>(3, 4)));
+    CALL_SUBTEST_2((test_bccb_transpose<double>(8, 6)));
+    CALL_SUBTEST_2((test_bccb_transpose<double>(1, 12)));
+    CALL_SUBTEST_2((test_bccb_transpose<std::complex<double>>(6, 8)));
+    CALL_SUBTEST_2((test_bccb_transpose<std::complex<float>>(5, 7)));
+
+    // Direct and pseudo-inverse solves, degenerate operators.
+    CALL_SUBTEST_3((test_bccb_solve<double>(1, 1)));
+    CALL_SUBTEST_3((test_bccb_solve<double>(6, 8)));
+    CALL_SUBTEST_3((test_bccb_solve<float>(5, 6)));
+    CALL_SUBTEST_3((test_bccb_solve<std::complex<double>>(6, 6)));
+    CALL_SUBTEST_3((test_bccb_rank_deficient<std::complex<double>>(6, 8, 4)));
+    CALL_SUBTEST_3((test_bccb_rank_deficient<std::complex<float>>(4, 5, 2)));
+    CALL_SUBTEST_3((test_bccb_zero<double>(4, 5)));
+    CALL_SUBTEST_3(test_bccb_nan_propagation(6, 7));
+
+    // Closed-form eigendecomposition, SVD, inverse, determinant.
+    CALL_SUBTEST_4((test_bccb_eigen<double>(4, 5)));
+    CALL_SUBTEST_4((test_bccb_eigen<double>(1, 8)));
+    CALL_SUBTEST_4((test_bccb_eigen<std::complex<double>>(3, 5)));
+    CALL_SUBTEST_4((test_bccb_svd<double>(4, 5)));
+    CALL_SUBTEST_4((test_bccb_svd<std::complex<double>>(4, 4)));
+    CALL_SUBTEST_4((test_bccb_svd<float>(3, 4)));
+    CALL_SUBTEST_4((test_bccb_inverse<double>(6, 8)));
+    CALL_SUBTEST_4((test_bccb_inverse<std::complex<double>>(5, 5)));
+    CALL_SUBTEST_4((test_bccb_determinant<double>(3, 4)));
+    CALL_SUBTEST_4((test_bccb_determinant<std::complex<double>>(3, 3)));
+
+    // Matrix-free iterative solve and fixed-size generators.
+    CALL_SUBTEST_5((test_bccb_matrix_free_cg<double>(8, 10)));
+    CALL_SUBTEST_5((test_bccb_fixed<double, 3, 4>()));
+    CALL_SUBTEST_5((test_bccb_fixed<std::complex<float>, 4, 3>()));
+
+    // Non-5-smooth (prime) block dimensions: the padded product-embedding grid,
+    // in each axis combination (n2 awkward, n1 awkward, both).
+    CALL_SUBTEST_5((test_bccb_prime_dimensions<double>(7, 6)));
+    CALL_SUBTEST_5((test_bccb_prime_dimensions<double>(6, 7)));
+    CALL_SUBTEST_5((test_bccb_prime_dimensions<double>(7, 7)));
+    CALL_SUBTEST_5((test_bccb_prime_dimensions<std::complex<double>>(11, 7)));
+    CALL_SUBTEST_5((test_bccb_prime_dimensions<float>(7, 6)));
+
+    // Product lifetime, aliasing, mixed-scalar promotion, dimension mismatches,
+    // across the scalar-loop and FFT dispatch tiers.
+    CALL_SUBTEST_6((test_bccb_delayed_product<double>(4, 5)));
+    CALL_SUBTEST_6((test_bccb_delayed_product<std::complex<double>>(6, 8)));
+    CALL_SUBTEST_6((test_bccb_aliased_product<double>(3, 4)));
+    CALL_SUBTEST_6((test_bccb_aliased_product<double>(8, 6)));
+    CALL_SUBTEST_6((test_bccb_aliased_product<std::complex<double>>(6, 8)));
+    CALL_SUBTEST_6((test_bccb_aliased_expression<double>(3, 4)));
+    CALL_SUBTEST_6((test_bccb_aliased_expression<double>(6, 8)));
+    CALL_SUBTEST_6((test_bccb_aliased_expression<std::complex<double>>(6, 8)));
+    CALL_SUBTEST_6((test_bccb_mixed_scalar<double>(3, 4)));
+    CALL_SUBTEST_6((test_bccb_mixed_scalar<double>(6, 8)));
+    CALL_SUBTEST_6((test_bccb_mixed_scalar<float>(8, 8)));
+    CALL_SUBTEST_6(test_bccb_dimension_asserts());
+
+    // Finite-range robustness: scaled transforms, the complex overflow boundary,
+    // balanced determinant accumulation, and the rank threshold boundary.
+    CALL_SUBTEST_7(test_bccb_finite_overflow());
+    CALL_SUBTEST_7((test_bccb_fft_complex_boundary<double>(6, 8)));
+    CALL_SUBTEST_7((test_bccb_fft_complex_boundary<float>(6, 8)));
+    CALL_SUBTEST_7(test_bccb_determinant_scaled());
+    CALL_SUBTEST_7(test_bccb_rank_boundaries());
+    CALL_SUBTEST_7(test_bccb_rank_complex_boundary());
+    CALL_SUBTEST_7(test_bccb_rank_flush_to_zero());
+
+    // Entrywise Inf/NaN propagation: FFT-sized operators must fall back to the
+    // direct kernel; small ones are IEEE-exact already. A zero right-hand side
+    // under a non-finite operator yields NaN, not zero.
+    CALL_SUBTEST_7((test_bccb_nonfinite_product<double>(6, 8)));
+    CALL_SUBTEST_7((test_bccb_nonfinite_product<double>(3, 4)));
+    CALL_SUBTEST_7((test_bccb_nonfinite_product<std::complex<double>>(6, 8)));
+    CALL_SUBTEST_7(test_bccb_nonfinite_zero_rhs(6, 8));
+
+    CALL_SUBTEST_8(test_structured_symbol_reciprocals<float>());
+    CALL_SUBTEST_8(test_structured_symbol_reciprocals<double>());
+    CALL_SUBTEST_8(test_structured_symbol_reciprocals<long double>());
+    CALL_SUBTEST_8(test_structured_packet_reciprocals<float>());
+    CALL_SUBTEST_8(test_structured_packet_reciprocals<double>());
+    CALL_SUBTEST_8(test_circulant_inverse_modes<float>());
+    CALL_SUBTEST_8(test_circulant_inverse_modes<double>());
+  }
+}
diff --git a/contrib/test/structured_cauchy.cpp b/contrib/test/structured_cauchy.cpp
new file mode 100644
index 0000000..68f7685
--- /dev/null
+++ b/contrib/test/structured_cauchy.cpp
@@ -0,0 +1,816 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Reference dense Cauchy built entry-wise from the node vectors.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_cauchy(const Matrix<Scalar, Dynamic, 1>& x,
+                                                  const Matrix<Scalar, Dynamic, 1>& y) {
+  Matrix<Scalar, Dynamic, Dynamic> dense(x.size(), y.size());
+  for (Index j = 0; j < y.size(); ++j)
+    for (Index i = 0; i < x.size(); ++i) dense(i, j) = Scalar(1) / (x[i] - y[j]);
+  return dense;
+}
+
+// Reference dense Cauchy built entry-wise through the guarded reciprocal, the
+// single helper every coefficient evaluation must agree with at the overflow
+// boundary.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_cauchy_guarded(const Matrix<Scalar, Dynamic, 1>& x,
+                                                          const Matrix<Scalar, Dynamic, 1>& y) {
+  Matrix<Scalar, Dynamic, Dynamic> dense(x.size(), y.size());
+  for (Index j = 0; j < y.size(); ++j)
+    for (Index i = 0; i < x.size(); ++i) dense(i, j) = internal::cauchy_reciprocal_diff(x[i], y[j]);
+  return dense;
+}
+
+// Separated node sets: x in [2,3], y in [0,1], so all denominators are in [1,3].
+template <typename Scalar>
+void separated_nodes(Index m, Index n, Matrix<Scalar, Dynamic, 1>& x, Matrix<Scalar, Dynamic, 1>& y) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  x = Matrix<Scalar, Dynamic, 1>::Random(m);
+  y = Matrix<Scalar, Dynamic, 1>::Random(n);
+  x = (x * Scalar(RealScalar(0.5))).array() + Scalar(RealScalar(2.5));
+  y = (y * Scalar(RealScalar(0.5))).array() + Scalar(RealScalar(0.5));
+}
+
+template <typename Scalar>
+void test_cauchy_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x, y;
+  separated_nodes<Scalar>(m, n, x, y);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = reference_cauchy<Scalar>(x, y);
+
+  Mat Cd = C;
+  VERIFY_IS_APPROX(Cd, dense);
+  Mat accumulated = Mat::Random(m, n);
+  const Mat initial = accumulated;
+  accumulated += C;
+  VERIFY_IS_APPROX(accumulated, initial + dense);
+  accumulated -= C;
+  VERIFY_IS_APPROX(accumulated, initial);
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, m - 1), j = internal::random<Index>(0, n - 1);
+    VERIFY_IS_APPROX(C.coeff(i, j), dense(i, j));
+  }
+
+  Vec v = Vec::Random(n);
+  VERIFY_IS_APPROX((C * v).eval(), (dense * v).eval());
+
+  Mat V = Mat::Random(n, 3);
+  VERIFY_IS_APPROX((C * V).eval(), (dense * V).eval());
+
+  // Accumulation form exercised by the iterative solvers.
+  Vec w = Vec::Random(m);
+  Vec w0 = w;
+  w.noalias() += C * v;
+  VERIFY_IS_APPROX(w, (w0 + dense * v).eval());
+}
+
+template <typename Scalar>
+void test_cauchy_transpose(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x, y;
+  separated_nodes<Scalar>(m, n, x, y);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = reference_cauchy<Scalar>(x, y);
+
+  Mat Td = C.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = C.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Kd = C.conjugate();
+  VERIFY_IS_APPROX(Kd, Mat(dense.conjugate()));
+
+  Vec w = Vec::Random(m);
+  VERIFY_IS_APPROX((C.transpose() * w).eval(), (dense.transpose() * w).eval());
+  VERIFY_IS_APPROX((C.adjoint() * w).eval(), (dense.adjoint() * w).eval());
+}
+
+// GKO solve on separated random nodes, verified through residuals (Cauchy
+// matrices are exponentially ill-conditioned, so forward-error comparisons
+// between different algorithms would not be meaningful).
+template <typename Scalar>
+void test_cauchy_lu(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x, y;
+  separated_nodes<Scalar>(n, n, x, y);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = reference_cauchy<Scalar>(x, y);
+
+  CauchyLU<Scalar> lu(C);
+  VERIFY(lu.info() == Success);
+
+  // Backward-stability-style residual bound, scaled by the scalar's epsilon (the
+  // separated node sets bound the GKO generators by 1, so no growth term).
+  const RealScalar tol = RealScalar(1000) * RealScalar(n) * NumTraits<RealScalar>::epsilon();
+
+  Vec b = Vec::Random(n);
+  Vec u = lu.solve(b);
+  VERIFY((dense * u - b).norm() <= tol * (dense.norm() * u.norm() + b.norm()));
+
+  // Multiple right-hand sides.
+  Mat B = Mat::Random(n, 3);
+  Mat U = lu.solve(B);
+  VERIFY((dense * U - B).norm() <= tol * (dense.norm() * U.norm() + B.norm()));
+
+  // Transposed and adjoint systems reuse the same factorization.
+  Vec vt = lu.transpose().solve(b);
+  VERIFY((dense.transpose() * vt - b).norm() <= tol * (dense.norm() * vt.norm() + b.norm()));
+  Vec va = lu.adjoint().solve(b);
+  VERIFY((dense.adjoint() * va - b).norm() <= tol * (dense.norm() * va.norm() + b.norm()));
+}
+
+// The Hilbert matrix as a Cauchy matrix (x_i = i+1, y_j = -j): deterministic
+// residual bounds far below what the astronomical conditioning would allow a
+// forward-error test, plus the closed-form determinant against the dense LU one.
+void test_cauchy_hilbert() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  auto residual = [](Index n) {
+    Vec x(n), y(n);
+    for (Index i = 0; i < n; ++i) {
+      x[i] = double(i + 1);
+      y[i] = -double(i);
+    }
+    Cauchy<double> C(x, y);
+    Mat dense = reference_cauchy<double>(x, y);
+    Vec b = dense * Vec::Ones(n);
+    CauchyLU<double> lu(C);
+    VERIFY(lu.info() == Success);
+    Vec u = lu.solve(b);
+    return (dense * u - b).norm() / b.norm();
+  };
+  // GKO partial pivoting is backward stable, so the residual stays a small
+  // multiple of epsilon even as the Hilbert conditioning explodes with n.
+  const double eps = NumTraits<double>::epsilon();
+  VERIFY(residual(8) <= 5e5 * eps);   // ~1e-10
+  VERIFY(residual(12) <= 5e7 * eps);  // ~1e-8
+
+  Vec x(5), y(5);
+  for (Index i = 0; i < 5; ++i) {
+    x[i] = double(i + 1);
+    y[i] = -double(i);
+  }
+  Cauchy<double> H5(x, y);
+  Mat dense = reference_cauchy<double>(x, y);
+  VERIFY_IS_APPROX(H5.determinant(), dense.determinant());
+}
+
+// Clustered row nodes make leading minors nearly singular: partial pivoting must
+// keep the factorization backward stable (residual check).
+void test_cauchy_lu_pivoting(Index n) {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  Vec x(n), y(n);
+  for (Index i = 0; i < n; ++i) {
+    x[i] = 2.0 + 1e-13 * double(i * i);  // tight cluster
+    y[i] = double(i) / double(n);        // spread out
+  }
+  Cauchy<double> C(x, y);
+  Mat dense = reference_cauchy<double>(x, y);
+  CauchyLU<double> lu(C);
+  VERIFY(lu.info() == Success);
+  Vec b = Vec::Random(n);
+  Vec u = lu.solve(b);
+  const double tol = 5e7 * NumTraits<double>::epsilon();  // ~1e-8
+  VERIFY((dense * u - b).norm() <= tol * (dense.norm() * u.norm() + b.norm()));
+}
+
+// A duplicated row node makes two rows identical, hence the matrix exactly
+// singular; a zero pivot must survive partial pivoting and be reported.
+void test_cauchy_lu_singular() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  Vec x(5), y(5);
+  x << 2.0, 2.5, 2.0, 2.75, 2.25;  // x[2] duplicates x[0]
+  y << 0.1, 0.3, 0.5, 0.7, 0.9;
+  Cauchy<double> C(x, y);
+  CauchyLU<double> lu(C);
+  VERIFY(lu.info() == NumericalIssue);
+}
+
+// Generator mantissas can overflow even when every matrix entry and LU factor
+// is finite. Exponent-tracked generators must preserve the cancellation against
+// the node reciprocal, and still expose an exact duplicate-row singularity.
+template <typename Scalar>
+void test_cauchy_lu_scaled_generators() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x(2), y(2), b(2);
+  const RealScalar P = std::ldexp(RealScalar(1), 1000);
+  const RealScalar t = std::ldexp(RealScalar(1), -1000);
+  x << Scalar(0), Scalar(-P);
+  y << Scalar(P), Scalar(-t);
+  b << Scalar(1), Scalar(0.25);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = C;
+  VERIFY(dense.allFinite());
+  CauchyLU<Scalar> lu(C);
+  VERIFY(lu.info() == Success);
+  Vec u = lu.solve(b);
+  VERIFY(u.allFinite());
+  const RealScalar tol = RealScalar(64) * NumTraits<RealScalar>::epsilon();
+  VERIFY((dense * u - b).cwiseAbs().maxCoeff() <= tol * b.cwiseAbs().maxCoeff());
+
+  Vec xs(2);
+  xs << Scalar(0), Scalar(0);
+  Cauchy<Scalar> Cs(xs, y);
+  Mat denseSingular = Cs;
+  VERIFY(denseSingular.allFinite());
+  CauchyLU<Scalar> singularLu(Cs);
+  VERIFY(singularLu.info() == NumericalIssue);
+
+  Vec xi(1), yi(1);
+  xi << Scalar(0);
+  yi << Scalar(-std::numeric_limits<RealScalar>::denorm_min());
+  Cauchy<Scalar> Ci(xi, yi);
+  CauchyLU<Scalar> nonfiniteLu(Ci);
+  VERIFY(nonfiniteLu.info() == NumericalIssue);
+}
+
+// y = -x gives the symmetric generalized Hilbert matrix 1/(x_i + x_j): verify
+// the symmetry closure of the transpose through the node identity C^T = C(-y,-x).
+template <typename Scalar>
+void test_cauchy_symmetric(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x(n);
+  for (Index i = 0; i < n; ++i) x[i] = Scalar(1) + Scalar(i);
+  Vec negx = -x;
+  Cauchy<Scalar> C(x, negx);
+  Mat dense = reference_cauchy<Scalar>(x, negx);
+  VERIFY_IS_APPROX(dense, Mat(dense.transpose()));
+  Cauchy<Scalar> Ct = C.transpose();
+  VERIFY_IS_EQUAL(Ct.rowNodes(), Vec(x));  // -(-x) round-trips exactly
+  Mat Ctd = Ct;
+  VERIFY_IS_APPROX(Ctd, dense);
+}
+
+// The closed form is a product of exact node differences (relative error
+// O(n^2 eps)); the dense LU determinant it is compared against carries a
+// cond(C)*eps error, so keep n small and the tolerance loose: the reference is
+// the less accurate side of this comparison.
+template <typename Scalar>
+void test_cauchy_determinant(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x, y;
+  separated_nodes<Scalar>(n, n, x, y);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = reference_cauchy<Scalar>(x, y);
+  // The closed form is accurate to O(n^2 eps); the dense LU reference is the less
+  // accurate side, its determinant carrying a relative error that grows like
+  // cond(C)*eps (empirically ~0.1*cond*eps). Scale the bound by the SVD condition
+  // number so the test is robust across random node draws.
+  JacobiSVD<Mat> svd(dense);
+  const RealScalar cond = svd.singularValues()(0) / svd.singularValues()(svd.singularValues().size() - 1);
+  const RealScalar tol = RealScalar(100) * cond * NumTraits<RealScalar>::epsilon();
+  VERIFY(numext::abs(C.determinant() - dense.determinant()) <= tol * numext::abs(dense.determinant()));
+}
+
+// The products carry the default product tag, so assignment materializes a
+// temporary exactly like a dense product: x = C * x and x += C * x must see the
+// pre-assignment right-hand side. Without the temporary, x = C * x would read a
+// zeroed right-hand side and x += C * x would interleave destination writes
+// with right-hand-side reads.
+template <typename Scalar>
+void test_cauchy_aliased_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x, y;
+  separated_nodes<Scalar>(n, n, x, y);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = reference_cauchy<Scalar>(x, y);
+
+  Vec v = Vec::Random(n);
+  Vec w = v;
+  w = C * w;
+  VERIFY_IS_APPROX(w, (dense * v).eval());
+
+  w = v;
+  w += C * w;
+  VERIFY_IS_APPROX(w, (v + dense * v).eval());
+
+  w = v;
+  w -= C * w;
+  VERIFY_IS_APPROX(w, (v - dense * v).eval());
+
+  Mat V = Mat::Random(n, 3);
+  Mat W = V;
+  W = C * W;
+  VERIFY_IS_APPROX(W, (dense * V).eval());
+}
+
+// Aliasing beyond the same-object case: the default-product temporary must also
+// resolve right-hand-side expressions that reference the destination,
+// overlapping views of one buffer, and rectangular self-assignment where the
+// destination is resized by the assignment.
+template <typename Scalar>
+void test_cauchy_aliased_expression(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec xn, yn;
+  separated_nodes<Scalar>(n, n, xn, yn);
+  Cauchy<Scalar> C(xn, yn);
+  Mat dense = reference_cauchy<Scalar>(xn, yn);
+
+  // Right-hand-side expression referencing the destination.
+  Vec v = Vec::Random(n), v0 = v;
+  v = C * (v + Vec::Ones(n));
+  VERIFY_IS_APPROX(v, (dense * (v0 + Vec::Ones(n))).eval());
+
+  // Overlapping (shifted) segments of one buffer.
+  Vec buf = Vec::Random(n + 1);
+  Vec expected = dense * buf.tail(n);
+  buf.head(n) = C * buf.tail(n);
+  VERIFY_IS_APPROX(buf.head(n).eval(), expected);
+
+  // Rectangular self-assignment: z = R * z resizes the destination from n to m,
+  // so the product must be captured before the destination storage is touched.
+  const Index m = n + 3;
+  Vec xr, yr;
+  separated_nodes<Scalar>(m, n, xr, yr);
+  Cauchy<Scalar> R(xr, yr);
+  Mat denseR = reference_cauchy<Scalar>(xr, yr);
+  Vec z = Vec::Random(n), z0 = z;
+  z = R * z;
+  VERIFY_IS_EQUAL(z.size(), m);
+  VERIFY_IS_APPROX(z, (denseR * z0).eval());
+}
+
+// transpose()/conjugate()/adjoint() return owning temporaries, so the product
+// expression must nest the structured operand by value: a delayed-evaluated
+// expression has to outlive the temporary operator it was built from. The static
+// check pins the value nesting; the behavioral check would read freed memory if
+// the product held a reference instead.
+template <typename Scalar>
+void test_cauchy_delayed_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<Cauchy<Scalar>>::type>::value);
+
+  Vec x, y;
+  separated_nodes<Scalar>(m, n, x, y);
+  Cauchy<Scalar> C(x, y);
+  Mat dense = reference_cauchy<Scalar>(x, y);
+
+  Vec w = Vec::Random(m);
+  auto expr = C.adjoint() * w;        // the adjoint temporary dies with the full expression
+  Vec scribble = Vec::Random(m + n);  // reuses the temporary's freed heap storage
+  Vec u = expr;
+  VERIFY_IS_APPROX(u, (dense.adjoint() * w).eval());
+  VERIFY_IS_EQUAL(scribble.size(), m + n);  // keep the scribble alive across the evaluation
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex product
+// scalar, so alpha and the accumulation must run in the promoted type rather than
+// the operator scalar.
+template <typename RealScalar>
+void test_cauchy_mixed_scalar(Index m, Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RVec x, y;
+  separated_nodes<RealScalar>(m, n, x, y);
+  Cauchy<RealScalar> C(x, y);
+  CMat dense = reference_cauchy<RealScalar>(x, y).template cast<Complex>();
+
+  CVec v = CVec::Random(n);
+  CVec w = C * v;
+  VERIFY_IS_APPROX(w, (dense * v).eval());
+
+  CVec w0 = CVec::Random(m);
+  w = w0;
+  w.noalias() += C * v;
+  VERIFY_IS_APPROX(w, (w0 + dense * v).eval());
+
+  CVec xc, yc;
+  separated_nodes<Complex>(m, n, xc, yc);
+  Cauchy<Complex> Cc(xc, yc);
+  CMat denseC = reference_cauchy<Complex>(xc, yc);
+  RVec vr = RVec::Random(n);
+  CVec z = Cc * vr;
+  VERIFY_IS_APPROX(z, (denseC * vr).eval());
+}
+
+// Wide-dynamic-range determinants: the closed-form factors overflow or underflow
+// individually while the determinant itself is representable, so the balanced
+// m * 2^e accumulation must carry the exponent past the intermediate extremes.
+void test_cauchy_determinant_range() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  // Reviewer repro: x = [2s, 3s], y = [0, s] with s = 1e160. The determinant is
+  // -1/(12 s^2) ~ -8.35e-322, a subnormal, while the naive numerator product
+  // -s^2 = -1e320 already overflows. Both the closed form and the dense LU
+  // reference round once into the subnormal range (spacing denorm_min), so the
+  // comparison needs an absolute term of a few subnormal spacings on top of a
+  // relative term; the relative term alone would be far below denorm_min.
+  {
+    const double s = 1e160;
+    Vec x(2), y(2);
+    x << 2 * s, 3 * s;
+    y << 0.0, s;
+    Cauchy<double> C(x, y);
+    Mat dense = reference_cauchy<double>(x, y);
+    const double det = C.determinant();
+    const double ref = dense.partialPivLu().determinant();
+    const double kRelTol = 16 * NumTraits<double>::epsilon();
+    const double kAbsTol = 4 * std::numeric_limits<double>::denorm_min();
+    VERIFY((numext::isfinite)(det));
+    VERIFY(numext::abs(det - ref) <= kRelTol * numext::abs(ref) + kAbsTol);
+  }
+
+  // Overflow-side analogue: x = [2s, 3s, 4s], y = [0, s/2, s] with s = 1e-60.
+  // The determinant is -1/(3780 s^3) ~ -2.65e176, huge but representable, while
+  // the naive numerator product -s^6/2 = -5e-361 underflows to zero. The dense
+  // LU reference is the less accurate side (its error carries the conditioning
+  // of the matrix, measured ~64 eps here); the deterministic nodes make 1000 eps
+  // comfortable headroom.
+  {
+    const double s = 1e-60;
+    Vec x(3), y(3);
+    x << 2 * s, 3 * s, 4 * s;
+    y << 0.0, s / 2, s;
+    Cauchy<double> C(x, y);
+    Mat dense = reference_cauchy<double>(x, y);
+    const double det = C.determinant();
+    const double ref = dense.partialPivLu().determinant();
+    const double kRelTol = 1000 * NumTraits<double>::epsilon();
+    VERIFY((numext::isfinite)(det));
+    VERIFY(numext::abs(det - ref) <= kRelTol * numext::abs(ref));
+  }
+
+  // Genuinely infinite determinant: x[0] == y[0] makes entry (0,0) infinite (a
+  // zero denominator factor with a non-zero numerator); the signed limit as
+  // x[0] -> y[0] from above is -inf, and division by the exact zero factor must
+  // produce it rather than a balanced-away finite value.
+  {
+    Vec x(2), y(2);
+    x << 1.0, 2.0;
+    y << 1.0, 3.0;
+    Cauchy<double> C(x, y);
+    const double det = C.determinant();
+    VERIFY((numext::isinf)(det));
+    VERIFY(det < 0.0);
+  }
+
+  // Coincident row nodes: two identical rows, so the matrix is exactly singular
+  // and the zero numerator factor must propagate to an exact zero.
+  {
+    Vec x(3), y(3);
+    x << 2.0, 3.0, 2.0;  // x[2] duplicates x[0]
+    y << 0.0, 0.5, 1.0;
+    Cauchy<double> C(x, y);
+    VERIFY_IS_EQUAL(C.determinant(), 0.0);
+  }
+}
+
+// Node differences at the overflow boundary: forming x_j - x_i or x_i - y_j can
+// overflow to Inf even though every matrix entry is finite and unexceptional.
+// Such factors must enter the balanced accumulation through the exact
+// halved-operand recomputation, so only the determinant's own overflow or
+// underflow is visible in the result -- saturated to a zero or infinity of the
+// mathematically correct sign.
+void test_cauchy_determinant_overflow_boundary() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const double M = 0.6 * (std::numeric_limits<double>::max)();
+
+  // Reviewer reproducer: every coefficient 1/(x_i - y_j) is finite and the exact
+  // determinant (2M)(-0.8M) / (0.7056 M^4) underflows, but the numerator
+  // difference x_1 - x_0 = 1.2 * DBL_MAX overflows if formed naively (the old
+  // code returned -Inf). The result must be a zero of the correct sign: one
+  // negative numerator factor against two negative denominator factors.
+  {
+    Vec x(2), y(2);
+    x << -M, M;
+    y << -0.4 * M, 0.4 * M;
+    const double det = Cauchy<double>(x, y).determinant();
+    VERIFY(det == 0.0 && std::signbit(det));
+  }
+
+  // Sign flip of the same configuration: swapping the y nodes negates the
+  // determinant, so the underflow must land on +0.
+  {
+    Vec x(2), y(2);
+    x << -M, M;
+    y << 0.4 * M, -0.4 * M;
+    const double det = Cauchy<double>(x, y).determinant();
+    VERIFY(det == 0.0 && !std::signbit(det));
+  }
+
+  // Purely imaginary nodes of the same magnitudes: the halved-operand
+  // recomputation applies componentwise to complex nodes. Scaling every node by
+  // i multiplies the 2x2 determinant by i^2 / i^4 = -1, so this underflow lands
+  // on a real part of +0 (the value is real: the four denominator divisions
+  // rotate the accumulation back onto the real axis).
+  {
+    typedef std::complex<double> Cplx;
+    Matrix<Cplx, Dynamic, 1> x(2), y(2);
+    x << Cplx(0.0, -M), Cplx(0.0, M);
+    y << Cplx(0.0, -0.4 * M), Cplx(0.0, 0.4 * M);
+    const Cplx det = Cauchy<Cplx>(x, y).determinant();
+    VERIFY(numext::real(det) == 0.0 && numext::imag(det) == 0.0);
+    VERIFY(!std::signbit(numext::real(det)));
+  }
+
+  // A representable determinant whose evaluation crosses the boundary, guard on
+  // a denominator factor (accumulated exponent decremented): with P = 2^1023,
+  // x = [-P, 0], y = [P, c], the difference x_0 - y_0 = -2^1024 overflows, yet
+  // det = (P - c) / (2 P c (P + c)), which for c = 2^-60 is 2^-964 up to a
+  // relative correction c/P ~ 2^-1083, far below roundoff. Every rounded factor
+  // is a power of two, so the balanced accumulation is exact here.
+  {
+    const double P = std::ldexp(1.0, 1023);
+    const double c = std::ldexp(1.0, -60);
+    Vec x(2), y(2);
+    x << -P, 0.0;
+    y << P, c;
+    const double det = Cauchy<double>(x, y).determinant();
+    VERIFY_IS_APPROX(det, std::ldexp(1.0, -964));
+  }
+
+  // Guard on a numerator factor (accumulated exponent incremented):
+  // x = [-P, P, 0], y = [c, -c, d] with c = 2^1000 and d = 2^-1050. The
+  // numerator difference x_1 - x_0 = 2^1024 overflows; the determinant
+  // -4 P^3 (c^2 - d^2) / ((P^2 - c^2)^2 (P^2 - d^2) c d) equals
+  // -2^-1017 / (1 - 2^-46)^2 up to relative corrections of order 2^-2050.
+  {
+    const double P = std::ldexp(1.0, 1023);
+    const double c = std::ldexp(1.0, 1000);
+    const double d = std::ldexp(1.0, -1050);
+    Vec x(3), y(3);
+    x << -P, P, 0.0;
+    y << c, -c, d;
+    const double det = Cauchy<double>(x, y).determinant();
+    const double r = 1.0 - std::ldexp(1.0, -46);  // 1 - (c/P)^2
+    VERIFY_IS_APPROX(det, -std::ldexp(1.0, -1017) / (r * r));
+  }
+
+  // Genuine overflow: clustered tiny nodes push the determinant past the
+  // representable range while every factor stays finite; the accumulated
+  // exponent must saturate to a correctly signed infinity, in both signs.
+  {
+    const double t = std::ldexp(1.0, -537);
+    Vec x(2), y(2);
+    x << 0.0, 3.0 * t;
+    y << t, 2.0 * t;  // det = -3 / (4 t^2) ~ -1.6e323
+    const double det = Cauchy<double>(x, y).determinant();
+    VERIFY((numext::isinf)(det) && std::signbit(det));
+  }
+  {
+    const double t = std::ldexp(1.0, -537);
+    Vec x(2), y(2);
+    x << 0.0, 3.0 * t;
+    y << 2.0 * t, t;  // swapped y nodes: det = +3 / (4 t^2)
+    const double det = Cauchy<double>(x, y).determinant();
+    VERIFY((numext::isinf)(det) && !std::signbit(det));
+  }
+}
+
+// Boundary nodes in every coefficient evaluation: when x_i - y_j overflows for
+// finite nodes, a naively formed coefficient collapses to 1/Inf = 0 while the
+// true value is a representable subnormal. coeff(), the dense materialization,
+// the products and the CauchyLU factorization must all produce the guarded
+// value -- and agree with determinant(), which derives the same quantity
+// through its balanced accumulation.
+void test_cauchy_boundary_coefficients() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const double X = (std::numeric_limits<double>::max)();
+  const double e = std::ldexp(1.0, -1025);  // 1/(2*DBL_MAX), correctly rounded (subnormal)
+
+  // 1x1 reviewer case: the single coefficient is 1/(2*DBL_MAX) = 2^-1025
+  // (2.7813423231340017e-309). Every step is correctly rounded IEEE arithmetic
+  // with a power-of-two result, so the checks are exact equalities.
+  {
+    Vec x(1), y(1);
+    x << X;
+    y << -X;
+    Cauchy<double> C(x, y);
+    VERIFY_IS_EQUAL(C.coeff(0, 0), e);
+    Mat d = C;
+    VERIFY_IS_EQUAL(d(0, 0), e);
+    Mat acc = Mat::Zero(1, 1);
+    acc += C;  // addTo
+    VERIFY_IS_EQUAL(acc(0, 0), e);
+    acc -= C;  // subTo
+    VERIFY_IS_EQUAL(acc(0, 0), 0.0);
+    Vec p = C * Vec::Ones(1);
+    VERIFY_IS_EQUAL(p[0], e);
+    // determinant() reaches 2^-1025 through the balanced accumulation; the
+    // guarded coefficient matches it exactly.
+    VERIFY_IS_EQUAL(C.determinant(), e);
+    // The old code materialized a zero coefficient and reported the (regular)
+    // matrix as singular; the guarded pivot is subnormal but non-zero.
+    CauchyLU<double> lu(C);
+    VERIFY(lu.info() == Success);
+    Vec u = lu.solve(p);  // p = C * [1]; recovered exactly (e / e = 1)
+    VERIFY_IS_EQUAL(u[0], 1.0);
+  }
+
+  // A non-power-of-two boundary difference catches double rounding: computing
+  // (1/t)*0.5 is one subnormal ULP above the correctly rounded 0.5/t. MPFR gives
+  // the expected value below for x=1.1777865466541931e308 and
+  // y=-1.7435684109415042e308, represented by their exact double bit patterns.
+  {
+    Vec x(1), y(1);
+    x << numext::bit_cast<double>(numext::uint64_t(0x7fe4f71daafe5a86ull));
+    y << numext::bit_cast<double>(numext::uint64_t(0xffef095b3493b755ull));
+    const double expected = numext::bit_cast<double>(numext::uint64_t(0x00027621a9baa547ull));
+    Cauchy<double> C(x, y);
+    VERIFY_IS_EQUAL(C.coeff(0, 0), expected);
+    Mat dense = C;
+    VERIFY_IS_EQUAL(dense(0, 0), expected);
+    Vec product = C * Vec::Ones(1);
+    VERIFY_IS_EQUAL(product[0], expected);
+    VERIFY_IS_EQUAL(C.determinant(), expected);
+    CauchyLU<double> lu(C);
+    VERIFY(lu.info() == Success);
+    Vec rhs(1);
+    rhs << expected;
+    Vec solution = lu.solve(rhs);
+    VERIFY_IS_EQUAL(solution[0], 1.0);
+  }
+
+  // 2x2 with boundary pairs among moderate ones: three of the four differences
+  // overflow (2X and two 1.5X), one stays finite (X). All APIs agree with the
+  // reference built from the guarded reciprocal; scaled by its magnitude the
+  // matrix is well conditioned (cond ~ 38), so the GKO solve -- whose column
+  // generation and generator updates cross the boundary too -- recovers the
+  // solution accurately.
+  {
+    Vec x(2), y(2);
+    x << X, X / 2;
+    y << -X, -X / 2;
+    Cauchy<double> C(x, y);
+    Mat ref = reference_cauchy_guarded<double>(x, y);
+    VERIFY_IS_EQUAL(ref(0, 0), e);                       // 1/(2*DBL_MAX)
+    VERIFY_IS_EQUAL(ref(1, 1), std::ldexp(1.0, -1024));  // 1/DBL_MAX
+    VERIFY(ref.allFinite());
+    VERIFY((ref.array() != 0.0).all());
+    for (Index j = 0; j < 2; ++j)
+      for (Index i = 0; i < 2; ++i) VERIFY_IS_EQUAL(C.coeff(i, j), ref(i, j));
+    Mat d = C;
+    for (Index j = 0; j < 2; ++j)
+      for (Index i = 0; i < 2; ++i) VERIFY_IS_EQUAL(d(i, j), ref(i, j));
+    Vec v(2);
+    v << 0.75, -0.5;
+    VERIFY_IS_APPROX((C * v).eval(), (ref * v).eval());
+    CauchyLU<double> lu(C);
+    VERIFY(lu.info() == Success);
+    Vec b = C * Vec::Ones(2);
+    Vec u = lu.solve(b);
+    VERIFY_IS_APPROX(u, Vec::Ones(2).eval());
+  }
+
+  // Complex nodes: purely imaginary boundary nodes overflow in the imaginary
+  // component of the difference; the guard applies componentwise. The paths
+  // sharing the helper agree exactly; the value is -i/(2*DBL_MAX) and the
+  // determinant derives it independently, both to within a few subnormal
+  // spacings (complex division rounds per component).
+  {
+    typedef std::complex<double> Cplx;
+    const double tiny = 4.0 * std::numeric_limits<double>::denorm_min();
+    Matrix<Cplx, Dynamic, 1> xc(1), yc(1);
+    xc << Cplx(0.0, X);
+    yc << Cplx(0.0, -X);
+    Cauchy<Cplx> C(xc, yc);
+    const Cplx cval = C.coeff(0, 0);
+    Matrix<Cplx, Dynamic, Dynamic> dc = C;
+    VERIFY_IS_EQUAL(dc(0, 0), cval);
+    Matrix<Cplx, Dynamic, 1> pc = C * Matrix<Cplx, Dynamic, 1>::Ones(1);
+    VERIFY_IS_EQUAL(pc[0], cval);
+    VERIFY(numext::abs(numext::real(cval)) <= tiny);
+    VERIFY(numext::abs(numext::imag(cval) + e) <= tiny);
+    const Cplx det = C.determinant();
+    VERIFY(numext::abs(numext::real(det) - numext::real(cval)) <= tiny);
+    VERIFY(numext::abs(numext::imag(det) - numext::imag(cval)) <= tiny);
+  }
+}
+
+template <typename Scalar, int M, int N>
+void test_cauchy_fixed() {
+  typedef Matrix<Scalar, M, 1> XVec;
+  typedef Matrix<Scalar, N, 1> YVec;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, M, N> MatMN;
+
+  Vec xd, yd;
+  separated_nodes<Scalar>(M, N, xd, yd);
+  XVec x = xd;
+  YVec y = yd;
+  typedef Cauchy<Scalar, M, N> CauchyType;
+  CauchyType C(x, y);
+  STATIC_CHECK((Cauchy<Scalar, M, N>::RowsAtCompileTime == M));
+  STATIC_CHECK((Cauchy<Scalar, M, N>::ColsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeCauchy(x, y))>::ColsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(C.transpose())>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(C.transpose())>::ColsAtCompileTime == M));
+
+  MatMN dense = C;
+  VERIFY_IS_APPROX(dense, MatMN(reference_cauchy<Scalar>(xd, yd)));
+
+  CauchyType* heapC = new CauchyType(x, y);
+  VERIFY(std::uintptr_t(heapC) % std::alignment_of<CauchyType>::value == 0);
+  MatMN heapDense = *heapC;
+  delete heapC;
+  VERIFY_IS_APPROX(heapDense, dense);
+
+#if EIGEN_MAX_ALIGN_BYTES > 0 && !EIGEN_HAS_CXX17_OVERALIGN
+  void* raw = (CauchyType::operator new)(sizeof(CauchyType));
+  VERIFY(std::uintptr_t(raw) % std::alignment_of<CauchyType>::value == 0);
+  (CauchyType::operator delete)(raw);
+#endif
+
+  YVec v = YVec::Random();
+  Matrix<Scalar, M, 1> w = C * v;
+  VERIFY_IS_APPROX(w, (dense * v).eval());
+
+  // .noalias() keeps the direct (temporary-free) path of the default product tag;
+  // the matching fixed dimensions also pin the compile-time product check.
+  Matrix<Scalar, M, 1> w2;
+  w2.noalias() = C * v;
+  VERIFY_IS_APPROX(w2, (dense * v).eval());
+}
+
+EIGEN_DECLARE_TEST(structured_cauchy) {
+  for (int i = 0; i < g_repeat; ++i) {
+    // Products, dense assignment, coefficient access.
+    CALL_SUBTEST_1((test_cauchy_product<double>(1, 1)));
+    CALL_SUBTEST_1((test_cauchy_product<double>(8, 8)));
+    CALL_SUBTEST_1((test_cauchy_product<double>(20, 12)));  // tall
+    CALL_SUBTEST_1((test_cauchy_product<double>(12, 20)));  // wide
+    CALL_SUBTEST_1((test_cauchy_product<float>(10, 10)));
+    CALL_SUBTEST_1((test_cauchy_product<std::complex<double>>(9, 7)));
+    CALL_SUBTEST_1((test_cauchy_product<std::complex<float>>(7, 9)));
+    CALL_SUBTEST_1((test_cauchy_transpose<double>(10, 14)));
+    CALL_SUBTEST_1((test_cauchy_transpose<std::complex<double>>(8, 6)));
+
+    // GKO pivoted LU solves.
+    CALL_SUBTEST_2((test_cauchy_lu<double>(1)));
+    CALL_SUBTEST_2((test_cauchy_lu<double>(2)));
+    CALL_SUBTEST_2((test_cauchy_lu<double>(12)));
+    CALL_SUBTEST_2((test_cauchy_lu<double>(30)));
+    CALL_SUBTEST_2((test_cauchy_lu<std::complex<double>>(16)));
+    CALL_SUBTEST_2((test_cauchy_lu<float>(10)));
+    CALL_SUBTEST_2(test_cauchy_hilbert());
+    CALL_SUBTEST_2(test_cauchy_lu_pivoting(20));
+    CALL_SUBTEST_2(test_cauchy_lu_singular());
+    CALL_SUBTEST_2((test_cauchy_lu_scaled_generators<double>()));
+    CALL_SUBTEST_2((test_cauchy_lu_scaled_generators<std::complex<double>>()));
+
+    // Closed-form determinant, symmetric generalized Hilbert, fixed sizes.
+    CALL_SUBTEST_3((test_cauchy_determinant<double>(4)));
+    CALL_SUBTEST_3((test_cauchy_determinant<std::complex<double>>(4)));
+    CALL_SUBTEST_3((test_cauchy_symmetric<double>(9)));
+    CALL_SUBTEST_3((test_cauchy_fixed<double, 6, 4>()));
+    CALL_SUBTEST_3((test_cauchy_fixed<std::complex<float>, 4, 5>()));
+
+    // Numerical and lifetime boundaries: aliased and value-nested (owning)
+    // delayed products, mixed-scalar products, wide-dynamic-range determinants.
+    CALL_SUBTEST_4((test_cauchy_aliased_product<double>(11)));
+    CALL_SUBTEST_4((test_cauchy_aliased_product<std::complex<double>>(8)));
+    CALL_SUBTEST_4((test_cauchy_aliased_expression<double>(11)));
+    CALL_SUBTEST_4((test_cauchy_aliased_expression<std::complex<double>>(8)));
+    CALL_SUBTEST_4((test_cauchy_delayed_product<double>(12, 9)));
+    CALL_SUBTEST_4((test_cauchy_delayed_product<std::complex<double>>(7, 10)));
+    CALL_SUBTEST_4((test_cauchy_mixed_scalar<double>(10, 13)));
+    CALL_SUBTEST_4((test_cauchy_mixed_scalar<float>(9, 6)));
+    CALL_SUBTEST_4(test_cauchy_determinant_range());
+    CALL_SUBTEST_4(test_cauchy_determinant_overflow_boundary());
+    CALL_SUBTEST_4(test_cauchy_boundary_coefficients());
+  }
+}
diff --git a/contrib/test/structured_dplr.cpp b/contrib/test/structured_dplr.cpp
new file mode 100644
index 0000000..b17348d
--- /dev/null
+++ b/contrib/test/structured_dplr.cpp
@@ -0,0 +1,684 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Well-conditioned random operator: diagonal bounded away from zero and a
+// contractive correction, so the capacitance matrix is safely invertible.
+template <typename Scalar>
+void random_dplr(Index n, Index k, Matrix<Scalar, Dynamic, 1>& d, Matrix<Scalar, Dynamic, Dynamic>& U,
+                 Matrix<Scalar, Dynamic, Dynamic>& V) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  d = Matrix<Scalar, Dynamic, 1>::Random(n);
+  d.array() += Scalar(RealScalar(3));
+  U = Scalar(RealScalar(0.5)) * Matrix<Scalar, Dynamic, Dynamic>::Random(n, k);
+  V = Scalar(RealScalar(0.5)) * Matrix<Scalar, Dynamic, Dynamic>::Random(n, k);
+}
+
+// Reference dense matrix built independently, entry by entry.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_dplr(const Matrix<Scalar, Dynamic, 1>& d,
+                                                const Matrix<Scalar, Dynamic, Dynamic>& U,
+                                                const Matrix<Scalar, Dynamic, Dynamic>& V) {
+  const Index n = d.size();
+  Matrix<Scalar, Dynamic, Dynamic> dense(n, n);
+  for (Index j = 0; j < n; ++j)
+    for (Index i = 0; i < n; ++i) {
+      Scalar s = (i == j) ? d[i] : Scalar(0);
+      for (Index t = 0; t < U.cols(); ++t) s += U(i, t) * numext::conj(V(j, t));
+      dense(i, j) = s;
+    }
+  return dense;
+}
+
+template <typename Scalar>
+void test_dplr_product(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+  VERIFY_IS_EQUAL(A.correctionRank(), k);
+
+  Mat Ad = A;
+  VERIFY_IS_APPROX(Ad, dense);
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, n - 1), j = internal::random<Index>(0, n - 1);
+    VERIFY_IS_APPROX(A.coeff(i, j), dense(i, j));
+  }
+
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((A * x).eval(), (dense * x).eval());
+
+  Mat X = Mat::Random(n, 3);
+  VERIFY_IS_APPROX((A * X).eval(), (dense * X).eval());
+
+  // Accumulation form exercised by the iterative solvers.
+  Vec y = Vec::Random(n);
+  Vec y0 = y;
+  y.noalias() += A * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+
+  // Dimension mismatches are caught when the product expression is formed.
+  VERIFY_RAISES_ASSERT(A * Vec(Vec::Random(n + 1)));
+}
+
+template <typename Scalar>
+void test_dplr_transpose(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+
+  Mat Td = A.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = A.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Kd = A.conjugate();
+  VERIFY_IS_APPROX(Kd, Mat(dense.conjugate()));
+
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((A.transpose() * x).eval(), (dense.transpose() * x).eval());
+  VERIFY_IS_APPROX((A.adjoint() * x).eval(), (dense.adjoint() * x).eval());
+}
+
+template <typename Scalar>
+void test_dplr_solve(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+
+  Vec b = Vec::Random(n);
+  Vec x = A.solve(b);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+  VERIFY_IS_APPROX(x, dense.partialPivLu().solve(b).eval());
+
+  Mat B = Mat::Random(n, 3);
+  Mat X = A.solve(B);
+  VERIFY_IS_APPROX(X, dense.partialPivLu().solve(B).eval());
+
+  Mat empty_rhs(n, 0);
+  Mat empty_solution = A.solve(empty_rhs);
+  VERIFY_IS_EQUAL(empty_solution.rows(), n);
+  VERIFY_IS_EQUAL(empty_solution.cols(), 0);
+}
+
+template <typename Scalar>
+void test_dplr_inverse_determinant(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+
+  // The inverse is itself diagonal-plus-low-rank; materialize and check.
+  DiagonalPlusLowRank<Scalar> Ainv = A.inverse();
+  VERIFY_IS_EQUAL(Ainv.correctionRank(), k);
+  Mat invd = Ainv;
+  VERIFY_IS_APPROX((invd * dense).eval(), Mat(Mat::Identity(n, n)));
+
+  // Inverting twice returns to the original operator.
+  Mat back = Ainv.inverse();
+  VERIFY_IS_APPROX(back, dense);
+
+  VERIFY_IS_APPROX(A.determinant(), dense.determinant());
+}
+
+template <typename Scalar>
+void test_dplr_matrix_free_gmres(Index n, Index k) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+
+  Vec b = Vec::Random(n);
+  GMRES<DiagonalPlusLowRank<Scalar>, IdentityPreconditioner> gmres;
+  gmres.setTolerance(RealScalar(1e-12));
+  gmres.compute(A);
+  Vec x = gmres.solve(b);
+  VERIFY(gmres.info() == Success);
+  const RealScalar tol = RealScalar(5e6) * NumTraits<RealScalar>::epsilon();  // ~1e-9 in double
+  VERIFY((dense * x - b).norm() <= tol * b.norm());
+}
+
+// The products carry the default product tag, so an assignment whose right-hand
+// side aliases the destination materializes the product into a temporary exactly
+// like a dense product would -- including the aliasing that the former
+// is_same_dense check could not see: overlapping views and right-hand-side
+// expressions referencing the destination.
+template <typename Scalar>
+void test_dplr_aliased_product(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Pin the routing: the structured products must dispatch through the shared
+  // structured_product_impl.
+  STATIC_CHECK(
+      (std::is_base_of<internal::structured_product_impl<DiagonalPlusLowRank<Scalar>, Vec>,
+                       internal::generic_product_impl<DiagonalPlusLowRank<Scalar>, Vec, internal::StructuredShape,
+                                                      DenseShape, GemvProduct>>::value));
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+
+  Vec x = Vec::Random(n);
+  Vec y = x;
+  y = A * y;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  y = x;
+  y += A * y;
+  VERIFY_IS_APPROX(y, (x + dense * x).eval());
+
+  // Right-hand-side expression referencing the destination.
+  y = x;
+  y = A * (y + Vec::Ones(n));
+  VERIFY_IS_APPROX(y, (dense * (x + Vec::Ones(n))).eval());
+
+  // Overlapping views of a shared buffer, in both directions.
+  Vec w = Vec::Random(n + 1);
+  Vec w0 = w;
+  w.tail(n) = A * w.head(n);
+  VERIFY_IS_APPROX(w.tail(n).eval(), (dense * w0.head(n)).eval());
+  w = w0;
+  w.head(n) = A * w.tail(n);
+  VERIFY_IS_APPROX(w.head(n).eval(), (dense * w0.tail(n)).eval());
+}
+
+// Product expressions must nest the structured operand by value: a
+// delayed-evaluated expression has to outlive the temporary operator it was
+// built from. The static check pins the value nesting; the behavioral check
+// would read freed memory if the product held a reference instead.
+template <typename Scalar>
+void test_dplr_delayed_product(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<DiagonalPlusLowRank<Scalar>>::type>::value);
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+  Mat dense = reference_dplr<Scalar>(d, U, V);
+
+  Vec x = Vec::Random(n);
+  auto expr = A.adjoint() * x;        // the adjoint temporary dies with the full expression
+  Vec scribble = Vec::Random(2 * n);  // reuses the temporary's freed heap storage
+  Vec y = expr;
+  VERIFY_IS_APPROX(y, (dense.adjoint() * x).eval());
+  VERIFY_IS_EQUAL(scribble.size(), 2 * n);  // keep the scribble alive across the evaluation
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex product
+// scalar, so alpha, the workspaces and the accumulation must run in the promoted
+// type rather than the operator scalar.
+template <typename RealScalar>
+void test_dplr_mixed_scalar(Index n, Index k) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> RMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RVec d;
+  RMat U, V;
+  random_dplr<RealScalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<RealScalar> A(d, U, V);
+  CMat dense = reference_dplr<RealScalar>(d, U, V).template cast<Complex>();
+
+  CVec x = CVec::Random(n);
+  CVec y = A * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  CVec y0 = CVec::Random(n);
+  y = y0;
+  y.noalias() += A * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+
+  CVec dc;
+  CMat Uc, Vc;
+  random_dplr<Complex>(n, k, dc, Uc, Vc);
+  DiagonalPlusLowRank<Complex> Ac(dc, Uc, Vc);
+  CMat denseC = reference_dplr<Complex>(dc, Uc, Vc);
+  RVec xr = RVec::Random(n);
+  CVec z = Ac * xr;
+  VERIFY_IS_APPROX(z, (denseC * xr).eval());
+}
+
+// Wide-dynamic-range determinants: the diagonal product is accumulated in the
+// balanced form m * 2^e, so partial products neither overflow nor underflow
+// when the determinant itself is representable, whatever the ordering of large
+// and small diagonal entries. Genuinely non-representable determinants must
+// still saturate to infinity / zero.
+void test_dplr_determinant_scaled() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  {
+    // The reviewer's magnitude regime: det(D) = 1e200 * 1e200 * 1e-100 = 1e300 is
+    // finite, but the plain running product hits 1e400 partway. k = 0 at runtime.
+    Vec d(3);
+    d << 1e200, 1e200, 1e-100;
+    DiagonalPlusLowRank<double> A(d, Mat::Zero(3, 0), Mat::Zero(3, 0));
+    const double det = A.determinant();
+    VERIFY((numext::isfinite)(det));
+    VERIFY_IS_APPROX(det, 1e300);
+  }
+  {
+    // Underflow-side analogue: the partial product flushes to zero at 1e-400
+    // while det(D) = 1e-300 is representable.
+    Vec d(3);
+    d << 1e-200, 1e-200, 1e100;
+    DiagonalPlusLowRank<double> A(d, Mat::Zero(3, 0), Mat::Zero(3, 0));
+    const double det = A.determinant();
+    VERIFY(det != 0.0);
+    VERIFY_IS_APPROX(det, 1e-300);
+  }
+  {
+    // The capacitance determinant enters the same balanced accumulation: with
+    // 450 entries of 10 first, the running diagonal product tops out at 1e450
+    // while det(D) = 10^450 * 10^-150 = 1e300; the rank-1 correction
+    // U = d[0] e_0, V = e_0 gives the capacitance 1 + d[0]/d[0] = 2, so
+    // det(A) = 2e300 by the determinant lemma.
+    const Index n = 600;
+    Vec d(n);
+    d.head(450).setConstant(10.0);
+    d.tail(150).setConstant(0.1);
+    Mat U = Mat::Zero(n, 1), V = Mat::Zero(n, 1);
+    U(0, 0) = d[0];
+    V(0, 0) = 1.0;
+    DiagonalPlusLowRank<double> A(d, U, V);
+    const double det = A.determinant();
+    // One rounding multiply per balanced factor, and the decimal constants 0.1
+    // and their 150-fold product are themselves inexact: a few n eps total.
+    const double det_tol = 4.0 * double(n) * NumTraits<double>::epsilon();
+    VERIFY((numext::isfinite)(det));
+    VERIFY(numext::abs(det / 2e300 - 1.0) <= det_tol);
+  }
+  {
+    // Complex scalars balance on max(|re|, |im|): det = i * 1e200 * 1e100 = 1e300 i.
+    CVec d(3);
+    d << Complex(0, 1e200), Complex(1e200, 0), Complex(1e-100, 0);
+    DiagonalPlusLowRank<Complex> A(d, CMat::Zero(3, 0), CMat::Zero(3, 0));
+    VERIFY_IS_APPROX(A.determinant(), Complex(0, 1e300));
+  }
+}
+
+// The two factors of the determinant lemma can sit at opposite ends of the exponent range even when
+// the determinant is ~1, since D^{-1} scales the capacitance entries by the reciprocal diagonal. Both
+// det(D) and det(capacitance) must therefore accumulate in the balanced mantissa * 2^e form, the
+// latter from the LU pivots rather than the plain pivot product .determinant() would form.
+void test_dplr_determinant_capacitance() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  const double eps = NumTraits<double>::epsilon();
+
+  {
+    // The reviewer's reproducer: D + I I^H = diag(1 + 1e-200) is essentially the
+    // identity, but det(D) = 1e-400 underflows and det(capacitance) ~ 1e400
+    // overflows when either is formed on its own.
+    Vec d(2);
+    d << 1e-200, 1e-200;
+    DiagonalPlusLowRank<double> A(d, Mat::Identity(2, 2), Mat::Identity(2, 2));
+    const double det = A.determinant();
+    VERIFY(numext::abs(det - 1.0) <= 16.0 * eps);
+  }
+  {
+    // Mirrored, in exact powers of two: d = 2^60 and U = -(2^60 - 2^8) I with
+    // V = I represent diag(2^8), so det(A) = 2^176 exactly. Every intermediate
+    // is a power-of-two computation (the capacitance is exactly 2^-52 I by
+    // Sterbenz subtraction), yet det(D) = 2^1342-ish overflows and the plain
+    // capacitance pivot product 2^-1144 underflows.
+    const Index n = 22;
+    Vec d = Vec::Constant(n, std::ldexp(1.0, 60));
+    Mat U = (std::ldexp(1.0, 8) - std::ldexp(1.0, 60)) * Mat::Identity(n, n);
+    Mat V = Mat::Identity(n, n);
+    DiagonalPlusLowRank<double> A(d, U, V);
+    VERIFY_IS_EQUAL(A.determinant(), std::ldexp(1.0, 176));
+  }
+  {
+    // Complex analogue of the reproducer: the mantissa stays complex and is
+    // balanced on max(|re|, |im|). D + I I^H = diag(1 + 1e-200 i), det ~ 1.
+    Matrix<Complex, Dynamic, 1> d(2);
+    d << Complex(0, 1e-200), Complex(0, 1e-200);
+    DiagonalPlusLowRank<Complex> A(d, CMat::Identity(2, 2), CMat::Identity(2, 2));
+    VERIFY_IS_APPROX(A.determinant(), Complex(1, 0));
+  }
+  {
+    // Sign correctness through the capacitance path at extreme scales:
+    // D + (-I) I^H = diag(1e-200 - 1) ~ -I_3, det ~ -1; the balanced pivot
+    // product of the capacitance ~ -1e200 I_3 carries the sign.
+    Vec d = Vec::Constant(3, 1e-200);
+    DiagonalPlusLowRank<double> A(d, (-Mat::Identity(3, 3)).eval(), Mat::Identity(3, 3));
+    VERIFY_IS_APPROX(A.determinant(), -1.0);
+  }
+  {
+    // Sign correctness across mixed extreme diagonal scales (rank 0).
+    Vec d(4);
+    d << -1e200, 1e-200, 1e200, 1e-200;
+    DiagonalPlusLowRank<double> A(d, Mat::Zero(4, 0), Mat::Zero(4, 0));
+    VERIFY_IS_APPROX(A.determinant(), -1.0);
+  }
+  {
+    // Genuine overflow saturates to infinity of the correct sign...
+    Vec d(3);
+    d << -1e200, 1e200, 1e200;
+    DiagonalPlusLowRank<double> A(d, Mat::Zero(3, 0), Mat::Zero(3, 0));
+    const double det = A.determinant();
+    VERIFY((numext::isinf)(det) && det < 0.0);
+  }
+  {
+    // ... and genuine underflow to a zero of the correct sign.
+    Vec d(3);
+    d << -1e-200, 1e-200, 1e-200;
+    DiagonalPlusLowRank<double> A(d, Mat::Zero(3, 0), Mat::Zero(3, 0));
+    const double det = A.determinant();
+    VERIFY_IS_EQUAL(det, 0.0);
+    VERIFY(std::signbit(det));
+  }
+}
+
+// The capacitance triple product V^H D^{-1} U can overflow in its plain association while the
+// capacitance itself is representable: D^{-1} pairs the reciprocal of a tiny diagonal with a huge
+// factor before the other, tiny factor pulls the product back down. The Woodbury kernels form these
+// products from exactly rescaled factors so no spurious Inf/NaN reaches determinant(), solve() or
+// inverse().
+void test_dplr_capacitance_overflow() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  const double eps = NumTraits<double>::epsilon();
+
+  {
+    // The reviewer's case: D + UV^H = 1e-200 + 1e-200 * 1e200 ~ 1 and the
+    // capacitance 1 + 1e200 is representable, but V^H D^{-1} = 1e400 is not;
+    // determinant() used to return Inf and solve() NaN.
+    Vec d(1), u(1), v(1);
+    d << 1e-200;
+    u << 1e-200;
+    v << 1e200;
+    DiagonalPlusLowRank<double> A(d, u, v);
+    VERIFY((numext::isfinite)(A.capacitance()(0, 0)));
+    VERIFY_IS_APPROX(A.capacitance()(0, 0), 1e200);
+    VERIFY(numext::abs(A.determinant() - 1.0) <= 8.0 * eps);
+    // The Woodbury splitting routes this solve through D^{-1} b ~ 1e200 and
+    // cancels it back down to x ~ 1, so the amplified digits are lost to any
+    // association (see the solve() documentation); the fix is that the solve
+    // stays finite instead of turning into NaN through an infinite capacitance.
+    Vec b(1);
+    b << 1.0;
+    VERIFY(A.solve(b).allFinite());
+
+    // D^{-1} b is 1e400 here, though the operator is essentially the identity and the solution 1e200
+    // is representable; without the power-of-two rescaling the first term is Inf and the correction
+    // turns it into NaN, which is what this pins. It cannot pin finiteness: A ~ 1 makes the correction
+    // cancel D^{-1} b over ~200 digits, and whether that leaves 0 or an ulp the undone scaling lifts
+    // back to Inf is a codegen detail (x86-64 gives the first, aarch64 the second).
+    Vec big_b(1);
+    big_b << 1e200;
+    VERIFY(!A.solve(big_b).array().isNaN().any());
+  }
+  {
+    // The same overflow pattern in exact powers of two, where the Woodbury
+    // arithmetic is exact end to end: d = 2^-522, U = 2^-1025, V = 2^503
+    // represent A = [2^-521] exactly; V^H D^{-1} = 2^1025 still overflows, and
+    // the capacitance is exactly 2. Determinant and solve must match the dense
+    // results for the represented matrix exactly.
+    Vec d(1), u(1), v(1);
+    d << std::ldexp(1.0, -522);
+    u << std::ldexp(1.0, -1025);
+    v << std::ldexp(1.0, 503);
+    DiagonalPlusLowRank<double> A(d, u, v);
+    VERIFY_IS_EQUAL(A.capacitance()(0, 0), 2.0);
+    VERIFY_IS_EQUAL(A.determinant(), std::ldexp(1.0, -521));
+    Vec b(1);
+    b << 1.0;
+    VERIFY_IS_EQUAL(A.solve(b)(0), std::ldexp(1.0, 521));
+  }
+  {
+    // Symmetric mirror (U huge, V tiny): the plain capacitance association is
+    // safe here, but the inverse's D^{-1} U product overflows spuriously while
+    // the inverse factor -1e400 / (1 + 1e200) ~ -1e200 is representable.
+    Vec d(1), u(1), v(1);
+    d << 1e-200;
+    u << 1e200;
+    v << 1e-200;
+    DiagonalPlusLowRank<double> A(d, u, v);
+    VERIFY(numext::abs(A.determinant() - 1.0) <= 8.0 * eps);
+    DiagonalPlusLowRank<double> Ainv = A.inverse();
+    VERIFY(Ainv.factorU().allFinite());
+    VERIFY_IS_APPROX(Ainv.factorU()(0, 0), -1e200);
+    Vec b(1);
+    b << 1.0;
+    VERIFY(A.solve(b).allFinite());
+  }
+  {
+    // Exact-power-of-two mirror: d = 2^-522, U = 2^502, V = 2^-1025 represent
+    // A = [1.5 * 2^-522]; D^{-1} U = 2^1024 overflows, yet the inverse factor
+    // -2^1024 / 1.5 is representable and the solve is exact to rounding.
+    Vec d(1), u(1), v(1);
+    d << std::ldexp(1.0, -522);
+    u << std::ldexp(1.0, 502);
+    v << std::ldexp(1.0, -1025);
+    DiagonalPlusLowRank<double> A(d, u, v);
+    VERIFY_IS_EQUAL(A.capacitance()(0, 0), 1.5);
+    VERIFY_IS_EQUAL(A.determinant(), 1.5 * std::ldexp(1.0, -522));
+    DiagonalPlusLowRank<double> Ainv = A.inverse();
+    VERIFY_IS_APPROX(Ainv.factorU()(0, 0), -std::ldexp(1.0 / 1.5, 1024));
+    Vec b(1);
+    b << 3.0;
+    VERIFY_IS_EQUAL(A.solve(b)(0), std::ldexp(1.0, 523));
+  }
+  {
+    // Complex analogue of the reviewer's case: the operator is essentially
+    // [i], the capacitance 1 + 1e200 is representable, and the balancing and
+    // rescaling act on component magnitudes.
+    CVec d(1), u(1), v(1);
+    d << Complex(0, 1e-200);
+    u << Complex(1e-200, 0);
+    v << Complex(0, -1e200);
+    DiagonalPlusLowRank<Complex> A(d, u, v);
+    VERIFY((numext::isfinite)(numext::real(A.capacitance()(0, 0))));
+    VERIFY_IS_APPROX(A.capacitance()(0, 0), Complex(1e200, 0));
+    VERIFY_IS_APPROX(A.determinant(), Complex(0, 1));
+  }
+}
+
+// Moderate data must keep the plain product association: the normalized
+// Woodbury kernels only engage when a conservative exponent bound says a
+// product could overflow, so for well-scaled operators the capacitance and the
+// solve are bit-identical to the unnormalized evaluation.
+template <typename Scalar>
+void test_dplr_capacitance_fast_path(Index n, Index k) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec d;
+  Mat U, V;
+  random_dplr<Scalar>(n, k, d, U, V);
+  DiagonalPlusLowRank<Scalar> A(d, U, V);
+
+  // Match the stored reciprocal: scalar and packet complex division can round differently.
+  const Vec dinv = d.cwiseInverse();
+  Mat capRef = Mat::Identity(k, k);
+  capRef.noalias() += V.adjoint() * dinv.asDiagonal() * U;
+  VERIFY_IS_CWISE_EQUAL(A.capacitance(), capRef);
+
+  Vec b = Vec::Random(n);
+  PartialPivLU<Mat> capLU(capRef);
+  Vec xRef = dinv.asDiagonal() * b;
+  xRef.noalias() -= dinv.asDiagonal() * (U * capLU.solve(V.adjoint() * xRef));
+  VERIFY_IS_CWISE_EQUAL(A.solve(b), xRef);
+}
+
+// A fixed correction rank of zero is a compile-level regression: the operator
+// must instantiate -- the capacitance solve is compile-time dispatched away, so
+// PartialPivLU<Matrix<Scalar, 0, 0>> is never formed -- and behave as the plain
+// diagonal it is.
+template <typename Scalar, int N>
+void test_dplr_fixed_rank0() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, N, 1> VecN;
+  typedef Matrix<Scalar, N, 0> FacN0;
+  typedef Matrix<Scalar, N, N> MatN;
+
+  VecN d = VecN::Random();
+  d.array() += Scalar(RealScalar(3));
+  FacN0 U, V;
+  DiagonalPlusLowRank<Scalar, N, 0> A(d, U, V);
+  VERIFY_IS_EQUAL(A.correctionRank(), Index(0));
+
+  MatN dense = MatN::Zero();
+  dense.diagonal() = d;
+  MatN Ad = A;
+  VERIFY_IS_APPROX(Ad, dense);
+
+  VecN x = VecN::Random();
+  VecN y = A * x;
+  VERIFY_IS_APPROX(y, (d.asDiagonal() * x).eval());
+
+  VecN b = VecN::Random();
+  VecN xs = A.solve(b);
+  VERIFY_IS_APPROX(xs, (b.array() / d.array()).matrix().eval());
+
+  VERIFY_IS_APPROX(A.determinant(), d.prod());
+
+  DiagonalPlusLowRank<Scalar, N, 0> Ainv = A.inverse();
+  MatN invd = Ainv;
+  VERIFY_IS_APPROX((invd * dense).eval(), MatN(MatN::Identity()));
+
+  // Dynamic size with the rank still fixed at zero takes the same dispatch.
+  Matrix<Scalar, Dynamic, 1> dd = d;
+  Matrix<Scalar, Dynamic, 0> Ud(N, 0), Vd(N, 0);
+  DiagonalPlusLowRank<Scalar, Dynamic, 0> B(dd, Ud, Vd);
+  Matrix<Scalar, Dynamic, 1> yb = B * Matrix<Scalar, Dynamic, 1>(x);
+  VERIFY_IS_APPROX(yb, (d.asDiagonal() * x).eval());
+  VERIFY_IS_APPROX(B.solve(Matrix<Scalar, Dynamic, 1>(b)).eval(), (b.array() / d.array()).matrix().eval());
+  VERIFY_IS_APPROX(B.determinant(), d.prod());
+}
+
+template <typename Scalar, int N, int K>
+void test_dplr_fixed() {
+  typedef Matrix<Scalar, N, 1> VecN;
+  typedef Matrix<Scalar, N, K> FacNK;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  VecN d = VecN::Random();
+  d.array() += Scalar(RealScalar(3));
+  FacNK U = FacNK::Random(), V = FacNK::Random();
+  DiagonalPlusLowRank<Scalar, N, K> A(d, U, V);
+  STATIC_CHECK((DiagonalPlusLowRank<Scalar, N, K>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeDiagonalPlusLowRank(d, U, V))>::RowsAtCompileTime == N));
+
+  Mat dense = reference_dplr<Scalar>(Vec(d), Mat(U), Mat(V));
+  Matrix<Scalar, N, N> Adense = A;
+  VERIFY_IS_APPROX(Mat(Adense), dense);
+
+  VecN x = VecN::Random();
+  VecN y = A * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  VecN b = VecN::Random();
+  VecN xs = A.solve(b);
+  VERIFY_IS_APPROX((dense * xs).eval(), b);
+
+  // A dynamic right-hand side against the fixed-size operator: the compile-time
+  // product-dimension check must accept the Dynamic/fixed mix.
+  Vec xd = Vec(x);
+  Vec yd = A * xd;
+  VERIFY_IS_APPROX(yd, (dense * xd).eval());
+}
+
+EIGEN_DECLARE_TEST(structured_dplr) {
+  for (int i = 0; i < g_repeat; ++i) {
+    // Products, dense assignment, coefficient access; k = 0 is a plain diagonal
+    // and k = n a full-rank correction.
+    CALL_SUBTEST_1((test_dplr_product<double>(1, 0)));
+    CALL_SUBTEST_1((test_dplr_product<double>(10, 0)));
+    CALL_SUBTEST_1((test_dplr_product<double>(10, 1)));
+    CALL_SUBTEST_1((test_dplr_product<double>(20, 3)));
+    CALL_SUBTEST_1((test_dplr_product<double>(8, 8)));
+    CALL_SUBTEST_1((test_dplr_product<float>(12, 2)));
+    CALL_SUBTEST_1((test_dplr_product<std::complex<double>>(9, 2)));
+    CALL_SUBTEST_1((test_dplr_product<std::complex<float>>(7, 3)));
+    CALL_SUBTEST_1((test_dplr_transpose<double>(10, 2)));
+    CALL_SUBTEST_1((test_dplr_transpose<std::complex<double>>(8, 3)));
+
+    // Woodbury solves against the dense LU.
+    CALL_SUBTEST_2((test_dplr_solve<double>(1, 0)));
+    CALL_SUBTEST_2((test_dplr_solve<double>(10, 0)));
+    CALL_SUBTEST_2((test_dplr_solve<double>(10, 1)));
+    CALL_SUBTEST_2((test_dplr_solve<double>(30, 4)));
+    CALL_SUBTEST_2((test_dplr_solve<double>(8, 8)));
+    CALL_SUBTEST_2((test_dplr_solve<float>(12, 2)));
+    CALL_SUBTEST_2((test_dplr_solve<std::complex<double>>(14, 3)));
+    CALL_SUBTEST_2((test_dplr_solve<std::complex<float>>(8, 2)));
+
+    // Inverse closure, determinant lemma, matrix-free GMRES, fixed sizes.
+    CALL_SUBTEST_3((test_dplr_inverse_determinant<double>(10, 2)));
+    CALL_SUBTEST_3((test_dplr_inverse_determinant<double>(6, 0)));
+    CALL_SUBTEST_3((test_dplr_inverse_determinant<std::complex<double>>(8, 3)));
+    CALL_SUBTEST_3((test_dplr_matrix_free_gmres<double>(24, 3)));
+    CALL_SUBTEST_3((test_dplr_fixed<double, 6, 2>()));
+    CALL_SUBTEST_3((test_dplr_fixed<std::complex<float>, 5, 1>()));
+
+    // Review regressions: aliased and value-nested (owning) delayed products,
+    // mixed-scalar products, the balanced determinant accumulation, and the
+    // fixed rank-0 instantiation.
+    CALL_SUBTEST_4((test_dplr_aliased_product<double>(11, 3)));
+    CALL_SUBTEST_4((test_dplr_aliased_product<std::complex<double>>(9, 2)));
+    CALL_SUBTEST_4((test_dplr_delayed_product<double>(13, 2)));
+    CALL_SUBTEST_4((test_dplr_delayed_product<std::complex<double>>(10, 3)));
+    CALL_SUBTEST_4((test_dplr_mixed_scalar<double>(12, 3)));
+    CALL_SUBTEST_4((test_dplr_mixed_scalar<float>(9, 2)));
+    CALL_SUBTEST_4(test_dplr_determinant_scaled());
+    CALL_SUBTEST_4(test_dplr_determinant_capacitance());
+    CALL_SUBTEST_4(test_dplr_capacitance_overflow());
+    CALL_SUBTEST_4((test_dplr_capacitance_fast_path<double>(11, 3)));
+    CALL_SUBTEST_4((test_dplr_capacitance_fast_path<std::complex<double>>(9, 2)));
+    CALL_SUBTEST_4((test_dplr_fixed_rank0<double, 5>()));
+    CALL_SUBTEST_4((test_dplr_fixed_rank0<std::complex<float>, 4>()));
+  }
+}
diff --git a/contrib/test/structured_dpr1.cpp b/contrib/test/structured_dpr1.cpp
new file mode 100644
index 0000000..555b978
--- /dev/null
+++ b/contrib/test/structured_dpr1.cpp
@@ -0,0 +1,614 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+template <typename Scalar>
+EIGEN_DONT_INLINE Scalar dpr1_subnormal_input_probe() {
+  volatile Scalar denorm = (std::numeric_limits<Scalar>::denorm_min)();
+  volatile Scalar highest = (std::numeric_limits<Scalar>::max)();
+  return denorm * highest;
+}
+
+template <typename Scalar>
+bool dpr1_preserves_subnormal_inputs() {
+  return std::numeric_limits<Scalar>::has_denorm == std::denorm_present &&
+         dpr1_subnormal_input_probe<Scalar>() != Scalar(0);
+}
+
+template <typename Scalar>
+bool dpr1_has_gradual_underflow() {
+  return std::numeric_limits<Scalar>::has_denorm == std::denorm_present && underflowProbe<Scalar>() != Scalar(0);
+}
+
+// Full quality check of one decomposition: eigenvalues against a dense
+// reference, residual ||A*V - V*Lambda||, and -- the litmus test for the
+// Gu-Eisenstat machinery -- orthogonality ||V^T V - I||, all relative to
+// epsilon-scaled bounds.
+template <typename Scalar>
+void check_dpr1(const Matrix<Scalar, Dynamic, 1>& d, Scalar rho, const Matrix<Scalar, Dynamic, 1>& z) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  const Index n = d.size();
+  Mat dense = Mat(d.asDiagonal()) + rho * z * z.transpose();
+  // The natural backward-error scale of the secular formulation is the data
+  // scale ||D|| + |rho| ||z||^2 (as for LAPACK's merged D&C problems), which can
+  // exceed ||A|| when d + rho*z*z^T cancels; bounds are relative to it.
+  Scalar scale = d.cwiseAbs().maxCoeff() + numext::abs(rho) * z.squaredNorm();
+  if (scale == Scalar(0)) scale = Scalar(1);  // zero matrix: absolute bounds
+  const Scalar tol = Scalar(100) * Scalar(n) * NumTraits<Scalar>::epsilon();
+
+  DPR1EigenSolver<Scalar> es(d, rho, z);
+  VERIFY(es.info() == Success);
+  const Vec& lambda = es.eigenvalues();
+  const Mat& V = es.eigenvectors();
+
+  // Eigenvalues ascending and matching the dense reference to eps * scale.
+  for (Index i = 0; i + 1 < n; ++i) VERIFY(lambda[i] <= lambda[i + 1]);
+  SelfAdjointEigenSolver<Mat> ref(dense, EigenvaluesOnly);
+  VERIFY((lambda - ref.eigenvalues()).cwiseAbs().maxCoeff() <= tol * scale);
+
+  // Residual and orthogonality (the latter is scale-free and holds at O(n*eps)).
+  VERIFY((dense * V - V * lambda.asDiagonal()).norm() <= tol * scale * Scalar(numext::sqrt(Scalar(n))));
+  VERIFY((V.transpose() * V - Mat::Identity(n, n)).norm() <= tol);
+
+  // The eigenvalues-only path agrees exactly with the full path.
+  DPR1EigenSolver<Scalar> esv(d, rho, z, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(esv.eigenvalues(), lambda);
+}
+
+template <typename Scalar>
+void test_dpr1_random(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Vec d = Vec::Random(n), z = Vec::Random(n);
+  check_dpr1<Scalar>(d, Scalar(1), z);
+  check_dpr1<Scalar>(d, Scalar(-1), z);              // negative rho
+  check_dpr1<Scalar>(d, Scalar(1e-3), z);            // weak update
+  check_dpr1<Scalar>(d, Scalar(50) * Scalar(n), z);  // dominant update
+}
+
+// Tight clusters and exact duplicates in the diagonal force the Givens
+// deflation path (the secular equation requires strictly separated poles).
+template <typename Scalar>
+void test_dpr1_clustered(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Vec d(n), z = Vec::Random(n);
+  for (Index i = 0; i < n; ++i) {
+    const Index cluster = i / 3, offsetInCluster = i % 3;
+    d[i] = Scalar(1) + Scalar(cluster) + Scalar(1e-15) * Scalar(offsetInCluster);
+  }
+  check_dpr1<Scalar>(d, Scalar(2), z);
+
+  // All diagonal entries exactly equal: A = c*I + rho*z*z^T has closed-form
+  // spectrum {c, ..., c, c + rho*||z||^2}.
+  Vec dc = Vec::Constant(n, Scalar(3));
+  check_dpr1<Scalar>(dc, Scalar(1), z);
+  DPR1EigenSolver<Scalar> es(dc, Scalar(1), z);
+  VERIFY(numext::abs(es.eigenvalues()[n - 1] - (Scalar(3) + z.squaredNorm())) <=
+         Scalar(100) * Scalar(n) * NumTraits<Scalar>::epsilon() * (Scalar(3) + z.squaredNorm()));
+}
+
+// Zero and tiny z entries exercise the z-deflation path.
+template <typename Scalar>
+void test_dpr1_sparse_z(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Vec d = Vec::Random(n);
+  d.array() += Scalar(2);
+  Vec z = Vec::Zero(n);
+  z[1] = Scalar(0.7);
+  z[n / 2] = Scalar(-0.3);
+  z[n - 1] = Scalar(1e-30);  // far below the deflation threshold
+  check_dpr1<Scalar>(d, Scalar(1), z);
+
+  check_dpr1<Scalar>(d, Scalar(1), Vec(Vec::Zero(n)));    // pure diagonal
+  check_dpr1<Scalar>(d, Scalar(0), Vec(Vec::Random(n)));  // rho = 0
+}
+
+// Edge sizes and the classic textbook case.
+template <typename Scalar>
+void test_dpr1_edges() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+
+  Vec d1(1), z1(1);
+  d1 << Scalar(2);
+  z1 << Scalar(3);
+  DPR1EigenSolver<Scalar> es1(d1, Scalar(2), z1);
+  VERIFY(numext::abs(es1.eigenvalues()[0] - Scalar(20)) <= Scalar(100) * NumTraits<Scalar>::epsilon() * Scalar(20));
+
+  Vec d2(2), z2(2);
+  d2 << Scalar(1), Scalar(2);
+  z2 << Scalar(1), Scalar(1);
+  check_dpr1<Scalar>(d2, Scalar(1), z2);
+
+  // d_i = i, z = ones/sqrt(n): every interval holds exactly one root.
+  const Index n = 24;
+  Vec d(n), z(n);
+  for (Index i = 0; i < n; ++i) {
+    d[i] = Scalar(i);
+    z[i] = Scalar(1);
+  }
+  z /= z.norm();
+  check_dpr1<Scalar>(d, Scalar(1), z);
+  check_dpr1<Scalar>(d, Scalar(-1), z);
+}
+
+// Unsorted input: the solver must sort internally and undo the permutation.
+template <typename Scalar>
+void test_dpr1_unsorted(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Vec d = Vec::Random(n), z = Vec::Random(n);
+  d = d.reverse().eval();
+  check_dpr1<Scalar>(d, Scalar(1.5), z);
+}
+
+// Rank-one matrix (all-zero diagonal): spectrum {0,...,0, rho*||z||^2}.
+template <typename Scalar>
+void test_dpr1_rank_one(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Vec z = Vec::Random(n);
+  check_dpr1<Scalar>(Vec(Vec::Zero(n)), Scalar(2), z);
+}
+
+// Wide dynamic range in d and rho scaling.
+template <typename Scalar>
+void test_dpr1_scaling(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Vec d = Vec::Random(n), z = Vec::Random(n);
+  d = d.cwiseProduct(Vec::LinSpaced(n, Scalar(1e-8), Scalar(1e8)));
+  check_dpr1<Scalar>(d, Scalar(1e6), z);
+  check_dpr1<Scalar>(d, Scalar(-1e-6), z);
+}
+
+// The Gu-Eisenstat litmus test: poles close enough that naive eigenvectors lose
+// orthogonality, but far enough apart (well above the deflation threshold) that
+// the secular solver must handle them. Gaps span eps^1 to eps^(1/2) scales.
+template <typename Scalar>
+void test_dpr1_close_undeflated(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  Vec d(n), z(n);
+  Scalar gap = Scalar(100) * eps;
+  for (Index i = 0; i < n; ++i) {
+    d[i] = Scalar(1) + Scalar(i) * gap;
+    gap *= Scalar(4);  // gaps sweep 1e2*eps ... ~1e6*eps
+    if (gap > numext::sqrt(eps)) gap = Scalar(100) * eps;
+    z[i] = Scalar(0.3) + Scalar(0.5) * Scalar(i % 7) / Scalar(7);
+  }
+  check_dpr1<Scalar>(d, Scalar(1), z);
+  check_dpr1<Scalar>(d, Scalar(-1), z);
+}
+
+// stableNorm keeps huge z representable: with float z ~ 2e19, z.squaredNorm()
+// would overflow but rho*||z||^2 is a perfectly ordinary number.
+void test_dpr1_huge_z() {
+  typedef Matrix<float, Dynamic, 1> Vec;
+  Vec d(1), z(1);
+  d << 1.0f;
+  z << 2e19f;
+  DPR1EigenSolver<float> es(d, 1e-30f, z);
+  VERIFY(es.info() == Success);
+  // Form rho*z^2 = 4e8 one factor at a time: the literal 4e38 already overflows
+  // float (an infinite `expected` would make the bound below vacuous).
+  const float expected = 1.0f + (1e-30f * 2e19f) * 2e19f;
+  VERIFY((numext::isfinite)(expected));
+  // Loose bound: expected ~ 4e8 is dominated by the rank-one term, so only its
+  // leading digits survive in float.
+  const float tol = 1000.0f * NumTraits<float>::epsilon();  // ~1.2e-4
+  VERIFY(numext::abs(es.eigenvalues()[0] - expected) <= tol * expected);
+
+  // A spectrum that genuinely overflows (top eigenvalue ~1e320 here) must be
+  // reported, not silently deflated. Note rho*||z||^2 overflowing is *not* by
+  // itself invalid (see test_dpr1_overflowing_update_representable_spectrum);
+  // this input is rejected because the eigenvalue itself is not representable.
+  DPR1EigenSolver<double> ov((Matrix<double, Dynamic, 1>(1) << 1.0).finished(), 1e200,
+                             (Matrix<double, Dynamic, 1>(1) << 1e60).finished());
+  VERIFY(ov.info() == InvalidInput);
+}
+
+// Non-finite input must be rejected up front (it would otherwise break the
+// sorting comparator and silently deflate everything).
+void test_dpr1_nonfinite() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  Vec d = Vec::Random(6), z = Vec::Random(6);
+  Vec dn = d;
+  dn[2] = std::numeric_limits<double>::quiet_NaN();
+  DPR1EigenSolver<double> e1(dn, 1.0, z);
+  VERIFY(e1.info() == InvalidInput);
+  Vec zn = z;
+  zn[4] = std::numeric_limits<double>::infinity();
+  DPR1EigenSolver<double> e2(d, 1.0, zn);
+  VERIFY(e2.info() == InvalidInput);
+  DPR1EigenSolver<double> e3(d, std::numeric_limits<double>::quiet_NaN(), z);
+  VERIFY(e3.info() == InvalidInput);
+
+  const Vec empty;
+  DPR1EigenSolver<double> e4(empty, std::numeric_limits<double>::quiet_NaN(), empty);
+  VERIFY(e4.info() == InvalidInput);
+  DPR1EigenSolver<double> e5(empty, std::numeric_limits<double>::infinity(), empty);
+  VERIFY(e5.info() == InvalidInput);
+}
+
+void test_dpr1_invalid_options() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const Vec d = Vec::LinSpaced(3, 1.0, 3.0);
+  const Vec z = Vec::Ones(3);
+  DPR1EigenSolver<double> es;
+  VERIFY_RAISES_ASSERT((es.compute(d, 1.0, z, ComputeEigenvectors | EigenvaluesOnly)));
+  VERIFY_RAISES_ASSERT((es.compute(d, 1.0, z, ComputeFullU)));
+}
+
+// Regression (MR 2694 review): poles spanning the full exponent range with a huge but representable
+// update. Pole differences (d_1 - d_0 = 1.5*DBL_MAX) overflow unless the problem is rescaled by an
+// exact power of two; the solver used to report Success with an infinite eigenvalue. The reference is
+// a dense solve of the rescaled problem 2^-e * (d, rho), whose spectrum is exactly 2^-e times the
+// original.
+void test_dpr1_full_range_poles() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const double dmax = (std::numeric_limits<double>::max)();
+  Vec d(2), z(2);
+  d << -0.75 * dmax, 0.75 * dmax;
+  z << 1.0, 1.0;
+  const double rho = 1e300;
+  DPR1EigenSolver<double> es(d, rho, z);
+  VERIFY(es.info() == Success);
+  VERIFY(es.eigenvalues().allFinite());
+
+  const int e = 1024;  // 2^-e maps 0.75*DBL_MAX into [0.5, 1)
+  Vec dS(2);
+  dS << std::ldexp(d[0], -e), std::ldexp(d[1], -e);
+  const double rhoS = std::ldexp(rho, -e);
+  Mat dense = Mat(dS.asDiagonal()) + rhoS * z * z.transpose();
+  SelfAdjointEigenSolver<Mat> ref(dense, EigenvaluesOnly);
+  const double scaleS = dS.cwiseAbs().maxCoeff() + rhoS * z.squaredNorm();
+  const double tol = 100.0 * NumTraits<double>::epsilon();
+  Vec lambdaS(2);
+  lambdaS << std::ldexp(es.eigenvalues()[0], -e), std::ldexp(es.eigenvalues()[1], -e);
+  VERIFY((lambdaS - ref.eigenvalues()).cwiseAbs().maxCoeff() <= tol * scaleS);
+  // Eigenvectors are scale-invariant: check them on the rescaled matrix.
+  const Mat& V = es.eigenvectors();
+  VERIFY((dense * V - V * lambdaS.asDiagonal()).norm() <= tol * scaleS);
+  VERIFY((V.transpose() * V - Mat::Identity(2, 2)).norm() <= tol);
+}
+
+// Regression (MR 2694 review): z entries at the top of the range make ||z||
+// itself overflow, but the update rho*z*z^T (rank-one eigenvalue ~6.46e306) is
+// perfectly representable; the solver used to return InvalidInput. It must
+// instead normalize z by an exact power of two, 2^-p z with rho 2^(2p), which
+// leaves the matrix identical -- the same rewrite gives the dense reference.
+void test_dpr1_huge_z_norm() {
+  if (!dpr1_preserves_subnormal_inputs<double>()) return;
+
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const double dmax = (std::numeric_limits<double>::max)();
+  Vec d(2), z(2);
+  d << 0.0, 0.0;
+  z << dmax, dmax;
+  const double rho = 1e-310;  // subnormal, so rho * 2^(2p) stays finite
+  DPR1EigenSolver<double> es(d, rho, z);
+  VERIFY(es.info() == Success);
+
+  const int p = 1024;  // 2^-p maps DBL_MAX into [0.5, 1)
+  Vec zS(2);
+  zS << std::ldexp(z[0], -p), std::ldexp(z[1], -p);
+  const double rhoS = std::ldexp(rho, 2 * p);  // exact: subnormal scaled up
+  Mat dense = Mat(d.asDiagonal()) + rhoS * zS * zS.transpose();
+  SelfAdjointEigenSolver<Mat> ref(dense, EigenvaluesOnly);
+  const double scale = rhoS * zS.squaredNorm();  // the rank-one eigenvalue, ~6.46e306
+  const double tol = 100.0 * NumTraits<double>::epsilon();
+  VERIFY((es.eigenvalues() - ref.eigenvalues()).cwiseAbs().maxCoeff() <= tol * scale);
+  VERIFY(numext::abs(es.eigenvalues()[1] - scale) <= tol * scale);
+}
+
+// Regression (MR 2694 review): a z entry just above the deflation threshold
+// puts the secular root ~rho*z_0^2 ~ 6.3e-30 from its pole; bisecting the O(1)
+// bracket down to it takes ~150 halvings, beyond the old 2*digits+32 iteration
+// cap, and used to report NoConvergence (check_dpr1 requires Success).
+void test_dpr1_near_deflation_root() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  Vec d(2), z(2);
+  d << 0.0, 1.0;
+  z << 16.0 * NumTraits<double>::epsilon(), 1.0;
+  check_dpr1<double>(d, 1.0, z);
+}
+
+// Regression (MR 2694 review): finite 1x1 input whose only eigenvalue
+// d + rho*z^2 = 2*DBL_MAX overflows. The documented contract for a spectrum
+// that is not representable is InvalidInput, not Success carrying infinity.
+void test_dpr1_overflowing_spectrum() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const double dmax = (std::numeric_limits<double>::max)();
+  Vec d(1), z(1);
+  d << dmax;
+  z << 1.0;
+  DPR1EigenSolver<double> es(d, dmax, z);
+  VERIFY(es.info() == InvalidInput);
+  VERIFY((numext::isnan)(es.eigenvalues()[0]));
+  // Same with the overflow amplified through z (eigenvalue = 5*DBL_MAX): the
+  // internal rescaling saturates the unrepresentable eigenvalue to infinity,
+  // which the contract maps to InvalidInput + NaN rather than Success + inf.
+  z << 2.0;
+  DPR1EigenSolver<double> es2(d, dmax, z);
+  VERIFY(es2.info() == InvalidInput);
+  VERIFY((numext::isnan)(es2.eigenvalues()[0]));
+}
+
+// Regression (MR 2694 review): the normalized secular problem can round a root across the
+// maximum-finite boundary before it is scaled back, so that root's finiteness cannot classify the
+// exact spectrum. The first update has lambda = DBL_MAX - 19/256 ulp, which rounds to DBL_MAX; the
+// second has lambda = DBL_MAX + 3739/2048 ulp and genuinely overflows. Constants are assembled from
+// their exact significands, hexadecimal float literals not being in the C++14 baseline.
+void test_dpr1_maximum_range_rounding() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const double dmax = (std::numeric_limits<double>::max)();
+  Vec d(1), z(1);
+
+  d << -dmax;
+  z << 31.0 / 8.0;
+  const double rhoRepresentable = std::ldexp(4798840810018093.0, 969);
+  DPR1EigenSolver<double> representable(d, rhoRepresentable, z);
+  VERIFY(representable.info() == Success);
+  VERIFY_IS_EQUAL(representable.eigenvalues()[0], dmax);
+
+  d << dmax;
+  DPR1EigenSolver<double> representableNegative(d, -rhoRepresentable, z);
+  VERIFY(representableNegative.info() == Success);
+  VERIFY_IS_EQUAL(representableNegative.eigenvalues()[0], -dmax);
+
+  d << -dmax;
+  z << 65.0 / 2.0;
+  const double rhoOverflow = std::ldexp(8732186543767835.0, 962);
+  DPR1EigenSolver<double> overflow(d, rhoOverflow, z);
+  VERIFY(overflow.info() == InvalidInput);
+  VERIFY((numext::isnan)(overflow.eigenvalues()[0]));
+
+  d << dmax;
+  DPR1EigenSolver<double> overflowNegative(d, -rhoOverflow, z);
+  VERIFY(overflowNegative.info() == InvalidInput);
+  VERIFY((numext::isnan)(overflowNegative.eigenvalues()[0]));
+}
+
+// Multiple exactly representable endpoint terms must be certifiable together:
+// rho*z_i^2/(max-d_i) = 1/2 for each i, so the spectrum is exactly {0, max}.
+template <typename Scalar>
+void test_dpr1_exact_endpoint_sum() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  using std::nextafter;
+  const Scalar highest = (std::numeric_limits<Scalar>::max)();
+  const Scalar boundaryRho = highest / Scalar(2);
+  const Vec d = Vec::Zero(2);
+  const Vec z = Vec::Ones(2);
+
+  DPR1EigenSolver<Scalar> positive(d, boundaryRho, z);
+  VERIFY(positive.info() == Success);
+  VERIFY_IS_EQUAL(positive.eigenvalues()[0], Scalar(0));
+  VERIFY_IS_EQUAL(positive.eigenvalues()[1], highest);
+
+  DPR1EigenSolver<Scalar> negative(d, -boundaryRho, z);
+  VERIFY(negative.info() == Success);
+  VERIFY_IS_EQUAL(negative.eigenvalues()[0], -highest);
+  VERIFY_IS_EQUAL(negative.eigenvalues()[1], Scalar(0));
+
+  const Vec d4 = Vec::Zero(4);
+  const Vec z4 = Vec::Ones(4);
+  DPR1EigenSolver<Scalar> fourTerms(d4, highest / Scalar(4), z4);
+  VERIFY(fourTerms.info() == Success);
+  VERIFY_IS_EQUAL(fourTerms.eigenvalues()[3], highest);
+
+  DPR1EigenSolver<Scalar> below(d, nextafter(boundaryRho, Scalar(0)), z);
+  VERIFY(below.info() == Success);
+  VERIFY(below.eigenvalues().allFinite());
+
+  DPR1EigenSolver<Scalar> above(d, nextafter(boundaryRho, highest), z);
+  VERIFY(above.info() == InvalidInput);
+
+  // The exact top eigenvalue is highest + min. Normalizing the endpoint
+  // denominator drops that tiny difference, so this case must remain
+  // conservatively unresolved instead of reusing the exact-equality path.
+  const Vec minDiagonal = Vec::Constant(2, (std::numeric_limits<Scalar>::min)());
+  DPR1EigenSolver<Scalar> unresolved(minDiagonal, boundaryRho, z);
+  VERIFY(unresolved.info() != Success);
+}
+
+// Regression (MR 2694 review): rho*||z||^2 = 2*max overflows, but the single eigenvalue
+// d + rho*z^2 = -max + 2*max = max is representable. The rescaling must come from component exponents
+// alone, never materializing rho*||z||^2 at full scale. The secular root sits exactly on the far end
+// of its bisection bracket, so the computed eigenvalue lands within a couple of ulps of max rather
+// than exactly at it.
+template <typename Scalar>
+void test_dpr1_overflowing_update_representable_spectrum() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  const Scalar dmax = (std::numeric_limits<Scalar>::max)();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  Vec d(1), z(1);
+  d << -dmax;
+  z << Scalar(2);
+  DPR1EigenSolver<Scalar> es(d, dmax / Scalar(2), z);
+  VERIFY(es.info() == Success);
+  const Scalar lam = es.eigenvalues()[0];
+  VERIFY((numext::isfinite)(lam));
+  VERIFY(numext::abs(lam - dmax) <= Scalar(4) * eps * dmax);
+  // n = 1: the eigenvector is the coordinate axis, exactly (up to sign).
+  VERIFY(numext::abs(es.eigenvectors()(0, 0)) == Scalar(1));
+}
+
+// Regression (MR 2694 review), n > 1 version: poles near -0.75*DBL_MAX with
+// rho*||z||^2 ~ 1.2*DBL_MAX (overflowing if materialized) but every eigenvalue
+// representable -- the top root lands near +0.4*DBL_MAX, the rest interlace
+// the poles. Verified against a dense solve of the exactly rescaled problem,
+// whose spectrum is exactly 2^-e times the original.
+void test_dpr1_huge_representable_spectrum() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const Index n = 8;
+  const double dmax = (std::numeric_limits<double>::max)();
+  Vec d(n), z(n);
+  for (Index i = 0; i < n; ++i) {
+    d[i] = -dmax * (0.70 + 0.01 * double(i));
+    z[i] = 1.0 + double(i) / 8.0;  // ||z||^2 ~ 18.6
+  }
+  const double rho = dmax / 16;
+  DPR1EigenSolver<double> es(d, rho, z);
+  VERIFY(es.info() == Success);
+  VERIFY(es.eigenvalues().allFinite());
+
+  const int e = 1025;  // 2^-e maps every |d_i| and rho*||z||^2 below 1
+  Vec dS(n), lambdaS(n);
+  for (Index i = 0; i < n; ++i) {
+    dS[i] = std::ldexp(d[i], -e);
+    lambdaS[i] = std::ldexp(es.eigenvalues()[i], -e);
+  }
+  const double rhoS = std::ldexp(rho, -e);
+  Mat dense = Mat(dS.asDiagonal()) + rhoS * z * z.transpose();
+  SelfAdjointEigenSolver<Mat> ref(dense, EigenvaluesOnly);
+  const double scaleS = dS.cwiseAbs().maxCoeff() + rhoS * z.squaredNorm();
+  const double tol = 100.0 * double(n) * NumTraits<double>::epsilon();
+  VERIFY((lambdaS - ref.eigenvalues()).cwiseAbs().maxCoeff() <= tol * scaleS);
+  // Eigenvectors are scale-invariant: check them on the rescaled matrix.
+  const Mat& V = es.eigenvectors();
+  VERIFY((dense * V - V * lambdaS.asDiagonal()).norm() <= tol * scaleS * numext::sqrt(double(n)));
+  VERIFY((V.transpose() * V - Mat::Identity(n, n)).norm() <= tol);
+}
+
+// Mirror case at the bottom of the range: d and rho near DBL_MIN. The same
+// exact power-of-two machinery scales *up* (scaleExp < 0), which needs no
+// separate underflow handling -- scaling up from anywhere at or above the
+// normal range is exact, and the eigenvalues here are all normal. Verified
+// against a dense solve of the exactly upscaled problem.
+void test_dpr1_tiny_scale() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const Index n = 8;
+  const double dmin = (std::numeric_limits<double>::min)();
+  Vec d(n), z(n);
+  for (Index i = 0; i < n; ++i) {
+    d[i] = dmin * double(1 + i);
+    z[i] = 1.0 + double(i) / 8.0;
+  }
+  const double rho = 3 * dmin;
+  DPR1EigenSolver<double> es(d, rho, z);
+  VERIFY(es.info() == Success);
+
+  const int e = -1020;  // upscale by 2^1020: exact, brings the data to O(1)
+  Vec dS(n), lambdaS(n);
+  for (Index i = 0; i < n; ++i) {
+    dS[i] = std::ldexp(d[i], -e);
+    lambdaS[i] = std::ldexp(es.eigenvalues()[i], -e);  // exact: all normal
+  }
+  const double rhoS = std::ldexp(rho, -e);
+  Mat dense = Mat(dS.asDiagonal()) + rhoS * z * z.transpose();
+  SelfAdjointEigenSolver<Mat> ref(dense, EigenvaluesOnly);
+  const double scaleS = dS.cwiseAbs().maxCoeff() + rhoS * z.squaredNorm();
+  const double tol = 100.0 * double(n) * NumTraits<double>::epsilon();
+  VERIFY((lambdaS - ref.eigenvalues()).cwiseAbs().maxCoeff() <= tol * scaleS);
+  VERIFY((dense * es.eigenvectors() - es.eigenvectors() * lambdaS.asDiagonal()).norm() <=
+         tol * scaleS * numext::sqrt(double(n)));
+
+  if (dpr1_preserves_subnormal_inputs<double>() && dpr1_has_gradual_underflow<double>()) {
+    // Deep-subnormal rank-one update: spectrum {0 x7, rho*||z||^2 = 2^-1065}.
+    // The result is rounded onto the subnormal grid on the way back down, so the
+    // bound is a few subnormal ulps (denorm_min), not a relative one.
+    const double dn = (std::numeric_limits<double>::denorm_min)();
+    Vec z1 = Vec::Ones(n);
+    const double rho1 = 64 * dn;
+    DPR1EigenSolver<double> sub(Vec(Vec::Zero(n)), rho1, z1);
+    VERIFY(sub.info() == Success);
+    VERIFY(numext::abs(sub.eigenvalues()[n - 1] - double(n) * rho1) <= 8 * dn);
+    VERIFY(sub.eigenvalues().head(n - 1).cwiseAbs().maxCoeff() == 0.0);
+  }
+}
+
+void test_dpr1_ftz_mode() {
+  const double underflowBefore = underflowProbe<double>();
+  bool flushToZeroSupported = false;
+  {
+    ScopedFlushToZero flushToZero;
+    flushToZeroSupported = flushToZero.isSupported();
+    if (flushToZeroSupported) {
+      VERIFY_IS_EQUAL(underflowProbe<double>(), 0.0);
+      test_dpr1_edges<double>();
+    }
+  }
+  if (flushToZeroSupported) VERIFY_IS_EQUAL(underflowProbe<double>(), underflowBefore);
+}
+
+// A huge diagonal spread makes every z entry individually negligible even though
+// rho itself is not: the whole update deflates and m == 0.
+void test_dpr1_all_deflated() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  Vec d(4), z(4);
+  d << 0.0, 1e17, 2e17, 3e17;
+  z << 0.5, 0.5, 0.5, 0.5;
+  check_dpr1<double>(d, 1.0, z);
+}
+
+EIGEN_DECLARE_TEST(structured_dpr1) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1((test_dpr1_random<double>(1)));
+    CALL_SUBTEST_1((test_dpr1_random<double>(2)));
+    CALL_SUBTEST_1((test_dpr1_random<double>(3)));
+    CALL_SUBTEST_1((test_dpr1_random<double>(10)));
+    CALL_SUBTEST_1((test_dpr1_random<double>(33)));
+    CALL_SUBTEST_1((test_dpr1_random<double>(64)));
+    CALL_SUBTEST_1((test_dpr1_random<float>(12)));
+    CALL_SUBTEST_1((test_dpr1_random<float>(40)));
+    CALL_SUBTEST_1((test_dpr1_random<long double>(12)));
+
+    CALL_SUBTEST_2((test_dpr1_clustered<double>(12)));
+    CALL_SUBTEST_2((test_dpr1_clustered<double>(30)));
+    CALL_SUBTEST_2((test_dpr1_clustered<float>(15)));
+    CALL_SUBTEST_2((test_dpr1_sparse_z<double>(16)));
+    CALL_SUBTEST_2((test_dpr1_sparse_z<float>(9)));
+    CALL_SUBTEST_2((test_dpr1_rank_one<double>(20)));
+    CALL_SUBTEST_2((test_dpr1_rank_one<float>(11)));
+    CALL_SUBTEST_2((test_dpr1_clustered<long double>(12)));
+    CALL_SUBTEST_2((test_dpr1_sparse_z<long double>(9)));
+
+    CALL_SUBTEST_3((test_dpr1_edges<double>()));
+    CALL_SUBTEST_3((test_dpr1_edges<float>()));
+    CALL_SUBTEST_3((test_dpr1_unsorted<double>(17)));
+    CALL_SUBTEST_3((test_dpr1_scaling<double>(14)));
+    CALL_SUBTEST_3((test_dpr1_edges<long double>()));
+    CALL_SUBTEST_3((test_dpr1_scaling<long double>(14)));
+    CALL_SUBTEST_3(test_dpr1_invalid_options());
+
+    // Gu-Eisenstat litmus (close but undeflated poles), orthogonality growth at
+    // larger n, extreme scales, non-finite rejection, full-deflation pin.
+    CALL_SUBTEST_4((test_dpr1_close_undeflated<double>(24)));
+    CALL_SUBTEST_4((test_dpr1_close_undeflated<float>(16)));
+    CALL_SUBTEST_4((test_dpr1_random<double>(128)));
+    CALL_SUBTEST_4((test_dpr1_close_undeflated<long double>(16)));
+    CALL_SUBTEST_4(test_dpr1_huge_z());
+    CALL_SUBTEST_4(test_dpr1_nonfinite());
+    CALL_SUBTEST_4(test_dpr1_all_deflated());
+
+    // MR 2694 review regressions: exponent-range extremes and deep bisection.
+    CALL_SUBTEST_5(test_dpr1_full_range_poles());
+    CALL_SUBTEST_5(test_dpr1_huge_z_norm());
+    CALL_SUBTEST_5(test_dpr1_near_deflation_root());
+    CALL_SUBTEST_5(test_dpr1_overflowing_spectrum());
+    CALL_SUBTEST_5(test_dpr1_maximum_range_rounding());
+    CALL_SUBTEST_5((test_dpr1_exact_endpoint_sum<float>()));
+    CALL_SUBTEST_5((test_dpr1_exact_endpoint_sum<double>()));
+    CALL_SUBTEST_5((test_dpr1_exact_endpoint_sum<long double>()));
+    CALL_SUBTEST_5((test_dpr1_overflowing_update_representable_spectrum<double>()));
+    CALL_SUBTEST_5((test_dpr1_overflowing_update_representable_spectrum<float>()));
+    CALL_SUBTEST_5((test_dpr1_overflowing_update_representable_spectrum<long double>()));
+    CALL_SUBTEST_5(test_dpr1_huge_representable_spectrum());
+    CALL_SUBTEST_5(test_dpr1_tiny_scale());
+    CALL_SUBTEST_5(test_dpr1_ftz_mode());
+  }
+}
diff --git a/contrib/test/structured_kronecker.cpp b/contrib/test/structured_kronecker.cpp
new file mode 100644
index 0000000..4b2b77c
--- /dev/null
+++ b/contrib/test/structured_kronecker.cpp
@@ -0,0 +1,1954 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Reference dense Kronecker product, built entry-wise and independently of both
+// the operator under test and the KroneckerProduct module.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_kron(const Matrix<Scalar, Dynamic, Dynamic>& A,
+                                                const Matrix<Scalar, Dynamic, Dynamic>& B) {
+  Matrix<Scalar, Dynamic, Dynamic> K(A.rows() * B.rows(), A.cols() * B.cols());
+  for (Index i = 0; i < K.rows(); ++i)
+    for (Index j = 0; j < K.cols(); ++j) K(i, j) = A(i / B.rows(), j / B.cols()) * B(i % B.rows(), j % B.cols());
+  return K;
+}
+
+template <typename Scalar>
+void test_kron_product(Index m1, Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat A = Mat::Random(m1, n1), B = Mat::Random(m2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+  VERIFY_IS_EQUAL(K.rows(), m1 * m2);
+  VERIFY_IS_EQUAL(K.cols(), n1 * n2);
+
+  // Dense assignment through the evaluator and coefficient access.
+  Mat Kd = K;
+  VERIFY_IS_APPROX(Kd, dense);
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, K.rows() - 1), j = internal::random<Index>(0, K.cols() - 1);
+    VERIFY_IS_APPROX(K.coeff(i, j), dense(i, j));
+  }
+
+  // Fast matrix-vector and matrix-matrix products via the vec identity.
+  Vec x = Vec::Random(n1 * n2);
+  VERIFY_IS_APPROX((K * x).eval(), (dense * x).eval());
+  Mat X = Mat::Random(n1 * n2, 3);
+  VERIFY_IS_APPROX((K * X).eval(), (dense * X).eval());
+
+  // A matrix product on the right must be materialized once before addProduct()
+  // takes column expressions from it. Keep the outer expression alive past the
+  // full expression that created the nested product as a lifetime check too.
+  Mat P = Mat::Random(n1 * n2, 4), Q = Mat::Random(4, 3);
+  auto nestedProduct = K * (P * Q);
+  Mat nestedResult = nestedProduct;
+  VERIFY_IS_APPROX(nestedResult, (dense * (P * Q)).eval());
+
+  // Accumulation form exercised by the iterative solvers.
+  Vec y = Vec::Random(m1 * m2);
+  Vec y0 = y;
+  y.noalias() += K * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+}
+
+template <typename Scalar>
+void test_kron_transpose(Index m1, Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat A = Mat::Random(m1, n1), B = Mat::Random(m2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Mat Td = K.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = K.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Cd = K.conjugate();
+  VERIFY_IS_APPROX(Cd, Mat(dense.conjugate()));
+
+  Vec y = Vec::Random(m1 * m2);
+  VERIFY_IS_APPROX((K.transpose() * y).eval(), (dense.transpose() * y).eval());
+  VERIFY_IS_APPROX((K.adjoint() * y).eval(), (dense.adjoint() * y).eval());
+}
+
+// The products carry the default product tag, so plain assignment materializes a
+// temporary exactly like a dense product would. That must resolve every aliasing
+// form between the destination and the right-hand side: the same object, an
+// expression referencing the destination, and overlapping views -- cases the old
+// AliasFreeProduct same-object check could not see.
+template <typename Scalar>
+void test_kron_aliased_product(Index n1, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Square factors so that the destination and the right-hand side can alias.
+  Mat A = Mat::Random(n1, n1), B = Mat::Random(n2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Vec x = Vec::Random(n1 * n2);
+  Vec y = x;
+  y = K * y;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  y = x;
+  y += K * y;
+  VERIFY_IS_APPROX(y, (x + dense * x).eval());
+
+  y = x;
+  y -= K * y;
+  VERIFY_IS_APPROX(y, (x - dense * x).eval());
+
+  Mat X = Mat::Random(n1 * n2, 3);
+  Mat Y = X;
+  Y = K * Y;
+  VERIFY_IS_APPROX(Y, (dense * X).eval());
+
+  // Right-hand-side expression referencing the destination.
+  y = x;
+  y = K * (y + Vec::Ones(n1 * n2));
+  VERIFY_IS_APPROX(y, (dense * (x + Vec::Ones(n1 * n2))).eval());
+
+  // Overlapping views: the destination shares all but one entry with the
+  // right-hand side.
+  Vec buf = Vec::Random(n1 * n2 + 1);
+  const Vec expected = dense * buf.tail(n1 * n2);
+  buf.head(n1 * n2) = K * buf.tail(n1 * n2);
+  VERIFY_IS_APPROX(buf.head(n1 * n2).eval(), expected);
+}
+
+// Rectangular operators resize an aliased destination: x = K * x must evaluate
+// into a temporary before x is resized from cols() to rows() entries.
+template <typename Scalar>
+void test_kron_aliased_resize(Index m1, Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat A = Mat::Random(m1, n1), B = Mat::Random(m2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Vec x = Vec::Random(n1 * n2);
+  const Vec xref = x;
+  x = K * x;
+  VERIFY_IS_EQUAL(x.size(), m1 * m2);
+  VERIFY_IS_APPROX(x, (dense * xref).eval());
+
+  Mat X = Mat::Random(n1 * n2, 2);
+  const Mat Xref = X;
+  X = K * X;
+  VERIFY_IS_EQUAL(X.rows(), m1 * m2);
+  VERIFY_IS_APPROX(X, (dense * Xref).eval());
+}
+
+// transpose()/conjugate()/adjoint() and makeKroneckerOperator() return owning
+// temporaries, so the product expression must nest the structured operand by
+// value: a delayed-evaluated expression has to outlive the temporary operator it
+// was built from. The static check pins the value nesting; the behavioral check
+// would read freed memory if the product held a reference instead.
+template <typename Scalar>
+void test_kron_delayed_product(Index m1, Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK((!std::is_reference<typename internal::ref_selector<KroneckerOperator<Mat, Mat>>::type>::value));
+
+  Mat A = Mat::Random(m1, n1), B = Mat::Random(m2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Vec y = Vec::Random(m1 * m2);
+  auto expr = K.adjoint() * y;                          // the adjoint temporary dies with the full expression
+  Vec scribble = Vec::Random(2 * (m1 * m2 + n1 * n2));  // reuses the temporary's freed heap storage
+  Vec x = expr;
+  VERIFY_IS_APPROX(x, (dense.adjoint() * y).eval());
+  VERIFY_IS_EQUAL(scribble.size(), 2 * (m1 * m2 + n1 * n2));  // keep the scribble alive across the evaluation
+
+  Vec xin = Vec::Random(n1 * n2);
+  auto expr2 = makeKroneckerOperator(Mat(A), Mat(B)) * xin;  // factory temporary
+  Vec scribble2 = Vec::Random(m1 * m2 + n1 * n2);
+  Vec y2 = expr2;
+  VERIFY_IS_APPROX(y2, (dense * xin).eval());
+  VERIFY_IS_EQUAL(scribble2.size(), m1 * m2 + n1 * n2);
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex product
+// scalar, so alpha, the vec-trick workspaces and the accumulation must run in the
+// promoted type rather than the operator scalar.
+template <typename RealScalar>
+void test_kron_mixed_scalar(Index m1, Index n1, Index m2, Index n2) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> RMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RMat A = RMat::Random(m1, n1), B = RMat::Random(m2, n2);
+  KroneckerOperator<RMat, RMat> K(A, B);
+  CMat dense = reference_kron<RealScalar>(A, B).template cast<Complex>();
+
+  CVec x = CVec::Random(n1 * n2);
+  CVec y = K * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  CVec y0 = CVec::Random(m1 * m2);
+  y = y0;
+  y.noalias() += K * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+
+  CMat Ac = CMat::Random(m1, n1), Bc = CMat::Random(m2, n2);
+  KroneckerOperator<CMat, CMat> Kc(Ac, Bc);
+  CMat denseC = reference_kron<Complex>(Ac, Bc);
+  RVec xr = RVec::Random(n1 * n2);
+  CVec z = Kc * xr;
+  VERIFY_IS_APPROX(z, (denseC * xr).eval());
+}
+
+template <typename Scalar>
+void test_kron_solve(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Diagonal boosts keep both factors (hence the product) well conditioned.
+  Mat A = Mat::Random(n1, n1) + RealScalar(2 * n1) * Mat::Identity(n1, n1);
+  Mat B = Mat::Random(n2, n2) + RealScalar(2 * n2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Vec b = Vec::Random(n1 * n2);
+  Vec x = K.solve(b);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+  VERIFY_IS_APPROX(x, dense.partialPivLu().solve(b).eval());
+
+  Mat Bm = Mat::Random(n1 * n2, 3);
+  Mat Xm = K.solve(Bm);
+  VERIFY_IS_APPROX(Xm, dense.partialPivLu().solve(Bm).eval());
+}
+
+template <typename Scalar>
+void test_kron_least_squares(Index m1, Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat A = Mat::Random(m1, n1), B = Mat::Random(m2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  // The minimum-norm least-squares solution is unique, so the factored
+  // pseudo-inverse must match the dense complete orthogonal decomposition.
+  Mat b = Mat::Random(m1 * m2, 3);
+  Mat x = K.leastSquaresSolve(b);
+  VERIFY_IS_APPROX(x, dense.completeOrthogonalDecomposition().solve(b).eval());
+}
+
+template <typename Scalar>
+void test_kron_least_squares_rank_deficient(Index m1, Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // A rank-one left factor and a rank-two right factor make the product rank
+  // deficient; the minimum-norm least-squares solution stays unique and
+  // comparable against the dense complete orthogonal decomposition.
+  Mat A = Vec::Random(m1) * Vec::Random(n1).transpose();
+  Mat B = Vec::Random(m2) * Vec::Random(n2).transpose() + Vec::Random(m2) * Vec::Random(n2).transpose();
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+  VERIFY_IS_EQUAL(K.rank(), dense.completeOrthogonalDecomposition().rank());
+
+  Mat b = Mat::Random(m1 * m2, 3);
+  Mat x = K.leastSquaresSolve(b);
+  VERIFY_IS_APPROX(x, dense.completeOrthogonalDecomposition().solve(b).eval());
+}
+
+// Near-rank-deficiency must be judged at the product level: with
+// A = B = diag(1, 1e-8) each factor is full rank against its own threshold, but
+// the smallest singular value of the product, 1e-16, falls below the
+// product-level threshold min(rows,cols) * eps * sigma_max(A) * sigma_max(B).
+// The rank is 3 -- matching the dense complete orthogonal decomposition -- and
+// leastSquaresSolve() must truncate the 1e-16 mode instead of inverting it.
+void test_kron_product_level_rank() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  const double small = 1e-8;  // sqrt(eps)-ish: kept per factor, truncated as a pairwise product
+  Mat A(2, 2);
+  A << 1, 0, 0, small;
+  Mat B = A;
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<double>(A, B);
+
+  CompleteOrthogonalDecomposition<Mat> cod(dense);
+  VERIFY_IS_EQUAL(cod.rank(), 3);
+  VERIFY_IS_EQUAL(K.rank(), cod.rank());
+
+  Vec b = Vec::Random(4);
+  Vec x = K.leastSquaresSolve(b);
+  VERIFY_IS_APPROX(x, cod.solve(b).eval());
+  // Direct encoding of "the 1e-16 mode is not inverted": the solution is bounded
+  // by the reciprocal of the smallest kept singular value (with slack), far below
+  // the 1e16 blow-up an inverted product mode would produce.
+  const double invertedModeBound = double(10) / small;  // smallest kept product singular value is `small`
+  VERIFY(x.norm() <= invertedModeBound * b.norm());
+}
+
+// det(A (x) B) = det(A)^n2 * det(B)^n1 must be accumulated with exponent
+// balancing: det(A)^n2 or det(B)^n1 can overflow or underflow on their own even
+// when the result is representable.
+void test_kron_determinant_scaling() {
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  // Reviewer repro: det(A)^2 = 1e400 overflows on its own, yet the determinant
+  // of K = diag(1e100, 1e100) is 1e200.
+  Mat A(1, 1);
+  A << 1e200;
+  Mat B = Mat::Zero(2, 2);
+  B(0, 0) = B(1, 1) = 1e-100;
+  KroneckerOperator<Mat, Mat> K(A, B);
+  VERIFY_IS_APPROX(K.determinant(), 1e200);
+  VERIFY_IS_APPROX(K.determinant(), reference_kron<double>(A, B).determinant());
+
+  // Underflow-side analogue: det(A2)^2 = 1e-400 underflows on its own, yet the
+  // determinant of K2 = diag(1e-100, 1e-100) is 1e-200.
+  Mat A2(1, 1);
+  A2 << 1e-200;
+  Mat B2 = Mat::Zero(2, 2);
+  B2(0, 0) = B2(1, 1) = 1e100;
+  KroneckerOperator<Mat, Mat> K2(A2, B2);
+  VERIFY_IS_APPROX(K2.determinant(), 1e-200);
+  VERIFY_IS_APPROX(K2.determinant(), reference_kron<double>(A2, B2).determinant());
+
+  // A genuinely overflowing determinant (1e800) must still give infinity ...
+  Mat B3 = Mat::Zero(2, 2);
+  B3(0, 0) = B3(1, 1) = 1e200;
+  KroneckerOperator<Mat, Mat> K3(A, B3);
+  VERIFY((numext::isinf)(K3.determinant()));
+  VERIFY(K3.determinant() > 0);
+
+  // ... and a genuinely underflowing one (1e-800) must flush to zero.
+  Mat B4 = Mat::Zero(2, 2);
+  B4(0, 0) = B4(1, 1) = 1e-200;
+  KroneckerOperator<Mat, Mat> K4(A2, B4);
+  VERIFY_IS_EQUAL(K4.determinant(), 0.0);
+}
+
+// Reviewer repro: (A (x) B) with A = [1e-200] and B = [1e200] is exactly the
+// identity, but evaluating (B X) A^T without protection overflows in
+// B X = 1e400 and returns Inf. The power-of-two pre-scaling must keep every
+// intermediate finite whenever the true result is representable -- and powers of
+// two shift only exponents, so no accuracy may be lost.
+void test_kron_extreme_scale_product() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  Mat A(1, 1), B(1, 1);
+  A << 1e-200;
+  B << 1e200;
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Vec x(1);
+  x << 1e200;
+  Vec y = K * x;
+  VERIFY(y.allFinite());
+  VERIFY_IS_APPROX(y[0], 1e200);
+
+  // Same magnitudes through solve(): with the factors swapped the operator is
+  // still the identity, and the intermediate B^{-1} mat(b) = 1e400 overflows;
+  // the normalized-frame solve must return the exact solution.
+  KroneckerOperator<Mat, Mat> Ks(B, A);
+  Vec b(1);
+  b << 1e200;
+  Vec xs = Ks.solve(b);
+  VERIFY(xs.allFinite());
+  VERIFY_IS_APPROX(xs[0], 1e200);
+
+  // Identity built from scaled unit matrices: the first GEMM is ~1e400 while
+  // K * x == x exactly.
+  Mat A2 = 1e-200 * Mat::Identity(2, 2), B2 = 1e200 * Mat::Identity(3, 3);
+  KroneckerOperator<Mat, Mat> K2(A2, B2);
+  Vec x2 = 1e200 * Vec::Random(6);
+  Vec y2 = K2 * x2;
+  VERIFY(y2.allFinite());
+  VERIFY_IS_APPROX(y2, x2);
+
+  // Multi-dimensional overflow boundary: the intermediate B X ~ 2^1103 overflows
+  // while the true result ~ 2^904 is representable -- and the dense reference can
+  // compute it, because the materialized product has moderate entries ~ 2^400.
+  Mat A3 = std::ldexp(1.0, -200) * Mat::Random(2, 2);
+  Mat B3 = std::ldexp(1.0, 600) * Mat::Random(2, 2);
+  KroneckerOperator<Mat, Mat> K3(A3, B3);
+  Mat dense3 = reference_kron<double>(A3, B3);
+  Vec x3 = std::ldexp(1.0, 500) * Vec::Random(4);
+  Vec y3 = K3 * x3;
+  VERIFY(y3.allFinite());
+  VERIFY_IS_APPROX(y3, (dense3 * x3).eval());
+
+  // A genuinely overflowing result must still saturate to infinity.
+  KroneckerOperator<Mat, Mat> K4(B, B);  // [1e200] (x) [1e200]
+  Vec y4 = K4 * x;                       // true result 1e600
+  VERIFY((numext::isinf)(y4[0]));
+  VERIFY(y4[0] > 0);
+}
+
+// Complex analogue: the exponent bounds must come from the component-wise
+// magnitudes. A finite complex value near the overflow threshold has a
+// non-representable modulus, which would silently disable the scaling (and a
+// result with components near the threshold has one too, which must not be
+// destroyed on the way back).
+void test_kron_extreme_scale_complex() {
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, 1> Vec;
+  typedef Matrix<Complex, Dynamic, Dynamic> Mat;
+
+  Mat A(1, 1), B(1, 1);
+  A << Complex(1e-300, 0.0);
+  B << Complex(1e308, 1e308);  // |B(0,0)| overflows; the components are finite
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Vec x(1);
+  x << Complex(1e300, 0.0);
+  Vec y = K * x;
+  VERIFY(y.allFinite());
+  // Exact scalar reference, evaluated in an order that never leaves the
+  // representable range: (A * B) * x = (1e8 + 1e8 i) * 1e300.
+  const Complex expected = (A(0, 0) * B(0, 0)) * x[0];
+  VERIFY_IS_APPROX(y[0], expected);
+
+  Mat A2(1, 1), B2(1, 1);
+  A2 << Complex(1e-200, 0.0);
+  B2 << Complex(1.2e200, -1.3e200);
+  KroneckerOperator<Mat, Mat> K2(A2, B2);
+  Vec x2(1);
+  x2 << Complex(1.1e200, -0.7e200);
+  Vec y2 = K2 * x2;
+  VERIFY(y2.allFinite());
+  VERIFY_IS_APPROX(y2[0], ((A2(0, 0) * B2(0, 0)) * x2[0]));
+}
+
+// Reviewer repro: with A = [1e-310] (subnormal) the absolute rank threshold
+// min(rows,cols) * eps * sa_max underflows to zero before the sb_max
+// multiplication, so every pairwise singular-value product used to pass and
+// rank() returned 8 where the dense SVD says 1. The comparison must happen in
+// ratio space: (sa_i/sa_0) * (sb_j/sb_0) against min(rows,cols) * eps.
+void test_kron_rank_ratio_threshold() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  Mat A(1, 1);
+  A << 1e-310;  // subnormal
+  Mat B = Mat::Zero(8, 8);
+  for (Index i = 0; i < 8; ++i) B(i, i) = std::pow(10.0, 308.0 - 15.0 * double(i));  // 1e308, 1e293, ...
+  KroneckerOperator<Mat, Mat> K(A, B);
+
+  // The materialized product has moderate entries (1e-2 down to 1e-107), so the
+  // dense SVD is a trustworthy reference: the singular-value ratios decay by
+  // 1e-15 per mode, below the 8 * eps ~ 1.8e-15 threshold, leaving rank one.
+  Mat dense = reference_kron<double>(A, B);
+  JacobiSVD<Mat, ComputeThinU | ComputeThinV> svd(dense);
+  VERIFY_IS_EQUAL(svd.rank(), 1);
+  VERIFY_IS_EQUAL(K.rank(), svd.rank());
+
+  // leastSquaresSolve must truncate the seven sub-threshold modes instead of
+  // inverting them: inverting even the second one would blow the solution up by
+  // ~1e17 (the last by ~1e107). The kept mode has sigma = 1e-2.
+  Vec b = Vec::Random(8);
+  Vec x = K.leastSquaresSolve(b);
+  VERIFY(x.allFinite());
+  VERIFY_IS_APPROX(x, svd.solve(b).eval());
+  VERIFY(x.norm() <= 1e3 * b.norm());
+
+  // An exactly zero factor zeroes the whole operator: rank 0 and a zero
+  // pseudo-inverse (instead of 0/0 singular-value ratios).
+  Mat Z = Mat::Zero(2, 2);
+  KroneckerOperator<Mat, Mat> Kz(Z, B.topLeftCorner(2, 2).eval());
+  VERIFY_IS_EQUAL(Kz.rank(), 0);
+  Vec bz = Vec::Random(4);
+  VERIFY_IS_EQUAL(Kz.leastSquaresSolve(bz).norm(), 0.0);
+}
+
+// The ratio test alone dropped SVDBase's smallest-normal clamp: a subnormal
+// product singular value, whose reciprocal overflows, must count as an exact
+// zero. A = [1], B = [DBL_MIN/2] has the singular value DBL_MIN/2: the dense
+// rank is 0 and the pseudo-inverse is zero, but without the clamp the
+// structured rank was 1 and leastSquaresSolve returned ~9e307. The boundary
+// DBL_MIN itself stays rank one, matching SVDBase::rank()'s >= convention.
+void test_kron_rank_min_normal_clamp() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  const double mn = (std::numeric_limits<double>::min)();
+
+  Mat A(1, 1), B(1, 1);
+  A << 1.0;
+  B << mn / 2;  // subnormal
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<double>(A, B);
+  JacobiSVD<Mat, ComputeThinU | ComputeThinV> svd(dense);
+  VERIFY_IS_EQUAL(svd.rank(), 0);
+  VERIFY_IS_EQUAL(K.rank(), svd.rank());
+  Vec b(1);
+  b << 1.0;
+  VERIFY_IS_EQUAL(K.leastSquaresSolve(b).norm(), 0.0);
+  VERIFY_IS_EQUAL(svd.solve(b).norm(), 0.0);
+
+  // Boundary: the smallest normal number is the smallest kept singular value.
+  Mat B2(1, 1);
+  B2 << mn;
+  KroneckerOperator<Mat, Mat> K2(A, B2);
+  JacobiSVD<Mat> svd2(reference_kron<double>(A, B2));
+  VERIFY_IS_EQUAL(svd2.rank(), 1);
+  VERIFY_IS_EQUAL(K2.rank(), svd2.rank());
+  Vec x2 = K2.leastSquaresSolve(b);
+  VERIFY(x2.allFinite());
+  VERIFY_IS_APPROX(x2[0], 1.0 / mn);
+}
+
+// solve() must run in a normalized frame; the previous detect-and-retry missed
+// (a) silent underflow -- the intermediate B^-1 mat(b) flushes to zero, which is
+// finite, so nothing triggered a retry -- and (b) factors whose raw inverse is
+// not representable even against a unit right-hand side.
+void test_kron_solve_normalized() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  // (a) Identity operator, tiny right-hand side: B^-1 * b = 1e-400 used to
+  // underflow silently to zero.
+  for (Index n : {Index(1), Index(5)}) {
+    Mat A = Mat::Identity(n, n), B = Mat::Identity(n, n);
+    A *= 1e-200;
+    B *= 1e200;
+    KroneckerOperator<Mat, Mat> K(A, B);
+    Vec b = Vec::Constant(n * n, 1e-200);
+    Vec x = K.solve(b);
+    VERIFY_IS_APPROX((x / 1e-200).eval(), Vec::Ones(n * n).eval());
+
+    // (b) B^-1 ~ 1e310 is not representable, yet the operator is ~0.01 and the
+    // solution ~100: in the normalized frame every intermediate is bounded by the
+    // conditioning of the factors.
+    Mat A2 = Mat::Identity(n, n), B2 = Mat::Identity(n, n);
+    A2 *= 1e308;
+    B2 *= 1e-310;  // subnormal
+    KroneckerOperator<Mat, Mat> K2(A2, B2);
+    Vec b2 = Vec::Ones(n * n);
+    Vec x2 = K2.solve(b2);
+    VERIFY(x2.allFinite());
+    VERIFY_IS_APPROX(x2, Vec::Constant(n * n, 1.0 / (A2(0, 0) * B2(0, 0))).eval());
+  }
+}
+
+// Moderate inputs must be bit-identical to the unnormalized evaluation: partial
+// pivoting is invariant under the uniform power-of-two normalization and every
+// substitution step scales exactly with it.
+template <typename Scalar>
+void test_kron_solve_bit_identity(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  // The reference below reproduces the member-internal evaluation, which pins
+  // its workspaces to column-major storage.
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> CmMat;
+
+  Mat A = Mat::Random(n1, n1) + RealScalar(2 * n1) * Mat::Identity(n1, n1);
+  Mat B = Mat::Random(n2, n2) + RealScalar(2 * n2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+
+  Mat Bm = Mat::Random(n1 * n2, 2);
+  Mat X = K.solve(Bm);
+
+  // Raw, unnormalized reference evaluation.
+  PartialPivLU<CmMat> luA(A), luB(B);
+  for (Index k = 0; k < Bm.cols(); ++k) {
+    const Vec bc = Bm.col(k);
+    const Map<const CmMat> Bmat(bc.data(), n2, n1);
+    const CmMat Xref = luA.solve(luB.solve(Bmat).transpose()).transpose();
+    const Map<const Vec> xref(Xref.data(), Xref.size());
+    VERIFY_IS_EQUAL(X.col(k).eval(), Vec(xref));
+  }
+}
+
+template <typename Scalar>
+void test_kron_eigen(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+
+  Mat A = Mat::Random(n1, n1), B = Mat::Random(n2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  CMat dense = reference_kron<Scalar>(A, B).template cast<Complex>();
+
+  CVec lambda = K.eigenvalues();
+  CMat V = K.eigenvectors();  // materializes the Kronecker eigenvector operator
+  VERIFY_IS_APPROX((dense * V).eval(), (V * lambda.asDiagonal()).eval());
+}
+
+template <typename Scalar>
+void test_kron_svd(Index m1, Index n1, Index m2, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Mat A = Mat::Random(m1, n1), B = Mat::Random(m2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Matrix<RealScalar, Dynamic, 1> sv = K.singularValues();
+  Mat U = K.matrixU(), V = K.matrixV();
+  const Index k = sv.size();
+  VERIFY_IS_EQUAL(U.cols(), k);
+  VERIFY_IS_EQUAL(V.cols(), k);
+
+  // Thin SVD in Kronecker order: U and V have orthonormal columns and
+  // U * diag(sv) * V^H reconstructs the matrix.
+  VERIFY_IS_APPROX((U.adjoint() * U).eval(), Mat(Mat::Identity(k, k)));
+  VERIFY_IS_APPROX((V.adjoint() * V).eval(), Mat(Mat::Identity(k, k)));
+  VERIFY_IS_APPROX((U * sv.template cast<Scalar>().asDiagonal() * V.adjoint()).eval(), dense);
+
+  // The value multiset matches the dense SVD (compare sorted).
+  Matrix<RealScalar, Dynamic, 1> svSorted = sv;
+  std::sort(svSorted.data(), svSorted.data() + svSorted.size(), std::greater<RealScalar>());
+  JacobiSVD<Mat> svd(dense);
+  VERIFY_IS_APPROX(svSorted, svd.singularValues().head(k).eval());
+  if (svd.singularValues().size() > k)  // rectangular shapes pad with structural zeros
+    VERIFY(svd.singularValues().tail(svd.singularValues().size() - k).norm() <=
+           RealScalar(100) * NumTraits<RealScalar>::epsilon() * svd.singularValues()[0]);
+}
+
+template <typename Scalar>
+void test_kron_inverse_determinant(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Modest diagonal boost: invertible, with the determinant's magnitude tame
+  // enough for a relative comparison in double precision.
+  Mat A = Mat::Random(n1, n1) + RealScalar(2) * Mat::Identity(n1, n1);
+  Mat B = Mat::Random(n2, n2) + RealScalar(2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Mat inv = K.inverse();
+  VERIFY_IS_APPROX((inv * dense).eval(), Mat(Mat::Identity(dense.rows(), dense.cols())));
+  VERIFY_IS_APPROX(K.determinant(), dense.determinant());
+}
+
+template <typename Scalar>
+void test_kron_matrix_free_cg(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // SPD factors make an SPD Kronecker product.
+  Mat Ar = Mat::Random(n1, n1), Br = Mat::Random(n2, n2);
+  Mat A = Ar * Ar.adjoint() + RealScalar(n1) * Mat::Identity(n1, n1);
+  Mat B = Br * Br.adjoint() + RealScalar(n2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Mat, Mat> K(A, B);
+  Mat dense = reference_kron<Scalar>(A, B);
+
+  Vec b = Vec::Random(n1 * n2);
+  ConjugateGradient<KroneckerOperator<Mat, Mat>, Lower | Upper, IdentityPreconditioner> cg;
+  cg.compute(K);
+  Vec x = cg.solve(b);
+  VERIFY(cg.info() == Success);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+}
+
+template <typename Scalar, int M1, int N1, int M2, int N2>
+void test_kron_fixed() {
+  typedef Matrix<Scalar, M1, N1> MatA;
+  typedef Matrix<Scalar, M2, N2> MatB;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  MatA A = MatA::Random();
+  MatB B = MatB::Random();
+  KroneckerOperator<MatA, MatB> K(A, B);
+  STATIC_CHECK((KroneckerOperator<MatA, MatB>::RowsAtCompileTime == M1 * M2));
+  STATIC_CHECK((KroneckerOperator<MatA, MatB>::ColsAtCompileTime == N1 * N2));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeKroneckerOperator(A, B))>::RowsAtCompileTime == M1 * M2));
+  STATIC_CHECK((internal::remove_all_t<decltype(K.transpose())>::RowsAtCompileTime == N1 * N2));
+  STATIC_CHECK((internal::remove_all_t<decltype(K.transpose())>::ColsAtCompileTime == M1 * M2));
+
+  Mat dense = reference_kron<Scalar>(Mat(A), Mat(B));
+  Matrix<Scalar, M1 * M2, N1 * N2> Kd = K;
+  VERIFY_IS_APPROX(Mat(Kd), dense);
+
+  Matrix<Scalar, N1 * N2, 1> x = Matrix<Scalar, N1 * N2, 1>::Random();
+  Matrix<Scalar, M1 * M2, 1> y = K * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  // The solvers must propagate the compile-time product dimension instead of
+  // collapsing to Dynamic rows.
+  typedef Matrix<Scalar, M1 * M2, 1> FixedB;
+  STATIC_CHECK((internal::remove_all_t<decltype(std::declval<const KroneckerOperator<MatA, MatB>&>().leastSquaresSolve(
+                    std::declval<const FixedB&>()))>::RowsAtCompileTime == N1 * N2));
+}
+
+// solve()/leastSquaresSolve() on fixed-size square factors: the returned type
+// carries the fixed row count, and the values match the dense references.
+template <typename Scalar, int N1, int N2>
+void test_kron_fixed_solve() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, N1, N1> MatA;
+  typedef Matrix<Scalar, N2, N2> MatB;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  MatA A = MatA::Random() + RealScalar(2 * N1) * MatA::Identity();
+  MatB B = MatB::Random() + RealScalar(2 * N2) * MatB::Identity();
+  KroneckerOperator<MatA, MatB> K(A, B);
+  Mat dense = reference_kron<Scalar>(Mat(A), Mat(B));
+
+  const Matrix<Scalar, N1 * N2, 1> b = Matrix<Scalar, N1 * N2, 1>::Random();
+  const auto x = K.solve(b);
+  STATIC_CHECK((internal::remove_all_t<decltype(x)>::RowsAtCompileTime == N1 * N2));
+  VERIFY_IS_APPROX((dense * Vec(x)).eval(), Vec(b));
+
+  const auto xls = K.leastSquaresSolve(b);
+  STATIC_CHECK((internal::remove_all_t<decltype(xls)>::RowsAtCompileTime == N1 * N2));
+  VERIFY_IS_APPROX(Vec(xls), Vec(x));
+}
+
+// ---- Diagonal and identity factors -----------------------------------------
+
+// Diagonal factors: D (x) B, B (x) D and D1 (x) D2 must match the densified
+// reference through dense assignment, coefficient access and every product
+// path, while storing only the diagonals.
+template <typename Scalar>
+void test_kron_diag_product(Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef DiagonalMatrix<Scalar, Dynamic> Diag;
+
+  const Diag D1(Vec::Random(n1)), D2(Vec::Random(n2));
+  Mat B = Mat::Random(m2, n2);
+  const Mat D1d = D1.toDenseMatrix(), D2d = D2.toDenseMatrix();
+
+  KroneckerOperator<Diag, Mat> KL(D1, B);    // D1 (x) B
+  KroneckerOperator<Mat, Diag> KR(B, D2);    // B (x) D2
+  KroneckerOperator<Diag, Diag> KD(D1, D2);  // D1 (x) D2
+
+  Mat refL = reference_kron<Scalar>(D1d, B);
+  Mat refR = reference_kron<Scalar>(B, D2d);
+  Mat refD = reference_kron<Scalar>(D1d, D2d);
+
+  // Dense assignment through evalTo (a diagonal factor writes zero blocks off
+  // its diagonal) and coefficient access.
+  VERIFY_IS_APPROX(Mat(KL), refL);
+  VERIFY_IS_APPROX(Mat(KR), refR);
+  VERIFY_IS_APPROX(Mat(KD), refD);
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, KL.rows() - 1), j = internal::random<Index>(0, KL.cols() - 1);
+    VERIFY_IS_APPROX(KL.coeff(i, j), refL(i, j));
+    i = internal::random<Index>(0, KD.rows() - 1), j = internal::random<Index>(0, KD.cols() - 1);
+    VERIFY_IS_APPROX(KD.coeff(i, j), refD(i, j));
+  }
+
+  // Dense accumulation through addTo/subTo (a diagonal factor accumulates only
+  // the block diagonals).
+  Mat acc = Mat::Random(refL.rows(), refL.cols());
+  const Mat acc0 = acc;
+  acc += KL;
+  VERIFY_IS_APPROX(acc, (acc0 + refL).eval());
+  acc -= KL;
+  VERIFY_IS_APPROX(acc, acc0);
+
+  // Vector, matrix and accumulated products via the vec identity.
+  Vec x = Vec::Random(refL.cols());
+  VERIFY_IS_APPROX((KL * x).eval(), (refL * x).eval());
+  Mat X = Mat::Random(refL.cols(), 3);
+  VERIFY_IS_APPROX((KL * X).eval(), (refL * X).eval());
+  Vec y = Vec::Random(refL.rows());
+  Vec y0 = y;
+  y.noalias() += KL * x;
+  VERIFY_IS_APPROX(y, (y0 + refL * x).eval());
+
+  Vec xr = Vec::Random(refR.cols());
+  VERIFY_IS_APPROX((KR * xr).eval(), (refR * xr).eval());
+  Vec xd = Vec::Random(refD.cols());
+  VERIFY_IS_APPROX((KD * xd).eval(), (refD * xd).eval());
+
+  // Factory deduction from a diagonal expression maps to an owning
+  // DiagonalMatrix factor.
+  auto KF = makeKroneckerOperator(D1.diagonal().asDiagonal(), B);
+  STATIC_CHECK((std::is_same<decltype(KF), KroneckerOperator<Diag, Mat>>::value));
+  VERIFY_IS_APPROX((KF * x).eval(), (refL * x).eval());
+}
+
+// Identity factors, the I (x) A and A (x) I operators of finite-difference
+// discretizations: a unit-diagonal factor stores O(p) data and applies as a
+// no-op scaling instead of a GEMM. Checked against the dense reference and
+// against the vec identity (I (x) A) vec(X) = vec(A X) directly.
+template <typename Scalar>
+void test_kron_identity(Index p, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> CmMat;  // reshape frame of the vec identity
+  typedef DiagonalMatrix<Scalar, Dynamic> Diag;
+
+  Mat A = Mat::Random(m2, n2);
+  auto KI = makeKroneckerOperator(Vec::Ones(p).asDiagonal(), A);  // I_p (x) A
+  auto IK = makeKroneckerOperator(A, Vec::Ones(p).asDiagonal());  // A (x) I_p
+  STATIC_CHECK((std::is_same<decltype(KI), KroneckerOperator<Diag, Mat>>::value));
+  STATIC_CHECK((std::is_same<decltype(IK), KroneckerOperator<Mat, Diag>>::value));
+
+  const Mat Ip = Mat::Identity(p, p);
+  Mat refI = reference_kron<Scalar>(Ip, A);
+  Mat refK = reference_kron<Scalar>(A, Ip);
+
+  Vec x = Vec::Random(p * n2);
+  VERIFY_IS_APPROX((KI * x).eval(), (refI * x).eval());
+  VERIFY_IS_APPROX((IK * x).eval(), (refK * x).eval());
+
+  // (I_p (x) A) vec(X) = vec(A X) with X of size n2 x p: block-wise application
+  // of A to each length-n2 segment.
+  const Map<const CmMat> Xmat(x.data(), n2, p);
+  CmMat Y = A * Xmat;
+  VERIFY_IS_APPROX((KI * x).eval(), Vec(Map<const Vec>(Y.data(), Y.size())));
+}
+
+// The transposition family of a diagonal factor stays diagonal, in type and in
+// value.
+template <typename Scalar>
+void test_kron_diag_transpose(Index n1, Index m2, Index n2) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef DiagonalMatrix<Scalar, Dynamic> Diag;
+
+  const Diag D(Vec::Random(n1));
+  Mat B = Mat::Random(m2, n2);
+  KroneckerOperator<Diag, Mat> K(D, B);
+  Mat dense = reference_kron<Scalar>(D.toDenseMatrix(), B);
+
+  STATIC_CHECK((std::is_same<typename internal::remove_all_t<decltype(K.transpose())>,
+                             KroneckerOperator<Diag, Matrix<Scalar, Dynamic, Dynamic>>>::value));
+  STATIC_CHECK((std::is_same<typename internal::remove_all_t<decltype(K.adjoint())>,
+                             KroneckerOperator<Diag, Matrix<Scalar, Dynamic, Dynamic>>>::value));
+  STATIC_CHECK(
+      (std::is_same<typename internal::remove_all_t<decltype(K.conjugate())>, KroneckerOperator<Diag, Mat>>::value));
+
+  Mat Td = K.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = K.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Cd = K.conjugate();
+  VERIFY_IS_APPROX(Cd, Mat(dense.conjugate()));
+
+  Vec y = Vec::Random(dense.rows());
+  VERIFY_IS_APPROX((K.transpose() * y).eval(), (dense.transpose() * y).eval());
+  VERIFY_IS_APPROX((K.adjoint() * y).eval(), (dense.adjoint() * y).eval());
+}
+
+// solve() through diagonal factors: a diagonal side is an entrywise division
+// instead of an LU substitution. All three factor-kind mixes against the dense
+// LU solve.
+template <typename Scalar>
+void test_kron_diag_solve(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef DiagonalMatrix<Scalar, Dynamic> Diag;
+
+  // Diagonal entries bounded away from zero and diagonally boosted dense
+  // factors keep everything well conditioned.
+  const Diag D1(Vec::Random(n1) + Vec::Constant(n1, Scalar(2)));
+  const Diag D2(Vec::Random(n2) + Vec::Constant(n2, Scalar(2)));
+  Mat A = Mat::Random(n1, n1) + RealScalar(2 * n1) * Mat::Identity(n1, n1);
+  Mat B = Mat::Random(n2, n2) + RealScalar(2 * n2) * Mat::Identity(n2, n2);
+
+  KroneckerOperator<Diag, Mat> KL(D1, B);
+  KroneckerOperator<Mat, Diag> KR(A, D2);
+  KroneckerOperator<Diag, Diag> KD(D1, D2);
+
+  Mat denseL = reference_kron<Scalar>(D1.toDenseMatrix(), B);
+  Mat denseR = reference_kron<Scalar>(A, D2.toDenseMatrix());
+  Mat denseD = reference_kron<Scalar>(D1.toDenseMatrix(), D2.toDenseMatrix());
+
+  Vec b = Vec::Random(n1 * n2);
+  VERIFY_IS_APPROX((denseL * KL.solve(b)).eval(), b);
+  VERIFY_IS_APPROX(KL.solve(b), denseL.partialPivLu().solve(b).eval());
+  VERIFY_IS_APPROX(KR.solve(b), denseR.partialPivLu().solve(b).eval());
+  VERIFY_IS_APPROX(KD.solve(b), denseD.partialPivLu().solve(b).eval());
+
+  Mat Bm = Mat::Random(n1 * n2, 3);
+  VERIFY_IS_APPROX(KL.solve(Bm), denseL.partialPivLu().solve(Bm).eval());
+  VERIFY_IS_APPROX(KR.solve(Bm), denseR.partialPivLu().solve(Bm).eval());
+}
+
+// inverse() of a diagonal factor stays diagonal (entrywise reciprocals);
+// determinant() accumulates directly from the diagonal, skipping the LU.
+template <typename Scalar>
+void test_kron_diag_inverse_determinant(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef DiagonalMatrix<Scalar, Dynamic> Diag;
+
+  const Diag D(Vec::Random(n1) + Vec::Constant(n1, Scalar(2)));
+  Mat B = Mat::Random(n2, n2) + RealScalar(2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Diag, Mat> K(D, B);
+  Mat dense = reference_kron<Scalar>(D.toDenseMatrix(), B);
+
+  auto Kinv = K.inverse();
+  STATIC_CHECK((std::is_same<typename internal::remove_all_t<decltype(Kinv)>,
+                             KroneckerOperator<Diag, Matrix<Scalar, Dynamic, Dynamic, ColMajor>>>::value));
+  Mat inv = Kinv;
+  VERIFY_IS_APPROX((inv * dense).eval(), Mat(Mat::Identity(dense.rows(), dense.cols())));
+  VERIFY_IS_APPROX(K.determinant(), dense.determinant());
+
+  const Diag D2(Vec::Random(n2) + Vec::Constant(n2, Scalar(2)));
+  KroneckerOperator<Diag, Diag> KD(D, D2);
+  Mat denseD = reference_kron<Scalar>(D.toDenseMatrix(), D2.toDenseMatrix());
+  VERIFY_IS_APPROX(KD.determinant(), denseD.determinant());
+  Mat invD = KD.inverse();
+  VERIFY_IS_APPROX((invD * denseD).eval(), Mat(Mat::Identity(denseD.rows(), denseD.cols())));
+}
+
+// The decomposition family on diagonal factors (materialized densely for the
+// factor decompositions): eigen-residual, SVD reconstruction, rank and
+// minimum-norm least squares against the dense references.
+template <typename Scalar>
+void test_kron_diag_decompositions(Index n1, Index n2) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef DiagonalMatrix<Scalar, Dynamic> Diag;
+
+  const Diag D(Vec::Random(n1));
+  Mat B = Mat::Random(n2, n2);
+  KroneckerOperator<Diag, Mat> K(D, B);
+  Mat dense = reference_kron<Scalar>(D.toDenseMatrix(), B);
+
+  CVec lambda = K.eigenvalues();
+  CMat V = K.eigenvectors();
+  VERIFY_IS_APPROX((dense.template cast<Complex>() * V).eval(), (V * lambda.asDiagonal()).eval());
+
+  Matrix<RealScalar, Dynamic, 1> sv = K.singularValues();
+  Mat U = K.matrixU(), W = K.matrixV();
+  VERIFY_IS_APPROX((U * sv.template cast<Scalar>().asDiagonal() * W.adjoint()).eval(), dense);
+
+  VERIFY_IS_EQUAL(K.rank(), dense.completeOrthogonalDecomposition().rank());
+  Vec b = Vec::Random(n1 * n2);
+  VERIFY_IS_APPROX(K.leastSquaresSolve(b), dense.completeOrthogonalDecomposition().solve(b).eval());
+}
+
+// The overflow-hardening contract must hold through diagonal factors: products
+// and solves with extreme diagonal magnitudes stay finite whenever the true
+// result is representable, and the balanced determinant survives partial
+// products that overflow on their own.
+void test_kron_diag_extreme_scale() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  typedef DiagonalMatrix<double, Dynamic> Diag;
+
+  // diag(1e-200) (x) [1e200] is the identity; the unprotected application
+  // B X = 1e400 would overflow.
+  Diag D(Vec::Constant(1, 1e-200));
+  Mat B(1, 1);
+  B << 1e200;
+  KroneckerOperator<Diag, Mat> K(D, B);
+  Vec x(1);
+  x << 1e200;
+  Vec y = K * x;
+  VERIFY(y.allFinite());
+  VERIFY_IS_APPROX(y[0], 1e200);
+
+  // Same magnitudes through solve(), diagonal on the divided side.
+  KroneckerOperator<Mat, Diag> Ks(B, D);
+  Vec b(1);
+  b << 1e200;
+  Vec xs = Ks.solve(b);
+  VERIFY(xs.allFinite());
+  VERIFY_IS_APPROX(xs[0], 1e200);
+
+  // Identity built from extreme diagonal scales: products and the entrywise
+  // divisions of the diagonal-diagonal solve run in the normalized frame.
+  Diag Da(Vec::Constant(2, 1e-200)), Db(Vec::Constant(3, 1e200));
+  KroneckerOperator<Diag, Diag> K2(Da, Db);
+  Vec x2 = 1e200 * Vec::Random(6);
+  Vec y2 = K2 * x2;
+  VERIFY(y2.allFinite());
+  VERIFY_IS_APPROX(y2, x2);
+  Vec b2 = 1e-200 * Vec::Random(6);
+  Vec xd = K2.solve(b2);
+  VERIFY(xd.allFinite());
+  VERIFY_IS_APPROX(xd, b2);
+
+  // det(diag(1e200))^2 = 1e400 overflows on its own, yet the determinant of
+  // diag(1e200) (x) diag(1e-100, 1e-100) is 1e200 -- and the diagonal path
+  // must balance exactly like the LU path.
+  Diag A1(Vec::Constant(1, 1e200)), B1(Vec::Constant(2, 1e-100));
+  KroneckerOperator<Diag, Diag> Kd(A1, B1);
+  VERIFY_IS_APPROX(Kd.determinant(), 1e200);
+}
+
+// Mixed-scalar promotion through a diagonal factor: a real operator applied to
+// a complex right-hand side runs in the promoted scalar.
+template <typename RealScalar>
+void test_kron_diag_mixed_scalar(Index n1, Index m2, Index n2) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> RMat;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  typedef DiagonalMatrix<RealScalar, Dynamic> RDiag;
+
+  const RDiag D(RVec::Random(n1));
+  RMat B = RMat::Random(m2, n2);
+  KroneckerOperator<RDiag, RMat> K(D, B);
+  CMat dense = reference_kron<RealScalar>(D.toDenseMatrix(), B).template cast<Complex>();
+
+  CVec x = CVec::Random(n1 * n2);
+  CVec y = K * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+  CVec y0 = CVec::Random(n1 * m2);
+  y = y0;
+  y.noalias() += K * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+}
+
+// Fixed-size diagonal factors propagate compile-time dimensions.
+template <typename Scalar, int N1, int M2, int N2>
+void test_kron_diag_fixed() {
+  typedef DiagonalMatrix<Scalar, N1> Diag;
+  typedef Matrix<Scalar, M2, N2> MatB;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  const Diag D(Matrix<Scalar, N1, 1>::Random());
+  MatB B = MatB::Random();
+  KroneckerOperator<Diag, MatB> K(D, B);
+  STATIC_CHECK((KroneckerOperator<Diag, MatB>::RowsAtCompileTime == N1 * M2));
+  STATIC_CHECK((KroneckerOperator<Diag, MatB>::ColsAtCompileTime == N1 * N2));
+
+  Mat dense = reference_kron<Scalar>(Mat(D.toDenseMatrix()), Mat(B));
+  Matrix<Scalar, N1 * M2, N1 * N2> Kd = K;
+  VERIFY_IS_APPROX(Mat(Kd), dense);
+
+  Matrix<Scalar, N1 * N2, 1> x = Matrix<Scalar, N1 * N2, 1>::Random();
+  Matrix<Scalar, N1 * M2, 1> y = K * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+}
+
+// Matrix-free CG through a diagonal-factor operator: a positive diagonal
+// tensored with an SPD dense factor is SPD.
+void test_kron_diag_matrix_free_cg(Index n1, Index n2) {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+  typedef DiagonalMatrix<double, Dynamic> Diag;
+
+  const Diag D(Vec::Random(n1).cwiseAbs() + Vec::Constant(n1, 1.0));
+  Mat Br = Mat::Random(n2, n2);
+  Mat B = Br * Br.adjoint() + double(n2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Diag, Mat> K(D, B);
+  Mat dense = reference_kron<double>(D.toDenseMatrix(), B);
+
+  Vec b = Vec::Random(n1 * n2);
+  ConjugateGradient<KroneckerOperator<Diag, Mat>, Lower | Upper, IdentityPreconditioner> cg;
+  cg.compute(K);
+  Vec x = cg.solve(b);
+  VERIFY(cg.info() == Success);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+}
+
+// ---- Sparse factors ---------------------------------------------------------
+
+// A random sparse test matrix with about half of its entries stored, drawn
+// densely so that the dense reference is exact.
+template <typename Scalar, int Options = ColMajor>
+SparseMatrix<Scalar, Options> random_sparse(Index rows, Index cols) {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  Mat dense = Mat::Random(rows, cols);
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i)
+      if (internal::random<int>(0, 1) == 0) dense(i, j) = Scalar(0);
+  return dense.sparseView();
+}
+
+// A random sparse factor made diagonally dominant by the shifts 2n, 4n, ...,
+// 2n^2: the Gershgorin discs are disjoint, so it is nonsingular, well
+// conditioned and diagonalizable with distinct eigenvalues (a half-zeroed
+// random sparse matrix alone is often nilpotent).
+template <typename Scalar>
+SparseMatrix<Scalar> random_sparse_dominant(Index n) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealVec = Matrix<RealScalar, Dynamic, 1>;
+  Mat dense = Mat(random_sparse<Scalar>(n, n));
+  dense.diagonal() += (RealScalar(2 * n) * RealVec::LinSpaced(n, RealScalar(1), RealScalar(n))).template cast<Scalar>();
+  return dense.sparseView();
+}
+
+// Sparse factors: S (x) B, B (x) S and S1 (x) S2 must match the densified
+// reference through dense assignment, coefficient access and every product
+// path, while storing only the sparse factors' nonzeros. A row-major sparse
+// factor takes the same paths.
+template <typename Scalar>
+void test_kron_sparse_product(Index m1, Index n1, Index m2, Index n2) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<Scalar>;
+  using RowSparse = SparseMatrix<Scalar, RowMajor>;
+
+  const Sparse S1 = random_sparse<Scalar>(m1, n1), S2 = random_sparse<Scalar>(m2, n2);
+  const RowSparse R1(S1);
+  const Mat B = Mat::Random(m2, n2);
+  const Mat S1d = S1, S2d = S2;
+
+  KroneckerOperator<Sparse, Mat> KL(S1, B);      // S1 (x) B
+  KroneckerOperator<Mat, Sparse> KR(B, S2);      // B (x) S2
+  KroneckerOperator<Sparse, Sparse> KS(S1, S2);  // S1 (x) S2
+  KroneckerOperator<RowSparse, Mat> KM(R1, B);   // row-major sparse factor
+
+  Mat refL = reference_kron<Scalar>(S1d, B);
+  Mat refR = reference_kron<Scalar>(B, S2d);
+  Mat refS = reference_kron<Scalar>(S1d, S2d);
+
+  // Dense assignment through evalTo (only the blocks of stored entries are
+  // visited, the rest is cleared) and coefficient access.
+  VERIFY_IS_APPROX(Mat(KL), refL);
+  VERIFY_IS_APPROX(Mat(KR), refR);
+  VERIFY_IS_APPROX(Mat(KS), refS);
+  VERIFY_IS_APPROX(Mat(KM), refL);
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, KS.rows() - 1), j = internal::random<Index>(0, KS.cols() - 1);
+    VERIFY_IS_APPROX(KS.coeff(i, j), refS(i, j));
+  }
+
+  // Dense accumulation writes only the blocks of stored entries.
+  Mat acc = Mat::Random(refL.rows(), refL.cols());
+  const Mat acc0 = acc;
+  acc += KL;
+  VERIFY_IS_APPROX(acc, (acc0 + refL).eval());
+  acc -= KL;
+  VERIFY_IS_APPROX(acc, acc0);
+
+  // Vector, matrix and accumulated products through the sparse-dense kernels.
+  Vec x = Vec::Random(refL.cols());
+  VERIFY_IS_APPROX((KL * x).eval(), (refL * x).eval());
+  VERIFY_IS_APPROX((KM * x).eval(), (refL * x).eval());
+  Mat X = Mat::Random(refL.cols(), 3);
+  VERIFY_IS_APPROX((KL * X).eval(), (refL * X).eval());
+  Vec y = Vec::Random(refL.rows());
+  Vec y0 = y;
+  y.noalias() += KL * x;
+  VERIFY_IS_APPROX(y, (y0 + refL * x).eval());
+
+  Vec xr = Vec::Random(refR.cols());
+  VERIFY_IS_APPROX((KR * xr).eval(), (refR * xr).eval());
+  Vec xs = Vec::Random(refS.cols());
+  VERIFY_IS_APPROX((KS * xs).eval(), (refS * xs).eval());
+  Mat Xs = Mat::Random(refS.cols(), 2);
+  VERIFY_IS_APPROX((KS * Xs).eval(), (refS * Xs).eval());
+
+  // Factory deduction: a sparse expression maps to an owning SparseMatrix
+  // factor, a transposed column-major matrix to a row-major one.
+  auto KF = makeKroneckerOperator(S1, B);
+  STATIC_CHECK((std::is_same<decltype(KF), KroneckerOperator<Sparse, Mat>>::value));
+  VERIFY_IS_APPROX((KF * x).eval(), (refL * x).eval());
+  auto KT = makeKroneckerOperator(S1.transpose(), S2);
+  STATIC_CHECK((std::is_same<decltype(KT), KroneckerOperator<RowSparse, Sparse>>::value));
+  VERIFY_IS_APPROX(Mat(KT), reference_kron<Scalar>(Mat(S1d.transpose()), S2d));
+}
+
+// Assigning the operator to a SparseMatrix materializes the product sparsely:
+// exactly one stored entry per pair of stored factor entries, compressed, for
+// every factor-kind mix and both destination storage orders.
+template <typename Scalar>
+void test_kron_sparse_materialize(Index m1, Index n1, Index m2, Index n2) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<Scalar>;
+  using RowSparse = SparseMatrix<Scalar, RowMajor>;
+  using Diag = DiagonalMatrix<Scalar, Dynamic>;
+
+  const Sparse S1 = random_sparse<Scalar>(m1, n1), S2 = random_sparse<Scalar>(m2, n2);
+  const Mat B = Mat::Random(m2, n2);
+  const Diag D(Vec::Random(m1));
+  const Mat S1d = S1, S2d = S2;
+  const Mat refS = reference_kron<Scalar>(S1d, S2d);
+
+  KroneckerOperator<Sparse, Sparse> KS(S1, S2);
+  Sparse M;
+  M = KS;
+  VERIFY(M.isCompressed());
+  VERIFY_IS_EQUAL(M.nonZeros(), S1.nonZeros() * S2.nonZeros());
+  VERIFY_IS_APPROX(Mat(M), refS);
+  RowSparse Mr;
+  Mr = KS;
+  VERIFY_IS_EQUAL(Mr.nonZeros(), S1.nonZeros() * S2.nonZeros());
+  VERIFY_IS_APPROX(Mat(Mr), refS);
+
+  // Dense and diagonal factors contribute all their stored entries.
+  Sparse Md;
+  Md = KroneckerOperator<Mat, Sparse>(B, S2);
+  VERIFY_IS_EQUAL(Md.nonZeros(), B.size() * S2.nonZeros());
+  VERIFY_IS_APPROX(Mat(Md), reference_kron<Scalar>(B, S2d));
+  Sparse Mdiag;
+  Mdiag = KroneckerOperator<Diag, Sparse>(D, S2);
+  VERIFY_IS_EQUAL(Mdiag.nonZeros(), m1 * S2.nonZeros());
+  VERIFY_IS_APPROX(Mat(Mdiag), reference_kron<Scalar>(D.toDenseMatrix(), S2d));
+  Sparse Mright;
+  Mright = KroneckerOperator<Sparse, Diag>(S2, D);
+  VERIFY_IS_EQUAL(Mright.nonZeros(), S2.nonZeros() * m1);
+  VERIFY_IS_APPROX(Mat(Mright), reference_kron<Scalar>(S2d, D.toDenseMatrix()));
+  Sparse Mdense;
+  Mdense = KroneckerOperator<Mat, Mat>(B, B);
+  VERIFY_IS_EQUAL(Mdense.nonZeros(), B.size() * B.size());
+  VERIFY_IS_APPROX(Mat(Mdense), reference_kron<Scalar>(B, B));
+
+  // Row-major sparse factors visit the destination columns out of order, each
+  // column still in increasing row index: every insertion is an append into
+  // the per-inner-vector reservation.
+  const RowSparse R1(S1), R2(S2);
+  KroneckerOperator<RowSparse, RowSparse> KRM(R1, R2);
+  Sparse Mrm;
+  Mrm = KRM;
+  VERIFY(Mrm.isCompressed());
+  VERIFY(Mrm.innerIndicesAreSorted());
+  VERIFY_IS_EQUAL(Mrm.nonZeros(), S1.nonZeros() * S2.nonZeros());
+  VERIFY_IS_APPROX(Mat(Mrm), refS);
+
+  // Sparse accumulation.
+  Sparse acc = random_sparse<Scalar>(M.rows(), M.cols());
+  const Mat acc0 = acc;
+  acc += KS;
+  VERIFY_IS_APPROX(Mat(acc), (acc0 + refS).eval());
+  acc -= KS;
+  VERIFY_IS_APPROX(Mat(acc), acc0);
+}
+
+// The identity-Kronecker operators of finite-difference discretizations with a
+// sparse S -- I_p (x) S, S (x) I_p and I_p (x) S (x) I_q -- against the dense
+// reference and the vec identity. The triple product nests a materialized
+// S (x) I_q as the sparse factor.
+template <typename Scalar>
+void test_kron_sparse_identity(Index p, Index m2, Index n2, Index q) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> CmMat;  // reshape frame of the vec identity
+  using Sparse = SparseMatrix<Scalar>;
+  using Diag = DiagonalMatrix<Scalar, Dynamic>;
+
+  const Sparse S = random_sparse<Scalar>(m2, n2);
+  const Mat Sd = S, Ip = Mat::Identity(p, p), Iq = Mat::Identity(q, q);
+  auto KI = makeKroneckerOperator(Vec::Ones(p).asDiagonal(), S);  // I_p (x) S
+  auto IK = makeKroneckerOperator(S, Vec::Ones(p).asDiagonal());  // S (x) I_p
+  STATIC_CHECK((std::is_same<decltype(KI), KroneckerOperator<Diag, Sparse>>::value));
+  STATIC_CHECK((std::is_same<decltype(IK), KroneckerOperator<Sparse, Diag>>::value));
+
+  Mat refI = reference_kron<Scalar>(Ip, Sd), refK = reference_kron<Scalar>(Sd, Ip);
+  VERIFY_IS_APPROX(Mat(KI), refI);
+  VERIFY_IS_APPROX(Mat(IK), refK);
+  Vec x = Vec::Random(p * n2);
+  VERIFY_IS_APPROX((KI * x).eval(), (refI * x).eval());
+  VERIFY_IS_APPROX((IK * x).eval(), (refK * x).eval());
+
+  // (I_p (x) S) vec(X) = vec(S X) with X of size n2 x p: one sparse-dense product.
+  const Map<const CmMat> Xmat(x.data(), n2, p);
+  CmMat Y = S * Xmat;
+  VERIFY_IS_APPROX((KI * x).eval(), Vec(Map<const Vec>(Y.data(), Y.size())));
+
+  // Sparse materialization stores p nnz(S) entries on either side.
+  Sparse MI;
+  MI = KI;
+  VERIFY_IS_EQUAL(MI.nonZeros(), p * S.nonZeros());
+  VERIFY_IS_APPROX(Mat(MI), refI);
+  Sparse MK;
+  MK = IK;
+  VERIFY_IS_EQUAL(MK.nonZeros(), p * S.nonZeros());
+  VERIFY_IS_APPROX(Mat(MK), refK);
+
+  // I_p (x) S (x) I_q = I_p (x) (S (x) I_q), the inner product materialized
+  // with q nnz(S) entries and nested as the sparse factor.
+  Sparse SI;
+  SI = makeKroneckerOperator(S, Vec::Ones(q).asDiagonal());
+  auto K3 = makeKroneckerOperator(Vec::Ones(p).asDiagonal(), SI);
+  Mat ref3 = reference_kron<Scalar>(Ip, reference_kron<Scalar>(Sd, Iq));
+  VERIFY_IS_APPROX(Mat(K3), ref3);
+  Vec x3 = Vec::Random(ref3.cols());
+  VERIFY_IS_APPROX((K3 * x3).eval(), (ref3 * x3).eval());
+  Sparse M3;
+  M3 = K3;
+  VERIFY_IS_EQUAL(M3.nonZeros(), p * q * S.nonZeros());
+  VERIFY_IS_APPROX(Mat(M3), ref3);
+}
+
+// The transposition family of a sparse factor stays sparse, in type and value.
+template <typename Scalar>
+void test_kron_sparse_transpose(Index m1, Index n1, Index m2, Index n2) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<Scalar>;
+
+  const Sparse S = random_sparse<Scalar>(m1, n1);
+  const Mat B = Mat::Random(m2, n2);
+  KroneckerOperator<Sparse, Mat> K(S, B);
+  Mat dense = reference_kron<Scalar>(Mat(S), B);
+
+  STATIC_CHECK((std::is_same<typename internal::remove_all_t<decltype(K.transpose())>,
+                             KroneckerOperator<Sparse, Matrix<Scalar, Dynamic, Dynamic>>>::value));
+  STATIC_CHECK((std::is_same<typename internal::remove_all_t<decltype(K.adjoint())>,
+                             KroneckerOperator<Sparse, Matrix<Scalar, Dynamic, Dynamic>>>::value));
+  STATIC_CHECK(
+      (std::is_same<typename internal::remove_all_t<decltype(K.conjugate())>, KroneckerOperator<Sparse, Mat>>::value));
+
+  Mat Td = K.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = K.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Cd = K.conjugate();
+  VERIFY_IS_APPROX(Cd, Mat(dense.conjugate()));
+  VERIFY_IS_EQUAL(K.transpose().lhs().nonZeros(), S.nonZeros());
+
+  Vec y = Vec::Random(dense.rows());
+  VERIFY_IS_APPROX((K.transpose() * y).eval(), (dense.transpose() * y).eval());
+  VERIFY_IS_APPROX((K.adjoint() * y).eval(), (dense.adjoint() * y).eval());
+}
+
+// solve() through sparse factors: one SparseLU per sparse factor, then column
+// solves in the normalized frame. All factor-kind mixes against the dense LU.
+template <typename Scalar>
+void test_kron_sparse_solve(Index n1, Index n2) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<Scalar>;
+  using RowSparse = SparseMatrix<Scalar, RowMajor>;
+  using Diag = DiagonalMatrix<Scalar, Dynamic>;
+
+  const Sparse S1 = random_sparse_dominant<Scalar>(n1), S2 = random_sparse_dominant<Scalar>(n2);
+  const Mat A = Mat::Random(n1, n1) + RealScalar(2 * n1) * Mat::Identity(n1, n1);
+  const Mat B = Mat::Random(n2, n2) + RealScalar(2 * n2) * Mat::Identity(n2, n2);
+  const Diag D(Vec::Random(n2) + Vec::Constant(n2, Scalar(2)));
+
+  KroneckerOperator<Sparse, Mat> KL(S1, B);
+  KroneckerOperator<Mat, Sparse> KR(A, S2);
+  KroneckerOperator<Sparse, Sparse> KS(S1, S2);
+  KroneckerOperator<Sparse, Diag> KD(S1, D);
+  const RowSparse R1(S1);
+  KroneckerOperator<RowSparse, Mat> KM(R1, B);
+
+  Mat denseL = reference_kron<Scalar>(Mat(S1), B), denseR = reference_kron<Scalar>(A, Mat(S2));
+  Mat denseS = reference_kron<Scalar>(Mat(S1), Mat(S2)), denseD = reference_kron<Scalar>(Mat(S1), D.toDenseMatrix());
+
+  Vec b = Vec::Random(n1 * n2);
+  VERIFY_IS_APPROX((denseL * KL.solve(b)).eval(), b);
+  VERIFY_IS_APPROX(KL.solve(b), denseL.partialPivLu().solve(b).eval());
+  VERIFY_IS_APPROX(KR.solve(b), denseR.partialPivLu().solve(b).eval());
+  VERIFY_IS_APPROX(KS.solve(b), denseS.partialPivLu().solve(b).eval());
+  VERIFY_IS_APPROX(KD.solve(b), denseD.partialPivLu().solve(b).eval());
+  VERIFY_IS_APPROX(KM.solve(b), denseL.partialPivLu().solve(b).eval());
+
+  Mat Bm = Mat::Random(n1 * n2, 3);
+  VERIFY_IS_APPROX(KL.solve(Bm), denseL.partialPivLu().solve(Bm).eval());
+  VERIFY_IS_APPROX(KR.solve(Bm), denseR.partialPivLu().solve(Bm).eval());
+  VERIFY_IS_APPROX(KS.solve(Bm), denseS.partialPivLu().solve(Bm).eval());
+}
+
+// inverse() of a sparse factor is a dense matrix from one SparseLU solve;
+// determinant() accumulates the SparseLU pivots with the balancing of the dense
+// path, and an exactly singular sparse factor gives an exact zero.
+template <typename Scalar>
+void test_kron_sparse_inverse_determinant(Index n1, Index n2) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using CmMat = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using Sparse = SparseMatrix<Scalar>;
+  using Diag = DiagonalMatrix<Scalar, Dynamic>;
+
+  const Sparse S = random_sparse_dominant<Scalar>(n1);
+  const Mat B = Mat::Random(n2, n2) + RealScalar(2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Sparse, Mat> K(S, B);
+  Mat dense = reference_kron<Scalar>(Mat(S), B);
+
+  auto Kinv = K.inverse();
+  STATIC_CHECK((std::is_same<typename internal::remove_all_t<decltype(Kinv)>, KroneckerOperator<CmMat, CmMat>>::value));
+  Mat inv = Kinv;
+  VERIFY_IS_APPROX((inv * dense).eval(), Mat(Mat::Identity(dense.rows(), dense.cols())));
+  VERIFY_IS_APPROX(K.determinant(), dense.determinant());
+
+  const Diag D(Vec::Random(n2) + Vec::Constant(n2, Scalar(2)));
+  KroneckerOperator<Sparse, Diag> KD(S, D);
+  Mat denseD = reference_kron<Scalar>(Mat(S), D.toDenseMatrix());
+  VERIFY_IS_APPROX(KD.determinant(), denseD.determinant());
+  Mat invD = KD.inverse();
+  VERIFY_IS_APPROX((invD * denseD).eval(), Mat(Mat::Identity(denseD.rows(), denseD.cols())));
+
+  // A structurally empty column makes the factor exactly singular.
+  Mat Zd = Mat(S);
+  Zd.col(0).setZero();
+  const Sparse Z = Zd.sparseView();
+  KroneckerOperator<Sparse, Mat> KZ(Z, B);
+  VERIFY_IS_EQUAL(KZ.determinant(), Scalar(0));
+
+  // [[0, 2], [3, 0]] forces a row interchange: the permutation sign must enter.
+  Mat Pd(2, 2);
+  Pd << Scalar(0), Scalar(2), Scalar(3), Scalar(0);
+  const Sparse P = Pd.sparseView();
+  KroneckerOperator<Sparse, Mat> KP(P, B);
+  VERIFY_IS_APPROX(KP.determinant(), reference_kron<Scalar>(Pd, B).determinant());
+}
+
+// Degenerate sparse factors. An exactly singular factor (a structurally empty
+// column) fails its SparseLU: solve() and inverse() fill with NaN, the
+// determinant is an exact zero. A NaN entry propagates through products, solves
+// and the determinant. An all-zero factor gives zero products, determinant and
+// rank, and an empty materialization.
+void test_kron_sparse_degenerate(Index n1, Index n2) {
+  using Vec = Matrix<double, Dynamic, 1>;
+  using Mat = Matrix<double, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<double>;
+
+  const Mat B = Mat::Random(n2, n2) + 2.0 * Mat::Identity(n2, n2);
+  Vec b = Vec::Random(n1 * n2);
+
+  Mat Zd = Mat(random_sparse_dominant<double>(n1));
+  Zd.col(0).setZero();
+  const Sparse Z = Zd.sparseView();
+  KroneckerOperator<Sparse, Mat> KZ(Z, B);
+  KroneckerOperator<Mat, Sparse> KZr(B, Z);
+  VERIFY(KZ.solve(b).array().isNaN().all());
+  VERIFY(KZr.solve(b).array().isNaN().all());
+  Mat inv = KZ.inverse();
+  VERIFY(inv.array().isNaN().all());
+  VERIFY_IS_EQUAL(KZ.determinant(), 0.0);
+  VERIFY_IS_EQUAL(KZr.determinant(), 0.0);
+
+  Mat Nd = Mat(random_sparse_dominant<double>(n1));
+  Nd(0, 0) = std::numeric_limits<double>::quiet_NaN();
+  const Sparse N = Nd.sparseView();
+  KroneckerOperator<Sparse, Mat> KN(N, B);
+  VERIFY((numext::isnan)(KN.determinant()));
+  VERIFY(!(KN * b).eval().allFinite());
+  VERIFY(!KN.solve(b).allFinite());
+
+  const Sparse O(n1, n1);
+  KroneckerOperator<Sparse, Mat> KO(O, B);
+  VERIFY_IS_EQUAL((KO * b).eval(), Vec(Vec::Zero(n1 * n2)));
+  VERIFY_IS_EQUAL(KO.determinant(), 0.0);
+  VERIFY_IS_EQUAL(KO.rank(), 0);
+  Sparse MO;
+  MO = KO;
+  VERIFY_IS_EQUAL(MO.nonZeros(), 0);
+  VERIFY_IS_EQUAL(MO.rows(), n1 * n2);
+  VERIFY_IS_EQUAL(MO.cols(), n1 * n2);
+}
+
+// A factor handed over uncompressed (reserve + insert) is compressed on
+// construction, and its explicitly stored zeros count as stored entries of the
+// materialization, exactly as in kroneckerProduct().
+void test_kron_sparse_stored_zeros(Index n1, Index n2) {
+  using Vec = Matrix<double, Dynamic, 1>;
+  using Mat = Matrix<double, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<double>;
+
+  Sparse U(n1, n1);
+  U.reserve(VectorXi::Constant(int(n1), 2));
+  for (Index j = 0; j < n1; ++j) {
+    U.insert(j, j) = double(j + 1);
+    U.insert((j + 1) % n1, j) = 0.0;
+  }
+  VERIFY(!U.isCompressed());
+  const Mat B = Mat::Random(n2, n2);
+  KroneckerOperator<Sparse, Mat> K(U, B);
+  VERIFY(K.lhs().isCompressed());
+  VERIFY_IS_EQUAL(K.lhs().nonZeros(), 2 * n1);
+  Mat dense = reference_kron<double>(Mat(U), B);
+  VERIFY_IS_APPROX(Mat(K), dense);
+  Vec x = Vec::Random(dense.cols());
+  VERIFY_IS_APPROX((K * x).eval(), (dense * x).eval());
+  Sparse M;
+  M = K;
+  VERIFY_IS_EQUAL(M.nonZeros(), 2 * n1 * n2 * n2);
+  VERIFY_IS_APPROX(Mat(M), dense);
+}
+
+// Moderate inputs must be bit-identical to the unnormalized SparseLU
+// evaluation: the column ordering is structural, magnitude pivoting is
+// invariant under the uniform power-of-two normalization, and every
+// substitution scales exactly with it.
+template <typename Scalar>
+void test_kron_sparse_solve_bit_identity(Index n1, Index n2) {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using Sparse = SparseMatrix<Scalar>;
+
+  const Sparse S1 = random_sparse_dominant<Scalar>(n1), S2 = random_sparse_dominant<Scalar>(n2);
+  KroneckerOperator<Sparse, Sparse> K(S1, S2);
+  Vec b = Vec::Random(n1 * n2);
+  Vec x = K.solve(b);
+
+  SparseLU<Sparse> luA(S1), luB(S2);
+  const Mat Bm = b.reshaped(n2, n1);
+  const Mat Y = luB.solve(Bm);  // S2^{-1} mat(b)
+  const Mat Yt = Y.transpose();
+  Mat X = luA.solve(Yt).transpose();  // (S1^{-1} Y^T)^T = Y S1^{-T}
+  VERIFY_IS_EQUAL(x, Vec(X.reshaped()));
+}
+
+// An ill-conditioned sparse factor: the tridiagonal Laplacian of order n has
+// condition number ~0.4 n^2, so I_p (x) L is judged by its backward error
+// ||b - K x|| <= n eps ||L||_2 ||x||, with ||L||_2 < 4, not entrywise.
+void test_kron_sparse_solve_laplacian(Index n, Index p) {
+  using Vec = Matrix<double, Dynamic, 1>;
+  using Sparse = SparseMatrix<double>;
+
+  Sparse L(n, n);
+  L.reserve(VectorXi::Constant(int(n), 3));
+  for (Index j = 0; j < n; ++j) {
+    if (j > 0) L.insert(j - 1, j) = -1.0;
+    L.insert(j, j) = 2.0;
+    if (j + 1 < n) L.insert(j + 1, j) = -1.0;
+  }
+  auto K = makeKroneckerOperator(Vec::Ones(p).asDiagonal(), L);
+  Vec b = Vec::Random(n * p);
+  Vec x = K.solve(b);
+  Vec r = b - K * x;
+  VERIFY(r.norm() <= double(n) * NumTraits<double>::epsilon() * 4.0 * x.norm());
+}
+
+// The decomposition family on a sparse factor (materialized densely for the
+// factor decompositions): eigen-residual, SVD reconstruction, rank and
+// minimum-norm least squares against the dense references.
+template <typename Scalar>
+void test_kron_sparse_decompositions(Index n1, Index n2) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Complex = std::complex<RealScalar>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using CMat = Matrix<Complex, Dynamic, Dynamic>;
+  using CVec = Matrix<Complex, Dynamic, 1>;
+  using Sparse = SparseMatrix<Scalar>;
+
+  const Sparse S = random_sparse_dominant<Scalar>(n1);
+  Mat B = Mat::Random(n2, n2);
+  KroneckerOperator<Sparse, Mat> K(S, B);
+  Mat dense = reference_kron<Scalar>(Mat(S), B);
+
+  CVec lambda = K.eigenvalues();
+  CMat V = K.eigenvectors();
+  VERIFY_IS_APPROX((dense.template cast<Complex>() * V).eval(), (V * lambda.asDiagonal()).eval());
+
+  Matrix<RealScalar, Dynamic, 1> sv = K.singularValues();
+  Mat U = K.matrixU(), W = K.matrixV();
+  VERIFY_IS_APPROX((U * sv.template cast<Scalar>().asDiagonal() * W.adjoint()).eval(), dense);
+
+  VERIFY_IS_EQUAL(K.rank(), dense.completeOrthogonalDecomposition().rank());
+  Vec b = Vec::Random(n1 * n2);
+  VERIFY_IS_APPROX(K.leastSquaresSolve(b), dense.completeOrthogonalDecomposition().solve(b).eval());
+}
+
+// The overflow-hardening contract through sparse factors: products and solves
+// with extreme magnitudes stay finite whenever the true result is
+// representable, and the balanced SparseLU determinant survives partial
+// products that overflow on their own.
+void test_kron_sparse_extreme_scale() {
+  using Vec = Matrix<double, Dynamic, 1>;
+  using Mat = Matrix<double, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<double>;
+
+  // [1e-200] (x) [1e200] is the identity; the unprotected B X = 1e400 overflows.
+  Mat Sd(1, 1), B(1, 1);
+  Sd << 1e-200;
+  B << 1e200;
+  const Sparse S = Sd.sparseView();
+  KroneckerOperator<Sparse, Mat> K(S, B);
+  KroneckerOperator<Mat, Sparse> K2(B, S);  // the sparse factor on the applied side
+  Vec x(1);
+  x << 1e200;
+  Vec y = K * x;
+  VERIFY(y.allFinite());
+  VERIFY_IS_APPROX(y[0], 1e200);
+  y = K2 * x;
+  VERIFY(y.allFinite());
+  VERIFY_IS_APPROX(y[0], 1e200);
+
+  // Same magnitudes through solve(), the sparse factor factorized in the
+  // normalized frame.
+  Vec b(1);
+  b << 1e200;
+  Vec xs = K.solve(b);
+  VERIFY(xs.allFinite());
+  VERIFY_IS_APPROX(xs[0], 1e200);
+  xs = K2.solve(b);
+  VERIFY(xs.allFinite());
+  VERIFY_IS_APPROX(xs[0], 1e200);
+
+  // [[0, 1e-200], [1e-200, 0]] (x) [1e200] is the 2 x 2 exchange matrix: the
+  // scaled factorization pivots off the diagonal and every intermediate stays
+  // finite through product and solve.
+  Mat Ed(2, 2);
+  Ed << 0.0, 1e-200, 1e-200, 0.0;
+  const Sparse E = Ed.sparseView();
+  KroneckerOperator<Sparse, Mat> KE(E, B);
+  Vec x2(2), y2(2);
+  x2 << 1e200, 2e200;
+  y2 = KE * x2;
+  VERIFY(y2.allFinite());
+  VERIFY_IS_APPROX(y2, Vec(x2.reverse()));
+  Vec xe = KE.solve(x2);
+  VERIFY(xe.allFinite());
+  VERIFY_IS_APPROX(xe, Vec(x2.reverse()));
+
+  // det([1e200])^2 = 1e400 overflows on its own, yet the determinant of
+  // [1e200] (x) diag(1e-100, 1e-100) is 1e200 -- through the SparseLU pivots.
+  Mat A1(1, 1);
+  A1 << 1e200;
+  Vec d(2);
+  d << 1e-100, 1e-100;
+  const Sparse SA = A1.sparseView(), SB = Mat(d.asDiagonal()).sparseView();
+  KroneckerOperator<Sparse, Sparse> Kd(SA, SB);
+  VERIFY_IS_APPROX(Kd.determinant(), 1e200);
+}
+
+// Mixed-scalar promotion through a sparse factor on either side: a real
+// operator applied to a complex right-hand side runs in the promoted scalar.
+template <typename RealScalar>
+void test_kron_sparse_mixed_scalar(Index n1, Index m2, Index n2) {
+  using Complex = std::complex<RealScalar>;
+  using RMat = Matrix<RealScalar, Dynamic, Dynamic>;
+  using CVec = Matrix<Complex, Dynamic, 1>;
+  using CMat = Matrix<Complex, Dynamic, Dynamic>;
+  using RSparse = SparseMatrix<RealScalar>;
+
+  const RSparse S = random_sparse<RealScalar>(n1, n1);
+  RMat B = RMat::Random(m2, n2);
+  KroneckerOperator<RSparse, RMat> KL(S, B);
+  KroneckerOperator<RMat, RSparse> KR(B, S);
+  CMat denseL = reference_kron<RealScalar>(RMat(S), B).template cast<Complex>();
+  CMat denseR = reference_kron<RealScalar>(B, RMat(S)).template cast<Complex>();
+
+  CVec x = CVec::Random(n1 * n2);
+  CVec y = KL * x;
+  VERIFY_IS_APPROX(y, (denseL * x).eval());
+  CVec y0 = CVec::Random(n1 * m2);
+  y = y0;
+  y.noalias() += KL * x;
+  VERIFY_IS_APPROX(y, (y0 + denseL * x).eval());
+  CVec xr = CVec::Random(n2 * n1);
+  CVec yr = KR * xr;
+  VERIFY_IS_APPROX(yr, (denseR * xr).eval());
+}
+
+// Matrix-free CG through a sparse-factor operator: an SPD sparse factor
+// tensored with an SPD dense factor is SPD.
+void test_kron_sparse_matrix_free_cg(Index n1, Index n2) {
+  using Vec = Matrix<double, Dynamic, 1>;
+  using Mat = Matrix<double, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<double>;
+
+  const Mat R = Mat(random_sparse<double>(n1, n1));
+  const Mat Sd = R * R.transpose() + double(n1) * Mat::Identity(n1, n1);
+  const Sparse S = Sd.sparseView();
+  Mat Br = Mat::Random(n2, n2);
+  Mat B = Br * Br.adjoint() + double(n2) * Mat::Identity(n2, n2);
+  KroneckerOperator<Sparse, Mat> K(S, B);
+  Mat dense = reference_kron<double>(Sd, B);
+
+  Vec b = Vec::Random(n1 * n2);
+  ConjugateGradient<KroneckerOperator<Sparse, Mat>, Lower | Upper, IdentityPreconditioner> cg;
+  cg.compute(K);
+  Vec x = cg.solve(b);
+  VERIFY(cg.info() == Success);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+}
+
+template <typename Scalar, int Options>
+void test_kron_sparse_determinant_subnormal(const Scalar& phase) {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Mat = Matrix<Scalar, 2, 2>;
+  using Sparse = SparseMatrix<Scalar, Options>;
+  const Real normalMin = (std::numeric_limits<Real>::min)();
+  const Real large = Real(1) / normalMin;
+  Matrix<Scalar, 1, 1> b;
+  b << Scalar(1);
+
+  // Scaling this whole factor down would discard its small, essential pivot.
+  Mat a = Mat::Zero();
+  Sparse wide(2, 2);
+  wide.insert(0, 0) = Scalar(large);
+  wide.insert(1, 1) = Scalar(normalMin);
+  VERIFY_IS_EQUAL(makeKroneckerOperator(wide, b).determinant(), Scalar(1));
+
+  if (underflowProbe<Real>() == Real(0) || ScopedFlushToZero::hardwareFlushesSubnormalInputs()) return;
+  const Real small = normalMin / Real(16);
+  b << Scalar(large);
+  const Real tolerance = Real(64) * NumTraits<Real>::epsilon();
+  Sparse sparseA(2, 2), singular(2, 2);
+  for (int swap = 0; swap < 2; ++swap) {
+    a << Real(2) * small * phase, small * phase, small * phase, Real(2) * small * phase;
+    if (swap) a.row(0).swap(a.row(1));
+    // Insert explicitly: sparseView's complex magnitude test can underflow.
+    sparseA.setZero();
+    for (Index j = 0; j < 2; ++j)
+      for (Index i = 0; i < 2; ++i) sparseA.insert(i, j) = a(i, j);
+    // (small * large)^2 * det([[2,1],[1,2]]) = 3/256, exactly.
+    const Scalar expected = Scalar(swap ? -Real(3) / Real(256) : Real(3) / Real(256)) * phase * phase;
+    const Scalar left = makeKroneckerOperator(sparseA, b).determinant();
+    const Scalar right = makeKroneckerOperator(b, sparseA).determinant();
+    VERIFY((numext::isfinite)(left));
+    VERIFY((numext::isfinite)(right));
+    VERIFY(numext::abs(left - expected) <= tolerance * numext::abs(expected));
+    VERIFY(numext::abs(right - expected) <= tolerance * numext::abs(expected));
+
+    const DiagonalMatrix<Scalar, 2> identityScale(Matrix<Scalar, 2, 1>::Constant(Scalar(large)));
+    const Scalar repeated = makeKroneckerOperator(sparseA, identityScale).determinant();
+    VERIFY((numext::isfinite)(repeated));
+    VERIFY(numext::abs(repeated - expected * expected) <= tolerance * numext::abs(expected * expected));
+
+    singular = sparseA;
+    for (Index j = 0; j < 2; ++j) singular.coeffRef(1, j) = singular.coeff(0, j);
+    VERIFY_IS_EQUAL(makeKroneckerOperator(singular, b).determinant(), Scalar(0));
+  }
+
+  // Non-dyadic entries near tiny = min * 2^-(digits/2), which carry about
+  // digits/2 bits: eliminating there would lose the other half, the exact
+  // scale-up does not. The reference is the determinant of the stored data.
+  // ARMv7 NEON flushes subnormal inputs regardless of FPSCR.FZ: the packet
+  // exponent bound then sees a zero factor, skips the scale-up, and the
+  // elimination keeps only those digits/2 bits.
+  if (!subnormalDivisionIsExact<Real>()) return;
+  const Real tiny = std::ldexp(normalMin, -(std::numeric_limits<Real>::digits / 2));
+  const Real huge = std::ldexp(Real(1), std::numeric_limits<Real>::max_exponent - 1);
+  a << Real(4.1), Real(1.3), Real(1.1), Real(5.3);
+  a *= Scalar(tiny) * phase;
+  sparseA.setZero();
+  for (Index j = 0; j < 2; ++j)
+    for (Index i = 0; i < 2; ++i) sparseA.insert(i, j) = a(i, j);
+  const Mat stored = a / tiny;  // exact
+  const Scalar expectedStored = stored.determinant() * Scalar((tiny * huge) * (tiny * huge));
+  b << Scalar(huge);
+  const Scalar precise = makeKroneckerOperator(sparseA, b).determinant();
+  VERIFY(numext::abs(precise - expectedStored) <= tolerance * numext::abs(expectedStored));
+}
+
+template <typename ProductScalar, typename Lhs, typename Rhs>
+void check_kron_sparse_nonfinite(const KroneckerOperator<Lhs, Rhs>& k) {
+  using Scalar = typename Lhs::Scalar;
+  using Real = typename NumTraits<ProductScalar>::Real;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using ProductMatrix = Matrix<ProductScalar, Dynamic, Dynamic, RowMajor>;
+  SparseMatrix<Scalar> sparse;
+  sparse = k;
+  const Mat dense = k;
+  Mat coefficients(k.rows(), k.cols());
+  for (Index j = 0; j < k.cols(); ++j)
+    for (Index i = 0; i < k.rows(); ++i) coefficients(i, j) = k.coeff(i, j);
+  VERIFY_IS_CWISE_EQUAL(coefficients.realView(), dense.realView());
+  VERIFY_IS_CWISE_EQUAL(Mat(sparse).realView(), dense.realView());
+
+  ProductMatrix x = ProductMatrix::Ones(k.cols(), 3);
+  x(0, 1) = ProductScalar(NumTraits<Real>::quiet_NaN());
+  x(k.cols() - 1, 2) = ProductScalar(NumTraits<Real>::infinity());
+  // Vector products keep the reference independent of complex packet Inf/NaN handling.
+  ProductMatrix expected(k.rows(), x.cols());
+  for (Index j = 0; j < x.cols(); ++j) expected.col(j) = sparse * x.col(j);
+  ProductMatrix actual = k * x;
+  VERIFY_IS_CWISE_EQUAL(actual.realView(), expected.realView());
+  actual.setConstant(ProductScalar(3));
+  actual.noalias() += k * x;
+  const ProductMatrix added = (expected.array() + ProductScalar(3)).matrix();
+  VERIFY_IS_CWISE_EQUAL(actual.realView(), added.realView());
+  actual.setConstant(ProductScalar(3));
+  actual.noalias() -= k * x;
+  const ProductMatrix subtracted = (ProductScalar(3) - expected.array()).matrix();
+  VERIFY_IS_CWISE_EQUAL(actual.realView(), subtracted.realView());
+}
+
+template <typename Scalar, int Options>
+void test_kron_sparse_nonfinite() {
+  using Real = typename NumTraits<Scalar>::Real;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using Sparse = SparseMatrix<Scalar, Options>;
+  const Sparse empty(1, 1);
+  Sparse storedZero(1, 1);
+  storedZero.insert(0, 0) = Scalar(0);
+  Sparse pattern(3, 3);
+  pattern.insert(0, 0) = Scalar(1);
+  pattern.insert(2, 0) = Scalar(0);
+  pattern.insert(0, 2) = Scalar(2);  // Row 1 and column 1 are structurally empty.
+
+  Mat finite = Mat::Ones(2, 2);
+  check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(finite, pattern));
+  check_kron_sparse_nonfinite<std::complex<Real>>(makeKroneckerOperator(finite, pattern));
+  for (Real special : {NumTraits<Real>::infinity(), NumTraits<Real>::quiet_NaN()}) {
+    const Mat single = Mat::Constant(1, 1, Scalar(special));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(single, empty));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(empty, single));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(single, storedZero));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(storedZero, single));
+    Mat nonfinite = finite;
+    nonfinite(0, 0) = Scalar(special);
+    const Sparse sparseNonfinite = nonfinite.sparseView();
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(nonfinite, pattern));
+    check_kron_sparse_nonfinite<std::complex<Real>>(makeKroneckerOperator(nonfinite, pattern));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(pattern, nonfinite));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(sparseNonfinite, pattern));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(pattern, sparseNonfinite));
+    const DiagonalMatrix<Scalar, 2> diagonal(nonfinite.diagonal());
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(diagonal, pattern));
+    check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(pattern, diagonal));
+    // Without a sparse factor the product stays on the GEMM path, which must
+    // agree with the materialization as well. Real scalars only: the scalar
+    // reference does not fix the Inf/NaN components of a complex packet product.
+    if (!NumTraits<Scalar>::IsComplex) {
+      check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(diagonal, nonfinite));
+      check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(nonfinite, diagonal));
+      check_kron_sparse_nonfinite<Scalar>(makeKroneckerOperator(diagonal, diagonal));
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(structured_kronecker) {
+  for (int i = 0; i < g_repeat; ++i) {
+    // Products, dense assignment, coefficient access across factor shapes.
+    CALL_SUBTEST_1((test_kron_product<double>(1, 1, 1, 1)));
+    CALL_SUBTEST_1((test_kron_product<double>(2, 3, 3, 2)));
+    CALL_SUBTEST_1((test_kron_product<double>(4, 4, 5, 5)));
+    CALL_SUBTEST_1((test_kron_product<double>(8, 3, 2, 7)));
+    CALL_SUBTEST_1((test_kron_product<double>(1, 6, 7, 1)));  // vector-shaped factors
+    CALL_SUBTEST_1((test_kron_product<float>(5, 4, 4, 5)));
+    CALL_SUBTEST_1((test_kron_product<std::complex<double>>(3, 5, 4, 2)));
+    CALL_SUBTEST_1((test_kron_product<std::complex<float>>(4, 3, 3, 4)));
+
+    // Transposition family.
+    CALL_SUBTEST_2((test_kron_transpose<double>(4, 6, 5, 3)));
+    CALL_SUBTEST_2((test_kron_transpose<std::complex<double>>(3, 4, 5, 2)));
+
+    // Direct solves through factor LU.
+    CALL_SUBTEST_3((test_kron_solve<double>(1, 1)));
+    CALL_SUBTEST_3((test_kron_solve<double>(4, 7)));
+    CALL_SUBTEST_3((test_kron_solve<double>(9, 5)));
+    CALL_SUBTEST_3((test_kron_solve<float>(5, 4)));
+    CALL_SUBTEST_3((test_kron_solve<std::complex<double>>(6, 4)));
+    CALL_SUBTEST_3(test_kron_solve_normalized());
+    CALL_SUBTEST_3((test_kron_solve_bit_identity<double>(4, 3)));
+    CALL_SUBTEST_3((test_kron_solve_bit_identity<std::complex<double>>(3, 4)));
+
+    // Minimum-norm least squares through factor pseudo-inverses.
+    CALL_SUBTEST_3((test_kron_least_squares<double>(8, 5, 7, 4)));  // tall x tall
+    CALL_SUBTEST_3((test_kron_least_squares<double>(8, 5, 3, 6)));  // tall x wide
+    CALL_SUBTEST_3((test_kron_least_squares<std::complex<double>>(6, 4, 5, 3)));
+    CALL_SUBTEST_3((test_kron_least_squares_rank_deficient<double>(6, 4, 5, 3)));
+    CALL_SUBTEST_3((test_kron_least_squares_rank_deficient<std::complex<double>>(5, 3, 4, 4)));
+
+    // Eigendecomposition, SVD, inverse, determinant.
+    CALL_SUBTEST_4((test_kron_eigen<double>(4, 5)));
+    CALL_SUBTEST_4((test_kron_eigen<double>(1, 6)));
+    CALL_SUBTEST_4((test_kron_eigen<std::complex<double>>(3, 4)));
+    CALL_SUBTEST_4((test_kron_svd<double>(4, 4, 5, 5)));
+    CALL_SUBTEST_4((test_kron_svd<double>(6, 4, 3, 5)));  // rectangular: structural zeros
+    CALL_SUBTEST_4((test_kron_svd<std::complex<double>>(4, 3, 4, 4)));
+    CALL_SUBTEST_4((test_kron_svd<float>(4, 4, 4, 4)));
+    CALL_SUBTEST_4((test_kron_inverse_determinant<double>(4, 5)));
+    CALL_SUBTEST_4((test_kron_inverse_determinant<std::complex<double>>(3, 4)));
+
+    // Matrix-free iterative solve and fixed-size factors.
+    CALL_SUBTEST_5((test_kron_matrix_free_cg<double>(6, 7)));
+    CALL_SUBTEST_5((test_kron_fixed<double, 3, 4, 2, 5>()));
+    CALL_SUBTEST_5((test_kron_fixed<std::complex<float>, 2, 3, 3, 2>()));
+    CALL_SUBTEST_5((test_kron_fixed_solve<double, 2, 3>()));
+    CALL_SUBTEST_5((test_kron_fixed_solve<std::complex<double>, 3, 2>()));
+
+    // Lifetime and aliasing of the product expression, mixed-scalar promotion.
+    CALL_SUBTEST_6((test_kron_aliased_product<double>(3, 4)));
+    CALL_SUBTEST_6((test_kron_aliased_product<std::complex<double>>(4, 3)));
+    CALL_SUBTEST_6((test_kron_aliased_resize<double>(4, 3, 2, 5)));
+    CALL_SUBTEST_6((test_kron_aliased_resize<std::complex<double>>(2, 4, 5, 3)));
+    CALL_SUBTEST_6((test_kron_delayed_product<double>(4, 3, 2, 5)));
+    CALL_SUBTEST_6((test_kron_delayed_product<std::complex<float>>(3, 3, 4, 2)));
+    CALL_SUBTEST_6((test_kron_mixed_scalar<double>(4, 3, 3, 5)));
+    CALL_SUBTEST_6((test_kron_mixed_scalar<float>(3, 4, 2, 3)));
+
+    // Numerical boundaries: product-level rank truncation, balanced determinant,
+    // overflow-safe product scaling and ratio-space rank thresholds.
+    CALL_SUBTEST_7(test_kron_product_level_rank());
+    CALL_SUBTEST_7(test_kron_determinant_scaling());
+    CALL_SUBTEST_7(test_kron_extreme_scale_product());
+    CALL_SUBTEST_7(test_kron_extreme_scale_complex());
+    CALL_SUBTEST_7(test_kron_rank_ratio_threshold());
+    CALL_SUBTEST_7(test_kron_rank_min_normal_clamp());
+
+    // Diagonal and identity factors: products, transposition family,
+    // mixed-scalar promotion, fixed sizes.
+    CALL_SUBTEST_8((test_kron_diag_product<double>(4, 5, 3)));
+    CALL_SUBTEST_8((test_kron_diag_product<float>(3, 4, 4)));
+    CALL_SUBTEST_8((test_kron_diag_product<std::complex<double>>(3, 4, 2)));
+    CALL_SUBTEST_8((test_kron_identity<double>(5, 4, 3)));
+    CALL_SUBTEST_8((test_kron_identity<std::complex<double>>(3, 3, 4)));
+    CALL_SUBTEST_8((test_kron_diag_transpose<double>(4, 5, 3)));
+    CALL_SUBTEST_8((test_kron_diag_transpose<std::complex<double>>(3, 4, 5)));
+    CALL_SUBTEST_8((test_kron_diag_mixed_scalar<double>(4, 3, 5)));
+    CALL_SUBTEST_8((test_kron_diag_mixed_scalar<float>(3, 4, 2)));
+    CALL_SUBTEST_8((test_kron_diag_fixed<double, 3, 2, 4>()));
+    CALL_SUBTEST_8((test_kron_diag_fixed<std::complex<float>, 2, 3, 3>()));
+
+    // Diagonal factors through the solvers, inverse/determinant, the
+    // decomposition family, extreme scales and matrix-free CG.
+    CALL_SUBTEST_9((test_kron_diag_solve<double>(4, 7)));
+    CALL_SUBTEST_9((test_kron_diag_solve<float>(5, 4)));
+    CALL_SUBTEST_9((test_kron_diag_solve<std::complex<double>>(6, 4)));
+    CALL_SUBTEST_9((test_kron_diag_inverse_determinant<double>(4, 5)));
+    CALL_SUBTEST_9((test_kron_diag_inverse_determinant<std::complex<double>>(3, 4)));
+    CALL_SUBTEST_9((test_kron_diag_decompositions<double>(4, 5)));
+    CALL_SUBTEST_9((test_kron_diag_decompositions<std::complex<double>>(3, 4)));
+    CALL_SUBTEST_9(test_kron_diag_extreme_scale());
+    CALL_SUBTEST_9(test_kron_diag_matrix_free_cg(6, 7));
+
+    // Sparse factors: products, materialization, the identity-Kronecker
+    // operators, the transposition family, mixed-scalar promotion.
+    CALL_SUBTEST_10((test_kron_sparse_product<double>(4, 5, 3, 4)));
+    CALL_SUBTEST_10((test_kron_sparse_product<float>(3, 4, 4, 2)));
+    CALL_SUBTEST_10((test_kron_sparse_product<std::complex<double>>(3, 4, 2, 3)));
+    CALL_SUBTEST_10((test_kron_sparse_product<double>(1, 1, 1, 1)));
+    CALL_SUBTEST_10((test_kron_sparse_materialize<double>(4, 5, 3, 4)));
+    CALL_SUBTEST_10((test_kron_sparse_materialize<std::complex<float>>(3, 2, 4, 3)));
+    CALL_SUBTEST_10((test_kron_sparse_identity<double>(5, 4, 3, 2)));
+    CALL_SUBTEST_10((test_kron_sparse_identity<std::complex<double>>(3, 3, 4, 2)));
+    CALL_SUBTEST_10((test_kron_sparse_transpose<double>(4, 5, 3, 2)));
+    CALL_SUBTEST_10((test_kron_sparse_transpose<std::complex<double>>(3, 4, 2, 5)));
+    CALL_SUBTEST_10((test_kron_sparse_mixed_scalar<double>(4, 3, 5)));
+    CALL_SUBTEST_10((test_kron_sparse_mixed_scalar<float>(3, 4, 2)));
+    CALL_SUBTEST_10(test_kron_sparse_stored_zeros(4, 3));
+
+    // Sparse factors through the solvers, inverse/determinant, the
+    // decomposition family, extreme scales and matrix-free CG.
+    CALL_SUBTEST_11((test_kron_sparse_solve<double>(4, 7)));
+    CALL_SUBTEST_11((test_kron_sparse_solve<float>(5, 4)));
+    CALL_SUBTEST_11((test_kron_sparse_solve<std::complex<double>>(6, 4)));
+    CALL_SUBTEST_11((test_kron_sparse_inverse_determinant<double>(4, 5)));
+    CALL_SUBTEST_11((test_kron_sparse_inverse_determinant<std::complex<double>>(3, 4)));
+    CALL_SUBTEST_11((test_kron_sparse_decompositions<double>(4, 5)));
+    CALL_SUBTEST_11((test_kron_sparse_decompositions<std::complex<double>>(3, 4)));
+    CALL_SUBTEST_11((test_kron_sparse_solve_bit_identity<double>(4, 3)));
+    CALL_SUBTEST_11((test_kron_sparse_solve_bit_identity<std::complex<double>>(3, 4)));
+    CALL_SUBTEST_11(test_kron_sparse_solve_laplacian(64, 4));
+    CALL_SUBTEST_11(test_kron_sparse_degenerate(4, 3));
+    CALL_SUBTEST_11(test_kron_sparse_extreme_scale());
+    CALL_SUBTEST_11(test_kron_sparse_matrix_free_cg(6, 7));
+
+    CALL_SUBTEST_12((test_kron_sparse_determinant_subnormal<float, ColMajor>(1)));
+    CALL_SUBTEST_12((test_kron_sparse_determinant_subnormal<double, RowMajor>(1)));
+    CALL_SUBTEST_12((test_kron_sparse_determinant_subnormal<std::complex<float>, RowMajor>({1, 1})));
+    CALL_SUBTEST_12((test_kron_sparse_determinant_subnormal<std::complex<double>, ColMajor>({1, 1})));
+
+    CALL_SUBTEST_13((test_kron_sparse_nonfinite<float, ColMajor>()));
+    CALL_SUBTEST_13((test_kron_sparse_nonfinite<double, RowMajor>()));
+    CALL_SUBTEST_13((test_kron_sparse_nonfinite<std::complex<float>, RowMajor>()));
+    CALL_SUBTEST_13((test_kron_sparse_nonfinite<std::complex<double>, ColMajor>()));
+  }
+}
diff --git a/contrib/test/structured_matrices.cpp b/contrib/test/structured_matrices.cpp
new file mode 100644
index 0000000..6a9deaf
--- /dev/null
+++ b/contrib/test/structured_matrices.cpp
@@ -0,0 +1,1922 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Reference dense circulant built straight from the generating column, so that the
+// fast (FFT) product is validated against an independent construction of the matrix.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_circulant(const Matrix<Scalar, Dynamic, 1>& c) {
+  const Index n = c.size();
+  Matrix<Scalar, Dynamic, Dynamic> dense(n, n);
+  for (Index j = 0; j < n; ++j)
+    for (Index i = 0; i < n; ++i) {
+      Index k = i - j;
+      if (k < 0) k += n;
+      dense(i, j) = c[k];
+    }
+  return dense;
+}
+
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_toeplitz(const Matrix<Scalar, Dynamic, 1>& c,
+                                                    const Matrix<Scalar, Dynamic, 1>& r) {
+  const Index m = c.size(), n = r.size();
+  Matrix<Scalar, Dynamic, Dynamic> dense(m, n);
+  for (Index j = 0; j < n; ++j)
+    for (Index i = 0; i < m; ++i) dense(i, j) = (i >= j) ? c[i - j] : r[j - i];
+  return dense;
+}
+
+template <typename Scalar>
+void test_circulant_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  // The operator agrees with the independently-built dense matrix, both through
+  // coeff access and assigned to a dense matrix via its evaluator.
+  Mat Cd = C;
+  VERIFY_IS_EQUAL(Cd, dense);
+  Matrix<Scalar, Dynamic, Dynamic, RowMajor> rowMajor = C;
+  VERIFY_IS_EQUAL(rowMajor, dense);
+  rowMajor += C;
+  VERIFY_IS_EQUAL(rowMajor, (Scalar(2) * dense).eval());
+  rowMajor -= C;
+  VERIFY_IS_EQUAL(rowMajor, dense);
+  for (Index t = 0; t < (std::min)(n, Index(5)); ++t) {
+    Index i = internal::random<Index>(0, n - 1), j = internal::random<Index>(0, n - 1);
+    VERIFY_IS_APPROX(C.coeff(i, j), dense(i, j));
+  }
+
+  // Fast matrix-vector and matrix-matrix products.
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((C * x).eval(), (dense * x).eval());
+
+  Mat X = Mat::Random(n, 3);
+  VERIFY_IS_APPROX((C * X).eval(), (dense * X).eval());
+
+  // Accumulation forms exercised by the iterative solvers.
+  Vec y = Vec::Random(n);
+  Vec y0 = y;
+  y.noalias() += C * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+}
+
+template <typename Scalar>
+void test_circulant_solve(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Diagonally dominant => well conditioned, so the direct FFT solve is accurate.
+  Vec c = Vec::Random(n);
+  c[0] += Scalar(RealScalar(2 * n));
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  Vec b = Vec::Random(n);
+  Vec x = C.solve(b);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+
+  // Multiple right-hand sides at once.
+  Mat B = Mat::Random(n, 4);
+  Mat Xs = C.solve(B);
+  VERIFY_IS_APPROX((dense * Xs).eval(), B);
+}
+
+// The precomputed symbol holds the eigenvalues of the circulant matrix:
+// C * f_k = symbol[k] * f_k, with f_k the k-th column of the inverse DFT matrix.
+template <typename Scalar>
+void test_circulant_symbol(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Complex, Dynamic, 1> ComplexVec;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  VERIFY_IS_EQUAL(C.symbol().size(), n);
+  Matrix<Complex, Dynamic, Dynamic> denseC = reference_circulant<Scalar>(c).template cast<Complex>();
+
+  const Index step = numext::maxi<Index>(n / 4, 1);
+  for (Index k = 0; k < n; k += step) {
+    ComplexVec f(n);
+    for (Index j = 0; j < n; ++j) f[j] = std::polar(RealScalar(1), RealScalar(2 * EIGEN_PI * j * k) / RealScalar(n));
+    VERIFY_IS_APPROX((denseC * f).eval(), (C.symbol()[k] * f).eval());
+  }
+}
+
+template <typename Scalar>
+void test_toeplitz_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(m), r = Vec::Random(n);
+  r[0] = c[0];  // diagonal entry; r[0] is ignored anyway
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = reference_toeplitz<Scalar>(c, r);
+
+  Mat Td = T;
+  VERIFY_IS_EQUAL(Td, dense);
+  Matrix<Scalar, Dynamic, Dynamic, RowMajor> rowMajor = T;
+  VERIFY_IS_EQUAL(rowMajor, dense);
+  rowMajor += T;
+  VERIFY_IS_EQUAL(rowMajor, (Scalar(2) * dense).eval());
+  rowMajor -= T;
+  VERIFY_IS_EQUAL(rowMajor, dense);
+
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((T * x).eval(), (dense * x).eval());
+
+  Mat X = Mat::Random(n, 3);
+  VERIFY_IS_APPROX((T * X).eval(), (dense * X).eval());
+}
+
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_hankel(const Matrix<Scalar, Dynamic, 1>& h, Index m, Index n) {
+  Matrix<Scalar, Dynamic, Dynamic> dense(m, n);
+  for (Index j = 0; j < n; ++j)
+    for (Index i = 0; i < m; ++i) dense(i, j) = h[i + j];
+  return dense;
+}
+
+template <typename Scalar>
+void test_hankel_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(m + n - 1);
+  Hankel<Scalar> H(h.head(m), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, m, n);
+
+  // The stored generating sequence is rebuilt exactly from column + last row.
+  VERIFY_IS_EQUAL(H.generator(), h);
+  VERIFY_IS_EQUAL(Vec(H.column()), Vec(h.head(m)));
+  VERIFY_IS_EQUAL(Vec(H.lastRow()), Vec(h.tail(n)));
+
+  Mat Hd = H;
+  VERIFY_IS_EQUAL(Hd, dense);
+  Matrix<Scalar, Dynamic, Dynamic, RowMajor> rowMajor = H;
+  VERIFY_IS_EQUAL(rowMajor, dense);
+  rowMajor += H;
+  VERIFY_IS_EQUAL(rowMajor, (Scalar(2) * dense).eval());
+  rowMajor -= H;
+  VERIFY_IS_EQUAL(rowMajor, dense);
+  for (Index t = 0; t < (std::min)(m, Index(5)); ++t) {
+    Index i = internal::random<Index>(0, m - 1), j = internal::random<Index>(0, n - 1);
+    VERIFY_IS_APPROX(H.coeff(i, j), dense(i, j));
+  }
+
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((H * x).eval(), (dense * x).eval());
+
+  Mat X = Mat::Random(n, 3);
+  VERIFY_IS_APPROX((H * X).eval(), (dense * X).eval());
+
+  // Accumulation forms exercised by the iterative solvers.
+  Vec y = Vec::Random(m);
+  Vec y0 = y;
+  y.noalias() += H * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+}
+
+// Reviewer regression (MR 2688): applying an exact 40x40 exchange matrix (as a
+// Hankel operator, FFT tier) to a vector of huge finite entries must return the
+// unchanged finite values, not NaNs: the FFT intermediates overflow unless each
+// column is scaled by an exact power of two derived from the column's and the
+// symbol's magnitudes.
+void test_hankel_fft_overflow() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const Index n = 40;
+  const double huge = (std::numeric_limits<double>::max)() / 16;
+
+  // H(i,j) = h[i+j] with h = e_{n-1} is the exchange matrix (anti-identity).
+  Vec h = Vec::Zero(2 * n - 1);
+  h[n - 1] = 1.0;
+  Hankel<double> H(h.head(n), h.tail(n));
+
+  Vec x = Vec::Constant(n, huge);
+  Vec y = H * x;
+  VERIFY(y.allFinite());
+  VERIFY_IS_APPROX((y / huge).eval(), Vec::Ones(n).eval());  // y == x.reverse() == x
+
+  // A huge generator makes a huge symbol; its exponent must be scaled out too.
+  Vec hh = Vec::Zero(2 * n - 1);
+  hh[n - 1] = huge;
+  Hankel<double> Hh(hh.head(n), hh.tail(n));
+  Vec z = Hh * Vec::Ones(n);
+  VERIFY(z.allFinite());
+  VERIFY_IS_APPROX((z / huge).eval(), Vec::Ones(n).eval());
+}
+
+// The scaling exponents are derived from component-wise magnitudes: a finite
+// complex value near the overflow threshold has a non-representable modulus,
+// which would otherwise disable the scaling and turn an exactly representable
+// product into NaN.
+template <typename RealScalar>
+void test_hankel_fft_complex_boundary(Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  const RealScalar kFftRoundTripTol = RealScalar(100) * NumTraits<RealScalar>::epsilon();
+  const RealScalar big = RealScalar(0.75) * (std::numeric_limits<RealScalar>::max)();
+
+  // Exchange matrix with a complex generator: the product returns the reversed
+  // right-hand side -- the input itself, being constant -- even though |x_k|
+  // overflows.
+  CVec h = CVec::Zero(2 * n - 1);
+  h[n - 1] = Complex(1);
+  Hankel<Complex> H(h.head(n), h.tail(n));
+  CVec x = CVec::Constant(n, Complex(big, big));
+  CVec y = H * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / big).maxCoeff() <= kFftRoundTripTol);
+
+  // A real exchange operator applied to the same complex right-hand side takes
+  // the mixed-scalar product path.
+  RVec hr = RVec::Zero(2 * n - 1);
+  hr[n - 1] = RealScalar(1);
+  Hankel<RealScalar> Hr(hr.head(n), hr.tail(n));
+  y = Hr * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / big).maxCoeff() <= kFftRoundTripTol);
+}
+
+// transpose()/conjugate()/adjoint() return owning temporaries (and so does
+// makeHankel), so the product expression must nest the structured operand by
+// value: a delayed-evaluated expression has to outlive the temporary operator it
+// was built from. The static check pins the value nesting; the behavioral checks
+// would read freed memory if the product held a reference instead.
+template <typename Scalar>
+void test_hankel_delayed_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<Hankel<Scalar>>::type>::value);
+
+  Vec h = Vec::Random(m + n - 1);
+  Hankel<Scalar> H(h.head(m), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, m, n);
+
+  Vec y = Vec::Random(m);
+  auto expr = H.adjoint() * y;        // the adjoint temporary dies with the full expression
+  Vec scribble = Vec::Random(m + n);  // reuses the temporary's freed heap storage
+  Vec x = expr;
+  VERIFY_IS_APPROX(x, (dense.adjoint() * y).eval());
+  VERIFY_IS_EQUAL(scribble.size(), m + n);
+
+  Vec x2 = Vec::Random(n);
+  auto expr2 = makeHankel(h.head(m).eval(), h.tail(n).eval()) * x2;  // factory-returned temporary
+  Vec scribble2 = Vec::Random(m + n);
+  Vec y2 = expr2;
+  VERIFY_IS_APPROX(y2, (dense * x2).eval());
+  VERIFY_IS_EQUAL(scribble2.size(), m + n);
+}
+
+// The products carry the default product tag, so plain assignment materializes a
+// temporary exactly like a dense product and an aliased right-hand side is safe:
+// without it, x = H * x would read a zeroed right-hand side and x += H * x would
+// interleave destination writes with right-hand-side reads.
+template <typename Scalar>
+void test_hankel_aliased_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Square so that the destination and the right-hand side can alias.
+  Vec h = Vec::Random(2 * n - 1);
+  Hankel<Scalar> H(h.head(n), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, n, n);
+
+  Vec x = Vec::Random(n);
+  Vec y = x;
+  y = H * y;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  y = x;
+  y += H * y;
+  VERIFY_IS_APPROX(y, (x + dense * x).eval());
+
+  y = x;
+  y -= H * y;
+  VERIFY_IS_APPROX(y, (x - dense * x).eval());
+
+  Mat X = Mat::Random(n, 3);
+  Mat Y = X;
+  Y = H * Y;
+  VERIFY_IS_APPROX(Y, (dense * X).eval());
+}
+
+// Aliasing beyond the same-object case: the default-product temporary must also
+// resolve right-hand-side expressions that reference the destination, overlapping
+// views of one buffer, and rectangular self-assignments where the destination is
+// resized by the assignment.
+template <typename Scalar>
+void test_hankel_aliased_expression(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(2 * n - 1);
+  Hankel<Scalar> H(h.head(n), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, n, n);
+
+  // Right-hand-side expression referencing the destination.
+  Vec x = Vec::Random(n), x0 = x;
+  x = H * (x + Vec::Ones(n));
+  VERIFY_IS_APPROX(x, (dense * (x0 + Vec::Ones(n))).eval());
+
+  // Overlapping (shifted) segments of one buffer.
+  Vec buf = Vec::Random(n + 1);
+  Vec expected = dense * buf.tail(n);
+  buf.head(n) = H * buf.tail(n);
+  VERIFY_IS_APPROX(buf.head(n).eval(), expected);
+
+  // Rectangular self-assignment: z = H * z resizes the destination, so the
+  // product must be captured before the destination storage is touched.
+  const Index m = n + 3;
+  Vec hr = Vec::Random(m + n - 1);
+  Hankel<Scalar> Hr(hr.head(m), hr.tail(n));
+  Mat denseR = reference_hankel<Scalar>(hr, m, n);
+  Vec z = Vec::Random(n), z0 = z;
+  z = Hr * z;
+  VERIFY_IS_EQUAL(z.size(), m);
+  VERIFY_IS_APPROX(z, (denseR * z0).eval());
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex product
+// scalar, so alpha and the accumulation must run in the promoted type rather than
+// the operator scalar.
+template <typename RealScalar>
+void test_hankel_mixed_scalar(Index m, Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RVec h = RVec::Random(m + n - 1);
+  Hankel<RealScalar> H(h.head(m), h.tail(n));
+  CMat dense = reference_hankel<RealScalar>(h, m, n).template cast<Complex>();
+
+  CVec x = CVec::Random(n);
+  CVec y = H * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  CVec y0 = CVec::Random(m);
+  y = y0;
+  y.noalias() += H * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+
+  CVec hc = CVec::Random(m + n - 1);
+  Hankel<Complex> Hc(hc.head(m), hc.tail(n));
+  CMat denseC = reference_hankel<Complex>(hc, m, n);
+  RVec xr = RVec::Random(n);
+  CVec z = Hc * xr;
+  VERIFY_IS_APPROX(z, (denseC * xr).eval());
+}
+
+// Entrywise IEEE comparison for the non-finite tests: NaNs match NaNs,
+// infinities match by value (sign included), finite entries match to roundoff.
+// VERIFY_IS_APPROX would reject any output containing NaN.
+template <typename D1, typename D2>
+bool ieee_entrywise_match(const D1& a, const D2& b) {
+  if (a.rows() != b.rows() || a.cols() != b.cols()) return false;
+  for (Index j = 0; j < a.cols(); ++j)
+    for (Index i = 0; i < a.rows(); ++i) {
+      const typename D1::Scalar x = a(i, j), y = b(i, j);
+      if (x == y) continue;                    // finite match or same-signed infinities
+      if ((x != x) && (y != y)) continue;      // both NaN
+      if (!test_isApprox(x, y)) return false;  // finite roundoff
+    }
+  return true;
+}
+
+// Scalar-loop product: the mathematically transparent IEEE reference for the
+// non-finite tests. Eigen's own vectorized complex kernels can smear a single
+// infinity into NaN (Inf - Inf across the split real/imaginary accumulators), so
+// the dense product is not a faithful entrywise reference for non-finite data.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, 1> reference_product_ieee(const Matrix<Scalar, Dynamic, Dynamic>& A,
+                                                  const Matrix<Scalar, Dynamic, 1>& x) {
+  Matrix<Scalar, Dynamic, 1> y(A.rows());
+  for (Index i = 0; i < A.rows(); ++i) {
+    Scalar acc(0);
+    for (Index j = 0; j < A.cols(); ++j) acc += A(i, j) * x[j];
+    y[i] = acc;
+  }
+  return y;
+}
+
+// A single Inf or NaN in the data must propagate like the reference product --
+// through the dot products that touch it -- instead of being smeared into NaNs
+// across the whole output by the transforms. The reviewer reproducer (MR 2688):
+// the 40x40 exchange matrix, as a Hankel operator on the FFT tier, applied to a
+// vector with one +Inf must return +Inf in the mirrored entry; the remaining
+// entries are NaN through the IEEE 0*Inf terms of the dense dot products.
+template <typename Scalar>
+void test_hankel_nonfinite_product(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  const RealScalar inf = std::numeric_limits<RealScalar>::infinity();
+  const RealScalar nan = std::numeric_limits<RealScalar>::quiet_NaN();
+
+  // The exchange matrix is the Hankel operator generated by h = e_{n-1}.
+  Vec h = Vec::Zero(2 * n - 1);
+  h[n - 1] = Scalar(1);
+  Hankel<Scalar> H(h.head(n), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, n, n);
+
+  // Inf in the right-hand side: the mirrored entry must be +Inf (for a complex
+  // operator its real part; the 0*Inf cross term makes the imaginary part NaN).
+  Vec x = Vec::Random(n);
+  x[n / 4] = Scalar(inf);
+  Vec y = H * x;
+  VERIFY(ieee_entrywise_match(y, reference_product_ieee(dense, x)));
+  VERIFY(numext::real(y[n - 1 - n / 4]) == inf);
+
+  // NaN in the right-hand side.
+  Vec xn = Vec::Random(n);
+  xn[n - 1] = Scalar(nan);
+  VERIFY(ieee_entrywise_match((H * xn).eval(), reference_product_ieee(dense, xn)));
+
+  // Mixed multi-column right-hand side: the non-finite column falls back to the
+  // direct kernel individually while the finite column keeps the FFT path.
+  Mat Xm(n, 2);
+  Xm.col(0) = Vec::Random(n);
+  Xm.col(1) = x;
+  Mat Ym = H * Xm;
+  VERIFY_IS_APPROX(Ym.col(0).eval(), (dense * Xm.col(0)).eval());
+  VERIFY(ieee_entrywise_match(Ym.col(1).eval(), reference_product_ieee(dense, Vec(Xm.col(1)))));
+
+  // Inf in the generating sequence: the operator itself is non-finite, whatever
+  // the right-hand side.
+  Vec h2 = Vec::Random(2 * n - 1);
+  h2[1] = Scalar(-inf);
+  Hankel<Scalar> H2(h2.head(n), h2.tail(n));
+  Mat dense2 = reference_hankel<Scalar>(h2, n, n);
+  Vec x2 = Vec::Random(n);
+  VERIFY(ieee_entrywise_match((H2 * x2).eval(), reference_product_ieee(dense2, x2)));
+}
+
+// The transposed / adjoint / conjugated Hankel operators agree with the dense
+// references, both materialized and through their fast products. For rectangular
+// operators on the FFT tier this validates the phase-multiplication symbol reuse
+// (the DFT shift theorem), including its sign.
+template <typename Scalar>
+void test_hankel_transpose(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(m + n - 1);
+  Hankel<Scalar> H(h.head(m), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, m, n);
+
+  Mat Td = H.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = H.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Kd = H.conjugate();
+  VERIFY_IS_APPROX(Kd, Mat(dense.conjugate()));
+
+  Vec y = Vec::Random(m);
+  VERIFY_IS_APPROX((H.transpose() * y).eval(), (dense.transpose() * y).eval());
+  VERIFY_IS_APPROX((H.adjoint() * y).eval(), (dense.adjoint() * y).eval());
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((H.conjugate() * x).eval(), (dense.conjugate() * x).eval());
+
+  // The generating sequence round-trips exactly; the symbol round-trips to
+  // rounding (the phase factors cancel only approximately when m != n).
+  Hankel<Scalar> Htt = H.transpose().transpose();
+  VERIFY_IS_EQUAL(Htt.generator(), h);
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  const auto symbol = H.symbol();
+  const auto roundTrip = Htt.symbol();
+  VERIFY((roundTrip - symbol).norm() <= RealScalar(16) * NumTraits<RealScalar>::epsilon() * symbol.norm());
+  Mat Httd = Htt;
+  VERIFY_IS_APPROX(Httd, dense);
+}
+
+// A real square Hankel matrix is symmetric: transpose() is an exact fixed point.
+template <typename Scalar>
+void test_hankel_symmetry(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(2 * n - 1);
+  Hankel<Scalar> H(h.head(n), h.tail(n));
+  Hankel<Scalar> Ht = H.transpose();
+  VERIFY_IS_EQUAL(Ht.generator(), h);
+  VERIFY_IS_EQUAL(Ht.symbol(), H.symbol());  // square: no phase multiplication at all
+  Mat dense = H;
+  VERIFY_IS_APPROX(dense, Mat(dense.transpose()));
+}
+
+// The column-reversed Toeplitz equivalent: toToeplitz() == H * E.
+template <typename Scalar>
+void test_hankel_to_toeplitz(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(m + n - 1);
+  Hankel<Scalar> H(h.head(m), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, m, n);
+  Mat Td = H.toToeplitz();
+  VERIFY_IS_APPROX(Td, Mat(dense.rowwise().reverse()));
+}
+
+// Direct O(n^2) solve of a square Hankel system through the Toeplitz equivalent.
+template <typename Scalar>
+void test_hankel_solve(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // h[n-1] is the constant anti-diagonal that becomes the diagonal of the
+  // Toeplitz equivalent; boosting it makes the system well conditioned.
+  Vec h = Vec::Random(2 * n - 1);
+  h[n - 1] += Scalar(RealScalar(2 * n));
+  Hankel<Scalar> H(h.head(n), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, n, n);
+
+  Vec b = Vec::Random(n);
+  Vec x = H.solve(b);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+  VERIFY_IS_APPROX(x, dense.fullPivLu().solve(b).eval());
+
+  Mat B = Mat::Random(n, 3);
+  Mat X = H.solve(B);
+  VERIFY_IS_APPROX(X, dense.fullPivLu().solve(B).eval());
+}
+
+// A zero constant anti-diagonal makes the Toeplitz equivalent's diagonal zero, so
+// its 1x1 leading minor is singular and the solve must go through the look-ahead
+// init/block-step machinery. Verified through the residual (the look-ahead
+// Levinson algorithm is weakly stable).
+template <typename Scalar>
+void test_hankel_solve_lookahead(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(2 * n - 1);
+  h[n - 1] = Scalar(0);
+  Hankel<Scalar> H(h.head(n), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, n, n);
+
+  Vec b = dense * Vec::Ones(n);
+  Vec x = H.solve(b);
+  const RealScalar tol = RealScalar(5e6) * NumTraits<RealScalar>::epsilon();  // ~1e-9 in double
+  VERIFY((dense * x - b).norm() <= tol * b.norm());
+}
+
+// The Hilbert matrix is the canonical ill-conditioned Hankel matrix: H(i,j) =
+// 1/(i+j+1), i.e. h[k] = 1/(k+1). Deterministic, so the tolerances below are
+// calibrated with a ~100x margin against measured values. The look-ahead Levinson
+// solver is weakly stable: the forward error grows like eps * cond, but the
+// residual stays small far beyond the point where the solution itself is lost.
+void test_hankel_hilbert() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<double, Dynamic, Dynamic> Mat;
+
+  auto residual = [](Index n) {
+    Vec h(2 * n - 1);
+    for (Index k = 0; k < 2 * n - 1; ++k) h[k] = 1.0 / double(k + 1);
+    Hankel<double> H(h.head(n), h.tail(n));
+    Mat dense = reference_hankel<double>(h, n, n);
+    Vec b = dense * Vec::Ones(n);
+    Vec x = H.solve(b);
+    return (dense * x - b).norm() / b.norm();
+  };
+  const double eps = NumTraits<double>::epsilon();
+  VERIFY(residual(8) <= 5e6 * eps);    // ~1e-9;  cond ~ 1.5e10, measured residual ~ 1.4e-11
+  VERIFY(residual(12) <= 5e10 * eps);  // ~1e-5; cond ~ 1.7e16, measured residual ~ 1.1e-7
+
+  // The condition estimate of the Toeplitz equivalent must see the
+  // ill-conditioning (measured ~ 2.7e15 at n = 12).
+  Vec h(23);
+  for (Index k = 0; k < 23; ++k) h[k] = 1.0 / double(k + 1);
+  Hankel<double> H(h.head(12), h.tail(12));
+  LookAheadLevinson<double> lev(H.toToeplitz());
+  VERIFY(lev.conditionEstimate() >= 1e14);
+}
+
+// With adjoint() available, a rectangular Hankel feeds the matrix-free
+// least-squares solvers end to end.
+template <typename Scalar>
+void test_hankel_least_squares(Index m, Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec h = Vec::Random(m + n - 1);
+  Hankel<Scalar> H(h.head(m), h.tail(n));
+  Mat dense = reference_hankel<Scalar>(h, m, n);
+
+  Vec b = Vec::Random(m);
+
+  LSMR<Hankel<Scalar>, IdentityPreconditioner> lsmr;
+  lsmr.setTolerance(RealScalar(1e-12)).setMaxIterations(20 * n);
+  lsmr.compute(H);
+  Vec x = lsmr.solve(b);
+  VERIFY(lsmr.info() == Success);
+  // Check LSMR's own convergence criterion -- the normal-equations residual --
+  // rather than the forward error, whose accuracy degrades with cond^2 and would
+  // make the test flaky for unlucky random operators.
+  Vec r = b - dense * x;
+  const RealScalar tol = RealScalar(5e7) * NumTraits<RealScalar>::epsilon();     // ~1e-8, relative
+  const RealScalar absTol = RealScalar(5e3) * NumTraits<RealScalar>::epsilon();  // ~1e-12, floor
+  VERIFY((dense.adjoint() * r).norm() <= tol * dense.norm() * r.norm() + absTol * b.norm());
+}
+
+template <typename Scalar, int M, int N>
+void test_hankel_fixed() {
+  typedef Matrix<Scalar, M, 1> ColVec;
+  typedef Matrix<Scalar, N, 1> RowVec;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, M, N> MatMN;
+
+  Vec h = Vec::Random(M + N - 1);
+  ColVec c = h.template head<M>();
+  RowVec r = h.template tail<N>();
+  Hankel<Scalar, M, N> H(c, r);
+  STATIC_CHECK((Hankel<Scalar, M, N>::RowsAtCompileTime == M));
+  STATIC_CHECK((Hankel<Scalar, M, N>::ColsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeHankel(c, r))>::ColsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(H.transpose())>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(H.transpose())>::ColsAtCompileTime == M));
+
+  MatMN dense = H;
+  VERIFY_IS_APPROX(dense, MatMN(reference_hankel<Scalar>(h, M, N)));
+
+  RowVec x = RowVec::Random();
+  Matrix<Scalar, M, 1> y = H * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  ColVec w = ColVec::Random();
+  RowVec tw = H.transpose() * w;
+  VERIFY_IS_APPROX(tw, (dense.transpose() * w).eval());
+}
+
+// solve() on a fixed-size operator returns a fixed-size result (reviewer
+// regression for MR 2688: the return type used to have Dynamic rows). Either
+// fixed dimension of the square operator determines the compile-time row count.
+template <typename Scalar, int N>
+void test_hankel_fixed_solve() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, N, 1> VecN;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, N, N> MatN;
+
+  STATIC_CHECK((internal::remove_all_t<decltype(std::declval<const Hankel<Scalar, N, N>&>().solve(
+                    std::declval<const VecN&>()))>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(std::declval<const Hankel<Scalar, Dynamic, N>&>().solve(
+                    std::declval<const Vec&>()))>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(std::declval<const Hankel<Scalar, N, Dynamic>&>().solve(
+                    std::declval<const Vec&>()))>::RowsAtCompileTime == N));
+
+  // h[N-1] is the constant anti-diagonal that becomes the diagonal of the
+  // Toeplitz equivalent; boosting it makes the system well conditioned.
+  Vec h = Vec::Random(2 * N - 1);
+  h[N - 1] += Scalar(RealScalar(2 * N));
+  Hankel<Scalar, N, N> H(h.template head<N>(), h.template tail<N>());
+  MatN dense = H;
+
+  VecN b = VecN::Random();
+  VecN x = H.solve(b);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+
+  Matrix<Scalar, N, 2> B = Matrix<Scalar, N, 2>::Random();
+  STATIC_CHECK((internal::remove_all_t<decltype(H.solve(B))>::ColsAtCompileTime == 2));
+  Matrix<Scalar, N, 2> X = H.solve(B);
+  VERIFY_IS_APPROX((dense * X).eval(), B);
+}
+
+// The transposed / adjoint / conjugated operators agree with the dense references,
+// both materialized and through their fast products, which reuse the cached symbol
+// (index reversal / conjugation) instead of computing new FFTs.
+template <typename Scalar>
+void test_circulant_transpose(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  Mat Td = C.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = C.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Kd = C.conjugate();
+  VERIFY_IS_APPROX(Kd, Mat(dense.conjugate()));
+
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((C.transpose() * x).eval(), (dense.transpose() * x).eval());
+  VERIFY_IS_APPROX((C.adjoint() * x).eval(), (dense.adjoint() * x).eval());
+  VERIFY_IS_APPROX((C.conjugate() * x).eval(), (dense.conjugate() * x).eval());
+
+  // The transposition family round-trips exactly: generators and symbols are pure
+  // permutations / conjugations, so no FFT is recomputed and no roundoff accrues.
+  Circulant<Scalar> Ctt = C.transpose().transpose();
+  VERIFY_IS_EQUAL(Ctt.column(), c);
+  VERIFY_IS_EQUAL(Ctt.symbol(), C.symbol());
+  Circulant<Scalar> Caa = C.adjoint().adjoint();
+  VERIFY_IS_EQUAL(Caa.column(), c);
+  VERIFY_IS_EQUAL(Caa.symbol(), C.symbol());
+}
+
+template <typename Scalar>
+void test_toeplitz_transpose(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // r[0] is deliberately left random (it is documented as ignored): the transposed
+  // operator must take its diagonal from c[0], not from r[0].
+  Vec c = Vec::Random(m), r = Vec::Random(n);
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = reference_toeplitz<Scalar>(c, r);
+
+  Mat Td = T.transpose();
+  VERIFY_IS_APPROX(Td, Mat(dense.transpose()));
+  Mat Ad = T.adjoint();
+  VERIFY_IS_APPROX(Ad, Mat(dense.adjoint()));
+  Mat Kd = T.conjugate();
+  VERIFY_IS_APPROX(Kd, Mat(dense.conjugate()));
+
+  Vec y = Vec::Random(m);
+  VERIFY_IS_APPROX((T.transpose() * y).eval(), (dense.transpose() * y).eval());
+  VERIFY_IS_APPROX((T.adjoint() * y).eval(), (dense.adjoint() * y).eval());
+  Vec x = Vec::Random(n);
+  VERIFY_IS_APPROX((T.conjugate() * x).eval(), (dense.conjugate() * x).eval());
+
+  // Exact round trip (row[0] is normalized to the diagonal value on the way).
+  Toeplitz<Scalar> Ttt = T.transpose().transpose();
+  VERIFY_IS_EQUAL(Ttt.column(), c);
+  if (n > 1) VERIFY_IS_EQUAL(Vec(Ttt.row().tail(n - 1)), Vec(r.tail(n - 1)));
+  VERIFY_IS_EQUAL(Ttt.symbol(), T.symbol());
+}
+
+// transpose()/conjugate()/adjoint() return owning temporaries, so the product
+// expression must nest the structured operand by value: a delayed-evaluated
+// expression has to outlive the temporary operator it was built from. The static
+// check pins the value nesting; the behavioral check would read freed memory if
+// the product held a reference instead.
+template <typename Scalar>
+void test_circulant_delayed_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<Circulant<Scalar>>::type>::value);
+
+  Vec c = Vec::Random(n), x = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  auto expr = C.adjoint() * x;        // the adjoint temporary dies with the full expression
+  Vec scribble = Vec::Random(2 * n);  // reuses the temporary's freed heap storage
+  Vec y = expr;
+  VERIFY_IS_APPROX(y, (dense.adjoint() * x).eval());
+  VERIFY_IS_EQUAL(scribble.size(), 2 * n);  // keep the scribble alive across the evaluation
+}
+
+template <typename Scalar>
+void test_toeplitz_delayed_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<Toeplitz<Scalar>>::type>::value);
+
+  Vec c = Vec::Random(m), r = Vec::Random(n), y = Vec::Random(m);
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = reference_toeplitz<Scalar>(c, r);
+
+  auto expr = T.adjoint() * y;
+  Vec scribble = Vec::Random(m + n);
+  Vec x = expr;
+  VERIFY_IS_APPROX(x, (dense.adjoint() * y).eval());
+  VERIFY_IS_EQUAL(scribble.size(), m + n);
+}
+
+// The products are tagged AliasFreeProduct, so no temporary shields an aliased
+// right-hand side: the shared product implementation must copy it instead.
+// Without the copy, x = C * x reads a zeroed right-hand side and x += C * x
+// interleaves destination writes with right-hand-side reads.
+template <typename Scalar>
+void test_circulant_aliased_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  Vec x = Vec::Random(n);
+  Vec y = x;
+  y = C * y;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  y = x;
+  y += C * y;
+  VERIFY_IS_APPROX(y, (x + dense * x).eval());
+
+  y = x;
+  y -= C * y;
+  VERIFY_IS_APPROX(y, (x - dense * x).eval());
+
+  Mat X = Mat::Random(n, 3);
+  Mat Y = X;
+  Y = C * Y;
+  VERIFY_IS_APPROX(Y, (dense * X).eval());
+}
+
+template <typename Scalar>
+void test_toeplitz_aliased_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Square so that the destination and the right-hand side can alias.
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  r[0] = c[0];
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = reference_toeplitz<Scalar>(c, r);
+
+  Vec x = Vec::Random(n);
+  Vec y = x;
+  y = T * y;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  y = x;
+  y += T * y;
+  VERIFY_IS_APPROX(y, (x + dense * x).eval());
+}
+
+// Aliasing beyond the same-object case: the default-product temporary must also
+// resolve right-hand-side expressions that reference the destination, overlapping
+// views of one buffer, and rectangular self-assignments where the destination is
+// resized by the assignment.
+template <typename Scalar>
+void test_structured_aliased_expression(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  // Right-hand-side expression referencing the destination.
+  Vec x = Vec::Random(n), x0 = x;
+  x = C * (x + Vec::Ones(n));
+  VERIFY_IS_APPROX(x, (dense * (x0 + Vec::Ones(n))).eval());
+
+  // Overlapping (shifted) segments of one buffer.
+  Vec buf = Vec::Random(n + 1);
+  Vec expected = dense * buf.tail(n);
+  buf.head(n) = C * buf.tail(n);
+  VERIFY_IS_APPROX(buf.head(n).eval(), expected);
+
+  // Rectangular self-assignment: x = T * x resizes the destination, so the
+  // product must be captured before the destination storage is touched.
+  const Index m = n + 3;
+  Vec tc = Vec::Random(m), tr = Vec::Random(n);
+  tr[0] = tc[0];
+  Toeplitz<Scalar> T(tc, tr);
+  Mat denseT = reference_toeplitz<Scalar>(tc, tr);
+  Vec z = Vec::Random(n), z0 = z;
+  z = T * z;
+  VERIFY_IS_EQUAL(z.size(), m);
+  VERIFY_IS_APPROX(z, (denseT * z0).eval());
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex product
+// scalar, so alpha and the accumulation must run in the promoted type rather than
+// the operator scalar.
+template <typename RealScalar>
+void test_circulant_mixed_scalar(Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RVec c = RVec::Random(n);
+  Circulant<RealScalar> C(c);
+  CMat dense = reference_circulant<RealScalar>(c).template cast<Complex>();
+
+  CVec x = CVec::Random(n);
+  CVec y = C * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  CVec y0 = CVec::Random(n);
+  y = y0;
+  y.noalias() += C * x;
+  VERIFY_IS_APPROX(y, (y0 + dense * x).eval());
+
+  CVec cc = CVec::Random(n);
+  Circulant<Complex> Cc(cc);
+  CMat denseC = reference_circulant<Complex>(cc);
+  RVec xr = RVec::Random(n);
+  CVec z = Cc * xr;
+  VERIFY_IS_APPROX(z, (denseC * xr).eval());
+}
+
+template <typename RealScalar>
+void test_toeplitz_mixed_scalar(Index m, Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RVec c = RVec::Random(m), r = RVec::Random(n);
+  r[0] = c[0];
+  Toeplitz<RealScalar> T(c, r);
+  CMat dense = reference_toeplitz<RealScalar>(c, r).template cast<Complex>();
+
+  CVec x = CVec::Random(n);
+  CVec y = T * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+}
+
+// The FFT product path accumulates up to p addends per transform, so a finite
+// right-hand side near the overflow threshold (or a huge generator) used to
+// overflow inside the transforms and return NaN for a representable result. The
+// power-of-two scaled path must stay finite and accurate.
+template <typename RealScalar>
+void test_structured_fft_overflow(Index n) {
+  typedef Matrix<RealScalar, Dynamic, 1> Vec;
+  // FFT-transform roundoff bound for the identity round trip.
+  const RealScalar kFftRoundTripTol = RealScalar(100) * NumTraits<RealScalar>::epsilon();
+  const RealScalar huge = (std::numeric_limits<RealScalar>::max)() / RealScalar(16);
+
+  // Identity circulant applied to a huge finite vector returns it unchanged.
+  Vec c = Vec::Zero(n);
+  c[0] = RealScalar(1);
+  Circulant<RealScalar> C(c);
+  Vec x = Vec::Constant(n, huge);
+  Vec y = C * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / huge).maxCoeff() <= kFftRoundTripTol);
+
+  // A huge generator applied to a moderate vector: every output entry is huge
+  // but representable.
+  Circulant<RealScalar> Ch(Vec(huge * c));
+  Vec ones = Vec::Ones(n);
+  Vec z = Ch * ones;
+  VERIFY(z.allFinite());
+  VERIFY(((z.array() - huge).abs() / huge).maxCoeff() <= kFftRoundTripTol);
+
+  // Identity Toeplitz, same huge right-hand side.
+  Vec r = Vec::Zero(n);
+  r[0] = c[0];
+  Toeplitz<RealScalar> T(c, r);
+  Vec w = T * x;
+  VERIFY(w.allFinite());
+  VERIFY(((w - x).cwiseAbs() / huge).maxCoeff() <= kFftRoundTripTol);
+}
+
+// The scaling exponents are derived from component-wise magnitudes: a finite
+// complex value near the overflow threshold has a non-representable modulus,
+// which would otherwise disable the scaling and turn an exactly representable
+// product into NaN.
+template <typename RealScalar>
+void test_structured_fft_complex_boundary(Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  const RealScalar kFftRoundTripTol = RealScalar(100) * NumTraits<RealScalar>::epsilon();
+  const RealScalar big = RealScalar(0.75) * (std::numeric_limits<RealScalar>::max)();
+
+  // Identity circulant with a complex generator: the product returns the
+  // right-hand side unchanged even though |x_k| overflows.
+  CVec c = CVec::Zero(n);
+  c[0] = Complex(1);
+  Circulant<Complex> C(c);
+  CVec x = CVec::Constant(n, Complex(big, big));
+  CVec y = C * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / big).maxCoeff() <= kFftRoundTripTol);
+
+  // A real identity operator applied to the same complex right-hand side takes
+  // the mixed-scalar product path.
+  RVec cr = RVec::Zero(n);
+  cr[0] = RealScalar(1);
+  Circulant<RealScalar> Cr(cr);
+  y = Cr * x;
+  VERIFY(y.allFinite());
+  VERIFY(((y - x).cwiseAbs() / big).maxCoeff() <= kFftRoundTripTol);
+}
+
+// A single Inf or NaN in the data must propagate like the reference product --
+// through the dot products that touch it -- instead of being smeared into NaNs
+// across the whole output by the transforms.
+template <typename Scalar>
+void test_structured_nonfinite_product(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  const RealScalar inf = std::numeric_limits<RealScalar>::infinity();
+  const RealScalar nan = std::numeric_limits<RealScalar>::quiet_NaN();
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  // Inf in the right-hand side.
+  Vec x = Vec::Random(n);
+  x[n / 2] = Scalar(inf);
+  VERIFY(ieee_entrywise_match((C * x).eval(), reference_product_ieee(dense, x)));
+
+  // NaN in the right-hand side.
+  Vec xn = Vec::Random(n);
+  xn[n - 1] = Scalar(nan);
+  VERIFY(ieee_entrywise_match((C * xn).eval(), reference_product_ieee(dense, xn)));
+
+  // Mixed multi-column right-hand side: the non-finite column falls back to the
+  // direct kernel individually while the finite column keeps the FFT path.
+  Mat Xm(n, 2);
+  Xm.col(0) = Vec::Random(n);
+  Xm.col(1) = x;
+  Mat Ym = C * Xm;
+  VERIFY_IS_APPROX(Ym.col(0).eval(), (dense * Xm.col(0)).eval());
+  VERIFY(ieee_entrywise_match(Ym.col(1).eval(), reference_product_ieee(dense, Vec(Xm.col(1)))));
+
+  // Inf in the generator: the operator itself is non-finite, whatever the
+  // right-hand side.
+  Vec c2 = Vec::Random(n);
+  c2[1] = Scalar(-inf);
+  Circulant<Scalar> C2(c2);
+  Mat dense2 = reference_circulant<Scalar>(c2);
+  Vec x2 = Vec::Random(n);
+  VERIFY(ieee_entrywise_match((C2 * x2).eval(), reference_product_ieee(dense2, x2)));
+
+  // Toeplitz with an Inf in the row generator.
+  Vec tc = Vec::Random(n), tr = Vec::Random(n);
+  tr[0] = tc[0];
+  tr[n / 2] = Scalar(inf);
+  Toeplitz<Scalar> T(tc, tr);
+  Mat denseT = reference_toeplitz<Scalar>(tc, tr);
+  VERIFY(ieee_entrywise_match((T * x2).eval(), reference_product_ieee(denseT, x2)));
+
+  // Non-finite right-hand sides of solve() take the direct pseudo-inverse
+  // application; on the 1x1 operator this is a single scalar multiply by the
+  // inverse coefficient, checked against the same multiply on the dense inverse.
+  Vec b1(1);
+  b1[0] = Scalar(inf);
+  Circulant<Scalar> C1(Vec(Vec::Constant(1, Scalar(2))));
+  Mat pinv1 = Mat(C1.inverse());
+  VERIFY(ieee_entrywise_match(C1.solve(b1), reference_product_ieee(pinv1, b1)));
+}
+
+// Closed-form eigendecomposition: C * V = V * diag(eigenvalues) with V unitary.
+template <typename Scalar>
+void test_circulant_eigen(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  CMat denseC = reference_circulant<Scalar>(c).template cast<Complex>();
+
+  Matrix<Complex, Dynamic, 1> lam = C.eigenvalues();
+  CMat V = C.eigenvectors();
+  VERIFY_IS_APPROX((denseC * V).eval(), (V * lam.asDiagonal()).eval());
+  VERIFY_IS_APPROX((V.adjoint() * V).eval(), CMat(CMat::Identity(n, n)));
+}
+
+// Closed-form SVD: the singular values match JacobiSVD, and U * S * V^H
+// reconstructs the matrix with unitary factors.
+template <typename Scalar>
+void test_circulant_svd(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  Vec c = Vec::Random(n);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  Matrix<RealScalar, Dynamic, 1> sv = C.singularValues();
+  JacobiSVD<Mat> svd(dense);
+  VERIFY_IS_APPROX(sv, svd.singularValues());
+
+  // The symbol of a real operator is conjugate-symmetric, so every mode but the
+  // self-conjugate ones (k = 0 and, for even n, k = n/2) is tied with its mirror.
+  // The tie must be exact rather than accurate to roundoff: singularValues(),
+  // matrixU() and matrixV() each order the modes from their own symbol
+  // computation, and a pair ranked by its last bits can come out ordered one way
+  // in one of them and the other way in another -- pairing a left singular vector
+  // with the wrong right one. Runs of exactly equal values must therefore all be
+  // even, apart from those self-conjugate moduli (fewer runs are odd when a
+  // modulus coincidentally repeats).
+  if (!NumTraits<Scalar>::IsComplex) {
+    Index odd = 0;
+    for (Index t = 0; t < n;) {
+      Index run = t;
+      while (run < n && numext::equal_strict(sv[run], sv[t])) ++run;
+      if ((run - t) % 2 == 1) ++odd;
+      t = run;
+    }
+    VERIFY(odd <= (n % 2 == 0 ? 2 : 1));
+  }
+
+  CMat U = C.matrixU(), V = C.matrixV();
+  VERIFY_IS_APPROX((U * sv.template cast<Complex>().asDiagonal() * V.adjoint()).eval(),
+                   CMat(dense.template cast<Complex>()));
+  VERIFY_IS_APPROX((U.adjoint() * U).eval(), CMat(CMat::Identity(n, n)));
+  VERIFY_IS_APPROX((V.adjoint() * V).eval(), CMat(CMat::Identity(n, n)));
+}
+
+// A rank-one circulant (the all-ones matrix): solve() must return the
+// minimum-norm least-squares solution -- the SVD pseudo-inverse applied to b --
+// for both consistent and inconsistent right-hand sides.
+template <typename Scalar>
+void test_circulant_minnorm_solve(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Ones(n);
+  Circulant<Scalar> C(c);
+  VERIFY_IS_EQUAL(C.rank(), 1);
+  Mat dense = reference_circulant<Scalar>(c);
+  JacobiSVD<Mat, ComputeThinU | ComputeThinV> svd(dense);
+
+  Vec b = dense * Vec::Random(n);  // consistent right-hand side
+  VERIFY_IS_APPROX(C.solve(b), svd.solve(b).eval());
+  Vec b2 = Vec::Random(n);  // generally inconsistent; keep the projection non-zero
+  b2.array() += Scalar(2);
+  VERIFY_IS_APPROX(C.solve(b2), svd.solve(b2).eval());
+}
+
+// General rank-deficient circulant, synthesized by zeroing symbol entries. The
+// numerical rank must count exactly the surviving entries and solve() must match
+// the SVD pseudo-inverse. Scalar must be complex (the generator is an inverse DFT).
+template <typename Scalar>
+void test_circulant_rank_deficient(Index n, Index defect) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  CVec s = CVec::Random(n);
+  s.array() += Complex(2);  // keep the surviving moduli away from the threshold
+  for (Index k = 0; k < defect; ++k) s[2 * k + 1] = Complex(0);
+  CVec ct(n);
+  FFT<RealScalar> fft;
+  fft.inv(ct, s, n);
+  Vec c = ct;
+  Circulant<Scalar> C(c);
+  VERIFY_IS_EQUAL(C.rank(), n - defect);
+
+  Mat dense = reference_circulant<Scalar>(c);
+  JacobiSVD<Mat, ComputeThinU | ComputeThinV> svd(dense);
+  Vec b = Vec::Random(n);
+  VERIFY_IS_APPROX(C.solve(b), svd.solve(b).eval());
+
+  // The SVD factors must stay unitary and reconstruct the matrix even with zero
+  // singular values (exercising the arbitrary-phase completion of U and the
+  // tie-handling of the shared sort).
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+  Matrix<RealScalar, Dynamic, 1> sv = C.singularValues();
+  VERIFY((sv.tail(defect).array() <= RealScalar(n) * NumTraits<RealScalar>::epsilon() * sv[0]).all());
+  CMat U = C.matrixU(), V = C.matrixV();
+  VERIFY_IS_APPROX((U * sv.template cast<Complex>().asDiagonal() * V.adjoint()).eval(),
+                   CMat(dense.template cast<Complex>()));
+  VERIFY_IS_APPROX((U.adjoint() * U).eval(), CMat(CMat::Identity(n, n)));
+  VERIFY_IS_APPROX((V.adjoint() * V).eval(), CMat(CMat::Identity(n, n)));
+}
+
+// The zero operator: rank 0, pseudo-inverse solve identically zero, all singular
+// values zero. Pins the clamped-threshold boundary behavior.
+template <typename Scalar>
+void test_circulant_zero(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+
+  Circulant<Scalar> C(Vec(Vec::Zero(n)));
+  VERIFY_IS_EQUAL(C.rank(), 0);
+  VERIFY(C.singularValues().isZero());
+  Vec b = Vec::Random(n);
+  VERIFY(C.solve(b).isZero());
+}
+
+// A NaN in the generator must propagate to the solution (and count as non-zero in
+// rank()) instead of being silently laundered into zeros by the rank threshold.
+void test_circulant_nan_propagation(Index n) {
+  typedef Matrix<double, Dynamic, 1> Vec;
+
+  Vec c = Vec::Random(n);
+  c[n / 2] = std::numeric_limits<double>::quiet_NaN();
+  Circulant<double> C(c);
+  VERIFY_IS_EQUAL(C.rank(), n);
+  Vec b = Vec::Random(n);
+  Vec x = C.solve(b);
+  VERIFY(!(x.array() == x.array()).all());
+}
+
+template <typename Scalar>
+void test_circulant_inverse(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n);
+  c[0] += Scalar(RealScalar(2 * n));  // diagonally dominant => safely invertible
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  Mat inv = C.inverse();
+  VERIFY_IS_APPROX((inv * dense).eval(), Mat(Mat::Identity(n, n)));
+
+  // The inverse operator's fast product acts as a solve.
+  Vec b = Vec::Random(n);
+  VERIFY_IS_APPROX((C.inverse() * b).eval(), C.solve(b));
+}
+
+template <typename Scalar>
+void test_circulant_determinant(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Diagonal dominance keeps every eigenvalue away from zero, so the determinant
+  // is well conditioned and comparable against the dense LU-based value.
+  Vec c = Vec::Random(n);
+  c[0] += Scalar(RealScalar(2 * n));
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+  VERIFY_IS_APPROX(C.determinant(), dense.determinant());
+}
+
+// Spectra with a wide dynamic range: the determinant is representable, but a
+// plain product of the eigenvalues in FFT order overflows to infinity (or
+// underflows to an exact zero) partway through. Pins the balanced accumulation
+// in determinant().
+void test_circulant_determinant_scaled() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<std::complex<double>, Dynamic, 1> CVec;
+  const Index n = 1000;
+
+  // 653 eigenvalues `lead` and 347 eigenvalues `rest`, arranged symmetrically
+  // (s[k] == s[n-k]) so the generator is real, with the leading 327 FFT-order
+  // indices all equal to `lead` so the plain running product leaves the
+  // representable range partway through.
+  auto generator = [n](double lead, double rest) {
+    Vec mag = Vec::Constant(n, rest);
+    mag[0] = lead;
+    for (Index k = 1; k <= 326; ++k) mag[k] = mag[n - k] = lead;
+    CVec s = mag.cast<std::complex<double>>();
+    CVec ct(n);
+    FFT<double> fft;
+    fft.inv(ct, s, n);
+    return Vec(ct.real());
+  };
+
+  // The spectrum is only reproduced up to the FFT round trip's forward error,
+  // and the determinant multiplies ~1e3 such factors.
+  const double tol = 1e8 * NumTraits<double>::epsilon();
+  {
+    // det = 10^653 * 10^-347 = 1e306; the naive partial product reaches 1e327.
+    Circulant<double> C(generator(10.0, 0.1));
+    const double det = C.determinant();
+    VERIFY((numext::isfinite)(det));
+    VERIFY(numext::abs(det / 1e306 - 1.0) <= tol);
+  }
+  {
+    // det = 10^-653 * 10^347 = 1e-306; the naive partial product reaches 1e-327,
+    // well below the smallest subnormal, and flushes to an exact zero.
+    Circulant<double> C(generator(0.1, 10.0));
+    const double det = C.determinant();
+    VERIFY(det != 0.0);
+    VERIFY(numext::abs(det / 1e-306 - 1.0) <= tol);
+  }
+}
+
+// The rank decision at the clamped threshold (the smallest normal number): a
+// smallest-normal symbol entry is still inverted -- the comparison is strict,
+// matching SVDBase::rank(), which likewise reports rank one -- a subnormal entry
+// is treated as an exact zero, and non-finite entries count as non-zero.
+void test_circulant_rank_boundaries() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const double mn = (std::numeric_limits<double>::min)();
+  const Vec b = Vec::Ones(1);
+  {
+    Circulant<double> C(Vec(Vec::Constant(1, mn)));
+    VERIFY_IS_EQUAL(C.rank(), 1);
+    Vec x = C.solve(b);
+    VERIFY((numext::isfinite)(x[0]));
+    VERIFY_IS_APPROX(x[0], 1.0 / mn);
+  }
+  {
+    Circulant<double> C(Vec(Vec::Constant(1, mn / 2)));  // subnormal
+    VERIFY_IS_EQUAL(C.rank(), 0);
+    VERIFY(C.solve(b).isZero());
+  }
+  {
+    Circulant<double> C(Vec(Vec::Constant(1, std::numeric_limits<double>::infinity())));
+    VERIFY_IS_EQUAL(C.rank(), 1);
+    VERIFY((numext::isinf)(C.determinant()));
+  }
+}
+
+// True where a subnormal result survives: under flush-to-zero -- NVHPC's default
+// -fast, for one -- it is an exact zero instead.
+bool subnormals_survive() { return !numext::is_exactly_zero(underflowProbe<double>()); }
+
+// A finite complex symbol entry near the overflow threshold has a
+// non-representable modulus. The rank threshold used to be computed from the raw
+// moduli, turning it into infinity: the rank was under-reported and solve()
+// zeroed valid Fourier modes. Both are now evaluated in an exactly rescaled
+// frame.
+void test_circulant_rank_complex_boundary() {
+  typedef std::complex<double> Complex;
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  const double mx = (std::numeric_limits<double>::max)();
+
+  // The length-one shortcut has no FFTs, but its pointwise division still needs
+  // scaling: a huge right-hand side over the balanced O(1) symbol overflows before
+  // the symbol exponent is folded back, though the result itself is moderate.
+  const Vec oneCol = Vec::Constant(1, 0.75 * mx);
+  const Vec oneB = Vec::Constant(1, 0.25 * mx);
+  const Vec oneX = Circulant<double>(oneCol).solve(oneB);
+  const double oneExpected = oneB[0] / oneCol[0];
+  VERIFY(oneX.allFinite());
+  VERIFY(numext::abs(oneX[0] / oneExpected - 1.0) <= 16 * NumTraits<double>::epsilon());
+
+  // n = 2: the symbol is exactly [c0 + c1, c0 - c1], so pick the generator from
+  // the desired spectrum. |s0| overflows while both of its components are finite.
+  const Complex s0(0.75 * mx, 0.75 * mx), s1(1e300, 0.0);
+  CVec c(2);
+  c[0] = (s0 + s1) * 0.5;
+  c[1] = (s0 - s1) * 0.5;
+  Circulant<Complex> C(c);
+  VERIFY_IS_EQUAL(C.rank(), 2);
+
+  // The second Fourier mode must be inverted, not zeroed: a product of a small
+  // vector solves back to that vector (the accuracy is limited by the condition
+  // number |s0| / |s1| ~ 2.5e8).
+  CVec x0(2);
+  x0[0] = Complex(1e-10, -2e-10);
+  x0[1] = Complex(-3e-10, 1e-10);
+  CVec b = C * x0;
+  VERIFY(b.allFinite());
+  CVec x = C.solve(b);
+  VERIFY(((x - x0).cwiseAbs().maxCoeff() / x0.cwiseAbs().maxCoeff()) <= 1e-6);
+
+  // A large right-hand side in the smaller retained mode must be scaled for the
+  // division's amplification as well as for the transforms: the quotient is
+  // moderate, but the balanced-frame division overflows without it.
+  const double h = 0.25 * mx;
+  CVec largeB(2);
+  largeB << Complex(h), Complex(-h);
+  const CVec largeX = C.solve(largeB);
+  const double expected = h / numext::real(C.symbol()[1]);
+  CVec expectedX(2);
+  expectedX << Complex(expected), Complex(-expected);
+  VERIFY(largeX.allFinite());
+  VERIFY(((largeX - expectedX).cwiseAbs().maxCoeff() / expected) <= 32 * NumTraits<double>::epsilon());
+
+  // The reciprocal of an entry near the overflow boundary is subnormal but
+  // representable, and must not collapse to zero: formed as conj(z)/|z|^2, or by
+  // Smith's algorithm, it overflows to exactly zero and drops the mode. Gated on
+  // flush-to-zero, where that entry is not representable at all -- which is why
+  // solve() divides by the symbol rather than multiplying by its reciprocal.
+  const CVec sinv = C.inverse().symbol();
+  VERIFY(sinv.allFinite());
+  if (subnormals_survive()) VERIFY_IS_EQUAL((sinv.array() == Complex(0)).count(), 0);
+
+  // A genuinely negligible second entry still truncates in the scaled frame.
+  CVec c2(2);
+  c2[0] = (s0 + Complex(1)) * 0.5;
+  c2[1] = (s0 - Complex(1)) * 0.5;
+  VERIFY_IS_EQUAL(Circulant<Complex>(c2).rank(), 1);
+}
+
+// Fixed-size operators: generators are stored in fixed-size vectors, products and
+// solves return fixed-size results, and small sizes go through the coeff-based
+// product dispatch.
+template <typename Scalar, int N>
+void test_circulant_fixed() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, N, 1> VecN;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, N, N> MatN;
+
+  VecN c = VecN::Random();
+  c[0] += Scalar(RealScalar(2 * N));  // well conditioned for the solve below
+  Circulant<Scalar, N> C(c);
+  STATIC_CHECK((Circulant<Scalar, N>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeCirculant(c))>::RowsAtCompileTime == N));
+
+  MatN dense = C;
+  VERIFY_IS_APPROX(dense, MatN(reference_circulant<Scalar>(Vec(c))));
+
+  VecN x = VecN::Random();
+  VecN y = C * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  VecN b = VecN::Random();
+  VecN xs = C.solve(b);
+  VERIFY_IS_APPROX((dense * xs).eval(), b);
+
+  STATIC_CHECK((internal::remove_all_t<decltype(C.transpose())>::RowsAtCompileTime == N));
+  VecN xt = C.transpose() * x;
+  VERIFY_IS_APPROX(xt, (dense.transpose() * x).eval());
+}
+
+template <typename Scalar, int M, int N>
+void test_toeplitz_fixed() {
+  typedef Matrix<Scalar, M, 1> ColVec;
+  typedef Matrix<Scalar, N, 1> RowVec;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, M, N> MatMN;
+
+  ColVec c = ColVec::Random();
+  RowVec r = RowVec::Random();
+  r[0] = c[0];
+  Toeplitz<Scalar, M, N> T(c, r);
+  STATIC_CHECK((Toeplitz<Scalar, M, N>::RowsAtCompileTime == M));
+  STATIC_CHECK((Toeplitz<Scalar, M, N>::ColsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeToeplitz(c, r))>::ColsAtCompileTime == N));
+
+  MatMN dense = T;
+  VERIFY_IS_APPROX(dense, MatMN(reference_toeplitz<Scalar>(Vec(c), Vec(r))));
+
+  RowVec x = RowVec::Random();
+  Matrix<Scalar, M, 1> y = T * x;
+  VERIFY_IS_APPROX(y, (dense * x).eval());
+
+  STATIC_CHECK((internal::remove_all_t<decltype(T.transpose())>::RowsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(T.transpose())>::ColsAtCompileTime == M));
+  ColVec w = ColVec::Random();
+  RowVec tw = T.transpose() * w;
+  VERIFY_IS_APPROX(tw, (dense.transpose() * w).eval());
+}
+
+template <typename Scalar>
+void test_matrix_free_cg(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Symmetric, strongly diagonally dominant circulant => SPD.
+  Vec c = Vec::Zero(n);
+  c[0] = Scalar(4);
+  c[1] = Scalar(-1);
+  c[n - 1] = Scalar(-1);
+  Circulant<Scalar> C(c);
+  Mat dense = reference_circulant<Scalar>(c);
+
+  Vec b = Vec::Random(n);
+  ConjugateGradient<Circulant<Scalar>, Lower | Upper, IdentityPreconditioner> cg;
+  cg.compute(C);
+  Vec x = cg.solve(b);
+  VERIFY(cg.info() == Success);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+}
+
+template <typename Scalar>
+void test_matrix_free_gmres(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  // Strongly diagonally dominant (nonsymmetric) Toeplitz.
+  Vec c = Vec::Random(n) * Scalar(RealScalar(0.1));
+  Vec r = Vec::Random(n) * Scalar(RealScalar(0.1));
+  c[0] = Scalar(3);
+  r[0] = Scalar(3);
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = reference_toeplitz<Scalar>(c, r);
+
+  Vec b = Vec::Random(n);
+  GMRES<Toeplitz<Scalar>, IdentityPreconditioner> gmres;
+  gmres.compute(T);
+  Vec x = gmres.solve(b);
+  VERIFY(gmres.info() == Success);
+  VERIFY_IS_APPROX((dense * x).eval(), b);
+}
+
+// With adjoint() available, the rectangular operators feed Eigen's matrix-free
+// least-squares solvers end to end: both LSMR and LeastSquaresConjugateGradient
+// evaluate mat.adjoint() * v through the fast product.
+template <typename Scalar>
+void test_matrix_free_least_squares(Index m, Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(m), r = Vec::Random(n);
+  c[0] += Scalar(RealScalar(4));  // boost the diagonal to bound the conditioning
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = reference_toeplitz<Scalar>(c, r);
+
+  Vec b = Vec::Random(m);
+  Vec xref = dense.colPivHouseholderQr().solve(b);
+
+  // Forward-error bound for the diagonally-boosted (well-conditioned) operator.
+  const RealScalar tol = RealScalar(5e8) * NumTraits<RealScalar>::epsilon();  // ~1e-7 in double
+
+  LSMR<Toeplitz<Scalar>, IdentityPreconditioner> lsmr;
+  lsmr.setTolerance(RealScalar(1e-12)).setMaxIterations(10 * n);
+  lsmr.compute(T);
+  Vec x = lsmr.solve(b);
+  VERIFY(lsmr.info() == Success);
+  VERIFY((x - xref).norm() <= tol * xref.norm());
+
+  LeastSquaresConjugateGradient<Toeplitz<Scalar>, IdentityPreconditioner> lscg;
+  lscg.setTolerance(RealScalar(1e-12));
+  lscg.setMaxIterations(10 * n);
+  lscg.compute(T);
+  Vec x2 = lscg.solve(b);
+  VERIFY(lscg.info() == Success);
+  VERIFY((x2 - xref).norm() <= tol * xref.norm());
+}
+
+// Diagonally dominant (well-conditioned) Toeplitz: the look-ahead solver must agree
+// with a dense LU solve.
+template <typename Scalar>
+void test_levinson_wellcond(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  c[0] = r[0] = Scalar(RealScalar(2 * n));
+  Toeplitz<Scalar> T(c, r);
+  Mat dense = T;
+
+  Vec b = Vec::Random(n);
+  LookAheadLevinson<Scalar> lev(T);
+  VERIFY(lev.info() == Success);
+  Vec x = lev.solve(b);
+  VERIFY_IS_APPROX(x, dense.fullPivLu().solve(b).eval());
+
+  // Multiple right-hand sides.
+  Mat B = Mat::Random(n, 3);
+  VERIFY_IS_APPROX(lev.solve(B), dense.fullPivLu().solve(B).eval());
+
+  // Transposed and adjoint systems reuse the same factorization (persymmetry).
+  Vec xt = lev.transpose().solve(b);
+  VERIFY_IS_APPROX(xt, dense.transpose().fullPivLu().solve(b).eval());
+  Vec xa = lev.adjoint().solve(b);
+  VERIFY_IS_APPROX(xa, dense.adjoint().fullPivLu().solve(b).eval());
+  Mat Xt = lev.transpose().solve(B);
+  VERIFY_IS_APPROX(Xt, dense.transpose().fullPivLu().solve(B).eval());
+}
+
+// Indefinite / ill-conditioned matrices that force look-ahead block steps. The
+// generators and required block sizes are from Chan & Hansen's test set; the true
+// solution is the all-ones vector.
+void test_levinson_lookahead() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  // Loose bound for these deliberately ill-conditioned look-ahead cases (~1e-9);
+  // the look-ahead Levinson recursion is weakly stable, so the forward error is a
+  // large but bounded multiple of epsilon.
+  const double tol = 5e6 * NumTraits<double>::epsilon();
+  auto check = [tol](const Vec& c, const Vec& r, Index pmax) {
+    Toeplitz<double> T(c, r);
+    Vec xt = Vec::Ones(c.size());
+    Vec b = T * xt;
+    LookAheadLevinson<double> lev;
+    lev.setMaxBlockSize(pmax).compute(T);
+    VERIFY(lev.info() == Success);
+    Vec x = lev.solve(b);
+    VERIFY((x - xt).norm() <= tol * xt.norm());
+
+    // The transposed solve must track the same look-ahead block steps.
+    Matrix<double, Dynamic, Dynamic> dense = T;
+    Vec bt = dense.transpose() * xt;
+    Vec y = lev.transpose().solve(bt);
+    VERIFY((y - xt).norm() <= tol * xt.norm());
+  };
+
+  Vec c1(6), r1(6);  // Sweet-1 (block size 2)
+  c1 << 4, 6, 71.0 / 15 + 5e-8, 5, 3, 1;
+  r1 << 4, 8, 1, 6, 2, 3;
+  check(c1, r1, 3);
+
+  Vec c2(6), r2(6);  // Sweet-2 (block size 2)
+  c2 << 8, 4, -34 + 5e-13, 5, 3, 1;
+  r2 << 8, 4, 1, 6, 2, 3;
+  check(c2, r2, 3);
+
+  Vec c3(13), r3(13);  // Sweet-3 (block size 6)
+  c3 << 5, 1, -3, 12.755, -19.656, 28.361, -7, -1, 2, 1, -6, 1, -0.5;
+  r3 << 5, -1, 6, 2, 5.697, 5.850, 3, -5, -2, -7, 1, 10, -15;
+  check(c3, r3, 6);
+
+  // shifted KMS: leading submatrices T_k with k = 1,4,7,... are singular, so the
+  // full order n must be a multiple of 3 for T_n itself to be non-singular.
+  for (Index n : {15, 30, 60}) {
+    Vec c(n), r(n);
+    c[0] = r[0] = 1e-14;
+    for (Index i = 1; i < n; ++i) c[i] = r[i] = std::pow(0.5, double(i - 1));
+    check(c, r, 3);
+  }
+}
+
+// Fixed-size Toeplitz operators also feed the solver.
+void test_levinson_fixed() {
+  typedef Matrix<double, 12, 1> Vec12;
+  Vec12 c = Vec12::Random(), r = Vec12::Random();
+  c[0] = r[0] = 24.0;
+  Toeplitz<double, 12, 12> T(c, r);
+  Matrix<double, 12, 12> dense = T;
+  Vec12 b = Vec12::Random();
+  LookAheadLevinson<double> lev(T);
+  VERIFY(lev.info() == Success);
+  VERIFY_IS_APPROX(lev.solve(b), dense.fullPivLu().solve(b).eval());
+}
+
+// Evaluating the Solve expression inside a larger expression (rather than
+// assigning it straight to a plain matrix) goes through evaluator<Solve>, which
+// caches pointers into its preallocated result before _solve_impl runs:
+// _solve_impl must copy into the destination coefficient-wise, never move-assign
+// it (a move steals the buffer and leaves the cached pointers dangling). Only a
+// matrix right-hand side is affected: a vector one has a different plain type,
+// which cannot select the move-assignment. Hankel::solve wraps the Levinson
+// solve in exactly such an expression (colwise().reverse()).
+template <typename Scalar>
+void test_levinson_solve_in_expression(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec c = Vec::Random(n), r = Vec::Random(n);
+  r[0] = c[0] += Scalar(RealScalar(2 * n));  // diagonally dominant => well conditioned
+  Toeplitz<Scalar> T(c, r);
+  LookAheadLevinson<Scalar> lev(T);
+  VERIFY(lev.info() == Success);
+
+  Mat B = Mat::Random(n, 3);
+  Mat direct = lev.solve(B);  // plain assignment: solves straight into `direct`
+  Mat inExpr = lev.solve(B).colwise().reverse();
+  VERIFY_IS_APPROX(inExpr, direct.colwise().reverse().eval());
+
+  Vec b = Vec::Random(n);
+  Vec x = lev.solve(b).colwise().reverse();
+  VERIFY_IS_APPROX(x, Vec(Vec(lev.solve(b)).reverse()));
+}
+
+// A numerically singular Toeplitz must be reported through info().
+void test_levinson_singular() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  for (Index n : {4, 9}) {
+    Vec c = Vec::Ones(n), r = Vec::Ones(n);  // all-ones Toeplitz is rank 1 for n >= 2
+    LookAheadLevinson<double> lev(Toeplitz<double>(c, r));
+    VERIFY(lev.info() == NumericalIssue);
+  }
+}
+
+EIGEN_DECLARE_TEST(structured_matrices) {
+  for (int i = 0; i < g_repeat; ++i) {
+    // Circulant: direct path (small), FFT path (composite and prime sizes), edge cases.
+    CALL_SUBTEST_1((test_circulant_product<double>(1)));
+    CALL_SUBTEST_1((test_circulant_product<double>(2)));
+    CALL_SUBTEST_1((test_circulant_product<double>(8)));
+    CALL_SUBTEST_1((test_circulant_product<double>(64)));
+    CALL_SUBTEST_1((test_circulant_product<double>(97)));  // prime: padded embedding product
+    CALL_SUBTEST_1((test_circulant_product<std::complex<double>>(97)));
+    CALL_SUBTEST_1((test_circulant_product<float>(48)));
+    CALL_SUBTEST_1((test_circulant_product<std::complex<double>>(7)));  // direct path, complex
+    CALL_SUBTEST_1((test_circulant_product<std::complex<double>>(50)));
+    CALL_SUBTEST_1((test_circulant_product<std::complex<float>>(40)));
+    CALL_SUBTEST_1((test_circulant_solve<double>(1)));  // degenerate 1x1 solve
+    CALL_SUBTEST_1((test_circulant_solve<double>(8)));
+    CALL_SUBTEST_1((test_circulant_solve<double>(50)));
+    CALL_SUBTEST_1((test_circulant_solve<double>(97)));  // prime: solve keeps the exact-size symbol
+    CALL_SUBTEST_1((test_circulant_solve<std::complex<double>>(40)));
+    CALL_SUBTEST_1((test_circulant_solve<float>(32)));
+    CALL_SUBTEST_1((test_circulant_symbol<double>(16)));
+    CALL_SUBTEST_1((test_circulant_symbol<std::complex<double>>(12)));
+
+    // Toeplitz: square, tall, wide, small (direct), single row/column, real and complex.
+    CALL_SUBTEST_2((test_toeplitz_product<double>(1, 1)));
+    CALL_SUBTEST_2((test_toeplitz_product<double>(2, 2)));
+    CALL_SUBTEST_2((test_toeplitz_product<double>(10, 10)));
+    CALL_SUBTEST_2((test_toeplitz_product<double>(64, 64)));
+    CALL_SUBTEST_2((test_toeplitz_product<double>(96, 48)));
+    CALL_SUBTEST_2((test_toeplitz_product<double>(48, 96)));
+    CALL_SUBTEST_2((test_toeplitz_product<double>(1, 40)));  // single row, FFT path
+    CALL_SUBTEST_2((test_toeplitz_product<double>(40, 1)));  // single column, FFT path
+    CALL_SUBTEST_2((test_toeplitz_product<float>(50, 50)));
+    CALL_SUBTEST_2((test_toeplitz_product<std::complex<double>>(5, 7)));  // direct path, complex
+    CALL_SUBTEST_2((test_toeplitz_product<std::complex<double>>(48, 64)));
+    CALL_SUBTEST_2((test_toeplitz_product<std::complex<float>>(40, 40)));
+
+    // Matrix-free iterative solves through the existing solvers.
+    CALL_SUBTEST_3((test_matrix_free_cg<double>(80)));
+    CALL_SUBTEST_3((test_matrix_free_gmres<double>(80)));
+    CALL_SUBTEST_3((test_matrix_free_least_squares<double>(60, 40)));
+    CALL_SUBTEST_3((test_matrix_free_least_squares<std::complex<double>>(48, 32)));
+
+    // Fixed-size operators: small (coeff-based dispatch) and above the FFT threshold.
+    CALL_SUBTEST_4((test_circulant_fixed<double, 4>()));
+    CALL_SUBTEST_4((test_circulant_fixed<std::complex<float>, 4>()));
+    CALL_SUBTEST_4((test_circulant_fixed<double, 48>()));
+    CALL_SUBTEST_4((test_toeplitz_fixed<double, 4, 6>()));
+    CALL_SUBTEST_4((test_toeplitz_fixed<double, 40, 24>()));
+    CALL_SUBTEST_4((test_toeplitz_fixed<std::complex<float>, 6, 4>()));
+
+    // Transposition family across the dispatch tiers (scalar, direct, FFT incl. prime).
+    CALL_SUBTEST_6((test_circulant_transpose<double>(1)));
+    CALL_SUBTEST_6((test_circulant_transpose<double>(8)));
+    CALL_SUBTEST_6((test_circulant_transpose<double>(24)));
+    CALL_SUBTEST_6((test_circulant_transpose<double>(97)));
+    CALL_SUBTEST_6((test_circulant_transpose<float>(48)));
+    CALL_SUBTEST_6((test_circulant_transpose<std::complex<double>>(40)));
+    CALL_SUBTEST_6((test_circulant_transpose<std::complex<float>>(33)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<double>(1, 1)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<double>(12, 7)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<double>(64, 40)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<double>(40, 64)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<double>(1, 40)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<std::complex<double>>(48, 48)));
+    CALL_SUBTEST_6((test_toeplitz_transpose<std::complex<float>>(20, 36)));
+
+    // Closed-form eigendecomposition, SVD, pseudo-inverse solve, inverse, determinant.
+    CALL_SUBTEST_7((test_circulant_eigen<double>(1)));
+    CALL_SUBTEST_7((test_circulant_eigen<double>(16)));
+    CALL_SUBTEST_7((test_circulant_eigen<double>(40)));
+    CALL_SUBTEST_7((test_circulant_eigen<std::complex<double>>(21)));
+    CALL_SUBTEST_7((test_circulant_svd<double>(1)));
+    CALL_SUBTEST_7((test_circulant_svd<double>(19)));
+    CALL_SUBTEST_7((test_circulant_svd<double>(18)));  // conjugate-pair moduli routinely differ in the last bits
+    CALL_SUBTEST_7((test_circulant_svd<double>(24)));
+    CALL_SUBTEST_7((test_circulant_svd<std::complex<double>>(18)));
+    CALL_SUBTEST_7((test_circulant_svd<float>(12)));
+    CALL_SUBTEST_7((test_circulant_minnorm_solve<double>(20)));
+    CALL_SUBTEST_7((test_circulant_minnorm_solve<std::complex<double>>(15)));
+    CALL_SUBTEST_7((test_circulant_rank_deficient<std::complex<double>>(24, 3)));
+    CALL_SUBTEST_7((test_circulant_rank_deficient<std::complex<double>>(50, 5)));
+    CALL_SUBTEST_7((test_circulant_rank_deficient<std::complex<float>>(16, 2)));
+    CALL_SUBTEST_7((test_circulant_zero<double>(12)));
+    CALL_SUBTEST_7((test_circulant_zero<std::complex<double>>(7)));
+    CALL_SUBTEST_7(test_circulant_nan_propagation(20));
+    CALL_SUBTEST_7((test_circulant_inverse<double>(1)));
+    CALL_SUBTEST_7((test_circulant_inverse<double>(50)));
+    CALL_SUBTEST_7((test_circulant_inverse<double>(97)));  // prime: inverse rebuilds the padded product symbol
+    CALL_SUBTEST_7((test_circulant_inverse<std::complex<double>>(20)));
+    CALL_SUBTEST_7((test_circulant_inverse<float>(16)));
+    CALL_SUBTEST_7((test_circulant_determinant<double>(1)));
+    CALL_SUBTEST_7((test_circulant_determinant<double>(12)));
+    CALL_SUBTEST_7((test_circulant_determinant<std::complex<double>>(9)));
+
+    // Numerical and lifetime boundaries: value-nested (owning) delayed products,
+    // aliased products across the dispatch tiers (scalar, direct, FFT), the
+    // balanced determinant accumulation, and the rank threshold boundary.
+    CALL_SUBTEST_8((test_circulant_delayed_product<double>(24)));
+    CALL_SUBTEST_8((test_circulant_delayed_product<std::complex<double>>(48)));
+    CALL_SUBTEST_8((test_toeplitz_delayed_product<double>(40, 24)));
+    CALL_SUBTEST_8((test_toeplitz_delayed_product<std::complex<float>>(12, 8)));
+    CALL_SUBTEST_8((test_circulant_aliased_product<double>(8)));
+    CALL_SUBTEST_8((test_circulant_aliased_product<double>(64)));
+    CALL_SUBTEST_8((test_circulant_aliased_product<std::complex<double>>(40)));
+    CALL_SUBTEST_8((test_toeplitz_aliased_product<double>(12)));
+    CALL_SUBTEST_8((test_toeplitz_aliased_product<double>(48)));
+    CALL_SUBTEST_8((test_toeplitz_aliased_product<std::complex<float>>(36)));
+    CALL_SUBTEST_8((test_circulant_mixed_scalar<double>(8)));
+    CALL_SUBTEST_8((test_circulant_mixed_scalar<double>(24)));
+    CALL_SUBTEST_8((test_circulant_mixed_scalar<double>(64)));
+    CALL_SUBTEST_8((test_circulant_mixed_scalar<float>(97)));
+    CALL_SUBTEST_8((test_toeplitz_mixed_scalar<double>(8, 8)));
+    CALL_SUBTEST_8((test_toeplitz_mixed_scalar<double>(64, 40)));
+    CALL_SUBTEST_8(test_circulant_determinant_scaled());
+    CALL_SUBTEST_8(test_circulant_rank_boundaries());
+    CALL_SUBTEST_8(test_circulant_rank_complex_boundary());
+    CALL_SUBTEST_8((test_structured_fft_overflow<double>(40)));
+    CALL_SUBTEST_8((test_structured_fft_overflow<double>(97)));  // prime, no 5-smooth padding
+    CALL_SUBTEST_8((test_structured_fft_overflow<float>(40)));
+    CALL_SUBTEST_8((test_structured_fft_complex_boundary<double>(40)));
+    CALL_SUBTEST_8((test_structured_fft_complex_boundary<float>(40)));
+
+    // Aliasing beyond the same-object case, across the dispatch tiers.
+    CALL_SUBTEST_8((test_structured_aliased_expression<double>(8)));
+    CALL_SUBTEST_8((test_structured_aliased_expression<double>(24)));
+    CALL_SUBTEST_8((test_structured_aliased_expression<double>(48)));
+    CALL_SUBTEST_8((test_structured_aliased_expression<std::complex<double>>(40)));
+
+    // Entrywise Inf/NaN propagation: FFT-sized operators must fall back to the
+    // direct kernel; small ones are IEEE-exact already.
+    CALL_SUBTEST_8((test_structured_nonfinite_product<double>(40)));
+    CALL_SUBTEST_8((test_structured_nonfinite_product<double>(12)));
+    CALL_SUBTEST_8((test_structured_nonfinite_product<std::complex<double>>(40)));
+
+    // Look-ahead Levinson direct Toeplitz solver, one subtest per scalar type:
+    // each type pulls in its own FullPivLU reference solves for vector and matrix
+    // right-hand sides, which together made this the most memory-hungry
+    // translation unit in the test suite.
+    CALL_SUBTEST_5((test_levinson_wellcond<double>(1)));
+    CALL_SUBTEST_5((test_levinson_wellcond<double>(2)));
+    CALL_SUBTEST_5((test_levinson_wellcond<double>(20)));
+    CALL_SUBTEST_5((test_levinson_wellcond<double>(60)));
+    CALL_SUBTEST_11((test_levinson_wellcond<float>(40)));
+    CALL_SUBTEST_12((test_levinson_wellcond<std::complex<double>>(30)));
+    CALL_SUBTEST_12((test_levinson_solve_in_expression<std::complex<double>>(16)));
+    CALL_SUBTEST_13(test_levinson_lookahead());
+    CALL_SUBTEST_13(test_levinson_fixed());
+    CALL_SUBTEST_13(test_levinson_singular());
+    CALL_SUBTEST_13((test_levinson_solve_in_expression<double>(1)));
+    CALL_SUBTEST_13((test_levinson_solve_in_expression<double>(24)));
+    CALL_SUBTEST_14((test_levinson_wellcond<std::complex<float>>(24)));
+
+    // Hankel: products across dispatch tiers, transposition family (validating the
+    // phase-multiplication symbol reuse on rectangular FFT-tier operators), the
+    // Toeplitz equivalence, direct solves, matrix-free least squares, fixed sizes.
+    CALL_SUBTEST_9((test_hankel_product<double>(1, 1)));
+    CALL_SUBTEST_9((test_hankel_product<double>(2, 3)));
+    CALL_SUBTEST_9((test_hankel_product<double>(8, 8)));
+    CALL_SUBTEST_9((test_hankel_product<double>(12, 7)));
+    CALL_SUBTEST_9((test_hankel_product<double>(17, 16)));  // just above the scalar tier
+    CALL_SUBTEST_9((test_hankel_product<double>(20, 24)));  // direct segment tier
+    CALL_SUBTEST_9((test_hankel_product<double>(32, 33)));  // first FFT-tier size
+    CALL_SUBTEST_9((test_hankel_product<double>(64, 40)));
+    CALL_SUBTEST_9((test_hankel_product<double>(40, 64)));
+    CALL_SUBTEST_9((test_hankel_product<double>(97, 50)));
+    CALL_SUBTEST_9((test_hankel_product<double>(1, 40)));   // single row: direct O(n) path
+    CALL_SUBTEST_9((test_hankel_product<double>(40, 1)));   // single column: direct O(n) path
+    CALL_SUBTEST_9((test_hankel_product<double>(1, 400)));  // skinny far beyond the FFT threshold
+    CALL_SUBTEST_9((test_hankel_product<double>(400, 1)));
+    CALL_SUBTEST_9((test_hankel_product<float>(50, 50)));
+    CALL_SUBTEST_9((test_hankel_product<std::complex<double>>(5, 7)));
+    CALL_SUBTEST_9((test_hankel_product<std::complex<double>>(48, 64)));
+    CALL_SUBTEST_9((test_hankel_product<std::complex<float>>(40, 40)));
+    CALL_SUBTEST_9((test_hankel_transpose<double>(1, 1)));
+    CALL_SUBTEST_9((test_hankel_transpose<double>(12, 7)));
+    CALL_SUBTEST_9((test_hankel_transpose<double>(20, 24)));  // direct tier, empty symbol
+    CALL_SUBTEST_9((test_hankel_transpose<double>(64, 40)));
+    CALL_SUBTEST_9((test_hankel_transpose<double>(40, 64)));
+    CALL_SUBTEST_9((test_hankel_transpose<double>(1, 40)));
+    CALL_SUBTEST_9((test_hankel_transpose<std::complex<double>>(33, 20)));
+    CALL_SUBTEST_9((test_hankel_transpose<std::complex<float>>(20, 36)));
+    CALL_SUBTEST_9((test_hankel_symmetry<double>(48)));
+    CALL_SUBTEST_9((test_hankel_to_toeplitz<double>(12, 7)));
+    CALL_SUBTEST_9((test_hankel_to_toeplitz<std::complex<double>>(40, 56)));
+    CALL_SUBTEST_9((test_hankel_solve<double>(1)));
+    CALL_SUBTEST_9((test_hankel_solve<double>(20)));
+    CALL_SUBTEST_9((test_hankel_solve<double>(45)));
+    CALL_SUBTEST_9((test_hankel_solve<std::complex<double>>(24)));
+    CALL_SUBTEST_9((test_hankel_solve<float>(16)));
+    CALL_SUBTEST_9((test_hankel_solve_lookahead<double>(20)));
+    CALL_SUBTEST_9((test_hankel_solve_lookahead<std::complex<double>>(15)));
+    CALL_SUBTEST_9(test_hankel_hilbert());
+    CALL_SUBTEST_9((test_hankel_least_squares<double>(60, 40)));
+    CALL_SUBTEST_9((test_hankel_least_squares<std::complex<double>>(48, 32)));
+    CALL_SUBTEST_9((test_hankel_fixed<double, 4, 6>()));
+    CALL_SUBTEST_9((test_hankel_fixed<double, 40, 24>()));
+    CALL_SUBTEST_9((test_hankel_fixed<std::complex<float>, 6, 4>()));
+    CALL_SUBTEST_9((test_hankel_fixed_solve<double, 8>()));
+    CALL_SUBTEST_9((test_hankel_fixed_solve<std::complex<double>, 12>()));
+
+    // MR 2688 review regressions: finite-overflow scaling in the FFT tier,
+    // delayed (value-nested) products, aliased right-hand sides across the
+    // dispatch tiers, and mixed real/complex products.
+    CALL_SUBTEST_10(test_hankel_fft_overflow());
+    CALL_SUBTEST_10((test_hankel_fft_complex_boundary<double>(40)));
+    CALL_SUBTEST_10((test_hankel_fft_complex_boundary<float>(40)));
+    CALL_SUBTEST_10((test_hankel_delayed_product<double>(24, 12)));
+    CALL_SUBTEST_10((test_hankel_delayed_product<double>(40, 64)));
+    CALL_SUBTEST_10((test_hankel_delayed_product<std::complex<double>>(48, 33)));
+    CALL_SUBTEST_10((test_hankel_aliased_product<double>(8)));   // scalar tier
+    CALL_SUBTEST_10((test_hankel_aliased_product<double>(24)));  // direct segment tier
+    CALL_SUBTEST_10((test_hankel_aliased_product<double>(64)));  // FFT tier
+    CALL_SUBTEST_10((test_hankel_aliased_product<std::complex<double>>(40)));
+
+    // Aliasing beyond the same-object case, across the dispatch tiers.
+    CALL_SUBTEST_10((test_hankel_aliased_expression<double>(8)));
+    CALL_SUBTEST_10((test_hankel_aliased_expression<double>(24)));
+    CALL_SUBTEST_10((test_hankel_aliased_expression<double>(48)));
+    CALL_SUBTEST_10((test_hankel_aliased_expression<std::complex<double>>(40)));
+
+    // Entrywise Inf/NaN propagation: FFT-sized operators must fall back to the
+    // direct kernels; small ones are IEEE-exact already.
+    CALL_SUBTEST_10((test_hankel_nonfinite_product<double>(40)));
+    CALL_SUBTEST_10((test_hankel_nonfinite_product<double>(12)));
+    CALL_SUBTEST_10((test_hankel_nonfinite_product<std::complex<double>>(40)));
+
+    CALL_SUBTEST_10((test_hankel_mixed_scalar<double>(8, 8)));    // scalar tier
+    CALL_SUBTEST_10((test_hankel_mixed_scalar<double>(24, 20)));  // direct segment tier
+    CALL_SUBTEST_10((test_hankel_mixed_scalar<double>(64, 40)));  // FFT tier
+    CALL_SUBTEST_10((test_hankel_mixed_scalar<double>(1, 40)));   // skinny direct paths
+    CALL_SUBTEST_10((test_hankel_mixed_scalar<double>(40, 1)));
+    CALL_SUBTEST_10((test_hankel_mixed_scalar<float>(48, 64)));
+  }
+}
diff --git a/contrib/test/structured_vandermonde.cpp b/contrib/test/structured_vandermonde.cpp
new file mode 100644
index 0000000..aea01a2
--- /dev/null
+++ b/contrib/test/structured_vandermonde.cpp
@@ -0,0 +1,816 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Reference dense Vandermonde built entry-wise from the nodes.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, Dynamic> reference_vandermonde(const Matrix<Scalar, Dynamic, 1>& x, Index n) {
+  const Index m = x.size();
+  Matrix<Scalar, Dynamic, Dynamic> dense(m, n);
+  for (Index i = 0; i < m; ++i) {
+    Scalar p(1);
+    for (Index j = 0; j < n; ++j) {
+      dense(i, j) = p;
+      p *= x[i];
+    }
+  }
+  return dense;
+}
+
+template <typename Scalar>
+void test_vandermonde_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x = Vec::Random(m);
+  Vandermonde<Scalar> V(x, n);
+  Mat dense = reference_vandermonde<Scalar>(x, n);
+
+  Mat Vd = V;
+  VERIFY_IS_APPROX(Vd, dense);
+  for (Index t = 0; t < 5; ++t) {
+    Index i = internal::random<Index>(0, m - 1), j = internal::random<Index>(0, n - 1);
+    VERIFY_IS_APPROX(V.coeff(i, j), dense(i, j));
+  }
+
+  Vec a = Vec::Random(n);
+  VERIFY_IS_APPROX((V * a).eval(), (dense * a).eval());
+
+  Mat A = Mat::Random(n, 3);
+  VERIFY_IS_APPROX((V * A).eval(), (dense * A).eval());
+
+  // Accumulation form exercised by the iterative solvers.
+  Vec y = Vec::Random(m);
+  Vec y0 = y;
+  y.noalias() += V * a;
+  VERIFY_IS_APPROX(y, (y0 + dense * a).eval());
+}
+
+// Well-conditioned interpolation: Chebyshev-like nodes in [-1,1] keep the
+// conditioning around (1+sqrt(2))^n, so for moderate n a modest tolerance wide
+// of roundoff verifies the primal and dual solves against the exact solution.
+template <typename Scalar>
+void test_bjorck_pereyra(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x(n);
+  for (Index i = 0; i < n; ++i)
+    x[i] = Scalar(RealScalar(std::cos(double(EIGEN_PI) * double(2 * i + 1) / double(2 * n))));  // Chebyshev nodes
+  Vandermonde<Scalar> V(x);
+  Mat dense = reference_vandermonde<Scalar>(x, n);
+
+  BjorckPereyra<Scalar> bp(V);
+  VERIFY(bp.info() == Success);
+
+  // Forward-error bound for the (moderately conditioned) Chebyshev-node system.
+  const RealScalar tol = RealScalar(5e7) * NumTraits<RealScalar>::epsilon();  // ~1e-8 in double
+
+  // Primal: interpolate values of a known polynomial and recover its coefficients.
+  Vec aTrue = Vec::Random(n);
+  Vec f = dense * aTrue;
+  Vec a = bp.solve(f);
+  VERIFY((a - aTrue).norm() <= tol * aTrue.norm());
+
+  // Dual (moment) system through the SolverBase transpose idiom.
+  Vec wTrue = Vec::Random(n);
+  Vec b = dense.transpose() * wTrue;
+  Vec w = bp.transpose().solve(b);
+  VERIFY((w - wTrue).norm() <= tol * wTrue.norm());
+
+  // Adjoint solve.
+  Vec c = dense.adjoint() * wTrue;
+  Vec u = bp.adjoint().solve(c);
+  VERIFY((u - wTrue).norm() <= tol * wTrue.norm());
+
+  // Multiple right-hand sides.
+  Mat F = Mat::Random(n, 3);
+  Mat A = bp.solve(F);
+  VERIFY_IS_APPROX((dense * A).eval(), F);
+}
+
+// The n-th roots of unity make V/sqrt(n) exactly unitary. Verify against the
+// analytic inverse a = V^H f / n to catch catastrophic Newton-basis growth.
+template <typename RealScalar>
+void test_bjorck_pereyra_roots_of_unity(Index n) {
+  typedef std::complex<RealScalar> Scalar;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+
+  Vec x(n);
+  for (Index i = 0; i < n; ++i)
+    x[i] = std::polar(RealScalar(1), RealScalar(2 * EIGEN_PI) * RealScalar(i) / RealScalar(n));
+  Vandermonde<Scalar> V(x);
+
+  BjorckPereyra<Scalar> bp(V);
+  VERIFY(bp.info() == Success);
+
+  // The first cardinal polynomial has every coefficient equal to 1/n. This
+  // deterministic case exposes the severe Newton-basis growth of cyclic node
+  // order while remaining analytically checkable.
+  Vec f = Vec::Zero(n);
+  f[0] = Scalar(1);
+  Vec a = bp.solve(f);
+  Vec aRef = Vec::Constant(n, Scalar(RealScalar(1) / RealScalar(n)));
+  // The recurrence performs O(n^2) complex operations; the fixed factor also
+  // covers growth in its intermediate Newton coefficients.
+  const RealScalar tol = RealScalar(128) * RealScalar(n) * RealScalar(n) * NumTraits<RealScalar>::epsilon();
+  VERIFY((a - aRef).norm() <= tol * aRef.norm());
+}
+
+// Eigen::half has explicit conversion from the wider type returned by the
+// standard scaling functions. Instantiate both product and solver paths so the
+// range-protection helpers retain support for narrow floating-point scalars.
+void test_vandermonde_half() {
+  typedef Matrix<half, 2, 1> Vec;
+  Vec nodes, coefficients;
+  nodes << half(0), half(2);
+  coefficients << half(3), half(2);
+
+  Vandermonde<half, 2, 2> V(nodes);
+  Vec values = V * coefficients;
+  VERIFY_IS_EQUAL(float(values[0]), 3.0f);
+  VERIFY_IS_EQUAL(float(values[1]), 7.0f);
+
+  BjorckPereyra<half> bp(V);
+  Vec recovered = bp.solve(values);
+  VERIFY_IS_EQUAL(float(recovered[0]), 3.0f);
+  VERIFY_IS_EQUAL(float(recovered[1]), 2.0f);
+}
+
+// Björck-Pereyra's celebrated accuracy property (Higham, ASNA ch. 22): for
+// monotone nodes and an alternating-sign right-hand side the forward error is
+// tiny even though the matrix conditioning is astronomical. Deterministic.
+void test_bjorck_pereyra_higham() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+
+  const Index n = 20;
+  Vec x(n);
+  for (Index i = 0; i < n; ++i) x[i] = double(i + 1) / 32.0;  // exactly represented, monotone in (0,1)
+  Vandermonde<double> V(x);
+
+  // f_i = (-1)^i: alternating signs.
+  Vec f(n);
+  for (Index i = 0; i < n; ++i) f[i] = (i % 2 == 0) ? 1.0 : -1.0;
+  BjorckPereyra<double> bp(V);
+  Vec a = bp.solve(f);
+
+  // Independent long-double coefficient reference. For equally spaced nodes
+  // with h=1/32, the Newton weights are Delta^k f_0 / (k! h^k) = (-64)^k/k!.
+  // Accumulate weight_k * product_{j<k}(z-x_j) directly in the monomial basis.
+  Matrix<long double, Dynamic, 1> aRef = Matrix<long double, Dynamic, 1>::Zero(n);
+  Matrix<long double, Dynamic, 1> basis = Matrix<long double, Dynamic, 1>::Zero(n);
+  basis[0] = 1.0L;
+  long double weight = 1.0L;
+  for (Index k = 0; k < n; ++k) {
+    aRef += weight * basis;
+    if (k + 1 == n) break;
+    const long double node = static_cast<long double>(x[k]);
+    basis[k + 1] = basis[k];
+    for (Index j = k; j > 0; --j) basis[j] = basis[j - 1] - node * basis[j];
+    basis[0] *= -node;
+    weight *= -64.0L / static_cast<long double>(k + 1);
+  }
+
+  const Vec roundedRef = aRef.cast<double>();
+  const double maxRelativeError = ((a - roundedRef).cwiseAbs().array() / roundedRef.cwiseAbs().array()).maxCoeff();
+  const double coefficientTol = 8.0 * double(n) * double(n) * NumTraits<double>::epsilon();
+  VERIFY(maxRelativeError <= coefficientTol);
+}
+
+// The transpose and adjoint recurrences must be distinguished for genuinely
+// complex nodes. A rotated root-of-unity grid keeps both systems well
+// conditioned while avoiding the unrotated grid's extra symmetries.
+void test_bjorck_pereyra_complex_transpose_adjoint(Index n) {
+  typedef std::complex<double> Scalar;
+  typedef Matrix<double, Dynamic, 1> RealVec;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x(n);
+  for (Index i = 0; i < n; ++i) x[i] = std::polar(1.0, double(2 * EIGEN_PI) * (double(i) + 0.25) / double(n));
+  Vandermonde<Scalar> V(x);
+  Mat dense = reference_vandermonde<Scalar>(x, n);
+  BjorckPereyra<Scalar> bp(V);
+
+  Vec expected = Vec::Random(n);
+  Vec transposed = bp.transpose().solve(dense.transpose() * expected);
+  Vec adjoint = bp.adjoint().solve(dense.adjoint() * expected);
+  const double tol = 256.0 * double(n) * double(n) * NumTraits<double>::epsilon();
+  const double scale = numext::maxi(1.0, expected.norm());
+  VERIFY((transposed - expected).norm() <= tol * scale);
+  VERIFY((adjoint - expected).norm() <= tol * scale);
+
+  // A real right-hand side is compatible with complex nodes and promotes the
+  // solve result to complex. The rotated Fourier matrix has V^H V = n I, so
+  // all three analytic inverse forms are available without another solver.
+  RealVec realRhs = RealVec::Random(n);
+  Vec primalMixed = bp.solve(realRhs);
+  Vec transposedMixed = bp.transpose().solve(realRhs);
+  Vec adjointMixed = bp.adjoint().solve(realRhs);
+  Vec primalRef = dense.adjoint() * realRhs / Scalar(double(n));
+  Vec transposedRef = dense.conjugate() * realRhs / Scalar(double(n));
+  Vec adjointRef = dense * realRhs / Scalar(double(n));
+  const double mixedScale = numext::maxi(1.0, realRhs.norm());
+  VERIFY((primalMixed - primalRef).norm() <= tol * mixedScale);
+  VERIFY((transposedMixed - transposedRef).norm() <= tol * mixedScale);
+  VERIFY((adjointMixed - adjointRef).norm() <= tol * mixedScale);
+
+  // The reverse promotion direction remains valid as well: real nodes with a
+  // complex right-hand side produce complex work values and output.
+  RealVec realNodes(2);
+  realNodes << -1.0, 1.0;
+  BjorckPereyra<double> realBp{Vandermonde<double>(realNodes)};
+  Vec complexRhs(2), complexExpected(2);
+  complexRhs << Scalar(1.0, 1.0), Scalar(3.0, -2.0);
+  complexExpected << Scalar(2.0, -0.5), Scalar(1.0, -1.5);
+  Vec realNodeMixed = realBp.solve(complexRhs);
+  VERIFY((realNodeMixed - complexExpected).norm() <= 4.0 * NumTraits<double>::epsilon() * complexExpected.norm());
+
+  // Materializing an aliased RHS must precede the internal Leja permutation.
+  Vec aliased = Vec::Random(n);
+  const Vec aliasInput = (aliased + Vec::Ones(n)).eval();
+  const Vec aliasReference = bp.solve(aliasInput);
+  aliased = bp.solve(aliased + Vec::Ones(n));
+  VERIFY((aliased - aliasReference).norm() <= tol * numext::maxi(1.0, aliasReference.norm()));
+}
+
+// Repeated nodes make the matrix exactly singular, while non-finite nodes make
+// the solver input invalid. Both must be reported before solve evaluation.
+void test_bjorck_pereyra_singular() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  Vec x(5);
+  x << 0.1, 0.7, 0.3, 0.7, 0.9;
+  Vandermonde<double> V(x);
+  BjorckPereyra<double> bp(V);
+  VERIFY(bp.info() == NumericalIssue);
+
+  x[3] = std::numeric_limits<double>::quiet_NaN();
+  bp.compute(Vandermonde<double>(x));
+  VERIFY(bp.info() == InvalidInput);
+}
+
+// Aliased products: the products carry the default product tag, so assignment
+// materializes a temporary exactly like a dense product and x = V * x,
+// x += V * x must come out as if the right-hand side had been copied first.
+template <typename Scalar>
+void test_vandermonde_aliased_product(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x = Vec::Random(n);
+  Vandermonde<Scalar> V(x);  // square, so x = V * x type-checks
+  Mat dense = reference_vandermonde<Scalar>(x, n);
+
+  Vec b = Vec::Random(n);
+  Vec y = b;
+  y = V * y;
+  VERIFY_IS_APPROX(y, (dense * b).eval());
+
+  y = b;
+  y += V * y;
+  VERIFY_IS_APPROX(y, (b + dense * b).eval());
+
+  y = b;
+  y -= V * y;
+  VERIFY_IS_APPROX(y, (b - dense * b).eval());
+
+  Mat B = Mat::Random(n, 3);
+  Mat Y = B;
+  Y = V * Y;
+  VERIFY_IS_APPROX(Y, (dense * B).eval());
+}
+
+// Aliasing beyond the same-object case: the default-product temporary must also
+// resolve right-hand-side expressions that reference the destination, overlapping
+// views of one buffer, and rectangular self-assignments where the destination is
+// resized by the assignment.
+template <typename Scalar>
+void test_vandermonde_aliased_expression(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec nodes = Vec::Random(n);
+  Vandermonde<Scalar> V(nodes);  // square
+  Mat dense = reference_vandermonde<Scalar>(nodes, n);
+
+  // Right-hand-side expression referencing the destination.
+  Vec x = Vec::Random(n), x0 = x;
+  x = V * (x + Vec::Ones(n));
+  VERIFY_IS_APPROX(x, (dense * (x0 + Vec::Ones(n))).eval());
+
+  // Overlapping (shifted) segments of one buffer.
+  Vec buf = Vec::Random(n + 1);
+  Vec expected = dense * buf.tail(n);
+  buf.head(n) = V * buf.tail(n);
+  VERIFY_IS_APPROX(buf.head(n).eval(), expected);
+
+  // Rectangular self-assignment (the reviewer's 5x4 case): x = V * x resizes
+  // the destination from 4 to 5, so the product must be captured before the
+  // destination storage is touched.
+  Vec tallNodes = Vec::Random(5);
+  Vandermonde<Scalar> Vt(tallNodes, 4);
+  Mat denseT = reference_vandermonde<Scalar>(tallNodes, 4);
+  Vec z = Vec::Random(4), z0 = z;
+  z = Vt * z;
+  VERIFY_IS_EQUAL(z.size(), 5);
+  VERIFY_IS_APPROX(z, (denseT * z0).eval());
+}
+
+// A delayed-evaluated product expression must keep its structured factor alive:
+// the makeVandermonde() factory returns an owning temporary, so Product has to
+// nest the operator by value (no NestByRefBit) or `expr` dangles.
+template <typename Scalar>
+void test_vandermonde_delayed_product(Index m, Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  STATIC_CHECK(!std::is_reference<typename internal::ref_selector<Vandermonde<Scalar>>::type>::value);
+
+  Vec x = Vec::Random(m), a = Vec::Random(n);
+  Mat dense = reference_vandermonde<Scalar>(x, n);
+
+  auto expr = makeVandermonde(x, n) * a;  // the factory temporary dies with the full expression
+  Vec scribble = Vec::Random(2 * m);      // reuses the temporary's freed heap storage
+  Vec y = expr;
+  VERIFY_IS_APPROX(y, (dense * a).eval());
+  VERIFY_IS_EQUAL(scribble.size(), 2 * m);  // keep the scribble alive across the evaluation
+}
+
+// Mixed-scalar products: a real operator applied to a complex right-hand side
+// (and a complex operator applied to a real one) promotes to the complex
+// product scalar, so alpha and the Horner accumulation must run in the promoted
+// type rather than the operator scalar.
+template <typename RealScalar>
+void test_vandermonde_mixed_scalar(Index m, Index n) {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<RealScalar, Dynamic, 1> RVec;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  typedef Matrix<Complex, Dynamic, Dynamic> CMat;
+
+  RVec x = RVec::Random(m);
+  Vandermonde<RealScalar> V(x, n);
+  CMat dense = reference_vandermonde<RealScalar>(x, n).template cast<Complex>();
+
+  CVec a = CVec::Random(n);
+  CVec y = V * a;
+  VERIFY_IS_APPROX(y, (dense * a).eval());
+
+  CVec y0 = CVec::Random(m);
+  y = y0;
+  y.noalias() += V * a;
+  VERIFY_IS_APPROX(y, (y0 + dense * a).eval());
+
+  CVec xc = CVec::Random(m);
+  Vandermonde<Complex> Vc(xc, n);
+  CMat denseC = reference_vandermonde<Complex>(xc, n);
+  RVec ar = RVec::Random(n);
+  CVec z = Vc * ar;
+  VERIFY_IS_APPROX(z, (denseC * ar).eval());
+}
+
+template <typename Scalar>
+void test_vandermonde_determinant(Index n) {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+
+  Vec x = Vec::Random(n);
+  Vandermonde<Scalar> V(x);
+  Mat dense = reference_vandermonde<Scalar>(x, n);
+  VERIFY_IS_APPROX(V.determinant(), dense.determinant());
+}
+
+// Reference for the wide-dynamic-range determinant tests: the same factor sequence with explicit
+// exponent tracking, halving any factor whose node difference overflows (exact, since a difference
+// only overflows for huge normal operands). Power-of-two rescaling is exact, so this reproduces the
+// exact product up to one rounding per multiplication, representable where naive partial products
+// leave the double range. Finite nodes only.
+double reference_vandermonde_det(const Matrix<double, Dynamic, 1>& x) {
+  double mantissa = 1.0;
+  Index exponent = 0;
+  for (Index j = 1; j < x.size(); ++j)
+    for (Index i = 0; i < j; ++i) {
+      double diff = x[j] - x[i];
+      if (!(numext::isfinite)(diff)) {
+        diff = 0.5 * x[j] - 0.5 * x[i];
+        ++exponent;
+      }
+      int e;
+      mantissa *= std::frexp(diff, &e);
+      exponent += e;
+      mantissa = std::frexp(mantissa, &e);
+      exponent += e;
+    }
+  return std::ldexp(mantissa, static_cast<int>(exponent));
+}
+
+// Balanced determinant accumulation (reviewer repro on MR 2691): the running
+// product is kept as mantissa * 2^e with exact frexp/ldexp renormalization, so
+// partial products that leave the representable range cannot destroy a
+// representable determinant, while zeros and genuine overflow still propagate.
+void test_vandermonde_determinant_scaled() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef std::complex<double> Complex;
+  // The implementation accumulates the identical factor sequence as the
+  // reference above, so the two sides differ only by the exactness of the
+  // power-of-two renormalization.
+  const double kBalancedTol = 16 * NumTraits<double>::epsilon();
+  // The analytic values below additionally absorb the representation error of
+  // the decimal node literals and of pow(10, 27.5), amplified by the 15-factor
+  // product.
+  const double kAnalyticTol = 100 * NumTraits<double>::epsilon();
+
+  const double a = 1e-110, M = std::pow(10.0, 27.5);
+  {
+    // Underflow side (the reviewer's exact node set): the a-spaced factors alone
+    // reach 2e-330, below the smallest subnormal, so the naive running product
+    // flushes to an exact zero -- yet the determinant is 864 * a^3 * M^12 ~ 864.
+    Vec x(6);
+    x << 0.0, a, 2 * a, M, 2 * M, 3 * M;
+    Vandermonde<double> V(x);
+    const double det = V.determinant();
+    const double ref = reference_vandermonde_det(x);
+    VERIFY((numext::isfinite)(det));
+    VERIFY(numext::abs(det / ref - 1.0) <= kBalancedTol);
+    VERIFY(numext::abs(det / 864.0 - 1.0) <= kAnalyticTol);
+  }
+  {
+    // Overflow-side analogue: with the large nodes first the naive running
+    // product tops out at ~4.3e327 (infinity) three factors before the end, yet
+    // the determinant is a representable -864 * B^12 * s^3 = -8.64e305.
+    const double B = 1e28, s = 1e-11;
+    Vec x(6);
+    x << B, 2 * B, 3 * B, 0.0, s, 2 * s;
+    Vandermonde<double> V(x);
+    const double det = V.determinant();
+    const double ref = reference_vandermonde_det(x);
+    VERIFY((numext::isfinite)(det));
+    VERIFY(numext::abs(det / ref - 1.0) <= kBalancedTol);
+    VERIFY(numext::abs(det / -8.64e305 - 1.0) <= kAnalyticTol);
+  }
+  {
+    // Genuinely overflowing determinant, ~3.5e424: must saturate to +infinity.
+    const double T = 1e28;
+    Vec x(6);
+    x << 0.0, T, 2 * T, 3 * T, 4 * T, 5 * T;
+    Vandermonde<double> V(x);
+    const double det = V.determinant();
+    VERIFY((numext::isinf)(det) && det > 0.0);
+  }
+  {
+    // Genuinely underflowing determinant: subnormal-spaced nodes give 15 factors
+    // below 2^-1071, a product near 2^-16000, which must saturate to zero with
+    // the sign of the factored form: +0 for ascending nodes (all factors
+    // positive), -0 for the descending permutation (15 negative factors).
+    const double d = std::numeric_limits<double>::denorm_min();
+    Vec x(6);
+    x << 0.0, d, 2 * d, 3 * d, 4 * d, 5 * d;
+    const double det = Vandermonde<double>(x).determinant();
+    VERIFY(det == 0.0 && !std::signbit(det));
+    const double detNeg = Vandermonde<double>(Vec(x.reverse())).determinant();
+    VERIFY(detNeg == 0.0 && std::signbit(detNeg));
+  }
+  {
+    // A repeated node makes the matrix exactly singular: the zero factor must
+    // propagate to an exact 0 even though the naive running product overflows
+    // beforehand (which would end in 0 * inf = NaN).
+    Vec x(5);
+    x << 0.0, 1e300, 1e-300, 1e300, 5.0;
+    Vandermonde<double> V(x);
+    VERIFY(V.determinant() == 0.0);
+  }
+  {
+    // Complex path of the balanced accumulation: purely imaginary nodes i*x
+    // turn every factor of the underflow-side case into i*(x_j - x_i), so
+    // det = i^15 * 864 = -864i.
+    Vec xr(6);
+    xr << 0.0, a, 2 * a, M, 2 * M, 3 * M;
+    Matrix<Complex, Dynamic, 1> x = Complex(0, 1) * xr.cast<Complex>();
+    Vandermonde<Complex> V(x);
+    const Complex det = V.determinant();
+    const Complex ref(0.0, -reference_vandermonde_det(xr));
+    VERIFY((numext::isfinite)(numext::abs(det)));
+    VERIFY(numext::abs(det - ref) <= kBalancedTol * numext::abs(ref));
+  }
+}
+
+// Reviewer reproducer on MR 2691: a node difference can overflow while the determinant stays
+// representable. For nodes [-DBL_MAX, DBL_MAX, d, 2d, ..., 5d] with d the smallest subnormal,
+// DBL_MAX - (-DBL_MAX) = 2^1025 overflows, yet det = -576 DBL_MAX^11 d^10 ~ -3.1633e160. The
+// overflowing difference must be halved (exact for these huge normal operands) and the factor of
+// two carried in the running exponent.
+void test_vandermonde_determinant_overflowing_differences() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef std::complex<double> Complex;
+  const double M = (std::numeric_limits<double>::max)();
+  const double d = std::numeric_limits<double>::denorm_min();
+  const double kBalancedTol = 16 * NumTraits<double>::epsilon();
+  const double kAnalyticTol = 100 * NumTraits<double>::epsilon();
+
+  Vec x(7);
+  x << -M, M, d, 2 * d, 3 * d, 4 * d, 5 * d;
+  const double det = Vandermonde<double>(x).determinant();
+  VERIFY((numext::isfinite)(det));
+
+  // Scaled reference computation with the identical factor sequence.
+  const double ref = reference_vandermonde_det(x);
+  VERIFY(numext::abs(det / ref - 1.0) <= kBalancedTol);
+
+  // Analytic factored form, accumulated with the same exponent bookkeeping:
+  // every huge factor rounds to +-DBL_MAX (and the halved leading factor is
+  // exactly DBL_MAX * 2), the d-spaced block contributes exactly 288 * 2^-10740,
+  // so det = -2 * 288 * DBL_MAX^11 * 2^-10740.
+  double mantissa = -576.0;
+  Index exponent = -10740;
+  for (int t = 0; t < 11; ++t) {
+    int e;
+    mantissa *= std::frexp(M, &e);
+    exponent += e;
+    mantissa = std::frexp(mantissa, &e);
+    exponent += e;
+  }
+  const double expected = std::ldexp(mantissa, static_cast<int>(exponent));
+  VERIFY(numext::abs(det / expected - 1.0) <= kAnalyticTol);
+  VERIFY(numext::abs(det / -3.1633e160 - 1.0) <= 1e-3);  // the reviewer's quoted value
+
+  // Complex nodes i*x: every factor becomes i*(x_j - x_i) -- the overflow now
+  // sits in the imaginary components, which the component-wise finiteness check
+  // must catch -- and det picks up i^21 = i.
+  Matrix<Complex, Dynamic, 1> xc = Complex(0, 1) * x.cast<Complex>();
+  const Complex detc = Vandermonde<Complex>(xc).determinant();
+  const Complex refc = Complex(0, 1) * Complex(ref);
+  VERIFY((numext::isfinite)(detc));
+  VERIFY(numext::abs(detc - refc) <= kBalancedTol * numext::abs(refc));
+}
+
+// Reviewer reproducer on MR 2691: Horner intermediates can overflow while the value stays
+// representable. At node 1/2 with coefficients [0, DBL_MAX, DBL_MAX] the intermediate 1.5 DBL_MAX
+// is Inf, but the value is exactly fl(0.75 DBL_MAX). The scaled path must return it bit-exactly,
+// the plain path must match the naive loop for moderate data, and genuinely unrepresentable values
+// must still saturate.
+void test_vandermonde_scaled_horner() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  typedef std::complex<double> Complex;
+  typedef Matrix<Complex, Dynamic, 1> CVec;
+  const double M = (std::numeric_limits<double>::max)();
+
+  {
+    // The reviewer's exact reproducer, in each accumulation form.
+    Vec x(1);
+    x << 0.5;
+    Vandermonde<double> V(x, 3);
+    Vec a(3);
+    a << 0.0, M, M;
+    Vec y = V * a;
+    VERIFY_IS_EQUAL(y[0], 0.75 * M);
+    y.setZero();
+    y.noalias() += V * a;
+    VERIFY_IS_EQUAL(y[0], 0.75 * M);
+    // Two identical columns exercise the per-column screening.
+    Matrix<double, Dynamic, Dynamic> A(3, 2);
+    A.col(0) = a;
+    A.col(1) = a;
+    Matrix<double, Dynamic, Dynamic> Y = V * A;
+    VERIFY_IS_EQUAL(Y(0, 0), 0.75 * M);
+    VERIFY_IS_EQUAL(Y(0, 1), 0.75 * M);
+  }
+  {
+    // Complex path: the same coefficients rotated by i keep the overflow in a
+    // single component; the value is i * fl(0.75 * DBL_MAX).
+    CVec xc(1);
+    xc << Complex(0.5, 0.0);
+    Vandermonde<Complex> Vc(xc, 3);
+    CVec ac(3);
+    ac << Complex(0), Complex(0, M), Complex(0, M);
+    CVec yc = Vc * ac;
+    VERIFY_IS_EQUAL(numext::real(yc[0]), 0.0);
+    VERIFY_IS_EQUAL(numext::imag(yc[0]), 0.75 * M);
+  }
+  {
+    // Genuine overflow must still saturate: value 3 * DBL_MAX at the node 2.
+    Vec x(1);
+    x << 2.0;
+    Vandermonde<double> V(x, 2);
+    Vec a(2);
+    a << M, M;
+    Vec y = V * a;
+    VERIFY((numext::isinf)(y[0]) && y[0] > 0.0);
+    a << M, -M;  // value -DBL_MAX: representable again, sign preserved
+    y = V * a;
+    VERIFY_IS_EQUAL(y[0], -M);
+  }
+  {
+    // A vanished accumulator has no scale (reviewer repro): after the running
+    // value becomes exactly zero -- a zero node annihilating it, or an exact
+    // cancellation -- the frame exponent must reset, or the trailing small
+    // coefficient underflows in the stale huge frame and the value 0 is
+    // returned instead of the coefficient itself.
+    const double mn = (std::numeric_limits<double>::min)();
+    const double dm = std::numeric_limits<double>::denorm_min();
+    Vec x(1);
+    x << 0.0;  // zero node: the value is exactly a[0]
+    Vandermonde<double> V0(x, 3);
+    Vec a(3);
+    a << mn, M, M;
+    Vec y = V0 * a;
+    VERIFY_IS_EQUAL(y[0], mn);
+
+    x << 1.0;  // exact cancellation: M - M + dm = dm
+    Vandermonde<double> V1(x, 3);
+    a << dm, -M, M;
+    y = V1 * a;
+    VERIFY_IS_EQUAL(y[0], dm);
+  }
+  {
+    // Complex variant: the real components cancel exactly while the tiny
+    // imaginary coefficient must survive in a fresh frame.
+    const double dm = std::numeric_limits<double>::denorm_min();
+    CVec xc(1);
+    xc << Complex(1.0, 0.0);
+    Vandermonde<Complex> Vc(xc, 3);
+    CVec ac(3);
+    ac << Complex(0.0, dm), Complex(-M, 0.0), Complex(M, 0.0);
+    CVec yc = Vc * ac;
+    VERIFY_IS_EQUAL(numext::real(yc[0]), 0.0);
+    VERIFY_IS_EQUAL(numext::imag(yc[0]), dm);
+  }
+  {
+    // Near-cancellation: M - (M - 2^971) leaves the tiny nonzero intermediate
+    // 2^971 (mantissa 2^-53 in the huge frame), which the frexp renormalization
+    // must rebase; the trailing coefficient 1 then rounds away exactly as in
+    // real arithmetic: fl(2^971 + 1) = 2^971.
+    const double big = std::ldexp(1.0, 971);  // ulp(DBL_MAX), and M - big is exact
+    Vec x(1);
+    x << 1.0;
+    Vandermonde<double> V(x, 3);
+    Vec a(3);
+    a << 1.0, -(M - big), M;
+    Vec y = V * a;
+    VERIFY_IS_EQUAL(y[0], big);
+  }
+  {
+    // Moderate data keeps the plain path, so this matches a naive Horner loop to Horner's own forward
+    // error bound (Higham, ASNA 2nd ed., section 5.1): |p(x) - fl(p(x))| <= gamma_{2n} sum_j |a_j| |x|^j
+    // <= 2n eps sum_j |a_j| for |x| <= 1. Not bit-identical, since the compiler may contract
+    // acc * x[i] + a[j] into an FMA in one of the two loops and not the other.
+    const Index m = 7, n = 6;
+    Vec x = Vec::Random(m), a = Vec::Random(n);
+    Vandermonde<double> V(x, n);
+    Vec y = V * a;
+    const double bound = double(2 * n) * NumTraits<double>::epsilon() * a.cwiseAbs().sum();
+    for (Index i = 0; i < m; ++i) {
+      double acc = a[n - 1];
+      for (Index j = n - 2; j >= 0; --j) acc = acc * x[i] + a[j];
+      VERIFY(numext::abs(y[i] - acc) <= bound);
+    }
+  }
+}
+
+template <typename Scalar, int M, int N>
+void test_vandermonde_fixed() {
+  typedef Matrix<Scalar, M, 1> NodeVec;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, M, N> MatMN;
+
+  NodeVec x = NodeVec::Random();
+  Vandermonde<Scalar, M, N> V(x, N);
+  STATIC_CHECK((Vandermonde<Scalar, M, N>::RowsAtCompileTime == M));
+  STATIC_CHECK((Vandermonde<Scalar, M, N>::ColsAtCompileTime == N));
+  STATIC_CHECK((internal::remove_all_t<decltype(makeVandermonde(x))>::ColsAtCompileTime == M));
+
+  MatMN dense = V;
+  VERIFY_IS_APPROX(dense, MatMN(reference_vandermonde<Scalar>(Vec(x), N)));
+
+  Matrix<Scalar, N, 1> a = Matrix<Scalar, N, 1>::Random();
+  Matrix<Scalar, M, 1> y = V * a;
+  VERIFY_IS_APPROX(y, (dense * a).eval());
+}
+
+// Core rewrites alpha * (V * a) as (alpha * V) * a. Keep the two scaled
+// expression forms together because they share the same structured wrapper.
+void test_vandermonde_expression_regressions() {
+  typedef Matrix<double, 1, 1> Vec1;
+  typedef Matrix<double, 3, 1> Vec3;
+  typedef Matrix<double, 1, 3> Row3;
+  typedef Matrix<double, 3, 3> Mat3;
+  typedef Matrix<double, 3, 2> Mat32;
+
+  Vec1 x;
+  x << 0.5;
+  Vandermonde<double, 1, 3> V(x, 3);
+  Row3 dense = V;
+  Row3 scaledDense = 2.0 * V;
+  VERIFY_IS_APPROX(scaledDense, (2.0 * dense).eval());
+
+  Vec3 a;
+  a << 1.0, 2.0, 3.0;
+  Vec1 scaledProduct = 0.5 * (V * a);
+  VERIFY_IS_APPROX(scaledProduct, (0.5 * (dense * a)).eval());
+
+  // A product on the right must be evaluated before the structured Horner
+  // evaluator asks it for coefficients.
+  Mat3 B = Mat3::Random();
+  Mat32 C = Mat32::Random();
+  VERIFY_IS_APPROX((V * (B * C)).eval(), (dense * (B * C)).eval());
+}
+
+void test_vandermonde_dimension_checks() {
+  VectorXd x(2);
+  x << 0.0, 1.0;
+  VERIFY_RAISES_ASSERT((Vandermonde<double, Dynamic, 3>(x)));
+
+  Vandermonde<double> rectangular(x, 3);
+  VERIFY_RAISES_ASSERT((BjorckPereyra<double>(rectangular)));
+}
+
+// Fixed-size Vandermonde expressions own the operator by value so temporaries
+// returned from factories remain alive. Their node storage must therefore avoid
+// over-alignment: generic Product and cwise wrapper types do not supply aligned
+// operator new under C++14.
+void test_vandermonde_fixed_heap_expressions() {
+  typedef Matrix<double, 4, 1> Vec4;
+  typedef Matrix<double, 4, 4> Mat4;
+
+  Vec4 x;
+  x << -1.0, -0.25, 0.5, 1.0;
+  Vec4 a;
+  a << 1.0, 2.0, 3.0, 4.0;
+
+  typedef decltype(makeVandermonde(x) * a) ProductExpression;
+  typedef decltype(2.0 * makeVandermonde(x)) ScaledExpression;
+  STATIC_CHECK(alignof(ProductExpression) <= alignof(std::max_align_t));
+  STATIC_CHECK(alignof(ScaledExpression) <= alignof(std::max_align_t));
+
+  ProductExpression* delayedProduct = new ProductExpression(makeVandermonde(x) * a);
+  ScaledExpression* delayedScaled = new ScaledExpression(2.0 * makeVandermonde(x));
+
+  const Mat4 dense = reference_vandermonde<double>(Matrix<double, Dynamic, 1>(x), 4);
+  Vec4 y = *delayedProduct;
+  Mat4 scaled = *delayedScaled;
+  VERIFY_IS_APPROX(y, (dense * a).eval());
+  VERIFY_IS_APPROX(scaled, (2.0 * dense).eval());
+  delete delayedProduct;
+  delete delayedScaled;
+}
+
+EIGEN_DECLARE_TEST(structured_vandermonde) {
+  for (int i = 0; i < g_repeat; ++i) {
+    // Horner products, dense assignment, coefficient access.
+    CALL_SUBTEST_1((test_vandermonde_product<double>(1, 1)));
+    CALL_SUBTEST_1((test_vandermonde_product<double>(8, 8)));
+    CALL_SUBTEST_1((test_vandermonde_product<double>(20, 12)));  // tall
+    CALL_SUBTEST_1((test_vandermonde_product<double>(12, 20)));  // wide
+    CALL_SUBTEST_1((test_vandermonde_product<float>(10, 10)));
+    CALL_SUBTEST_1((test_vandermonde_product<std::complex<double>>(9, 7)));
+    CALL_SUBTEST_1((test_vandermonde_product<std::complex<float>>(7, 9)));
+
+    // Björck-Pereyra primal/dual/adjoint solves.
+    CALL_SUBTEST_2((test_bjorck_pereyra<double>(1)));
+    CALL_SUBTEST_2((test_bjorck_pereyra<double>(2)));
+    CALL_SUBTEST_2((test_bjorck_pereyra<double>(10)));
+    CALL_SUBTEST_2((test_bjorck_pereyra<double>(14)));
+    CALL_SUBTEST_2((test_bjorck_pereyra<std::complex<double>>(10)));
+    CALL_SUBTEST_2((test_bjorck_pereyra_roots_of_unity<double>(64)));
+    CALL_SUBTEST_2((test_bjorck_pereyra_roots_of_unity<float>(32)));
+    CALL_SUBTEST_2(test_vandermonde_half());
+    CALL_SUBTEST_2(test_bjorck_pereyra_higham());
+    CALL_SUBTEST_2(test_bjorck_pereyra_complex_transpose_adjoint(12));
+    CALL_SUBTEST_2(test_bjorck_pereyra_singular());
+
+    // Closed-form determinant and fixed sizes.
+    CALL_SUBTEST_3((test_vandermonde_determinant<double>(8)));
+    CALL_SUBTEST_3((test_vandermonde_determinant<std::complex<double>>(7)));
+    CALL_SUBTEST_3(test_vandermonde_determinant_scaled());
+    CALL_SUBTEST_3(test_vandermonde_determinant_overflowing_differences());
+    CALL_SUBTEST_3(test_vandermonde_scaled_horner());
+    CALL_SUBTEST_3((test_vandermonde_fixed<double, 6, 4>()));
+    CALL_SUBTEST_3((test_vandermonde_fixed<double, 5, 5>()));
+    CALL_SUBTEST_3((test_vandermonde_fixed<std::complex<float>, 4, 4>()));
+    CALL_SUBTEST_3(test_vandermonde_expression_regressions());
+    CALL_SUBTEST_3(test_vandermonde_fixed_heap_expressions());
+
+    // Product regressions: aliasing, operand lifetime, mixed scalars.
+    CALL_SUBTEST_4((test_vandermonde_aliased_product<double>(8)));
+    CALL_SUBTEST_4((test_vandermonde_aliased_product<double>(17)));
+    CALL_SUBTEST_4((test_vandermonde_aliased_product<std::complex<double>>(9)));
+    CALL_SUBTEST_4((test_vandermonde_aliased_expression<double>(8)));
+    CALL_SUBTEST_4((test_vandermonde_aliased_expression<std::complex<double>>(9)));
+    CALL_SUBTEST_4((test_vandermonde_delayed_product<double>(12, 9)));
+    CALL_SUBTEST_4((test_vandermonde_delayed_product<std::complex<double>>(8, 8)));
+    CALL_SUBTEST_4((test_vandermonde_mixed_scalar<double>(10, 8)));
+    CALL_SUBTEST_4((test_vandermonde_mixed_scalar<float>(7, 9)));
+  }
+
+  CALL_SUBTEST_3(test_vandermonde_dimension_checks());
+}
diff --git a/contrib/test/structured_vandermonde_int_index.cpp b/contrib/test/structured_vandermonde_int_index.cpp
new file mode 100644
index 0000000..4d9cc1b
--- /dev/null
+++ b/contrib/test/structured_vandermonde_int_index.cpp
@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifdef EIGEN_DEFAULT_DENSE_INDEX_TYPE
+#undef EIGEN_DEFAULT_DENSE_INDEX_TYPE
+#endif
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#include "main.h"
+
+#include <contrib/Eigen/StructuredMatrices>
+
+using namespace Eigen;
+
+// Roughly 2.2 million factors near the top of the double range exceed a
+// 32-bit Index exponent even though the determinant has the unambiguous result
+// +Inf. The internal exponent type must not wrap.
+void test_vandermonde_determinant_int_index() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const Index n = 2100;
+  const double low = -9e307, high = 9e307;
+  Vec x(n);
+  for (Index i = 0; i < n; ++i) {
+    const double t = double(i) / double(n - 1);
+    x[i] = (1.0 - t) * low + t * high;
+  }
+
+  const double det = Vandermonde<double>(x).determinant();
+  VERIFY((numext::isinf)(det));
+  VERIFY(det > 0.0);
+}
+
+// The scaled-Horner frame can likewise exceed a 32-bit Index exponent. A
+// degree-2,099,999 monomial at DBL_MAX must overflow to +Inf rather than wrap
+// its accumulated exponent and underflow to zero.
+void test_vandermonde_scaled_horner_int_index() {
+  typedef Matrix<double, Dynamic, 1> Vec;
+  const Index n = 2100000;
+  Vec x(1), a = Vec::Zero(n);
+  x[0] = (std::numeric_limits<double>::max)();
+  a[n - 1] = 1.0;
+
+  Vec y = Vandermonde<double>(x, n) * a;
+  VERIFY((numext::isinf)(y[0]));
+  VERIFY(y[0] > 0.0);
+}
+
+EIGEN_DECLARE_TEST(structured_vandermonde_int_index) {
+  STATIC_CHECK(sizeof(Index) == sizeof(int));
+  CALL_SUBTEST_1(test_vandermonde_determinant_int_index());
+  CALL_SUBTEST_2(test_vandermonde_scaled_horner_int_index());
+}
diff --git a/contrib/test/tensor_argmax.cpp b/contrib/test/tensor_argmax.cpp
new file mode 100644
index 0000000..2143160
--- /dev/null
+++ b/contrib/test/tensor_argmax.cpp
@@ -0,0 +1,271 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Eugene Brevdo <ebrevdo@google.com>
+//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::Pair;
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_index_pairs() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  tensor = (tensor + tensor.constant(0.5)).log();
+
+  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
+  index_pairs = tensor.index_pairs();
+
+  for (DenseIndex n = 0; n < 2 * 3 * 5 * 7; ++n) {
+    const Pair<DenseIndex, float>& v = index_pairs.coeff(n);
+    VERIFY_IS_EQUAL(v.first, n);
+    VERIFY_IS_EQUAL(v.second, tensor.coeff(n));
+  }
+}
+
+template <int DataLayout>
+static void test_argmax_pair_reducer() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  tensor = (tensor + tensor.constant(0.5)).log();
+
+  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
+  index_pairs = tensor.index_pairs();
+
+  Tensor<Pair<DenseIndex, float>, 0, DataLayout> reduced;
+  DimensionList<DenseIndex, 4> dims;
+  reduced = index_pairs.reduce(dims, internal::ArgMaxPairReducer<Pair<DenseIndex, float> >());
+
+  Tensor<float, 0, DataLayout> maxi = tensor.maximum();
+
+  VERIFY_IS_EQUAL(maxi(), reduced(0).second);
+
+  array<DenseIndex, 3> reduce_dims;
+  for (int d = 0; d < 3; ++d) reduce_dims[d] = d;
+  Tensor<Pair<DenseIndex, float>, 1, DataLayout> reduced_by_dims(7);
+  reduced_by_dims = index_pairs.reduce(reduce_dims, internal::ArgMaxPairReducer<Pair<DenseIndex, float> >());
+
+  Tensor<float, 1, DataLayout> max_by_dims = tensor.maximum(reduce_dims);
+
+  for (int l = 0; l < 7; ++l) {
+    VERIFY_IS_EQUAL(max_by_dims(l), reduced_by_dims(l).second);
+  }
+}
+
+template <int DataLayout>
+static void test_argmin_pair_reducer() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  tensor = (tensor + tensor.constant(0.5)).log();
+
+  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
+  index_pairs = tensor.index_pairs();
+
+  Tensor<Pair<DenseIndex, float>, 0, DataLayout> reduced;
+  DimensionList<DenseIndex, 4> dims;
+  reduced = index_pairs.reduce(dims, internal::ArgMinPairReducer<Pair<DenseIndex, float> >());
+
+  Tensor<float, 0, DataLayout> mini = tensor.minimum();
+
+  VERIFY_IS_EQUAL(mini(), reduced(0).second);
+
+  array<DenseIndex, 3> reduce_dims;
+  for (int d = 0; d < 3; ++d) reduce_dims[d] = d;
+  Tensor<Pair<DenseIndex, float>, 1, DataLayout> reduced_by_dims(7);
+  reduced_by_dims = index_pairs.reduce(reduce_dims, internal::ArgMinPairReducer<Pair<DenseIndex, float> >());
+
+  Tensor<float, 1, DataLayout> min_by_dims = tensor.minimum(reduce_dims);
+
+  for (int l = 0; l < 7; ++l) {
+    VERIFY_IS_EQUAL(min_by_dims(l), reduced_by_dims(l).second);
+  }
+}
+
+template <int DataLayout>
+static void test_simple_argmax() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  tensor = (tensor + tensor.constant(0.5)).log();
+  tensor(0, 0, 0, 0) = 10.0;
+
+  Tensor<DenseIndex, 0, DataLayout> tensor_argmax;
+
+  tensor_argmax = tensor.argmax();
+
+  VERIFY_IS_EQUAL(tensor_argmax(0), 0);
+
+  tensor(1, 2, 4, 6) = 20.0;
+
+  tensor_argmax = tensor.argmax();
+
+  VERIFY_IS_EQUAL(tensor_argmax(0), 2 * 3 * 5 * 7 - 1);
+}
+
+template <int DataLayout>
+static void test_simple_argmin() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  tensor = (tensor + tensor.constant(0.5)).log();
+  tensor(0, 0, 0, 0) = -10.0;
+
+  Tensor<DenseIndex, 0, DataLayout> tensor_argmin;
+
+  tensor_argmin = tensor.argmin();
+
+  VERIFY_IS_EQUAL(tensor_argmin(0), 0);
+
+  tensor(1, 2, 4, 6) = -20.0;
+
+  tensor_argmin = tensor.argmin();
+
+  VERIFY_IS_EQUAL(tensor_argmin(0), 2 * 3 * 5 * 7 - 1);
+}
+
+template <int DataLayout>
+static void test_argmax_dim() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  std::vector<int> dims{2, 3, 5, 7};
+
+  for (int dim = 0; dim < 4; ++dim) {
+    tensor.setRandom();
+    tensor = (tensor + tensor.constant(0.5)).log();
+
+    Tensor<DenseIndex, 3, DataLayout> tensor_argmax;
+    array<DenseIndex, 4> ix;
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != 0) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
+            tensor(ix) = 10.0;
+          }
+        }
+      }
+    }
+
+    tensor_argmax = tensor.argmax(dim);
+
+    VERIFY_IS_EQUAL(tensor_argmax.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
+    for (ptrdiff_t n = 0; n < tensor_argmax.size(); ++n) {
+      // Expect max to be in the first index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_argmax.data()[n], 0);
+    }
+
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != tensor.dimension(dim) - 1) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
+            tensor(ix) = 20.0;
+          }
+        }
+      }
+    }
+
+    tensor_argmax = tensor.argmax(dim);
+
+    VERIFY_IS_EQUAL(tensor_argmax.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
+    for (ptrdiff_t n = 0; n < tensor_argmax.size(); ++n) {
+      // Expect max to be in the last index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_argmax.data()[n], tensor.dimension(dim) - 1);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_argmin_dim() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  std::vector<int> dims{2, 3, 5, 7};
+
+  for (int dim = 0; dim < 4; ++dim) {
+    tensor.setRandom();
+    tensor = (tensor + tensor.constant(0.5)).log();
+
+    Tensor<DenseIndex, 3, DataLayout> tensor_argmin;
+    array<DenseIndex, 4> ix;
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != 0) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = -10.0
+            tensor(ix) = -10.0;
+          }
+        }
+      }
+    }
+
+    tensor_argmin = tensor.argmin(dim);
+
+    VERIFY_IS_EQUAL(tensor_argmin.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
+    for (ptrdiff_t n = 0; n < tensor_argmin.size(); ++n) {
+      // Expect min to be in the first index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_argmin.data()[n], 0);
+    }
+
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != tensor.dimension(dim) - 1) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = -20.0
+            tensor(ix) = -20.0;
+          }
+        }
+      }
+    }
+
+    tensor_argmin = tensor.argmin(dim);
+
+    VERIFY_IS_EQUAL(tensor_argmin.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
+    for (ptrdiff_t n = 0; n < tensor_argmin.size(); ++n) {
+      // Expect min to be in the last index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_argmin.data()[n], tensor.dimension(dim) - 1);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_argmax) {
+  CALL_SUBTEST(test_simple_index_pairs<RowMajor>());
+  CALL_SUBTEST(test_simple_index_pairs<ColMajor>());
+  CALL_SUBTEST(test_argmax_pair_reducer<RowMajor>());
+  CALL_SUBTEST(test_argmax_pair_reducer<ColMajor>());
+  CALL_SUBTEST(test_argmin_pair_reducer<RowMajor>());
+  CALL_SUBTEST(test_argmin_pair_reducer<ColMajor>());
+  CALL_SUBTEST(test_simple_argmax<RowMajor>());
+  CALL_SUBTEST(test_simple_argmax<ColMajor>());
+  CALL_SUBTEST(test_simple_argmin<RowMajor>());
+  CALL_SUBTEST(test_simple_argmin<ColMajor>());
+  CALL_SUBTEST(test_argmax_dim<RowMajor>());
+  CALL_SUBTEST(test_argmax_dim<ColMajor>());
+  CALL_SUBTEST(test_argmin_dim<RowMajor>());
+  CALL_SUBTEST(test_argmin_dim<ColMajor>());
+}
diff --git a/contrib/test/tensor_argmax_gpu.cu b/contrib/test/tensor_argmax_gpu.cu
new file mode 100644
index 0000000..f944b50
--- /dev/null
+++ b/contrib/test/tensor_argmax_gpu.cu
@@ -0,0 +1,271 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int Layout>
+void test_gpu_simple_argmax() {
+  Tensor<double, 3, Layout> in(Eigen::array<DenseIndex, 3>{72, 53, 97});
+  Tensor<DenseIndex, 0, Layout> out_max;
+  Tensor<DenseIndex, 0, Layout> out_min;
+  in.setRandom();
+  in *= in.constant(100.0);
+  in(0, 0, 0) = -1000.0;
+  in(71, 52, 96) = 1000.0;
+
+  std::size_t in_bytes = in.size() * sizeof(double);
+  std::size_t out_bytes = out_max.size() * sizeof(DenseIndex);
+
+  double* d_in;
+  DenseIndex* d_out_max;
+  DenseIndex* d_out_min;
+  gpuMalloc((void**)(&d_in), in_bytes);
+  gpuMalloc((void**)(&d_out_max), out_bytes);
+  gpuMalloc((void**)(&d_out_min), out_bytes);
+
+  gpuMemcpy(d_in, in.data(), in_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<double, 3, Layout>, Aligned> gpu_in(d_in, Eigen::array<DenseIndex, 3>{72, 53, 97});
+  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout>, Aligned> gpu_out_max(d_out_max);
+  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout>, Aligned> gpu_out_min(d_out_min);
+
+  gpu_out_max.device(gpu_device) = gpu_in.argmax();
+  gpu_out_min.device(gpu_device) = gpu_in.argmin();
+
+  assert(gpuMemcpyAsync(out_max.data(), d_out_max, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+         gpuSuccess);
+  assert(gpuMemcpyAsync(out_min.data(), d_out_min, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+         gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  VERIFY_IS_EQUAL(out_max(), 72 * 53 * 97 - 1);
+  VERIFY_IS_EQUAL(out_min(), 0);
+
+  gpuFree(d_in);
+  gpuFree(d_out_max);
+  gpuFree(d_out_min);
+}
+
+template <int DataLayout>
+void test_gpu_argmax_dim() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  std::vector<int> dims;
+  dims.push_back(2);
+  dims.push_back(3);
+  dims.push_back(5);
+  dims.push_back(7);
+
+  for (int dim = 0; dim < 4; ++dim) {
+    tensor.setRandom();
+    tensor = (tensor + tensor.constant(0.5)).log();
+
+    array<DenseIndex, 3> out_shape;
+    for (int d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
+
+    Tensor<DenseIndex, 3, DataLayout> tensor_arg(out_shape);
+
+    array<DenseIndex, 4> ix;
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != 0) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
+            tensor(ix) = 10.0;
+          }
+        }
+      }
+    }
+
+    std::size_t in_bytes = tensor.size() * sizeof(float);
+    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
+
+    float* d_in;
+    DenseIndex* d_out;
+    gpuMalloc((void**)(&d_in), in_bytes);
+    gpuMalloc((void**)(&d_out), out_bytes);
+
+    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
+
+    Eigen::GpuStreamDevice stream;
+    Eigen::GpuDevice gpu_device(&stream);
+
+    Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout>, Aligned> gpu_in(d_in,
+                                                                          Eigen::array<DenseIndex, 4>{2, 3, 5, 7});
+    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout>, Aligned> gpu_out(d_out, out_shape);
+
+    gpu_out.device(gpu_device) = gpu_in.argmax(dim);
+
+    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+           gpuSuccess);
+    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+    VERIFY_IS_EQUAL(tensor_arg.size(), size_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the first index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
+    }
+
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != tensor.dimension(dim) - 1) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
+            tensor(ix) = 20.0;
+          }
+        }
+      }
+    }
+
+    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
+
+    gpu_out.device(gpu_device) = gpu_in.argmax(dim);
+
+    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+           gpuSuccess);
+    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the last index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
+    }
+
+    gpuFree(d_in);
+    gpuFree(d_out);
+  }
+}
+
+template <int DataLayout>
+void test_gpu_argmin_dim() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  std::vector<int> dims;
+  dims.push_back(2);
+  dims.push_back(3);
+  dims.push_back(5);
+  dims.push_back(7);
+
+  for (int dim = 0; dim < 4; ++dim) {
+    tensor.setRandom();
+    tensor = (tensor + tensor.constant(0.5)).log();
+
+    array<DenseIndex, 3> out_shape;
+    for (int d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
+
+    Tensor<DenseIndex, 3, DataLayout> tensor_arg(out_shape);
+
+    array<DenseIndex, 4> ix;
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != 0) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
+            tensor(ix) = -10.0;
+          }
+        }
+      }
+    }
+
+    std::size_t in_bytes = tensor.size() * sizeof(float);
+    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
+
+    float* d_in;
+    DenseIndex* d_out;
+    gpuMalloc((void**)(&d_in), in_bytes);
+    gpuMalloc((void**)(&d_out), out_bytes);
+
+    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
+
+    Eigen::GpuStreamDevice stream;
+    Eigen::GpuDevice gpu_device(&stream);
+
+    Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout>, Aligned> gpu_in(d_in,
+                                                                          Eigen::array<DenseIndex, 4>{2, 3, 5, 7});
+    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout>, Aligned> gpu_out(d_out, out_shape);
+
+    gpu_out.device(gpu_device) = gpu_in.argmin(dim);
+
+    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+           gpuSuccess);
+    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+    VERIFY_IS_EQUAL(tensor_arg.size(), 2 * 3 * 5 * 7 / tensor.dimension(dim));
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect min to be in the first index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
+    }
+
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        for (int k = 0; k < 5; ++k) {
+          for (int l = 0; l < 7; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            if (ix[dim] != tensor.dimension(dim) - 1) continue;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
+            tensor(ix) = -20.0;
+          }
+        }
+      }
+    }
+
+    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
+
+    gpu_out.device(gpu_device) = gpu_in.argmin(dim);
+
+    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+           gpuSuccess);
+    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the last index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
+    }
+
+    gpuFree(d_in);
+    gpuFree(d_out);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_argmax_gpu) {
+  CALL_SUBTEST_1(test_gpu_simple_argmax<RowMajor>());
+  CALL_SUBTEST_1(test_gpu_simple_argmax<ColMajor>());
+  CALL_SUBTEST_2(test_gpu_argmax_dim<RowMajor>());
+  CALL_SUBTEST_2(test_gpu_argmax_dim<ColMajor>());
+  CALL_SUBTEST_3(test_gpu_argmin_dim<RowMajor>());
+  CALL_SUBTEST_3(test_gpu_argmin_dim<ColMajor>());
+}
diff --git a/contrib/test/tensor_argmax_sycl.cpp b/contrib/test/tensor_argmax_sycl.cpp
new file mode 100644
index 0000000..bc19af5
--- /dev/null
+++ b/contrib/test/tensor_argmax_sycl.cpp
@@ -0,0 +1,259 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int Layout, typename DenseIndex>
+static void test_sycl_simple_argmax(const Eigen::SyclDevice& sycl_device) {
+  Tensor<DataType, 3, Layout, DenseIndex> in(Eigen::array<DenseIndex, 3>{{2, 2, 2}});
+  Tensor<DenseIndex, 0, Layout, DenseIndex> out_max;
+  Tensor<DenseIndex, 0, Layout, DenseIndex> out_min;
+  in.setRandom();
+  in *= in.constant(static_cast<DataType>(100.0));
+  in(0, 0, 0) = static_cast<DataType>(-1000.0);
+  in(1, 1, 1) = static_cast<DataType>(1000.0);
+
+  std::size_t in_bytes = in.size() * sizeof(DataType);
+  std::size_t out_bytes = out_max.size() * sizeof(DenseIndex);
+
+  DataType* d_in = static_cast<DataType*>(sycl_device.allocate(in_bytes));
+  DenseIndex* d_out_max = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
+  DenseIndex* d_out_min = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, Layout, DenseIndex> > gpu_in(d_in,
+                                                                           Eigen::array<DenseIndex, 3>{{2, 2, 2}});
+  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout, DenseIndex> > gpu_out_max(d_out_max);
+  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout, DenseIndex> > gpu_out_min(d_out_min);
+  sycl_device.memcpyHostToDevice(d_in, in.data(), in_bytes);
+
+  gpu_out_max.device(sycl_device) = gpu_in.argmax();
+  gpu_out_min.device(sycl_device) = gpu_in.argmin();
+
+  sycl_device.memcpyDeviceToHost(out_max.data(), d_out_max, out_bytes);
+  sycl_device.memcpyDeviceToHost(out_min.data(), d_out_min, out_bytes);
+
+  VERIFY_IS_EQUAL(out_max(), 2 * 2 * 2 - 1);
+  VERIFY_IS_EQUAL(out_min(), 0);
+
+  sycl_device.deallocate(d_in);
+  sycl_device.deallocate(d_out_max);
+  sycl_device.deallocate(d_out_min);
+}
+
+template <typename DataType, int DataLayout, typename DenseIndex>
+static void test_sycl_argmax_dim(const Eigen::SyclDevice& sycl_device) {
+  DenseIndex sizeDim0 = 9;
+  DenseIndex sizeDim1 = 3;
+  DenseIndex sizeDim2 = 5;
+  DenseIndex sizeDim3 = 7;
+  Tensor<DataType, 4, DataLayout, DenseIndex> tensor(sizeDim0, sizeDim1, sizeDim2, sizeDim3);
+
+  std::vector<DenseIndex> dims;
+  dims.push_back(sizeDim0);
+  dims.push_back(sizeDim1);
+  dims.push_back(sizeDim2);
+  dims.push_back(sizeDim3);
+  for (DenseIndex dim = 0; dim < 4; ++dim) {
+    array<DenseIndex, 3> out_shape;
+    for (DenseIndex d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
+
+    Tensor<DenseIndex, 3, DataLayout, DenseIndex> tensor_arg(out_shape);
+
+    array<DenseIndex, 4> ix;
+    for (DenseIndex i = 0; i < sizeDim0; ++i) {
+      for (DenseIndex j = 0; j < sizeDim1; ++j) {
+        for (DenseIndex k = 0; k < sizeDim2; ++k) {
+          for (DenseIndex l = 0; l < sizeDim3; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l)
+            // = 10.0
+            tensor(ix) = static_cast<DataType>((ix[dim] != 0) ? -1.0 : 10.0);
+          }
+        }
+      }
+    }
+
+    std::size_t in_bytes = tensor.size() * sizeof(DataType);
+    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
+
+    DataType* d_in = static_cast<DataType*>(sycl_device.allocate(in_bytes));
+    DenseIndex* d_out = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
+
+    Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, DenseIndex> > gpu_in(
+        d_in, Eigen::array<DenseIndex, 4>{{sizeDim0, sizeDim1, sizeDim2, sizeDim3}});
+    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout, DenseIndex> > gpu_out(d_out, out_shape);
+
+    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
+    gpu_out.device(sycl_device) = gpu_in.argmax(dim);
+    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
+
+    VERIFY_IS_EQUAL(static_cast<size_t>(tensor_arg.size()),
+                    size_t(sizeDim0 * sizeDim1 * sizeDim2 * sizeDim3 / tensor.dimension(dim)));
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the first index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
+    }
+
+    sycl_device.synchronize();
+
+    for (DenseIndex i = 0; i < sizeDim0; ++i) {
+      for (DenseIndex j = 0; j < sizeDim1; ++j) {
+        for (DenseIndex k = 0; k < sizeDim2; ++k) {
+          for (DenseIndex l = 0; l < sizeDim3; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
+            tensor(ix) = static_cast<DataType>((ix[dim] != tensor.dimension(dim) - 1) ? -1.0 : 20.0);
+          }
+        }
+      }
+    }
+
+    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
+    gpu_out.device(sycl_device) = gpu_in.argmax(dim);
+    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the last index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
+    }
+    sycl_device.deallocate(d_in);
+    sycl_device.deallocate(d_out);
+  }
+}
+
+template <typename DataType, int DataLayout, typename DenseIndex>
+static void test_sycl_argmin_dim(const Eigen::SyclDevice& sycl_device) {
+  DenseIndex sizeDim0 = 9;
+  DenseIndex sizeDim1 = 3;
+  DenseIndex sizeDim2 = 5;
+  DenseIndex sizeDim3 = 7;
+  Tensor<DataType, 4, DataLayout, DenseIndex> tensor(sizeDim0, sizeDim1, sizeDim2, sizeDim3);
+
+  std::vector<DenseIndex> dims;
+  dims.push_back(sizeDim0);
+  dims.push_back(sizeDim1);
+  dims.push_back(sizeDim2);
+  dims.push_back(sizeDim3);
+  for (DenseIndex dim = 0; dim < 4; ++dim) {
+    array<DenseIndex, 3> out_shape;
+    for (DenseIndex d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
+
+    Tensor<DenseIndex, 3, DataLayout, DenseIndex> tensor_arg(out_shape);
+
+    array<DenseIndex, 4> ix;
+    for (DenseIndex i = 0; i < sizeDim0; ++i) {
+      for (DenseIndex j = 0; j < sizeDim1; ++j) {
+        for (DenseIndex k = 0; k < sizeDim2; ++k) {
+          for (DenseIndex l = 0; l < sizeDim3; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = -10.0
+            tensor(ix) = static_cast<DataType>((ix[dim] != 0) ? 1.0 : -10.0);
+          }
+        }
+      }
+    }
+
+    std::size_t in_bytes = tensor.size() * sizeof(DataType);
+    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
+
+    DataType* d_in = static_cast<DataType*>(sycl_device.allocate(in_bytes));
+    DenseIndex* d_out = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
+
+    Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, DenseIndex> > gpu_in(
+        d_in, Eigen::array<DenseIndex, 4>{{sizeDim0, sizeDim1, sizeDim2, sizeDim3}});
+    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout, DenseIndex> > gpu_out(d_out, out_shape);
+
+    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
+    gpu_out.device(sycl_device) = gpu_in.argmin(dim);
+    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
+
+    VERIFY_IS_EQUAL(static_cast<size_t>(tensor_arg.size()),
+                    size_t(sizeDim0 * sizeDim1 * sizeDim2 * sizeDim3 / tensor.dimension(dim)));
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the first index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
+    }
+
+    sycl_device.synchronize();
+
+    for (DenseIndex i = 0; i < sizeDim0; ++i) {
+      for (DenseIndex j = 0; j < sizeDim1; ++j) {
+        for (DenseIndex k = 0; k < sizeDim2; ++k) {
+          for (DenseIndex l = 0; l < sizeDim3; ++l) {
+            ix[0] = i;
+            ix[1] = j;
+            ix[2] = k;
+            ix[3] = l;
+            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = -20.0
+            tensor(ix) = static_cast<DataType>((ix[dim] != tensor.dimension(dim) - 1) ? 1.0 : -20.0);
+          }
+        }
+      }
+    }
+
+    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
+    gpu_out.device(sycl_device) = gpu_in.argmin(dim);
+    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
+
+    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
+      // Expect max to be in the last index of the reduced dimension
+      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
+    }
+    sycl_device.deallocate(d_in);
+    sycl_device.deallocate(d_out);
+  }
+}
+
+template <typename DataType, typename Device_Selector>
+void sycl_argmax_test_per_device(const Device_Selector& d) {
+  QueueInterface queueInterface(d);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_sycl_simple_argmax<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_simple_argmax<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_argmax_dim<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_argmax_dim<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_argmin_dim<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_argmin_dim<DataType, RowMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_argmax_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_argmax_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_argmax_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_assign.cpp b/contrib/test/tensor_assign.cpp
new file mode 100644
index 0000000..da98cbc
--- /dev/null
+++ b/contrib/test/tensor_assign.cpp
@@ -0,0 +1,365 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_1d() {
+  Tensor<int, 1> vec1(6);
+  Tensor<int, 1, RowMajor> vec2(6);
+  vec1(0) = 4;
+  vec2(0) = 0;
+  vec1(1) = 8;
+  vec2(1) = 1;
+  vec1(2) = 15;
+  vec2(2) = 2;
+  vec1(3) = 16;
+  vec2(3) = 3;
+  vec1(4) = 23;
+  vec2(4) = 4;
+  vec1(5) = 42;
+  vec2(5) = 5;
+
+  int col_major[6] = {0};
+  int row_major[6] = {0};
+  TensorMap<Tensor<int, 1> > vec3(col_major, 6);
+  TensorMap<Tensor<int, 1, RowMajor> > vec4(row_major, 6);
+
+  vec3 = vec1;
+  vec4 = vec2;
+
+  VERIFY_IS_EQUAL(vec3(0), 4);
+  VERIFY_IS_EQUAL(vec3(1), 8);
+  VERIFY_IS_EQUAL(vec3(2), 15);
+  VERIFY_IS_EQUAL(vec3(3), 16);
+  VERIFY_IS_EQUAL(vec3(4), 23);
+  VERIFY_IS_EQUAL(vec3(5), 42);
+
+  VERIFY_IS_EQUAL(vec4(0), 0);
+  VERIFY_IS_EQUAL(vec4(1), 1);
+  VERIFY_IS_EQUAL(vec4(2), 2);
+  VERIFY_IS_EQUAL(vec4(3), 3);
+  VERIFY_IS_EQUAL(vec4(4), 4);
+  VERIFY_IS_EQUAL(vec4(5), 5);
+
+  vec1.setZero();
+  vec2.setZero();
+  vec1 = vec3;
+  vec2 = vec4;
+
+  VERIFY_IS_EQUAL(vec1(0), 4);
+  VERIFY_IS_EQUAL(vec1(1), 8);
+  VERIFY_IS_EQUAL(vec1(2), 15);
+  VERIFY_IS_EQUAL(vec1(3), 16);
+  VERIFY_IS_EQUAL(vec1(4), 23);
+  VERIFY_IS_EQUAL(vec1(5), 42);
+
+  VERIFY_IS_EQUAL(vec2(0), 0);
+  VERIFY_IS_EQUAL(vec2(1), 1);
+  VERIFY_IS_EQUAL(vec2(2), 2);
+  VERIFY_IS_EQUAL(vec2(3), 3);
+  VERIFY_IS_EQUAL(vec2(4), 4);
+  VERIFY_IS_EQUAL(vec2(5), 5);
+}
+
+static void test_2d() {
+  Tensor<int, 2> mat1(2, 3);
+  Tensor<int, 2, RowMajor> mat2(2, 3);
+
+  mat1(0, 0) = 0;
+  mat1(0, 1) = 1;
+  mat1(0, 2) = 2;
+  mat1(1, 0) = 3;
+  mat1(1, 1) = 4;
+  mat1(1, 2) = 5;
+
+  mat2(0, 0) = 0;
+  mat2(0, 1) = 1;
+  mat2(0, 2) = 2;
+  mat2(1, 0) = 3;
+  mat2(1, 1) = 4;
+  mat2(1, 2) = 5;
+
+  int col_major[6] = {0};
+  int row_major[6] = {0};
+  TensorMap<Tensor<int, 2> > mat3(row_major, 2, 3);
+  TensorMap<Tensor<int, 2, RowMajor> > mat4(col_major, 2, 3);
+
+  mat3 = mat1;
+  mat4 = mat2;
+
+  VERIFY_IS_EQUAL(mat3(0, 0), 0);
+  VERIFY_IS_EQUAL(mat3(0, 1), 1);
+  VERIFY_IS_EQUAL(mat3(0, 2), 2);
+  VERIFY_IS_EQUAL(mat3(1, 0), 3);
+  VERIFY_IS_EQUAL(mat3(1, 1), 4);
+  VERIFY_IS_EQUAL(mat3(1, 2), 5);
+
+  VERIFY_IS_EQUAL(mat4(0, 0), 0);
+  VERIFY_IS_EQUAL(mat4(0, 1), 1);
+  VERIFY_IS_EQUAL(mat4(0, 2), 2);
+  VERIFY_IS_EQUAL(mat4(1, 0), 3);
+  VERIFY_IS_EQUAL(mat4(1, 1), 4);
+  VERIFY_IS_EQUAL(mat4(1, 2), 5);
+
+  mat1.setZero();
+  mat2.setZero();
+  mat1 = mat3;
+  mat2 = mat4;
+
+  VERIFY_IS_EQUAL(mat1(0, 0), 0);
+  VERIFY_IS_EQUAL(mat1(0, 1), 1);
+  VERIFY_IS_EQUAL(mat1(0, 2), 2);
+  VERIFY_IS_EQUAL(mat1(1, 0), 3);
+  VERIFY_IS_EQUAL(mat1(1, 1), 4);
+  VERIFY_IS_EQUAL(mat1(1, 2), 5);
+
+  VERIFY_IS_EQUAL(mat2(0, 0), 0);
+  VERIFY_IS_EQUAL(mat2(0, 1), 1);
+  VERIFY_IS_EQUAL(mat2(0, 2), 2);
+  VERIFY_IS_EQUAL(mat2(1, 0), 3);
+  VERIFY_IS_EQUAL(mat2(1, 1), 4);
+  VERIFY_IS_EQUAL(mat2(1, 2), 5);
+}
+
+static void test_3d() {
+  Tensor<int, 3> mat1(2, 3, 7);
+  Tensor<int, 3, RowMajor> mat2(2, 3, 7);
+
+  int val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        mat2(i, j, k) = val;
+        val++;
+      }
+    }
+  }
+
+  int col_major[2 * 3 * 7] = {0};
+  int row_major[2 * 3 * 7] = {0};
+  TensorMap<Tensor<int, 3> > mat3(col_major, 2, 3, 7);
+  TensorMap<Tensor<int, 3, RowMajor> > mat4(row_major, 2, 3, 7);
+
+  mat3 = mat1;
+  mat4 = mat2;
+
+  val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(mat3(i, j, k), val);
+        VERIFY_IS_EQUAL(mat4(i, j, k), val);
+        val++;
+      }
+    }
+  }
+
+  mat1.setZero();
+  mat2.setZero();
+  mat1 = mat3;
+  mat2 = mat4;
+
+  val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(mat1(i, j, k), val);
+        VERIFY_IS_EQUAL(mat2(i, j, k), val);
+        val++;
+      }
+    }
+  }
+}
+
+static void test_same_type() {
+  Tensor<int, 1> orig_tensor(5);
+  Tensor<int, 1> dest_tensor(5);
+  orig_tensor.setRandom();
+  dest_tensor.setRandom();
+  int* orig_data = orig_tensor.data();
+  int* dest_data = dest_tensor.data();
+  dest_tensor = orig_tensor;
+  VERIFY_IS_EQUAL(orig_tensor.data(), orig_data);
+  VERIFY_IS_EQUAL(dest_tensor.data(), dest_data);
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_EQUAL(dest_tensor(i), orig_tensor(i));
+  }
+
+  TensorFixedSize<int, Sizes<5> > orig_array;
+  TensorFixedSize<int, Sizes<5> > dest_array;
+  orig_array.setRandom();
+  dest_array.setRandom();
+  orig_data = orig_array.data();
+  dest_data = dest_array.data();
+  dest_array = orig_array;
+  VERIFY_IS_EQUAL(orig_array.data(), orig_data);
+  VERIFY_IS_EQUAL(dest_array.data(), dest_data);
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_EQUAL(dest_array(i), orig_array(i));
+  }
+
+  int orig[5] = {1, 2, 3, 4, 5};
+  int dest[5] = {6, 7, 8, 9, 10};
+  TensorMap<Tensor<int, 1> > orig_map(orig, 5);
+  TensorMap<Tensor<int, 1> > dest_map(dest, 5);
+  orig_data = orig_map.data();
+  dest_data = dest_map.data();
+  dest_map = orig_map;
+  VERIFY_IS_EQUAL(orig_map.data(), orig_data);
+  VERIFY_IS_EQUAL(dest_map.data(), dest_data);
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_EQUAL(dest[i], i + 1);
+  }
+}
+
+static void test_auto_resize() {
+  Tensor<int, 1> tensor1;
+  Tensor<int, 1> tensor2(3);
+  Tensor<int, 1> tensor3(5);
+  Tensor<int, 1> tensor4(7);
+
+  Tensor<int, 1> new_tensor(5);
+  new_tensor.setRandom();
+
+  tensor1 = tensor2 = tensor3 = tensor4 = new_tensor;
+
+  VERIFY_IS_EQUAL(tensor1.dimension(0), new_tensor.dimension(0));
+  VERIFY_IS_EQUAL(tensor2.dimension(0), new_tensor.dimension(0));
+  VERIFY_IS_EQUAL(tensor3.dimension(0), new_tensor.dimension(0));
+  VERIFY_IS_EQUAL(tensor4.dimension(0), new_tensor.dimension(0));
+  for (int i = 0; i < new_tensor.dimension(0); ++i) {
+    VERIFY_IS_EQUAL(tensor1(i), new_tensor(i));
+    VERIFY_IS_EQUAL(tensor2(i), new_tensor(i));
+    VERIFY_IS_EQUAL(tensor3(i), new_tensor(i));
+    VERIFY_IS_EQUAL(tensor4(i), new_tensor(i));
+  }
+}
+
+static void test_compound_assign() {
+  Tensor<int, 1> start_tensor(10);
+  Tensor<int, 1> offset_tensor(10);
+  setRandomDataInRange(start_tensor, -1000, 1000);
+  setRandomDataInRange(offset_tensor, -1000, 1000);
+
+  // Avoid division by zero in the final compound assignment check.
+  for (int i = 0; i < 10; ++i) {
+    if (offset_tensor(i) == 0) offset_tensor(i) = 1;
+  }
+
+  Tensor<int, 1> tensor = start_tensor;
+  tensor += offset_tensor;
+  for (int i = 0; i < 10; ++i) {
+    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) + offset_tensor(i));
+  }
+
+  tensor = start_tensor;
+  tensor -= offset_tensor;
+  for (int i = 0; i < 10; ++i) {
+    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) - offset_tensor(i));
+  }
+
+  tensor = start_tensor;
+  tensor *= offset_tensor;
+  for (int i = 0; i < 10; ++i) {
+    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) * offset_tensor(i));
+  }
+
+  tensor = start_tensor;
+  tensor /= offset_tensor;
+  for (int i = 0; i < 10; ++i) {
+    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) / offset_tensor(i));
+  }
+}
+
+static void test_std_initializers_tensor() {
+  Tensor<int, 1> a(3);
+  a.setValues({0, 1, 2});
+  VERIFY_IS_EQUAL(a(0), 0);
+  VERIFY_IS_EQUAL(a(1), 1);
+  VERIFY_IS_EQUAL(a(2), 2);
+
+  // It fills the top-left slice.
+  a.setValues({10, 20});
+  VERIFY_IS_EQUAL(a(0), 10);
+  VERIFY_IS_EQUAL(a(1), 20);
+  VERIFY_IS_EQUAL(a(2), 2);
+
+  // Chaining.
+  Tensor<int, 1> a2(3);
+  a2 = a.setValues({100, 200, 300});
+  VERIFY_IS_EQUAL(a(0), 100);
+  VERIFY_IS_EQUAL(a(1), 200);
+  VERIFY_IS_EQUAL(a(2), 300);
+  VERIFY_IS_EQUAL(a2(0), 100);
+  VERIFY_IS_EQUAL(a2(1), 200);
+  VERIFY_IS_EQUAL(a2(2), 300);
+
+  Tensor<int, 2> b(2, 3);
+  b.setValues({{0, 1, 2}, {3, 4, 5}});
+  VERIFY_IS_EQUAL(b(0, 0), 0);
+  VERIFY_IS_EQUAL(b(0, 1), 1);
+  VERIFY_IS_EQUAL(b(0, 2), 2);
+  VERIFY_IS_EQUAL(b(1, 0), 3);
+  VERIFY_IS_EQUAL(b(1, 1), 4);
+  VERIFY_IS_EQUAL(b(1, 2), 5);
+
+  // It fills the top-left slice.
+  b.setValues({{10, 20}, {30}});
+  VERIFY_IS_EQUAL(b(0, 0), 10);
+  VERIFY_IS_EQUAL(b(0, 1), 20);
+  VERIFY_IS_EQUAL(b(0, 2), 2);
+  VERIFY_IS_EQUAL(b(1, 0), 30);
+  VERIFY_IS_EQUAL(b(1, 1), 4);
+  VERIFY_IS_EQUAL(b(1, 2), 5);
+
+  Eigen::Tensor<int, 3> c(3, 2, 4);
+  c.setValues(
+      {{{0, 1, 2, 3}, {4, 5, 6, 7}}, {{10, 11, 12, 13}, {14, 15, 16, 17}}, {{20, 21, 22, 23}, {24, 25, 26, 27}}});
+  VERIFY_IS_EQUAL(c(0, 0, 0), 0);
+  VERIFY_IS_EQUAL(c(0, 0, 1), 1);
+  VERIFY_IS_EQUAL(c(0, 0, 2), 2);
+  VERIFY_IS_EQUAL(c(0, 0, 3), 3);
+  VERIFY_IS_EQUAL(c(0, 1, 0), 4);
+  VERIFY_IS_EQUAL(c(0, 1, 1), 5);
+  VERIFY_IS_EQUAL(c(0, 1, 2), 6);
+  VERIFY_IS_EQUAL(c(0, 1, 3), 7);
+  VERIFY_IS_EQUAL(c(1, 0, 0), 10);
+  VERIFY_IS_EQUAL(c(1, 0, 1), 11);
+  VERIFY_IS_EQUAL(c(1, 0, 2), 12);
+  VERIFY_IS_EQUAL(c(1, 0, 3), 13);
+  VERIFY_IS_EQUAL(c(1, 1, 0), 14);
+  VERIFY_IS_EQUAL(c(1, 1, 1), 15);
+  VERIFY_IS_EQUAL(c(1, 1, 2), 16);
+  VERIFY_IS_EQUAL(c(1, 1, 3), 17);
+  VERIFY_IS_EQUAL(c(2, 0, 0), 20);
+  VERIFY_IS_EQUAL(c(2, 0, 1), 21);
+  VERIFY_IS_EQUAL(c(2, 0, 2), 22);
+  VERIFY_IS_EQUAL(c(2, 0, 3), 23);
+  VERIFY_IS_EQUAL(c(2, 1, 0), 24);
+  VERIFY_IS_EQUAL(c(2, 1, 1), 25);
+  VERIFY_IS_EQUAL(c(2, 1, 2), 26);
+  VERIFY_IS_EQUAL(c(2, 1, 3), 27);
+}
+
+EIGEN_DECLARE_TEST(tensor_assign) {
+  CALL_SUBTEST(test_1d());
+  CALL_SUBTEST(test_2d());
+  CALL_SUBTEST(test_3d());
+  CALL_SUBTEST(test_same_type());
+  CALL_SUBTEST(test_auto_resize());
+  CALL_SUBTEST(test_compound_assign());
+  CALL_SUBTEST(test_std_initializers_tensor());
+}
diff --git a/contrib/test/tensor_block_access.cpp b/contrib/test/tensor_block_access.cpp
new file mode 100644
index 0000000..d8dd0b8
--- /dev/null
+++ b/contrib/test/tensor_block_access.cpp
@@ -0,0 +1,486 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Andy Davis <andydavis@google.com>
+// Copyright (C) 2018 Eugene Zhulenev <ezhulenev@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <algorithm>
+#include <set>
+
+#include <Eigen/Tensor>
+
+using Eigen::ColMajor;
+using Eigen::Index;
+using Eigen::RowMajor;
+using Eigen::Tensor;
+using Eigen::internal::TensorBlockShapeType;
+
+static TensorOpCost zeroCost() { return {0, 0, 0}; }
+
+template <typename T>
+static const T& choose(int layout, const T& col, const T& row) {
+  return layout == ColMajor ? col : row;
+}
+
+static TensorBlockShapeType RandomShape() {
+  return internal::random<bool>() ? TensorBlockShapeType::kUniformAllDims : TensorBlockShapeType::kSkewedInnerDims;
+}
+
+template <int NumDims>
+static size_t RandomTargetSize(const DSizes<Index, NumDims>& dims) {
+  return internal::random<size_t>(1, dims.TotalSize());
+}
+
+template <int NumDims>
+static DSizes<Index, NumDims> RandomDims() {
+  array<Index, NumDims> dims;
+  for (int i = 0; i < NumDims; ++i) {
+    dims[i] = internal::random<int>(1, 20);
+  }
+  return DSizes<Index, NumDims>(dims);
+}
+
+template <typename T>
+static T* GenerateRandomData(const Index& size) {
+  T* data = new T[size];
+  for (int i = 0; i < size; ++i) {
+    data[i] = internal::random<T>();
+  }
+  return data;
+}
+
+template <int NumDims>
+static void Debug(DSizes<Index, NumDims> dims) {
+  for (int i = 0; i < NumDims; ++i) {
+    std::cout << dims[i] << "; ";
+  }
+  std::cout << std::endl;
+}
+
+template <int Layout>
+static void test_block_mapper_sanity() {
+  typedef internal::TensorBlockMapper<2, Layout> TensorBlockMapper;
+
+  DSizes<Index, 2> tensor_dims(100, 100);
+
+  // Test uniform blocks.
+  TensorBlockMapper uniform_block_mapper(tensor_dims, {TensorBlockShapeType::kUniformAllDims, 100, zeroCost()});
+
+  VERIFY_IS_EQUAL(uniform_block_mapper.blockCount(), 100);
+  VERIFY_IS_EQUAL(uniform_block_mapper.blockTotalSize(), 100);
+
+  // 10x10 blocks
+  auto uniform_b0 = uniform_block_mapper.blockDescriptor(0);
+  VERIFY_IS_EQUAL(uniform_b0.dimensions().at(0), 10);
+  VERIFY_IS_EQUAL(uniform_b0.dimensions().at(1), 10);
+
+  // Test skewed to inner dims blocks.
+  TensorBlockMapper skewed_block_mapper(tensor_dims, {TensorBlockShapeType::kSkewedInnerDims, 100, zeroCost()});
+
+  VERIFY_IS_EQUAL(skewed_block_mapper.blockCount(), 100);
+  VERIFY_IS_EQUAL(skewed_block_mapper.blockTotalSize(), 100);
+
+  // 1x100 (100x1) rows/cols depending on a tensor layout.
+  auto skewed_b0 = skewed_block_mapper.blockDescriptor(0);
+  VERIFY_IS_EQUAL(skewed_b0.dimensions().at(0), choose(Layout, 100, 1));
+  VERIFY_IS_EQUAL(skewed_b0.dimensions().at(1), choose(Layout, 1, 100));
+}
+
+// Given a TensorBlock "visit" every element accessible though it, and a keep an
+// index in the visited set. Verify that every coeff accessed only once.
+template <int NumDims, int Layout>
+static void UpdateCoeffSet(const DSizes<Index, NumDims>& tensor_strides,
+                           const internal::TensorBlockDescriptor<NumDims>& block, Index first_coeff_index,
+                           int dim_index, std::set<Index>* visited_coeffs) {
+  const DSizes<Index, NumDims>& block_sizes = block.dimensions();
+
+  for (int i = 0; i < block_sizes[dim_index]; ++i) {
+    if (dim_index == choose(Layout, 0, NumDims - 1)) {
+      typedef std::pair<std::set<Index>::iterator, bool> ReturnType;
+      ReturnType inserted = visited_coeffs->insert(first_coeff_index + i);
+      VERIFY_IS_EQUAL(inserted.second, true);
+    } else {
+      int next_dim_index = dim_index + choose(Layout, -1, 1);
+      UpdateCoeffSet<NumDims, Layout>(tensor_strides, block, first_coeff_index, next_dim_index, visited_coeffs);
+      first_coeff_index += tensor_strides[dim_index];
+    }
+  }
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_block_mapper_maps_every_element() {
+  typedef internal::TensorBlockMapper<NumDims, Layout> TensorBlockMapper;
+
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>();
+  DSizes<Index, NumDims> strides = internal::strides<Layout>(dims);
+
+  // Keep track of elements indices available via block access.
+  std::set<Index> coeff_set;
+
+  // Try different combinations of block types and sizes.
+  TensorBlockMapper block_mapper(dims, {RandomShape(), RandomTargetSize(dims), zeroCost()});
+
+  for (int i = 0; i < block_mapper.blockCount(); ++i) {
+    auto block = block_mapper.blockDescriptor(i);
+    UpdateCoeffSet<NumDims, Layout>(strides, block, block.offset(), choose(Layout, NumDims - 1, 0), &coeff_set);
+  }
+
+  // Verify that every coefficient in the original Tensor is accessible through
+  // TensorBlock only once.
+  Index total_coeffs = dims.TotalSize();
+  VERIFY_IS_EQUAL(Index(coeff_set.size()), total_coeffs);
+  VERIFY_IS_EQUAL(*coeff_set.begin(), 0);
+  VERIFY_IS_EQUAL(*coeff_set.rbegin(), total_coeffs - 1);
+}
+
+template <typename Scalar, typename StorageIndex, int Dim>
+class EqualityChecker {
+  const Scalar* input_data;
+  const DSizes<StorageIndex, Dim>&input_dims, &input_strides, &output_dims, &output_strides;
+  void check_recursive(const Scalar* input, const Scalar* output, int depth = 0) const {
+    if (depth == Dim) {
+      VERIFY_IS_EQUAL(*input, *output);
+      return;
+    }
+
+    for (int i = 0; i < output_dims[depth]; ++i) {
+      check_recursive(input + i % input_dims[depth] * input_strides[depth], output + i * output_strides[depth],
+                      depth + 1);
+    }
+  }
+
+ public:
+  EqualityChecker(const Scalar* input_data_, const DSizes<StorageIndex, Dim>& input_dims_,
+                  const DSizes<StorageIndex, Dim>& input_strides_, const DSizes<StorageIndex, Dim>& output_dims_,
+                  const DSizes<StorageIndex, Dim>& output_strides_)
+      : input_data(input_data_),
+        input_dims(input_dims_),
+        input_strides(input_strides_),
+        output_dims(output_dims_),
+        output_strides(output_strides_) {}
+
+  void operator()(const Scalar* output_data) const { check_recursive(input_data, output_data); }
+};
+
+template <int Layout>
+static void test_uniform_block_shape() {
+  typedef internal::TensorBlockDescriptor<5> TensorBlock;
+  typedef internal::TensorBlockMapper<5, Layout> TensorBlockMapper;
+
+  {
+    // Test shape 'UniformAllDims' with uniform 'max_coeff count'.
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 5 * 5 * 5 * 5 * 5;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    for (int i = 0; i < 5; ++i) {
+      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'UniformAllDims' with larger 'max_coeff count' which spills
+  // partially into first inner-most dimension.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 7 * 5 * 5 * 5 * 5;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
+    for (int i = 1; i < 5; ++i) {
+      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 5 * 5 * 5 * 5 * 6;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(6, block.dimensions()[4]);
+    for (int i = 3; i >= 0; --i) {
+      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'UniformAllDims' with larger 'max_coeff count' which spills
+  // fully into first inner-most dimension.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 11 * 5 * 5 * 5 * 5;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
+    for (int i = 1; i < 5; ++i) {
+      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 5 * 5 * 5 * 5 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    for (int i = 3; i >= 0; --i) {
+      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'UniformAllDims' with larger 'max_coeff count' which spills
+  // fully into first few inner-most dimensions.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(7, 5, 6, 17, 7);
+    const Index max_coeff_count = 7 * 5 * 6 * 7 * 5;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
+    VERIFY_IS_EQUAL(7, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[4]);
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(7, 5, 6, 9, 7);
+    const Index max_coeff_count = 5 * 5 * 5 * 6 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY_IS_EQUAL(6, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[2]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[0]);
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'UniformAllDims' with full allocation to all dims.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(7, 5, 6, 17, 7);
+    const Index max_coeff_count = 7 * 5 * 6 * 17 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
+    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(7, 5, 6, 9, 7);
+    const Index max_coeff_count = 7 * 5 * 6 * 9 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY_IS_EQUAL(9, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+}
+
+template <int Layout>
+static void test_skewed_inner_dim_block_shape() {
+  typedef internal::TensorBlockDescriptor<5> TensorBlock;
+  typedef internal::TensorBlockMapper<5, Layout> TensorBlockMapper;
+
+  // Test shape 'SkewedInnerDims' with partial allocation to inner-most dim.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 10 * 1 * 1 * 1 * 1;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(10, block.dimensions()[0]);
+    for (int i = 1; i < 5; ++i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 1 * 1 * 1 * 1 * 6;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(6, block.dimensions()[4]);
+    for (int i = 3; i >= 0; --i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'SkewedInnerDims' with full allocation to inner-most dim.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 11 * 1 * 1 * 1 * 1;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
+    for (int i = 1; i < 5; ++i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 1 * 1 * 1 * 1 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    for (int i = 3; i >= 0; --i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'SkewedInnerDims' with full allocation to inner-most dim,
+  // and partial allocation to second inner-dim.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 11 * 3 * 1 * 1 * 1;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
+    VERIFY_IS_EQUAL(3, block.dimensions()[1]);
+    for (int i = 2; i < 5; ++i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 1 * 1 * 1 * 15 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY_IS_EQUAL(15, block.dimensions()[3]);
+    for (int i = 2; i >= 0; --i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'SkewedInnerDims' with full allocation to inner-most dim,
+  // and partial allocation to third inner-dim.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 11 * 5 * 5 * 1 * 1;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[2]);
+    for (int i = 3; i < 5; ++i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 1 * 1 * 5 * 17 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[2]);
+    for (int i = 1; i >= 0; --i) {
+      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
+    }
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+
+  // Test shape 'SkewedInnerDims' with full allocation to all dims.
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 11 * 5 * 6 * 17 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
+    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  } else {
+    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
+    const Index max_coeff_count = 11 * 5 * 6 * 17 * 7;
+    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
+    TensorBlock block = block_mapper.blockDescriptor(0);
+    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
+    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
+    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
+    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
+    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
+    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
+  }
+}
+
+template <int Layout>
+static void test_empty_dims(const internal::TensorBlockShapeType block_shape) {
+  // Test blocking of tensors with zero dimensions:
+  //  - we must not crash on asserts and divisions by zero
+  //  - we must not return block with zero dimensions
+  //    (recipe for overflows/underflows, divisions by zero and NaNs later)
+  //  - total block count must be zero
+  {
+    typedef internal::TensorBlockMapper<1, Layout> TensorBlockMapper;
+
+    DSizes<Index, 1> dims(0);
+    for (size_t max_coeff_count = 0; max_coeff_count < 2; ++max_coeff_count) {
+      TensorBlockMapper block_mapper(dims, {block_shape, max_coeff_count, zeroCost()});
+      VERIFY_IS_EQUAL(block_mapper.blockCount(), 0);
+      VERIFY(block_mapper.blockTotalSize() >= 1);
+    }
+  }
+
+  {
+    typedef internal::TensorBlockMapper<2, Layout> TensorBlockMapper;
+
+    for (int dim1 = 0; dim1 < 3; ++dim1) {
+      for (int dim2 = 0; dim2 < 3; ++dim2) {
+        DSizes<Index, 2> dims(dim1, dim2);
+        for (size_t max_coeff_count = 0; max_coeff_count < 2; ++max_coeff_count) {
+          TensorBlockMapper block_mapper(dims, {block_shape, max_coeff_count, zeroCost()});
+          if (dim1 * dim2 == 0) {
+            VERIFY_IS_EQUAL(block_mapper.blockCount(), 0);
+          }
+          VERIFY(block_mapper.blockTotalSize() >= 1);
+        }
+      }
+    }
+  }
+}
+
+#define TEST_LAYOUTS(NAME)        \
+  CALL_SUBTEST(NAME<ColMajor>()); \
+  CALL_SUBTEST(NAME<RowMajor>())
+
+#define TEST_LAYOUTS_AND_DIMS(TYPE, NAME)    \
+  CALL_SUBTEST((NAME<TYPE, 1, ColMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 1, RowMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 2, ColMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 2, RowMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 3, ColMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 3, RowMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 4, ColMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 4, RowMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 5, ColMajor>())); \
+  CALL_SUBTEST((NAME<TYPE, 5, RowMajor>()))
+
+#define TEST_LAYOUTS_WITH_ARG(NAME, ARG) \
+  CALL_SUBTEST(NAME<ColMajor>(ARG));     \
+  CALL_SUBTEST(NAME<RowMajor>(ARG))
+
+EIGEN_DECLARE_TEST(tensor_block_access) {
+  TEST_LAYOUTS(test_block_mapper_sanity);
+  TEST_LAYOUTS_AND_DIMS(float, test_block_mapper_maps_every_element);
+  TEST_LAYOUTS(test_uniform_block_shape);
+  TEST_LAYOUTS(test_skewed_inner_dim_block_shape);
+  TEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kUniformAllDims);
+  TEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kSkewedInnerDims);
+}
+
+#undef TEST_LAYOUTS
+#undef TEST_LAYOUTS_WITH_ARG
diff --git a/contrib/test/tensor_block_eval.cpp b/contrib/test/tensor_block_eval.cpp
new file mode 100644
index 0000000..6ed1242
--- /dev/null
+++ b/contrib/test/tensor_block_eval.cpp
@@ -0,0 +1,1736 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// clang-format off
+#include "main.h"
+#include <Eigen/Tensor>
+#include "../Eigen/SpecialFunctions"
+// clang-format on
+
+using Eigen::internal::TensorBlockDescriptor;
+using Eigen::internal::TensorExecutor;
+
+template <typename T, int NumDims, int Layout>
+static void setRandomForBinaryProduct(Tensor<T, NumDims, Layout>& tensor) {
+  EIGEN_IF_CONSTEXPR ((std::is_integral<T>::value && !std::is_same<T, bool>::value)) {
+    setRandomDataInRange(tensor, T(-1000), T(1000));
+  } else {
+    tensor.setRandom();
+  }
+}
+
+// -------------------------------------------------------------------------- //
+// Utility functions to generate random tensors, blocks, and evaluate them.
+
+template <int NumDims>
+static DSizes<Index, NumDims> RandomDims(Index min, Index max) {
+  DSizes<Index, NumDims> dims;
+  for (int i = 0; i < NumDims; ++i) {
+    dims[i] = internal::random<Index>(min, max);
+  }
+  return DSizes<Index, NumDims>(dims);
+}
+
+// Block offsets and extents allows to construct a TensorSlicingOp corresponding
+// to a TensorBlockDescriptor.
+template <int NumDims>
+struct TensorBlockParams {
+  DSizes<Index, NumDims> offsets;
+  DSizes<Index, NumDims> sizes;
+  TensorBlockDescriptor<NumDims, Index> desc;
+};
+
+template <int Layout, int NumDims>
+static TensorBlockParams<NumDims> RandomBlock(DSizes<Index, NumDims> dims, Index min, Index max) {
+  // Choose random offsets and sizes along all tensor dimensions.
+  DSizes<Index, NumDims> offsets(RandomDims<NumDims>(min, max));
+  DSizes<Index, NumDims> sizes(RandomDims<NumDims>(min, max));
+
+  // Make sure that offset + size do not overflow dims.
+  for (int i = 0; i < NumDims; ++i) {
+    offsets[i] = numext::mini(dims[i] - 1, offsets[i]);
+    sizes[i] = numext::mini(sizes[i], dims[i] - offsets[i]);
+  }
+
+  Index offset = 0;
+  DSizes<Index, NumDims> strides = Eigen::internal::strides<Layout>(dims);
+  for (int i = 0; i < NumDims; ++i) {
+    offset += strides[i] * offsets[i];
+  }
+
+  return {offsets, sizes, TensorBlockDescriptor<NumDims, Index>(offset, sizes)};
+}
+
+// Generate block with block sizes skewed towards inner dimensions. This type of
+// block is required for evaluating broadcast expressions.
+template <int Layout, int NumDims>
+static std::enable_if_t<NumDims == 0, void> SetSkewedInnerBlockInnerOffset(DSizes<Index, NumDims>& /*offsets*/,
+                                                                           Index /*index*/) {}
+
+template <int Layout, int NumDims>
+static std::enable_if_t<(NumDims > 0), void> SetSkewedInnerBlockInnerOffset(DSizes<Index, NumDims>& offsets,
+                                                                            Index index) {
+  EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+    offsets[0] = index;
+  } else {
+    offsets[NumDims - 1] = index;
+  }
+}
+
+template <int Layout, int NumDims>
+static TensorBlockParams<NumDims> SkewedInnerBlock(DSizes<Index, NumDims> dims) {
+  using BlockMapper = internal::TensorBlockMapper<NumDims, Layout, Index>;
+  BlockMapper block_mapper(
+      dims,
+      {internal::TensorBlockShapeType::kSkewedInnerDims, internal::random<size_t>(1, dims.TotalSize()), {0, 0, 0}});
+
+  Index total_blocks = block_mapper.blockCount();
+  Index block_index = internal::random<Index>(0, total_blocks - 1);
+  auto block = block_mapper.blockDescriptor(block_index);
+  DSizes<Index, NumDims> sizes = block.dimensions();
+
+  auto strides = internal::strides<Layout>(dims);
+  DSizes<Index, NumDims> offsets;
+
+  // Compute offsets for the first block coefficient.
+  Index index = block.offset();
+  EIGEN_IF_CONSTEXPR (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+    for (int i = NumDims - 1; i > 0; --i) {
+      const Index idx = index / strides[i];
+      index -= idx * strides[i];
+      offsets[i] = idx;
+    }
+  } else {
+    for (int i = 0; i < NumDims - 1; ++i) {
+      const Index idx = index / strides[i];
+      index -= idx * strides[i];
+      offsets[i] = idx;
+    }
+  }
+  SetSkewedInnerBlockInnerOffset<Layout, NumDims>(offsets, index);
+
+  return {offsets, sizes, block};
+}
+
+template <int NumDims>
+static TensorBlockParams<NumDims> FixedSizeBlock(DSizes<Index, NumDims> dims) {
+  DSizes<Index, NumDims> offsets;
+  for (int i = 0; i < NumDims; ++i) offsets[i] = 0;
+
+  return {offsets, dims, TensorBlockDescriptor<NumDims, Index>(0, dims)};
+}
+
+inline Eigen::IndexList<Index, Eigen::type2index<1>> NByOne(Index n) {
+  Eigen::IndexList<Index, Eigen::type2index<1>> ret;
+  ret.set(0, n);
+  return ret;
+}
+inline Eigen::IndexList<Eigen::type2index<1>, Index> OneByM(Index m) {
+  Eigen::IndexList<Eigen::type2index<1>, Index> ret;
+  ret.set(1, m);
+  return ret;
+}
+
+// -------------------------------------------------------------------------- //
+// Verify that block expression evaluation produces the same result as a
+// TensorSliceOp (reading a tensor block is same to taking a tensor slice).
+
+template <typename T, int NumDims, int Layout, typename Expression, typename GenBlockParams>
+static void VerifyBlockEvaluator(const Expression& expr, GenBlockParams gen_block) {
+  using Device = DefaultDevice;
+  auto d = Device();
+
+  // Scratch memory allocator for block evaluation.
+  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
+  TensorBlockScratch scratch(d);
+
+  // TensorEvaluator is needed to produce tensor blocks of the expression.
+  auto eval = TensorEvaluator<const Expression, Device>(expr, d);
+  eval.evalSubExprsIfNeeded(nullptr);
+
+  // Choose a random offsets, sizes and TensorBlockDescriptor.
+  TensorBlockParams<NumDims> block_params = gen_block();
+
+  // Evaluate TensorBlock expression into a tensor.
+  Tensor<T, NumDims, Layout> block(block_params.desc.dimensions());
+
+  // Dimensions for the potential destination buffer.
+  DSizes<Index, NumDims> dst_dims;
+  if (internal::random<bool>()) {
+    dst_dims = block_params.desc.dimensions();
+  } else {
+    for (int i = 0; i < NumDims; ++i) {
+      Index extent = internal::random<Index>(0, 5);
+      dst_dims[i] = block_params.desc.dimension(i) + extent;
+    }
+  }
+
+  // Maybe use this tensor as a block desc destination.
+  Tensor<T, NumDims, Layout> dst(dst_dims);
+  dst.setZero();
+  if (internal::random<bool>()) {
+    block_params.desc.template AddDestinationBuffer<Layout>(dst.data(), internal::strides<Layout>(dst.dimensions()));
+  }
+
+  const bool root_of_expr = internal::random<bool>();
+  auto tensor_block = eval.block(block_params.desc, scratch, root_of_expr);
+
+  if (tensor_block.kind() == internal::TensorBlockKind::kMaterializedInOutput) {
+    // Copy data from destination buffer.
+    if (dimensions_match(dst.dimensions(), block.dimensions())) {
+      block = dst;
+    } else {
+      DSizes<Index, NumDims> offsets;
+      for (int i = 0; i < NumDims; ++i) offsets[i] = 0;
+      block = dst.slice(offsets, block.dimensions());
+    }
+
+  } else {
+    // Assign to block from expression.
+    auto b_expr = tensor_block.expr();
+
+    // We explicitly disable vectorization and tiling, to run a simple coefficient
+    // wise assignment loop, because it's very simple and should be correct.
+    using BlockAssign = TensorAssignOp<decltype(block), const decltype(b_expr)>;
+    using BlockExecutor = TensorExecutor<const BlockAssign, Device, false, internal::TiledEvaluation::Off>;
+    BlockExecutor::run(BlockAssign(block, b_expr), d);
+  }
+
+  // Cleanup temporary buffers owned by a tensor block.
+  tensor_block.cleanup();
+
+  // Compute a Tensor slice corresponding to a Tensor block.
+  Tensor<T, NumDims, Layout> slice(block_params.desc.dimensions());
+  auto s_expr = expr.slice(block_params.offsets, block_params.sizes);
+
+  // Explicitly use coefficient assignment to evaluate slice expression.
+  using SliceAssign = TensorAssignOp<decltype(slice), const decltype(s_expr)>;
+  using SliceExecutor = TensorExecutor<const SliceAssign, Device, false, internal::TiledEvaluation::Off>;
+  SliceExecutor::run(SliceAssign(slice, s_expr), d);
+
+  // Tensor block and tensor slice must be the same.
+  for (Index i = 0; i < block.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(block.coeff(i), slice.coeff(i));
+  }
+
+  // Release evaluator-owned temporaries (e.g. the materialized buffer that
+  // TensorScan / TensorFFT allocate during evalSubExprsIfNeeded).
+  eval.cleanup();
+}
+
+// -------------------------------------------------------------------------- //
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_block() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // Identity tensor expression transformation.
+  VerifyBlockEvaluator<T, NumDims, Layout>(input, [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_unary_expr_block() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.abs(), [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_binary_expr_block() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> lhs(dims), rhs(dims);
+  setRandomForBinaryProduct(lhs);
+  setRandomForBinaryProduct(rhs);
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(lhs * rhs, [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_binary_with_unary_expr_block() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> lhs(dims), rhs(dims);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>((lhs.abs() + rhs.abs()).sqrt(),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_broadcast() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 10);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  DSizes<Index, NumDims> bcast = RandomDims<NumDims>(1, 5);
+
+  DSizes<Index, NumDims> bcasted_dims;
+  for (int i = 0; i < NumDims; ++i) bcasted_dims[i] = dims[i] * bcast[i];
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast),
+                                           [&bcasted_dims]() { return SkewedInnerBlock<Layout>(bcasted_dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast),
+                                           [&bcasted_dims]() { return RandomBlock<Layout>(bcasted_dims, 5, 10); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast),
+                                           [&bcasted_dims]() { return FixedSizeBlock(bcasted_dims); });
+
+  // Check that desc.destination() memory is not shared between two broadcast
+  // materializations.
+  Tensor<T, NumDims, Layout> product_input(dims);
+  setRandomForBinaryProduct(product_input);
+  VerifyBlockEvaluator<T, NumDims, Layout>(product_input.broadcast(bcast) * product_input.abs().broadcast(bcast),
+                                           [&bcasted_dims]() { return SkewedInnerBlock<Layout>(bcasted_dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_scan() {
+  // Scan eagerly materializes m_output during evalSubExprsIfNeeded; this
+  // exercises the block() wrapper around that buffer.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(4, 12);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  constexpr Index axis = NumDims == 1 ? 0 : NumDims / 2;
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.cumsum(axis), [&dims]() { return RandomBlock<Layout>(dims, 1, 5); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.cumsum(axis), [&dims]() { return FixedSizeBlock(dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_fft() {
+  // FFT eagerly materializes m_data during evalSubExprsIfNeeded; this
+  // exercises the block() wrapper around that buffer. Use RealPart so
+  // the output type matches the input type and the harness's slice
+  // comparison stays straightforward.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(4, 12);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  Eigen::array<int, 1> fft_dims = {0};
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.template fft<RealPart, FFT_FORWARD>(fft_dims),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 5); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.template fft<RealPart, FFT_FORWARD>(fft_dims),
+                                           [&dims]() { return FixedSizeBlock(dims); });
+}
+
+// A destination buffer whose strides do not match the block's dense strides
+// cannot back a tensor expression, but it can still absorb the block when the
+// block is the root of the expression tree, because nothing reads the result
+// back through `expr()`. Verify that such a destination is used rather than
+// routed through scratch, and that the values landing in it are correct.
+template <typename T, int NumDims, int Layout, typename Expression>
+static void VerifyStridedDestinationAtRoot(Expression expr, const DSizes<Index, NumDims>& expr_dims) {
+  using Device = DefaultDevice;
+  using Desc = TensorBlockDescriptor<NumDims, Index>;
+  auto d = Device();
+
+  internal::TensorBlockScratchAllocator<Device> scratch(d);
+
+  auto eval = TensorEvaluator<const Expression, Device>(expr, d);
+  eval.evalSubExprsIfNeeded(nullptr);
+
+  // A block strictly inside the expression, and a destination strictly larger
+  // than the block, so that the destination strides are dense in no dimension
+  // but the innermost.
+  DSizes<Index, NumDims> offsets, sizes, dst_dims;
+  for (int i = 0; i < NumDims; ++i) {
+    offsets[i] = 1;
+    sizes[i] = expr_dims[i] - 2;
+    dst_dims[i] = sizes[i] + 2;
+  }
+
+  Index offset = 0;
+  const DSizes<Index, NumDims> expr_strides = internal::strides<Layout>(expr_dims);
+  for (int i = 0; i < NumDims; ++i) offset += expr_strides[i] * offsets[i];
+
+  Desc desc(offset, sizes);
+  Tensor<T, NumDims, Layout> dst(dst_dims);
+  dst.setZero();
+  desc.template AddDestinationBuffer<Layout>(dst.data(), internal::strides<Layout>(dst.dimensions()));
+  VERIFY(desc.destination().kind() == Desc::DestinationBuffer::kStrided);
+
+  auto tensor_block = eval.block(desc, scratch, /*root_of_expr_ast=*/true);
+  VERIFY(tensor_block.kind() == internal::TensorBlockKind::kMaterializedInOutput);
+  tensor_block.cleanup();
+
+  DSizes<Index, NumDims> zeros;
+  for (int i = 0; i < NumDims; ++i) zeros[i] = 0;
+  Tensor<T, NumDims, Layout> block = dst.slice(zeros, sizes);
+
+  // Reference: the same slice evaluated coefficient-wise.
+  Tensor<T, NumDims, Layout> slice(sizes);
+  auto s_expr = expr.slice(offsets, sizes);
+  using SliceAssign = TensorAssignOp<decltype(slice), const decltype(s_expr)>;
+  using SliceExecutor = TensorExecutor<const SliceAssign, Device, false, internal::TiledEvaluation::Off>;
+  SliceExecutor::run(SliceAssign(slice, s_expr), d);
+
+  for (Index i = 0; i < sizes.TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(block.coeff(i), slice.coeff(i));
+  }
+
+  eval.cleanup();
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_layout_swap() {
+  // The swap_layout expression has the opposite layout of its operand. Build
+  // the input with the opposite layout and assert the block evaluator on the
+  // resulting expression matches the slice-based reference.
+  constexpr int InputLayout = (Layout == ColMajor) ? RowMajor : ColMajor;
+  DSizes<Index, NumDims> input_dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, InputLayout> input(input_dims);
+  setRandomForBinaryProduct(input);
+
+  DSizes<Index, NumDims> swapped_dims;
+  for (int i = 0; i < NumDims; ++i) {
+    swapped_dims[i] = input_dims[NumDims - 1 - i];
+  }
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.swap_layout(),
+                                           [&swapped_dims]() { return RandomBlock<Layout>(swapped_dims, 1, 10); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.swap_layout(),
+                                           [&swapped_dims]() { return FixedSizeBlock(swapped_dims); });
+
+  // An operand without a raw buffer: the block request is forwarded to the
+  // operand with reversed dimensions. A shuffle serves materialized blocks
+  // (re-wrapped without a copy), while a cwise expression on top of it serves
+  // lazy blocks (materialized by the layout swap itself).
+  DSizes<Index, NumDims> reversing_shuffle;
+  for (int i = 0; i < NumDims; ++i) reversing_shuffle[i] = NumDims - 1 - i;
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.shuffle(reversing_shuffle).swap_layout(),
+                                           [&input_dims]() { return RandomBlock<Layout>(input_dims, 1, 10); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.shuffle(reversing_shuffle).swap_layout(),
+                                           [&input_dims]() { return FixedSizeBlock(input_dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(
+      (input.shuffle(reversing_shuffle) * input.shuffle(reversing_shuffle)).swap_layout(),
+      [&input_dims]() { return RandomBlock<Layout>(input_dims, 1, 10); });
+
+  // Both forwarding branches must take a strided destination at the root of
+  // the expression tree instead of paying for a scratch round trip. A
+  // one-dimensional destination is never strided, so it has nothing to pin.
+  EIGEN_IF_CONSTEXPR (NumDims > 1) {
+    VerifyStridedDestinationAtRoot<T, NumDims, Layout>(input.shuffle(reversing_shuffle).swap_layout(), input_dims);
+    VerifyStridedDestinationAtRoot<T, NumDims, Layout>(
+        (input.shuffle(reversing_shuffle) * input.shuffle(reversing_shuffle)).swap_layout(), input_dims);
+  }
+}
+
+// Regression for the original failure mode this MR fixes: TensorPaddingOp's
+// BlockAccess gates on m_impl.RawAccess (true for Scan/FFT/LayoutSwap/Contraction)
+// and its getResourceRequirements() unconditionally calls the operand's. Before
+// the operand-side block plumbing was added, instantiating the executor's
+// Tiling=On path through these compositions failed to compile. Driving block()
+// over the composed expressions exercises both sides of that compile path.
+template <typename T, int NumDims, int Layout>
+static void test_eval_composed_block_ops() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(4, 8);
+  array<std::pair<Index, Index>, NumDims> paddings;
+  DSizes<Index, NumDims> padded_dims;
+  for (int i = 0; i < NumDims; ++i) {
+    paddings[i] = std::make_pair(1, 2);
+    padded_dims[i] = dims[i] + 3;
+  }
+
+  constexpr Index axis = NumDims == 1 ? 0 : NumDims / 2;
+
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // cumsum(...).pad(...) — TensorScan + TensorPadding.
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.cumsum(axis).pad(paddings),
+                                           [&padded_dims]() { return RandomBlock<Layout>(padded_dims, 1, 5); });
+
+  // swap_layout().pad(...) — operand built with the opposite layout so the
+  // composed expression evaluates in the test's Layout.
+  constexpr int InputLayout = (Layout == ColMajor) ? RowMajor : ColMajor;
+  Tensor<T, NumDims, InputLayout> swap_input(dims);
+  swap_input.setRandom();
+  DSizes<Index, NumDims> swap_padded_dims;
+  for (int i = 0; i < NumDims; ++i) {
+    swap_padded_dims[i] = dims[NumDims - 1 - i] + 3;
+  }
+  VerifyBlockEvaluator<T, NumDims, Layout>(swap_input.swap_layout().pad(paddings), [&swap_padded_dims]() {
+    return RandomBlock<Layout>(swap_padded_dims, 1, 5);
+  });
+}
+
+// 2D-specific regression: contract(...).pad(...) hit the same composition bug
+// because TensorContraction has RawAccess=true but lacked getResourceRequirements().
+template <typename T, int Layout>
+static void test_eval_contract_pad_composition() {
+  Tensor<T, 2, Layout> A(8, 6);
+  Tensor<T, 2, Layout> B(6, 4);
+  A.setRandom();
+  B.setRandom();
+
+  Eigen::array<IndexPair<Index>, 1> contract_dims = {IndexPair<Index>(1, 0)};
+  array<std::pair<Index, Index>, 2> paddings = {std::pair<Index, Index>{1, 1}, std::pair<Index, Index>{2, 2}};
+  DSizes<Index, 2> padded_dims(8 + 2, 4 + 4);
+
+  VerifyBlockEvaluator<T, 2, Layout>(A.contract(B, contract_dims).pad(paddings),
+                                     [&padded_dims]() { return RandomBlock<Layout>(padded_dims, 1, 5); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_reshape() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 10);
+
+  DSizes<Index, NumDims> shuffled = dims;
+  std::shuffle(&shuffled[0], &shuffled[NumDims - 1], std::mt19937(g_seed));
+
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.reshape(shuffled),
+                                           [&shuffled]() { return RandomBlock<Layout>(shuffled, 1, 10); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.reshape(shuffled),
+                                           [&shuffled]() { return SkewedInnerBlock<Layout>(shuffled); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_cast() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.template cast<int>().template cast<T>(),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_ternary() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> a(dims);
+  Tensor<T, NumDims, Layout> b(dims);
+  Tensor<T, NumDims, Layout> x(dims);
+  // betainc requires a > 0, b > 0 and x in [0, 1].
+  a.setRandom();
+  b.setRandom();
+  x.setRandom();
+  a = a.abs() + a.constant(T(0.5));
+  b = b.abs() + b.constant(T(0.5));
+  x = (x + x.constant(T(1))) * x.constant(T(0.5));
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(Eigen::betainc(a, b, x),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 20); });
+  VerifyBlockEvaluator<T, NumDims, Layout>(Eigen::betainc(a, b, x), [&dims]() { return FixedSizeBlock(dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_nullary() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.constant(T(7)),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.constant(T(7)), [&dims]() { return FixedSizeBlock(dims); });
+
+  // Nullary leaf composed under a block-capable binary expression.
+  VerifyBlockEvaluator<T, NumDims, Layout>(input * input.constant(T(1)),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_random_nullary() {
+  // Each draw is a pure function of the generator's seed and the coefficient's
+  // tensor-linear index, so a block must reproduce the coefficient evaluation
+  // of the same expression exactly.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  auto expr = input.random();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(expr, [&dims]() { return RandomBlock<Layout>(dims, 5, 10); });
+  VerifyBlockEvaluator<T, NumDims, Layout>(expr, [&dims]() { return FixedSizeBlock(dims); });
+
+  // The full tensor always has >= 10 elements; all of them collapsing to one
+  // value means the generator was not actually invoked per element.
+  Tensor<T, NumDims, Layout> full = expr;
+  bool all_equal = true;
+  for (Index i = 0; i < full.size(); ++i) {
+    VERIFY(full.coeff(i) >= T(0) && full.coeff(i) < T(1));
+    all_equal = all_equal && (full.coeff(i) == full.coeff(0));
+  }
+  VERIFY(!all_equal);
+}
+
+// A zero-argument operator() alone does not imply index independence: when an
+// indexed overload also exists, nullary_wrapper dispatches to it, so blocks
+// must be materialized with true tensor-linear indices rather than served
+// lazily with indices restarting at each block origin.
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_indexed_nullary() {
+  struct BothOverloads {
+    T operator()() const { return T(-1); }
+    T operator()(Index i) const { return static_cast<T>(i); }
+  };
+
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.nullaryExpr(BothOverloads()),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.nullaryExpr(BothOverloads()),
+                                           [&dims]() { return FixedSizeBlock(dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_select() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> lhs(dims);
+  Tensor<T, NumDims, Layout> rhs(dims);
+  Tensor<bool, NumDims, Layout> cond(dims);
+  lhs.setRandom();
+  rhs.setRandom();
+  cond.setRandom();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(cond.select(lhs, rhs),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 20); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_padding() {
+  constexpr int inner_dim = Layout == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
+
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  DSizes<Index, NumDims> pad_before = RandomDims<NumDims>(0, 4);
+  DSizes<Index, NumDims> pad_after = RandomDims<NumDims>(0, 4);
+  array<std::pair<Index, Index>, NumDims> paddings;
+  for (int i = 0; i < NumDims; ++i) {
+    paddings[i] = std::make_pair(pad_before[i], pad_after[i]);
+  }
+
+  // Test squeezing reads from inner dim.
+  if (internal::random<bool>()) {
+    pad_before[inner_dim] = 0;
+    pad_after[inner_dim] = 0;
+    paddings[inner_dim] = std::make_pair(0, 0);
+  }
+
+  DSizes<Index, NumDims> padded_dims;
+  for (int i = 0; i < NumDims; ++i) {
+    padded_dims[i] = dims[i] + pad_before[i] + pad_after[i];
+  }
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.pad(paddings),
+                                           [&padded_dims]() { return FixedSizeBlock(padded_dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.pad(paddings),
+                                           [&padded_dims]() { return RandomBlock<Layout>(padded_dims, 1, 10); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.pad(paddings),
+                                           [&padded_dims]() { return SkewedInnerBlock<Layout>(padded_dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_chipping() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  Index chip_dim = internal::random<int>(0, NumDims - 1);
+  Index chip_offset = internal::random<Index>(0, dims[chip_dim] - 2);
+
+  DSizes<Index, NumDims - 1> chipped_dims;
+  for (Index i = 0; i < chip_dim; ++i) {
+    chipped_dims[i] = dims[i];
+  }
+  for (Index i = chip_dim + 1; i < NumDims; ++i) {
+    chipped_dims[i - 1] = dims[i];
+  }
+
+  // Block buffer forwarding.
+  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.chip(chip_offset, chip_dim),
+                                               [&chipped_dims]() { return FixedSizeBlock(chipped_dims); });
+
+  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.chip(chip_offset, chip_dim),
+                                               [&chipped_dims]() { return RandomBlock<Layout>(chipped_dims, 1, 10); });
+
+  // Block expression assignment.
+  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.abs().chip(chip_offset, chip_dim),
+                                               [&chipped_dims]() { return FixedSizeBlock(chipped_dims); });
+
+  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.abs().chip(chip_offset, chip_dim),
+                                               [&chipped_dims]() { return RandomBlock<Layout>(chipped_dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_concatenation() {
+  DSizes<Index, NumDims> lhs_dims = RandomDims<NumDims>(5, 12);
+  DSizes<Index, NumDims> rhs_dims = lhs_dims;
+
+  const Index axis = internal::random<int>(0, NumDims - 1);
+  rhs_dims[axis] = internal::random<Index>(1, 10);
+
+  Tensor<T, NumDims, Layout> lhs(lhs_dims);
+  Tensor<T, NumDims, Layout> rhs(rhs_dims);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  DSizes<Index, NumDims> out_dims = lhs_dims;
+  out_dims[axis] = lhs_dims[axis] + rhs_dims[axis];
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(lhs.concatenate(rhs, axis),
+                                           [&out_dims]() { return FixedSizeBlock(out_dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(lhs.concatenate(rhs, axis),
+                                           [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 5); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(lhs.concatenate(rhs, axis),
+                                           [&out_dims]() { return SkewedInnerBlock<Layout>(out_dims); });
+}
+
+template <typename T, int NumDims>
+struct SimpleTensorGenerator {
+  T operator()(const array<Index, NumDims>& coords) const {
+    T result = static_cast<T>(0);
+    for (int i = 0; i < NumDims; ++i) {
+      result += static_cast<T>((i + 1) * coords[i]);
+    }
+    return result;
+  }
+};
+
+// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
+template <int NumDims>
+struct SimpleTensorGenerator<bool, NumDims> {
+  bool operator()(const array<Index, NumDims>& coords) const {
+    bool result = false;
+    for (int i = 0; i < NumDims; ++i) {
+      result = result != (coords[i] != 0);
+    }
+    return result;
+  }
+};
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_generator() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  auto generator = SimpleTensorGenerator<T, NumDims>();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.generate(generator), [&dims]() { return FixedSizeBlock(dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.generate(generator),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_reverse() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // Randomly reverse dimensions.
+  Eigen::DSizes<bool, NumDims> reverse;
+  for (int i = 0; i < NumDims; ++i) reverse[i] = internal::random<bool>();
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.reverse(reverse), [&dims]() { return FixedSizeBlock(dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.reverse(reverse),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_slice() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // Pick a random slice of an input tensor.
+  DSizes<Index, NumDims> slice_start = RandomDims<NumDims>(5, 10);
+  DSizes<Index, NumDims> slice_size = RandomDims<NumDims>(5, 10);
+
+  // Make sure that slice start + size do not overflow tensor dims.
+  for (int i = 0; i < NumDims; ++i) {
+    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
+    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
+  }
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.slice(slice_start, slice_size),
+                                           [&slice_size]() { return FixedSizeBlock(slice_size); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.slice(slice_start, slice_size),
+                                           [&slice_size]() { return RandomBlock<Layout>(slice_size, 1, 10); });
+}
+
+// Exercise the block evaluator for bool slices as a sub-expression of a
+// block-aware parent op at sizes spanning Packet16b (16-lane bool packet)
+// boundaries. Before the BlockAccess fix for bool slicing, the parent op's
+// BlockAccess would be forced to false and this composition would never
+// dispatch through the block path.
+template <int NumDims, int Layout>
+static void test_eval_tensor_slice_bool_composite() {
+  const Index boundary_sizes[] = {15, 16, 17, 31, 32, 33, 47, 48, 49};
+  for (Index sz : boundary_sizes) {
+    DSizes<Index, NumDims> dims;
+    for (int i = 0; i < NumDims; ++i) dims[i] = sz;
+
+    Tensor<bool, NumDims, Layout> lhs(dims);
+    Tensor<bool, NumDims, Layout> rhs(dims);
+    lhs.setRandom();
+    rhs.setRandom();
+
+    // Slice skewed off the boundary so the block layout straddles packet
+    // boundaries of the underlying tensor.
+    DSizes<Index, NumDims> slice_start;
+    DSizes<Index, NumDims> slice_size;
+    for (int i = 0; i < NumDims; ++i) {
+      slice_start[i] = sz >= 2 ? 1 : 0;
+      slice_size[i] = sz - slice_start[i];
+    }
+
+    auto expr = lhs.slice(slice_start, slice_size) && rhs.slice(slice_start, slice_size);
+
+    VerifyBlockEvaluator<bool, NumDims, Layout>(expr, [&slice_size]() { return FixedSizeBlock(slice_size); });
+    VerifyBlockEvaluator<bool, NumDims, Layout>(expr,
+                                                [&slice_size, sz]() { return RandomBlock<Layout>(slice_size, 1, sz); });
+  }
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_shuffle() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  DSizes<Index, NumDims> shuffle;
+  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
+
+  do {
+    DSizes<Index, NumDims> shuffled_dims;
+    for (int i = 0; i < NumDims; ++i) shuffled_dims[i] = dims[shuffle[i]];
+
+    VerifyBlockEvaluator<T, NumDims, Layout>(input.shuffle(shuffle),
+                                             [&shuffled_dims]() { return FixedSizeBlock(shuffled_dims); });
+
+    VerifyBlockEvaluator<T, NumDims, Layout>(input.shuffle(shuffle),
+                                             [&shuffled_dims]() { return RandomBlock<Layout>(shuffled_dims, 1, 5); });
+
+    break;
+
+  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_inflation() {
+  // Keep the input small: inflation multiplies every dimension by its stride.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(2, 5);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  DSizes<Index, NumDims> strides;
+  DSizes<Index, NumDims> inflated_dims;
+  for (int i = 0; i < NumDims; ++i) {
+    strides[i] = internal::random<Index>(1, 3);
+    inflated_dims[i] = (dims[i] - 1) * strides[i] + 1;
+  }
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.inflate(strides),
+                                           [&inflated_dims]() { return RandomBlock<Layout>(inflated_dims, 1, 10); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.inflate(strides),
+                                           [&inflated_dims]() { return SkewedInnerBlock<Layout>(inflated_dims); });
+
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.inflate(strides),
+                                           [&inflated_dims]() { return FixedSizeBlock(inflated_dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_eval_tensor_strided_slice() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // Sweep unit, dilated, and negative strides; start/stop are chosen in-range
+  // so that clamping does not kick in.
+  const Index stride_choices[] = {1, 2, 3, -1, -2};
+  for (const Index s : stride_choices) {
+    DSizes<Index, NumDims> start, stop, strides, out_dims;
+    for (int i = 0; i < NumDims; ++i) {
+      strides[i] = s;
+      if (s > 0) {
+        start[i] = 1;
+        stop[i] = dims[i] - 1;
+      } else {
+        start[i] = dims[i] - 2;
+        stop[i] = 0;
+      }
+      const Index interval = stop[i] - start[i];
+      out_dims[i] = interval / strides[i] + (interval % strides[i] != 0 ? 1 : 0);
+    }
+
+    VerifyBlockEvaluator<T, NumDims, Layout>(input.stridedSlice(start, stop, strides),
+                                             [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 5); });
+    VerifyBlockEvaluator<T, NumDims, Layout>(input.stridedSlice(start, stop, strides),
+                                             [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // The identity strided slice serves blocks straight from the input buffer.
+  DSizes<Index, NumDims> zeros, ones;
+  for (int i = 0; i < NumDims; ++i) {
+    zeros[i] = 0;
+    ones[i] = 1;
+  }
+  VerifyBlockEvaluator<T, NumDims, Layout>(input.stridedSlice(zeros, dims, ones),
+                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 5); });
+}
+
+template <typename T, int Layout>
+static void test_eval_tensor_reshape_with_bcast() {
+  Index dim = internal::random<Index>(1, 100);
+
+  Tensor<T, 2, Layout> lhs(1, dim);
+  Tensor<T, 2, Layout> rhs(dim, 1);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  auto reshapeLhs = NByOne(dim);
+  auto reshapeRhs = OneByM(dim);
+
+  auto bcastLhs = OneByM(dim);
+  auto bcastRhs = NByOne(dim);
+
+  DSizes<Index, 2> dims(dim, dim);
+
+  VerifyBlockEvaluator<T, 2, Layout>(
+      lhs.reshape(reshapeLhs).broadcast(bcastLhs) * rhs.reshape(reshapeRhs).broadcast(bcastRhs),
+      [dims]() { return SkewedInnerBlock<Layout, 2>(dims); });
+}
+
+template <typename T, int Layout>
+static void test_eval_tensor_forced_eval() {
+  Index dim = internal::random<Index>(1, 100);
+
+  Tensor<T, 2, Layout> lhs(dim, 1);
+  Tensor<T, 2, Layout> rhs(1, dim);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  auto bcastLhs = OneByM(dim);
+  auto bcastRhs = NByOne(dim);
+
+  DSizes<Index, 2> dims(dim, dim);
+
+  VerifyBlockEvaluator<T, 2, Layout>((lhs.broadcast(bcastLhs) * rhs.broadcast(bcastRhs)).eval().reshape(dims),
+                                     [dims]() { return SkewedInnerBlock<Layout, 2>(dims); });
+
+  VerifyBlockEvaluator<T, 2, Layout>((lhs.broadcast(bcastLhs) * rhs.broadcast(bcastRhs)).eval().reshape(dims),
+                                     [dims]() { return RandomBlock<Layout, 2>(dims, 1, 50); });
+}
+
+template <typename T, int Layout>
+static void test_eval_tensor_chipping_of_bcast() {
+  if (Layout != static_cast<int>(RowMajor)) return;
+
+  Index dim0 = internal::random<Index>(1, 10);
+  Index dim1 = internal::random<Index>(1, 10);
+  Index dim2 = internal::random<Index>(1, 10);
+
+  Tensor<T, 3, Layout> input(1, dim1, dim2);
+  input.setRandom();
+
+  Eigen::array<Index, 3> bcast = {{dim0, 1, 1}};
+  DSizes<Index, 2> chipped_dims(dim0, dim2);
+
+  VerifyBlockEvaluator<T, 2, Layout>(input.broadcast(bcast).chip(0, 1),
+                                     [chipped_dims]() { return FixedSizeBlock(chipped_dims); });
+
+  VerifyBlockEvaluator<T, 2, Layout>(input.broadcast(bcast).chip(0, 1),
+                                     [chipped_dims]() { return SkewedInnerBlock<Layout, 2>(chipped_dims); });
+
+  VerifyBlockEvaluator<T, 2, Layout>(input.broadcast(bcast).chip(0, 1),
+                                     [chipped_dims]() { return RandomBlock<Layout, 2>(chipped_dims, 1, 5); });
+}
+
+template <typename T, int Layout>
+static void test_eval_tensor_patch() {
+  DSizes<Index, 3> dims = RandomDims<3>(4, 10);
+  Tensor<T, 3, Layout> input(dims);
+  input.setRandom();
+
+  DSizes<Index, 3> patch_dims;
+  Index num_patches = 1;
+  for (int i = 0; i < 3; ++i) {
+    patch_dims[i] = internal::random<Index>(1, dims[i]);
+    num_patches *= (dims[i] - patch_dims[i] + 1);
+  }
+
+  DSizes<Index, 4> out_dims;
+  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+    out_dims = DSizes<Index, 4>(patch_dims[0], patch_dims[1], patch_dims[2], num_patches);
+  } else {
+    out_dims = DSizes<Index, 4>(num_patches, patch_dims[0], patch_dims[1], patch_dims[2]);
+  }
+
+  VerifyBlockEvaluator<T, 4, Layout>(input.extract_patches(patch_dims),
+                                     [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+
+  VerifyBlockEvaluator<T, 4, Layout>(input.extract_patches(patch_dims),
+                                     [&out_dims]() { return SkewedInnerBlock<Layout>(out_dims); });
+
+  VerifyBlockEvaluator<T, 4, Layout>(input.extract_patches(patch_dims),
+                                     [&out_dims]() { return FixedSizeBlock(out_dims); });
+
+  // Dispatch check: stride() serves neither blocks nor raw buffers, so this
+  // pins down that the patch block path needs no capability bit from its
+  // argument, only coeff().
+  {
+    const array<Index, 3> strides = {{2, 2, 2}};
+    auto strided = input.stride(strides);
+    typedef TensorEvaluator<const decltype(strided), DefaultDevice> StridedEval;
+    static_assert(!StridedEval::BlockAccess && !StridedEval::RawAccess,
+                  "stride() must stay a coeff()-only argument for this check to be meaningful");
+
+    DSizes<Index, 3> strided_dims;
+    DSizes<Index, 3> strided_patch_dims;
+    Index strided_num_patches = 1;
+    for (int i = 0; i < 3; ++i) {
+      strided_dims[i] = (dims[i] - 1) / 2 + 1;
+      strided_patch_dims[i] = internal::random<Index>(1, strided_dims[i]);
+      strided_num_patches *= (strided_dims[i] - strided_patch_dims[i] + 1);
+    }
+    DSizes<Index, 4> strided_out_dims;
+    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
+      strided_out_dims =
+          DSizes<Index, 4>(strided_patch_dims[0], strided_patch_dims[1], strided_patch_dims[2], strided_num_patches);
+    } else {
+      strided_out_dims =
+          DSizes<Index, 4>(strided_num_patches, strided_patch_dims[0], strided_patch_dims[1], strided_patch_dims[2]);
+    }
+
+    auto strided_patch = strided.extract_patches(strided_patch_dims);
+    typedef TensorEvaluator<const decltype(strided_patch), DefaultDevice> PatchEval;
+    static_assert(PatchEval::BlockAccess && PatchEval::PreferBlockAccess,
+                  "the patch block path must dispatch for a coeff()-only argument");
+    VerifyBlockEvaluator<T, 4, Layout>(strided_patch,
+                                       [&strided_out_dims]() { return RandomBlock<Layout>(strided_out_dims, 1, 10); });
+  }
+}
+
+template <typename T, int Layout>
+static void test_eval_tensor_image_patch() {
+  static constexpr bool kColMajor = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+  const Index depth = internal::random<Index>(1, 5);
+  const Index rows = internal::random<Index>(6, 12);
+  const Index cols = internal::random<Index>(6, 12);
+  const Index batch = internal::random<Index>(1, 3);
+
+  DSizes<Index, 4> input_dims =
+      kColMajor ? DSizes<Index, 4>(depth, rows, cols, batch) : DSizes<Index, 4>(batch, cols, rows, depth);
+  Tensor<T, 4, Layout> input(input_dims);
+  input.setRandom();
+
+  const Index pr = internal::random<Index>(1, 3);
+  const Index pc = internal::random<Index>(1, 3);
+
+  auto make_out_dims = [&](Index out_r, Index out_c) {
+    return kColMajor ? DSizes<Index, 5>(depth, pr, pc, out_r * out_c, batch)
+                     : DSizes<Index, 5>(batch, out_r * out_c, pc, pr, depth);
+  };
+
+  // No padding, unit strides.
+  {
+    DSizes<Index, 5> out_dims = make_out_dims(rows - pr + 1, cols - pc + 1);
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 1, 1, 1, 1, PADDING_VALID),
+                                       [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 1, 1, 1, 1, PADDING_VALID),
+                                       [&out_dims]() { return SkewedInnerBlock<Layout>(out_dims); });
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 1, 1, 1, 1, PADDING_VALID),
+                                       [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Same padding with strided patch extraction (blocks contain padding runs).
+  {
+    DSizes<Index, 5> out_dims = make_out_dims(numext::div_ceil(rows, Index(2)), numext::div_ceil(cols, Index(2)));
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 2, 2, 1, 1, PADDING_SAME),
+                                       [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 2, 2, 1, 1, PADDING_SAME),
+                                       [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Dilated patches (non-unit in-row/in-col strides).
+  {
+    const Index pr_eff = pr + (pr - 1);
+    const Index pc_eff = pc + (pc - 1);
+    DSizes<Index, 5> out_dims = make_out_dims(rows - pr_eff + 1, cols - pc_eff + 1);
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 1, 1, 2, 2, PADDING_VALID),
+                                       [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 5, Layout>(input.extract_image_patches(pr, pc, 1, 1, 2, 2, PADDING_VALID),
+                                       [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Inflated (zero-interleaved) input. Only the long overload can set the
+  // inflate strides, and they are what makes an in-range coordinate land
+  // between samples, which is a branch none of the cases above reach.
+  {
+    const Index rows_eff = (rows - 1) * 2 + 1;
+    const Index cols_eff = (cols - 1) * 2 + 1;
+    DSizes<Index, 5> out_dims = make_out_dims(rows_eff - pr + 1, cols_eff - pc + 1);
+    auto inflated = input.extract_image_patches(pr, pc, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, T(0));
+    VerifyBlockEvaluator<T, 5, Layout>(inflated, [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 5, Layout>(inflated, [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Dispatch check: stride() serves neither blocks nor raw buffers, so this
+  // pins down that the block path needs no capability bit from its argument.
+  {
+    const array<Index, 4> strides = {{1, 2, 2, 1}};
+    auto strided_patch = input.stride(strides).extract_image_patches(pr, pc, 1, 1, 1, 1, PADDING_VALID);
+    typedef TensorEvaluator<const decltype(strided_patch), DefaultDevice> PatchEval;
+    static_assert(PatchEval::BlockAccess && PatchEval::PreferBlockAccess,
+                  "the image-patch block path must dispatch for a coeff()-only argument");
+    const Index rows_s = (rows - 1) / 2 + 1;
+    const Index cols_s = (cols - 1) / 2 + 1;
+    DSizes<Index, 5> out_dims = make_out_dims(rows_s - pr + 1, cols_s - pc + 1);
+    VerifyBlockEvaluator<T, 5, Layout>(strided_patch, [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+  }
+}
+
+template <typename T, int Layout>
+static void test_eval_tensor_volume_patch() {
+  static constexpr bool kColMajor = static_cast<int>(Layout) == static_cast<int>(ColMajor);
+  const Index depth = internal::random<Index>(1, 4);
+  const Index planes = internal::random<Index>(5, 8);
+  const Index rows = internal::random<Index>(5, 8);
+  const Index cols = internal::random<Index>(5, 8);
+  const Index batch = internal::random<Index>(1, 2);
+
+  DSizes<Index, 5> input_dims = kColMajor ? DSizes<Index, 5>(depth, planes, rows, cols, batch)
+                                          : DSizes<Index, 5>(batch, cols, rows, planes, depth);
+  Tensor<T, 5, Layout> input(input_dims);
+  input.setRandom();
+
+  const Index pp = internal::random<Index>(1, 3);
+  const Index pr = internal::random<Index>(1, 3);
+  const Index pc = internal::random<Index>(1, 3);
+
+  auto make_out_dims = [&](Index out_p, Index out_r, Index out_c) {
+    return kColMajor ? DSizes<Index, 6>(depth, pp, pr, pc, out_p * out_r * out_c, batch)
+                     : DSizes<Index, 6>(batch, out_p * out_r * out_c, pc, pr, pp, depth);
+  };
+
+  // No padding, unit strides.
+  {
+    DSizes<Index, 6> out_dims = make_out_dims(planes - pp + 1, rows - pr + 1, cols - pc + 1);
+    VerifyBlockEvaluator<T, 6, Layout>(input.extract_volume_patches(pp, pr, pc, 1, 1, 1, PADDING_VALID),
+                                       [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 6, Layout>(input.extract_volume_patches(pp, pr, pc, 1, 1, 1, PADDING_VALID),
+                                       [&out_dims]() { return SkewedInnerBlock<Layout>(out_dims); });
+    VerifyBlockEvaluator<T, 6, Layout>(input.extract_volume_patches(pp, pr, pc, 1, 1, 1, PADDING_VALID),
+                                       [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Same padding with strided patch extraction (blocks contain padding runs).
+  {
+    DSizes<Index, 6> out_dims = make_out_dims(numext::div_ceil(planes, Index(2)), numext::div_ceil(rows, Index(2)),
+                                              numext::div_ceil(cols, Index(2)));
+    VerifyBlockEvaluator<T, 6, Layout>(input.extract_volume_patches(pp, pr, pc, 2, 2, 2, PADDING_SAME),
+                                       [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 6, Layout>(input.extract_volume_patches(pp, pr, pc, 2, 2, 2, PADDING_SAME),
+                                       [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Inflated (zero-interleaved) input, reaching the branch that rejects an
+  // in-range coordinate for landing between samples.
+  {
+    const Index planes_eff = (planes - 1) * 2 + 1;
+    const Index rows_eff = (rows - 1) * 2 + 1;
+    const Index cols_eff = (cols - 1) * 2 + 1;
+    DSizes<Index, 6> out_dims = make_out_dims(planes_eff - pp + 1, rows_eff - pr + 1, cols_eff - pc + 1);
+    auto inflated = input.extract_volume_patches(pp, pr, pc, 1, 1, 1, 2, 2, 2, 0, 0, 0, 0, 0, 0, T(0));
+    VerifyBlockEvaluator<T, 6, Layout>(inflated, [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+    VerifyBlockEvaluator<T, 6, Layout>(inflated, [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+
+  // Dispatch check: stride() serves neither blocks nor raw buffers, so this
+  // pins down that the block path needs no capability bit from its argument.
+  {
+    const array<Index, 5> strides = {{1, 2, 2, 2, 1}};
+    auto strided_patch = input.stride(strides).extract_volume_patches(pp, pr, pc, 1, 1, 1, PADDING_VALID);
+    typedef TensorEvaluator<const decltype(strided_patch), DefaultDevice> PatchEval;
+    static_assert(PatchEval::BlockAccess && PatchEval::PreferBlockAccess,
+                  "the volume-patch block path must dispatch for a coeff()-only argument");
+    const Index planes_s = (planes - 1) / 2 + 1;
+    const Index rows_s = (rows - 1) / 2 + 1;
+    const Index cols_s = (cols - 1) / 2 + 1;
+    DSizes<Index, 6> out_dims = make_out_dims(planes_s - pp + 1, rows_s - pr + 1, cols_s - pc + 1);
+    VerifyBlockEvaluator<T, 6, Layout>(strided_patch, [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 10); });
+  }
+}
+
+// -------------------------------------------------------------------------- //
+// Verify that assigning block to a Tensor expression produces the same result
+// as an assignment to TensorSliceOp (writing a block is is identical to
+// assigning one tensor to a slice of another tensor).
+
+// `Layout` is the layout of the expression and the blocks written through it;
+// `TensorLayout` is the layout of the underlying destination tensor. They only
+// differ when the expression contains a layout swap.
+template <typename T, int NumDims, int Layout, int NumExprDims = NumDims, int TensorLayout = Layout,
+          typename Expression, typename GenBlockParams>
+static void VerifyBlockAssignment(Tensor<T, NumDims, TensorLayout>& tensor, Expression expr, GenBlockParams gen_block) {
+  using Device = DefaultDevice;
+  auto d = Device();
+
+  // We use tensor evaluator as a target for block and slice assignments.
+  auto eval = TensorEvaluator<decltype(expr), Device>(expr, d);
+
+  // Generate a random block, or choose a block that fits in full expression.
+  TensorBlockParams<NumExprDims> block_params = gen_block();
+
+  // Generate random data of the selected block size.
+  Tensor<T, NumExprDims, Layout> block(block_params.desc.dimensions());
+  block.setRandom();
+
+  // ************************************************************************ //
+  // (1) Assignment from a block.
+
+  // Construct a materialize block from a random generated block tensor.
+  internal::TensorMaterializedBlock<T, NumExprDims, Layout> blk(internal::TensorBlockKind::kView, block.data(),
+                                                                block.dimensions());
+
+  // Reset all underlying tensor values to zero.
+  tensor.setZero();
+
+  // Use evaluator to write block into a tensor.
+  eval.writeBlock(block_params.desc, blk);
+
+  // Make a copy of the result after assignment.
+  Tensor<T, NumDims, TensorLayout> block_assigned = tensor;
+
+  // ************************************************************************ //
+  // (2) Assignment to a slice
+
+  // Reset all underlying tensor values to zero.
+  tensor.setZero();
+
+  // Assign block to a slice of original expression
+  auto s_expr = expr.slice(block_params.offsets, block_params.sizes);
+
+  // Explicitly use coefficient assignment to evaluate slice expression.
+  using SliceAssign = TensorAssignOp<decltype(s_expr), const decltype(block)>;
+  using SliceExecutor = TensorExecutor<const SliceAssign, Device, false, internal::TiledEvaluation::Off>;
+  SliceExecutor::run(SliceAssign(s_expr, block), d);
+
+  // Make a copy of the result after assignment.
+  Tensor<T, NumDims, TensorLayout> slice_assigned = tensor;
+
+  for (Index i = 0; i < tensor.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(block_assigned.coeff(i), slice_assigned.coeff(i));
+  }
+}
+
+// -------------------------------------------------------------------------- //
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map, [&dims]() { return RandomBlock<Layout>(dims, 10, 20); });
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map, [&dims]() { return FixedSizeBlock(dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_reshape() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  DSizes<Index, NumDims> shuffled = dims;
+  std::shuffle(&shuffled[0], &shuffled[NumDims - 1], std::mt19937(g_seed));
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reshape(shuffled),
+                                            [&shuffled]() { return RandomBlock<Layout>(shuffled, 1, 10); });
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reshape(shuffled),
+                                            [&shuffled]() { return SkewedInnerBlock<Layout>(shuffled); });
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reshape(shuffled),
+                                            [&shuffled]() { return FixedSizeBlock(shuffled); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_chipping() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  Index chip_dim = internal::random<int>(0, NumDims - 1);
+  Index chip_offset = internal::random<Index>(0, dims[chip_dim] - 2);
+
+  DSizes<Index, NumDims - 1> chipped_dims;
+  for (Index i = 0; i < chip_dim; ++i) {
+    chipped_dims[i] = dims[i];
+  }
+  for (Index i = chip_dim + 1; i < NumDims; ++i) {
+    chipped_dims[i - 1] = dims[i];
+  }
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  VerifyBlockAssignment<T, NumDims, Layout, NumDims - 1>(
+      tensor, map.chip(chip_offset, chip_dim), [&chipped_dims]() { return RandomBlock<Layout>(chipped_dims, 1, 10); });
+
+  VerifyBlockAssignment<T, NumDims, Layout, NumDims - 1>(
+      tensor, map.chip(chip_offset, chip_dim), [&chipped_dims]() { return SkewedInnerBlock<Layout>(chipped_dims); });
+
+  VerifyBlockAssignment<T, NumDims, Layout, NumDims - 1>(tensor, map.chip(chip_offset, chip_dim),
+                                                         [&chipped_dims]() { return FixedSizeBlock(chipped_dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_slice() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  // Pick a random slice of tensor.
+  DSizes<Index, NumDims> slice_start = RandomDims<NumDims>(5, 10);
+  DSizes<Index, NumDims> slice_size = RandomDims<NumDims>(5, 10);
+
+  // Make sure that slice start + size do not overflow tensor dims.
+  for (int i = 0; i < NumDims; ++i) {
+    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
+    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
+  }
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.slice(slice_start, slice_size),
+                                            [&slice_size]() { return RandomBlock<Layout>(slice_size, 1, 10); });
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.slice(slice_start, slice_size),
+                                            [&slice_size]() { return SkewedInnerBlock<Layout>(slice_size); });
+
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.slice(slice_start, slice_size),
+                                            [&slice_size]() { return FixedSizeBlock(slice_size); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_shuffle() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  DSizes<Index, NumDims> shuffle;
+  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  do {
+    DSizes<Index, NumDims> shuffled_dims;
+    for (int i = 0; i < NumDims; ++i) shuffled_dims[i] = dims[shuffle[i]];
+
+    VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.shuffle(shuffle),
+                                              [&shuffled_dims]() { return FixedSizeBlock(shuffled_dims); });
+
+    VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.shuffle(shuffle),
+                                              [&shuffled_dims]() { return RandomBlock<Layout>(shuffled_dims, 1, 5); });
+
+  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_layout_swap() {
+  // The swap_layout lvalue has the opposite layout of the underlying tensor.
+  // static so the lambdas below can name it without capturing: MSVC 14.29
+  // rejects an uncaptured non-static constexpr local there (error C3493).
+  static constexpr int SwappedLayout = (Layout == ColMajor) ? RowMajor : ColMajor;
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  DSizes<Index, NumDims> swapped_dims;
+  for (int i = 0; i < NumDims; ++i) swapped_dims[i] = dims[NumDims - 1 - i];
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  VerifyBlockAssignment<T, NumDims, SwappedLayout>(
+      tensor, map.swap_layout(), [&swapped_dims]() { return RandomBlock<SwappedLayout>(swapped_dims, 1, 10); });
+
+  VerifyBlockAssignment<T, NumDims, SwappedLayout>(tensor, map.swap_layout(),
+                                                   [&swapped_dims]() { return FixedSizeBlock(swapped_dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_strided_slice() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  // Sweep unit, dilated, and negative strides; start/stop are chosen in-range
+  // so that clamping does not kick in.
+  const Index stride_choices[] = {1, 2, -1, -2};
+  for (const Index s : stride_choices) {
+    DSizes<Index, NumDims> start, stop, strides, out_dims;
+    for (int i = 0; i < NumDims; ++i) {
+      strides[i] = s;
+      if (s > 0) {
+        start[i] = 1;
+        stop[i] = dims[i] - 1;
+      } else {
+        start[i] = dims[i] - 2;
+        stop[i] = 0;
+      }
+      const Index interval = stop[i] - start[i];
+      out_dims[i] = interval / strides[i] + (interval % strides[i] != 0 ? 1 : 0);
+    }
+
+    VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.stridedSlice(start, stop, strides),
+                                              [&out_dims]() { return RandomBlock<Layout>(out_dims, 1, 5); });
+    VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.stridedSlice(start, stop, strides),
+                                              [&out_dims]() { return FixedSizeBlock(out_dims); });
+  }
+}
+
+// A lazy rhs expression has no raw buffer, so the tiled executor drives
+// writeBlock with a block expression: assigned directly into the destination
+// for a unit inner stride, and through a materialized temporary otherwise.
+// VerifyBlockAssignment cannot reach these paths because it always feeds
+// writeBlock a materialized block.
+template <typename T, int NumDims, int Layout>
+static void test_assign_expr_to_tensor_strided_slice() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  const Index stride_choices[] = {1, 2, -1, -2};
+  for (const Index s : stride_choices) {
+    DSizes<Index, NumDims> start, stop, strides, out_dims;
+    for (int i = 0; i < NumDims; ++i) {
+      strides[i] = s;
+      if (s > 0) {
+        start[i] = 1;
+        stop[i] = dims[i] - 1;
+      } else {
+        start[i] = dims[i] - 2;
+        stop[i] = 0;
+      }
+      const Index interval = stop[i] - start[i];
+      out_dims[i] = interval / strides[i] + (interval % strides[i] != 0 ? 1 : 0);
+    }
+
+    Tensor<T, NumDims, Layout> rhs(out_dims);
+    rhs.setRandom();
+
+    auto lhs_expr = map.stridedSlice(start, stop, strides);
+    auto rhs_expr = rhs + rhs.constant(T(1));
+    using Assign = TensorAssignOp<decltype(lhs_expr), const decltype(rhs_expr)>;
+
+    tensor.setZero();
+    TensorExecutor<const Assign, DefaultDevice, /*Vectorizable=*/true, internal::TiledEvaluation::On>::run(
+        Assign(lhs_expr, rhs_expr), DefaultDevice());
+    Tensor<T, NumDims, Layout> tiled = tensor;
+
+    tensor.setZero();
+    TensorExecutor<const Assign, DefaultDevice, /*Vectorizable=*/false, internal::TiledEvaluation::Off>::run(
+        Assign(lhs_expr, rhs_expr), DefaultDevice());
+
+    for (Index i = 0; i < tensor.size(); ++i) {
+      VERIFY_IS_EQUAL(tiled.coeff(i), tensor.coeff(i));
+    }
+  }
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_reverse() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  array<bool, NumDims> reverse;
+  for (int i = 0; i < NumDims; ++i) reverse[i] = false;
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reverse(reverse),
+                                            [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+
+  for (int i = 0; i < NumDims; ++i) reverse[i] = true;
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reverse(reverse),
+                                            [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reverse(reverse), [&dims]() { return FixedSizeBlock(dims); });
+
+  for (int i = 0; i < NumDims; ++i) reverse[i] = internal::random<bool>();
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reverse(reverse),
+                                            [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_roll() {
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
+  Tensor<T, NumDims, Layout> tensor(dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
+
+  array<Index, NumDims> rolls;
+  for (int i = 0; i < NumDims; ++i) rolls[i] = 0;
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.roll(rolls),
+                                            [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+
+  // Shifts beyond the dimension size and negative shifts must wrap.
+  for (int i = 0; i < NumDims; ++i) rolls[i] = internal::random<Index>(-2 * dims[i], 2 * dims[i]);
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.roll(rolls),
+                                            [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
+  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.roll(rolls), [&dims]() { return FixedSizeBlock(dims); });
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_assign_to_tensor_concatenation() {
+  // A concatenation writes into two operands, which VerifyBlockAssignment's
+  // single-tensor contract cannot express; compare writeBlock against a
+  // scalar reference instead. This is also the only place the RowMajor lvalue
+  // evaluator is instantiated: its coeffRef/writePacket are ColMajor-only, so
+  // a slice-assignment reference would not compile.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
+  const int axis = internal::random<int>(0, NumDims - 1);
+  const Index left_axis_size = internal::random<Index>(1, dims[axis] - 1);
+
+  DSizes<Index, NumDims> left_dims = dims;
+  left_dims[axis] = left_axis_size;
+  DSizes<Index, NumDims> right_dims = dims;
+  right_dims[axis] = dims[axis] - left_axis_size;
+
+  Tensor<T, NumDims, Layout> left(left_dims);
+  Tensor<T, NumDims, Layout> right(right_dims);
+
+  TensorMap<Tensor<T, NumDims, Layout>> left_map(left.data(), left_dims);
+  TensorMap<Tensor<T, NumDims, Layout>> right_map(right.data(), right_dims);
+
+  auto expr = left_map.concatenate(right_map, axis);
+  auto eval = TensorEvaluator<decltype(expr), DefaultDevice>(expr, DefaultDevice());
+
+  const DSizes<Index, NumDims> strides = internal::strides<Layout>(dims);
+
+  // Whether a block straddles the concat axis decides which of the two copies
+  // in writeBlock run, so pin all three cases instead of leaving it to chance:
+  // a random block, one that spans the seam, and one wholly in the right
+  // operand.
+  auto verify = [&](TensorBlockParams<NumDims> params) {
+    Tensor<T, NumDims, Layout> block(params.desc.dimensions());
+    block.setRandom();
+
+    left.setZero();
+    right.setZero();
+    internal::TensorMaterializedBlock<T, NumDims, Layout> blk(internal::TensorBlockKind::kView, block.data(),
+                                                              block.dimensions());
+    eval.writeBlock(params.desc, blk);
+
+    // Scalar reference: land every block coefficient in the expected operand.
+    Tensor<T, NumDims, Layout> expected_left(left_dims);
+    Tensor<T, NumDims, Layout> expected_right(right_dims);
+    expected_left.setZero();
+    expected_right.setZero();
+
+    DSizes<Index, NumDims> it;
+    for (int i = 0; i < NumDims; ++i) it[i] = 0;
+    for (Index count = 0; count < block.size(); ++count) {
+      array<Index, NumDims> dst;
+      for (int i = 0; i < NumDims; ++i) dst[i] = params.offsets[i] + it[i];
+      if (dst[axis] < left_axis_size) {
+        expected_left(dst) = block(it);
+      } else {
+        dst[axis] -= left_axis_size;
+        expected_right(dst) = block(it);
+      }
+      for (int i = 0; i < NumDims; ++i) {
+        if (++it[i] < params.desc.dimension(i)) break;
+        it[i] = 0;
+      }
+    }
+
+    for (Index i = 0; i < left.size(); ++i) VERIFY_IS_EQUAL(left.coeff(i), expected_left.coeff(i));
+    for (Index i = 0; i < right.size(); ++i) VERIFY_IS_EQUAL(right.coeff(i), expected_right.coeff(i));
+  };
+
+  // Builds the descriptor for an explicit offset/extent box.
+  auto make_params = [&](DSizes<Index, NumDims> offsets, DSizes<Index, NumDims> sizes) {
+    Index offset = 0;
+    for (int i = 0; i < NumDims; ++i) offset += strides[i] * offsets[i];
+    return TensorBlockParams<NumDims>{offsets, sizes, TensorBlockDescriptor<NumDims, Index>(offset, sizes)};
+  };
+
+  verify(RandomBlock<Layout>(dims, 1, 10));
+
+  // Straddling the seam: both the left and the right copy run.
+  {
+    DSizes<Index, NumDims> offsets;
+    DSizes<Index, NumDims> sizes;
+    for (int i = 0; i < NumDims; ++i) {
+      offsets[i] = 0;
+      sizes[i] = numext::mini(dims[i], Index(3));
+    }
+    offsets[axis] = left_axis_size - 1;
+    sizes[axis] = numext::mini(Index(2), dims[axis] - offsets[axis]);
+    verify(make_params(offsets, sizes));
+  }
+
+  // Wholly inside the right operand: only the right copy runs.
+  {
+    DSizes<Index, NumDims> offsets;
+    DSizes<Index, NumDims> sizes;
+    for (int i = 0; i < NumDims; ++i) {
+      offsets[i] = 0;
+      sizes[i] = numext::mini(dims[i], Index(3));
+    }
+    offsets[axis] = left_axis_size;
+    sizes[axis] = numext::mini(Index(2), dims[axis] - offsets[axis]);
+    verify(make_params(offsets, sizes));
+  }
+}
+
+// -------------------------------------------------------------------------- //
+
+#define CALL_SUBTEST_PART(PART) CALL_SUBTEST_##PART
+
+#define CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(PART, NAME)     \
+  CALL_SUBTEST_PART(PART)((NAME<float, 1, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 2, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 3, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 4, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 5, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 1, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 2, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 3, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 4, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 5, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<int, 1, RowMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 2, RowMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 3, RowMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 4, RowMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 5, RowMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 1, ColMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 2, ColMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 3, ColMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 4, ColMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<int, 5, ColMajor>()));   \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 1, RowMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 2, RowMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 3, RowMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 4, RowMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 5, RowMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 1, ColMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 2, ColMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 3, ColMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 4, ColMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, 5, ColMajor>()))
+
+#define CALL_SUBTESTS_DIMS_LAYOUTS(PART, NAME)           \
+  CALL_SUBTEST_PART(PART)((NAME<float, 1, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 2, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 3, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 4, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 5, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 1, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 2, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 3, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 4, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, 5, ColMajor>()))
+
+#define CALL_SUBTESTS_LAYOUTS_TYPES(PART, NAME)       \
+  CALL_SUBTEST_PART(PART)((NAME<float, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<bool, RowMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, ColMajor>()))
+
+EIGEN_DECLARE_TEST(tensor_block_eval) {
+  // clang-format off
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(1, test_eval_tensor_block);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(1, test_eval_tensor_binary_expr_block);
+  CALL_SUBTESTS_DIMS_LAYOUTS(1, test_eval_tensor_unary_expr_block);
+  CALL_SUBTESTS_DIMS_LAYOUTS(2, test_eval_tensor_binary_with_unary_expr_block);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(2, test_eval_tensor_broadcast);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(2, test_eval_tensor_reshape);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(2, test_eval_tensor_layout_swap);
+  CALL_SUBTEST_PART(2)((test_eval_tensor_scan<float, 2, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_scan<float, 3, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_scan<float, 4, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_scan<float, 2, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_scan<float, 3, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_scan<float, 4, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_fft<float, 2, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_fft<float, 3, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_fft<float, 4, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_fft<float, 2, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_fft<float, 3, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_tensor_fft<float, 4, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_composed_block_ops<float, 2, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_composed_block_ops<float, 3, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_composed_block_ops<float, 4, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_composed_block_ops<float, 2, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_composed_block_ops<float, 3, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_composed_block_ops<float, 4, ColMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_contract_pad_composition<float, RowMajor>()));
+  CALL_SUBTEST_PART(2)((test_eval_contract_pad_composition<float, ColMajor>()));
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_cast);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_nullary);
+  CALL_SUBTESTS_DIMS_LAYOUTS(3, test_eval_tensor_random_nullary);
+  CALL_SUBTESTS_DIMS_LAYOUTS(3, test_eval_tensor_indexed_nullary);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_select);
+  CALL_SUBTESTS_DIMS_LAYOUTS(3, test_eval_tensor_ternary);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_padding);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_chipping);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_concatenation);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_generator);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_reverse);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(5, test_eval_tensor_slice);
+  CALL_SUBTEST_PART(5)((test_eval_tensor_slice_bool_composite<1, RowMajor>()));
+  CALL_SUBTEST_PART(5)((test_eval_tensor_slice_bool_composite<2, RowMajor>()));
+  CALL_SUBTEST_PART(5)((test_eval_tensor_slice_bool_composite<3, RowMajor>()));
+  CALL_SUBTEST_PART(5)((test_eval_tensor_slice_bool_composite<1, ColMajor>()));
+  CALL_SUBTEST_PART(5)((test_eval_tensor_slice_bool_composite<2, ColMajor>()));
+  CALL_SUBTEST_PART(5)((test_eval_tensor_slice_bool_composite<3, ColMajor>()));
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(5, test_eval_tensor_shuffle);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(5, test_eval_tensor_strided_slice);
+
+  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_reshape_with_bcast);
+  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_forced_eval);
+  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_chipping_of_bcast);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(6, test_eval_tensor_inflation);
+  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_patch);
+  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_image_patch);
+  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_volume_patch);
+
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(7, test_assign_to_tensor);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(7, test_assign_to_tensor_reshape);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(7, test_assign_to_tensor_chipping);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_to_tensor_slice);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_to_tensor_shuffle);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_to_tensor_layout_swap);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_to_tensor_strided_slice);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_expr_to_tensor_strided_slice);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(9, test_assign_to_tensor_reverse);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(9, test_assign_to_tensor_roll);
+  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(9, test_assign_to_tensor_concatenation);
+
+  // Force CMake to split this test.
+  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8;9
+
+  // clang-format on
+}
diff --git a/contrib/test/tensor_block_io.cpp b/contrib/test/tensor_block_io.cpp
new file mode 100644
index 0000000..5a3efb6
--- /dev/null
+++ b/contrib/test/tensor_block_io.cpp
@@ -0,0 +1,593 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// clang-format off
+#include "main.h"
+#include <Eigen/Tensor>
+// clang-format on
+
+// -------------------------------------------------------------------------- //
+// A set of tests for TensorBlockIO: copying data between tensor blocks.
+
+template <int NumDims>
+static DSizes<Index, NumDims> RandomDims(Index min, Index max) {
+  DSizes<Index, NumDims> dims;
+  for (int i = 0; i < NumDims; ++i) {
+    dims[i] = internal::random<Index>(min, max);
+  }
+  return DSizes<Index, NumDims>(dims);
+}
+
+static internal::TensorBlockShapeType RandomBlockShape() {
+  return internal::random<bool>() ? internal::TensorBlockShapeType::kUniformAllDims
+                                  : internal::TensorBlockShapeType::kSkewedInnerDims;
+}
+
+template <int NumDims>
+static size_t RandomTargetBlockSize(const DSizes<Index, NumDims>& dims) {
+  return internal::random<size_t>(1, dims.TotalSize());
+}
+
+template <int Layout, int NumDims>
+static Index GetInputIndex(Index output_index, const array<Index, NumDims>& output_to_input_dim_map,
+                           const array<Index, NumDims>& input_strides, const array<Index, NumDims>& output_strides) {
+  int input_index = 0;
+  EIGEN_IF_CONSTEXPR (Layout == ColMajor) {
+    for (int i = NumDims - 1; i > 0; --i) {
+      const Index idx = output_index / output_strides[i];
+      input_index += idx * input_strides[output_to_input_dim_map[i]];
+      output_index -= idx * output_strides[i];
+    }
+    return input_index + output_index * input_strides[output_to_input_dim_map[0]];
+  } else {
+    for (int i = 0; i < NumDims - 1; ++i) {
+      const Index idx = output_index / output_strides[i];
+      input_index += idx * input_strides[output_to_input_dim_map[i]];
+      output_index -= idx * output_strides[i];
+    }
+    return input_index + output_index * input_strides[output_to_input_dim_map[NumDims - 1]];
+  }
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_block_io_copy_data_from_source_to_target() {
+  using TensorBlockIO = internal::TensorBlockIO<T, Index, NumDims, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  // Generate a random input Tensor.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 30);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // Write data to an output Tensor.
+  Tensor<T, NumDims, Layout> output(dims);
+
+  // Construct a tensor block mapper.
+  using TensorBlockMapper = internal::TensorBlockMapper<NumDims, Layout, Index>;
+  TensorBlockMapper block_mapper(dims, {RandomBlockShape(), RandomTargetBlockSize(dims), {0, 0, 0}});
+
+  // We will copy data from input to output through this buffer.
+  Tensor<T, NumDims, Layout> block(block_mapper.blockDimensions());
+
+  // Precompute strides for TensorBlockIO::Copy.
+  auto input_strides = internal::strides<Layout>(dims);
+  auto output_strides = internal::strides<Layout>(dims);
+
+  const T* input_data = input.data();
+  T* output_data = output.data();
+  T* block_data = block.data();
+
+  for (int i = 0; i < block_mapper.blockCount(); ++i) {
+    auto desc = block_mapper.blockDescriptor(i);
+
+    auto blk_dims = desc.dimensions();
+    auto blk_strides = internal::strides<Layout>(blk_dims);
+
+    {
+      // Read from input into a block buffer.
+      IODst dst(blk_dims, blk_strides, block_data, 0);
+      IOSrc src(input_strides, input_data, desc.offset());
+
+      TensorBlockIO::Copy(dst, src);
+    }
+
+    {
+      // Write from block buffer to output.
+      IODst dst(blk_dims, output_strides, output_data, desc.offset());
+      IOSrc src(blk_strides, block_data, 0);
+
+      TensorBlockIO::Copy(dst, src);
+    }
+  }
+
+  for (int i = 0; i < dims.TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(input_data[i], output_data[i]);
+  }
+}
+
+template <typename T, int NumDims, int Layout>
+static void test_block_io_copy_using_reordered_dimensions() {
+  // Generate a random input Tensor.
+  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 30);
+  Tensor<T, NumDims, Layout> input(dims);
+  input.setRandom();
+
+  // Create a random dimension re-ordering/shuffle.
+  std::vector<int> shuffle;
+
+  for (int i = 0; i < NumDims; ++i) shuffle.push_back(i);
+  std::shuffle(shuffle.begin(), shuffle.end(), std::mt19937(g_seed));
+
+  DSizes<Index, NumDims> output_tensor_dims;
+  DSizes<Index, NumDims> input_to_output_dim_map;
+  DSizes<Index, NumDims> output_to_input_dim_map;
+  for (Index i = 0; i < NumDims; ++i) {
+    output_tensor_dims[shuffle[i]] = dims[i];
+    input_to_output_dim_map[i] = shuffle[i];
+    output_to_input_dim_map[shuffle[i]] = i;
+  }
+
+  // Write data to an output Tensor.
+  Tensor<T, NumDims, Layout> output(output_tensor_dims);
+
+  // Construct a tensor block mapper.
+  // NOTE: Tensor block mapper works with shuffled dimensions.
+  using TensorBlockMapper = internal::TensorBlockMapper<NumDims, Layout, Index>;
+  TensorBlockMapper block_mapper(output_tensor_dims,
+                                 {RandomBlockShape(), RandomTargetBlockSize(output_tensor_dims), {0, 0, 0}});
+
+  // We will copy data from input to output through this buffer.
+  Tensor<T, NumDims, Layout> block(block_mapper.blockDimensions());
+
+  // Precompute strides for TensorBlockIO::Copy.
+  auto input_strides = internal::strides<Layout>(dims);
+  auto output_strides = internal::strides<Layout>(output_tensor_dims);
+
+  const T* input_data = input.data();
+  T* output_data = output.data();
+  T* block_data = block.data();
+
+  for (Index i = 0; i < block_mapper.blockCount(); ++i) {
+    auto desc = block_mapper.blockDescriptor(i);
+
+    const Index first_coeff_index =
+        GetInputIndex<Layout, NumDims>(desc.offset(), output_to_input_dim_map, input_strides, output_strides);
+
+    // NOTE: Block dimensions are in the same order as output dimensions.
+
+    using TensorBlockIO = internal::TensorBlockIO<T, Index, NumDims, Layout>;
+    using IODst = typename TensorBlockIO::Dst;
+    using IOSrc = typename TensorBlockIO::Src;
+
+    auto blk_dims = desc.dimensions();
+    auto blk_strides = internal::strides<Layout>(blk_dims);
+
+    {
+      // Read from input into a block buffer.
+      IODst dst(blk_dims, blk_strides, block_data, 0);
+      IOSrc src(input_strides, input_data, first_coeff_index);
+
+      // TODO(ezhulenev): Remove when fully switched to TensorBlock.
+      DSizes<int, NumDims> dim_map;
+      for (int j = 0; j < NumDims; ++j) dim_map[j] = static_cast<int>(output_to_input_dim_map[j]);
+      TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/dim_map);
+    }
+
+    {
+      // We need to convert block dimensions from output to input order.
+      auto dst_dims = blk_dims;
+      for (int out_dim = 0; out_dim < NumDims; ++out_dim) {
+        dst_dims[output_to_input_dim_map[out_dim]] = blk_dims[out_dim];
+      }
+
+      // Write from block buffer to output.
+      IODst dst(dst_dims, input_strides, output_data, first_coeff_index);
+      IOSrc src(blk_strides, block_data, 0);
+
+      // TODO(ezhulenev): Remove when fully switched to TensorBlock.
+      DSizes<int, NumDims> dim_map;
+      for (int j = 0; j < NumDims; ++j) dim_map[j] = static_cast<int>(input_to_output_dim_map[j]);
+      TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/dim_map);
+    }
+  }
+
+  for (Index i = 0; i < dims.TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(input_data[i], output_data[i]);
+  }
+}
+
+// This is the special case for reading data with reordering, when dimensions
+// before/after reordering are the same. Squeezing reads along inner dimensions
+// in this case is illegal, because we reorder innermost dimension.
+template <int Layout>
+static void test_block_io_copy_using_reordered_dimensions_do_not_squeeze() {
+  DSizes<Index, 3> tensor_dims(7, 9, 7);
+  DSizes<Index, 3> block_dims = tensor_dims;
+
+  DSizes<int, 3> block_to_tensor_dim;
+  block_to_tensor_dim[0] = 2;
+  block_to_tensor_dim[1] = 1;
+  block_to_tensor_dim[2] = 0;
+
+  auto tensor_strides = internal::strides<Layout>(tensor_dims);
+  auto block_strides = internal::strides<Layout>(block_dims);
+
+  Tensor<float, 3, Layout> block(block_dims);
+  Tensor<float, 3, Layout> tensor(tensor_dims);
+  tensor.setRandom();
+
+  float* tensor_data = tensor.data();
+  float* block_data = block.data();
+
+  using TensorBlockIO = internal::TensorBlockIO<float, Index, 3, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  // Read from a tensor into a block.
+  IODst dst(block_dims, block_strides, block_data, 0);
+  IOSrc src(tensor_strides, tensor_data, 0);
+
+  TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/block_to_tensor_dim);
+
+  TensorMap<Tensor<float, 3, Layout> > block_tensor(block_data, block_dims);
+  TensorMap<Tensor<float, 3, Layout> > tensor_tensor(tensor_data, tensor_dims);
+
+  for (Index d0 = 0; d0 < tensor_dims[0]; ++d0) {
+    for (Index d1 = 0; d1 < tensor_dims[1]; ++d1) {
+      for (Index d2 = 0; d2 < tensor_dims[2]; ++d2) {
+        float block_value = block_tensor(d2, d1, d0);
+        float tensor_value = tensor_tensor(d0, d1, d2);
+        VERIFY_IS_EQUAL(block_value, tensor_value);
+      }
+    }
+  }
+}
+
+// This is the special case for reading data with reordering, when dimensions
+// before/after reordering are the same. Squeezing reads in this case is allowed
+// because we reorder outer dimensions.
+template <int Layout>
+static void test_block_io_copy_using_reordered_dimensions_squeeze() {
+  DSizes<Index, 4> tensor_dims(7, 5, 9, 9);
+  DSizes<Index, 4> block_dims = tensor_dims;
+
+  DSizes<int, 4> block_to_tensor_dim;
+  block_to_tensor_dim[0] = 0;
+  block_to_tensor_dim[1] = 1;
+  block_to_tensor_dim[2] = 3;
+  block_to_tensor_dim[3] = 2;
+
+  auto tensor_strides = internal::strides<Layout>(tensor_dims);
+  auto block_strides = internal::strides<Layout>(block_dims);
+
+  Tensor<float, 4, Layout> block(block_dims);
+  Tensor<float, 4, Layout> tensor(tensor_dims);
+  tensor.setRandom();
+
+  float* tensor_data = tensor.data();
+  float* block_data = block.data();
+
+  using TensorBlockIO = internal::TensorBlockIO<float, Index, 4, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  // Read from a tensor into a block.
+  IODst dst(block_dims, block_strides, block_data, 0);
+  IOSrc src(tensor_strides, tensor_data, 0);
+
+  TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/block_to_tensor_dim);
+
+  TensorMap<Tensor<float, 4, Layout> > block_tensor(block_data, block_dims);
+  TensorMap<Tensor<float, 4, Layout> > tensor_tensor(tensor_data, tensor_dims);
+
+  for (Index d0 = 0; d0 < tensor_dims[0]; ++d0) {
+    for (Index d1 = 0; d1 < tensor_dims[1]; ++d1) {
+      for (Index d2 = 0; d2 < tensor_dims[2]; ++d2) {
+        for (Index d3 = 0; d3 < tensor_dims[3]; ++d3) {
+          float block_value = block_tensor(d0, d1, d3, d2);
+          float tensor_value = tensor_tensor(d0, d1, d2, d3);
+          VERIFY_IS_EQUAL(block_value, tensor_value);
+        }
+      }
+    }
+  }
+}
+
+template <int Layout>
+static void test_block_io_zero_stride() {
+  DSizes<Index, 5> rnd_dims = RandomDims<5>(1, 30);
+
+  DSizes<Index, 5> input_tensor_dims = rnd_dims;
+  input_tensor_dims[0] = 1;
+  input_tensor_dims[2] = 1;
+  input_tensor_dims[4] = 1;
+
+  Tensor<float, 5, Layout> input(input_tensor_dims);
+  input.setRandom();
+
+  DSizes<Index, 5> output_tensor_dims = rnd_dims;
+
+  auto input_tensor_strides = internal::strides<Layout>(input_tensor_dims);
+  auto output_tensor_strides = internal::strides<Layout>(output_tensor_dims);
+
+  auto input_tensor_strides_with_zeros = input_tensor_strides;
+  input_tensor_strides_with_zeros[0] = 0;
+  input_tensor_strides_with_zeros[2] = 0;
+  input_tensor_strides_with_zeros[4] = 0;
+
+  Tensor<float, 5, Layout> output(output_tensor_dims);
+  output.setRandom();
+
+  using TensorBlockIO = internal::TensorBlockIO<float, Index, 5, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  // Write data from input to output with broadcasting in dims [0, 2, 4].
+  IODst dst(output_tensor_dims, output_tensor_strides, output.data(), 0);
+  IOSrc src(input_tensor_strides_with_zeros, input.data(), 0);
+  TensorBlockIO::Copy(dst, src);
+
+  for (int i = 0; i < output_tensor_dims[0]; ++i) {
+    for (int j = 0; j < output_tensor_dims[1]; ++j) {
+      for (int k = 0; k < output_tensor_dims[2]; ++k) {
+        for (int l = 0; l < output_tensor_dims[3]; ++l) {
+          for (int m = 0; m < output_tensor_dims[4]; ++m) {
+            float input_value = input(0, j, 0, l, 0);
+            float output_value = output(i, j, k, l, m);
+            VERIFY_IS_EQUAL(input_value, output_value);
+          }
+        }
+      }
+    }
+  }
+}
+
+template <int Layout>
+static void test_block_io_squeeze_ones() {
+  using TensorBlockIO = internal::TensorBlockIO<float, Index, 5, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  // Total size > 1.
+  {
+    DSizes<Index, 5> block_sizes(1, 2, 1, 2, 1);
+    auto strides = internal::strides<Layout>(block_sizes);
+
+    // Create a random input tensor.
+    Tensor<float, 5> input(block_sizes);
+    input.setRandom();
+
+    Tensor<float, 5> output(block_sizes);
+
+    IODst dst(block_sizes, strides, output.data(), 0);
+    IOSrc src(strides, input.data());
+    TensorBlockIO::Copy(dst, src);
+
+    for (Index i = 0; i < block_sizes.TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(output.data()[i], input.data()[i]);
+    }
+  }
+
+  // Total size == 1.
+  {
+    DSizes<Index, 5> block_sizes(1, 1, 1, 1, 1);
+    auto strides = internal::strides<Layout>(block_sizes);
+
+    // Create a random input tensor.
+    Tensor<float, 5> input(block_sizes);
+    input.setRandom();
+
+    Tensor<float, 5> output(block_sizes);
+
+    IODst dst(block_sizes, strides, output.data(), 0);
+    IOSrc src(strides, input.data());
+    TensorBlockIO::Copy(dst, src);
+
+    for (Index i = 0; i < block_sizes.TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(output.data()[i], input.data()[i]);
+    }
+  }
+}
+
+#define CALL_SUBTESTS(NAME)                   \
+  CALL_SUBTEST((NAME<float, 1, RowMajor>())); \
+  CALL_SUBTEST((NAME<float, 2, RowMajor>())); \
+  CALL_SUBTEST((NAME<float, 4, RowMajor>())); \
+  CALL_SUBTEST((NAME<float, 5, RowMajor>())); \
+  CALL_SUBTEST((NAME<float, 1, ColMajor>())); \
+  CALL_SUBTEST((NAME<float, 2, ColMajor>())); \
+  CALL_SUBTEST((NAME<float, 4, ColMajor>())); \
+  CALL_SUBTEST((NAME<float, 5, ColMajor>())); \
+  CALL_SUBTEST((NAME<bool, 1, RowMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 2, RowMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 4, RowMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 5, RowMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 1, ColMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 2, ColMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 4, ColMajor>()));  \
+  CALL_SUBTEST((NAME<bool, 5, ColMajor>()))
+
+// The inner dimensions may only be squeezed into one run while the elements
+// keep forming a single arithmetic progression at the inner stride on both
+// sides. A reversed inner dimension under a forward outer dimension is the
+// case where the outer strides match but the progressions do not, so squeezing
+// there would walk backwards out of the source.
+template <int Layout>
+static void test_block_io_negative_inner_stride_do_not_squeeze() {
+  using TensorBlockIO = internal::TensorBlockIO<float, Index, 2, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  const Index inner = 8;
+  const Index outer = 4;
+  DSizes<Index, 2> block_sizes = (static_cast<int>(Layout) == static_cast<int>(ColMajor))
+                                     ? DSizes<Index, 2>(inner, outer)
+                                     : DSizes<Index, 2>(outer, inner);
+
+  // Pad the front of the source so that a wrongly squeezed run reads defined
+  // (but incorrect) values instead of running off the allocation.
+  Tensor<float, 1> padded(2 * inner * outer);
+  padded.setRandom();
+  const float* input = padded.data() + inner * outer;
+
+  Tensor<float, 1> output(inner * outer);
+  output.setZero();
+
+  const Index inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : 1;
+  const Index outer_dim = 1 - inner_dim;
+
+  // Source walks the inner dimension backwards, the outer dimension forwards.
+  DSizes<Index, 2> src_strides;
+  src_strides[inner_dim] = -1;
+  src_strides[outer_dim] = inner;
+  const Index src_offset = inner - 1;
+
+  const DSizes<Index, 2> dst_strides = internal::strides<Layout>(block_sizes);
+  IODst dst(block_sizes, dst_strides, output.data(), 0);
+  IOSrc src(src_strides, input, src_offset);
+  TensorBlockIO::Copy(dst, src);
+
+  for (Index o = 0; o < outer; ++o) {
+    for (Index i = 0; i < inner; ++i) {
+      const float expected = input[src_offset + o * src_strides[outer_dim] + i * src_strides[inner_dim]];
+      const float actual = output.data()[o * dst_strides[outer_dim] + i * dst_strides[inner_dim]];
+      VERIFY_IS_EQUAL(actual, expected);
+    }
+  }
+}
+
+// A unit-magnitude negative stride on one or both sides is copied with a
+// packet reversal rather than element-by-element. Sweep the run length so the
+// full-packet body, the half-packet step and the scalar tail are all covered
+// for every scalar width, with and without an outer dimension to iterate.
+template <typename Scalar, int Layout>
+static void test_block_io_reversed_inner_runs() {
+  using TensorBlockIO = internal::TensorBlockIO<Scalar, Index, 2, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  const Index inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : 1;
+  const Index outer_dim = 1 - inner_dim;
+
+  // `outer == 1` leaves the block iterator empty, so the copy is a single run.
+  for (Index outer : {Index(1), Index(3)}) {
+    // Lengths straddling the packet and half-packet boundaries of every width.
+    for (Index inner = 1; inner <= 40; ++inner) {
+      DSizes<Index, 2> block_sizes;
+      block_sizes[inner_dim] = inner;
+      block_sizes[outer_dim] = outer;
+
+      Tensor<Scalar, 1> input(inner * outer);
+      input.setRandom();
+      const DSizes<Index, 2> dense = internal::strides<Layout>(block_sizes);
+
+      // reversed destination, forward source; forward destination, reversed
+      // source; and both reversed.
+      for (int variant = 0; variant < 3; ++variant) {
+        const bool rev_dst = (variant != 1);
+        const bool rev_src = (variant != 0);
+
+        Tensor<Scalar, 1> output(inner * outer);
+        output.setZero();
+
+        DSizes<Index, 2> src_strides = dense, dst_strides = dense;
+        src_strides[inner_dim] = rev_src ? -1 : 1;
+        dst_strides[inner_dim] = rev_dst ? -1 : 1;
+        const Index src_offset = rev_src ? inner - 1 : 0;
+        const Index dst_offset = rev_dst ? inner - 1 : 0;
+
+        IODst dst(block_sizes, dst_strides, output.data(), dst_offset);
+        IOSrc src(src_strides, input.data(), src_offset);
+        TensorBlockIO::Copy(dst, src);
+
+        for (Index o = 0; o < outer; ++o) {
+          for (Index i = 0; i < inner; ++i) {
+            const Scalar expected = input.data()[src_offset + o * src_strides[outer_dim] + i * src_strides[inner_dim]];
+            const Scalar actual = output.data()[dst_offset + o * dst_strides[outer_dim] + i * dst_strides[inner_dim]];
+            VERIFY_IS_EQUAL(actual, expected);
+          }
+        }
+      }
+    }
+  }
+}
+
+// Conversely, a uniformly dilated source does keep one progression across the
+// dimension boundary, so it must squeeze and still copy the right elements.
+template <int Layout>
+static void test_block_io_dilated_inner_stride_squeeze() {
+  using TensorBlockIO = internal::TensorBlockIO<float, Index, 2, Layout>;
+  using IODst = typename TensorBlockIO::Dst;
+  using IOSrc = typename TensorBlockIO::Src;
+
+  const Index inner = 8;
+  const Index outer = 4;
+  const Index dilation = 2;
+  DSizes<Index, 2> block_sizes = (static_cast<int>(Layout) == static_cast<int>(ColMajor))
+                                     ? DSizes<Index, 2>(inner, outer)
+                                     : DSizes<Index, 2>(outer, inner);
+
+  Tensor<float, 1> input(dilation * inner * outer);
+  input.setRandom();
+
+  Tensor<float, 1> output(inner * outer);
+  output.setZero();
+
+  const Index inner_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : 1;
+  const Index outer_dim = 1 - inner_dim;
+
+  DSizes<Index, 2> src_strides;
+  src_strides[inner_dim] = dilation;
+  src_strides[outer_dim] = dilation * inner;
+
+  const DSizes<Index, 2> dst_strides = internal::strides<Layout>(block_sizes);
+  IODst dst(block_sizes, dst_strides, output.data(), 0);
+  IOSrc src(src_strides, input.data(), 0);
+  TensorBlockIO::Copy(dst, src);
+
+  for (Index o = 0; o < outer; ++o) {
+    for (Index i = 0; i < inner; ++i) {
+      const float expected = input.data()[o * src_strides[outer_dim] + i * src_strides[inner_dim]];
+      const float actual = output.data()[o * dst_strides[outer_dim] + i * dst_strides[inner_dim]];
+      VERIFY_IS_EQUAL(actual, expected);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_block_io) {
+  // clang-format off
+  CALL_SUBTESTS(test_block_io_copy_data_from_source_to_target);
+  CALL_SUBTESTS(test_block_io_copy_using_reordered_dimensions);
+
+  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_do_not_squeeze<RowMajor>());
+  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_do_not_squeeze<ColMajor>());
+
+  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_squeeze<RowMajor>());
+  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_squeeze<ColMajor>());
+
+  CALL_SUBTEST(test_block_io_zero_stride<RowMajor>());
+  CALL_SUBTEST(test_block_io_zero_stride<ColMajor>());
+
+  CALL_SUBTEST(test_block_io_squeeze_ones<RowMajor>());
+  CALL_SUBTEST(test_block_io_squeeze_ones<ColMajor>());
+
+  CALL_SUBTEST(test_block_io_negative_inner_stride_do_not_squeeze<RowMajor>());
+  CALL_SUBTEST(test_block_io_negative_inner_stride_do_not_squeeze<ColMajor>());
+  CALL_SUBTEST((test_block_io_reversed_inner_runs<float, RowMajor>()));
+  CALL_SUBTEST((test_block_io_reversed_inner_runs<float, ColMajor>()));
+  CALL_SUBTEST((test_block_io_reversed_inner_runs<double, RowMajor>()));
+  CALL_SUBTEST((test_block_io_reversed_inner_runs<double, ColMajor>()));
+  CALL_SUBTEST((test_block_io_reversed_inner_runs<int, ColMajor>()));
+  CALL_SUBTEST((test_block_io_reversed_inner_runs<bool, ColMajor>()));
+
+  CALL_SUBTEST(test_block_io_dilated_inner_stride_squeeze<RowMajor>());
+  CALL_SUBTEST(test_block_io_dilated_inner_stride_squeeze<ColMajor>());
+  // clang-format on
+}
diff --git a/contrib/test/tensor_block_view.cpp b/contrib/test/tensor_block_view.cpp
new file mode 100644
index 0000000..1bd79b2
--- /dev/null
+++ b/contrib/test/tensor_block_view.cpp
@@ -0,0 +1,260 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+template <typename Evaluator, typename TensorType, std::enable_if_t<Evaluator::PacketAccess, int> = 0>
+static void check_view_packets(const Evaluator& evaluator, const TensorType& expected) {
+  using Scalar = typename TensorType::Scalar;
+  constexpr int PacketSize = PacketType<Scalar, DefaultDevice>::size;
+  Scalar values[PacketSize];
+  for (Index i = 0; i + PacketSize <= expected.size(); ++i) {
+    internal::pstoreu(values, evaluator.template packet<Unaligned>(i));
+    for (int k = 0; k < PacketSize; ++k) VERIFY_IS_EQUAL(values[k], expected.data()[i + k]);
+  }
+}
+
+template <typename Evaluator, typename TensorType, std::enable_if_t<!Evaluator::PacketAccess, int> = 0>
+static void check_view_packets(const Evaluator&, const TensorType&) {}
+
+template <typename Scalar, int Layout>
+static void test_strided_view() {
+  using TensorType = Tensor<Scalar, 3, Layout>;
+  using Dimensions = DSizes<Index, 3>;
+  using Evaluator = TensorEvaluator<const TensorType, DefaultDevice>;
+  DefaultDevice device;
+  TensorType input(23, 19, 11);
+  for (Index i = 0; i < input.size(); ++i) input.data()[i] = Scalar(i % 97);
+  Evaluator evaluator(input, device);
+  internal::TensorBlockScratchAllocator<DefaultDevice> scratch(device);
+  const Index full_inner = Layout == ColMajor ? 23 : 11;
+  for (Index inner : {Index(1), Index(3), Index(5), Index(9), full_inner}) {
+    Dimensions offsets(2, 3, 1);
+    if (inner == full_inner) offsets[Layout == ColMajor ? 0 : 2] = 0;
+    const Index offset =
+        Layout == ColMajor ? input.dimensions().IndexOfColMajor(offsets) : input.dimensions().IndexOfRowMajor(offsets);
+    const Dimensions sizes = Layout == ColMajor ? Dimensions(inner, 7, 3) : Dimensions(3, 7, inner);
+    internal::TensorBlockDescriptor<3> desc(offset, sizes);
+    auto block = evaluator.block(desc, scratch);
+    VERIFY_IS_EQUAL(block.kind(), internal::TensorBlockKind::kView);
+    VERIFY(block.data() == nullptr);
+
+    TensorType expected(sizes);
+    for (Index k = 0; k < sizes[2]; ++k)
+      for (Index j = 0; j < sizes[1]; ++j)
+        for (Index i = 0; i < sizes[0]; ++i) expected(i, j, k) = input(i + offsets[0], j + offsets[1], k + offsets[2]);
+
+    using BlockExpr = typename Evaluator::TensorBlock::XprType;
+    TensorEvaluator<const BlockExpr, DefaultDevice> block_eval(block.expr(), device);
+    for (Index i = 0; i < expected.size(); ++i) VERIFY_IS_EQUAL(block_eval.coeff(i), expected.data()[i]);
+    check_view_packets(block_eval, expected);
+
+    TensorType output(sizes);
+    using Assignment = internal::TensorBlockAssignment<Scalar, 3, BlockExpr>;
+    Assignment::Run(Assignment::target(sizes, internal::strides<Layout>(sizes), output.data()), block.expr());
+    for (Index i = 0; i < output.size(); ++i) VERIFY_IS_EQUAL(output.data()[i], expected.data()[i]);
+
+    const Scalar saved = input.data()[offset];
+    input.data()[offset] = Scalar(101);
+    VERIFY_IS_EQUAL(block_eval.coeff(0), Scalar(101));
+    input.data()[offset] = saved;
+    block.cleanup();
+    scratch.reset();
+  }
+
+  const Dimensions sizes = Layout == ColMajor ? Dimensions(23, 4, 1) : Dimensions(1, 4, 11);
+  internal::TensorBlockDescriptor<3> desc(0, sizes);
+  auto block = evaluator.block(desc, scratch);
+  VERIFY_IS_EQUAL(block.kind(), internal::TensorBlockKind::kView);
+  VERIFY(block.data() == input.data());
+  block.cleanup();
+}
+
+struct BlockViewCounter {
+  mutable Index calls = 0;
+  float operator()(float value) const { return value + float(calls++); }
+};
+
+template <bool Vectorized>
+struct BlockViewRvalueFunctor {
+  using Packet = typename internal::packet_traits<float>::type;
+  float operator()(float&& value) const { return value + 1.0f; }
+  Packet packetOp(Packet&& value) const { return internal::padd(value, internal::pset1<Packet>(1.0f)); }
+};
+
+template <bool Vectorized>
+struct BlockViewOverloadedFunctor : BlockViewRvalueFunctor<Vectorized> {
+  using Base = BlockViewRvalueFunctor<Vectorized>;
+  using Packet = typename Base::Packet;
+  using Base::operator();
+  using Base::packetOp;
+  float operator()(const float& value) const { return value + 2.0f; }
+  Packet packetOp(const Packet& value) const { return internal::padd(value, internal::pset1<Packet>(2.0f)); }
+};
+
+namespace Eigen {
+namespace internal {
+template <bool Vectorized>
+struct functor_traits<BlockViewRvalueFunctor<Vectorized>> {
+  static constexpr int Cost = NumTraits<float>::AddCost;
+  static constexpr bool PacketAccess = Vectorized && packet_traits<float>::Vectorizable;
+};
+template <bool Vectorized>
+struct functor_traits<BlockViewOverloadedFunctor<Vectorized>> : functor_traits<BlockViewRvalueFunctor<Vectorized>> {};
+}  // namespace internal
+}  // namespace Eigen
+
+template <int Layout, bool Vectorized, typename Device>
+static void test_view_functor_forwarding(const Device& device) {
+  using TensorType = Tensor<float, 2, Layout>;
+  const Index rows = 129, cols = 193;
+  TensorType input(cols, rows), bias(rows, cols), output(rows, cols);
+  for (Index j = 0; j < cols; ++j) {
+    for (Index i = 0; i < rows; ++i) {
+      input(j, i) = float((i * 3 + j) % 17);
+      bias(i, j) = float((i + j * 7) % 13);
+    }
+  }
+  const array<int, 2> transpose{{1, 0}};
+  const auto check = [&](const auto& functor) {
+    auto expression = input.shuffle(transpose) + bias.unaryExpr(functor);
+    // MSVC 19.29 treats decltype(output) as a reference inside this generic lambda.
+    using Assign = TensorAssignOp<TensorType, const decltype(expression)>;
+    static_assert(internal::IsTileable<Device, const Assign>::value == internal::TiledEvaluation::On,
+                  "Functor forwarding must reach block evaluation");
+    static_assert(internal::IsVectorizable<Device, const Assign>::value ==
+                      (Vectorized && internal::packet_traits<float>::Vectorizable),
+                  "Exercise both scalar and packet functor forwarding");
+    output.device(device) = expression;
+    for (Index j = 0; j < cols; ++j)
+      for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(output(i, j), input(j, i) + bias(i, j) + 1.0f);
+  };
+  check(BlockViewRvalueFunctor<Vectorized>());
+  check(BlockViewOverloadedFunctor<Vectorized>());
+}
+
+template <int Layout>
+static void test_view_functor_state(bool dense_source) {
+  Tensor<float, 2, Layout> input(dense_source ? 7 : 23, dense_source ? 9 : 19), output(23, 19);
+  const DSizes<Index, 2> sizes(7, 9);
+  input.setZero();
+  DefaultDevice device;
+  TensorEvaluator<const decltype(input), DefaultDevice> evaluator(input, device);
+  internal::TensorBlockScratchAllocator<DefaultDevice> scratch(device);
+  internal::TensorBlockDescriptor<2> desc(0, sizes);
+  auto block = evaluator.block(desc, scratch);
+  auto expression = block.expr().unaryExpr(BlockViewCounter());
+  using Assignment = internal::TensorBlockAssignment<float, 2, decltype(expression)>;
+  Assignment::Run(Assignment::target(sizes, internal::strides<Layout>(output.dimensions()), output.data()), expression);
+  for (Index j = 0; j < sizes[1]; ++j)
+    for (Index i = 0; i < sizes[0]; ++i)
+      VERIFY_IS_EQUAL(output(i, j), float(Layout == ColMajor ? i + sizes[0] * j : j + sizes[1] * i));
+  block.cleanup();
+}
+
+template <int Layout, typename Device>
+static void test_view_compositions(const Device& device) {
+  const Index rows = 129, cols = 193;
+  Tensor<float, 2, Layout> input(cols, rows), bias(rows, cols), output(rows, cols);
+  Tensor<bool, 2, Layout> condition(rows, cols);
+  for (Index j = 0; j < cols; ++j) {
+    for (Index i = 0; i < rows; ++i) {
+      input(j, i) = float((i * 3 + j) % 17);
+      bias(i, j) = float((i + j * 7) % 13);
+      condition(i, j) = (i + j) % 2 == 0;
+    }
+  }
+  const array<int, 2> transpose{{1, 0}};
+  auto expression = input.shuffle(transpose) + bias;
+  using Assign = TensorAssignOp<decltype(output), const decltype(expression)>;
+  static_assert(internal::IsTileable<Device, const Assign>::value == internal::TiledEvaluation::On,
+                "Shuffle and bias must reach block evaluation");
+  output.device(device) = expression;
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(output(i, j), input(j, i) + bias(i, j));
+
+  output.device(device) = condition.select(expression.square() + 2.0f, bias);
+  for (Index j = 0; j < cols; ++j) {
+    for (Index i = 0; i < rows; ++i) {
+      const float sum = input(j, i) + bias(i, j);
+      VERIFY_IS_EQUAL(output(i, j), condition(i, j) ? sum * sum + 2.0f : bias(i, j));
+    }
+  }
+
+  Tensor<double, 2, Layout> converted(rows, cols);
+  converted.device(device) = expression.template cast<double>();
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(converted(i, j), double(input(j, i) + bias(i, j)));
+
+  output.device(device) = expression + bias.constant(3.0f);
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(output(i, j), input(j, i) + bias(i, j) + 3.0f);
+
+  const auto add_three = [](float a, float b, float c) { return a + b + c; };
+  const TensorCwiseTernaryOp<decltype(add_three), const decltype(expression), const decltype(bias),
+                             const decltype(bias)>
+      ternary(expression, bias, bias, add_three);
+  output.device(device) = ternary;
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(output(i, j), input(j, i) + 3.0f * bias(i, j));
+
+  Tensor<float, 2, Layout == ColMajor ? RowMajor : ColMajor> swapped(cols, rows);
+  swapped.device(device) = expression.swap_layout();
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(swapped(j, i), input(j, i) + bias(i, j));
+
+  bias.device(device) = expression;
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(bias(i, j), input(j, i) + float((i + j * 7) % 13));
+}
+
+static void test_scalar_and_empty_views() {
+  DefaultDevice device;
+  internal::TensorBlockScratchAllocator<DefaultDevice> scratch(device);
+  float value = 3.0f;
+  using ScalarBlock = internal::TensorMaterializedBlock<float, 0, ColMajor>;
+  internal::TensorBlockDescriptor<0> scalar_desc(0, DSizes<Index, 0>());
+  auto block = ScalarBlock::materialize(&value, DSizes<Index, 0>(), scalar_desc, scratch);
+  Tensor<float, 0> scalar = block.expr();
+  VERIFY_IS_EQUAL(scalar(), value);
+  block.cleanup();
+
+  Tensor<float, 2> input(0, 3), bias(3, 0), output(3, 0);
+  output = input.shuffle(array<int, 2>{{1, 0}}) + bias;
+  VERIFY_IS_EQUAL(output.size(), 0);
+}
+
+EIGEN_DECLARE_TEST(tensor_block_view) {
+  CALL_SUBTEST((test_strided_view<float, ColMajor>()));
+  CALL_SUBTEST((test_strided_view<float, RowMajor>()));
+  CALL_SUBTEST((test_strided_view<double, ColMajor>()));
+  CALL_SUBTEST((test_strided_view<double, RowMajor>()));
+  CALL_SUBTEST((test_strided_view<int, ColMajor>()));
+  CALL_SUBTEST((test_strided_view<int, RowMajor>()));
+  CALL_SUBTEST((test_strided_view<std::complex<float>, ColMajor>()));
+  CALL_SUBTEST((test_strided_view<std::complex<float>, RowMajor>()));
+  for (bool dense_source : {false, true}) {
+    CALL_SUBTEST((test_view_functor_state<ColMajor>(dense_source)));
+    CALL_SUBTEST((test_view_functor_state<RowMajor>(dense_source)));
+  }
+  DefaultDevice device;
+  CALL_SUBTEST((test_view_functor_forwarding<ColMajor, false>(device)));
+  CALL_SUBTEST((test_view_functor_forwarding<RowMajor, false>(device)));
+  CALL_SUBTEST((test_view_functor_forwarding<ColMajor, true>(device)));
+  CALL_SUBTEST((test_view_functor_forwarding<RowMajor, true>(device)));
+  CALL_SUBTEST((test_view_compositions<ColMajor>(device)));
+  CALL_SUBTEST((test_view_compositions<RowMajor>(device)));
+  ThreadPool pool(4);
+  for (int threads : {1, 4}) {
+    ThreadPoolDevice threaded_device(&pool, threads);
+    CALL_SUBTEST((test_view_functor_forwarding<ColMajor, false>(threaded_device)));
+    CALL_SUBTEST((test_view_functor_forwarding<RowMajor, false>(threaded_device)));
+    CALL_SUBTEST((test_view_functor_forwarding<ColMajor, true>(threaded_device)));
+    CALL_SUBTEST((test_view_functor_forwarding<RowMajor, true>(threaded_device)));
+    CALL_SUBTEST((test_view_compositions<ColMajor>(threaded_device)));
+    CALL_SUBTEST((test_view_compositions<RowMajor>(threaded_device)));
+  }
+  CALL_SUBTEST(test_scalar_and_empty_views());
+}
diff --git a/contrib/test/tensor_broadcast_sycl.cpp b/contrib/test/tensor_broadcast_sycl.cpp
new file mode 100644
index 0000000..5d1f684
--- /dev/null
+++ b/contrib/test/tensor_broadcast_sycl.cpp
@@ -0,0 +1,141 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_broadcast_sycl_fixed(const Eigen::SyclDevice& sycl_device) {
+  // BROADCAST test:
+  IndexType inDim1 = 2;
+  IndexType inDim2 = 3;
+  IndexType inDim3 = 5;
+  IndexType inDim4 = 7;
+  IndexType bDim1 = 2;
+  IndexType bDim2 = 3;
+  IndexType bDim3 = 1;
+  IndexType bDim4 = 4;
+  array<IndexType, 4> in_range = {{inDim1, inDim2, inDim3, inDim4}};
+  array<IndexType, 4> broadcasts = {{bDim1, bDim2, bDim3, bDim4}};
+  array<IndexType, 4> out_range;  // = in_range * broadcasts
+  for (size_t i = 0; i < out_range.size(); ++i) out_range[i] = in_range[i] * broadcasts[i];
+
+  Tensor<DataType, 4, DataLayout, IndexType> input(in_range);
+  Tensor<DataType, 4, DataLayout, IndexType> out(out_range);
+
+  for (size_t i = 0; i < in_range.size(); ++i) VERIFY_IS_EQUAL(out.dimension(i), out_range[i]);
+
+  for (IndexType i = 0; i < input.size(); ++i) input(i) = static_cast<DataType>(i);
+
+  DataType* gpu_in_data =
+      static_cast<DataType*>(sycl_device.allocate(input.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<TensorFixedSize<DataType, Sizes<2, 3, 5, 7>, DataLayout, IndexType>> gpu_in(gpu_in_data, in_range);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_out(gpu_out_data, out_range);
+  sycl_device.memcpyHostToDevice(gpu_in_data, input.data(), (input.dimensions().TotalSize()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = gpu_in.broadcast(broadcasts);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < inDim1 * bDim1; ++i) {
+    for (IndexType j = 0; j < inDim2 * bDim2; ++j) {
+      for (IndexType k = 0; k < inDim3 * bDim3; ++k) {
+        for (IndexType l = 0; l < inDim4 * bDim4; ++l) {
+          VERIFY_IS_APPROX(input(i % 2, j % 3, k % 5, l % 7), out(i, j, k, l));
+        }
+      }
+    }
+  }
+  printf("Broadcast Test with fixed size Passed\n");
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_broadcast_sycl(const Eigen::SyclDevice& sycl_device) {
+  // BROADCAST test:
+  IndexType inDim1 = 2;
+  IndexType inDim2 = 3;
+  IndexType inDim3 = 5;
+  IndexType inDim4 = 7;
+  IndexType bDim1 = 2;
+  IndexType bDim2 = 3;
+  IndexType bDim3 = 1;
+  IndexType bDim4 = 4;
+  array<IndexType, 4> in_range = {{inDim1, inDim2, inDim3, inDim4}};
+  array<IndexType, 4> broadcasts = {{bDim1, bDim2, bDim3, bDim4}};
+  array<IndexType, 4> out_range;  // = in_range * broadcasts
+  for (size_t i = 0; i < out_range.size(); ++i) out_range[i] = in_range[i] * broadcasts[i];
+
+  Tensor<DataType, 4, DataLayout, IndexType> input(in_range);
+  Tensor<DataType, 4, DataLayout, IndexType> out(out_range);
+
+  for (size_t i = 0; i < in_range.size(); ++i) VERIFY_IS_EQUAL(out.dimension(i), out_range[i]);
+
+  for (IndexType i = 0; i < input.size(); ++i) input(i) = static_cast<DataType>(i);
+
+  DataType* gpu_in_data =
+      static_cast<DataType*>(sycl_device.allocate(input.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_in(gpu_in_data, in_range);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_out(gpu_out_data, out_range);
+  sycl_device.memcpyHostToDevice(gpu_in_data, input.data(), (input.dimensions().TotalSize()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = gpu_in.broadcast(broadcasts);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < inDim1 * bDim1; ++i) {
+    for (IndexType j = 0; j < inDim2 * bDim2; ++j) {
+      for (IndexType k = 0; k < inDim3 * bDim3; ++k) {
+        for (IndexType l = 0; l < inDim4 * bDim4; ++l) {
+          VERIFY_IS_APPROX(input(i % inDim1, j % inDim2, k % inDim3, l % inDim4), out(i, j, k, l));
+        }
+      }
+    }
+  }
+  printf("Broadcast Test Passed\n");
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType>
+void sycl_broadcast_test_per_device(const cl::sycl::device& d) {
+  std::cout << "Running on " << d.template get_info<cl::sycl::info::device::name>() << std::endl;
+  QueueInterface queueInterface(d);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_broadcast_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_broadcast_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_broadcast_sycl_fixed<DataType, RowMajor, int64_t>(sycl_device);
+  test_broadcast_sycl_fixed<DataType, ColMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_broadcast_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_broadcast_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_broadcast_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_broadcasting.cpp b/contrib/test/tensor_broadcasting.cpp
new file mode 100644
index 0000000..722387d
--- /dev/null
+++ b/contrib/test/tensor_broadcasting.cpp
@@ -0,0 +1,336 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_broadcasting() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> broadcasts;
+  broadcasts[0] = 1;
+  broadcasts[1] = 1;
+  broadcasts[2] = 1;
+  broadcasts[3] = 1;
+
+  Tensor<float, 4, DataLayout> no_broadcast;
+  no_broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(no_broadcast.dimension(0), 2);
+  VERIFY_IS_EQUAL(no_broadcast.dimension(1), 3);
+  VERIFY_IS_EQUAL(no_broadcast.dimension(2), 5);
+  VERIFY_IS_EQUAL(no_broadcast.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_broadcast(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  broadcasts[0] = 2;
+  broadcasts[1] = 3;
+  broadcasts[2] = 1;
+  broadcasts[3] = 4;
+  Tensor<float, 4, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 4);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 5);
+  VERIFY_IS_EQUAL(broadcast.dimension(3), 28);
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 28; ++l) {
+          VERIFY_IS_EQUAL(tensor(i % 2, j % 3, k % 5, l % 7), broadcast(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_vectorized_broadcasting() {
+  Tensor<float, 3, DataLayout> tensor(8, 3, 5);
+  tensor.setRandom();
+  array<ptrdiff_t, 3> broadcasts;
+  broadcasts[0] = 2;
+  broadcasts[1] = 3;
+  broadcasts[2] = 4;
+
+  Tensor<float, 3, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 16);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
+
+  for (int i = 0; i < 16; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 20; ++k) {
+        VERIFY_IS_EQUAL(tensor(i % 8, j % 3, k % 5), broadcast(i, j, k));
+      }
+    }
+  }
+
+  tensor.resize(11, 3, 5);
+
+  tensor.setRandom();
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 22);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
+
+  for (int i = 0; i < 22; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 20; ++k) {
+        VERIFY_IS_EQUAL(tensor(i % 11, j % 3, k % 5), broadcast(i, j, k));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_static_broadcasting() {
+  Tensor<float, 3, DataLayout> tensor(8, 3, 5);
+  tensor.setRandom();
+
+  Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>, Eigen::type2index<4>> broadcasts;
+  Tensor<float, 3, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 16);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
+
+  for (int i = 0; i < 16; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 20; ++k) {
+        VERIFY_IS_EQUAL(tensor(i % 8, j % 3, k % 5), broadcast(i, j, k));
+      }
+    }
+  }
+
+  tensor.resize(11, 3, 5);
+
+  tensor.setRandom();
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 22);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
+
+  for (int i = 0; i < 22; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 20; ++k) {
+        VERIFY_IS_EQUAL(tensor(i % 11, j % 3, k % 5), broadcast(i, j, k));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_fixed_size_broadcasting() {
+  // Need to add a [] operator to the Size class for this to work
+#if 0
+  Tensor<float, 1, DataLayout> t1(10);
+  t1.setRandom();
+  TensorFixedSize<float, Sizes<1>, DataLayout> t2;
+  t2 = t2.constant(20.0f);
+
+  Tensor<float, 1, DataLayout> t3 = t1 + t2.broadcast(Eigen::array<int, 1>{{10}});
+  for (int i = 0; i < 10; ++i) {
+    VERIFY_IS_APPROX(t3(i), t1(i) + t2(0));
+  }
+
+  TensorMap<TensorFixedSize<float, Sizes<1>, DataLayout> > t4(t2.data(), {{1}});
+  Tensor<float, 1, DataLayout> t5 = t1 + t4.broadcast(Eigen::array<int, 1>{{10}});
+  for (int i = 0; i < 10; ++i) {
+    VERIFY_IS_APPROX(t5(i), t1(i) + t2(0));
+  }
+#endif
+}
+
+template <int DataLayout>
+static void test_simple_broadcasting_one_by_n() {
+  Tensor<float, 4, DataLayout> tensor(1, 13, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> broadcasts;
+  broadcasts[0] = 9;
+  broadcasts[1] = 1;
+  broadcasts[2] = 1;
+  broadcasts[3] = 1;
+  Tensor<float, 4, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 9);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 13);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 5);
+  VERIFY_IS_EQUAL(broadcast.dimension(3), 7);
+
+  for (int i = 0; i < 9; ++i) {
+    for (int j = 0; j < 13; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i % 1, j % 13, k % 5, l % 7), broadcast(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_simple_broadcasting_n_by_one() {
+  Tensor<float, 4, DataLayout> tensor(7, 3, 5, 1);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> broadcasts;
+  broadcasts[0] = 1;
+  broadcasts[1] = 1;
+  broadcasts[2] = 1;
+  broadcasts[3] = 19;
+  Tensor<float, 4, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 7);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 3);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 5);
+  VERIFY_IS_EQUAL(broadcast.dimension(3), 19);
+
+  for (int i = 0; i < 7; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 19; ++l) {
+          VERIFY_IS_EQUAL(tensor(i % 7, j % 3, k % 5, l % 1), broadcast(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_size_one_broadcasting() {
+  Tensor<float, 1, DataLayout> tensor(1);
+  tensor.setRandom();
+  array<ptrdiff_t, 1> broadcasts = {64};
+  Tensor<float, 1, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), broadcasts[0]);
+
+  for (int i = 0; i < broadcasts[0]; ++i) {
+    VERIFY_IS_EQUAL(tensor(0), broadcast(i));
+  }
+}
+
+template <int DataLayout>
+static void test_simple_broadcasting_one_by_n_by_one_1d() {
+  Tensor<float, 3, DataLayout> tensor(1, 7, 1);
+  tensor.setRandom();
+  array<ptrdiff_t, 3> broadcasts;
+  broadcasts[0] = 5;
+  broadcasts[1] = 1;
+  broadcasts[2] = 13;
+  Tensor<float, 3, DataLayout> broadcasted;
+  broadcasted = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcasted.dimension(0), 5);
+  VERIFY_IS_EQUAL(broadcasted.dimension(1), 7);
+  VERIFY_IS_EQUAL(broadcasted.dimension(2), 13);
+
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      for (int k = 0; k < 13; ++k) {
+        VERIFY_IS_EQUAL(tensor(0, j % 7, 0), broadcasted(i, j, k));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_simple_broadcasting_one_by_n_by_one_2d() {
+  Tensor<float, 4, DataLayout> tensor(1, 7, 13, 1);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> broadcasts;
+  broadcasts[0] = 5;
+  broadcasts[1] = 1;
+  broadcasts[2] = 1;
+  broadcasts[3] = 19;
+  Tensor<float, 4, DataLayout> broadcast;
+  broadcast = tensor.broadcast(broadcasts);
+
+  VERIFY_IS_EQUAL(broadcast.dimension(0), 5);
+  VERIFY_IS_EQUAL(broadcast.dimension(1), 7);
+  VERIFY_IS_EQUAL(broadcast.dimension(2), 13);
+  VERIFY_IS_EQUAL(broadcast.dimension(3), 19);
+
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      for (int k = 0; k < 13; ++k) {
+        for (int l = 0; l < 19; ++l) {
+          VERIFY_IS_EQUAL(tensor(0, j % 7, k % 13, 0), broadcast(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+// Regression: a scalar-changing consumer (here `.cast<double>()`) sits above
+// broadcast in the assign. Before TensorConversionOp::block dropped the
+// forwarded destination on a non-degenerate cast, broadcast's prepareStorage
+// would reuse a double-sized buffer as int storage (assert in debug,
+// corruption in release). Mirrors test_concatenation_through_cast.
+template <int DataLayout>
+static void test_broadcasting_through_cast() {
+  Tensor<int, 2, DataLayout> src(2, 3);
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) src(i, j) = i + 1 + 10 * j;
+  }
+  array<int, 2> bcast{2, 1};
+  Tensor<double, 2, DataLayout> out(4, 3);
+  out = src.broadcast(bcast).template cast<double>();
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 4; ++i) {
+      VERIFY_IS_APPROX(out(i, j), static_cast<double>(src(i % 2, j)));
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_broadcasting) {
+  CALL_SUBTEST(test_simple_broadcasting<ColMajor>());
+  CALL_SUBTEST(test_simple_broadcasting<RowMajor>());
+  CALL_SUBTEST(test_vectorized_broadcasting<ColMajor>());
+  CALL_SUBTEST(test_vectorized_broadcasting<RowMajor>());
+  CALL_SUBTEST(test_static_broadcasting<ColMajor>());
+  CALL_SUBTEST(test_static_broadcasting<RowMajor>());
+  CALL_SUBTEST(test_fixed_size_broadcasting<ColMajor>());
+  CALL_SUBTEST(test_fixed_size_broadcasting<RowMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_one_by_n<RowMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_n_by_one<RowMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_one_by_n<ColMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_n_by_one<ColMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_1d<ColMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_2d<ColMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_1d<RowMajor>());
+  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_2d<RowMajor>());
+  CALL_SUBTEST(test_size_one_broadcasting<ColMajor>());
+  CALL_SUBTEST(test_size_one_broadcasting<RowMajor>());
+  CALL_SUBTEST(test_broadcasting_through_cast<ColMajor>());
+  CALL_SUBTEST(test_broadcasting_through_cast<RowMajor>());
+}
diff --git a/contrib/test/tensor_builtins_sycl.cpp b/contrib/test/tensor_builtins_sycl.cpp
new file mode 100644
index 0000000..9fdb069
--- /dev/null
+++ b/contrib/test/tensor_builtins_sycl.cpp
@@ -0,0 +1,498 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+// Functions used to compare the TensorMap implementation on the device with
+// the equivalent on the host
+namespace SYCL {
+
+template <typename T>
+T abs(T x) {
+  return cl::sycl::abs(x);
+}
+template <>
+Eigen::half abs(Eigen::half x) {
+  return Eigen::half(cl::sycl::fabs(static_cast<cl::sycl::half>(x)));
+}
+
+template <>
+float abs(float x) {
+  return cl::sycl::fabs(x);
+}
+
+template <>
+double abs(double x) {
+  return cl::sycl::fabs(x);
+}
+
+template <typename T>
+T square(T x) {
+  return x * x;
+}
+template <typename T>
+T cube(T x) {
+  return x * x * x;
+}
+template <typename T>
+T inverse(T x) {
+  return T(1) / x;
+}
+template <typename T>
+T cwiseMax(T x, T y) {
+  return cl::sycl::max(x, y);
+}
+template <>
+Eigen::half cwiseMax(Eigen::half x, Eigen::half y) {
+  return Eigen::half(cl::sycl::max(static_cast<cl::sycl::half>(x), static_cast<cl::sycl::half>(y)));
+}
+
+template <typename T>
+T cwiseMin(T x, T y) {
+  return cl::sycl::min(x, y);
+}
+template <>
+Eigen::half cwiseMin(Eigen::half x, Eigen::half y) {
+  return Eigen::half(cl::sycl::min(static_cast<cl::sycl::half>(x), static_cast<cl::sycl::half>(y)));
+}
+
+template <typename T>
+T sqrt(T x) {
+  return cl::sycl::sqrt(x);
+}
+template <>
+Eigen::half sqrt(Eigen::half x) {
+  return Eigen::half(cl::sycl::sqrt(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T rsqrt(T x) {
+  return cl::sycl::rsqrt(x);
+}
+template <>
+Eigen::half rsqrt(Eigen::half x) {
+  return Eigen::half(cl::sycl::rsqrt(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T tanh(T x) {
+  return cl::sycl::tanh(x);
+}
+template <>
+Eigen::half tanh(Eigen::half x) {
+  return Eigen::half(cl::sycl::tanh(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T exp(T x) {
+  return cl::sycl::exp(x);
+}
+template <>
+Eigen::half exp(Eigen::half x) {
+  return Eigen::half(cl::sycl::exp(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T expm1(T x) {
+  return cl::sycl::expm1(x);
+}
+template <>
+Eigen::half expm1(Eigen::half x) {
+  return Eigen::half(cl::sycl::expm1(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T log(T x) {
+  return cl::sycl::log(x);
+}
+template <>
+Eigen::half log(Eigen::half x) {
+  return Eigen::half(cl::sycl::log(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T ceil(T x) {
+  return cl::sycl::ceil(x);
+}
+template <>
+Eigen::half ceil(Eigen::half x) {
+  return Eigen::half(cl::sycl::ceil(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T floor(T x) {
+  return cl::sycl::floor(x);
+}
+template <>
+Eigen::half floor(Eigen::half x) {
+  return Eigen::half(cl::sycl::floor(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T round(T x) {
+  return cl::sycl::round(x);
+}
+template <>
+Eigen::half round(Eigen::half x) {
+  return Eigen::half(cl::sycl::round(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T log1p(T x) {
+  return cl::sycl::log1p(x);
+}
+template <>
+Eigen::half log1p(Eigen::half x) {
+  return Eigen::half(cl::sycl::log1p(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T sign(T x) {
+  return cl::sycl::sign(x);
+}
+template <>
+Eigen::half sign(Eigen::half x) {
+  return Eigen::half(cl::sycl::sign(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T isnan(T x) {
+  return cl::sycl::isnan(x);
+}
+template <>
+Eigen::half isnan(Eigen::half x) {
+  return Eigen::half(cl::sycl::isnan(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T isfinite(T x) {
+  return cl::sycl::isfinite(x);
+}
+template <>
+Eigen::half isfinite(Eigen::half x) {
+  return Eigen::half(cl::sycl::isfinite(static_cast<cl::sycl::half>(x)));
+}
+
+template <typename T>
+T isinf(T x) {
+  return cl::sycl::isinf(x);
+}
+template <>
+Eigen::half isinf(Eigen::half x) {
+  return Eigen::half(cl::sycl::isinf(static_cast<cl::sycl::half>(x)));
+}
+}  // namespace SYCL
+
+#define DECLARE_UNARY_STRUCT_NON_SYCL(FUNC)  \
+  struct op_##FUNC {                         \
+    template <typename T>                    \
+    auto operator()(const T& x) {            \
+      return SYCL::FUNC(x);                  \
+    }                                        \
+    template <typename T>                    \
+    auto operator()(const TensorMap<T>& x) { \
+      return x.FUNC();                       \
+    }                                        \
+  };
+
+DECLARE_UNARY_STRUCT_NON_SYCL(abs)
+DECLARE_UNARY_STRUCT_NON_SYCL(square)
+DECLARE_UNARY_STRUCT_NON_SYCL(cube)
+DECLARE_UNARY_STRUCT_NON_SYCL(inverse)
+
+#define DECLARE_BINARY_STRUCT_NON_SYCL(FUNC)                          \
+  struct op_##FUNC {                                                  \
+    template <typename T1, typename T2>                               \
+    auto operator()(const T1& x, const T2& y) {                       \
+      return SYCL::FUNC(x, y);                                        \
+    }                                                                 \
+    template <typename T1, typename T2>                               \
+    auto operator()(const TensorMap<T1>& x, const TensorMap<T2>& y) { \
+      return x.FUNC(y);                                               \
+    }                                                                 \
+  };
+
+DECLARE_BINARY_STRUCT_NON_SYCL(cwiseMax)
+DECLARE_BINARY_STRUCT_NON_SYCL(cwiseMin)
+
+struct EqualAssignment {
+  template <typename Lhs, typename Rhs>
+  void operator()(Lhs& lhs, const Rhs& rhs) {
+    lhs = rhs;
+  }
+};
+
+struct PlusEqualAssignment {
+  template <typename Lhs, typename Rhs>
+  void operator()(Lhs& lhs, const Rhs& rhs) {
+    lhs += rhs;
+  }
+};
+
+template <typename DataType, int DataLayout, typename Assignment, typename Operator>
+void test_unary_builtins_for_scalar(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+  Operator op;
+  Assignment asgn;
+  {
+    /* Assignment(out, Operator(in)) */
+    Tensor<DataType, 3, DataLayout, int64_t> in(tensor_range);
+    Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
+    in = in.random() + DataType(0.01);
+    out = out.random() + DataType(0.01);
+    Tensor<DataType, 3, DataLayout, int64_t> reference(out);
+    DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
+    DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+    TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu(gpu_data, tensor_range);
+    TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
+    sycl_device.memcpyHostToDevice(gpu_data, in.data(), (in.size()) * sizeof(DataType));
+    sycl_device.memcpyHostToDevice(gpu_data_out, out.data(), (out.size()) * sizeof(DataType));
+    auto device_expr = gpu_out.device(sycl_device);
+    asgn(device_expr, op(gpu));
+    sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
+    for (int64_t i = 0; i < out.size(); ++i) {
+      DataType ver = reference(i);
+      asgn(ver, op(in(i)));
+      VERIFY_IS_APPROX(out(i), ver);
+    }
+    sycl_device.deallocate(gpu_data);
+    sycl_device.deallocate(gpu_data_out);
+  }
+  {
+    /* Assignment(out, Operator(out)) */
+    Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
+    // Offset with 1 to avoid tiny output (< 1e-6) as they can easily fail.
+    out = out.random() + DataType(1);
+    Tensor<DataType, 3, DataLayout, int64_t> reference(out);
+    DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+    TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
+    sycl_device.memcpyHostToDevice(gpu_data_out, out.data(), (out.size()) * sizeof(DataType));
+    auto device_expr = gpu_out.device(sycl_device);
+    asgn(device_expr, op(gpu_out));
+    sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
+    for (int64_t i = 0; i < out.size(); ++i) {
+      DataType ver = reference(i);
+      asgn(ver, op(reference(i)));
+      VERIFY_IS_APPROX(out(i), ver);
+    }
+    sycl_device.deallocate(gpu_data_out);
+  }
+}
+
+#define DECLARE_UNARY_STRUCT(FUNC)                                 \
+  struct op_##FUNC {                                               \
+    template <typename T>                                          \
+    auto operator()(const T& x) -> decltype(SYCL::FUNC(x)) {       \
+      return SYCL::FUNC(x);                                        \
+    }                                                              \
+    template <typename T>                                          \
+    auto operator()(const TensorMap<T>& x) -> decltype(x.FUNC()) { \
+      return x.FUNC();                                             \
+    }                                                              \
+  };
+
+DECLARE_UNARY_STRUCT(sqrt)
+DECLARE_UNARY_STRUCT(rsqrt)
+DECLARE_UNARY_STRUCT(tanh)
+DECLARE_UNARY_STRUCT(exp)
+DECLARE_UNARY_STRUCT(expm1)
+DECLARE_UNARY_STRUCT(log)
+DECLARE_UNARY_STRUCT(ceil)
+DECLARE_UNARY_STRUCT(floor)
+DECLARE_UNARY_STRUCT(round)
+DECLARE_UNARY_STRUCT(log1p)
+DECLARE_UNARY_STRUCT(sign)
+DECLARE_UNARY_STRUCT(isnan)
+DECLARE_UNARY_STRUCT(isfinite)
+DECLARE_UNARY_STRUCT(isinf)
+
+template <typename DataType, int DataLayout, typename Assignment>
+void test_unary_builtins_for_assignement(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+#define RUN_UNARY_TEST(FUNC) \
+  test_unary_builtins_for_scalar<DataType, DataLayout, Assignment, op_##FUNC>(sycl_device, tensor_range)
+  RUN_UNARY_TEST(abs);
+  RUN_UNARY_TEST(sqrt);
+  RUN_UNARY_TEST(rsqrt);
+  RUN_UNARY_TEST(square);
+  RUN_UNARY_TEST(cube);
+  RUN_UNARY_TEST(inverse);
+  RUN_UNARY_TEST(tanh);
+  RUN_UNARY_TEST(exp);
+  RUN_UNARY_TEST(expm1);
+  RUN_UNARY_TEST(log);
+  RUN_UNARY_TEST(ceil);
+  RUN_UNARY_TEST(floor);
+  RUN_UNARY_TEST(round);
+  RUN_UNARY_TEST(log1p);
+  RUN_UNARY_TEST(sign);
+}
+
+template <typename DataType, int DataLayout, typename Operator>
+void test_unary_builtins_return_bool(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+  /* out = op(in) */
+  Operator op;
+  Tensor<DataType, 3, DataLayout, int64_t> in(tensor_range);
+  Tensor<bool, 3, DataLayout, int64_t> out(tensor_range);
+  in = in.random() + DataType(0.01);
+  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
+  bool* gpu_data_out = static_cast<bool*>(sycl_device.allocate(out.size() * sizeof(bool)));
+  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu(gpu_data, tensor_range);
+  TensorMap<Tensor<bool, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
+  sycl_device.memcpyHostToDevice(gpu_data, in.data(), (in.size()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = op(gpu);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(bool));
+  for (int64_t i = 0; i < out.size(); ++i) {
+    VERIFY_IS_EQUAL(out(i), op(in(i)));
+  }
+  sycl_device.deallocate(gpu_data);
+  sycl_device.deallocate(gpu_data_out);
+}
+
+template <typename DataType, int DataLayout>
+void test_unary_builtins(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+  test_unary_builtins_for_assignement<DataType, DataLayout, PlusEqualAssignment>(sycl_device, tensor_range);
+  test_unary_builtins_for_assignement<DataType, DataLayout, EqualAssignment>(sycl_device, tensor_range);
+  test_unary_builtins_return_bool<DataType, DataLayout, op_isnan>(sycl_device, tensor_range);
+  test_unary_builtins_return_bool<DataType, DataLayout, op_isfinite>(sycl_device, tensor_range);
+  test_unary_builtins_return_bool<DataType, DataLayout, op_isinf>(sycl_device, tensor_range);
+}
+
+template <typename DataType>
+static void test_builtin_unary_sycl(const Eigen::SyclDevice& sycl_device) {
+  int64_t sizeDim1 = 10;
+  int64_t sizeDim2 = 10;
+  int64_t sizeDim3 = 10;
+  array<int64_t, 3> tensor_range = {{sizeDim1, sizeDim2, sizeDim3}};
+
+  test_unary_builtins<DataType, RowMajor>(sycl_device, tensor_range);
+  test_unary_builtins<DataType, ColMajor>(sycl_device, tensor_range);
+}
+
+template <typename DataType, int DataLayout, typename Operator>
+void test_binary_builtins_func(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+  /* out = op(in_1, in_2) */
+  Operator op;
+  Tensor<DataType, 3, DataLayout, int64_t> in_1(tensor_range);
+  Tensor<DataType, 3, DataLayout, int64_t> in_2(tensor_range);
+  Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
+  in_1 = in_1.random() + DataType(0.01);
+  in_2 = in_2.random() + DataType(0.01);
+  Tensor<DataType, 3, DataLayout, int64_t> reference(out);
+  DataType* gpu_data_1 = static_cast<DataType*>(sycl_device.allocate(in_1.size() * sizeof(DataType)));
+  DataType* gpu_data_2 = static_cast<DataType*>(sycl_device.allocate(in_2.size() * sizeof(DataType)));
+  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_1(gpu_data_1, tensor_range);
+  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_2(gpu_data_2, tensor_range);
+  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
+  sycl_device.memcpyHostToDevice(gpu_data_1, in_1.data(), (in_1.size()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_data_2, in_2.data(), (in_2.size()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = op(gpu_1, gpu_2);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
+  for (int64_t i = 0; i < out.size(); ++i) {
+    VERIFY_IS_APPROX(out(i), op(in_1(i), in_2(i)));
+  }
+  sycl_device.deallocate(gpu_data_1);
+  sycl_device.deallocate(gpu_data_2);
+  sycl_device.deallocate(gpu_data_out);
+}
+
+template <typename DataType, int DataLayout, typename Operator>
+void test_binary_builtins_fixed_arg2(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+  /* out = op(in_1, 2) */
+  Operator op;
+  const DataType arg2(2);
+  Tensor<DataType, 3, DataLayout, int64_t> in_1(tensor_range);
+  Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
+  in_1 = in_1.random();
+  Tensor<DataType, 3, DataLayout, int64_t> reference(out);
+  DataType* gpu_data_1 = static_cast<DataType*>(sycl_device.allocate(in_1.size() * sizeof(DataType)));
+  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_1(gpu_data_1, tensor_range);
+  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
+  sycl_device.memcpyHostToDevice(gpu_data_1, in_1.data(), (in_1.size()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = op(gpu_1, arg2);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
+  for (int64_t i = 0; i < out.size(); ++i) {
+    VERIFY_IS_APPROX(out(i), op(in_1(i), arg2));
+  }
+  sycl_device.deallocate(gpu_data_1);
+  sycl_device.deallocate(gpu_data_out);
+}
+
+#define DECLARE_BINARY_STRUCT_OP(NAME, OPERATOR)                          \
+  struct op_##NAME {                                                      \
+    template <typename T1, typename T2>                                   \
+    auto operator()(const T1& x, const T2& y) -> decltype(x OPERATOR y) { \
+      return x OPERATOR y;                                                \
+    }                                                                     \
+  };
+
+DECLARE_BINARY_STRUCT_OP(plus, +)
+DECLARE_BINARY_STRUCT_OP(minus, -)
+DECLARE_BINARY_STRUCT_OP(times, *)
+DECLARE_BINARY_STRUCT_OP(divide, /)
+DECLARE_BINARY_STRUCT_OP(modulo, %)
+
+template <typename DataType, int DataLayout>
+void test_binary_builtins(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
+  test_binary_builtins_func<DataType, DataLayout, op_cwiseMax>(sycl_device, tensor_range);
+  test_binary_builtins_func<DataType, DataLayout, op_cwiseMin>(sycl_device, tensor_range);
+  test_binary_builtins_func<DataType, DataLayout, op_plus>(sycl_device, tensor_range);
+  test_binary_builtins_func<DataType, DataLayout, op_minus>(sycl_device, tensor_range);
+  test_binary_builtins_func<DataType, DataLayout, op_times>(sycl_device, tensor_range);
+  test_binary_builtins_func<DataType, DataLayout, op_divide>(sycl_device, tensor_range);
+}
+
+template <typename DataType>
+static void test_floating_builtin_binary_sycl(const Eigen::SyclDevice& sycl_device) {
+  int64_t sizeDim1 = 10;
+  int64_t sizeDim2 = 10;
+  int64_t sizeDim3 = 10;
+  array<int64_t, 3> tensor_range = {{sizeDim1, sizeDim2, sizeDim3}};
+  test_binary_builtins<DataType, RowMajor>(sycl_device, tensor_range);
+  test_binary_builtins<DataType, ColMajor>(sycl_device, tensor_range);
+}
+
+template <typename DataType>
+static void test_integer_builtin_binary_sycl(const Eigen::SyclDevice& sycl_device) {
+  int64_t sizeDim1 = 10;
+  int64_t sizeDim2 = 10;
+  int64_t sizeDim3 = 10;
+  array<int64_t, 3> tensor_range = {{sizeDim1, sizeDim2, sizeDim3}};
+  test_binary_builtins_fixed_arg2<DataType, RowMajor, op_modulo>(sycl_device, tensor_range);
+  test_binary_builtins_fixed_arg2<DataType, ColMajor, op_modulo>(sycl_device, tensor_range);
+}
+
+EIGEN_DECLARE_TEST(tensor_builtins_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    QueueInterface queueInterface(device);
+    Eigen::SyclDevice sycl_device(&queueInterface);
+    CALL_SUBTEST_1(test_builtin_unary_sycl<half>(sycl_device));
+    CALL_SUBTEST_2(test_floating_builtin_binary_sycl<half>(sycl_device));
+    CALL_SUBTEST_3(test_builtin_unary_sycl<float>(sycl_device));
+    CALL_SUBTEST_4(test_floating_builtin_binary_sycl<float>(sycl_device));
+    CALL_SUBTEST_5(test_integer_builtin_binary_sycl<int>(sycl_device));
+  }
+}
diff --git a/contrib/test/tensor_cast_float16_gpu.cu b/contrib/test/tensor_cast_float16_gpu.cu
new file mode 100644
index 0000000..530eb48
--- /dev/null
+++ b/contrib/test/tensor_cast_float16_gpu.cu
@@ -0,0 +1,74 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+void test_gpu_conversion() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  Tensor<float, 1> floats(num_elem);
+  floats.setRandom();
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  float* d_conv = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_half(d_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
+
+  gpu_device.memcpyHostToDevice(d_float, floats.data(), num_elem * sizeof(float));
+
+  gpu_half.device(gpu_device) = gpu_float.cast<Eigen::half>();
+  gpu_conv.device(gpu_device) = gpu_half.cast<float>();
+
+  Tensor<float, 1> initial(num_elem);
+  Tensor<float, 1> final(num_elem);
+  gpu_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(initial(i), final(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_half);
+  gpu_device.deallocate(d_conv);
+}
+
+void test_fallback_conversion() {
+  int num_elem = 101;
+  Tensor<float, 1> floats(num_elem);
+  floats.setRandom();
+
+  Eigen::Tensor<Eigen::half, 1> halfs = floats.cast<Eigen::half>();
+  Eigen::Tensor<float, 1> conv = halfs.cast<float>();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(floats(i), conv(i));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_cast_float16_gpu) {
+  CALL_SUBTEST(test_gpu_conversion());
+  CALL_SUBTEST(test_fallback_conversion());
+}
diff --git a/contrib/test/tensor_casts.cpp b/contrib/test/tensor_casts.cpp
new file mode 100644
index 0000000..10cc712
--- /dev/null
+++ b/contrib/test/tensor_casts.cpp
@@ -0,0 +1,88 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "random_without_cast_overflow.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::Tensor;
+
+template <typename FromType, typename ToType>
+static void test_type_cast() {
+  Tensor<FromType, 2> ftensor(101, 201);
+  // Generate random values for a valid cast.
+  for (int i = 0; i < 101; ++i) {
+    for (int j = 0; j < 201; ++j) {
+      ftensor(i, j) = internal::random_without_cast_overflow<FromType, ToType>::value();
+    }
+  }
+
+  Tensor<ToType, 2> ttensor(101, 201);
+  ttensor = ftensor.template cast<ToType>();
+
+  for (int i = 0; i < 101; ++i) {
+    for (int j = 0; j < 201; ++j) {
+      const ToType ref = internal::cast<FromType, ToType>(ftensor(i, j));
+      VERIFY_IS_EQUAL(ttensor(i, j), ref);
+    }
+  }
+}
+
+template <typename Scalar, typename EnableIf = void>
+struct test_cast_runner {
+  static void run() {
+    test_type_cast<Scalar, bool>();
+    test_type_cast<Scalar, int8_t>();
+    test_type_cast<Scalar, int16_t>();
+    test_type_cast<Scalar, int32_t>();
+    test_type_cast<Scalar, int64_t>();
+    test_type_cast<Scalar, uint8_t>();
+    test_type_cast<Scalar, uint16_t>();
+    test_type_cast<Scalar, uint32_t>();
+    test_type_cast<Scalar, uint64_t>();
+    test_type_cast<Scalar, half>();
+    test_type_cast<Scalar, bfloat16>();
+    test_type_cast<Scalar, float>();
+    test_type_cast<Scalar, double>();
+    test_type_cast<Scalar, std::complex<float>>();
+    test_type_cast<Scalar, std::complex<double>>();
+  }
+};
+
+// Only certain types allow cast from std::complex<>.
+template <typename Scalar>
+struct test_cast_runner<Scalar, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
+  static void run() {
+    test_type_cast<Scalar, half>();
+    test_type_cast<Scalar, bfloat16>();
+    test_type_cast<Scalar, std::complex<float>>();
+    test_type_cast<Scalar, std::complex<double>>();
+  }
+};
+
+EIGEN_DECLARE_TEST(tensor_casts) {
+  CALL_SUBTEST(test_cast_runner<bool>::run());
+  CALL_SUBTEST(test_cast_runner<int8_t>::run());
+  CALL_SUBTEST(test_cast_runner<int16_t>::run());
+  CALL_SUBTEST(test_cast_runner<int32_t>::run());
+  CALL_SUBTEST(test_cast_runner<int64_t>::run());
+  CALL_SUBTEST(test_cast_runner<uint8_t>::run());
+  CALL_SUBTEST(test_cast_runner<uint16_t>::run());
+  CALL_SUBTEST(test_cast_runner<uint32_t>::run());
+  CALL_SUBTEST(test_cast_runner<uint64_t>::run());
+  CALL_SUBTEST(test_cast_runner<half>::run());
+  CALL_SUBTEST(test_cast_runner<bfloat16>::run());
+  CALL_SUBTEST(test_cast_runner<float>::run());
+  CALL_SUBTEST(test_cast_runner<double>::run());
+  CALL_SUBTEST(test_cast_runner<std::complex<float>>::run());
+  CALL_SUBTEST(test_cast_runner<std::complex<double>>::run());
+}
diff --git a/contrib/test/tensor_chipping.cpp b/contrib/test/tensor_chipping.cpp
new file mode 100644
index 0000000..6e84c79
--- /dev/null
+++ b/contrib/test/tensor_chipping.cpp
@@ -0,0 +1,459 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_chip() {
+  Tensor<float, 5, DataLayout> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+
+  Tensor<float, 4, DataLayout> chip1;
+  chip1 = tensor.template chip<0>(1);
+
+  VERIFY_IS_EQUAL(chip1.dimension(0), 3);
+  VERIFY_IS_EQUAL(chip1.dimension(1), 5);
+  VERIFY_IS_EQUAL(chip1.dimension(2), 7);
+  VERIFY_IS_EQUAL(chip1.dimension(3), 11);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1, i, j, k, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip2 = tensor.template chip<1>(1);
+  VERIFY_IS_EQUAL(chip2.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip2.dimension(1), 5);
+  VERIFY_IS_EQUAL(chip2.dimension(2), 7);
+  VERIFY_IS_EQUAL(chip2.dimension(3), 11);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1, j, k, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip3 = tensor.template chip<2>(2);
+  VERIFY_IS_EQUAL(chip3.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip3.dimension(1), 3);
+  VERIFY_IS_EQUAL(chip3.dimension(2), 7);
+  VERIFY_IS_EQUAL(chip3.dimension(3), 11);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2, k, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip4(tensor.template chip<3>(5));
+  VERIFY_IS_EQUAL(chip4.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip4.dimension(1), 3);
+  VERIFY_IS_EQUAL(chip4.dimension(2), 5);
+  VERIFY_IS_EQUAL(chip4.dimension(3), 11);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip5(tensor.template chip<4>(7));
+  VERIFY_IS_EQUAL(chip5.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip5.dimension(1), 3);
+  VERIFY_IS_EQUAL(chip5.dimension(2), 5);
+  VERIFY_IS_EQUAL(chip5.dimension(3), 7);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_dynamic_chip() {
+  Tensor<float, 5, DataLayout> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+
+  Tensor<float, 4, DataLayout> chip1;
+  chip1 = tensor.chip(1, 0);
+  VERIFY_IS_EQUAL(chip1.dimension(0), 3);
+  VERIFY_IS_EQUAL(chip1.dimension(1), 5);
+  VERIFY_IS_EQUAL(chip1.dimension(2), 7);
+  VERIFY_IS_EQUAL(chip1.dimension(3), 11);
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1, i, j, k, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip2 = tensor.chip(1, 1);
+  VERIFY_IS_EQUAL(chip2.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip2.dimension(1), 5);
+  VERIFY_IS_EQUAL(chip2.dimension(2), 7);
+  VERIFY_IS_EQUAL(chip2.dimension(3), 11);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1, j, k, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip3 = tensor.chip(2, 2);
+  VERIFY_IS_EQUAL(chip3.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip3.dimension(1), 3);
+  VERIFY_IS_EQUAL(chip3.dimension(2), 7);
+  VERIFY_IS_EQUAL(chip3.dimension(3), 11);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2, k, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip4(tensor.chip(5, 3));
+  VERIFY_IS_EQUAL(chip4.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip4.dimension(1), 3);
+  VERIFY_IS_EQUAL(chip4.dimension(2), 5);
+  VERIFY_IS_EQUAL(chip4.dimension(3), 11);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5, l));
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> chip5(tensor.chip(7, 4));
+  VERIFY_IS_EQUAL(chip5.dimension(0), 2);
+  VERIFY_IS_EQUAL(chip5.dimension(1), 3);
+  VERIFY_IS_EQUAL(chip5.dimension(2), 5);
+  VERIFY_IS_EQUAL(chip5.dimension(3), 7);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_chip_in_expr() {
+  Tensor<float, 5, DataLayout> input1(2, 3, 5, 7, 11);
+  input1.setRandom();
+  Tensor<float, 4, DataLayout> input2(3, 5, 7, 11);
+  input2.setRandom();
+
+  Tensor<float, 4, DataLayout> result = input1.template chip<0>(0) + input2;
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          float expected = input1(0, i, j, k, l) + input2(i, j, k, l);
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected);
+        }
+      }
+    }
+  }
+
+  Tensor<float, 3, DataLayout> input3(3, 7, 11);
+  input3.setRandom();
+  Tensor<float, 3, DataLayout> result2 = input1.template chip<0>(0).template chip<1>(2) + input3;
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      for (int k = 0; k < 11; ++k) {
+        float expected = input1(0, i, 2, j, k) + input3(i, j, k);
+        VERIFY_IS_EQUAL(result2(i, j, k), expected);
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_chip_as_lvalue() {
+  Tensor<float, 5, DataLayout> input1(2, 3, 5, 7, 11);
+  input1.setRandom();
+
+  Tensor<float, 4, DataLayout> input2(3, 5, 7, 11);
+  input2.setRandom();
+  Tensor<float, 5, DataLayout> tensor = input1;
+  tensor.template chip<0>(1) = input2;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          for (int m = 0; m < 11; ++m) {
+            if (i != 1) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input2(j, k, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> input3(2, 5, 7, 11);
+  input3.setRandom();
+  tensor = input1;
+  tensor.template chip<1>(1) = input3;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          for (int m = 0; m < 11; ++m) {
+            if (j != 1) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input3(i, k, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> input4(2, 3, 7, 11);
+  input4.setRandom();
+  tensor = input1;
+  tensor.template chip<2>(3) = input4;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          for (int m = 0; m < 11; ++m) {
+            if (k != 3) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input4(i, j, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> input5(2, 3, 5, 11);
+  input5.setRandom();
+  tensor = input1;
+  tensor.template chip<3>(4) = input5;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          for (int m = 0; m < 11; ++m) {
+            if (l != 4) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input5(i, j, k, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, DataLayout> input6(2, 3, 5, 7);
+  input6.setRandom();
+  tensor = input1;
+  tensor.template chip<4>(5) = input6;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          for (int m = 0; m < 11; ++m) {
+            if (m != 5) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input6(i, j, k, l));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Tensor<float, 5, DataLayout> input7(2, 3, 5, 7, 11);
+  input7.setRandom();
+  tensor = input1;
+  tensor.chip(0, 0) = input7.chip(0, 0);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          for (int m = 0; m < 11; ++m) {
+            if (i != 0) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input7(i, j, k, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+static void test_chip_raw_data_col_major() {
+  Tensor<float, 5, ColMajor> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+
+  typedef TensorEvaluator<decltype(tensor.chip<4>(3)), DefaultDevice> Evaluator4;
+  auto chip = Evaluator4(tensor.chip<4>(3), DefaultDevice());
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          int chip_index = i + 2 * (j + 3 * (k + 5 * l));
+          VERIFY_IS_EQUAL(chip.data()[chip_index], tensor(i, j, k, l, 3));
+        }
+      }
+    }
+  }
+
+  typedef TensorEvaluator<decltype(tensor.chip<0>(0)), DefaultDevice> Evaluator0;
+  auto chip0 = Evaluator0(tensor.chip<0>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip0.data(), static_cast<float*>(0));
+
+  typedef TensorEvaluator<decltype(tensor.chip<1>(0)), DefaultDevice> Evaluator1;
+  auto chip1 = Evaluator1(tensor.chip<1>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip1.data(), static_cast<float*>(0));
+
+  typedef TensorEvaluator<decltype(tensor.chip<2>(0)), DefaultDevice> Evaluator2;
+  auto chip2 = Evaluator2(tensor.chip<2>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip2.data(), static_cast<float*>(0));
+
+  typedef TensorEvaluator<decltype(tensor.chip<3>(0)), DefaultDevice> Evaluator3;
+  auto chip3 = Evaluator3(tensor.chip<3>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip3.data(), static_cast<float*>(0));
+}
+
+static void test_chip_raw_data_row_major() {
+  Tensor<float, 5, RowMajor> tensor(11, 7, 5, 3, 2);
+  tensor.setRandom();
+
+  typedef TensorEvaluator<decltype(tensor.chip<0>(3)), DefaultDevice> Evaluator0;
+  auto chip = Evaluator0(tensor.chip<0>(3), DefaultDevice());
+  for (int i = 0; i < 7; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 2; ++l) {
+          int chip_index = l + 2 * (k + 3 * (j + 5 * i));
+          VERIFY_IS_EQUAL(chip.data()[chip_index], tensor(3, i, j, k, l));
+        }
+      }
+    }
+  }
+
+  typedef TensorEvaluator<decltype(tensor.chip<1>(0)), DefaultDevice> Evaluator1;
+  auto chip1 = Evaluator1(tensor.chip<1>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip1.data(), static_cast<float*>(0));
+
+  typedef TensorEvaluator<decltype(tensor.chip<2>(0)), DefaultDevice> Evaluator2;
+  auto chip2 = Evaluator2(tensor.chip<2>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip2.data(), static_cast<float*>(0));
+
+  typedef TensorEvaluator<decltype(tensor.chip<3>(0)), DefaultDevice> Evaluator3;
+  auto chip3 = Evaluator3(tensor.chip<3>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip3.data(), static_cast<float*>(0));
+
+  typedef TensorEvaluator<decltype(tensor.chip<4>(0)), DefaultDevice> Evaluator4;
+  auto chip4 = Evaluator4(tensor.chip<4>(0), DefaultDevice());
+  VERIFY_IS_EQUAL(chip4.data(), static_cast<float*>(0));
+}
+
+template <int Rank, int Layout>
+EIGEN_DONT_INLINE Tensor<double, Rank - 1, Layout> runtime_axis_chip(const Tensor<double, Rank, Layout>& input,
+                                                                     Index offset, Index axis) {
+  return input.chip(offset, axis);
+}
+
+template <int Rank, int Layout, int Axis>
+void test_runtime_axis_block_chip() {
+  DSizes<Index, Rank> dimensions;
+  for (int i = 0; i < Rank; ++i) dimensions[i] = 3 + i;
+  Tensor<double, Rank, Layout> input(dimensions);
+  for (Index i = 0; i < input.size(); ++i) input.data()[i] = double(i);
+  for (Index offset : {Index(0), dimensions[Axis] - 1}) {
+    const Tensor<double, Rank - 1, Layout> result = runtime_axis_chip(input, offset, Axis);
+    const Tensor<double, Rank - 1, Layout> expected = input.template chip<Axis>(offset);
+    VERIFY_IS_EQUAL(result.size(), expected.size());
+    for (Index i = 0; i < result.size(); ++i) VERIFY_IS_EQUAL(result.data()[i], expected.data()[i]);
+
+    Tensor<double, Rank, Layout> actual = input;
+    Tensor<double, Rank, Layout> reference = input;
+    actual.chip(offset, Axis) = result + result;
+    reference.template chip<Axis>(offset) = expected + expected;
+    for (Index i = 0; i < actual.size(); ++i) VERIFY_IS_EQUAL(actual.data()[i], reference.data()[i]);
+  }
+}
+
+template <int Layout>
+void test_runtime_axis_block_chips() {
+  test_runtime_axis_block_chip<3, Layout, 0>();
+  test_runtime_axis_block_chip<3, Layout, 1>();
+  test_runtime_axis_block_chip<3, Layout, 2>();
+  test_runtime_axis_block_chip<4, Layout, 0>();
+  test_runtime_axis_block_chip<4, Layout, 1>();
+  test_runtime_axis_block_chip<4, Layout, 2>();
+  test_runtime_axis_block_chip<4, Layout, 3>();
+}
+
+EIGEN_DECLARE_TEST(tensor_chipping) {
+  CALL_SUBTEST(test_runtime_axis_block_chips<ColMajor>());
+  CALL_SUBTEST(test_runtime_axis_block_chips<RowMajor>());
+  CALL_SUBTEST(test_simple_chip<ColMajor>());
+  CALL_SUBTEST(test_simple_chip<RowMajor>());
+  CALL_SUBTEST(test_dynamic_chip<ColMajor>());
+  CALL_SUBTEST(test_dynamic_chip<RowMajor>());
+  CALL_SUBTEST(test_chip_in_expr<ColMajor>());
+  CALL_SUBTEST(test_chip_in_expr<RowMajor>());
+  CALL_SUBTEST(test_chip_as_lvalue<ColMajor>());
+  CALL_SUBTEST(test_chip_as_lvalue<RowMajor>());
+  CALL_SUBTEST(test_chip_raw_data_col_major());
+  CALL_SUBTEST(test_chip_raw_data_row_major());
+}
diff --git a/contrib/test/tensor_chipping_sycl.cpp b/contrib/test/tensor_chipping_sycl.cpp
new file mode 100644
index 0000000..9158bcf
--- /dev/null
+++ b/contrib/test/tensor_chipping_sycl.cpp
@@ -0,0 +1,613 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_static_chip_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  IndexType sizeDim5 = 11;
+
+  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+  array<IndexType, 4> chip1TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+
+  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> chip1(chip1TensorRange);
+
+  tensor.setRandom();
+
+  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
+  const size_t chip1TensorBuffSize = chip1.size() * sizeof(DataType);
+  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_chip1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
+
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip1(gpu_data_chip1, chip1TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
+  gpu_chip1.device(sycl_device) = gpu_tensor.template chip<0l>(1l);
+  sycl_device.memcpyDeviceToHost(chip1.data(), gpu_data_chip1, chip1TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip1.dimension(0), sizeDim2);
+  VERIFY_IS_EQUAL(chip1.dimension(1), sizeDim3);
+  VERIFY_IS_EQUAL(chip1.dimension(2), sizeDim4);
+  VERIFY_IS_EQUAL(chip1.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim2; ++i) {
+    for (IndexType j = 0; j < sizeDim3; ++j) {
+      for (IndexType k = 0; k < sizeDim4; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1l, i, j, k, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip2TensorRange = {{sizeDim1, sizeDim3, sizeDim4, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip2(chip2TensorRange);
+  const size_t chip2TensorBuffSize = chip2.size() * sizeof(DataType);
+  DataType* gpu_data_chip2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip2(gpu_data_chip2, chip2TensorRange);
+
+  gpu_chip2.device(sycl_device) = gpu_tensor.template chip<1l>(1l);
+  sycl_device.memcpyDeviceToHost(chip2.data(), gpu_data_chip2, chip2TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip2.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip2.dimension(1), sizeDim3);
+  VERIFY_IS_EQUAL(chip2.dimension(2), sizeDim4);
+  VERIFY_IS_EQUAL(chip2.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim3; ++j) {
+      for (IndexType k = 0; k < sizeDim4; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1l, j, k, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip3TensorRange = {{sizeDim1, sizeDim2, sizeDim4, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip3(chip3TensorRange);
+  const size_t chip3TensorBuffSize = chip3.size() * sizeof(DataType);
+  DataType* gpu_data_chip3 = static_cast<DataType*>(sycl_device.allocate(chip3TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip3(gpu_data_chip3, chip3TensorRange);
+
+  gpu_chip3.device(sycl_device) = gpu_tensor.template chip<2l>(2l);
+  sycl_device.memcpyDeviceToHost(chip3.data(), gpu_data_chip3, chip3TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip3.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip3.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(chip3.dimension(2), sizeDim4);
+  VERIFY_IS_EQUAL(chip3.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim4; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2l, k, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip4TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip4(chip4TensorRange);
+  const size_t chip4TensorBuffSize = chip4.size() * sizeof(DataType);
+  DataType* gpu_data_chip4 = static_cast<DataType*>(sycl_device.allocate(chip4TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip4(gpu_data_chip4, chip4TensorRange);
+
+  gpu_chip4.device(sycl_device) = gpu_tensor.template chip<3l>(5l);
+  sycl_device.memcpyDeviceToHost(chip4.data(), gpu_data_chip4, chip4TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip4.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip4.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(chip4.dimension(2), sizeDim3);
+  VERIFY_IS_EQUAL(chip4.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5l, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip5TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip5(chip5TensorRange);
+  const size_t chip5TensorBuffSize = chip5.size() * sizeof(DataType);
+  DataType* gpu_data_chip5 = static_cast<DataType*>(sycl_device.allocate(chip5TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip5(gpu_data_chip5, chip5TensorRange);
+
+  gpu_chip5.device(sycl_device) = gpu_tensor.template chip<4l>(7l);
+  sycl_device.memcpyDeviceToHost(chip5.data(), gpu_data_chip5, chip5TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip5.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip5.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(chip5.dimension(2), sizeDim3);
+  VERIFY_IS_EQUAL(chip5.dimension(3), sizeDim4);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        for (IndexType l = 0; l < sizeDim4; ++l) {
+          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7l));
+        }
+      }
+    }
+  }
+
+  sycl_device.deallocate(gpu_data_tensor);
+  sycl_device.deallocate(gpu_data_chip1);
+  sycl_device.deallocate(gpu_data_chip2);
+  sycl_device.deallocate(gpu_data_chip3);
+  sycl_device.deallocate(gpu_data_chip4);
+  sycl_device.deallocate(gpu_data_chip5);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_dynamic_chip_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  IndexType sizeDim5 = 11;
+
+  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+  array<IndexType, 4> chip1TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+
+  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> chip1(chip1TensorRange);
+
+  tensor.setRandom();
+
+  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
+  const size_t chip1TensorBuffSize = chip1.size() * sizeof(DataType);
+  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_chip1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
+
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip1(gpu_data_chip1, chip1TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
+  gpu_chip1.device(sycl_device) = gpu_tensor.chip(1l, 0l);
+  sycl_device.memcpyDeviceToHost(chip1.data(), gpu_data_chip1, chip1TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip1.dimension(0), sizeDim2);
+  VERIFY_IS_EQUAL(chip1.dimension(1), sizeDim3);
+  VERIFY_IS_EQUAL(chip1.dimension(2), sizeDim4);
+  VERIFY_IS_EQUAL(chip1.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim2; ++i) {
+    for (IndexType j = 0; j < sizeDim3; ++j) {
+      for (IndexType k = 0; k < sizeDim4; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1l, i, j, k, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip2TensorRange = {{sizeDim1, sizeDim3, sizeDim4, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip2(chip2TensorRange);
+  const size_t chip2TensorBuffSize = chip2.size() * sizeof(DataType);
+  DataType* gpu_data_chip2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip2(gpu_data_chip2, chip2TensorRange);
+
+  gpu_chip2.device(sycl_device) = gpu_tensor.chip(1l, 1l);
+  sycl_device.memcpyDeviceToHost(chip2.data(), gpu_data_chip2, chip2TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip2.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip2.dimension(1), sizeDim3);
+  VERIFY_IS_EQUAL(chip2.dimension(2), sizeDim4);
+  VERIFY_IS_EQUAL(chip2.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim3; ++j) {
+      for (IndexType k = 0; k < sizeDim4; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1l, j, k, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip3TensorRange = {{sizeDim1, sizeDim2, sizeDim4, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip3(chip3TensorRange);
+  const size_t chip3TensorBuffSize = chip3.size() * sizeof(DataType);
+  DataType* gpu_data_chip3 = static_cast<DataType*>(sycl_device.allocate(chip3TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip3(gpu_data_chip3, chip3TensorRange);
+
+  gpu_chip3.device(sycl_device) = gpu_tensor.chip(2l, 2l);
+  sycl_device.memcpyDeviceToHost(chip3.data(), gpu_data_chip3, chip3TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip3.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip3.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(chip3.dimension(2), sizeDim4);
+  VERIFY_IS_EQUAL(chip3.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim4; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2l, k, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip4TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip4(chip4TensorRange);
+  const size_t chip4TensorBuffSize = chip4.size() * sizeof(DataType);
+  DataType* gpu_data_chip4 = static_cast<DataType*>(sycl_device.allocate(chip4TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip4(gpu_data_chip4, chip4TensorRange);
+
+  gpu_chip4.device(sycl_device) = gpu_tensor.chip(5l, 3l);
+  sycl_device.memcpyDeviceToHost(chip4.data(), gpu_data_chip4, chip4TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip4.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip4.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(chip4.dimension(2), sizeDim3);
+  VERIFY_IS_EQUAL(chip4.dimension(3), sizeDim5);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        for (IndexType l = 0; l < sizeDim5; ++l) {
+          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5l, l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> chip5TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> chip5(chip5TensorRange);
+  const size_t chip5TensorBuffSize = chip5.size() * sizeof(DataType);
+  DataType* gpu_data_chip5 = static_cast<DataType*>(sycl_device.allocate(chip5TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip5(gpu_data_chip5, chip5TensorRange);
+
+  gpu_chip5.device(sycl_device) = gpu_tensor.chip(7l, 4l);
+  sycl_device.memcpyDeviceToHost(chip5.data(), gpu_data_chip5, chip5TensorBuffSize);
+
+  VERIFY_IS_EQUAL(chip5.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(chip5.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(chip5.dimension(2), sizeDim3);
+  VERIFY_IS_EQUAL(chip5.dimension(3), sizeDim4);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        for (IndexType l = 0; l < sizeDim4; ++l) {
+          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7l));
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_tensor);
+  sycl_device.deallocate(gpu_data_chip1);
+  sycl_device.deallocate(gpu_data_chip2);
+  sycl_device.deallocate(gpu_data_chip3);
+  sycl_device.deallocate(gpu_data_chip4);
+  sycl_device.deallocate(gpu_data_chip5);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_chip_in_expr(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  IndexType sizeDim5 = 11;
+
+  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+  array<IndexType, 4> chip1TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+
+  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
+
+  Tensor<DataType, 4, DataLayout, IndexType> chip1(chip1TensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> tensor1(chip1TensorRange);
+  tensor.setRandom();
+  tensor1.setRandom();
+
+  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
+  const size_t chip1TensorBuffSize = chip1.size() * sizeof(DataType);
+  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_chip1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
+  DataType* gpu_data_tensor1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
+
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip1(gpu_data_chip1, chip1TensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_tensor1(gpu_data_tensor1, chip1TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
+  sycl_device.memcpyHostToDevice(gpu_data_tensor1, tensor1.data(), chip1TensorBuffSize);
+  gpu_chip1.device(sycl_device) = gpu_tensor.template chip<0l>(0l) + gpu_tensor1;
+  sycl_device.memcpyDeviceToHost(chip1.data(), gpu_data_chip1, chip1TensorBuffSize);
+
+  for (int i = 0; i < sizeDim2; ++i) {
+    for (int j = 0; j < sizeDim3; ++j) {
+      for (int k = 0; k < sizeDim4; ++k) {
+        for (int l = 0; l < sizeDim5; ++l) {
+          float expected = tensor(0l, i, j, k, l) + tensor1(i, j, k, l);
+          VERIFY_IS_EQUAL(chip1(i, j, k, l), expected);
+        }
+      }
+    }
+  }
+
+  array<IndexType, 3> chip2TensorRange = {{sizeDim2, sizeDim4, sizeDim5}};
+  Tensor<DataType, 3, DataLayout, IndexType> tensor2(chip2TensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> chip2(chip2TensorRange);
+  tensor2.setRandom();
+  const size_t chip2TensorBuffSize = tensor2.size() * sizeof(DataType);
+  DataType* gpu_data_tensor2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
+  DataType* gpu_data_chip2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_tensor2(gpu_data_tensor2, chip2TensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_chip2(gpu_data_chip2, chip2TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_tensor2, tensor2.data(), chip2TensorBuffSize);
+  gpu_chip2.device(sycl_device) = gpu_tensor.template chip<0l>(0l).template chip<1l>(2l) + gpu_tensor2;
+  sycl_device.memcpyDeviceToHost(chip2.data(), gpu_data_chip2, chip2TensorBuffSize);
+
+  for (int i = 0; i < sizeDim2; ++i) {
+    for (int j = 0; j < sizeDim4; ++j) {
+      for (int k = 0; k < sizeDim5; ++k) {
+        float expected = tensor(0l, i, 2l, j, k) + tensor2(i, j, k);
+        VERIFY_IS_EQUAL(chip2(i, j, k), expected);
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_tensor);
+  sycl_device.deallocate(gpu_data_tensor1);
+  sycl_device.deallocate(gpu_data_chip1);
+  sycl_device.deallocate(gpu_data_tensor2);
+  sycl_device.deallocate(gpu_data_chip2);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_chip_as_lvalue_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  IndexType sizeDim5 = 11;
+
+  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+  array<IndexType, 4> input2TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+
+  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 5, DataLayout, IndexType> input1(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> input2(input2TensorRange);
+  input1.setRandom();
+  input2.setRandom();
+
+  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
+  const size_t input2TensorBuffSize = input2.size() * sizeof(DataType);
+  std::cout << tensorBuffSize << " , " << input2TensorBuffSize << std::endl;
+  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_input1 = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_input2 = static_cast<DataType*>(sycl_device.allocate(input2TensorBuffSize));
+
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_input1(gpu_data_input1, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input2(gpu_data_input2, input2TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_input1, input1.data(), tensorBuffSize);
+  gpu_tensor.device(sycl_device) = gpu_input1;
+  sycl_device.memcpyHostToDevice(gpu_data_input2, input2.data(), input2TensorBuffSize);
+  gpu_tensor.template chip<0l>(1l).device(sycl_device) = gpu_input2;
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
+
+  for (int i = 0; i < sizeDim1; ++i) {
+    for (int j = 0; j < sizeDim2; ++j) {
+      for (int k = 0; k < sizeDim3; ++k) {
+        for (int l = 0; l < sizeDim4; ++l) {
+          for (int m = 0; m < sizeDim5; ++m) {
+            if (i != 1) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input2(j, k, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  gpu_tensor.device(sycl_device) = gpu_input1;
+  array<IndexType, 4> input3TensorRange = {{sizeDim1, sizeDim3, sizeDim4, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> input3(input3TensorRange);
+  input3.setRandom();
+
+  const size_t input3TensorBuffSize = input3.size() * sizeof(DataType);
+  DataType* gpu_data_input3 = static_cast<DataType*>(sycl_device.allocate(input3TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input3(gpu_data_input3, input3TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_input3, input3.data(), input3TensorBuffSize);
+  gpu_tensor.template chip<1l>(1l).device(sycl_device) = gpu_input3;
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
+
+  for (int i = 0; i < sizeDim1; ++i) {
+    for (int j = 0; j < sizeDim2; ++j) {
+      for (int k = 0; k < sizeDim3; ++k) {
+        for (int l = 0; l < sizeDim4; ++l) {
+          for (int m = 0; m < sizeDim5; ++m) {
+            if (j != 1) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input3(i, k, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  gpu_tensor.device(sycl_device) = gpu_input1;
+  array<IndexType, 4> input4TensorRange = {{sizeDim1, sizeDim2, sizeDim4, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> input4(input4TensorRange);
+  input4.setRandom();
+
+  const size_t input4TensorBuffSize = input4.size() * sizeof(DataType);
+  DataType* gpu_data_input4 = static_cast<DataType*>(sycl_device.allocate(input4TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input4(gpu_data_input4, input4TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_input4, input4.data(), input4TensorBuffSize);
+  gpu_tensor.template chip<2l>(3l).device(sycl_device) = gpu_input4;
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
+
+  for (int i = 0; i < sizeDim1; ++i) {
+    for (int j = 0; j < sizeDim2; ++j) {
+      for (int k = 0; k < sizeDim3; ++k) {
+        for (int l = 0; l < sizeDim4; ++l) {
+          for (int m = 0; m < sizeDim5; ++m) {
+            if (k != 3) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input4(i, j, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  gpu_tensor.device(sycl_device) = gpu_input1;
+  array<IndexType, 4> input5TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim5}};
+  Tensor<DataType, 4, DataLayout, IndexType> input5(input5TensorRange);
+  input5.setRandom();
+
+  const size_t input5TensorBuffSize = input5.size() * sizeof(DataType);
+  DataType* gpu_data_input5 = static_cast<DataType*>(sycl_device.allocate(input5TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input5(gpu_data_input5, input5TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_input5, input5.data(), input5TensorBuffSize);
+  gpu_tensor.template chip<3l>(4l).device(sycl_device) = gpu_input5;
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
+
+  for (int i = 0; i < sizeDim1; ++i) {
+    for (int j = 0; j < sizeDim2; ++j) {
+      for (int k = 0; k < sizeDim3; ++k) {
+        for (int l = 0; l < sizeDim4; ++l) {
+          for (int m = 0; m < sizeDim5; ++m) {
+            if (l != 4) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input5(i, j, k, m));
+            }
+          }
+        }
+      }
+    }
+  }
+  gpu_tensor.device(sycl_device) = gpu_input1;
+  array<IndexType, 4> input6TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> input6(input6TensorRange);
+  input6.setRandom();
+
+  const size_t input6TensorBuffSize = input6.size() * sizeof(DataType);
+  DataType* gpu_data_input6 = static_cast<DataType*>(sycl_device.allocate(input6TensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input6(gpu_data_input6, input6TensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_input6, input6.data(), input6TensorBuffSize);
+  gpu_tensor.template chip<4l>(5l).device(sycl_device) = gpu_input6;
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
+
+  for (int i = 0; i < sizeDim1; ++i) {
+    for (int j = 0; j < sizeDim2; ++j) {
+      for (int k = 0; k < sizeDim3; ++k) {
+        for (int l = 0; l < sizeDim4; ++l) {
+          for (int m = 0; m < sizeDim5; ++m) {
+            if (m != 5) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input6(i, j, k, l));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  gpu_tensor.device(sycl_device) = gpu_input1;
+  Tensor<DataType, 5, DataLayout, IndexType> input7(tensorRange);
+  input7.setRandom();
+
+  DataType* gpu_data_input7 = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_input7(gpu_data_input7, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_input7, input7.data(), tensorBuffSize);
+  gpu_tensor.chip(0l, 0l).device(sycl_device) = gpu_input7.chip(0l, 0l);
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
+
+  for (int i = 0; i < sizeDim1; ++i) {
+    for (int j = 0; j < sizeDim2; ++j) {
+      for (int k = 0; k < sizeDim3; ++k) {
+        for (int l = 0; l < sizeDim4; ++l) {
+          for (int m = 0; m < sizeDim5; ++m) {
+            if (i != 0) {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
+            } else {
+              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input7(i, j, k, l, m));
+            }
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_tensor);
+  sycl_device.deallocate(gpu_data_input1);
+  sycl_device.deallocate(gpu_data_input2);
+  sycl_device.deallocate(gpu_data_input3);
+  sycl_device.deallocate(gpu_data_input4);
+  sycl_device.deallocate(gpu_data_input5);
+  sycl_device.deallocate(gpu_data_input6);
+  sycl_device.deallocate(gpu_data_input7);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_chipping_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  /* test_static_chip_sycl<DataType, RowMajor, int64_t>(sycl_device);
+   test_static_chip_sycl<DataType, ColMajor, int64_t>(sycl_device);
+   test_dynamic_chip_sycl<DataType, RowMajor, int64_t>(sycl_device);
+   test_dynamic_chip_sycl<DataType, ColMajor, int64_t>(sycl_device);
+   test_chip_in_expr<DataType, RowMajor, int64_t>(sycl_device);
+   test_chip_in_expr<DataType, ColMajor, int64_t>(sycl_device);*/
+  test_chip_as_lvalue_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  // test_chip_as_lvalue_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_chipping_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_chipping_test_per_device<float>(device));
+    CALL_SUBTEST(sycl_chipping_test_per_device<half>(device));
+  }
+}
diff --git a/contrib/test/tensor_comparisons.cpp b/contrib/test/tensor_comparisons.cpp
new file mode 100644
index 0000000..bf145c3
--- /dev/null
+++ b/contrib/test/tensor_comparisons.cpp
@@ -0,0 +1,210 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+using Scalar = float;
+
+using TypedLTOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT, true>;
+using TypedLEOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE, true>;
+using TypedGTOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT, true>;
+using TypedGEOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE, true>;
+using TypedEQOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ, true>;
+using TypedNEOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ, true>;
+
+static void test_orderings() {
+  Tensor<Scalar, 3> mat1(2, 3, 7);
+  Tensor<Scalar, 3> mat2(2, 3, 7);
+
+  mat1.setRandom();
+  mat2.setRandom();
+
+  Tensor<bool, 3> lt(2, 3, 7);
+  Tensor<bool, 3> le(2, 3, 7);
+  Tensor<bool, 3> gt(2, 3, 7);
+  Tensor<bool, 3> ge(2, 3, 7);
+
+  Tensor<Scalar, 3> typed_lt(2, 3, 7);
+  Tensor<Scalar, 3> typed_le(2, 3, 7);
+  Tensor<Scalar, 3> typed_gt(2, 3, 7);
+  Tensor<Scalar, 3> typed_ge(2, 3, 7);
+
+  lt = mat1 < mat2;
+  le = mat1 <= mat2;
+  gt = mat1 > mat2;
+  ge = mat1 >= mat2;
+
+  typed_lt = mat1.binaryExpr(mat2, TypedLTOp());
+  typed_le = mat1.binaryExpr(mat2, TypedLEOp());
+  typed_gt = mat1.binaryExpr(mat2, TypedGTOp());
+  typed_ge = mat1.binaryExpr(mat2, TypedGEOp());
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(lt(i, j, k), mat1(i, j, k) < mat2(i, j, k));
+        VERIFY_IS_EQUAL(le(i, j, k), mat1(i, j, k) <= mat2(i, j, k));
+        VERIFY_IS_EQUAL(gt(i, j, k), mat1(i, j, k) > mat2(i, j, k));
+        VERIFY_IS_EQUAL(ge(i, j, k), mat1(i, j, k) >= mat2(i, j, k));
+
+        VERIFY_IS_EQUAL(lt(i, j, k), (bool)typed_lt(i, j, k));
+        VERIFY_IS_EQUAL(le(i, j, k), (bool)typed_le(i, j, k));
+        VERIFY_IS_EQUAL(gt(i, j, k), (bool)typed_gt(i, j, k));
+        VERIFY_IS_EQUAL(ge(i, j, k), (bool)typed_ge(i, j, k));
+      }
+    }
+  }
+}
+
+static void test_equality() {
+  Tensor<Scalar, 3> mat1(2, 3, 7);
+  Tensor<Scalar, 3> mat2(2, 3, 7);
+
+  mat1.setRandom();
+  mat2.setRandom();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        if (internal::random<bool>()) {
+          mat2(i, j, k) = mat1(i, j, k);
+        }
+      }
+    }
+  }
+
+  Tensor<bool, 3> eq(2, 3, 7);
+  Tensor<bool, 3> ne(2, 3, 7);
+
+  Tensor<Scalar, 3> typed_eq(2, 3, 7);
+  Tensor<Scalar, 3> typed_ne(2, 3, 7);
+
+  eq = (mat1 == mat2);
+  ne = (mat1 != mat2);
+
+  typed_eq = mat1.binaryExpr(mat2, TypedEQOp());
+  typed_ne = mat1.binaryExpr(mat2, TypedNEOp());
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(eq(i, j, k), mat1(i, j, k) == mat2(i, j, k));
+        VERIFY_IS_EQUAL(ne(i, j, k), mat1(i, j, k) != mat2(i, j, k));
+
+        VERIFY_IS_EQUAL(eq(i, j, k), (bool)typed_eq(i, j, k));
+        VERIFY_IS_EQUAL(ne(i, j, k), (bool)typed_ne(i, j, k));
+      }
+    }
+  }
+}
+
+static void test_isnan() {
+  Tensor<Scalar, 3> mat(2, 3, 7);
+
+  mat.setRandom();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        if (internal::random<bool>()) {
+          mat(i, j, k) = std::numeric_limits<Scalar>::quiet_NaN();
+        }
+      }
+    }
+  }
+  Tensor<bool, 3> nan(2, 3, 7);
+  nan = (mat.isnan)();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(nan(i, j, k), (std::isnan)(mat(i, j, k)));
+      }
+    }
+  }
+}
+
+static void test_isinf() {
+  Tensor<Scalar, 3> mat(2, 3, 7);
+
+  mat.setRandom();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        if (internal::random<bool>()) {
+          mat(i, j, k) = std::numeric_limits<Scalar>::infinity();
+        }
+      }
+    }
+  }
+  Tensor<bool, 3> inf(2, 3, 7);
+  inf = (mat.isinf)();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(inf(i, j, k), (std::isinf)(mat(i, j, k)));
+      }
+    }
+  }
+}
+
+static void test_isfinite() {
+  Tensor<Scalar, 3> mat(2, 3, 7);
+
+  mat.setRandom();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        if (internal::random<bool>()) {
+          mat(i, j, k) = std::numeric_limits<Scalar>::infinity();
+        }
+        if (internal::random<bool>()) {
+          mat(i, j, k) = std::numeric_limits<Scalar>::quiet_NaN();
+        }
+      }
+    }
+  }
+  Tensor<bool, 3> inf(2, 3, 7);
+  inf = (mat.isfinite)();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(inf(i, j, k), (std::isfinite)(mat(i, j, k)));
+      }
+    }
+  }
+}
+
+// Integer scalars have no NaN or infinity; every value must classify as finite, including
+// |x| >= 2^30, whose bit pattern the vectorized predicates used to misread as infinity.
+static void test_predicates_integer() {
+  Tensor<int, 1> mat(8);
+  mat.setValues({0, 1, -1, 1 << 30, -(1 << 30), 2147483647, -2147483647 - 1, 42});
+  Tensor<bool, 1> nan(8), inf(8), finite(8);
+  nan = (mat.isnan)();
+  inf = (mat.isinf)();
+  finite = (mat.isfinite)();
+  for (int i = 0; i < 8; ++i) {
+    VERIFY(!nan(i));
+    VERIFY(!inf(i));
+    VERIFY(finite(i));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_comparisons) {
+  CALL_SUBTEST(test_orderings());
+  CALL_SUBTEST(test_equality());
+  CALL_SUBTEST(test_isnan());
+  CALL_SUBTEST(test_isinf());
+  CALL_SUBTEST(test_isfinite());
+  CALL_SUBTEST(test_predicates_integer());
+}
diff --git a/contrib/test/tensor_complex_cwise_ops_gpu.cu b/contrib/test/tensor_complex_cwise_ops_gpu.cu
new file mode 100644
index 0000000..f99440b
--- /dev/null
+++ b/contrib/test/tensor_complex_cwise_ops_gpu.cu
@@ -0,0 +1,91 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename T>
+void test_cuda_complex_cwise_ops() {
+  const int kNumItems = 2;
+  std::size_t complex_bytes = kNumItems * sizeof(std::complex<T>);
+
+  std::complex<T>* d_in1;
+  std::complex<T>* d_in2;
+  std::complex<T>* d_out;
+  cudaMalloc((void**)(&d_in1), complex_bytes);
+  cudaMalloc((void**)(&d_in2), complex_bytes);
+  cudaMalloc((void**)(&d_out), complex_bytes);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<std::complex<T>, 1, 0, int>, Eigen::Aligned> gpu_in1(d_in1, kNumItems);
+  Eigen::TensorMap<Eigen::Tensor<std::complex<T>, 1, 0, int>, Eigen::Aligned> gpu_in2(d_in2, kNumItems);
+  Eigen::TensorMap<Eigen::Tensor<std::complex<T>, 1, 0, int>, Eigen::Aligned> gpu_out(d_out, kNumItems);
+
+  const std::complex<T> a(static_cast<T>(3.14), static_cast<T>(2.7));
+  const std::complex<T> b(static_cast<T>(-10.6), static_cast<T>(1.4));
+
+  gpu_in1.device(gpu_device) = gpu_in1.constant(a);
+  gpu_in2.device(gpu_device) = gpu_in2.constant(b);
+
+  enum CwiseOp { Add = 0, Sub, Mul, Div, Neg, NbOps };
+
+  Tensor<std::complex<T>, 1, 0, int> actual(kNumItems);
+  for (int op = Add; op < NbOps; op++) {
+    std::complex<T> expected;
+    switch (static_cast<CwiseOp>(op)) {
+      case Add:
+        gpu_out.device(gpu_device) = gpu_in1 + gpu_in2;
+        expected = a + b;
+        break;
+      case Sub:
+        gpu_out.device(gpu_device) = gpu_in1 - gpu_in2;
+        expected = a - b;
+        break;
+      case Mul:
+        gpu_out.device(gpu_device) = gpu_in1 * gpu_in2;
+        expected = a * b;
+        break;
+      case Div:
+        gpu_out.device(gpu_device) = gpu_in1 / gpu_in2;
+        expected = a / b;
+        break;
+      case Neg:
+        gpu_out.device(gpu_device) = -gpu_in1;
+        expected = -a;
+        break;
+      case NbOps:
+        break;
+    }
+    assert(cudaMemcpyAsync(actual.data(), d_out, complex_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) ==
+           cudaSuccess);
+    assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
+
+    for (int i = 0; i < kNumItems; ++i) {
+      VERIFY_IS_APPROX(actual(i), expected);
+    }
+  }
+
+  cudaFree(d_in1);
+  cudaFree(d_in2);
+  cudaFree(d_out);
+}
+
+EIGEN_DECLARE_TEST(test_tensor_complex_cwise_ops) {
+  CALL_SUBTEST(test_cuda_complex_cwise_ops<float>());
+  CALL_SUBTEST(test_cuda_complex_cwise_ops<double>());
+}
diff --git a/contrib/test/tensor_complex_gpu.cu b/contrib/test/tensor_complex_gpu.cu
new file mode 100644
index 0000000..3777383
--- /dev/null
+++ b/contrib/test/tensor_complex_gpu.cu
@@ -0,0 +1,177 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+void test_cuda_nullary() {
+  Tensor<std::complex<float>, 1, 0, int> in1(2);
+  Tensor<std::complex<float>, 1, 0, int> in2(2);
+  in1.setRandom();
+  in2.setRandom();
+
+  std::size_t float_bytes = in1.size() * sizeof(float);
+  std::size_t complex_bytes = in1.size() * sizeof(std::complex<float>);
+
+  std::complex<float>* d_in1;
+  std::complex<float>* d_in2;
+  float* d_out2;
+  cudaMalloc((void**)(&d_in1), complex_bytes);
+  cudaMalloc((void**)(&d_in2), complex_bytes);
+  cudaMalloc((void**)(&d_out2), float_bytes);
+  cudaMemcpy(d_in1, in1.data(), complex_bytes, cudaMemcpyHostToDevice);
+  cudaMemcpy(d_in2, in2.data(), complex_bytes, cudaMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<std::complex<float>, 1, 0, int>, Eigen::Aligned> gpu_in1(d_in1, 2);
+  Eigen::TensorMap<Eigen::Tensor<std::complex<float>, 1, 0, int>, Eigen::Aligned> gpu_in2(d_in2, 2);
+  Eigen::TensorMap<Eigen::Tensor<float, 1, 0, int>, Eigen::Aligned> gpu_out2(d_out2, 2);
+
+  gpu_in1.device(gpu_device) = gpu_in1.constant(std::complex<float>(3.14f, 2.7f));
+  gpu_out2.device(gpu_device) = gpu_in2.abs();
+
+  Tensor<std::complex<float>, 1, 0, int> new1(2);
+  Tensor<float, 1, 0, int> new2(2);
+
+  assert(cudaMemcpyAsync(new1.data(), d_in1, complex_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) ==
+         cudaSuccess);
+  assert(cudaMemcpyAsync(new2.data(), d_out2, float_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
+
+  assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
+
+  for (int i = 0; i < 2; ++i) {
+    VERIFY_IS_APPROX(new1(i), std::complex<float>(3.14f, 2.7f));
+    VERIFY_IS_APPROX(new2(i), std::abs(in2(i)));
+  }
+
+  cudaFree(d_in1);
+  cudaFree(d_in2);
+  cudaFree(d_out2);
+}
+
+static void test_cuda_sum_reductions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  const int num_rows = internal::random<int>(1024, 5 * 1024);
+  const int num_cols = internal::random<int>(1024, 5 * 1024);
+
+  Tensor<std::complex<float>, 2> in(num_rows, num_cols);
+  in.setRandom();
+
+  Tensor<std::complex<float>, 0> full_redux;
+  full_redux = in.sum();
+
+  std::size_t in_bytes = in.size() * sizeof(std::complex<float>);
+  std::size_t out_bytes = full_redux.size() * sizeof(std::complex<float>);
+  std::complex<float>* gpu_in_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(in_bytes));
+  std::complex<float>* gpu_out_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(out_bytes));
+  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
+
+  TensorMap<Tensor<std::complex<float>, 2> > in_gpu(gpu_in_ptr, num_rows, num_cols);
+  TensorMap<Tensor<std::complex<float>, 0> > out_gpu(gpu_out_ptr);
+
+  out_gpu.device(gpu_device) = in_gpu.sum();
+
+  Tensor<std::complex<float>, 0> full_redux_gpu;
+  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
+  gpu_device.synchronize();
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
+
+  gpu_device.deallocate(gpu_in_ptr);
+  gpu_device.deallocate(gpu_out_ptr);
+}
+
+static void test_cuda_mean_reductions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  const int num_rows = internal::random<int>(1024, 5 * 1024);
+  const int num_cols = internal::random<int>(1024, 5 * 1024);
+
+  Tensor<std::complex<float>, 2> in(num_rows, num_cols);
+  in.setRandom();
+
+  Tensor<std::complex<float>, 0> full_redux;
+  full_redux = in.mean();
+
+  std::size_t in_bytes = in.size() * sizeof(std::complex<float>);
+  std::size_t out_bytes = full_redux.size() * sizeof(std::complex<float>);
+  std::complex<float>* gpu_in_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(in_bytes));
+  std::complex<float>* gpu_out_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(out_bytes));
+  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
+
+  TensorMap<Tensor<std::complex<float>, 2> > in_gpu(gpu_in_ptr, num_rows, num_cols);
+  TensorMap<Tensor<std::complex<float>, 0> > out_gpu(gpu_out_ptr);
+
+  out_gpu.device(gpu_device) = in_gpu.mean();
+
+  Tensor<std::complex<float>, 0> full_redux_gpu;
+  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
+  gpu_device.synchronize();
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
+
+  gpu_device.deallocate(gpu_in_ptr);
+  gpu_device.deallocate(gpu_out_ptr);
+}
+
+static void test_cuda_product_reductions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  const int num_rows = internal::random<int>(1024, 5 * 1024);
+  const int num_cols = internal::random<int>(1024, 5 * 1024);
+
+  Tensor<std::complex<float>, 2> in(num_rows, num_cols);
+  in.setRandom();
+
+  Tensor<std::complex<float>, 0> full_redux;
+  full_redux = in.prod();
+
+  std::size_t in_bytes = in.size() * sizeof(std::complex<float>);
+  std::size_t out_bytes = full_redux.size() * sizeof(std::complex<float>);
+  std::complex<float>* gpu_in_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(in_bytes));
+  std::complex<float>* gpu_out_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(out_bytes));
+  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
+
+  TensorMap<Tensor<std::complex<float>, 2> > in_gpu(gpu_in_ptr, num_rows, num_cols);
+  TensorMap<Tensor<std::complex<float>, 0> > out_gpu(gpu_out_ptr);
+
+  out_gpu.device(gpu_device) = in_gpu.prod();
+
+  Tensor<std::complex<float>, 0> full_redux_gpu;
+  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
+  gpu_device.synchronize();
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
+
+  gpu_device.deallocate(gpu_in_ptr);
+  gpu_device.deallocate(gpu_out_ptr);
+}
+
+EIGEN_DECLARE_TEST(test_tensor_complex) {
+  CALL_SUBTEST(test_cuda_nullary());
+  CALL_SUBTEST(test_cuda_sum_reductions());
+  CALL_SUBTEST(test_cuda_mean_reductions());
+  CALL_SUBTEST(test_cuda_product_reductions());
+}
diff --git a/contrib/test/tensor_concatenation.cpp b/contrib/test/tensor_concatenation.cpp
new file mode 100644
index 0000000..b17ee4a
--- /dev/null
+++ b/contrib/test/tensor_concatenation.cpp
@@ -0,0 +1,268 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <complex>
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_dimension_failures() {
+  Tensor<int, 3, DataLayout> left(2, 3, 1);
+  Tensor<int, 3, DataLayout> right(3, 3, 1);
+  left.setRandom();
+  right.setRandom();
+
+  // Okay; other dimensions are equal.
+  Tensor<int, 3, DataLayout> concatenation = left.concatenate(right, 0);
+
+  // Dimension mismatches.
+  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, 1));
+  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, 2));
+
+  // Axis > NumDims or < 0.
+  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, 3));
+  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, -1));
+}
+
+template <int DataLayout>
+static void test_static_dimension_failure() {
+  Tensor<int, 2, DataLayout> left(2, 3);
+  Tensor<int, 3, DataLayout> right(2, 3, 1);
+  left.setRandom();
+  right.setRandom();
+
+  // TensorConcatenationOp requires both operands to have the same static rank.
+  // To join tensors of different ranks, reshape one of the operands at the
+  // call site; both directions are exercised here.
+  Tensor<int, 3, DataLayout> concatenation = left.reshape(Tensor<int, 3>::Dimensions(2, 3, 1)).concatenate(right, 0);
+  Tensor<int, 2, DataLayout> alternative = left.concatenate(right.reshape(Tensor<int, 2>::Dimensions(2, 3)), 0);
+}
+
+template <int DataLayout>
+static void test_simple_concatenation() {
+  Tensor<int, 3, DataLayout> left(2, 3, 1);
+  Tensor<int, 3, DataLayout> right(2, 3, 1);
+  left.setRandom();
+  right.setRandom();
+
+  Tensor<int, 3, DataLayout> concatenation = left.concatenate(right, 0);
+  VERIFY_IS_EQUAL(concatenation.dimension(0), 4);
+  VERIFY_IS_EQUAL(concatenation.dimension(1), 3);
+  VERIFY_IS_EQUAL(concatenation.dimension(2), 1);
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) {
+      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
+    }
+    for (int i = 2; i < 4; ++i) {
+      VERIFY_IS_EQUAL(concatenation(i, j, 0), right(i - 2, j, 0));
+    }
+  }
+
+  concatenation = left.concatenate(right, 1);
+  VERIFY_IS_EQUAL(concatenation.dimension(0), 2);
+  VERIFY_IS_EQUAL(concatenation.dimension(1), 6);
+  VERIFY_IS_EQUAL(concatenation.dimension(2), 1);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
+    }
+    for (int j = 3; j < 6; ++j) {
+      VERIFY_IS_EQUAL(concatenation(i, j, 0), right(i, j - 3, 0));
+    }
+  }
+
+  concatenation = left.concatenate(right, 2);
+  VERIFY_IS_EQUAL(concatenation.dimension(0), 2);
+  VERIFY_IS_EQUAL(concatenation.dimension(1), 3);
+  VERIFY_IS_EQUAL(concatenation.dimension(2), 2);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
+      VERIFY_IS_EQUAL(concatenation(i, j, 1), right(i, j, 0));
+    }
+  }
+}
+
+// Exercise the packet() fast path when the concat axis is not the innermost
+// dim and the inner dim is small enough that a packet load spans multiple
+// rows -- including rows that fall on the right side of the boundary. The
+// guard in packet() must reject this case and fall back to scalars.
+template <int DataLayout>
+static void test_concatenation_packet_axis_not_innermost() {
+  // Output shape (8, 6, 1) with concat along axis 1: each packet load whose
+  // first/last linear indices land on the left side will sweep through right
+  // rows in between unless the fast path is correctly guarded.
+  Tensor<float, 3, DataLayout> left(8, 3, 1);
+  Tensor<float, 3, DataLayout> right(8, 3, 1);
+  left.setRandom();
+  right.setRandom();
+
+  Tensor<float, 3, DataLayout> concatenation = left.concatenate(right, 1);
+  VERIFY_IS_EQUAL(concatenation.dimension(0), 8);
+  VERIFY_IS_EQUAL(concatenation.dimension(1), 6);
+  VERIFY_IS_EQUAL(concatenation.dimension(2), 1);
+  for (int i = 0; i < 8; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
+      VERIFY_IS_EQUAL(concatenation(i, j + 3, 0), right(i, j, 0));
+    }
+  }
+
+  // Force evaluation through the packet path with a coefficient-wise op so
+  // the executor will request packets aligned to the output strides.
+  Tensor<float, 3, DataLayout> doubled = concatenation * concatenation.constant(2.0f);
+  for (int i = 0; i < 8; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_APPROX(doubled(i, j, 0), 2.0f * left(i, j, 0));
+      VERIFY_IS_APPROX(doubled(i, j + 3, 0), 2.0f * right(i, j, 0));
+    }
+  }
+}
+
+static void test_concatenation_as_lvalue() {
+  Tensor<int, 2> t1(2, 3);
+  Tensor<int, 2> t2(2, 3);
+  t1.setRandom();
+  t2.setRandom();
+
+  Tensor<int, 2> result(4, 3);
+  result.setRandom();
+  t1.concatenate(t2, 0) = result;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(t1(i, j), result(i, j));
+      VERIFY_IS_EQUAL(t2(i, j), result(i + 2, j));
+    }
+  }
+}
+
+// Assignments into a concatenation run through the tiled executor's
+// writeBlock, which splits each block at the concat axis. Unlike the
+// coeff/packet write path this is layout-generic, so the RowMajor
+// instantiation exercises a previously unsupported case.
+template <int DataLayout>
+static void test_concatenation_write_blocks() {
+  for (int axis = 0; axis < 3; ++axis) {
+    Eigen::DSizes<Eigen::Index, 3> left_dims(7, 5, 11);
+    Eigen::DSizes<Eigen::Index, 3> right_dims(left_dims);
+    right_dims[axis] = 4;
+    Eigen::DSizes<Eigen::Index, 3> dims(left_dims);
+    dims[axis] = left_dims[axis] + right_dims[axis];
+
+    Tensor<float, 3, DataLayout> left(left_dims);
+    Tensor<float, 3, DataLayout> right(right_dims);
+    Tensor<float, 3, DataLayout> src(dims);
+    src.setRandom();
+
+    // Materialized-block path: a plain tensor on the right-hand side.
+    left.setZero();
+    right.setZero();
+    left.concatenate(right, axis) = src;
+
+    // Lazy-block path: a cwise expression on the right-hand side.
+    Tensor<float, 3, DataLayout> left2(left_dims);
+    Tensor<float, 3, DataLayout> right2(right_dims);
+    left2.setZero();
+    right2.setZero();
+    left2.concatenate(right2, axis) = src * src.constant(2.0f);
+
+    for (Eigen::Index i = 0; i < dims[0]; ++i) {
+      for (Eigen::Index j = 0; j < dims[1]; ++j) {
+        for (Eigen::Index k = 0; k < dims[2]; ++k) {
+          Eigen::array<Eigen::Index, 3> coords = {{i, j, k}};
+          if (coords[axis] < left_dims[axis]) {
+            VERIFY_IS_EQUAL(left(coords), src(i, j, k));
+            VERIFY_IS_EQUAL(left2(coords), 2.0f * src(i, j, k));
+          } else {
+            coords[axis] -= left_dims[axis];
+            VERIFY_IS_EQUAL(right(coords), src(i, j, k));
+            VERIFY_IS_EQUAL(right2(coords), 2.0f * src(i, j, k));
+          }
+        }
+      }
+    }
+  }
+}
+
+// Regression tests: when a scalar-changing consumer (TensorCwiseUnaryOp,
+// TensorConversionOp) sits above concat in an assign, the assign forwards a
+// destination buffer sized for its *output* scalar (e.g. float in
+// `abs(complex)`, double in `int.cast<double>()`). Before the producer-side
+// fix in TensorCwiseUnaryOp::block / TensorConversionOp::block, concat's
+// prepareStorage would reuse that buffer as its own (different) scalar,
+// asserting in debug and corrupting output in release. These cases exercise
+// the block path with the consumer dropping the buffer.
+
+template <int DataLayout>
+static void test_complex_concatenation_through_abs() {
+  Tensor<std::complex<float>, 2, DataLayout> a(2, 3);
+  Tensor<std::complex<float>, 2, DataLayout> b(2, 3);
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) {
+      a(i, j) = std::complex<float>(static_cast<float>(i + 1), static_cast<float>(j + 1));
+      b(i, j) = std::complex<float>(static_cast<float>(i + 5), static_cast<float>(j + 2));
+    }
+  }
+
+  Tensor<float, 2, DataLayout> out(4, 3);
+  out = a.concatenate(b, 0).abs();
+
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) {
+      VERIFY_IS_APPROX(out(i, j), std::abs(a(i, j)));
+      VERIFY_IS_APPROX(out(i + 2, j), std::abs(b(i, j)));
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_concatenation_through_cast() {
+  Tensor<int, 2, DataLayout> a(2, 3);
+  Tensor<int, 2, DataLayout> b(2, 3);
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) {
+      a(i, j) = i + 1 + 10 * j;
+      b(i, j) = i + 5 + 10 * j;
+    }
+  }
+
+  Tensor<double, 2, DataLayout> out(4, 3);
+  out = a.concatenate(b, 0).template cast<double>();
+
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) {
+      VERIFY_IS_APPROX(out(i, j), static_cast<double>(a(i, j)));
+      VERIFY_IS_APPROX(out(i + 2, j), static_cast<double>(b(i, j)));
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_concatenation) {
+  CALL_SUBTEST(test_dimension_failures<ColMajor>());
+  CALL_SUBTEST(test_dimension_failures<RowMajor>());
+  CALL_SUBTEST(test_static_dimension_failure<ColMajor>());
+  CALL_SUBTEST(test_static_dimension_failure<RowMajor>());
+  CALL_SUBTEST(test_simple_concatenation<ColMajor>());
+  CALL_SUBTEST(test_simple_concatenation<RowMajor>());
+  CALL_SUBTEST(test_concatenation_packet_axis_not_innermost<ColMajor>());
+  CALL_SUBTEST(test_concatenation_packet_axis_not_innermost<RowMajor>());
+  CALL_SUBTEST(test_concatenation_as_lvalue());
+  CALL_SUBTEST(test_concatenation_write_blocks<ColMajor>());
+  CALL_SUBTEST(test_concatenation_write_blocks<RowMajor>());
+  CALL_SUBTEST(test_complex_concatenation_through_abs<ColMajor>());
+  CALL_SUBTEST(test_complex_concatenation_through_abs<RowMajor>());
+  CALL_SUBTEST(test_concatenation_through_cast<ColMajor>());
+  CALL_SUBTEST(test_concatenation_through_cast<RowMajor>());
+}
diff --git a/contrib/test/tensor_concatenation_sycl.cpp b/contrib/test/tensor_concatenation_sycl.cpp
new file mode 100644
index 0000000..31cd01f
--- /dev/null
+++ b/contrib/test/tensor_concatenation_sycl.cpp
@@ -0,0 +1,192 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_concatenation(const Eigen::SyclDevice& sycl_device) {
+  IndexType leftDim1 = 2;
+  IndexType leftDim2 = 3;
+  IndexType leftDim3 = 1;
+  Eigen::array<IndexType, 3> leftRange = {{leftDim1, leftDim2, leftDim3}};
+  IndexType rightDim1 = 2;
+  IndexType rightDim2 = 3;
+  IndexType rightDim3 = 1;
+  Eigen::array<IndexType, 3> rightRange = {{rightDim1, rightDim2, rightDim3}};
+
+  // IndexType concatDim1 = 3;
+  //	IndexType concatDim2 = 3;
+  //	IndexType concatDim3 = 1;
+  // Eigen::array<IndexType, 3> concatRange = {{concatDim1, concatDim2, concatDim3}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> left(leftRange);
+  Tensor<DataType, 3, DataLayout, IndexType> right(rightRange);
+  left.setRandom();
+  right.setRandom();
+
+  DataType* gpu_in1_data =
+      static_cast<DataType*>(sycl_device.allocate(left.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_in2_data =
+      static_cast<DataType*>(sycl_device.allocate(right.dimensions().TotalSize() * sizeof(DataType)));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, leftRange);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, rightRange);
+  sycl_device.memcpyHostToDevice(gpu_in1_data, left.data(), (left.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in2_data, right.data(), (right.dimensions().TotalSize()) * sizeof(DataType));
+  ///
+  Tensor<DataType, 3, DataLayout, IndexType> concatenation1(leftDim1 + rightDim1, leftDim2, leftDim3);
+  DataType* gpu_out_data1 =
+      static_cast<DataType*>(sycl_device.allocate(concatenation1.dimensions().TotalSize() * sizeof(DataType)));
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out1(gpu_out_data1,
+                                                                               concatenation1.dimensions());
+
+  // concatenation = left.concatenate(right, 0);
+  gpu_out1.device(sycl_device) = gpu_in1.concatenate(gpu_in2, 0);
+  sycl_device.memcpyDeviceToHost(concatenation1.data(), gpu_out_data1,
+                                 (concatenation1.dimensions().TotalSize()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(concatenation1.dimension(0), 4);
+  VERIFY_IS_EQUAL(concatenation1.dimension(1), 3);
+  VERIFY_IS_EQUAL(concatenation1.dimension(2), 1);
+  for (IndexType j = 0; j < 3; ++j) {
+    for (IndexType i = 0; i < 2; ++i) {
+      VERIFY_IS_EQUAL(concatenation1(i, j, 0), left(i, j, 0));
+    }
+    for (IndexType i = 2; i < 4; ++i) {
+      VERIFY_IS_EQUAL(concatenation1(i, j, 0), right(i - 2, j, 0));
+    }
+  }
+
+  sycl_device.deallocate(gpu_out_data1);
+  Tensor<DataType, 3, DataLayout, IndexType> concatenation2(leftDim1, leftDim2 + rightDim2, leftDim3);
+  DataType* gpu_out_data2 =
+      static_cast<DataType*>(sycl_device.allocate(concatenation2.dimensions().TotalSize() * sizeof(DataType)));
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out2(gpu_out_data2,
+                                                                               concatenation2.dimensions());
+  gpu_out2.device(sycl_device) = gpu_in1.concatenate(gpu_in2, 1);
+  sycl_device.memcpyDeviceToHost(concatenation2.data(), gpu_out_data2,
+                                 (concatenation2.dimensions().TotalSize()) * sizeof(DataType));
+
+  // concatenation = left.concatenate(right, 1);
+  VERIFY_IS_EQUAL(concatenation2.dimension(0), 2);
+  VERIFY_IS_EQUAL(concatenation2.dimension(1), 6);
+  VERIFY_IS_EQUAL(concatenation2.dimension(2), 1);
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(concatenation2(i, j, 0), left(i, j, 0));
+    }
+    for (IndexType j = 3; j < 6; ++j) {
+      VERIFY_IS_EQUAL(concatenation2(i, j, 0), right(i, j - 3, 0));
+    }
+  }
+  sycl_device.deallocate(gpu_out_data2);
+  Tensor<DataType, 3, DataLayout, IndexType> concatenation3(leftDim1, leftDim2, leftDim3 + rightDim3);
+  DataType* gpu_out_data3 =
+      static_cast<DataType*>(sycl_device.allocate(concatenation3.dimensions().TotalSize() * sizeof(DataType)));
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out3(gpu_out_data3,
+                                                                               concatenation3.dimensions());
+  gpu_out3.device(sycl_device) = gpu_in1.concatenate(gpu_in2, 2);
+  sycl_device.memcpyDeviceToHost(concatenation3.data(), gpu_out_data3,
+                                 (concatenation3.dimensions().TotalSize()) * sizeof(DataType));
+
+  // concatenation = left.concatenate(right, 2);
+  VERIFY_IS_EQUAL(concatenation3.dimension(0), 2);
+  VERIFY_IS_EQUAL(concatenation3.dimension(1), 3);
+  VERIFY_IS_EQUAL(concatenation3.dimension(2), 2);
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(concatenation3(i, j, 0), left(i, j, 0));
+      VERIFY_IS_EQUAL(concatenation3(i, j, 1), right(i, j, 0));
+    }
+  }
+  sycl_device.deallocate(gpu_out_data3);
+  sycl_device.deallocate(gpu_in1_data);
+  sycl_device.deallocate(gpu_in2_data);
+}
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_concatenation_as_lvalue(const Eigen::SyclDevice& sycl_device) {
+  IndexType leftDim1 = 2;
+  IndexType leftDim2 = 3;
+  Eigen::array<IndexType, 2> leftRange = {{leftDim1, leftDim2}};
+
+  IndexType rightDim1 = 2;
+  IndexType rightDim2 = 3;
+  Eigen::array<IndexType, 2> rightRange = {{rightDim1, rightDim2}};
+
+  IndexType concatDim1 = 4;
+  IndexType concatDim2 = 3;
+  Eigen::array<IndexType, 2> resRange = {{concatDim1, concatDim2}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> left(leftRange);
+  Tensor<DataType, 2, DataLayout, IndexType> right(rightRange);
+  Tensor<DataType, 2, DataLayout, IndexType> result(resRange);
+
+  left.setRandom();
+  right.setRandom();
+  result.setRandom();
+
+  DataType* gpu_in1_data =
+      static_cast<DataType*>(sycl_device.allocate(left.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_in2_data =
+      static_cast<DataType*>(sycl_device.allocate(right.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(result.dimensions().TotalSize() * sizeof(DataType)));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_in1(gpu_in1_data, leftRange);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_in2(gpu_in2_data, rightRange);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_out(gpu_out_data, resRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in1_data, left.data(), (left.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in2_data, right.data(), (right.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_out_data, result.data(), (result.dimensions().TotalSize()) * sizeof(DataType));
+
+  //  t1.concatenate(t2, 0) = result;
+  gpu_in1.concatenate(gpu_in2, 0).device(sycl_device) = gpu_out;
+  sycl_device.memcpyDeviceToHost(left.data(), gpu_in1_data, (left.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(right.data(), gpu_in2_data, (right.dimensions().TotalSize()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(left(i, j), result(i, j));
+      VERIFY_IS_EQUAL(right(i, j), result(i + 2, j));
+    }
+  }
+  sycl_device.deallocate(gpu_in1_data);
+  sycl_device.deallocate(gpu_in2_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, typename Dev_selector>
+void tensorConcat_perDevice(Dev_selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_concatenation<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_concatenation<DataType, ColMajor, int64_t>(sycl_device);
+  test_concatenation_as_lvalue<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_concatenation_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(tensorConcat_perDevice<half>(device));
+    CALL_SUBTEST(tensorConcat_perDevice<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_const.cpp b/contrib/test/tensor_const.cpp
new file mode 100644
index 0000000..5ee1ed6
--- /dev/null
+++ b/contrib/test/tensor_const.cpp
@@ -0,0 +1,57 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+using Eigen::Tensor;
+
+static void test_simple_assign() {
+  Tensor<int, 3> random(2, 3, 7);
+  random.setRandom();
+
+  TensorMap<Tensor<const int, 3> > constant(random.data(), 2, 3, 7);
+  Tensor<int, 3> result(2, 3, 7);
+  result = constant;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL((result(i, j, k)), random(i, j, k));
+      }
+    }
+  }
+}
+
+static void test_assign_of_const_tensor() {
+  Tensor<int, 3> random(2, 3, 7);
+  random.setRandom();
+
+  TensorMap<Tensor<const int, 3> > constant1(random.data(), 2, 3, 7);
+  TensorMap<const Tensor<int, 3> > constant2(random.data(), 2, 3, 7);
+  const TensorMap<Tensor<int, 3> > constant3(random.data(), 2, 3, 7);
+
+  Tensor<int, 2> result1 = constant1.chip(0, 2);
+  Tensor<int, 2> result2 = constant2.chip(0, 2);
+  Tensor<int, 2> result3 = constant3.chip(0, 2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL((result1(i, j)), random(i, j, 0));
+      VERIFY_IS_EQUAL((result2(i, j)), random(i, j, 0));
+      VERIFY_IS_EQUAL((result3(i, j)), random(i, j, 0));
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_const) {
+  CALL_SUBTEST(test_simple_assign());
+  CALL_SUBTEST(test_assign_of_const_tensor());
+}
diff --git a/contrib/test/tensor_contract_gpu.cu b/contrib/test/tensor_contract_gpu.cu
new file mode 100644
index 0000000..84dc3a5
--- /dev/null
+++ b/contrib/test/tensor_contract_gpu.cu
@@ -0,0 +1,324 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+// Copyright (C) 2014 Navdeep Jaitly <ndjaitly@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+typedef Tensor<float, 1>::DimensionPair DimPair;
+
+template <int DataLayout>
+void test_gpu_contraction(int m_size, int k_size, int n_size) {
+  Tensor<float, 2, DataLayout> t_left(m_size, k_size);
+  Tensor<float, 2, DataLayout> t_right(k_size, n_size);
+  Tensor<float, 2, DataLayout> t_result(m_size, n_size);
+  Tensor<float, 2, DataLayout> t_result_gpu(m_size, n_size);
+  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(float);
+  std::size_t t_right_bytes = t_right.size() * sizeof(float);
+  std::size_t t_result_bytes = t_result.size() * sizeof(float);
+
+  float* d_t_left;
+  float* d_t_right;
+  float* d_t_result;
+
+  gpuMalloc((void**)(&d_t_left), t_left_bytes);
+  gpuMalloc((void**)(&d_t_right), t_right_bytes);
+  gpuMalloc((void**)(&d_t_result), t_result_bytes);
+
+  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>> gpu_t_left(d_t_left, Eigen::array<int, 2>{m_size, k_size});
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>> gpu_t_right(d_t_right, Eigen::array<int, 2>{k_size, n_size});
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>> gpu_t_result(d_t_result, Eigen::array<int, 2>{m_size, n_size});
+
+  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
+  t_result = t_left.contract(t_right, dims);
+
+  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
+  for (DenseIndex i = 0; i < t_result.size(); i++) {
+    // Absolute slack for accumulation-order differences between device and host contractions.
+    if (numext::abs(t_result(i) - t_result_gpu(i)) < 1024 * NumTraits<float>::epsilon()) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), 1024 * NumTraits<float>::epsilon())) {
+      continue;
+    }
+    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
+    assert(false);
+  }
+
+  gpuFree((void*)d_t_left);
+  gpuFree((void*)d_t_right);
+  gpuFree((void*)d_t_result);
+}
+
+template <int DataLayout, typename Scalar = float>
+void test_gpu_contraction_zero_k(int m_size, int n_size) {
+  const int k_size = 0;
+  Tensor<Scalar, 2, DataLayout> t_left(m_size, k_size);
+  Tensor<Scalar, 2, DataLayout> t_right(k_size, n_size);
+  Tensor<Scalar, 2, DataLayout> t_result(m_size, n_size);
+  Tensor<Scalar, 2, DataLayout> t_result_gpu(m_size, n_size);
+  t_result_gpu.setConstant(Scalar(123));
+  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
+
+  std::size_t t_left_bytes = (std::max)(t_left.size(), DenseIndex(1)) * sizeof(Scalar);
+  std::size_t t_right_bytes = (std::max)(t_right.size(), DenseIndex(1)) * sizeof(Scalar);
+  std::size_t t_result_bytes = t_result.size() * sizeof(Scalar);
+
+  Scalar* d_t_left;
+  Scalar* d_t_right;
+  Scalar* d_t_result;
+
+  gpuMalloc((void**)(&d_t_left), t_left_bytes);
+  gpuMalloc((void**)(&d_t_right), t_right_bytes);
+  gpuMalloc((void**)(&d_t_result), t_result_bytes);
+
+  // Prefill the device output with a nonzero value to verify that the GPU path actively zeroes the output buffer.
+  gpuMemcpy(d_t_result, t_result_gpu.data(), t_result_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2, DataLayout>> gpu_t_left(d_t_left, Eigen::array<int, 2>{m_size, k_size});
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2, DataLayout>> gpu_t_right(d_t_right, Eigen::array<int, 2>{k_size, n_size});
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2, DataLayout>> gpu_t_result(d_t_result, Eigen::array<int, 2>{m_size, n_size});
+
+  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
+  t_result = t_left.contract(t_right, dims);
+
+  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
+  for (DenseIndex i = 0; i < t_result.size(); i++) {
+    VERIFY_IS_EQUAL(t_result(i), Scalar(0));
+    VERIFY_IS_EQUAL(t_result_gpu(i), Scalar(0));
+  }
+
+  gpuFree((void*)d_t_left);
+  gpuFree((void*)d_t_right);
+  gpuFree((void*)d_t_result);
+}
+
+template <int DataLayout>
+void test_gpu_contraction_double(int m_size, int k_size, int n_size) {
+  Tensor<double, 2, DataLayout> t_left(m_size, k_size);
+  Tensor<double, 2, DataLayout> t_right(k_size, n_size);
+  Tensor<double, 2, DataLayout> t_result(m_size, n_size);
+  Tensor<double, 2, DataLayout> t_result_gpu(m_size, n_size);
+  Eigen::array<Tensor<double, 1>::DimensionPair, 1> dims{Tensor<double, 1>::DimensionPair(1, 0)};
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(double);
+  std::size_t t_right_bytes = t_right.size() * sizeof(double);
+  std::size_t t_result_bytes = t_result.size() * sizeof(double);
+
+  double* d_t_left;
+  double* d_t_right;
+  double* d_t_result;
+
+  gpuMalloc((void**)(&d_t_left), t_left_bytes);
+  gpuMalloc((void**)(&d_t_right), t_right_bytes);
+  gpuMalloc((void**)(&d_t_result), t_result_bytes);
+
+  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<double, 2, DataLayout>> gpu_t_left(d_t_left, Eigen::array<int, 2>{m_size, k_size});
+  Eigen::TensorMap<Eigen::Tensor<double, 2, DataLayout>> gpu_t_right(d_t_right, Eigen::array<int, 2>{k_size, n_size});
+  Eigen::TensorMap<Eigen::Tensor<double, 2, DataLayout>> gpu_t_result(d_t_result, Eigen::array<int, 2>{m_size, n_size});
+
+  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
+  t_result = t_left.contract(t_right, dims);
+
+  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
+  for (DenseIndex i = 0; i < t_result.size(); i++) {
+    if (std::abs(t_result(i) - t_result_gpu(i)) < 524288 * NumTraits<double>::epsilon()) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), 524288 * NumTraits<double>::epsilon())) {
+      continue;
+    }
+    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
+    assert(false);
+  }
+
+  gpuFree((void*)d_t_left);
+  gpuFree((void*)d_t_right);
+  gpuFree((void*)d_t_result);
+}
+
+template <int DataLayout>
+void test_scalar(int m_size, int k_size, int n_size) {
+  std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << ")" << std::endl;
+  // with these dimensions, the output has 300 * 140 elements, which is
+  // more than 30 * 1024, which is the number of threads in blocks on
+  // a 15 SM GK110 GPU
+  Tensor<float, 2, DataLayout> t_left(m_size, k_size);
+  Tensor<float, 2, DataLayout> t_right(k_size, n_size);
+  Tensor<float, 0, DataLayout> t_result;
+  Tensor<float, 0, DataLayout> t_result_gpu;
+  Eigen::array<DimPair, 2> dims{DimPair(0, 0), DimPair(1, 1)};
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(float);
+  std::size_t t_right_bytes = t_right.size() * sizeof(float);
+  std::size_t t_result_bytes = sizeof(float);
+
+  float* d_t_left;
+  float* d_t_right;
+  float* d_t_result;
+
+  gpuMalloc((void**)(&d_t_left), t_left_bytes);
+  gpuMalloc((void**)(&d_t_right), t_right_bytes);
+  gpuMalloc((void**)(&d_t_result), t_result_bytes);
+
+  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>> gpu_t_left(d_t_left, m_size, k_size);
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>> gpu_t_right(d_t_right, k_size, n_size);
+  Eigen::TensorMap<Eigen::Tensor<float, 0, DataLayout>> gpu_t_result(d_t_result);
+
+  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
+  t_result = t_left.contract(t_right, dims);
+
+  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
+  if (numext::abs(t_result() - t_result_gpu()) > 1024 * NumTraits<float>::epsilon() &&
+      !Eigen::internal::isApprox(t_result(), t_result_gpu(), 1024 * NumTraits<float>::epsilon())) {
+    std::cout << "mismatch detected: " << t_result() << " vs " << t_result_gpu() << std::endl;
+    assert(false);
+  }
+
+  gpuFree((void*)d_t_left);
+  gpuFree((void*)d_t_right);
+  gpuFree((void*)d_t_result);
+}
+
+template <int DataLayout>
+void test_gpu_contraction_m() {
+  for (int k = 32; k < 256; k++) {
+    test_gpu_contraction<DataLayout>(k, 128, 128);
+  }
+}
+
+template <int DataLayout>
+void test_gpu_contraction_k() {
+  for (int k = 32; k < 256; k++) {
+    test_gpu_contraction<DataLayout>(128, k, 128);
+  }
+}
+
+template <int DataLayout>
+void test_gpu_contraction_n() {
+  for (int k = 32; k < 256; k++) {
+    test_gpu_contraction<DataLayout>(128, 128, k);
+  }
+}
+
+template <int DataLayout>
+void test_gpu_contraction_sizes() {
+  int m_sizes[3][5] = {{31, 39, 63, 64, 65}, {127, 129, 255, 257, 511}, {512, 513, 1023, 1024, 1025}};
+
+  int n_sizes[3][5] = {{31, 39, 63, 64, 65}, {127, 129, 255, 257, 511}, {512, 513, 1023, 1024, 1025}};
+
+  int k_sizes[3][6] = {{31, 39, 63, 64, 65, 95}, {96, 127, 129, 255, 257, 511}, {512, 513, 725, 1023, 1024, 1025}};
+
+  // Some selection of specific cases.
+  //  - m changes rows each iteration
+  //  - n changes rows each 3 iterations
+  //  - k changes rows each 9 iterations
+  //  - within a row, advance once column each iteration
+  const int m_cols = 5;
+  const int n_cols = 5;
+  const int k_cols = 6;
+  int m_offset = 0;
+  int n_offset = 1;
+  int k_offset = 2;
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int l = 0; l < 3; ++l) {
+        int m = m_sizes[l][m_offset];
+        int n = n_sizes[j][n_offset];
+        int k = k_sizes[i][k_offset];
+        test_gpu_contraction<DataLayout>(m, n, k);
+        n_offset = (n_offset + 1) % n_cols;
+        k_offset = (k_offset + 1) % k_cols;
+      }
+      m_offset = (m_offset + 1) % m_cols;
+      if (j < 2) {
+        n_offset = (n_offset + n_cols - 3) % n_cols;  // Rewind 3.
+      }
+    }
+    k_offset = (k_offset + 2 * k_cols - 9) % k_cols;  // Rewind 9.
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_contract_gpu) {
+  CALL_SUBTEST_1(test_gpu_contraction<ColMajor>(128, 128, 128));
+  CALL_SUBTEST_1(test_gpu_contraction<RowMajor>(128, 128, 128));
+  CALL_SUBTEST_1(test_gpu_contraction_double<ColMajor>(64, 64, 64));
+  CALL_SUBTEST_1(test_gpu_contraction_double<RowMajor>(64, 64, 64));
+  CALL_SUBTEST_1(test_gpu_contraction_double<ColMajor>(100, 100, 100));
+  CALL_SUBTEST_1(test_gpu_contraction_double<RowMajor>(100, 100, 100));
+  CALL_SUBTEST_1(test_gpu_contraction_double<ColMajor>(65, 129, 33));
+  CALL_SUBTEST_1(test_gpu_contraction_double<RowMajor>(65, 129, 33));
+
+  CALL_SUBTEST_1(test_scalar<ColMajor>(128, 128, 128));
+  CALL_SUBTEST_1(test_scalar<RowMajor>(128, 128, 128));
+
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<ColMajor>(10, 20)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<RowMajor>(10, 20)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<ColMajor>(64, 64)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<RowMajor>(64, 64)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<ColMajor, double>(10, 20)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<RowMajor, double>(10, 20)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<ColMajor, double>(64, 64)));
+  CALL_SUBTEST_1((test_gpu_contraction_zero_k<RowMajor, double>(64, 64)));
+
+  CALL_SUBTEST_2(test_gpu_contraction_m<ColMajor>());
+  CALL_SUBTEST_3(test_gpu_contraction_m<RowMajor>());
+
+  CALL_SUBTEST_4(test_gpu_contraction_k<ColMajor>());
+  CALL_SUBTEST_5(test_gpu_contraction_k<RowMajor>());
+
+  CALL_SUBTEST_6(test_gpu_contraction_n<ColMajor>());
+  CALL_SUBTEST_7(test_gpu_contraction_n<RowMajor>());
+
+#if !defined(EIGEN_USE_HIP)
+  // disable these subtests for HIP
+  CALL_SUBTEST_8(test_gpu_contraction_sizes<ColMajor>());
+  CALL_SUBTEST_9(test_gpu_contraction_sizes<RowMajor>());
+#endif
+}
diff --git a/contrib/test/tensor_contract_sycl.cpp b/contrib/test/tensor_contract_sycl.cpp
new file mode 100644
index 0000000..7e64061
--- /dev/null
+++ b/contrib/test/tensor_contract_sycl.cpp
@@ -0,0 +1,831 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include <algorithm>
+#include <chrono>
+#include <ctime>
+#include <iostream>
+
+#include "main.h"
+
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void static test_sycl_contraction(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  // Absolute slack for accumulation-order differences between device and host float contractions.
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  // with these dimensions, the output has 300 * 140 elements, which is
+  // more than 30 * 1024, which is the number of threads in blocks on
+  // a 15 SM GK110 GPU
+  Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
+  Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result(m_size, n_size);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(m_size, n_size);
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
+  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
+  Eigen::array<IndexType, 2> result_dims = {{m_size, n_size}};
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
+  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
+  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, result_dims);
+
+  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
+
+  t_result = t_left.contract(t_right, dims);
+
+  for (IndexType i = 0; i < t_result.size(); i++) {
+    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
+      continue;
+    }
+
+    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
+              << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
+    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
+  }
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void test_sycl_contraction_m(const Device &sycl_device) {
+  for (IndexType k = 32; k < 256; k++) {
+    test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, k, 128, 128);
+  }
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void test_sycl_contraction_k(const Device &sycl_device) {
+  for (IndexType k = 32; k < 256; k++) {
+    test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, 128, k, 128);
+  }
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void test_sycl_contraction_n(const Device &sycl_device) {
+  for (IndexType k = 32; k < 256; k++) {
+    test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, 128, 128, k);
+  }
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void test_sycl_contraction_sizes(const Device &sycl_device) {
+  IndexType m_sizes[] = {31, 39, 63, 64, 65, 127, 129, 255, 257, 511, 512, 513, 1023, 1024, 1025};
+
+  IndexType n_sizes[] = {31, 39, 63, 64, 65, 127, 129, 255, 257, 511, 512, 513, 1023, 1024, 1025};
+
+  IndexType k_sizes[] = {31, 39, 63, 64, 65, 95, 96, 127, 129, 255, 257, 511, 512, 513, 1023, 1024, 1025};
+
+  for (IndexType i = 0; i < 15; i++) {
+    for (IndexType j = 0; j < 15; j++) {
+      for (IndexType k = 0; k < 17; k++) {
+        test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, m_sizes[i], n_sizes[j], k_sizes[k]);
+      }
+    }
+  }
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void static test_no_out_of_bounds(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
+  Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result(m_size, n_size);
+
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
+  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
+  Eigen::array<IndexType, 2> result_dims = {{m_size, n_size}};
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  // Allocate buffers twice as big to check for invalid read and write
+  auto padded_left_size = 2 * t_left.size();
+  auto padded_right_size = 2 * t_right.size();
+  auto padded_result_size = 2 * t_result.size();
+
+  std::size_t t_left_bytes = padded_left_size * sizeof(DataType);
+  std::size_t t_right_bytes = padded_right_size * sizeof(DataType);
+  std::size_t t_result_bytes = padded_result_size * sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  // TensorMaps are still of the same size than the Tensors
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, result_dims);
+
+  // Write nan after the actual buffer to propagate nans everywhere in case of
+  // invalid reads
+  DataType nan = std::numeric_limits<DataType>::quiet_NaN();
+  auto host_left_data = new DataType[padded_left_size];
+  std::copy_n(t_left.data(), t_left.size(), host_left_data);
+  std::fill_n(host_left_data + t_left.size(), t_left.size(), nan);
+  auto host_right_data = new DataType[padded_right_size];
+  std::copy_n(t_right.data(), t_right.size(), host_right_data);
+  std::fill_n(host_right_data + t_right.size(), t_right.size(), nan);
+  auto host_result_data = new DataType[padded_result_size];
+  std::fill_n(host_result_data, padded_result_size, nan);
+
+  sycl_device.memcpyHostToDevice(d_t_left, host_left_data, t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, host_right_data, t_right_bytes);
+  sycl_device.memcpyHostToDevice(d_t_result, host_result_data, t_result_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
+  sycl_device.memcpyDeviceToHost(host_result_data, d_t_result, t_result_bytes);
+
+  t_result = t_left.contract(t_right, dims);
+
+  for (IndexType i = 0; i < t_result.size(); i++) {
+    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - host_result_data[i]))) < error_threshold) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), host_result_data[i], error_threshold)) {
+      continue;
+    }
+    if (std::isnan(host_result_data[i])) {
+      std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size
+                << ", invalid read detected at IndexType " << i << ": " << t_result(i) << " vs " << host_result_data[i]
+                << std::endl;
+    } else {
+      std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
+                << i << ": " << t_result(i) << " vs " << host_result_data[i] << std::endl;
+    }
+    VERIFY_IS_APPROX(host_result_data[i], t_result(i));
+  }
+  // Make sure that the rest of the result is still nans
+  for (IndexType i = t_result.size(); i < padded_result_size; i++) {
+    if (std::isnan(host_result_data[i])) {
+      continue;
+    }
+    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size
+              << ", invalid write detected at IndexType " << i << ": " << host_result_data[i] << std::endl;
+    VERIFY_IS_APPROX(host_result_data[i], t_result(i));
+  }
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+
+  delete[] host_left_data;
+  delete[] host_right_data;
+  delete[] host_result_data;
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void test_scalar(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
+  // std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size <<
+  // ")" << std::endl;
+  // with these dimensions, the output has 300 * 140 elements, which is
+  // more than 30 * 1024, which is the number of threads in blocks on
+  // a 15 SM GK110 GPU
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
+  Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
+  Tensor<DataType, 0, DataLayout, IndexType> t_result;
+  Tensor<DataType, 0, DataLayout, IndexType> t_result_gpu;
+  Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(1, 1)}};
+  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
+  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
+  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
+  std::size_t t_result_bytes = sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 0, DataLayout, IndexType>> gpu_t_result(d_t_result);
+
+  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
+
+  t_result = t_left.contract(t_right, dims);
+
+  if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result() - t_result_gpu()))) > error_threshold &&
+      !Eigen::internal::isApprox(t_result(), t_result_gpu(), error_threshold)) {
+    std::cout << "K: " << k_size << ", N: " << n_size << ", M: " << m_size << " : mismatch detected: " << t_result()
+              << " vs " << t_result_gpu() << std::endl;
+    VERIFY_IS_APPROX(t_result_gpu(), t_result());
+  }
+
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void contraction_batch(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size,
+                       IndexType m_batch, IndexType start, IndexType limit) {
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  typedef Eigen::array<IndexType, 3> TensorDim;
+  typedef Eigen::Tensor<DataType, 3, DataLayout, IndexType> TensorType;
+  TensorDim left_dims = {{m_batch, k_size, m_size}};
+  TensorDim right_dims = {{m_batch, n_size, k_size}};
+  TensorDim res_dims = {{m_batch, m_size, n_size}};
+  Eigen::array<DimPair, 1> contract_pairs = {{DimPair(0, 1)}};
+
+  TensorType t_left(left_dims);
+  TensorType t_right(right_dims);
+  TensorType t_result_gpu(res_dims);
+  TensorType t_result(res_dims);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
+  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
+  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  Eigen::TensorMap<TensorType> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<TensorType> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<TensorType> gpu_t_result(d_t_result, res_dims);
+
+  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
+  for (int i = start; i < limit; ++i) {
+    auto x = gpu_t_left.template chip<0>(i);
+    auto y = gpu_t_right.template chip<0>(i);
+    auto z = gpu_t_result.template chip<0>(i);
+    z.device(sycl_device) = x.contract(y, contract_pairs);
+  }
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
+
+  for (int i = start; i < limit; ++i) {
+    auto x = t_left.template chip<0>(i);
+    auto y = t_right.template chip<0>(i);
+    auto z = t_result.template chip<0>(i);
+    z = x.contract(y, contract_pairs);
+  }
+
+  for (IndexType i = 0; i < t_result.size(); i++) {
+    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
+      continue;
+    }
+    std::cout << "mismatch detected at IndexType " << i << ": " << t_result(i) << " vs " << t_result_gpu(i)
+              << std::endl;
+    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
+  }
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void contraction_rhs_transposed(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
+  Eigen::array<IndexType, 2> right_dims = {{n_size, k_size}};
+  Eigen::array<IndexType, 2> res_dims = {{m_size, n_size}};
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 1)}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
+  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
+  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, res_dims);
+
+  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
+
+  t_result = t_left.contract(t_right, dims);
+
+  for (IndexType j = 0; j < m_size; j++) {
+    for (IndexType i = 0; i < n_size; i++) {
+      if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(j, i) - t_result_gpu(j, i)))) <
+          error_threshold) {
+        continue;
+      }
+      if (Eigen::internal::isApprox(t_result(j, i), t_result_gpu(j, i), error_threshold)) {
+        continue;
+      }
+      std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size
+                << ", mismatch detected at IndexType m: " << j << " n: " << i << " CPU : " << t_result(j, i)
+                << " vs SYCL:" << t_result_gpu(j, i) << std::endl;
+      VERIFY_IS_APPROX(t_result_gpu(j, i), t_result(j, i));
+    }
+  }
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void contraction_lhs_transposed(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  Eigen::array<IndexType, 2> left_dims = {{k_size, m_size}};
+  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
+  Eigen::array<IndexType, 2> res_dims = {{m_size, n_size}};
+  Eigen::array<DimPair, 1> dims = {{DimPair(0, 0)}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
+  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
+  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, res_dims);
+
+  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
+
+  t_result = t_left.contract(t_right, dims);
+
+  for (IndexType i = 0; i < t_result.size(); i++) {
+    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
+      continue;
+    }
+    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
+              << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
+    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
+  }
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+}
+
+template <int DataLayout, typename DataType, typename IndexType, typename Device>
+void contraction_both_transposed(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
+  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  Eigen::array<IndexType, 2> left_dims = {{k_size, m_size}};
+  Eigen::array<IndexType, 2> right_dims = {{n_size, k_size}};
+  Eigen::array<IndexType, 2> res_dims = {{m_size, n_size}};
+  Eigen::array<DimPair, 1> dims = {{DimPair(0, 1)}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
+  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
+  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
+
+  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
+  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
+  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, res_dims);
+
+  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
+  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
+
+  t_result = t_left.contract(t_right, dims);
+
+  for (IndexType i = 0; i < t_result.size(); i++) {
+    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
+      continue;
+    }
+    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
+              << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
+
+    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
+  }
+  sycl_device.deallocate(d_t_left);
+  sycl_device.deallocate(d_t_right);
+  sycl_device.deallocate(d_t_result);
+}
+
+template <typename Dev>
+void inline tensorOutofBound(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Test out of bound for Tensor-Tensor
+  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 10, 1024, 1024);
+  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 1024, 1024, 4096);
+  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 4096, 1024, 2048);
+  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 784, 2048, 1024);
+  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 2048, 1024, 784);
+  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 10, 1024, 10);
+  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 513, 4096, 513);
+  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 783, 1024, 783);
+  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 784, 2048, 784);
+  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 11, 1024, 11);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "tensor out of bound tests finished computation at " << std::ctime(&end_time)
+            << "elapsed time: " << elapsed_seconds.count() << "s\n";
+}
+
+template <typename Dev>
+void inline tensorTensor_m(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Tensor Tensor Contraction
+  test_sycl_contraction_m<ColMajor, DataType, IndexType>(sycl_device);
+  test_sycl_contraction_m<RowMajor, DataType, IndexType>(sycl_device);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
+            << "elapsed time: " << elapsed_seconds.count() << "s\n";
+}
+
+template <typename Dev>
+void inline tensorTensor_n(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Tensor Tensor Contraction
+  test_sycl_contraction_n<ColMajor, DataType, IndexType>(sycl_device);
+  test_sycl_contraction_n<RowMajor, DataType, IndexType>(sycl_device);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
+            << "elapsed time: " << elapsed_seconds.count() << "s\n";
+}
+
+template <typename Dev>
+void inline tensorTensor_k(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  test_sycl_contraction_k<ColMajor, DataType, IndexType>(sycl_device);
+  test_sycl_contraction_k<RowMajor, DataType, IndexType>(sycl_device);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
+            << "elapsed time: " << elapsed_seconds.count() << "s\n";
+}
+
+template <typename Dev>
+void inline tensorTensor_sizes(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Tensor Tensor Contraction
+  test_sycl_contraction_sizes<ColMajor, DataType, IndexType>(sycl_device);
+  test_sycl_contraction_sizes<RowMajor, DataType, IndexType>(sycl_device);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
+            << "elapsed time: " << elapsed_seconds.count() << "s\n";
+}
+template <typename Dev>
+void inline vectorVector(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // VECTOR-VECTOR
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1025, 1, 1025);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1025, 1, 1025);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1024, 1, 1024);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1024, 1, 1024);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1023, 1, 1023);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1023, 1, 1023);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "contracted tensor tests finished computation at " << std::ctime(&end_time)
+            << "elapsed time: " << elapsed_seconds.count() << "s\n";
+}
+
+template <typename Dev>
+void inline vectorTensor(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Vector-Tensor
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 1025, 1025);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 1025, 1025);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 1024, 1024);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 1024, 1024);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 1023, 1023);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 1023, 1023);
+
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 4097, 4097);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 4097, 4097);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 4096, 4096);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 4096, 4096);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 4095, 4095);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 4095, 4095);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 802816, 32);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline tensorVector(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Matrix-Vector
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1025, 1025, 1);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1125, 1025, 1);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1224, 1024, 1);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1024, 1024, 1);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1023, 1023, 1);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1023, 1023, 1);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 4097, 4197, 1);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 4097, 4097, 1);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 4096, 4096, 1);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 4096, 8196, 1);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 4095, 4095, 1);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 4095, 4095, 1);
+// If the GEMV disabled it will creates one kernel to calculate the contraction.
+// Therefore the acumuation of float number will overflow the precision
+// threshold for float and cause the test to fail. While it the GMV multiple
+// kernel will be created and each one run the overflow of accumutation breaks
+// among the kernels.
+#ifndef EIGEN_SYCL_DISABLE_GEMV
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 32, 802032, 1);
+#endif
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline tensorScalar(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // SCALAR Contraction
+  test_scalar<ColMajor, DataType, IndexType>(sycl_device, 127, 127, 127);
+  test_scalar<RowMajor, DataType, IndexType>(sycl_device, 127, 127, 127);
+  test_scalar<ColMajor, DataType, IndexType>(sycl_device, 128, 128, 128);
+  test_scalar<RowMajor, DataType, IndexType>(sycl_device, 128, 128, 128);
+  test_scalar<ColMajor, DataType, IndexType>(sycl_device, 129, 129, 129);
+  test_scalar<RowMajor, DataType, IndexType>(sycl_device, 129, 129, 129);
+
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline skinnyTensor_row(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Tensor Tensor Contraction
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 16, 4, 16);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 257, 131073, 257);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 256, 131072, 256);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 16, 131073, 16);
+  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 17, 131072, 17);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline skinnyTensor_col(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+  // Tensor Tensor Contraction
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 16, 4, 16);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 257, 131073, 257);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 256, 131072, 256);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 16, 131073, 16);
+  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 17, 131072, 17);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline tensor_contraction_batch_per_device(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+
+  contraction_batch<RowMajor, DataType, IndexType>(sycl_device, 64, 75, 30, 4, 0, 4);
+  contraction_batch<ColMajor, DataType, IndexType>(sycl_device, 64, 75, 30, 4, 0, 4);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline tensor_contraction_lhs_transposed_per_device(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 8, 4, 8);
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 32, 8, 32);
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 64, 16, 64);
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 784, 2048, 1024);
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 1024, 10, 1024);
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 4096, 1024, 1024);
+  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 2048, 4096, 1024);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline tensor_contraction_rhs_transposed_per_device(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 16, 4, 16);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 17, 5, 17);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 32, 8, 32);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 64, 16, 64);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 10, 1024, 1024);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 1024, 1024, 4096);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 4096, 1024, 2048);
+  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 2048, 1024, 784);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+template <typename Dev>
+void inline tensor_contraction_both_transposed_per_device(const Dev &sycl_device) {
+  typedef float DataType;
+  typedef int64_t IndexType;
+  std::chrono::time_point<std::chrono::system_clock> start, end;
+  start = std::chrono::system_clock::now();
+
+  contraction_both_transposed<RowMajor, DataType, IndexType>(sycl_device, 17, 5, 17);
+  contraction_both_transposed<RowMajor, DataType, IndexType>(sycl_device, 32, 8, 32);
+  contraction_both_transposed<RowMajor, DataType, IndexType>(sycl_device, 64, 16, 64);
+  end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end - start;
+  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
+  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
+            << "s\n";
+}
+
+EIGEN_DECLARE_TEST(tensor_contract_sycl) {
+  for (const auto &device : Eigen::get_sycl_supported_devices()) {
+    std::cout << "Running on " << device.template get_info<cl::sycl::info::device::name>() << std::endl;
+    QueueInterface queueInterface(device);
+    auto sycl_device = Eigen::SyclDevice(&queueInterface);
+    CALL_SUBTEST_1(tensorOutofBound(sycl_device));
+    CALL_SUBTEST_2(tensorTensor_m(sycl_device));
+    CALL_SUBTEST_2(tensorTensor_n(sycl_device));
+    CALL_SUBTEST_2(tensorTensor_k(sycl_device));
+    CALL_SUBTEST_2(tensorTensor_sizes(sycl_device));
+    CALL_SUBTEST_3(vectorVector(sycl_device));
+    CALL_SUBTEST_4(vectorTensor(sycl_device));
+    CALL_SUBTEST_5(tensorVector(sycl_device));
+    CALL_SUBTEST_6(tensorScalar(sycl_device));
+    CALL_SUBTEST_7(skinnyTensor_row(sycl_device));
+    CALL_SUBTEST_7(skinnyTensor_col(sycl_device));
+    CALL_SUBTEST_8(tensor_contraction_batch_per_device(sycl_device));
+    CALL_SUBTEST_9(tensor_contraction_lhs_transposed_per_device(sycl_device));
+    CALL_SUBTEST_10(tensor_contraction_rhs_transposed_per_device(sycl_device));
+    CALL_SUBTEST_11(tensor_contraction_both_transposed_per_device(sycl_device));
+  }
+}
diff --git a/contrib/test/tensor_contraction.cpp b/contrib/test/tensor_contraction.cpp
new file mode 100644
index 0000000..a2616df
--- /dev/null
+++ b/contrib/test/tensor_contraction.cpp
@@ -0,0 +1,1003 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::DefaultDevice;
+using Eigen::Tensor;
+
+typedef Tensor<float, 1>::DimensionPair DimPair;
+
+template <int DataLayout>
+static void test_evals() {
+  Tensor<float, 2, DataLayout> mat1(2, 3);
+  Tensor<float, 2, DataLayout> mat2(2, 3);
+  Tensor<float, 2, DataLayout> mat3(3, 2);
+
+  mat1.setRandom();
+  mat2.setRandom();
+  mat3.setRandom();
+
+  Tensor<float, 2, DataLayout> mat4(3, 3);
+  mat4.setZero();
+  Eigen::array<DimPair, 1> dims3 = {{DimPair(0, 0)}};
+  typedef TensorEvaluator<decltype(mat1.contract(mat2, dims3)), DefaultDevice> Evaluator;
+  Evaluator eval(mat1.contract(mat2, dims3), DefaultDevice());
+  eval.evalTo(mat4.data());
+  EIGEN_STATIC_ASSERT(Evaluator::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  VERIFY_IS_EQUAL(eval.dimensions()[0], 3);
+  VERIFY_IS_EQUAL(eval.dimensions()[1], 3);
+
+  VERIFY_IS_APPROX(mat4(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(1, 0) * mat2(1, 0));
+  VERIFY_IS_APPROX(mat4(0, 1), mat1(0, 0) * mat2(0, 1) + mat1(1, 0) * mat2(1, 1));
+  VERIFY_IS_APPROX(mat4(0, 2), mat1(0, 0) * mat2(0, 2) + mat1(1, 0) * mat2(1, 2));
+  VERIFY_IS_APPROX(mat4(1, 0), mat1(0, 1) * mat2(0, 0) + mat1(1, 1) * mat2(1, 0));
+  VERIFY_IS_APPROX(mat4(1, 1), mat1(0, 1) * mat2(0, 1) + mat1(1, 1) * mat2(1, 1));
+  VERIFY_IS_APPROX(mat4(1, 2), mat1(0, 1) * mat2(0, 2) + mat1(1, 1) * mat2(1, 2));
+  VERIFY_IS_APPROX(mat4(2, 0), mat1(0, 2) * mat2(0, 0) + mat1(1, 2) * mat2(1, 0));
+  VERIFY_IS_APPROX(mat4(2, 1), mat1(0, 2) * mat2(0, 1) + mat1(1, 2) * mat2(1, 1));
+  VERIFY_IS_APPROX(mat4(2, 2), mat1(0, 2) * mat2(0, 2) + mat1(1, 2) * mat2(1, 2));
+
+  Tensor<float, 2, DataLayout> mat5(2, 2);
+  mat5.setZero();
+  Eigen::array<DimPair, 1> dims4 = {{DimPair(1, 1)}};
+  typedef TensorEvaluator<decltype(mat1.contract(mat2, dims4)), DefaultDevice> Evaluator2;
+  Evaluator2 eval2(mat1.contract(mat2, dims4), DefaultDevice());
+  eval2.evalTo(mat5.data());
+  EIGEN_STATIC_ASSERT(Evaluator2::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  VERIFY_IS_EQUAL(eval2.dimensions()[0], 2);
+  VERIFY_IS_EQUAL(eval2.dimensions()[1], 2);
+
+  VERIFY_IS_APPROX(mat5(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(0, 1) * mat2(0, 1) + mat1(0, 2) * mat2(0, 2));
+  VERIFY_IS_APPROX(mat5(0, 1), mat1(0, 0) * mat2(1, 0) + mat1(0, 1) * mat2(1, 1) + mat1(0, 2) * mat2(1, 2));
+  VERIFY_IS_APPROX(mat5(1, 0), mat1(1, 0) * mat2(0, 0) + mat1(1, 1) * mat2(0, 1) + mat1(1, 2) * mat2(0, 2));
+  VERIFY_IS_APPROX(mat5(1, 1), mat1(1, 0) * mat2(1, 0) + mat1(1, 1) * mat2(1, 1) + mat1(1, 2) * mat2(1, 2));
+
+  Tensor<float, 2, DataLayout> mat6(2, 2);
+  mat6.setZero();
+  Eigen::array<DimPair, 1> dims6 = {{DimPair(1, 0)}};
+  typedef TensorEvaluator<decltype(mat1.contract(mat3, dims6)), DefaultDevice> Evaluator3;
+  Evaluator3 eval3(mat1.contract(mat3, dims6), DefaultDevice());
+  eval3.evalTo(mat6.data());
+  EIGEN_STATIC_ASSERT(Evaluator3::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  VERIFY_IS_EQUAL(eval3.dimensions()[0], 2);
+  VERIFY_IS_EQUAL(eval3.dimensions()[1], 2);
+
+  VERIFY_IS_APPROX(mat6(0, 0), mat1(0, 0) * mat3(0, 0) + mat1(0, 1) * mat3(1, 0) + mat1(0, 2) * mat3(2, 0));
+  VERIFY_IS_APPROX(mat6(0, 1), mat1(0, 0) * mat3(0, 1) + mat1(0, 1) * mat3(1, 1) + mat1(0, 2) * mat3(2, 1));
+  VERIFY_IS_APPROX(mat6(1, 0), mat1(1, 0) * mat3(0, 0) + mat1(1, 1) * mat3(1, 0) + mat1(1, 2) * mat3(2, 0));
+  VERIFY_IS_APPROX(mat6(1, 1), mat1(1, 0) * mat3(0, 1) + mat1(1, 1) * mat3(1, 1) + mat1(1, 2) * mat3(2, 1));
+}
+
+template <int DataLayout>
+static void test_scalar() {
+  Tensor<float, 1, DataLayout> vec1({6});
+  Tensor<float, 1, DataLayout> vec2({6});
+
+  vec1.setRandom();
+  vec2.setRandom();
+
+  Eigen::array<DimPair, 1> dims = {{DimPair(0, 0)}};
+  Tensor<float, 0, DataLayout> scalar = vec1.contract(vec2, dims);
+
+  float expected = 0.0f;
+  for (int i = 0; i < 6; ++i) {
+    expected += vec1(i) * vec2(i);
+  }
+  VERIFY_IS_APPROX(scalar(), expected);
+}
+
+template <int DataLayout>
+static void test_multidims() {
+  Tensor<float, 3, DataLayout> mat1(2, 2, 2);
+  Tensor<float, 4, DataLayout> mat2(2, 2, 2, 2);
+
+  mat1.setRandom();
+  mat2.setRandom();
+
+  Tensor<float, 3, DataLayout> mat3(2, 2, 2);
+  mat3.setZero();
+  Eigen::array<DimPair, 2> dims = {{DimPair(1, 2), DimPair(2, 3)}};
+  typedef TensorEvaluator<decltype(mat1.contract(mat2, dims)), DefaultDevice> Evaluator;
+  Evaluator eval(mat1.contract(mat2, dims), DefaultDevice());
+  eval.evalTo(mat3.data());
+  EIGEN_STATIC_ASSERT(Evaluator::NumDims == 3ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  VERIFY_IS_EQUAL(eval.dimensions()[0], 2);
+  VERIFY_IS_EQUAL(eval.dimensions()[1], 2);
+  VERIFY_IS_EQUAL(eval.dimensions()[2], 2);
+
+  VERIFY_IS_APPROX(mat3(0, 0, 0), mat1(0, 0, 0) * mat2(0, 0, 0, 0) + mat1(0, 1, 0) * mat2(0, 0, 1, 0) +
+                                      mat1(0, 0, 1) * mat2(0, 0, 0, 1) + mat1(0, 1, 1) * mat2(0, 0, 1, 1));
+  VERIFY_IS_APPROX(mat3(0, 0, 1), mat1(0, 0, 0) * mat2(0, 1, 0, 0) + mat1(0, 1, 0) * mat2(0, 1, 1, 0) +
+                                      mat1(0, 0, 1) * mat2(0, 1, 0, 1) + mat1(0, 1, 1) * mat2(0, 1, 1, 1));
+  VERIFY_IS_APPROX(mat3(0, 1, 0), mat1(0, 0, 0) * mat2(1, 0, 0, 0) + mat1(0, 1, 0) * mat2(1, 0, 1, 0) +
+                                      mat1(0, 0, 1) * mat2(1, 0, 0, 1) + mat1(0, 1, 1) * mat2(1, 0, 1, 1));
+  VERIFY_IS_APPROX(mat3(0, 1, 1), mat1(0, 0, 0) * mat2(1, 1, 0, 0) + mat1(0, 1, 0) * mat2(1, 1, 1, 0) +
+                                      mat1(0, 0, 1) * mat2(1, 1, 0, 1) + mat1(0, 1, 1) * mat2(1, 1, 1, 1));
+  VERIFY_IS_APPROX(mat3(1, 0, 0), mat1(1, 0, 0) * mat2(0, 0, 0, 0) + mat1(1, 1, 0) * mat2(0, 0, 1, 0) +
+                                      mat1(1, 0, 1) * mat2(0, 0, 0, 1) + mat1(1, 1, 1) * mat2(0, 0, 1, 1));
+  VERIFY_IS_APPROX(mat3(1, 0, 1), mat1(1, 0, 0) * mat2(0, 1, 0, 0) + mat1(1, 1, 0) * mat2(0, 1, 1, 0) +
+                                      mat1(1, 0, 1) * mat2(0, 1, 0, 1) + mat1(1, 1, 1) * mat2(0, 1, 1, 1));
+  VERIFY_IS_APPROX(mat3(1, 1, 0), mat1(1, 0, 0) * mat2(1, 0, 0, 0) + mat1(1, 1, 0) * mat2(1, 0, 1, 0) +
+                                      mat1(1, 0, 1) * mat2(1, 0, 0, 1) + mat1(1, 1, 1) * mat2(1, 0, 1, 1));
+  VERIFY_IS_APPROX(mat3(1, 1, 1), mat1(1, 0, 0) * mat2(1, 1, 0, 0) + mat1(1, 1, 0) * mat2(1, 1, 1, 0) +
+                                      mat1(1, 0, 1) * mat2(1, 1, 0, 1) + mat1(1, 1, 1) * mat2(1, 1, 1, 1));
+
+  Tensor<float, 2, DataLayout> mat4(2, 2);
+  Tensor<float, 3, DataLayout> mat5(2, 2, 2);
+
+  mat4.setRandom();
+  mat5.setRandom();
+
+  Tensor<float, 1, DataLayout> mat6(2);
+  mat6.setZero();
+  Eigen::array<DimPair, 2> dims2{{DimPair(0, 1), DimPair(1, 0)}};
+  typedef TensorEvaluator<decltype(mat4.contract(mat5, dims2)), DefaultDevice> Evaluator2;
+  Evaluator2 eval2(mat4.contract(mat5, dims2), DefaultDevice());
+  eval2.evalTo(mat6.data());
+  EIGEN_STATIC_ASSERT(Evaluator2::NumDims == 1ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  VERIFY_IS_EQUAL(eval2.dimensions()[0], 2);
+
+  VERIFY_IS_APPROX(mat6(0), mat4(0, 0) * mat5(0, 0, 0) + mat4(1, 0) * mat5(0, 1, 0) + mat4(0, 1) * mat5(1, 0, 0) +
+                                mat4(1, 1) * mat5(1, 1, 0));
+  VERIFY_IS_APPROX(mat6(1), mat4(0, 0) * mat5(0, 0, 1) + mat4(1, 0) * mat5(0, 1, 1) + mat4(0, 1) * mat5(1, 0, 1) +
+                                mat4(1, 1) * mat5(1, 1, 1));
+}
+
+template <int DataLayout>
+static void test_holes() {
+  Tensor<float, 4, DataLayout> t1(2, 5, 7, 3);
+  Tensor<float, 5, DataLayout> t2(2, 7, 11, 13, 3);
+  t1.setRandom();
+  t2.setRandom();
+
+  Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(3, 4)}};
+  Tensor<float, 5, DataLayout> result = t1.contract(t2, dims);
+  VERIFY_IS_EQUAL(result.dimension(0), 5);
+  VERIFY_IS_EQUAL(result.dimension(1), 7);
+  VERIFY_IS_EQUAL(result.dimension(2), 7);
+  VERIFY_IS_EQUAL(result.dimension(3), 11);
+  VERIFY_IS_EQUAL(result.dimension(4), 13);
+
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 5; ++l) {
+          for (int m = 0; m < 5; ++m) {
+            VERIFY_IS_APPROX(result(i, j, k, l, m),
+                             t1(0, i, j, 0) * t2(0, k, l, m, 0) + t1(1, i, j, 0) * t2(1, k, l, m, 0) +
+                                 t1(0, i, j, 1) * t2(0, k, l, m, 1) + t1(1, i, j, 1) * t2(1, k, l, m, 1) +
+                                 t1(0, i, j, 2) * t2(0, k, l, m, 2) + t1(1, i, j, 2) * t2(1, k, l, m, 2));
+          }
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_full_redux() {
+  Tensor<float, 2, DataLayout> t1(2, 2);
+  Tensor<float, 3, DataLayout> t2(2, 2, 2);
+  t1.setRandom();
+  t2.setRandom();
+
+  Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(1, 1)}};
+  Tensor<float, 1, DataLayout> result = t1.contract(t2, dims);
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_APPROX(result(0),
+                   t1(0, 0) * t2(0, 0, 0) + t1(1, 0) * t2(1, 0, 0) + t1(0, 1) * t2(0, 1, 0) + t1(1, 1) * t2(1, 1, 0));
+  VERIFY_IS_APPROX(result(1),
+                   t1(0, 0) * t2(0, 0, 1) + t1(1, 0) * t2(1, 0, 1) + t1(0, 1) * t2(0, 1, 1) + t1(1, 1) * t2(1, 1, 1));
+
+  dims[0] = DimPair(1, 0);
+  dims[1] = DimPair(2, 1);
+  result = t2.contract(t1, dims);
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_APPROX(result(0),
+                   t1(0, 0) * t2(0, 0, 0) + t1(1, 0) * t2(0, 1, 0) + t1(0, 1) * t2(0, 0, 1) + t1(1, 1) * t2(0, 1, 1));
+  VERIFY_IS_APPROX(result(1),
+                   t1(0, 0) * t2(1, 0, 0) + t1(1, 0) * t2(1, 1, 0) + t1(0, 1) * t2(1, 0, 1) + t1(1, 1) * t2(1, 1, 1));
+}
+
+template <int DataLayout>
+static void test_contraction_of_contraction() {
+  Tensor<float, 2, DataLayout> t1(2, 2);
+  Tensor<float, 2, DataLayout> t2(2, 2);
+  Tensor<float, 2, DataLayout> t3(2, 2);
+  Tensor<float, 2, DataLayout> t4(2, 2);
+  t1.setRandom();
+  t2.setRandom();
+  t3.setRandom();
+  t4.setRandom();
+
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+  auto contract1 = t1.contract(t2, dims);
+  auto diff = t3 - contract1;
+  auto contract2 = t1.contract(t4, dims);
+  Tensor<float, 2, DataLayout> result = contract2.contract(diff, dims);
+
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 2);
+
+  Eigen::Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> m1(t1.data(), 2, 2), m2(t2.data(), 2, 2),
+      m3(t3.data(), 2, 2), m4(t4.data(), 2, 2);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> expected = (m1 * m4) * (m3 - m1 * m2);
+
+  VERIFY_IS_APPROX(result(0, 0), expected(0, 0));
+  VERIFY_IS_APPROX(result(0, 1), expected(0, 1));
+  VERIFY_IS_APPROX(result(1, 0), expected(1, 0));
+  VERIFY_IS_APPROX(result(1, 1), expected(1, 1));
+}
+
+template <int DataLayout>
+static void test_expr() {
+  Tensor<float, 2, DataLayout> mat1(2, 3);
+  Tensor<float, 2, DataLayout> mat2(3, 2);
+  mat1.setRandom();
+  mat2.setRandom();
+
+  Tensor<float, 2, DataLayout> mat3(2, 2);
+
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+  mat3 = mat1.contract(mat2, dims);
+
+  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(0, 1) * mat2(1, 0) + mat1(0, 2) * mat2(2, 0));
+  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0) * mat2(0, 1) + mat1(0, 1) * mat2(1, 1) + mat1(0, 2) * mat2(2, 1));
+  VERIFY_IS_APPROX(mat3(1, 0), mat1(1, 0) * mat2(0, 0) + mat1(1, 1) * mat2(1, 0) + mat1(1, 2) * mat2(2, 0));
+  VERIFY_IS_APPROX(mat3(1, 1), mat1(1, 0) * mat2(0, 1) + mat1(1, 1) * mat2(1, 1) + mat1(1, 2) * mat2(2, 1));
+}
+
+template <int DataLayout>
+static void test_out_of_order_contraction() {
+  Tensor<float, 3, DataLayout> mat1(2, 2, 2);
+  Tensor<float, 3, DataLayout> mat2(2, 2, 2);
+
+  mat1.setRandom();
+  mat2.setRandom();
+
+  Tensor<float, 2, DataLayout> mat3(2, 2);
+
+  Eigen::array<DimPair, 2> dims = {{DimPair(2, 0), DimPair(0, 2)}};
+  mat3 = mat1.contract(mat2, dims);
+
+  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0, 0) * mat2(0, 0, 0) + mat1(1, 0, 0) * mat2(0, 0, 1) +
+                                   mat1(0, 0, 1) * mat2(1, 0, 0) + mat1(1, 0, 1) * mat2(1, 0, 1));
+  VERIFY_IS_APPROX(mat3(1, 0), mat1(0, 1, 0) * mat2(0, 0, 0) + mat1(1, 1, 0) * mat2(0, 0, 1) +
+                                   mat1(0, 1, 1) * mat2(1, 0, 0) + mat1(1, 1, 1) * mat2(1, 0, 1));
+  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0, 0) * mat2(0, 1, 0) + mat1(1, 0, 0) * mat2(0, 1, 1) +
+                                   mat1(0, 0, 1) * mat2(1, 1, 0) + mat1(1, 0, 1) * mat2(1, 1, 1));
+  VERIFY_IS_APPROX(mat3(1, 1), mat1(0, 1, 0) * mat2(0, 1, 0) + mat1(1, 1, 0) * mat2(0, 1, 1) +
+                                   mat1(0, 1, 1) * mat2(1, 1, 0) + mat1(1, 1, 1) * mat2(1, 1, 1));
+
+  Eigen::array<DimPair, 2> dims2 = {{DimPair(0, 2), DimPair(2, 0)}};
+  mat3 = mat1.contract(mat2, dims2);
+
+  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0, 0) * mat2(0, 0, 0) + mat1(1, 0, 0) * mat2(0, 0, 1) +
+                                   mat1(0, 0, 1) * mat2(1, 0, 0) + mat1(1, 0, 1) * mat2(1, 0, 1));
+  VERIFY_IS_APPROX(mat3(1, 0), mat1(0, 1, 0) * mat2(0, 0, 0) + mat1(1, 1, 0) * mat2(0, 0, 1) +
+                                   mat1(0, 1, 1) * mat2(1, 0, 0) + mat1(1, 1, 1) * mat2(1, 0, 1));
+  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0, 0) * mat2(0, 1, 0) + mat1(1, 0, 0) * mat2(0, 1, 1) +
+                                   mat1(0, 0, 1) * mat2(1, 1, 0) + mat1(1, 0, 1) * mat2(1, 1, 1));
+  VERIFY_IS_APPROX(mat3(1, 1), mat1(0, 1, 0) * mat2(0, 1, 0) + mat1(1, 1, 0) * mat2(0, 1, 1) +
+                                   mat1(0, 1, 1) * mat2(1, 1, 0) + mat1(1, 1, 1) * mat2(1, 1, 1));
+}
+
+template <int DataLayout>
+static void test_consistency() {
+  // this does something like testing (A*B)^T = (B^T * A^T)
+
+  Tensor<float, 3, DataLayout> mat1(4, 3, 5);
+  Tensor<float, 5, DataLayout> mat2(3, 2, 1, 5, 4);
+  mat1.setRandom();
+  mat2.setRandom();
+
+  Tensor<float, 4, DataLayout> mat3(5, 2, 1, 5);
+  Tensor<float, 4, DataLayout> mat4(2, 1, 5, 5);
+
+  // contract on dimensions of size 4 and 3
+  Eigen::array<DimPair, 2> dims1 = {{DimPair(0, 4), DimPair(1, 0)}};
+  Eigen::array<DimPair, 2> dims2 = {{DimPair(4, 0), DimPair(0, 1)}};
+
+  mat3 = mat1.contract(mat2, dims1);
+  mat4 = mat2.contract(mat1, dims2);
+
+  // check that these are equal except for ordering of dimensions
+  if (DataLayout == ColMajor) {
+    for (size_t i = 0; i < 5; i++) {
+      for (size_t j = 0; j < 10; j++) {
+        VERIFY_IS_APPROX(mat3.data()[i + 5 * j], mat4.data()[j + 10 * i]);
+      }
+    }
+  } else {
+    // Row major
+    for (size_t i = 0; i < 5; i++) {
+      for (size_t j = 0; j < 10; j++) {
+        VERIFY_IS_APPROX(mat3.data()[10 * i + j], mat4.data()[i + 5 * j]);
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_large_contraction() {
+  Tensor<float, 4, DataLayout> t_left(30, 50, 8, 31);
+  Tensor<float, 5, DataLayout> t_right(8, 31, 7, 20, 10);
+  Tensor<float, 5, DataLayout> t_result(30, 50, 7, 20, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 1500, 248);
+  MapXf m_right(t_right.data(), 248, 1400);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 2> dims = {{DimPair(2, 0), DimPair(3, 1)}};
+
+  // compute results by separate methods
+  t_result = t_left.contract(t_right, dims);
+  m_result = m_left * m_right;
+
+  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
+    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
+  }
+}
+
+template <int DataLayout>
+static void test_matrix_vector() {
+  Tensor<float, 2, DataLayout> t_left(30, 50);
+  Tensor<float, 1, DataLayout> t_right(50);
+  Tensor<float, 1, DataLayout> t_result(30);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 30, 50);
+  MapXf m_right(t_right.data(), 50, 1);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(30, 1);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // compute results by separate methods
+  t_result = t_left.contract(t_right, dims);
+  m_result = m_left * m_right;
+
+  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY(internal::isApprox(t_result(i), m_result(i, 0), 1));
+  }
+}
+
+// Regression test for issue #1648: contraction y = A^T * x where the LHS
+// contracted dim is the contiguous one. Prior to the fix this dispatched
+// through evalGemv with a mapper that scalar-gathered, producing correct
+// values but >100x slower than the equivalent Matrix expression.
+template <typename Scalar, int DataLayout>
+static void test_matrix_transpose_vector_impl() {
+  for (int M : {1, 5, 16, 17, 64, 129}) {
+    for (int N : {1, 4, 16, 33, 100}) {
+      Tensor<Scalar, 2, DataLayout> t_left(M, N);
+      Tensor<Scalar, 1, DataLayout> t_right(M);
+      t_left.setRandom();
+      t_right.setRandom();
+
+      Eigen::array<DimPair, 1> dims{{DimPair(0, 0)}};
+      Tensor<Scalar, 1, DataLayout> t_result = t_left.contract(t_right, dims);
+
+      typedef Map<const Eigen::Matrix<Scalar, Dynamic, Dynamic, DataLayout>> MapMat;
+      typedef Map<const Eigen::Matrix<Scalar, Dynamic, 1>> MapVec;
+      MapMat m_left(t_left.data(), M, N);
+      MapVec m_right(t_right.data(), M);
+      Eigen::Matrix<Scalar, Dynamic, 1> m_result = m_left.transpose() * m_right;
+
+      for (int j = 0; j < N; ++j) {
+        VERIFY(internal::isApprox(t_result(j), m_result(j), 1));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_matrix_transpose_vector() {
+  test_matrix_transpose_vector_impl<float, DataLayout>();
+  test_matrix_transpose_vector_impl<double, DataLayout>();
+}
+
+template <int DataLayout>
+static void test_tensor_vector() {
+  Tensor<float, 3, DataLayout> t_left(7, 13, 17);
+  Tensor<float, 2, DataLayout> t_right(1, 7);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  typedef typename Tensor<float, 1, DataLayout>::DimensionPair DimensionPair;
+  Eigen::array<DimensionPair, 1> dim_pair01{{{0, 1}}};
+  Tensor<float, 3, DataLayout> t_result = t_left.contract(t_right, dim_pair01);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 7, 13 * 17);
+  MapXf m_right(t_right.data(), 1, 7);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result = m_left.transpose() * m_right.transpose();
+
+  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY(internal::isApprox(t_result(i), m_result(i, 0), 1));
+  }
+}
+
+template <int DataLayout>
+static void test_small_blocking_factors() {
+  Tensor<float, 4, DataLayout> t_left(30, 5, 3, 31);
+  Tensor<float, 5, DataLayout> t_right(3, 31, 7, 20, 1);
+  t_left.setRandom();
+  t_right.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  // Force the cache sizes, which results in smaller blocking factors.
+  Eigen::setCpuCacheSizes(896, 1920, 2944);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 2> dims = {{DimPair(2, 0), DimPair(3, 1)}};
+  Tensor<float, 5, DataLayout> t_result;
+  t_result = t_left.contract(t_right, dims);
+
+  // compute result using a simple eigen matrix product
+  Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> m_left(t_left.data(), 150, 93);
+  Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> m_right(t_right.data(), 93, 140);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result = m_left * m_right;
+
+  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
+  }
+}
+
+template <int DataLayout>
+static void test_tensor_product() {
+  Tensor<float, 2, DataLayout> mat1(2, 3);
+  Tensor<float, 2, DataLayout> mat2(4, 1);
+  mat1.setRandom();
+  mat2.setRandom();
+
+  Eigen::array<DimPair, 0> dims;
+  Tensor<float, 4, DataLayout> result = mat1.contract(mat2, dims);
+
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 3);
+  VERIFY_IS_EQUAL(result.dimension(2), 4);
+  VERIFY_IS_EQUAL(result.dimension(3), 1);
+  for (int i = 0; i < result.dimension(0); ++i) {
+    for (int j = 0; j < result.dimension(1); ++j) {
+      for (int k = 0; k < result.dimension(2); ++k) {
+        for (int l = 0; l < result.dimension(3); ++l) {
+          VERIFY_IS_APPROX(result(i, j, k, l), mat1(i, j) * mat2(k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_const_inputs() {
+  Tensor<float, 2, DataLayout> in1(2, 3);
+  Tensor<float, 2, DataLayout> in2(3, 2);
+  in1.setRandom();
+  in2.setRandom();
+
+  TensorMap<Tensor<const float, 2, DataLayout>> mat1(in1.data(), 2, 3);
+  TensorMap<Tensor<const float, 2, DataLayout>> mat2(in2.data(), 3, 2);
+  Tensor<float, 2, DataLayout> mat3(2, 2);
+
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+  mat3 = mat1.contract(mat2, dims);
+
+  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(0, 1) * mat2(1, 0) + mat1(0, 2) * mat2(2, 0));
+  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0) * mat2(0, 1) + mat1(0, 1) * mat2(1, 1) + mat1(0, 2) * mat2(2, 1));
+  VERIFY_IS_APPROX(mat3(1, 0), mat1(1, 0) * mat2(0, 0) + mat1(1, 1) * mat2(1, 0) + mat1(1, 2) * mat2(2, 0));
+  VERIFY_IS_APPROX(mat3(1, 1), mat1(1, 0) * mat2(0, 1) + mat1(1, 1) * mat2(1, 1) + mat1(1, 2) * mat2(2, 1));
+}
+
+// Apply Sqrt to all output elements.
+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));
+      }
+    }
+  }
+};
+
+template <int DataLayout>
+static void test_large_contraction_with_output_kernel() {
+  Tensor<float, 4, DataLayout> t_left(30, 50, 8, 31);
+  Tensor<float, 5, DataLayout> t_right(8, 31, 7, 20, 10);
+  Tensor<float, 5, DataLayout> t_result(30, 50, 7, 20, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+  // Put trash in mat4 to verify contraction clears output memory.
+  t_result.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 1500, 248);
+  MapXf m_right(t_right.data(), 248, 1400);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 2> dims{{DimPair(2, 0), DimPair(3, 1)}};
+
+  // compute results by separate methods
+  t_result = t_left.contract(t_right, dims, SqrtOutputKernel());
+
+  m_result = m_left * m_right;
+
+  for (std::ptrdiff_t i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
+    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
+  }
+}
+
+// Tensors whose StorageIndex is narrower than Eigen::Index instantiate the GEBP kernel with that index type, which
+// the architecture-specific kernels have to support.
+template <int DataLayout, typename Scalar>
+static void test_narrow_index_contraction() {
+  typedef Tensor<Scalar, 2, DataLayout, int> TensorType;
+  typedef typename TensorType::DimensionPair NarrowDimPair;
+
+  TensorType t_left(53, 37);
+  TensorType t_right(37, 41);
+  TensorType t_result(53, 41);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  typedef Map<Eigen::Matrix<Scalar, Dynamic, Dynamic, DataLayout>> MapType;
+  MapType m_left(t_left.data(), 53, 37);
+  MapType m_right(t_right.data(), 37, 41);
+  Eigen::Matrix<Scalar, Dynamic, Dynamic, DataLayout> m_result(53, 41);
+
+  Eigen::array<NarrowDimPair, 1> dims{{NarrowDimPair(1, 0)}};
+
+  t_result = t_left.contract(t_right, dims);
+  m_result = m_left * m_right;
+
+  for (int i = 0; i < t_result.size(); ++i) {
+    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
+  }
+}
+
+template <int DataLayout, typename Scalar>
+static void test_zero_dim_contraction_2d() {
+  // Test {10, 0} * {0, 20} -> {10, 20}
+  Tensor<Scalar, 2, DataLayout> t_left(10, 0);
+  Tensor<Scalar, 2, DataLayout> t_right(0, 20);
+
+  // Pre-fill destination tensor with non-zero values to verify that contraction actively zeroes output memory.
+  const Scalar non_zero = Scalar(123);
+  Tensor<Scalar, 2, DataLayout> t_result(10, 20);
+  t_result.setConstant(non_zero);
+
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+  t_result = t_left.contract(t_right, dims);
+
+  VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+  VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+  VERIFY_IS_EQUAL(t_result.size(), 200);
+
+  for (Index i = 0; i < t_result.dimension(0); ++i) {
+    for (Index j = 0; j < t_result.dimension(1); ++j) {
+      VERIFY_IS_EQUAL(t_result(i, j), Scalar(0));
+    }
+  }
+
+  // Also test via TensorEvaluator directly with evalTo into pre-filled memory.
+  Tensor<Scalar, 2, DataLayout> t_result_eval(10, 20);
+  t_result_eval.setConstant(non_zero);
+  typedef TensorEvaluator<decltype(t_left.contract(t_right, dims)), DefaultDevice> Evaluator;
+  Evaluator eval(t_left.contract(t_right, dims), DefaultDevice());
+  eval.evalTo(t_result_eval.data());
+  for (Index i = 0; i < t_result_eval.size(); ++i) {
+    VERIFY_IS_EQUAL(t_result_eval.data()[i], Scalar(0));
+  }
+
+  // Test large contraction: {64, 0} * {0, 64} -> {64, 64}
+  // This exercises the path where max(m, n) >= 48, which previously triggered a
+  // SIGFPE (division by zero) in computeProductBlockingSizes.
+  {
+    Tensor<Scalar, 2, DataLayout> t_left_large(64, 0);
+    Tensor<Scalar, 2, DataLayout> t_right_large(0, 64);
+    Tensor<Scalar, 2, DataLayout> t_result_large(64, 64);
+    t_result_large.setConstant(non_zero);
+
+    t_result_large = t_left_large.contract(t_right_large, dims);
+
+    VERIFY_IS_EQUAL(t_result_large.dimension(0), 64);
+    VERIFY_IS_EQUAL(t_result_large.dimension(1), 64);
+    VERIFY_IS_EQUAL(t_result_large.size(), 64 * 64);
+
+    for (Index i = 0; i < t_result_large.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result_large.data()[i], Scalar(0));
+    }
+  }
+
+  // 1D Vector contractions (GEMV shapes)
+  // Matrix {10, 0} * Vector {0} -> Vector {10}
+  Tensor<Scalar, 1, DataLayout> vec_right(0);
+  Tensor<Scalar, 1, DataLayout> vec_result(10);
+  vec_result.setConstant(non_zero);
+  vec_result = t_left.contract(vec_right, dims);
+  VERIFY_IS_EQUAL(vec_result.dimension(0), 10);
+  for (Index i = 0; i < vec_result.size(); ++i) {
+    VERIFY_IS_EQUAL(vec_result(i), Scalar(0));
+  }
+
+  // Vector {0} * Matrix {0, 20} -> Vector {20}
+  Tensor<Scalar, 1, DataLayout> vec_left(0);
+  Tensor<Scalar, 1, DataLayout> vec_result2(20);
+  vec_result2.setConstant(non_zero);
+  Eigen::array<DimPair, 1> dims_vm = {{DimPair(0, 0)}};
+  vec_result2 = vec_left.contract(t_right, dims_vm);
+  VERIFY_IS_EQUAL(vec_result2.dimension(0), 20);
+  for (Index i = 0; i < vec_result2.size(); ++i) {
+    VERIFY_IS_EQUAL(vec_result2(i), Scalar(0));
+  }
+
+  // Vector {0} * Vector {0} -> Scalar {}
+  Tensor<Scalar, 0, DataLayout> scalar_result;
+  scalar_result() = non_zero;
+  scalar_result = vec_left.contract(vec_right, dims_vm);
+  VERIFY_IS_EQUAL(scalar_result(), Scalar(0));
+}
+
+template <int DataLayout, typename Scalar>
+static void test_zero_dim_contraction_multidims() {
+  // Test {5, 0, 4} * {0, 3, 4} with contraction dims {1, 0} and {2, 2} -> {5, 3}
+  Tensor<Scalar, 3, DataLayout> t_left(5, 0, 4);
+  Tensor<Scalar, 3, DataLayout> t_right(0, 3, 4);
+
+  const Scalar non_zero = Scalar(123);
+  Tensor<Scalar, 2, DataLayout> t_result(5, 3);
+  t_result.setConstant(non_zero);
+
+  Eigen::array<DimPair, 2> dims = {{DimPair(1, 0), DimPair(2, 2)}};
+  t_result = t_left.contract(t_right, dims);
+
+  VERIFY_IS_EQUAL(t_result.dimension(0), 5);
+  VERIFY_IS_EQUAL(t_result.dimension(1), 3);
+  VERIFY_IS_EQUAL(t_result.size(), 15);
+
+  for (Index i = 0; i < t_result.dimension(0); ++i) {
+    for (Index j = 0; j < t_result.dimension(1); ++j) {
+      VERIFY_IS_EQUAL(t_result(i, j), Scalar(0));
+    }
+  }
+
+  // 4D contractions: {2, 5, 0, 3} * {0, 4, 3, 2} with contraction dims {2, 0} and {3, 2} -> {2, 5, 4, 2}
+  Tensor<Scalar, 4, DataLayout> t_left4(2, 5, 0, 3);
+  Tensor<Scalar, 4, DataLayout> t_right4(0, 4, 3, 2);
+  Tensor<Scalar, 4, DataLayout> t_result4(2, 5, 4, 2);
+  t_result4.setConstant(non_zero);
+
+  Eigen::array<DimPair, 2> dims4 = {{DimPair(2, 0), DimPair(3, 2)}};
+  t_result4 = t_left4.contract(t_right4, dims4);
+
+  VERIFY_IS_EQUAL(t_result4.dimension(0), 2);
+  VERIFY_IS_EQUAL(t_result4.dimension(1), 5);
+  VERIFY_IS_EQUAL(t_result4.dimension(2), 4);
+  VERIFY_IS_EQUAL(t_result4.dimension(3), 2);
+  VERIFY_IS_EQUAL(t_result4.size(), 80);
+
+  for (Index i = 0; i < t_result4.size(); ++i) {
+    VERIFY_IS_EQUAL(t_result4.data()[i], Scalar(0));
+  }
+}
+
+template <int DataLayout, typename Scalar>
+static void test_zero_dim_contraction_outer_zeros() {
+  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+
+  // Outer zero on LHS: {0, 5} * {5, 10} -> {0, 10}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(0, 5);
+    Tensor<Scalar, 2, DataLayout> t_right(5, 10);
+    t_right.setRandom();
+    Tensor<Scalar, 2, DataLayout> t_result(0, 10);
+    t_result = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 10);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Outer zero on RHS: {10, 5} * {5, 0} -> {10, 0}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(10, 5);
+    Tensor<Scalar, 2, DataLayout> t_right(5, 0);
+    t_left.setRandom();
+    Tensor<Scalar, 2, DataLayout> t_result(10, 0);
+    t_result = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 0);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Outer zero on both LHS and RHS: {0, 5} * {5, 0} -> {0, 0}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(0, 5);
+    Tensor<Scalar, 2, DataLayout> t_right(5, 0);
+    Tensor<Scalar, 2, DataLayout> t_result(0, 0);
+    t_result = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 0);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Both outer and inner zero: {0, 0} * {0, 10} -> {0, 10}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(0, 0);
+    Tensor<Scalar, 2, DataLayout> t_right(0, 10);
+    Tensor<Scalar, 2, DataLayout> t_result(0, 10);
+    t_result = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 10);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Both outer and inner zero: {10, 0} * {0, 0} -> {10, 0}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(10, 0);
+    Tensor<Scalar, 2, DataLayout> t_right(0, 0);
+    Tensor<Scalar, 2, DataLayout> t_result(10, 0);
+    t_result = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 0);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Both outer and inner zero: {0, 0} * {0, 0} -> {0, 0}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(0, 0);
+    Tensor<Scalar, 2, DataLayout> t_right(0, 0);
+    Tensor<Scalar, 2, DataLayout> t_result(0, 0);
+    t_result = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 0);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Multidimensional with outer zero: {0, 3, 4} * {3, 2, 4} with contraction dims {1, 0} and {2, 2} -> {0, 2}
+  {
+    Tensor<Scalar, 3, DataLayout> t_left(0, 3, 4);
+    Tensor<Scalar, 3, DataLayout> t_right(3, 2, 4);
+    t_right.setRandom();
+    Eigen::array<DimPair, 2> dims_md = {{DimPair(1, 0), DimPair(2, 2)}};
+    Tensor<Scalar, 2, DataLayout> t_result(0, 2);
+    t_result = t_left.contract(t_right, dims_md);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 2);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+}
+
+template <typename Scalar>
+struct AddBiasOutputKernel {
+  Scalar bias;
+  explicit AddBiasOutputKernel(Scalar b) : bias(b) {}
+
+  template <typename Index, typename ResScalar>
+  EIGEN_ALWAYS_INLINE void operator()(const internal::blas_data_mapper<ResScalar, Index, ColMajor>& output_mapper,
+                                      const TensorContractionParams&, Index, Index, Index num_rows,
+                                      Index num_cols) const {
+    for (Index i = 0; i < num_rows; ++i) {
+      for (Index j = 0; j < num_cols; ++j) {
+        output_mapper(i, j) += bias;
+      }
+    }
+  }
+};
+
+template <int DataLayout, typename Scalar>
+static void test_zero_dim_contraction_output_kernel() {
+  const Scalar non_zero = Scalar(123);
+  const Scalar bias = Scalar(42);
+
+  // 2D contraction with bias addition on zero-sized contraction dimension:
+  // {10, 0} * {0, 20} -> {10, 20}
+  // The contraction sum is 0, so output kernel adds bias to produce `bias` everywhere.
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(10, 0);
+    Tensor<Scalar, 2, DataLayout> t_right(0, 20);
+    Tensor<Scalar, 2, DataLayout> t_result(10, 20);
+    t_result.setConstant(non_zero);
+
+    Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+    t_result = t_left.contract(t_right, dims, AddBiasOutputKernel<Scalar>(bias));
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+    for (Index i = 0; i < t_result.dimension(0); ++i) {
+      for (Index j = 0; j < t_result.dimension(1); ++j) {
+        VERIFY_IS_EQUAL(t_result(i, j), bias);
+      }
+    }
+  }
+
+  // 2D contraction with SqrtOutputKernel on zero-sized contraction dimension:
+  // sqrt(0) == 0
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(10, 0);
+    Tensor<Scalar, 2, DataLayout> t_right(0, 20);
+    Tensor<Scalar, 2, DataLayout> t_result(10, 20);
+    t_result.setConstant(non_zero);
+
+    Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+    t_result = t_left.contract(t_right, dims, SqrtOutputKernel());
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], Scalar(0));
+    }
+  }
+
+  // Large contraction with bias addition on zero-sized contraction dimension:
+  // {64, 0} * {0, 64} -> {64, 64}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left_large(64, 0);
+    Tensor<Scalar, 2, DataLayout> t_right_large(0, 64);
+    Tensor<Scalar, 2, DataLayout> t_result_large(64, 64);
+    t_result_large.setConstant(non_zero);
+
+    Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+    t_result_large = t_left_large.contract(t_right_large, dims, AddBiasOutputKernel<Scalar>(bias));
+
+    VERIFY_IS_EQUAL(t_result_large.dimension(0), 64);
+    VERIFY_IS_EQUAL(t_result_large.dimension(1), 64);
+    for (Index i = 0; i < t_result_large.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result_large.data()[i], bias);
+    }
+  }
+
+  // Multidimensional contraction with bias: {5, 0, 4} * {0, 3, 4} -> {5, 3}
+  {
+    Tensor<Scalar, 3, DataLayout> t_left(5, 0, 4);
+    Tensor<Scalar, 3, DataLayout> t_right(0, 3, 4);
+    Tensor<Scalar, 2, DataLayout> t_result(5, 3);
+    t_result.setConstant(non_zero);
+
+    Eigen::array<DimPair, 2> dims = {{DimPair(1, 0), DimPair(2, 2)}};
+    t_result = t_left.contract(t_right, dims, AddBiasOutputKernel<Scalar>(bias));
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 5);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 3);
+    for (Index i = 0; i < t_result.dimension(0); ++i) {
+      for (Index j = 0; j < t_result.dimension(1); ++j) {
+        VERIFY_IS_EQUAL(t_result(i, j), bias);
+      }
+    }
+  }
+
+  // GEMV-shape contraction with bias (e.g. 1 column in RHS): {10, 0} * {0, 1} -> {10, 1}
+  {
+    Tensor<Scalar, 2, DataLayout> t_left(10, 0);
+    Tensor<Scalar, 2, DataLayout> t_right(0, 1);
+    Tensor<Scalar, 2, DataLayout> t_result(10, 1);
+    t_result.setConstant(non_zero);
+
+    Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
+    t_result = t_left.contract(t_right, dims, AddBiasOutputKernel<Scalar>(bias));
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 1);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], bias);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_contraction) {
+  CALL_SUBTEST_1(test_evals<ColMajor>());
+  CALL_SUBTEST_1(test_evals<RowMajor>());
+  CALL_SUBTEST_1(test_scalar<ColMajor>());
+  CALL_SUBTEST_1(test_scalar<RowMajor>());
+  CALL_SUBTEST_2(test_multidims<ColMajor>());
+  CALL_SUBTEST_2(test_multidims<RowMajor>());
+  CALL_SUBTEST_2(test_holes<ColMajor>());
+  CALL_SUBTEST_2(test_holes<RowMajor>());
+  CALL_SUBTEST_3(test_full_redux<ColMajor>());
+  CALL_SUBTEST_3(test_full_redux<RowMajor>());
+  CALL_SUBTEST_3(test_contraction_of_contraction<ColMajor>());
+  CALL_SUBTEST_3(test_contraction_of_contraction<RowMajor>());
+  CALL_SUBTEST_4(test_expr<ColMajor>());
+  CALL_SUBTEST_4(test_expr<RowMajor>());
+  CALL_SUBTEST_4(test_out_of_order_contraction<ColMajor>());
+  CALL_SUBTEST_4(test_out_of_order_contraction<RowMajor>());
+  CALL_SUBTEST_5(test_consistency<ColMajor>());
+  CALL_SUBTEST_5(test_consistency<RowMajor>());
+  CALL_SUBTEST_5(test_large_contraction<ColMajor>());
+  CALL_SUBTEST_5(test_large_contraction<RowMajor>());
+  CALL_SUBTEST_6(test_matrix_vector<ColMajor>());
+  CALL_SUBTEST_6(test_matrix_vector<RowMajor>());
+  CALL_SUBTEST_6(test_matrix_transpose_vector<ColMajor>());
+  CALL_SUBTEST_6(test_matrix_transpose_vector<RowMajor>());
+  CALL_SUBTEST_6(test_tensor_vector<ColMajor>());
+  CALL_SUBTEST_6(test_tensor_vector<RowMajor>());
+  CALL_SUBTEST_7(test_small_blocking_factors<ColMajor>());
+  CALL_SUBTEST_7(test_small_blocking_factors<RowMajor>());
+  CALL_SUBTEST_7(test_tensor_product<ColMajor>());
+  CALL_SUBTEST_7(test_tensor_product<RowMajor>());
+  CALL_SUBTEST_8(test_const_inputs<ColMajor>());
+  CALL_SUBTEST_8(test_const_inputs<RowMajor>());
+  CALL_SUBTEST_8(test_large_contraction_with_output_kernel<ColMajor>());
+  CALL_SUBTEST_8(test_large_contraction_with_output_kernel<RowMajor>());
+  CALL_SUBTEST_9((test_narrow_index_contraction<ColMajor, float>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<RowMajor, float>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<ColMajor, double>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<RowMajor, double>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<ColMajor, std::complex<float>>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<RowMajor, std::complex<float>>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<ColMajor, std::complex<double>>()));
+  CALL_SUBTEST_9((test_narrow_index_contraction<RowMajor, std::complex<double>>()));
+
+  // Zero-dimension contraction tests:
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<ColMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<RowMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<ColMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<RowMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<ColMajor, std::complex<float>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<RowMajor, std::complex<float>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<ColMajor, std::complex<double>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_2d<RowMajor, std::complex<double>>()));
+
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<ColMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<RowMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<ColMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<RowMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<ColMajor, std::complex<float>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<RowMajor, std::complex<float>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<ColMajor, std::complex<double>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_multidims<RowMajor, std::complex<double>>()));
+
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<ColMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<RowMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<ColMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<RowMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<ColMajor, std::complex<float>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<RowMajor, std::complex<float>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<ColMajor, std::complex<double>>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_outer_zeros<RowMajor, std::complex<double>>()));
+
+  CALL_SUBTEST_10((test_zero_dim_contraction_output_kernel<ColMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_output_kernel<RowMajor, float>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_output_kernel<ColMajor, double>()));
+  CALL_SUBTEST_10((test_zero_dim_contraction_output_kernel<RowMajor, double>()));
+
+  // Force CMake to split this test.
+  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8;9;10
+}
diff --git a/contrib/test/tensor_convolution.cpp b/contrib/test/tensor_convolution.cpp
new file mode 100644
index 0000000..f3c91ca
--- /dev/null
+++ b/contrib/test/tensor_convolution.cpp
@@ -0,0 +1,146 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::DefaultDevice;
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_evals() {
+  Tensor<float, 2, DataLayout> input(3, 3);
+  Tensor<float, 1, DataLayout> kernel(2);
+
+  input.setRandom();
+  kernel.setRandom();
+
+  Tensor<float, 2, DataLayout> result(2, 3);
+  result.setZero();
+  Eigen::array<Tensor<float, 2>::Index, 1> dims3;
+  dims3[0] = 0;
+
+  typedef TensorEvaluator<decltype(input.convolve(kernel, dims3)), DefaultDevice> Evaluator;
+  Evaluator eval(input.convolve(kernel, dims3), DefaultDevice());
+  eval.evalTo(result.data());
+  EIGEN_STATIC_ASSERT(Evaluator::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
+  VERIFY_IS_EQUAL(eval.dimensions()[0], 2);
+  VERIFY_IS_EQUAL(eval.dimensions()[1], 3);
+
+  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0) + input(1, 0) * kernel(1));  // index 0
+  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0) + input(1, 1) * kernel(1));  // index 2
+  VERIFY_IS_APPROX(result(0, 2), input(0, 2) * kernel(0) + input(1, 2) * kernel(1));  // index 4
+  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0) + input(2, 0) * kernel(1));  // index 1
+  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0) + input(2, 1) * kernel(1));  // index 3
+  VERIFY_IS_APPROX(result(1, 2), input(1, 2) * kernel(0) + input(2, 2) * kernel(1));  // index 5
+}
+
+template <int DataLayout>
+static void test_expr() {
+  Tensor<float, 2, DataLayout> input(3, 3);
+  Tensor<float, 2, DataLayout> kernel(2, 2);
+  input.setRandom();
+  kernel.setRandom();
+
+  Tensor<float, 2, DataLayout> result(2, 2);
+  Eigen::array<ptrdiff_t, 2> dims;
+  dims[0] = 0;
+  dims[1] = 1;
+  result = input.convolve(kernel, dims);
+
+  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0, 0) + input(0, 1) * kernel(0, 1) + input(1, 0) * kernel(1, 0) +
+                                     input(1, 1) * kernel(1, 1));
+  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0, 0) + input(0, 2) * kernel(0, 1) + input(1, 1) * kernel(1, 0) +
+                                     input(1, 2) * kernel(1, 1));
+  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0, 0) + input(1, 1) * kernel(0, 1) + input(2, 0) * kernel(1, 0) +
+                                     input(2, 1) * kernel(1, 1));
+  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0, 0) + input(1, 2) * kernel(0, 1) + input(2, 1) * kernel(1, 0) +
+                                     input(2, 2) * kernel(1, 1));
+}
+
+template <int DataLayout>
+static void test_modes() {
+  Tensor<float, 1, DataLayout> input(3);
+  Tensor<float, 1, DataLayout> kernel(3);
+  input(0) = 1.0f;
+  input(1) = 2.0f;
+  input(2) = 3.0f;
+  kernel(0) = 0.5f;
+  kernel(1) = 1.0f;
+  kernel(2) = 0.0f;
+
+  Eigen::array<ptrdiff_t, 1> dims;
+  dims[0] = 0;
+  Eigen::array<std::pair<ptrdiff_t, ptrdiff_t>, 1> padding;
+
+  // Emulate VALID mode (as defined in
+  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
+  padding[0] = std::make_pair(0, 0);
+  Tensor<float, 1, DataLayout> valid(1);
+  valid = input.pad(padding).convolve(kernel, dims);
+  VERIFY_IS_EQUAL(valid.dimension(0), 1);
+  VERIFY_IS_APPROX(valid(0), 2.5f);
+
+  // Emulate SAME mode (as defined in
+  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
+  padding[0] = std::make_pair(1, 1);
+  Tensor<float, 1, DataLayout> same(3);
+  same = input.pad(padding).convolve(kernel, dims);
+  VERIFY_IS_EQUAL(same.dimension(0), 3);
+  VERIFY_IS_APPROX(same(0), 1.0f);
+  VERIFY_IS_APPROX(same(1), 2.5f);
+  VERIFY_IS_APPROX(same(2), 4.0f);
+
+  // Emulate FULL mode (as defined in
+  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
+  padding[0] = std::make_pair(2, 2);
+  Tensor<float, 1, DataLayout> full(5);
+  full = input.pad(padding).convolve(kernel, dims);
+  VERIFY_IS_EQUAL(full.dimension(0), 5);
+  VERIFY_IS_APPROX(full(0), 0.0f);
+  VERIFY_IS_APPROX(full(1), 1.0f);
+  VERIFY_IS_APPROX(full(2), 2.5f);
+  VERIFY_IS_APPROX(full(3), 4.0f);
+  VERIFY_IS_APPROX(full(4), 1.5f);
+}
+
+template <int DataLayout>
+static void test_strides() {
+  Tensor<float, 1, DataLayout> input(13);
+  Tensor<float, 1, DataLayout> kernel(3);
+  input.setRandom();
+  kernel.setRandom();
+
+  Eigen::array<ptrdiff_t, 1> dims;
+  dims[0] = 0;
+  Eigen::array<ptrdiff_t, 1> stride_of_3;
+  stride_of_3[0] = 3;
+  Eigen::array<ptrdiff_t, 1> stride_of_2;
+  stride_of_2[0] = 2;
+
+  Tensor<float, 1, DataLayout> result;
+  result = input.stride(stride_of_3).convolve(kernel, dims).stride(stride_of_2);
+
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_APPROX(result(0), (input(0) * kernel(0) + input(3) * kernel(1) + input(6) * kernel(2)));
+  VERIFY_IS_APPROX(result(1), (input(6) * kernel(0) + input(9) * kernel(1) + input(12) * kernel(2)));
+}
+
+EIGEN_DECLARE_TEST(tensor_convolution) {
+  CALL_SUBTEST(test_evals<ColMajor>());
+  CALL_SUBTEST(test_evals<RowMajor>());
+  CALL_SUBTEST(test_expr<ColMajor>());
+  CALL_SUBTEST(test_expr<RowMajor>());
+  CALL_SUBTEST(test_modes<ColMajor>());
+  CALL_SUBTEST(test_modes<RowMajor>());
+  CALL_SUBTEST(test_strides<ColMajor>());
+  CALL_SUBTEST(test_strides<RowMajor>());
+}
diff --git a/contrib/test/tensor_convolution_sycl.cpp b/contrib/test/tensor_convolution_sycl.cpp
new file mode 100644
index 0000000..8366310
--- /dev/null
+++ b/contrib/test/tensor_convolution_sycl.cpp
@@ -0,0 +1,460 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include <iostream>
+#include <chrono>
+#include <ctime>
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+#include <iomanip>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+// Absolute slack for accumulation-order differences between device and host float convolutions.
+static const float error_threshold = 1024 * NumTraits<float>::epsilon();
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_larg_expr1D(const Eigen::SyclDevice& sycl_device) {
+  IndexType indim0 = 53;
+  IndexType indim1 = 55;
+  IndexType indim2 = 51;
+  IndexType outdim0 = 50;
+  IndexType outdim1 = 55;
+  IndexType outdim2 = 51;
+  Eigen::array<IndexType, 3> input_dims = {{indim0, indim1, indim2}};
+  Eigen::array<IndexType, 1> kernel_dims = {{4}};
+  Eigen::array<IndexType, 3> result_dims = {{outdim0, outdim1, outdim2}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> result(result_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> result_host(result_dims);
+
+  Eigen::array<IndexType, 1> dims3{0};
+
+  input.setRandom();
+  kernel.setRandom();
+  result.setZero();
+  result_host.setZero();
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t result_bytes = result.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_result(d_result, result_dims);
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
+  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
+
+  result_host = input.convolve(kernel, dims3);
+
+  for (IndexType i = 0; i < outdim0; i++) {
+    for (IndexType j = 0; j < outdim1; j++) {
+      for (IndexType k = 0; k < outdim2; k++) {
+        if (!(Eigen::internal::isApprox(result(i, j, k), result_host(i, j, k), error_threshold))) {
+          std::cout << std::setprecision(16) << "mismatch detected at index  ( " << i << " , " << j << ", " << k
+                    << " ) "
+                    << " \t " << result(i, j, k) << " vs " << result_host(i, j, k) << std::endl;
+          assert(false);
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(d_input);
+  sycl_device.deallocate(d_kernel);
+  sycl_device.deallocate(d_result);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_larg_expr2D(const Eigen::SyclDevice& sycl_device) {
+  IndexType indim0 = 53;
+  IndexType indim1 = 55;
+  IndexType indim2 = 51;
+  IndexType outdim0 = 50;
+  IndexType outdim1 = 51;
+  IndexType outdim2 = 51;
+  Eigen::array<IndexType, 3> input_dims = {{indim0, indim1, indim2}};
+  Eigen::array<IndexType, 2> kernel_dims = {{4, 5}};
+  Eigen::array<IndexType, 3> result_dims = {{outdim0, outdim1, outdim2}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> kernel(kernel_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> result(result_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> result_host(result_dims);
+
+  Eigen::array<IndexType, 2> dims3{{0, 1}};
+
+  input.setRandom();
+  kernel.setRandom();
+  result.setZero();
+  result_host.setZero();
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t result_bytes = result.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_result(d_result, result_dims);
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
+  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
+
+  result_host = input.convolve(kernel, dims3);
+
+  for (IndexType i = 0; i < outdim0; i++) {
+    for (IndexType j = 0; j < outdim1; j++) {
+      for (IndexType k = 0; k < outdim2; k++) {
+        if (!(Eigen::internal::isApprox(result(i, j, k), result_host(i, j, k), error_threshold))) {
+          std::cout << std::setprecision(16) << "mismatch detected at index  ( " << i << " , " << j << ", " << k
+                    << " ) "
+                    << " \t " << result(i, j, k) << " vs " << result_host(i, j, k) << std::endl;
+          assert(false);
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(d_input);
+  sycl_device.deallocate(d_kernel);
+  sycl_device.deallocate(d_result);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_larg_expr3D(const Eigen::SyclDevice& sycl_device) {
+  IndexType indim0 = 53;
+  IndexType indim1 = 55;
+  IndexType indim2 = 51;
+  IndexType outdim0 = 50;
+  IndexType outdim1 = 51;
+  IndexType outdim2 = 49;
+  Eigen::array<IndexType, 3> input_dims = {{indim0, indim1, indim2}};
+  Eigen::array<IndexType, 3> kernel_dims = {{4, 5, 3}};
+  Eigen::array<IndexType, 3> result_dims = {{outdim0, outdim1, outdim2}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> kernel(kernel_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> result(result_dims);
+  Tensor<DataType, 3, DataLayout, IndexType> result_host(result_dims);
+
+  Eigen::array<IndexType, 3> dims3{{0, 1, 2}};
+
+  input.setRandom();
+  kernel.setRandom();
+  result.setZero();
+  result_host.setZero();
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t result_bytes = result.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_result(d_result, result_dims);
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
+  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
+
+  result_host = input.convolve(kernel, dims3);
+
+  for (IndexType i = 0; i < outdim0; i++) {
+    for (IndexType j = 0; j < outdim1; j++) {
+      for (IndexType k = 0; k < outdim2; k++) {
+        if (!(Eigen::internal::isApprox(result(i, j, k), result_host(i, j, k), error_threshold))) {
+          std::cout << std::setprecision(16) << "mismatch detected at index  ( " << i << " , " << j << ", " << k
+                    << " ) "
+                    << " \t " << result(i, j, k) << " vs " << result_host(i, j, k) << std::endl;
+          assert(false);
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(d_input);
+  sycl_device.deallocate(d_kernel);
+  sycl_device.deallocate(d_result);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_evals(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 2> input_dims = {{3, 3}};
+  Eigen::array<IndexType, 1> kernel_dims = {{2}};
+  Eigen::array<IndexType, 2> result_dims = {{2, 3}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> result(result_dims);
+
+  Eigen::array<IndexType, 1> dims3{0};
+
+  input.setRandom();
+  kernel.setRandom();
+  result.setZero();
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t result_bytes = result.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_result(d_result, result_dims);
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
+  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
+
+  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0) + input(1, 0) * kernel(1));  // index 0
+  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0) + input(1, 1) * kernel(1));  // index 2
+  VERIFY_IS_APPROX(result(0, 2), input(0, 2) * kernel(0) + input(1, 2) * kernel(1));  // index 4
+  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0) + input(2, 0) * kernel(1));  // index 1
+  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0) + input(2, 1) * kernel(1));  // index 3
+  VERIFY_IS_APPROX(result(1, 2), input(1, 2) * kernel(0) + input(2, 2) * kernel(1));  // index 5
+
+  sycl_device.deallocate(d_input);
+  sycl_device.deallocate(d_kernel);
+  sycl_device.deallocate(d_result);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_expr(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 2> input_dims = {{3, 3}};
+  Eigen::array<IndexType, 2> kernel_dims = {{2, 2}};
+  Eigen::array<IndexType, 2> result_dims = {{2, 2}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> kernel(kernel_dims);
+  Tensor<DataType, 2, DataLayout, IndexType> result(result_dims);
+
+  input.setRandom();
+  kernel.setRandom();
+  Eigen::array<IndexType, 2> dims;
+  dims[0] = 0;
+  dims[1] = 1;
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t result_bytes = result.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_result(d_result, result_dims);
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims);
+  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
+
+  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0, 0) + input(0, 1) * kernel(0, 1) + input(1, 0) * kernel(1, 0) +
+                                     input(1, 1) * kernel(1, 1));
+  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0, 0) + input(0, 2) * kernel(0, 1) + input(1, 1) * kernel(1, 0) +
+                                     input(1, 2) * kernel(1, 1));
+  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0, 0) + input(1, 1) * kernel(0, 1) + input(2, 0) * kernel(1, 0) +
+                                     input(2, 1) * kernel(1, 1));
+  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0, 0) + input(1, 2) * kernel(0, 1) + input(2, 1) * kernel(1, 0) +
+                                     input(2, 2) * kernel(1, 1));
+
+  sycl_device.deallocate(d_input);
+  sycl_device.deallocate(d_kernel);
+  sycl_device.deallocate(d_result);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_modes(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 1> input_dims = {{3}};
+  Eigen::array<IndexType, 1> kernel_dims = {{3}};
+
+  Tensor<DataType, 1, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
+
+  input.setRandom();
+  kernel.setRandom();
+  Eigen::array<IndexType, 1> dims;
+  dims[0] = 0;
+
+  input(0) = 1.0f;
+  input(1) = 2.0f;
+  input(2) = 3.0f;
+  kernel(0) = 0.5f;
+  kernel(1) = 1.0f;
+  kernel(2) = 0.0f;
+
+  Eigen::array<std::pair<IndexType, IndexType>, 1> padding;
+
+  // Emulate VALID mode (as defined in
+  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
+  padding[0] = std::make_pair(0, 0);
+  Tensor<DataType, 1, DataLayout, IndexType> valid(1);
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t valid_bytes = valid.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_valid = static_cast<DataType*>(sycl_device.allocate(valid_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_valid(d_valid, valid.dimensions());
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_valid.device(sycl_device) = gpu_input.pad(padding).convolve(gpu_kernel, dims);
+  sycl_device.memcpyDeviceToHost(valid.data(), d_valid, valid_bytes);
+
+  VERIFY_IS_EQUAL(valid.dimension(0), 1);
+  VERIFY_IS_APPROX(valid(0), 2.5f);
+
+  // Emulate SAME mode (as defined in
+  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
+  padding[0] = std::make_pair(1, 1);
+  Tensor<DataType, 1, DataLayout, IndexType> same(3);
+  std::size_t same_bytes = same.size() * sizeof(DataType);
+  DataType* d_same = static_cast<DataType*>(sycl_device.allocate(same_bytes));
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_same(d_same, same.dimensions());
+  gpu_same.device(sycl_device) = gpu_input.pad(padding).convolve(gpu_kernel, dims);
+  sycl_device.memcpyDeviceToHost(same.data(), d_same, same_bytes);
+
+  VERIFY_IS_EQUAL(same.dimension(0), 3);
+  VERIFY_IS_APPROX(same(0), 1.0f);
+  VERIFY_IS_APPROX(same(1), 2.5f);
+  VERIFY_IS_APPROX(same(2), 4.0f);
+
+  // Emulate FULL mode (as defined in
+  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
+  padding[0] = std::make_pair(2, 2);
+
+  Tensor<DataType, 1, DataLayout, IndexType> full(5);
+  std::size_t full_bytes = full.size() * sizeof(DataType);
+  DataType* d_full = static_cast<DataType*>(sycl_device.allocate(full_bytes));
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_full(d_full, full.dimensions());
+  gpu_full.device(sycl_device) = gpu_input.pad(padding).convolve(gpu_kernel, dims);
+  sycl_device.memcpyDeviceToHost(full.data(), d_full, full_bytes);
+
+  VERIFY_IS_EQUAL(full.dimension(0), 5);
+  VERIFY_IS_APPROX(full(0), 0.0f);
+  VERIFY_IS_APPROX(full(1), 1.0f);
+  VERIFY_IS_APPROX(full(2), 2.5f);
+  VERIFY_IS_APPROX(full(3), 4.0f);
+  VERIFY_IS_APPROX(full(4), 1.5f);
+
+  sycl_device.deallocate(d_input);
+  sycl_device.deallocate(d_kernel);
+  sycl_device.deallocate(d_valid);
+  sycl_device.deallocate(d_same);
+  sycl_device.deallocate(d_full);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_strides(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 1> input_dims = {{13}};
+  Eigen::array<IndexType, 1> kernel_dims = {{3}};
+
+  Tensor<DataType, 1, DataLayout, IndexType> input(input_dims);
+  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
+  Tensor<DataType, 1, DataLayout, IndexType> result(2);
+
+  input.setRandom();
+  kernel.setRandom();
+  Eigen::array<IndexType, 1> dims;
+  dims[0] = 0;
+
+  Eigen::array<IndexType, 1> stride_of_3;
+  stride_of_3[0] = 3;
+  Eigen::array<IndexType, 1> stride_of_2;
+  stride_of_2[0] = 2;
+
+  std::size_t input_bytes = input.size() * sizeof(DataType);
+  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
+  std::size_t result_bytes = result.size() * sizeof(DataType);
+
+  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
+  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
+  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_input(d_input, input_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_result(d_result, result.dimensions());
+  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
+  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
+
+  gpu_result.device(sycl_device) = gpu_input.stride(stride_of_3).convolve(gpu_kernel, dims).stride(stride_of_2);
+  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
+
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_APPROX(result(0), (input(0) * kernel(0) + input(3) * kernel(1) + input(6) * kernel(2)));
+  VERIFY_IS_APPROX(result(1), (input(6) * kernel(0) + input(9) * kernel(1) + input(12) * kernel(2)));
+}
+
+template <typename Dev_selector>
+void tensorConvolutionPerDevice(Dev_selector& s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_larg_expr1D<float, RowMajor, int64_t>(sycl_device);
+  test_larg_expr1D<float, ColMajor, int64_t>(sycl_device);
+  test_larg_expr2D<float, RowMajor, int64_t>(sycl_device);
+  test_larg_expr2D<float, ColMajor, int64_t>(sycl_device);
+  test_larg_expr3D<float, RowMajor, int64_t>(sycl_device);
+  test_larg_expr3D<float, ColMajor, int64_t>(sycl_device);
+  test_evals<float, ColMajor, int64_t>(sycl_device);
+  test_evals<float, RowMajor, int64_t>(sycl_device);
+  test_expr<float, ColMajor, int64_t>(sycl_device);
+  test_expr<float, RowMajor, int64_t>(sycl_device);
+  test_modes<float, ColMajor, int64_t>(sycl_device);
+  test_modes<float, RowMajor, int64_t>(sycl_device);
+  test_strides<float, ColMajor, int64_t>(sycl_device);
+  test_strides<float, RowMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_convolution_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(tensorConvolutionPerDevice(device));
+  }
+}
diff --git a/contrib/test/tensor_cost_model.cpp b/contrib/test/tensor_cost_model.cpp
new file mode 100644
index 0000000..58eb996
--- /dev/null
+++ b/contrib/test/tensor_cost_model.cpp
@@ -0,0 +1,54 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 The Eigen Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::DefaultDevice;
+using Eigen::Tensor;
+using Eigen::TensorEvaluator;
+
+// Regression: TensorCwiseNullaryOp must report bytes_loaded == 0.
+// NullaryOps (constants, Zero, Identity, Random, sequence generators)
+// produce values from registers or minimal state without loading from
+// memory. If they reported nonzero bytes_loaded, expressions dominated
+// by constants (e.g. Horner-form polynomials) would be misclassified as
+// memory-bound and the threadpool cost model would over-restrict
+// parallelism. See TensorEvaluator.h, the CwiseNullaryOp specialization
+// of costPerCoeff().
+template <typename Scalar>
+static void test_nullary_zero_bytes_loaded() {
+  Tensor<Scalar, 1> shape(/*size=*/16);
+  auto zeros = shape.constant(Scalar(0));
+  auto sevens = shape.constant(Scalar(7));
+
+  using ZeroEval = TensorEvaluator<const decltype(zeros), DefaultDevice>;
+  using ConstEval = TensorEvaluator<const decltype(sevens), DefaultDevice>;
+
+  DefaultDevice device;
+  ZeroEval zero_eval(zeros, device);
+  ConstEval const_eval(sevens, device);
+
+  for (bool vectorized : {false, true}) {
+    const auto zero_cost = zero_eval.costPerCoeff(vectorized);
+    const auto const_cost = const_eval.costPerCoeff(vectorized);
+    VERIFY_IS_EQUAL(zero_cost.bytes_loaded(), 0.0);
+    VERIFY_IS_EQUAL(zero_cost.bytes_stored(), 0.0);
+    VERIFY_IS_EQUAL(const_cost.bytes_loaded(), 0.0);
+    VERIFY_IS_EQUAL(const_cost.bytes_stored(), 0.0);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_cost_model) {
+  CALL_SUBTEST(test_nullary_zero_bytes_loaded<float>());
+  CALL_SUBTEST(test_nullary_zero_bytes_loaded<double>());
+  CALL_SUBTEST(test_nullary_zero_bytes_loaded<int>());
+}
diff --git a/contrib/test/tensor_custom_index.cpp b/contrib/test/tensor_custom_index.cpp
new file mode 100644
index 0000000..efb04f6
--- /dev/null
+++ b/contrib/test/tensor_custom_index.cpp
@@ -0,0 +1,84 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <limits>
+#include <map>
+
+#include <Eigen/Dense>
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_map_as_index() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  using NormalIndex = DSizes<ptrdiff_t, 4>;
+  using CustomIndex = std::map<ptrdiff_t, ptrdiff_t>;
+  CustomIndex coeffC;
+  coeffC[0] = 1;
+  coeffC[1] = 2;
+  coeffC[2] = 4;
+  coeffC[3] = 1;
+  NormalIndex coeff(1, 2, 4, 1);
+
+  VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff));
+  VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff));
+}
+
+template <int DataLayout>
+static void test_matrix_as_index() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  using NormalIndex = DSizes<ptrdiff_t, 4>;
+  using CustomIndex = Matrix<unsigned int, 4, 1>;
+  CustomIndex coeffC(1, 2, 4, 1);
+  NormalIndex coeff(1, 2, 4, 1);
+
+  VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff));
+  VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff));
+}
+
+template <int DataLayout>
+static void test_varlist_as_index() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  DSizes<ptrdiff_t, 4> coeff(1, 2, 4, 1);
+
+  VERIFY_IS_EQUAL(tensor.coeff({1, 2, 4, 1}), tensor.coeff(coeff));
+  VERIFY_IS_EQUAL(tensor.coeffRef({1, 2, 4, 1}), tensor.coeffRef(coeff));
+}
+
+template <int DataLayout>
+static void test_sizes_as_index() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  DSizes<ptrdiff_t, 4> coeff(1, 2, 4, 1);
+  Sizes<1, 2, 4, 1> coeffC;
+
+  VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff));
+  VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff));
+}
+
+EIGEN_DECLARE_TEST(tensor_custom_index) {
+  test_map_as_index<ColMajor>();
+  test_map_as_index<RowMajor>();
+  test_matrix_as_index<ColMajor>();
+  test_matrix_as_index<RowMajor>();
+  test_varlist_as_index<ColMajor>();
+  test_varlist_as_index<RowMajor>();
+  test_sizes_as_index<ColMajor>();
+  test_sizes_as_index<RowMajor>();
+}
diff --git a/contrib/test/tensor_custom_op.cpp b/contrib/test/tensor_custom_op.cpp
new file mode 100644
index 0000000..39abce8
--- /dev/null
+++ b/contrib/test/tensor_custom_op.cpp
@@ -0,0 +1,416 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+struct InsertZeros {
+  DSizes<DenseIndex, 2> dimensions(const Tensor<float, 2>& input) const {
+    DSizes<DenseIndex, 2> result;
+    result[0] = input.dimension(0) * 2;
+    result[1] = input.dimension(1) * 2;
+    return result;
+  }
+
+  template <typename Output, typename Device>
+  void eval(const Tensor<float, 2>& input, Output& output, const Device& device) const {
+    array<DenseIndex, 2> strides;
+    strides[0] = 2;
+    strides[1] = 2;
+    output.stride(strides).device(device) = input;
+
+    Eigen::DSizes<DenseIndex, 2> offsets(1, 1);
+    Eigen::DSizes<DenseIndex, 2> extents(output.dimension(0) - 1, output.dimension(1) - 1);
+    output.slice(offsets, extents).stride(strides).device(device) = input.constant(0.0f);
+  }
+};
+
+static void test_custom_unary_op() {
+  Tensor<float, 2> tensor(3, 5);
+  tensor.setRandom();
+
+  Tensor<float, 2> result = tensor.customOp(InsertZeros());
+  VERIFY_IS_EQUAL(result.dimension(0), 6);
+  VERIFY_IS_EQUAL(result.dimension(1), 10);
+
+  for (int i = 0; i < 6; i += 2) {
+    for (int j = 0; j < 10; j += 2) {
+      VERIFY_IS_EQUAL(result(i, j), tensor(i / 2, j / 2));
+    }
+  }
+  for (int i = 1; i < 6; i += 2) {
+    for (int j = 1; j < 10; j += 2) {
+      VERIFY_IS_EQUAL(result(i, j), 0);
+    }
+  }
+}
+
+struct BatchMatMul {
+  DSizes<DenseIndex, 3> dimensions(const Tensor<float, 3>& input1, const Tensor<float, 3>& input2) const {
+    DSizes<DenseIndex, 3> result;
+    result[0] = input1.dimension(0);
+    result[1] = input2.dimension(1);
+    result[2] = input2.dimension(2);
+    return result;
+  }
+
+  template <typename Output, typename Device>
+  void eval(const Tensor<float, 3>& input1, const Tensor<float, 3>& input2, Output& output,
+            const Device& device) const {
+    typedef Tensor<float, 3>::DimensionPair DimPair;
+    array<DimPair, 1> dims;
+    dims[0] = DimPair(1, 0);
+    for (int i = 0; i < output.dimension(2); ++i) {
+      output.template chip<2>(i).device(device) = input1.chip<2>(i).contract(input2.chip<2>(i), dims);
+    }
+  }
+};
+
+static void test_custom_binary_op() {
+  Tensor<float, 3> tensor1(2, 3, 5);
+  tensor1.setRandom();
+  Tensor<float, 3> tensor2(3, 7, 5);
+  tensor2.setRandom();
+
+  Tensor<float, 3> result = tensor1.customOp(tensor2, BatchMatMul());
+  for (int i = 0; i < 5; ++i) {
+    typedef Tensor<float, 3>::DimensionPair DimPair;
+    array<DimPair, 1> dims;
+    dims[0] = DimPair(1, 0);
+    Tensor<float, 2> reference = tensor1.chip<2>(i).contract(tensor2.chip<2>(i), dims);
+    TensorRef<Tensor<float, 2> > val = result.chip<2>(i);
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(val(j, k), reference(j, k));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+struct InsertZerosLayout {
+  DSizes<DenseIndex, 2> dimensions(const Tensor<float, 2, DataLayout>& input) const {
+    DSizes<DenseIndex, 2> result;
+    result[0] = input.dimension(0) * 2;
+    result[1] = input.dimension(1) * 2;
+    return result;
+  }
+
+  template <typename Output, typename Device>
+  void eval(const Tensor<float, 2, DataLayout>& input, Output& output, const Device& device) const {
+    output.device(device) = output.constant(0.0f);
+
+    array<DenseIndex, 2> strides;
+    strides[0] = 2;
+    strides[1] = 2;
+    output.stride(strides).device(device) = input;
+  }
+};
+
+template <int DataLayout>
+static float insert_zeros_reference(const Tensor<float, 2, DataLayout>& input, Index i, Index j) {
+  return i % 2 == 0 && j % 2 == 0 ? input(i / 2, j / 2) : 0.0f;
+}
+
+template <int DataLayout>
+static void test_custom_op_raw_access() {
+  // The custom-op evaluators materialize into a dense buffer, so they must
+  // advertise raw access like TensorForcedEvalOp.
+  typedef Tensor<float, 2, DataLayout> Tensor2;
+
+  Tensor2 tensor(13, 17);
+  tensor.setRandom();
+
+  auto custom_expr = tensor.customOp(InsertZerosLayout<DataLayout>());
+  typedef TensorEvaluator<const decltype(custom_expr), DefaultDevice> CustomEval;
+  static_assert(CustomEval::RawAccess == 1, "custom op must expose its materialized buffer");
+
+  // Padding consumes the custom op directly through data().
+  Eigen::array<std::pair<Index, Index>, 2> paddings;
+  paddings[0] = {2, 3};
+  paddings[1] = {1, 4};
+  Tensor2 result = custom_expr.pad(paddings);
+
+  VERIFY_IS_EQUAL(result.dimension(0), 2 + 26 + 3);
+  VERIFY_IS_EQUAL(result.dimension(1), 1 + 34 + 4);
+  for (Index i = 0; i < result.dimension(0); ++i) {
+    for (Index j = 0; j < result.dimension(1); ++j) {
+      const bool interior = i >= 2 && i < 2 + 26 && j >= 1 && j < 1 + 34;
+      if (interior) {
+        const Index ii = i - 2;
+        const Index jj = j - 1;
+        VERIFY_IS_EQUAL(result(i, j), insert_zeros_reference(tensor, ii, jj));
+      } else {
+        VERIFY_IS_EQUAL(result(i, j), 0.0f);
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+struct AddInputsLayout {
+  DSizes<DenseIndex, 2> dimensions(const Tensor<float, 2, DataLayout>& lhs, const Tensor<float, 2, DataLayout>&) const {
+    return lhs.dimensions();
+  }
+
+  template <typename Output, typename Device>
+  void eval(const Tensor<float, 2, DataLayout>& lhs, const Tensor<float, 2, DataLayout>& rhs, Output& output,
+            const Device& device) const {
+    output.device(device) = lhs + rhs;
+  }
+};
+
+template <int DataLayout>
+static void test_custom_op_block_access() {
+  typedef Tensor<float, 2, DataLayout> Tensor2;
+
+  Tensor2 lhs(259, 263);
+  Tensor2 rhs(259, 263);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  // Exceed TensorSlicingOp's coefficient threshold so it delegates to the
+  // custom-op evaluator's block() method instead of its memcpy path.
+  Eigen::array<Index, 2> offsets = {1, 2};
+  Eigen::array<Index, 2> extents;
+  extents[0] = DataLayout == ColMajor ? 129 : 257;
+  extents[1] = DataLayout == ColMajor ? 257 : 129;
+
+  auto unary_expr = lhs.customOp(InsertZerosLayout<DataLayout>());
+  typedef TensorEvaluator<const decltype(unary_expr), DefaultDevice> UnaryEval;
+  static_assert(UnaryEval::BlockAccess == 1, "custom unary op must support block access");
+  Tensor2 unary_result = unary_expr.slice(offsets, extents);
+
+  for (Index i = 0; i < extents[0]; ++i) {
+    for (Index j = 0; j < extents[1]; ++j) {
+      const Index source_i = i + offsets[0];
+      const Index source_j = j + offsets[1];
+      VERIFY_IS_EQUAL(unary_result(i, j), insert_zeros_reference(lhs, source_i, source_j));
+    }
+  }
+
+  auto binary_expr = lhs.customOp(rhs, AddInputsLayout<DataLayout>());
+  typedef TensorEvaluator<const decltype(binary_expr), DefaultDevice> BinaryEval;
+  static_assert(BinaryEval::RawAccess == 1, "custom binary op must expose its materialized buffer");
+  static_assert(BinaryEval::BlockAccess == 1, "custom binary op must support block access");
+  Tensor2 binary_result = binary_expr.slice(offsets, extents);
+
+  for (Index i = 0; i < extents[0]; ++i) {
+    for (Index j = 0; j < extents[1]; ++j) {
+      const Index source_i = i + offsets[0];
+      const Index source_j = j + offsets[1];
+      VERIFY_IS_EQUAL(binary_result(i, j), lhs(source_i, source_j) + rhs(source_i, source_j));
+    }
+  }
+}
+
+struct RowSumOp {
+  // The rank-changing functor from the customOp() documentation example.
+  template <typename Input>
+  DSizes<Index, 1> dimensions(const Input& input) const {
+    return DSizes<Index, 1>(input.dimension(0));
+  }
+
+  template <typename Input, typename Output, typename Device>
+  void eval(const Input& input, Output& output, const Device& device) const {
+    array<Index, 1> reduce_dims{1};
+    output.device(device) = input.sum(reduce_dims);
+  }
+};
+
+struct RowSumExprOp {
+  // Rank-changing functor accepting arbitrary input expressions. Lazy
+  // expressions do not expose dimension(), so sizes are computed with a
+  // TensorEvaluator, whose constructor determines the dimensions without
+  // evaluating the expression.
+  template <typename Input>
+  DSizes<Index, 1> dimensions(const Input& input) const {
+    DefaultDevice device;
+    TensorEvaluator<const Input, DefaultDevice> eval(input, device);
+    return DSizes<Index, 1>(eval.dimensions()[0]);
+  }
+
+  template <typename Input, typename Output, typename Device>
+  void eval(const Input& input, Output& output, const Device& device) const {
+    array<Index, 1> reduce_dims{1};
+    output.device(device) = input.sum(reduce_dims);
+  }
+};
+
+template <int DataLayout>
+static void test_custom_unary_op_output_rank() {
+  // Regression test for issue #3106: the output rank must come from the
+  // functor's dimensions() method, not from the input expression.
+  Tensor<float, 2, DataLayout> tensor(3, 5);
+  tensor.setRandom();
+
+  Tensor<float, 1, DataLayout> row_sums = tensor.customOp(RowSumOp());
+  VERIFY_IS_EQUAL(row_sums.dimension(0), 3);
+  for (Index i = 0; i < 3; ++i) {
+    float expected = 0.0f;
+    for (Index j = 0; j < 5; ++j) {
+      expected += tensor(i, j);
+    }
+    VERIFY_IS_APPROX(row_sums(i), expected);
+  }
+
+  // The input may be an arbitrary expression rather than a plain tensor.
+  Tensor<float, 1, DataLayout> doubled_row_sums = (tensor + tensor).customOp(RowSumExprOp());
+  VERIFY_IS_EQUAL(doubled_row_sums.dimension(0), 3);
+  for (Index i = 0; i < 3; ++i) {
+    VERIFY_IS_APPROX(doubled_row_sums(i), 2.0f * row_sums(i));
+  }
+}
+
+struct OuterProductOp {
+  template <typename Lhs, typename Rhs>
+  DSizes<Index, 2> dimensions(const Lhs& lhs, const Rhs& rhs) const {
+    return DSizes<Index, 2>(lhs.dimension(0), rhs.dimension(0));
+  }
+
+  template <typename Lhs, typename Rhs, typename Output, typename Device>
+  void eval(const Lhs& lhs, const Rhs& rhs, Output& output, const Device& device) const {
+    const array<IndexPair<Index>, 0> contract_dims{};
+    output.device(device) = lhs.contract(rhs, contract_dims);
+  }
+};
+
+template <typename OuterTensor, typename VectorTensor>
+static void verify_outer_product(const OuterTensor& outer, const VectorTensor& lhs, const VectorTensor& rhs) {
+  using OuterIndex = typename OuterTensor::Index;
+  VERIFY_IS_EQUAL(outer.dimension(0), lhs.dimension(0));
+  VERIFY_IS_EQUAL(outer.dimension(1), rhs.dimension(0));
+  for (OuterIndex i = 0; i < outer.dimension(0); ++i) {
+    for (OuterIndex j = 0; j < outer.dimension(1); ++j) {
+      VERIFY_IS_APPROX(outer(i, j), lhs(i) * rhs(j));
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_custom_binary_op_output_rank() {
+  Tensor<float, 1, DataLayout> lhs(3);
+  Tensor<float, 1, DataLayout> rhs(4);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  Tensor<float, 2, DataLayout> outer = lhs.customOp(rhs, OuterProductOp());
+  verify_outer_product(outer, lhs, rhs);
+}
+
+struct OuterProductIntIndexOp {
+  // Returns dimensions with index type int regardless of the expressions'
+  // index type.
+  template <typename Lhs, typename Rhs>
+  DSizes<int, 2> dimensions(const Lhs& lhs, const Rhs& rhs) const {
+    return DSizes<int, 2>(static_cast<int>(lhs.dimension(0)), static_cast<int>(rhs.dimension(0)));
+  }
+
+  template <typename Lhs, typename Rhs, typename Output, typename Device>
+  void eval(const Lhs& lhs, const Rhs& rhs, Output& output, const Device& device) const {
+    const array<IndexPair<typename Lhs::Index>, 0> contract_dims{};
+    output.device(device) = lhs.contract(rhs, contract_dims);
+  }
+};
+
+template <int DataLayout>
+static void test_custom_binary_op_custom_index() {
+  // Operands with a non-default index type: their DSizes<int, ...> dimensions
+  // are promoted into the evaluator's Dimensions and output map.
+  Tensor<float, 1, DataLayout, int> lhs(3);
+  Tensor<float, 1, DataLayout, int> rhs(4);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  Tensor<float, 2, DataLayout, int> outer = lhs.customOp(rhs, OuterProductIntIndexOp());
+  verify_outer_product(outer, lhs, rhs);
+
+  // The functor may also return dimensions with a narrower index type than the
+  // expressions'; the evaluator promotes them.
+  Tensor<float, 1, DataLayout> lhs_default(3);
+  Tensor<float, 1, DataLayout> rhs_default(4);
+  lhs_default.setRandom();
+  rhs_default.setRandom();
+
+  Tensor<float, 2, DataLayout> outer_default = lhs_default.customOp(rhs_default, OuterProductIntIndexOp());
+  verify_outer_product(outer_default, lhs_default, rhs_default);
+}
+
+// An index type as wide as DenseIndex but distinct from it where the platform
+// provides one (long long versus long on LP64), so the output map's index type
+// is pinned on a width tie and not just when the operands are narrower.
+using EqualWidthIndex =
+    std::conditional_t<sizeof(long long) == sizeof(DenseIndex) && !std::is_same<long long, DenseIndex>::value,
+                       long long,
+                       std::conditional_t<sizeof(long) == sizeof(DenseIndex) && !std::is_same<long, DenseIndex>::value,
+                                          long, DenseIndex> >;
+
+template <int DataLayout, typename IndexType>
+struct AddExactOutput {
+  DSizes<IndexType, 2> dimensions(const Tensor<float, 2, DataLayout, IndexType>& lhs,
+                                  const Tensor<float, 2, DataLayout, IndexType>&) const {
+    return DSizes<IndexType, 2>(lhs.dimension(0), lhs.dimension(1));
+  }
+
+  // eval() spells out the exact Output type the evaluator constructs: the
+  // DenseIndex-typed map, for any operand index type no wider than DenseIndex.
+  template <typename Device>
+  void eval(const Tensor<float, 2, DataLayout, IndexType>& lhs, const Tensor<float, 2, DataLayout, IndexType>& rhs,
+            TensorMap<Tensor<float, 2, DataLayout> >& output, const Device& device) const {
+    output.device(device) = lhs + rhs;
+  }
+};
+
+template <int DataLayout, typename IndexType>
+static void verify_exact_output_type() {
+  Tensor<float, 2, DataLayout, IndexType> lhs(3, 4);
+  Tensor<float, 2, DataLayout, IndexType> rhs(3, 4);
+  lhs.setRandom();
+  rhs.setRandom();
+
+  Tensor<float, 2, DataLayout, IndexType> sum = lhs.customOp(rhs, AddExactOutput<DataLayout, IndexType>());
+  VERIFY_IS_EQUAL(sum.dimension(0), 3);
+  VERIFY_IS_EQUAL(sum.dimension(1), 4);
+  for (IndexType i = 0; i < 3; ++i) {
+    for (IndexType j = 0; j < 4; ++j) {
+      VERIFY_IS_APPROX(sum(i, j), lhs(i, j) + rhs(i, j));
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_custom_binary_op_exact_output_type() {
+  // The Output parameter of eval() is a user customization point: functors
+  // written against the concrete DenseIndex-typed TensorMap must keep
+  // compiling for operand index types no wider than DenseIndex, including a
+  // distinct type of the same width.
+  verify_exact_output_type<DataLayout, int>();
+  verify_exact_output_type<DataLayout, EqualWidthIndex>();
+}
+
+EIGEN_DECLARE_TEST(tensor_custom_op) {
+  CALL_SUBTEST(test_custom_unary_op());
+  CALL_SUBTEST(test_custom_binary_op());
+  CALL_SUBTEST(test_custom_op_raw_access<ColMajor>());
+  CALL_SUBTEST(test_custom_op_raw_access<RowMajor>());
+  CALL_SUBTEST(test_custom_op_block_access<ColMajor>());
+  CALL_SUBTEST(test_custom_op_block_access<RowMajor>());
+  CALL_SUBTEST(test_custom_unary_op_output_rank<ColMajor>());
+  CALL_SUBTEST(test_custom_unary_op_output_rank<RowMajor>());
+  CALL_SUBTEST(test_custom_binary_op_output_rank<ColMajor>());
+  CALL_SUBTEST(test_custom_binary_op_output_rank<RowMajor>());
+  CALL_SUBTEST(test_custom_binary_op_custom_index<ColMajor>());
+  CALL_SUBTEST(test_custom_binary_op_custom_index<RowMajor>());
+  CALL_SUBTEST(test_custom_binary_op_exact_output_type<ColMajor>());
+  CALL_SUBTEST(test_custom_binary_op_exact_output_type<RowMajor>());
+}
diff --git a/contrib/test/tensor_custom_op_sycl.cpp b/contrib/test/tensor_custom_op_sycl.cpp
new file mode 100644
index 0000000..de5740a
--- /dev/null
+++ b/contrib/test/tensor_custom_op_sycl.cpp
@@ -0,0 +1,171 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+template <typename TensorType>
+struct InsertZeros {
+  DSizes<DenseIndex, 2> dimensions(const TensorType& input) const {
+    DSizes<DenseIndex, 2> result;
+    result[0] = input.dimension(0) * 2;
+    result[1] = input.dimension(1) * 2;
+    return result;
+  }
+
+  template <typename Output, typename Device>
+  void eval(const TensorType& input, Output& output, const Device& device) const {
+    array<DenseIndex, 2> strides;
+    strides[0] = 2;
+    strides[1] = 2;
+    output.stride(strides).device(device) = input;
+
+    Eigen::DSizes<DenseIndex, 2> offsets(1, 1);
+    Eigen::DSizes<DenseIndex, 2> extents(output.dimension(0) - 1, output.dimension(1) - 1);
+    output.slice(offsets, extents).stride(strides).device(device) = input.constant(0.0f);
+  }
+};
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_custom_unary_op_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 3;
+  IndexType sizeDim2 = 5;
+  Eigen::array<IndexType, 2> tensorRange = {{sizeDim1, sizeDim2}};
+  Eigen::array<IndexType, 2> tensorResultRange = {{6, 10}};
+
+  Eigen::Tensor<DataType, 2, DataLayout, IndexType> in1(tensorRange);
+  Eigen::Tensor<DataType, 2, DataLayout, IndexType> out(tensorResultRange);
+
+  DataType* gpu_in1_data =
+      static_cast<DataType*>(sycl_device.allocate(in1.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
+
+  typedef Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > TensorType;
+  TensorType gpu_in1(gpu_in1_data, tensorRange);
+  TensorType gpu_out(gpu_out_data, tensorResultRange);
+
+  in1.setRandom();
+  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.dimensions().TotalSize()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = gpu_in1.customOp(InsertZeros<TensorType>());
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(out.dimension(0), 6);
+  VERIFY_IS_EQUAL(out.dimension(1), 10);
+
+  for (int i = 0; i < 6; i += 2) {
+    for (int j = 0; j < 10; j += 2) {
+      VERIFY_IS_EQUAL(out(i, j), in1(i / 2, j / 2));
+    }
+  }
+  for (int i = 1; i < 6; i += 2) {
+    for (int j = 1; j < 10; j += 2) {
+      VERIFY_IS_EQUAL(out(i, j), 0);
+    }
+  }
+  sycl_device.deallocate(gpu_in1_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename TensorType>
+struct BatchMatMul {
+  DSizes<DenseIndex, 3> dimensions(const TensorType& input1, const TensorType& input2) const {
+    DSizes<DenseIndex, 3> result;
+    result[0] = input1.dimension(0);
+    result[1] = input2.dimension(1);
+    result[2] = input2.dimension(2);
+    return result;
+  }
+
+  template <typename Output, typename Device>
+  void eval(const TensorType& input1, const TensorType& input2, Output& output, const Device& device) const {
+    typedef typename TensorType::DimensionPair DimPair;
+    array<DimPair, 1> dims;
+    dims[0] = DimPair(1, 0);
+    for (int64_t i = 0; i < output.dimension(2); ++i) {
+      output.template chip<2>(i).device(device) = input1.template chip<2>(i).contract(input2.template chip<2>(i), dims);
+    }
+  }
+};
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_custom_binary_op_sycl(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 3> tensorRange1 = {{2, 3, 5}};
+  Eigen::array<IndexType, 3> tensorRange2 = {{3, 7, 5}};
+  Eigen::array<IndexType, 3> tensorResultRange = {{2, 7, 5}};
+
+  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange1);
+  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange2);
+  Eigen::Tensor<DataType, 3, DataLayout, IndexType> out(tensorResultRange);
+
+  DataType* gpu_in1_data =
+      static_cast<DataType*>(sycl_device.allocate(in1.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_in2_data =
+      static_cast<DataType*>(sycl_device.allocate(in2.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
+
+  typedef Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > TensorType;
+  TensorType gpu_in1(gpu_in1_data, tensorRange1);
+  TensorType gpu_in2(gpu_in2_data, tensorRange2);
+  TensorType gpu_out(gpu_out_data, tensorResultRange);
+
+  in1.setRandom();
+  in2.setRandom();
+
+  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.dimensions().TotalSize()) * sizeof(DataType));
+
+  gpu_out.device(sycl_device) = gpu_in1.customOp(gpu_in2, BatchMatMul<TensorType>());
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < 5; ++i) {
+    typedef typename Eigen::Tensor<DataType, 3, DataLayout, IndexType>::DimensionPair DimPair;
+    array<DimPair, 1> dims;
+    dims[0] = DimPair(1, 0);
+    Eigen::Tensor<DataType, 2, DataLayout, IndexType> reference =
+        in1.template chip<2>(i).contract(in2.template chip<2>(i), dims);
+    TensorRef<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > val = out.template chip<2>(i);
+    for (IndexType j = 0; j < 2; ++j) {
+      for (IndexType k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(val(j, k), reference(j, k));
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_in1_data);
+  sycl_device.deallocate(gpu_in2_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, typename Dev_selector>
+void custom_op_perDevice(Dev_selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_custom_unary_op_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_custom_unary_op_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_custom_binary_op_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_custom_binary_op_sycl<DataType, RowMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_custom_op_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(custom_op_perDevice<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_device.cu b/contrib/test/tensor_device.cu
new file mode 100644
index 0000000..66c81ec
--- /dev/null
+++ b/contrib/test/tensor_device.cu
@@ -0,0 +1,505 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include "OffByOneScalar.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+// Context for evaluation on cpu
+struct CPUContext {
+  CPUContext(const Eigen::Tensor<float, 3>& in1, Eigen::Tensor<float, 3>& in2, Eigen::Tensor<float, 3>& out)
+      : in1_(in1), in2_(in2), out_(out), kernel_1d_(2), kernel_2d_(2, 2), kernel_3d_(2, 2, 2) {
+    kernel_1d_(0) = 3.14f;
+    kernel_1d_(1) = 2.7f;
+
+    kernel_2d_(0, 0) = 3.14f;
+    kernel_2d_(1, 0) = 2.7f;
+    kernel_2d_(0, 1) = 0.2f;
+    kernel_2d_(1, 1) = 7.0f;
+
+    kernel_3d_(0, 0, 0) = 3.14f;
+    kernel_3d_(0, 1, 0) = 2.7f;
+    kernel_3d_(0, 0, 1) = 0.2f;
+    kernel_3d_(0, 1, 1) = 7.0f;
+    kernel_3d_(1, 0, 0) = -1.0f;
+    kernel_3d_(1, 1, 0) = -0.3f;
+    kernel_3d_(1, 0, 1) = -0.7f;
+    kernel_3d_(1, 1, 1) = -0.5f;
+  }
+
+  const Eigen::DefaultDevice& device() const { return cpu_device_; }
+
+  const Eigen::Tensor<float, 3>& in1() const { return in1_; }
+  const Eigen::Tensor<float, 3>& in2() const { return in2_; }
+  Eigen::Tensor<float, 3>& out() { return out_; }
+  const Eigen::Tensor<float, 1>& kernel1d() const { return kernel_1d_; }
+  const Eigen::Tensor<float, 2>& kernel2d() const { return kernel_2d_; }
+  const Eigen::Tensor<float, 3>& kernel3d() const { return kernel_3d_; }
+
+ private:
+  const Eigen::Tensor<float, 3>& in1_;
+  const Eigen::Tensor<float, 3>& in2_;
+  Eigen::Tensor<float, 3>& out_;
+
+  Eigen::Tensor<float, 1> kernel_1d_;
+  Eigen::Tensor<float, 2> kernel_2d_;
+  Eigen::Tensor<float, 3> kernel_3d_;
+
+  Eigen::DefaultDevice cpu_device_;
+};
+
+// Context for evaluation on GPU
+struct GPUContext {
+  GPUContext(const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in1, Eigen::TensorMap<Eigen::Tensor<float, 3>>& in2,
+             Eigen::TensorMap<Eigen::Tensor<float, 3>>& out)
+      : in1_(in1), in2_(in2), out_(out), gpu_device_(&stream_) {
+    assert(gpuMalloc((void**)(&kernel_1d_), 2 * sizeof(float)) == gpuSuccess);
+    float kernel_1d_val[] = {3.14f, 2.7f};
+    assert(gpuMemcpy(kernel_1d_, kernel_1d_val, 2 * sizeof(float), gpuMemcpyHostToDevice) == gpuSuccess);
+
+    assert(gpuMalloc((void**)(&kernel_2d_), 4 * sizeof(float)) == gpuSuccess);
+    float kernel_2d_val[] = {3.14f, 2.7f, 0.2f, 7.0f};
+    assert(gpuMemcpy(kernel_2d_, kernel_2d_val, 4 * sizeof(float), gpuMemcpyHostToDevice) == gpuSuccess);
+
+    assert(gpuMalloc((void**)(&kernel_3d_), 8 * sizeof(float)) == gpuSuccess);
+    float kernel_3d_val[] = {3.14f, -1.0f, 2.7f, -0.3f, 0.2f, -0.7f, 7.0f, -0.5f};
+    assert(gpuMemcpy(kernel_3d_, kernel_3d_val, 8 * sizeof(float), gpuMemcpyHostToDevice) == gpuSuccess);
+  }
+  ~GPUContext() {
+    assert(gpuFree(kernel_1d_) == gpuSuccess);
+    assert(gpuFree(kernel_2d_) == gpuSuccess);
+    assert(gpuFree(kernel_3d_) == gpuSuccess);
+  }
+
+  const Eigen::GpuDevice& device() const { return gpu_device_; }
+
+  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in1() const { return in1_; }
+  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in2() const { return in2_; }
+  Eigen::TensorMap<Eigen::Tensor<float, 3>>& out() { return out_; }
+  Eigen::TensorMap<Eigen::Tensor<float, 1>> kernel1d() const {
+    return Eigen::TensorMap<Eigen::Tensor<float, 1>>(kernel_1d_, 2);
+  }
+  Eigen::TensorMap<Eigen::Tensor<float, 2>> kernel2d() const {
+    return Eigen::TensorMap<Eigen::Tensor<float, 2>>(kernel_2d_, 2, 2);
+  }
+  Eigen::TensorMap<Eigen::Tensor<float, 3>> kernel3d() const {
+    return Eigen::TensorMap<Eigen::Tensor<float, 3>>(kernel_3d_, 2, 2, 2);
+  }
+
+ private:
+  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in1_;
+  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in2_;
+  Eigen::TensorMap<Eigen::Tensor<float, 3>>& out_;
+
+  float* kernel_1d_;
+  float* kernel_2d_;
+  float* kernel_3d_;
+
+  Eigen::GpuStreamDevice stream_;
+  Eigen::GpuDevice gpu_device_;
+};
+
+// The actual expression to evaluate
+template <typename Context>
+void test_contextual_eval(Context* context) {
+  context->out().device(context->device()) = context->in1() + context->in2() * 3.14f + context->in1().constant(2.718f);
+}
+
+template <typename Context>
+void test_forced_contextual_eval(Context* context) {
+  context->out().device(context->device()) =
+      (context->in1() + context->in2()).eval() * 3.14f + context->in1().constant(2.718f);
+}
+
+template <typename Context>
+void test_compound_assignment(Context* context) {
+  context->out().device(context->device()) = context->in1().constant(2.718f);
+  context->out().device(context->device()) += context->in1() + context->in2() * 3.14f;
+}
+
+template <typename Context>
+void test_contraction(Context* context) {
+  Eigen::array<std::pair<int, int>, 2> dims;
+  dims[0] = std::make_pair(1, 1);
+  dims[1] = std::make_pair(2, 2);
+
+  Eigen::array<int, 2> shape{40, 50 * 70};
+
+  Eigen::DSizes<int, 2> indices(0, 0);
+  Eigen::DSizes<int, 2> sizes(40, 40);
+
+  context->out().reshape(shape).slice(indices, sizes).device(context->device()) =
+      context->in1().contract(context->in2(), dims);
+}
+
+template <typename Context>
+void test_1d_convolution(Context* context) {
+  Eigen::DSizes<int, 3> indices(0, 0, 0);
+  Eigen::DSizes<int, 3> sizes(40, 49, 70);
+
+  Eigen::array<int, 1> dims{1};
+  context->out().slice(indices, sizes).device(context->device()) = context->in1().convolve(context->kernel1d(), dims);
+}
+
+template <typename Context>
+void test_2d_convolution(Context* context) {
+  Eigen::DSizes<int, 3> indices(0, 0, 0);
+  Eigen::DSizes<int, 3> sizes(40, 49, 69);
+
+  Eigen::array<int, 2> dims{1, 2};
+  context->out().slice(indices, sizes).device(context->device()) = context->in1().convolve(context->kernel2d(), dims);
+}
+
+template <typename Context>
+void test_3d_convolution(Context* context) {
+  Eigen::DSizes<int, 3> indices(0, 0, 0);
+  Eigen::DSizes<int, 3> sizes(39, 49, 69);
+
+  Eigen::array<int, 3> dims{0, 1, 2};
+  context->out().slice(indices, sizes).device(context->device()) = context->in1().convolve(context->kernel3d(), dims);
+}
+
+// Helper method to synchronize device.
+template <typename Device>
+void synchronize(Device& /*device*/) { /*nothing*/
+}
+template <>
+void synchronize(Eigen::GpuDevice& device) {
+  device.synchronize();
+}
+
+template <typename DataType, typename TensorDevice>
+void test_device_memory(const TensorDevice& device) {
+  int count = 100;
+  Eigen::array<int, 1> tensorRange{count};
+  Eigen::Tensor<DataType, 1> host(tensorRange);
+  Eigen::Tensor<DataType, 1> expected(tensorRange);
+  DataType* device_data = static_cast<DataType*>(device.allocate(count * sizeof(DataType)));
+
+  // memset
+  const char byte_value = static_cast<char>(0xAB);
+  device.memset(device_data, byte_value, count * sizeof(DataType));
+  device.memcpyDeviceToHost(host.data(), device_data, count * sizeof(DataType));
+  synchronize(device);
+  // Cast to void* so the byte-level fill is not diagnosed as writing to a
+  // non-trivial type for scalars like OffByOneScalar.
+  memset(static_cast<void*>(expected.data()), byte_value, count * sizeof(DataType));
+  for (Index i = 0; i < count; i++) {
+    VERIFY_IS_EQUAL(host(i), expected(i));
+  }
+
+  // fill
+  DataType fill_value = DataType(7);
+  std::fill_n(expected.data(), count, fill_value);
+  device.fill(device_data, device_data + count, fill_value);
+  device.memcpyDeviceToHost(host.data(), device_data, count * sizeof(DataType));
+  synchronize(device);
+  for (int i = 0; i < count; i++) {
+    VERIFY_IS_EQUAL(host(i), expected(i));
+  }
+
+  device.deallocate(device_data);
+}
+
+void test_cpu() {
+  Eigen::Tensor<float, 3> in1(40, 50, 70);
+  Eigen::Tensor<float, 3> in2(40, 50, 70);
+  Eigen::Tensor<float, 3> out(40, 50, 70);
+
+  in1 = in1.random() + in1.constant(10.0f);
+  in2 = in2.random() + in2.constant(10.0f);
+
+  CPUContext context(in1, in2, out);
+  test_contextual_eval(&context);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
+      }
+    }
+  }
+
+  test_forced_contextual_eval(&context);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) + in2(i, j, k)) * 3.14f + 2.718f);
+      }
+    }
+  }
+
+  test_compound_assignment(&context);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
+      }
+    }
+  }
+
+  test_contraction(&context);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 40; ++j) {
+      const float result = out(i, j, 0);
+      float expected = 0;
+      for (int k = 0; k < 50; ++k) {
+        for (int l = 0; l < 70; ++l) {
+          expected += in1(i, k, l) * in2(j, k, l);
+        }
+      }
+      VERIFY_IS_APPROX(expected, result);
+    }
+  }
+
+  test_1d_convolution(&context);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 49; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f));
+      }
+    }
+  }
+
+  test_2d_convolution(&context);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 49; ++j) {
+      for (int k = 0; k < 69; ++k) {
+        const float result = out(i, j, k);
+        const float expected =
+            (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f) + (in1(i, j, k + 1) * 0.2f + in1(i, j + 1, k + 1) * 7.0f);
+        // Skip when both values are within float rounding error of zero; the relative check is unreliable there.
+        if (numext::abs(expected) < 1024 * NumTraits<float>::epsilon() &&
+            numext::abs(result) < 1024 * NumTraits<float>::epsilon()) {
+          continue;
+        }
+        VERIFY_IS_APPROX(expected, result);
+      }
+    }
+  }
+
+  test_3d_convolution(&context);
+  for (int i = 0; i < 39; ++i) {
+    for (int j = 0; j < 49; ++j) {
+      for (int k = 0; k < 69; ++k) {
+        const float result = out(i, j, k);
+        const float expected =
+            (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f + in1(i, j, k + 1) * 0.2f + in1(i, j + 1, k + 1) * 7.0f) +
+            (in1(i + 1, j, k) * -1.0f + in1(i + 1, j + 1, k) * -0.3f + in1(i + 1, j, k + 1) * -0.7f +
+             in1(i + 1, j + 1, k + 1) * -0.5f);
+        // Skip when both values are within float rounding error of zero; the relative check is unreliable there.
+        if (numext::abs(expected) < 1024 * NumTraits<float>::epsilon() &&
+            numext::abs(result) < 1024 * NumTraits<float>::epsilon()) {
+          continue;
+        }
+        VERIFY_IS_APPROX(expected, result);
+      }
+    }
+  }
+
+  test_device_memory<float>(context.device());
+  test_device_memory<OffByOneScalar<int>>(context.device());
+}
+
+void test_gpu() {
+  Eigen::Tensor<float, 3> in1(40, 50, 70);
+  Eigen::Tensor<float, 3> in2(40, 50, 70);
+  Eigen::Tensor<float, 3> out(40, 50, 70);
+  in1 = in1.random() + in1.constant(10.0f);
+  in2 = in2.random() + in2.constant(10.0f);
+
+  std::size_t in1_bytes = in1.size() * sizeof(float);
+  std::size_t in2_bytes = in2.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_in1;
+  float* d_in2;
+  float* d_out;
+  gpuMalloc((void**)(&d_in1), in1_bytes);
+  gpuMalloc((void**)(&d_in2), in2_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in2, in2.data(), in2_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 3>> gpu_in1(d_in1, 40, 50, 70);
+  Eigen::TensorMap<Eigen::Tensor<float, 3>> gpu_in2(d_in2, 40, 50, 70);
+  Eigen::TensorMap<Eigen::Tensor<float, 3>> gpu_out(d_out, 40, 50, 70);
+
+  GPUContext context(gpu_in1, gpu_in2, gpu_out);
+  test_contextual_eval(&context);
+  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
+      }
+    }
+  }
+
+  test_forced_contextual_eval(&context);
+  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) + in2(i, j, k)) * 3.14f + 2.718f);
+      }
+    }
+  }
+
+  test_compound_assignment(&context);
+  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 50; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
+      }
+    }
+  }
+
+  test_contraction(&context);
+  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 40; ++j) {
+      const float result = out(i, j, 0);
+      float expected = 0;
+      for (int k = 0; k < 50; ++k) {
+        for (int l = 0; l < 70; ++l) {
+          expected += in1(i, k, l) * in2(j, k, l);
+        }
+      }
+      VERIFY_IS_APPROX(expected, result);
+    }
+  }
+
+  test_1d_convolution(&context);
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, context.device().stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(context.device().stream()) == gpuSuccess);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 49; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f));
+      }
+    }
+  }
+
+  test_2d_convolution(&context);
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, context.device().stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(context.device().stream()) == gpuSuccess);
+  for (int i = 0; i < 40; ++i) {
+    for (int j = 0; j < 49; ++j) {
+      for (int k = 0; k < 69; ++k) {
+        const float result = out(i, j, k);
+        const float expected =
+            (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f + in1(i, j, k + 1) * 0.2f + in1(i, j + 1, k + 1) * 7.0f);
+        VERIFY_IS_APPROX(expected, result);
+      }
+    }
+  }
+
+#if !defined(EIGEN_USE_HIP)
+  // disable this test on the HIP platform
+  // 3D tensor convolutions seem to hang on the HIP platform
+
+  test_3d_convolution(&context);
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, context.device().stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(context.device().stream()) == gpuSuccess);
+  for (int i = 0; i < 39; ++i) {
+    for (int j = 0; j < 49; ++j) {
+      for (int k = 0; k < 69; ++k) {
+        const float result = out(i, j, k);
+        const float expected = (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f + in1(i, j, k + 1) * 0.2f +
+                                in1(i, j + 1, k + 1) * 7.0f + in1(i + 1, j, k) * -1.0f + in1(i + 1, j + 1, k) * -0.3f +
+                                in1(i + 1, j, k + 1) * -0.7f + in1(i + 1, j + 1, k + 1) * -0.5f);
+        VERIFY_IS_APPROX(expected, result);
+      }
+    }
+  }
+
+#endif
+
+  test_device_memory<float>(context.device());
+  test_device_memory<OffByOneScalar<int>>(context.device());
+}
+
+// The attribute cache has to agree with the properties struct on every field both carry, and the accessors built
+// on it have to describe the device the stream belongs to.
+void test_device_attributes() {
+  int device = 0;
+  VERIFY(gpuGetDevice(&device) == gpuSuccess);
+  const Eigen::GpuDeviceAttributes& attributes = Eigen::GetGpuDeviceAttributes(device);
+
+  gpuDeviceProp_t properties;
+  VERIFY(gpuGetDeviceProperties(&properties, device) == gpuSuccess);
+  VERIFY_IS_EQUAL(attributes.multiProcessorCount, properties.multiProcessorCount);
+  VERIFY_IS_EQUAL(attributes.maxThreadsPerBlock, properties.maxThreadsPerBlock);
+  VERIFY_IS_EQUAL(attributes.maxThreadsPerMultiProcessor, properties.maxThreadsPerMultiProcessor);
+  VERIFY_IS_EQUAL(attributes.sharedMemPerBlock, static_cast<int>(properties.sharedMemPerBlock));
+  VERIFY_IS_EQUAL(attributes.computeCapabilityMajor, properties.major);
+  VERIFY_IS_EQUAL(attributes.computeCapabilityMinor, properties.minor);
+  VERIFY_IS_EQUAL(attributes.warpSize, properties.warpSize);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  VERIFY_IS_EQUAL(gpu_device.warpSize(), properties.warpSize);
+  VERIFY_IS_EQUAL(static_cast<int>(gpu_device.numThreads()), properties.warpSize);
+  // Every architecture Eigen supports can opt in to at least what a block gets by default.
+  VERIFY(gpu_device.sharedMemPerBlockOptin() >= gpu_device.sharedMemPerBlock());
+  int pools = 0;
+#if !defined(EIGEN_USE_HIP)
+  int driver_version = 0;
+  VERIFY(cudaDriverGetVersion(&driver_version) == cudaSuccess);
+  if (driver_version >= 11020)
+#endif
+  {
+    VERIFY(gpuDeviceGetAttribute(&pools, gpuDevAttrMemoryPoolsSupported, device) == gpuSuccess);
+  }
+  VERIFY_IS_EQUAL(gpu_device.memoryPoolsSupported(), pools != 0);
+}
+
+// A GpuStreamDevice built for a fixed device answers for that device, not for whichever device the calling thread
+// happens to be bound to: the stream and its allocations live on the configured one. With several devices visible
+// the current device is deliberately set to a different one; with a single device the loop still checks that the
+// configured index is what is reported.
+void test_stream_device_attributes() {
+  int device_count = 0;
+  VERIFY(gpuGetDeviceCount(&device_count) == gpuSuccess);
+  int restore = 0;
+  VERIFY(gpuGetDevice(&restore) == gpuSuccess);
+
+  for (int device = 0; device < device_count; ++device) {
+    VERIFY(gpuSetDevice((device + 1) % device_count) == gpuSuccess);
+    Eigen::GpuStreamDevice stream(device);
+    Eigen::GpuDevice gpu_device(&stream);
+    const Eigen::GpuDeviceAttributes& attributes = Eigen::GetGpuDeviceAttributes(device);
+    VERIFY_IS_EQUAL(gpu_device.warpSize(), attributes.warpSize);
+    VERIFY_IS_EQUAL(static_cast<int>(gpu_device.numThreads()), attributes.warpSize);
+    VERIFY_IS_EQUAL(gpu_device.sharedMemPerBlockOptin(), attributes.sharedMemPerBlockOptin);
+    VERIFY_IS_EQUAL(gpu_device.memoryPoolsSupported(), attributes.memoryPoolsSupported != 0);
+    VERIFY_IS_EQUAL(gpu_device.getNumGpuMultiProcessors(), attributes.multiProcessorCount);
+  }
+
+  VERIFY(gpuSetDevice(restore) == gpuSuccess);
+}
+
+EIGEN_DECLARE_TEST(tensor_device) {
+  CALL_SUBTEST_1(test_cpu());
+  CALL_SUBTEST_2(test_gpu());
+  CALL_SUBTEST_3(test_device_attributes());
+  CALL_SUBTEST_3(test_stream_device_attributes());
+}
diff --git a/contrib/test/tensor_device_sycl.cpp b/contrib/test/tensor_device_sycl.cpp
new file mode 100644
index 0000000..77b6d82
--- /dev/null
+++ b/contrib/test/tensor_device_sycl.cpp
@@ -0,0 +1,91 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include "OffByOneScalar.h"
+#include <contrib/Eigen/Tensor>
+#include <stdint.h>
+#include <iostream>
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_device_memory(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 100;
+  array<IndexType, 1> tensorRange = {{sizeDim1}};
+  Tensor<DataType, 1, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 1, DataLayout, IndexType> in1(tensorRange);
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
+
+  // memset
+  memset(in1.data(), 1, in1.size() * sizeof(DataType));
+  sycl_device.memset(gpu_in_data, 1, in.size() * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(in.data(), gpu_in_data, in.size() * sizeof(DataType));
+  for (IndexType i = 0; i < in.size(); i++) {
+    VERIFY_IS_EQUAL(in(i), in1(i));
+  }
+
+  // fill
+  DataType value = DataType(7);
+  std::fill_n(in1.data(), in1.size(), value);
+  sycl_device.fill(gpu_in_data, gpu_in_data + in.size(), value);
+  sycl_device.memcpyDeviceToHost(in.data(), gpu_in_data, in.size() * sizeof(DataType));
+  for (IndexType i = 0; i < in.size(); i++) {
+    VERIFY_IS_EQUAL(in(i), in1(i));
+  }
+
+  sycl_device.deallocate(gpu_in_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_device_exceptions(const Eigen::SyclDevice& sycl_device) {
+  VERIFY(sycl_device.ok());
+  IndexType sizeDim1 = 100;
+  array<IndexType, 1> tensorDims = {{sizeDim1}};
+  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(sizeDim1 * sizeof(DataType)));
+  sycl_device.memset(gpu_data, 1, sizeDim1 * sizeof(DataType));
+
+  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> in(gpu_data, tensorDims);
+  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> out(gpu_data, tensorDims);
+  out.device(sycl_device) = in / in.constant(0);
+
+  sycl_device.synchronize();
+  VERIFY(!sycl_device.ok());
+  sycl_device.deallocate(gpu_data);
+}
+
+template <typename DataType>
+void sycl_device_test_per_device(const cl::sycl::device& d) {
+  std::cout << "Running on " << d.template get_info<cl::sycl::info::device::name>() << std::endl;
+  QueueInterface queueInterface(d);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_device_memory<DataType, RowMajor, int64_t>(sycl_device);
+  test_device_memory<DataType, ColMajor, int64_t>(sycl_device);
+  /// this test throw an exception. enable it if you want to see the exception
+  // test_device_exceptions<DataType, RowMajor>(sycl_device);
+  /// this test throw an exception. enable it if you want to see the exception
+  // test_device_exceptions<DataType, ColMajor>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_device_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_device_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_device_test_per_device<float>(device));
+    CALL_SUBTEST(sycl_device_test_per_device<OffByOneScalar<int>>(device));
+  }
+}
diff --git a/contrib/test/tensor_dimension.cpp b/contrib/test/tensor_dimension.cpp
new file mode 100644
index 0000000..4c064e2
--- /dev/null
+++ b/contrib/test/tensor_dimension.cpp
@@ -0,0 +1,102 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+static void test_dynamic_size() {
+  Eigen::DSizes<int, 3> dimensions(2, 3, 7);
+
+  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<0>(dimensions), 2);
+  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<1>(dimensions), 3);
+  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<2>(dimensions), 7);
+  VERIFY_IS_EQUAL((int)dimensions.TotalSize(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL((int)dimensions[0], 2);
+  VERIFY_IS_EQUAL((int)dimensions[1], 3);
+  VERIFY_IS_EQUAL((int)dimensions[2], 7);
+}
+
+static void test_fixed_size() {
+  Eigen::Sizes<2, 3, 7> dimensions;
+
+  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<0>(dimensions), 2);
+  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<1>(dimensions), 3);
+  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<2>(dimensions), 7);
+  VERIFY_IS_EQUAL((int)dimensions.TotalSize(), 2 * 3 * 7);
+}
+
+static void test_match() {
+  Eigen::DSizes<unsigned int, 3> dyn((unsigned int)2, (unsigned int)3, (unsigned int)7);
+  Eigen::Sizes<2, 3, 7> stat;
+  VERIFY_IS_EQUAL(Eigen::dimensions_match(dyn, stat), true);
+
+  Eigen::DSizes<int, 3> dyn1(2, 3, 7);
+  Eigen::DSizes<int, 2> dyn2(2, 3);
+  VERIFY_IS_EQUAL(Eigen::dimensions_match(dyn1, dyn2), false);
+}
+
+static void test_rank_zero() {
+  Eigen::Sizes<> scalar;
+  VERIFY_IS_EQUAL((int)scalar.TotalSize(), 1);
+  VERIFY_IS_EQUAL((int)scalar.rank(), 0);
+  VERIFY_IS_EQUAL((int)internal::array_prod(scalar), 1);
+
+  Eigen::DSizes<ptrdiff_t, 0> dscalar;
+  VERIFY_IS_EQUAL((int)dscalar.TotalSize(), 1);
+  VERIFY_IS_EQUAL((int)dscalar.rank(), 0);
+}
+
+static void test_index_type_promotion() {
+  Eigen::DSizes<int, 3> src0(1, 2, 3);
+  Eigen::array<int, 3> src1;
+  src1[0] = 4;
+  src1[1] = 5;
+  src1[2] = 6;
+
+  Eigen::DSizes<long, 3> dst0(src0);
+  Eigen::DSizes<long, 3> dst1(src1);
+
+  VERIFY_IS_EQUAL(dst0[0], 1L);
+  VERIFY_IS_EQUAL(dst0[1], 2L);
+  VERIFY_IS_EQUAL(dst0[2], 3L);
+  VERIFY_IS_EQUAL(dst1[0], 4L);
+  VERIFY_IS_EQUAL(dst1[1], 5L);
+  VERIFY_IS_EQUAL(dst1[2], 6L);
+}
+
+// Regression test for issue #1616: unsigned dimension types must not trigger
+// narrowing errors in the variadic constructor.
+static void test_unsigned_dimensions() {
+  Eigen::DSizes<int, 3> dimensions(2u, 3ul, std::size_t(7));
+
+  VERIFY_IS_EQUAL((int)dimensions[0], 2);
+  VERIFY_IS_EQUAL((int)dimensions[1], 3);
+  VERIFY_IS_EQUAL((int)dimensions[2], 7);
+}
+
+// A dimension the index type cannot represent must assert rather than silently truncate.
+static void test_narrowing_dimensions() {
+  // Fixed width: on ILP32 targets shifting std::size_t by 40 is undefined, and GCC folds it to an in-range 0.
+  VERIFY_RAISES_ASSERT((Eigen::DSizes<int, 3>(2, 3, std::uint64_t(1) << 40)));
+  VERIFY_RAISES_ASSERT((Eigen::DSizes<std::ptrdiff_t, 3>(2, 3, std::size_t(-1))));
+}
+
+EIGEN_DECLARE_TEST(tensor_dimension) {
+  CALL_SUBTEST(test_dynamic_size());
+  CALL_SUBTEST(test_fixed_size());
+  CALL_SUBTEST(test_match());
+  CALL_SUBTEST(test_rank_zero());
+  CALL_SUBTEST(test_index_type_promotion());
+  CALL_SUBTEST(test_unsigned_dimensions());
+  CALL_SUBTEST(test_narrowing_dimensions());
+}
diff --git a/contrib/test/tensor_empty.cpp b/contrib/test/tensor_empty.cpp
new file mode 100644
index 0000000..8ad5954
--- /dev/null
+++ b/contrib/test/tensor_empty.cpp
@@ -0,0 +1,36 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+static void test_empty_tensor() {
+  Tensor<float, 2> source;
+  Tensor<float, 2> tgt1 = source;
+  Tensor<float, 2> tgt2(source);
+  Tensor<float, 2> tgt3;
+  tgt3 = tgt1;
+  tgt3 = tgt2;
+}
+
+static void test_empty_fixed_size_tensor() {
+  TensorFixedSize<float, Sizes<0> > source;
+  TensorFixedSize<float, Sizes<0> > tgt1 = source;
+  TensorFixedSize<float, Sizes<0> > tgt2(source);
+  TensorFixedSize<float, Sizes<0> > tgt3;
+  tgt3 = tgt1;
+  tgt3 = tgt2;
+}
+
+EIGEN_DECLARE_TEST(tensor_empty) {
+  CALL_SUBTEST(test_empty_tensor());
+  CALL_SUBTEST(test_empty_fixed_size_tensor());
+}
diff --git a/contrib/test/tensor_executor.cpp b/contrib/test/tensor_executor.cpp
new file mode 100644
index 0000000..c238436
--- /dev/null
+++ b/contrib/test/tensor_executor.cpp
@@ -0,0 +1,964 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2018 Eugene Zhulenev <ezhulenev@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+#include "../Eigen/SpecialFunctions"
+
+using Eigen::ColMajor;
+using Eigen::RowMajor;
+using Eigen::Tensor;
+using Eigen::internal::TiledEvaluation;
+
+// A set of tests to verify that different TensorExecutor strategies yields the
+// same results for all the ops, supporting tiled evaluation.
+
+// Default assignment that does no use block evaluation or vectorization.
+// We assume that default coefficient evaluation is well tested and correct.
+template <typename Dst, typename Expr>
+void DefaultAssign(Dst& dst, Expr expr) {
+  using Assign = Eigen::TensorAssignOp<Dst, const Expr>;
+  using Executor = Eigen::internal::TensorExecutor<const Assign, DefaultDevice,
+                                                   /*Vectorizable=*/false,
+                                                   /*Tiling=*/TiledEvaluation::Off>;
+
+  Executor::run(Assign(dst, expr), DefaultDevice());
+}
+
+// Assignment with specified device and tiling strategy.
+template <bool Vectorizable, TiledEvaluation Tiling, typename Device, typename Dst, typename Expr>
+void DeviceAssign(Device& d, Dst& dst, Expr expr) {
+  using Assign = Eigen::TensorAssignOp<Dst, const Expr>;
+  using Executor = Eigen::internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+}
+
+template <int NumDims>
+static array<Index, NumDims> RandomDims(int min_dim = 1, int max_dim = 20) {
+  array<Index, NumDims> dims;
+  for (int i = 0; i < NumDims; ++i) {
+    dims[i] = internal::random<int>(min_dim, max_dim);
+  }
+  return dims;
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_unary_expr(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  // Pick a large enough tensor size to bypass small tensor block evaluation
+  // optimization.
+  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
+
+  Tensor<T, NumDims, Options, Index> src(dims);
+  Tensor<T, NumDims, Options, Index> dst(dims);
+
+  src.setRandom();
+  const auto expr = src.square();
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    T square = src.coeff(i) * src.coeff(i);
+    VERIFY_IS_EQUAL(square, dst.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_nullary_expr(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  // A constant() leaf must not disable any executor configuration; in
+  // particular this sweep forces Tiling::On, which requires the nullary
+  // evaluator to serve blocks.
+  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
+
+  Tensor<T, NumDims, Options, Index> src(dims);
+  Tensor<T, NumDims, Options, Index> dst(dims);
+
+  src.setRandom();
+  const auto expr = src * src.constant(T(2));
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(T(2) * src.coeff(i), dst.coeff(i));
+  }
+}
+
+template <typename RandomGenerator>
+void test_random_capabilities(const RandomGenerator& generator) {
+  Tensor<float, 2> src(128, 128);
+  Tensor<float, 2> dst(128, 128);
+  src.setZero();
+
+  array<Index, 2> shuffle{{1, 0}};
+  const auto random = src.random(generator);
+  const auto expr = src.shuffle(shuffle) + random;
+
+  using RandomExpr = decltype(random);
+  using DefaultRandomEvaluator = TensorEvaluator<const RandomExpr, DefaultDevice>;
+  using ThreadPoolRandomEvaluator = TensorEvaluator<const RandomExpr, ThreadPoolDevice>;
+  // Element i is a pure function of (seed, i), so a block is materialized with the elements' own tensor-linear
+  // indices and no traversal order can change what a fill produces.
+  static_assert(DefaultRandomEvaluator::BlockAccess, "DefaultDevice random expressions must serve blocks");
+  static_assert(ThreadPoolRandomEvaluator::BlockAccess, "ThreadPoolDevice random expressions must serve blocks");
+  static_assert(DefaultRandomEvaluator::PacketAccess, "DefaultDevice random expressions must keep packet access");
+  static_assert(ThreadPoolRandomEvaluator::PacketAccess, "ThreadPoolDevice random expressions must keep packet access");
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  static_assert(
+      internal::IsVectorizable<DefaultDevice, const Assign>::value == (PacketType<float, DefaultDevice>::size > 1),
+      "DefaultDevice random expressions must use packets when vectorization is available");
+  static_assert(internal::IsVectorizable<ThreadPoolDevice, const Assign>::value ==
+                    (PacketType<float, ThreadPoolDevice>::size > 1),
+                "ThreadPoolDevice random expressions must use packets when vectorization is available");
+  // The shuffle prefers block access and the random leaf no longer declines it, so the expression is tiled.
+  static_assert(internal::IsTileable<DefaultDevice, const Assign>::value == TiledEvaluation::On,
+                "DefaultDevice expressions containing random leaves must be tileable");
+  static_assert(internal::IsTileable<ThreadPoolDevice, const Assign>::value == TiledEvaluation::On,
+                "ThreadPoolDevice expressions containing random leaves must be tileable");
+
+  Eigen::ThreadPool tp(4);
+  ThreadPoolDevice device(&tp, 4);
+  dst.device(device) = expr;
+
+  // Tiled evaluation across four threads has to agree coefficient for coefficient with linear coefficient
+  // evaluation on one thread. That equality is what declaring the generators repeatable promises.
+  Tensor<float, 2> reference(128, 128);
+  DefaultAssign(reference, expr);
+
+  bool all_equal = true;
+  for (Index i = 0; i < dst.size(); ++i) {
+    VERIFY((numext::isfinite)(dst.coeff(i)));
+    VERIFY_IS_EQUAL(dst.coeff(i), reference.coeff(i));
+    all_equal = all_equal && dst.coeff(i) == dst.coeff(0);
+  }
+  VERIFY(!all_equal);
+}
+
+// Custom nullary functors carry no functor_traits, so they must default to
+// the conservative non-repeatable classification and remain on the
+// coefficient path on every device. Declaring IsRepeatable in functor_traits
+// opts back into block evaluation.
+struct UnannotatedIndexedFunctor {
+  float operator()() const { return -1.0f; }
+  float operator()(Index i) const { return static_cast<float>(i); }
+};
+
+struct UnannotatedNullaryFunctor {
+  float operator()() const { return 1.0f; }
+};
+
+struct StatefulIndexedFunctor {
+  StatefulIndexedFunctor() : next(0) {}
+
+  float operator()(Index i) const { return static_cast<float>(i + next++); }
+
+  mutable Index next;
+};
+
+struct RepeatableIndexedFunctor {
+  float operator()(Index i) const { return static_cast<float>(i); }
+};
+
+namespace Eigen {
+namespace internal {
+template <>
+struct functor_traits<RepeatableIndexedFunctor> {
+  enum { Cost = 1, PacketAccess = false, IsRepeatable = true };
+};
+}  // namespace internal
+}  // namespace Eigen
+
+void test_custom_nullary_functor_block_access() {
+  Tensor<float, 2> src(512, 512);
+  Tensor<float, 2> dst(512, 512);
+  src.setZero();
+
+  const auto indexed = src.nullaryExpr(UnannotatedIndexedFunctor());
+  using IndexedExpr = decltype(indexed);
+  static_assert(!TensorEvaluator<const IndexedExpr, DefaultDevice>::BlockAccess,
+                "Unannotated indexed functors must preserve their linear call order");
+  static_assert(!TensorEvaluator<const IndexedExpr, ThreadPoolDevice>::BlockAccess,
+                "Unannotated functors must not opt into ThreadPoolDevice shared-evaluator tiling");
+
+  using NullaryOnlyExpr = decltype(src.nullaryExpr(UnannotatedNullaryFunctor()));
+  static_assert(!TensorEvaluator<const NullaryOnlyExpr, DefaultDevice>::BlockAccess,
+                "Unannotated zero-argument functors must keep their linear call order");
+
+  const auto repeatable = src.nullaryExpr(RepeatableIndexedFunctor());
+  using RepeatableExpr = decltype(repeatable);
+  static_assert(TensorEvaluator<const RepeatableExpr, DefaultDevice>::BlockAccess,
+                "IsRepeatable indexed functors must serve materialized blocks on DefaultDevice");
+  static_assert(TensorEvaluator<const RepeatableExpr, ThreadPoolDevice>::BlockAccess,
+                "IsRepeatable functors may serve blocks from a shared ThreadPoolDevice evaluator");
+
+  using ConstantExpr = decltype(src.constant(7.0f));
+  static_assert(TensorEvaluator<const ConstantExpr, ThreadPoolDevice>::BlockAccess,
+                "Constants must remain tileable on ThreadPoolDevice");
+
+  array<Index, 2> shuffle{{1, 0}};
+  const auto repeatable_expr = src.shuffle(shuffle) + repeatable;
+  using RepeatableAssign = TensorAssignOp<decltype(dst), const decltype(repeatable_expr)>;
+  static_assert(internal::IsTileable<DefaultDevice, const RepeatableAssign>::value == TiledEvaluation::On,
+                "DefaultDevice expressions with repeatable indexed functors must remain tileable");
+
+  // Tiled evaluation must feed the functor true tensor-linear indices; a lazy
+  // block would restart them at each block origin.
+  DefaultDevice d;
+  dst.device(d) = repeatable_expr;
+  for (Index i = 0; i < dst.size(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), static_cast<float>(i));
+  }
+
+  const auto stateful = src.nullaryExpr(StatefulIndexedFunctor());
+  const auto stateful_expr = src.shuffle(shuffle) + stateful;
+  using StatefulAssign = TensorAssignOp<decltype(dst), const decltype(stateful_expr)>;
+  static_assert(internal::IsTileable<DefaultDevice, const StatefulAssign>::value == TiledEvaluation::Off,
+                "Non-repeatable indexed functors must preserve linear invocation order");
+
+  dst.device(d) = stateful_expr;
+  for (Index i = 0; i < dst.size(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), static_cast<float>(2 * i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_binary_expr(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  // Pick a large enough tensor size to bypass small tensor block evaluation
+  // optimization.
+  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
+
+  Tensor<T, NumDims, Options, Index> lhs(dims);
+  Tensor<T, NumDims, Options, Index> rhs(dims);
+  Tensor<T, NumDims, Options, Index> dst(dims);
+
+  lhs.setRandom();
+  rhs.setRandom();
+
+  const auto expr = lhs + rhs;
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    T sum = lhs.coeff(i) + rhs.coeff(i);
+    VERIFY_IS_EQUAL(sum, dst.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_broadcasting(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(1, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  const auto broadcasts = RandomDims<NumDims>(1, 7);
+  const auto expr = src.broadcast(broadcasts);
+
+  // We assume that broadcasting on a default device is tested and correct, so
+  // we can rely on it to verify correctness of tensor executor and tiling.
+  Tensor<T, NumDims, Options, Index> golden;
+  golden = expr;
+
+  // Now do the broadcasting using configured tensor executor.
+  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+template <int Layout>
+void test_execute_ternary_tiled(DefaultDevice default_device, ThreadPoolDevice thread_pool_device) {
+  constexpr Index Rows = 47;
+  constexpr Index Cols = 53;
+
+  Tensor<float, 2, Layout> a(1, Cols);
+  Tensor<float, 2, Layout> b(1, Cols);
+  Tensor<float, 2, Layout> x(Rows, Cols);
+  a.setRandom();
+  b.setRandom();
+  x.setRandom();
+  a = a.abs() + a.constant(0.5f);
+  b = b.abs() + b.constant(0.5f);
+  x = (x + x.constant(1.0f)) * x.constant(0.5f);
+
+  const Eigen::array<Index, 2> broadcasts = {Rows, 1};
+  const auto expr = Eigen::betainc(a.broadcast(broadcasts), b.broadcast(broadcasts), x);
+
+  Tensor<float, 2, Layout> golden(Rows, Cols);
+  DefaultAssign(golden, expr);
+
+  Tensor<float, 2, Layout> default_result(Rows, Cols);
+  using Assign = TensorAssignOp<decltype(default_result), const decltype(expr)>;
+  static_assert(internal::IsTileable<DefaultDevice, const Assign>::value == TiledEvaluation::On,
+                "ternary expressions with broadcasts must enable tiled evaluation");
+  static_assert(internal::IsTileable<ThreadPoolDevice, const Assign>::value == TiledEvaluation::On,
+                "ternary expressions with broadcasts must enable threaded tiled evaluation");
+
+  default_result.device(default_device) = expr;
+
+  Tensor<float, 2, Layout> threaded_result(Rows, Cols);
+  threaded_result.device(thread_pool_device) = expr;
+
+  for (Index i = 0; i < Rows * Cols; ++i) {
+    VERIFY_IS_EQUAL(default_result.coeff(i), golden.coeff(i));
+    VERIFY_IS_EQUAL(threaded_result.coeff(i), golden.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+struct test_execute_chipping_rvalue_runner {
+  template <int ChipDim>
+  static std::enable_if_t<0 <= ChipDim, void> run_dim(Device& d, const array<Index, NumDims>& dims,
+                                                      const Tensor<T, NumDims, Layout, Index>& src) {
+    const auto offset = internal::random<Index>(0, dims[(ChipDim)] - 1);
+    const auto expr = src.template chip<ChipDim>(offset);
+
+    Tensor<T, NumDims - 1, Layout, Index> golden;
+    golden = expr;
+
+    Tensor<T, NumDims - 1, Layout, Index> dst(golden.dimensions());
+
+    using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+    using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+    Executor::run(Assign(dst, expr), d);
+
+    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+    }
+
+    // Recursively reduce chip dimension.
+    run_dim<ChipDim - 1>(d, dims, src);
+  }
+
+  template <int ChipDim>
+      static std::enable_if_t <
+      ChipDim<0, void> run_dim(Device&, const array<Index, NumDims>&, const Tensor<T, NumDims, Layout, Index>&) {}
+
+  static void run(Device d) {
+    auto dims = RandomDims<NumDims>(1, 10);
+    Tensor<T, NumDims, Layout, Index> src(dims);
+    src.setRandom();
+    run_dim<NumDims - 1>(d, dims, src);
+  }
+};
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_chipping_rvalue(Device d) {
+  test_execute_chipping_rvalue_runner<T, NumDims, Device, Vectorizable, Tiling, Layout>::run(d);
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+struct test_execute_chipping_lvalue_runner {
+  template <int ChipDim>
+  static std::enable_if_t<0 <= ChipDim> run_dim(Device& d, const array<Index, NumDims>& dims) {
+    /* Generate random data that we'll assign to the chipped tensor dim. */
+    array<Index, NumDims - 1> src_dims;
+    for (int i = 0; i < NumDims - 1; ++i) {
+      int dim = i < (ChipDim) ? i : i + 1;
+      src_dims[i] = dims[dim];
+    }
+
+    Tensor<T, NumDims - 1, Layout, Index> src(src_dims);
+    src.setRandom();
+
+    const auto offset = internal::random<Index>(0, dims[(ChipDim)] - 1);
+
+    Tensor<T, NumDims, Layout, Index> random(dims);
+    random.setZero();
+
+    Tensor<T, NumDims, Layout, Index> golden(dims);
+    golden = random;
+    golden.template chip<(ChipDim)>(offset) = src;
+
+    Tensor<T, NumDims, Layout, Index> dst(dims);
+    dst = random;
+    auto expr = dst.template chip<(ChipDim)>(offset);
+
+    using Assign = TensorAssignOp<decltype(expr), const decltype(src)>;
+    using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+    Executor::run(Assign(expr, src), d);
+
+    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+    }
+
+    run_dim<ChipDim - 1>(d, dims);
+  }
+
+  template <int ChipDim>
+      static std::enable_if_t < ChipDim<0, void> run_dim(Device&, const array<Index, NumDims>&) {}
+
+  static void run(Device d) {
+    auto dims = RandomDims<NumDims>(1, 10);
+    run_dim<NumDims - 1>(d, dims);
+  }
+};
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_chipping_lvalue(Device d) {
+  test_execute_chipping_lvalue_runner<T, NumDims, Device, Vectorizable, Tiling, Layout>::run(d);
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_shuffle_rvalue(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(1, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  DSizes<Index, NumDims> shuffle;
+  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
+
+  // Test all possible shuffle permutations.
+  do {
+    DSizes<Index, NumDims> shuffled_dims;
+    for (int i = 0; i < NumDims; ++i) {
+      shuffled_dims[i] = dims[shuffle[i]];
+    }
+
+    const auto expr = src.shuffle(shuffle);
+
+    // We assume that shuffling on a default device is tested and correct, so
+    // we can rely on it to verify correctness of tensor executor and tiling.
+    Tensor<T, NumDims, Options, Index> golden(shuffled_dims);
+    DefaultAssign(golden, expr);
+
+    // Now do the shuffling using configured tensor executor.
+    Tensor<T, NumDims, Options, Index> dst(shuffled_dims);
+    DeviceAssign<Vectorizable, Tiling>(d, dst, expr);
+
+    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+    }
+
+  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_shuffle_lvalue(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(5, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  DSizes<Index, NumDims> shuffle;
+  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
+
+  // Test all possible shuffle permutations.
+  do {
+    DSizes<Index, NumDims> shuffled_dims;
+    for (int i = 0; i < NumDims; ++i) shuffled_dims[shuffle[i]] = dims[i];
+
+    // We assume that shuffling on a default device is tested and correct, so
+    // we can rely on it to verify correctness of tensor executor and tiling.
+    Tensor<T, NumDims, Options, Index> golden(shuffled_dims);
+    auto golden_shuffle = golden.shuffle(shuffle);
+    DefaultAssign(golden_shuffle, src);
+
+    // Now do the shuffling using configured tensor executor.
+    Tensor<T, NumDims, Options, Index> dst(shuffled_dims);
+    auto dst_shuffle = dst.shuffle(shuffle);
+    DeviceAssign<Vectorizable, Tiling>(d, dst_shuffle, src);
+
+    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+    }
+
+  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_reshape(Device d) {
+  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
+
+  static constexpr int ReshapedDims = NumDims - 1;
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(5, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  // Multiple 0th dimension and then shuffle.
+  std::vector<Index> shuffle;
+  for (int i = 0; i < ReshapedDims; ++i) shuffle.push_back(i);
+  std::shuffle(shuffle.begin(), shuffle.end(), std::mt19937());
+
+  DSizes<Index, ReshapedDims> reshaped_dims;
+  reshaped_dims[shuffle[0]] = dims[0] * dims[1];
+  for (int i = 1; i < ReshapedDims; ++i) reshaped_dims[shuffle[i]] = dims[i + 1];
+
+  Tensor<T, ReshapedDims, Options, Index> golden = src.reshape(reshaped_dims);
+
+  // Now reshape using configured tensor executor.
+  Tensor<T, ReshapedDims, Options, Index> dst(golden.dimensions());
+
+  auto expr = src.reshape(reshaped_dims);
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_slice_rvalue(Device d) {
+  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(5, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  // Pick a random slice of src tensor.
+  auto slice_start = DSizes<Index, NumDims>(RandomDims<NumDims>());
+  auto slice_size = DSizes<Index, NumDims>(RandomDims<NumDims>());
+
+  // Make sure that slice start + size do not overflow tensor dims.
+  for (int i = 0; i < NumDims; ++i) {
+    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
+    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
+  }
+
+  Tensor<T, NumDims, Options, Index> golden = src.slice(slice_start, slice_size);
+
+  // Now reshape using configured tensor executor.
+  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
+
+  auto expr = src.slice(slice_start, slice_size);
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+// Regression test for BlockAccess=true on bool slice rvalue expressions.
+// Sweeps sizes spanning Packet16b (16-lane bool packet) boundaries so the
+// tiled executor is forced to cross packet boundaries inside a single slice.
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_slice_rvalue_bool_boundaries(Device d) {
+  static_assert(std::is_same<T, bool>::value, "Only bool is supported.");
+  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
+  static constexpr int Options = 0 | Layout;
+
+  const Index boundary_sizes[] = {15, 16, 17, 31, 32, 33, 47, 48, 49, 63, 64, 65};
+  for (Index sz : boundary_sizes) {
+    array<Index, NumDims> src_dims;
+    for (int i = 0; i < NumDims; ++i) src_dims[i] = sz;
+
+    Tensor<bool, NumDims, Options, Index> src(src_dims);
+    src.setRandom();
+
+    DSizes<Index, NumDims> slice_start;
+    DSizes<Index, NumDims> slice_size;
+    for (int i = 0; i < NumDims; ++i) {
+      slice_start[i] = sz >= 2 ? 1 : 0;
+      slice_size[i] = sz - slice_start[i];
+    }
+
+    Tensor<bool, NumDims, Options, Index> golden = src.slice(slice_start, slice_size);
+
+    Tensor<bool, NumDims, Options, Index> dst(golden.dimensions());
+    auto expr = src.slice(slice_start, slice_size);
+
+    using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+    using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+    Executor::run(Assign(dst, expr), d);
+
+    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+    }
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_slice_lvalue(Device d) {
+  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(5, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  // Pick a random slice of src tensor.
+  auto slice_start = DSizes<Index, NumDims>(RandomDims<NumDims>(1, 10));
+  auto slice_size = DSizes<Index, NumDims>(RandomDims<NumDims>(1, 10));
+
+  // Make sure that slice start + size do not overflow tensor dims.
+  for (int i = 0; i < NumDims; ++i) {
+    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
+    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
+  }
+
+  Tensor<T, NumDims, Options, Index> slice(slice_size);
+  slice.setRandom();
+
+  // Assign a slice using default executor.
+  Tensor<T, NumDims, Options, Index> golden = src;
+  golden.slice(slice_start, slice_size) = slice;
+
+  // And using configured execution strategy.
+  Tensor<T, NumDims, Options, Index> dst = src;
+  auto expr = dst.slice(slice_start, slice_size);
+
+  using Assign = TensorAssignOp<decltype(expr), const decltype(slice)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(expr, slice), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_broadcasting_of_forced_eval(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(1, 10);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  const auto broadcasts = RandomDims<NumDims>(1, 7);
+  const auto expr = src.square().eval().broadcast(broadcasts);
+
+  // We assume that broadcasting on a default device is tested and correct, so
+  // we can rely on it to verify correctness of tensor executor and tiling.
+  Tensor<T, NumDims, Options, Index> golden;
+  golden = expr;
+
+  // Now do the broadcasting using configured tensor executor.
+  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+template <typename T, int NumDims>
+struct DummyGenerator {
+  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T operator()(const array<Index, NumDims>& dims) const {
+    T result = static_cast<T>(0);
+    for (int i = 0; i < NumDims; ++i) {
+      result += static_cast<T>((i + 1) * dims[i]);
+    }
+    return result;
+  }
+};
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_generator_op(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(20, 30);
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  const auto expr = src.generate(DummyGenerator<T, NumDims>());
+
+  // We assume that generator on a default device is tested and correct, so
+  // we can rely on it to verify correctness of tensor executor and tiling.
+  Tensor<T, NumDims, Options, Index> golden;
+  golden = expr;
+
+  // Now do the broadcasting using configured tensor executor.
+  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_execute_reverse_rvalue(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  auto dims = RandomDims<NumDims>(1, numext::pow(1000000.0, 1.0 / NumDims));
+  Tensor<T, NumDims, Options, Index> src(dims);
+  src.setRandom();
+
+  // Reverse half of the dimensions.
+  Eigen::array<bool, NumDims> reverse;
+  for (int i = 0; i < NumDims; ++i) reverse[i] = internal::random<bool>();
+
+  const auto expr = src.reverse(reverse);
+
+  // We assume that reversing on a default device is tested and correct, so
+  // we can rely on it to verify correctness of tensor executor and tiling.
+  Tensor<T, NumDims, Options, Index> golden;
+  golden = expr;
+
+  // Now do the reversing using configured tensor executor.
+  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
+
+  Executor::run(Assign(dst, expr), d);
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_async_execute_unary_expr(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  // Pick a large enough tensor size to bypass small tensor block evaluation
+  // optimization.
+  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
+
+  Tensor<T, NumDims, Options, Index> src(dims);
+  Tensor<T, NumDims, Options, Index> dst(dims);
+
+  src.setRandom();
+  const auto expr = src.square();
+
+  Eigen::Barrier done(1);
+  auto on_done = [&done]() { done.Notify(); };
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using DoneCallback = decltype(on_done);
+  using Executor = internal::TensorAsyncExecutor<const Assign, Device, DoneCallback, Vectorizable, Tiling>;
+
+  Executor::runAsync(Assign(dst, expr), d, on_done);
+  done.Wait();
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    T square = src.coeff(i) * src.coeff(i);
+    VERIFY_IS_EQUAL(square, dst.coeff(i));
+  }
+}
+
+template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
+void test_async_execute_binary_expr(Device d) {
+  static constexpr int Options = 0 | Layout;
+
+  // Pick a large enough tensor size to bypass small tensor block evaluation
+  // optimization.
+  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
+
+  Tensor<T, NumDims, Options, Index> lhs(dims);
+  Tensor<T, NumDims, Options, Index> rhs(dims);
+  Tensor<T, NumDims, Options, Index> dst(dims);
+
+  lhs.setRandom();
+  rhs.setRandom();
+
+  const auto expr = lhs + rhs;
+
+  Eigen::Barrier done(1);
+  auto on_done = [&done]() { done.Notify(); };
+
+  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
+  using DoneCallback = decltype(on_done);
+  using Executor = internal::TensorAsyncExecutor<const Assign, Device, DoneCallback, Vectorizable, Tiling>;
+
+  Executor::runAsync(Assign(dst, expr), d, on_done);
+  done.Wait();
+
+  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
+    T sum = lhs.coeff(i) + rhs.coeff(i);
+    VERIFY_IS_EQUAL(sum, dst.coeff(i));
+  }
+}
+
+#ifndef EIGEN_DONT_VECTORIZE
+#define EIGEN_DONT_VECTORIZE 0
+#endif
+#define VECTORIZABLE(T, VAL) !EIGEN_DONT_VECTORIZE&& Eigen::internal::packet_traits<T>::Vectorizable&& VAL
+
+#define CALL_SUBTEST_PART(PART) CALL_SUBTEST_##PART
+
+#define CALL_SUBTEST_COMBINATIONS(PART, NAME, T, NUM_DIMS)                                                            \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::Off, ColMajor>(default_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::On, ColMajor>(default_device)));  \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, ColMajor>(default_device)));        \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::On, ColMajor>(default_device)));         \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::Off, RowMajor>(default_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::On, RowMajor>(default_device)));  \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, RowMajor>(default_device)));        \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::On, RowMajor>(default_device)));         \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, ColMajor>(tp_device)));   \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, ColMajor>(tp_device)));    \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, ColMajor>(tp_device)));          \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, ColMajor>(tp_device)));           \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, RowMajor>(tp_device)));   \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, RowMajor>(tp_device)));    \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, RowMajor>(tp_device)));          \
+  CALL_SUBTEST_PART(PART)                                                                                             \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, RowMajor>(tp_device)))
+
+// NOTE: Currently only ThreadPoolDevice supports async expression evaluation.
+#define CALL_ASYNC_SUBTEST_COMBINATIONS(PART, NAME, T, NUM_DIMS)                                                    \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, ColMajor>(tp_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, ColMajor>(tp_device)));  \
+  CALL_SUBTEST_PART(PART)                                                                                           \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, ColMajor>(tp_device)));        \
+  CALL_SUBTEST_PART(PART)                                                                                           \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, ColMajor>(tp_device)));         \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, RowMajor>(tp_device))); \
+  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, RowMajor>(tp_device)));  \
+  CALL_SUBTEST_PART(PART)                                                                                           \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, RowMajor>(tp_device)));        \
+  CALL_SUBTEST_PART(PART)                                                                                           \
+  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, RowMajor>(tp_device)))
+
+EIGEN_DECLARE_TEST(tensor_executor) {
+  Eigen::DefaultDevice default_device;
+  // Default device is unused in ASYNC tests.
+  EIGEN_UNUSED_VARIABLE(default_device);
+
+  const auto num_threads = internal::random<int>(20, 24);
+  Eigen::ThreadPool tp(num_threads);
+  Eigen::ThreadPoolDevice tp_device(&tp, num_threads);
+
+  CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 3);
+  CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 4);
+  CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 3);
+  CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 4);
+  CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(2, test_execute_nullary_expr, float, 3);
+  CALL_SUBTEST_COMBINATIONS(2, test_execute_nullary_expr, float, 4);
+  CALL_SUBTEST_COMBINATIONS(2, test_execute_nullary_expr, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 3);
+  CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 4);
+  CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 5);
+
+  CALL_SUBTEST_8((test_execute_ternary_tiled<ColMajor>(default_device, tp_device)));
+  CALL_SUBTEST_8((test_execute_ternary_tiled<RowMajor>(default_device, tp_device)));
+  CALL_SUBTEST_8(test_random_capabilities(internal::UniformRandomGenerator<float>(123)));
+  CALL_SUBTEST_8(test_random_capabilities(internal::NormalRandomGenerator<float>(123)));
+  CALL_SUBTEST_8(test_custom_nullary_functor_block_access());
+
+  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 2);
+  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 3);
+  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 4);
+  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 2);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 5);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, bool, 2);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, bool, 3);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, bool, 4);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, bool, 5);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue_bool_boundaries, bool, 2);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue_bool_boundaries, bool, 3);
+  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue_bool_boundaries, bool, 4);
+
+  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 2);
+  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 2);
+  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 3);
+  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 4);
+  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 2);
+  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 3);
+  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 4);
+  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 5);
+
+  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 1);
+  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 2);
+  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 3);
+  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 4);
+  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 5);
+
+  CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 3);
+  CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 4);
+  CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 5);
+
+  CALL_ASYNC_SUBTEST_COMBINATIONS(16, test_async_execute_binary_expr, float, 3);
+  CALL_ASYNC_SUBTEST_COMBINATIONS(16, test_async_execute_binary_expr, float, 4);
+  CALL_ASYNC_SUBTEST_COMBINATIONS(16, test_async_execute_binary_expr, float, 5);
+
+  // Force CMake to split this test.
+  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16
+}
diff --git a/contrib/test/tensor_expr.cpp b/contrib/test/tensor_expr.cpp
new file mode 100644
index 0000000..e150d5d
--- /dev/null
+++ b/contrib/test/tensor_expr.cpp
@@ -0,0 +1,559 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include <numeric>
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_1d() {
+  Tensor<float, 1> vec1(6);
+  Tensor<float, 1, RowMajor> vec2(6);
+
+  vec1(0) = 4.0;
+  vec2(0) = 0.0;
+  vec1(1) = 8.0;
+  vec2(1) = 1.0;
+  vec1(2) = 15.0;
+  vec2(2) = 2.0;
+  vec1(3) = 16.0;
+  vec2(3) = 3.0;
+  vec1(4) = 23.0;
+  vec2(4) = 4.0;
+  vec1(5) = 42.0;
+  vec2(5) = 5.0;
+
+  float data3[6];
+  TensorMap<Tensor<float, 1>> vec3(data3, 6);
+  vec3 = vec1.sqrt();
+  float data4[6];
+  TensorMap<Tensor<float, 1, RowMajor>> vec4(data4, 6);
+  vec4 = vec2.square();
+  float data5[6];
+  TensorMap<Tensor<float, 1, RowMajor>> vec5(data5, 6);
+  vec5 = vec2.cube();
+
+  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
+  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
+  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0));
+  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0));
+  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
+  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
+
+  VERIFY_IS_APPROX(vec4(0), 0.0f);
+  VERIFY_IS_APPROX(vec4(1), 1.0f);
+  VERIFY_IS_APPROX(vec4(2), 2.0f * 2.0f);
+  VERIFY_IS_APPROX(vec4(3), 3.0f * 3.0f);
+  VERIFY_IS_APPROX(vec4(4), 4.0f * 4.0f);
+  VERIFY_IS_APPROX(vec4(5), 5.0f * 5.0f);
+
+  VERIFY_IS_APPROX(vec5(0), 0.0f);
+  VERIFY_IS_APPROX(vec5(1), 1.0f);
+  VERIFY_IS_APPROX(vec5(2), 2.0f * 2.0f * 2.0f);
+  VERIFY_IS_APPROX(vec5(3), 3.0f * 3.0f * 3.0f);
+  VERIFY_IS_APPROX(vec5(4), 4.0f * 4.0f * 4.0f);
+  VERIFY_IS_APPROX(vec5(5), 5.0f * 5.0f * 5.0f);
+
+  vec3 = vec1 + vec2;
+  VERIFY_IS_APPROX(vec3(0), 4.0f + 0.0f);
+  VERIFY_IS_APPROX(vec3(1), 8.0f + 1.0f);
+  VERIFY_IS_APPROX(vec3(2), 15.0f + 2.0f);
+  VERIFY_IS_APPROX(vec3(3), 16.0f + 3.0f);
+  VERIFY_IS_APPROX(vec3(4), 23.0f + 4.0f);
+  VERIFY_IS_APPROX(vec3(5), 42.0f + 5.0f);
+}
+
+static void test_2d() {
+  float data1[6];
+  TensorMap<Tensor<float, 2>> mat1(data1, 2, 3);
+  float data2[6];
+  TensorMap<Tensor<float, 2, RowMajor>> mat2(data2, 2, 3);
+
+  mat1(0, 0) = 0.0;
+  mat1(0, 1) = 1.0;
+  mat1(0, 2) = 2.0;
+  mat1(1, 0) = 3.0;
+  mat1(1, 1) = 4.0;
+  mat1(1, 2) = 5.0;
+
+  mat2(0, 0) = -0.0;
+  mat2(0, 1) = -1.0;
+  mat2(0, 2) = -2.0;
+  mat2(1, 0) = -3.0;
+  mat2(1, 1) = -4.0;
+  mat2(1, 2) = -5.0;
+
+  Tensor<float, 2> mat3(2, 3);
+  Tensor<float, 2, RowMajor> mat4(2, 3);
+  mat3 = mat1.abs();
+  mat4 = mat2.abs();
+
+  VERIFY_IS_APPROX(mat3(0, 0), 0.0f);
+  VERIFY_IS_APPROX(mat3(0, 1), 1.0f);
+  VERIFY_IS_APPROX(mat3(0, 2), 2.0f);
+  VERIFY_IS_APPROX(mat3(1, 0), 3.0f);
+  VERIFY_IS_APPROX(mat3(1, 1), 4.0f);
+  VERIFY_IS_APPROX(mat3(1, 2), 5.0f);
+
+  VERIFY_IS_APPROX(mat4(0, 0), 0.0f);
+  VERIFY_IS_APPROX(mat4(0, 1), 1.0f);
+  VERIFY_IS_APPROX(mat4(0, 2), 2.0f);
+  VERIFY_IS_APPROX(mat4(1, 0), 3.0f);
+  VERIFY_IS_APPROX(mat4(1, 1), 4.0f);
+  VERIFY_IS_APPROX(mat4(1, 2), 5.0f);
+}
+
+static void test_3d() {
+  Tensor<float, 3> mat1(2, 3, 7);
+  Tensor<float, 3, RowMajor> mat2(2, 3, 7);
+
+  float val = 1.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        mat2(i, j, k) = val;
+        val += 1.0f;
+      }
+    }
+  }
+
+  Tensor<float, 3> mat3(2, 3, 7);
+  mat3 = mat1 + mat1;
+  Tensor<float, 3, RowMajor> mat4(2, 3, 7);
+  mat4 = mat2 * 3.14f;
+  Tensor<float, 3> mat5(2, 3, 7);
+  mat5 = (mat1 + mat1.constant(1)).inverse().log();
+  Tensor<float, 3, RowMajor> mat6(2, 3, 7);
+  mat6 = mat2.pow(0.5f) * 3.14f;
+  Tensor<float, 3> mat7(2, 3, 7);
+  mat7 = mat1.cwiseMax(mat5 * 2.0f).exp();
+  Tensor<float, 3, RowMajor> mat8(2, 3, 7);
+  mat8 = (-mat2).exp() * 3.14f;
+  Tensor<float, 3, RowMajor> mat9(2, 3, 7);
+  mat9 = mat2 + 3.14f;
+  Tensor<float, 3, RowMajor> mat10(2, 3, 7);
+  mat10 = mat2 - 3.14f;
+  Tensor<float, 3, RowMajor> mat11(2, 3, 7);
+  mat11 = mat2 / 3.14f;
+
+  val = 1.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat3(i, j, k), val + val);
+        VERIFY_IS_APPROX(mat4(i, j, k), val * 3.14f);
+        VERIFY_IS_APPROX(mat5(i, j, k), logf(1.0f / (val + 1)));
+        VERIFY_IS_APPROX(mat6(i, j, k), sqrtf(val) * 3.14f);
+        VERIFY_IS_APPROX(mat7(i, j, k), expf((std::max)(val, mat5(i, j, k) * 2.0f)));
+        VERIFY_IS_APPROX(mat8(i, j, k), expf(-val) * 3.14f);
+        VERIFY_IS_APPROX(mat9(i, j, k), val + 3.14f);
+        VERIFY_IS_APPROX(mat10(i, j, k), val - 3.14f);
+        VERIFY_IS_APPROX(mat11(i, j, k), val / 3.14f);
+        val += 1.0f;
+      }
+    }
+  }
+}
+
+static void test_constants() {
+  Tensor<float, 3> mat1(2, 3, 7);
+  Tensor<float, 3> mat2(2, 3, 7);
+  Tensor<float, 3> mat3(2, 3, 7);
+
+  float val = 1.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        val += 1.0f;
+      }
+    }
+  }
+  mat2 = mat1.constant(3.14f);
+  mat3 = mat1.cwiseMax(7.3f).exp();
+
+  val = 1.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat2(i, j, k), 3.14f);
+        VERIFY_IS_APPROX(mat3(i, j, k), expf((std::max)(val, 7.3f)));
+        val += 1.0f;
+      }
+    }
+  }
+}
+
+static void test_boolean() {
+  const int kSize = 31;
+  Tensor<int, 1> vec(kSize);
+  std::iota(vec.data(), vec.data() + kSize, 0);
+
+  // Test ||.
+  Tensor<bool, 1> bool1 = (vec < vec.constant(1) || vec > vec.constant(4)).cast<bool>();
+  for (int i = 0; i < kSize; ++i) {
+    bool expected = i < 1 || i > 4;
+    VERIFY_IS_EQUAL(bool1[i], expected);
+  }
+
+  // Test &&, including cast of operand vec.
+  Tensor<bool, 1> bool2 = vec.cast<bool>() && (vec < vec.constant(4)).cast<bool>();
+  for (int i = 0; i < kSize; ++i) {
+    bool expected = bool(i) && i < 4;
+    VERIFY_IS_EQUAL(bool2[i], expected);
+  }
+
+  // Compilation tests:
+  // Test Tensor<bool> against results of cast or comparison; verifies that
+  // CoeffReturnType is set to match Op return type of bool for Unary and Binary
+  // Ops.
+  Tensor<bool, 1> bool3 = vec.cast<bool>() && bool2;
+  bool3 = (vec < vec.constant(4)).cast<bool>() && bool2;
+}
+
+static void test_functors() {
+  Tensor<float, 3> mat1(2, 3, 7);
+  Tensor<float, 3> mat2(2, 3, 7);
+  Tensor<float, 3> mat3(2, 3, 7);
+
+  float val = 1.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        val += 1.0f;
+      }
+    }
+  }
+  mat2 = mat1.inverse().unaryExpr(&asinf);
+  mat3 = mat1.unaryExpr(&tanhf);
+
+  val = 1.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat2(i, j, k), asinf(1.0f / mat1(i, j, k)));
+        VERIFY_IS_APPROX(mat3(i, j, k), tanhf(mat1(i, j, k)));
+        val += 1.0f;
+      }
+    }
+  }
+}
+
+static void test_type_casting() {
+  Tensor<bool, 3> mat1(2, 3, 7);
+  Tensor<float, 3> mat2(2, 3, 7);
+  Tensor<double, 3> mat3(2, 3, 7);
+  mat1.setRandom();
+  mat2.setRandom();
+
+  mat3 = mat1.cast<double>();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat3(i, j, k), mat1(i, j, k) ? 1.0 : 0.0);
+      }
+    }
+  }
+
+  mat3 = mat2.cast<double>();
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat3(i, j, k), static_cast<double>(mat2(i, j, k)));
+      }
+    }
+  }
+}
+
+static void test_select() {
+  using TypedGTOp = internal::scalar_cmp_op<float, float, internal::cmp_GT, true>;
+
+  Tensor<float, 3> selector(2, 3, 7);
+  Tensor<float, 3> mat1(2, 3, 7);
+  Tensor<float, 3> mat2(2, 3, 7);
+  Tensor<float, 3> result(2, 3, 7);
+
+  selector.setRandom();
+  mat1.setRandom();
+  mat2.setRandom();
+
+  // test select with a boolean condition
+  result = (selector > selector.constant(0.5f)).select(mat1, mat2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(result(i, j, k), (selector(i, j, k) > 0.5f) ? mat1(i, j, k) : mat2(i, j, k));
+      }
+    }
+  }
+
+  // test select with a typed condition
+  result = selector.binaryExpr(selector.constant(0.5f), TypedGTOp()).select(mat1, mat2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(result(i, j, k), (selector(i, j, k) > 0.5f) ? mat1(i, j, k) : mat2(i, j, k));
+      }
+    }
+  }
+}
+
+// Nan propagation does currently not work like one would expect from std::max/std::min,
+// so we disable it for now
+#if !EIGEN_ARCH_ARM_OR_ARM64
+template <typename Scalar>
+void test_minmax_nan_propagation_templ() {
+  for (int size = 1; size < 17; ++size) {
+    const Scalar kNaN = std::numeric_limits<Scalar>::quiet_NaN();
+    const Scalar kInf = std::numeric_limits<Scalar>::infinity();
+    const Scalar kZero(0);
+    Tensor<Scalar, 1> vec_full_nan(size);
+    Tensor<Scalar, 1> vec_one_nan(size);
+    Tensor<Scalar, 1> vec_zero(size);
+    vec_full_nan.setConstant(kNaN);
+    vec_zero.setZero();
+    vec_one_nan.setZero();
+    vec_one_nan(size / 2) = kNaN;
+
+    auto verify_all_nan = [&](const Tensor<Scalar, 1>& v) {
+      for (int i = 0; i < size; ++i) {
+        VERIFY((numext::isnan)(v(i)));
+      }
+    };
+
+    auto verify_all_zero = [&](const Tensor<Scalar, 1>& v) {
+      for (int i = 0; i < size; ++i) {
+        VERIFY_IS_EQUAL(v(i), Scalar(0));
+      }
+    };
+
+    // Test NaN propagating max.
+    // max(nan, nan) = nan
+    // max(nan, 0) = nan
+    // max(0, nan) = nan
+    // max(0, 0) = 0
+    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(kNaN));
+    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(vec_full_nan));
+    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(kZero));
+    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(vec_zero));
+    verify_all_nan(vec_zero.template cwiseMax<PropagateNaN>(kNaN));
+    verify_all_nan(vec_zero.template cwiseMax<PropagateNaN>(vec_full_nan));
+    verify_all_zero(vec_zero.template cwiseMax<PropagateNaN>(kZero));
+    verify_all_zero(vec_zero.template cwiseMax<PropagateNaN>(vec_zero));
+
+    // Test number propagating max.
+    // max(nan, nan) = nan
+    // max(nan, 0) = 0
+    // max(0, nan) = 0
+    // max(0, 0) = 0
+    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNumbers>(kNaN));
+    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNumbers>(vec_full_nan));
+    verify_all_zero(vec_full_nan.template cwiseMax<PropagateNumbers>(kZero));
+    verify_all_zero(vec_full_nan.template cwiseMax<PropagateNumbers>(vec_zero));
+    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(kNaN));
+    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(vec_full_nan));
+    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(kZero));
+    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(vec_zero));
+
+    // Test NaN propagating min.
+    // min(nan, nan) = nan
+    // min(nan, 0) = nan
+    // min(0, nan) = nan
+    // min(0, 0) = 0
+    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(kNaN));
+    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(vec_full_nan));
+    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(kZero));
+    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(vec_zero));
+    verify_all_nan(vec_zero.template cwiseMin<PropagateNaN>(kNaN));
+    verify_all_nan(vec_zero.template cwiseMin<PropagateNaN>(vec_full_nan));
+    verify_all_zero(vec_zero.template cwiseMin<PropagateNaN>(kZero));
+    verify_all_zero(vec_zero.template cwiseMin<PropagateNaN>(vec_zero));
+
+    // Test number propagating min.
+    // min(nan, nan) = nan
+    // min(nan, 0) = 0
+    // min(0, nan) = 0
+    // min(0, 0) = 0
+    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNumbers>(kNaN));
+    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNumbers>(vec_full_nan));
+    verify_all_zero(vec_full_nan.template cwiseMin<PropagateNumbers>(kZero));
+    verify_all_zero(vec_full_nan.template cwiseMin<PropagateNumbers>(vec_zero));
+    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(kNaN));
+    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(vec_full_nan));
+    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(kZero));
+    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(vec_zero));
+
+    // Test min and max reduction
+    Tensor<Scalar, 0> val;
+    val = vec_zero.minimum();
+    VERIFY_IS_EQUAL(val(), kZero);
+    val = vec_zero.template minimum<PropagateNaN>();
+    VERIFY_IS_EQUAL(val(), kZero);
+    val = vec_zero.template minimum<PropagateNumbers>();
+    VERIFY_IS_EQUAL(val(), kZero);
+    val = vec_zero.maximum();
+    VERIFY_IS_EQUAL(val(), kZero);
+    val = vec_zero.template maximum<PropagateNaN>();
+    VERIFY_IS_EQUAL(val(), kZero);
+    val = vec_zero.template maximum<PropagateNumbers>();
+    VERIFY_IS_EQUAL(val(), kZero);
+
+    // Test NaN propagation for tensor of all NaNs.
+    val = vec_full_nan.template minimum<PropagateNaN>();
+    VERIFY((numext::isnan)(val()));
+    val = vec_full_nan.template minimum<PropagateNumbers>();
+    VERIFY_IS_EQUAL(val(), kInf);
+    val = vec_full_nan.template maximum<PropagateNaN>();
+    VERIFY((numext::isnan)(val()));
+    val = vec_full_nan.template maximum<PropagateNumbers>();
+    VERIFY_IS_EQUAL(val(), -kInf);
+
+    // Test NaN propagation for tensor with a single NaN.
+    val = vec_one_nan.template minimum<PropagateNaN>();
+    VERIFY((numext::isnan)(val()));
+    val = vec_one_nan.template minimum<PropagateNumbers>();
+    VERIFY_IS_EQUAL(val(), (size == 1 ? kInf : kZero));
+    val = vec_one_nan.template maximum<PropagateNaN>();
+    VERIFY((numext::isnan)(val()));
+    val = vec_one_nan.template maximum<PropagateNumbers>();
+    VERIFY_IS_EQUAL(val(), (size == 1 ? -kInf : kZero));
+  }
+}
+#else
+template <typename Scalar>
+void test_minmax_nan_propagation_templ() {}
+#endif
+
+static void test_clip() {
+  Tensor<float, 1> vec(6);
+  vec(0) = 4.0;
+  vec(1) = 8.0;
+  vec(2) = 15.0;
+  vec(3) = 16.0;
+  vec(4) = 23.0;
+  vec(5) = 42.0;
+
+  float kMin = 20;
+  float kMax = 30;
+
+  Tensor<float, 1> vec_clipped(6);
+  vec_clipped = vec.clip(kMin, kMax);
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(vec_clipped(i), numext::mini(numext::maxi(vec(i), kMin), kMax));
+  }
+}
+
+static void test_minmax_nan_propagation() {
+  test_minmax_nan_propagation_templ<float>();
+  test_minmax_nan_propagation_templ<double>();
+}
+
+// A scalar operand whose type differs from the tensor's Scalar (e.g. a double literal against a
+// float tensor, or an int against a float tensor) must bind to the scalar operators through an
+// implicit conversion rather than being deduced as a broken tensor-tensor expression.
+static void test_mixed_scalar_arithmetic() {
+  Tensor<float, 2> in(2, 2);
+  in.setConstant(2.0f);
+
+  Tensor<float, 2> out = in + 0.5;  // double literal
+  VERIFY_IS_EQUAL(out(0, 0), 2.5f);
+  out = 0.5 + in;
+  VERIFY_IS_EQUAL(out(0, 0), 2.5f);
+  out = in - 0.5;
+  VERIFY_IS_EQUAL(out(0, 0), 1.5f);
+  out = in * 2;  // int literal
+  VERIFY_IS_EQUAL(out(0, 0), 4.0f);
+  out = in / 0.5;
+  VERIFY_IS_EQUAL(out(0, 0), 4.0f);
+  out = in.cwiseMax(0.5);
+  VERIFY_IS_EQUAL(out(0, 0), 2.0f);
+  out = in.cwiseMin(0.5);
+  VERIFY_IS_EQUAL(out(0, 0), 0.5f);
+
+  // In-place compound assignment with a differing scalar type.
+  out = in;
+  out += 0.5;
+  VERIFY_IS_EQUAL(out(0, 0), 2.5f);
+  out -= 0.5;
+  VERIFY_IS_EQUAL(out(0, 0), 2.0f);
+  out *= 2;  // int literal
+  VERIFY_IS_EQUAL(out(0, 0), 4.0f);
+  out /= 0.5;
+  VERIFY_IS_EQUAL(out(0, 0), 8.0f);
+
+  // Tensor-tensor operators must keep working through the constrained overloads.
+  Tensor<float, 2> other(2, 2);
+  other.setConstant(3.0f);
+  out = in + other;
+  VERIFY_IS_EQUAL(out(0, 0), 5.0f);
+  out += other;
+  VERIFY_IS_EQUAL(out(0, 0), 8.0f);
+  out = in.cwiseMax(other);
+  VERIFY_IS_EQUAL(out(0, 0), 3.0f);
+}
+
+template <typename Scalar>
+static void test_const_tensor_map_scalar_arithmetic() {
+  Tensor<Scalar, 1> storage(2);
+  storage.setConstant(Scalar(2));
+  const TensorMap<const Tensor<Scalar, 1>> input(storage.data(), storage.dimensions());
+  const Scalar scale = Scalar(3);
+
+  Tensor<Scalar, 1> output = scale * input;
+  VERIFY_IS_EQUAL(output(0), Scalar(6));
+  VERIFY_IS_EQUAL(output(1), Scalar(6));
+}
+
+// A scalar on the left of a comparison reflects to the member comparison: scalar < tensor is
+// tensor > scalar, etc. The scalar type may differ from the tensor Scalar.
+static void test_scalar_lhs_comparison() {
+  Tensor<float, 1> v(5);
+  for (int i = 0; i < 5; ++i) v(i) = float(i);  // 0, 1, 2, 3, 4
+
+  Tensor<bool, 1> lt = (2.0 < v);   // true where v > 2
+  Tensor<bool, 1> le = (2.0 <= v);  // true where v >= 2
+  Tensor<bool, 1> gt = (2.0 > v);   // true where v < 2
+  Tensor<bool, 1> ge = (2.0 >= v);  // true where v <= 2
+  Tensor<bool, 1> eq = (3.0 == v);  // true where v == 3
+  Tensor<bool, 1> ne = (3.0 != v);  // true where v != 3
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_EQUAL(lt(i), v(i) > 2.0f);
+    VERIFY_IS_EQUAL(le(i), v(i) >= 2.0f);
+    VERIFY_IS_EQUAL(gt(i), v(i) < 2.0f);
+    VERIFY_IS_EQUAL(ge(i), v(i) <= 2.0f);
+    VERIFY_IS_EQUAL(eq(i), v(i) == 3.0f);
+    VERIFY_IS_EQUAL(ne(i), v(i) != 3.0f);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_expr) {
+  CALL_SUBTEST(test_1d());
+  CALL_SUBTEST(test_2d());
+  CALL_SUBTEST(test_3d());
+  CALL_SUBTEST(test_constants());
+  CALL_SUBTEST(test_boolean());
+  CALL_SUBTEST(test_functors());
+  CALL_SUBTEST(test_type_casting());
+  CALL_SUBTEST(test_select());
+  CALL_SUBTEST(test_clip());
+  CALL_SUBTEST(test_minmax_nan_propagation());
+  CALL_SUBTEST(test_mixed_scalar_arithmetic());
+  CALL_SUBTEST(test_const_tensor_map_scalar_arithmetic<Eigen::half>());
+  CALL_SUBTEST(test_const_tensor_map_scalar_arithmetic<Eigen::bfloat16>());
+  CALL_SUBTEST(test_scalar_lhs_comparison());
+}
diff --git a/contrib/test/tensor_fft.cpp b/contrib/test/tensor_fft.cpp
new file mode 100644
index 0000000..c3979d8
--- /dev/null
+++ b/contrib/test/tensor_fft.cpp
@@ -0,0 +1,353 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Jianwei Cui <thucjw@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_fft_2D_golden() {
+  Tensor<float, 2, DataLayout> input(2, 3);
+  input(0, 0) = 1;
+  input(0, 1) = 2;
+  input(0, 2) = 3;
+  input(1, 0) = 4;
+  input(1, 1) = 5;
+  input(1, 2) = 6;
+
+  array<ptrdiff_t, 2> fft;
+  fft[0] = 0;
+  fft[1] = 1;
+
+  Tensor<std::complex<float>, 2, DataLayout> output = input.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
+
+  std::complex<float> output_golden[6];  // in ColMajor order
+  output_golden[0] = std::complex<float>(21, 0);
+  output_golden[1] = std::complex<float>(-9, 0);
+  output_golden[2] = std::complex<float>(-3, 1.73205);
+  output_golden[3] = std::complex<float>(0, 0);
+  output_golden[4] = std::complex<float>(-3, -1.73205);
+  output_golden[5] = std::complex<float>(0, 0);
+
+  std::complex<float> c_offset = std::complex<float>(1.0, 1.0);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_APPROX(output(0) + c_offset, output_golden[0] + c_offset);
+    VERIFY_IS_APPROX(output(1) + c_offset, output_golden[1] + c_offset);
+    VERIFY_IS_APPROX(output(2) + c_offset, output_golden[2] + c_offset);
+    VERIFY_IS_APPROX(output(3) + c_offset, output_golden[3] + c_offset);
+    VERIFY_IS_APPROX(output(4) + c_offset, output_golden[4] + c_offset);
+    VERIFY_IS_APPROX(output(5) + c_offset, output_golden[5] + c_offset);
+  } else {
+    VERIFY_IS_APPROX(output(0) + c_offset, output_golden[0] + c_offset);
+    VERIFY_IS_APPROX(output(1) + c_offset, output_golden[2] + c_offset);
+    VERIFY_IS_APPROX(output(2) + c_offset, output_golden[4] + c_offset);
+    VERIFY_IS_APPROX(output(3) + c_offset, output_golden[1] + c_offset);
+    VERIFY_IS_APPROX(output(4) + c_offset, output_golden[3] + c_offset);
+    VERIFY_IS_APPROX(output(5) + c_offset, output_golden[5] + c_offset);
+  }
+}
+
+static void test_fft_complex_input_golden() {
+  Tensor<std::complex<float>, 1, ColMajor> input(5);
+  input(0) = std::complex<float>(1, 1);
+  input(1) = std::complex<float>(2, 2);
+  input(2) = std::complex<float>(3, 3);
+  input(3) = std::complex<float>(4, 4);
+  input(4) = std::complex<float>(5, 5);
+
+  array<ptrdiff_t, 1> fft;
+  fft[0] = 0;
+
+  Tensor<std::complex<float>, 1, ColMajor> forward_output_both_parts = input.fft<BothParts, FFT_FORWARD>(fft);
+  Tensor<std::complex<float>, 1, ColMajor> reverse_output_both_parts = input.fft<BothParts, FFT_REVERSE>(fft);
+
+  Tensor<float, 1, ColMajor> forward_output_real_part = input.fft<RealPart, FFT_FORWARD>(fft);
+  Tensor<float, 1, ColMajor> reverse_output_real_part = input.fft<RealPart, FFT_REVERSE>(fft);
+
+  Tensor<float, 1, ColMajor> forward_output_imag_part = input.fft<ImagPart, FFT_FORWARD>(fft);
+  Tensor<float, 1, ColMajor> reverse_output_imag_part = input.fft<ImagPart, FFT_REVERSE>(fft);
+
+  VERIFY_IS_EQUAL(forward_output_both_parts.dimension(0), input.dimension(0));
+  VERIFY_IS_EQUAL(reverse_output_both_parts.dimension(0), input.dimension(0));
+
+  VERIFY_IS_EQUAL(forward_output_real_part.dimension(0), input.dimension(0));
+  VERIFY_IS_EQUAL(reverse_output_real_part.dimension(0), input.dimension(0));
+
+  VERIFY_IS_EQUAL(forward_output_imag_part.dimension(0), input.dimension(0));
+  VERIFY_IS_EQUAL(reverse_output_imag_part.dimension(0), input.dimension(0));
+
+  std::complex<float> forward_golden_result[5];
+  std::complex<float> reverse_golden_result[5];
+
+  forward_golden_result[0] = std::complex<float>(15.000000000000000, +15.000000000000000);
+  forward_golden_result[1] = std::complex<float>(-5.940954801177935, +0.940954801177934);
+  forward_golden_result[2] = std::complex<float>(-3.312299240582266, -1.687700759417735);
+  forward_golden_result[3] = std::complex<float>(-1.687700759417735, -3.312299240582266);
+  forward_golden_result[4] = std::complex<float>(0.940954801177934, -5.940954801177935);
+
+  reverse_golden_result[0] = std::complex<float>(3.000000000000000, +3.000000000000000);
+  reverse_golden_result[1] = std::complex<float>(0.188190960235587, -1.188190960235587);
+  reverse_golden_result[2] = std::complex<float>(-0.337540151883547, -0.662459848116453);
+  reverse_golden_result[3] = std::complex<float>(-0.662459848116453, -0.337540151883547);
+  reverse_golden_result[4] = std::complex<float>(-1.188190960235587, +0.188190960235587);
+
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_APPROX(forward_output_both_parts(i), forward_golden_result[i]);
+    VERIFY_IS_APPROX(forward_output_real_part(i), forward_golden_result[i].real());
+    VERIFY_IS_APPROX(forward_output_imag_part(i), forward_golden_result[i].imag());
+  }
+
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_APPROX(reverse_output_both_parts(i), reverse_golden_result[i]);
+    VERIFY_IS_APPROX(reverse_output_real_part(i), reverse_golden_result[i].real());
+    VERIFY_IS_APPROX(reverse_output_imag_part(i), reverse_golden_result[i].imag());
+  }
+}
+
+static void test_fft_real_input_golden() {
+  Tensor<float, 1, ColMajor> input(5);
+  input(0) = 1.0;
+  input(1) = 2.0;
+  input(2) = 3.0;
+  input(3) = 4.0;
+  input(4) = 5.0;
+
+  array<ptrdiff_t, 1> fft;
+  fft[0] = 0;
+
+  Tensor<std::complex<float>, 1, ColMajor> forward_output_both_parts = input.fft<BothParts, FFT_FORWARD>(fft);
+  Tensor<std::complex<float>, 1, ColMajor> reverse_output_both_parts = input.fft<BothParts, FFT_REVERSE>(fft);
+
+  Tensor<float, 1, ColMajor> forward_output_real_part = input.fft<RealPart, FFT_FORWARD>(fft);
+  Tensor<float, 1, ColMajor> reverse_output_real_part = input.fft<RealPart, FFT_REVERSE>(fft);
+
+  Tensor<float, 1, ColMajor> forward_output_imag_part = input.fft<ImagPart, FFT_FORWARD>(fft);
+  Tensor<float, 1, ColMajor> reverse_output_imag_part = input.fft<ImagPart, FFT_REVERSE>(fft);
+
+  VERIFY_IS_EQUAL(forward_output_both_parts.dimension(0), input.dimension(0));
+  VERIFY_IS_EQUAL(reverse_output_both_parts.dimension(0), input.dimension(0));
+
+  VERIFY_IS_EQUAL(forward_output_real_part.dimension(0), input.dimension(0));
+  VERIFY_IS_EQUAL(reverse_output_real_part.dimension(0), input.dimension(0));
+
+  VERIFY_IS_EQUAL(forward_output_imag_part.dimension(0), input.dimension(0));
+  VERIFY_IS_EQUAL(reverse_output_imag_part.dimension(0), input.dimension(0));
+
+  std::complex<float> forward_golden_result[5];
+  std::complex<float> reverse_golden_result[5];
+
+  forward_golden_result[0] = std::complex<float>(15, 0);
+  forward_golden_result[1] = std::complex<float>(-2.5, +3.44095480117793);
+  forward_golden_result[2] = std::complex<float>(-2.5, +0.81229924058227);
+  forward_golden_result[3] = std::complex<float>(-2.5, -0.81229924058227);
+  forward_golden_result[4] = std::complex<float>(-2.5, -3.44095480117793);
+
+  reverse_golden_result[0] = std::complex<float>(3.0, 0);
+  reverse_golden_result[1] = std::complex<float>(-0.5, -0.688190960235587);
+  reverse_golden_result[2] = std::complex<float>(-0.5, -0.162459848116453);
+  reverse_golden_result[3] = std::complex<float>(-0.5, +0.162459848116453);
+  reverse_golden_result[4] = std::complex<float>(-0.5, +0.688190960235587);
+
+  std::complex<float> c_offset(1.0, 1.0);
+  float r_offset = 1.0;
+
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_APPROX(forward_output_both_parts(i) + c_offset, forward_golden_result[i] + c_offset);
+    VERIFY_IS_APPROX(forward_output_real_part(i) + r_offset, forward_golden_result[i].real() + r_offset);
+    VERIFY_IS_APPROX(forward_output_imag_part(i) + r_offset, forward_golden_result[i].imag() + r_offset);
+  }
+
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_APPROX(reverse_output_both_parts(i) + c_offset, reverse_golden_result[i] + c_offset);
+    VERIFY_IS_APPROX(reverse_output_real_part(i) + r_offset, reverse_golden_result[i].real() + r_offset);
+    VERIFY_IS_APPROX(reverse_output_imag_part(i) + r_offset, reverse_golden_result[i].imag() + r_offset);
+  }
+}
+
+template <int DataLayout, typename RealScalar, bool isComplexInput, int FFTResultType, int FFTDirection, int TensorRank>
+static void test_fft_real_input_energy() {
+  Eigen::DSizes<ptrdiff_t, TensorRank> dimensions;
+  ptrdiff_t total_size = 1;
+  for (int i = 0; i < TensorRank; ++i) {
+    dimensions[i] = rand() % 20 + 1;
+    total_size *= dimensions[i];
+  }
+  const DSizes<ptrdiff_t, TensorRank> arr = dimensions;
+
+  typedef std::conditional_t<isComplexInput == true, std::complex<RealScalar>, RealScalar> InputScalar;
+
+  Tensor<InputScalar, TensorRank, DataLayout> input;
+  input.resize(arr);
+  input.setRandom();
+
+  array<ptrdiff_t, TensorRank> fft;
+  for (int i = 0; i < TensorRank; ++i) {
+    fft[i] = i;
+  }
+
+  typedef std::conditional_t<FFTResultType == Eigen::BothParts, std::complex<RealScalar>, RealScalar> OutputScalar;
+  Tensor<OutputScalar, TensorRank, DataLayout> output;
+  output = input.template fft<FFTResultType, FFTDirection>(fft);
+
+  for (int i = 0; i < TensorRank; ++i) {
+    VERIFY_IS_EQUAL(output.dimension(i), input.dimension(i));
+  }
+
+  RealScalar energy_original = 0.0;
+  RealScalar energy_after_fft = 0.0;
+
+  for (int i = 0; i < total_size; ++i) {
+    energy_original += numext::abs2(input(i));
+  }
+
+  for (int i = 0; i < total_size; ++i) {
+    energy_after_fft += numext::abs2(output(i));
+  }
+
+  if (FFTDirection == FFT_FORWARD) {
+    VERIFY_IS_APPROX(energy_original, energy_after_fft / total_size);
+  } else {
+    VERIFY_IS_APPROX(energy_original, energy_after_fft * total_size);
+  }
+}
+
+template <typename RealScalar>
+static void test_fft_non_power_of_2_round_trip(int exponent) {
+  int n = (1 << exponent) + 1;
+
+  Eigen::DSizes<ptrdiff_t, 1> dimensions;
+  dimensions[0] = n;
+  const DSizes<ptrdiff_t, 1> arr = dimensions;
+  Tensor<RealScalar, 1, ColMajor, ptrdiff_t> input;
+
+  input.resize(arr);
+  input.setRandom();
+
+  array<int, 1> fft;
+  fft[0] = 0;
+
+  Tensor<std::complex<RealScalar>, 1, ColMajor> forward = input.template fft<BothParts, FFT_FORWARD>(fft);
+
+  Tensor<RealScalar, 1, ColMajor, ptrdiff_t> output = forward.template fft<RealPart, FFT_REVERSE>(fft);
+
+  for (int i = 0; i < n; ++i) {
+    RealScalar tol = test_precision<RealScalar>() * (std::abs(input[i]) + std::abs(output[i]) + 1);
+    VERIFY_IS_APPROX_OR_LESS_THAN(std::abs(input[i] - output[i]), tol);
+  }
+}
+
+// Documented precondition: finite inputs must produce finite outputs. The hot-
+// path complex multiply uses the naive form (no NaN/inf disambiguation), so
+// this verifies the optimization didn't introduce spurious NaN/inf on legal
+// inputs. Covers both Cooley-Tukey (power-of-2) and Bluestein (non-pow-2).
+template <typename RealScalar>
+static void test_fft_finite_input_stays_finite(int n) {
+  using Complex = std::complex<RealScalar>;
+  Tensor<Complex, 1, ColMajor> input(n);
+  // Large but finite magnitudes — close to overflow but not at it — to catch
+  // any cmul that produces inf - inf = NaN under unfavorable scheduling.
+  const RealScalar big = RealScalar(1e18);
+  for (int i = 0; i < n; ++i) {
+    input(i) = Complex(big * std::cos(RealScalar(i)), big * std::sin(RealScalar(0.5) * RealScalar(i)));
+  }
+  array<int, 1> fft = {0};
+  Tensor<Complex, 1, ColMajor> fwd = input.template fft<Eigen::BothParts, FFT_FORWARD>(fft);
+  for (int i = 0; i < n; ++i) {
+    VERIFY((numext::isfinite)(fwd(i).real()));
+    VERIFY((numext::isfinite)(fwd(i).imag()));
+  }
+  Tensor<Complex, 1, ColMajor> rev = fwd.template fft<Eigen::BothParts, FFT_REVERSE>(fft);
+  for (int i = 0; i < n; ++i) {
+    VERIFY((numext::isfinite)(rev(i).real()));
+    VERIFY((numext::isfinite)(rev(i).imag()));
+  }
+}
+
+// `x = x.fft(...)` aliases the FFT input and output onto the same storage.
+// Regression test for the memcpy fast-path's self-copy guard in evalToBuf.
+template <typename RealScalar>
+static void test_fft_in_place_assign(int n) {
+  using Complex = std::complex<RealScalar>;
+  Tensor<Complex, 1, ColMajor> reference(n);
+  reference.setRandom();
+  Tensor<Complex, 1, ColMajor> x = reference;
+  array<int, 1> fft = {0};
+  x = x.template fft<Eigen::BothParts, FFT_FORWARD>(fft);
+  x = x.template fft<Eigen::BothParts, FFT_REVERSE>(fft);
+  for (int i = 0; i < n; ++i) {
+    RealScalar tol = test_precision<RealScalar>() * (std::abs(reference(i)) + std::abs(x(i)) + RealScalar(1));
+    VERIFY_IS_APPROX_OR_LESS_THAN(std::abs(reference(i) - x(i)) / RealScalar(n), tol);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_fft) {
+  test_fft_complex_input_golden();
+  test_fft_real_input_golden();
+
+  test_fft_2D_golden<ColMajor>();
+  test_fft_2D_golden<RowMajor>();
+
+  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 1>();
+  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 1>();
+  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 1>();
+  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 1>();
+
+  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 2>();
+  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 2>();
+  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 2>();
+  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 2>();
+
+  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 3>();
+  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 3>();
+  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 3>();
+  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 3>();
+
+  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 4>();
+  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 4>();
+  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 4>();
+  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 4>();
+
+  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 1>();
+  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 1>();
+  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 1>();
+  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 1>();
+
+  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 2>();
+  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 2>();
+  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 2>();
+  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 2>();
+
+  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 3>();
+  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 3>();
+  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 3>();
+  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 3>();
+
+  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 4>();
+  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 4>();
+  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 4>();
+  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 4>();
+
+  test_fft_non_power_of_2_round_trip<float>(7);
+  test_fft_non_power_of_2_round_trip<double>(7);
+
+  // Pow-2 (Cooley-Tukey) and non-pow-2 (Bluestein) finite-input precondition.
+  test_fft_finite_input_stays_finite<float>(64);
+  test_fft_finite_input_stays_finite<float>(100);
+  test_fft_finite_input_stays_finite<double>(64);
+  test_fft_finite_input_stays_finite<double>(100);
+
+  // x = x.fft(...) — exercises the self-copy guard in evalToBuf.
+  test_fft_in_place_assign<float>(64);
+  test_fft_in_place_assign<float>(100);
+  test_fft_in_place_assign<double>(64);
+  test_fft_in_place_assign<double>(100);
+}
diff --git a/contrib/test/tensor_fixed_size.cpp b/contrib/test/tensor_fixed_size.cpp
new file mode 100644
index 0000000..1e5396e
--- /dev/null
+++ b/contrib/test/tensor_fixed_size.cpp
@@ -0,0 +1,332 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_0d() {
+  TensorFixedSize<float, Sizes<> > scalar1;
+  TensorFixedSize<float, Sizes<>, RowMajor> scalar2;
+  VERIFY_IS_EQUAL(scalar1.rank(), 0);
+  VERIFY_IS_EQUAL(scalar1.size(), 1);
+  VERIFY_IS_EQUAL(internal::array_prod(scalar1.dimensions()), 1);
+
+  scalar1() = 7.0;
+  scalar2() = 13.0;
+
+  // Test against shallow copy.
+  TensorFixedSize<float, Sizes<> > copy = scalar1;
+  VERIFY_IS_NOT_EQUAL(scalar1.data(), copy.data());
+  VERIFY_IS_APPROX(scalar1(), copy());
+  copy = scalar1;
+  VERIFY_IS_NOT_EQUAL(scalar1.data(), copy.data());
+  VERIFY_IS_APPROX(scalar1(), copy());
+
+  TensorFixedSize<float, Sizes<> > scalar3 = scalar1.sqrt();
+  TensorFixedSize<float, Sizes<>, RowMajor> scalar4 = scalar2.sqrt();
+  VERIFY_IS_EQUAL(scalar3.rank(), 0);
+  VERIFY_IS_APPROX(scalar3(), sqrtf(7.0));
+  VERIFY_IS_APPROX(scalar4(), sqrtf(13.0));
+
+  scalar3 = scalar1 + scalar2;
+  VERIFY_IS_APPROX(scalar3(), 7.0f + 13.0f);
+}
+
+static void test_1d() {
+  TensorFixedSize<float, Sizes<6> > vec1;
+  TensorFixedSize<float, Sizes<6>, RowMajor> vec2;
+
+  VERIFY_IS_EQUAL((vec1.size()), 6);
+  //  VERIFY_IS_EQUAL((vec1.dimensions()[0]), 6);
+  //  VERIFY_IS_EQUAL((vec1.dimension(0)), 6);
+
+  vec1(0) = 4.0;
+  vec2(0) = 0.0;
+  vec1(1) = 8.0;
+  vec2(1) = 1.0;
+  vec1(2) = 15.0;
+  vec2(2) = 2.0;
+  vec1(3) = 16.0;
+  vec2(3) = 3.0;
+  vec1(4) = 23.0;
+  vec2(4) = 4.0;
+  vec1(5) = 42.0;
+  vec2(5) = 5.0;
+
+  // Test against shallow copy.
+  TensorFixedSize<float, Sizes<6> > copy = vec1;
+  VERIFY_IS_NOT_EQUAL(vec1.data(), copy.data());
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_APPROX(vec1(i), copy(i));
+  }
+  copy = vec1;
+  VERIFY_IS_NOT_EQUAL(vec1.data(), copy.data());
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_APPROX(vec1(i), copy(i));
+  }
+
+  TensorFixedSize<float, Sizes<6> > vec3 = vec1.sqrt();
+  TensorFixedSize<float, Sizes<6>, RowMajor> vec4 = vec2.sqrt();
+
+  VERIFY_IS_EQUAL((vec3.size()), 6);
+  VERIFY_IS_EQUAL(vec3.rank(), 1);
+  //  VERIFY_IS_EQUAL((vec3.dimensions()[0]), 6);
+  //  VERIFY_IS_EQUAL((vec3.dimension(0)), 6);
+
+  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
+  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
+  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0));
+  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0));
+  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
+  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
+
+  VERIFY_IS_APPROX(vec4(0), sqrtf(0.0));
+  VERIFY_IS_APPROX(vec4(1), sqrtf(1.0));
+  VERIFY_IS_APPROX(vec4(2), sqrtf(2.0));
+  VERIFY_IS_APPROX(vec4(3), sqrtf(3.0));
+  VERIFY_IS_APPROX(vec4(4), sqrtf(4.0));
+  VERIFY_IS_APPROX(vec4(5), sqrtf(5.0));
+
+  vec3 = vec1 + vec2;
+  VERIFY_IS_APPROX(vec3(0), 4.0f + 0.0f);
+  VERIFY_IS_APPROX(vec3(1), 8.0f + 1.0f);
+  VERIFY_IS_APPROX(vec3(2), 15.0f + 2.0f);
+  VERIFY_IS_APPROX(vec3(3), 16.0f + 3.0f);
+  VERIFY_IS_APPROX(vec3(4), 23.0f + 4.0f);
+  VERIFY_IS_APPROX(vec3(5), 42.0f + 5.0f);
+}
+
+static void test_tensor_map() {
+  TensorFixedSize<float, Sizes<6> > vec1;
+  TensorFixedSize<float, Sizes<6>, RowMajor> vec2;
+
+  vec1(0) = 4.0;
+  vec2(0) = 0.0;
+  vec1(1) = 8.0;
+  vec2(1) = 1.0;
+  vec1(2) = 15.0;
+  vec2(2) = 2.0;
+  vec1(3) = 16.0;
+  vec2(3) = 3.0;
+  vec1(4) = 23.0;
+  vec2(4) = 4.0;
+  vec1(5) = 42.0;
+  vec2(5) = 5.0;
+
+  float data3[6];
+  TensorMap<TensorFixedSize<float, Sizes<6> > > vec3(data3, 6);
+  vec3 = vec1.sqrt() + vec2;
+
+  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
+  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0) + 1.0f);
+  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0) + 2.0f);
+  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0) + 3.0f);
+  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0) + 4.0f);
+  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0) + 5.0f);
+}
+
+static void test_2d() {
+  float data1[6];
+  TensorMap<TensorFixedSize<float, Sizes<2, 3> > > mat1(data1, 2, 3);
+  float data2[6];
+  TensorMap<TensorFixedSize<float, Sizes<2, 3>, RowMajor> > mat2(data2, 2, 3);
+
+  VERIFY_IS_EQUAL((mat1.size()), 2 * 3);
+  VERIFY_IS_EQUAL(mat1.rank(), 2);
+  //  VERIFY_IS_EQUAL((mat1.dimension(0)), 2);
+  //  VERIFY_IS_EQUAL((mat1.dimension(1)), 3);
+
+  mat1(0, 0) = 0.0;
+  mat1(0, 1) = 1.0;
+  mat1(0, 2) = 2.0;
+  mat1(1, 0) = 3.0;
+  mat1(1, 1) = 4.0;
+  mat1(1, 2) = 5.0;
+
+  mat2(0, 0) = -0.0;
+  mat2(0, 1) = -1.0;
+  mat2(0, 2) = -2.0;
+  mat2(1, 0) = -3.0;
+  mat2(1, 1) = -4.0;
+  mat2(1, 2) = -5.0;
+
+  TensorFixedSize<float, Sizes<2, 3> > mat3;
+  TensorFixedSize<float, Sizes<2, 3>, RowMajor> mat4;
+  mat3 = mat1.abs();
+  mat4 = mat2.abs();
+
+  VERIFY_IS_EQUAL((mat3.size()), 2 * 3);
+  //  VERIFY_IS_EQUAL((mat3.dimension(0)), 2);
+  //  VERIFY_IS_EQUAL((mat3.dimension(1)), 3);
+
+  VERIFY_IS_APPROX(mat3(0, 0), 0.0f);
+  VERIFY_IS_APPROX(mat3(0, 1), 1.0f);
+  VERIFY_IS_APPROX(mat3(0, 2), 2.0f);
+  VERIFY_IS_APPROX(mat3(1, 0), 3.0f);
+  VERIFY_IS_APPROX(mat3(1, 1), 4.0f);
+  VERIFY_IS_APPROX(mat3(1, 2), 5.0f);
+
+  VERIFY_IS_APPROX(mat4(0, 0), 0.0f);
+  VERIFY_IS_APPROX(mat4(0, 1), 1.0f);
+  VERIFY_IS_APPROX(mat4(0, 2), 2.0f);
+  VERIFY_IS_APPROX(mat4(1, 0), 3.0f);
+  VERIFY_IS_APPROX(mat4(1, 1), 4.0f);
+  VERIFY_IS_APPROX(mat4(1, 2), 5.0f);
+}
+
+static void test_3d() {
+  TensorFixedSize<float, Sizes<2, 3, 7> > mat1;
+  TensorFixedSize<float, Sizes<2, 3, 7>, RowMajor> mat2;
+
+  VERIFY_IS_EQUAL((mat1.size()), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(mat1.rank(), 3);
+  //  VERIFY_IS_EQUAL((mat1.dimension(0)), 2);
+  //  VERIFY_IS_EQUAL((mat1.dimension(1)), 3);
+  //  VERIFY_IS_EQUAL((mat1.dimension(2)), 7);
+
+  float val = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        mat2(i, j, k) = val;
+        val += 1.0f;
+      }
+    }
+  }
+
+  TensorFixedSize<float, Sizes<2, 3, 7> > mat3;
+  mat3 = mat1.sqrt();
+  TensorFixedSize<float, Sizes<2, 3, 7>, RowMajor> mat4;
+  mat4 = mat2.sqrt();
+
+  VERIFY_IS_EQUAL((mat3.size()), 2 * 3 * 7);
+  //  VERIFY_IS_EQUAL((mat3.dimension(0)), 2);
+  //  VERIFY_IS_EQUAL((mat3.dimension(1)), 3);
+  //  VERIFY_IS_EQUAL((mat3.dimension(2)), 7);
+
+  val = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat3(i, j, k), sqrtf(val));
+        VERIFY_IS_APPROX(mat4(i, j, k), sqrtf(val));
+        val += 1.0f;
+      }
+    }
+  }
+}
+
+static void test_array() {
+  TensorFixedSize<float, Sizes<2, 3, 7> > mat1;
+  float val = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        val += 1.0f;
+      }
+    }
+  }
+
+  TensorFixedSize<float, Sizes<2, 3, 7> > mat3;
+  mat3 = mat1.pow(3.5f);
+
+  val = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat3(i, j, k), powf(val, 3.5f));
+        val += 1.0f;
+      }
+    }
+  }
+}
+
+// Sanity check: `TensorFixedSize` whose element count isn't a multiple of the packet width
+// (5 floats) must still be safely usable when embedded in a larger aligned struct at
+// a non-16-byte-aligned offset.  Since `IsAligned` (and thus the `Aligned`/`Unaligned`
+// `LoadMode` `TensorEvaluator` picks for packet ops) is a flat, `Size`-independent trait,
+// it must not assume a stronger alignment than the storage actually provides for odd
+// sizes like this one.
+struct TensorFixedSizeEmbeddingHolder {
+  float pad;
+  TensorFixedSize<float, Sizes<5> > tensor;
+};
+
+static void test_embedded_odd_size() {
+  EIGEN_ALIGN_MAX TensorFixedSizeEmbeddingHolder lhs;
+  EIGEN_ALIGN_MAX TensorFixedSizeEmbeddingHolder rhs;
+
+  for (int i = 0; i < 5; ++i) {
+    rhs.tensor(i) = static_cast<float>(i + 1);
+  }
+
+  lhs.tensor = rhs.tensor + rhs.tensor;
+
+  for (int i = 0; i < 5; ++i) {
+    VERIFY_IS_APPROX(lhs.tensor(i), 2.0f * static_cast<float>(i + 1));
+  }
+}
+
+// Regression test: `IsAligned` is consumed by evaluators as the legacy `Aligned` load mode,
+// which promises `Aligned16`-byte alignment regardless of what `EIGEN_MAX_STATIC_ALIGN_BYTES`
+// is actually set to.  A build configured with `0 < EIGEN_MAX_STATIC_ALIGN_BYTES < Aligned`
+// (e.g. 8) still only 8-byte-aligns `TensorStorage`'s fixed array via `EIGEN_ALIGN_MAX`, so
+// `IsAligned` must not claim aligned access is safe unless the configured static alignment
+// actually reaches `Aligned` (16) bytes.
+static_assert(TensorFixedSize<float, Sizes<5> >::IsAligned == (EIGEN_MAX_STATIC_ALIGN_BYTES >= 16),
+              "IsAligned must match whether EIGEN_MAX_STATIC_ALIGN_BYTES actually provides Aligned16 storage");
+
+// Regression test for issue #1616: unsigned index types must not trigger
+// narrowing errors in the variadic accessors.
+static void test_unsigned_indices() {
+  TensorFixedSize<float, Sizes<2, 3> > tensor;
+  tensor.setZero();
+
+  tensor(1u, std::size_t(2)) = 5.0f;
+  VERIFY_IS_EQUAL(tensor(1ul, 2u), 5.0f);
+  tensor.coeffRef(0u, 1ul) = 7.0f;
+
+  const TensorFixedSize<float, Sizes<2, 3> >& const_tensor = tensor;
+  VERIFY_IS_EQUAL(const_tensor.coeff(0ul, 1u), 7.0f);
+  VERIFY_IS_EQUAL(const_tensor(0u, std::size_t(1)), 7.0f);
+}
+
+// An index the tensor's index type cannot represent must assert rather than silently truncate.
+static void test_narrowing_indices() {
+  // Fixed width: on ILP32 targets shifting std::size_t by 40 is undefined, and GCC folds it to an in-range 0.
+  const std::uint64_t too_large = std::uint64_t(1) << 40;
+
+  TensorFixedSize<float, Sizes<2, 3>, ColMajor, int> tensor;
+  tensor.setZero();
+  VERIFY_RAISES_ASSERT(tensor(0, too_large) = 1.0f);
+  VERIFY_RAISES_ASSERT(tensor.coeffRef(0, too_large) = 1.0f);
+
+  const TensorFixedSize<float, Sizes<2, 3>, ColMajor, int>& const_tensor = tensor;
+  VERIFY_RAISES_ASSERT(const_tensor(0, too_large));
+  VERIFY_RAISES_ASSERT(const_tensor.coeff(0, too_large));
+}
+
+EIGEN_DECLARE_TEST(tensor_fixed_size) {
+  CALL_SUBTEST(test_0d());
+  CALL_SUBTEST(test_1d());
+  CALL_SUBTEST(test_tensor_map());
+  CALL_SUBTEST(test_2d());
+  CALL_SUBTEST(test_3d());
+  CALL_SUBTEST(test_array());
+  CALL_SUBTEST(test_embedded_odd_size());
+  CALL_SUBTEST(test_unsigned_indices());
+  CALL_SUBTEST(test_narrowing_indices());
+}
diff --git a/contrib/test/tensor_forced_eval.cpp b/contrib/test/tensor_forced_eval.cpp
new file mode 100644
index 0000000..708eec7
--- /dev/null
+++ b/contrib/test/tensor_forced_eval.cpp
@@ -0,0 +1,94 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+
+#include "main.h"
+
+#include <Eigen/Core>
+#include <Eigen/Tensor>
+
+#include "AnnoyingScalar.h"
+
+using Eigen::MatrixXf;
+using Eigen::Tensor;
+
+static void test_simple() {
+  MatrixXf m1(3, 3);
+  MatrixXf m2(3, 3);
+  m1.setRandom();
+  m2.setRandom();
+
+  TensorMap<Tensor<float, 2> > mat1(m1.data(), 3, 3);
+  TensorMap<Tensor<float, 2> > mat2(m2.data(), 3, 3);
+
+  Tensor<float, 2> mat3(3, 3);
+  mat3 = mat1;
+
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims;
+  dims[0] = DimPair(1, 0);
+
+  mat3 = mat3.contract(mat2, dims).eval();
+
+  VERIFY_IS_APPROX(mat3(0, 0), (m1 * m2).eval()(0, 0));
+  VERIFY_IS_APPROX(mat3(0, 1), (m1 * m2).eval()(0, 1));
+  VERIFY_IS_APPROX(mat3(0, 2), (m1 * m2).eval()(0, 2));
+  VERIFY_IS_APPROX(mat3(1, 0), (m1 * m2).eval()(1, 0));
+  VERIFY_IS_APPROX(mat3(1, 1), (m1 * m2).eval()(1, 1));
+  VERIFY_IS_APPROX(mat3(1, 2), (m1 * m2).eval()(1, 2));
+  VERIFY_IS_APPROX(mat3(2, 0), (m1 * m2).eval()(2, 0));
+  VERIFY_IS_APPROX(mat3(2, 1), (m1 * m2).eval()(2, 1));
+  VERIFY_IS_APPROX(mat3(2, 2), (m1 * m2).eval()(2, 2));
+}
+
+static void test_const() {
+  MatrixXf input(3, 3);
+  input.setRandom();
+  MatrixXf output = input;
+  output.rowwise() -= input.colwise().maxCoeff();
+
+  Eigen::array<int, 1> depth_dim;
+  depth_dim[0] = 0;
+  Tensor<float, 2>::Dimensions dims2d;
+  dims2d[0] = 1;
+  dims2d[1] = 3;
+  Eigen::array<int, 2> bcast;
+  bcast[0] = 3;
+  bcast[1] = 1;
+  const TensorMap<const Tensor<float, 2> > input_tensor(input.data(), 3, 3);
+  Tensor<float, 2> output_tensor =
+      (input_tensor - input_tensor.maximum(depth_dim).eval().reshape(dims2d).broadcast(bcast));
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_APPROX(output(i, j), output_tensor(i, j));
+    }
+  }
+}
+
+// Bug #1530: forced-eval of a non-POD tensor leaked elements because
+// TensorForcedEvalOp::cleanup() never called destructors on the placement-new'd
+// buffer.
+static void test_non_pod_no_leak() {
+  AnnoyingScalar::instances = 0;
+  {
+    Tensor<AnnoyingScalar, 1> a(8);
+    Tensor<AnnoyingScalar, 1> b(8);
+    b = a.eval();  // forces TensorForcedEvalOp
+  }
+  VERIFY_IS_EQUAL(AnnoyingScalar::instances, 0);
+}
+
+EIGEN_DECLARE_TEST(tensor_forced_eval) {
+  CALL_SUBTEST(test_simple());
+  CALL_SUBTEST(test_const());
+  CALL_SUBTEST(test_non_pod_no_leak());
+}
diff --git a/contrib/test/tensor_forced_eval_sycl.cpp b/contrib/test/tensor_forced_eval_sycl.cpp
new file mode 100644
index 0000000..71108c8
--- /dev/null
+++ b/contrib/test/tensor_forced_eval_sycl.cpp
@@ -0,0 +1,79 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+template <typename DataType, int DataLayout, typename IndexType>
+void test_forced_eval_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 100;
+  IndexType sizeDim2 = 20;
+  IndexType sizeDim3 = 20;
+  Eigen::array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
+  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange);
+  Eigen::Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
+
+  DataType* gpu_in1_data =
+      static_cast<DataType*>(sycl_device.allocate(in1.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_in2_data =
+      static_cast<DataType*>(sycl_device.allocate(in2.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
+
+  in1 = in1.random() + in1.constant(static_cast<DataType>(10.0f));
+  in2 = in2.random() + in2.constant(static_cast<DataType>(10.0f));
+
+  // creating TensorMap from tensor
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, tensorRange);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, tensorRange);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
+  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.dimensions().TotalSize()) * sizeof(DataType));
+  /// c=(a+b)*b
+  gpu_out.device(sycl_device) = (gpu_in1 + gpu_in2).eval() * gpu_in2;
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) + in2(i, j, k)) * in2(i, j, k));
+      }
+    }
+  }
+  printf("(a+b)*b Test Passed\n");
+  sycl_device.deallocate(gpu_in1_data);
+  sycl_device.deallocate(gpu_in2_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, typename Dev_selector>
+void tensorForced_evalperDevice(Dev_selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_forced_eval_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_forced_eval_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_forced_eval_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(tensorForced_evalperDevice<float>(device));
+    CALL_SUBTEST(tensorForced_evalperDevice<half>(device));
+  }
+}
diff --git a/contrib/test/tensor_generator.cpp b/contrib/test/tensor_generator.cpp
new file mode 100644
index 0000000..33bf39a
--- /dev/null
+++ b/contrib/test/tensor_generator.cpp
@@ -0,0 +1,83 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+struct Generator1D {
+  Generator1D() {}
+
+  float operator()(const array<Eigen::DenseIndex, 1>& coordinates) const { return coordinates[0]; }
+};
+
+template <int DataLayout>
+static void test_1D() {
+  Tensor<float, 1, DataLayout> vec(6);
+  Tensor<float, 1, DataLayout> result = vec.generate(Generator1D());
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(result(i), i);
+  }
+}
+
+struct Generator2D {
+  Generator2D() {}
+
+  float operator()(const array<Eigen::DenseIndex, 2>& coordinates) const {
+    return 3 * coordinates[0] + 11 * coordinates[1];
+  }
+};
+
+template <int DataLayout>
+static void test_2D() {
+  Tensor<float, 2, DataLayout> matrix(512, 512);
+  Tensor<float, 2, DataLayout> result = matrix.generate(Generator2D());
+
+  for (int i = 0; i < 512; ++i) {
+    for (int j = 0; j < 512; ++j) {
+      VERIFY_IS_EQUAL(result(i, j), 3 * i + 11 * j);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_gaussian() {
+  int rows = 32;
+  int cols = 48;
+  array<float, 2> means;
+  means[0] = rows / 2.0f;
+  means[1] = cols / 2.0f;
+  array<float, 2> std_devs;
+  std_devs[0] = 3.14f;
+  std_devs[1] = 2.7f;
+  internal::GaussianGenerator<float, Eigen::DenseIndex, 2> gaussian_gen(means, std_devs);
+
+  Tensor<float, 2, DataLayout> matrix(rows, cols);
+  Tensor<float, 2, DataLayout> result = matrix.generate(gaussian_gen);
+
+  for (int i = 0; i < rows; ++i) {
+    for (int j = 0; j < cols; ++j) {
+      float g_rows = powf(rows / 2.0f - i, 2) / (3.14f * 3.14f) * 0.5f;
+      float g_cols = powf(cols / 2.0f - j, 2) / (2.7f * 2.7f) * 0.5f;
+      float gaussian = expf(-g_rows - g_cols);
+      VERIFY_IS_EQUAL(result(i, j), gaussian);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_generator) {
+  CALL_SUBTEST(test_1D<ColMajor>());
+  CALL_SUBTEST(test_1D<RowMajor>());
+  CALL_SUBTEST(test_2D<ColMajor>());
+  CALL_SUBTEST(test_2D<RowMajor>());
+  CALL_SUBTEST(test_gaussian<ColMajor>());
+  CALL_SUBTEST(test_gaussian<RowMajor>());
+}
diff --git a/contrib/test/tensor_generator_sycl.cpp b/contrib/test/tensor_generator_sycl.cpp
new file mode 100644
index 0000000..6439afd
--- /dev/null
+++ b/contrib/test/tensor_generator_sycl.cpp
@@ -0,0 +1,141 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+static const float error_threshold = 1e-8f;
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+struct Generator1D {
+  Generator1D() {}
+
+  float operator()(const array<Eigen::DenseIndex, 1>& coordinates) const { return coordinates[0]; }
+};
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_1D_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 6;
+  array<IndexType, 1> tensorRange = {{sizeDim1}};
+  Tensor<DataType, 1, DataLayout, IndexType> vec(tensorRange);
+  Tensor<DataType, 1, DataLayout, IndexType> result(tensorRange);
+
+  const size_t tensorBuffSize = vec.size() * sizeof(DataType);
+  DataType* gpu_data_vec = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_result = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+
+  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> gpu_vec(gpu_data_vec, tensorRange);
+  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> gpu_result(gpu_data_result, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_vec, vec.data(), tensorBuffSize);
+  gpu_result.device(sycl_device) = gpu_vec.generate(Generator1D());
+  sycl_device.memcpyDeviceToHost(result.data(), gpu_data_result, tensorBuffSize);
+
+  for (IndexType i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(result(i), i);
+  }
+}
+
+struct Generator2D {
+  Generator2D() {}
+
+  float operator()(const array<Eigen::DenseIndex, 2>& coordinates) const {
+    return 3 * coordinates[0] + 11 * coordinates[1];
+  }
+};
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_2D_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 5;
+  IndexType sizeDim2 = 7;
+  array<IndexType, 2> tensorRange = {{sizeDim1, sizeDim2}};
+  Tensor<DataType, 2, DataLayout, IndexType> matrix(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> result(tensorRange);
+
+  const size_t tensorBuffSize = matrix.size() * sizeof(DataType);
+  DataType* gpu_data_matrix = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_result = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_matrix(gpu_data_matrix, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_result(gpu_data_result, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_matrix, matrix.data(), tensorBuffSize);
+  gpu_result.device(sycl_device) = gpu_matrix.generate(Generator2D());
+  sycl_device.memcpyDeviceToHost(result.data(), gpu_data_result, tensorBuffSize);
+
+  for (IndexType i = 0; i < 5; ++i) {
+    for (IndexType j = 0; j < 5; ++j) {
+      VERIFY_IS_EQUAL(result(i, j), 3 * i + 11 * j);
+    }
+  }
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_gaussian_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType rows = 32;
+  IndexType cols = 48;
+  array<DataType, 2> means;
+  means[0] = rows / 2.0f;
+  means[1] = cols / 2.0f;
+  array<DataType, 2> std_devs;
+  std_devs[0] = 3.14f;
+  std_devs[1] = 2.7f;
+  internal::GaussianGenerator<DataType, Eigen::DenseIndex, 2> gaussian_gen(means, std_devs);
+
+  array<IndexType, 2> tensorRange = {{rows, cols}};
+  Tensor<DataType, 2, DataLayout, IndexType> matrix(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> result(tensorRange);
+
+  const size_t tensorBuffSize = matrix.size() * sizeof(DataType);
+  DataType* gpu_data_matrix = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_result = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_matrix(gpu_data_matrix, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_result(gpu_data_result, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_matrix, matrix.data(), tensorBuffSize);
+  gpu_result.device(sycl_device) = gpu_matrix.generate(gaussian_gen);
+  sycl_device.memcpyDeviceToHost(result.data(), gpu_data_result, tensorBuffSize);
+
+  for (IndexType i = 0; i < rows; ++i) {
+    for (IndexType j = 0; j < cols; ++j) {
+      DataType g_rows = powf(rows / 2.0f - i, 2) / (3.14f * 3.14f) * 0.5f;
+      DataType g_cols = powf(cols / 2.0f - j, 2) / (2.7f * 2.7f) * 0.5f;
+      DataType gaussian = expf(-g_rows - g_cols);
+      Eigen::internal::isApprox(result(i, j), gaussian, error_threshold);
+    }
+  }
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_generator_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_1D_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_1D_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_2D_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_2D_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_gaussian_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_gaussian_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_generator_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_generator_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_gpu.cu b/contrib/test/tensor_gpu.cu
new file mode 100644
index 0000000..6689473
--- /dev/null
+++ b/contrib/test/tensor_gpu.cu
@@ -0,0 +1,1642 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+void test_gpu_nullary() {
+  Tensor<float, 1, 0, int> in1(2);
+  Tensor<float, 1, 0, int> in2(2);
+  in1.setRandom();
+  in2.setRandom();
+
+  std::size_t tensor_bytes = in1.size() * sizeof(float);
+
+  float* d_in1;
+  float* d_in2;
+  gpuMalloc((void**)(&d_in1), tensor_bytes);
+  gpuMalloc((void**)(&d_in2), tensor_bytes);
+  gpuMemcpy(d_in1, in1.data(), tensor_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in2, in2.data(), tensor_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1, 0, int>, Eigen::Aligned> gpu_in1(d_in1, 2);
+  Eigen::TensorMap<Eigen::Tensor<float, 1, 0, int>, Eigen::Aligned> gpu_in2(d_in2, 2);
+
+  gpu_in1.device(gpu_device) = gpu_in1.constant(3.14f);
+  gpu_in2.device(gpu_device) = gpu_in2.random();
+
+  Tensor<float, 1, 0, int> new1(2);
+  Tensor<float, 1, 0, int> new2(2);
+
+  assert(gpuMemcpyAsync(new1.data(), d_in1, tensor_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuMemcpyAsync(new2.data(), d_in2, tensor_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 2; ++i) {
+    VERIFY_IS_APPROX(new1(i), 3.14f);
+    VERIFY_IS_NOT_EQUAL(new2(i), in2(i));
+  }
+
+  gpuFree(d_in1);
+  gpuFree(d_in2);
+}
+
+// Tests that there are no indexing overflows when computing tensors with the
+// max representable size.
+template <typename IndexType, IndexType N = (std::numeric_limits<IndexType>::max)()>
+void test_gpu_nullary_max_size() {
+  typedef int8_t DataType;
+  typedef Tensor<DataType, 1, 0, IndexType> TensorType;
+  typedef Eigen::array<IndexType, 1> ArrayType;
+
+  const IndexType n = N;
+  TensorType in1((ArrayType(n)));
+  in1.setZero();
+
+  std::size_t in1_bytes = in1.size() * sizeof(DataType);
+
+  DataType* d_in1;
+  gpuMalloc((void**)(&d_in1), in1_bytes);
+
+  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<TensorType> gpu_in1(d_in1, ArrayType(n));
+
+  gpu_in1.device(gpu_device) = gpu_in1.constant(123);
+
+  TensorType new1((ArrayType(n)));
+
+  assert(gpuMemcpyAsync(new1.data(), d_in1, in1_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (IndexType i = 0; i < n; ++i) {
+    VERIFY_IS_EQUAL(new1(ArrayType(i)), 123);
+  }
+
+  gpuFree(d_in1);
+}
+
+void test_gpu_elementwise_small() {
+  Tensor<float, 1> in1(Eigen::array<Eigen::DenseIndex, 1>{2});
+  Tensor<float, 1> in2(Eigen::array<Eigen::DenseIndex, 1>{2});
+  Tensor<float, 1> out(Eigen::array<Eigen::DenseIndex, 1>{2});
+  in1.setRandom();
+  in2.setRandom();
+
+  std::size_t in1_bytes = in1.size() * sizeof(float);
+  std::size_t in2_bytes = in2.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_in1;
+  float* d_in2;
+  float* d_out;
+  gpuMalloc((void**)(&d_in1), in1_bytes);
+  gpuMalloc((void**)(&d_in2), in2_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in2, in2.data(), in2_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_in1(d_in1, Eigen::array<Eigen::DenseIndex, 1>{2});
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_in2(d_in2, Eigen::array<Eigen::DenseIndex, 1>{2});
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_out(d_out, Eigen::array<Eigen::DenseIndex, 1>{2});
+
+  gpu_out.device(gpu_device) = gpu_in1 + gpu_in2;
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 2; ++i) {
+    VERIFY_IS_APPROX(out(Eigen::array<Eigen::DenseIndex, 1>{i}),
+                     in1(Eigen::array<Eigen::DenseIndex, 1>{i}) + in2(Eigen::array<Eigen::DenseIndex, 1>{i}));
+  }
+
+  gpuFree(d_in1);
+  gpuFree(d_in2);
+  gpuFree(d_out);
+}
+
+void test_gpu_elementwise() {
+  Tensor<float, 3> in1(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  Tensor<float, 3> in2(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  Tensor<float, 3> in3(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  Tensor<float, 3> out(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  in1.setRandom();
+  in2.setRandom();
+  in3.setRandom();
+
+  std::size_t in1_bytes = in1.size() * sizeof(float);
+  std::size_t in2_bytes = in2.size() * sizeof(float);
+  std::size_t in3_bytes = in3.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_in1;
+  float* d_in2;
+  float* d_in3;
+  float* d_out;
+  gpuMalloc((void**)(&d_in1), in1_bytes);
+  gpuMalloc((void**)(&d_in2), in2_bytes);
+  gpuMalloc((void**)(&d_in3), in3_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in2, in2.data(), in2_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in3, in3.data(), in3_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_in1(d_in1, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_in2(d_in2, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_in3(d_in3, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_out(d_out, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
+
+  gpu_out.device(gpu_device) = gpu_in1 + gpu_in2 * gpu_in3;
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 53; ++j) {
+      for (int k = 0; k < 97; ++k) {
+        VERIFY_IS_APPROX(
+            out(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}),
+            in1(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}) +
+                in2(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}) * in3(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}));
+      }
+    }
+  }
+
+  gpuFree(d_in1);
+  gpuFree(d_in2);
+  gpuFree(d_in3);
+  gpuFree(d_out);
+}
+
+void test_gpu_props() {
+  Tensor<float, 1> in1(200);
+  Tensor<bool, 1> out(200);
+  in1.setRandom();
+
+  std::size_t in1_bytes = in1.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(bool);
+
+  float* d_in1;
+  bool* d_out;
+  gpuMalloc((void**)(&d_in1), in1_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_in1(d_in1, 200);
+  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_out(d_out, 200);
+
+  gpu_out.device(gpu_device) = (gpu_in1.isnan)();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 200; ++i) {
+    VERIFY_IS_EQUAL(out(i), (std::isnan)(in1(i)));
+  }
+
+  gpuFree(d_in1);
+  gpuFree(d_out);
+}
+
+// Drives the striding evaluators' packet paths directly from device code.
+// TensorExecutor gates GPU vectorization on PacketAccess && IsAligned, and
+// striding is never aligned, so the `.device(gpu) =` path below always takes
+// the scalar kernel and never instantiates packet()/writePacket() for the
+// device. Calling them here is what keeps them device-callable.
+template <typename ReadEvaluator, typename WriteEvaluator>
+__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void striding_packet_kernel(ReadEvaluator read_eval, WriteEvaluator write_eval,
+                                                                    int num_packets) {
+  const int packet_size = Eigen::internal::unpacket_traits<typename ReadEvaluator::PacketReturnType>::size;
+  for (int p = blockIdx.x * blockDim.x + threadIdx.x; p < num_packets; p += blockDim.x * gridDim.x) {
+    const Eigen::DenseIndex index = static_cast<Eigen::DenseIndex>(p) * packet_size;
+    write_eval.template writePacket<Eigen::Unaligned>(index, read_eval.template packet<Eigen::Unaligned>(index));
+  }
+}
+
+// Strided reads and writes on the device. The executor half checks the scalar
+// kernel end to end; the kernel half above reaches the packet paths, which the
+// executor cannot select for an unaligned evaluator.
+template <int DataLayout>
+void test_gpu_striding() {
+  Tensor<float, 2, DataLayout> in(31, 26);
+  Tensor<float, 2, DataLayout> read_out(16, 13);
+  Tensor<float, 2, DataLayout> write_out(31, 26);
+  in.setRandom();
+  write_out.setZero();
+
+  std::size_t in_bytes = in.size() * sizeof(float);
+  std::size_t read_out_bytes = read_out.size() * sizeof(float);
+  std::size_t write_out_bytes = write_out.size() * sizeof(float);
+
+  float* d_in;
+  float* d_read_out;
+  float* d_write_out;
+  gpuMalloc((void**)(&d_in), in_bytes);
+  gpuMalloc((void**)(&d_read_out), read_out_bytes);
+  gpuMalloc((void**)(&d_write_out), write_out_bytes);
+
+  gpuMemcpy(d_in, in.data(), in_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_write_out, write_out.data(), write_out_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>, Eigen::Aligned> gpu_in(d_in, 31, 26);
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>, Eigen::Aligned> gpu_read_out(d_read_out, 16, 13);
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout>, Eigen::Aligned> gpu_write_out(d_write_out, 31, 26);
+
+  Eigen::array<Eigen::DenseIndex, 2> strides{{2, 2}};
+  gpu_read_out.device(gpu_device) = (gpu_in + gpu_in.constant(1.0f)).stride(strides);
+  gpu_write_out.stride(strides).device(gpu_device) =
+      gpu_in.slice(Eigen::array<Eigen::DenseIndex, 2>{{0, 0}}, Eigen::array<Eigen::DenseIndex, 2>{{16, 13}});
+
+  assert(gpuMemcpyAsync(read_out.data(), d_read_out, read_out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+         gpuSuccess);
+  assert(gpuMemcpyAsync(write_out.data(), d_write_out, write_out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+         gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 16; ++i) {
+    for (int j = 0; j < 13; ++j) {
+      VERIFY_IS_EQUAL(read_out(i, j), in(2 * i, 2 * j) + 1.0f);
+      VERIFY_IS_EQUAL(write_out(2 * i, 2 * j), in(i, j));
+    }
+  }
+
+  // Now the packet paths, which the executor above cannot reach.
+  Tensor<float, 2, DataLayout> packet_out(31, 26);
+  packet_out.setZero();
+  gpuMemcpy(d_write_out, packet_out.data(), write_out_bytes, gpuMemcpyHostToDevice);
+
+  auto read_expr = gpu_in.stride(strides);
+  auto write_expr = gpu_write_out.stride(strides);
+  typedef Eigen::TensorEvaluator<const decltype(read_expr), Eigen::GpuDevice> ReadEval;
+  typedef Eigen::TensorEvaluator<decltype(write_expr), Eigen::GpuDevice> WriteEval;
+  ReadEval read_eval(read_expr, gpu_device);
+  WriteEval write_eval(write_expr, gpu_device);
+  read_eval.evalSubExprsIfNeeded(NULL);
+
+  const int packet_size = Eigen::internal::unpacket_traits<typename ReadEval::PacketReturnType>::size;
+  const int num_packets = static_cast<int>(read_eval.dimensions().TotalSize()) / packet_size;
+#ifdef EIGEN_USE_HIP
+  hipLaunchKernelGGL(HIP_KERNEL_NAME(striding_packet_kernel<ReadEval, WriteEval>), dim3(1), dim3(64), 0,
+                     gpu_device.stream(), read_eval, write_eval, num_packets);
+#else
+  // Various versions of clang-format incorrectly add spaces to the kernel launch brackets.
+  // clang-format off
+  striding_packet_kernel<ReadEval, WriteEval><<<1, 64, 0, gpu_device.stream()>>>(read_eval, write_eval, num_packets);
+  // clang-format on
+#endif
+  assert(gpuMemcpyAsync(packet_out.data(), d_write_out, write_out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
+         gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+  read_eval.cleanup();
+
+  // Only whole packets are stored; the tail stays zero.
+  for (int k = 0; k < num_packets * packet_size; ++k) {
+    const int i = (static_cast<int>(DataLayout) == static_cast<int>(ColMajor)) ? k % 16 : k / 13;
+    const int j = (static_cast<int>(DataLayout) == static_cast<int>(ColMajor)) ? k / 16 : k % 13;
+    VERIFY_IS_EQUAL(packet_out(2 * i, 2 * j), in(2 * i, 2 * j));
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_read_out);
+  gpuFree(d_write_out);
+}
+
+void test_gpu_reduction() {
+  Tensor<float, 4> in1(72, 53, 97, 113);
+  Tensor<float, 2> out(72, 97);
+  in1.setRandom();
+
+  std::size_t in1_bytes = in1.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_in1;
+  float* d_out;
+  gpuMalloc((void**)(&d_in1), in1_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 4> > gpu_in1(d_in1, 72, 53, 97, 113);
+  Eigen::TensorMap<Eigen::Tensor<float, 2> > gpu_out(d_out, 72, 97);
+
+  array<Eigen::DenseIndex, 2> reduction_axis;
+  reduction_axis[0] = 1;
+  reduction_axis[1] = 3;
+
+  gpu_out.device(gpu_device) = gpu_in1.maximum(reduction_axis);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 97; ++j) {
+      float expected = 0;
+      for (int k = 0; k < 53; ++k) {
+        for (int l = 0; l < 113; ++l) {
+          expected = std::max<float>(expected, in1(i, k, j, l));
+        }
+      }
+      VERIFY_IS_APPROX(out(i, j), expected);
+    }
+  }
+
+  gpuFree(d_in1);
+  gpuFree(d_out);
+}
+
+template <int DataLayout>
+void test_gpu_contraction() {
+  // with these dimensions, the output has 300 * 140 elements, which is
+  // more than 30 * 1024, which is the number of threads in blocks on
+  // a 15 SM GK110 GPU
+  Tensor<float, 4, DataLayout> t_left(6, 50, 3, 31);
+  Tensor<float, 5, DataLayout> t_right(Eigen::array<Eigen::DenseIndex, 5>{3, 31, 7, 20, 1});
+  Tensor<float, 5, DataLayout> t_result(Eigen::array<Eigen::DenseIndex, 5>{6, 50, 7, 20, 1});
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  std::size_t t_left_bytes = t_left.size() * sizeof(float);
+  std::size_t t_right_bytes = t_right.size() * sizeof(float);
+  std::size_t t_result_bytes = t_result.size() * sizeof(float);
+
+  float* d_t_left;
+  float* d_t_right;
+  float* d_t_result;
+
+  gpuMalloc((void**)(&d_t_left), t_left_bytes);
+  gpuMalloc((void**)(&d_t_right), t_right_bytes);
+  gpuMalloc((void**)(&d_t_result), t_result_bytes);
+
+  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_t_left(d_t_left, 6, 50, 3, 31);
+  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_t_right(d_t_right, 3, 31, 7, 20, 1);
+  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_t_result(d_t_result, 6, 50, 7, 20, 1);
+
+  typedef Eigen::Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> > MapXf;
+  MapXf m_left(t_left.data(), 300, 93);
+  MapXf m_right(t_right.data(), 93, 140);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(300, 140);
+
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 2> dims;
+  dims[0] = DimPair(2, 0);
+  dims[1] = DimPair(3, 1);
+
+  m_result = m_left * m_right;
+  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
+
+  gpuMemcpy(t_result.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
+
+  for (DenseIndex i = 0; i < t_result.size(); i++) {
+    // Absolute slack for accumulation-order differences between device and host contractions.
+    if (numext::abs(t_result.data()[i] - m_result.data()[i]) >= 1024 * NumTraits<float>::epsilon()) {
+      std::cout << "mismatch detected at index " << i << ": " << t_result.data()[i] << " vs " << m_result.data()[i]
+                << std::endl;
+      assert(false);
+    }
+  }
+
+  gpuFree(d_t_left);
+  gpuFree(d_t_right);
+  gpuFree(d_t_result);
+}
+
+template <int DataLayout>
+void test_gpu_convolution_1d() {
+  Tensor<float, 4, DataLayout> input(74, 37, 11, 137);
+  Tensor<float, 1, DataLayout> kernel(4);
+  Tensor<float, 4, DataLayout> out(74, 34, 11, 137);
+  input = input.constant(10.0f) + input.random();
+  kernel = kernel.constant(7.0f) + kernel.random();
+
+  std::size_t input_bytes = input.size() * sizeof(float);
+  std::size_t kernel_bytes = kernel.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_input;
+  float* d_kernel;
+  float* d_out;
+  gpuMalloc((void**)(&d_input), input_bytes);
+  gpuMalloc((void**)(&d_kernel), kernel_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_input(d_input, 74, 37, 11, 137);
+  Eigen::TensorMap<Eigen::Tensor<float, 1, DataLayout> > gpu_kernel(d_kernel, 4);
+  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_out(d_out, 74, 34, 11, 137);
+
+  Eigen::array<Eigen::DenseIndex, 1> dims{1};
+  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 74; ++i) {
+    for (int j = 0; j < 34; ++j) {
+      for (int k = 0; k < 11; ++k) {
+        for (int l = 0; l < 137; ++l) {
+          const float result = out(i, j, k, l);
+          const float expected = input(i, j + 0, k, l) * kernel(0) + input(i, j + 1, k, l) * kernel(1) +
+                                 input(i, j + 2, k, l) * kernel(2) + input(i, j + 3, k, l) * kernel(3);
+          VERIFY_IS_APPROX(result, expected);
+        }
+      }
+    }
+  }
+
+  gpuFree(d_input);
+  gpuFree(d_kernel);
+  gpuFree(d_out);
+}
+
+void test_gpu_convolution_inner_dim_col_major_1d() {
+  Tensor<float, 4, ColMajor> input(74, 9, 11, 7);
+  Tensor<float, 1, ColMajor> kernel(4);
+  Tensor<float, 4, ColMajor> out(71, 9, 11, 7);
+  input = input.constant(10.0f) + input.random();
+  kernel = kernel.constant(7.0f) + kernel.random();
+
+  std::size_t input_bytes = input.size() * sizeof(float);
+  std::size_t kernel_bytes = kernel.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_input;
+  float* d_kernel;
+  float* d_out;
+  gpuMalloc((void**)(&d_input), input_bytes);
+  gpuMalloc((void**)(&d_kernel), kernel_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 4, ColMajor> > gpu_input(d_input, 74, 9, 11, 7);
+  Eigen::TensorMap<Eigen::Tensor<float, 1, ColMajor> > gpu_kernel(d_kernel, 4);
+  Eigen::TensorMap<Eigen::Tensor<float, 4, ColMajor> > gpu_out(d_out, 71, 9, 11, 7);
+
+  Eigen::array<Eigen::DenseIndex, 1> dims{0};
+  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 71; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 11; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          const float result = out(i, j, k, l);
+          const float expected = input(i + 0, j, k, l) * kernel(0) + input(i + 1, j, k, l) * kernel(1) +
+                                 input(i + 2, j, k, l) * kernel(2) + input(i + 3, j, k, l) * kernel(3);
+          VERIFY_IS_APPROX(result, expected);
+        }
+      }
+    }
+  }
+
+  gpuFree(d_input);
+  gpuFree(d_kernel);
+  gpuFree(d_out);
+}
+
+void test_gpu_convolution_inner_dim_row_major_1d() {
+  Tensor<float, 4, RowMajor> input(7, 9, 11, 74);
+  Tensor<float, 1, RowMajor> kernel(4);
+  Tensor<float, 4, RowMajor> out(7, 9, 11, 71);
+  input = input.constant(10.0f) + input.random();
+  kernel = kernel.constant(7.0f) + kernel.random();
+
+  std::size_t input_bytes = input.size() * sizeof(float);
+  std::size_t kernel_bytes = kernel.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_input;
+  float* d_kernel;
+  float* d_out;
+  gpuMalloc((void**)(&d_input), input_bytes);
+  gpuMalloc((void**)(&d_kernel), kernel_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 4, RowMajor> > gpu_input(d_input, 7, 9, 11, 74);
+  Eigen::TensorMap<Eigen::Tensor<float, 1, RowMajor> > gpu_kernel(d_kernel, 4);
+  Eigen::TensorMap<Eigen::Tensor<float, 4, RowMajor> > gpu_out(d_out, 7, 9, 11, 71);
+
+  Eigen::array<Eigen::DenseIndex, 1> dims{3};
+  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 7; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 11; ++k) {
+        for (int l = 0; l < 71; ++l) {
+          const float result = out(i, j, k, l);
+          const float expected = input(i, j, k, l + 0) * kernel(0) + input(i, j, k, l + 1) * kernel(1) +
+                                 input(i, j, k, l + 2) * kernel(2) + input(i, j, k, l + 3) * kernel(3);
+          VERIFY_IS_APPROX(result, expected);
+        }
+      }
+    }
+  }
+
+  gpuFree(d_input);
+  gpuFree(d_kernel);
+  gpuFree(d_out);
+}
+
+template <int DataLayout>
+void test_gpu_convolution_2d() {
+  Tensor<float, 4, DataLayout> input(74, 37, 11, 137);
+  Tensor<float, 2, DataLayout> kernel(3, 4);
+  Tensor<float, 4, DataLayout> out(74, 35, 8, 137);
+  input = input.constant(10.0f) + input.random();
+  kernel = kernel.constant(7.0f) + kernel.random();
+
+  std::size_t input_bytes = input.size() * sizeof(float);
+  std::size_t kernel_bytes = kernel.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_input;
+  float* d_kernel;
+  float* d_out;
+  gpuMalloc((void**)(&d_input), input_bytes);
+  gpuMalloc((void**)(&d_kernel), kernel_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_input(d_input, 74, 37, 11, 137);
+  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_kernel(d_kernel, 3, 4);
+  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_out(d_out, 74, 35, 8, 137);
+
+  Eigen::array<Eigen::DenseIndex, 2> dims{1, 2};
+  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 74; ++i) {
+    for (int j = 0; j < 35; ++j) {
+      for (int k = 0; k < 8; ++k) {
+        for (int l = 0; l < 137; ++l) {
+          const float result = out(i, j, k, l);
+          const float expected = input(i, j + 0, k + 0, l) * kernel(0, 0) + input(i, j + 1, k + 0, l) * kernel(1, 0) +
+                                 input(i, j + 2, k + 0, l) * kernel(2, 0) + input(i, j + 0, k + 1, l) * kernel(0, 1) +
+                                 input(i, j + 1, k + 1, l) * kernel(1, 1) + input(i, j + 2, k + 1, l) * kernel(2, 1) +
+                                 input(i, j + 0, k + 2, l) * kernel(0, 2) + input(i, j + 1, k + 2, l) * kernel(1, 2) +
+                                 input(i, j + 2, k + 2, l) * kernel(2, 2) + input(i, j + 0, k + 3, l) * kernel(0, 3) +
+                                 input(i, j + 1, k + 3, l) * kernel(1, 3) + input(i, j + 2, k + 3, l) * kernel(2, 3);
+          VERIFY_IS_APPROX(result, expected);
+        }
+      }
+    }
+  }
+
+  gpuFree(d_input);
+  gpuFree(d_kernel);
+  gpuFree(d_out);
+}
+
+template <int DataLayout>
+void test_gpu_convolution_3d() {
+  Tensor<float, 5, DataLayout> input(Eigen::array<Eigen::DenseIndex, 5>{74, 37, 11, 137, 17});
+  Tensor<float, 3, DataLayout> kernel(3, 4, 2);
+  Tensor<float, 5, DataLayout> out(Eigen::array<Eigen::DenseIndex, 5>{74, 35, 8, 136, 17});
+  input = input.constant(10.0f) + input.random();
+  kernel = kernel.constant(7.0f) + kernel.random();
+
+  std::size_t input_bytes = input.size() * sizeof(float);
+  std::size_t kernel_bytes = kernel.size() * sizeof(float);
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_input;
+  float* d_kernel;
+  float* d_out;
+  gpuMalloc((void**)(&d_input), input_bytes);
+  gpuMalloc((void**)(&d_kernel), kernel_bytes);
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_input(d_input, 74, 37, 11, 137, 17);
+  Eigen::TensorMap<Eigen::Tensor<float, 3, DataLayout> > gpu_kernel(d_kernel, 3, 4, 2);
+  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_out(d_out, 74, 35, 8, 136, 17);
+
+  Eigen::array<Eigen::DenseIndex, 3> dims{1, 2, 3};
+  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 74; ++i) {
+    for (int j = 0; j < 35; ++j) {
+      for (int k = 0; k < 8; ++k) {
+        for (int l = 0; l < 136; ++l) {
+          for (int m = 0; m < 17; ++m) {
+            const float result = out(i, j, k, l, m);
+            const float expected = input(i, j + 0, k + 0, l + 0, m) * kernel(0, 0, 0) +
+                                   input(i, j + 1, k + 0, l + 0, m) * kernel(1, 0, 0) +
+                                   input(i, j + 2, k + 0, l + 0, m) * kernel(2, 0, 0) +
+                                   input(i, j + 0, k + 1, l + 0, m) * kernel(0, 1, 0) +
+                                   input(i, j + 1, k + 1, l + 0, m) * kernel(1, 1, 0) +
+                                   input(i, j + 2, k + 1, l + 0, m) * kernel(2, 1, 0) +
+                                   input(i, j + 0, k + 2, l + 0, m) * kernel(0, 2, 0) +
+                                   input(i, j + 1, k + 2, l + 0, m) * kernel(1, 2, 0) +
+                                   input(i, j + 2, k + 2, l + 0, m) * kernel(2, 2, 0) +
+                                   input(i, j + 0, k + 3, l + 0, m) * kernel(0, 3, 0) +
+                                   input(i, j + 1, k + 3, l + 0, m) * kernel(1, 3, 0) +
+                                   input(i, j + 2, k + 3, l + 0, m) * kernel(2, 3, 0) +
+                                   input(i, j + 0, k + 0, l + 1, m) * kernel(0, 0, 1) +
+                                   input(i, j + 1, k + 0, l + 1, m) * kernel(1, 0, 1) +
+                                   input(i, j + 2, k + 0, l + 1, m) * kernel(2, 0, 1) +
+                                   input(i, j + 0, k + 1, l + 1, m) * kernel(0, 1, 1) +
+                                   input(i, j + 1, k + 1, l + 1, m) * kernel(1, 1, 1) +
+                                   input(i, j + 2, k + 1, l + 1, m) * kernel(2, 1, 1) +
+                                   input(i, j + 0, k + 2, l + 1, m) * kernel(0, 2, 1) +
+                                   input(i, j + 1, k + 2, l + 1, m) * kernel(1, 2, 1) +
+                                   input(i, j + 2, k + 2, l + 1, m) * kernel(2, 2, 1) +
+                                   input(i, j + 0, k + 3, l + 1, m) * kernel(0, 3, 1) +
+                                   input(i, j + 1, k + 3, l + 1, m) * kernel(1, 3, 1) +
+                                   input(i, j + 2, k + 3, l + 1, m) * kernel(2, 3, 1);
+            VERIFY_IS_APPROX(result, expected);
+          }
+        }
+      }
+    }
+  }
+
+  gpuFree(d_input);
+  gpuFree(d_kernel);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_lgamma(const Scalar stddev) {
+  Tensor<Scalar, 2> in(72, 97);
+  in.setRandom();
+  in *= in.constant(stddev);
+  Tensor<Scalar, 2> out(72, 97);
+  out.setZero();
+
+  std::size_t bytes = in.size() * sizeof(Scalar);
+
+  Scalar* d_in;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_in(d_in, 72, 97);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 72, 97);
+
+  gpu_out.device(gpu_device) = gpu_in.lgamma();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 97; ++j) {
+      VERIFY_IS_APPROX(out(i, j), (std::lgamma)(in(i, j)));
+    }
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_digamma() {
+  Tensor<Scalar, 1> in(8);
+  Tensor<Scalar, 1> out(8);
+  Tensor<Scalar, 1> expected_out(8);
+  out.setZero();
+
+  in(0) = Scalar(1);
+  in(1) = Scalar(1.5);
+  in(2) = Scalar(4);
+  in(3) = Scalar(-10.5);
+  in(4) = Scalar(10000.5);
+  in(5) = Scalar(0.0);
+  in(6) = Scalar(-0.0);
+  in(7) = Scalar(-1);
+
+  expected_out(0) = Scalar(-0.5772156649015329);
+  expected_out(1) = Scalar(0.03648997397857645);
+  expected_out(2) = Scalar(1.2561176684318);
+  expected_out(3) = Scalar(2.398239129535781);
+  expected_out(4) = Scalar(9.210340372392849);
+  // Signed infinities at the zero pole, as in special_functions.cpp; NaN at
+  // the negative-integer poles.
+  expected_out(5) = -std::numeric_limits<Scalar>::infinity();
+  expected_out(6) = std::numeric_limits<Scalar>::infinity();
+  expected_out(7) = std::numeric_limits<Scalar>::quiet_NaN();
+
+  std::size_t bytes = in.size() * sizeof(Scalar);
+
+  Scalar* d_in;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 8);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 8);
+
+  gpu_out.device(gpu_device) = gpu_in.digamma();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 8; ++i) {
+    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_zeta() {
+  Tensor<Scalar, 1> in_x(6);
+  Tensor<Scalar, 1> in_q(6);
+  Tensor<Scalar, 1> out(6);
+  Tensor<Scalar, 1> expected_out(6);
+  out.setZero();
+
+  in_x(0) = Scalar(1);
+  in_x(1) = Scalar(1.5);
+  in_x(2) = Scalar(4);
+  in_x(3) = Scalar(-10.5);
+  in_x(4) = Scalar(10000.5);
+  in_x(5) = Scalar(3);
+
+  in_q(0) = Scalar(1.2345);
+  in_q(1) = Scalar(2);
+  in_q(2) = Scalar(1.5);
+  in_q(3) = Scalar(3);
+  in_q(4) = Scalar(1.0001);
+  in_q(5) = Scalar(-2.5);
+
+  expected_out(0) = std::numeric_limits<Scalar>::infinity();
+  expected_out(1) = Scalar(1.61237534869);
+  expected_out(2) = Scalar(0.234848505667);
+  expected_out(3) = std::numeric_limits<Scalar>::quiet_NaN();
+  expected_out(4) = Scalar(0.367879440865);
+  expected_out(5) = Scalar(0.054102025820864097);
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_in_x;
+  Scalar* d_in_q;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in_x), bytes);
+  gpuMalloc((void**)(&d_in_q), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in_q, in_q.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 6);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_q(d_in_q, 6);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 6);
+
+  gpu_out.device(gpu_device) = gpu_in_x.zeta(gpu_in_q);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in_x);
+  gpuFree(d_in_q);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_polygamma() {
+  Tensor<Scalar, 1> in_x(7);
+  Tensor<Scalar, 1> in_n(7);
+  Tensor<Scalar, 1> out(7);
+  Tensor<Scalar, 1> expected_out(7);
+  out.setZero();
+
+  in_n(0) = Scalar(1);
+  in_n(1) = Scalar(1);
+  in_n(2) = Scalar(1);
+  in_n(3) = Scalar(17);
+  in_n(4) = Scalar(31);
+  in_n(5) = Scalar(28);
+  in_n(6) = Scalar(8);
+
+  in_x(0) = Scalar(2);
+  in_x(1) = Scalar(3);
+  in_x(2) = Scalar(25.5);
+  in_x(3) = Scalar(4.7);
+  in_x(4) = Scalar(11.8);
+  in_x(5) = Scalar(17.7);
+  in_x(6) = Scalar(30.2);
+
+  expected_out(0) = Scalar(0.644934066848);
+  expected_out(1) = Scalar(0.394934066848);
+  expected_out(2) = Scalar(0.0399946696496);
+  expected_out(3) = Scalar(293.334565435);
+  expected_out(4) = Scalar(0.445487887616);
+  expected_out(5) = Scalar(-2.47810300902e-07);
+  expected_out(6) = Scalar(-8.29668781082e-09);
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_in_x;
+  Scalar* d_in_n;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in_x), bytes);
+  gpuMalloc((void**)(&d_in_n), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in_n, in_n.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 7);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_n(d_in_n, 7);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 7);
+
+  gpu_out.device(gpu_device) = gpu_in_n.polygamma(gpu_in_x);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 7; ++i) {
+    VERIFY_IS_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in_x);
+  gpuFree(d_in_n);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_igamma() {
+  Tensor<Scalar, 2> a(6, 6);
+  Tensor<Scalar, 2> x(6, 6);
+  Tensor<Scalar, 2> out(6, 6);
+  Tensor<Scalar, 2> expected_out(6, 6);
+  out.setZero();
+
+  Scalar a_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
+  Scalar x_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
+
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      a(i, j) = a_s[i];
+      x(i, j) = x_s[j];
+    }
+  }
+
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      expected_out(i, j) = numext::igamma(a(i, j), x(i, j));
+    }
+  }
+
+  std::size_t bytes = a.size() * sizeof(Scalar);
+
+  Scalar* d_a;
+  Scalar* d_x;
+  Scalar* d_out;
+  assert(gpuMalloc((void**)(&d_a), bytes) == gpuSuccess);
+  assert(gpuMalloc((void**)(&d_x), bytes) == gpuSuccess);
+  assert(gpuMalloc((void**)(&d_out), bytes) == gpuSuccess);
+
+  gpuMemcpy(d_a, a.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_x, x.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_a(d_a, 6, 6);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_x(d_x, 6, 6);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 6, 6);
+
+  gpu_out.device(gpu_device) = gpu_a.igamma(gpu_x);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      if ((std::isnan)(expected_out(i, j))) {
+        VERIFY((std::isnan)(out(i, j)));
+      } else {
+        VERIFY_IS_APPROX(out(i, j), expected_out(i, j));
+      }
+    }
+  }
+
+  gpuFree(d_a);
+  gpuFree(d_x);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_igammac() {
+  Tensor<Scalar, 2> a(6, 6);
+  Tensor<Scalar, 2> x(6, 6);
+  Tensor<Scalar, 2> out(6, 6);
+  Tensor<Scalar, 2> expected_out(6, 6);
+  out.setZero();
+
+  Scalar a_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
+  Scalar x_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
+
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      a(i, j) = a_s[i];
+      x(i, j) = x_s[j];
+    }
+  }
+
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      expected_out(i, j) = numext::igammac(a(i, j), x(i, j));
+    }
+  }
+
+  std::size_t bytes = a.size() * sizeof(Scalar);
+
+  Scalar* d_a;
+  Scalar* d_x;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_a), bytes);
+  gpuMalloc((void**)(&d_x), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_a, a.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_x, x.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_a(d_a, 6, 6);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_x(d_x, 6, 6);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 6, 6);
+
+  gpu_out.device(gpu_device) = gpu_a.igammac(gpu_x);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      if ((std::isnan)(expected_out(i, j))) {
+        VERIFY((std::isnan)(out(i, j)));
+      } else {
+        VERIFY_IS_APPROX(out(i, j), expected_out(i, j));
+      }
+    }
+  }
+
+  gpuFree(d_a);
+  gpuFree(d_x);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_erf(const Scalar stddev) {
+  Tensor<Scalar, 2> in(72, 97);
+  in.setRandom();
+  in *= in.constant(stddev);
+  Tensor<Scalar, 2> out(72, 97);
+  out.setZero();
+
+  std::size_t bytes = in.size() * sizeof(Scalar);
+
+  Scalar* d_in;
+  Scalar* d_out;
+  assert(gpuMalloc((void**)(&d_in), bytes) == gpuSuccess);
+  assert(gpuMalloc((void**)(&d_out), bytes) == gpuSuccess);
+
+  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_in(d_in, 72, 97);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 72, 97);
+
+  gpu_out.device(gpu_device) = gpu_in.erf();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 97; ++j) {
+      VERIFY_IS_APPROX(out(i, j), (std::erf)(in(i, j)));
+    }
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_erfc(const Scalar stddev) {
+  Tensor<Scalar, 2> in(72, 97);
+  in.setRandom();
+  in *= in.constant(stddev);
+  Tensor<Scalar, 2> out(72, 97);
+  out.setZero();
+
+  std::size_t bytes = in.size() * sizeof(Scalar);
+
+  Scalar* d_in;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_in(d_in, 72, 97);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 72, 97);
+
+  gpu_out.device(gpu_device) = gpu_in.erfc();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 97; ++j) {
+      VERIFY_IS_APPROX(out(i, j), (std::erfc)(in(i, j)));
+    }
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_ndtri() {
+  Tensor<Scalar, 1> in_x(9);
+  Tensor<Scalar, 1> out(9);
+  Tensor<Scalar, 1> expected_out(9);
+  out.setZero();
+
+  in_x(0) = Scalar(1);
+  in_x(1) = Scalar(0.);
+  in_x(2) = Scalar(0.5);
+  in_x(3) = Scalar(0.2);
+  in_x(4) = Scalar(0.8);
+  in_x(5) = Scalar(0.9);
+  in_x(6) = Scalar(0.1);
+  in_x(7) = Scalar(0.99);
+  in_x(8) = Scalar(0.01);
+
+  for (int i = 0; i < 9; ++i) {
+    expected_out(i) = numext::ndtri(in_x(i));
+  }
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_in_x;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in_x), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 9);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 9);
+
+  gpu_out.device(gpu_device) = gpu_in_x.ndtri();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 9; ++i) {
+    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in_x);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_betainc() {
+  Tensor<Scalar, 1> in_x(125);
+  Tensor<Scalar, 1> in_a(125);
+  Tensor<Scalar, 1> in_b(125);
+  Tensor<Scalar, 1> out(125);
+  Tensor<Scalar, 1> expected_out(125);
+  out.setZero();
+
+  Array<Scalar, 1, Dynamic> x(125);
+  Array<Scalar, 1, Dynamic> a(125);
+  Array<Scalar, 1, Dynamic> b(125);
+
+  a << 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+      0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999,
+      0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379,
+      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+      999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999,
+      999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999,
+      999.999;
+
+  b << 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+      31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999,
+      0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
+      31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999,
+      0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999,
+      999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999,
+      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999,
+      999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
+      0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379,
+      31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999;
+
+  x << -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1,
+      0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5,
+      0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1,
+      -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2,
+      0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8,
+      1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1;
+
+  for (int i = 0; i < 125; ++i) {
+    in_x(i) = x(i);
+    in_a(i) = a(i);
+    in_b(i) = b(i);
+    expected_out(i) = numext::betainc(a(i), b(i), x(i));
+  }
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_in_x;
+  Scalar* d_in_a;
+  Scalar* d_in_b;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in_x), bytes);
+  gpuMalloc((void**)(&d_in_a), bytes);
+  gpuMalloc((void**)(&d_in_b), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in_a, in_a.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_in_b, in_b.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 125);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_a(d_in_a, 125);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_b(d_in_b, 125);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 125);
+
+  gpu_out.device(gpu_device) = betainc(gpu_in_a, gpu_in_b, gpu_in_x);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 125; ++i) {
+    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in_x);
+  gpuFree(d_in_a);
+  gpuFree(d_in_b);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_i0e() {
+  Tensor<Scalar, 1> in_x(21);
+  Tensor<Scalar, 1> out(21);
+  Tensor<Scalar, 1> expected_out(21);
+  out.setZero();
+
+  Array<Scalar, 1, Dynamic> in_x_array(21);
+  Array<Scalar, 1, Dynamic> expected_out_array(21);
+
+  in_x_array << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0,
+      14.0, 16.0, 18.0, 20.0;
+
+  expected_out_array << 0.0897803118848, 0.0947062952128, 0.100544127361, 0.107615251671, 0.116426221213,
+      0.127833337163, 0.143431781857, 0.16665743264, 0.207001921224, 0.308508322554, 1.0, 0.308508322554,
+      0.207001921224, 0.16665743264, 0.143431781857, 0.127833337163, 0.116426221213, 0.107615251671, 0.100544127361,
+      0.0947062952128, 0.0897803118848;
+
+  for (int i = 0; i < 21; ++i) {
+    in_x(i) = in_x_array(i);
+    expected_out(i) = expected_out_array(i);
+  }
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_in;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in, in_x.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 21);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 21);
+
+  gpu_out.device(gpu_device) = gpu_in.bessel_i0e();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 21; ++i) {
+    VERIFY_IS_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_i1e() {
+  Tensor<Scalar, 1> in_x(21);
+  Tensor<Scalar, 1> out(21);
+  Tensor<Scalar, 1> expected_out(21);
+  out.setZero();
+
+  Array<Scalar, 1, Dynamic> in_x_array(21);
+  Array<Scalar, 1, Dynamic> expected_out_array(21);
+
+  in_x_array << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0,
+      14.0, 16.0, 18.0, 20.0;
+
+  expected_out_array << -0.0875062221833, -0.092036796872, -0.0973496147565, -0.103697667463, -0.11146429929,
+      -0.121262681384, -0.134142493293, -0.152051459309, -0.178750839502, -0.215269289249, 0.0, 0.215269289249,
+      0.178750839502, 0.152051459309, 0.134142493293, 0.121262681384, 0.11146429929, 0.103697667463, 0.0973496147565,
+      0.092036796872, 0.0875062221833;
+
+  for (int i = 0; i < 21; ++i) {
+    in_x(i) = in_x_array(i);
+    expected_out(i) = expected_out_array(i);
+  }
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_in;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_in), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_in, in_x.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 21);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 21);
+
+  gpu_out.device(gpu_device) = gpu_in.bessel_i1e();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 21; ++i) {
+    VERIFY_IS_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_in);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_igamma_der_a() {
+  Tensor<Scalar, 1> in_x(30);
+  Tensor<Scalar, 1> in_a(30);
+  Tensor<Scalar, 1> out(30);
+  Tensor<Scalar, 1> expected_out(30);
+  out.setZero();
+
+  Array<Scalar, 1, Dynamic> in_a_array(30);
+  Array<Scalar, 1, Dynamic> in_x_array(30);
+  Array<Scalar, 1, Dynamic> expected_out_array(30);
+
+  // See special_functions.cpp for the Python code that generates the test data.
+
+  in_a_array << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0, 10.0,
+      10.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
+
+  in_x_array << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
+      5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
+      1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
+      10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
+      968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
+
+  expected_out_array << -32.7256441441, -36.4394150514, -9.66467612263, -36.4394150514, -36.4394150514, -1.0891900302,
+      -2.66351229645, -2.48666868596, -0.929700494428, -3.56327722764, -0.455320135314, -0.391437214323,
+      -0.491352055991, -0.350454834292, -0.471773162921, -0.104084440522, -0.0723646747909, -0.0992828975532,
+      -0.121638215446, -0.122619605294, -0.0317670267286, -0.0359974812869, -0.0154359225363, -0.0375775365921,
+      -0.00794899153653, -0.00777303219211, -0.00796085782042, -0.0125850719397, -0.00455500206958, -0.00476436993148;
+
+  for (int i = 0; i < 30; ++i) {
+    in_x(i) = in_x_array(i);
+    in_a(i) = in_a_array(i);
+    expected_out(i) = expected_out_array(i);
+  }
+
+  std::size_t bytes = in_x.size() * sizeof(Scalar);
+
+  Scalar* d_a;
+  Scalar* d_x;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_a), bytes);
+  gpuMalloc((void**)(&d_x), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_a, in_a.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_a(d_a, 30);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_x(d_x, 30);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 30);
+
+  gpu_out.device(gpu_device) = gpu_a.igamma_der_a(gpu_x);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 30; ++i) {
+    VERIFY_IS_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_a);
+  gpuFree(d_x);
+  gpuFree(d_out);
+}
+
+template <typename Scalar>
+void test_gpu_gamma_sample_der_alpha() {
+  Tensor<Scalar, 1> in_alpha(30);
+  Tensor<Scalar, 1> in_sample(30);
+  Tensor<Scalar, 1> out(30);
+  Tensor<Scalar, 1> expected_out(30);
+  out.setZero();
+
+  Array<Scalar, 1, Dynamic> in_alpha_array(30);
+  Array<Scalar, 1, Dynamic> in_sample_array(30);
+  Array<Scalar, 1, Dynamic> expected_out_array(30);
+
+  // See special_functions.cpp for the Python code that generates the test data.
+
+  in_alpha_array << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0,
+      10.0, 10.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
+
+  in_sample_array << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
+      5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
+      1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
+      10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
+      968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
+
+  expected_out_array << 7.42424742367e-23, 1.02004297287e-34, 0.0130155240738, 1.02004297287e-34, 1.02004297287e-34,
+      1.96505168277e-13, 0.525575786243, 0.713903991771, 2.32077561808e-14, 0.000179348049886, 0.635500453302,
+      1.27561284917, 0.878125852156, 0.41565819538, 1.03606488534, 0.885964824887, 1.16424049334, 1.10764479598,
+      1.04590810812, 1.04193666963, 0.965193152414, 0.976217589464, 0.93008035061, 0.98153216096, 0.909196397698,
+      0.98434963993, 0.984738050206, 1.00106492525, 0.97734200649, 1.02198794179;
+
+  for (int i = 0; i < 30; ++i) {
+    in_alpha(i) = in_alpha_array(i);
+    in_sample(i) = in_sample_array(i);
+    expected_out(i) = expected_out_array(i);
+  }
+
+  std::size_t bytes = in_alpha.size() * sizeof(Scalar);
+
+  Scalar* d_alpha;
+  Scalar* d_sample;
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_alpha), bytes);
+  gpuMalloc((void**)(&d_sample), bytes);
+  gpuMalloc((void**)(&d_out), bytes);
+
+  gpuMemcpy(d_alpha, in_alpha.data(), bytes, gpuMemcpyHostToDevice);
+  gpuMemcpy(d_sample, in_sample.data(), bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_alpha(d_alpha, 30);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_sample(d_sample, 30);
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 30);
+
+  gpu_out.device(gpu_device) = gpu_alpha.gamma_sample_der_alpha(gpu_sample);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  for (int i = 0; i < 30; ++i) {
+    VERIFY_IS_APPROX(out(i), expected_out(i));
+  }
+
+  gpuFree(d_alpha);
+  gpuFree(d_sample);
+  gpuFree(d_out);
+}
+
+EIGEN_DECLARE_TEST(tensor_gpu) {
+  CALL_SUBTEST_1(test_gpu_nullary());
+  CALL_SUBTEST_1(test_gpu_nullary_max_size<int16_t>());
+  CALL_SUBTEST_1(test_gpu_nullary_max_size<int32_t>());
+  CALL_SUBTEST_1((test_gpu_nullary_max_size<int64_t, (std::numeric_limits<int32_t>::max)() + 100ll>()));
+  CALL_SUBTEST_1(test_gpu_elementwise_small());
+  CALL_SUBTEST_1(test_gpu_elementwise());
+  CALL_SUBTEST_1(test_gpu_props());
+  CALL_SUBTEST_1(test_gpu_striding<ColMajor>());
+  CALL_SUBTEST_1(test_gpu_striding<RowMajor>());
+  CALL_SUBTEST_2(test_gpu_reduction());
+  CALL_SUBTEST_3(test_gpu_contraction<ColMajor>());
+  CALL_SUBTEST_3(test_gpu_contraction<RowMajor>());
+  CALL_SUBTEST_4(test_gpu_convolution_1d<ColMajor>());
+  CALL_SUBTEST_4(test_gpu_convolution_1d<RowMajor>());
+  CALL_SUBTEST_4(test_gpu_convolution_inner_dim_col_major_1d());
+  CALL_SUBTEST_4(test_gpu_convolution_inner_dim_row_major_1d());
+  CALL_SUBTEST_5(test_gpu_convolution_2d<ColMajor>());
+  CALL_SUBTEST_5(test_gpu_convolution_2d<RowMajor>());
+#if !defined(EIGEN_USE_HIP)
+  // disable these tests on HIP for now.
+  // they hang..need to investigate and fix
+  CALL_SUBTEST_6(test_gpu_convolution_3d<ColMajor>());
+  CALL_SUBTEST_7(test_gpu_convolution_3d<RowMajor>());
+#endif
+
+  CALL_SUBTEST_8(test_gpu_lgamma<float>(1.0f));
+  CALL_SUBTEST_8(test_gpu_lgamma<float>(100.0f));
+  CALL_SUBTEST_8(test_gpu_lgamma<float>(0.01f));
+  CALL_SUBTEST_8(test_gpu_lgamma<float>(0.001f));
+
+  CALL_SUBTEST_8(test_gpu_lgamma<double>(1.0));
+  CALL_SUBTEST_8(test_gpu_lgamma<double>(100.0));
+  CALL_SUBTEST_8(test_gpu_lgamma<double>(0.01));
+  CALL_SUBTEST_8(test_gpu_lgamma<double>(0.001));
+
+  CALL_SUBTEST_8(test_gpu_erf<float>(1.0f));
+  CALL_SUBTEST_8(test_gpu_erf<float>(100.0f));
+  CALL_SUBTEST_8(test_gpu_erf<float>(0.01f));
+  CALL_SUBTEST_8(test_gpu_erf<float>(0.001f));
+
+  CALL_SUBTEST_8(test_gpu_erfc<float>(1.0f));
+  // CALL_SUBTEST_8(test_gpu_erfc<float>(100.0f));
+  CALL_SUBTEST_8(test_gpu_erfc<float>(5.0f));  // GPU erfc lacks precision for large inputs
+  CALL_SUBTEST_8(test_gpu_erfc<float>(0.01f));
+  CALL_SUBTEST_8(test_gpu_erfc<float>(0.001f));
+
+  CALL_SUBTEST_8(test_gpu_erf<double>(1.0));
+  CALL_SUBTEST_8(test_gpu_erf<double>(100.0));
+  CALL_SUBTEST_8(test_gpu_erf<double>(0.01));
+  CALL_SUBTEST_8(test_gpu_erf<double>(0.001));
+
+  CALL_SUBTEST_8(test_gpu_erfc<double>(1.0));
+  // CALL_SUBTEST_8(test_gpu_erfc<double>(100.0));
+  CALL_SUBTEST_8(test_gpu_erfc<double>(5.0));  // GPU erfc lacks precision for large inputs
+  CALL_SUBTEST_8(test_gpu_erfc<double>(0.01));
+  CALL_SUBTEST_8(test_gpu_erfc<double>(0.001));
+
+#if !defined(EIGEN_USE_HIP)
+  // disable these tests on HIP for now.
+
+  CALL_SUBTEST_9(test_gpu_ndtri<float>());
+  CALL_SUBTEST_9(test_gpu_ndtri<double>());
+
+  CALL_SUBTEST_9(test_gpu_digamma<float>());
+  CALL_SUBTEST_9(test_gpu_digamma<double>());
+
+  CALL_SUBTEST_9(test_gpu_polygamma<float>());
+  CALL_SUBTEST_9(test_gpu_polygamma<double>());
+
+  CALL_SUBTEST_9(test_gpu_zeta<float>());
+  CALL_SUBTEST_9(test_gpu_zeta<double>());
+#endif
+
+  CALL_SUBTEST_9(test_gpu_igamma<float>());
+  CALL_SUBTEST_9(test_gpu_igammac<float>());
+
+  CALL_SUBTEST_9(test_gpu_igamma<double>());
+  CALL_SUBTEST_9(test_gpu_igammac<double>());
+
+#if !defined(EIGEN_USE_HIP)
+  // disable these tests on HIP for now.
+  CALL_SUBTEST_9(test_gpu_betainc<float>());
+  CALL_SUBTEST_9(test_gpu_betainc<double>());
+
+  CALL_SUBTEST_9(test_gpu_i0e<float>());
+  CALL_SUBTEST_9(test_gpu_i0e<double>());
+
+  CALL_SUBTEST_9(test_gpu_i1e<float>());
+  CALL_SUBTEST_9(test_gpu_i1e<double>());
+
+  CALL_SUBTEST_9(test_gpu_igamma_der_a<float>());
+  CALL_SUBTEST_9(test_gpu_igamma_der_a<double>());
+
+  CALL_SUBTEST_9(test_gpu_gamma_sample_der_alpha<float>());
+  CALL_SUBTEST_9(test_gpu_gamma_sample_der_alpha<double>());
+#endif
+}
diff --git a/contrib/test/tensor_gpu_device_attributes.cu b/contrib/test/tensor_gpu_device_attributes.cu
new file mode 100644
index 0000000..aa4c983
--- /dev/null
+++ b/contrib/test/tensor_gpu_device_attributes.cu
@@ -0,0 +1,137 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+#define EIGEN_USE_GPU
+#define EIGEN_NO_DEBUG
+
+#if defined(EIGEN_USE_HIP)
+#include <hip/hip_runtime.h>
+using TestGpuError = hipError_t;
+using TestGpuAttribute = hipDeviceAttribute_t;
+#else
+#include <cuda_runtime.h>
+using TestGpuError = cudaError_t;
+using TestGpuAttribute = cudaDeviceAttr;
+#endif
+
+static int driver_version = 11010;
+static int pool_support = 1;
+static int pool_queries = 0;
+static int runtime_errors = 0;
+static TestGpuError injected_error = static_cast<TestGpuError>(0);
+static TestGpuError last_error = static_cast<TestGpuError>(0);
+
+static TestGpuError test_device_get_attribute(int* value, TestGpuAttribute attribute, int device);
+static TestGpuError test_get_device_count(int* count) {
+  *count = 2;
+  return static_cast<TestGpuError>(0);
+}
+static TestGpuError test_get_last_error() {
+  const TestGpuError result = last_error;
+  last_error = static_cast<TestGpuError>(0);
+  return result;
+}
+#if defined(EIGEN_USE_HIP)
+#define hipDeviceGetAttribute test_device_get_attribute
+#define hipGetDeviceCount test_get_device_count
+#define hipGetLastError test_get_last_error
+#else
+static cudaError_t test_driver_get_version(int* version) {
+  *version = driver_version;
+  return cudaSuccess;
+}
+#define cudaDeviceGetAttribute test_device_get_attribute
+#define cudaGetDeviceCount test_get_device_count
+#define cudaGetLastError test_get_last_error
+#define cudaDriverGetVersion test_driver_get_version
+#endif
+
+static void record_runtime_error(TestGpuError error) {
+  if (static_cast<int>(error) != 0) ++runtime_errors;
+}
+#define EIGEN_GPU_RUNTIME_CHECK(expr) record_runtime_error(expr)
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+// Inject old-runtime responses before the public umbrella is parsed, without requiring old drivers or hardware.
+static TestGpuError test_device_get_attribute(int* value, TestGpuAttribute attribute, int device) {
+  *value = -1;
+  if (injected_error != gpuSuccess) return injected_error;
+  if (attribute == gpuDevAttrMaxSharedMemoryPerBlockOptin) {
+#if defined(EIGEN_USE_HIP)
+    if (device == 0) return last_error = hipErrorInvalidValue;
+#endif
+    *value = 98304;
+  } else if (attribute == gpuDevAttrMaxSharedMemoryPerBlock) {
+    *value = 49152;
+  } else if (attribute == gpuDevAttrMemoryPoolsSupported) {
+    ++pool_queries;
+#if !defined(EIGEN_USE_HIP)
+    if (driver_version < 11020) return last_error = cudaErrorInvalidValue;
+#endif
+    *value = pool_support;
+  } else if (attribute == gpuDevAttrWarpSize) {
+    *value = 32 * (device + 1);
+  } else {
+    *value = 1;
+  }
+  return gpuSuccess;
+}
+
+static void test_attribute_cache() {
+  // numThreads() initializes every cached field, even on runtimes missing an optional attribute.
+  for (int device = 0; device < 2; ++device) {
+    Eigen::GpuStreamDevice stream(device);
+    Eigen::GpuDevice gpu_device(&stream);
+    VERIFY_IS_EQUAL(gpu_device.numThreads(), static_cast<size_t>(32 * (device + 1)));
+    VERIFY_IS_EQUAL(runtime_errors, 0);
+    VERIFY_IS_EQUAL(test_get_last_error(), gpuSuccess);
+#if defined(EIGEN_USE_HIP)
+    VERIFY_IS_EQUAL(gpu_device.sharedMemPerBlockOptin(), device == 0 ? 49152 : 98304);
+    VERIFY(gpu_device.memoryPoolsSupported());
+#else
+    VERIFY_IS_EQUAL(gpu_device.sharedMemPerBlockOptin(), 98304);
+    VERIFY(!gpu_device.memoryPoolsSupported());
+    VERIFY_IS_EQUAL(pool_queries, 0);
+#endif
+  }
+}
+
+static void test_attribute_queries() {
+  driver_version = 11020;
+  for (int supported = 0; supported <= 1; ++supported) {
+    pool_support = supported;
+    const int queries_before = pool_queries;
+    VERIFY_IS_EQUAL(Eigen::GetGpuDeviceAttribute(gpuDevAttrMemoryPoolsSupported, 0), supported);
+    VERIFY_IS_EQUAL(pool_queries, queries_before + 1);
+  }
+  VERIFY_IS_EQUAL(runtime_errors, 0);
+
+#if defined(EIGEN_USE_HIP)
+  injected_error = hipErrorInvalidValue;
+#else
+  injected_error = cudaErrorInvalidValue;
+#endif
+  // An invalid-value error on a required attribute or a supported pool query is still a runtime failure.
+  Eigen::GetGpuDeviceAttribute(gpuDevAttrWarpSize, 0);
+  VERIFY_IS_EQUAL(runtime_errors, 1);
+  Eigen::GetGpuDeviceAttribute(gpuDevAttrMemoryPoolsSupported, 0);
+  VERIFY_IS_EQUAL(runtime_errors, 2);
+#if defined(EIGEN_USE_HIP)
+  injected_error = hipErrorInvalidDevice;
+#else
+  injected_error = cudaErrorInvalidDevice;
+#endif
+  Eigen::GetGpuDeviceAttribute(gpuDevAttrMaxSharedMemoryPerBlockOptin, 0);
+  VERIFY_IS_EQUAL(runtime_errors, 3);
+  injected_error = gpuSuccess;
+  runtime_errors = 0;
+}
+
+EIGEN_DECLARE_TEST(tensor_gpu_device_attributes) {
+  CALL_SUBTEST(test_attribute_cache());
+  CALL_SUBTEST(test_attribute_queries());
+}
diff --git a/contrib/test/tensor_gpu_runtime_check.cu b/contrib/test/tensor_gpu_runtime_check.cu
new file mode 100644
index 0000000..4a238c4
--- /dev/null
+++ b/contrib/test/tensor_gpu_runtime_check.cu
@@ -0,0 +1,108 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// A failed runtime call or kernel launch inside GpuDevice has to reach EIGEN_GPU_RUNTIME_CHECK, in a release build
+// as much as in a debug one (tensor_gpu_runtime_check_ndebug.cu compiles this file with EIGEN_NO_DEBUG). The macro
+// is overridden here to record the failure instead of stopping the process.
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_USE_GPU
+
+#include <string>
+
+struct RecordedGpuError {
+  int code = 0;
+  std::string expression;
+  std::string file;
+  int line = 0;
+};
+static RecordedGpuError g_last_gpu_error;
+static int g_num_gpu_errors = 0;
+
+// cudaSuccess and hipSuccess are both 0.
+template <typename Error>
+__host__ void record_gpu_runtime_error(Error error, const char* expression, const char* file, int line) {
+  if (static_cast<int>(error) == 0) return;
+  ++g_num_gpu_errors;
+  g_last_gpu_error.code = static_cast<int>(error);
+  g_last_gpu_error.expression = expression;
+  g_last_gpu_error.file = file;
+  g_last_gpu_error.line = line;
+}
+#define EIGEN_GPU_RUNTIME_CHECK(expr) ::record_gpu_runtime_error((expr), #expr, __FILE__, __LINE__)
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+#if defined(EIGEN_USE_HIP)
+static const int kInvalidConfiguration = static_cast<int>(hipErrorInvalidConfiguration);
+static const int kInvalidValue = static_cast<int>(hipErrorInvalidValue);
+#else
+static const int kInvalidConfiguration = static_cast<int>(cudaErrorInvalidConfiguration);
+static const int kInvalidValue = static_cast<int>(cudaErrorInvalidValue);
+#endif
+
+__global__ void write_one_kernel(int* out) {
+  if (blockIdx.x == 0 && threadIdx.x == 0) *out = 1;
+}
+
+static bool ends_with(const std::string& s, const std::string& suffix) {
+  return s.size() >= suffix.size() && s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+// A valid launch through LAUNCH_GPU_KERNEL runs and records nothing; one with more threads per block than any
+// device allows is refused at enqueue time, and the refusal is reported from gpu_launch's own check.
+static void test_launch_check() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice device(&stream);
+  int* d_out = static_cast<int*>(device.allocate(sizeof(int)));
+  device.memset(d_out, 0, sizeof(int));
+  g_num_gpu_errors = 0;
+
+  LAUNCH_GPU_KERNEL(write_one_kernel, 1, 32, 0, device, d_out);
+  int out = 0;
+  device.memcpyDeviceToHost(&out, d_out, sizeof(int));
+  device.synchronize();
+  VERIFY_IS_EQUAL(out, 1);
+  VERIFY_IS_EQUAL(g_num_gpu_errors, 0);
+
+  const int too_many_threads = 2 * device.maxGpuThreadsPerBlock();
+  LAUNCH_GPU_KERNEL(write_one_kernel, 1, too_many_threads, 0, device, d_out);
+  VERIFY_IS_EQUAL(g_num_gpu_errors, 1);
+  // Which of the two codes an oversize block gets depends on the toolkit: CUDA 13.3 reports invalid value.
+  VERIFY(g_last_gpu_error.code == kInvalidConfiguration || g_last_gpu_error.code == kInvalidValue);
+  VERIFY_IS_EQUAL(g_last_gpu_error.expression, std::string("gpuGetLastError()"));
+  VERIFY(ends_with(g_last_gpu_error.file, "GpuRuntime.h"));
+
+  device.deallocate(d_out);
+  VERIFY_IS_EQUAL(g_num_gpu_errors, 1);
+}
+
+// A runtime call that fails inside GpuDevice is reported with the call's own text and location.
+static void test_runtime_call_check() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice device(&stream);
+  g_num_gpu_errors = 0;
+
+  int host_dst = 0;
+  // HIP can accept a host source here; a null source with a nonzero size is invalid on both runtimes.
+  device.memcpyDeviceToHost(&host_dst, nullptr, sizeof(int));
+  VERIFY_IS_EQUAL(g_num_gpu_errors, 1);
+  VERIFY_IS_EQUAL(g_last_gpu_error.code, kInvalidValue);
+  VERIFY(g_last_gpu_error.expression.find("gpuMemcpyAsync") == 0);
+  VERIFY(ends_with(g_last_gpu_error.file, "TensorDeviceGpu.h"));
+  VERIFY(g_last_gpu_error.line > 0);
+}
+
+EIGEN_DECLARE_TEST(tensor_gpu_runtime_check) {
+  CALL_SUBTEST(test_launch_check());
+  CALL_SUBTEST(test_runtime_call_check());
+}
diff --git a/contrib/test/tensor_gpu_runtime_check_ndebug.cu b/contrib/test/tensor_gpu_runtime_check_ndebug.cu
new file mode 100644
index 0000000..3942f62
--- /dev/null
+++ b/contrib/test/tensor_gpu_runtime_check_ndebug.cu
@@ -0,0 +1,13 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// The same checks with assertions compiled out: the runtime checks have to fire in a release build, where the
+// gpu_assert() calls they replace were empty.
+#define EIGEN_NO_DEBUG 1
+#include "tensor_gpu_runtime_check.cu"
diff --git a/contrib/test/tensor_ifft.cpp b/contrib/test/tensor_ifft.cpp
new file mode 100644
index 0000000..cd341ec
--- /dev/null
+++ b/contrib/test/tensor_ifft.cpp
@@ -0,0 +1,158 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Jianwei Cui <thucjw@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <complex>
+#include <cmath>
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_1D_fft_ifft_invariant(int sequence_length) {
+  Tensor<double, 1, DataLayout> tensor(sequence_length);
+  tensor.setRandom();
+
+  array<int, 1> fft;
+  fft[0] = 0;
+
+  Tensor<std::complex<double>, 1, DataLayout> tensor_after_fft;
+  Tensor<std::complex<double>, 1, DataLayout> tensor_after_fft_ifft;
+
+  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
+  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
+
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), sequence_length);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), sequence_length);
+
+  for (int i = 0; i < sequence_length; ++i) {
+    VERIFY_IS_APPROX(static_cast<float>(tensor(i)), static_cast<float>(std::real(tensor_after_fft_ifft(i))));
+  }
+}
+
+template <int DataLayout>
+static void test_2D_fft_ifft_invariant(int dim0, int dim1) {
+  Tensor<double, 2, DataLayout> tensor(dim0, dim1);
+  tensor.setRandom();
+
+  array<int, 2> fft;
+  fft[0] = 0;
+  fft[1] = 1;
+
+  Tensor<std::complex<double>, 2, DataLayout> tensor_after_fft;
+  Tensor<std::complex<double>, 2, DataLayout> tensor_after_fft_ifft;
+
+  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
+  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
+
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
+
+  for (int i = 0; i < dim0; ++i) {
+    for (int j = 0; j < dim1; ++j) {
+      // std::cout << "[" << i << "][" << j << "]" <<  "  Original data: " << tensor(i,j) << " Transformed data:" <<
+      // tensor_after_fft_ifft(i,j) << std::endl;
+      VERIFY_IS_APPROX(static_cast<float>(tensor(i, j)), static_cast<float>(std::real(tensor_after_fft_ifft(i, j))));
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_3D_fft_ifft_invariant(int dim0, int dim1, int dim2) {
+  Tensor<double, 3, DataLayout> tensor(dim0, dim1, dim2);
+  tensor.setRandom();
+
+  array<int, 3> fft;
+  fft[0] = 0;
+  fft[1] = 1;
+  fft[2] = 2;
+
+  Tensor<std::complex<double>, 3, DataLayout> tensor_after_fft;
+  Tensor<std::complex<double>, 3, DataLayout> tensor_after_fft_ifft;
+
+  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
+  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
+
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(2), dim2);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(2), dim2);
+
+  for (int i = 0; i < dim0; ++i) {
+    for (int j = 0; j < dim1; ++j) {
+      for (int k = 0; k < dim2; ++k) {
+        VERIFY_IS_APPROX(static_cast<float>(tensor(i, j, k)),
+                         static_cast<float>(std::real(tensor_after_fft_ifft(i, j, k))));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_sub_fft_ifft_invariant(int dim0, int dim1, int dim2, int dim3) {
+  Tensor<double, 4, DataLayout> tensor(dim0, dim1, dim2, dim3);
+  tensor.setRandom();
+
+  array<int, 2> fft;
+  fft[0] = 2;
+  fft[1] = 0;
+
+  Tensor<std::complex<double>, 4, DataLayout> tensor_after_fft;
+  Tensor<double, 4, DataLayout> tensor_after_fft_ifft;
+
+  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
+  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::RealPart, Eigen::FFT_REVERSE>(fft);
+
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(2), dim2);
+  VERIFY_IS_EQUAL(tensor_after_fft.dimension(3), dim3);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(2), dim2);
+  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(3), dim3);
+
+  for (int i = 0; i < dim0; ++i) {
+    for (int j = 0; j < dim1; ++j) {
+      for (int k = 0; k < dim2; ++k) {
+        for (int l = 0; l < dim3; ++l) {
+          VERIFY_IS_APPROX(static_cast<float>(tensor(i, j, k, l)),
+                           static_cast<float>(tensor_after_fft_ifft(i, j, k, l)));
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_ifft) {
+  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(4));
+  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(16));
+  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(32));
+  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(1024 * 1024));
+
+  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(4, 4));
+  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(8, 16));
+  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(16, 32));
+  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(1024, 1024));
+
+  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(4, 4, 4));
+  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(8, 16, 32));
+  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(16, 4, 8));
+  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(256, 256, 256));
+
+  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(4, 4, 4, 4));
+  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(8, 16, 32, 64));
+  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(16, 4, 8, 12));
+  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(64, 64, 64, 64));
+}
diff --git a/contrib/test/tensor_image_op_sycl.cpp b/contrib/test/tensor_image_op_sycl.cpp
new file mode 100644
index 0000000..80df57e
--- /dev/null
+++ b/contrib/test/tensor_image_op_sycl.cpp
@@ -0,0 +1,101 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_image_op_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 245;
+  IndexType sizeDim2 = 343;
+  IndexType sizeDim3 = 577;
+
+  array<IndexType, 3> input_range = {{sizeDim1, sizeDim2, sizeDim3}};
+  array<IndexType, 3> slice_range = {{sizeDim1 - 1, sizeDim2, sizeDim3}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> tensor1(input_range);
+  Tensor<DataType, 3, DataLayout, IndexType> tensor2(input_range);
+  Tensor<DataType, 3, DataLayout, IndexType> tensor3(slice_range);
+  Tensor<DataType, 3, DataLayout, IndexType> tensor3_cpu(slice_range);
+
+  typedef Eigen::DSizes<IndexType, 3> Index3;
+  Index3 strides1(1L, 1L, 1L);
+  Index3 indicesStart1(1L, 0L, 0L);
+  Index3 indicesStop1(sizeDim1, sizeDim2, sizeDim3);
+
+  Index3 strides2(1L, 1L, 1L);
+  Index3 indicesStart2(0L, 0L, 0L);
+  Index3 indicesStop2(sizeDim1 - 1, sizeDim2, sizeDim3);
+  Eigen::DSizes<IndexType, 3> sizes(sizeDim1 - 1, sizeDim2, sizeDim3);
+
+  tensor1.setRandom();
+  tensor2.setRandom();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
+  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(tensor3.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, input_range);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, input_range);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu3(gpu_data3, slice_range);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_data2, tensor2.data(), (tensor2.size()) * sizeof(DataType));
+  gpu3.device(sycl_device) = gpu1.slice(indicesStart1, sizes) - gpu2.slice(indicesStart2, sizes);
+  sycl_device.memcpyDeviceToHost(tensor3.data(), gpu_data3, (tensor3.size()) * sizeof(DataType));
+
+  tensor3_cpu = tensor1.stridedSlice(indicesStart1, indicesStop1, strides1) -
+                tensor2.stridedSlice(indicesStart2, indicesStop2, strides2);
+
+  for (IndexType i = 0; i < slice_range[0]; ++i) {
+    for (IndexType j = 0; j < slice_range[1]; ++j) {
+      for (IndexType k = 0; k < slice_range[2]; ++k) {
+        VERIFY_IS_EQUAL(tensor3_cpu(i, j, k), tensor3(i, j, k));
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+  sycl_device.deallocate(gpu_data3);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_computing_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_image_op_sycl<DataType, RowMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_image_op_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_computing_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_computing_test_per_device<float>(device));
+#ifdef EIGEN_SYCL_DOUBLE_SUPPORT
+    CALL_SUBTEST(sycl_computing_test_per_device<double>(device));
+#endif
+  }
+}
diff --git a/contrib/test/tensor_image_patch.cpp b/contrib/test/tensor_image_patch.cpp
new file mode 100644
index 0000000..393e623
--- /dev/null
+++ b/contrib/test/tensor_image_patch.cpp
@@ -0,0 +1,1218 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+void test_simple_patch() {
+  Tensor<float, 4> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
+
+  // Single pixel patch: ColMajor
+  Tensor<float, 5> single_pixel_patch;
+  single_pixel_patch = tensor.extract_image_patches(1, 1);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(0), 2);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(3), 3 * 5);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(4), 7);
+
+  // Single pixel patch: RowMajor
+  Tensor<float, 5, RowMajor> single_pixel_patch_row_major;
+  single_pixel_patch_row_major = tensor_row_major.extract_image_patches(1, 1);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(1), 3 * 5);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(3), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(4), 2);
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    // ColMajor
+    if (tensor.data()[i] != single_pixel_patch.data()[i]) {
+      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
+                << single_pixel_patch.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], tensor.data()[i]);
+    // RowMajor
+    if (tensor_row_major.data()[i] != single_pixel_patch_row_major.data()[i]) {
+      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
+                << single_pixel_patch_row_major.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_pixel_patch_row_major.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], single_pixel_patch_row_major.data()[i]);
+  }
+
+  // Entire image patch: ColMajor
+  Tensor<float, 5> entire_image_patch;
+  entire_image_patch = tensor.extract_image_patches(3, 5);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(0), 2);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(1), 3);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(2), 5);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(3), 3 * 5);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(4), 7);
+
+  // Entire image patch: RowMajor
+  Tensor<float, 5, RowMajor> entire_image_patch_row_major;
+  entire_image_patch_row_major = tensor_row_major.extract_image_patches(3, 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 3 * 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 3);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(4), 2);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      int patchId = i + 3 * j;
+      for (int r = 0; r < 3; ++r) {
+        for (int c = 0; c < 5; ++c) {
+          for (int d = 0; d < 2; ++d) {
+            for (int b = 0; b < 7; ++b) {
+              float expected = 0.0f;
+              float expected_row_major = 0.0f;
+              if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
+                expected = tensor(d, r - 1 + i, c - 2 + j, b);
+                expected_row_major = tensor_row_major(b, c - 2 + j, r - 1 + i, d);
+              }
+              // ColMajor
+              if (entire_image_patch(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(entire_image_patch(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (entire_image_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(entire_image_patch_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 2D patch: ColMajor
+  Tensor<float, 5> twod_patch;
+  twod_patch = tensor.extract_image_patches(2, 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(0), 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(3), 3 * 5);
+  VERIFY_IS_EQUAL(twod_patch.dimension(4), 7);
+
+  // 2D patch: RowMajor
+  Tensor<float, 5, RowMajor> twod_patch_row_major;
+  twod_patch_row_major = tensor_row_major.extract_image_patches(2, 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 3 * 5);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(4), 2);
+
+  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
+  int row_padding = 0;
+  int col_padding = 0;
+  int stride = 1;
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      int patchId = i + 3 * j;
+      for (int r = 0; r < 2; ++r) {
+        for (int c = 0; c < 2; ++c) {
+          for (int d = 0; d < 2; ++d) {
+            for (int b = 0; b < 7; ++b) {
+              float expected = 0.0f;
+              float expected_row_major = 0.0f;
+              int row_offset = r * stride + i - row_padding;
+              int col_offset = c * stride + j - col_padding;
+              // ColMajor
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor.dimension(1) &&
+                  col_offset < tensor.dimension(2)) {
+                expected = tensor(d, row_offset, col_offset, b);
+              }
+              if (twod_patch(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(twod_patch(d, r, c, patchId, b), expected);
+
+              // RowMajor
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(2) &&
+                  col_offset < tensor_row_major.dimension(1)) {
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              if (twod_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(twod_patch_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Verifies VALID padding (no padding) with incrementing values.
+void test_patch_padding_valid() {
+  int input_depth = 3;
+  int input_rows = 3;
+  int input_cols = 3;
+  int input_batches = 1;
+  int ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
+  int stride = 2;  // Only same stride is supported.
+  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
+  // Initializes tensor with incrementing numbers.
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = i + 1;
+  }
+  // ColMajor
+  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+
+  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result.dimension(3), 1);              // number of patches
+  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
+
+  Tensor<float, 5, RowMajor> result_row_major =
+      tensor_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
+
+  // No padding is carried out.
+  int row_padding = 0;
+  int col_padding = 0;
+
+  for (int i = 0; (i + stride + ksize - 1) < input_rows; i += stride) {    // input rows
+    for (int j = 0; (j + stride + ksize - 1) < input_cols; j += stride) {  // input cols
+      int patchId = i + input_rows * j;
+      for (int r = 0; r < ksize; ++r) {                // patch rows
+        for (int c = 0; c < ksize; ++c) {              // patch cols
+          for (int d = 0; d < input_depth; ++d) {      // depth
+            for (int b = 0; b < input_batches; ++b) {  // batch
+              float expected = 0.0f;
+              float expected_row_major = 0.0f;
+              int row_offset = r + i - row_padding;
+              int col_offset = c + j - col_padding;
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
+                expected = tensor(d, row_offset, col_offset, b);
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              // ColMajor
+              if (result(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Verifies VALID padding (no padding) with the same value.
+void test_patch_padding_valid_same_value() {
+  int input_depth = 1;
+  int input_rows = 5;
+  int input_cols = 5;
+  int input_batches = 2;
+  int ksize = 3;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
+  int stride = 2;  // Only same stride is supported.
+  // ColMajor
+  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
+  tensor = tensor.constant(11.0f);
+  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+
+  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result.dimension(3), 4);              // number of patches
+  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
+
+  Tensor<float, 5, RowMajor> result_row_major =
+      tensor_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
+
+  // No padding is carried out.
+  int row_padding = 0;
+  int col_padding = 0;
+
+  for (int i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
+    for (int j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
+      int patchId = i + input_rows * j;
+      for (int r = 0; r < ksize; ++r) {                // patch rows
+        for (int c = 0; c < ksize; ++c) {              // patch cols
+          for (int d = 0; d < input_depth; ++d) {      // depth
+            for (int b = 0; b < input_batches; ++b) {  // batch
+              float expected = 0.0f;
+              float expected_row_major = 0.0f;
+              int row_offset = r + i - row_padding;
+              int col_offset = c + j - col_padding;
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
+                expected = tensor(d, row_offset, col_offset, b);
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              // ColMajor
+              if (result(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Verifies SAME padding.
+void test_patch_padding_same() {
+  int input_depth = 3;
+  int input_rows = 4;
+  int input_cols = 2;
+  int input_batches = 1;
+  int ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
+  int stride = 2;  // Only same stride is supported.
+  // ColMajor
+  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
+  // Initializes tensor with incrementing numbers.
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = i + 1;
+  }
+  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
+
+  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result.dimension(3), 2);              // number of patches
+  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
+
+  Tensor<float, 5, RowMajor> result_row_major =
+      tensor_row_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
+  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
+
+  // Based on the calculation described in TensorTraits.h, padding happens to be
+  // 0.
+  int row_padding = 0;
+  int col_padding = 0;
+
+  for (int i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
+    for (int j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
+      int patchId = i + input_rows * j;
+      for (int r = 0; r < ksize; ++r) {                // patch rows
+        for (int c = 0; c < ksize; ++c) {              // patch cols
+          for (int d = 0; d < input_depth; ++d) {      // depth
+            for (int b = 0; b < input_batches; ++b) {  // batch
+              float expected = 0.0f;
+              float expected_row_major = 0.0f;
+              int row_offset = r * stride + i - row_padding;
+              int col_offset = c * stride + j - col_padding;
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
+                expected = tensor(d, row_offset, col_offset, b);
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              // ColMajor
+              if (result(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Verifies that SAME padding, when computed as negative values, will be clipped
+// to zero.
+void test_patch_padding_same_negative_padding_clip_to_zero() {
+  int input_depth = 1;
+  int input_rows = 15;
+  int input_cols = 1;
+  int input_batches = 1;
+  int ksize = 1;  // Corresponds to the Rows and Cols for
+                  // tensor.extract_image_patches<>.
+  int row_stride = 5;
+  int col_stride = 1;
+  // ColMajor
+  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
+  // Initializes tensor with incrementing numbers.
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = i + 1;
+  }
+  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, row_stride, col_stride, 1, 1, PADDING_SAME);
+  // row padding will be computed as -2 originally and then be clipped to 0.
+  VERIFY_IS_EQUAL(result.coeff(0), 1.0f);
+  VERIFY_IS_EQUAL(result.coeff(1), 6.0f);
+  VERIFY_IS_EQUAL(result.coeff(2), 11.0f);
+
+  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result.dimension(3), 3);              // number of patches
+  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
+
+  Tensor<float, 5, RowMajor> result_row_major =
+      tensor_row_major.extract_image_patches(ksize, ksize, row_stride, col_stride, 1, 1, PADDING_SAME);
+  VERIFY_IS_EQUAL(result_row_major.coeff(0), 1.0f);
+  VERIFY_IS_EQUAL(result_row_major.coeff(1), 6.0f);
+  VERIFY_IS_EQUAL(result_row_major.coeff(2), 11.0f);
+
+  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
+}
+
+void test_patch_no_extra_dim() {
+  Tensor<float, 3> tensor(2, 3, 5);
+  tensor.setRandom();
+  Tensor<float, 3, RowMajor> tensor_row_major = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(0));
+
+  // Single pixel patch: ColMajor
+  Tensor<float, 4> single_pixel_patch;
+  single_pixel_patch = tensor.extract_image_patches(1, 1);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(0), 2);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch.dimension(3), 3 * 5);
+
+  // Single pixel patch: RowMajor
+  Tensor<float, 4, RowMajor> single_pixel_patch_row_major;
+  single_pixel_patch_row_major = tensor_row_major.extract_image_patches(1, 1);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(0), 3 * 5);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(3), 2);
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    // ColMajor
+    if (tensor.data()[i] != single_pixel_patch.data()[i]) {
+      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
+                << single_pixel_patch.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], tensor.data()[i]);
+    // RowMajor
+    if (tensor_row_major.data()[i] != single_pixel_patch_row_major.data()[i]) {
+      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
+                << single_pixel_patch_row_major.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_pixel_patch_row_major.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], single_pixel_patch_row_major.data()[i]);
+  }
+
+  // Entire image patch: ColMajor
+  Tensor<float, 4> entire_image_patch;
+  entire_image_patch = tensor.extract_image_patches(3, 5);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(0), 2);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(1), 3);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(2), 5);
+  VERIFY_IS_EQUAL(entire_image_patch.dimension(3), 3 * 5);
+
+  // Entire image patch: RowMajor
+  Tensor<float, 4, RowMajor> entire_image_patch_row_major;
+  entire_image_patch_row_major = tensor_row_major.extract_image_patches(3, 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 3 * 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 3);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 2);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      int patchId = i + 3 * j;
+      for (int r = 0; r < 3; ++r) {
+        for (int c = 0; c < 5; ++c) {
+          for (int d = 0; d < 2; ++d) {
+            float expected = 0.0f;
+            float expected_row_major = 0.0f;
+            if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
+              expected = tensor(d, r - 1 + i, c - 2 + j);
+              expected_row_major = tensor_row_major(c - 2 + j, r - 1 + i, d);
+            }
+            // ColMajor
+            if (entire_image_patch(d, r, c, patchId) != expected) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(entire_image_patch(d, r, c, patchId), expected);
+            // RowMajor
+            if (entire_image_patch_row_major(patchId, c, r, d) != expected_row_major) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(entire_image_patch_row_major(patchId, c, r, d), expected_row_major);
+            // Check that ColMajor and RowMajor agree.
+            VERIFY_IS_EQUAL(expected, expected_row_major);
+          }
+        }
+      }
+    }
+  }
+
+  // 2D patch: ColMajor
+  Tensor<float, 4> twod_patch;
+  twod_patch = tensor.extract_image_patches(2, 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(0), 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch.dimension(3), 3 * 5);
+
+  // 2D patch: RowMajor
+  Tensor<float, 4, RowMajor> twod_patch_row_major;
+  twod_patch_row_major = tensor_row_major.extract_image_patches(2, 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 3 * 5);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
+
+  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
+  int row_padding = 0;
+  int col_padding = 0;
+  int stride = 1;
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      int patchId = i + 3 * j;
+      for (int r = 0; r < 2; ++r) {
+        for (int c = 0; c < 2; ++c) {
+          for (int d = 0; d < 2; ++d) {
+            float expected = 0.0f;
+            float expected_row_major = 0.0f;
+            int row_offset = r * stride + i - row_padding;
+            int col_offset = c * stride + j - col_padding;
+            // ColMajor
+            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor.dimension(1) &&
+                col_offset < tensor.dimension(2)) {
+              expected = tensor(d, row_offset, col_offset);
+            }
+            if (twod_patch(d, r, c, patchId) != expected) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(twod_patch(d, r, c, patchId), expected);
+            // RowMajor
+            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(1) &&
+                col_offset < tensor_row_major.dimension(0)) {
+              expected_row_major = tensor_row_major(col_offset, row_offset, d);
+            }
+            if (twod_patch_row_major(patchId, c, r, d) != expected_row_major) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(twod_patch_row_major(patchId, c, r, d), expected_row_major);
+            // Check that ColMajor and RowMajor agree.
+            VERIFY_IS_EQUAL(expected, expected_row_major);
+          }
+        }
+      }
+    }
+  }
+}
+
+void test_imagenet_patches() {
+  // Test the code on typical configurations used by the 'imagenet' benchmarks at
+  // https://github.com/soumith/convnet-benchmarks
+  // ColMajor
+  Tensor<float, 4> l_in(3, 128, 128, 16);
+  l_in.setRandom();
+  Tensor<float, 5> l_out = l_in.extract_image_patches(11, 11);
+  VERIFY_IS_EQUAL(l_out.dimension(0), 3);
+  VERIFY_IS_EQUAL(l_out.dimension(1), 11);
+  VERIFY_IS_EQUAL(l_out.dimension(2), 11);
+  VERIFY_IS_EQUAL(l_out.dimension(3), 128 * 128);
+  VERIFY_IS_EQUAL(l_out.dimension(4), 16);
+
+  // RowMajor
+  Tensor<float, 5, RowMajor> l_out_row_major = l_in.swap_layout().extract_image_patches(11, 11);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 16);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 128 * 128);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 11);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 11);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 3);
+
+  for (int b = 0; b < 16; ++b) {
+    for (int i = 0; i < 128; ++i) {
+      for (int j = 0; j < 128; ++j) {
+        int patchId = i + 128 * j;
+        for (int c = 0; c < 11; ++c) {
+          for (int r = 0; r < 11; ++r) {
+            for (int d = 0; d < 3; ++d) {
+              float expected = 0.0f;
+              if (r - 5 + i >= 0 && c - 5 + j >= 0 && r - 5 + i < 128 && c - 5 + j < 128) {
+                expected = l_in(d, r - 5 + i, c - 5 + j, b);
+              }
+              // ColMajor
+              if (l_out(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ColMajor
+  l_in.resize(16, 64, 64, 32);
+  l_in.setRandom();
+  l_out = l_in.extract_image_patches(9, 9);
+  VERIFY_IS_EQUAL(l_out.dimension(0), 16);
+  VERIFY_IS_EQUAL(l_out.dimension(1), 9);
+  VERIFY_IS_EQUAL(l_out.dimension(2), 9);
+  VERIFY_IS_EQUAL(l_out.dimension(3), 64 * 64);
+  VERIFY_IS_EQUAL(l_out.dimension(4), 32);
+
+  // RowMajor
+  l_out_row_major = l_in.swap_layout().extract_image_patches(9, 9);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 64 * 64);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 9);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 9);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 16);
+
+  for (int b = 0; b < 32; ++b) {
+    for (int i = 0; i < 64; ++i) {
+      for (int j = 0; j < 64; ++j) {
+        int patchId = i + 64 * j;
+        for (int c = 0; c < 9; ++c) {
+          for (int r = 0; r < 9; ++r) {
+            for (int d = 0; d < 16; ++d) {
+              float expected = 0.0f;
+              if (r - 4 + i >= 0 && c - 4 + j >= 0 && r - 4 + i < 64 && c - 4 + j < 64) {
+                expected = l_in(d, r - 4 + i, c - 4 + j, b);
+              }
+              // ColMajor
+              if (l_out(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ColMajor
+  l_in.resize(32, 16, 16, 32);
+  l_in.setRandom();
+  l_out = l_in.extract_image_patches(7, 7);
+  VERIFY_IS_EQUAL(l_out.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out.dimension(1), 7);
+  VERIFY_IS_EQUAL(l_out.dimension(2), 7);
+  VERIFY_IS_EQUAL(l_out.dimension(3), 16 * 16);
+  VERIFY_IS_EQUAL(l_out.dimension(4), 32);
+
+  // RowMajor
+  l_out_row_major = l_in.swap_layout().extract_image_patches(7, 7);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 16 * 16);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 7);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 7);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 32);
+
+  for (int b = 0; b < 32; ++b) {
+    for (int i = 0; i < 16; ++i) {
+      for (int j = 0; j < 16; ++j) {
+        int patchId = i + 16 * j;
+        for (int c = 0; c < 7; ++c) {
+          for (int r = 0; r < 7; ++r) {
+            for (int d = 0; d < 32; ++d) {
+              float expected = 0.0f;
+              if (r - 3 + i >= 0 && c - 3 + j >= 0 && r - 3 + i < 16 && c - 3 + j < 16) {
+                expected = l_in(d, r - 3 + i, c - 3 + j, b);
+              }
+              // ColMajor
+              if (l_out(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ColMajor
+  l_in.resize(64, 13, 13, 32);
+  l_in.setRandom();
+  l_out = l_in.extract_image_patches(3, 3);
+  VERIFY_IS_EQUAL(l_out.dimension(0), 64);
+  VERIFY_IS_EQUAL(l_out.dimension(1), 3);
+  VERIFY_IS_EQUAL(l_out.dimension(2), 3);
+  VERIFY_IS_EQUAL(l_out.dimension(3), 13 * 13);
+  VERIFY_IS_EQUAL(l_out.dimension(4), 32);
+
+  // RowMajor
+  l_out_row_major = l_in.swap_layout().extract_image_patches(3, 3);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 13 * 13);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 3);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 3);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 64);
+
+  for (int b = 0; b < 32; ++b) {
+    for (int i = 0; i < 13; ++i) {
+      for (int j = 0; j < 13; ++j) {
+        int patchId = i + 13 * j;
+        for (int c = 0; c < 3; ++c) {
+          for (int r = 0; r < 3; ++r) {
+            for (int d = 0; d < 64; ++d) {
+              float expected = 0.0f;
+              if (r - 1 + i >= 0 && c - 1 + j >= 0 && r - 1 + i < 13 && c - 1 + j < 13) {
+                expected = l_in(d, r - 1 + i, c - 1 + j, b);
+              }
+              // ColMajor
+              if (l_out(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Tests inflate strides (row_inflate_strides, col_inflate_strides).
+// Inflate inserts zeros between input elements before patch extraction.
+void test_patch_inflate_strides() {
+  // ColMajor: 2 channels, 3 rows, 4 cols, 1 batch
+  const int depth = 2;
+  const int rows = 3;
+  const int cols = 4;
+  const int batch = 1;
+  Tensor<float, 4> tensor(depth, rows, cols, batch);
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = static_cast<float>(i + 1);
+  }
+
+  const int row_inflate = 2;
+  const int col_inflate = 3;
+  const int patch_rows = 3;
+  const int patch_cols = 4;
+
+  // Effective input size after inflation:
+  //   eff_rows = (3-1)*2 + 1 = 5
+  //   eff_cols = (4-1)*3 + 1 = 10
+  // With explicit padding=0, VALID-like extraction:
+  //   outputRows = ceil((5 + 0 + 0 - 3 + 1) / 1) = 3
+  //   outputCols = ceil((10 + 0 + 0 - 4 + 1) / 1) = 7
+  Tensor<float, 5> result =
+      tensor.extract_image_patches(patch_rows, patch_cols, 1, 1, 1, 1, row_inflate, col_inflate, 0, 0, 0, 0, 0.0f);
+  const int outputRows = 3;
+  const int outputCols = 7;
+  VERIFY_IS_EQUAL(result.dimension(0), depth);
+  VERIFY_IS_EQUAL(result.dimension(1), patch_rows);
+  VERIFY_IS_EQUAL(result.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result.dimension(3), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result.dimension(4), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              // Position in effective (inflated) input
+              int effRow = oi + pr;
+              int effCol = oj + pc;
+              float expected = 0.0f;
+              // Check if this maps to an actual input element
+              if (effRow % row_inflate == 0 && effCol % col_inflate == 0) {
+                int origRow = effRow / row_inflate;
+                int origCol = effCol / col_inflate;
+                if (origRow >= 0 && origRow < rows && origCol >= 0 && origCol < cols) {
+                  expected = tensor(d, origRow, origCol, b);
+                }
+              }
+              VERIFY_IS_EQUAL(result(d, pr, pc, patchId, b), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_rm = tensor.swap_layout();
+  Tensor<float, 5, RowMajor> result_rm =
+      tensor_rm.extract_image_patches(patch_rows, patch_cols, 1, 1, 1, 1, row_inflate, col_inflate, 0, 0, 0, 0, 0.0f);
+  VERIFY_IS_EQUAL(result_rm.dimension(4), depth);
+  VERIFY_IS_EQUAL(result_rm.dimension(3), patch_rows);
+  VERIFY_IS_EQUAL(result_rm.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result_rm.dimension(1), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result_rm.dimension(0), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              int effRow = oi + pr;
+              int effCol = oj + pc;
+              float expected = 0.0f;
+              if (effRow % row_inflate == 0 && effCol % col_inflate == 0) {
+                int origRow = effRow / row_inflate;
+                int origCol = effCol / col_inflate;
+                if (origRow >= 0 && origRow < rows && origCol >= 0 && origCol < cols) {
+                  expected = tensor_rm(b, origCol, origRow, d);
+                }
+              }
+              VERIFY_IS_EQUAL(result_rm(b, patchId, pc, pr, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Tests dilation (in_row_strides, in_col_strides).
+// Dilation samples every Nth element within each patch.
+void test_patch_dilation() {
+  const int depth = 3;
+  const int rows = 5;
+  const int cols = 5;
+  const int batch = 1;
+  Tensor<float, 4> tensor(depth, rows, cols, batch);
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = static_cast<float>(i + 1);
+  }
+
+  const int patch_rows = 2;
+  const int patch_cols = 2;
+  const int in_row_strides = 2;  // dilation
+  const int in_col_strides = 2;
+
+  // Effective patch size: patch + (patch-1)*(dilation-1)
+  //   eff_patch_rows = 2 + (2-1)*(2-1) = 3
+  //   eff_patch_cols = 2 + (2-1)*(2-1) = 3
+  // With PADDING_VALID:
+  //   outputRows = ceil((5 - 3 + 1) / 1) = 3
+  //   outputCols = ceil((5 - 3 + 1) / 1) = 3
+  Tensor<float, 5> result =
+      tensor.extract_image_patches(patch_rows, patch_cols, 1, 1, in_row_strides, in_col_strides, PADDING_VALID);
+  const int outputRows = 3;
+  const int outputCols = 3;
+  VERIFY_IS_EQUAL(result.dimension(0), depth);
+  VERIFY_IS_EQUAL(result.dimension(1), patch_rows);
+  VERIFY_IS_EQUAL(result.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result.dimension(3), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result.dimension(4), batch);
+
+  // row_padding and col_padding are 0 for VALID.
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              // Within-patch dilation: sample at stride in_row_strides
+              int inputRow = oi + pr * in_row_strides;
+              int inputCol = oj + pc * in_col_strides;
+              float expected = 0.0f;
+              if (inputRow >= 0 && inputRow < rows && inputCol >= 0 && inputCol < cols) {
+                expected = tensor(d, inputRow, inputCol, b);
+              }
+              VERIFY_IS_EQUAL(result(d, pr, pc, patchId, b), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_rm = tensor.swap_layout();
+  Tensor<float, 5, RowMajor> result_rm =
+      tensor_rm.extract_image_patches(patch_rows, patch_cols, 1, 1, in_row_strides, in_col_strides, PADDING_VALID);
+  VERIFY_IS_EQUAL(result_rm.dimension(4), depth);
+  VERIFY_IS_EQUAL(result_rm.dimension(3), patch_rows);
+  VERIFY_IS_EQUAL(result_rm.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result_rm.dimension(1), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result_rm.dimension(0), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              int inputRow = oi + pr * in_row_strides;
+              int inputCol = oj + pc * in_col_strides;
+              float expected = 0.0f;
+              if (inputRow >= 0 && inputRow < rows && inputCol >= 0 && inputCol < cols) {
+                expected = tensor_rm(b, inputCol, inputRow, d);
+              }
+              VERIFY_IS_EQUAL(result_rm(b, patchId, pc, pr, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Tests explicit padding with asymmetric top/bottom/left/right values.
+void test_patch_explicit_padding() {
+  const int depth = 3;
+  const int rows = 4;
+  const int cols = 4;
+  const int batch = 1;
+  Tensor<float, 4> tensor(depth, rows, cols, batch);
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = static_cast<float>(i + 1);
+  }
+
+  const int patch_rows = 3;
+  const int patch_cols = 3;
+  const int padding_top = 1;
+  const int padding_bottom = 2;
+  const int padding_left = 1;
+  const int padding_right = 2;
+
+  // outputRows = ceil((4 + 1 + 2 - 3 + 1) / 1) = 5
+  // outputCols = ceil((4 + 1 + 2 - 3 + 1) / 1) = 5
+  Tensor<float, 5> result = tensor.extract_image_patches(patch_rows, patch_cols, 1, 1, 1, 1, 1, 1, padding_top,
+                                                         padding_bottom, padding_left, padding_right, 0.0f);
+  const int outputRows = 5;
+  const int outputCols = 5;
+  VERIFY_IS_EQUAL(result.dimension(0), depth);
+  VERIFY_IS_EQUAL(result.dimension(1), patch_rows);
+  VERIFY_IS_EQUAL(result.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result.dimension(3), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result.dimension(4), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              int inputRow = oi + pr - padding_top;
+              int inputCol = oj + pc - padding_left;
+              float expected = 0.0f;
+              if (inputRow >= 0 && inputRow < rows && inputCol >= 0 && inputCol < cols) {
+                expected = tensor(d, inputRow, inputCol, b);
+              }
+              VERIFY_IS_EQUAL(result(d, pr, pc, patchId, b), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_rm = tensor.swap_layout();
+  Tensor<float, 5, RowMajor> result_rm = tensor_rm.extract_image_patches(
+      patch_rows, patch_cols, 1, 1, 1, 1, 1, 1, padding_top, padding_bottom, padding_left, padding_right, 0.0f);
+  VERIFY_IS_EQUAL(result_rm.dimension(4), depth);
+  VERIFY_IS_EQUAL(result_rm.dimension(3), patch_rows);
+  VERIFY_IS_EQUAL(result_rm.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result_rm.dimension(1), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result_rm.dimension(0), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              int inputRow = oi + pr - padding_top;
+              int inputCol = oj + pc - padding_left;
+              float expected = 0.0f;
+              if (inputRow >= 0 && inputRow < rows && inputCol >= 0 && inputCol < cols) {
+                expected = tensor_rm(b, inputCol, inputRow, d);
+              }
+              VERIFY_IS_EQUAL(result_rm(b, patchId, pc, pr, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Tests rectangular input with non-square patches and different row/col strides.
+void test_patch_asymmetric() {
+  const int depth = 3;
+  const int rows = 3;
+  const int cols = 7;
+  const int batch = 1;
+  Tensor<float, 4> tensor(depth, rows, cols, batch);
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = static_cast<float>(i + 1);
+  }
+
+  const int patch_rows = 2;
+  const int patch_cols = 3;
+  const int row_stride = 1;
+  const int col_stride = 2;
+
+  // PADDING_VALID:
+  //   outputRows = ceil((3 - 2 + 1) / 1) = 2
+  //   outputCols = ceil((7 - 3 + 1) / 2) = 3
+  Tensor<float, 5> result =
+      tensor.extract_image_patches(patch_rows, patch_cols, row_stride, col_stride, 1, 1, PADDING_VALID);
+  const int outputRows = 2;
+  const int outputCols = 3;
+  VERIFY_IS_EQUAL(result.dimension(0), depth);
+  VERIFY_IS_EQUAL(result.dimension(1), patch_rows);
+  VERIFY_IS_EQUAL(result.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result.dimension(3), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result.dimension(4), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              int inputRow = oi * row_stride + pr;
+              int inputCol = oj * col_stride + pc;
+              float expected = 0.0f;
+              if (inputRow >= 0 && inputRow < rows && inputCol >= 0 && inputCol < cols) {
+                expected = tensor(d, inputRow, inputCol, b);
+              }
+              VERIFY_IS_EQUAL(result(d, pr, pc, patchId, b), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // RowMajor
+  Tensor<float, 4, RowMajor> tensor_rm = tensor.swap_layout();
+  Tensor<float, 5, RowMajor> result_rm =
+      tensor_rm.extract_image_patches(patch_rows, patch_cols, row_stride, col_stride, 1, 1, PADDING_VALID);
+  VERIFY_IS_EQUAL(result_rm.dimension(4), depth);
+  VERIFY_IS_EQUAL(result_rm.dimension(3), patch_rows);
+  VERIFY_IS_EQUAL(result_rm.dimension(2), patch_cols);
+  VERIFY_IS_EQUAL(result_rm.dimension(1), outputRows * outputCols);
+  VERIFY_IS_EQUAL(result_rm.dimension(0), batch);
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            for (int d = 0; d < depth; ++d) {
+              int inputRow = oi * row_stride + pr;
+              int inputCol = oj * col_stride + pc;
+              float expected = 0.0f;
+              if (inputRow >= 0 && inputRow < rows && inputCol >= 0 && inputCol < cols) {
+                expected = tensor_rm(b, inputCol, inputRow, d);
+              }
+              VERIFY_IS_EQUAL(result_rm(b, patchId, pc, pr, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Exercises packet loads that span multiple rows/columns within the patch.
+void test_patch_contiguous_packet_span() {
+  const int depth = 1;
+  const int rows = 5;
+  const int cols = 5;
+  const int batch = 1;
+  Tensor<float, 4> tensor(depth, rows, cols, batch);
+  for (int i = 0; i < tensor.size(); ++i) {
+    tensor.data()[i] = static_cast<float>(i + 1);
+  }
+
+  const int patch_rows = 3;
+  const int patch_cols = 3;
+  Tensor<float, 5> result = tensor.extract_image_patches(patch_rows, patch_cols, 1, 1, 1, 1, PADDING_VALID);
+  const int outputRows = 3;
+  const int outputCols = 3;
+
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        const int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            const int inputRow = oi + pr;
+            const int inputCol = oj + pc;
+            VERIFY_IS_EQUAL(result(0, pr, pc, patchId, b), tensor(0, inputRow, inputCol, b));
+          }
+        }
+      }
+    }
+  }
+
+  Tensor<float, 4, RowMajor> tensor_rm = tensor.swap_layout();
+  Tensor<float, 5, RowMajor> result_rm =
+      tensor_rm.extract_image_patches(patch_rows, patch_cols, 1, 1, 1, 1, PADDING_VALID);
+  for (int b = 0; b < batch; ++b) {
+    for (int oi = 0; oi < outputRows; ++oi) {
+      for (int oj = 0; oj < outputCols; ++oj) {
+        const int patchId = oi + outputRows * oj;
+        for (int pr = 0; pr < patch_rows; ++pr) {
+          for (int pc = 0; pc < patch_cols; ++pc) {
+            const int inputRow = oi + pr;
+            const int inputCol = oj + pc;
+            VERIFY_IS_EQUAL(result_rm(b, patchId, pc, pr, 0), tensor_rm(b, inputCol, inputRow, 0));
+          }
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_image_patch) {
+  CALL_SUBTEST_1(test_simple_patch());
+  CALL_SUBTEST_2(test_patch_no_extra_dim());
+  CALL_SUBTEST_3(test_patch_padding_valid());
+  CALL_SUBTEST_4(test_patch_padding_valid_same_value());
+  CALL_SUBTEST_5(test_patch_padding_same());
+  CALL_SUBTEST_6(test_imagenet_patches());
+  CALL_SUBTEST_7(test_patch_padding_same_negative_padding_clip_to_zero());
+  CALL_SUBTEST_8(test_patch_inflate_strides());
+  CALL_SUBTEST_9(test_patch_dilation());
+  CALL_SUBTEST_10(test_patch_explicit_padding());
+  CALL_SUBTEST_11(test_patch_asymmetric());
+  CALL_SUBTEST_12(test_patch_contiguous_packet_span());
+}
diff --git a/contrib/test/tensor_image_patch_sycl.cpp b/contrib/test/tensor_image_patch_sycl.cpp
new file mode 100644
index 0000000..de540c5
--- /dev/null
+++ b/contrib/test/tensor_image_patch_sycl.cpp
@@ -0,0 +1,1156 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+static const int DataLayout = ColMajor;
+
+template <typename DataType, typename IndexType>
+static void test_simple_image_patch_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 4> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  array<IndexType, 4> tensorRowMajorRange = {{sizeDim4, sizeDim3, sizeDim2, sizeDim1}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+  tensor_col_major.setRandom();
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_col_major.size()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
+
+  // Single pixel patch: ColMajor
+  array<IndexType, 5> patchColMajorTensorRange = {{sizeDim1, 1, 1, sizeDim2 * sizeDim3, sizeDim4}};
+  Tensor<DataType, 5, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
+                                                                                   patchColMajorTensorRange);
+  gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
+  sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), 2);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), 3 * 5);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(4), 7);
+
+  // Single pixel patch: RowMajor
+  array<IndexType, 5> patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 1, 1, sizeDim1}};
+  Tensor<DataType, 5, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
+                                                                                 patchRowMajorTensorRange);
+  gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
+  sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 3 * 5);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), 1);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(4), 2);
+
+  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
+    // ColMajor
+    if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
+      std::cout << "Mismatch detected at index colmajor " << i << " : " << tensor_col_major.data()[i] << " vs "
+                << single_patch_col_major.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
+    // RowMajor
+    if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
+      std::cout << "Mismatch detected at index row major" << i << " : " << tensor_row_major.data()[i] << " vs "
+                << single_patch_row_major.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
+  }
+
+  // Entire image patch: ColMajor
+  patchColMajorTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3, sizeDim4}};
+  Tensor<DataType, 5, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
+  patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
+      gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
+  gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
+  sycl_device.memcpyDeviceToHost(entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major,
+                                 patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(4), 7);
+
+  // Entire image patch: RowMajor
+  patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1}};
+  Tensor<DataType, 5, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
+      gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
+  gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
+  sycl_device.memcpyDeviceToHost(entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major,
+                                 patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 3 * 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 3);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(4), 2);
+
+  for (IndexType i = 0; i < 3; ++i) {
+    for (IndexType j = 0; j < 5; ++j) {
+      IndexType patchId = i + 3 * j;
+      for (IndexType r = 0; r < 3; ++r) {
+        for (IndexType c = 0; c < 5; ++c) {
+          for (IndexType d = 0; d < 2; ++d) {
+            for (IndexType b = 0; b < 7; ++b) {
+              DataType expected_col_major = 0.0f;
+              DataType expected_row_major = 0.0f;
+              if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
+                expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j, b);
+                expected_row_major = tensor_row_major(b, c - 2 + j, r - 1 + i, d);
+              }
+              // ColMajor
+              if (entire_image_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId, b), expected_col_major);
+              // RowMajor
+              if (entire_image_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(entire_image_patch_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 2D patch: ColMajor
+  patchColMajorTensorRange = {{sizeDim1, 2, 2, sizeDim2 * sizeDim3, sizeDim4}};
+  Tensor<DataType, 5, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
+  patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
+                                                                                 patchColMajorTensorRange);
+  gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
+  sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(4), 7);
+
+  // 2D patch: RowMajor
+  patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 2, 2, sizeDim1}};
+  Tensor<DataType, 5, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
+                                                                               patchRowMajorTensorRange);
+  gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
+  sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 3 * 5);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(4), 2);
+
+  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
+  IndexType row_padding = 0;
+  IndexType col_padding = 0;
+  IndexType stride = 1;
+
+  for (IndexType i = 0; i < 3; ++i) {
+    for (IndexType j = 0; j < 5; ++j) {
+      IndexType patchId = i + 3 * j;
+      for (IndexType r = 0; r < 2; ++r) {
+        for (IndexType c = 0; c < 2; ++c) {
+          for (IndexType d = 0; d < 2; ++d) {
+            for (IndexType b = 0; b < 7; ++b) {
+              DataType expected_col_major = 0.0f;
+              DataType expected_row_major = 0.0f;
+              IndexType row_offset = r * stride + i - row_padding;
+              IndexType col_offset = c * stride + j - col_padding;
+              // ColMajor
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
+                  col_offset < tensor_col_major.dimension(2)) {
+                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
+              }
+              if (twod_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId, b), expected_col_major);
+
+              // RowMajor
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(2) &&
+                  col_offset < tensor_row_major.dimension(1)) {
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              if (twod_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(twod_patch_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  sycl_device.deallocate(gpu_data_col_major);
+  sycl_device.deallocate(gpu_data_row_major);
+  sycl_device.deallocate(gpu_data_single_patch_col_major);
+  sycl_device.deallocate(gpu_data_single_patch_row_major);
+  sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
+  sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
+  sycl_device.deallocate(gpu_data_twod_patch_col_major);
+  sycl_device.deallocate(gpu_data_twod_patch_row_major);
+}
+
+// Verifies VALID padding (no padding) with incrementing values.
+template <typename DataType, typename IndexType>
+static void test_patch_padding_valid_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType input_depth = 3;
+  IndexType input_rows = 3;
+  IndexType input_cols = 3;
+  IndexType input_batches = 1;
+  IndexType ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
+  IndexType stride = 2;  // Only same stride is supported.
+
+  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
+  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_col_major.size()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
+
+  // Initializes tensor with incrementing numbers.
+  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
+    tensor_col_major.data()[i] = i + 1;
+  }
+  // ColMajor
+  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 1, input_batches}};
+  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
+                                                                             patchColMajorTensorRange);
+  gpu_result_col_major.device(sycl_device) =
+      gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result_col_major.dimension(3), 1);              // number of patches
+  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 1, ksize, ksize, input_depth}};
+  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
+                                                                           patchRowMajorTensorRange);
+  gpu_result_row_major.device(sycl_device) =
+      gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
+
+  // No padding is carried out.
+  IndexType row_padding = 0;
+  IndexType col_padding = 0;
+
+  for (IndexType i = 0; (i + stride + ksize - 1) < input_rows; i += stride) {    // input rows
+    for (IndexType j = 0; (j + stride + ksize - 1) < input_cols; j += stride) {  // input cols
+      IndexType patchId = i + input_rows * j;
+      for (IndexType r = 0; r < ksize; ++r) {                // patch rows
+        for (IndexType c = 0; c < ksize; ++c) {              // patch cols
+          for (IndexType d = 0; d < input_depth; ++d) {      // depth
+            for (IndexType b = 0; b < input_batches; ++b) {  // batch
+              DataType expected_col_major = 0.0f;
+              DataType expected_row_major = 0.0f;
+              IndexType row_offset = r + i - row_padding;
+              IndexType col_offset = c + j - col_padding;
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
+                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              // ColMajor
+              if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
+              // RowMajor
+              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_col_major);
+  sycl_device.deallocate(gpu_data_row_major);
+  sycl_device.deallocate(gpu_data_result_col_major);
+  sycl_device.deallocate(gpu_data_result_row_major);
+}
+
+// Verifies VALID padding (no padding) with the same value.
+template <typename DataType, typename IndexType>
+static void test_patch_padding_valid_same_value_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType input_depth = 1;
+  IndexType input_rows = 5;
+  IndexType input_cols = 5;
+  IndexType input_batches = 2;
+  IndexType ksize = 3;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
+  IndexType stride = 2;  // Only same stride is supported.
+  // ColMajor
+
+  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
+  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+  gpu_col_major.device(sycl_device) = gpu_col_major.constant(11.0f);
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor_col_major.data(), gpu_data_col_major,
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_row_major.size()) * sizeof(DataType));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
+
+  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 4, input_batches}};
+  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
+                                                                             patchColMajorTensorRange);
+  gpu_result_col_major.device(sycl_device) =
+      gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result_col_major.dimension(3), 4);              // number of patches
+  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 4, ksize, ksize, input_depth}};
+  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
+                                                                           patchRowMajorTensorRange);
+  gpu_result_row_major.device(sycl_device) =
+      gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
+  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
+
+  // No padding is carried out.
+  IndexType row_padding = 0;
+  IndexType col_padding = 0;
+
+  for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
+    for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
+      IndexType patchId = i + input_rows * j;
+      for (IndexType r = 0; r < ksize; ++r) {                // patch rows
+        for (IndexType c = 0; c < ksize; ++c) {              // patch cols
+          for (IndexType d = 0; d < input_depth; ++d) {      // depth
+            for (IndexType b = 0; b < input_batches; ++b) {  // batch
+              DataType expected_col_major = 0.0f;
+              DataType expected_row_major = 0.0f;
+              IndexType row_offset = r + i - row_padding;
+              IndexType col_offset = c + j - col_padding;
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
+                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              // ColMajor
+              if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
+              // RowMajor
+              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Verifies SAME padding.
+template <typename DataType, typename IndexType>
+static void test_patch_padding_same_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType input_depth = 3;
+  IndexType input_rows = 4;
+  IndexType input_cols = 2;
+  IndexType input_batches = 1;
+  IndexType ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
+  IndexType stride = 2;  // Only same stride is supported.
+
+  // ColMajor
+  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
+  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_col_major.size()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
+
+  // Initializes tensor with incrementing numbers.
+  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
+    tensor_col_major.data()[i] = i + 1;
+  }
+
+  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 2, input_batches}};
+  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
+                                                                             patchColMajorTensorRange);
+  gpu_result_col_major.device(sycl_device) =
+      gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
+  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);    // depth
+  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);          // kernel rows
+  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);          // kernel cols
+  VERIFY_IS_EQUAL(result_col_major.dimension(3), 2);              // number of patches
+  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches);  // number of batches
+
+  // RowMajor
+
+  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 2, ksize, ksize, input_depth}};
+  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
+                                                                           patchRowMajorTensorRange);
+  gpu_result_row_major.device(sycl_device) =
+      gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
+  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
+  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
+  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
+  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
+  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
+
+  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
+  IndexType row_padding = 0;
+  IndexType col_padding = 0;
+
+  for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
+    for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
+      IndexType patchId = i + input_rows * j;
+      for (IndexType r = 0; r < ksize; ++r) {                // patch rows
+        for (IndexType c = 0; c < ksize; ++c) {              // patch cols
+          for (IndexType d = 0; d < input_depth; ++d) {      // depth
+            for (IndexType b = 0; b < input_batches; ++b) {  // batch
+              DataType expected_col_major = 0.0f;
+              DataType expected_row_major = 0.0f;
+              IndexType row_offset = r * stride + i - row_padding;
+              IndexType col_offset = c * stride + j - col_padding;
+              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
+                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
+                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
+              }
+              // ColMajor
+              if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
+              // RowMajor
+              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
+              // Check that ColMajor and RowMajor agree.
+              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename DataType, typename IndexType>
+static void test_patch_no_extra_dim_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+
+  // ColMajor
+  array<IndexType, 3> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  array<IndexType, 3> tensorRowMajorRange = {{sizeDim3, sizeDim2, sizeDim1}};
+  Tensor<DataType, 3, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  tensor_col_major.setRandom();
+  Tensor<DataType, 3, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_row_major.size()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(2));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(1));
+  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(0));
+
+  // Single pixel patch: ColMajor
+  array<IndexType, 4> patchColMajorTensorRange = {{sizeDim1, 1, 1, sizeDim2 * sizeDim3}};
+  Tensor<DataType, 4, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
+                                                                                   patchColMajorTensorRange);
+  gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
+  sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), sizeDim2 * sizeDim3);
+
+  // Single pixel patch: RowMajor
+  array<IndexType, 4> patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, 1, 1, sizeDim1}};
+  Tensor<DataType, 4, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
+                                                                                 patchRowMajorTensorRange);
+  gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
+  sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), sizeDim2 * sizeDim3);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), sizeDim1);
+
+  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
+    // ColMajor
+    if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
+      std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
+                << single_patch_col_major.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
+    // RowMajor
+    if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
+      std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
+                << single_patch_row_major.data()[i] << std::endl;
+    }
+    VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
+    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
+  }
+
+  // Entire image patch: ColMajor
+  patchColMajorTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3}};
+  Tensor<DataType, 4, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
+  patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
+      gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
+  gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
+  sycl_device.memcpyDeviceToHost(entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major,
+                                 patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
+  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
+
+  // Entire image patch: RowMajor
+  patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1}};
+  Tensor<DataType, 4, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
+      gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
+  gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
+  sycl_device.memcpyDeviceToHost(entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major,
+                                 patchTensorBuffSize);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 3 * 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 5);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 3);
+  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 2);
+
+  for (IndexType i = 0; i < 3; ++i) {
+    for (IndexType j = 0; j < 5; ++j) {
+      IndexType patchId = i + 3 * j;
+      for (IndexType r = 0; r < 3; ++r) {
+        for (IndexType c = 0; c < 5; ++c) {
+          for (IndexType d = 0; d < 2; ++d) {
+            DataType expected_col_major = 0.0f;
+            DataType expected_row_major = 0.0f;
+            if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
+              expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j);
+              expected_row_major = tensor_row_major(c - 2 + j, r - 1 + i, d);
+            }
+            // ColMajor
+            if (entire_image_patch_col_major(d, r, c, patchId) != expected_col_major) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId), expected_col_major);
+            // RowMajor
+            if (entire_image_patch_row_major(patchId, c, r, d) != expected_row_major) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(entire_image_patch_row_major(patchId, c, r, d), expected_row_major);
+            // Check that ColMajor and RowMajor agree.
+            VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+          }
+        }
+      }
+    }
+  }
+
+  // 2D patch: ColMajor
+  patchColMajorTensorRange = {{sizeDim1, 2, 2, sizeDim2 * sizeDim3}};
+  Tensor<DataType, 4, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
+  patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
+                                                                                 patchColMajorTensorRange);
+  gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
+  sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
+
+  // 2D patch: RowMajor
+  patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, 2, 2, sizeDim1}};
+  Tensor<DataType, 4, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
+                                                                               patchRowMajorTensorRange);
+  gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
+  sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 3 * 5);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
+  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
+
+  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
+  IndexType row_padding = 0;
+  IndexType col_padding = 0;
+  IndexType stride = 1;
+
+  for (IndexType i = 0; i < 3; ++i) {
+    for (IndexType j = 0; j < 5; ++j) {
+      IndexType patchId = i + 3 * j;
+      for (IndexType r = 0; r < 2; ++r) {
+        for (IndexType c = 0; c < 2; ++c) {
+          for (IndexType d = 0; d < 2; ++d) {
+            DataType expected_col_major = 0.0f;
+            DataType expected_row_major = 0.0f;
+            IndexType row_offset = r * stride + i - row_padding;
+            IndexType col_offset = c * stride + j - col_padding;
+            // ColMajor
+            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
+                col_offset < tensor_col_major.dimension(2)) {
+              expected_col_major = tensor_col_major(d, row_offset, col_offset);
+            }
+            if (twod_patch_col_major(d, r, c, patchId) != expected_col_major) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId), expected_col_major);
+            // RowMajor
+            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(1) &&
+                col_offset < tensor_row_major.dimension(0)) {
+              expected_row_major = tensor_row_major(col_offset, row_offset, d);
+            }
+            if (twod_patch_row_major(patchId, c, r, d) != expected_row_major) {
+              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
+                        << std::endl;
+            }
+            VERIFY_IS_EQUAL(twod_patch_row_major(patchId, c, r, d), expected_row_major);
+            // Check that ColMajor and RowMajor agree.
+            VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
+          }
+        }
+      }
+    }
+  }
+
+  sycl_device.deallocate(gpu_data_col_major);
+  sycl_device.deallocate(gpu_data_row_major);
+  sycl_device.deallocate(gpu_data_single_patch_col_major);
+  sycl_device.deallocate(gpu_data_single_patch_row_major);
+  sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
+  sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
+  sycl_device.deallocate(gpu_data_twod_patch_col_major);
+  sycl_device.deallocate(gpu_data_twod_patch_row_major);
+}
+
+template <typename DataType, typename IndexType>
+static void test_imagenet_patches_sycl(const Eigen::SyclDevice& sycl_device) {
+  // Test the code on typical configurations used by the 'imagenet' benchmarks at
+  // https://github.com/soumith/convnet-benchmarks
+  // ColMajor
+  IndexType sizeDim1 = 3;
+  IndexType sizeDim2 = 128;
+  IndexType sizeDim3 = 128;
+  IndexType sizeDim4 = 16;
+  array<IndexType, 4> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> l_in_col_major(tensorColMajorRange);
+  l_in_col_major.setRandom();
+
+  DataType* gpu_data_l_in_col_major =
+      static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major(gpu_data_l_in_col_major, tensorColMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
+                                 (l_in_col_major.size()) * sizeof(DataType));
+
+  array<IndexType, 5> patchTensorRange = {{sizeDim1, 11, 11, sizeDim2 * sizeDim3, sizeDim4}};
+  Tensor<DataType, 5, DataLayout, IndexType> l_out_col_major(patchTensorRange);
+  size_t patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major(gpu_data_l_out_col_major, patchTensorRange);
+  gpu_l_out_col_major.device(sycl_device) = gpu_l_in_col_major.extract_image_patches(11, 11);
+  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 11);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 11);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), sizeDim2 * sizeDim3);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), sizeDim4);
+
+  // RowMajor
+  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 11, 11, sizeDim1}};
+  Tensor<DataType, 5, RowMajor, IndexType> l_out_row_major(patchTensorRange);
+  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major(gpu_data_l_out_row_major, patchTensorRange);
+  gpu_l_out_row_major.device(sycl_device) = gpu_l_in_col_major.swap_layout().extract_image_patches(11, 11);
+  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), sizeDim4);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), sizeDim2 * sizeDim3);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 11);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 11);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), sizeDim1);
+
+  for (IndexType b = 0; b < 16; ++b) {
+    for (IndexType i = 0; i < 128; ++i) {
+      for (IndexType j = 0; j < 128; ++j) {
+        IndexType patchId = i + 128 * j;
+        for (IndexType c = 0; c < 11; ++c) {
+          for (IndexType r = 0; r < 11; ++r) {
+            for (IndexType d = 0; d < 3; ++d) {
+              DataType expected = 0.0f;
+              if (r - 5 + i >= 0 && c - 5 + j >= 0 && r - 5 + i < 128 && c - 5 + j < 128) {
+                expected = l_in_col_major(d, r - 5 + i, c - 5 + j, b);
+              }
+              // ColMajor
+              if (l_out_col_major(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ColMajor
+  sycl_device.deallocate(gpu_data_l_in_col_major);
+  sycl_device.deallocate(gpu_data_l_out_col_major);
+  sizeDim1 = 16;
+  sizeDim2 = 64;
+  sizeDim3 = 64;
+  sizeDim4 = 32;
+  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  l_in_col_major.resize(tensorColMajorRange);
+  l_in_col_major.setRandom();
+  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize1(gpu_data_l_in_col_major,
+                                                                                 tensorColMajorRange);
+
+  patchTensorRange = {{sizeDim1, 9, 9, sizeDim2 * sizeDim3, sizeDim4}};
+  l_out_col_major.resize(patchTensorRange);
+  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
+  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize1(gpu_data_l_out_col_major,
+                                                                                    patchTensorRange);
+  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
+                                 (l_in_col_major.size()) * sizeof(DataType));
+  gpu_l_out_col_major_resize1.device(sycl_device) = gpu_l_in_col_major_resize1.extract_image_patches(9, 9);
+  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 16);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 9);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 9);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 64 * 64);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
+
+  // RowMajor
+  sycl_device.deallocate(gpu_data_l_out_row_major);
+  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 9, 9, sizeDim1}};
+  l_out_row_major.resize(patchTensorRange);
+  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
+  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize1(gpu_data_l_out_row_major,
+                                                                                  patchTensorRange);
+  gpu_l_out_row_major_resize1.device(sycl_device) =
+      gpu_l_in_col_major_resize1.swap_layout().extract_image_patches(9, 9);
+  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 64 * 64);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 9);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 9);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 16);
+
+  for (IndexType b = 0; b < 32; ++b) {
+    for (IndexType i = 0; i < 64; ++i) {
+      for (IndexType j = 0; j < 64; ++j) {
+        IndexType patchId = i + 64 * j;
+        for (IndexType c = 0; c < 9; ++c) {
+          for (IndexType r = 0; r < 9; ++r) {
+            for (IndexType d = 0; d < 16; ++d) {
+              DataType expected = 0.0f;
+              if (r - 4 + i >= 0 && c - 4 + j >= 0 && r - 4 + i < 64 && c - 4 + j < 64) {
+                expected = l_in_col_major(d, r - 4 + i, c - 4 + j, b);
+              }
+              // ColMajor
+              if (l_out_col_major(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ColMajor
+
+  sycl_device.deallocate(gpu_data_l_in_col_major);
+  sycl_device.deallocate(gpu_data_l_out_col_major);
+  sizeDim1 = 32;
+  sizeDim2 = 16;
+  sizeDim3 = 16;
+  sizeDim4 = 32;
+  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  l_in_col_major.resize(tensorColMajorRange);
+  l_in_col_major.setRandom();
+  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize2(gpu_data_l_in_col_major,
+                                                                                 tensorColMajorRange);
+
+  patchTensorRange = {{sizeDim1, 7, 7, sizeDim2 * sizeDim3, sizeDim4}};
+  l_out_col_major.resize(patchTensorRange);
+  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
+  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize2(gpu_data_l_out_col_major,
+                                                                                    patchTensorRange);
+  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
+                                 (l_in_col_major.size()) * sizeof(DataType));
+  gpu_l_out_col_major_resize2.device(sycl_device) = gpu_l_in_col_major_resize2.extract_image_patches(7, 7);
+  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 7);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 7);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 16 * 16);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
+
+  // RowMajor
+  sycl_device.deallocate(gpu_data_l_out_row_major);
+  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 7, 7, sizeDim1}};
+  l_out_row_major.resize(patchTensorRange);
+  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
+  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize2(gpu_data_l_out_row_major,
+                                                                                  patchTensorRange);
+  gpu_l_out_row_major_resize2.device(sycl_device) =
+      gpu_l_in_col_major_resize2.swap_layout().extract_image_patches(7, 7);
+  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 16 * 16);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 7);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 7);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 32);
+
+  for (IndexType b = 0; b < 32; ++b) {
+    for (IndexType i = 0; i < 16; ++i) {
+      for (IndexType j = 0; j < 16; ++j) {
+        IndexType patchId = i + 16 * j;
+        for (IndexType c = 0; c < 7; ++c) {
+          for (IndexType r = 0; r < 7; ++r) {
+            for (IndexType d = 0; d < 32; ++d) {
+              DataType expected = 0.0f;
+              if (r - 3 + i >= 0 && c - 3 + j >= 0 && r - 3 + i < 16 && c - 3 + j < 16) {
+                expected = l_in_col_major(d, r - 3 + i, c - 3 + j, b);
+              }
+              // ColMajor
+              if (l_out_col_major(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // ColMajor
+  sycl_device.deallocate(gpu_data_l_in_col_major);
+  sycl_device.deallocate(gpu_data_l_out_col_major);
+  sizeDim1 = 64;
+  sizeDim2 = 13;
+  sizeDim3 = 13;
+  sizeDim4 = 32;
+  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  l_in_col_major.resize(tensorColMajorRange);
+  l_in_col_major.setRandom();
+  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize3(gpu_data_l_in_col_major,
+                                                                                 tensorColMajorRange);
+
+  patchTensorRange = {{sizeDim1, 3, 3, sizeDim2 * sizeDim3, sizeDim4}};
+  l_out_col_major.resize(patchTensorRange);
+  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
+  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize3(gpu_data_l_out_col_major,
+                                                                                    patchTensorRange);
+  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
+                                 (l_in_col_major.size()) * sizeof(DataType));
+  gpu_l_out_col_major_resize3.device(sycl_device) = gpu_l_in_col_major_resize3.extract_image_patches(3, 3);
+  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 64);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 3);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 3);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 13 * 13);
+  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
+
+  // RowMajor
+  sycl_device.deallocate(gpu_data_l_out_row_major);
+  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 3, 3, sizeDim1}};
+  l_out_row_major.resize(patchTensorRange);
+  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
+  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize3(gpu_data_l_out_row_major,
+                                                                                  patchTensorRange);
+  gpu_l_out_row_major_resize3.device(sycl_device) =
+      gpu_l_in_col_major_resize3.swap_layout().extract_image_patches(3, 3);
+  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 13 * 13);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 3);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 3);
+  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 64);
+
+  for (IndexType b = 0; b < 32; ++b) {
+    for (IndexType i = 0; i < 13; ++i) {
+      for (IndexType j = 0; j < 13; ++j) {
+        IndexType patchId = i + 13 * j;
+        for (IndexType c = 0; c < 3; ++c) {
+          for (IndexType r = 0; r < 3; ++r) {
+            for (IndexType d = 0; d < 64; ++d) {
+              DataType expected = 0.0f;
+              if (r - 1 + i >= 0 && c - 1 + j >= 0 && r - 1 + i < 13 && c - 1 + j < 13) {
+                expected = l_in_col_major(d, r - 1 + i, c - 1 + j, b);
+              }
+              // ColMajor
+              if (l_out_col_major(d, r, c, patchId, b) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
+              // RowMajor
+              if (l_out_row_major(b, patchId, c, r, d) != expected) {
+                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
+                          << " d=" << d << " b=" << b << std::endl;
+              }
+              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
+            }
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_l_in_col_major);
+  sycl_device.deallocate(gpu_data_l_out_col_major);
+  sycl_device.deallocate(gpu_data_l_out_row_major);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_tensor_image_patch_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_image_patch_sycl<DataType, int64_t>(sycl_device);
+  test_patch_padding_valid_sycl<DataType, int64_t>(sycl_device);
+  test_patch_padding_valid_same_value_sycl<DataType, int64_t>(sycl_device);
+  test_patch_padding_same_sycl<DataType, int64_t>(sycl_device);
+  test_patch_no_extra_dim_sycl<DataType, int64_t>(sycl_device);
+  test_imagenet_patches_sycl<DataType, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_image_patch_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_tensor_image_patch_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_index_list.cpp b/contrib/test/tensor_index_list.cpp
new file mode 100644
index 0000000..c5adf3f
--- /dev/null
+++ b/contrib/test/tensor_index_list.cpp
@@ -0,0 +1,460 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+static void test_static_index_list() {
+  Tensor<float, 4> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  constexpr auto reduction_axis = make_index_list(0, 1, 2);
+  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 0);
+  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
+  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 2);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 0);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 2);
+
+  VERIFY_IS_EQUAL(reduction_axis.size(), std::size_t(3));
+
+  EIGEN_STATIC_ASSERT((internal::array_get<0>(reduction_axis) == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::array_get<1>(reduction_axis) == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::array_get<2>(reduction_axis) == 2), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  Tensor<float, 1> result = tensor.sum(reduction_axis);
+  for (int i = 0; i < result.size(); ++i) {
+    float expected = 0.0f;
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 5; ++l) {
+          expected += tensor(j, k, l, i);
+        }
+      }
+    }
+    VERIFY_IS_APPROX(result(i), expected);
+  }
+}
+
+static void test_type2index_list() {
+  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+  tensor += tensor.constant(10.0f);
+
+  typedef Eigen::IndexList<Eigen::type2index<0>> Dims0;
+  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>> Dims1;
+  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>> Dims2;
+  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>, Eigen::type2index<3>>
+      Dims3;
+  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>, Eigen::type2index<3>,
+                           Eigen::type2index<4>>
+      Dims4;
+
+#if 0
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims0>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims1>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims2>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims3>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims4>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+#endif
+
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims0, 1, ColMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims1, 2, ColMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims2, 3, ColMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims3, 4, ColMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims4, 5, ColMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims0, 1, RowMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims1, 2, RowMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims2, 3, RowMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims3, 4, RowMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims4, 5, RowMajor>::value == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  const Dims0 reduction_axis0;
+  Tensor<float, 4> result0 = tensor.sum(reduction_axis0);
+  for (int m = 0; m < 11; ++m) {
+    for (int l = 0; l < 7; ++l) {
+      for (int k = 0; k < 5; ++k) {
+        for (int j = 0; j < 3; ++j) {
+          float expected = 0.0f;
+          for (int i = 0; i < 2; ++i) {
+            expected += tensor(i, j, k, l, m);
+          }
+          VERIFY_IS_APPROX(result0(j, k, l, m), expected);
+        }
+      }
+    }
+  }
+
+  const Dims1 reduction_axis1;
+  Tensor<float, 3> result1 = tensor.sum(reduction_axis1);
+  for (int m = 0; m < 11; ++m) {
+    for (int l = 0; l < 7; ++l) {
+      for (int k = 0; k < 5; ++k) {
+        float expected = 0.0f;
+        for (int j = 0; j < 3; ++j) {
+          for (int i = 0; i < 2; ++i) {
+            expected += tensor(i, j, k, l, m);
+          }
+        }
+        VERIFY_IS_APPROX(result1(k, l, m), expected);
+      }
+    }
+  }
+
+  const Dims2 reduction_axis2;
+  Tensor<float, 2> result2 = tensor.sum(reduction_axis2);
+  for (int m = 0; m < 11; ++m) {
+    for (int l = 0; l < 7; ++l) {
+      float expected = 0.0f;
+      for (int k = 0; k < 5; ++k) {
+        for (int j = 0; j < 3; ++j) {
+          for (int i = 0; i < 2; ++i) {
+            expected += tensor(i, j, k, l, m);
+          }
+        }
+      }
+      VERIFY_IS_APPROX(result2(l, m), expected);
+    }
+  }
+
+  const Dims3 reduction_axis3;
+  Tensor<float, 1> result3 = tensor.sum(reduction_axis3);
+  for (int m = 0; m < 11; ++m) {
+    float expected = 0.0f;
+    for (int l = 0; l < 7; ++l) {
+      for (int k = 0; k < 5; ++k) {
+        for (int j = 0; j < 3; ++j) {
+          for (int i = 0; i < 2; ++i) {
+            expected += tensor(i, j, k, l, m);
+          }
+        }
+      }
+    }
+    VERIFY_IS_APPROX(result3(m), expected);
+  }
+
+  const Dims4 reduction_axis4;
+  Tensor<float, 0> result4 = tensor.sum(reduction_axis4);
+  float expected = 0.0f;
+  for (int m = 0; m < 11; ++m) {
+    for (int l = 0; l < 7; ++l) {
+      for (int k = 0; k < 5; ++k) {
+        for (int j = 0; j < 3; ++j) {
+          for (int i = 0; i < 2; ++i) {
+            expected += tensor(i, j, k, l, m);
+          }
+        }
+      }
+    }
+  }
+  VERIFY_IS_APPROX(result4(), expected);
+}
+
+static void test_type2indexpair_list() {
+  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+  tensor += tensor.constant(10.0f);
+
+  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>> Dims0;
+  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::type2indexpair<1, 11>, Eigen::type2indexpair<2, 12>>
+      Dims2_a;
+  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::IndexPair<Index>, Eigen::type2indexpair<2, 12>>
+      Dims2_b;
+  typedef Eigen::IndexPairList<Eigen::IndexPair<Index>, Eigen::type2indexpair<1, 11>, Eigen::IndexPair<Index>> Dims2_c;
+
+  Dims2_a d2_a;
+
+  Dims2_b d2_b;
+  d2_b.set(1, Eigen::IndexPair<Index>(1, 11));
+
+  Dims2_c d2_c;
+  d2_c.set(0, Eigen::IndexPair<Index>(Eigen::IndexPair<Index>(0, 10)));
+  d2_c.set(1, Eigen::IndexPair<Index>(1, 11));  // setting type2indexpair to correct value.
+  d2_c.set(2, Eigen::IndexPair<Index>(2, 12));
+
+  VERIFY_IS_EQUAL(d2_a[0].first, 0);
+  VERIFY_IS_EQUAL(d2_a[0].second, 10);
+  VERIFY_IS_EQUAL(d2_a[1].first, 1);
+  VERIFY_IS_EQUAL(d2_a[1].second, 11);
+  VERIFY_IS_EQUAL(d2_a[2].first, 2);
+  VERIFY_IS_EQUAL(d2_a[2].second, 12);
+
+  VERIFY_IS_EQUAL(d2_b[0].first, 0);
+  VERIFY_IS_EQUAL(d2_b[0].second, 10);
+  VERIFY_IS_EQUAL(d2_b[1].first, 1);
+  VERIFY_IS_EQUAL(d2_b[1].second, 11);
+  VERIFY_IS_EQUAL(d2_b[2].first, 2);
+  VERIFY_IS_EQUAL(d2_b[2].second, 12);
+
+  VERIFY_IS_EQUAL(d2_c[0].first, 0);
+  VERIFY_IS_EQUAL(d2_c[0].second, 10);
+  VERIFY_IS_EQUAL(d2_c[1].first, 1);
+  VERIFY_IS_EQUAL(d2_c[1].second, 11);
+  VERIFY_IS_EQUAL(d2_c[2].first, 2);
+  VERIFY_IS_EQUAL(d2_c[2].second, 12);
+
+  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(1) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(0) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(2) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims0>(0, 0) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims0>(0, 1) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(0, 0) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(0, 1) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(1, 1) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(1, 2) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(2, 2) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(2, 3) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(0, 0) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(0, 1) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(1, 1) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(1, 2) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(2, 2) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(2, 3) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(0, 0) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(0, 1) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(1, 1) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(1, 2) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(2, 2) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(2, 3) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims0>(0, 10) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims0>(0, 11) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(0, 10) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(0, 11) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(1, 11) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(1, 12) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(2, 12) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(2, 13) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(0, 10) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(0, 11) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(1, 11) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(1, 12) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(2, 12) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(2, 13) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(0, 10) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(0, 11) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(1, 11) == true),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(1, 12) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(2, 12) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(2, 13) == false),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE);
+}
+
+template <typename QualifiedIndexList>
+static void verify_static_index_metadata() {
+  static_assert(Eigen::internal::index_known_statically<QualifiedIndexList>(1), "index should be known statically");
+  static_assert(Eigen::internal::all_indices_known_statically<QualifiedIndexList>(),
+                "all indices should be known statically");
+  static_assert(Eigen::internal::indices_statically_known_to_increase<QualifiedIndexList>(),
+                "indices should be known to increase");
+  static_assert(Eigen::internal::index_statically_eq<QualifiedIndexList>(1, 1), "index should be statically equal");
+  static_assert(Eigen::internal::index_statically_ne<QualifiedIndexList>(1, 2), "index should be statically unequal");
+  static_assert(Eigen::internal::index_statically_gt<QualifiedIndexList>(1, 0), "index should be statically greater");
+  static_assert(Eigen::internal::index_statically_lt<QualifiedIndexList>(1, 2), "index should be statically less");
+}
+
+template <typename QualifiedIndexPairList>
+static void verify_static_index_pair_metadata() {
+  static_assert(Eigen::internal::index_pair_first_statically_eq<QualifiedIndexPairList>(1, 1),
+                "first index should be statically equal");
+  static_assert(Eigen::internal::index_pair_second_statically_eq<QualifiedIndexPairList>(1, 11),
+                "second index should be statically equal");
+}
+
+static void test_cv_qualified_index_metadata() {
+  using StaticIndices = Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>>;
+  using StaticIndexPairs = Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::type2indexpair<1, 11>>;
+  using StaticDimensions = Eigen::DimensionList<Eigen::Index, 3>;
+
+  verify_static_index_metadata<const StaticIndices>();
+  verify_static_index_metadata<volatile StaticIndices>();
+  verify_static_index_pair_metadata<const StaticIndexPairs>();
+  verify_static_index_pair_metadata<volatile StaticIndexPairs>();
+  verify_static_index_metadata<const StaticDimensions>();
+  verify_static_index_metadata<volatile StaticDimensions>();
+}
+
+static void test_dynamic_index_list() {
+  Tensor<float, 4> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  int dim1 = 2;
+  int dim2 = 1;
+  int dim3 = 0;
+
+  auto reduction_axis = make_index_list(dim1, dim2, dim3);
+
+  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 2);
+  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
+  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 0);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 2);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 0);
+
+  Tensor<float, 1> result = tensor.sum(reduction_axis);
+  for (int i = 0; i < result.size(); ++i) {
+    float expected = 0.0f;
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 5; ++l) {
+          expected += tensor(j, k, l, i);
+        }
+      }
+    }
+    VERIFY_IS_APPROX(result(i), expected);
+  }
+}
+
+static void test_mixed_index_list() {
+  Tensor<float, 4> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  int dim2 = 1;
+  int dim4 = 3;
+
+  auto reduction_axis = make_index_list(0, dim2, 2, dim4);
+
+  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 0);
+  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
+  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 2);
+  VERIFY_IS_EQUAL(internal::array_get<3>(reduction_axis), 3);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 0);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 2);
+  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[3]), 3);
+
+  typedef IndexList<type2index<0>, int, type2index<2>, int> ReductionIndices;
+  ReductionIndices reduction_indices;
+  reduction_indices.set(1, 1);
+  reduction_indices.set(3, 3);
+  EIGEN_STATIC_ASSERT((internal::array_get<0>(reduction_indices) == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::array_get<2>(reduction_indices) == 2), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_known_statically<ReductionIndices>(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_known_statically<ReductionIndices>(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionIndices>(0, 0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionIndices>(2, 2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+#if 0
+  EIGEN_STATIC_ASSERT((internal::all_indices_known_statically<ReductionIndices>() == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<ReductionIndices>() == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
+#endif
+
+  typedef IndexList<type2index<0>, type2index<1>, type2index<2>, type2index<3>> ReductionList;
+  ReductionList reduction_list;
+  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(0, 0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(1, 1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(2, 2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(3, 3) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+#if 0
+  EIGEN_STATIC_ASSERT((internal::all_indices_known_statically<ReductionList>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<ReductionList>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
+#endif
+
+  Tensor<float, 0> result1 = tensor.sum(reduction_axis);
+  Tensor<float, 0> result2 = tensor.sum(reduction_indices);
+  Tensor<float, 0> result3 = tensor.sum(reduction_list);
+
+  float expected = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          expected += tensor(i, j, k, l);
+        }
+      }
+    }
+  }
+  VERIFY_IS_APPROX(result1(), expected);
+  VERIFY_IS_APPROX(result2(), expected);
+  VERIFY_IS_APPROX(result3(), expected);
+}
+
+static void test_dim_check() {
+  Eigen::IndexList<Eigen::type2index<1>, int> dim1;
+  dim1.set(1, 2);
+  Eigen::IndexList<Eigen::type2index<1>, int> dim2;
+  dim2.set(1, 2);
+  VERIFY(dimensions_match(dim1, dim2));
+}
+
+EIGEN_DECLARE_TEST(tensor_index_list) {
+  CALL_SUBTEST(test_static_index_list());
+  CALL_SUBTEST(test_type2index_list());
+  CALL_SUBTEST(test_type2indexpair_list());
+  CALL_SUBTEST(test_cv_qualified_index_metadata());
+  CALL_SUBTEST(test_dynamic_index_list());
+  CALL_SUBTEST(test_mixed_index_list());
+  CALL_SUBTEST(test_dim_check());
+}
diff --git a/contrib/test/tensor_inflation.cpp b/contrib/test/tensor_inflation.cpp
new file mode 100644
index 0000000..8d7a97e
--- /dev/null
+++ b/contrib/test/tensor_inflation.cpp
@@ -0,0 +1,183 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Ke Yang <yangke@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+#include <Eigen/ThreadPool>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_inflation() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> strides;
+
+  strides[0] = 1;
+  strides[1] = 1;
+  strides[2] = 1;
+  strides[3] = 1;
+
+  Tensor<float, 4, DataLayout> no_stride;
+  no_stride = tensor.inflate(strides);
+
+  VERIFY_IS_EQUAL(no_stride.dimension(0), 2);
+  VERIFY_IS_EQUAL(no_stride.dimension(1), 3);
+  VERIFY_IS_EQUAL(no_stride.dimension(2), 5);
+  VERIFY_IS_EQUAL(no_stride.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  strides[0] = 2;
+  strides[1] = 4;
+  strides[2] = 2;
+  strides[3] = 3;
+  Tensor<float, 4, DataLayout> inflated;
+  inflated = tensor.inflate(strides);
+
+  VERIFY_IS_EQUAL(inflated.dimension(0), 3);
+  VERIFY_IS_EQUAL(inflated.dimension(1), 9);
+  VERIFY_IS_EQUAL(inflated.dimension(2), 9);
+  VERIFY_IS_EQUAL(inflated.dimension(3), 19);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 9; ++j) {
+      for (int k = 0; k < 9; ++k) {
+        for (int l = 0; l < 19; ++l) {
+          if (i % 2 == 0 && j % 4 == 0 && k % 2 == 0 && l % 3 == 0) {
+            VERIFY_IS_EQUAL(inflated(i, j, k, l), tensor(i / 2, j / 4, k / 2, l / 3));
+          } else {
+            VERIFY_IS_EQUAL(0, inflated(i, j, k, l));
+          }
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_inflation_of_expression() {
+  // An expression argument has no raw buffer; the block path reads it through
+  // the argument evaluator's coeff(). Sizes with partial-packet tails.
+  Tensor<float, 3, DataLayout> tensor(17, 5, 7);
+  tensor.setRandom();
+
+  array<ptrdiff_t, 3> strides;
+  strides[0] = 2;
+  strides[1] = 3;
+  strides[2] = 1;
+
+  Tensor<float, 3, DataLayout> inflated = (tensor + tensor.constant(1.0f)).inflate(strides);
+
+  VERIFY_IS_EQUAL(inflated.dimension(0), 33);
+  VERIFY_IS_EQUAL(inflated.dimension(1), 13);
+  VERIFY_IS_EQUAL(inflated.dimension(2), 7);
+
+  for (Index i = 0; i < inflated.dimension(0); ++i) {
+    for (Index j = 0; j < inflated.dimension(1); ++j) {
+      for (Index k = 0; k < inflated.dimension(2); ++k) {
+        if (i % 2 == 0 && j % 3 == 0) {
+          VERIFY_IS_EQUAL(inflated(i, j, k), tensor(i / 2, j / 3, k) + 1.0f);
+        } else {
+          VERIFY_IS_EQUAL(inflated(i, j, k), 0.0f);
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_inflation_block_access_gating() {
+  // Inflation reads its argument through coeff() in block(), so it must only
+  // advertise BlockAccess when the argument itself is safe for block-style
+  // (concurrent, repeated) evaluation. A random-generator nullary is repeatable
+  // -- every draw is a pure function of (seed, index) -- so it keeps the tiled
+  // path, as a plain tensor and a cwise expression do. A TensorRef exposes no
+  // block access and must disable it.
+  typedef Tensor<float, 3, DataLayout> TensorType;
+  typedef Eigen::array<ptrdiff_t, 3> Strides;
+
+  typedef decltype(std::declval<const TensorType&>().inflate(std::declval<Strides>())) PlainInflate;
+  typedef decltype((std::declval<const TensorType&>() * std::declval<const TensorType&>().constant(1.0f))
+                       .inflate(std::declval<Strides>())) CwiseInflate;
+  typedef decltype(std::declval<const TensorType&>().random().inflate(std::declval<Strides>())) RandomInflate;
+  typedef Eigen::TensorRef<const TensorType> RefType;
+  typedef decltype(std::declval<const RefType&>().inflate(std::declval<Strides>())) RefInflate;
+
+  EIGEN_STATIC_ASSERT((Eigen::TensorEvaluator<const PlainInflate, Eigen::DefaultDevice>::BlockAccess),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT((Eigen::TensorEvaluator<const CwiseInflate, Eigen::DefaultDevice>::BlockAccess),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT((Eigen::TensorEvaluator<const RandomInflate, Eigen::DefaultDevice>::BlockAccess),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT((!Eigen::TensorEvaluator<const RefInflate, Eigen::DefaultDevice>::BlockAccess),
+                      YOU_MADE_A_PROGRAMMING_MISTAKE)
+}
+
+template <int DataLayout>
+static void test_inflation_thread_pool() {
+  // Tiled ThreadPool evaluation shares the evaluator across concurrent block
+  // tasks; exercise it with a raw tensor and an expression argument. The output
+  // has to be large enough that the executor's block mapper emits more than one
+  // block, otherwise it runs single-block on the calling thread and the
+  // concurrency this test exists for never happens.
+  Tensor<float, 3, DataLayout> tensor(101, 51, 33);
+  tensor.setRandom();
+
+  array<ptrdiff_t, 3> strides;
+  strides[0] = 2;
+  strides[1] = 3;
+  strides[2] = 1;
+
+  Eigen::array<Index, 3> inflated_dims;
+  for (int i = 0; i < 3; ++i) inflated_dims[i] = (tensor.dimension(i) - 1) * strides[i] + 1;
+
+  Eigen::ThreadPool tp(4);
+  Eigen::ThreadPoolDevice device(&tp, 4);
+
+  Tensor<float, 3, DataLayout> inflated(inflated_dims);
+  inflated.device(device) = tensor.inflate(strides);
+
+  Tensor<float, 3, DataLayout> inflated_expr(inflated_dims);
+  inflated_expr.device(device) = (tensor + tensor.constant(1.0f)).inflate(strides);
+
+  for (Index i = 0; i < inflated.dimension(0); ++i) {
+    for (Index j = 0; j < inflated.dimension(1); ++j) {
+      for (Index k = 0; k < inflated.dimension(2); ++k) {
+        const bool on_lattice = (i % strides[0] == 0) && (j % strides[1] == 0) && (k % strides[2] == 0);
+        const float expected = on_lattice ? tensor(i / strides[0], j / strides[1], k / strides[2]) : 0.0f;
+        VERIFY_IS_EQUAL(inflated(i, j, k), expected);
+        VERIFY_IS_EQUAL(inflated_expr(i, j, k), on_lattice ? expected + 1.0f : 0.0f);
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_inflation) {
+  CALL_SUBTEST(test_simple_inflation<ColMajor>());
+  CALL_SUBTEST(test_simple_inflation<RowMajor>());
+  CALL_SUBTEST(test_inflation_of_expression<ColMajor>());
+  CALL_SUBTEST(test_inflation_of_expression<RowMajor>());
+  CALL_SUBTEST(test_inflation_block_access_gating<ColMajor>());
+  CALL_SUBTEST(test_inflation_block_access_gating<RowMajor>());
+  CALL_SUBTEST(test_inflation_thread_pool<ColMajor>());
+  CALL_SUBTEST(test_inflation_thread_pool<RowMajor>());
+}
diff --git a/contrib/test/tensor_inflation_sycl.cpp b/contrib/test/tensor_inflation_sycl.cpp
new file mode 100644
index 0000000..2a800ef
--- /dev/null
+++ b/contrib/test/tensor_inflation_sycl.cpp
@@ -0,0 +1,131 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+// Inflation Definition for each dimension the inflated val would be
+//((dim-1)*strid[dim] +1)
+
+// for 1 dimension vector of size 3 with value (4,4,4) with the inflated stride value of 3 would be changed to
+// tensor of size (2*3) +1 = 7 with the value of
+// (4, 0, 0, 4, 0, 0, 4).
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_simple_inflation_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> no_stride(tensorRange);
+  tensor.setRandom();
+
+  array<IndexType, 4> strides;
+  strides[0] = 1;
+  strides[1] = 1;
+  strides[2] = 1;
+  strides[3] = 1;
+
+  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
+  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_no_stride = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_no_stride(gpu_data_no_stride, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
+  gpu_no_stride.device(sycl_device) = gpu_tensor.inflate(strides);
+  sycl_device.memcpyDeviceToHost(no_stride.data(), gpu_data_no_stride, tensorBuffSize);
+
+  VERIFY_IS_EQUAL(no_stride.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(no_stride.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(no_stride.dimension(2), sizeDim3);
+  VERIFY_IS_EQUAL(no_stride.dimension(3), sizeDim4);
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  strides[0] = 2;
+  strides[1] = 4;
+  strides[2] = 2;
+  strides[3] = 3;
+
+  IndexType inflatedSizeDim1 = 3;
+  IndexType inflatedSizeDim2 = 9;
+  IndexType inflatedSizeDim3 = 9;
+  IndexType inflatedSizeDim4 = 19;
+  array<IndexType, 4> inflatedTensorRange = {{inflatedSizeDim1, inflatedSizeDim2, inflatedSizeDim3, inflatedSizeDim4}};
+
+  Tensor<DataType, 4, DataLayout, IndexType> inflated(inflatedTensorRange);
+
+  const size_t inflatedTensorBuffSize = inflated.size() * sizeof(DataType);
+  DataType* gpu_data_inflated = static_cast<DataType*>(sycl_device.allocate(inflatedTensorBuffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_inflated(gpu_data_inflated, inflatedTensorRange);
+  gpu_inflated.device(sycl_device) = gpu_tensor.inflate(strides);
+  sycl_device.memcpyDeviceToHost(inflated.data(), gpu_data_inflated, inflatedTensorBuffSize);
+
+  VERIFY_IS_EQUAL(inflated.dimension(0), inflatedSizeDim1);
+  VERIFY_IS_EQUAL(inflated.dimension(1), inflatedSizeDim2);
+  VERIFY_IS_EQUAL(inflated.dimension(2), inflatedSizeDim3);
+  VERIFY_IS_EQUAL(inflated.dimension(3), inflatedSizeDim4);
+
+  for (IndexType i = 0; i < inflatedSizeDim1; ++i) {
+    for (IndexType j = 0; j < inflatedSizeDim2; ++j) {
+      for (IndexType k = 0; k < inflatedSizeDim3; ++k) {
+        for (IndexType l = 0; l < inflatedSizeDim4; ++l) {
+          if (i % strides[0] == 0 && j % strides[1] == 0 && k % strides[2] == 0 && l % strides[3] == 0) {
+            VERIFY_IS_EQUAL(inflated(i, j, k, l),
+                            tensor(i / strides[0], j / strides[1], k / strides[2], l / strides[3]));
+          } else {
+            VERIFY_IS_EQUAL(0, inflated(i, j, k, l));
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_tensor);
+  sycl_device.deallocate(gpu_data_no_stride);
+  sycl_device.deallocate(gpu_data_inflated);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_inflation_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_inflation_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_inflation_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_inflation_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_inflation_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_inflation_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_intdiv.cpp b/contrib/test/tensor_intdiv.cpp
new file mode 100644
index 0000000..8041969
--- /dev/null
+++ b/contrib/test/tensor_intdiv.cpp
@@ -0,0 +1,140 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014-2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+void test_signed_32bit() {
+  // Divide by one
+  const Eigen::internal::TensorIntDivisor<int32_t, false> div_by_one(1);
+
+  for (int32_t j = 0; j < 25000; ++j) {
+    const int32_t fast_div = j / div_by_one;
+    const int32_t slow_div = j / 1;
+    VERIFY_IS_EQUAL(fast_div, slow_div);
+  }
+
+  // Standard divide by 2 or more
+  for (int32_t i = 2; i < 25000; ++i) {
+    const Eigen::internal::TensorIntDivisor<int32_t, false> div(i);
+
+    for (int32_t j = 0; j < 25000; ++j) {
+      const int32_t fast_div = j / div;
+      const int32_t slow_div = j / i;
+      VERIFY_IS_EQUAL(fast_div, slow_div);
+    }
+  }
+
+  // Optimized divide by 2 or more
+  for (int32_t i = 2; i < 25000; ++i) {
+    const Eigen::internal::TensorIntDivisor<int32_t, true> div(i);
+
+    for (int32_t j = 0; j < 25000; ++j) {
+      const int32_t fast_div = j / div;
+      const int32_t slow_div = j / i;
+      VERIFY_IS_EQUAL(fast_div, slow_div);
+    }
+  }
+}
+
+void test_unsigned_32bit() {
+  for (uint32_t i = 1; i < 25000; ++i) {
+    const Eigen::internal::TensorIntDivisor<uint32_t> div(i);
+
+    for (uint32_t j = 0; j < 25000; ++j) {
+      const uint32_t fast_div = j / div;
+      const uint32_t slow_div = j / i;
+      VERIFY_IS_EQUAL(fast_div, slow_div);
+    }
+  }
+}
+
+void test_signed_64bit() {
+  for (int64_t i = 1; i < 25000; ++i) {
+    const Eigen::internal::TensorIntDivisor<int64_t> div(i);
+
+    for (int64_t j = 0; j < 25000; ++j) {
+      const int64_t fast_div = j / div;
+      const int64_t slow_div = j / i;
+      VERIFY_IS_EQUAL(fast_div, slow_div);
+    }
+  }
+}
+
+void test_unsigned_64bit() {
+  for (uint64_t i = 1; i < 25000; ++i) {
+    const Eigen::internal::TensorIntDivisor<uint64_t> div(i);
+
+    for (uint64_t j = 0; j < 25000; ++j) {
+      const uint64_t fast_div = j / div;
+      const uint64_t slow_div = j / i;
+      VERIFY_IS_EQUAL(fast_div, slow_div);
+    }
+  }
+}
+
+void test_powers_32bit() {
+  const int32_t int32_max = (std::numeric_limits<int32_t>::max)();
+  for (int expon = 1; expon < 31; expon++) {
+    int32_t div = (1 << expon);
+    for (int num_expon = 0; num_expon < 32; num_expon++) {
+      const int64_t pivot = int64_t(1) << num_expon;
+      int32_t start_num = pivot > int32_max ? int32_max : static_cast<int32_t>(pivot);
+      int32_t end_num = start_num;
+      start_num = (std::max)(int32_t(0), start_num - 100);
+      end_num = static_cast<int32_t>((std::min)(int64_t(int32_max), int64_t(end_num) + 100));
+      if (start_num < 0) start_num = 0;
+      for (int32_t num = start_num; num < end_num; num++) {
+        Eigen::internal::TensorIntDivisor<int32_t> divider = Eigen::internal::TensorIntDivisor<int32_t>(div);
+        int32_t result = num / div;
+        int32_t result_op = divider.divide(num);
+        VERIFY_IS_EQUAL(result_op, result);
+      }
+    }
+  }
+}
+
+void test_powers_64bit() {
+  for (int expon = 0; expon < 63; expon++) {
+    int64_t div = (1ull << expon);
+    for (int num_expon = 0; num_expon < 63; num_expon++) {
+      int64_t start_num = (1ull << num_expon) - 10;
+      int64_t end_num = (1ull << num_expon) + 10;
+      if (start_num < 0) start_num = 0;
+      for (int64_t num = start_num; num < end_num; num++) {
+        Eigen::internal::TensorIntDivisor<int64_t> divider(div);
+        int64_t result = num / div;
+        int64_t result_op = divider.divide(num);
+        VERIFY_IS_EQUAL(result_op, result);
+      }
+    }
+  }
+}
+
+void test_specific() {
+  // A particular combination that was previously failing
+  int64_t div = 209715200;
+  int64_t num = 3238002688ll;
+  Eigen::internal::TensorIntDivisor<int64_t> divider(div);
+  int64_t result = num / div;
+  int64_t result_op = divider.divide(num);
+  VERIFY_IS_EQUAL(result, result_op);
+}
+
+EIGEN_DECLARE_TEST(tensor_intdiv) {
+  CALL_SUBTEST_1(test_signed_32bit());
+  CALL_SUBTEST_2(test_unsigned_32bit());
+  CALL_SUBTEST_3(test_signed_64bit());
+  CALL_SUBTEST_4(test_unsigned_64bit());
+  CALL_SUBTEST_5(test_powers_32bit());
+  CALL_SUBTEST_6(test_powers_64bit());
+  CALL_SUBTEST_7(test_specific());
+}
diff --git a/contrib/test/tensor_io.cpp b/contrib/test/tensor_io.cpp
new file mode 100644
index 0000000..e148762
--- /dev/null
+++ b/contrib/test/tensor_io.cpp
@@ -0,0 +1,153 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+#include "main.h"
+
+#include <sstream>
+#include <Eigen/Tensor>
+
+template <typename Scalar, int rank, int Layout>
+struct test_tensor_ostream_impl {};
+
+template <typename Scalar, int Layout>
+struct test_tensor_ostream_impl<Scalar, 0, Layout> {
+  static void run() {
+    Eigen::Tensor<Scalar, 0, Layout> t;
+    t.setValues(1);
+    std::ostringstream os;
+    os << t.format(Eigen::TensorIOFormat::Plain());
+    VERIFY(os.str() == "1");
+  }
+};
+
+template <typename Scalar, int Layout>
+struct test_tensor_ostream_impl<Scalar, 1, Layout> {
+  static void run() {
+    Eigen::Tensor<Scalar, 1, Layout> t = {3};
+    t.setValues({1, 2, 3});
+    std::ostringstream os;
+    os << t.format(Eigen::TensorIOFormat::Plain());
+    VERIFY(os.str() == "1 2 3");
+  }
+};
+
+template <typename Scalar, int Layout>
+struct test_tensor_ostream_impl<Scalar, 2, Layout> {
+  static void run() {
+    Eigen::Tensor<Scalar, 2, Layout> t = {3, 2};
+    t.setValues({{1, 2}, {3, 4}, {5, 6}});
+    std::ostringstream os;
+    os << t.format(Eigen::TensorIOFormat::Plain());
+    VERIFY(os.str() == "1 2\n3 4\n5 6");
+  }
+};
+
+template <typename Scalar, int Layout>
+struct test_tensor_ostream_impl<Scalar, 3, Layout> {
+  static void run() {
+    Eigen::Tensor<Scalar, 3, Layout> t = {4, 3, 2};
+    t.setValues({{{1, 2}, {3, 4}, {5, 6}},
+                 {{7, 8}, {9, 10}, {11, 12}},
+                 {{13, 14}, {15, 16}, {17, 18}},
+                 {{19, 20}, {21, 22}, {23, 24}}});
+    std::ostringstream os;
+    os << t.format(Eigen::TensorIOFormat::Plain());
+    VERIFY(os.str() == " 1  2\n 3  4\n 5  6\n\n 7  8\n 9 10\n11 12\n\n13 14\n15 16\n17 18\n\n19 20\n21 22\n23 24");
+  }
+};
+
+template <int Layout>
+struct test_tensor_ostream_impl<bool, 2, Layout> {
+  static void run() {
+    Eigen::Tensor<bool, 2, Layout> t = {3, 2};
+    t.setValues({{false, true}, {true, false}, {false, false}});
+    std::ostringstream os;
+    os << t.format(Eigen::TensorIOFormat::Plain());
+    VERIFY(os.str() == "0 1\n1 0\n0 0");
+  }
+};
+
+template <typename Scalar, int Layout>
+struct test_tensor_ostream_impl<std::complex<Scalar>, 2, Layout> {
+  static void run() {
+    Eigen::Tensor<std::complex<Scalar>, 2, Layout> t = {3, 2};
+    t.setValues({{std::complex<Scalar>(1, 2), std::complex<Scalar>(12, 3)},
+                 {std::complex<Scalar>(-4, 2), std::complex<Scalar>(0, 5)},
+                 {std::complex<Scalar>(-1, 4), std::complex<Scalar>(5, 27)}});
+    std::ostringstream os;
+    os << t.format(Eigen::TensorIOFormat::Plain());
+    VERIFY(os.str() == " (1,2) (12,3)\n(-4,2)  (0,5)\n(-1,4) (5,27)");
+
+    os.str("");
+    os.clear();
+    os << t.format(Eigen::TensorIOFormat::Numpy());
+    VERIFY(os.str() == "[[ 1+2j 12+3j]\n [-4+2j  0+5j]\n [-1+4j 5+27j]]");
+
+    os.str("");
+    os.clear();
+    os << t.format(Eigen::TensorIOFormat::Native());
+    VERIFY(os.str() == "{{ {1, 2}, {12, 3}},\n {{-4, 2},  {0, 5}},\n {{-1, 4}, {5, 27}}}");
+  }
+};
+
+template <typename Scalar, int rank, int Layout>
+void test_tensor_ostream() {
+  test_tensor_ostream_impl<Scalar, rank, Layout>::run();
+}
+
+void test_const_tensor_ostream() {
+  Eigen::Tensor<float, 0> t;
+  t.setValues(1);
+  const Eigen::TensorMap<Eigen::Tensor<const float, 0, Eigen::RowMajor>, Eigen::Unaligned> t_const(
+      t.data(), Eigen::DSizes<Eigen::DenseIndex, 0>{});
+  std::ostringstream os;
+  os << t_const.format(Eigen::TensorIOFormat::Plain());
+  VERIFY(os.str() == "1");
+}
+
+EIGEN_DECLARE_TEST(tensor_io) {
+  CALL_SUBTEST((test_tensor_ostream<float, 0, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<float, 1, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<float, 2, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<float, 3, Eigen::ColMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<double, 0, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<double, 1, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<double, 2, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<double, 3, Eigen::ColMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<int, 0, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<int, 1, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<int, 2, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<int, 3, Eigen::ColMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<float, 0, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<float, 1, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<float, 2, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<float, 3, Eigen::RowMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<double, 0, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<double, 1, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<double, 2, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<double, 3, Eigen::RowMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<int, 0, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<int, 1, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<int, 2, Eigen::RowMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<int, 3, Eigen::RowMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<bool, 2, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<bool, 2, Eigen::RowMajor>()));
+
+  CALL_SUBTEST((test_tensor_ostream<std::complex<double>, 2, Eigen::ColMajor>()));
+  CALL_SUBTEST((test_tensor_ostream<std::complex<float>, 2, Eigen::ColMajor>()));
+
+  // Test printing TensorMap with const elements.
+  CALL_SUBTEST((test_const_tensor_ostream()));
+}
diff --git a/contrib/test/tensor_layout_swap.cpp b/contrib/test/tensor_layout_swap.cpp
new file mode 100644
index 0000000..27e51c9
--- /dev/null
+++ b/contrib/test/tensor_layout_swap.cpp
@@ -0,0 +1,126 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+static void test_simple_swap() {
+  Tensor<float, 3, ColMajor> tensor(2, 3, 7);
+  tensor.setRandom();
+
+  Tensor<float, 3, RowMajor> tensor2 = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor2.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor2.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor2.dimension(0));
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor(i, j, k), tensor2(k, j, i));
+      }
+    }
+  }
+}
+
+static void test_swap_as_lvalue() {
+  Tensor<float, 3, ColMajor> tensor(2, 3, 7);
+  tensor.setRandom();
+
+  Tensor<float, 3, RowMajor> tensor2(7, 3, 2);
+  tensor2.swap_layout() = tensor;
+  VERIFY_IS_EQUAL(tensor.dimension(0), tensor2.dimension(2));
+  VERIFY_IS_EQUAL(tensor.dimension(1), tensor2.dimension(1));
+  VERIFY_IS_EQUAL(tensor.dimension(2), tensor2.dimension(0));
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor(i, j, k), tensor2(k, j, i));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_block_swap_read() {
+  constexpr int SwappedLayout = (DataLayout == ColMajor) ? RowMajor : ColMajor;
+  Tensor<float, 3, DataLayout> tensor(17, 5, 7);
+  tensor.setRandom();
+
+  array<ptrdiff_t, 3> shuffle{{2, 0, 1}};
+  Tensor<float, 3, DataLayout> shuffled = tensor.shuffle(shuffle);
+
+  // The shuffle prefers block evaluation and serves materialized blocks; the
+  // layout swap forwards the block request and re-wraps the result. This runs
+  // through the tiled executor end to end.
+  Tensor<float, 3, SwappedLayout> result = tensor.shuffle(shuffle).swap_layout();
+  VERIFY_IS_EQUAL(result.dimension(0), shuffled.dimension(2));
+  VERIFY_IS_EQUAL(result.dimension(1), shuffled.dimension(1));
+  VERIFY_IS_EQUAL(result.dimension(2), shuffled.dimension(0));
+  for (ptrdiff_t i = 0; i < shuffled.dimension(0); ++i) {
+    for (ptrdiff_t j = 0; j < shuffled.dimension(1); ++j) {
+      for (ptrdiff_t k = 0; k < shuffled.dimension(2); ++k) {
+        VERIFY_IS_EQUAL(result(k, j, i), shuffled(i, j, k));
+      }
+    }
+  }
+
+  // A cwise expression on top of the shuffle serves lazy blocks that the
+  // layout swap has to materialize itself.
+  Tensor<float, 3, DataLayout> bias(shuffled.dimensions());
+  bias.setRandom();
+  Tensor<float, 3, SwappedLayout> result2 = (tensor.shuffle(shuffle) + bias).swap_layout();
+  for (ptrdiff_t i = 0; i < shuffled.dimension(0); ++i) {
+    for (ptrdiff_t j = 0; j < shuffled.dimension(1); ++j) {
+      for (ptrdiff_t k = 0; k < shuffled.dimension(2); ++k) {
+        VERIFY_IS_EQUAL(result2(k, j, i), shuffled(i, j, k) + bias(i, j, k));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_block_swap_write() {
+  constexpr int SwappedLayout = (DataLayout == ColMajor) ? RowMajor : ColMajor;
+  Tensor<float, 3, SwappedLayout> src(17, 5, 7);
+  src.setRandom();
+
+  array<ptrdiff_t, 3> shuffle{{2, 0, 1}};
+  Tensor<float, 3, SwappedLayout> shuffled = src.shuffle(shuffle);
+  Tensor<float, 3, SwappedLayout> bias(shuffled.dimensions());
+  bias.setRandom();
+
+  // The destination is a raw buffer viewed through a layout swap. The shuffle
+  // on the right prefers block evaluation, so the tiled executor either
+  // materializes right-hand-side blocks straight into the destination or
+  // hands lazy blocks to the layout swap's writeBlock.
+  Tensor<float, 3, DataLayout> dst(shuffled.dimension(2), shuffled.dimension(1), shuffled.dimension(0));
+  dst.swap_layout() = src.shuffle(shuffle) + bias;
+
+  for (ptrdiff_t i = 0; i < shuffled.dimension(0); ++i) {
+    for (ptrdiff_t j = 0; j < shuffled.dimension(1); ++j) {
+      for (ptrdiff_t k = 0; k < shuffled.dimension(2); ++k) {
+        VERIFY_IS_EQUAL(dst(k, j, i), shuffled(i, j, k) + bias(i, j, k));
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_layout_swap) {
+  CALL_SUBTEST(test_simple_swap());
+  CALL_SUBTEST(test_swap_as_lvalue());
+  CALL_SUBTEST(test_block_swap_read<ColMajor>());
+  CALL_SUBTEST(test_block_swap_read<RowMajor>());
+  CALL_SUBTEST(test_block_swap_write<ColMajor>());
+  CALL_SUBTEST(test_block_swap_write<RowMajor>());
+}
diff --git a/contrib/test/tensor_layout_swap_sycl.cpp b/contrib/test/tensor_layout_swap_sycl.cpp
new file mode 100644
index 0000000..9674804
--- /dev/null
+++ b/contrib/test/tensor_layout_swap_sycl.cpp
@@ -0,0 +1,121 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename DataType, typename IndexType>
+static void test_simple_swap_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 7;
+  array<IndexType, 3> tensorColRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  array<IndexType, 3> tensorRowRange = {{sizeDim3, sizeDim2, sizeDim1}};
+
+  Tensor<DataType, 3, ColMajor, IndexType> tensor1(tensorColRange);
+  Tensor<DataType, 3, RowMajor, IndexType> tensor2(tensorRowRange);
+  tensor1.setRandom();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu1(gpu_data1, tensorColRange);
+  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu2(gpu_data2, tensorRowRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor2.size()) * sizeof(DataType));
+
+  //  Tensor<float, 3, ColMajor> tensor(2,3,7);
+  // tensor.setRandom();
+
+  //  Tensor<float, 3, RowMajor> tensor2 = tensor.swap_layout();
+  VERIFY_IS_EQUAL(tensor1.dimension(0), tensor2.dimension(2));
+  VERIFY_IS_EQUAL(tensor1.dimension(1), tensor2.dimension(1));
+  VERIFY_IS_EQUAL(tensor1.dimension(2), tensor2.dimension(0));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor1(i, j, k), tensor2(k, j, i));
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+}
+
+template <typename DataType, typename IndexType>
+static void test_swap_as_lvalue_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 7;
+  array<IndexType, 3> tensorColRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  array<IndexType, 3> tensorRowRange = {{sizeDim3, sizeDim2, sizeDim1}};
+
+  Tensor<DataType, 3, ColMajor, IndexType> tensor1(tensorColRange);
+  Tensor<DataType, 3, RowMajor, IndexType> tensor2(tensorRowRange);
+  tensor1.setRandom();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu1(gpu_data1, tensorColRange);
+  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu2(gpu_data2, tensorRowRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
+  gpu2.swap_layout().device(sycl_device) = gpu1;
+  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor2.size()) * sizeof(DataType));
+
+  //  Tensor<float, 3, ColMajor> tensor(2,3,7);
+  //  tensor.setRandom();
+
+  // Tensor<float, 3, RowMajor> tensor2(7,3,2);
+  //  tensor2.swap_layout() = tensor;
+  VERIFY_IS_EQUAL(tensor1.dimension(0), tensor2.dimension(2));
+  VERIFY_IS_EQUAL(tensor1.dimension(1), tensor2.dimension(1));
+  VERIFY_IS_EQUAL(tensor1.dimension(2), tensor2.dimension(0));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor1(i, j, k), tensor2(k, j, i));
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_tensor_layout_swap_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_swap_sycl<DataType, int64_t>(sycl_device);
+  test_swap_as_lvalue_sycl<DataType, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_layout_swap_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_tensor_layout_swap_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_tensor_layout_swap_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_lvalue.cpp b/contrib/test/tensor_lvalue.cpp
new file mode 100644
index 0000000..d48b1f2
--- /dev/null
+++ b/contrib/test/tensor_lvalue.cpp
@@ -0,0 +1,37 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_compound_assignment() {
+  Tensor<float, 3> mat1(2, 3, 7);
+  Tensor<float, 3> mat2(2, 3, 7);
+  Tensor<float, 3> mat3(2, 3, 7);
+
+  mat1.setRandom();
+  mat2.setRandom();
+  mat3 = mat1;
+  mat3 += mat2;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(mat3(i, j, k), mat1(i, j, k) + mat2(i, j, k));
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_lvalue) { CALL_SUBTEST(test_compound_assignment()); }
diff --git a/contrib/test/tensor_map.cpp b/contrib/test/tensor_map.cpp
new file mode 100644
index 0000000..ef6ff40
--- /dev/null
+++ b/contrib/test/tensor_map.cpp
@@ -0,0 +1,358 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_0d() {
+  Tensor<int, 0> scalar1;
+  Tensor<int, 0, RowMajor> scalar2;
+
+  TensorMap<const Tensor<int, 0>> scalar3(scalar1.data());
+  TensorMap<const Tensor<int, 0, RowMajor>> scalar4(scalar2.data());
+
+  scalar1() = 7;
+  scalar2() = 13;
+
+  VERIFY_IS_EQUAL(scalar1.rank(), 0);
+  VERIFY_IS_EQUAL(scalar1.size(), 1);
+
+  VERIFY_IS_EQUAL(scalar3(), 7);
+  VERIFY_IS_EQUAL(scalar4(), 13);
+}
+
+static void test_1d() {
+  Tensor<int, 1> vec1(6);
+  Tensor<int, 1, RowMajor> vec2(6);
+
+  TensorMap<const Tensor<int, 1>> vec3(vec1.data(), 6);
+  TensorMap<const Tensor<int, 1, RowMajor>> vec4(vec2.data(), 6);
+
+  vec1(0) = 4;
+  vec2(0) = 0;
+  vec1(1) = 8;
+  vec2(1) = 1;
+  vec1(2) = 15;
+  vec2(2) = 2;
+  vec1(3) = 16;
+  vec2(3) = 3;
+  vec1(4) = 23;
+  vec2(4) = 4;
+  vec1(5) = 42;
+  vec2(5) = 5;
+
+  VERIFY_IS_EQUAL(vec1.rank(), 1);
+  VERIFY_IS_EQUAL(vec1.size(), 6);
+  VERIFY_IS_EQUAL(vec1.dimension(0), 6);
+
+  VERIFY_IS_EQUAL(vec3(0), 4);
+  VERIFY_IS_EQUAL(vec3(1), 8);
+  VERIFY_IS_EQUAL(vec3(2), 15);
+  VERIFY_IS_EQUAL(vec3(3), 16);
+  VERIFY_IS_EQUAL(vec3(4), 23);
+  VERIFY_IS_EQUAL(vec3(5), 42);
+
+  VERIFY_IS_EQUAL(vec4(0), 0);
+  VERIFY_IS_EQUAL(vec4(1), 1);
+  VERIFY_IS_EQUAL(vec4(2), 2);
+  VERIFY_IS_EQUAL(vec4(3), 3);
+  VERIFY_IS_EQUAL(vec4(4), 4);
+  VERIFY_IS_EQUAL(vec4(5), 5);
+}
+
+static void test_2d() {
+  Tensor<int, 2> mat1(2, 3);
+  Tensor<int, 2, RowMajor> mat2(2, 3);
+
+  mat1(0, 0) = 0;
+  mat1(0, 1) = 1;
+  mat1(0, 2) = 2;
+  mat1(1, 0) = 3;
+  mat1(1, 1) = 4;
+  mat1(1, 2) = 5;
+
+  mat2(0, 0) = 0;
+  mat2(0, 1) = 1;
+  mat2(0, 2) = 2;
+  mat2(1, 0) = 3;
+  mat2(1, 1) = 4;
+  mat2(1, 2) = 5;
+
+  TensorMap<const Tensor<int, 2>> mat3(mat1.data(), 2, 3);
+  TensorMap<const Tensor<int, 2, RowMajor>> mat4(mat2.data(), 2, 3);
+
+  VERIFY_IS_EQUAL(mat3.rank(), 2);
+  VERIFY_IS_EQUAL(mat3.size(), 6);
+  VERIFY_IS_EQUAL(mat3.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat3.dimension(1), 3);
+
+  VERIFY_IS_EQUAL(mat4.rank(), 2);
+  VERIFY_IS_EQUAL(mat4.size(), 6);
+  VERIFY_IS_EQUAL(mat4.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat4.dimension(1), 3);
+
+  VERIFY_IS_EQUAL(mat3(0, 0), 0);
+  VERIFY_IS_EQUAL(mat3(0, 1), 1);
+  VERIFY_IS_EQUAL(mat3(0, 2), 2);
+  VERIFY_IS_EQUAL(mat3(1, 0), 3);
+  VERIFY_IS_EQUAL(mat3(1, 1), 4);
+  VERIFY_IS_EQUAL(mat3(1, 2), 5);
+
+  VERIFY_IS_EQUAL(mat4(0, 0), 0);
+  VERIFY_IS_EQUAL(mat4(0, 1), 1);
+  VERIFY_IS_EQUAL(mat4(0, 2), 2);
+  VERIFY_IS_EQUAL(mat4(1, 0), 3);
+  VERIFY_IS_EQUAL(mat4(1, 1), 4);
+  VERIFY_IS_EQUAL(mat4(1, 2), 5);
+}
+
+static void test_3d() {
+  Tensor<int, 3> mat1(2, 3, 7);
+  Tensor<int, 3, RowMajor> mat2(2, 3, 7);
+
+  int val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        mat2(i, j, k) = val;
+        val++;
+      }
+    }
+  }
+
+  TensorMap<const Tensor<int, 3>> mat3(mat1.data(), 2, 3, 7);
+  TensorMap<const Tensor<int, 3, RowMajor>> mat4(mat2.data(), 2, 3, 7);
+
+  VERIFY_IS_EQUAL(mat3.rank(), 3);
+  VERIFY_IS_EQUAL(mat3.size(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(mat3.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat3.dimension(1), 3);
+  VERIFY_IS_EQUAL(mat3.dimension(2), 7);
+
+  VERIFY_IS_EQUAL(mat4.rank(), 3);
+  VERIFY_IS_EQUAL(mat4.size(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(mat4.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat4.dimension(1), 3);
+  VERIFY_IS_EQUAL(mat4.dimension(2), 7);
+
+  val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(mat3(i, j, k), val);
+        VERIFY_IS_EQUAL(mat4(i, j, k), val);
+        val++;
+      }
+    }
+  }
+}
+
+static void test_from_tensor() {
+  Tensor<int, 3> mat1(2, 3, 7);
+  Tensor<int, 3, RowMajor> mat2(2, 3, 7);
+
+  int val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        mat1(i, j, k) = val;
+        mat2(i, j, k) = val;
+        val++;
+      }
+    }
+  }
+
+  TensorMap<Tensor<int, 3>> mat3(mat1);
+  TensorMap<Tensor<int, 3, RowMajor>> mat4(mat2);
+
+  VERIFY_IS_EQUAL(mat3.rank(), 3);
+  VERIFY_IS_EQUAL(mat3.size(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(mat3.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat3.dimension(1), 3);
+  VERIFY_IS_EQUAL(mat3.dimension(2), 7);
+
+  VERIFY_IS_EQUAL(mat4.rank(), 3);
+  VERIFY_IS_EQUAL(mat4.size(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(mat4.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat4.dimension(1), 3);
+  VERIFY_IS_EQUAL(mat4.dimension(2), 7);
+
+  val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(mat3(i, j, k), val);
+        VERIFY_IS_EQUAL(mat4(i, j, k), val);
+        val++;
+      }
+    }
+  }
+
+  TensorFixedSize<int, Sizes<2, 3, 7>> mat5;
+
+  val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        array<ptrdiff_t, 3> coords;
+        coords[0] = i;
+        coords[1] = j;
+        coords[2] = k;
+        mat5(coords) = val;
+        val++;
+      }
+    }
+  }
+
+  TensorMap<TensorFixedSize<int, Sizes<2, 3, 7>>> mat6(mat5);
+
+  VERIFY_IS_EQUAL(mat6.rank(), 3);
+  VERIFY_IS_EQUAL(mat6.size(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(mat6.dimension(0), 2);
+  VERIFY_IS_EQUAL(mat6.dimension(1), 3);
+  VERIFY_IS_EQUAL(mat6.dimension(2), 7);
+
+  val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(mat6(i, j, k), val);
+        val++;
+      }
+    }
+  }
+}
+
+static int f(const TensorMap<Tensor<int, 3>>& tensor) {
+  //  Size<0> empty;
+  EIGEN_STATIC_ASSERT((internal::array_size<Sizes<>>::value == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  EIGEN_STATIC_ASSERT((internal::array_size<DSizes<int, 0>>::value == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
+  Tensor<int, 0> result = tensor.sum();
+  return result();
+}
+
+static void test_casting() {
+  Tensor<int, 3> tensor(2, 3, 7);
+
+  int val = 0;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        tensor(i, j, k) = val;
+        val++;
+      }
+    }
+  }
+
+  TensorMap<Tensor<int, 3>> map(tensor);
+  int sum1 = f(map);
+  int sum2 = f(tensor);
+
+  VERIFY_IS_EQUAL(sum1, sum2);
+  VERIFY_IS_EQUAL(sum1, 861);
+}
+
+template <typename T>
+static const T& add_const(T& value) {
+  return value;
+}
+
+static void test_0d_const_tensor() {
+  Tensor<int, 0> scalar1;
+  Tensor<int, 0, RowMajor> scalar2;
+
+  TensorMap<const Tensor<int, 0>> scalar3(add_const(scalar1).data());
+  TensorMap<const Tensor<int, 0, RowMajor>> scalar4(add_const(scalar2).data());
+
+  scalar1() = 7;
+  scalar2() = 13;
+
+  VERIFY_IS_EQUAL(scalar1.rank(), 0);
+  VERIFY_IS_EQUAL(scalar1.size(), 1);
+
+  VERIFY_IS_EQUAL(scalar3(), 7);
+  VERIFY_IS_EQUAL(scalar4(), 13);
+}
+
+static void test_0d_const_tensor_map() {
+  Tensor<int, 0> scalar1;
+  Tensor<int, 0, RowMajor> scalar2;
+
+  const TensorMap<Tensor<int, 0>> scalar3(scalar1.data());
+  const TensorMap<Tensor<int, 0, RowMajor>> scalar4(scalar2.data());
+
+  // Although TensorMap is constant, we still can write to the underlying
+  // storage, because we map over non-constant Tensor.
+  scalar3() = 7;
+  scalar4() = 13;
+
+  VERIFY_IS_EQUAL(scalar1(), 7);
+  VERIFY_IS_EQUAL(scalar2(), 13);
+
+  // Pointer to the underlying storage is also non-const.
+  scalar3.data()[0] = 8;
+  scalar4.data()[0] = 14;
+
+  VERIFY_IS_EQUAL(scalar1(), 8);
+  VERIFY_IS_EQUAL(scalar2(), 14);
+}
+
+// Regression test for issue #1616: unsigned index and dimension types must not
+// trigger narrowing errors in the variadic constructor and accessors.
+static void test_unsigned_indices() {
+  Tensor<int, 3> tensor(2, 3, 7);
+  tensor.setZero();
+
+  TensorMap<Tensor<int, 3>> map(tensor.data(), 2u, 3ul, std::size_t(7));
+  map(1u, std::size_t(2), 6ul) = 5;
+  VERIFY_IS_EQUAL(map(1ul, 2u, std::size_t(6)), 5);
+  VERIFY_IS_EQUAL(tensor(1, 2, 6), 5);
+
+  TensorMap<const Tensor<int, 3>> const_map(tensor.data(), 2u, 3ul, std::size_t(7));
+  VERIFY_IS_EQUAL(const_map(1u, 2ul, std::size_t(6)), 5);
+}
+
+// An index or dimension the tensor's index type cannot represent must assert rather than silently truncate.
+static void test_narrowing_indices() {
+  // Fixed width: on ILP32 targets shifting std::size_t by 40 is undefined, and GCC folds it to an in-range 0.
+  const std::uint64_t too_large = std::uint64_t(1) << 40;
+
+  Tensor<int, 3, ColMajor, int> tensor(2, 3, 7);
+  tensor.setZero();
+
+  VERIFY_RAISES_ASSERT((TensorMap<Tensor<int, 3, ColMajor, int>>(tensor.data(), 2, 3, too_large)));
+
+  TensorMap<Tensor<int, 3, ColMajor, int>> map(tensor.data(), 2, 3, 7);
+  VERIFY_RAISES_ASSERT(map(0, 0, too_large) = 1);
+
+  TensorMap<const Tensor<int, 3, ColMajor, int>> const_map(tensor.data(), 2, 3, 7);
+  VERIFY_RAISES_ASSERT(const_map(0, 0, too_large));
+}
+
+EIGEN_DECLARE_TEST(tensor_map) {
+  CALL_SUBTEST(test_0d());
+  CALL_SUBTEST(test_1d());
+  CALL_SUBTEST(test_2d());
+  CALL_SUBTEST(test_3d());
+
+  CALL_SUBTEST(test_from_tensor());
+  CALL_SUBTEST(test_casting());
+
+  CALL_SUBTEST(test_0d_const_tensor());
+  CALL_SUBTEST(test_0d_const_tensor_map());
+
+  CALL_SUBTEST(test_unsigned_indices());
+  CALL_SUBTEST(test_narrowing_indices());
+}
diff --git a/contrib/test/tensor_math.cpp b/contrib/test/tensor_math.cpp
new file mode 100644
index 0000000..ee1e429
--- /dev/null
+++ b/contrib/test/tensor_math.cpp
@@ -0,0 +1,43 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_tanh() {
+  Tensor<float, 1> vec1(6);
+  vec1.setRandom();
+
+  Tensor<float, 1> vec2 = vec1.tanh();
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_APPROX(vec2(i), tanhf(vec1(i)));
+  }
+}
+
+static void test_sigmoid() {
+  Tensor<float, 1> vec1(6);
+  vec1.setRandom();
+
+  Tensor<float, 1> vec2 = vec1.sigmoid();
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_APPROX(vec2(i), 1.0f / (1.0f + std::exp(-vec1(i))));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_math) {
+  CALL_SUBTEST(test_tanh());
+  CALL_SUBTEST(test_sigmoid());
+}
diff --git a/contrib/test/tensor_math_sycl.cpp b/contrib/test/tensor_math_sycl.cpp
new file mode 100644
index 0000000..73e7859
--- /dev/null
+++ b/contrib/test/tensor_math_sycl.cpp
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_tanh_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 4;
+  IndexType sizeDim2 = 4;
+  IndexType sizeDim3 = 1;
+  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out_cpu(tensorRange);
+
+  in = in.random();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, in.data(), (in.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1.tanh();
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data2, (out.size()) * sizeof(DataType));
+
+  out_cpu = in.tanh();
+
+  for (int i = 0; i < in.size(); ++i) {
+    VERIFY_IS_APPROX(out(i), out_cpu(i));
+  }
+}
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_sigmoid_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 4;
+  IndexType sizeDim2 = 4;
+  IndexType sizeDim3 = 1;
+  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out_cpu(tensorRange);
+
+  in = in.random();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, in.data(), (in.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1.sigmoid();
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data2, (out.size()) * sizeof(DataType));
+
+  out_cpu = in.sigmoid();
+
+  for (int i = 0; i < in.size(); ++i) {
+    VERIFY_IS_APPROX(out(i), out_cpu(i));
+  }
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_computing_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_tanh_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_tanh_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_sigmoid_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_sigmoid_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_math_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_computing_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_computing_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_mixed_indices.cpp b/contrib/test/tensor_mixed_indices.cpp
new file mode 100644
index 0000000..6ab77cb
--- /dev/null
+++ b/contrib/test/tensor_mixed_indices.cpp
@@ -0,0 +1,54 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+static void test_simple() {
+  Tensor<float, 1, ColMajor> vec1(6);
+  Tensor<float, 1, ColMajor, int> vec2(6);
+
+  vec1(0) = 4.0;
+  vec2(0) = 0.0;
+  vec1(1) = 8.0;
+  vec2(1) = 1.0;
+  vec1(2) = 15.0;
+  vec2(2) = 2.0;
+  vec1(3) = 16.0;
+  vec2(3) = 3.0;
+  vec1(4) = 23.0;
+  vec2(4) = 4.0;
+  vec1(5) = 42.0;
+  vec2(5) = 5.0;
+
+  float data3[6];
+  TensorMap<Tensor<float, 1, ColMajor>> vec3(data3, 6);
+  vec3 = vec1.sqrt();
+  float data4[6];
+  TensorMap<Tensor<float, 1, ColMajor, int>> vec4(data4, 6);
+  vec4 = vec2.square();
+
+  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
+  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
+  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0));
+  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0));
+  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
+  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
+
+  VERIFY_IS_APPROX(vec4(0), 0.0f);
+  VERIFY_IS_APPROX(vec4(1), 1.0f);
+  VERIFY_IS_APPROX(vec4(2), 2.0f * 2.0f);
+  VERIFY_IS_APPROX(vec4(3), 3.0f * 3.0f);
+  VERIFY_IS_APPROX(vec4(4), 4.0f * 4.0f);
+  VERIFY_IS_APPROX(vec4(5), 5.0f * 5.0f);
+}
+
+EIGEN_DECLARE_TEST(tensor_mixed_indices) { CALL_SUBTEST(test_simple()); }
diff --git a/contrib/test/tensor_morphing.cpp b/contrib/test/tensor_morphing.cpp
new file mode 100644
index 0000000..6f0cbfb
--- /dev/null
+++ b/contrib/test/tensor_morphing.cpp
@@ -0,0 +1,672 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename>
+static void test_simple_reshape() {
+  Tensor<float, 5> tensor1(2, 3, 1, 7, 1);
+  tensor1.setRandom();
+
+  Tensor<float, 3> tensor2(2, 3, 7);
+  Tensor<float, 2> tensor3(6, 7);
+  Tensor<float, 2> tensor4(2, 21);
+
+  Tensor<float, 3>::Dimensions dim1(2, 3, 7);
+  tensor2 = tensor1.reshape(dim1);
+  Tensor<float, 2>::Dimensions dim2(6, 7);
+  tensor3 = tensor1.reshape(dim2);
+  Tensor<float, 2>::Dimensions dim3(2, 21);
+  tensor4 = tensor1.reshape(dim1).reshape(dim3);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor2(i, j, k));
+        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor3(i + 2 * j, k));
+        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor4(i, j + 3 * k));
+      }
+    }
+  }
+}
+
+template <typename>
+static void test_static_reshape() {
+  using Eigen::type2index;
+
+  Tensor<float, 5> tensor(2, 3, 1, 7, 1);
+  tensor.setRandom();
+
+  // New dimensions: [2, 3, 7]
+  Eigen::IndexList<type2index<2>, type2index<3>, type2index<7>> dim;
+  Tensor<float, 3> reshaped = tensor.reshape(static_cast<Eigen::DSizes<ptrdiff_t, 3>>(dim));
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor(i, j, 0, k, 0), reshaped(i, j, k));
+      }
+    }
+  }
+}
+
+template <typename>
+static void test_reshape_in_expr() {
+  // The TensorMaps below alias the matrix data as default-layout (col-major)
+  // tensors, so pin the matrices to ColMajor: MatrixXf would not match under
+  // EIGEN_DEFAULT_TO_ROW_MAJOR.
+  typedef Matrix<float, Dynamic, Dynamic, ColMajor> Mtx;
+  Mtx m1(2, 3 * 5 * 7 * 11);
+  Mtx m2(3 * 5 * 7 * 11, 13);
+  m1.setRandom();
+  m2.setRandom();
+  Mtx m3 = m1 * m2;
+
+  TensorMap<Tensor<float, 5>> tensor1(m1.data(), 2, 3, 5, 7, 11);
+  TensorMap<Tensor<float, 5>> tensor2(m2.data(), 3, 5, 7, 11, 13);
+  Tensor<float, 2>::Dimensions newDims1(2, 3 * 5 * 7 * 11);
+  Tensor<float, 2>::Dimensions newDims2(3 * 5 * 7 * 11, 13);
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  array<DimPair, 1> contract_along{{DimPair(1, 0)}};
+  Tensor<float, 2> tensor3(2, 13);
+  tensor3 = tensor1.reshape(newDims1).contract(tensor2.reshape(newDims2), contract_along);
+
+  Map<Mtx> res(tensor3.data(), 2, 13);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 13; ++j) {
+      VERIFY_IS_APPROX(res(i, j), m3(i, j));
+    }
+  }
+}
+
+template <typename>
+static void test_reshape_as_lvalue() {
+  Tensor<float, 3> tensor(2, 3, 7);
+  tensor.setRandom();
+
+  Tensor<float, 2> tensor2d(6, 7);
+  Tensor<float, 3>::Dimensions dim(2, 3, 7);
+  tensor2d.reshape(dim) = tensor;
+
+  float scratch[2 * 3 * 1 * 7 * 1];
+  TensorMap<Tensor<float, 5>> tensor5d(scratch, 2, 3, 1, 7, 1);
+  tensor5d.reshape(dim).device(Eigen::DefaultDevice()) = tensor;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor2d(i + 2 * j, k), tensor(i, j, k));
+        VERIFY_IS_EQUAL(tensor5d(i, j, 0, k, 0), tensor(i, j, k));
+      }
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_simple_slice() {
+  Tensor<T, 5, DataLayout> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+
+  Tensor<T, 5, DataLayout> slice1(1, 1, 1, 1, 1);
+  Eigen::DSizes<ptrdiff_t, 5> indices(1, 2, 3, 4, 5);
+  Eigen::DSizes<ptrdiff_t, 5> sizes(1, 1, 1, 1, 1);
+  slice1 = tensor.slice(indices, sizes);
+  VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
+
+  Tensor<T, 5, DataLayout> slice2(1, 1, 2, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 5> indices2(1, 1, 3, 4, 5);
+  Eigen::DSizes<ptrdiff_t, 5> sizes2(1, 1, 2, 2, 3);
+  slice2 = tensor.slice(indices2, sizes2);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        VERIFY_IS_EQUAL(slice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
+      }
+    }
+  }
+}
+
+template <typename T>
+static void test_const_slice() {
+  const T b[1] = {42};
+  TensorMap<Tensor<const T, 1>> m(b, 1);
+  DSizes<DenseIndex, 1> offsets;
+  offsets[0] = 0;
+  TensorRef<const Tensor<const T, 1>> slice_ref(m.slice(offsets, m.dimensions()));
+  VERIFY_IS_EQUAL(slice_ref(0), 42);
+}
+
+template <typename T, int DataLayout>
+static void test_slice_in_expr() {
+  typedef Matrix<T, Dynamic, Dynamic, DataLayout> Mtx;
+  Mtx m1(7, 7);
+  Mtx m2(3, 3);
+  m1.setRandom();
+  m2.setRandom();
+
+  Mtx m3 = m1.block(1, 2, 3, 3) * m2.block(0, 2, 3, 1);
+
+  TensorMap<Tensor<T, 2, DataLayout>> tensor1(m1.data(), 7, 7);
+  TensorMap<Tensor<T, 2, DataLayout>> tensor2(m2.data(), 3, 3);
+  Tensor<T, 2, DataLayout> tensor3(3, 1);
+  typedef typename Tensor<T, 1>::DimensionPair DimPair;
+  array<DimPair, 1> contract_along{{DimPair(1, 0)}};
+
+  Eigen::DSizes<ptrdiff_t, 2> indices1(1, 2);
+  Eigen::DSizes<ptrdiff_t, 2> sizes1(3, 3);
+  Eigen::DSizes<ptrdiff_t, 2> indices2(0, 2);
+  Eigen::DSizes<ptrdiff_t, 2> sizes2(3, 1);
+  tensor3 = tensor1.slice(indices1, sizes1).contract(tensor2.slice(indices2, sizes2), contract_along);
+
+  Map<Mtx> res(tensor3.data(), 3, 1);
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 1; ++j) {
+      VERIFY_IS_APPROX(res(i, j), m3(i, j));
+    }
+  }
+
+  // Take an arbitrary slice of an arbitrarily sized tensor.
+  TensorMap<Tensor<const T, 2, DataLayout>> tensor4(m1.data(), 7, 7);
+  Tensor<T, 1, DataLayout> tensor6 =
+      tensor4.reshape(DSizes<ptrdiff_t, 1>(7 * 7)).exp().slice(DSizes<ptrdiff_t, 1>(0), DSizes<ptrdiff_t, 1>(35));
+  for (int i = 0; i < 35; ++i) {
+    VERIFY_IS_APPROX(tensor6(i), expf(tensor4.data()[i]));
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_slice_as_lvalue() {
+  Tensor<T, 3, DataLayout> tensor1(2, 2, 7);
+  tensor1.setRandom();
+  Tensor<T, 3, DataLayout> tensor2(2, 2, 7);
+  tensor2.setRandom();
+  Tensor<T, 3, DataLayout> tensor3(4, 3, 5);
+  tensor3.setRandom();
+  Tensor<T, 3, DataLayout> tensor4(4, 3, 2);
+  tensor4.setRandom();
+  Tensor<T, 3, DataLayout> tensor5(10, 13, 12);
+  tensor5.setRandom();
+
+  Tensor<T, 3, DataLayout> result(4, 5, 7);
+  Eigen::DSizes<ptrdiff_t, 3> sizes12(2, 2, 7);
+  Eigen::DSizes<ptrdiff_t, 3> first_slice(0, 0, 0);
+  result.slice(first_slice, sizes12) = tensor1;
+  Eigen::DSizes<ptrdiff_t, 3> second_slice(2, 0, 0);
+  result.slice(second_slice, sizes12).device(Eigen::DefaultDevice()) = tensor2;
+
+  Eigen::DSizes<ptrdiff_t, 3> sizes3(4, 3, 5);
+  Eigen::DSizes<ptrdiff_t, 3> third_slice(0, 2, 0);
+  result.slice(third_slice, sizes3) = tensor3;
+
+  Eigen::DSizes<ptrdiff_t, 3> sizes4(4, 3, 2);
+  Eigen::DSizes<ptrdiff_t, 3> fourth_slice(0, 2, 5);
+  result.slice(fourth_slice, sizes4) = tensor4;
+
+  for (int j = 0; j < 2; ++j) {
+    for (int k = 0; k < 7; ++k) {
+      for (int i = 0; i < 2; ++i) {
+        VERIFY_IS_EQUAL(result(i, j, k), tensor1(i, j, k));
+        VERIFY_IS_EQUAL(result(i + 2, j, k), tensor2(i, j, k));
+      }
+    }
+  }
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 2; j < 5; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        VERIFY_IS_EQUAL(result(i, j, k), tensor3(i, j - 2, k));
+      }
+      for (int k = 5; k < 7; ++k) {
+        VERIFY_IS_EQUAL(result(i, j, k), tensor4(i, j - 2, k - 5));
+      }
+    }
+  }
+
+  Eigen::DSizes<ptrdiff_t, 3> sizes5(4, 5, 7);
+  Eigen::DSizes<ptrdiff_t, 3> fifth_slice(0, 0, 0);
+  result.slice(fifth_slice, sizes5) = tensor5.slice(fifth_slice, sizes5);
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 2; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(result(i, j, k), tensor5(i, j, k));
+      }
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_slice_raw_data() {
+  Tensor<T, 4, DataLayout> tensor(3, 5, 7, 11);
+  tensor.setRandom();
+
+  Eigen::DSizes<ptrdiff_t, 4> offsets(1, 2, 3, 4);
+  Eigen::DSizes<ptrdiff_t, 4> extents(1, 1, 1, 1);
+  typedef TensorEvaluator<decltype(tensor.slice(offsets, extents)), DefaultDevice> SliceEvaluator;
+  auto slice1 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+  VERIFY_IS_EQUAL(slice1.dimensions().TotalSize(), 1);
+  VERIFY_IS_EQUAL(slice1.data()[0], tensor(1, 2, 3, 4));
+
+  if (DataLayout == ColMajor) {
+    extents = Eigen::DSizes<ptrdiff_t, 4>(2, 1, 1, 1);
+    auto slice2 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+    VERIFY_IS_EQUAL(slice2.dimensions().TotalSize(), 2);
+    VERIFY_IS_EQUAL(slice2.data()[0], tensor(1, 2, 3, 4));
+    VERIFY_IS_EQUAL(slice2.data()[1], tensor(2, 2, 3, 4));
+  } else {
+    extents = Eigen::DSizes<ptrdiff_t, 4>(1, 1, 1, 2);
+    auto slice2 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+    VERIFY_IS_EQUAL(slice2.dimensions().TotalSize(), 2);
+    VERIFY_IS_EQUAL(slice2.data()[0], tensor(1, 2, 3, 4));
+    VERIFY_IS_EQUAL(slice2.data()[1], tensor(1, 2, 3, 5));
+  }
+
+  extents = Eigen::DSizes<ptrdiff_t, 4>(1, 2, 1, 1);
+  auto slice3 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+  VERIFY_IS_EQUAL(slice3.dimensions().TotalSize(), 2);
+  VERIFY_IS_EQUAL(slice3.data(), static_cast<T*>(0));
+
+  if (DataLayout == ColMajor) {
+    offsets = Eigen::DSizes<ptrdiff_t, 4>(0, 2, 3, 4);
+    extents = Eigen::DSizes<ptrdiff_t, 4>(3, 2, 1, 1);
+    auto slice4 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+    VERIFY_IS_EQUAL(slice4.dimensions().TotalSize(), 6);
+    for (int i = 0; i < 3; ++i) {
+      for (int j = 0; j < 2; ++j) {
+        VERIFY_IS_EQUAL(slice4.data()[i + 3 * j], tensor(i, 2 + j, 3, 4));
+      }
+    }
+  } else {
+    offsets = Eigen::DSizes<ptrdiff_t, 4>(1, 2, 3, 0);
+    extents = Eigen::DSizes<ptrdiff_t, 4>(1, 1, 2, 11);
+    auto slice4 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+    VERIFY_IS_EQUAL(slice4.dimensions().TotalSize(), 22);
+    for (int l = 0; l < 11; ++l) {
+      for (int k = 0; k < 2; ++k) {
+        VERIFY_IS_EQUAL(slice4.data()[l + 11 * k], tensor(1, 2, 3 + k, l));
+      }
+    }
+  }
+
+  if (DataLayout == ColMajor) {
+    offsets = Eigen::DSizes<ptrdiff_t, 4>(0, 0, 0, 4);
+    extents = Eigen::DSizes<ptrdiff_t, 4>(3, 5, 7, 2);
+    auto slice5 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+    VERIFY_IS_EQUAL(slice5.dimensions().TotalSize(), 210);
+    for (int i = 0; i < 3; ++i) {
+      for (int j = 0; j < 5; ++j) {
+        for (int k = 0; k < 7; ++k) {
+          for (int l = 0; l < 2; ++l) {
+            int slice_index = i + 3 * (j + 5 * (k + 7 * l));
+            VERIFY_IS_EQUAL(slice5.data()[slice_index], tensor(i, j, k, l + 4));
+          }
+        }
+      }
+    }
+  } else {
+    offsets = Eigen::DSizes<ptrdiff_t, 4>(1, 0, 0, 0);
+    extents = Eigen::DSizes<ptrdiff_t, 4>(2, 5, 7, 11);
+    auto slice5 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+    VERIFY_IS_EQUAL(slice5.dimensions().TotalSize(), 770);
+    for (int l = 0; l < 11; ++l) {
+      for (int k = 0; k < 7; ++k) {
+        for (int j = 0; j < 5; ++j) {
+          for (int i = 0; i < 2; ++i) {
+            int slice_index = l + 11 * (k + 7 * (j + 5 * i));
+            VERIFY_IS_EQUAL(slice5.data()[slice_index], tensor(i + 1, j, k, l));
+          }
+        }
+      }
+    }
+  }
+
+  offsets = Eigen::DSizes<ptrdiff_t, 4>(0, 0, 0, 0);
+  extents = Eigen::DSizes<ptrdiff_t, 4>(3, 5, 7, 11);
+  auto slice6 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
+  VERIFY_IS_EQUAL(slice6.dimensions().TotalSize(), 3 * 5 * 7 * 11);
+  VERIFY_IS_EQUAL(slice6.data(), tensor.data());
+}
+
+template <typename T, int DataLayout>
+static void test_strided_slice() {
+  typedef Tensor<T, 5, DataLayout> Tensor5f;
+  typedef Eigen::DSizes<Eigen::DenseIndex, 5> Index5;
+  typedef Tensor<T, 2, DataLayout> Tensor2f;
+  typedef Eigen::DSizes<Eigen::DenseIndex, 2> Index2;
+  Tensor<T, 5, DataLayout> tensor(2, 3, 5, 7, 11);
+  Tensor<T, 2, DataLayout> tensor2(7, 11);
+  tensor.setRandom();
+  tensor2.setRandom();
+
+  if (true) {
+    Tensor2f slice(2, 3);
+    Index2 strides(-2, -1);
+    Index2 indicesStart(5, 7);
+    Index2 indicesStop(0, 4);
+    slice = tensor2.stridedSlice(indicesStart, indicesStop, strides);
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        VERIFY_IS_EQUAL(slice(j, k), tensor2(5 - 2 * j, 7 - k));
+      }
+    }
+  }
+
+  if (true) {
+    Tensor2f slice(0, 1);
+    Index2 strides(1, 1);
+    Index2 indicesStart(5, 4);
+    Index2 indicesStop(5, 5);
+    slice = tensor2.stridedSlice(indicesStart, indicesStop, strides);
+  }
+
+  if (true) {  // test clamped degenerate interavls
+    Tensor2f slice(7, 11);
+    Index2 strides(1, -1);
+    Index2 indicesStart(-3, 20);  // should become 0,10
+    Index2 indicesStop(20, -11);  // should become 11, -1
+    slice = tensor2.stridedSlice(indicesStart, indicesStop, strides);
+    for (int j = 0; j < 7; ++j) {
+      for (int k = 0; k < 11; ++k) {
+        VERIFY_IS_EQUAL(slice(j, k), tensor2(j, 10 - k));
+      }
+    }
+  }
+
+  if (true) {
+    Tensor5f slice1(1, 1, 1, 1, 1);
+    Eigen::DSizes<Eigen::DenseIndex, 5> indicesStart(1, 2, 3, 4, 5);
+    Eigen::DSizes<Eigen::DenseIndex, 5> indicesStop(2, 3, 4, 5, 6);
+    Eigen::DSizes<Eigen::DenseIndex, 5> strides(1, 1, 1, 1, 1);
+    slice1 = tensor.stridedSlice(indicesStart, indicesStop, strides);
+    VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
+  }
+
+  if (true) {
+    Tensor5f slice(1, 1, 2, 2, 3);
+    Index5 start(1, 1, 3, 4, 5);
+    Index5 stop(2, 2, 5, 6, 8);
+    Index5 strides(1, 1, 1, 1, 1);
+    slice = tensor.stridedSlice(start, stop, strides);
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 2; ++j) {
+        for (int k = 0; k < 3; ++k) {
+          VERIFY_IS_EQUAL(slice(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
+        }
+      }
+    }
+  }
+
+  if (true) {
+    Tensor5f slice(1, 1, 2, 2, 3);
+    Index5 strides3(1, 1, -2, 1, -1);
+    Index5 indices3Start(1, 1, 4, 4, 7);
+    Index5 indices3Stop(2, 2, 0, 6, 4);
+    slice = tensor.stridedSlice(indices3Start, indices3Stop, strides3);
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 2; ++j) {
+        for (int k = 0; k < 3; ++k) {
+          VERIFY_IS_EQUAL(slice(0, 0, i, j, k), tensor(1, 1, 4 - 2 * i, 4 + j, 7 - k));
+        }
+      }
+    }
+  }
+
+  if (false) {  // tests degenerate interval
+    Tensor5f slice(1, 1, 2, 2, 3);
+    Index5 strides3(1, 1, 2, 1, 1);
+    Index5 indices3Start(1, 1, 4, 4, 7);
+    Index5 indices3Stop(2, 2, 0, 6, 4);
+    slice = tensor.stridedSlice(indices3Start, indices3Stop, strides3);
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_strided_slice_write() {
+  typedef Tensor<T, 2, DataLayout> Tensor2f;
+  typedef Eigen::DSizes<Eigen::DenseIndex, 2> Index2;
+
+  Tensor<T, 2, DataLayout> tensor(7, 11), tensor2(7, 11);
+  tensor.setRandom();
+  tensor2 = tensor;
+  Tensor2f slice(2, 3);
+
+  slice.setRandom();
+
+  Index2 strides(1, 1);
+  Index2 indicesStart(3, 4);
+  Index2 indicesStop(5, 7);
+  Index2 lengths(2, 3);
+
+  tensor.slice(indicesStart, lengths) = slice;
+  tensor2.stridedSlice(indicesStart, indicesStop, strides) = slice;
+
+  for (int i = 0; i < 7; i++)
+    for (int j = 0; j < 11; j++) {
+      VERIFY_IS_EQUAL(tensor(i, j), tensor2(i, j));
+    }
+}
+
+template <typename T, int DataLayout>
+static void test_strided_slice_packet_access() {
+  typedef Tensor<T, 2, DataLayout> Tensor2;
+  typedef Eigen::DSizes<Eigen::DenseIndex, 2> Index2;
+
+  // The strided-slice evaluators forward the nested evaluator's packet
+  // access; the packet methods below are exercised through the executor.
+  typedef Eigen::TensorStridingSlicingOp<const Index2, const Index2, const Index2, const Tensor2> SliceOp;
+  typedef TensorEvaluator<const SliceOp, DefaultDevice> SliceEval;
+  typedef TensorEvaluator<const Tensor2, DefaultDevice> ArgEval;
+  static_assert(int(SliceEval::PacketAccess) == int(ArgEval::PacketAccess),
+                "strided slice must forward the nested evaluator's packet access");
+
+  // Sizes with partial-packet tails for every packet size in use.
+  Tensor2 tensor(31, 37);
+  tensor.setRandom();
+
+  // Stride patterns covering, in each storage order: the identity fast path,
+  // contiguous inner loads, reversed (-1) inner loads, and the non-unit and
+  // boundary-crossing gather fallback.
+  const Eigen::DenseIndex stride_patterns[][2] = {{1, 1}, {1, 2}, {2, 1}, {-1, 1}, {1, -1}, {-2, 3}, {3, -2}, {-1, -1}};
+
+  for (const auto& sp : stride_patterns) {
+    const Index2 strides(sp[0], sp[1]);
+    const Index2 start(sp[0] > 0 ? 1 : 29, sp[1] > 0 ? 2 : 35);
+    const Index2 stop(sp[0] > 0 ? 30 : 0, sp[1] > 0 ? 36 : 1);
+
+    // Reads through the packet path.
+    Tensor2 slice = tensor.stridedSlice(start, stop, strides);
+    for (Eigen::DenseIndex i = 0; i < slice.dimension(0); ++i) {
+      for (Eigen::DenseIndex j = 0; j < slice.dimension(1); ++j) {
+        VERIFY_IS_EQUAL(slice(i, j), tensor(start[0] + i * strides[0], start[1] + j * strides[1]));
+      }
+    }
+
+    // Expression-sourced reads (no direct data access in the argument).
+    Tensor2 expr_slice = (tensor * tensor.constant(T(2))).stridedSlice(start, stop, strides);
+    for (Eigen::DenseIndex i = 0; i < expr_slice.dimension(0); ++i) {
+      for (Eigen::DenseIndex j = 0; j < expr_slice.dimension(1); ++j) {
+        VERIFY_IS_EQUAL(expr_slice(i, j), T(2) * tensor(start[0] + i * strides[0], start[1] + j * strides[1]));
+      }
+    }
+
+    // Writes through the packet path, against a scalar-loop reference.
+    Tensor2 dst_ref = tensor;
+    Tensor2 dst = tensor;
+    Tensor2 src(slice.dimension(0), slice.dimension(1));
+    src.setRandom();
+    dst.stridedSlice(start, stop, strides) = src;
+    for (Eigen::DenseIndex i = 0; i < src.dimension(0); ++i) {
+      for (Eigen::DenseIndex j = 0; j < src.dimension(1); ++j) {
+        dst_ref(start[0] + i * strides[0], start[1] + j * strides[1]) = src(i, j);
+      }
+    }
+    for (Eigen::DenseIndex i = 0; i < dst.dimension(0); ++i) {
+      for (Eigen::DenseIndex j = 0; j < dst.dimension(1); ++j) {
+        VERIFY_IS_EQUAL(dst(i, j), dst_ref(i, j));
+      }
+    }
+  }
+
+  // Full-range unit-stride slice: the identity fast path.
+  {
+    const Eigen::array<Eigen::DenseIndex, 2> strides = {{1, 1}};
+    const Eigen::array<Eigen::DenseIndex, 2> start = {{0, 0}};
+    const Eigen::array<Eigen::DenseIndex, 2> stop = {{31, 37}};
+    Tensor2 slice = tensor.stridedSlice(start, stop, strides);
+    Tensor2 destination(31, 37);
+    destination.setZero();
+    destination.stridedSlice(start, stop, strides) = tensor;
+    for (Eigen::DenseIndex i = 0; i < 31; ++i) {
+      for (Eigen::DenseIndex j = 0; j < 37; ++j) {
+        VERIFY_IS_EQUAL(slice(i, j), tensor(i, j));
+        VERIFY_IS_EQUAL(destination(i, j), tensor(i, j));
+      }
+    }
+  }
+}
+
+template <typename = void>
+static void test_strided_slice_packet_cost() {
+  typedef Tensor<float, 2> Tensor2;
+  typedef Eigen::DSizes<Eigen::DenseIndex, 2> Index2;
+
+  Tensor2 tensor(32, 32);
+  tensor.setRandom();
+  const Index2 start(0, 0);
+  const Index2 stop(32, 32);
+  const Index2 strides(2, 2);
+  auto expression = tensor.exp();
+  auto slice = expression.stridedSlice(start, stop, strides);
+
+  DefaultDevice device;
+  TensorEvaluator<const decltype(expression), DefaultDevice> expression_evaluator(expression, device);
+  TensorEvaluator<const decltype(slice), DefaultDevice> slice_evaluator(slice, device);
+  const TensorOpCost scalar_expression_cost = expression_evaluator.costPerCoeff(false);
+  const TensorOpCost packet_slice_cost = slice_evaluator.costPerCoeff(true);
+
+  // A gathered packet evaluates the nested expression coefficient by
+  // coefficient and must not receive the nested evaluator's packet discount.
+  VERIFY(packet_slice_cost.compute_cycles() >= scalar_expression_cost.compute_cycles());
+}
+
+template <typename T, int DataLayout>
+static void test_composition() {
+  Eigen::Tensor<T, 2, DataLayout> matrix(7, 11);
+  matrix.setRandom();
+
+  const DSizes<ptrdiff_t, 3> newDims(1, 1, 11);
+  Eigen::Tensor<T, 3, DataLayout> tensor =
+      matrix.slice(DSizes<ptrdiff_t, 2>(2, 0), DSizes<ptrdiff_t, 2>(1, 11)).reshape(newDims);
+
+  VERIFY_IS_EQUAL(tensor.dimensions().TotalSize(), 11);
+  VERIFY_IS_EQUAL(tensor.dimension(0), 1);
+  VERIFY_IS_EQUAL(tensor.dimension(1), 1);
+  VERIFY_IS_EQUAL(tensor.dimension(2), 11);
+  for (int i = 0; i < 11; ++i) {
+    VERIFY_IS_EQUAL(tensor(0, 0, i), matrix(2, i));
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_empty_slice() {
+  Tensor<T, 3, DataLayout> tensor(2, 3, 5);
+  tensor.setRandom();
+  Tensor<T, 3, DataLayout> copy = tensor;
+
+  // empty size in first dimension
+  Eigen::DSizes<ptrdiff_t, 3> indices1(1, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 3> sizes1(0, 1, 2);
+  Tensor<T, 3, DataLayout> slice1(0, 1, 2);
+  slice1.setRandom();
+  tensor.slice(indices1, sizes1) = slice1;
+
+  // empty size in second dimension
+  Eigen::DSizes<ptrdiff_t, 3> indices2(1, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 3> sizes2(1, 0, 2);
+  Tensor<T, 3, DataLayout> slice2(1, 0, 2);
+  slice2.setRandom();
+  tensor.slice(indices2, sizes2) = slice2;
+
+  // empty size in third dimension
+  Eigen::DSizes<ptrdiff_t, 3> indices3(1, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 3> sizes3(1, 1, 0);
+  Tensor<T, 3, DataLayout> slice3(1, 1, 0);
+  slice3.setRandom();
+  tensor.slice(indices3, sizes3) = slice3;
+
+  // empty size in first and second dimension
+  Eigen::DSizes<ptrdiff_t, 3> indices4(1, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 3> sizes4(0, 0, 2);
+  Tensor<T, 3, DataLayout> slice4(0, 0, 2);
+  slice4.setRandom();
+  tensor.slice(indices4, sizes4) = slice4;
+
+  // empty size in second and third dimension
+  Eigen::DSizes<ptrdiff_t, 3> indices5(1, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 3> sizes5(1, 0, 0);
+  Tensor<T, 3, DataLayout> slice5(1, 0, 0);
+  slice5.setRandom();
+  tensor.slice(indices5, sizes5) = slice5;
+
+  // empty size in all dimensions
+  Eigen::DSizes<ptrdiff_t, 3> indices6(1, 2, 3);
+  Eigen::DSizes<ptrdiff_t, 3> sizes6(0, 0, 0);
+  Tensor<T, 3, DataLayout> slice6(0, 0, 0);
+  slice6.setRandom();
+  tensor.slice(indices6, sizes6) = slice6;
+
+  // none of these operations should change the tensor's components
+  // because all of the rvalue slices have at least one zero dimension
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        VERIFY_IS_EQUAL(tensor(i, j, k), copy(i, j, k));
+      }
+    }
+  }
+}
+
+#define CALL_SUBTEST_PART(PART) CALL_SUBTEST_##PART
+
+#define CALL_SUBTESTS_TYPES_LAYOUTS(PART, NAME)       \
+  CALL_SUBTEST_PART(PART)((NAME<float, ColMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<float, RowMajor>())); \
+  CALL_SUBTEST_PART(PART)((NAME<bool, ColMajor>()));  \
+  CALL_SUBTEST_PART(PART)((NAME<bool, RowMajor>()))
+
+// The type/layout sweeps reach CALL_SUBTEST_N through CALL_SUBTESTS_TYPES_LAYOUTS,
+// which the configure-time suffix scan cannot see; list the parts explicitly.
+// EIGEN_SUFFIXES;1;2;3;4;5;6;7;8
+EIGEN_DECLARE_TEST(tensor_morphing) {
+  CALL_SUBTEST_1(test_simple_reshape<void>());
+  CALL_SUBTEST_1(test_static_reshape<void>());
+  CALL_SUBTEST_1(test_reshape_as_lvalue<void>());
+  CALL_SUBTEST_1(test_reshape_in_expr<void>());
+  CALL_SUBTEST_1(test_const_slice<float>());
+  // test_slice_in_expr uses a matrix product, so it cannot join the
+  // bool-sweeping CALL_SUBTESTS_TYPES_LAYOUTS batches below.
+  CALL_SUBTEST_1((test_slice_in_expr<float, ColMajor>()));
+  CALL_SUBTEST_1((test_slice_in_expr<float, RowMajor>()));
+
+  CALL_SUBTESTS_TYPES_LAYOUTS(2, test_simple_slice);
+  CALL_SUBTESTS_TYPES_LAYOUTS(3, test_slice_as_lvalue);
+  CALL_SUBTESTS_TYPES_LAYOUTS(4, test_slice_raw_data);
+  CALL_SUBTESTS_TYPES_LAYOUTS(5, test_strided_slice_write);
+  CALL_SUBTESTS_TYPES_LAYOUTS(6, test_strided_slice);
+  CALL_SUBTESTS_TYPES_LAYOUTS(7, test_composition);
+
+  CALL_SUBTEST_8((test_strided_slice_packet_access<float, ColMajor>()));
+  CALL_SUBTEST_8((test_strided_slice_packet_access<float, RowMajor>()));
+  CALL_SUBTEST_8((test_strided_slice_packet_access<double, ColMajor>()));
+  CALL_SUBTEST_8((test_strided_slice_packet_access<double, RowMajor>()));
+  CALL_SUBTEST_8(test_strided_slice_packet_cost<>());
+}
diff --git a/contrib/test/tensor_morphing_sycl.cpp b/contrib/test/tensor_morphing_sycl.cpp
new file mode 100644
index 0000000..a012614
--- /dev/null
+++ b/contrib/test/tensor_morphing_sycl.cpp
@@ -0,0 +1,386 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_reshape(const Eigen::SyclDevice& sycl_device) {
+  typename Tensor<DataType, 5, DataLayout, IndexType>::Dimensions dim1(2, 3, 1, 7, 1);
+  typename Tensor<DataType, 3, DataLayout, IndexType>::Dimensions dim2(2, 3, 7);
+  typename Tensor<DataType, 2, DataLayout, IndexType>::Dimensions dim3(6, 7);
+  typename Tensor<DataType, 2, DataLayout, IndexType>::Dimensions dim4(2, 21);
+
+  Tensor<DataType, 5, DataLayout, IndexType> tensor1(dim1);
+  Tensor<DataType, 3, DataLayout, IndexType> tensor2(dim2);
+  Tensor<DataType, 2, DataLayout, IndexType> tensor3(dim3);
+  Tensor<DataType, 2, DataLayout, IndexType> tensor4(dim4);
+
+  tensor1.setRandom();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
+  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(tensor3.size() * sizeof(DataType)));
+  DataType* gpu_data4 = static_cast<DataType*>(sycl_device.allocate(tensor4.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu1(gpu_data1, dim1);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, dim2);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu3(gpu_data3, dim3);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu4(gpu_data4, dim4);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
+
+  gpu2.device(sycl_device) = gpu1.reshape(dim2);
+  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor1.size()) * sizeof(DataType));
+
+  gpu3.device(sycl_device) = gpu1.reshape(dim3);
+  sycl_device.memcpyDeviceToHost(tensor3.data(), gpu_data3, (tensor3.size()) * sizeof(DataType));
+
+  gpu4.device(sycl_device) = gpu1.reshape(dim2).reshape(dim4);
+  sycl_device.memcpyDeviceToHost(tensor4.data(), gpu_data4, (tensor4.size()) * sizeof(DataType));
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor2(i, j, k));  /// ColMajor
+        if (static_cast<int>(DataLayout) == static_cast<int>(ColMajor)) {
+          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor3(i + 2 * j, k));  /// ColMajor
+          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor4(i, j + 3 * k));  /// ColMajor
+        } else {
+          // VERIFY_IS_EQUAL(tensor1(i,j,0,k,0), tensor2(i,j,k));      /// RowMajor
+          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor4(i, j * 7 + k));  /// RowMajor
+          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor3(i * 3 + j, k));  /// RowMajor
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+  sycl_device.deallocate(gpu_data3);
+  sycl_device.deallocate(gpu_data4);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_reshape_as_lvalue(const Eigen::SyclDevice& sycl_device) {
+  typename Tensor<DataType, 3, DataLayout, IndexType>::Dimensions dim1(2, 3, 7);
+  typename Tensor<DataType, 2, DataLayout, IndexType>::Dimensions dim2(6, 7);
+  typename Tensor<DataType, 5, DataLayout, IndexType>::Dimensions dim3(2, 3, 1, 7, 1);
+  Tensor<DataType, 3, DataLayout, IndexType> tensor(dim1);
+  Tensor<DataType, 2, DataLayout, IndexType> tensor2d(dim2);
+  Tensor<DataType, 5, DataLayout, IndexType> tensor5d(dim3);
+
+  tensor.setRandom();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2d.size() * sizeof(DataType)));
+  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(tensor5d.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, dim1);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu2(gpu_data2, dim2);
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu3(gpu_data3, dim3);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
+
+  gpu2.reshape(dim1).device(sycl_device) = gpu1;
+  sycl_device.memcpyDeviceToHost(tensor2d.data(), gpu_data2, (tensor2d.size()) * sizeof(DataType));
+
+  gpu3.reshape(dim1).device(sycl_device) = gpu1;
+  sycl_device.memcpyDeviceToHost(tensor5d.data(), gpu_data3, (tensor5d.size()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(tensor5d(i, j, 0, k, 0), tensor(i, j, k));
+        if (static_cast<int>(DataLayout) == static_cast<int>(ColMajor)) {
+          VERIFY_IS_EQUAL(tensor2d(i + 2 * j, k), tensor(i, j, k));  /// ColMajor
+        } else {
+          VERIFY_IS_EQUAL(tensor2d(i * 3 + j, k), tensor(i, j, k));  /// RowMajor
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+  sycl_device.deallocate(gpu_data3);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_strided_slice_as_rhs_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  IndexType sizeDim5 = 11;
+  typedef Eigen::DSizes<IndexType, 5> Index5;
+  Index5 strides(1L, 1L, 1L, 1L, 1L);
+  Index5 indicesStart(1L, 2L, 3L, 4L, 5L);
+  Index5 indicesStop(2L, 3L, 4L, 5L, 6L);
+  Index5 lengths(1L, 1L, 1L, 1L, 1L);
+
+  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
+  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
+  tensor.setRandom();
+
+  array<IndexType, 5> slice1_range = {{1, 1, 1, 1, 1}};
+  Tensor<DataType, 5, DataLayout, IndexType> slice1(slice1_range);
+  Tensor<DataType, 5, DataLayout, IndexType> slice_stride1(slice1_range);
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(slice1.size() * sizeof(DataType)));
+  DataType* gpu_data_stride2 = static_cast<DataType*>(sycl_device.allocate(slice_stride1.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu2(gpu_data2, slice1_range);
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_stride2(gpu_data_stride2, slice1_range);
+
+  Eigen::DSizes<IndexType, 5> indices(1, 2, 3, 4, 5);
+  Eigen::DSizes<IndexType, 5> sizes(1, 1, 1, 1, 1);
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1.slice(indices, sizes);
+  sycl_device.memcpyDeviceToHost(slice1.data(), gpu_data2, (slice1.size()) * sizeof(DataType));
+
+  gpu_stride2.device(sycl_device) = gpu1.stridedSlice(indicesStart, indicesStop, strides);
+  sycl_device.memcpyDeviceToHost(slice_stride1.data(), gpu_data_stride2, (slice_stride1.size()) * sizeof(DataType));
+
+  VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
+  VERIFY_IS_EQUAL(slice_stride1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
+
+  array<IndexType, 5> slice2_range = {{1, 1, 2, 2, 3}};
+  Tensor<DataType, 5, DataLayout, IndexType> slice2(slice2_range);
+  Tensor<DataType, 5, DataLayout, IndexType> strideSlice2(slice2_range);
+
+  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(slice2.size() * sizeof(DataType)));
+  DataType* gpu_data_stride3 = static_cast<DataType*>(sycl_device.allocate(strideSlice2.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu3(gpu_data3, slice2_range);
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_stride3(gpu_data_stride3, slice2_range);
+  Eigen::DSizes<IndexType, 5> indices2(1, 1, 3, 4, 5);
+  Eigen::DSizes<IndexType, 5> sizes2(1, 1, 2, 2, 3);
+  Index5 strides2(1L, 1L, 1L, 1L, 1L);
+  Index5 indicesStart2(1L, 1L, 3L, 4L, 5L);
+  Index5 indicesStop2(2L, 2L, 5L, 6L, 8L);
+
+  gpu3.device(sycl_device) = gpu1.slice(indices2, sizes2);
+  sycl_device.memcpyDeviceToHost(slice2.data(), gpu_data3, (slice2.size()) * sizeof(DataType));
+
+  gpu_stride3.device(sycl_device) = gpu1.stridedSlice(indicesStart2, indicesStop2, strides2);
+  sycl_device.memcpyDeviceToHost(strideSlice2.data(), gpu_data_stride3, (strideSlice2.size()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 2; ++j) {
+      for (IndexType k = 0; k < 3; ++k) {
+        VERIFY_IS_EQUAL(slice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
+        VERIFY_IS_EQUAL(strideSlice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+  sycl_device.deallocate(gpu_data3);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_strided_slice_write_sycl(const Eigen::SyclDevice& sycl_device) {
+  typedef Tensor<DataType, 2, DataLayout, IndexType> Tensor2f;
+  typedef Eigen::DSizes<IndexType, 2> Index2;
+  IndexType sizeDim1 = 7L;
+  IndexType sizeDim2 = 11L;
+  array<IndexType, 2> tensorRange = {{sizeDim1, sizeDim2}};
+  Tensor<DataType, 2, DataLayout, IndexType> tensor(tensorRange), tensor2(tensorRange);
+  IndexType sliceDim1 = 2;
+  IndexType sliceDim2 = 3;
+  array<IndexType, 2> sliceRange = {{sliceDim1, sliceDim2}};
+  Tensor2f slice(sliceRange);
+  Index2 strides(1L, 1L);
+  Index2 indicesStart(3L, 4L);
+  Index2 indicesStop(5L, 7L);
+  Index2 lengths(2L, 3L);
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
+  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(slice.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu3(gpu_data3, sliceRange);
+
+  tensor.setRandom();
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1;
+
+  slice.setRandom();
+  sycl_device.memcpyHostToDevice(gpu_data3, slice.data(), (slice.size()) * sizeof(DataType));
+
+  gpu1.slice(indicesStart, lengths).device(sycl_device) = gpu3;
+  gpu2.stridedSlice(indicesStart, indicesStop, strides).device(sycl_device) = gpu3;
+  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data1, (tensor.size()) * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor2.size()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < sizeDim1; i++)
+    for (IndexType j = 0; j < sizeDim2; j++) {
+      VERIFY_IS_EQUAL(tensor(i, j), tensor2(i, j));
+    }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+  sycl_device.deallocate(gpu_data3);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_strided_slice_reverse_packet_sycl(const Eigen::SyclDevice& sycl_device) {
+  typedef Tensor<DataType, 2, DataLayout, IndexType> Tensor2;
+  typedef Eigen::DSizes<IndexType, 2> Index2;
+
+  const array<IndexType, 2> input_range = {{31, 37}};
+  const array<IndexType, 2> slice_range = {{29, 34}};
+  constexpr bool IsColMajor = static_cast<int>(DataLayout) == static_cast<int>(ColMajor);
+  const Index2 strides(IsColMajor ? -1 : 1, IsColMajor ? 1 : -1);
+  const Index2 start(IsColMajor ? 29 : 1, IsColMajor ? 2 : 35);
+  const Index2 stop(IsColMajor ? 0 : 30, IsColMajor ? 36 : 1);
+
+  Tensor2 input(input_range);
+  Tensor2 slice(slice_range);
+  Tensor2 src(slice_range);
+  Tensor2 dst(input_range);
+  Tensor2 dst_ref(input_range);
+  input.setRandom();
+  src.setRandom();
+  dst = input;
+  dst_ref = input;
+
+  DataType* gpu_input_data = static_cast<DataType*>(sycl_device.allocate(input.size() * sizeof(DataType)));
+  DataType* gpu_slice_data = static_cast<DataType*>(sycl_device.allocate(slice.size() * sizeof(DataType)));
+  DataType* gpu_dst_data = static_cast<DataType*>(sycl_device.allocate(dst.size() * sizeof(DataType)));
+  TensorMap<Tensor2> gpu_input(gpu_input_data, input_range);
+  TensorMap<Tensor2> gpu_slice(gpu_slice_data, slice_range);
+  TensorMap<Tensor2> gpu_dst(gpu_dst_data, input_range);
+
+  sycl_device.memcpyHostToDevice(gpu_input_data, input.data(), input.size() * sizeof(DataType));
+  gpu_slice.device(sycl_device) = gpu_input.stridedSlice(start, stop, strides);
+  sycl_device.memcpyDeviceToHost(slice.data(), gpu_slice_data, slice.size() * sizeof(DataType));
+  for (IndexType i = 0; i < slice.dimension(0); ++i) {
+    for (IndexType j = 0; j < slice.dimension(1); ++j) {
+      VERIFY_IS_EQUAL(slice(i, j), input(start[0] + i * strides[0], start[1] + j * strides[1]));
+    }
+  }
+
+  sycl_device.memcpyHostToDevice(gpu_slice_data, src.data(), src.size() * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_dst_data, dst.data(), dst.size() * sizeof(DataType));
+  gpu_dst.stridedSlice(start, stop, strides).device(sycl_device) = gpu_slice;
+  sycl_device.memcpyDeviceToHost(dst.data(), gpu_dst_data, dst.size() * sizeof(DataType));
+  for (IndexType i = 0; i < src.dimension(0); ++i) {
+    for (IndexType j = 0; j < src.dimension(1); ++j) {
+      dst_ref(start[0] + i * strides[0], start[1] + j * strides[1]) = src(i, j);
+    }
+  }
+  for (IndexType i = 0; i < dst.dimension(0); ++i) {
+    for (IndexType j = 0; j < dst.dimension(1); ++j) {
+      VERIFY_IS_EQUAL(dst(i, j), dst_ref(i, j));
+    }
+  }
+
+  sycl_device.deallocate(gpu_input_data);
+  sycl_device.deallocate(gpu_slice_data);
+  sycl_device.deallocate(gpu_dst_data);
+}
+
+template <typename OutIndex, typename DSizes>
+Eigen::array<OutIndex, DSizes::count> To32BitDims(const DSizes& in) {
+  Eigen::array<OutIndex, DSizes::count> out;
+  for (int i = 0; i < DSizes::count; ++i) {
+    out[i] = in[i];
+  }
+  return out;
+}
+
+template <class DataType, int DataLayout, typename IndexType, typename ConvertedIndexType>
+int run_eigen(const SyclDevice& sycl_device) {
+  using TensorI64 = Tensor<DataType, 5, DataLayout, IndexType>;
+  using TensorI32 = Tensor<DataType, 5, DataLayout, ConvertedIndexType>;
+  using TensorMI64 = TensorMap<TensorI64>;
+  using TensorMI32 = TensorMap<TensorI32>;
+  Eigen::array<IndexType, 5> tensor_range{{4, 1, 1, 1, 6}};
+  Eigen::array<IndexType, 5> slice_range{{4, 1, 1, 1, 3}};
+
+  TensorI64 out_tensor_gpu(tensor_range);
+  TensorI64 out_tensor_cpu(tensor_range);
+  out_tensor_cpu.setRandom();
+
+  TensorI64 sub_tensor(slice_range);
+  sub_tensor.setRandom();
+
+  DataType* out_gpu_data = static_cast<DataType*>(sycl_device.allocate(out_tensor_cpu.size() * sizeof(DataType)));
+  DataType* sub_gpu_data = static_cast<DataType*>(sycl_device.allocate(sub_tensor.size() * sizeof(DataType)));
+  TensorMI64 out_gpu(out_gpu_data, tensor_range);
+  TensorMI64 sub_gpu(sub_gpu_data, slice_range);
+
+  sycl_device.memcpyHostToDevice(out_gpu_data, out_tensor_cpu.data(), out_tensor_cpu.size() * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(sub_gpu_data, sub_tensor.data(), sub_tensor.size() * sizeof(DataType));
+
+  Eigen::array<ConvertedIndexType, 5> slice_offset_32{{0, 0, 0, 0, 3}};
+  Eigen::array<ConvertedIndexType, 5> slice_range_32{{4, 1, 1, 1, 3}};
+  TensorMI32 out_cpu_32(out_tensor_cpu.data(), To32BitDims<ConvertedIndexType>(out_tensor_cpu.dimensions()));
+  TensorMI32 sub_cpu_32(sub_tensor.data(), To32BitDims<ConvertedIndexType>(sub_tensor.dimensions()));
+  TensorMI32 out_gpu_32(out_gpu.data(), To32BitDims<ConvertedIndexType>(out_gpu.dimensions()));
+  TensorMI32 sub_gpu_32(sub_gpu.data(), To32BitDims<ConvertedIndexType>(sub_gpu.dimensions()));
+
+  out_gpu_32.slice(slice_offset_32, slice_range_32).device(sycl_device) = sub_gpu_32;
+
+  out_cpu_32.slice(slice_offset_32, slice_range_32) = sub_cpu_32;
+
+  sycl_device.memcpyDeviceToHost(out_tensor_gpu.data(), out_gpu_data, out_tensor_cpu.size() * sizeof(DataType));
+  int has_err = 0;
+  for (IndexType i = 0; i < out_tensor_cpu.size(); ++i) {
+    auto exp = out_tensor_cpu(i);
+    auto val = out_tensor_gpu(i);
+    if (val != exp) {
+      std::cout << "#" << i << " got " << val << " but expected " << exp << std::endl;
+      has_err = 1;
+    }
+  }
+  sycl_device.deallocate(out_gpu_data);
+  sycl_device.deallocate(sub_gpu_data);
+  return has_err;
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_morphing_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_reshape<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_reshape<DataType, ColMajor, int64_t>(sycl_device);
+  test_reshape_as_lvalue<DataType, RowMajor, int64_t>(sycl_device);
+  test_reshape_as_lvalue<DataType, ColMajor, int64_t>(sycl_device);
+  test_strided_slice_write_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_strided_slice_write_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_strided_slice_reverse_packet_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_strided_slice_reverse_packet_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_strided_slice_as_rhs_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_strided_slice_as_rhs_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  run_eigen<float, RowMajor, long, int>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_morphing_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_morphing_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_morphing_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_move.cpp b/contrib/test/tensor_move.cpp
new file mode 100644
index 0000000..03c3564
--- /dev/null
+++ b/contrib/test/tensor_move.cpp
@@ -0,0 +1,69 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Viktor Csomor <viktor.csomor@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+#include <utility>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void calc_indices(int i, int& x, int& y, int& z) {
+  x = i / 4;
+  y = (i % 4) / 2;
+  z = i % 2;
+}
+
+static void test_move() {
+  int x;
+  int y;
+  int z;
+
+  Tensor<int, 3> tensor1(2, 2, 2);
+  Tensor<int, 3, RowMajor> tensor2(2, 2, 2);
+
+  for (int i = 0; i < 8; i++) {
+    calc_indices(i, x, y, z);
+    tensor1(x, y, z) = i;
+    tensor2(x, y, z) = 2 * i;
+  }
+
+  // Invokes the move constructor.
+  Tensor<int, 3> moved_tensor1 = std::move(tensor1);
+  Tensor<int, 3, RowMajor> moved_tensor2 = std::move(tensor2);
+
+  VERIFY_IS_EQUAL(tensor1.size(), 0);
+  VERIFY_IS_EQUAL(tensor2.size(), 0);
+
+  for (int i = 0; i < 8; i++) {
+    calc_indices(i, x, y, z);
+    VERIFY_IS_EQUAL(moved_tensor1(x, y, z), i);
+    VERIFY_IS_EQUAL(moved_tensor2(x, y, z), 2 * i);
+  }
+
+  Tensor<int, 3> moved_tensor3(2, 2, 2);
+  Tensor<int, 3, RowMajor> moved_tensor4(2, 2, 2);
+
+  moved_tensor3.setZero();
+  moved_tensor4.setZero();
+
+  // Invokes the move assignment operator.
+  moved_tensor3 = std::move(moved_tensor1);
+  moved_tensor4 = std::move(moved_tensor2);
+
+  for (int i = 0; i < 8; i++) {
+    calc_indices(i, x, y, z);
+    VERIFY_IS_EQUAL(moved_tensor3(x, y, z), i);
+    VERIFY_IS_EQUAL(moved_tensor4(x, y, z), 2 * i);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_move) { CALL_SUBTEST(test_move()); }
diff --git a/contrib/test/tensor_notification.cpp b/contrib/test/tensor_notification.cpp
new file mode 100644
index 0000000..8090cd2
--- /dev/null
+++ b/contrib/test/tensor_notification.cpp
@@ -0,0 +1,68 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Vijay Vasudevan <vrv@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <atomic>
+
+#include <stdlib.h>
+#include "main.h"
+#include <Eigen/Tensor>
+
+static void test_notification_single() {
+  ThreadPool thread_pool(1);
+
+  std::atomic<int> counter(0);
+  Eigen::Notification n;
+  auto func = [&n, &counter]() {
+    n.Wait();
+    ++counter;
+  };
+  thread_pool.Schedule(func);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+  // The thread should be waiting for the notification.
+  VERIFY_IS_EQUAL(counter, 0);
+
+  // Unblock the thread
+  n.Notify();
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+  // Verify the counter has been incremented
+  VERIFY_IS_EQUAL(counter, 1);
+}
+
+// Like test_notification_single() but enqueues multiple threads to
+// validate that all threads get notified by Notify().
+static void test_notification_multiple() {
+  ThreadPool thread_pool(1);
+
+  std::atomic<int> counter(0);
+  Eigen::Notification n;
+  auto func = [&n, &counter]() {
+    n.Wait();
+    ++counter;
+  };
+  thread_pool.Schedule(func);
+  thread_pool.Schedule(func);
+  thread_pool.Schedule(func);
+  thread_pool.Schedule(func);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  VERIFY_IS_EQUAL(counter, 0);
+  n.Notify();
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  VERIFY_IS_EQUAL(counter, 4);
+}
+
+EIGEN_DECLARE_TEST(tensor_notification) {
+  CALL_SUBTEST(test_notification_single());
+  CALL_SUBTEST(test_notification_multiple());
+}
diff --git a/contrib/test/tensor_of_bfloat16_gpu.cu b/contrib/test/tensor_of_bfloat16_gpu.cu
new file mode 100644
index 0000000..fc1cc27
--- /dev/null
+++ b/contrib/test/tensor_of_bfloat16_gpu.cu
@@ -0,0 +1,474 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2021 Rohit Santhanam <rohit.santhanam@amd.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename>
+void test_gpu_numext() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  bool* d_res_bfloat16 = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
+  bool* d_res_float = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(gpu_device) = gpu_float.unaryExpr(Eigen::internal::scalar_isnan_op<float>());
+  // Test bfloat16 specific isnan op.
+  gpu_res_bfloat16.device(gpu_device) =
+      gpu_float.cast<Eigen::bfloat16>().unaryExpr(Eigen::internal::scalar_isnan_op<Eigen::bfloat16>());
+
+  Tensor<bool, 1> bfloat16_prec(num_elem);
+  Tensor<bool, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(bool));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(bool));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_EQUAL(full_prec(i), bfloat16_prec(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_bfloat16);
+  gpu_device.deallocate(d_res_float);
+}
+
+#ifdef EIGEN_HAS_GPU_BF16
+
+template <typename>
+void test_gpu_conversion() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::bfloat16* d_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  float* d_conv = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_bfloat16(d_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
+
+  gpu_float.device(gpu_device) = gpu_float.random();
+  gpu_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>();
+  gpu_conv.device(gpu_device) = gpu_bfloat16.cast<float>();
+
+  Tensor<float, 1> initial(num_elem);
+  Tensor<float, 1> final(num_elem);
+  gpu_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(static_cast<Eigen::bfloat16>(initial(i)), static_cast<Eigen::bfloat16>(final(i)));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_bfloat16);
+  gpu_device.deallocate(d_conv);
+}
+
+template <typename>
+void test_gpu_unary() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_bfloat16 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_float.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().cast<float>();
+  gpu_res_float.device(gpu_device) = gpu_float.abs();
+  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().abs().cast<float>();
+
+  Tensor<float, 1> bfloat16_prec(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_bfloat16);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_elementwise() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_bfloat16 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float1.device(gpu_device) = gpu_float1.random();
+  gpu_float1.device(gpu_device) = gpu_float1.cast<Eigen::bfloat16>().cast<float>();
+  gpu_float2.device(gpu_device) = gpu_float2.random();
+  gpu_float2.device(gpu_device) = gpu_float2.cast<Eigen::bfloat16>().cast<float>();
+  gpu_res_float.device(gpu_device) = (gpu_float1 + gpu_float2) * gpu_float1;
+  gpu_res_bfloat16.device(gpu_device) =
+      ((gpu_float1.cast<Eigen::bfloat16>() + gpu_float2.cast<Eigen::bfloat16>()) * gpu_float1.cast<Eigen::bfloat16>())
+          .cast<float>();
+
+  Tensor<float, 1> bfloat16_prec(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(static_cast<Eigen::bfloat16>(full_prec(i)), static_cast<Eigen::bfloat16>(bfloat16_prec(i)));
+  }
+
+  gpu_device.deallocate(d_float1);
+  gpu_device.deallocate(d_float2);
+  gpu_device.deallocate(d_res_bfloat16);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_trancendental() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float3 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::bfloat16* d_res1_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res1_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res2_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res2_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res3_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res3_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float3(d_float3, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res1_bfloat16(d_res1_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res1_float(d_res1_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res2_bfloat16(d_res2_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res2_float(d_res2_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res3_bfloat16(d_res3_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res3_float(d_res3_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res4_bfloat16(d_res3_bfloat16, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res4_float(d_res3_float, num_elem);
+
+  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
+  gpu_float1.device(gpu_device) = gpu_float1.cast<Eigen::bfloat16>().cast<float>();
+  gpu_float2.device(gpu_device) = gpu_float2.random() + gpu_float1.constant(0.5f);
+  gpu_float2.device(gpu_device) = gpu_float2.cast<Eigen::bfloat16>().cast<float>();
+  gpu_float3.device(gpu_device) = gpu_float3.random();
+  gpu_float3.device(gpu_device) = gpu_float3.cast<Eigen::bfloat16>().cast<float>();
+  gpu_res1_float.device(gpu_device) = gpu_float1.exp().cast<Eigen::bfloat16>();
+  gpu_res2_float.device(gpu_device) = gpu_float2.log().cast<Eigen::bfloat16>();
+  gpu_res3_float.device(gpu_device) = gpu_float3.log1p().cast<Eigen::bfloat16>();
+  gpu_res4_float.device(gpu_device) = gpu_float3.expm1().cast<Eigen::bfloat16>();
+
+  gpu_res1_bfloat16.device(gpu_device) = gpu_float1.cast<Eigen::bfloat16>();
+  gpu_res1_bfloat16.device(gpu_device) = gpu_res1_bfloat16.exp();
+
+  gpu_res2_bfloat16.device(gpu_device) = gpu_float2.cast<Eigen::bfloat16>();
+  gpu_res2_bfloat16.device(gpu_device) = gpu_res2_bfloat16.log();
+
+  gpu_res3_bfloat16.device(gpu_device) = gpu_float3.cast<Eigen::bfloat16>();
+  gpu_res3_bfloat16.device(gpu_device) = gpu_res3_bfloat16.log1p();
+
+  gpu_res3_bfloat16.device(gpu_device) = gpu_float3.cast<Eigen::bfloat16>();
+  gpu_res3_bfloat16.device(gpu_device) = gpu_res3_bfloat16.expm1();
+
+  Tensor<float, 1> input1(num_elem);
+  Tensor<Eigen::bfloat16, 1> bfloat16_prec1(num_elem);
+  Tensor<Eigen::bfloat16, 1> full_prec1(num_elem);
+  Tensor<float, 1> input2(num_elem);
+  Tensor<Eigen::bfloat16, 1> bfloat16_prec2(num_elem);
+  Tensor<Eigen::bfloat16, 1> full_prec2(num_elem);
+  Tensor<float, 1> input3(num_elem);
+  Tensor<Eigen::bfloat16, 1> bfloat16_prec3(num_elem);
+  Tensor<Eigen::bfloat16, 1> full_prec3(num_elem);
+  gpu_device.memcpyDeviceToHost(input1.data(), d_float1, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(input2.data(), d_float2, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(input3.data(), d_float3, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(bfloat16_prec1.data(), d_res1_bfloat16, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec1.data(), d_res1_float, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(bfloat16_prec2.data(), d_res2_bfloat16, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec2.data(), d_res2_float, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(bfloat16_prec3.data(), d_res3_bfloat16, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec3.data(), d_res3_float, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(full_prec1(i), bfloat16_prec1(i));
+  }
+  for (int i = 0; i < num_elem; ++i) {
+    if (std::abs(input2(i) - 1.f) < 0.05f)  // log lacks accuracy nearby 1
+      VERIFY_IS_APPROX(full_prec2(i) + Eigen::bfloat16(0.1f), bfloat16_prec2(i) + Eigen::bfloat16(0.1f));
+    else
+      VERIFY_IS_APPROX(full_prec2(i), bfloat16_prec2(i));
+  }
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(full_prec3(i), bfloat16_prec3(i));
+  }
+  gpu_device.deallocate(d_float1);
+  gpu_device.deallocate(d_float2);
+  gpu_device.deallocate(d_float3);
+  gpu_device.deallocate(d_res1_bfloat16);
+  gpu_device.deallocate(d_res1_float);
+  gpu_device.deallocate(d_res2_bfloat16);
+  gpu_device.deallocate(d_res2_float);
+  gpu_device.deallocate(d_res3_float);
+  gpu_device.deallocate(d_res3_bfloat16);
+}
+
+template <typename>
+void test_gpu_contractions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int rows = 23;
+  int cols = 23;
+  int num_elem = rows * cols;
+
+  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::bfloat16* d_res_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float1(d_float1, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float2(d_float2, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 2>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 2>, Eigen::Aligned> gpu_res_float(d_res_float, rows, cols);
+
+  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
+  gpu_float2.device(gpu_device) = gpu_float2.random() - gpu_float2.constant(0.5f);
+
+  typedef Tensor<float, 2>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
+  gpu_res_float.device(gpu_device) = gpu_float1.contract(gpu_float2, dims).cast<Eigen::bfloat16>();
+  gpu_res_bfloat16.device(gpu_device) =
+      gpu_float1.cast<Eigen::bfloat16>().contract(gpu_float2.cast<Eigen::bfloat16>(), dims);
+
+  Tensor<Eigen::bfloat16, 2> bfloat16_prec(rows, cols);
+  Tensor<Eigen::bfloat16, 2> full_prec(rows, cols);
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(Eigen::bfloat16));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < rows; ++i) {
+    for (int j = 0; j < cols; ++j) {
+      // 2 * eps_bfloat16 of absolute slack covers the typical accumulated rounding error of the 23-term bfloat16
+      // dot product before falling back to the relative check.
+      if (numext::abs(full_prec(i, j) - bfloat16_prec(i, j)) >
+          Eigen::bfloat16(2.f) * NumTraits<Eigen::bfloat16>::epsilon()) {
+        VERIFY_IS_APPROX(full_prec(i, j), bfloat16_prec(i, j));
+      }
+    }
+  }
+
+  gpu_device.deallocate(d_float1);
+  gpu_device.deallocate(d_float2);
+  gpu_device.deallocate(d_res_bfloat16);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_reductions(int size1, int size2, int redux) {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = size1 * size2;
+  int result_size = (redux == 1 ? size1 : size2);
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::bfloat16* d_res_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(result_size * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res_float = (Eigen::bfloat16*)gpu_device.allocate(result_size * sizeof(Eigen::bfloat16));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size1, size2);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, result_size);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res_float(d_res_float, result_size);
+
+  gpu_float.device(gpu_device) = gpu_float.random() * 2.0f;
+
+  Eigen::array<int, 1> redux_dim = {redux};
+  gpu_res_float.device(gpu_device) = gpu_float.sum(redux_dim).cast<Eigen::bfloat16>();
+  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().sum(redux_dim);
+
+  Tensor<Eigen::bfloat16, 1> bfloat16_prec(result_size);
+  Tensor<Eigen::bfloat16, 1> full_prec(result_size);
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, result_size * sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, result_size * sizeof(Eigen::bfloat16));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < result_size; ++i) {
+    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_bfloat16);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_reductions() {
+  test_gpu_reductions<void>(13, 13, 0);
+  test_gpu_reductions<void>(13, 13, 1);
+
+  test_gpu_reductions<void>(35, 36, 0);
+  test_gpu_reductions<void>(35, 36, 1);
+
+  test_gpu_reductions<void>(36, 35, 0);
+  test_gpu_reductions<void>(36, 35, 1);
+}
+
+template <typename>
+void test_gpu_full_reductions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int size = 13;
+  int num_elem = size * size;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::bfloat16* d_res_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(1 * sizeof(Eigen::bfloat16));
+  Eigen::bfloat16* d_res_float = (Eigen::bfloat16*)gpu_device.allocate(1 * sizeof(Eigen::bfloat16));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size, size);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 0>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 0>, Eigen::Aligned> gpu_res_float(d_res_float);
+
+  gpu_float.device(gpu_device) = gpu_float.random();
+
+  gpu_res_float.device(gpu_device) = gpu_float.sum().cast<Eigen::bfloat16>();
+  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().sum();
+
+  Tensor<Eigen::bfloat16, 0> bfloat16_prec;
+  Tensor<Eigen::bfloat16, 0> full_prec;
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::bfloat16));
+  gpu_device.synchronize();
+
+  VERIFY_IS_APPROX(full_prec(), bfloat16_prec());
+
+  gpu_res_float.device(gpu_device) = gpu_float.maximum().cast<Eigen::bfloat16>();
+  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().maximum();
+  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, sizeof(Eigen::bfloat16));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::bfloat16));
+  gpu_device.synchronize();
+
+  VERIFY_IS_APPROX(full_prec(), bfloat16_prec());
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_bfloat16);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_forced_evals() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_bfloat16_1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_bfloat16_2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_bfloat16_1(d_res_bfloat16_1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Unaligned> gpu_res_bfloat16_2(d_res_bfloat16_2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  Eigen::array<int, 1> no_bcast;
+  no_bcast[0] = 1;
+
+  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_float.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().cast<float>();
+  gpu_res_float.device(gpu_device) = gpu_float.abs();
+  gpu_res_bfloat16_1.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().abs().eval().cast<float>();
+  gpu_res_bfloat16_2.device(gpu_device) =
+      gpu_float.cast<Eigen::bfloat16>().abs().broadcast(no_bcast).eval().cast<float>();
+
+  Tensor<float, 1> bfloat16_prec1(num_elem);
+  Tensor<float, 1> bfloat16_prec2(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(bfloat16_prec1.data(), d_res_bfloat16_1, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(bfloat16_prec2.data(), d_res_bfloat16_2, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec1(i));
+    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec2(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_bfloat16_1);
+  gpu_device.deallocate(d_res_bfloat16_2);
+  gpu_device.deallocate(d_res_float);
+}
+
+#endif
+
+EIGEN_DECLARE_TEST(tensor_of_bfloat16_gpu) {
+  CALL_SUBTEST_1(test_gpu_numext<void>());
+
+// The reduction unit tests have been excluded until a working
+// implementation to expand the accumulator data type to float32
+// is available.
+// TODO: add reduction unit tests
+#ifdef EIGEN_HAS_GPU_BF16
+  CALL_SUBTEST_2(test_gpu_conversion<void>());
+  CALL_SUBTEST_3(test_gpu_unary<void>());
+  CALL_SUBTEST_4(test_gpu_elementwise<void>());
+  CALL_SUBTEST_5(test_gpu_trancendental<void>());
+  CALL_SUBTEST_6(test_gpu_contractions<void>());
+  CALL_SUBTEST_7(test_gpu_reductions<void>());
+  CALL_SUBTEST_8(test_gpu_full_reductions<void>());
+  CALL_SUBTEST_9(test_gpu_forced_evals<void>());
+#else
+  // Without device bfloat16 support parts 2-9 have nothing to run.  Report them as skipped rather than let an
+  // empty part pass: under EIGEN_SPLIT_LARGE_TESTS each part is its own executable, and a green one would claim
+  // coverage that never ran.  Detected at run time: an EIGEN_TEST_PART_<n> token in the source would make
+  // ei_add_test split the test even with EIGEN_SPLIT_LARGE_TESTS=OFF.
+  bool ran_numext = false;
+  CALL_SUBTEST_1(ran_numext = true);
+  if (!ran_numext) skip_test("bfloat16 device support (EIGEN_HAS_GPU_BF16) is not available with this toolkit.");
+  std::cout << "bfloat16 device support (EIGEN_HAS_GPU_BF16) is not available with this toolkit: only the numext "
+               "part runs."
+            << std::endl;
+#endif
+}
diff --git a/contrib/test/tensor_of_complex.cpp b/contrib/test/tensor_of_complex.cpp
new file mode 100644
index 0000000..0e5c698
--- /dev/null
+++ b/contrib/test/tensor_of_complex.cpp
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+static void test_additions() {
+  Tensor<std::complex<float>, 1> data1(3);
+  Tensor<std::complex<float>, 1> data2(3);
+  for (int i = 0; i < 3; ++i) {
+    data1(i) = std::complex<float>(i, -i);
+    data2(i) = std::complex<float>(i, 7 * i);
+  }
+
+  Tensor<std::complex<float>, 1> sum = data1 + data2;
+  for (int i = 0; i < 3; ++i) {
+    VERIFY_IS_EQUAL(sum(i), std::complex<float>(2 * i, 6 * i));
+  }
+}
+
+static void test_abs() {
+  Tensor<std::complex<float>, 1> data1(3);
+  Tensor<std::complex<double>, 1> data2(3);
+  data1.setRandom();
+  data2.setRandom();
+
+  Tensor<float, 1> abs1 = data1.abs();
+  Tensor<double, 1> abs2 = data2.abs();
+  for (int i = 0; i < 3; ++i) {
+    VERIFY_IS_APPROX(abs1(i), std::abs(data1(i)));
+    VERIFY_IS_APPROX(abs2(i), std::abs(data2(i)));
+  }
+}
+
+static void test_arg() {
+  Tensor<std::complex<float>, 1> data1(3);
+  Tensor<std::complex<double>, 1> data2(3);
+  data1.setRandom();
+  data2.setRandom();
+
+  Tensor<float, 1> arg1 = data1.arg();
+  Tensor<double, 1> arg2 = data2.arg();
+  for (int i = 0; i < 3; ++i) {
+    VERIFY_IS_APPROX(arg1(i), std::arg(data1(i)));
+    VERIFY_IS_APPROX(arg2(i), std::arg(data2(i)));
+  }
+}
+
+static void test_conjugate() {
+  Tensor<std::complex<float>, 1> data1(3);
+  Tensor<std::complex<double>, 1> data2(3);
+  Tensor<int, 1> data3(3);
+  data1.setRandom();
+  data2.setRandom();
+  data3.setRandom();
+
+  Tensor<std::complex<float>, 1> conj1 = data1.conjugate();
+  Tensor<std::complex<double>, 1> conj2 = data2.conjugate();
+  Tensor<int, 1> conj3 = data3.conjugate();
+  for (int i = 0; i < 3; ++i) {
+    VERIFY_IS_APPROX(conj1(i), std::conj(data1(i)));
+    VERIFY_IS_APPROX(conj2(i), std::conj(data2(i)));
+    VERIFY_IS_APPROX(conj3(i), data3(i));
+  }
+}
+
+static void test_contractions() {
+  Tensor<std::complex<float>, 4> t_left(30, 50, 8, 31);
+  Tensor<std::complex<float>, 5> t_right(8, 31, 7, 20, 10);
+  Tensor<std::complex<float>, 5> t_result(30, 50, 7, 20, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  typedef Map<Matrix<std::complex<float>, Dynamic, Dynamic>> MapXcf;
+  MapXcf m_left(t_left.data(), 1500, 248);
+  MapXcf m_right(t_right.data(), 248, 1400);
+  Matrix<std::complex<float>, Dynamic, Dynamic> m_result(1500, 1400);
+
+  // This contraction should be equivalent to a regular matrix multiplication
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 2> dims;
+  dims[0] = DimPair(2, 0);
+  dims[1] = DimPair(3, 1);
+  t_result = t_left.contract(t_right, dims);
+  m_result = m_left * m_right;
+  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_of_complex) {
+  CALL_SUBTEST(test_additions());
+  CALL_SUBTEST(test_abs());
+  CALL_SUBTEST(test_arg());
+  CALL_SUBTEST(test_conjugate());
+  CALL_SUBTEST(test_contractions());
+}
diff --git a/contrib/test/tensor_of_const_values.cpp b/contrib/test/tensor_of_const_values.cpp
new file mode 100644
index 0000000..d6d211c
--- /dev/null
+++ b/contrib/test/tensor_of_const_values.cpp
@@ -0,0 +1,99 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_assign() {
+  float data1[6];
+  TensorMap<Tensor<const float, 2>> mat1(data1, 2, 3);
+  float data2[6];
+  const TensorMap<Tensor<float, 2>> mat2(data2, 2, 3);
+
+  for (int i = 0; i < 6; ++i) {
+    data1[i] = i;
+    data2[i] = -i;
+  }
+
+  Tensor<float, 2> rslt1;
+  rslt1 = mat1;
+  Tensor<float, 2> rslt2;
+  rslt2 = mat2;
+
+  Tensor<float, 2> rslt3 = mat1;
+  Tensor<float, 2> rslt4 = mat2;
+
+  Tensor<float, 2> rslt5(mat1);
+  Tensor<float, 2> rslt6(mat2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_APPROX(rslt1(i, j), static_cast<float>(i + 2 * j));
+      VERIFY_IS_APPROX(rslt2(i, j), static_cast<float>(-i - 2 * j));
+      VERIFY_IS_APPROX(rslt3(i, j), static_cast<float>(i + 2 * j));
+      VERIFY_IS_APPROX(rslt4(i, j), static_cast<float>(-i - 2 * j));
+      VERIFY_IS_APPROX(rslt5(i, j), static_cast<float>(i + 2 * j));
+      VERIFY_IS_APPROX(rslt6(i, j), static_cast<float>(-i - 2 * j));
+    }
+  }
+}
+
+static void test_plus() {
+  float data1[6];
+  TensorMap<Tensor<const float, 2>> mat1(data1, 2, 3);
+  float data2[6];
+  TensorMap<Tensor<float, 2>> mat2(data2, 2, 3);
+
+  for (int i = 0; i < 6; ++i) {
+    data1[i] = i;
+    data2[i] = -i;
+  }
+
+  Tensor<float, 2> sum1;
+  sum1 = mat1 + mat2;
+  Tensor<float, 2> sum2;
+  sum2 = mat2 + mat1;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_APPROX(sum1(i, j), 0.0f);
+      VERIFY_IS_APPROX(sum2(i, j), 0.0f);
+    }
+  }
+}
+
+static void test_plus_equal() {
+  float data1[6];
+  TensorMap<Tensor<const float, 2>> mat1(data1, 2, 3);
+  float data2[6];
+  TensorMap<Tensor<float, 2>> mat2(data2, 2, 3);
+
+  for (int i = 0; i < 6; ++i) {
+    data1[i] = i;
+    data2[i] = -i;
+  }
+  mat2 += mat1;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_APPROX(mat2(i, j), 0.0f);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_of_const_values) {
+  CALL_SUBTEST(test_assign());
+  CALL_SUBTEST(test_plus());
+  CALL_SUBTEST(test_plus_equal());
+}
diff --git a/contrib/test/tensor_of_float16_gpu.cu b/contrib/test/tensor_of_float16_gpu.cu
new file mode 100644
index 0000000..fa9b2da
--- /dev/null
+++ b/contrib/test/tensor_of_float16_gpu.cu
@@ -0,0 +1,428 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename>
+void test_gpu_numext() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  bool* d_res_half = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
+  bool* d_res_float = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(gpu_device) = gpu_float.unaryExpr(Eigen::internal::scalar_isnan_op<float>());
+  gpu_res_half.device(gpu_device) =
+      gpu_float.template cast<Eigen::half>().unaryExpr(Eigen::internal::scalar_isnan_op<Eigen::half>());
+
+  Tensor<bool, 1> half_prec(num_elem);
+  Tensor<bool, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(bool));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(bool));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking numext " << i << std::endl;
+    VERIFY_IS_EQUAL(full_prec(i), half_prec(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_half);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_unary() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_half = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(gpu_device) = gpu_float.abs();
+  gpu_res_half.device(gpu_device) = gpu_float.template cast<Eigen::half>().abs().template cast<float>();
+
+  Tensor<float, 1> half_prec(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking unary " << i << std::endl;
+    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_half);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_elementwise() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_half = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float1.device(gpu_device) = gpu_float1.random();
+  gpu_float2.device(gpu_device) = gpu_float2.random();
+  gpu_res_float.device(gpu_device) = (gpu_float1 + gpu_float2) * gpu_float1;
+  gpu_res_half.device(gpu_device) =
+      ((gpu_float1.template cast<Eigen::half>() + gpu_float2.template cast<Eigen::half>()) *
+       gpu_float1.template cast<Eigen::half>())
+          .template cast<float>();
+
+  Tensor<float, 1> half_prec(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise " << i << ": full prec = " << full_prec(i) << " vs half prec = " << half_prec(i)
+              << std::endl;
+    VERIFY_IS_APPROX(static_cast<Eigen::half>(full_prec(i)), static_cast<Eigen::half>(half_prec(i)));
+  }
+
+  gpu_device.deallocate(d_float1);
+  gpu_device.deallocate(d_float2);
+  gpu_device.deallocate(d_res_half);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_trancendental() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float3 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res1_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res1_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res2_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res2_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res3_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res3_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float3(d_float3, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_half(d_res1_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_float(d_res1_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_half(d_res2_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_float(d_res2_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_half(d_res3_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_float(d_res3_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_half(d_res3_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_float(d_res3_float, num_elem);
+
+  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
+  gpu_float2.device(gpu_device) = gpu_float2.random() + gpu_float1.constant(0.5f);
+  gpu_float3.device(gpu_device) = gpu_float3.random();
+  gpu_res1_float.device(gpu_device) = gpu_float1.exp().template cast<Eigen::half>();
+  gpu_res2_float.device(gpu_device) = gpu_float2.log().template cast<Eigen::half>();
+  gpu_res3_float.device(gpu_device) = gpu_float3.log1p().template cast<Eigen::half>();
+  gpu_res4_float.device(gpu_device) = gpu_float3.expm1().template cast<Eigen::half>();
+
+  gpu_res1_half.device(gpu_device) = gpu_float1.template cast<Eigen::half>();
+  gpu_res1_half.device(gpu_device) = gpu_res1_half.exp();
+
+  gpu_res2_half.device(gpu_device) = gpu_float2.template cast<Eigen::half>();
+  gpu_res2_half.device(gpu_device) = gpu_res2_half.log();
+
+  gpu_res3_half.device(gpu_device) = gpu_float3.template cast<Eigen::half>();
+  gpu_res3_half.device(gpu_device) = gpu_res3_half.log1p();
+
+  gpu_res3_half.device(gpu_device) = gpu_float3.template cast<Eigen::half>();
+  gpu_res3_half.device(gpu_device) = gpu_res3_half.expm1();
+
+  Tensor<float, 1> input1(num_elem);
+  Tensor<Eigen::half, 1> half_prec1(num_elem);
+  Tensor<Eigen::half, 1> full_prec1(num_elem);
+  Tensor<float, 1> input2(num_elem);
+  Tensor<Eigen::half, 1> half_prec2(num_elem);
+  Tensor<Eigen::half, 1> full_prec2(num_elem);
+  Tensor<float, 1> input3(num_elem);
+  Tensor<Eigen::half, 1> half_prec3(num_elem);
+  Tensor<Eigen::half, 1> full_prec3(num_elem);
+  gpu_device.memcpyDeviceToHost(input1.data(), d_float1, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(input2.data(), d_float2, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(input3.data(), d_float3, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(half_prec1.data(), d_res1_half, num_elem * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec1.data(), d_res1_float, num_elem * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(half_prec2.data(), d_res2_half, num_elem * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec2.data(), d_res2_float, num_elem * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(half_prec3.data(), d_res3_half, num_elem * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec3.data(), d_res3_float, num_elem * sizeof(Eigen::half));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise exp " << i << " input = " << input1(i) << " full = " << full_prec1(i)
+              << " half = " << half_prec1(i) << std::endl;
+    VERIFY_IS_APPROX(full_prec1(i), half_prec1(i));
+  }
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise log " << i << " input = " << input2(i) << " full = " << full_prec2(i)
+              << " half = " << half_prec2(i) << std::endl;
+    if (std::abs(input2(i) - 1.f) < 0.05f)  // log lacks accuracy nearby 1
+      VERIFY_IS_APPROX(full_prec2(i) + Eigen::half(0.1f), half_prec2(i) + Eigen::half(0.1f));
+    else
+      VERIFY_IS_APPROX(full_prec2(i), half_prec2(i));
+  }
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise plog1 " << i << " input = " << input3(i) << " full = " << full_prec3(i)
+              << " half = " << half_prec3(i) << std::endl;
+    VERIFY_IS_APPROX(full_prec3(i), half_prec3(i));
+  }
+  gpu_device.deallocate(d_float1);
+  gpu_device.deallocate(d_float2);
+  gpu_device.deallocate(d_float3);
+  gpu_device.deallocate(d_res1_half);
+  gpu_device.deallocate(d_res1_float);
+  gpu_device.deallocate(d_res2_half);
+  gpu_device.deallocate(d_res2_float);
+  gpu_device.deallocate(d_res3_float);
+  gpu_device.deallocate(d_res3_half);
+}
+
+template <typename>
+void test_gpu_contractions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int rows = 23;
+  int cols = 23;
+  int num_elem = rows * cols;
+
+  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float1(d_float1, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float2(d_float2, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_half(d_res_half, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_float(d_res_float, rows, cols);
+
+  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
+  gpu_float2.device(gpu_device) = gpu_float2.random() - gpu_float2.constant(0.5f);
+
+  typedef Tensor<float, 2>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
+  gpu_res_float.device(gpu_device) = gpu_float1.contract(gpu_float2, dims).template cast<Eigen::half>();
+  gpu_res_half.device(gpu_device) =
+      gpu_float1.template cast<Eigen::half>().contract(gpu_float2.template cast<Eigen::half>(), dims);
+
+  Tensor<Eigen::half, 2> half_prec(rows, cols);
+  Tensor<Eigen::half, 2> full_prec(rows, cols);
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(Eigen::half));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < rows; ++i) {
+    for (int j = 0; j < cols; ++j) {
+      std::cout << "Checking contract " << i << " " << j << full_prec(i, j) << " " << half_prec(i, j) << std::endl;
+      // 16 * eps_half of absolute slack covers the typical accumulated rounding error of the 23-term half dot
+      // product before falling back to the relative check.
+      if (numext::abs(full_prec(i, j) - half_prec(i, j)) > Eigen::half(16.f) * NumTraits<Eigen::half>::epsilon()) {
+        VERIFY_IS_APPROX(full_prec(i, j), half_prec(i, j));
+      }
+    }
+  }
+
+  gpu_device.deallocate(d_float1);
+  gpu_device.deallocate(d_float2);
+  gpu_device.deallocate(d_res_half);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_reductions(int size1, int size2, int redux) {
+  std::cout << "Reducing " << size1 << " by " << size2 << " tensor along dim " << redux << std::endl;
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = size1 * size2;
+  int result_size = (redux == 1 ? size1 : size2);
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res_half = (Eigen::half*)gpu_device.allocate(result_size * sizeof(Eigen::half));
+  Eigen::half* d_res_float = (Eigen::half*)gpu_device.allocate(result_size * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size1, size2);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_half(d_res_half, result_size);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_float(d_res_float, result_size);
+
+  gpu_float.device(gpu_device) = gpu_float.random() * 2.0f;
+
+  Eigen::array<int, 1> redux_dim = {redux};
+  gpu_res_float.device(gpu_device) = gpu_float.sum(redux_dim).template cast<Eigen::half>();
+  gpu_res_half.device(gpu_device) = gpu_float.template cast<Eigen::half>().sum(redux_dim);
+
+  Tensor<Eigen::half, 1> half_prec(result_size);
+  Tensor<Eigen::half, 1> full_prec(result_size);
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, result_size * sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, result_size * sizeof(Eigen::half));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < result_size; ++i) {
+    std::cout << "EXPECTED " << full_prec(i) << " GOT " << half_prec(i) << std::endl;
+    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_half);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_reductions() {
+  test_gpu_reductions<void>(13, 13, 0);
+  test_gpu_reductions<void>(13, 13, 1);
+
+  test_gpu_reductions<void>(35, 36, 0);
+  test_gpu_reductions<void>(35, 36, 1);
+
+  test_gpu_reductions<void>(36, 35, 0);
+  test_gpu_reductions<void>(36, 35, 1);
+}
+
+template <typename>
+void test_gpu_full_reductions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int size = 13;
+  int num_elem = size * size;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res_half = (Eigen::half*)gpu_device.allocate(1 * sizeof(Eigen::half));
+  Eigen::half* d_res_float = (Eigen::half*)gpu_device.allocate(1 * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size, size);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_half(d_res_half);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_float(d_res_float);
+
+  gpu_float.device(gpu_device) = gpu_float.random();
+
+  gpu_res_float.device(gpu_device) = gpu_float.sum().template cast<Eigen::half>();
+  gpu_res_half.device(gpu_device) = gpu_float.template cast<Eigen::half>().sum();
+
+  Tensor<Eigen::half, 0> half_prec;
+  Tensor<Eigen::half, 0> full_prec;
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
+  gpu_device.synchronize();
+
+  VERIFY_IS_APPROX(full_prec(), half_prec());
+
+  gpu_res_float.device(gpu_device) = gpu_float.maximum().template cast<Eigen::half>();
+  gpu_res_half.device(gpu_device) = gpu_float.template cast<Eigen::half>().maximum();
+  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
+  gpu_device.synchronize();
+
+  VERIFY_IS_APPROX(full_prec(), half_prec());
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_half);
+  gpu_device.deallocate(d_res_float);
+}
+
+template <typename>
+void test_gpu_forced_evals() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  int num_elem = 101;
+
+  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_half1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_half2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half1(d_res_half1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Unaligned> gpu_res_half2(d_res_half2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  Eigen::array<int, 1> no_bcast;
+  no_bcast[0] = 1;
+
+  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(gpu_device) = gpu_float.abs();
+  gpu_res_half1.device(gpu_device) = gpu_float.template cast<Eigen::half>().abs().eval().template cast<float>();
+  gpu_res_half2.device(gpu_device) =
+      gpu_float.template cast<Eigen::half>().abs().broadcast(no_bcast).eval().template cast<float>();
+
+  Tensor<float, 1> half_prec1(num_elem);
+  Tensor<float, 1> half_prec2(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  gpu_device.memcpyDeviceToHost(half_prec1.data(), d_res_half1, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(half_prec2.data(), d_res_half2, num_elem * sizeof(float));
+  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  gpu_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking forced eval " << i << full_prec(i) << " vs " << half_prec1(i) << " vs " << half_prec2(i)
+              << std::endl;
+    VERIFY_IS_APPROX(full_prec(i), half_prec1(i));
+    VERIFY_IS_APPROX(full_prec(i), half_prec2(i));
+  }
+
+  gpu_device.deallocate(d_float);
+  gpu_device.deallocate(d_res_half1);
+  gpu_device.deallocate(d_res_half2);
+  gpu_device.deallocate(d_res_float);
+}
+
+EIGEN_DECLARE_TEST(tensor_of_float16_gpu) {
+  CALL_SUBTEST_1(test_gpu_numext<void>());
+
+  CALL_SUBTEST_1(test_gpu_unary<void>());
+  CALL_SUBTEST_1(test_gpu_elementwise<void>());
+  CALL_SUBTEST_1(test_gpu_trancendental<void>());
+  CALL_SUBTEST_2(test_gpu_contractions<void>());
+  CALL_SUBTEST_3(test_gpu_reductions<void>());
+  CALL_SUBTEST_4(test_gpu_full_reductions<void>());
+  CALL_SUBTEST_5(test_gpu_forced_evals<void>());
+}
diff --git a/contrib/test/tensor_of_float16_sycl.cpp b/contrib/test/tensor_of_float16_sycl.cpp
new file mode 100644
index 0000000..cede148
--- /dev/null
+++ b/contrib/test/tensor_of_float16_sycl.cpp
@@ -0,0 +1,395 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2023
+// Alejandro Acosta  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_SYCL
+#define EIGEN_SYCL_HALF_SUPPORT
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+
+void test_gpu_numext(const Eigen::SyclDevice& sycl_device) {
+  int num_elem = 101;
+
+  float* d_float = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+  bool* d_res_half = static_cast<bool*>(sycl_device.allocate(num_elem * sizeof(bool)));
+  bool* d_res_float = static_cast<bool*>(sycl_device.allocate(num_elem * sizeof(bool)));
+
+  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Tensor<bool, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
+  Eigen::TensorMap<Tensor<bool, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float.device(sycl_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(sycl_device) = gpu_float.unaryExpr(Eigen::internal::scalar_isnan_op<float>());
+  gpu_res_half.device(sycl_device) =
+      gpu_float.cast<Eigen::half>().unaryExpr(Eigen::internal::scalar_isnan_op<Eigen::half>());
+
+  Tensor<bool, 1> half_prec(num_elem);
+  Tensor<bool, 1> full_prec(num_elem);
+
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(bool));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(bool));
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking numext " << i << std::endl;
+    VERIFY_IS_EQUAL(full_prec(i), half_prec(i));
+  }
+}
+
+void test_gpu_conversion(const Eigen::SyclDevice& sycl_device) {
+  int num_elem = 101;
+
+  float* d_float = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+  Eigen::half* d_half = static_cast<Eigen::half*>(sycl_device.allocate(num_elem * sizeof(Eigen::half)));
+  float* d_conv = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_half(d_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
+
+  gpu_float.device(sycl_device) = gpu_float.random();
+  gpu_half.device(sycl_device) = gpu_float.cast<Eigen::half>();
+  gpu_conv.device(sycl_device) = gpu_half.cast<float>();
+
+  Tensor<float, 1> initial(num_elem);
+  Tensor<float, 1> final(num_elem);
+  sycl_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
+
+  for (int i = 0; i < num_elem; ++i) {
+    VERIFY_IS_APPROX(initial(i), final(i));
+  }
+}
+
+void test_gpu_unary(const Eigen::SyclDevice& sycl_device) {
+  int num_elem = 101;
+
+  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_res_half = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float.device(sycl_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(sycl_device) = gpu_float.abs();
+  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().abs().cast<float>();
+
+  Tensor<float, 1> half_prec(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  sycl_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking unary " << i << std::endl;
+    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
+  }
+}
+
+void test_gpu_elementwise(const Eigen::SyclDevice& sycl_device) {
+  int num_elem = 101;
+
+  float* d_float1 = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+  float* d_float2 = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+  float* d_res_half = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+  float* d_res_float = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
+
+  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
+  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
+  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
+  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  gpu_float1.device(sycl_device) = gpu_float1.random();
+  gpu_float2.device(sycl_device) = gpu_float2.random();
+  gpu_res_float.device(sycl_device) = (gpu_float1 + gpu_float2) * gpu_float1;
+  gpu_res_half.device(sycl_device) =
+      ((gpu_float1.cast<Eigen::half>() + gpu_float2.cast<Eigen::half>()) * gpu_float1.cast<Eigen::half>())
+          .cast<float>();
+
+  Tensor<float, 1> half_prec(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise " << i << ": full prec = " << full_prec(i) << " vs half prec = " << half_prec(i)
+              << std::endl;
+    VERIFY_IS_APPROX(static_cast<Eigen::half>(full_prec(i)), static_cast<Eigen::half>(half_prec(i)));
+  }
+}
+
+void test_gpu_trancendental(const Eigen::SyclDevice& sycl_device) {
+  int num_elem = 101;
+
+  float* d_float1 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_float3 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res1_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res1_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res2_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res2_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res3_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res3_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float3(d_float3, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_half(d_res1_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_float(d_res1_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_half(d_res2_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_float(d_res2_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_half(d_res3_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_float(d_res3_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_half(d_res3_half, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_float(d_res3_float, num_elem);
+
+  gpu_float1.device(sycl_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
+  gpu_float2.device(sycl_device) = gpu_float2.random() + gpu_float1.constant(0.5f);
+  gpu_float3.device(sycl_device) = gpu_float3.random();
+  gpu_res1_float.device(sycl_device) = gpu_float1.exp().cast<Eigen::half>();
+  gpu_res2_float.device(sycl_device) = gpu_float2.log().cast<Eigen::half>();
+  gpu_res3_float.device(sycl_device) = gpu_float3.log1p().cast<Eigen::half>();
+  gpu_res4_float.device(sycl_device) = gpu_float3.expm1().cast<Eigen::half>();
+
+  gpu_res1_half.device(sycl_device) = gpu_float1.cast<Eigen::half>();
+  gpu_res1_half.device(sycl_device) = gpu_res1_half.exp();
+
+  gpu_res2_half.device(sycl_device) = gpu_float2.cast<Eigen::half>();
+  gpu_res2_half.device(sycl_device) = gpu_res2_half.log();
+
+  gpu_res3_half.device(sycl_device) = gpu_float3.cast<Eigen::half>();
+  gpu_res3_half.device(sycl_device) = gpu_res3_half.log1p();
+
+  gpu_res3_half.device(sycl_device) = gpu_float3.cast<Eigen::half>();
+  gpu_res3_half.device(sycl_device) = gpu_res3_half.expm1();
+
+  Tensor<float, 1> input1(num_elem);
+  Tensor<Eigen::half, 1> half_prec1(num_elem);
+  Tensor<Eigen::half, 1> full_prec1(num_elem);
+  Tensor<float, 1> input2(num_elem);
+  Tensor<Eigen::half, 1> half_prec2(num_elem);
+  Tensor<Eigen::half, 1> full_prec2(num_elem);
+  Tensor<float, 1> input3(num_elem);
+  Tensor<Eigen::half, 1> half_prec3(num_elem);
+  Tensor<Eigen::half, 1> full_prec3(num_elem);
+  sycl_device.memcpyDeviceToHost(input1.data(), d_float1, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(input2.data(), d_float2, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(input3.data(), d_float3, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(half_prec1.data(), d_res1_half, num_elem * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec1.data(), d_res1_float, num_elem * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(half_prec2.data(), d_res2_half, num_elem * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec2.data(), d_res2_float, num_elem * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(half_prec3.data(), d_res3_half, num_elem * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec3.data(), d_res3_float, num_elem * sizeof(Eigen::half));
+  sycl_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise exp " << i << " input = " << input1(i) << " full = " << full_prec1(i)
+              << " half = " << half_prec1(i) << std::endl;
+    VERIFY_IS_APPROX(full_prec1(i), half_prec1(i));
+  }
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise log " << i << " input = " << input2(i) << " full = " << full_prec2(i)
+              << " half = " << half_prec2(i) << std::endl;
+    if (std::abs(input2(i) - 1.f) < 0.05f)  // log lacks accuracy nearby 1
+      VERIFY_IS_APPROX(full_prec2(i) + Eigen::half(0.1f), half_prec2(i) + Eigen::half(0.1f));
+    else
+      VERIFY_IS_APPROX(full_prec2(i), half_prec2(i));
+  }
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking elemwise plog1 " << i << " input = " << input3(i) << " full = " << full_prec3(i)
+              << " half = " << half_prec3(i) << std::endl;
+    VERIFY_IS_APPROX(full_prec3(i), half_prec3(i));
+  }
+}
+
+void test_gpu_contractions(const Eigen::SyclDevice& sycl_device) {
+  int rows = 23;
+  int cols = 23;
+  int num_elem = rows * cols;
+
+  float* d_float1 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_float2 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+  Eigen::half* d_res_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float1(d_float1, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float2(d_float2, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_half(d_res_half, rows, cols);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_float(d_res_float, rows, cols);
+
+  gpu_float1.device(sycl_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
+  gpu_float2.device(sycl_device) = gpu_float2.random() - gpu_float2.constant(0.5f);
+
+  typedef typename Tensor<float, 2>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims;
+  gpu_res_float.device(sycl_device) = gpu_float1.contract(gpu_float2, dims).cast<Eigen::half>();
+  gpu_res_half.device(sycl_device) = gpu_float1.cast<Eigen::half>().contract(gpu_float2.cast<Eigen::half>(), dims);
+
+  Tensor<Eigen::half, 2> half_prec(rows, cols);
+  Tensor<Eigen::half, 2> full_prec(rows, cols);
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(Eigen::half));
+  sycl_device.synchronize();
+
+  for (int i = 0; i < rows; ++i) {
+    for (int j = 0; j < cols; ++j) {
+      std::cout << "Checking contract " << i << " " << j << full_prec(i, j) << " " << half_prec(i, j) << std::endl;
+      // 16 * eps_half of absolute slack covers the typical accumulated rounding error of the 23-term half dot
+      // product before falling back to the relative check.
+      if (numext::abs(full_prec(i, j) - half_prec(i, j)) > Eigen::half(16.f) * NumTraits<Eigen::half>::epsilon()) {
+        VERIFY_IS_APPROX(full_prec(i, j), half_prec(i, j));
+      }
+    }
+  }
+}
+
+void test_gpu_reductions(const Eigen::SyclDevice& sycl_device, int size1, int size2, int redux) {
+  std::cout << "Reducing " << size1 << " by " << size2 << " tensor along dim " << redux << std::endl;
+
+  int num_elem = size1 * size2;
+  int result_size = (redux == 1 ? size1 : size2);
+
+  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res_half = (Eigen::half*)sycl_device.allocate(result_size * sizeof(Eigen::half));
+  Eigen::half* d_res_float = (Eigen::half*)sycl_device.allocate(result_size * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size1, size2);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_half(d_res_half, result_size);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_float(d_res_float, result_size);
+
+  gpu_float.device(sycl_device) = gpu_float.random() * 2.0f;
+
+  Eigen::array<int, 1> redux_dim = {redux};
+  gpu_res_float.device(sycl_device) = gpu_float.sum(redux_dim).cast<Eigen::half>();
+  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().sum(redux_dim);
+
+  Tensor<Eigen::half, 1> half_prec(result_size);
+  Tensor<Eigen::half, 1> full_prec(result_size);
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, result_size * sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, result_size * sizeof(Eigen::half));
+  sycl_device.synchronize();
+
+  for (int i = 0; i < result_size; ++i) {
+    std::cout << "EXPECTED " << full_prec(i) << " GOT " << half_prec(i) << std::endl;
+    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
+  }
+}
+
+void test_gpu_reductions(const Eigen::SyclDevice& sycl_device) {
+  test_gpu_reductions(sycl_device, 13, 13, 0);
+  test_gpu_reductions(sycl_device, 13, 13, 1);
+
+  test_gpu_reductions(sycl_device, 35, 36, 0);
+  test_gpu_reductions(sycl_device, 35, 36, 1);
+
+  test_gpu_reductions(sycl_device, 36, 35, 0);
+  test_gpu_reductions(sycl_device, 36, 35, 1);
+}
+
+void test_gpu_full_reductions(const Eigen::SyclDevice& sycl_device) {
+  int size = 13;
+  int num_elem = size * size;
+
+  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  Eigen::half* d_res_half = (Eigen::half*)sycl_device.allocate(1 * sizeof(Eigen::half));
+  Eigen::half* d_res_float = (Eigen::half*)sycl_device.allocate(1 * sizeof(Eigen::half));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size, size);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_half(d_res_half);
+  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_float(d_res_float);
+
+  gpu_float.device(sycl_device) = gpu_float.random();
+
+  gpu_res_float.device(sycl_device) = gpu_float.sum().cast<Eigen::half>();
+  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().sum();
+
+  Tensor<Eigen::half, 0> half_prec;
+  Tensor<Eigen::half, 0> full_prec;
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
+  sycl_device.synchronize();
+
+  VERIFY_IS_APPROX(full_prec(), half_prec());
+
+  gpu_res_float.device(sycl_device) = gpu_float.maximum().cast<Eigen::half>();
+  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().maximum();
+  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
+  sycl_device.synchronize();
+
+  VERIFY_IS_APPROX(full_prec(), half_prec());
+}
+
+void test_gpu_forced_evals(const Eigen::SyclDevice& sycl_device) {
+  int num_elem = 101;
+
+  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_res_half1 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_res_half2 = (float*)sycl_device.allocate(num_elem * sizeof(float));
+  float* d_res_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
+
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half1(d_res_half1, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Unaligned> gpu_res_half2(d_res_half2, num_elem);
+  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
+
+  Eigen::array<int, 1> no_bcast;
+  no_bcast[0] = 1;
+
+  gpu_float.device(sycl_device) = gpu_float.random() - gpu_float.constant(0.5f);
+  gpu_res_float.device(sycl_device) = gpu_float.abs();
+  gpu_res_half1.device(sycl_device) = gpu_float.cast<Eigen::half>().abs().eval().cast<float>();
+  gpu_res_half2.device(sycl_device) = gpu_float.cast<Eigen::half>().abs().broadcast(no_bcast).eval().cast<float>();
+
+  Tensor<float, 1> half_prec1(num_elem);
+  Tensor<float, 1> half_prec2(num_elem);
+  Tensor<float, 1> full_prec(num_elem);
+  sycl_device.memcpyDeviceToHost(half_prec1.data(), d_res_half1, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(half_prec2.data(), d_res_half2, num_elem * sizeof(float));
+  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
+  sycl_device.synchronize();
+
+  for (int i = 0; i < num_elem; ++i) {
+    std::cout << "Checking forced eval " << i << full_prec(i) << " vs " << half_prec1(i) << " vs " << half_prec2(i)
+              << std::endl;
+    VERIFY_IS_APPROX(full_prec(i), half_prec1(i));
+    VERIFY_IS_APPROX(full_prec(i), half_prec2(i));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_of_float16_sycl) {
+  for (const auto& s : Eigen::get_sycl_supported_devices()) {
+    QueueInterface queueInterface(s);
+    auto sycl_device = Eigen::SyclDevice(&queueInterface);
+
+    CALL_SUBTEST_1(test_gpu_numext(sycl_device));
+    CALL_SUBTEST_1(test_gpu_conversion(sycl_device));
+    CALL_SUBTEST_1(test_gpu_unary(sycl_device));
+    CALL_SUBTEST_1(test_gpu_elementwise(sycl_device));
+    CALL_SUBTEST_1(test_gpu_trancendental(sycl_device));
+    CALL_SUBTEST_2(test_gpu_contractions(sycl_device));
+    CALL_SUBTEST_3(test_gpu_reductions(sycl_device));
+    CALL_SUBTEST_4(test_gpu_full_reductions(sycl_device));
+    CALL_SUBTEST_5(test_gpu_forced_evals(sycl_device));
+  }
+}
diff --git a/contrib/test/tensor_of_strings.cpp b/contrib/test/tensor_of_strings.cpp
new file mode 100644
index 0000000..4fbde53
--- /dev/null
+++ b/contrib/test/tensor_of_strings.cpp
@@ -0,0 +1,142 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+static void test_assign() {
+  std::string data1[6];
+  TensorMap<Tensor<std::string, 2>> mat1(data1, 2, 3);
+  std::string data2[6];
+  const TensorMap<Tensor<const std::string, 2>> mat2(data2, 2, 3);
+
+  for (int i = 0; i < 6; ++i) {
+    std::ostringstream s1;
+    s1 << "abc" << i * 3;
+    data1[i] = s1.str();
+    std::ostringstream s2;
+    s2 << "def" << i * 5;
+    data2[i] = s2.str();
+  }
+
+  Tensor<std::string, 2> rslt1;
+  rslt1 = mat1;
+  Tensor<std::string, 2> rslt2;
+  rslt2 = mat2;
+
+  Tensor<std::string, 2> rslt3 = mat1;
+  Tensor<std::string, 2> rslt4 = mat2;
+
+  Tensor<std::string, 2> rslt5(mat1);
+  Tensor<std::string, 2> rslt6(mat2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(rslt1(i, j), data1[i + 2 * j]);
+      VERIFY_IS_EQUAL(rslt2(i, j), data2[i + 2 * j]);
+      VERIFY_IS_EQUAL(rslt3(i, j), data1[i + 2 * j]);
+      VERIFY_IS_EQUAL(rslt4(i, j), data2[i + 2 * j]);
+      VERIFY_IS_EQUAL(rslt5(i, j), data1[i + 2 * j]);
+      VERIFY_IS_EQUAL(rslt6(i, j), data2[i + 2 * j]);
+    }
+  }
+}
+
+static void test_concat() {
+  Tensor<std::string, 2> t1(2, 3);
+  Tensor<std::string, 2> t2(2, 3);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      std::ostringstream s1;
+      s1 << "abc" << i + j * 2;
+      t1(i, j) = s1.str();
+      std::ostringstream s2;
+      s2 << "def" << i * 5 + j * 32;
+      t2(i, j) = s2.str();
+    }
+  }
+
+  Tensor<std::string, 2> result = t1.concatenate(t2, 1);
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 6);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(result(i, j), t1(i, j));
+      VERIFY_IS_EQUAL(result(i, j + 3), t2(i, j));
+    }
+  }
+}
+
+static void test_slices() {
+  Tensor<std::string, 2> data(2, 6);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      std::ostringstream s1;
+      s1 << "abc" << i + j * 2;
+      data(i, j) = s1.str();
+    }
+  }
+
+  const Eigen::DSizes<ptrdiff_t, 2> half_size(2, 3);
+  const Eigen::DSizes<ptrdiff_t, 2> first_half(0, 0);
+  const Eigen::DSizes<ptrdiff_t, 2> second_half(0, 3);
+
+  Tensor<std::string, 2> t1 = data.slice(first_half, half_size);
+  Tensor<std::string, 2> t2 = data.slice(second_half, half_size);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      VERIFY_IS_EQUAL(data(i, j), t1(i, j));
+      VERIFY_IS_EQUAL(data(i, j + 3), t2(i, j));
+    }
+  }
+}
+
+static void test_additions() {
+  Tensor<std::string, 1> data1(3);
+  Tensor<std::string, 1> data2(3);
+  for (int i = 0; i < 3; ++i) {
+    data1(i) = "abc";
+    std::ostringstream s1;
+    s1 << i;
+    data2(i) = s1.str();
+  }
+
+  Tensor<std::string, 1> sum = data1 + data2;
+  for (int i = 0; i < 3; ++i) {
+    std::ostringstream concat;
+    concat << "abc" << i;
+    std::string expected = concat.str();
+    VERIFY_IS_EQUAL(sum(i), expected);
+  }
+}
+
+static void test_initialization() {
+  Tensor<std::string, 2> a(2, 3);
+  a.setConstant(std::string("foo"));
+  for (int i = 0; i < 2 * 3; ++i) {
+    VERIFY_IS_EQUAL(a(i), std::string("foo"));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_of_strings) {
+  // Beware: none of this is likely to ever work on a GPU.
+  CALL_SUBTEST(test_assign());
+  CALL_SUBTEST(test_concat());
+  CALL_SUBTEST(test_slices());
+  CALL_SUBTEST(test_additions());
+  CALL_SUBTEST(test_initialization());
+}
diff --git a/contrib/test/tensor_padding.cpp b/contrib/test/tensor_padding.cpp
new file mode 100644
index 0000000..ee35d7c
--- /dev/null
+++ b/contrib/test/tensor_padding.cpp
@@ -0,0 +1,117 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_padding() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> paddings;
+  paddings[0] = std::make_pair(0, 0);
+  paddings[1] = std::make_pair(2, 1);
+  paddings[2] = std::make_pair(3, 4);
+  paddings[3] = std::make_pair(0, 0);
+
+  Tensor<float, 4, DataLayout> padded;
+  padded = tensor.pad(paddings);
+
+  VERIFY_IS_EQUAL(padded.dimension(0), 2 + 0);
+  VERIFY_IS_EQUAL(padded.dimension(1), 3 + 3);
+  VERIFY_IS_EQUAL(padded.dimension(2), 5 + 7);
+  VERIFY_IS_EQUAL(padded.dimension(3), 7 + 0);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      for (int k = 0; k < 12; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
+            VERIFY_IS_EQUAL(padded(i, j, k, l), tensor(i, j - 2, k - 3, l));
+          } else {
+            VERIFY_IS_EQUAL(padded(i, j, k, l), 0.0f);
+          }
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_padded_expr() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> paddings;
+  paddings[0] = std::make_pair(0, 0);
+  paddings[1] = std::make_pair(2, 1);
+  paddings[2] = std::make_pair(3, 4);
+  paddings[3] = std::make_pair(0, 0);
+
+  Eigen::DSizes<ptrdiff_t, 2> reshape_dims;
+  reshape_dims[0] = 12;
+  reshape_dims[1] = 84;
+
+  Tensor<float, 2, DataLayout> result;
+  result = tensor.pad(paddings).reshape(reshape_dims);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      for (int k = 0; k < 12; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          const float result_value =
+              DataLayout == ColMajor ? result(i + 2 * j, k + 12 * l) : result(j + 6 * i, l + 7 * k);
+          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
+            VERIFY_IS_EQUAL(result_value, tensor(i, j - 2, k - 3, l));
+          } else {
+            VERIFY_IS_EQUAL(result_value, 0.0f);
+          }
+        }
+      }
+    }
+  }
+}
+
+// Regression: a scalar-changing consumer (here `.cast<double>()`) sits above
+// pad in the assign. Before TensorConversionOp::block dropped the forwarded
+// destination on a non-degenerate cast, pad's prepareStorage would reuse a
+// double-sized buffer as int storage (assert in debug, corruption in
+// release). Mirrors test_concatenation_through_cast.
+template <int DataLayout>
+static void test_padding_through_cast() {
+  Tensor<int, 2, DataLayout> src(2, 3);
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) src(i, j) = i + 1 + 10 * j;
+  }
+  array<std::pair<ptrdiff_t, ptrdiff_t>, 2> paddings;
+  paddings[0] = std::make_pair(1, 1);
+  paddings[1] = std::make_pair(0, 0);
+  Tensor<double, 2, DataLayout> out(4, 3);
+  out = src.pad(paddings).template cast<double>();
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 4; ++i) {
+      const double expected = (i >= 1 && i < 3) ? static_cast<double>(src(i - 1, j)) : 0.0;
+      VERIFY_IS_APPROX(out(i, j), expected);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_padding) {
+  CALL_SUBTEST(test_simple_padding<ColMajor>());
+  CALL_SUBTEST(test_simple_padding<RowMajor>());
+  CALL_SUBTEST(test_padded_expr<ColMajor>());
+  CALL_SUBTEST(test_padded_expr<RowMajor>());
+  CALL_SUBTEST(test_padding_through_cast<ColMajor>());
+  CALL_SUBTEST(test_padding_through_cast<RowMajor>());
+}
diff --git a/contrib/test/tensor_padding_sycl.cpp b/contrib/test/tensor_padding_sycl.cpp
new file mode 100644
index 0000000..93e7727
--- /dev/null
+++ b/contrib/test/tensor_padding_sycl.cpp
@@ -0,0 +1,149 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_padding(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  tensor.setRandom();
+
+  array<std::pair<IndexType, IndexType>, 4> paddings;
+  paddings[0] = std::make_pair(0, 0);
+  paddings[1] = std::make_pair(2, 1);
+  paddings[2] = std::make_pair(3, 4);
+  paddings[3] = std::make_pair(0, 0);
+
+  IndexType padedSizeDim1 = 2;
+  IndexType padedSizeDim2 = 6;
+  IndexType padedSizeDim3 = 12;
+  IndexType padedSizeDim4 = 7;
+  array<IndexType, 4> padedtensorRange = {{padedSizeDim1, padedSizeDim2, padedSizeDim3, padedSizeDim4}};
+
+  Tensor<DataType, 4, DataLayout, IndexType> padded(padedtensorRange);
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(padded.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu2(gpu_data2, padedtensorRange);
+
+  VERIFY_IS_EQUAL(padded.dimension(0), 2 + 0);
+  VERIFY_IS_EQUAL(padded.dimension(1), 3 + 3);
+  VERIFY_IS_EQUAL(padded.dimension(2), 5 + 7);
+  VERIFY_IS_EQUAL(padded.dimension(3), 7 + 0);
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1.pad(paddings);
+  sycl_device.memcpyDeviceToHost(padded.data(), gpu_data2, (padded.size()) * sizeof(DataType));
+  for (IndexType i = 0; i < padedSizeDim1; ++i) {
+    for (IndexType j = 0; j < padedSizeDim2; ++j) {
+      for (IndexType k = 0; k < padedSizeDim3; ++k) {
+        for (IndexType l = 0; l < padedSizeDim4; ++l) {
+          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
+            VERIFY_IS_EQUAL(padded(i, j, k, l), tensor(i, j - 2, k - 3, l));
+          } else {
+            VERIFY_IS_EQUAL(padded(i, j, k, l), 0.0f);
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_padded_expr(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  tensor.setRandom();
+
+  array<std::pair<IndexType, IndexType>, 4> paddings;
+  paddings[0] = std::make_pair(0, 0);
+  paddings[1] = std::make_pair(2, 1);
+  paddings[2] = std::make_pair(3, 4);
+  paddings[3] = std::make_pair(0, 0);
+
+  Eigen::DSizes<IndexType, 2> reshape_dims;
+  reshape_dims[0] = 12;
+  reshape_dims[1] = 84;
+
+  Tensor<DataType, 2, DataLayout, IndexType> result(reshape_dims);
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(result.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu2(gpu_data2, reshape_dims);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
+  gpu2.device(sycl_device) = gpu1.pad(paddings).reshape(reshape_dims);
+  sycl_device.memcpyDeviceToHost(result.data(), gpu_data2, (result.size()) * sizeof(DataType));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 6; ++j) {
+      for (IndexType k = 0; k < 12; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          const float result_value =
+              DataLayout == ColMajor ? result(i + 2 * j, k + 12 * l) : result(j + 6 * i, l + 7 * k);
+          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
+            VERIFY_IS_EQUAL(result_value, tensor(i, j - 2, k - 3, l));
+          } else {
+            VERIFY_IS_EQUAL(result_value, 0.0f);
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_padding_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_padding<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_padding<DataType, ColMajor, int64_t>(sycl_device);
+  test_padded_expr<DataType, RowMajor, int64_t>(sycl_device);
+  test_padded_expr<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_padding_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_padding_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_padding_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_patch.cpp b/contrib/test/tensor_patch.cpp
new file mode 100644
index 0000000..a16e91e
--- /dev/null
+++ b/contrib/test/tensor_patch.cpp
@@ -0,0 +1,171 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_patch() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> patch_dims;
+
+  patch_dims[0] = 1;
+  patch_dims[1] = 1;
+  patch_dims[2] = 1;
+  patch_dims[3] = 1;
+
+  Tensor<float, 5, DataLayout> no_patch;
+  no_patch = tensor.extract_patches(patch_dims);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(no_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(4), tensor.size());
+  } else {
+    VERIFY_IS_EQUAL(no_patch.dimension(0), tensor.size());
+    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(4), 1);
+  }
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    VERIFY_IS_EQUAL(tensor.data()[i], no_patch.data()[i]);
+  }
+
+  patch_dims[0] = 2;
+  patch_dims[1] = 3;
+  patch_dims[2] = 5;
+  patch_dims[3] = 7;
+  Tensor<float, 5, DataLayout> single_patch;
+  single_patch = tensor.extract_patches(patch_dims);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(single_patch.dimension(0), 2);
+    VERIFY_IS_EQUAL(single_patch.dimension(1), 3);
+    VERIFY_IS_EQUAL(single_patch.dimension(2), 5);
+    VERIFY_IS_EQUAL(single_patch.dimension(3), 7);
+    VERIFY_IS_EQUAL(single_patch.dimension(4), 1);
+  } else {
+    VERIFY_IS_EQUAL(single_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(single_patch.dimension(1), 2);
+    VERIFY_IS_EQUAL(single_patch.dimension(2), 3);
+    VERIFY_IS_EQUAL(single_patch.dimension(3), 5);
+    VERIFY_IS_EQUAL(single_patch.dimension(4), 7);
+  }
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    VERIFY_IS_EQUAL(tensor.data()[i], single_patch.data()[i]);
+  }
+
+  patch_dims[0] = 1;
+  patch_dims[1] = 2;
+  patch_dims[2] = 2;
+  patch_dims[3] = 1;
+  Tensor<float, 5, DataLayout> twod_patch;
+  twod_patch = tensor.extract_patches(patch_dims);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(twod_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(3), 1);
+    VERIFY_IS_EQUAL(twod_patch.dimension(4), 2 * 2 * 4 * 7);
+  } else {
+    VERIFY_IS_EQUAL(twod_patch.dimension(0), 2 * 2 * 4 * 7);
+    VERIFY_IS_EQUAL(twod_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(3), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(4), 1);
+  }
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 4; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          int patch_loc;
+          if (DataLayout == ColMajor) {
+            patch_loc = i + 2 * (j + 2 * (k + 4 * l));
+          } else {
+            patch_loc = l + 7 * (k + 4 * (j + 2 * i));
+          }
+          for (int x = 0; x < 2; ++x) {
+            for (int y = 0; y < 2; ++y) {
+              if (DataLayout == ColMajor) {
+                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(0, x, y, 0, patch_loc));
+              } else {
+                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(patch_loc, 0, x, y, 0));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  patch_dims[0] = 1;
+  patch_dims[1] = 2;
+  patch_dims[2] = 3;
+  patch_dims[3] = 5;
+  Tensor<float, 5, DataLayout> threed_patch;
+  threed_patch = tensor.extract_patches(patch_dims);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(threed_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(threed_patch.dimension(1), 2);
+    VERIFY_IS_EQUAL(threed_patch.dimension(2), 3);
+    VERIFY_IS_EQUAL(threed_patch.dimension(3), 5);
+    VERIFY_IS_EQUAL(threed_patch.dimension(4), 2 * 2 * 3 * 3);
+  } else {
+    VERIFY_IS_EQUAL(threed_patch.dimension(0), 2 * 2 * 3 * 3);
+    VERIFY_IS_EQUAL(threed_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(threed_patch.dimension(2), 2);
+    VERIFY_IS_EQUAL(threed_patch.dimension(3), 3);
+    VERIFY_IS_EQUAL(threed_patch.dimension(4), 5);
+  }
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 3; ++l) {
+          int patch_loc;
+          if (DataLayout == ColMajor) {
+            patch_loc = i + 2 * (j + 2 * (k + 3 * l));
+          } else {
+            patch_loc = l + 3 * (k + 3 * (j + 2 * i));
+          }
+          for (int x = 0; x < 2; ++x) {
+            for (int y = 0; y < 3; ++y) {
+              for (int z = 0; z < 5; ++z) {
+                if (DataLayout == ColMajor) {
+                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(0, x, y, z, patch_loc));
+                } else {
+                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(patch_loc, 0, x, y, z));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_patch) {
+  CALL_SUBTEST(test_simple_patch<ColMajor>());
+  CALL_SUBTEST(test_simple_patch<RowMajor>());
+  //   CALL_SUBTEST(test_expr_shuffling());
+}
diff --git a/contrib/test/tensor_patch_sycl.cpp b/contrib/test/tensor_patch_sycl.cpp
new file mode 100644
index 0000000..faca3b6
--- /dev/null
+++ b/contrib/test/tensor_patch_sycl.cpp
@@ -0,0 +1,250 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_patch_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  array<IndexType, 5> patchTensorRange;
+  if (DataLayout == ColMajor) {
+    patchTensorRange = {{1, 1, 1, 1, sizeDim1 * sizeDim2 * sizeDim3 * sizeDim4}};
+  } else {
+    patchTensorRange = {{sizeDim1 * sizeDim2 * sizeDim3 * sizeDim4, 1, 1, 1, 1}};
+  }
+
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 5, DataLayout, IndexType> no_patch(patchTensorRange);
+
+  tensor.setRandom();
+
+  array<ptrdiff_t, 4> patch_dims;
+  patch_dims[0] = 1;
+  patch_dims[1] = 1;
+  patch_dims[2] = 1;
+  patch_dims[3] = 1;
+
+  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
+  size_t patchTensorBuffSize = no_patch.size() * sizeof(DataType);
+  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
+  DataType* gpu_data_no_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_no_patch(gpu_data_no_patch, patchTensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
+  gpu_no_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
+  sycl_device.memcpyDeviceToHost(no_patch.data(), gpu_data_no_patch, patchTensorBuffSize);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(no_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(4), tensor.size());
+  } else {
+    VERIFY_IS_EQUAL(no_patch.dimension(0), tensor.size());
+    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
+    VERIFY_IS_EQUAL(no_patch.dimension(4), 1);
+  }
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    VERIFY_IS_EQUAL(tensor.data()[i], no_patch.data()[i]);
+  }
+
+  patch_dims[0] = 2;
+  patch_dims[1] = 3;
+  patch_dims[2] = 5;
+  patch_dims[3] = 7;
+
+  if (DataLayout == ColMajor) {
+    patchTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, 1}};
+  } else {
+    patchTensorRange = {{1, sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  }
+  Tensor<DataType, 5, DataLayout, IndexType> single_patch(patchTensorRange);
+  patchTensorBuffSize = single_patch.size() * sizeof(DataType);
+  DataType* gpu_data_single_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_single_patch(gpu_data_single_patch, patchTensorRange);
+
+  gpu_single_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
+  sycl_device.memcpyDeviceToHost(single_patch.data(), gpu_data_single_patch, patchTensorBuffSize);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(single_patch.dimension(0), 2);
+    VERIFY_IS_EQUAL(single_patch.dimension(1), 3);
+    VERIFY_IS_EQUAL(single_patch.dimension(2), 5);
+    VERIFY_IS_EQUAL(single_patch.dimension(3), 7);
+    VERIFY_IS_EQUAL(single_patch.dimension(4), 1);
+  } else {
+    VERIFY_IS_EQUAL(single_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(single_patch.dimension(1), 2);
+    VERIFY_IS_EQUAL(single_patch.dimension(2), 3);
+    VERIFY_IS_EQUAL(single_patch.dimension(3), 5);
+    VERIFY_IS_EQUAL(single_patch.dimension(4), 7);
+  }
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    VERIFY_IS_EQUAL(tensor.data()[i], single_patch.data()[i]);
+  }
+  patch_dims[0] = 1;
+  patch_dims[1] = 2;
+  patch_dims[2] = 2;
+  patch_dims[3] = 1;
+
+  if (DataLayout == ColMajor) {
+    patchTensorRange = {{1, 2, 2, 1, 2 * 2 * 4 * 7}};
+  } else {
+    patchTensorRange = {{2 * 2 * 4 * 7, 1, 2, 2, 1}};
+  }
+  Tensor<DataType, 5, DataLayout, IndexType> twod_patch(patchTensorRange);
+  patchTensorBuffSize = twod_patch.size() * sizeof(DataType);
+  DataType* gpu_data_twod_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_twod_patch(gpu_data_twod_patch, patchTensorRange);
+
+  gpu_twod_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
+  sycl_device.memcpyDeviceToHost(twod_patch.data(), gpu_data_twod_patch, patchTensorBuffSize);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(twod_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(3), 1);
+    VERIFY_IS_EQUAL(twod_patch.dimension(4), 2 * 2 * 4 * 7);
+  } else {
+    VERIFY_IS_EQUAL(twod_patch.dimension(0), 2 * 2 * 4 * 7);
+    VERIFY_IS_EQUAL(twod_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(3), 2);
+    VERIFY_IS_EQUAL(twod_patch.dimension(4), 1);
+  }
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 4; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          int patch_loc;
+          if (DataLayout == ColMajor) {
+            patch_loc = i + 2 * (j + 2 * (k + 4 * l));
+          } else {
+            patch_loc = l + 7 * (k + 4 * (j + 2 * i));
+          }
+          for (int x = 0; x < 2; ++x) {
+            for (int y = 0; y < 2; ++y) {
+              if (DataLayout == ColMajor) {
+                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(0, x, y, 0, patch_loc));
+              } else {
+                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(patch_loc, 0, x, y, 0));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  patch_dims[0] = 1;
+  patch_dims[1] = 2;
+  patch_dims[2] = 3;
+  patch_dims[3] = 5;
+
+  if (DataLayout == ColMajor) {
+    patchTensorRange = {{1, 2, 3, 5, 2 * 2 * 3 * 3}};
+  } else {
+    patchTensorRange = {{2 * 2 * 3 * 3, 1, 2, 3, 5}};
+  }
+  Tensor<DataType, 5, DataLayout, IndexType> threed_patch(patchTensorRange);
+  patchTensorBuffSize = threed_patch.size() * sizeof(DataType);
+  DataType* gpu_data_threed_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_threed_patch(gpu_data_threed_patch, patchTensorRange);
+
+  gpu_threed_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
+  sycl_device.memcpyDeviceToHost(threed_patch.data(), gpu_data_threed_patch, patchTensorBuffSize);
+
+  if (DataLayout == ColMajor) {
+    VERIFY_IS_EQUAL(threed_patch.dimension(0), 1);
+    VERIFY_IS_EQUAL(threed_patch.dimension(1), 2);
+    VERIFY_IS_EQUAL(threed_patch.dimension(2), 3);
+    VERIFY_IS_EQUAL(threed_patch.dimension(3), 5);
+    VERIFY_IS_EQUAL(threed_patch.dimension(4), 2 * 2 * 3 * 3);
+  } else {
+    VERIFY_IS_EQUAL(threed_patch.dimension(0), 2 * 2 * 3 * 3);
+    VERIFY_IS_EQUAL(threed_patch.dimension(1), 1);
+    VERIFY_IS_EQUAL(threed_patch.dimension(2), 2);
+    VERIFY_IS_EQUAL(threed_patch.dimension(3), 3);
+    VERIFY_IS_EQUAL(threed_patch.dimension(4), 5);
+  }
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 3; ++l) {
+          int patch_loc;
+          if (DataLayout == ColMajor) {
+            patch_loc = i + 2 * (j + 2 * (k + 3 * l));
+          } else {
+            patch_loc = l + 3 * (k + 3 * (j + 2 * i));
+          }
+          for (int x = 0; x < 2; ++x) {
+            for (int y = 0; y < 3; ++y) {
+              for (int z = 0; z < 5; ++z) {
+                if (DataLayout == ColMajor) {
+                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(0, x, y, z, patch_loc));
+                } else {
+                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(patch_loc, 0, x, y, z));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_tensor);
+  sycl_device.deallocate(gpu_data_no_patch);
+  sycl_device.deallocate(gpu_data_single_patch);
+  sycl_device.deallocate(gpu_data_twod_patch);
+  sycl_device.deallocate(gpu_data_threed_patch);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_tensor_patch_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_patch_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_patch_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_patch_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_tensor_patch_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_tensor_patch_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_random.cpp b/contrib/test/tensor_random.cpp
new file mode 100644
index 0000000..45b1afc
--- /dev/null
+++ b/contrib/test/tensor_random.cpp
@@ -0,0 +1,216 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+template <typename Scalar>
+static void test_default() {
+  Tensor<Scalar, 1> vec(6);
+
+  // Fixme: we should check that the generated numbers follow a uniform
+  // distribution instead.
+  // For low-precision types (half, bfloat16), the RNG has limited distinct
+  // values (e.g. 128 for bfloat16), so adjacent collisions are possible.
+  // Retry a few times to avoid spurious failures.
+  bool all_distinct = false;
+  for (int attempt = 0; attempt < 10 && !all_distinct; ++attempt) {
+    vec.setRandom();
+    all_distinct = true;
+    for (int i = 1; i < 6; ++i) {
+      if (vec(i) == vec(i - 1)) {
+        all_distinct = false;
+        break;
+      }
+    }
+  }
+  VERIFY(all_distinct);
+}
+
+template <typename Scalar>
+static void test_normal() {
+  Tensor<Scalar, 1> vec(6);
+
+  // Fixme: we should check that the generated numbers follow a gaussian
+  // distribution instead.
+  bool all_distinct = false;
+  for (int attempt = 0; attempt < 10 && !all_distinct; ++attempt) {
+    vec.template setRandom<Eigen::internal::NormalRandomGenerator<Scalar>>();
+    all_distinct = true;
+    for (int i = 1; i < 6; ++i) {
+      if (vec(i) == vec(i - 1)) {
+        all_distinct = false;
+        break;
+      }
+    }
+  }
+  VERIFY(all_distinct);
+}
+
+template <typename Scalar>
+static void test_normal_all_finite(Eigen::Index size) {
+  // Regression test: the 16-bit uniform draw is exactly 0 with probability
+  // 2^-10 (half) / 2^-7 (bfloat16). Running the ratio-of-uniforms rejection
+  // in 16-bit arithmetic let log(0) = -inf poison the acceptance test and
+  // returned v / 0 = +/-inf (or 0/0 = NaN) at measurable rates.
+  Tensor<Scalar, 1> vec(size);
+  vec.template setRandom<Eigen::internal::NormalRandomGenerator<Scalar>>();
+  Eigen::Index num_not_finite = 0;
+  for (Eigen::Index i = 0; i < size; ++i) {
+    if (!(numext::isfinite)(vec(i))) ++num_not_finite;
+  }
+  VERIFY_IS_EQUAL(num_not_finite, Eigen::Index(0));
+}
+
+template <typename Scalar>
+static void test_uniform_range(Eigen::Index size) {
+  // All uniform draws must lie in [0, 1).
+  Tensor<Scalar, 1> vec(size);
+  vec.setRandom();
+  Eigen::Index num_out_of_range = 0;
+  for (Eigen::Index i = 0; i < size; ++i) {
+    if (!(vec(i) >= Scalar(0.0f) && vec(i) < Scalar(1.0f))) ++num_out_of_range;
+  }
+  VERIFY_IS_EQUAL(num_out_of_range, Eigen::Index(0));
+}
+
+// Every draw is a pure function of (seed, index), which is what functor_traits reports as IsRepeatable and what
+// lets the nullary evaluator serve blocks. So a materialized block has to hold exactly what the coefficient path
+// produces at the same tensor-linear indices, and evaluating one expression twice has to repeat the fill.
+template <typename Scalar, typename Generator, int Layout, int NumDims>
+static void test_block_shape(const DSizes<Index, NumDims>& dims, const DSizes<Index, NumDims>& origin,
+                             const DSizes<Index, NumDims>& sizes) {
+  using TensorT = Tensor<Scalar, NumDims, Layout>;
+  using Expr = TensorCwiseNullaryOp<Generator, const TensorT>;
+  using Evaluator = TensorEvaluator<const Expr, DefaultDevice>;
+  VERIFY(int(Evaluator::BlockAccess) == 1);
+
+  TensorT shape(dims);
+  const Expr expr = shape.template random<Generator>(Generator(1234));
+
+  DefaultDevice device;
+  Evaluator eval(expr, device);
+  eval.evalSubExprsIfNeeded(nullptr);
+  internal::TensorBlockScratchAllocator<DefaultDevice> scratch(device);
+
+  const DSizes<Index, NumDims> tensor_strides = internal::strides<Layout>(dims);
+  const DSizes<Index, NumDims> block_strides = internal::strides<Layout>(sizes);
+  Index offset = 0;
+  for (int d = 0; d < NumDims; ++d) offset += origin[d] * tensor_strides[d];
+
+  internal::TensorBlockDescriptor<NumDims, Index> desc(offset, sizes);
+  auto block = eval.block(desc, scratch);
+  const Scalar* data = block.data();
+  VERIFY(data != nullptr);
+
+  DSizes<Index, NumDims> coord;
+  for (int d = 0; d < NumDims; ++d) coord[d] = 0;
+  for (Index i = 0; i < sizes.TotalSize(); ++i) {
+    Index in_block = 0;
+    Index in_tensor = 0;
+    for (int d = 0; d < NumDims; ++d) {
+      in_block += coord[d] * block_strides[d];
+      in_tensor += (origin[d] + coord[d]) * tensor_strides[d];
+    }
+    VERIFY_IS_EQUAL(data[in_block], eval.coeff(in_tensor));
+    for (int d = 0; d < NumDims; ++d) {
+      const int dim = (Layout == ColMajor) ? d : NumDims - 1 - d;
+      if (++coord[dim] < sizes[dim]) break;
+      coord[dim] = 0;
+    }
+  }
+  block.cleanup();
+  eval.cleanup();
+
+  TensorT first = expr;
+  TensorT second = expr;
+  for (Index i = 0; i < first.size(); ++i) VERIFY_IS_EQUAL(first(i), second(i));
+}
+
+template <typename Scalar, typename Generator>
+static void test_block_materialization() {
+  // Blocks strictly inside the tensor, so their runs are separated in linear-index space: 2-D in both layouts,
+  // then 3-D, where the innermost dimension is a partial run either way.
+  test_block_shape<Scalar, Generator, ColMajor>(DSizes<Index, 2>(17, 23), DSizes<Index, 2>(3, 5),
+                                                DSizes<Index, 2>(8, 11));
+  test_block_shape<Scalar, Generator, RowMajor>(DSizes<Index, 2>(17, 23), DSizes<Index, 2>(3, 5),
+                                                DSizes<Index, 2>(8, 11));
+  test_block_shape<Scalar, Generator, ColMajor>(DSizes<Index, 3>(9, 7, 5), DSizes<Index, 3>(2, 1, 1),
+                                                DSizes<Index, 3>(5, 4, 3));
+  test_block_shape<Scalar, Generator, RowMajor>(DSizes<Index, 3>(9, 7, 5), DSizes<Index, 3>(2, 1, 1),
+                                                DSizes<Index, 3>(5, 4, 3));
+}
+
+template <typename Scalar>
+static void test_complex_draw_order() {
+  using Complex = std::complex<Scalar>;
+  uint64_t scalar_state = 1234, complex_state = scalar_state;
+  for (uint64_t index = 0; index < 32; ++index) {
+    const Scalar real = internal::RandomToTypeUniform<Scalar>(&scalar_state, index);
+    const Scalar imag = internal::RandomToTypeUniform<Scalar>(&scalar_state, index);
+    VERIFY_IS_EQUAL(internal::RandomToTypeUniform<Complex>(&complex_state, index), Complex(real, imag));
+    const Scalar normal_real = internal::RandomToTypeNormal<Scalar>(&scalar_state, index);
+    const Scalar normal_imag = internal::RandomToTypeNormal<Scalar>(&scalar_state, index);
+    VERIFY_IS_EQUAL(internal::RandomToTypeNormal<Complex>(&complex_state, index), Complex(normal_real, normal_imag));
+  }
+}
+
+struct MyGenerator {
+  MyGenerator() {}
+  MyGenerator(const MyGenerator&) {}
+
+  // Return a random value to be used.  "element_location" is the
+  // location of the entry to set in the tensor, it can typically
+  // be ignored.
+  int operator()(Eigen::DenseIndex element_location, Eigen::DenseIndex /*unused*/ = 0) const {
+    return static_cast<int>(3 * element_location);
+  }
+
+  // Same as above but generates several numbers at a time.
+  internal::packet_traits<int>::type packetOp(Eigen::DenseIndex packet_location,
+                                              Eigen::DenseIndex /*unused*/ = 0) const {
+    const int packetSize = internal::packet_traits<int>::size;
+    int values[packetSize];
+    for (int i = 0; i < packetSize; ++i) {
+      values[i] = static_cast<int>(3 * (packet_location + i));
+    }
+    return internal::ploadu<typename internal::packet_traits<int>::type>(values);
+  }
+};
+
+static void test_custom() {
+  Tensor<int, 1> vec(6);
+  vec.setRandom<MyGenerator>();
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(vec(i), 3 * i);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_random) {
+  CALL_SUBTEST((test_default<float>()));
+  CALL_SUBTEST((test_normal<float>()));
+  CALL_SUBTEST((test_default<double>()));
+  CALL_SUBTEST((test_normal<double>()));
+  CALL_SUBTEST((test_default<Eigen::half>()));
+  CALL_SUBTEST((test_normal<Eigen::half>()));
+  CALL_SUBTEST((test_default<Eigen::bfloat16>()));
+  CALL_SUBTEST((test_normal<Eigen::bfloat16>()));
+  CALL_SUBTEST((test_normal_all_finite<Eigen::half>(Eigen::Index(1) << 21)));
+  CALL_SUBTEST((test_normal_all_finite<Eigen::bfloat16>(Eigen::Index(1) << 18)));
+  CALL_SUBTEST((test_uniform_range<Eigen::half>(Eigen::Index(1) << 16)));
+  CALL_SUBTEST((test_uniform_range<Eigen::bfloat16>(Eigen::Index(1) << 16)));
+  CALL_SUBTEST((test_block_materialization<float, Eigen::internal::UniformRandomGenerator<float>>()));
+  CALL_SUBTEST((test_block_materialization<double, Eigen::internal::NormalRandomGenerator<double>>()));
+  CALL_SUBTEST(test_custom());
+  CALL_SUBTEST(test_complex_draw_order<float>());
+  CALL_SUBTEST(test_complex_draw_order<double>());
+}
diff --git a/contrib/test/tensor_random_gpu.cu b/contrib/test/tensor_random_gpu.cu
new file mode 100644
index 0000000..9bb6fdb
--- /dev/null
+++ b/contrib/test/tensor_random_gpu.cu
@@ -0,0 +1,250 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <Eigen/Tensor>
+
+void test_gpu_random_uniform() {
+  Tensor<float, 2> out(72, 97);
+  out.setZero();
+
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_out;
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2> > gpu_out(d_out, 72, 97);
+
+  gpu_out.device(gpu_device) = gpu_out.random();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  // For now we just check this code doesn't crash.
+  // TODO: come up with a valid test of randomness
+}
+
+void test_gpu_random_normal() {
+  Tensor<float, 2> out(72, 97);
+  out.setZero();
+
+  std::size_t out_bytes = out.size() * sizeof(float);
+
+  float* d_out;
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 2> > gpu_out(d_out, 72, 97);
+
+  Eigen::internal::NormalRandomGenerator<float> gen(true);
+  gpu_out.device(gpu_device) = gpu_out.random(gen);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+}
+
+template <typename Scalar>
+void test_gpu_random_uniform_range(int rows, int cols) {
+  Tensor<Scalar, 2> out(rows, cols);
+  out.setZero();
+
+  std::size_t out_bytes = out.size() * sizeof(Scalar);
+
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, rows, cols);
+
+  gpu_out.device(gpu_device) = gpu_out.random();
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  // All uniform draws must lie in [0, 1).
+  int num_out_of_range = 0;
+  for (int i = 0; i < out.size(); ++i) {
+    if (!(out.data()[i] >= Scalar(0.0f) && out.data()[i] < Scalar(1.0f))) ++num_out_of_range;
+  }
+  VERIFY_IS_EQUAL(num_out_of_range, 0);
+}
+
+template <typename Scalar>
+void test_gpu_random_normal_all_finite(int rows, int cols) {
+  Tensor<Scalar, 2> out(rows, cols);
+  out.setZero();
+
+  std::size_t out_bytes = out.size() * sizeof(Scalar);
+
+  Scalar* d_out;
+  gpuMalloc((void**)(&d_out), out_bytes);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, rows, cols);
+
+  Eigen::internal::NormalRandomGenerator<Scalar> gen(true);
+  gpu_out.device(gpu_device) = gpu_out.random(gen);
+
+  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
+  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
+
+  // Regression test for 16-bit types: the deviate must be computed in float,
+  // otherwise log(0) in the rejection algorithm emits NaN/Inf.
+  int num_not_finite = 0;
+  for (int i = 0; i < out.size(); ++i) {
+    if (!(numext::isfinite)(out.data()[i])) ++num_not_finite;
+  }
+  VERIFY_IS_EQUAL(num_not_finite, 0);
+}
+
+// Fills n elements on the device through `gen` and returns them. MapOptions selects the executor path: Aligned
+// takes the packet path, Unaligned the scalar one.
+template <typename Scalar, int MapOptions, typename Generator>
+static Tensor<Scalar, 1> device_random_fill(int n, const Generator& gen) {
+  const std::size_t bytes = n * sizeof(Scalar);
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+  Scalar* d_out = static_cast<Scalar*>(gpu_device.allocate(bytes));
+  Eigen::TensorMap<Eigen::Tensor<Scalar, 1>, MapOptions> gpu_out(d_out, n);
+  gpu_out.device(gpu_device) = gpu_out.random(gen);
+  Tensor<Scalar, 1> out(n);
+  gpu_device.memcpyDeviceToHost(out.data(), d_out, bytes);
+  gpu_device.synchronize();
+  gpu_device.deallocate(d_out);
+  return out;
+}
+
+// The generator travels into the kernel by value, so every thread starts from the same state, yet each element has
+// to come from its own stream. An unaligned map takes the scalar path and an aligned one the packet path; both have
+// to produce a 64-bucket histogram within 5% of flat (6.4 standard deviations at n = 2^20) with almost every
+// element different from element 0 (a correct 23-bit uniform repeats a given value about n / 2^23 times).
+template <int MapOptions>
+static void test_gpu_random_uniform_distribution() {
+  const int n = 1 << 20;
+  const int num_buckets = 64;
+  const int expected_per_bucket = n / num_buckets;
+  const int bucket_tolerance = expected_per_bucket / 20;
+  const int max_equal_to_first = n / 100;
+
+  const Tensor<float, 1> out =
+      device_random_fill<float, MapOptions>(n, Eigen::internal::UniformRandomGenerator<float>());
+
+  Eigen::Array<int, num_buckets, 1> histogram = Eigen::Array<int, num_buckets, 1>::Zero();
+  int num_out_of_range = 0;
+  int num_equal_to_first = 0;
+  for (int i = 0; i < n; ++i) {
+    const float x = out(i);
+    if (!(x >= 0.0f && x < 1.0f)) {
+      ++num_out_of_range;
+      continue;
+    }
+    ++histogram(static_cast<int>(x * num_buckets));
+    if (x == out(0)) ++num_equal_to_first;
+  }
+  VERIFY_IS_EQUAL(num_out_of_range, 0);
+  VERIFY(num_equal_to_first < max_equal_to_first);
+  VERIFY((histogram - expected_per_bucket).abs().maxCoeff() <= bucket_tolerance);
+}
+
+// Same two paths for the normal generator: sample mean, variance and the mass within one standard deviation,
+// each allowed about ten standard errors at n = 2^20, plus the distinctness check.
+template <int MapOptions>
+static void test_gpu_random_normal_distribution() {
+  const int n = 1 << 20;
+  const double mean_tolerance = 0.01;
+  const double variance_tolerance = 0.02;
+  const double one_sigma_mass = 0.682689;
+  const double one_sigma_tolerance = 0.005;
+  const int max_equal_to_first = n / 100;
+
+  const Tensor<float, 1> out =
+      device_random_fill<float, MapOptions>(n, Eigen::internal::NormalRandomGenerator<float>());
+
+  double sum = 0.0;
+  double sum_of_squares = 0.0;
+  int num_within_one_sigma = 0;
+  int num_equal_to_first = 0;
+  for (int i = 0; i < n; ++i) {
+    const double x = static_cast<double>(out(i));
+    sum += x;
+    sum_of_squares += x * x;
+    if (std::abs(x) < 1.0) ++num_within_one_sigma;
+    if (out(i) == out(0)) ++num_equal_to_first;
+  }
+  const double mean = sum / n;
+  const double variance = sum_of_squares / n - mean * mean;
+  VERIFY(std::abs(mean) < mean_tolerance);
+  VERIFY(std::abs(variance - 1.0) < variance_tolerance);
+  VERIFY(std::abs(double(num_within_one_sigma) / n - one_sigma_mass) < one_sigma_tolerance);
+  VERIFY(num_equal_to_first < max_equal_to_first);
+}
+
+// A seeded uniform generator is a pure function of (seed, index): the device fill reproduces the host fill bit for
+// bit whatever path either side takes (scalar or packet, at any packet width). The odd length leaves a scalar tail
+// behind the packet loop.
+template <typename Scalar, int MapOptions>
+static void test_gpu_random_matches_host() {
+  const int n = (1 << 16) + 3;
+  const uint64_t seed = 0x9e3779b97f4a7c15ULL;
+
+  Eigen::internal::UniformRandomGenerator<Scalar> gen(seed);
+  Tensor<Scalar, 1> host(n);
+  host = host.random(gen);
+
+  const Tensor<Scalar, 1> out = device_random_fill<Scalar, MapOptions>(n, gen);
+
+  for (int i = 0; i < n; ++i) {
+    VERIFY_IS_EQUAL(out(i), host(i));
+  }
+}
+
+static void test_complex() {
+  Tensor<std::complex<float>, 1> vec(6);
+  vec.setRandom();
+
+  // Fixme: we should check that the generated numbers follow a uniform
+  // distribution instead.
+  for (int i = 1; i < 6; ++i) {
+    VERIFY_IS_NOT_EQUAL(vec(i), vec(i - 1));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_random_gpu) {
+  CALL_SUBTEST(test_gpu_random_uniform());
+  CALL_SUBTEST(test_gpu_random_normal());
+  CALL_SUBTEST(test_gpu_random_uniform_range<Eigen::half>(256, 256));
+  CALL_SUBTEST(test_gpu_random_uniform_range<Eigen::bfloat16>(256, 256));
+  CALL_SUBTEST(test_gpu_random_normal_all_finite<Eigen::half>(1024, 2048));
+  CALL_SUBTEST(test_gpu_random_normal_all_finite<Eigen::bfloat16>(512, 512));
+  CALL_SUBTEST(test_gpu_random_uniform_distribution<Eigen::Unaligned>());
+  CALL_SUBTEST(test_gpu_random_uniform_distribution<Eigen::Aligned>());
+  CALL_SUBTEST(test_gpu_random_normal_distribution<Eigen::Unaligned>());
+  CALL_SUBTEST(test_gpu_random_normal_distribution<Eigen::Aligned>());
+  CALL_SUBTEST((test_gpu_random_matches_host<float, Eigen::Unaligned>()));
+  CALL_SUBTEST((test_gpu_random_matches_host<float, Eigen::Aligned>()));
+  CALL_SUBTEST((test_gpu_random_matches_host<double, Eigen::Unaligned>()));
+  CALL_SUBTEST((test_gpu_random_matches_host<double, Eigen::Aligned>()));
+  CALL_SUBTEST(test_complex());
+}
diff --git a/contrib/test/tensor_random_sycl.cpp b/contrib/test/tensor_random_sycl.cpp
new file mode 100644
index 0000000..72bb147
--- /dev/null
+++ b/contrib/test/tensor_random_sycl.cpp
@@ -0,0 +1,85 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_sycl_random_uniform(const Eigen::SyclDevice& sycl_device) {
+  Tensor<DataType, 2, DataLayout, IndexType> out(72, 97);
+  out.setZero();
+
+  std::size_t out_bytes = out.size() * sizeof(DataType);
+
+  IndexType sizeDim0 = 72;
+  IndexType sizeDim1 = 97;
+
+  array<IndexType, 2> tensorRange = {{sizeDim0, sizeDim1}};
+
+  DataType* d_out = static_cast<DataType*>(sycl_device.allocate(out_bytes));
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_out(d_out, tensorRange);
+
+  gpu_out.device(sycl_device) = gpu_out.random();
+  sycl_device.memcpyDeviceToHost(out.data(), d_out, out_bytes);
+
+  // For now we just check the code doesn't crash.
+  // TODO: come up with a valid test of randomness
+  sycl_device.deallocate(d_out);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_random_normal(const Eigen::SyclDevice& sycl_device) {
+  Tensor<DataType, 2, DataLayout, IndexType> out(72, 97);
+  out.setZero();
+  std::size_t out_bytes = out.size() * sizeof(DataType);
+
+  IndexType sizeDim0 = 72;
+  IndexType sizeDim1 = 97;
+
+  array<IndexType, 2> tensorRange = {{sizeDim0, sizeDim1}};
+
+  DataType* d_out = static_cast<DataType*>(sycl_device.allocate(out_bytes));
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_out(d_out, tensorRange);
+  Eigen::internal::NormalRandomGenerator<DataType> gen(true);
+  gpu_out.device(sycl_device) = gpu_out.random(gen);
+  sycl_device.memcpyDeviceToHost(out.data(), d_out, out_bytes);
+
+  // For now we just check the code doesn't crash.
+  // TODO: come up with a valid test of randomness
+  sycl_device.deallocate(d_out);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_random_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_sycl_random_uniform<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_random_uniform<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_random_normal<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_random_normal<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_random_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_random_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_random_test_per_device<float>(device));
+#ifdef EIGEN_SYCL_DOUBLE_SUPPORT
+    CALL_SUBTEST(sycl_random_test_per_device<double>(device));
+#endif
+  }
+}
diff --git a/contrib/test/tensor_reduction.cpp b/contrib/test/tensor_reduction.cpp
new file mode 100644
index 0000000..1de0712
--- /dev/null
+++ b/contrib/test/tensor_reduction.cpp
@@ -0,0 +1,791 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <limits>
+#include <numeric>
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_trivial_reductions() {
+  {
+    Tensor<float, 0, DataLayout> tensor;
+    tensor.setRandom();
+    array<ptrdiff_t, 0> reduction_axis;
+
+    Tensor<float, 0, DataLayout> result = tensor.sum(reduction_axis);
+    VERIFY_IS_EQUAL(result(), tensor());
+  }
+
+  {
+    Tensor<float, 1, DataLayout> tensor(7);
+    tensor.setRandom();
+    array<ptrdiff_t, 0> reduction_axis;
+
+    Tensor<float, 1, DataLayout> result = tensor.sum(reduction_axis);
+    VERIFY_IS_EQUAL(result.dimension(0), 7);
+    for (int i = 0; i < 7; ++i) {
+      VERIFY_IS_EQUAL(result(i), tensor(i));
+    }
+  }
+
+  {
+    Tensor<float, 2, DataLayout> tensor(2, 3);
+    tensor.setRandom();
+    array<ptrdiff_t, 0> reduction_axis;
+
+    Tensor<float, 2, DataLayout> result = tensor.sum(reduction_axis);
+    VERIFY_IS_EQUAL(result.dimension(0), 2);
+    VERIFY_IS_EQUAL(result.dimension(1), 3);
+    for (int i = 0; i < 2; ++i) {
+      for (int j = 0; j < 3; ++j) {
+        VERIFY_IS_EQUAL(result(i, j), tensor(i, j));
+      }
+    }
+  }
+}
+
+template <typename Scalar, int DataLayout>
+static void test_scalar_reduction_conversion() {
+  using TensorType = Tensor<Scalar, 4, DataLayout>;
+  using PartialReductionDims = array<ptrdiff_t, 2>;
+  using FullReduction = decltype(std::declval<const TensorType&>().sum());
+  using PartialReduction = decltype(std::declval<const TensorType&>().sum(std::declval<const PartialReductionDims&>()));
+
+  static_assert(std::is_convertible<FullReduction, Scalar>::value, "full reductions should convert to scalars");
+  static_assert(!std::is_convertible<PartialReduction, Scalar>::value,
+                "partial reductions should not convert to scalars");
+
+  TensorType tensor(2, 2, 2, 2);
+  Scalar expected_sum(0);
+  Scalar expected_prod(1);
+  Scalar expected_min = NumTraits<Scalar>::highest();
+  Scalar expected_max = NumTraits<Scalar>::lowest();
+  for (int i = 0; i < tensor.size(); ++i) {
+    // Bound the product so the half test does not overflow.
+    const Scalar value = static_cast<Scalar>((i % 3) + 1);
+    tensor(i) = value;
+    expected_sum += value;
+    expected_prod *= value;
+    expected_min = numext::mini(expected_min, value);
+    expected_max = numext::maxi(expected_max, value);
+  }
+
+  const Scalar sum = tensor.sum();
+  array<ptrdiff_t, 4> reduction_axis4 = {0, 1, 2, 3};
+  const Scalar sum_from_dims = tensor.sum(reduction_axis4);
+  const Scalar prod = tensor.prod();
+  const Scalar smallest = tensor.minimum();
+  const Scalar largest = tensor.maximum();
+  const Scalar mean = tensor.mean();
+  const Scalar expected_mean = expected_sum / static_cast<Scalar>(tensor.size());
+
+  if (NumTraits<Scalar>::IsInteger) {
+    VERIFY_IS_EQUAL(sum, expected_sum);
+    VERIFY_IS_EQUAL(sum_from_dims, expected_sum);
+    VERIFY_IS_EQUAL(prod, expected_prod);
+    VERIFY_IS_EQUAL(smallest, expected_min);
+    VERIFY_IS_EQUAL(largest, expected_max);
+    VERIFY_IS_EQUAL(mean, expected_mean);
+  } else {
+    VERIFY_IS_APPROX(sum, expected_sum);
+    VERIFY_IS_APPROX(sum_from_dims, expected_sum);
+    VERIFY_IS_APPROX(prod, expected_prod);
+    VERIFY_IS_APPROX(smallest, expected_min);
+    VERIFY_IS_APPROX(largest, expected_max);
+    VERIFY_IS_APPROX(mean, expected_mean);
+  }
+}
+
+template <typename Scalar, int DataLayout>
+static void test_scalar_reduction_mixed_operators() {
+  // Mixed scalar operations must stay lazy despite the reduction's implicit scalar conversion.
+  Tensor<Scalar, 2, DataLayout> tensor(3, 4);
+  tensor.setConstant(Scalar(2));
+
+  // Scalar-left overloads must not pollute ADL for NumTraits enums.
+  static_assert(NumTraits<Scalar>::MulCost + 1 > 0, "NumTraits enum arithmetic should not be ambiguous");
+
+  static_assert(!std::is_same<decltype(tensor.sum() > 0), bool>::value,
+                "scalar comparisons on a full reduction should stay lazy expressions");
+  static_assert(!std::is_arithmetic<decltype(2 * tensor.sum())>::value,
+                "scalar arithmetic on a full reduction should stay lazy expressions");
+
+  const Tensor<bool, 0, DataLayout> gt = tensor.sum() > 0;
+  VERIFY(gt());
+  const Tensor<bool, 0, DataLayout> eq = tensor.sum() == 24;
+  VERIFY(eq());
+  const Tensor<bool, 0, DataLayout> lt = tensor.sum() < 1L;
+  VERIFY(!lt());
+  const Tensor<bool, 0, DataLayout> ge = tensor.sum() >= 0.0f;
+  VERIFY(ge());
+  const Tensor<bool, 0, DataLayout> le = tensor.sum() <= 100u;
+  VERIFY(le());
+  const Tensor<bool, 0, DataLayout> ne = tensor.sum() != 0;
+  VERIFY(ne());
+  const Tensor<Scalar, 0, DataLayout> twice = 2 * tensor.sum();
+  VERIFY_IS_EQUAL(twice(), Scalar(48));
+  const Tensor<Scalar, 0, DataLayout> plus_one = 1 + tensor.sum();
+  VERIFY_IS_EQUAL(plus_one(), Scalar(25));
+  const Tensor<Scalar, 0, DataLayout> from_25 = 25 - tensor.sum();
+  VERIFY_IS_EQUAL(from_25(), Scalar(1));
+  const Tensor<Scalar, 0, DataLayout> ratio = 48 / tensor.sum();
+  VERIFY_IS_EQUAL(ratio(), Scalar(2));
+  const Tensor<Scalar, 0, DataLayout> scaled = 2.0 * tensor.sum();
+  VERIFY_IS_EQUAL(scaled(), Scalar(48));
+
+  // Unscoped enums must remain valid scalar operands.
+  enum MixedOpsTestEnum { kEnumTwo = 2 };
+  const Tensor<bool, 0, DataLayout> gt_enum = tensor.sum() > kEnumTwo;
+  VERIFY(gt_enum());
+  const Tensor<Scalar, 0, DataLayout> twice_enum = kEnumTwo * tensor.sum();
+  VERIFY_IS_EQUAL(twice_enum(), Scalar(48));
+}
+
+static void test_scalar_reduction_mixed_operators_mod() {
+  Tensor<int, 2> tensor(3, 4);
+  tensor.setConstant(2);
+  const Tensor<int, 0> rem = tensor.sum() % 5L;
+  VERIFY_IS_EQUAL(rem(), 4);
+}
+
+template <typename Scalar, int DataLayout>
+static void test_simple_reductions() {
+  Tensor<Scalar, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  // Add a little offset so that the product reductions won't be close to zero.
+  tensor += tensor.constant(Scalar(0.5f));
+  array<ptrdiff_t, 2> reduction_axis2;
+  reduction_axis2[0] = 1;
+  reduction_axis2[1] = 3;
+
+  Tensor<Scalar, 2, DataLayout> result = tensor.sum(reduction_axis2);
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 5);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      Scalar sum = Scalar(0.0f);
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          sum += tensor(i, k, j, l);
+        }
+      }
+      VERIFY_IS_APPROX(result(i, j), sum);
+    }
+  }
+
+  {
+    Tensor<Scalar, 0, DataLayout> sum1 = tensor.sum();
+    VERIFY_IS_EQUAL(sum1.rank(), 0);
+
+    array<ptrdiff_t, 4> reduction_axis4;
+    reduction_axis4[0] = 0;
+    reduction_axis4[1] = 1;
+    reduction_axis4[2] = 2;
+    reduction_axis4[3] = 3;
+    Tensor<Scalar, 0, DataLayout> sum2 = tensor.sum(reduction_axis4);
+    VERIFY_IS_EQUAL(sum2.rank(), 0);
+
+    VERIFY_IS_APPROX(sum1(), sum2());
+  }
+
+  reduction_axis2[0] = 0;
+  reduction_axis2[1] = 2;
+  result = tensor.prod(reduction_axis2);
+  VERIFY_IS_EQUAL(result.dimension(0), 3);
+  VERIFY_IS_EQUAL(result.dimension(1), 7);
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      Scalar prod = Scalar(1.0f);
+      for (int k = 0; k < 2; ++k) {
+        for (int l = 0; l < 5; ++l) {
+          prod *= tensor(k, i, l, j);
+        }
+      }
+      VERIFY_IS_APPROX(result(i, j), prod);
+    }
+  }
+
+  {
+    Tensor<Scalar, 0, DataLayout> prod1 = tensor.prod();
+    VERIFY_IS_EQUAL(prod1.rank(), 0);
+
+    array<ptrdiff_t, 4> reduction_axis4;
+    reduction_axis4[0] = 0;
+    reduction_axis4[1] = 1;
+    reduction_axis4[2] = 2;
+    reduction_axis4[3] = 3;
+    Tensor<Scalar, 0, DataLayout> prod2 = tensor.prod(reduction_axis4);
+    VERIFY_IS_EQUAL(prod2.rank(), 0);
+
+    VERIFY_IS_APPROX(prod1(), prod2());
+  }
+
+  reduction_axis2[0] = 0;
+  reduction_axis2[1] = 2;
+  result = tensor.maximum(reduction_axis2);
+  VERIFY_IS_EQUAL(result.dimension(0), 3);
+  VERIFY_IS_EQUAL(result.dimension(1), 7);
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      Scalar max_val = std::numeric_limits<Scalar>::lowest();
+      for (int k = 0; k < 2; ++k) {
+        for (int l = 0; l < 5; ++l) {
+          max_val = (std::max)(max_val, tensor(k, i, l, j));
+        }
+      }
+      VERIFY_IS_APPROX(result(i, j), max_val);
+    }
+  }
+
+  {
+    Tensor<Scalar, 0, DataLayout> max1 = tensor.maximum();
+    VERIFY_IS_EQUAL(max1.rank(), 0);
+
+    array<ptrdiff_t, 4> reduction_axis4;
+    reduction_axis4[0] = 0;
+    reduction_axis4[1] = 1;
+    reduction_axis4[2] = 2;
+    reduction_axis4[3] = 3;
+    Tensor<Scalar, 0, DataLayout> max2 = tensor.maximum(reduction_axis4);
+    VERIFY_IS_EQUAL(max2.rank(), 0);
+
+    VERIFY_IS_APPROX(max1(), max2());
+  }
+
+  reduction_axis2[0] = 0;
+  reduction_axis2[1] = 1;
+  result = tensor.minimum(reduction_axis2);
+  VERIFY_IS_EQUAL(result.dimension(0), 5);
+  VERIFY_IS_EQUAL(result.dimension(1), 7);
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      Scalar min_val = (std::numeric_limits<Scalar>::max)();
+      for (int k = 0; k < 2; ++k) {
+        for (int l = 0; l < 3; ++l) {
+          min_val = (std::min)(min_val, tensor(k, l, i, j));
+        }
+      }
+      VERIFY_IS_APPROX(result(i, j), min_val);
+    }
+  }
+
+  {
+    Tensor<Scalar, 0, DataLayout> min1 = tensor.minimum();
+    VERIFY_IS_EQUAL(min1.rank(), 0);
+
+    array<ptrdiff_t, 4> reduction_axis4;
+    reduction_axis4[0] = 0;
+    reduction_axis4[1] = 1;
+    reduction_axis4[2] = 2;
+    reduction_axis4[3] = 3;
+    Tensor<Scalar, 0, DataLayout> min2 = tensor.minimum(reduction_axis4);
+    VERIFY_IS_EQUAL(min2.rank(), 0);
+
+    VERIFY_IS_APPROX(min1(), min2());
+  }
+
+  reduction_axis2[0] = 0;
+  reduction_axis2[1] = 1;
+  result = tensor.mean(reduction_axis2);
+  VERIFY_IS_EQUAL(result.dimension(0), 5);
+  VERIFY_IS_EQUAL(result.dimension(1), 7);
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      Scalar sum = Scalar(0.0f);
+      int count = 0;
+      for (int k = 0; k < 2; ++k) {
+        for (int l = 0; l < 3; ++l) {
+          sum += tensor(k, l, i, j);
+          ++count;
+        }
+      }
+      VERIFY_IS_APPROX(result(i, j), sum / Scalar(count));
+    }
+  }
+
+  {
+    Tensor<Scalar, 0, DataLayout> mean1 = tensor.mean();
+    VERIFY_IS_EQUAL(mean1.rank(), 0);
+
+    array<ptrdiff_t, 4> reduction_axis4;
+    reduction_axis4[0] = 0;
+    reduction_axis4[1] = 1;
+    reduction_axis4[2] = 2;
+    reduction_axis4[3] = 3;
+    Tensor<Scalar, 0, DataLayout> mean2 = tensor.mean(reduction_axis4);
+    VERIFY_IS_EQUAL(mean2.rank(), 0);
+
+    VERIFY_IS_APPROX(mean1(), mean2());
+  }
+}
+
+static void test_all_any() {
+  Tensor<int, 1> ints(10);
+  std::iota(ints.data(), ints.data() + ints.dimension(0), 0);
+
+  TensorFixedSize<bool, Sizes<>> all_;
+  all_ = ints.all();
+  VERIFY(!all_());
+  all_ = (ints >= ints.constant(0)).all();
+  VERIFY(all_());
+
+  TensorFixedSize<bool, Sizes<>> any;
+  any = (ints > ints.constant(10)).any();
+  VERIFY(!any());
+  any = (ints < ints.constant(1)).any();
+  VERIFY(any());
+}
+
+template <int DataLayout>
+static void test_reductions_in_expr() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 2> reduction_axis2;
+  reduction_axis2[0] = 1;
+  reduction_axis2[1] = 3;
+
+  Tensor<float, 2, DataLayout> result(2, 5);
+  result = result.constant(1.0f) - tensor.sum(reduction_axis2);
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 5);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      float sum = 0.0f;
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          sum += tensor(i, k, j, l);
+        }
+      }
+      VERIFY_IS_APPROX(result(i, j), 1.0f - sum);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_full_reductions() {
+  Tensor<float, 2, DataLayout> tensor(2, 3);
+  tensor.setRandom();
+  array<ptrdiff_t, 2> reduction_axis;
+  reduction_axis[0] = 0;
+  reduction_axis[1] = 1;
+
+  Tensor<float, 0, DataLayout> result = tensor.sum(reduction_axis);
+  VERIFY_IS_EQUAL(result.rank(), 0);
+
+  float sum = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      sum += tensor(i, j);
+    }
+  }
+  VERIFY_IS_APPROX(result(0), sum);
+
+  result = tensor.square().sum(reduction_axis).sqrt();
+  VERIFY_IS_EQUAL(result.rank(), 0);
+
+  sum = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      sum += tensor(i, j) * tensor(i, j);
+    }
+  }
+  VERIFY_IS_APPROX(result(), sqrtf(sum));
+}
+
+struct UserReducer {
+  static const bool PacketAccess = false;
+  UserReducer(float offset) : offset_(offset) {}
+  void reduce(const float val, float* accum) { *accum += val * val; }
+  float initialize() const { return 0; }
+  float finalize(const float accum) const { return 1.0f / (accum + offset_); }
+
+ private:
+  const float offset_;
+};
+
+// A reducer that transforms each value it accepts (sum of squares), with reducer_traits
+// declaring PacketAccess. Its reduce() cannot merge two partial accumulators — feeding a partial
+// sum back through reduce() would square it — so the scalar unrolled path must not engage: the
+// gate is reducer_can_reorder_accumulators, which such a reducer does not opt into, not
+// PacketAccess. long double has no packets, which forces the scalar path while the declared
+// PacketAccess stays true.
+struct SquaredSumReducer {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const long double t, long double* accum) const { *accum += t * t; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE long double initialize() const { return 0; }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE long double finalize(const long double accum) const { return accum; }
+};
+
+namespace Eigen {
+namespace internal {
+template <typename Device>
+struct reducer_traits<SquaredSumReducer, Device> {
+  enum { Cost = 1, PacketAccess = true, IsStateful = false, IsExactlyAssociative = true };
+};
+}  // namespace internal
+}  // namespace Eigen
+
+template <int DataLayout>
+static void test_value_transforming_reducer() {
+  // The opt-ins that let the unrolled path interleave operands, pinned at both ends: a reducer
+  // that transforms each value, and one that carries state, must stay out however they declare
+  // PacketAccess.
+  STATIC_CHECK((internal::reducer_can_reorder_accumulators<internal::SumReducer<float>>::value));
+  STATIC_CHECK((internal::reducer_can_reorder_accumulators<internal::MinReducer<float>>::value));
+  STATIC_CHECK((!internal::reducer_can_reorder_accumulators<SquaredSumReducer>::value));
+  STATIC_CHECK((!internal::reducer_can_reorder_accumulators<internal::MeanReducer<float>>::value));
+
+  Tensor<long double, 1, DataLayout> t(12);
+  long double expected = 0;
+  for (int i = 0; i < 12; ++i) {
+    t(i) = static_cast<long double>(i + 1);
+    expected += t(i) * t(i);
+  }
+  array<ptrdiff_t, 1> reduction_axis;
+  reduction_axis[0] = 0;
+  SquaredSumReducer reducer;
+  Tensor<long double, 0, DataLayout> result = t.reduce(reduction_axis, reducer);
+  VERIFY_IS_EQUAL(result(), expected);  // 1^2 + ... + 12^2 = 650, exact in long double
+}
+
+template <int DataLayout>
+static void test_user_defined_reductions() {
+  Tensor<float, 2, DataLayout> tensor(5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 1> reduction_axis;
+  reduction_axis[0] = 1;
+
+  UserReducer reducer(10.0f);
+  Tensor<float, 1, DataLayout> result = tensor.reduce(reduction_axis, reducer);
+  VERIFY_IS_EQUAL(result.dimension(0), 5);
+  for (int i = 0; i < 5; ++i) {
+    float expected = 10.0f;
+    for (int j = 0; j < 7; ++j) {
+      expected += tensor(i, j) * tensor(i, j);
+    }
+    expected = 1.0f / expected;
+    VERIFY_IS_APPROX(result(i), expected);
+  }
+}
+
+template <int DataLayout>
+static void test_tensor_maps() {
+  int inputs[2 * 3 * 5 * 7];
+  TensorMap<Tensor<int, 4, DataLayout>> tensor_map(inputs, 2, 3, 5, 7);
+  TensorMap<Tensor<const int, 4, DataLayout>> tensor_map_const(inputs, 2, 3, 5, 7);
+  const TensorMap<Tensor<const int, 4, DataLayout>> tensor_map_const_const(inputs, 2, 3, 5, 7);
+
+  setRandomDataInRange(tensor_map, -1000, 1000);
+  array<ptrdiff_t, 2> reduction_axis;
+  reduction_axis[0] = 1;
+  reduction_axis[1] = 3;
+
+  Tensor<int, 2, DataLayout> result = tensor_map.sum(reduction_axis);
+  Tensor<int, 2, DataLayout> result2 = tensor_map_const.sum(reduction_axis);
+  Tensor<int, 2, DataLayout> result3 = tensor_map_const_const.sum(reduction_axis);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      int sum = 0;
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          sum += tensor_map(i, k, j, l);
+        }
+      }
+      VERIFY_IS_EQUAL(result(i, j), sum);
+      VERIFY_IS_EQUAL(result2(i, j), sum);
+      VERIFY_IS_EQUAL(result3(i, j), sum);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_static_dims() {
+  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
+  Tensor<float, 2, DataLayout> out(72, 97);
+  in.setRandom();
+
+  Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<3>> reduction_axis;
+
+  out = in.maximum(reduction_axis);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 97; ++j) {
+      float expected = -1e10f;
+      for (int k = 0; k < 53; ++k) {
+        for (int l = 0; l < 113; ++l) {
+          expected = (std::max)(expected, in(i, k, j, l));
+        }
+      }
+      VERIFY_IS_EQUAL(out(i, j), expected);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_innermost_last_dims() {
+  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
+  Tensor<float, 2, DataLayout> out(97, 113);
+  in.setRandom();
+
+  // Reduce on the innermost dimensions.
+  // This triggers the use of packets for ColMajor.
+  Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>> reduction_axis;
+
+  out = in.maximum(reduction_axis);
+
+  for (int i = 0; i < 97; ++i) {
+    for (int j = 0; j < 113; ++j) {
+      float expected = -1e10f;
+      for (int k = 0; k < 53; ++k) {
+        for (int l = 0; l < 72; ++l) {
+          expected = (std::max)(expected, in(l, k, i, j));
+        }
+      }
+      VERIFY_IS_EQUAL(out(i, j), expected);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_innermost_first_dims() {
+  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
+  Tensor<float, 2, DataLayout> out(72, 53);
+  in.setRandom();
+
+  // Reduce on the innermost dimensions.
+  // This triggers the use of packets for RowMajor.
+  Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>> reduction_axis;
+
+  out = in.maximum(reduction_axis);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 53; ++j) {
+      float expected = -1e10f;
+      for (int k = 0; k < 97; ++k) {
+        for (int l = 0; l < 113; ++l) {
+          expected = (std::max)(expected, in(i, j, k, l));
+        }
+      }
+      VERIFY_IS_EQUAL(out(i, j), expected);
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_reduce_middle_dims() {
+  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
+  Tensor<float, 2, DataLayout> out(72, 53);
+  in.setRandom();
+
+  // Reduce on the innermost dimensions.
+  // This triggers the use of packets for RowMajor.
+  Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<2>> reduction_axis;
+
+  out = in.maximum(reduction_axis);
+
+  for (int i = 0; i < 72; ++i) {
+    for (int j = 0; j < 113; ++j) {
+      float expected = -1e10f;
+      for (int k = 0; k < 53; ++k) {
+        for (int l = 0; l < 97; ++l) {
+          expected = (std::max)(expected, in(i, k, l, j));
+        }
+      }
+      VERIFY_IS_EQUAL(out(i, j), expected);
+    }
+  }
+}
+
+// Exercises the runtime innermost-dim detection added at TensorReduction.h:817
+// (coeff path) and :861 (packet path). The static `ReducingInnerMostDims`
+// predicate only fires when the reduce-dim container is an IndexList; with
+// Eigen::array it stays false at compile time, but the m_reducingInnerMostDims
+// runtime mirror picks up the same fast path. We verify correctness against a
+// manual sum and check that the result is bit-identical to the IndexList form.
+template <int DataLayout>
+static void test_dynamic_innermost_dims() {
+  // 2D: ColMajor reduces axis 0 (innermost); RowMajor reduces axis 1 (innermost).
+  // Size chosen >> PacketSize so packet() drives the hot path.
+  Tensor<float, 2, DataLayout> in_2d(127, 53);
+  in_2d.setRandom();
+  Eigen::array<int, 1> dyn_axis_2d{(DataLayout == ColMajor) ? 0 : 1};
+  Tensor<float, 1, DataLayout> out_2d_dyn = in_2d.sum(dyn_axis_2d);
+
+  Eigen::IndexList<Eigen::type2index<(DataLayout == ColMajor) ? 0 : 1>> static_axis_2d;
+  Tensor<float, 1, DataLayout> out_2d_static = in_2d.sum(static_axis_2d);
+
+  const int preserved_2d = (DataLayout == ColMajor) ? 53 : 127;
+  const int reduced_2d = (DataLayout == ColMajor) ? 127 : 53;
+  for (int i = 0; i < preserved_2d; ++i) {
+    float expected = 0;
+    for (int j = 0; j < reduced_2d; ++j) {
+      expected += (DataLayout == ColMajor) ? in_2d(j, i) : in_2d(i, j);
+    }
+    VERIFY_IS_APPROX(out_2d_dyn(i), expected);
+    VERIFY_IS_EQUAL(out_2d_dyn(i), out_2d_static(i));
+  }
+
+  // 4D: reduce the two innermost dims at once. This is the multi-reduce case
+  // where the runtime mirror also needs to recognize the contiguous block.
+  Tensor<float, 4, DataLayout> in_4d(31, 17, 19, 23);
+  in_4d.setRandom();
+  Eigen::array<int, 2> dyn_axes_4d = (DataLayout == ColMajor) ? Eigen::array<int, 2>{0, 1} : Eigen::array<int, 2>{2, 3};
+  Tensor<float, 2, DataLayout> out_4d_dyn = in_4d.sum(dyn_axes_4d);
+  Eigen::IndexList<Eigen::type2index<(DataLayout == ColMajor) ? 0 : 2>,
+                   Eigen::type2index<(DataLayout == ColMajor) ? 1 : 3>>
+      static_axes_4d;
+  Tensor<float, 2, DataLayout> out_4d_static = in_4d.sum(static_axes_4d);
+
+  if (DataLayout == ColMajor) {
+    for (int i = 0; i < 19; ++i) {
+      for (int j = 0; j < 23; ++j) {
+        VERIFY_IS_EQUAL(out_4d_dyn(i, j), out_4d_static(i, j));
+      }
+    }
+  } else {
+    for (int i = 0; i < 31; ++i) {
+      for (int j = 0; j < 17; ++j) {
+        VERIFY_IS_EQUAL(out_4d_dyn(i, j), out_4d_static(i, j));
+      }
+    }
+  }
+
+  // Negative case: reducing a non-innermost dim must NOT take the runtime
+  // fast path. We can't observe the dispatch directly, but bit-identity with
+  // a manual sum + agreement with the IndexList form covers correctness.
+  Eigen::array<int, 1> outer_axis{(DataLayout == ColMajor) ? 1 : 0};
+  Tensor<float, 1, DataLayout> out_outer = in_2d.sum(outer_axis);
+  const int preserved_outer = (DataLayout == ColMajor) ? 127 : 53;
+  const int reduced_outer = (DataLayout == ColMajor) ? 53 : 127;
+  for (int i = 0; i < preserved_outer; ++i) {
+    float expected = 0;
+    for (int j = 0; j < reduced_outer; ++j) {
+      expected += (DataLayout == ColMajor) ? in_2d(i, j) : in_2d(j, i);
+    }
+    VERIFY_IS_APPROX(out_outer(i), expected);
+  }
+}
+
+template <int DataLayout>
+static void test_mixed_type_scalar_arithmetic() {
+  Tensor<float, 2, DataLayout> in(2, 2);
+  in.setConstant(1.0f);
+  Tensor<float, 0, DataLayout> result;
+
+  // Mixed type: double OP TensorReductionOp<float>
+  result = 0.5 * in.sum();
+  VERIFY_IS_EQUAL(result(), 2.0f);
+  result = 0.5 + in.sum();
+  VERIFY_IS_EQUAL(result(), 4.5f);
+  result = 0.5 - in.sum();
+  VERIFY_IS_EQUAL(result(), -3.5f);
+  result = 2.0 / in.sum();
+  VERIFY_IS_EQUAL(result(), 0.5f);
+
+  // Mixed type: TensorReductionOp<float> OP double
+  result = in.sum() * 0.5;
+  VERIFY_IS_EQUAL(result(), 2.0f);
+  result = in.sum() + 0.5;
+  VERIFY_IS_EQUAL(result(), 4.5f);
+  result = in.sum() - 0.5;
+  VERIFY_IS_EQUAL(result(), 3.5f);
+  result = in.sum() / 0.5;
+  VERIFY_IS_EQUAL(result(), 8.0f);
+
+  // Mixed type: TensorReductionOp<float> OP int
+  result = in.sum() * 2;
+  VERIFY_IS_EQUAL(result(), 8.0f);
+
+  // Reductions on both sides must keep using the tensor-tensor operators rather than the
+  // scalar overloads reachable through the rank-0 conversion to Scalar.
+  result = in.sum() * in.sum();
+  VERIFY_IS_EQUAL(result(), 16.0f);
+  result = in.sum() - in.maximum();
+  VERIFY_IS_EQUAL(result(), 3.0f);
+}
+
+template <typename ScalarType, int num_elements, int max_mean>
+void test_sum_accuracy() {
+  Tensor<double, 1> double_tensor(num_elements);
+  Tensor<ScalarType, 1> tensor(num_elements);
+  for (double prescribed_mean = 0; prescribed_mean <= max_mean;
+       prescribed_mean = numext::maxi(1.0, prescribed_mean * 3.99)) {
+    // FIXME: NormalRandomGenerator doesn't work in bfloat and half.
+    double_tensor.setRandom<Eigen::internal::NormalRandomGenerator<double>>();
+    double_tensor += double_tensor.constant(prescribed_mean);
+    tensor = double_tensor.cast<ScalarType>();
+
+    Tensor<ScalarType, 0> sum;
+    sum = tensor.sum();
+
+    // Compute the reference value in double precision.
+    double expected_sum = 0.0;
+    double abs_sum = 0.0;
+    for (int i = 0; i < num_elements; ++i) {
+      expected_sum += static_cast<double>(tensor(i));
+      abs_sum += static_cast<double>(numext::abs(tensor(i)));
+    }
+    // Test against probabilistic forward error bound. In reality, the error is much smaller
+    // when we use tree summation.
+    double err = Eigen::numext::abs(static_cast<double>(sum()) - expected_sum);
+    double tol = numext::sqrt(static_cast<double>(num_elements)) *
+                 static_cast<double>(NumTraits<ScalarType>::epsilon()) * abs_sum;
+    VERIFY_LE(err, tol);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_reduction) {
+  CALL_SUBTEST(test_trivial_reductions<ColMajor>());
+  CALL_SUBTEST(test_trivial_reductions<RowMajor>());
+  CALL_SUBTEST((test_scalar_reduction_conversion<int, ColMajor>()));
+  CALL_SUBTEST((test_scalar_reduction_conversion<int, RowMajor>()));
+  CALL_SUBTEST((test_scalar_reduction_conversion<Eigen::half, ColMajor>()));
+  CALL_SUBTEST((test_scalar_reduction_mixed_operators<float, ColMajor>()));
+  CALL_SUBTEST((test_scalar_reduction_mixed_operators<double, ColMajor>()));
+  CALL_SUBTEST((test_scalar_reduction_mixed_operators<int, RowMajor>()));
+  CALL_SUBTEST(test_scalar_reduction_mixed_operators_mod());
+  CALL_SUBTEST((test_simple_reductions<float, ColMajor>()));
+  CALL_SUBTEST((test_simple_reductions<float, RowMajor>()));
+  CALL_SUBTEST((test_simple_reductions<Eigen::half, ColMajor>()));
+  CALL_SUBTEST((test_simple_reductions<Eigen::bfloat16, ColMajor>()));
+  CALL_SUBTEST(test_all_any());
+  CALL_SUBTEST(test_reductions_in_expr<ColMajor>());
+  CALL_SUBTEST(test_reductions_in_expr<RowMajor>());
+  CALL_SUBTEST(test_full_reductions<ColMajor>());
+  CALL_SUBTEST(test_full_reductions<RowMajor>());
+  CALL_SUBTEST(test_user_defined_reductions<ColMajor>());
+  CALL_SUBTEST(test_user_defined_reductions<RowMajor>());
+  CALL_SUBTEST(test_value_transforming_reducer<ColMajor>());
+  CALL_SUBTEST(test_value_transforming_reducer<RowMajor>());
+  CALL_SUBTEST(test_tensor_maps<ColMajor>());
+  CALL_SUBTEST(test_tensor_maps<RowMajor>());
+  CALL_SUBTEST(test_static_dims<ColMajor>());
+  CALL_SUBTEST(test_static_dims<RowMajor>());
+  CALL_SUBTEST(test_innermost_last_dims<ColMajor>());
+  CALL_SUBTEST(test_innermost_last_dims<RowMajor>());
+  CALL_SUBTEST(test_innermost_first_dims<ColMajor>());
+  CALL_SUBTEST(test_innermost_first_dims<RowMajor>());
+  CALL_SUBTEST(test_reduce_middle_dims<ColMajor>());
+  CALL_SUBTEST(test_reduce_middle_dims<RowMajor>());
+  CALL_SUBTEST(test_dynamic_innermost_dims<ColMajor>());
+  CALL_SUBTEST(test_dynamic_innermost_dims<RowMajor>());
+  CALL_SUBTEST((test_sum_accuracy<float, 10 * 1024 * 1024, 8 * 1024>()));
+  CALL_SUBTEST((test_sum_accuracy<Eigen::bfloat16, 10 * 1024 * 1024, 8 * 1024>()));
+  // The range of half is limited to 65519 when using round-to-even,
+  // so we are severely limited in the size and mean of the tensors
+  // we can reduce without overflow.
+  CALL_SUBTEST((test_sum_accuracy<Eigen::half, 4 * 1024, 16>()));
+  CALL_SUBTEST((test_sum_accuracy<Eigen::half, 10 * 1024 * 1024, 0>()));
+  CALL_SUBTEST(test_mixed_type_scalar_arithmetic<ColMajor>());
+  CALL_SUBTEST(test_mixed_type_scalar_arithmetic<RowMajor>());
+}
diff --git a/contrib/test/tensor_reduction_gpu.cu b/contrib/test/tensor_reduction_gpu.cu
new file mode 100644
index 0000000..e4f9ddf
--- /dev/null
+++ b/contrib/test/tensor_reduction_gpu.cu
@@ -0,0 +1,155 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+template <typename Type, int DataLayout>
+static void test_full_reductions() {
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  const int num_rows = internal::random<int>(1024, 5 * 1024);
+  const int num_cols = internal::random<int>(1024, 5 * 1024);
+
+  Tensor<Type, 2, DataLayout> in(num_rows, num_cols);
+  in.setRandom();
+
+  Tensor<Type, 0, DataLayout> full_redux;
+  full_redux = in.sum();
+
+  std::size_t in_bytes = in.size() * sizeof(Type);
+  std::size_t out_bytes = full_redux.size() * sizeof(Type);
+  Type* gpu_in_ptr = static_cast<Type*>(gpu_device.allocate(in_bytes));
+  Type* gpu_out_ptr = static_cast<Type*>(gpu_device.allocate(out_bytes));
+  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
+
+  TensorMap<Tensor<Type, 2, DataLayout> > in_gpu(gpu_in_ptr, num_rows, num_cols);
+  TensorMap<Tensor<Type, 0, DataLayout> > out_gpu(gpu_out_ptr);
+
+  out_gpu.device(gpu_device) = in_gpu.sum();
+
+  Tensor<Type, 0, DataLayout> full_redux_gpu;
+  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
+  gpu_device.synchronize();
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
+
+  gpu_device.deallocate(gpu_in_ptr);
+  gpu_device.deallocate(gpu_out_ptr);
+}
+
+template <typename Type, int DataLayout>
+static void test_first_dim_reductions(int dim_x = 33, int dim_y = 1, int dim_z = 128) {
+  Tensor<Type, 3, DataLayout> in(dim_x, dim_y, dim_z);
+  in.setRandom();
+
+  Eigen::array<int, 1> red_axis;
+  red_axis[0] = 0;
+  Tensor<Type, 2, DataLayout> redux = in.sum(red_axis);
+
+  // Create device
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice dev(&stream);
+
+  // Create data(T)
+  Type* in_data = (Type*)dev.allocate(dim_x * dim_y * dim_z * sizeof(Type));
+  Type* out_data = (Type*)dev.allocate(dim_z * dim_y * sizeof(Type));
+  Eigen::TensorMap<Eigen::Tensor<Type, 3, DataLayout> > gpu_in(in_data, dim_x, dim_y, dim_z);
+  Eigen::TensorMap<Eigen::Tensor<Type, 2, DataLayout> > gpu_out(out_data, dim_y, dim_z);
+
+  // Perform operation
+  dev.memcpyHostToDevice(in_data, in.data(), in.size() * sizeof(Type));
+  gpu_out.device(dev) = gpu_in.sum(red_axis);
+  gpu_out.device(dev) += gpu_in.sum(red_axis);
+  Tensor<Type, 2, DataLayout> redux_gpu(dim_y, dim_z);
+  dev.memcpyDeviceToHost(redux_gpu.data(), out_data, gpu_out.size() * sizeof(Type));
+  dev.synchronize();
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (int i = 0; i < gpu_out.size(); ++i) {
+    VERIFY_IS_APPROX(2 * redux(i), redux_gpu(i));
+  }
+
+  dev.deallocate(in_data);
+  dev.deallocate(out_data);
+}
+
+template <typename Type, int DataLayout>
+static void test_last_dim_reductions(int dim_x = 128, int dim_y = 1, int dim_z = 33) {
+  Tensor<Type, 3, DataLayout> in(dim_x, dim_y, dim_z);
+  in.setRandom();
+
+  Eigen::array<int, 1> red_axis;
+  red_axis[0] = 2;
+  Tensor<Type, 2, DataLayout> redux = in.sum(red_axis);
+
+  // Create device
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice dev(&stream);
+
+  // Create data
+  Type* in_data = (Type*)dev.allocate(dim_x * dim_y * dim_z * sizeof(Type));
+  Type* out_data = (Type*)dev.allocate(dim_x * dim_y * sizeof(Type));
+  Eigen::TensorMap<Eigen::Tensor<Type, 3, DataLayout> > gpu_in(in_data, dim_x, dim_y, dim_z);
+  Eigen::TensorMap<Eigen::Tensor<Type, 2, DataLayout> > gpu_out(out_data, dim_x, dim_y);
+
+  // Perform operation
+  dev.memcpyHostToDevice(in_data, in.data(), in.size() * sizeof(Type));
+  gpu_out.device(dev) = gpu_in.sum(red_axis);
+  gpu_out.device(dev) += gpu_in.sum(red_axis);
+  Tensor<Type, 2, DataLayout> redux_gpu(dim_x, dim_y);
+  dev.memcpyDeviceToHost(redux_gpu.data(), out_data, gpu_out.size() * sizeof(Type));
+  dev.synchronize();
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (int i = 0; i < gpu_out.size(); ++i) {
+    VERIFY_IS_APPROX(2 * redux(i), redux_gpu(i));
+  }
+
+  dev.deallocate(in_data);
+  dev.deallocate(out_data);
+}
+
+EIGEN_DECLARE_TEST(tensor_reduction_gpu) {
+  CALL_SUBTEST_1((test_full_reductions<float, ColMajor>()));
+  CALL_SUBTEST_1((test_full_reductions<double, ColMajor>()));
+  CALL_SUBTEST_2((test_full_reductions<float, RowMajor>()));
+  CALL_SUBTEST_2((test_full_reductions<double, RowMajor>()));
+
+  CALL_SUBTEST_3((test_first_dim_reductions<float, ColMajor>()));
+  CALL_SUBTEST_3((test_first_dim_reductions<double, ColMajor>()));
+  CALL_SUBTEST_4((test_first_dim_reductions<float, RowMajor>()));
+  CALL_SUBTEST_4((test_first_dim_reductions<double, RowMajor>()));
+
+  CALL_SUBTEST_5((test_last_dim_reductions<float, ColMajor>()));
+  CALL_SUBTEST_5((test_last_dim_reductions<double, ColMajor>()));
+  CALL_SUBTEST_6((test_last_dim_reductions<float, RowMajor>()));
+  CALL_SUBTEST_6((test_last_dim_reductions<double, RowMajor>()));
+
+  // CUDA double sums also reach OuterReductionKernel below and above the former shape band. HIP keeps that band.
+  {
+    Eigen::GpuStreamDevice stream;
+    Eigen::GpuDevice device(&stream);
+    const int multi_processors = device.getNumGpuMultiProcessors();
+    for (int outputs : {4 * multi_processors, 16 * multi_processors, 65 * multi_processors}) {
+      CALL_SUBTEST_7((test_last_dim_reductions<double, ColMajor>(outputs, 1, 128)));
+      CALL_SUBTEST_7((test_first_dim_reductions<double, RowMajor>(128, 1, outputs)));
+    }
+    CALL_SUBTEST_7((test_last_dim_reductions<double, ColMajor>(16 * multi_processors, 1, 33)));
+    CALL_SUBTEST_7((test_first_dim_reductions<double, RowMajor>(33, 1, 16 * multi_processors)));
+  }
+}
diff --git a/contrib/test/tensor_reduction_sycl.cpp b/contrib/test/tensor_reduction_sycl.cpp
new file mode 100644
index 0000000..b4ce774
--- /dev/null
+++ b/contrib/test/tensor_reduction_sycl.cpp
@@ -0,0 +1,858 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+
+#include <contrib/Eigen/Tensor>
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device) {
+  const IndexType num_rows = 753;
+  const IndexType num_cols = 537;
+  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
+
+  array<IndexType, 2> outRange = {{1, 1}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> full_redux(outRange);
+  Tensor<DataType, 2, DataLayout, IndexType> full_redux_gpu(outRange);
+
+  in.setRandom();
+  auto dim = DSizes<IndexType, 2>(1, 1);
+  full_redux = in.sum().reshape(dim);
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      (DataType*)sycl_device.allocate(sizeof(DataType) * (full_redux_gpu.dimensions().TotalSize()));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, outRange);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.sum().reshape(dim);
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data,
+                                 (full_redux_gpu.dimensions().TotalSize()) * sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  std::cout << "SYCL FULL :" << full_redux_gpu(0, 0) << ", CPU FULL: " << full_redux(0, 0) << "\n";
+  VERIFY_IS_APPROX(full_redux_gpu(0, 0), full_redux(0, 0));
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_sum_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
+  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
+  const IndexType num_rows = 64;
+  const IndexType num_cols = 64;
+  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
+  const IndexType n_elems = internal::array_prod(tensor_range);
+
+  data_tensor in(tensor_range);
+  scalar_tensor full_redux;
+  scalar_tensor full_redux_gpu;
+
+  in.setRandom();
+  array<IndexType, 2> tensor_offset_range(tensor_range);
+  tensor_offset_range[0] -= 1;
+
+  const IndexType offset = 64;
+  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
+  full_redux = in_offset.sum();
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
+  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.sum();
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_max_sycl(const Eigen::SyclDevice& sycl_device) {
+  const IndexType num_rows = 4096;
+  const IndexType num_cols = 4096;
+  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 0, DataLayout, IndexType> full_redux;
+  Tensor<DataType, 0, DataLayout, IndexType> full_redux_gpu;
+
+  in.setRandom();
+
+  full_redux = in.maximum();
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data = (DataType*)sycl_device.allocate(sizeof(DataType));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 0, DataLayout, IndexType>> out_gpu(gpu_out_data);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.maximum();
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_max_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
+  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
+  const IndexType num_rows = 64;
+  const IndexType num_cols = 64;
+  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
+  const IndexType n_elems = internal::array_prod(tensor_range);
+
+  data_tensor in(tensor_range);
+  scalar_tensor full_redux;
+  scalar_tensor full_redux_gpu;
+
+  in.setRandom();
+  array<IndexType, 2> tensor_offset_range(tensor_range);
+  tensor_offset_range[0] -= 1;
+  // Set the initial value to be the max.
+  // As we don't include this in the reduction the result should not be 2.
+  in(0) = static_cast<DataType>(2);
+
+  const IndexType offset = 64;
+  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
+  full_redux = in_offset.maximum();
+  VERIFY_IS_NOT_EQUAL(full_redux(), in(0));
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
+  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.maximum();
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
+  const IndexType num_rows = 4096;
+  const IndexType num_cols = 4096;
+  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
+  array<IndexType, 1> argRange = {{num_cols}};
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 0;
+  //  red_axis[1]=1;
+  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> in_arg1(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> in_arg2(tensorRange);
+  Tensor<bool, 1, DataLayout, IndexType> out_arg_cpu(argRange);
+  Tensor<bool, 1, DataLayout, IndexType> out_arg_gpu(argRange);
+  Tensor<bool, 1, DataLayout, IndexType> out_arg_gpu_helper(argRange);
+  Tensor<DataType, 0, DataLayout, IndexType> full_redux;
+  Tensor<DataType, 0, DataLayout, IndexType> full_redux_gpu;
+
+  in.setRandom();
+  in_arg1.setRandom();
+  in_arg2.setRandom();
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_in_arg1_data =
+      static_cast<DataType*>(sycl_device.allocate(in_arg1.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_in_arg2_data =
+      static_cast<DataType*>(sycl_device.allocate(in_arg2.dimensions().TotalSize() * sizeof(DataType)));
+  bool* gpu_out_arg__gpu_helper_data =
+      static_cast<bool*>(sycl_device.allocate(out_arg_gpu.dimensions().TotalSize() * sizeof(DataType)));
+  bool* gpu_out_arg_data =
+      static_cast<bool*>(sycl_device.allocate(out_arg_gpu.dimensions().TotalSize() * sizeof(DataType)));
+
+  DataType* gpu_out_data = (DataType*)sycl_device.allocate(sizeof(DataType));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_Arg1_gpu(gpu_in_arg1_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_Arg2_gpu(gpu_in_arg2_data, tensorRange);
+  TensorMap<Tensor<bool, 1, DataLayout, IndexType>> out_Argout_gpu(gpu_out_arg_data, argRange);
+  TensorMap<Tensor<bool, 1, DataLayout, IndexType>> out_Argout_gpu_helper(gpu_out_arg__gpu_helper_data, argRange);
+  TensorMap<Tensor<DataType, 0, DataLayout, IndexType>> out_gpu(gpu_out_data);
+
+  // CPU VERSION
+  out_arg_cpu =
+      (in_arg1.argmax(1) == in_arg2.argmax(1)).select(out_arg_cpu.constant(true), out_arg_cpu.constant(false));
+  full_redux = (out_arg_cpu.template cast<float>()).reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
+
+  // GPU VERSION
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in_arg1_data, in_arg1.data(),
+                                 (in_arg1.dimensions().TotalSize()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_in_arg2_data, in_arg2.data(),
+                                 (in_arg2.dimensions().TotalSize()) * sizeof(DataType));
+  out_Argout_gpu_helper.device(sycl_device) = (in_Arg1_gpu.argmax(1) == in_Arg2_gpu.argmax(1));
+  out_Argout_gpu.device(sycl_device) =
+      (out_Argout_gpu_helper).select(out_Argout_gpu.constant(true), out_Argout_gpu.constant(false));
+  out_gpu.device(sycl_device) =
+      (out_Argout_gpu.template cast<float>()).reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  std::cout << "SYCL : " << full_redux_gpu() << " , CPU : " << full_redux() << '\n';
+  VERIFY_IS_EQUAL(full_redux_gpu(), full_redux());
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_in_arg1_data);
+  sycl_device.deallocate(gpu_in_arg2_data);
+  sycl_device.deallocate(gpu_out_arg__gpu_helper_data);
+  sycl_device.deallocate(gpu_out_arg_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_mean_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
+  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
+  const IndexType num_rows = 64;
+  const IndexType num_cols = 64;
+  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
+  const IndexType n_elems = internal::array_prod(tensor_range);
+
+  data_tensor in(tensor_range);
+  scalar_tensor full_redux;
+  scalar_tensor full_redux_gpu;
+
+  in.setRandom();
+  array<IndexType, 2> tensor_offset_range(tensor_range);
+  tensor_offset_range[0] -= 1;
+
+  const IndexType offset = 64;
+  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
+  full_redux = in_offset.mean();
+  VERIFY_IS_NOT_EQUAL(full_redux(), in(0));
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
+  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.mean();
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_mean_with_odd_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  // This is a particular case which illustrates a possible problem when the
+  // number of local threads in a workgroup is even, but is not a power of two.
+  using data_tensor = Tensor<DataType, 1, DataLayout, IndexType>;
+  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
+  // 2177 = (17 * 128) + 1 gives rise to 18 local threads.
+  // 8708 = 4 * 2177 = 4 * (17 * 128) + 4 uses 18 vectorised local threads.
+  const IndexType n_elems = 8707;
+  array<IndexType, 1> tensor_range = {{n_elems}};
+
+  data_tensor in(tensor_range);
+  DataType full_redux;
+  DataType full_redux_gpu;
+  TensorMap<scalar_tensor> red_cpu(&full_redux);
+  TensorMap<scalar_tensor> red_gpu(&full_redux_gpu);
+
+  const DataType const_val = static_cast<DataType>(0.6391);
+  in = in.constant(const_val);
+
+  Eigen::IndexList<Eigen::type2index<0>> red_axis;
+  red_cpu = in.reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
+  VERIFY_IS_APPROX(const_val, red_cpu());
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data, tensor_range);
+  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
+  sycl_device.memcpyDeviceToHost(red_gpu.data(), gpu_out_data, sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux_gpu, full_redux);
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_min_sycl(const Eigen::SyclDevice& sycl_device) {
+  const IndexType num_rows = 876;
+  const IndexType num_cols = 953;
+  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 0, DataLayout, IndexType> full_redux;
+  Tensor<DataType, 0, DataLayout, IndexType> full_redux_gpu;
+
+  in.setRandom();
+
+  full_redux = in.minimum();
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data = (DataType*)sycl_device.allocate(sizeof(DataType));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 0, DataLayout, IndexType>> out_gpu(gpu_out_data);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.minimum();
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_full_reductions_min_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
+  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
+  const IndexType num_rows = 64;
+  const IndexType num_cols = 64;
+  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
+  const IndexType n_elems = internal::array_prod(tensor_range);
+
+  data_tensor in(tensor_range);
+  scalar_tensor full_redux;
+  scalar_tensor full_redux_gpu;
+
+  in.setRandom();
+  array<IndexType, 2> tensor_offset_range(tensor_range);
+  tensor_offset_range[0] -= 1;
+  // Set the initial value to be the min.
+  // As we don't include this in the reduction the result should not be -2.
+  in(0) = static_cast<DataType>(-2);
+
+  const IndexType offset = 64;
+  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
+  full_redux = in_offset.minimum();
+  VERIFY_IS_NOT_EQUAL(full_redux(), in(0));
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
+  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.minimum();
+  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_first_dim_reductions_max_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType dim_x = 145;
+  IndexType dim_y = 1;
+  IndexType dim_z = 67;
+
+  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 0;
+  array<IndexType, 2> reduced_tensorRange = {{dim_y, dim_z}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
+
+  in.setRandom();
+
+  redux = in.maximum(red_axis);
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.maximum(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
+    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_first_dim_reductions_max_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
+  using reduced_tensor = Tensor<DataType, 1, DataLayout, IndexType>;
+
+  const IndexType num_rows = 64;
+  const IndexType num_cols = 64;
+  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
+  array<IndexType, 1> reduced_range = {{num_cols}};
+  const IndexType n_elems = internal::array_prod(tensor_range);
+  const IndexType n_reduced = num_cols;
+
+  data_tensor in(tensor_range);
+  reduced_tensor redux;
+  reduced_tensor redux_gpu(reduced_range);
+
+  in.setRandom();
+  array<IndexType, 2> tensor_offset_range(tensor_range);
+  tensor_offset_range[0] -= 1;
+  // Set maximum value outside of the considered range.
+  for (IndexType i = 0; i < n_reduced; i++) {
+    in(i) = static_cast<DataType>(2);
+  }
+
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 0;
+
+  const IndexType offset = 64;
+  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
+  redux = in_offset.maximum(red_axis);
+  for (IndexType i = 0; i < n_reduced; i++) {
+    VERIFY_IS_NOT_EQUAL(redux(i), in(i));
+  }
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(n_reduced * sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
+  TensorMap<reduced_tensor> out_gpu(gpu_out_data, reduced_range);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.maximum(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, n_reduced * sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType i = 0; i < n_reduced; i++) {
+    VERIFY_IS_APPROX(redux_gpu(i), redux(i));
+  }
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_last_dim_reductions_max_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
+  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
+  using reduced_tensor = Tensor<DataType, 1, DataLayout, IndexType>;
+
+  const IndexType num_rows = 64;
+  const IndexType num_cols = 64;
+  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
+  array<IndexType, 1> full_reduced_range = {{num_rows}};
+  array<IndexType, 1> reduced_range = {{num_rows - 1}};
+  const IndexType n_elems = internal::array_prod(tensor_range);
+  const IndexType n_reduced = reduced_range[0];
+
+  data_tensor in(tensor_range);
+  reduced_tensor redux(full_reduced_range);
+  reduced_tensor redux_gpu(reduced_range);
+
+  in.setRandom();
+  redux.setZero();
+  array<IndexType, 2> tensor_offset_range(tensor_range);
+  tensor_offset_range[0] -= 1;
+  // Set maximum value outside of the considered range.
+  for (IndexType i = 0; i < n_reduced; i++) {
+    in(i) = static_cast<DataType>(2);
+  }
+
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 1;
+
+  const IndexType offset = 64;
+  // Introduce an offset in both the input and the output.
+  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
+  TensorMap<reduced_tensor> red_offset(redux.data() + 1, reduced_range);
+  red_offset = in_offset.maximum(red_axis);
+
+  // Check that the first value hasn't been changed and that the reduced values
+  // are not equal to the previously set maximum in the input outside the range.
+  VERIFY_IS_EQUAL(redux(0), static_cast<DataType>(0));
+  for (IndexType i = 0; i < n_reduced; i++) {
+    VERIFY_IS_NOT_EQUAL(red_offset(i), in(i));
+  }
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate((n_reduced + 1) * sizeof(DataType)));
+
+  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
+  TensorMap<reduced_tensor> out_gpu(gpu_out_data + 1, reduced_range);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.maximum(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), out_gpu.data(), n_reduced * sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType i = 0; i < n_reduced; i++) {
+    VERIFY_IS_APPROX(redux_gpu(i), red_offset(i));
+  }
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_first_dim_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device, IndexType dim_x, IndexType dim_y) {
+  array<IndexType, 2> tensorRange = {{dim_x, dim_y}};
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 0;
+  array<IndexType, 1> reduced_tensorRange = {{dim_y}};
+
+  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 1, DataLayout, IndexType> redux(reduced_tensorRange);
+  Tensor<DataType, 1, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
+
+  in.setRandom();
+  redux = in.sum(red_axis);
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.sum(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType i = 0; i < redux.size(); i++) {
+    VERIFY_IS_APPROX(redux_gpu.data()[i], redux.data()[i]);
+  }
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_first_dim_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType dim_x = 145;
+  IndexType dim_y = 1;
+  IndexType dim_z = 67;
+
+  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 0;
+  array<IndexType, 2> reduced_tensorRange = {{dim_y, dim_z}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
+
+  in.setRandom();
+
+  redux = in.mean(red_axis);
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.mean(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
+
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
+    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_last_dim_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType dim_x = 64;
+  IndexType dim_y = 1;
+  IndexType dim_z = 32;
+
+  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 2;
+  array<IndexType, 2> reduced_tensorRange = {{dim_x, dim_y}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
+
+  in.setRandom();
+
+  redux = in.mean(red_axis);
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.mean(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
+    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_last_dim_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType dim_x = 64;
+  IndexType dim_y = 1;
+  IndexType dim_z = 32;
+
+  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
+  Eigen::array<IndexType, 1> red_axis;
+  red_axis[0] = 2;
+  array<IndexType, 2> reduced_tensorRange = {{dim_x, dim_y}};
+
+  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
+  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
+
+  in.setRandom();
+
+  redux = in.sum(red_axis);
+
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.sum(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
+    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_last_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device) {
+  auto tensorRange = Sizes<64, 32>(64, 32);
+  // auto red_axis =  Sizes<0,1>(0,1);
+  Eigen::IndexList<Eigen::type2index<1>> red_axis;
+  auto reduced_tensorRange = Sizes<64>(64);
+  TensorFixedSize<DataType, Sizes<64, 32>, DataLayout> in_fix;
+  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_fix;
+  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_gpu_fix;
+
+  in_fix.setRandom();
+
+  redux_fix = in_fix.sum(red_axis);
+
+  DataType* gpu_in_data =
+      static_cast<DataType*>(sycl_device.allocate(in_fix.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<TensorFixedSize<DataType, Sizes<64, 32>, DataLayout>> in_gpu_fix(gpu_in_data, tensorRange);
+  TensorMap<TensorFixedSize<DataType, Sizes<64>, DataLayout>> out_gpu_fix(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in_fix.data(), (in_fix.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu_fix.device(sycl_device) = in_gpu_fix.sum(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu_fix.data(), gpu_out_data,
+                                 redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType j = 0; j < reduced_tensorRange[0]; j++) {
+    VERIFY_IS_APPROX(redux_gpu_fix(j), redux_fix(j));
+  }
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_last_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
+  auto tensorRange = Sizes<64, 32>(64, 32);
+  Eigen::IndexList<Eigen::type2index<1>> red_axis;
+  auto reduced_tensorRange = Sizes<64>(64);
+  TensorFixedSize<DataType, Sizes<64, 32>, DataLayout> in_fix;
+  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_fix;
+  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_gpu_fix;
+
+  in_fix.setRandom();
+  redux_fix = in_fix.mean(red_axis);
+
+  DataType* gpu_in_data =
+      static_cast<DataType*>(sycl_device.allocate(in_fix.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<TensorFixedSize<DataType, Sizes<64, 32>, DataLayout>> in_gpu_fix(gpu_in_data, tensorRange);
+  TensorMap<TensorFixedSize<DataType, Sizes<64>, DataLayout>> out_gpu_fix(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in_fix.data(), (in_fix.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu_fix.device(sycl_device) = in_gpu_fix.mean(red_axis);
+  sycl_device.memcpyDeviceToHost(redux_gpu_fix.data(), gpu_out_data,
+                                 redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType));
+  sycl_device.synchronize();
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType j = 0; j < reduced_tensorRange[0]; j++) {
+    VERIFY_IS_APPROX(redux_gpu_fix(j), redux_fix(j));
+  }
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+// SYCL supports a generic case of reduction where the accumulator is a
+// different type than the input data This is an example on how to get if a
+// Tensor contains nan and/or inf in one reduction
+template <typename InT, typename OutT>
+struct CustomReducer {
+  static const bool PacketAccess = false;
+  static const bool IsStateful = false;
+
+  static constexpr OutT InfBit = 1;
+  static constexpr OutT NanBit = 2;
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const InT x, OutT* accum) const {
+    if (Eigen::numext::isinf(x))
+      *accum |= InfBit;
+    else if (Eigen::numext::isnan(x))
+      *accum |= NanBit;
+  }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const OutT x, OutT* accum) const { *accum |= x; }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE OutT initialize() const { return OutT(0); }
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE OutT finalize(const OutT accum) const { return accum; }
+};
+
+template <typename DataType, typename AccumType, int DataLayout, typename IndexType>
+static void test_full_reductions_custom_sycl(const Eigen::SyclDevice& sycl_device) {
+  constexpr IndexType InSize = 64;
+  auto tensorRange = Sizes<InSize>(InSize);
+  Eigen::IndexList<Eigen::type2index<0>> dims;
+  auto reduced_tensorRange = Sizes<>();
+  TensorFixedSize<DataType, Sizes<InSize>, DataLayout> in_fix;
+  TensorFixedSize<AccumType, Sizes<>, DataLayout> redux_gpu_fix;
+
+  CustomReducer<DataType, AccumType> reducer;
+
+  in_fix.setRandom();
+
+  size_t in_size_bytes = in_fix.dimensions().TotalSize() * sizeof(DataType);
+  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in_size_bytes));
+  AccumType* gpu_out_data = static_cast<AccumType*>(sycl_device.allocate(sizeof(AccumType)));
+
+  TensorMap<TensorFixedSize<DataType, Sizes<InSize>, DataLayout>> in_gpu_fix(gpu_in_data, tensorRange);
+  TensorMap<TensorFixedSize<AccumType, Sizes<>, DataLayout>> out_gpu_fix(gpu_out_data, reduced_tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, in_fix.data(), in_size_bytes);
+  out_gpu_fix.device(sycl_device) = in_gpu_fix.reduce(dims, reducer);
+  sycl_device.memcpyDeviceToHost(redux_gpu_fix.data(), gpu_out_data, sizeof(AccumType));
+  VERIFY_IS_EQUAL(redux_gpu_fix(0), AccumType(0));
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, typename Dev>
+void sycl_reduction_test_full_per_device(const Dev& sycl_device) {
+  test_full_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_sum_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_min_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_min_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_max_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_max_sycl<DataType, RowMajor, int64_t>(sycl_device);
+
+  test_full_reductions_mean_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_mean_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_custom_sycl<DataType, int, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_custom_sycl<DataType, int, ColMajor, int64_t>(sycl_device);
+  sycl_device.synchronize();
+}
+
+template <typename DataType, typename Dev>
+void sycl_reduction_full_offset_per_device(const Dev& sycl_device) {
+  test_full_reductions_sum_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_sum_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_min_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_min_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_max_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_max_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_mean_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_full_reductions_mean_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_full_reductions_mean_with_odd_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  sycl_device.synchronize();
+}
+
+template <typename DataType, typename Dev>
+void sycl_reduction_test_first_dim_per_device(const Dev& sycl_device) {
+  test_first_dim_reductions_sum_sycl<DataType, ColMajor, int64_t>(sycl_device, 4197, 4097);
+  test_first_dim_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device, 4197, 4097);
+  test_first_dim_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device, 129, 8);
+  test_first_dim_reductions_max_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_first_dim_reductions_max_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  sycl_device.synchronize();
+}
+
+template <typename DataType, typename Dev>
+void sycl_reduction_test_last_dim_per_device(const Dev& sycl_device) {
+  test_last_dim_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_last_dim_reductions_max_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_last_reductions_sum_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_last_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_last_reductions_mean_sycl<DataType, ColMajor, int64_t>(sycl_device);
+  test_last_reductions_mean_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  sycl_device.synchronize();
+}
+
+EIGEN_DECLARE_TEST(tensor_reduction_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    std::cout << "Running on " << device.template get_info<cl::sycl::info::device::name>() << std::endl;
+    QueueInterface queueInterface(device);
+    auto sycl_device = Eigen::SyclDevice(&queueInterface);
+    CALL_SUBTEST_1(sycl_reduction_test_full_per_device<float>(sycl_device));
+    CALL_SUBTEST_2(sycl_reduction_full_offset_per_device<float>(sycl_device));
+    CALL_SUBTEST_3(sycl_reduction_test_first_dim_per_device<float>(sycl_device));
+    CALL_SUBTEST_4(sycl_reduction_test_last_dim_per_device<float>(sycl_device));
+  }
+}
diff --git a/contrib/test/tensor_ref.cpp b/contrib/test/tensor_ref.cpp
new file mode 100644
index 0000000..5b52742
--- /dev/null
+++ b/contrib/test/tensor_ref.cpp
@@ -0,0 +1,304 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_simple_lvalue_ref() {
+  Tensor<int, 1> input(6);
+  input.setRandom();
+
+  TensorRef<Tensor<int, 1>> ref3(input);
+  TensorRef<Tensor<int, 1>> ref4 = input;
+
+  VERIFY_IS_EQUAL(ref3.data(), input.data());
+  VERIFY_IS_EQUAL(ref4.data(), input.data());
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(ref3(i), input(i));
+    VERIFY_IS_EQUAL(ref4(i), input(i));
+  }
+
+  for (int i = 0; i < 6; ++i) {
+    ref3.coeffRef(i) = i;
+  }
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(input(i), i);
+  }
+  for (int i = 0; i < 6; ++i) {
+    ref4.coeffRef(i) = -i * 2;
+  }
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(input(i), -i * 2);
+  }
+}
+
+static void test_simple_rvalue_ref() {
+  Tensor<int, 1> input1(6);
+  setRandomDataInRange(input1, -1000, 1000);
+  Tensor<int, 1> input2(6);
+  setRandomDataInRange(input2, -1000, 1000);
+
+  TensorRef<const Tensor<int, 1>> ref3(input1 + input2);
+  TensorRef<const Tensor<int, 1>> ref4 = input1 + input2;
+
+  VERIFY_IS_NOT_EQUAL(ref3.data(), input1.data());
+  VERIFY_IS_NOT_EQUAL(ref4.data(), input1.data());
+  VERIFY_IS_NOT_EQUAL(ref3.data(), input2.data());
+  VERIFY_IS_NOT_EQUAL(ref4.data(), input2.data());
+
+  for (int i = 0; i < 6; ++i) {
+    VERIFY_IS_EQUAL(ref3(i), input1(i) + input2(i));
+    VERIFY_IS_EQUAL(ref4(i), input1(i) + input2(i));
+  }
+}
+
+static void test_multiple_dims() {
+  Tensor<float, 3> input(3, 5, 7);
+  input.setRandom();
+
+  TensorRef<Tensor<float, 3>> ref(input);
+  VERIFY_IS_EQUAL(ref.data(), input.data());
+  VERIFY_IS_EQUAL(ref.dimension(0), 3);
+  VERIFY_IS_EQUAL(ref.dimension(1), 5);
+  VERIFY_IS_EQUAL(ref.dimension(2), 7);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(ref(i, j, k), input(i, j, k));
+      }
+    }
+  }
+}
+
+static void test_slice() {
+  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+
+  Eigen::DSizes<ptrdiff_t, 5> indices(1, 2, 3, 4, 5);
+  Eigen::DSizes<ptrdiff_t, 5> sizes(1, 1, 1, 1, 1);
+  TensorRef<Tensor<float, 5>> slice = tensor.slice(indices, sizes);
+  VERIFY_IS_EQUAL(slice(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
+
+  Eigen::DSizes<ptrdiff_t, 5> indices2(1, 1, 3, 4, 5);
+  Eigen::DSizes<ptrdiff_t, 5> sizes2(1, 1, 2, 2, 3);
+  slice = tensor.slice(indices2, sizes2);
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        VERIFY_IS_EQUAL(slice(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
+      }
+    }
+  }
+
+  Eigen::DSizes<ptrdiff_t, 5> indices3(0, 0, 0, 0, 0);
+  Eigen::DSizes<ptrdiff_t, 5> sizes3(2, 3, 1, 1, 1);
+  slice = tensor.slice(indices3, sizes3);
+  VERIFY_IS_EQUAL(slice.data(), tensor.data());
+}
+
+static void test_ref_of_trace() {
+  Tensor<int, 2> input(6, 6);
+  setRandomDataInRange(input, -1000, 1000);
+  int trace = 0;
+  for (int i = 0; i < 6; ++i) {
+    trace += input(i, i);
+  }
+  TensorRef<const Tensor<int, 0>> ref(input.trace());
+  VERIFY_IS_EQUAL(ref.coeff(0), trace);
+}
+
+static void test_fixed_size_scalar_ref() {
+  Tensor<Vector2d, 2> input(3, 3);
+  TensorRef<Tensor<Vector2d, 2>> ref(input);
+
+  VERIFY_IS_EQUAL(ref.data(), input.data());
+  VERIFY_IS_EQUAL(ref.dimension(0), 3);
+  VERIFY_IS_EQUAL(ref.dimension(1), 3);
+
+  ref.coeffRef(0) = Vector2d(1.0, 2.0);
+  VERIFY_IS_APPROX(input.coeff(0), Vector2d(1.0, 2.0));
+
+  // Four doubles require over-aligned evaluator storage when AVX is enabled in C++14.
+  Tensor<Vector4d, 1> wide_input(2);
+  TensorRef<Tensor<Vector4d, 1>> wide_ref(wide_input);
+  wide_ref.coeffRef(0) = Vector4d::Ones();
+  VERIFY_IS_EQUAL(wide_input.coeff(0), Vector4d::Ones());
+}
+
+static void test_ref_of_ref() {
+  Tensor<float, 3> input(3, 5, 7);
+  input.setRandom();
+
+  TensorRef<Tensor<float, 3>> ref(input);
+  TensorRef<Tensor<float, 3>> ref_of_ref(ref);
+  TensorRef<Tensor<float, 3>> ref_of_ref2;
+  ref_of_ref2 = ref;
+
+  VERIFY_IS_EQUAL(ref_of_ref.data(), input.data());
+  VERIFY_IS_EQUAL(ref_of_ref.dimension(0), 3);
+  VERIFY_IS_EQUAL(ref_of_ref.dimension(1), 5);
+  VERIFY_IS_EQUAL(ref_of_ref.dimension(2), 7);
+
+  VERIFY_IS_EQUAL(ref_of_ref2.data(), input.data());
+  VERIFY_IS_EQUAL(ref_of_ref2.dimension(0), 3);
+  VERIFY_IS_EQUAL(ref_of_ref2.dimension(1), 5);
+  VERIFY_IS_EQUAL(ref_of_ref2.dimension(2), 7);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(ref_of_ref(i, j, k), input(i, j, k));
+        VERIFY_IS_EQUAL(ref_of_ref2(i, j, k), input(i, j, k));
+      }
+    }
+  }
+}
+
+static void test_ref_in_expr() {
+  Tensor<float, 3> input(3, 5, 7);
+  input.setRandom();
+  TensorRef<Tensor<float, 3>> input_ref(input);
+
+  Tensor<float, 3> result(3, 5, 7);
+  result.setRandom();
+  TensorRef<const Tensor<float, 3>> result_ref(result);
+
+  Tensor<float, 3> bias(3, 5, 7);
+  bias.setRandom();
+
+  result_ref = input_ref + bias;
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(result_ref(i, j, k), input(i, j, k) + bias(i, j, k));
+        VERIFY_IS_NOT_EQUAL(result(i, j, k), input(i, j, k) + bias(i, j, k));
+      }
+    }
+  }
+
+  result = result_ref;
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_EQUAL(result(i, j, k), input(i, j, k) + bias(i, j, k));
+      }
+    }
+  }
+}
+
+static void test_coeff_ref() {
+  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
+  tensor.setRandom();
+  Tensor<float, 5> original = tensor;
+
+  TensorRef<Tensor<float, 4>> slice = tensor.chip(7, 4);
+  slice.coeffRef(0, 0, 0, 0) = 1.0f;
+  slice.coeffRef(1, 0, 0, 0) += 2.0f;
+
+  VERIFY_IS_EQUAL(tensor(0, 0, 0, 0, 7), 1.0f);
+  VERIFY_IS_EQUAL(tensor(1, 0, 0, 0, 7), original(1, 0, 0, 0, 7) + 2.0f);
+}
+
+static void test_nested_ops_with_ref() {
+  Tensor<float, 4> t(2, 3, 5, 7);
+  t.setRandom();
+  TensorMap<Tensor<const float, 4>> m(t.data(), 2, 3, 5, 7);
+  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> paddings;
+  paddings[0] = std::make_pair(0, 0);
+  paddings[1] = std::make_pair(2, 1);
+  paddings[2] = std::make_pair(3, 4);
+  paddings[3] = std::make_pair(0, 0);
+  DSizes<Eigen::DenseIndex, 4> shuffle_dims(0, 1, 2, 3);
+  TensorRef<const Tensor<const float, 4>> ref(m.pad(paddings));
+  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> trivial;
+  trivial[0] = std::make_pair(0, 0);
+  trivial[1] = std::make_pair(0, 0);
+  trivial[2] = std::make_pair(0, 0);
+  trivial[3] = std::make_pair(0, 0);
+  Tensor<float, 4> padded = ref.shuffle(shuffle_dims).pad(trivial);
+  VERIFY_IS_EQUAL(padded.dimension(0), 2 + 0);
+  VERIFY_IS_EQUAL(padded.dimension(1), 3 + 3);
+  VERIFY_IS_EQUAL(padded.dimension(2), 5 + 7);
+  VERIFY_IS_EQUAL(padded.dimension(3), 7 + 0);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 6; ++j) {
+      for (int k = 0; k < 12; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
+            VERIFY_IS_EQUAL(padded(i, j, k, l), t(i, j - 2, k - 3, l));
+          } else {
+            VERIFY_IS_EQUAL(padded(i, j, k, l), 0.0f);
+          }
+        }
+      }
+    }
+  }
+}
+
+// Regression test for issue #1616: unsigned index types must not trigger
+// narrowing errors in the variadic accessors.
+static void test_unsigned_indices() {
+  Tensor<float, 3> tensor(2, 3, 7);
+  tensor.setRandom();
+
+  TensorRef<Tensor<float, 3>> ref(tensor);
+  VERIFY_IS_EQUAL(ref(1u, std::size_t(2), 6ul), tensor(1, 2, 6));
+  ref.coeffRef(1u, 2ul, std::size_t(6)) = 5.0f;
+  VERIFY_IS_EQUAL(tensor(1, 2, 6), 5.0f);
+}
+
+// TensorRef's accessors must take the plain object's index type. Unqualified Index in the class body does not find
+// the base's typedef, so coeffRef used to take Eigen::Index while operator() took the plain object's index type.
+static void test_index_type() {
+  using RefType = Eigen::TensorRef<Tensor<float, 3, Eigen::ColMajor, int>>;
+  VERIFY((std::is_same<RefType::Index, int>::value));
+
+  Tensor<float, 3, Eigen::ColMajor, int> tensor(2, 3, 7);
+  tensor.setZero();
+  RefType ref(tensor);
+
+  float& (RefType::*coeff_ref)(RefType::Index) = &RefType::coeffRef;
+  (ref.*coeff_ref)(3) = 5.0f;
+  VERIFY_IS_EQUAL(tensor.coeff(3), 5.0f);
+}
+
+// An index the ref's index type cannot represent must assert rather than silently truncate. size_t(-1) is
+// representable by no signed index type, so this holds whichever index type the accessor takes.
+static void test_narrowing_indices() {
+  Tensor<float, 3> tensor(2, 3, 7);
+  tensor.setRandom();
+
+  TensorRef<Tensor<float, 3>> ref(tensor);
+  VERIFY_RAISES_ASSERT(ref(0, 0, std::size_t(-1)));
+  VERIFY_RAISES_ASSERT(ref.coeffRef(0, 0, std::size_t(-1)) = 1.0f);
+}
+
+EIGEN_DECLARE_TEST(tensor_ref) {
+  CALL_SUBTEST(test_simple_lvalue_ref());
+  CALL_SUBTEST(test_simple_rvalue_ref());
+  CALL_SUBTEST(test_multiple_dims());
+  CALL_SUBTEST(test_slice());
+  CALL_SUBTEST(test_ref_of_trace());
+  CALL_SUBTEST(test_fixed_size_scalar_ref());
+  CALL_SUBTEST(test_ref_of_ref());
+  CALL_SUBTEST(test_ref_in_expr());
+  CALL_SUBTEST(test_coeff_ref());
+  CALL_SUBTEST(test_nested_ops_with_ref());
+  CALL_SUBTEST(test_unsigned_indices());
+  CALL_SUBTEST(test_index_type());
+  CALL_SUBTEST(test_narrowing_indices());
+}
diff --git a/contrib/test/tensor_reinclude.cpp b/contrib/test/tensor_reinclude.cpp
new file mode 100644
index 0000000..6ed7868
--- /dev/null
+++ b/contrib/test/tensor_reinclude.cpp
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <unsupported/Eigen/CXX11/Tensor>
+
+// Re-inclusion after enabling a backend must complete its device type. Backend
+// evaluation still requires the macro before the first Eigen include.
+#define EIGEN_USE_THREADS
+#include <unsupported/Eigen/CXX11/Tensor>
+
+EIGEN_DECLARE_TEST(tensor_reinclude) {
+  Eigen::ThreadPool pool(1);
+  Eigen::ThreadPoolDevice device(&pool, 1);
+  VERIFY_IS_EQUAL(device.numThreads(), 1);
+}
diff --git a/contrib/test/tensor_reverse.cpp b/contrib/test/tensor_reverse.cpp
new file mode 100644
index 0000000..64a583e
--- /dev/null
+++ b/contrib/test/tensor_reverse.cpp
@@ -0,0 +1,316 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Navdeep Jaitly <ndjaitly@google.com and
+//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_reverse() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<bool, 4> dim_rev;
+  dim_rev[0] = false;
+  dim_rev[1] = true;
+  dim_rev[2] = true;
+  dim_rev[3] = false;
+
+  Tensor<float, 4, DataLayout> reversed_tensor;
+  reversed_tensor = tensor.reverse(dim_rev);
+
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(0), 2);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(1), 3);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(2), 5);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(i, 2 - j, 4 - k, l));
+        }
+      }
+    }
+  }
+
+  dim_rev[0] = true;
+  dim_rev[1] = false;
+  dim_rev[2] = false;
+  dim_rev[3] = false;
+
+  reversed_tensor = tensor.reverse(dim_rev);
+
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(0), 2);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(1), 3);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(2), 5);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dim_rev[0] = true;
+  dim_rev[1] = false;
+  dim_rev[2] = false;
+  dim_rev[3] = true;
+
+  reversed_tensor = tensor.reverse(dim_rev);
+
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(0), 2);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(1), 3);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(2), 5);
+  VERIFY_IS_EQUAL(reversed_tensor.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, 6 - l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_expr_reverse(bool LValue) {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<bool, 4> dim_rev;
+  dim_rev[0] = false;
+  dim_rev[1] = true;
+  dim_rev[2] = false;
+  dim_rev[3] = true;
+
+  Tensor<float, 4, DataLayout> expected(2, 3, 5, 7);
+  if (LValue) {
+    expected.reverse(dim_rev) = tensor;
+  } else {
+    expected = tensor.reverse(dim_rev);
+  }
+
+  Tensor<float, 4, DataLayout> result(2, 3, 5, 7);
+
+  array<ptrdiff_t, 4> src_slice_dim;
+  src_slice_dim[0] = 2;
+  src_slice_dim[1] = 3;
+  src_slice_dim[2] = 1;
+  src_slice_dim[3] = 7;
+  array<ptrdiff_t, 4> src_slice_start;
+  src_slice_start[0] = 0;
+  src_slice_start[1] = 0;
+  src_slice_start[2] = 0;
+  src_slice_start[3] = 0;
+  array<ptrdiff_t, 4> dst_slice_dim = src_slice_dim;
+  array<ptrdiff_t, 4> dst_slice_start = src_slice_start;
+
+  for (int i = 0; i < 5; ++i) {
+    if (LValue) {
+      result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev) = tensor.slice(src_slice_start, src_slice_dim);
+    } else {
+      result.slice(dst_slice_start, dst_slice_dim) = tensor.slice(src_slice_start, src_slice_dim).reverse(dim_rev);
+    }
+    src_slice_start[2] += 1;
+    dst_slice_start[2] += 1;
+  }
+
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 3);
+  VERIFY_IS_EQUAL(result.dimension(2), 5);
+  VERIFY_IS_EQUAL(result.dimension(3), 7);
+
+  for (int i = 0; i < expected.dimension(0); ++i) {
+    for (int j = 0; j < expected.dimension(1); ++j) {
+      for (int k = 0; k < expected.dimension(2); ++k) {
+        for (int l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dst_slice_start[2] = 0;
+  result.setRandom();
+  for (int i = 0; i < 5; ++i) {
+    if (LValue) {
+      result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev) = tensor.slice(dst_slice_start, dst_slice_dim);
+    } else {
+      result.slice(dst_slice_start, dst_slice_dim) = tensor.reverse(dim_rev).slice(dst_slice_start, dst_slice_dim);
+    }
+    dst_slice_start[2] += 1;
+  }
+
+  for (int i = 0; i < expected.dimension(0); ++i) {
+    for (int j = 0; j < expected.dimension(1); ++j) {
+      for (int k = 0; k < expected.dimension(2); ++k) {
+        for (int l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+// Verify that the rvalue evaluator's packet() returns the same lanes as
+// coeff() at every aligned and unaligned packet offset. This guards against
+// regressions in the packet implementation that the executor-level tests
+// (which only compare the assembled result) would not surface.
+template <int DataLayout>
+static void test_packet_reverse() {
+  using namespace Eigen::internal;
+
+  Tensor<float, 3, DataLayout> tensor(8, 5, 7);
+  tensor.setRandom();
+
+  array<bool, 3> dim_rev_inner =
+      (DataLayout == ColMajor) ? array<bool, 3>{{true, false, false}} : array<bool, 3>{{false, false, true}};
+  array<bool, 3> dim_rev_outer =
+      (DataLayout == ColMajor) ? array<bool, 3>{{false, false, true}} : array<bool, 3>{{true, false, false}};
+  array<bool, 3> dim_rev_all{{true, true, true}};
+
+  for (const auto& dim_rev : {dim_rev_inner, dim_rev_outer, dim_rev_all}) {
+    auto expr = tensor.reverse(dim_rev);
+    using Eval = TensorEvaluator<const decltype(expr), DefaultDevice>;
+    using Packet = typename Eval::PacketReturnType;
+    constexpr int PacketSize = Eval::PacketSize;
+
+    DefaultDevice device;
+    Eval eval(expr, device);
+    eval.evalSubExprsIfNeeded(nullptr);
+
+    const Index total = tensor.size();
+    EIGEN_ALIGN_MAX float lanes[PacketSize];
+    for (Index offset = 0; offset + PacketSize <= total; ++offset) {
+      Packet p = eval.template packet<Unaligned>(offset);
+      pstoreu(lanes, p);
+      for (int i = 0; i < PacketSize; ++i) {
+        VERIFY_IS_EQUAL(lanes[i], eval.coeff(offset + i));
+      }
+    }
+    eval.cleanup();
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_reverse_write_packet_paths() {
+  // Writes through a reversed destination hit the lvalue writePacket fast
+  // path (contiguous store, preverse when the inner dimension is reversed).
+  // Sizes with partial-packet tails; sweep all 8 reverse-flag combinations.
+  Tensor<T, 3, DataLayout> src(17, 5, 7);
+  src.setRandom();
+
+  for (int mask = 0; mask < 8; ++mask) {
+    array<bool, 3> rev{{(mask & 1) != 0, (mask & 2) != 0, (mask & 4) != 0}};
+
+    Tensor<T, 3, DataLayout> dst(17, 5, 7);
+    dst.setZero();
+    dst.reverse(rev) = src;
+
+    for (Index i = 0; i < 17; ++i) {
+      for (Index j = 0; j < 5; ++j) {
+        for (Index k = 0; k < 7; ++k) {
+          const Index di = rev[0] ? 16 - i : i;
+          const Index dj = rev[1] ? 4 - j : j;
+          const Index dk = rev[2] ? 6 - k : k;
+          VERIFY_IS_EQUAL(dst(di, dj, dk), src(i, j, k));
+        }
+      }
+    }
+
+    // Also through an expression source, so the RHS runs its packet path.
+    Tensor<T, 3, DataLayout> dst2(17, 5, 7);
+    dst2.setZero();
+    dst2.reverse(rev) = src * src.constant(T(2));
+    for (Index i = 0; i < 17; ++i) {
+      for (Index j = 0; j < 5; ++j) {
+        for (Index k = 0; k < 7; ++k) {
+          const Index di = rev[0] ? 16 - i : i;
+          const Index dj = rev[1] ? 4 - j : j;
+          const Index dk = rev[2] ? 6 - k : k;
+          VERIFY_IS_EQUAL(dst2(di, dj, dk), T(2) * src(i, j, k));
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_reverse_write_blocks() {
+  // A right-hand side that prefers block evaluation (a shuffle) routes the
+  // assignment through the tiled executor and the reverse destination's
+  // writeBlock. Sweep all 8 reverse-flag combinations; sizes have
+  // partial-packet tails.
+  Tensor<T, 3, DataLayout> src(17, 5, 7);
+  EIGEN_IF_CONSTEXPR (NumTraits<T>::IsInteger) {
+    setRandomDataInRange(src, T(-1000), T(1000));
+  } else {
+    src.setRandom();
+  }
+
+  array<ptrdiff_t, 3> shuffle{{2, 0, 1}};
+  const Tensor<T, 3, DataLayout> shuffled = src.shuffle(shuffle);
+
+  for (int mask = 0; mask < 8; ++mask) {
+    array<bool, 3> rev{{(mask & 1) != 0, (mask & 2) != 0, (mask & 4) != 0}};
+
+    // Materialized right-hand-side blocks.
+    Tensor<T, 3, DataLayout> dst(shuffled.dimensions());
+    dst.setZero();
+    dst.reverse(rev) = src.shuffle(shuffle);
+
+    // Lazy right-hand-side blocks (cwise on top of the shuffle).
+    Tensor<T, 3, DataLayout> dst2(shuffled.dimensions());
+    dst2.setZero();
+    dst2.reverse(rev) = src.shuffle(shuffle) * src.shuffle(shuffle).constant(T(2));
+
+    for (Index i = 0; i < shuffled.dimension(0); ++i) {
+      for (Index j = 0; j < shuffled.dimension(1); ++j) {
+        for (Index k = 0; k < shuffled.dimension(2); ++k) {
+          const Index di = rev[0] ? shuffled.dimension(0) - 1 - i : i;
+          const Index dj = rev[1] ? shuffled.dimension(1) - 1 - j : j;
+          const Index dk = rev[2] ? shuffled.dimension(2) - 1 - k : k;
+          VERIFY_IS_EQUAL(dst(di, dj, dk), shuffled(i, j, k));
+          VERIFY_IS_EQUAL(dst2(di, dj, dk), T(2) * shuffled(i, j, k));
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_reverse) {
+  CALL_SUBTEST(test_simple_reverse<ColMajor>());
+  CALL_SUBTEST(test_simple_reverse<RowMajor>());
+  CALL_SUBTEST(test_expr_reverse<ColMajor>(true));
+  CALL_SUBTEST(test_expr_reverse<RowMajor>(true));
+  CALL_SUBTEST(test_expr_reverse<ColMajor>(false));
+  CALL_SUBTEST(test_expr_reverse<RowMajor>(false));
+  CALL_SUBTEST(test_packet_reverse<ColMajor>());
+  CALL_SUBTEST(test_packet_reverse<RowMajor>());
+  CALL_SUBTEST((test_reverse_write_packet_paths<float, ColMajor>()));
+  CALL_SUBTEST((test_reverse_write_packet_paths<float, RowMajor>()));
+  CALL_SUBTEST((test_reverse_write_packet_paths<double, ColMajor>()));
+  CALL_SUBTEST((test_reverse_write_packet_paths<double, RowMajor>()));
+  CALL_SUBTEST((test_reverse_write_blocks<float, ColMajor>()));
+  CALL_SUBTEST((test_reverse_write_blocks<float, RowMajor>()));
+  CALL_SUBTEST((test_reverse_write_blocks<int, ColMajor>()));
+  CALL_SUBTEST((test_reverse_write_blocks<int, RowMajor>()));
+}
diff --git a/contrib/test/tensor_reverse_sycl.cpp b/contrib/test/tensor_reverse_sycl.cpp
new file mode 100644
index 0000000..579991a
--- /dev/null
+++ b/contrib/test/tensor_reverse_sycl.cpp
@@ -0,0 +1,233 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_reverse(const Eigen::SyclDevice& sycl_device) {
+  IndexType dim1 = 2;
+  IndexType dim2 = 3;
+  IndexType dim3 = 5;
+  IndexType dim4 = 7;
+
+  array<IndexType, 4> tensorRange = {{dim1, dim2, dim3, dim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> reversed_tensor(tensorRange);
+  tensor.setRandom();
+
+  array<bool, 4> dim_rev;
+  dim_rev[0] = false;
+  dim_rev[1] = true;
+  dim_rev[2] = true;
+  dim_rev[3] = false;
+
+  DataType* gpu_in_data =
+      static_cast<DataType*>(sycl_device.allocate(tensor.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data =
+      static_cast<DataType*>(sycl_device.allocate(reversed_tensor.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > out_gpu(gpu_out_data, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, tensor.data(), (tensor.dimensions().TotalSize()) * sizeof(DataType));
+  out_gpu.device(sycl_device) = in_gpu.reverse(dim_rev);
+  sycl_device.memcpyDeviceToHost(reversed_tensor.data(), gpu_out_data,
+                                 reversed_tensor.dimensions().TotalSize() * sizeof(DataType));
+  // Check that the CPU and GPU reductions return the same result.
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(i, 2 - j, 4 - k, l));
+        }
+      }
+    }
+  }
+  dim_rev[0] = true;
+  dim_rev[1] = false;
+  dim_rev[2] = false;
+  dim_rev[3] = false;
+
+  out_gpu.device(sycl_device) = in_gpu.reverse(dim_rev);
+  sycl_device.memcpyDeviceToHost(reversed_tensor.data(), gpu_out_data,
+                                 reversed_tensor.dimensions().TotalSize() * sizeof(DataType));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dim_rev[0] = true;
+  dim_rev[1] = false;
+  dim_rev[2] = false;
+  dim_rev[3] = true;
+  out_gpu.device(sycl_device) = in_gpu.reverse(dim_rev);
+  sycl_device.memcpyDeviceToHost(reversed_tensor.data(), gpu_out_data,
+                                 reversed_tensor.dimensions().TotalSize() * sizeof(DataType));
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, 6 - l));
+        }
+      }
+    }
+  }
+
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_expr_reverse(const Eigen::SyclDevice& sycl_device, bool LValue) {
+  IndexType dim1 = 2;
+  IndexType dim2 = 3;
+  IndexType dim3 = 5;
+  IndexType dim4 = 7;
+
+  array<IndexType, 4> tensorRange = {{dim1, dim2, dim3, dim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> expected(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> result(tensorRange);
+  tensor.setRandom();
+
+  array<bool, 4> dim_rev;
+  dim_rev[0] = false;
+  dim_rev[1] = true;
+  dim_rev[2] = false;
+  dim_rev[3] = true;
+
+  DataType* gpu_in_data =
+      static_cast<DataType*>(sycl_device.allocate(tensor.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data_expected =
+      static_cast<DataType*>(sycl_device.allocate(expected.dimensions().TotalSize() * sizeof(DataType)));
+  DataType* gpu_out_data_result =
+      static_cast<DataType*>(sycl_device.allocate(result.dimensions().TotalSize() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > in_gpu(gpu_in_data, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > out_gpu_expected(gpu_out_data_expected, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > out_gpu_result(gpu_out_data_result, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_in_data, tensor.data(), (tensor.dimensions().TotalSize()) * sizeof(DataType));
+
+  if (LValue) {
+    out_gpu_expected.reverse(dim_rev).device(sycl_device) = in_gpu;
+  } else {
+    out_gpu_expected.device(sycl_device) = in_gpu.reverse(dim_rev);
+  }
+  sycl_device.memcpyDeviceToHost(expected.data(), gpu_out_data_expected,
+                                 expected.dimensions().TotalSize() * sizeof(DataType));
+
+  array<IndexType, 4> src_slice_dim;
+  src_slice_dim[0] = 2;
+  src_slice_dim[1] = 3;
+  src_slice_dim[2] = 1;
+  src_slice_dim[3] = 7;
+  array<IndexType, 4> src_slice_start;
+  src_slice_start[0] = 0;
+  src_slice_start[1] = 0;
+  src_slice_start[2] = 0;
+  src_slice_start[3] = 0;
+  array<IndexType, 4> dst_slice_dim = src_slice_dim;
+  array<IndexType, 4> dst_slice_start = src_slice_start;
+
+  for (IndexType i = 0; i < 5; ++i) {
+    if (LValue) {
+      out_gpu_result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev).device(sycl_device) =
+          in_gpu.slice(src_slice_start, src_slice_dim);
+    } else {
+      out_gpu_result.slice(dst_slice_start, dst_slice_dim).device(sycl_device) =
+          in_gpu.slice(src_slice_start, src_slice_dim).reverse(dim_rev);
+    }
+    src_slice_start[2] += 1;
+    dst_slice_start[2] += 1;
+  }
+  sycl_device.memcpyDeviceToHost(result.data(), gpu_out_data_result,
+                                 result.dimensions().TotalSize() * sizeof(DataType));
+
+  for (IndexType i = 0; i < expected.dimension(0); ++i) {
+    for (IndexType j = 0; j < expected.dimension(1); ++j) {
+      for (IndexType k = 0; k < expected.dimension(2); ++k) {
+        for (IndexType l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dst_slice_start[2] = 0;
+  result.setRandom();
+  sycl_device.memcpyHostToDevice(gpu_out_data_result, result.data(),
+                                 (result.dimensions().TotalSize()) * sizeof(DataType));
+  for (IndexType i = 0; i < 5; ++i) {
+    if (LValue) {
+      out_gpu_result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev).device(sycl_device) =
+          in_gpu.slice(dst_slice_start, dst_slice_dim);
+    } else {
+      out_gpu_result.slice(dst_slice_start, dst_slice_dim).device(sycl_device) =
+          in_gpu.reverse(dim_rev).slice(dst_slice_start, dst_slice_dim);
+    }
+    dst_slice_start[2] += 1;
+  }
+  sycl_device.memcpyDeviceToHost(result.data(), gpu_out_data_result,
+                                 result.dimensions().TotalSize() * sizeof(DataType));
+
+  for (IndexType i = 0; i < expected.dimension(0); ++i) {
+    for (IndexType j = 0; j < expected.dimension(1); ++j) {
+      for (IndexType k = 0; k < expected.dimension(2); ++k) {
+        for (IndexType l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <typename DataType>
+void sycl_reverse_test_per_device(const cl::sycl::device& d) {
+  QueueInterface queueInterface(d);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_reverse<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_reverse<DataType, ColMajor, int64_t>(sycl_device);
+  test_expr_reverse<DataType, RowMajor, int64_t>(sycl_device, false);
+  test_expr_reverse<DataType, ColMajor, int64_t>(sycl_device, false);
+  test_expr_reverse<DataType, RowMajor, int64_t>(sycl_device, true);
+  test_expr_reverse<DataType, ColMajor, int64_t>(sycl_device, true);
+}
+EIGEN_DECLARE_TEST(tensor_reverse_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    std::cout << "Running on " << device.get_info<cl::sycl::info::device::name>() << std::endl;
+    CALL_SUBTEST_1(sycl_reverse_test_per_device<short>(device));
+    CALL_SUBTEST_2(sycl_reverse_test_per_device<int>(device));
+    CALL_SUBTEST_3(sycl_reverse_test_per_device<unsigned int>(device));
+#ifdef EIGEN_SYCL_DOUBLE_SUPPORT
+    CALL_SUBTEST_4(sycl_reverse_test_per_device<double>(device));
+#endif
+    CALL_SUBTEST_5(sycl_reverse_test_per_device<half>(device));
+    CALL_SUBTEST_6(sycl_reverse_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_roll.cpp b/contrib/test/tensor_roll.cpp
new file mode 100644
index 0000000..6af429f
--- /dev/null
+++ b/contrib/test/tensor_roll.cpp
@@ -0,0 +1,243 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 Tobias Wood tobias@spinicist.org.uk
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_roll() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<Index, 4> dim_roll;
+  dim_roll[0] = 0;
+  dim_roll[1] = 1;
+  dim_roll[2] = 4;
+  dim_roll[3] = 8;
+
+  Tensor<float, 4, DataLayout> rolled_tensor;
+  rolled_tensor = tensor.roll(dim_roll);
+
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(0), 2);
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(1), 3);
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(2), 5);
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, (j + 1) % 3, (k + 4) % 5, (l + 8) % 7), rolled_tensor(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dim_roll[0] = -3;
+  dim_roll[1] = -2;
+  dim_roll[2] = -1;
+  dim_roll[3] = 0;
+
+  rolled_tensor = tensor.roll(dim_roll);
+
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(0), 2);
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(1), 3);
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(2), 5);
+  VERIFY_IS_EQUAL(rolled_tensor.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor((i + 1) % 2, (j + 1) % 3, (k + 4) % 5, l), rolled_tensor(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_expr_roll(bool LValue) {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<Index, 4> dim_roll;
+  dim_roll[0] = 2;
+  dim_roll[1] = 1;
+  dim_roll[2] = 0;
+  dim_roll[3] = 3;
+
+  Tensor<float, 4, DataLayout> expected(tensor.dimensions());
+  if (LValue) {
+    expected.roll(dim_roll) = tensor;
+  } else {
+    expected = tensor.roll(dim_roll);
+  }
+
+  Tensor<float, 4, DataLayout> result(tensor.dimensions());
+
+  array<ptrdiff_t, 4> src_slice_dim;
+  src_slice_dim[0] = tensor.dimension(0);
+  src_slice_dim[1] = tensor.dimension(1);
+  src_slice_dim[2] = 1;
+  src_slice_dim[3] = tensor.dimension(3);
+  array<ptrdiff_t, 4> src_slice_start;
+  src_slice_start[0] = 0;
+  src_slice_start[1] = 0;
+  src_slice_start[2] = 0;
+  src_slice_start[3] = 0;
+  array<ptrdiff_t, 4> dst_slice_dim = src_slice_dim;
+  array<ptrdiff_t, 4> dst_slice_start = src_slice_start;
+
+  for (int i = 0; i < tensor.dimension(2); ++i) {
+    if (LValue) {
+      result.slice(dst_slice_start, dst_slice_dim).roll(dim_roll) = tensor.slice(src_slice_start, src_slice_dim);
+    } else {
+      result.slice(dst_slice_start, dst_slice_dim) = tensor.slice(src_slice_start, src_slice_dim).roll(dim_roll);
+    }
+    src_slice_start[2] += 1;
+    dst_slice_start[2] += 1;
+  }
+
+  VERIFY_IS_EQUAL(result.dimension(0), tensor.dimension(0));
+  VERIFY_IS_EQUAL(result.dimension(1), tensor.dimension(1));
+  VERIFY_IS_EQUAL(result.dimension(2), tensor.dimension(2));
+  VERIFY_IS_EQUAL(result.dimension(3), tensor.dimension(3));
+
+  for (int i = 0; i < expected.dimension(0); ++i) {
+    for (int j = 0; j < expected.dimension(1); ++j) {
+      for (int k = 0; k < expected.dimension(2); ++k) {
+        for (int l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dst_slice_start[2] = 0;
+  result.setRandom();
+  for (int i = 0; i < tensor.dimension(2); ++i) {
+    if (LValue) {
+      result.slice(dst_slice_start, dst_slice_dim).roll(dim_roll) = tensor.slice(dst_slice_start, dst_slice_dim);
+    } else {
+      result.slice(dst_slice_start, dst_slice_dim) = tensor.roll(dim_roll).slice(dst_slice_start, dst_slice_dim);
+    }
+    dst_slice_start[2] += 1;
+  }
+
+  for (int i = 0; i < expected.dimension(0); ++i) {
+    for (int j = 0; j < expected.dimension(1); ++j) {
+      for (int k = 0; k < expected.dimension(2); ++k) {
+        for (int l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+// Verify that the rvalue evaluator's packet() returns the same lanes as
+// coeff() for every offset across a range of shift values, including the
+// no-shift, in-slice, and wrap-around cases.
+template <int DataLayout>
+static void test_packet_roll() {
+  using namespace Eigen::internal;
+
+  Tensor<float, 3, DataLayout> tensor(8, 5, 7);
+  tensor.setRandom();
+
+  // Cover several shift configurations: zero, in-bounds, and a shift that
+  // forces a modular wrap-around inside any reasonable packet.
+  array<array<Index, 3>, 4> roll_configs;
+  roll_configs[0] = {{0, 0, 0}};
+  roll_configs[1] = {{2, 1, 3}};
+  roll_configs[2] = {{6, 0, 0}};  // near-end shift on dim 0
+  roll_configs[3] = {{0, 0, 6}};  // near-end shift on dim 2
+
+  for (const auto& rolls : roll_configs) {
+    auto expr = tensor.roll(rolls);
+    using Eval = TensorEvaluator<const decltype(expr), DefaultDevice>;
+    using Packet = typename Eval::PacketReturnType;
+    constexpr int PacketSize = Eval::PacketSize;
+
+    DefaultDevice device;
+    Eval eval(expr, device);
+    eval.evalSubExprsIfNeeded(nullptr);
+
+    const Index total = tensor.size();
+    EIGEN_ALIGN_MAX float lanes[PacketSize];
+    for (Index offset = 0; offset + PacketSize <= total; ++offset) {
+      Packet p = eval.template packet<Unaligned>(offset);
+      pstoreu(lanes, p);
+      for (int i = 0; i < PacketSize; ++i) {
+        VERIFY_IS_EQUAL(lanes[i], eval.coeff(offset + i));
+      }
+    }
+    eval.cleanup();
+  }
+}
+
+template <int DataLayout>
+static void test_roll_write_blocks() {
+  // The roll destination prefers block evaluation, so any block-capable
+  // right-hand side routes through writeBlock, which scatters each block as
+  // wrap-around pieces. Sweep zero, in-range, oversized and negative shifts;
+  // sizes have partial-packet tails.
+  Tensor<float, 3, DataLayout> src(17, 5, 7);
+  src.setRandom();
+
+  const ptrdiff_t roll_sets[][3] = {{0, 0, 0}, {3, 0, 0}, {0, 2, 5}, {20, 7, 3}, {-4, 1, -9}};
+  for (const auto& r : roll_sets) {
+    array<Index, 3> rolls{{r[0], r[1], r[2]}};
+
+    // Materialized right-hand-side blocks (plain tensor).
+    Tensor<float, 3, DataLayout> dst(17, 5, 7);
+    dst.setZero();
+    dst.roll(rolls) = src;
+
+    // Lazy right-hand-side blocks (cwise expression).
+    Tensor<float, 3, DataLayout> dst2(17, 5, 7);
+    dst2.setZero();
+    dst2.roll(rolls) = src * src.constant(2.0f);
+
+    auto wrap = [](Index i, Index r_, Index n) {
+      Index m = (i + r_) % n;
+      return m < 0 ? m + n : m;
+    };
+    for (Index i = 0; i < 17; ++i) {
+      for (Index j = 0; j < 5; ++j) {
+        for (Index k = 0; k < 7; ++k) {
+          const Index di = wrap(i, rolls[0], 17);
+          const Index dj = wrap(j, rolls[1], 5);
+          const Index dk = wrap(k, rolls[2], 7);
+          VERIFY_IS_EQUAL(dst(di, dj, dk), src(i, j, k));
+          VERIFY_IS_EQUAL(dst2(di, dj, dk), 2.0f * src(i, j, k));
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_roll) {
+  CALL_SUBTEST(test_simple_roll<ColMajor>());
+  CALL_SUBTEST(test_simple_roll<RowMajor>());
+  CALL_SUBTEST(test_expr_roll<ColMajor>(true));
+  CALL_SUBTEST(test_expr_roll<RowMajor>(true));
+  CALL_SUBTEST(test_expr_roll<ColMajor>(false));
+  CALL_SUBTEST(test_expr_roll<RowMajor>(false));
+  CALL_SUBTEST(test_packet_roll<ColMajor>());
+  CALL_SUBTEST(test_packet_roll<RowMajor>());
+  CALL_SUBTEST(test_roll_write_blocks<ColMajor>());
+  CALL_SUBTEST(test_roll_write_blocks<RowMajor>());
+}
diff --git a/contrib/test/tensor_roundings.cpp b/contrib/test/tensor_roundings.cpp
new file mode 100644
index 0000000..e387c78
--- /dev/null
+++ b/contrib/test/tensor_roundings.cpp
@@ -0,0 +1,58 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+static void test_float_rounding() {
+  Tensor<float, 2> ftensor(20, 30);
+  ftensor = ftensor.random() * 100.f;
+
+  Tensor<float, 2> result = ftensor.round();
+
+  for (int i = 0; i < 20; ++i) {
+    for (int j = 0; j < 30; ++j) {
+      VERIFY_IS_EQUAL(result(i, j), numext::round(ftensor(i, j)));
+    }
+  }
+}
+
+static void test_float_flooring() {
+  Tensor<float, 2> ftensor(20, 30);
+  ftensor = ftensor.random() * 100.f;
+
+  Tensor<float, 2> result = ftensor.floor();
+
+  for (int i = 0; i < 20; ++i) {
+    for (int j = 0; j < 30; ++j) {
+      VERIFY_IS_EQUAL(result(i, j), numext::floor(ftensor(i, j)));
+    }
+  }
+}
+
+static void test_float_ceiling() {
+  Tensor<float, 2> ftensor(20, 30);
+  ftensor = ftensor.random() * 100.f;
+
+  Tensor<float, 2> result = ftensor.ceil();
+
+  for (int i = 0; i < 20; ++i) {
+    for (int j = 0; j < 30; ++j) {
+      VERIFY_IS_EQUAL(result(i, j), numext::ceil(ftensor(i, j)));
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_roundings) {
+  CALL_SUBTEST(test_float_rounding());
+  CALL_SUBTEST(test_float_ceiling());
+  CALL_SUBTEST(test_float_flooring());
+}
diff --git a/contrib/test/tensor_scan.cpp b/contrib/test/tensor_scan.cpp
new file mode 100644
index 0000000..0e2bcf4
--- /dev/null
+++ b/contrib/test/tensor_scan.cpp
@@ -0,0 +1,109 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Igor Babuschkin <igor@babuschk.in>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <limits>
+#include <numeric>
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout, typename Type = float, bool Exclusive = false>
+static void test_1d_scan() {
+  int size = 50;
+  Tensor<Type, 1, DataLayout> tensor(size);
+  tensor.setRandom();
+  Tensor<Type, 1, DataLayout> result = tensor.cumsum(0, Exclusive);
+
+  VERIFY_IS_EQUAL(tensor.dimension(0), result.dimension(0));
+
+  float accum = 0;
+  for (int i = 0; i < size; i++) {
+    if (Exclusive) {
+      VERIFY_IS_EQUAL(result(i), accum);
+      accum += tensor(i);
+    } else {
+      accum += tensor(i);
+      VERIFY_IS_EQUAL(result(i), accum);
+    }
+  }
+
+  accum = 1;
+  result = tensor.cumprod(0, Exclusive);
+  for (int i = 0; i < size; i++) {
+    if (Exclusive) {
+      VERIFY_IS_EQUAL(result(i), accum);
+      accum *= tensor(i);
+    } else {
+      accum *= tensor(i);
+      VERIFY_IS_EQUAL(result(i), accum);
+    }
+  }
+}
+
+template <int DataLayout, typename Type = float>
+static void test_4d_scan() {
+  int size = 5;
+  Tensor<Type, 4, DataLayout> tensor(size, size, size, size);
+  tensor.setRandom();
+
+  Tensor<Type, 4, DataLayout> result(size, size, size, size);
+
+  result = tensor.cumsum(0);
+  float accum = 0;
+  for (int i = 0; i < size; i++) {
+    accum += tensor(i, 1, 2, 3);
+    VERIFY_IS_EQUAL(result(i, 1, 2, 3), accum);
+  }
+  result = tensor.cumsum(1);
+  accum = 0;
+  for (int i = 0; i < size; i++) {
+    accum += tensor(1, i, 2, 3);
+    VERIFY_IS_EQUAL(result(1, i, 2, 3), accum);
+  }
+  result = tensor.cumsum(2);
+  accum = 0;
+  for (int i = 0; i < size; i++) {
+    accum += tensor(1, 2, i, 3);
+    VERIFY_IS_EQUAL(result(1, 2, i, 3), accum);
+  }
+  result = tensor.cumsum(3);
+  accum = 0;
+  for (int i = 0; i < size; i++) {
+    accum += tensor(1, 2, 3, i);
+    VERIFY_IS_EQUAL(result(1, 2, 3, i), accum);
+  }
+}
+
+template <int DataLayout>
+static void test_tensor_maps() {
+  int inputs[20];
+  TensorMap<Tensor<int, 1, DataLayout> > tensor_map(inputs, 20);
+  setRandomDataInRange(tensor_map, -1000, 1000);
+
+  Tensor<int, 1, DataLayout> result = tensor_map.cumsum(0);
+
+  int accum = 0;
+  for (int i = 0; i < 20; ++i) {
+    accum += tensor_map(i);
+    VERIFY_IS_EQUAL(result(i), accum);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_scan) {
+  CALL_SUBTEST((test_1d_scan<ColMajor, float, true>()));
+  CALL_SUBTEST((test_1d_scan<ColMajor, float, false>()));
+  CALL_SUBTEST((test_1d_scan<RowMajor, float, true>()));
+  CALL_SUBTEST((test_1d_scan<RowMajor, float, false>()));
+  CALL_SUBTEST(test_4d_scan<ColMajor>());
+  CALL_SUBTEST(test_4d_scan<RowMajor>());
+  CALL_SUBTEST(test_tensor_maps<ColMajor>());
+  CALL_SUBTEST(test_tensor_maps<RowMajor>());
+}
diff --git a/contrib/test/tensor_scan_gpu.cu b/contrib/test/tensor_scan_gpu.cu
new file mode 100644
index 0000000..f586c08
--- /dev/null
+++ b/contrib/test/tensor_scan_gpu.cu
@@ -0,0 +1,74 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#define EIGEN_USE_GPU
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+typedef Tensor<float, 1>::DimensionPair DimPair;
+
+template <int DataLayout>
+void test_gpu_cumsum(int m_size, int k_size, int n_size) {
+  std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << ")" << std::endl;
+  Tensor<float, 3, DataLayout> t_input(m_size, k_size, n_size);
+  Tensor<float, 3, DataLayout> t_result(m_size, k_size, n_size);
+  Tensor<float, 3, DataLayout> t_result_gpu(m_size, k_size, n_size);
+
+  t_input.setRandom();
+
+  std::size_t t_input_bytes = t_input.size() * sizeof(float);
+  std::size_t t_result_bytes = t_result.size() * sizeof(float);
+
+  float* d_t_input;
+  float* d_t_result;
+
+  gpuMalloc((void**)(&d_t_input), t_input_bytes);
+  gpuMalloc((void**)(&d_t_result), t_result_bytes);
+
+  gpuMemcpy(d_t_input, t_input.data(), t_input_bytes, gpuMemcpyHostToDevice);
+
+  Eigen::GpuStreamDevice stream;
+  Eigen::GpuDevice gpu_device(&stream);
+
+  Eigen::TensorMap<Eigen::Tensor<float, 3, DataLayout> > gpu_t_input(d_t_input,
+                                                                     Eigen::array<int, 3>{m_size, k_size, n_size});
+  Eigen::TensorMap<Eigen::Tensor<float, 3, DataLayout> > gpu_t_result(d_t_result,
+                                                                      Eigen::array<int, 3>{m_size, k_size, n_size});
+
+  gpu_t_result.device(gpu_device) = gpu_t_input.cumsum(1);
+  t_result = t_input.cumsum(1);
+
+  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
+  for (DenseIndex i = 0; i < t_result.size(); i++) {
+    // Scans accumulate float rounding error; 1024 * eps of absolute slack covers it before the relative check.
+    if (numext::abs(t_result(i) - t_result_gpu(i)) < 1024 * NumTraits<float>::epsilon()) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), 1024 * NumTraits<float>::epsilon())) {
+      continue;
+    }
+    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
+    assert(false);
+  }
+
+  gpuFree((void*)d_t_input);
+  gpuFree((void*)d_t_result);
+}
+
+EIGEN_DECLARE_TEST(tensor_scan_gpu) {
+  CALL_SUBTEST_1(test_gpu_cumsum<ColMajor>(128, 128, 128));
+  CALL_SUBTEST_2(test_gpu_cumsum<RowMajor>(128, 128, 128));
+}
diff --git a/contrib/test/tensor_scan_sycl.cpp b/contrib/test/tensor_scan_sycl.cpp
new file mode 100644
index 0000000..79518b6
--- /dev/null
+++ b/contrib/test/tensor_scan_sycl.cpp
@@ -0,0 +1,114 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+typedef Tensor<float, 1>::DimensionPair DimPair;
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_cumsum(const Eigen::SyclDevice& sycl_device, IndexType m_size, IndexType k_size, IndexType n_size,
+                      int consume_dim, bool exclusive) {
+  // Scans accumulate float rounding error over up to 2049 elements; 1024 * eps bounds the resulting drift.
+  static const DataType error_threshold = DataType(1024) * NumTraits<DataType>::epsilon();
+  std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << " consume_dim : " << consume_dim << ")"
+            << std::endl;
+  Tensor<DataType, 3, DataLayout, IndexType> t_input(m_size, k_size, n_size);
+  Tensor<DataType, 3, DataLayout, IndexType> t_result(m_size, k_size, n_size);
+  Tensor<DataType, 3, DataLayout, IndexType> t_result_gpu(m_size, k_size, n_size);
+
+  t_input.setRandom();
+  std::size_t t_input_bytes = t_input.size() * sizeof(DataType);
+  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
+
+  DataType* gpu_data_in = static_cast<DataType*>(sycl_device.allocate(t_input_bytes));
+  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(t_result_bytes));
+
+  array<IndexType, 3> tensorRange = {{m_size, k_size, n_size}};
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_t_input(gpu_data_in, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_t_result(gpu_data_out, tensorRange);
+  sycl_device.memcpyHostToDevice(gpu_data_in, t_input.data(), t_input_bytes);
+  sycl_device.memcpyHostToDevice(gpu_data_out, t_input.data(), t_input_bytes);
+
+  gpu_t_result.device(sycl_device) = gpu_t_input.cumsum(consume_dim, exclusive);
+
+  t_result = t_input.cumsum(consume_dim, exclusive);
+
+  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), gpu_data_out, t_result_bytes);
+  sycl_device.synchronize();
+
+  for (IndexType i = 0; i < t_result.size(); i++) {
+    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
+      continue;
+    }
+    std::cout << "mismatch detected at index " << i << " CPU : " << t_result(i) << " vs SYCL : " << t_result_gpu(i)
+              << std::endl;
+    assert(false);
+  }
+  sycl_device.deallocate(gpu_data_in);
+  sycl_device.deallocate(gpu_data_out);
+}
+
+template <typename DataType, typename Dev>
+void sycl_scan_test_exclusive_dim0_per_device(const Dev& sycl_device) {
+  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, true);
+  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, true);
+}
+template <typename DataType, typename Dev>
+void sycl_scan_test_exclusive_dim1_per_device(const Dev& sycl_device) {
+  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, true);
+  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, true);
+}
+template <typename DataType, typename Dev>
+void sycl_scan_test_exclusive_dim2_per_device(const Dev& sycl_device) {
+  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, true);
+  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, true);
+}
+template <typename DataType, typename Dev>
+void sycl_scan_test_inclusive_dim0_per_device(const Dev& sycl_device) {
+  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, false);
+  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, false);
+}
+template <typename DataType, typename Dev>
+void sycl_scan_test_inclusive_dim1_per_device(const Dev& sycl_device) {
+  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, false);
+  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, false);
+}
+template <typename DataType, typename Dev>
+void sycl_scan_test_inclusive_dim2_per_device(const Dev& sycl_device) {
+  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, false);
+  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, false);
+}
+EIGEN_DECLARE_TEST(tensor_scan_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    std::cout << "Running on " << device.template get_info<cl::sycl::info::device::name>() << std::endl;
+    QueueInterface queueInterface(device);
+    auto sycl_device = Eigen::SyclDevice(&queueInterface);
+    CALL_SUBTEST_1(sycl_scan_test_exclusive_dim0_per_device<float>(sycl_device));
+    CALL_SUBTEST_2(sycl_scan_test_exclusive_dim1_per_device<float>(sycl_device));
+    CALL_SUBTEST_3(sycl_scan_test_exclusive_dim2_per_device<float>(sycl_device));
+    CALL_SUBTEST_4(sycl_scan_test_inclusive_dim0_per_device<float>(sycl_device));
+    CALL_SUBTEST_5(sycl_scan_test_inclusive_dim1_per_device<float>(sycl_device));
+    CALL_SUBTEST_6(sycl_scan_test_inclusive_dim2_per_device<float>(sycl_device));
+  }
+}
diff --git a/contrib/test/tensor_shuffling.cpp b/contrib/test/tensor_shuffling.cpp
new file mode 100644
index 0000000..0f432e2
--- /dev/null
+++ b/contrib/test/tensor_shuffling.cpp
@@ -0,0 +1,364 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_shuffling() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> shuffles;
+  shuffles[0] = 0;
+  shuffles[1] = 1;
+  shuffles[2] = 2;
+  shuffles[3] = 3;
+
+  Tensor<float, 4, DataLayout> no_shuffle;
+  no_shuffle = tensor.shuffle(shuffles);
+
+  VERIFY_IS_EQUAL(no_shuffle.dimension(0), 2);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(1), 3);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(2), 5);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_shuffle(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  shuffles[0] = 2;
+  shuffles[1] = 3;
+  shuffles[2] = 1;
+  shuffles[3] = 0;
+  Tensor<float, 4, DataLayout> shuffle;
+  shuffle = tensor.shuffle(shuffles);
+
+  VERIFY_IS_EQUAL(shuffle.dimension(0), 5);
+  VERIFY_IS_EQUAL(shuffle.dimension(1), 7);
+  VERIFY_IS_EQUAL(shuffle.dimension(2), 3);
+  VERIFY_IS_EQUAL(shuffle.dimension(3), 2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_expr_shuffling() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  array<ptrdiff_t, 4> shuffles;
+  shuffles[0] = 2;
+  shuffles[1] = 3;
+  shuffles[2] = 1;
+  shuffles[3] = 0;
+  Tensor<float, 4, DataLayout> expected;
+  expected = tensor.shuffle(shuffles);
+
+  Tensor<float, 4, DataLayout> result(5, 7, 3, 2);
+
+  array<ptrdiff_t, 4> src_slice_dim{{2, 3, 1, 7}};
+  array<ptrdiff_t, 4> src_slice_start{{0, 0, 0, 0}};
+  array<ptrdiff_t, 4> dst_slice_dim{{1, 7, 3, 2}};
+  array<ptrdiff_t, 4> dst_slice_start{{0, 0, 0, 0}};
+
+  for (int i = 0; i < 5; ++i) {
+    result.slice(dst_slice_start, dst_slice_dim) = tensor.slice(src_slice_start, src_slice_dim).shuffle(shuffles);
+    src_slice_start[2] += 1;
+    dst_slice_start[0] += 1;
+  }
+
+  VERIFY_IS_EQUAL(result.dimension(0), 5);
+  VERIFY_IS_EQUAL(result.dimension(1), 7);
+  VERIFY_IS_EQUAL(result.dimension(2), 3);
+  VERIFY_IS_EQUAL(result.dimension(3), 2);
+
+  for (int i = 0; i < expected.dimension(0); ++i) {
+    for (int j = 0; j < expected.dimension(1); ++j) {
+      for (int k = 0; k < expected.dimension(2); ++k) {
+        for (int l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  dst_slice_start[0] = 0;
+  result.setRandom();
+  for (int i = 0; i < 5; ++i) {
+    result.slice(dst_slice_start, dst_slice_dim) = tensor.shuffle(shuffles).slice(dst_slice_start, dst_slice_dim);
+    dst_slice_start[0] += 1;
+  }
+
+  for (int i = 0; i < expected.dimension(0); ++i) {
+    for (int j = 0; j < expected.dimension(1); ++j) {
+      for (int k = 0; k < expected.dimension(2); ++k) {
+        for (int l = 0; l < expected.dimension(3); ++l) {
+          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_shuffling_as_value() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> shuffles;
+  shuffles[2] = 0;
+  shuffles[3] = 1;
+  shuffles[1] = 2;
+  shuffles[0] = 3;
+  Tensor<float, 4, DataLayout> shuffle(5, 7, 3, 2);
+  shuffle.shuffle(shuffles) = tensor;
+
+  VERIFY_IS_EQUAL(shuffle.dimension(0), 5);
+  VERIFY_IS_EQUAL(shuffle.dimension(1), 7);
+  VERIFY_IS_EQUAL(shuffle.dimension(2), 3);
+  VERIFY_IS_EQUAL(shuffle.dimension(3), 2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
+        }
+      }
+    }
+  }
+
+  array<ptrdiff_t, 4> no_shuffle;
+  no_shuffle[0] = 0;
+  no_shuffle[1] = 1;
+  no_shuffle[2] = 2;
+  no_shuffle[3] = 3;
+  Tensor<float, 4, DataLayout> shuffle2(5, 7, 3, 2);
+  shuffle2.shuffle(shuffles) = tensor.shuffle(no_shuffle);
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 2; ++l) {
+          VERIFY_IS_EQUAL(shuffle2(i, j, k, l), shuffle(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_shuffle_unshuffle() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+
+  // Choose a random permutation.
+  array<ptrdiff_t, 4> shuffles;
+  for (int i = 0; i < 4; ++i) {
+    shuffles[i] = i;
+  }
+  array<ptrdiff_t, 4> shuffles_inverse;
+  for (int i = 0; i < 4; ++i) {
+    const ptrdiff_t index = internal::random<ptrdiff_t>(i, 3);
+    shuffles_inverse[shuffles[index]] = i;
+    std::swap(shuffles[i], shuffles[index]);
+  }
+
+  Tensor<float, 4, DataLayout> shuffle;
+  shuffle = tensor.shuffle(shuffles).shuffle(shuffles_inverse);
+
+  VERIFY_IS_EQUAL(shuffle.dimension(0), 2);
+  VERIFY_IS_EQUAL(shuffle.dimension(1), 3);
+  VERIFY_IS_EQUAL(shuffle.dimension(2), 5);
+  VERIFY_IS_EQUAL(shuffle.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_empty_shuffling() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 0, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> shuffles;
+  shuffles[0] = 0;
+  shuffles[1] = 1;
+  shuffles[2] = 2;
+  shuffles[3] = 3;
+
+  Tensor<float, 4, DataLayout> no_shuffle;
+  no_shuffle = tensor.shuffle(shuffles);
+
+  VERIFY_IS_EQUAL(no_shuffle.dimension(0), 2);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(1), 3);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(2), 0);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 0; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_shuffle(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  shuffles[0] = 2;
+  shuffles[1] = 3;
+  shuffles[2] = 1;
+  shuffles[3] = 0;
+  Tensor<float, 4, DataLayout> shuffle;
+  shuffle = tensor.shuffle(shuffles);
+
+  VERIFY_IS_EQUAL(shuffle.dimension(0), 0);
+  VERIFY_IS_EQUAL(shuffle.dimension(1), 7);
+  VERIFY_IS_EQUAL(shuffle.dimension(2), 3);
+  VERIFY_IS_EQUAL(shuffle.dimension(3), 2);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 0; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
+        }
+      }
+    }
+  }
+}
+
+// Regression: a scalar-changing consumer (here `.cast<double>()`) sits above
+// shuffle in the assign. Before TensorConversionOp::block dropped the
+// forwarded destination on a non-degenerate cast, shuffle's prepareStorage
+// would reuse a double-sized buffer as int storage (assert in debug,
+// corruption in release). Mirrors test_concatenation_through_cast.
+template <int DataLayout>
+static void test_shuffling_through_cast() {
+  Tensor<int, 2, DataLayout> src(2, 3);
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) src(i, j) = i + 1 + 10 * j;
+  }
+  array<ptrdiff_t, 2> shuffles{1, 0};
+  Tensor<double, 2, DataLayout> out(3, 2);
+  out = src.shuffle(shuffles).template cast<double>();
+  for (int j = 0; j < 3; ++j) {
+    for (int i = 0; i < 2; ++i) {
+      VERIFY_IS_APPROX(out(j, i), static_cast<double>(src(i, j)));
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_shuffling_packet_paths() {
+  // Sizes with partial-packet tails; expression-sourced reads so the packet
+  // path (not the block path) is exercised, sweeping permutations that
+  // preserve and that shuffle the inner dimension.
+  Tensor<T, 3, DataLayout> tensor(17, 5, 7);
+  tensor.setRandom();
+
+  const ptrdiff_t perms[][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {2, 1, 0}, {1, 2, 0}, {2, 0, 1}};
+  for (const auto& p : perms) {
+    array<ptrdiff_t, 3> shuffle{{p[0], p[1], p[2]}};
+
+    // Expression-sourced: the argument has no raw buffer, so the shuffle
+    // cannot use its block path and must serve packets.
+    Tensor<T, 3, DataLayout> result = (tensor * tensor.constant(T(2))).shuffle(shuffle);
+    for (Index i = 0; i < result.dimension(0); ++i) {
+      for (Index j = 0; j < result.dimension(1); ++j) {
+        for (Index k = 0; k < result.dimension(2); ++k) {
+          array<Index, 3> out_idx{{i, j, k}};
+          array<Index, 3> in_idx;
+          in_idx[p[0]] = i;
+          in_idx[p[1]] = j;
+          in_idx[p[2]] = k;
+          VERIFY_IS_EQUAL(result(out_idx), T(2) * tensor(in_idx[0], in_idx[1], in_idx[2]));
+        }
+      }
+    }
+
+    // Lvalue: writePacket through the shuffled destination.
+    Tensor<T, 3, DataLayout> dst(17, 5, 7);
+    dst.setZero();
+    array<Index, 3> dst_dims{{17, 5, 7}};
+    Tensor<T, 3, DataLayout> src(dst_dims[p[0]], dst_dims[p[1]], dst_dims[p[2]]);
+    src.setRandom();
+    array<Index, 3> no_strides{{1, 1, 1}};
+    // Unit striding keeps packet access but disables block evaluation.
+    dst.shuffle(shuffle) = src.stride(no_strides);
+    for (Index i = 0; i < src.dimension(0); ++i) {
+      for (Index j = 0; j < src.dimension(1); ++j) {
+        for (Index k = 0; k < src.dimension(2); ++k) {
+          array<Index, 3> in_idx;
+          in_idx[p[0]] = i;
+          in_idx[p[1]] = j;
+          in_idx[p[2]] = k;
+          VERIFY_IS_EQUAL(src(i, j, k), dst(in_idx[0], in_idx[1], in_idx[2]));
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_identity_shuffling_without_impl_packet_access() {
+  Tensor<T, 3, DataLayout> tensor(17, 5, 7);
+  tensor.setRandom();
+  const Eigen::TensorRef<const Tensor<T, 3, DataLayout>> ref(tensor);
+  array<ptrdiff_t, 3> identity{{0, 1, 2}};
+
+  Tensor<T, 3, DataLayout> result = ref.shuffle(identity);
+  for (Index i = 0; i < result.size(); ++i) {
+    VERIFY_IS_EQUAL(result.coeff(i), tensor.coeff(i));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_shuffling) {
+  CALL_SUBTEST(test_simple_shuffling<ColMajor>());
+  CALL_SUBTEST(test_simple_shuffling<RowMajor>());
+  CALL_SUBTEST(test_expr_shuffling<ColMajor>());
+  CALL_SUBTEST(test_expr_shuffling<RowMajor>());
+  CALL_SUBTEST(test_shuffling_as_value<ColMajor>());
+  CALL_SUBTEST(test_shuffling_as_value<RowMajor>());
+  CALL_SUBTEST(test_shuffle_unshuffle<ColMajor>());
+  CALL_SUBTEST(test_shuffle_unshuffle<RowMajor>());
+  CALL_SUBTEST(test_empty_shuffling<ColMajor>());
+  CALL_SUBTEST(test_empty_shuffling<RowMajor>());
+  CALL_SUBTEST(test_shuffling_through_cast<ColMajor>());
+  CALL_SUBTEST(test_shuffling_through_cast<RowMajor>());
+  CALL_SUBTEST((test_shuffling_packet_paths<float, ColMajor>()));
+  CALL_SUBTEST((test_shuffling_packet_paths<float, RowMajor>()));
+  CALL_SUBTEST((test_shuffling_packet_paths<double, ColMajor>()));
+  CALL_SUBTEST((test_shuffling_packet_paths<double, RowMajor>()));
+  CALL_SUBTEST((test_identity_shuffling_without_impl_packet_access<float, ColMajor>()));
+  CALL_SUBTEST((test_identity_shuffling_without_impl_packet_access<float, RowMajor>()));
+}
diff --git a/contrib/test/tensor_shuffling_sycl.cpp b/contrib/test/tensor_shuffling_sycl.cpp
new file mode 100644
index 0000000..fe45e1f
--- /dev/null
+++ b/contrib/test/tensor_shuffling_sycl.cpp
@@ -0,0 +1,115 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_shuffling_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
+  Tensor<DataType, 4, DataLayout, IndexType> no_shuffle(tensorRange);
+  tensor.setRandom();
+
+  const size_t buffSize = tensor.size() * sizeof(DataType);
+  array<IndexType, 4> shuffles;
+  shuffles[0] = 0;
+  shuffles[1] = 1;
+  shuffles[2] = 2;
+  shuffles[3] = 3;
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(buffSize));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(buffSize));
+
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), buffSize);
+
+  gpu2.device(sycl_device) = gpu1.shuffle(shuffles);
+  sycl_device.memcpyDeviceToHost(no_shuffle.data(), gpu_data2, buffSize);
+  sycl_device.synchronize();
+
+  VERIFY_IS_EQUAL(no_shuffle.dimension(0), sizeDim1);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(1), sizeDim2);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(2), sizeDim3);
+  VERIFY_IS_EQUAL(no_shuffle.dimension(3), sizeDim4);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        for (IndexType l = 0; l < sizeDim4; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_shuffle(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  shuffles[0] = 2;
+  shuffles[1] = 3;
+  shuffles[2] = 1;
+  shuffles[3] = 0;
+  array<IndexType, 4> tensorrangeShuffle = {{sizeDim3, sizeDim4, sizeDim2, sizeDim1}};
+  Tensor<DataType, 4, DataLayout, IndexType> shuffle(tensorrangeShuffle);
+  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(buffSize));
+  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu3(gpu_data3, tensorrangeShuffle);
+
+  gpu3.device(sycl_device) = gpu1.shuffle(shuffles);
+  sycl_device.memcpyDeviceToHost(shuffle.data(), gpu_data3, buffSize);
+  sycl_device.synchronize();
+
+  VERIFY_IS_EQUAL(shuffle.dimension(0), sizeDim3);
+  VERIFY_IS_EQUAL(shuffle.dimension(1), sizeDim4);
+  VERIFY_IS_EQUAL(shuffle.dimension(2), sizeDim2);
+  VERIFY_IS_EQUAL(shuffle.dimension(3), sizeDim1);
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        for (IndexType l = 0; l < sizeDim4; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
+        }
+      }
+    }
+  }
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_shuffling_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_shuffling_sycl<DataType, RowMajor, int64_t>(sycl_device);
+  test_simple_shuffling_sycl<DataType, ColMajor, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_shuffling_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_shuffling_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_shuffling_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_simple.cpp b/contrib/test/tensor_simple.cpp
new file mode 100644
index 0000000..723a680
--- /dev/null
+++ b/contrib/test/tensor_simple.cpp
@@ -0,0 +1,374 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_0d() {
+  Tensor<int, 0> scalar1;
+  Tensor<int, 0, RowMajor> scalar2;
+  Tensor<int, 0> scalar3;
+  Tensor<int, 0, RowMajor> scalar4;
+
+  scalar3.resize();
+  scalar4.resize();
+
+  scalar1() = 7;
+  scalar2() = 13;
+  scalar3.setValues(17);
+  scalar4.setZero();
+
+  VERIFY_IS_EQUAL(scalar1.rank(), 0);
+  VERIFY_IS_EQUAL(scalar1.size(), 1);
+
+  VERIFY_IS_EQUAL(scalar1(), 7);
+  VERIFY_IS_EQUAL(scalar2(), 13);
+  VERIFY_IS_EQUAL(scalar3(), 17);
+  VERIFY_IS_EQUAL(scalar4(), 0);
+
+  Tensor<int, 0> scalar5(scalar1);
+
+  VERIFY_IS_EQUAL(scalar5(), 7);
+  VERIFY_IS_EQUAL(scalar5.data()[0], 7);
+}
+
+static void test_1d() {
+  Tensor<int, 1> vec1(6);
+  Tensor<int, 1, RowMajor> vec2(6);
+  Tensor<int, 1> vec3;
+  Tensor<int, 1, RowMajor> vec4;
+
+  vec3.resize(6);
+  vec4.resize(6);
+
+  vec1(0) = 4;
+  vec2(0) = 0;
+  vec3(0) = 5;
+  vec1(1) = 8;
+  vec2(1) = 1;
+  vec3(1) = 4;
+  vec1(2) = 15;
+  vec2(2) = 2;
+  vec3(2) = 3;
+  vec1(3) = 16;
+  vec2(3) = 3;
+  vec3(3) = 2;
+  vec1(4) = 23;
+  vec2(4) = 4;
+  vec3(4) = 1;
+  vec1(5) = 42;
+  vec2(5) = 5;
+  vec3(5) = 0;
+  vec4.setZero();
+
+  VERIFY_IS_EQUAL((vec1.rank()), 1);
+  VERIFY_IS_EQUAL((vec1.size()), 6);
+  VERIFY_IS_EQUAL((vec1.dimensions()[0]), 6);
+
+  VERIFY_IS_EQUAL((vec1[0]), 4);
+  VERIFY_IS_EQUAL((vec1[1]), 8);
+  VERIFY_IS_EQUAL((vec1[2]), 15);
+  VERIFY_IS_EQUAL((vec1[3]), 16);
+  VERIFY_IS_EQUAL((vec1[4]), 23);
+  VERIFY_IS_EQUAL((vec1[5]), 42);
+
+  VERIFY_IS_EQUAL((vec2[0]), 0);
+  VERIFY_IS_EQUAL((vec2[1]), 1);
+  VERIFY_IS_EQUAL((vec2[2]), 2);
+  VERIFY_IS_EQUAL((vec2[3]), 3);
+  VERIFY_IS_EQUAL((vec2[4]), 4);
+  VERIFY_IS_EQUAL((vec2[5]), 5);
+
+  VERIFY_IS_EQUAL((vec3[0]), 5);
+  VERIFY_IS_EQUAL((vec3[1]), 4);
+  VERIFY_IS_EQUAL((vec3[2]), 3);
+  VERIFY_IS_EQUAL((vec3[3]), 2);
+  VERIFY_IS_EQUAL((vec3[4]), 1);
+  VERIFY_IS_EQUAL((vec3[5]), 0);
+
+  VERIFY_IS_EQUAL((vec4[0]), 0);
+  VERIFY_IS_EQUAL((vec4[1]), 0);
+  VERIFY_IS_EQUAL((vec4[2]), 0);
+  VERIFY_IS_EQUAL((vec4[3]), 0);
+  VERIFY_IS_EQUAL((vec4[4]), 0);
+  VERIFY_IS_EQUAL((vec4[5]), 0);
+
+  Tensor<int, 1> vec5(vec1);
+
+  VERIFY_IS_EQUAL((vec5(0)), 4);
+  VERIFY_IS_EQUAL((vec5(1)), 8);
+  VERIFY_IS_EQUAL((vec5(2)), 15);
+  VERIFY_IS_EQUAL((vec5(3)), 16);
+  VERIFY_IS_EQUAL((vec5(4)), 23);
+  VERIFY_IS_EQUAL((vec5(5)), 42);
+
+  VERIFY_IS_EQUAL((vec5.data()[0]), 4);
+  VERIFY_IS_EQUAL((vec5.data()[1]), 8);
+  VERIFY_IS_EQUAL((vec5.data()[2]), 15);
+  VERIFY_IS_EQUAL((vec5.data()[3]), 16);
+  VERIFY_IS_EQUAL((vec5.data()[4]), 23);
+  VERIFY_IS_EQUAL((vec5.data()[5]), 42);
+}
+
+static void test_2d() {
+  Tensor<int, 2> mat1(2, 3);
+  Tensor<int, 2, RowMajor> mat2(2, 3);
+
+  mat1(0, 0) = 0;
+  mat1(0, 1) = 1;
+  mat1(0, 2) = 2;
+  mat1(1, 0) = 3;
+  mat1(1, 1) = 4;
+  mat1(1, 2) = 5;
+
+  mat2(0, 0) = 0;
+  mat2(0, 1) = 1;
+  mat2(0, 2) = 2;
+  mat2(1, 0) = 3;
+  mat2(1, 1) = 4;
+  mat2(1, 2) = 5;
+
+  VERIFY_IS_EQUAL((mat1.rank()), 2);
+  VERIFY_IS_EQUAL((mat1.size()), 6);
+  VERIFY_IS_EQUAL((mat1.dimensions()[0]), 2);
+  VERIFY_IS_EQUAL((mat1.dimensions()[1]), 3);
+
+  VERIFY_IS_EQUAL((mat2.rank()), 2);
+  VERIFY_IS_EQUAL((mat2.size()), 6);
+  VERIFY_IS_EQUAL((mat2.dimensions()[0]), 2);
+  VERIFY_IS_EQUAL((mat2.dimensions()[1]), 3);
+
+  VERIFY_IS_EQUAL((mat1.data()[0]), 0);
+  VERIFY_IS_EQUAL((mat1.data()[1]), 3);
+  VERIFY_IS_EQUAL((mat1.data()[2]), 1);
+  VERIFY_IS_EQUAL((mat1.data()[3]), 4);
+  VERIFY_IS_EQUAL((mat1.data()[4]), 2);
+  VERIFY_IS_EQUAL((mat1.data()[5]), 5);
+
+  VERIFY_IS_EQUAL((mat2.data()[0]), 0);
+  VERIFY_IS_EQUAL((mat2.data()[1]), 1);
+  VERIFY_IS_EQUAL((mat2.data()[2]), 2);
+  VERIFY_IS_EQUAL((mat2.data()[3]), 3);
+  VERIFY_IS_EQUAL((mat2.data()[4]), 4);
+  VERIFY_IS_EQUAL((mat2.data()[5]), 5);
+}
+
+static void test_3d() {
+  Tensor<int, 3> epsilon(3, 3, 3);
+  epsilon.setZero();
+  epsilon(0, 1, 2) = epsilon(2, 0, 1) = epsilon(1, 2, 0) = 1;
+  epsilon(2, 1, 0) = epsilon(0, 2, 1) = epsilon(1, 0, 2) = -1;
+
+  VERIFY_IS_EQUAL((epsilon.size()), 27);
+  VERIFY_IS_EQUAL((epsilon.dimensions()[0]), 3);
+  VERIFY_IS_EQUAL((epsilon.dimensions()[1]), 3);
+  VERIFY_IS_EQUAL((epsilon.dimensions()[2]), 3);
+
+  VERIFY_IS_EQUAL((epsilon(0, 0, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(0, 0, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(0, 0, 2)), 0);
+  VERIFY_IS_EQUAL((epsilon(0, 1, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(0, 1, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(0, 2, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(0, 2, 2)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 0, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 0, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 1, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 1, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 1, 2)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 2, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(1, 2, 2)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 0, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 0, 2)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 1, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 1, 2)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 2, 0)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 2, 1)), 0);
+  VERIFY_IS_EQUAL((epsilon(2, 2, 2)), 0);
+
+  VERIFY_IS_EQUAL((epsilon(0, 1, 2)), 1);
+  VERIFY_IS_EQUAL((epsilon(2, 0, 1)), 1);
+  VERIFY_IS_EQUAL((epsilon(1, 2, 0)), 1);
+  VERIFY_IS_EQUAL((epsilon(2, 1, 0)), -1);
+  VERIFY_IS_EQUAL((epsilon(0, 2, 1)), -1);
+  VERIFY_IS_EQUAL((epsilon(1, 0, 2)), -1);
+
+  array<Eigen::DenseIndex, 3> dims;
+  dims[0] = 2;
+  dims[1] = 3;
+  dims[2] = 4;
+  Tensor<int, 3> t1(dims);
+  Tensor<int, 3, RowMajor> t2(dims);
+
+  VERIFY_IS_EQUAL((t1.size()), 24);
+  VERIFY_IS_EQUAL((t1.dimensions()[0]), 2);
+  VERIFY_IS_EQUAL((t1.dimensions()[1]), 3);
+  VERIFY_IS_EQUAL((t1.dimensions()[2]), 4);
+
+  VERIFY_IS_EQUAL((t2.size()), 24);
+  VERIFY_IS_EQUAL((t2.dimensions()[0]), 2);
+  VERIFY_IS_EQUAL((t2.dimensions()[1]), 3);
+  VERIFY_IS_EQUAL((t2.dimensions()[2]), 4);
+
+  for (int i = 0; i < 2; i++) {
+    for (int j = 0; j < 3; j++) {
+      for (int k = 0; k < 4; k++) {
+        t1(i, j, k) = 100 * i + 10 * j + k;
+        t2(i, j, k) = 100 * i + 10 * j + k;
+      }
+    }
+  }
+
+  VERIFY_IS_EQUAL((t1.data()[0]), 0);
+  VERIFY_IS_EQUAL((t1.data()[1]), 100);
+  VERIFY_IS_EQUAL((t1.data()[2]), 10);
+  VERIFY_IS_EQUAL((t1.data()[3]), 110);
+  VERIFY_IS_EQUAL((t1.data()[4]), 20);
+  VERIFY_IS_EQUAL((t1.data()[5]), 120);
+  VERIFY_IS_EQUAL((t1.data()[6]), 1);
+  VERIFY_IS_EQUAL((t1.data()[7]), 101);
+  VERIFY_IS_EQUAL((t1.data()[8]), 11);
+  VERIFY_IS_EQUAL((t1.data()[9]), 111);
+  VERIFY_IS_EQUAL((t1.data()[10]), 21);
+  VERIFY_IS_EQUAL((t1.data()[11]), 121);
+  VERIFY_IS_EQUAL((t1.data()[12]), 2);
+  VERIFY_IS_EQUAL((t1.data()[13]), 102);
+  VERIFY_IS_EQUAL((t1.data()[14]), 12);
+  VERIFY_IS_EQUAL((t1.data()[15]), 112);
+  VERIFY_IS_EQUAL((t1.data()[16]), 22);
+  VERIFY_IS_EQUAL((t1.data()[17]), 122);
+  VERIFY_IS_EQUAL((t1.data()[18]), 3);
+  VERIFY_IS_EQUAL((t1.data()[19]), 103);
+  VERIFY_IS_EQUAL((t1.data()[20]), 13);
+  VERIFY_IS_EQUAL((t1.data()[21]), 113);
+  VERIFY_IS_EQUAL((t1.data()[22]), 23);
+  VERIFY_IS_EQUAL((t1.data()[23]), 123);
+
+  VERIFY_IS_EQUAL((t2.data()[0]), 0);
+  VERIFY_IS_EQUAL((t2.data()[1]), 1);
+  VERIFY_IS_EQUAL((t2.data()[2]), 2);
+  VERIFY_IS_EQUAL((t2.data()[3]), 3);
+  VERIFY_IS_EQUAL((t2.data()[4]), 10);
+  VERIFY_IS_EQUAL((t2.data()[5]), 11);
+  VERIFY_IS_EQUAL((t2.data()[6]), 12);
+  VERIFY_IS_EQUAL((t2.data()[7]), 13);
+  VERIFY_IS_EQUAL((t2.data()[8]), 20);
+  VERIFY_IS_EQUAL((t2.data()[9]), 21);
+  VERIFY_IS_EQUAL((t2.data()[10]), 22);
+  VERIFY_IS_EQUAL((t2.data()[11]), 23);
+  VERIFY_IS_EQUAL((t2.data()[12]), 100);
+  VERIFY_IS_EQUAL((t2.data()[13]), 101);
+  VERIFY_IS_EQUAL((t2.data()[14]), 102);
+  VERIFY_IS_EQUAL((t2.data()[15]), 103);
+  VERIFY_IS_EQUAL((t2.data()[16]), 110);
+  VERIFY_IS_EQUAL((t2.data()[17]), 111);
+  VERIFY_IS_EQUAL((t2.data()[18]), 112);
+  VERIFY_IS_EQUAL((t2.data()[19]), 113);
+  VERIFY_IS_EQUAL((t2.data()[20]), 120);
+  VERIFY_IS_EQUAL((t2.data()[21]), 121);
+  VERIFY_IS_EQUAL((t2.data()[22]), 122);
+  VERIFY_IS_EQUAL((t2.data()[23]), 123);
+}
+
+static void test_simple_assign() {
+  Tensor<int, 3> epsilon(3, 3, 3);
+  epsilon.setZero();
+  epsilon(0, 1, 2) = epsilon(2, 0, 1) = epsilon(1, 2, 0) = 1;
+  epsilon(2, 1, 0) = epsilon(0, 2, 1) = epsilon(1, 0, 2) = -1;
+
+  Tensor<int, 3> e2(3, 3, 3);
+  e2.setZero();
+  VERIFY_IS_EQUAL((e2(1, 2, 0)), 0);
+
+  e2 = epsilon;
+  VERIFY_IS_EQUAL((e2(1, 2, 0)), 1);
+  VERIFY_IS_EQUAL((e2(0, 1, 2)), 1);
+  VERIFY_IS_EQUAL((e2(2, 0, 1)), 1);
+  VERIFY_IS_EQUAL((e2(2, 1, 0)), -1);
+  VERIFY_IS_EQUAL((e2(0, 2, 1)), -1);
+  VERIFY_IS_EQUAL((e2(1, 0, 2)), -1);
+}
+
+static void test_resize() {
+  Tensor<int, 3> epsilon;
+  epsilon.resize(2, 3, 7);
+  VERIFY_IS_EQUAL(epsilon.dimension(0), 2);
+  VERIFY_IS_EQUAL(epsilon.dimension(1), 3);
+  VERIFY_IS_EQUAL(epsilon.dimension(2), 7);
+  VERIFY_IS_EQUAL(epsilon.size(), 2 * 3 * 7);
+
+  const int* old_data = epsilon.data();
+  epsilon.resize(3, 2, 7);
+  VERIFY_IS_EQUAL(epsilon.dimension(0), 3);
+  VERIFY_IS_EQUAL(epsilon.dimension(1), 2);
+  VERIFY_IS_EQUAL(epsilon.dimension(2), 7);
+  VERIFY_IS_EQUAL(epsilon.size(), 2 * 3 * 7);
+  VERIFY_IS_EQUAL(epsilon.data(), old_data);
+
+  epsilon.resize(3, 5, 7);
+  VERIFY_IS_EQUAL(epsilon.dimension(0), 3);
+  VERIFY_IS_EQUAL(epsilon.dimension(1), 5);
+  VERIFY_IS_EQUAL(epsilon.dimension(2), 7);
+  VERIFY_IS_EQUAL(epsilon.size(), 3 * 5 * 7);
+}
+
+// Regression test for issue #1616: unsigned index and dimension types must not
+// trigger narrowing errors in the variadic constructor, resize, and accessors.
+static void test_unsigned_indices() {
+  Tensor<int, 3> tensor(2u, 3ul, std::size_t(7));
+  tensor.setZero();
+  tensor.resize(std::size_t(2), 3u, 7ul);
+  tensor.setZero();
+
+  tensor(1u, std::size_t(2), 6ul) = 5;
+  VERIFY_IS_EQUAL(tensor(1u, 2u, 6u), 5);
+  VERIFY_IS_EQUAL(tensor.coeff(1ul, 2u, std::size_t(6)), 5);
+  tensor.coeffRef(0u, 0ul, std::size_t(0)) = 7;
+
+  const Tensor<int, 3>& const_tensor = tensor;
+  VERIFY_IS_EQUAL(const_tensor(0u, std::size_t(0), 0ul), 7);
+  VERIFY_IS_EQUAL(const_tensor.coeff(0ul, 0u, 0u), 7);
+}
+
+// An index the tensor's index type cannot represent must assert rather than silently truncate.
+static void test_narrowing_indices() {
+  // Fixed width: on ILP32 targets shifting std::size_t by 40 is undefined, and GCC folds it to an in-range 0.
+  const std::uint64_t too_large = std::uint64_t(1) << 40;
+
+  Tensor<int, 3, ColMajor, int> tensor(2, 3, 7);
+  tensor.setZero();
+  VERIFY_RAISES_ASSERT(tensor(0, 0, too_large) = 1);
+  VERIFY_RAISES_ASSERT(tensor.coeffRef(0, 0, too_large) = 1);
+  VERIFY_RAISES_ASSERT(tensor.resize(2, 3, too_large));
+
+  const Tensor<int, 3, ColMajor, int>& const_tensor = tensor;
+  VERIFY_RAISES_ASSERT(const_tensor(0, 0, too_large));
+  VERIFY_RAISES_ASSERT(const_tensor.coeff(0, 0, too_large));
+
+  // A same-width unsigned value reaches the index type without truncating, but as a negative index.
+  Tensor<int, 3> wide_tensor(2, 3, 7);
+  wide_tensor.setZero();
+  VERIFY_RAISES_ASSERT(wide_tensor(0, 0, std::size_t(-1)) = 1);
+}
+
+EIGEN_DECLARE_TEST(tensor_simple) {
+  CALL_SUBTEST(test_0d());
+  CALL_SUBTEST(test_1d());
+  CALL_SUBTEST(test_2d());
+  CALL_SUBTEST(test_3d());
+  CALL_SUBTEST(test_simple_assign());
+  CALL_SUBTEST(test_resize());
+  CALL_SUBTEST(test_unsigned_indices());
+  CALL_SUBTEST(test_narrowing_indices());
+}
diff --git a/contrib/test/tensor_special_members.cpp b/contrib/test/tensor_special_members.cpp
new file mode 100644
index 0000000..aa6b846
--- /dev/null
+++ b/contrib/test/tensor_special_members.cpp
@@ -0,0 +1,36 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using DynamicDims = DSizes<Index, 3>;
+using StaticDims = Sizes<2, 3, 4>;
+using IndexTuple = internal::IndexTuple<Index, type2index<3>>;
+using DynamicIndexList = IndexList<Index, type2index<3>>;
+
+static_assert(std::is_trivially_destructible<TensorOpCost>::value, "TensorOpCost should have a trivial destructor");
+static_assert(std::is_move_constructible<TensorOpCost>::value, "TensorOpCost should be move constructible");
+static_assert(std::is_move_constructible<DynamicDims>::value, "DSizes should be move constructible");
+static_assert(std::is_trivially_destructible<DynamicDims>::value, "DSizes should have a trivial destructor");
+static_assert(std::is_move_constructible<StaticDims>::value, "Sizes should be move constructible");
+static_assert(std::is_trivially_destructible<StaticDims>::value, "Sizes should have a trivial destructor");
+static_assert(std::is_move_constructible<Pair<int, int>>::value, "Pair should be move constructible");
+static_assert(std::is_trivially_destructible<Pair<int, int>>::value, "Pair should have a trivial destructor");
+static_assert(std::is_move_constructible<IndexPair<Index>>::value, "IndexPair should be move constructible");
+static_assert(std::is_trivially_destructible<IndexPair<Index>>::value, "IndexPair should have a trivial destructor");
+static_assert(std::is_move_constructible<IndexTuple>::value, "IndexTuple should be move constructible");
+static_assert(std::is_trivially_destructible<IndexTuple>::value, "IndexTuple should have a trivial destructor");
+static_assert(std::is_move_constructible<DynamicIndexList>::value, "IndexList should be move constructible");
+static_assert(std::is_trivially_destructible<DynamicIndexList>::value, "IndexList should have a trivial destructor");
+
+constexpr TensorOpCost default_cost;
+static_assert(default_cost.bytes_loaded() == 0.0, "TensorOpCost default bytes_loaded should be zero");
+static_assert(default_cost.bytes_stored() == 0.0, "TensorOpCost default bytes_stored should be zero");
+static_assert(default_cost.compute_cycles() == 0.0, "TensorOpCost default compute_cycles should be zero");
+
+EIGEN_DECLARE_TEST(tensor_special_members) {}
diff --git a/contrib/test/tensor_striding.cpp b/contrib/test/tensor_striding.cpp
new file mode 100644
index 0000000..d84ef56
--- /dev/null
+++ b/contrib/test/tensor_striding.cpp
@@ -0,0 +1,198 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_simple_striding() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> strides;
+  strides[0] = 1;
+  strides[1] = 1;
+  strides[2] = 1;
+  strides[3] = 1;
+
+  Tensor<float, 4, DataLayout> no_stride;
+  no_stride = tensor.stride(strides);
+
+  VERIFY_IS_EQUAL(no_stride.dimension(0), 2);
+  VERIFY_IS_EQUAL(no_stride.dimension(1), 3);
+  VERIFY_IS_EQUAL(no_stride.dimension(2), 5);
+  VERIFY_IS_EQUAL(no_stride.dimension(3), 7);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  strides[0] = 2;
+  strides[1] = 4;
+  strides[2] = 2;
+  strides[3] = 3;
+  Tensor<float, 4, DataLayout> stride;
+  stride = tensor.stride(strides);
+
+  VERIFY_IS_EQUAL(stride.dimension(0), 1);
+  VERIFY_IS_EQUAL(stride.dimension(1), 1);
+  VERIFY_IS_EQUAL(stride.dimension(2), 3);
+  VERIFY_IS_EQUAL(stride.dimension(3), 3);
+
+  for (int i = 0; i < 1; ++i) {
+    for (int j = 0; j < 1; ++j) {
+      for (int k = 0; k < 3; ++k) {
+        for (int l = 0; l < 3; ++l) {
+          VERIFY_IS_EQUAL(tensor(2 * i, 4 * j, 2 * k, 3 * l), stride(i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_striding_as_lvalue() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
+  tensor.setRandom();
+  array<ptrdiff_t, 4> strides;
+  strides[0] = 2;
+  strides[1] = 4;
+  strides[2] = 2;
+  strides[3] = 3;
+
+  Tensor<float, 4, DataLayout> result(3, 12, 10, 21);
+  result.stride(strides) = tensor;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), result(2 * i, 4 * j, 2 * k, 3 * l));
+        }
+      }
+    }
+  }
+
+  array<ptrdiff_t, 4> no_strides;
+  no_strides[0] = 1;
+  no_strides[1] = 1;
+  no_strides[2] = 1;
+  no_strides[3] = 1;
+  Tensor<float, 4, DataLayout> result2(3, 12, 10, 21);
+  result2.stride(strides) = tensor.stride(no_strides);
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        for (int l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), result2(2 * i, 4 * j, 2 * k, 3 * l));
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_striding_packet_paths() {
+  // Sizes with partial-packet tails; expression-sourced reads so the packet
+  // path is exercised, sweeping strides that keep the inner dimension intact
+  // (contiguous inner runs), that stride it (gathers), and the identity.
+  // setRandom() draws integers from the full range of T, so the values scaled
+  // below would overflow; bounded draws keep them representable for every T.
+  Tensor<T, 3, DataLayout> tensor(17, 5, 7);
+  setRandomDataInRange(tensor, T(-10), T(10));
+
+  const ptrdiff_t stride_sets[][3] = {{1, 1, 1}, {2, 1, 1}, {1, 2, 1}, {1, 1, 2}, {2, 2, 2}, {3, 1, 2}};
+  for (const auto& s : stride_sets) {
+    array<ptrdiff_t, 3> strides{{s[0], s[1], s[2]}};
+
+    // Expression-sourced: the argument has no raw buffer, so the striding
+    // serves packets assembled from the nested expression.
+    Tensor<T, 3, DataLayout> result = (tensor * tensor.constant(T(2))).stride(strides);
+    for (Index i = 0; i < result.dimension(0); ++i) {
+      for (Index j = 0; j < result.dimension(1); ++j) {
+        for (Index k = 0; k < result.dimension(2); ++k) {
+          VERIFY_IS_EQUAL(result(i, j, k), T(2) * tensor(i * s[0], j * s[1], k * s[2]));
+        }
+      }
+    }
+
+    // Lvalue: writePacket through the strided destination.
+    Tensor<T, 3, DataLayout> dst(17, 5, 7);
+    dst.setZero();
+    Tensor<T, 3, DataLayout> src((17 + s[0] - 1) / s[0], (5 + s[1] - 1) / s[1], (7 + s[2] - 1) / s[2]);
+    setRandomDataInRange(src, T(-10), T(10));
+    dst.stride(strides) = src * src.constant(T(3));
+    for (Index i = 0; i < src.dimension(0); ++i) {
+      for (Index j = 0; j < src.dimension(1); ++j) {
+        for (Index k = 0; k < src.dimension(2); ++k) {
+          VERIFY_IS_EQUAL(dst(i * s[0], j * s[1], k * s[2]), T(3) * src(i, j, k));
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int DataLayout>
+static void test_striding_without_impl_packet_access() {
+  // A TensorRef argument exposes only coefficient access, but the striding
+  // still serves packets by assembling them coefficient by coefficient.
+  Tensor<T, 3, DataLayout> tensor(17, 5, 7);
+  tensor.setRandom();
+  const Eigen::TensorRef<const Tensor<T, 3, DataLayout>> ref(tensor);
+
+  array<ptrdiff_t, 3> identity{{1, 1, 1}};
+
+  // Pin the capabilities this test relies on: the nested TensorRef evaluator
+  // must not have packet access (otherwise this test exercises nothing), while
+  // the striding evaluator on top of it must still advertise it.
+  typedef Eigen::TensorRef<const Tensor<T, 3, DataLayout>> RefType;
+  typedef decltype(std::declval<const RefType&>().stride(identity)) StrideExprType;
+  typedef Eigen::TensorEvaluator<const RefType, Eigen::DefaultDevice> RefEvaluator;
+  typedef Eigen::TensorEvaluator<const StrideExprType, Eigen::DefaultDevice> StrideEvaluator;
+  EIGEN_STATIC_ASSERT(!RefEvaluator::PacketAccess, YOU_MADE_A_PROGRAMMING_MISTAKE)
+  EIGEN_STATIC_ASSERT(StrideEvaluator::PacketAccess, YOU_MADE_A_PROGRAMMING_MISTAKE)
+
+  Tensor<T, 3, DataLayout> result = ref.stride(identity);
+  for (Index i = 0; i < result.size(); ++i) {
+    VERIFY_IS_EQUAL(result.coeff(i), tensor.coeff(i));
+  }
+
+  array<ptrdiff_t, 3> strides{{2, 1, 3}};
+  Tensor<T, 3, DataLayout> strided = ref.stride(strides);
+  for (Index i = 0; i < strided.dimension(0); ++i) {
+    for (Index j = 0; j < strided.dimension(1); ++j) {
+      for (Index k = 0; k < strided.dimension(2); ++k) {
+        VERIFY_IS_EQUAL(strided(i, j, k), tensor(i * 2, j, k * 3));
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_striding) {
+  CALL_SUBTEST(test_simple_striding<ColMajor>());
+  CALL_SUBTEST(test_simple_striding<RowMajor>());
+  CALL_SUBTEST(test_striding_as_lvalue<ColMajor>());
+  CALL_SUBTEST(test_striding_as_lvalue<RowMajor>());
+  CALL_SUBTEST((test_striding_packet_paths<float, ColMajor>()));
+  CALL_SUBTEST((test_striding_packet_paths<float, RowMajor>()));
+  CALL_SUBTEST((test_striding_packet_paths<int, ColMajor>()));
+  CALL_SUBTEST((test_striding_packet_paths<int, RowMajor>()));
+  CALL_SUBTEST((test_striding_without_impl_packet_access<float, ColMajor>()));
+  CALL_SUBTEST((test_striding_without_impl_packet_access<float, RowMajor>()));
+}
diff --git a/contrib/test/tensor_striding_sycl.cpp b/contrib/test/tensor_striding_sycl.cpp
new file mode 100644
index 0000000..95097eb
--- /dev/null
+++ b/contrib/test/tensor_striding_sycl.cpp
@@ -0,0 +1,194 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include <iostream>
+#include <chrono>
+#include <ctime>
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_simple_striding(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 4> tensor_dims = {{2, 3, 5, 7}};
+  Eigen::array<IndexType, 4> stride_dims = {{1, 1, 3, 3}};
+
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensor_dims);
+  Tensor<DataType, 4, DataLayout, IndexType> no_stride(tensor_dims);
+  Tensor<DataType, 4, DataLayout, IndexType> stride(stride_dims);
+
+  std::size_t tensor_bytes = tensor.size() * sizeof(DataType);
+  std::size_t no_stride_bytes = no_stride.size() * sizeof(DataType);
+  std::size_t stride_bytes = stride.size() * sizeof(DataType);
+  DataType* d_tensor = static_cast<DataType*>(sycl_device.allocate(tensor_bytes));
+  DataType* d_no_stride = static_cast<DataType*>(sycl_device.allocate(no_stride_bytes));
+  DataType* d_stride = static_cast<DataType*>(sycl_device.allocate(stride_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_tensor(d_tensor, tensor_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_no_stride(d_no_stride, tensor_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_stride(d_stride, stride_dims);
+
+  tensor.setRandom();
+  array<IndexType, 4> strides;
+  strides[0] = 1;
+  strides[1] = 1;
+  strides[2] = 1;
+  strides[3] = 1;
+  sycl_device.memcpyHostToDevice(d_tensor, tensor.data(), tensor_bytes);
+  gpu_no_stride.device(sycl_device) = gpu_tensor.stride(strides);
+  sycl_device.memcpyDeviceToHost(no_stride.data(), d_no_stride, no_stride_bytes);
+
+  // no_stride = tensor.stride(strides);
+
+  VERIFY_IS_EQUAL(no_stride.dimension(0), 2);
+  VERIFY_IS_EQUAL(no_stride.dimension(1), 3);
+  VERIFY_IS_EQUAL(no_stride.dimension(2), 5);
+  VERIFY_IS_EQUAL(no_stride.dimension(3), 7);
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  strides[0] = 2;
+  strides[1] = 4;
+  strides[2] = 2;
+  strides[3] = 3;
+  // Tensor<float, 4, DataLayout> stride;
+  //   stride = tensor.stride(strides);
+
+  gpu_stride.device(sycl_device) = gpu_tensor.stride(strides);
+  sycl_device.memcpyDeviceToHost(stride.data(), d_stride, stride_bytes);
+
+  VERIFY_IS_EQUAL(stride.dimension(0), 1);
+  VERIFY_IS_EQUAL(stride.dimension(1), 1);
+  VERIFY_IS_EQUAL(stride.dimension(2), 3);
+  VERIFY_IS_EQUAL(stride.dimension(3), 3);
+
+  for (IndexType i = 0; i < 1; ++i) {
+    for (IndexType j = 0; j < 1; ++j) {
+      for (IndexType k = 0; k < 3; ++k) {
+        for (IndexType l = 0; l < 3; ++l) {
+          VERIFY_IS_EQUAL(tensor(2 * i, 4 * j, 2 * k, 3 * l), stride(i, j, k, l));
+        }
+      }
+    }
+  }
+
+  sycl_device.deallocate(d_tensor);
+  sycl_device.deallocate(d_no_stride);
+  sycl_device.deallocate(d_stride);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+static void test_striding_as_lvalue(const Eigen::SyclDevice& sycl_device) {
+  Eigen::array<IndexType, 4> tensor_dims = {{2, 3, 5, 7}};
+  Eigen::array<IndexType, 4> stride_dims = {{3, 12, 10, 21}};
+
+  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensor_dims);
+  Tensor<DataType, 4, DataLayout, IndexType> no_stride(stride_dims);
+  Tensor<DataType, 4, DataLayout, IndexType> stride(stride_dims);
+
+  std::size_t tensor_bytes = tensor.size() * sizeof(DataType);
+  std::size_t no_stride_bytes = no_stride.size() * sizeof(DataType);
+  std::size_t stride_bytes = stride.size() * sizeof(DataType);
+
+  DataType* d_tensor = static_cast<DataType*>(sycl_device.allocate(tensor_bytes));
+  DataType* d_no_stride = static_cast<DataType*>(sycl_device.allocate(no_stride_bytes));
+  DataType* d_stride = static_cast<DataType*>(sycl_device.allocate(stride_bytes));
+
+  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_tensor(d_tensor, tensor_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_no_stride(d_no_stride, stride_dims);
+  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_stride(d_stride, stride_dims);
+
+  // Tensor<float, 4, DataLayout> tensor(2,3,5,7);
+  tensor.setRandom();
+  array<IndexType, 4> strides;
+  strides[0] = 2;
+  strides[1] = 4;
+  strides[2] = 2;
+  strides[3] = 3;
+
+  //  Tensor<float, 4, DataLayout> result(3, 12, 10, 21);
+  //  result.stride(strides) = tensor;
+  sycl_device.memcpyHostToDevice(d_tensor, tensor.data(), tensor_bytes);
+  gpu_stride.stride(strides).device(sycl_device) = gpu_tensor;
+  sycl_device.memcpyDeviceToHost(stride.data(), d_stride, stride_bytes);
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), stride(2 * i, 4 * j, 2 * k, 3 * l));
+        }
+      }
+    }
+  }
+
+  array<IndexType, 4> no_strides;
+  no_strides[0] = 1;
+  no_strides[1] = 1;
+  no_strides[2] = 1;
+  no_strides[3] = 1;
+  //  Tensor<float, 4, DataLayout> result2(3, 12, 10, 21);
+  //  result2.stride(strides) = tensor.stride(no_strides);
+
+  gpu_no_stride.stride(strides).device(sycl_device) = gpu_tensor.stride(no_strides);
+  sycl_device.memcpyDeviceToHost(no_stride.data(), d_no_stride, no_stride_bytes);
+
+  for (IndexType i = 0; i < 2; ++i) {
+    for (IndexType j = 0; j < 3; ++j) {
+      for (IndexType k = 0; k < 5; ++k) {
+        for (IndexType l = 0; l < 7; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(2 * i, 4 * j, 2 * k, 3 * l));
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(d_tensor);
+  sycl_device.deallocate(d_no_stride);
+  sycl_device.deallocate(d_stride);
+}
+
+template <typename Dev_selector>
+void tensorStridingPerDevice(Dev_selector& s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_simple_striding<float, ColMajor, int64_t>(sycl_device);
+  test_simple_striding<float, RowMajor, int64_t>(sycl_device);
+  test_striding_as_lvalue<float, ColMajor, int64_t>(sycl_device);
+  test_striding_as_lvalue<float, RowMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_striding_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(tensorStridingPerDevice(device));
+  }
+}
diff --git a/contrib/test/tensor_sugar.cpp b/contrib/test/tensor_sugar.cpp
new file mode 100644
index 0000000..1bf7e09
--- /dev/null
+++ b/contrib/test/tensor_sugar.cpp
@@ -0,0 +1,81 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::RowMajor;
+using Eigen::Tensor;
+
+static void test_comparison_sugar() {
+  // we already trust comparisons between tensors, we're simply checking that
+  // the sugared versions are doing the same thing
+  Tensor<int, 3> t(6, 7, 5);
+
+  t.setRandom();
+  // make sure we have at least one value == 0
+  t(0, 0, 0) = 0;
+
+  Tensor<bool, 0> b;
+
+#define TEST_TENSOR_EQUAL(e1, e2) \
+  b = ((e1) == (e2)).all();       \
+  VERIFY(b())
+
+#define TEST_OP(op) TEST_TENSOR_EQUAL(t op 0, t op t.constant(0))
+
+  TEST_OP(==);
+  TEST_OP(!=);
+  TEST_OP(<=);
+  TEST_OP(>=);
+  TEST_OP(<);
+  TEST_OP(>);
+#undef TEST_OP
+#undef TEST_TENSOR_EQUAL
+}
+
+static void test_scalar_sugar_add_mul() {
+  Tensor<float, 3> A(6, 7, 5);
+  Tensor<float, 3> B(6, 7, 5);
+  A.setRandom();
+  B.setRandom();
+
+  const float alpha = 0.43f;
+  const float beta = 0.21f;
+  const float gamma = 0.14f;
+
+  Tensor<float, 3> R = A.constant(gamma) + A * A.constant(alpha) + B * B.constant(beta);
+  Tensor<float, 3> S = A * alpha + B * beta + gamma;
+  Tensor<float, 3> T = gamma + alpha * A + beta * B;
+
+  for (int i = 0; i < 6 * 7 * 5; ++i) {
+    VERIFY_IS_APPROX(R(i), S(i));
+    VERIFY_IS_APPROX(R(i), T(i));
+  }
+}
+
+static void test_scalar_sugar_sub_div() {
+  Tensor<float, 3> A(6, 7, 5);
+  Tensor<float, 3> B(6, 7, 5);
+  A.setRandom();
+  B.setRandom();
+
+  const float alpha = 0.43f;
+  const float beta = 0.21f;
+  const float gamma = 0.14f;
+  const float delta = 0.32f;
+
+  Tensor<float, 3> R = A.constant(gamma) - A / A.constant(alpha) - B.constant(beta) / B - A.constant(delta);
+  Tensor<float, 3> S = gamma - A / alpha - beta / B - delta;
+
+  for (int i = 0; i < 6 * 7 * 5; ++i) {
+    VERIFY_IS_APPROX(R(i), S(i));
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_sugar) {
+  CALL_SUBTEST(test_comparison_sugar());
+  CALL_SUBTEST(test_scalar_sugar_add_mul());
+  CALL_SUBTEST(test_scalar_sugar_sub_div());
+}
diff --git a/contrib/test/tensor_sycl.cpp b/contrib/test/tensor_sycl.cpp
new file mode 100644
index 0000000..0b6f383
--- /dev/null
+++ b/contrib/test/tensor_sycl.cpp
@@ -0,0 +1,349 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+// Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::SyclDevice;
+using Eigen::Tensor;
+using Eigen::TensorMap;
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_mem_transfers(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 5;
+  IndexType sizeDim2 = 5;
+  IndexType sizeDim3 = 1;
+  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out1(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out2(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out3(tensorRange);
+
+  in1 = in1.random();
+
+  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
+  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(out1.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data1, in1.data(), (in1.size()) * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_data2, in1.data(), (in1.size()) * sizeof(DataType));
+  gpu1.device(sycl_device) = gpu1 * 3.14f;
+  gpu2.device(sycl_device) = gpu2 * 2.7f;
+  sycl_device.memcpyDeviceToHost(out1.data(), gpu_data1, (out1.size()) * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out2.data(), gpu_data1, (out2.size()) * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out3.data(), gpu_data2, (out3.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+
+  for (IndexType i = 0; i < in1.size(); ++i) {
+    //  std::cout << "SYCL DATA : " << out1(i) << "  vs  CPU DATA : " << in1(i) * 3.14f << "\n";
+    VERIFY_IS_APPROX(out1(i), in1(i) * 3.14f);
+    VERIFY_IS_APPROX(out2(i), in1(i) * 3.14f);
+    VERIFY_IS_APPROX(out3(i), in1(i) * 2.7f);
+  }
+
+  sycl_device.deallocate(gpu_data1);
+  sycl_device.deallocate(gpu_data2);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_mem_sync(const Eigen::SyclDevice& sycl_device) {
+  IndexType size = 20;
+  array<IndexType, 1> tensorRange = {{size}};
+  Tensor<DataType, 1, DataLayout, IndexType> in1(tensorRange);
+  Tensor<DataType, 1, DataLayout, IndexType> in2(tensorRange);
+  Tensor<DataType, 1, DataLayout, IndexType> out(tensorRange);
+
+  in1 = in1.random();
+  in2 = in1;
+
+  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> gpu1(gpu_data, tensorRange);
+  sycl_device.memcpyHostToDevice(gpu_data, in1.data(), (in1.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+  in1.setZero();
+
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data, out.size() * sizeof(DataType));
+  sycl_device.synchronize();
+
+  for (IndexType i = 0; i < in1.size(); ++i) {
+    VERIFY_IS_APPROX(out(i), in2(i));
+  }
+
+  sycl_device.deallocate(gpu_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_mem_sync_offsets(const Eigen::SyclDevice& sycl_device) {
+  using tensor_type = Tensor<DataType, 1, DataLayout, IndexType>;
+  IndexType full_size = 32;
+  IndexType half_size = full_size / 2;
+  array<IndexType, 1> tensorRange = {{full_size}};
+  tensor_type in1(tensorRange);
+  tensor_type out(tensorRange);
+
+  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(full_size * sizeof(DataType)));
+  TensorMap<tensor_type> gpu1(gpu_data, tensorRange);
+
+  in1 = in1.random();
+  // Copy all data to device, then permute on copy back to host
+  sycl_device.memcpyHostToDevice(gpu_data, in1.data(), full_size * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data + half_size, half_size * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out.data() + half_size, gpu_data, half_size * sizeof(DataType));
+
+  for (IndexType i = 0; i < half_size; ++i) {
+    VERIFY_IS_APPROX(out(i), in1(i + half_size));
+    VERIFY_IS_APPROX(out(i + half_size), in1(i));
+  }
+
+  in1 = in1.random();
+  out.setZero();
+  // Permute copies to device, then copy all back to host
+  sycl_device.memcpyHostToDevice(gpu_data + half_size, in1.data(), half_size * sizeof(DataType));
+  sycl_device.memcpyHostToDevice(gpu_data, in1.data() + half_size, half_size * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data, full_size * sizeof(DataType));
+
+  for (IndexType i = 0; i < half_size; ++i) {
+    VERIFY_IS_APPROX(out(i), in1(i + half_size));
+    VERIFY_IS_APPROX(out(i + half_size), in1(i));
+  }
+
+  in1 = in1.random();
+  out.setZero();
+  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(full_size * sizeof(DataType)));
+  TensorMap<tensor_type> gpu2(gpu_data_out, tensorRange);
+  // Copy all to device, permute copies on device, then copy all back to host
+  sycl_device.memcpyHostToDevice(gpu_data, in1.data(), full_size * sizeof(DataType));
+  sycl_device.memcpy(gpu_data_out + half_size, gpu_data, half_size * sizeof(DataType));
+  sycl_device.memcpy(gpu_data_out, gpu_data + half_size, half_size * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, full_size * sizeof(DataType));
+
+  for (IndexType i = 0; i < half_size; ++i) {
+    VERIFY_IS_APPROX(out(i), in1(i + half_size));
+    VERIFY_IS_APPROX(out(i + half_size), in1(i));
+  }
+
+  sycl_device.deallocate(gpu_data_out);
+  sycl_device.deallocate(gpu_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_memset_offsets(const Eigen::SyclDevice& sycl_device) {
+  using tensor_type = Tensor<DataType, 1, DataLayout, IndexType>;
+  IndexType full_size = 32;
+  IndexType half_size = full_size / 2;
+  array<IndexType, 1> tensorRange = {{full_size}};
+  tensor_type cpu_out(tensorRange);
+  tensor_type out(tensorRange);
+
+  cpu_out.setZero();
+
+  std::memset(cpu_out.data(), 0, half_size * sizeof(DataType));
+  std::memset(cpu_out.data() + half_size, 1, half_size * sizeof(DataType));
+
+  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(full_size * sizeof(DataType)));
+  TensorMap<tensor_type> gpu1(gpu_data, tensorRange);
+
+  sycl_device.memset(gpu_data, 0, half_size * sizeof(DataType));
+  sycl_device.memset(gpu_data + half_size, 1, half_size * sizeof(DataType));
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_data, full_size * sizeof(DataType));
+
+  for (IndexType i = 0; i < full_size; ++i) {
+    VERIFY_IS_APPROX(out(i), cpu_out(i));
+  }
+
+  sycl_device.deallocate(gpu_data);
+}
+
+template <typename DataType, int DataLayout, typename IndexType>
+void test_sycl_computations(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim1 = 100;
+  IndexType sizeDim2 = 10;
+  IndexType sizeDim3 = 20;
+  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
+  Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> in3(tensorRange);
+  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
+
+  in2 = in2.random();
+  in3 = in3.random();
+
+  DataType* gpu_in1_data = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
+  DataType* gpu_in2_data = static_cast<DataType*>(sycl_device.allocate(in2.size() * sizeof(DataType)));
+  DataType* gpu_in3_data = static_cast<DataType*>(sycl_device.allocate(in3.size() * sizeof(DataType)));
+  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
+
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in3(gpu_in3_data, tensorRange);
+  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
+
+  /// a=1.2f
+  gpu_in1.device(sycl_device) = gpu_in1.constant(1.2f);
+  sycl_device.memcpyDeviceToHost(in1.data(), gpu_in1_data, (in1.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(in1(i, j, k), 1.2f);
+      }
+    }
+  }
+  printf("a=1.2f Test passed\n");
+
+  /// a=b*1.2f
+  gpu_out.device(sycl_device) = gpu_in1 * 1.2f;
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * 1.2f);
+      }
+    }
+  }
+  printf("a=b*1.2f Test Passed\n");
+
+  /// c=a*b
+  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.size()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = gpu_in1 * gpu_in2;
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * in2(i, j, k));
+      }
+    }
+  }
+  printf("c=a*b Test Passed\n");
+
+  /// c=a+b
+  gpu_out.device(sycl_device) = gpu_in1 + gpu_in2;
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k));
+      }
+    }
+  }
+  printf("c=a+b Test Passed\n");
+
+  /// c=a*a
+  gpu_out.device(sycl_device) = gpu_in1 * gpu_in1;
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * in1(i, j, k));
+      }
+    }
+  }
+  printf("c= a*a Test Passed\n");
+
+  // a*3.14f + b*2.7f
+  gpu_out.device(sycl_device) = gpu_in1 * gpu_in1.constant(3.14f) + gpu_in2 * gpu_in2.constant(2.7f);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * 3.14f + in2(i, j, k) * 2.7f);
+      }
+    }
+  }
+  printf("a*3.14f + b*2.7f Test Passed\n");
+
+  /// d= (a>0.5? b:c)
+  sycl_device.memcpyHostToDevice(gpu_in3_data, in3.data(), (in3.size()) * sizeof(DataType));
+  gpu_out.device(sycl_device) = (gpu_in1 > gpu_in1.constant(0.5f)).select(gpu_in2, gpu_in3);
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
+  sycl_device.synchronize();
+  for (IndexType i = 0; i < sizeDim1; ++i) {
+    for (IndexType j = 0; j < sizeDim2; ++j) {
+      for (IndexType k = 0; k < sizeDim3; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) > 0.5f) ? in2(i, j, k) : in3(i, j, k));
+      }
+    }
+  }
+  printf("d= (a>0.5? b:c) Test Passed\n");
+  sycl_device.deallocate(gpu_in1_data);
+  sycl_device.deallocate(gpu_in2_data);
+  sycl_device.deallocate(gpu_in3_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+template <typename Scalar1, typename Scalar2, int DataLayout, typename IndexType>
+static void test_sycl_cast(const Eigen::SyclDevice& sycl_device) {
+  IndexType size = 20;
+  array<IndexType, 1> tensorRange = {{size}};
+  Tensor<Scalar1, 1, DataLayout, IndexType> in(tensorRange);
+  Tensor<Scalar2, 1, DataLayout, IndexType> out(tensorRange);
+  Tensor<Scalar2, 1, DataLayout, IndexType> out_host(tensorRange);
+
+  in = in.random();
+
+  Scalar1* gpu_in_data = static_cast<Scalar1*>(sycl_device.allocate(in.size() * sizeof(Scalar1)));
+  Scalar2* gpu_out_data = static_cast<Scalar2*>(sycl_device.allocate(out.size() * sizeof(Scalar2)));
+
+  TensorMap<Tensor<Scalar1, 1, DataLayout, IndexType>> gpu_in(gpu_in_data, tensorRange);
+  TensorMap<Tensor<Scalar2, 1, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
+  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.size()) * sizeof(Scalar1));
+  gpu_out.device(sycl_device) = gpu_in.template cast<Scalar2>();
+  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, out.size() * sizeof(Scalar2));
+  out_host = in.template cast<Scalar2>();
+  for (IndexType i = 0; i < size; i++) {
+    VERIFY_IS_APPROX(out(i), out_host(i));
+  }
+  printf("cast Test Passed\n");
+  sycl_device.deallocate(gpu_in_data);
+  sycl_device.deallocate(gpu_out_data);
+}
+template <typename DataType, typename dev_Selector>
+void sycl_computing_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  test_sycl_mem_transfers<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_computations<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_mem_sync<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_mem_sync_offsets<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_memset_offsets<DataType, RowMajor, int64_t>(sycl_device);
+  test_sycl_mem_transfers<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_computations<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_mem_sync<DataType, ColMajor, int64_t>(sycl_device);
+  test_sycl_cast<DataType, int, RowMajor, int64_t>(sycl_device);
+  test_sycl_cast<DataType, int, ColMajor, int64_t>(sycl_device);
+}
+
+EIGEN_DECLARE_TEST(tensor_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_computing_test_per_device<float>(device));
+  }
+}
diff --git a/contrib/test/tensor_symmetry.cpp b/contrib/test/tensor_symmetry.cpp
new file mode 100644
index 0000000..2b7f0cc
--- /dev/null
+++ b/contrib/test/tensor_symmetry.cpp
@@ -0,0 +1,775 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+#include <Eigen/TensorSymmetry>
+
+#include <map>
+#include <set>
+
+using Eigen::AntiHermiticity;
+using Eigen::AntiSymmetry;
+using Eigen::DynamicSGroup;
+using Eigen::Hermiticity;
+using Eigen::SGroup;
+using Eigen::StaticSGroup;
+using Eigen::Symmetry;
+using Eigen::Tensor;
+
+using Eigen::ConjugationFlag;
+using Eigen::GlobalImagFlag;
+using Eigen::GlobalRealFlag;
+using Eigen::GlobalZeroFlag;
+using Eigen::NegationFlag;
+
+// helper function to determine if the compiler instantiated a static
+// or dynamic symmetry group
+template <typename... Sym>
+bool isDynGroup(StaticSGroup<Sym...> const& dummy) {
+  (void)dummy;
+  return false;
+}
+
+bool isDynGroup(DynamicSGroup const& dummy) {
+  (void)dummy;
+  return true;
+}
+
+// helper class for checking that the symmetry groups are correct
+struct checkIdx {
+  template <typename ArrType>
+  static inline int doCheck_(ArrType e, int flags, int dummy, std::set<uint64_t>& found,
+                             std::map<uint64_t, int> const& expected) {
+    // use decimal representation of value
+    uint64_t value = e[0];
+    for (std::size_t i = 1; i < e.size(); i++) value = value * 10 + e[i];
+
+    // we want to make sure that we find each element
+    auto it = expected.find(value);
+    VERIFY((it != expected.end()));
+    VERIFY_IS_EQUAL(it->second, flags);
+
+    // we want to make sure we only have each element once;
+    // set::insert returns true for the second part of the pair
+    // if the element was really inserted and not already there
+    auto p = found.insert(value);
+    VERIFY((p.second));
+
+    return dummy;
+  }
+
+  static inline int run(std::vector<int> e, int flags, int dummy, std::set<uint64_t>& found,
+                        std::map<uint64_t, int> const& expected) {
+    return doCheck_(e, flags, dummy, found, expected);
+  }
+
+  template <std::size_t N>
+  static inline int run(std::array<int, N> e, int flags, int dummy, std::set<uint64_t>& found,
+                        std::map<uint64_t, int> const& expected) {
+    return doCheck_(e, flags, dummy, found, expected);
+  }
+};
+
+static void test_symgroups_dynamic() {
+  std::vector<int> identity;
+  for (int i = 0; i <= 6; i++) identity.push_back(i);
+
+  // Simple dynamic symmetry group
+  DynamicSGroup group;
+  group.add(0, 1, NegationFlag);
+  group.add(0, 2, ConjugationFlag);
+
+  VERIFY_IS_EQUAL(group.size(), 6u);
+  VERIFY_IS_EQUAL(group.globalFlags(), GlobalImagFlag);
+
+  std::set<uint64_t> found;
+  std::map<uint64_t, int> expected;
+  expected[123456] = 0;
+  expected[1023456] = NegationFlag;
+  expected[2103456] = ConjugationFlag;
+  expected[1203456] = ConjugationFlag | NegationFlag;
+  expected[2013456] = ConjugationFlag | NegationFlag;
+  expected[213456] = ConjugationFlag;
+
+  group.apply<checkIdx, int>(identity, 0, found, expected);
+  VERIFY_IS_EQUAL(found.size(), 6u);
+}
+
+static void test_symgroups_selection() {
+  std::array<int, 7> identity7{{0, 1, 2, 3, 4, 5, 6}};
+  std::array<int, 10> identity10{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
+
+  {
+    // Simple static symmetry group, selected via SGroup
+    SGroup<AntiSymmetry<0, 1>, Hermiticity<0, 2>> group;
+
+    std::set<uint64_t> found;
+    std::map<uint64_t, int> expected;
+    expected[123456] = 0;
+    expected[1023456] = NegationFlag;
+    expected[2103456] = ConjugationFlag;
+    expected[1203456] = ConjugationFlag | NegationFlag;
+    expected[2013456] = ConjugationFlag | NegationFlag;
+    expected[213456] = ConjugationFlag;
+
+    VERIFY(!isDynGroup(group));
+    VERIFY_IS_EQUAL(group.size(), 6u);
+    VERIFY_IS_EQUAL(group.globalFlags(), GlobalImagFlag);
+    group.apply<checkIdx, int>(identity7, 0, found, expected);
+    VERIFY_IS_EQUAL(found.size(), 6u);
+  }
+
+  {
+    // simple factorizing group: 5 generators, 2^5 = 32 elements
+    // selection should make this dynamic, although static group
+    // can still be reasonably generated
+    SGroup<Symmetry<0, 1>, Symmetry<2, 3>, Symmetry<4, 5>, Symmetry<6, 7>, Symmetry<8, 9>> group;
+
+    std::set<uint64_t> found;
+    std::map<uint64_t, int> expected;
+    expected[123456789] = 0;
+    expected[123456798] = 0;
+    expected[123457689] = 0;
+    expected[123457698] = 0;
+    expected[123546789] = 0;
+    expected[123546798] = 0;
+    expected[123547689] = 0;
+    expected[123547698] = 0;
+    expected[132456789] = 0;
+    expected[132456798] = 0;
+    expected[132457689] = 0;
+    expected[132457698] = 0;
+    expected[132546789] = 0;
+    expected[132546798] = 0;
+    expected[132547689] = 0;
+    expected[132547698] = 0;
+    expected[1023456789] = 0;
+    expected[1023456798] = 0;
+    expected[1023457689] = 0;
+    expected[1023457698] = 0;
+    expected[1023546789] = 0;
+    expected[1023546798] = 0;
+    expected[1023547689] = 0;
+    expected[1023547698] = 0;
+    expected[1032456789] = 0;
+    expected[1032456798] = 0;
+    expected[1032457689] = 0;
+    expected[1032457698] = 0;
+    expected[1032546789] = 0;
+    expected[1032546798] = 0;
+    expected[1032547689] = 0;
+    expected[1032547698] = 0;
+
+    VERIFY(isDynGroup(group));
+    VERIFY_IS_EQUAL(group.size(), 32u);
+    VERIFY_IS_EQUAL(group.globalFlags(), 0);
+    group.apply<checkIdx, int>(identity10, 0, found, expected);
+    VERIFY_IS_EQUAL(found.size(), 32u);
+
+    // no verify that we could also generate a static group
+    // with these generators
+    found.clear();
+    StaticSGroup<Symmetry<0, 1>, Symmetry<2, 3>, Symmetry<4, 5>, Symmetry<6, 7>, Symmetry<8, 9>> group_static;
+    VERIFY_IS_EQUAL(group_static.size(), 32u);
+    VERIFY_IS_EQUAL(group_static.globalFlags(), 0);
+    group_static.apply<checkIdx, int>(identity10, 0, found, expected);
+    VERIFY_IS_EQUAL(found.size(), 32u);
+  }
+
+  {
+    // try to create a HUGE group
+    SGroup<Symmetry<0, 1>, Symmetry<1, 2>, Symmetry<2, 3>, Symmetry<3, 4>, Symmetry<4, 5>, Symmetry<5, 6>> group;
+
+    std::set<uint64_t> found;
+    uint64_t pre_expected[5040] = {
+        123456,  1023456, 213456,  2013456, 1203456, 2103456, 132456,  1032456, 312456,  3012456, 1302456, 3102456,
+        231456,  2031456, 321456,  3021456, 2301456, 3201456, 1230456, 2130456, 1320456, 3120456, 2310456, 3210456,
+        124356,  1024356, 214356,  2014356, 1204356, 2104356, 142356,  1042356, 412356,  4012356, 1402356, 4102356,
+        241356,  2041356, 421356,  4021356, 2401356, 4201356, 1240356, 2140356, 1420356, 4120356, 2410356, 4210356,
+        134256,  1034256, 314256,  3014256, 1304256, 3104256, 143256,  1043256, 413256,  4013256, 1403256, 4103256,
+        341256,  3041256, 431256,  4031256, 3401256, 4301256, 1340256, 3140256, 1430256, 4130256, 3410256, 4310256,
+        234156,  2034156, 324156,  3024156, 2304156, 3204156, 243156,  2043156, 423156,  4023156, 2403156, 4203156,
+        342156,  3042156, 432156,  4032156, 3402156, 4302156, 2340156, 3240156, 2430156, 4230156, 3420156, 4320156,
+        1234056, 2134056, 1324056, 3124056, 2314056, 3214056, 1243056, 2143056, 1423056, 4123056, 2413056, 4213056,
+        1342056, 3142056, 1432056, 4132056, 3412056, 4312056, 2341056, 3241056, 2431056, 4231056, 3421056, 4321056,
+        123546,  1023546, 213546,  2013546, 1203546, 2103546, 132546,  1032546, 312546,  3012546, 1302546, 3102546,
+        231546,  2031546, 321546,  3021546, 2301546, 3201546, 1230546, 2130546, 1320546, 3120546, 2310546, 3210546,
+        125346,  1025346, 215346,  2015346, 1205346, 2105346, 152346,  1052346, 512346,  5012346, 1502346, 5102346,
+        251346,  2051346, 521346,  5021346, 2501346, 5201346, 1250346, 2150346, 1520346, 5120346, 2510346, 5210346,
+        135246,  1035246, 315246,  3015246, 1305246, 3105246, 153246,  1053246, 513246,  5013246, 1503246, 5103246,
+        351246,  3051246, 531246,  5031246, 3501246, 5301246, 1350246, 3150246, 1530246, 5130246, 3510246, 5310246,
+        235146,  2035146, 325146,  3025146, 2305146, 3205146, 253146,  2053146, 523146,  5023146, 2503146, 5203146,
+        352146,  3052146, 532146,  5032146, 3502146, 5302146, 2350146, 3250146, 2530146, 5230146, 3520146, 5320146,
+        1235046, 2135046, 1325046, 3125046, 2315046, 3215046, 1253046, 2153046, 1523046, 5123046, 2513046, 5213046,
+        1352046, 3152046, 1532046, 5132046, 3512046, 5312046, 2351046, 3251046, 2531046, 5231046, 3521046, 5321046,
+        124536,  1024536, 214536,  2014536, 1204536, 2104536, 142536,  1042536, 412536,  4012536, 1402536, 4102536,
+        241536,  2041536, 421536,  4021536, 2401536, 4201536, 1240536, 2140536, 1420536, 4120536, 2410536, 4210536,
+        125436,  1025436, 215436,  2015436, 1205436, 2105436, 152436,  1052436, 512436,  5012436, 1502436, 5102436,
+        251436,  2051436, 521436,  5021436, 2501436, 5201436, 1250436, 2150436, 1520436, 5120436, 2510436, 5210436,
+        145236,  1045236, 415236,  4015236, 1405236, 4105236, 154236,  1054236, 514236,  5014236, 1504236, 5104236,
+        451236,  4051236, 541236,  5041236, 4501236, 5401236, 1450236, 4150236, 1540236, 5140236, 4510236, 5410236,
+        245136,  2045136, 425136,  4025136, 2405136, 4205136, 254136,  2054136, 524136,  5024136, 2504136, 5204136,
+        452136,  4052136, 542136,  5042136, 4502136, 5402136, 2450136, 4250136, 2540136, 5240136, 4520136, 5420136,
+        1245036, 2145036, 1425036, 4125036, 2415036, 4215036, 1254036, 2154036, 1524036, 5124036, 2514036, 5214036,
+        1452036, 4152036, 1542036, 5142036, 4512036, 5412036, 2451036, 4251036, 2541036, 5241036, 4521036, 5421036,
+        134526,  1034526, 314526,  3014526, 1304526, 3104526, 143526,  1043526, 413526,  4013526, 1403526, 4103526,
+        341526,  3041526, 431526,  4031526, 3401526, 4301526, 1340526, 3140526, 1430526, 4130526, 3410526, 4310526,
+        135426,  1035426, 315426,  3015426, 1305426, 3105426, 153426,  1053426, 513426,  5013426, 1503426, 5103426,
+        351426,  3051426, 531426,  5031426, 3501426, 5301426, 1350426, 3150426, 1530426, 5130426, 3510426, 5310426,
+        145326,  1045326, 415326,  4015326, 1405326, 4105326, 154326,  1054326, 514326,  5014326, 1504326, 5104326,
+        451326,  4051326, 541326,  5041326, 4501326, 5401326, 1450326, 4150326, 1540326, 5140326, 4510326, 5410326,
+        345126,  3045126, 435126,  4035126, 3405126, 4305126, 354126,  3054126, 534126,  5034126, 3504126, 5304126,
+        453126,  4053126, 543126,  5043126, 4503126, 5403126, 3450126, 4350126, 3540126, 5340126, 4530126, 5430126,
+        1345026, 3145026, 1435026, 4135026, 3415026, 4315026, 1354026, 3154026, 1534026, 5134026, 3514026, 5314026,
+        1453026, 4153026, 1543026, 5143026, 4513026, 5413026, 3451026, 4351026, 3541026, 5341026, 4531026, 5431026,
+        234516,  2034516, 324516,  3024516, 2304516, 3204516, 243516,  2043516, 423516,  4023516, 2403516, 4203516,
+        342516,  3042516, 432516,  4032516, 3402516, 4302516, 2340516, 3240516, 2430516, 4230516, 3420516, 4320516,
+        235416,  2035416, 325416,  3025416, 2305416, 3205416, 253416,  2053416, 523416,  5023416, 2503416, 5203416,
+        352416,  3052416, 532416,  5032416, 3502416, 5302416, 2350416, 3250416, 2530416, 5230416, 3520416, 5320416,
+        245316,  2045316, 425316,  4025316, 2405316, 4205316, 254316,  2054316, 524316,  5024316, 2504316, 5204316,
+        452316,  4052316, 542316,  5042316, 4502316, 5402316, 2450316, 4250316, 2540316, 5240316, 4520316, 5420316,
+        345216,  3045216, 435216,  4035216, 3405216, 4305216, 354216,  3054216, 534216,  5034216, 3504216, 5304216,
+        453216,  4053216, 543216,  5043216, 4503216, 5403216, 3450216, 4350216, 3540216, 5340216, 4530216, 5430216,
+        2345016, 3245016, 2435016, 4235016, 3425016, 4325016, 2354016, 3254016, 2534016, 5234016, 3524016, 5324016,
+        2453016, 4253016, 2543016, 5243016, 4523016, 5423016, 3452016, 4352016, 3542016, 5342016, 4532016, 5432016,
+        1234506, 2134506, 1324506, 3124506, 2314506, 3214506, 1243506, 2143506, 1423506, 4123506, 2413506, 4213506,
+        1342506, 3142506, 1432506, 4132506, 3412506, 4312506, 2341506, 3241506, 2431506, 4231506, 3421506, 4321506,
+        1235406, 2135406, 1325406, 3125406, 2315406, 3215406, 1253406, 2153406, 1523406, 5123406, 2513406, 5213406,
+        1352406, 3152406, 1532406, 5132406, 3512406, 5312406, 2351406, 3251406, 2531406, 5231406, 3521406, 5321406,
+        1245306, 2145306, 1425306, 4125306, 2415306, 4215306, 1254306, 2154306, 1524306, 5124306, 2514306, 5214306,
+        1452306, 4152306, 1542306, 5142306, 4512306, 5412306, 2451306, 4251306, 2541306, 5241306, 4521306, 5421306,
+        1345206, 3145206, 1435206, 4135206, 3415206, 4315206, 1354206, 3154206, 1534206, 5134206, 3514206, 5314206,
+        1453206, 4153206, 1543206, 5143206, 4513206, 5413206, 3451206, 4351206, 3541206, 5341206, 4531206, 5431206,
+        2345106, 3245106, 2435106, 4235106, 3425106, 4325106, 2354106, 3254106, 2534106, 5234106, 3524106, 5324106,
+        2453106, 4253106, 2543106, 5243106, 4523106, 5423106, 3452106, 4352106, 3542106, 5342106, 4532106, 5432106,
+        123465,  1023465, 213465,  2013465, 1203465, 2103465, 132465,  1032465, 312465,  3012465, 1302465, 3102465,
+        231465,  2031465, 321465,  3021465, 2301465, 3201465, 1230465, 2130465, 1320465, 3120465, 2310465, 3210465,
+        124365,  1024365, 214365,  2014365, 1204365, 2104365, 142365,  1042365, 412365,  4012365, 1402365, 4102365,
+        241365,  2041365, 421365,  4021365, 2401365, 4201365, 1240365, 2140365, 1420365, 4120365, 2410365, 4210365,
+        134265,  1034265, 314265,  3014265, 1304265, 3104265, 143265,  1043265, 413265,  4013265, 1403265, 4103265,
+        341265,  3041265, 431265,  4031265, 3401265, 4301265, 1340265, 3140265, 1430265, 4130265, 3410265, 4310265,
+        234165,  2034165, 324165,  3024165, 2304165, 3204165, 243165,  2043165, 423165,  4023165, 2403165, 4203165,
+        342165,  3042165, 432165,  4032165, 3402165, 4302165, 2340165, 3240165, 2430165, 4230165, 3420165, 4320165,
+        1234065, 2134065, 1324065, 3124065, 2314065, 3214065, 1243065, 2143065, 1423065, 4123065, 2413065, 4213065,
+        1342065, 3142065, 1432065, 4132065, 3412065, 4312065, 2341065, 3241065, 2431065, 4231065, 3421065, 4321065,
+        123645,  1023645, 213645,  2013645, 1203645, 2103645, 132645,  1032645, 312645,  3012645, 1302645, 3102645,
+        231645,  2031645, 321645,  3021645, 2301645, 3201645, 1230645, 2130645, 1320645, 3120645, 2310645, 3210645,
+        126345,  1026345, 216345,  2016345, 1206345, 2106345, 162345,  1062345, 612345,  6012345, 1602345, 6102345,
+        261345,  2061345, 621345,  6021345, 2601345, 6201345, 1260345, 2160345, 1620345, 6120345, 2610345, 6210345,
+        136245,  1036245, 316245,  3016245, 1306245, 3106245, 163245,  1063245, 613245,  6013245, 1603245, 6103245,
+        361245,  3061245, 631245,  6031245, 3601245, 6301245, 1360245, 3160245, 1630245, 6130245, 3610245, 6310245,
+        236145,  2036145, 326145,  3026145, 2306145, 3206145, 263145,  2063145, 623145,  6023145, 2603145, 6203145,
+        362145,  3062145, 632145,  6032145, 3602145, 6302145, 2360145, 3260145, 2630145, 6230145, 3620145, 6320145,
+        1236045, 2136045, 1326045, 3126045, 2316045, 3216045, 1263045, 2163045, 1623045, 6123045, 2613045, 6213045,
+        1362045, 3162045, 1632045, 6132045, 3612045, 6312045, 2361045, 3261045, 2631045, 6231045, 3621045, 6321045,
+        124635,  1024635, 214635,  2014635, 1204635, 2104635, 142635,  1042635, 412635,  4012635, 1402635, 4102635,
+        241635,  2041635, 421635,  4021635, 2401635, 4201635, 1240635, 2140635, 1420635, 4120635, 2410635, 4210635,
+        126435,  1026435, 216435,  2016435, 1206435, 2106435, 162435,  1062435, 612435,  6012435, 1602435, 6102435,
+        261435,  2061435, 621435,  6021435, 2601435, 6201435, 1260435, 2160435, 1620435, 6120435, 2610435, 6210435,
+        146235,  1046235, 416235,  4016235, 1406235, 4106235, 164235,  1064235, 614235,  6014235, 1604235, 6104235,
+        461235,  4061235, 641235,  6041235, 4601235, 6401235, 1460235, 4160235, 1640235, 6140235, 4610235, 6410235,
+        246135,  2046135, 426135,  4026135, 2406135, 4206135, 264135,  2064135, 624135,  6024135, 2604135, 6204135,
+        462135,  4062135, 642135,  6042135, 4602135, 6402135, 2460135, 4260135, 2640135, 6240135, 4620135, 6420135,
+        1246035, 2146035, 1426035, 4126035, 2416035, 4216035, 1264035, 2164035, 1624035, 6124035, 2614035, 6214035,
+        1462035, 4162035, 1642035, 6142035, 4612035, 6412035, 2461035, 4261035, 2641035, 6241035, 4621035, 6421035,
+        134625,  1034625, 314625,  3014625, 1304625, 3104625, 143625,  1043625, 413625,  4013625, 1403625, 4103625,
+        341625,  3041625, 431625,  4031625, 3401625, 4301625, 1340625, 3140625, 1430625, 4130625, 3410625, 4310625,
+        136425,  1036425, 316425,  3016425, 1306425, 3106425, 163425,  1063425, 613425,  6013425, 1603425, 6103425,
+        361425,  3061425, 631425,  6031425, 3601425, 6301425, 1360425, 3160425, 1630425, 6130425, 3610425, 6310425,
+        146325,  1046325, 416325,  4016325, 1406325, 4106325, 164325,  1064325, 614325,  6014325, 1604325, 6104325,
+        461325,  4061325, 641325,  6041325, 4601325, 6401325, 1460325, 4160325, 1640325, 6140325, 4610325, 6410325,
+        346125,  3046125, 436125,  4036125, 3406125, 4306125, 364125,  3064125, 634125,  6034125, 3604125, 6304125,
+        463125,  4063125, 643125,  6043125, 4603125, 6403125, 3460125, 4360125, 3640125, 6340125, 4630125, 6430125,
+        1346025, 3146025, 1436025, 4136025, 3416025, 4316025, 1364025, 3164025, 1634025, 6134025, 3614025, 6314025,
+        1463025, 4163025, 1643025, 6143025, 4613025, 6413025, 3461025, 4361025, 3641025, 6341025, 4631025, 6431025,
+        234615,  2034615, 324615,  3024615, 2304615, 3204615, 243615,  2043615, 423615,  4023615, 2403615, 4203615,
+        342615,  3042615, 432615,  4032615, 3402615, 4302615, 2340615, 3240615, 2430615, 4230615, 3420615, 4320615,
+        236415,  2036415, 326415,  3026415, 2306415, 3206415, 263415,  2063415, 623415,  6023415, 2603415, 6203415,
+        362415,  3062415, 632415,  6032415, 3602415, 6302415, 2360415, 3260415, 2630415, 6230415, 3620415, 6320415,
+        246315,  2046315, 426315,  4026315, 2406315, 4206315, 264315,  2064315, 624315,  6024315, 2604315, 6204315,
+        462315,  4062315, 642315,  6042315, 4602315, 6402315, 2460315, 4260315, 2640315, 6240315, 4620315, 6420315,
+        346215,  3046215, 436215,  4036215, 3406215, 4306215, 364215,  3064215, 634215,  6034215, 3604215, 6304215,
+        463215,  4063215, 643215,  6043215, 4603215, 6403215, 3460215, 4360215, 3640215, 6340215, 4630215, 6430215,
+        2346015, 3246015, 2436015, 4236015, 3426015, 4326015, 2364015, 3264015, 2634015, 6234015, 3624015, 6324015,
+        2463015, 4263015, 2643015, 6243015, 4623015, 6423015, 3462015, 4362015, 3642015, 6342015, 4632015, 6432015,
+        1234605, 2134605, 1324605, 3124605, 2314605, 3214605, 1243605, 2143605, 1423605, 4123605, 2413605, 4213605,
+        1342605, 3142605, 1432605, 4132605, 3412605, 4312605, 2341605, 3241605, 2431605, 4231605, 3421605, 4321605,
+        1236405, 2136405, 1326405, 3126405, 2316405, 3216405, 1263405, 2163405, 1623405, 6123405, 2613405, 6213405,
+        1362405, 3162405, 1632405, 6132405, 3612405, 6312405, 2361405, 3261405, 2631405, 6231405, 3621405, 6321405,
+        1246305, 2146305, 1426305, 4126305, 2416305, 4216305, 1264305, 2164305, 1624305, 6124305, 2614305, 6214305,
+        1462305, 4162305, 1642305, 6142305, 4612305, 6412305, 2461305, 4261305, 2641305, 6241305, 4621305, 6421305,
+        1346205, 3146205, 1436205, 4136205, 3416205, 4316205, 1364205, 3164205, 1634205, 6134205, 3614205, 6314205,
+        1463205, 4163205, 1643205, 6143205, 4613205, 6413205, 3461205, 4361205, 3641205, 6341205, 4631205, 6431205,
+        2346105, 3246105, 2436105, 4236105, 3426105, 4326105, 2364105, 3264105, 2634105, 6234105, 3624105, 6324105,
+        2463105, 4263105, 2643105, 6243105, 4623105, 6423105, 3462105, 4362105, 3642105, 6342105, 4632105, 6432105,
+        123564,  1023564, 213564,  2013564, 1203564, 2103564, 132564,  1032564, 312564,  3012564, 1302564, 3102564,
+        231564,  2031564, 321564,  3021564, 2301564, 3201564, 1230564, 2130564, 1320564, 3120564, 2310564, 3210564,
+        125364,  1025364, 215364,  2015364, 1205364, 2105364, 152364,  1052364, 512364,  5012364, 1502364, 5102364,
+        251364,  2051364, 521364,  5021364, 2501364, 5201364, 1250364, 2150364, 1520364, 5120364, 2510364, 5210364,
+        135264,  1035264, 315264,  3015264, 1305264, 3105264, 153264,  1053264, 513264,  5013264, 1503264, 5103264,
+        351264,  3051264, 531264,  5031264, 3501264, 5301264, 1350264, 3150264, 1530264, 5130264, 3510264, 5310264,
+        235164,  2035164, 325164,  3025164, 2305164, 3205164, 253164,  2053164, 523164,  5023164, 2503164, 5203164,
+        352164,  3052164, 532164,  5032164, 3502164, 5302164, 2350164, 3250164, 2530164, 5230164, 3520164, 5320164,
+        1235064, 2135064, 1325064, 3125064, 2315064, 3215064, 1253064, 2153064, 1523064, 5123064, 2513064, 5213064,
+        1352064, 3152064, 1532064, 5132064, 3512064, 5312064, 2351064, 3251064, 2531064, 5231064, 3521064, 5321064,
+        123654,  1023654, 213654,  2013654, 1203654, 2103654, 132654,  1032654, 312654,  3012654, 1302654, 3102654,
+        231654,  2031654, 321654,  3021654, 2301654, 3201654, 1230654, 2130654, 1320654, 3120654, 2310654, 3210654,
+        126354,  1026354, 216354,  2016354, 1206354, 2106354, 162354,  1062354, 612354,  6012354, 1602354, 6102354,
+        261354,  2061354, 621354,  6021354, 2601354, 6201354, 1260354, 2160354, 1620354, 6120354, 2610354, 6210354,
+        136254,  1036254, 316254,  3016254, 1306254, 3106254, 163254,  1063254, 613254,  6013254, 1603254, 6103254,
+        361254,  3061254, 631254,  6031254, 3601254, 6301254, 1360254, 3160254, 1630254, 6130254, 3610254, 6310254,
+        236154,  2036154, 326154,  3026154, 2306154, 3206154, 263154,  2063154, 623154,  6023154, 2603154, 6203154,
+        362154,  3062154, 632154,  6032154, 3602154, 6302154, 2360154, 3260154, 2630154, 6230154, 3620154, 6320154,
+        1236054, 2136054, 1326054, 3126054, 2316054, 3216054, 1263054, 2163054, 1623054, 6123054, 2613054, 6213054,
+        1362054, 3162054, 1632054, 6132054, 3612054, 6312054, 2361054, 3261054, 2631054, 6231054, 3621054, 6321054,
+        125634,  1025634, 215634,  2015634, 1205634, 2105634, 152634,  1052634, 512634,  5012634, 1502634, 5102634,
+        251634,  2051634, 521634,  5021634, 2501634, 5201634, 1250634, 2150634, 1520634, 5120634, 2510634, 5210634,
+        126534,  1026534, 216534,  2016534, 1206534, 2106534, 162534,  1062534, 612534,  6012534, 1602534, 6102534,
+        261534,  2061534, 621534,  6021534, 2601534, 6201534, 1260534, 2160534, 1620534, 6120534, 2610534, 6210534,
+        156234,  1056234, 516234,  5016234, 1506234, 5106234, 165234,  1065234, 615234,  6015234, 1605234, 6105234,
+        561234,  5061234, 651234,  6051234, 5601234, 6501234, 1560234, 5160234, 1650234, 6150234, 5610234, 6510234,
+        256134,  2056134, 526134,  5026134, 2506134, 5206134, 265134,  2065134, 625134,  6025134, 2605134, 6205134,
+        562134,  5062134, 652134,  6052134, 5602134, 6502134, 2560134, 5260134, 2650134, 6250134, 5620134, 6520134,
+        1256034, 2156034, 1526034, 5126034, 2516034, 5216034, 1265034, 2165034, 1625034, 6125034, 2615034, 6215034,
+        1562034, 5162034, 1652034, 6152034, 5612034, 6512034, 2561034, 5261034, 2651034, 6251034, 5621034, 6521034,
+        135624,  1035624, 315624,  3015624, 1305624, 3105624, 153624,  1053624, 513624,  5013624, 1503624, 5103624,
+        351624,  3051624, 531624,  5031624, 3501624, 5301624, 1350624, 3150624, 1530624, 5130624, 3510624, 5310624,
+        136524,  1036524, 316524,  3016524, 1306524, 3106524, 163524,  1063524, 613524,  6013524, 1603524, 6103524,
+        361524,  3061524, 631524,  6031524, 3601524, 6301524, 1360524, 3160524, 1630524, 6130524, 3610524, 6310524,
+        156324,  1056324, 516324,  5016324, 1506324, 5106324, 165324,  1065324, 615324,  6015324, 1605324, 6105324,
+        561324,  5061324, 651324,  6051324, 5601324, 6501324, 1560324, 5160324, 1650324, 6150324, 5610324, 6510324,
+        356124,  3056124, 536124,  5036124, 3506124, 5306124, 365124,  3065124, 635124,  6035124, 3605124, 6305124,
+        563124,  5063124, 653124,  6053124, 5603124, 6503124, 3560124, 5360124, 3650124, 6350124, 5630124, 6530124,
+        1356024, 3156024, 1536024, 5136024, 3516024, 5316024, 1365024, 3165024, 1635024, 6135024, 3615024, 6315024,
+        1563024, 5163024, 1653024, 6153024, 5613024, 6513024, 3561024, 5361024, 3651024, 6351024, 5631024, 6531024,
+        235614,  2035614, 325614,  3025614, 2305614, 3205614, 253614,  2053614, 523614,  5023614, 2503614, 5203614,
+        352614,  3052614, 532614,  5032614, 3502614, 5302614, 2350614, 3250614, 2530614, 5230614, 3520614, 5320614,
+        236514,  2036514, 326514,  3026514, 2306514, 3206514, 263514,  2063514, 623514,  6023514, 2603514, 6203514,
+        362514,  3062514, 632514,  6032514, 3602514, 6302514, 2360514, 3260514, 2630514, 6230514, 3620514, 6320514,
+        256314,  2056314, 526314,  5026314, 2506314, 5206314, 265314,  2065314, 625314,  6025314, 2605314, 6205314,
+        562314,  5062314, 652314,  6052314, 5602314, 6502314, 2560314, 5260314, 2650314, 6250314, 5620314, 6520314,
+        356214,  3056214, 536214,  5036214, 3506214, 5306214, 365214,  3065214, 635214,  6035214, 3605214, 6305214,
+        563214,  5063214, 653214,  6053214, 5603214, 6503214, 3560214, 5360214, 3650214, 6350214, 5630214, 6530214,
+        2356014, 3256014, 2536014, 5236014, 3526014, 5326014, 2365014, 3265014, 2635014, 6235014, 3625014, 6325014,
+        2563014, 5263014, 2653014, 6253014, 5623014, 6523014, 3562014, 5362014, 3652014, 6352014, 5632014, 6532014,
+        1235604, 2135604, 1325604, 3125604, 2315604, 3215604, 1253604, 2153604, 1523604, 5123604, 2513604, 5213604,
+        1352604, 3152604, 1532604, 5132604, 3512604, 5312604, 2351604, 3251604, 2531604, 5231604, 3521604, 5321604,
+        1236504, 2136504, 1326504, 3126504, 2316504, 3216504, 1263504, 2163504, 1623504, 6123504, 2613504, 6213504,
+        1362504, 3162504, 1632504, 6132504, 3612504, 6312504, 2361504, 3261504, 2631504, 6231504, 3621504, 6321504,
+        1256304, 2156304, 1526304, 5126304, 2516304, 5216304, 1265304, 2165304, 1625304, 6125304, 2615304, 6215304,
+        1562304, 5162304, 1652304, 6152304, 5612304, 6512304, 2561304, 5261304, 2651304, 6251304, 5621304, 6521304,
+        1356204, 3156204, 1536204, 5136204, 3516204, 5316204, 1365204, 3165204, 1635204, 6135204, 3615204, 6315204,
+        1563204, 5163204, 1653204, 6153204, 5613204, 6513204, 3561204, 5361204, 3651204, 6351204, 5631204, 6531204,
+        2356104, 3256104, 2536104, 5236104, 3526104, 5326104, 2365104, 3265104, 2635104, 6235104, 3625104, 6325104,
+        2563104, 5263104, 2653104, 6253104, 5623104, 6523104, 3562104, 5362104, 3652104, 6352104, 5632104, 6532104,
+        124563,  1024563, 214563,  2014563, 1204563, 2104563, 142563,  1042563, 412563,  4012563, 1402563, 4102563,
+        241563,  2041563, 421563,  4021563, 2401563, 4201563, 1240563, 2140563, 1420563, 4120563, 2410563, 4210563,
+        125463,  1025463, 215463,  2015463, 1205463, 2105463, 152463,  1052463, 512463,  5012463, 1502463, 5102463,
+        251463,  2051463, 521463,  5021463, 2501463, 5201463, 1250463, 2150463, 1520463, 5120463, 2510463, 5210463,
+        145263,  1045263, 415263,  4015263, 1405263, 4105263, 154263,  1054263, 514263,  5014263, 1504263, 5104263,
+        451263,  4051263, 541263,  5041263, 4501263, 5401263, 1450263, 4150263, 1540263, 5140263, 4510263, 5410263,
+        245163,  2045163, 425163,  4025163, 2405163, 4205163, 254163,  2054163, 524163,  5024163, 2504163, 5204163,
+        452163,  4052163, 542163,  5042163, 4502163, 5402163, 2450163, 4250163, 2540163, 5240163, 4520163, 5420163,
+        1245063, 2145063, 1425063, 4125063, 2415063, 4215063, 1254063, 2154063, 1524063, 5124063, 2514063, 5214063,
+        1452063, 4152063, 1542063, 5142063, 4512063, 5412063, 2451063, 4251063, 2541063, 5241063, 4521063, 5421063,
+        124653,  1024653, 214653,  2014653, 1204653, 2104653, 142653,  1042653, 412653,  4012653, 1402653, 4102653,
+        241653,  2041653, 421653,  4021653, 2401653, 4201653, 1240653, 2140653, 1420653, 4120653, 2410653, 4210653,
+        126453,  1026453, 216453,  2016453, 1206453, 2106453, 162453,  1062453, 612453,  6012453, 1602453, 6102453,
+        261453,  2061453, 621453,  6021453, 2601453, 6201453, 1260453, 2160453, 1620453, 6120453, 2610453, 6210453,
+        146253,  1046253, 416253,  4016253, 1406253, 4106253, 164253,  1064253, 614253,  6014253, 1604253, 6104253,
+        461253,  4061253, 641253,  6041253, 4601253, 6401253, 1460253, 4160253, 1640253, 6140253, 4610253, 6410253,
+        246153,  2046153, 426153,  4026153, 2406153, 4206153, 264153,  2064153, 624153,  6024153, 2604153, 6204153,
+        462153,  4062153, 642153,  6042153, 4602153, 6402153, 2460153, 4260153, 2640153, 6240153, 4620153, 6420153,
+        1246053, 2146053, 1426053, 4126053, 2416053, 4216053, 1264053, 2164053, 1624053, 6124053, 2614053, 6214053,
+        1462053, 4162053, 1642053, 6142053, 4612053, 6412053, 2461053, 4261053, 2641053, 6241053, 4621053, 6421053,
+        125643,  1025643, 215643,  2015643, 1205643, 2105643, 152643,  1052643, 512643,  5012643, 1502643, 5102643,
+        251643,  2051643, 521643,  5021643, 2501643, 5201643, 1250643, 2150643, 1520643, 5120643, 2510643, 5210643,
+        126543,  1026543, 216543,  2016543, 1206543, 2106543, 162543,  1062543, 612543,  6012543, 1602543, 6102543,
+        261543,  2061543, 621543,  6021543, 2601543, 6201543, 1260543, 2160543, 1620543, 6120543, 2610543, 6210543,
+        156243,  1056243, 516243,  5016243, 1506243, 5106243, 165243,  1065243, 615243,  6015243, 1605243, 6105243,
+        561243,  5061243, 651243,  6051243, 5601243, 6501243, 1560243, 5160243, 1650243, 6150243, 5610243, 6510243,
+        256143,  2056143, 526143,  5026143, 2506143, 5206143, 265143,  2065143, 625143,  6025143, 2605143, 6205143,
+        562143,  5062143, 652143,  6052143, 5602143, 6502143, 2560143, 5260143, 2650143, 6250143, 5620143, 6520143,
+        1256043, 2156043, 1526043, 5126043, 2516043, 5216043, 1265043, 2165043, 1625043, 6125043, 2615043, 6215043,
+        1562043, 5162043, 1652043, 6152043, 5612043, 6512043, 2561043, 5261043, 2651043, 6251043, 5621043, 6521043,
+        145623,  1045623, 415623,  4015623, 1405623, 4105623, 154623,  1054623, 514623,  5014623, 1504623, 5104623,
+        451623,  4051623, 541623,  5041623, 4501623, 5401623, 1450623, 4150623, 1540623, 5140623, 4510623, 5410623,
+        146523,  1046523, 416523,  4016523, 1406523, 4106523, 164523,  1064523, 614523,  6014523, 1604523, 6104523,
+        461523,  4061523, 641523,  6041523, 4601523, 6401523, 1460523, 4160523, 1640523, 6140523, 4610523, 6410523,
+        156423,  1056423, 516423,  5016423, 1506423, 5106423, 165423,  1065423, 615423,  6015423, 1605423, 6105423,
+        561423,  5061423, 651423,  6051423, 5601423, 6501423, 1560423, 5160423, 1650423, 6150423, 5610423, 6510423,
+        456123,  4056123, 546123,  5046123, 4506123, 5406123, 465123,  4065123, 645123,  6045123, 4605123, 6405123,
+        564123,  5064123, 654123,  6054123, 5604123, 6504123, 4560123, 5460123, 4650123, 6450123, 5640123, 6540123,
+        1456023, 4156023, 1546023, 5146023, 4516023, 5416023, 1465023, 4165023, 1645023, 6145023, 4615023, 6415023,
+        1564023, 5164023, 1654023, 6154023, 5614023, 6514023, 4561023, 5461023, 4651023, 6451023, 5641023, 6541023,
+        245613,  2045613, 425613,  4025613, 2405613, 4205613, 254613,  2054613, 524613,  5024613, 2504613, 5204613,
+        452613,  4052613, 542613,  5042613, 4502613, 5402613, 2450613, 4250613, 2540613, 5240613, 4520613, 5420613,
+        246513,  2046513, 426513,  4026513, 2406513, 4206513, 264513,  2064513, 624513,  6024513, 2604513, 6204513,
+        462513,  4062513, 642513,  6042513, 4602513, 6402513, 2460513, 4260513, 2640513, 6240513, 4620513, 6420513,
+        256413,  2056413, 526413,  5026413, 2506413, 5206413, 265413,  2065413, 625413,  6025413, 2605413, 6205413,
+        562413,  5062413, 652413,  6052413, 5602413, 6502413, 2560413, 5260413, 2650413, 6250413, 5620413, 6520413,
+        456213,  4056213, 546213,  5046213, 4506213, 5406213, 465213,  4065213, 645213,  6045213, 4605213, 6405213,
+        564213,  5064213, 654213,  6054213, 5604213, 6504213, 4560213, 5460213, 4650213, 6450213, 5640213, 6540213,
+        2456013, 4256013, 2546013, 5246013, 4526013, 5426013, 2465013, 4265013, 2645013, 6245013, 4625013, 6425013,
+        2564013, 5264013, 2654013, 6254013, 5624013, 6524013, 4562013, 5462013, 4652013, 6452013, 5642013, 6542013,
+        1245603, 2145603, 1425603, 4125603, 2415603, 4215603, 1254603, 2154603, 1524603, 5124603, 2514603, 5214603,
+        1452603, 4152603, 1542603, 5142603, 4512603, 5412603, 2451603, 4251603, 2541603, 5241603, 4521603, 5421603,
+        1246503, 2146503, 1426503, 4126503, 2416503, 4216503, 1264503, 2164503, 1624503, 6124503, 2614503, 6214503,
+        1462503, 4162503, 1642503, 6142503, 4612503, 6412503, 2461503, 4261503, 2641503, 6241503, 4621503, 6421503,
+        1256403, 2156403, 1526403, 5126403, 2516403, 5216403, 1265403, 2165403, 1625403, 6125403, 2615403, 6215403,
+        1562403, 5162403, 1652403, 6152403, 5612403, 6512403, 2561403, 5261403, 2651403, 6251403, 5621403, 6521403,
+        1456203, 4156203, 1546203, 5146203, 4516203, 5416203, 1465203, 4165203, 1645203, 6145203, 4615203, 6415203,
+        1564203, 5164203, 1654203, 6154203, 5614203, 6514203, 4561203, 5461203, 4651203, 6451203, 5641203, 6541203,
+        2456103, 4256103, 2546103, 5246103, 4526103, 5426103, 2465103, 4265103, 2645103, 6245103, 4625103, 6425103,
+        2564103, 5264103, 2654103, 6254103, 5624103, 6524103, 4562103, 5462103, 4652103, 6452103, 5642103, 6542103,
+        134562,  1034562, 314562,  3014562, 1304562, 3104562, 143562,  1043562, 413562,  4013562, 1403562, 4103562,
+        341562,  3041562, 431562,  4031562, 3401562, 4301562, 1340562, 3140562, 1430562, 4130562, 3410562, 4310562,
+        135462,  1035462, 315462,  3015462, 1305462, 3105462, 153462,  1053462, 513462,  5013462, 1503462, 5103462,
+        351462,  3051462, 531462,  5031462, 3501462, 5301462, 1350462, 3150462, 1530462, 5130462, 3510462, 5310462,
+        145362,  1045362, 415362,  4015362, 1405362, 4105362, 154362,  1054362, 514362,  5014362, 1504362, 5104362,
+        451362,  4051362, 541362,  5041362, 4501362, 5401362, 1450362, 4150362, 1540362, 5140362, 4510362, 5410362,
+        345162,  3045162, 435162,  4035162, 3405162, 4305162, 354162,  3054162, 534162,  5034162, 3504162, 5304162,
+        453162,  4053162, 543162,  5043162, 4503162, 5403162, 3450162, 4350162, 3540162, 5340162, 4530162, 5430162,
+        1345062, 3145062, 1435062, 4135062, 3415062, 4315062, 1354062, 3154062, 1534062, 5134062, 3514062, 5314062,
+        1453062, 4153062, 1543062, 5143062, 4513062, 5413062, 3451062, 4351062, 3541062, 5341062, 4531062, 5431062,
+        134652,  1034652, 314652,  3014652, 1304652, 3104652, 143652,  1043652, 413652,  4013652, 1403652, 4103652,
+        341652,  3041652, 431652,  4031652, 3401652, 4301652, 1340652, 3140652, 1430652, 4130652, 3410652, 4310652,
+        136452,  1036452, 316452,  3016452, 1306452, 3106452, 163452,  1063452, 613452,  6013452, 1603452, 6103452,
+        361452,  3061452, 631452,  6031452, 3601452, 6301452, 1360452, 3160452, 1630452, 6130452, 3610452, 6310452,
+        146352,  1046352, 416352,  4016352, 1406352, 4106352, 164352,  1064352, 614352,  6014352, 1604352, 6104352,
+        461352,  4061352, 641352,  6041352, 4601352, 6401352, 1460352, 4160352, 1640352, 6140352, 4610352, 6410352,
+        346152,  3046152, 436152,  4036152, 3406152, 4306152, 364152,  3064152, 634152,  6034152, 3604152, 6304152,
+        463152,  4063152, 643152,  6043152, 4603152, 6403152, 3460152, 4360152, 3640152, 6340152, 4630152, 6430152,
+        1346052, 3146052, 1436052, 4136052, 3416052, 4316052, 1364052, 3164052, 1634052, 6134052, 3614052, 6314052,
+        1463052, 4163052, 1643052, 6143052, 4613052, 6413052, 3461052, 4361052, 3641052, 6341052, 4631052, 6431052,
+        135642,  1035642, 315642,  3015642, 1305642, 3105642, 153642,  1053642, 513642,  5013642, 1503642, 5103642,
+        351642,  3051642, 531642,  5031642, 3501642, 5301642, 1350642, 3150642, 1530642, 5130642, 3510642, 5310642,
+        136542,  1036542, 316542,  3016542, 1306542, 3106542, 163542,  1063542, 613542,  6013542, 1603542, 6103542,
+        361542,  3061542, 631542,  6031542, 3601542, 6301542, 1360542, 3160542, 1630542, 6130542, 3610542, 6310542,
+        156342,  1056342, 516342,  5016342, 1506342, 5106342, 165342,  1065342, 615342,  6015342, 1605342, 6105342,
+        561342,  5061342, 651342,  6051342, 5601342, 6501342, 1560342, 5160342, 1650342, 6150342, 5610342, 6510342,
+        356142,  3056142, 536142,  5036142, 3506142, 5306142, 365142,  3065142, 635142,  6035142, 3605142, 6305142,
+        563142,  5063142, 653142,  6053142, 5603142, 6503142, 3560142, 5360142, 3650142, 6350142, 5630142, 6530142,
+        1356042, 3156042, 1536042, 5136042, 3516042, 5316042, 1365042, 3165042, 1635042, 6135042, 3615042, 6315042,
+        1563042, 5163042, 1653042, 6153042, 5613042, 6513042, 3561042, 5361042, 3651042, 6351042, 5631042, 6531042,
+        145632,  1045632, 415632,  4015632, 1405632, 4105632, 154632,  1054632, 514632,  5014632, 1504632, 5104632,
+        451632,  4051632, 541632,  5041632, 4501632, 5401632, 1450632, 4150632, 1540632, 5140632, 4510632, 5410632,
+        146532,  1046532, 416532,  4016532, 1406532, 4106532, 164532,  1064532, 614532,  6014532, 1604532, 6104532,
+        461532,  4061532, 641532,  6041532, 4601532, 6401532, 1460532, 4160532, 1640532, 6140532, 4610532, 6410532,
+        156432,  1056432, 516432,  5016432, 1506432, 5106432, 165432,  1065432, 615432,  6015432, 1605432, 6105432,
+        561432,  5061432, 651432,  6051432, 5601432, 6501432, 1560432, 5160432, 1650432, 6150432, 5610432, 6510432,
+        456132,  4056132, 546132,  5046132, 4506132, 5406132, 465132,  4065132, 645132,  6045132, 4605132, 6405132,
+        564132,  5064132, 654132,  6054132, 5604132, 6504132, 4560132, 5460132, 4650132, 6450132, 5640132, 6540132,
+        1456032, 4156032, 1546032, 5146032, 4516032, 5416032, 1465032, 4165032, 1645032, 6145032, 4615032, 6415032,
+        1564032, 5164032, 1654032, 6154032, 5614032, 6514032, 4561032, 5461032, 4651032, 6451032, 5641032, 6541032,
+        345612,  3045612, 435612,  4035612, 3405612, 4305612, 354612,  3054612, 534612,  5034612, 3504612, 5304612,
+        453612,  4053612, 543612,  5043612, 4503612, 5403612, 3450612, 4350612, 3540612, 5340612, 4530612, 5430612,
+        346512,  3046512, 436512,  4036512, 3406512, 4306512, 364512,  3064512, 634512,  6034512, 3604512, 6304512,
+        463512,  4063512, 643512,  6043512, 4603512, 6403512, 3460512, 4360512, 3640512, 6340512, 4630512, 6430512,
+        356412,  3056412, 536412,  5036412, 3506412, 5306412, 365412,  3065412, 635412,  6035412, 3605412, 6305412,
+        563412,  5063412, 653412,  6053412, 5603412, 6503412, 3560412, 5360412, 3650412, 6350412, 5630412, 6530412,
+        456312,  4056312, 546312,  5046312, 4506312, 5406312, 465312,  4065312, 645312,  6045312, 4605312, 6405312,
+        564312,  5064312, 654312,  6054312, 5604312, 6504312, 4560312, 5460312, 4650312, 6450312, 5640312, 6540312,
+        3456012, 4356012, 3546012, 5346012, 4536012, 5436012, 3465012, 4365012, 3645012, 6345012, 4635012, 6435012,
+        3564012, 5364012, 3654012, 6354012, 5634012, 6534012, 4563012, 5463012, 4653012, 6453012, 5643012, 6543012,
+        1345602, 3145602, 1435602, 4135602, 3415602, 4315602, 1354602, 3154602, 1534602, 5134602, 3514602, 5314602,
+        1453602, 4153602, 1543602, 5143602, 4513602, 5413602, 3451602, 4351602, 3541602, 5341602, 4531602, 5431602,
+        1346502, 3146502, 1436502, 4136502, 3416502, 4316502, 1364502, 3164502, 1634502, 6134502, 3614502, 6314502,
+        1463502, 4163502, 1643502, 6143502, 4613502, 6413502, 3461502, 4361502, 3641502, 6341502, 4631502, 6431502,
+        1356402, 3156402, 1536402, 5136402, 3516402, 5316402, 1365402, 3165402, 1635402, 6135402, 3615402, 6315402,
+        1563402, 5163402, 1653402, 6153402, 5613402, 6513402, 3561402, 5361402, 3651402, 6351402, 5631402, 6531402,
+        1456302, 4156302, 1546302, 5146302, 4516302, 5416302, 1465302, 4165302, 1645302, 6145302, 4615302, 6415302,
+        1564302, 5164302, 1654302, 6154302, 5614302, 6514302, 4561302, 5461302, 4651302, 6451302, 5641302, 6541302,
+        3456102, 4356102, 3546102, 5346102, 4536102, 5436102, 3465102, 4365102, 3645102, 6345102, 4635102, 6435102,
+        3564102, 5364102, 3654102, 6354102, 5634102, 6534102, 4563102, 5463102, 4653102, 6453102, 5643102, 6543102,
+        234561,  2034561, 324561,  3024561, 2304561, 3204561, 243561,  2043561, 423561,  4023561, 2403561, 4203561,
+        342561,  3042561, 432561,  4032561, 3402561, 4302561, 2340561, 3240561, 2430561, 4230561, 3420561, 4320561,
+        235461,  2035461, 325461,  3025461, 2305461, 3205461, 253461,  2053461, 523461,  5023461, 2503461, 5203461,
+        352461,  3052461, 532461,  5032461, 3502461, 5302461, 2350461, 3250461, 2530461, 5230461, 3520461, 5320461,
+        245361,  2045361, 425361,  4025361, 2405361, 4205361, 254361,  2054361, 524361,  5024361, 2504361, 5204361,
+        452361,  4052361, 542361,  5042361, 4502361, 5402361, 2450361, 4250361, 2540361, 5240361, 4520361, 5420361,
+        345261,  3045261, 435261,  4035261, 3405261, 4305261, 354261,  3054261, 534261,  5034261, 3504261, 5304261,
+        453261,  4053261, 543261,  5043261, 4503261, 5403261, 3450261, 4350261, 3540261, 5340261, 4530261, 5430261,
+        2345061, 3245061, 2435061, 4235061, 3425061, 4325061, 2354061, 3254061, 2534061, 5234061, 3524061, 5324061,
+        2453061, 4253061, 2543061, 5243061, 4523061, 5423061, 3452061, 4352061, 3542061, 5342061, 4532061, 5432061,
+        234651,  2034651, 324651,  3024651, 2304651, 3204651, 243651,  2043651, 423651,  4023651, 2403651, 4203651,
+        342651,  3042651, 432651,  4032651, 3402651, 4302651, 2340651, 3240651, 2430651, 4230651, 3420651, 4320651,
+        236451,  2036451, 326451,  3026451, 2306451, 3206451, 263451,  2063451, 623451,  6023451, 2603451, 6203451,
+        362451,  3062451, 632451,  6032451, 3602451, 6302451, 2360451, 3260451, 2630451, 6230451, 3620451, 6320451,
+        246351,  2046351, 426351,  4026351, 2406351, 4206351, 264351,  2064351, 624351,  6024351, 2604351, 6204351,
+        462351,  4062351, 642351,  6042351, 4602351, 6402351, 2460351, 4260351, 2640351, 6240351, 4620351, 6420351,
+        346251,  3046251, 436251,  4036251, 3406251, 4306251, 364251,  3064251, 634251,  6034251, 3604251, 6304251,
+        463251,  4063251, 643251,  6043251, 4603251, 6403251, 3460251, 4360251, 3640251, 6340251, 4630251, 6430251,
+        2346051, 3246051, 2436051, 4236051, 3426051, 4326051, 2364051, 3264051, 2634051, 6234051, 3624051, 6324051,
+        2463051, 4263051, 2643051, 6243051, 4623051, 6423051, 3462051, 4362051, 3642051, 6342051, 4632051, 6432051,
+        235641,  2035641, 325641,  3025641, 2305641, 3205641, 253641,  2053641, 523641,  5023641, 2503641, 5203641,
+        352641,  3052641, 532641,  5032641, 3502641, 5302641, 2350641, 3250641, 2530641, 5230641, 3520641, 5320641,
+        236541,  2036541, 326541,  3026541, 2306541, 3206541, 263541,  2063541, 623541,  6023541, 2603541, 6203541,
+        362541,  3062541, 632541,  6032541, 3602541, 6302541, 2360541, 3260541, 2630541, 6230541, 3620541, 6320541,
+        256341,  2056341, 526341,  5026341, 2506341, 5206341, 265341,  2065341, 625341,  6025341, 2605341, 6205341,
+        562341,  5062341, 652341,  6052341, 5602341, 6502341, 2560341, 5260341, 2650341, 6250341, 5620341, 6520341,
+        356241,  3056241, 536241,  5036241, 3506241, 5306241, 365241,  3065241, 635241,  6035241, 3605241, 6305241,
+        563241,  5063241, 653241,  6053241, 5603241, 6503241, 3560241, 5360241, 3650241, 6350241, 5630241, 6530241,
+        2356041, 3256041, 2536041, 5236041, 3526041, 5326041, 2365041, 3265041, 2635041, 6235041, 3625041, 6325041,
+        2563041, 5263041, 2653041, 6253041, 5623041, 6523041, 3562041, 5362041, 3652041, 6352041, 5632041, 6532041,
+        245631,  2045631, 425631,  4025631, 2405631, 4205631, 254631,  2054631, 524631,  5024631, 2504631, 5204631,
+        452631,  4052631, 542631,  5042631, 4502631, 5402631, 2450631, 4250631, 2540631, 5240631, 4520631, 5420631,
+        246531,  2046531, 426531,  4026531, 2406531, 4206531, 264531,  2064531, 624531,  6024531, 2604531, 6204531,
+        462531,  4062531, 642531,  6042531, 4602531, 6402531, 2460531, 4260531, 2640531, 6240531, 4620531, 6420531,
+        256431,  2056431, 526431,  5026431, 2506431, 5206431, 265431,  2065431, 625431,  6025431, 2605431, 6205431,
+        562431,  5062431, 652431,  6052431, 5602431, 6502431, 2560431, 5260431, 2650431, 6250431, 5620431, 6520431,
+        456231,  4056231, 546231,  5046231, 4506231, 5406231, 465231,  4065231, 645231,  6045231, 4605231, 6405231,
+        564231,  5064231, 654231,  6054231, 5604231, 6504231, 4560231, 5460231, 4650231, 6450231, 5640231, 6540231,
+        2456031, 4256031, 2546031, 5246031, 4526031, 5426031, 2465031, 4265031, 2645031, 6245031, 4625031, 6425031,
+        2564031, 5264031, 2654031, 6254031, 5624031, 6524031, 4562031, 5462031, 4652031, 6452031, 5642031, 6542031,
+        345621,  3045621, 435621,  4035621, 3405621, 4305621, 354621,  3054621, 534621,  5034621, 3504621, 5304621,
+        453621,  4053621, 543621,  5043621, 4503621, 5403621, 3450621, 4350621, 3540621, 5340621, 4530621, 5430621,
+        346521,  3046521, 436521,  4036521, 3406521, 4306521, 364521,  3064521, 634521,  6034521, 3604521, 6304521,
+        463521,  4063521, 643521,  6043521, 4603521, 6403521, 3460521, 4360521, 3640521, 6340521, 4630521, 6430521,
+        356421,  3056421, 536421,  5036421, 3506421, 5306421, 365421,  3065421, 635421,  6035421, 3605421, 6305421,
+        563421,  5063421, 653421,  6053421, 5603421, 6503421, 3560421, 5360421, 3650421, 6350421, 5630421, 6530421,
+        456321,  4056321, 546321,  5046321, 4506321, 5406321, 465321,  4065321, 645321,  6045321, 4605321, 6405321,
+        564321,  5064321, 654321,  6054321, 5604321, 6504321, 4560321, 5460321, 4650321, 6450321, 5640321, 6540321,
+        3456021, 4356021, 3546021, 5346021, 4536021, 5436021, 3465021, 4365021, 3645021, 6345021, 4635021, 6435021,
+        3564021, 5364021, 3654021, 6354021, 5634021, 6534021, 4563021, 5463021, 4653021, 6453021, 5643021, 6543021,
+        2345601, 3245601, 2435601, 4235601, 3425601, 4325601, 2354601, 3254601, 2534601, 5234601, 3524601, 5324601,
+        2453601, 4253601, 2543601, 5243601, 4523601, 5423601, 3452601, 4352601, 3542601, 5342601, 4532601, 5432601,
+        2346501, 3246501, 2436501, 4236501, 3426501, 4326501, 2364501, 3264501, 2634501, 6234501, 3624501, 6324501,
+        2463501, 4263501, 2643501, 6243501, 4623501, 6423501, 3462501, 4362501, 3642501, 6342501, 4632501, 6432501,
+        2356401, 3256401, 2536401, 5236401, 3526401, 5326401, 2365401, 3265401, 2635401, 6235401, 3625401, 6325401,
+        2563401, 5263401, 2653401, 6253401, 5623401, 6523401, 3562401, 5362401, 3652401, 6352401, 5632401, 6532401,
+        2456301, 4256301, 2546301, 5246301, 4526301, 5426301, 2465301, 4265301, 2645301, 6245301, 4625301, 6425301,
+        2564301, 5264301, 2654301, 6254301, 5624301, 6524301, 4562301, 5462301, 4652301, 6452301, 5642301, 6542301,
+        3456201, 4356201, 3546201, 5346201, 4536201, 5436201, 3465201, 4365201, 3645201, 6345201, 4635201, 6435201,
+        3564201, 5364201, 3654201, 6354201, 5634201, 6534201, 4563201, 5463201, 4653201, 6453201, 5643201, 6543201,
+        1234560, 2134560, 1324560, 3124560, 2314560, 3214560, 1243560, 2143560, 1423560, 4123560, 2413560, 4213560,
+        1342560, 3142560, 1432560, 4132560, 3412560, 4312560, 2341560, 3241560, 2431560, 4231560, 3421560, 4321560,
+        1235460, 2135460, 1325460, 3125460, 2315460, 3215460, 1253460, 2153460, 1523460, 5123460, 2513460, 5213460,
+        1352460, 3152460, 1532460, 5132460, 3512460, 5312460, 2351460, 3251460, 2531460, 5231460, 3521460, 5321460,
+        1245360, 2145360, 1425360, 4125360, 2415360, 4215360, 1254360, 2154360, 1524360, 5124360, 2514360, 5214360,
+        1452360, 4152360, 1542360, 5142360, 4512360, 5412360, 2451360, 4251360, 2541360, 5241360, 4521360, 5421360,
+        1345260, 3145260, 1435260, 4135260, 3415260, 4315260, 1354260, 3154260, 1534260, 5134260, 3514260, 5314260,
+        1453260, 4153260, 1543260, 5143260, 4513260, 5413260, 3451260, 4351260, 3541260, 5341260, 4531260, 5431260,
+        2345160, 3245160, 2435160, 4235160, 3425160, 4325160, 2354160, 3254160, 2534160, 5234160, 3524160, 5324160,
+        2453160, 4253160, 2543160, 5243160, 4523160, 5423160, 3452160, 4352160, 3542160, 5342160, 4532160, 5432160,
+        1234650, 2134650, 1324650, 3124650, 2314650, 3214650, 1243650, 2143650, 1423650, 4123650, 2413650, 4213650,
+        1342650, 3142650, 1432650, 4132650, 3412650, 4312650, 2341650, 3241650, 2431650, 4231650, 3421650, 4321650,
+        1236450, 2136450, 1326450, 3126450, 2316450, 3216450, 1263450, 2163450, 1623450, 6123450, 2613450, 6213450,
+        1362450, 3162450, 1632450, 6132450, 3612450, 6312450, 2361450, 3261450, 2631450, 6231450, 3621450, 6321450,
+        1246350, 2146350, 1426350, 4126350, 2416350, 4216350, 1264350, 2164350, 1624350, 6124350, 2614350, 6214350,
+        1462350, 4162350, 1642350, 6142350, 4612350, 6412350, 2461350, 4261350, 2641350, 6241350, 4621350, 6421350,
+        1346250, 3146250, 1436250, 4136250, 3416250, 4316250, 1364250, 3164250, 1634250, 6134250, 3614250, 6314250,
+        1463250, 4163250, 1643250, 6143250, 4613250, 6413250, 3461250, 4361250, 3641250, 6341250, 4631250, 6431250,
+        2346150, 3246150, 2436150, 4236150, 3426150, 4326150, 2364150, 3264150, 2634150, 6234150, 3624150, 6324150,
+        2463150, 4263150, 2643150, 6243150, 4623150, 6423150, 3462150, 4362150, 3642150, 6342150, 4632150, 6432150,
+        1235640, 2135640, 1325640, 3125640, 2315640, 3215640, 1253640, 2153640, 1523640, 5123640, 2513640, 5213640,
+        1352640, 3152640, 1532640, 5132640, 3512640, 5312640, 2351640, 3251640, 2531640, 5231640, 3521640, 5321640,
+        1236540, 2136540, 1326540, 3126540, 2316540, 3216540, 1263540, 2163540, 1623540, 6123540, 2613540, 6213540,
+        1362540, 3162540, 1632540, 6132540, 3612540, 6312540, 2361540, 3261540, 2631540, 6231540, 3621540, 6321540,
+        1256340, 2156340, 1526340, 5126340, 2516340, 5216340, 1265340, 2165340, 1625340, 6125340, 2615340, 6215340,
+        1562340, 5162340, 1652340, 6152340, 5612340, 6512340, 2561340, 5261340, 2651340, 6251340, 5621340, 6521340,
+        1356240, 3156240, 1536240, 5136240, 3516240, 5316240, 1365240, 3165240, 1635240, 6135240, 3615240, 6315240,
+        1563240, 5163240, 1653240, 6153240, 5613240, 6513240, 3561240, 5361240, 3651240, 6351240, 5631240, 6531240,
+        2356140, 3256140, 2536140, 5236140, 3526140, 5326140, 2365140, 3265140, 2635140, 6235140, 3625140, 6325140,
+        2563140, 5263140, 2653140, 6253140, 5623140, 6523140, 3562140, 5362140, 3652140, 6352140, 5632140, 6532140,
+        1245630, 2145630, 1425630, 4125630, 2415630, 4215630, 1254630, 2154630, 1524630, 5124630, 2514630, 5214630,
+        1452630, 4152630, 1542630, 5142630, 4512630, 5412630, 2451630, 4251630, 2541630, 5241630, 4521630, 5421630,
+        1246530, 2146530, 1426530, 4126530, 2416530, 4216530, 1264530, 2164530, 1624530, 6124530, 2614530, 6214530,
+        1462530, 4162530, 1642530, 6142530, 4612530, 6412530, 2461530, 4261530, 2641530, 6241530, 4621530, 6421530,
+        1256430, 2156430, 1526430, 5126430, 2516430, 5216430, 1265430, 2165430, 1625430, 6125430, 2615430, 6215430,
+        1562430, 5162430, 1652430, 6152430, 5612430, 6512430, 2561430, 5261430, 2651430, 6251430, 5621430, 6521430,
+        1456230, 4156230, 1546230, 5146230, 4516230, 5416230, 1465230, 4165230, 1645230, 6145230, 4615230, 6415230,
+        1564230, 5164230, 1654230, 6154230, 5614230, 6514230, 4561230, 5461230, 4651230, 6451230, 5641230, 6541230,
+        2456130, 4256130, 2546130, 5246130, 4526130, 5426130, 2465130, 4265130, 2645130, 6245130, 4625130, 6425130,
+        2564130, 5264130, 2654130, 6254130, 5624130, 6524130, 4562130, 5462130, 4652130, 6452130, 5642130, 6542130,
+        1345620, 3145620, 1435620, 4135620, 3415620, 4315620, 1354620, 3154620, 1534620, 5134620, 3514620, 5314620,
+        1453620, 4153620, 1543620, 5143620, 4513620, 5413620, 3451620, 4351620, 3541620, 5341620, 4531620, 5431620,
+        1346520, 3146520, 1436520, 4136520, 3416520, 4316520, 1364520, 3164520, 1634520, 6134520, 3614520, 6314520,
+        1463520, 4163520, 1643520, 6143520, 4613520, 6413520, 3461520, 4361520, 3641520, 6341520, 4631520, 6431520,
+        1356420, 3156420, 1536420, 5136420, 3516420, 5316420, 1365420, 3165420, 1635420, 6135420, 3615420, 6315420,
+        1563420, 5163420, 1653420, 6153420, 5613420, 6513420, 3561420, 5361420, 3651420, 6351420, 5631420, 6531420,
+        1456320, 4156320, 1546320, 5146320, 4516320, 5416320, 1465320, 4165320, 1645320, 6145320, 4615320, 6415320,
+        1564320, 5164320, 1654320, 6154320, 5614320, 6514320, 4561320, 5461320, 4651320, 6451320, 5641320, 6541320,
+        3456120, 4356120, 3546120, 5346120, 4536120, 5436120, 3465120, 4365120, 3645120, 6345120, 4635120, 6435120,
+        3564120, 5364120, 3654120, 6354120, 5634120, 6534120, 4563120, 5463120, 4653120, 6453120, 5643120, 6543120,
+        2345610, 3245610, 2435610, 4235610, 3425610, 4325610, 2354610, 3254610, 2534610, 5234610, 3524610, 5324610,
+        2453610, 4253610, 2543610, 5243610, 4523610, 5423610, 3452610, 4352610, 3542610, 5342610, 4532610, 5432610,
+        2346510, 3246510, 2436510, 4236510, 3426510, 4326510, 2364510, 3264510, 2634510, 6234510, 3624510, 6324510,
+        2463510, 4263510, 2643510, 6243510, 4623510, 6423510, 3462510, 4362510, 3642510, 6342510, 4632510, 6432510,
+        2356410, 3256410, 2536410, 5236410, 3526410, 5326410, 2365410, 3265410, 2635410, 6235410, 3625410, 6325410,
+        2563410, 5263410, 2653410, 6253410, 5623410, 6523410, 3562410, 5362410, 3652410, 6352410, 5632410, 6532410,
+        2456310, 4256310, 2546310, 5246310, 4526310, 5426310, 2465310, 4265310, 2645310, 6245310, 4625310, 6425310,
+        2564310, 5264310, 2654310, 6254310, 5624310, 6524310, 4562310, 5462310, 4652310, 6452310, 5642310, 6542310,
+        3456210, 4356210, 3546210, 5346210, 4536210, 5436210, 3465210, 4365210, 3645210, 6345210, 4635210, 6435210,
+        3564210, 5364210, 3654210, 6354210, 5634210, 6534210, 4563210, 5463210, 4653210, 6453210, 5643210, 6543210};
+    std::map<uint64_t, int> expected;
+    for (std::size_t i = 0; i < 5040; i++) expected[pre_expected[i]] = 0;  // flags are 0, everything is symmetric here
+
+    VERIFY(isDynGroup(group));
+    VERIFY_IS_EQUAL(group.size(), 5040u);
+    VERIFY_IS_EQUAL(group.globalFlags(), 0);
+    group.apply<checkIdx, int>(identity7, 0, found, expected);
+    VERIFY_IS_EQUAL(found.size(), 5040u);
+  }
+}
+
+static void test_tensor_epsilon() {
+  SGroup<AntiSymmetry<0, 1>, AntiSymmetry<1, 2>> sym;
+  Tensor<int, 3> epsilon(3, 3, 3);
+
+  epsilon.setZero();
+  sym(epsilon, 0, 1, 2) = 1;
+
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      for (int k = 0; k < 3; k++) {
+        VERIFY_IS_EQUAL((epsilon(i, j, k)), (-(j - i) * (k - j) * (i - k) / 2));
+      }
+    }
+  }
+}
+
+static void test_tensor_sym() {
+  SGroup<Symmetry<0, 1>, Symmetry<2, 3>> sym;
+  Tensor<int, 4> t(10, 10, 10, 10);
+
+  t.setZero();
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = l; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = j; i < 10; i++) {
+          sym(t, i, j, k, l) = (i + j) * (k + l);
+        }
+      }
+    }
+  }
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = 0; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = 0; i < 10; i++) {
+          VERIFY_IS_EQUAL((t(i, j, k, l)), ((i + j) * (k + l)));
+        }
+      }
+    }
+  }
+}
+
+static void test_tensor_asym() {
+  SGroup<AntiSymmetry<0, 1>, AntiSymmetry<2, 3>> sym;
+  Tensor<int, 4> t(10, 10, 10, 10);
+
+  t.setZero();
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = l + 1; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = j + 1; i < 10; i++) {
+          sym(t, i, j, k, l) = ((i * j) + (k * l));
+        }
+      }
+    }
+  }
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = 0; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = 0; i < 10; i++) {
+          if (i < j && k < l)
+            VERIFY_IS_EQUAL((t(i, j, k, l)), (((i * j) + (k * l))));
+          else if (i > j && k > l)
+            VERIFY_IS_EQUAL((t(i, j, k, l)), (((i * j) + (k * l))));
+          else if (i < j && k > l)
+            VERIFY_IS_EQUAL((t(i, j, k, l)), (-((i * j) + (k * l))));
+          else if (i > j && k < l)
+            VERIFY_IS_EQUAL((t(i, j, k, l)), (-((i * j) + (k * l))));
+          else
+            VERIFY_IS_EQUAL((t(i, j, k, l)), 0);
+        }
+      }
+    }
+  }
+}
+
+static void test_tensor_dynsym() {
+  DynamicSGroup sym;
+  sym.addSymmetry(0, 1);
+  sym.addSymmetry(2, 3);
+  Tensor<int, 4> t(10, 10, 10, 10);
+
+  t.setZero();
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = l; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = j; i < 10; i++) {
+          sym(t, i, j, k, l) = (i + j) * (k + l);
+        }
+      }
+    }
+  }
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = 0; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = 0; i < 10; i++) {
+          VERIFY_IS_EQUAL((t(i, j, k, l)), ((i + j) * (k + l)));
+        }
+      }
+    }
+  }
+}
+
+static void test_tensor_randacc() {
+  SGroup<Symmetry<0, 1>, Symmetry<2, 3>> sym;
+  Tensor<int, 4> t(10, 10, 10, 10);
+
+  t.setZero();
+
+  // set elements 1 million times, that way we access the
+  // entire matrix
+  for (int n = 0; n < 1000000; n++) {
+    int i = rand() % 10;
+    int j = rand() % 10;
+    int k = rand() % 10;
+    int l = rand() % 10;
+    // only access those indices in a given order
+    if (i < j) std::swap(i, j);
+    if (k < l) std::swap(k, l);
+    sym(t, i, j, k, l) = (i + j) * (k + l);
+  }
+
+  for (int l = 0; l < 10; l++) {
+    for (int k = 0; k < 10; k++) {
+      for (int j = 0; j < 10; j++) {
+        for (int i = 0; i < 10; i++) {
+          VERIFY_IS_EQUAL((t(i, j, k, l)), ((i + j) * (k + l)));
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_symmetry) {
+  CALL_SUBTEST(test_symgroups_dynamic());
+  CALL_SUBTEST(test_symgroups_selection());
+  CALL_SUBTEST(test_tensor_epsilon());
+  CALL_SUBTEST(test_tensor_sym());
+  CALL_SUBTEST(test_tensor_asym());
+  CALL_SUBTEST(test_tensor_dynsym());
+  CALL_SUBTEST(test_tensor_randacc());
+}
+
+/*
+ * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
+ */
diff --git a/contrib/test/tensor_thread_local.cpp b/contrib/test/tensor_thread_local.cpp
new file mode 100644
index 0000000..a62874c
--- /dev/null
+++ b/contrib/test/tensor_thread_local.cpp
@@ -0,0 +1,146 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include <iostream>
+#include <unordered_set>
+
+#include "main.h"
+#include <Eigen/ThreadPool>
+
+struct Counter {
+  Counter() = default;
+
+  void inc() {
+    // Check that mutation happens only in a thread that created this counter.
+    VERIFY_IS_EQUAL(std::this_thread::get_id(), created_by);
+    counter_value++;
+  }
+  int value() { return counter_value; }
+
+  std::thread::id created_by;
+  int counter_value = 0;
+};
+
+struct InitCounter {
+  void operator()(Counter& counter) { counter.created_by = std::this_thread::get_id(); }
+};
+
+void test_simple_thread_local() {
+  int num_threads = internal::random<int>(4, 32);
+  Eigen::ThreadPool thread_pool(num_threads);
+  Eigen::ThreadLocal<Counter, InitCounter> counter(num_threads, InitCounter());
+
+  int num_tasks = 3 * num_threads;
+  Eigen::Barrier barrier(num_tasks);
+
+  for (int i = 0; i < num_tasks; ++i) {
+    thread_pool.Schedule([&counter, &barrier]() {
+      Counter& local = counter.local();
+      local.inc();
+
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+      barrier.Notify();
+    });
+  }
+
+  barrier.Wait();
+
+  counter.ForEach([](std::thread::id, Counter& cnt) { VERIFY_IS_EQUAL(cnt.value(), 3); });
+}
+
+void test_zero_sized_thread_local() {
+  Eigen::ThreadLocal<Counter, InitCounter> counter(0, InitCounter());
+
+  Counter& local = counter.local();
+  local.inc();
+
+  int total = 0;
+  counter.ForEach([&total](std::thread::id, Counter& cnt) {
+    total += cnt.value();
+    VERIFY_IS_EQUAL(cnt.value(), 1);
+  });
+
+  VERIFY_IS_EQUAL(total, 1);
+}
+
+// All thread local values fits into the lock-free storage.
+void test_large_number_of_tasks_no_spill() {
+  int num_threads = internal::random<int>(4, 32);
+  Eigen::ThreadPool thread_pool(num_threads);
+  Eigen::ThreadLocal<Counter, InitCounter> counter(num_threads, InitCounter());
+
+  int num_tasks = 10000;
+  Eigen::Barrier barrier(num_tasks);
+
+  for (int i = 0; i < num_tasks; ++i) {
+    thread_pool.Schedule([&counter, &barrier]() {
+      Counter& local = counter.local();
+      local.inc();
+      barrier.Notify();
+    });
+  }
+
+  barrier.Wait();
+
+  int total = 0;
+  std::unordered_set<std::thread::id> unique_threads;
+
+  counter.ForEach([&](std::thread::id id, Counter& cnt) {
+    total += cnt.value();
+    unique_threads.insert(id);
+  });
+
+  VERIFY_IS_EQUAL(total, num_tasks);
+  // Not all threads in a pool might be woken up to execute submitted tasks.
+  // Also thread_pool.Schedule() might use current thread if queue is full.
+  VERIFY_IS_EQUAL(unique_threads.size() <= (static_cast<size_t>(num_threads + 1)), true);
+}
+
+// Lock free thread local storage is too small to fit all the unique threads,
+// and it spills to a map guarded by a mutex.
+void test_large_number_of_tasks_with_spill() {
+  int num_threads = internal::random<int>(4, 32);
+  Eigen::ThreadPool thread_pool(num_threads);
+  Eigen::ThreadLocal<Counter, InitCounter> counter(1, InitCounter());
+
+  int num_tasks = 10000;
+  Eigen::Barrier barrier(num_tasks);
+
+  for (int i = 0; i < num_tasks; ++i) {
+    thread_pool.Schedule([&counter, &barrier]() {
+      Counter& local = counter.local();
+      local.inc();
+      barrier.Notify();
+    });
+  }
+
+  barrier.Wait();
+
+  int total = 0;
+  std::unordered_set<std::thread::id> unique_threads;
+
+  counter.ForEach([&](std::thread::id id, Counter& cnt) {
+    total += cnt.value();
+    unique_threads.insert(id);
+  });
+
+  VERIFY_IS_EQUAL(total, num_tasks);
+  // Not all threads in a pool might be woken up to execute submitted tasks.
+  // Also thread_pool.Schedule() might use current thread if queue is full.
+  VERIFY_IS_EQUAL(unique_threads.size() <= (static_cast<size_t>(num_threads + 1)), true);
+}
+
+EIGEN_DECLARE_TEST(tensor_thread_local) {
+  CALL_SUBTEST(test_simple_thread_local());
+  CALL_SUBTEST(test_zero_sized_thread_local());
+  CALL_SUBTEST(test_large_number_of_tasks_no_spill());
+  CALL_SUBTEST(test_large_number_of_tasks_with_spill());
+}
diff --git a/contrib/test/tensor_thread_pool.cpp b/contrib/test/tensor_thread_pool.cpp
new file mode 100644
index 0000000..3f6863d
--- /dev/null
+++ b/contrib/test/tensor_thread_pool.cpp
@@ -0,0 +1,1205 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS
+
+#include "main.h"
+#include <atomic>
+#include <iostream>
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+class TestAllocator : public Allocator {
+ public:
+  ~TestAllocator() EIGEN_OVERRIDE {}
+  EIGEN_DEVICE_FUNC void* allocate(size_t num_bytes) const EIGEN_OVERRIDE {
+    const_cast<TestAllocator*>(this)->alloc_count_++;
+    return internal::aligned_malloc(num_bytes);
+  }
+  EIGEN_DEVICE_FUNC void deallocate(void* buffer) const EIGEN_OVERRIDE {
+    const_cast<TestAllocator*>(this)->dealloc_count_++;
+    internal::aligned_free(buffer);
+  }
+
+  int alloc_count() const { return alloc_count_; }
+  int dealloc_count() const { return dealloc_count_; }
+
+ private:
+  int alloc_count_ = 0;
+  int dealloc_count_ = 0;
+};
+
+void test_multithread_elementwise() {
+  Tensor<float, 3> in1(200, 30, 70);
+  Tensor<float, 3> in2(200, 30, 70);
+  Tensor<double, 3> out(200, 30, 70);
+
+  in1.setRandom();
+  in2.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+  out.device(thread_pool_device) = (in1 + in2 * 3.14f).cast<double>();
+
+  for (int i = 0; i < 200; ++i) {
+    for (int j = 0; j < 30; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), static_cast<double>(in1(i, j, k) + in2(i, j, k) * 3.14f));
+      }
+    }
+  }
+}
+
+void test_async_multithread_elementwise() {
+  Tensor<float, 3> in1(200, 30, 70);
+  Tensor<float, 3> in2(200, 30, 70);
+  Tensor<double, 3> out(200, 30, 70);
+
+  in1.setRandom();
+  in2.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+
+  Eigen::Barrier b(1);
+  out.device(thread_pool_device, [&b]() { b.Notify(); }) = (in1 + in2 * 3.14f).cast<double>();
+  b.Wait();
+
+  for (int i = 0; i < 200; ++i) {
+    for (int j = 0; j < 30; ++j) {
+      for (int k = 0; k < 70; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), static_cast<double>(in1(i, j, k) + in2(i, j, k) * 3.14f));
+      }
+    }
+  }
+}
+
+void test_multithread_chip() {
+  Tensor<float, 5> in(2, 3, 5, 7, 11);
+  Tensor<float, 4> out(3, 5, 7, 11);
+
+  in.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+
+  out.device(thread_pool_device) = in.chip(1, 0);
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(out(i, j, k, l), in(1, i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+void test_async_multithread_chip() {
+  Tensor<float, 5> in(2, 3, 5, 7, 11);
+  Tensor<float, 4> out(3, 5, 7, 11);
+
+  in.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+
+  Eigen::Barrier b(1);
+  out.device(thread_pool_device, [&b]() { b.Notify(); }) = in.chip(1, 0);
+  b.Wait();
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(out(i, j, k, l), in(1, i, j, k, l));
+        }
+      }
+    }
+  }
+}
+
+void test_multithread_volume_patch() {
+  Tensor<float, 5> in(4, 2, 3, 5, 7);
+  Tensor<float, 6> out(4, 1, 1, 1, 2 * 3 * 5, 7);
+
+  in.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+
+  out.device(thread_pool_device) = in.extract_volume_patches(1, 1, 1);
+
+  for (int i = 0; i < in.size(); ++i) {
+    VERIFY_IS_EQUAL(in.data()[i], out.data()[i]);
+  }
+}
+
+void test_async_multithread_volume_patch() {
+  Tensor<float, 5> in(4, 2, 3, 5, 7);
+  Tensor<float, 6> out(4, 1, 1, 1, 2 * 3 * 5, 7);
+
+  in.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+
+  Eigen::Barrier b(1);
+  out.device(thread_pool_device, [&b]() { b.Notify(); }) = in.extract_volume_patches(1, 1, 1);
+  b.Wait();
+
+  for (int i = 0; i < in.size(); ++i) {
+    VERIFY_IS_EQUAL(in.data()[i], out.data()[i]);
+  }
+}
+
+// Stateful-but-copyable unary functor: flags an overlap when two threads call
+// the same instance concurrently. The executors must copy the evaluator (and
+// with it the functor) into each task, so no instance is ever called
+// concurrently even though the expression is evaluated by multiple threads.
+struct OverlapDetectingOp {
+  explicit OverlapDetectingOp(std::atomic<int>* overlaps) : overlaps_(overlaps) {}
+  OverlapDetectingOp(const OverlapDetectingOp& other) : overlaps_(other.overlaps_) {}
+
+  float operator()(const float& x) const {
+    if (busy_.exchange(true)) overlaps_->fetch_add(1);
+    const float result = x + 1.0f;
+    busy_.store(false);
+    return result;
+  }
+
+  std::atomic<int>* overlaps_;
+  mutable std::atomic<bool> busy_{false};
+};
+
+// The driver expression uses reverse() because its block() has always read
+// the argument through coeff() with BlockAccess independent of the argument,
+// so these tests exercise the tiled executor's per-task evaluator copy
+// regardless of how any one evaluator's traits evolve.
+void test_multithread_tiled_stateful_functor() {
+  Tensor<float, 4> in(64, 64, 64, 8);
+  in.setRandom();
+
+  const array<bool, 4> rev = {{false, true, true, false}};
+  Tensor<float, 4> expected(64, 64, 64, 8);
+  expected = (in + 1.0f).reverse(rev);
+
+  std::atomic<int> overlaps(0);
+  Eigen::ThreadPool tp(4);
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, 4);
+
+  Tensor<float, 4> out(64, 64, 64, 8);
+  out.device(thread_pool_device) = in.unaryExpr(OverlapDetectingOp(&overlaps)).reverse(rev);
+
+  VERIFY_IS_EQUAL(overlaps.load(), 0);
+  for (int i = 0; i < out.size(); ++i) {
+    VERIFY_IS_EQUAL(out.data()[i], expected.data()[i]);
+  }
+}
+
+void test_async_multithread_tiled_stateful_functor() {
+  Tensor<float, 4> in(64, 64, 64, 8);
+  in.setRandom();
+
+  const array<bool, 4> rev = {{false, true, true, false}};
+  Tensor<float, 4> expected(64, 64, 64, 8);
+  expected = (in + 1.0f).reverse(rev);
+
+  std::atomic<int> overlaps(0);
+  Eigen::ThreadPool tp(4);
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, 4);
+
+  Tensor<float, 4> out(64, 64, 64, 8);
+  Eigen::Barrier b(1);
+  out.device(thread_pool_device, [&b]() { b.Notify(); }) = in.unaryExpr(OverlapDetectingOp(&overlaps)).reverse(rev);
+  b.Wait();
+
+  VERIFY_IS_EQUAL(overlaps.load(), 0);
+  for (int i = 0; i < out.size(); ++i) {
+    VERIFY_IS_EQUAL(out.data()[i], expected.data()[i]);
+  }
+}
+
+void test_multithread_compound_assignment() {
+  Tensor<float, 3> in1(2, 3, 7);
+  Tensor<float, 3> in2(2, 3, 7);
+  Tensor<float, 3> out(2, 3, 7);
+
+  in1.setRandom();
+  in2.setRandom();
+
+  Eigen::ThreadPool tp(internal::random<int>(3, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
+  out.device(thread_pool_device) = in1;
+  out.device(thread_pool_device) += in2 * 3.14f;
+
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f);
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+void test_multithread_contraction() {
+  Tensor<float, 4, DataLayout> t_left(30, 50, 37, 31);
+  Tensor<float, 5, DataLayout> t_right(37, 31, 70, 2, 10);
+  Tensor<float, 5, DataLayout> t_result(30, 50, 70, 2, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+
+  // this contraction should be equivalent to a single matrix multiplication
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 2> dims{{DimPair(2, 0), DimPair(3, 1)}};
+
+  typedef Map<Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 1500, 1147);
+  MapXf m_right(t_right.data(), 1147, 1400);
+  Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
+
+  Eigen::ThreadPool tp(4);
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, 4);
+
+  // compute results by separate methods
+  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
+  m_result = m_left * m_right;
+
+  // The tensor contraction and the matrix product sum the k=1147 terms in different orders; their results differ
+  // by a small multiple of eps, covered here as absolute slack before the relative check.
+  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
+    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
+    if (fabsf(t_result(i) - m_result(i)) < 128 * NumTraits<float>::epsilon()) {
+      continue;
+    }
+    if (Eigen::internal::isApprox(t_result(i), m_result(i), 128 * NumTraits<float>::epsilon())) {
+      continue;
+    }
+    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << m_result(i) << std::endl;
+    assert(false);
+  }
+}
+
+// Issue #1648: lock the threaded dispatch of gemv-shape contractions
+// (TensorContractionThreadPool forces num_threads = 1 for n == 1 and routes
+// through evalProductSequential, which now selects one of four direct GEMV
+// fast paths). Covers y = A^T * x where the LHS contracted dim is the
+// contiguous one — the path that motivated the fix.
+template <int DataLayout>
+void test_multithread_gemv_transpose() {
+  for (int M : {17, 64, 129}) {
+    for (int N : {16, 33, 100}) {
+      Tensor<float, 2, DataLayout> t_left(M, N);
+      Tensor<float, 1, DataLayout> t_right(M);
+      t_left.setRandom();
+      t_right.setRandom();
+
+      typedef Tensor<float, 1>::DimensionPair DimPair;
+      Eigen::array<DimPair, 1> dims{{DimPair(0, 0)}};
+
+      Eigen::ThreadPool tp(4);
+      Eigen::ThreadPoolDevice thread_pool_device(&tp, 4);
+      Tensor<float, 1, DataLayout> t_result(N);
+      t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
+
+      typedef Map<const Matrix<float, Dynamic, Dynamic, DataLayout>> MapMat;
+      typedef Map<const Matrix<float, Dynamic, 1>> MapVec;
+      MapMat m_left(t_left.data(), M, N);
+      MapVec m_right(t_right.data(), M);
+      Matrix<float, Dynamic, 1> m_result = m_left.transpose() * m_right;
+
+      for (int j = 0; j < N; ++j) {
+        VERIFY(internal::isApprox(t_result(j), m_result(j), 16 * NumTraits<float>::epsilon()));
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+void test_contraction_corner_cases() {
+  Tensor<float, 2, DataLayout> t_left(32, 500);
+  Tensor<float, 2, DataLayout> t_right(32, 28 * 28);
+  Tensor<float, 2, DataLayout> t_result(500, 28 * 28);
+
+  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
+  t_right = (t_right.constant(-0.6f) + t_right.random()) * 2.0f;
+  t_result = t_result.constant(NAN);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(0, 0)}};
+
+  typedef Map<Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 32, 500);
+  MapXf m_right(t_right.data(), 32, 28 * 28);
+  Matrix<float, Dynamic, Dynamic, DataLayout> m_result(500, 28 * 28);
+
+  Eigen::ThreadPool tp(12);
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, 12);
+
+  // compute results by separate methods
+  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
+  m_result = m_left.transpose() * m_right;
+
+  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
+    assert(!(numext::isnan)(t_result.data()[i]));
+    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 256 * NumTraits<float>::epsilon()) {
+      std::cout << "mismatch detected at index " << i << " : " << t_result.data()[i] << " vs " << m_result.data()[i]
+                << std::endl;
+      assert(false);
+    }
+  }
+
+  t_left.resize(32, 1);
+  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
+  t_result.resize(1, 28 * 28);
+  t_result = t_result.constant(NAN);
+  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
+  new (&m_left) MapXf(t_left.data(), 32, 1);
+  m_result = m_left.transpose() * m_right;
+  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
+    assert(!(numext::isnan)(t_result.data()[i]));
+    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 256 * NumTraits<float>::epsilon()) {
+      std::cout << "mismatch detected: " << t_result.data()[i] << " vs " << m_result.data()[i] << std::endl;
+      assert(false);
+    }
+  }
+
+  t_left.resize(32, 500);
+  t_right.resize(32, 4);
+  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
+  t_right = (t_right.constant(-0.6f) + t_right.random()) * 2.0f;
+  t_result.resize(500, 4);
+  t_result = t_result.constant(NAN);
+  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
+  new (&m_left) MapXf(t_left.data(), 32, 500);
+  new (&m_right) MapXf(t_right.data(), 32, 4);
+  m_result = m_left.transpose() * m_right;
+  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
+    assert(!(numext::isnan)(t_result.data()[i]));
+    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 256 * NumTraits<float>::epsilon()) {
+      std::cout << "mismatch detected: " << t_result.data()[i] << " vs " << m_result.data()[i] << std::endl;
+      assert(false);
+    }
+  }
+
+  t_left.resize(32, 1);
+  t_right.resize(32, 4);
+  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
+  t_right = (t_right.constant(-0.6f) + t_right.random()) * 2.0f;
+  t_result.resize(1, 4);
+  t_result = t_result.constant(NAN);
+  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
+  new (&m_left) MapXf(t_left.data(), 32, 1);
+  new (&m_right) MapXf(t_right.data(), 32, 4);
+  m_result = m_left.transpose() * m_right;
+  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
+    assert(!(numext::isnan)(t_result.data()[i]));
+    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 256 * NumTraits<float>::epsilon()) {
+      std::cout << "mismatch detected: " << t_result.data()[i] << " vs " << m_result.data()[i] << std::endl;
+      assert(false);
+    }
+  }
+}
+
+template <int DataLayout>
+void test_multithread_contraction_agrees_with_singlethread() {
+  int contract_size = internal::random<int>(1, 5000);
+
+  Tensor<float, 3, DataLayout> left(internal::random<int>(1, 80), contract_size, internal::random<int>(1, 100));
+
+  Tensor<float, 4, DataLayout> right(internal::random<int>(1, 25), internal::random<int>(1, 37), contract_size,
+                                     internal::random<int>(1, 51));
+
+  left.setRandom();
+  right.setRandom();
+
+  // add constants to shift values away from 0 for more precision
+  left += left.constant(1.5f);
+  right += right.constant(1.5f);
+
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 2)}};
+
+  Eigen::ThreadPool tp(internal::random<int>(2, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(2, 11));
+
+  Tensor<float, 5, DataLayout> st_result;
+  st_result = left.contract(right, dims);
+
+  Tensor<float, 5, DataLayout> tp_result(st_result.dimensions());
+  tp_result.device(thread_pool_device) = left.contract(right, dims);
+
+  VERIFY(dimensions_match(st_result.dimensions(), tp_result.dimensions()));
+  for (ptrdiff_t i = 0; i < st_result.size(); i++) {
+    // if both of the values are very small, then do nothing (because the test will fail
+    // due to numerical precision issues when values are small)
+    if (numext::abs(st_result.data()[i] - tp_result.data()[i]) >= 1024 * NumTraits<float>::epsilon()) {
+      VERIFY_IS_APPROX(st_result.data()[i], tp_result.data()[i]);
+    }
+  }
+}
+
+// Apply Sqrt to all output elements.
+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));
+      }
+    }
+  }
+};
+
+template <int DataLayout>
+static void test_multithread_contraction_with_output_kernel() {
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  Tensor<float, 4, DataLayout> t_left(30, 50, 8, 31);
+  Tensor<float, 5, DataLayout> t_right(8, 31, 7, 20, 10);
+  Tensor<float, 5, DataLayout> t_result(30, 50, 7, 20, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+  // Put trash in mat4 to verify contraction clears output memory.
+  t_result.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 1500, 248);
+  MapXf m_right(t_right.data(), 248, 1400);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 2> dims{{DimPair(2, 0), DimPair(3, 1)}};
+
+  // compute results by separate methods
+  t_result.device(device) = t_left.contract(t_right, dims, SqrtOutputKernel());
+
+  m_result = m_left * m_right;
+
+  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
+    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
+  }
+}
+
+template <int DataLayout>
+void test_async_multithread_contraction_agrees_with_singlethread() {
+  int contract_size = internal::random<int>(100, 500);
+
+  Tensor<float, 3, DataLayout> left(internal::random<int>(10, 40), contract_size, internal::random<int>(10, 40));
+
+  Tensor<float, 4, DataLayout> right(internal::random<int>(1, 20), internal::random<int>(1, 20), contract_size,
+                                     internal::random<int>(1, 20));
+
+  left.setRandom();
+  right.setRandom();
+
+  // add constants to shift values away from 0 for more precision
+  left += left.constant(1.5f);
+  right += right.constant(1.5f);
+
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 2)}};
+
+  Eigen::ThreadPool tp(internal::random<int>(2, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(8, 32));
+
+  Tensor<float, 5, DataLayout> st_result;
+  st_result = left.contract(right, dims);
+
+  Tensor<float, 5, DataLayout> tp_result(st_result.dimensions());
+
+  Eigen::Barrier barrier(1);
+  tp_result.device(thread_pool_device, [&barrier]() { barrier.Notify(); }) = left.contract(right, dims);
+  barrier.Wait();
+
+  VERIFY(dimensions_match(st_result.dimensions(), tp_result.dimensions()));
+  for (ptrdiff_t i = 0; i < st_result.size(); i++) {
+    // if both of the values are very small, then do nothing (because the test
+    // will fail due to numerical precision issues when values are small)
+    if (numext::abs(st_result.data()[i] - tp_result.data()[i]) >= 1024 * NumTraits<float>::epsilon()) {
+      VERIFY_IS_APPROX(st_result.data()[i], tp_result.data()[i]);
+    }
+  }
+}
+
+// We are triggering 'evalShardedByInnerDim' optimization.
+template <int DataLayout>
+static void test_sharded_by_inner_dim_contraction() {
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+
+  const int num_threads = internal::random<int>(4, 16);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  Tensor<float, 2, DataLayout> t_left(2, 10000);
+  Tensor<float, 2, DataLayout> t_right(10000, 10);
+  Tensor<float, 2, DataLayout> t_result(2, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+  // Put trash in t_result to verify contraction clears output memory.
+  t_result.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 2, 10000);
+  MapXf m_right(t_right.data(), 10000, 10);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // compute results by separate methods
+  t_result.device(device) = t_left.contract(t_right, dims);
+  m_result = m_left * m_right;
+
+  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
+  }
+}
+
+// We are triggering 'evalShardedByInnerDim' optimization with output kernel.
+template <int DataLayout>
+static void test_sharded_by_inner_dim_contraction_with_output_kernel() {
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+
+  const int num_threads = internal::random<int>(4, 16);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  Tensor<float, 2, DataLayout> t_left(2, 10000);
+  Tensor<float, 2, DataLayout> t_right(10000, 10);
+  Tensor<float, 2, DataLayout> t_result(2, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+  // Put trash in t_result to verify contraction clears output memory.
+  t_result.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 2, 10000);
+  MapXf m_right(t_right.data(), 10000, 10);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // compute results by separate methods
+  t_result.device(device) = t_left.contract(t_right, dims, SqrtOutputKernel());
+  m_result = m_left * m_right;
+
+  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
+  }
+}
+
+// We are triggering 'evalShardedByInnerDim' optimization.
+template <int DataLayout>
+static void test_async_sharded_by_inner_dim_contraction() {
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+
+  const int num_threads = internal::random<int>(4, 16);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  Tensor<float, 2, DataLayout> t_left(2, 10000);
+  Tensor<float, 2, DataLayout> t_right(10000, 10);
+  Tensor<float, 2, DataLayout> t_result(2, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+  // Put trash in t_result to verify contraction clears output memory.
+  t_result.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 2, 10000);
+  MapXf m_right(t_right.data(), 10000, 10);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // compute results by separate methods
+  Eigen::Barrier barrier(1);
+  t_result.device(device, [&barrier]() { barrier.Notify(); }) = t_left.contract(t_right, dims);
+  barrier.Wait();
+
+  m_result = m_left * m_right;
+
+  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
+  }
+}
+
+// We are triggering 'evalShardedByInnerDim' optimization with output kernel.
+template <int DataLayout>
+static void test_async_sharded_by_inner_dim_contraction_with_output_kernel() {
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+
+  const int num_threads = internal::random<int>(4, 16);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  Tensor<float, 2, DataLayout> t_left(2, 10000);
+  Tensor<float, 2, DataLayout> t_right(10000, 10);
+  Tensor<float, 2, DataLayout> t_result(2, 10);
+
+  t_left.setRandom();
+  t_right.setRandom();
+  // Put trash in t_result to verify contraction clears output memory.
+  t_result.setRandom();
+
+  // Add a little offset so that the results won't be close to zero.
+  t_left += t_left.constant(1.0f);
+  t_right += t_right.constant(1.0f);
+
+  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
+  MapXf m_left(t_left.data(), 2, 10000);
+  MapXf m_right(t_right.data(), 10000, 10);
+  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
+
+  // this contraction should be equivalent to a single matrix multiplication
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // compute results by separate methods
+  Eigen::Barrier barrier(1);
+  t_result.device(device, [&barrier]() { barrier.Notify(); }) = t_left.contract(t_right, dims, SqrtOutputKernel());
+  barrier.Wait();
+  m_result = m_left * m_right;
+
+  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
+    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
+  }
+}
+
+template <int DataLayout>
+void test_full_contraction() {
+  int contract_size1 = internal::random<int>(1, 500);
+  int contract_size2 = internal::random<int>(1, 500);
+
+  Tensor<float, 2, DataLayout> left(contract_size1, contract_size2);
+  Tensor<float, 2, DataLayout> right(contract_size1, contract_size2);
+  left.setRandom();
+  right.setRandom();
+
+  // add constants to shift values away from 0 for more precision
+  left += left.constant(1.5f);
+  right += right.constant(1.5f);
+
+  typedef Tensor<float, 2>::DimensionPair DimPair;
+  Eigen::array<DimPair, 2> dims{{DimPair(0, 0), DimPair(1, 1)}};
+
+  Eigen::ThreadPool tp(internal::random<int>(2, 11));
+  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(2, 11));
+
+  Tensor<float, 0, DataLayout> st_result;
+  st_result = left.contract(right, dims);
+
+  Tensor<float, 0, DataLayout> tp_result;
+  tp_result.device(thread_pool_device) = left.contract(right, dims);
+
+  VERIFY(dimensions_match(st_result.dimensions(), tp_result.dimensions()));
+  // if both of the values are very small, then do nothing (because the test will fail
+  // due to numerical precision issues when values are small)
+  if (numext::abs(st_result() - tp_result()) >= 1024 * NumTraits<float>::epsilon()) {
+    VERIFY_IS_APPROX(st_result(), tp_result());
+  }
+}
+
+template <int DataLayout>
+void test_multithreaded_reductions() {
+  const int num_threads = internal::random<int>(3, 11);
+  ThreadPool thread_pool(num_threads);
+  Eigen::ThreadPoolDevice thread_pool_device(&thread_pool, num_threads);
+
+  const int num_rows = internal::random<int>(13, 732);
+  const int num_cols = internal::random<int>(13, 732);
+  Tensor<float, 2, DataLayout> t1(num_rows, num_cols);
+  t1.setRandom();
+
+  Tensor<float, 0, DataLayout> full_redux;
+  full_redux = t1.sum();
+
+  Tensor<float, 0, DataLayout> full_redux_tp;
+  full_redux_tp.device(thread_pool_device) = t1.sum();
+
+  // Check that the single threaded and the multi threaded reductions return
+  // the same result.
+  VERIFY_IS_APPROX(full_redux(), full_redux_tp());
+}
+
+void test_multithreaded_complex_reduction() {
+  using Scalar = std::complex<float>;
+  constexpr Index size = 4096;
+
+  // Preserve the mapped source and fixed-size mapped destination from the issue #1647 backtrace: this exact
+  // instantiation triggers the old GCC compiler bug.
+  Tensor<Scalar, 1, RowMajor> storage(size);
+  storage.setConstant(Scalar(1.0f, 2.0f));
+  TensorMap<Tensor<Scalar, 1, RowMajor>> input(storage.data(), size);
+  EIGEN_ALIGN_MAX Scalar output_storage;
+  TensorMap<TensorFixedSize<Scalar, Sizes<>, RowMajor>, Aligned> output(&output_storage);
+
+  ThreadPool thread_pool(2);
+  ThreadPoolDevice thread_pool_device(&thread_pool, 2);
+  output.device(thread_pool_device) = input.sum();
+
+  VERIFY_IS_EQUAL(output(), Scalar(static_cast<float>(size), static_cast<float>(2 * size)));
+}
+
+void test_multithreaded_complex_partial_reductions() {
+  using Scalar = std::complex<float>;
+  constexpr Index outer_size = 32;
+  constexpr Index reduced_size = 257;
+
+  Tensor<Scalar, 2, RowMajor> input(outer_size, reduced_size);
+  for (Index i = 0; i < outer_size; ++i) {
+    for (Index j = 0; j < reduced_size; ++j) {
+      input(i, j) = Scalar(static_cast<float>(i + 1), static_cast<float>(2 * i + 1));
+    }
+  }
+
+  ThreadPool thread_pool(2);
+  ThreadPoolDevice thread_pool_device(&thread_pool, 2);
+
+  IndexList<type2index<1>> static_reduction_dim;
+  Tensor<Scalar, 1, RowMajor> static_result(outer_size);
+  static_result.device(thread_pool_device) = input.sum(static_reduction_dim);
+
+  array<Index, 1> runtime_reduction_dim{1};
+  Tensor<Scalar, 1, RowMajor> runtime_result(outer_size);
+  runtime_result.device(thread_pool_device) = input.sum(runtime_reduction_dim);
+
+  for (Index i = 0; i < outer_size; ++i) {
+    const Scalar expected = static_cast<float>(reduced_size) * input(i, 0);
+    VERIFY_IS_EQUAL(static_result(i), expected);
+    VERIFY_IS_EQUAL(runtime_result(i), expected);
+  }
+}
+
+void test_memcpy() {
+  for (int i = 0; i < 5; ++i) {
+    const int num_threads = internal::random<int>(3, 11);
+    Eigen::ThreadPool tp(num_threads);
+    Eigen::ThreadPoolDevice thread_pool_device(&tp, num_threads);
+
+    const int size = internal::random<int>(13, 7632);
+    Tensor<float, 1> t1(size);
+    t1.setRandom();
+    std::vector<float> result(size);
+    thread_pool_device.memcpy(&result[0], t1.data(), size * sizeof(float));
+    for (int j = 0; j < size; j++) {
+      VERIFY_IS_EQUAL(t1(j), result[j]);
+    }
+  }
+}
+
+void test_multithread_random() {
+  Eigen::ThreadPool tp(2);
+  Eigen::ThreadPoolDevice device(&tp, 2);
+  Tensor<float, 1> t(1 << 20);
+  t.device(device) = t.random<Eigen::internal::NormalRandomGenerator<float>>();
+}
+
+template <int DataLayout>
+void test_multithread_shuffle(Allocator* allocator) {
+  Tensor<float, 4, DataLayout> tensor(17, 5, 7, 11);
+  tensor.setRandom();
+
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads, allocator);
+
+  Tensor<float, 4, DataLayout> shuffle(7, 5, 11, 17);
+  array<ptrdiff_t, 4> shuffles = {{2, 1, 3, 0}};
+  shuffle.device(device) = tensor.shuffle(shuffles);
+
+  for (int i = 0; i < 17; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      for (int k = 0; k < 7; ++k) {
+        for (int l = 0; l < 11; ++l) {
+          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, j, l, i));
+        }
+      }
+    }
+  }
+}
+
+void test_threadpool_allocate(TestAllocator* allocator) {
+  const int num_threads = internal::random<int>(2, 11);
+  const int num_allocs = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads, allocator);
+
+  for (int a = 0; a < num_allocs; ++a) {
+    void* ptr = device.allocate(512);
+    device.deallocate(ptr);
+  }
+  VERIFY(allocator != nullptr);
+  VERIFY_IS_EQUAL(allocator->alloc_count(), num_allocs);
+  VERIFY_IS_EQUAL(allocator->dealloc_count(), num_allocs);
+}
+
+template <int DataLayout>
+void test_multithread_zero_dim_contraction() {
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  // 2D contraction: {10, 0} * {0, 20} -> {10, 20}
+  {
+    Tensor<float, 2, DataLayout> t_left(10, 0);
+    Tensor<float, 2, DataLayout> t_right(0, 20);
+    Tensor<float, 2, DataLayout> t_result(10, 20);
+    t_result.setConstant(123.0f);
+
+    typedef Tensor<float, 1>::DimensionPair DimPair;
+    Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+    t_result.device(device) = t_left.contract(t_right, dims);
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], 0.0f);
+    }
+  }
+
+  // 2D contraction with non-empty dim >= 48: {64, 0} * {0, 64} -> {64, 64}
+  {
+    Tensor<float, 2, DataLayout> t_left(64, 0);
+    Tensor<float, 2, DataLayout> t_right(0, 64);
+    Tensor<float, 2, DataLayout> t_result(64, 64);
+    t_result.setConstant(123.0f);
+
+    typedef Tensor<float, 1>::DimensionPair DimPair;
+    Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+    t_result.device(device) = t_left.contract(t_right, dims);
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 64);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 64);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], 0.0f);
+    }
+  }
+
+  // Multidim contraction: {5, 0, 4} * {0, 3, 4} with dims {1, 0} and {2, 2} -> {5, 3}
+  {
+    Tensor<float, 3, DataLayout> t_left(5, 0, 4);
+    Tensor<float, 3, DataLayout> t_right(0, 3, 4);
+    Tensor<float, 2, DataLayout> t_result(5, 3);
+    t_result.setConstant(123.0f);
+
+    typedef Tensor<float, 1>::DimensionPair DimPair;
+    Eigen::array<DimPair, 2> dims{{DimPair(1, 0), DimPair(2, 2)}};
+
+    t_result.device(device) = t_left.contract(t_right, dims);
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 5);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 3);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], 0.0f);
+    }
+  }
+}
+
+template <int DataLayout>
+void test_async_multithread_zero_dim_contraction() {
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  Tensor<float, 2, DataLayout> t_left(10, 0);
+  Tensor<float, 2, DataLayout> t_right(0, 20);
+  Tensor<float, 2, DataLayout> t_result(10, 20);
+  t_result.setConstant(123.0f);
+
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  Eigen::Barrier barrier(1);
+  t_result.device(device, [&barrier]() { barrier.Notify(); }) = t_left.contract(t_right, dims);
+  barrier.Wait();
+
+  VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+  VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+  for (Index i = 0; i < t_result.size(); ++i) {
+    VERIFY_IS_EQUAL(t_result.data()[i], 0.0f);
+  }
+}
+
+template <typename Scalar>
+struct AddBiasOutputKernel {
+  Scalar bias;
+  explicit AddBiasOutputKernel(Scalar b) : bias(b) {}
+
+  template <typename Index, typename ResScalar>
+  EIGEN_ALWAYS_INLINE void operator()(const internal::blas_data_mapper<ResScalar, Index, ColMajor>& output_mapper,
+                                      const TensorContractionParams&, Index, Index, Index num_rows,
+                                      Index num_cols) const {
+    for (Index i = 0; i < num_rows; ++i) {
+      for (Index j = 0; j < num_cols; ++j) {
+        output_mapper(i, j) += bias;
+      }
+    }
+  }
+};
+
+template <int DataLayout>
+void test_multithread_zero_dim_contraction_with_output_kernel() {
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  const float bias = 42.0f;
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // {10, 0} * {0, 20} -> {10, 20}
+  {
+    Tensor<float, 2, DataLayout> t_left(10, 0);
+    Tensor<float, 2, DataLayout> t_right(0, 20);
+    Tensor<float, 2, DataLayout> t_result(10, 20);
+    t_result.setConstant(123.0f);
+
+    t_result.device(device) = t_left.contract(t_right, dims, AddBiasOutputKernel<float>(bias));
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], bias);
+    }
+  }
+
+  // {64, 0} * {0, 64} -> {64, 64}
+  {
+    Tensor<float, 2, DataLayout> t_left(64, 0);
+    Tensor<float, 2, DataLayout> t_right(0, 64);
+    Tensor<float, 2, DataLayout> t_result(64, 64);
+    t_result.setConstant(123.0f);
+
+    t_result.device(device) = t_left.contract(t_right, dims, AddBiasOutputKernel<float>(bias));
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 64);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 64);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], bias);
+    }
+  }
+}
+
+template <int DataLayout>
+void test_async_multithread_zero_dim_contraction_with_output_kernel() {
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  const float bias = 42.0f;
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // {10, 0} * {0, 20} -> {10, 20}
+  {
+    Tensor<float, 2, DataLayout> t_left(10, 0);
+    Tensor<float, 2, DataLayout> t_right(0, 20);
+    Tensor<float, 2, DataLayout> t_result(10, 20);
+    t_result.setConstant(123.0f);
+
+    Eigen::Barrier barrier(1);
+    t_result.device(device, [&barrier]() { barrier.Notify(); }) =
+        t_left.contract(t_right, dims, AddBiasOutputKernel<float>(bias));
+    barrier.Wait();
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 20);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], bias);
+    }
+  }
+
+  // {64, 0} * {0, 64} -> {64, 64}
+  {
+    Tensor<float, 2, DataLayout> t_left(64, 0);
+    Tensor<float, 2, DataLayout> t_right(0, 64);
+    Tensor<float, 2, DataLayout> t_result(64, 64);
+    t_result.setConstant(123.0f);
+
+    Eigen::Barrier barrier(1);
+    t_result.device(device, [&barrier]() { barrier.Notify(); }) =
+        t_left.contract(t_right, dims, AddBiasOutputKernel<float>(bias));
+    barrier.Wait();
+
+    VERIFY_IS_EQUAL(t_result.dimension(0), 64);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 64);
+    for (Index i = 0; i < t_result.size(); ++i) {
+      VERIFY_IS_EQUAL(t_result.data()[i], bias);
+    }
+  }
+}
+
+template <int DataLayout>
+void test_multithread_zero_dim_outer_zeros() {
+  const int num_threads = internal::random<int>(2, 11);
+  ThreadPool threads(num_threads);
+  Eigen::ThreadPoolDevice device(&threads, num_threads);
+
+  typedef Tensor<float, 1>::DimensionPair DimPair;
+  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
+
+  // Outer zero on LHS: {0, 5} * {5, 10} -> {0, 10}
+  {
+    Tensor<float, 2, DataLayout> t_left(0, 5);
+    Tensor<float, 2, DataLayout> t_right(5, 10);
+    t_right.setRandom();
+    Tensor<float, 2, DataLayout> t_result(0, 10);
+    t_result.device(device) = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 10);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Outer zero on RHS: {10, 5} * {5, 0} -> {10, 0}
+  {
+    Tensor<float, 2, DataLayout> t_left(10, 5);
+    Tensor<float, 2, DataLayout> t_right(5, 0);
+    t_left.setRandom();
+    Tensor<float, 2, DataLayout> t_result(10, 0);
+    t_result.device(device) = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 10);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 0);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Outer zero on both: {0, 5} * {5, 0} -> {0, 0}
+  {
+    Tensor<float, 2, DataLayout> t_left(0, 5);
+    Tensor<float, 2, DataLayout> t_right(5, 0);
+    Tensor<float, 2, DataLayout> t_result(0, 0);
+    t_result.device(device) = t_left.contract(t_right, dims);
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 0);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+
+  // Async zero outer dim
+  {
+    Tensor<float, 2, DataLayout> t_left(0, 5);
+    Tensor<float, 2, DataLayout> t_right(5, 10);
+    t_right.setRandom();
+    Tensor<float, 2, DataLayout> t_result(0, 10);
+    Eigen::Barrier barrier(1);
+    t_result.device(device, [&barrier]() { barrier.Notify(); }) = t_left.contract(t_right, dims);
+    barrier.Wait();
+    VERIFY_IS_EQUAL(t_result.dimension(0), 0);
+    VERIFY_IS_EQUAL(t_result.dimension(1), 10);
+    VERIFY_IS_EQUAL(t_result.size(), 0);
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_thread_pool) {
+  CALL_SUBTEST_1(test_multithread_elementwise());
+  CALL_SUBTEST_1(test_async_multithread_elementwise());
+  CALL_SUBTEST_1(test_multithread_compound_assignment());
+
+  CALL_SUBTEST_2(test_multithread_contraction<ColMajor>());
+  CALL_SUBTEST_2(test_multithread_contraction<RowMajor>());
+  CALL_SUBTEST_2(test_multithread_gemv_transpose<ColMajor>());
+  CALL_SUBTEST_2(test_multithread_gemv_transpose<RowMajor>());
+
+  CALL_SUBTEST_3(test_multithread_chip());
+  CALL_SUBTEST_3(test_async_multithread_chip());
+
+  CALL_SUBTEST_4(test_multithread_volume_patch());
+  CALL_SUBTEST_4(test_async_multithread_volume_patch());
+  CALL_SUBTEST_4(test_multithread_tiled_stateful_functor());
+  CALL_SUBTEST_4(test_async_multithread_tiled_stateful_functor());
+
+  CALL_SUBTEST_5(test_multithread_contraction_agrees_with_singlethread<ColMajor>());
+  CALL_SUBTEST_5(test_multithread_contraction_agrees_with_singlethread<RowMajor>());
+  CALL_SUBTEST_5(test_multithread_contraction_with_output_kernel<ColMajor>());
+  CALL_SUBTEST_5(test_multithread_contraction_with_output_kernel<RowMajor>());
+
+  CALL_SUBTEST_6(test_async_multithread_contraction_agrees_with_singlethread<ColMajor>());
+  CALL_SUBTEST_6(test_async_multithread_contraction_agrees_with_singlethread<RowMajor>());
+
+  // Test EvalShardedByInnerDimContext parallelization strategy.
+  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction<ColMajor>());
+  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction<RowMajor>());
+  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction_with_output_kernel<ColMajor>());
+  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction_with_output_kernel<RowMajor>());
+
+  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction<ColMajor>());
+  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction<RowMajor>());
+  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction_with_output_kernel<ColMajor>());
+  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction_with_output_kernel<RowMajor>());
+
+  // Exercise various cases that have been problematic in the past.
+  CALL_SUBTEST_9(test_contraction_corner_cases<ColMajor>());
+  CALL_SUBTEST_9(test_contraction_corner_cases<RowMajor>());
+
+  CALL_SUBTEST_10(test_full_contraction<ColMajor>());
+  CALL_SUBTEST_10(test_full_contraction<RowMajor>());
+
+  CALL_SUBTEST_11(test_multithreaded_reductions<ColMajor>());
+  CALL_SUBTEST_11(test_multithreaded_reductions<RowMajor>());
+  CALL_SUBTEST_11(test_multithreaded_complex_reduction());
+  CALL_SUBTEST_11(test_multithreaded_complex_partial_reductions());
+
+  CALL_SUBTEST_12(test_memcpy());
+  CALL_SUBTEST_12(test_multithread_random());
+
+  TestAllocator test_allocator;
+  CALL_SUBTEST_13(test_multithread_shuffle<ColMajor>(nullptr));
+  CALL_SUBTEST_13(test_multithread_shuffle<RowMajor>(&test_allocator));
+  CALL_SUBTEST_13(test_threadpool_allocate(&test_allocator));
+
+  CALL_SUBTEST_14(test_multithread_zero_dim_contraction<ColMajor>());
+  CALL_SUBTEST_14(test_multithread_zero_dim_contraction<RowMajor>());
+  CALL_SUBTEST_14(test_async_multithread_zero_dim_contraction<ColMajor>());
+  CALL_SUBTEST_14(test_async_multithread_zero_dim_contraction<RowMajor>());
+  CALL_SUBTEST_14(test_multithread_zero_dim_contraction_with_output_kernel<ColMajor>());
+  CALL_SUBTEST_14(test_multithread_zero_dim_contraction_with_output_kernel<RowMajor>());
+  CALL_SUBTEST_14(test_async_multithread_zero_dim_contraction_with_output_kernel<ColMajor>());
+  CALL_SUBTEST_14(test_async_multithread_zero_dim_contraction_with_output_kernel<RowMajor>());
+  CALL_SUBTEST_14(test_multithread_zero_dim_outer_zeros<ColMajor>());
+  CALL_SUBTEST_14(test_multithread_zero_dim_outer_zeros<RowMajor>());
+
+  // Force CMake to split this test.
+  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8;9;10;11;12;13;14
+}
diff --git a/contrib/test/tensor_trace.cpp b/contrib/test/tensor_trace.cpp
new file mode 100644
index 0000000..e680d46
--- /dev/null
+++ b/contrib/test/tensor_trace.cpp
@@ -0,0 +1,169 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2017 Gagan Goel <gagan.nith@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::array;
+using Eigen::Tensor;
+
+template <int DataLayout>
+static void test_0D_trace() {
+  Tensor<float, 0, DataLayout> tensor;
+  tensor.setRandom();
+  array<ptrdiff_t, 0> dims;
+  Tensor<float, 0, DataLayout> result = tensor.trace(dims);
+  VERIFY_IS_EQUAL(result(), tensor());
+}
+
+template <int DataLayout>
+static void test_all_dimensions_trace() {
+  Tensor<float, 3, DataLayout> tensor1(5, 5, 5);
+  tensor1.setRandom();
+  Tensor<float, 0, DataLayout> result1 = tensor1.trace();
+  VERIFY_IS_EQUAL(result1.rank(), 0);
+  float sum = 0.0f;
+  for (int i = 0; i < 5; ++i) {
+    sum += tensor1(i, i, i);
+  }
+  VERIFY_IS_EQUAL(result1(), sum);
+
+  Tensor<float, 5, DataLayout> tensor2(7, 7, 7, 7, 7);
+  tensor2.setRandom();
+  array<ptrdiff_t, 5> dims = {{2, 1, 0, 3, 4}};
+  Tensor<float, 0, DataLayout> result2 = tensor2.trace(dims);
+  VERIFY_IS_EQUAL(result2.rank(), 0);
+  sum = 0.0f;
+  for (int i = 0; i < 7; ++i) {
+    sum += tensor2(i, i, i, i, i);
+  }
+  VERIFY_IS_EQUAL(result2(), sum);
+}
+
+template <int DataLayout>
+static void test_simple_trace() {
+  Tensor<float, 3, DataLayout> tensor1(3, 5, 3);
+  tensor1.setRandom();
+  array<ptrdiff_t, 2> dims1 = {{0, 2}};
+  Tensor<float, 1, DataLayout> result1 = tensor1.trace(dims1);
+  VERIFY_IS_EQUAL(result1.rank(), 1);
+  VERIFY_IS_EQUAL(result1.dimension(0), 5);
+  float sum = 0.0f;
+  for (int i = 0; i < 5; ++i) {
+    sum = 0.0f;
+    for (int j = 0; j < 3; ++j) {
+      sum += tensor1(j, i, j);
+    }
+    VERIFY_IS_EQUAL(result1(i), sum);
+  }
+
+  Tensor<float, 4, DataLayout> tensor2(5, 5, 7, 7);
+  tensor2.setRandom();
+  array<ptrdiff_t, 2> dims2 = {{2, 3}};
+  Tensor<float, 2, DataLayout> result2 = tensor2.trace(dims2);
+  VERIFY_IS_EQUAL(result2.rank(), 2);
+  VERIFY_IS_EQUAL(result2.dimension(0), 5);
+  VERIFY_IS_EQUAL(result2.dimension(1), 5);
+  for (int i = 0; i < 5; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      sum = 0.0f;
+      for (int k = 0; k < 7; ++k) {
+        sum += tensor2(i, j, k, k);
+      }
+      VERIFY_IS_EQUAL(result2(i, j), sum);
+    }
+  }
+
+  array<ptrdiff_t, 2> dims3 = {{1, 0}};
+  Tensor<float, 2, DataLayout> result3 = tensor2.trace(dims3);
+  VERIFY_IS_EQUAL(result3.rank(), 2);
+  VERIFY_IS_EQUAL(result3.dimension(0), 7);
+  VERIFY_IS_EQUAL(result3.dimension(1), 7);
+  for (int i = 0; i < 7; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      sum = 0.0f;
+      for (int k = 0; k < 5; ++k) {
+        sum += tensor2(k, k, i, j);
+      }
+      VERIFY_IS_EQUAL(result3(i, j), sum);
+    }
+  }
+
+  Tensor<float, 5, DataLayout> tensor3(3, 7, 3, 7, 3);
+  tensor3.setRandom();
+  array<ptrdiff_t, 3> dims4 = {{0, 2, 4}};
+  Tensor<float, 2, DataLayout> result4 = tensor3.trace(dims4);
+  VERIFY_IS_EQUAL(result4.rank(), 2);
+  VERIFY_IS_EQUAL(result4.dimension(0), 7);
+  VERIFY_IS_EQUAL(result4.dimension(1), 7);
+  for (int i = 0; i < 7; ++i) {
+    for (int j = 0; j < 7; ++j) {
+      sum = 0.0f;
+      for (int k = 0; k < 3; ++k) {
+        sum += tensor3(k, i, k, j, k);
+      }
+      VERIFY_IS_EQUAL(result4(i, j), sum);
+    }
+  }
+
+  Tensor<float, 5, DataLayout> tensor4(3, 7, 4, 7, 5);
+  tensor4.setRandom();
+  array<ptrdiff_t, 2> dims5 = {{1, 3}};
+  Tensor<float, 3, DataLayout> result5 = tensor4.trace(dims5);
+  VERIFY_IS_EQUAL(result5.rank(), 3);
+  VERIFY_IS_EQUAL(result5.dimension(0), 3);
+  VERIFY_IS_EQUAL(result5.dimension(1), 4);
+  VERIFY_IS_EQUAL(result5.dimension(2), 5);
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      for (int k = 0; k < 5; ++k) {
+        sum = 0.0f;
+        for (int l = 0; l < 7; ++l) {
+          sum += tensor4(i, l, j, l, k);
+        }
+        VERIFY_IS_EQUAL(result5(i, j, k), sum);
+      }
+    }
+  }
+}
+
+template <int DataLayout>
+static void test_trace_in_expr() {
+  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 3);
+  tensor.setRandom();
+  array<ptrdiff_t, 2> dims = {{1, 3}};
+  Tensor<float, 2, DataLayout> result(2, 5);
+  result = result.constant(1.0f) - tensor.trace(dims);
+  VERIFY_IS_EQUAL(result.rank(), 2);
+  VERIFY_IS_EQUAL(result.dimension(0), 2);
+  VERIFY_IS_EQUAL(result.dimension(1), 5);
+  float sum = 0.0f;
+  for (int i = 0; i < 2; ++i) {
+    for (int j = 0; j < 5; ++j) {
+      sum = 0.0f;
+      for (int k = 0; k < 3; ++k) {
+        sum += tensor(i, k, j, k);
+      }
+      VERIFY_IS_EQUAL(result(i, j), 1.0f - sum);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_trace) {
+  CALL_SUBTEST(test_0D_trace<ColMajor>());
+  CALL_SUBTEST(test_0D_trace<RowMajor>());
+  CALL_SUBTEST(test_all_dimensions_trace<ColMajor>());
+  CALL_SUBTEST(test_all_dimensions_trace<RowMajor>());
+  CALL_SUBTEST(test_simple_trace<ColMajor>());
+  CALL_SUBTEST(test_simple_trace<RowMajor>());
+  CALL_SUBTEST(test_trace_in_expr<ColMajor>());
+  CALL_SUBTEST(test_trace_in_expr<RowMajor>());
+}
diff --git a/contrib/test/tensor_uint128.cpp b/contrib/test/tensor_uint128.cpp
new file mode 100644
index 0000000..0fb6b0d
--- /dev/null
+++ b/contrib/test/tensor_uint128.cpp
@@ -0,0 +1,179 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+#if EIGEN_COMP_MSVC || !defined(__SIZEOF_INT128__)
+#define EIGEN_NO_INT128
+#else
+typedef __uint128_t uint128_t;
+#endif
+
+// Only run the test on compilers that support 128bit integers natively
+#ifndef EIGEN_NO_INT128
+
+using Eigen::internal::static_val;
+using Eigen::internal::TensorUInt128;
+
+void VERIFY_EQUAL(TensorUInt128<uint64_t, uint64_t> actual, uint128_t expected) {
+  bool matchl = actual.lower() == static_cast<uint64_t>(expected);
+  bool matchh = actual.upper() == static_cast<uint64_t>(expected >> 64);
+  if (!matchl || !matchh) {
+    const char* testname = g_test_stack.back().c_str();
+    std::cerr << "Test " << testname << " failed in " << __FILE__ << " (" << __LINE__ << ")" << std::endl;
+    abort();
+  }
+}
+
+void test_add() {
+  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
+  for (uint64_t i1 = 0; i1 < 100; ++i1) {
+    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
+      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
+      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
+      for (uint64_t j1 = 0; j1 < 100; ++j1) {
+        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
+          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
+          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
+          TensorUInt128<uint64_t, uint64_t> actual = i + j;
+          uint128_t expected = a + b;
+          VERIFY_EQUAL(actual, expected);
+        }
+      }
+    }
+  }
+}
+
+void test_sub() {
+  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
+  for (uint64_t i1 = 0; i1 < 100; ++i1) {
+    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
+      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
+      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
+      for (uint64_t j1 = 0; j1 < 100; ++j1) {
+        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
+          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
+          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
+          TensorUInt128<uint64_t, uint64_t> actual = i - j;
+          uint128_t expected = a - b;
+          VERIFY_EQUAL(actual, expected);
+        }
+      }
+    }
+  }
+}
+
+void test_mul() {
+  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
+  for (uint64_t i1 = 0; i1 < 100; ++i1) {
+    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
+      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
+      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
+      for (uint64_t j1 = 0; j1 < 100; ++j1) {
+        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
+          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
+          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
+          TensorUInt128<uint64_t, uint64_t> actual = i * j;
+          uint128_t expected = a * b;
+          VERIFY_EQUAL(actual, expected);
+        }
+      }
+    }
+  }
+}
+
+void test_div() {
+  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
+  for (uint64_t i1 = 0; i1 < 100; ++i1) {
+    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
+      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
+      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
+      for (uint64_t j1 = 0; j1 < 100; ++j1) {
+        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
+          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
+          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
+          TensorUInt128<uint64_t, uint64_t> actual = i / j;
+          uint128_t expected = a / b;
+          VERIFY_EQUAL(actual, expected);
+        }
+      }
+    }
+  }
+}
+
+void test_misc1() {
+  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
+  for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
+    TensorUInt128<static_val<0>, uint64_t> i(0, i2);
+    uint128_t a = static_cast<uint128_t>(i2);
+    for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
+      TensorUInt128<static_val<0>, uint64_t> j(0, j2);
+      uint128_t b = static_cast<uint128_t>(j2);
+      uint64_t actual = (i * j).upper();
+      uint64_t expected = (a * b) >> 64;
+      VERIFY_IS_EQUAL(actual, expected);
+    }
+  }
+}
+
+void test_div_overflow() {
+  // Regression test for infinite loop when lhs > 2^127 (issue #3012).
+  // Division would overflow d during doubling, causing an infinite loop.
+  TensorUInt128<uint64_t, uint64_t> a(1ULL << 63, 1);
+  TensorUInt128<uint64_t, uint64_t> b(2);
+  uint128_t expected = ((static_cast<uint128_t>(1ULL << 63) << 64) + 1) / 2;
+  VERIFY_EQUAL(a / b, expected);
+
+  // Also test with high bits in both operands
+  TensorUInt128<uint64_t, uint64_t> c(UINT64_MAX, UINT64_MAX);
+  TensorUInt128<uint64_t, uint64_t> d(1);
+  uint128_t c128 = (static_cast<uint128_t>(UINT64_MAX) << 64) | UINT64_MAX;
+  VERIFY_EQUAL(c / d, c128);
+
+  TensorUInt128<uint64_t, uint64_t> e(UINT64_MAX, UINT64_MAX);
+  TensorUInt128<uint64_t, uint64_t> f(0, 3);
+  uint128_t e128 = (static_cast<uint128_t>(UINT64_MAX) << 64) | UINT64_MAX;
+  VERIFY_EQUAL(e / f, e128 / 3);
+}
+
+void test_misc2() {
+  int64_t incr = internal::random<int64_t>(1, 100);
+  for (int64_t log_div = 0; log_div < 63; ++log_div) {
+    for (int64_t divider = 1; divider <= 1000000 * incr; divider += incr) {
+      uint64_t expected = (static_cast<uint128_t>(1) << (64 + log_div)) / static_cast<uint128_t>(divider) -
+                          (static_cast<uint128_t>(1) << 64) + 1;
+      uint64_t shift = 1ULL << log_div;
+
+      TensorUInt128<uint64_t, uint64_t> result =
+          (TensorUInt128<uint64_t, static_val<0> >(shift, 0) / TensorUInt128<static_val<0>, uint64_t>(divider) -
+           TensorUInt128<static_val<1>, static_val<0> >(1, 0) + TensorUInt128<static_val<0>, static_val<1> >(1));
+      uint64_t actual = static_cast<uint64_t>(result);
+      VERIFY_IS_EQUAL(actual, expected);
+    }
+  }
+}
+#endif
+
+EIGEN_DECLARE_TEST(tensor_uint128) {
+#ifdef EIGEN_NO_INT128
+  // Skip the test on compilers that don't support 128bit integers natively
+  return;
+#else
+  CALL_SUBTEST_1(test_add());
+  CALL_SUBTEST_2(test_sub());
+  CALL_SUBTEST_3(test_mul());
+  CALL_SUBTEST_4(test_div());
+  CALL_SUBTEST_5(test_misc1());
+  CALL_SUBTEST_6(test_misc2());
+  CALL_SUBTEST_7(test_div_overflow());
+#endif
+}
diff --git a/contrib/test/tensor_volume_patch.cpp b/contrib/test/tensor_volume_patch.cpp
new file mode 100644
index 0000000..09a1b8e
--- /dev/null
+++ b/contrib/test/tensor_volume_patch.cpp
@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Tensor>
+
+using Eigen::Tensor;
+
+static void test_single_voxel_patch() {
+  Tensor<float, 5> tensor(4, 2, 3, 5, 7);
+  tensor.setRandom();
+  Tensor<float, 5, RowMajor> tensor_row_major = tensor.swap_layout();
+
+  Tensor<float, 6> single_voxel_patch;
+  single_voxel_patch = tensor.extract_volume_patches(1, 1, 1);
+  VERIFY_IS_EQUAL(single_voxel_patch.dimension(0), 4);
+  VERIFY_IS_EQUAL(single_voxel_patch.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch.dimension(3), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch.dimension(4), 2 * 3 * 5);
+  VERIFY_IS_EQUAL(single_voxel_patch.dimension(5), 7);
+
+  Tensor<float, 6, RowMajor> single_voxel_patch_row_major;
+  single_voxel_patch_row_major = tensor_row_major.extract_volume_patches(1, 1, 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(1), 2 * 3 * 5);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(3), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(4), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(5), 4);
+
+  for (int i = 0; i < tensor.size(); ++i) {
+    VERIFY_IS_EQUAL(tensor.data()[i], single_voxel_patch.data()[i]);
+    VERIFY_IS_EQUAL(tensor_row_major.data()[i], single_voxel_patch_row_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor.data()[i], tensor_row_major.data()[i]);
+  }
+}
+
+static void test_entire_volume_patch() {
+  const int depth = 4;
+  const int patch_z = 2;
+  const int patch_y = 3;
+  const int patch_x = 5;
+  const int batch = 7;
+
+  Tensor<float, 5> tensor(depth, patch_z, patch_y, patch_x, batch);
+  tensor.setRandom();
+  Tensor<float, 5, RowMajor> tensor_row_major = tensor.swap_layout();
+
+  Tensor<float, 6> entire_volume_patch;
+  entire_volume_patch = tensor.extract_volume_patches(patch_z, patch_y, patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch.dimension(0), depth);
+  VERIFY_IS_EQUAL(entire_volume_patch.dimension(1), patch_z);
+  VERIFY_IS_EQUAL(entire_volume_patch.dimension(2), patch_y);
+  VERIFY_IS_EQUAL(entire_volume_patch.dimension(3), patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch.dimension(4), patch_z * patch_y * patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch.dimension(5), batch);
+
+  Tensor<float, 6, RowMajor> entire_volume_patch_row_major;
+  entire_volume_patch_row_major = tensor_row_major.extract_volume_patches(patch_z, patch_y, patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(0), batch);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(1), patch_z * patch_y * patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(2), patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(3), patch_y);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(4), patch_z);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(5), depth);
+
+  const int dz = patch_z - 1;
+  const int dy = patch_y - 1;
+  const int dx = patch_x - 1;
+
+  const int forward_pad_z = dz / 2;
+  const int forward_pad_y = dy / 2;
+  const int forward_pad_x = dx / 2;
+
+  for (int pz = 0; pz < patch_z; pz++) {
+    for (int py = 0; py < patch_y; py++) {
+      for (int px = 0; px < patch_x; px++) {
+        const int patchId = pz + patch_z * (py + px * patch_y);
+        for (int z = 0; z < patch_z; z++) {
+          for (int y = 0; y < patch_y; y++) {
+            for (int x = 0; x < patch_x; x++) {
+              for (int b = 0; b < batch; b++) {
+                for (int d = 0; d < depth; d++) {
+                  float expected = 0.0f;
+                  float expected_row_major = 0.0f;
+                  const int eff_z = z - forward_pad_z + pz;
+                  const int eff_y = y - forward_pad_y + py;
+                  const int eff_x = x - forward_pad_x + px;
+                  if (eff_z >= 0 && eff_y >= 0 && eff_x >= 0 && eff_z < patch_z && eff_y < patch_y && eff_x < patch_x) {
+                    expected = tensor(d, eff_z, eff_y, eff_x, b);
+                    expected_row_major = tensor_row_major(b, eff_x, eff_y, eff_z, d);
+                  }
+                  VERIFY_IS_EQUAL(entire_volume_patch(d, z, y, x, patchId, b), expected);
+                  VERIFY_IS_EQUAL(entire_volume_patch_row_major(b, patchId, x, y, z, d), expected_row_major);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(tensor_volume_patch) {
+  CALL_SUBTEST(test_single_voxel_patch());
+  CALL_SUBTEST(test_entire_volume_patch());
+}
diff --git a/contrib/test/tensor_volume_patch_sycl.cpp b/contrib/test/tensor_volume_patch_sycl.cpp
new file mode 100644
index 0000000..28310a4
--- /dev/null
+++ b/contrib/test/tensor_volume_patch_sycl.cpp
@@ -0,0 +1,230 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2016
+// Mehdi Goli    Codeplay Software Ltd.
+// Ralph Potter  Codeplay Software Ltd.
+// Luke Iwanski  Codeplay Software Ltd.
+// Contact: <eigen@codeplay.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
+#define EIGEN_USE_SYCL
+
+#include "main.h"
+#include <contrib/Eigen/Tensor>
+
+using Eigen::Tensor;
+static const int DataLayout = ColMajor;
+
+template <typename DataType, typename IndexType>
+static void test_single_voxel_patch_sycl(const Eigen::SyclDevice& sycl_device) {
+  IndexType sizeDim0 = 4;
+  IndexType sizeDim1 = 2;
+  IndexType sizeDim2 = 3;
+  IndexType sizeDim3 = 5;
+  IndexType sizeDim4 = 7;
+  array<IndexType, 5> tensorColMajorRange = {{sizeDim0, sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
+  array<IndexType, 5> tensorRowMajorRange = {{sizeDim4, sizeDim3, sizeDim2, sizeDim1, sizeDim0}};
+  Tensor<DataType, 5, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  Tensor<DataType, 5, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+  tensor_col_major.setRandom();
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 5, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+
+  // single volume patch: ColMajor
+  array<IndexType, 6> patchColMajorTensorRange = {{sizeDim0, 1, 1, 1, sizeDim1 * sizeDim2 * sizeDim3, sizeDim4}};
+  Tensor<DataType, 6, DataLayout, IndexType> single_voxel_patch_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = single_voxel_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_single_voxel_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 6, DataLayout, IndexType>> gpu_single_voxel_patch_col_major(
+      gpu_data_single_voxel_patch_col_major, patchColMajorTensorRange);
+  gpu_single_voxel_patch_col_major.device(sycl_device) = gpu_col_major.extract_volume_patches(1, 1, 1);
+  sycl_device.memcpyDeviceToHost(single_voxel_patch_col_major.data(), gpu_data_single_voxel_patch_col_major,
+                                 patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(0), 4);
+  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(1), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(3), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(4), 2 * 3 * 5);
+  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(5), 7);
+
+  array<IndexType, 6> patchRowMajorTensorRange = {{sizeDim4, sizeDim1 * sizeDim2 * sizeDim3, 1, 1, 1, sizeDim0}};
+  Tensor<DataType, 6, RowMajor, IndexType> single_voxel_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = single_voxel_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_single_voxel_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 6, RowMajor, IndexType>> gpu_single_voxel_patch_row_major(
+      gpu_data_single_voxel_patch_row_major, patchRowMajorTensorRange);
+  gpu_single_voxel_patch_row_major.device(sycl_device) = gpu_row_major.extract_volume_patches(1, 1, 1);
+  sycl_device.memcpyDeviceToHost(single_voxel_patch_row_major.data(), gpu_data_single_voxel_patch_row_major,
+                                 patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(0), 7);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(1), 2 * 3 * 5);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(2), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(3), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(4), 1);
+  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(5), 4);
+
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
+    VERIFY_IS_EQUAL(tensor_col_major.data()[i], single_voxel_patch_col_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor_row_major.data()[i], single_voxel_patch_row_major.data()[i]);
+    VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
+  }
+
+  sycl_device.deallocate(gpu_data_col_major);
+  sycl_device.deallocate(gpu_data_row_major);
+  sycl_device.deallocate(gpu_data_single_voxel_patch_col_major);
+  sycl_device.deallocate(gpu_data_single_voxel_patch_row_major);
+}
+
+template <typename DataType, typename IndexType>
+static void test_entire_volume_patch_sycl(const Eigen::SyclDevice& sycl_device) {
+  const int depth = 4;
+  const int patch_z = 2;
+  const int patch_y = 3;
+  const int patch_x = 5;
+  const int batch = 7;
+
+  array<IndexType, 5> tensorColMajorRange = {{depth, patch_z, patch_y, patch_x, batch}};
+  array<IndexType, 5> tensorRowMajorRange = {{batch, patch_x, patch_y, patch_z, depth}};
+  Tensor<DataType, 5, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
+  Tensor<DataType, 5, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
+  tensor_col_major.setRandom();
+
+  DataType* gpu_data_col_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
+  DataType* gpu_data_row_major =
+      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
+  TensorMap<Tensor<DataType, 5, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
+  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
+
+  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
+                                 (tensor_col_major.size()) * sizeof(DataType));
+  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
+  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
+                                 (tensor_col_major.size()) * sizeof(DataType));
+
+  // single volume patch: ColMajor
+  array<IndexType, 6> patchColMajorTensorRange = {
+      {depth, patch_z, patch_y, patch_x, patch_z * patch_y * patch_x, batch}};
+  Tensor<DataType, 6, DataLayout, IndexType> entire_volume_patch_col_major(patchColMajorTensorRange);
+  size_t patchTensorBuffSize = entire_volume_patch_col_major.size() * sizeof(DataType);
+  DataType* gpu_data_entire_volume_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 6, DataLayout, IndexType>> gpu_entire_volume_patch_col_major(
+      gpu_data_entire_volume_patch_col_major, patchColMajorTensorRange);
+  gpu_entire_volume_patch_col_major.device(sycl_device) =
+      gpu_col_major.extract_volume_patches(patch_z, patch_y, patch_x);
+  sycl_device.memcpyDeviceToHost(entire_volume_patch_col_major.data(), gpu_data_entire_volume_patch_col_major,
+                                 patchTensorBuffSize);
+
+  //  Tensor<float, 5> tensor(depth, patch_z, patch_y, patch_x, batch);
+  //  tensor.setRandom();
+  //  Tensor<float, 5, RowMajor> tensor_row_major = tensor.swap_layout();
+
+  // Tensor<float, 6> entire_volume_patch;
+  // entire_volume_patch = tensor.extract_volume_patches(patch_z, patch_y, patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(0), depth);
+  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(1), patch_z);
+  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(2), patch_y);
+  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(3), patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(4), patch_z * patch_y * patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(5), batch);
+
+  //  Tensor<float, 6, RowMajor> entire_volume_patch_row_major;
+  // entire_volume_patch_row_major = tensor_row_major.extract_volume_patches(patch_z, patch_y, patch_x);
+
+  array<IndexType, 6> patchRowMajorTensorRange = {
+      {batch, patch_z * patch_y * patch_x, patch_x, patch_y, patch_z, depth}};
+  Tensor<DataType, 6, RowMajor, IndexType> entire_volume_patch_row_major(patchRowMajorTensorRange);
+  patchTensorBuffSize = entire_volume_patch_row_major.size() * sizeof(DataType);
+  DataType* gpu_data_entire_volume_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
+  TensorMap<Tensor<DataType, 6, RowMajor, IndexType>> gpu_entire_volume_patch_row_major(
+      gpu_data_entire_volume_patch_row_major, patchRowMajorTensorRange);
+  gpu_entire_volume_patch_row_major.device(sycl_device) =
+      gpu_row_major.extract_volume_patches(patch_z, patch_y, patch_x);
+  sycl_device.memcpyDeviceToHost(entire_volume_patch_row_major.data(), gpu_data_entire_volume_patch_row_major,
+                                 patchTensorBuffSize);
+
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(0), batch);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(1), patch_z * patch_y * patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(2), patch_x);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(3), patch_y);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(4), patch_z);
+  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(5), depth);
+
+  const int dz = patch_z - 1;
+  const int dy = patch_y - 1;
+  const int dx = patch_x - 1;
+
+  const int forward_pad_z = dz / 2;
+  const int forward_pad_y = dy / 2;
+  const int forward_pad_x = dx / 2;
+
+  for (int pz = 0; pz < patch_z; pz++) {
+    for (int py = 0; py < patch_y; py++) {
+      for (int px = 0; px < patch_x; px++) {
+        const int patchId = pz + patch_z * (py + px * patch_y);
+        for (int z = 0; z < patch_z; z++) {
+          for (int y = 0; y < patch_y; y++) {
+            for (int x = 0; x < patch_x; x++) {
+              for (int b = 0; b < batch; b++) {
+                for (int d = 0; d < depth; d++) {
+                  float expected = 0.0f;
+                  float expected_row_major = 0.0f;
+                  const int eff_z = z - forward_pad_z + pz;
+                  const int eff_y = y - forward_pad_y + py;
+                  const int eff_x = x - forward_pad_x + px;
+                  if (eff_z >= 0 && eff_y >= 0 && eff_x >= 0 && eff_z < patch_z && eff_y < patch_y && eff_x < patch_x) {
+                    expected = tensor_col_major(d, eff_z, eff_y, eff_x, b);
+                    expected_row_major = tensor_row_major(b, eff_x, eff_y, eff_z, d);
+                  }
+                  VERIFY_IS_EQUAL(entire_volume_patch_col_major(d, z, y, x, patchId, b), expected);
+                  VERIFY_IS_EQUAL(entire_volume_patch_row_major(b, patchId, x, y, z, d), expected_row_major);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  sycl_device.deallocate(gpu_data_col_major);
+  sycl_device.deallocate(gpu_data_row_major);
+  sycl_device.deallocate(gpu_data_entire_volume_patch_col_major);
+  sycl_device.deallocate(gpu_data_entire_volume_patch_row_major);
+}
+
+template <typename DataType, typename dev_Selector>
+void sycl_tensor_volume_patch_test_per_device(dev_Selector s) {
+  QueueInterface queueInterface(s);
+  auto sycl_device = Eigen::SyclDevice(&queueInterface);
+  std::cout << "Running on " << s.template get_info<cl::sycl::info::device::name>() << std::endl;
+  test_single_voxel_patch_sycl<DataType, int64_t>(sycl_device);
+  test_entire_volume_patch_sycl<DataType, int64_t>(sycl_device);
+}
+EIGEN_DECLARE_TEST(tensor_volume_patch_sycl) {
+  for (const auto& device : Eigen::get_sycl_supported_devices()) {
+    CALL_SUBTEST(sycl_tensor_volume_patch_test_per_device<half>(device));
+    CALL_SUBTEST(sycl_tensor_volume_patch_test_per_device<float>(device));
+  }
+}
diff --git a/debug/gdb/__init__.py b/debug/gdb/__init__.py
index bb7b160..7dcb21d 100644
--- a/debug/gdb/__init__.py
+++ b/debug/gdb/__init__.py
@@ -1 +1,3 @@
 # Intentionally empty
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
diff --git a/debug/gdb/printers.py b/debug/gdb/printers.py
index 2c3fccf..ca9e013 100644
--- a/debug/gdb/printers.py
+++ b/debug/gdb/printers.py
@@ -7,6 +7,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
 
 # Pretty printers for Eigen::Matrix
 # This is still pretty basic as the python extension to gdb is still pretty basic. 
diff --git a/debug/lldb/eigenlldb.py b/debug/lldb/eigenlldb.py
index 94a52be..776545e 100644
--- a/debug/lldb/eigenlldb.py
+++ b/debug/lldb/eigenlldb.py
@@ -8,6 +8,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
 
 # Pretty printers for Eigen::Matrix to use with LLDB debugger
 #
diff --git a/demos/CMakeLists.txt b/demos/CMakeLists.txt
index deb560f..a27f047 100644
--- a/demos/CMakeLists.txt
+++ b/demos/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 project(EigenDemos)
 
 add_custom_target(demos)
diff --git a/demos/mandelbrot/CMakeLists.txt b/demos/mandelbrot/CMakeLists.txt
index ae6001d..66dd13f 100644
--- a/demos/mandelbrot/CMakeLists.txt
+++ b/demos/mandelbrot/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 find_package(Qt4 REQUIRED)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8..9c192fe 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "mandelbrot.h"
 #include <iostream>
diff --git a/demos/mandelbrot/mandelbrot.h b/demos/mandelbrot/mandelbrot.h
index 8b8e5b9..0b7d9a6 100644
--- a/demos/mandelbrot/mandelbrot.h
+++ b/demos/mandelbrot/mandelbrot.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef MANDELBROT_H
 #define MANDELBROT_H
diff --git a/demos/mix_eigen_and_c/binary_library.cpp b/demos/mix_eigen_and_c/binary_library.cpp
index 2ac7821..4da74b6 100644
--- a/demos/mix_eigen_and_c/binary_library.cpp
+++ b/demos/mix_eigen_and_c/binary_library.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This C++ file compiles to binary code that can be linked to by your C program,
 // thanks to the extern "C" syntax used in the declarations in binary_library.h.
diff --git a/demos/mix_eigen_and_c/binary_library.h b/demos/mix_eigen_and_c/binary_library.h
index 9f16382..8cb1a8f 100644
--- a/demos/mix_eigen_and_c/binary_library.h
+++ b/demos/mix_eigen_and_c/binary_library.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This is a pure C header, no C++ here.
 // The functions declared here will be implemented in C++ but
diff --git a/demos/mix_eigen_and_c/example.c b/demos/mix_eigen_and_c/example.c
index 790c45b..a8e2e60 100644
--- a/demos/mix_eigen_and_c/example.c
+++ b/demos/mix_eigen_and_c/example.c
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "binary_library.h"
 #include "stdio.h"
diff --git a/demos/opengl/CMakeLists.txt b/demos/opengl/CMakeLists.txt
index 299aa44..38bc5ad 100644
--- a/demos/opengl/CMakeLists.txt
+++ b/demos/opengl/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 find_package(Qt4)
 find_package(OpenGL)
 
diff --git a/demos/opengl/camera.cpp b/demos/opengl/camera.cpp
index 0e5cc58..20f2242 100644
--- a/demos/opengl/camera.cpp
+++ b/demos/opengl/camera.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "camera.h"
 
diff --git a/demos/opengl/camera.h b/demos/opengl/camera.h
index 676ad23..a8f99ca 100644
--- a/demos/opengl/camera.h
+++ b/demos/opengl/camera.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_CAMERA_H
 #define EIGEN_CAMERA_H
diff --git a/demos/opengl/gpuhelper.cpp b/demos/opengl/gpuhelper.cpp
index fefd36b..1e4086d 100644
--- a/demos/opengl/gpuhelper.cpp
+++ b/demos/opengl/gpuhelper.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "gpuhelper.h"
 #include "icosphere.h"
diff --git a/demos/opengl/gpuhelper.h b/demos/opengl/gpuhelper.h
index b28c625..e31ffb6 100644
--- a/demos/opengl/gpuhelper.h
+++ b/demos/opengl/gpuhelper.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_GPUHELPER_H
 #define EIGEN_GPUHELPER_H
diff --git a/demos/opengl/icosphere.cpp b/demos/opengl/icosphere.cpp
index db28c47..e5abdea 100644
--- a/demos/opengl/icosphere.cpp
+++ b/demos/opengl/icosphere.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "icosphere.h"
 
diff --git a/demos/opengl/icosphere.h b/demos/opengl/icosphere.h
index 11418c1..909710f 100644
--- a/demos/opengl/icosphere.h
+++ b/demos/opengl/icosphere.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ICOSPHERE_H
 #define EIGEN_ICOSPHERE_H
diff --git a/demos/opengl/quaternion_demo.cpp b/demos/opengl/quaternion_demo.cpp
index e7472fa..74f8f59 100644
--- a/demos/opengl/quaternion_demo.cpp
+++ b/demos/opengl/quaternion_demo.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "quaternion_demo.h"
 #include "icosphere.h"
diff --git a/demos/opengl/quaternion_demo.h b/demos/opengl/quaternion_demo.h
index 5eb4fce..4c8f351 100644
--- a/demos/opengl/quaternion_demo.h
+++ b/demos/opengl/quaternion_demo.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_QUATERNION_DEMO_H
 #define EIGEN_QUATERNION_DEMO_H
diff --git a/demos/opengl/trackball.cpp b/demos/opengl/trackball.cpp
index 62e7168..dfa22a5 100644
--- a/demos/opengl/trackball.cpp
+++ b/demos/opengl/trackball.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "trackball.h"
 #include "camera.h"
diff --git a/demos/opengl/trackball.h b/demos/opengl/trackball.h
index dda235f..a0026ba 100644
--- a/demos/opengl/trackball.h
+++ b/demos/opengl/trackball.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TRACKBALL_H
 #define EIGEN_TRACKBALL_H
diff --git a/doc/AsciiQuickReference.txt b/doc/AsciiQuickReference.txt
index 0256c81..9564b6a 100644
--- a/doc/AsciiQuickReference.txt
+++ b/doc/AsciiQuickReference.txt
@@ -50,12 +50,6 @@
 // Matrix slicing and blocks. All expressions listed here are read/write.
 // Templated size versions are faster. Note that Matlab is 1-based (a size N
 // vector is x(1)...x(N)).
-/******************************************************************************/
-/*                  PLEASE HELP US IMPROVING THIS SECTION                     */
-/* Eigen 3.4 supports a much improved API for sub-matrices, including,        */
-/* slicing and indexing from arrays:                                          */
-/* http://eigen.tuxfamily.org/dox-devel/group__TutorialSlicingIndexing.html   */
-/******************************************************************************/
 // Eigen                           // Matlab
 x.head(n)                          // x(1:n)
 x.head<n>()                        // x(1:n)
@@ -88,26 +82,34 @@
 P.bottomLeftCorner<rows,cols>()    // P(end-rows+1:end, 1:cols)
 P.bottomRightCorner<rows,cols>()   // P(end-rows+1:end, end-cols+1:end)
 
+// Slicing and indexing with operator() (Eigen 3.4+).
+// using namespace Eigen::indexing; provides seq, seqN, all, last, lastN.
+// Eigen                           // Matlab
+x(seq(i, j))                       // x(i+1 : j+1)
+x(seq(i, j, step))                 // x(i+1 : step : j+1)
+x(seqN(i, n))                      // x(i+1 : i+n)
+x(lastN(n))                        // x(end-n+1 : end)
+P(all, j)                          // P(:, j+1)
+P(seq(0, last, 2), all)            // P(1:2:end, :)
+P(ind, all)                        // P(ind, :)      // ind: vector/array of indices (0-based)
+
 // Of particular note is Eigen's swap function which is highly optimized.
 // Eigen                           // Matlab
 R.row(i) = P.col(j);               // R(i, :) = P(:, j)
-R.col(j1).swap(mat1.col(j2));      // R(:, [j1 j2]) = R(:, [j2, j1])
+R.col(j1).swap(R.col(j2));         // R(:, [j1 j2]) = R(:, [j2, j1])
 
-// Views, transpose, etc;
-/******************************************************************************/
-/*                  PLEASE HELP US IMPROVING THIS SECTION                     */
-/* Eigen 3.4 supports a new API for reshaping:                                */
-/* http://eigen.tuxfamily.org/dox-devel/group__TutorialReshape.html           */
-/******************************************************************************/
+// Views, transpose, reshape, etc.
 // Eigen                           // Matlab
 R.adjoint()                        // R'
 R.transpose()                      // R.' or conj(R')       // Read-write
 R.diagonal()                       // diag(R)               // Read-write
 x.asDiagonal()                     // diag(x)
 R.transpose().colwise().reverse()  // rot90(R)              // Read-write
-R.rowwise().reverse()              // fliplr(R)
-R.colwise().reverse()              // flipud(R)
+R.rowwise().reverse()              // fliplr(R)             // Read-write
+R.colwise().reverse()              // flipud(R)             // Read-write
 R.replicate(i,j)                   // repmat(P,i,j)
+R.reshaped(m,n)                    // reshape(R,m,n)        // Read-write, column-major view
+R.reshaped()                       // R(:)                  // Read-write, 1D column-major view
 
 
 // All the same as Matlab, but matlab doesn't have *= style operators.
@@ -122,11 +124,11 @@
 // Vectorized operations on each element independently
 // Eigen                       // Matlab
 R = P.cwiseProduct(Q);         // R = P .* Q
-R = P.array() * s.array();     // R = P .* s
+R = P.array() * s;             // R = P .* s
 R = P.cwiseQuotient(Q);        // R = P ./ Q
 R = P.array() / Q.array();     // R = P ./ Q
-R = P.array() + s.array();     // R = P + s
-R = P.array() - s.array();     // R = P - s
+R = P.array() + s;             // R = P + s
+R = P.array() - s;             // R = P - s
 R.array() += s;                // R = R + s
 R.array() -= s;                // R = R - s
 R.array() < Q.array();         // R < Q
@@ -154,7 +156,8 @@
 R.array().abs2()               // abs(P.^2)
 (R.array() < s).select(P,Q );  // (R < s ? P : Q)
 R = (Q.array()==0).select(P,R) // R(Q==0) = P(Q==0)
-R = P.unaryExpr(ptr_fun(func)) // R = arrayfun(func, P)   // with: scalar func(const scalar &x);
+R = P.unaryExpr([](float x) -> float { return func(x); }); // R = arrayfun(func, P). The lambda must
+                                                           // preserve P's scalar type.
 
 
 // Reductions.
@@ -180,7 +183,7 @@
 
 // Dot products, norms, etc.
 // Eigen                  // Matlab
-x.norm()                  // norm(x).    Note that norm(R) doesn't work in Eigen.
+x.norm()                  // norm(x).    Note: R.norm() is the Frobenius norm, not Matlab's norm(R).
 x.squaredNorm()           // dot(x, x)   Note the equivalence is not true for complex
 x.dot(y)                  // dot(x, y)
 x.cross(y)                // cross(x, y) Requires #include <Eigen/Geometry>
@@ -207,17 +210,21 @@
 Matrix2i::Map(data) = 2*mat2x2;           // overwrite elements of data with 2*mat2x2
 MatrixXi::Map(data, 2, 2) += mat2x2;      // adds mat2x2 to elements of data (alternative syntax if size is not know at compile time)
 
-// Solve Ax = b. Result stored in x. Matlab: x = A \ b.
-x = A.ldlt().solve(b));  // A sym. p.s.d.    #include <Eigen/Cholesky>
-x = A.llt() .solve(b));  // A sym. p.d.      #include <Eigen/Cholesky>
-x = A.lu()  .solve(b));  // Stable and fast. #include <Eigen/LU>
-x = A.qr()  .solve(b));  // No pivoting.     #include <Eigen/QR>
-x = A.svd() .solve(b));  // Stable, slowest. #include <Eigen/SVD>
-// .ldlt() -> .matrixL() and .matrixD()
-// .llt()  -> .matrixL()
-// .lu()   -> .matrixL() and .matrixU()
-// .qr()   -> .matrixQ() and .matrixR()
-// .svd()  -> .matrixU(), .singularValues(), and .matrixV()
+// Solve A*xd = bd. Result stored in xd. Matlab: xd = A \ bd.
+Vector3d bd, xd;                              // A is double, so the RHS and result are too.
+xd = A.ldlt().solve(bd);                      // A sym. p.s.d.       #include <Eigen/Cholesky>
+xd = A.llt().solve(bd);                       // A sym. p.d.         #include <Eigen/Cholesky>
+xd = A.lu().solve(bd);                        // A invertible; fast. #include <Eigen/LU>
+xd = A.householderQr().solve(bd);             // Least squares, full rank.       #include <Eigen/QR>
+xd = A.completeOrthogonalDecomposition()
+      .solve(bd);                             // Least squares, rank-deficient OK. #include <Eigen/QR>
+xd = A.bdcSvd<ComputeThinU |
+              ComputeThinV>().solve(bd);      // Most robust, slowest. #include <Eigen/SVD>
+// .ldlt()             -> .matrixL() and .vectorD()
+// .llt()              -> .matrixL()
+// .lu()               -> .matrixLU(), .permutationP()
+// .householderQr()    -> .householderQ() and .matrixQR()
+// .bdcSvd<...>()      -> .matrixU(), .singularValues(), and .matrixV()
 
 // Eigenvalue problems
 // Eigen                          // Matlab
diff --git a/doc/B01_Experimental.dox b/doc/B01_Experimental.dox
index e1f031d..13ddef0 100644
--- a/doc/B01_Experimental.dox
+++ b/doc/B01_Experimental.dox
@@ -6,46 +6,32 @@
 
 \section Experimental_summary Summary
 
-With the 2.0 release, Eigen's API is, to a large extent, stable. However, we wish to retain the freedom to make API incompatible changes. To that effect, we call many parts of Eigen "experimental" which means that they are not subject to API stability guarantee.
+Most of %Eigen's public API is stable: since %Eigen 5.0 releases follow
+<a href="https://semver.org">semantic versioning</a>, so API-breaking changes to supported,
+documented features only happen in major releases. However, some parts of %Eigen are explicitly
+\em experimental, meaning that they are not covered by this stability guarantee.
 
-Our goal is that for the 2.1 release (expected in July 2009) most of these parts become API-stable too.
-
-We are aware that API stability is a major concern for our users. That's why it's a priority for us to reach it, but at the same time we're being serious about not calling Eigen API-stable too early.
-
-Experimental features may at any time:
+Experimental features may, in any release:
 \li be removed;
 \li be subject to an API incompatible change;
 \li introduce API or ABI incompatible changes in your own code if you let them affect your API or ABI.
 
-\section Experimental_modules Experimental modules
+\section Experimental_what What is experimental?
 
-The following modules are considered entirely experimental, and we make no firm API stability guarantee about them for the time being:
-\li SVD
-\li QR
-\li Cholesky
-\li Sparse
-\li Geometry (this one should be mostly stable, but it's a little too early to make a formal guarantee)
+\li Features whose documentation carries the explicit warning "This is not considered to be part of
+    the stable public API yet", which links to this page.
+\li Everything in the \c Eigen::internal namespace, and the private implementation headers under
+    <tt>Eigen/src/</tt> and <tt>contrib/Eigen/src/</tt>. Include the public module headers such
+    as <tt><Eigen/Core></tt> instead; names not reachable through them are implementation details,
+    even where a header does not mechanically enforce this.
+\li The modules under <a href="contrib/index.html"><tt>contrib/Eigen/</tt></a>. These are
+    contributed modules maintained with looser API-stability guarantees than the main library.
+    "Contrib" does not mean low quality or low usage — the Tensor module, for instance, is a
+    foundational dependency of TensorFlow — but their APIs may evolve between minor releases.
 
-\section Experimental_core Experimental parts of the Core module
-
-In the Core module, the only classes subject to ABI stability guarantee (meaning that you can use it for data members in your public ABI) is:
-\li Matrix
-\li Map
-
-All other classes offer no ABI guarantee, e.g. the layout of their data can be changed.
-
-The only classes subject to (even partial) API stability guarantee (meaning that you can safely construct and use objects) are:
-\li MatrixBase : partial API stability (see below)
-\li Matrix : full API stability (except for experimental stuff inherited from MatrixBase)
-\li Map : full API stability (except for experimental stuff inherited from MatrixBase)
-
-All other classes offer no direct API guarantee, e.g. their methods can be changed; however notice that most classes inherit MatrixBase and that this is where most of their API comes from -- so in practice most of the API is stable.
-
-A few MatrixBase methods are considered experimental, hence not part of any API stability guarantee:
-\li all methods documented as internal
-\li all methods hidden in the Doxygen documentation
-\li all methods marked as experimental
-\li all methods defined in experimental modules
+Undocumented behavior of otherwise stable classes (for example, the exact layout of a
+decomposition's internal storage as exposed by low-level accessors) should likewise not be relied
+upon.
 
 */
 
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index 6178d4b..9a4f8cd 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 project(EigenDoc)
 
 set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL TRUE)
@@ -37,16 +40,16 @@
   ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
 )
 
-set(EIGEN_DOXY_PROJECT_NAME             "Eigen-unsupported")
-set(EIGEN_DOXY_OUTPUT_DIRECTORY_SUFFIX  "/unsupported")
-set(EIGEN_DOXY_INPUT                    "\"${Eigen_SOURCE_DIR}/unsupported/doc\" \"${Eigen_SOURCE_DIR}/unsupported/Eigen\"")
+set(EIGEN_DOXY_PROJECT_NAME             "Eigen-Contrib")
+set(EIGEN_DOXY_OUTPUT_DIRECTORY_SUFFIX  "/contrib")
+set(EIGEN_DOXY_INPUT                    "\"${Eigen_SOURCE_DIR}/contrib/doc\" \"${Eigen_SOURCE_DIR}/contrib/Eigen\"")
 set(EIGEN_DOXY_HTML_COLORSTYLE_HUE      "0")
 set(EIGEN_DOXY_TAGFILES                 "\"${Eigen_BINARY_DIR}/doc/Eigen.doxytags=..\"")
 #set(EIGEN_DOXY_TAGFILES                 "")
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
-  ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile-unsupported
+  ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile-contrib
 )
 
 configure_file(
@@ -65,8 +68,8 @@
 )
 
 configure_file(
-  ${Eigen_SOURCE_DIR}/unsupported/doc/eigendoxy_layout.xml.in
-  ${Eigen_BINARY_DIR}/doc/unsupported/eigendoxy_layout.xml
+  ${Eigen_SOURCE_DIR}/contrib/doc/eigendoxy_layout.xml.in
+  ${Eigen_BINARY_DIR}/doc/contrib/eigendoxy_layout.xml
 )
 
 set(examples_targets "")
@@ -91,32 +94,36 @@
 )
 
 add_custom_target(
-  doc-unsupported-prerequisites
+  doc-contrib-prerequisites
   ALL
-  COMMAND ${CMAKE_COMMAND} -E make_directory ${Eigen_BINARY_DIR}/doc/html/unsupported
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Eigen_Silly_Professor_64x64.png  ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2pnode.png                    ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
-  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2node.png                     ${CMAKE_CURRENT_BINARY_DIR}/html/unsupported/
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${Eigen_BINARY_DIR}/doc/html/contrib
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Eigen_Silly_Professor_64x64.png  ${CMAKE_CURRENT_BINARY_DIR}/html/contrib/
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2pnode.png                    ${CMAKE_CURRENT_BINARY_DIR}/html/contrib/
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ftv2node.png                     ${CMAKE_CURRENT_BINARY_DIR}/html/contrib/
   WORKING_DIRECTORY ${Eigen_BINARY_DIR}/doc
 )
 
 add_dependencies(doc-eigen-prerequisites all_snippets all_examples)
-add_dependencies(doc-unsupported-prerequisites unsupported_snippets unsupported_examples)
+add_dependencies(doc-contrib-prerequisites contrib_snippets contrib_examples)
 
 add_custom_target(doc ALL
   COMMAND doxygen
-  COMMAND doxygen Doxyfile-unsupported
+  COMMAND doxygen Doxyfile-contrib
   COMMAND ${CMAKE_COMMAND} -E copy ${Eigen_BINARY_DIR}/doc/html/group__TopicUnalignedArrayAssert.html ${Eigen_BINARY_DIR}/doc/html/TopicUnalignedArrayAssert.html
   COMMAND ${CMAKE_COMMAND} -E rename html eigen-doc
-  COMMAND ${CMAKE_COMMAND} -E remove eigen-doc/eigen-doc.tgz eigen-doc/unsupported/_formulas.log eigen-doc/_formulas.log
+  COMMAND ${CMAKE_COMMAND} -E remove eigen-doc/eigen-doc.tgz eigen-doc/contrib/_formulas.log eigen-doc/_formulas.log
   COMMAND ${CMAKE_COMMAND} -E tar cfz eigen-doc.tgz eigen-doc
   COMMAND ${CMAKE_COMMAND} -E rename eigen-doc.tgz eigen-doc/eigen-doc.tgz
   COMMAND ${CMAKE_COMMAND} -E rename eigen-doc html
   WORKING_DIRECTORY ${Eigen_BINARY_DIR}/doc)
 
-add_dependencies(doc doc-eigen-prerequisites doc-unsupported-prerequisites)
+add_dependencies(doc doc-eigen-prerequisites doc-contrib-prerequisites)
 
-add_custom_target(install-doc ALL
-  COMMAND ${CMAKE_COMMAND} -E copy_directory ${Eigen_BINARY_DIR}/doc ${CMAKE_INSTALL_FULL_DOCDIR}
-)
-add_dependencies(install-doc doc)
+# This target writes below CMAKE_INSTALL_PREFIX like any install rule, so it
+# follows EIGEN_INSTALL: with the option off, Eigen places no file there.
+if(EIGEN_INSTALL)
+  add_custom_target(install-doc ALL
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${Eigen_BINARY_DIR}/doc ${CMAKE_INSTALL_FULL_DOCDIR}
+  )
+  add_dependencies(install-doc doc)
+endif()
diff --git a/doc/CoeffwiseMathFunctionsTable.dox b/doc/CoeffwiseMathFunctionsTable.dox
index cda19d9..cf1dcd9 100644
--- a/doc/CoeffwiseMathFunctionsTable.dox
+++ b/doc/CoeffwiseMathFunctionsTable.dox
@@ -23,7 +23,6 @@
 foo(a[i]);
 \endcode
 means that the STL's function \c std::foo will be potentially called if it is compatible with the underlying scalar type. If not, then the user must ensure that an overload of the function foo is available for the given scalar type (usually defined in the same namespace as the given scalar type).
-This also means that, unless specified, if the function \c std::foo is available only in some recent c++ versions (e.g., c++11), then the respective %Eigen's function/method will be usable on standard types only if the compiler support the required c++ version.
 
 <table class="manual-hl">
 <tr>
@@ -124,7 +123,7 @@
   </td>
   <td>natural (base \f$ e \f$) logarithm of 1 plus \n the given number (\f$ \ln({1+a_i}) \f$)</td>
   <td>built-in generic implementation based on \c log,\n
-  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/log1p">\c std::log1p </a>; \cpp11</td>
+  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/log1p">\c std::log1p </a></td>
   <td></td>
 </tr>
 <tr>
@@ -141,6 +140,21 @@
   <td></td>
 </tr>
 <tr>
+  <td class="code">
+  \anchor cwisetable_ldexp
+  a.\link ArrayBase::ldexp ldexp\endlink(e); \n
+  \link Eigen::ldexp ldexp\endlink(a,e);
+  </td>
+  <td>multiplies each coefficient by \f$ 2^{e} \f$ for an integer \c e (\f$ a_i \cdot 2^{e} \f$); \n
+  exact — the floating-point exponent is adjusted directly, so the result \n
+  is correct (including denormals) even when \f$ 2^{e} \f$ itself is not representable</td>
+  <td class="code">
+  using <a href="http://en.cppreference.com/w/cpp/numeric/math/ldexp">std::ldexp</a>; \n
+  ldexp(a[i],e);
+  </td>
+  <td>SSE2, AVX (f,d)</td>
+</tr>
+<tr>
 <th colspan="4">Power functions</th>
 </tr>
 <tr>
@@ -418,7 +432,7 @@
   </td>
   <td>nearest integer, \n rounding away from zero in halfway cases</td>
   <td>built-in generic implementation \n based on \c floor and \c ceil,\n
-  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/round">\c std::round </a>; \cpp11</td>
+  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/round">\c std::round </a></td>
   <td>SSE4,AVX,ZVector (f,d)</td>
 </tr>
 <tr>
@@ -428,7 +442,7 @@
   \link Eigen::rint rint\endlink(a);
   </td>
   <td>nearest integer, \n rounding to nearest even in halfway cases</td>
-  <td>built-in generic implementation using <a href="http://en.cppreference.com/w/cpp/numeric/math/rint">\c std::rint </a>; \cpp11
+  <td>built-in generic implementation using <a href="http://en.cppreference.com/w/cpp/numeric/math/rint">\c std::rint </a>
   or <a href="http://en.cppreference.com/w/c/numeric/math/rint">\c rintf </a>; </td>
   <td>SSE4,AVX (f,d)</td>
 </tr>
@@ -446,7 +460,7 @@
   </td>
   <td>checks if the given number has finite value</td>
   <td>built-in generic implementation,\n
-  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/isfinite">\c std::isfinite </a>; \cpp11</td>
+  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/isfinite">\c std::isfinite </a></td>
   <td></td>
 </tr>
 <tr>
@@ -457,7 +471,7 @@
   </td>
   <td>checks if the given number is infinite</td>
   <td>built-in generic implementation,\n
-  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/isinf">\c std::isinf </a>; \cpp11</td>
+  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/isinf">\c std::isinf </a></td>
   <td></td>
 </tr>
 <tr>
@@ -468,13 +482,93 @@
   </td>
   <td>checks if the given number is not a number</td>
   <td>built-in generic implementation,\n
-  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/isnan">\c std::isnan </a>; \cpp11</td>
+  plus \c using <a href="http://en.cppreference.com/w/cpp/numeric/math/isnan">\c std::isnan </a></td>
+  <td></td>
+</tr>
+<tr>
+  <td class="code">
+  \anchor cwisetable_less
+  a.\c operator<(b); \n
+  a.\c operator<(s);
+  </td>
+  <td>coefficient-wise less than comparison (\f$ a_i \lt b_i \f$). \n
+  \c a and \c b can be either an array or scalar.</td>
+  <td class="code">
+  a[i] < b[i];
+  </td>
+  <td></td>
+</tr>
+<tr>
+  <td class="code">
+  \anchor cwisetable_less_equal
+  a.\c operator<=(b); \n
+  a.\c operator<=(s);
+  </td>
+  <td>coefficient-wise less than or equal comparison (\f$ a_i \le b_i \f$). \n
+  \c a and \c b can be either an array or scalar.</td>
+  <td class="code">
+  a[i] <= b[i];
+  </td>
+  <td></td>
+</tr>
+<tr>
+  <td class="code">
+  \anchor cwisetable_greater
+  a.\c operator>(b); \n
+  a.\c operator>(s);
+  </td>
+  <td>coefficient-wise greater than comparison (\f$ a_i \gt b_i \f$). \n
+  \c a and \c b can be either an array or scalar.</td>
+  <td class="code">
+  a[i] > b[i];
+  </td>
+  <td></td>
+</tr>
+<tr>
+  <td class="code">
+  \anchor cwisetable_greater_equal
+  a.\c operator>=(b); \n
+  a.\c operator>=(s);
+  </td>
+  <td>coefficient-wise greater than or equal comparison (\f$ a_i \ge b_i \f$). \n
+  \c a and \c b can be either an array or scalar.</td>
+  <td class="code">
+  a[i] >= b[i];
+  </td>
+  <td></td>
+</tr>
+<tr>
+  <td class="code">
+  \anchor cwisetable_equal
+  a.\c operator==(b); \n
+  a.\c operator==(s);
+  </td>
+  <td>coefficient-wise equality comparison (\f$ a_i = b_i \f$). \n
+  \c a and \c b can be either an array or scalar. \n
+  \warning Performs exact comparison; prefer \c isApprox() for floating-point types.</td>
+  <td class="code">
+  a[i] == b[i];
+  </td>
+  <td></td>
+</tr>
+<tr>
+  <td class="code">
+  \anchor cwisetable_not_equal
+  a.\c operator!=(b); \n
+  a.\c operator!=(s);
+  </td>
+  <td>coefficient-wise not-equal comparison (\f$ a_i \ne b_i \f$). \n
+  \c a and \c b can be either an array or scalar. \n
+  \warning Performs exact comparison; prefer \c isApprox() for floating-point types.</td>
+  <td class="code">
+  a[i] != b[i];
+  </td>
   <td></td>
 </tr>
 <tr>
 <th colspan="4">Error and gamma functions</th>
 </tr>
-<tr> <td colspan="4">  Require \c \#include \c <unsupported/Eigen/SpecialFunctions> </td></tr>
+<tr> <td colspan="4">  Require \c \#include \c <contrib/Eigen/SpecialFunctions> </td></tr>
 <tr>
   <td class="code">
   \anchor cwisetable_erf
@@ -483,7 +577,7 @@
   </td>
   <td>error function</td>
   <td class="code">
-  using <a href="http://en.cppreference.com/w/cpp/numeric/math/erf">std::erf</a>; \cpp11 \n
+  using <a href="http://en.cppreference.com/w/cpp/numeric/math/erf">std::erf</a> \n
   erf(a[i]);
   </td>
   <td></td>
@@ -496,7 +590,7 @@
   </td>
   <td>complementary error function</td>
   <td class="code">
-  using <a href="http://en.cppreference.com/w/cpp/numeric/math/erfc">std::erfc</a>; \cpp11 \n
+  using <a href="http://en.cppreference.com/w/cpp/numeric/math/erfc">std::erfc</a> \n
   erfc(a[i]);
   </td>
   <td></td>
@@ -509,7 +603,7 @@
   </td>
   <td>natural logarithm of the gamma function</td>
   <td class="code">
-  using <a href="http://en.cppreference.com/w/cpp/numeric/math/lgamma">std::lgamma</a>; \cpp11 \n
+  using <a href="http://en.cppreference.com/w/cpp/numeric/math/lgamma">std::lgamma</a> \n
   lgamma(a[i]);
   </td>
   <td></td>
@@ -534,7 +628,7 @@
   <td><a href="https://en.wikipedia.org/wiki/Incomplete_gamma_function">lower incomplete gamma integral</a>
   \n \f$ \gamma(a_i,x_i)= \frac{1}{|a_i|} \int_{0}^{x_i}e^{\text{-}t} t^{a_i-1} \mathrm{d} t \f$</td>
   <td>
-  built-in for float and double,\n but requires \cpp11
+  built-in for float and double,\n built-in generic fallback
   </td>
   <td></td>
 </tr>
@@ -546,14 +640,14 @@
   <td><a href="https://en.wikipedia.org/wiki/Incomplete_gamma_function">upper incomplete gamma integral</a>
   \n \f$ \Gamma(a_i,x_i) = \frac{1}{|a_i|} \int_{x_i}^{\infty}e^{\text{-}t} t^{a_i-1} \mathrm{d} t \f$</td>
   <td>
-  built-in for float and double,\n but requires \cpp11
+  built-in for float and double,\n built-in generic fallback
   </td>
   <td></td>
 </tr>
 <tr>
 <th colspan="4">Special functions</th>
 </tr>
-<tr> <td colspan="4">  Require \c \#include \c <unsupported/Eigen/SpecialFunctions> </td></tr>
+<tr> <td colspan="4">  Require \c \#include \c <contrib/Eigen/SpecialFunctions> </td></tr>
 <tr>
   <td class="code">
   \anchor cwisetable_polygamma
@@ -574,7 +668,7 @@
   </td>
   <td><a href="https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function">regularized incomplete beta function</a></td>
   <td>
-  built-in for float and double,\n but requires \cpp11
+  built-in for float and double,\n built-in generic fallback
   </td>
   <td></td>
 </tr>
diff --git a/doc/CustomizingEigen_CustomScalar.dox b/doc/CustomizingEigen_CustomScalar.dox
index 672cfc3..c774009 100644
--- a/doc/CustomizingEigen_CustomScalar.dox
+++ b/doc/CustomizingEigen_CustomScalar.dox
@@ -3,8 +3,10 @@
 /** \page TopicCustomizing_CustomScalar Using custom scalar types
 \anchor user_defined_scalars
 
-By default, Eigen currently supports standard floating-point types (\c float, \c double, \c std::complex<float>, \c std::complex<double>, \c long \c double), as well as all native integer types (e.g., \c int, \c unsigned \c int, \c short, etc.), and \c bool.
-On x86-64 systems, \c long \c double permits to locally enforces the use of x87 registers with extended accuracy (in comparison to SSE).
+By default, Eigen supports the standard floating-point types (\c float, \c double, \c long \c double, \c std::complex<float>, \c std::complex<double>), all native integer types (e.g., \c int, \c unsigned \c int, \c short, etc.), and \c bool.
+%Eigen also ships with two reduced-precision floating-point types of its own: \c Eigen::half (IEEE fp16) and \c Eigen::bfloat16.
+On x86-64 systems, \c long \c double permits to locally enforce the use of x87 registers with extended accuracy (in comparison to SSE).
+See \ref TopicScalarTypes for an overview.
 
 In order to add support for a custom type \c T you need:
 -# make sure the common operator (+,-,*,/,etc.) are supported by the type \c T
@@ -14,7 +16,7 @@
 
 The math function should be defined in the same namespace than \c T, or in the \c std namespace though that second approach is not recommended.
 
-Here is a concrete example adding support for the Adolc's \c adouble type. <a href="https://projects.coin-or.org/ADOL-C">Adolc</a> is an automatic differentiation library. The type \c adouble is basically a real value tracking the values of any number of partial derivatives.
+Here is a concrete example adding support for the Adolc's \c adouble type. <a href="https://github.com/coin-or/ADOL-C">Adolc</a> is an automatic differentiation library. The type \c adouble is basically a real value tracking the values of any number of partial derivatives.
 
 \code
 #ifndef ADOLCSUPPORT_H
diff --git a/doc/CustomizingEigen_Functors.dox b/doc/CustomizingEigen_Functors.dox
new file mode 100644
index 0000000..ee1ad09
--- /dev/null
+++ b/doc/CustomizingEigen_Functors.dox
@@ -0,0 +1,94 @@
+namespace Eigen {
+
+/** \page TopicCustomizing_Functors Writing custom functors
+
+Several Eigen extension points accept a user-provided function object, or functor. This is often the lightest way to
+customize an expression without defining a new expression type.
+
+\section CustomFunctors_Where Where functors are used
+
+Common entry points include:
+
+- \link MatrixBase::unaryExpr unaryExpr()\endlink for coefficient-wise unary operations.
+- \link MatrixBase::binaryExpr binaryExpr()\endlink for coefficient-wise binary operations.
+- \link DenseBase::NullaryExpr NullaryExpr()\endlink for procedural matrices whose coefficients are generated on
+  demand. See \ref TopicCustomizing_NullaryExpr for larger examples.
+- \link DenseBase::redux redux()\endlink and \link VectorwiseOp::redux colwise()/rowwise().redux()\endlink for custom
+  reductions. See \ref TutorialReductionsVisitorsBroadcastingReductionsUserdefined for a tutorial example.
+
+\section CustomFunctors_ScalarInterface Scalar interface
+
+At minimum, a functor provides an \c operator() matching the expression kind:
+
+\code
+struct clamp {
+  double lo, hi;
+  double operator()(double x) const { return x < lo ? lo : (hi < x ? hi : x); }
+};
+
+struct add_scaled {
+  double scale;
+  double operator()(double a, double b) const { return a + scale * b; }
+};
+
+struct checkerboard {
+  double operator()(Eigen::Index i, Eigen::Index j) const { return ((i + j) % 2) ? -1.0 : 1.0; }
+};
+\endcode
+
+The result type is deduced from \c operator() and may differ from the input scalar type.
+Binary functors can rely on Eigen's scalar binary-op traits when the return type follows the usual scalar rules; custom
+mixed-scalar operations may need a ScalarBinaryOpTraits specialization.
+
+Functors used with \c redux() must implement an associative binary operation and return the same scalar type as the
+expression, because Eigen may combine coefficients in an order chosen by the evaluator.
+
+\section CustomFunctors_Traits Cost and vectorization traits
+
+Eigen assigns conservative defaults to unknown functors:
+
+\code
+template <typename T>
+struct functor_traits {
+  enum { Cost = 10, PacketAccess = false, IsRepeatable = false };
+};
+\endcode
+
+For performance-sensitive functors, specialize \c Eigen::internal::functor_traits for your functor:
+
+\code
+namespace Eigen {
+namespace internal {
+template <>
+struct functor_traits<clamp> {
+  enum { Cost = 3 * NumTraits<double>::AddCost, PacketAccess = false };
+};
+}  // namespace internal
+}  // namespace Eigen
+\endcode
+
+\c Cost is an approximate scalar cost used by Eigen's expression evaluators. \c PacketAccess may be set to \c true only
+when the functor also provides packet overloads compatible with the packet types used by the relevant scalar type.
+Unary and binary packetized functors usually provide a \c packetOp() member; reduction functors that support packet
+reductions also provide \c predux().
+
+Most user functors should start with scalar-only code and leave \c PacketAccess set to \c false. That keeps the functor
+portable and lets Eigen use the scalar path for that operation while preserving vectorization opportunities elsewhere in
+the expression.
+
+\section CustomFunctors_State Capturing state
+
+Functor objects are copied into expression objects and may be evaluated later. Store any captured data so that it
+outlives the expression evaluation. For example, a nullary functor producing a view into another matrix should either
+store a safe reference to an object owned by the caller or require the caller to evaluate the expression before the
+referenced object goes out of scope.
+
+\section CustomFunctors_WhenNot When a functor is not enough
+
+If the expression needs a new shape, a custom nested expression type, or evaluator-specific behavior that cannot be
+expressed coefficient by coefficient, see \ref TopicNewExpressionType. For many procedural matrices and indexed views,
+\ref TopicCustomizing_NullaryExpr is simpler than a new expression type.
+
+*/
+
+}
diff --git a/doc/CustomizingEigen_NullaryExpr.dox b/doc/CustomizingEigen_NullaryExpr.dox
index 37c8dcd..45a4a1a 100644
--- a/doc/CustomizingEigen_NullaryExpr.dox
+++ b/doc/CustomizingEigen_NullaryExpr.dox
@@ -56,6 +56,10 @@
 
 \section NullaryExpr_Indexing Example 2: indexing rows and columns
 
+\note Since %Eigen 3.4, indexing a matrix with arrays of row and column indices is directly supported
+through \c operator(), see \ref TutorialSlicingIndexing. The example below remains instructive as a
+demonstration of what can be built from nullary expressions.
+
 The goal here is to mimic MatLab's ability to index a matrix through two vectors of indices referencing the rows and columns to be picked respectively, like this:
 
 \snippet nullary_indexing.out main1
diff --git a/doc/CustomizingEigen_Plugins.dox b/doc/CustomizingEigen_Plugins.dox
index 9ab0200..4957fa1 100644
--- a/doc/CustomizingEigen_Plugins.dox
+++ b/doc/CustomizingEigen_Plugins.dox
@@ -20,14 +20,14 @@
 Here is an example of an extension file for adding methods to MatrixBase: \n
 \b MatrixBaseAddons.h
 \code
-inline Scalar at(uint i, uint j) const { return this->operator()(i,j); }
-inline Scalar& at(uint i, uint j) { return this->operator()(i,j); }
-inline Scalar at(uint i) const { return this->operator[](i); }
-inline Scalar& at(uint i) { return this->operator[](i); }
+inline Scalar at(Index i, Index j) const { return this->operator()(i,j); }
+inline Scalar& at(Index i, Index j) { return this->operator()(i,j); }
+inline Scalar at(Index i) const { return this->operator[](i); }
+inline Scalar& at(Index i) { return this->operator[](i); }
 
 inline RealScalar squaredLength() const { return squaredNorm(); }
 inline RealScalar length() const { return norm(); }
-inline RealScalar invLength(void) const { return fast_inv_sqrt(squaredNorm()); }
+inline RealScalar invLength() const { return numext::rsqrt(squaredNorm()); }
 
 template<typename OtherDerived>
 inline Scalar squaredDistanceTo(const MatrixBase<OtherDerived>& other) const
@@ -35,15 +35,15 @@
 
 template<typename OtherDerived>
 inline RealScalar distanceTo(const MatrixBase<OtherDerived>& other) const
-{ return internal::sqrt(derived().squaredDistanceTo(other)); }
+{ return numext::sqrt(derived().squaredDistanceTo(other)); }
 
 inline void scaleTo(RealScalar l) { RealScalar vl = norm(); if (vl>1e-9) derived() *= (l/vl); }
 
 inline Transpose<Derived> transposed() {return this->transpose();}
 inline const Transpose<Derived> transposed() const {return this->transpose();}
 
-inline uint minComponentId(void) const  { int i; this->minCoeff(&i); return i; }
-inline uint maxComponentId(void) const  { int i; this->maxCoeff(&i); return i; }
+inline Index minComponentId() const  { Index i; this->minCoeff(&i); return i; }
+inline Index maxComponentId() const  { Index i; this->maxCoeff(&i); return i; }
 
 template<typename OtherDerived>
 void makeFloor(const MatrixBase<OtherDerived>& other) { derived() = derived().cwiseMin(other.derived()); }
@@ -52,11 +52,11 @@
 
 const CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const Derived, const ConstantReturnType>
 operator+(const Scalar& scalar) const
-{ return CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const Derived, const ConstantReturnType>(derived(), Constant(rows(),cols(),scalar)); }
+{ return CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const Derived, const ConstantReturnType>(derived(), Derived::Constant(rows(),cols(),scalar)); }
 
 friend const CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const ConstantReturnType, Derived>
 operator+(const Scalar& scalar, const MatrixBase<Derived>& mat)
-{ return CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const ConstantReturnType, Derived>(Constant(rows(),cols(),scalar), mat.derived()); }
+{ return CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const ConstantReturnType, Derived>(Derived::Constant(mat.rows(),mat.cols(),scalar), mat.derived()); }
 \endcode
 
 Then one can add the following declaration in the config.h or whatever prerequisites header file of his project:
diff --git a/doc/DenseDecompositionBenchmark.dox b/doc/DenseDecompositionBenchmark.dox
index f5bfc9c..3bf796e 100644
--- a/doc/DenseDecompositionBenchmark.dox
+++ b/doc/DenseDecompositionBenchmark.dox
@@ -9,7 +9,7 @@
 This benchmark has been run on a laptop equipped with an Intel core i7 \@ 2,6 GHz, and compiled with clang with \b AVX and \b FMA instruction sets enabled but without multi-threading.
 It uses \b single \b precision \b float numbers. For double, you can get a good estimate by multiplying the timings by a factor 2.
 
-The square matrices are symmetric, and for the overconstrained matrices, the reported timmings include the cost to compute the symmetric covariance matrix \f$ A^T A \f$ for the first four solvers based on Cholesky and LU, as denoted by the \b * symbol (top-right corner part of the table).
+The square matrices are symmetric, and for the overconstrained matrices, the reported timings include the cost to compute the symmetric covariance matrix \f$ A^T A \f$ for the first four solvers based on Cholesky and LU, as denoted by the \b * symbol (top-right corner part of the table).
 Timings are in \b milliseconds, and factors are relative to the LLT decomposition which is the fastest but also the least general and robust.
 
 <table class="manual">
@@ -30,10 +30,11 @@
 <a name="note_ls">\b *: </a> This decomposition do not support direct least-square solving for over-constrained problems, and the reported timing include the cost to form the symmetric covariance matrix \f$ A^T A \f$.
 
 \b Observations:
- + LLT is always the fastest solvers.
+ + LLT is always the fastest solver.
  + For largely over-constrained problems, the cost of Cholesky/LU decompositions is dominated by the computation of the symmetric covariance matrix.
- + For large problem sizes, only the decomposition implementing a cache-friendly blocking strategy scale well. Those include LLT, PartialPivLU, HouseholderQR, and BDCSVD. This explain why for a 4k x 4k matrix, HouseholderQR is faster than LDLT. In the future, LDLT and ColPivHouseholderQR will also implement blocking strategies.
+ + For large problem sizes, only the decompositions implementing a cache-friendly blocking strategy scale well. Those include LLT, PartialPivLU, HouseholderQR, and BDCSVD. This explains why for a 4k x 4k matrix, HouseholderQR is faster than LDLT.
  + CompleteOrthogonalDecomposition is based on ColPivHouseholderQR and they thus achieve the same level of performance.
+ + FullPivLU and FullPivHouseholderQR are dramatically slower for large matrices due to the lack of blocking, and are not shown for the 4k x 4k case.
 
 The above table was originally generated by a benchmark tool. Feel free to write your own benchmark to generate a table matching your hardware, compiler, and favorite problem sizes.
 
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index 445fc0a..b029124 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -17,7 +17,7 @@
                          "lu_module=This is defined in the %LU module. \code #include <Eigen/LU> \endcode" \
                          "qr_module=This is defined in the %QR module. \code #include <Eigen/QR> \endcode" \
                          "svd_module=This is defined in the %SVD module. \code #include <Eigen/SVD> \endcode" \
-                         "specialfunctions_module=This is defined in the \b unsupported SpecialFunctions module. \code #include <Eigen/SpecialFunctions> \endcode" \
+                         "specialfunctions_module=This is defined in the \b contrib SpecialFunctions module. \code #include <contrib/Eigen/SpecialFunctions> \endcode" \
                          label=\bug \
                          "matrixworld=<a href='#matrixonly' style='color:green;text-decoration: none;'>*</a>" \
                          "arrayworld=<a href='#arrayonly' style='color:blue;text-decoration: none;'>*</a>" \
@@ -28,13 +28,12 @@
                          "nonstableyet=\warning This is not considered to be part of the stable public API yet. Changes may happen in future releases. See \ref Experimental \"Experimental parts of Eigen\"" \
                          "implsparsesolverconcept=This class follows the \link TutorialSparseSolverConcept sparse solver concept \endlink." \
                          blank= \
-                         "cpp11=<span class='cpp11'>[c++11]</span>" \
-                         "cpp14=<span class='cpp14'>[c++14]</span>" \
                          "cpp17=<span class='cpp17'>[c++17]</span>" \
                          "newin{1}=<span class='newin3x'>New in %Eigen \1.</span>" \
                          "eigenAutoToc=<!-- TOC placeholder -->" \
                          eigenManualPage=\defgroup
 EXTENSION_MAPPING      = .h=C++ \
+                         .inc=C++ \
                          no_extension=C++
 DISTRIBUTE_GROUP_DOC   = YES
 NUM_PROC_THREADS       = 0
@@ -64,8 +63,8 @@
                          ${Eigen_SOURCE_DIR}/doc/examples \
                          ${Eigen_SOURCE_DIR}/doc/special_examples \
                          ${Eigen_SOURCE_DIR}/doc/snippets \
-                         ${Eigen_SOURCE_DIR}/unsupported/doc/examples \
-                         ${Eigen_SOURCE_DIR}/unsupported/doc/snippets
+                         ${Eigen_SOURCE_DIR}/contrib/doc/examples \
+                         ${Eigen_SOURCE_DIR}/contrib/doc/snippets
 
 #                        ${Eigen_SOURCE_DIR}/Eigen/src/Core/products \
 #                        ${Eigen_SOURCE_DIR}/Eigen/src/Core/util/ForwardDeclarations.h \
@@ -95,10 +94,10 @@
                          ${Eigen_BINARY_DIR}/doc/examples \
                          ${Eigen_SOURCE_DIR}/doc/special_examples \
                          ${Eigen_BINARY_DIR}/doc/special_examples \
-                         ${Eigen_SOURCE_DIR}/unsupported/doc/snippets \
-                         ${Eigen_BINARY_DIR}/unsupported/doc/snippets \
-                         ${Eigen_SOURCE_DIR}/unsupported/doc/examples \
-                         ${Eigen_BINARY_DIR}/unsupported/doc/examples
+                         ${Eigen_SOURCE_DIR}/contrib/doc/snippets \
+                         ${Eigen_BINARY_DIR}/contrib/doc/snippets \
+                         ${Eigen_SOURCE_DIR}/contrib/doc/examples \
+                         ${Eigen_BINARY_DIR}/contrib/doc/examples
 IMAGE_PATH             = ${Eigen_BINARY_DIR}/doc/html
 # Prevent README.md from being considered a directory description (i.e. for Tensor).
 IMPLICIT_DIR_DOCS      = NO
@@ -127,11 +126,12 @@
                          EIGEN_QT_SUPPORT \
                          EIGEN_STRONG_INLINE=inline \
                          EIGEN_DEVICE_FUNC= \
-                         "EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR)=template<typename OtherDerived> const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> METHOD(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const;" \
+                         "EIGEN_MAKE_CWISE_UNARY_OP(METHOD,FUNCTOR,RETURN_TYPE)=const CwiseUnaryOp<FUNCTOR<Scalar>,const Derived> METHOD() const; using RETURN_TYPE=CwiseUnaryOp<FUNCTOR<Scalar>,const Derived>;" \
+                         "EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR)=template<typename OtherDerived> const CwiseBinaryOp<FUNCTOR<Scalar,typename OtherDerived::Scalar>, const Derived, const OtherDerived> METHOD(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const;" \
                          "EIGEN_CWISE_PRODUCT_RETURN_TYPE(LHS,RHS)=CwiseBinaryOp<internal::scalar_product_op<LHS::Scalar,RHS::Scalar>, const LHS, const RHS>" \
                          "EIGEN_CAT2(a,b)= a ## b" \
                          "EIGEN_CAT(a,b)=EIGEN_CAT2(a,b)" \
-                         "EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,OPNAME)=CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<LHS::Scalar, RHS::Scalar>, const LHS, const RHS>" \
+                         "EIGEN_CWISE_BINARY_RETURN_TYPE(LHS,RHS,FUNCTOR)=CwiseBinaryOp<FUNCTOR<LHS::Scalar,RHS::Scalar>, const LHS, const RHS>" \
                          EIGEN_ALIGN_TO_BOUNDARY(x)= \
                          "DOXCOMMA=," \
                          "EIGEN_STATIC_ASSERT(COND,MSG)="
diff --git a/doc/FunctionsTakingEigenTypes.dox b/doc/FunctionsTakingEigenTypes.dox
index 3e74546..9f40435 100644
--- a/doc/FunctionsTakingEigenTypes.dox
+++ b/doc/FunctionsTakingEigenTypes.dox
@@ -89,7 +89,7 @@
 <td>
 \verbinclude function_taking_ref.out
 </td></tr></table>
-In the first two calls to inv_cond, no copy occur because the memory layout of the arguments matches the memory layout accepted by Ref<MatrixXf>. However, in the last call, we have a generic expression that will be automatically evaluated into a temporary MatrixXf by the Ref<> object.
+In the first two calls to inv_cond, no copy occurs because the memory layout of the arguments matches the memory layout accepted by Ref<MatrixXf>. However, in the last call, we have a generic expression that will be automatically evaluated into a temporary MatrixXf by the Ref<> object.
 
 A Ref object can also be writable. Here is an example of a function computing the covariance matrix of two input matrices where each row is an observation:
 \code
@@ -103,7 +103,7 @@
 \endcode
 and here are two examples calling cov without any copy:
 \code
-MatrixXf m1, m2, m3
+MatrixXf m1, m2, m3;
 cov(m1, m2, m3);
 cov(m1.leftCols<3>(), m2.leftCols<3>(), m3.topLeftCorner<3,3>());
 \endcode
@@ -151,7 +151,7 @@
 \endcode
 the compiler will fail, because it is not possible to convert the expression returned by \c MatrixXf::block() into a non-const \c MatrixXf&. This is the case because the compiler wants to protect you from writing your result to a temporary object. In this special case this protection is not intended -- we want to write to a temporary object. So how can we overcome this problem? 
 
-The solution which is preferred at the moment is based on a little \em hack. One needs to pass a const reference to the matrix and internally the constness needs to be cast away. The correct implementation for C98 compliant compilers would be
+The solution which is preferred at the moment is based on a little \em hack. One needs to pass a const reference to the matrix and internally the constness needs to be cast away. This is also the pattern %Eigen itself uses internally for writable expression arguments. The correct implementation would be
 \code
 template <typename Derived, typename OtherDerived>
 void cov(const MatrixBase<Derived>& x, const MatrixBase<Derived>& y, MatrixBase<OtherDerived> const & C)
diff --git a/doc/HiPerformance.dox b/doc/HiPerformance.dox
index 662fc9a..dfdc381 100644
--- a/doc/HiPerformance.dox
+++ b/doc/HiPerformance.dox
@@ -3,7 +3,7 @@
 
 /** \page TopicWritingEfficientProductExpression Writing efficient matrix product expressions
 
-In general achieving good performance with Eigen does no require any special effort:
+In general achieving good performance with Eigen does not require any special effort:
 simply write your expressions in the most high level way. This is especially true
 for small fixed size matrices. For large matrices, however, it might be useful to
 take some care when writing your expressions in order to minimize useless evaluations
@@ -14,10 +14,10 @@
 all kind of matrix products and triangular solvers.
 
 Indeed, in Eigen we have implemented a set of highly optimized routines which are very similar
-to BLAS's ones. Unlike BLAS, those routines are made available to user via a high level and
+to BLAS's ones. Unlike BLAS, those routines are made available to users via a high level and
 natural API. Each of these routines can compute in a single evaluation a wide variety of expressions.
 Given an expression, the challenge is then to map it to a minimal set of routines.
-As explained latter, this mechanism has some limitations, and knowing them will allow
+As explained later, this mechanism has some limitations, and knowing them will allow
 you to write faster code by making your expressions more Eigen friendly.
 
 \section GEMM General Matrix-Matrix product (GEMM)
diff --git a/doc/InplaceDecomposition.dox b/doc/InplaceDecomposition.dox
index cb1c6d4..b722a24 100644
--- a/doc/InplaceDecomposition.dox
+++ b/doc/InplaceDecomposition.dox
@@ -2,7 +2,7 @@
 
 /** \eigenManualPage InplaceDecomposition Inplace matrix decompositions
 
-Starting from %Eigen 3.3, the LU, Cholesky, and QR decompositions can operate \em inplace, that is, directly within the given input matrix.
+Starting from %Eigen 3.3, the LU, Cholesky, and QR decompositions can operate \em inplace, that is, directly within the given input matrix; the Hessenberg, tridiagonal, Schur, and QZ reductions and the dense eigensolvers followed.
 This feature is especially useful when dealing with huge matrices, and or when the available memory is very limited (embedded systems).
 
 To this end, the respective decomposition class must be instantiated with a Ref<> matrix type, and the decomposition object must be constructed with the input matrix as argument. As an example, let us consider an inplace LU decomposition with partial pivoting.
@@ -103,13 +103,58 @@
 
 - class LLT
 - class LDLT
+- class BunchKaufman
 - class PartialPivLU
 - class FullPivLU
 - class HouseholderQR
 - class ColPivHouseholderQR
+- class RandColPivHouseholderQR
 - class FullPivHouseholderQR
 - class CompleteOrthogonalDecomposition
+- class RandCompleteOrthogonalDecomposition
+- class HessenbergDecomposition
+- class Tridiagonalization
+- class RealSchur
+- class ComplexSchur (complex \c MatrixType only)
+- class RealQZ
+- class ComplexQZ
+- class SelfAdjointEigenSolver
+- class GeneralizedSelfAdjointEigenSolver
+- class EigenSolver
+- class ComplexEigenSolver (complex \c MatrixType only)
+- class GeneralizedEigenSolver
+
+The factorizations store their packed factors in the input matrix, as in the LU example above. For the reductions
+and eigensolvers, the input matrix is used as the workspace of the algorithm; what it holds afterwards depends on
+the class:
+
+- HessenbergDecomposition and Tridiagonalization: the packed representation returned by packedMatrix().
+- RealSchur, ComplexSchur, RealQZ, and ComplexQZ: the (quasi-)triangular factors T, or S and T; the unitary
+  factors are stored in the decomposition object.
+- SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver: the eigenvectors when they are requested, and
+  eigenvectors() then refers to the input matrix; otherwise, unspecified values. The generalized solver also
+  factorizes \c B in place.
+- EigenSolver, ComplexEigenSolver, and GeneralizedEigenSolver: unspecified values; the results are stored in the
+  decomposition object.
+
+RealSchur may use a separate workspace even when instantiated with Ref<>. For an n-by-n matrix with n >= 128 and
+an outer stride in bytes divisible by 1024, it allocates a temporary padded matrix of n*(n+1) coefficients, performs
+the Hessenberg reduction and Schur iteration there, and copies T back to the bound input matrix. This also applies
+to compute(); computeFromHessenberg() uses the same padding policy for the Schur iteration. Zero inputs still
+incur the temporary allocation at these sizes and strides.
+
+To avoid this temporary, bind a Ref<> with an outer stride in bytes that is not divisible by 1024. For example,
+a 512-by-512 double matrix can use a 513-by-512 column-major backing matrix and bind its top 512 rows; the outer
+stride is then 513*sizeof(double) bytes. Defining EIGEN_NO_MALLOC, or disabling allocation or deallocation through
+EIGEN_RUNTIME_NO_MALLOC, also suppresses padding and uses the bound storage, which may be slower. These controls
+do not eliminate other allocations: construction and resizing of solver storage, forming Schur vectors, or
+evaluating input expressions may still require memory. Inplace decomposition does not guarantee allocation-free
+construction or computation.
+
+Since the decomposition object then refers to the input matrix, the input matrix must outlive it, as in the LU
+example. The QZ and generalized eigensolver classes take two matrices, and both must be passed as non-const
+lvalues to select the inplace constructor.
 
 */
 
-}
\ No newline at end of file
+}
diff --git a/doc/InsideEigenExample.dox b/doc/InsideEigenExample.dox
index 570ecbf..73fd1d9 100644
--- a/doc/InsideEigenExample.dox
+++ b/doc/InsideEigenExample.dox
@@ -82,26 +82,25 @@
 \code
   Eigen::VectorXf u(size);
 \endcode
-the constructor that is called is Matrix::Matrix(int), in src/Core/Matrix.h. Besides some assertions, all it does is to construct the \a m_storage member, which is of type DenseStorage\<float, Dynamic, Dynamic, 1\>.
+the constructor that is called is Matrix::Matrix(Index), in src/Core/Matrix.h. Besides some assertions, all it does is to construct the \a m_storage member, which is of type DenseStorage\<float, Dynamic, Dynamic, 1, 0\> (the last parameter carries the Options).
 
 You may wonder, isn't it overengineering to have the storage in a separate class? The reason is that the Matrix class template covers all kinds of matrices and vector: both fixed-size and dynamic-size. The storage method is not the same in these two cases. For fixed-size, the matrix coefficients are stored as a plain member array. For dynamic-size, the coefficients will be stored as a pointer to a dynamically-allocated array. Because of this, we need to abstract storage away from the Matrix class. That's DenseStorage.
 
-Let's look at this constructor, in src/Core/DenseStorage.h. You can see that there are many partial template specializations of DenseStorages here, treating separately the cases where dimensions are Dynamic or fixed at compile-time. The partial specialization that we are looking at is:
+Let's look at this constructor, in src/Core/DenseStorage.h. You can see that there are many partial template specializations of the DenseStorage implementation here, treating separately the cases where dimensions are Dynamic or fixed at compile-time. The partial specialization that we are looking at is the one for a dynamic size with a fixed number of columns:
 \code
-template<typename T, int Cols_> class DenseStorage<T, Dynamic, Dynamic, Cols_>
+template<typename T, int Cols, int Options> class DenseStorage_impl<T, Dynamic, Dynamic, Cols, Options>
 \endcode
 
-Here, the constructor called is DenseStorage::DenseStorage(int size, int rows, int columns)
-with size=50, rows=50, columns=1.
-
-Here is this constructor:
+Here, the constructor called is DenseStorage_impl(Index size, Index rows, Index cols)
+with size=50, rows=50, cols=1:
 \code
-inline DenseStorage(int size, int rows, int) : m_data(internal::aligned_new<T>(size)), m_rows(rows) {}
+constexpr DenseStorage_impl(Index size, Index rows, Index /*cols*/)
+    : m_data(conditional_aligned_new_auto<T, Align>(size)), m_rows(rows) {}
 \endcode
 
-Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), as you can see, we have our own internal::aligned_new defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it uses a platform-specific call to allocate a 128-bit-aligned array, as that is very useful for vectorization with both SSE2 and AltiVec. If vectorization is disabled, it amounts to the standard new[].
+Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), we have our own internal::conditional_aligned_new_auto defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it allocates a suitably aligned array (e.g. 16-byte-aligned for SSE2, more for AVX or AVX512), as that is very useful for vectorization. If no alignment is required, it amounts to the standard new[].
 
-As you can see, the constructor also sets the \a m_rows member to \a size. Notice that there is no \a m_columns member: indeed, in this partial specialization of DenseStorage, we know the number of columns at compile-time, since the Cols_ template parameter is different from Dynamic. Namely, in our case, Cols_ is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable.
+As you can see, the constructor also sets the \a m_rows member to \a rows. Notice that there is no \a m_cols member: indeed, in this partial specialization of DenseStorage_impl, we know the number of columns at compile-time, since the Cols template parameter is different from Dynamic. Namely, in our case, Cols is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable.
 
 When you call VectorXf::data() to get the pointer to the array of coefficients, it returns DenseStorage::data() which returns the \a m_data member.
 
@@ -131,7 +130,7 @@
 
 The return type of this operator is
 \code
-CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf>
+CwiseBinaryOp<internal::scalar_sum_op<float, float>, const VectorXf, const VectorXf>
 \endcode
 The CwiseBinaryOp class is our first encounter with an expression template. As we said, the operator+ doesn't by itself perform any computation, it just returns an abstract "sum of vectors" expression. Since there are also "difference of vectors" and "coefficient-wise product of vectors" expressions, we unify them all as "coefficient-wise binary operations", which we abbreviate as "CwiseBinaryOp". "Coefficient-wise" means that the operations is performed coefficient by coefficient. "binary" means that there are two operands -- we are adding two vectors with one another.
 
@@ -163,7 +162,7 @@
 v + w
 \endcode
 
-Now that MatrixBase is a good friend, let's write fully the prototype of the operator+ that gets called here (this code is from src/Core/MatrixBase.h):
+Now that MatrixBase is a good friend, let's write fully the prototype of the operator+ that gets called here (the actual declaration is generated by the EIGEN_MAKE_CWISE_BINARY_OP macro in the plugin file src/plugins/CommonCwiseBinaryOps.inc, included from within MatrixBase; slightly simplified, it amounts to):
 
 \code
 template<typename Derived>
@@ -172,7 +171,9 @@
   // ...
 
   template<typename OtherDerived>
-  const CwiseBinaryOp<internal::scalar_sum_op<typename internal::traits<Derived>::Scalar>, Derived, OtherDerived>
+  const CwiseBinaryOp<internal::scalar_sum_op<typename internal::traits<Derived>::Scalar,
+                                              typename internal::traits<OtherDerived>::Scalar>,
+                      const Derived, const OtherDerived>
   operator+(const MatrixBase<OtherDerived> &other) const;
 
   // ...
@@ -181,9 +182,9 @@
 
 Here of course, \a Derived and \a OtherDerived are VectorXf.
 
-As we said, CwiseBinaryOp is also used for other operations such as substration, so it takes another template parameter determining the operation that will be applied to coefficients. This template parameter is a functor, that is, a class in which we have an operator() so it behaves like a function. Here, the functor used is internal::scalar_sum_op. It is defined in src/Core/Functors.h.
+As we said, CwiseBinaryOp is also used for other operations such as subtraction, so it takes another template parameter determining the operation that will be applied to coefficients. This template parameter is a functor, that is, a class in which we have an operator() so it behaves like a function. Here, the functor used is internal::scalar_sum_op. It is defined in src/Core/functors/BinaryFunctors.h.
 
-Let us now explain the internal::traits here. The internal::scalar_sum_op class takes one template parameter: the type of the numbers to handle. Here of course we want to pass the scalar type (a.k.a. numeric type) of VectorXf, which is \c float. How do we determine which is the scalar type of \a Derived ? Throughout Eigen, all matrix and expression types define a typedef \a Scalar which gives its scalar type. For example, VectorXf::Scalar is a typedef for \c float. So here, if life was easy, we could find the numeric type of \a Derived as just
+Let us now explain the internal::traits here. The internal::scalar_sum_op class takes two template parameters: the types of the numbers to add (which may differ, e.g. when adding a real and a complex matrix). Here of course we want to pass the scalar type (a.k.a. numeric type) of VectorXf, which is \c float, twice. How do we determine which is the scalar type of \a Derived ? Throughout Eigen, all matrix and expression types define a typedef \a Scalar which gives its scalar type. For example, VectorXf::Scalar is a typedef for \c float. So here, if life was easy, we could find the numeric type of \a Derived as just
 \code
 typename Derived::Scalar
 \endcode
@@ -199,7 +200,7 @@
 {
   // ...
 
-  const CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf>
+  const CwiseBinaryOp<internal::scalar_sum_op<float, float>, const VectorXf, const VectorXf>
   operator+(const MatrixBase<VectorXf> &other) const;
 
   // ...
@@ -212,11 +213,6 @@
 
 \section Assignment The assignment
 
-<div class="warningbox">
-<strong>PLEASE HELP US IMPROVING THIS SECTION.</strong>
-This page reflects how %Eigen worked until 3.2, but since %Eigen 3.3 the assignment is more sophisticated as it involves an Assignment expression, and the creation of so called evaluator which are responsible for the evaluation of each kind of expressions.
-</div>
-
 At this point, the expression \a v + \a w has finished evaluating, so, in the process of compiling the line of code
 \code
 u = v + w;
@@ -226,272 +222,120 @@
 What operator= is being called here? The vector u is an object of class VectorXf, i.e. Matrix. In src/Core/Matrix.h, inside the definition of class Matrix, we see this:
 \code
     template<typename OtherDerived>
-    inline Matrix& operator=(const MatrixBase<OtherDerived>& other)
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Matrix& operator=(const DenseBase<OtherDerived>& other)
     {
-      eigen_assert(m_storage.data()!=0 && "you cannot use operator= with a non initialized matrix (instead use set()");
-      return Base::operator=(other.derived());
+      return Base::_set(other);
     }
 \endcode
-Here, Base is a typedef for MatrixBase\<Matrix\>. So, what is being called is the operator= of MatrixBase. Let's see its prototype in src/Core/MatrixBase.h:
+Here, Base is a typedef for PlainObjectBase\<Matrix\>. The _set() helper, in src/Core/PlainObjectBase.h, forwards to the central assignment entry point:
 \code
-    template<typename OtherDerived>
-    Derived& operator=(const MatrixBase<OtherDerived>& other);
+    internal::call_assignment(this->derived(), other.derived());
 \endcode
-Here, \a Derived is VectorXf (since u is a VectorXf) and \a OtherDerived is CwiseBinaryOp. More specifically, as explained in the previous section, \a OtherDerived is:
-\code
-CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf>
-\endcode
-So the full prototype of the operator= being called is:
-\code
-VectorXf& MatrixBase<VectorXf>::operator=(const MatrixBase<CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf> > & other);
-\endcode
-This operator= literally reads "copying a sum of two VectorXf's into another VectorXf".
+This function literally reads "assign a sum of two VectorXf's to another VectorXf", and everything from here on lives in src/Core/AssignEvaluator.h. This file implements %Eigen's evaluator-based assignment mechanism (introduced in %Eigen 3.3): expressions describe \em what to compute, while separate \em evaluator classes, one specialization of internal::evaluator\<\> per expression type, describe \em how to compute coefficients and packets of it.
 
-Let's now look at the implementation of this operator=. It resides in the file src/Core/Assign.h.
-
-What we can see there is:
+The first stage is a compile-time dispatch on whether the right-hand side must be assumed to alias the destination:
 \code
-template<typename Derived>
-template<typename OtherDerived>
-inline Derived& MatrixBase<Derived>
-  ::operator=(const MatrixBase<OtherDerived>& other)
-{
-  return internal::assign_selector<Derived,OtherDerived>::run(derived(), other.derived());
+template <typename Dst, typename Src, typename Func, std::enable_if_t<evaluator_assume_aliasing<Src>::value, int> = 0>
+constexpr void call_assignment(Dst& dst, const Src& src, const Func& func) {
+  typename plain_matrix_type<Src>::type tmp(src);
+  call_assignment_no_alias(dst, tmp, func);
+}
+
+template <typename Dst, typename Src, typename Func, std::enable_if_t<!evaluator_assume_aliasing<Src>::value, int> = 0>
+constexpr void call_assignment(Dst& dst, const Src& src, const Func& func) {
+  call_assignment_no_alias(dst, src, func);
+}
+\endcode
+As explained in \ref TopicLazyEvaluation, certain expressions, most notably the matrix Product expression, are evaluated into a temporary before being assigned, in order to avoid aliasing issues when doing "m = m * m;". The internal::evaluator_assume_aliasing trait identifies them. Our CwiseBinaryOp sum is not one of them -- we said since the beginning that we didn't want a temporary to be introduced here -- so we take the second overload and go straight to call_assignment_no_alias. This is also, incidentally, exactly what writing u.noalias() = v + w would have done directly.
+
+Inside call_assignment_no_alias, a compile-time constant NeedToTranspose handles the special case of assigning a row-vector to a column-vector (the one exception to the rule that assignment requires matching dimensions); here both sides are column vectors, so it is false. After a few static assertions, the call lands in the Assignment class template, which dispatches on the \em shapes of the two sides. Both sides here have dense shape, so the Dense2Dense specialization runs, which (ignoring a runtime aliasing check in debug builds) simply calls call_dense_assignment_loop:
+\code
+template <typename DstXprType, typename SrcXprType, typename Functor>
+constexpr void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor& func) {
+  using DstEvaluatorType = evaluator<DstXprType>;
+  using SrcEvaluatorType = evaluator<SrcXprType>;
+
+  SrcEvaluatorType srcEvaluator(src);
+  resize_if_allowed(dst, src, func);
+  DstEvaluatorType dstEvaluator(dst);
+
+  using Kernel = generic_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType, Functor>;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+
+  dense_assignment_loop<Kernel>::run(kernel);
 }
 \endcode
 
-OK so our next task is to understand internal::assign_selector :)
-
-Here is its declaration (all that is still in the same file src/Core/Assign.h)
+This is where the evaluators appear. The evaluator of our CwiseBinaryOp expression stores the functor and, recursively, the evaluators of its two operands; the evaluator of a Matrix simply stores the data pointer. The \a kernel object bundles the destination evaluator, the source evaluator, and the assignment functor (here internal::assign_op, meaning plain assignment; compound assignments like += reuse this exact machinery with a different functor). The kernel exposes two essential operations:
 \code
-template<typename Derived, typename OtherDerived,
-         bool EvalBeforeAssigning = int(OtherDerived::Flags) & EvalBeforeAssigningBit,
-         bool NeedToTranspose = Derived::IsVectorAtCompileTime
-                && OtherDerived::IsVectorAtCompileTime
-                && int(Derived::RowsAtCompileTime) == int(OtherDerived::ColsAtCompileTime)
-                && int(Derived::ColsAtCompileTime) == int(OtherDerived::RowsAtCompileTime)
-                && int(Derived::SizeAtCompileTime) != 1>
-struct internal::assign_selector;
+  void assignCoeff(Index index) {
+    m_functor.assignCoeff(m_dst.coeffRef(index), m_src.coeff(index));
+  }
+  template <int StoreMode, int LoadMode, typename Packet>
+  void assignPacket(Index index) {
+    m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode, Packet>(index));
+  }
 \endcode
 
-So internal::assign_selector takes 4 template parameters, but the 2 last ones are automatically determined by the 2 first ones.
+The last line hands the kernel to dense_assignment_loop, whose run() function selects the evaluation strategy. A helper class, internal::copy_using_evaluator_traits, computes two compile-time constants from the evaluators' capabilities: \a Traversal (how to iterate: coefficient by coefficient, linearly, by aligned packets, ...) and \a Unrolling (whether to fully unroll the loop at compile time). In our example \a Traversal is \a LinearVectorizedTraversal -- both sides can be addressed linearly by a single integer index and support packet access -- and \a Unrolling is \a NoUnrolling, which is obvious since our vectors have dynamic size so there's no way to unroll the loop at compile-time.
 
-EvalBeforeAssigning is here to enforce the EvalBeforeAssigningBit. As explained <a href="TopicLazyEvaluation.html">here</a>, certain expressions have this flag which makes them automatically evaluate into temporaries before assigning them to another expression. This is the case of the Product expression, in order to avoid strange aliasing effects when doing "m = m * m;" However, of course here our CwiseBinaryOp expression doesn't have the EvalBeforeAssigningBit: we said since the beginning that we didn't want a temporary to be introduced here. So if you go to src/Core/CwiseBinaryOp.h, you'll see that the Flags in internal::traits\<CwiseBinaryOp\> don't include the EvalBeforeAssigningBit. The Flags member of CwiseBinaryOp is then imported from the internal::traits by the EIGEN_GENERIC_PUBLIC_INTERFACE macro. Anyway, here the template parameter EvalBeforeAssigning has the value \c false.
-
-NeedToTranspose is here for the case where the user wants to copy a row-vector into a column-vector. We allow this as a special exception to the general rule that in assignments we require the dimensions to match. Anyway, here both the left-hand and right-hand sides are column vectors, in the sense that ColsAtCompileTime is equal to 1. So NeedToTranspose is \c false too.
-
-So, here we are in the partial specialization:
+So the partial specialization that runs is, in slightly simplified form:
 \code
-internal::assign_selector<Derived, OtherDerived, false, false>
-\endcode
+template <typename Kernel>
+struct dense_assignment_loop_impl<Kernel, LinearVectorizedTraversal, NoUnrolling> {
+  static void run(Kernel& kernel) {
+    const Index size = kernel.size();
+    const Index alignedStart = DstIsAligned ? 0 : first_aligned<Alignment>(kernel.dstDataPtr(), size);
+    const Index alignedEnd = alignedStart + numext::round_down(size - alignedStart, PacketSize);
 
-Here's how it is defined:
-\code
-template<typename Derived, typename OtherDerived>
-struct internal::assign_selector<Derived,OtherDerived,false,false> {
-  static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); }
-};
-\endcode
+    head_loop::run(kernel, 0, alignedStart);                      // scalar (or partial-packet) prologue
 
-OK so now our next job is to understand how lazyAssign works :)
+    for (Index index = alignedStart; index < alignedEnd; index += PacketSize)
+      kernel.template assignPacket<Alignment, SrcAlignment, PacketType>(index);
 
-\code
-template<typename Derived>
-template<typename OtherDerived>
-inline Derived& MatrixBase<Derived>
-  ::lazyAssign(const MatrixBase<OtherDerived>& other)
-{
-  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
-  eigen_assert(rows() == other.rows() && cols() == other.cols());
-  internal::assign_impl<Derived, OtherDerived>::run(derived(),other.derived());
-  return derived();
-}
-\endcode
-
-What do we see here? Some assertions, and then the only interesting line is:
-\code
-  internal::assign_impl<Derived, OtherDerived>::run(derived(),other.derived());
-\endcode
-
-OK so now we want to know what is inside internal::assign_impl.
-
-Here is its declaration:
-\code
-template<typename Derived1, typename Derived2,
-         int Vectorization = internal::assign_traits<Derived1, Derived2>::Vectorization,
-         int Unrolling = internal::assign_traits<Derived1, Derived2>::Unrolling>
-struct internal::assign_impl;
-\endcode
-Again, internal::assign_selector takes 4 template parameters, but the 2 last ones are automatically determined by the 2 first ones.
-
-These two parameters \a Vectorization and \a Unrolling are determined by a helper class internal::assign_traits. Its job is to determine which vectorization strategy to use (that is \a Vectorization) and which unrolling strategy to use (that is \a Unrolling).
-
-We'll not enter into the details of how these strategies are chosen (this is in the implementation of internal::assign_traits at the top of the same file). Let's just say that here \a Vectorization has the value \a LinearVectorization, and \a Unrolling has the value \a NoUnrolling (the latter is obvious since our vectors have dynamic size so there's no way to unroll the loop at compile-time).
-
-So the partial specialization of internal::assign_impl that we're looking at is:
-\code
-internal::assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling>
-\endcode
-
-Here is how it's defined:
-\code
-template<typename Derived1, typename Derived2>
-struct internal::assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling>
-{
-  static void run(Derived1 &dst, const Derived2 &src)
-  {
-    const int size = dst.size();
-    const int packetSize = internal::packet_traits<typename Derived1::Scalar>::size;
-    const int alignedStart = internal::assign_traits<Derived1,Derived2>::DstIsAligned ? 0
-                           : internal::first_aligned(&dst.coeffRef(0), size);
-    const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
-
-    for(int index = 0; index < alignedStart; index++)
-      dst.copyCoeff(index, src);
-
-    for(int index = alignedStart; index < alignedEnd; index += packetSize)
-    {
-      dst.template copyPacket<Derived2, Aligned, internal::assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
-    }
-
-    for(int index = alignedEnd; index < size; index++)
-      dst.copyCoeff(index, src);
+    tail_loop::run(kernel, alignedEnd, size);                     // scalar (or partial-packet) epilogue
   }
 };
 \endcode
 
-Here's how it works. \a LinearVectorization means that the left-hand and right-hand side expression can be accessed linearly i.e. you can refer to their coefficients by one integer \a index, as opposed to having to refer to its coefficients by two integers \a row, \a column.
+Here's how it works. As we said at the beginning, vectorization works with blocks of 4 floats with SSE, so \a PacketSize is 4. There are two potential problems that the loop structure deals with:
+\li first, vectorized stores are most efficient when they are aligned to the packet size. So when writing to the coefficients of the destination, we want to group them into packets of 4 such that each packet is 128-bit-aligned. In general, this requires skipping a few coefficients at the beginning, which is the purpose of \a alignedStart and the head loop. In our case the destination is a VectorXf, and remember that in the construction of the vectors we allocated aligned arrays. The evaluator advertises this alignment at compile time, so \a alignedStart is zero and the head loop is avoided altogether without any runtime check.
+\li second, the number of coefficients is not in general a multiple of \a PacketSize. Here, there are 50 coefficients and \a PacketSize is 4, so \a alignedEnd is 48 and the last 2 coefficients are handled by the tail loop.
 
-As we said at the beginning, vectorization works with blocks of 4 floats. Here, \a PacketSize is 4.
-
-There are two potential problems that we need to deal with:
-\li first, vectorization works much better if the packets are 128-bit-aligned. This is especially important for write access. So when writing to the coefficients of \a dst, we want to group these coefficients by packets of 4 such that each of these packets is 128-bit-aligned. In general, this requires to skip a few coefficients at the beginning of \a dst. This is the purpose of \a alignedStart. We then copy these first few coefficients one by one, not by packets. However, in our case, the \a dst expression is a VectorXf and remember that in the construction of the vectors we allocated aligned arrays. Thanks to \a DstIsAligned, Eigen remembers that without having to do any runtime check, so \a alignedStart is zero and this part is avoided altogether.
-\li second, the number of coefficients to copy is not in general a multiple of \a packetSize. Here, there are 50 coefficients to copy and \a packetSize is 4. So we'll have to copy the last 2 coefficients one by one, not by packets. Here, \a alignedEnd is 48.
-
-Now come the actual loops.
-
-First, the vectorized part: the 48 first coefficients out of 50 will be copied by packets of 4:
+Now let's follow one call to kernel.assignPacket(index) all the way down. The assignment functor internal::assign_op, from src/Core/functors/AssignmentFunctors.h, stores the source packet into the destination memory:
 \code
-  for(int index = alignedStart; index < alignedEnd; index += packetSize)
-  {
-    dst.template copyPacket<Derived2, Aligned, internal::assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
-  }
-\endcode
-
-What is copyPacket? It is defined in src/Core/Coeffs.h:
-\code
-template<typename Derived>
-template<typename OtherDerived, int StoreMode, int LoadMode>
-inline void MatrixBase<Derived>::copyPacket(int index, const MatrixBase<OtherDerived>& other)
-{
-  eigen_internal_assert(index >= 0 && index < size());
-  derived().template writePacket<StoreMode>(index,
-    other.derived().template packet<LoadMode>(index));
+template <int Alignment, typename Packet>
+void assign_op::assignPacket(DstScalar* a, const Packet& b) const {
+  pstoret<DstScalar, Packet, Alignment>(a, b);
 }
 \endcode
-
-OK, what are writePacket() and packet() here?
-
-First, writePacket() here is a method on the left-hand side VectorXf. So we go to src/Core/Matrix.h to look at its definition:
+internal::pstoret, in src/Core/GenericPacketMath.h, is a dispatcher selecting between the aligned internal::pstore and the unaligned internal::pstoreu at compile time. Since \a Alignment says the store is aligned, it calls internal::pstore, whose SSE specialization in src/Core/arch/SSE/PacketMath.h is essentially:
 \code
-template<int StoreMode>
-inline void writePacket(int index, const PacketScalar& x)
-{
-  internal::pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, x);
+template <>
+inline void pstore<float>(float* to, const Packet4f& from) { _mm_store_ps(to, from); }
+\endcode
+Here, Packet4f is %Eigen's name for the SSE type __m128 ("packet of 4 floats"), and _mm_store_ps is an SSE intrinsic representing a single SSE instruction. The packet_traits\<float\> specialization in the same file is what declared, at compile time, that packets of floats have size 4, which is where \a PacketSize came from.
+
+The source packet was produced by m_src.packet(index), where m_src is the evaluator of our sum expression. Its packet() function, in src/Core/CoreEvaluators.h, reads one packet from each operand's evaluator and combines them with the functor:
+\code
+template <int LoadMode, typename PacketType>
+PacketType binary_evaluator<CwiseBinaryOp>::packet(Index index) const {
+  return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode, PacketType>(index),
+                             m_d.rhsImpl.template packet<LoadMode, PacketType>(index));
 }
 \endcode
-Here, \a StoreMode is \a #Aligned, indicating that we are doing a 128-bit-aligned write access, \a PacketScalar is a type representing a "SSE packet of 4 floats" and internal::pstoret is a function writing such a packet in memory. Their definitions are architecture-specific, we find them in src/Core/arch/SSE/PacketMath.h:
-
-The line in src/Core/arch/SSE/PacketMath.h that determines the PacketScalar type (via a typedef in Matrix.h) is:
+Here, \a lhsImpl and \a rhsImpl are the evaluators of the vectors \a v and \a w. Their packet() function loads 4 consecutive floats with internal::ploadt, the load-side analogue of internal::pstoret, which resolves to the _mm_load_ps intrinsic. Finally, the functor's packetOp(), in src/Core/functors/BinaryFunctors.h, is:
 \code
-template<> struct internal::packet_traits<float>  { typedef __m128  type; enum {size=4}; };
-\endcode
-Here, __m128 is a SSE-specific type. Notice that the enum \a size here is what was used to define \a packetSize above.
-
-And here is the implementation of internal::pstoret:
-\code
-template<> inline void internal::pstore(float*  to, const __m128&  from) { _mm_store_ps(to, from); }
-\endcode
-Here, __mm_store_ps is a SSE-specific intrinsic function, representing a single SSE instruction. The difference between internal::pstore and internal::pstoret is that internal::pstoret is a dispatcher handling both the aligned and unaligned cases, you find its definition in src/Core/GenericPacketMath.h:
-\code
-template<typename Scalar, typename Packet, int LoadMode>
-inline void internal::pstoret(Scalar* to, const Packet& from)
-{
-  if(LoadMode == Aligned)
-    internal::pstore(to, from);
-  else
-    internal::pstoreu(to, from);
+template <typename Packet>
+Packet scalar_sum_op::packetOp(const Packet& a, const Packet& b) const {
+  return internal::padd(a, b);
 }
 \endcode
+and internal::padd's SSE specialization is a single _mm_add_ps instruction.
 
-OK, that explains how writePacket() works. Now let's look into the packet() call. Remember that we are analyzing this line of code inside copyPacket():
-\code
-derived().template writePacket<StoreMode>(index,
-    other.derived().template packet<LoadMode>(index));
-\endcode
+To summarize, the vectorized loop has been compiled to the following code: for \a index taking the values 0, 4, 8, ..., 44 -- twelve iterations covering the first 48 coefficients -- read the packet of 4 floats starting at v[index] and the packet starting at w[index] using two _mm_load_ps SSE instructions, add them together using an _mm_add_ps instruction, then store the result using an _mm_store_ps instruction.
 
-Here, \a other is our sum expression \a v + \a w. The .derived() is just casting from MatrixBase to the subclass which here is CwiseBinaryOp. So let's go to src/Core/CwiseBinaryOp.h:
-\code
-class CwiseBinaryOp
-{
-  // ...
-    template<int LoadMode>
-    inline PacketScalar packet(int index) const
-    {
-      return m_functor.packetOp(m_lhs.template packet<LoadMode>(index), m_rhs.template packet<LoadMode>(index));
-    }
-};
-\endcode
-Here, \a m_lhs is the vector \a v, and \a m_rhs is the vector \a w. So the packet() function here is Matrix::packet(). The template parameter \a LoadMode is \a #Aligned. So we're looking at
-\code
-class Matrix
-{
-  // ...
-    template<int LoadMode>
-    inline PacketScalar packet(int index) const
-    {
-      return internal::ploadt<Scalar, LoadMode>(m_storage.data() + index);
-    }
-};
-\endcode
-We let you look up the definition of internal::ploadt in GenericPacketMath.h and the internal::pload in src/Core/arch/SSE/PacketMath.h. It is very similar to the above for internal::pstore.
-
-Let's go back to CwiseBinaryOp::packet(). Once the packets from the vectors \a v and \a w have been returned, what does this function do? It calls m_functor.packetOp() on them. What is m_functor? Here we must remember what particular template specialization of CwiseBinaryOp we're dealing with:
-\code
-CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf>
-\endcode
-So m_functor is an object of the empty class internal::scalar_sum_op<float>. As we mentioned above, don't worry about why we constructed an object of this empty class at all -- it's an implementation detail, the point is that some other functors need to store member data.
-
-Anyway, internal::scalar_sum_op is defined in src/Core/Functors.h:
-\code
-template<typename Scalar> struct internal::scalar_sum_op EIGEN_EMPTY_STRUCT {
-  inline const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }
-  template<typename PacketScalar>
-  inline const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
-  { return internal::padd(a,b); }
-};
-\endcode
-As you can see, all what packetOp() does is to call internal::padd on the two packets. Here is the definition of internal::padd from src/Core/arch/SSE/PacketMath.h:
-\code
-template<> inline __m128  internal::padd(const __m128&  a, const __m128&  b) { return _mm_add_ps(a,b); }
-\endcode
-Here, _mm_add_ps is a SSE-specific intrinsic function, representing a single SSE instruction.
-
-To summarize, the loop
-\code
-  for(int index = alignedStart; index < alignedEnd; index += packetSize)
-  {
-    dst.template copyPacket<Derived2, Aligned, internal::assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
-  }
-\endcode
-has been compiled to the following code: for \a index going from 0 to the 11 ( = 48/4 - 1), read the i-th packet (of 4 floats) from the vector v and the i-th packet from the vector w using two __mm_load_ps SSE instructions, then add them together using a __mm_add_ps instruction, then store the result using a __mm_store_ps instruction.
-
-There remains the second loop handling the last few (here, the last 2) coefficients:
-\code
-  for(int index = alignedEnd; index < size; index++)
-    dst.copyCoeff(index, src);
-\endcode
-However, it works just like the one we just explained, it is just simpler because there is no SSE vectorization involved here. copyPacket() becomes copyCoeff(), packet() becomes coeff(), writePacket() becomes coeffRef(). If you followed us this far, you can probably understand this part by yourself.
+There remains the tail loop handling the last few (here, the last 2) coefficients. Depending on the instruction set it either uses partial-packet loads and stores, or falls back to kernel.assignCoeff(index), which does the same walk through the evaluators coefficient by coefficient: assignPacket() becomes assignCoeff(), packet() becomes coeff(), and pstore() becomes a plain scalar store. If you followed us this far, you can probably understand this part by yourself.
 
 We see that all the C++ abstraction of Eigen goes away during compilation and that we indeed are precisely controlling which assembly instructions we emit. Such is the beauty of C++! Since we have such precise control over the emitted assembly instructions, but such complex logic to choose the right instructions, we can say that Eigen really behaves like an optimizing compiler. If you prefer, you could say that Eigen behaves like a script for the compiler. In a sense, C++ template metaprogramming is scripting the compiler -- and it's been shown that this scripting language is Turing-complete. See <a href="http://en.wikipedia.org/wiki/Template_metaprogramming"> Wikipedia</a>.
 
diff --git a/doc/LeastSquares.dox b/doc/LeastSquares.dox
index ddbf38d..7ee27d5 100644
--- a/doc/LeastSquares.dox
+++ b/doc/LeastSquares.dox
@@ -7,13 +7,49 @@
 vector \a x which is closest to being a solution, in the sense that the difference \a Ax - \a b is
 as small as possible. This \a x is called the least square solution (if the Euclidean norm is used).
 
-The three methods discussed on this page are the SVD decomposition, the QR decomposition and normal
-equations. Of these, the SVD decomposition is generally the most accurate but the slowest, normal
-equations is the fastest but least accurate, and the QR decomposition is in between.
+The methods discussed on this page are the complete orthogonal decomposition (COD), the SVD
+decomposition, other QR decompositions, and normal equations. For most problems, we recommend
+CompleteOrthogonalDecomposition: it robustly computes the minimum-norm least squares solution
+(like the SVD) for both over- and under-determined systems, including rank-deficient ones, but at
+QR-like speed. For large problems, RandCompleteOrthogonalDecomposition computes the same kind of
+factorization with a randomized blocked rank-revealing QR. The SVD is the most robust but also the
+slowest; use it when you also need singular values or vectors. Normal equations are the fastest but
+least robust.
 
 \eigenAutoToc
 
 
+\section LeastSquaresCOD Using the complete orthogonal decomposition (recommended)
+
+CompleteOrthogonalDecomposition is the recommended method for least squares problems. It handles the
+widest class of problems — overdetermined, underdetermined, and rank-deficient systems — and computes
+the minimum-norm solution when the system is rank-deficient or underdetermined, just like the SVD.
+It is based on a rank-revealing QR factorization (ColPivHouseholderQR) followed by a post-processing
+step, so it is significantly faster than SVD while providing comparable robustness.
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr>
+  <td>\include LeastSquaresCOD.cpp </td>
+  <td>\verbinclude LeastSquaresCOD.out </td>
+</tr>
+</table>
+
+For large problems, RandCompleteOrthogonalDecomposition computes the same kind of factorization
+through a randomized blocked rank-revealing QR (RandColPivHouseholderQR) instead. It selects each
+block of pivots from a small Gaussian sketch of the matrix, which keeps nearly all of the work in
+level-3 BLAS kernels rather than in the memory-bound column scan that classical column pivoting
+requires. The pivots therefore differ from the ones classical column pivoting would choose, and so
+do the resulting factors, but the pivot-quality difference is empirically minor. It has the same interface, so it is a drop-in
+replacement in the example above, and additionally exposes setBlockSize() and setSeed() to control
+the underlying QR. For small matrices the cost of forming the sketch dominates, so prefer
+CompleteOrthogonalDecomposition there.
+
+Both classes also provide pseudoInverse(); they are the only decompositions in %Eigen that do. Note
+that solve() is more efficient and more accurate than multiplying by an explicitly formed
+pseudo-inverse.
+
+
 \section LeastSquaresSVD Using the SVD decomposition
 
 The \link BDCSVD::solve() solve() \endlink method in the BDCSVD class can be directly used to
@@ -30,16 +66,20 @@
 </table>
 
 This is example from the page \link TutorialLinearAlgebra Linear algebra and decompositions \endlink.
-If you just need to solve the least squares problem, but are not interested in the SVD per se, a
-faster alternative method is CompleteOrthogonalDecomposition. 
+The SVD gives you singular values and vectors in addition to the least squares solution, but if you
+only need the solution, CompleteOrthogonalDecomposition (above) is faster.
 
 
-\section LeastSquaresQR Using the QR decomposition
+\section LeastSquaresQR Using other QR decompositions
 
-The solve() method in QR decomposition classes also computes the least squares solution. There are
-three QR decomposition classes: HouseholderQR (no pivoting, fast but unstable if your matrix is
-not rull rank), ColPivHouseholderQR (column pivoting, thus a bit slower but more stable) and
-FullPivHouseholderQR (full pivoting, so slowest and slightly more stable than ColPivHouseholderQR).
+The solve() method in QR decomposition classes also computes the least squares solution. Besides the
+two complete orthogonal decompositions (above), there are four other QR decomposition classes:
+HouseholderQR (no pivoting, so fast but unreliable if your matrix is not full rank),
+ColPivHouseholderQR (column pivoting, a bit slower but rank-revealing), RandColPivHouseholderQR
+(randomized blocked column pivoting, rank-revealing and intended for large matrices), and
+FullPivHouseholderQR (full pivoting, significantly slower and rarely needed in practice).
+Note that only the complete orthogonal decompositions and the SVD-based solvers compute minimum-norm
+solutions for rank-deficient or underdetermined problems; the plain QR variants do not.
 Here is an example with column pivoting:
 
 <table class="example">
diff --git a/doc/Manual.dox b/doc/Manual.dox
index c229ef5..0238307 100644
--- a/doc/Manual.dox
+++ b/doc/Manual.dox
@@ -8,6 +8,7 @@
   - \subpage TopicCustomizing_Plugins
   - \subpage TopicCustomizing_InheritingMatrix
   - \subpage TopicCustomizing_CustomScalar
+  - \subpage TopicCustomizing_Functors
   - \subpage TopicCustomizing_NullaryExpr
   - \subpage TopicNewExpressionType
   \sa \ref TopicPreprocessorDirectives
@@ -16,34 +17,30 @@
 
 /** \page UserManual_Generalities General topics
   - \subpage TopicFunctionTakingEigenTypes
+  - \subpage TopicScalarTypes
+  - \subpage TopicVectorization
   - \subpage TopicPreprocessorDirectives
   - \subpage TopicAssertions
   - \subpage TopicMultiThreading
   - \subpage TopicUsingBlasLapack
   - \subpage TopicUsingIntelMKL
+  - \subpage TopicUsingAOCL
   - \subpage TopicCUDA
   - \subpage TopicPitfalls
   - \subpage TopicTemplateKeyword
+  - \subpage TopicWritingEfficientProductExpression
+  - \subpage Experimental
   - \subpage UserManual_UnderstandingEigen
   - \subpage TopicCMakeGuide
 */
 
 /** \page UserManual_UnderstandingEigen Understanding Eigen
+  - \subpage TopicEigenExpressionTemplates
   - \subpage TopicInsideEigenExample
   - \subpage TopicClassHierarchy
   - \subpage TopicLazyEvaluation
 */
 
-/** \page UnclassifiedPages Unclassified pages
-  - \subpage TopicVectorization
-  - \subpage TopicEigenExpressionTemplates
-  - \subpage TopicScalarTypes
-  - \subpage TutorialSparse_example_details
-  - \subpage TopicWritingEfficientProductExpression
-  - \subpage Experimental
-*/
-
-
 /** \defgroup Support_modules Support modules
   * Category of modules which add support for external libraries.
   */
diff --git a/doc/MatrixfreeSolverExample.dox b/doc/MatrixfreeSolverExample.dox
index 3efa292..2871e66 100644
--- a/doc/MatrixfreeSolverExample.dox
+++ b/doc/MatrixfreeSolverExample.dox
@@ -5,7 +5,9 @@
 
 \eigenManualPage MatrixfreeSolverExample Matrix-free solvers
 
-Iterative solvers such as ConjugateGradient and BiCGSTAB can be used in a matrix free context. To this end, user must provide a wrapper class inheriting EigenBase<> and implementing the following methods:
+Iterative solvers such as ConjugateGradient and BiCGSTAB can be used in a matrix free context. To this end, user must provide a wrapper class inheriting EigenBase<> and implementing the following members:
+ - the nested types \c Scalar, \c RealScalar and \c StorageIndex
+ - the constants \c ColsAtCompileTime, \c MaxColsAtCompileTime and \c IsRowMajor
  - \c Index \c rows() and \c Index \c cols(): returns number of rows and columns respectively
  - \c operator* with your type and an %Eigen dense column vector (its actual implementation goes in a specialization of the internal::generic_product_impl class)
 
diff --git a/doc/NewExpressionType.dox b/doc/NewExpressionType.dox
index c2f2433..caf7509 100644
--- a/doc/NewExpressionType.dox
+++ b/doc/NewExpressionType.dox
@@ -6,7 +6,7 @@
 \warning
 Disclaimer: this page is tailored to very advanced users who are not afraid of dealing with some %Eigen's internal aspects.
 In most cases, a custom expression can be avoided by either using custom \ref MatrixBase::unaryExpr "unary" or \ref MatrixBase::binaryExpr "binary" functors,
-while extremely complex matrix manipulations can be achieved by a nullary functors as described in the \ref TopicCustomizing_NullaryExpr "previous page".
+while extremely complex matrix manipulations can be achieved by nullary functors as described in the \ref TopicCustomizing_NullaryExpr "previous page".
 
 This page describes with the help of an example how to implement a new
 light-weight expression type in %Eigen. This consists of three parts:
@@ -14,8 +14,38 @@
 information about the expression, and the evaluator class which is
 used to evaluate the expression to a matrix.
 
-\b TO \b DO: Write a page explaining the design, with details on
-vectorization etc., and refer to that page here.
+\section TopicNewExpressionChecklist Checklist before adding a new matrix or expression type
+
+Adding a new dense expression type is an internal extension point. Before doing so, check whether a smaller extension
+point is enough:
+
+- If you only need coefficient-wise custom work, prefer custom \ref TopicCustomizing_Functors "functors" with
+  unaryExpr(), binaryExpr(), NullaryExpr(), or redux().
+- If you need a procedural matrix or a read-only indexed view, prefer \ref TopicCustomizing_NullaryExpr
+  "nullary expressions".
+- If you only need convenience methods on Matrix or Array, prefer the \ref TopicCustomizing_Plugins "plugin"
+  mechanism.
+- If you need an owning matrix with conventional dense storage, prefer composing or inheriting from Matrix, as described
+  in \ref TopicCustomizing_InheritingMatrix.
+
+When a new expression type is still needed, the implementation usually has to provide:
+
+- an expression class deriving from MatrixBase, ArrayBase, or EigenBase, depending on the public API it should expose;
+- an \c internal::traits specialization describing scalar type, storage kind, compile-time sizes, flags, and related
+  expression properties;
+- storage for operands or parameters, with careful lifetime handling for nested expressions;
+- rows(), cols(), and any other dimension accessors required by the chosen base class;
+- an \c internal::evaluator specialization implementing coefficient access, and packet access only when the expression
+  can really be vectorized;
+- an entry-point function that constructs the expression and returns it by value;
+- focused tests for fixed and dynamic sizes, constness, aliasing/evaluation behavior, and any supported storage orders.
+
+Owning storage types are much more invasive than lightweight expressions because they interact with PlainObjectBase,
+resizing, alignment, assignment, and evaluator assumptions. New code should avoid introducing such a type unless the
+existing Matrix, Array, Map, Ref, view, or expression mechanisms cannot represent the use case.
+
+For background on the design that a new expression type plugs into, see \ref TopicEigenExpressionTemplates,
+\ref TopicClassHierarchy, \ref TopicLazyEvaluation, and \ref TopicInsideEigenExample.
 
 
 \eigenAutoToc
@@ -56,9 +86,9 @@
 
 \section TopicTraits The traits class
 
-For every expression class \c X, there should be a traits class 
-\c Traits<X> in the \c Eigen::internal namespace containing
-information about \c X known as compile time.
+For every expression class \c X, there should be a traits class
+\c internal::traits<X> in the \c Eigen namespace containing
+information about \c X known at compile time.
 
 As explained in \ref TopicSetting, we designed the \c Circulant
 expression class to refer to dense matrices. The entries of the
@@ -88,8 +118,14 @@
 is a square matrix with as many columns as the vector used to
 construct the matrix.
 
-\b TO \b DO: What about the \c Nested typedef? It seems to be
-necessary; is this only temporary?
+The \c Nested typedef is what an enclosing expression stores this one
+as: \c CwiseUnaryOp, \c CwiseBinaryOp and their kin declare their
+operand members as \c ArgType::Nested. Define it from
+\c internal::ref_selector, as above, which selects a reference or a
+value from the expression's own \c NestByRefBit. Whether a
+sub-expression is instead evaluated into a temporary is a separate
+decision, taken by \c internal::nested_eval from the evaluator's flags
+and costs rather than from this typedef.
 
 \include make_circulant.cpp.expression
 
@@ -140,4 +176,3 @@
 
 */
 }
-
diff --git a/doc/Overview.dox b/doc/Overview.dox
index 3bca806..17c4a66 100644
--- a/doc/Overview.dox
+++ b/doc/Overview.dox
@@ -2,7 +2,7 @@
 
 /** \mainpage notitle
 
-This is the API documentation for Eigen3. You can <a href="eigen-doc.tgz">download</a> it as a tgz archive for offline reading.
+This is the API documentation for %Eigen. You can <a href="eigen-doc.tgz">download</a> it as a tgz archive for offline reading.
 
 For a first contact with Eigen, the best place is to have a look at the \subpage GettingStarted page that show you how to write and compile your first program with Eigen.
 
@@ -19,13 +19,11 @@
 
 Under the \subpage UserManual_Generalities section, you will find documentation on more general topics such as preprocessor directives, controlling assertions, multi-threading, MKL support, some Eigen's internal insights, and much more...
 
-For details regarding Eigen's inner-workings, see the \subpage UserManual_UnderstandingEigen section.
-
-Some random topics can be found under the \subpage UnclassifiedPages section.
+For details regarding Eigen's inner-workings, see the \ref UserManual_UnderstandingEigen section.
 
 Finally, do not miss the search engine, useful to quickly get to the documentation of a given class or function.
 
-Want more? Checkout the <a href="unsupported/index.html">\em unsupported \em modules </a> documentation.
+Want more? Checkout the <a href="contrib/index.html">\em contrib \em modules </a> documentation.
 
 */
 
diff --git a/doc/Pitfalls.dox b/doc/Pitfalls.dox
index 7e627cf..b3f49bc 100644
--- a/doc/Pitfalls.dox
+++ b/doc/Pitfalls.dox
@@ -20,7 +20,7 @@
 Indeed, prior to C++17,  C++ does not have quite good enough support for explicit data alignment.
 In that case your program hits an assertion failure (that is, a "controlled crash") with a message that tells you to consult this page:
 \code
-http://eigen.tuxfamily.org/dox/group__TopicUnalignedArrayAssert.html
+http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html
 \endcode
 Have a look at \link TopicUnalignedArrayAssert it \endlink and see for yourself if that's something that you can cope with.
 It contains detailed information about how to deal with each known cause for that issue.
@@ -28,7 +28,7 @@
 Now what if you don't care about vectorization and so don't want to be annoyed with these alignment issues? Then read \link getrid how to get rid of them \endlink.
 
 
-\section TopicPitfalls_auto_keyword C++11 and the auto keyword
+\section TopicPitfalls_auto_keyword The auto keyword
 
 In short: do not use the auto keywords with %Eigen's expressions, unless you are 100% sure about what you are doing. In particular, do not use the auto keyword as a replacement for a \c Matrix<> type. Here is an example:
 
@@ -99,13 +99,13 @@
 A << 1, 2, 3;
 Vector3f B = ((1 < 0) ? (A.reverse()) : A);
 \endcode
-This example will return <code>B = 3, 2, 1</code>. Do you see why?
-The reason is that in c++ the type of the \c ELSE statement is inferred from the type of the \c THEN expression such that both match.
-Since \c THEN is a <code>Reverse<Vector3f></code>, the \c ELSE statement A is converted to a <code>Reverse<Vector3f></code>, and the compiler thus generates:
+This example will return <code>B = 1, 2, 3</code>. Do you see why?
+The reason is that in c++ both statements of the ternary operator must be converted to a common type.
+The constructor of <code>Reverse<Vector3f></code> from a \c Vector3f is \c explicit, so the \c ELSE statement A cannot be converted to a <code>Reverse<Vector3f></code>; the common type is \c Vector3f instead, and the compiler thus generates:
 \code
-Vector3f B = ((1 < 0) ? (A.reverse()) : Reverse<Vector3f>(A));
+Vector3f B = ((1 < 0) ? Vector3f(A.reverse()) : Vector3f(A));
 \endcode
-In this very particular case, a workaround would be to call A.reverse().eval() for the \c THEN statement, but the safest and fastest is really to avoid this ternary operator with %Eigen's expressions and use a if/else construct.
+The value is the expected one here, but the selected statement is silently evaluated into a temporary plain object, and two different %Eigen expression types often have no common type at all, in which case the ternary operator does not even compile. The safest and fastest is really to avoid this ternary operator with %Eigen's expressions and use a if/else construct.
 
 
 \section TopicPitfalls_pass_by_value Pass-by-value
@@ -129,23 +129,22 @@
 
 \section TopicPitfalls_matrix_bool Matrices with boolean coefficients
 
-The current behaviour of using \c Matrix with boolean coefficients is inconsistent and likely to change in future versions of Eigen, so please use it carefully!
+For \c bool coefficients, %Eigen interprets the arithmetic operators in the Boolean semiring: \c + is the
+logical OR and \c * is the logical AND. In particular, the product of two \c bool matrices is a Boolean
+matrix product: coefficient \c (i,j) of <tt>A * B</tt> tells whether row \c i of \c A and column \c j of
+\c B share a \c true entry. This holds for every matrix size and every product implementation.
 
-A simple example for such an inconsistency is 
-
+The Boolean semiring has no additive inverse, so subtraction (including \c -=) and unary minus are
+not supported for \c bool matrices or arrays. These operations produce a compile-time diagnostic.
+For integer arithmetic on 0/1 data, cast the operands to a signed integer type before the operation:
 \code
-template<int Size>
-void foo() {
-  Eigen::Matrix<bool, Size, Size> A, B, C;
-  A.setOnes();
-  B.setOnes();
-
-  C = A * B - A * B;
-  std::cout << C << "\n";
-}
+Matrix<bool, Dynamic, Dynamic> A(n, n), B(n, n);
+A.setOnes();
+B.setOnes();
+MatrixXi C = A.cast<int>() * B.cast<int>() - A.cast<int>() * B.cast<int>(); // zero
 \endcode
-
-since calling \c foo<3>() prints the zero matrix while calling \c foo<10>() prints the identity matrix.
+For coefficient-wise Boolean negation use <tt>!A.array()</tt>; for coefficient-wise XOR use
+<tt>A.array() != B.array()</tt>.
 
 */
 }
diff --git a/doc/PreprocessorDirectives.dox b/doc/PreprocessorDirectives.dox
index c8da063..b12db06 100644
--- a/doc/PreprocessorDirectives.dox
+++ b/doc/PreprocessorDirectives.dox
@@ -48,20 +48,22 @@
 
 \section TopicPreprocessorDirectivesCppVersion C++ standard features
 
-By default, %Eigen strive to automatically detect and enable language features at compile-time based on
+By default, %Eigen strives to automatically detect and enable language features at compile-time based on
 the information provided by the compiler.
 
  - \b EIGEN_MAX_CPP_VER - disables usage of C++ features requiring a version greater than EIGEN_MAX_CPP_VER.
    Possible values are: 14, 17, etc. If not defined (the default), %Eigen enables all features supported
-   by the compiler.
+   by the compiler. For instance, one might limit the C++ version to C++14 by defining
+   EIGEN_MAX_CPP_VER=14.
 
 Individual features can be explicitly enabled or disabled by defining the following token to 0 or 1 respectively.
-For instance, one might limit the C++ version to C++14 by defining EIGEN_MAX_CPP_VER=14, but still enable C99 math
-functions by defining EIGEN_HAS_C99_MATH=1.
+For instance, one might disable use of \c std::invoke_result by defining
+EIGEN_HAS_STD_INVOKE_RESULT=0.
 
- - \b EIGEN_HAS_C99_MATH - controls the usage of C99 math functions such as erf, erfc, lgamma, etc.
  - \b EIGEN_HAS_STD_INVOKE_RESULT - controls the usage of \c std::invoke_result (C++17). When disabled,
    \c std::result_of is used as a fallback.
+ - \b EIGEN_HAS_C99_MATH - Deprecated and ignored. Defined to 1 by default for compatibility with downstream code
+   that checks this token; defining it has no effect on %Eigen.
  - \b EIGEN_NO_IO - Disables any usage and support for `<iostreams>`.
 
 \section TopicPreprocessorDirectivesAssertions Assertions
@@ -71,8 +73,9 @@
 
  - \b EIGEN_NO_DEBUG - disables %Eigen's assertions if defined. Not defined by default, unless the
    \c NDEBUG macro is defined (this is a standard C++ macro which disables all asserts).
- - \b EIGEN_NO_STATIC_ASSERT - if defined, compile-time static assertions are replaced by runtime assertions;
-   this saves compilation time. Not defined by default.
+ - \b EIGEN_NO_STATIC_ASSERT - if defined, %Eigen's compile-time static assertions are removed rather than
+   downgraded: the misuse they guard against is then reported neither at compile time nor at run time.
+   Not defined by default.
  - \b eigen_assert - macro with one argument that is used inside %Eigen for assertions. By default, it is
    basically defined to be \c assert, which aborts the program if the assertion is violated. Redefine this
    macro if you want to do something else, like throwing an exception.
@@ -80,7 +83,7 @@
 \section TopicPreprocessorDirectivesPerformance Alignment, vectorization and performance tweaking
 
  - \b \c EIGEN_MALLOC_ALREADY_ALIGNED - Can be set to 0 or 1 to tell whether default system \c malloc already
-   returns aligned buffers. In not defined, then this information is automatically deduced from the compiler
+   returns aligned buffers. If not defined, then this information is automatically deduced from the compiler
    and system preprocessor tokens.
  - \b \c EIGEN_MAX_ALIGN_BYTES - Must be a power of two, or 0. Defines an upper bound on the memory boundary in bytes on which dynamically and statically allocated data may be aligned by %Eigen. If not defined, a default value is automatically computed based on architecture, compiler, and OS.
  This option is typically used to enforce binary compatibility between code/libraries compiled with different SIMD options. For instance, one may compile AVX code and enforce ABI compatibility with existing SSE code by defining \c EIGEN_MAX_ALIGN_BYTES=16. In the other way round, since by default AVX implies 32 bytes alignment for best performance, one can compile SSE code to be ABI compatible with AVX code by defining \c EIGEN_MAX_ALIGN_BYTES=32.
@@ -88,20 +91,32 @@
  Let us emphasize that \c EIGEN_MAX_*_ALIGN_BYTES define only a desirable upper bound. In practice data is aligned to largest power-of-two common divisor of \c EIGEN_MAX_STATIC_ALIGN_BYTES and the size of the data, such that memory is not wasted.
  - \b \c EIGEN_DONT_PARALLELIZE - if defined, this disables multi-threading. This is only relevant if you enabled OpenMP.
    See \ref TopicMultiThreading for details.
+ - \b \c EIGEN_GEMM_THREADPOOL - if defined, the general matrix-matrix product is parallelized using a user-provided
+   \c Eigen::ThreadPool instead of OpenMP; register the pool with \c Eigen::setGemmThreadPool(). Mutually exclusive
+   with OpenMP parallelization. See \ref TopicMultiThreading for details.
  - \b \c EIGEN_DONT_VECTORIZE - disables explicit vectorization when defined. Not defined by default, unless
-   alignment is disabled by %Eigen's platform test or the user defining \c EIGEN_DONT_ALIGN.
+   alignment is disabled by %Eigen's platform test or the user defining \c EIGEN_DONT_ALIGN. The implication also runs
+   the other way outside GPU compilation: defining it sets the ideal alignment to zero, so \c EIGEN_MAX_ALIGN_BYTES and
+   \c EIGEN_MAX_STATIC_ALIGN_BYTES default to 0 and fixed-size vectorizable types lose their over-alignment. It
+   therefore affects the ABI and must be defined consistently across translation units. See \ref TopicVectorization.
  - \b \c EIGEN_UNALIGNED_VECTORIZE - disables/enables vectorization with unaligned stores. Default is 1 (enabled).
    If set to 0 (disabled), then expression for which the destination cannot be aligned are not vectorized (e.g., unaligned
    small fixed size vectors or matrices)
- - \b \c EIGEN_FAST_MATH - enables some optimizations which might affect the accuracy of the result. This currently
-   enables the SSE vectorization of sin() and cos(), and speedups sqrt() for single precision. Defined to 1 by default.
-   Define it to 0 to disable.
+ - \b \c EIGEN_FAST_MATH - enables optimizations which might affect the accuracy of the result. On the SIMD
+   backends where such faster but slightly less accurate implementations exist, this currently controls the
+   vectorization of \c sin(), \c cos(), \c tan(), \c tanh(), \c erf(), \c erfc(), and reciprocal, and selects
+   faster \c sqrt()/\c rsqrt() implementations (e.g., Newton-Raphson iterations on AVX512). Defined to 1 by
+   default. Define it to 0 to disable.
  - \b \c EIGEN_UNROLLING_LIMIT - defines the size of a loop to enable meta unrolling. Set it to zero to disable
    unrolling. The size of a loop here is expressed in %Eigen's own notion of "number of FLOPS", it does not
    correspond to the number of iterations or the number of instructions. The default is value 110.
  - \b \c EIGEN_STACK_ALLOCATION_LIMIT - defines the maximum bytes for a buffer to be allocated on the stack. For internal
-   temporary buffers, dynamic memory allocation is employed as a fall back. For fixed-size matrices or arrays, exceeding
-   this threshold raises a compile time assertion. Use 0 to set no limit. Default is 128 KB.
+   temporary buffers, dynamic memory allocation is employed as a fall back; setting the limit to 0 disables stack
+   allocation for them, so every such temporary is heap-allocated. For fixed-size matrices or arrays, exceeding this
+   threshold raises a compile time assertion; there, 0 disables the check. Default is 128 KB.
+ - \b \c EIGEN_STACK_ALIGN_BYTES - alignment of the internal temporary buffers allocated on the stack. Defaults to
+   \c EIGEN_DEFAULT_ALIGN_BYTES, except in ARM SME builds where it is 64: the SME GEMM kernel reads its packed panels a
+   streaming vector at a time and slows by 35-50% when they straddle 64-byte lines. It does not affect the ABI.
  - \b \c EIGEN_NO_CUDA - disables CUDA support when defined. Might be useful in .cu files for which Eigen is used on the host only,
    and never called from device code.
  - \b \c EIGEN_NO_HIP - disables HIP support when defined. Analogous to \c EIGEN_NO_CUDA for AMD's HIP compiler.
@@ -112,6 +127,22 @@
  - \b \c EIGEN_DEFAULT_L1_CACHE_SIZE - Sets the default L1 cache size that is used in Eigen's GEBP kernel when the correct cache size cannot be determined at runtime.
  - \b \c EIGEN_DEFAULT_L2_CACHE_SIZE - Sets the default L2 cache size that is used in Eigen's GEBP kernel when the correct cache size cannot be determined at runtime.
  - \b \c EIGEN_DEFAULT_L3_CACHE_SIZE - Sets the default L3 cache size that is used in Eigen's GEBP kernel when the correct cache size cannot be determined at runtime.
+ - \b \c EIGEN_SME_MAX_KC - Maximum depth (k) blocking size used by the ARM SME GEMM kernel, expressed in \c float
+   elements and scaled by the scalar width for wider types. The default (2048) is empirically tuned for Apple M4;
+   override to retune for other SME implementations.
+ - \b \c EIGEN_SME_NEON_MAX_DEPTH, \c EIGEN_SME_NEON_MAX_PANEL, \c EIGEN_SME_NEON_MAX_WIDTH, \c EIGEN_SME_NEON_SHALLOW_DEPTH,
+   \c EIGEN_SME_NEON_SHALLOW_WIDTH, \c EIGEN_SME_NEON_THIN_DIM - Bounds below which the ARM SME GEMM backend packs
+   and multiplies a block with NEON instead of the ZA tiles (panels no deeper than the depth bound and no wider than
+   the panel bound; a block of such panels no wider than the width bound, or the shallow width up to the shallow
+   depth, or narrower than the thin bound on one side). One value overrides the per-scalar defaults, which are fitted
+   for Apple M4. \c EIGEN_SME_NO_NEON_SMALL_BLOCKS and \c EIGEN_SME_FORCE_NEON_SMALL_BLOCKS pin the path for A/B runs.
+ - \b \c EIGEN_ARM64_NO_SME_F64F64 - Disables the double-precision ARM SME GEMM kernel, which needs the optional
+   FEAT_SME_F64F64 extension. %Eigen enables it whenever the compiler reports that extension; define this macro when
+   the build target is wider than the run target, so that \c double keeps the generic kernel.
+ - \b \c EIGEN_SME_PACKED_RHS_BUDGET_BYTES - Byte budget for the packed RHS panel in the ARM SME GEMM kernel.
+   The default (32 MB) is empirically tuned for Apple M4.
+ - \b \c EIGEN_SME_LHS_WORKING_SET_BUDGET_BYTES - Byte budget for the LHS working set in the ARM SME GEMM kernel.
+   The default (7 MB) is empirically tuned for Apple M4.
 
  - \b \c EIGEN_DONT_ALIGN - Deprecated, it is a synonym for \c EIGEN_MAX_ALIGN_BYTES=0. It disables alignment completely. %Eigen will not try to align its objects and does not expect that any objects passed to it are aligned. This will turn off vectorization if \b \c EIGEN_UNALIGNED_VECTORIZE=1. Not defined by default.
  - \b \c EIGEN_DONT_ALIGN_STATICALLY - Deprecated, it is a synonym for \c EIGEN_MAX_STATIC_ALIGN_BYTES=0. It disables alignment of arrays on the stack. Not defined by default, unless \c EIGEN_DONT_ALIGN is defined.
diff --git a/doc/QuickReference.dox b/doc/QuickReference.dox
index 4aece90..8d1ee24 100644
--- a/doc/QuickReference.dox
+++ b/doc/QuickReference.dox
@@ -9,7 +9,7 @@
 <a href="#" class="top">top</a>
 \section QuickRef_Headers Modules and Header files
 
-The Eigen library is divided in a Core module and several additional modules. Each module has a corresponding header file which has to be included in order to use the module. The \c %Dense and \c Eigen header files are provided to conveniently gain access to several modules at once.
+The Eigen library is divided into a Core module and several additional modules. Each module has a corresponding header file which has to be included in order to use the module. The \c %Dense and \c Eigen header files are provided to conveniently gain access to several modules at once.
 
 <table class="manual">
 <tr><th>Module</th><th>Header file</th><th>Contents</th></tr>
@@ -19,7 +19,7 @@
 <tr class="alt"><td>\link Cholesky_Module Cholesky \endlink</td><td>\code#include <Eigen/Cholesky>\endcode</td><td>LLT and LDLT Cholesky factorization with solver</td></tr>
 <tr            ><td>\link Householder_Module Householder \endlink</td><td>\code#include <Eigen/Householder>\endcode</td><td>Householder transformations; this module is used by several linear algebra modules</td></tr>
 <tr class="alt"><td>\link SVD_Module SVD \endlink</td><td>\code#include <Eigen/SVD>\endcode</td><td>SVD decompositions with least-squares solver (JacobiSVD, BDCSVD)</td></tr>
-<tr            ><td>\link QR_Module QR \endlink</td><td>\code#include <Eigen/QR>\endcode</td><td>QR decomposition with solver (HouseholderQR, ColPivHouseholderQR, FullPivHouseholderQR)</td></tr>
+<tr            ><td>\link QR_Module QR \endlink</td><td>\code#include <Eigen/QR>\endcode</td><td>QR decompositions with solver (HouseholderQR, ColPivHouseholderQR, RandColPivHouseholderQR, FullPivHouseholderQR) and the complete orthogonal decompositions (CompleteOrthogonalDecomposition, RandCompleteOrthogonalDecomposition)</td></tr>
 <tr class="alt"><td>\link Eigenvalues_Module Eigenvalues \endlink</td><td>\code#include <Eigen/Eigenvalues>\endcode</td><td>Eigenvalue, eigenvector decompositions (EigenSolver, SelfAdjointEigenSolver, ComplexEigenSolver)</td></tr>
 <tr            ><td>\link Sparse_Module Sparse \endlink</td><td>\code#include <Eigen/Sparse>\endcode</td><td>%Sparse matrix storage and related basic linear algebra (SparseMatrix, SparseVector) \n (see \ref SparseQuickRefPage for details on sparse modules)</td></tr>
 <tr class="alt"><td></td><td>\code#include <Eigen/Dense>\endcode</td><td>Includes Core, Geometry, LU, Cholesky, SVD, QR, and Eigenvalues header files</td></tr>
@@ -142,7 +142,7 @@
 <td colspan="2">\code
 ObjectType::Scalar              ObjectType::RowsAtCompileTime
 ObjectType::RealScalar          ObjectType::ColsAtCompileTime
-ObjectType::Index               ObjectType::SizeAtCompileTime
+Eigen::Index                    ObjectType::SizeAtCompileTime
 \endcode</td><td></td></tr>
 <tr class="alt"><td>Resizing</td>
 <td>\code
@@ -416,7 +416,7 @@
 
 array1.floor()                floor(array1)
 array1.ceil()                 ceil(array1)
-array1.round()                round(aray1)
+array1.round()                round(array1)
 
 array1.isFinite()             isfinite(array1)
 array1.isInf()                isinf(array1)
@@ -483,14 +483,17 @@
 while the second one (based on .array()) returns an array expression.
 Recall that .array() has no cost, it only changes the available API and interpretation of the data.
 
-It is also very simple to apply any user defined function \c foo using DenseBase::unaryExpr together with <a href="http://en.cppreference.com/w/cpp/utility/functional/ptr_fun">std::ptr_fun</a> (c++03, deprecated or removed in newer C++ versions), <a href="http://en.cppreference.com/w/cpp/utility/functional/ref">std::ref</a> (c++11), or <a href="http://en.cppreference.com/w/cpp/language/lambda">lambdas</a> (c++11):
+It is also very simple to apply any user defined function \c foo using DenseBase::unaryExpr with function pointers,
+<a href="http://en.cppreference.com/w/cpp/utility/functional/ref">std::ref</a>, or
+<a href="http://en.cppreference.com/w/cpp/language/lambda">lambdas</a>:
 \code
-mat1.unaryExpr(std::ptr_fun(foo));
+mat1.unaryExpr(&foo);
 mat1.unaryExpr(std::ref(foo));
 mat1.unaryExpr([](double x) { return foo(x); });
 \endcode
 
-Please note that it's not possible to pass a raw function pointer to \c unaryExpr, so please warp it as shown above.
+Please note that a function name such as \c foo cannot be passed directly to \c unaryExpr, so pass a function pointer
+or wrap it as shown above.
 
 <a href="#" class="top">top</a>
 \section QuickRef_Reductions Reductions
@@ -533,11 +536,8 @@
 
 <a href="#" class="top">top</a>\section QuickRef_Blocks Sub-matrices
 
-<div class="warningbox">
-<strong>PLEASE HELP US IMPROVING THIS SECTION.</strong>
-%Eigen 3.4 supports a much improved API for sub-matrices, including,
-slicing and indexing from arrays: \ref TutorialSlicingIndexing
-</div>
+\note %Eigen also supports a more powerful `operator()` API for sub-matrices, including slicing
+with arithmetic sequences and indexing from arrays of indices; see \ref TutorialSlicingIndexing.
 
 Read-write access to a \link DenseBase::col(Index) column \endlink
 or a \link DenseBase::row(Index) row \endlink of a matrix (or array):
@@ -593,10 +593,13 @@
 
 <a href="#" class="top">top</a>\section QuickRef_Misc Miscellaneous operations
 
-<div class="warningbox">
-<strong>PLEASE HELP US IMPROVING THIS SECTION.</strong>
-%Eigen 3.4 supports a new API for reshaping: \ref TutorialReshape
-</div>
+\subsection QuickRef_ReshapeRef Reshape
+Matrices and arrays can be viewed with different dimensions through `reshaped()` (see \ref TutorialReshape):
+\code
+mat.reshaped(nrows, ncols)      // 2D view with the given dimensions
+mat.reshaped()                  // 1D linear (column-vector) view
+mat.reshaped<AutoOrder>()       // 1D view following the storage order of mat
+\endcode
 
 \subsection QuickRef_Reverse Reverse
 Vectors, rows, and/or columns of a matrix can be reversed (see DenseBase::reverse(), DenseBase::reverseInPlace(), VectorwiseOp::reverse()).
@@ -608,10 +611,10 @@
 \subsection QuickRef_Replicate Replicate
 Vectors, matrices, rows, and/or columns can be replicated in any direction (see DenseBase::replicate(), VectorwiseOp::replicate())
 \code
-vec.replicate(times)                                          vec.replicate<Times>
+vec.replicate(times, 1)                                       vec.replicate<Times, 1>()
 mat.replicate(vertical_times, horizontal_times)               mat.replicate<VerticalTimes, HorizontalTimes>()
-mat.colwise().replicate(vertical_times, horizontal_times)     mat.colwise().replicate<VerticalTimes, HorizontalTimes>()
-mat.rowwise().replicate(vertical_times, horizontal_times)     mat.rowwise().replicate<VerticalTimes, HorizontalTimes>()
+mat.colwise().replicate(times)                                mat.colwise().replicate<Times>()
+mat.rowwise().replicate(times)                                mat.rowwise().replicate<Times>()
 \endcode
 
 
@@ -683,7 +686,8 @@
 Products:
 </td><td>\code
 m3 += s1 * m1.adjoint().triangularView<Eigen::UnitUpper>() * m2
-m3 -= s1 * m2.conjugate() * m1.adjoint().triangularView<Eigen::Lower>() \endcode
+m3 -= s1 * m2.conjugate() * m1.adjoint().triangularView<Eigen::Lower>()
+m3  = m1.triangularView<Eigen::Upper>() * m2.triangularView<Eigen::Lower>()  // dense result \endcode
 </td></tr>
 <tr><td>
 Solving linear equations:\n
@@ -745,63 +749,4 @@
 </table>
 
 */
-
-/*
-<table class="tutorial_code">
-<tr><td>
-\link MatrixBase::asDiagonal() make a diagonal matrix \endlink \n from a vector </td><td>\code
-mat1 = vec1.asDiagonal();\endcode
-</td></tr>
-<tr><td>
-Declare a diagonal matrix</td><td>\code
-DiagonalMatrix<Scalar,SizeAtCompileTime> diag1(size);
-diag1.diagonal() = vector;\endcode
-</td></tr>
-<tr><td>Access \link MatrixBase::diagonal() the diagonal and super/sub diagonals of a matrix \endlink as a vector (read/write)</td>
- <td>\code
-vec1 = mat1.diagonal();            mat1.diagonal() = vec1;      // main diagonal
-vec1 = mat1.diagonal(+n);          mat1.diagonal(+n) = vec1;    // n-th super diagonal
-vec1 = mat1.diagonal(-n);          mat1.diagonal(-n) = vec1;    // n-th sub diagonal
-vec1 = mat1.diagonal<1>();         mat1.diagonal<1>() = vec1;   // first super diagonal
-vec1 = mat1.diagonal<-2>();        mat1.diagonal<-2>() = vec1;  // second sub diagonal
-\endcode</td>
-</tr>
-
-<tr><td>View on a triangular part of a matrix (read/write)</td>
- <td>\code
-mat2 = mat1.triangularView<Xxx>();
-// Xxx = Upper, Lower, StrictlyUpper, StrictlyLower, UnitUpper, UnitLower
-mat1.triangularView<Upper>() = mat2 + mat3; // only the upper part is evaluated and referenced
-\endcode</td></tr>
-
-<tr><td>View a triangular part as a symmetric/self-adjoint matrix (read/write)</td>
- <td>\code
-mat2 = mat1.selfadjointView<Xxx>();     // Xxx = Upper or Lower
-mat1.selfadjointView<Upper>() = mat2 + mat2.adjoint();  // evaluated and write to the upper triangular part only
-\endcode</td></tr>
-
-</table>
-
-Optimized products:
-\code
-mat3 += scalar * vec1.asDiagonal() * mat1
-mat3 += scalar * mat1 * vec1.asDiagonal()
-mat3.noalias() += scalar * mat1.triangularView<Xxx>() * mat2
-mat3.noalias() += scalar * mat2 * mat1.triangularView<Xxx>()
-mat3.noalias() += scalar * mat1.selfadjointView<Upper or Lower>() * mat2
-mat3.noalias() += scalar * mat2 * mat1.selfadjointView<Upper or Lower>()
-mat1.selfadjointView<Upper or Lower>().rankUpdate(mat2);
-mat1.selfadjointView<Upper or Lower>().rankUpdate(mat2.adjoint(), scalar);
-\endcode
-
-Inverse products: (all are optimized)
-\code
-mat3 = vec1.asDiagonal().inverse() * mat1
-mat3 = mat1 * diag1.inverse()
-mat1.triangularView<Xxx>().solveInPlace(mat2)
-mat1.triangularView<Xxx>().solveInPlace<OnTheRight>(mat2)
-mat2 = mat1.selfadjointView<Upper or Lower>().llt().solve(mat2)
-\endcode
-
-*/
 }
diff --git a/doc/QuickStartGuide.dox b/doc/QuickStartGuide.dox
index 6042aca..5e307ba 100644
--- a/doc/QuickStartGuide.dox
+++ b/doc/QuickStartGuide.dox
@@ -8,7 +8,7 @@
 
 \section GettingStartedInstallation How to "install" Eigen?
 
-In order to use Eigen, you just need to download and extract Eigen's source code (see <a href="http://eigen.tuxfamily.org/index.php?title=Main_Page#Download">the wiki</a> for download instructions). In fact, the header files in the \c Eigen subdirectory are the only files required to compile programs using Eigen. The header files are the same for all platforms. It is not necessary to use CMake or install anything.
+In order to use Eigen, you just need to download and extract Eigen's source code (releases are published on <a href="https://gitlab.com/libeigen/eigen/-/releases">Eigen's GitLab project</a>). In fact, the header files in the \c Eigen subdirectory are the only files required to compile programs using Eigen. The header files are the same for all platforms. It is not necessary to use CMake or install anything.
 
 
 \section GettingStartedFirstProgram A simple first program
@@ -26,7 +26,7 @@
 
 \code g++ -I /path/to/eigen/ my_program.cpp -o my_program \endcode
 
-On Linux or Mac OS X, another option is to symlink or copy the Eigen folder into \c /usr/local/include/. This way, you can compile the program with:
+On Linux or macOS, another option is to symlink or copy the Eigen folder into \c /usr/local/include/. This way, you can compile the program with:
 
 \code g++ my_program.cpp -o my_program \endcode
 
diff --git a/doc/SparseLinearSystems.dox b/doc/SparseLinearSystems.dox
index 0c7bfc1..9deb9a6 100644
--- a/doc/SparseLinearSystems.dox
+++ b/doc/SparseLinearSystems.dox
@@ -21,6 +21,9 @@
 <tr><td>SimplicialLDLT \n <tt>\#include<Eigen/\link SparseCholesky_Module SparseCholesky\endlink></tt></td><td>Direct LDLt factorization</td><td>SPD</td><td>Fill-in reducing</td>
     <td>Recommended for very sparse and not too large problems (e.g., 2D Poisson eq.)</td></tr>
 
+<tr><td>SimplicialNonHermitianLLT \n SimplicialNonHermitianLDLT \n <tt>\#include<Eigen/\link SparseCholesky_Module SparseCholesky\endlink></tt></td><td>Direct LLt, LDLt factorizations without conjugation</td><td>Complex symmetric</td><td>Fill-in reducing</td>
+    <td>For complex symmetric (non-Hermitian) matrices, e.g., arising from PDEs with absorbing boundary conditions</td></tr>
+
 <tr><td>SparseLU \n <tt>\#include<Eigen/\link SparseLU_Module SparseLU\endlink></tt></td> <td>LU factorization </td>
     <td>Square </td><td>Fill-in reducing, Leverage fast dense algebra</td>
     <td>optimized for small and large problems with irregular patterns </td></tr>
@@ -44,9 +47,37 @@
     <td>IdentityPreconditioner, [LeastSquareDiagonalPreconditioner]</td>
     <td>Solve for min |Ax-b|^2 without forming A'A</td></tr>
 
+<tr><td>LSMR \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Golub-Kahan bidiagonalization (MINRES on the normal equations)</td><td>Rectangular</td>
+    <td>[IdentityPreconditioner], (self-adjoint right preconditioner)</td>
+    <td>Solve for min |Ax-b|^2, monotonic |A'r|, optional damping. Robust on ill-conditioned problems</td></tr>
+
 <tr><td>BiCGSTAB \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Iterative stabilized bi-conjugate gradient</td><td>Square</td>
     <td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
     <td>To speedup the convergence, try it with the \ref IncompleteLUT preconditioner.</td></tr>
+
+<tr><td>BiCGSTABL \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Generalization of BiCGSTAB with higher-degree stabilization polynomials</td><td>Square</td>
+    <td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
+    <td>More robust than BiCGSTAB on problems where the convergence of BiCGSTAB stagnates</td></tr>
+
+<tr><td>MINRES \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Minimal residual method</td><td>Symmetric, possibly indefinite</td>
+    <td>[IdentityPreconditioner], DiagonalPreconditioner (must be positive definite)</td>
+    <td>Handles symmetric indefinite systems that CG cannot; monotonically decreasing residual</td></tr>
+
+<tr><td>GMRES \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Restarted generalized minimal residual method</td><td>Square</td>
+    <td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
+    <td>Robust general-purpose Krylov method; memory grows with the restart length</td></tr>
+
+<tr><td>DGMRES \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Restarted GMRES with deflation</td><td>Square</td>
+    <td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
+    <td>Deflation of the smallest eigenvalues can restore the convergence lost at restarts</td></tr>
+
+<tr><td>IDRS \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Induced dimension reduction method IDR(s)</td><td>Square</td>
+    <td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
+    <td>Short recurrences with tunable subspace dimension \c s; often converges where BiCGSTAB fails</td></tr>
+
+<tr><td>IDRSTABL \n <tt>\#include<Eigen/\link IterativeLinearSolvers_Module IterativeLinearSolvers\endlink></tt></td><td>Combination of IDR(s) and BiCGSTAB(L)</td><td>Square</td>
+    <td>IdentityPreconditioner, [DiagonalPreconditioner], IncompleteLUT</td>
+    <td>Combines the strengths of IDR(s) and BiCGSTAB(L) for hard nonsymmetric problems</td></tr>
 </table>
 
 \subsection TutorialSparseSolverList_Wrapper Wrappers to external solvers
@@ -55,7 +86,7 @@
 <tr><th>Class</th><th>Module</th><th>Solver kind</th><th>Matrix kind</th><th>Features related to performance</th>
     <th>Dependencies,License</th><th class="width20em"><p>Notes</p></th></tr>
 <tr><td>PastixLLT \n PastixLDLT \n PastixLU</td><td>\link PaStiXSupport_Module PaStiXSupport \endlink</td><td>Direct LLt, LDLt, LU factorizations</td><td>SPD \n SPD \n Square</td><td>Fill-in reducing, Leverage fast dense algebra, Multithreading</td>
-    <td>Requires the <a href="http://pastix.gforge.inria.fr">PaStiX</a> package, \b CeCILL-C </td>
+    <td>Requires the <a href="https://gitlab.inria.fr/solverstack/pastix">PaStiX</a> package, \b CeCILL-C </td>
     <td>optimized for tough problems and symmetric patterns</td></tr>
 <tr><td>CholmodSupernodalLLT</td><td>\link CholmodSupport_Module CholmodSupport \endlink</td><td>Direct LLt factorization</td><td>SPD</td><td>Fill-in reducing, Leverage fast dense algebra</td>
     <td>Requires the <a href="http://www.suitesparse.com">SuiteSparse</a> package, \b GPL </td>
@@ -67,13 +98,13 @@
     <td>Requires the <a href="http://www.suitesparse.com">SuiteSparse</a> package, \b GPL </td>
     <td></td></tr>
 <tr><td>SuperLU</td><td>\link SuperLUSupport_Module SuperLUSupport \endlink</td><td>Direct LU factorization</td><td>Square</td><td>Fill-in reducing, Leverage fast dense algebra</td>
-    <td>Requires the <a href="http://crd-legacy.lbl.gov/~xiaoye/SuperLU/">SuperLU</a> library, (BSD-like)</td>
+    <td>Requires the <a href="https://github.com/xiaoyeli/superlu">SuperLU</a> library, (BSD-like)</td>
     <td></td></tr>
 <tr><td>SPQR</td><td>\link SPQRSupport_Module SPQRSupport \endlink  </td> <td> QR factorization </td> 
     <td> Any, rectangular</td><td>fill-in reducing, multithreaded, fast dense algebra</td>
     <td> requires the <a href="http://www.suitesparse.com">SuiteSparse</a> package, \b GPL </td><td>recommended for linear least-squares problems, has a rank-revealing feature</tr>
 <tr><td>PardisoLLT \n PardisoLDLT \n PardisoLU</td><td>\link PardisoSupport_Module PardisoSupport \endlink</td><td>Direct LLt, LDLt, LU factorizations</td><td>SPD \n SPD \n Square</td><td>Fill-in reducing, Leverage fast dense algebra, Multithreading</td>
-    <td>Requires the <a href="http://eigen.tuxfamily.org/Counter/redirect_to_mkl.php">Intel MKL</a> package, \b Proprietary </td>
+    <td>Requires the <a href="https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl.html">Intel oneMKL</a> package, \b Proprietary </td>
     <td>optimized for tough problems patterns, see also \link TopicUsingIntelMKL using MKL with Eigen \endlink</td></tr>
 <tr><td>AccelerateLLT \n AccelerateLDLT \n AccelerateQR</td><td>\link AccelerateSupport_Module AccelerateSupport \endlink</td><td>Direct LLt, LDLt, QR factorizations</td><td>SPD \n SPD \n Rectangular</td><td>Fill-in reducing, Leverage fast dense algebra, Multithreading</td>
     <td>Requires the <a href="https://developer.apple.com/documentation/accelerate">Apple Accelerate</a> package, \b Proprietary </td>
@@ -156,7 +187,7 @@
 
 For iterative solvers, the compute step is used to eventually setup a preconditioner. For instance, with the ILUT preconditioner, the incomplete factors L and U are computed in this step. Remember that, basically, the goal of the preconditioner is to speedup the convergence of an iterative method by solving a modified linear system where the coefficient matrix has more clustered eigenvalues. For real problems, an iterative solver should always be used with a preconditioner. In Eigen, a preconditioner is  selected by simply adding it as a template parameter to the iterative solver object. 
 \code
-IterativeSolverClassName<SparseMatrix<double>, PreconditionerName<SparseMatrix<double> > solver; 
+IterativeSolverClassName<SparseMatrix<double>, PreconditionerName<SparseMatrix<double>::Scalar> > solver;
 \endcode
 The member function `preconditioner()` returns a read-write reference to the preconditioner 
  to directly interact with it. See the \link IterativeLinearSolvers_Module Iterative solvers module \endlink and the documentation of each class for the list of available methods.
@@ -178,9 +209,9 @@
 \section BenchmarkRoutine
 Most of the time, all you need is to know how much time it will take to solve your system, and hopefully, what is the most suitable solver. You can benchmark solvers by timing them on matrices in <a href="http://math.nist.gov/MatrixMarket/formats.html">MatrixMarket Coordinate format</a>. See the `benchmarks/Sparse/` directory for example benchmarks.
 
-To export your matrices and right-hand-side vectors in the matrix-market format, you can use the unsupported SparseExtra module:
+To export your matrices and right-hand-side vectors in the matrix-market format, you can use the contrib SparseExtra module:
 \code
-#include <unsupported/Eigen/SparseExtra>
+#include <contrib/Eigen/SparseExtra>
 ...
 Eigen::saveMarket(A, "filename.mtx");
 Eigen::saveMarket(A, "filename_SPD.mtx", Eigen::Symmetric); // if A is symmetric-positive-definite
diff --git a/doc/SparseQuickReference.dox b/doc/SparseQuickReference.dox
index b8eac8d..af7dcc4 100644
--- a/doc/SparseQuickReference.dox
+++ b/doc/SparseQuickReference.dox
@@ -30,12 +30,12 @@
 <tr> 
 <td> Assignment </td>
 <td> 
-\code 
-  SparseMatrix<double,Colmajor> sm1;
+\code
+  SparseMatrix<double,ColMajor> sm1;
  // Initialize sm2 with sm1.
-  SparseMatrix<double,Rowmajor> sm2(sm1), sm3;        
+  SparseMatrix<double,RowMajor> sm2(sm1), sm3;
   // Assignment and evaluations modify the storage order.
-  sm3 = sm1; 
+  sm3 = sm1;
  \endcode
 </td>
 <td> The copy constructor can be used to convert from a storage order to another</td>
@@ -62,13 +62,13 @@
   std::vector< Eigen::Triplet<double> > tripletList;
   tripletList.reserve(estimation_of_entries);
   // -- Fill tripletList with nonzero elements...
-  sm1.setFromTriplets(TripletList.begin(), TripletList.end());
+  sm1.setFromTriplets(tripletList.begin(), tripletList.end());
 \endcode
 </td>
 <td>A complete example is available at \link TutorialSparseFilling Triplet Insertion \endlink.</td>
 </tr>
-<tr class="alt"> 
-<td> Constant or Random Insertion</td>
+<tr class="alt">
+<td> Reset to zero</td>
 <td>
 \code
 sm1.setZero();
@@ -153,8 +153,8 @@
 \code 
 perm.indices();      // Reference to the vector of indices
 sm1.twistedBy(perm); // Permute rows and columns
-sm2 = sm1 * perm;    // Permute the rows
-sm2 = perm * sm1;    // Permute the columns
+sm2 = sm1 * perm;    // Permute the columns
+sm2 = perm * sm1;    // Permute the rows
 \endcode 
 </td>
 <td> 
@@ -186,10 +186,9 @@
 <tr><td colspan="2">Sub-matrices</td></tr>
 <tr>
 <td> 
-\code 
-  sm1.block(startRow, startCol, rows, cols); 
-  sm1.block(startRow, startCol); 
-  sm1.topLeftCorner(rows, cols); 
+\code
+  sm1.block(startRow, startCol, rows, cols);
+  sm1.topLeftCorner(rows, cols);
   sm1.topRightCorner(rows, cols);
   sm1.bottomLeftCorner( rows, cols);
   sm1.bottomRightCorner( rows, cols);
@@ -219,15 +218,14 @@
 </tr>
 <tr><td colspan="2"> Triangular and selfadjoint views</td></tr>
 <tr>
-<td> 
+<td>
 \code
-  sm2 = sm1.triangularview<Lower>();
-  sm2 = sm1.selfadjointview<Lower>();
+  sm2 = sm1.triangularView<Lower>();
+  sm2 = sm1.selfadjointView<Lower>();
 \endcode
 </td>
-<td> Several combination between triangular views and blocks views are possible
-\code 
-  \endcode </td>
+<td> Several combinations between triangular views and blocks views are possible
+</td>
 </tr>
 <tr class="alt"><td colspan="2">Triangular solve </td></tr>
 <tr class="alt">
diff --git a/doc/StlContainers.dox b/doc/StlContainers.dox
index 0342573..9931730 100644
--- a/doc/StlContainers.dox
+++ b/doc/StlContainers.dox
@@ -12,8 +12,6 @@
 That is, an allocator capable of allocating buffers with 16, 32, or even 64 bytes alignment.
 %Eigen does provide one ready for use: aligned_allocator.
 
-Prior to \cpp11, if you want to use the `std::vector` container, then you also have to <code> \#include <Eigen/StdVector> </code>.
-
 These issues arise only with \ref TopicFixedSizeVectorizable "fixed-size vectorizable Eigen types" and \ref TopicStructHavingEigenMembers "structures having such Eigen objects as member".
 For other %Eigen types, such as Vector3f or MatrixXd, no special care is needed when using STL containers.
 
@@ -34,9 +32,7 @@
 
 \section StlContainers_vector The case of std::vector
 
-This section is for c++98/03 users only. \cpp11 (or above) users can stop reading here.
-
-So in c++98/03, the situation with `std::vector` is more complicated because of a bug in the standard (explanation below).
+On some older toolchains (notably MSVC in 64-bit mode with reduced alignment settings), the situation with `std::vector` is more complicated because of a bug in the standard (explanation below).
 To workaround the issue, we had to specialize it for the Eigen::aligned_allocator type.
 In practice you \b must use the Eigen::aligned_allocator (not another aligned allocator), \b and \#include <Eigen/StdVector>.
 
@@ -62,7 +58,7 @@
 \code
 #include<Eigen/StdVector>
 /* ... */
-EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(Matrix2d)
+EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(Eigen::Vector2d)
 std::vector<Eigen::Vector2d>
 \endcode
 
diff --git a/doc/StructHavingEigenMembers.dox b/doc/StructHavingEigenMembers.dox
index 4c97093..86f9f15 100644
--- a/doc/StructHavingEigenMembers.dox
+++ b/doc/StructHavingEigenMembers.dox
@@ -151,7 +151,7 @@
 
 \section StructHavingEigenMembers_othersolutions Other solutions
 
-In case putting the `EIGEN_MAKE_ALIGNED_OPERATOR_NEW` macro everywhere is too intrusive, there exists at least two other solutions.
+In case putting the `EIGEN_MAKE_ALIGNED_OPERATOR_NEW` macro everywhere is too intrusive, there are other solutions.
 
 \subsection othersolutions1 Disabling alignment
 
@@ -168,9 +168,38 @@
 This has only for effect to make load/stores to `v` more expensive (usually slightly, but that's hardware dependent).
 
 
-\subsection othersolutions2 Private structure
+\subsection othersolutions2 Owning Eigen objects through smart pointers
 
-The second consist in storing the fixed-size objects into a private struct which will be dynamically allocated at the construction time of the main object:
+If only one or two fixed-size vectorizable Eigen objects are involved, the containing class can store them through
+owning smart pointers instead of storing them directly. Then each Eigen object is dynamically allocated on its own and
+uses Eigen's aligned allocation, while the containing object no longer has an over-aligned Eigen member:
+
+\code
+class Foo
+{
+  ...
+  std::unique_ptr<Eigen::Vector4d> v;
+  ...
+public:
+  Foo() : v(new Eigen::Vector4d) {}
+  void bar()
+  {
+    // use *v instead of v
+    ...
+  }
+};
+\endcode
+
+Do not use a naked owning pointer for this unless you also define the destructor and copy/move operations correctly.
+A `std::unique_ptr` member also makes `Foo` non-copyable unless you define copy operations with the desired ownership
+semantics.
+For several Eigen members, grouping them into a helper structure as shown below is usually clearer and requires only
+one additional allocation.
+
+\subsection othersolutions3 Private structure
+
+Another solution consists in storing the fixed-size objects into a private struct which will be dynamically allocated
+at the construction time of the main object:
 
 \code
 struct Foo_d
diff --git a/doc/TemplateKeyword.dox b/doc/TemplateKeyword.dox
index fbf2c70..a9cb203 100644
--- a/doc/TemplateKeyword.dox
+++ b/doc/TemplateKeyword.dox
@@ -108,9 +108,9 @@
 
 \code
 template <typename T>
-void iterateOverSparseMatrix(const SparseMatrix<T>& mat;
+void iterateOverSparseMatrix(const SparseMatrix<T>& mat)
 {
-  for (int k=0; k<m1.outerSize(); ++k)
+  for (int k=0; k<mat.outerSize(); ++k)
     for (typename SparseMatrix<T>::InnerIterator it(mat,k); it; ++it)
     {
       /* ... */
@@ -124,10 +124,9 @@
 For more information and a fuller explanation of this topic, the reader may consult the following sources:
 - The book "C++ Template Metaprogramming" by David Abrahams and Aleksey Gurtovoy contains a very good
   explanation in Appendix B ("The typename and template Keywords") which formed the basis for this page.
-- http://pages.cs.wisc.edu/~driscoll/typename.html
-- http://www.parashift.com/c++-faq-lite/templates.html#faq-35.18
-- http://www.comeaucomputing.com/techtalk/templates/#templateprefix
-- http://www.comeaucomputing.com/techtalk/templates/#typename
+- The cppreference page on <a href="https://en.cppreference.com/w/cpp/language/dependent_name">dependent names</a>.
+- The ISO C++ FAQ entry on
+  <a href="https://isocpp.org/wiki/faq/templates#nondependent-name-lookup-members">name lookup within class templates</a>.
 
 */
 }
diff --git a/doc/TopicAliasing.dox b/doc/TopicAliasing.dox
index a8f1644..cedc1b6 100644
--- a/doc/TopicAliasing.dox
+++ b/doc/TopicAliasing.dox
@@ -64,14 +64,14 @@
 and exits with a message like
 
 \verbatim
-void Eigen::DenseBase<Derived>::checkTransposeAliasing(const OtherDerived&) const 
-[with OtherDerived = Eigen::Transpose<Eigen::Matrix<int, 2, 2, 0, 2, 2> >, Derived = Eigen::Matrix<int, 2, 2, 0, 2, 2>]: 
-Assertion `(!internal::check_transpose_aliasing_selector<Scalar,internal::blas_traits<Derived>::IsTransposed,OtherDerived>::run(internal::extract_data(derived()), other)) 
+static void Eigen::internal::checkTransposeAliasing_impl<Derived, OtherDerived>::run(const Derived&, const OtherDerived&)
+[with Derived = Eigen::Matrix<int, 2, 2>; OtherDerived = Eigen::Transpose<Eigen::Matrix<int, 2, 2> >]:
+Assertion `(!check_transpose_aliasing_run_time_selector<Scalar, blas_traits<Derived>::IsTransposed, OtherDerived>::run(extract_data(dst), other))
 && "aliasing detected during transposition, use transposeInPlace() or evaluate the rhs into a temporary using .eval()"' failed.
 \endverbatim
 
-The user can turn %Eigen's run-time assertions like the one to detect this aliasing problem off by defining the
-EIGEN_NO_DEBUG macro, and the above program was compiled with this macro turned off in order to illustrate the
+The user can disable %Eigen's run-time assertions, including the one detecting this aliasing problem, by defining the
+EIGEN_NO_DEBUG macro. The above program was compiled with assertions disabled in this way in order to illustrate the
 aliasing problem. See \ref TopicAssertions for more information about %Eigen's run-time assertions.
 
 
diff --git a/doc/TopicAssertions.dox b/doc/TopicAssertions.dox
index a2cc6cf..5e1bb08 100644
--- a/doc/TopicAssertions.dox
+++ b/doc/TopicAssertions.dox
@@ -6,7 +6,7 @@
 
 \section PlainAssert Assertions
 
-The macro eigen_assert is defined to be \c eigen_plain_assert by default. We use eigen_plain_assert instead of \c assert to work around a known bug for GCC <= 4.3. Basically, eigen_plain_assert \a is \c assert.
+The macro eigen_assert is defined to be \c eigen_plain_assert by default, and eigen_plain_assert essentially behaves like the standard \c assert. Having %Eigen's own layer instead of using \c assert directly lets %Eigen handle device code (assertions in GPU kernels are disabled unless explicitly enabled) and avoid ODR pitfalls caused by \c __FILE__ expanding differently across translation units; see Eigen/src/Core/util/Assert.h for the details.
 
 \subsection RedefineAssert Redefining assertions
 
@@ -25,44 +25,27 @@
 
 \section StaticAssert Static assertions
 
-Static assertions are not standardized until C++11. However, in the Eigen library, there are many conditions can and should be detectedat compile time. For instance, we use static assertions to prevent the code below from compiling.
+In the Eigen library, there are many conditions that can and should be detected at compile time. For instance, we use static assertions to prevent the code below from compiling.
 
 \code
 Matrix3d()  + Matrix4d();   // adding matrices of different sizes
 Matrix4cd() * Vector3cd();  // invalid product known at compile time
 \endcode
 
-Static assertions are defined in StaticAssert.h. If there is native static_assert, we use it. Otherwise, we have implemented an assertion macro that can show a limited range of messages.
-
-One can easily come up with static assertions without messages, such as:
+Static assertions are defined in StaticAssert.h. EIGEN_STATIC_ASSERT(CONDITION,MSG) expands to the native
+<tt>static_assert</tt>:
 
 \code
-#define STATIC_ASSERT(x) \
-  switch(0) { case 0: case x:; }
+#define EIGEN_STATIC_ASSERT(X,MSG) static_assert(X, #MSG);
 \endcode
 
-However, the example above obviously cannot tell why the assertion failed. Therefore, we define a \c struct in namespace Eigen::internal to handle available messages.
+\c CONDITION must be a compile-time boolean expression. \c MSG is not evaluated: it is stringified into the
+diagnostic, which is why the messages are written ALL_CAPS_AND_THEY_ARE_SHOUTING, as in
+\c YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX. Use one of the existing messages where it fits; see StaticAssert.h
+for the established names.
 
-\code
-template<bool condition>
-struct static_assertion {};
-
-template<>
-struct static_assertion<true>
-{
-  enum {
-    YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX,
-    YOU_MIXED_VECTORS_OF_DIFFERENT_SIZES,
-    // see StaticAssert.h for all enums.
-  };
-};
-\endcode
-
-And then, we define EIGEN_STATIC_ASSERT(CONDITION,MSG) to access Eigen::internal::static_assertion<bool(CONDITION)>::MSG. If the condition evaluates into \c false, your compiler displays a lot of messages explaining there is no MSG in static_assert<false>. Nevertheless, this is \a not in what we are interested. As you can see, all members of static_assert<true> are ALL_CAPS_AND_THEY_ARE_SHOUTING.
-
-\warning
-When using this macro, MSG should be a member of static_assertion<true>, or the static assertion \b always fails.
-Currently, it can only be used in function scope.
+Because it expands to a declaration, EIGEN_STATIC_ASSERT can be used wherever a declaration is allowed, including
+class scope — see for instance \c log1p_impl in MathFunctions.h.
 
 \subsection DerivedStaticAssert Derived static assertions
 
@@ -96,13 +79,14 @@
 
 \subsection DisableStaticAssert Disabling static assertions
 
-If \c EIGEN_NO_STATIC_ASSERT is defined, static assertions turn into <tt>eigen_assert</tt>'s, working like:
+If \c EIGEN_NO_STATIC_ASSERT is defined, the static assertions are removed entirely:
 
 \code
-#define EIGEN_STATIC_ASSERT(CONDITION,MSG) eigen_assert((CONDITION) && #MSG);
+#define EIGEN_STATIC_ASSERT(CONDITION,MSG)
 \endcode
 
-This saves compile time but consumes more run time. \c EIGEN_NO_STATIC_ASSERT is undefined by default.
+They are not downgraded to run-time checks, so the misuse they guard against is reported neither at compile time
+nor at run time. \c EIGEN_NO_STATIC_ASSERT is undefined by default.
 
 */
 }
diff --git a/doc/TopicCMakeGuide.dox b/doc/TopicCMakeGuide.dox
index dc0d706..f73a0a6 100644
--- a/doc/TopicCMakeGuide.dox
+++ b/doc/TopicCMakeGuide.dox
@@ -7,7 +7,9 @@
 %Eigen provides native CMake support which allows the library to be easily
 used in CMake projects.
 
-\note %CMake 3.5 (or later) is required to enable this functionality.
+\note Configuring and installing %Eigen requires %CMake 3.18 (or later). The generated `Eigen3Config.cmake`
+imposes no version floor of its own, so a project consuming an already-installed %Eigen may use an older %CMake;
+the \ref title_fetchcontent route below adds %Eigen's own build to your project and so requires 3.18 as well.
 
 %Eigen exports a CMake target called `Eigen3::Eigen` which can be imported
 using the `find_package` CMake command and used by calling
@@ -34,12 +36,15 @@
 encountered.  To request a specific version of %Eigen, use the `<version>`
 option in `find_package`:
 ```
-find_package(Eigen3 3.4 REQUIRED NO_MODULE)  # Restricts to 3.4.z
+find_package(Eigen3 3.4 REQUIRED NO_MODULE)  # Any version >=3.4 but <4.0.0.
 ```
 Starting with Eigen 3.4.1, we also support a range spanning major versions:
 ```
 find_package(Eigen3 3.4...5 REQUIRED NO_MODULE)  # Any version >=3.4.1 but <6.0.0.
 ```
+\note Version ranges are `find_package` syntax introduced in %CMake 3.19. Older %CMake
+passes `3.4...5` through as a single version string, which `Eigen3ConfigVersion.cmake`
+cannot parse and therefore rejects.
 
 Do not forget to set the <a href="https://cmake.org/cmake/help/v3.7/variable/CMAKE_PREFIX_PATH.html">\c CMAKE_PREFIX_PATH </a> variable if Eigen is not installed in a default location or if you want to pick a specific version. For instance:
 \code{.sh}
@@ -60,6 +65,110 @@
 endif (TARGET Eigen3::Eigen)
 \endcode
 
+\section title_fetchcontent Using FetchContent
+
+You can use the
+<a href="https://cmake.org/cmake/help/latest/module/FetchContent.html">FetchContent</a>
+module to download and include %Eigen directly in your project without
+installing it first. This adds %Eigen's own build to your project, so it requires
+%CMake 3.18 rather than the 3.11 that introduced FetchContent.
+
+A basic example:
+\code{.cmake}
+cmake_minimum_required(VERSION 3.18)
+project(myproject)
+
+include(FetchContent)
+FetchContent_Declare(
+  Eigen
+  GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+  GIT_TAG        master
+  GIT_SHALLOW    TRUE
+)
+FetchContent_MakeAvailable(Eigen)
+
+add_executable(example example.cpp)
+target_link_libraries(example Eigen3::Eigen)
+\endcode
+
+\subsection title_fetchcontent_options Disabling Eigen build options
+
+When %Eigen is added as a sub-project, its documentation, testing, and
+pkg-config targets may collide with your project's own targets. Disable
+them before calling \c FetchContent_MakeAvailable:
+\code{.cmake}
+set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE)
+set(EIGEN_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
+set(EIGEN_BUILD_PKGCONFIG OFF CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(Eigen)
+\endcode
+
+\subsection title_fetchcontent_install Disabling Eigen's install rules
+
+%Eigen's install rules are enabled even when it is built as a sub-project, so
+that a project embedding %Eigen can ship it as part of its own package. If your
+project does not want %Eigen's headers to land in \c CMAKE_INSTALL_PREFIX (or in
+a \c CPack package), set \c EIGEN_INSTALL to \c OFF:
+\code{.cmake}
+set(EIGEN_INSTALL OFF CACHE BOOL "" FORCE)
+
+FetchContent_MakeAvailable(Eigen)
+\endcode
+
+%Eigen then places no file at all under \c CMAKE_INSTALL_PREFIX, the generated
+documentation included.
+
+\note %CMake refuses to generate an \c install(EXPORT ...) whose targets link a
+target that no installed export set provides. So if you export your own targets
+and their public interface links \c Eigen3::Eigen, you must either leave
+\c EIGEN_INSTALL on and install %Eigen's CMake package alongside them, or consume
+%Eigen through \c find_package instead of embedding it.
+
+\subsection title_fetchcontent_exclude Using EXCLUDE_FROM_ALL
+
+Projects that depend on %Eigen should typically exclude installing %Eigen by
+default to avoid overwriting a previous installation. Passing
+\c EXCLUDE_FROM_ALL to \c add_subdirectory drops %Eigen's install rules, and in
+addition keeps %Eigen's targets out of the default build. That form works on
+every %CMake version %Eigen supports:
+\code{.cmake}
+add_subdirectory(path/to/eigen eigen-build EXCLUDE_FROM_ALL)
+\endcode
+
+\c FetchContent_Declare accepts the same keyword, but only from %CMake 3.28
+onwards, so a project using it has to say so:
+\code{.cmake}
+cmake_minimum_required(VERSION 3.28)
+
+include(FetchContent)
+FetchContent_Declare(
+  Eigen
+  GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+  GIT_TAG        master
+  GIT_SHALLOW    TRUE
+  EXCLUDE_FROM_ALL
+)
+FetchContent_MakeAvailable(Eigen)
+\endcode
+
+\warning %CMake 3.17 through 3.27 accept \c EXCLUDE_FROM_ALL in
+\c FetchContent_Declare without complaint and ignore it, so %Eigen is installed
+anyway. Below 3.28, use \c EIGEN_INSTALL or the \c add_subdirectory form.
+
+\subsection title_fetchcontent_cmake330 Note for CMake 3.30 and later
+
+CMake 3.30 changed the default value of the
+<a href="https://cmake.org/cmake/help/latest/policy/CMP0168.html">CMP0168</a>
+policy so that \c FetchContent_Declare uses
+\c FetchContent_Populate internally with a different sub-build strategy.
+If you encounter issues with sub-builds you can either upgrade to a
+compatible %Eigen version or set the policy explicitly:
+\code{.cmake}
+cmake_policy(SET CMP0168 OLD)
+\endcode
+
 */
 
 }
diff --git a/doc/TopicEigenExpressionTemplates.dox b/doc/TopicEigenExpressionTemplates.dox
index b31fd47..4efc1b5 100644
--- a/doc/TopicEigenExpressionTemplates.dox
+++ b/doc/TopicEigenExpressionTemplates.dox
@@ -2,10 +2,73 @@
 
 /** \page TopicEigenExpressionTemplates Expression templates in Eigen
 
+Arithmetic operators and most methods in %Eigen do not compute anything by themselves. Instead they
+return a small \em expression \em object that merely describes the computation to be performed and
+stores references to the operands. The actual computation happens later, typically when the whole
+expression is assigned to a destination. This technique is known as <i>expression templates</i>,
+and understanding its user-visible consequences helps to write both correct and fast %Eigen code.
 
-TODO: write this dox page!
+\eigenAutoToc
 
-Is linked from the tutorial on arithmetic ops.
+\section TopicETHow How it works
+
+Consider:
+\code
+VectorXf a(50), b(50), c(50), d(50);
+a = 3*b + 4*c + 5*d;
+\endcode
+
+The right-hand side does not create any temporary vector. The subexpression \c 3*b is an object of
+type <tt>CwiseBinaryOp<scalar_product_op, ..., ...></tt> that just stores the scalar and a reference
+to \c b; the additions nest similar objects around it. The complete type of the right-hand side
+encodes the whole expression tree at compile time. Only when this expression is assigned to \c a
+does %Eigen generate a single evaluation loop, morally equivalent to:
+\code
+for (int i = 0; i < 50; ++i)
+  a[i] = 3*b[i] + 4*c[i] + 5*d[i];
+\endcode
+
+The benefits are that the arrays are traversed only once, no temporary objects are created, and the
+single fused loop can be unrolled and vectorized (see \ref TopicVectorization). Consequently, you
+should not be afraid of writing large expressions: doing so gives %Eigen more opportunities for
+optimization. A step-by-step tour of the machinery behind this example is given in
+\ref TopicInsideEigenExample, and the involved class hierarchy is described in
+\ref TopicClassHierarchy.
+
+Not every subexpression is evaluated lazily: matrix products, for instance, are evaluated into
+temporaries in most contexts, both for performance and for correctness in the face of aliasing.
+The rules governing which subexpressions are evaluated where are documented in
+\ref TopicLazyEvaluation.
+
+\section TopicETConsequences What it means in practice
+
+Because an "expression" is not a matrix, a few things deserve attention:
+
+  - <b>Do not use \c auto to capture an expression</b> unless you know exactly what you are doing:
+    the deduced type is the expression type, not a plain matrix, so the computation re-runs every
+    time the variable is used, and the expression may hold dangling references to destroyed
+    temporaries. See \ref TopicPitfalls_auto_keyword.
+  - <b>Assignment evaluates coefficient-wise into the destination</b>, so if the destination also
+    appears on the right-hand side, coefficients may be read after they have been overwritten. This
+    is the aliasing problem, explained in \ref TopicAliasing. Use .eval(), an xxxInPlace() method,
+    or \link MatrixBase::noalias() noalias()\endlink as appropriate.
+  - <b>Functions should accept expressions, not just matrices.</b> Take parameters of type
+    <tt>const MatrixBase<Derived>&</tt> (or ArrayBase, DenseBase, EigenBase, or Ref) so that
+    arbitrary expressions can be passed without evaluating them into a temporary; see
+    \ref TopicFunctionTakingEigenTypes.
+  - <b>Materializing an expression</b> is done with \link DenseBase::eval() .eval()\endlink, which
+    returns a plain matrix or array (and is a no-op when the expression already is one), or by
+    assigning the expression to a plain object.
+  - <b>The two branches of the ternary operator <tt>?:</tt></b> must have a common type, which two
+    different expression types usually do not; use \c if/\c else or evaluate the branches. See
+    \ref TopicPitfalls_ternary_operator.
+
+\section TopicETExtending Extending the expression system
+
+Coefficient-wise custom operations rarely need a new expression type: a functor passed to
+unaryExpr(), binaryExpr(), or NullaryExpr() is usually enough (see \ref TopicCustomizing_Functors
+and \ref TopicCustomizing_NullaryExpr). When a genuinely new expression type is required,
+\ref TopicNewExpressionType walks through a complete example.
 
 */
 
diff --git a/doc/TopicLazyEvaluation.dox b/doc/TopicLazyEvaluation.dox
index d2a704f..c2c6d05 100644
--- a/doc/TopicLazyEvaluation.dox
+++ b/doc/TopicLazyEvaluation.dox
@@ -52,37 +52,37 @@
 
 The default evaluation strategy is to fuse the operations in a single loop, and %Eigen will choose it except in a few circumstances.
 
-<b>The first circumstance</b> in which %Eigen chooses to evaluate a sub-expression is when it sees an assignment <tt>a = b;</tt> and the expression \c b has the evaluate-before-assigning \link flags flag\endlink.
+<b>The first circumstance</b> in which %Eigen chooses to evaluate a sub-expression is when it sees an assignment <tt>a = b;</tt> where \c b is an expression whose assignment logic mandates evaluation into a temporary.
 The most important example of such an expression is the \link Product matrix product expression\endlink. For example, when you do
 
 \code mat = mat * mat;
 \endcode
 
-%Eigen will evaluate <tt>mat * mat</tt> into a temporary matrix, and then copies it into the original \c mat.
+%Eigen will evaluate <tt>mat * mat</tt> into a temporary matrix, and then copy it into the original \c mat.
 This guarantees a correct result as we saw above that lazy evaluation gives wrong results with matrix products.
 It also doesn't cost much, as the cost of the matrix product itself is much higher.
 Note that this temporary is introduced at evaluation time only, that is, within operator= in this example.
-The expression <tt>mat * mat</tt> still return a abstract product type.
+The expression <tt>mat * mat</tt> still returns an abstract product type.
 
-What if you know that the result does no alias the operand of the product and want to force lazy evaluation? Then use \link MatrixBase::noalias() .noalias()\endlink instead. Here is an example:
+What if you know that the result does not alias the operand of the product and want to force lazy evaluation? Then use \link MatrixBase::noalias() .noalias()\endlink instead. Here is an example:
 
 \code mat1.noalias() = mat2 * mat2;
 \endcode
 
-Here, since we know that mat2 is not the same matrix as mat1, we know that lazy evaluation is not dangerous, so we may force lazy evaluation. Concretely, the effect of noalias() here is to bypass the evaluate-before-assigning \link flags flag\endlink.
+Here, since we know that mat2 is not the same matrix as mat1, we know that lazy evaluation is not dangerous, so we may force lazy evaluation. Concretely, the effect of noalias() here is to let the product be evaluated directly into \c mat1 instead of going through a temporary.
 
-<b>The second circumstance</b> in which %Eigen chooses to evaluate a sub-expression, is when it sees a nested expression such as <tt>a + b</tt> where \c b is already an expression having the evaluate-before-nesting \link flags flag\endlink.
+<b>The second circumstance</b> in which %Eigen chooses to evaluate a sub-expression, is when it sees a nested expression such as <tt>a + b</tt> where \c b is already an expression having the evaluate-before-nesting flag (\c EvalBeforeNestingBit).
 Again, the most important example of such an expression is the \link Product matrix product expression\endlink.
 For example, when you do
 
 \code mat1 = mat2 * mat3 + mat4 * mat5;
 \endcode
 
-the products <tt>mat2 * mat3</tt> and <tt>mat4 * mat5</tt> gets evaluated separately into temporary matrices before being summed up in <tt>mat1</tt>.
+the products <tt>mat2 * mat3</tt> and <tt>mat4 * mat5</tt> get evaluated separately into temporary matrices before being summed up in <tt>mat1</tt>.
 Indeed, to be efficient matrix products need to be evaluated within a destination matrix at hand, and not as simple "dot products".
 For small matrices, however, you might want to enforce a "dot-product" based lazy evaluation with lazyProduct().
 Again, it is important to understand that those temporaries are created at evaluation time only, that is in operator =.
-See TopicPitfalls_auto_keyword for common pitfalls regarding this remark.
+See \ref TopicPitfalls_auto_keyword for common pitfalls regarding this remark.
 
 <b>The third circumstance</b> in which %Eigen chooses to evaluate a sub-expression, is when its cost model shows that the total cost of an operation is reduced if a sub-expression gets evaluated into a temporary.
 Indeed, in certain cases, an intermediate result is sufficiently costly to compute and is reused sufficiently many times, that is worth "caching". Here is an example:
diff --git a/doc/TopicLinearAlgebraDecompositions.dox b/doc/TopicLinearAlgebraDecompositions.dox
index 8598ce6..8fb7bb7 100644
--- a/doc/TopicLinearAlgebraDecompositions.dox
+++ b/doc/TopicLinearAlgebraDecompositions.dox
@@ -31,7 +31,7 @@
         <td>PartialPivLU</td>
         <td>Invertible</td>
         <td>Fast</td>
-        <td>Depends on condition number</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
         <td>-</td>
         <td>-</td>
         <td>Yes</td>
@@ -42,10 +42,10 @@
     <tr class="alt">
         <td>FullPivLU</td>
         <td>-</td>
-        <td>Slow</td>
-        <td>Proven</td>
+        <td>Slow (no blocking)</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
         <td>Yes</td>
-        <td>-</td>
+        <td>Rank, kernel, image</td>
         <td>Yes</td>
         <td>Excellent</td>
         <td>-</td>
@@ -55,10 +55,10 @@
         <td>HouseholderQR</td>
         <td>-</td>
         <td>Fast</td>
-        <td>Depends on condition number</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
         <td>-</td>
-        <td>Orthogonalization</td>
-        <td>Yes</td>
+        <td>Orthogonalization, least squares for overdetermined systems</td>
+        <td>Yes (and does least squares)</td>
         <td>Excellent</td>
         <td>Blocking</td>
     </tr>
@@ -67,43 +67,67 @@
         <td>ColPivHouseholderQR</td>
         <td>-</td>
         <td>Fast</td>
-        <td>Good</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
         <td>Yes</td>
-        <td>Orthogonalization</td>
-        <td>Yes</td>
+        <td>Orthogonalization, least squares for overdetermined systems</td>
+        <td>Yes (and does least squares)</td>
         <td>Excellent</td>
         <td><em>-</em></td>
     </tr>
 
     <tr>
+        <td>RandColPivHouseholderQR</td>
+        <td>-</td>
+        <td>Fast (large matrices)</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
+        <td>Yes</td>
+        <td>Orthogonalization, least squares for overdetermined systems</td>
+        <td>Yes (and does least squares)</td>
+        <td>Good</td>
+        <td>Blocking, randomized pivot selection</td>
+    </tr>
+
+    <tr class="alt">
         <td>FullPivHouseholderQR</td>
         <td>-</td>
-        <td>Slow</td>
-        <td>Proven</td>
+        <td>Slow (no blocking)</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
         <td>Yes</td>
-        <td>Orthogonalization</td>
-        <td>Yes</td>
+        <td>Orthogonalization, least squares for overdetermined systems</td>
+        <td>Yes (and does least squares)</td>
         <td>Average</td>
         <td>-</td>
     </tr>
 
-    <tr class="alt">
+    <tr>
         <td>CompleteOrthogonalDecomposition</td>
         <td>-</td>
         <td>Fast</td>
-        <td>Good</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
         <td>Yes</td>
-        <td>Orthogonalization</td>
-        <td>Yes</td>
+        <td>Orthogonalization, minimum-norm least squares, pseudo-inverse</td>
+        <td>Yes (and does least squares)</td>
         <td>Excellent</td>
         <td><em>-</em></td>
     </tr>
 
+    <tr class="alt">
+        <td>RandCompleteOrthogonalDecomposition</td>
+        <td>-</td>
+        <td>Fast (large matrices)</td>
+        <td>Good<sup><a href="#note4">4</a></sup></td>
+        <td>Yes</td>
+        <td>Orthogonalization, minimum-norm least squares, pseudo-inverse</td>
+        <td>Yes (and does least squares)</td>
+        <td>Good</td>
+        <td>Blocking, randomized pivot selection</td>
+    </tr>
+
     <tr>
         <td>LLT</td>
         <td>Positive definite</td>
         <td>Very fast</td>
-        <td>Depends on condition number</td>
+        <td>Good<sup><a href="#note5">5</a></sup></td>
         <td>-</td>
         <td>-</td>
         <td>Yes</td>
@@ -120,7 +144,19 @@
         <td>-</td>
         <td>Yes</td>
         <td>Excellent</td>
-        <td><em>Soon: blocking</em></td>
+        <td>-</td>
+    </tr>
+
+    <tr>
+        <td>BunchKaufman</td>
+        <td>Self-adjoint (possibly indefinite)</td>
+        <td>Very fast</td>
+        <td>Good</td>
+        <td>-</td>
+        <td>Inertia</td>
+        <td>Yes</td>
+        <td>Good</td>
+        <td>Blocking</td>
     </tr>
 
     <tr><th class="inter" colspan="9">\n Singular values and eigenvalues decompositions</th></tr>
@@ -137,11 +173,11 @@
         <td>Blocked bidiagonalization</td>
     </tr>
 
-    <tr>
+    <tr class="alt">
         <td>JacobiSVD (two-sided)</td>
         <td>-</td>
         <td>Slow (but fast for small matrices)</td>
-        <td>Proven<sup><a href="#note3">3</a></sup></td>
+        <td>High relative accuracy<sup><a href="#note3">3</a></sup></td>
         <td>Yes</td>
         <td>Singular values/vectors, least squares</td>
         <td>Yes (and does least squares)</td>
@@ -149,24 +185,36 @@
         <td>R-SVD</td>
     </tr>
 
-    <tr class="alt">
+    <tr>
         <td>SelfAdjointEigenSolver</td>
         <td>Self-adjoint</td>
         <td>Fast-average<sup><a href="#note2">2</a></sup></td>
         <td>Good</td>
-        <td>Yes</td>
+        <td>-</td>
         <td>Eigenvalues/vectors</td>
         <td>-</td>
         <td>Excellent</td>
         <td><em>Closed forms for 2x2 and 3x3</em></td>
     </tr>
 
+    <tr class="alt">
+        <td>TridiagonalEigenSolver</td>
+        <td>Symmetric tridiagonal</td>
+        <td>Fast</td>
+        <td>Good</td>
+        <td>-</td>
+        <td>Eigenvalues/vectors, subsets of the spectrum</td>
+        <td>-</td>
+        <td>Good</td>
+        <td>Vectorization, Explicit MT</td>
+    </tr>
+
     <tr>
         <td>ComplexEigenSolver</td>
         <td>Square</td>
         <td>Slow-very slow<sup><a href="#note2">2</a></sup></td>
         <td>Depends on condition number</td>
-        <td>Yes</td>
+        <td>-</td>
         <td>Eigenvalues/vectors</td>
         <td>-</td>
         <td>Average</td>
@@ -178,7 +226,7 @@
         <td>Square and real</td>
         <td>Average-slow<sup><a href="#note2">2</a></sup></td>
         <td>Depends on condition number</td>
-        <td>Yes</td>
+        <td>-</td>
         <td>Eigenvalues/vectors</td>
         <td>-</td>
         <td>Average</td>
@@ -197,6 +245,18 @@
         <td>-</td>
     </tr>
 
+    <tr class="alt">
+        <td>GeneralizedEigenSolver</td>
+        <td>Square and real</td>
+        <td>Slow-very slow<sup><a href="#note2">2</a></sup></td>
+        <td>Depends on condition number</td>
+        <td>-</td>
+        <td>Generalized eigenvalues/vectors</td>
+        <td>-</td>
+        <td>Average</td>
+        <td>-</td>
+    </tr>
+
     <tr><th class="inter" colspan="9">\n Helper decompositions</th></tr>
 
     <tr>
@@ -204,7 +264,7 @@
         <td>Square and real</td>
         <td>Average-slow<sup><a href="#note2">2</a></sup></td>
         <td>Depends on condition number</td>
-        <td>Yes</td>
+        <td>-</td>
         <td>-</td>
         <td>-</td>
         <td>Average</td>
@@ -216,14 +276,38 @@
         <td>Square</td>
         <td>Slow-very slow<sup><a href="#note2">2</a></sup></td>
         <td>Depends on condition number</td>
-        <td>Yes</td>
+        <td>-</td>
         <td>-</td>
         <td>-</td>
         <td>Average</td>
         <td>-</td>
     </tr>
 
+    <tr>
+        <td>RealQZ</td>
+        <td>Square and real (pair of matrices)</td>
+        <td>Average-slow<sup><a href="#note2">2</a></sup></td>
+        <td>Depends on condition number</td>
+        <td>-</td>
+        <td>Generalized eigenvalues of a pencil</td>
+        <td>-</td>
+        <td>Average</td>
+        <td>-</td>
+    </tr>
+
     <tr class="alt">
+        <td>ComplexQZ</td>
+        <td>Square (pair of matrices)</td>
+        <td>Slow-very slow<sup><a href="#note2">2</a></sup></td>
+        <td>Depends on condition number</td>
+        <td>-</td>
+        <td>Generalized eigenvalues of a pencil</td>
+        <td>-</td>
+        <td>Average</td>
+        <td>-</td>
+    </tr>
+
+    <tr>
         <td>Tridiagonalization</td>
         <td>Self-adjoint</td>
         <td>Fast</td>
@@ -232,10 +316,10 @@
         <td>-</td>
         <td>-</td>
         <td>Good</td>
-        <td><em>Soon: blocking</em></td>
+        <td>-</td>
     </tr>
 
-    <tr>
+    <tr class="alt">
         <td>HessenbergDecomposition</td>
         <td>Square</td>
         <td>Average</td>
@@ -244,18 +328,66 @@
         <td>-</td>
         <td>-</td>
         <td>Good</td>
-        <td><em>Soon: blocking</em></td>
+        <td>-</td>
     </tr>
 
 </table>
 
 \b Notes:
 <ul>
-<li><a name="note1">\b 1: </a>There exist two variants of the LDLT algorithm. Eigen's one produces a pure diagonal D matrix, and therefore it cannot handle indefinite matrices, unlike Lapack's one which produces a block diagonal D matrix.</li>
+<li><a name="note1">\b 1: </a>There exist two variants of the LDLT algorithm. %Eigen's LDLT produces a pure diagonal D matrix and therefore cannot handle indefinite matrices; it uses symmetric pivoting, which keeps the factorization stable when pivots are tiny or zero. The other variant, which produces the block-diagonal D needed for indefinite self-adjoint matrices, is provided by the BunchKaufman class.</li>
 <li><a name="note2">\b 2: </a>Eigenvalues, SVD and Schur decompositions rely on iterative algorithms. Their convergence speed depends on how well the eigenvalues are separated.</li>
-<li><a name="note3">\b 3: </a>Our JacobiSVD is two-sided, making for proven and optimal precision for square matrices. For non-square matrices, we have to use a QR preconditioner first. The default choice, ColPivHouseholderQR, is already very reliable, but if you want it to be proven, use FullPivHouseholderQR instead.
+<li><a name="note3">\b 3: </a>Our JacobiSVD is two-sided, which buys high relative accuracy on square matrices: where a bidiagonalizing algorithm only computes each singular value accurately relative to the largest one, Jacobi computes it accurately relative to itself, so that tiny singular values are still meaningful. That property is conditional rather than absolute -- the relative error is governed by the condition number of the matrix obtained by scaling its columns to unit norm, so a matrix that stays ill-conditioned under any such scaling loses it (J. Demmel and K. Veselic, "Jacobi's method is more accurate than QR", SIAM J. Matrix Anal. Appl. 13 (1992), pp. 1204-1245). For non-square matrices, we have to use a QR preconditioner first. Householder QR is backward stable with or without pivoting, so this choice is about rank revelation rather than about the accuracy of the factorization itself: the default \c ColPivHouseholderQRPreconditioner reveals rank reliably in practice but without a guarantee, \c FullPivHouseholderQRPreconditioner inspects the whole trailing submatrix at a substantially higher cost, and \c HouseholderQRPreconditioner and \c NoQRPreconditioner do not pivot at all. See the guidance below on complete pivoting.</li>
+<li><a name="note4">\b 4: </a>These factorizations are all backward stable, but pivoting buys something different in each. For LU the backward error bound is proportional to the growth factor: partial pivoting bounds it only by \f$ 2^{n-1} \f$, whereas complete pivoting admits a far smaller bound that grows only slightly faster than polynomially in \c n. That partial-pivoting worst case is not observed on real matrices, however, and partial pivoting is more than sufficient in practice. Householder QR is backward stable irrespective of pivoting, with a bound that involves no growth factor at all; there, pivoting serves rank revelation rather than stability, and what separates column from complete pivoting is how reliably the trailing diagonal of R exposes a rank deficiency. Since complete pivoting also rules out the cache-friendly blocked algorithms, LAPACK and %Eigen both treat partial and column pivoting as the defaults for LU and QR; see the guidance below. This is a judgement about those two factorizations rather than about complete pivoting in general: LAPACK does provide a complete-pivoting Cholesky (\c pstrf) for positive semidefinite matrices, where the pivoting also determines the rank.</li>
+<li><a name="note5">\b 5: </a>Cholesky needs no pivoting for stability: on a positive definite matrix the growth factor is bounded by 1, so the unpivoted factorization is backward stable as it stands. What conditioning governs is instead whether it completes: on a matrix that is positive definite but nearly singular, rounding can drive a computed pivot to zero or below, and %Eigen reports that through info() rather than returning a meaningless factor. Use LDLT, or a rank-revealing decomposition, for such matrices.</li>
 </ul>
 
+\section TopicLinAlgPracticalGuidance Practical guidance
+
+The following recommendations apply to the most common use cases:
+
+\li <b>Symmetric positive definite systems:</b> Use \b LLT. It is the fastest solver and has excellent
+    numerical properties for this class of problems. For semidefinite or nearly singular symmetric systems,
+    use \b LDLT.
+\li <b>Symmetric indefinite systems:</b> Use \b BunchKaufman. It extends the Cholesky family to
+    indefinite self-adjoint matrices with a backward-stable pivoting strategy at LDLT-like speed,
+    and also reveals the inertia of the matrix.
+\li <b>General invertible systems:</b> Use \b PartialPivLU. It uses cache-friendly blocking and implicit
+    multi-threading, making it the fastest general-purpose solver. Partial pivoting is sufficient for
+    virtually all practical problems.
+\li <b>Least squares (over- or under-determined systems):</b> Use \b CompleteOrthogonalDecomposition as
+    the default. Like the SVD, it robustly computes the minimum-norm solution for rank-deficient and
+    under-determined problems, but at QR-like speed. Use \b BDCSVD when you also need singular values
+    or vectors, not just the least squares solution.
+\li <b>Large least squares problems:</b> Use \b RandCompleteOrthogonalDecomposition. It produces the
+    same kind of factorization as \b CompleteOrthogonalDecomposition, but chooses pivots from a small random
+    sketch so that nearly all of the work happens in level-3 BLAS kernels rather than in the
+    memory-bound column scan of classical column pivoting. The pivot-quality difference is empirically
+    minor. On small matrices the sketch overhead dominates, so prefer the non-randomized class there.
+\li <b>Pseudo-inverse:</b> \b CompleteOrthogonalDecomposition and \b RandCompleteOrthogonalDecomposition
+    are the only decompositions that provide pseudoInverse() directly. Prefer solve() over multiplying
+    by an explicitly formed pseudo-inverse.
+\li <b>Full-rank least squares (overdetermined systems):</b> When the matrix is known to be full rank,
+    \b HouseholderQR is the fastest option. For very tall and skinny well-conditioned matrices,
+    solving via the normal equations with \b LLT can be faster still.
+\li <b>FullPivLU and FullPivHouseholderQR</b> use complete pivoting, which rules out the
+    cache-friendly blocked algorithms and so makes them substantially slower than their partial- and
+    column-pivoting counterparts, increasingly so as the matrix grows. What complete pivoting buys --
+    a smaller growth factor for LU, a more reliable rank decision for QR -- rarely repays that cost on
+    its own, so PartialPivLU and ColPivHouseholderQR are the right default. LAPACK reflects the same
+    trade-off for LU and QR: it exposes no complete-pivoting driver for either, standardizing instead
+    on partial-pivoting LU (\c getrf) and column-pivoted QR (\c geqp3, \c geqp3rk). Complete-pivoting
+    LU survives there only as the auxiliary routine \c getc2, called by the generalized Sylvester
+    solver, and complete pivoting has no QR counterpart at all.
+\li <b>When complete pivoting is worth it:</b> rank determination. Column pivoting is reliable in
+    practice but not guaranteed (Kahan's matrix is the standard example of a nearly rank-deficient
+    matrix whose column-pivoted QR exposes no small trailing diagonal entry), whereas complete
+    pivoting inspects the whole trailing submatrix at each step. If your application depends on
+    getting the rank right, FullPivLU or FullPivHouseholderQR is a defensible choice, and the
+    argument is strongest for small matrices, where the lost blocking costs comparatively little.
+    When rank is the whole point and the cost is acceptable, BDCSVD remains the most reliable answer,
+    since the singular values let you choose the threshold yourself.
+
 \section TopicLinAlgTerminology Terminology
 
 <dl>
@@ -277,8 +409,6 @@
     <dd>Means the algorithm is explicitly parallelized to take advantage of multicore processors via OpenMP.</dd>
   <dt><b>Meta-unroller</b></dt>
     <dd>Means the algorithm is automatically and explicitly unrolled for very small fixed size matrices.</dd>
-  <dt><b></b></dt>
-    <dd></dd>
 </dl>
 
 
diff --git a/doc/TopicMultithreading.dox b/doc/TopicMultithreading.dox
index e8e10c5..1cc189e 100644
--- a/doc/TopicMultithreading.dox
+++ b/doc/TopicMultithreading.dox
@@ -50,7 +50,7 @@
 \section TopicMultiThreading_UsingEigenWithMT Using Eigen in a multi-threaded application
 
 \warning Note that all functions generating random matrices are \b not re-entrant nor thread-safe. Those include DenseBase::Random(), and DenseBase::setRandom(). This is because these functions are based on \c std::rand which is not re-entrant.
-For thread-safe random generation, we recommend the use of C++11 random generators (\link DenseBase::NullaryExpr(Index, const CustomNullaryOp&) example \endlink).
+For thread-safe random generation, we recommend the use of the std random generators (\link DenseBase::NullaryExpr(Index, const CustomNullaryOp&) example \endlink).
 
 In the case your application is parallelized with OpenMP, you might want to disable %Eigen's own parallelization as detailed in the previous section.
 
diff --git a/doc/TopicScalarTypes.dox b/doc/TopicScalarTypes.dox
index 2ff03c1..d6e3d2e 100644
--- a/doc/TopicScalarTypes.dox
+++ b/doc/TopicScalarTypes.dox
@@ -2,10 +2,66 @@
 
 /** \page TopicScalarTypes Scalar types
 
+The \c Scalar template parameter of Matrix, Array, SparseMatrix, and the other %Eigen containers
+determines the type of the coefficients. This page lists the scalar types that work out of the box
+and points to the mechanism for adding new ones.
 
-TODO: write this dox page!
+\eigenAutoToc
 
-Is linked from the tutorial on the Matrix class.
+\section TopicScalarTypesBuiltin Supported scalar types
+
+The following types are supported without any additional work:
+
+  - the standard floating-point types \c float, \c double, and <tt>long double</tt>;
+  - <tt>std::complex</tt> of any of those, most commonly <tt>std::complex<float></tt> and
+    <tt>std::complex<double></tt>;
+  - all standard integer types, signed and unsigned (e.g. \c int, <tt>unsigned int</tt>,
+    \c short, <tt>std::int64_t</tt>, ...);
+  - \c bool, with the arithmetic operators interpreted in the Boolean semiring
+    (see \ref TopicPitfalls_matrix_bool);
+  - the reduced-precision floating-point types \c Eigen::half (IEEE binary16) and
+    \c Eigen::bfloat16, which %Eigen provides itself in Eigen/Core.
+
+A few practical notes:
+
+  - <b>Convenience typedefs</b> such as \c MatrixXd or \c Vector4i exist for \c float, \c double,
+    \c int, and the two standard complex types; for every other scalar type simply spell out
+    <tt>Matrix<Scalar, Rows, Cols></tt> or define your own typedef.
+  - <b>Mixing scalar types</b> in one expression is not done implicitly: adding a \c float matrix
+    to a \c double matrix is a compile-time error. Convert explicitly with
+    <tt>.cast<NewScalar>()</tt>. The exceptions are the documented
+    real-times-complex combinations, e.g. multiplying a real matrix by a complex scalar.
+  - <b>Integer scalars</b> use exact arithmetic, with the usual C++ caveats: overflow wraps or is
+    undefined depending on signedness, and division truncates. Decompositions and other
+    algorithms that require field operations are meant for floating-point (or rational custom)
+    scalars, not for integer types.
+  - <b><tt>long double</tt></b> follows the platform's definition (80-bit extended precision on
+    x86 Linux, 128-bit on some platforms, plain \c double on MSVC). It is never vectorized.
+  - <b>\c Eigen::half and \c Eigen::bfloat16</b> are primarily storage and interchange formats:
+    on hardware without native arithmetic, operations are emulated by converting to \c float and
+    back. Both are vectorized on instruction sets with hardware support (see
+    \ref TopicVectorization).
+
+The scalar types with vectorized kernels for a given instruction set are listed on the
+\ref TopicVectorization "vectorization page"; every supported scalar type also works through the
+scalar code paths.
+
+\section TopicScalarTypesTraits NumTraits
+
+The properties of a scalar type are centralized in the NumTraits class template: whether the type
+is integer, signed, or complex, the corresponding real type (e.g. \c float for
+<tt>std::complex<float></tt>), machine epsilon, and the tolerances used by the fuzzy comparison
+functions such as isApprox(). Generic code should query NumTraits and use the math functions from
+the \c Eigen::numext namespace (numext::sqrt, numext::abs2, ...) rather than hard-coding
+properties of \c float or \c double, so that it keeps working for every supported scalar type.
+
+\section TopicScalarTypesCustom Custom scalar types
+
+Any user-defined type with the usual arithmetic operators can be used as a scalar type after
+specializing NumTraits for it and providing the math functions that make sense for the type. The
+full recipe, with complete examples (an automatic-differentiation type and a GMP rational type),
+is given in \ref TopicCustomizing_CustomScalar. Ready-made support for the MPFR arbitrary-precision
+type is available in the contrib module <a href="contrib/group__MPRealSupport__Module.html">MPRealSupport</a>.
 
 */
 
diff --git a/doc/TopicVectorization.dox b/doc/TopicVectorization.dox
index 274d045..f3b4cb7 100644
--- a/doc/TopicVectorization.dox
+++ b/doc/TopicVectorization.dox
@@ -2,8 +2,108 @@
 
 /** \page TopicVectorization Vectorization
 
+%Eigen performs \em explicit vectorization: instead of relying on the compiler to auto-vectorize scalar
+loops, %Eigen's evaluators generate SIMD instructions directly through a portable wrapper layer (the
+"packet math" layer). This page gives an overview of which instruction sets are supported, how
+vectorization is enabled, what gets vectorized, and how to control it.
 
-TODO: write this dox page!
+\eigenAutoToc
+
+\section TopicVectorizationArch Supported instruction sets
+
+On CPUs, %Eigen provides vectorized kernels for the following instruction sets:
+
+<table class="manual">
+<tr><th>Architecture</th><th>Instruction sets</th><th>Notes</th></tr>
+<tr><td>x86 / x86-64</td><td>SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2+FMA, AVX512 (incl. the DQ, VL, FP16, and BF16 extensions)</td>
+    <td>Selected from the compiler's target flags (e.g. \c -mavx2 \c -mfma, \c /arch:AVX2)</td></tr>
+<tr class="alt"><td>ARM / AArch64</td><td>NEON, SME; SVE as an opt-in backend</td>
+    <td>SVE requires \c EIGEN_ARM64_USE_SVE and a fixed vector length
+        (<tt>-msve-vector-bits=N</tt>). The SME backend accelerates real and complex matrix
+        products and is selected automatically when the compiler targets SME2
+        (<tt>-march=armv9.2-a+sme2</tt>, or a <tt>-mcpu</tt> that implies it) \em without
+        <tt>-msve-vector-bits</tt>, since a fixed length would pin the kernels to one runtime
+        streaming vector length; everything else keeps the NEON path. Define
+        \c EIGEN_ARM64_NO_SME to opt out, or \c EIGEN_ARM64_USE_SME to turn a toolchain that
+        cannot provide it into a build error instead of a NEON fallback. Double precision
+        additionally needs the optional FEAT_SME_F64F64 extension (<tt>+sme-f64f64</tt>, or a
+        <tt>-mcpu</tt> that implies it); without it \c double and \c std::complex<double> keep
+        the generic kernel</td></tr>
+<tr><td>PowerPC</td><td>AltiVec, VSX, MMA</td><td></td></tr>
+<tr class="alt"><td>IBM Z (s390x)</td><td>ZVector</td><td></td></tr>
+<tr><td>MIPS</td><td>MSA</td><td></td></tr>
+<tr class="alt"><td>LoongArch</td><td>LSX</td><td></td></tr>
+<tr><td>RISC-V</td><td>RVV 1.0</td>
+    <td>Requires \c EIGEN_RISCV64_USE_RVV10 and a fixed vector length
+        (<tt>-mrvv-vector-bits=zvl</tt>)</td></tr>
+<tr class="alt"><td>Qualcomm Hexagon</td><td>HVX</td><td></td></tr>
+</table>
+
+In addition, the same packet abstraction is used to generate efficient device code for CUDA and HIP
+GPUs (see \ref TopicCUDA) and for SYCL devices.
+
+Vectorization is enabled automatically whenever the compiler's target flags advertise one of the
+supported instruction sets. You can check what a given translation unit ended up using by printing
+Eigen::SimdInstructionSetsInUse():
+\code
+std::cout << Eigen::SimdInstructionSetsInUse() << std::endl;
+\endcode
+
+\section TopicVectorizationWhat What gets vectorized
+
+Vectorization applies across %Eigen, most notably to:
+  - assignment of coefficient-wise expressions (e.g. <tt>a = 2*b + c.cwiseProduct(d)</tt>),
+    including the fused evaluation loops described in \ref TopicEigenExpressionTemplates;
+  - reductions such as sum(), minCoeff(), squaredNorm(), and their partial (colwise/rowwise)
+    variants;
+  - matrix-matrix and matrix-vector products, and through them most decompositions;
+  - many coefficient-wise math functions; the \ref CoeffwiseMathFunctions "math function catalogue"
+    lists, for every function, the instruction sets and scalar types with a vectorized
+    implementation.
+
+The scalar types with SIMD support depend on the instruction set; \c float, \c double, 32- and
+64-bit integers, and <tt>std::complex<float></tt>/<tt>std::complex<double></tt> are covered on the
+main backends, with \c Eigen::half and \c Eigen::bfloat16 vectorized where hardware support exists
+(e.g. AVX512FP16, NEON). Types without SIMD support, such as <tt>long double</tt> or custom scalar
+types, simply use scalar code.
+
+Fixed-size objects are vectorized when their size is a multiple of the packet size; this is where
+the alignment rules for \ref TopicFixedSizeVectorizable "fixed-size vectorizable types" come from.
+Dynamic-size objects use aligned heap allocation plus vectorized loops with scalar prologues and
+epilogues where needed. Unaligned loads and stores are used where alignment cannot be established;
+this is enabled by default and controlled by \c EIGEN_UNALIGNED_VECTORIZE.
+
+\section TopicVectorizationCtrl Controlling vectorization
+
+Vectorization is meant to be transparent, but the following macros, all documented in
+\ref TopicPreprocessorDirectives, let you control it:
+
+  - \c EIGEN_DONT_VECTORIZE disables explicit vectorization entirely.
+  - \c EIGEN_MAX_ALIGN_BYTES and \c EIGEN_MAX_STATIC_ALIGN_BYTES bound the alignment %Eigen
+    requests for heap and static data respectively; note that changing them affects the ABI.
+  - \c EIGEN_UNALIGNED_VECTORIZE=0 restricts vectorization to expressions whose destination is
+    aligned.
+  - \c EIGEN_FAST_MATH selects between faster and more accurate vectorized math functions.
+
+Disabling vectorization also drops %Eigen's alignment: outside GPU compilation,
+\c EIGEN_DONT_VECTORIZE sets the ideal alignment to zero, and the defaults for
+\c EIGEN_MAX_STATIC_ALIGN_BYTES and \c EIGEN_MAX_ALIGN_BYTES follow it. Fixed-size vectorizable
+types then lose their over-alignment — \c alignof(Vector4f) drops from 16 to 4 on a typical x86-64
+build — so translation units that disagree about \c EIGEN_DONT_VECTORIZE disagree about the ABI.
+Define the alignment macros explicitly and identically everywhere if you need the boundary to stay
+fixed. See \ref TopicUnalignedArrayAssert for what the alignment is there for.
+
+When compiling CUDA sources, host-side SIMD must be disabled; see \ref TopicCUDA.
+
+\section TopicVectorizationInternals Under the hood
+
+Vectorized kernels are written in terms of generic packet primitives — pload(), pstore(), padd(),
+pmul(), predux(), and friends — declared in Eigen/src/Core/GenericPacketMath.h and specialized for
+each instruction set under <tt>Eigen/src/Core/arch/</tt>. Expression evaluators query each
+expression's packet support and alignment at compile time to choose between scalar, linear,
+sliced, and unrolled vectorized evaluation loops. Custom functors can participate in vectorization
+by providing a \c packetOp() and advertising \c PacketAccess in their traits; see
+\ref TopicCustomizing_Functors.
 
 */
 }
diff --git a/doc/TutorialAdvancedInitialization.dox b/doc/TutorialAdvancedInitialization.dox
index 50374d0..4bf2544 100644
--- a/doc/TutorialAdvancedInitialization.dox
+++ b/doc/TutorialAdvancedInitialization.dox
@@ -4,7 +4,8 @@
 
 This page discusses several advanced methods for initializing matrices. It gives more details on the
 comma-initializer, which was introduced before. It also explains how to get special matrices such as the
-identity matrix and the zero matrix.
+identity matrix and the zero matrix. Construction from C++11 initializer lists, such as
+<tt>MatrixXd m{{1, 2}, {3, 4}}</tt>, is covered in \ref TutorialMatrixConstructors "the Matrix class tutorial".
 
 \eigenAutoToc
 
diff --git a/doc/TutorialGeometry.dox b/doc/TutorialGeometry.dox
index 2938df4..5285de2 100644
--- a/doc/TutorialGeometry.dox
+++ b/doc/TutorialGeometry.dox
@@ -7,7 +7,7 @@
 \eigenAutoToc
 
 Eigen's Geometry module provides two different kinds of geometric transformations:
-  - Abstract transformations, such as rotations (represented by \ref AngleAxis "angle and axis" or by a \ref Quaternion "quaternion"), \ref Translation "translations", \ref Scaling() "scalings". These transformations are NOT represented as matrices, but you can nevertheless mix them with matrices and vectors in expressions, and convert them to matrices if you wish.
+  - Abstract transformations, such as rotations (represented by \ref AngleAxis "angle and axis" or by a \ref Quaternion "quaternion"), \ref Translation "translations", \ref UniformScaling "scalings". These transformations are NOT represented as matrices, but you can nevertheless mix them with matrices and vectors in expressions, and convert them to matrices if you wish.
   - Projective or affine transformation matrices: see the Transform class. These are really matrices.
 
 \note If you are working with OpenGL 4x4 matrices then Affine3f and Affine3d are what you want. Since Eigen defaults to column-major storage, you can directly use the Transform::data() method to pass your transformation matrix to OpenGL.
@@ -61,9 +61,9 @@
 <tr><td>
 N-D Linear transformations \n
 <em class=note>(pure rotations, \n scaling, etc.)</em></td><td>\code
-Matrix<float,N> t = concatenation_of_rotations_and_scalings;
-Matrix<float,2> t = Rotation2Df(a) * Scaling(s);
-Matrix<float,3> t = AngleAxisf(a,axis) * Scaling(s);\endcode</td></tr>
+Matrix<float,N,N> t = concatenation_of_rotations_and_scalings;
+Matrix2f t = Rotation2Df(a) * Scaling(s);
+Matrix3f t = AngleAxisf(a,axis) * Scaling(s);\endcode</td></tr>
 </table>
 
 <strong>Notes on rotations</strong>\n To transform more than a single vector the preferred
@@ -78,7 +78,10 @@
 kind of transformations.
 
 Any of the above transformation types can be converted to any other types of the same nature,
-or to a more generic type. Here are some additional examples:
+or to a more generic type. Conversions use either assignment or direct
+initialization \c (T t(other);); copy initialization \c (T t = other;) does not
+compile because the conversion constructors on \c Transform are intentionally
+\c explicit. Here are some additional examples:
 <table class="manual">
 <tr><td>\code
 Rotation2Df r;  r  = Matrix2f(..);       // assumes a pure rotation matrix
@@ -86,8 +89,9 @@
 AngleAxisf aa;  aa = Matrix3f(..);       // assumes a pure rotation matrix
 Matrix2f m;     m  = Rotation2Df(..);
 Matrix3f m;     m  = Quaternionf(..);       Matrix3f m;   m = Scaling(..);
-Affine3f m;     m  = AngleAxis3f(..);       Affine3f m;   m = Scaling(..);
+Affine3f m;     m  = AngleAxisf(..);        Affine3f m;   m = Scaling(..);
 Affine3f m;     m  = Translation3f(..);     Affine3f m;   m = Matrix3f(..);
+Affine3f m(Translation3f(..));           // direct initialization
 \endcode</td></tr>
 </table>
 
@@ -143,7 +147,7 @@
 OpenGL compatibility \b 2D </td><td>\code
 Affine3f aux(Affine3f::Identity());
 aux.linear().topLeftCorner<2,2>() = t.linear();
-aux.translation().start<2>() = t.translation();
+aux.translation().head<2>() = t.translation();
 glLoadMatrixf(aux.data());\endcode</td></tr>
 </table>
 
diff --git a/doc/TutorialLinearAlgebra.dox b/doc/TutorialLinearAlgebra.dox
index 8042fca..577fc05 100644
--- a/doc/TutorialLinearAlgebra.dox
+++ b/doc/TutorialLinearAlgebra.dox
@@ -43,9 +43,33 @@
         <th>Requirements<br/>on the matrix</th>
         <th>Speed<br/> (small-to-medium)</th>
         <th>Speed<br/> (large)</th>
-        <th>Accuracy</th>
+        <th>Robustness<sup><a href="#note_robust">*</a></sup></th>
     </tr>
     <tr>
+        <td>LLT</td>
+        <td>llt()</td>
+        <td>Positive definite</td>
+        <td>+++</td>
+        <td>+++</td>
+        <td>+</td>
+    </tr>
+    <tr class="alt">
+        <td>LDLT</td>
+        <td>ldlt()</td>
+        <td>Positive or negative<br/> semidefinite</td>
+        <td>+++</td>
+        <td>+</td>
+        <td>++</td>
+    </tr>
+    <tr>
+        <td>BunchKaufman</td>
+        <td>bunchKaufman()</td>
+        <td>Self-adjoint</td>
+        <td>+++</td>
+        <td>++</td>
+        <td>++</td>
+    </tr>
+    <tr class="alt">
         <td>PartialPivLU</td>
         <td>partialPivLu()</td>
         <td>Invertible</td>
@@ -53,14 +77,6 @@
         <td>++</td>
         <td>+</td>
     </tr>
-    <tr class="alt">
-        <td>FullPivLU</td>
-        <td>fullPivLu()</td>
-        <td>None</td>
-        <td>-</td>
-        <td>- -</td>
-        <td>+++</td>
-    </tr>
     <tr>
         <td>HouseholderQR</td>
         <td>householderQr()</td>
@@ -78,14 +94,6 @@
         <td>+++</td>
     </tr>
     <tr>
-        <td>FullPivHouseholderQR</td>
-        <td>fullPivHouseholderQr()</td>
-        <td>None</td>
-        <td>-</td>
-        <td>- -</td>
-        <td>+++</td>
-    </tr>
-    <tr class="alt">
         <td>CompleteOrthogonalDecomposition</td>
         <td>completeOrthogonalDecomposition()</td>
         <td>None</td>
@@ -94,22 +102,14 @@
         <td>+++</td>
     </tr>
     <tr class="alt">
-        <td>LLT</td>
-        <td>llt()</td>
-        <td>Positive definite</td>
-        <td>+++</td>
-        <td>+++</td>
+        <td>RandCompleteOrthogonalDecomposition</td>
+        <td>randCompleteOrthogonalDecomposition()</td>
+        <td>None</td>
+        <td>-</td>
         <td>+</td>
+        <td>+++</td>
     </tr>
     <tr>
-        <td>LDLT</td>
-        <td>ldlt()</td>
-        <td>Positive or negative<br/> semidefinite</td>
-        <td>+++</td>
-        <td>+</td>
-        <td>++</td>
-    </tr>
-    <tr class="alt">
         <td>BDCSVD</td>
         <td>bdcSvd()</td>
         <td>None</td>
@@ -126,15 +126,49 @@
         <td>+++</td>
     </tr>
 </table>
+
+<a name="note_robust"><b>*</b></a> The <b>Robustness</b> column indicates how well the decomposition handles
+ill-conditioned or rank-deficient matrices. All decompositions give excellent accuracy when their
+requirements on the matrix are met and the problem is well-conditioned.
+
 To get an overview of the true relative speed of the different decompositions, check this \link DenseDecompositionBenchmark benchmark \endlink.
 
-All of these decompositions offer a solve() method that works as in the above example. 
+All of these decompositions offer a solve() method that works as in the above example.
 
-If you know more about the properties of your matrix, you can use the above table to select the best method.
-For example, a good choice for solving linear systems with a non-symmetric matrix of full rank is PartialPivLU.
-If you know that your matrix is also symmetric and positive definite, the above table says that
-a very good choice is the LLT or LDLT decomposition. Here's an example, also demonstrating that using a general
-matrix (not a vector) as right hand side is possible:
+\b Practical \b recommendations:
+\li If your matrix is symmetric positive definite, use \b LLT. It is the fastest and is perfectly accurate
+    for this class of problems. If your matrix is only positive or negative semidefinite, use \b LDLT,
+    whose symmetric pivoting keeps the factorization stable in the presence of tiny or zero pivots.
+    \b LDLT produces a purely diagonal D and so cannot handle indefinite matrices; for a self-adjoint
+    matrix that is indefinite, use \b BunchKaufman, which produces a block-diagonal D at LDLT-like speed
+    and also reveals the inertia.
+\li For a general invertible matrix, \b PartialPivLU is the best choice. It is fast (uses cache-friendly
+    blocking) and reliable for the vast majority of problems.
+\li For least squares problems (over- or under-determined systems), \b CompleteOrthogonalDecomposition
+    is the recommended default. Like the SVD, it robustly computes the minimum-norm solution for
+    rank-deficient and under-determined problems, but at the cost of a QR decomposition rather than
+    an SVD. Use \b ColPivHouseholderQR if you only need least squares for full-rank overdetermined
+    systems and don't need the minimum-norm property.
+\li For \em large least squares problems, consider \b RandCompleteOrthogonalDecomposition. It computes
+    the same kind of factorization as CompleteOrthogonalDecomposition, but its rank-revealing QR step
+    selects pivots from a small random sketch, which lets nearly all of the work be done by level-3
+    BLAS kernels instead of the memory-bound column scan used by classical column pivoting. On small
+    matrices the sketch overhead dominates and plain CompleteOrthogonalDecomposition is preferable.
+\li \b SVD decompositions (BDCSVD, JacobiSVD) are the most robust but also the slowest. Use these when
+    you need singular values/vectors, not just the solution.
+\li \b HouseholderQR is the fastest option for full-rank least squares problems, but it does not
+    reveal rank and cannot compute minimum-norm solutions for rank-deficient problems.
+\li FullPivLU and FullPivHouseholderQR use complete pivoting, which rules out blocking and so makes
+    them substantially slower, increasingly so as the matrix grows. What it buys -- a smaller growth
+    factor for LU, a more reliable rank decision for QR -- rarely repays that cost on its own, so
+    PartialPivLU and ColPivHouseholderQR are the better default; LAPACK made the same call, offering
+    no complete-pivoting LU or QR driver. Where complete pivoting does earn its cost is rank
+    determination, since column pivoting is reliable in practice but not guaranteed. If your
+    application depends on getting the rank right, the full-pivoting classes are a reasonable choice,
+    especially for small matrices, where the lost blocking costs comparatively little.
+
+Here's an example showing the use of LLT for a symmetric positive definite system, also demonstrating
+that using a general matrix (not a vector) as right hand side is possible:
 
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
@@ -151,14 +185,17 @@
 
 \section TutorialLinAlgLeastsquares Least squares solving
 
-The most general and accurate method to solve under- or over-determined linear systems
-in the least squares sense, is the SVD decomposition. Eigen provides two implementations.
-The recommended one is the BDCSVD class, which scales well for large problems
-and automatically falls back to the JacobiSVD class for smaller problems.
-For both classes, their solve() method solved the linear system in the least-squares
-sense. 
+The recommended method to solve under- or over-determined linear systems in the least squares sense is
+\b CompleteOrthogonalDecomposition. Like the SVD, it robustly computes the minimum-norm least squares
+solution, correctly handling rank-deficient and under-determined problems, but it is significantly faster
+since it is based on a rank-revealing QR decomposition rather than a full SVD. For large problems,
+\b RandCompleteOrthogonalDecomposition computes the same kind of factorization with a randomized blocked
+rank-revealing QR that spends nearly all of its time in level-3 BLAS kernels.
 
-Here is an example:
+If you also need the singular values or vectors themselves (not just the least squares solution), use
+\b BDCSVD, which scales well for large problems and automatically falls back to JacobiSVD for smaller ones.
+
+Here is an example using the SVD:
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr>
@@ -167,11 +204,9 @@
 </tr>
 </table>
 
-An alternative to the SVD, which is usually faster and about as accurate, is CompleteOrthogonalDecomposition. 
-
-Again, if you know more about the problem, the table above contains methods that are potentially faster.
-If your matrix is full rank, HouseHolderQR is the method of choice. If your matrix is full rank and well conditioned,
-using the Cholesky decomposition (LLT) on the matrix of the normal equations can be faster still.
+If you know more about the problem, faster methods are available.
+If your matrix is full rank, HouseholderQR is the fastest method. If your matrix is full rank and
+well conditioned, using the Cholesky decomposition (LLT) on the normal equations can be faster still.
 Our page on \link LeastSquares least squares solving \endlink has more details.
 
 
@@ -267,8 +302,13 @@
 whether they are rank-revealing or not.
 
 Rank-revealing decompositions offer at least a rank() method. They can also offer convenience methods such as isInvertible(),
-and some are also providing methods to compute the kernel (null-space) and image (column-space) of the matrix, as is the
-case with FullPivLU:
+and FullPivLU is the only one that additionally computes the kernel (null-space) and the image (column-space) of the matrix,
+through kernel() and image(). ColPivHouseholderQR and CompleteOrthogonalDecomposition are faster rank-revealing
+factorizations providing rank() and isInvertible() but no null-space basis. CompleteOrthogonalDecomposition and
+RandCompleteOrthogonalDecomposition additionally offer pseudoInverse(); they are the only decompositions in %Eigen
+that do, so they are also the cheapest route to a Moore-Penrose pseudo-inverse, which would otherwise have to be
+assembled by hand from an SVD. Note that solve() should still be preferred over multiplying by an explicitly formed
+pseudo-inverse. Here is an example using FullPivLU:
 
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
diff --git a/doc/TutorialMapClass.dox b/doc/TutorialMapClass.dox
index 64f0a0e..e266bb1 100644
--- a/doc/TutorialMapClass.dox
+++ b/doc/TutorialMapClass.dox
@@ -38,12 +38,13 @@
     typename StrideType>
 \endcode
 \li \c MapOptions specifies whether the pointer is \c #Aligned, or \c #Unaligned.  The default is \c #Unaligned.
-\li \c StrideType allows you to specify a custom layout for the memory array, using the Stride class.  One example would be to specify that the data array is organized in row-major format:
+\li \c StrideType allows you to specify a custom layout for the memory array, using the Stride class.  One example is
+to map every other row from a column-major array with an inner stride of 2:
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr>
-<td>\include Tutorial_Map_rowmajor.cpp </td>
-<td>\verbinclude Tutorial_Map_rowmajor.out </td>
+<td>\include Tutorial_Map_inner_stride.cpp </td>
+<td>\verbinclude Tutorial_Map_inner_stride.out </td>
 </table>
 However, Stride is even more flexible than this; for details, see the documentation for the Map and Stride classes.
 
diff --git a/doc/TutorialMatrixClass.dox b/doc/TutorialMatrixClass.dox
index 6b0c6f6..62f2fd0 100644
--- a/doc/TutorialMatrixClass.dox
+++ b/doc/TutorialMatrixClass.dox
@@ -102,14 +102,7 @@
 and is a no-operation.
 
 Matrices and vectors can also be initialized from lists of coefficients.
-Prior to C++11, this feature is limited to small fixed-size column or vectors up to size 4:
-\code
-Vector2d a(5.0, 6.0);
-Vector3d b(5.0, 6.0, 7.0);
-Vector4d c(5.0, 6.0, 7.0, 8.0);
-\endcode
-
-If C++11 is enabled, fixed-size column or row vectors of arbitrary size can be initialized by passing an arbitrary number of coefficients:
+Fixed-size column or row vectors of arbitrary size can be initialized by passing an arbitrary number of coefficients:
 \code
 Vector2i a(1, 2);                      // A column-vector containing the elements {1, 2}
 Matrix<int, 5, 1> b {1, 2, 3, 4, 5};   // A column-vector containing the elements {1, 2, 3, 4, 5}
diff --git a/doc/TutorialReductionsVisitorsBroadcasting.dox b/doc/TutorialReductionsVisitorsBroadcasting.dox
index f5322b4..20f3534 100644
--- a/doc/TutorialReductionsVisitorsBroadcasting.dox
+++ b/doc/TutorialReductionsVisitorsBroadcasting.dox
@@ -76,9 +76,21 @@
 
 \subsection TutorialReductionsVisitorsBroadcastingReductionsUserdefined User defined reductions
 
-TODO
+The \link DenseBase::redux() redux() \endlink method lets you define your own reduction by passing a binary functor.
+The functor is called with two coefficients and must return one coefficient of the same scalar type. It should implement
+an associative operation, because Eigen is free to choose the order in which coefficients are combined.
 
-In the meantime you can have a look at the DenseBase::redux() function.
+The following example returns the coefficient with the largest absolute value, first over the whole matrix and then
+column-wise:
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr><td>
+\include Tutorial_ReductionsVisitorsBroadcasting_reductions_userdefined.cpp
+</td>
+<td>
+\verbinclude Tutorial_ReductionsVisitorsBroadcasting_reductions_userdefined.out
+</td></tr></table>
 
 \section TutorialReductionsVisitorsBroadcastingVisitors Visitors
 Visitors are useful when one wants to obtain the location of a coefficient inside 
@@ -149,7 +161,7 @@
 </td></tr></table>
 
 The previous example applies the \link DenseBase::sum() sum() \endlink reduction on each column
-though the \link DenseBase::colwise() colwise() \endlink visitor, obtaining a new matrix whose
+through the \link DenseBase::colwise() colwise() \endlink proxy, obtaining a new matrix whose
 size is 1x4.
 
 Therefore, if
@@ -197,7 +209,7 @@
 The operators <tt>-=</tt>, <tt>+</tt> and <tt>-</tt> can also be used column-wise and row-wise. On arrays, we 
 can also use the operators <tt>*=</tt>, <tt>/=</tt>, <tt>*</tt> and <tt>/</tt> to perform coefficient-wise 
 multiplication and division column-wise or row-wise. These operators are not available on matrices because it
-is not clear what they would do. If you want multiply column 0 of a matrix \c mat with \c v(0), column 1 with 
+is not clear what they would do. If you want to multiply column 0 of a matrix \c mat with \c v(0), column 1 with
 \c v(1), and so on, then use <tt>mat = mat * v.asDiagonal()</tt>.
 
 It is important to point out that the vector to be added column-wise or row-wise must be of type Vector,
diff --git a/doc/TutorialReshape.dox b/doc/TutorialReshape.dox
index 07e5c3c..9a9949a 100644
--- a/doc/TutorialReshape.dox
+++ b/doc/TutorialReshape.dox
@@ -23,7 +23,18 @@
 </td></tr></table>
 
 By default, the input coefficients are always interpreted in column-major order regardless of the storage order of the input expression.
-For more control on ordering, compile-time sizes, and automatic size deduction, please see de documentation of `DenseBase::reshaped(NRowsType,NColsType)` that contains all the details with many examples.
+The following example with increasing coefficients makes this reading order explicit:
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr><td>
+\include Tutorial_ReshapeMat2Mat.cpp
+</td>
+<td>
+\verbinclude Tutorial_ReshapeMat2Mat.out
+</td></tr></table>
+
+For more control on ordering, compile-time sizes, and automatic size deduction, please see the documentation of `DenseBase::reshaped(NRowsType,NColsType)` that contains all the details with many examples.
 
 
 \section TutorialReshapeMat2Vec 1D linear views
@@ -42,12 +53,25 @@
 </td></tr></table>
 
 This shortcut always returns a column vector and by default input coefficients are always interpreted in column-major order.
+To follow the storage order of the input instead, pass `AutoOrder`, as in the following example flattening the same
+data stored in column-major and row-major order:
+
+<table class="example">
+<tr><th>Example:</th></tr>
+<tr><td>
+\include Tutorial_ReshapeMat2Vec.cpp
+</td></tr>
+<tr><th>Output:</th></tr>
+<tr><td>
+\verbinclude Tutorial_ReshapeMat2Vec.out
+</td></tr></table>
+
 Again, see the documentation of DenseBase::reshaped() for more control on the ordering.
 
-\section TutorialReshapeInPlace
+\section TutorialReshapeInPlace Reshaping in place
 
 The above examples create reshaped views, but what about reshaping inplace a given matrix?
-Of course this task in only conceivable for matrix and arrays having runtime dimensions.
+Of course this task is only conceivable for matrices and arrays having runtime dimensions.
 In many cases, this can be accomplished via PlainObjectBase::resize(Index,Index):
 
 <table class="example">
@@ -73,7 +97,7 @@
 \verbinclude Tutorial_reshaped_vs_resize_2.out
 </td></tr></table>
 
-Finally, assigning a reshaped matrix to itself is currently not supported and will result to undefined-behavior because of \link TopicAliasing aliasing \endlink.
+Finally, assigning a reshaped matrix to itself is currently not supported and results in undefined behavior because of \link TopicAliasing aliasing \endlink.
 The following is forbidden: \code A = A.reshaped(2,8); \endcode
 This is OK: \code A = A.reshaped(2,8).eval(); \endcode
 
diff --git a/doc/TutorialSTL.dox b/doc/TutorialSTL.dox
index 9a825bc..26a04b1 100644
--- a/doc/TutorialSTL.dox
+++ b/doc/TutorialSTL.dox
@@ -9,16 +9,16 @@
 
 \section TutorialSTLVectors Iterating over 1D arrays and vectors 
 
-Any dense 1D expressions exposes the pair of `begin()/end()` methods to iterate over them.
+Any dense 1D expression exposes the pair of `begin()/end()` methods to iterate over it.
 
-This directly enables c++11 range for loops:
+This directly enables range for loops:
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr><td>
-\include Tutorial_range_for_loop_1d_cxx11.cpp
+\include Tutorial_range_for_loop_1d.cpp
 </td>
 <td>
-\verbinclude Tutorial_range_for_loop_1d_cxx11.out
+\verbinclude Tutorial_range_for_loop_1d.out
 </td></tr></table>
 
 One dimensional expressions can also easily be passed to STL algorithms:
@@ -31,7 +31,7 @@
 \verbinclude Tutorial_std_sort.out
 </td></tr></table>
 
-Similar to `std::vector`, 1D expressions also exposes the pair of `cbegin()/cend()` methods to conveniently get const iterators on non-const object.
+Similar to `std::vector`, 1D expressions also expose the pair of `cbegin()/cend()` methods to conveniently get const iterators on non-const objects.
 
 \section TutorialSTLMatrices Iterating over coefficients of 2D arrays and matrices
 
@@ -41,10 +41,10 @@
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr><td>
-\include Tutorial_range_for_loop_2d_cxx11.cpp
+\include Tutorial_range_for_loop_2d.cpp
 </td>
 <td>
-\verbinclude Tutorial_range_for_loop_2d_cxx11.out
+\verbinclude Tutorial_range_for_loop_2d.out
 </td></tr></table>
 
 \section TutorialSTLRowsColumns Iterating over rows or columns of 2D arrays and matrices
@@ -55,10 +55,10 @@
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr><td>
-\include Tutorial_std_sort_rows_cxx11.cpp
+\include Tutorial_std_sort_rows.cpp
 </td>
 <td>
-\verbinclude Tutorial_std_sort_rows_cxx11.out
+\verbinclude Tutorial_std_sort_rows.out
 </td></tr></table>
 
 */
diff --git a/doc/TutorialSlicingIndexing.dox b/doc/TutorialSlicingIndexing.dox
index a1b00df..58cd716 100644
--- a/doc/TutorialSlicingIndexing.dox
+++ b/doc/TutorialSlicingIndexing.dox
@@ -18,7 +18,22 @@
   - An ArithmeticSequence as constructed by the Eigen::seq, Eigen::seqN, or Eigen::placeholders::lastN functions.
   - Any 1D vector/array of integers including %Eigen's vector/array, expressions, std::vector, std::array, as well as plain C arrays: `int[N]`.
 
-More generally, it can accepts any object exposing the following two member functions:
+The symbols \c last, \c lastp1, \c end, \c all, and \c lastN live in the Eigen::placeholders namespace,
+while \c seq, \c seqN, and \c fix live directly in the Eigen namespace.
+For convenience, they are all re-exported via the Eigen::indexing namespace.
+To make the code examples on this page compile, add one of the following:
+\code
+using namespace Eigen::indexing;
+// or individually:
+using Eigen::placeholders::last;
+using Eigen::placeholders::all;
+using Eigen::placeholders::lastN;
+using Eigen::seq;
+using Eigen::seqN;
+using Eigen::fix;
+\endcode
+
+More generally, it can accept any object exposing the following two member functions:
   \code
   <integral type> operator[](<integral type>) const;
   <integral type> size() const;
@@ -57,7 +72,7 @@
 </tr>
 </table>
 
-The \c firstIdx and \c lastIdx parameters can also be defined with the help of the Eigen::last symbol representing the index of the last row, column or element of the underlying matrix/vector once the arithmetic sequence is passed to it through operator().
+The \c firstIdx and \c lastIdx parameters can also be defined with the help of the Eigen::placeholders::last symbol representing the index of the last row, column or element of the underlying matrix/vector once the arithmetic sequence is passed to it through operator().
 Here are some examples for a 2D array/matrix \c A and a 1D array/vector \c v.
 <table class="manual">
 <tr>
@@ -133,11 +148,6 @@
   <td>\code A.bottomRightCorner(m,n) \endcode</td>
 </tr>
 <tr>
-  <td>Bottom-right corner of A of size \c m times \c n</td>
-  <td>\code A(lastN(m), lastN(n)) \endcode</td>
-  <td>\code A.bottomRightCorner(m,n) \endcode</td>
-</tr>
-<tr>
   <td>Last \c n columns taking 1 column over 3</td>
   <td>\code A(all, lastN(n,3)) \endcode</td>
   <td></td>
@@ -148,7 +158,7 @@
 
 In terms of performance, %Eigen and the compiler can take advantage of compile-time size and increment.
 To this end, you can enforce compile-time parameters using Eigen::fix<val>.
-Such compile-time value can be combined with the Eigen::last symbol:
+Such compile-time value can be combined with the Eigen::placeholders::last symbol:
 \code v(seq(last-fix<7>, last-fix<2>))
 \endcode
 In this example %Eigen knowns at compile-time that the returned expression has 6 elements.
@@ -183,20 +193,20 @@
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr><td>
-\include Slicing_stdvector_cxx11.cpp
+\include Slicing_stdvector.cpp
 </td>
 <td>
-\verbinclude Slicing_stdvector_cxx11.out
+\verbinclude Slicing_stdvector.out
 </td></tr></table>
 
 You can also directly pass a static array:
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr><td>
-\include Slicing_rawarray_cxx11.cpp
+\include Slicing_rawarray.cpp
 </td>
 <td>
-\verbinclude Slicing_rawarray_cxx11.out
+\verbinclude Slicing_rawarray.out
 </td></tr></table>
 
 or expressions:
@@ -226,12 +236,42 @@
 <table class="example">
 <tr><th>Example:</th><th>Output:</th></tr>
 <tr><td>
-\include Slicing_custom_padding_cxx11.cpp
+\include Slicing_custom_padding.cpp
 </td>
 <td>
-\verbinclude Slicing_custom_padding_cxx11.out
+\verbinclude Slicing_custom_padding.out
 </td></tr></table>
 
+\section TutorialSlicingMap Slicing with Map
+
+Before the introduction of the `operator()` API in %Eigen 3.4, uniformly spaced slices were typically built by
+mapping the underlying array with a custom \ref TutorialMapClass "Map" and a suitable Stride.
+This remains a valid alternative, for instance when targeting older versions of %Eigen.
+Here is an example viewing every other coefficient of a vector:
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr><td>
+\include Tutorial_SlicingVec.cpp
+</td>
+<td>
+\verbinclude Tutorial_SlicingVec.out
+</td></tr></table>
+
+and an example taking one column over three of a matrix:
+
+<table class="example">
+<tr><th>Example:</th><th>Output:</th></tr>
+<tr><td>
+\include Tutorial_SlicingCol.cpp
+</td>
+<td>
+\verbinclude Tutorial_SlicingCol.out
+</td></tr></table>
+
+Beware that with Map the stride has to be adjusted to the storage order of the mapped object, as done for \c M4 above,
+whereas the equivalent `A(all, seq(0, last, 3))` works regardless of the storage order.
+
 <br>
 
 */
diff --git a/doc/TutorialSparse.dox b/doc/TutorialSparse.dox
index f226108..2f750a4 100644
--- a/doc/TutorialSparse.dox
+++ b/doc/TutorialSparse.dox
@@ -219,7 +219,7 @@
 5: mat.makeCompressed();                        // optional
 \endcode
 
-- The key ingredient here is the line 2 where we reserve room for 6 non-zeros per column. In many cases, the number of non-zeros per column or row can easily be known in advance. If it varies significantly for each inner vector, then it is possible to specify a reserve size for each inner vector by providing a vector object with an `operator[](int j)` returning the reserve size of the \c j-th inner vector (e.g., via a `VectorXi` or `std::vector<int>`). If only a rought estimate of the number of nonzeros per inner-vector can be obtained, it is highly recommended to overestimate it rather than the opposite. If this line is omitted, then the first insertion of a new element will reserve room for 2 elements per inner vector.
+- The key ingredient here is the line 2 where we reserve room for 6 non-zeros per column. In many cases, the number of non-zeros per column or row can easily be known in advance. If it varies significantly for each inner vector, then it is possible to specify a reserve size for each inner vector by providing a vector object with an `operator[](int j)` returning the reserve size of the \c j-th inner vector (e.g., via a `VectorXi` or `std::vector<int>`). If only a rough estimate of the number of nonzeros per inner-vector can be obtained, it is highly recommended to overestimate it rather than the opposite. If this line is omitted, then the first insertion of a new element will reserve room for one element per inner vector, and room for one more element per inner vector is reserved again whenever an insertion finds no free slot in any inner vector.
 - The line 4 performs a sorted insertion. In this example, the ideal case is when the \c j-th column is not full and contains non-zeros whose inner-indices are smaller than \c i. In this case, this operation boils down to trivial O(1) operation.
 - When calling `insert(i,j)` the element `i`, `j` must not already exists, otherwise use the `coeffRef(i,j)` method that will allow to, e.g., accumulate values. This method first performs a binary search and finally calls `insert(i,j)` if the element does not already exist. It is more flexible than `insert()` but also more costly.
 - The line 5 suppresses the remaining empty space and transforms the matrix into a compressed column storage.
@@ -284,9 +284,9 @@
     \endcode
   - \b symmetric \b sparse-dense. The product of a sparse symmetric matrix with a dense matrix (or vector) can also be optimized by specifying the symmetry with `selfadjointView()`:
     \code
-dm2 = sm1.selfadjointView<>() * dm1;          // if all coefficients of sm1 are stored
-dm2 = sm1.selfadjointView<Upper>() * dm1;     // if only the upper part of sm1 is stored
-dm2 = sm1.selfadjointView<Lower>() * dm1;     // if only the lower part of sm1 is stored
+dm2 = sm1.selfadjointView<Lower|Upper>() * dm1;  // if all coefficients of sm1 are stored
+dm2 = sm1.selfadjointView<Upper>() * dm1;        // if only the upper part of sm1 is stored
+dm2 = sm1.selfadjointView<Lower>() * dm1;        // if only the lower part of sm1 is stored
     \endcode
   - \b sparse-sparse. For sparse-sparse products, two different algorithms are available. The default one is conservative and preserve the explicit zeros that might appear:
     \code
@@ -333,16 +333,16 @@
 
 Just as with dense matrices, the `triangularView()` function can be used to address a triangular part of the matrix, and perform triangular solves with a dense right hand side:
 \code
-dm2 = sm1.triangularView<Lower>(dm1);
-dv2 = sm1.transpose().triangularView<Upper>(dv1);
+dm2 = sm1.triangularView<Lower>().solve(dm1);
+dv2 = sm1.transpose().triangularView<Upper>().solve(dv1);
 \endcode
 
 The `selfadjointView()` function permits various operations:
  - optimized sparse-dense matrix products:
     \code
-dm2 = sm1.selfadjointView<>() * dm1;          // if all coefficients of sm1 are stored
-dm2 = sm1.selfadjointView<Upper>() * dm1;     // if only the upper part of sm1 is stored
-dm2 = sm1.selfadjointView<Lower>() * dm1;     // if only the lower part of sm1 is stored
+dm2 = sm1.selfadjointView<Lower|Upper>() * dm1;  // if all coefficients of sm1 are stored
+dm2 = sm1.selfadjointView<Upper>() * dm1;        // if only the upper part of sm1 is stored
+dm2 = sm1.selfadjointView<Lower>() * dm1;        // if only the lower part of sm1 is stored
     \endcode
  - copy of triangular parts:
     \code
diff --git a/doc/TutorialSparse_example_details.dox b/doc/TutorialSparse_example_details.dox
index 0438da8..73c0f15 100644
--- a/doc/TutorialSparse_example_details.dox
+++ b/doc/TutorialSparse_example_details.dox
@@ -1,4 +1,4 @@
 /**
-\page TutorialSparse_example_details
+\page TutorialSparse_example_details Sparse tutorial: example details
 \include Tutorial_sparse_example_details.cpp
 */
diff --git a/doc/UnalignedArrayAssert.dox b/doc/UnalignedArrayAssert.dox
index 0ed6f88..8288d19 100644
--- a/doc/UnalignedArrayAssert.dox
+++ b/doc/UnalignedArrayAssert.dox
@@ -4,16 +4,17 @@
 
 Hello! You are seeing this webpage because your program terminated on an assertion failure like this one:
 <pre>
-my_program: path/to/eigen/Eigen/src/Core/DenseStorage.h:44:
-Eigen::internal::matrix_array<T, Size, MatrixOptions, Align>::internal::matrix_array()
-[with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]:
-Assertion (reinterpret_cast<size_t>(array) & (sizemask)) == 0 && "this assertion
-is explained here: http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html
-**** READ THIS WEB PAGE !!! ****"' failed.
+my_program: path/to/eigen/Eigen/src/Core/DenseStorage.h:61:
+constexpr Eigen::internal::plain_array<T, Size, MatrixOrArrayOptions, Alignment>::plain_array()
+[with T = double; int Size = 2; int MatrixOrArrayOptions = 0; int Alignment = 16]:
+Assertion `(is_constant_evaluated() || (std::uintptr_t(array) % Alignment == 0)) &&
+"this assertion is explained here: "
+"http://eigen.tuxfamily.org/dox-devel/group__TopicUnalignedArrayAssert.html"
+" **** READ THIS WEB PAGE !!! ****"' failed.
 </pre>
 
 There are 4 known causes for this issue.
-If you can target \cpp17 only with a recent compiler (e.g., GCC>=7, clang>=5, MSVC>=19.12), then you're lucky: enabling c++17 should be enough (if not, please <a href="http://eigen.tuxfamily.org/bz/">report</a> to us).
+If you can target \cpp17 only with a recent compiler (e.g., GCC>=7, clang>=5, MSVC>=19.12), then you're lucky: enabling c++17 should be enough (if not, please <a href="https://gitlab.com/libeigen/eigen/-/issues">report</a> to us).
 Otherwise, please read on to understand those issues and learn how to fix them.
 
 \eigenAutoToc
@@ -62,7 +63,7 @@
 
 Note that here, Eigen::Matrix2d is only used as an example, more generally the issue arises for all \ref TopicFixedSizeVectorizable "fixed-size vectorizable Eigen types" and \ref TopicStructHavingEigenMembers "structures having such Eigen objects as member".
 
-The same issue will be exhibited by any classes/functions by-passing operator new to allocate memory, that is, by performing custom memory allocation followed by calls to the placement new operator. This is for instance typically the case of \c `std::make_shared` or `std::allocate_shared` for which is the solution is to use an \ref aligned_allocator "aligned allocator" as detailed in the \ref TopicStlContainers "solution for STL containers".
+The same issue will be exhibited by any classes/functions bypassing operator new to allocate memory, that is, by performing custom memory allocation followed by calls to the placement new operator. This is for instance typically the case of `std::make_shared` or `std::allocate_shared`, for which the solution is to use an \ref aligned_allocator "aligned allocator" as detailed in the \ref TopicStlContainers "solution for STL containers".
 
 \section c3 Cause 3: Passing Eigen objects by value
 
@@ -110,14 +111,20 @@
   <li>Define \link TopicPreprocessorDirectivesPerformance EIGEN_MAX_STATIC_ALIGN_BYTES \endlink to 0. That disables all 16-byte (and above) static alignment code, while keeping 16-byte (or above) heap alignment. This has the effect of
       vectorizing fixed-size objects (like Matrix4d) through unaligned stores (as controlled by \link TopicPreprocessorDirectivesPerformance EIGEN_UNALIGNED_VECTORIZE \endlink), while keeping unchanged the vectorization of dynamic-size objects
       (like MatrixXd). On 64 bytes systems, you might also define it 16 to disable only 32 and 64 bytes of over-alignment. But do note that this breaks ABI compatibility with the default behavior of static alignment.</li>
-  <li>Or define both \link TopicPreprocessorDirectivesPerformance  EIGEN_DONT_VECTORIZE \endlink and `EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT`. This keeps the
-      16-byte (or above) alignment code and thus preserves ABI compatibility, but completely disables vectorization.</li>
+  <li>Or define \link TopicPreprocessorDirectivesPerformance EIGEN_DONT_VECTORIZE \endlink. Outside GPU compilation,
+      where the alignment is kept because device code needs it, this sets %Eigen's ideal alignment to zero besides
+      disabling vectorization, so fixed-size vectorizable types are no longer over-aligned and the assertion can no
+      longer trigger: `EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT` is then defined automatically, and you do not need to
+      define it yourself.</li>
 </ul>
 
-If you want to know why defining `EIGEN_DONT_VECTORIZE` does not by itself disable 16-byte (or above) alignment and the assertion, here's the explanation:
-
-It doesn't disable the assertion, because otherwise code that runs fine without vectorization would suddenly crash when enabling vectorization.
-It doesn't disable 16-byte (or above) alignment, because that would mean that vectorized and non-vectorized code are not mutually ABI-compatible. This ABI compatibility is very important, even for people who develop only an in-house application, as for instance one may want to have in the same application a vectorized path and a non-vectorized path.
+The last two options change the alignment %Eigen requests for every fixed-size vectorizable type, and alignment is part
+of the ABI: outside GPU compilation, `alignof(Vector4f)` is 16 in a default x86-64 build and 4 under
+`EIGEN_DONT_VECTORIZE`, so a translation unit compiled one way cannot exchange %Eigen objects, or structures holding
+them, with one compiled the other way. Define such a macro for every translation unit of your program, including any
+library you link against that exposes %Eigen types in its interface. The \c DontAlign option carries no such risk: it
+is part of the type, so every translation unit that sees the declaration agrees about it. See \ref TopicVectorization
+for the alignment consequences of the vectorization macros.
 
 \section checkmycode How can I check my code is safe regarding alignment issues?
 
diff --git a/doc/UsingBlasLapackBackends.dox b/doc/UsingBlasLapackBackends.dox
index c700d85..059e1e9 100644
--- a/doc/UsingBlasLapackBackends.dox
+++ b/doc/UsingBlasLapackBackends.dox
@@ -36,12 +36,12 @@
 
 
 Since %Eigen version 3.3 and later, any F77 compatible BLAS or LAPACK libraries can be used as backends for dense matrix products and dense matrix decompositions.
-For instance, one can use <a href="http://eigen.tuxfamily.org/Counter/redirect_to_mkl.php">Intel® MKL</a>, Apple's Accelerate framework on OSX, <a href="http://www.openblas.net/">OpenBLAS</a>, <a href="http://www.netlib.org/lapack">Netlib LAPACK</a>, etc.
+For instance, one can use <a href="https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl.html">Intel® oneMKL</a>, Apple's Accelerate framework on macOS, <a href="http://www.openblas.net/">OpenBLAS</a>, <a href="http://www.netlib.org/lapack">Netlib LAPACK</a>, etc.
 
 Do not miss this \link TopicUsingIntelMKL page \endlink for further discussions on the specific use of Intel® MKL (also includes VML, PARDISO, etc.)
 
-In order to use an external BLAS and/or LAPACK library, you must link you own application to the respective libraries and their dependencies.
-For LAPACK, you must also link to the standard <a href="http://www.netlib.org/lapack/lapacke.html">Lapacke</a> library, which is used as a convenient think layer between %Eigen's C++ code and LAPACK F77 interface. Then you must activate their usage by defining one or multiple of the following macros (\b before including any %Eigen's header):
+In order to use an external BLAS and/or LAPACK library, you must link your own application to the respective libraries and their dependencies.
+For LAPACK, you must also link to the standard <a href="http://www.netlib.org/lapack/lapacke.html">Lapacke</a> library, which is used as a convenient thin layer between %Eigen's C++ code and LAPACK F77 interface. Then you must activate their usage by defining one or multiple of the following macros (\b before including any %Eigen's header):
 
 \note For Mac users, in order to use the lapack version shipped with the Accelerate framework, you also need the lapacke library.
 Using <a href="https://www.macports.org/">MacPorts</a>, this is as easy as:
@@ -54,6 +54,8 @@
 <tr><td>\c EIGEN_USE_BLAS </td><td>Enables the use of external BLAS level 2 and 3 routines (compatible with any F77 BLAS interface)</td></tr>
 <tr class="alt"><td>\c EIGEN_USE_LAPACKE </td><td>Enables the use of external Lapack routines via the <a href="http://www.netlib.org/lapack/lapacke.html">Lapacke</a> C interface to Lapack (compatible with any F77 LAPACK interface)</td></tr>
 <tr><td>\c EIGEN_USE_LAPACKE_STRICT </td><td>Same as \c EIGEN_USE_LAPACKE but algorithms of lower numerical robustness are disabled. \n This currently concerns only JacobiSVD which otherwise would be replaced by \c gesvd that is less robust than Jacobi rotations.</td></tr>
+<tr class="alt"><td>\c EIGEN_64BIT_BLAS </td><td>Selects the 64-bit integer ("ILP64") BLAS interface instead of the default 32-bit ("LP64") one. See \ref TopicUsingBlasLapack_ILP64 below.</td></tr>
+<tr><td>\c EIGEN_BLAS_SYMBOL_SUFFIX </td><td>Suffix of the external BLAS symbol names, for ILP64 libraries that decorate them; e.g. \c _64 selects \c dgemm_64_ instead of \c dgemm_. See \ref TopicUsingBlasLapack_ILP64 below.</td></tr>
 </table>
 
 When doing so, a number of %Eigen's algorithms are silently substituted with calls to BLAS or LAPACK routines.
@@ -134,6 +136,35 @@
 </table>
 In the examples, m1 and m2 are dense matrices and v1 and v2 are dense vectors.
 
+\section TopicUsingBlasLapack_ILP64 The 64-bit integer (ILP64) interface
+
+By default %Eigen calls the 32-bit integer ("LP64") BLAS interface, which limits matrix dimensions and strides to
+2<sup>31</sup>-1. Define \c EIGEN_64BIT_BLAS to call the 64-bit integer ("ILP64") interface instead. ILP64 libraries
+come in two flavours, and they differ in how the symbols are named rather than only in the integer width:
+
+<table class="manual">
+<tr><th>Flavour</th><th>Symbol</th><th>Example</th><th>%Eigen configuration</th></tr>
+<tr><td>Separate ILP64 library, undecorated names</td><td>\c dgemm_ </td>
+    <td>oneMKL \c *_ilp64, OpenBLAS \c INTERFACE64=1 </td><td>\c EIGEN_64BIT_BLAS </td></tr>
+<tr class="alt"><td>Decorated names, may coexist with LP64 in one library</td><td>\c dgemm_64_ </td>
+    <td>Netlib LAPACK \c BUILD_INDEX64_EXT_API, oneMKL >= 2025, OpenBLAS \c SYMBOLSUFFIX=64_ </td>
+    <td>\c EIGEN_64BIT_BLAS and \c EIGEN_BLAS_SYMBOL_SUFFIX=_64 </td></tr>
+</table>
+
+With Intel® MKL, \c EIGEN_64BIT_BLAS must agree with \c MKL_ILP64; %Eigen checks this at compile time.
+
+\warning \c EIGEN_64BIT_BLAS is ABI-affecting: it changes the integer type %Eigen passes to BLAS, so it must be
+defined consistently for every translation unit linked into your program. Prefer setting it on the compile line
+(for example through a CMake target) rather than \c \#define -ing it in individual sources.
+
+\warning %Eigen cannot detect a mismatch between \c EIGEN_64BIT_BLAS and the library you actually link, except for
+Intel® MKL. Fortran BLAS passes every dimension by pointer, so a width mismatch is invisible to both the compiler
+and the linker. Getting it wrong corrupts arguments at run time: calling an ILP64 library without
+\c EIGEN_64BIT_BLAS fails immediately with nonsense dimensions, while the reverse tends to appear to work on
+little-endian machines until a dimension exceeds 2<sup>31</sup>. Since no build-time check is possible, verify the
+combination by running a product against the library you actually ship. %Eigen's test suite does this from CMake;
+see \c eigen_check_external_blas_integer_size in \c test/CMakeLists.txt for a probe you can adapt.
+
 */
 
 }
diff --git a/doc/UsingIntelMKL.dox b/doc/UsingIntelMKL.dox
index fc35c3c..d1931a2 100644
--- a/doc/UsingIntelMKL.dox
+++ b/doc/UsingIntelMKL.dox
@@ -38,16 +38,16 @@
 
 Since %Eigen version 3.1 and later, users can benefit from built-in Intel® Math Kernel Library (MKL) optimizations with an installed copy of Intel MKL 10.3 (or later).
 
-<a href="http://eigen.tuxfamily.org/Counter/redirect_to_mkl.php"> Intel MKL </a> provides highly optimized multi-threaded mathematical routines for x86-compatible architectures.
-Intel MKL is available on Linux, Mac and Windows for both Intel64 and IA32 architectures.
+<a href="https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl.html"> Intel MKL </a> (now distributed as Intel® oneAPI Math Kernel Library, oneMKL) provides highly optimized multi-threaded mathematical routines for x86-compatible architectures.
+Current oneMKL releases are available on Linux and Windows; macOS support was removed in oneMKL 2024.0 and is only present in earlier releases.
 
 \note
-Intel® MKL is a proprietary software and it is the responsibility of users to buy or register for community (free) Intel MKL licenses for their products. Moreover, the license of the user product has to allow linking to proprietary software that excludes any unmodified versions of the GPL.
+Intel® oneMKL is closed source, but it is distributed under the Intel Simplified Software License: there is no license to buy and no community-license registration to complete, and the terms grant royalty-free use and redistribution with no limit on the number of copies. See the <a href="https://www.intel.com/content/www/us/en/developer/articles/tool/onemkl-license-faq.html">oneMKL license FAQ</a> for the terms that apply to your own product.
 
 Using Intel MKL through %Eigen is easy:
 -# define the \c EIGEN_USE_MKL_ALL macro before including any %Eigen's header
--# link your program to MKL libraries (see the <a href="http://software.intel.com/en-us/articles/intel-mkl-link-line-advisor/">MKL linking advisor</a>)
--# on a 64bits system, you must use the LP64 interface (not the ILP64 one)
+-# link your program to MKL libraries (see the <a href="https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl-link-line-advisor.html">MKL link line advisor</a>)
+-# to use the ILP64 interface rather than LP64, define \c EIGEN_64BIT_BLAS alongside \c MKL_ILP64 (see \ref TopicUsingBlasLapack_ILP64); %Eigen checks at compile time that the two agree
 
 When doing so, a number of %Eigen's algorithms are silently substituted with calls to Intel MKL routines.
 These substitutions apply only for \b Dynamic \b or \b large enough objects with one of the following four standard scalar types: \c float, \c double, \c complex<float>, and \c complex<double>.
@@ -104,8 +104,9 @@
 
 
 \section TopicUsingIntelMKL_Links Links
-- Intel MKL can be purchased and downloaded <a href="http://eigen.tuxfamily.org/Counter/redirect_to_mkl.php">here</a>.
-- Intel MKL is also bundled with <a href="http://software.intel.com/en-us/articles/intel-composer-xe/">Intel Composer XE</a>.
+- Intel MKL can be downloaded from the
+  <a href="https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl.html">Intel oneMKL page</a>,
+  either standalone or as part of the Intel oneAPI Base Toolkit.
 
 
 */
diff --git a/doc/UsingNVCC.dox b/doc/UsingNVCC.dox
index ce5e07f..c0c5a73 100644
--- a/doc/UsingNVCC.dox
+++ b/doc/UsingNVCC.dox
@@ -15,6 +15,9 @@
 before including any %Eigen header.
 This might be useful to disable some warnings when a \c .cu file makes use of %Eigen on the host side only.
 
+%Eigen requires CUDA 11.8 or later and compute capability 6.0 (\c sm_60) or later; CUDA 13 itself requires
+\c sm_75. For HIP the floor is ROCm 5.6.
+
 \warning Host SIMD vectorization must be disabled in \c .cu files. It is \b strongly
 \b recommended to move all costly host-side computation from \c .cu files to regular \c .cpp files.
 
@@ -27,7 +30,7 @@
 
 \section TopicCUDA_KnownIssues Known issues
 
- - On 64-bit systems %Eigen uses \c long \c int as the default type for indexes and sizes.
+ - On 64-bit systems %Eigen uses \c std::ptrdiff_t, a 64-bit type, as the default type for indexes and sizes.
    On CUDA/HIP devices, it would make sense to default to 32-bit \c int.
    However, to keep host and device code compatible, this cannot be done automatically by %Eigen,
    and the user is thus required to define \c EIGEN_DEFAULT_DENSE_INDEX_TYPE to \c int throughout
diff --git a/doc/WrongStackAlignment.dox b/doc/WrongStackAlignment.dox
index 17d5513..c78f081 100644
--- a/doc/WrongStackAlignment.dox
+++ b/doc/WrongStackAlignment.dox
@@ -2,10 +2,9 @@
 
 /** \eigenManualPage TopicWrongStackAlignment Compiler making a wrong assumption on stack alignment
 
-<h4>It appears that this was a GCC bug that has been fixed in GCC 4.5.
-If you hit this issue, please upgrade to GCC 4.5 and report to us, so we can update this page.</h4>
-
-This is an issue that, so far, we met only with GCC on Windows: for instance, MinGW and TDM-GCC.
+\note This is a historical issue affecting GCC before version 4.5 on Windows (MinGW, TDM-GCC).
+It was fixed in GCC 4.5, and every compiler supported by current %Eigen handles stack alignment
+correctly. The page is kept for users stuck on such legacy toolchains.
 
 By default, in a function like this,
 
@@ -17,7 +16,7 @@
 }
 \endcode
 
-GCC assumes that the stack is already 16-byte-aligned so that the object \a q will be created at a 16-byte-aligned location. For this reason, it doesn't take any special care to explicitly align the object \a q, as Eigen requires.
+GCC assumes that the stack is already 16-byte-aligned so that the object \a q will be created at a 16-byte-aligned location. For this reason, it doesn't take any special care to explicitly align the object \a q, as %Eigen requires.
 
 The problem is that, in some particular cases, this assumption can be wrong on Windows, where the stack is only guaranteed to have 4-byte alignment. Indeed, even though GCC takes care of aligning the stack in the main function and does its best to keep it aligned, when a function is called from another thread or from a binary compiled with another compiler, the stack alignment can be corrupted. This results in the object 'q' being created at an unaligned location, making your program crash with the \ref TopicUnalignedArrayAssert "assertion on unaligned arrays". So far we found the three following solutions.
 
@@ -32,7 +31,7 @@
   //...
 }
 \endcode
-Read <a href="http://gcc.gnu.org/onlinedocs/gcc-4.4.0/gcc/Function-Attributes.html#Function-Attributes">this GCC documentation</a> to understand what this does. Of course this should only be done on GCC on Windows, so for portability you'll have to encapsulate this in a macro which you leave empty on other platforms. The advantage of this solution is that you can finely select which function might have a corrupted stack alignment. Of course on the downside this has to be done for every such function, so you may prefer one of the following two global solutions.
+Read <a href="https://gcc.gnu.org/onlinedocs/gcc/x86-Function-Attributes.html">this GCC documentation</a> to understand what this does. Of course this should only be done on GCC on Windows, so for portability you'll have to encapsulate this in a macro which you leave empty on other platforms. The advantage of this solution is that you can finely select which function might have a corrupted stack alignment. Of course on the downside this has to be done for every such function, so you may prefer one of the following two global solutions.
 
 
 \section sec_sol2 Global solutions
diff --git a/doc/examples/CMakeLists.txt b/doc/examples/CMakeLists.txt
index 39766c1..243650b 100644
--- a/doc/examples/CMakeLists.txt
+++ b/doc/examples/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 file(GLOB examples_SRCS "*.cpp")
 
 foreach(example_src ${examples_SRCS})
diff --git a/doc/examples/CustomizingEigen_Inheritance.cpp b/doc/examples/CustomizingEigen_Inheritance.cpp
index 26e1e3c..c56188d 100644
--- a/doc/examples/CustomizingEigen_Inheritance.cpp
+++ b/doc/examples/CustomizingEigen_Inheritance.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/Cwise_erf.cpp b/doc/examples/Cwise_erf.cpp
index 598c18c..17d1f2f 100644
--- a/doc/examples/Cwise_erf.cpp
+++ b/doc/examples/Cwise_erf.cpp
@@ -1,5 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
-#include <unsupported/Eigen/SpecialFunctions>
+#include <contrib/Eigen/SpecialFunctions>
 #include <iostream>
 int main() {
   Eigen::Array4d v(-0.5, 2, 0, -7);
diff --git a/doc/examples/Cwise_erfc.cpp b/doc/examples/Cwise_erfc.cpp
index 98b0b75..b8b0e6d 100644
--- a/doc/examples/Cwise_erfc.cpp
+++ b/doc/examples/Cwise_erfc.cpp
@@ -1,5 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
-#include <unsupported/Eigen/SpecialFunctions>
+#include <contrib/Eigen/SpecialFunctions>
 #include <iostream>
 int main() {
   Eigen::Array4d v(-0.5, 2, 0, -7);
diff --git a/doc/examples/Cwise_lgamma.cpp b/doc/examples/Cwise_lgamma.cpp
index 10866d8..ce6188c 100644
--- a/doc/examples/Cwise_lgamma.cpp
+++ b/doc/examples/Cwise_lgamma.cpp
@@ -1,5 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
-#include <unsupported/Eigen/SpecialFunctions>
+#include <contrib/Eigen/SpecialFunctions>
 #include <iostream>
 int main() {
   Eigen::Array4d v(0.5, 10, 0, -1);
diff --git a/doc/examples/DenseBase_middleCols_int.cpp b/doc/examples/DenseBase_middleCols_int.cpp
index cb7dace..3059cce 100644
--- a/doc/examples/DenseBase_middleCols_int.cpp
+++ b/doc/examples/DenseBase_middleCols_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/DenseBase_middleRows_int.cpp b/doc/examples/DenseBase_middleRows_int.cpp
index 6a25500..0d4c265 100644
--- a/doc/examples/DenseBase_middleRows_int.cpp
+++ b/doc/examples/DenseBase_middleRows_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/DenseBase_template_int_middleCols.cpp b/doc/examples/DenseBase_template_int_middleCols.cpp
index 52c032c..61e5a65 100644
--- a/doc/examples/DenseBase_template_int_middleCols.cpp
+++ b/doc/examples/DenseBase_template_int_middleCols.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/DenseBase_template_int_middleRows.cpp b/doc/examples/DenseBase_template_int_middleRows.cpp
index 4db5e70..f415db1 100644
--- a/doc/examples/DenseBase_template_int_middleRows.cpp
+++ b/doc/examples/DenseBase_template_int_middleRows.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/QuickStart_example.cpp b/doc/examples/QuickStart_example.cpp
index 103ddd5..52c857d 100644
--- a/doc/examples/QuickStart_example.cpp
+++ b/doc/examples/QuickStart_example.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/QuickStart_example2_dynamic.cpp b/doc/examples/QuickStart_example2_dynamic.cpp
index c7e7c32..4f99d04 100644
--- a/doc/examples/QuickStart_example2_dynamic.cpp
+++ b/doc/examples/QuickStart_example2_dynamic.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/QuickStart_example2_fixed.cpp b/doc/examples/QuickStart_example2_fixed.cpp
index e643a47..79a7083 100644
--- a/doc/examples/QuickStart_example2_fixed.cpp
+++ b/doc/examples/QuickStart_example2_fixed.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TemplateKeyword_flexible.cpp b/doc/examples/TemplateKeyword_flexible.cpp
index 09919a3..1fe7922 100644
--- a/doc/examples/TemplateKeyword_flexible.cpp
+++ b/doc/examples/TemplateKeyword_flexible.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/TemplateKeyword_simple.cpp b/doc/examples/TemplateKeyword_simple.cpp
index 4902988..16c7aba 100644
--- a/doc/examples/TemplateKeyword_simple.cpp
+++ b/doc/examples/TemplateKeyword_simple.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/TutorialInplaceLU.cpp b/doc/examples/TutorialInplaceLU.cpp
index a0bf8b5..fabae79 100644
--- a/doc/examples/TutorialInplaceLU.cpp
+++ b/doc/examples/TutorialInplaceLU.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgComputeTwice.cpp b/doc/examples/TutorialLinAlgComputeTwice.cpp
index 41ff22e..40c08bc 100644
--- a/doc/examples/TutorialLinAlgComputeTwice.cpp
+++ b/doc/examples/TutorialLinAlgComputeTwice.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgExComputeSolveError.cpp b/doc/examples/TutorialLinAlgExComputeSolveError.cpp
index 268aa35..040acd2 100644
--- a/doc/examples/TutorialLinAlgExComputeSolveError.cpp
+++ b/doc/examples/TutorialLinAlgExComputeSolveError.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp b/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp
index 7caed4a..c50f9ae 100644
--- a/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp
+++ b/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgExSolveLDLT.cpp b/doc/examples/TutorialLinAlgExSolveLDLT.cpp
index c11557d..6e93477 100644
--- a/doc/examples/TutorialLinAlgExSolveLDLT.cpp
+++ b/doc/examples/TutorialLinAlgExSolveLDLT.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgInverseDeterminant.cpp b/doc/examples/TutorialLinAlgInverseDeterminant.cpp
index c03fe5c..58df51d 100644
--- a/doc/examples/TutorialLinAlgInverseDeterminant.cpp
+++ b/doc/examples/TutorialLinAlgInverseDeterminant.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgRankRevealing.cpp b/doc/examples/TutorialLinAlgRankRevealing.cpp
index 1f89146..7d21b66 100644
--- a/doc/examples/TutorialLinAlgRankRevealing.cpp
+++ b/doc/examples/TutorialLinAlgRankRevealing.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgSVDSolve.cpp b/doc/examples/TutorialLinAlgSVDSolve.cpp
index 3cee2b4..4464060 100644
--- a/doc/examples/TutorialLinAlgSVDSolve.cpp
+++ b/doc/examples/TutorialLinAlgSVDSolve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
@@ -7,5 +10,5 @@
   Eigen::VectorXf b = Eigen::VectorXf::Random(3);
   std::cout << "Here is the right hand side b:\n" << b << std::endl;
   std::cout << "The least-squares solution is:\n"
-            << A.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b) << std::endl;
+            << A.bdcSvd<Eigen::ComputeThinU | Eigen::ComputeThinV>().solve(b) << std::endl;
 }
diff --git a/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp b/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp
index 6faccb6..4a0238e 100644
--- a/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp
+++ b/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/TutorialLinAlgSetThreshold.cpp b/doc/examples/TutorialLinAlgSetThreshold.cpp
index 97251f8..c8daea0 100644
--- a/doc/examples/TutorialLinAlgSetThreshold.cpp
+++ b/doc/examples/TutorialLinAlgSetThreshold.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ArrayClass_accessors.cpp b/doc/examples/Tutorial_ArrayClass_accessors.cpp
index 5e91deb..c5761a5 100644
--- a/doc/examples/Tutorial_ArrayClass_accessors.cpp
+++ b/doc/examples/Tutorial_ArrayClass_accessors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ArrayClass_addition.cpp b/doc/examples/Tutorial_ArrayClass_addition.cpp
index e9a8f3e..9223600 100644
--- a/doc/examples/Tutorial_ArrayClass_addition.cpp
+++ b/doc/examples/Tutorial_ArrayClass_addition.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ArrayClass_cwise_other.cpp b/doc/examples/Tutorial_ArrayClass_cwise_other.cpp
index cbd3238..1a33aad 100644
--- a/doc/examples/Tutorial_ArrayClass_cwise_other.cpp
+++ b/doc/examples/Tutorial_ArrayClass_cwise_other.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ArrayClass_interop.cpp b/doc/examples/Tutorial_ArrayClass_interop.cpp
index 9b02f2a..972a0ce 100644
--- a/doc/examples/Tutorial_ArrayClass_interop.cpp
+++ b/doc/examples/Tutorial_ArrayClass_interop.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp b/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp
index b5bc6ae..7f391db 100644
--- a/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp
+++ b/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ArrayClass_mult.cpp b/doc/examples/Tutorial_ArrayClass_mult.cpp
index 39c2300..f2e4e14 100644
--- a/doc/examples/Tutorial_ArrayClass_mult.cpp
+++ b/doc/examples/Tutorial_ArrayClass_mult.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_BlockOperations_block_assignment.cpp b/doc/examples/Tutorial_BlockOperations_block_assignment.cpp
index 27b88b3..66963a5 100644
--- a/doc/examples/Tutorial_BlockOperations_block_assignment.cpp
+++ b/doc/examples/Tutorial_BlockOperations_block_assignment.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_BlockOperations_colrow.cpp b/doc/examples/Tutorial_BlockOperations_colrow.cpp
index b236334..e942c9f 100644
--- a/doc/examples/Tutorial_BlockOperations_colrow.cpp
+++ b/doc/examples/Tutorial_BlockOperations_colrow.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_BlockOperations_corner.cpp b/doc/examples/Tutorial_BlockOperations_corner.cpp
index cd093fc..6f4338a 100644
--- a/doc/examples/Tutorial_BlockOperations_corner.cpp
+++ b/doc/examples/Tutorial_BlockOperations_corner.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_BlockOperations_print_block.cpp b/doc/examples/Tutorial_BlockOperations_print_block.cpp
index 45683c9..1a04cb9 100644
--- a/doc/examples/Tutorial_BlockOperations_print_block.cpp
+++ b/doc/examples/Tutorial_BlockOperations_print_block.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_BlockOperations_vector.cpp b/doc/examples/Tutorial_BlockOperations_vector.cpp
index 0ce2b0b..99b1615 100644
--- a/doc/examples/Tutorial_BlockOperations_vector.cpp
+++ b/doc/examples/Tutorial_BlockOperations_vector.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_PartialLU_solve.cpp b/doc/examples/Tutorial_PartialLU_solve.cpp
index bfc0973..4d1ba18 100644
--- a/doc/examples/Tutorial_PartialLU_solve.cpp
+++ b/doc/examples/Tutorial_PartialLU_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <Eigen/LU>
 #include <iostream>
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
index 61ab75f..2caae33 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
index 63ee724..1b16ddb 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
index 1f937ad..b995ba8 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_simple_rowwise.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
index f40184b..b520ec2 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_colwise.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
index 88e319d..7ca108a 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
index 71f2030..0c3eb13 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
index 75bfee0..c5c4cbc 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
index 695f538..c31f199 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Dense>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_userdefined.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_userdefined.cpp
new file mode 100644
index 0000000..1821fb6
--- /dev/null
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_userdefined.cpp
@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <Eigen/Dense>
+#include <cmath>
+#include <iostream>
+
+struct GreaterAbs {
+  double operator()(double a, double b) const {
+    using std::abs;
+    return abs(a) < abs(b) ? b : a;
+  }
+};
+
+int main() {
+  Eigen::MatrixXd m(2, 3);
+  m << -2, 1, 4, 3, -5, 2;
+
+  std::cout << "matrix:\n" << m << "\n\n";
+  std::cout << "largest absolute value: " << m.redux(GreaterAbs()) << "\n";
+  std::cout << "column-wise:\n" << m.colwise().redux(GreaterAbs()) << "\n";
+}
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
index b525b2a..9c69963 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_rowwise.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
index ce3ca7e..411dc6c 100644
--- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
+++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/Tutorial_simple_example_dynamic_size.cpp b/doc/examples/Tutorial_simple_example_dynamic_size.cpp
index 102223f..9706af7 100644
--- a/doc/examples/Tutorial_simple_example_dynamic_size.cpp
+++ b/doc/examples/Tutorial_simple_example_dynamic_size.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/Tutorial_simple_example_fixed_size.cpp b/doc/examples/Tutorial_simple_example_fixed_size.cpp
index 8e20230..ab059bb 100644
--- a/doc/examples/Tutorial_simple_example_fixed_size.cpp
+++ b/doc/examples/Tutorial_simple_example_fixed_size.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_Block.cpp b/doc/examples/class_Block.cpp
index 0fb9202..fa7b5eb 100644
--- a/doc/examples/class_Block.cpp
+++ b/doc/examples/class_Block.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_CwiseBinaryOp.cpp b/doc/examples/class_CwiseBinaryOp.cpp
index f8c1f92..1437189 100644
--- a/doc/examples/class_CwiseBinaryOp.cpp
+++ b/doc/examples/class_CwiseBinaryOp.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_CwiseUnaryOp.cpp b/doc/examples/class_CwiseUnaryOp.cpp
index 24177ce..05b9158 100644
--- a/doc/examples/class_CwiseUnaryOp.cpp
+++ b/doc/examples/class_CwiseUnaryOp.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_CwiseUnaryOp_ptrfun.cpp b/doc/examples/class_CwiseUnaryOp_ptrfun.cpp
index 279355c..3d7394d 100644
--- a/doc/examples/class_CwiseUnaryOp_ptrfun.cpp
+++ b/doc/examples/class_CwiseUnaryOp_ptrfun.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
@@ -11,6 +14,8 @@
 
 int main(int, char**) {
   Eigen::Matrix4d m1 = Eigen::Matrix4d::Random();
-  std::cout << m1 << std::endl << "becomes: " << std::endl << m1.unaryExpr(std::ptr_fun(ramp)) << std::endl;
+  std::cout << m1 << std::endl
+            << "becomes: " << std::endl
+            << m1.unaryExpr([](double x) { return ramp(x); }) << std::endl;
   return 0;
 }
diff --git a/doc/examples/class_FixedBlock.cpp b/doc/examples/class_FixedBlock.cpp
index 875e779..5743738 100644
--- a/doc/examples/class_FixedBlock.cpp
+++ b/doc/examples/class_FixedBlock.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_FixedReshaped.cpp b/doc/examples/class_FixedReshaped.cpp
index 29a04f6..e53ba22 100644
--- a/doc/examples/class_FixedReshaped.cpp
+++ b/doc/examples/class_FixedReshaped.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_FixedVectorBlock.cpp b/doc/examples/class_FixedVectorBlock.cpp
index cee8ac8..d2b5aa2 100644
--- a/doc/examples/class_FixedVectorBlock.cpp
+++ b/doc/examples/class_FixedVectorBlock.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_Reshaped.cpp b/doc/examples/class_Reshaped.cpp
index a91c3ff..1de7453 100644
--- a/doc/examples/class_Reshaped.cpp
+++ b/doc/examples/class_Reshaped.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/class_VectorBlock.cpp b/doc/examples/class_VectorBlock.cpp
index d427fa7..48fe8e7 100644
--- a/doc/examples/class_VectorBlock.cpp
+++ b/doc/examples/class_VectorBlock.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/function_taking_eigenbase.cpp b/doc/examples/function_taking_eigenbase.cpp
index 524ea18..6fd5e9b 100644
--- a/doc/examples/function_taking_eigenbase.cpp
+++ b/doc/examples/function_taking_eigenbase.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Core>
 
diff --git a/doc/examples/function_taking_ref.cpp b/doc/examples/function_taking_ref.cpp
index 8fd8c76..e298447 100644
--- a/doc/examples/function_taking_ref.cpp
+++ b/doc/examples/function_taking_ref.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/SVD>
 
diff --git a/doc/examples/make_circulant.cpp b/doc/examples/make_circulant.cpp
index 92e6aaa..7cef8d1 100644
--- a/doc/examples/make_circulant.cpp
+++ b/doc/examples/make_circulant.cpp
@@ -2,6 +2,8 @@
 This program is presented in several fragments in the doc page.
 Every fragment is in its own file; this file simply combines them.
 */
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include "make_circulant.cpp.preamble"
 #include "make_circulant.cpp.traits"
diff --git a/doc/examples/make_circulant2.cpp b/doc/examples/make_circulant2.cpp
index b3bbcfc..655390c 100644
--- a/doc/examples/make_circulant2.cpp
+++ b/doc/examples/make_circulant2.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/matrixfree_cg.cpp b/doc/examples/matrixfree_cg.cpp
index 66f2c27..90aea63 100644
--- a/doc/examples/matrixfree_cg.cpp
+++ b/doc/examples/matrixfree_cg.cpp
@@ -1,8 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
-#include <Eigen/Core>
-#include <Eigen/Dense>
 #include <Eigen/IterativeLinearSolvers>
-#include <unsupported/Eigen/IterativeSolvers>
 
 class MatrixReplacement;
 using Eigen::SparseMatrix;
@@ -19,11 +19,13 @@
 // For the sake of simplicity, this example simply wrap a Eigen::SparseMatrix.
 class MatrixReplacement : public Eigen::EigenBase<MatrixReplacement> {
  public:
-  // Required typedefs, constants, and method:
-  typedef double Scalar;
-  typedef double RealScalar;
-  typedef int StorageIndex;
-  enum { ColsAtCompileTime = Eigen::Dynamic, MaxColsAtCompileTime = Eigen::Dynamic, IsRowMajor = false };
+  // Required types, constants, and methods:
+  using Scalar = double;
+  using RealScalar = double;
+  using StorageIndex = int;
+  static constexpr int ColsAtCompileTime = Eigen::Dynamic;
+  static constexpr int MaxColsAtCompileTime = Eigen::Dynamic;
+  static constexpr bool IsRowMajor = false;
 
   Index rows() const { return mp_mat->rows(); }
   Index cols() const { return mp_mat->cols(); }
@@ -34,13 +36,13 @@
   }
 
   // Custom API:
-  MatrixReplacement() : mp_mat(0) {}
+  MatrixReplacement() = default;
 
   void attachMyMatrix(const SparseMatrix<double>& mat) { mp_mat = &mat; }
-  const SparseMatrix<double> my_matrix() const { return *mp_mat; }
+  const SparseMatrix<double>& my_matrix() const { return *mp_mat; }
 
  private:
-  const SparseMatrix<double>* mp_mat;
+  const SparseMatrix<double>* mp_mat = nullptr;
 };
 
 // Implementation of MatrixReplacement * Eigen::DenseVector though a specialization of internal::generic_product_impl:
@@ -51,7 +53,7 @@
 struct generic_product_impl<MatrixReplacement, Rhs, SparseShape, DenseShape,
                             GemvProduct>  // GEMV stands for matrix-vector
     : generic_product_impl_base<MatrixReplacement, Rhs, generic_product_impl<MatrixReplacement, Rhs> > {
-  typedef typename Product<MatrixReplacement, Rhs>::Scalar Scalar;
+  using Scalar = typename Product<MatrixReplacement, Rhs>::Scalar;
 
   template <typename Dest>
   static void scaleAndAddTo(Dest& dst, const MatrixReplacement& lhs, const Rhs& rhs, const Scalar& alpha) {
@@ -69,51 +71,41 @@
 }  // namespace internal
 }  // namespace Eigen
 
+// Solve Ax = b with the given matrix-free solver and report the outcome. The default tolerance,
+// NumTraits<double>::epsilon(), is out of reach for CG and MINRES on this matrix, so pick an attainable one.
+template <typename Solver>
+void solve(const char* name, Solver& solver, const MatrixReplacement& A, const Eigen::VectorXd& b) {
+  solver.setTolerance(1e-10);
+  solver.compute(A);
+  Eigen::VectorXd x = solver.solve(b);
+  std::cout << name << (solver.info() == Eigen::Success ? " converged" : " did not converge") << " after "
+            << solver.iterations() << " iterations, estimated error: " << solver.error() << std::endl;
+}
+
 int main() {
-  int n = 10;
+  Eigen::Index n = 10;
   Eigen::SparseMatrix<double> S = Eigen::MatrixXd::Random(n, n).sparseView(0.5, 1);
   S = S.transpose() * S;
 
   MatrixReplacement A;
   A.attachMyMatrix(S);
 
-  Eigen::VectorXd b(n), x;
+  Eigen::VectorXd b(n);
   b.setRandom();
 
   // Solve Ax = b using various iterative solver with matrix-free version:
-  {
-    Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> cg;
-    cg.compute(A);
-    x = cg.solve(b);
-    std::cout << "CG:       #iterations: " << cg.iterations() << ", estimated error: " << cg.error() << std::endl;
-  }
+  Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> cg;
+  solve("CG:      ", cg, A, b);
 
-  {
-    Eigen::BiCGSTAB<MatrixReplacement, Eigen::IdentityPreconditioner> bicg;
-    bicg.compute(A);
-    x = bicg.solve(b);
-    std::cout << "BiCGSTAB: #iterations: " << bicg.iterations() << ", estimated error: " << bicg.error() << std::endl;
-  }
+  Eigen::BiCGSTAB<MatrixReplacement, Eigen::IdentityPreconditioner> bicgstab;
+  solve("BiCGSTAB:", bicgstab, A, b);
 
-  {
-    Eigen::GMRES<MatrixReplacement, Eigen::IdentityPreconditioner> gmres;
-    gmres.compute(A);
-    x = gmres.solve(b);
-    std::cout << "GMRES:    #iterations: " << gmres.iterations() << ", estimated error: " << gmres.error() << std::endl;
-  }
+  Eigen::GMRES<MatrixReplacement, Eigen::IdentityPreconditioner> gmres;
+  solve("GMRES:   ", gmres, A, b);
 
-  {
-    Eigen::DGMRES<MatrixReplacement, Eigen::IdentityPreconditioner> gmres;
-    gmres.compute(A);
-    x = gmres.solve(b);
-    std::cout << "DGMRES:   #iterations: " << gmres.iterations() << ", estimated error: " << gmres.error() << std::endl;
-  }
+  Eigen::DGMRES<MatrixReplacement, Eigen::IdentityPreconditioner> dgmres;
+  solve("DGMRES:  ", dgmres, A, b);
 
-  {
-    Eigen::MINRES<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> minres;
-    minres.compute(A);
-    x = minres.solve(b);
-    std::cout << "MINRES:   #iterations: " << minres.iterations() << ", estimated error: " << minres.error()
-              << std::endl;
-  }
+  Eigen::MINRES<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> minres;
+  solve("MINRES:  ", minres, A, b);
 }
diff --git a/doc/examples/nullary_indexing.cpp b/doc/examples/nullary_indexing.cpp
index f98e690..569d674 100644
--- a/doc/examples/nullary_indexing.cpp
+++ b/doc/examples/nullary_indexing.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Core>
 #include <iostream>
 
diff --git a/doc/examples/tut_arithmetic_add_sub.cpp b/doc/examples/tut_arithmetic_add_sub.cpp
index ceb43ca..cada0ee 100644
--- a/doc/examples/tut_arithmetic_add_sub.cpp
+++ b/doc/examples/tut_arithmetic_add_sub.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_arithmetic_dot_cross.cpp b/doc/examples/tut_arithmetic_dot_cross.cpp
index 09eea39..3cd30ee 100644
--- a/doc/examples/tut_arithmetic_dot_cross.cpp
+++ b/doc/examples/tut_arithmetic_dot_cross.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_arithmetic_matrix_mul.cpp b/doc/examples/tut_arithmetic_matrix_mul.cpp
index ead4800..f1a22be 100644
--- a/doc/examples/tut_arithmetic_matrix_mul.cpp
+++ b/doc/examples/tut_arithmetic_matrix_mul.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_arithmetic_redux_basic.cpp b/doc/examples/tut_arithmetic_redux_basic.cpp
index 3140237..b3ed1ed 100644
--- a/doc/examples/tut_arithmetic_redux_basic.cpp
+++ b/doc/examples/tut_arithmetic_redux_basic.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_arithmetic_scalar_mul_div.cpp b/doc/examples/tut_arithmetic_scalar_mul_div.cpp
index 05f1ebd..22e0f59 100644
--- a/doc/examples/tut_arithmetic_scalar_mul_div.cpp
+++ b/doc/examples/tut_arithmetic_scalar_mul_div.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_matrix_coefficient_accessors.cpp b/doc/examples/tut_matrix_coefficient_accessors.cpp
index e509a98..065f4c2 100644
--- a/doc/examples/tut_matrix_coefficient_accessors.cpp
+++ b/doc/examples/tut_matrix_coefficient_accessors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_matrix_resize.cpp b/doc/examples/tut_matrix_resize.cpp
index 6e00919..aca785f 100644
--- a/doc/examples/tut_matrix_resize.cpp
+++ b/doc/examples/tut_matrix_resize.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/examples/tut_matrix_resize_fixed_size.cpp b/doc/examples/tut_matrix_resize_fixed_size.cpp
index 44645d8..d7dc975 100644
--- a/doc/examples/tut_matrix_resize_fixed_size.cpp
+++ b/doc/examples/tut_matrix_resize_fixed_size.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <iostream>
 #include <Eigen/Dense>
 
diff --git a/doc/snippets/AngleAxis_mimic_euler.cpp b/doc/snippets/AngleAxis_mimic_euler.cpp
index 0033f59..ef22e34 100644
--- a/doc/snippets/AngleAxis_mimic_euler.cpp
+++ b/doc/snippets/AngleAxis_mimic_euler.cpp
@@ -1,4 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f m;
-m = AngleAxisf(0.25 * EIGEN_PI, Vector3f::UnitX()) * AngleAxisf(0.5 * EIGEN_PI, Vector3f::UnitY()) *
-    AngleAxisf(0.33 * EIGEN_PI, Vector3f::UnitZ());
+m = AngleAxisf(float(0.25L * EIGEN_PI), Vector3f::UnitX()) * AngleAxisf(float(0.5L * EIGEN_PI), Vector3f::UnitY()) *
+    AngleAxisf(float(0.33L * EIGEN_PI), Vector3f::UnitZ());
 cout << m << endl << "is unitary: " << m.isUnitary() << endl;
diff --git a/doc/snippets/Array_initializer_list_23.cpp b/doc/snippets/Array_initializer_list_23.cpp
new file mode 100644
index 0000000..c17941b
--- /dev/null
+++ b/doc/snippets/Array_initializer_list_23.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+ArrayXXi a{{1, 2, 3}, {3, 4, 5}};
+cout << a << endl;
diff --git a/doc/snippets/Array_initializer_list_23_cxx11.cpp b/doc/snippets/Array_initializer_list_23_cxx11.cpp
deleted file mode 100644
index 8f491cb..0000000
--- a/doc/snippets/Array_initializer_list_23_cxx11.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-ArrayXXi a{{1, 2, 3}, {3, 4, 5}};
-cout << a << endl;
diff --git a/doc/snippets/Array_initializer_list_vector.cpp b/doc/snippets/Array_initializer_list_vector.cpp
new file mode 100644
index 0000000..9e14a94
--- /dev/null
+++ b/doc/snippets/Array_initializer_list_vector.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+Array<int, Dynamic, 1> v{{1, 2, 3, 4, 5}};
+cout << v << endl;
diff --git a/doc/snippets/Array_initializer_list_vector_cxx11.cpp b/doc/snippets/Array_initializer_list_vector_cxx11.cpp
deleted file mode 100644
index 398831f..0000000
--- a/doc/snippets/Array_initializer_list_vector_cxx11.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-Array<int, Dynamic, 1> v{{1, 2, 3, 4, 5}};
-cout << v << endl;
diff --git a/doc/snippets/Array_variadic_ctor.cpp b/doc/snippets/Array_variadic_ctor.cpp
new file mode 100644
index 0000000..9c63a4f
--- /dev/null
+++ b/doc/snippets/Array_variadic_ctor.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+Array<int, 1, 6> a(1, 2, 3, 4, 5, 6);
+Array<int, 3, 1> b{1, 2, 3};
+cout << a << "\n\n" << b << endl;
diff --git a/doc/snippets/Array_variadic_ctor_cxx11.cpp b/doc/snippets/Array_variadic_ctor_cxx11.cpp
deleted file mode 100644
index 6df78a5..0000000
--- a/doc/snippets/Array_variadic_ctor_cxx11.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-Array<int, 1, 6> a(1, 2, 3, 4, 5, 6);
-Array<int, 3, 1> b{1, 2, 3};
-cout << a << "\n\n" << b << endl;
diff --git a/doc/snippets/BiCGSTAB_simple.cpp b/doc/snippets/BiCGSTAB_simple.cpp
index 68f07c9..d3755c9 100644
--- a/doc/snippets/BiCGSTAB_simple.cpp
+++ b/doc/snippets/BiCGSTAB_simple.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int n = 10000;
 VectorXd x(n), b(n);
 SparseMatrix<double> A(n, n);
diff --git a/doc/snippets/BiCGSTAB_step_by_step.cpp b/doc/snippets/BiCGSTAB_step_by_step.cpp
index 7fe53a5..33c5558 100644
--- a/doc/snippets/BiCGSTAB_step_by_step.cpp
+++ b/doc/snippets/BiCGSTAB_step_by_step.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int n = 10000;
 VectorXd x(n), b(n);
 SparseMatrix<double> A(n, n);
diff --git a/doc/snippets/CMakeLists.txt b/doc/snippets/CMakeLists.txt
index 1c25831..bc5dd5f 100644
--- a/doc/snippets/CMakeLists.txt
+++ b/doc/snippets/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 file(GLOB snippets_SRCS "*.cpp")
 
 add_custom_target(all_snippets)
diff --git a/doc/snippets/ColPivHouseholderQR_solve.cpp b/doc/snippets/ColPivHouseholderQR_solve.cpp
index eb7d1ff..d93853c 100644
--- a/doc/snippets/ColPivHouseholderQR_solve.cpp
+++ b/doc/snippets/ColPivHouseholderQR_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f m = Matrix3f::Random();
 Matrix3f y = Matrix3f::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/ComplexEigenSolver_compute.cpp b/doc/snippets/ComplexEigenSolver_compute.cpp
index e55409d..7b99898 100644
--- a/doc/snippets/ComplexEigenSolver_compute.cpp
+++ b/doc/snippets/ComplexEigenSolver_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf A = MatrixXcf::Random(4, 4);
 cout << "Here is a random 4x4 matrix, A:" << endl << A << endl << endl;
 
diff --git a/doc/snippets/ComplexEigenSolver_eigenvalues.cpp b/doc/snippets/ComplexEigenSolver_eigenvalues.cpp
index d3bff51..ecbbd7e 100644
--- a/doc/snippets/ComplexEigenSolver_eigenvalues.cpp
+++ b/doc/snippets/ComplexEigenSolver_eigenvalues.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf ones = MatrixXcf::Ones(3, 3);
 ComplexEigenSolver<MatrixXcf> ces(ones, /* computeEigenvectors = */ false);
 cout << "The eigenvalues of the 3x3 matrix of ones are:" << endl << ces.eigenvalues() << endl;
diff --git a/doc/snippets/ComplexEigenSolver_eigenvectors.cpp b/doc/snippets/ComplexEigenSolver_eigenvectors.cpp
index 46aab4a..4afb6e5 100644
--- a/doc/snippets/ComplexEigenSolver_eigenvectors.cpp
+++ b/doc/snippets/ComplexEigenSolver_eigenvectors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf ones = MatrixXcf::Ones(3, 3);
 ComplexEigenSolver<MatrixXcf> ces(ones);
 cout << "The first eigenvector of the 3x3 matrix of ones is:" << endl << ces.eigenvectors().col(0) << endl;
diff --git a/doc/snippets/ComplexSchur_compute.cpp b/doc/snippets/ComplexSchur_compute.cpp
index 53b7f8b..0b0d169 100644
--- a/doc/snippets/ComplexSchur_compute.cpp
+++ b/doc/snippets/ComplexSchur_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf A = MatrixXcf::Random(4, 4);
 ComplexSchur<MatrixXcf> schur(4);
 schur.compute(A);
diff --git a/doc/snippets/ComplexSchur_matrixT.cpp b/doc/snippets/ComplexSchur_matrixT.cpp
index e1033ad..d995b67 100644
--- a/doc/snippets/ComplexSchur_matrixT.cpp
+++ b/doc/snippets/ComplexSchur_matrixT.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf A = MatrixXcf::Random(4, 4);
 cout << "Here is a random 4x4 matrix, A:" << endl << A << endl << endl;
 ComplexSchur<MatrixXcf> schurOfA(A, false);  // false means do not compute U
diff --git a/doc/snippets/ComplexSchur_matrixU.cpp b/doc/snippets/ComplexSchur_matrixU.cpp
index 8138394..fa7fba1 100644
--- a/doc/snippets/ComplexSchur_matrixU.cpp
+++ b/doc/snippets/ComplexSchur_matrixU.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf A = MatrixXcf::Random(4, 4);
 cout << "Here is a random 4x4 matrix, A:" << endl << A << endl << endl;
 ComplexSchur<MatrixXcf> schurOfA(A);
diff --git a/doc/snippets/Cwise_abs.cpp b/doc/snippets/Cwise_abs.cpp
index 744851a..a45b93b 100644
--- a/doc/snippets/Cwise_abs.cpp
+++ b/doc/snippets/Cwise_abs.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, -2, -3);
 cout << v.abs() << endl;
diff --git a/doc/snippets/Cwise_abs2.cpp b/doc/snippets/Cwise_abs2.cpp
index 71e5cb2..4f873aa 100644
--- a/doc/snippets/Cwise_abs2.cpp
+++ b/doc/snippets/Cwise_abs2.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, -2, -3);
 cout << v.abs2() << endl;
diff --git a/doc/snippets/Cwise_acos.cpp b/doc/snippets/Cwise_acos.cpp
index bbbbf52..6fca747 100644
--- a/doc/snippets/Cwise_acos.cpp
+++ b/doc/snippets/Cwise_acos.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(0, sqrt(2.) / 2, 1);
 cout << v.acos() << endl;
diff --git a/doc/snippets/Cwise_arg.cpp b/doc/snippets/Cwise_arg.cpp
index 3f45133..965fd17 100644
--- a/doc/snippets/Cwise_arg.cpp
+++ b/doc/snippets/Cwise_arg.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXcf v = ArrayXcf::Random(3);
 cout << v << endl << endl;
 cout << arg(v) << endl;
diff --git a/doc/snippets/Cwise_array_atan2_array.cpp b/doc/snippets/Cwise_array_atan2_array.cpp
index 5742f9a..2ba7161 100644
--- a/doc/snippets/Cwise_array_atan2_array.cpp
+++ b/doc/snippets/Cwise_array_atan2_array.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array<double, 1, 3> x(8, -25, 3), y(1. / 3., 0.5, -2.);
 cout << "atan2([" << x << "], [" << y << "]) = " << x.atan2(y) << endl;  // using ArrayBase::pow
 cout << "atan2([" << x << "], [" << y << "] = " << atan2(x, y) << endl;  // using Eigen::pow
diff --git a/doc/snippets/Cwise_array_power_array.cpp b/doc/snippets/Cwise_array_power_array.cpp
index ab2d87a..a9d4e61 100644
--- a/doc/snippets/Cwise_array_power_array.cpp
+++ b/doc/snippets/Cwise_array_power_array.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array<double, 1, 3> x(8, 25, 3), e(1. / 3., 0.5, 2.);
 cout << "[" << x << "]^[" << e << "] = " << x.pow(e) << endl;   // using ArrayBase::pow
 cout << "[" << x << "]^[" << e << "] = " << pow(x, e) << endl;  // using Eigen::pow
diff --git a/doc/snippets/Cwise_asin.cpp b/doc/snippets/Cwise_asin.cpp
index 3a64671..232477b 100644
--- a/doc/snippets/Cwise_asin.cpp
+++ b/doc/snippets/Cwise_asin.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(0, sqrt(2.) / 2, 1);
 cout << v.asin() << endl;
diff --git a/doc/snippets/Cwise_atan.cpp b/doc/snippets/Cwise_atan.cpp
index 1b60a9a..537b8f6 100644
--- a/doc/snippets/Cwise_atan.cpp
+++ b/doc/snippets/Cwise_atan.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(5, 0, 1);
 cout << v.atan() << endl;
diff --git a/doc/snippets/Cwise_boolean_and.cpp b/doc/snippets/Cwise_boolean_and.cpp
index 227ac36..21b128d 100644
--- a/doc/snippets/Cwise_boolean_and.cpp
+++ b/doc/snippets/Cwise_boolean_and.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(-1, 2, 1), w(-3, 2, 3);
 cout << ((v < w) && (v < 0)) << endl;
diff --git a/doc/snippets/Cwise_boolean_not.cpp b/doc/snippets/Cwise_boolean_not.cpp
index 404fd94..28bff2b 100644
--- a/doc/snippets/Cwise_boolean_not.cpp
+++ b/doc/snippets/Cwise_boolean_not.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 v(1) *= 0.0 / 0.0;
 v(2) /= 0.0;
diff --git a/doc/snippets/Cwise_boolean_or.cpp b/doc/snippets/Cwise_boolean_or.cpp
index df87f7a..271689b 100644
--- a/doc/snippets/Cwise_boolean_or.cpp
+++ b/doc/snippets/Cwise_boolean_or.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(-1, 2, 1), w(-3, 2, 3);
 cout << ((v < w) || (v < 0)) << endl;
diff --git a/doc/snippets/Cwise_cbrt.cpp b/doc/snippets/Cwise_cbrt.cpp
index b6dcdfc..30cde97 100644
--- a/doc/snippets/Cwise_cbrt.cpp
+++ b/doc/snippets/Cwise_cbrt.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 4);
 cout << v.cbrt() << endl;
diff --git a/doc/snippets/Cwise_ceil.cpp b/doc/snippets/Cwise_ceil.cpp
index 6123891..caec7f9 100644
--- a/doc/snippets/Cwise_ceil.cpp
+++ b/doc/snippets/Cwise_ceil.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(7, -2, 2);
 cout << v << endl << endl;
 cout << ceil(v) << endl;
diff --git a/doc/snippets/Cwise_cos.cpp b/doc/snippets/Cwise_cos.cpp
index 37bb0a5..930d852 100644
--- a/doc/snippets/Cwise_cos.cpp
+++ b/doc/snippets/Cwise_cos.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(EIGEN_PI, EIGEN_PI / 2, EIGEN_PI / 3);
 cout << v.cos() << endl;
diff --git a/doc/snippets/Cwise_cosh.cpp b/doc/snippets/Cwise_cosh.cpp
index 3cd3304..fbbe1d4 100644
--- a/doc/snippets/Cwise_cosh.cpp
+++ b/doc/snippets/Cwise_cosh.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(5, 0, 1);
 cout << cosh(v) << endl;
diff --git a/doc/snippets/Cwise_cube.cpp b/doc/snippets/Cwise_cube.cpp
index 69f4c34..3ace6fa 100644
--- a/doc/snippets/Cwise_cube.cpp
+++ b/doc/snippets/Cwise_cube.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(2, 3, 4);
 cout << v.cube() << endl;
diff --git a/doc/snippets/Cwise_equal_equal.cpp b/doc/snippets/Cwise_equal_equal.cpp
index 7fdeafa..66176b8 100644
--- a/doc/snippets/Cwise_equal_equal.cpp
+++ b/doc/snippets/Cwise_equal_equal.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(3, 2, 1);
 cout << (v == w) << endl;
diff --git a/doc/snippets/Cwise_exp.cpp b/doc/snippets/Cwise_exp.cpp
index 9d65259..0cb3d7f 100644
--- a/doc/snippets/Cwise_exp.cpp
+++ b/doc/snippets/Cwise_exp.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 cout << v.exp() << endl;
diff --git a/doc/snippets/Cwise_floor.cpp b/doc/snippets/Cwise_floor.cpp
index 8f3ec85..ed05de1 100644
--- a/doc/snippets/Cwise_floor.cpp
+++ b/doc/snippets/Cwise_floor.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(7, -2, 2);
 cout << v << endl << endl;
 cout << floor(v) << endl;
diff --git a/doc/snippets/Cwise_greater.cpp b/doc/snippets/Cwise_greater.cpp
index 77d448a..51c5b7c 100644
--- a/doc/snippets/Cwise_greater.cpp
+++ b/doc/snippets/Cwise_greater.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(3, 2, 1);
 cout << (v > w) << endl;
diff --git a/doc/snippets/Cwise_greater_equal.cpp b/doc/snippets/Cwise_greater_equal.cpp
index 8aa94e8..63618a9 100644
--- a/doc/snippets/Cwise_greater_equal.cpp
+++ b/doc/snippets/Cwise_greater_equal.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(3, 2, 1);
 cout << (v >= w) << endl;
diff --git a/doc/snippets/Cwise_inverse.cpp b/doc/snippets/Cwise_inverse.cpp
index 292daef..a31d982 100644
--- a/doc/snippets/Cwise_inverse.cpp
+++ b/doc/snippets/Cwise_inverse.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(2, 3, 4);
 cout << v.inverse() << endl;
diff --git a/doc/snippets/Cwise_isFinite.cpp b/doc/snippets/Cwise_isFinite.cpp
index c3309f2..744cdaf 100644
--- a/doc/snippets/Cwise_isFinite.cpp
+++ b/doc/snippets/Cwise_isFinite.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 v(1) *= 0.0 / 0.0;
 v(2) /= 0.0;
diff --git a/doc/snippets/Cwise_isInf.cpp b/doc/snippets/Cwise_isInf.cpp
index c97b8a6..0a623c5 100644
--- a/doc/snippets/Cwise_isInf.cpp
+++ b/doc/snippets/Cwise_isInf.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 v(1) *= 0.0 / 0.0;
 v(2) /= 0.0;
diff --git a/doc/snippets/Cwise_isNaN.cpp b/doc/snippets/Cwise_isNaN.cpp
index ab2b528..520f457 100644
--- a/doc/snippets/Cwise_isNaN.cpp
+++ b/doc/snippets/Cwise_isNaN.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 v(1) *= 0.0 / 0.0;
 v(2) /= 0.0;
diff --git a/doc/snippets/Cwise_ldexp.cpp b/doc/snippets/Cwise_ldexp.cpp
new file mode 100644
index 0000000..6b93a0c
--- /dev/null
+++ b/doc/snippets/Cwise_ldexp.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+Array4d v(1, 2, 3, 4);
+cout << v.ldexp(-2) << endl;
diff --git a/doc/snippets/Cwise_less.cpp b/doc/snippets/Cwise_less.cpp
index 95ccb30..dacafe7 100644
--- a/doc/snippets/Cwise_less.cpp
+++ b/doc/snippets/Cwise_less.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(3, 2, 1);
 cout << (v < w) << endl;
diff --git a/doc/snippets/Cwise_less_equal.cpp b/doc/snippets/Cwise_less_equal.cpp
index 08d65be..2847286 100644
--- a/doc/snippets/Cwise_less_equal.cpp
+++ b/doc/snippets/Cwise_less_equal.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(3, 2, 1);
 cout << (v <= w) << endl;
diff --git a/doc/snippets/Cwise_log.cpp b/doc/snippets/Cwise_log.cpp
index f3e13d6..275d0d0 100644
--- a/doc/snippets/Cwise_log.cpp
+++ b/doc/snippets/Cwise_log.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 cout << v.log() << endl;
diff --git a/doc/snippets/Cwise_log10.cpp b/doc/snippets/Cwise_log10.cpp
index 8656f48..bc2b1c3 100644
--- a/doc/snippets/Cwise_log10.cpp
+++ b/doc/snippets/Cwise_log10.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array4d v(-1, 0, 1, 2);
 cout << log10(v) << endl;
diff --git a/doc/snippets/Cwise_max.cpp b/doc/snippets/Cwise_max.cpp
index ab8d397..c230650 100644
--- a/doc/snippets/Cwise_max.cpp
+++ b/doc/snippets/Cwise_max.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(2, 3, 4), w(4, 2, 3);
 cout << v.max(w) << endl;
diff --git a/doc/snippets/Cwise_min.cpp b/doc/snippets/Cwise_min.cpp
index 771eaf2..22ecc20 100644
--- a/doc/snippets/Cwise_min.cpp
+++ b/doc/snippets/Cwise_min.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(2, 3, 4), w(4, 2, 3);
 cout << v.min(w) << endl;
diff --git a/doc/snippets/Cwise_minus.cpp b/doc/snippets/Cwise_minus.cpp
index 1389b4a..9c6876d 100644
--- a/doc/snippets/Cwise_minus.cpp
+++ b/doc/snippets/Cwise_minus.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 cout << v - 5 << endl;
diff --git a/doc/snippets/Cwise_minus_equal.cpp b/doc/snippets/Cwise_minus_equal.cpp
index 33433e0..5ec0cef 100644
--- a/doc/snippets/Cwise_minus_equal.cpp
+++ b/doc/snippets/Cwise_minus_equal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 v -= 5;
 cout << v << endl;
diff --git a/doc/snippets/Cwise_not_equal.cpp b/doc/snippets/Cwise_not_equal.cpp
index 60aea2b..3ac90f2 100644
--- a/doc/snippets/Cwise_not_equal.cpp
+++ b/doc/snippets/Cwise_not_equal.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(3, 2, 1);
 cout << (v != w) << endl;
diff --git a/doc/snippets/Cwise_plus.cpp b/doc/snippets/Cwise_plus.cpp
index 7a878d6..f22bf3f 100644
--- a/doc/snippets/Cwise_plus.cpp
+++ b/doc/snippets/Cwise_plus.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 cout << v + 5 << endl;
diff --git a/doc/snippets/Cwise_plus_equal.cpp b/doc/snippets/Cwise_plus_equal.cpp
index 3e00ba2..4d9117d 100644
--- a/doc/snippets/Cwise_plus_equal.cpp
+++ b/doc/snippets/Cwise_plus_equal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3);
 v += 5;
 cout << v << endl;
diff --git a/doc/snippets/Cwise_pow.cpp b/doc/snippets/Cwise_pow.cpp
index 28a9dc5..da62ba1 100644
--- a/doc/snippets/Cwise_pow.cpp
+++ b/doc/snippets/Cwise_pow.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(8, 27, 64);
 cout << v.pow(0.333333) << endl;
diff --git a/doc/snippets/Cwise_product.cpp b/doc/snippets/Cwise_product.cpp
index cee5b20..d614b1c 100644
--- a/doc/snippets/Cwise_product.cpp
+++ b/doc/snippets/Cwise_product.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array33i a = Array33i::Random(), b = Array33i::Random();
 Array33i c = a * b;
 cout << "a:\n" << a << "\nb:\n" << b << "\nc:\n" << c << endl;
diff --git a/doc/snippets/Cwise_quotient.cpp b/doc/snippets/Cwise_quotient.cpp
index ab8b506..04f559c 100644
--- a/doc/snippets/Cwise_quotient.cpp
+++ b/doc/snippets/Cwise_quotient.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(2, 3, 4), w(4, 2, 3);
 cout << v / w << endl;
diff --git a/doc/snippets/Cwise_rint.cpp b/doc/snippets/Cwise_rint.cpp
index eb8bc84..7dda1d9 100644
--- a/doc/snippets/Cwise_rint.cpp
+++ b/doc/snippets/Cwise_rint.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(7, -2, 2);
 cout << v << endl << endl;
 cout << rint(v) << endl;
diff --git a/doc/snippets/Cwise_round.cpp b/doc/snippets/Cwise_round.cpp
index d9ff417..f87ae61 100644
--- a/doc/snippets/Cwise_round.cpp
+++ b/doc/snippets/Cwise_round.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(7, -2, 2);
 cout << v << endl << endl;
 cout << round(v) << endl;
diff --git a/doc/snippets/Cwise_scalar_power_array.cpp b/doc/snippets/Cwise_scalar_power_array.cpp
index 65bb478..8d9c88f 100644
--- a/doc/snippets/Cwise_scalar_power_array.cpp
+++ b/doc/snippets/Cwise_scalar_power_array.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array<double, 1, 3> e(2, -3, 1. / 3.);
 cout << "10^[" << e << "] = " << pow(10, e) << endl;
diff --git a/doc/snippets/Cwise_sign.cpp b/doc/snippets/Cwise_sign.cpp
index 55d24ab..985d928 100644
--- a/doc/snippets/Cwise_sign.cpp
+++ b/doc/snippets/Cwise_sign.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(-3, 5, 0);
 cout << v.sign() << endl;
diff --git a/doc/snippets/Cwise_sin.cpp b/doc/snippets/Cwise_sin.cpp
index 697a188..983fec6 100644
--- a/doc/snippets/Cwise_sin.cpp
+++ b/doc/snippets/Cwise_sin.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(EIGEN_PI, EIGEN_PI / 2, EIGEN_PI / 3);
 cout << v.sin() << endl;
diff --git a/doc/snippets/Cwise_sinh.cpp b/doc/snippets/Cwise_sinh.cpp
index aefcd6d..50ea4b3 100644
--- a/doc/snippets/Cwise_sinh.cpp
+++ b/doc/snippets/Cwise_sinh.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(5, 0, 1);
 cout << sinh(v) << endl;
diff --git a/doc/snippets/Cwise_slash_equal.cpp b/doc/snippets/Cwise_slash_equal.cpp
index cb776b8..6b06b34 100644
--- a/doc/snippets/Cwise_slash_equal.cpp
+++ b/doc/snippets/Cwise_slash_equal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(3, 2, 4), w(5, 4, 2);
 v /= w;
 cout << v << endl;
diff --git a/doc/snippets/Cwise_sqrt.cpp b/doc/snippets/Cwise_sqrt.cpp
index e0e5d36..1f55418 100644
--- a/doc/snippets/Cwise_sqrt.cpp
+++ b/doc/snippets/Cwise_sqrt.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 4);
 cout << v.sqrt() << endl;
diff --git a/doc/snippets/Cwise_square.cpp b/doc/snippets/Cwise_square.cpp
index 2b3132e..6fd4226 100644
--- a/doc/snippets/Cwise_square.cpp
+++ b/doc/snippets/Cwise_square.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(2, 3, 4);
 cout << v.square() << endl;
diff --git a/doc/snippets/Cwise_tan.cpp b/doc/snippets/Cwise_tan.cpp
index ccb85f5..6e26d4f 100644
--- a/doc/snippets/Cwise_tan.cpp
+++ b/doc/snippets/Cwise_tan.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(EIGEN_PI, EIGEN_PI / 2, EIGEN_PI / 3);
 cout << v.tan() << endl;
diff --git a/doc/snippets/Cwise_tanh.cpp b/doc/snippets/Cwise_tanh.cpp
index ae8fea5..467da3a 100644
--- a/doc/snippets/Cwise_tanh.cpp
+++ b/doc/snippets/Cwise_tanh.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(5, 0, 1);
 cout << tanh(v) << endl;
diff --git a/doc/snippets/Cwise_times_equal.cpp b/doc/snippets/Cwise_times_equal.cpp
index 45151be..b5d80d5 100644
--- a/doc/snippets/Cwise_times_equal.cpp
+++ b/doc/snippets/Cwise_times_equal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array3d v(1, 2, 3), w(2, 3, 0);
 v *= w;
 cout << v << endl;
diff --git a/doc/snippets/Cwise_trunc.cpp b/doc/snippets/Cwise_trunc.cpp
index 8fb29c8..e242d42 100644
--- a/doc/snippets/Cwise_trunc.cpp
+++ b/doc/snippets/Cwise_trunc.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXd v = ArrayXd::LinSpaced(7, -2, 2);
 cout << v << endl << endl;
 cout << trunc(v) << endl;
diff --git a/doc/snippets/DenseBase_LinSpaced.cpp b/doc/snippets/DenseBase_LinSpaced.cpp
index a57053f..1cca372 100644
--- a/doc/snippets/DenseBase_LinSpaced.cpp
+++ b/doc/snippets/DenseBase_LinSpaced.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << VectorXi::LinSpaced(4, 7, 10).transpose() << endl;
 cout << VectorXd::LinSpaced(5, 0.0, 1.0).transpose() << endl;
diff --git a/doc/snippets/DenseBase_LinSpacedInt.cpp b/doc/snippets/DenseBase_LinSpacedInt.cpp
index 732d70a..e7031a5 100644
--- a/doc/snippets/DenseBase_LinSpacedInt.cpp
+++ b/doc/snippets/DenseBase_LinSpacedInt.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << "Even spacing inputs:" << endl;
 cout << VectorXi::LinSpaced(8, 1, 4).transpose() << endl;
 cout << VectorXi::LinSpaced(8, 1, 8).transpose() << endl;
diff --git a/doc/snippets/DenseBase_LinSpaced_seq_deprecated.cpp b/doc/snippets/DenseBase_LinSpaced_seq_deprecated.cpp
index 3c4a565..2c1cbe9 100644
--- a/doc/snippets/DenseBase_LinSpaced_seq_deprecated.cpp
+++ b/doc/snippets/DenseBase_LinSpaced_seq_deprecated.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << VectorXi::LinSpaced(Sequential, 4, 7, 10).transpose() << endl;
 cout << VectorXd::LinSpaced(Sequential, 5, 0.0, 1.0).transpose() << endl;
diff --git a/doc/snippets/DenseBase_setLinSpaced.cpp b/doc/snippets/DenseBase_setLinSpaced.cpp
index 6c1eca6..83ef5c8 100644
--- a/doc/snippets/DenseBase_setLinSpaced.cpp
+++ b/doc/snippets/DenseBase_setLinSpaced.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 VectorXf v;
 v.setLinSpaced(5, 0.5f, 1.5f);
 cout << v << endl;
diff --git a/doc/snippets/DirectionWise_hnormalized.cpp b/doc/snippets/DirectionWise_hnormalized.cpp
index 8a46652..0f00845 100644
--- a/doc/snippets/DirectionWise_hnormalized.cpp
+++ b/doc/snippets/DirectionWise_hnormalized.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4Xd M = Matrix4Xd::Random(4, 5);
 Projective3d P(Matrix4d::Random());
 cout << "The matrix M is:" << endl << M << endl << endl;
diff --git a/doc/snippets/DirectionWise_replicate.cpp b/doc/snippets/DirectionWise_replicate.cpp
index c448307..9e3e11f 100644
--- a/doc/snippets/DirectionWise_replicate.cpp
+++ b/doc/snippets/DirectionWise_replicate.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m = MatrixXi::Random(2, 3);
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "m.colwise().replicate<3>() = ..." << endl;
diff --git a/doc/snippets/DirectionWise_replicate_int.cpp b/doc/snippets/DirectionWise_replicate_int.cpp
index f9b1b53..1529177 100644
--- a/doc/snippets/DirectionWise_replicate_int.cpp
+++ b/doc/snippets/DirectionWise_replicate_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3i v = Vector3i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "v.rowwise().replicate(5) = ..." << endl;
diff --git a/doc/snippets/EigenSolver_EigenSolver_MatrixType.cpp b/doc/snippets/EigenSolver_EigenSolver_MatrixType.cpp
index b54425f..dda5527 100644
--- a/doc/snippets/EigenSolver_EigenSolver_MatrixType.cpp
+++ b/doc/snippets/EigenSolver_EigenSolver_MatrixType.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd A = MatrixXd::Random(6, 6);
 cout << "Here is a random 6x6 matrix, A:" << endl << A << endl << endl;
 
diff --git a/doc/snippets/EigenSolver_compute.cpp b/doc/snippets/EigenSolver_compute.cpp
index 6f794ee..d9e29ff 100644
--- a/doc/snippets/EigenSolver_compute.cpp
+++ b/doc/snippets/EigenSolver_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 EigenSolver<MatrixXf> es;
 MatrixXf A = MatrixXf::Random(4, 4);
 es.compute(A, /* computeEigenvectors = */ false);
diff --git a/doc/snippets/EigenSolver_eigenvalues.cpp b/doc/snippets/EigenSolver_eigenvalues.cpp
index 866183c..0a9a7ce 100644
--- a/doc/snippets/EigenSolver_eigenvalues.cpp
+++ b/doc/snippets/EigenSolver_eigenvalues.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 EigenSolver<MatrixXd> es(ones, false);
 cout << "The eigenvalues of the 3x3 matrix of ones are:" << endl << es.eigenvalues() << endl;
diff --git a/doc/snippets/EigenSolver_eigenvectors.cpp b/doc/snippets/EigenSolver_eigenvectors.cpp
index 6d4606d..16fc84f 100644
--- a/doc/snippets/EigenSolver_eigenvectors.cpp
+++ b/doc/snippets/EigenSolver_eigenvectors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 EigenSolver<MatrixXd> es(ones);
 cout << "The first eigenvector of the 3x3 matrix of ones is:" << endl << es.eigenvectors().col(0) << endl;
diff --git a/doc/snippets/EigenSolver_pseudoEigenvectors.cpp b/doc/snippets/EigenSolver_pseudoEigenvectors.cpp
index d9f3698..633d52b 100644
--- a/doc/snippets/EigenSolver_pseudoEigenvectors.cpp
+++ b/doc/snippets/EigenSolver_pseudoEigenvectors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd A = MatrixXd::Random(6, 6);
 cout << "Here is a random 6x6 matrix, A:" << endl << A << endl << endl;
 
diff --git a/doc/snippets/FullPivHouseholderQR_solve.cpp b/doc/snippets/FullPivHouseholderQR_solve.cpp
index 621d1d1..ba48c21 100644
--- a/doc/snippets/FullPivHouseholderQR_solve.cpp
+++ b/doc/snippets/FullPivHouseholderQR_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f m = Matrix3f::Random();
 Matrix3f y = Matrix3f::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/FullPivLU_image.cpp b/doc/snippets/FullPivLU_image.cpp
index a8f664e..8e5ef27 100644
--- a/doc/snippets/FullPivLU_image.cpp
+++ b/doc/snippets/FullPivLU_image.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m;
 m << 1, 1, 0, 1, 3, 2, 0, 1, 1;
 cout << "Here is the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/FullPivLU_kernel.cpp b/doc/snippets/FullPivLU_kernel.cpp
index 448a515..96af748 100644
--- a/doc/snippets/FullPivLU_kernel.cpp
+++ b/doc/snippets/FullPivLU_kernel.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m = MatrixXf::Random(3, 5);
 cout << "Here is the matrix m:" << endl << m << endl;
 MatrixXf ker = m.fullPivLu().kernel();
diff --git a/doc/snippets/FullPivLU_solve.cpp b/doc/snippets/FullPivLU_solve.cpp
index a4ecb83..be277ab 100644
--- a/doc/snippets/FullPivLU_solve.cpp
+++ b/doc/snippets/FullPivLU_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix<float, 2, 3> m = Matrix<float, 2, 3>::Random();
 Matrix2f y = Matrix2f::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/GeneralizedEigenSolver.cpp b/doc/snippets/GeneralizedEigenSolver.cpp
index f7a7254..96d4b93 100644
--- a/doc/snippets/GeneralizedEigenSolver.cpp
+++ b/doc/snippets/GeneralizedEigenSolver.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 GeneralizedEigenSolver<MatrixXf> ges;
 MatrixXf A = MatrixXf::Random(4, 4);
 MatrixXf B = MatrixXf::Random(4, 4);
diff --git a/doc/snippets/HessenbergDecomposition_compute.cpp b/doc/snippets/HessenbergDecomposition_compute.cpp
index 91c015a..8c85116 100644
--- a/doc/snippets/HessenbergDecomposition_compute.cpp
+++ b/doc/snippets/HessenbergDecomposition_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf A = MatrixXcf::Random(4, 4);
 HessenbergDecomposition<MatrixXcf> hd(4);
 hd.compute(A);
diff --git a/doc/snippets/HessenbergDecomposition_matrixH.cpp b/doc/snippets/HessenbergDecomposition_matrixH.cpp
index 1386feb..34000f7 100644
--- a/doc/snippets/HessenbergDecomposition_matrixH.cpp
+++ b/doc/snippets/HessenbergDecomposition_matrixH.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4f A = MatrixXf::Random(4, 4);
 cout << "Here is a random 4x4 matrix:" << endl << A << endl;
 HessenbergDecomposition<MatrixXf> hessOfA(A);
diff --git a/doc/snippets/HessenbergDecomposition_packedMatrix.cpp b/doc/snippets/HessenbergDecomposition_packedMatrix.cpp
index 66c1fd0..82451ce 100644
--- a/doc/snippets/HessenbergDecomposition_packedMatrix.cpp
+++ b/doc/snippets/HessenbergDecomposition_packedMatrix.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4d A = Matrix4d::Random(4, 4);
 cout << "Here is a random 4x4 matrix:" << endl << A << endl;
 HessenbergDecomposition<Matrix4d> hessOfA(A);
diff --git a/doc/snippets/HouseholderQR_householderQ.cpp b/doc/snippets/HouseholderQR_householderQ.cpp
index 6b5cb92..dc53d51 100644
--- a/doc/snippets/HouseholderQR_householderQ.cpp
+++ b/doc/snippets/HouseholderQR_householderQ.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A(MatrixXf::Random(5, 3)), thinQ(MatrixXf::Identity(5, 3)), Q;
 A.setRandom();
 HouseholderQR<MatrixXf> qr(A);
diff --git a/doc/snippets/HouseholderQR_solve.cpp b/doc/snippets/HouseholderQR_solve.cpp
index 35d70ba..84244cd 100644
--- a/doc/snippets/HouseholderQR_solve.cpp
+++ b/doc/snippets/HouseholderQR_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 typedef Matrix<float, 3, 3> Matrix3x3;
 Matrix3x3 m = Matrix3x3::Random();
 Matrix3f y = Matrix3f::Random();
diff --git a/doc/snippets/HouseholderSequence_HouseholderSequence.cpp b/doc/snippets/HouseholderSequence_HouseholderSequence.cpp
index ae088e6..3f21084 100644
--- a/doc/snippets/HouseholderSequence_HouseholderSequence.cpp
+++ b/doc/snippets/HouseholderSequence_HouseholderSequence.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d v = Matrix3d::Random();
 cout << "The matrix v is:" << endl;
 cout << v << endl;
diff --git a/doc/snippets/IOFormat.cpp b/doc/snippets/IOFormat.cpp
index 735f5dd..379c580 100644
--- a/doc/snippets/IOFormat.cpp
+++ b/doc/snippets/IOFormat.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 std::string sep = "\n----------------------------------------\n";
 Matrix3d m1;
 m1 << 1.111111, 2, 3.33333, 4, 5, 6, 7, 8.888888, 9;
diff --git a/doc/snippets/JacobiSVD_basic.cpp b/doc/snippets/JacobiSVD_basic.cpp
index f451727..ebec327 100644
--- a/doc/snippets/JacobiSVD_basic.cpp
+++ b/doc/snippets/JacobiSVD_basic.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m = MatrixXf::Random(3, 2);
 cout << "Here is the matrix m:" << endl << m << endl;
 JacobiSVD<MatrixXf, ComputeThinU | ComputeThinV> svd(m);
diff --git a/doc/snippets/Jacobi_makeGivens.cpp b/doc/snippets/Jacobi_makeGivens.cpp
index 6f8ec05..d31f80e 100644
--- a/doc/snippets/Jacobi_makeGivens.cpp
+++ b/doc/snippets/Jacobi_makeGivens.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector2f v = Vector2f::Random();
 JacobiRotation<float> G;
 G.makeGivens(v.x(), v.y());
diff --git a/doc/snippets/Jacobi_makeJacobi.cpp b/doc/snippets/Jacobi_makeJacobi.cpp
index a86e80a..0db5e59 100644
--- a/doc/snippets/Jacobi_makeJacobi.cpp
+++ b/doc/snippets/Jacobi_makeJacobi.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2f m = Matrix2f::Random();
 m = (m + m.adjoint()).eval();
 JacobiRotation<float> J;
diff --git a/doc/snippets/LLT_example.cpp b/doc/snippets/LLT_example.cpp
index c464ac9..6b14e38 100644
--- a/doc/snippets/LLT_example.cpp
+++ b/doc/snippets/LLT_example.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd A(3, 3);
 A << 4, -1, 2, -1, 6, 0, 2, 0, 5;
 cout << "The matrix A is" << endl << A << endl;
diff --git a/doc/snippets/LLT_solve.cpp b/doc/snippets/LLT_solve.cpp
index 52659ab..137375b 100644
--- a/doc/snippets/LLT_solve.cpp
+++ b/doc/snippets/LLT_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 typedef Matrix<float, Dynamic, 2> DataMatrix;
 // let's generate some samples on the 3D plane of equation z = 2x+3y (with some noise)
 DataMatrix samples = DataMatrix::Random(12, 2);
diff --git a/doc/snippets/LeastSquaresCOD.cpp b/doc/snippets/LeastSquaresCOD.cpp
new file mode 100644
index 0000000..943db1d
--- /dev/null
+++ b/doc/snippets/LeastSquaresCOD.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+MatrixXf A = MatrixXf::Random(3, 2);
+VectorXf b = VectorXf::Random(3);
+cout << "The solution using the COD is:\n" << A.completeOrthogonalDecomposition().solve(b) << endl;
diff --git a/doc/snippets/LeastSquaresNormalEquations.cpp b/doc/snippets/LeastSquaresNormalEquations.cpp
index 00434f7..f949891 100644
--- a/doc/snippets/LeastSquaresNormalEquations.cpp
+++ b/doc/snippets/LeastSquaresNormalEquations.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A = MatrixXf::Random(3, 2);
 VectorXf b = VectorXf::Random(3);
 cout << "The solution using normal equations is:\n" << (A.transpose() * A).ldlt().solve(A.transpose() * b) << endl;
diff --git a/doc/snippets/LeastSquaresQR.cpp b/doc/snippets/LeastSquaresQR.cpp
index 9f8f723..0bee0f6 100644
--- a/doc/snippets/LeastSquaresQR.cpp
+++ b/doc/snippets/LeastSquaresQR.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A = MatrixXf::Random(3, 2);
 VectorXf b = VectorXf::Random(3);
 cout << "The solution using the QR decomposition is:\n" << A.colPivHouseholderQr().solve(b) << endl;
diff --git a/doc/snippets/Map_general_stride.cpp b/doc/snippets/Map_general_stride.cpp
index e2677ff..abd2c3f 100644
--- a/doc/snippets/Map_general_stride.cpp
+++ b/doc/snippets/Map_general_stride.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int array[24];
 for (int i = 0; i < 24; ++i) array[i] = i;
 cout << Map<MatrixXi, 0, Stride<Dynamic, 2> >(array, 3, 3, Stride<Dynamic, 2>(8, 2)) << endl;
diff --git a/doc/snippets/Map_inner_stride.cpp b/doc/snippets/Map_inner_stride.cpp
index f315756..6f9e650 100644
--- a/doc/snippets/Map_inner_stride.cpp
+++ b/doc/snippets/Map_inner_stride.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int array[12];
 for (int i = 0; i < 12; ++i) array[i] = i;
 cout << Map<VectorXi, 0, InnerStride<2> >(array, 6)  // the inner stride has already been passed as template parameter
diff --git a/doc/snippets/Map_outer_stride.cpp b/doc/snippets/Map_outer_stride.cpp
index 75b1655..2629eb9 100644
--- a/doc/snippets/Map_outer_stride.cpp
+++ b/doc/snippets/Map_outer_stride.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int array[12];
 for (int i = 0; i < 12; ++i) array[i] = i;
 cout << Map<MatrixXi, 0, OuterStride<> >(array, 3, 3, OuterStride<>(4)) << endl;
diff --git a/doc/snippets/Map_placement_new.cpp b/doc/snippets/Map_placement_new.cpp
index eb5213d..3cd37e2 100644
--- a/doc/snippets/Map_placement_new.cpp
+++ b/doc/snippets/Map_placement_new.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 Map<RowVectorXi> v(data, 4);
 cout << "The mapped vector v is: " << v << "\n";
diff --git a/doc/snippets/Map_simple.cpp b/doc/snippets/Map_simple.cpp
index 3e8fa81..541d529 100644
--- a/doc/snippets/Map_simple.cpp
+++ b/doc/snippets/Map_simple.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int array[9];
 for (int i = 0; i < 9; ++i) array[i] = i;
 cout << Map<Matrix3i>(array) << endl;
diff --git a/doc/snippets/MatrixBase_adjoint.cpp b/doc/snippets/MatrixBase_adjoint.cpp
index 4680d59..74def23 100644
--- a/doc/snippets/MatrixBase_adjoint.cpp
+++ b/doc/snippets/MatrixBase_adjoint.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2cf m = Matrix2cf::Random();
 cout << "Here is the 2x2 complex matrix m:" << endl << m << endl;
 cout << "Here is the adjoint of m:" << endl << m.adjoint() << endl;
diff --git a/doc/snippets/MatrixBase_all.cpp b/doc/snippets/MatrixBase_all.cpp
index f31d10c..371fcc9 100644
--- a/doc/snippets/MatrixBase_all.cpp
+++ b/doc/snippets/MatrixBase_all.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3f boxMin(Vector3f::Zero()), boxMax(Vector3f::Ones());
 Vector3f p0 = Vector3f::Random(), p1 = Vector3f::Random().cwiseAbs();
 // let's check if p0 and p1 are inside the axis aligned box defined by the corners boxMin,boxMax:
diff --git a/doc/snippets/MatrixBase_applyOnTheLeft.cpp b/doc/snippets/MatrixBase_applyOnTheLeft.cpp
index 00676a3..26d402e 100644
--- a/doc/snippets/MatrixBase_applyOnTheLeft.cpp
+++ b/doc/snippets/MatrixBase_applyOnTheLeft.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A = Matrix3f::Random(3, 3), B;
 B << 0, 1, 0, 0, 0, 1, 1, 0, 0;
 cout << "At start, A = " << endl << A << endl;
diff --git a/doc/snippets/MatrixBase_applyOnTheRight.cpp b/doc/snippets/MatrixBase_applyOnTheRight.cpp
index a1008c6..1d25b78 100644
--- a/doc/snippets/MatrixBase_applyOnTheRight.cpp
+++ b/doc/snippets/MatrixBase_applyOnTheRight.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A = Matrix3f::Random(3, 3), B;
 B << 0, 1, 0, 0, 0, 1, 1, 0, 0;
 cout << "At start, A = " << endl << A << endl;
diff --git a/doc/snippets/MatrixBase_array.cpp b/doc/snippets/MatrixBase_array.cpp
index 456d1d6..dfbb047 100644
--- a/doc/snippets/MatrixBase_array.cpp
+++ b/doc/snippets/MatrixBase_array.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(1, 2, 3);
 v.array() += 3;
 v.array() -= 2;
diff --git a/doc/snippets/MatrixBase_array_const.cpp b/doc/snippets/MatrixBase_array_const.cpp
index e662f6c..235022c 100644
--- a/doc/snippets/MatrixBase_array_const.cpp
+++ b/doc/snippets/MatrixBase_array_const.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(-1, 2, -3);
 cout << "the absolute values:" << endl << v.array().abs() << endl;
 cout << "the absolute values plus one:" << endl << v.array().abs() + 1 << endl;
diff --git a/doc/snippets/MatrixBase_asDiagonal.cpp b/doc/snippets/MatrixBase_asDiagonal.cpp
index 637e95b..1fefa51 100644
--- a/doc/snippets/MatrixBase_asDiagonal.cpp
+++ b/doc/snippets/MatrixBase_asDiagonal.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << Matrix3i(Vector3i(2, 5, 6).asDiagonal()) << endl;
diff --git a/doc/snippets/MatrixBase_block_int_int.cpp b/doc/snippets/MatrixBase_block_int_int.cpp
index ade73ee..b457b1f 100644
--- a/doc/snippets/MatrixBase_block_int_int.cpp
+++ b/doc/snippets/MatrixBase_block_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.block<2,2>(1,1):" << endl << m.block<2, 2>(1, 1) << endl;
diff --git a/doc/snippets/MatrixBase_block_int_int_int_int.cpp b/doc/snippets/MatrixBase_block_int_int_int_int.cpp
index 7238cbb..96eb584 100644
--- a/doc/snippets/MatrixBase_block_int_int_int_int.cpp
+++ b/doc/snippets/MatrixBase_block_int_int_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.block(1, 1, 2, 2):" << endl << m.block(1, 1, 2, 2) << endl;
diff --git a/doc/snippets/MatrixBase_bottomLeftCorner_int_int.cpp b/doc/snippets/MatrixBase_bottomLeftCorner_int_int.cpp
index ebae95e..67ae4bb 100644
--- a/doc/snippets/MatrixBase_bottomLeftCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_bottomLeftCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.bottomLeftCorner(2, 2):" << endl;
diff --git a/doc/snippets/MatrixBase_bottomRightCorner_int_int.cpp b/doc/snippets/MatrixBase_bottomRightCorner_int_int.cpp
index bf05093..4a475e8 100644
--- a/doc/snippets/MatrixBase_bottomRightCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_bottomRightCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.bottomRightCorner(2, 2):" << endl;
diff --git a/doc/snippets/MatrixBase_bottomRows_int.cpp b/doc/snippets/MatrixBase_bottomRows_int.cpp
index 47ca92e..332dbd1 100644
--- a/doc/snippets/MatrixBase_bottomRows_int.cpp
+++ b/doc/snippets/MatrixBase_bottomRows_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.bottomRows(2):" << endl;
diff --git a/doc/snippets/MatrixBase_cast.cpp b/doc/snippets/MatrixBase_cast.cpp
index 016880b..3939f73 100644
--- a/doc/snippets/MatrixBase_cast.cpp
+++ b/doc/snippets/MatrixBase_cast.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2d md = Matrix2d::Identity() * 0.45;
 Matrix2f mf = Matrix2f::Identity();
 cout << md + mf.cast<double>() << endl;
diff --git a/doc/snippets/MatrixBase_col.cpp b/doc/snippets/MatrixBase_col.cpp
index cf0241e..613cc6a 100644
--- a/doc/snippets/MatrixBase_col.cpp
+++ b/doc/snippets/MatrixBase_col.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Identity();
 m.col(1) = Vector3d(4, 5, 6);
 cout << m << endl;
diff --git a/doc/snippets/MatrixBase_colwise.cpp b/doc/snippets/MatrixBase_colwise.cpp
index a31033d..b47564c 100644
--- a/doc/snippets/MatrixBase_colwise.cpp
+++ b/doc/snippets/MatrixBase_colwise.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the sum of each column:" << endl << m.colwise().sum() << endl;
diff --git a/doc/snippets/MatrixBase_colwise_iterator.cpp b/doc/snippets/MatrixBase_colwise_iterator.cpp
new file mode 100644
index 0000000..3a3de98
--- /dev/null
+++ b/doc/snippets/MatrixBase_colwise_iterator.cpp
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+Matrix3i m = Matrix3i::Random();
+cout << "Here is the initial matrix m:" << endl << m << endl;
+int i = -1;
+for (auto c : m.colwise()) {
+  c *= i;
+  ++i;
+}
+cout << "Here is the matrix m after the for-range-loop:" << endl << m << endl;
+auto cols = m.colwise();
+auto it = std::find_if(cols.cbegin(), cols.cend(), [](Matrix3i::ConstColXpr x) { return x.squaredNorm() == 0; });
+cout << "The first empty column is: " << distance(cols.cbegin(), it) << endl;
diff --git a/doc/snippets/MatrixBase_colwise_iterator_cxx11.cpp b/doc/snippets/MatrixBase_colwise_iterator_cxx11.cpp
deleted file mode 100644
index c033043..0000000
--- a/doc/snippets/MatrixBase_colwise_iterator_cxx11.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-Matrix3i m = Matrix3i::Random();
-cout << "Here is the initial matrix m:" << endl << m << endl;
-int i = -1;
-for (auto c : m.colwise()) {
-  c *= i;
-  ++i;
-}
-cout << "Here is the matrix m after the for-range-loop:" << endl << m << endl;
-auto cols = m.colwise();
-auto it = std::find_if(cols.cbegin(), cols.cend(), [](Matrix3i::ConstColXpr x) { return x.squaredNorm() == 0; });
-cout << "The first empty column is: " << distance(cols.cbegin(), it) << endl;
diff --git a/doc/snippets/MatrixBase_computeInverseAndDetWithCheck.cpp b/doc/snippets/MatrixBase_computeInverseAndDetWithCheck.cpp
index 774d4d4..ea7417d 100644
--- a/doc/snippets/MatrixBase_computeInverseAndDetWithCheck.cpp
+++ b/doc/snippets/MatrixBase_computeInverseAndDetWithCheck.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 Matrix3d inverse;
diff --git a/doc/snippets/MatrixBase_computeInverseWithCheck.cpp b/doc/snippets/MatrixBase_computeInverseWithCheck.cpp
index 7c95100..1db4cfd 100644
--- a/doc/snippets/MatrixBase_computeInverseWithCheck.cpp
+++ b/doc/snippets/MatrixBase_computeInverseWithCheck.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 Matrix3d inverse;
diff --git a/doc/snippets/MatrixBase_cwiseAbs.cpp b/doc/snippets/MatrixBase_cwiseAbs.cpp
index e424190..f107315 100644
--- a/doc/snippets/MatrixBase_cwiseAbs.cpp
+++ b/doc/snippets/MatrixBase_cwiseAbs.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(2, 3);
 m << 2, -4, 6, -5, 1, 0;
 cout << m.cwiseAbs() << endl;
diff --git a/doc/snippets/MatrixBase_cwiseAbs2.cpp b/doc/snippets/MatrixBase_cwiseAbs2.cpp
index 952ba9d..55ef4bb 100644
--- a/doc/snippets/MatrixBase_cwiseAbs2.cpp
+++ b/doc/snippets/MatrixBase_cwiseAbs2.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(2, 3);
 m << 2, -4, 6, -5, 1, 0;
 cout << m.cwiseAbs2() << endl;
diff --git a/doc/snippets/MatrixBase_cwiseArg.cpp b/doc/snippets/MatrixBase_cwiseArg.cpp
index e0857cf..9c32d7a 100644
--- a/doc/snippets/MatrixBase_cwiseArg.cpp
+++ b/doc/snippets/MatrixBase_cwiseArg.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf v = MatrixXcf::Random(2, 3);
 cout << v << endl << endl;
 cout << v.cwiseArg() << endl;
\ No newline at end of file
diff --git a/doc/snippets/MatrixBase_cwiseEqual.cpp b/doc/snippets/MatrixBase_cwiseEqual.cpp
index dae553c..735f9db 100644
--- a/doc/snippets/MatrixBase_cwiseEqual.cpp
+++ b/doc/snippets/MatrixBase_cwiseEqual.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m(2, 2);
 m << 1, 0, 1, 1;
 cout << "Comparing m with identity matrix:" << endl;
diff --git a/doc/snippets/MatrixBase_cwiseInverse.cpp b/doc/snippets/MatrixBase_cwiseInverse.cpp
index 74551cb..b076fd4 100644
--- a/doc/snippets/MatrixBase_cwiseInverse.cpp
+++ b/doc/snippets/MatrixBase_cwiseInverse.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(2, 3);
 m << 2, 0.5, 1, 3, 0.25, 1;
 cout << m.cwiseInverse() << endl;
diff --git a/doc/snippets/MatrixBase_cwiseMax.cpp b/doc/snippets/MatrixBase_cwiseMax.cpp
index cd613b5..2e483b6 100644
--- a/doc/snippets/MatrixBase_cwiseMax.cpp
+++ b/doc/snippets/MatrixBase_cwiseMax.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(2, 3, 4), w(4, 2, 3);
 cout << v.cwiseMax(w) << endl;
diff --git a/doc/snippets/MatrixBase_cwiseMin.cpp b/doc/snippets/MatrixBase_cwiseMin.cpp
index 6fa93f3..42bf0ee 100644
--- a/doc/snippets/MatrixBase_cwiseMin.cpp
+++ b/doc/snippets/MatrixBase_cwiseMin.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(2, 3, 4), w(4, 2, 3);
 cout << v.cwiseMin(w) << endl;
diff --git a/doc/snippets/MatrixBase_cwiseNotEqual.cpp b/doc/snippets/MatrixBase_cwiseNotEqual.cpp
index 1a3ec73..a408bf9 100644
--- a/doc/snippets/MatrixBase_cwiseNotEqual.cpp
+++ b/doc/snippets/MatrixBase_cwiseNotEqual.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m(2, 2);
 m << 1, 0, 1, 1;
 cout << "Comparing m with identity matrix:" << endl;
diff --git a/doc/snippets/MatrixBase_cwiseProduct.cpp b/doc/snippets/MatrixBase_cwiseProduct.cpp
index 79540a9..adfb54a 100644
--- a/doc/snippets/MatrixBase_cwiseProduct.cpp
+++ b/doc/snippets/MatrixBase_cwiseProduct.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3i a = Matrix3i::Random(), b = Matrix3i::Random();
 Matrix3i c = a.cwiseProduct(b);
 cout << "a:\n" << a << "\nb:\n" << b << "\nc:\n" << c << endl;
diff --git a/doc/snippets/MatrixBase_cwiseQuotient.cpp b/doc/snippets/MatrixBase_cwiseQuotient.cpp
index c78110f..96a2659 100644
--- a/doc/snippets/MatrixBase_cwiseQuotient.cpp
+++ b/doc/snippets/MatrixBase_cwiseQuotient.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(2, 3, 4), w(4, 2, 3);
 cout << v.cwiseQuotient(w) << endl;
diff --git a/doc/snippets/MatrixBase_cwiseSign.cpp b/doc/snippets/MatrixBase_cwiseSign.cpp
index c2ee94d..a0b568a 100644
--- a/doc/snippets/MatrixBase_cwiseSign.cpp
+++ b/doc/snippets/MatrixBase_cwiseSign.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(2, 3);
 m << 2, -4, 6, -5, 1, 0;
 cout << m.cwiseSign() << endl;
diff --git a/doc/snippets/MatrixBase_cwiseSqrt.cpp b/doc/snippets/MatrixBase_cwiseSqrt.cpp
index 5bfb5f3..3d1a205 100644
--- a/doc/snippets/MatrixBase_cwiseSqrt.cpp
+++ b/doc/snippets/MatrixBase_cwiseSqrt.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(1, 2, 4);
 cout << v.cwiseSqrt() << endl;
diff --git a/doc/snippets/MatrixBase_diagonal.cpp b/doc/snippets/MatrixBase_diagonal.cpp
index c15dcf1..9af7fad 100644
--- a/doc/snippets/MatrixBase_diagonal.cpp
+++ b/doc/snippets/MatrixBase_diagonal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3i m = Matrix3i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here are the coefficients on the main diagonal of m:" << endl << m.diagonal() << endl;
diff --git a/doc/snippets/MatrixBase_diagonalView.cpp b/doc/snippets/MatrixBase_diagonalView.cpp
index 4fbf719..5396f27 100644
--- a/doc/snippets/MatrixBase_diagonalView.cpp
+++ b/doc/snippets/MatrixBase_diagonalView.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m;
 m << 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9;
 cout << "Here's the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/MatrixBase_diagonal_int.cpp b/doc/snippets/MatrixBase_diagonal_int.cpp
index 7b66abf..621235e 100644
--- a/doc/snippets/MatrixBase_diagonal_int.cpp
+++ b/doc/snippets/MatrixBase_diagonal_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here are the coefficients on the 1st super-diagonal and 2nd sub-diagonal of m:" << endl
diff --git a/doc/snippets/MatrixBase_diagonal_template_int.cpp b/doc/snippets/MatrixBase_diagonal_template_int.cpp
index 0e73d1c..f02bc79 100644
--- a/doc/snippets/MatrixBase_diagonal_template_int.cpp
+++ b/doc/snippets/MatrixBase_diagonal_template_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here are the coefficients on the 1st super-diagonal and 2nd sub-diagonal of m:" << endl
diff --git a/doc/snippets/MatrixBase_eigenvalues.cpp b/doc/snippets/MatrixBase_eigenvalues.cpp
index 010f45d..0821da4 100644
--- a/doc/snippets/MatrixBase_eigenvalues.cpp
+++ b/doc/snippets/MatrixBase_eigenvalues.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 VectorXcd eivals = ones.eigenvalues();
 cout << "The eigenvalues of the 3x3 matrix of ones are:" << endl << eivals << endl;
diff --git a/doc/snippets/MatrixBase_end_int.cpp b/doc/snippets/MatrixBase_end_int.cpp
index 03c54a9..df43618 100644
--- a/doc/snippets/MatrixBase_end_int.cpp
+++ b/doc/snippets/MatrixBase_end_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVector4i v = RowVector4i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "Here is v.tail(2):" << endl << v.tail(2) << endl;
diff --git a/doc/snippets/MatrixBase_eval.cpp b/doc/snippets/MatrixBase_eval.cpp
index 1df3aa0..d89f1a3 100644
--- a/doc/snippets/MatrixBase_eval.cpp
+++ b/doc/snippets/MatrixBase_eval.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2f M = Matrix2f::Random();
 Matrix2f m;
 m = M;
diff --git a/doc/snippets/MatrixBase_fixedBlock_int_int.cpp b/doc/snippets/MatrixBase_fixedBlock_int_int.cpp
index 6a3a8cb..caba6f5 100644
--- a/doc/snippets/MatrixBase_fixedBlock_int_int.cpp
+++ b/doc/snippets/MatrixBase_fixedBlock_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4d m = Vector4d(1, 2, 3, 4).asDiagonal();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.fixed<2, 2>(2, 2):" << endl << m.block<2, 2>(2, 2) << endl;
diff --git a/doc/snippets/MatrixBase_hnormalized.cpp b/doc/snippets/MatrixBase_hnormalized.cpp
index 23334ac..7edc73a 100644
--- a/doc/snippets/MatrixBase_hnormalized.cpp
+++ b/doc/snippets/MatrixBase_hnormalized.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector4d v = Vector4d::Random();
 Projective3d P(Matrix4d::Random());
 cout << "v                   = " << v.transpose() << "]^T" << endl;
diff --git a/doc/snippets/MatrixBase_homogeneous.cpp b/doc/snippets/MatrixBase_homogeneous.cpp
index ead1796..96ccf75 100644
--- a/doc/snippets/MatrixBase_homogeneous.cpp
+++ b/doc/snippets/MatrixBase_homogeneous.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v = Vector3d::Random();
 Projective3d P(Matrix4d::Random());
 cout << "v                                   = [" << v.transpose() << "]^T" << endl;
diff --git a/doc/snippets/MatrixBase_identity.cpp b/doc/snippets/MatrixBase_identity.cpp
index b5c1e59..c17728b 100644
--- a/doc/snippets/MatrixBase_identity.cpp
+++ b/doc/snippets/MatrixBase_identity.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << Matrix<double, 3, 4>::Identity() << endl;
diff --git a/doc/snippets/MatrixBase_identity_int_int.cpp b/doc/snippets/MatrixBase_identity_int_int.cpp
index 918649d..f809df7 100644
--- a/doc/snippets/MatrixBase_identity_int_int.cpp
+++ b/doc/snippets/MatrixBase_identity_int_int.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << MatrixXd::Identity(4, 3) << endl;
diff --git a/doc/snippets/MatrixBase_inverse.cpp b/doc/snippets/MatrixBase_inverse.cpp
index a56142e..4d8c6be 100644
--- a/doc/snippets/MatrixBase_inverse.cpp
+++ b/doc/snippets/MatrixBase_inverse.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Its inverse is:" << endl << m.inverse() << endl;
diff --git a/doc/snippets/MatrixBase_isDiagonal.cpp b/doc/snippets/MatrixBase_isDiagonal.cpp
index 290654f..512757e 100644
--- a/doc/snippets/MatrixBase_isDiagonal.cpp
+++ b/doc/snippets/MatrixBase_isDiagonal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = 10000 * Matrix3d::Identity();
 m(0, 2) = 1;
 cout << "Here's the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/MatrixBase_isIdentity.cpp b/doc/snippets/MatrixBase_isIdentity.cpp
index ea535c7..cfdc74b 100644
--- a/doc/snippets/MatrixBase_isIdentity.cpp
+++ b/doc/snippets/MatrixBase_isIdentity.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Identity();
 m(0, 2) = 1e-4;
 cout << "Here's the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/MatrixBase_isOnes.cpp b/doc/snippets/MatrixBase_isOnes.cpp
index 899230a..18f777c 100644
--- a/doc/snippets/MatrixBase_isOnes.cpp
+++ b/doc/snippets/MatrixBase_isOnes.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Ones();
 m(0, 2) += 1e-4;
 cout << "Here's the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/MatrixBase_isOrthogonal.cpp b/doc/snippets/MatrixBase_isOrthogonal.cpp
index 3e079b4..95236d2 100644
--- a/doc/snippets/MatrixBase_isOrthogonal.cpp
+++ b/doc/snippets/MatrixBase_isOrthogonal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3d v(1, 0, 0);
 Vector3d w(1e-4, 0, 1);
 cout << "Here's the vector v:" << endl << v << endl;
diff --git a/doc/snippets/MatrixBase_isUnitary.cpp b/doc/snippets/MatrixBase_isUnitary.cpp
index 56f1b96..c636738 100644
--- a/doc/snippets/MatrixBase_isUnitary.cpp
+++ b/doc/snippets/MatrixBase_isUnitary.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Identity();
 m(0, 2) = 1e-4;
 cout << "Here's the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/MatrixBase_isZero.cpp b/doc/snippets/MatrixBase_isZero.cpp
index c878f1c..860fcf4 100644
--- a/doc/snippets/MatrixBase_isZero.cpp
+++ b/doc/snippets/MatrixBase_isZero.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Zero();
 m(0, 2) = 1e-4;
 cout << "Here's the matrix m:" << endl << m << endl;
diff --git a/doc/snippets/MatrixBase_leftCols_int.cpp b/doc/snippets/MatrixBase_leftCols_int.cpp
index 6ea984e..39e8140 100644
--- a/doc/snippets/MatrixBase_leftCols_int.cpp
+++ b/doc/snippets/MatrixBase_leftCols_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.leftCols(2):" << endl;
diff --git a/doc/snippets/MatrixBase_noalias.cpp b/doc/snippets/MatrixBase_noalias.cpp
index 607d3d5..f7837f6 100644
--- a/doc/snippets/MatrixBase_noalias.cpp
+++ b/doc/snippets/MatrixBase_noalias.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2d a, b, c;
 a << 1, 2, 3, 4;
 b << 5, 6, 7, 8;
diff --git a/doc/snippets/MatrixBase_ones.cpp b/doc/snippets/MatrixBase_ones.cpp
index 02c767c..0739188 100644
--- a/doc/snippets/MatrixBase_ones.cpp
+++ b/doc/snippets/MatrixBase_ones.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << Matrix2d::Ones() << endl;
 cout << 6 * RowVector4i::Ones() << endl;
diff --git a/doc/snippets/MatrixBase_ones_int.cpp b/doc/snippets/MatrixBase_ones_int.cpp
index 2ef188e..8a6d441 100644
--- a/doc/snippets/MatrixBase_ones_int.cpp
+++ b/doc/snippets/MatrixBase_ones_int.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << 6 * RowVectorXi::Ones(4) << endl;
 cout << VectorXf::Ones(2) << endl;
diff --git a/doc/snippets/MatrixBase_ones_int_int.cpp b/doc/snippets/MatrixBase_ones_int_int.cpp
index 38bd8cf..4e82968 100644
--- a/doc/snippets/MatrixBase_ones_int_int.cpp
+++ b/doc/snippets/MatrixBase_ones_int_int.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << MatrixXi::Ones(2, 3) << endl;
diff --git a/doc/snippets/MatrixBase_operatorNorm.cpp b/doc/snippets/MatrixBase_operatorNorm.cpp
index 99ca14d..599e4b0 100644
--- a/doc/snippets/MatrixBase_operatorNorm.cpp
+++ b/doc/snippets/MatrixBase_operatorNorm.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 cout << "The operator norm of the 3x3 matrix of ones is " << ones.operatorNorm() << endl;
diff --git a/doc/snippets/MatrixBase_prod.cpp b/doc/snippets/MatrixBase_prod.cpp
index d2f27bd..9f4a7bc 100644
--- a/doc/snippets/MatrixBase_prod.cpp
+++ b/doc/snippets/MatrixBase_prod.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the product of all the coefficients:" << endl << m.prod() << endl;
diff --git a/doc/snippets/MatrixBase_random.cpp b/doc/snippets/MatrixBase_random.cpp
index 65fc524..771c3d6 100644
--- a/doc/snippets/MatrixBase_random.cpp
+++ b/doc/snippets/MatrixBase_random.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << 100 * Matrix2i::Random() << endl;
diff --git a/doc/snippets/MatrixBase_random_int.cpp b/doc/snippets/MatrixBase_random_int.cpp
index f161d03..bfd3e6b 100644
--- a/doc/snippets/MatrixBase_random_int.cpp
+++ b/doc/snippets/MatrixBase_random_int.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << VectorXi::Random(2) << endl;
diff --git a/doc/snippets/MatrixBase_random_int_int.cpp b/doc/snippets/MatrixBase_random_int_int.cpp
index 92f87c8..20255b5 100644
--- a/doc/snippets/MatrixBase_random_int_int.cpp
+++ b/doc/snippets/MatrixBase_random_int_int.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << MatrixXi::Random(2, 3) << endl;
diff --git a/doc/snippets/MatrixBase_replicate.cpp b/doc/snippets/MatrixBase_replicate.cpp
index bffd102..c29147b 100644
--- a/doc/snippets/MatrixBase_replicate.cpp
+++ b/doc/snippets/MatrixBase_replicate.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m = MatrixXi::Random(2, 3);
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "m.replicate<3,2>() = ..." << endl;
diff --git a/doc/snippets/MatrixBase_replicate_int_int.cpp b/doc/snippets/MatrixBase_replicate_int_int.cpp
index 1aee265..cfa180d 100644
--- a/doc/snippets/MatrixBase_replicate_int_int.cpp
+++ b/doc/snippets/MatrixBase_replicate_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Vector3i v = Vector3i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "v.replicate(2,5) = ..." << endl;
diff --git a/doc/snippets/MatrixBase_reshaped_auto.cpp b/doc/snippets/MatrixBase_reshaped_auto.cpp
index 59f9d3f..309f5df 100644
--- a/doc/snippets/MatrixBase_reshaped_auto.cpp
+++ b/doc/snippets/MatrixBase_reshaped_auto.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.reshaped(2, AutoSize):" << endl << m.reshaped(2, AutoSize) << endl;
diff --git a/doc/snippets/MatrixBase_reshaped_fixed.cpp b/doc/snippets/MatrixBase_reshaped_fixed.cpp
index c1ae2c0..6110516 100644
--- a/doc/snippets/MatrixBase_reshaped_fixed.cpp
+++ b/doc/snippets/MatrixBase_reshaped_fixed.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.reshaped(fix<2>,fix<8>):" << endl << m.reshaped(fix<2>, fix<8>) << endl;
diff --git a/doc/snippets/MatrixBase_reshaped_int_int.cpp b/doc/snippets/MatrixBase_reshaped_int_int.cpp
index af4ca59..cb63ff7 100644
--- a/doc/snippets/MatrixBase_reshaped_int_int.cpp
+++ b/doc/snippets/MatrixBase_reshaped_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.reshaped(2, 8):" << endl << m.reshaped(2, 8) << endl;
diff --git a/doc/snippets/MatrixBase_reshaped_to_vector.cpp b/doc/snippets/MatrixBase_reshaped_to_vector.cpp
index 37f65f7..be661af 100644
--- a/doc/snippets/MatrixBase_reshaped_to_vector.cpp
+++ b/doc/snippets/MatrixBase_reshaped_to_vector.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.reshaped().transpose():" << endl << m.reshaped().transpose() << endl;
diff --git a/doc/snippets/MatrixBase_reverse.cpp b/doc/snippets/MatrixBase_reverse.cpp
index ca12558..865d46a 100644
--- a/doc/snippets/MatrixBase_reverse.cpp
+++ b/doc/snippets/MatrixBase_reverse.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m = MatrixXi::Random(3, 4);
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the reverse of m:" << endl << m.reverse() << endl;
diff --git a/doc/snippets/MatrixBase_rightCols_int.cpp b/doc/snippets/MatrixBase_rightCols_int.cpp
index cb51340..c4ff3a4 100644
--- a/doc/snippets/MatrixBase_rightCols_int.cpp
+++ b/doc/snippets/MatrixBase_rightCols_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.rightCols(2):" << endl;
diff --git a/doc/snippets/MatrixBase_row.cpp b/doc/snippets/MatrixBase_row.cpp
index 481bff8..5af667a 100644
--- a/doc/snippets/MatrixBase_row.cpp
+++ b/doc/snippets/MatrixBase_row.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Identity();
 m.row(1) = Vector3d(4, 5, 6);
 cout << m << endl;
diff --git a/doc/snippets/MatrixBase_rowwise.cpp b/doc/snippets/MatrixBase_rowwise.cpp
index b869224..8f26de6 100644
--- a/doc/snippets/MatrixBase_rowwise.cpp
+++ b/doc/snippets/MatrixBase_rowwise.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the sum of each row:" << endl << m.rowwise().sum() << endl;
diff --git a/doc/snippets/MatrixBase_segment_int_int.cpp b/doc/snippets/MatrixBase_segment_int_int.cpp
index 70cd6d2..ae74550 100644
--- a/doc/snippets/MatrixBase_segment_int_int.cpp
+++ b/doc/snippets/MatrixBase_segment_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVector4i v = RowVector4i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "Here is v.segment(1, 2):" << endl << v.segment(1, 2) << endl;
diff --git a/doc/snippets/MatrixBase_select.cpp b/doc/snippets/MatrixBase_select.cpp
index d14941b..5e6a3ba 100644
--- a/doc/snippets/MatrixBase_select.cpp
+++ b/doc/snippets/MatrixBase_select.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m(3, 3);
 m << 1, 2, 3, 4, 5, 6, 7, 8, 9;
 m = (m.array() >= 5).select(-m, m);
diff --git a/doc/snippets/MatrixBase_selfadjointView.cpp b/doc/snippets/MatrixBase_selfadjointView.cpp
index 4bd3c7e..38b289f 100644
--- a/doc/snippets/MatrixBase_selfadjointView.cpp
+++ b/doc/snippets/MatrixBase_selfadjointView.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3i m = Matrix3i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the symmetric matrix extracted from the upper part of m:" << endl
diff --git a/doc/snippets/MatrixBase_set.cpp b/doc/snippets/MatrixBase_set.cpp
index d392b68..48652eb 100644
--- a/doc/snippets/MatrixBase_set.cpp
+++ b/doc/snippets/MatrixBase_set.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3i m1;
 m1 << 1, 2, 3, 4, 5, 6, 7, 8, 9;
 cout << m1 << endl << endl;
diff --git a/doc/snippets/MatrixBase_setIdentity.cpp b/doc/snippets/MatrixBase_setIdentity.cpp
index 916b477..f11ea4e 100644
--- a/doc/snippets/MatrixBase_setIdentity.cpp
+++ b/doc/snippets/MatrixBase_setIdentity.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Zero();
 m.block<3, 3>(1, 0).setIdentity();
 cout << m << endl;
diff --git a/doc/snippets/MatrixBase_setOnes.cpp b/doc/snippets/MatrixBase_setOnes.cpp
index 4cef9c1..deb6c8d 100644
--- a/doc/snippets/MatrixBase_setOnes.cpp
+++ b/doc/snippets/MatrixBase_setOnes.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 m.row(1).setOnes();
 cout << m << endl;
diff --git a/doc/snippets/MatrixBase_setRandom.cpp b/doc/snippets/MatrixBase_setRandom.cpp
index e2c257d..9376476 100644
--- a/doc/snippets/MatrixBase_setRandom.cpp
+++ b/doc/snippets/MatrixBase_setRandom.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Zero();
 m.col(1).setRandom();
 cout << m << endl;
diff --git a/doc/snippets/MatrixBase_setZero.cpp b/doc/snippets/MatrixBase_setZero.cpp
index 9b5b958..474414f 100644
--- a/doc/snippets/MatrixBase_setZero.cpp
+++ b/doc/snippets/MatrixBase_setZero.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 m.row(1).setZero();
 cout << m << endl;
diff --git a/doc/snippets/MatrixBase_start_int.cpp b/doc/snippets/MatrixBase_start_int.cpp
index c261d2b..f345089 100644
--- a/doc/snippets/MatrixBase_start_int.cpp
+++ b/doc/snippets/MatrixBase_start_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVector4i v = RowVector4i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "Here is v.head(2):" << endl << v.head(2) << endl;
diff --git a/doc/snippets/MatrixBase_template_int_bottomRows.cpp b/doc/snippets/MatrixBase_template_int_bottomRows.cpp
index f9ea892..e0299d1 100644
--- a/doc/snippets/MatrixBase_template_int_bottomRows.cpp
+++ b/doc/snippets/MatrixBase_template_int_bottomRows.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.bottomRows<2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_end.cpp b/doc/snippets/MatrixBase_template_int_end.cpp
index f5ccb00..d4c6530 100644
--- a/doc/snippets/MatrixBase_template_int_end.cpp
+++ b/doc/snippets/MatrixBase_template_int_end.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVector4i v = RowVector4i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "Here is v.tail(2):" << endl << v.tail<2>() << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_block_int_int_int_int.cpp b/doc/snippets/MatrixBase_template_int_int_block_int_int_int_int.cpp
index 4dced03..988923b 100644
--- a/doc/snippets/MatrixBase_template_int_int_block_int_int_int_int.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_block_int_int_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the block:" << endl << m.block<2, Dynamic>(1, 1, 2, 3) << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner.cpp b/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner.cpp
index bf9f0ab..cffcfbf 100644
--- a/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.bottomLeftCorner<2,2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp b/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
index 3d22fc2..e091439 100644
--- a/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.bottomLeftCorner<2,Dynamic>(2,2):" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_bottomRightCorner.cpp b/doc/snippets/MatrixBase_template_int_int_bottomRightCorner.cpp
index 4a78bed..c46f84b 100644
--- a/doc/snippets/MatrixBase_template_int_int_bottomRightCorner.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_bottomRightCorner.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.bottomRightCorner<2,2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_bottomRightCorner_int_int.cpp b/doc/snippets/MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
index 75a3e93..2e606fc 100644
--- a/doc/snippets/MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.bottomRightCorner<2,Dynamic>(2,2):" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_topLeftCorner.cpp b/doc/snippets/MatrixBase_template_int_int_topLeftCorner.cpp
index 7c765d4..902a778 100644
--- a/doc/snippets/MatrixBase_template_int_int_topLeftCorner.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_topLeftCorner.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.topLeftCorner<2,2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_topLeftCorner_int_int.cpp b/doc/snippets/MatrixBase_template_int_int_topLeftCorner_int_int.cpp
index ae72684..440a91a 100644
--- a/doc/snippets/MatrixBase_template_int_int_topLeftCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_topLeftCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.topLeftCorner<2,Dynamic>(2,2):" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_topRightCorner.cpp b/doc/snippets/MatrixBase_template_int_int_topRightCorner.cpp
index 9698521..55a25b8 100644
--- a/doc/snippets/MatrixBase_template_int_int_topRightCorner.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_topRightCorner.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.topRightCorner<2,2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_int_topRightCorner_int_int.cpp b/doc/snippets/MatrixBase_template_int_int_topRightCorner_int_int.cpp
index 4144242..843f690 100644
--- a/doc/snippets/MatrixBase_template_int_int_topRightCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_template_int_int_topRightCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.topRightCorner<2,Dynamic>(2,2):" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_leftCols.cpp b/doc/snippets/MatrixBase_template_int_leftCols.cpp
index 1c425d9..cf3764e 100644
--- a/doc/snippets/MatrixBase_template_int_leftCols.cpp
+++ b/doc/snippets/MatrixBase_template_int_leftCols.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.leftCols<2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_rightCols.cpp b/doc/snippets/MatrixBase_template_int_rightCols.cpp
index fc8c0d9..1c38e0b 100644
--- a/doc/snippets/MatrixBase_template_int_rightCols.cpp
+++ b/doc/snippets/MatrixBase_template_int_rightCols.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.rightCols<2>():" << endl;
diff --git a/doc/snippets/MatrixBase_template_int_segment.cpp b/doc/snippets/MatrixBase_template_int_segment.cpp
index e448b40..52066d0 100644
--- a/doc/snippets/MatrixBase_template_int_segment.cpp
+++ b/doc/snippets/MatrixBase_template_int_segment.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVector4i v = RowVector4i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "Here is v.segment<2>(1):" << endl << v.segment<2>(1) << endl;
diff --git a/doc/snippets/MatrixBase_template_int_start.cpp b/doc/snippets/MatrixBase_template_int_start.cpp
index d336b37..27a527b 100644
--- a/doc/snippets/MatrixBase_template_int_start.cpp
+++ b/doc/snippets/MatrixBase_template_int_start.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVector4i v = RowVector4i::Random();
 cout << "Here is the vector v:" << endl << v << endl;
 cout << "Here is v.head(2):" << endl << v.head<2>() << endl;
diff --git a/doc/snippets/MatrixBase_template_int_topRows.cpp b/doc/snippets/MatrixBase_template_int_topRows.cpp
index 0110251..e932f68 100644
--- a/doc/snippets/MatrixBase_template_int_topRows.cpp
+++ b/doc/snippets/MatrixBase_template_int_topRows.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.topRows<2>():" << endl;
diff --git a/doc/snippets/MatrixBase_topLeftCorner_int_int.cpp b/doc/snippets/MatrixBase_topLeftCorner_int_int.cpp
index e52cb3b..2449b93 100644
--- a/doc/snippets/MatrixBase_topLeftCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_topLeftCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.topLeftCorner(2, 2):" << endl;
diff --git a/doc/snippets/MatrixBase_topRightCorner_int_int.cpp b/doc/snippets/MatrixBase_topRightCorner_int_int.cpp
index 811fa56..ea6f0bc 100644
--- a/doc/snippets/MatrixBase_topRightCorner_int_int.cpp
+++ b/doc/snippets/MatrixBase_topRightCorner_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.topRightCorner(2, 2):" << endl;
diff --git a/doc/snippets/MatrixBase_topRows_int.cpp b/doc/snippets/MatrixBase_topRows_int.cpp
index f2d75f1..c3239d6 100644
--- a/doc/snippets/MatrixBase_topRows_int.cpp
+++ b/doc/snippets/MatrixBase_topRows_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array44i a = Array44i::Random();
 cout << "Here is the array a:" << endl << a << endl;
 cout << "Here is a.topRows(2):" << endl;
diff --git a/doc/snippets/MatrixBase_transpose.cpp b/doc/snippets/MatrixBase_transpose.cpp
index 8bf2716..5ed389b 100644
--- a/doc/snippets/MatrixBase_transpose.cpp
+++ b/doc/snippets/MatrixBase_transpose.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2i m = Matrix2i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the transpose of m:" << endl << m.transpose() << endl;
diff --git a/doc/snippets/MatrixBase_triangularView.cpp b/doc/snippets/MatrixBase_triangularView.cpp
index 03aa303..1ec861d 100644
--- a/doc/snippets/MatrixBase_triangularView.cpp
+++ b/doc/snippets/MatrixBase_triangularView.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3i m = Matrix3i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the upper-triangular matrix extracted from m:" << endl
diff --git a/doc/snippets/MatrixBase_zero.cpp b/doc/snippets/MatrixBase_zero.cpp
index 6064936..e1f8d61 100644
--- a/doc/snippets/MatrixBase_zero.cpp
+++ b/doc/snippets/MatrixBase_zero.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << Matrix2d::Zero() << endl;
 cout << RowVector4i::Zero() << endl;
diff --git a/doc/snippets/MatrixBase_zero_int.cpp b/doc/snippets/MatrixBase_zero_int.cpp
index 370a9ba..b0af884 100644
--- a/doc/snippets/MatrixBase_zero_int.cpp
+++ b/doc/snippets/MatrixBase_zero_int.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << RowVectorXi::Zero(4) << endl;
 cout << VectorXf::Zero(2) << endl;
diff --git a/doc/snippets/MatrixBase_zero_int_int.cpp b/doc/snippets/MatrixBase_zero_int_int.cpp
index a500724..b7ab81d 100644
--- a/doc/snippets/MatrixBase_zero_int_int.cpp
+++ b/doc/snippets/MatrixBase_zero_int_int.cpp
@@ -1 +1,4 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 cout << MatrixXi::Zero(2, 3) << endl;
diff --git a/doc/snippets/Matrix_Map_stride.cpp b/doc/snippets/Matrix_Map_stride.cpp
index 5125b54..dbe2b10 100644
--- a/doc/snippets/Matrix_Map_stride.cpp
+++ b/doc/snippets/Matrix_Map_stride.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4i A;
 A << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16;
 
diff --git a/doc/snippets/Matrix_initializer_list_23.cpp b/doc/snippets/Matrix_initializer_list_23.cpp
new file mode 100644
index 0000000..b82e7d6
--- /dev/null
+++ b/doc/snippets/Matrix_initializer_list_23.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+MatrixXd m{{1, 2, 3}, {4, 5, 6}};
+cout << m << endl;
diff --git a/doc/snippets/Matrix_initializer_list_23_cxx11.cpp b/doc/snippets/Matrix_initializer_list_23_cxx11.cpp
deleted file mode 100644
index 8cde1cb..0000000
--- a/doc/snippets/Matrix_initializer_list_23_cxx11.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-MatrixXd m{{1, 2, 3}, {4, 5, 6}};
-cout << m << endl;
diff --git a/doc/snippets/Matrix_initializer_list_vector.cpp b/doc/snippets/Matrix_initializer_list_vector.cpp
new file mode 100644
index 0000000..5838e7b
--- /dev/null
+++ b/doc/snippets/Matrix_initializer_list_vector.cpp
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+VectorXi v{{1, 2}};
+cout << v << endl;
diff --git a/doc/snippets/Matrix_initializer_list_vector_cxx11.cpp b/doc/snippets/Matrix_initializer_list_vector_cxx11.cpp
deleted file mode 100644
index 7096deb..0000000
--- a/doc/snippets/Matrix_initializer_list_vector_cxx11.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-VectorXi v{{1, 2}};
-cout << v << endl;
diff --git a/doc/snippets/Matrix_resize_NoChange_int.cpp b/doc/snippets/Matrix_resize_NoChange_int.cpp
index c86ee30..df6ffd2 100644
--- a/doc/snippets/Matrix_resize_NoChange_int.cpp
+++ b/doc/snippets/Matrix_resize_NoChange_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(3, 4);
 m.resize(NoChange, 5);
 cout << "m: " << m.rows() << " rows, " << m.cols() << " cols" << endl;
diff --git a/doc/snippets/Matrix_resize_int.cpp b/doc/snippets/Matrix_resize_int.cpp
index 7f34df7..e417fa9 100644
--- a/doc/snippets/Matrix_resize_int.cpp
+++ b/doc/snippets/Matrix_resize_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 VectorXd v(10);
 v.resize(3);
 RowVector3d w;
diff --git a/doc/snippets/Matrix_resize_int_NoChange.cpp b/doc/snippets/Matrix_resize_int_NoChange.cpp
index e30763d..a471c9b 100644
--- a/doc/snippets/Matrix_resize_int_NoChange.cpp
+++ b/doc/snippets/Matrix_resize_int_NoChange.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(3, 4);
 m.resize(5, NoChange);
 cout << "m: " << m.rows() << " rows, " << m.cols() << " cols" << endl;
diff --git a/doc/snippets/Matrix_resize_int_int.cpp b/doc/snippets/Matrix_resize_int_int.cpp
index 5453dbd..19e9e19 100644
--- a/doc/snippets/Matrix_resize_int_int.cpp
+++ b/doc/snippets/Matrix_resize_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd m(2, 3);
 m << 1, 2, 3, 4, 5, 6;
 cout << "here's the 2x3 matrix m:" << endl << m << endl;
diff --git a/doc/snippets/Matrix_setConstant_int.cpp b/doc/snippets/Matrix_setConstant_int.cpp
index ff5a86c..d6bbee9 100644
--- a/doc/snippets/Matrix_setConstant_int.cpp
+++ b/doc/snippets/Matrix_setConstant_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 VectorXf v;
 v.setConstant(3, 5);
 cout << v << endl;
diff --git a/doc/snippets/Matrix_setConstant_int_int.cpp b/doc/snippets/Matrix_setConstant_int_int.cpp
index 32b950c..d4f5e19 100644
--- a/doc/snippets/Matrix_setConstant_int_int.cpp
+++ b/doc/snippets/Matrix_setConstant_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m;
 m.setConstant(3, 3, 5);
 cout << m << endl;
diff --git a/doc/snippets/Matrix_setIdentity_int_int.cpp b/doc/snippets/Matrix_setIdentity_int_int.cpp
index a659671..5cc4e8e 100644
--- a/doc/snippets/Matrix_setIdentity_int_int.cpp
+++ b/doc/snippets/Matrix_setIdentity_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m;
 m.setIdentity(3, 3);
 cout << m << endl;
diff --git a/doc/snippets/Matrix_setOnes_int.cpp b/doc/snippets/Matrix_setOnes_int.cpp
index 752cb35..7471489 100644
--- a/doc/snippets/Matrix_setOnes_int.cpp
+++ b/doc/snippets/Matrix_setOnes_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 VectorXf v;
 v.setOnes(3);
 cout << v << endl;
diff --git a/doc/snippets/Matrix_setOnes_int_int.cpp b/doc/snippets/Matrix_setOnes_int_int.cpp
index 1ffb66b..bb6ac7f 100644
--- a/doc/snippets/Matrix_setOnes_int_int.cpp
+++ b/doc/snippets/Matrix_setOnes_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m;
 m.setOnes(3, 3);
 cout << m << endl;
diff --git a/doc/snippets/Matrix_setRandom_int.cpp b/doc/snippets/Matrix_setRandom_int.cpp
index e160dd7..6caa837 100644
--- a/doc/snippets/Matrix_setRandom_int.cpp
+++ b/doc/snippets/Matrix_setRandom_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 VectorXf v;
 v.setRandom(3);
 cout << v << endl;
diff --git a/doc/snippets/Matrix_setRandom_int_int.cpp b/doc/snippets/Matrix_setRandom_int_int.cpp
index 80cda11..2fc63ff 100644
--- a/doc/snippets/Matrix_setRandom_int_int.cpp
+++ b/doc/snippets/Matrix_setRandom_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m;
 m.setRandom(3, 3);
 cout << m << endl;
diff --git a/doc/snippets/Matrix_setZero_int.cpp b/doc/snippets/Matrix_setZero_int.cpp
index 0fb16c1..f7302c1 100644
--- a/doc/snippets/Matrix_setZero_int.cpp
+++ b/doc/snippets/Matrix_setZero_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 VectorXf v;
 v.setZero(3);
 cout << v << endl;
diff --git a/doc/snippets/Matrix_setZero_int_int.cpp b/doc/snippets/Matrix_setZero_int_int.cpp
index ad883b9..0dd27e6 100644
--- a/doc/snippets/Matrix_setZero_int_int.cpp
+++ b/doc/snippets/Matrix_setZero_int_int.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf m;
 m.setZero(3, 3);
 cout << m << endl;
diff --git a/doc/snippets/Matrix_variadic_ctor.cpp b/doc/snippets/Matrix_variadic_ctor.cpp
new file mode 100644
index 0000000..04238a2
--- /dev/null
+++ b/doc/snippets/Matrix_variadic_ctor.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+Matrix<int, 1, 6> a(1, 2, 3, 4, 5, 6);
+Matrix<int, 3, 1> b{1, 2, 3};
+cout << a << "\n\n" << b << endl;
diff --git a/doc/snippets/Matrix_variadic_ctor_cxx11.cpp b/doc/snippets/Matrix_variadic_ctor_cxx11.cpp
deleted file mode 100644
index 45acd99..0000000
--- a/doc/snippets/Matrix_variadic_ctor_cxx11.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-Matrix<int, 1, 6> a(1, 2, 3, 4, 5, 6);
-Matrix<int, 3, 1> b{1, 2, 3};
-cout << a << "\n\n" << b << endl;
diff --git a/doc/snippets/PartialPivLU_solve.cpp b/doc/snippets/PartialPivLU_solve.cpp
index ebfa56d..8cb300f 100644
--- a/doc/snippets/PartialPivLU_solve.cpp
+++ b/doc/snippets/PartialPivLU_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd A = MatrixXd::Random(3, 3);
 MatrixXd B = MatrixXd::Random(3, 2);
 cout << "Here is the invertible matrix A:" << endl << A << endl;
diff --git a/doc/snippets/PartialRedux_count.cpp b/doc/snippets/PartialRedux_count.cpp
index 1c3b3a2..39be806 100644
--- a/doc/snippets/PartialRedux_count.cpp
+++ b/doc/snippets/PartialRedux_count.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 Matrix<ptrdiff_t, 3, 1> res = (m.array() >= 0.5).rowwise().count();
diff --git a/doc/snippets/PartialRedux_maxCoeff.cpp b/doc/snippets/PartialRedux_maxCoeff.cpp
index e8fd382..ddd58ce 100644
--- a/doc/snippets/PartialRedux_maxCoeff.cpp
+++ b/doc/snippets/PartialRedux_maxCoeff.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the maximum of each column:" << endl << m.colwise().maxCoeff() << endl;
diff --git a/doc/snippets/PartialRedux_minCoeff.cpp b/doc/snippets/PartialRedux_minCoeff.cpp
index d717bc0..4b150e0 100644
--- a/doc/snippets/PartialRedux_minCoeff.cpp
+++ b/doc/snippets/PartialRedux_minCoeff.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the minimum of each column:" << endl << m.colwise().minCoeff() << endl;
diff --git a/doc/snippets/PartialRedux_norm.cpp b/doc/snippets/PartialRedux_norm.cpp
index dbcf290..9352ba1 100644
--- a/doc/snippets/PartialRedux_norm.cpp
+++ b/doc/snippets/PartialRedux_norm.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the norm of each column:" << endl << m.colwise().norm() << endl;
diff --git a/doc/snippets/PartialRedux_prod.cpp b/doc/snippets/PartialRedux_prod.cpp
index aacf09c..8e8f4cf 100644
--- a/doc/snippets/PartialRedux_prod.cpp
+++ b/doc/snippets/PartialRedux_prod.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the product of each row:" << endl << m.rowwise().prod() << endl;
diff --git a/doc/snippets/PartialRedux_squaredNorm.cpp b/doc/snippets/PartialRedux_squaredNorm.cpp
index 9f3293e..c0fc3da 100644
--- a/doc/snippets/PartialRedux_squaredNorm.cpp
+++ b/doc/snippets/PartialRedux_squaredNorm.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the square norm of each row:" << endl << m.rowwise().squaredNorm() << endl;
diff --git a/doc/snippets/PartialRedux_sum.cpp b/doc/snippets/PartialRedux_sum.cpp
index ec82d3e..e45acb6 100644
--- a/doc/snippets/PartialRedux_sum.cpp
+++ b/doc/snippets/PartialRedux_sum.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the sum of each row:" << endl << m.rowwise().sum() << endl;
diff --git a/doc/snippets/RealQZ_compute.cpp b/doc/snippets/RealQZ_compute.cpp
index 10edefc..cd042c0 100644
--- a/doc/snippets/RealQZ_compute.cpp
+++ b/doc/snippets/RealQZ_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A = MatrixXf::Random(4, 4);
 MatrixXf B = MatrixXf::Random(4, 4);
 RealQZ<MatrixXf> qz(4);  // preallocate space for 4x4 matrices
diff --git a/doc/snippets/RealSchur_RealSchur_MatrixType.cpp b/doc/snippets/RealSchur_RealSchur_MatrixType.cpp
index 485b0ee..d3fd29c 100644
--- a/doc/snippets/RealSchur_RealSchur_MatrixType.cpp
+++ b/doc/snippets/RealSchur_RealSchur_MatrixType.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd A = MatrixXd::Random(6, 6);
 cout << "Here is a random 6x6 matrix, A:" << endl << A << endl << endl;
 
diff --git a/doc/snippets/RealSchur_compute.cpp b/doc/snippets/RealSchur_compute.cpp
index 78c71c8..6507cc5 100644
--- a/doc/snippets/RealSchur_compute.cpp
+++ b/doc/snippets/RealSchur_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A = MatrixXf::Random(4, 4);
 RealSchur<MatrixXf> schur(4);
 schur.compute(A, /* computeU = */ false);
diff --git a/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp b/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
index 0a26e9c..162e610 100644
--- a/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 SelfAdjointEigenSolver<Matrix4f> es;
 Matrix4f X = Matrix4f::Random(4, 4);
 Matrix4f A = X + X.transpose();
diff --git a/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp b/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
index 0ed9092..2e63819 100644
--- a/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(5, 5);
 MatrixXd A = X + X.transpose();
 cout << "Here is a random symmetric 5x5 matrix, A:" << endl << A << endl << endl;
diff --git a/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp b/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
index e2889b7..8222419 100644
--- a/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(5, 5);
 MatrixXd A = X + X.transpose();
 cout << "Here is a random symmetric matrix, A:" << endl << A << endl;
diff --git a/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType.cpp b/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType.cpp
index 1548562..fb6ed87 100644
--- a/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 SelfAdjointEigenSolver<MatrixXf> es(4);
 MatrixXf X = MatrixXf::Random(4, 4);
 MatrixXf A = X + X.transpose();
diff --git a/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType2.cpp b/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType2.cpp
index 88d44c6..2a87d8c 100644
--- a/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType2.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_compute_MatrixType2.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(5, 5);
 MatrixXd A = X * X.transpose();
 X = MatrixXd::Random(5, 5);
diff --git a/doc/snippets/SelfAdjointEigenSolver_eigenvalues.cpp b/doc/snippets/SelfAdjointEigenSolver_eigenvalues.cpp
index d80f90c..937a88c 100644
--- a/doc/snippets/SelfAdjointEigenSolver_eigenvalues.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_eigenvalues.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 SelfAdjointEigenSolver<MatrixXd> es(ones);
 cout << "The eigenvalues of the 3x3 matrix of ones are:" << endl << es.eigenvalues() << endl;
diff --git a/doc/snippets/SelfAdjointEigenSolver_eigenvectors.cpp b/doc/snippets/SelfAdjointEigenSolver_eigenvectors.cpp
index a91dca1..e4b28b6 100644
--- a/doc/snippets/SelfAdjointEigenSolver_eigenvectors.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_eigenvectors.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 SelfAdjointEigenSolver<MatrixXd> es(ones);
 cout << "The first eigenvector of the 3x3 matrix of ones is:" << endl << es.eigenvectors().col(0) << endl;
diff --git a/doc/snippets/SelfAdjointEigenSolver_operatorInverseSqrt.cpp b/doc/snippets/SelfAdjointEigenSolver_operatorInverseSqrt.cpp
index 50e83f3..496a66c 100644
--- a/doc/snippets/SelfAdjointEigenSolver_operatorInverseSqrt.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_operatorInverseSqrt.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(4, 4);
 MatrixXd A = X * X.transpose();
 cout << "Here is a random positive-definite matrix, A:" << endl << A << endl << endl;
diff --git a/doc/snippets/SelfAdjointEigenSolver_operatorSqrt.cpp b/doc/snippets/SelfAdjointEigenSolver_operatorSqrt.cpp
index bced567..78c3d5d 100644
--- a/doc/snippets/SelfAdjointEigenSolver_operatorSqrt.cpp
+++ b/doc/snippets/SelfAdjointEigenSolver_operatorSqrt.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(4, 4);
 MatrixXd A = X * X.transpose();
 cout << "Here is a random positive-definite matrix, A:" << endl << A << endl << endl;
diff --git a/doc/snippets/SelfAdjointView_eigenvalues.cpp b/doc/snippets/SelfAdjointView_eigenvalues.cpp
index 8cef6d8..bd6c9df 100644
--- a/doc/snippets/SelfAdjointView_eigenvalues.cpp
+++ b/doc/snippets/SelfAdjointView_eigenvalues.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 VectorXd eivals = ones.selfadjointView<Lower>().eigenvalues();
 cout << "The eigenvalues of the 3x3 matrix of ones are:" << endl << eivals << endl;
diff --git a/doc/snippets/SelfAdjointView_operatorNorm.cpp b/doc/snippets/SelfAdjointView_operatorNorm.cpp
index c229faf..e202732 100644
--- a/doc/snippets/SelfAdjointView_operatorNorm.cpp
+++ b/doc/snippets/SelfAdjointView_operatorNorm.cpp
@@ -1,2 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd ones = MatrixXd::Ones(3, 3);
 cout << "The operator norm of the 3x3 matrix of ones is " << ones.selfadjointView<Lower>().operatorNorm() << endl;
diff --git a/doc/snippets/Slicing_arrayexpr.cpp b/doc/snippets/Slicing_arrayexpr.cpp
index b78dbfa..7ed5571 100644
--- a/doc/snippets/Slicing_arrayexpr.cpp
+++ b/doc/snippets/Slicing_arrayexpr.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXi ind(5);
 ind << 4, 2, 5, 5, 3;
 MatrixXi A = MatrixXi::Random(4, 6);
diff --git a/doc/snippets/Slicing_custom_padding.cpp b/doc/snippets/Slicing_custom_padding.cpp
new file mode 100644
index 0000000..fc9e72c
--- /dev/null
+++ b/doc/snippets/Slicing_custom_padding.cpp
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+struct pad {
+  Index size() const { return out_size; }
+  Index operator[](Index i) const { return std::max<Index>(0, i - (out_size - in_size)); }
+  Index in_size, out_size;
+};
+
+Matrix3i A;
+A.reshaped() = VectorXi::LinSpaced(9, 1, 9);
+cout << "Initial matrix A:\n" << A << "\n\n";
+MatrixXi B(5, 5);
+B = A(pad{3, 5}, pad{3, 5});
+cout << "A(pad{3,N}, pad{3,N}):\n" << B << "\n\n";
diff --git a/doc/snippets/Slicing_custom_padding_cxx11.cpp b/doc/snippets/Slicing_custom_padding_cxx11.cpp
deleted file mode 100644
index 4d482f6..0000000
--- a/doc/snippets/Slicing_custom_padding_cxx11.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-struct pad {
-  Index size() const { return out_size; }
-  Index operator[](Index i) const { return std::max<Index>(0, i - (out_size - in_size)); }
-  Index in_size, out_size;
-};
-
-Matrix3i A;
-A.reshaped() = VectorXi::LinSpaced(9, 1, 9);
-cout << "Initial matrix A:\n" << A << "\n\n";
-MatrixXi B(5, 5);
-B = A(pad{3, 5}, pad{3, 5});
-cout << "A(pad{3,N}, pad{3,N}):\n" << B << "\n\n";
diff --git a/doc/snippets/Slicing_rawarray.cpp b/doc/snippets/Slicing_rawarray.cpp
new file mode 100644
index 0000000..47f8cbf
--- /dev/null
+++ b/doc/snippets/Slicing_rawarray.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+MatrixXi A = MatrixXi::Random(4, 6);
+cout << "Initial matrix A:\n" << A << "\n\n";
+cout << "A(all,{4,2,5,5,3}):\n" << A(Eigen::placeholders::all, {4, 2, 5, 5, 3}) << "\n\n";
diff --git a/doc/snippets/Slicing_rawarray_cxx11.cpp b/doc/snippets/Slicing_rawarray_cxx11.cpp
deleted file mode 100644
index 0495db6..0000000
--- a/doc/snippets/Slicing_rawarray_cxx11.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-MatrixXi A = MatrixXi::Random(4, 6);
-cout << "Initial matrix A:\n" << A << "\n\n";
-cout << "A(all,{4,2,5,5,3}):\n" << A(Eigen::placeholders::all, {4, 2, 5, 5, 3}) << "\n\n";
diff --git a/doc/snippets/Slicing_stdvector.cpp b/doc/snippets/Slicing_stdvector.cpp
new file mode 100644
index 0000000..5131082
--- /dev/null
+++ b/doc/snippets/Slicing_stdvector.cpp
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+std::vector<int> ind{4, 2, 5, 5, 3};
+MatrixXi A = MatrixXi::Random(4, 6);
+cout << "Initial matrix A:\n" << A << "\n\n";
+cout << "A(all,ind):\n" << A(Eigen::placeholders::all, ind) << "\n\n";
diff --git a/doc/snippets/Slicing_stdvector_cxx11.cpp b/doc/snippets/Slicing_stdvector_cxx11.cpp
deleted file mode 100644
index 7d5ad0c..0000000
--- a/doc/snippets/Slicing_stdvector_cxx11.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-std::vector<int> ind{4, 2, 5, 5, 3};
-MatrixXi A = MatrixXi::Random(4, 6);
-cout << "Initial matrix A:\n" << A << "\n\n";
-cout << "A(all,ind):\n" << A(Eigen::placeholders::all, ind) << "\n\n";
diff --git a/doc/snippets/SparseMatrix_coeffs.cpp b/doc/snippets/SparseMatrix_coeffs.cpp
index 266e32d..1b33eda 100644
--- a/doc/snippets/SparseMatrix_coeffs.cpp
+++ b/doc/snippets/SparseMatrix_coeffs.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 SparseMatrix<double> A(3, 3);
 A.insert(1, 2) = 0;
 A.insert(0, 1) = 1;
diff --git a/doc/snippets/TopicAliasing_block.cpp b/doc/snippets/TopicAliasing_block.cpp
index bbb7c2a..09b0bde 100644
--- a/doc/snippets/TopicAliasing_block.cpp
+++ b/doc/snippets/TopicAliasing_block.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi mat(3, 3);
 mat << 1, 2, 3, 4, 5, 6, 7, 8, 9;
 cout << "Here is the matrix mat:\n" << mat << endl;
diff --git a/doc/snippets/TopicAliasing_block_correct.cpp b/doc/snippets/TopicAliasing_block_correct.cpp
index 6a3002e..106c88c 100644
--- a/doc/snippets/TopicAliasing_block_correct.cpp
+++ b/doc/snippets/TopicAliasing_block_correct.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi mat(3, 3);
 mat << 1, 2, 3, 4, 5, 6, 7, 8, 9;
 cout << "Here is the matrix mat:\n" << mat << endl;
diff --git a/doc/snippets/TopicAliasing_cwise.cpp b/doc/snippets/TopicAliasing_cwise.cpp
index cb9d08a..200e265 100644
--- a/doc/snippets/TopicAliasing_cwise.cpp
+++ b/doc/snippets/TopicAliasing_cwise.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf mat(2, 2);
 mat << 1, 2, 4, 7;
 cout << "Here is the matrix mat:\n" << mat << endl << endl;
diff --git a/doc/snippets/TopicAliasing_mult1.cpp b/doc/snippets/TopicAliasing_mult1.cpp
index 4ae2a47..06494ec 100644
--- a/doc/snippets/TopicAliasing_mult1.cpp
+++ b/doc/snippets/TopicAliasing_mult1.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf matA(2, 2);
 matA << 2, 0, 0, 2;
 matA = matA * matA;
diff --git a/doc/snippets/TopicAliasing_mult2.cpp b/doc/snippets/TopicAliasing_mult2.cpp
index 52c9987..fcba70b 100644
--- a/doc/snippets/TopicAliasing_mult2.cpp
+++ b/doc/snippets/TopicAliasing_mult2.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf matA(2, 2), matB(2, 2);
 matA << 2, 0, 0, 2;
 
diff --git a/doc/snippets/TopicAliasing_mult3.cpp b/doc/snippets/TopicAliasing_mult3.cpp
index b2bed6f..408f280 100644
--- a/doc/snippets/TopicAliasing_mult3.cpp
+++ b/doc/snippets/TopicAliasing_mult3.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf matA(2, 2);
 matA << 2, 0, 0, 2;
 matA.noalias() = matA * matA;
diff --git a/doc/snippets/TopicAliasing_mult4.cpp b/doc/snippets/TopicAliasing_mult4.cpp
index 9a82322..229d00e 100644
--- a/doc/snippets/TopicAliasing_mult4.cpp
+++ b/doc/snippets/TopicAliasing_mult4.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A(2, 2), B(3, 2);
 B << 2, 0, 0, 3, 1, 1;
 A << 2, 0, 0, -2;
diff --git a/doc/snippets/TopicAliasing_mult5.cpp b/doc/snippets/TopicAliasing_mult5.cpp
index 79a94c8..cae9e0d 100644
--- a/doc/snippets/TopicAliasing_mult5.cpp
+++ b/doc/snippets/TopicAliasing_mult5.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf A(2, 2), B(3, 2);
 B << 2, 0, 0, 3, 1, 1;
 A << 2, 0, 0, -2;
diff --git a/doc/snippets/TopicStorageOrders_example.cpp b/doc/snippets/TopicStorageOrders_example.cpp
index 64e2123..75c08b1 100644
--- a/doc/snippets/TopicStorageOrders_example.cpp
+++ b/doc/snippets/TopicStorageOrders_example.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix<int, 3, 4, ColMajor> Acolmajor;
 Acolmajor << 8, 2, 2, 9, 9, 1, 4, 4, 3, 5, 4, 5;
 cout << "The matrix A:" << endl;
diff --git a/doc/snippets/Triangular_solve.cpp b/doc/snippets/Triangular_solve.cpp
index 2da806b..41df445 100644
--- a/doc/snippets/Triangular_solve.cpp
+++ b/doc/snippets/Triangular_solve.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3d m = Matrix3d::Zero();
 m.triangularView<Eigen::Upper>().setOnes();
 cout << "Here is the matrix m:\n" << m << endl;
diff --git a/doc/snippets/Tridiagonalization_Tridiagonalization_MatrixType.cpp b/doc/snippets/Tridiagonalization_Tridiagonalization_MatrixType.cpp
index 087b1ec..e6911e6 100644
--- a/doc/snippets/Tridiagonalization_Tridiagonalization_MatrixType.cpp
+++ b/doc/snippets/Tridiagonalization_Tridiagonalization_MatrixType.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(5, 5);
 MatrixXd A = X + X.transpose();
 cout << "Here is a random symmetric 5x5 matrix:" << endl << A << endl << endl;
diff --git a/doc/snippets/Tridiagonalization_compute.cpp b/doc/snippets/Tridiagonalization_compute.cpp
index 1bb9d28..3680d7f 100644
--- a/doc/snippets/Tridiagonalization_compute.cpp
+++ b/doc/snippets/Tridiagonalization_compute.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Tridiagonalization<MatrixXf> tri;
 MatrixXf X = MatrixXf::Random(4, 4);
 MatrixXf A = X + X.transpose();
diff --git a/doc/snippets/Tridiagonalization_decomposeInPlace.cpp b/doc/snippets/Tridiagonalization_decomposeInPlace.cpp
index b28c935..904d3f7 100644
--- a/doc/snippets/Tridiagonalization_decomposeInPlace.cpp
+++ b/doc/snippets/Tridiagonalization_decomposeInPlace.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXd X = MatrixXd::Random(5, 5);
 MatrixXd A = X + X.transpose();
 cout << "Here is a random symmetric 5x5 matrix:" << endl << A << endl << endl;
diff --git a/doc/snippets/Tridiagonalization_diagonal.cpp b/doc/snippets/Tridiagonalization_diagonal.cpp
index 18edc1e..183da3c 100644
--- a/doc/snippets/Tridiagonalization_diagonal.cpp
+++ b/doc/snippets/Tridiagonalization_diagonal.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcd X = MatrixXcd::Random(4, 4);
 MatrixXcd A = X + X.adjoint();
 cout << "Here is a random self-adjoint 4x4 matrix:" << endl << A << endl << endl;
diff --git a/doc/snippets/Tridiagonalization_householderCoefficients.cpp b/doc/snippets/Tridiagonalization_householderCoefficients.cpp
index f880f1d..88b1a28 100644
--- a/doc/snippets/Tridiagonalization_householderCoefficients.cpp
+++ b/doc/snippets/Tridiagonalization_householderCoefficients.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4d X = Matrix4d::Random(4, 4);
 Matrix4d A = X + X.transpose();
 cout << "Here is a random symmetric 4x4 matrix:" << endl << A << endl;
diff --git a/doc/snippets/Tridiagonalization_packedMatrix.cpp b/doc/snippets/Tridiagonalization_packedMatrix.cpp
index 3b186a8..c92abcd 100644
--- a/doc/snippets/Tridiagonalization_packedMatrix.cpp
+++ b/doc/snippets/Tridiagonalization_packedMatrix.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix4d X = Matrix4d::Random(4, 4);
 Matrix4d A = X + X.transpose();
 cout << "Here is a random symmetric 4x4 matrix:" << endl << A << endl;
diff --git a/doc/snippets/Tutorial_AdvancedInitialization_Block.cpp b/doc/snippets/Tutorial_AdvancedInitialization_Block.cpp
index 752c522..f5ecc4a 100644
--- a/doc/snippets/Tutorial_AdvancedInitialization_Block.cpp
+++ b/doc/snippets/Tutorial_AdvancedInitialization_Block.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf matA(2, 2);
 matA << 1, 2, 3, 4;
 MatrixXf matB(4, 4);
diff --git a/doc/snippets/Tutorial_AdvancedInitialization_CommaTemporary.cpp b/doc/snippets/Tutorial_AdvancedInitialization_CommaTemporary.cpp
index 8af3d74..7942eba 100644
--- a/doc/snippets/Tutorial_AdvancedInitialization_CommaTemporary.cpp
+++ b/doc/snippets/Tutorial_AdvancedInitialization_CommaTemporary.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf mat = MatrixXf::Random(2, 3);
 std::cout << mat << std::endl << std::endl;
 mat = (MatrixXf(2, 2) << 0, 1, 1, 0).finished() * mat;
diff --git a/doc/snippets/Tutorial_AdvancedInitialization_Join.cpp b/doc/snippets/Tutorial_AdvancedInitialization_Join.cpp
index 55a2153..1053b06 100644
--- a/doc/snippets/Tutorial_AdvancedInitialization_Join.cpp
+++ b/doc/snippets/Tutorial_AdvancedInitialization_Join.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVectorXd vec1(3);
 vec1 << 1, 2, 3;
 std::cout << "vec1 = " << vec1 << std::endl;
diff --git a/doc/snippets/Tutorial_AdvancedInitialization_LinSpaced.cpp b/doc/snippets/Tutorial_AdvancedInitialization_LinSpaced.cpp
index a400cb2..a59b2b0 100644
--- a/doc/snippets/Tutorial_AdvancedInitialization_LinSpaced.cpp
+++ b/doc/snippets/Tutorial_AdvancedInitialization_LinSpaced.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 ArrayXXf table(10, 4);
 table.col(0) = ArrayXf::LinSpaced(10, 0, 90);
 table.col(1) = EIGEN_PI / 180 * table.col(0);
diff --git a/doc/snippets/Tutorial_AdvancedInitialization_ThreeWays.cpp b/doc/snippets/Tutorial_AdvancedInitialization_ThreeWays.cpp
index 4878dd7..73e35c3 100644
--- a/doc/snippets/Tutorial_AdvancedInitialization_ThreeWays.cpp
+++ b/doc/snippets/Tutorial_AdvancedInitialization_ThreeWays.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 const int size = 6;
 MatrixXd mat1(size, size);
 mat1.topLeftCorner(size / 2, size / 2) = MatrixXd::Zero(size / 2, size / 2);
diff --git a/doc/snippets/Tutorial_AdvancedInitialization_Zero.cpp b/doc/snippets/Tutorial_AdvancedInitialization_Zero.cpp
index 03fb899..0df204e 100644
--- a/doc/snippets/Tutorial_AdvancedInitialization_Zero.cpp
+++ b/doc/snippets/Tutorial_AdvancedInitialization_Zero.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 std::cout << "A fixed-size array:\n";
 Array33f a1 = Array33f::Zero();
 std::cout << a1 << "\n\n";
diff --git a/doc/snippets/Tutorial_Map_inner_stride.cpp b/doc/snippets/Tutorial_Map_inner_stride.cpp
new file mode 100644
index 0000000..189de08
--- /dev/null
+++ b/doc/snippets/Tutorial_Map_inner_stride.cpp
@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+int array[24];
+for (int i = 0; i < 24; ++i) array[i] = i;
+
+cout << "Original column-major matrix:\n" << Map<Matrix<int, 6, 4> >(array) << endl;
+cout << "Every other row:\n" << Map<Matrix<int, 3, 4>, Unaligned, InnerStride<2> >(array) << endl;
diff --git a/doc/snippets/Tutorial_Map_rowmajor.cpp b/doc/snippets/Tutorial_Map_rowmajor.cpp
deleted file mode 100644
index f1b9a2f..0000000
--- a/doc/snippets/Tutorial_Map_rowmajor.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-int array[8];
-for (int i = 0; i < 8; ++i) array[i] = i;
-cout << "Column-major:\n" << Map<Matrix<int, 2, 4> >(array) << endl;
-cout << "Row-major:\n" << Map<Matrix<int, 2, 4, RowMajor> >(array) << endl;
-cout << "Row-major using stride:\n" << Map<Matrix<int, 2, 4>, Unaligned, Stride<1, 4> >(array) << endl;
diff --git a/doc/snippets/Tutorial_Map_using.cpp b/doc/snippets/Tutorial_Map_using.cpp
index 6fd6ea8..fb8def4 100644
--- a/doc/snippets/Tutorial_Map_using.cpp
+++ b/doc/snippets/Tutorial_Map_using.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 typedef Matrix<float, 1, Dynamic> MatrixType;
 typedef Map<MatrixType> MapType;
 typedef Map<const MatrixType> MapTypeConst;  // a read-only map
diff --git a/doc/snippets/Tutorial_ReshapeMat2Mat.cpp b/doc/snippets/Tutorial_ReshapeMat2Mat.cpp
index 855af31..7e4c12f 100644
--- a/doc/snippets/Tutorial_ReshapeMat2Mat.cpp
+++ b/doc/snippets/Tutorial_ReshapeMat2Mat.cpp
@@ -1,5 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf M1(2, 6);  // Column-major storage
 M1 << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12;
 
-Map<MatrixXf> M2(M1.data(), 6, 2);
-cout << "M2:" << endl << M2 << endl;
+cout << "M2:" << endl << M1.reshaped(6, 2) << endl;
diff --git a/doc/snippets/Tutorial_ReshapeMat2Vec.cpp b/doc/snippets/Tutorial_ReshapeMat2Vec.cpp
index 9a2df01..09c0b68 100644
--- a/doc/snippets/Tutorial_ReshapeMat2Vec.cpp
+++ b/doc/snippets/Tutorial_ReshapeMat2Vec.cpp
@@ -1,9 +1,10 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf M1(3, 3);  // Column-major storage
 M1 << 1, 2, 3, 4, 5, 6, 7, 8, 9;
 
-Map<RowVectorXf> v1(M1.data(), M1.size());
-cout << "v1:" << endl << v1 << endl;
+cout << "v1:" << endl << M1.reshaped().transpose() << endl;
 
 Matrix<float, Dynamic, Dynamic, RowMajor> M2(M1);
-Map<RowVectorXf> v2(M2.data(), M2.size());
-cout << "v2:" << endl << v2 << endl;
+cout << "v2:" << endl << M2.reshaped<AutoOrder>().transpose() << endl;
diff --git a/doc/snippets/Tutorial_SlicingCol.cpp b/doc/snippets/Tutorial_SlicingCol.cpp
index bfaec50..41dc671 100644
--- a/doc/snippets/Tutorial_SlicingCol.cpp
+++ b/doc/snippets/Tutorial_SlicingCol.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf M1 = MatrixXf::Random(3, 8);
 cout << "Column major input:" << endl << M1 << "\n";
 Map<MatrixXf, 0, OuterStride<> > M2(M1.data(), M1.rows(), (M1.cols() + 2) / 3, OuterStride<>(M1.outerStride() * 3));
diff --git a/doc/snippets/Tutorial_SlicingVec.cpp b/doc/snippets/Tutorial_SlicingVec.cpp
index d0c81c6..7f3cdf6 100644
--- a/doc/snippets/Tutorial_SlicingVec.cpp
+++ b/doc/snippets/Tutorial_SlicingVec.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 RowVectorXf v = RowVectorXf::LinSpaced(20, 0, 19);
 cout << "Input:" << endl << v << endl;
 Map<RowVectorXf, 0, InnerStride<2> > v2(v.data(), v.size() / 2);
diff --git a/doc/snippets/Tutorial_commainit_01.cpp b/doc/snippets/Tutorial_commainit_01.cpp
index 36728a7..966dee7 100644
--- a/doc/snippets/Tutorial_commainit_01.cpp
+++ b/doc/snippets/Tutorial_commainit_01.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f m;
 m << 1, 2, 3, 4, 5, 6, 7, 8, 9;
 std::cout << m;
diff --git a/doc/snippets/Tutorial_commainit_01b.cpp b/doc/snippets/Tutorial_commainit_01b.cpp
index 126277b..a3ecc01 100644
--- a/doc/snippets/Tutorial_commainit_01b.cpp
+++ b/doc/snippets/Tutorial_commainit_01b.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f m;
 m.row(0) << 1, 2, 3;
 m.block(1, 0, 2, 2) << 4, 5, 7, 8;
diff --git a/doc/snippets/Tutorial_commainit_02.cpp b/doc/snippets/Tutorial_commainit_02.cpp
index 3437237..80abbef 100644
--- a/doc/snippets/Tutorial_commainit_02.cpp
+++ b/doc/snippets/Tutorial_commainit_02.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 int rows = 5, cols = 5;
 MatrixXf m(rows, cols);
 m << (Matrix3f() << 1, 2, 3, 4, 5, 6, 7, 8, 9).finished(),
diff --git a/doc/snippets/Tutorial_range_for_loop_1d.cpp b/doc/snippets/Tutorial_range_for_loop_1d.cpp
new file mode 100644
index 0000000..447d649
--- /dev/null
+++ b/doc/snippets/Tutorial_range_for_loop_1d.cpp
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+VectorXi v = VectorXi::Random(4);
+cout << "Here is the vector v:\n";
+for (auto x : v) cout << x << " ";
+cout << "\n";
diff --git a/doc/snippets/Tutorial_range_for_loop_1d_cxx11.cpp b/doc/snippets/Tutorial_range_for_loop_1d_cxx11.cpp
deleted file mode 100644
index ee3af86..0000000
--- a/doc/snippets/Tutorial_range_for_loop_1d_cxx11.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-VectorXi v = VectorXi::Random(4);
-cout << "Here is the vector v:\n";
-for (auto x : v) cout << x << " ";
-cout << "\n";
diff --git a/doc/snippets/Tutorial_range_for_loop_2d.cpp b/doc/snippets/Tutorial_range_for_loop_2d.cpp
new file mode 100644
index 0000000..dc121f2
--- /dev/null
+++ b/doc/snippets/Tutorial_range_for_loop_2d.cpp
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+Matrix2i A = Matrix2i::Random();
+cout << "Here are the coeffs of the 2x2 matrix A:\n";
+for (auto x : A.reshaped()) cout << x << " ";
+cout << "\n";
diff --git a/doc/snippets/Tutorial_range_for_loop_2d_cxx11.cpp b/doc/snippets/Tutorial_range_for_loop_2d_cxx11.cpp
deleted file mode 100644
index 27e1f8a..0000000
--- a/doc/snippets/Tutorial_range_for_loop_2d_cxx11.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-Matrix2i A = Matrix2i::Random();
-cout << "Here are the coeffs of the 2x2 matrix A:\n";
-for (auto x : A.reshaped()) cout << x << " ";
-cout << "\n";
diff --git a/doc/snippets/Tutorial_reshaped_vs_resize_1.cpp b/doc/snippets/Tutorial_reshaped_vs_resize_1.cpp
index 41a5d99..4ef4f73 100644
--- a/doc/snippets/Tutorial_reshaped_vs_resize_1.cpp
+++ b/doc/snippets/Tutorial_reshaped_vs_resize_1.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.reshaped(2, 8):" << endl << m.reshaped(2, 8) << endl;
diff --git a/doc/snippets/Tutorial_reshaped_vs_resize_2.cpp b/doc/snippets/Tutorial_reshaped_vs_resize_2.cpp
index c5d3929..9cdcdc2 100644
--- a/doc/snippets/Tutorial_reshaped_vs_resize_2.cpp
+++ b/doc/snippets/Tutorial_reshaped_vs_resize_2.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix<int, Dynamic, Dynamic, RowMajor> m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is m.reshaped(2, 8):" << endl << m.reshaped(2, 8) << endl;
diff --git a/doc/snippets/Tutorial_solve_matrix_inverse.cpp b/doc/snippets/Tutorial_solve_matrix_inverse.cpp
index e39696f..811a206 100644
--- a/doc/snippets/Tutorial_solve_matrix_inverse.cpp
+++ b/doc/snippets/Tutorial_solve_matrix_inverse.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A;
 Vector3f b;
 A << 1, 2, 3, 4, 5, 6, 7, 8, 10;
diff --git a/doc/snippets/Tutorial_solve_multiple_rhs.cpp b/doc/snippets/Tutorial_solve_multiple_rhs.cpp
index b08100a..d4f3e04 100644
--- a/doc/snippets/Tutorial_solve_multiple_rhs.cpp
+++ b/doc/snippets/Tutorial_solve_multiple_rhs.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A(3, 3);
 A << 1, 2, 3, 4, 5, 6, 7, 8, 10;
 Matrix<float, 3, 2> B;
diff --git a/doc/snippets/Tutorial_solve_reuse_decomposition.cpp b/doc/snippets/Tutorial_solve_reuse_decomposition.cpp
index d47c6ca..380ecc5 100644
--- a/doc/snippets/Tutorial_solve_reuse_decomposition.cpp
+++ b/doc/snippets/Tutorial_solve_reuse_decomposition.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A(3, 3);
 A << 1, 2, 3, 4, 5, 6, 7, 8, 10;
 PartialPivLU<Matrix3f> luOfA(A);  // compute LU decomposition of A
diff --git a/doc/snippets/Tutorial_solve_singular.cpp b/doc/snippets/Tutorial_solve_singular.cpp
index 4d168df..a910acb 100644
--- a/doc/snippets/Tutorial_solve_singular.cpp
+++ b/doc/snippets/Tutorial_solve_singular.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A;
 Vector3f b;
 A << 1, 2, 3, 4, 5, 6, 7, 8, 9;
diff --git a/doc/snippets/Tutorial_solve_triangular.cpp b/doc/snippets/Tutorial_solve_triangular.cpp
index b422f24..4910d81 100644
--- a/doc/snippets/Tutorial_solve_triangular.cpp
+++ b/doc/snippets/Tutorial_solve_triangular.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A;
 Vector3f b;
 A << 1, 2, 3, 0, 5, 6, 0, 0, 10;
diff --git a/doc/snippets/Tutorial_solve_triangular_inplace.cpp b/doc/snippets/Tutorial_solve_triangular_inplace.cpp
index f928e78..930b4f7 100644
--- a/doc/snippets/Tutorial_solve_triangular_inplace.cpp
+++ b/doc/snippets/Tutorial_solve_triangular_inplace.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f A;
 Vector3f b;
 A << 1, 2, 3, 0, 5, 6, 0, 0, 10;
diff --git a/doc/snippets/Tutorial_std_sort.cpp b/doc/snippets/Tutorial_std_sort.cpp
index cde2a6f..fa52364 100644
--- a/doc/snippets/Tutorial_std_sort.cpp
+++ b/doc/snippets/Tutorial_std_sort.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Array4i v = Array4i::Random().abs();
 cout << "Here is the initial vector v:\n" << v.transpose() << "\n";
 std::sort(v.begin(), v.end());
diff --git a/doc/snippets/Tutorial_std_sort_rows.cpp b/doc/snippets/Tutorial_std_sort_rows.cpp
new file mode 100644
index 0000000..9cbc406
--- /dev/null
+++ b/doc/snippets/Tutorial_std_sort_rows.cpp
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+ArrayXXi A = ArrayXXi::Random(4, 4).abs();
+cout << "Here is the initial matrix A:\n" << A << "\n";
+for (auto row : A.rowwise()) std::sort(row.begin(), row.end());
+cout << "Here is the sorted matrix A:\n" << A << "\n";
diff --git a/doc/snippets/Tutorial_std_sort_rows_cxx11.cpp b/doc/snippets/Tutorial_std_sort_rows_cxx11.cpp
deleted file mode 100644
index d948949..0000000
--- a/doc/snippets/Tutorial_std_sort_rows_cxx11.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-ArrayXXi A = ArrayXXi::Random(4, 4).abs();
-cout << "Here is the initial matrix A:\n" << A << "\n";
-for (auto row : A.rowwise()) std::sort(row.begin(), row.end());
-cout << "Here is the sorted matrix A:\n" << A << "\n";
diff --git a/doc/snippets/VectorwiseOp_homogeneous.cpp b/doc/snippets/VectorwiseOp_homogeneous.cpp
index 3d2c8fd..211188d 100644
--- a/doc/snippets/VectorwiseOp_homogeneous.cpp
+++ b/doc/snippets/VectorwiseOp_homogeneous.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3Xd M = Matrix3Xd::Random(3, 5);
 Projective3d P(Matrix4d::Random());
 cout << "The matrix M is:" << endl << M << endl << endl;
diff --git a/doc/snippets/Vectorwise_reverse.cpp b/doc/snippets/Vectorwise_reverse.cpp
index 85a0065..b7a7291 100644
--- a/doc/snippets/Vectorwise_reverse.cpp
+++ b/doc/snippets/Vectorwise_reverse.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXi m = MatrixXi::Random(3, 4);
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here is the rowwise reverse of m:" << endl << m.rowwise().reverse() << endl;
diff --git a/doc/snippets/class_FullPivLU.cpp b/doc/snippets/class_FullPivLU.cpp
index 2951c8d..0b8770a 100644
--- a/doc/snippets/class_FullPivLU.cpp
+++ b/doc/snippets/class_FullPivLU.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 typedef Matrix<double, 5, 3> Matrix5x3;
 typedef Matrix<double, 5, 5> Matrix5x5;
 Matrix5x3 m = Matrix5x3::Random();
diff --git a/doc/snippets/tut_arithmetic_redux_minmax.cpp b/doc/snippets/tut_arithmetic_redux_minmax.cpp
index dc43358..67a6d41 100644
--- a/doc/snippets/tut_arithmetic_redux_minmax.cpp
+++ b/doc/snippets/tut_arithmetic_redux_minmax.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix3f m = Matrix3f::Random();
 std::ptrdiff_t i, j;
 float minOfM = m.minCoeff(&i, &j);
diff --git a/doc/snippets/tut_arithmetic_transpose_aliasing.cpp b/doc/snippets/tut_arithmetic_transpose_aliasing.cpp
index 75d46cf..cedc00e 100644
--- a/doc/snippets/tut_arithmetic_transpose_aliasing.cpp
+++ b/doc/snippets/tut_arithmetic_transpose_aliasing.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 Matrix2i a;
 a << 1, 2, 3, 4;
 cout << "Here is the matrix a:\n" << a << endl;
diff --git a/doc/snippets/tut_arithmetic_transpose_conjugate.cpp b/doc/snippets/tut_arithmetic_transpose_conjugate.cpp
index 3b356d2..b88bc47 100644
--- a/doc/snippets/tut_arithmetic_transpose_conjugate.cpp
+++ b/doc/snippets/tut_arithmetic_transpose_conjugate.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXcf a = MatrixXcf::Random(2, 2);
 cout << "Here is the matrix a\n" << a << endl;
 
diff --git a/doc/snippets/tut_arithmetic_transpose_inplace.cpp b/doc/snippets/tut_arithmetic_transpose_inplace.cpp
index dbf8bc4..57a50d8 100644
--- a/doc/snippets/tut_arithmetic_transpose_inplace.cpp
+++ b/doc/snippets/tut_arithmetic_transpose_inplace.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf a(2, 3);
 a << 1, 2, 3, 4, 5, 6;
 cout << "Here is the initial matrix a:\n" << a << endl;
diff --git a/doc/snippets/tut_matrix_assignment_resizing.cpp b/doc/snippets/tut_matrix_assignment_resizing.cpp
index 9f5da43..6d0b6c8 100644
--- a/doc/snippets/tut_matrix_assignment_resizing.cpp
+++ b/doc/snippets/tut_matrix_assignment_resizing.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 MatrixXf a(2, 2);
 std::cout << "a is of size " << a.rows() << "x" << a.cols() << std::endl;
 MatrixXf b(3, 3);
diff --git a/doc/special_examples/CMakeLists.txt b/doc/special_examples/CMakeLists.txt
index af3f7e4..b0e90b0 100644
--- a/doc/special_examples/CMakeLists.txt
+++ b/doc/special_examples/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 if(NOT EIGEN_TEST_NOQT)
   find_package(Qt4)
   if(QT4_FOUND)
@@ -19,13 +22,13 @@
   add_dependencies(all_examples Tutorial_sparse_example)
 endif()
 
-add_executable(random_cpp11 random_cpp11.cpp)
-target_link_libraries(random_cpp11 ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO} Eigen3::Eigen)
-add_dependencies(all_examples random_cpp11)
+add_executable(random_generators random_generators.cpp)
+target_link_libraries(random_generators ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO} Eigen3::Eigen)
+add_dependencies(all_examples random_generators)
 
 add_custom_command(
-  TARGET random_cpp11
+  TARGET random_generators
   POST_BUILD
-  COMMAND random_cpp11
-  ARGS >${CMAKE_CURRENT_BINARY_DIR}/random_cpp11.out
+  COMMAND random_generators
+  ARGS >${CMAKE_CURRENT_BINARY_DIR}/random_generators.out
 )
diff --git a/doc/special_examples/Tutorial_sparse_example.cpp b/doc/special_examples/Tutorial_sparse_example.cpp
index b8994ba..1d7c1a3 100644
--- a/doc/special_examples/Tutorial_sparse_example.cpp
+++ b/doc/special_examples/Tutorial_sparse_example.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Sparse>
 #include <vector>
 #include <iostream>
diff --git a/doc/special_examples/Tutorial_sparse_example_details.cpp b/doc/special_examples/Tutorial_sparse_example_details.cpp
index 1bcdeb5..81ef47a 100644
--- a/doc/special_examples/Tutorial_sparse_example_details.cpp
+++ b/doc/special_examples/Tutorial_sparse_example_details.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Sparse>
 #include <vector>
 #include <QImage>
diff --git a/doc/special_examples/random_cpp11.cpp b/doc/special_examples/random_cpp11.cpp
deleted file mode 100644
index a59613a..0000000
--- a/doc/special_examples/random_cpp11.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <Eigen/Core>
-#include <iostream>
-#include <random>
-
-int main() {
-  std::default_random_engine generator;
-  std::poisson_distribution<int> distribution(4.1);
-  auto poisson = [&]() { return distribution(generator); };
-
-  Eigen::RowVectorXi v = Eigen::RowVectorXi::NullaryExpr(10, poisson);
-  std::cout << v << "\n";
-}
diff --git a/doc/special_examples/random_generators.cpp b/doc/special_examples/random_generators.cpp
new file mode 100644
index 0000000..00489a1
--- /dev/null
+++ b/doc/special_examples/random_generators.cpp
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <Eigen/Core>
+#include <iostream>
+#include <random>
+
+int main() {
+  std::default_random_engine generator;
+  std::poisson_distribution<int> distribution(4.1);
+  auto poisson = [&]() { return distribution(generator); };
+
+  Eigen::RowVectorXi v = Eigen::RowVectorXi::NullaryExpr(10, poisson);
+  std::cout << v << "\n";
+}
diff --git a/doc/tutorial.cpp b/doc/tutorial.cpp
index 7e58b61..923aef9 100644
--- a/doc/tutorial.cpp
+++ b/doc/tutorial.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <Eigen/Array>
 
 int main(int argc, char *argv[]) {
diff --git a/failtest/CMakeLists.txt b/failtest/CMakeLists.txt
index 107c9e2..afa179a 100644
--- a/failtest/CMakeLists.txt
+++ b/failtest/CMakeLists.txt
@@ -1,6 +1,21 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 ei_add_failtest("failtest_sanity_check")
 
+ei_add_failtest("bool_subtract")
+ei_add_failtest("bool_negate")
+ei_add_failtest("bool_subtract_assign")
+ei_add_failtest("bool_subtract_product")
+ei_add_failtest("bool_subtract_noalias")
+ei_add_failtest("bool_subtract_noalias_gemv")
+ei_add_failtest("bool_subtract_noalias_inner")
+ei_add_failtest("bool_array_subtract")
+ei_add_failtest("bool_array_negate")
+ei_add_failtest("bool_array_subtract_scalar")
+ei_add_failtest("permutation_unsupported_shape")
+ei_add_failtest("transpositions_unsupported_shape")
+
 ei_add_failtest("block_nonconst_ctor_on_const_xpr_0")
 ei_add_failtest("block_nonconst_ctor_on_const_xpr_1")
 ei_add_failtest("block_nonconst_ctor_on_const_xpr_2")
@@ -66,3 +81,28 @@
 ei_add_failtest("eigensolver_cplx")
 ei_add_failtest("initializer_list_1")
 ei_add_failtest("initializer_list_2")
+
+ei_add_failtest("erf_no_scalar_overload")
+ei_add_failtest("erfc_no_scalar_overload")
+ei_add_failtest("vandermonde_int")
+ei_add_failtest("vandermonde_rectangular_square")
+ei_add_failtest("bjorckpereyra_rectangular")
+
+ei_add_failtest("structured_bindings_dynamic_matrix")
+ei_add_failtest("structured_bindings_dynamic_array")
+ei_add_failtest("structured_bindings_rowmajor")
+
+# Structured bindings require C++17 — the header is a no-op otherwise and the
+# "_ok" targets would not compile. Force the standard on these four targets
+# (two per failtest: the _ok and _ko variants).
+foreach(_sb_target
+    structured_bindings_dynamic_matrix_ok structured_bindings_dynamic_matrix_ko
+    structured_bindings_dynamic_array_ok  structured_bindings_dynamic_array_ko
+    structured_bindings_rowmajor_ok       structured_bindings_rowmajor_ko)
+  set_target_properties(${_sb_target} PROPERTIES
+                        CXX_STANDARD 17
+                        CXX_STANDARD_REQUIRED ON
+                        CXX_EXTENSIONS OFF)
+endforeach()
+
+ei_add_failtest_fixture()
diff --git a/failtest/bjorckpereyra_rectangular.cpp b/failtest/bjorckpereyra_rectangular.cpp
new file mode 100644
index 0000000..3f0387e
--- /dev/null
+++ b/failtest/bjorckpereyra_rectangular.cpp
@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../contrib/Eigen/StructuredMatrices"
+
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+constexpr int Cols = 3;
+#else
+constexpr int Cols = 2;
+#endif
+
+int main() {
+  Eigen::Vector2d nodes;
+  nodes << 0.0, 1.0;
+  Eigen::Vandermonde<double, 2, Cols> vandermonde(nodes, Cols);
+  Eigen::BjorckPereyra<double> solver(vandermonde);
+  return static_cast<int>(solver.rows());
+}
diff --git a/failtest/bool_array_negate.cpp b/failtest/bool_array_negate.cpp
new file mode 100644
index 0000000..2af0114
--- /dev/null
+++ b/failtest/bool_array_negate.cpp
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Array<bool, Eigen::Dynamic, 1> a(8);
+  a.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  -a;
+#else
+  -a.cast<int>();
+#endif
+}
diff --git a/failtest/bool_array_subtract.cpp b/failtest/bool_array_subtract.cpp
new file mode 100644
index 0000000..1a2f932
--- /dev/null
+++ b/failtest/bool_array_subtract.cpp
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Array<bool, 2, 1> a, b;
+  a.setOnes();
+  b.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  a - b;
+#else
+  a.cast<int>() - b.cast<int>();
+#endif
+}
diff --git a/failtest/bool_array_subtract_scalar.cpp b/failtest/bool_array_subtract_scalar.cpp
new file mode 100644
index 0000000..c66a215
--- /dev/null
+++ b/failtest/bool_array_subtract_scalar.cpp
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Array<bool, Eigen::Dynamic, 1> a(8);
+  a.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  a - true;
+#else
+  a.cast<int>() - 1;
+#endif
+}
diff --git a/failtest/bool_negate.cpp b/failtest/bool_negate.cpp
new file mode 100644
index 0000000..486143b
--- /dev/null
+++ b/failtest/bool_negate.cpp
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic> a(8, 8);
+  a.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  -a;
+#else
+  -a.cast<int>();
+#endif
+}
diff --git a/failtest/bool_subtract.cpp b/failtest/bool_subtract.cpp
new file mode 100644
index 0000000..c85856d
--- /dev/null
+++ b/failtest/bool_subtract.cpp
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, 2, 2> a, b;
+  a.setOnes();
+  b.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  a - b;
+#else
+  a.cast<int>() - b.cast<int>();
+#endif
+}
diff --git a/failtest/bool_subtract_assign.cpp b/failtest/bool_subtract_assign.cpp
new file mode 100644
index 0000000..c3e5224
--- /dev/null
+++ b/failtest/bool_subtract_assign.cpp
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, 2, 2> a, b;
+  a.setOnes();
+  b.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  a -= b;
+#else
+  Eigen::Matrix2i c = a.cast<int>();
+  c -= b.cast<int>();
+#endif
+}
diff --git a/failtest/bool_subtract_noalias.cpp b/failtest/bool_subtract_noalias.cpp
new file mode 100644
index 0000000..ee27f68
--- /dev/null
+++ b/failtest/bool_subtract_noalias.cpp
@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic> a(8, 8), b(8, 8), c(8, 8);
+  a.setOnes();
+  b.setOnes();
+  c.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  c.noalias() -= a * b;
+#else
+  Eigen::MatrixXi d = c.cast<int>();
+  d.noalias() -= a.cast<int>() * b.cast<int>();
+#endif
+}
diff --git a/failtest/bool_subtract_noalias_gemv.cpp b/failtest/bool_subtract_noalias_gemv.cpp
new file mode 100644
index 0000000..9ddbcf7
--- /dev/null
+++ b/failtest/bool_subtract_noalias_gemv.cpp
@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic> a(8, 8);
+  Eigen::Matrix<bool, Eigen::Dynamic, 1> b(8), c(8);
+  a.setOnes();
+  b.setOnes();
+  c.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  c.noalias() -= a * b;
+#else
+  Eigen::VectorXi d = c.cast<int>();
+  d.noalias() -= a.cast<int>() * b.cast<int>();
+#endif
+}
diff --git a/failtest/bool_subtract_noalias_inner.cpp b/failtest/bool_subtract_noalias_inner.cpp
new file mode 100644
index 0000000..1207dca
--- /dev/null
+++ b/failtest/bool_subtract_noalias_inner.cpp
@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, Eigen::Dynamic, 1> a(8), b(8);
+  Eigen::Matrix<bool, 1, 1> c;
+  a.setOnes();
+  b.setOnes();
+  c.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  c.noalias() -= a.transpose() * b;
+#else
+  Eigen::Matrix<int, 1, 1> d = c.cast<int>();
+  d.noalias() -= a.cast<int>().transpose() * b.cast<int>();
+#endif
+}
diff --git a/failtest/bool_subtract_product.cpp b/failtest/bool_subtract_product.cpp
new file mode 100644
index 0000000..888b790
--- /dev/null
+++ b/failtest/bool_subtract_product.cpp
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic> a(8, 8), b(8, 8);
+  a.setOnes();
+  b.setOnes();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic> c = a * b - a * b;
+#else
+  Eigen::MatrixXi c = a.cast<int>() * b.cast<int>() - a.cast<int>() * b.cast<int>();
+#endif
+}
diff --git a/failtest/erf_no_scalar_overload.cpp b/failtest/erf_no_scalar_overload.cpp
new file mode 100644
index 0000000..edb7ed4
--- /dev/null
+++ b/failtest/erf_no_scalar_overload.cpp
@@ -0,0 +1,24 @@
+#include "../contrib/Eigen/SpecialFunctions"
+
+// A custom scalar that does not provide erf. Eigen's approximations are tuned
+// for float and double and are not valid for it, so numext::erf must be
+// rejected at compile time instead of computing a wrong result.
+namespace custom_scalar {
+struct CustomReal {
+  double value;
+};
+#ifndef EIGEN_SHOULD_FAIL_TO_BUILD
+inline CustomReal erf(const CustomReal& x) { return CustomReal{std::erf(x.value)}; }
+#endif
+}  // namespace custom_scalar
+
+namespace Eigen {
+template <>
+struct NumTraits<custom_scalar::CustomReal> : NumTraits<double> {
+  using Real = custom_scalar::CustomReal;
+  using NonInteger = custom_scalar::CustomReal;
+  using Nested = custom_scalar::CustomReal;
+};
+}  // namespace Eigen
+
+int main() { return Eigen::numext::erf(custom_scalar::CustomReal{0.5}).value > 0.0 ? 0 : 1; }
diff --git a/failtest/erfc_no_scalar_overload.cpp b/failtest/erfc_no_scalar_overload.cpp
new file mode 100644
index 0000000..30f0858
--- /dev/null
+++ b/failtest/erfc_no_scalar_overload.cpp
@@ -0,0 +1,24 @@
+#include "../contrib/Eigen/SpecialFunctions"
+
+// A custom scalar that does not provide erfc. Eigen's approximations are tuned
+// for float and double and are not valid for it, so numext::erfc must be
+// rejected at compile time instead of computing a wrong result.
+namespace custom_scalar {
+struct CustomReal {
+  double value;
+};
+#ifndef EIGEN_SHOULD_FAIL_TO_BUILD
+inline CustomReal erfc(const CustomReal& x) { return CustomReal{std::erfc(x.value)}; }
+#endif
+}  // namespace custom_scalar
+
+namespace Eigen {
+template <>
+struct NumTraits<custom_scalar::CustomReal> : NumTraits<double> {
+  using Real = custom_scalar::CustomReal;
+  using NonInteger = custom_scalar::CustomReal;
+  using Nested = custom_scalar::CustomReal;
+};
+}  // namespace Eigen
+
+int main() { return Eigen::numext::erfc(custom_scalar::CustomReal{0.5}).value > 0.0 ? 0 : 1; }
diff --git a/failtest/permutation_unsupported_shape.cpp b/failtest/permutation_unsupported_shape.cpp
new file mode 100644
index 0000000..58b77f0
--- /dev/null
+++ b/failtest/permutation_unsupported_shape.cpp
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_NO_STATIC_ASSERT
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::PermutationMatrix<2> permutation;
+  permutation.setIdentity();
+  Eigen::Matrix2d matrix = Eigen::Matrix2d::Identity();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  auto operand = matrix.triangularView<Eigen::Lower>();
+#else
+  auto operand = matrix;
+#endif
+  Eigen::Matrix2d result = Eigen::Matrix2d::Constant(42);
+  result.noalias() = Eigen::Product<decltype(permutation), decltype(operand)>(permutation, operand);
+  return result.isIdentity() ? 0 : 1;
+}
diff --git a/failtest/structured_bindings_dynamic_array.cpp b/failtest/structured_bindings_dynamic_array.cpp
new file mode 100644
index 0000000..502484a
--- /dev/null
+++ b/failtest/structured_bindings_dynamic_array.cpp
@@ -0,0 +1,19 @@
+#include "../Eigen/Core"
+
+// Reproduces the "Dynamic-sized Array breaks tuple_size" bug: the Array
+// specialization behaves like the Matrix one — a SFINAE-friendly empty
+// tuple_size (issue #3103), so naming ::value must still fail to compile.
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+#define ROWS Eigen::Dynamic
+#define COLS Eigen::Dynamic
+#else
+#define ROWS 3
+#define COLS 1
+#endif
+
+#include <tuple>
+
+int main() {
+  (void)std::tuple_size<Eigen::Array<double, ROWS, COLS>>::value;
+  return 0;  // Test should pass.
+}
diff --git a/failtest/structured_bindings_dynamic_matrix.cpp b/failtest/structured_bindings_dynamic_matrix.cpp
new file mode 100644
index 0000000..687e41c
--- /dev/null
+++ b/failtest/structured_bindings_dynamic_matrix.cpp
@@ -0,0 +1,19 @@
+#include "../Eigen/Core"
+
+// Reproduces the "Dynamic-sized Matrix breaks tuple_size" bug reported on !2336.
+// tuple_size<MatrixXd> is a SFINAE-friendly empty specialization (issue #3103),
+// so naming ::value outside a SFINAE context must still fail to compile.
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+#define ROWS Eigen::Dynamic
+#define COLS Eigen::Dynamic
+#else
+#define ROWS 3
+#define COLS 1
+#endif
+
+#include <tuple>
+
+int main() {
+  (void)std::tuple_size<Eigen::Matrix<double, ROWS, COLS>>::value;
+  return 0;  // Test should pass.
+}
diff --git a/failtest/structured_bindings_rowmajor.cpp b/failtest/structured_bindings_rowmajor.cpp
new file mode 100644
index 0000000..17a01e6
--- /dev/null
+++ b/failtest/structured_bindings_rowmajor.cpp
@@ -0,0 +1,18 @@
+#include "../Eigen/Core"
+
+// Reproduces the "storage-order footgun" on !2336: get<I>() uses coeffRef(Index),
+// which is linear in storage order, so a RowMajor matrix would silently flip
+// decomposition order vs. the column-major default. We static_assert against
+// RowMajor until the semantics are agreed upon — this failtest guards that.
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+#define STORAGE_ORDER Eigen::RowMajor
+#else
+#define STORAGE_ORDER Eigen::ColMajor
+#endif
+
+int main() {
+  Eigen::Matrix<double, 2, 2, STORAGE_ORDER> m;
+  m << 1, 2, 3, 4;
+  (void)Eigen::get<0>(m);
+  return 0;  // Test should pass.
+}
diff --git a/failtest/transpositions_unsupported_shape.cpp b/failtest/transpositions_unsupported_shape.cpp
new file mode 100644
index 0000000..937a324
--- /dev/null
+++ b/failtest/transpositions_unsupported_shape.cpp
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_NO_STATIC_ASSERT
+#include "../Eigen/Core"
+
+int main() {
+  Eigen::Transpositions<2> transpositions;
+  transpositions.setIdentity();
+  Eigen::Matrix2d matrix = Eigen::Matrix2d::Identity();
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+  auto operand = matrix.triangularView<Eigen::Lower>();
+#else
+  auto operand = matrix;
+#endif
+  Eigen::Matrix2d result = Eigen::Matrix2d::Constant(42);
+  result.noalias() = Eigen::Product<decltype(transpositions), decltype(operand)>(transpositions, operand);
+  return result.isIdentity() ? 0 : 1;
+}
diff --git a/failtest/vandermonde_int.cpp b/failtest/vandermonde_int.cpp
new file mode 100644
index 0000000..99d2f51
--- /dev/null
+++ b/failtest/vandermonde_int.cpp
@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../contrib/Eigen/StructuredMatrices"
+
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+using Scalar = int;
+#else
+using Scalar = double;
+#endif
+
+int main() {
+  Eigen::Matrix<Scalar, 2, 1> nodes;
+  nodes << Scalar(1), Scalar(2);
+  Eigen::Vandermonde<Scalar, 2, 2> vandermonde(nodes);
+  return static_cast<int>(vandermonde.rows());
+}
diff --git a/failtest/vandermonde_rectangular_square.cpp b/failtest/vandermonde_rectangular_square.cpp
new file mode 100644
index 0000000..d7217f8
--- /dev/null
+++ b/failtest/vandermonde_rectangular_square.cpp
@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "../contrib/Eigen/StructuredMatrices"
+
+#ifdef EIGEN_SHOULD_FAIL_TO_BUILD
+constexpr int Cols = 3;
+#else
+constexpr int Cols = 2;
+#endif
+
+int main() {
+  Eigen::Vector2d nodes;
+  nodes << 0.0, 1.0;
+  Eigen::Vandermonde<double, 2, Cols> vandermonde(nodes);
+  return static_cast<int>(vandermonde.cols());
+}
diff --git a/lapack/CMakeLists.txt b/lapack/CMakeLists.txt
index 51bb455..27faa45 100644
--- a/lapack/CMakeLists.txt
+++ b/lapack/CMakeLists.txt
@@ -1,21 +1,33 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 project(EigenLapack CXX)
 
 if(EIGEN_BUILD_LAPACK AND EIGEN_BUILD_BLAS)
 
-include(CheckLanguage)
-check_language(Fortran)
-if(CMAKE_Fortran_COMPILER)
-  enable_language(Fortran)
-  if("${CMAKE_Fortran_COMPILER_ID}" STREQUAL "GNU")
-    if ("${CMAKE_Fortran_COMPILER_VERSION}" VERSION_GREATER_EQUAL 10.0)
-      # We use an old version of LAPACK with argument type mismatches.
-      # Allow them to compile anyway with newer GNU versions.
-      set(CMAKE_Fortran_FLAGS  "${CMAKE_Fortran_FLAGS} -fallow-argument-mismatch")
+option(EIGEN_ENABLE_LAPACK_TESTS "Enable the Lapack unit tests" OFF)
+
+if(EIGEN_ENABLE_LAPACK_TESTS)
+  include(CheckLanguage)
+  check_language(Fortran)
+  if(CMAKE_Fortran_COMPILER)
+    enable_language(Fortran)
+    if("${CMAKE_Fortran_COMPILER_ID}" STREQUAL "GNU")
+      if ("${CMAKE_Fortran_COMPILER_VERSION}" VERSION_GREATER_EQUAL 10.0)
+        # We use an old version of LAPACK with argument type mismatches.
+        # Allow them to compile anyway with newer GNU versions.
+        set(CMAKE_Fortran_FLAGS  "${CMAKE_Fortran_FLAGS} -fallow-argument-mismatch")
+      endif()
     endif()
+    set(EIGEN_Fortran_COMPILER_WORKS ON)
+  else()
+    set(EIGEN_Fortran_COMPILER_WORKS OFF)
   endif()
-  set(EIGEN_Fortran_COMPILER_WORKS ON)
-else()
-  set(EIGEN_Fortran_COMPILER_WORKS OFF)
+
+  if(NOT EIGEN_Fortran_COMPILER_WORKS)
+    message(STATUS "A Fortran compiler was not found; LAPACK unit tests won't be enabled")
+    set(EIGEN_ENABLE_LAPACK_TESTS OFF)
+  endif()
 endif()
 
 add_custom_target(lapack)
@@ -23,36 +35,18 @@
 
 set(EigenLapack_SRCS
   dsecnd_INT_CPU_TIME.cpp second_INT_CPU_TIME.cpp single.cpp double.cpp complex_single.cpp complex_double.cpp
-)
-
-set(EIGEN_LAPACK_DEF "eigen_lapack_cpp.def")
-
-if(EIGEN_Fortran_COMPILER_WORKS)
-
-set(EigenLapack_SRCS  ${EigenLapack_SRCS}
-  slarft.f  dlarft.f  clarft.f  zlarft.f
-  slarfb.f  dlarfb.f  clarfb.f  zlarfb.f
-  slarfg.f  dlarfg.f  clarfg.f  zlarfg.f
-  slarf.f   dlarf.f   clarf.f   zlarf.f
-  sladiv.f  dladiv.f  cladiv.f  zladiv.f
-  ilaslr.f  iladlr.f  ilaclr.f  ilazlr.f
-  ilaslc.f  iladlc.f  ilaclc.f  ilazlc.f
-  dlapy2.f  dlapy3.f  slapy2.f  slapy3.f
-  clacgv.f  zlacgv.f
-  slamch.f  dlamch.f
+  ilaver.cpp
 )
 
 set(EIGEN_LAPACK_DEF "eigen_lapack.def")
 
-option(EIGEN_ENABLE_LAPACK_TESTS OFF "Enable the Lapack unit tests")
-
 if(EIGEN_ENABLE_LAPACK_TESTS)
 
   get_filename_component(eigen_full_path_to_reference_lapack "./reference/" ABSOLUTE)
   if(NOT EXISTS ${eigen_full_path_to_reference_lapack})
     # Download lapack and install sources and testing at the right place
     message(STATUS "Download lapack_addons_3.4.1.tgz...")
-    
+
     file(DOWNLOAD "http://downloads.tuxfamily.org/eigen/lapack_addons_3.4.1.tgz"
                   "${CMAKE_CURRENT_SOURCE_DIR}/lapack_addons_3.4.1.tgz"
                   INACTIVITY_TIMEOUT 15
@@ -60,7 +54,7 @@
                   STATUS download_status
                   EXPECTED_MD5 ab5742640617e3221a873aba44bbdc93
                   SHOW_PROGRESS)
-                  
+
     message(STATUS ${download_status})
     list(GET download_status 0 download_status_num)
     set(download_status_num 0)
@@ -71,9 +65,9 @@
       message(STATUS "Download of lapack_addons_3.4.1.tgz failed, LAPACK unit tests won't be enabled")
       set(EIGEN_ENABLE_LAPACK_TESTS false)
     endif()
-                  
+
   endif()
-  
+
   get_filename_component(eigen_full_path_to_reference_lapack "./reference/" ABSOLUTE)
   if(EXISTS ${eigen_full_path_to_reference_lapack})
     set(EigenLapack_funcfilenames
@@ -81,8 +75,19 @@
         spotrf.f  dpotrf.f  cpotrf.f  zpotrf.f
         spotrs.f  dpotrs.f  cpotrs.f  zpotrs.f
         sgetrf.f  dgetrf.f  cgetrf.f  zgetrf.f
-        sgetrs.f  dgetrs.f  cgetrs.f  zgetrs.f)
-    
+        sgetrs.f  dgetrs.f  cgetrs.f  zgetrs.f
+        slarft.f  dlarft.f  clarft.f  zlarft.f
+        slarfb.f  dlarfb.f  clarfb.f  zlarfb.f
+        slarfg.f  dlarfg.f  clarfg.f  zlarfg.f
+        slarf.f   dlarf.f   clarf.f   zlarf.f
+        sladiv.f  dladiv.f  cladiv.f  zladiv.f
+        ilaslr.f  iladlr.f  ilaclr.f  ilazlr.f
+        ilaslc.f  iladlc.f  ilaclc.f  ilazlc.f
+        dlapy2.f  dlapy3.f  slapy2.f  slapy3.f
+        clacgv.f  zlacgv.f
+        slamch.f  dlamch.f
+        ilaver.f)
+
     file(GLOB ReferenceLapack_SRCS0 RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "reference/*.f")
     foreach(filename1 IN LISTS ReferenceLapack_SRCS0)
       string(REPLACE "reference/" "" filename ${filename1})
@@ -93,9 +98,7 @@
       endif()
     endforeach()
   endif()
-  
-  
-endif()
+
 
 endif()
 
@@ -122,16 +125,18 @@
   endif()
   target_link_libraries(${target} Eigen3::Eigen)
   add_dependencies(lapack ${target})
-  install(TARGETS ${target}
-          RUNTIME DESTINATION bin
-          LIBRARY DESTINATION lib
-          ARCHIVE DESTINATION lib)
+  if(EIGEN_INSTALL)
+    install(TARGETS ${target}
+            RUNTIME DESTINATION bin
+            LIBRARY DESTINATION lib
+            ARCHIVE DESTINATION lib)
+  endif()
 endforeach()
 
 
 get_filename_component(eigen_full_path_to_testing_lapack "./testing/" ABSOLUTE)
-if(EXISTS ${eigen_full_path_to_testing_lapack})
-  
+if(EIGEN_ENABLE_LAPACK_TESTS AND EXISTS ${eigen_full_path_to_testing_lapack})
+
   # The following comes from lapack/TESTING/CMakeLists.txt
   # Get Python
   find_package(PythonInterp)
@@ -145,8 +150,8 @@
   set(BUILD_SINGLE      true)
   set(BUILD_DOUBLE      true)
   set(BUILD_COMPLEX     true)
-  set(BUILD_COMPLEX16E  true)
-  
+  set(BUILD_COMPLEX16   true)
+
   if(MSVC_VERSION)
 #  string(REPLACE "/STACK:10000000" "/STACK:900000000000000000"
 #    CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
@@ -167,8 +172,8 @@
       add_test(NAME LAPACK-${testName}
         COMMAND "${CMAKE_COMMAND}"
         -DTEST=$<TARGET_FILE:${target}>
-        -DINPUT=${TEST_INPUT} 
-        -DOUTPUT=${TEST_OUTPUT} 
+        -DINPUT=${TEST_INPUT}
+        -DOUTPUT=${TEST_OUTPUT}
         -DINTDIR=${CMAKE_CFG_INTDIR}
         -P "${LAPACK_SOURCE_DIR}/testing/runtest.cmake")
     endif()
@@ -460,7 +465,11 @@
 
   # ==============================================================================
 
-  execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${LAPACK_SOURCE_DIR}/testing/lapack_testing.py ${LAPACK_BINARY_DIR})
+  if(EXISTS "${LAPACK_SOURCE_DIR}/lapack_testing.py")
+    execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${LAPACK_SOURCE_DIR}/lapack_testing.py ${LAPACK_BINARY_DIR})
+  else()
+    execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${LAPACK_SOURCE_DIR}/testing/lapack_testing.py ${LAPACK_BINARY_DIR})
+  endif()
   add_test(
     NAME LAPACK_Test_Summary
     WORKING_DIRECTORY ${LAPACK_BINARY_DIR}
diff --git a/lapack/blaswrap.h b/lapack/blaswrap.h
deleted file mode 100644
index 4f7c71e..0000000
--- a/lapack/blaswrap.h
+++ /dev/null
@@ -1,2 +0,0 @@
-// This is an empty file by design to make the clapack functions in this
-// directory compile without modification. 
diff --git a/lapack/cholesky.inc b/lapack/cholesky.inc
index 695d3b8..d0f934e 100644
--- a/lapack/cholesky.inc
+++ b/lapack/cholesky.inc
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "lapack_common.h"
 #include <Eigen/Cholesky>
@@ -21,7 +22,7 @@
     *info = -4;
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "POTRF", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "POTRF", &e, kBlasNameLength);
   }
 
   Scalar *a = reinterpret_cast<Scalar *>(pa);
@@ -53,7 +54,7 @@
     *info = -7;
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "POTRS", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "POTRS", &e, kBlasNameLength);
   }
 
   Scalar *a = reinterpret_cast<Scalar *>(pa);
diff --git a/lapack/clacgv.c b/lapack/clacgv.c
deleted file mode 100644
index 896d313..0000000
--- a/lapack/clacgv.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* clacgv.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline void r_cnjg(complex *r, complex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void clacgv_(integer *n, complex *x, integer *incx) {
-  /* System generated locals */
-  integer i__1, i__2;
-  complex q__1;
-
-  /* Local variables */
-  integer i__, ioff;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CLACGV conjugates a complex vector of length N. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N       (input) INTEGER */
-  /*          The length of the vector X.  N >= 0. */
-
-  /*  X       (input/output) COMPLEX array, dimension */
-  /*                         (1+(N-1)*abs(INCX)) */
-  /*          On entry, the vector of length N to be conjugated. */
-  /*          On exit, X is overwritten with conjg(X). */
-
-  /*  INCX    (input) INTEGER */
-  /*          The spacing between successive elements of X. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --x;
-
-  /* Function Body */
-  if (*incx == 1) {
-    i__1 = *n;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      i__2 = i__;
-      r_cnjg(&q__1, &x[i__]);
-      x[i__2].r = q__1.r, x[i__2].i = q__1.i;
-      /* L10: */
-    }
-  } else {
-    ioff = 1;
-    if (*incx < 0) {
-      ioff = 1 - (*n - 1) * *incx;
-    }
-    i__1 = *n;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      i__2 = ioff;
-      r_cnjg(&q__1, &x[ioff]);
-      x[i__2].r = q__1.r, x[i__2].i = q__1.i;
-      ioff += *incx;
-      /* L20: */
-    }
-  }
-
-  /*     End of CLACGV */
-
-} /* clacgv_ */
diff --git a/lapack/cladiv.c b/lapack/cladiv.c
deleted file mode 100644
index e6a0b0d..0000000
--- a/lapack/cladiv.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/* cladiv.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Complex */ void cladiv_(complex *ret_val, complex *x, complex *y) {
-  /* System generated locals */
-  real r__1, r__2, r__3, r__4;
-  complex q__1;
-
-  /* Local variables */
-  real zi, zr;
-  extern /* Subroutine */ void sladiv_(real *, real *, real *, real *, real *, real *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CLADIV := X / Y, where X and Y are complex.  The computation of X / Y */
-  /*  will not overflow on an intermediary step unless the results */
-  /*  overflows. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  X       (input) COMPLEX */
-  /*  Y       (input) COMPLEX */
-  /*          The complex scalars X and Y. */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  r__1 = x->r;
-  r__2 = x->i;
-  r__3 = y->r;
-  r__4 = y->i;
-  sladiv_(&r__1, &r__2, &r__3, &r__4, &zr, &zi);
-  q__1.r = zr, q__1.i = zi;
-  ret_val->r = q__1.r, ret_val->i = q__1.i;
-
-  /*     End of CLADIV */
-
-} /* cladiv_ */
diff --git a/lapack/clarf.c b/lapack/clarf.c
deleted file mode 100644
index 0be36cd..0000000
--- a/lapack/clarf.c
+++ /dev/null
@@ -1,185 +0,0 @@
-/* clarf.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static complex c_b1 = {1.f, 0.f};
-static complex c_b2 = {0.f, 0.f};
-static integer c__1 = 1;
-
-/* Subroutine */ void clarf_(char *side, integer *m, integer *n, complex *v, integer *incv, complex *tau, complex *c__,
-                             integer *ldc, complex *work) {
-  /* System generated locals */
-  integer c_dim1, c_offset, i__1;
-  complex q__1;
-
-  /* Local variables */
-  integer i__;
-  logical applyleft;
-  extern /* Subroutine */ void cgerc_(integer *, integer *, complex *, complex *, integer *, complex *, integer *,
-                                      complex *, integer *),
-      cgemv_(const char *, const integer *, const integer *, const complex *, const complex *, const integer *,
-             const complex *, const integer *, const complex *, complex *, const integer *);
-  extern logical lsame_(char *, char *);
-  integer lastc, lastv;
-  extern integer ilaclc_(integer *, integer *, complex *, integer *),
-      ilaclr_(integer *, integer *, complex *, integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CLARF applies a complex elementary reflector H to a complex M-by-N */
-  /*  matrix C, from either the left or the right. H is represented in the */
-  /*  form */
-
-  /*        H = I - tau * v * v' */
-
-  /*  where tau is a complex scalar and v is a complex vector. */
-
-  /*  If tau = 0, then H is taken to be the unit matrix. */
-
-  /*  To apply H' (the conjugate transpose of H), supply conjg(tau) instead */
-  /*  tau. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': form  H * C */
-  /*          = 'R': form  C * H */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  V       (input) COMPLEX array, dimension */
-  /*                     (1 + (M-1)*abs(INCV)) if SIDE = 'L' */
-  /*                  or (1 + (N-1)*abs(INCV)) if SIDE = 'R' */
-  /*          The vector v in the representation of H. V is not used if */
-  /*          TAU = 0. */
-
-  /*  INCV    (input) INTEGER */
-  /*          The increment between elements of v. INCV <> 0. */
-
-  /*  TAU     (input) COMPLEX */
-  /*          The value tau in the representation of H. */
-
-  /*  C       (input/output) COMPLEX array, dimension (LDC,N) */
-  /*          On entry, the M-by-N matrix C. */
-  /*          On exit, C is overwritten by the matrix H * C if SIDE = 'L', */
-  /*          or C * H if SIDE = 'R'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDC >= max(1,M). */
-
-  /*  WORK    (workspace) COMPLEX array, dimension */
-  /*                         (N) if SIDE = 'L' */
-  /*                      or (M) if SIDE = 'R' */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --v;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  --work;
-
-  /* Function Body */
-  applyleft = lsame_(side, "L");
-  lastv = 0;
-  lastc = 0;
-  if (tau->r != 0.f || tau->i != 0.f) {
-    /*     Set up variables for scanning V.  LASTV begins pointing to the end */
-    /*     of V. */
-    if (applyleft) {
-      lastv = *m;
-    } else {
-      lastv = *n;
-    }
-    if (*incv > 0) {
-      i__ = (lastv - 1) * *incv + 1;
-    } else {
-      i__ = 1;
-    }
-    /*     Look for the last non-zero row in V. */
-    for (;;) { /* while(complicated condition) */
-      i__1 = i__;
-      if (!(lastv > 0 && (v[i__1].r == 0.f && v[i__1].i == 0.f))) break;
-      --lastv;
-      i__ -= *incv;
-    }
-    if (applyleft) {
-      /*     Scan for the last non-zero column in C(1:lastv,:). */
-      lastc = ilaclc_(&lastv, n, &c__[c_offset], ldc);
-    } else {
-      /*     Scan for the last non-zero row in C(:,1:lastv). */
-      lastc = ilaclr_(m, &lastv, &c__[c_offset], ldc);
-    }
-  }
-  /*     Note that lastc.eq.0 renders the BLAS operations null; no special */
-  /*     case is needed at this level. */
-  if (applyleft) {
-    /*        Form  H * C */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1) */
-
-      cgemv_("Conjugate transpose", &lastv, &lastc, &c_b1, &c__[c_offset], ldc, &v[1], incv, &c_b2, &work[1], &c__1);
-
-      /*           C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)' */
-
-      q__1.r = -tau->r, q__1.i = -tau->i;
-      cgerc_(&lastv, &lastc, &q__1, &v[1], incv, &work[1], &c__1, &c__[c_offset], ldc);
-    }
-  } else {
-    /*        Form  C * H */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastc,1:lastv) * v(1:lastv,1) */
-
-      cgemv_("No transpose", &lastc, &lastv, &c_b1, &c__[c_offset], ldc, &v[1], incv, &c_b2, &work[1], &c__1);
-
-      /*           C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)' */
-
-      q__1.r = -tau->r, q__1.i = -tau->i;
-      cgerc_(&lastc, &lastv, &q__1, &work[1], &c__1, &v[1], incv, &c__[c_offset], ldc);
-    }
-  }
-
-  /*     End of CLARF */
-
-} /* clarf_ */
diff --git a/lapack/clarfb.c b/lapack/clarfb.c
deleted file mode 100644
index 72fd915..0000000
--- a/lapack/clarfb.c
+++ /dev/null
@@ -1,736 +0,0 @@
-/* clarfb.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline void r_cnjg(complex *r, complex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Table of constant values */
-
-static complex c_b1 = {1.f, 0.f};
-static integer c__1 = 1;
-
-/* Subroutine */ void clarfb_(char *side, char *trans, char *direct, char *storev, integer *m, integer *n, integer *k,
-                              complex *v, integer *ldv, complex *t, integer *ldt, complex *c__, integer *ldc,
-                              complex *work, integer *ldwork) {
-  /* System generated locals */
-  integer c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1, work_offset, i__1, i__2, i__3, i__4, i__5;
-  complex q__1, q__2;
-
-  /* Local variables */
-  integer i__, j;
-  extern /* Subroutine */ void cgemm_(const char *, const char *, const integer *, const integer *, const integer *,
-                                      const complex *, const complex *, const integer *, const complex *,
-                                      const integer *, const complex *, complex *, const integer *);
-  extern logical lsame_(char *, char *);
-  integer lastc;
-  extern /* Subroutine */ void ccopy_(integer *, complex *, integer *, complex *, integer *),
-      ctrmm_(const char *, const char *, const char *, const char *, const integer *, const integer *, const complex *,
-             const complex *, const integer *, complex *, const integer *);
-  integer lastv;
-  extern integer ilaclc_(integer *, integer *, complex *, integer *);
-  extern /* Subroutine */ void clacgv_(integer *, complex *, integer *);
-  extern integer ilaclr_(integer *, integer *, complex *, integer *);
-  char transt[1];
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CLARFB applies a complex block reflector H or its transpose H' to a */
-  /*  complex M-by-N matrix C, from either the left or the right. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': apply H or H' from the Left */
-  /*          = 'R': apply H or H' from the Right */
-
-  /*  TRANS   (input) CHARACTER*1 */
-  /*          = 'N': apply H (No transpose) */
-  /*          = 'C': apply H' (Conjugate transpose) */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Indicates how H is formed from a product of elementary */
-  /*          reflectors */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Indicates how the vectors which define the elementary */
-  /*          reflectors are stored: */
-  /*          = 'C': Columnwise */
-  /*          = 'R': Rowwise */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the matrix T (= the number of elementary */
-  /*          reflectors whose product defines the block reflector). */
-
-  /*  V       (input) COMPLEX array, dimension */
-  /*                                (LDV,K) if STOREV = 'C' */
-  /*                                (LDV,M) if STOREV = 'R' and SIDE = 'L' */
-  /*                                (LDV,N) if STOREV = 'R' and SIDE = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M); */
-  /*          if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N); */
-  /*          if STOREV = 'R', LDV >= K. */
-
-  /*  T       (input) COMPLEX array, dimension (LDT,K) */
-  /*          The triangular K-by-K matrix T in the representation of the */
-  /*          block reflector. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  C       (input/output) COMPLEX array, dimension (LDC,N) */
-  /*          On entry, the M-by-N matrix C. */
-  /*          On exit, C is overwritten by H*C or H'*C or C*H or C*H'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDC >= max(1,M). */
-
-  /*  WORK    (workspace) COMPLEX array, dimension (LDWORK,K) */
-
-  /*  LDWORK  (input) INTEGER */
-  /*          The leading dimension of the array WORK. */
-  /*          If SIDE = 'L', LDWORK >= max(1,N); */
-  /*          if SIDE = 'R', LDWORK >= max(1,M). */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  work_dim1 = *ldwork;
-  work_offset = 1 + work_dim1;
-  work -= work_offset;
-
-  /* Function Body */
-  if (*m <= 0 || *n <= 0) {
-    return;
-  }
-
-  if (lsame_(trans, "N")) {
-    *(unsigned char *)transt = 'C';
-  } else {
-    *(unsigned char *)transt = 'N';
-  }
-
-  if (lsame_(storev, "C")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1 )    (first K rows) */
-      /*                     ( V2 ) */
-      /*           where  V1  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          clacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L10: */
-        }
-
-        /*              W := W * V1 */
-
-        ctrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2 */
-
-          i__1 = lastv - *k;
-          cgemm_("Conjugate transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[*k + 1 + c_dim1], ldc,
-                 &v[*k + 1 + v_dim1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ctrmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (*m > *k) {
-          /*                 C2 := C2 - V2 * W' */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("No transpose", "Conjugate transpose", &i__1, &lastc, k, &q__1, &v[*k + 1 + v_dim1], ldv,
-                 &work[work_offset], ldwork, &c_b1, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = j + i__ * c_dim1;
-            i__4 = j + i__ * c_dim1;
-            r_cnjg(&q__2, &work[i__ + j * work_dim1]);
-            q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i - q__2.i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L20: */
-          }
-          /* L30: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L40: */
-        }
-
-        /*              W := W * V1 */
-
-        ctrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2 */
-
-          i__1 = lastv - *k;
-          cgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[*k + 1 + v_dim1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ctrmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2' */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("No transpose", "Conjugate transpose", &lastc, &i__1, k, &q__1, &work[work_offset], ldwork,
-                 &v[*k + 1 + v_dim1], ldv, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + j * c_dim1;
-            i__4 = i__ + j * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L50: */
-          }
-          /* L60: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1 ) */
-      /*                     ( V2 )    (last K rows) */
-      /*           where  V2  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          clacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L70: */
-        }
-
-        /*              W := W * V2 */
-
-        ctrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1 */
-
-          i__1 = lastv - *k;
-          cgemm_("Conjugate transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset], ldv,
-                 &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ctrmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1 * W' */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("No transpose", "Conjugate transpose", &i__1, &lastc, k, &q__1, &v[v_offset], ldv, &work[work_offset],
-                 ldwork, &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = lastv - *k + j + i__ * c_dim1;
-            i__4 = lastv - *k + j + i__ * c_dim1;
-            r_cnjg(&q__2, &work[i__ + j * work_dim1]);
-            q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i - q__2.i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L80: */
-          }
-          /* L90: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[(lastv - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L100: */
-        }
-
-        /*              W := W * V2 */
-
-        ctrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1 */
-
-          i__1 = lastv - *k;
-          cgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b1,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ctrmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1' */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("No transpose", "Conjugate transpose", &lastc, &i__1, k, &q__1, &work[work_offset], ldwork,
-                 &v[v_offset], ldv, &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + (lastv - *k + j) * c_dim1;
-            i__4 = i__ + (lastv - *k + j) * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L110: */
-          }
-          /* L120: */
-        }
-      }
-    }
-
-  } else if (lsame_(storev, "R")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1  V2 )    (V1: first K columns) */
-      /*           where  V1  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          clacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L130: */
-        }
-
-        /*              W := W * V1' */
-
-        ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2' */
-
-          i__1 = lastv - *k;
-          cgemm_("Conjugate transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[*k + 1 + c_dim1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ctrmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - V2' * W' */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("Conjugate transpose", "Conjugate transpose", &i__1, &lastc, k, &q__1, &v[(*k + 1) * v_dim1 + 1], ldv,
-                 &work[work_offset], ldwork, &c_b1, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        ctrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = j + i__ * c_dim1;
-            i__4 = j + i__ * c_dim1;
-            r_cnjg(&q__2, &work[i__ + j * work_dim1]);
-            q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i - q__2.i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L140: */
-          }
-          /* L150: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L160: */
-        }
-
-        /*              W := W * V1' */
-
-        ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2' */
-
-          i__1 = lastv - *k;
-          cgemm_("No transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ctrmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2 */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("No transpose", "No transpose", &lastc, &i__1, k, &q__1, &work[work_offset], ldwork,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        ctrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + j * c_dim1;
-            i__4 = i__ + j * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L170: */
-          }
-          /* L180: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1  V2 )    (V2: last K columns) */
-      /*           where  V2  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          clacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L190: */
-        }
-
-        /*              W := W * V2' */
-
-        ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1],
-               ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1' */
-
-          i__1 = lastv - *k;
-          cgemm_("Conjugate transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc,
-                 &v[v_offset], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ctrmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1' * W' */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("Conjugate transpose", "Conjugate transpose", &i__1, &lastc, k, &q__1, &v[v_offset], ldv,
-                 &work[work_offset], ldwork, &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        ctrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = lastv - *k + j + i__ * c_dim1;
-            i__4 = lastv - *k + j + i__ * c_dim1;
-            r_cnjg(&q__2, &work[i__ + j * work_dim1]);
-            q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i - q__2.i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L200: */
-          }
-          /* L210: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaclc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaclr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          ccopy_(&lastc, &c__[(lastv - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L220: */
-        }
-
-        /*              W := W * V2' */
-
-        ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1],
-               ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1' */
-
-          i__1 = lastv - *k;
-          cgemm_("No transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset], ldv,
-                 &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ctrmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1 */
-
-          i__1 = lastv - *k;
-          q__1.r = -1.f, q__1.i = -0.f;
-          cgemm_("No transpose", "No transpose", &lastc, &i__1, k, &q__1, &work[work_offset], ldwork, &v[v_offset], ldv,
-                 &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        ctrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + (lastv - *k + j) * c_dim1;
-            i__4 = i__ + (lastv - *k + j) * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
-            /* L230: */
-          }
-          /* L240: */
-        }
-      }
-    }
-  }
-
-  /*     End of CLARFB */
-
-} /* clarfb_ */
diff --git a/lapack/clarfg.c b/lapack/clarfg.c
deleted file mode 100644
index 69bfd94..0000000
--- a/lapack/clarfg.c
+++ /dev/null
@@ -1,182 +0,0 @@
-/* clarfg.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline real r_sign(real *a, real *b) {
-  real x;
-  x = (*a >= 0 ? *a : -*a);
-  return (*b >= 0 ? x : -x);
-}
-
-/* Table of constant values */
-
-static complex c_b5 = {1.f, 0.f};
-
-/* Subroutine */ void clarfg_(integer *n, complex *alpha, complex *x, integer *incx, complex *tau) {
-  /* System generated locals */
-  integer i__1;
-  real r__1, r__2;
-  complex q__1, q__2;
-
-  /* Local variables */
-  integer j, knt;
-  real beta;
-  extern /* Subroutine */ void cscal_(integer *, complex *, complex *, integer *);
-  real alphi, alphr, xnorm;
-  extern real scnrm2_(integer *, complex *, integer *), slapy3_(real *, real *, real *);
-  extern /* Complex */ void cladiv_(complex *, complex *, complex *);
-  extern doublereal slamch_(char *);
-  extern /* Subroutine */ void csscal_(integer *, real *, complex *, integer *);
-  real safmin, rsafmn;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CLARFG generates a complex elementary reflector H of order n, such */
-  /*  that */
-
-  /*        H' * ( alpha ) = ( beta ),   H' * H = I. */
-  /*             (   x   )   (   0  ) */
-
-  /*  where alpha and beta are scalars, with beta real, and x is an */
-  /*  (n-1)-element complex vector. H is represented in the form */
-
-  /*        H = I - tau * ( 1 ) * ( 1 v' ) , */
-  /*                      ( v ) */
-
-  /*  where tau is a complex scalar and v is a complex (n-1)-element */
-  /*  vector. Note that H is not hermitian. */
-
-  /*  If the elements of x are all zero and alpha is real, then tau = 0 */
-  /*  and H is taken to be the unit matrix. */
-
-  /*  Otherwise  1 <= real(tau) <= 2  and  abs(tau-1) <= 1 . */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the elementary reflector. */
-
-  /*  ALPHA   (input/output) COMPLEX */
-  /*          On entry, the value alpha. */
-  /*          On exit, it is overwritten with the value beta. */
-
-  /*  X       (input/output) COMPLEX array, dimension */
-  /*                         (1+(N-2)*abs(INCX)) */
-  /*          On entry, the vector x. */
-  /*          On exit, it is overwritten with the vector v. */
-
-  /*  INCX    (input) INTEGER */
-  /*          The increment between elements of X. INCX > 0. */
-
-  /*  TAU     (output) COMPLEX */
-  /*          The value tau. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --x;
-
-  /* Function Body */
-  if (*n <= 0) {
-    tau->r = 0.f, tau->i = 0.f;
-    return;
-  }
-
-  i__1 = *n - 1;
-  xnorm = scnrm2_(&i__1, &x[1], incx);
-  alphr = alpha->r;
-  alphi = alpha->i;
-
-  if (xnorm == 0.f && alphi == 0.f) {
-    /*        H  =  I */
-
-    tau->r = 0.f, tau->i = 0.f;
-  } else {
-    /*        general case */
-
-    r__1 = slapy3_(&alphr, &alphi, &xnorm);
-    beta = -r_sign(&r__1, &alphr);
-    safmin = slamch_("S") / slamch_("E");
-    rsafmn = 1.f / safmin;
-
-    knt = 0;
-    if (dabs(beta) < safmin) {
-      /*           XNORM, BETA may be inaccurate; scale X and recompute them */
-
-    L10:
-      ++knt;
-      i__1 = *n - 1;
-      csscal_(&i__1, &rsafmn, &x[1], incx);
-      beta *= rsafmn;
-      alphi *= rsafmn;
-      alphr *= rsafmn;
-      if (dabs(beta) < safmin) {
-        goto L10;
-      }
-
-      /*           New BETA is at most 1, at least SAFMIN */
-
-      i__1 = *n - 1;
-      xnorm = scnrm2_(&i__1, &x[1], incx);
-      q__1.r = alphr, q__1.i = alphi;
-      alpha->r = q__1.r, alpha->i = q__1.i;
-      r__1 = slapy3_(&alphr, &alphi, &xnorm);
-      beta = -r_sign(&r__1, &alphr);
-    }
-    r__1 = (beta - alphr) / beta;
-    r__2 = -alphi / beta;
-    q__1.r = r__1, q__1.i = r__2;
-    tau->r = q__1.r, tau->i = q__1.i;
-    q__2.r = alpha->r - beta, q__2.i = alpha->i;
-    cladiv_(&q__1, &c_b5, &q__2);
-    alpha->r = q__1.r, alpha->i = q__1.i;
-    i__1 = *n - 1;
-    cscal_(&i__1, alpha, &x[1], incx);
-
-    /*        If ALPHA is subnormal, it may lose relative accuracy */
-
-    i__1 = knt;
-    for (j = 1; j <= i__1; ++j) {
-      beta *= safmin;
-      /* L20: */
-    }
-    alpha->r = beta, alpha->i = 0.f;
-  }
-
-  /*     End of CLARFG */
-
-} /* clarfg_ */
diff --git a/lapack/clarft.c b/lapack/clarft.c
deleted file mode 100644
index 3a5efd5..0000000
--- a/lapack/clarft.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/* clarft.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static complex c_b2 = {0.f, 0.f};
-static integer c__1 = 1;
-
-/* Subroutine */ void clarft_(char *direct, char *storev, integer *n, integer *k, complex *v, integer *ldv,
-                              complex *tau, complex *t, integer *ldt) {
-  /* System generated locals */
-  integer t_dim1, t_offset, v_dim1, v_offset, i__1, i__2, i__3, i__4;
-  complex q__1;
-
-  /* Local variables */
-  integer i__, j, prevlastv;
-  complex vii;
-  extern /* Subroutine */ void cgemv_(const char *, const integer *, const integer *, const complex *, const complex *,
-                                      const integer *, const complex *, const integer *, const complex *, complex *,
-                                      const integer *);
-  extern logical lsame_(char *, char *);
-  integer lastv;
-  extern /* Subroutine */ void ctrmv_(const char *, const char *, const char *, const integer *, const complex *,
-                                      const integer *, complex *, const integer *),
-      clacgv_(integer *, complex *, integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  CLARFT forms the triangular factor T of a complex block reflector H */
-  /*  of order n, which is defined as a product of k elementary reflectors. */
-
-  /*  If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; */
-
-  /*  If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. */
-
-  /*  If STOREV = 'C', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th column of the array V, and */
-
-  /*     H  =  I - V * T * V' */
-
-  /*  If STOREV = 'R', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th row of the array V, and */
-
-  /*     H  =  I - V' * T * V */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Specifies the order in which the elementary reflectors are */
-  /*          multiplied to form the block reflector: */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Specifies how the vectors which define the elementary */
-  /*          reflectors are stored (see also Further Details): */
-  /*          = 'C': columnwise */
-  /*          = 'R': rowwise */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the block reflector H. N >= 0. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the triangular factor T (= the number of */
-  /*          elementary reflectors). K >= 1. */
-
-  /*  V       (input/output) COMPLEX array, dimension */
-  /*                               (LDV,K) if STOREV = 'C' */
-  /*                               (LDV,N) if STOREV = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K. */
-
-  /*  TAU     (input) COMPLEX array, dimension (K) */
-  /*          TAU(i) must contain the scalar factor of the elementary */
-  /*          reflector H(i). */
-
-  /*  T       (output) COMPLEX array, dimension (LDT,K) */
-  /*          The k by k triangular factor T of the block reflector. */
-  /*          If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is */
-  /*          lower triangular. The rest of the array is not used. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The shape of the matrix V and the storage of the vectors which define */
-  /*  the H(i) is best illustrated by the following example with n = 5 and */
-  /*  k = 3. The elements equal to 1 are not stored; the corresponding */
-  /*  array elements are modified but restored on exit. The rest of the */
-  /*  array is not used. */
-
-  /*  DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R': */
-
-  /*               V = (  1       )                 V = (  1 v1 v1 v1 v1 ) */
-  /*                   ( v1  1    )                     (     1 v2 v2 v2 ) */
-  /*                   ( v1 v2  1 )                     (        1 v3 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-
-  /*  DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R': */
-
-  /*               V = ( v1 v2 v3 )                 V = ( v1 v1  1       ) */
-  /*                   ( v1 v2 v3 )                     ( v2 v2 v2  1    ) */
-  /*                   (  1 v2 v3 )                     ( v3 v3 v3 v3  1 ) */
-  /*                   (     1 v3 ) */
-  /*                   (        1 ) */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  --tau;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-
-  /* Function Body */
-  if (*n == 0) {
-    return;
-  }
-
-  if (lsame_(direct, "F")) {
-    prevlastv = *n;
-    i__1 = *k;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      prevlastv = max(prevlastv, i__);
-      i__2 = i__;
-      if (tau[i__2].r == 0.f && tau[i__2].i == 0.f) {
-        /*              H(i)  =  I */
-
-        i__2 = i__;
-        for (j = 1; j <= i__2; ++j) {
-          i__3 = j + i__ * t_dim1;
-          t[i__3].r = 0.f, t[i__3].i = 0.f;
-          /* L10: */
-        }
-      } else {
-        /*              general case */
-
-        i__2 = i__ + i__ * v_dim1;
-        vii.r = v[i__2].r, vii.i = v[i__2].i;
-        i__2 = i__ + i__ * v_dim1;
-        v[i__2].r = 1.f, v[i__2].i = 0.f;
-        if (lsame_(storev, "C")) {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            i__3 = lastv + i__ * v_dim1;
-            if (v[i__3].r != 0.f || v[i__3].i != 0.f) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i) */
-
-          i__2 = j - i__ + 1;
-          i__3 = i__ - 1;
-          i__4 = i__;
-          q__1.r = -tau[i__4].r, q__1.i = -tau[i__4].i;
-          cgemv_("Conjugate transpose", &i__2, &i__3, &q__1, &v[i__ + v_dim1], ldv, &v[i__ + i__ * v_dim1], &c__1,
-                 &c_b2, &t[i__ * t_dim1 + 1], &c__1);
-        } else {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            i__3 = i__ + lastv * v_dim1;
-            if (v[i__3].r != 0.f || v[i__3].i != 0.f) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)' */
-
-          if (i__ < j) {
-            i__2 = j - i__;
-            clacgv_(&i__2, &v[i__ + (i__ + 1) * v_dim1], ldv);
-          }
-          i__2 = i__ - 1;
-          i__3 = j - i__ + 1;
-          i__4 = i__;
-          q__1.r = -tau[i__4].r, q__1.i = -tau[i__4].i;
-          cgemv_("No transpose", &i__2, &i__3, &q__1, &v[i__ * v_dim1 + 1], ldv, &v[i__ + i__ * v_dim1], ldv, &c_b2,
-                 &t[i__ * t_dim1 + 1], &c__1);
-          if (i__ < j) {
-            i__2 = j - i__;
-            clacgv_(&i__2, &v[i__ + (i__ + 1) * v_dim1], ldv);
-          }
-        }
-        i__2 = i__ + i__ * v_dim1;
-        v[i__2].r = vii.r, v[i__2].i = vii.i;
-
-        /*              T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i) */
-
-        i__2 = i__ - 1;
-        ctrmv_("Upper", "No transpose", "Non-unit", &i__2, &t[t_offset], ldt, &t[i__ * t_dim1 + 1], &c__1);
-        i__2 = i__ + i__ * t_dim1;
-        i__3 = i__;
-        t[i__2].r = tau[i__3].r, t[i__2].i = tau[i__3].i;
-        if (i__ > 1) {
-          prevlastv = max(prevlastv, lastv);
-        } else {
-          prevlastv = lastv;
-        }
-      }
-      /* L20: */
-    }
-  } else {
-    prevlastv = 1;
-    for (i__ = *k; i__ >= 1; --i__) {
-      i__1 = i__;
-      if (tau[i__1].r == 0.f && tau[i__1].i == 0.f) {
-        /*              H(i)  =  I */
-
-        i__1 = *k;
-        for (j = i__; j <= i__1; ++j) {
-          i__2 = j + i__ * t_dim1;
-          t[i__2].r = 0.f, t[i__2].i = 0.f;
-          /* L30: */
-        }
-      } else {
-        /*              general case */
-
-        if (i__ < *k) {
-          if (lsame_(storev, "C")) {
-            i__1 = *n - *k + i__ + i__ * v_dim1;
-            vii.r = v[i__1].r, vii.i = v[i__1].i;
-            i__1 = *n - *k + i__ + i__ * v_dim1;
-            v[i__1].r = 1.f, v[i__1].i = 0.f;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              i__2 = lastv + i__ * v_dim1;
-              if (v[i__2].r != 0.f || v[i__2].i != 0.f) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i) */
-
-            i__1 = *n - *k + i__ - j + 1;
-            i__2 = *k - i__;
-            i__3 = i__;
-            q__1.r = -tau[i__3].r, q__1.i = -tau[i__3].i;
-            cgemv_("Conjugate transpose", &i__1, &i__2, &q__1, &v[j + (i__ + 1) * v_dim1], ldv, &v[j + i__ * v_dim1],
-                   &c__1, &c_b2, &t[i__ + 1 + i__ * t_dim1], &c__1);
-            i__1 = *n - *k + i__ + i__ * v_dim1;
-            v[i__1].r = vii.r, v[i__1].i = vii.i;
-          } else {
-            i__1 = i__ + (*n - *k + i__) * v_dim1;
-            vii.r = v[i__1].r, vii.i = v[i__1].i;
-            i__1 = i__ + (*n - *k + i__) * v_dim1;
-            v[i__1].r = 1.f, v[i__1].i = 0.f;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              i__2 = i__ + lastv * v_dim1;
-              if (v[i__2].r != 0.f || v[i__2].i != 0.f) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)' */
-
-            i__1 = *n - *k + i__ - 1 - j + 1;
-            clacgv_(&i__1, &v[i__ + j * v_dim1], ldv);
-            i__1 = *k - i__;
-            i__2 = *n - *k + i__ - j + 1;
-            i__3 = i__;
-            q__1.r = -tau[i__3].r, q__1.i = -tau[i__3].i;
-            cgemv_("No transpose", &i__1, &i__2, &q__1, &v[i__ + 1 + j * v_dim1], ldv, &v[i__ + j * v_dim1], ldv, &c_b2,
-                   &t[i__ + 1 + i__ * t_dim1], &c__1);
-            i__1 = *n - *k + i__ - 1 - j + 1;
-            clacgv_(&i__1, &v[i__ + j * v_dim1], ldv);
-            i__1 = i__ + (*n - *k + i__) * v_dim1;
-            v[i__1].r = vii.r, v[i__1].i = vii.i;
-          }
-
-          /*                 T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i) */
-
-          i__1 = *k - i__;
-          ctrmv_("Lower", "No transpose", "Non-unit", &i__1, &t[i__ + 1 + (i__ + 1) * t_dim1], ldt,
-                 &t[i__ + 1 + i__ * t_dim1], &c__1);
-          if (i__ > 1) {
-            prevlastv = min(prevlastv, lastv);
-          } else {
-            prevlastv = lastv;
-          }
-        }
-        i__1 = i__ + i__ * t_dim1;
-        i__2 = i__;
-        t[i__1].r = tau[i__2].r, t[i__1].i = tau[i__2].i;
-      }
-      /* L40: */
-    }
-  }
-
-  /*     End of CLARFT */
-
-} /* clarft_ */
diff --git a/lapack/complex_double.cpp b/lapack/complex_double.cpp
index 1056767..2cc9623 100644
--- a/lapack/complex_double.cpp
+++ b/lapack/complex_double.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR std::complex<double>
 #define SCALAR_SUFFIX z
@@ -16,3 +17,5 @@
 #include "cholesky.inc"
 #include "lu.inc"
 #include "svd.inc"
+#include "householder.inc"
+#include "utilities.inc"
diff --git a/lapack/complex_single.cpp b/lapack/complex_single.cpp
index 40ab913..14191b8 100644
--- a/lapack/complex_single.cpp
+++ b/lapack/complex_single.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR std::complex<float>
 #define SCALAR_SUFFIX c
@@ -16,3 +17,5 @@
 #include "cholesky.inc"
 #include "lu.inc"
 #include "svd.inc"
+#include "householder.inc"
+#include "utilities.inc"
diff --git a/lapack/dladiv.c b/lapack/dladiv.c
deleted file mode 100644
index 45c0183..0000000
--- a/lapack/dladiv.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* dladiv.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Subroutine */ void dladiv_(doublereal *a, doublereal *b, doublereal *c__, doublereal *d__, doublereal *p,
-                              doublereal *q) {
-  doublereal e, f;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLADIV performs complex division in  real arithmetic */
-
-  /*                        a + i*b */
-  /*             p + i*q = --------- */
-  /*                        c + i*d */
-
-  /*  The algorithm is due to Robert L. Smith and can be found */
-  /*  in D. Knuth, The art of Computer Programming, Vol.2, p.195 */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  A       (input) DOUBLE PRECISION */
-  /*  B       (input) DOUBLE PRECISION */
-  /*  C       (input) DOUBLE PRECISION */
-  /*  D       (input) DOUBLE PRECISION */
-  /*          The scalars a, b, c, and d in the above expression. */
-
-  /*  P       (output) DOUBLE PRECISION */
-  /*  Q       (output) DOUBLE PRECISION */
-  /*          The scalars p and q in the above expression. */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (abs(*d__) < abs(*c__)) {
-    e = *d__ / *c__;
-    f = *c__ + *d__ * e;
-    *p = (*a + *b * e) / f;
-    *q = (*b - *a * e) / f;
-  } else {
-    e = *c__ / *d__;
-    f = *d__ + *c__ * e;
-    *p = (*b + *a * e) / f;
-    *q = (-(*a) + *b * e) / f;
-  }
-
-  /*     End of DLADIV */
-
-} /* dladiv_ */
diff --git a/lapack/dlamch.c b/lapack/dlamch.c
deleted file mode 100644
index 71c4166..0000000
--- a/lapack/dlamch.c
+++ /dev/null
@@ -1,992 +0,0 @@
-/* dlamch.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-/* static integer c__1 = 1; */
-static doublereal c_b32 = 0.;
-
-static inline doublereal pow_di(doublereal *ap, integer *bp) {
-  doublereal pow, x;
-  integer n;
-  unsigned long u;
-
-  pow = 1;
-  x = *ap;
-  n = *bp;
-
-  if (n != 0) {
-    if (n < 0) {
-      n = -n;
-      x = 1 / x;
-    }
-    for (u = n;;) {
-      if (u & 01) pow *= x;
-      if (u >>= 1)
-        x *= x;
-      else
-        break;
-    }
-  }
-  return (pow);
-}
-
-doublereal dlamch_(char *cmach) {
-  /* Initialized data */
-
-  static logical first = TRUE_;
-
-  /* System generated locals */
-  integer i__1;
-  doublereal ret_val;
-
-  /* Local variables */
-  static doublereal t;
-  integer it;
-  static doublereal rnd, eps, base;
-  integer beta;
-  static doublereal emin, prec, emax;
-  integer imin, imax;
-  logical lrnd = 0;
-  static doublereal rmin, rmax;
-  doublereal rmach = 0;
-  extern logical lsame_(char *, char *);
-  doublereal small;
-  static doublereal sfmin;
-  extern /* Subroutine */ void dlamc2_(integer *, integer *, logical *, doublereal *, integer *, doublereal *,
-                                       integer *, doublereal *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLAMCH determines double precision machine parameters. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  CMACH   (input) CHARACTER*1 */
-  /*          Specifies the value to be returned by DLAMCH: */
-  /*          = 'E' or 'e',   DLAMCH := eps */
-  /*          = 'S' or 's ,   DLAMCH := sfmin */
-  /*          = 'B' or 'b',   DLAMCH := base */
-  /*          = 'P' or 'p',   DLAMCH := eps*base */
-  /*          = 'N' or 'n',   DLAMCH := t */
-  /*          = 'R' or 'r',   DLAMCH := rnd */
-  /*          = 'M' or 'm',   DLAMCH := emin */
-  /*          = 'U' or 'u',   DLAMCH := rmin */
-  /*          = 'L' or 'l',   DLAMCH := emax */
-  /*          = 'O' or 'o',   DLAMCH := rmax */
-
-  /*          where */
-
-  /*          eps   = relative machine precision */
-  /*          sfmin = safe minimum, such that 1/sfmin does not overflow */
-  /*          base  = base of the machine */
-  /*          prec  = eps*base */
-  /*          t     = number of (base) digits in the mantissa */
-  /*          rnd   = 1.0 when rounding occurs in addition, 0.0 otherwise */
-  /*          emin  = minimum exponent before (gradual) underflow */
-  /*          rmin  = underflow threshold - base**(emin-1) */
-  /*          emax  = largest exponent before overflow */
-  /*          rmax  = overflow threshold  - (base**emax)*(1-eps) */
-
-  /* ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Save statement .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (first) {
-    dlamc2_(&beta, &it, &lrnd, &eps, &imin, &rmin, &imax, &rmax);
-    base = (doublereal)beta;
-    t = (doublereal)it;
-    if (lrnd) {
-      rnd = 1.;
-      i__1 = 1 - it;
-      eps = pow_di(&base, &i__1) / 2;
-    } else {
-      rnd = 0.;
-      i__1 = 1 - it;
-      eps = pow_di(&base, &i__1);
-    }
-    prec = eps * base;
-    emin = (doublereal)imin;
-    emax = (doublereal)imax;
-    sfmin = rmin;
-    small = 1. / rmax;
-    if (small >= sfmin) {
-      /*           Use SMALL plus a bit, to avoid the possibility of rounding */
-      /*           causing overflow when computing  1/sfmin. */
-
-      sfmin = small * (eps + 1.);
-    }
-  }
-
-  if (lsame_(cmach, "E")) {
-    rmach = eps;
-  } else if (lsame_(cmach, "S")) {
-    rmach = sfmin;
-  } else if (lsame_(cmach, "B")) {
-    rmach = base;
-  } else if (lsame_(cmach, "P")) {
-    rmach = prec;
-  } else if (lsame_(cmach, "N")) {
-    rmach = t;
-  } else if (lsame_(cmach, "R")) {
-    rmach = rnd;
-  } else if (lsame_(cmach, "M")) {
-    rmach = emin;
-  } else if (lsame_(cmach, "U")) {
-    rmach = rmin;
-  } else if (lsame_(cmach, "L")) {
-    rmach = emax;
-  } else if (lsame_(cmach, "O")) {
-    rmach = rmax;
-  }
-
-  ret_val = rmach;
-  first = FALSE_;
-  return ret_val;
-
-  /*     End of DLAMCH */
-
-} /* dlamch_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void dlamc1_(integer *beta, integer *t, logical *rnd, logical *ieee1) {
-  /* Initialized data */
-
-  static logical first = TRUE_;
-
-  /* System generated locals */
-  doublereal d__1, d__2;
-
-  /* Local variables */
-  doublereal a, b, c__, f, t1, t2;
-  static integer lt;
-  doublereal one, qtr;
-  static logical lrnd;
-  static integer lbeta;
-  doublereal savec;
-  extern doublereal dlamc3_(doublereal *, doublereal *);
-  static logical lieee1;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLAMC1 determines the machine parameters given by BETA, T, RND, and */
-  /*  IEEE1. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  BETA    (output) INTEGER */
-  /*          The base of the machine. */
-
-  /*  T       (output) INTEGER */
-  /*          The number of ( BETA ) digits in the mantissa. */
-
-  /*  RND     (output) LOGICAL */
-  /*          Specifies whether proper rounding  ( RND = .TRUE. )  or */
-  /*          chopping  ( RND = .FALSE. )  occurs in addition. This may not */
-  /*          be a reliable guide to the way in which the machine performs */
-  /*          its arithmetic. */
-
-  /*  IEEE1   (output) LOGICAL */
-  /*          Specifies whether rounding appears to be done in the IEEE */
-  /*          'round to nearest' style. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The routine is based on the routine  ENVRON  by Malcolm and */
-  /*  incorporates suggestions by Gentleman and Marovich. See */
-
-  /*     Malcolm M. A. (1972) Algorithms to reveal properties of */
-  /*        floating-point arithmetic. Comms. of the ACM, 15, 949-951. */
-
-  /*     Gentleman W. M. and Marovich S. B. (1974) More on algorithms */
-  /*        that reveal properties of floating point arithmetic units. */
-  /*        Comms. of the ACM, 17, 276-277. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Save statement .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (first) {
-    one = 1.;
-
-    /*        LBETA,  LIEEE1,  LT and  LRND  are the  local values  of  BETA, */
-    /*        IEEE1, T and RND. */
-
-    /*        Throughout this routine  we use the function  DLAMC3  to ensure */
-    /*        that relevant values are  stored and not held in registers,  or */
-    /*        are not affected by optimizers. */
-
-    /*        Compute  a = 2.0**m  with the  smallest positive integer m such */
-    /*        that */
-
-    /*           fl( a + 1.0 ) = a. */
-
-    a = 1.;
-    c__ = 1.;
-
-  /* +       WHILE( C.EQ.ONE )LOOP */
-  L10:
-    if (c__ == one) {
-      a *= 2;
-      c__ = dlamc3_(&a, &one);
-      d__1 = -a;
-      c__ = dlamc3_(&c__, &d__1);
-      goto L10;
-    }
-    /* +       END WHILE */
-
-    /*        Now compute  b = 2.0**m  with the smallest positive integer m */
-    /*        such that */
-
-    /*           fl( a + b ) .gt. a. */
-
-    b = 1.;
-    c__ = dlamc3_(&a, &b);
-
-  /* +       WHILE( C.EQ.A )LOOP */
-  L20:
-    if (c__ == a) {
-      b *= 2;
-      c__ = dlamc3_(&a, &b);
-      goto L20;
-    }
-    /* +       END WHILE */
-
-    /*        Now compute the base.  a and c  are neighbouring floating point */
-    /*        numbers  in the  interval  ( beta**t, beta**( t + 1 ) )  and so */
-    /*        their difference is beta. Adding 0.25 to c is to ensure that it */
-    /*        is truncated to beta and not ( beta - 1 ). */
-
-    qtr = one / 4;
-    savec = c__;
-    d__1 = -a;
-    c__ = dlamc3_(&c__, &d__1);
-    lbeta = (integer)(c__ + qtr);
-
-    /*        Now determine whether rounding or chopping occurs,  by adding a */
-    /*        bit  less  than  beta/2  and a  bit  more  than  beta/2  to  a. */
-
-    b = (doublereal)lbeta;
-    d__1 = b / 2;
-    d__2 = -b / 100;
-    f = dlamc3_(&d__1, &d__2);
-    c__ = dlamc3_(&f, &a);
-    if (c__ == a) {
-      lrnd = TRUE_;
-    } else {
-      lrnd = FALSE_;
-    }
-    d__1 = b / 2;
-    d__2 = b / 100;
-    f = dlamc3_(&d__1, &d__2);
-    c__ = dlamc3_(&f, &a);
-    if (lrnd && c__ == a) {
-      lrnd = FALSE_;
-    }
-
-    /*        Try and decide whether rounding is done in the  IEEE  'round to */
-    /*        nearest' style. B/2 is half a unit in the last place of the two */
-    /*        numbers A and SAVEC. Furthermore, A is even, i.e. has last  bit */
-    /*        zero, and SAVEC is odd. Thus adding B/2 to A should not  change */
-    /*        A, but adding B/2 to SAVEC should change SAVEC. */
-
-    d__1 = b / 2;
-    t1 = dlamc3_(&d__1, &a);
-    d__1 = b / 2;
-    t2 = dlamc3_(&d__1, &savec);
-    lieee1 = t1 == a && t2 > savec && lrnd;
-
-    /*        Now find  the  mantissa, t.  It should  be the  integer part of */
-    /*        log to the base beta of a,  however it is safer to determine  t */
-    /*        by powering.  So we find t as the smallest positive integer for */
-    /*        which */
-
-    /*           fl( beta**t + 1.0 ) = 1.0. */
-
-    lt = 0;
-    a = 1.;
-    c__ = 1.;
-
-  /* +       WHILE( C.EQ.ONE )LOOP */
-  L30:
-    if (c__ == one) {
-      ++lt;
-      a *= lbeta;
-      c__ = dlamc3_(&a, &one);
-      d__1 = -a;
-      c__ = dlamc3_(&c__, &d__1);
-      goto L30;
-    }
-    /* +       END WHILE */
-  }
-
-  *beta = lbeta;
-  *t = lt;
-  *rnd = lrnd;
-  *ieee1 = lieee1;
-  first = FALSE_;
-
-  /*     End of DLAMC1 */
-
-} /* dlamc1_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void dlamc2_(integer *beta, integer *t, logical *rnd, doublereal *eps, integer *emin, doublereal *rmin,
-                              integer *emax, doublereal *rmax) {
-  /* Initialized data */
-
-  static logical first = TRUE_;
-  static logical iwarn = FALSE_;
-
-  /* Format strings */
-  /*
-  static char fmt_9999[] =
-      "(//\002 WARNING. The value EMIN may be incorre"
-      "ct:-\002,\002  EMIN = \002,i8,/\002 If, after inspection, the va"
-      "lue EMIN looks\002,\002 acceptable please comment out \002,/\002"
-      " the IF block as marked within the code of routine\002,\002 DLAM"
-      "C2,\002,/\002 otherwise supply EMIN explicitly.\002,/)";
-  */
-  /* System generated locals */
-  integer i__1;
-  doublereal d__1, d__2, d__3, d__4, d__5;
-
-  /* Builtin functions */
-  /* integer s_wsfe(cilist *), do_fio(integer *, char *, ftnlen), e_wsfe(void); */
-
-  /* Local variables */
-  doublereal a, b, c__;
-  integer i__;
-  static integer lt;
-  doublereal one, two;
-  logical ieee;
-  doublereal half;
-  logical lrnd = 0;
-  static doublereal leps;
-  doublereal zero;
-  static integer lbeta;
-  doublereal rbase;
-  static integer lemin, lemax;
-  integer gnmin;
-  doublereal small;
-  integer gpmin;
-  doublereal third;
-  static doublereal lrmin, lrmax;
-  doublereal sixth;
-  extern /* Subroutine */ void dlamc1_(integer *, integer *, logical *, logical *);
-  extern doublereal dlamc3_(doublereal *, doublereal *);
-  logical lieee1;
-  extern /* Subroutine */ void dlamc4_(integer *, doublereal *, integer *),
-      dlamc5_(integer *, integer *, integer *, logical *, integer *, doublereal *);
-  integer ngnmin, ngpmin;
-
-  /* Fortran I/O blocks */
-  /* static cilist io___58 = {0, 6, 0, fmt_9999, 0}; */
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLAMC2 determines the machine parameters specified in its argument */
-  /*  list. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  BETA    (output) INTEGER */
-  /*          The base of the machine. */
-
-  /*  T       (output) INTEGER */
-  /*          The number of ( BETA ) digits in the mantissa. */
-
-  /*  RND     (output) LOGICAL */
-  /*          Specifies whether proper rounding  ( RND = .TRUE. )  or */
-  /*          chopping  ( RND = .FALSE. )  occurs in addition. This may not */
-  /*          be a reliable guide to the way in which the machine performs */
-  /*          its arithmetic. */
-
-  /*  EPS     (output) DOUBLE PRECISION */
-  /*          The smallest positive number such that */
-
-  /*             fl( 1.0 - EPS ) .LT. 1.0, */
-
-  /*          where fl denotes the computed value. */
-
-  /*  EMIN    (output) INTEGER */
-  /*          The minimum exponent before (gradual) underflow occurs. */
-
-  /*  RMIN    (output) DOUBLE PRECISION */
-  /*          The smallest normalized number for the machine, given by */
-  /*          BASE**( EMIN - 1 ), where  BASE  is the floating point value */
-  /*          of BETA. */
-
-  /*  EMAX    (output) INTEGER */
-  /*          The maximum exponent before overflow occurs. */
-
-  /*  RMAX    (output) DOUBLE PRECISION */
-  /*          The largest positive number for the machine, given by */
-  /*          BASE**EMAX * ( 1 - EPS ), where  BASE  is the floating point */
-  /*          value of BETA. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The computation of  EPS  is based on a routine PARANOIA by */
-  /*  W. Kahan of the University of California at Berkeley. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Save statement .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (first) {
-    zero = 0.;
-    one = 1.;
-    two = 2.;
-
-    /*        LBETA, LT, LRND, LEPS, LEMIN and LRMIN  are the local values of */
-    /*        BETA, T, RND, EPS, EMIN and RMIN. */
-
-    /*        Throughout this routine  we use the function  DLAMC3  to ensure */
-    /*        that relevant values are stored  and not held in registers,  or */
-    /*        are not affected by optimizers. */
-
-    /*        DLAMC1 returns the parameters  LBETA, LT, LRND and LIEEE1. */
-
-    dlamc1_(&lbeta, &lt, &lrnd, &lieee1);
-
-    /*        Start to find EPS. */
-
-    b = (doublereal)lbeta;
-    i__1 = -lt;
-    a = pow_di(&b, &i__1);
-    leps = a;
-
-    /*        Try some tricks to see whether or not this is the correct  EPS. */
-
-    b = two / 3;
-    half = one / 2;
-    d__1 = -half;
-    sixth = dlamc3_(&b, &d__1);
-    third = dlamc3_(&sixth, &sixth);
-    d__1 = -half;
-    b = dlamc3_(&third, &d__1);
-    b = dlamc3_(&b, &sixth);
-    b = abs(b);
-    if (b < leps) {
-      b = leps;
-    }
-
-    leps = 1.;
-
-  /* +       WHILE( ( LEPS.GT.B ).AND.( B.GT.ZERO ) )LOOP */
-  L10:
-    if (leps > b && b > zero) {
-      leps = b;
-      d__1 = half * leps;
-      /* Computing 5th power */
-      d__3 = two, d__4 = d__3, d__3 *= d__3;
-      /* Computing 2nd power */
-      d__5 = leps;
-      d__2 = d__4 * (d__3 * d__3) * (d__5 * d__5);
-      c__ = dlamc3_(&d__1, &d__2);
-      d__1 = -c__;
-      c__ = dlamc3_(&half, &d__1);
-      b = dlamc3_(&half, &c__);
-      d__1 = -b;
-      c__ = dlamc3_(&half, &d__1);
-      b = dlamc3_(&half, &c__);
-      goto L10;
-    }
-    /* +       END WHILE */
-
-    if (a < leps) {
-      leps = a;
-    }
-
-    /*        Computation of EPS complete. */
-
-    /*        Now find  EMIN.  Let A = + or - 1, and + or - (1 + BASE**(-3)). */
-    /*        Keep dividing  A by BETA until (gradual) underflow occurs. This */
-    /*        is detected when we cannot recover the previous A. */
-
-    rbase = one / lbeta;
-    small = one;
-    for (i__ = 1; i__ <= 3; ++i__) {
-      d__1 = small * rbase;
-      small = dlamc3_(&d__1, &zero);
-      /* L20: */
-    }
-    a = dlamc3_(&one, &small);
-    dlamc4_(&ngpmin, &one, &lbeta);
-    d__1 = -one;
-    dlamc4_(&ngnmin, &d__1, &lbeta);
-    dlamc4_(&gpmin, &a, &lbeta);
-    d__1 = -a;
-    dlamc4_(&gnmin, &d__1, &lbeta);
-    ieee = FALSE_;
-
-    if (ngpmin == ngnmin && gpmin == gnmin) {
-      if (ngpmin == gpmin) {
-        lemin = ngpmin;
-        /*            ( Non twos-complement machines, no gradual underflow; */
-        /*              e.g.,  VAX ) */
-      } else if (gpmin - ngpmin == 3) {
-        lemin = ngpmin - 1 + lt;
-        ieee = TRUE_;
-        /*            ( Non twos-complement machines, with gradual underflow; */
-        /*              e.g., IEEE standard followers ) */
-      } else {
-        lemin = min(ngpmin, gpmin);
-        /*            ( A guess; no known machine ) */
-        iwarn = TRUE_;
-      }
-
-    } else if (ngpmin == gpmin && ngnmin == gnmin) {
-      if ((i__1 = ngpmin - ngnmin, abs(i__1)) == 1) {
-        lemin = max(ngpmin, ngnmin);
-        /*            ( Twos-complement machines, no gradual underflow; */
-        /*              e.g., CYBER 205 ) */
-      } else {
-        lemin = min(ngpmin, ngnmin);
-        /*            ( A guess; no known machine ) */
-        iwarn = TRUE_;
-      }
-
-    } else if ((i__1 = ngpmin - ngnmin, abs(i__1)) == 1 && gpmin == gnmin) {
-      if (gpmin - min(ngpmin, ngnmin) == 3) {
-        lemin = max(ngpmin, ngnmin) - 1 + lt;
-        /*            ( Twos-complement machines with gradual underflow; */
-        /*              no known machine ) */
-      } else {
-        lemin = min(ngpmin, ngnmin);
-        /*            ( A guess; no known machine ) */
-        iwarn = TRUE_;
-      }
-
-    } else {
-      /* Computing MIN */
-      i__1 = min(ngpmin, ngnmin), i__1 = min(i__1, gpmin);
-      lemin = min(i__1, gnmin);
-      /*         ( A guess; no known machine ) */
-      iwarn = TRUE_;
-    }
-    first = FALSE_;
-    /* ** */
-    /* Comment out this if block if EMIN is ok */
-    /*
-    if (iwarn) {
-      first = TRUE_;
-      s_wsfe(&io___58);
-      do_fio(&c__1, (char *)&lemin, (ftnlen)sizeof(integer));
-      e_wsfe();
-    }
-    */
-    /* ** */
-
-    /*        Assume IEEE arithmetic if we found denormalised  numbers above, */
-    /*        or if arithmetic seems to round in the  IEEE style,  determined */
-    /*        in routine DLAMC1. A true IEEE machine should have both  things */
-    /*        true; however, faulty machines may have one or the other. */
-
-    ieee = ieee || lieee1;
-
-    /*        Compute  RMIN by successive division by  BETA. We could compute */
-    /*        RMIN as BASE**( EMIN - 1 ),  but some machines underflow during */
-    /*        this computation. */
-
-    lrmin = 1.;
-    i__1 = 1 - lemin;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      d__1 = lrmin * rbase;
-      lrmin = dlamc3_(&d__1, &zero);
-      /* L30: */
-    }
-
-    /*        Finally, call DLAMC5 to compute EMAX and RMAX. */
-
-    dlamc5_(&lbeta, &lt, &lemin, &ieee, &lemax, &lrmax);
-  }
-
-  *beta = lbeta;
-  *t = lt;
-  *rnd = lrnd;
-  *eps = leps;
-  *emin = lemin;
-  *rmin = lrmin;
-  *emax = lemax;
-  *rmax = lrmax;
-
-  /*     End of DLAMC2 */
-
-} /* dlamc2_ */
-
-/* *********************************************************************** */
-
-doublereal dlamc3_(doublereal *a, doublereal *b) {
-  /* System generated locals */
-  doublereal ret_val;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLAMC3  is intended to force  A  and  B  to be stored prior to doing */
-  /*  the addition of  A  and  B ,  for use in situations where optimizers */
-  /*  might hold one of these in a register. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  A       (input) DOUBLE PRECISION */
-  /*  B       (input) DOUBLE PRECISION */
-  /*          The values A and B. */
-
-  /* ===================================================================== */
-
-  /*     .. Executable Statements .. */
-
-  ret_val = *a + *b;
-
-  return ret_val;
-
-  /*     End of DLAMC3 */
-
-} /* dlamc3_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void dlamc4_(integer *emin, doublereal *start, integer *base) {
-  /* System generated locals */
-  integer i__1;
-  doublereal d__1;
-
-  /* Local variables */
-  doublereal a;
-  integer i__;
-  doublereal b1, b2, c1, c2, d1, d2, one, zero, rbase;
-  extern doublereal dlamc3_(doublereal *, doublereal *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLAMC4 is a service routine for DLAMC2. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  EMIN    (output) INTEGER */
-  /*          The minimum exponent before (gradual) underflow, computed by */
-  /*          setting A = START and dividing by BASE until the previous A */
-  /*          can not be recovered. */
-
-  /*  START   (input) DOUBLE PRECISION */
-  /*          The starting point for determining EMIN. */
-
-  /*  BASE    (input) INTEGER */
-  /*          The base of the machine. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  a = *start;
-  one = 1.;
-  rbase = one / *base;
-  zero = 0.;
-  *emin = 1;
-  d__1 = a * rbase;
-  b1 = dlamc3_(&d__1, &zero);
-  c1 = a;
-  c2 = a;
-  d1 = a;
-  d2 = a;
-/* +    WHILE( ( C1.EQ.A ).AND.( C2.EQ.A ).AND. */
-/*    $       ( D1.EQ.A ).AND.( D2.EQ.A )      )LOOP */
-L10:
-  if (c1 == a && c2 == a && d1 == a && d2 == a) {
-    --(*emin);
-    a = b1;
-    d__1 = a / *base;
-    b1 = dlamc3_(&d__1, &zero);
-    d__1 = b1 * *base;
-    c1 = dlamc3_(&d__1, &zero);
-    d1 = zero;
-    i__1 = *base;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      d1 += b1;
-      /* L20: */
-    }
-    d__1 = a * rbase;
-    b2 = dlamc3_(&d__1, &zero);
-    d__1 = b2 / rbase;
-    c2 = dlamc3_(&d__1, &zero);
-    d2 = zero;
-    i__1 = *base;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      d2 += b2;
-      /* L30: */
-    }
-    goto L10;
-  }
-  /* +    END WHILE */
-
-  /*     End of DLAMC4 */
-
-} /* dlamc4_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void dlamc5_(integer *beta, integer *p, integer *emin, logical *ieee, integer *emax,
-                              doublereal *rmax) {
-  /* System generated locals */
-  integer i__1;
-  doublereal d__1;
-
-  /* Local variables */
-  integer i__;
-  doublereal y, z__;
-  integer try__, lexp;
-  doublereal oldy;
-  integer uexp, nbits;
-  extern doublereal dlamc3_(doublereal *, doublereal *);
-  doublereal recbas;
-  integer exbits, expsum;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLAMC5 attempts to compute RMAX, the largest machine floating-point */
-  /*  number, without overflow.  It assumes that EMAX + abs(EMIN) sum */
-  /*  approximately to a power of 2.  It will fail on machines where this */
-  /*  assumption does not hold, for example, the Cyber 205 (EMIN = -28625, */
-  /*  EMAX = 28718).  It will also fail if the value supplied for EMIN is */
-  /*  too large (i.e. too close to zero), probably with overflow. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  BETA    (input) INTEGER */
-  /*          The base of floating-point arithmetic. */
-
-  /*  P       (input) INTEGER */
-  /*          The number of base BETA digits in the mantissa of a */
-  /*          floating-point value. */
-
-  /*  EMIN    (input) INTEGER */
-  /*          The minimum exponent before (gradual) underflow. */
-
-  /*  IEEE    (input) LOGICAL */
-  /*          A logical flag specifying whether or not the arithmetic */
-  /*          system is thought to comply with the IEEE standard. */
-
-  /*  EMAX    (output) INTEGER */
-  /*          The largest exponent before overflow */
-
-  /*  RMAX    (output) DOUBLE PRECISION */
-  /*          The largest machine floating-point number. */
-
-  /* ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     First compute LEXP and UEXP, two powers of 2 that bound */
-  /*     abs(EMIN). We then assume that EMAX + abs(EMIN) will sum */
-  /*     approximately to the bound that is closest to abs(EMIN). */
-  /*     (EMAX is the exponent of the required number RMAX). */
-
-  lexp = 1;
-  exbits = 1;
-L10:
-  try__ = lexp << 1;
-  if (try__ <= -(*emin)) {
-    lexp = try__;
-    ++exbits;
-    goto L10;
-  }
-  if (lexp == -(*emin)) {
-    uexp = lexp;
-  } else {
-    uexp = try__;
-    ++exbits;
-  }
-
-  /*     Now -LEXP is less than or equal to EMIN, and -UEXP is greater */
-  /*     than or equal to EMIN. EXBITS is the number of bits needed to */
-  /*     store the exponent. */
-
-  if (uexp + *emin > -lexp - *emin) {
-    expsum = lexp << 1;
-  } else {
-    expsum = uexp << 1;
-  }
-
-  /*     EXPSUM is the exponent range, approximately equal to */
-  /*     EMAX - EMIN + 1 . */
-
-  *emax = expsum + *emin - 1;
-  nbits = exbits + 1 + *p;
-
-  /*     NBITS is the total number of bits needed to store a */
-  /*     floating-point number. */
-
-  if (nbits % 2 == 1 && *beta == 2) {
-    /*        Either there are an odd number of bits used to store a */
-    /*        floating-point number, which is unlikely, or some bits are */
-    /*        not used in the representation of numbers, which is possible, */
-    /*        (e.g. Cray machines) or the mantissa has an implicit bit, */
-    /*        (e.g. IEEE machines, Dec Vax machines), which is perhaps the */
-    /*        most likely. We have to assume the last alternative. */
-    /*        If this is true, then we need to reduce EMAX by one because */
-    /*        there must be some way of representing zero in an implicit-bit */
-    /*        system. On machines like Cray, we are reducing EMAX by one */
-    /*        unnecessarily. */
-
-    --(*emax);
-  }
-
-  if (*ieee) {
-    /*        Assume we are on an IEEE machine which reserves one exponent */
-    /*        for infinity and NaN. */
-
-    --(*emax);
-  }
-
-  /*     Now create RMAX, the largest machine number, which should */
-  /*     be equal to (1.0 - BETA**(-P)) * BETA**EMAX . */
-
-  /*     First compute 1.0 - BETA**(-P), being careful that the */
-  /*     result is less than 1.0 . */
-
-  recbas = 1. / *beta;
-  z__ = *beta - 1.;
-  y = 0.;
-  i__1 = *p;
-  for (i__ = 1; i__ <= i__1; ++i__) {
-    z__ *= recbas;
-    if (y < 1.) {
-      oldy = y;
-    }
-    y = dlamc3_(&y, &z__);
-    /* L20: */
-  }
-  if (y >= 1.) {
-    y = oldy;
-  }
-
-  /*     Now multiply by BETA**EMAX to get RMAX. */
-
-  i__1 = *emax;
-  for (i__ = 1; i__ <= i__1; ++i__) {
-    d__1 = y * *beta;
-    y = dlamc3_(&d__1, &c_b32);
-    /* L30: */
-  }
-
-  *rmax = y;
-
-  /*     End of DLAMC5 */
-
-} /* dlamc5_ */
diff --git a/lapack/dlapy2.c b/lapack/dlapy2.c
deleted file mode 100644
index ef4cf57..0000000
--- a/lapack/dlapy2.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* dlapy2.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-doublereal dlapy2_(doublereal *x, doublereal *y)
-{
-    /* System generated locals */
-    doublereal ret_val, d__1;
-
-    /* Builtin functions */
-    double sqrt(doublereal);
-
-    /* Local variables */
-    doublereal w, z__, xabs, yabs;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2) -- */
-/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-/*     November 2006 */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  DLAPY2 returns sqrt(x**2+y**2), taking care not to cause unnecessary */
-/*  overflow. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  X       (input) DOUBLE PRECISION */
-/*  Y       (input) DOUBLE PRECISION */
-/*          X and Y specify the values x and y. */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Intrinsic Functions .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-    xabs = abs(*x);
-    yabs = abs(*y);
-    w = max(xabs,yabs);
-    z__ = min(xabs,yabs);
-    if (z__ == 0.) {
-	ret_val = w;
-    } else {
-/* Computing 2nd power */
-	d__1 = z__ / w;
-	ret_val = w * sqrt(d__1 * d__1 + 1.);
-    }
-    return ret_val;
-
-/*     End of DLAPY2 */
-
-} /* dlapy2_ */
diff --git a/lapack/dlapy3.c b/lapack/dlapy3.c
deleted file mode 100644
index 91d5220..0000000
--- a/lapack/dlapy3.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/* dlapy3.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__)
-{
-    /* System generated locals */
-    doublereal ret_val, d__1, d__2, d__3;
-
-    /* Builtin functions */
-    double sqrt(doublereal);
-
-    /* Local variables */
-    doublereal w, xabs, yabs, zabs;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2) -- */
-/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-/*     November 2006 */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  DLAPY3 returns sqrt(x**2+y**2+z**2), taking care not to cause */
-/*  unnecessary overflow. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  X       (input) DOUBLE PRECISION */
-/*  Y       (input) DOUBLE PRECISION */
-/*  Z       (input) DOUBLE PRECISION */
-/*          X, Y and Z specify the values x, y and z. */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Intrinsic Functions .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-    xabs = abs(*x);
-    yabs = abs(*y);
-    zabs = abs(*z__);
-/* Computing MAX */
-    d__1 = max(xabs,yabs);
-    w = max(d__1,zabs);
-    if (w == 0.) {
-/*     W can be zero for max(0,nan,0) */
-/*     adding all three entries together will make sure */
-/*     NaN will not disappear. */
-	ret_val = xabs + yabs + zabs;
-    } else {
-/* Computing 2nd power */
-	d__1 = xabs / w;
-/* Computing 2nd power */
-	d__2 = yabs / w;
-/* Computing 2nd power */
-	d__3 = zabs / w;
-	ret_val = w * sqrt(d__1 * d__1 + d__2 * d__2 + d__3 * d__3);
-    }
-    return ret_val;
-
-/*     End of DLAPY3 */
-
-} /* dlapy3_ */
diff --git a/lapack/dlarf.c b/lapack/dlarf.c
deleted file mode 100644
index 07dda21..0000000
--- a/lapack/dlarf.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/* dlarf.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static doublereal c_b4 = 1.;
-static doublereal c_b5 = 0.;
-static integer c__1 = 1;
-
-/* Subroutine */ void dlarf_(char *side, integer *m, integer *n, doublereal *v, integer *incv, doublereal *tau,
-                             doublereal *c__, integer *ldc, doublereal *work) {
-  /* System generated locals */
-  integer c_dim1, c_offset;
-  doublereal d__1;
-
-  /* Local variables */
-  integer i__;
-  logical applyleft;
-  extern /* Subroutine */ void dger_(integer *, integer *, doublereal *, doublereal *, integer *, doublereal *,
-                                     integer *, doublereal *, integer *);
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void dgemv_(const char *, const integer *, const integer *, const doublereal *,
-                                      const doublereal *, const integer *, const doublereal *, const integer *,
-                                      const doublereal *, doublereal *, const integer *);
-  integer lastc, lastv;
-  extern integer iladlc_(integer *, integer *, doublereal *, integer *),
-      iladlr_(integer *, integer *, doublereal *, integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLARF applies a real elementary reflector H to a real m by n matrix */
-  /*  C, from either the left or the right. H is represented in the form */
-
-  /*        H = I - tau * v * v' */
-
-  /*  where tau is a real scalar and v is a real vector. */
-
-  /*  If tau = 0, then H is taken to be the unit matrix. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': form  H * C */
-  /*          = 'R': form  C * H */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  V       (input) DOUBLE PRECISION array, dimension */
-  /*                     (1 + (M-1)*abs(INCV)) if SIDE = 'L' */
-  /*                  or (1 + (N-1)*abs(INCV)) if SIDE = 'R' */
-  /*          The vector v in the representation of H. V is not used if */
-  /*          TAU = 0. */
-
-  /*  INCV    (input) INTEGER */
-  /*          The increment between elements of v. INCV <> 0. */
-
-  /*  TAU     (input) DOUBLE PRECISION */
-  /*          The value tau in the representation of H. */
-
-  /*  C       (input/output) DOUBLE PRECISION array, dimension (LDC,N) */
-  /*          On entry, the m by n matrix C. */
-  /*          On exit, C is overwritten by the matrix H * C if SIDE = 'L', */
-  /*          or C * H if SIDE = 'R'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDC >= max(1,M). */
-
-  /*  WORK    (workspace) DOUBLE PRECISION array, dimension */
-  /*                         (N) if SIDE = 'L' */
-  /*                      or (M) if SIDE = 'R' */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --v;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  --work;
-
-  /* Function Body */
-  applyleft = lsame_(side, "L");
-  lastv = 0;
-  lastc = 0;
-  if (*tau != 0.) {
-    /*     Set up variables for scanning V.  LASTV begins pointing to the end */
-    /*     of V. */
-    if (applyleft) {
-      lastv = *m;
-    } else {
-      lastv = *n;
-    }
-    if (*incv > 0) {
-      i__ = (lastv - 1) * *incv + 1;
-    } else {
-      i__ = 1;
-    }
-    /*     Look for the last non-zero row in V. */
-    while (lastv > 0 && v[i__] == 0.) {
-      --lastv;
-      i__ -= *incv;
-    }
-    if (applyleft) {
-      /*     Scan for the last non-zero column in C(1:lastv,:). */
-      lastc = iladlc_(&lastv, n, &c__[c_offset], ldc);
-    } else {
-      /*     Scan for the last non-zero row in C(:,1:lastv). */
-      lastc = iladlr_(m, &lastv, &c__[c_offset], ldc);
-    }
-  }
-  /*     Note that lastc.eq.0 renders the BLAS operations null; no special */
-  /*     case is needed at this level. */
-  if (applyleft) {
-    /*        Form  H * C */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1) */
-
-      dgemv_("Transpose", &lastv, &lastc, &c_b4, &c__[c_offset], ldc, &v[1], incv, &c_b5, &work[1], &c__1);
-
-      /*           C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)' */
-
-      d__1 = -(*tau);
-      dger_(&lastv, &lastc, &d__1, &v[1], incv, &work[1], &c__1, &c__[c_offset], ldc);
-    }
-  } else {
-    /*        Form  C * H */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastc,1:lastv) * v(1:lastv,1) */
-
-      dgemv_("No transpose", &lastc, &lastv, &c_b4, &c__[c_offset], ldc, &v[1], incv, &c_b5, &work[1], &c__1);
-
-      /*           C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)' */
-
-      d__1 = -(*tau);
-      dger_(&lastc, &lastv, &d__1, &work[1], &c__1, &v[1], incv, &c__[c_offset], ldc);
-    }
-  }
-
-  /*     End of DLARF */
-
-} /* dlarf_ */
diff --git a/lapack/dlarfb.c b/lapack/dlarfb.c
deleted file mode 100644
index 3bf4d23..0000000
--- a/lapack/dlarfb.c
+++ /dev/null
@@ -1,680 +0,0 @@
-/* dlarfb.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static integer c__1 = 1;
-static doublereal c_b14 = 1.;
-static doublereal c_b25 = -1.;
-
-/* Subroutine */ void dlarfb_(char *side, char *trans, char *direct, char *storev, integer *m, integer *n, integer *k,
-                              doublereal *v, integer *ldv, doublereal *t, integer *ldt, doublereal *c__, integer *ldc,
-                              doublereal *work, integer *ldwork) {
-  /* System generated locals */
-  integer c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1, work_offset, i__1, i__2;
-
-  /* Local variables */
-  integer i__, j;
-  extern /* Subroutine */ void dgemm_(const char *, const char *, const integer *, const integer *, const integer *,
-                                      const doublereal *, const doublereal *, const integer *, const doublereal *,
-                                      const integer *, const doublereal *, doublereal *, const integer *);
-  extern logical lsame_(char *, char *);
-  integer lastc;
-  extern /* Subroutine */ void dcopy_(integer *, doublereal *, integer *, doublereal *, integer *),
-      dtrmm_(const char *, const char *, const char *, const char *, const integer *, const integer *,
-             const doublereal *, const doublereal *, const integer *, doublereal *, const integer *);
-  integer lastv;
-  extern integer iladlc_(integer *, integer *, doublereal *, integer *),
-      iladlr_(integer *, integer *, doublereal *, integer *);
-  char transt[1];
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLARFB applies a real block reflector H or its transpose H' to a */
-  /*  real m by n matrix C, from either the left or the right. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': apply H or H' from the Left */
-  /*          = 'R': apply H or H' from the Right */
-
-  /*  TRANS   (input) CHARACTER*1 */
-  /*          = 'N': apply H (No transpose) */
-  /*          = 'T': apply H' (Transpose) */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Indicates how H is formed from a product of elementary */
-  /*          reflectors */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Indicates how the vectors which define the elementary */
-  /*          reflectors are stored: */
-  /*          = 'C': Columnwise */
-  /*          = 'R': Rowwise */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the matrix T (= the number of elementary */
-  /*          reflectors whose product defines the block reflector). */
-
-  /*  V       (input) DOUBLE PRECISION array, dimension */
-  /*                                (LDV,K) if STOREV = 'C' */
-  /*                                (LDV,M) if STOREV = 'R' and SIDE = 'L' */
-  /*                                (LDV,N) if STOREV = 'R' and SIDE = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M); */
-  /*          if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N); */
-  /*          if STOREV = 'R', LDV >= K. */
-
-  /*  T       (input) DOUBLE PRECISION array, dimension (LDT,K) */
-  /*          The triangular k by k matrix T in the representation of the */
-  /*          block reflector. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  C       (input/output) DOUBLE PRECISION array, dimension (LDC,N) */
-  /*          On entry, the m by n matrix C. */
-  /*          On exit, C is overwritten by H*C or H'*C or C*H or C*H'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDA >= max(1,M). */
-
-  /*  WORK    (workspace) DOUBLE PRECISION array, dimension (LDWORK,K) */
-
-  /*  LDWORK  (input) INTEGER */
-  /*          The leading dimension of the array WORK. */
-  /*          If SIDE = 'L', LDWORK >= max(1,N); */
-  /*          if SIDE = 'R', LDWORK >= max(1,M). */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  work_dim1 = *ldwork;
-  work_offset = 1 + work_dim1;
-  work -= work_offset;
-
-  /* Function Body */
-  if (*m <= 0 || *n <= 0) {
-    return;
-  }
-
-  if (lsame_(trans, "N")) {
-    *(unsigned char *)transt = 'T';
-  } else {
-    *(unsigned char *)transt = 'N';
-  }
-
-  if (lsame_(storev, "C")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1 )    (first K rows) */
-      /*                     ( V2 ) */
-      /*           where  V1  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L10: */
-        }
-
-        /*              W := W * V1 */
-
-        dtrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2 */
-
-          i__1 = lastv - *k;
-          dgemm_("Transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[*k + 1 + c_dim1], ldc, &v[*k + 1 + v_dim1],
-                 ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        dtrmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - V2 * W' */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[*k + 1 + v_dim1], ldv, &work[work_offset],
-                 ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        dtrmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L20: */
-          }
-          /* L30: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L40: */
-        }
-
-        /*              W := W * V1 */
-
-        dtrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2 */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[*k + 1 + v_dim1], ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        dtrmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2' */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "Transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork, &v[*k + 1 + v_dim1],
-                 ldv, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        dtrmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
-            /* L50: */
-          }
-          /* L60: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1 ) */
-      /*                     ( V2 )    (last K rows) */
-      /*           where  V2  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L70: */
-        }
-
-        /*              W := W * V2 */
-
-        dtrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1 */
-
-          i__1 = lastv - *k;
-          dgemm_("Transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b14,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        dtrmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1 * W' */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[v_offset], ldv, &work[work_offset], ldwork,
-                 &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        dtrmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[lastv - *k + j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L80: */
-          }
-          /* L90: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[(*n - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L100: */
-        }
-
-        /*              W := W * V2 */
-
-        dtrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1 */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv,
-                 &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        dtrmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1' */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "Transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork, &v[v_offset], ldv,
-                 &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        dtrmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + (lastv - *k + j) * c_dim1] -= work[i__ + j * work_dim1];
-            /* L110: */
-          }
-          /* L120: */
-        }
-      }
-    }
-
-  } else if (lsame_(storev, "R")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1  V2 )    (V1: first K columns) */
-      /*           where  V1  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L130: */
-        }
-
-        /*              W := W * V1' */
-
-        dtrmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2' */
-
-          i__1 = lastv - *k;
-          dgemm_("Transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[*k + 1 + c_dim1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        dtrmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - V2' * W' */
-
-          i__1 = lastv - *k;
-          dgemm_("Transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[(*k + 1) * v_dim1 + 1], ldv, &work[work_offset],
-                 ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        dtrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L140: */
-          }
-          /* L150: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L160: */
-        }
-
-        /*              W := W * V1' */
-
-        dtrmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2' */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        dtrmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2 */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "No transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        dtrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
-            /* L170: */
-          }
-          /* L180: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1  V2 )    (V2: last K columns) */
-      /*           where  V2  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L190: */
-        }
-
-        /*              W := W * V2' */
-
-        dtrmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1' */
-
-          i__1 = lastv - *k;
-          dgemm_("Transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b14,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        dtrmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1' * W' */
-
-          i__1 = lastv - *k;
-          dgemm_("Transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[v_offset], ldv, &work[work_offset], ldwork,
-                 &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        dtrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[lastv - *k + j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L200: */
-          }
-          /* L210: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = iladlc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = iladlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          dcopy_(&lastc, &c__[(lastv - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L220: */
-        }
-
-        /*              W := W * V2' */
-
-        dtrmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1' */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b14,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        dtrmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1 */
-
-          i__1 = lastv - *k;
-          dgemm_("No transpose", "No transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork, &v[v_offset],
-                 ldv, &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        dtrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + (lastv - *k + j) * c_dim1] -= work[i__ + j * work_dim1];
-            /* L230: */
-          }
-          /* L240: */
-        }
-      }
-    }
-  }
-
-  /*     End of DLARFB */
-
-} /* dlarfb_ */
diff --git a/lapack/dlarfg.c b/lapack/dlarfg.c
deleted file mode 100644
index be321f9..0000000
--- a/lapack/dlarfg.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/* dlarfg.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline doublereal d_sign(doublereal *a, doublereal *b) {
-  doublereal x;
-  x = (*a >= 0 ? *a : -*a);
-  return (*b >= 0 ? x : -x);
-}
-
-/* Subroutine */ void dlarfg_(integer *n, doublereal *alpha, doublereal *x, integer *incx, doublereal *tau) {
-  /* System generated locals */
-  integer i__1;
-  doublereal d__1;
-
-  /* Local variables */
-  integer j, knt;
-  doublereal beta;
-  extern doublereal dnrm2_(integer *, doublereal *, integer *);
-  extern /* Subroutine */ void dscal_(integer *, doublereal *, doublereal *, integer *);
-  doublereal xnorm;
-  extern doublereal dlapy2_(doublereal *, doublereal *), dlamch_(char *);
-  doublereal safmin, rsafmn;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLARFG generates a real elementary reflector H of order n, such */
-  /*  that */
-
-  /*        H * ( alpha ) = ( beta ),   H' * H = I. */
-  /*            (   x   )   (   0  ) */
-
-  /*  where alpha and beta are scalars, and x is an (n-1)-element real */
-  /*  vector. H is represented in the form */
-
-  /*        H = I - tau * ( 1 ) * ( 1 v' ) , */
-  /*                      ( v ) */
-
-  /*  where tau is a real scalar and v is a real (n-1)-element */
-  /*  vector. */
-
-  /*  If the elements of x are all zero, then tau = 0 and H is taken to be */
-  /*  the unit matrix. */
-
-  /*  Otherwise  1 <= tau <= 2. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the elementary reflector. */
-
-  /*  ALPHA   (input/output) DOUBLE PRECISION */
-  /*          On entry, the value alpha. */
-  /*          On exit, it is overwritten with the value beta. */
-
-  /*  X       (input/output) DOUBLE PRECISION array, dimension */
-  /*                         (1+(N-2)*abs(INCX)) */
-  /*          On entry, the vector x. */
-  /*          On exit, it is overwritten with the vector v. */
-
-  /*  INCX    (input) INTEGER */
-  /*          The increment between elements of X. INCX > 0. */
-
-  /*  TAU     (output) DOUBLE PRECISION */
-  /*          The value tau. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --x;
-
-  /* Function Body */
-  if (*n <= 1) {
-    *tau = 0.;
-    return;
-  }
-
-  i__1 = *n - 1;
-  xnorm = dnrm2_(&i__1, &x[1], incx);
-
-  if (xnorm == 0.) {
-    /*        H  =  I */
-
-    *tau = 0.;
-  } else {
-    /*        general case */
-
-    d__1 = dlapy2_(alpha, &xnorm);
-    beta = -d_sign(&d__1, alpha);
-    safmin = dlamch_("S") / dlamch_("E");
-    knt = 0;
-    if (abs(beta) < safmin) {
-      /*           XNORM, BETA may be inaccurate; scale X and recompute them */
-
-      rsafmn = 1. / safmin;
-    L10:
-      ++knt;
-      i__1 = *n - 1;
-      dscal_(&i__1, &rsafmn, &x[1], incx);
-      beta *= rsafmn;
-      *alpha *= rsafmn;
-      if (abs(beta) < safmin) {
-        goto L10;
-      }
-
-      /*           New BETA is at most 1, at least SAFMIN */
-
-      i__1 = *n - 1;
-      xnorm = dnrm2_(&i__1, &x[1], incx);
-      d__1 = dlapy2_(alpha, &xnorm);
-      beta = -d_sign(&d__1, alpha);
-    }
-    *tau = (beta - *alpha) / beta;
-    i__1 = *n - 1;
-    d__1 = 1. / (*alpha - beta);
-    dscal_(&i__1, &d__1, &x[1], incx);
-
-    /*        If ALPHA is subnormal, it may lose relative accuracy */
-
-    i__1 = knt;
-    for (j = 1; j <= i__1; ++j) {
-      beta *= safmin;
-      /* L20: */
-    }
-    *alpha = beta;
-  }
-
-  /*     End of DLARFG */
-
-} /* dlarfg_ */
diff --git a/lapack/dlarft.c b/lapack/dlarft.c
deleted file mode 100644
index 46f36f9..0000000
--- a/lapack/dlarft.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/* dlarft.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static integer c__1 = 1;
-static doublereal c_b8 = 0.;
-
-/* Subroutine */ void dlarft_(char *direct, char *storev, integer *n, integer *k, doublereal *v, integer *ldv,
-                              doublereal *tau, doublereal *t, integer *ldt) {
-  /* System generated locals */
-  integer t_dim1, t_offset, v_dim1, v_offset, i__1, i__2, i__3;
-  doublereal d__1;
-
-  /* Local variables */
-  integer i__, j, prevlastv;
-  doublereal vii;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void dgemv_(const char *, const integer *, const integer *, const doublereal *,
-                                      const doublereal *, const integer *, const doublereal *, const integer *,
-                                      const doublereal *, doublereal *, const integer *);
-  integer lastv;
-  extern /* Subroutine */ void dtrmv_(const char *, const char *, const char *, const integer *, const doublereal *,
-                                      const integer *, doublereal *, const integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  DLARFT forms the triangular factor T of a real block reflector H */
-  /*  of order n, which is defined as a product of k elementary reflectors. */
-
-  /*  If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; */
-
-  /*  If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. */
-
-  /*  If STOREV = 'C', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th column of the array V, and */
-
-  /*     H  =  I - V * T * V' */
-
-  /*  If STOREV = 'R', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th row of the array V, and */
-
-  /*     H  =  I - V' * T * V */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Specifies the order in which the elementary reflectors are */
-  /*          multiplied to form the block reflector: */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Specifies how the vectors which define the elementary */
-  /*          reflectors are stored (see also Further Details): */
-  /*          = 'C': columnwise */
-  /*          = 'R': rowwise */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the block reflector H. N >= 0. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the triangular factor T (= the number of */
-  /*          elementary reflectors). K >= 1. */
-
-  /*  V       (input/output) DOUBLE PRECISION array, dimension */
-  /*                               (LDV,K) if STOREV = 'C' */
-  /*                               (LDV,N) if STOREV = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K. */
-
-  /*  TAU     (input) DOUBLE PRECISION array, dimension (K) */
-  /*          TAU(i) must contain the scalar factor of the elementary */
-  /*          reflector H(i). */
-
-  /*  T       (output) DOUBLE PRECISION array, dimension (LDT,K) */
-  /*          The k by k triangular factor T of the block reflector. */
-  /*          If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is */
-  /*          lower triangular. The rest of the array is not used. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The shape of the matrix V and the storage of the vectors which define */
-  /*  the H(i) is best illustrated by the following example with n = 5 and */
-  /*  k = 3. The elements equal to 1 are not stored; the corresponding */
-  /*  array elements are modified but restored on exit. The rest of the */
-  /*  array is not used. */
-
-  /*  DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R': */
-
-  /*               V = (  1       )                 V = (  1 v1 v1 v1 v1 ) */
-  /*                   ( v1  1    )                     (     1 v2 v2 v2 ) */
-  /*                   ( v1 v2  1 )                     (        1 v3 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-
-  /*  DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R': */
-
-  /*               V = ( v1 v2 v3 )                 V = ( v1 v1  1       ) */
-  /*                   ( v1 v2 v3 )                     ( v2 v2 v2  1    ) */
-  /*                   (  1 v2 v3 )                     ( v3 v3 v3 v3  1 ) */
-  /*                   (     1 v3 ) */
-  /*                   (        1 ) */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  --tau;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-
-  /* Function Body */
-  if (*n == 0) {
-    return;
-  }
-
-  if (lsame_(direct, "F")) {
-    prevlastv = *n;
-    i__1 = *k;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      prevlastv = max(i__, prevlastv);
-      if (tau[i__] == 0.) {
-        /*              H(i)  =  I */
-
-        i__2 = i__;
-        for (j = 1; j <= i__2; ++j) {
-          t[j + i__ * t_dim1] = 0.;
-          /* L10: */
-        }
-      } else {
-        /*              general case */
-
-        vii = v[i__ + i__ * v_dim1];
-        v[i__ + i__ * v_dim1] = 1.;
-        if (lsame_(storev, "C")) {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            if (v[lastv + i__ * v_dim1] != 0.) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i) */
-
-          i__2 = j - i__ + 1;
-          i__3 = i__ - 1;
-          d__1 = -tau[i__];
-          dgemv_("Transpose", &i__2, &i__3, &d__1, &v[i__ + v_dim1], ldv, &v[i__ + i__ * v_dim1], &c__1, &c_b8,
-                 &t[i__ * t_dim1 + 1], &c__1);
-        } else {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            if (v[i__ + lastv * v_dim1] != 0.) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)' */
-
-          i__2 = i__ - 1;
-          i__3 = j - i__ + 1;
-          d__1 = -tau[i__];
-          dgemv_("No transpose", &i__2, &i__3, &d__1, &v[i__ * v_dim1 + 1], ldv, &v[i__ + i__ * v_dim1], ldv, &c_b8,
-                 &t[i__ * t_dim1 + 1], &c__1);
-        }
-        v[i__ + i__ * v_dim1] = vii;
-
-        /*              T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i) */
-
-        i__2 = i__ - 1;
-        dtrmv_("Upper", "No transpose", "Non-unit", &i__2, &t[t_offset], ldt, &t[i__ * t_dim1 + 1], &c__1);
-        t[i__ + i__ * t_dim1] = tau[i__];
-        if (i__ > 1) {
-          prevlastv = max(prevlastv, lastv);
-        } else {
-          prevlastv = lastv;
-        }
-      }
-      /* L20: */
-    }
-  } else {
-    prevlastv = 1;
-    for (i__ = *k; i__ >= 1; --i__) {
-      if (tau[i__] == 0.) {
-        /*              H(i)  =  I */
-
-        i__1 = *k;
-        for (j = i__; j <= i__1; ++j) {
-          t[j + i__ * t_dim1] = 0.;
-          /* L30: */
-        }
-      } else {
-        /*              general case */
-
-        if (i__ < *k) {
-          if (lsame_(storev, "C")) {
-            vii = v[*n - *k + i__ + i__ * v_dim1];
-            v[*n - *k + i__ + i__ * v_dim1] = 1.;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              if (v[lastv + i__ * v_dim1] != 0.) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i) */
-
-            i__1 = *n - *k + i__ - j + 1;
-            i__2 = *k - i__;
-            d__1 = -tau[i__];
-            dgemv_("Transpose", &i__1, &i__2, &d__1, &v[j + (i__ + 1) * v_dim1], ldv, &v[j + i__ * v_dim1], &c__1,
-                   &c_b8, &t[i__ + 1 + i__ * t_dim1], &c__1);
-            v[*n - *k + i__ + i__ * v_dim1] = vii;
-          } else {
-            vii = v[i__ + (*n - *k + i__) * v_dim1];
-            v[i__ + (*n - *k + i__) * v_dim1] = 1.;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              if (v[i__ + lastv * v_dim1] != 0.) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)' */
-
-            i__1 = *k - i__;
-            i__2 = *n - *k + i__ - j + 1;
-            d__1 = -tau[i__];
-            dgemv_("No transpose", &i__1, &i__2, &d__1, &v[i__ + 1 + j * v_dim1], ldv, &v[i__ + j * v_dim1], ldv, &c_b8,
-                   &t[i__ + 1 + i__ * t_dim1], &c__1);
-            v[i__ + (*n - *k + i__) * v_dim1] = vii;
-          }
-
-          /*                 T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i) */
-
-          i__1 = *k - i__;
-          dtrmv_("Lower", "No transpose", "Non-unit", &i__1, &t[i__ + 1 + (i__ + 1) * t_dim1], ldt,
-                 &t[i__ + 1 + i__ * t_dim1], &c__1);
-          if (i__ > 1) {
-            prevlastv = min(prevlastv, lastv);
-          } else {
-            prevlastv = lastv;
-          }
-        }
-        t[i__ + i__ * t_dim1] = tau[i__];
-      }
-      /* L40: */
-    }
-  }
-
-  /*     End of DLARFT */
-
-} /* dlarft_ */
diff --git a/lapack/double.cpp b/lapack/double.cpp
index 9e57e90..5d0fa09 100644
--- a/lapack/double.cpp
+++ b/lapack/double.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR double
 #define SCALAR_SUFFIX d
@@ -16,3 +17,5 @@
 #include "lu.inc"
 #include "eigenvalues.inc"
 #include "svd.inc"
+#include "householder.inc"
+#include "utilities.inc"
diff --git a/lapack/dsecnd_INT_CPU_TIME.cpp b/lapack/dsecnd_INT_CPU_TIME.cpp
index 7dfc5e2..258777e 100644
--- a/lapack/dsecnd_INT_CPU_TIME.cpp
+++ b/lapack/dsecnd_INT_CPU_TIME.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifdef _WIN32
 #include <cstdint>
diff --git a/lapack/eigen_lapack.def b/lapack/eigen_lapack.def
index 4e882cd..7de9e00 100644
--- a/lapack/eigen_lapack.def
+++ b/lapack/eigen_lapack.def
@@ -2,9 +2,49 @@
 
 LIBRARY eigen_lapack
 EXPORTS
-    ; Eigen C/C++ implementations
     ; Utilities
     xerbla_
+    ilaver_
+    slamch_
+    dlamch_
+    slamc3_
+    dlamc3_
+    slapy2_
+    dlapy2_
+    slapy3_
+    dlapy3_
+    sladiv_
+    dladiv_
+    cladiv_
+    zladiv_
+    clacgv_
+    zlacgv_
+    ilaclc_
+    ilaclr_
+    iladlc_
+    iladlr_
+    ilaslc_
+    ilaslr_
+    ilazlc_
+    ilazlr_
+
+    ; Householder
+    slarfg_
+    dlarfg_
+    clarfg_
+    zlarfg_
+    slarf_
+    dlarf_
+    clarf_
+    zlarf_
+    slarft_
+    dlarft_
+    clarft_
+    zlarft_
+    slarfb_
+    dlarfb_
+    clarfb_
+    zlarfb_
 
     ; Eigenvalues
     ssyev_
@@ -44,46 +84,6 @@
     second_
     dsecnd_
 
-    ; Fortran implementations
-    clacgv_
-    zlacgv_
-    sladiv_
-    dladiv_
-    cladiv_
-    zladiv_
-    slamch_
-    dlamch_
-    slamc3_
-    dlamc3_
-    slapy2_
-    dlapy2_
-    slapy3_
-    dlapy3_
-    slarf_
-    dlarf_
-    clarf_
-    zlarf_
-    slarfb_
-    dlarfb_
-    clarfb_
-    zlarfb_
-    slarfg_
-    dlarfg_
-    clarfg_
-    zlarfg_
-    slarft_
-    dlarft_
-    clarft_
-    zlarft_
-    ilaclc_
-    ilaclr_
-    iladlc_
-    iladlr_
-    ilaslc_
-    ilaslr_
-    ilazlc_
-    ilazlr_
-
     ; Missing
     ; csymv_
     ; zsymv_
diff --git a/lapack/eigen_lapack_cpp.def b/lapack/eigen_lapack_cpp.def
deleted file mode 100644
index 4df600b..0000000
--- a/lapack/eigen_lapack_cpp.def
+++ /dev/null
@@ -1,143 +0,0 @@
-; Definition file for eigen_lapack.dll, containing only the C++ implementations.
-
-LIBRARY eigen_lapack
-EXPORTS
-    ; Eigen C/C++ implementations
-    ; Utilities
-    xerbla_
-
-    ; Eigenvalues
-    ssyev_
-    dsyev_
-
-    ; LU
-    sgetrf_
-    sgetrs_
-    dgetrf_
-    dgetrs_
-    cgetrf_
-    cgetrs_
-    zgetrf_
-    zgetrs_
-
-    ; QR
-    spotrf_
-    spotrs_
-    dpotrf_
-    dpotrs_
-    cpotrf_
-    cpotrs_
-    zpotrf_
-    zpotrs_
-
-    ; SVD
-    sgesdd_
-    sgesvd_
-    dgesdd_
-    dgesvd_
-    cgesdd_
-    cgesvd_
-    zgesdd_
-    zgesvd_
-
-    ; Time
-    second_
-    dsecnd_
-
-    ; Fortran implementations
-    ; clacgv_
-    ; zlacgv_
-    ; sladiv_
-    ; dladiv_
-    ; cladiv_
-    ; zladiv_
-    ; slamch_
-    ; dlamch_
-    ; slamc3_
-    ; dlamc3_
-    ; slapy2_
-    ; dlapy2_
-    ; slapy3_
-    ; dlapy3_
-    ; slarf_
-    ; dlarf_
-    ; clarf_
-    ; zlarf_
-    ; slarfb_
-    ; dlarfb_
-    ; clarfb_
-    ; zlarfb_
-    ; slarfg_
-    ; dlarfg_
-    ; clarfg_
-    ; zlarfg_
-    ; slarft_
-    ; dlarft_
-    ; clarft_
-    ; zlarft_
-    ; ilaclc_
-    ; ilaclr_
-    ; iladlc_
-    ; iladlr_
-    ; ilaslc_
-    ; ilaslr_
-    ; ilazlc_
-    ; ilazlr_
-
-    ; Missing
-    ; csymv_
-    ; zsymv_
-    ; cspmv_
-    ; zspmv_
-    ; csyr_
-    ; zsyr_
-    ; cspr_
-    ; zspr_
-    ; sgemt_
-    ; dgemt_
-    ; cgemt_
-    ; zgemt_
-    ; sgema_
-    ; dgema_
-    ; cgema_
-    ; zgema_
-    ; sgems_
-    ; dgems_
-    ; cgems_
-    ; zgems_
-    ; sgetf2_
-    ; dgetf2_
-    ; cgetf2_
-    ; zgetf2_
-    ; slaswp_
-    ; dlaswp_
-    ; claswp_
-    ; zlaswp_
-    ; sgesv_
-    ; dgesv_
-    ; cgesv_
-    ; zgesv_
-    ; spotf2_
-    ; dpotf2_
-    ; cpotf2_
-    ; zpotf2_
-    ; slauu2_
-    ; dlauu2_
-    ; clauu2_
-    ; zlauu2_
-    ; slauum_
-    ; dlauum_
-    ; clauum_
-    ; zlauum_
-    ; strti2_
-    ; dtrti2_
-    ; ctrti2_
-    ; ztrti2_
-    ; strtri_
-    ; dtrtri_
-    ; ctrtri_
-    ; ztrtri_
-    ; spotri_
-    ; dpotri_
-    ; cpotri_
-    ; zpotri_
diff --git a/lapack/eigenvalues.inc b/lapack/eigenvalues.inc
index c67c825..0a8902d 100644
--- a/lapack/eigenvalues.inc
+++ b/lapack/eigenvalues.inc
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "lapack_common.h"
 #include <Eigen/Eigenvalues>
@@ -31,7 +32,7 @@
 
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "SYEV ", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "SYEV ", &e, kBlasNameLength);
   }
 
   if (query_size) {
diff --git a/lapack/experimental/README.md b/lapack/experimental/README.md
deleted file mode 100644
index 86aaace..0000000
--- a/lapack/experimental/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-This directory contains C++11 replacment for the f2c-ed functions in the lapack
-directory. This is a temporary directory, which is being used to develop and
-stage these changes, once this code is upstreamed, it will be deleted.
diff --git a/lapack/experimental/ilaver.cpp b/lapack/experimental/ilaver.cpp
deleted file mode 100644
index ddab5dd..0000000
--- a/lapack/experimental/ilaver.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "../../Eigen/Core"
-
-extern "C" {
-void ilaver_(int* major, int* minor, int* patch);
-}
-
-void ilaver_(int* major, int* minor, int* patch) {
-  *major = EIGEN_WORLD_VERSION;
-  *minor = EIGEN_MAJOR_VERSION;
-  *patch = EIGEN_MINOR_VERSION;
-}
diff --git a/lapack/experimental/ilaxly.cpp b/lapack/experimental/ilaxly.cpp
deleted file mode 100644
index c2e56a2..0000000
--- a/lapack/experimental/ilaxly.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "../../Eigen/Core"
-
-extern "C" {
-int ilaslc_(int *m, int *n, float *a, int *lda);
-int iladlc_(int *m, int *n, double *a, int *lda);
-int ilaclc_(int *m, int *n, std::complex<float> *a, int *lda);
-int ilazlc_(int *m, int *n, std::complex<double> *a, int *lda);
-int ilaslr_(int *m, int *n, float *a, int *lda);
-int iladlr_(int *m, int *n, double *a, int *lda);
-int ilaclr_(int *m, int *n, std::complex<float> *a, int *lda);
-int ilazlr_(int *m, int *n, std::complex<double> *a, int *lda);
-}
-
-using Eigen::ColMajor;
-using Eigen::Dynamic;
-using Eigen::Map;
-using Eigen::Matrix;
-using Eigen::OuterStride;
-
-// Scan a matrix for its last non-zero column.
-template <typename T>
-int ilaxlc(const int m, const int n, T *a, const int lda) {
-  if (n == 0) return 0;
-  using MatrixType =
-      Map<Matrix<T, Dynamic, Dynamic, ColMajor>, 0, OuterStride<>>;
-  MatrixType a_matrix(a, m, n, OuterStride<>(lda));
-
-  // Quick test for the common case where one corner is non-zero.
-  if ((a_matrix(0, n - 1) != T(0)) || (a_matrix(m - 1, n - 1) != T(0))) {
-    return n;
-  }
-
-  // Now scan each column from the end, returning with the first non-zero.
-  int c = n - 1;
-  for (; c >= 0; --c) {
-    if ((a_matrix.array().col(c) != T(0)).any()) {
-      break;
-    }
-  }
-  return c + 1;
-}
-
-int ilaslc_(int *m, int *n, float *a, int *lda) {
-  return ilaxlc(*m, *n, a, *lda);
-}
-
-int iladlc_(int *m, int *n, double *a, int *lda) {
-  return ilaxlc(*m, *n, a, *lda);
-}
-
-int ilaclc_(int *m, int *n, std::complex<float> *a, int *lda) {
-  return ilaxlc(*m, *n, a, *lda);
-}
-
-int ilazlc_(int *m, int *n, std::complex<double> *a, int *lda) {
-  return ilaxlc(*m, *n, a, *lda);
-}
-
-// Scan a matrix for its last non-zero row.
-template <typename T>
-int ilaxlr(const int m, const int n, T *a, const int lda) {
-  if (m == 0) return m;
-  using MatrixType =
-      Map<Matrix<T, Dynamic, Dynamic, ColMajor>, 0, OuterStride<>>;
-  MatrixType a_matrix(a, m, n, OuterStride<>(lda));
-
-  // Quick test for the common case where one corner is non-zero.
-  if ((a_matrix(m - 1, 0) != T(0)) || (a_matrix(m - 1, n - 1) != T(0))) {
-    return m;
-  }
-
-  // Now scan each rowfrom the end, returning with the first non-zero.
-  int r = m - 1;
-  for (; r >= 0; --r) {
-    if ((a_matrix.array().row(r) == T(0)).any()) {
-      break;
-    }
-  }
-  return r + 1;
-}
-
-int ilaslr_(int *m, int *n, float *a, int *lda) {
-  return ilaxlr(*m, *n, a, *lda);
-}
-
-int iladlr_(int *m, int *n, double *a, int *lda) {
-  return ilaxlr(*m, *n, a, *lda);
-}
-
-int ilaclr_(int *m, int *n, std::complex<float> *a, int *lda) {
-  return ilaxlr(*m, *n, a, *lda);
-}
-
-int ilazlr_(int *m, int *n, std::complex<double> *a, int *lda) {
-  return ilaxlr(*m, *n, a, *lda);
-}
diff --git a/lapack/experimental/xlacgv.cpp b/lapack/experimental/xlacgv.cpp
deleted file mode 100644
index d022a3b..0000000
--- a/lapack/experimental/xlacgv.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "../../Eigen/Core"
-
-extern "C" {
-void clacgv_(int *n, std::complex<float> *x, int *incx);
-void zlacgv_(int *n, std::complex<double> *x, int *incx);
-}
-
-using Eigen::Map;
-using Eigen::Matrix;
-using Eigen::Dynamic;
-using Eigen::InnerStride;
-
-// Conjugate the entries of the vector x.
-template <typename T>
-void xlacgv(const int n,  T *x, const int incx) {
-  using StridedVector = Map<Matrix<T, Dynamic, 1>, 0, InnerStride<Dynamic>>;
-  StridedVector xvec(x, n, InnerStride<Dynamic>(std::abs(incx)));
-  xvec = xvec.conjugate();
-}
-
-void clacgv_(int *n, std::complex<float> *x, int *incx) {
-  xlacgv(*n, x, *incx);
-}
-
-void zlacgv_(int *n, std::complex<double> *x, int *incx) {
-  xlacgv(*n, x, *incx);
-}
diff --git a/lapack/experimental/xladiv.cpp b/lapack/experimental/xladiv.cpp
deleted file mode 100644
index 381950f..0000000
--- a/lapack/experimental/xladiv.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include <cmath>
-#include <complex>
-
-extern "C" {
-void sladiv_(float* a, float* b, float* c, float* d, float* p, float* q);
-void dladiv_(double* a, double* b, double* c, double* d, double* p, double* q);
-std::complex<float> cladiv_(std::complex<float>* x, std::complex<float>* y);
-std::complex<double> zladiv_(std::complex<double>* x, std::complex<double>* y);
-}
-
-// This implementation is from pg. 21
-// http://www.open-std.org/jtc1/sc22/wg11/docs/n435.pdf and LLVM's libc++.
-template <typename T>
-void complex_divide(T a, T b, T c, T d, T& x, T& y) {
-  int ilogbw = 0;
-  const T logbw = std::logb(std::fmax(std::abs(c), std::abs(d)));
-  if (std::isfinite(logbw)) {
-    ilogbw = static_cast<int>(logbw);
-    c = scalbn(c, -ilogbw);
-    d = scalbn(d, -ilogbw);
-  }
-  const T denom = c * c + d * d;
-
-  x = scalbn((a * c + b * d) / denom, -ilogbw);
-  y = scalbn((b * c - a * d) / denom, -ilogbw);
-  if (std::isnan(x) && std::isnan(y)) {
-    if ((denom == T(0)) && (!std::isnan(a) || !std::isnan(b))) {
-      x = std::copysign(std::numeric_limits<T>::infinity(), c) * a;
-      y = std::copysign(std::numeric_limits<T>::infinity(), c) * b;
-    } else if ((std::isinf(a) || std::isinf(b)) && std::isfinite(c) &&
-               std::isfinite(d)) {
-      a = std::copysign(std::isinf(a) ? T(1) : T(0), a);
-      b = std::copysign(std::isinf(b) ? T(1) : T(0), b);
-      x = std::numeric_limits<T>::infinity() * (a * c + b * d);
-      y = std::numeric_limits<T>::infinity() * (b * c - a * d);
-    } else if (std::isinf(logbw) && logbw > T(0) && std::isfinite(a) &&
-               std::isfinite(b)) {
-      c = std::copysign(std::isinf(c) ? T(1) : T(0), c);
-      d = std::copysign(std::isinf(d) ? T(1) : T(0), d);
-      x = T(0) * (a * c + b * d);
-      y = T(0) * (b * c - a * d);
-    }
-  }
-}
-
-void sladiv_(float* a, float* b, float* c, float* d, float* p, float* q) {
-  complex_divide(*a, *b, *c, *d, *p, *q);
-}
-
-void dladiv_(double* a, double* b, double* c, double* d, double* p, double* q) {
-  complex_divide(*a, *b, *c, *d, *p, *q);
-}
-
-std::complex<float> cladiv_(std::complex<float>* x, std::complex<float>* y) {
-  float p, q;
-  complex_divide(x->real(), x->imag(), y->real(), y->imag(), p, q);
-  return std::complex<float>(p, q);
-}
-
-std::complex<double> zladiv_(std::complex<double>* x, std::complex<double>* y) {
-  double p, q;
-  complex_divide(x->real(), x->imag(), y->real(), y->imag(), p, q);
-  return std::complex<double>(p, q);
-}
diff --git a/lapack/experimental/xlamch.cpp b/lapack/experimental/xlamch.cpp
deleted file mode 100644
index 79efd80..0000000
--- a/lapack/experimental/xlamch.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include <limits>
-
-#include "../../Eigen/Core"
-
-extern "C" {
-float slamch_(char* cmach);
-double dlamch_(char* cmach);
-float slamc3_(char* cmach);
-double dlamc3_(char* cmach);
-}
-
-// Determines machine parameters.
-template <typename T>
-T xlamch(const char c) {
-  if (c == 'E' || c == 'e') {
-    // eps = relative machine precision. Looking at
-    // https://gcc.gnu.org/onlinedocs/gfortran/EPSILON.html observe that it is
-    // the smallest number E such that 1 + E > 1. It is NOT the same as
-    // numeric_limits::epsilon, which is the difference between 1 and the
-    // floating point number that succeeds it.
-    return std::numeric_limits<T>::epsilon() / std::numeric_limits<T>::radix;
-  }
-
-  if (c == 'S' || c == 's') {
-    // sfmin = safe minimum, such that 1 / sfmin does not overflow
-    EIGEN_CONSTEXPR T tiny = std::numeric_limits<T>::min();
-    EIGEN_CONSTEXPR T small = T(1) / std::numeric_limits<T>::max();
-    EIGEN_CONSTEXPR T small_scaled =
-        small * (T(1) + std::numeric_limits<T>::epsilon());
-    return (small >= tiny) ? small_scaled : tiny;
-  }
-
-  if (c == 'B' || c == 'b') {
-    // base =  base of the machine.
-    return std::numeric_limits<T>::radix;
-  }
-
-  if (c == 'P' || c == 'p') {
-    // prec = eps * base
-    return std::numeric_limits<T>::epsilon();
-  }
-
-  if (c == 'N' || c == 'n') {
-    // t = number of (base) digits in the mantissa
-    return std::numeric_limits<T>::digits;
-  }
-
-  if (c == 'R' || c == 'r') {
-    // rnd = 1.0 when rounding occurs in addition.
-    return 1;
-  }
-
-  if (c == 'M' || c == 'm') {
-    // emin = minimum exponent before (gradual) underflow
-    return std::numeric_limits<T>::min_exponent;
-  }
-
-  if (c == 'U' || c == 'u') {
-    // rmin =  underflow threshold - base**(emin-1)
-    return std::numeric_limits<T>::min();
-  }
-
-  if (c == 'L' || c == 'l') {
-    // emax = largest exponent before overflow
-    return std::numeric_limits<T>::max_exponent;
-  }
-  if (c == 'O' || c == 'o') {
-    // rmax  = overflow threshold  - (base**emax)*(1-eps)
-    return std::numeric_limits<T>::max();
-  }
-
-  return 0;
-}
-
-float slamch_(char* cmach) { return xlamch<float>(*cmach); }
-double dlamch_(char* cmach) { return xlamch<double>(*cmach); }
-
-// xLAMC3  is intended to force  A  and  B  to be stored prior to doing
-// the addition of  A  and  B ,  for use in situations where optimizers
-// might hold one of these in a register.
-float slamc3_(float* a, float* b) {
-  volatile float retval = *a + *b;
-  return retval;
-}
-
-double dlamc3_(double* a, double* b) {
-  volatile double retval = *a + *b;
-  return retval;
-}
diff --git a/lapack/experimental/xlapy2.cpp b/lapack/experimental/xlapy2.cpp
deleted file mode 100644
index 5992f9e..0000000
--- a/lapack/experimental/xlapy2.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <algorithm>
-#include <cmath>
-
-extern "C" {
-float slapy2_(float* x, float* y);
-double dlapy2_(double* x, double* y);
-}
-
-// Compute sqrt(x*x + y*y) taking care not to cause unnecessary overflow.
-template <typename T>
-T xlapy2(const T x, const T y) {
-  const T xabs = std::abs(x);
-  const T yabs = std::abs(y);
-  const T w = std::fmax(xabs, yabs);
-  const T z = std::fmin(xabs, yabs);
-  if (z > T(0)) {
-    const T t = z / w;
-    return w * std::sqrt(T(1) + t * t);
-  }
-  return w;
-}
-
-float slapy2_(float* x, float* y) { return xlapy2(*x, *y); }
-double dlapy2_(double* x, double* y) { return xlapy2(*x, *y); }
diff --git a/lapack/experimental/xlapy3.cpp b/lapack/experimental/xlapy3.cpp
deleted file mode 100644
index 9c935fa..0000000
--- a/lapack/experimental/xlapy3.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <algorithm>
-#include <cmath>
-
-extern "C" {
-float slapy3_(float* x, float* y, float* z);
-double dlapy3_(double* x, double* y, double* z);
-}
-
-// Compute sqrt(x*x + y*y + z*z) taking care not to cause unnecessary overflow.
-template <typename T>
-T xlapy3(const T x, const T y, const T z) {
-  const T xabs = std::abs(x);
-  const T yabs = std::abs(y);
-  const T zabs = std::abs(z);
-  const T w = std::fmax(std::fmax(xabs, yabs), zabs);
-
-  if (w == T(0)) {
-    // W can be zero for max(0,nan,0) adding all three entries together will
-    // make sure NaN will not disappear.
-    return (xabs + yabs + zabs);
-  }
-
-  const T tx = xabs / w;
-  const T ty = yabs / w;
-  const T tz = zabs / w;
-  return w * std::sqrt(tx * tx + ty * ty + tz * tz);
-}
-
-float slapy3_(float* x, float* y, float* z) { return xlapy3(*x, *y, *z); }
-double dlapy3_(double* x, double* y, double* z) { return xlapy3(*x, *y, *z); }
diff --git a/lapack/experimental/xsecnd.cpp b/lapack/experimental/xsecnd.cpp
deleted file mode 100644
index d9e3879..0000000
--- a/lapack/experimental/xsecnd.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <ctime>
-
-extern "C" {
-float second_();
-double dsecnd_();
-}
-
-// Elapsed CPU Time in seconds.
-float second_(float* x, float* y) {
-  return static_cast<float>(std::clock()) / static_cast<float>(CLOCKS_PER_SEC);
-}
-
-double dsecnd_(double* x, double* y) {
-  return static_cast<double>(std::clock()) /
-         static_cast<double>(CLOCKS_PER_SEC);
-}
diff --git a/lapack/householder.inc b/lapack/householder.inc
new file mode 100644
index 0000000..f3e91d4
--- /dev/null
+++ b/lapack/householder.inc
@@ -0,0 +1,809 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 The Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "lapack_common.h"
+
+// Architectural Note:
+// Eigen's internal Householder routines (Eigen/src/Householder/) implement a subset of
+// operations (primarily Left / Forward / Columnwise reflectors). LAPACK routines (larfg,
+// larf, larft, larfb) require the complete Cartesian product of side (Left/Right) x
+// trans (NoTrans/ConjTrans) x direct (Forward/Backward) x storev (Columnwise/Rowwise),
+// as well as Netlib-compliant scaling (safmin/xlamch) and reflector sign conventions.
+// They are implemented natively here with zero dynamic heap allocations.
+
+// LARFG generates an elementary reflector H of order n, such that
+// H * [alpha, x]^T = [beta, 0]^T, H^* * H = I.
+EIGEN_LAPACK_FUNC(larfg)(int* n, RealScalar* palpha, RealScalar* px, int* incx, RealScalar* ptau) {
+  Scalar* alpha = reinterpret_cast<Scalar*>(palpha);
+  Scalar* x = reinterpret_cast<Scalar*>(px);
+  Scalar* tau = reinterpret_cast<Scalar*>(ptau);
+
+  if (*n <= 0) {
+    *tau = Scalar(0);
+    return;
+  }
+
+  int m = *n - 1;
+  RealScalar xnorm = RealScalar(0);
+  if (m > 0) {
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > xvec(
+        x, m, Eigen::InnerStride<Eigen::Dynamic>(*incx));
+    xnorm = xvec.stableNorm();
+  }
+
+#if !ISCOMPLEX
+  if (m == 0 || xnorm == RealScalar(0)) {
+    *tau = Scalar(0);
+    return;
+  }
+
+  RealScalar alphar = *alpha;
+  RealScalar beta = -Eigen::numext::copysign(Eigen::internal::xlapy2(alphar, xnorm), alphar);
+  RealScalar safmin = Eigen::internal::xlamch<RealScalar>('S') / Eigen::internal::xlamch<RealScalar>('E');
+  int knt = 0;
+  if (Eigen::numext::abs(beta) < safmin) {
+    RealScalar rsafmn = RealScalar(1) / safmin;
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > xvec(
+        x, m, Eigen::InnerStride<Eigen::Dynamic>(*incx));
+    do {
+      ++knt;
+      xvec *= rsafmn;
+      beta *= rsafmn;
+      alphar *= rsafmn;
+    } while (Eigen::numext::abs(beta) < safmin);
+
+    xnorm = xvec.stableNorm();
+    beta = -Eigen::numext::copysign(Eigen::internal::xlapy2(alphar, xnorm), alphar);
+  }
+
+  *tau = (beta - alphar) / beta;
+  {
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > xvec(
+        x, m, Eigen::InnerStride<Eigen::Dynamic>(*incx));
+    xvec *= (RealScalar(1) / (alphar - beta));
+  }
+
+  for (int j = 0; j < knt; ++j) {
+    beta *= safmin;
+  }
+  *alpha = beta;
+
+#else
+  RealScalar alphr = Eigen::numext::real(*alpha);
+  RealScalar alphi = Eigen::numext::imag(*alpha);
+
+  if (Eigen::numext::is_exactly_zero(xnorm) && Eigen::numext::is_exactly_zero(alphi)) {
+    *tau = Scalar(0);
+    return;
+  }
+
+  RealScalar beta = -Eigen::numext::copysign(Eigen::internal::xlapy3(alphr, alphi, xnorm), alphr);
+  RealScalar safmin = Eigen::internal::xlamch<RealScalar>('S') / Eigen::internal::xlamch<RealScalar>('E');
+  RealScalar rsafmn = RealScalar(1) / safmin;
+  int knt = 0;
+
+  if (Eigen::numext::abs(beta) < safmin) {
+    do {
+      ++knt;
+      if (m > 0) {
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > xvec(
+            x, m, Eigen::InnerStride<Eigen::Dynamic>(*incx));
+        xvec *= rsafmn;
+      }
+      beta *= rsafmn;
+      alphi *= rsafmn;
+      alphr *= rsafmn;
+    } while (Eigen::numext::abs(beta) < safmin);
+
+    if (m > 0) {
+      Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > xvec(
+          x, m, Eigen::InnerStride<Eigen::Dynamic>(*incx));
+      xnorm = xvec.stableNorm();
+    }
+    *alpha = Scalar(alphr, alphi);
+    beta = -Eigen::numext::copysign(Eigen::internal::xlapy3(alphr, alphi, xnorm), alphr);
+  }
+
+  *tau = Scalar((beta - alphr) / beta, -alphi / beta);
+  Scalar denom = *alpha - beta;
+  // For consistency with LAPACK (CLARFG/ZLARFG), compute 1 / (alpha - beta) via xladiv
+  // (Smith's algorithm) to avoid intermediate overflow when scaling the reflector vector.
+  Scalar scale = Eigen::internal::xladiv(Scalar(1), denom);
+  if (m > 0) {
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > xvec(
+        x, m, Eigen::InnerStride<Eigen::Dynamic>(*incx));
+    xvec *= scale;
+  }
+
+  for (int j = 0; j < knt; ++j) {
+    beta *= safmin;
+  }
+  *alpha = Scalar(beta, RealScalar(0));
+#endif
+}
+
+// LARF applies an elementary reflector H = I - tau * v * v^* to matrix C from either left or right.
+EIGEN_LAPACK_FUNC(larf)
+(const char* side, int* m, int* n, RealScalar* pv, int* incv, RealScalar* ptau, RealScalar* pc, int* ldc,
+ RealScalar* pwork) {
+  if (*m <= 0 || *n <= 0) return;
+
+  Scalar* v = reinterpret_cast<Scalar*>(pv);
+  Scalar* tau = reinterpret_cast<Scalar*>(ptau);
+  Scalar* c = reinterpret_cast<Scalar*>(pc);
+  Scalar* work = reinterpret_cast<Scalar*>(pwork);
+
+  if (*tau == Scalar(0)) return;
+
+  bool applyleft = (SIDE(*side) == LEFT);
+  int lastv = applyleft ? *m : *n;
+
+  if (*incv > 0) {
+    int idx = (lastv - 1) * *incv;
+    while (lastv > 0 && v[idx] == Scalar(0)) {
+      --lastv;
+      idx -= *incv;
+    }
+  } else {
+    int idx = 0;
+    while (lastv > 0 && v[idx] == Scalar(0)) {
+      --lastv;
+      idx -= *incv;
+    }
+  }
+
+  if (lastv == 0) return;
+
+  int lastc = 0;
+  if (applyleft) {
+    lastc = Eigen::internal::ilaxlc(lastv, *n, c, *ldc);
+  } else {
+    lastc = Eigen::internal::ilaxlr(*m, lastv, c, *ldc);
+  }
+
+  if (lastc == 0) return;
+
+  if (applyleft) {
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C_sub(
+        c, lastv, lastc, Eigen::OuterStride<>(*ldc));
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1> > w(work, lastc);
+
+    if (*incv > 0) {
+      Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > v_sub(
+          v, lastv, Eigen::InnerStride<Eigen::Dynamic>(*incv));
+      w.noalias() = C_sub.adjoint() * v_sub;
+      C_sub.noalias() -= (*tau) * (v_sub * w.adjoint());
+    } else {
+      Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > v_fwd(
+          v, lastv, Eigen::InnerStride<Eigen::Dynamic>(-*incv));
+      auto v_sub = v_fwd.reverse();
+      w.noalias() = C_sub.adjoint() * v_sub;
+      C_sub.noalias() -= (*tau) * (v_sub * w.adjoint());
+    }
+  } else {
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C_sub(
+        c, lastc, lastv, Eigen::OuterStride<>(*ldc));
+    Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, 1> > w(work, lastc);
+
+    if (*incv > 0) {
+      Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > v_sub(
+          v, lastv, Eigen::InnerStride<Eigen::Dynamic>(*incv));
+      w.noalias() = C_sub * v_sub;
+      C_sub.noalias() -= (*tau) * (w * v_sub.adjoint());
+    } else {
+      Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> > v_fwd(
+          v, lastv, Eigen::InnerStride<Eigen::Dynamic>(-*incv));
+      auto v_sub = v_fwd.reverse();
+      w.noalias() = C_sub * v_sub;
+      C_sub.noalias() -= (*tau) * (w * v_sub.adjoint());
+    }
+  }
+}
+
+// LARFT forms the triangular factor T of a block reflector H of order n.
+EIGEN_LAPACK_FUNC(larft)
+(const char* direct, const char* storev, int* n, int* k, RealScalar* pv, int* ldv, RealScalar* ptau, RealScalar* pt,
+ int* ldt) {
+  if (*n == 0 || *k == 0) return;
+
+  const Scalar* v = reinterpret_cast<const Scalar*>(pv);
+  Scalar* tau = reinterpret_cast<Scalar*>(ptau);
+  Scalar* t = reinterpret_cast<Scalar*>(pt);
+
+  bool forward = (*direct == 'F' || *direct == 'f');
+  bool colwise = (*storev == 'C' || *storev == 'c');
+
+  Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > T_mat(
+      t, *k, *k, Eigen::OuterStride<>(*ldt));
+
+  if (forward) {
+    int prevlastv = *n;
+    for (int i = 0; i < *k; ++i) {
+      prevlastv = Eigen::numext::maxi(prevlastv, i + 1);
+      if (tau[i] == Scalar(0)) {
+        for (int j = 0; j <= i; ++j) {
+          T_mat(j, i) = Scalar(0);
+        }
+      } else {
+        int lastv = i;
+        if (colwise) {
+          for (lastv = *n - 1; lastv >= i + 1; --lastv) {
+            if (v[lastv + i * (*ldv)] != Scalar(0)) break;
+          }
+          int j = Eigen::numext::mini(lastv, prevlastv - 1);
+          if (i > 0) {
+            // Reflectors v(i, 0..i-1) have implicit unit diagonal at row i.
+            // Split dot product: V_prev(i, :)^H * 1 + V_prev(i+1:j, :)^H * V_cur(i+1:j)
+            // avoiding mutation of v[i + i*ldv].
+            Eigen::Map<const Eigen::Matrix<Scalar, 1, Eigen::Dynamic>, 0, Eigen::InnerStride<Eigen::Dynamic> >
+                V_prev_row(&v[i], i, Eigen::InnerStride<Eigen::Dynamic>(*ldv));
+            T_mat.col(i).head(i).noalias() = -tau[i] * V_prev_row.conjugate().transpose();
+
+            if (j > i) {
+              int len_sub = j - i;
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                         Eigen::OuterStride<> >
+                  V_prev_sub(&v[i + 1], len_sub, i, Eigen::OuterStride<>(*ldv));
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> > V_cur_sub(&v[(i + 1) + i * (*ldv)], len_sub);
+              T_mat.col(i).head(i).noalias() += -tau[i] * (V_prev_sub.adjoint() * V_cur_sub);
+            }
+          }
+        } else {
+          for (lastv = *n - 1; lastv >= i + 1; --lastv) {
+            if (v[i + lastv * (*ldv)] != Scalar(0)) break;
+          }
+          int j = Eigen::numext::mini(lastv, prevlastv - 1);
+          if (i > 0) {
+            // Reflectors v(0..i-1, i) have implicit unit diagonal at col i.
+            // Split dot product: V_prev(:, i) * 1 + V_prev(:, i+1:j) * V_cur(i+1:j)^*
+            // avoiding mutation of v[i + i*ldv].
+            Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> > V_prev_col(&v[i * (*ldv)], i);
+            T_mat.col(i).head(i).noalias() = -tau[i] * V_prev_col;
+
+            if (j > i) {
+              int len_sub = j - i;
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                         Eigen::OuterStride<> >
+                  V_prev_sub(&v[(i + 1) * (*ldv)], i, len_sub, Eigen::OuterStride<>(*ldv));
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> >
+                  V_cur_sub(&v[i + (i + 1) * (*ldv)], len_sub, Eigen::InnerStride<Eigen::Dynamic>(*ldv));
+              T_mat.col(i).head(i).noalias() += -tau[i] * (V_prev_sub * V_cur_sub.conjugate());
+            }
+          }
+        }
+
+        if (i > 0) {
+          // In-place triangular update: T(0:i-1, i) = T(0:i-1, 0:i-1) * T(0:i-1, i)
+          for (int r = 0; r < i; ++r) {
+            Scalar sum = Scalar(0);
+            for (int c = r; c < i; ++c) {
+              sum += T_mat(r, c) * T_mat(c, i);
+            }
+            T_mat(r, i) = sum;
+          }
+        }
+        T_mat(i, i) = tau[i];
+        if (i > 0) {
+          prevlastv = Eigen::numext::maxi(prevlastv, lastv + 1);
+        } else {
+          prevlastv = lastv + 1;
+        }
+      }
+    }
+  } else {
+    int prevlastv = 0;
+    for (int i = *k - 1; i >= 0; --i) {
+      if (tau[i] == Scalar(0)) {
+        for (int j = i; j < *k; ++j) {
+          T_mat(j, i) = Scalar(0);
+        }
+      } else {
+        if (i < *k - 1) {
+          int lastv = 0;
+          int num_vecs = *k - 1 - i;
+          if (colwise) {
+            int diag_row = *n - *k + i;
+            for (lastv = 0; lastv < i; ++lastv) {
+              if (v[lastv + i * (*ldv)] != Scalar(0)) break;
+            }
+            int j = Eigen::numext::maxi(lastv, prevlastv);
+
+            // Reflectors v(j..diag_row, i+1..k-1) have implicit unit diagonal at row diag_row.
+            // Split dot product: V_rest(diag_row, :)^H * 1 + V_rest(j:diag_row-1, :)^H * V_cur(j:diag_row-1)
+            // avoiding mutation of v[diag_row + i*ldv].
+            Eigen::Map<const Eigen::Matrix<Scalar, 1, Eigen::Dynamic>, 0, Eigen::InnerStride<Eigen::Dynamic> >
+                V_rest_row(&v[diag_row + (i + 1) * (*ldv)], num_vecs, Eigen::InnerStride<Eigen::Dynamic>(*ldv));
+            T_mat.col(i).tail(num_vecs).noalias() = -tau[i] * V_rest_row.conjugate().transpose();
+
+            if (diag_row > j) {
+              int len_sub = diag_row - j;
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                         Eigen::OuterStride<> >
+                  V_rest_sub(&v[j + (i + 1) * (*ldv)], len_sub, num_vecs, Eigen::OuterStride<>(*ldv));
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> > V_cur_sub(&v[j + i * (*ldv)], len_sub);
+              T_mat.col(i).tail(num_vecs).noalias() += -tau[i] * (V_rest_sub.adjoint() * V_cur_sub);
+            }
+          } else {
+            int diag_col = *n - *k + i;
+            for (lastv = 0; lastv < i; ++lastv) {
+              if (v[i + lastv * (*ldv)] != Scalar(0)) break;
+            }
+            int j = Eigen::numext::maxi(lastv, prevlastv);
+
+            // Reflectors v(i+1..k-1, j..diag_col) have implicit unit diagonal at col diag_col.
+            // Split dot product: V_rest(:, diag_col) * 1 + V_rest(:, j:diag_col-1) * V_cur(j:diag_col-1)^*
+            // avoiding mutation of v[i + diag_col*ldv].
+            Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> > V_rest_col(&v[(i + 1) + diag_col * (*ldv)],
+                                                                                   num_vecs);
+            T_mat.col(i).tail(num_vecs).noalias() = -tau[i] * V_rest_col;
+
+            if (diag_col > j) {
+              int len_sub = diag_col - j;
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                         Eigen::OuterStride<> >
+                  V_rest_sub(&v[(i + 1) + j * (*ldv)], num_vecs, len_sub, Eigen::OuterStride<>(*ldv));
+              Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, 1>, 0, Eigen::InnerStride<Eigen::Dynamic> >
+                  V_cur_sub(&v[i + j * (*ldv)], len_sub, Eigen::InnerStride<Eigen::Dynamic>(*ldv));
+              T_mat.col(i).tail(num_vecs).noalias() += -tau[i] * (V_rest_sub * V_cur_sub.conjugate());
+            }
+          }
+
+          // In-place triangular update: T(i+1:k-1, i) = T(i+1:k-1, i+1:k-1) * T(i+1:k-1, i)
+          for (int r = num_vecs - 1; r >= 0; --r) {
+            int row = (i + 1) + r;
+            Scalar sum = Scalar(0);
+            for (int c = 0; c <= r; ++c) {
+              sum += T_mat(row, (i + 1) + c) * T_mat((i + 1) + c, i);
+            }
+            T_mat(row, i) = sum;
+          }
+
+          if (i < *k - 1) {
+            prevlastv = Eigen::numext::mini(prevlastv, lastv);
+          } else {
+            prevlastv = lastv;
+          }
+        }
+        T_mat(i, i) = tau[i];
+      }
+    }
+  }
+}
+
+namespace {
+
+// In-place triangular matrix multiplications: W = W * Tri
+// Updates W column-by-column directly within caller-supplied work buffer with zero heap allocations.
+
+template <bool UnitDiag, typename MatrixW, typename MatrixTri>
+void apply_triangular_right_upper(MatrixW& W, const MatrixTri& U) {
+  const Eigen::Index k = W.cols();
+  for (Eigen::Index j = k - 1; j >= 1; --j) {
+    if (!UnitDiag) {
+      W.col(j) *= U(j, j);
+    }
+    W.col(j).noalias() += W.leftCols(j) * U.col(j).head(j);
+  }
+  if (!UnitDiag && k > 0) {
+    W.col(0) *= U(0, 0);
+  }
+}
+
+template <bool UnitDiag, typename MatrixW, typename MatrixTri>
+void apply_triangular_right_lower(MatrixW& W, const MatrixTri& L) {
+  const Eigen::Index k = W.cols();
+  for (Eigen::Index j = 0; j < k - 1; ++j) {
+    const Eigen::Index tail_len = k - 1 - j;
+    if (!UnitDiag) {
+      W.col(j) *= L(j, j);
+    }
+    W.col(j).noalias() += W.rightCols(tail_len) * L.col(j).tail(tail_len);
+  }
+  if (!UnitDiag && k > 0) {
+    W.col(k - 1) *= L(k - 1, k - 1);
+  }
+}
+
+template <bool UnitDiag, typename MatrixW, typename MatrixTri>
+void apply_triangular_right_upper_adjoint(MatrixW& W, const MatrixTri& U) {
+  // U is Upper Triangular, so U^H is Lower Triangular.
+  const Eigen::Index k = W.cols();
+  for (Eigen::Index j = 0; j < k - 1; ++j) {
+    const Eigen::Index tail_len = k - 1 - j;
+    if (!UnitDiag) {
+      W.col(j) *= Eigen::numext::conj(U(j, j));
+    }
+    W.col(j).noalias() += W.rightCols(tail_len) * U.row(j).tail(tail_len).adjoint();
+  }
+  if (!UnitDiag && k > 0) {
+    W.col(k - 1) *= Eigen::numext::conj(U(k - 1, k - 1));
+  }
+}
+
+template <bool UnitDiag, typename MatrixW, typename MatrixTri>
+void apply_triangular_right_lower_adjoint(MatrixW& W, const MatrixTri& L) {
+  // L is Lower Triangular, so L^H is Upper Triangular.
+  const Eigen::Index k = W.cols();
+  for (Eigen::Index j = k - 1; j >= 1; --j) {
+    if (!UnitDiag) {
+      W.col(j) *= Eigen::numext::conj(L(j, j));
+    }
+    W.col(j).noalias() += W.leftCols(j) * L.row(j).head(j).adjoint();
+  }
+  if (!UnitDiag && k > 0) {
+    W.col(0) *= Eigen::numext::conj(L(0, 0));
+  }
+}
+
+}  // namespace
+
+// LARFB applies a block reflector H or its transpose/adjoint to matrix C.
+EIGEN_LAPACK_FUNC(larfb)
+(const char* side, const char* trans, const char* direct, const char* storev, int* m, int* n, int* k, RealScalar* pv,
+ int* ldv, RealScalar* pt, int* ldt, RealScalar* pc, int* ldc, RealScalar* pwork, int* ldwork) {
+  if (*m <= 0 || *n <= 0 || *k <= 0) return;
+
+  const Scalar* v = reinterpret_cast<const Scalar*>(pv);
+  const Scalar* t = reinterpret_cast<const Scalar*>(pt);
+  Scalar* c = reinterpret_cast<Scalar*>(pc);
+  Scalar* work = reinterpret_cast<Scalar*>(pwork);
+
+  bool applyleft = (SIDE(*side) == LEFT);
+  bool notran = (OP(*trans) == NOTR);
+  bool forward = (*direct == 'F' || *direct == 'f');
+  bool colwise = (*storev == 'C' || *storev == 'c');
+
+  Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+      T_mat(t, *k, *k, Eigen::OuterStride<>(*ldt));
+
+  int lastv = 0;
+  int lastc = 0;
+
+  if (colwise) {
+    if (forward) {
+      if (applyleft) {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlr(*m, *k, v, *ldv));
+        lastc = Eigen::internal::ilaxlc(lastv, *n, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C1(
+            c, *k, lastc, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V1(v, *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C1.adjoint() * V1.template triangularView<Eigen::UnitLower>();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k], lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k], lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C2.adjoint() * V2;
+        }
+
+        if (notran) {
+          apply_triangular_right_upper_adjoint<false>(W, T_mat);
+        } else {
+          apply_triangular_right_upper<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k], lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k], lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          C2.noalias() -= V2 * W.adjoint();
+        }
+
+        apply_triangular_right_lower_adjoint<true>(W, V1);
+        C1.noalias() -= W.adjoint();
+
+      } else {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlr(*n, *k, v, *ldv));
+        lastc = Eigen::internal::ilaxlr(*m, lastv, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C1(
+            c, lastc, *k, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V1(v, *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C1 * V1.template triangularView<Eigen::UnitLower>();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k * (*ldc)], lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k], lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C2 * V2;
+        }
+
+        if (notran) {
+          apply_triangular_right_upper<false>(W, T_mat);
+        } else {
+          apply_triangular_right_upper_adjoint<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k * (*ldc)], lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k], lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          C2.noalias() -= W * V2.adjoint();
+        }
+
+        apply_triangular_right_lower_adjoint<true>(W, V1);
+        C1.noalias() -= W;
+      }
+    } else {
+      // colwise && !forward
+      if (applyleft) {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlr(*m, *k, v, *ldv));
+        lastc = Eigen::internal::ilaxlc(lastv, *n, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C2(
+            &c[lastv - *k], *k, lastc, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V2(&v[lastv - *k], *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C2.adjoint() * V2.template triangularView<Eigen::UnitUpper>();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C1.adjoint() * V1;
+        }
+
+        if (notran) {
+          apply_triangular_right_lower_adjoint<false>(W, T_mat);
+        } else {
+          apply_triangular_right_lower<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          C1.noalias() -= V1 * W.adjoint();
+        }
+
+        apply_triangular_right_upper_adjoint<true>(W, V2);
+        C2.noalias() -= W.adjoint();
+
+      } else {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlr(*n, *k, v, *ldv));
+        lastc = Eigen::internal::ilaxlr(*m, lastv, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C2(
+            &c[(lastv - *k) * (*ldc)], lastc, *k, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V2(&v[lastv - *k], *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C2 * V2.template triangularView<Eigen::UnitUpper>();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C1 * V1;
+        }
+
+        if (notran) {
+          apply_triangular_right_lower<false>(W, T_mat);
+        } else {
+          apply_triangular_right_lower_adjoint<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, lastv - *k, *k, Eigen::OuterStride<>(*ldv));
+          C1.noalias() -= W * V1.adjoint();
+        }
+
+        apply_triangular_right_upper_adjoint<true>(W, V2);
+        C2.noalias() -= W;
+      }
+    }
+  } else {
+    // storev == 'R'
+    if (forward) {
+      if (applyleft) {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlc(*k, *m, v, *ldv));
+        lastc = Eigen::internal::ilaxlc(lastv, *n, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C1(
+            c, *k, lastc, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V1(v, *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C1.adjoint() * V1.template triangularView<Eigen::UnitUpper>().adjoint();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k], lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k * (*ldv)], *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C2.adjoint() * V2.adjoint();
+        }
+
+        if (notran) {
+          apply_triangular_right_upper_adjoint<false>(W, T_mat);
+        } else {
+          apply_triangular_right_upper<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k], lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k * (*ldv)], *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          C2.noalias() -= V2.adjoint() * W.adjoint();
+        }
+
+        apply_triangular_right_upper<true>(W, V1);
+        C1.noalias() -= W.adjoint();
+
+      } else {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlc(*k, *n, v, *ldv));
+        lastc = Eigen::internal::ilaxlr(*m, lastv, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C1(
+            c, lastc, *k, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V1(v, *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C1 * V1.template triangularView<Eigen::UnitUpper>().adjoint();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k * (*ldc)], lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k * (*ldv)], *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C2 * V2.adjoint();
+        }
+
+        if (notran) {
+          apply_triangular_right_upper<false>(W, T_mat);
+        } else {
+          apply_triangular_right_upper_adjoint<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C2(&c[*k * (*ldc)], lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V2(&v[*k * (*ldv)], *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          C2.noalias() -= W * V2;
+        }
+
+        apply_triangular_right_upper<true>(W, V1);
+        C1.noalias() -= W;
+      }
+    } else {
+      // storev == 'R' && !forward
+      if (applyleft) {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlc(*k, *m, v, *ldv));
+        lastc = Eigen::internal::ilaxlc(lastv, *n, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C2(
+            &c[lastv - *k], *k, lastc, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V2(&v[(lastv - *k) * (*ldv)], *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C2.adjoint() * V2.template triangularView<Eigen::UnitLower>().adjoint();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C1.adjoint() * V1.adjoint();
+        }
+
+        if (notran) {
+          apply_triangular_right_lower_adjoint<false>(W, T_mat);
+        } else {
+          apply_triangular_right_lower<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastv - *k, lastc, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          C1.noalias() -= V1.adjoint() * W.adjoint();
+        }
+
+        apply_triangular_right_lower<true>(W, V2);
+        C2.noalias() -= W.adjoint();
+
+      } else {
+        lastv = Eigen::numext::maxi(*k, Eigen::internal::ilaxlc(*k, *n, v, *ldv));
+        lastc = Eigen::internal::ilaxlr(*m, lastv, c, *ldc);
+        if (lastc == 0) return;
+
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > W(
+            work, lastc, *k, Eigen::OuterStride<>(*ldwork));
+        Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> > C2(
+            &c[(lastv - *k) * (*ldc)], lastc, *k, Eigen::OuterStride<>(*ldc));
+        Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                   Eigen::OuterStride<> >
+            V2(&v[(lastv - *k) * (*ldv)], *k, *k, Eigen::OuterStride<>(*ldv));
+
+        W.noalias() = C2 * V2.template triangularView<Eigen::UnitLower>().adjoint();
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          W.noalias() += C1 * V1.adjoint();
+        }
+
+        if (notran) {
+          apply_triangular_right_lower<false>(W, T_mat);
+        } else {
+          apply_triangular_right_lower_adjoint<false>(W, T_mat);
+        }
+
+        if (lastv > *k) {
+          Eigen::Map<Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0, Eigen::OuterStride<> >
+              C1(c, lastc, lastv - *k, Eigen::OuterStride<>(*ldc));
+          Eigen::Map<const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor>, 0,
+                     Eigen::OuterStride<> >
+              V1(v, *k, lastv - *k, Eigen::OuterStride<>(*ldv));
+          C1.noalias() -= W * V1;
+        }
+
+        apply_triangular_right_lower<true>(W, V2);
+        C2.noalias() -= W;
+      }
+    }
+  }
+}
diff --git a/lapack/ilaclc.c b/lapack/ilaclc.c
deleted file mode 100644
index d5f4518..0000000
--- a/lapack/ilaclc.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* ilaclc.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer ilaclc_(integer *m, integer *n, complex *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1, i__2;
-
-    /* Local variables */
-    integer i__;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILACLC scans A for its last non-zero column. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) COMPLEX array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*n == 0) {
-	ret_val = *n;
-    } else /* if(complicated condition) */ {
-	i__1 = *n * a_dim1 + 1;
-	i__2 = *m + *n * a_dim1;
-	if (a[i__1].r != 0.f || a[i__1].i != 0.f || (a[i__2].r != 0.f || a[
-		i__2].i != 0.f)) {
-	    ret_val = *n;
-	} else {
-/*     Now scan each column from the end, returning with the first non-zero. */
-	    for (ret_val = *n; ret_val >= 1; --ret_val) {
-		i__1 = *m;
-		for (i__ = 1; i__ <= i__1; ++i__) {
-		    i__2 = i__ + ret_val * a_dim1;
-		    if (a[i__2].r != 0.f || a[i__2].i != 0.f) {
-			return ret_val;
-		    }
-		}
-	    }
-	}
-    }
-    return ret_val;
-} /* ilaclc_ */
diff --git a/lapack/ilaclr.c b/lapack/ilaclr.c
deleted file mode 100644
index fe768c0..0000000
--- a/lapack/ilaclr.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/* ilaclr.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer ilaclr_(integer *m, integer *n, complex *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1, i__2;
-
-    /* Local variables */
-    integer i__, j;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILACLR scans A for its last non-zero row. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) COMPLEX          array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*m == 0) {
-	ret_val = *m;
-    } else /* if(complicated condition) */ {
-	i__1 = *m + a_dim1;
-	i__2 = *m + *n * a_dim1;
-	if (a[i__1].r != 0.f || a[i__1].i != 0.f || (a[i__2].r != 0.f || a[
-		i__2].i != 0.f)) {
-	    ret_val = *m;
-	} else {
-/*     Scan up each column tracking the last zero row seen. */
-	    ret_val = 0;
-	    i__1 = *n;
-	    for (j = 1; j <= i__1; ++j) {
-		for (i__ = *m; i__ >= 1; --i__) {
-		    i__2 = i__ + j * a_dim1;
-		    if (a[i__2].r != 0.f || a[i__2].i != 0.f) {
-			break;
-		    }
-		}
-		ret_val = max(ret_val,i__);
-	    }
-	}
-    }
-    return ret_val;
-} /* ilaclr_ */
diff --git a/lapack/iladlc.c b/lapack/iladlc.c
deleted file mode 100644
index 8af8292..0000000
--- a/lapack/iladlc.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/* iladlc.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer iladlc_(integer *m, integer *n, doublereal *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1;
-
-    /* Local variables */
-    integer i__;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILADLC scans A for its last non-zero column. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) DOUBLE PRECISION array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*n == 0) {
-	ret_val = *n;
-    } else if (a[*n * a_dim1 + 1] != 0. || a[*m + *n * a_dim1] != 0.) {
-	ret_val = *n;
-    } else {
-/*     Now scan each column from the end, returning with the first non-zero. */
-	for (ret_val = *n; ret_val >= 1; --ret_val) {
-	    i__1 = *m;
-	    for (i__ = 1; i__ <= i__1; ++i__) {
-		if (a[i__ + ret_val * a_dim1] != 0.) {
-		    return ret_val;
-		}
-	    }
-	}
-    }
-    return ret_val;
-} /* iladlc_ */
diff --git a/lapack/iladlr.c b/lapack/iladlr.c
deleted file mode 100644
index 9e074d8..0000000
--- a/lapack/iladlr.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/* iladlr.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer iladlr_(integer *m, integer *n, doublereal *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1;
-
-    /* Local variables */
-    integer i__, j;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILADLR scans A for its last non-zero row. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) DOUBLE PRECISION array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*m == 0) {
-	ret_val = *m;
-    } else if (a[*m + a_dim1] != 0. || a[*m + *n * a_dim1] != 0.) {
-	ret_val = *m;
-    } else {
-/*     Scan up each column tracking the last zero row seen. */
-	ret_val = 0;
-	i__1 = *n;
-	for (j = 1; j <= i__1; ++j) {
-	    for (i__ = *m; i__ >= 1; --i__) {
-		if (a[i__ + j * a_dim1] != 0.) {
-		    break;
-		}
-	    }
-	    ret_val = max(ret_val,i__);
-	}
-    }
-    return ret_val;
-} /* iladlr_ */
diff --git a/lapack/ilaslc.c b/lapack/ilaslc.c
deleted file mode 100644
index cbcfe17..0000000
--- a/lapack/ilaslc.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/* ilaslc.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer ilaslc_(integer *m, integer *n, real *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1;
-
-    /* Local variables */
-    integer i__;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILASLC scans A for its last non-zero column. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) REAL array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*n == 0) {
-	ret_val = *n;
-    } else if (a[*n * a_dim1 + 1] != 0.f || a[*m + *n * a_dim1] != 0.f) {
-	ret_val = *n;
-    } else {
-/*     Now scan each column from the end, returning with the first non-zero. */
-	for (ret_val = *n; ret_val >= 1; --ret_val) {
-	    i__1 = *m;
-	    for (i__ = 1; i__ <= i__1; ++i__) {
-		if (a[i__ + ret_val * a_dim1] != 0.f) {
-		    return ret_val;
-		}
-	    }
-	}
-    }
-    return ret_val;
-} /* ilaslc_ */
diff --git a/lapack/ilaslr.c b/lapack/ilaslr.c
deleted file mode 100644
index 4d9c7b6..0000000
--- a/lapack/ilaslr.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/* ilaslr.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer ilaslr_(integer *m, integer *n, real *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1;
-
-    /* Local variables */
-    integer i__, j;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILASLR scans A for its last non-zero row. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) REAL             array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*m == 0) {
-	ret_val = *m;
-    } else if (a[*m + a_dim1] != 0.f || a[*m + *n * a_dim1] != 0.f) {
-	ret_val = *m;
-    } else {
-/*     Scan up each column tracking the last zero row seen. */
-	ret_val = 0;
-	i__1 = *n;
-	for (j = 1; j <= i__1; ++j) {
-	    for (i__ = *m; i__ >= 1; --i__) {
-		if (a[i__ + j * a_dim1] != 0.f) {
-		    break;
-		}
-	    }
-	    ret_val = max(ret_val,i__);
-	}
-    }
-    return ret_val;
-} /* ilaslr_ */
diff --git a/lapack/ilaver.cpp b/lapack/ilaver.cpp
new file mode 100644
index 0000000..4f52bc8
--- /dev/null
+++ b/lapack/ilaver.cpp
@@ -0,0 +1,20 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 The Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "lapack.h"
+
+extern "C" {
+// Returns the LAPACK version that this implementation conforms to.
+void ilaver_(int* major, int* minor, int* patch) {
+  *major = 3;
+  *minor = 4;
+  *patch = 1;
+}
+}
diff --git a/lapack/ilazlc.c b/lapack/ilazlc.c
deleted file mode 100644
index 4691646..0000000
--- a/lapack/ilazlc.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* ilazlc.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer ilazlc_(integer *m, integer *n, doublecomplex *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1, i__2;
-
-    /* Local variables */
-    integer i__;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILAZLC scans A for its last non-zero column. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) COMPLEX*16 array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*n == 0) {
-	ret_val = *n;
-    } else /* if(complicated condition) */ {
-	i__1 = *n * a_dim1 + 1;
-	i__2 = *m + *n * a_dim1;
-	if (a[i__1].r != 0. || a[i__1].i != 0. || (a[i__2].r != 0. || a[i__2]
-		.i != 0.)) {
-	    ret_val = *n;
-	} else {
-/*     Now scan each column from the end, returning with the first non-zero. */
-	    for (ret_val = *n; ret_val >= 1; --ret_val) {
-		i__1 = *m;
-		for (i__ = 1; i__ <= i__1; ++i__) {
-		    i__2 = i__ + ret_val * a_dim1;
-		    if (a[i__2].r != 0. || a[i__2].i != 0.) {
-			return ret_val;
-		    }
-		}
-	    }
-	}
-    }
-    return ret_val;
-} /* ilazlc_ */
diff --git a/lapack/ilazlr.c b/lapack/ilazlr.c
deleted file mode 100644
index 553b166..0000000
--- a/lapack/ilazlr.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/* ilazlr.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-integer ilazlr_(integer *m, integer *n, doublecomplex *a, integer *lda)
-{
-    /* System generated locals */
-    integer a_dim1, a_offset, ret_val, i__1, i__2;
-
-    /* Local variables */
-    integer i__, j;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2.1)                        -- */
-
-/*  -- April 2009                                                      -- */
-
-/*  -- LAPACK is a software package provided by Univ. of Tennessee,    -- */
-/*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-/*     .. Array Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  ILAZLR scans A for its last non-zero row. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  M       (input) INTEGER */
-/*          The number of rows of the matrix A. */
-
-/*  N       (input) INTEGER */
-/*          The number of columns of the matrix A. */
-
-/*  A       (input) COMPLEX*16 array, dimension (LDA,N) */
-/*          The m by n matrix A. */
-
-/*  LDA     (input) INTEGER */
-/*          The leading dimension of the array A. LDA >= max(1,M). */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-/*     Quick test for the common case where one corner is non-zero. */
-    /* Parameter adjustments */
-    a_dim1 = *lda;
-    a_offset = 1 + a_dim1;
-    a -= a_offset;
-
-    /* Function Body */
-    if (*m == 0) {
-	ret_val = *m;
-    } else /* if(complicated condition) */ {
-	i__1 = *m + a_dim1;
-	i__2 = *m + *n * a_dim1;
-	if (a[i__1].r != 0. || a[i__1].i != 0. || (a[i__2].r != 0. || a[i__2]
-		.i != 0.)) {
-	    ret_val = *m;
-	} else {
-/*     Scan up each column tracking the last zero row seen. */
-	    ret_val = 0;
-	    i__1 = *n;
-	    for (j = 1; j <= i__1; ++j) {
-		for (i__ = *m; i__ >= 1; --i__) {
-		    i__2 = i__ + j * a_dim1;
-		    if (a[i__2].r != 0. || a[i__2].i != 0.) {
-			break;
-		    }
-		}
-		ret_val = max(ret_val,i__);
-	    }
-	}
-    }
-    return ret_val;
-} /* ilazlr_ */
diff --git a/lapack/lapack.h b/lapack/lapack.h
index ad6485d..9495f47 100644
--- a/lapack/lapack.h
+++ b/lapack/lapack.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef LAPACK_H
 #define LAPACK_H
 
@@ -21,6 +24,14 @@
 extern "C" {
 #endif
 
+typedef struct {
+  float r, i;
+} eigen_lapack_complex_float;
+
+typedef struct {
+  double r, i;
+} eigen_lapack_complex_double;
+
 EIGEN_LAPACK_API void BLASFUNC(csymv)(const char *, const int *, const float *, const float *, const int *,
                                       const float *, const int *, const float *, float *, const int *);
 EIGEN_LAPACK_API void BLASFUNC(zsymv)(const char *, const int *, const double *, const double *, const int *,
@@ -190,6 +201,72 @@
 EIGEN_LAPACK_API float BLASFUNC(second)();
 EIGEN_LAPACK_API double BLASFUNC(dsecnd)();
 
+// Householder.
+EIGEN_LAPACK_API void BLASFUNC(slarfg)(int *, float *, float *, int *, float *);
+EIGEN_LAPACK_API void BLASFUNC(dlarfg)(int *, double *, double *, int *, double *);
+EIGEN_LAPACK_API void BLASFUNC(clarfg)(int *, float *, float *, int *, float *);
+EIGEN_LAPACK_API void BLASFUNC(zlarfg)(int *, double *, double *, int *, double *);
+
+EIGEN_LAPACK_API void BLASFUNC(slarf)(const char *, int *, int *, float *, int *, float *, float *, int *, float *);
+EIGEN_LAPACK_API void BLASFUNC(dlarf)(const char *, int *, int *, double *, int *, double *, double *, int *, double *);
+EIGEN_LAPACK_API void BLASFUNC(clarf)(const char *, int *, int *, float *, int *, float *, float *, int *, float *);
+EIGEN_LAPACK_API void BLASFUNC(zlarf)(const char *, int *, int *, double *, int *, double *, double *, int *, double *);
+
+EIGEN_LAPACK_API void BLASFUNC(slarft)(const char *, const char *, int *, int *, float *, int *, float *, float *,
+                                       int *);
+EIGEN_LAPACK_API void BLASFUNC(dlarft)(const char *, const char *, int *, int *, double *, int *, double *, double *,
+                                       int *);
+EIGEN_LAPACK_API void BLASFUNC(clarft)(const char *, const char *, int *, int *, float *, int *, float *, float *,
+                                       int *);
+EIGEN_LAPACK_API void BLASFUNC(zlarft)(const char *, const char *, int *, int *, double *, int *, double *, double *,
+                                       int *);
+
+EIGEN_LAPACK_API void BLASFUNC(slarfb)(const char *, const char *, const char *, const char *, int *, int *, int *,
+                                       float *, int *, float *, int *, float *, int *, float *, int *);
+EIGEN_LAPACK_API void BLASFUNC(dlarfb)(const char *, const char *, const char *, const char *, int *, int *, int *,
+                                       double *, int *, double *, int *, double *, int *, double *, int *);
+EIGEN_LAPACK_API void BLASFUNC(clarfb)(const char *, const char *, const char *, const char *, int *, int *, int *,
+                                       float *, int *, float *, int *, float *, int *, float *, int *);
+EIGEN_LAPACK_API void BLASFUNC(zlarfb)(const char *, const char *, const char *, const char *, int *, int *, int *,
+                                       double *, int *, double *, int *, double *, int *, double *, int *);
+
+// Utilities.
+EIGEN_LAPACK_API float BLASFUNC(slapy2)(float *, float *);
+EIGEN_LAPACK_API double BLASFUNC(dlapy2)(double *, double *);
+
+EIGEN_LAPACK_API float BLASFUNC(slapy3)(float *, float *, float *);
+EIGEN_LAPACK_API double BLASFUNC(dlapy3)(double *, double *, double *);
+
+EIGEN_LAPACK_API void BLASFUNC(clacgv)(int *, float *, int *);
+EIGEN_LAPACK_API void BLASFUNC(zlacgv)(int *, double *, int *);
+
+EIGEN_LAPACK_API float BLASFUNC(slamch)(const char *);
+EIGEN_LAPACK_API double BLASFUNC(dlamch)(const char *);
+EIGEN_LAPACK_API float BLASFUNC(slamc3)(float *, float *);
+EIGEN_LAPACK_API double BLASFUNC(dlamc3)(double *, double *);
+
+EIGEN_LAPACK_API void BLASFUNC(sladiv)(const float *, const float *, const float *, const float *, float *, float *);
+EIGEN_LAPACK_API void BLASFUNC(dladiv)(const double *, const double *, const double *, const double *, double *,
+                                       double *);
+
+// Note: Returning complex structs by value adheres to the SysV AMD64 ABI (gfortran
+// on Linux/x86_64), consistent with the return-by-value convention used for cdotc/zdotc
+// in blas/complexdots.cpp.
+EIGEN_LAPACK_API eigen_lapack_complex_float BLASFUNC(cladiv)(const float *, const float *);
+EIGEN_LAPACK_API eigen_lapack_complex_double BLASFUNC(zladiv)(const double *, const double *);
+
+EIGEN_LAPACK_API int BLASFUNC(ilaslc)(int *, int *, float *, int *);
+EIGEN_LAPACK_API int BLASFUNC(iladlc)(int *, int *, double *, int *);
+EIGEN_LAPACK_API int BLASFUNC(ilaclc)(int *, int *, float *, int *);
+EIGEN_LAPACK_API int BLASFUNC(ilazlc)(int *, int *, double *, int *);
+
+EIGEN_LAPACK_API int BLASFUNC(ilaslr)(int *, int *, float *, int *);
+EIGEN_LAPACK_API int BLASFUNC(iladlr)(int *, int *, double *, int *);
+EIGEN_LAPACK_API int BLASFUNC(ilaclr)(int *, int *, float *, int *);
+EIGEN_LAPACK_API int BLASFUNC(ilazlr)(int *, int *, double *, int *);
+
+EIGEN_LAPACK_API void BLASFUNC(ilaver)(int *, int *, int *);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lapack/lapack_common.h b/lapack/lapack_common.h
index 726fabf..733cc4f 100644
--- a/lapack/lapack_common.h
+++ b/lapack/lapack_common.h
@@ -6,12 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_LAPACK_COMMON_H
 #define EIGEN_LAPACK_COMMON_H
 
 #include "../blas/common.h"
 #include "lapack.h"
+#include "lapack_utils.h"
 
 #define EIGEN_LAPACK_FUNC(FUNC) EIGEN_BLAS_FUNC(FUNC)
 
diff --git a/lapack/lapack_datatypes.h b/lapack/lapack_datatypes.h
deleted file mode 100644
index 01818a5..0000000
--- a/lapack/lapack_datatypes.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef EIGEN_LAPACK_DATATYPES_H_
-#define EIGEN_LAPACK_DATATYPES_H_
-
-#include "../blas/f2c/datatypes.h"
-
-#define TRUE_ (logical)1
-#define FALSE_ (logical)0
-
-#endif  // EIGEN_LAPACK_DATATYPES_H_
\ No newline at end of file
diff --git a/lapack/lapack_testing.py b/lapack/lapack_testing.py
new file mode 100644
index 0000000..1e43e3a
--- /dev/null
+++ b/lapack/lapack_testing.py
@@ -0,0 +1,325 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# SPDX-FileCopyrightText: 1992-2013 The University of Tennessee and The University of Tennessee Research Foundation
+# SPDX-FileCopyrightText: 2000-2013 The University of California Berkeley
+# SPDX-FileCopyrightText: 2006-2013 The University of Colorado Denver
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+###############################################################################
+# lapack_testing.py  
+###############################################################################
+
+
+from __future__ import print_function
+from subprocess import Popen, STDOUT, PIPE 
+import os, sys, math
+import getopt
+# Arguments
+try:
+   opts, args = getopt.getopt(sys.argv[1:], "hd:srep:t:n", 
+                              ["help", "dir", "short", "run", "error","prec=","test=","number"])
+   
+except getopt.error as msg:
+   print(msg)
+   print("for help use --help")
+   sys.exit(2)
+
+short_summary=0
+with_file=1
+just_errors = 0
+prec='x'
+test='all'
+only_numbers=0
+dir="TESTING"
+for o, a in opts:
+   if o in ("-h", "--help"):
+      print(sys.argv[0]+" [-h|--help] [-d dir |--dir dir] [-s |--short] [-r |--run] [-e |--error] [-p p |--prec p] [-t test |--test test] [-n | --number]")
+      print("     - h is to print this message")
+      print("     - r is to use to run the LAPACK tests then analyse the output (.out files). By default, the script will not run all the LAPACK tests")
+      print("     - d [dir] is to indicate where is the LAPACK testing directory (.out files). By default, the script will use .")
+      print(" LEVEL OF OUTPUT")
+      print("     - x is to print a detailed summary")
+      print("     - e is to print only the error summary")
+      print("     - s is to print a short summary")
+      print("     - n is to print the numbers of failing tests (turn on summary mode)")
+      print(" SECLECTION OF TESTS:")
+      print("     - p [s/c/d/z/x] is to indicate the PRECISION to run:")
+      print("            s=single")
+      print("            d=double")
+      print("            sd=single/double")
+      print("            c=complex")
+      print("            z=double complex")
+      print("            cz=complex/double complex")
+      print("            x=all [DEFAULT]")
+      print("     - t [lin/eig/mixed/rfp/all] is to indicate which TEST FAMILY to run:")
+      print("            lin=Linear Equation")
+      print("            eig=Eigen Problems")
+      print("            mixed=mixed-precision")
+      print("            rfp=rfp format")
+      print("            all=all tests [DEFAULT]")
+      print(" EXAMPLES:")
+      print("     ./lapack_testing.py -n")
+      print("            Will return the numbers of failed tests by analyzing the LAPACK output")
+      print("     ./lapack_testing.py -n -r -p s")
+      print("            Will return the numbers of failed tests in REAL precision by running the LAPACK Tests then analyzing the output")
+      print("     ./lapack_testing.py -n -p s -t eig ")
+      print("            Will return the numbers of failed tests in REAL precision by analyzing only the LAPACK output of EIGEN testings")
+      print("Written by Julie Langou (June 2011) ")
+      sys.exit(0)
+   else:
+      if o in ("-s", "--short"):
+         short_summary = 1
+      if o in ("-r", "--run"):
+         with_file = 0
+      if o in ("-e", "--error"):
+         just_errors = 1
+      if o in ( '-p', '--prec' ):
+         prec = a
+      if o in ( '-d', '--dir' ):
+         dir = a
+      if o in ( '-t', '--test' ):
+         test = a
+      if o in ( '-n', '--number' ):
+         only_numbers = 1
+         short_summary = 1
+
+# process options
+os.chdir(dir)
+execution=1
+summary="\n\t\t\t-->   LAPACK TESTING SUMMARY  <--\n";
+if with_file: summary+= "\t\tProcessing LAPACK Testing output found in the "+dir+" directory\n";
+summary+="SUMMARY             \tnb test run \tnumerical error   \tother error  \n";
+summary+="================   \t===========\t=================\t================  \n";
+nb_of_test=0
+
+# Add current directory to the path for subshells of this shell
+# Allows the popen to find local files in both windows and unixes
+os.environ["PATH"] = os.environ["PATH"]+":."
+
+# Define a function to open the executable (different filenames on unix and Windows)
+def run_summary_test( f, cmdline, short_summary):
+   nb_test_run=0
+   nb_test_fail=0
+   nb_test_illegal=0
+   nb_test_info=0
+   if (with_file):
+      if not os.path.exists(cmdline):
+        error_message=cmdline+" file not found"
+        r=1
+        if short_summary: return [nb_test_run,nb_test_fail,nb_test_illegal,nb_test_info]
+      else:
+        pipe = open(cmdline,'r')
+        r=0
+   else:
+      if os.name != 'nt':
+         cmdline="./" + cmdline
+
+      outfile=cmdline.split()[4]
+      pipe = open(outfile,'w')
+      p = Popen(cmdline, shell=True, stdout=pipe)
+      p.wait()
+      pipe.close()
+      r=p.returncode
+      pipe = open(outfile,'r')
+      error_message=cmdline+" did not work"
+
+   if r != 0 and not with_file:
+       print("---- TESTING " + cmdline.split()[0] + "... FAILED(" + error_message +") !")
+       for line in pipe.readlines():
+          f.write(str(line))
+   elif r != 0 and with_file and not short_summary:
+       print("---- WARNING: please check that you have the LAPACK output : "+cmdline+"!")
+       print("---- WARNING: with the option -r, we can run the LAPACK testing for you")
+      # print("---- "+error_message)
+   else:
+         for line in pipe.readlines():
+                f.write(str(line))
+                words_in_line=line.split()
+                if (line.find("run")!=-1):
+#                  print(line)
+                   whereisrun=words_in_line.index("run)")
+                   nb_test_run+=int(words_in_line[whereisrun-2])
+                if (line.find("out of")!=-1):
+                   if (short_summary==0): print(line, end="")
+                   whereisout= words_in_line.index("out")
+                   nb_test_fail+=int(words_in_line[whereisout-1])
+                if (line.find("illegal")!=-1):
+                   if (short_summary==0):print(line, end="")
+                   nb_test_illegal+=1
+                if (line.find(" INFO")!=-1):
+                   if (short_summary==0):print(line, end="")
+                   nb_test_info+=1
+                if (with_file==1):
+                   pipe.close()
+           
+   f.flush();
+
+   return [nb_test_run,nb_test_fail,nb_test_illegal,nb_test_info]
+
+
+# If filename cannot be opened, send output to sys.stderr
+filename = "testing_results.txt"
+try:
+     f = open(filename, 'w')
+except IOError:
+     f = sys.stdout
+
+if (short_summary==0):
+   print(" ")
+   print("---------------- Testing LAPACK Routines ----------------")
+   print(" ")
+   print("-- Detailed results are stored in", filename)
+
+dtypes = (
+("s", "d", "c", "z"),
+("REAL             ", "DOUBLE PRECISION", "COMPLEX          ", "COMPLEX16         "),
+)
+
+if prec=='s':
+   range_prec=[0]
+elif prec=='d':
+   range_prec=[1]
+elif prec=='sd':
+   range_prec=[0,1]
+elif prec=='c':
+   range_prec=[2]
+elif prec=='z':
+   range_prec=[3]
+elif prec=='cz':
+   range_prec=[2,3]
+else: 
+   prec='x';
+   range_prec=range(4)
+
+if test=='lin':
+   range_test=[15]
+elif test=='mixed':
+   range_test=[16]
+   range_prec=[1,3]
+elif test=='rfp':
+   range_test=[17]
+elif test=='eig':
+   range_test=range(15)
+else:  
+   range_test=range(18)
+
+list_results = [
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0],
+]
+
+for dtype in range_prec:
+  letter = dtypes[0][dtype]
+  name = dtypes[1][dtype]
+
+  if (short_summary==0):
+     print(" ")
+     print("------------------------- %s ------------------------" % name)
+     print(" ")
+     sys.stdout.flush()
+
+
+  dtests = (
+  ("nep", "sep", "svd",
+  letter+"ec",letter+"ed",letter+"gg",
+  letter+"gd",letter+"sb",letter+"sg",
+  letter+"bb","glm","gqr",
+  "gsv","csd","lse",
+  letter+"test", letter+dtypes[0][dtype-1]+"test",letter+"test_rfp"),
+  ("Nonsymmetric Eigenvalue Problem", "Symmetric Eigenvalue Problem", "Singular Value Decomposition",
+  "Eigen Condition","Nonsymmetric Eigenvalue","Nonsymmetric Generalized Eigenvalue Problem",
+  "Nonsymmetric Generalized Eigenvalue Problem driver", "Symmetric Eigenvalue Problem", "Symmetric Eigenvalue Generalized Problem",
+  "Banded Singular Value Decomposition routines", "Generalized Linear Regression Model routines", "Generalized QR and RQ factorization routines",
+  "Generalized Singular Value Decomposition routines", "CS Decomposition routines", "Constrained Linear Least Squares routines",
+  "Linear Equation routines", "Mixed Precision linear equation routines","RFP linear equation routines"),
+  (letter+"nep", letter+"sep", letter+"svd",
+  letter+"ec",letter+"ed",letter+"gg",
+  letter+"gd",letter+"sb",letter+"sg",
+  letter+"bb",letter+"glm",letter+"gqr",
+  letter+"gsv",letter+"csd",letter+"lse",
+  letter+"test", letter+dtypes[0][dtype-1]+"test",letter+"test_rfp"),
+  )
+
+
+  for dtest in range_test:
+     nb_of_test=0
+     # NEED TO SKIP SOME PRECISION (namely s and c) FOR PROTO MIXED PRECISION TESTING
+     if dtest==16 and (letter=="s" or letter=="c"):
+        continue
+     if (with_file==1):
+        cmdbase=dtests[2][dtest]+".out"
+     else:
+        if dtest==15:
+           # LIN TESTS
+           cmdbase="xlintst"+letter+" < "+dtests[0][dtest]+".in > "+dtests[2][dtest]+".out"
+        elif dtest==16:
+           # PROTO LIN TESTS
+           cmdbase="xlintst"+letter+dtypes[0][dtype-1]+" < "+dtests[0][dtest]+".in > "+dtests[2][dtest]+".out"
+        elif dtest==17:
+           # PROTO LIN TESTS
+           cmdbase="xlintstrf"+letter+" < "+dtests[0][dtest]+".in > "+dtests[2][dtest]+".out"
+        else:
+           # EIG TESTS
+           cmdbase="xeigtst"+letter+" < "+dtests[0][dtest]+".in > "+dtests[2][dtest]+".out"
+     if (not just_errors and not short_summary):
+        print("-->  Testing "+name+" "+dtests[1][dtest]+" [ "+cmdbase+" ]")
+     # Run the process: either to read the file or run the LAPACK testing   
+     nb_test = run_summary_test(f, cmdbase, short_summary)
+     list_results[0][dtype]+=nb_test[0]
+     list_results[1][dtype]+=nb_test[1]
+     list_results[2][dtype]+=nb_test[2]
+     list_results[3][dtype]+=nb_test[3]
+     got_error=nb_test[1]+nb_test[2]+nb_test[3]
+     
+     if (not short_summary):
+        if (nb_test[0]>0 and just_errors==0):
+           print("-->  Tests passed: "+str(nb_test[0]))
+        if (nb_test[1]>0):
+           print("-->  Tests failing to pass the threshold: "+str(nb_test[1]))
+        if (nb_test[2]>0):
+           print("-->  Illegal Error: "+str(nb_test[2]))
+        if (nb_test[3]>0):
+           print("-->  Info Error: "+str(nb_test[3]))
+        if (got_error>0 and just_errors==1):
+           print("ERROR IS LOCATED IN "+name+" "+dtests[1][dtest]+" [ "+cmdbase+" ]")
+           print("")
+        if (just_errors==0):
+           print("")
+#     elif (got_error>0):
+#        print(dtests[2][dtest]+".out \t"+str(nb_test[1])+"\t"+str(nb_test[2])+"\t"+str(nb_test[3]))
+        
+     sys.stdout.flush()
+  if (list_results[0][dtype] > 0 ):
+     percent_num_error=float(list_results[1][dtype])/float(list_results[0][dtype])*100
+     percent_error=float(list_results[2][dtype]+list_results[3][dtype])/float(list_results[0][dtype])*100
+  else:
+     percent_num_error=0
+     percent_error=0
+  summary+=name+"\t"+str(list_results[0][dtype])+"\t\t"+str(list_results[1][dtype])+"\t("+"%.3f" % percent_num_error+"%)\t"+str(list_results[2][dtype]+list_results[3][dtype])+"\t("+"%.3f" % percent_error+"%)\t""\n"
+  list_results[0][4]+=list_results[0][dtype]
+  list_results[1][4]+=list_results[1][dtype]
+  list_results[2][4]+=list_results[2][dtype]
+  list_results[3][4]+=list_results[3][dtype]
+  
+if only_numbers==1:
+   print(str(list_results[1][4])+"\n"+str(list_results[2][4]+list_results[3][4]))
+else:
+   print(summary)
+   if (list_results[0][4] > 0 ):
+      percent_num_error=float(list_results[1][4])/float(list_results[0][4])*100
+      percent_error=float(list_results[2][4]+list_results[3][4])/float(list_results[0][4])*100
+   else:
+      percent_num_error=0
+      percent_error=0
+   if (prec=='x'):
+        print("--> ALL PRECISIONS\t"+str(list_results[0][4])+"\t\t"+str(list_results[1][4])+"\t("+"%.3f" % percent_num_error+"%)\t"+str(list_results[2][4]+list_results[3][4])+"\t("+"%.3f" % percent_error+"%)\t""\n")
+   if list_results[0][4] == 0:
+     print("NO TESTS WERE ANALYZED, please use the -r option to run the LAPACK TESTING")
+
+# This may close the sys.stdout stream, so make it the last statement
+f.close()
diff --git a/lapack/lapack_utils.h b/lapack/lapack_utils.h
new file mode 100644
index 0000000..1337dec
--- /dev/null
+++ b/lapack/lapack_utils.h
@@ -0,0 +1,169 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 The Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_LAPACK_UTILS_H
+#define EIGEN_LAPACK_UTILS_H
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <complex>
+#include <limits>
+
+#include "../Eigen/Core"
+
+namespace Eigen {
+namespace internal {
+
+// Compute sqrt(x*x + y*y) taking care not to cause unnecessary overflow.
+template <typename T>
+T xlapy2(const T x, const T y) {
+  return numext::hypot(x, y);
+}
+
+// Compute sqrt(x*x + y*y + z*z) taking care not to cause unnecessary overflow.
+template <typename T>
+T xlapy3(const T x, const T y, const T z) {
+  if (x == T(0) && y == T(0) && z == T(0)) {
+    return T(0);
+  }
+
+  const T xabs = numext::abs(x);
+  const T yabs = numext::abs(y);
+  const T zabs = numext::abs(z);
+  const T w = numext::maxi(numext::maxi(xabs, yabs), zabs);
+
+  if (numext::is_exactly_zero(w)) {
+    return (xabs + yabs + zabs);
+  }
+
+  const T tx = xabs / w;
+  const T ty = yabs / w;
+  const T tz = zabs / w;
+  return w * numext::sqrt(tx * tx + ty * ty + tz * tz);
+}
+
+// Determines machine parameters according to LAPACK specification.
+template <typename T>
+T xlamch(const char c) {
+  switch (std::tolower(static_cast<unsigned char>(c))) {
+    case 'e':
+      return numext::numeric_limits<T>::epsilon() / numext::numeric_limits<T>::radix;
+    case 's': {
+      EIGEN_CONSTEXPR T tiny = (numext::numeric_limits<T>::min)();
+      EIGEN_CONSTEXPR T small = T(1) / (numext::numeric_limits<T>::max)();
+      EIGEN_CONSTEXPR T small_scaled = small * (T(1) + numext::numeric_limits<T>::epsilon());
+      return (small >= tiny) ? small_scaled : tiny;
+    }
+    case 'b':
+      return numext::numeric_limits<T>::radix;
+    case 'p':
+      return numext::numeric_limits<T>::epsilon();
+    case 'n':
+      return numext::numeric_limits<T>::digits;
+    case 'r':
+      return 1;
+    case 'm':
+      return numext::numeric_limits<T>::min_exponent;
+    case 'u':
+      return (numext::numeric_limits<T>::min)();
+    case 'l':
+      return numext::numeric_limits<T>::max_exponent;
+    case 'o':
+      return (numext::numeric_limits<T>::max)();
+    default:
+      return 0;
+  }
+}
+
+// Performs complex division in real arithmetic, avoiding unnecessary intermediate overflow.
+// Consistent with LAPACK auxiliary routines SLADIV / DLADIV and CLADIV / ZLADIV
+// (algorithm due to Robert L. Smith, D. Knuth, The Art of Computer Programming, Vol. 2, p. 195).
+template <typename RealScalar>
+EIGEN_STRONG_INLINE std::complex<RealScalar> xladiv(const std::complex<RealScalar>& num,
+                                                    const std::complex<RealScalar>& den) {
+  const RealScalar a = numext::real(num);
+  const RealScalar b = numext::imag(num);
+  const RealScalar c = numext::real(den);
+  const RealScalar d = numext::imag(den);
+
+  RealScalar p, q;
+  if (numext::abs(d) < numext::abs(c)) {
+    const RealScalar e = d / c;
+    const RealScalar f = c + d * e;
+    p = (a + b * e) / f;
+    q = (b - a * e) / f;
+  } else {
+    const RealScalar e = c / d;
+    const RealScalar f = d + c * e;
+    p = (b + a * e) / f;
+    q = (-a + b * e) / f;
+  }
+  return std::complex<RealScalar>(p, q);
+}
+
+template <typename RealScalar>
+EIGEN_STRONG_INLINE std::complex<RealScalar> xladiv(const RealScalar a, const RealScalar b, const RealScalar c,
+                                                    const RealScalar d) {
+  return xladiv(std::complex<RealScalar>(a, b), std::complex<RealScalar>(c, d));
+}
+
+// Conjugate entries of vector x.
+template <typename T>
+void xlacgv(const int n, T* x, const int incx) {
+  using StridedVector = Map<Matrix<T, Dynamic, 1>, Unaligned, InnerStride<Dynamic> >;
+  StridedVector xvec(x, n, InnerStride<Dynamic>(numext::abs(incx)));
+  xvec = xvec.conjugate();
+}
+
+// Scan a matrix for its last non-zero column.
+template <typename T>
+int ilaxlc(const int m, const int n, const T* a, const int lda) {
+  if (m == 0 || n == 0) return 0;
+  using MatrixType = Map<const Matrix<T, Dynamic, Dynamic, ColMajor>, Unaligned, OuterStride<> >;
+  MatrixType a_matrix(a, m, n, OuterStride<>(lda));
+
+  // Quick test for the common case where one corner is non-zero.
+  if (!numext::is_exactly_zero(a_matrix(0, n - 1)) || !numext::is_exactly_zero(a_matrix(m - 1, n - 1))) {
+    return n;
+  }
+
+  // Now scan each column from the end, returning with the first non-zero.
+  int c = n - 1;
+  while (c >= 0 && (a_matrix.array().col(c) == T(0)).all()) {
+    --c;
+  }
+  return c + 1;
+}
+
+// Scan a matrix for its last non-zero row.
+template <typename T>
+int ilaxlr(const int m, const int n, const T* a, const int lda) {
+  if (m == 0 || n == 0) return 0;
+  using MatrixType = Map<const Matrix<T, Dynamic, Dynamic, ColMajor>, Unaligned, OuterStride<> >;
+  MatrixType a_matrix(a, m, n, OuterStride<>(lda));
+
+  // Quick test for the common case where one corner is non-zero.
+  if (!numext::is_exactly_zero(a_matrix(m - 1, 0)) || !numext::is_exactly_zero(a_matrix(m - 1, n - 1))) {
+    return m;
+  }
+
+  // Now scan each row from the end, returning with the first non-zero.
+  int r = m - 1;
+  while (r >= 0 && (a_matrix.array().row(r) == T(0)).all()) {
+    --r;
+  }
+  return r + 1;
+}
+
+}  // namespace internal
+}  // namespace Eigen
+
+#endif  // EIGEN_LAPACK_UTILS_H
diff --git a/lapack/lu.inc b/lapack/lu.inc
index 69fdc3d..d63c11b 100644
--- a/lapack/lu.inc
+++ b/lapack/lu.inc
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "common.h"
 #include <Eigen/LU>
@@ -21,7 +22,7 @@
     *info = -4;
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "GETRF", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "GETRF", &e, kBlasNameLength);
   }
 
   if (*m == 0 || *n == 0) return;
@@ -54,7 +55,7 @@
     *info = -8;
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "GETRS", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "GETRS", &e, kBlasNameLength);
   }
 
   Scalar *a = reinterpret_cast<Scalar *>(pa);
diff --git a/lapack/second_INT_CPU_TIME.cpp b/lapack/second_INT_CPU_TIME.cpp
index 49371ff..a893d92 100644
--- a/lapack/second_INT_CPU_TIME.cpp
+++ b/lapack/second_INT_CPU_TIME.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifdef _WIN32
 #include <cstdint>
diff --git a/lapack/single.cpp b/lapack/single.cpp
index 10c0a2b..3968316 100644
--- a/lapack/single.cpp
+++ b/lapack/single.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define SCALAR float
 #define SCALAR_SUFFIX s
@@ -16,3 +17,5 @@
 #include "lu.inc"
 #include "eigenvalues.inc"
 #include "svd.inc"
+#include "householder.inc"
+#include "utilities.inc"
diff --git a/lapack/sladiv.c b/lapack/sladiv.c
deleted file mode 100644
index 629992d..0000000
--- a/lapack/sladiv.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* sladiv.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Subroutine */ void sladiv_(real *a, real *b, real *c__, real *d__, real *p, real *q) {
-  real e, f;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLADIV performs complex division in  real arithmetic */
-
-  /*                        a + i*b */
-  /*             p + i*q = --------- */
-  /*                        c + i*d */
-
-  /*  The algorithm is due to Robert L. Smith and can be found */
-  /*  in D. Knuth, The art of Computer Programming, Vol.2, p.195 */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  A       (input) REAL */
-  /*  B       (input) REAL */
-  /*  C       (input) REAL */
-  /*  D       (input) REAL */
-  /*          The scalars a, b, c, and d in the above expression. */
-
-  /*  P       (output) REAL */
-  /*  Q       (output) REAL */
-  /*          The scalars p and q in the above expression. */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (dabs(*d__) < dabs(*c__)) {
-    e = *d__ / *c__;
-    f = *c__ + *d__ * e;
-    *p = (*a + *b * e) / f;
-    *q = (*b - *a * e) / f;
-  } else {
-    e = *c__ / *d__;
-    f = *d__ + *c__ * e;
-    *p = (*b + *a * e) / f;
-    *q = (-(*a) + *b * e) / f;
-  }
-
-  /*     End of SLADIV */
-
-} /* sladiv_ */
diff --git a/lapack/slamch.c b/lapack/slamch.c
deleted file mode 100644
index 7438dfe..0000000
--- a/lapack/slamch.c
+++ /dev/null
@@ -1,991 +0,0 @@
-/* slamch.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-/* static integer c__1 = 1; */
-static real c_b32 = 0.f;
-
-static inline real pow_ri(real *ap, integer *bp) {
-  real pow, x;
-  integer n;
-  unsigned long u;
-
-  pow = 1;
-  x = *ap;
-  n = *bp;
-
-  if (n != 0) {
-    if (n < 0) {
-      n = -n;
-      x = 1 / x;
-    }
-    for (u = n;;) {
-      if (u & 01) pow *= x;
-      if (u >>= 1)
-        x *= x;
-      else
-        break;
-    }
-  }
-  return (pow);
-}
-
-doublereal slamch_(char *cmach) {
-  /* Initialized data */
-
-  static logical first = TRUE_;
-
-  /* System generated locals */
-  integer i__1;
-  real ret_val;
-
-  /* Local variables */
-  static real t;
-  integer it;
-  static real rnd, eps, base;
-  integer beta;
-  static real emin, prec, emax;
-  integer imin, imax;
-  logical lrnd;
-  static real rmin, rmax;
-  real rmach = 0;
-  extern logical lsame_(char *, char *);
-  real small;
-  static real sfmin;
-  extern /* Subroutine */ void slamc2_(integer *, integer *, logical *, real *, integer *, real *, integer *, real *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLAMCH determines single precision machine parameters. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  CMACH   (input) CHARACTER*1 */
-  /*          Specifies the value to be returned by SLAMCH: */
-  /*          = 'E' or 'e',   SLAMCH := eps */
-  /*          = 'S' or 's ,   SLAMCH := sfmin */
-  /*          = 'B' or 'b',   SLAMCH := base */
-  /*          = 'P' or 'p',   SLAMCH := eps*base */
-  /*          = 'N' or 'n',   SLAMCH := t */
-  /*          = 'R' or 'r',   SLAMCH := rnd */
-  /*          = 'M' or 'm',   SLAMCH := emin */
-  /*          = 'U' or 'u',   SLAMCH := rmin */
-  /*          = 'L' or 'l',   SLAMCH := emax */
-  /*          = 'O' or 'o',   SLAMCH := rmax */
-
-  /*          where */
-
-  /*          eps   = relative machine precision */
-  /*          sfmin = safe minimum, such that 1/sfmin does not overflow */
-  /*          base  = base of the machine */
-  /*          prec  = eps*base */
-  /*          t     = number of (base) digits in the mantissa */
-  /*          rnd   = 1.0 when rounding occurs in addition, 0.0 otherwise */
-  /*          emin  = minimum exponent before (gradual) underflow */
-  /*          rmin  = underflow threshold - base**(emin-1) */
-  /*          emax  = largest exponent before overflow */
-  /*          rmax  = overflow threshold  - (base**emax)*(1-eps) */
-
-  /* ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Save statement .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (first) {
-    slamc2_(&beta, &it, &lrnd, &eps, &imin, &rmin, &imax, &rmax);
-    base = (real)beta;
-    t = (real)it;
-    if (lrnd) {
-      rnd = 1.f;
-      i__1 = 1 - it;
-      eps = pow_ri(&base, &i__1) / 2;
-    } else {
-      rnd = 0.f;
-      i__1 = 1 - it;
-      eps = pow_ri(&base, &i__1);
-    }
-    prec = eps * base;
-    emin = (real)imin;
-    emax = (real)imax;
-    sfmin = rmin;
-    small = 1.f / rmax;
-    if (small >= sfmin) {
-      /*           Use SMALL plus a bit, to avoid the possibility of rounding */
-      /*           causing overflow when computing  1/sfmin. */
-
-      sfmin = small * (eps + 1.f);
-    }
-  }
-
-  if (lsame_(cmach, "E")) {
-    rmach = eps;
-  } else if (lsame_(cmach, "S")) {
-    rmach = sfmin;
-  } else if (lsame_(cmach, "B")) {
-    rmach = base;
-  } else if (lsame_(cmach, "P")) {
-    rmach = prec;
-  } else if (lsame_(cmach, "N")) {
-    rmach = t;
-  } else if (lsame_(cmach, "R")) {
-    rmach = rnd;
-  } else if (lsame_(cmach, "M")) {
-    rmach = emin;
-  } else if (lsame_(cmach, "U")) {
-    rmach = rmin;
-  } else if (lsame_(cmach, "L")) {
-    rmach = emax;
-  } else if (lsame_(cmach, "O")) {
-    rmach = rmax;
-  }
-
-  ret_val = rmach;
-  first = FALSE_;
-  return ret_val;
-
-  /*     End of SLAMCH */
-
-} /* slamch_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void slamc1_(integer *beta, integer *t, logical *rnd, logical *ieee1) {
-  /* Initialized data */
-
-  static logical first = TRUE_;
-
-  /* System generated locals */
-  real r__1, r__2;
-
-  /* Local variables */
-  real a, b, c__, f, t1, t2;
-  static integer lt;
-  real one, qtr;
-  static logical lrnd;
-  static integer lbeta;
-  real savec;
-  static logical lieee1;
-  extern doublereal slamc3_(real *, real *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLAMC1 determines the machine parameters given by BETA, T, RND, and */
-  /*  IEEE1. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  BETA    (output) INTEGER */
-  /*          The base of the machine. */
-
-  /*  T       (output) INTEGER */
-  /*          The number of ( BETA ) digits in the mantissa. */
-
-  /*  RND     (output) LOGICAL */
-  /*          Specifies whether proper rounding  ( RND = .TRUE. )  or */
-  /*          chopping  ( RND = .FALSE. )  occurs in addition. This may not */
-  /*          be a reliable guide to the way in which the machine performs */
-  /*          its arithmetic. */
-
-  /*  IEEE1   (output) LOGICAL */
-  /*          Specifies whether rounding appears to be done in the IEEE */
-  /*          'round to nearest' style. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The routine is based on the routine  ENVRON  by Malcolm and */
-  /*  incorporates suggestions by Gentleman and Marovich. See */
-
-  /*     Malcolm M. A. (1972) Algorithms to reveal properties of */
-  /*        floating-point arithmetic. Comms. of the ACM, 15, 949-951. */
-
-  /*     Gentleman W. M. and Marovich S. B. (1974) More on algorithms */
-  /*        that reveal properties of floating point arithmetic units. */
-  /*        Comms. of the ACM, 17, 276-277. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Save statement .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (first) {
-    one = 1.f;
-
-    /*        LBETA,  LIEEE1,  LT and  LRND  are the  local values  of  BETA, */
-    /*        IEEE1, T and RND. */
-
-    /*        Throughout this routine  we use the function  SLAMC3  to ensure */
-    /*        that relevant values are  stored and not held in registers,  or */
-    /*        are not affected by optimizers. */
-
-    /*        Compute  a = 2.0**m  with the  smallest positive integer m such */
-    /*        that */
-
-    /*           fl( a + 1.0 ) = a. */
-
-    a = 1.f;
-    c__ = 1.f;
-
-  /* +       WHILE( C.EQ.ONE )LOOP */
-  L10:
-    if (c__ == one) {
-      a *= 2;
-      c__ = slamc3_(&a, &one);
-      r__1 = -a;
-      c__ = slamc3_(&c__, &r__1);
-      goto L10;
-    }
-    /* +       END WHILE */
-
-    /*        Now compute  b = 2.0**m  with the smallest positive integer m */
-    /*        such that */
-
-    /*           fl( a + b ) .gt. a. */
-
-    b = 1.f;
-    c__ = slamc3_(&a, &b);
-
-  /* +       WHILE( C.EQ.A )LOOP */
-  L20:
-    if (c__ == a) {
-      b *= 2;
-      c__ = slamc3_(&a, &b);
-      goto L20;
-    }
-    /* +       END WHILE */
-
-    /*        Now compute the base.  a and c  are neighbouring floating point */
-    /*        numbers  in the  interval  ( beta**t, beta**( t + 1 ) )  and so */
-    /*        their difference is beta. Adding 0.25 to c is to ensure that it */
-    /*        is truncated to beta and not ( beta - 1 ). */
-
-    qtr = one / 4;
-    savec = c__;
-    r__1 = -a;
-    c__ = slamc3_(&c__, &r__1);
-    lbeta = c__ + qtr;
-
-    /*        Now determine whether rounding or chopping occurs,  by adding a */
-    /*        bit  less  than  beta/2  and a  bit  more  than  beta/2  to  a. */
-
-    b = (real)lbeta;
-    r__1 = b / 2;
-    r__2 = -b / 100;
-    f = slamc3_(&r__1, &r__2);
-    c__ = slamc3_(&f, &a);
-    if (c__ == a) {
-      lrnd = TRUE_;
-    } else {
-      lrnd = FALSE_;
-    }
-    r__1 = b / 2;
-    r__2 = b / 100;
-    f = slamc3_(&r__1, &r__2);
-    c__ = slamc3_(&f, &a);
-    if (lrnd && c__ == a) {
-      lrnd = FALSE_;
-    }
-
-    /*        Try and decide whether rounding is done in the  IEEE  'round to */
-    /*        nearest' style. B/2 is half a unit in the last place of the two */
-    /*        numbers A and SAVEC. Furthermore, A is even, i.e. has last  bit */
-    /*        zero, and SAVEC is odd. Thus adding B/2 to A should not  change */
-    /*        A, but adding B/2 to SAVEC should change SAVEC. */
-
-    r__1 = b / 2;
-    t1 = slamc3_(&r__1, &a);
-    r__1 = b / 2;
-    t2 = slamc3_(&r__1, &savec);
-    lieee1 = t1 == a && t2 > savec && lrnd;
-
-    /*        Now find  the  mantissa, t.  It should  be the  integer part of */
-    /*        log to the base beta of a,  however it is safer to determine  t */
-    /*        by powering.  So we find t as the smallest positive integer for */
-    /*        which */
-
-    /*           fl( beta**t + 1.0 ) = 1.0. */
-
-    lt = 0;
-    a = 1.f;
-    c__ = 1.f;
-
-  /* +       WHILE( C.EQ.ONE )LOOP */
-  L30:
-    if (c__ == one) {
-      ++lt;
-      a *= lbeta;
-      c__ = slamc3_(&a, &one);
-      r__1 = -a;
-      c__ = slamc3_(&c__, &r__1);
-      goto L30;
-    }
-    /* +       END WHILE */
-  }
-
-  *beta = lbeta;
-  *t = lt;
-  *rnd = lrnd;
-  *ieee1 = lieee1;
-  first = FALSE_;
-
-  /*     End of SLAMC1 */
-
-} /* slamc1_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void slamc2_(integer *beta, integer *t, logical *rnd, real *eps, integer *emin, real *rmin,
-                              integer *emax, real *rmax) {
-  /* Initialized data */
-
-  static logical first = TRUE_;
-  static logical iwarn = FALSE_;
-
-  /* Format strings */
-  /*
-  static char fmt_9999[] =
-      "(//\002 WARNING. The value EMIN may be incorre"
-      "ct:-\002,\002  EMIN = \002,i8,/\002 If, after inspection, the va"
-      "lue EMIN looks\002,\002 acceptable please comment out \002,/\002"
-      " the IF block as marked within the code of routine\002,\002 SLAM"
-      "C2,\002,/\002 otherwise supply EMIN explicitly.\002,/)";
-  */
-  /* System generated locals */
-  integer i__1;
-  real r__1, r__2, r__3, r__4, r__5;
-
-  /* Builtin functions */
-  /* double pow_ri(real *, integer *); */
-  /* integer s_wsfe(cilist *), do_fio(integer *, char *, ftnlen), e_wsfe(void); */
-
-  /* Local variables */
-  real a, b, c__;
-  integer i__;
-  static integer lt;
-  real one, two;
-  logical ieee;
-  real half;
-  logical lrnd = 0;
-  static real leps;
-  real zero;
-  static integer lbeta;
-  real rbase;
-  static integer lemin, lemax;
-  integer gnmin;
-  real small;
-  integer gpmin;
-  real third;
-  static real lrmin, lrmax;
-  real sixth;
-  logical lieee1;
-  extern /* Subroutine */ void slamc1_(integer *, integer *, logical *, logical *);
-  extern doublereal slamc3_(real *, real *);
-  extern /* Subroutine */ void slamc4_(integer *, real *, integer *),
-      slamc5_(integer *, integer *, integer *, logical *, integer *, real *);
-  integer ngnmin, ngpmin;
-
-  /* Fortran I/O blocks */
-  /* static cilist io___58 = {0, 6, 0, fmt_9999, 0}; */
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLAMC2 determines the machine parameters specified in its argument */
-  /*  list. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  BETA    (output) INTEGER */
-  /*          The base of the machine. */
-
-  /*  T       (output) INTEGER */
-  /*          The number of ( BETA ) digits in the mantissa. */
-
-  /*  RND     (output) LOGICAL */
-  /*          Specifies whether proper rounding  ( RND = .TRUE. )  or */
-  /*          chopping  ( RND = .FALSE. )  occurs in addition. This may not */
-  /*          be a reliable guide to the way in which the machine performs */
-  /*          its arithmetic. */
-
-  /*  EPS     (output) REAL */
-  /*          The smallest positive number such that */
-
-  /*             fl( 1.0 - EPS ) .LT. 1.0, */
-
-  /*          where fl denotes the computed value. */
-
-  /*  EMIN    (output) INTEGER */
-  /*          The minimum exponent before (gradual) underflow occurs. */
-
-  /*  RMIN    (output) REAL */
-  /*          The smallest normalized number for the machine, given by */
-  /*          BASE**( EMIN - 1 ), where  BASE  is the floating point value */
-  /*          of BETA. */
-
-  /*  EMAX    (output) INTEGER */
-  /*          The maximum exponent before overflow occurs. */
-
-  /*  RMAX    (output) REAL */
-  /*          The largest positive number for the machine, given by */
-  /*          BASE**EMAX * ( 1 - EPS ), where  BASE  is the floating point */
-  /*          value of BETA. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The computation of  EPS  is based on a routine PARANOIA by */
-  /*  W. Kahan of the University of California at Berkeley. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Save statement .. */
-  /*     .. */
-  /*     .. Data statements .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  if (first) {
-    zero = 0.f;
-    one = 1.f;
-    two = 2.f;
-
-    /*        LBETA, LT, LRND, LEPS, LEMIN and LRMIN  are the local values of */
-    /*        BETA, T, RND, EPS, EMIN and RMIN. */
-
-    /*        Throughout this routine  we use the function  SLAMC3  to ensure */
-    /*        that relevant values are stored  and not held in registers,  or */
-    /*        are not affected by optimizers. */
-
-    /*        SLAMC1 returns the parameters  LBETA, LT, LRND and LIEEE1. */
-
-    slamc1_(&lbeta, &lt, &lrnd, &lieee1);
-
-    /*        Start to find EPS. */
-
-    b = (real)lbeta;
-    i__1 = -lt;
-    a = pow_ri(&b, &i__1);
-    leps = a;
-
-    /*        Try some tricks to see whether or not this is the correct  EPS. */
-
-    b = two / 3;
-    half = one / 2;
-    r__1 = -half;
-    sixth = slamc3_(&b, &r__1);
-    third = slamc3_(&sixth, &sixth);
-    r__1 = -half;
-    b = slamc3_(&third, &r__1);
-    b = slamc3_(&b, &sixth);
-    b = dabs(b);
-    if (b < leps) {
-      b = leps;
-    }
-
-    leps = 1.f;
-
-  /* +       WHILE( ( LEPS.GT.B ).AND.( B.GT.ZERO ) )LOOP */
-  L10:
-    if (leps > b && b > zero) {
-      leps = b;
-      r__1 = half * leps;
-      /* Computing 5th power */
-      r__3 = two, r__4 = r__3, r__3 *= r__3;
-      /* Computing 2nd power */
-      r__5 = leps;
-      r__2 = r__4 * (r__3 * r__3) * (r__5 * r__5);
-      c__ = slamc3_(&r__1, &r__2);
-      r__1 = -c__;
-      c__ = slamc3_(&half, &r__1);
-      b = slamc3_(&half, &c__);
-      r__1 = -b;
-      c__ = slamc3_(&half, &r__1);
-      b = slamc3_(&half, &c__);
-      goto L10;
-    }
-    /* +       END WHILE */
-
-    if (a < leps) {
-      leps = a;
-    }
-
-    /*        Computation of EPS complete. */
-
-    /*        Now find  EMIN.  Let A = + or - 1, and + or - (1 + BASE**(-3)). */
-    /*        Keep dividing  A by BETA until (gradual) underflow occurs. This */
-    /*        is detected when we cannot recover the previous A. */
-
-    rbase = one / lbeta;
-    small = one;
-    for (i__ = 1; i__ <= 3; ++i__) {
-      r__1 = small * rbase;
-      small = slamc3_(&r__1, &zero);
-      /* L20: */
-    }
-    a = slamc3_(&one, &small);
-    slamc4_(&ngpmin, &one, &lbeta);
-    r__1 = -one;
-    slamc4_(&ngnmin, &r__1, &lbeta);
-    slamc4_(&gpmin, &a, &lbeta);
-    r__1 = -a;
-    slamc4_(&gnmin, &r__1, &lbeta);
-    ieee = FALSE_;
-
-    if (ngpmin == ngnmin && gpmin == gnmin) {
-      if (ngpmin == gpmin) {
-        lemin = ngpmin;
-        /*            ( Non twos-complement machines, no gradual underflow; */
-        /*              e.g.,  VAX ) */
-      } else if (gpmin - ngpmin == 3) {
-        lemin = ngpmin - 1 + lt;
-        ieee = TRUE_;
-        /*            ( Non twos-complement machines, with gradual underflow; */
-        /*              e.g., IEEE standard followers ) */
-      } else {
-        lemin = min(ngpmin, gpmin);
-        /*            ( A guess; no known machine ) */
-        iwarn = TRUE_;
-      }
-
-    } else if (ngpmin == gpmin && ngnmin == gnmin) {
-      if ((i__1 = ngpmin - ngnmin, abs(i__1)) == 1) {
-        lemin = max(ngpmin, ngnmin);
-        /*            ( Twos-complement machines, no gradual underflow; */
-        /*              e.g., CYBER 205 ) */
-      } else {
-        lemin = min(ngpmin, ngnmin);
-        /*            ( A guess; no known machine ) */
-        iwarn = TRUE_;
-      }
-
-    } else if ((i__1 = ngpmin - ngnmin, abs(i__1)) == 1 && gpmin == gnmin) {
-      if (gpmin - min(ngpmin, ngnmin) == 3) {
-        lemin = max(ngpmin, ngnmin) - 1 + lt;
-        /*            ( Twos-complement machines with gradual underflow; */
-        /*              no known machine ) */
-      } else {
-        lemin = min(ngpmin, ngnmin);
-        /*            ( A guess; no known machine ) */
-        iwarn = TRUE_;
-      }
-
-    } else {
-      /* Computing MIN */
-      i__1 = min(ngpmin, ngnmin), i__1 = min(i__1, gpmin);
-      lemin = min(i__1, gnmin);
-      /*         ( A guess; no known machine ) */
-      iwarn = TRUE_;
-    }
-    first = FALSE_;
-    /* ** */
-    /* Comment out this if block if EMIN is ok */
-    /*
-    if (iwarn) {
-      first = TRUE_;
-      s_wsfe(&io___58);
-      do_fio(&c__1, (char *)&lemin, (ftnlen)sizeof(integer));
-      e_wsfe();
-    }
-    */
-    /* ** */
-
-    /*        Assume IEEE arithmetic if we found denormalised  numbers above, */
-    /*        or if arithmetic seems to round in the  IEEE style,  determined */
-    /*        in routine SLAMC1. A true IEEE machine should have both  things */
-    /*        true; however, faulty machines may have one or the other. */
-
-    ieee = ieee || lieee1;
-
-    /*        Compute  RMIN by successive division by  BETA. We could compute */
-    /*        RMIN as BASE**( EMIN - 1 ),  but some machines underflow during */
-    /*        this computation. */
-
-    lrmin = 1.f;
-    i__1 = 1 - lemin;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      r__1 = lrmin * rbase;
-      lrmin = slamc3_(&r__1, &zero);
-      /* L30: */
-    }
-
-    /*        Finally, call SLAMC5 to compute EMAX and RMAX. */
-
-    slamc5_(&lbeta, &lt, &lemin, &ieee, &lemax, &lrmax);
-  }
-
-  *beta = lbeta;
-  *t = lt;
-  *rnd = lrnd;
-  *eps = leps;
-  *emin = lemin;
-  *rmin = lrmin;
-  *emax = lemax;
-  *rmax = lrmax;
-
-  /*     End of SLAMC2 */
-
-} /* slamc2_ */
-
-/* *********************************************************************** */
-
-doublereal slamc3_(real *a, real *b) {
-  /* System generated locals */
-  real ret_val;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLAMC3  is intended to force  A  and  B  to be stored prior to doing */
-  /*  the addition of  A  and  B ,  for use in situations where optimizers */
-  /*  might hold one of these in a register. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  A       (input) REAL */
-  /*  B       (input) REAL */
-  /*          The values A and B. */
-
-  /* ===================================================================== */
-
-  /*     .. Executable Statements .. */
-
-  ret_val = *a + *b;
-
-  return ret_val;
-
-  /*     End of SLAMC3 */
-
-} /* slamc3_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void slamc4_(integer *emin, real *start, integer *base) {
-  /* System generated locals */
-  integer i__1;
-  real r__1;
-
-  /* Local variables */
-  real a;
-  integer i__;
-  real b1, b2, c1, c2, d1, d2, one, zero, rbase;
-  extern doublereal slamc3_(real *, real *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLAMC4 is a service routine for SLAMC2. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  EMIN    (output) INTEGER */
-  /*          The minimum exponent before (gradual) underflow, computed by */
-  /*          setting A = START and dividing by BASE until the previous A */
-  /*          can not be recovered. */
-
-  /*  START   (input) REAL */
-  /*          The starting point for determining EMIN. */
-
-  /*  BASE    (input) INTEGER */
-  /*          The base of the machine. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  a = *start;
-  one = 1.f;
-  rbase = one / *base;
-  zero = 0.f;
-  *emin = 1;
-  r__1 = a * rbase;
-  b1 = slamc3_(&r__1, &zero);
-  c1 = a;
-  c2 = a;
-  d1 = a;
-  d2 = a;
-/* +    WHILE( ( C1.EQ.A ).AND.( C2.EQ.A ).AND. */
-/*    $       ( D1.EQ.A ).AND.( D2.EQ.A )      )LOOP */
-L10:
-  if (c1 == a && c2 == a && d1 == a && d2 == a) {
-    --(*emin);
-    a = b1;
-    r__1 = a / *base;
-    b1 = slamc3_(&r__1, &zero);
-    r__1 = b1 * *base;
-    c1 = slamc3_(&r__1, &zero);
-    d1 = zero;
-    i__1 = *base;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      d1 += b1;
-      /* L20: */
-    }
-    r__1 = a * rbase;
-    b2 = slamc3_(&r__1, &zero);
-    r__1 = b2 / rbase;
-    c2 = slamc3_(&r__1, &zero);
-    d2 = zero;
-    i__1 = *base;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      d2 += b2;
-      /* L30: */
-    }
-    goto L10;
-  }
-  /* +    END WHILE */
-
-  /*     End of SLAMC4 */
-
-} /* slamc4_ */
-
-/* *********************************************************************** */
-
-/* Subroutine */ void slamc5_(integer *beta, integer *p, integer *emin, logical *ieee, integer *emax, real *rmax) {
-  /* System generated locals */
-  integer i__1;
-  real r__1;
-
-  /* Local variables */
-  integer i__;
-  real y, z__;
-  integer try__, lexp;
-  real oldy;
-  integer uexp, nbits;
-  extern doublereal slamc3_(real *, real *);
-  real recbas;
-  integer exbits, expsum;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLAMC5 attempts to compute RMAX, the largest machine floating-point */
-  /*  number, without overflow.  It assumes that EMAX + abs(EMIN) sum */
-  /*  approximately to a power of 2.  It will fail on machines where this */
-  /*  assumption does not hold, for example, the Cyber 205 (EMIN = -28625, */
-  /*  EMAX = 28718).  It will also fail if the value supplied for EMIN is */
-  /*  too large (i.e. too close to zero), probably with overflow. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  BETA    (input) INTEGER */
-  /*          The base of floating-point arithmetic. */
-
-  /*  P       (input) INTEGER */
-  /*          The number of base BETA digits in the mantissa of a */
-  /*          floating-point value. */
-
-  /*  EMIN    (input) INTEGER */
-  /*          The minimum exponent before (gradual) underflow. */
-
-  /*  IEEE    (input) LOGICAL */
-  /*          A logical flag specifying whether or not the arithmetic */
-  /*          system is thought to comply with the IEEE standard. */
-
-  /*  EMAX    (output) INTEGER */
-  /*          The largest exponent before overflow */
-
-  /*  RMAX    (output) REAL */
-  /*          The largest machine floating-point number. */
-
-  /* ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     First compute LEXP and UEXP, two powers of 2 that bound */
-  /*     abs(EMIN). We then assume that EMAX + abs(EMIN) will sum */
-  /*     approximately to the bound that is closest to abs(EMIN). */
-  /*     (EMAX is the exponent of the required number RMAX). */
-
-  lexp = 1;
-  exbits = 1;
-L10:
-  try__ = lexp << 1;
-  if (try__ <= -(*emin)) {
-    lexp = try__;
-    ++exbits;
-    goto L10;
-  }
-  if (lexp == -(*emin)) {
-    uexp = lexp;
-  } else {
-    uexp = try__;
-    ++exbits;
-  }
-
-  /*     Now -LEXP is less than or equal to EMIN, and -UEXP is greater */
-  /*     than or equal to EMIN. EXBITS is the number of bits needed to */
-  /*     store the exponent. */
-
-  if (uexp + *emin > -lexp - *emin) {
-    expsum = lexp << 1;
-  } else {
-    expsum = uexp << 1;
-  }
-
-  /*     EXPSUM is the exponent range, approximately equal to */
-  /*     EMAX - EMIN + 1 . */
-
-  *emax = expsum + *emin - 1;
-  nbits = exbits + 1 + *p;
-
-  /*     NBITS is the total number of bits needed to store a */
-  /*     floating-point number. */
-
-  if (nbits % 2 == 1 && *beta == 2) {
-    /*        Either there are an odd number of bits used to store a */
-    /*        floating-point number, which is unlikely, or some bits are */
-    /*        not used in the representation of numbers, which is possible, */
-    /*        (e.g. Cray machines) or the mantissa has an implicit bit, */
-    /*        (e.g. IEEE machines, Dec Vax machines), which is perhaps the */
-    /*        most likely. We have to assume the last alternative. */
-    /*        If this is true, then we need to reduce EMAX by one because */
-    /*        there must be some way of representing zero in an implicit-bit */
-    /*        system. On machines like Cray, we are reducing EMAX by one */
-    /*        unnecessarily. */
-
-    --(*emax);
-  }
-
-  if (*ieee) {
-    /*        Assume we are on an IEEE machine which reserves one exponent */
-    /*        for infinity and NaN. */
-
-    --(*emax);
-  }
-
-  /*     Now create RMAX, the largest machine number, which should */
-  /*     be equal to (1.0 - BETA**(-P)) * BETA**EMAX . */
-
-  /*     First compute 1.0 - BETA**(-P), being careful that the */
-  /*     result is less than 1.0 . */
-
-  recbas = 1.f / *beta;
-  z__ = *beta - 1.f;
-  y = 0.f;
-  i__1 = *p;
-  for (i__ = 1; i__ <= i__1; ++i__) {
-    z__ *= recbas;
-    if (y < 1.f) {
-      oldy = y;
-    }
-    y = slamc3_(&y, &z__);
-    /* L20: */
-  }
-  if (y >= 1.f) {
-    y = oldy;
-  }
-
-  /*     Now multiply by BETA**EMAX to get RMAX. */
-
-  i__1 = *emax;
-  for (i__ = 1; i__ <= i__1; ++i__) {
-    r__1 = y * *beta;
-    y = slamc3_(&r__1, &c_b32);
-    /* L30: */
-  }
-
-  *rmax = y;
-
-  /*     End of SLAMC5 */
-
-} /* slamc5_ */
diff --git a/lapack/slapy2.c b/lapack/slapy2.c
deleted file mode 100644
index 63293cd..0000000
--- a/lapack/slapy2.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* slapy2.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-doublereal slapy2_(real *x, real *y)
-{
-    /* System generated locals */
-    real ret_val, r__1;
-
-    /* Builtin functions */
-    double sqrt(doublereal);
-
-    /* Local variables */
-    real w, z__, xabs, yabs;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2) -- */
-/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-/*     November 2006 */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  SLAPY2 returns sqrt(x**2+y**2), taking care not to cause unnecessary */
-/*  overflow. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  X       (input) REAL */
-/*  Y       (input) REAL */
-/*          X and Y specify the values x and y. */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Intrinsic Functions .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-    xabs = dabs(*x);
-    yabs = dabs(*y);
-    w = dmax(xabs,yabs);
-    z__ = dmin(xabs,yabs);
-    if (z__ == 0.f) {
-	ret_val = w;
-    } else {
-/* Computing 2nd power */
-	r__1 = z__ / w;
-	ret_val = w * sqrt(r__1 * r__1 + 1.f);
-    }
-    return ret_val;
-
-/*     End of SLAPY2 */
-
-} /* slapy2_ */
diff --git a/lapack/slapy3.c b/lapack/slapy3.c
deleted file mode 100644
index 3e352a4..0000000
--- a/lapack/slapy3.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/* slapy3.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-	on Microsoft Windows system, link with libf2c.lib;
-	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-	or, if you install libf2c.a in a standard place, with -lf2c -lm
-	-- in that order, at the end of the command line, as in
-		cc *.o -lf2c -lm
-	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-		http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-doublereal slapy3_(real *x, real *y, real *z__)
-{
-    /* System generated locals */
-    real ret_val, r__1, r__2, r__3;
-
-    /* Builtin functions */
-    double sqrt(doublereal);
-
-    /* Local variables */
-    real w, xabs, yabs, zabs;
-
-
-/*  -- LAPACK auxiliary routine (version 3.2) -- */
-/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-/*     November 2006 */
-
-/*     .. Scalar Arguments .. */
-/*     .. */
-
-/*  Purpose */
-/*  ======= */
-
-/*  SLAPY3 returns sqrt(x**2+y**2+z**2), taking care not to cause */
-/*  unnecessary overflow. */
-
-/*  Arguments */
-/*  ========= */
-
-/*  X       (input) REAL */
-/*  Y       (input) REAL */
-/*  Z       (input) REAL */
-/*          X, Y and Z specify the values x, y and z. */
-
-/*  ===================================================================== */
-
-/*     .. Parameters .. */
-/*     .. */
-/*     .. Local Scalars .. */
-/*     .. */
-/*     .. Intrinsic Functions .. */
-/*     .. */
-/*     .. Executable Statements .. */
-
-    xabs = dabs(*x);
-    yabs = dabs(*y);
-    zabs = dabs(*z__);
-/* Computing MAX */
-    r__1 = max(xabs,yabs);
-    w = dmax(r__1,zabs);
-    if (w == 0.f) {
-/*     W can be zero for max(0,nan,0) */
-/*     adding all three entries together will make sure */
-/*     NaN will not disappear. */
-	ret_val = xabs + yabs + zabs;
-    } else {
-/* Computing 2nd power */
-	r__1 = xabs / w;
-/* Computing 2nd power */
-	r__2 = yabs / w;
-/* Computing 2nd power */
-	r__3 = zabs / w;
-	ret_val = w * sqrt(r__1 * r__1 + r__2 * r__2 + r__3 * r__3);
-    }
-    return ret_val;
-
-/*     End of SLAPY3 */
-
-} /* slapy3_ */
diff --git a/lapack/slarf.c b/lapack/slarf.c
deleted file mode 100644
index 66133ba..0000000
--- a/lapack/slarf.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/* slarf.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static real c_b4 = 1.f;
-static real c_b5 = 0.f;
-static integer c__1 = 1;
-
-/* Subroutine */ void slarf_(char *side, integer *m, integer *n, real *v, integer *incv, real *tau, real *c__,
-                             integer *ldc, real *work) {
-  /* System generated locals */
-  integer c_dim1, c_offset;
-  real r__1;
-
-  /* Local variables */
-  integer i__;
-  logical applyleft;
-  extern /* Subroutine */ void sger_(integer *, integer *, real *, real *, integer *, real *, integer *, real *,
-                                     integer *);
-  extern logical lsame_(char *, char *);
-  integer lastc;
-  extern /* Subroutine */ void sgemv_(const char *, const integer *, const integer *, const real *, const real *,
-                                      const integer *, const real *, const integer *, const real *, real *,
-                                      const integer *);
-  integer lastv;
-  extern integer ilaslc_(integer *, integer *, real *, integer *), ilaslr_(integer *, integer *, real *, integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLARF applies a real elementary reflector H to a real m by n matrix */
-  /*  C, from either the left or the right. H is represented in the form */
-
-  /*        H = I - tau * v * v' */
-
-  /*  where tau is a real scalar and v is a real vector. */
-
-  /*  If tau = 0, then H is taken to be the unit matrix. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': form  H * C */
-  /*          = 'R': form  C * H */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  V       (input) REAL array, dimension */
-  /*                     (1 + (M-1)*abs(INCV)) if SIDE = 'L' */
-  /*                  or (1 + (N-1)*abs(INCV)) if SIDE = 'R' */
-  /*          The vector v in the representation of H. V is not used if */
-  /*          TAU = 0. */
-
-  /*  INCV    (input) INTEGER */
-  /*          The increment between elements of v. INCV <> 0. */
-
-  /*  TAU     (input) REAL */
-  /*          The value tau in the representation of H. */
-
-  /*  C       (input/output) REAL array, dimension (LDC,N) */
-  /*          On entry, the m by n matrix C. */
-  /*          On exit, C is overwritten by the matrix H * C if SIDE = 'L', */
-  /*          or C * H if SIDE = 'R'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDC >= max(1,M). */
-
-  /*  WORK    (workspace) REAL array, dimension */
-  /*                         (N) if SIDE = 'L' */
-  /*                      or (M) if SIDE = 'R' */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --v;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  --work;
-
-  /* Function Body */
-  applyleft = lsame_(side, "L");
-  lastv = 0;
-  lastc = 0;
-  if (*tau != 0.f) {
-    /*     Set up variables for scanning V.  LASTV begins pointing to the end */
-    /*     of V. */
-    if (applyleft) {
-      lastv = *m;
-    } else {
-      lastv = *n;
-    }
-    if (*incv > 0) {
-      i__ = (lastv - 1) * *incv + 1;
-    } else {
-      i__ = 1;
-    }
-    /*     Look for the last non-zero row in V. */
-    while (lastv > 0 && v[i__] == 0.f) {
-      --lastv;
-      i__ -= *incv;
-    }
-    if (applyleft) {
-      /*     Scan for the last non-zero column in C(1:lastv,:). */
-      lastc = ilaslc_(&lastv, n, &c__[c_offset], ldc);
-    } else {
-      /*     Scan for the last non-zero row in C(:,1:lastv). */
-      lastc = ilaslr_(m, &lastv, &c__[c_offset], ldc);
-    }
-  }
-  /*     Note that lastc.eq.0 renders the BLAS operations null; no special */
-  /*     case is needed at this level. */
-  if (applyleft) {
-    /*        Form  H * C */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1) */
-
-      sgemv_("Transpose", &lastv, &lastc, &c_b4, &c__[c_offset], ldc, &v[1], incv, &c_b5, &work[1], &c__1);
-
-      /*           C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)' */
-
-      r__1 = -(*tau);
-      sger_(&lastv, &lastc, &r__1, &v[1], incv, &work[1], &c__1, &c__[c_offset], ldc);
-    }
-  } else {
-    /*        Form  C * H */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastc,1:lastv) * v(1:lastv,1) */
-
-      sgemv_("No transpose", &lastc, &lastv, &c_b4, &c__[c_offset], ldc, &v[1], incv, &c_b5, &work[1], &c__1);
-
-      /*           C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)' */
-
-      r__1 = -(*tau);
-      sger_(&lastc, &lastv, &r__1, &work[1], &c__1, &v[1], incv, &c__[c_offset], ldc);
-    }
-  }
-
-  /*     End of SLARF */
-
-} /* slarf_ */
diff --git a/lapack/slarfb.c b/lapack/slarfb.c
deleted file mode 100644
index 95364b2..0000000
--- a/lapack/slarfb.c
+++ /dev/null
@@ -1,679 +0,0 @@
-/* slarfb.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static integer c__1 = 1;
-static real c_b14 = 1.f;
-static real c_b25 = -1.f;
-
-/* Subroutine */ void slarfb_(char *side, char *trans, char *direct, char *storev, integer *m, integer *n, integer *k,
-                              real *v, integer *ldv, real *t, integer *ldt, real *c__, integer *ldc, real *work,
-                              integer *ldwork) {
-  /* System generated locals */
-  integer c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1, work_offset, i__1, i__2;
-
-  /* Local variables */
-  integer i__, j;
-  extern logical lsame_(char *, char *);
-  integer lastc;
-  extern /* Subroutine */ void sgemm_(const char *, const char *, const integer *, const integer *, const integer *,
-                                      const real *, const real *, const integer *, const real *, const integer *,
-                                      const real *, real *, const integer *);
-  integer lastv;
-  extern /* Subroutine */ void scopy_(integer *, real *, integer *, real *, integer *),
-      strmm_(const char *, const char *, const char *, const char *, const integer *, const integer *, const real *,
-             const real *, const integer *, real *, const integer *);
-  extern integer ilaslc_(integer *, integer *, real *, integer *), ilaslr_(integer *, integer *, real *, integer *);
-  char transt[1];
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLARFB applies a real block reflector H or its transpose H' to a */
-  /*  real m by n matrix C, from either the left or the right. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': apply H or H' from the Left */
-  /*          = 'R': apply H or H' from the Right */
-
-  /*  TRANS   (input) CHARACTER*1 */
-  /*          = 'N': apply H (No transpose) */
-  /*          = 'T': apply H' (Transpose) */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Indicates how H is formed from a product of elementary */
-  /*          reflectors */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Indicates how the vectors which define the elementary */
-  /*          reflectors are stored: */
-  /*          = 'C': Columnwise */
-  /*          = 'R': Rowwise */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the matrix T (= the number of elementary */
-  /*          reflectors whose product defines the block reflector). */
-
-  /*  V       (input) REAL array, dimension */
-  /*                                (LDV,K) if STOREV = 'C' */
-  /*                                (LDV,M) if STOREV = 'R' and SIDE = 'L' */
-  /*                                (LDV,N) if STOREV = 'R' and SIDE = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M); */
-  /*          if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N); */
-  /*          if STOREV = 'R', LDV >= K. */
-
-  /*  T       (input) REAL array, dimension (LDT,K) */
-  /*          The triangular k by k matrix T in the representation of the */
-  /*          block reflector. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  C       (input/output) REAL array, dimension (LDC,N) */
-  /*          On entry, the m by n matrix C. */
-  /*          On exit, C is overwritten by H*C or H'*C or C*H or C*H'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDA >= max(1,M). */
-
-  /*  WORK    (workspace) REAL array, dimension (LDWORK,K) */
-
-  /*  LDWORK  (input) INTEGER */
-  /*          The leading dimension of the array WORK. */
-  /*          If SIDE = 'L', LDWORK >= max(1,N); */
-  /*          if SIDE = 'R', LDWORK >= max(1,M). */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  work_dim1 = *ldwork;
-  work_offset = 1 + work_dim1;
-  work -= work_offset;
-
-  /* Function Body */
-  if (*m <= 0 || *n <= 0) {
-    return;
-  }
-
-  if (lsame_(trans, "N")) {
-    *(unsigned char *)transt = 'T';
-  } else {
-    *(unsigned char *)transt = 'N';
-  }
-
-  if (lsame_(storev, "C")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1 )    (first K rows) */
-      /*                     ( V2 ) */
-      /*           where  V1  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L10: */
-        }
-
-        /*              W := W * V1 */
-
-        strmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2 */
-
-          i__1 = lastv - *k;
-          sgemm_("Transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[*k + 1 + c_dim1], ldc, &v[*k + 1 + v_dim1],
-                 ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        strmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - V2 * W' */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[*k + 1 + v_dim1], ldv, &work[work_offset],
-                 ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        strmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L20: */
-          }
-          /* L30: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L40: */
-        }
-
-        /*              W := W * V1 */
-
-        strmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2 */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[*k + 1 + v_dim1], ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        strmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2' */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "Transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork, &v[*k + 1 + v_dim1],
-                 ldv, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        strmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
-            /* L50: */
-          }
-          /* L60: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1 ) */
-      /*                     ( V2 )    (last K rows) */
-      /*           where  V2  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L70: */
-        }
-
-        /*              W := W * V2 */
-
-        strmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1 */
-
-          i__1 = lastv - *k;
-          sgemm_("Transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b14,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        strmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1 * W' */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[v_offset], ldv, &work[work_offset], ldwork,
-                 &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        strmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[lastv - *k + j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L80: */
-          }
-          /* L90: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[(*n - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L100: */
-        }
-
-        /*              W := W * V2 */
-
-        strmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1 */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv,
-                 &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        strmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1' */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "Transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork, &v[v_offset], ldv,
-                 &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        strmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + (lastv - *k + j) * c_dim1] -= work[i__ + j * work_dim1];
-            /* L110: */
-          }
-          /* L120: */
-        }
-      }
-    }
-
-  } else if (lsame_(storev, "R")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1  V2 )    (V1: first K columns) */
-      /*           where  V1  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L130: */
-        }
-
-        /*              W := W * V1' */
-
-        strmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2' */
-
-          i__1 = lastv - *k;
-          sgemm_("Transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[*k + 1 + c_dim1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        strmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - V2' * W' */
-
-          i__1 = lastv - *k;
-          sgemm_("Transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[(*k + 1) * v_dim1 + 1], ldv, &work[work_offset],
-                 ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        strmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L140: */
-          }
-          /* L150: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L160: */
-        }
-
-        /*              W := W * V1' */
-
-        strmm_("Right", "Upper", "Transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2' */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b14, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        strmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2 */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "No transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        strmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b14, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
-            /* L170: */
-          }
-          /* L180: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1  V2 )    (V2: last K columns) */
-      /*           where  V2  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          /* L190: */
-        }
-
-        /*              W := W * V2' */
-
-        strmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1' */
-
-          i__1 = lastv - *k;
-          sgemm_("Transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b14,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        strmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1' * W' */
-
-          i__1 = lastv - *k;
-          sgemm_("Transpose", "Transpose", &i__1, &lastc, k, &c_b25, &v[v_offset], ldv, &work[work_offset], ldwork,
-                 &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        strmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[lastv - *k + j + i__ * c_dim1] -= work[i__ + j * work_dim1];
-            /* L200: */
-          }
-          /* L210: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilaslc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilaslr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          scopy_(&lastc, &c__[(lastv - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L220: */
-        }
-
-        /*              W := W * V2' */
-
-        strmm_("Right", "Lower", "Transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1' */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "Transpose", &lastc, k, &i__1, &c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b14,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        strmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b14, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1 */
-
-          i__1 = lastv - *k;
-          sgemm_("No transpose", "No transpose", &lastc, &i__1, k, &c_b25, &work[work_offset], ldwork, &v[v_offset],
-                 ldv, &c_b14, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        strmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b14, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            c__[i__ + (lastv - *k + j) * c_dim1] -= work[i__ + j * work_dim1];
-            /* L230: */
-          }
-          /* L240: */
-        }
-      }
-    }
-  }
-
-  /*     End of SLARFB */
-
-} /* slarfb_ */
diff --git a/lapack/slarfg.c b/lapack/slarfg.c
deleted file mode 100644
index beccdc3..0000000
--- a/lapack/slarfg.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/* slarfg.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline real r_sign(real *a, real *b) {
-  real x;
-  x = (*a >= 0 ? *a : -*a);
-  return (*b >= 0 ? x : -x);
-}
-
-/* Subroutine */ void slarfg_(integer *n, real *alpha, real *x, integer *incx, real *tau) {
-  /* System generated locals */
-  integer i__1;
-  real r__1;
-
-  /* Local variables */
-  integer j, knt;
-  real beta;
-  extern real snrm2_(integer *, real *, integer *);
-  extern /* Subroutine */ void sscal_(integer *, real *, real *, integer *);
-  real xnorm;
-  extern doublereal slapy2_(real *, real *), slamch_(char *);
-  real safmin, rsafmn;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLARFG generates a real elementary reflector H of order n, such */
-  /*  that */
-
-  /*        H * ( alpha ) = ( beta ),   H' * H = I. */
-  /*            (   x   )   (   0  ) */
-
-  /*  where alpha and beta are scalars, and x is an (n-1)-element real */
-  /*  vector. H is represented in the form */
-
-  /*        H = I - tau * ( 1 ) * ( 1 v' ) , */
-  /*                      ( v ) */
-
-  /*  where tau is a real scalar and v is a real (n-1)-element */
-  /*  vector. */
-
-  /*  If the elements of x are all zero, then tau = 0 and H is taken to be */
-  /*  the unit matrix. */
-
-  /*  Otherwise  1 <= tau <= 2. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the elementary reflector. */
-
-  /*  ALPHA   (input/output) REAL */
-  /*          On entry, the value alpha. */
-  /*          On exit, it is overwritten with the value beta. */
-
-  /*  X       (input/output) REAL array, dimension */
-  /*                         (1+(N-2)*abs(INCX)) */
-  /*          On entry, the vector x. */
-  /*          On exit, it is overwritten with the vector v. */
-
-  /*  INCX    (input) INTEGER */
-  /*          The increment between elements of X. INCX > 0. */
-
-  /*  TAU     (output) REAL */
-  /*          The value tau. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --x;
-
-  /* Function Body */
-  if (*n <= 1) {
-    *tau = 0.f;
-    return;
-  }
-
-  i__1 = *n - 1;
-  xnorm = snrm2_(&i__1, &x[1], incx);
-
-  if (xnorm == 0.f) {
-    /*        H  =  I */
-
-    *tau = 0.f;
-  } else {
-    /*        general case */
-
-    r__1 = slapy2_(alpha, &xnorm);
-    beta = -r_sign(&r__1, alpha);
-    safmin = slamch_("S") / slamch_("E");
-    knt = 0;
-    if (dabs(beta) < safmin) {
-      /*           XNORM, BETA may be inaccurate; scale X and recompute them */
-
-      rsafmn = 1.f / safmin;
-    L10:
-      ++knt;
-      i__1 = *n - 1;
-      sscal_(&i__1, &rsafmn, &x[1], incx);
-      beta *= rsafmn;
-      *alpha *= rsafmn;
-      if (dabs(beta) < safmin) {
-        goto L10;
-      }
-
-      /*           New BETA is at most 1, at least SAFMIN */
-
-      i__1 = *n - 1;
-      xnorm = snrm2_(&i__1, &x[1], incx);
-      r__1 = slapy2_(alpha, &xnorm);
-      beta = -r_sign(&r__1, alpha);
-    }
-    *tau = (beta - *alpha) / beta;
-    i__1 = *n - 1;
-    r__1 = 1.f / (*alpha - beta);
-    sscal_(&i__1, &r__1, &x[1], incx);
-
-    /*        If ALPHA is subnormal, it may lose relative accuracy */
-
-    i__1 = knt;
-    for (j = 1; j <= i__1; ++j) {
-      beta *= safmin;
-      /* L20: */
-    }
-    *alpha = beta;
-  }
-
-  /*     End of SLARFG */
-
-} /* slarfg_ */
diff --git a/lapack/slarft.c b/lapack/slarft.c
deleted file mode 100644
index 97bfa41..0000000
--- a/lapack/slarft.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/* slarft.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static integer c__1 = 1;
-static real c_b8 = 0.f;
-
-/* Subroutine */ void slarft_(char *direct, char *storev, integer *n, integer *k, real *v, integer *ldv, real *tau,
-                              real *t, integer *ldt) {
-  /* System generated locals */
-  integer t_dim1, t_offset, v_dim1, v_offset, i__1, i__2, i__3;
-  real r__1;
-
-  /* Local variables */
-  integer i__, j, prevlastv;
-  real vii;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void sgemv_(const char *, const integer *, const integer *, const real *, const real *,
-                                      const integer *, const real *, const integer *, const real *, real *,
-                                      const integer *);
-  integer lastv;
-  extern /* Subroutine */ void strmv_(const char *, const char *, const char *, const integer *, const real *,
-                                      const integer *, real *, const integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  SLARFT forms the triangular factor T of a real block reflector H */
-  /*  of order n, which is defined as a product of k elementary reflectors. */
-
-  /*  If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; */
-
-  /*  If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. */
-
-  /*  If STOREV = 'C', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th column of the array V, and */
-
-  /*     H  =  I - V * T * V' */
-
-  /*  If STOREV = 'R', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th row of the array V, and */
-
-  /*     H  =  I - V' * T * V */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Specifies the order in which the elementary reflectors are */
-  /*          multiplied to form the block reflector: */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Specifies how the vectors which define the elementary */
-  /*          reflectors are stored (see also Further Details): */
-  /*          = 'C': columnwise */
-  /*          = 'R': rowwise */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the block reflector H. N >= 0. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the triangular factor T (= the number of */
-  /*          elementary reflectors). K >= 1. */
-
-  /*  V       (input/output) REAL array, dimension */
-  /*                               (LDV,K) if STOREV = 'C' */
-  /*                               (LDV,N) if STOREV = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K. */
-
-  /*  TAU     (input) REAL array, dimension (K) */
-  /*          TAU(i) must contain the scalar factor of the elementary */
-  /*          reflector H(i). */
-
-  /*  T       (output) REAL array, dimension (LDT,K) */
-  /*          The k by k triangular factor T of the block reflector. */
-  /*          If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is */
-  /*          lower triangular. The rest of the array is not used. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The shape of the matrix V and the storage of the vectors which define */
-  /*  the H(i) is best illustrated by the following example with n = 5 and */
-  /*  k = 3. The elements equal to 1 are not stored; the corresponding */
-  /*  array elements are modified but restored on exit. The rest of the */
-  /*  array is not used. */
-
-  /*  DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R': */
-
-  /*               V = (  1       )                 V = (  1 v1 v1 v1 v1 ) */
-  /*                   ( v1  1    )                     (     1 v2 v2 v2 ) */
-  /*                   ( v1 v2  1 )                     (        1 v3 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-
-  /*  DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R': */
-
-  /*               V = ( v1 v2 v3 )                 V = ( v1 v1  1       ) */
-  /*                   ( v1 v2 v3 )                     ( v2 v2 v2  1    ) */
-  /*                   (  1 v2 v3 )                     ( v3 v3 v3 v3  1 ) */
-  /*                   (     1 v3 ) */
-  /*                   (        1 ) */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  --tau;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-
-  /* Function Body */
-  if (*n == 0) {
-    return;
-  }
-
-  if (lsame_(direct, "F")) {
-    prevlastv = *n;
-    i__1 = *k;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      prevlastv = max(i__, prevlastv);
-      if (tau[i__] == 0.f) {
-        /*              H(i)  =  I */
-
-        i__2 = i__;
-        for (j = 1; j <= i__2; ++j) {
-          t[j + i__ * t_dim1] = 0.f;
-          /* L10: */
-        }
-      } else {
-        /*              general case */
-
-        vii = v[i__ + i__ * v_dim1];
-        v[i__ + i__ * v_dim1] = 1.f;
-        if (lsame_(storev, "C")) {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            if (v[lastv + i__ * v_dim1] != 0.f) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i) */
-
-          i__2 = j - i__ + 1;
-          i__3 = i__ - 1;
-          r__1 = -tau[i__];
-          sgemv_("Transpose", &i__2, &i__3, &r__1, &v[i__ + v_dim1], ldv, &v[i__ + i__ * v_dim1], &c__1, &c_b8,
-                 &t[i__ * t_dim1 + 1], &c__1);
-        } else {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            if (v[i__ + lastv * v_dim1] != 0.f) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)' */
-
-          i__2 = i__ - 1;
-          i__3 = j - i__ + 1;
-          r__1 = -tau[i__];
-          sgemv_("No transpose", &i__2, &i__3, &r__1, &v[i__ * v_dim1 + 1], ldv, &v[i__ + i__ * v_dim1], ldv, &c_b8,
-                 &t[i__ * t_dim1 + 1], &c__1);
-        }
-        v[i__ + i__ * v_dim1] = vii;
-
-        /*              T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i) */
-
-        i__2 = i__ - 1;
-        strmv_("Upper", "No transpose", "Non-unit", &i__2, &t[t_offset], ldt, &t[i__ * t_dim1 + 1], &c__1);
-        t[i__ + i__ * t_dim1] = tau[i__];
-        if (i__ > 1) {
-          prevlastv = max(prevlastv, lastv);
-        } else {
-          prevlastv = lastv;
-        }
-      }
-      /* L20: */
-    }
-  } else {
-    prevlastv = 1;
-    for (i__ = *k; i__ >= 1; --i__) {
-      if (tau[i__] == 0.f) {
-        /*              H(i)  =  I */
-
-        i__1 = *k;
-        for (j = i__; j <= i__1; ++j) {
-          t[j + i__ * t_dim1] = 0.f;
-          /* L30: */
-        }
-      } else {
-        /*              general case */
-
-        if (i__ < *k) {
-          if (lsame_(storev, "C")) {
-            vii = v[*n - *k + i__ + i__ * v_dim1];
-            v[*n - *k + i__ + i__ * v_dim1] = 1.f;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              if (v[lastv + i__ * v_dim1] != 0.f) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i) */
-
-            i__1 = *n - *k + i__ - j + 1;
-            i__2 = *k - i__;
-            r__1 = -tau[i__];
-            sgemv_("Transpose", &i__1, &i__2, &r__1, &v[j + (i__ + 1) * v_dim1], ldv, &v[j + i__ * v_dim1], &c__1,
-                   &c_b8, &t[i__ + 1 + i__ * t_dim1], &c__1);
-            v[*n - *k + i__ + i__ * v_dim1] = vii;
-          } else {
-            vii = v[i__ + (*n - *k + i__) * v_dim1];
-            v[i__ + (*n - *k + i__) * v_dim1] = 1.f;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              if (v[i__ + lastv * v_dim1] != 0.f) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)' */
-
-            i__1 = *k - i__;
-            i__2 = *n - *k + i__ - j + 1;
-            r__1 = -tau[i__];
-            sgemv_("No transpose", &i__1, &i__2, &r__1, &v[i__ + 1 + j * v_dim1], ldv, &v[i__ + j * v_dim1], ldv, &c_b8,
-                   &t[i__ + 1 + i__ * t_dim1], &c__1);
-            v[i__ + (*n - *k + i__) * v_dim1] = vii;
-          }
-
-          /*                 T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i) */
-
-          i__1 = *k - i__;
-          strmv_("Lower", "No transpose", "Non-unit", &i__1, &t[i__ + 1 + (i__ + 1) * t_dim1], ldt,
-                 &t[i__ + 1 + i__ * t_dim1], &c__1);
-          if (i__ > 1) {
-            prevlastv = min(prevlastv, lastv);
-          } else {
-            prevlastv = lastv;
-          }
-        }
-        t[i__ + i__ * t_dim1] = tau[i__];
-      }
-      /* L40: */
-    }
-  }
-
-  /*     End of SLARFT */
-
-} /* slarft_ */
diff --git a/lapack/svd.inc b/lapack/svd.inc
index 733f07e..b186e56 100644
--- a/lapack/svd.inc
+++ b/lapack/svd.inc
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "lapack_common.h"
 #include <Eigen/SVD>
@@ -44,7 +45,7 @@
 
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "GESDD ", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "GESDD ", &e, kBlasNameLength);
   }
 
   if (query_size) {
@@ -114,7 +115,7 @@
 
   if (*info != 0) {
     int e = -*info;
-    return xerbla_(SCALAR_SUFFIX_UP "GESVD ", &e);
+    return xerbla_(SCALAR_SUFFIX_UP "GESVD ", &e, kBlasNameLength);
   }
 
   if (query_size) {
diff --git a/lapack/utilities.inc b/lapack/utilities.inc
new file mode 100644
index 0000000..4785ec7
--- /dev/null
+++ b/lapack/utilities.inc
@@ -0,0 +1,101 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2024 The Eigen Authors
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "lapack_common.h"
+
+#if !ISCOMPLEX
+
+// Compute sqrt(x*x + y*y) taking care not to cause unnecessary overflow.
+extern "C" EIGEN_LAPACK_API Scalar EIGEN_BLAS_FUNC_NAME(lapy2)(Scalar* x, Scalar* y) {
+  return Eigen::numext::hypot(*x, *y);
+}
+
+// Compute sqrt(x*x + y*y + z*z) taking care not to cause unnecessary overflow.
+extern "C" EIGEN_LAPACK_API Scalar EIGEN_BLAS_FUNC_NAME(lapy3)(Scalar* x, Scalar* y, Scalar* z) {
+  return Eigen::internal::xlapy3(*x, *y, *z);
+}
+
+// Determines machine parameters according to LAPACK specification.
+extern "C" EIGEN_LAPACK_API Scalar EIGEN_BLAS_FUNC_NAME(lamch)(const char* cmach) {
+  return Eigen::internal::xlamch<Scalar>(*cmach);
+}
+
+// xLAMC3 is intended to force A and B to be stored prior to doing
+// the addition of A and B, for use in situations where optimizers
+// might hold one of these in a register.
+extern "C" EIGEN_LAPACK_API Scalar EIGEN_BLAS_FUNC_NAME(lamc3)(Scalar* a, Scalar* b) {
+  volatile Scalar retval = *a + *b;
+  return retval;
+}
+
+// Performs complex division in real arithmetic, avoiding unnecessary overflow.
+// Consistent with LAPACK SLADIV / DLADIV (Smith's algorithm).
+EIGEN_LAPACK_FUNC(ladiv)(const Scalar* a, const Scalar* b, const Scalar* c, const Scalar* d, Scalar* p, Scalar* q) {
+  const std::complex<Scalar> res = Eigen::internal::xladiv(*a, *b, *c, *d);
+  *p = Eigen::numext::real(res);
+  *q = Eigen::numext::imag(res);
+}
+
+// Last non-zero column/row scanning for real matrices.
+extern "C" EIGEN_LAPACK_API int EIGEN_CAT(ila, EIGEN_CAT(SCALAR_SUFFIX, lc_))(int* m, int* n, Scalar* a, int* lda) {
+  return Eigen::internal::ilaxlc(*m, *n, a, *lda);
+}
+
+extern "C" EIGEN_LAPACK_API int EIGEN_CAT(ila, EIGEN_CAT(SCALAR_SUFFIX, lr_))(int* m, int* n, Scalar* a, int* lda) {
+  return Eigen::internal::ilaxlr(*m, *n, a, *lda);
+}
+
+#else
+
+namespace {
+template <typename T>
+struct complex_return_type;
+
+template <>
+struct complex_return_type<float> {
+  using type = eigen_lapack_complex_float;
+};
+
+template <>
+struct complex_return_type<double> {
+  using type = eigen_lapack_complex_double;
+};
+}  // namespace
+
+// Conjugates entries of vector x.
+EIGEN_LAPACK_FUNC(lacgv)(int* n, RealScalar* px, int* incx) {
+  Eigen::internal::xlacgv(*n, reinterpret_cast<Scalar*>(px), *incx);
+}
+
+// Performs complex division avoiding unnecessary overflow.
+// Consistent with LAPACK CLADIV / ZLADIV (Smith's algorithm).
+// Note on calling convention: Returning a 2-element struct { RealScalar r, i; }
+// by value adheres to the SysV AMD64 ABI (gfortran on Linux/x86_64), consistent
+// with the return-by-value convention used for cdotc/zdotc in blas/complexdots.cpp.
+// Non-SysV environments (such as MSVC or f2c) may use hidden-pointer return conventions
+// for complex-valued Fortran functions.
+extern "C" EIGEN_LAPACK_API typename complex_return_type<RealScalar>::type EIGEN_BLAS_FUNC_NAME(ladiv)(
+    const RealScalar* px, const RealScalar* py) {
+  const auto* x = reinterpret_cast<const Scalar*>(px);
+  const auto* y = reinterpret_cast<const Scalar*>(py);
+  const Scalar res = Eigen::internal::xladiv(*x, *y);
+  return {Eigen::numext::real(res), Eigen::numext::imag(res)};
+}
+
+// Last non-zero column/row scanning for complex matrices.
+extern "C" EIGEN_LAPACK_API int EIGEN_CAT(ila, EIGEN_CAT(SCALAR_SUFFIX, lc_))(int* m, int* n, RealScalar* a, int* lda) {
+  return Eigen::internal::ilaxlc(*m, *n, reinterpret_cast<Scalar*>(a), *lda);
+}
+
+extern "C" EIGEN_LAPACK_API int EIGEN_CAT(ila, EIGEN_CAT(SCALAR_SUFFIX, lr_))(int* m, int* n, RealScalar* a, int* lda) {
+  return Eigen::internal::ilaxlr(*m, *n, reinterpret_cast<Scalar*>(a), *lda);
+}
+
+#endif
diff --git a/lapack/zlacgv.c b/lapack/zlacgv.c
deleted file mode 100644
index 672fb3e..0000000
--- a/lapack/zlacgv.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* zlacgv.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline void d_cnjg(doublecomplex *r, doublecomplex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Subroutine */ void zlacgv_(integer *n, doublecomplex *x, integer *incx) {
-  /* System generated locals */
-  integer i__1, i__2;
-  doublecomplex z__1;
-
-  /* Local variables */
-  integer i__, ioff;
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZLACGV conjugates a complex vector of length N. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N       (input) INTEGER */
-  /*          The length of the vector X.  N >= 0. */
-
-  /*  X       (input/output) COMPLEX*16 array, dimension */
-  /*                         (1+(N-1)*abs(INCX)) */
-  /*          On entry, the vector of length N to be conjugated. */
-  /*          On exit, X is overwritten with conjg(X). */
-
-  /*  INCX    (input) INTEGER */
-  /*          The spacing between successive elements of X. */
-
-  /* ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --x;
-
-  /* Function Body */
-  if (*incx == 1) {
-    i__1 = *n;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      i__2 = i__;
-      d_cnjg(&z__1, &x[i__]);
-      x[i__2].r = z__1.r, x[i__2].i = z__1.i;
-      /* L10: */
-    }
-  } else {
-    ioff = 1;
-    if (*incx < 0) {
-      ioff = 1 - (*n - 1) * *incx;
-    }
-    i__1 = *n;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      i__2 = ioff;
-      d_cnjg(&z__1, &x[ioff]);
-      x[i__2].r = z__1.r, x[i__2].i = z__1.i;
-      ioff += *incx;
-      /* L20: */
-    }
-  }
-
-  /*     End of ZLACGV */
-
-} /* zlacgv_ */
diff --git a/lapack/zladiv.c b/lapack/zladiv.c
deleted file mode 100644
index 37aa923..0000000
--- a/lapack/zladiv.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/* zladiv.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Double Complex */ void zladiv_(doublecomplex *ret_val, doublecomplex *x, doublecomplex *y) {
-  /* System generated locals */
-  doublereal d__1, d__2, d__3, d__4;
-  doublecomplex z__1;
-
-  /* Local variables */
-  doublereal zi, zr;
-  extern /* Subroutine */ void dladiv_(doublereal *, doublereal *, doublereal *, doublereal *, doublereal *,
-                                       doublereal *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZLADIV := X / Y, where X and Y are complex.  The computation of X / Y */
-  /*  will not overflow on an intermediary step unless the results */
-  /*  overflows. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  X       (input) COMPLEX*16 */
-  /*  Y       (input) COMPLEX*16 */
-  /*          The complex scalars X and Y. */
-
-  /*  ===================================================================== */
-
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  d__1 = x->r;
-  d__2 = x->i;
-  d__3 = y->r;
-  d__4 = y->i;
-  dladiv_(&d__1, &d__2, &d__3, &d__4, &zr, &zi);
-  z__1.r = zr, z__1.i = zi;
-  ret_val->r = z__1.r, ret_val->i = z__1.i;
-
-  /*     End of ZLADIV */
-
-} /* zladiv_ */
diff --git a/lapack/zlarf.c b/lapack/zlarf.c
deleted file mode 100644
index 032cb31..0000000
--- a/lapack/zlarf.c
+++ /dev/null
@@ -1,187 +0,0 @@
-/* zlarf.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static doublecomplex c_b1 = {1., 0.};
-static doublecomplex c_b2 = {0., 0.};
-static integer c__1 = 1;
-
-/* Subroutine */ void zlarf_(char *side, integer *m, integer *n, doublecomplex *v, integer *incv, doublecomplex *tau,
-                             doublecomplex *c__, integer *ldc, doublecomplex *work) {
-  /* System generated locals */
-  integer c_dim1, c_offset, i__1;
-  doublecomplex z__1;
-
-  /* Local variables */
-  integer i__;
-  logical applyleft;
-  extern logical lsame_(char *, char *);
-  integer lastc;
-  extern /* Subroutine */ void zgerc_(integer *, integer *, doublecomplex *, doublecomplex *, integer *,
-                                      doublecomplex *, integer *, doublecomplex *, integer *),
-      zgemv_(const char *, const integer *, const integer *, const doublecomplex *, const doublecomplex *,
-             const integer *, const doublecomplex *, const integer *, const doublecomplex *, doublecomplex *,
-             const integer *);
-  integer lastv;
-  extern integer ilazlc_(integer *, integer *, doublecomplex *, integer *),
-      ilazlr_(integer *, integer *, doublecomplex *, integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZLARF applies a complex elementary reflector H to a complex M-by-N */
-  /*  matrix C, from either the left or the right. H is represented in the */
-  /*  form */
-
-  /*        H = I - tau * v * v' */
-
-  /*  where tau is a complex scalar and v is a complex vector. */
-
-  /*  If tau = 0, then H is taken to be the unit matrix. */
-
-  /*  To apply H' (the conjugate transpose of H), supply conjg(tau) instead */
-  /*  tau. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': form  H * C */
-  /*          = 'R': form  C * H */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  V       (input) COMPLEX*16 array, dimension */
-  /*                     (1 + (M-1)*abs(INCV)) if SIDE = 'L' */
-  /*                  or (1 + (N-1)*abs(INCV)) if SIDE = 'R' */
-  /*          The vector v in the representation of H. V is not used if */
-  /*          TAU = 0. */
-
-  /*  INCV    (input) INTEGER */
-  /*          The increment between elements of v. INCV <> 0. */
-
-  /*  TAU     (input) COMPLEX*16 */
-  /*          The value tau in the representation of H. */
-
-  /*  C       (input/output) COMPLEX*16 array, dimension (LDC,N) */
-  /*          On entry, the M-by-N matrix C. */
-  /*          On exit, C is overwritten by the matrix H * C if SIDE = 'L', */
-  /*          or C * H if SIDE = 'R'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDC >= max(1,M). */
-
-  /*  WORK    (workspace) COMPLEX*16 array, dimension */
-  /*                         (N) if SIDE = 'L' */
-  /*                      or (M) if SIDE = 'R' */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --v;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  --work;
-
-  /* Function Body */
-  applyleft = lsame_(side, "L");
-  lastv = 0;
-  lastc = 0;
-  if (tau->r != 0. || tau->i != 0.) {
-    /*     Set up variables for scanning V.  LASTV begins pointing to the end */
-    /*     of V. */
-    if (applyleft) {
-      lastv = *m;
-    } else {
-      lastv = *n;
-    }
-    if (*incv > 0) {
-      i__ = (lastv - 1) * *incv + 1;
-    } else {
-      i__ = 1;
-    }
-    /*     Look for the last non-zero row in V. */
-    for (;;) { /* while(complicated condition) */
-      i__1 = i__;
-      if (!(lastv > 0 && (v[i__1].r == 0. && v[i__1].i == 0.))) break;
-      --lastv;
-      i__ -= *incv;
-    }
-    if (applyleft) {
-      /*     Scan for the last non-zero column in C(1:lastv,:). */
-      lastc = ilazlc_(&lastv, n, &c__[c_offset], ldc);
-    } else {
-      /*     Scan for the last non-zero row in C(:,1:lastv). */
-      lastc = ilazlr_(m, &lastv, &c__[c_offset], ldc);
-    }
-  }
-  /*     Note that lastc.eq.0 renders the BLAS operations null; no special */
-  /*     case is needed at this level. */
-  if (applyleft) {
-    /*        Form  H * C */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastv,1:lastc)' * v(1:lastv,1) */
-
-      zgemv_("Conjugate transpose", &lastv, &lastc, &c_b1, &c__[c_offset], ldc, &v[1], incv, &c_b2, &work[1], &c__1);
-
-      /*           C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)' */
-
-      z__1.r = -tau->r, z__1.i = -tau->i;
-      zgerc_(&lastv, &lastc, &z__1, &v[1], incv, &work[1], &c__1, &c__[c_offset], ldc);
-    }
-  } else {
-    /*        Form  C * H */
-
-    if (lastv > 0) {
-      /*           w(1:lastc,1) := C(1:lastc,1:lastv) * v(1:lastv,1) */
-
-      zgemv_("No transpose", &lastc, &lastv, &c_b1, &c__[c_offset], ldc, &v[1], incv, &c_b2, &work[1], &c__1);
-
-      /*           C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)' */
-
-      z__1.r = -tau->r, z__1.i = -tau->i;
-      zgerc_(&lastc, &lastv, &z__1, &work[1], &c__1, &v[1], incv, &c__[c_offset], ldc);
-    }
-  }
-
-  /*     End of ZLARF */
-
-} /* zlarf_ */
diff --git a/lapack/zlarfb.c b/lapack/zlarfb.c
deleted file mode 100644
index d98370c..0000000
--- a/lapack/zlarfb.c
+++ /dev/null
@@ -1,737 +0,0 @@
-/* zlarfb.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline void d_cnjg(doublecomplex *r, doublecomplex *z) {
-  r->r = z->r;
-  r->i = -(z->i);
-}
-
-/* Table of constant values */
-
-static doublecomplex c_b1 = {1., 0.};
-static integer c__1 = 1;
-
-/* Subroutine */ void zlarfb_(char *side, char *trans, char *direct, char *storev, integer *m, integer *n, integer *k,
-                              doublecomplex *v, integer *ldv, doublecomplex *t, integer *ldt, doublecomplex *c__,
-                              integer *ldc, doublecomplex *work, integer *ldwork) {
-  /* System generated locals */
-  integer c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1, work_offset, i__1, i__2, i__3, i__4, i__5;
-  doublecomplex z__1, z__2;
-
-  /* Local variables */
-  integer i__, j;
-  extern logical lsame_(char *, char *);
-  integer lastc;
-  extern /* Subroutine */ void zgemm_(const char *, const char *, const integer *, const integer *, const integer *,
-                                      const doublecomplex *, const doublecomplex *, const integer *,
-                                      const doublecomplex *, const integer *, const doublecomplex *, doublecomplex *,
-                                      const integer *);
-  integer lastv;
-  extern /* Subroutine */ void zcopy_(integer *, doublecomplex *, integer *, doublecomplex *, integer *),
-      ztrmm_(const char *, const char *, const char *, const char *, const integer *, const integer *,
-             const doublecomplex *, const doublecomplex *, const integer *, doublecomplex *, const integer *);
-  extern integer ilazlc_(integer *, integer *, doublecomplex *, integer *);
-  extern /* Subroutine */ void zlacgv_(integer *, doublecomplex *, integer *);
-  extern integer ilazlr_(integer *, integer *, doublecomplex *, integer *);
-  char transt[1];
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZLARFB applies a complex block reflector H or its transpose H' to a */
-  /*  complex M-by-N matrix C, from either the left or the right. */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  SIDE    (input) CHARACTER*1 */
-  /*          = 'L': apply H or H' from the Left */
-  /*          = 'R': apply H or H' from the Right */
-
-  /*  TRANS   (input) CHARACTER*1 */
-  /*          = 'N': apply H (No transpose) */
-  /*          = 'C': apply H' (Conjugate transpose) */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Indicates how H is formed from a product of elementary */
-  /*          reflectors */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Indicates how the vectors which define the elementary */
-  /*          reflectors are stored: */
-  /*          = 'C': Columnwise */
-  /*          = 'R': Rowwise */
-
-  /*  M       (input) INTEGER */
-  /*          The number of rows of the matrix C. */
-
-  /*  N       (input) INTEGER */
-  /*          The number of columns of the matrix C. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the matrix T (= the number of elementary */
-  /*          reflectors whose product defines the block reflector). */
-
-  /*  V       (input) COMPLEX*16 array, dimension */
-  /*                                (LDV,K) if STOREV = 'C' */
-  /*                                (LDV,M) if STOREV = 'R' and SIDE = 'L' */
-  /*                                (LDV,N) if STOREV = 'R' and SIDE = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M); */
-  /*          if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N); */
-  /*          if STOREV = 'R', LDV >= K. */
-
-  /*  T       (input) COMPLEX*16 array, dimension (LDT,K) */
-  /*          The triangular K-by-K matrix T in the representation of the */
-  /*          block reflector. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  C       (input/output) COMPLEX*16 array, dimension (LDC,N) */
-  /*          On entry, the M-by-N matrix C. */
-  /*          On exit, C is overwritten by H*C or H'*C or C*H or C*H'. */
-
-  /*  LDC     (input) INTEGER */
-  /*          The leading dimension of the array C. LDC >= max(1,M). */
-
-  /*  WORK    (workspace) COMPLEX*16 array, dimension (LDWORK,K) */
-
-  /*  LDWORK  (input) INTEGER */
-  /*          The leading dimension of the array WORK. */
-  /*          If SIDE = 'L', LDWORK >= max(1,N); */
-  /*          if SIDE = 'R', LDWORK >= max(1,M). */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-  c_dim1 = *ldc;
-  c_offset = 1 + c_dim1;
-  c__ -= c_offset;
-  work_dim1 = *ldwork;
-  work_offset = 1 + work_dim1;
-  work -= work_offset;
-
-  /* Function Body */
-  if (*m <= 0 || *n <= 0) {
-    return;
-  }
-
-  if (lsame_(trans, "N")) {
-    *(unsigned char *)transt = 'C';
-  } else {
-    *(unsigned char *)transt = 'N';
-  }
-
-  if (lsame_(storev, "C")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1 )    (first K rows) */
-      /*                     ( V2 ) */
-      /*           where  V1  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          zlacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L10: */
-        }
-
-        /*              W := W * V1 */
-
-        ztrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2 */
-
-          i__1 = lastv - *k;
-          zgemm_("Conjugate transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[*k + 1 + c_dim1], ldc,
-                 &v[*k + 1 + v_dim1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ztrmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (*m > *k) {
-          /*                 C2 := C2 - V2 * W' */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("No transpose", "Conjugate transpose", &i__1, &lastc, k, &z__1, &v[*k + 1 + v_dim1], ldv,
-                 &work[work_offset], ldwork, &c_b1, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        ztrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = j + i__ * c_dim1;
-            i__4 = j + i__ * c_dim1;
-            d_cnjg(&z__2, &work[i__ + j * work_dim1]);
-            z__1.r = c__[i__4].r - z__2.r, z__1.i = c__[i__4].i - z__2.i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L20: */
-          }
-          /* L30: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L40: */
-        }
-
-        /*              W := W * V1 */
-
-        ztrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2 */
-
-          i__1 = lastv - *k;
-          zgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[*k + 1 + v_dim1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ztrmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2' */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("No transpose", "Conjugate transpose", &lastc, &i__1, k, &z__1, &work[work_offset], ldwork,
-                 &v[*k + 1 + v_dim1], ldv, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1' */
-
-        ztrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + j * c_dim1;
-            i__4 = i__ + j * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            z__1.r = c__[i__4].r - work[i__5].r, z__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L50: */
-          }
-          /* L60: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1 ) */
-      /*                     ( V2 )    (last K rows) */
-      /*           where  V2  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlr_(m, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V  =  (C1'*V1 + C2'*V2)  (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          zlacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L70: */
-        }
-
-        /*              W := W * V2 */
-
-        ztrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1 */
-
-          i__1 = lastv - *k;
-          zgemm_("Conjugate transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset], ldv,
-                 &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ztrmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1 * W' */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("No transpose", "Conjugate transpose", &i__1, &lastc, k, &z__1, &v[v_offset], ldv, &work[work_offset],
-                 ldwork, &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        ztrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = lastv - *k + j + i__ * c_dim1;
-            i__4 = lastv - *k + j + i__ * c_dim1;
-            d_cnjg(&z__2, &work[i__ + j * work_dim1]);
-            z__1.r = c__[i__4].r - z__2.r, z__1.i = c__[i__4].i - z__2.i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L80: */
-          }
-          /* L90: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlr_(n, k, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V  =  (C1*V1 + C2*V2)  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[(lastv - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L100: */
-        }
-
-        /*              W := W * V2 */
-
-        ztrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1 */
-
-          i__1 = lastv - *k;
-          zgemm_("No transpose", "No transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset], ldv, &c_b1,
-                 &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ztrmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1' */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("No transpose", "Conjugate transpose", &lastc, &i__1, k, &z__1, &work[work_offset], ldwork,
-                 &v[v_offset], ldv, &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2' */
-
-        ztrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[lastv - *k + 1 + v_dim1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + (lastv - *k + j) * c_dim1;
-            i__4 = i__ + (lastv - *k + j) * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            z__1.r = c__[i__4].r - work[i__5].r, z__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L110: */
-          }
-          /* L120: */
-        }
-      }
-    }
-
-  } else if (lsame_(storev, "R")) {
-    if (lsame_(direct, "F")) {
-      /*           Let  V =  ( V1  V2 )    (V1: first K columns) */
-      /*           where  V1  is unit upper triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C1' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          zlacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L130: */
-        }
-
-        /*              W := W * V1' */
-
-        ztrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2'*V2' */
-
-          i__1 = lastv - *k;
-          zgemm_("Conjugate transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[*k + 1 + c_dim1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ztrmm_("Right", "Upper", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - V2' * W' */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("Conjugate transpose", "Conjugate transpose", &i__1, &lastc, k, &z__1, &v[(*k + 1) * v_dim1 + 1], ldv,
-                 &work[work_offset], ldwork, &c_b1, &c__[*k + 1 + c_dim1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        ztrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = j + i__ * c_dim1;
-            i__4 = j + i__ * c_dim1;
-            d_cnjg(&z__2, &work[i__ + j * work_dim1]);
-            z__1.r = c__[i__4].r - z__2.r, z__1.i = c__[i__4].i - z__2.i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L140: */
-          }
-          /* L150: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C1 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[j * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L160: */
-        }
-
-        /*              W := W * V1' */
-
-        ztrmm_("Right", "Upper", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C2 * V2' */
-
-          i__1 = lastv - *k;
-          zgemm_("No transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ztrmm_("Right", "Upper", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C2 := C2 - W * V2 */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("No transpose", "No transpose", &lastc, &i__1, k, &z__1, &work[work_offset], ldwork,
-                 &v[(*k + 1) * v_dim1 + 1], ldv, &c_b1, &c__[(*k + 1) * c_dim1 + 1], ldc);
-        }
-
-        /*              W := W * V1 */
-
-        ztrmm_("Right", "Upper", "No transpose", "Unit", &lastc, k, &c_b1, &v[v_offset], ldv, &work[work_offset],
-               ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + j * c_dim1;
-            i__4 = i__ + j * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            z__1.r = c__[i__4].r - work[i__5].r, z__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L170: */
-          }
-          /* L180: */
-        }
-      }
-
-    } else {
-      /*           Let  V =  ( V1  V2 )    (V2: last K columns) */
-      /*           where  V2  is unit lower triangular. */
-
-      if (lsame_(side, "L")) {
-        /*              Form  H * C  or  H' * C  where  C = ( C1 ) */
-        /*                                                  ( C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlc_(k, m, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlc_(&lastv, n, &c__[c_offset], ldc);
-
-        /*              W := C' * V'  =  (C1'*V1' + C2'*V2') (stored in WORK) */
-
-        /*              W := C2' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[lastv - *k + j + c_dim1], ldc, &work[j * work_dim1 + 1], &c__1);
-          zlacgv_(&lastc, &work[j * work_dim1 + 1], &c__1);
-          /* L190: */
-        }
-
-        /*              W := W * V2' */
-
-        ztrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1],
-               ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1'*V1' */
-
-          i__1 = lastv - *k;
-          zgemm_("Conjugate transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc,
-                 &v[v_offset], ldv, &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T'  or  W * T */
-
-        ztrmm_("Right", "Lower", transt, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - V' * W' */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - V1' * W' */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("Conjugate transpose", "Conjugate transpose", &i__1, &lastc, k, &z__1, &v[v_offset], ldv,
-                 &work[work_offset], ldwork, &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        ztrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C2 := C2 - W' */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = lastv - *k + j + i__ * c_dim1;
-            i__4 = lastv - *k + j + i__ * c_dim1;
-            d_cnjg(&z__2, &work[i__ + j * work_dim1]);
-            z__1.r = c__[i__4].r - z__2.r, z__1.i = c__[i__4].i - z__2.i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L200: */
-          }
-          /* L210: */
-        }
-
-      } else if (lsame_(side, "R")) {
-        /*              Form  C * H  or  C * H'  where  C = ( C1  C2 ) */
-
-        /* Computing MAX */
-        i__1 = *k, i__2 = ilazlc_(k, n, &v[v_offset], ldv);
-        lastv = max(i__1, i__2);
-        lastc = ilazlr_(m, &lastv, &c__[c_offset], ldc);
-
-        /*              W := C * V'  =  (C1*V1' + C2*V2')  (stored in WORK) */
-
-        /*              W := C2 */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          zcopy_(&lastc, &c__[(lastv - *k + j) * c_dim1 + 1], &c__1, &work[j * work_dim1 + 1], &c__1);
-          /* L220: */
-        }
-
-        /*              W := W * V2' */
-
-        ztrmm_("Right", "Lower", "Conjugate transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1],
-               ldv, &work[work_offset], ldwork);
-        if (lastv > *k) {
-          /*                 W := W + C1 * V1' */
-
-          i__1 = lastv - *k;
-          zgemm_("No transpose", "Conjugate transpose", &lastc, k, &i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset], ldv,
-                 &c_b1, &work[work_offset], ldwork);
-        }
-
-        /*              W := W * T  or  W * T' */
-
-        ztrmm_("Right", "Lower", trans, "Non-unit", &lastc, k, &c_b1, &t[t_offset], ldt, &work[work_offset], ldwork);
-
-        /*              C := C - W * V */
-
-        if (lastv > *k) {
-          /*                 C1 := C1 - W * V1 */
-
-          i__1 = lastv - *k;
-          z__1.r = -1., z__1.i = -0.;
-          zgemm_("No transpose", "No transpose", &lastc, &i__1, k, &z__1, &work[work_offset], ldwork, &v[v_offset], ldv,
-                 &c_b1, &c__[c_offset], ldc);
-        }
-
-        /*              W := W * V2 */
-
-        ztrmm_("Right", "Lower", "No transpose", "Unit", &lastc, k, &c_b1, &v[(lastv - *k + 1) * v_dim1 + 1], ldv,
-               &work[work_offset], ldwork);
-
-        /*              C1 := C1 - W */
-
-        i__1 = *k;
-        for (j = 1; j <= i__1; ++j) {
-          i__2 = lastc;
-          for (i__ = 1; i__ <= i__2; ++i__) {
-            i__3 = i__ + (lastv - *k + j) * c_dim1;
-            i__4 = i__ + (lastv - *k + j) * c_dim1;
-            i__5 = i__ + j * work_dim1;
-            z__1.r = c__[i__4].r - work[i__5].r, z__1.i = c__[i__4].i - work[i__5].i;
-            c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
-            /* L230: */
-          }
-          /* L240: */
-        }
-      }
-    }
-  }
-
-  /*     End of ZLARFB */
-
-} /* zlarfb_ */
diff --git a/lapack/zlarfg.c b/lapack/zlarfg.c
deleted file mode 100644
index ba5a1f9..0000000
--- a/lapack/zlarfg.c
+++ /dev/null
@@ -1,183 +0,0 @@
-/* zlarfg.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-static inline doublereal d_sign(doublereal *a, doublereal *b) {
-  doublereal x;
-  x = (*a >= 0 ? *a : -*a);
-  return (*b >= 0 ? x : -x);
-}
-
-/* Table of constant values */
-
-static doublecomplex c_b5 = {1., 0.};
-
-/* Subroutine */ void zlarfg_(integer *n, doublecomplex *alpha, doublecomplex *x, integer *incx, doublecomplex *tau) {
-  /* System generated locals */
-  integer i__1;
-  doublereal d__1, d__2;
-  doublecomplex z__1, z__2;
-
-  /* Local variables */
-  integer j, knt;
-  doublereal beta, alphi, alphr;
-  extern /* Subroutine */ void zscal_(integer *, doublecomplex *, doublecomplex *, integer *);
-  doublereal xnorm;
-  extern doublereal dlapy3_(doublereal *, doublereal *, doublereal *), dznrm2_(integer *, doublecomplex *, integer *),
-      dlamch_(char *);
-  doublereal safmin;
-  extern /* Subroutine */ void zdscal_(integer *, doublereal *, doublecomplex *, integer *);
-  doublereal rsafmn;
-  extern /* Double Complex */ void zladiv_(doublecomplex *, doublecomplex *, doublecomplex *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZLARFG generates a complex elementary reflector H of order n, such */
-  /*  that */
-
-  /*        H' * ( alpha ) = ( beta ),   H' * H = I. */
-  /*             (   x   )   (   0  ) */
-
-  /*  where alpha and beta are scalars, with beta real, and x is an */
-  /*  (n-1)-element complex vector. H is represented in the form */
-
-  /*        H = I - tau * ( 1 ) * ( 1 v' ) , */
-  /*                      ( v ) */
-
-  /*  where tau is a complex scalar and v is a complex (n-1)-element */
-  /*  vector. Note that H is not hermitian. */
-
-  /*  If the elements of x are all zero and alpha is real, then tau = 0 */
-  /*  and H is taken to be the unit matrix. */
-
-  /*  Otherwise  1 <= real(tau) <= 2  and  abs(tau-1) <= 1 . */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the elementary reflector. */
-
-  /*  ALPHA   (input/output) COMPLEX*16 */
-  /*          On entry, the value alpha. */
-  /*          On exit, it is overwritten with the value beta. */
-
-  /*  X       (input/output) COMPLEX*16 array, dimension */
-  /*                         (1+(N-2)*abs(INCX)) */
-  /*          On entry, the vector x. */
-  /*          On exit, it is overwritten with the vector v. */
-
-  /*  INCX    (input) INTEGER */
-  /*          The increment between elements of X. INCX > 0. */
-
-  /*  TAU     (output) COMPLEX*16 */
-  /*          The value tau. */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Intrinsic Functions .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /* Parameter adjustments */
-  --x;
-
-  /* Function Body */
-  if (*n <= 0) {
-    tau->r = 0., tau->i = 0.;
-    return;
-  }
-
-  i__1 = *n - 1;
-  xnorm = dznrm2_(&i__1, &x[1], incx);
-  alphr = alpha->r;
-  alphi = alpha->i;
-
-  if (xnorm == 0. && alphi == 0.) {
-    /*        H  =  I */
-
-    tau->r = 0., tau->i = 0.;
-  } else {
-    /*        general case */
-
-    d__1 = dlapy3_(&alphr, &alphi, &xnorm);
-    beta = -d_sign(&d__1, &alphr);
-    safmin = dlamch_("S") / dlamch_("E");
-    rsafmn = 1. / safmin;
-
-    knt = 0;
-    if (abs(beta) < safmin) {
-      /*           XNORM, BETA may be inaccurate; scale X and recompute them */
-
-    L10:
-      ++knt;
-      i__1 = *n - 1;
-      zdscal_(&i__1, &rsafmn, &x[1], incx);
-      beta *= rsafmn;
-      alphi *= rsafmn;
-      alphr *= rsafmn;
-      if (abs(beta) < safmin) {
-        goto L10;
-      }
-
-      /*           New BETA is at most 1, at least SAFMIN */
-
-      i__1 = *n - 1;
-      xnorm = dznrm2_(&i__1, &x[1], incx);
-      z__1.r = alphr, z__1.i = alphi;
-      alpha->r = z__1.r, alpha->i = z__1.i;
-      d__1 = dlapy3_(&alphr, &alphi, &xnorm);
-      beta = -d_sign(&d__1, &alphr);
-    }
-    d__1 = (beta - alphr) / beta;
-    d__2 = -alphi / beta;
-    z__1.r = d__1, z__1.i = d__2;
-    tau->r = z__1.r, tau->i = z__1.i;
-    z__2.r = alpha->r - beta, z__2.i = alpha->i;
-    zladiv_(&z__1, &c_b5, &z__2);
-    alpha->r = z__1.r, alpha->i = z__1.i;
-    i__1 = *n - 1;
-    zscal_(&i__1, alpha, &x[1], incx);
-
-    /*        If ALPHA is subnormal, it may lose relative accuracy */
-
-    i__1 = knt;
-    for (j = 1; j <= i__1; ++j) {
-      beta *= safmin;
-      /* L20: */
-    }
-    alpha->r = beta, alpha->i = 0.;
-  }
-
-  /*     End of ZLARFG */
-
-} /* zlarfg_ */
diff --git a/lapack/zlarft.c b/lapack/zlarft.c
deleted file mode 100644
index 3b40c28..0000000
--- a/lapack/zlarft.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/* zlarft.f -- translated by f2c (version 20061008).
-   You must link the resulting object file with libf2c:
-        on Microsoft Windows system, link with libf2c.lib;
-        on Linux or Unix systems, link with .../path/to/libf2c.a -lm
-        or, if you install libf2c.a in a standard place, with -lf2c -lm
-        -- in that order, at the end of the command line, as in
-                cc *.o -lf2c -lm
-        Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
-
-                http://www.netlib.org/f2c/libf2c.zip
-*/
-
-#include "blaswrap.h"
-#include "lapack_datatypes.h"
-
-/* Table of constant values */
-
-static doublecomplex c_b2 = {0., 0.};
-static integer c__1 = 1;
-
-/* Subroutine */ void zlarft_(char *direct, char *storev, integer *n, integer *k, doublecomplex *v, integer *ldv,
-                              doublecomplex *tau, doublecomplex *t, integer *ldt) {
-  /* System generated locals */
-  integer t_dim1, t_offset, v_dim1, v_offset, i__1, i__2, i__3, i__4;
-  doublecomplex z__1;
-
-  /* Local variables */
-  integer i__, j, prevlastv;
-  doublecomplex vii;
-  extern logical lsame_(char *, char *);
-  extern /* Subroutine */ void zgemv_(const char *, const integer *, const integer *, const doublecomplex *,
-                                      const doublecomplex *, const integer *, const doublecomplex *, const integer *,
-                                      const doublecomplex *, doublecomplex *, const integer *);
-  integer lastv;
-  extern /* Subroutine */ void ztrmv_(const char *, const char *, const char *, const integer *, const doublecomplex *,
-                                      const integer *, doublecomplex *, const integer *),
-      zlacgv_(integer *, doublecomplex *, integer *);
-
-  /*  -- LAPACK auxiliary routine (version 3.2) -- */
-  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
-  /*     November 2006 */
-
-  /*     .. Scalar Arguments .. */
-  /*     .. */
-  /*     .. Array Arguments .. */
-  /*     .. */
-
-  /*  Purpose */
-  /*  ======= */
-
-  /*  ZLARFT forms the triangular factor T of a complex block reflector H */
-  /*  of order n, which is defined as a product of k elementary reflectors. */
-
-  /*  If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; */
-
-  /*  If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. */
-
-  /*  If STOREV = 'C', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th column of the array V, and */
-
-  /*     H  =  I - V * T * V' */
-
-  /*  If STOREV = 'R', the vector which defines the elementary reflector */
-  /*  H(i) is stored in the i-th row of the array V, and */
-
-  /*     H  =  I - V' * T * V */
-
-  /*  Arguments */
-  /*  ========= */
-
-  /*  DIRECT  (input) CHARACTER*1 */
-  /*          Specifies the order in which the elementary reflectors are */
-  /*          multiplied to form the block reflector: */
-  /*          = 'F': H = H(1) H(2) . . . H(k) (Forward) */
-  /*          = 'B': H = H(k) . . . H(2) H(1) (Backward) */
-
-  /*  STOREV  (input) CHARACTER*1 */
-  /*          Specifies how the vectors which define the elementary */
-  /*          reflectors are stored (see also Further Details): */
-  /*          = 'C': columnwise */
-  /*          = 'R': rowwise */
-
-  /*  N       (input) INTEGER */
-  /*          The order of the block reflector H. N >= 0. */
-
-  /*  K       (input) INTEGER */
-  /*          The order of the triangular factor T (= the number of */
-  /*          elementary reflectors). K >= 1. */
-
-  /*  V       (input/output) COMPLEX*16 array, dimension */
-  /*                               (LDV,K) if STOREV = 'C' */
-  /*                               (LDV,N) if STOREV = 'R' */
-  /*          The matrix V. See further details. */
-
-  /*  LDV     (input) INTEGER */
-  /*          The leading dimension of the array V. */
-  /*          If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K. */
-
-  /*  TAU     (input) COMPLEX*16 array, dimension (K) */
-  /*          TAU(i) must contain the scalar factor of the elementary */
-  /*          reflector H(i). */
-
-  /*  T       (output) COMPLEX*16 array, dimension (LDT,K) */
-  /*          The k by k triangular factor T of the block reflector. */
-  /*          If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is */
-  /*          lower triangular. The rest of the array is not used. */
-
-  /*  LDT     (input) INTEGER */
-  /*          The leading dimension of the array T. LDT >= K. */
-
-  /*  Further Details */
-  /*  =============== */
-
-  /*  The shape of the matrix V and the storage of the vectors which define */
-  /*  the H(i) is best illustrated by the following example with n = 5 and */
-  /*  k = 3. The elements equal to 1 are not stored; the corresponding */
-  /*  array elements are modified but restored on exit. The rest of the */
-  /*  array is not used. */
-
-  /*  DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R': */
-
-  /*               V = (  1       )                 V = (  1 v1 v1 v1 v1 ) */
-  /*                   ( v1  1    )                     (     1 v2 v2 v2 ) */
-  /*                   ( v1 v2  1 )                     (        1 v3 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-  /*                   ( v1 v2 v3 ) */
-
-  /*  DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R': */
-
-  /*               V = ( v1 v2 v3 )                 V = ( v1 v1  1       ) */
-  /*                   ( v1 v2 v3 )                     ( v2 v2 v2  1    ) */
-  /*                   (  1 v2 v3 )                     ( v3 v3 v3 v3  1 ) */
-  /*                   (     1 v3 ) */
-  /*                   (        1 ) */
-
-  /*  ===================================================================== */
-
-  /*     .. Parameters .. */
-  /*     .. */
-  /*     .. Local Scalars .. */
-  /*     .. */
-  /*     .. External Subroutines .. */
-  /*     .. */
-  /*     .. External Functions .. */
-  /*     .. */
-  /*     .. Executable Statements .. */
-
-  /*     Quick return if possible */
-
-  /* Parameter adjustments */
-  v_dim1 = *ldv;
-  v_offset = 1 + v_dim1;
-  v -= v_offset;
-  --tau;
-  t_dim1 = *ldt;
-  t_offset = 1 + t_dim1;
-  t -= t_offset;
-
-  /* Function Body */
-  if (*n == 0) {
-    return;
-  }
-
-  if (lsame_(direct, "F")) {
-    prevlastv = *n;
-    i__1 = *k;
-    for (i__ = 1; i__ <= i__1; ++i__) {
-      prevlastv = max(prevlastv, i__);
-      i__2 = i__;
-      if (tau[i__2].r == 0. && tau[i__2].i == 0.) {
-        /*              H(i)  =  I */
-
-        i__2 = i__;
-        for (j = 1; j <= i__2; ++j) {
-          i__3 = j + i__ * t_dim1;
-          t[i__3].r = 0., t[i__3].i = 0.;
-          /* L10: */
-        }
-      } else {
-        /*              general case */
-
-        i__2 = i__ + i__ * v_dim1;
-        vii.r = v[i__2].r, vii.i = v[i__2].i;
-        i__2 = i__ + i__ * v_dim1;
-        v[i__2].r = 1., v[i__2].i = 0.;
-        if (lsame_(storev, "C")) {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            i__3 = lastv + i__ * v_dim1;
-            if (v[i__3].r != 0. || v[i__3].i != 0.) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)' * V(i:j,i) */
-
-          i__2 = j - i__ + 1;
-          i__3 = i__ - 1;
-          i__4 = i__;
-          z__1.r = -tau[i__4].r, z__1.i = -tau[i__4].i;
-          zgemv_("Conjugate transpose", &i__2, &i__3, &z__1, &v[i__ + v_dim1], ldv, &v[i__ + i__ * v_dim1], &c__1,
-                 &c_b2, &t[i__ * t_dim1 + 1], &c__1);
-        } else {
-          /*                 Skip any trailing zeros. */
-          i__2 = i__ + 1;
-          for (lastv = *n; lastv >= i__2; --lastv) {
-            i__3 = i__ + lastv * v_dim1;
-            if (v[i__3].r != 0. || v[i__3].i != 0.) {
-              break;
-            }
-          }
-          j = min(lastv, prevlastv);
-
-          /*                 T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)' */
-
-          if (i__ < j) {
-            i__2 = j - i__;
-            zlacgv_(&i__2, &v[i__ + (i__ + 1) * v_dim1], ldv);
-          }
-          i__2 = i__ - 1;
-          i__3 = j - i__ + 1;
-          i__4 = i__;
-          z__1.r = -tau[i__4].r, z__1.i = -tau[i__4].i;
-          zgemv_("No transpose", &i__2, &i__3, &z__1, &v[i__ * v_dim1 + 1], ldv, &v[i__ + i__ * v_dim1], ldv, &c_b2,
-                 &t[i__ * t_dim1 + 1], &c__1);
-          if (i__ < j) {
-            i__2 = j - i__;
-            zlacgv_(&i__2, &v[i__ + (i__ + 1) * v_dim1], ldv);
-          }
-        }
-        i__2 = i__ + i__ * v_dim1;
-        v[i__2].r = vii.r, v[i__2].i = vii.i;
-
-        /*              T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i) */
-
-        i__2 = i__ - 1;
-        ztrmv_("Upper", "No transpose", "Non-unit", &i__2, &t[t_offset], ldt, &t[i__ * t_dim1 + 1], &c__1);
-        i__2 = i__ + i__ * t_dim1;
-        i__3 = i__;
-        t[i__2].r = tau[i__3].r, t[i__2].i = tau[i__3].i;
-        if (i__ > 1) {
-          prevlastv = max(prevlastv, lastv);
-        } else {
-          prevlastv = lastv;
-        }
-      }
-      /* L20: */
-    }
-  } else {
-    prevlastv = 1;
-    for (i__ = *k; i__ >= 1; --i__) {
-      i__1 = i__;
-      if (tau[i__1].r == 0. && tau[i__1].i == 0.) {
-        /*              H(i)  =  I */
-
-        i__1 = *k;
-        for (j = i__; j <= i__1; ++j) {
-          i__2 = j + i__ * t_dim1;
-          t[i__2].r = 0., t[i__2].i = 0.;
-          /* L30: */
-        }
-      } else {
-        /*              general case */
-
-        if (i__ < *k) {
-          if (lsame_(storev, "C")) {
-            i__1 = *n - *k + i__ + i__ * v_dim1;
-            vii.r = v[i__1].r, vii.i = v[i__1].i;
-            i__1 = *n - *k + i__ + i__ * v_dim1;
-            v[i__1].r = 1., v[i__1].i = 0.;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              i__2 = lastv + i__ * v_dim1;
-              if (v[i__2].r != 0. || v[i__2].i != 0.) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(j:n-k+i,i+1:k)' * V(j:n-k+i,i) */
-
-            i__1 = *n - *k + i__ - j + 1;
-            i__2 = *k - i__;
-            i__3 = i__;
-            z__1.r = -tau[i__3].r, z__1.i = -tau[i__3].i;
-            zgemv_("Conjugate transpose", &i__1, &i__2, &z__1, &v[j + (i__ + 1) * v_dim1], ldv, &v[j + i__ * v_dim1],
-                   &c__1, &c_b2, &t[i__ + 1 + i__ * t_dim1], &c__1);
-            i__1 = *n - *k + i__ + i__ * v_dim1;
-            v[i__1].r = vii.r, v[i__1].i = vii.i;
-          } else {
-            i__1 = i__ + (*n - *k + i__) * v_dim1;
-            vii.r = v[i__1].r, vii.i = v[i__1].i;
-            i__1 = i__ + (*n - *k + i__) * v_dim1;
-            v[i__1].r = 1., v[i__1].i = 0.;
-            /*                    Skip any leading zeros. */
-            i__1 = i__ - 1;
-            for (lastv = 1; lastv <= i__1; ++lastv) {
-              i__2 = i__ + lastv * v_dim1;
-              if (v[i__2].r != 0. || v[i__2].i != 0.) {
-                break;
-              }
-            }
-            j = max(lastv, prevlastv);
-
-            /*                    T(i+1:k,i) := */
-            /*                            - tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)' */
-
-            i__1 = *n - *k + i__ - 1 - j + 1;
-            zlacgv_(&i__1, &v[i__ + j * v_dim1], ldv);
-            i__1 = *k - i__;
-            i__2 = *n - *k + i__ - j + 1;
-            i__3 = i__;
-            z__1.r = -tau[i__3].r, z__1.i = -tau[i__3].i;
-            zgemv_("No transpose", &i__1, &i__2, &z__1, &v[i__ + 1 + j * v_dim1], ldv, &v[i__ + j * v_dim1], ldv, &c_b2,
-                   &t[i__ + 1 + i__ * t_dim1], &c__1);
-            i__1 = *n - *k + i__ - 1 - j + 1;
-            zlacgv_(&i__1, &v[i__ + j * v_dim1], ldv);
-            i__1 = i__ + (*n - *k + i__) * v_dim1;
-            v[i__1].r = vii.r, v[i__1].i = vii.i;
-          }
-
-          /*                 T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i) */
-
-          i__1 = *k - i__;
-          ztrmv_("Lower", "No transpose", "Non-unit", &i__1, &t[i__ + 1 + (i__ + 1) * t_dim1], ldt,
-                 &t[i__ + 1 + i__ * t_dim1], &c__1);
-          if (i__ > 1) {
-            prevlastv = min(prevlastv, lastv);
-          } else {
-            prevlastv = lastv;
-          }
-        }
-        i__1 = i__ + i__ * t_dim1;
-        i__2 = i__;
-        t[i__1].r = tau[i__2].r, t[i__1].i = tau[i__2].i;
-      }
-      /* L40: */
-    }
-  }
-
-  /*     End of ZLARFT */
-
-} /* zlarft_ */
diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt
index 0d9a631..833a2ae 100644
--- a/scripts/CMakeLists.txt
+++ b/scripts/CMakeLists.txt
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 get_property(EIGEN_TESTS_LIST GLOBAL PROPERTY EIGEN_TESTS_LIST)
 configure_file(buildtests.in ${CMAKE_BINARY_DIR}/buildtests.sh @ONLY)
 
diff --git a/scripts/add_spdx_headers.py b/scripts/add_spdx_headers.py
new file mode 100755
index 0000000..47b3d33
--- /dev/null
+++ b/scripts/add_spdx_headers.py
@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+# This file is part of Eigen, a lightweight C++ template library
+# for linear algebra.
+#
+# Copyright (C) 2026 The Eigen Authors
+#
+# This Source Code Form is subject to the terms of the Mozilla
+# Public License v. 2.0. If a copy of the MPL was not distributed
+# with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+# REUSE-IgnoreStart
+"""
+Insert per-file SPDX license tags across the Eigen tree.
+
+Idempotent: files already containing an SPDX-License-Identifier tag are left
+untouched. Re-running after a clean run produces no changes.
+
+The license id assigned to each file is determined by `classify(path)`:
+- LAPACKE/BLAS bridges with Intel copyright    -> BSD-3-Clause
+- MORSE-derived cmake/Find*.cmake modules      -> BSD-3-Clause
+- Reference-BLAS Fortran tests blas/testing/*.f -> BSD-3-Clause
+- LevenbergMarquardt MINPACK-derived headers   -> MPL-2.0 AND LicenseRef-MINPACK
+- Everything else under repo                    -> MPL-2.0
+
+The comment style is determined by the file extension:
+- C / C++ / CUDA / Inc / Fortran-fixed-form ('//', '#', '*' etc.)
+
+Files explicitly excluded from inline SPDX (handled instead by REUSE.toml):
+- LICENSES/, COPYING.*, LICENSE                                (license texts)
+- *.dox, *.in, *.md, *.dat, *.png, README*, INSTALL,           (assets/templates)
+  *.def, *.natvis, *.css, *.xsl, *.preamble, *.traits, *.krazy
+- .git*, .clang*, .coderabbit*, .gitlab/                       (config dotfiles)
+- failtest/*.cpp                                               (trivial stubs)
+- signature_of_eigen3_matrix_library                           (sentinel file)
+"""
+# REUSE-IgnoreEnd
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Iterable
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+SPDX_RE = re.compile(r"SPDX-License-Identifier\s*:")
+# Match REUSE's own copyright detection (case-sensitive `Copyright`); lowercase
+# `copyright` lines (typo in some headers) won't be recognised, so we'll still
+# inject `SPDX-FileCopyrightText` for those files.
+COPYRIGHT_RE = re.compile(r"Copyright\b")
+
+
+# ---------------------------------------------------------------------------
+# Path classification
+# ---------------------------------------------------------------------------
+
+# Files containing an Intel BSD-3-Clause copyright header (LAPACKE/BLAS bridges).
+# Match by content rather than path so this stays correct as files are added.
+INTEL_BSD_MARKER = b"Copyright (c) 2011, Intel Corporation"
+INTEL_BSD_MARKER_2010 = b"Copyright (c) 2010, Intel Corp"
+
+# MORSE-derived cmake modules (Univ. of Tennessee 2009-2014).
+MORSE_MARKER = b"@copyright (c) 2009-2014 The University of Tennessee"
+
+# Header marker for the LevenbergMarquardt MINPACK-derived files.
+MINPACK_MARKER = b"Minpack license"
+
+# Reference-BLAS / LAPACK Fortran (Univ. of Tennessee/Berkeley/Colorado Denver).
+REFBLAS_MARKERS = (
+    b"Reference BLAS is a software package",
+    b"LAPACK is a software package provided by Univ. of Tennessee",
+)
+
+# Apache-2.0 — TensorFlow-derived BFloat16, Codeplay FindComputeCpp.cmake.
+APACHE_MARKER = b"Licensed under the Apache License"
+
+
+def in_failtest(rel: Path) -> bool:
+    return rel.parts and rel.parts[0] == "failtest"
+
+
+# Bulk-mapped via REUSE.toml — never insert inline SPDX into these.
+SKIP_BY_NAME = {
+    "CHANGELOG.md",
+    "INSTALL",
+    "README.md",
+    "signature_of_eigen3_matrix_library",
+    "CLAUDE.md",
+}
+
+SKIP_BY_SUFFIX = {
+    ".dox",
+    ".in",
+    ".dat",
+    ".png",
+    ".svg",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".md",
+    ".txt",        # README.txt, *.txt config — handled by REUSE.toml
+    ".def",        # blas/eigen_blas.def, lapack/eigen_lapack*.def
+    ".natvis",
+    ".css",
+    ".xsl",
+    ".preamble",
+    ".traits",
+    ".krazy",
+    ".yaml",       # .coderabbit.yaml — REUSE.toml
+    ".entry",      # doc/examples/make_circulant.cpp.entry / .evaluator / ...
+    ".evaluator",
+    ".expression",
+    ".main",
+}
+
+# Top-level / specially-handled excluded paths (relative to repo root).
+SKIP_PATHS = {
+    ".clang-format",
+    ".clang-tidy",
+    ".coderabbit.yaml",
+    ".git-blame-ignore-revs",
+    ".gitattributes",
+    ".gitignore",
+    "LICENSE",
+    "REUSE.toml",
+}
+
+
+def is_skipped(rel: Path) -> bool:
+    name = rel.name
+    posix = rel.as_posix()
+    if posix in SKIP_PATHS:
+        return True
+    if posix.startswith("LICENSES/") or posix.startswith("COPYING"):
+        return True
+    if posix.startswith(".gitlab/") or posix.startswith(".git/"):
+        return True
+    if in_failtest(rel) and rel.suffix == ".cpp":
+        return True
+    # Recognise CMakeLists.txt by name BEFORE the .txt suffix-skip below.
+    if name == "CMakeLists.txt":
+        return False
+    if name in SKIP_BY_NAME:
+        return True
+    if rel.suffix in SKIP_BY_SUFFIX:
+        return True
+    return False
+
+
+def classify(rel: Path, content: bytes) -> str:
+    """Return the SPDX-License-Identifier expression for a file."""
+    if INTEL_BSD_MARKER in content or INTEL_BSD_MARKER_2010 in content:
+        return "BSD-3-Clause"
+    if MORSE_MARKER in content:
+        return "BSD-3-Clause"
+    if MINPACK_MARKER in content:
+        return "MPL-2.0 AND LicenseRef-MINPACK"
+    if any(m in content for m in REFBLAS_MARKERS):
+        return "BSD-3-Clause"
+    if APACHE_MARKER in content:
+        return "Apache-2.0"
+    return "MPL-2.0"
+
+
+# ---------------------------------------------------------------------------
+# Comment-style dispatch
+# ---------------------------------------------------------------------------
+
+# (suffix -> comment prefix). Files without a known suffix are handled by name.
+SLASH_LANGUAGES = {".h", ".hh", ".cpp", ".cc", ".c", ".cu", ".inc", ".js"}
+HASH_LANGUAGES = {".cmake", ".sh", ".py", ".ps1", ".yml", ".cfg"}
+FORTRAN_LANGUAGES = {".f", ".F", ".f90"}
+
+
+def is_eigen_umbrella_header(rel: Path) -> bool:
+    """`Eigen/Core`, `contrib/Eigen/Tensor`, etc. — extensionless C++ headers."""
+    parts = rel.parts
+    if rel.suffix:
+        return False
+    if len(parts) >= 2 and parts[0] == "Eigen" and parts[-1][:1].isupper():
+        return len(parts) == 2
+    if (
+        len(parts) >= 3
+        and parts[0] in ("contrib", "unsupported")
+        and parts[1] == "Eigen"
+        and parts[-1][:1].isupper()
+    ):
+        # contrib/Eigen/Tensor (real), unsupported/Eigen/Tensor (legacy shim), ...
+        return True
+    return False
+
+
+def has_shebang(path: Path) -> bool:
+    try:
+        with path.open("rb") as f:
+            return f.read(2) == b"#!"
+    except OSError:
+        return False
+
+
+def comment_prefix_for(rel: Path, full: Path | None = None) -> str | None:
+    if rel.suffix in SLASH_LANGUAGES:
+        return "//"
+    if rel.suffix in HASH_LANGUAGES:
+        return "#"
+    if rel.suffix in FORTRAN_LANGUAGES:
+        return "*>"
+    name = rel.name
+    if name == "CMakeLists.txt":
+        return "#"
+    if is_eigen_umbrella_header(rel):
+        return "//"
+    # Extensionless executable scripts (e.g. scripts/eigen_gen_docs).
+    if not rel.suffix and full is not None and has_shebang(full):
+        return "#"
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Insertion strategy
+# ---------------------------------------------------------------------------
+
+def insert_spdx(
+    path: Path, content: bytes, spdx_id: str, comment: str
+) -> bytes | None:
+    """Return new file bytes with the SPDX line inserted, or None for no-op."""
+    full_text = content.decode("utf-8", errors="replace")
+    if SPDX_RE.search(full_text):
+        return None  # Already tagged.
+
+    head = full_text[:4096]
+    has_copyright = COPYRIGHT_RE.search(head) is not None
+
+    # Match the file's line-ending style (CRLF vs LF) so we don't introduce
+    # mixed endings that clang-format will then "fix".
+    eol = "\r\n" if b"\r\n" in content[:4096] else "\n"
+
+    # REUSE-IgnoreStart
+    spdx_lines = []
+    if not has_copyright:
+        spdx_lines.append(f"{comment} SPDX-FileCopyrightText: The Eigen Authors{eol}")
+    spdx_lines.append(f"{comment} SPDX-License-Identifier: {spdx_id}{eol}")
+    spdx_line = "".join(spdx_lines).encode()
+    # REUSE-IgnoreEnd
+
+    lines = full_text.splitlines(keepends=True)
+
+    # Two header families to consider:
+    #
+    # (a) Existing C-line-comment MPL prose ("// This file is part of Eigen, ...
+    #     // ... obtain one at http://mozilla.org/MPL/2.0/."): append SPDX
+    #     directly after the prose block (last consecutive comment line at
+    #     top-of-file).
+    #
+    # (b) Existing C-block-comment header (Intel "/* Copyright (c) 2011, Intel
+    #     Corporation ... */"): append a comment line right after the closing
+    #     "*/".
+    #
+    # (c) Hash-comment prose (.cmake / .gitlab-ci.yml / etc.): append after the
+    #     last consecutive '#'-comment line at top.
+    #
+    # (d) Fortran '*'-comment prose (Reference BLAS): append a `*>` line after
+    #     the last consecutive '*'-prefixed line at top.
+    #
+    # (e) No header: insert SPDX as the very first line, then a blank line.
+    #
+    # Files starting with `#!shebang` or a `#ifndef` guard — we always insert
+    # the SPDX line above the guard but below any shebang.
+
+    insert_at = 0
+    has_shebang = lines and lines[0].startswith("#!")
+    if has_shebang:
+        insert_at = 1
+
+    # (b) C-block comment opening at index `insert_at`.
+    if insert_at < len(lines) and lines[insert_at].lstrip().startswith("/*"):
+        for i in range(insert_at, len(lines)):
+            if "*/" in lines[i]:
+                insert_at = i + 1
+                # Skip a single blank line after the block, if any.
+                break
+        new_block = spdx_line.decode()
+        # We want SPDX as a // line after the */.
+        return ("".join(lines[:insert_at]) + new_block + "".join(lines[insert_at:])).encode()
+
+    # (a, c, d) Detect a top-of-file run of comment lines and insert after.
+    end_of_block = insert_at
+    if comment == "//":
+        marker_prefixes = ("//",)
+    elif comment == "#":
+        marker_prefixes = ("#",)
+    elif comment == "*>":
+        # Fortran free-form file headers begin with `*` or `*>`.
+        marker_prefixes = ("*",)
+    else:
+        marker_prefixes = (comment,)
+
+    while end_of_block < len(lines):
+        s = lines[end_of_block].lstrip()
+        if any(s.startswith(p) for p in marker_prefixes):
+            end_of_block += 1
+            continue
+        break
+
+    if end_of_block > insert_at:
+        # Append SPDX after the existing prose block.
+        return (
+            "".join(lines[:end_of_block])
+            + spdx_line.decode()
+            + "".join(lines[end_of_block:])
+        ).encode()
+
+    # (e) No header — insert at the top (after shebang if present), and
+    # follow with a single blank line *unless* the file already starts with
+    # one (otherwise clang-format collapses the duplicate).
+    next_is_blank = (
+        insert_at < len(lines) and lines[insert_at].strip() == ""
+    )
+    blank = "" if next_is_blank else eol
+    return (
+        "".join(lines[:insert_at])
+        + spdx_line.decode()
+        + blank
+        + "".join(lines[insert_at:])
+    ).encode()
+
+
+# ---------------------------------------------------------------------------
+# Driver
+# ---------------------------------------------------------------------------
+
+def tracked_files() -> Iterable[Path]:
+    out = subprocess.check_output(
+        ["git", "ls-files"], cwd=REPO_ROOT, text=True
+    )
+    for line in out.splitlines():
+        if line:
+            yield Path(line)
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument(
+        "--check",
+        action="store_true",
+        help="Don't write; exit 1 if any file would change.",
+    )
+    p.add_argument(
+        "--paths",
+        nargs="*",
+        help="Limit to these paths (relative to repo root). Default: all tracked.",
+    )
+    p.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Print every file decision (skip / classify / change).",
+    )
+    args = p.parse_args()
+
+    if args.paths:
+        targets = [Path(p) for p in args.paths]
+    else:
+        targets = list(tracked_files())
+
+    changed = []
+    for rel in targets:
+        if is_skipped(rel):
+            if args.verbose:
+                print(f"[skip-rule] {rel}")
+            continue
+
+        full = REPO_ROOT / rel
+        prefix = comment_prefix_for(rel, full)
+        if prefix is None:
+            if args.verbose:
+                print(f"[skip-ext]  {rel}")
+            continue
+        try:
+            content = full.read_bytes()
+        except (FileNotFoundError, IsADirectoryError):
+            continue
+
+        spdx_id = classify(rel, content)
+        new_content = insert_spdx(rel, content, spdx_id, prefix)
+        if new_content is None:
+            if args.verbose:
+                print(f"[ok]        {rel}  ({spdx_id})")
+            continue
+
+        if args.check:
+            print(f"[would-change] {rel}  ({spdx_id})")
+            changed.append(rel)
+            continue
+
+        full.write_bytes(new_content)
+        print(f"[changed]   {rel}  ({spdx_id})")
+        changed.append(rel)
+
+    if args.check and changed:
+        print(f"\n{len(changed)} file(s) need SPDX headers.", file=sys.stderr)
+        return 1
+    if not args.check:
+        print(f"\nUpdated {len(changed)} file(s).")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/affected_tests.py b/scripts/affected_tests.py
new file mode 100644
index 0000000..65f8490
--- /dev/null
+++ b/scripts/affected_tests.py
@@ -0,0 +1,551 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Select the tests affected by a set of changed files.
+
+Eigen is header-only, so a test is affected by a change exactly when its
+translation unit textually includes the changed file.  This script builds the
+include graph over ``Eigen/``, ``contrib/Eigen/``, ``unsupported/Eigen/`` and the test trees, then
+maps changed paths to the CMake test targets that reach them.
+
+The graph follows every ``#include`` regardless of preprocessor guards, so the
+closure is a strict superset of the true compile dependency and no test is
+dropped because a conditional branch was not taken.  Over-approximation is the
+safe direction here: the point is to widen coverage relative to the fixed smoke
+list, not to minimise work.  Changes that invalidate the mapping itself (CMake,
+CI, the BLAS/LAPACK shims) fall back to the full ``buildtests`` target.
+
+Two output files are written, both consumed by the build and test scripts of each
+platform in the tier -- ``ci/scripts/build.linux.script.sh`` and
+``ci/scripts/test.linux.script.sh``, and their ``.windows.script.ps1``
+counterparts:
+
+  targets.txt       ``NONE``, a newline-separated target list, or the
+                    full-suite list of ``buildtests`` and the targets it does
+                    not aggregate
+  ctest_regex.txt   ``ALL``, ``NONE``, or a CTest ``-R`` regex
+
+The selected names are CMake target names, not CTest test names: a split test
+``foo`` registers ``foo_1``..``foo_N`` as tests but a single ``foo`` target that
+aggregates them, so selecting ``foo`` builds and runs every part.  Targets that
+a given configuration does not register (optional dependencies such as CHOLMOD
+or SYCL) are filtered out by the build scripts, the only place that knows what
+CMake actually configured.
+
+Two registrations do not fit that shape:
+
+* Each compile-failure test under ``failtest/`` compiles its own target from
+  inside CTest, so those are selected as CTest names and never handed to the
+  build job.
+* ``buildtests`` aggregates the ``ei_add_test`` targets only.  A bare
+  ``add_executable`` such as ``bug1213`` is attached to nothing, so the
+  full-suite mode has to name those targets next to ``buildtests``.
+
+A registered target need not compile a ``.cpp``, and need not be named by a
+literal: ``ei_add_test`` takes the source extension from
+``EIGEN_ADD_TEST_FILENAME_EXTENSION``, which the GPU blocks set to ``cu``, and
+the GPU module registers families of tests from ``foreach`` item lists.  Both
+are read out of the CMake source, so a translation unit under a test root with
+no registration the parser can see is an error rather than an assumption.
+Those targets are selected like any other; the build script drops them in
+configurations that did not register them.  ``test/buildsystem/`` is skipped:
+its consumer projects are separate CMake projects configured by their own CI
+job, so an ``add_executable`` there is not a test registration.
+"""
+
+import argparse
+import collections
+import fnmatch
+import os
+import re
+import subprocess
+import sys
+
+# Directories scanned to build the include graph.
+# unsupported/Eigen holds only the legacy umbrella shims now, but they are
+# still headers a change can propagate through, so the graph keeps them.
+SCAN_ROOTS = ("Eigen", "contrib/Eigen", "unsupported/Eigen", "test", "contrib/test", "failtest")
+
+# Directories whose .cpp files are test translation units.
+TEST_ROOTS = ("test", "contrib/test")
+
+# Subtrees of TEST_ROOTS that are not part of this build.  test/buildsystem/
+# holds standalone CMake projects that test:linux:buildsystem configures on
+# their own, so their add_executable() calls register targets no configuration
+# here has, and their sources are not test translation units.
+EXCLUDED_TEST_DIRS = ("test/buildsystem",)
+
+# Compile-failure suite.  ei_add_failtest registers <name>_ok and <name>_ko as
+# CTest tests whose test action is a build of an EXCLUDE_FROM_ALL target.
+FAILTEST_ROOT = "failtest"
+
+# Extensions a registered test translation unit can have.  ".cu" comes from the
+# GPU registrations; see CMAKE_REGISTRATION_RE.
+TEST_SOURCE_SUFFIXES = (".cpp", ".cu")
+
+# Share of the test suite above which an explicit selection is replaced by the
+# full ``buildtests`` target.
+DEFAULT_MAX_FRACTION = 0.85
+
+# Changes matching these patterns cannot affect which tests exist or what they
+# cover, so they select nothing.
+IGNORED_PATTERNS = (
+    ".gitattributes",
+    ".gitignore",
+    ".clang-format",
+    ".clang-tidy",
+    "*.md",
+    "*.dox",
+    "AGENTS.md",
+    "COPYING*",
+    "INSTALL",
+    "README*",
+    "REUSE.toml",
+    ".agents/*",
+    ".gitlab/*",
+    "LICENSES/*",
+    "benchmarks/*",
+    # The CI YAML is orchestration -- rules, tags, artifacts, job names -- and
+    # cannot change which test includes which header, which is the only mapping
+    # this selector maintains.  Ignored rather than merely dropped from
+    # FULL_REBUILD_PATTERNS below: these files are not under SCAN_ROOTS, so an
+    # un-forced path would instead fall through to "not in the include graph"
+    # and force the full suite anyway.
+    "ci/*.gitlab-ci.yml",
+    "ci/CTest2JUnit.xsl",
+    "debug/*",
+    "demos/*",
+    "doc/*",
+    "contrib/benchmarks/*",
+    "contrib/doc/*",
+)
+
+# Changes matching these patterns invalidate the include-graph mapping itself
+# (test registration, split counts, the CI drivers, or shim libraries whose
+# tests are not modelled here), so they force the full test suite.  Checked
+# after IGNORED_PATTERNS, so a benchmark's or the docs' own CMakeLists.txt does
+# not drag in the whole suite.
+FULL_REBUILD_PATTERNS = (
+    "CMakeLists.txt",
+    "*/CMakeLists.txt",
+    "*.cmake",
+    "*.cmake.in",
+    # Keeps forcing: it defines the selector-to-driver contract itself
+    # (EIGEN_CI_BUILD_TARGET_FILE, EIGEN_CI_CTEST_REGEX_FILE).
+    ".gitlab-ci.yml",
+    # ci/ splits: the scripts and the image definitions can change what a build
+    # produces or how a test runs.  The *.gitlab-ci.yml files cannot, and are
+    # ignored above.
+    "ci/scripts/*",
+    "ci/docker/*",
+    "cmake/*",
+    "scripts/*",
+    "blas/*",
+    "lapack/*",
+)
+
+INCLUDE_RE = re.compile(r'^[ \t]*#[ \t]*include[ \t]*[<"]([^>"]+)[>"]', re.MULTILINE)
+# One pass over a test CMakeLists.txt, in source order, because what a
+# registration means depends on the state at that point: the source extension
+# comes from EIGEN_ADD_TEST_FILENAME_EXTENSION, which the CUDA and HIP blocks
+# set to "cu" and unset again, so gpu_basic is test/gpu_basic.cu while its
+# neighbours are .cpp; and a name spelled ${var} resolves against the item list
+# of the enclosing foreach(), which is how the GPU module registers its
+# cusolver_* and cudss_* tests.
+CMAKE_REGISTRATION_RE = re.compile(
+    r"^[ \t]*(?:"
+    r'(?P<scope>set|unset)\([ \t]*EIGEN_ADD_TEST_FILENAME_EXTENSION[ \t]*"?(?P<extension>[A-Za-z_0-9]*)"?'
+    r"|(?:ei_add_test|ei_add_gpu_test)\([ \t]*"
+    r"(?P<test>[A-Za-z_][A-Za-z_0-9]*|\$\{[A-Za-z_][A-Za-z_0-9]*\})"
+    r"|add_executable\([ \t]*(?P<executable>[A-Za-z_][A-Za-z_0-9]*)[ \t\r\n]+(?P<sources>[^)]*)\)"
+    r"|foreach\((?P<loop>[^)]*)\)"
+    r"|(?P<endloop>endforeach)\("
+    r")",
+    re.MULTILINE,
+)
+# A bare CMake identifier, used to recognise a foreach loop variable.
+CMAKE_NAME_RE = re.compile(r"[A-Za-z_][A-Za-z_0-9]*\Z")
+CMAKE_FAILTEST_RE = re.compile(
+    r'^[ \t]*ei_add_failtest\([ \t]*"?([A-Za-z_][A-Za-z_0-9]*)"?',
+    re.MULTILINE,
+)
+
+
+def _matches(path, patterns):
+    return any(fnmatch.fnmatch(path, p) for p in patterns)
+
+
+def _under(path, roots):
+    return any(path.startswith(root + "/") for root in roots)
+
+
+class IncludeGraph:
+    """Textual ``#include`` graph over the scanned source roots."""
+
+    def __init__(self, source_dir):
+        self.source_dir = source_dir
+        self.files = set()
+        self._direct = {}
+        self._by_suffix = {}
+        self._scan()
+
+    def _scan(self):
+        for root in SCAN_ROOTS:
+            abs_root = os.path.join(self.source_dir, root)
+            if not os.path.isdir(abs_root):
+                continue
+            for dirpath, dirnames, filenames in os.walk(abs_root):
+                dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+                for name in filenames:
+                    rel = os.path.relpath(os.path.join(dirpath, name), self.source_dir)
+                    self.files.add(rel)
+        # Index every path suffix so that an include spelled relative to a
+        # directory outside the scanned roots still resolves.  Ambiguous
+        # suffixes are dropped rather than guessed.
+        candidates = {}
+        for rel in self.files:
+            parts = rel.split("/")
+            for i in range(len(parts)):
+                candidates.setdefault("/".join(parts[i:]), []).append(rel)
+        self._by_suffix = {suffix: matches[0]
+                           for suffix, matches in candidates.items() if len(matches) == 1}
+
+    def read_text(self, rel):
+        """Contents of a file in the tree, or ``''`` if it cannot be read."""
+        try:
+            with open(os.path.join(self.source_dir, rel), "r", errors="ignore") as handle:
+                return handle.read()
+        except OSError:
+            return ""
+
+    def direct_includes(self, rel):
+        """Resolved includes of a single file."""
+        cached = self._direct.get(rel)
+        if cached is not None:
+            return cached
+        resolved = set()
+        self._direct[rel] = resolved  # placed first: the graph has cycles
+        directory = os.path.dirname(rel)
+        for spelling in INCLUDE_RE.findall(self.read_text(rel)):
+            candidate = os.path.normpath(os.path.join(directory, spelling))
+            if candidate in self.files:
+                resolved.add(candidate)
+            elif spelling in self.files:
+                resolved.add(spelling)
+            elif spelling in self._by_suffix:
+                resolved.add(self._by_suffix[spelling])
+        return resolved
+
+    def closure(self, rel):
+        """Every file reachable from ``rel`` through includes."""
+        seen = set()
+        stack = [rel]
+        while stack:
+            for nxt in self.direct_includes(stack.pop()):
+                if nxt not in seen:
+                    seen.add(nxt)
+                    stack.append(nxt)
+        return seen
+
+
+# targets     -- test translation unit -> the CMake target that compiles it
+# standalone  -- targets the ``buildtests`` aggregate does not depend on
+# failtests   -- failtest translation unit -> the CTest names that compile it
+Registrations = collections.namedtuple("Registrations", "targets standalone failtests")
+
+
+def _loop_binding(arguments):
+    """Names a ``foreach(...)`` binds, or ``None`` when they are not literal."""
+    tokens = [token.strip('"') for token in arguments.split()]
+    if not tokens or not CMAKE_NAME_RE.match(tokens[0]):
+        return None
+    variable, items = tokens[0], tokens[1:]
+    if items[:2] == ["IN", "ITEMS"]:
+        items = items[2:]
+    elif items[:1] == ["IN"]:
+        # IN LISTS and IN ZIP_LISTS iterate variables, not literal names.
+        return None
+    return variable, [item for item in items if "$" not in item]
+
+
+def _loop_expand(token, loops):
+    """Resolve a registration name against the enclosing ``foreach`` bindings."""
+    if not token.startswith("$"):
+        return [token]
+    name = token[2:-1]
+    for binding in reversed(loops):
+        if binding is not None and binding[0] == name:
+            return binding[1]
+    return []
+
+
+def test_registrations(graph):
+    """Map registered translation units to what CI has to build or run."""
+    source_targets = {}
+    standalone = set()
+
+    def register(source, target):
+        previous = source_targets.get(source)
+        if previous is not None and previous != target:
+            raise ValueError("%s is registered by both %s and %s" % (source, previous, target))
+        source_targets[source] = target
+
+    cmake_files = sorted(
+        rel
+        for rel in graph.files
+        if os.path.basename(rel) == "CMakeLists.txt"
+        and _under(rel, TEST_ROOTS)
+        and not _under(rel, EXCLUDED_TEST_DIRS)
+    )
+    for cmake_file in cmake_files:
+        directory = os.path.dirname(cmake_file)
+        extension = "cpp"
+        # foreach() bindings in effect, innermost last.  A loop over anything
+        # but a literal item list pushes None so endforeach() stays balanced.
+        loops = []
+        for match in CMAKE_REGISTRATION_RE.finditer(graph.read_text(cmake_file)):
+            if match.group("scope"):
+                # unset(), or a set() with no value, restores the default.
+                extension = match.group("extension") if match.group("scope") == "set" else ""
+                extension = extension or "cpp"
+                continue
+            if match.group("loop") is not None:
+                loops.append(_loop_binding(match.group("loop")))
+                continue
+            if match.group("endloop"):
+                if loops:
+                    loops.pop()
+                continue
+            if match.group("test"):
+                for target in _loop_expand(match.group("test"), loops):
+                    source = os.path.normpath(
+                        os.path.join(directory, "%s.%s" % (target, extension)))
+                    if source in graph.files:
+                        register(source, target)
+                continue
+            target = match.group("executable")
+            for token in re.findall(r'"[^"]*"|[^\s]+', match.group("sources")):
+                token = token.strip('"')
+                if not token.endswith(TEST_SOURCE_SUFFIXES) or "$" in token:
+                    continue
+                source = os.path.normpath(os.path.join(directory, token))
+                if source in graph.files:
+                    register(source, target)
+                    standalone.add(target)
+
+    failtests = {}
+    for name in CMAKE_FAILTEST_RE.findall(graph.read_text(FAILTEST_ROOT + "/CMakeLists.txt")):
+        source = "%s/%s.cpp" % (FAILTEST_ROOT, name)
+        if source in graph.files:
+            failtests[source] = (name + "_ok", name + "_ko")
+
+    return Registrations(source_targets, standalone, failtests)
+
+
+def full_suite(graph, reasons):
+    """Full-suite selection, naming the targets ``buildtests`` does not build."""
+    try:
+        standalone = test_registrations(graph).standalone
+    except ValueError:
+        # A broken registration is reported by the paths that depend on the
+        # mapping; the full suite stays available without it.
+        standalone = ()
+    return Selection("all", reasons=reasons, standalone=standalone)
+
+
+def reverse_map(graph, sources):
+    """Map each included file to the test sources that reach it."""
+    reverse = {}
+    for src in sources:
+        for dep in graph.closure(src):
+            reverse.setdefault(dep, set()).add(src)
+    return reverse
+
+
+class Selection:
+    """Outcome: the full suite, explicit targets, no tests, or an error."""
+
+    def __init__(self, mode, targets=(), reasons=(), ctest_names=(), standalone=()):
+        self.mode = mode  # "all", "targets", "none", or "error"
+        self.targets = set(targets)
+        self.reasons = list(reasons)
+        # CTest names with no build target of their own.
+        self.ctest_names = set(ctest_names)
+        # Targets to name alongside ``buildtests`` in "all" mode.
+        self.standalone = set(standalone)
+
+    @property
+    def targets_file(self):
+        if self.mode == "error":
+            raise ValueError("an invalid selection has no target file")
+        if self.mode == "all":
+            return "".join(name + "\n" for name in ["buildtests"] + sorted(self.standalone))
+        if self.mode == "none":
+            return "NONE\n"
+        return "".join(name + "\n" for name in sorted(self.targets))
+
+    @property
+    def regex_file(self):
+        if self.mode == "error":
+            raise ValueError("an invalid selection has no regex file")
+        if self.mode == "all":
+            return "ALL\n"
+        if self.mode == "none":
+            return "NONE\n"
+        names = sorted(self.targets) + sorted(self.ctest_names)
+        return "^(%s)(_[0-9]+)?$\n" % "|".join(re.escape(name) for name in names)
+
+
+def select(graph, changed_files, max_fraction=DEFAULT_MAX_FRACTION):
+    """Map changed paths to the tests that must run."""
+    paths = []
+    for path in changed_files:
+        path = path.strip()
+        if path and not _matches(path, IGNORED_PATTERNS):
+            paths.append(path)
+    if not paths:
+        return Selection("none", reasons=["no change reaches a test"])
+    for path in paths:
+        if _matches(path, FULL_REBUILD_PATTERNS):
+            return full_suite(graph, ["%s forces the full suite" % path])
+
+    try:
+        registered = test_registrations(graph)
+    except ValueError as error:
+        return Selection("error", reasons=[str(error)])
+    sources = sorted(registered.targets)
+    reverse = reverse_map(graph, sources)
+    failtest_reverse = reverse_map(graph, sorted(registered.failtests))
+
+    selected = set()
+    selected_failtests = set()
+    reasons = []
+    for path in paths:
+        reached_by = set(reverse.get(path, ()))
+        if path in registered.targets:
+            reached_by.add(path)
+        failtests = set(failtest_reverse.get(path, ()))
+        if path in registered.failtests:
+            failtests.add(path)
+        if reached_by or failtests:
+            selected |= reached_by
+            selected_failtests |= failtests
+            continue
+        if path in graph.files:
+            # A source file in the tree that nothing includes: either a new
+            # header not yet wired up or an unregistered translation unit.
+            roots = TEST_ROOTS + (FAILTEST_ROOT,)
+            if (_under(path, roots) and not _under(path, EXCLUDED_TEST_DIRS)
+                    and path.endswith(TEST_SOURCE_SUFFIXES)):
+                return Selection("error", reasons=["%s has no CMake test target" % path])
+            reasons.append("%s is in the tree but reaches no test" % path)
+            continue
+        # Deleted, renamed, or outside every scanned root: the graph cannot say
+        # what it affected, so do not guess.
+        return full_suite(graph, ["%s is not in the include graph" % path])
+
+    if not selected and not selected_failtests:
+        return Selection("none", reasons=reasons or ["no change reaches a test"])
+
+    if len(selected) > max_fraction * len(sources):
+        reasons.append(
+            "%d of %d test sources selected (>%.0f%%)"
+            % (len(selected), len(sources), 100 * max_fraction)
+        )
+        return full_suite(graph, reasons)
+
+    ctest_names = set()
+    for source in sorted(selected_failtests):
+        ctest_names.update(registered.failtests[source])
+    if ctest_names:
+        reasons.append("%d compile-failure test(s) build from inside CTest"
+                       % len(selected_failtests))
+    return Selection("targets", (registered.targets[s] for s in selected), reasons,
+                     ctest_names=ctest_names)
+
+
+def changed_files_from_git(source_dir, base_sha, head="HEAD"):
+    """Paths changed between ``base_sha`` and ``head``."""
+    result = subprocess.run(
+        ["git", "diff", "--no-renames", "--name-only", "%s...%s" % (base_sha, head)],
+        cwd=source_dir,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError("git diff failed: %s" % result.stderr.strip())
+    return [line for line in result.stdout.splitlines() if line.strip()]
+
+
+def parse_args(argv):
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    default_source = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    parser.add_argument("--source-dir", default=default_source,
+                        help="Eigen source tree (default: the tree containing this script)")
+    parser.add_argument("--base-sha",
+                        help="compute changed files from 'git diff BASE...HEAD'")
+    parser.add_argument("--head", default="HEAD", help="head revision for --base-sha")
+    parser.add_argument("--changed-files",
+                        help="read newline-separated changed paths from this file ('-' for stdin)")
+    parser.add_argument("--output-dir",
+                        help="write targets.txt and ctest_regex.txt here")
+    parser.add_argument("--max-fraction", type=float, default=DEFAULT_MAX_FRACTION,
+                        help="degrade to the full suite above this fraction (default: %(default)s)")
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+
+    if args.changed_files:
+        if args.changed_files == "-":
+            changed = sys.stdin.read().splitlines()
+        else:
+            with open(args.changed_files) as handle:
+                changed = handle.read().splitlines()
+    elif args.base_sha:
+        try:
+            changed = changed_files_from_git(args.source_dir, args.base_sha, args.head)
+        except RuntimeError as error:
+            # Without a usable diff there is no basis for narrowing.
+            print("%s; selecting the full suite" % error, file=sys.stderr)
+            changed = None
+    else:
+        print("one of --base-sha or --changed-files is required", file=sys.stderr)
+        return 2
+
+    graph = IncludeGraph(args.source_dir)
+    if changed is None:
+        selection = full_suite(graph, ["the merge-base diff is unavailable"])
+    else:
+        selection = select(graph, changed, args.max_fraction)
+
+    print("mode: %s" % selection.mode, file=sys.stderr)
+    for reason in selection.reasons:
+        print("  %s" % reason, file=sys.stderr)
+    if selection.mode == "error":
+        return 1
+    if selection.mode == "targets":
+        print("  %d targets: %s" % (len(selection.targets),
+                                    " ".join(sorted(selection.targets))), file=sys.stderr)
+        if selection.ctest_names:
+            print("  %d CTest-only: %s" % (len(selection.ctest_names),
+                                           " ".join(sorted(selection.ctest_names))),
+                  file=sys.stderr)
+
+    if args.output_dir:
+        os.makedirs(args.output_dir, exist_ok=True)
+        with open(os.path.join(args.output_dir, "targets.txt"), "w") as handle:
+            handle.write(selection.targets_file)
+        with open(os.path.join(args.output_dir, "ctest_regex.txt"), "w") as handle:
+            handle.write(selection.regex_file)
+    else:
+        sys.stdout.write(selection.targets_file)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/check_style.py b/scripts/check_style.py
new file mode 100644
index 0000000..cb0e4f3
--- /dev/null
+++ b/scripts/check_style.py
@@ -0,0 +1,406 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Advisory style check for added C++ code, for what clang-tidy cannot say.
+
+Flags the problems that recur in this repository's code reviews and that no
+clang-tidy check states: narration-comment verbosity (see the comment rules in
+``AGENTS.md``), ``enum`` constant blocks, ``std::integral_constant<bool,...>``,
+C++17-and-later constructs in the C++14 trees, and ``std::`` math in library
+headers where ``numext::`` is required.  Conventions clang-tidy *can* state
+live in ``.clang-tidy`` and are checked by ``clang_tidy_hook.py`` against the
+same added lines.  Only lines a change ADDS are reported, but each file's
+complete post-image is lexed so surrounding context — an enclosing block
+comment, a Doxygen continuation, a multi-line initializer — is classified
+correctly.
+
+The findings are advisory: a flagged construct may be justified, in which
+case keep it and state the reason where the construct is.
+
+Modes:
+  --diff BASE     check lines added relative to ``merge-base(BASE, HEAD)``,
+                  including uncommitted changes and untracked C++ files;
+                  exit 1 if findings
+  --claude-hook   run as a Claude Code PostToolUse hook: read the tool-call
+                  JSON from stdin and check the text the edit added; exit 2
+                  if findings so the harness feeds them back to the model
+
+The Claude Code hook is registered for this repository in
+``.claude/settings.json``.  Other agents and humans can run the diff mode
+directly, e.g. ``python3 scripts/check_style.py --diff origin/master``.
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from style_common import (REPO_ROOT, added_lines_from_diff, added_from_structured_patch,  # noqa: E402,F401
+                          diff_added_lines, hook_added_line_numbers, hook_edit_snippets,
+                          hook_post_image_and_added, is_cxx_path, read_post_image)
+
+# Trees whose headers and tests must compile as C++14 (see AGENTS.md rule 3).
+# unsupported/Eigen/ is kept for the legacy umbrella shims that still live there;
+# the implementation tree itself is contrib/.
+CXX14_TREES = ("Eigen/", "contrib/Eigen/", "unsupported/Eigen/", "test/", "contrib/test/", "failtest/", "blas/",
+               "lapack/")
+# Guarded exceptions with a documented newer requirement: SYCL sources build
+# only in the C++17 SYCL configurations, while duccfft and the structured-
+# binding failtests explicitly select C++17 in their test CMakeLists files.
+CXX17_PREFIXES = ("Eigen/src/Core/arch/SYCL/",)
+CXX17_FILES = {
+    "test/sycl_basic.cpp",
+    "contrib/Eigen/src/FFT/duccfft_impl.h",
+    "contrib/test/duccfft.cpp",
+    "failtest/structured_bindings_dynamic_matrix.cpp",
+    "failtest/structured_bindings_dynamic_array.cpp",
+    "failtest/structured_bindings_rowmajor.cpp",
+}
+# Library implementation headers, where numext:: is required over std:: math.
+LIBRARY_SRC_TREES = ("Eigen/src/", "contrib/Eigen/src/")
+
+DOXYGEN = re.compile(r"^\s*(/\*\*|/\*!|///|//!)")
+LICENSE = re.compile(r"SPDX|Copyright|License|Mozilla Public", re.I)
+# A bibliography is provenance, which AGENTS.md keeps, and it is long by nature: one entry per
+# work cited already exceeds the block threshold. Matched on the block's own header line so that
+# ordinary prose mentioning a reference is still counted.
+REFERENCES = re.compile(r"^\s*(?://|/\*)?\s*References:\s*$", re.M)
+STD_MATH = (
+    r"abs|arg|conj|real|imag|sqrt|cbrt|isnan|isinf|isfinite|signbit|exp|exp2|expm1|log|log1p|log2|pow|"
+    r"sin|cos|tan|asin|acos|atan|atan2|asinh|acosh|atanh|sinh|cosh|tanh|hypot|fma|copysign|ldexp|floor|"
+    r"ceil|round|rint|trunc|fmod"
+)
+
+# Convention checks applied per added code line (comments and literals blanked).
+#
+# Only conventions clang-tidy cannot currently state belong here; NULL and
+# typedef moved to modernize-use-nullptr and modernize-use-using in
+# .clang-tidy, which clang_tidy_hook.py and ci/scripts/run-clang-tidy.sh run
+# against the same added lines.  The entries below are the remainder: those
+# needing a CustomChecks query (parked in .clang-tidy until CI's clang-tidy
+# reaches 22) and those no AST matcher reaches at all.
+#
+# One known gap in that handover: modernize-use-using in clang-tidy 18 (the
+# checkformat:clangtidy toolchain) reports typedefs at class and namespace
+# scope but not function-local ones (measured — Block.h 17 of 18, Redux.h 24
+# of 25, GeneralMatrixMatrix.h 21 of 28).  That was an upstream defect,
+# llvm/llvm-project#72179, fixed in the 19.x release, so the gap closes when
+# the CI image's clang-tidy moves; until then a function-local typedef in new
+# code goes unreported.  Reintroducing a regex for it would bring back the
+# false positives this handover removes.  modernize-use-nullptr has no gap.
+CODE_CHECKS = [
+    # Awaiting the parked eigen-bool-constant query.
+    (r"std::integral_constant<\s*bool\b", "std::integral_constant<bool,...>: use Eigen's bool_constant (Meta.h)"),
+    # Awaiting the parked eigen-enum-constant query.  No stock check states
+    # this rule: cppcoreguidelines-use-enum-class asks for `enum class`,
+    # whereas Eigen wants static constexpr for trait constants.
+    (r"^\s*enum\s*(?::[^{}]+)?\{", "enum constant block: trait/evaluator constants are static constexpr in new "
+                                   "code; Flags is `unsigned int`"),
+]
+CXX14_CHECKS = [
+    # Awaiting the parked eigen-if-constexpr query.  A C++14 build does not
+    # reliably reject this on its own: clang accepts `if constexpr` as an
+    # extension and only warns under -Wc++17-extensions.
+    (r"\bif\s+constexpr\b", "if constexpr: supported code compiles as C++14; use EIGEN_IF_CONSTEXPR (...) with a "
+                            "condition that is valid either way"),
+    # These do fail the default C++14 build; flagging them at edit time just
+    # shortens the loop, and covers headers no built target happens to include.
+    (r"\bstd::(any|span|optional|variant|string_view|byte|filesystem|void_t)\b",
+     "C++17/20 library facility: the supported baseline is C++14"),
+]
+# Also C++14-tree only (CMakeLists.txt defaults CMAKE_CXX_STANDARD to 14), and
+# not expressible as a matcher — designated initializers do not parse in C++14,
+# so there is no AST for a check to match.
+DESIGNATED_MSG = "designated initializer: C++20-only; use aggregate assignment with /*name=*/ comments"
+
+
+RAW_PREFIX = re.compile(r"(?:^|[^0-9A-Za-z_])(?:u8|u|U|L)?R$")
+
+
+def is_digit_separator(line, i):
+    """Return whether the apostrophe at ``i`` belongs to a C++ number."""
+    if i + 1 >= len(line) or not line[i + 1].isalnum():
+        return False
+    start = i
+    while start > 0 and (line[start - 1].isalnum() or line[start - 1] in "._'"):
+        start -= 1
+    token = line[start:i]
+    return bool(token) and (token[0].isdigit() or (len(token) > 1 and token[0] == "." and token[1].isdigit()))
+
+
+def scan_quoted(line, j, quote):
+    """Scan a quoted literal's remainder from position ``j``.
+
+    Returns (next_position, closed, spliced): ``spliced`` is True when the
+    line ends with a backslash inside the literal, so the literal continues
+    on the next physical line.
+    """
+    n = len(line)
+    while j < n:
+        if line[j] == "\\":
+            if j == n - 1:
+                return n, False, True
+            j += 2
+            continue
+        if line[j] == quote:
+            return j + 1, True, False
+        j += 1
+    return n, False, False
+
+
+def lex_lines(lines):
+    """Lex a file's complete contiguous text.
+
+    Returns (code_lines, comment_only, doxygen_only) as parallel lists: per
+    line, the code with comments and string/character literals blanked, the
+    stripped comment text when the line holds no code (else None), and whether
+    that comment belongs to Doxygen.  Block comments, raw string literals, and
+    backslash-spliced ordinary literals carry their state across physical
+    lines.
+    """
+    code_lines, comment_only, doxygen_only = [], [], []
+    in_block = False
+    block_doxygen = False
+    raw_terminator = None  # e.g. )delim" while inside a raw string literal
+    open_quote = None      # quote character of a spliced ordinary literal
+    for line in lines:
+        out, i, n = [], 0, len(line)
+        had_code = False
+        had_comment = in_block
+        line_doxygen = block_doxygen if in_block else False
+        literal_at_start = raw_terminator is not None or open_quote is not None
+        while i < n:
+            if in_block:
+                j = line.find("*/", i)
+                if j < 0:
+                    i = n
+                else:
+                    in_block = False
+                    block_doxygen = False
+                    i = j + 2
+                continue
+            if raw_terminator is not None:
+                j = line.find(raw_terminator, i)
+                if j < 0:
+                    i = n
+                else:
+                    i = j + len(raw_terminator)
+                    raw_terminator = None
+                continue
+            if open_quote is not None:
+                i, closed, spliced = scan_quoted(line, i, open_quote)
+                if closed or not spliced:  # an unspliced open literal is ill-formed; close at EOL
+                    open_quote = None
+                continue
+            c = line[i]
+            if c == "/" and i + 1 < n and line[i + 1] == "/":
+                had_comment = True
+                line_doxygen = line_doxygen or bool(DOXYGEN.match(line[i:]))
+                break
+            if c == "/" and i + 1 < n and line[i + 1] == "*":
+                had_comment = True
+                block_doxygen = line.startswith(("/**", "/*!"), i)
+                line_doxygen = line_doxygen or block_doxygen
+                in_block = True
+                i += 2
+                continue
+            if c == '"' and RAW_PREFIX.search(line[:i]):
+                paren = line.find("(", i + 1)
+                delimiter = line[i + 1:paren] if paren >= 0 else None
+                if delimiter is not None and len(delimiter) <= 16 and not re.search(r"[()\\\s]", delimiter):
+                    out.append('""')
+                    had_code = True
+                    raw_terminator = ")" + delimiter + '"'
+                    j = line.find(raw_terminator, paren + 1)
+                    if j < 0:
+                        i = n
+                    else:
+                        i = j + len(raw_terminator)
+                        raw_terminator = None
+                    continue
+            if c == "'" and is_digit_separator(line, i):
+                # C++14 digit separator inside a preprocessing-number, not a
+                # character-literal delimiter (for example 1'000 or 0xFF'00).
+                out.append(c)
+                had_code = True
+                i += 1
+                continue
+            if c in "\"'":
+                out.append(c + c)
+                had_code = True
+                i, closed, spliced = scan_quoted(line, i + 1, c)
+                if not closed and spliced:
+                    open_quote = c
+                continue
+            out.append(c)
+            if not c.isspace():
+                had_code = True
+            i += 1
+        stripped = line.strip()
+        is_comment = (not had_code) and had_comment and not literal_at_start
+        code_lines.append("".join(out))
+        comment_only.append(stripped if is_comment else None)
+        doxygen_only.append(line_doxygen if is_comment else None)
+    return code_lines, comment_only, doxygen_only
+
+
+def check_comments(comment_only, doxygen_only, added, findings):
+    """Flag comment blocks that gain six or more added narration lines.
+
+    Blocks are formed over the full file, so an addition inside an existing
+    Doxygen, license or bibliography block inherits that block's exemption, and
+    only the ADDED lines count toward the threshold — extending a pre-existing
+    block by a line or two is not reported.
+    """
+    def finish_block(block_start, block_end, is_doxygen):
+        block = comment_only[block_start:block_end]
+        added_in_block = [line_no for line_no in range(block_start + 1, block_end + 1) if line_no in added]
+        text = "\n".join(block)
+        exempt = is_doxygen or LICENSE.search(text) or REFERENCES.search(text)
+        if added_in_block and len(added_in_block) >= 6 and not exempt:
+            findings.append((added_in_block[0], "%d added lines of non-Doxygen comment: AGENTS.md keeps only "
+                                                "mathematics, invariants, compatibility constraints, provenance, "
+                                                "or the reason a deliberate construct must not be simplified"
+                                                % len(added_in_block)))
+
+    block_start, block_doxygen = None, None
+    for idx in range(len(comment_only) + 1):
+        comment = comment_only[idx] if idx < len(comment_only) else None
+        if comment is not None:
+            if block_start is None:
+                block_start = idx
+                block_doxygen = doxygen_only[idx]
+            elif doxygen_only[idx] != block_doxygen:
+                finish_block(block_start, idx, block_doxygen)
+                block_start = idx
+                block_doxygen = doxygen_only[idx]
+        elif block_start is not None:
+            finish_block(block_start, idx, block_doxygen)
+            block_start = None
+
+
+def check_designated_initializer(code_lines, line_no, findings):
+    code = code_lines[line_no - 1]
+    hit = re.search(r"[{,]\s*\.\w+\s*=", code)
+    if not hit and re.match(r"\s*\.\w+\s*=", code):
+        # A line-leading designator continues a braced initializer only when
+        # the previous code line ends with `{` or `,`; anything else is a
+        # wrapped member access or assignment.
+        for prev in range(line_no - 2, -1, -1):
+            prev_code = code_lines[prev].rstrip()
+            if prev_code:
+                hit = prev_code.endswith("{") or prev_code.endswith(",")
+                break
+    if hit:
+        findings.append((line_no, DESIGNATED_MSG))
+        return True
+    return False
+
+
+def check_conventions(rel_path, code_lines, added, findings):
+    checks = list(CODE_CHECKS)
+    cxx17_path = (
+        rel_path in CXX17_FILES
+        or rel_path.startswith(CXX17_PREFIXES)
+        or (rel_path.startswith("contrib/Eigen/src/Tensor/") and rel_path.endswith("Sycl.h"))
+        or (rel_path.startswith("contrib/test/") and rel_path.endswith("_sycl.cpp"))
+    )
+    if rel_path.startswith(CXX14_TREES) and not cxx17_path:
+        checks += CXX14_CHECKS
+    if rel_path.startswith(LIBRARY_SRC_TREES):
+        checks.append((r"(?:\(\s*)?\bstd::(?:%s)\s*(?:\)\s*)?\(" % STD_MATH,
+                       "std:: math call in a library header: use the numext:: equivalent "
+                       "(device- and custom-scalar-aware)"))
+        checks.append((r"(?:\(\s*)?\bstd::frexp\s*(?:\)\s*)?\(",
+                       "std::frexp call in a library header: use EIGEN_USING_STD(frexp) and an unqualified call "
+                       "for ADL and device/custom-scalar support"))
+    added_sorted = sorted(added)
+    for pattern, message in checks:
+        rx = re.compile(pattern)
+        for line_no in added_sorted:
+            if rx.search(code_lines[line_no - 1]):
+                findings.append((line_no, message))
+                break  # one report per pattern per file
+    for line_no in added_sorted:
+        if check_designated_initializer(code_lines, line_no, findings):
+            break
+
+
+def find_findings(rel_path, lines, added):
+    """Check one file: ``lines`` is the complete post-image, ``added`` the set
+    of 1-based line numbers the change added.  Returns [(line_no, message)]."""
+    if not is_cxx_path(rel_path):
+        return []
+    added = {n for n in added if 1 <= n <= len(lines) and lines[n - 1].strip()}
+    if not added:
+        return []
+    code_lines, comment_only, doxygen_only = lex_lines(lines)
+    findings = []
+    check_comments(comment_only, doxygen_only, added, findings)
+    check_conventions(rel_path, code_lines, added, findings)
+    findings.sort()
+    return findings
+
+
+def run_diff_mode(base, root=REPO_ROOT):
+    """Return [(rel_path, line_no, message)] for lines added since
+    merge-base(base, HEAD), including untracked C++ files."""
+    per_file = diff_added_lines(base, root)
+    results = []
+    for rel_path in sorted(per_file):
+        text = read_post_image(root, rel_path)
+        if text is None:  # deleted or unreadable
+            continue
+        for line_no, message in find_findings(rel_path, text.splitlines(), per_file[rel_path]):
+            results.append((rel_path, line_no, message))
+    return results
+
+
+def run_hook_mode():
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        return 0
+    rel_path, snippets = hook_edit_snippets(payload)
+    if rel_path is None:
+        return 0
+    # The hook runs after the edit, so the file on disk is the post-image; it is
+    # lexed whole so enclosing comments and initializers classify correctly.
+    lines, added, _ = hook_post_image_and_added(payload, rel_path, snippets)
+    findings = find_findings(rel_path, lines, added)
+    if findings:
+        sys.stderr.write("style check (%s) — review before proceeding:\n" % rel_path)
+        for _, message in findings[:8]:
+            sys.stderr.write("  - %s\n" % message)
+        sys.stderr.write("Advisory: keep a flagged construct only if it is justified, and say why at the "
+                         "construct.\n")
+        return 2
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--diff", metavar="BASE", help="check lines added relative to merge-base(BASE, HEAD)")
+    mode.add_argument("--claude-hook", action="store_true", help="run as a Claude Code PostToolUse hook")
+    args = parser.parse_args()
+    if args.claude_hook:
+        try:
+            return run_hook_mode()
+        except Exception:
+            return 0  # a broken hook must not block the harness
+    results = run_diff_mode(args.diff)
+    for rel_path, line_no, message in results:
+        print("%s:%d: %s" % (rel_path, line_no, message))
+    if results:
+        print("\n%d advisory finding(s) in added lines. Keep a flagged construct only if it is justified, "
+              "and say why at the construct." % len(results))
+    return 1 if results else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/ci_cmake_msvc.ps1 b/scripts/ci_cmake_msvc.ps1
index c08b9ae..9b20103 100644
--- a/scripts/ci_cmake_msvc.ps1
+++ b/scripts/ci_cmake_msvc.ps1
@@ -1,4 +1,6 @@
 # Powershell script to set up MSVC cmake builds that mirror the CI.  Useful for reproducing issues.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 param ($EIGEN_CI_ROOTDIR,
        $EIGEN_CI_BUILDDIR,
diff --git a/scripts/ci_cmake_msvc_cuda.ps1 b/scripts/ci_cmake_msvc_cuda.ps1
index dd615ec..1b024c2 100644
--- a/scripts/ci_cmake_msvc_cuda.ps1
+++ b/scripts/ci_cmake_msvc_cuda.ps1
@@ -1,4 +1,6 @@
 # Powershell script to set up MSVC CUDA cmake builds that mirror the CI.  Useful for reproducing issues.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 param ($EIGEN_CI_ROOTDIR,
        $EIGEN_CI_BUILDDIR,
diff --git a/scripts/clang_tidy_hook.py b/scripts/clang_tidy_hook.py
new file mode 100644
index 0000000..5bc747e
--- /dev/null
+++ b/scripts/clang_tidy_hook.py
@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Run clang-tidy on the lines an edit added.
+
+``.clang-tidy`` is the authority on the conventions clang-tidy can express, so
+rather than restate them this hook runs the real thing on the edited file and
+reports only diagnostics on added lines (``--line-filter``).  Without that
+restriction the checks would be unusable interactively: ``Eigen/src`` holds
+~4100 ``typedef``s, and whole-file output buries the two lines just written.
+
+Editing a header under ``Eigen/src`` cannot be compiled directly — the module's
+``InternalHeaderCheck.h`` ``#error``s out — so a driver includes the module
+umbrella first and then the edited header.  The umbrella name is read from the
+``#error "Please include <X>"`` directive.  This mirrors what
+``ci/scripts/run-clang-tidy.sh`` does for merge requests.  Including the edited
+header explicitly also covers a new header that the umbrella does not export
+yet.
+
+LLVM's ``clang-tidy-diff.py`` cannot replace this routing: it invokes changed
+headers directly, which trips Eigen's internal-header guard, and a PostToolUse
+payload is not a unified diff.
+
+No compilation database is required: ``-std=c++14 -I<repo>`` parses any file
+in the C++14 trees, with ``test/`` added for the test sources and
+``contrib/`` for the contrib ones, which keeps the hook usable in a
+fresh checkout with no build directory.
+
+The hook fails open — a missing clang-tidy, an unparsable file, a translation
+unit that does not compile, or any unexpected error exits 0 rather than blocking
+the harness. Only real findings on added lines block.
+"""
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from style_common import (REPO_ROOT, diff_added_lines, hook_edit_snippets,  # noqa: E402
+                          hook_post_image_and_added, is_cxx_path, line_filter_json)
+
+# Parsing an umbrella costs about a second, so keep the hook off trees whose
+# conventions these checks do not describe (bench/, demos/, doc/ examples).
+# unsupported/Eigen/ is kept for the legacy umbrella shims that still live
+# there; the implementation tree itself is contrib/, which has no shims and
+# so needs the src-tree rules.
+CHECKED_TREES = ("Eigen/", "contrib/Eigen/", "unsupported/Eigen/", "test/", "contrib/test/", "failtest/", "blas/",
+                 "lapack/")
+SRC_TREES = ("Eigen/src/", "contrib/Eigen/src/")
+# Modules whose umbrella needs a third-party header we cannot assume is present.
+EXTERNAL_DEP_MODULES = ("AccelerateSupport", "CholmodSupport", "KLUSupport", "MetisSupport",
+                        "PaStiXSupport", "PardisoSupport", "SPQRSupport", "SuperLUSupport",
+                        "UmfPackSupport")
+PLEASE_INCLUDE = re.compile(r'"Please include ([^ "]+)')
+TIMEOUT_SECONDS = 30
+
+
+def module_of(rel_path):
+    """Return the ``Eigen/src/<Module>`` name owning ``rel_path``, else None."""
+    m = re.match(r"^(?:contrib/)?Eigen/src/([^/]+)/", rel_path)
+    return m.group(1) if m else None
+
+
+def umbrella_for(rel_path, root=REPO_ROOT):
+    """Return the module umbrella to include when linting a src-tree header.
+
+    The source of truth is the ``#error "Please include <X>"`` directive on the
+    header itself or on its sibling ``InternalHeaderCheck.h``; the
+    ``<root>/<Module>`` heuristic covers arch-specific backends nested deeper
+    than the module root, which carry no directive of their own.
+    """
+    module = module_of(rel_path)
+    if module is None or module in EXTERNAL_DEP_MODULES:
+        return None
+    for candidate in (rel_path, os.path.join(os.path.dirname(rel_path), "InternalHeaderCheck.h")):
+        try:
+            with open(os.path.join(root, candidate), encoding="utf-8", errors="replace") as handle:
+                hit = PLEASE_INCLUDE.search(handle.read())
+        except OSError:
+            continue
+        if hit and os.path.isfile(os.path.join(root, hit.group(1))):
+            return hit.group(1)
+    fallback = ("contrib/Eigen/" if rel_path.startswith("contrib/") else "Eigen/") + module
+    return fallback if os.path.isfile(os.path.join(root, fallback)) else None
+
+
+def cuda_include_dir(default_root="/usr/local/cuda"):
+    """Include directory of an installed CUDA toolkit, or None if there is none.
+
+    Every header in the GPU module that includes ``GpuSupport.h`` reaches
+    ``<cuda_runtime.h>``. Without it clang drops the include and every
+    declaration behind it, leaving an AST too truncated to check the module
+    against; with it the header is checked like any other.
+
+    ``default_root`` is where the toolkit is looked for once the environment
+    names none; a test passes a directory that holds no toolkit so the
+    negative case does not depend on the host.
+    """
+    roots = [os.environ.get(name) for name in ("CUDAToolkit_ROOT", "CUDA_HOME", "CUDA_PATH")]
+    roots.append(default_root)
+    for root in roots:
+        if root and os.path.isfile(os.path.join(root, "include", "cuda_runtime.h")):
+            return os.path.join(root, "include")
+    return None
+
+
+def compile_args(rel_path, root=REPO_ROOT):
+    """Include paths sufficient to parse ``rel_path`` without a compile database.
+
+    Test sources reach ``main.h`` through ``test/``; the contrib ones also
+    include their module umbrellas as ``<Eigen/Tensor>``, which resolves only
+    with ``contrib/`` on the path.  These are the directories
+    ``contrib/test/CMakeLists.txt`` adds for them.
+    """
+    args = ["-std=c++14", "-I" + root]
+    if rel_path.startswith(("test/", "contrib/test/")):
+        args += ["-I" + os.path.join(root, "test")]
+    if rel_path.startswith("contrib/test/"):
+        args += ["-I" + os.path.join(root, "contrib")]
+    cuda = cuda_include_dir()
+    if cuda:
+        args += ["-isystem", cuda]
+    return args
+
+
+def tidy_target(rel_path, tmpdir, root=REPO_ROOT):
+    """Return the path clang-tidy should be pointed at, or None to skip.
+
+    Source files are linted directly; src-tree headers go through a generated
+    driver that includes their module umbrella followed by the header itself.
+    """
+    if rel_path.startswith(SRC_TREES) or not os.path.splitext(rel_path)[1]:
+        include = umbrella_for(rel_path, root) if rel_path.startswith(SRC_TREES) else rel_path
+        if include is None:
+            return None
+        driver = os.path.join(tmpdir, "tidy_driver_" + rel_path.replace("/", "_") + ".cpp")
+        with open(driver, "w", encoding="utf-8") as handle:
+            handle.write("#include <%s>\n" % include)
+            if rel_path.startswith(SRC_TREES):
+                handle.write("#include <%s>\n" % rel_path)
+        return driver
+    if os.path.splitext(rel_path)[1].lower() in (".cpp", ".cc", ".cxx"):
+        return os.path.join(root, rel_path)
+    return None  # a .h outside the src trees has no reliable standalone TU
+
+
+def run_clang_tidy(per_file, root=REPO_ROOT, tidy=None):
+    """Lint the added lines of each file in ``per_file``.
+
+    Returns (diagnostics, skipped): ``diagnostics`` are clang-tidy's warning
+    lines, ``skipped`` a list of (path, reason) for files that could not be
+    checked.  A file whose translation unit does not compile is one of those:
+    clang-tidy emits no useful check output for it, and reporting it as clean
+    would claim a check that never ran.
+    """
+    tidy = shutil.which(tidy or "clang-tidy")
+    if tidy is None:
+        return None, []
+    diagnostics, skipped = [], []
+    with tempfile.TemporaryDirectory() as tmpdir:
+        for rel_path, added in sorted(per_file.items()):
+            if not added or not is_cxx_path(rel_path) or not rel_path.startswith(CHECKED_TREES):
+                continue
+            target = tidy_target(rel_path, tmpdir, root)
+            if target is None:
+                skipped.append((rel_path, "no standalone translation unit"))
+                continue
+            cmd = [tidy, "--quiet",
+                   "--config-file=" + os.path.join(root, ".clang-tidy"),
+                   "--header-filter=" + re.escape(rel_path),
+                   "--line-filter=" + line_filter_json({rel_path: added}),
+                   target, "--"] + compile_args(rel_path, root)
+            try:
+                done = subprocess.run(cmd, capture_output=True, text=True, timeout=TIMEOUT_SECONDS)
+            except OSError:
+                skipped.append((rel_path, "clang-tidy could not be run"))
+                continue
+            except subprocess.TimeoutExpired:
+                skipped.append((rel_path, "clang-tidy timed out after %ds" % TIMEOUT_SECONDS))
+                continue
+            broke = False
+            output = "\n".join(part for part in (done.stdout, done.stderr) if part)
+            for line in output.splitlines():
+                if not re.search(r": (warning|error): ", line):
+                    continue
+                if "clang-diagnostic-error" in line or ": error: " in line:
+                    broke = True
+                    continue
+                diagnostics.append(re.sub(r"^" + re.escape(root) + "/", "", line))
+            if broke:
+                skipped.append((rel_path, "translation unit did not compile"))
+            elif done.returncode != 0:
+                skipped.append((rel_path, "clang-tidy failed"))
+    return diagnostics, skipped
+
+
+def run_hook_mode(tidy=None):
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        return 0
+    rel_path, snippets = hook_edit_snippets(payload)
+    if rel_path is None or not is_cxx_path(rel_path) or not rel_path.startswith(CHECKED_TREES):
+        return 0
+    _, added, exact = hook_post_image_and_added(payload, rel_path, snippets)
+    if not exact or not added:
+        # Without real line numbers a line filter would point at the wrong
+        # lines; silence beats a misplaced diagnostic.
+        return 0
+    diagnostics, skipped = run_clang_tidy({rel_path: added}, tidy=tidy)
+    if not diagnostics:
+        broken = [reason for path, reason in (skipped or []) if reason == "translation unit did not compile"]
+        if broken:
+            # A header edited mid-refactor routinely fails to parse on its own,
+            # so show the user a non-blocking notice rather than feeding Claude
+            # an error with no finding to act on.
+            message = "clang-tidy (%s): not checked — the translation unit did not compile." % rel_path
+            sys.stdout.write(json.dumps({"systemMessage": message}) + "\n")
+            return 0
+        return 0
+    sys.stderr.write("clang-tidy (%s) — added lines only:\n" % rel_path)
+    for line in diagnostics[:8]:
+        sys.stderr.write("  %s\n" % line)
+    if len(diagnostics) > 8:
+        sys.stderr.write("  ... and %d more\n" % (len(diagnostics) - 8))
+    sys.stderr.write("Advisory: these are Eigen conventions from .clang-tidy; keep a flagged construct "
+                     "only if it is justified, and say why at the construct.\n")
+    return 2
+
+
+def run_diff_mode(base, tidy=None):
+    per_file = diff_added_lines(base)
+    diagnostics, skipped = run_clang_tidy(per_file, tidy=tidy)
+    if diagnostics is None:
+        sys.stderr.write("%s not found; skipping.\n" % (tidy or "clang-tidy"))
+        return 0
+    for line in diagnostics:
+        print(line)
+    for rel_path, reason in skipped:
+        print("%s: not checked (%s)" % (rel_path, reason))
+    if diagnostics:
+        print("\n%d clang-tidy finding(s) on added lines." % len(diagnostics))
+    return 1 if diagnostics else 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--diff", metavar="BASE", help="lint lines added since merge-base(BASE, HEAD)")
+    mode.add_argument("--claude-hook", action="store_true", help="run as a Claude Code PostToolUse hook")
+    parser.add_argument("-b", "--binary", metavar="CLANG_TIDY",
+                        help="clang-tidy executable to use, as a PATH name or a full path "
+                             "(e.g. clang-tidy-19 from LLVM's version-suffixed packages); "
+                             "default: clang-tidy")
+    args = parser.parse_args()
+    if args.claude_hook:
+        try:
+            return run_hook_mode(tidy=args.binary)
+        except Exception:
+            return 0  # a broken hook must not block the harness
+    if args.binary and shutil.which(args.binary) is None:
+        # In diff mode an explicitly named binary that is absent is a usage
+        # error; silently skipping would claim a check that never ran.  Hook
+        # mode above keeps the fail-open contract instead.
+        parser.error("--binary %s not found" % args.binary)
+    return run_diff_mode(args.diff, tidy=args.binary)
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/eigen_gen_credits.cpp b/scripts/eigen_gen_credits.cpp
index bf8e4df..8bf81a2 100644
--- a/scripts/eigen_gen_credits.cpp
+++ b/scripts/eigen_gen_credits.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include <string>
 #include <sstream>
 #include <iostream>
diff --git a/scripts/eigen_gen_docs b/scripts/eigen_gen_docs
index 787dcb3..953d2e7 100755
--- a/scripts/eigen_gen_docs
+++ b/scripts/eigen_gen_docs
@@ -1,4 +1,6 @@
 #!/bin/sh
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 # configuration
 # You should call this script with USER set as you want, else some default
diff --git a/scripts/eigen_gen_split_test_help.cmake b/scripts/eigen_gen_split_test_help.cmake
index e43f5aa..8d8e44d 100755
--- a/scripts/eigen_gen_split_test_help.cmake
+++ b/scripts/eigen_gen_split_test_help.cmake
@@ -1,4 +1,7 @@
 #!cmake -P
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 file(WRITE split_test_helper.h "")
 foreach(i RANGE 1 999)
   file(APPEND split_test_helper.h
diff --git a/scripts/git_commit_mrs_and_issues.py b/scripts/git_commit_mrs_and_issues.py
index 854ec39..6ebb119 100644
--- a/scripts/git_commit_mrs_and_issues.py
+++ b/scripts/git_commit_mrs_and_issues.py
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 """Search for MRs and issues related to a list of commits."""
 
 import argparse
diff --git a/scripts/gitlab_api_deploy_package.py b/scripts/gitlab_api_deploy_package.py
index 70dc03f..8c4ae91 100644
--- a/scripts/gitlab_api_deploy_package.py
+++ b/scripts/gitlab_api_deploy_package.py
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 """Helper script to download source archives and upload them to the Eigen GitLab generic package registry."""
 
 import os
diff --git a/scripts/gitlab_api_issues.py b/scripts/gitlab_api_issues.py
index 1d191fa..7aea324 100644
--- a/scripts/gitlab_api_issues.py
+++ b/scripts/gitlab_api_issues.py
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 """Downloads all issues from GitLab matching specified criteria."""
 
 import argparse
diff --git a/scripts/gitlab_api_labeller.py b/scripts/gitlab_api_labeller.py
index f5d3530..5ad1950 100644
--- a/scripts/gitlab_api_labeller.py
+++ b/scripts/gitlab_api_labeller.py
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 """Adds a label to a GitLab merge requests or issues."""
 
 import os
diff --git a/scripts/gitlab_api_mrs.py b/scripts/gitlab_api_mrs.py
index 12eb5f9..26e9924 100644
--- a/scripts/gitlab_api_mrs.py
+++ b/scripts/gitlab_api_mrs.py
@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
 """Downloads all MRs from GitLab matching specified criteria."""
 
 import argparse
diff --git a/scripts/msvc_setup.ps1 b/scripts/msvc_setup.ps1
index 3890a45..ecc22eb 100644
--- a/scripts/msvc_setup.ps1
+++ b/scripts/msvc_setup.ps1
@@ -1,4 +1,6 @@
 # Powershell script to set up MSVC environment.
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 
 param ($EIGEN_CI_MSVC_ARCH, $EIGEN_CI_MSVC_VER)
 function Get-ScriptDirectory { Split-Path $MyInvocation.ScriptName }
diff --git a/scripts/style_common.py b/scripts/style_common.py
new file mode 100644
index 0000000..8d3bd69
--- /dev/null
+++ b/scripts/style_common.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Shared plumbing for the added-line style checks.
+
+Both ``check_style.py`` (textual conventions) and ``clang_tidy_hook.py``
+(clang-tidy conventions) need the same two things: the set of line numbers a
+change ADDED to each file, and the ability to turn a Claude Code PostToolUse
+payload into that set.  That logic lives here so the two checkers cannot drift
+apart in what they consider an added line.
+
+Run directly to emit a clang-tidy ``--line-filter`` argument for the files a
+diff touches, which is how ``ci/scripts/run-clang-tidy.sh`` restricts an MR's
+diagnostics to its own lines:
+
+    python3 scripts/style_common.py --line-filter BASE [--] [path ...]
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CXX_EXT = {".h", ".hpp", ".hxx", ".cpp", ".cc", ".cxx", ".cu", ".cuh", ".inc"}
+# unsupported/Eigen/ still holds the legacy umbrella shims, which are
+# extensionless headers too.
+EXTENSIONLESS_HEADER_TREES = ("Eigen/", "contrib/Eigen/", "unsupported/Eigen/")
+
+
+def is_cxx_path(rel_path):
+    """Return whether ``rel_path`` is C++ source, including Eigen's
+    extensionless public module headers such as ``Eigen/Core``."""
+    return (os.path.splitext(rel_path)[1].lower() in CXX_EXT
+            or (not os.path.splitext(os.path.basename(rel_path))[1]
+                and rel_path.startswith(EXTENSIONLESS_HEADER_TREES)))
+
+
+def git(root, *args):
+    return subprocess.run(["git"] + list(args), cwd=root, capture_output=True, text=True)
+
+
+def read_post_image(root, rel_path):
+    try:
+        with open(os.path.join(root, rel_path), encoding="utf-8", errors="replace") as handle:
+            return handle.read()
+    except OSError:
+        return None
+
+
+def added_lines_from_diff(diff_text):
+    """Parse ``git diff -U0`` output into {relative_path: set(added line numbers)}."""
+    files = {}
+    path, new_line = None, 0
+    for raw in diff_text.splitlines():
+        if raw.startswith("+++ "):
+            name = raw[4:]
+            path = None if name == "/dev/null" else name[2:] if name.startswith("b/") else name
+        elif raw.startswith("@@"):
+            m = re.search(r"\+(\d+)(?:,(\d+))?", raw)
+            new_line = int(m.group(1)) if m else 0
+        elif raw.startswith("+") and not raw.startswith("+++"):
+            if path is not None:
+                files.setdefault(path, set()).add(new_line)
+            new_line += 1
+        elif not raw.startswith("-") and not raw.startswith("\\"):
+            # "\ No newline at end of file" is a marker, not a context line.
+            new_line += 1
+    return files
+
+
+def added_from_structured_patch(tool_response):
+    """Derive added line numbers from the tool response's structured patch,
+    which records the exact edited hunks.  A valid deletion-only patch returns
+    an empty set; None means absent or malformed data and enables fallback."""
+    try:
+        added = set()
+        for hunk in tool_response["structuredPatch"]:
+            line_no = int(hunk["newStart"])
+            for entry in hunk["lines"]:
+                if entry.startswith("+"):
+                    added.add(line_no)
+                    line_no += 1
+                elif not entry.startswith("-") and not entry.startswith("\\"):
+                    # "\ No newline at end of file" is a marker, not a context line.
+                    line_no += 1
+        return added
+    except Exception:
+        return None
+
+
+def hook_added_line_numbers(content, snippets):
+    """Map the strings an edit added onto post-image line numbers.
+
+    Each snippet must occur exactly once — a repeated occurrence cannot be
+    told apart from pre-existing identical text, and would mark unrelated
+    lines.  A snippet's span excludes the line after its trailing newline.
+    Returns None when any snippet is absent or ambiguous; the caller then
+    checks the snippet text standalone."""
+    added = set()
+    for snippet in snippets:
+        if not snippet:
+            continue
+        start = content.find(snippet)
+        if start < 0 or content.find(snippet, start + 1) >= 0:
+            return None
+        first = content.count("\n", 0, start) + 1
+        span = snippet.count("\n") + (0 if snippet.endswith("\n") else 1)
+        added.update(range(first, first + max(span, 1)))
+    return added
+
+
+def hook_edit_snippets(payload):
+    """Return (rel_path, snippets) for an edit payload, or (None, None) when
+    the tool call is not an in-repository C++ edit this checker handles."""
+    tool_input = payload.get("tool_input", {}) or {}
+    tool_name = payload.get("tool_name", "")
+    path = tool_input.get("file_path", "") or ""
+    if not path:
+        return None, None
+    rel_path = os.path.relpath(os.path.abspath(path), REPO_ROOT).replace(os.sep, "/")
+    if rel_path.startswith(".."):
+        return None, None
+    if tool_name == "Write":
+        snippets = [tool_input.get("content", "")]
+    elif tool_name == "Edit":
+        snippets = [tool_input.get("new_string", "")]
+    elif tool_name == "MultiEdit":
+        snippets = [e.get("new_string", "") for e in tool_input.get("edits", [])]
+    else:
+        return None, None
+    if not any(s.strip() for s in snippets):
+        return None, None
+    return rel_path, snippets
+
+
+def hook_post_image_and_added(payload, rel_path, snippets):
+    """Resolve the post-image lines and added line numbers for an edit.
+
+    The hook runs after the edit, so the file on disk is the post-image.  The
+    edited lines come from the tool response's structured patch when present,
+    else from locating a uniquely occurring added string.  Returns
+    (lines, added, exact): ``exact`` is False when the lines could not be
+    located in the real file and the snippet text is being checked standalone.
+    """
+    text = read_post_image(REPO_ROOT, rel_path)
+    added = None
+    lines = None
+    if text is not None:
+        lines = text.splitlines()
+        added = added_from_structured_patch(payload.get("tool_response") or {})
+        if added is None:
+            if payload.get("tool_name") == "Write":
+                added = set(range(1, len(lines) + 1))
+            else:
+                added = hook_added_line_numbers(text, snippets)
+    if added is None:
+        lines = "\n".join(snippets).splitlines()
+        return lines, set(range(1, len(lines) + 1)), False
+    return lines, added, True
+
+
+def diff_added_lines(base, root=REPO_ROOT, include_untracked=True):
+    """Return {rel_path: set(added line numbers)} for everything added since
+    merge-base(base, HEAD), optionally including whole untracked C++ files."""
+    merge_base = git(root, "merge-base", base, "HEAD")
+    resolved = merge_base.stdout.strip() if merge_base.returncode == 0 else base
+    diff = git(root, "diff", "-U0", "--no-color", resolved)
+    if diff.returncode not in (0, 1):
+        sys.stderr.write(diff.stderr)
+        raise SystemExit(2)
+    per_file = added_lines_from_diff(diff.stdout)
+    if include_untracked:
+        untracked = git(root, "ls-files", "--others", "--exclude-standard")
+        for rel_path in untracked.stdout.splitlines():
+            if is_cxx_path(rel_path):
+                text = read_post_image(root, rel_path)
+                if text is not None:
+                    per_file.setdefault(rel_path, set()).update(range(1, len(text.splitlines()) + 1))
+    return per_file
+
+
+def as_ranges(numbers):
+    """Collapse a set of line numbers into sorted inclusive [start, end] pairs."""
+    ranges = []
+    for number in sorted(numbers):
+        if ranges and number == ranges[-1][1] + 1:
+            ranges[-1][1] = number
+        else:
+            ranges.append([number, number])
+    return ranges
+
+
+def line_filter_json(per_file):
+    """Build clang-tidy's --line-filter argument from {rel_path: line numbers}.
+
+    clang-tidy matches ``name`` as a path suffix and, when the filter is
+    non-empty, reports nothing for files it does not list — so the filter
+    doubles as the file filter.  Repository-relative paths are used rather
+    than bare basenames, which would collide across modules.
+    """
+    return json.dumps([{"name": rel_path, "lines": as_ranges(lines)}
+                       for rel_path, lines in sorted(per_file.items()) if lines])
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--line-filter", metavar="BASE", required=True,
+                        help="emit a clang-tidy --line-filter for lines added since merge-base(BASE, HEAD)")
+    parser.add_argument("paths", nargs="*", help="restrict the filter to these repository-relative paths")
+    args = parser.parse_args()
+    per_file = diff_added_lines(args.line_filter, include_untracked=False)
+    if args.paths:
+        wanted = set(args.paths)
+        per_file = {p: lines for p, lines in per_file.items() if p in wanted}
+    print(line_filter_json(per_file))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/test_affected_tests.py b/scripts/test_affected_tests.py
new file mode 100644
index 0000000..05e5988
--- /dev/null
+++ b/scripts/test_affected_tests.py
@@ -0,0 +1,579 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Unit tests for scripts/affected_tests.py.
+
+Runs against a synthetic source tree so the expectations do not drift as the
+real headers change, plus a few assertions against the checked-out tree that
+only depend on properties the selector must always hold.
+
+Usage: python3 scripts/test_affected_tests.py
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from affected_tests import (
+    IncludeGraph,
+    Selection,
+    changed_files_from_git,
+    full_suite,
+    select,
+    test_registrations,
+)
+
+FIXTURE = {
+    "Eigen/Core": '#include "src/Core/util/Meta.h"\n#include "src/Core/Block.h"\n',
+    "Eigen/Dense": '#include "Core"\n#include "SVD"\n',
+    "Eigen/SVD": '#include "Core"\n#include "src/SVD/BDCSVD.h"\n',
+    "Eigen/src/Core/util/Meta.h": "",
+    "Eigen/src/Core/Block.h": "",
+    "Eigen/src/SVD/BDCSVD.h": "",
+    "Eigen/src/Geometry/Quaternion.h": "",
+    "test/main.h": "#include <Eigen/Core>\n",
+    "test/block.cpp": '#include "main.h"\n',
+    "test/bdcsvd.cpp": '#include "main.h"\n#include <Eigen/SVD>\n',
+    "test/dense.cpp": '#include "main.h"\n#include <Eigen/Dense>\n',
+    "test/multitu.cpp": '#include "main.h"\n',
+    "test/multitu_main.cpp": '#include "main.h"\n',
+    "test/gpu_common.h": '#include "main.h"\n',
+    "test/gpu_basic.cu": '#include "gpu_common.h"\n',
+    "test/after_gpu.cpp": '#include "main.h"\n',
+    "test/CMakeLists.txt": """ei_add_test(block)
+ei_add_test(bdcsvd)
+ei_add_test(dense)
+add_executable(multitu multitu.cpp multitu_main.cpp)
+set(EIGEN_ADD_TEST_FILENAME_EXTENSION  "cu")
+ei_add_test(gpu_basic)
+unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
+ei_add_test(after_gpu)
+""",
+    # Standalone CMake projects, configured by test:linux:buildsystem alone.
+    # The two target names differ so that a source shared between them would
+    # be a duplicate registration if the scan looked at them at all.
+    "test/buildsystem/consumers/main.cpp": "#include <Eigen/Dense>\n",
+    "test/buildsystem/consumers/installed/CMakeLists.txt":
+        "add_executable(installed_consumer ../main.cpp)\n",
+    "test/buildsystem/consumers/subproject/CMakeLists.txt":
+        "add_executable(subproject_consumer ../main.cpp)\n",
+    "contrib/test/extra.cpp": '#include "../../test/main.h"\n',
+    "contrib/test/CMakeLists.txt": "ei_add_test(extra)\n",
+    "failtest/svd_int.cpp": "#include <Eigen/SVD>\n",
+    "failtest/const_block.cpp": "#include <Eigen/Core>\n",
+    "failtest/CMakeLists.txt": 'ei_add_failtest("svd_int")\nei_add_failtest("const_block")\n',
+}
+
+
+def build_fixture(root):
+    for rel, content in FIXTURE.items():
+        path = os.path.join(root, rel)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as handle:
+            handle.write(content)
+
+
+FAILURES = []
+
+
+def check(condition, message):
+    if condition:
+        return
+    FAILURES.append(message)
+    print("FAIL: %s" % message)
+
+
+def targets_of(selection):
+    return sorted(selection.targets)
+
+
+def test_fixture_graph(root):
+    graph = IncludeGraph(root)
+    sources = sorted(test_registrations(graph).targets)
+    check(sources == ["contrib/test/extra.cpp", "test/after_gpu.cpp", "test/bdcsvd.cpp",
+                      "test/block.cpp", "test/dense.cpp", "test/gpu_basic.cu",
+                      "test/multitu.cpp", "test/multitu_main.cpp"],
+          "test sources discovered in both trees, got %s" % sources)
+
+    # A leaf header reaches only the tests whose closure includes it.
+    sel = select(graph, ["Eigen/src/SVD/BDCSVD.h"])
+    check(sel.mode == "targets" and targets_of(sel) == ["bdcsvd", "dense"],
+          "BDCSVD.h selects bdcsvd and dense, got %s (%s)" % (targets_of(sel), sel.mode))
+
+    # A hub header reaches everything and degrades to the full suite.
+    sel = select(graph, ["Eigen/src/Core/util/Meta.h"])
+    check(sel.mode == "all", "Meta.h degrades to the full suite, got %s" % sel.mode)
+
+    # ... but not when the threshold allows the explicit list.
+    sel = select(graph, ["Eigen/src/Core/util/Meta.h"], max_fraction=1.0)
+    check(sel.mode == "targets" and len(sel.targets) == 7,
+          "Meta.h reaches all seven targets, got %s" % targets_of(sel))
+
+    # Umbrella indirection is followed: Dense -> SVD -> BDCSVD.h.
+    sel = select(graph, ["Eigen/Dense"])
+    check(sel.mode == "targets" and targets_of(sel) == ["dense"],
+          "Eigen/Dense selects only the test including it, got %s" % targets_of(sel))
+
+    # A header that no test reaches selects nothing.
+    sel = select(graph, ["Eigen/src/Geometry/Quaternion.h"])
+    check(sel.mode == "none", "an unreached header selects nothing, got %s" % sel.mode)
+
+    # A changed test source selects itself.
+    sel = select(graph, ["test/block.cpp"])
+    check(sel.mode == "targets" and targets_of(sel) == ["block"],
+          "a changed test selects itself, got %s" % targets_of(sel))
+
+    # Multi-translation-unit executables map every source to the registered
+    # target rather than assuming each basename is a target.
+    sel = select(graph, ["test/multitu_main.cpp"])
+    check(sel.mode == "targets" and targets_of(sel) == ["multitu"],
+          "a secondary translation unit selects its executable, got %s" % targets_of(sel))
+
+    # Documentation, benchmarks and metadata select nothing, including their
+    # own CMakeLists.txt -- which must not trip the full-rebuild rule.
+    sel = select(graph, ["doc/TopicLazyEvaluation.dox", "README.md", ".agents/ci.md",
+                         "benchmarks/Core/bench_reductions.cpp",
+                         "contrib/benchmarks/GPU/CMakeLists.txt",
+                         "doc/CMakeLists.txt", "debug/gdb/printers.py"])
+    check(sel.mode == "none", "docs and benchmarks select nothing, got %s (%s)"
+          % (sel.mode, sel.reasons))
+
+    # CMake and CI changes invalidate the mapping.
+    for path in ["CMakeLists.txt", "test/CMakeLists.txt", "cmake/EigenTesting.cmake",
+                 "ci/scripts/build.linux.script.sh", "ci/scripts/test_cache.py",
+                 "ci/docker/ubuntu-24.04-amd64-smoketest-run/Dockerfile",
+                 ".gitlab-ci.yml", "blas/level3_impl.h"]:
+        sel = select(graph, [path])
+        check(sel.mode == "all", "%s forces the full suite, got %s" % (path, sel.mode))
+
+    # The CI YAML is orchestration: it cannot change which test includes which
+    # header.  "none", not "all" -- these files are outside SCAN_ROOTS, so
+    # merely dropping them from FULL_REBUILD_PATTERNS would leave them falling
+    # through to "not in the include graph" and forcing the full suite anyway.
+    for path in ["ci/test.linux.gitlab-ci.yml", "ci/common.gitlab-ci.yml",
+                 "ci/build.linux.gitlab-ci.yml", "ci/CTest2JUnit.xsl", "ci/README.md"]:
+        sel = select(graph, [path])
+        check(sel.mode == "none", "%s selects nothing, got %s (%s)"
+              % (path, sel.mode, sel.reasons))
+
+    # An ignored CI path neither widens nor suppresses a real selection.
+    sel = select(graph, ["ci/test.linux.gitlab-ci.yml", "Eigen/src/SVD/BDCSVD.h"])
+    check(sel.mode == "targets" and "bdcsvd" in sel.targets,
+          "a CI YAML edit alongside a real change still selects bdcsvd, got %s %s"
+          % (sel.mode, sorted(sel.targets)))
+
+    # An unknown path (deleted or renamed away) is not guessed at.
+    sel = select(graph, ["Eigen/src/Core/util/Removed.h"])
+    check(sel.mode == "all", "an unknown path forces the full suite, got %s" % sel.mode)
+
+    # A new test source must not disappear as an unconfigured target if its
+    # CMake registration was forgotten.
+    new_test = os.path.join(root, "test", "brand_new.cpp")
+    with open(new_test, "w") as handle:
+        handle.write('#include "main.h"\n')
+    graph = IncludeGraph(root)
+    sel = select(graph, ["test/brand_new.cpp"])
+    check(sel.mode == "error", "an unregistered test source fails selection, got %s" % sel.mode)
+
+    # A full-suite change takes precedence regardless of path order; this is
+    # the normal path when a new source and its CMake registration land together.
+    sel = select(graph, ["test/brand_new.cpp", "test/CMakeLists.txt"])
+    check(sel.mode == "all", "CMake changes force the full suite before source validation")
+
+    with open(os.path.join(root, "test", "CMakeLists.txt"), "a") as handle:
+        handle.write("ei_add_test(brand_new)\n")
+    graph = IncludeGraph(root)
+    sel = select(graph, ["test/brand_new.cpp"])
+    check(sel.mode == "targets" and "brand_new" in sel.targets,
+          "a registered new test source is selected, got %s" % targets_of(sel))
+    os.remove(new_test)
+
+    # Mixed changes union their selections.
+    graph = IncludeGraph(root)
+    sel = select(graph, ["Eigen/src/SVD/BDCSVD.h", "contrib/test/extra.cpp"])
+    check(sel.mode == "targets" and targets_of(sel) == ["bdcsvd", "dense", "extra"],
+          "mixed changes union, got %s" % targets_of(sel))
+
+
+def test_buildsystem_fixtures(root):
+    """test/buildsystem/ registers nothing: it is not part of this build."""
+    graph = IncludeGraph(root)
+    registered = test_registrations(graph)
+    check("test/buildsystem/consumers/main.cpp" not in registered.targets,
+          "a buildsystem consumer is not a test translation unit")
+    check("installed_consumer" not in registered.standalone
+          and "subproject_consumer" not in registered.standalone,
+          "a buildsystem consumer is not a standalone target, got %s"
+          % sorted(registered.standalone))
+    check("consumer" not in full_suite(graph, []).targets_file,
+          "full mode does not name a target no configuration has, got %r"
+          % full_suite(graph, []).targets_file)
+
+    # Falling to "reaches no test" is the honest answer: test:linux:buildsystem
+    # covers these on every merge request through its own changes: rule.
+    sel = select(graph, ["test/buildsystem/consumers/main.cpp"])
+    check(sel.mode == "none",
+          "a buildsystem source reaches no test, got %s (%s)" % (sel.mode, sel.reasons))
+
+    # A .cpp there is not an unregistered test source either, so adding one
+    # must not fail the selection.
+    extra = os.path.join(root, "test", "buildsystem", "consumers", "extra.cpp")
+    with open(extra, "w") as handle:
+        handle.write("#include <Eigen/Core>\n")
+    try:
+        sel = select(IncludeGraph(root), ["test/buildsystem/consumers/extra.cpp"])
+        check(sel.mode == "none",
+              "a new buildsystem source is not an unregistered test, got %s" % sel.mode)
+    finally:
+        os.remove(extra)
+
+
+def test_failtests(root):
+    """The compile-failure suite is selected as CTest names, never as targets."""
+    graph = IncludeGraph(root)
+    registered = test_registrations(graph)
+    check(sorted(registered.failtests) == ["failtest/const_block.cpp", "failtest/svd_int.cpp"],
+          "failtests are discovered, got %s" % sorted(registered.failtests))
+    check(registered.failtests["failtest/svd_int.cpp"] == ("svd_int_ok", "svd_int_ko"),
+          "each failtest registers an _ok and a _ko CTest test")
+    check(not any(t.startswith("svd_int") for t in registered.targets.values()),
+          "failtests are not build targets")
+
+    # A changed failtest source runs itself and nothing else.  It has no build
+    # target: CTest compiles it as the test action.
+    sel = select(graph, ["failtest/svd_int.cpp"])
+    check(sel.mode == "targets" and targets_of(sel) == [],
+          "a failtest selects no build target, got %s" % targets_of(sel))
+    check(sorted(sel.ctest_names) == ["svd_int_ko", "svd_int_ok"],
+          "a failtest selects its CTest names, got %s" % sorted(sel.ctest_names))
+    check(sel.targets_file == "", "a failtest-only selection builds nothing, got %r"
+          % sel.targets_file)
+    check(sel.regex_file == "^(svd_int_ko|svd_int_ok)(_[0-9]+)?$\n",
+          "a failtest-only regex names both parts, got %r" % sel.regex_file)
+
+    # A header reaches its failtests through the same include closure as its
+    # tests, so both are selected together.
+    sel = select(graph, ["Eigen/src/SVD/BDCSVD.h"])
+    check(sel.mode == "targets" and targets_of(sel) == ["bdcsvd", "dense"],
+          "BDCSVD.h still selects its tests, got %s" % targets_of(sel))
+    check(sorted(sel.ctest_names) == ["svd_int_ko", "svd_int_ok"],
+          "BDCSVD.h also selects the failtest reaching it, got %s" % sorted(sel.ctest_names))
+    check(sel.regex_file == "^(bdcsvd|dense|svd_int_ko|svd_int_ok)(_[0-9]+)?$\n",
+          "targets and CTest-only names share one regex, got %r" % sel.regex_file)
+
+    # A failtest with no ei_add_failtest call is an error, like a test source
+    # with no registration.
+    orphan = os.path.join(root, "failtest", "orphan.cpp")
+    with open(orphan, "w") as handle:
+        handle.write("#include <Eigen/Core>\n")
+    try:
+        sel = select(IncludeGraph(root), ["failtest/orphan.cpp"])
+        check(sel.mode == "error",
+              "an unregistered failtest fails selection, got %s" % sel.mode)
+    finally:
+        os.remove(orphan)
+
+
+def test_cuda_registrations(root):
+    """ei_add_test compiles .cu while EIGEN_ADD_TEST_FILENAME_EXTENSION is set."""
+    graph = IncludeGraph(root)
+    registered = test_registrations(graph)
+    check(registered.targets.get("test/gpu_basic.cu") == "gpu_basic",
+          "a .cu test registers its own source, got %s"
+          % registered.targets.get("test/gpu_basic.cu"))
+    check("test/gpu_basic.cpp" not in registered.targets,
+          "the .cu registration does not synthesise a .cpp source")
+    check(registered.targets.get("test/after_gpu.cpp") == "after_gpu",
+          "unset restores the default extension, got %s"
+          % registered.targets.get("test/after_gpu.cpp"))
+
+    sel = select(graph, ["test/gpu_basic.cu"])
+    check(sel.mode == "targets" and targets_of(sel) == ["gpu_basic"],
+          "a changed .cu source selects its target, got %s (%s)"
+          % (targets_of(sel), sel.mode))
+
+    # A header only the .cu test includes must still reach it: a configuration
+    # without CUDA reports the target as unconfigured, which is not the same as
+    # reporting that no test is affected.
+    sel = select(graph, ["test/gpu_common.h"])
+    check(sel.mode == "targets" and targets_of(sel) == ["gpu_basic"],
+          "a GPU-only header selects the .cu test, got %s (%s)"
+          % (targets_of(sel), sel.mode))
+
+    # An unregistered .cu is an error, like an unregistered .cpp.
+    orphan = os.path.join(root, "test", "gpu_orphan.cu")
+    with open(orphan, "w") as handle:
+        handle.write('#include "main.h"\n')
+    try:
+        sel = select(IncludeGraph(root), ["test/gpu_orphan.cu"])
+        check(sel.mode == "error", "an unregistered .cu fails selection, got %s" % sel.mode)
+    finally:
+        os.remove(orphan)
+
+
+FOREACH_FIXTURE = {
+    "test/main.h": "",
+    "contrib/test/GPU/gpu_test_helpers.h": '#include "../../../test/main.h"\n',
+    "contrib/test/GPU/device_matrix.cpp": '#include "gpu_test_helpers.h"\n',
+    "contrib/test/GPU/cusolver_llt.cpp": '#include "gpu_test_helpers.h"\n',
+    "contrib/test/GPU/cusolver_qr.cpp": '#include "gpu_test_helpers.h"\n',
+    "contrib/test/GPU/from_variable.cpp": '#include "gpu_test_helpers.h"\n',
+    "contrib/test/GPU/unregistered.cpp": '#include "gpu_test_helpers.h"\n',
+    "contrib/test/GPU/CMakeLists.txt": """function(ei_add_gpu_test test_name)
+  ei_add_test(${test_name} "" "CUDA::cudart_static")
+  foreach(t ${_targets})
+    add_dependencies(buildtests_gpu ${t})
+  endforeach()
+endfunction()
+
+ei_add_gpu_test(device_matrix EXTRA_LIBS CUDA::cublas)
+
+foreach(_cusolver_test IN ITEMS cusolver_llt cusolver_qr)
+  ei_add_gpu_test(${_cusolver_test} EXTRA_LIBS CUDA::cusolver)
+endforeach()
+
+foreach(_computed IN LISTS SOME_LIST)
+  ei_add_gpu_test(${_computed})
+endforeach()
+""",
+}
+
+
+def test_foreach_registrations():
+    """GPU registrations are derived from the calls, including foreach items."""
+    root = tempfile.mkdtemp(prefix="eigen-affected-foreach-")
+    try:
+        for rel, content in FOREACH_FIXTURE.items():
+            path = os.path.join(root, rel)
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with open(path, "w") as handle:
+                handle.write(content)
+        graph = IncludeGraph(root)
+        sources = test_registrations(graph).targets
+
+        check(sources.get("contrib/test/GPU/device_matrix.cpp") == "device_matrix",
+              "a literal ei_add_gpu_test registers its source, got %s"
+              % sources.get("contrib/test/GPU/device_matrix.cpp"))
+        check(sources.get("contrib/test/GPU/cusolver_llt.cpp") == "cusolver_llt"
+              and sources.get("contrib/test/GPU/cusolver_qr.cpp") == "cusolver_qr",
+              "foreach(... IN ITEMS ...) expands to one registration per item, got %s"
+              % sorted(sources))
+
+        # ei_add_test(${test_name}) inside the wrapper's own body is a function
+        # parameter, not a loop item, so it must not register anything.
+        check("contrib/test/GPU/test_name.cpp" not in sources
+              and "test_name" not in set(sources.values()),
+              "the wrapper's own parameter is not a registration, got %s" % sorted(sources))
+
+        # A .cpp whose only registration iterates a variable, and one with no
+        # registration at all, must both reach the error path rather than being
+        # assumed registered because of where they live.
+        for path in ("contrib/test/GPU/from_variable.cpp",
+                     "contrib/test/GPU/unregistered.cpp"):
+            check(path not in sources, "%s is not registered, got %s" % (path, sources.get(path)))
+            sel = select(graph, [path])
+            check(sel.mode == "error",
+                  "%s fails selection, got %s (%s)" % (path, sel.mode, sel.reasons))
+
+        # The header the registered tests share still reaches them.
+        sel = select(graph, ["contrib/test/GPU/gpu_test_helpers.h"], max_fraction=1.0)
+        check(sel.mode == "targets"
+              and targets_of(sel) == ["cusolver_llt", "cusolver_qr", "device_matrix"],
+              "the GPU header reaches its registered tests, got %s (%s)"
+              % (targets_of(sel), sel.mode))
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def test_output_encoding():
+    sel = Selection("targets", ["adjoint", "bdcsvd"])
+    check(sel.targets_file == "adjoint\nbdcsvd\n",
+          "target list is newline separated, got %r" % sel.targets_file)
+    check(sel.regex_file == "^(adjoint|bdcsvd)(_[0-9]+)?$\n",
+          "regex matches every part, got %r" % sel.regex_file)
+
+    sel = Selection("targets", ["adjoint"], ctest_names=["x_ok", "x_ko"])
+    check(sel.targets_file == "adjoint\n",
+          "CTest-only names stay out of the target list, got %r" % sel.targets_file)
+    check(sel.regex_file == "^(adjoint|x_ko|x_ok)(_[0-9]+)?$\n",
+          "CTest-only names join the regex, got %r" % sel.regex_file)
+
+    check(Selection("all").targets_file == "buildtests\n", "full mode builds everything")
+    # buildtests does not aggregate a bare add_executable, so full mode has to
+    # name those targets or they stop being compiled.
+    check(Selection("all", standalone=["bug1213"]).targets_file == "buildtests\nbug1213\n",
+          "full mode names the targets buildtests omits, got %r"
+          % Selection("all", standalone=["bug1213"]).targets_file)
+    check(Selection("all").regex_file == "ALL\n", "full mode runs everything")
+    check(Selection("none").targets_file == "NONE\n", "empty mode builds nothing")
+    check(Selection("none").regex_file == "NONE\n", "empty mode runs nothing")
+
+
+def test_git_rename_paths():
+    root = tempfile.mkdtemp(prefix="eigen-affected-git-")
+    try:
+        old_path = os.path.join(root, "Eigen", "src", "Old.h")
+        new_path = os.path.join(root, "Eigen", "src", "New.h")
+        os.makedirs(os.path.dirname(old_path))
+        with open(old_path, "w") as handle:
+            handle.write("// test\n")
+        subprocess.run(["git", "init", "-q"], cwd=root, check=True)
+        subprocess.run(["git", "add", "Eigen/src/Old.h"], cwd=root, check=True)
+        subprocess.run(
+            ["git", "-c", "user.name=Eigen Tests", "-c", "user.email=eigen@example.com",
+             "commit", "-qm", "base"],
+            cwd=root,
+            check=True,
+        )
+        base = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=root, check=True, capture_output=True, text=True
+        ).stdout.strip()
+        os.rename(old_path, new_path)
+        subprocess.run(
+            ["git", "add", "Eigen/src/Old.h", "Eigen/src/New.h"], cwd=root, check=True
+        )
+        subprocess.run(
+            ["git", "-c", "user.name=Eigen Tests", "-c", "user.email=eigen@example.com",
+             "commit", "-qm", "rename"],
+            cwd=root,
+            check=True,
+        )
+        changed = changed_files_from_git(root, base)
+        check(changed == ["Eigen/src/New.h", "Eigen/src/Old.h"],
+              "renames expose both paths, got %s" % changed)
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def test_real_tree():
+    """Properties that must hold against the checked-out tree."""
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    if not os.path.isdir(os.path.join(root, "Eigen", "src")):
+        print("skipping real-tree checks: not an Eigen source tree")
+        return
+    graph = IncludeGraph(root)
+    registered = test_registrations(graph)
+    source_targets = registered.targets
+    check(len(source_targets) > 200,
+          "real tree has many test sources, got %d" % len(source_targets))
+
+    # Manual add_executable targets are named explicitly in full-suite selection.
+    # redux_bounded_compile is also a dependency of redux_bounded; bug1213 and
+    # ulp_accuracy have no aggregate. Asserted as an exact set, because a
+    # name that reaches this set without belonging in it makes the build jobs'
+    # "not configured in this build" diagnostic permanently non-empty.
+    check(registered.standalone == {"bug1213", "redux_bounded_compile", "ulp_accuracy"},
+          "unexpected standalone target set, got %s" % sorted(registered.standalone))
+    if "test/bug1213.cpp" in graph.files:
+        check("\nbug1213\n" in full_suite(graph, []).targets_file,
+              "full mode names bug1213, got %r" % full_suite(graph, []).targets_file)
+
+    check("redux_bounded_compile" in full_suite(graph, []).targets_file.splitlines(),
+          "full mode names redux_bounded_compile")
+    sel = select(graph, ["test/redux_bounded_compile.cpp"])
+    check(sel.mode == "targets" and sel.targets == {"redux_bounded_compile"},
+          "compile regression source selects its target, got %s (%s)"
+          % (sorted(sel.targets), sel.mode))
+
+    # test/buildsystem/ is under a test root but is not part of this build.
+    check(not any(rel.startswith("test/buildsystem/") for rel in source_targets),
+          "no buildsystem fixture is registered, got %s"
+          % sorted(rel for rel in source_targets if rel.startswith("test/buildsystem/")))
+
+    # The GPU tests are registered as .cu through EIGEN_ADD_TEST_FILENAME_EXTENSION.
+    # Configurations without CUDA report them as unconfigured; dropping them from
+    # the mapping instead would report that no test is affected at all.
+    if "test/gpu_basic.cu" in graph.files:
+        check(source_targets.get("test/gpu_basic.cu") == "gpu_basic",
+              "test/gpu_basic.cu maps to gpu_basic, got %s"
+              % source_targets.get("test/gpu_basic.cu"))
+        sel = select(graph, ["test/gpu_common.h"])
+        check(sel.mode == "targets" and "gpu_basic" in sel.targets,
+              "test/gpu_common.h reaches gpu_basic, got %s (%s)"
+              % (sorted(sel.targets), sel.mode))
+
+    # Every GPU module test is registered by a call the parser can see, so a
+    # source added without a registration reaches the error path.
+    gpu_dir = os.path.join(root, "contrib", "test", "GPU")
+    if os.path.isdir(gpu_dir):
+        gpu_sources = sorted("contrib/test/GPU/" + name for name in os.listdir(gpu_dir)
+                             if name.endswith(".cpp"))
+        unmapped = [rel for rel in gpu_sources if rel not in source_targets]
+        check(gpu_sources and not unmapped,
+              "every GPU test source is registered, got %s unmapped of %d"
+              % (unmapped, len(gpu_sources)))
+        check(source_targets.get("contrib/test/GPU/cusolver_svd.cpp") == "cusolver_svd",
+              "a foreach-registered GPU test maps to its target, got %s"
+              % source_targets.get("contrib/test/GPU/cusolver_svd.cpp"))
+        probe = os.path.join(gpu_dir, "affected_tests_probe.cpp")
+        with open(probe, "w") as handle:
+            handle.write('#include "gpu_test_helpers.h"\n')
+        try:
+            sel = select(IncludeGraph(root), ["contrib/test/GPU/affected_tests_probe.cpp"])
+            check(sel.mode == "error",
+                  "an unregistered GPU source fails selection, got %s" % sel.mode)
+        finally:
+            os.remove(probe)
+
+    # The compile-failure suite must stay reachable: it is filtered out by any
+    # -R regex that does not name it.
+    check(len(registered.failtests) > 50,
+          "real tree registers the failtest suite, got %d" % len(registered.failtests))
+    sel = select(graph, sorted(registered.failtests)[:1])
+    check(sel.mode == "targets" and sel.ctest_names,
+          "a changed failtest selects CTest names, got %s (%s)" % (sel.mode, sel.reasons))
+
+    # main.h is a hub: changing it must run everything.
+    sel = select(graph, ["test/main.h"])
+    check(sel.mode == "all", "test/main.h runs the full suite, got %s" % sel.mode)
+
+    # Private implementation headers may legitimately move.  While present,
+    # they must reach their focused test; broadening to the full suite is safe.
+    selections = []
+    for path, target in (("Eigen/src/Eigenvalues/RealQZ.h", "real_qz"),
+                         ("Eigen/src/SVD/BDCSVD.h", "bdcsvd")):
+        if path not in graph.files:
+            print("skipping real-tree check for absent private header %s" % path)
+            continue
+        sel = select(graph, [path])
+        selections.append(sel)
+        check(sel.mode in ("targets", "all"), "%s yields safe coverage, got %s" % (path, sel.mode))
+        if sel.mode == "targets":
+            check(target in sel.targets, "%s selects %s" % (path, target))
+
+    # Every selected name must come from a real CMake registration.
+    registered_targets = set(source_targets.values())
+    for sel in selections:
+        unknown = sorted(t for t in sel.targets if t not in registered_targets)
+        check(not unknown, "selected names are test sources, got %s" % unknown)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="eigen-affected-")
+    try:
+        build_fixture(root)
+        test_fixture_graph(root)
+        test_buildsystem_fixtures(root)
+        test_failtests(root)
+        test_cuda_registrations(root)
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+    test_foreach_registrations()
+    test_output_encoding()
+    test_git_rename_paths()
+    test_real_tree()
+
+    if FAILURES:
+        print("\n%d check(s) failed" % len(FAILURES))
+        return 1
+    print("all checks passed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/test_check_style.py b/scripts/test_check_style.py
new file mode 100644
index 0000000..b51fff1
--- /dev/null
+++ b/scripts/test_check_style.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Unit tests for scripts/check_style.py.
+
+Runs the checks on synthetic post-images, the diff parser on a crafted diff,
+and the diff mode against a temporary git repository, so the expectations do
+not depend on the checked-out tree.
+
+Usage: python3 scripts/test_check_style.py
+"""
+
+import os
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from check_style import (
+    added_from_structured_patch,
+    added_lines_from_diff,
+    find_findings,
+    hook_added_line_numbers,
+    run_diff_mode,
+)
+
+
+def messages(rel_path, text, added=None):
+    lines = text.splitlines()
+    if added is None:
+        added = set(range(1, len(lines) + 1))
+    return [m for _, m in find_findings(rel_path, lines, added)]
+
+
+def assert_flags(rel_path, text, *fragments, **kwargs):
+    got = messages(rel_path, text, kwargs.get("added"))
+    for fragment in fragments:
+        assert any(fragment in m for m in got), "expected %r in findings for %s, got %r" % (fragment, rel_path, got)
+
+
+def assert_clean(rel_path, text, added=None):
+    got = messages(rel_path, text, added)
+    assert not got, "expected no findings for %s, got %r" % (rel_path, got)
+
+
+def test_conventions_flagged():
+    assert_flags("Eigen/src/Core/Foo.h", "std::integral_constant<bool, true> b;\n", "bool_constant")
+    assert_flags("Eigen/src/Core/Foo.h", "enum { Flags = 0 };\n", "static constexpr")
+    assert_flags("Eigen/src/Core/Foo.h", "enum : unsigned int { Flags = 0 };\n", "static constexpr")
+    assert_flags("Eigen/src/Core/Foo.h", "enum : std::uint32_t { Flags = 0 };\n", "static constexpr")
+    assert_flags("Eigen/src/Core/Foo.h", "S s = {.size = 3};\n", "designated initializer")
+    assert_flags("Eigen/src/Core/Foo.h", "if constexpr (kSize > 4) {}\n", "EIGEN_IF_CONSTEXPR")
+    assert_flags("test/foo.cpp", "std::optional<int> x;\n", "C++17/20 library facility")
+    assert_flags("test/foo.cpp", "std::any x;\n", "C++17/20 library facility")
+    assert_flags("test/foo.cpp", "std::filesystem::path p;\n", "C++17/20 library facility")
+    assert_flags("Eigen/src/Core/Foo.h", "double x = std::sqrt(2.0);\n", "numext::")
+    assert_flags("Eigen/src/Core/Foo.h", "double x = (std::sqrt)(2.0);\n", "numext::")
+    assert_flags("Eigen/src/Core/Foo.h", "double x = std::exp2(2.0);\n", "numext::")
+    assert_flags("Eigen/src/Core/Foo.h", "double x = std::cbrt(2.0);\n", "numext::")
+    assert_flags("Eigen/src/Core/Foo.h", "double x = std::acosh(2.0);\n", "numext::")
+    assert_flags("Eigen/src/Core/Foo.h", "auto x = std::conj(value);\n", "numext::")
+    assert_flags("Eigen/src/Core/Foo.h", "double x = std::frexp(value, &exponent);\n", "EIGEN_USING_STD")
+
+
+def test_scoping():
+    # Eigen's public module headers are C++ despite having no extension.
+    assert_flags("Eigen/Core", "enum { Flags = 0 };\n", "static constexpr")
+    assert_flags("unsupported/Eigen/FFT", "if constexpr (kSize > 4) {}\n", "EIGEN_IF_CONSTEXPR")
+    # std:: math is only flagged in library implementation headers.
+    assert_clean("test/foo.cpp", "double x = std::sqrt(2.0);\n")
+    # C++14 checks do not apply outside the C++14 trees.
+    assert_clean("benchmarks/Core/foo.cpp", "if constexpr (kSize > 4) {}\n")
+    # Non-C++ files are ignored entirely.
+    assert_clean("AGENTS.md", "enum { Flags = 0 };\nif constexpr (x) {}\n")
+    # Only ADDED lines are reported: the same violations on unchanged lines stay silent.
+    assert_clean("Eigen/src/Core/Foo.h", "enum { Flags = 0 };\nint x = 1;\n", added={2})
+    # Sources with a documented C++17 requirement are exempt from the C++14 checks...
+    assert_clean("test/sycl_basic.cpp", "if constexpr (kSize > 4) {}\n")
+    assert_clean("Eigen/src/Core/arch/SYCL/PacketMath.h", "if constexpr (kSize > 4) {}\n")
+    assert_clean("contrib/Eigen/src/Tensor/TensorDeviceSycl.h", "if constexpr (kSize > 4) {}\n")
+    assert_clean("contrib/test/tensor_sycl.cpp", "if constexpr (kSize > 4) {}\n")
+    assert_clean("contrib/Eigen/src/FFT/duccfft_impl.h", "if constexpr (kSize > 4) {}\n")
+    assert_clean("contrib/test/duccfft.cpp", "if constexpr (kSize > 4) {}\n")
+    assert_clean("failtest/structured_bindings_dynamic_matrix.cpp", "if constexpr (kSize > 4) {}\n")
+    assert_clean("failtest/structured_bindings_dynamic_array.cpp", "if constexpr (kSize > 4) {}\n")
+    assert_clean("failtest/structured_bindings_rowmajor.cpp", "if constexpr (kSize > 4) {}\n")
+    # A coincidental substring is not a documented C++17 requirement.
+    assert_flags("test/not_sycl_related.cpp", "if constexpr (kSize > 4) {}\n", "EIGEN_IF_CONSTEXPR")
+    assert_flags("contrib/Eigen/src/FFT/kissfft_impl.h", "if constexpr (kSize > 4) {}\n", "EIGEN_IF_CONSTEXPR")
+    # ...but not from the other conventions.
+    assert_flags("test/sycl_basic.cpp", "std::integral_constant<bool, true> b;\n", "bool_constant")
+
+
+def test_false_positive_probes():
+    assert_clean("Eigen/src/Core/Foo.h", "opts.size = 4;\nfoo(a.b, c.d);\n")           # member access, not init
+    assert_clean("Eigen/src/Core/Foo.h", "double v[] = {.5, 1.5};\n")                  # float literal, not init
+    assert_clean("Eigen/src/Core/Foo.h", "enum class Kind { A, B };\n")                # scoped enums are fine
+    assert_clean("Eigen/src/Core/Foo.h", "enum Kind : unsigned int { A, B };\n")       # named enums are fine
+    assert_clean("Eigen/src/Core/Foo.h", 'auto s = "if constexpr integral_constant<bool,";\n')  # in a string
+    assert_clean("Eigen/src/Core/Foo.h", "const char c = 'N';\n")                      # character literal
+    assert_clean("Eigen/src/Core/Foo.h", "const wchar_t c = L'N';\n")                  # prefixed character literal
+    assert_clean("Eigen/src/Core/Foo.h", "// if constexpr discussed in a comment\nint x = 1;\n")
+    # A C++14 digit separator is not the start of a character literal; code
+    # later on the same line must remain visible to convention checks.
+    assert_flags("Eigen/src/Core/Foo.h", "auto n = 1'000; std::integral_constant<bool, true> b;\n",
+                 "bool_constant")
+    assert_flags("Eigen/src/Core/Foo.h", "auto n = 0xFF'00; std::integral_constant<bool, true> b;\n",
+                 "bool_constant")
+    assert_clean("Eigen/src/Core/Foo.h", "using MyInt = int;\nstatic constexpr unsigned int Flags = 0;\n"
+                                         "const char* p = nullptr;\nEIGEN_IF_CONSTEXPR (kSize > 4) {}\n"
+                                         "double x = numext::sqrt(2.0);\n")
+
+
+def test_multiline_designated_initializer():
+    # The designator on its own line after `{` or `,` is still a C++20 designated initializer.
+    assert_flags("Eigen/src/Core/Foo.h", "S s = {\n    .size = 3,\n};\n", "designated initializer")
+    assert_flags("Eigen/src/Core/Foo.h", "S s = {\n    .a = 1,\n    .b = 2,\n};\n", "designated initializer")
+    # A wrapped member assignment is not: the previous code line does not end with `{` or `,`.
+    assert_clean("Eigen/src/Core/Foo.h", "obj\n    .member = value;\n")
+    assert_clean("Eigen/src/Core/Foo.h", "foo(bar)\n    .field = 1;\n")
+
+
+def test_context_across_diff_gaps():
+    # An added continuation line inside an existing block comment is a comment,
+    # not code, even though the surrounding lines were not added.
+    text = "/* existing block\n * Do not use if constexpr here\n */\nint x = 1;\n"
+    assert_clean("Eigen/src/Core/Foo.h", text, added={2})
+    # Same for an existing Doxygen block: additions inherit its exemption.
+    doxy = "/** \\brief Existing docs.\n" + "\n".join(" * added line %d" % i for i in range(8)) + "\n */\nint x;\n"
+    assert_clean("Eigen/src/Core/Foo.h", doxy, added=set(range(2, 10)))
+    # A string on an unchanged line does not leak its content into added lines.
+    text = 'const char* s = "no /* here";\nstd::integral_constant<bool, true> b;\n'
+    assert_flags("Eigen/src/Core/Foo.h", text, "bool_constant", added={2})
+
+
+def test_comment_verbosity():
+    narration = "\n".join("// narration line %d" % i for i in range(6)) + "\nint x = 1;\n"
+    assert_flags("Eigen/src/Core/Foo.h", narration, "non-Doxygen comment")
+    # License headers and Doxygen blocks are exempt however long they are.
+    license_header = "\n".join("// SPDX-License-Identifier: MPL-2.0" if i == 0 else "// Copyright notice %d" % i
+                               for i in range(8)) + "\nint x = 1;\n"
+    assert_clean("Eigen/src/Core/Foo.h", license_header)
+    # A bibliography under its own header is provenance, exempt however long it runs.
+    refs = "// References:\n" + "\n".join("//  [%d] Author, \"Title\", 20%02d." % (i, i) for i in range(8))
+    assert_clean("Eigen/src/Core/Foo.h", refs + "\nint x = 1;\n")
+    # Prose that merely mentions references is still narration.
+    prose = "\n".join("// see the References: section for line %d" % i for i in range(6)) + "\nint x = 1;\n"
+    assert_flags("Eigen/src/Core/Foo.h", prose, "non-Doxygen comment")
+    # Five added lines stay under the threshold.
+    assert_clean("Eigen/src/Core/Foo.h", "\n".join("// l%d" % i for i in range(5)) + "\nint x = 1;\n")
+    # Extending an existing narration block by two lines is not reported: only
+    # ADDED lines count toward the threshold.
+    block = "\n".join("// old line %d" % i for i in range(10)) + "\n// new a\n// new b\nint x = 1;\n"
+    assert_clean("Eigen/src/Core/Foo.h", block, added={11, 12})
+    # Six added lines inside an existing non-Doxygen block are reported.
+    block = "// old line\n" + "\n".join("// new %d" % i for i in range(6)) + "\nint x = 1;\n"
+    assert_flags("Eigen/src/Core/Foo.h", block, "non-Doxygen comment", added=set(range(2, 8)))
+    # Blank physical lines and a closing line without a leading `*` remain
+    # inside their lexical block, but the blank line does not count as prose.
+    block = "/* first\nsecond\nthird\n\nfourth\nfifth\nsixth */\nint x = 1;\n"
+    assert_flags("Eigen/src/Core/Foo.h", block, "non-Doxygen comment")
+    # A blank line inside Doxygen must not split off the remaining lines and
+    # lose the exemption inherited from the opening delimiter.
+    doxy = "/** docs\n\nline one\nline two\nline three\nline four\nline five\nline six */\nint x = 1;\n"
+    assert_clean("Eigen/src/Core/Foo.h", doxy)
+    # An adjacent ordinary heading is a separate comment run and must not
+    # strip the exemption from the Doxygen block that follows it.
+    doxy = "// API documentation follows\n/** docs\nline one\nline two\nline three\nline four\nline five\nline six */\n"
+    assert_clean("Eigen/src/Core/Foo.h", doxy)
+    # The Doxygen kind is carried even when the opener follows code and is not
+    # itself a comment-only line.
+    trailing_doxy = ("int value; /**< docs\n * line one\n * line two\n * line three\n"
+                     " * line four\n * line five\n * line six */\n")
+    assert_clean("Eigen/src/Core/Foo.h", trailing_doxy)
+    # Conversely, ordinary narration immediately after Doxygen does not
+    # inherit its exemption.
+    narration = "/** short docs */\n" + "\n".join("// narration %d" % i for i in range(6)) + "\n"
+    assert_flags("Eigen/src/Core/Foo.h", narration, "non-Doxygen comment")
+
+
+def test_multiline_literals():
+    # Contents of a raw string spanning lines are literal, not code.
+    raw = 'const char* prog = R"cl(\nif constexpr (true) { std::optional<int> x; }\n)cl";\nint y = 1;\n'
+    assert_clean("Eigen/src/Core/Foo.h", raw)
+    # Code after the raw string closes is lexed again.
+    raw_then_code = 'auto s = R"(\ntext\n)"; std::integral_constant<bool, true> b;\n'
+    assert_flags("Eigen/src/Core/Foo.h", raw_then_code, "bool_constant")
+    # A backslash-spliced ordinary string stays a literal on its continuation lines.
+    spliced = 'const char* s = "first \\\nif constexpr (x) \\\nlast";\nint z = 1;\n'
+    assert_clean("Eigen/src/Core/Foo.h", spliced)
+    # A raw-string-looking suffix of an identifier is an ordinary string.
+    assert_clean("Eigen/src/Core/Foo.h", 'auto v = myR"(not raw)";\n')
+    # Single-line raw strings close on the same line.
+    assert_clean("Eigen/src/Core/Foo.h", 'auto s = R"(if constexpr NULL typedef)";\n')
+
+
+def test_hook_line_mapping():
+    content = "int x;\nint changed;\nconst char* p = NULL;\n"
+    # A snippet with a trailing newline covers only its own line, not the next.
+    assert hook_added_line_numbers(content, ["int changed;\n"]) == {2}
+    assert hook_added_line_numbers(content, ["int changed;"]) == {2}
+    # Multi-line snippets cover their span.
+    assert hook_added_line_numbers(content, ["int x;\nint changed;\n"]) == {1, 2}
+    # An ambiguous snippet cannot be located; the caller must fall back.
+    assert hook_added_line_numbers("true\nif constexpr (true)\n", ["true"]) is None
+    # An absent snippet likewise.
+    assert hook_added_line_numbers(content, ["not present"]) is None
+
+
+def test_structured_patch():
+    response = {"structuredPatch": [
+        {"oldStart": 4, "oldLines": 2, "newStart": 5, "newLines": 3,
+         "lines": [" context", "-old line", "+new one", "+new two", " context"]},
+    ]}
+    assert added_from_structured_patch(response) == {6, 7}
+    deletion_only = {"structuredPatch": [
+        {"oldStart": 1, "oldLines": 3, "newStart": 1, "newLines": 2,
+         "lines": [" context", "-removed", " context"]},
+    ]}
+    # A valid empty result must not fall back and mark the retained context.
+    deletion_added = added_from_structured_patch(deletion_only)
+    assert deletion_added == set()
+    assert_clean("Eigen/src/Core/Foo.h", "int keep;\nstd::integral_constant<bool, true> b;\n",
+                 added=deletion_added)
+    assert added_from_structured_patch({}) is None
+    assert added_from_structured_patch({"structuredPatch": "bogus"}) is None
+
+
+def test_diff_parser():
+    diff = (
+        "diff --git a/Eigen/src/Core/Foo.h b/Eigen/src/Core/Foo.h\n"
+        "--- a/Eigen/src/Core/Foo.h\n"
+        "+++ b/Eigen/src/Core/Foo.h\n"
+        "@@ -10,0 +11,2 @@ context\n"
+        "+const char* p = NULL;\n"
+        "+int y = 2;\n"
+        "@@ -20,1 +23,1 @@ context\n"
+        "-old line\n"
+        "+typedef int T;\n"
+        "diff --git a/gone.cpp b/gone.cpp\n"
+        "--- a/gone.cpp\n"
+        "+++ /dev/null\n"
+    )
+    files = added_lines_from_diff(diff)
+    assert set(files) == {"Eigen/src/Core/Foo.h"}, files
+    assert files["Eigen/src/Core/Foo.h"] == {11, 12, 23}, files
+
+
+def test_no_newline_marker():
+    # Replacing an unterminated last line: the "\ No newline" markers must not
+    # advance the line counter, or the addition maps past the post-image.
+    diff = (
+        "--- a/Eigen/src/Core/Foo.h\n"
+        "+++ b/Eigen/src/Core/Foo.h\n"
+        "@@ -1 +1 @@\n"
+        "-int old;\n"
+        "\\ No newline at end of file\n"
+        "+const char* p = NULL;\n"
+        "\\ No newline at end of file\n"
+    )
+    files = added_lines_from_diff(diff)
+    assert files["Eigen/src/Core/Foo.h"] == {1}, files
+    assert messages("Eigen/src/Core/Foo.h", "std::integral_constant<bool, true> b;", added={1})
+    response = {"structuredPatch": [
+        {"oldStart": 1, "oldLines": 1, "newStart": 1, "newLines": 1,
+         "lines": ["-int old;", "\\ No newline at end of file",
+                   "+const char* p = NULL;", "\\ No newline at end of file"]},
+    ]}
+    assert added_from_structured_patch(response) == {1}
+
+
+def test_diff_mode_merge_base_and_untracked():
+    with tempfile.TemporaryDirectory(prefix="check_style_test_") as tmp:
+        def sh(*args):
+            subprocess.run(args, cwd=tmp, check=True, capture_output=True)
+
+        def write(rel, text):
+            path = os.path.join(tmp, rel)
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with open(path, "w") as handle:
+                handle.write(text)
+
+        sh("git", "init", "-q", "-b", "main")
+        # The base carries a one-line file without a trailing newline, so the
+        # feature diff emits "\ No newline at end of file" markers.
+        write("Eigen/src/Core/NoEol.h", "int old;")
+        sh("git", "add", "Eigen/src/Core/NoEol.h")
+        sh("git", "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", "-m", "base")
+        sh("git", "branch", "target")
+        # Feature branch adds a violating file and replaces the unterminated line.
+        write("Eigen/src/Core/Added.h", "std::integral_constant<bool, true> b;\n")
+        write("Eigen/src/Core/NoEol.h", "enum { Flags = 0 };")
+        sh("git", "add", "Eigen/src/Core/Added.h", "Eigen/src/Core/NoEol.h")
+        sh("git", "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", "-m", "feature")
+        # Target advances independently with its own violating file: a
+        # two-tree diff against `target` would report it in reverse.
+        sh("git", "checkout", "-q", "target")
+        write("Eigen/src/Core/TargetOnly.h", "std::integral_constant<bool, false> legacy;\n")
+        sh("git", "add", "Eigen/src/Core/TargetOnly.h")
+        sh("git", "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-q", "-m", "target-only")
+        sh("git", "checkout", "-q", "main")
+        # An untracked new file must be scanned even though git diff omits it.
+        write("Eigen/src/Core/Untracked.h", "std::integral_constant<bool, true> b;\n")
+        write("Eigen/NewModule", "enum { Flags = 0 };\n")
+
+        results = run_diff_mode("target", root=tmp)
+        paths = {rel_path for rel_path, _, _ in results}
+        assert "Eigen/src/Core/Added.h" in paths, results
+        assert "Eigen/src/Core/Untracked.h" in paths, results
+        assert "Eigen/NewModule" in paths, results
+        assert "Eigen/src/Core/TargetOnly.h" not in paths, results
+        # The unterminated replacement maps to line 1 despite the markers.
+        noeol = [(l, m) for p, l, m in results if p == "Eigen/src/Core/NoEol.h"]
+        assert noeol and noeol[0][0] == 1 and "static constexpr" in noeol[0][1], results
+
+
+def main():
+    tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
+    for test in tests:
+        test()
+        print("PASS %s" % test.__name__)
+    print("%d tests passed" % len(tests))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/test_clang_tidy_hook.py b/scripts/test_clang_tidy_hook.py
new file mode 100644
index 0000000..65857b4
--- /dev/null
+++ b/scripts/test_clang_tidy_hook.py
@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Unit tests for scripts/clang_tidy_hook.py and scripts/style_common.py.
+
+The line-filter construction, umbrella resolution and target selection are
+tested against the real tree without invoking clang-tidy.  The end-to-end
+check does invoke it, and is skipped when clang-tidy is not installed.
+
+Usage: python3 scripts/test_clang_tidy_hook.py
+"""
+
+import io
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import clang_tidy_hook
+from clang_tidy_hook import (compile_args, cuda_include_dir, module_of, run_clang_tidy,
+                             tidy_target, umbrella_for)
+from style_common import REPO_ROOT, as_ranges, line_filter_json
+
+
+def test_as_ranges():
+    assert as_ranges(set()) == []
+    assert as_ranges({5}) == [[5, 5]]
+    # Consecutive numbers collapse; gaps start a new range.
+    assert as_ranges({1, 2, 3}) == [[1, 3]]
+    assert as_ranges({3, 1, 2, 7, 8, 20}) == [[1, 3], [7, 8], [20, 20]]
+
+
+def test_line_filter_json():
+    payload = json.loads(line_filter_json({"Eigen/src/Core/Block.h": {10, 11, 40}}))
+    assert payload == [{"name": "Eigen/src/Core/Block.h", "lines": [[10, 11], [40, 40]]}], payload
+    # Repository-relative paths, not basenames: `Block.h` alone would match any
+    # module's Block.h, since clang-tidy compares the name as a path suffix.
+    assert "/" in payload[0]["name"]
+    # A file with no added lines must not appear: an empty entry would be a
+    # filter that silences the file rather than one that reports nothing.
+    assert json.loads(line_filter_json({"a.h": set(), "b.h": {1}})) == [{"name": "b.h", "lines": [[1, 1]]}]
+
+
+def test_module_of():
+    assert module_of("Eigen/src/Core/Block.h") == "Core"
+    assert module_of("Eigen/src/Core/arch/AVX/PacketMath.h") == "Core"
+    assert module_of("contrib/Eigen/src/Tensor/TensorBlock.h") == "Tensor"
+    assert module_of("test/block.cpp") is None
+    assert module_of("Eigen/Core") is None
+
+
+def test_umbrella_resolution():
+    # Read from the module's InternalHeaderCheck.h `#error` directive.
+    assert umbrella_for("Eigen/src/Core/Block.h") == "Eigen/Core"
+    # The Tensor module's umbrella lives outside its own directory tree.
+    assert umbrella_for("contrib/Eigen/src/Tensor/TensorBlock.h") == "contrib/Eigen/Tensor"
+    # Arch backends nested below the module root carry no directive of their
+    # own and fall back to <root>/<Module>.
+    assert umbrella_for("Eigen/src/Core/arch/AVX/PacketMath.h") == "Eigen/Core"
+    # Modules needing a third-party header are skipped rather than guessed at.
+    assert umbrella_for("Eigen/src/CholmodSupport/CholmodSupport.h") is None
+    # Every module in the tree must resolve, or the hook silently skips files.
+    unresolved = []
+    for tree in ("Eigen/src", "contrib/Eigen/src"):
+        for module in sorted(os.listdir(os.path.join(REPO_ROOT, tree))):
+            rel = "%s/%s/InternalHeaderCheck.h" % (tree, module)
+            if not os.path.isfile(os.path.join(REPO_ROOT, rel)):
+                continue
+            if umbrella_for(rel) is None and module not in (
+                    "AccelerateSupport", "CholmodSupport", "KLUSupport", "MetisSupport",
+                    "PaStiXSupport", "PardisoSupport", "SPQRSupport", "SuperLUSupport",
+                    "UmfPackSupport"):
+                unresolved.append(rel)
+    assert not unresolved, unresolved
+
+
+def test_tidy_target():
+    with tempfile.TemporaryDirectory(prefix="tidy_target_test_") as tmp:
+        # A src-tree header is linted after its umbrella.  The explicit second
+        # include is needed for a new header the umbrella does not export yet.
+        driver = tidy_target("Eigen/src/Core/Block.h", tmp)
+        assert driver is not None and driver.startswith(tmp)
+        assert open(driver).read() == ("#include <Eigen/Core>\n"
+                                       "#include <Eigen/src/Core/Block.h>\n")
+        # An extensionless public module header is included directly.
+        driver = tidy_target("Eigen/Core", tmp)
+        assert open(driver).read() == "#include <Eigen/Core>\n"
+        # A test source is linted in place, not through a driver.
+        assert tidy_target("test/block.cpp", tmp) == os.path.join(REPO_ROOT, "test/block.cpp")
+        # A header outside the src trees has no reliable standalone TU.
+        assert tidy_target("test/main.h", tmp) is None
+        # An unresolvable module is skipped.
+        assert tidy_target("Eigen/src/CholmodSupport/CholmodSupport.h", tmp) is None
+
+
+def test_compile_args():
+    args = compile_args("Eigen/src/Core/Block.h")
+    assert "-std=c++14" in args and "-I" + REPO_ROOT in args
+    # Test sources include main.h from test/.
+    assert any(a.endswith("/test") for a in compile_args("test/block.cpp"))
+    assert any(a.endswith("/test") for a in compile_args("contrib/test/tensor_block_access.cpp"))
+    assert not any(a.endswith("/test") for a in compile_args("Eigen/src/Core/Block.h"))
+    # Contrib test sources include their umbrellas as <Eigen/Tensor>, which
+    # only resolves with contrib/ on the path; nothing else needs it.
+    assert any(a.endswith("/contrib") for a in compile_args("contrib/test/tensor_block_access.cpp"))
+    assert not any(a.endswith("/contrib") for a in compile_args("test/block.cpp"))
+    assert not any(a.endswith("/contrib") for a in compile_args("contrib/Eigen/src/Tensor/TensorBlock.h"))
+
+
+def test_cuda_include_dir():
+    saved = {name: os.environ.pop(name, None)
+             for name in ("CUDAToolkit_ROOT", "CUDA_HOME", "CUDA_PATH")}
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            include = os.path.join(tmpdir, "include")
+            os.makedirs(include)
+            absent = os.path.join(tmpdir, "absent")
+            os.environ["CUDA_HOME"] = tmpdir
+            assert cuda_include_dir(absent) is None, "an empty toolkit root must not be accepted"
+            with open(os.path.join(include, "cuda_runtime.h"), "w", encoding="utf-8") as handle:
+                handle.write("\n")
+            assert cuda_include_dir(absent) == include
+            assert compile_args("contrib/Eigen/src/GPU/DeviceMatrix.h")[-2:] == ["-isystem", include]
+    finally:
+        for name, value in saved.items():
+            if value is None:
+                os.environ.pop(name, None)
+            else:
+                os.environ[name] = value
+
+
+def test_end_to_end_line_filter():
+    """clang-tidy must report an added NULL and stay silent on legacy ones."""
+    if shutil.which("clang-tidy") is None:
+        print("SKIP test_end_to_end_line_filter (clang-tidy not installed)")
+        return
+    with tempfile.TemporaryDirectory(prefix="tidy_e2e_test_") as tmp:
+        header = os.path.join(tmp, "probe.h")
+        with open(header, "w") as handle:
+            handle.write("struct Probe {\n"
+                         "  typedef int Legacy;\n"      # line 2: pre-existing
+                         "  typedef int Added;\n"       # line 3: "added"
+                         "};\n")
+        source = os.path.join(tmp, "probe.cpp")
+        with open(source, "w") as handle:
+            handle.write('#include "probe.h"\n')
+        cmd = ["clang-tidy", "--quiet", "--checks=-*,modernize-use-using",
+               "--header-filter=probe\\.h",
+               "--line-filter=" + json.dumps([{"name": "probe.h", "lines": [[3, 3]]}]),
+               source, "--", "-std=c++14", "-I" + tmp]
+        out = subprocess.run(cmd, capture_output=True, text=True, timeout=60).stdout
+        hits = [line for line in out.splitlines() if "modernize-use-using" in line]
+        assert len(hits) == 1, "expected exactly the added line, got %r" % (hits,)
+        assert "probe.h:3:" in hits[0], hits
+
+
+def test_broken_translation_unit_is_not_reported_clean():
+    """A file that does not compile must be named, not silently passed."""
+    if shutil.which("clang-tidy") is None:
+        print("SKIP test_broken_translation_unit_is_not_reported_clean (clang-tidy not installed)")
+        return
+    with tempfile.TemporaryDirectory(prefix="tidy_broken_test_") as tmp:
+        os.makedirs(os.path.join(tmp, "test"))
+        # run_clang_tidy reads <root>/.clang-tidy, so the fake root needs one.
+        shutil.copyfile(os.path.join(REPO_ROOT, ".clang-tidy"), os.path.join(tmp, ".clang-tidy"))
+        source = os.path.join(tmp, "test", "broken.cpp")
+        with open(source, "w") as handle:
+            handle.write("int valid = 0;\nthis is not valid C++ at all @@@;\n")
+        diagnostics, skipped = run_clang_tidy({"test/broken.cpp": {2}}, root=tmp)
+        assert diagnostics == [], diagnostics
+        reasons = [reason for path, reason in skipped if path == "test/broken.cpp"]
+        assert reasons == ["translation unit did not compile"], skipped
+
+
+def test_hook_mode_reports_broken_unit_without_blocking():
+    """An uncompiled unit produces a non-blocking user notice, while a real
+    finding on an added line still blocks."""
+    payload = {"tool_name": "Write",
+               "tool_input": {"file_path": os.path.join(REPO_ROOT, "test", "probe.cpp"),
+                              "content": "int probe = 0;\n"}}
+
+    def run(diagnostics, skipped):
+        saved = (sys.stdin, sys.stdout, sys.stderr, clang_tidy_hook.hook_post_image_and_added,
+                 clang_tidy_hook.run_clang_tidy)
+        sys.stdin, sys.stdout, sys.stderr = (io.StringIO(json.dumps(payload)), io.StringIO(), io.StringIO())
+        clang_tidy_hook.hook_post_image_and_added = lambda *args: (["int probe = 0;"], {1}, True)
+        clang_tidy_hook.run_clang_tidy = lambda per_file, **kwargs: (diagnostics, skipped)
+        try:
+            return clang_tidy_hook.run_hook_mode(), sys.stdout.getvalue(), sys.stderr.getvalue()
+        finally:
+            (sys.stdin, sys.stdout, sys.stderr, clang_tidy_hook.hook_post_image_and_added,
+             clang_tidy_hook.run_clang_tidy) = saved
+
+    code, out, err = run([], [("test/probe.cpp", "translation unit did not compile")])
+    notice = json.loads(out)
+    assert code == 0 and "did not compile" in notice["systemMessage"] and not err, (code, out, err)
+    code, out, err = run(["test/probe.cpp:1:1: warning: use 'using' [modernize-use-using]"], [])
+    assert code == 2 and not out and "modernize-use-using" in err, (code, out, err)
+
+
+def test_new_src_header_is_checked():
+    """A private header absent from its umbrella must still be parsed."""
+    if shutil.which("clang-tidy") is None:
+        print("SKIP test_new_src_header_is_checked (clang-tidy not installed)")
+        return
+    with tempfile.TemporaryDirectory(prefix="tidy_new_header_test_") as tmp:
+        src = os.path.join(tmp, "Eigen", "src", "Core")
+        os.makedirs(src)
+        with open(os.path.join(tmp, ".clang-tidy"), "w") as handle:
+            handle.write("Checks: '-*,modernize-use-using'\n")
+        with open(os.path.join(tmp, "Eigen", "Core"), "w") as handle:
+            handle.write("#define EIGEN_CORE_MODULE_H\n")
+        with open(os.path.join(src, "InternalHeaderCheck.h"), "w") as handle:
+            handle.write("#ifndef EIGEN_CORE_MODULE_H\n"
+                         "#error \"Please include Eigen/Core instead of this file directly.\"\n"
+                         "#endif\n")
+        with open(os.path.join(src, "Added.h"), "w") as handle:
+            handle.write('#include "InternalHeaderCheck.h"\n'
+                         "typedef int AddedAlias;\n")
+
+        diagnostics, skipped = run_clang_tidy({"Eigen/src/Core/Added.h": {2}}, root=tmp)
+        assert not skipped, skipped
+        assert len(diagnostics) == 1 and "modernize-use-using" in diagnostics[0], diagnostics
+
+
+def test_contrib_test_source_is_checked():
+    """A contrib test source includes its module umbrella as <Eigen/X>,
+    which resolves only through contrib/; without that path every such
+    file was skipped as a translation unit that did not compile."""
+    if shutil.which("clang-tidy") is None:
+        print("SKIP test_contrib_test_source_is_checked (clang-tidy not installed)")
+        return
+    with tempfile.TemporaryDirectory(prefix="tidy_contrib_test_") as tmp:
+        os.makedirs(os.path.join(tmp, "contrib", "Eigen"))
+        os.makedirs(os.path.join(tmp, "contrib", "test"))
+        with open(os.path.join(tmp, ".clang-tidy"), "w") as handle:
+            handle.write("Checks: '-*,modernize-use-using'\n")
+        with open(os.path.join(tmp, "contrib", "Eigen", "Probe"), "w") as handle:
+            handle.write("#define EIGEN_PROBE_MODULE_H\n")
+        with open(os.path.join(tmp, "contrib", "test", "probe.cpp"), "w") as handle:
+            handle.write("#include <Eigen/Probe>\n"
+                         "typedef int AddedAlias;\n")
+
+        diagnostics, skipped = run_clang_tidy({"contrib/test/probe.cpp": {2}}, root=tmp)
+        assert not skipped, skipped
+        assert len(diagnostics) == 1 and "modernize-use-using" in diagnostics[0], diagnostics
+
+
+def test_binary_flag():
+    """--binary must be honored: a usage error in diff mode, fail-open in hook mode."""
+    script = os.path.join(REPO_ROOT, "scripts", "clang_tidy_hook.py")
+    done = subprocess.run([sys.executable, script, "--diff", "HEAD", "--binary", "no-such-clang-tidy"],
+                          capture_output=True, text=True)
+    assert done.returncode == 2 and "no-such-clang-tidy" in done.stderr, (done.returncode, done.stderr)
+    done = subprocess.run([sys.executable, script, "--claude-hook", "--binary", "no-such-clang-tidy"],
+                          input="{}", capture_output=True, text=True)
+    assert done.returncode == 0, (done.returncode, done.stderr)
+    # A resolvable path is used as given: /bin/false runs and fails, which
+    # run_clang_tidy reports per file (test_clang_tidy_failure_is_not_reported_clean).
+
+
+def test_clang_tidy_failure_is_not_reported_clean():
+    with tempfile.TemporaryDirectory(prefix="tidy_failure_test_") as tmp:
+        os.makedirs(os.path.join(tmp, "test"))
+        with open(os.path.join(tmp, ".clang-tidy"), "w") as handle:
+            handle.write("Checks: '-*'\n")
+        with open(os.path.join(tmp, "test", "probe.cpp"), "w") as handle:
+            handle.write("int probe;\n")
+        diagnostics, skipped = run_clang_tidy({"test/probe.cpp": {1}}, root=tmp, tidy="/bin/false")
+        assert diagnostics == [], diagnostics
+        assert skipped == [("test/probe.cpp", "clang-tidy failed")], skipped
+
+
+def test_failtest_is_checked_without_failure_macro():
+    """Failtests are linted as their successful compile, not their _ko target."""
+    if shutil.which("clang-tidy") is None:
+        print("SKIP test_failtest_is_checked_without_failure_macro (clang-tidy not installed)")
+        return
+    with tempfile.TemporaryDirectory(prefix="tidy_failtest_test_") as tmp:
+        os.makedirs(os.path.join(tmp, "failtest"))
+        with open(os.path.join(tmp, ".clang-tidy"), "w") as handle:
+            handle.write("Checks: '-*,modernize-use-using'\n")
+        with open(os.path.join(tmp, "failtest", "probe.cpp"), "w") as handle:
+            handle.write("#ifdef EIGEN_SHOULD_FAIL_TO_BUILD\n"
+                         "this is intentionally invalid;\n"
+                         "#endif\n"
+                         "typedef int AddedAlias;\n")
+
+        diagnostics, skipped = run_clang_tidy({"failtest/probe.cpp": {4}}, root=tmp)
+        assert not skipped, skipped
+        assert len(diagnostics) == 1 and "modernize-use-using" in diagnostics[0], diagnostics
+
+
+def main():
+    tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
+    for test in tests:
+        test()
+        print("PASS %s" % test.__name__)
+    print("%d tests passed" % len(tests))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/test_tidy_compile_db.py b/scripts/test_tidy_compile_db.py
new file mode 100644
index 0000000..9a80dd6
--- /dev/null
+++ b/scripts/test_tidy_compile_db.py
@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Unit tests for scripts/tidy_compile_db.py.
+
+The reduction decides what clang-tidy parses, so the cases that matter are the
+ones where dropping an entry would drop an added line with it: a split part
+selected by a guard rather than by the added text, several parts named at once,
+and a second build configuration of the same source.  Synthetic databases keep
+the tests independent of a configured build directory; one case reads
+`test/bdcsvd.cpp` from the tree so the guard shapes stay real.
+
+Usage: python3 scripts/test_tidy_compile_db.py
+"""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from style_common import REPO_ROOT  # noqa: E402
+from tidy_compile_db import (MAX_PARTS, added_lines, configuration_of, part_of,  # noqa: E402
+                             reduce_entries, required_parts, summarize)
+
+SCRIPT = os.path.join(REPO_ROOT, "scripts", "tidy_compile_db.py")
+
+
+def entry(source, part=None, extra=(), output="obj"):
+    """A compilation-database entry the way CMake's Ninja generator writes one."""
+    flags = " ".join(list(extra) + (["-DEIGEN_TEST_PART_%s=1" % part] if part else []))
+    return {"directory": "/build", "file": source,
+            "command": "/usr/bin/c++ %s -I/repo -std=c++14 -o %s -c %s" % (flags, output, source),
+            "output": output}
+
+
+def parts_kept(matches, text, lines):
+    keep, _, _ = reduce_entries(matches, text, lines)
+    return [part_of(kept) for kept in keep]
+
+
+def test_part_define_does_not_distinguish_configurations():
+    """Entries differing only in the part share one configuration."""
+    first = entry("/repo/test/t.cpp", part="1", output="t_1.o")
+    second = entry("/repo/test/t.cpp", part="2", output="t_2.o")
+    assert configuration_of(first) == configuration_of(second)
+    assert part_of(first) == "1" and part_of(second) == "2"
+    # A macro that is not a part define does distinguish them, and so does no
+    # define at all.
+    shared = entry("/repo/blas/b.cpp", extra=["-DEIGEN_BLAS_BUILD_DLL", "-fPIC"])
+    assert configuration_of(shared) != configuration_of(entry("/repo/blas/b.cpp"))
+
+
+def test_unguarded_lines_collapse_to_one_part():
+    matches = [entry("/repo/test/t.cpp", part=str(n), output="t_%d.o" % n) for n in (1, 2, 3)]
+    text = "void f() {\n  int i = 0;\n}\n"
+    assert parts_kept(matches, text, [2]) == ["1"], parts_kept(matches, text, [2])
+
+
+def test_guarded_line_selects_its_part():
+    """The added text names no part; the guard around it does.
+
+    This is the case a scan of the diff alone gets wrong: with part 1 selected,
+    the preprocessor removes the whole changed region.
+    """
+    matches = [entry("/repo/test/t.cpp", part=str(n), output="t_%d.o" % n) for n in (1, 2, 3)]
+    text = ("#if defined(EIGEN_TEST_PART_3) || defined(EIGEN_TEST_PART_ALL)\n"
+            "void guarded() { int* p = 0; }\n"
+            "#endif\n")
+    assert parts_kept(matches, text, [2]) == ["3"]
+
+
+def test_every_named_part_is_retained():
+    """Additions naming two parts keep both, not just the first."""
+    matches = [entry("/repo/test/t.cpp", part=str(n), output="t_%d.o" % n) for n in (1, 2, 3)]
+    text = ("void run() {\n"
+            "  CALL_SUBTEST_1(f<int>());\n"
+            "  CALL_SUBTEST_2(g<int>());\n"
+            "}\n")
+    assert parts_kept(matches, text, [2, 3]) == ["1", "2"]
+
+
+def test_multi_line_call_subtest_covers_its_continuation():
+    matches = [entry("/repo/test/t.cpp", part=str(n), output="t_%d.o" % n) for n in (1, 2)]
+    text = ("void run() {\n"
+            "  CALL_SUBTEST_2((f<Matrix<float, 1, 1>,\n"
+            "                    int>()));\n"
+            "}\n")
+    # Line 3 carries no part of its own; it is inside part 2's invocation.
+    assert parts_kept(matches, text, [3]) == ["2"]
+
+
+def test_elif_chain_and_else_branch():
+    text = ("#if defined EIGEN_TEST_PART_1\n"
+            "int first;\n"
+            "#elif defined EIGEN_TEST_PART_2\n"
+            "int second;\n"
+            "#else\n"
+            "int rest;\n"
+            "#endif\n")
+    universe = frozenset(["1", "2", "3"])
+    assert required_parts(text, [2], universe) == [frozenset(["1"])]
+    assert required_parts(text, [4], universe) == [frozenset(["2"])]
+    # The `#else` is compiled by every part the branches above did not claim.
+    assert required_parts(text, [6], universe) == [frozenset(["3"])]
+
+
+def test_guard_condition_spanning_continuation_lines():
+    text = ("#if defined(EIGEN_TEST_PART_2) || \\\n"
+            "    defined(EIGEN_TEST_PART_3)\n"
+            "int guarded;\n"
+            "#endif\n")
+    universe = frozenset(["1", "2", "3"])
+    assert required_parts(text, [3], universe) == [frozenset(["2", "3"])]
+
+
+def test_condition_that_only_restricts_other_macros():
+    """A guard naming no part constrains no part, inside or after it."""
+    text = ("#ifdef __clang__\n"
+            "int a;\n"
+            "#else\n"
+            "int b;\n"
+            "#endif\n"
+            "int c;\n")
+    universe = frozenset(["1", "2"])
+    assert required_parts(text, [2, 4, 6], universe) == [universe, universe, universe]
+
+
+def test_nested_guards_intersect():
+    text = ("#if defined(EIGEN_TEST_PART_1) || defined(EIGEN_TEST_PART_2)\n"
+            "#ifndef EIGEN_TEST_PART_2\n"
+            "int only_one;\n"
+            "#endif\n"
+            "#endif\n")
+    assert required_parts(text, [3], frozenset(["1", "2", "3"])) == [frozenset(["1"])]
+
+
+def test_cap_reports_the_parts_it_leaves_out():
+    count = MAX_PARTS + 2
+    matches = [entry("/repo/test/t.cpp", part=str(n), output="t_%d.o" % n)
+               for n in range(1, count + 1)]
+    text = "void run() {\n" + "".join("  CALL_SUBTEST_%d(f());\n" % n
+                                      for n in range(1, count + 1)) + "}\n"
+    lines = list(range(2, count + 2))
+    keep, skipped, unreachable = reduce_entries(matches, text, lines)
+    assert len(keep) == MAX_PARTS, len(keep)
+    assert len(skipped) == count - MAX_PARTS, skipped
+    assert not unreachable
+    # A capped run must say so rather than report the file as clean.
+    report = summarize(matches, keep, skipped, unreachable)
+    assert "NOT CHECKED" in report and skipped[0] in report, report
+
+
+def test_lines_no_configured_part_compiles_are_reported():
+    matches = [entry("/repo/test/t.cpp", part=str(n), output="t_%d.o" % n) for n in (1, 2)]
+    text = ("#if defined(EIGEN_TEST_PART_ALL)\n"
+            "int unbuilt;\n"
+            "#endif\n")
+    keep, skipped, unreachable = reduce_entries(matches, text, [2])
+    assert unreachable == 1 and not skipped
+    assert "no configured part" in summarize(matches, keep, skipped, unreachable)
+
+
+def test_distinct_configurations_are_all_kept():
+    """The static and shared builds of a BLAS source parse different code."""
+    static = entry("/repo/blas/b.cpp", output="static.o")
+    shared = entry("/repo/blas/b.cpp", extra=["-DEIGEN_BLAS_BUILD_DLL", "-fPIC"], output="shared.o")
+    matches = [static, shared]
+    text = ("#if defined(EIGEN_BLAS_BUILD_DLL)\n"
+            "typedef int OnlyInTheSharedBuild;\n"
+            "#endif\n")
+    keep, skipped, unreachable = reduce_entries(matches, text, [2])
+    assert keep == matches, keep
+    assert not skipped and not unreachable
+    assert summarize(matches, keep, skipped, unreachable) == ""
+
+
+def test_configurations_and_parts_combine():
+    """Each configuration keeps its own part selection."""
+    matches = ([entry("/repo/test/t.cpp", part=str(n), output="plain_%d.o" % n) for n in (1, 2)]
+               + [entry("/repo/test/t.cpp", part=str(n), extra=["-DEIGEN_DONT_VECTORIZE"],
+                        output="novec_%d.o" % n) for n in (1, 2)])
+    text = ("void run() {\n"
+            "  CALL_SUBTEST_2(f());\n"
+            "}\n")
+    keep, _, _ = reduce_entries(matches, text, [2])
+    assert [(part_of(kept), kept["output"]) for kept in keep] == [("2", "plain_2.o"),
+                                                                  ("2", "novec_2.o")]
+
+
+def test_bdcsvd_guard_in_the_real_tree():
+    """The tree's own `EIGEN_TEST_PART_53` block, as the review reported it."""
+    path = os.path.join(REPO_ROOT, "test", "bdcsvd.cpp")
+    with open(path, encoding="utf-8") as handle:
+        text = handle.read()
+    lines = text.splitlines()
+    guarded = next(number for number, line in enumerate(lines, 1)
+                   if line.startswith("void bdcsvd_extreme_scale_regressions"))
+    universe = frozenset(str(n) for n in range(1, 60))
+    assert required_parts(text, [guarded], universe) == [frozenset(["53"])], guarded
+
+
+def test_added_lines_expands_the_line_filter():
+    assert added_lines('[{"name": "test/t.cpp", "lines": [[3, 5], [9, 9]]}]') == [3, 4, 5, 9]
+    assert added_lines("[]") == []
+
+
+def test_command_line_writes_the_reduced_database():
+    with tempfile.TemporaryDirectory(prefix="tidy_compile_db_test_") as tmp:
+        source = os.path.join(tmp, "t.cpp")
+        with open(source, "w") as handle:
+            handle.write("#if defined(EIGEN_TEST_PART_3)\nint guarded;\n#endif\n")
+        database = os.path.join(tmp, "compile_commands.json")
+        with open(database, "w") as handle:
+            json.dump([entry(source, part=str(n), output="t_%d.o" % n) for n in (1, 2, 3)], handle)
+        outdir = os.path.join(tmp, "reduced")
+
+        line_filter = json.dumps([{"name": "t.cpp", "lines": [[2, 2]]}])
+        done = subprocess.run([sys.executable, SCRIPT, database, source, outdir, line_filter],
+                              capture_output=True, text=True)
+        assert done.returncode == 0, done
+        with open(os.path.join(outdir, "compile_commands.json")) as handle:
+            reduced = json.load(handle)
+        assert [part_of(kept) for kept in reduced] == ["3"], reduced
+        assert "checking part 3" in done.stdout, done.stdout
+
+        # A source outside the database is reported by exit status, not output.
+        done = subprocess.run([sys.executable, SCRIPT, database, os.path.join(tmp, "other.cpp"),
+                               outdir, line_filter], capture_output=True, text=True)
+        assert done.returncode == 1, done
+
+        # An unreadable database is fatal, so the caller can stop rather than
+        # silently check nothing.
+        done = subprocess.run([sys.executable, SCRIPT, source, source, outdir, line_filter],
+                              capture_output=True, text=True)
+        assert done.returncode == 2, done
+
+
+def main():
+    tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
+    for test in tests:
+        test()
+        print("PASS %s" % test.__name__)
+    print("%d tests passed" % len(tests))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/tidy_compile_db.py b/scripts/tidy_compile_db.py
new file mode 100644
index 0000000..bb39a7a
--- /dev/null
+++ b/scripts/tidy_compile_db.py
@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+"""Narrow a compilation database to the entries a changed source needs.
+
+``ci/scripts/run-clang-tidy.sh`` checks a changed source through the build
+directory's ``compile_commands.json``.  clang-tidy parses the file once per
+entry naming it, and a split test contributes one entry per ``EIGEN_TEST_PART``
+-- 17 for ``test/eigensolver_selfadjoint.cpp``, 41 for ``test/array_cwise.cpp``,
+at roughly a minute and 3 GB each.  A merge request touching such a file spends
+the job's entire timeout on it, and every file after it goes unchecked without
+saying so.
+
+Two entries are interchangeable only when they differ solely in which
+``-DEIGEN_TEST_PART_<n>`` they define.  ``blas/complexdots.cpp`` is compiled
+both into the static library and, with ``-DEIGEN_BLAS_BUILD_DLL``, into the
+shared one; code that only the second configuration enables is parsed only by
+the second entry.  Entries are therefore grouped by the arguments that affect
+parsing, every group keeps a representative, and only inside a group is a part
+chosen.
+
+Within a group the part matters exactly where the source asks for it.  A line
+inside a ``CALL_SUBTEST_<n>(...)`` invocation or an
+``#if defined(EIGEN_TEST_PART_<n>)`` guard exists only when part ``<n>`` is
+defined -- the split helper expands the invocation to nothing otherwise.  Every
+other line is parsed under any part, because the checks ``.clang-tidy`` enables
+are syntactic: they fire on declarations rather than on template
+instantiations.  So each added line is mapped to the parts that can compile it,
+and the smallest set of entries covering all of them is retained, up to
+``MAX_PARTS``.  Whatever that leaves unchecked is named on stdout: reporting a
+file clean without having parsed it is the failure this replaces.
+
+Usage: tidy_compile_db.py <database> <source> <outdir> <line-filter>
+
+``<line-filter>`` is the clang-tidy ``--line-filter`` argument that
+``scripts/style_common.py`` builds for the same source.  Writes the reduced
+database to ``<outdir>/compile_commands.json`` and prints a one-line summary
+when it dropped anything.  Exits 0 when the source is in the database, 1 when
+it is not, and 2 when the database cannot be read.
+"""
+
+import bisect
+import json
+import os
+import re
+import shlex
+import sys
+
+# A part costs about a minute and 2 GB, against a 15 minute job budget shared
+# with every other changed file, so cover as many parts as a diff needs only up
+# to this many.  Beyond it the summary line names the parts left unchecked
+# rather than letting the job run into its timeout, which is the silent failure
+# this whole reduction exists to remove.
+MAX_PARTS = 4
+
+# Arguments that name an output rather than describe the parse. They differ per
+# split part (`bdcsvd_1.dir` against `bdcsvd_2.dir`) and would defeat grouping.
+_VALUE_ARGS = ("-o", "-MT", "-MF", "-MQ", "-MJ")
+_OUTPUT_FLAGS = ("-c", "-MD", "-MMD", "-MP")
+_PART_DEFINE = re.compile(r"^-DEIGEN_TEST_PART_([0-9]+)(=.*)?$")
+_PART_ARG = re.compile(r"-DEIGEN_TEST_PART_([0-9]+)\b")
+_DIRECTIVE = re.compile(r"[ \t]*#[ \t]*(if|ifdef|ifndef|elif|else|endif)\b(.*)")
+_PART_MENTION = re.compile(r"(!\s*)?EIGEN_TEST_PART_([0-9]+|ALL)\b")
+_DEFINED_CALL = re.compile(r"defined\s*\(\s*([A-Za-z_]\w*)\s*\)")
+_DEFINED_BARE = re.compile(r"defined\s+([A-Za-z_]\w*)")
+_CALL_SUBTEST = re.compile(r"\bCALL_SUBTEST_([0-9]+)\s*\(")
+
+
+def arguments_of(entry):
+    """The compile command of a database entry, as an argument list."""
+    command = entry.get("command")
+    if command:
+        return shlex.split(command)
+    return list(entry.get("arguments", ()))
+
+
+def part_of(entry):
+    """The ``EIGEN_TEST_PART`` an entry defines, as a string, or None."""
+    found = _PART_ARG.search(entry.get("command") or " ".join(entry.get("arguments", ())))
+    return found.group(1) if found else None
+
+
+def configuration_of(entry):
+    """The arguments of an entry that affect how the source is parsed.
+
+    Output paths and the part define are excluded, so entries that differ only
+    in which part they build compare equal and nothing else does.
+    """
+    configuration = []
+    skip = False
+    for argument in arguments_of(entry):
+        if skip:
+            skip = False
+        elif argument in _VALUE_ARGS:
+            skip = True
+        elif argument in _OUTPUT_FLAGS or (argument.startswith("-o") and len(argument) > 2):
+            continue
+        elif not _PART_DEFINE.match(argument):
+            configuration.append(argument)
+    return tuple(configuration)
+
+
+def entries_for(commands, source):
+    """The database entries compiling ``source``, in database order."""
+    source = os.path.realpath(source)
+    matches = []
+    for entry in commands:
+        if not isinstance(entry, dict):
+            continue
+        path = entry.get("file")
+        if not path:
+            continue
+        if not os.path.isabs(path):
+            path = os.path.join(entry.get("directory", ""), path)
+        if os.path.realpath(path) == source:
+            matches.append(entry)
+    return matches
+
+
+def _part_mentions(condition, negated=False):
+    """The parts a preprocessor condition names, split by sense.
+
+    ``defined`` is elided first so a mention is negated exactly when a ``!``
+    precedes it.  ``EIGEN_TEST_PART_ALL`` is one of the mentions: no entry of a
+    split test defines it, so a branch that only it can reach is compiled by no
+    part rather than by every part.
+    """
+    text = _DEFINED_CALL.sub(r"\1", condition)
+    text = _DEFINED_BARE.sub(r"\1", text)
+    positive, negative = set(), set()
+    for mention in _PART_MENTION.finditer(text):
+        target = negative if bool(mention.group(1)) != negated else positive
+        target.add(mention.group(2))
+    return positive, negative
+
+
+def _branch(positive, negative, universe):
+    """The parts under which a branch with these mentions is compiled.
+
+    A positive mention is the binding one: ``defined(EIGEN_TEST_PART_3) && X``
+    still needs part 3, and ``defined(EIGEN_TEST_PART_3) || X`` is at least
+    compiled under part 3, which is all the caller needs to reach the line.
+    """
+    if positive:
+        return universe & positive
+    if negative:
+        return universe - negative
+    return universe
+
+
+def guard_constraints(lines, universe):
+    """Map each 1-based line number to the parts its ``#if`` guards allow."""
+    per_line = [universe] * (len(lines) + 2)
+    cumulative = [universe]
+    # Parts already claimed by an earlier branch of each open conditional, so
+    # that an `#else` can exclude them.
+    taken = []
+    index = 0
+    while index < len(lines):
+        first = index
+        directive = _DIRECTIVE.match(lines[index])
+        condition = ""
+        if directive:
+            condition = directive.group(2)
+            while condition.rstrip().endswith("\\") and index + 1 < len(lines):
+                index += 1
+                condition = condition.rstrip()[:-1] + lines[index]
+        for number in range(first + 1, index + 2):
+            per_line[number] = cumulative[-1]
+        if directive:
+            keyword = directive.group(1)
+            if keyword in ("if", "ifdef", "ifndef"):
+                positive, negative = _part_mentions(condition, negated=keyword == "ifndef")
+                branch = _branch(positive, negative, universe)
+                taken.append(branch if positive or negative else frozenset())
+                cumulative.append(cumulative[-1] & branch)
+            elif keyword in ("elif", "else") and taken:
+                cumulative.pop()
+                if keyword == "elif":
+                    positive, negative = _part_mentions(condition)
+                    branch = _branch(positive, negative, universe)
+                    taken[-1] = taken[-1] | (branch if positive or negative else frozenset())
+                else:
+                    branch = universe - taken[-1]
+                cumulative.append(cumulative[-1] & branch)
+            elif keyword == "endif" and taken:
+                taken.pop()
+                cumulative.pop()
+        index += 1
+    return per_line
+
+
+def call_constraints(text, universe):
+    """Map each 1-based line number to the parts its ``CALL_SUBTEST`` allows.
+
+    A line can carry more than one invocation, in which case either part
+    compiles part of it.
+    """
+    starts = [0] + [newline.end() for newline in re.finditer(r"\n", text)]
+    per_line = {}
+    for call in _CALL_SUBTEST.finditer(text):
+        depth, offset = 1, call.end()
+        while offset < len(text) and depth:
+            if text[offset] == "(":
+                depth += 1
+            elif text[offset] == ")":
+                depth -= 1
+            offset += 1
+        first = bisect.bisect_right(starts, call.start())
+        last = bisect.bisect_right(starts, offset - 1)
+        allowed = universe & {call.group(1)}
+        for number in range(first, last + 1):
+            per_line[number] = per_line.get(number, frozenset()) | allowed
+    return per_line
+
+
+def required_parts(text, lines, universe):
+    """The parts that can compile each of ``lines``, as a list of sets."""
+    source_lines = text.splitlines()
+    guards = guard_constraints(source_lines, universe)
+    calls = call_constraints(text, universe)
+    return [guards[number] & calls.get(number, universe)
+            for number in lines if number < len(guards)]
+
+
+def select_parts(required, order, limit=MAX_PARTS):
+    """The smallest set of parts covering ``required``, capped at ``limit``.
+
+    Returns the chosen parts and the requirements the cap left uncovered. Ties
+    go to the part the database lists first, which is what a diff that names no
+    part at all gets.
+    """
+    chosen = []
+    uncovered = [need for need in required if need]
+    while uncovered and len(chosen) < limit:
+        counts = {}
+        for need in uncovered:
+            for part in need:
+                counts[part] = counts.get(part, 0) + 1
+        best = min(counts, key=lambda part: (-counts[part], order.index(part)))
+        chosen.append(best)
+        uncovered = [need for need in uncovered if best not in need]
+    return chosen, uncovered
+
+
+def reduce_entries(matches, text, lines):
+    """The entries of ``matches`` needed to parse ``lines`` of ``text``.
+
+    Returns the retained entries in database order, the parts the cap left out,
+    and how many added lines no configured part compiles at all.
+    """
+    groups = {}
+    for index, entry in enumerate(matches):
+        groups.setdefault(configuration_of(entry), []).append(index)
+
+    keep, skipped, unreachable = set(), set(), 0
+    for group in groups.values():
+        parts = [part_of(matches[index]) for index in group]
+        if len(group) == 1 or None in parts or len(set(parts)) != len(parts):
+            # Not one configuration split into parts: every entry here parses
+            # something the others do not.
+            keep.update(group)
+            continue
+        universe = frozenset(parts)
+        required = required_parts(text, lines, universe)
+        unreachable = max(unreachable, sum(1 for need in required if not need))
+        chosen, uncovered = select_parts(required, parts)
+        skipped |= {part for need in uncovered for part in need}
+        keep.update(index for index, part in zip(group, parts) if part in chosen)
+    return [matches[index] for index in sorted(keep)], sorted(skipped, key=int), unreachable
+
+
+def added_lines(line_filter):
+    """The line numbers a clang-tidy ``--line-filter`` argument marks."""
+    lines = []
+    for item in json.loads(line_filter or "[]"):
+        for first, last in item.get("lines", ()):
+            lines.extend(range(first, last + 1))
+    return sorted(set(lines))
+
+
+def summarize(matches, keep, skipped, unreachable):
+    """A one-line report of what the reduction dropped, or an empty string.
+
+    What the reduction leaves out is stated rather than implied: a job that
+    prints "all clean" for a file it never parsed is the failure this replaces.
+    """
+    if len(keep) == len(matches) and not skipped and not unreachable:
+        return ""
+    parts = sorted((part for part in (part_of(entry) for entry in keep) if part), key=int)
+    if not parts:
+        checking = "%d entries" % len(keep)
+    else:
+        checking = "part%s %s" % ("" if len(parts) == 1 else "s", ", ".join(parts))
+    report = "(%d compilation-database entries; checking %s" % (len(matches), checking)
+    if skipped:
+        report += "; NOT CHECKED: added lines also need part%s %s" % (
+            "" if len(skipped) == 1 else "s", ", ".join(skipped))
+    if unreachable:
+        report += "; NOT CHECKED: %d added line(s) belong to no configured part" % unreachable
+    return report + ")"
+
+
+def main(argv):
+    database, source, outdir, line_filter = argv[1:5]
+    try:
+        with open(database, encoding="utf-8") as handle:
+            commands = json.load(handle)
+    except (OSError, ValueError) as error:
+        print("ERROR: could not read %s: %s" % (database, error), file=sys.stderr)
+        return 2
+    if not isinstance(commands, list):
+        print("ERROR: %s does not contain a JSON array" % database, file=sys.stderr)
+        return 2
+
+    matches = entries_for(commands, source)
+    if not matches:
+        return 1
+
+    with open(source, encoding="utf-8", errors="replace") as handle:
+        text = handle.read()
+    keep, skipped, unreachable = reduce_entries(matches, text, added_lines(line_filter))
+
+    os.makedirs(outdir, exist_ok=True)
+    with open(os.path.join(outdir, "compile_commands.json"), "w", encoding="utf-8") as handle:
+        json.dump(keep, handle)
+    report = summarize(matches, keep, skipped, unreachable)
+    if report:
+        print(report)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
diff --git a/test/AnnoyingScalar.h b/test/AnnoyingScalar.h
index 9e320ea..5b448c5 100644
--- a/test/AnnoyingScalar.h
+++ b/test/AnnoyingScalar.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TEST_ANNOYING_SCALAR_H
 #define EIGEN_TEST_ANNOYING_SCALAR_H
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 0555bfe..dc54759 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,5 +1,7 @@
 # The file split_test_helper.h was generated at first run,
 # it is now included in test/
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
 if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
   file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
 endif()
@@ -18,10 +20,91 @@
 
 # TODO do the same for EXTERNAL_LAPACK
 option(EIGEN_TEST_EXTERNAL_BLAS "Use external BLAS library for testsuite" OFF)
+option(EIGEN_TEST_EXTERNAL_BLAS_INT64 "Use the 64-bit integer (ILP64) interface of the external BLAS" OFF)
+set(EIGEN_TEST_EXTERNAL_BLAS_SYMBOL_SUFFIX "" CACHE STRING
+    "Symbol suffix of the external BLAS 64-bit interface, e.g. _64 for dgemm_64_")
+# Check that the BLAS integer width Eigen is configured for is the one the linked library actually uses.
+# Fortran BLAS takes every dimension by pointer, so a mismatch is invisible to the compiler and the linker and
+# only shows up as corrupted arguments at run time.
+#
+# The probe calls dgemm passing one 8-byte slot for every integer argument, holding 1 in its low word and -1 in
+# its high word. A 32-bit callee reads 1 and computes 3*5; a 64-bit callee reads a negative extent and bails out
+# through xerbla without touching memory. Detection is by output rather than exit status, because the reference
+# xerbla ends in a Fortran STOP, which skips the rest of main and still exits 0.
+function(eigen_check_external_blas_integer_size)
+  if(CMAKE_CROSSCOMPILING)
+    message(STATUS "External BLAS: cross-compiling, BLAS integer width not checked")
+    return()
+  endif()
+  set(probe_dir "${CMAKE_CURRENT_BINARY_DIR}/eigen_blas_int_probe")
+  set(probe_src "${probe_dir}/probe.cpp")
+  # Bracket argument: the suffix arrives as a compile definition, so nothing here needs escaping.
+  file(WRITE "${probe_src}" [==[
+#include <cstdint>
+#include <cstdio>
+#define EIGEN_PROBE_CAT2(a, b) a##b
+#define EIGEN_PROBE_CAT(a, b) EIGEN_PROBE_CAT2(a, b)
+#define EIGEN_PROBE_DGEMM EIGEN_PROBE_CAT(EIGEN_PROBE_CAT(dgemm, EIGEN_PROBE_SUFFIX), _)
+extern "C" void EIGEN_PROBE_DGEMM(const void*, const void*, const void*, const void*, const void*, const double*,
+                                  const double*, const void*, const double*, const void*, const double*, double*,
+                                  const void*);
+int main() {
+  std::int64_t slot = std::int64_t(1) | (std::int64_t(0xFFFFFFFF) << 32);
+  double alpha = 1.0, beta = 0.0, a[1] = {3.0}, b[1] = {5.0}, c[1] = {-999.0};
+  std::printf("EIGEN_PROBE_RAN\n");
+  std::fflush(stdout);
+  EIGEN_PROBE_DGEMM("N", "N", &slot, &slot, &slot, &alpha, a, &slot, b, &slot, &beta, c, &slot);
+  if (c[0] == 15.0) {
+    std::printf("EIGEN_PROBE_IS32\n");
+    std::fflush(stdout);
+  }
+  return 0;
+}
+]==])
+  try_run(probe_run probe_built "${probe_dir}" "${probe_src}"
+          COMPILE_DEFINITIONS "-DEIGEN_PROBE_SUFFIX=${EIGEN_TEST_EXTERNAL_BLAS_SYMBOL_SUFFIX}"
+          LINK_LIBRARIES ${BLAS_LIBRARIES}
+          COMPILE_OUTPUT_VARIABLE probe_build_output
+          RUN_OUTPUT_VARIABLE probe_output)
+  if(NOT probe_built)
+    message(FATAL_ERROR
+            "External BLAS: could not link dgemm${EIGEN_TEST_EXTERNAL_BLAS_SYMBOL_SUFFIX}_ against "
+            "${BLAS_LIBRARIES}. Check EIGEN_TEST_EXTERNAL_BLAS_SYMBOL_SUFFIX.\n${probe_build_output}")
+  endif()
+  if(NOT probe_output MATCHES "EIGEN_PROBE_RAN")
+    message(WARNING "External BLAS: integer-width probe did not run; BLAS integer width not checked")
+    return()
+  endif()
+  if(probe_output MATCHES "EIGEN_PROBE_IS32")
+    set(library_is_int64 FALSE)
+  else()
+    set(library_is_int64 TRUE)
+  endif()
+  if(library_is_int64 AND NOT EIGEN_TEST_EXTERNAL_BLAS_INT64)
+    message(FATAL_ERROR "External BLAS: ${BLAS_LIBRARIES} uses 64-bit integers. Set "
+                        "EIGEN_TEST_EXTERNAL_BLAS_INT64=ON, or point BLAS_LIBRARIES at an LP64 library.")
+  elseif(NOT library_is_int64 AND EIGEN_TEST_EXTERNAL_BLAS_INT64)
+    message(FATAL_ERROR "External BLAS: ${BLAS_LIBRARIES} uses 32-bit integers. Set "
+                        "EIGEN_TEST_EXTERNAL_BLAS_INT64=OFF, or point BLAS_LIBRARIES at an ILP64 library.")
+  endif()
+  if(library_is_int64)
+    message(STATUS "External BLAS: confirmed 64-bit (ILP64) integer interface")
+  else()
+    message(STATUS "External BLAS: confirmed 32-bit (LP64) integer interface")
+  endif()
+endfunction()
+
 if(EIGEN_TEST_EXTERNAL_BLAS)
   find_package(BLAS REQUIRED)
   message(STATUS "BLAS_COMPILER_FLAGS: ${BLAS_COMPILER_FLAGS}")
   add_definitions("-DEIGEN_USE_BLAS") # is adding  ${BLAS_COMPILER_FLAGS} necessary?
+  if(EIGEN_TEST_EXTERNAL_BLAS_INT64)
+    add_definitions("-DEIGEN_64BIT_BLAS")
+  endif()
+  if(NOT EIGEN_TEST_EXTERNAL_BLAS_SYMBOL_SUFFIX STREQUAL "")
+    add_definitions("-DEIGEN_BLAS_SYMBOL_SUFFIX=${EIGEN_TEST_EXTERNAL_BLAS_SYMBOL_SUFFIX}")
+  endif()
+  eigen_check_external_blas_integer_size()
   list(APPEND EXTERNAL_LIBS "${BLAS_LIBRARIES}")
 endif()
 
@@ -171,21 +254,53 @@
 set_property(GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT "Official")
 add_custom_target(BuildOfficial)
 
+# Not an ei_add_test: this checks values produced by the configure step itself,
+# so it compares what the enclosing project() call left in this scope.
+add_test(NAME cmake_project_version
+         COMMAND ${CMAKE_COMMAND}
+                 "-DEIGEN_EXPECTED_VERSION=${EIGEN_VERSION_NUMBER}"
+                 "-DEIGEN_IS_TOP_LEVEL=${PROJECT_IS_TOP_LEVEL}"
+                 "-DOBSERVED_PROJECT_VERSION=${PROJECT_VERSION}"
+                 "-DOBSERVED_Eigen3_VERSION=${Eigen3_VERSION}"
+                 "-DOBSERVED_CMAKE_PROJECT_VERSION=${CMAKE_PROJECT_VERSION}"
+                 -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake_project_version.cmake")
+set_property(TEST cmake_project_version PROPERTY LABELS "Official")
+
 ei_add_test(clz)
 ei_add_test(rand)
+ei_add_test(realview)
+ei_add_test(complex_components)
 ei_add_test(meta)
+ei_add_test(preprocessor_directives)
+ei_add_test(lru_cache)
 ei_add_test(maxsizevector)
 ei_add_test(numext)
+ei_add_test(complex_sqrt)
+ei_add_test(numext_fma_off)
+# Fused residuals must not depend on optional compiler contraction.
+set(twoprod_test_flags "")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+  set(twoprod_test_flags "-ffp-contract=off")
+endif()
+ei_add_test(twoprod "${twoprod_test_flags}")
+# Reuse the existing GCC AVX2 configuration's -mfma for a small scalar contraction regression.
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND EIGEN_TEST_AVX2)
+  ei_add_test(numext_fma_contraction "-ffp-contract=fast -DEIGEN_DONT_VECTORIZE")
+endif()
+ei_add_test(safe_scaling)
 ei_add_test(sizeof)
 ei_add_test(dynalloc)
 ei_add_test(nomalloc)
+ei_add_test(stack_allocation_limit)
 ei_add_test(first_aligned)
+ei_add_test(cache_sizes)
 ei_add_test(type_alias)
 ei_add_test(nullary)
 ei_add_test(mixingtypes)
 ei_add_test(float_conversion)
 ei_add_test(io)
 ei_add_test(packetmath "-DEIGEN_FAST_MATH=1")
+ei_add_test(packetmath_gather)
 # Generic clang vector backend tests for different vector sizes.
 include(CheckCXXSourceCompiles)
 check_cxx_source_compiles("
@@ -193,15 +308,43 @@
   int main() { return __builtin_vectorelements(v4sf{}); }
 " COMPILER_SUPPORTS_VECTOR_EXTENSIONS)
 if(COMPILER_SUPPORTS_VECTOR_EXTENSIONS)
+  ei_add_test(twoprod_generic "${twoprod_test_flags}")
   ei_add_test(packetmath_generic_16 "-DEIGEN_FAST_MATH=1")
   ei_add_test(packetmath_generic_32 "-DEIGEN_FAST_MATH=1")
   ei_add_test(packetmath_generic_64 "-DEIGEN_FAST_MATH=1")
+  ei_add_test(mixingtypes_generic_32)
+  ei_add_test(mixingtypes_generic_64)
 endif()
 ei_add_test(packet_segment)
 ei_add_test(vectorization_logic)
 ei_add_test(basicstuff)
 ei_add_test(constexpr)
 ei_add_test(constructor)
+function(eigen_check_std_variant)
+  if(NOT CMAKE_CXX_STANDARD OR CMAKE_CXX_STANDARD LESS 17)
+    set(CMAKE_CXX_STANDARD 17)
+  endif()
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  check_cxx_source_compiles("
+    #include <variant>
+    int main() {
+      std::variant<int, double> value(1);
+      return std::get<int>(value) != 1;
+    }" EIGEN_TEST_HAS_STD_VARIANT)
+endfunction()
+
+if("cxx_std_17" IN_LIST CMAKE_CXX_COMPILE_FEATURES)
+  eigen_check_std_variant()
+  if(EIGEN_TEST_HAS_STD_VARIANT)
+    # Keep constructor_variant unsplit: the C++17 feature applies to this executable target.
+    ei_add_test(constructor_variant)
+    target_compile_features(constructor_variant PRIVATE cxx_std_17)
+  else()
+    message(STATUS "Skipping constructor_variant: std::variant is unavailable")
+  endif()
+else()
+  message(STATUS "Skipping constructor_variant: C++17 is unavailable")
+endif()
 ei_add_test(linearstructure)
 ei_add_test(integer_types)
 ei_add_test(unalignedcount)
@@ -209,6 +352,15 @@
   ei_add_test(exceptions)
 endif()
 ei_add_test(redux)
+ei_add_test(redux_bounded)
+if(CMAKE_COMPILER_IS_GNUCXX)
+  # Keep this diagnostic isolated from the runtime suite's warning policy and packet reductions.
+  add_executable(redux_bounded_compile EXCLUDE_FROM_ALL redux_bounded_compile.cpp)
+  target_link_libraries(redux_bounded_compile PRIVATE Eigen3::Eigen)
+  target_compile_options(redux_bounded_compile PRIVATE -O3 -Werror=array-bounds)
+  target_compile_definitions(redux_bounded_compile PRIVATE EIGEN_DONT_VECTORIZE)
+  add_dependencies(redux_bounded redux_bounded_compile)
+endif()
 ei_add_test(visitor)
 ei_add_test(block)
 ei_add_test(corners)
@@ -221,11 +373,26 @@
 ei_add_test(conservative_resize)
 ei_add_test(product_small)
 ei_add_test(product_large)
+if(EIGEN_TEST_SME)
+  # EIGEN_TEST_SME defines EIGEN_ARM64_USE_SME (root CMakeLists.txt), which turns
+  # a toolchain without SME2 into a build error rather than a NEON fallback; the
+  # toolchain must still supply an SME2 -march/-mcpu.
+  ei_add_test(product_sme)
+endif()
+if(EIGEN_TEST_SVE)
+  # EIGEN_TEST_SVE defines EIGEN_ARM64_USE_SVE and -msve-vector-bits (root
+  # CMakeLists.txt); the toolchain must still supply an SVE -march/-mcpu.
+  # This guards every other SVE result: if the runner's vector length does not
+  # match the one the packets were built for, the rest of the suite is vacuous.
+  ei_add_test(sve_vector_length)
+endif()
 ei_add_test(product_extra)
+ei_add_test(product_evaluators)
 ei_add_test(diagonalmatrices)
 ei_add_test(diagonalview)
 ei_add_test(skew_symmetric_matrix3)
 ei_add_test(adjoint)
+ei_add_test(inner_product_bounded)
 ei_add_test(diagonal)
 ei_add_test(miscmatrices)
 ei_add_test(commainitializer)
@@ -238,10 +405,14 @@
 ei_add_test(matrix_cwise)
 ei_add_test(array_for_matrix)
 ei_add_test(array_replicate)
+ei_add_test(concat)
 ei_add_test(array_reverse)
 ei_add_test(ref)
 ei_add_test(is_same_dense)
 ei_add_test(triangular)
+ei_add_test(trsm_packet)
+ei_add_test(trsm_packet_cancellation)
+ei_add_test(triangular_in_place)
 ei_add_test(selfadjoint)
 ei_add_test(product_selfadjoint)
 ei_add_test(product_symm)
@@ -253,21 +424,27 @@
 ei_add_test(product_notemporary)
 ei_add_test(product_threaded "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
 ei_add_test(stable_norm)
+ei_add_test(structured_norm)
 ei_add_test(permutationmatrices)
+ei_add_test(scaled_permutation)
 ei_add_test(bandmatrix)
 ei_add_test(cholesky)
+ei_add_test(bunchkaufman)
 ei_add_test(condition_estimator)
 ei_add_test(lu)
 ei_add_test(determinant)
 ei_add_test(inverse)
 ei_add_test(qr)
 ei_add_test(qr_colpivoting)
+ei_add_test(qr_rand_colpivoting)
 ei_add_test(qr_fullpivoting)
 ei_add_test(upperbidiagonalization)
 ei_add_test(hessenberg)
 ei_add_test(schur_real)
+ei_add_test(schur_real_nomalloc)
 ei_add_test(schur_complex)
 ei_add_test(eigensolver_selfadjoint)
+ei_add_test(tridiagonal_eigensolver)
 ei_add_test(eigensolver_generic)
 ei_add_test(eigensolver_complex)
 ei_add_test(real_qz)
@@ -275,6 +452,7 @@
 ei_add_test(eigensolver_generalized_real)
 ei_add_test(jacobi)
 ei_add_test(jacobisvd)
+ei_add_test(jacobisvd_blocked)
 ei_add_test(bdcsvd)
 ei_add_test(householder)
 ei_add_test(geo_orthomethods)
@@ -285,16 +463,20 @@
 ei_add_test(geo_hyperplane)
 ei_add_test(geo_transformations)
 ei_add_test(geo_homogeneous)
+ei_add_test(geo_misc)
 ei_add_test(stdvector)
 ei_add_test(stdvector_overload)
 ei_add_test(stdlist)
 ei_add_test(stdlist_overload)
 ei_add_test(stddeque)
 ei_add_test(stddeque_overload)
+ei_add_test(block_sparse_matrix)
 ei_add_test(sparse_basic)
+ei_add_test(sparse_scatter)
 ei_add_test(sparse_block)
 ei_add_test(sparse_vector)
 ei_add_test(sparse_product)
+ei_add_test(sparse_threaded_product "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
 ei_add_test(sparse_ref)
 ei_add_test(sparse_solvers)
 ei_add_test(sparse_permutations)
@@ -304,8 +486,16 @@
 ei_add_test(incomplete_LUT)
 ei_add_test(bicgstab)
 ei_add_test(lscg)
+ei_add_test(lsmr)
+ei_add_test(gmres)
+ei_add_test(dgmres)
+ei_add_test(minres)
+ei_add_test(idrs)
+ei_add_test(bicgstabl)
+ei_add_test(idrstabl)
 ei_add_test(sparselu)
 ei_add_test(sparseqr)
+ei_add_test(sparse_ordering)
 ei_add_test(umeyama)
 ei_add_test(nesting_ops "${CMAKE_CXX_FLAGS_DEBUG}")
 ei_add_test(nestbyvalue)
@@ -317,13 +507,16 @@
 endif()
 ei_add_test(prec_inverse_4x4)
 ei_add_test(vectorwiseop)
+ei_add_test(vectorwise_norm)
 ei_add_test(special_numbers)
 ei_add_test(rvalue_types)
 ei_add_test(dense_storage)
 ei_add_test(ctorleak)
 ei_add_test(inplace_decomposition)
+ei_add_test(inplace_decomposition_lapacke)
 ei_add_test(half_float)
 ei_add_test(bfloat16_float)
+ei_add_test(bfloat16_classification)
 ei_add_test(array_of_string)
 ei_add_test(num_dimensions)
 ei_add_test(stl_iterators)
@@ -332,13 +525,22 @@
 ei_add_test(initializer_list_construction)
 ei_add_test(diagonal_matrix_variadic_ctor)
 ei_add_test(serializer)
+ei_add_test(special_members)
 ei_add_test(tuple_test)
+ei_add_test(structured_bindings)
 ei_add_test(threads_eventcount "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
 ei_add_test(threads_runqueue "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
 ei_add_test(threads_non_blocking_thread_pool "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
 ei_add_test(threads_fork_join "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
+ei_add_test(assignment_threaded "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
 add_executable(bug1213 bug1213.cpp bug1213_main.cpp)
 target_link_libraries(bug1213 Eigen3::Eigen)
+# ei_add_test applies EIGEN_TEST_CUSTOM_CXX_FLAGS to every target it registers;
+# a bare add_executable has to ask. Without it this is the one test target built
+# at the configuration's default -march, which is not what the job selected.
+if(EIGEN_TEST_CUSTOM_CXX_FLAGS)
+  target_compile_options(bug1213 PRIVATE ${EIGEN_TEST_CUSTOM_CXX_FLAGS})
+endif()
 
 check_cxx_compiler_flag("-ffast-math" COMPILER_SUPPORT_FASTMATH)
 if(COMPILER_SUPPORT_FASTMATH)
@@ -351,14 +553,31 @@
 endif()
 # The fastmath test intentionally uses NaN/infinity under -ffast-math.
 # Suppress the clang warning about this being technically undefined.
-check_cxx_compiler_flag("-Wno-nan-infinity-disabled" COMPILER_SUPPORT_WNO_NAN_INF)
-if(COMPILER_SUPPORT_WNO_NAN_INF)
-  set(EIGEN_FASTMATH_FLAGS "${EIGEN_FASTMATH_FLAGS} -Wno-nan-infinity-disabled")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  check_cxx_compiler_flag("-Wno-nan-infinity-disabled" COMPILER_SUPPORT_WNO_NAN_INF)
+  if(COMPILER_SUPPORT_WNO_NAN_INF)
+    set(EIGEN_FASTMATH_FLAGS "${EIGEN_FASTMATH_FLAGS} -Wno-nan-infinity-disabled")
+  endif()
+endif()
+
+if(COMPILER_SUPPORT_FASTMATH)
+  ei_add_test(packetmath_fastmath "-O2 ${EIGEN_FASTMATH_FLAGS}")
+elseif(COMPILER_SUPPORT_FPFAST)
+  ei_add_test(packetmath_fastmath "${EIGEN_FASTMATH_FLAGS}")
+endif()
+if(COMPILER_SUPPORT_FASTMATH AND COMPILER_SUPPORTS_VECTOR_EXTENSIONS)
+  ei_add_test(packetmath_fastmath_generic_16 "-O2 ${EIGEN_FASTMATH_FLAGS} -Werror")
+  ei_add_test(packetmath_fastmath_generic_32 "-O2 ${EIGEN_FASTMATH_FLAGS} -Werror")
+  ei_add_test(packetmath_fastmath_generic_64 "-O2 ${EIGEN_FASTMATH_FLAGS} -Werror")
 endif()
 
 ei_add_test(fastmath "${EIGEN_FASTMATH_FLAGS}")
-
-# # ei_add_test(denseLM)
+ei_add_test(bdcsvd_fastmath "${EIGEN_FASTMATH_FLAGS}")
+ei_add_test(bfloat16_classification_fastmath "${EIGEN_FASTMATH_FLAGS}")
+ei_add_test(eigensolver_selfadjoint_fastmath "${EIGEN_FASTMATH_FLAGS}")
+ei_add_test(stable_norm_fastmath "${EIGEN_FASTMATH_FLAGS}")
+ei_add_test(householder_fastmath "${EIGEN_FASTMATH_FLAGS}")
+ei_add_test(trsm_packet_cancellation_fastmath "${EIGEN_FASTMATH_FLAGS}")
 
 if(QT4_FOUND)
   ei_add_test(qtvector "" "${QT_QTCORE_LIBRARY}")
@@ -400,12 +619,6 @@
 endif()
 ei_add_property(EIGEN_TESTING_SUMMARY "Sparse lib flags:  ${SPARSE_LIBS}\n")
 
-option(EIGEN_TEST_EIGEN2 "Run whole Eigen2 test suite against EIGEN2_SUPPORT" OFF)
-mark_as_advanced(EIGEN_TEST_EIGEN2)
-if(EIGEN_TEST_EIGEN2)
-  message(WARNING "The Eigen2 test suite has been removed")
-endif()
-
 # boost MP unit test
 find_package(Boost 1.53.0 CONFIG)
 if(Boost_FOUND)
@@ -417,106 +630,17 @@
 endif()
 
 
-# CUDA unit tests
-option(EIGEN_TEST_CUDA "Enable CUDA support in unit tests" OFF)
-option(EIGEN_TEST_CUDA_CLANG "Use clang instead of nvcc to compile the CUDA tests" OFF)
-option(EIGEN_TEST_CUDA_NVC "Use nvc++ (NVHPC) instead of nvcc to compile the CUDA tests" OFF)
-
-if(EIGEN_TEST_CUDA_CLANG AND NOT CMAKE_CXX_COMPILER MATCHES "clang")
-  message(WARNING "EIGEN_TEST_CUDA_CLANG is set, but CMAKE_CXX_COMPILER does not appear to be clang.")
-endif()
-
-if(EIGEN_TEST_CUDA_NVC AND NOT CMAKE_CXX_COMPILER_ID MATCHES "NVHPC")
-  message(WARNING "EIGEN_TEST_CUDA_NVC is set, but CMAKE_CXX_COMPILER does not appear to be nvc++.")
-endif()
-
-find_package(CUDA 9.0)
-if(CUDA_FOUND AND EIGEN_TEST_CUDA)
-  # Make sure to compile without the -pedantic, -Wundef, -Wnon-virtual-dtor
-  # and -fno-check-new flags since they trigger thousands of compilation warnings
-  # in the CUDA runtime
-  string(REPLACE "-pedantic" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "-Wundef" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "-Wnon-virtual-dtor" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "-fno-check-new" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-  if(EIGEN_TEST_CUDA_CLANG)
-    string(APPEND CMAKE_CXX_FLAGS " --cuda-path=${CUDA_TOOLKIT_ROOT_DIR}")
-    foreach(GPU IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
-      string(APPEND CMAKE_CXX_FLAGS " --cuda-gpu-arch=sm_${GPU}")
-    endforeach()
-    string(APPEND CMAKE_CXX_FLAGS " ${EIGEN_CUDA_CXX_FLAGS}")
-  elseif(EIGEN_TEST_CUDA_NVC)
-    string(APPEND CMAKE_CXX_FLAGS " -cuda")
-    foreach(GPU IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
-      string(APPEND CMAKE_CXX_FLAGS " -gpu=cc${GPU}")
-    endforeach()
-    string(APPEND CMAKE_CXX_FLAGS " ${EIGEN_CUDA_CXX_FLAGS}")
-  else()
-    set(CUDA_PROPAGATE_HOST_FLAGS OFF)
-    set(NVCC_ARCH_FLAGS)
-    # Define an -arch=sm_<arch>, otherwise if GPU does not exactly match one of
-    # those in the arch list for -gencode, the kernels will fail to run with
-    #    cudaErrorNoKernelImageForDevice
-    # This can happen with newer cards (e.g. sm_75) and compiling with older
-    # versions of nvcc (e.g. 9.2) that do not support their specific arch.
-    list(LENGTH EIGEN_CUDA_COMPUTE_ARCH EIGEN_CUDA_COMPUTE_ARCH_SIZE)
-    if(EIGEN_CUDA_COMPUTE_ARCH_SIZE)
-      list(GET EIGEN_CUDA_COMPUTE_ARCH 0 EIGEN_CUDA_COMPUTE_DEFAULT)
-      set(NVCC_ARCH_FLAGS " -arch=sm_${EIGEN_CUDA_COMPUTE_DEFAULT}")
-    endif()
-    foreach(ARCH IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
-      string(APPEND NVCC_ARCH_FLAGS " -gencode arch=compute_${ARCH},code=sm_${ARCH}")
-    endforeach()
-    set(CUDA_NVCC_FLAGS  "--expt-relaxed-constexpr -Xcudafe \"--display_error_number\" ${NVCC_ARCH_FLAGS} ${CUDA_NVCC_FLAGS} ${EIGEN_CUDA_CXX_FLAGS}")
-    cuda_include_directories("${CMAKE_CURRENT_BINARY_DIR}" "${CUDA_TOOLKIT_ROOT_DIR}/include")
-  endif()
-
-  set(EIGEN_ADD_TEST_FILENAME_EXTENSION  "cu")
+# GPU unit tests, the same set under CUDA and HIP. The options, the toolkit and the CUDA/HIP language are set up
+# once in the top-level CMakeLists through cmake/EigenGpuTesting.cmake, which also decides how a .cu file is
+# compiled.
+if(EIGEN_GPU_TEST_MODE MATCHES "^(cuda|hip)")
+  set(EIGEN_ADD_TEST_FILENAME_EXTENSION "cu")
 
   ei_add_test(gpu_example)
   ei_add_test(gpu_basic)
+  ei_add_test(packetmath_gpu)
 
   unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
-
-endif()
-
-
-# HIP unit tests
-option(EIGEN_TEST_HIP "Add HIP support." OFF)
-if (EIGEN_TEST_HIP)
-
-  set(ROCM_PATH "/opt/rocm" CACHE STRING "Path to the ROCm installation.")
-
-  if (EXISTS ${ROCM_PATH}/hip)
-    set(HIP_PATH ${ROCM_PATH}/hip)
-    list(APPEND CMAKE_MODULE_PATH ${HIP_PATH}/cmake)
-  elseif (EXISTS ${ROCM_PATH}/lib/cmake/hip)
-    set(HIP_PATH ${ROCM_PATH})
-    list(APPEND CMAKE_MODULE_PATH ${HIP_PATH}/lib/cmake/hip)
-  else ()
-    message(FATAL_ERROR "EIGEN_TEST_HIP is ON, but could not find the ROCm installation under ${ROCM_PATH}")
-  endif()
-
-  find_package(HIP REQUIRED)
-  if (HIP_FOUND)
-    execute_process(COMMAND ${HIP_PATH}/bin/hipconfig --platform OUTPUT_VARIABLE HIP_PLATFORM)
-
-    if ((${HIP_PLATFORM} STREQUAL "hcc") OR (${HIP_PLATFORM} STREQUAL "amd"))
-
-      include_directories(${HIP_PATH}/include)
-
-      set(EIGEN_ADD_TEST_FILENAME_EXTENSION  "cu")
-      ei_add_test(gpu_basic)
-      ei_add_test(gpu_example)
-      unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
-
-    elseif ((${HIP_PLATFORM} STREQUAL "nvcc") OR (${HIP_PLATFORM} STREQUAL "nvidia"))
-      message(FATAL_ERROR "HIP_PLATFORM = nvcc is not supported within Eigen")
-    else ()
-      message(FATAL_ERROR "Unknown HIP_PLATFORM = ${HIP_PLATFORM}")
-    endif()
-  endif()
 endif()
 
 if(EIGEN_TEST_SYCL)
@@ -535,15 +659,17 @@
 # ULP accuracy measurement tool (see test/ulp_accuracy/README.md)
 find_package(MPFR)
 find_package(GMP)
+find_package(Threads REQUIRED)
 add_executable(ulp_accuracy ulp_accuracy/ulp_accuracy.cpp)
-target_compile_options(ulp_accuracy PRIVATE -pthread)
-target_link_libraries(ulp_accuracy Eigen3::Eigen ${CMAKE_THREAD_LIBS_INIT} pthread)
+# Threads::Threads rather than a literal -pthread and pthread: it carries the
+# right compile and link flags per toolchain and expands to nothing on MSVC,
+# where there is no pthread.lib to open.
+target_link_libraries(ulp_accuracy Eigen3::Eigen Threads::Threads)
+if(EIGEN_TEST_CUSTOM_CXX_FLAGS)
+  target_compile_options(ulp_accuracy PRIVATE ${EIGEN_TEST_CUSTOM_CXX_FLAGS})
+endif()
 if(MPFR_FOUND AND GMP_FOUND)
   target_include_directories(ulp_accuracy PRIVATE ${MPFR_INCLUDES} ${GMP_INCLUDES})
   target_link_libraries(ulp_accuracy ${MPFR_LIBRARIES} ${GMP_LIBRARIES})
   target_compile_definitions(ulp_accuracy PRIVATE EIGEN_HAS_MPFR)
 endif()
-
-# Register all smoke tests
-include("EigenSmokeTestList")
-ei_add_smoke_tests("${ei_smoke_test_list}")
diff --git a/test/CustomComplex.h b/test/CustomComplex.h
index 048f65b..079d417 100644
--- a/test/CustomComplex.h
+++ b/test/CustomComplex.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TEST_CUSTOM_COMPLEX_H
 #define EIGEN_TEST_CUSTOM_COMPLEX_H
diff --git a/test/MovableScalar.h b/test/MovableScalar.h
index 6a046de..f3efc7a 100644
--- a/test/MovableScalar.h
+++ b/test/MovableScalar.h
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_MISC_MOVABLE_SCALAR_H
 #define EIGEN_MISC_MOVABLE_SCALAR_H
diff --git a/test/NonCommutativeScalar.h b/test/NonCommutativeScalar.h
new file mode 100644
index 0000000..5745553
--- /dev/null
+++ b/test/NonCommutativeScalar.h
@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_NONCOMMUTATIVE_SCALAR_H
+#define EIGEN_TEST_NONCOMMUTATIVE_SCALAR_H
+
+#include <Eigen/Core>
+
+namespace noncommutative_scalar {
+
+// Quaternions: multiplication is associative and conjugation reverses products, but ab != ba in general.
+struct Quaternion {
+  double r, i, j, k;
+  Quaternion(double real = 0, double x = 0, double y = 0, double z = 0) : r(real), i(x), j(y), k(z) {}
+  Quaternion operator+(const Quaternion& b) const { return Quaternion(r + b.r, i + b.i, j + b.j, k + b.k); }
+  Quaternion operator-(const Quaternion& b) const { return Quaternion(r - b.r, i - b.i, j - b.j, k - b.k); }
+  Quaternion operator-() const { return Quaternion(-r, -i, -j, -k); }
+  Quaternion operator*(const Quaternion& b) const {
+    return Quaternion(r * b.r - i * b.i - j * b.j - k * b.k, r * b.i + i * b.r + j * b.k - k * b.j,
+                      r * b.j - i * b.k + j * b.r + k * b.i, r * b.k + i * b.j - j * b.i + k * b.r);
+  }
+  Quaternion& operator+=(const Quaternion& b) { return *this = *this + b; }
+  Quaternion& operator-=(const Quaternion& b) { return *this = *this - b; }
+  Quaternion& operator*=(const Quaternion& b) { return *this = *this * b; }
+  bool operator==(const Quaternion& b) const { return r == b.r && i == b.i && j == b.j && k == b.k; }
+  bool operator!=(const Quaternion& b) const { return !(*this == b); }
+};
+
+inline Quaternion conj(const Quaternion& a) { return Quaternion(a.r, -a.i, -a.j, -a.k); }
+inline double real(const Quaternion& a) { return a.r; }
+inline double imag(const Quaternion& a) { return a.i; }
+
+}  // namespace noncommutative_scalar
+
+namespace Eigen {
+template <>
+struct NumTraits<noncommutative_scalar::Quaternion> : GenericNumTraits<noncommutative_scalar::Quaternion> {
+  using Real = double;
+  using Literal = double;
+  static constexpr bool IsComplex = true;
+  static constexpr bool RequireInitialization = true;
+};
+}  // namespace Eigen
+
+#endif
diff --git a/test/OffByOneScalar.h b/test/OffByOneScalar.h
index 8184571..0bd3934 100644
--- a/test/OffByOneScalar.h
+++ b/test/OffByOneScalar.h
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 // A Scalar with internal representation T+1 so that zero is internally
 // represented by T(1). This is used to test memory fill.
diff --git a/test/SafeScalar.h b/test/SafeScalar.h
index 33a54c5..ab0718a 100644
--- a/test/SafeScalar.h
+++ b/test/SafeScalar.h
@@ -1,3 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_SAFE_SCALAR_H
+#define EIGEN_TEST_SAFE_SCALAR_H
 
 // A Scalar that asserts for uninitialized access.
 template <typename T>
@@ -30,4 +35,6 @@
 struct NumTraits<SafeScalar<T>> : GenericNumTraits<T> {
   enum { RequireInitialization = 1 };
 };
-}  // namespace Eigen
\ No newline at end of file
+}  // namespace Eigen
+
+#endif  // EIGEN_TEST_SAFE_SCALAR_H
diff --git a/test/accelerate_support.cpp b/test/accelerate_support.cpp
index ec0609a..4b287fd 100644
--- a/test/accelerate_support.cpp
+++ b/test/accelerate_support.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #if defined(DEBUG)
 #undef DEBUG
 #endif
diff --git a/test/adjoint.cpp b/test/adjoint.cpp
index 881d639..88d52d0 100644
--- a/test/adjoint.cpp
+++ b/test/adjoint.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -70,17 +71,6 @@
   }
 };
 
-template <typename MatrixType, typename Scalar = typename MatrixType::Scalar>
-MatrixType RandomMatrix(Index rows, Index cols, Scalar min, Scalar max) {
-  MatrixType M = MatrixType(rows, cols);
-  for (Index i = 0; i < rows; ++i) {
-    for (Index j = 0; j < cols; ++j) {
-      M(i, j) = Eigen::internal::random<Scalar>(min, max);
-    }
-  }
-  return M;
-}
-
 template <typename MatrixType>
 void adjoint(const MatrixType& m) {
   /* this test covers the following files:
@@ -249,6 +239,118 @@
   }
 }
 
+// dot() maps operands with a runtime unit stride to contiguous vectors and rewraps their unary ops around the map.
+// adjoint() nests a non-const Transpose, so the rewrap must produce the const-nested type unaryExpr() returns.
+template <typename Scalar>
+void inner_product_adjoint_rewrap() {
+  // Column-major so that row(r) has a compile-time non-unit stride and the raw maps below walk a row and a column.
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using StridedMap = Map<const Vec, Unaligned, InnerStride<Dynamic>>;
+  const Index n = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
+  const Index r = internal::random<Index>(0, n - 1);
+  Mat m = Mat::Random(n, n);
+  Vec v = Vec::Random(n);
+  Scalar expected(0);
+  for (Index k = 0; k < n; ++k) expected += m(r, k) * v(k);
+
+  // Compile-time non-unit stride: the map path is instantiated but not taken.
+  VERIFY_IS_APPROX(m.row(r).adjoint().dot(v), expected);
+  VERIFY_IS_APPROX(v.dot(m.row(r).adjoint()), numext::conj(expected));
+  // Runtime strides: n skips the map, 1 takes it.
+  StridedMap row(m.data() + r, n, InnerStride<Dynamic>(n));
+  StridedMap column(m.data() + r * n, n, InnerStride<Dynamic>(1));
+  VERIFY_IS_APPROX(row.adjoint().dot(v), expected);
+  VERIFY_IS_APPROX(v.dot(row.adjoint()), numext::conj(expected));
+  VERIFY_IS_APPROX(column.adjoint().dot(v), (m.col(r).transpose() * v).value());
+  VERIFY_IS_APPROX(v.dot(column.adjoint()), numext::conj((m.col(r).transpose() * v).value()));
+}
+
+template <typename Lhs, typename Rhs>
+void check_inner_product(const MatrixBase<Lhs>& lhs, const MatrixBase<Rhs>& rhs) {
+  using Scalar = typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Wide = std::complex<long double>;
+  const auto widen = [](const auto& value) {
+    return Wide(static_cast<long double>(numext::real(value)), static_cast<long double>(numext::imag(value)));
+  };
+  Wide dot(0), product(0);
+  long double magnitude = 0;
+  for (Index i = 0; i < lhs.size(); ++i) {
+    const Wide a = widen(lhs.coeff(i)), b = widen(rhs.coeff(i));
+    dot += std::conj(a) * b;
+    product += a * b;
+    magnitude += std::abs(a) * std::abs(b);
+  }
+  // Complex multiply/add and the reference reduction fit within 8*n*eps*sum(|a_i|*|b_i|).
+  const long double bound = 8 * lhs.size() * static_cast<long double>(NumTraits<RealScalar>::epsilon()) * magnitude;
+  VERIFY(std::abs(widen(lhs.dot(rhs)) - dot) <= bound);
+  VERIFY(std::abs(widen((lhs.adjoint() * rhs).value()) - dot) <= bound);
+  VERIFY(std::abs(widen((lhs.transpose() * rhs).value()) - product) <= bound);
+  Matrix<Scalar, 1, 1> result;
+  result.noalias() = lhs.transpose() * rhs;
+  VERIFY(std::abs(widen(result.value()) - product) <= bound);
+  result.noalias() += lhs.transpose() * rhs;
+  VERIFY(std::abs(widen(result.value()) - 2.0L * product) <= 2 * bound);
+  result.noalias() -= lhs.transpose() * rhs;
+  VERIFY(std::abs(widen(result.value()) - product) <= 3 * bound);
+}
+
+template <typename Scalar>
+void inner_product_runtime_stride() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  using StridedMap = Map<const Vec, Unaligned, InnerStride<Dynamic>>;
+  const Index packetSize = internal::packet_traits<Scalar>::size;
+  const Index sizes[] = {
+      0, 1, 2, 3, 4, 5, packetSize - 1, packetSize, packetSize + 1, 4 * packetSize, 9 * packetSize + 1};
+  for (Index n : sizes) {
+    Vec a = Vec::Random(2 * n + 2), b = Vec::Random(2 * n + 2);
+    for (Index lhsStride : {1, 2, -2}) {
+      for (Index rhsStride : {1, 2, -2}) {
+        const StridedMap lhs(a.data() + (lhsStride < 0 && n > 0 ? 2 * n : 1), n, InnerStride<Dynamic>(lhsStride));
+        const StridedMap rhs(b.data() + (rhsStride < 0 && n > 0 ? 2 * n : 1), n, InnerStride<Dynamic>(rhsStride));
+        check_inner_product(lhs, rhs);
+        check_inner_product(-lhs.conjugate(), -rhs);
+        // A functor with state must survive rewrapping, including when it has no packet support.
+        const Scalar shift = internal::random<Scalar>();
+        check_inner_product(lhs.unaryExpr([=](Scalar x) { return x + shift; }), rhs);
+        check_inner_product(lhs.real(), rhs);
+        check_inner_product(lhs, rhs.real());
+      }
+    }
+    Map<const Vec, AlignedMax, InnerStride<Dynamic>> aligned(a.data(), n, InnerStride<Dynamic>(1));
+    Ref<const Vec, Unaligned, InnerStride<Dynamic>> ref(aligned);
+    check_inner_product(aligned, ref);
+    check_inner_product(ref, b.head(n));
+    check_inner_product(a.head(n), ref);
+    // Rows and columns can both become contiguous through their runtime outer dimension.
+    Matrix<Scalar, Dynamic, Dynamic, ColMajor> row = a.head(n).transpose();
+    Matrix<Scalar, Dynamic, Dynamic, RowMajor> col = b.head(n);
+    check_inner_product(row.row(0).transpose(), col.col(0));
+    VERIFY_RAISES_ASSERT(ref.dot(b));
+  }
+}
+
+template <typename Scalar>
+void inner_product_exact_values() {
+  using Vec = Matrix<Scalar, Dynamic, 1>;
+  for (Index n : {0, 1, 2, 3, 4, 5, 17, 65}) {
+    Vec a(2 * n), b(2 * n);
+    for (Index i = 0; i < 2 * n; ++i) {
+      a(i) = Scalar(i % 3 == 0);
+      b(i) = Scalar(i % 2 == 0);
+    }
+    for (Index stride : {1, 2}) {
+      const Map<const Vec, Unaligned, InnerStride<Dynamic>> lhs(a.data(), n, InnerStride<Dynamic>(stride));
+      const Map<const Vec, Unaligned, InnerStride<Dynamic>> rhs(b.data(), n, InnerStride<Dynamic>(stride));
+      Index count = 0;
+      for (Index i = 0; i < n; ++i) count += (i * stride) % 6 == 0;
+      VERIFY_IS_EQUAL(lhs.dot(rhs), Scalar(count));
+      VERIFY_IS_EQUAL((lhs.transpose() * rhs).value(), Scalar(count));
+    }
+  }
+}
+
 // Test transposeInPlace at vectorization boundary sizes.
 // BlockedInPlaceTranspose uses PacketSize-blocked loops with a scalar remainder (line 273),
 // exercising off-by-one-prone transitions.
@@ -288,6 +390,35 @@
   }
 }
 
+template <typename Scalar, int Order, int InnerStride>
+void transposeInPlace_strided() {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Order>;
+  using MapType = Map<MatrixType, Unaligned, Stride<Dynamic, InnerStride>>;
+  STATIC_CHECK(!(internal::evaluator<MapType>::Flags & PacketAccessBit));
+  const Index packetSize = internal::packet_traits<Scalar>::size;
+  const Index sizes[] = {1, packetSize, packetSize + 1, 2 * packetSize, 2 * packetSize + 1};
+  for (Index size : sizes) {
+    for (Index innerStride : {1, 2, 3}) {
+      if (InnerStride != Dynamic && innerStride != InnerStride) continue;
+      const Index outerStride = size * innerStride + 3;
+      Matrix<Scalar, Dynamic, 1> storage(size * outerStride + 2);
+      for (Index i = 0; i < storage.size(); ++i) storage(i) = Scalar(i + 1);
+      const Matrix<Scalar, Dynamic, 1> original = storage;
+      Matrix<Scalar, Dynamic, 1> expected = original;
+      // Include padding and interleaved coefficients in the exact comparison.
+      for (Index outer = 0; outer < size; ++outer)
+        for (Index inner = 0; inner < size; ++inner)
+          expected(1 + outer * outerStride + inner * innerStride) =
+              original(1 + inner * outerStride + outer * innerStride);
+      MapType mapped(storage.data() + 1, size, size, Stride<Dynamic, InnerStride>(outerStride, innerStride));
+      mapped.transposeInPlace();
+      VERIFY(storage == expected);
+      mapped.transposeInPlace();
+      VERIFY(storage == original);
+    }
+  }
+}
+
 EIGEN_DECLARE_TEST(adjoint) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(adjoint(Matrix<float, 1, 1>()));
@@ -320,9 +451,33 @@
   CALL_SUBTEST_15(inner_product_boundary_sizes<double>());
   CALL_SUBTEST_16(inner_product_boundary_sizes<std::complex<float>>());
   CALL_SUBTEST_17(inner_product_boundary_sizes<std::complex<double>>());
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_19(inner_product_adjoint_rewrap<double>());
+    CALL_SUBTEST_19(inner_product_adjoint_rewrap<std::complex<float>>());
+    CALL_SUBTEST_19(inner_product_adjoint_rewrap<std::complex<double>>());
+  }
+
+  CALL_SUBTEST_20(inner_product_runtime_stride<float>());
+  CALL_SUBTEST_21(inner_product_runtime_stride<double>());
+  CALL_SUBTEST_22(inner_product_runtime_stride<std::complex<float>>());
+  CALL_SUBTEST_23(inner_product_runtime_stride<std::complex<double>>());
+
+  CALL_SUBTEST_24(inner_product_exact_values<int>());
+  CALL_SUBTEST_24(inner_product_exact_values<bool>());
+  CALL_SUBTEST_24(inner_product_exact_values<half>());
+  CALL_SUBTEST_24(inner_product_exact_values<bfloat16>());
 
   // transposeInPlace at vectorization boundaries (deterministic, outside g_repeat).
   CALL_SUBTEST_18(transposeInPlace_boundary<float>());
   CALL_SUBTEST_18(transposeInPlace_boundary<double>());
   CALL_SUBTEST_18(transposeInPlace_boundary<std::complex<float>>());
+
+  CALL_SUBTEST_19((transposeInPlace_strided<float, ColMajor, Dynamic>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<float, RowMajor, Dynamic>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<double, ColMajor, Dynamic>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<double, RowMajor, Dynamic>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<float, ColMajor, 2>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<float, RowMajor, 2>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<double, ColMajor, 2>()));
+  CALL_SUBTEST_19((transposeInPlace_strided<double, RowMajor, 2>()));
 }
diff --git a/test/array_cwise.cpp b/test/array_cwise.cpp
index f73a3bf..0cbdfe5 100644
--- a/test/array_cwise.cpp
+++ b/test/array_cwise.cpp
@@ -6,19 +6,36 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Silence warnings about the deprecated shiftLeft()/shiftRight(), which are still being tested.
+#define EIGEN_NO_DEPRECATED_WARNING
 
 #include <vector>
 #include "main.h"
+#include "random_for_arithmetic.h"
 #include "random_without_cast_overflow.h"
 
+static_assert(
+    std::is_same<ArrayXf::AbsReturnType, std::remove_const_t<decltype(std::declval<const ArrayXf&>().abs())>>::value,
+    "ArrayBase unary return type aliases must match their corresponding expressions");
+
 // suppress annoying unsigned integer warnings
-template <typename Scalar, bool IsSigned = NumTraits<Scalar>::IsSigned>
+template <typename Scalar, bool IsSignedInteger = NumTraits<Scalar>::IsSigned && NumTraits<Scalar>::IsInteger,
+          bool IsSigned = NumTraits<Scalar>::IsSigned>
 struct negative_or_zero_impl {
+  static Scalar run(const Scalar& a) {
+    using UnsignedScalar = std::make_unsigned_t<Scalar>;
+    return static_cast<Scalar>(UnsignedScalar(0) - static_cast<UnsignedScalar>(a));
+  }
+};
+template <typename Scalar>
+struct negative_or_zero_impl<Scalar, false, true> {
   static Scalar run(const Scalar& a) { return -a; }
 };
 template <typename Scalar>
-struct negative_or_zero_impl<Scalar, false> {
-  static Scalar run(const Scalar&) { return 0; }
+struct negative_or_zero_impl<Scalar, false, false> {
+  static Scalar run(const Scalar&) { return Scalar(0); }
 };
 template <typename Scalar>
 Scalar negative_or_zero(const Scalar& a) {
@@ -183,6 +200,7 @@
   unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(exp));
   unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(exp2));
   unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(log));
+  unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(log10));
   unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(sin));
   unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(cos));
   unary_op_test<Scalar>(UNARY_FUNCTOR_TEST_ARGS(tan));
@@ -214,6 +232,59 @@
   */
 }
 
+template <typename Scalar>
+void ldexp_test() {
+  const std::vector<Scalar> vals = special_values<Scalar>();
+  // Exercise both packet and scalar tails.
+  const Index num_repeats = 2 * Index(internal::packet_traits<Scalar>::size) + 1;
+  Array<Scalar, Dynamic, 1> x(num_repeats * Index(vals.size()));
+  Index count = 0;
+  for (const Scalar& value : vals) {
+    for (Index repeat = 0; repeat < num_repeats; ++repeat) x(count++) = value;
+  }
+
+  const int digits = std::numeric_limits<Scalar>::digits;
+  const int max_exp = std::numeric_limits<Scalar>::max_exponent;
+  // Include denormals, saturation, and unrepresentable 2^e scale factors.
+  const int exponents[] = {0,
+                           1,
+                           -1,
+                           digits - 1,
+                           1 - digits,
+                           max_exp - 1,
+                           1 - max_exp,
+                           max_exp + digits,
+                           -(max_exp + digits),
+                           2 * max_exp,
+                           -2 * max_exp,
+                           (std::numeric_limits<int>::max)(),
+                           (std::numeric_limits<int>::min)()};
+
+  bool all_pass = true;
+  for (const int exponent : exponents) {
+    const Array<Scalar, Dynamic, 1> method_result = x.ldexp(exponent);
+    const Array<Scalar, Dynamic, 1> global_result = Eigen::ldexp(x, exponent);
+    for (Index i = 0; i < x.size(); ++i) {
+      // double covers every tested Scalar, so one conversion back gives the exact reference.
+      const double expected = static_cast<double>(static_cast<Scalar>(std::ldexp(static_cast<double>(x(i)), exponent)));
+#if EIGEN_ARCH_ARM
+      // Work around 32-bit ARM flush-to-zero mode: skip cases with subnormal results.
+      if (expected != 0.0 && std::abs(expected) < static_cast<double>((std::numeric_limits<Scalar>::min)())) continue;
+#endif
+      for (const Scalar& result : {method_result(i), global_result(i)}) {
+        const double actual = static_cast<double>(result);
+        const bool success = (actual == expected && std::signbit(actual) == std::signbit(expected)) ||
+                             ((numext::isnan)(actual) && (numext::isnan)(expected));
+        all_pass &= success;
+        if (!success) {
+          std::cout << "ldexp(" << x(i) << "," << exponent << ") = " << result << " != " << expected << std::endl;
+        }
+      }
+    }
+  }
+  VERIFY(all_pass);
+}
+
 template <typename Base, typename Exponent, bool ExpIsInteger = NumTraits<Exponent>::IsInteger>
 struct ref_pow {
   static Base run(Base base, Exponent exponent) {
@@ -223,8 +294,23 @@
 };
 
 template <typename Base, typename Exponent>
+Base ref_pow_integer_base(Base base, Exponent exponent) {
+  // std::pow uses floating-point arithmetic and can round one ulp below the exact integer result before casting.
+  Base result(1);
+  while (exponent > Exponent(0)) {
+    if (exponent & Exponent(1)) result *= base;
+    exponent >>= 1;
+    if (exponent > Exponent(0)) base *= base;
+  }
+  return result;
+}
+
+template <typename Base, typename Exponent>
 struct ref_pow<Base, Exponent, true> {
   static Base run(Base base, Exponent exponent) {
+    if (NumTraits<Base>::IsInteger && (exponent > Exponent(0) || exponent == Exponent(0))) {
+      return ref_pow_integer_base(base, exponent);
+    }
     EIGEN_USING_STD(pow);
     return static_cast<Base>(pow(base, exponent));
   }
@@ -283,6 +369,10 @@
               bool ref_is_neg = !(numext::isnan)(e) && (bool)numext::signbit(e);
               bool flip_sign = result_is_neg != ref_is_neg;
               if (flip_sign) e = -e;
+            } else if (e == Base(0)) {
+              // Implementations may disagree on the sign of pow(-0, positive non-integer).  The specified result is
+              // +0, so do not inherit a negative zero from the scalar reference.
+              e = numext::abs(e);
             }
 
             Base a = eigenPow(j);
@@ -419,7 +509,6 @@
   int_pow_test_impl<unsigned int, int>();
   int_pow_test_impl<long long, unsigned long long>();
   int_pow_test_impl<unsigned long long, long long>();
-  int_pow_test_impl<long long, int>();
 }
 
 namespace Eigen {
@@ -482,25 +571,15 @@
   Index rows = m.rows();
   Index cols = m.cols();
 
-  ArrayType m1 = ArrayType::Random(rows, cols);
-  if (NumTraits<RealScalar>::IsInteger && NumTraits<RealScalar>::IsSigned && !NumTraits<Scalar>::IsComplex) {
-    // Here we cap the size of the values in m1 such that pow(3)/cube()
-    // doesn't overflow and result in undefined behavior. Notice that because
-    // pow(int, int) promotes its inputs and output to double (according to
-    // the C++ standard), we have to make sure that the result fits in 53 bits
-    // for int64,
-    RealScalar max_val =
-        numext::mini(RealScalar(std::cbrt(NumTraits<RealScalar>::highest())), RealScalar(std::cbrt(1LL << 53))) / 2;
-    m1.array() = (m1.abs().array() <= max_val).select(m1, Scalar(max_val));
-  }
-  ArrayType m2 = ArrayType::Random(rows, cols), m3(rows, cols);
+  ArrayType m1 = random_for_arithmetic<ArrayType>(rows, cols);
+  ArrayType m2 = random_for_arithmetic<ArrayType>(rows, cols), m3(rows, cols);
   ArrayType m4 = m1;  // copy constructor
   VERIFY_IS_APPROX(m1, m4);
 
-  ColVectorType cv1 = ColVectorType::Random(rows);
-  RowVectorType rv1 = RowVectorType::Random(cols);
+  ColVectorType cv1 = random_for_arithmetic<ColVectorType>(rows);
+  RowVectorType rv1 = random_for_arithmetic<RowVectorType>(cols);
 
-  Scalar s1 = internal::random<Scalar>(), s2 = internal::random<Scalar>();
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>(), s2 = random_scalar_for_arithmetic<Scalar>();
 
   // scalar addition
   VERIFY_IS_APPROX(m1 + s1, s1 + m1);
@@ -534,7 +613,7 @@
 
   m3 = m1;
   m4 = m1;
-  m2 = ArrayType::Random(rows, cols);
+  m2 = random_for_arithmetic<ArrayType>(rows, cols);
   m2 = (m2 == 0).select(1, m2);
   ArrayType::Map(m4.data(), m4.rows(), m4.cols()) /= ArrayType::Map(m2.data(), m2.rows(), m2.cols());
   VERIFY_IS_APPROX(m4, m3 / m2);
@@ -661,7 +740,8 @@
 
   Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
 
-  ArrayType m1 = ArrayType::Random(rows, cols), m2 = ArrayType::Random(rows, cols), m3(rows, cols), m4 = m1;
+  ArrayType m1 = random_for_arithmetic<ArrayType>(rows, cols), m2 = random_for_arithmetic<ArrayType>(rows, cols),
+            m3(rows, cols), m4 = m1;
 
   m4 = (m4.abs() == Scalar(0)).select(1, m4);
 
@@ -813,7 +893,6 @@
   VERIFY_IS_APPROX(m1.tanh().atanh(), atanh(tanh(m1)));
   VERIFY_IS_APPROX(m1.sinh().asinh(), asinh(sinh(m1)));
   VERIFY_IS_APPROX(m1.cosh().acosh(), acosh(cosh(m1)));
-  VERIFY_IS_APPROX(m1.tanh().atanh(), atanh(tanh(m1)));
   VERIFY_IS_APPROX(m1.logistic(), logistic(m1));
 
   VERIFY_IS_APPROX(m1.arg(), arg(m1));
@@ -1084,53 +1163,17 @@
   }
 }
 
-template <typename Scalar>
-struct shift_imm_traits {
-  enum { Cost = 1, PacketAccess = internal::packet_traits<Scalar>::HasShift };
-};
-
-template <int N, typename Scalar>
-struct logical_left_shift_op {
-  Scalar operator()(const Scalar& v) const { return numext::logical_shift_left(v, N); }
-  template <typename Packet>
-  Packet packetOp(const Packet& v) const {
-    return internal::plogical_shift_left<N>(v);
-  }
-};
-template <int N, typename Scalar>
-struct logical_right_shift_op {
-  Scalar operator()(const Scalar& v) const { return numext::logical_shift_right(v, N); }
-  template <typename Packet>
-  Packet packetOp(const Packet& v) const {
-    return internal::plogical_shift_right<N>(v);
-  }
-};
-template <int N, typename Scalar>
-struct arithmetic_right_shift_op {
-  Scalar operator()(const Scalar& v) const { return numext::arithmetic_shift_right(v, N); }
-  template <typename Packet>
-  Packet packetOp(const Packet& v) const {
-    return internal::parithmetic_shift_right<N>(v);
-  }
-};
-
-namespace Eigen {
-namespace internal {
-template <int N, typename Scalar>
-struct functor_traits<logical_left_shift_op<N, Scalar>> : shift_imm_traits<Scalar> {};
-template <int N, typename Scalar>
-struct functor_traits<logical_right_shift_op<N, Scalar>> : shift_imm_traits<Scalar> {};
-template <int N, typename Scalar>
-struct functor_traits<arithmetic_right_shift_op<N, Scalar>> : shift_imm_traits<Scalar> {};
-}  // namespace internal
-}  // namespace Eigen
-
+// A lambda takes the default functor_traits, so each reference arm stays scalar while the arm under
+// test vectorizes. Comparing the reference against the shift expression as well as against the
+// assigned result evaluates the expression coefficient-wise, which is the only path that reaches the
+// scalar operator() of its functor.
 template <typename ArrayType>
 struct shift_test_impl {
-  typedef typename ArrayType::Scalar Scalar;
+  using Scalar = typename ArrayType::Scalar;
   static constexpr size_t Size = sizeof(Scalar);
   static constexpr size_t MaxShift = (CHAR_BIT * Size) - 1;
 
+  // N starts at one: NEON's immediate right-shift intrinsics reject a count of zero.
   template <size_t N = 1>
   static inline std::enable_if_t<(N > MaxShift), void> run(const ArrayType&) {}
   template <size_t N = 1>
@@ -1139,18 +1182,29 @@
     const Index cols = m.cols();
 
     ArrayType m1 = ArrayType::Random(rows, cols), m2(rows, cols), m3(rows, cols);
+    // The high bit is what separates an arithmetic right shift from a logical one.
+    m1(0, 0) = NumTraits<Scalar>::lowest();
+    m1(rows - 1, cols - 1) = NumTraits<Scalar>::highest();
 
     m2 = m1.unaryExpr([](const Scalar& v) { return numext::logical_shift_left(v, N); });
-    m3 = m1.unaryExpr(logical_left_shift_op<N, Scalar>());
+    m3 = m1.template logicalShiftLeft<N>();
     VERIFY_IS_CWISE_EQUAL(m2, m3);
+    VERIFY_IS_CWISE_EQUAL(m2, m1.template logicalShiftLeft<N>());
+    VERIFY_IS_CWISE_EQUAL(m2, m1.template shiftLeft<N>());
 
     m2 = m1.unaryExpr([](const Scalar& v) { return numext::logical_shift_right(v, N); });
-    m3 = m1.unaryExpr(logical_right_shift_op<N, Scalar>());
+    m3 = m1.template logicalShiftRight<N>();
     VERIFY_IS_CWISE_EQUAL(m2, m3);
+    VERIFY_IS_CWISE_EQUAL(m2, m1.template logicalShiftRight<N>());
 
-    m2 = m1.unaryExpr([](const Scalar& v) { return numext::arithmetic_shift_right(v, N); });
-    m3 = m1.unaryExpr(arithmetic_right_shift_op<N, Scalar>());
+    // Referencing Scalar's own operator>> rather than the numext helper the functor calls keeps this
+    // arm independent of the implementation under test, and states the semantics: fill with the sign
+    // bit when Scalar is signed and with zero when it is not.
+    m2 = m1.unaryExpr([](const Scalar& v) { return static_cast<Scalar>(v >> N); });
+    m3 = m1.template arithmeticShiftRight<N>();
     VERIFY_IS_CWISE_EQUAL(m2, m3);
+    VERIFY_IS_CWISE_EQUAL(m2, m1.template arithmeticShiftRight<N>());
+    VERIFY_IS_CWISE_EQUAL(m2, m1.template shiftRight<N>());
 
     run<N + 1>(m);
   }
@@ -1268,6 +1322,30 @@
   typed_logicals_test_impl<ArrayType>::run(m);
 }
 
+// Integer scalars are always finite, so isFiniteTyped() must be true (nonzero) everywhere. Only
+// truthiness is checked: the exact nonzero value differs between the vectorized path (all-ones
+// mask) and the scalar path (1). Regression: the vectorized path used to compare |x| against a
+// synthesized "infinity" bit pattern, misclassifying |x| >= 2^(digits-1) for signed types and
+// everything for unsigned ones.
+template <typename ArrayType>
+void integer_typed_predicates_test(const ArrayType& m) {
+  typedef typename ArrayType::Scalar Scalar;
+  Index rows = m.rows();
+  Index cols = m.cols();
+  const Scalar values[] = {Scalar(0),
+                           Scalar(1),
+                           static_cast<Scalar>(-1),
+                           Scalar(Scalar(1) << (std::numeric_limits<Scalar>::digits - 1)),
+                           NumTraits<Scalar>::highest(),
+                           NumTraits<Scalar>::lowest()};
+  const Index num_values = sizeof(values) / sizeof(values[0]);
+  ArrayType m1(rows, cols);
+  for (Index i = 0; i < m1.size(); ++i) m1.coeffRef(i) = values[i % num_values];
+  // Materialize so the vectorized assignment path engages.
+  ArrayType finite = m1.isFiniteTyped();
+  VERIFY((finite != Scalar(0)).all());
+}
+
 template <typename SrcType, typename DstType, int RowsAtCompileTime, int ColsAtCompileTime>
 struct cast_test_impl {
   using SrcArray = Array<SrcType, RowsAtCompileTime, ColsAtCompileTime>;
@@ -1283,8 +1361,8 @@
   static constexpr int MaxPacketSize = internal::plain_enum_max(SrcPacketSize, DstPacketSize);
 
   static void run() {
-    const Index testRows = RowsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : RowsAtCompileTime;
-    const Index testCols = ColsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : ColsAtCompileTime;
+    constexpr Index testRows = RowsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : RowsAtCompileTime;
+    constexpr Index testCols = ColsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : ColsAtCompileTime;
     const Index testSize = testRows * testCols;
     const Index minTestSize = 100;
     const Index repeats = numext::div_ceil(minTestSize, testSize);
@@ -1321,8 +1399,8 @@
 
   template <size_t i = 0, size_t j = i + 1, bool Done = (i >= ScalarTupleSize - 1) || (j >= ScalarTupleSize)>
   static std::enable_if_t<!Done> run() {
-    using Type1 = typename std::tuple_element<i, ScalarTuple>::type;
-    using Type2 = typename std::tuple_element<j, ScalarTuple>::type;
+    using Type1 = std::tuple_element_t<i, ScalarTuple>;
+    using Type2 = std::tuple_element_t<j, ScalarTuple>;
     cast_test_impl<Type1, Type2, RowsAtCompileTime, ColsAtCompileTime>::run();
     cast_test_impl<Type2, Type1, RowsAtCompileTime, ColsAtCompileTime>::run();
     static constexpr size_t next_i = (j == ScalarTupleSize - 1) ? (i + 1) : (i + 0);
@@ -1338,6 +1416,73 @@
                   uint32_t, uint64_t, float, double, /*long double, */ half, bfloat16>::run();
 }
 
+void bool_logical_ops() {
+  const Index size = 67;
+  ArrayX<bool> lhs = ArrayXi::Random(size) > 0;
+  ArrayX<bool> rhs = ArrayXi::Random(size) > 0;
+  for (Index i = 0; i < 4; ++i) {
+    lhs[i] = lhs[size - 4 + i] = (i & 2) != 0;
+    rhs[i] = rhs[size - 4 + i] = (i & 1) != 0;
+  }
+
+  ArrayX<bool> actual_and(size), actual_or(size), actual_xor(size), actual_not(size);
+  ArrayX<bool> expected_and(size), expected_or(size), expected_xor(size), expected_not(size);
+  actual_and = lhs && rhs;
+  actual_or = lhs || rhs;
+  actual_xor = lhs.binaryExpr(rhs, internal::scalar_boolean_xor_op<bool>());
+  actual_not = !lhs;
+  for (Index i = 0; i < size; ++i) {
+    expected_and[i] = lhs[i] && rhs[i];
+    expected_or[i] = lhs[i] || rhs[i];
+    expected_xor[i] = lhs[i] != rhs[i];
+    expected_not[i] = !lhs[i];
+  }
+  VERIFY((actual_and == expected_and).all());
+  VERIFY((actual_or == expected_or).all());
+  VERIFY((actual_xor == expected_xor).all());
+  VERIFY((actual_not == expected_not).all());
+  VERIFY((lhs + rhs == expected_or).all());
+  VERIFY((lhs * rhs == expected_and).all());
+  VERIFY(((lhs != rhs) == expected_xor).all());
+
+  ArrayXi difference = lhs.cast<int>() - rhs.cast<int>();
+  ArrayXi opposite = -lhs.cast<int>();
+  ArrayXi expected_difference(size), expected_opposite(size);
+  for (Index i = 0; i < size; ++i) {
+    expected_difference[i] = int(lhs[i]) - int(rhs[i]);
+    expected_opposite[i] = -int(lhs[i]);
+  }
+  VERIFY_IS_CWISE_EQUAL(difference, expected_difference);
+  VERIFY_IS_CWISE_EQUAL(opposite, expected_opposite);
+}
+
+template <typename RealScalar>
+void complex_classification() {
+  using Complex = std::complex<RealScalar>;
+  const RealScalar inf = NumTraits<RealScalar>::infinity();
+  const RealScalar nan = NumTraits<RealScalar>::quiet_NaN();
+
+  struct TestCase {
+    Complex value;
+    bool finite;
+    bool infinite;
+    bool not_a_number;
+  };
+  const TestCase test_cases[] = {
+      {Complex(0, 0), true, false, false},     {Complex(inf, 0), false, true, false},
+      {Complex(0, inf), false, true, false},   {Complex(nan, 0), false, false, true},
+      {Complex(0, nan), false, false, true},   {Complex(inf, nan), false, false, true},
+      {Complex(nan, inf), false, false, true}, {Complex(-inf, -inf), false, true, false},
+      {Complex(nan, nan), false, false, true},
+  };
+
+  for (const TestCase& test_case : test_cases) {
+    VERIFY_IS_EQUAL((numext::isfinite)(test_case.value), test_case.finite);
+    VERIFY_IS_EQUAL((numext::isinf)(test_case.value), test_case.infinite);
+    VERIFY_IS_EQUAL((numext::isnan)(test_case.value), test_case.not_a_number);
+  }
+}
+
 EIGEN_DECLARE_TEST(array_cwise) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(array_generic(Array<float, 1, 1>()));
@@ -1355,6 +1500,23 @@
         ArrayXXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_9(shift_test(Array<Index, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
                                                              internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    // An unsigned Scalar has no sign bit, so its arithmetic right shift must not sign-extend.
+    CALL_SUBTEST_38(shift_test(Array<uint32_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                 internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_39(shift_test(Array<uint64_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                 internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_40(shift_test(Array<int8_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                               internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_40(shift_test(Array<uint8_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    // A random dynamic size above only occasionally lands on 4, so it does not reliably exercise
+    // the quarter-width NEON packets (Packet4c/Packet4uc); pin a fixed size to cover them every run.
+    CALL_SUBTEST_40(shift_test(Array<int8_t, 4, 1>()));
+    CALL_SUBTEST_40(shift_test(Array<uint8_t, 4, 1>()));
+    CALL_SUBTEST_41(shift_test(Array<int16_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_41(shift_test(Array<uint16_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                 internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_10(array_generic(Array<uint32_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
                                                                     internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_11(array_generic(Array<uint64_t, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
@@ -1393,6 +1555,9 @@
     CALL_SUBTEST_18(array_complex(
         ArrayXXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
   }
+  CALL_SUBTEST_17(complex_classification<float>());
+  CALL_SUBTEST_18(complex_classification<double>());
+  CALL_SUBTEST_18(complex_classification<long double>());
 
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_19(float_pow_test());
@@ -1401,11 +1566,22 @@
     CALL_SUBTEST_22(signbit_tests());
   }
   for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_34(ldexp_test<float>());
+    CALL_SUBTEST_35(ldexp_test<double>());
+    CALL_SUBTEST_36(ldexp_test<Eigen::half>());
+    CALL_SUBTEST_37(ldexp_test<Eigen::bfloat16>());
+  }
+  for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_23(typed_logicals_test(ArrayX<int>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_23(integer_typed_predicates_test(ArrayX<int>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_23(integer_typed_predicates_test(ArrayXX<int64_t>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                                                   internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_23(integer_typed_predicates_test(ArrayX<uint32_t>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_24(typed_logicals_test(ArrayX<float>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_25(typed_logicals_test(ArrayX<double>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_26(typed_logicals_test(ArrayX<std::complex<float>>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_27(typed_logicals_test(ArrayX<std::complex<double>>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_42(bool_logical_ops());
   }
 
   for (int i = 0; i < g_repeat; i++) {
@@ -1417,9 +1593,9 @@
     CALL_SUBTEST_33((cast_test<Dynamic, 1>()));
   }
 
-  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<int>::type, int>::value));
-  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<float>::type, float>::value));
-  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i>>::value));
+  VERIFY((std::is_same<internal::global_math_functions_filtering_base<int>::type, int>::value));
+  VERIFY((std::is_same<internal::global_math_functions_filtering_base<float>::type, float>::value));
+  VERIFY((std::is_same<internal::global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i>>::value));
   typedef CwiseUnaryOp<internal::scalar_abs_op<double>, ArrayXd> Xpr;
-  VERIFY((internal::is_same<internal::global_math_functions_filtering_base<Xpr>::type, ArrayBase<Xpr>>::value));
+  VERIFY((std::is_same<internal::global_math_functions_filtering_base<Xpr>::type, ArrayBase<Xpr>>::value));
 }
diff --git a/test/array_for_matrix.cpp b/test/array_for_matrix.cpp
index f072434..6ed31ef 100644
--- a/test/array_for_matrix.cpp
+++ b/test/array_for_matrix.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/array_of_string.cpp b/test/array_of_string.cpp
index f92603f..bbc5561 100644
--- a/test/array_of_string.cpp
+++ b/test/array_of_string.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/array_replicate.cpp b/test/array_replicate.cpp
index f5c9246..0e7587c 100644
--- a/test/array_replicate.cpp
+++ b/test/array_replicate.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -61,6 +62,69 @@
   VERIFY_IS_APPROX(vx1, v1.colwise().replicate(f2));
 }
 
+// A Replicate packet cannot cross a replication boundary, so the evaluator may serve packets
+// exactly when the inner (storage-order) direction is not replicated; without the flag, colwise
+// and rowwise broadcast operations silently fall back to scalar traversal.
+template <typename Scalar>
+void check_replicate_evaluator_flags() {
+  // Storage orders are pinned so the checks keep their meaning under EIGEN_DEFAULT_TO_ROW_MAJOR.
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> Mat;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMat;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, 1, Dynamic> RowVec;
+  enum { BasePacket = int(internal::evaluator<Mat>::Flags) & PacketAccessBit };
+
+  // Inner direction not replicated: packets serve from a single copy of the argument. The first
+  // two are the shapes colwise (col-major) and rowwise (row-major) operations expand to.
+  STATIC_CHECK((int(internal::evaluator<Replicate<Vec, 1, Dynamic> >::Flags) & PacketAccessBit) == int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Replicate<RowVec, Dynamic, 1> >::Flags) & PacketAccessBit) == int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Replicate<Mat, 1, 3> >::Flags) & PacketAccessBit) == int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Replicate<RowMat, 3, 1> >::Flags) & PacketAccessBit) == int(BasePacket));
+  STATIC_CHECK(int(internal::evaluator<Replicate<Vec, 1, Dynamic> >::Alignment) ==
+               int(internal::evaluator<Vec>::Alignment));
+
+  // Replicated inner direction (or factors unknown at compile time): a packet could cross a copy
+  // boundary, so there is no packet access.
+  STATIC_CHECK((int(internal::evaluator<Replicate<Mat, 3, 1> >::Flags) & PacketAccessBit) == 0);
+  STATIC_CHECK((int(internal::evaluator<Replicate<Vec, Dynamic, 1> >::Flags) & PacketAccessBit) == 0);
+  STATIC_CHECK((int(internal::evaluator<Replicate<Mat, Dynamic, Dynamic> >::Flags) & PacketAccessBit) == 0);
+}
+
+// Exercise the (possibly vectorized) broadcast kernels with sizes that have partial-packet tails.
+template <typename Scalar>
+void replicate_broadcasts(Index rows, Index cols) {
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, 1, Dynamic> RowVec;
+
+  Mat m = Mat::Random(rows, cols);
+  Vec v = Vec::Random(rows);
+  RowVec rv = RowVec::Random(cols);
+
+  Mat c = m;
+  c.colwise() += v;
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(c(i, j), Scalar(m(i, j) + v(i)));
+
+  Mat r = m;
+  r.rowwise() += rv;
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(r(i, j), Scalar(m(i, j) + rv(j)));
+
+  Mat h = m.template replicate<1, 3>();
+  for (Index j = 0; j < 3 * cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(h(i, j), m(i, j % cols));
+
+  Mat ver = m.template replicate<3, 1>();
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < 3 * rows; ++i) VERIFY_IS_EQUAL(ver(i, j), m(i % rows, j));
+
+  // A replicate nested inside a larger coefficient-wise expression.
+  Mat sum = m + v.rowwise().replicate(cols);
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) VERIFY_IS_EQUAL(sum(i, j), Scalar(m(i, j) + v(i)));
+}
+
 EIGEN_DECLARE_TEST(array_replicate) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(replicate(Matrix<float, 1, 1>()));
@@ -69,5 +133,11 @@
     CALL_SUBTEST_4(replicate(Vector4f()));
     CALL_SUBTEST_5(replicate(VectorXf(16)));
     CALL_SUBTEST_6(replicate(VectorXcd(10)));
+    CALL_SUBTEST_7(check_replicate_evaluator_flags<float>());
+    CALL_SUBTEST_7(replicate_broadcasts<float>(internal::random<Index>(1, 64), internal::random<Index>(1, 64)));
+    CALL_SUBTEST_7(replicate_broadcasts<float>(17, 19));
+    CALL_SUBTEST_8(check_replicate_evaluator_flags<double>());
+    CALL_SUBTEST_8(replicate_broadcasts<double>(internal::random<Index>(1, 64), internal::random<Index>(1, 64)));
+    CALL_SUBTEST_8(replicate_broadcasts<std::complex<float> >(9, 5));
   }
 }
diff --git a/test/array_reverse.cpp b/test/array_reverse.cpp
index f83d498..c9fc4ee 100644
--- a/test/array_reverse.cpp
+++ b/test/array_reverse.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <iostream>
@@ -219,6 +220,34 @@
   }
 }
 
+template <typename MatrixType, int Direction>
+void reverse_destination() {
+  using Scalar = typename MatrixType::Scalar;
+  const MatrixType source = MatrixType::Random();
+  MatrixType destination, expected;
+  Reverse<MatrixType, Direction> reversed(destination);
+  for (Index j = 0; j < source.cols(); ++j)
+    for (Index i = 0; i < source.rows(); ++i)
+      expected(i, j) = source(Direction == Horizontal ? i : source.rows() - 1 - i,
+                              Direction == Vertical ? j : source.cols() - 1 - j);
+
+  reversed = source;
+  VERIFY_IS_APPROX(destination, expected);
+  destination.setConstant(Scalar(3));
+  reversed += source;
+  VERIFY_IS_APPROX(destination, (expected.array() + Scalar(3)));
+  destination.setConstant(Scalar(3));
+  reversed -= source;
+  VERIFY_IS_APPROX(destination, (Scalar(3) - expected.array()));
+}
+
+template <typename MatrixType>
+void reverse_destinations() {
+  reverse_destination<MatrixType, BothDirections>();
+  reverse_destination<MatrixType, Vertical>();
+  reverse_destination<MatrixType, Horizontal>();
+}
+
 EIGEN_DECLARE_TEST(array_reverse) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(reverse(Matrix<float, 1, 1>()));
@@ -242,4 +271,10 @@
   CALL_SUBTEST_10(reverseInPlace_boundary<float>());
   CALL_SUBTEST_10(reverseInPlace_boundary<double>());
   CALL_SUBTEST_10(reverseInPlace_boundary<int>());
+  CALL_SUBTEST_11(reverse_destinations<Vector4d>());
+  CALL_SUBTEST_11(reverse_destinations<RowVector4d>());
+  CALL_SUBTEST_11(reverse_destinations<Matrix4f>());
+  CALL_SUBTEST_11((reverse_destinations<Matrix<float, 4, 4, RowMajor>>()));
+  CALL_SUBTEST_11((reverse_destinations<Array<float, 4, 4>>()));
+  CALL_SUBTEST_11((reverse_destinations<Matrix<std::complex<float>, 4, 4>>()));
 }
diff --git a/test/assignment_threaded.cpp b/test/assignment_threaded.cpp
index 7505a10..b7ffdff 100644
--- a/test/assignment_threaded.cpp
+++ b/test/assignment_threaded.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_USE_THREADS 1
 
@@ -76,7 +77,7 @@
   VERIFY_IS_CWISE_EQUAL(ref.bottomRightCorner(blockRows, blockCols), dst.bottomRightCorner(blockRows, blockCols));
 }
 
-EIGEN_DECLARE_TEST(test) {
+EIGEN_DECLARE_TEST(assignment_threaded) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST(test_threaded_assignment(MatrixXd(), 123, 123));
     CALL_SUBTEST(test_threaded_assignment(Matrix<float, 16, 16>()));
diff --git a/test/bandmatrix.cpp b/test/bandmatrix.cpp
index 027eb06..79d87bf 100644
--- a/test/bandmatrix.cpp
+++ b/test/bandmatrix.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/basicstuff.cpp b/test/basicstuff.cpp
index 882d4a9..aab0f8e 100644
--- a/test/basicstuff.cpp
+++ b/test/basicstuff.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 #include "random_without_cast_overflow.h"
 
 template <typename MatrixType>
@@ -32,13 +34,13 @@
 
   // this test relies a lot on Random.h, and there's not much more that we can do
   // to test it, hence I consider that we will have tested Random.h
-  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols), m3(rows, cols),
-             mzero = MatrixType::Zero(rows, cols),
+  MatrixType m1 = random_for_arithmetic<MatrixType>(rows, cols), m2 = random_for_arithmetic<MatrixType>(rows, cols),
+             m3(rows, cols), mzero = MatrixType::Zero(rows, cols),
              square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>::Random(rows, rows);
-  VectorType v1 = VectorType::Random(rows), vzero = VectorType::Zero(rows);
-  SquareMatrixType sm1 = SquareMatrixType::Random(rows, rows), sm2(rows, rows);
+  VectorType v1 = random_for_arithmetic<VectorType>(rows), vzero = VectorType::Zero(rows);
+  SquareMatrixType sm1 = random_for_arithmetic<SquareMatrixType>(rows, rows), sm2(rows, rows);
 
-  Scalar x = internal::random<Scalar>();
+  Scalar x = random_scalar_for_arithmetic<Scalar>();
   if (x == Scalar(0)) x = Scalar(1);
 
   Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
@@ -115,6 +117,8 @@
 
   // check == / != operators
   VERIFY(m1 == m1);
+  // Bounded integer fixtures can coincide by chance; force one coefficient apart.
+  m2(r, c) = m1(r, c) + Scalar(1);
   VERIFY(m1 != m2);
   VERIFY(!(m1 == m2));
   VERIFY(!(m1 != m1));
@@ -195,6 +199,28 @@
   VERIFY(!static_cast<const MatrixType&>(cm).imag().isZero());
 }
 
+// Regression test for issue #3096: reading imag() of a *non-const* real-valued object used to go
+// through the writable CwiseUnaryView, whose functor returns a dangling reference to a temporary
+// for real scalars (segfault with GCC, garbage with Clang). For real scalars the non-const imag()
+// overload must return the same read-only zero expression as the const one.
+template <typename MatrixType>
+void basicStuffRealImag(const MatrixType& m) {
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols);
+  // Non-const lvalue.
+  VERIFY_IS_EQUAL(m1.imag().cwiseAbs().sum(), RealScalar(0));
+  // Non-const expression wrappers (temporaries), the case that used to crash.
+  VERIFY((m1.array().imag() == RealScalar(0)).all());
+  VERIFY_IS_EQUAL(m1.block(0, 0, rows, cols).imag().cwiseAbs().sum(), RealScalar(0));
+  // real() of a real-valued object aliases the object itself, both in the const and non-const case.
+  VERIFY(m1.real().data() == m1.data());
+  VERIFY(static_cast<const MatrixType&>(m1).real().data() == m1.data());
+}
+
 template <typename SrcScalar, typename TgtScalar>
 struct casting_test {
   static void run() {
@@ -207,7 +233,12 @@
     Matrix<TgtScalar, 4, 4> n = m.template cast<TgtScalar>();
     for (int i = 0; i < m.rows(); ++i) {
       for (int j = 0; j < m.cols(); ++j) {
-        VERIFY_IS_APPROX(n(i, j), (internal::cast<SrcScalar, TgtScalar>(m(i, j))));
+        // Materialize both values to avoid GCC miscompilation at -O3 on some targets
+        // (e.g., loongarch64) where the compiler may keep intermediate results in wider
+        // FP registers, causing the comparison to see different precision than intended.
+        TgtScalar actual = n(i, j);
+        TgtScalar expected = internal::cast<SrcScalar, TgtScalar>(m(i, j));
+        VERIFY_IS_APPROX(actual, expected);
       }
     }
   }
@@ -341,6 +372,11 @@
         MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_5(basicStuffComplex(
         MatrixXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+
+    CALL_SUBTEST_1(basicStuffRealImag(Matrix<float, 1, 1>()));
+    CALL_SUBTEST_2(basicStuffRealImag(Matrix4d()));
+    CALL_SUBTEST_7(basicStuffRealImag(
+        MatrixXd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
   }
 
   CALL_SUBTEST_1(fixedSizeMatrixConstruction<unsigned char>());
diff --git a/test/bdcsvd.cpp b/test/bdcsvd.cpp
index 3ba4cb7..350e882 100644
--- a/test/bdcsvd.cpp
+++ b/test/bdcsvd.cpp
@@ -9,13 +9,17 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/
+// SPDX-License-Identifier: MPL-2.0
 
 // discard stack allocation as that too bypasses malloc
 #define EIGEN_STACK_ALLOCATION_LIMIT 0
 #define EIGEN_RUNTIME_NO_MALLOC
 
 #include "main.h"
+#include "fp_control.h"
+#include "tridiag_test_matrices.h"
 #include <Eigen/SVD>
+#include <cstdlib>
 
 #define SVD_DEFAULT(M) BDCSVD<M>
 #define SVD_FOR_MIN_NORM(M) BDCSVD<M>
@@ -46,6 +50,8 @@
   VERIFY_IS_APPROX(bdc_svd.singularValues(), jacobi_svd.singularValues());
 }
 
+#if defined(EIGEN_TEST_PART_46) || defined(EIGEN_TEST_PART_47) || defined(EIGEN_TEST_PART_48) || \
+    defined(EIGEN_TEST_PART_49) || defined(EIGEN_TEST_PART_ALL)
 // Verifies total deflation is **not** triggered.
 void compare_bdc_jacobi_instance(bool structure_as_m, int algoswap = 16) {
   MatrixXd m(4, 3);
@@ -60,21 +66,19 @@
   }
   compare_bdc_jacobi(m, algoswap, false);
 }
+#endif
 
 template <typename MatrixType>
-void bdcsvd_thin_options(const MatrixType& input = MatrixType()) {
-  svd_thin_option_checks<MatrixType, 0>(input);
+void bdcsvd_thin_full_options(const MatrixType& input = MatrixType()) {
+  svd_thin_full_option_checks<MatrixType, 0>(input);
 }
 
 template <typename MatrixType>
-void bdcsvd_full_options(const MatrixType& input = MatrixType()) {
-  svd_option_checks_full_only<MatrixType, 0>(input);
-}
+void bdcsvd_asserts(const MatrixType& input = MatrixType()) {
+  MatrixType m(input.rows(), input.cols());
+  svd_fill_random(m);
 
-template <typename MatrixType>
-void bdcsvd_verify_assert(const MatrixType& input = MatrixType()) {
-  svd_verify_assert<MatrixType>(input);
-  svd_verify_constructor_options_assert<BDCSVD<MatrixType>>(input);
+  svd_verify_assert<MatrixType>(m);
 }
 
 template <typename MatrixType>
@@ -85,93 +89,377 @@
   VERIFY_IS_APPROX(input, D);
 }
 
-EIGEN_DECLARE_TEST(bdcsvd) {
-  CALL_SUBTEST_1((bdcsvd_verify_assert<Matrix3f>()));
-  CALL_SUBTEST_2((bdcsvd_verify_assert<Matrix4d>()));
-  CALL_SUBTEST_3((bdcsvd_verify_assert<Matrix<float, 10, 7>>()));
-  CALL_SUBTEST_4((bdcsvd_verify_assert<Matrix<float, 7, 10>>()));
-  CALL_SUBTEST_5((bdcsvd_verify_assert<Matrix<std::complex<double>, 6, 9>>()));
+// Verify SVD of bidiagonal matrix given as diagonal + superdiagonal vectors.
+template <typename RealScalar>
+void verify_bidiagonal_svd(const Matrix<RealScalar, Dynamic, 1>& diag,
+                           const Matrix<RealScalar, Dynamic, 1>& superdiag) {
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixXr;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorXr;
+  const Index n = diag.size();
 
-  CALL_SUBTEST_6((svd_all_trivial_2x2(bdcsvd_thin_options<Matrix2cd>)));
-  CALL_SUBTEST_7((svd_all_trivial_2x2(bdcsvd_full_options<Matrix2cd>)));
-  CALL_SUBTEST_8((svd_all_trivial_2x2(bdcsvd_thin_options<Matrix2d>)));
-  CALL_SUBTEST_9((svd_all_trivial_2x2(bdcsvd_full_options<Matrix2d>)));
+  BDCSVD<MatrixXr, ComputeFullU | ComputeFullV> bdcsvd(diag, superdiag);
+  VERIFY(bdcsvd.info() == Success);
+
+  const VectorXr& sv = bdcsvd.singularValues();
+
+  // Singular values must be non-negative.
+  for (Index i = 0; i < sv.size(); ++i) {
+    VERIFY(sv(i) >= RealScalar(0));
+  }
+
+  // Singular values must be sorted descending.
+  for (Index i = 1; i < sv.size(); ++i) {
+    VERIFY(sv(i - 1) >= sv(i));
+  }
+
+  // Orthogonality of U and V.
+  VERIFY_IS_APPROX(bdcsvd.matrixU().transpose() * bdcsvd.matrixU(), MatrixXr::Identity(n, n));
+  VERIFY_IS_APPROX(bdcsvd.matrixV().transpose() * bdcsvd.matrixV(), MatrixXr::Identity(n, n));
+
+  // Reconstruction: U * S * V^T should equal the original bidiagonal.
+  MatrixXr B = MatrixXr::Zero(n, n);
+  B.diagonal() = diag;
+  if (n > 1) B.diagonal(1) = superdiag;
+  MatrixXr recon = bdcsvd.matrixU() * sv.asDiagonal() * bdcsvd.matrixV().transpose();
+  VERIFY_IS_APPROX(recon, B);
+
+  // Cross-validate singular values against JacobiSVD.
+  JacobiSVD<MatrixXr> jacobi(B);
+  VERIFY_IS_APPROX(sv, jacobi.singularValues());
+}
+
+// Verify that bidiagonal API and matrix API produce matching singular values.
+template <typename RealScalar>
+void verify_bidiagonal_vs_matrix_svd(const Matrix<RealScalar, Dynamic, 1>& diag,
+                                     const Matrix<RealScalar, Dynamic, 1>& superdiag) {
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixXr;
+  const Index n = diag.size();
+
+  // Build dense bidiagonal matrix.
+  MatrixXr B = MatrixXr::Zero(n, n);
+  B.diagonal() = diag;
+  if (n > 1) B.diagonal(1) = superdiag;
+
+  BDCSVD<MatrixXr> bidiag_svd(diag, superdiag);
+  BDCSVD<MatrixXr> matrix_svd(B);
+
+  VERIFY(bidiag_svd.info() == Success);
+  VERIFY(matrix_svd.info() == Success);
+  VERIFY_IS_APPROX(bidiag_svd.singularValues(), matrix_svd.singularValues());
+}
+
+template <typename RealScalar>
+void bdcsvd_bidiagonal_hard_cases() {
+  Eigen::internal::set_is_malloc_allowed(true);
+
+  // Use the shared tridiagonal test matrix generators.
+  // Each generator fills (diag, offdiag) which we treat as (diagonal, superdiagonal)
+  // of a bidiagonal matrix.
+  test::for_all_tridiag_test_matrices<RealScalar>(
+      [](const auto& diag, const auto& offdiag) { verify_bidiagonal_svd<RealScalar>(diag, offdiag); });
+
+  // Additional SVD-specific test: identity with cross-validation against full matrix SVD.
+  test::for_tridiag_sizes<RealScalar>([](auto& diag, auto& offdiag) {
+    test::tridiag_identity(diag, offdiag);
+    verify_bidiagonal_vs_matrix_svd<RealScalar>(diag, offdiag);
+  });
+
+  // Additional SVD-specific test: scalar for n=1.
+  {
+    typedef Matrix<RealScalar, Dynamic, 1> VectorXr;
+    VectorXr diag(1), offdiag(0);
+    diag(0) = RealScalar(3.14);
+    verify_bidiagonal_svd<RealScalar>(diag, offdiag);
+  }
+}
+
+#if defined(EIGEN_TEST_PART_6) || defined(EIGEN_TEST_PART_ALL)
+void bdcsvd_mixed_option_enum_regression() {
+  using NoQrFullSVD = BDCSVD<MatrixXd, NoQRPreconditioner | ComputeFullU | ComputeFullV>;
+  using ReversedMixedSVD = BDCSVD<MatrixXd, ComputeThinU | DisableQRDecomposition | ComputeFullV>;
+
+  STATIC_CHECK((int(NoQrFullSVD::QRDecomposition) == int(NoQRPreconditioner)));
+  STATIC_CHECK((NoQrFullSVD::ComputationOptions == (ComputeFullU | ComputeFullV)));
+
+  STATIC_CHECK((int(ReversedMixedSVD::QRDecomposition) == int(DisableQRDecomposition)));
+  STATIC_CHECK((ReversedMixedSVD::ComputationOptions == (ComputeThinU | ComputeFullV)));
+}
+#endif
+
+#if defined(EIGEN_TEST_PART_53) || defined(EIGEN_TEST_PART_ALL)
+void bdcsvd_extreme_scale_regressions() {
+  typedef Matrix<double, 6, 6> Matrix6d;
+  const double kTolerance = 16 * Matrix6d::RowsAtCompileTime * NumTraits<double>::epsilon();
+
+  const auto verify_decomposition = [kTolerance](const Matrix6d& matrix) {
+    BDCSVD<Matrix6d, ComputeFullU | ComputeFullV> svd;
+    svd.setSwitchSize(3);
+    svd.compute(matrix);
+
+    VERIFY(svd.info() == Success);
+
+    const Matrix6d reconstruction = svd.matrixU() * svd.singularValues().asDiagonal() * svd.matrixV().transpose();
+    VERIFY((reconstruction - matrix).stableNorm() <= kTolerance * matrix.stableNorm());
+
+    const Matrix6d identity = Matrix6d::Identity();
+    VERIFY((svd.matrixU().transpose() * svd.matrixU() - identity).stableNorm() <= kTolerance);
+    VERIFY((svd.matrixV().transpose() * svd.matrixV() - identity).stableNorm() <= kTolerance);
+
+    // Also exercise the values-only path, which uses a compact m_naiveU and
+    // linear workspace during divide-and-conquer merges.
+    BDCSVD<Matrix6d> valuesOnlySvd;
+    valuesOnlySvd.setSwitchSize(3);
+    valuesOnlySvd.compute(matrix);
+    VERIFY(valuesOnlySvd.info() == Success);
+    VERIFY_IS_APPROX(valuesOnlySvd.singularValues(), svd.singularValues());
+  };
+
+  Matrix6d matrix = Matrix6d::Zero();
+  const double kSubnormal1040 = std::numeric_limits<double>::denorm_min() * 17179869184.0;  // 2^-1040
+  const double kSubnormal1060 = std::numeric_limits<double>::denorm_min() * 16384.0;        // 2^-1060
+  const double kSmallestNormal = (std::numeric_limits<double>::min)();                      // 2^-1022
+  const double kNormal1000 = kSmallestNormal * 4194304.0;                                   // 2^-1000
+
+  // The merge combines normal and subnormal couplings. Squaring the two
+  // coupling terms directly used to underflow, which later left perturbCol0
+  // without a predecessor and made the decomposition report NumericalIssue.
+  matrix.diagonal() << kSubnormal1040, -kSubnormal1060, kSmallestNormal, 0.5, 1.0, kSmallestNormal;
+  matrix.diagonal(1) << -kNormal1000, kNormal1000, kSubnormal1040, kSubnormal1060, -8.0;
+  verify_decomposition(matrix);
+
+  // A singular-vector coefficient grows to about 2^570 here. Its squared
+  // norm overflows even though the vector has a finite, well-scaled
+  // normalization.
+  using std::ldexp;
+  matrix.setZero();
+  matrix.diagonal() << 0.0, 0.0, ldexp(1.0, -487), -1.0, 0.0, 0.0;
+  matrix.diagonal(1) << 0.0, ldexp(1.0, -453), -ldexp(1.0, -627), 0.0, 0.0;
+  verify_decomposition(matrix);
+}
+#endif
+
+#if defined(EIGEN_TEST_PART_54) || defined(EIGEN_TEST_PART_ALL)
+void bdcsvd_fast_math_regression_1588() {
+  const Index n = 500;
+  MatrixXd matrix = MatrixXd::Zero(n, n);
+
+  std::srand(1);
+  for (Index k = 0; k < 5000; ++k) {
+    const Index row = std::rand() % n;
+    const Index col = std::rand() % n;
+    matrix(row, col) = static_cast<double>(std::rand()) / static_cast<double>(RAND_MAX);
+  }
+  matrix = matrix * matrix;
+
+  BDCSVD<MatrixXd, ComputeThinU | ComputeThinV> svd(matrix);
+  VERIFY(svd.info() == Success);
+
+  MatrixXd reconstruction = svd.matrixU() * svd.singularValues().asDiagonal() * svd.matrixV().transpose();
+  const double relative_error = (reconstruction - matrix).norm() / matrix.norm();
+  // Deterministic input (fixed seed); the reconstruction is backward stable, so the relative error stays near eps.
+  VERIFY(relative_error < 64 * NumTraits<double>::epsilon());
+}
+#endif
+
+void bdcsvd_power_of_two_scaling() {
+  // Reciprocal scaling rounds the smaller singular value down by one ULP in both entry paths.
+  const Index size = 20;
+  VectorXf diagonal = VectorXf::Zero(size);
+  diagonal(0) = numext::bit_cast<float>(numext::uint32_t(0x13afd4a1));
+  diagonal(1) = numext::bit_cast<float>(numext::uint32_t(0x11525720));
+
+  MatrixXf matrix = MatrixXf::Zero(size, size + 1);
+  matrix.leftCols(size).diagonal() = diagonal;
+  BDCSVD<MatrixXf> denseSvd;
+  denseSvd.setSwitchSize(8);
+  denseSvd.compute(matrix);
+  VERIFY_IS_EQUAL(denseSvd.singularValues()(0), diagonal(0));
+  VERIFY_IS_EQUAL(denseSvd.singularValues()(1), diagonal(1));
+
+  BDCSVD<MatrixXf> bidiagonalSvd;
+  bidiagonalSvd.setSwitchSize(8);
+  bidiagonalSvd.compute(diagonal, VectorXf::Zero(size - 1));
+  VERIFY_IS_EQUAL(bidiagonalSvd.singularValues()(0), diagonal(0));
+  VERIFY_IS_EQUAL(bidiagonalSvd.singularValues()(1), diagonal(1));
+
+  // A subnormal coupling remains significant relative to a uniformly tiny bidiagonal matrix. Scale it without first
+  // feeding the subnormal operand to packet arithmetic, which flushes it on ARMv7 NEON.
+  const auto checkSubnormalCoupling = [&]() {
+    volatile float normalMin = (std::numeric_limits<float>::min)();
+    const float largest = 256.0f * normalMin;
+    // Construct min_normal / 2 without arithmetic that FTZ would flush before it reaches the solver.
+    const float coupling = numext::bit_cast<float>(numext::uint32_t(0x00400000));
+    diagonal.setZero();
+    diagonal(0) = largest;
+    VectorXf superdiagonal = VectorXf::Zero(size - 1);
+    superdiagonal(0) = coupling;
+    VERIFY_IS_EQUAL(numext::bit_cast<numext::uint32_t>(superdiagonal(0)), numext::uint32_t(0x00400000));
+    const float expectedRatio = numext::sqrt(1.0f + 1.0f / (512.0f * 512.0f));
+    for (int switchSize : {8, 32}) {
+      bidiagonalSvd.setSwitchSize(switchSize);
+      bidiagonalSvd.compute(diagonal, superdiagonal);
+      VERIFY(numext::abs(bidiagonalSvd.singularValues()(0) / largest - expectedRatio) <=
+             2.0f * NumTraits<float>::epsilon());
+    }
+  };
+  checkSubnormalCoupling();
+  ScopedFlushToZero ftz;
+  checkSubnormalCoupling();
+}
+
+template <typename RealScalar>
+void bdcsvd_secular_extrapolation() {
+  using Mat = Matrix<RealScalar, Dynamic, Dynamic>;
+  using Vec = Matrix<RealScalar, Dynamic, 1>;
+  for (Index n : {31, 32, 33, 63, 64, 65, 127, 128, 129}) {
+    Mat bidiagonal = Mat::Zero(n, n);
+    Vec diagonal = Vec::Random(n), superdiagonal = Vec::Random(n - 1);
+    for (int kind = 0; kind < 3; ++kind) {
+      if (kind == 1) {
+        diagonal.setOnes();
+        superdiagonal *= numext::sqrt(NumTraits<RealScalar>::epsilon());
+      } else if (kind == 2) {
+        diagonal = Vec::LinSpaced(n, RealScalar(0), RealScalar(1));
+        superdiagonal.setRandom();
+        for (Index i = 0; i + 1 < n; i += 7) superdiagonal(i) = RealScalar(0);
+      }
+      bidiagonal.diagonal() = diagonal;
+      bidiagonal.template diagonal<1>() = superdiagonal;
+      BDCSVD<Mat, ComputeFullU | ComputeFullV> svd(diagonal, superdiagonal);
+      VERIFY_IS_EQUAL(svd.info(), Success);
+      // Reconstruction and orthogonality each accumulate O(n * epsilon) rounding.
+      const RealScalar bound = RealScalar(64 * n) * NumTraits<RealScalar>::epsilon();
+      VERIFY((bidiagonal - svd.matrixU() * svd.singularValues().asDiagonal() * svd.matrixV().transpose()).norm() <=
+             bound * bidiagonal.norm());
+      const Mat identity = Mat::Identity(n, n);
+      VERIFY((svd.matrixU().transpose() * svd.matrixU() - identity).norm() <= bound);
+      VERIFY((svd.matrixV().transpose() * svd.matrixV() - identity).norm() <= bound);
+      JacobiSVD<Mat> reference(bidiagonal);
+      VERIFY((svd.singularValues() - reference.singularValues()).norm() <= bound * bidiagonal.norm());
+      BDCSVD<Mat> valuesOnly(diagonal, superdiagonal);
+      VERIFY_IS_EQUAL(valuesOnly.info(), Success);
+      VERIFY((valuesOnly.singularValues() - reference.singularValues()).norm() <= bound * bidiagonal.norm());
+    }
+  }
+}
+
+template <typename Scalar, int StorageOrder>
+void bdcsvd_qr_crossover() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  constexpr int options = ComputeThinU | ComputeThinV;
+  for (Index n : {16, 31}) {
+    for (Index rows : {4 * n - 1, 4 * n, 4 * n + 3, 4 * n + 4}) {
+      Mat tall = Mat::Random(rows, n);
+      tall.col(1) = tall.col(0);
+      for (bool transpose : {false, true}) {
+        Mat a;
+        if (transpose)
+          a = tall.adjoint();
+        else
+          a = tall;
+        BDCSVD<Mat, options> svd(a);
+        BDCSVD<Mat, options | int(DisableQRDecomposition)> direct(a);
+        VERIFY_IS_EQUAL(svd.info(), Success);
+        VERIFY_IS_EQUAL(direct.info(), Success);
+        const RealScalar bound = RealScalar(64 * rows) * NumTraits<RealScalar>::epsilon();
+        VERIFY((a - svd.matrixU() * svd.singularValues().asDiagonal() * svd.matrixV().adjoint()).norm() <=
+               bound * a.norm());
+        const Mat identity = Mat::Identity(n, n);
+        VERIFY((svd.matrixU().adjoint() * svd.matrixU() - identity).norm() <= bound);
+        VERIFY((svd.matrixV().adjoint() * svd.matrixV() - identity).norm() <= bound);
+        VERIFY((svd.singularValues() - direct.singularValues()).norm() <= bound * a.norm());
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(bdcsvd) {
+  CALL_SUBTEST_60((svd_normal_equation_roundoff<float, ColMajor>()));
+  CALL_SUBTEST_60((svd_normal_equation_roundoff<double, RowMajor>()));
+  CALL_SUBTEST_61((svd_normal_equation_roundoff<std::complex<float>, RowMajor>()));
+  CALL_SUBTEST_61((svd_normal_equation_roundoff<std::complex<double>, ColMajor>()));
+
+  CALL_SUBTEST_2((bdcsvd_asserts<Matrix4d>()));
+  CALL_SUBTEST_3((bdcsvd_asserts<Matrix<float, 10, 7>>()));
+  CALL_SUBTEST_4((bdcsvd_asserts<Matrix<float, 7, 10>>()));
+  CALL_SUBTEST_5((bdcsvd_asserts<Matrix<std::complex<double>, 6, 9>>()));
+  CALL_SUBTEST_6((bdcsvd_mixed_option_enum_regression()));
+
+  CALL_SUBTEST_7((bdcsvd_thin_full_options<Matrix2cd>()));
+  CALL_SUBTEST_9((bdcsvd_thin_full_options<Matrix2d>()));
 
   for (int i = 0; i < g_repeat; i++) {
     int r = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2), c = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
 
-    TEST_SET_BUT_UNUSED_VARIABLE(r)
-    TEST_SET_BUT_UNUSED_VARIABLE(c)
+    TEST_SET_BUT_UNUSED_VARIABLE(r);
+    TEST_SET_BUT_UNUSED_VARIABLE(c);
 
-    CALL_SUBTEST_10((compare_bdc_jacobi<MatrixXf>(MatrixXf(r, c))));
-    CALL_SUBTEST_11((compare_bdc_jacobi<MatrixXd>(MatrixXd(r, c))));
-    CALL_SUBTEST_12((compare_bdc_jacobi<MatrixXcd>(MatrixXcd(r, c))));
+    CALL_SUBTEST_11((compare_bdc_jacobi<MatrixXf>(MatrixXf(r, c))));
+    CALL_SUBTEST_12((compare_bdc_jacobi<MatrixXd>(MatrixXd(r, c))));
+    CALL_SUBTEST_13((compare_bdc_jacobi<MatrixXcd>(MatrixXcd(r, c))));
     // Test on inf/nan matrix
-    CALL_SUBTEST_13((svd_inf_nan<MatrixXf>()));
-    CALL_SUBTEST_14((svd_inf_nan<MatrixXd>()));
+    CALL_SUBTEST_14((svd_inf_nan<MatrixXf>()));
+    CALL_SUBTEST_15((svd_inf_nan<MatrixXd>()));
 
     // Verify some computations using all combinations of the Options template parameter.
-    CALL_SUBTEST_15((bdcsvd_thin_options<Matrix3f>()));
-    CALL_SUBTEST_16((bdcsvd_full_options<Matrix3f>()));
-    CALL_SUBTEST_17((bdcsvd_thin_options<Matrix<float, 2, 3>>()));
-    CALL_SUBTEST_18((bdcsvd_full_options<Matrix<float, 2, 3>>()));
-    CALL_SUBTEST_19((bdcsvd_thin_options<MatrixXd>(MatrixXd(20, 17))));
-    CALL_SUBTEST_20((bdcsvd_full_options<MatrixXd>(MatrixXd(20, 17))));
-    CALL_SUBTEST_21((bdcsvd_thin_options<MatrixXd>(MatrixXd(17, 20))));
-    CALL_SUBTEST_22((bdcsvd_full_options<MatrixXd>(MatrixXd(17, 20))));
-    CALL_SUBTEST_23((bdcsvd_thin_options<Matrix<double, Dynamic, 15>>(Matrix<double, Dynamic, 15>(r, 15))));
-    CALL_SUBTEST_24((bdcsvd_full_options<Matrix<double, Dynamic, 15>>(Matrix<double, Dynamic, 15>(r, 15))));
-    CALL_SUBTEST_25((bdcsvd_thin_options<Matrix<double, 13, Dynamic>>(Matrix<double, 13, Dynamic>(13, c))));
-    CALL_SUBTEST_26((bdcsvd_full_options<Matrix<double, 13, Dynamic>>(Matrix<double, 13, Dynamic>(13, c))));
-    CALL_SUBTEST_27((bdcsvd_thin_options<MatrixXf>(MatrixXf(r, c))));
-    CALL_SUBTEST_28((bdcsvd_full_options<MatrixXf>(MatrixXf(r, c))));
-    CALL_SUBTEST_29((bdcsvd_thin_options<MatrixXcd>(MatrixXcd(r, c))));
-    CALL_SUBTEST_30((bdcsvd_full_options<MatrixXcd>(MatrixXcd(r, c))));
-    CALL_SUBTEST_31((bdcsvd_thin_options<MatrixXd>(MatrixXd(r, c))));
-    CALL_SUBTEST_32((bdcsvd_full_options<MatrixXd>(MatrixXd(r, c))));
-    CALL_SUBTEST_33((bdcsvd_thin_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
+    CALL_SUBTEST_16((bdcsvd_thin_full_options<Matrix3f>()));
+    CALL_SUBTEST_18((bdcsvd_thin_full_options<Matrix<float, 2, 3>>()));
+    CALL_SUBTEST_20((bdcsvd_thin_full_options<MatrixXd>(MatrixXd(20, 17))));
+    CALL_SUBTEST_22((bdcsvd_thin_full_options<MatrixXd>(MatrixXd(17, 20))));
+    CALL_SUBTEST_24((bdcsvd_thin_full_options<Matrix<double, Dynamic, 15>>(Matrix<double, Dynamic, 15>(r, 15))));
+    CALL_SUBTEST_26((bdcsvd_thin_full_options<Matrix<double, 13, Dynamic>>(Matrix<double, 13, Dynamic>(13, c))));
+    CALL_SUBTEST_28((bdcsvd_thin_full_options<MatrixXf>(MatrixXf(r, c))));
+    CALL_SUBTEST_30((bdcsvd_thin_full_options<MatrixXcd>(MatrixXcd(r, c))));
+    CALL_SUBTEST_32((bdcsvd_thin_full_options<MatrixXd>(MatrixXd(r, c))));
+    CALL_SUBTEST_34((bdcsvd_thin_full_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
         Matrix<double, Dynamic, Dynamic, RowMajor>(20, 27))));
-    CALL_SUBTEST_34((bdcsvd_full_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
-        Matrix<double, Dynamic, Dynamic, RowMajor>(20, 27))));
-    CALL_SUBTEST_35((bdcsvd_thin_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
+    CALL_SUBTEST_36((bdcsvd_thin_full_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
         Matrix<double, Dynamic, Dynamic, RowMajor>(27, 20))));
-    CALL_SUBTEST_36((bdcsvd_full_options<Matrix<double, Dynamic, Dynamic, RowMajor>>(
-        Matrix<double, Dynamic, Dynamic, RowMajor>(27, 20))));
-    CALL_SUBTEST_37((
+    CALL_SUBTEST_38((
         svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, ColMajor, 20, 35>, ColPivHouseholderQRPreconditioner>(
             r, c)));
-    CALL_SUBTEST_38(
+    CALL_SUBTEST_39(
         (svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, ColMajor, 35, 20>, HouseholderQRPreconditioner>(r,
                                                                                                                    c)));
-    CALL_SUBTEST_39((
+    CALL_SUBTEST_40((
         svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, RowMajor, 20, 35>, ColPivHouseholderQRPreconditioner>(
             r, c)));
-    CALL_SUBTEST_40(
+    CALL_SUBTEST_41(
         (svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, RowMajor, 35, 20>, HouseholderQRPreconditioner>(r,
                                                                                                                    c)));
   }
 
   // test matrixbase method
-  CALL_SUBTEST_41((bdcsvd_method<Matrix2cd>()));
-  CALL_SUBTEST_42((bdcsvd_method<Matrix3f>()));
-
-  // Test problem size constructors
-  CALL_SUBTEST_43(BDCSVD<MatrixXf>(10, 10));
+  CALL_SUBTEST_42((bdcsvd_method<Matrix2cd>()));
+  CALL_SUBTEST_43((bdcsvd_method<Matrix3f>()));
 
   // Check that preallocation avoids subsequent mallocs
   // Disabled because not supported by BDCSVD
   // CALL_SUBTEST_9( svd_preallocate<void>() );
 
-  CALL_SUBTEST_44(svd_underoverflow<void>());
+  CALL_SUBTEST_45(svd_underoverflow<void>());
+  CALL_SUBTEST_45(bdcsvd_power_of_two_scaling());
 
   // Without total deflation issues.
-  CALL_SUBTEST_45((compare_bdc_jacobi_instance(true)));
-  CALL_SUBTEST_46((compare_bdc_jacobi_instance(false)));
+  CALL_SUBTEST_46((compare_bdc_jacobi_instance(true)));
+  CALL_SUBTEST_47((compare_bdc_jacobi_instance(false)));
 
   // With total deflation issues before, when it shouldn't be triggered.
-  CALL_SUBTEST_47((compare_bdc_jacobi_instance(true, 3)));
-  CALL_SUBTEST_48((compare_bdc_jacobi_instance(false, 3)));
+  CALL_SUBTEST_48((compare_bdc_jacobi_instance(true, 3)));
+  CALL_SUBTEST_49((compare_bdc_jacobi_instance(false, 3)));
 
   // Convergence for large constant matrix (https://gitlab.com/libeigen/eigen/-/issues/2491)
-  CALL_SUBTEST_49(bdcsvd_check_convergence<MatrixXf>(MatrixXf::Constant(500, 500, 1)));
+  CALL_SUBTEST_50(bdcsvd_check_convergence<MatrixXf>(MatrixXf::Constant(500, 500, 1)));
+
+  // Bidiagonal SVD hard test cases
+  CALL_SUBTEST_51((bdcsvd_bidiagonal_hard_cases<float>()));
+  CALL_SUBTEST_52((bdcsvd_bidiagonal_hard_cases<double>()));
+  CALL_SUBTEST_53((bdcsvd_extreme_scale_regressions()));
+  CALL_SUBTEST_54((bdcsvd_fast_math_regression_1588()));
+  CALL_SUBTEST_55((bdcsvd_secular_extrapolation<float>()));
+  CALL_SUBTEST_56((bdcsvd_secular_extrapolation<double>()));
+  CALL_SUBTEST_57((bdcsvd_qr_crossover<float, ColMajor>()));
+  CALL_SUBTEST_58((bdcsvd_qr_crossover<double, RowMajor>()));
+  CALL_SUBTEST_59((bdcsvd_qr_crossover<std::complex<double>, ColMajor>()));
 }
diff --git a/test/bdcsvd_fastmath.cpp b/test/bdcsvd_fastmath.cpp
new file mode 100644
index 0000000..733eeee
--- /dev/null
+++ b/test/bdcsvd_fastmath.cpp
@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/SVD>
+
+EIGEN_DECLARE_TEST(bdcsvd_fastmath) {
+  typedef Matrix<double, 6, 6> Matrix6d;
+  const double kTolerance = 16 * Matrix6d::RowsAtCompileTime * NumTraits<double>::epsilon();
+
+  // A finite singular-vector coefficient grows to about 2^570. Its ordinary
+  // squared norm overflows, and GCC's -ffast-math assumes isfinite() is true.
+  Matrix6d matrix = Matrix6d::Zero();
+  using std::ldexp;
+  matrix.diagonal() << 0.0, 0.0, ldexp(1.0, -487), -1.0, 0.0, 0.0;
+  matrix.diagonal(1) << 0.0, ldexp(1.0, -453), -ldexp(1.0, -627), 0.0, 0.0;
+
+  BDCSVD<Matrix6d, ComputeFullU | ComputeFullV> svd;
+  svd.setSwitchSize(3);
+  svd.compute(matrix);
+
+  VERIFY(svd.info() == Success);
+  const Matrix6d reconstruction = svd.matrixU() * svd.singularValues().asDiagonal() * svd.matrixV().transpose();
+  VERIFY((reconstruction - matrix).stableNorm() <= kTolerance * matrix.stableNorm());
+
+  const Matrix6d identity = Matrix6d::Identity();
+  VERIFY((svd.matrixU().transpose() * svd.matrixU() - identity).stableNorm() <= kTolerance);
+  VERIFY((svd.matrixV().transpose() * svd.matrixV() - identity).stableNorm() <= kTolerance);
+}
diff --git a/test/bfloat16_classification.cpp b/test/bfloat16_classification.cpp
new file mode 100644
index 0000000..6a698d4
--- /dev/null
+++ b/test/bfloat16_classification.cpp
@@ -0,0 +1,118 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// isinf/isnan/isfinite of every bfloat16 encoding, scalar, packet and through the public array predicates. The
+// inputs are built from raw bits and the expectations from the exponent and mantissa fields in integer arithmetic,
+// so nothing here can fold under -ffast-math: bfloat16_classification_fastmath compiles this file with that flag,
+// under which a classification of the widened float folds to "not NaN, not inf, finite".
+
+#include "main.h"
+
+namespace {
+
+using Eigen::numext::uint16_t;
+
+struct Classification {
+  bool is_inf, is_nan, is_finite;
+};
+
+// An exponent field of all ones is an infinity with a zero mantissa and a NaN otherwise.
+Classification classify(uint16_t bits) {
+  const bool exponent_all_ones = (bits & 0x7f80) == 0x7f80;
+  const bool mantissa_zero = (bits & 0x007f) == 0;
+  return {exponent_all_ones && mantissa_zero, exponent_all_ones && !mantissa_zero, !exponent_all_ones};
+}
+
+bfloat16 from_bits(int bits) { return numext::bit_cast<bfloat16>(static_cast<uint16_t>(bits)); }
+uint16_t bits_of(bfloat16 x) { return numext::bit_cast<uint16_t>(x); }
+
+void bfloat16_scalar_classification() {
+  for (int bits = 0; bits <= 0xffff; ++bits) {
+    const Classification expected = classify(static_cast<uint16_t>(bits));
+    const bfloat16 x = from_bits(bits);
+    VERIFY_IS_EQUAL((numext::isinf)(x), expected.is_inf);
+    VERIFY_IS_EQUAL((numext::isnan)(x), expected.is_nan);
+    VERIFY_IS_EQUAL((numext::isfinite)(x), expected.is_finite);
+  }
+}
+
+// A vectorized packet must return a full-bit mask per lane: all ones where the predicate holds, all zeros elsewhere.
+template <typename Packet, bool Vectorized = internal::unpacket_traits<Packet>::vectorizable>
+struct packet_classification {
+  static void run() {
+    constexpr int PacketSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_MAX bfloat16 in[PacketSize], is_inf[PacketSize], is_nan[PacketSize], is_finite[PacketSize];
+    for (int start = 0; start <= 0xffff; start += PacketSize) {
+      for (int lane = 0; lane < PacketSize; ++lane) in[lane] = from_bits(start + lane);
+      const Packet a = internal::pload<Packet>(in);
+      internal::pstore(is_inf, internal::pisinf(a));
+      internal::pstore(is_nan, internal::pisnan(a));
+      internal::pstore(is_finite, internal::pisfinite(a));
+      for (int lane = 0; lane < PacketSize; ++lane) {
+        const Classification expected = classify(static_cast<uint16_t>(start + lane));
+        VERIFY_IS_EQUAL(bits_of(is_inf[lane]), expected.is_inf ? 0xffff : 0);
+        VERIFY_IS_EQUAL(bits_of(is_nan[lane]), expected.is_nan ? 0xffff : 0);
+        VERIFY_IS_EQUAL(bits_of(is_finite[lane]), expected.is_finite ? 0xffff : 0);
+      }
+    }
+  }
+};
+template <typename Packet>
+struct packet_classification<Packet, false> {
+  static void run() {}
+};
+
+void bfloat16_packet_classification() {
+  using Packet = internal::packet_traits<bfloat16>::type;
+  using HalfPacket = internal::unpacket_traits<Packet>::half;
+  packet_classification<Packet>::run();
+  if (!std::is_same<Packet, HalfPacket>::value) packet_classification<HalfPacket>::run();
+}
+
+using ArrayType = Array<bfloat16, Dynamic, 1>;
+
+// The bool predicates go through numext::is*; the typed ones through pis* on whole packets and numext::is* on the
+// scalar tail, where a lane is the all-ones mask or Scalar(1), so only its truth value is checked. isFiniteTyped()
+// is the public typed predicate; the isinf/isnan functors have no public entry point and are applied directly.
+// (allFinite() is not checked: under __FINITE_MATH_ONLY__ it is true by definition, see all_finite_impl.)
+void check_array_classification(const ArrayType& x) {
+  const Array<bool, Dynamic, 1> is_inf = x.isInf(), is_nan = x.isNaN(), is_finite = x.isFinite();
+  const ArrayType typed_inf = x.unaryExpr(internal::scalar_isinf_op<bfloat16, true>()),
+                  typed_nan = x.unaryExpr(internal::scalar_isnan_op<bfloat16, true>()),
+                  typed_finite = x.isFiniteTyped();
+  for (Index i = 0; i < x.size(); ++i) {
+    const Classification expected = classify(bits_of(x[i]));
+    VERIFY_IS_EQUAL(is_inf[i], expected.is_inf);
+    VERIFY_IS_EQUAL(is_nan[i], expected.is_nan);
+    VERIFY_IS_EQUAL(is_finite[i], expected.is_finite);
+    VERIFY_IS_EQUAL(bits_of(typed_inf[i]) != 0, expected.is_inf);
+    VERIFY_IS_EQUAL(bits_of(typed_nan[i]) != 0, expected.is_nan);
+    VERIFY_IS_EQUAL(bits_of(typed_finite[i]) != 0, expected.is_finite);
+  }
+}
+
+void bfloat16_array_classification() {
+  ArrayType all(0x10000);
+  for (Index i = 0; i < all.size(); ++i) all[i] = from_bits(int(i));
+  check_array_classification(all);
+  // Lengths that are not a multiple of the packet size leave a scalar tail; over these lengths it crosses the
+  // largest finite value, the infinity and the first NaNs of either sign.
+  for (Index len = 1; len <= 33; ++len) {
+    check_array_classification(all.segment(0x7f70, len));
+    check_array_classification(all.segment(0xff70, len));
+  }
+}
+
+}  // namespace
+
+EIGEN_DECLARE_TEST(bfloat16_classification) {
+  CALL_SUBTEST(bfloat16_scalar_classification());
+  CALL_SUBTEST(bfloat16_packet_classification());
+  CALL_SUBTEST(bfloat16_array_classification());
+}
diff --git a/test/bfloat16_classification_fastmath.cpp b/test/bfloat16_classification_fastmath.cpp
new file mode 100644
index 0000000..abab0da
--- /dev/null
+++ b/test/bfloat16_classification_fastmath.cpp
@@ -0,0 +1,12 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// The same checks compiled with the compiler's fast-math flags (test/CMakeLists.txt), under which a classification
+// of the widened float folds to false: isinf/isnan/isfinite of a bfloat16 have to test its bits.
+#include "bfloat16_classification.cpp"  // NOLINT(bugprone-suspicious-include): the same suite under fast-math flags.
diff --git a/test/bfloat16_float.cpp b/test/bfloat16_float.cpp
index 12d6d86..7556d63 100644
--- a/test/bfloat16_float.cpp
+++ b/test/bfloat16_float.cpp
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include <sstream>
 #include <memory>
@@ -127,17 +129,15 @@
   VERIFY_IS_EQUAL(static_cast<float>(-bfloat16(3.0f)), -3.0f);
   VERIFY_IS_EQUAL(static_cast<float>(-bfloat16(-4.5f)), 4.5f);
 
-#if !EIGEN_COMP_MSVC
-  // Visual Studio errors out on divisions by 0
-  VERIFY((numext::isnan)(static_cast<float>(bfloat16(0.0 / 0.0))));
-  VERIFY((numext::isinf)(static_cast<float>(bfloat16(1.0 / 0.0))));
-  VERIFY((numext::isinf)(static_cast<float>(bfloat16(-1.0 / 0.0))));
+  const double nan = std::numeric_limits<double>::quiet_NaN();
+  const double infinity = std::numeric_limits<double>::infinity();
+  VERIFY((numext::isnan)(static_cast<float>(bfloat16(nan))));
+  VERIFY((numext::isinf)(static_cast<float>(bfloat16(infinity))));
+  VERIFY((numext::isinf)(static_cast<float>(bfloat16(-infinity))));
 
-  // Visual Studio errors out on divisions by 0
-  VERIFY((numext::isnan)(bfloat16(0.0 / 0.0)));
-  VERIFY((numext::isinf)(bfloat16(1.0 / 0.0)));
-  VERIFY((numext::isinf)(bfloat16(-1.0 / 0.0)));
-#endif
+  VERIFY((numext::isnan)(bfloat16(nan)));
+  VERIFY((numext::isinf)(bfloat16(infinity)));
+  VERIFY((numext::isinf)(bfloat16(-infinity)));
 
   // NaNs and infinities.
   VERIFY(!(numext::isinf)(static_cast<float>(bfloat16(3.38e38f))));  // Largest finite number.
@@ -179,6 +179,13 @@
 
   VERIFY(NumTraits<bfloat16>::IsSigned);
 
+  // The bfloat16 machine epsilon is 2^-7 = 0x3c00, and NumTraits must agree
+  // with std::numeric_limits.
+  VERIFY_BFLOAT16_BITS_EQUAL(NumTraits<bfloat16>::epsilon(), 0x3c00);
+  VERIFY_BFLOAT16_BITS_EQUAL(std::numeric_limits<bfloat16>::epsilon(), 0x3c00);
+  VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(NumTraits<bfloat16>::epsilon()),
+                  numext::bit_cast<numext::uint16_t>(std::numeric_limits<bfloat16>::epsilon()));
+
   VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(std::numeric_limits<bfloat16>::infinity()),
                   numext::bit_cast<numext::uint16_t>(bfloat16(std::numeric_limits<float>::infinity())));
   // There is no guarantee that casting a 32-bit NaN to bfloat16 has a precise
@@ -235,19 +242,19 @@
   VERIFY(bfloat16(1.0f) != bfloat16(2.0f));
 
   // Comparisons with NaNs and infinities.
-#if !EIGEN_COMP_MSVC
-  // Visual Studio errors out on divisions by 0
-  VERIFY(!(bfloat16(0.0 / 0.0) == bfloat16(0.0 / 0.0)));
-  VERIFY(bfloat16(0.0 / 0.0) != bfloat16(0.0 / 0.0));
+  const bfloat16 nan(std::numeric_limits<double>::quiet_NaN());
+  const bfloat16 infinity(std::numeric_limits<double>::infinity());
+  const bfloat16 negative_infinity(-std::numeric_limits<double>::infinity());
+  VERIFY(!(nan == nan));
+  VERIFY(nan != nan);
 
-  VERIFY(!(bfloat16(1.0) == bfloat16(0.0 / 0.0)));
-  VERIFY(!(bfloat16(1.0) < bfloat16(0.0 / 0.0)));
-  VERIFY(!(bfloat16(1.0) > bfloat16(0.0 / 0.0)));
-  VERIFY(bfloat16(1.0) != bfloat16(0.0 / 0.0));
+  VERIFY(!(bfloat16(1.0) == nan));
+  VERIFY(!(bfloat16(1.0) < nan));
+  VERIFY(!(bfloat16(1.0) > nan));
+  VERIFY(bfloat16(1.0) != nan);
 
-  VERIFY(bfloat16(1.0) < bfloat16(1.0 / 0.0));
-  VERIFY(bfloat16(1.0) > bfloat16(-1.0 / 0.0));
-#endif
+  VERIFY(bfloat16(1.0) < infinity);
+  VERIFY(bfloat16(1.0) > negative_infinity);
 }
 
 void test_basic_functions() {
@@ -377,9 +384,11 @@
          std::numeric_limits<bfloat16>::infinity());
   VERIFY(numext::nextafter(-(std::numeric_limits<bfloat16>::max)(), -std::numeric_limits<bfloat16>::infinity()) ==
          -std::numeric_limits<bfloat16>::infinity());
+  // The neighbors of ±0 are the smallest subnormals with the sign of the
+  // direction, matching std::nextafter (IEEE-754 nextUp/nextDown of zero).
   VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(1.0f)), 0x0001);
-  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(1.0f)), 0x0000);
-  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(-1.0f)), 0x8000);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(1.0f)), 0x0001);
+  VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(-1.0f)), 0x8001);
   VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(-1.0f)), 0x8001);
   VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(0.0f), bfloat16(-0.0f)), 0x8000);
   VERIFY_BFLOAT16_BITS_EQUAL(numext::nextafter(bfloat16(-0.0f), bfloat16(0.0f)), 0x0000);
diff --git a/test/bicgstab.cpp b/test/bicgstab.cpp
index 6d837e5..2b3e5de 100644
--- a/test/bicgstab.cpp
+++ b/test/bicgstab.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 #include <Eigen/IterativeLinearSolvers>
@@ -44,7 +45,10 @@
   expected(6) = -1001;
   expected(12) = -1001;
   expected(13) = 1001;
-  VERIFY_IS_EQUAL(x, expected);
+  // The regression is the breakdown handling (a spurious "not converged"), so require an
+  // accurate solution, not a bit-exact one: FP contraction makes the iterate differ by a
+  // few ulps on some targets (e.g. riscv64).
+  VERIFY_IS_APPROX(x, expected);
 
   Eigen::VectorXd residual = b - A * x;
   VERIFY(residual.isZero());
diff --git a/test/bicgstabl.cpp b/test/bicgstabl.cpp
new file mode 100644
index 0000000..256ce93
--- /dev/null
+++ b/test/bicgstabl.cpp
@@ -0,0 +1,39 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
+// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T>
+void test_bicgstabl_T() {
+  BiCGSTABL<SparseMatrix<T>, DiagonalPreconditioner<T> > bicgstabl_colmajor_diag;
+  BiCGSTABL<SparseMatrix<T>, IncompleteLUT<T> > bicgstabl_colmajor_ilut;
+
+  // This does not change the tolerance of the test, only the tolerance of the solver.
+  bicgstabl_colmajor_diag.setTolerance(NumTraits<T>::epsilon() * 20);
+  bicgstabl_colmajor_ilut.setTolerance(NumTraits<T>::epsilon() * 20);
+
+  CALL_SUBTEST(check_sparse_square_solving(bicgstabl_colmajor_diag));
+  CALL_SUBTEST(check_sparse_square_solving(bicgstabl_colmajor_ilut));
+}
+
+void test_bicgstabl_solve_with_guess_restart() {
+  // Regression for a solveWithGuess case where the recursive residual reached
+  // the tolerance before the true residual did.
+  srand(555248885);
+  test_bicgstabl_T<double>();
+}
+
+EIGEN_DECLARE_TEST(bicgstabl) {
+  CALL_SUBTEST_1(test_bicgstabl_T<double>());
+  CALL_SUBTEST_2(test_bicgstabl_T<std::complex<double> >());
+  CALL_SUBTEST_3(test_bicgstabl_solve_with_guess_restart());
+}
diff --git a/test/blasutil.cpp b/test/blasutil.cpp
index 199b571..e56416e 100644
--- a/test/blasutil.cpp
+++ b/test/blasutil.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/block.cpp b/test/block.cpp
index 5f48bfd..e56f799 100644
--- a/test/block.cpp
+++ b/test/block.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 
 template <typename MatrixType, typename Index, typename Scalar>
 std::enable_if_t<!NumTraits<typename MatrixType::Scalar>::IsComplex, typename MatrixType::Scalar> block_real_only(
@@ -32,7 +34,7 @@
 
 // Check at compile-time that T1==T2, and at runtime-time that a==b
 template <typename T1, typename T2>
-std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_block(const T1& a, const T2& b) {
+std::enable_if_t<std::is_same<T1, T2>::value, bool> is_same_block(const T1& a, const T2& b) {
   return a.isApprox(b);
 }
 
@@ -49,6 +51,21 @@
 }
 
 template <typename MatrixType>
+std::enable_if_t<((MatrixType::Flags & RowMajorBit) == 0), void> checkInnerVector(const MatrixType& m, Index /*r*/,
+                                                                                  Index c, Index /*rows*/, Index cols) {
+  VERIFY_IS_CWISE_EQUAL(m.innerVector(c), m.col(c));
+  VERIFY_IS_CWISE_EQUAL(m.innerVectors(c, cols), m.middleCols(c, cols));
+}
+
+template <typename MatrixType>
+std::enable_if_t<((MatrixType::Flags & RowMajorBit) != 0), void> checkInnerVector(const MatrixType& m, Index r,
+                                                                                  Index /*c*/, Index rows,
+                                                                                  Index /*cols*/) {
+  VERIFY_IS_CWISE_EQUAL(m.innerVector(r), m.row(r));
+  VERIFY_IS_CWISE_EQUAL(m.innerVectors(r, rows), m.middleRows(r, rows));
+}
+
+template <typename MatrixType>
 void block(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename MatrixType::RealScalar RealScalar;
@@ -60,11 +77,11 @@
   Index rows = m.rows();
   Index cols = m.cols();
 
-  MatrixType m1 = MatrixType::Random(rows, cols), m1_copy = m1, m2 = MatrixType::Random(rows, cols), m3(rows, cols),
-             ones = MatrixType::Ones(rows, cols);
-  VectorType v1 = VectorType::Random(rows);
+  MatrixType m1 = random_for_arithmetic<MatrixType>(rows, cols), m1_copy = m1,
+             m2 = random_for_arithmetic<MatrixType>(rows, cols), m3(rows, cols), ones = MatrixType::Ones(rows, cols);
+  VectorType v1 = random_for_arithmetic<VectorType>(rows);
 
-  Scalar s1 = internal::random<Scalar>();
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>();
 
   Index r1 = internal::random<Index>(0, rows - 1);
   Index r2 = internal::random<Index>(r1, rows - 1);
@@ -72,6 +89,7 @@
   Index c2 = internal::random<Index>(c1, cols - 1);
 
   block_real_only(m1, r1, r2, c1, c1, s1);
+  checkInnerVector(m1, r1, c1, r2 - r1, c2 - c1);
 
   // test fill logic with innerpanel and non-innerpanel blocks
   m1.row(r1).setConstant(s1);
@@ -383,11 +401,47 @@
   unwind_test_impl<BaseXpr>::run(xpr);
 }
 
+// A block that is an inner panel of a general sub-block is not an inner panel of
+// the sub-block's base expression: it spans the full inner dimension of its
+// immediate parent, but not that of the base. Unwinding must not promote it to
+// one, since an inner panel advertises linear access over the base's storage.
+template <typename BaseXpr>
+void unwind_inner_panel_test(const BaseXpr&) {
+  const Index rows = 20, cols = 20;
+  BaseXpr xpr = BaseXpr::Random(rows, cols);
+
+  // The parent spans neither dimension fully, so neither panel taken from it is
+  // an inner panel of `xpr`. Copying out through a plain object exercises this:
+  // an unwound block that wrongly claims to be an inner panel is traversed
+  // linearly and reads the wrong coefficients.
+  auto sub = xpr.block(1, 1, rows - 3, cols - 3);
+  auto sub_cols = sub.middleCols(2, 3);
+  auto sub_rows = sub.middleRows(2, 3);
+  VERIFY_IS_EQUAL(int(internal::traits<decltype(sub_cols.unwind())>::InnerPanel), 0);
+  VERIFY_IS_EQUAL(int(internal::traits<decltype(sub_rows.unwind())>::InnerPanel), 0);
+  BaseXpr sub_cols_ref = sub_cols, sub_cols_unwound = sub_cols.unwind();
+  VERIFY_IS_CWISE_EQUAL(sub_cols_ref, sub_cols_unwound);
+  BaseXpr sub_rows_ref = sub_rows, sub_rows_unwound = sub_rows.unwind();
+  VERIFY_IS_CWISE_EQUAL(sub_rows_ref, sub_rows_unwound);
+
+  // An inner panel of an inner panel *is* an inner panel of the base, and must
+  // keep saying so after unwinding.
+  auto inner_cols = xpr.middleCols(1, cols - 3).middleCols(2, 3);
+  VERIFY_IS_EQUAL(int(internal::traits<decltype(inner_cols.unwind())>::InnerPanel), int(BaseXpr::IsRowMajor ? 0 : 1));
+  BaseXpr inner_cols_ref = inner_cols, inner_cols_unwound = inner_cols.unwind();
+  VERIFY_IS_CWISE_EQUAL(inner_cols_ref, inner_cols_unwound);
+
+  auto inner_rows = xpr.middleRows(1, rows - 3).middleRows(2, 3);
+  VERIFY_IS_EQUAL(int(internal::traits<decltype(inner_rows.unwind())>::InnerPanel), int(BaseXpr::IsRowMajor ? 1 : 0));
+  BaseXpr inner_rows_ref = inner_rows, inner_rows_unwound = inner_rows.unwind();
+  VERIFY_IS_CWISE_EQUAL(inner_rows_ref, inner_rows_unwound);
+}
+
 EIGEN_DECLARE_TEST(block) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(block(Matrix<float, 1, 1>()));
-    CALL_SUBTEST_1(block(Matrix<float, 1, Dynamic>(internal::random(2, 50))));
-    CALL_SUBTEST_1(block(Matrix<float, Dynamic, 1>(internal::random(2, 50))));
+    CALL_SUBTEST_10(block(Matrix<float, 1, Dynamic>(internal::random(2, 50))));
+    CALL_SUBTEST_11(block(Matrix<float, Dynamic, 1>(internal::random(2, 50))));
     CALL_SUBTEST_2(block(Matrix4d()));
     CALL_SUBTEST_3(block(MatrixXcf(internal::random(2, 50), internal::random(2, 50))));
     CALL_SUBTEST_4(block(MatrixXi(internal::random(2, 50), internal::random(2, 50))));
@@ -397,6 +451,8 @@
 
     CALL_SUBTEST_8(block(Matrix<float, Dynamic, 4>(3, 4)));
     CALL_SUBTEST_9(unwind_test(MatrixXf()));
+    CALL_SUBTEST_9(unwind_inner_panel_test(MatrixXf()));
+    CALL_SUBTEST_9(unwind_inner_panel_test(Matrix<float, Dynamic, Dynamic, RowMajor>()));
 
 #ifndef EIGEN_DEFAULT_TO_ROW_MAJOR
     CALL_SUBTEST_6(data_and_stride(MatrixXf(internal::random(5, 50), internal::random(5, 50))));
diff --git a/test/block_sparse_matrix.cpp b/test/block_sparse_matrix.cpp
new file mode 100644
index 0000000..f415069
--- /dev/null
+++ b/test/block_sparse_matrix.cpp
@@ -0,0 +1,750 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse.h"
+
+using namespace Eigen;
+
+// ---------------------------------------------------------------------------
+// Helper: build a BlockSparseMatrix from a dense matrix
+// ---------------------------------------------------------------------------
+
+// Treats each BlockRows x BlockCols tile of `dense` as one block whenever the
+// tile is non-zero.
+template <int BlockRows, int BlockCols, typename Scalar, int Options, typename StorageIndex>
+BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex> denseToBlock(
+    const Matrix<Scalar, Dynamic, Dynamic>& dense) {
+  using BSM = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>;
+  using Triplet = typename BSM::TripletType;
+
+  Index bRows = dense.rows() / BlockRows;
+  Index bCols = dense.cols() / BlockCols;
+
+  std::vector<Triplet> triplets;
+  for (Index bi = 0; bi < bRows; ++bi) {
+    for (Index bj = 0; bj < bCols; ++bj) {
+      Matrix<Scalar, BlockRows, BlockCols> tile = dense.block(bi * BlockRows, bj * BlockCols, BlockRows, BlockCols);
+      if (tile.squaredNorm() > 0) triplets.emplace_back(StorageIndex(bi), StorageIndex(bj), tile);
+    }
+  }
+
+  BSM bsm(bRows, bCols);
+  bsm.setFromTriplets(triplets.begin(), triplets.end());
+  return bsm;
+}
+
+template <bool HasSquareBlocks>
+struct BlockSparseIdentityTester {
+  template <int BlockRows, int BlockCols, int Options, typename Scalar, typename StorageIndex>
+  static void run(int, int, const BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>&,
+                  const Matrix<Scalar, Dynamic, Dynamic>&) {}
+};
+
+template <>
+struct BlockSparseIdentityTester<true> {
+  template <int BlockRows, int BlockCols, int Options, typename Scalar, typename StorageIndex>
+  static void run(int bRows, int bCols, const BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>& A,
+                  const Matrix<Scalar, Dynamic, Dynamic>& dA) {
+    using BSM = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>;
+    using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+    const int rows = bRows * BlockRows;
+    const int cols = bCols * BlockCols;
+    BSM Id(bRows, bCols);
+    Id.setIdentity();
+    VERIFY_IS_APPROX(DenseMat(Id.toSparse()), DenseMat::Identity(rows, cols));
+    if (bRows == bCols) {
+      VERIFY_IS_APPROX(DenseMat((Id * A).toSparse()), dA);
+      VERIFY_IS_APPROX(DenseMat((A * Id).toSparse()), dA);
+    }
+  }
+};
+
+// ---------------------------------------------------------------------------
+// Core test driver templated on block size, storage order, and scalar type
+// ---------------------------------------------------------------------------
+
+template <int BlockRows, int BlockCols, int Options, typename Scalar = double>
+void test_block_sparse(int bRows, int bCols) {
+  using StorageIndex = int;
+  using BSM = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>;
+  using SpMat = SparseMatrix<Scalar, Options, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  int rows = bRows * BlockRows;
+  int cols = bCols * BlockCols;
+
+  // Build two random dense matrices with a coarse block structure.
+  DenseMat dA = DenseMat::Zero(rows, cols);
+  DenseMat dB = DenseMat::Zero(rows, cols);
+  for (int bi = 0; bi < bRows; ++bi) {
+    for (int bj = 0; bj < bCols; ++bj) {
+      if (internal::random<double>(0.0, 1.0) < 0.4) {
+        dA.block(bi * BlockRows, bj * BlockCols, BlockRows, BlockCols) = DenseMat::Random(BlockRows, BlockCols);
+      }
+      if (internal::random<double>(0.0, 1.0) < 0.4) {
+        dB.block(bi * BlockRows, bj * BlockCols, BlockRows, BlockCols) = DenseMat::Random(BlockRows, BlockCols);
+      }
+    }
+  }
+
+  BSM A = denseToBlock<BlockRows, BlockCols, Scalar, Options, StorageIndex>(dA);
+  BSM B = denseToBlock<BlockRows, BlockCols, Scalar, Options, StorageIndex>(dB);
+
+  // ---- toSparse / fromSparse round-trip -----------------------------------
+  {
+    SpMat spA = A.toSparse();
+    DenseMat dense_spA(spA);
+    VERIFY_IS_APPROX(dense_spA, dA);
+
+    BSM A2 = BSM::fromSparse(spA);
+    VERIFY_IS_APPROX(A2.toSparse(), spA);
+
+    // Implicit conversion operator
+    SpMat spA3 = A;
+    VERIFY_IS_APPROX(DenseMat(spA3), dA);
+  }
+
+  // ---- Addition -----------------------------------------------------------
+  {
+    BSM C = A + B;
+    DenseMat dC(C.toSparse());
+    VERIFY_IS_APPROX(dC, dA + dB);
+
+    BSM D = A;
+    D += B;
+    VERIFY_IS_APPROX(DenseMat(D.toSparse()), dA + dB);
+  }
+
+  // ---- Subtraction --------------------------------------------------------
+  {
+    BSM C = A - B;
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dA - dB);
+
+    BSM D = A;
+    D -= B;
+    VERIFY_IS_APPROX(DenseMat(D.toSparse()), dA - dB);
+  }
+
+  // ---- Unary minus --------------------------------------------------------
+  {
+    BSM C = -A;
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), -dA);
+  }
+
+  // ---- cwiseProduct (conjunction / intersection) --------------------------
+  {
+    BSM C = A.cwiseProduct(B);
+    // Result must only have blocks where both A and B had blocks.
+    DenseMat dC = dA.cwiseProduct(dB);
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dC);
+  }
+
+  // ---- unaryExpr ----------------------------------------------------------
+  {
+    BSM C = A.unaryExpr([](const Scalar& x) { return x * x; });
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dA.array().square().matrix());
+  }
+
+  // ---- disjunctionExpr (union sparsity) -----------------------------------
+  {
+    // sum via disjunctionExpr should match operator+
+    struct AddExpr {
+      Scalar operator()(const Scalar& a, const Scalar& b) const { return a + b; }
+      Scalar lhs(const Scalar& a) const { return a; }
+      Scalar rhs(const Scalar& b) const { return b; }
+    };
+    BSM C = A.disjunctionExpr(B, AddExpr{});
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dA + dB);
+  }
+
+  // ---- conjunctionExpr (intersection sparsity) ----------------------------
+  {
+    BSM C = A.conjunctionExpr(B, [](const Scalar& a, const Scalar& b) { return a * b; });
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dA.cwiseProduct(dB));
+  }
+
+  // ---- Scalar multiplication ----------------------------------------------
+  {
+    Scalar s = Scalar(3.14);
+    BSM C = A * s;
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dA * s);
+
+    BSM D = s * A;
+    VERIFY_IS_APPROX(DenseMat(D.toSparse()), s * dA);
+
+    BSM E = A;
+    E *= s;
+    VERIFY_IS_APPROX(DenseMat(E.toSparse()), dA * s);
+  }
+
+  // ---- Element access (coeff) ---------------------------------------------
+  {
+    for (int i = 0; i < rows; ++i) {
+      for (int j = 0; j < cols; ++j) {
+        VERIFY_IS_APPROX(A.coeff(i, j), dA(i, j));
+      }
+    }
+  }
+
+  // ---- setIdentity ----------------------------------------------------------
+  BlockSparseIdentityTester<BlockRows == BlockCols>::template run<BlockRows, BlockCols, Options, Scalar, StorageIndex>(
+      bRows, bCols, A, dA);
+
+  // ---- setFromTriplets with duplicate blocks (accumulation) ---------------
+  {
+    using Trip = typename BSM::TripletType;
+    using BlockMat = Matrix<Scalar, BlockRows, BlockCols>;
+    BlockMat half = BlockMat::Ones() * Scalar(0.5);
+
+    std::vector<Trip> trips;
+    trips.emplace_back(StorageIndex(0), StorageIndex(0), half);
+    trips.emplace_back(StorageIndex(0), StorageIndex(0), half);  // duplicate -> sum
+
+    BSM M(bRows, bCols);
+    M.setFromTriplets(trips.begin(), trips.end());
+
+    VERIFY(M.nonZeroBlocks() == 1);
+    VERIFY_IS_APPROX(DenseMat(M.blockRef(0)), DenseMat(BlockMat::Ones()));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Square-block product test
+// ---------------------------------------------------------------------------
+
+template <int B, int Options, typename Scalar = double>
+void test_block_sparse_product(int bM, int bK, int bN) {
+  using StorageIndex = int;
+  using BSMA = BlockSparseMatrix<Scalar, Options, B, B, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  int rowsA = bM * B, colsA = bK * B;
+  int colsB = bN * B;
+
+  DenseMat dA = DenseMat::Zero(rowsA, colsA);
+  DenseMat dB = DenseMat::Zero(colsA, colsB);
+
+  for (int bi = 0; bi < bM; ++bi)
+    for (int bk = 0; bk < bK; ++bk)
+      if (internal::random<double>(0.0, 1.0) < 0.4) dA.block(bi * B, bk * B, B, B) = DenseMat::Random(B, B);
+
+  for (int bk = 0; bk < bK; ++bk)
+    for (int bj = 0; bj < bN; ++bj)
+      if (internal::random<double>(0.0, 1.0) < 0.4) dB.block(bk * B, bj * B, B, B) = DenseMat::Random(B, B);
+
+  BSMA A = denseToBlock<B, B, Scalar, Options, StorageIndex>(dA);
+  BSMA Bmat = denseToBlock<B, B, Scalar, Options, StorageIndex>(dB);
+
+  BSMA C = A * Bmat;
+  DenseMat dC(C.toSparse());
+  VERIFY_IS_APPROX(dC, dA * dB);
+}
+
+// ---------------------------------------------------------------------------
+// Block-sparse * dense and dense * block-sparse products
+// ---------------------------------------------------------------------------
+
+template <int BlockRows, int BlockCols, int Options, typename Scalar = double>
+void test_block_sparse_dense_product(int bRows, int bCols) {
+  using StorageIndex = int;
+  using BSM = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+  using DenseVec = Matrix<Scalar, Dynamic, 1>;
+  using RowVec = Matrix<Scalar, 1, Dynamic>;
+
+  int rows = bRows * BlockRows;
+  int cols = bCols * BlockCols;
+
+  DenseMat dA = DenseMat::Zero(rows, cols);
+  for (int bi = 0; bi < bRows; ++bi)
+    for (int bj = 0; bj < bCols; ++bj)
+      if (internal::random<double>(0.0, 1.0) < 0.5)
+        dA.block(bi * BlockRows, bj * BlockCols, BlockRows, BlockCols) = DenseMat::Random(BlockRows, BlockCols);
+
+  BSM A = denseToBlock<BlockRows, BlockCols, Scalar, Options, StorageIndex>(dA);
+
+  // BSM * dense matrix
+  {
+    DenseMat rhs = DenseMat::Random(cols, 5);
+    VERIFY_IS_APPROX(A * rhs, dA * rhs);
+  }
+
+  // BSM * column vector
+  {
+    DenseVec v = DenseVec::Random(cols);
+    VERIFY_IS_APPROX(A * v, dA * v);
+  }
+
+  // dense matrix * BSM
+  {
+    DenseMat lhs = DenseMat::Random(5, rows);
+    VERIFY_IS_APPROX(lhs * A, lhs * dA);
+  }
+
+  // row vector * BSM
+  {
+    RowVec v = RowVec::Random(rows);
+    VERIFY_IS_APPROX(v * A, v * dA);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Non-square block product: A(BR x BC) * B(BC x BC2) -> C(BR x BC2)
+// ---------------------------------------------------------------------------
+
+void test_nonsquare_block_product() {
+  using Scalar = double;
+  using StorageIndex = int;
+  constexpr int BR = 2, BC = 3, BC2 = 4;
+  using BSMA = BlockSparseMatrix<Scalar, ColMajor, BR, BC, StorageIndex>;
+  using BSMB = BlockSparseMatrix<Scalar, ColMajor, BC, BC2, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  int bM = 4, bK = 3, bN = 5;
+  DenseMat dA = DenseMat::Zero(bM * BR, bK * BC);
+  DenseMat dB = DenseMat::Zero(bK * BC, bN * BC2);
+
+  for (int bi = 0; bi < bM; ++bi)
+    for (int bk = 0; bk < bK; ++bk)
+      if (internal::random<double>() > 0.0) dA.block(bi * BR, bk * BC, BR, BC) = DenseMat::Random(BR, BC);
+
+  for (int bk = 0; bk < bK; ++bk)
+    for (int bj = 0; bj < bN; ++bj)
+      if (internal::random<double>() > 0.0) dB.block(bk * BC, bj * BC2, BC, BC2) = DenseMat::Random(BC, BC2);
+
+  BSMA A = denseToBlock<BR, BC, Scalar, ColMajor, StorageIndex>(dA);
+  BSMB Bmat = denseToBlock<BC, BC2, Scalar, ColMajor, StorageIndex>(dB);
+
+  BlockSparseMatrix<Scalar, ColMajor, BR, BC2, StorageIndex> C = A * Bmat;
+  DenseMat dC(C.toSparse());
+  VERIFY_IS_APPROX(dC, dA * dB);
+}
+
+// ---------------------------------------------------------------------------
+// Transpose and adjoint
+// ---------------------------------------------------------------------------
+
+template <int BlockRows, int BlockCols, int Options, typename Scalar = double>
+void test_block_sparse_transpose(int bRows, int bCols) {
+  using StorageIndex = int;
+  using BSM = BlockSparseMatrix<Scalar, Options, BlockRows, BlockCols, StorageIndex>;
+  using BSMT = BlockSparseMatrix<Scalar, Options, BlockCols, BlockRows, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  int rows = bRows * BlockRows, cols = bCols * BlockCols;
+  DenseMat dA = DenseMat::Zero(rows, cols);
+  for (int bi = 0; bi < bRows; ++bi)
+    for (int bj = 0; bj < bCols; ++bj)
+      if (internal::random<double>(0.0, 1.0) < 0.5)
+        dA.block(bi * BlockRows, bj * BlockCols, BlockRows, BlockCols) = DenseMat::Random(BlockRows, BlockCols);
+
+  BSM A = denseToBlock<BlockRows, BlockCols, Scalar, Options, StorageIndex>(dA);
+
+  // transpose
+  BSMT At = A.transpose();
+  VERIFY_IS_APPROX(DenseMat(At.toSparse()), dA.transpose());
+
+  // adjoint (conjugate transpose for complex, same as transpose for real)
+  BSMT Ah = A.adjoint();
+  VERIFY_IS_APPROX(DenseMat(Ah.toSparse()), dA.adjoint());
+
+  // (A^T)^T == A
+  BSM AtT = At.transpose();
+  VERIFY_IS_APPROX(DenseMat(AtT.toSparse()), dA);
+}
+
+// ---------------------------------------------------------------------------
+// Triangular view: eval, +/-, dense products, DiagIsTriangular path
+// ---------------------------------------------------------------------------
+
+template <int B, int Options, typename Scalar = double>
+void test_block_sparse_triangular(int bN) {
+  using StorageIndex = int;
+  using BSM = BlockSparseMatrix<Scalar, Options, B, B, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  int N = bN * B;
+  DenseMat dA = DenseMat::Zero(N, N);
+  for (int bi = 0; bi < bN; ++bi)
+    for (int bj = 0; bj < bN; ++bj)
+      if (internal::random<double>(0.0, 1.0) < 0.5) dA.block(bi * B, bj * B, B, B) = DenseMat::Random(B, B);
+
+  BSM A = denseToBlock<B, B, Scalar, Options, StorageIndex>(dA);
+
+  // Upper eval
+  {
+    BSM Au = A.template triangularView<Upper>().eval();
+    DenseMat dAu = dA;
+    for (int bi = 0; bi < bN; ++bi) {
+      for (int bj = 0; bj < bi; ++bj) dAu.block(bi * B, bj * B, B, B).setZero();
+      dAu.block(bi * B, bi * B, B, B).template triangularView<StrictlyLower>().setZero();
+    }
+    VERIFY_IS_APPROX(DenseMat(Au.toSparse()), dAu);
+  }
+
+  // Lower eval
+  {
+    BSM Al = A.template triangularView<Lower>().eval();
+    DenseMat dAl = dA;
+    for (int bi = 0; bi < bN; ++bi) {
+      for (int bj = bi + 1; bj < bN; ++bj) dAl.block(bi * B, bj * B, B, B).setZero();
+      dAl.block(bi * B, bi * B, B, B).template triangularView<StrictlyUpper>().setZero();
+    }
+    VERIFY_IS_APPROX(DenseMat(Al.toSparse()), dAl);
+  }
+
+  // Tri * dense and dense * Tri
+  {
+    DenseMat dAu = dA;
+    for (int bi = 0; bi < bN; ++bi) {
+      for (int bj = 0; bj < bi; ++bj) dAu.block(bi * B, bj * B, B, B).setZero();
+      dAu.block(bi * B, bi * B, B, B).template triangularView<StrictlyLower>().setZero();
+    }
+
+    DenseMat rhs = DenseMat::Random(N, 4);
+    DenseMat lhs = DenseMat::Random(3, N);
+
+    VERIFY_IS_APPROX(A.template triangularView<Upper>() * rhs, dAu * rhs);
+    VERIFY_IS_APPROX(lhs * A.template triangularView<Upper>(), lhs * dAu);
+  }
+
+  // Tri + Tri
+  {
+    DenseMat dB = DenseMat::Zero(N, N);
+    for (int bi = 0; bi < bN; ++bi)
+      for (int bj = 0; bj < bN; ++bj)
+        if (internal::random<double>(0.0, 1.0) < 0.5) dB.block(bi * B, bj * B, B, B) = DenseMat::Random(B, B);
+    BSM Bmat = denseToBlock<B, B, Scalar, Options, StorageIndex>(dB);
+
+    DenseMat dAu = dA, dBu = dB;
+    for (int bi = 0; bi < bN; ++bi) {
+      for (int bj = 0; bj < bi; ++bj) {
+        dAu.block(bi * B, bj * B, B, B).setZero();
+        dBu.block(bi * B, bj * B, B, B).setZero();
+      }
+      dAu.block(bi * B, bi * B, B, B).template triangularView<StrictlyLower>().setZero();
+      dBu.block(bi * B, bi * B, B, B).template triangularView<StrictlyLower>().setZero();
+    }
+    BSM C = A.template triangularView<Upper>() + Bmat.template triangularView<Upper>();
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dAu + dBu);
+  }
+
+  // DiagIsTriangular=true product: build a BSM whose diagonal blocks are already
+  // upper-triangular in storage, and verify the product matches DiagIsTriangular=false.
+  {
+    DenseMat dAu = DenseMat::Zero(N, N);
+    for (int bi = 0; bi < bN; ++bi) {
+      DenseMat blk = DenseMat::Random(B, B);
+      blk.template triangularView<StrictlyLower>().setZero();
+      dAu.block(bi * B, bi * B, B, B) = blk;
+      for (int bj = bi + 1; bj < bN; ++bj)
+        if (internal::random<double>(0.0, 1.0) < 0.5) dAu.block(bi * B, bj * B, B, B) = DenseMat::Random(B, B);
+    }
+    BSM Au = denseToBlock<B, B, Scalar, Options, StorageIndex>(dAu);
+    DenseMat rhs = DenseMat::Random(N, 3);
+    DenseMat r1 = Au.template triangularView<Upper, false>() * rhs;
+    DenseMat r2 = Au.template triangularView<Upper, true>() * rhs;
+    VERIFY_IS_APPROX(r1, r2);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Triangular solve: forward/backward x direct/transposed/adjoint x both layouts
+// ---------------------------------------------------------------------------
+
+template <int B, int Options, typename Scalar>
+void test_block_sparse_triangular_solve(int bN) {
+  using StorageIndex = int;
+  using BSM = BlockSparseMatrix<Scalar, Options, B, B, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  int N = bN * B;
+
+  // Build a dense lower-block-triangular matrix.
+  // Diagonal blocks are lower triangular with non-zero diagonal.
+  // Off-diagonal (lower) blocks are random dense.
+  auto makeDenseLower = [&]() {
+    DenseMat dL = DenseMat::Zero(N, N);
+    for (int bi = 0; bi < bN; ++bi) {
+      DenseMat blk = DenseMat::Random(B, B);
+      blk.template triangularView<StrictlyUpper>().setZero();
+      for (int k = 0; k < B; ++k) blk(k, k) = Scalar(RealScalar(B + k + 1));
+      dL.block(bi * B, bi * B, B, B) = blk;
+      for (int bj = 0; bj < bi; ++bj)
+        if (internal::random<double>(0.0, 1.0) < 0.6) dL.block(bi * B, bj * B, B, B) = DenseMat::Random(B, B);
+    }
+    return dL;
+  };
+
+  auto makeDenseUpper = [&]() {
+    DenseMat dU = DenseMat::Zero(N, N);
+    for (int bi = 0; bi < bN; ++bi) {
+      DenseMat blk = DenseMat::Random(B, B);
+      blk.template triangularView<StrictlyLower>().setZero();
+      for (int k = 0; k < B; ++k) blk(k, k) = Scalar(RealScalar(B + k + 1));
+      dU.block(bi * B, bi * B, B, B) = blk;
+      for (int bj = bi + 1; bj < bN; ++bj)
+        if (internal::random<double>(0.0, 1.0) < 0.6) dU.block(bi * B, bj * B, B, B) = DenseMat::Random(B, B);
+    }
+    return dU;
+  };
+
+  // Lower triangular: direct, transposed, adjoint
+  {
+    DenseMat dL = makeDenseLower();
+    BSM L = denseToBlock<B, B, Scalar, Options, StorageIndex>(dL);
+
+    // L x = b
+    {
+      DenseMat b = DenseMat::Random(N, 3);
+      DenseMat x = b;
+      L.template triangularView<Lower>().solveInPlace(x);
+      VERIFY_IS_APPROX(dL * x, b);
+    }
+    // L^T x = b
+    {
+      DenseMat b = DenseMat::Random(N, 3);
+      DenseMat x = b;
+      L.template triangularView<Lower>().transpose().solveInPlace(x);
+      VERIFY_IS_APPROX(dL.transpose() * x, b);
+    }
+    // L^H x = b
+    {
+      DenseMat b = DenseMat::Random(N, 3);
+      DenseMat x = b;
+      L.template triangularView<Lower>().adjoint().solveInPlace(x);
+      VERIFY_IS_APPROX(dL.adjoint() * x, b);
+    }
+  }
+
+  // Upper triangular: direct, transposed, adjoint
+  {
+    DenseMat dU = makeDenseUpper();
+    BSM U = denseToBlock<B, B, Scalar, Options, StorageIndex>(dU);
+
+    // U x = b
+    {
+      DenseMat b = DenseMat::Random(N, 3);
+      DenseMat x = b;
+      U.template triangularView<Upper>().solveInPlace(x);
+      VERIFY_IS_APPROX(dU * x, b);
+    }
+    // U^T x = b
+    {
+      DenseMat b = DenseMat::Random(N, 3);
+      DenseMat x = b;
+      U.template triangularView<Upper>().transpose().solveInPlace(x);
+      VERIFY_IS_APPROX(dU.transpose() * x, b);
+    }
+    // U^H x = b
+    {
+      DenseMat b = DenseMat::Random(N, 3);
+      DenseMat x = b;
+      U.template triangularView<Upper>().adjoint().solveInPlace(x);
+      VERIFY_IS_APPROX(dU.adjoint() * x, b);
+    }
+  }
+
+  // DiagIsTriangular=true: diagonal blocks are already properly triangular in storage;
+  // result must match DiagIsTriangular=false (which zeroes the unused triangle first).
+  {
+    DenseMat dL = makeDenseLower();
+    BSM L = denseToBlock<B, B, Scalar, Options, StorageIndex>(dL);
+    DenseMat b = DenseMat::Random(N, 2);
+    DenseMat x1 = b, x2 = b;
+    {
+      auto tri_false = L.template triangularView<Lower, false>();
+      tri_false.solveInPlace(x1);
+    }
+    {
+      auto tri_true = L.template triangularView<Lower, true>();
+      tri_true.solveInPlace(x2);
+    }
+    VERIFY_IS_APPROX(x1, x2);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Self-adjoint view: eval, +/-, dense products
+// ---------------------------------------------------------------------------
+
+template <int B, int Options, typename Scalar = double>
+void test_block_sparse_selfadjoint(int bN) {
+  using StorageIndex = int;
+  using BSM = BlockSparseMatrix<Scalar, Options, B, B, StorageIndex>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic>;
+
+  int N = bN * B;
+
+  // Build a Hermitian dense matrix (stored upper triangle only).
+  DenseMat dFull = DenseMat::Zero(N, N);
+  for (int bi = 0; bi < bN; ++bi) {
+    // Diagonal block: Hermitian (symmetric for real, conjugate-symmetric for complex).
+    DenseMat blk = DenseMat::Random(B, B);
+    blk = (blk + blk.adjoint()).eval();
+    dFull.block(bi * B, bi * B, B, B) = blk;
+    for (int bj = bi + 1; bj < bN; ++bj)
+      if (internal::random<double>(0.0, 1.0) < 0.5) {
+        DenseMat offblk = DenseMat::Random(B, B);
+        dFull.block(bi * B, bj * B, B, B) = offblk;
+        dFull.block(bj * B, bi * B, B, B) = offblk.adjoint();  // conjugate transpose mirror
+      }
+  }
+
+  // Build BSM from the upper triangle only.
+  DenseMat dUpper = DenseMat::Zero(N, N);
+  for (int bi = 0; bi < bN; ++bi)
+    for (int bj = bi; bj < bN; ++bj) dUpper.block(bi * B, bj * B, B, B) = dFull.block(bi * B, bj * B, B, B);
+
+  BSM A = denseToBlock<B, B, Scalar, Options, StorageIndex>(dUpper);
+
+  // eval() must reproduce the full Hermitian matrix
+  {
+    BSM Asym = A.template selfadjointView<Upper>().eval();
+    VERIFY_IS_APPROX(DenseMat(Asym.toSparse()), dFull);
+  }
+
+  // selfadjointView * dense
+  {
+    DenseMat rhs = DenseMat::Random(N, 5);
+    VERIFY_IS_APPROX(A.template selfadjointView<Upper>() * rhs, dFull * rhs);
+  }
+
+  // dense * selfadjointView
+  {
+    DenseMat lhs = DenseMat::Random(4, N);
+    VERIFY_IS_APPROX(lhs * A.template selfadjointView<Upper>(), lhs * dFull);
+  }
+
+  // selfadjointView + selfadjointView
+  {
+    BSM Bmat = denseToBlock<B, B, Scalar, Options, StorageIndex>(dUpper * Scalar(2));
+    BSM C = A.template selfadjointView<Upper>() + Bmat.template selfadjointView<Upper>();
+    VERIFY_IS_APPROX(DenseMat(C.toSparse()), dFull * Scalar(3));
+  }
+
+  // DiagIsSelfAdjoint path: diagonal blocks ARE Hermitian, product should match
+  {
+    DenseMat rhs = DenseMat::Random(N, 3);
+    DenseMat result = A.template selfadjointView<Upper, true>() * rhs;
+    VERIFY_IS_APPROX(result, dFull * rhs);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// BlockTriplet type-trait checks
+// ---------------------------------------------------------------------------
+
+void test_block_triplet_traits() {
+  // Flat scalar array means BlockTriplet should be trivially copyable and
+  // standard-layout for any trivially-copyable Scalar and StorageIndex.
+  EIGEN_STATIC_ASSERT((std::is_trivially_copyable<BlockTriplet<float, 2, 2>>::value),
+                      BLOCKTRIPLET_MUST_BE_TRIVIALLY_COPYABLE)
+  EIGEN_STATIC_ASSERT((std::is_trivially_copyable<BlockTriplet<double, 3, 3>>::value),
+                      BLOCKTRIPLET_MUST_BE_TRIVIALLY_COPYABLE)
+  EIGEN_STATIC_ASSERT((std::is_trivially_copyable<BlockTriplet<float, 2, 3>>::value),
+                      BLOCKTRIPLET_MUST_BE_TRIVIALLY_COPYABLE)
+  EIGEN_STATIC_ASSERT((std::is_standard_layout<BlockTriplet<float, 2, 2>>::value), BLOCKTRIPLET_MUST_BE_STANDARD_LAYOUT)
+  EIGEN_STATIC_ASSERT((std::is_standard_layout<BlockTriplet<double, 4, 4>>::value),
+                      BLOCKTRIPLET_MUST_BE_STANDARD_LAYOUT)
+
+  // No alignment padding: size must equal 2*sizeof(StorageIndex) + BlockSize*sizeof(Scalar).
+  EIGEN_STATIC_ASSERT((sizeof(BlockTriplet<float, 2, 2>) == 2 * sizeof(int) + 4 * sizeof(float)),
+                      BLOCKTRIPLET_MUST_HAVE_NO_ALIGNMENT_PADDING)
+  EIGEN_STATIC_ASSERT((sizeof(BlockTriplet<double, 2, 2>) == 2 * sizeof(int) + 4 * sizeof(double)),
+                      BLOCKTRIPLET_MUST_HAVE_NO_ALIGNMENT_PADDING)
+  EIGEN_STATIC_ASSERT((sizeof(BlockTriplet<float, 4, 4>) == 2 * sizeof(int) + 16 * sizeof(float)),
+                      BLOCKTRIPLET_MUST_HAVE_NO_ALIGNMENT_PADDING)
+  EIGEN_STATIC_ASSERT((sizeof(BlockTriplet<double, 4, 4>) == 2 * sizeof(int) + 16 * sizeof(double)),
+                      BLOCKTRIPLET_MUST_HAVE_NO_ALIGNMENT_PADDING)
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+EIGEN_DECLARE_TEST(block_sparse_matrix) {
+  // ColMajor, real double, various block sizes and matrix sizes
+  CALL_SUBTEST_1((test_block_sparse<1, 1, ColMajor>(6, 8)));
+  CALL_SUBTEST_2((test_block_sparse<2, 2, ColMajor>(4, 6)));
+  CALL_SUBTEST_3((test_block_sparse<3, 3, ColMajor>(4, 5)));
+  CALL_SUBTEST_4((test_block_sparse<4, 4, ColMajor>(3, 3)));
+  CALL_SUBTEST_5((test_block_sparse<2, 3, ColMajor>(5, 4)));
+
+  // RowMajor, real double
+  CALL_SUBTEST_6((test_block_sparse<2, 2, RowMajor>(4, 6)));
+  CALL_SUBTEST_7((test_block_sparse<3, 3, RowMajor>(4, 5)));
+  CALL_SUBTEST_8((test_block_sparse<2, 3, RowMajor>(5, 4)));
+
+  // Products (ColMajor)
+  CALL_SUBTEST_9((test_block_sparse_product<2, ColMajor>(4, 5, 3)));
+  CALL_SUBTEST_9((test_block_sparse_product<3, ColMajor>(3, 4, 5)));
+
+  // Products (RowMajor)
+  CALL_SUBTEST_10((test_block_sparse_product<2, RowMajor>(4, 5, 3)));
+  CALL_SUBTEST_10((test_block_sparse_product<3, RowMajor>(3, 4, 5)));
+
+  // Non-square block product
+  CALL_SUBTEST_11(test_nonsquare_block_product());
+
+  // Block-sparse * dense and dense * block-sparse (ColMajor)
+  CALL_SUBTEST_12((test_block_sparse_dense_product<2, 2, ColMajor>(4, 5)));
+  CALL_SUBTEST_12((test_block_sparse_dense_product<3, 3, ColMajor>(3, 4)));
+  CALL_SUBTEST_12((test_block_sparse_dense_product<2, 3, ColMajor>(4, 3)));
+
+  // Block-sparse * dense and dense * block-sparse (RowMajor)
+  CALL_SUBTEST_13((test_block_sparse_dense_product<2, 2, RowMajor>(4, 5)));
+  CALL_SUBTEST_13((test_block_sparse_dense_product<3, 3, RowMajor>(3, 4)));
+  CALL_SUBTEST_13((test_block_sparse_dense_product<2, 3, RowMajor>(4, 3)));
+
+  // Transpose / adjoint (ColMajor and RowMajor, square and non-square blocks)
+  CALL_SUBTEST_14((test_block_sparse_transpose<2, 2, ColMajor>(4, 5)));
+  CALL_SUBTEST_14((test_block_sparse_transpose<2, 3, ColMajor>(5, 4)));
+  CALL_SUBTEST_14((test_block_sparse_transpose<2, 2, RowMajor>(4, 5)));
+  CALL_SUBTEST_14((test_block_sparse_transpose<3, 2, RowMajor>(4, 5)));
+
+  // Triangular view (ColMajor and RowMajor)
+  CALL_SUBTEST_15((test_block_sparse_triangular<2, ColMajor>(5)));
+  CALL_SUBTEST_15((test_block_sparse_triangular<3, ColMajor>(4)));
+  CALL_SUBTEST_15((test_block_sparse_triangular<2, RowMajor>(5)));
+
+  // Self-adjoint view (ColMajor and RowMajor)
+  CALL_SUBTEST_16((test_block_sparse_selfadjoint<2, ColMajor>(5)));
+  CALL_SUBTEST_16((test_block_sparse_selfadjoint<3, ColMajor>(4)));
+  CALL_SUBTEST_16((test_block_sparse_selfadjoint<2, RowMajor>(5)));
+
+  // BlockTriplet type traits
+  CALL_SUBTEST_17(test_block_triplet_traits());
+
+  // Complex scalar coverage: conjugation paths in adjoint, selfadjoint, triangular products
+  CALL_SUBTEST_18((test_block_sparse<2, 2, ColMajor, std::complex<double>>(4, 6)));
+  CALL_SUBTEST_18((test_block_sparse<3, 3, ColMajor, std::complex<double>>(4, 5)));
+  CALL_SUBTEST_18((test_block_sparse<2, 2, RowMajor, std::complex<double>>(4, 6)));
+  CALL_SUBTEST_18((test_block_sparse_dense_product<2, 2, ColMajor, std::complex<double>>(4, 5)));
+  CALL_SUBTEST_18((test_block_sparse_dense_product<2, 2, RowMajor, std::complex<double>>(4, 5)));
+  CALL_SUBTEST_18((test_block_sparse_transpose<2, 2, ColMajor, std::complex<double>>(4, 5)));
+  CALL_SUBTEST_18((test_block_sparse_transpose<2, 3, ColMajor, std::complex<double>>(5, 4)));
+  CALL_SUBTEST_18((test_block_sparse_selfadjoint<2, ColMajor, std::complex<double>>(5)));
+  CALL_SUBTEST_18((test_block_sparse_selfadjoint<3, ColMajor, std::complex<double>>(4)));
+  CALL_SUBTEST_18((test_block_sparse_selfadjoint<2, RowMajor, std::complex<double>>(5)));
+  CALL_SUBTEST_18((test_block_sparse_triangular<2, ColMajor, std::complex<double>>(5)));
+  CALL_SUBTEST_18((test_block_sparse_triangular<2, RowMajor, std::complex<double>>(5)));
+
+  // Triangular solve: forward/backward x direct/transposed/adjoint x ColMajor+RowMajor
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<2, ColMajor, double>(5)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<3, ColMajor, double>(4)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<2, RowMajor, double>(5)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<3, RowMajor, double>(4)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<2, ColMajor, std::complex<double>>(5)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<3, ColMajor, std::complex<double>>(4)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<2, RowMajor, std::complex<double>>(5)));
+  CALL_SUBTEST_19((test_block_sparse_triangular_solve<3, RowMajor, std::complex<double>>(4)));
+}
diff --git a/test/boostmultiprec.cpp b/test/boostmultiprec.cpp
index 76e80fe..36ba922 100644
--- a/test/boostmultiprec.cpp
+++ b/test/boostmultiprec.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include <sstream>
 
@@ -194,19 +195,15 @@
 
     CALL_SUBTEST_8(generalized_eigensolver_real(Mat(s, s)));
 
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 
   CALL_SUBTEST_9(
-      (jacobisvd_thin_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
-                                  internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
-  CALL_SUBTEST_9(
-      (jacobisvd_full_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
-                                  internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
-  CALL_SUBTEST_10((bdcsvd_thin_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
-                                           internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
-  CALL_SUBTEST_10((bdcsvd_full_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
-                                           internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
+      (jacobisvd_thin_full_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
+                                       internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
+  CALL_SUBTEST_10(
+      (bdcsvd_thin_full_options(Mat(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE),
+                                    internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
 
   CALL_SUBTEST_11((test_simplicial_cholesky_T<Real, int, ColMajor>()));
 }
diff --git a/test/bug1213.cpp b/test/bug1213.cpp
index 8dbe1a8..c60dc83 100644
--- a/test/bug1213.cpp
+++ b/test/bug1213.cpp
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 // This anonymous enum is essential to trigger the linking issue
 enum { Foo };
diff --git a/test/bug1213.h b/test/bug1213.h
index 49687f2..b86391d 100644
--- a/test/bug1213.h
+++ b/test/bug1213.h
@@ -1,3 +1,8 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_BUG1213_H
+#define EIGEN_TEST_BUG1213_H
 
 #include <Eigen/Core>
 
@@ -5,3 +10,5 @@
 bool bug1213_2(const Eigen::Matrix<T, dim, 1>& x);
 
 bool bug1213_1(const Eigen::Vector3f& x);
+
+#endif  // EIGEN_TEST_BUG1213_H
diff --git a/test/bug1213_main.cpp b/test/bug1213_main.cpp
index 3543155..1822eb4 100644
--- a/test/bug1213_main.cpp
+++ b/test/bug1213_main.cpp
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 // This is a regression unit regarding an unusual linking issue with GCC.
 
diff --git a/test/buildsystem/CMakeLists.txt b/test/buildsystem/CMakeLists.txt
new file mode 100644
index 0000000..589f317
--- /dev/null
+++ b/test/buildsystem/CMakeLists.txt
@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Build-system integration tests.  Each scenario asserts a claim about Eigen's
+# own CMake surface -- most by driving a real configure, build, and install of
+# Eigen -- so documented or relied-upon CMake behavior cannot drift from the
+# tree without a test failing.
+#
+# Registered only for a top-level, non-cross-compiling build: a scenario
+# configures and runs a nested project, which needs a usable host toolchain
+# rather than the artifacts of the enclosing build.
+#
+# CMAKE_CROSSCOMPILING alone does not catch the CI's emulator builds, which
+# select a cross compiler without a toolchain file or CMAKE_SYSTEM_NAME.  There
+# the enclosing suite runs through the CROSSCOMPILING_EMULATOR target property,
+# but the nested consumers inherit only the (cross) compiler, so the scenarios
+# that run one exec a foreign-architecture binary on the host.
+
+if(NOT PROJECT_IS_TOP_LEVEL OR CMAKE_CROSSCOMPILING OR CMAKE_CROSSCOMPILING_EMULATOR)
+  return()
+endif()
+
+set(EIGEN_BUILDSYSTEM_SCENARIOS
+    gpu_architectures
+    gpu_compile_options
+    gpu_flags
+    gpu_runtime_linkage
+    find_package
+    find_package_version_reject
+    add_subdirectory
+    install_default
+    install_off
+    install_off_all_options
+    exclude_from_all
+    suitesparse_reconfigure
+    )
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.21)
+  list(APPEND EIGEN_BUILDSYSTEM_SCENARIOS hip_architectures)
+endif()
+
+# find_package version ranges are CMake 3.19 syntax.  On the 3.17 Eigen still
+# supports, "3.4...5" reaches Eigen3ConfigVersion.cmake as one unparsable
+# version string and the consumer configure fails, so the claim this scenario
+# tests cannot be stated there at all.
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.19)
+  list(APPEND EIGEN_BUILDSYSTEM_SCENARIOS find_package_version_range)
+endif()
+
+# EIGEN_BUILD_PKGCONFIG only exists off Windows, so the scenario asserting
+# that it suppresses eigen3.pc has nothing to assert there.
+if(NOT WIN32 OR NOT CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+  list(APPEND EIGEN_BUILDSYSTEM_SCENARIOS pkgconfig_off)
+endif()
+
+set(EIGEN_BUILDSYSTEM_CONFIG "${CMAKE_BUILD_TYPE}")
+if(NOT EIGEN_BUILDSYSTEM_CONFIG)
+  set(EIGEN_BUILDSYSTEM_CONFIG "Release")
+endif()
+
+foreach(scenario IN LISTS EIGEN_BUILDSYSTEM_SCENARIOS)
+  add_test(NAME buildsystem_${scenario}
+    COMMAND ${CMAKE_COMMAND}
+      "-DEIGEN_SOURCE_DIR=${Eigen_SOURCE_DIR}"
+      "-DSCENARIO=${scenario}"
+      "-DWORK_DIR=${CMAKE_CURRENT_BINARY_DIR}/${scenario}"
+      "-DGENERATOR=${CMAKE_GENERATOR}"
+      "-DC_COMPILER=${CMAKE_C_COMPILER}"
+      "-DCXX_COMPILER=${CMAKE_CXX_COMPILER}"
+      "-DBUILD_CONFIG=${EIGEN_BUILDSYSTEM_CONFIG}"
+      -P "${CMAKE_CURRENT_SOURCE_DIR}/run_scenario.cmake")
+  # Each scenario runs several nested CMake invocations; the default 1500s
+  # ceiling is ample, but a hung nested build should fail rather than hang.
+  set_tests_properties(buildsystem_${scenario} PROPERTIES
+                       LABELS "buildsystem" TIMEOUT 900)
+endforeach()
diff --git a/test/buildsystem/consumers/gpu_architectures/CMakeLists.txt b/test/buildsystem/consumers/gpu_architectures/CMakeLists.txt
new file mode 100644
index 0000000..53db5dc
--- /dev/null
+++ b/test/buildsystem/consumers/gpu_architectures/CMakeLists.txt
@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.18)
+project(GpuArchitectures NONE)
+include("${EIGEN_SOURCE_DIR}/cmake/EigenGpuTesting.cmake")
+
+# Exercise route selection without requiring a toolkit, compiler, or GPU.
+macro(find_package package)
+  get_filename_component(toolkit_root "${CUDAToolkit_ROOT}" REALPATH)
+  get_filename_component(expected_toolkit_root "${EXPECTED_TOOLKIT_ROOT}" REALPATH)
+  if(NOT "${package}" STREQUAL "CUDAToolkit" OR NOT toolkit_root STREQUAL expected_toolkit_root)
+    message(FATAL_ERROR "Unexpected package: ${package}, CUDAToolkit_ROOT=${CUDAToolkit_ROOT}")
+  endif()
+  set(CUDAToolkit_VERSION 12.8)
+  set(CUDAToolkit_TARGET_DIR /cuda)
+endmacro()
+
+# Compiler identification compiles with the custom flags.
+macro(enable_language language)
+  if(NOT "${language}" STREQUAL "CUDA" OR NOT ROUTE STREQUAL "cuda-language" OR
+     NOT " ${CMAKE_CUDA_FLAGS} " MATCHES " -allow-unsupported-compiler ")
+    message(FATAL_ERROR "Unexpected language enablement: ${language}, CMAKE_CUDA_FLAGS=${CMAKE_CUDA_FLAGS}")
+  endif()
+endmacro()
+
+unset(ENV{CUDAToolkit_ROOT})
+set(EIGEN_TEST_CUDA ON)
+if(ROUTE STREQUAL "nvc")
+  set(EIGEN_TEST_CUDA_NVC ON)
+elseif(ROUTE STREQUAL "windows-clang")
+  set(EIGEN_TEST_CUDA_CLANG ON)
+  set(WIN32 TRUE)
+else()
+  set(EIGEN_CUDA_CXX_FLAGS -allow-unsupported-compiler)
+endif()
+string(REPLACE "," ";" CMAKE_CUDA_ARCHITECTURES "${ARCHITECTURES}")
+ei_gpu_testing_enable()
+string(STRIP "${CMAKE_CXX_FLAGS}" actual_flags)
+string(STRIP "${EXPECTED_FLAGS}" expected_flags)
+
+if(ROUTE STREQUAL "cuda-language")
+  if(NOT EIGEN_GPU_TEST_MODE STREQUAL "cuda-language")
+    message(FATAL_ERROR "Expected the CUDA language route")
+  endif()
+elseif(NOT EIGEN_GPU_TEST_MODE STREQUAL "cuda-as-cxx" OR NOT actual_flags STREQUAL expected_flags)
+  message(FATAL_ERROR "Unexpected C++ compiler flags: ${CMAKE_CXX_FLAGS}")
+endif()
diff --git a/test/buildsystem/consumers/gpu_compile_options/CMakeLists.txt b/test/buildsystem/consumers/gpu_compile_options/CMakeLists.txt
new file mode 100644
index 0000000..6d96880
--- /dev/null
+++ b/test/buildsystem/consumers/gpu_compile_options/CMakeLists.txt
@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.18)
+project(GpuCompileOptions CXX)
+include("${EIGEN_SOURCE_DIR}/cmake/EigenGpuTesting.cmake")
+include("${EIGEN_SOURCE_DIR}/cmake/EigenTesting.cmake")
+
+add_library(Eigen3::Eigen INTERFACE IMPORTED)
+add_library(CUDA::cudart_static INTERFACE IMPORTED)
+add_custom_target(buildtests)
+add_custom_target(buildtests_gpu)
+set(EIGEN_TEST_MAX_SIZE 320)
+
+# Inspect the actual test registration without requiring a GPU compiler or toolkit.
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/dummy.cu" "int main() { return 0; }\n")
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp" "int main() { return 0; }\n")
+set_source_files_properties("${CMAKE_CURRENT_BINARY_DIR}/dummy.cu" PROPERTIES LANGUAGE CXX)
+
+function(check_options name mode compiler extension msvc expected_options expected_definitions)
+  set(EIGEN_GPU_TEST_MODE "${mode}")
+  set(CMAKE_CUDA_COMPILER_ID "${compiler}")
+  set(EIGEN_ADD_TEST_FILENAME_EXTENSION "${extension}")
+  set(MSVC "${msvc}")
+  set(EIGEN_TEST_CUSTOM_CXX_FLAGS "/d2ReducedOptimizeHugeFunctions;/DEIGEN_STRONG_INLINE=inline;/Os;-DKEEP=1")
+  ei_add_test_internal("${CMAKE_CURRENT_BINARY_DIR}/dummy" "${name}" "/W4 /DLOCAL_DEF=2")
+  get_target_property(options "${name}" COMPILE_OPTIONS)
+  get_target_property(definitions "${name}" COMPILE_DEFINITIONS)
+  if(NOT options STREQUAL expected_options)
+    message(FATAL_ERROR "${name}: expected options [${expected_options}], got [${options}]")
+  endif()
+  if(NOT definitions STREQUAL expected_definitions)
+    message(FATAL_ERROR "${name}: expected definitions [${expected_definitions}], got [${definitions}]")
+  endif()
+endfunction()
+
+set(msvc_options "/bigobj;/W4;/DLOCAL_DEF=2;/d2ReducedOptimizeHugeFunctions;/DEIGEN_STRONG_INLINE=inline;/Os;-DKEEP=1")
+set(nvcc_options "-Xcompiler=/bigobj;-Xcompiler=/W4;-Xcompiler=/d2ReducedOptimizeHugeFunctions;-Xcompiler=/Os;-DKEEP=1")
+set(definitions "EIGEN_TEST_MAX_SIZE=320")
+check_options(nvcc cuda-language NVIDIA cu TRUE "${nvcc_options}"
+              "${definitions};LOCAL_DEF=2;EIGEN_STRONG_INLINE=inline")
+check_options(host cuda-language NVIDIA cpp TRUE "${msvc_options}" "${definitions}")
+check_options(clang cuda-language Clang cu TRUE "${msvc_options}" "${definitions}")
+check_options(cuda_as_cxx cuda-as-cxx NVIDIA cu TRUE "${msvc_options}" "${definitions}")
+check_options(non_msvc cuda-language NVIDIA cu FALSE
+              "/W4;/DLOCAL_DEF=2;/d2ReducedOptimizeHugeFunctions;/DEIGEN_STRONG_INLINE=inline;/Os;-DKEEP=1"
+              "${definitions}")
diff --git a/test/buildsystem/consumers/gpu_flags/CMakeLists.txt b/test/buildsystem/consumers/gpu_flags/CMakeLists.txt
new file mode 100644
index 0000000..0ae0c84
--- /dev/null
+++ b/test/buildsystem/consumers/gpu_flags/CMakeLists.txt
@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.18)
+project(GpuFlags NONE)
+include("${EIGEN_SOURCE_DIR}/cmake/EigenGpuTesting.cmake")
+
+function(check_flags actual expected what)
+  separate_arguments(actual NATIVE_COMMAND "${actual}")
+  separate_arguments(expected NATIVE_COMMAND "${expected}")
+  if(NOT actual STREQUAL expected)
+    message(FATAL_ERROR "${what}: expected [${expected}], got [${actual}]")
+  endif()
+endfunction()
+
+macro(find_package package)
+  set(CUDAToolkit_VERSION 12.8)
+  set(CUDAToolkit_TARGET_DIR /cuda)
+endmacro()
+
+# Keep compiler discovery hardware-independent, but run CMake's real flag/cache initialization.
+macro(enable_language language)
+  check_flags("${CMAKE_CUDA_FLAGS}" "${EXPECTED_DETECTION} ${extra_flags}" "compiler detection flags")
+  set(CMAKE_CUDA_COMPILER_ID EigenFlagTest)
+  include(CMakeInitializeConfigs)
+  include(CMakeCUDAInformation)
+endmacro()
+
+set(EIGEN_TEST_CUDA ON)
+set(EIGEN_CUDA_COMPUTE_ARCH 75)
+set(ENV{CUDAFLAGS} "${ENVIRONMENT_FLAGS}")
+if(DEFINED NORMAL_FLAGS)
+  set(CMAKE_CUDA_FLAGS "${NORMAL_FLAGS}")
+endif()
+set(extra_flags "${EIGEN_CUDA_CXX_FLAGS}")
+if(EIGEN_TEST_CUDA_CLANG)
+  string(PREPEND extra_flags "--cuda-path=/cuda ")
+  set(WIN32 FALSE)
+endif()
+
+# Compiler and platform modules can add flags only after compiler identification.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_BINARY_DIR}/Modules")
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/Modules/Compiler/EigenFlagTest-CUDA.cmake"
+     "string(APPEND CMAKE_CUDA_FLAGS_INIT \" -DPLATFORM_FLAG=1\")\n")
+ei_gpu_testing_enable()
+check_flags("${CMAKE_CUDA_FLAGS}" "${EXPECTED_BUILD} ${extra_flags}" "build flags")
+get_property(cache_flags CACHE CMAKE_CUDA_FLAGS PROPERTY VALUE)
+check_flags("${cache_flags}" "${EXPECTED_CACHE}" "cached flags")
diff --git a/test/buildsystem/consumers/gpu_runtime/CMakeLists.txt b/test/buildsystem/consumers/gpu_runtime/CMakeLists.txt
new file mode 100644
index 0000000..f5c5aa9
--- /dev/null
+++ b/test/buildsystem/consumers/gpu_runtime/CMakeLists.txt
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.18)
+project(GpuRuntimeLinkage CXX)
+include("${EIGEN_SOURCE_DIR}/cmake/EigenGpuTesting.cmake")
+
+# Inspect linkage without requiring either GPU compiler or an installed CUDA toolkit.
+add_library(CUDA::cudart_static INTERFACE IMPORTED)
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/dummy.cu" "int main() { return 0; }\n")
+set(EIGEN_GPU_TEST_MODE cuda-as-cxx)
+set(EIGEN_TEST_CUDA_NVC ON)
+ei_add_gpu_test_executable(nvc_test "${CMAKE_CURRENT_BINARY_DIR}/dummy.cu")
+get_target_property(nvc_libraries nvc_test LINK_LIBRARIES)
+if(nvc_libraries)
+  message(FATAL_ERROR "NVHPC must supply its own CUDA runtime, got: ${nvc_libraries}")
+endif()
+
+set(EIGEN_TEST_CUDA_NVC OFF)
+ei_add_gpu_test_executable(clang_test "${CMAKE_CURRENT_BINARY_DIR}/dummy.cu")
+get_target_property(clang_libraries clang_test LINK_LIBRARIES)
+if(NOT "CUDA::cudart_static" IN_LIST clang_libraries)
+  message(FATAL_ERROR "The Windows Clang path still needs an explicit CUDA runtime")
+endif()
diff --git a/test/buildsystem/consumers/hip_architectures/CMakeLists.txt b/test/buildsystem/consumers/hip_architectures/CMakeLists.txt
new file mode 100644
index 0000000..7e04fbc
--- /dev/null
+++ b/test/buildsystem/consumers/hip_architectures/CMakeLists.txt
@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+cmake_minimum_required(VERSION 3.21)
+project(EigenHipArchitectures LANGUAGES CXX)
+enable_testing()
+
+set(EIGEN_TEST_HIP ON)
+set(EIGEN_ADD_TEST_FILENAME_EXTENSION cu)
+set(EIGEN_TEST_MAX_SIZE 320)
+include("${EIGEN_SOURCE_DIR}/cmake/EigenTesting.cmake")
+include("${EIGEN_SOURCE_DIR}/cmake/EigenGpuTesting.cmake")
+add_library(Eigen3::Eigen INTERFACE IMPORTED)
+add_custom_target(buildtests)
+add_custom_target(buildtests_gpu)
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/probe.cu" "int main() { return 0; }\n")
+
+# Observe compiler detection and target setup without requiring ROCm or a GPU.
+macro(enable_language language)
+  if(NOT "${language}" STREQUAL "HIP" OR
+     NOT "${CMAKE_HIP_ARCHITECTURES}" STREQUAL "${expected_architectures}")
+    message(FATAL_ERROR "Unexpected HIP language setup: ${language}, ${CMAKE_HIP_ARCHITECTURES}")
+  endif()
+endmacro()
+
+function(check_architectures target eigen_architectures cmake_architectures expected_architectures)
+  set(EIGEN_HIP_ARCHITECTURES "${eigen_architectures}")
+  set(CMAKE_HIP_ARCHITECTURES "${cmake_architectures}")
+  ei_gpu_testing_enable()
+  ei_add_test_internal("${CMAKE_CURRENT_BINARY_DIR}/probe" ${target})
+  get_target_property(actual_architectures ${target} HIP_ARCHITECTURES)
+  get_source_file_property(language "${CMAKE_CURRENT_BINARY_DIR}/probe.cu" LANGUAGE)
+  get_target_property(definitions ${target} COMPILE_DEFINITIONS)
+  if(NOT "${actual_architectures}" STREQUAL "${expected_architectures}" OR
+     NOT language STREQUAL "HIP" OR NOT "EIGEN_USE_HIP" IN_LIST definitions)
+    message(FATAL_ERROR "${target}: unexpected HIP target setup: ${actual_architectures}, ${language}, ${definitions}")
+  endif()
+  # The wiring has been checked; generation uses the available host compiler.
+  set_source_files_properties("${CMAKE_CURRENT_BINARY_DIR}/probe.cu" PROPERTIES LANGUAGE CXX)
+endfunction()
+
+check_architectures(single_architecture gfx1151 "" gfx1151)
+check_architectures(multiple_architectures "gfx906;gfx90a:xnack-" "" "gfx906;gfx90a:xnack-")
+check_architectures(empty_architectures "" "" "")
+check_architectures(cmake_override gfx906 gfx942 gfx942)
+check_architectures(cmake_off gfx906 OFF OFF)
diff --git a/test/buildsystem/consumers/installed/CMakeLists.txt b/test/buildsystem/consumers/installed/CMakeLists.txt
new file mode 100644
index 0000000..eda0001
--- /dev/null
+++ b/test/buildsystem/consumers/installed/CMakeLists.txt
@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Consumes an installed Eigen exactly the way doc/TopicCMakeGuide.dox opens:
+# find_package plus target_link_libraries against Eigen3::Eigen.
+# EIGEN_VERSION_SPEC carries the optional version argument so one project can
+# stand in for the plain, ranged, and rejected forms the guide documents.
+
+cmake_minimum_required(VERSION 3.17)
+project(eigen_installed_consumer CXX)
+
+find_package(Eigen3 ${EIGEN_VERSION_SPEC} REQUIRED NO_MODULE)
+
+# Prove the package came from the install tree the scenario built. Eigen calls
+# export(PACKAGE Eigen3), so an unrelated build tree recorded in CMake's user
+# package registry can satisfy find_package and leave the scenario asserting
+# nothing about what it installed.
+if(EIGEN_EXPECTED_PREFIX)
+  get_filename_component(eigen_found_dir "${Eigen3_DIR}" REALPATH)
+  get_filename_component(eigen_expected_prefix "${EIGEN_EXPECTED_PREFIX}" REALPATH)
+  string(FIND "${eigen_found_dir}" "${eigen_expected_prefix}/" eigen_prefix_position)
+  if(NOT eigen_prefix_position EQUAL 0)
+    message(FATAL_ERROR
+            "found Eigen3 at ${eigen_found_dir}, expected it under ${eigen_expected_prefix}")
+  endif()
+endif()
+
+add_executable(consumer ../main.cpp)
+target_link_libraries(consumer Eigen3::Eigen)
diff --git a/test/buildsystem/consumers/main.cpp b/test/buildsystem/consumers/main.cpp
new file mode 100644
index 0000000..4a189fc
--- /dev/null
+++ b/test/buildsystem/consumers/main.cpp
@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Consumer program shared by the build-system integration tests.  It exists to
+// prove that the Eigen a scenario assembled is usable, so it exercises a
+// header, a template instantiation, and a computed result rather than only
+// including <Eigen/Dense>.  The marker on the last line is what the driver
+// matches; a run that ends early fails the scenario.
+
+#include <Eigen/Dense>
+
+#include <cstdio>
+
+int main() {
+  Eigen::Matrix3d m = Eigen::Matrix3d::Identity();
+  m(0, 1) = 2.0;
+  m(2, 0) = -1.0;
+
+  // Unit triangular up to the (2,0) entry, so the determinant is exactly one
+  // in binary floating point and needs no tolerance.
+  if (m.determinant() != 1.0) {
+    std::printf("determinant was %f, expected 1\n", m.determinant());
+    return 1;
+  }
+
+  Eigen::Vector3d v = m * Eigen::Vector3d(1.0, 1.0, 1.0);
+  if (v(0) != 3.0) {
+    std::printf("product gave %f, expected 3\n", v(0));
+    return 1;
+  }
+
+  std::printf("eigen-ok\n");
+  return 0;
+}
diff --git a/test/buildsystem/consumers/subproject/CMakeLists.txt b/test/buildsystem/consumers/subproject/CMakeLists.txt
new file mode 100644
index 0000000..10df8d6
--- /dev/null
+++ b/test/buildsystem/consumers/subproject/CMakeLists.txt
@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Embeds Eigen the way doc/TopicCMakeGuide.dox describes for FetchContent:
+# the options are forced before Eigen is added, then Eigen3::Eigen is linked.
+# FetchContent_MakeAvailable reduces to this add_subdirectory call, so driving
+# add_subdirectory directly tests the same path without a network fetch.
+#
+# EIGEN_USE_EXCLUDE_FROM_ALL selects the variant the guide's EXCLUDE_FROM_ALL
+# section describes.
+
+cmake_minimum_required(VERSION 3.17)
+project(eigen_subproject_consumer CXX)
+
+# The consumer runs a test of its own, so the scenario can require that CTest
+# in this build directory sees exactly that one test.  Without a test to find,
+# "Eigen contributed nothing" and "CTest read the wrong directory" produce the
+# same empty listing.  enable_testing() precedes add_subdirectory so that any
+# test Eigen registered would be generated into this tree too.
+enable_testing()
+
+set(EIGEN_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE)
+set(EIGEN_BUILD_DEMOS OFF CACHE BOOL "" FORCE)
+set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
+
+if(EIGEN_USE_EXCLUDE_FROM_ALL)
+  add_subdirectory("${EIGEN_SOURCE_DIR}" eigen-build EXCLUDE_FROM_ALL)
+else()
+  add_subdirectory("${EIGEN_SOURCE_DIR}" eigen-build)
+endif()
+
+add_executable(consumer ../main.cpp)
+target_link_libraries(consumer Eigen3::Eigen)
+add_test(NAME consumer_runs COMMAND consumer)
+
+# The consumer's own install rule must keep working whatever Eigen's does, so
+# the scenarios can tell "Eigen installed nothing" apart from "nothing ran".
+install(TARGETS consumer RUNTIME DESTINATION bin)
diff --git a/test/buildsystem/consumers/suitesparse/CMakeLists.txt b/test/buildsystem/consumers/suitesparse/CMakeLists.txt
new file mode 100644
index 0000000..0c7f343
--- /dev/null
+++ b/test/buildsystem/consumers/suitesparse/CMakeLists.txt
@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Stands in for Eigen's use of Find{CHOLMOD,UMFPACK,KLU,SPQR}.cmake: it asks for
+# the legacy variables those modules define and checks that they are still
+# usable, which is what a second configure of the same build tree used to break.
+# The suitesparse_reconfigure scenario supplies EIGEN_CMAKE_DIR, a <pkg>_DIR per
+# package pointing at a fake SuiteSparse >= 7 config package, and the include
+# directory those packages export.
+
+cmake_minimum_required(VERSION 3.17)
+project(suitesparse_consumer NONE)
+
+list(APPEND CMAKE_MODULE_PATH "${EIGEN_CMAKE_DIR}")
+
+foreach(pkg IN ITEMS CHOLMOD UMFPACK KLU SPQR)
+  find_package(${pkg})
+
+  if(NOT ${pkg}_FOUND)
+    message(FATAL_ERROR "${pkg} was not found")
+  endif()
+
+  # The legacy *_LIBRARIES value names an imported target, so the config package
+  # has to have been loaded by this configure run, not merely by the one that
+  # filled the cache.
+  if(NOT ${pkg}_LIBRARIES STREQUAL "SuiteSparse::${pkg}")
+    message(FATAL_ERROR "${pkg}_LIBRARIES is '${${pkg}_LIBRARIES}', expected SuiteSparse::${pkg}")
+  endif()
+  if(NOT TARGET ${${pkg}_LIBRARIES})
+    message(FATAL_ERROR "${pkg}_LIBRARIES names ${${pkg}_LIBRARIES}, which is not a target here")
+  endif()
+
+  # Asserting the exact directory the fake config package exports also proves
+  # the config-mode branch ran, rather than a SuiteSparse that happens to be
+  # installed on the host answering the manual fallback search.
+  if(NOT ${pkg}_INCLUDES STREQUAL "${EXPECTED_INCLUDE_DIR}")
+    message(FATAL_ERROR "${pkg}_INCLUDES is '${${pkg}_INCLUDES}', expected ${EXPECTED_INCLUDE_DIR}")
+  endif()
+  # A generator expression is not a directory, and a consumer that reads include directories at configure time
+  # cannot resolve one.
+  foreach(dir IN LISTS ${pkg}_INCLUDES)
+    if(NOT IS_DIRECTORY "${dir}")
+      message(FATAL_ERROR "${pkg}_INCLUDES holds '${dir}', which is not a usable directory")
+    endif()
+  endforeach()
+endforeach()
diff --git a/test/buildsystem/run_scenario.cmake b/test/buildsystem/run_scenario.cmake
new file mode 100644
index 0000000..feb98c1
--- /dev/null
+++ b/test/buildsystem/run_scenario.cmake
@@ -0,0 +1,263 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Driver for the build-system integration tests.  Run in script mode:
+#
+#   cmake -DEIGEN_SOURCE_DIR=<src> -DSCENARIO=<name> -DWORK_DIR=<dir>
+#         -DGENERATOR=<gen> -DCXX_COMPILER=<path> -DBUILD_CONFIG=<cfg>
+#         -P run_scenario.cmake
+#
+# The driver defines the helpers below and then includes
+# scenarios/${SCENARIO}.cmake, which performs the assertions.  A failed
+# assertion aborts with FATAL_ERROR, which CTest reports as a test failure.
+
+cmake_minimum_required(VERSION 3.17)
+
+foreach(var EIGEN_SOURCE_DIR SCENARIO WORK_DIR GENERATOR BUILD_CONFIG)
+  if(NOT DEFINED ${var})
+    message(FATAL_ERROR "run_scenario.cmake requires -D${var}=<value>")
+  endif()
+endforeach()
+
+set(BS_CONSUMER_DIR "${CMAKE_CURRENT_LIST_DIR}/consumers")
+set(BS_PREFIX "${WORK_DIR}/prefix")
+
+# The parts of Eigen's own build that no scenario inspects are slow to
+# configure and drag in tools a scenario should not depend on.
+set(BS_EIGEN_QUIET_OPTIONS
+    -DEIGEN_BUILD_TESTING=OFF
+    -DEIGEN_BUILD_DOC=OFF
+    -DEIGEN_BUILD_DEMOS=OFF
+    -DEIGEN_BUILD_BLAS=OFF
+    -DEIGEN_BUILD_LAPACK=OFF
+    )
+
+# Eigen calls export(PACKAGE Eigen3), so CMake's user package registry names
+# every Eigen build tree on the machine.  A find_package scenario that let the
+# registry answer would pass without ever reading the install tree it just
+# built, so every such configure disables both registries and additionally
+# asserts, in the consumer project, that the package came from BS_PREFIX.
+set(BS_FIND_PACKAGE_ISOLATION
+    -DCMAKE_FIND_USE_PACKAGE_REGISTRY=OFF
+    -DCMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY=OFF
+    )
+
+# Start from an empty work directory so a rerun cannot observe a previous
+# run's cache or install tree.
+file(REMOVE_RECURSE "${WORK_DIR}")
+file(MAKE_DIRECTORY "${WORK_DIR}")
+
+function(bs_fail message)
+  message(FATAL_ERROR "[${SCENARIO}] ${message}")
+endfunction()
+
+function(bs_assert_streq actual expected what)
+  if(NOT actual STREQUAL expected)
+    bs_fail("${what}:\n  expected [${expected}]\n  actual   [${actual}]")
+  endif()
+endfunction()
+
+# Runs a command, failing the scenario with its merged output unless the exit
+# status matches EXPECT_RESULT.  EXPECT_RESULT accepts a number or the word
+# FAILURE, which admits any non-zero status.
+function(bs_run)
+  cmake_parse_arguments(BS "" "WHAT;EXPECT_RESULT;OUTPUT_VARIABLE" "COMMAND" ${ARGN})
+  if(NOT DEFINED BS_EXPECT_RESULT)
+    set(BS_EXPECT_RESULT 0)
+  endif()
+  execute_process(COMMAND ${BS_COMMAND}
+                  RESULT_VARIABLE result
+                  OUTPUT_VARIABLE output
+                  ERROR_VARIABLE output)
+  if(BS_EXPECT_RESULT STREQUAL "FAILURE")
+    if(result EQUAL 0)
+      bs_fail("${BS_WHAT} was expected to fail but succeeded\n----\n${output}\n----")
+    endif()
+  elseif(NOT result EQUAL BS_EXPECT_RESULT)
+    bs_fail("${BS_WHAT} exited ${result}, expected ${BS_EXPECT_RESULT}\n----\n${output}\n----")
+  endif()
+  if(BS_OUTPUT_VARIABLE)
+    set(${BS_OUTPUT_VARIABLE} "${output}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+# Eigen's own project() call enables C as well as CXX, so a nested configure of
+# Eigen needs both compilers.  An image whose compilers are versioned names such
+# as gcc-10/g++-10, with no plain cc on PATH, has none to detect on its own.
+function(bs_cmake_compiler_args out_var)
+  set(args "")
+  if(C_COMPILER)
+    list(APPEND args "-DCMAKE_C_COMPILER=${C_COMPILER}")
+  endif()
+  if(CXX_COMPILER)
+    list(APPEND args "-DCMAKE_CXX_COMPILER=${CXX_COMPILER}")
+  endif()
+  set(${out_var} "${args}" PARENT_SCOPE)
+endfunction()
+
+# Configures <src> into <bin>.  Remaining arguments are passed to CMake.
+function(bs_configure what src bin)
+  bs_cmake_compiler_args(compiler_args)
+  bs_run(WHAT "configure ${what}"
+         COMMAND ${CMAKE_COMMAND} -S "${src}" -B "${bin}" -G "${GENERATOR}"
+                 "-DCMAKE_BUILD_TYPE=${BUILD_CONFIG}" ${compiler_args} ${ARGN})
+endfunction()
+
+# Configures <src> expecting failure, returning the output through <output_var>.
+function(bs_configure_expect_failure what src bin output_var)
+  bs_cmake_compiler_args(compiler_args)
+  bs_run(WHAT "configure ${what}" EXPECT_RESULT FAILURE OUTPUT_VARIABLE output
+         COMMAND ${CMAKE_COMMAND} -S "${src}" -B "${bin}" -G "${GENERATOR}"
+                 "-DCMAKE_BUILD_TYPE=${BUILD_CONFIG}" ${compiler_args} ${ARGN})
+  set(${output_var} "${output}" PARENT_SCOPE)
+endfunction()
+
+function(bs_build what bin)
+  bs_run(WHAT "build ${what}"
+         COMMAND ${CMAKE_COMMAND} --build "${bin}" --config "${BUILD_CONFIG}" ${ARGN})
+endfunction()
+
+function(bs_install what bin)
+  bs_run(WHAT "install ${what}"
+         COMMAND ${CMAKE_COMMAND} --install "${bin}" --config "${BUILD_CONFIG}")
+endfunction()
+
+# Configures Eigen as a top-level project and installs it into BS_PREFIX.
+# Remaining arguments are passed to the Eigen configure.
+function(bs_install_eigen)
+  bs_configure("Eigen" "${EIGEN_SOURCE_DIR}" "${WORK_DIR}/eigen-build"
+               "-DCMAKE_INSTALL_PREFIX=${BS_PREFIX}"
+               ${BS_EIGEN_QUIET_OPTIONS} ${ARGN})
+  bs_install("Eigen" "${WORK_DIR}/eigen-build")
+endfunction()
+
+# Every file in the install prefix, as paths relative to it.  Matching against
+# this list rather than globbing absolute paths keeps the assertions
+# independent of how deep INCLUDE_INSTALL_DIR happens to be.
+function(bs_installed_files out_var)
+  set(found "")
+  if(EXISTS "${BS_PREFIX}")
+    file(GLOB_RECURSE absolute LIST_DIRECTORIES false "${BS_PREFIX}/*")
+    foreach(path IN LISTS absolute)
+      file(RELATIVE_PATH relative "${BS_PREFIX}" "${path}")
+      list(APPEND found "${relative}")
+    endforeach()
+  endif()
+  list(SORT found)
+  set(${out_var} "${found}" PARENT_SCOPE)
+endfunction()
+
+# A readable excerpt of the install tree for failure messages.
+function(bs_installed_summary out_var)
+  bs_installed_files(all)
+  list(LENGTH all count)
+  set(excerpt "${all}")
+  if(count GREATER 20)
+    list(SUBLIST excerpt 0 20 excerpt)
+    list(APPEND excerpt "... and ${count} files in total")
+  endif()
+  string(REPLACE ";" "\n  " excerpt "${excerpt}")
+  set(${out_var} "${count} file(s) installed:\n  ${excerpt}" PARENT_SCOPE)
+endfunction()
+
+function(bs_matching_installed_files regex out_var)
+  bs_installed_files(all)
+  set(hits "")
+  foreach(path IN LISTS all)
+    if(path MATCHES "${regex}")
+      list(APPEND hits "${path}")
+    endif()
+  endforeach()
+  set(${out_var} "${hits}" PARENT_SCOPE)
+endfunction()
+
+function(bs_assert_installed regex what)
+  bs_matching_installed_files("${regex}" hits)
+  if(NOT hits)
+    bs_installed_summary(summary)
+    bs_fail("expected ${what} matching /${regex}/ in the install tree; ${summary}")
+  endif()
+endfunction()
+
+function(bs_assert_not_installed regex what)
+  bs_matching_installed_files("${regex}" hits)
+  if(hits)
+    string(REPLACE ";" "\n  " listing "${hits}")
+    bs_fail("expected no ${what} in the install tree, found:\n  ${listing}")
+  endif()
+endfunction()
+
+# Asserts the install tree holds nothing Eigen contributes: headers from the
+# supported and contributed trees, the legacy unsupported/ shims, the signature
+# file, eigen3.pc, and the CMake package files.
+function(bs_assert_no_eigen_installed)
+  bs_assert_not_installed("/Eigen/Core$" "supported Eigen header")
+  bs_assert_not_installed("/contrib/Eigen/Tensor$" "contributed Eigen header")
+  bs_assert_not_installed("/unsupported/Eigen/Tensor$" "legacy unsupported Eigen shim")
+  bs_assert_not_installed("signature_of_eigen3_matrix_library$" "Eigen signature file")
+  bs_assert_not_installed("eigen3\\.pc$" "eigen3.pc")
+  bs_assert_not_installed("Eigen3Config\\.cmake$" "Eigen3 CMake package")
+  bs_assert_not_installed("Eigen3Targets.*\\.cmake$" "Eigen3 CMake targets")
+endfunction()
+
+# Asserts the install tree holds the headers a consumer needs.
+function(bs_assert_eigen_headers_installed)
+  bs_assert_installed("/Eigen/Core$" "supported Eigen header")
+  bs_assert_installed("/Eigen/Dense$" "Eigen/Dense umbrella")
+  bs_assert_installed("/contrib/Eigen/Tensor$" "contributed Eigen header")
+  bs_assert_installed("/unsupported/Eigen/Tensor$" "legacy unsupported Eigen shim")
+  bs_assert_installed("signature_of_eigen3_matrix_library$" "Eigen signature file")
+endfunction()
+
+# The version Eigen3ConfigVersion.cmake will carry, read from the same header
+# the top-level CMakeLists parses.  Deriving the version constraints a scenario
+# tests from this keeps them meaningful across a release bump instead of
+# pinning them to whatever version happened to be current.
+function(bs_eigen_package_version out_major out_minor out_patch)
+  file(READ "${EIGEN_SOURCE_DIR}/Eigen/Version" header)
+  foreach(component MAJOR MINOR PATCH)
+    # Test the match itself, not CMAKE_MATCH_1: a legitimate component value of
+    # 0 is false to if().
+    string(REGEX MATCH "define[ \t]+EIGEN_${component}_VERSION[ \t]+([0-9]+)" matched "${header}")
+    if(NOT matched)
+      bs_fail("could not read EIGEN_${component}_VERSION from Eigen/Version")
+    endif()
+    set(value_${component} "${CMAKE_MATCH_1}")
+  endforeach()
+  set(${out_major} "${value_MAJOR}" PARENT_SCOPE)
+  set(${out_minor} "${value_MINOR}" PARENT_SCOPE)
+  set(${out_patch} "${value_PATCH}" PARENT_SCOPE)
+endfunction()
+
+function(bs_find_consumer_executable bin out_var)
+  foreach(candidate
+          "${bin}/consumer" "${bin}/consumer.exe"
+          "${bin}/${BUILD_CONFIG}/consumer" "${bin}/${BUILD_CONFIG}/consumer.exe")
+    if(EXISTS "${candidate}")
+      set(${out_var} "${candidate}" PARENT_SCOPE)
+      return()
+    endif()
+  endforeach()
+  set(${out_var} "" PARENT_SCOPE)
+endfunction()
+
+# Builds a consumer project and runs it, failing unless it prints the marker
+# its source promises.  Running it is what proves the headers a scenario
+# assembled are usable, not merely present.
+function(bs_build_and_run_consumer what bin)
+  bs_build("${what}" "${bin}")
+  bs_find_consumer_executable("${bin}" consumer_exe)
+  if(NOT consumer_exe)
+    bs_fail("${what}: built no consumer executable under ${bin}")
+  endif()
+  bs_run(WHAT "run ${what}" OUTPUT_VARIABLE output COMMAND "${consumer_exe}")
+  if(NOT output MATCHES "eigen-ok")
+    bs_fail("${what}: consumer ran but did not print its marker\n----\n${output}\n----")
+  endif()
+endfunction()
+
+set(BS_SCENARIO_FILE "${CMAKE_CURRENT_LIST_DIR}/scenarios/${SCENARIO}.cmake")
+if(NOT EXISTS "${BS_SCENARIO_FILE}")
+  message(FATAL_ERROR "no such scenario: ${BS_SCENARIO_FILE}")
+endif()
+include("${BS_SCENARIO_FILE}")
diff --git a/test/buildsystem/scenarios/add_subdirectory.cmake b/test/buildsystem/scenarios/add_subdirectory.cmake
new file mode 100644
index 0000000..d692ee7
--- /dev/null
+++ b/test/buildsystem/scenarios/add_subdirectory.cmake
@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: Eigen can be embedded without installing it first,
+# applying the guide's "Disabling Eigen build options" snippet beforehand.  The
+# consumer project sets exactly those options, so this covers both claims:
+# Eigen3::Eigen is usable from a sub-project, and an embedded Eigen contributes
+# nothing to the enclosing project's tests.
+
+bs_configure("embedding consumer" "${BS_CONSUMER_DIR}/subproject" "${WORK_DIR}/consumer"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}")
+bs_build_and_run_consumer("embedding consumer" "${WORK_DIR}/consumer")
+
+# Embedding Eigen must leave the enclosing project's test list alone: the
+# consumer registers one test of its own, and that must be all CTest reports.
+#
+# CTest gained --test-dir in CMake 3.20.  On the 3.17 Eigen supports it is
+# accepted and ignored, leaving CTest to inspect its own working directory --
+# which is the outer Eigen build tree, whose tests would then be reported as
+# the consumer's.  Select the consumer build directory by changing into it.
+bs_run(WHAT "list tests of the embedding consumer" OUTPUT_VARIABLE tests
+       COMMAND ${CMAKE_COMMAND} -E chdir "${WORK_DIR}/consumer"
+               ${CMAKE_CTEST_COMMAND} -N)
+if(NOT tests MATCHES "consumer_runs")
+  bs_fail("CTest did not inspect the consumer build directory\n----\n${tests}\n----")
+endif()
+if(NOT tests MATCHES "Total Tests: 1")
+  bs_fail("embedding Eigen changed the enclosing project's test list:\n----\n${tests}\n----")
+endif()
diff --git a/test/buildsystem/scenarios/exclude_from_all.cmake b/test/buildsystem/scenarios/exclude_from_all.cmake
new file mode 100644
index 0000000..fc9950b
--- /dev/null
+++ b/test/buildsystem/scenarios/exclude_from_all.cmake
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: passing EXCLUDE_FROM_ALL to add_subdirectory "drops
+# Eigen's install rules".  CMake documents this on the EXCLUDE_FROM_ALL
+# directory property rather than on add_subdirectory, and the wording only
+# appeared in recent releases, so the behavior is worth pinning at whatever
+# CMake version is running the suite.
+#
+# The guide's separate warning -- that FetchContent_Declare ignores the keyword
+# before CMake 3.28 -- cannot be checked here, because a scenario only ever has
+# the one CMake that launched it.
+
+bs_configure("embedding consumer with EXCLUDE_FROM_ALL" "${BS_CONSUMER_DIR}/subproject"
+             "${WORK_DIR}/consumer"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}"
+             "-DCMAKE_INSTALL_PREFIX=${BS_PREFIX}"
+             "-DEIGEN_USE_EXCLUDE_FROM_ALL=ON")
+bs_build_and_run_consumer("embedding consumer with EXCLUDE_FROM_ALL" "${WORK_DIR}/consumer")
+bs_install("embedding consumer with EXCLUDE_FROM_ALL" "${WORK_DIR}/consumer")
+
+bs_assert_no_eigen_installed()
+bs_assert_installed("bin/consumer" "the consumer's own executable")
diff --git a/test/buildsystem/scenarios/find_package.cmake b/test/buildsystem/scenarios/find_package.cmake
new file mode 100644
index 0000000..df22749
--- /dev/null
+++ b/test/buildsystem/scenarios/find_package.cmake
@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: an installed Eigen is consumed with
+# find_package(Eigen3 REQUIRED NO_MODULE) and target_link_libraries against
+# Eigen3::Eigen.  Also pins what a default top-level install contains, since
+# every later scenario asserting an absence is only meaningful against it.
+
+bs_install_eigen()
+
+bs_assert_eigen_headers_installed()
+bs_assert_installed("Eigen3Config\\.cmake$" "Eigen3 CMake package")
+bs_assert_installed("Eigen3ConfigVersion\\.cmake$" "Eigen3 package version file")
+bs_assert_installed("Eigen3Targets\\.cmake$" "Eigen3 exported targets")
+bs_assert_installed("/Eigen/Version$" "generated Eigen/Version header")
+
+# pkgconfig_off only asserts that eigen3.pc is absent, so without the positive
+# case here it would stay green even if pkg-config installation broke for every
+# configuration.  EIGEN_BUILD_PKGCONFIG, and with it eigen3.pc, exists only
+# where the top-level CMakeLists offers the option.
+if(NOT WIN32 OR NOT CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+  bs_assert_installed("eigen3\\.pc$" "eigen3.pc")
+endif()
+
+bs_configure("consumer" "${BS_CONSUMER_DIR}/installed" "${WORK_DIR}/consumer"
+             "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+             "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+             ${BS_FIND_PACKAGE_ISOLATION})
+bs_build_and_run_consumer("consumer" "${WORK_DIR}/consumer")
diff --git a/test/buildsystem/scenarios/find_package_version_range.cmake b/test/buildsystem/scenarios/find_package_version_range.cmake
new file mode 100644
index 0000000..31d5cfd
--- /dev/null
+++ b/test/buildsystem/scenarios/find_package_version_range.cmake
@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: "we also support a range spanning major versions",
+# spelled find_package(Eigen3 3.4...5 REQUIRED NO_MODULE).  The claim rests on
+# the hand-written cmake/Eigen3ConfigVersion.cmake.in, whose inclusive upper
+# bound admits everything below <max>+1, so the range has to be exercised
+# against a real installed package rather than reasoned about.
+#
+# The upper bound is taken from Eigen's own major version, which is what makes
+# the documented "3.4...5" span the current release; writing 5 here instead
+# would turn this into a failing test the day Eigen 6 ships.
+#
+# test/buildsystem/CMakeLists.txt registers this scenario only for CMake 3.19
+# and newer, which is where find_package learned range syntax.
+
+bs_install_eigen()
+bs_eigen_package_version(major minor patch)
+
+bs_configure("consumer with range 3.4...${major}" "${BS_CONSUMER_DIR}/installed"
+             "${WORK_DIR}/consumer"
+             "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+             "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+             "-DEIGEN_VERSION_SPEC=3.4...${major}"
+             ${BS_FIND_PACKAGE_ISOLATION})
+bs_build_and_run_consumer("consumer with a version range" "${WORK_DIR}/consumer")
+
+# An in-range success alone would also be produced by a range branch that
+# accepted every range, and find_package_version_reject cannot catch that: it
+# only reaches the non-range branch.  Bracket the installed version instead, so
+# a bound that stops being enforced fails here.
+math(EXPR above_major "${major}+1")
+math(EXPR above_major_end "${major}+2")
+bs_configure_expect_failure("consumer with range ${above_major}...${above_major_end}"
+                            "${BS_CONSUMER_DIR}/installed" "${WORK_DIR}/consumer-above" output
+                            "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+                            "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+                            "-DEIGEN_VERSION_SPEC=${above_major}...${above_major_end}"
+                            ${BS_FIND_PACKAGE_ISOLATION})
+if(NOT output MATCHES "Eigen3")
+  bs_fail("configure failed for some reason other than the version check\n----\n${output}\n----")
+endif()
+
+# "...<" is the exclusive upper bound, so this range stops just below the
+# installed major and must not match it.
+bs_configure_expect_failure("consumer with range 1...<${major}"
+                            "${BS_CONSUMER_DIR}/installed" "${WORK_DIR}/consumer-below" output
+                            "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+                            "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+                            "-DEIGEN_VERSION_SPEC=1...<${major}"
+                            ${BS_FIND_PACKAGE_ISOLATION})
+if(NOT output MATCHES "Eigen3")
+  bs_fail("configure failed for some reason other than the version check\n----\n${output}\n----")
+endif()
diff --git a/test/buildsystem/scenarios/find_package_version_reject.cmake b/test/buildsystem/scenarios/find_package_version_reject.cmake
new file mode 100644
index 0000000..f25b8d1
--- /dev/null
+++ b/test/buildsystem/scenarios/find_package_version_reject.cmake
@@ -0,0 +1,71 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# The complement of find_package_version_range: without a rejection case, a
+# version file that accepted everything would pass that test.
+#
+# The non-range branch of cmake/Eigen3ConfigVersion.cmake.in accepts a package
+# whose version is at least the requested one and below the next major, so a
+# bare "3.4" spans >=3.4 to <4.0.0 rather than 3.4.z.  Rejecting a request one
+# major above the installed package would hold under either reading, so the
+# cases below pin the implemented one: both bounds, plus -- whenever the
+# installed version leaves room to state it -- a minor below the installed one
+# that must still be accepted.
+
+bs_install_eigen()
+bs_eigen_package_version(major minor patch)
+
+if(major LESS 4)
+  bs_fail("this scenario assumes Eigen's major version is at least 4, got ${major}")
+endif()
+
+# Upper bound: an earlier major must not answer, whatever its minor.
+bs_configure_expect_failure("consumer pinned to 3.4" "${BS_CONSUMER_DIR}/installed"
+                            "${WORK_DIR}/consumer-old" output
+                            "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+                            "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+                            "-DEIGEN_VERSION_SPEC=3.4"
+                            ${BS_FIND_PACKAGE_ISOLATION})
+if(NOT output MATCHES "Eigen3")
+  bs_fail("configure failed for some reason other than the version check\n----\n${output}\n----")
+endif()
+
+math(EXPR too_new "${major}+1")
+bs_configure_expect_failure("consumer requiring ${too_new}" "${BS_CONSUMER_DIR}/installed"
+                            "${WORK_DIR}/consumer-new" output
+                            "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+                            "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+                            "-DEIGEN_VERSION_SPEC=${too_new}"
+                            ${BS_FIND_PACKAGE_ISOLATION})
+if(NOT output MATCHES "Eigen3")
+  bs_fail("configure failed for some reason other than the version check\n----\n${output}\n----")
+endif()
+
+# Lower bound: a patch above the installed one is inside the same major and must
+# still be rejected, which a file that only compared majors would not do.
+math(EXPR next_patch "${patch}+1")
+bs_configure_expect_failure("consumer requiring ${major}.${minor}.${next_patch}"
+                            "${BS_CONSUMER_DIR}/installed"
+                            "${WORK_DIR}/consumer-patch" output
+                            "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+                            "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+                            "-DEIGEN_VERSION_SPEC=${major}.${minor}.${next_patch}"
+                            ${BS_FIND_PACKAGE_ISOLATION})
+if(NOT output MATCHES "Eigen3")
+  bs_fail("configure failed for some reason other than the version check\n----\n${output}\n----")
+endif()
+
+# The case that separates ">=X.Y, <X+1.0.0" from "X.Y.z": an older minor of the
+# installed major must be accepted.  Only statable once the release series has
+# moved past .0, so it is a control the scenario adds when it can rather than a
+# requirement on the version number.
+if(minor GREATER 0)
+  math(EXPR previous_minor "${minor}-1")
+  bs_configure("consumer requiring ${major}.${previous_minor}" "${BS_CONSUMER_DIR}/installed"
+               "${WORK_DIR}/consumer-minor"
+               "-DCMAKE_PREFIX_PATH=${BS_PREFIX}"
+               "-DEIGEN_EXPECTED_PREFIX=${BS_PREFIX}"
+               "-DEIGEN_VERSION_SPEC=${major}.${previous_minor}"
+               ${BS_FIND_PACKAGE_ISOLATION})
+  bs_build_and_run_consumer("consumer requiring an older minor" "${WORK_DIR}/consumer-minor")
+endif()
diff --git a/test/buildsystem/scenarios/gpu_architectures.cmake b/test/buildsystem/scenarios/gpu_architectures.cmake
new file mode 100644
index 0000000..22fa86a
--- /dev/null
+++ b/test/buildsystem/scenarios/gpu_architectures.cmake
@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+include("${EIGEN_SOURCE_DIR}/cmake/EigenGpuTesting.cmake")
+
+# Architecture selection must not require an installed toolkit or GPU.
+function(check_architectures toolkit eigen_arch cmake_arch environment_arch expected)
+  set(CUDAToolkit_VERSION "${toolkit}")
+  set(EIGEN_CUDA_COMPUTE_ARCH "${eigen_arch}")
+  set(CMAKE_CUDA_ARCHITECTURES "${cmake_arch}")
+  set(ENV{CUDAARCHS} "${environment_arch}")
+  ei_cuda_resolve_compute_arch()
+  bs_assert_streq("${EIGEN_CUDA_COMPUTE_ARCH}" "${expected}" "CUDA architecture selection")
+endfunction()
+
+check_architectures(12.8 "" "" "" 60)
+check_architectures(13.3 "" "" "" 75)
+check_architectures(13.3 "" "89" "" 89)
+check_architectures(13.3 "" "75;89-real" "" "75;89-real")
+check_architectures(13.3 "" "native" "" native)
+check_architectures(13.3 "" "OFF" "" OFF)
+check_architectures(13.3 "" "" "89" 89)
+check_architectures(13.3 "" "89" "75" 89)
+check_architectures(13.3 "86" "89" "75" 86)
+
+# Observe the architecture setting at language enablement, before compiler ABI detection.
+macro(enable_language language)
+  bs_assert_streq("${language}" "HIP" "enabled GPU language")
+  bs_assert_streq("${CMAKE_HIP_ARCHITECTURES}" "${expected}" "HIP architectures before compiler detection")
+endmacro()
+
+function(check_hip_architectures eigen_arch cmake_arch expected)
+  set(EIGEN_TEST_CUDA OFF)
+  set(EIGEN_TEST_HIP ON)
+  unset(EIGEN_HIP_ARCHITECTURES CACHE)
+  if(NOT "${eigen_arch}" STREQUAL "")
+    set(EIGEN_HIP_ARCHITECTURES "${eigen_arch}")
+  endif()
+  set(CMAKE_HIP_ARCHITECTURES "${cmake_arch}")
+  ei_gpu_testing_enable()
+endfunction()
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.21)
+  check_hip_architectures("" ""
+    "gfx900;gfx906;gfx908;gfx90a;gfx940;gfx941;gfx942;gfx1030;gfx1100;gfx1101;gfx1102;gfx1150;gfx1151")
+  check_hip_architectures("gfx906;gfx1100" "" "gfx906;gfx1100")
+  check_hip_architectures("gfx906" "gfx942" "gfx942")
+  check_hip_architectures("gfx906" "OFF" "OFF")
+endif()
+
+# Trailing arguments are passed to the consumer's configure.
+function(check_cuda_route route architectures expected_result expected_flags)
+  string(MD5 configuration "${ARGN}")
+  string(SUBSTRING "${configuration}" 0 8 configuration)
+  execute_process(
+    COMMAND "${CMAKE_COMMAND}" -G "${GENERATOR}"
+            -S "${BS_CONSUMER_DIR}/gpu_architectures"
+            -B "${WORK_DIR}/${route}-${architectures}-${configuration}"
+            "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}"
+            "-DROUTE=${route}" "-DARCHITECTURES=${architectures}" "-DEXPECTED_FLAGS=${expected_flags}" ${ARGN}
+    RESULT_VARIABLE result OUTPUT_VARIABLE output ERROR_VARIABLE output)
+  if(expected_result STREQUAL "FAILURE")
+    if(result EQUAL 0 OR NOT output MATCHES "architectures only, for example 75;89")
+      bs_fail("${route} must reject ${architectures} with a numeric-architecture diagnostic:\n${output}")
+    endif()
+  elseif(NOT result EQUAL 0)
+    bs_fail("${route} rejected ${architectures}:\n${output}")
+  endif()
+endfunction()
+
+check_cuda_route(nvc 75 SUCCESS " -cuda -gpu=cc75 ")
+check_cuda_route(nvc "75,89" SUCCESS " -cuda -gpu=cc75 -gpu=cc89 ")
+check_cuda_route(windows-clang 75 SUCCESS " --cuda-path=/cuda --cuda-gpu-arch=sm_75 ")
+check_cuda_route(windows-clang "75,89" SUCCESS " --cuda-path=/cuda --cuda-gpu-arch=sm_75 --cuda-gpu-arch=sm_89 ")
+foreach(arch native OFF all all-major 89-real 89-virtual sm_89 "75,native")
+  check_cuda_route(nvc "${arch}" FAILURE "")
+  check_cuda_route(windows-clang "${arch}" FAILURE "")
+endforeach()
+check_cuda_route(cuda-language 75 SUCCESS "")
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.24)
+  foreach(arch native OFF all all-major 89-real 89-virtual "75,89-real")
+    check_cuda_route(cuda-language "${arch}" SUCCESS "")
+  endforeach()
+endif()
+
+# An explicit nvcc selects the toolkit around it unless CUDAToolkit_ROOT does, and only nvcc does.
+set(toolkit "${WORK_DIR}/cuda-12.8")
+set(nvcc "${toolkit}/bin/nvcc")
+if(CMAKE_HOST_WIN32)
+  string(APPEND nvcc ".exe")
+endif()
+file(WRITE "${nvcc}" "")
+check_cuda_route(cuda-language 75 SUCCESS "" "-DCMAKE_CUDA_COMPILER=${nvcc}" "-DEXPECTED_TOOLKIT_ROOT=${toolkit}")
+check_cuda_route(cuda-language 75 SUCCESS "" "-DCMAKE_CUDA_COMPILER=${nvcc}"
+                 "-DCUDAToolkit_ROOT=${WORK_DIR}/cuda-13.4" "-DEXPECTED_TOOLKIT_ROOT=${WORK_DIR}/cuda-13.4")
+check_cuda_route(nvc 75 SUCCESS " -cuda -gpu=cc75 " "-DCMAKE_CUDA_COMPILER=${nvcc}")
diff --git a/test/buildsystem/scenarios/gpu_compile_options.cmake b/test/buildsystem/scenarios/gpu_compile_options.cmake
new file mode 100644
index 0000000..73d1517
--- /dev/null
+++ b/test/buildsystem/scenarios/gpu_compile_options.cmake
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+bs_configure("GPU compile options" "${BS_CONSUMER_DIR}/gpu_compile_options" "${WORK_DIR}/build"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}")
diff --git a/test/buildsystem/scenarios/gpu_flags.cmake b/test/buildsystem/scenarios/gpu_flags.cmake
new file mode 100644
index 0000000..49c8977
--- /dev/null
+++ b/test/buildsystem/scenarios/gpu_flags.cmake
@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+function(check_cuda_flags name environment toolchain expected_detection expected_build expected_cache)
+  set(build "${WORK_DIR}/${name}-${clang}-${custom}")
+  set(toolchain_file "${build}/toolchain.cmake")
+  file(WRITE "${toolchain_file}" "set(CMAKE_CUDA_FLAGS_INIT \"${toolchain}\")\n")
+  bs_configure("CUDA flags: ${name}" "${BS_CONSUMER_DIR}/gpu_flags" "${build}"
+               "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}"
+               "-DCMAKE_TOOLCHAIN_FILE=${toolchain_file}"
+               "-DEIGEN_TEST_CUDA_CLANG=${clang}"
+               "-DEIGEN_CUDA_CXX_FLAGS=${custom}"
+               "-DENVIRONMENT_FLAGS=${environment}"
+               "-DEXPECTED_DETECTION=${expected_detection}"
+               "-DEXPECTED_BUILD=${expected_build}"
+               "-DEXPECTED_CACHE=${expected_cache}" ${ARGN})
+
+  # The cache keeps the initial defaults; changed Eigen flags replace the previous extras on reconfigure.
+  file(WRITE "${toolchain_file}" "set(CMAKE_CUDA_FLAGS_INIT \"-DCHANGED_INIT=1\")\n")
+  bs_configure("CUDA flags: ${name}, reconfigure" "${BS_CONSUMER_DIR}/gpu_flags" "${build}"
+               "-DEIGEN_CUDA_CXX_FLAGS=-DCHANGED_EIGEN=1"
+               "-DENVIRONMENT_FLAGS=-DCHANGED_ENV=1"
+               "-DEXPECTED_DETECTION=${expected_build}")
+endfunction()
+
+foreach(clang OFF ON)
+  foreach(custom "" "-DEIGEN_FLAG=1")
+    check_cuda_flags(empty "" "" "" "-DPLATFORM_FLAG=1" "-DPLATFORM_FLAG=1")
+    check_cuda_flags(environment "-DENV_FLAG=1" "" "-DENV_FLAG=1"
+                     "-DENV_FLAG=1 -DPLATFORM_FLAG=1" "-DENV_FLAG=1 -DPLATFORM_FLAG=1")
+    check_cuda_flags(toolchain "" "-DINIT_FLAG=1" "-DINIT_FLAG=1"
+                     "-DINIT_FLAG=1 -DPLATFORM_FLAG=1" "-DINIT_FLAG=1 -DPLATFORM_FLAG=1")
+    check_cuda_flags(combined "-DENV_FLAG=1" "-DINIT_FLAG=1" "-DENV_FLAG=1 -DINIT_FLAG=1"
+                     "-DENV_FLAG=1 -DINIT_FLAG=1 -DPLATFORM_FLAG=1"
+                     "-DENV_FLAG=1 -DINIT_FLAG=1 -DPLATFORM_FLAG=1")
+    check_cuda_flags(cache "-DENV_FLAG=1" "-DINIT_FLAG=1" "-DCACHE_FLAG=1" "-DCACHE_FLAG=1" "-DCACHE_FLAG=1"
+                     "-DCMAKE_CUDA_FLAGS=-DCACHE_FLAG=1")
+    check_cuda_flags(cache_empty "-DENV_FLAG=1" "-DINIT_FLAG=1" "" "" "" "-DCMAKE_CUDA_FLAGS=")
+    check_cuda_flags(normal "-DENV_FLAG=1" "-DINIT_FLAG=1" "-DNORMAL_FLAG=1" "-DNORMAL_FLAG=1"
+                     "-DENV_FLAG=1 -DINIT_FLAG=1 -DPLATFORM_FLAG=1" "-DNORMAL_FLAGS=-DNORMAL_FLAG=1")
+    check_cuda_flags(normal_empty "-DENV_FLAG=1" "-DINIT_FLAG=1" "" ""
+                     "-DENV_FLAG=1 -DINIT_FLAG=1 -DPLATFORM_FLAG=1" "-DNORMAL_FLAGS=")
+  endforeach()
+endforeach()
diff --git a/test/buildsystem/scenarios/gpu_runtime_linkage.cmake b/test/buildsystem/scenarios/gpu_runtime_linkage.cmake
new file mode 100644
index 0000000..4118fa8
--- /dev/null
+++ b/test/buildsystem/scenarios/gpu_runtime_linkage.cmake
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+bs_configure("GPU runtime linkage" "${BS_CONSUMER_DIR}/gpu_runtime" "${WORK_DIR}/build"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}")
diff --git a/test/buildsystem/scenarios/hip_architectures.cmake b/test/buildsystem/scenarios/hip_architectures.cmake
new file mode 100644
index 0000000..26af699
--- /dev/null
+++ b/test/buildsystem/scenarios/hip_architectures.cmake
@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+bs_configure("HIP architecture forwarding"
+             "${BS_CONSUMER_DIR}/hip_architectures" "${WORK_DIR}/consumer"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}")
diff --git a/test/buildsystem/scenarios/install_default.cmake b/test/buildsystem/scenarios/install_default.cmake
new file mode 100644
index 0000000..9dee1a8
--- /dev/null
+++ b/test/buildsystem/scenarios/install_default.cmake
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: "Eigen's install rules are enabled even when it is
+# built as a sub-project."  This is the baseline that makes install_off and
+# exclude_from_all meaningful -- without it, a build that installed nothing at
+# all would satisfy both of them.
+
+bs_configure("embedding consumer" "${BS_CONSUMER_DIR}/subproject" "${WORK_DIR}/consumer"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}"
+             "-DCMAKE_INSTALL_PREFIX=${BS_PREFIX}")
+bs_build("embedding consumer" "${WORK_DIR}/consumer")
+bs_install("embedding consumer" "${WORK_DIR}/consumer")
+
+bs_assert_eigen_headers_installed()
+bs_assert_installed("bin/consumer" "the consumer's own executable")
diff --git a/test/buildsystem/scenarios/install_off.cmake b/test/buildsystem/scenarios/install_off.cmake
new file mode 100644
index 0000000..eb40b33
--- /dev/null
+++ b/test/buildsystem/scenarios/install_off.cmake
@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: with EIGEN_INSTALL set to OFF, "Eigen then places no
+# file at all under CMAKE_INSTALL_PREFIX", while the embedding project's own
+# install rules keep working.  This is issue #3088.
+
+bs_configure("embedding consumer with EIGEN_INSTALL=OFF" "${BS_CONSUMER_DIR}/subproject"
+             "${WORK_DIR}/consumer"
+             "-DEIGEN_SOURCE_DIR=${EIGEN_SOURCE_DIR}"
+             "-DCMAKE_INSTALL_PREFIX=${BS_PREFIX}"
+             "-DEIGEN_INSTALL=OFF")
+bs_build_and_run_consumer("embedding consumer with EIGEN_INSTALL=OFF" "${WORK_DIR}/consumer")
+bs_install("embedding consumer with EIGEN_INSTALL=OFF" "${WORK_DIR}/consumer")
+
+bs_assert_no_eigen_installed()
+bs_assert_installed("bin/consumer" "the consumer's own executable")
+
+# Nothing but the consumer's own executable may appear, so a future install
+# rule added outside the EIGEN_INSTALL guard is caught here rather than only
+# by the named checks above.
+bs_installed_files(installed)
+list(LENGTH installed count)
+if(NOT count EQUAL 1)
+  bs_installed_summary(summary)
+  bs_fail("expected only the consumer's executable; ${summary}")
+endif()
diff --git a/test/buildsystem/scenarios/install_off_all_options.cmake b/test/buildsystem/scenarios/install_off_all_options.cmake
new file mode 100644
index 0000000..6f9fb39
--- /dev/null
+++ b/test/buildsystem/scenarios/install_off_all_options.cmake
@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox: with EIGEN_INSTALL set to OFF, "Eigen then places no
+# file at all under CMAKE_INSTALL_PREFIX".
+#
+# install_off exercises that claim where a project meets it, embedded, and there
+# EIGEN_BUILD_CMAKE_PACKAGE, EIGEN_BUILD_PKGCONFIG, EIGEN_BUILD_BLAS and
+# EIGEN_BUILD_LAPACK all default to OFF -- so the guards around those install
+# rules are never reached and could regress unnoticed.  Enable every one of them
+# in a top-level configure instead, which is also the only configuration that
+# reaches the install-doc target.
+
+bs_configure("Eigen with EIGEN_INSTALL=OFF and every install option on"
+             "${EIGEN_SOURCE_DIR}" "${WORK_DIR}/eigen-build"
+             "-DCMAKE_INSTALL_PREFIX=${BS_PREFIX}"
+             -DEIGEN_BUILD_TESTING=OFF
+             -DEIGEN_BUILD_DOC=OFF
+             -DEIGEN_BUILD_DEMOS=OFF
+             -DEIGEN_BUILD_BLAS=ON
+             -DEIGEN_BUILD_LAPACK=ON
+             -DEIGEN_BUILD_CMAKE_PACKAGE=ON
+             -DEIGEN_BUILD_PKGCONFIG=ON
+             -DEIGEN_INSTALL=OFF)
+bs_install("Eigen with EIGEN_INSTALL=OFF" "${WORK_DIR}/eigen-build")
+
+bs_assert_no_eigen_installed()
+bs_assert_not_installed("eigen_blas" "the BLAS library")
+bs_assert_not_installed("eigen_lapack" "the LAPACK library")
+
+# Naming the artifacts above still lets an unguarded install rule for something
+# else through, and here nothing at all is expected under the prefix.
+bs_installed_files(installed)
+if(installed)
+  bs_installed_summary(summary)
+  bs_fail("expected an empty install prefix; ${summary}")
+endif()
+
+# install-doc copies the generated documentation into CMAKE_INSTALL_FULL_DOCDIR,
+# so it is an install rule in every sense that matters here and must not exist
+# either.  Asking to build it is enough: the documentation is never generated,
+# because a target that is gone cannot run.
+bs_configure("Eigen with EIGEN_INSTALL=OFF and documentation enabled"
+             "${EIGEN_SOURCE_DIR}" "${WORK_DIR}/eigen-doc-build"
+             "-DCMAKE_INSTALL_PREFIX=${BS_PREFIX}"
+             -DEIGEN_BUILD_TESTING=OFF
+             -DEIGEN_BUILD_DOC=ON
+             -DEIGEN_BUILD_DEMOS=OFF
+             -DEIGEN_BUILD_BLAS=OFF
+             -DEIGEN_BUILD_LAPACK=OFF
+             -DEIGEN_INSTALL=OFF)
+bs_run(WHAT "build install-doc with EIGEN_INSTALL=OFF" EXPECT_RESULT FAILURE
+       OUTPUT_VARIABLE output
+       COMMAND ${CMAKE_COMMAND} --build "${WORK_DIR}/eigen-doc-build"
+               --config "${BUILD_CONFIG}" --target install-doc)
+if(NOT output MATCHES "install-doc")
+  bs_fail("the install-doc build failed for some other reason\n----\n${output}\n----")
+endif()
diff --git a/test/buildsystem/scenarios/pkgconfig_off.cmake b/test/buildsystem/scenarios/pkgconfig_off.cmake
new file mode 100644
index 0000000..ea944d4
--- /dev/null
+++ b/test/buildsystem/scenarios/pkgconfig_off.cmake
@@ -0,0 +1,12 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# doc/TopicCMakeGuide.dox lists EIGEN_BUILD_PKGCONFIG among the options an
+# embedding project turns off.  find_package already pins that a default
+# top-level install ships eigen3.pc, so this pins that the option suppresses
+# it, and that the headers are unaffected either way.
+
+bs_install_eigen(-DEIGEN_BUILD_PKGCONFIG=OFF)
+
+bs_assert_not_installed("eigen3\\.pc$" "eigen3.pc")
+bs_assert_eigen_headers_installed()
diff --git a/test/buildsystem/scenarios/suitesparse_reconfigure.cmake b/test/buildsystem/scenarios/suitesparse_reconfigure.cmake
new file mode 100644
index 0000000..e2ff944
--- /dev/null
+++ b/test/buildsystem/scenarios/suitesparse_reconfigure.cmake
@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Find{CHOLMOD,UMFPACK,KLU,SPQR}.cmake cache values that are only meaningful
+# while the SuiteSparse >= 7 config package is loaded: *_LIBRARIES names an
+# imported target and *_INCLUDES comes from that target's
+# INTERFACE_INCLUDE_DIRECTORIES.  So the claim under test is specifically that
+# the second configure of a build tree behaves like the first -- the first one
+# always worked -- and, separately, that no generator expression reaches the
+# cache, since SuiteSparse >= 7 lists one beside the real include directory.
+#
+# No SuiteSparse installation is involved: each package is a fake config file
+# exporting a target of the shape SuiteSparse installs.
+
+set(fake_root "${WORK_DIR}/suitesparse")
+set(include_dir "${fake_root}/include")
+file(MAKE_DIRECTORY "${include_dir}")
+
+set(package_args "")
+foreach(pkg IN ITEMS CHOLMOD UMFPACK KLU SPQR)
+  set(pkg_dir "${fake_root}/${pkg}")
+  file(MAKE_DIRECTORY "${pkg_dir}")
+  file(WRITE "${pkg_dir}/${pkg}Config.cmake"
+"# Stand-in for the config package SuiteSparse >= 7 installs.  The guard is
+# needed because Find${pkg}.cmake loads this file on every configure.
+if(NOT TARGET SuiteSparse::${pkg})
+  add_library(SuiteSparse::${pkg} INTERFACE IMPORTED)
+  set_target_properties(SuiteSparse::${pkg} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+    \"${include_dir};$<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>\")
+endif()
+")
+  list(APPEND package_args "-D${pkg}_DIR=${pkg_dir}")
+endforeach()
+
+set(consumer_src "${BS_CONSUMER_DIR}/suitesparse")
+set(consumer_bin "${WORK_DIR}/consumer")
+
+bs_configure("the SuiteSparse consumer, cold cache" "${consumer_src}" "${consumer_bin}"
+             "-DEIGEN_CMAKE_DIR=${EIGEN_SOURCE_DIR}/cmake"
+             "-DEXPECTED_INCLUDE_DIR=${include_dir}"
+             ${package_args})
+bs_configure("the SuiteSparse consumer, warm cache" "${consumer_src}" "${consumer_bin}"
+             "-DEIGEN_CMAKE_DIR=${EIGEN_SOURCE_DIR}/cmake"
+             "-DEXPECTED_INCLUDE_DIR=${include_dir}"
+             ${package_args})
+# What a build tool triggers after an edit: a re-configure carrying nothing but
+# the cache the previous runs wrote.
+bs_configure("the SuiteSparse consumer, re-generated from the cache alone"
+             "${consumer_src}" "${consumer_bin}")
+
+file(READ "${consumer_bin}/CMakeCache.txt" cache)
+foreach(pkg IN ITEMS CHOLMOD UMFPACK KLU SPQR)
+  if(NOT cache MATCHES "\n${pkg}_INCLUDES:[A-Z]+=([^\n]*)")
+    bs_fail("${pkg}_INCLUDES was never cached")
+  endif()
+  if(NOT CMAKE_MATCH_1 STREQUAL "${include_dir}")
+    bs_fail("${pkg}_INCLUDES cached as '${CMAKE_MATCH_1}', expected ${include_dir}")
+  endif()
+endforeach()
+
+# --- Upgrade path -------------------------------------------------------------
+# The scenario above starts from an empty cache, which is not how anyone meets
+# this bug: they have a build tree configured *before* the fix, whose cache
+# already holds the unusable generator-expression value.  `set(... CACHE ...)`
+# does nothing when the entry exists, so without FORCE the find modules would
+# leave that value in place and reconfiguring would never heal the tree.
+#
+# Seed exactly that state and require one configure to repair it.
+set(stale_bin "${WORK_DIR}/consumer-stale")
+file(MAKE_DIRECTORY "${stale_bin}")
+set(stale_genex "$<TARGET_PROPERTY:SuiteSparse::SuiteSparseConfig,INTERFACE_INCLUDE_DIRECTORIES>")
+set(seed "")
+foreach(pkg IN ITEMS CHOLMOD UMFPACK KLU SPQR)
+  string(APPEND seed "${pkg}_INCLUDES:PATH=${include_dir};${stale_genex}\n")
+  string(APPEND seed "${pkg}_LIBRARIES:STRING=SuiteSparse::${pkg}\n")
+endforeach()
+file(WRITE "${stale_bin}/CMakeCache.txt" "${seed}")
+
+bs_configure("the SuiteSparse consumer, cache poisoned by a pre-fix configure"
+             "${consumer_src}" "${stale_bin}"
+             "-DEIGEN_CMAKE_DIR=${EIGEN_SOURCE_DIR}/cmake"
+             "-DEXPECTED_INCLUDE_DIR=${include_dir}"
+             ${package_args})
+
+file(READ "${stale_bin}/CMakeCache.txt" stale_cache)
+foreach(pkg IN ITEMS CHOLMOD UMFPACK KLU SPQR)
+  if(NOT stale_cache MATCHES "\n${pkg}_INCLUDES:[A-Z]+=([^\n]*)")
+    bs_fail("${pkg}_INCLUDES was never cached in the poisoned tree")
+  endif()
+  # Hold the capture: any later MATCHES would overwrite CMAKE_MATCH_1.
+  set(healed "${CMAKE_MATCH_1}")
+  if(healed MATCHES "\\$<")
+    bs_fail("${pkg}_INCLUDES still holds a generator expression after re-configure: '${healed}'")
+  endif()
+  if(NOT healed STREQUAL "${include_dir}")
+    bs_fail("${pkg}_INCLUDES healed to '${healed}', expected ${include_dir}")
+  endif()
+endforeach()
diff --git a/test/bunchkaufman.cpp b/test/bunchkaufman.cpp
new file mode 100644
index 0000000..f037131
--- /dev/null
+++ b/test/bunchkaufman.cpp
@@ -0,0 +1,782 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Enable Eigen's runtime malloc tracking so bunchkaufman_no_malloc() can assert that compute()
+// performs no heap allocation when the workspace is pre-allocated. (Malloc stays allowed by default;
+// only that one subtest toggles it off.) Must be defined before any Eigen header is included.
+#define EIGEN_RUNTIME_NO_MALLOC
+
+#include "main.h"
+#include <Eigen/Cholesky>
+#include <Eigen/QR>
+#include <Eigen/Eigenvalues>
+#include "fp_control.h"
+#include "solverbase.h"
+
+// Reconstruct the block-diagonal D from vectorD() / subDiagonal() and check that
+// P^T L D L^* P == A and that matrixL()/matrixU() are consistent.
+template <typename MatrixType, typename BKType>
+void verify_factorization(const MatrixType& A, const BKType& bk) {
+  typedef typename MatrixType::Scalar Scalar;
+  const Index n = A.rows();
+
+  VERIFY_IS_APPROX(A, bk.reconstructedMatrix());
+
+  // The diagonal of D must be exactly real (not merely up to roundoff): the factorization
+  // re-realifies the trailing diagonal after each Hermitian update, like LAPACK xHETF2/xHETRF.
+  for (Index k = 0; k < n; ++k) {
+    VERIFY(numext::is_exactly_zero(numext::imag(bk.vectorD().coeff(k))));
+  }
+
+  // Build D explicitly from vectorD() and subDiagonal() and reconstruct manually.
+  MatrixType D = MatrixType::Zero(n, n);
+  D.diagonal() = bk.vectorD();
+  for (Index k = 0; k + 1 < n; ++k) {
+    Scalar s = bk.subDiagonal()(k);
+    if (!numext::is_exactly_zero(s)) {
+      D(k + 1, k) = s;
+      D(k, k + 1) = numext::conj(s);
+    }
+  }
+  // matrixU() should be the adjoint of matrixL().
+  MatrixType L = bk.matrixL();
+  MatrixType U = bk.matrixU();
+  VERIFY_IS_APPROX(L.adjoint(), U);
+
+  // P^T L D L^* P
+  MatrixType PtL = bk.transpositionsP().transpose() * L;
+  MatrixType recon = PtL * D * PtL.adjoint();
+  VERIFY_IS_APPROX(A, recon);
+}
+
+// Core test on a Hermitian indefinite matrix `symm` (full, self-adjoint).
+template <typename MatrixType>
+void bunchkaufman_solve_and_reconstruct(const MatrixType& symm) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+
+  const Index rows = symm.rows();
+  const Index cols = symm.cols();
+
+  SquareMatrixType symmLo = symm.template triangularView<Lower>();
+  SquareMatrixType symmUp = symm.template triangularView<Upper>();
+
+  BunchKaufman<SquareMatrixType, Lower> bk_lo(symmLo);
+  VERIFY(bk_lo.info() == Success);
+  verify_factorization(SquareMatrixType(symm), bk_lo);
+  check_solverbase<VectorType, VectorType>(symm, bk_lo, rows, rows, 1);
+  check_solverbase<MatrixType, MatrixType>(symm, bk_lo, rows, cols, rows);
+
+  BunchKaufman<SquareMatrixType, Upper> bk_up(symmUp);
+  VERIFY(bk_up.info() == Success);
+  verify_factorization(SquareMatrixType(symm), bk_up);
+  check_solverbase<VectorType, VectorType>(symm, bk_up, rows, rows, 1);
+
+  // MatrixBase / SelfAdjointView entry points.
+  verify_factorization(SquareMatrixType(symm), SquareMatrixType(symm).bunchKaufman());
+  verify_factorization(SquareMatrixType(symm), symm.template selfadjointView<Lower>().bunchKaufman());
+  verify_factorization(SquareMatrixType(symm), symm.template selfadjointView<Upper>().bunchKaufman());
+
+  // rcond() within a factor of 10 of the true reciprocal 1-norm condition number.
+  if (rows > 0) {
+    const SquareMatrixType inv = bk_lo.solve(SquareMatrixType::Identity(rows, rows));
+    using RealScalar = typename MatrixType::RealScalar;
+    RealScalar rcond = (RealScalar(1) / matrix_l1_norm<SquareMatrixType, Lower>(symmLo)) /
+                       matrix_l1_norm<SquareMatrixType, Lower>(inv);
+    RealScalar rcond_est = bk_lo.rcond();
+    VERIFY(rcond_est >= rcond / 10 && rcond_est <= rcond * 10);
+  }
+}
+
+// Build a Hermitian matrix with a prescribed (real) eigenvalue spectrum and check inertia + stability.
+template <typename MatrixType>
+void bunchkaufman_inertia_and_conditioning(Index n) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+
+  // Random orthonormal/unitary U via QR.
+  MatrixType R = MatrixType::Random(n, n);
+  HouseholderQR<MatrixType> qr(R);
+  MatrixType U = qr.householderQ();
+
+  // Eigenvalues spanning a wide magnitude range, with mixed signs (indefinite).
+  const RealScalar s = (std::min)(RealScalar(6), RealScalar(std::numeric_limits<RealScalar>::max_exponent10) / 8);
+  RealVectorType d(n);
+  Index expect_pos = 0, expect_neg = 0;
+  for (Index k = 0; k < n; ++k) {
+    RealScalar mag = numext::pow(RealScalar(10), internal::random<RealScalar>(-s, s));
+    RealScalar sign = internal::random<bool>() ? RealScalar(1) : RealScalar(-1);
+    d(k) = sign * mag;
+    if (d(k) > 0)
+      ++expect_pos;
+    else
+      ++expect_neg;
+  }
+  MatrixType A = U * d.asDiagonal() * U.adjoint();
+  // Force exact Hermitian symmetry (kill round-off asymmetry).
+  A = (A + A.adjoint()).eval() * Scalar(RealScalar(0.5));
+
+  BunchKaufman<MatrixType, Lower> bk(A);
+  VERIFY(bk.info() == Success);
+  VERIFY_IS_APPROX(A, bk.reconstructedMatrix());
+
+  // isPositive()/isNegative() agree with the true inertia.
+  VERIFY(bk.isPositive() == (expect_neg == 0));
+  VERIFY(bk.isNegative() == (expect_pos == 0));
+
+  // Backward-stable solve: relative residual is small even for ill-conditioned A.
+  Matrix<Scalar, Dynamic, 1> b = Matrix<Scalar, Dynamic, 1>::Random(n);
+  Matrix<Scalar, Dynamic, 1> x = bk.solve(b);
+  RealScalar res = (A * x - b).norm() / b.norm();
+  RealScalar tol = sqrt(test_precision<RealScalar>());
+  VERIFY(res <= tol);
+}
+
+// Definiteness / 2x2-pivot regression cases.
+template <typename Scalar>
+void bunchkaufman_small_cases() {
+  typedef Matrix<Scalar, 2, 2> Mat2;
+  typedef Matrix<Scalar, 2, 1> Vec2;
+
+  // Indefinite with zero diagonal -> requires a 2x2 pivot.
+  {
+    Mat2 A;
+    A << Scalar(0), Scalar(1), Scalar(1), Scalar(0);
+    BunchKaufman<Mat2> bk(A);
+    VERIFY(bk.info() == Success);
+    VERIFY_IS_APPROX(A, bk.reconstructedMatrix());
+    VERIFY(!bk.isPositive());
+    VERIFY(!bk.isNegative());
+    Vec2 b(Scalar(3), Scalar(5));
+    Vec2 x = bk.solve(b);
+    VERIFY_IS_APPROX(A * x, b);
+  }
+  // Diagonal indefinite [[1,0],[0,-1]].
+  {
+    Mat2 A;
+    A << Scalar(1), Scalar(0), Scalar(0), Scalar(-1);
+    BunchKaufman<Mat2> bk(A);
+    VERIFY(bk.info() == Success);
+    VERIFY_IS_APPROX(A, bk.reconstructedMatrix());
+    VERIFY(!bk.isPositive());
+    VERIFY(!bk.isNegative());
+  }
+  // 1x1.
+  {
+    Matrix<Scalar, 1, 1> A;
+    A << Scalar(-3);
+    BunchKaufman<Matrix<Scalar, 1, 1> > bk(A);
+    VERIFY(bk.info() == Success);
+    VERIFY_IS_APPROX(A, bk.reconstructedMatrix());
+    VERIFY(!bk.isPositive());
+    VERIFY(bk.isNegative());
+  }
+}
+
+// Exactly-singular matrix: factorization succeeds structurally but reports NumericalIssue,
+// while still reconstructing the input exactly. Exercised at a small size (unblocked kernel) and a
+// size larger than the panel width (blocked kernel, where the zero pivot lands inside a panel).
+template <typename Scalar>
+void bunchkaufman_singular(Index n) {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  // A zero column/row makes the matrix exactly singular with an exact zero pivot. Place it in the
+  // interior so that, for n > blocksize, it falls inside a panel of the blocked algorithm.
+  const Index z = n / 2;
+  MatrixType M = MatrixType::Random(n, n);
+  MatrixType A = M + M.adjoint();
+  A.col(z).setZero();
+  A.row(z).setZero();
+  BunchKaufman<MatrixType, Lower> lo(A);
+  VERIFY(lo.info() == NumericalIssue);
+  VERIFY_IS_APPROX(A, lo.reconstructedMatrix());
+  // matrixL() must be a well-formed unit lower triangular factor even on the singular column.
+  VERIFY((lo.matrixL().toDenseMatrix().diagonal().array() == Scalar(1)).all());
+  BunchKaufman<MatrixType, Upper> up(A);
+  VERIFY(up.info() == NumericalIssue);
+  VERIFY_IS_APPROX(A, up.reconstructedMatrix());
+}
+
+// A matrix containing a NaN must be reported as a numerical failure (matching LAPACK's DISNAN guard),
+// not silently accepted.
+template <typename Scalar>
+void bunchkaufman_nan() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  for (Index n : {5, 100}) {
+    MatrixType M = MatrixType::Random(n, n);
+    MatrixType A = M + M.adjoint();
+    A(n / 2, n / 2) = std::numeric_limits<typename NumTraits<Scalar>::Real>::quiet_NaN();
+    BunchKaufman<MatrixType> bk(A);
+    VERIFY(bk.info() == NumericalIssue);
+  }
+}
+
+// Rank-deficient PSD: A = a a^* with a of rank r < n. Reconstruct must match.
+template <typename Scalar>
+void bunchkaufman_rank_deficient() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  const Index n = 16;
+  const Index r = internal::random<Index>(1, n - 1);
+  MatrixType a = MatrixType::Random(n, r);
+  MatrixType A = a * a.adjoint();
+  BunchKaufman<MatrixType> bk(A);
+  VERIFY_IS_APPROX(A, bk.reconstructedMatrix());
+  VERIFY(!bk.isNegative());  // PSD -> no negative eigenvalues
+}
+
+// Blocking and 2x2-panel-boundary stress across sizes that straddle the panel width.
+template <typename Scalar>
+void bunchkaufman_blocking_boundary() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index PS = internal::packet_traits<Scalar>::size;
+  const Index sizes[] = {1,  2,  3,  PS - 1, PS,  PS + 1, 2 * PS, 31,  32,         33,
+                         63, 64, 65, 96,     127, 128,    129,    192, 2 * 64 + 3, 200};
+  for (Index n : sizes) {
+    if (n <= 0) continue;
+    MatrixType M = MatrixType::Random(n, n);
+    MatrixType A = M + M.adjoint();
+    // Force several 2x2 pivots by shrinking the diagonal.
+    A.diagonal() *= Scalar(RealScalar(1e-2));
+
+    BunchKaufman<MatrixType, Lower> lo(A);
+    VERIFY(lo.info() == Success);
+    VERIFY_IS_APPROX(A, lo.reconstructedMatrix());
+
+    BunchKaufman<MatrixType, Upper> up(A);
+    VERIFY(up.info() == Success);
+    VERIFY_IS_APPROX(A, up.reconstructedMatrix());
+
+    // Lower and Upper must yield the same (Hermitian) decomposition of A.
+    VERIFY_IS_APPROX(lo.reconstructedMatrix(), up.reconstructedMatrix());
+
+    Matrix<Scalar, Dynamic, 1> b = Matrix<Scalar, Dynamic, 1>::Random(n);
+    Matrix<Scalar, Dynamic, 1> x = lo.solve(b);
+    const Matrix<Scalar, Dynamic, 1> residual = A * x - b;
+    // The diagonal shrink above intentionally makes the pivot-boundary cases harder than the generic solve tests.
+    VERIFY(residual.norm() <= RealScalar(10) * NumTraits<Scalar>::epsilon() * (A.norm() * x.norm() + b.norm()));
+  }
+}
+
+// A = Q D Q^*, with Q unitary and D real, is Hermitian with det(A) = prod(D_ii). Mixed signs make A
+// indefinite, so the factorization mixes 1x1 and 2x2 blocks of D; drawing the |D_ii| from an annulus keeps
+// A well conditioned, hence the inertia -- and with it signDeterminant() -- unambiguous.
+template <typename MatrixType>
+void bunchkaufman_determinant(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+
+  MatrixType q = MatrixType::Random(size, size).householderQr().householderQ();
+  RealVectorType d(size);
+  for (Index i = 0; i < size; ++i) {
+    d(i) = internal::random<RealScalar>(RealScalar(1.2), RealScalar(2.8));
+    if (internal::random<bool>()) d(i) = -d(i);
+  }
+  const MatrixType a = q * d.template cast<Scalar>().asDiagonal() * q.adjoint();
+
+  const RealScalar det = d.prod();
+  const RealScalar logabsdet = d.array().abs().log().sum();
+
+  BunchKaufman<MatrixType, Lower> bklo(a);
+  VERIFY(bklo.info() == Success);
+  check_determinant(bklo, Scalar(det), logabsdet);
+  // Unlike the other decompositions, this sign is read off the inertia rather than accumulated from a
+  // product of signs, so it is exact.
+  VERIFY_IS_EQUAL(bklo.signDeterminant(), Scalar(numext::sign(det)));
+
+  BunchKaufman<MatrixType, Upper> bkup(a);
+  VERIFY(bkup.info() == Success);
+  check_determinant(bkup, Scalar(det), logabsdet);
+  // Unlike the other decompositions, this sign is read off the inertia rather than accumulated from a
+  // product of signs, so it is exact.
+  VERIFY_IS_EQUAL(bkup.signDeterminant(), Scalar(numext::sign(det)));
+}
+
+// The determinant of an empty matrix is the empty product, 1.
+template <typename MatrixType>
+void bunchkaufman_determinant_empty() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  BunchKaufman<MatrixType> bk{MatrixType(0, 0)};
+  VERIFY_IS_EQUAL(bk.determinant(), Scalar(1));
+  VERIFY_IS_EQUAL(bk.absDeterminant(), RealScalar(1));
+  VERIFY_IS_EQUAL(bk.logAbsDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(bk.signDeterminant(), Scalar(1));
+}
+
+// det(D) can be representable while the block determinants it is built from are not. The blocks below are
+// [[s/2, s], [s, s/2]] with det = -3s^2/4 at s = 2^600 and s = 2^-600, one overflowing and one
+// underflowing, whose product is exactly 9/16. Multiplying the blocks directly gives inf * 0 = NaN.
+void bunchkaufman_determinant_mixed_scale() {
+  MatrixXd a = MatrixXd::Zero(4, 4);
+  for (int b = 0; b < 2; ++b) {
+    const double s = numext::ldexp(1.0, b == 0 ? 600 : -600);
+    a(2 * b, 2 * b) = a(2 * b + 1, 2 * b + 1) = 0.5 * s;
+    a(2 * b + 1, 2 * b) = a(2 * b, 2 * b + 1) = s;
+  }
+
+  // (-3/4)^2 (2^600 2^-600)^2 = 9/16, exactly, both factors being powers of two.
+  const double det = 0.5625;
+
+  BunchKaufman<MatrixXd, Lower> bklo(a);
+  VERIFY(bklo.info() == Success);
+  check_determinant(bklo, det, numext::log(det));
+
+  BunchKaufman<MatrixXd, Upper> bkup(a);
+  VERIFY(bkup.info() == Success);
+  check_determinant(bkup, det, numext::log(det));
+}
+
+// Bunch-Kaufman selects a 2x2 block only where |d11 d22| <= alpha^2 |d21|^2, alpha = (1+sqrt(17))/8 < 1, so
+// det D_k = d11 d22 - |d21|^2 < 0 always. Subnormal |d21| underflows that determinant to zero, leaving the
+// log and the sign as the only accessors that can report it; both need det D_k / |d21|^2 = O(1), which
+// 1/|d21| overflows on, and the resulting infinity flips the block's inertia.
+template <typename MatrixType>
+void bunchkaufman_determinant_subnormal_block() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  if (!subnormalDivisionIsExact<RealScalar>()) {
+    const char* reason = ScopedFlushToZero::hardwareFlushesSubnormalInputs() ? "the hardware flushes subnormal inputs"
+                                                                             : "the compiler relaxed the division";
+    std::cout << "SKIP: bunchkaufman_determinant_subnormal_block needs an environment that divides by subnormals "
+                 "per IEEE 754 ("
+              << reason << ")." << std::endl;
+    return;
+  }
+
+  // Entries are exact integer multiples of the smallest subnormal u, so det A = (k11 k22 - k21^2) u^2 with
+  // the bracket an exact int, and log|det A| = log|k11 k22 - k21^2| + 2 log u -- a reference that shares no
+  // expression with the code under test. The off-diagonal stays real to keep the entries exact; the complex
+  // instantiation still reaches numext::abs() on a subnormal.
+  const RealScalar u = (std::numeric_limits<RealScalar>::denorm_min)();
+  const int k11[] = {0, 1, 2, 100};
+  const int k22[] = {0, 1, 2, 100};
+  const int k21[] = {1, 4, 8, 300};
+
+  for (int c = 0; c < 4; ++c) {
+    const int idet = k11[c] * k22[c] - k21[c] * k21[c];
+    VERIFY(idet < 0);
+    const RealScalar logabsdet = numext::log(RealScalar(-idet)) + RealScalar(2) * numext::log(u);
+
+    MatrixType a(2, 2);
+    a << Scalar(RealScalar(k11[c]) * u), Scalar(RealScalar(k21[c]) * u), Scalar(RealScalar(k21[c]) * u),
+        Scalar(RealScalar(k22[c]) * u);
+    // Flushing subnormal results to zero empties the matrix even where the division probe passed.
+    if (numext::is_exactly_zero(numext::abs(a.coeff(1, 0)))) return;
+
+    BunchKaufman<MatrixType, Lower> bk(a);
+    VERIFY(bk.info() == Success);
+
+    VERIFY_IS_EQUAL(bk.signDeterminant(), Scalar(-1));
+    VERIFY_IS_APPROX(bk.logAbsDeterminant(), logabsdet);
+    // det A is of order u^2, so zero is all these two can report.
+    VERIFY_IS_EQUAL(bk.absDeterminant(), RealScalar(0));
+    VERIFY_IS_EQUAL(bk.determinant(), Scalar(0));
+    VERIFY(!bk.isPositive());
+    VERIFY(!bk.isNegative());
+  }
+}
+
+// The criterion bounds |d11| against alpha|d21| but bounds |d22| only against the largest entry of its own
+// row, which can dwarf |d21|. So d22/d21 can overflow, and the scaled determinant comes out +-inf, or 0*inf
+// = NaN where d11 is zero; +inf and NaN count the block as definite with the sign of its trace, which is
+// positive here. The criterion puts the true magnitude below 1, which is what rejects all three.
+void bunchkaufman_inertia_wide_2x2_block() {
+  // The 2x2 block is (d11, d21, d22) = (a00, 1e-10, 1e299), determinant a00*1e299 - 1e-20 < 0 for every
+  // a00 below, so it contributes one eigenvalue of each sign. The block's inverse has entries of order
+  // d22/det ~ 1e319, so L = U D^{-1} is not representable and the factorization reports NumericalIssue
+  // (its own scaled determinant sees d22/d21 overflow); the inertia is still exact.
+  for (double a00 : {0.0, 1e-320, -1e-320}) {
+    MatrixXd a = MatrixXd::Zero(4, 4);
+    a(0, 0) = a00;
+    a(1, 0) = a(0, 1) = 1e-10;
+    a(1, 1) = 1e299;
+    a(3, 1) = a(1, 3) = 2e299;
+
+    BunchKaufman<MatrixXd> bk(a);
+    VERIFY(bk.info() == NumericalIssue);
+    VERIFY(!bk.isPositive());
+    VERIFY(!bk.isNegative());
+  }
+}
+
+// The scaling above divides by numext::abs(d21), so it relies on that magnitude not underflowing: for
+// |3u + 4iu| Eigen's hypot scales by the larger component instead of summing squares, giving 5u exactly
+// where u^2 would be zero. Not template code, because building the off-diagonal needs a complex literal.
+void bunchkaufman_determinant_subnormal_block_complex() {
+  typedef std::complex<double> Scalar;
+
+  if (!subnormalDivisionIsExact<double>()) return;
+
+  const double u = (std::numeric_limits<double>::denorm_min)();
+  MatrixXcd a(2, 2);
+  a << Scalar(u, 0), Scalar(3 * u, 4 * u), Scalar(3 * u, -4 * u), Scalar(u, 0);
+  BunchKaufman<MatrixXcd, Lower> bk(a);
+
+  // det = u^2 - |3u + 4iu|^2 = -24 u^2.
+  VERIFY_IS_EQUAL(bk.signDeterminant(), Scalar(-1));
+  VERIFY_IS_APPROX(bk.logAbsDeterminant(), numext::log(24.0) + 2.0 * numext::log(u));
+  VERIFY(!bk.isPositive());
+  VERIFY(!bk.isNegative());
+}
+
+template <typename MatrixType>
+void bunchkaufman_verify_assert() {
+  MatrixType tmp;
+  BunchKaufman<MatrixType> bk;
+  VERIFY_RAISES_ASSERT(bk.matrixL())
+  VERIFY_RAISES_ASSERT(bk.matrixU())
+  VERIFY_RAISES_ASSERT(bk.vectorD())
+  VERIFY_RAISES_ASSERT(bk.subDiagonal())
+  VERIFY_RAISES_ASSERT(bk.transpositionsP())
+  VERIFY_RAISES_ASSERT(bk.isPositive())
+  VERIFY_RAISES_ASSERT(bk.isNegative())
+  VERIFY_RAISES_ASSERT(bk.matrixLDLT())
+  VERIFY_RAISES_ASSERT(bk.reconstructedMatrix())
+  VERIFY_RAISES_ASSERT(bk.solve(tmp))
+  VERIFY_RAISES_ASSERT(bk.determinant())
+  VERIFY_RAISES_ASSERT(bk.absDeterminant())
+  VERIFY_RAISES_ASSERT(bk.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(bk.signDeterminant())
+}
+
+// Build a random Hermitian (real symmetric) indefinite matrix of the same type/size as `m`.
+template <typename MatrixType>
+MatrixType make_hermitian_indefinite(const MatrixType& m) {
+  MatrixType a = MatrixType::Random(m.rows(), m.cols());
+  return MatrixType(a + a.adjoint());
+}
+
+template <typename MatrixType>
+void bunchkaufman(const MatrixType& m) {
+  // General Hermitian indefinite.
+  bunchkaufman_solve_and_reconstruct(make_hermitian_indefinite(m));
+  // Zero-diagonal Hermitian -> forces 2x2 pivots throughout (needs n >= 2 to stay non-singular).
+  if (m.rows() >= 2) {
+    MatrixType A = make_hermitian_indefinite(m);
+    A.diagonal().setZero();
+    bunchkaufman_solve_and_reconstruct(A);
+  }
+}
+
+// Extreme-scale 2x2 pivot: an off-diagonal-only Hermitian 2x2 forces a single 2x2 pivot whose
+// determinant is det = -|off|^2. The scaled (det-free) 2x2 formulas must stay finite and correct when
+// |off| is huge or tiny. Regression for forming det = d11*d22 - |d21|^2 directly, which overflows to
+// +-inf for off=1e200 (solve then returns 0, residual 1) and underflows to 0 for off=1e-200 (solve
+// returns NaN/inf), and which also misclassifies the inertia. Requires a type that can hold 1e+-200,
+// so this is exercised for double / complex<double> only.
+template <typename Scalar>
+void bunchkaufman_extreme_scale() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, 2, 2> Mat2;
+  typedef Matrix<Scalar, 2, 1> Vec2;
+  const RealScalar tol = numext::sqrt(test_precision<RealScalar>());
+  for (RealScalar mag : {numext::pow(RealScalar(10), RealScalar(200)), numext::pow(RealScalar(10), RealScalar(-200))}) {
+    const Scalar off = Scalar(mag);
+    Mat2 A;
+    A << Scalar(0), numext::conj(off), off, Scalar(0);
+    BunchKaufman<Mat2> bk(A);
+    VERIFY(bk.info() == Success);
+    VERIFY(!bk.isPositive());  // det < 0 => one positive and one negative eigenvalue
+    VERIFY(!bk.isNegative());
+    // Use the max-abs (infinity) relative norm throughout: the Frobenius norm (.norm()) squares the
+    // ~1e200 entries and would overflow/underflow even for a correct factorization.
+    VERIFY((A - bk.reconstructedMatrix()).cwiseAbs().maxCoeff() <= tol * A.cwiseAbs().maxCoeff());
+    // A x = b with b = [1,1]; the product A*x stays O(1), so its residual is safe to measure.
+    const Vec2 b(Scalar(1), Scalar(1));
+    const Vec2 x = bk.solve(b);
+    VERIFY((A * x - b).cwiseAbs().maxCoeff() <= tol);
+  }
+}
+
+// Extreme-scale factorization at the matrix level: a zero-diagonal Hermitian matrix (2x2 pivots
+// throughout, exercising both the unblocked and -- for n > blocksize -- the blocked trailing update)
+// scaled to an extreme magnitude. The factorization is scale-equivariant and must remain overflow-free;
+// the solve must stay backward stable. double / complex<double> only (1e+-175 overflows float).
+template <typename Scalar>
+void bunchkaufman_extreme_scale_large(Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  const RealScalar tol = numext::sqrt(test_precision<RealScalar>());
+  MatrixType M = MatrixType::Random(n, n);
+  MatrixType A = M + M.adjoint();
+  A.diagonal().setZero();
+  // 1e+-175 is past the squaring threshold (|entry|^2 over/underflows double), so the pre-fix code
+  // (which forms det = d11*d22 - |d21|^2) produces NaN/Inf here, while the scaled formulas stay exact.
+  for (RealScalar sigma :
+       {numext::pow(RealScalar(10), RealScalar(175)), numext::pow(RealScalar(10), RealScalar(-175))}) {
+    const MatrixType As = A * Scalar(sigma);
+    BunchKaufman<MatrixType, Lower> bk(As);
+    VERIFY(bk.info() == Success);
+    // Max-abs relative reconstruction error (avoid .norm(), whose squaring overflows the ~1e175 entries).
+    VERIFY((As - bk.reconstructedMatrix()).cwiseAbs().maxCoeff() <= tol * As.cwiseAbs().maxCoeff());
+    // As*x stays O(1) for a unit-scale rhs, so its residual norm is safe to form.
+    const VectorType b = VectorType::Random(n);
+    const VectorType x = bk.solve(b);
+    VERIFY((As * x - b).norm() <= tol * b.norm());
+  }
+}
+
+// The off-diagonal of the subnormal 2x2 pivot block below: 4s, or (3 + 4i) s with the same |.| = 5s structure as
+// the determinant test above. Two overloads because a complex literal cannot be spelled in template code.
+template <typename Scalar>
+Scalar subnormal_block_off_diagonal(const Scalar& s, std::false_type /*IsComplex*/) {
+  return Scalar(4) * s;
+}
+template <typename Scalar>
+Scalar subnormal_block_off_diagonal(const typename NumTraits<Scalar>::Real& s, std::true_type /*IsComplex*/) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  return Scalar(RealScalar(3) * s, RealScalar(4) * s);
+}
+
+// Issue #3142: a 2x2 pivot block with a subnormal off-diagonal. D_k = s [[1, 4], [4, 1]] (d21 = (3+4i) s when
+// complex) is an ordinary 2x2 pivot, det D_k = -15 s^2 (-24 s^2), but 1/d21 overflows once d21 is subnormal, and a
+// reciprocal hoisted out of the factor-column and D-solve loops made both 0*inf. A is the identity apart from D_k
+// at rows p, p+1 and the m rows below it, coupled to it by small-integer multiples of s, so P = I, L - I is the
+// O(1) block C D_k^{-1}, and the Schur complement I - C D_k^{-1} C^* is I up to O(s) off-diagonal entries.
+template <typename MatrixType, typename BKType>
+void verify_subnormal_2x2_block(const MatrixType& A, const BKType& bk,
+                                const Matrix<typename MatrixType::Scalar, Dynamic, 1>& b,
+                                const Matrix<typename MatrixType::Scalar, Dynamic, 1>& x_true, Index m,
+                                const typename MatrixType::RealScalar& s) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  const RealScalar u = (std::numeric_limits<RealScalar>::denorm_min)();
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+
+  VERIFY(bk.info() == Success);
+  VERIFY(bk.matrixLDLT().allFinite());
+  VERIFY_IS_EQUAL(bk.signDeterminant(), Scalar(-1));
+  // The O(1) entries reconstruct exactly; an entry of order s is rebuilt from a few products that each round at
+  // the quantum u.
+  VERIFY((A - bk.reconstructedMatrix()).cwiseAbs().maxCoeff() <= RealScalar(8) * u);
+  // The D solve divides by d21 before anything else and is then a few roundings of O(1) values up to 2 in
+  // magnitude. A factor entry t*(ak*u0 - u1)/conj(d21) forms its numerator at the scale of s, about three
+  // roundings at the quantum u, so it is off by up to 3u/|d21| <= 3u/(4s); the substitution adds m*max|x| = 4
+  // of those to x.
+  const Matrix<Scalar, Dynamic, 1> x = bk.solve(b);
+  VERIFY(x.allFinite());
+  const RealScalar quantum = m > 0 ? u / s : RealScalar(0);
+  const RealScalar tol = RealScalar(16) * eps + RealScalar(4) * quantum;
+  VERIFY((x - x_true).cwiseAbs().maxCoeff() <= tol);
+}
+
+template <typename MatrixType>
+void bunchkaufman_subnormal_2x2_block(Index n, Index p, Index m, const typename MatrixType::RealScalar& s) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+
+  MatrixType A = MatrixType::Identity(n, n);
+  A(p, p) = A(p + 1, p + 1) = Scalar(s);
+  const Scalar d21 = subnormal_block_off_diagonal<Scalar>(s, internal::bool_constant<NumTraits<Scalar>::IsComplex>());
+  A(p + 1, p) = d21;
+  A(p, p + 1) = numext::conj(d21);
+  // Flushing subnormal results to zero empties the block even where the division probe passed.
+  if (numext::is_exactly_zero(numext::abs(A(p + 1, p)))) return;
+  // Couplings of magnitude at most 3s stay below |d21|, so the pivot search keeps row p+1 as the column
+  // maximum and selects the 2x2 block without an interchange.
+  for (Index i = 0; i < m; ++i) {
+    const Index r = p + 2 + i;
+    A(r, p) = A(p, r) = Scalar(RealScalar(i + 1) * s);
+    A(r, p + 1) = A(p + 1, r) = Scalar(RealScalar(2 * i - 3) * s);
+  }
+  VectorType x_true(n);
+  for (Index i = 0; i < n; ++i) x_true(i) = Scalar(RealScalar(i % 5) - RealScalar(2));
+  // Rows of order s are exact small-integer multiples of s; the others round to the integer x_true(i).
+  const VectorType b = A * x_true;
+
+  BunchKaufman<MatrixType, Lower> bk_lo(A);
+  verify_subnormal_2x2_block(A, bk_lo, b, x_true, m, s);
+  BunchKaufman<MatrixType, Upper> bk_up(A);
+  verify_subnormal_2x2_block(A, bk_up, b, x_true, m, s);
+}
+
+template <typename MatrixType>
+void bunchkaufman_subnormal_2x2_block() {
+  typedef typename MatrixType::RealScalar RealScalar;
+  if (!subnormalDivisionIsExact<RealScalar>()) {
+    const char* reason = ScopedFlushToZero::hardwareFlushesSubnormalInputs() ? "the hardware flushes subnormal inputs"
+                                                                             : "the compiler relaxed the division";
+    std::cout << "SKIP: bunchkaufman_subnormal_2x2_block needs an environment that divides by subnormals per "
+                 "IEEE 754 ("
+              << reason << ")." << std::endl;
+    return;
+  }
+  // s = min/1024 is subnormal with digits-10 significant bits, and 1/(4s) = 256/min overflows in every IEEE
+  // format. The coupled cases need those bits: their factor columns round at the quantum u relative to s.
+  const RealScalar s = (std::numeric_limits<RealScalar>::min)() / RealScalar(1024);
+  // The issue's two shapes -- the block last (no trailing update) and first -- at denorm_min itself where the
+  // block is real: every quotient is then dyadic and exact. A complex quotient of denorm_min-scale operands is
+  // exact only under a complex division that scales both operands, which the C++ runtime may or may not do, so
+  // the complex instantiations use s, where 3s*0.75 and 2.25s are representable under any of the algorithms.
+  const RealScalar s0 =
+      NumTraits<typename MatrixType::Scalar>::IsComplex ? s : (std::numeric_limits<RealScalar>::denorm_min)();
+  bunchkaufman_subnormal_2x2_block<MatrixType>(4, 2, 0, s0);
+  bunchkaufman_subnormal_2x2_block<MatrixType>(4, 0, 0, s0);
+  bunchkaufman_subnormal_2x2_block<MatrixType>(4, 0, 2, s);
+  // Above the panel width the blocked driver runs: block in the first panel, straddling the panel boundary
+  // (deferred to the next panel), opening the second panel, and last in the unblocked tail.
+  const Index n = 2 * internal::bunch_kaufman_blocksize<typename MatrixType::Scalar>() + 2;
+  for (Index p : {Index(0), n / 2 - 2, n / 2, n - 2}) {
+    bunchkaufman_subnormal_2x2_block<MatrixType>(n, p, p + 2 < n ? 2 : 0, s);
+  }
+}
+
+template <typename BKType, typename VectorType>
+void verify_near_max_scale(const BKType& bk, const VectorType& b, const VectorType& x_true) {
+  typedef typename VectorType::RealScalar RealScalar;
+  VERIFY(bk.info() == Success);
+  VERIFY(bk.matrixLDLT().allFinite());
+  // x_true = e_2 comes back through cancellations (6/5 - 6/5 and -3/5 + 3/5, or 18/25 - 18/25 and
+  // -9/25 + 9/25) of values that each carry a few roundings.
+  VERIFY((bk.solve(b) - x_true).cwiseAbs().maxCoeff() <= RealScalar(16) * NumTraits<RealScalar>::epsilon());
+}
+
+// A 2x2 pivot block at the top of the representable range: A = M [[1/2, 1, 0], [1, s/2, 9/10], [0, 9/10, 0]]
+// with M = max and s = +-1: d21 = M, ak = s/2, akm1 = 1/2, denom = s/4 - 1, and the factor row below the
+// block is (6/5, -3/5) for s = 1 and (18/25, -9/25) for s = -1. Scaling ak*u0 - u1 = -9M/10 by t before
+// dividing by d21 overflows although the entries are finite; for s = -1 so does denom*d21, which would zero
+// the row with info() == Success. n = 3 runs unblocked(), the identity wider than the panel partial_factor().
+// L D L^* is not checked: (L D)(2, 1) = 6M/5 - 3M/10 overflows in the middle of its own evaluation.
+template <typename MatrixType>
+void bunchkaufman_near_max_scale() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  const RealScalar M = (std::numeric_limits<RealScalar>::max)();
+  for (Index n : {Index(3), 2 * internal::bunch_kaufman_blocksize<Scalar>() + 2}) {
+    for (RealScalar s : {RealScalar(1), RealScalar(-1)}) {
+      MatrixType A = MatrixType::Identity(n, n);
+      A(0, 0) = Scalar(M / RealScalar(2));
+      A(1, 1) = Scalar(s * M / RealScalar(2));
+      A(1, 0) = A(0, 1) = Scalar(M);
+      A(2, 1) = A(1, 2) = Scalar(RealScalar(0.9) * M);
+      A(2, 2) = Scalar(0);
+      const VectorType b = A.col(2);
+      VectorType e2 = VectorType::Zero(n);
+      e2(2) = Scalar(1);
+      verify_near_max_scale(BunchKaufman<MatrixType, Lower>(A), b, e2);
+      verify_near_max_scale(BunchKaufman<MatrixType, Upper>(A), b, e2);
+    }
+  }
+}
+
+// Regression: the size constructor must pre-allocate the panel workspace so that a subsequent compute()
+// on a problem of that size performs no heap allocation. n is chosen above the panel width so the
+// blocked path (the one that uses the workspace) runs. (Uses the default stack-allocation limit so the
+// trailing-update GEMM's small blocking buffers stay on the stack rather than the heap.)
+template <typename Scalar>
+void bunchkaufman_no_malloc() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  const Index n = internal::bunch_kaufman_blocksize<Scalar>() + 36;
+  const MatrixType M = MatrixType::Random(n, n);
+  const MatrixType A = M + M.adjoint();
+  BunchKaufman<MatrixType> bk(n);  // pre-allocates m_matrix, m_transpositions, m_subdiag, m_workspace
+  internal::set_is_malloc_allowed(false);
+  bk.compute(A);
+  internal::set_is_malloc_allowed(true);
+  VERIFY(bk.info() == Success);
+}
+
+EIGEN_DECLARE_TEST(bunchkaufman) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(bunchkaufman(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_2(bunchkaufman(Matrix2d()));
+    CALL_SUBTEST_3(bunchkaufman(Matrix3f()));
+    CALL_SUBTEST_4(bunchkaufman(Matrix4d()));
+
+    int s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
+    CALL_SUBTEST_5(bunchkaufman(MatrixXd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
+    CALL_SUBTEST_6(bunchkaufman(MatrixXcd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    // Bounded so that the determinant itself, not just its logarithm, stays in range.
+    s = internal::random<int>(1, 30);
+    CALL_SUBTEST_5(bunchkaufman_determinant<MatrixXd>(s));
+    CALL_SUBTEST_6(bunchkaufman_determinant<MatrixXcd>(s));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    s = internal::random<int>(2, EIGEN_TEST_MAX_SIZE);
+    CALL_SUBTEST_5(bunchkaufman_inertia_and_conditioning<MatrixXd>(s));
+    s = internal::random<int>(2, EIGEN_TEST_MAX_SIZE / 2);
+    CALL_SUBTEST_6(bunchkaufman_inertia_and_conditioning<MatrixXcd>(s));
+
+    CALL_SUBTEST_7(bunchkaufman_small_cases<double>());
+    CALL_SUBTEST_7(bunchkaufman_small_cases<std::complex<double> >());
+    // Singular matrices in both the unblocked (n=8) and blocked (n=100 > blocksize) regimes.
+    CALL_SUBTEST_5(bunchkaufman_singular<double>(8));
+    CALL_SUBTEST_5(bunchkaufman_singular<double>(100));
+    CALL_SUBTEST_6(bunchkaufman_singular<std::complex<double> >(8));
+    CALL_SUBTEST_6(bunchkaufman_singular<std::complex<double> >(100));
+    CALL_SUBTEST_5(bunchkaufman_nan<double>());
+    CALL_SUBTEST_6(bunchkaufman_nan<std::complex<double> >());
+    CALL_SUBTEST_5(bunchkaufman_rank_deficient<double>());
+    CALL_SUBTEST_6(bunchkaufman_rank_deficient<std::complex<double> >());
+  }
+
+  // Empty-matrix edge case.
+  CALL_SUBTEST_5(bunchkaufman(MatrixXd(0, 0)));
+  CALL_SUBTEST_5(bunchkaufman_determinant_empty<MatrixXd>());
+
+  // Subnormal 2x2 block: the determinant underflows, its log and sign do not.
+  CALL_SUBTEST_5(bunchkaufman_determinant_subnormal_block<MatrixXd>());
+  CALL_SUBTEST_6(bunchkaufman_determinant_subnormal_block<MatrixXcd>());
+  CALL_SUBTEST_6(bunchkaufman_determinant_subnormal_block_complex());
+  CALL_SUBTEST_8(bunchkaufman_determinant_subnormal_block<MatrixXf>());
+  CALL_SUBTEST_5(bunchkaufman_inertia_wide_2x2_block());
+
+  // Mixed-scale 2x2 blocks: the block determinants leave the representable range, their product does not.
+  CALL_SUBTEST_5(bunchkaufman_determinant_mixed_scale());
+
+  // Problem-size constructors.
+  CALL_SUBTEST_8(BunchKaufman<MatrixXf>(10));
+  CALL_SUBTEST_8(BunchKaufman<MatrixXcd>(10));
+
+  // Assertion checks on an uninitialized decomposition.
+  CALL_SUBTEST_3(bunchkaufman_verify_assert<Matrix3f>());
+  CALL_SUBTEST_5(bunchkaufman_verify_assert<MatrixXd>());
+  CALL_SUBTEST_6(bunchkaufman_verify_assert<MatrixXcd>());
+
+  // Deterministic blocking / panel-boundary tests (outside g_repeat).
+  CALL_SUBTEST_8(bunchkaufman_blocking_boundary<double>());
+  CALL_SUBTEST_8(bunchkaufman_blocking_boundary<float>());
+  CALL_SUBTEST_8(bunchkaufman_blocking_boundary<std::complex<double> >());
+
+  // Extreme-scale 2x2 pivots: the scaled (det-free) 2x2 formulas must not over/underflow.
+  CALL_SUBTEST_7(bunchkaufman_extreme_scale<double>());
+  CALL_SUBTEST_7(bunchkaufman_extreme_scale<std::complex<double> >());
+  CALL_SUBTEST_5(bunchkaufman_extreme_scale_large<double>(8));
+  CALL_SUBTEST_5(bunchkaufman_extreme_scale_large<double>(100));
+  CALL_SUBTEST_6(bunchkaufman_extreme_scale_large<std::complex<double> >(8));
+  CALL_SUBTEST_6(bunchkaufman_extreme_scale_large<std::complex<double> >(100));
+
+  // Issue #3142: subnormal 2x2 pivot blocks through the unblocked and blocked paths and the D solve.
+  CALL_SUBTEST_5(bunchkaufman_subnormal_2x2_block<MatrixXd>());
+  CALL_SUBTEST_6(bunchkaufman_subnormal_2x2_block<MatrixXcd>());
+  CALL_SUBTEST_8(bunchkaufman_subnormal_2x2_block<MatrixXf>());
+  CALL_SUBTEST_8(bunchkaufman_subnormal_2x2_block<MatrixXcf>());
+  CALL_SUBTEST_5(bunchkaufman_near_max_scale<MatrixXd>());
+  CALL_SUBTEST_6(bunchkaufman_near_max_scale<MatrixXcd>());
+  CALL_SUBTEST_8(bunchkaufman_near_max_scale<MatrixXf>());
+  CALL_SUBTEST_8(bunchkaufman_near_max_scale<MatrixXcf>());
+
+  // No-malloc regression: the size constructor pre-allocates the panel workspace.
+  CALL_SUBTEST_8(bunchkaufman_no_malloc<double>());
+  CALL_SUBTEST_8(bunchkaufman_no_malloc<std::complex<double> >());
+}
diff --git a/test/cache_sizes.cpp b/test/cache_sizes.cpp
new file mode 100644
index 0000000..1880325
--- /dev/null
+++ b/test/cache_sizes.cpp
@@ -0,0 +1,225 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#ifdef EIGEN_CPU_CACHE_SYSFS
+#include <sched.h>
+#include <sys/stat.h>
+#include <cstdlib>
+#include <string>
+#include <vector>
+#endif
+
+void cache_sizes_plausible() {
+  // Whatever the platform reports has to be a plausible data-cache size: a stray unit suffix
+  // would otherwise be read as a handful of bytes and silently shrink every blocking size.
+  std::ptrdiff_t l1 = -1, l2 = -1, l3 = -1, l3_per_cpu = -1;
+  internal::queryCacheSizes(l1, l2, l3, l3_per_cpu);
+  for (std::ptrdiff_t size : {l1, l2, l3, l3_per_cpu})
+    if (size > 0) VERIFY(size >= 1024);
+  // A share is one CPU's slice of one L3 instance, so it can never exceed the reported L3.
+  VERIFY(l3_per_cpu >= 0);
+  if (l3_per_cpu > 0) VERIFY(l3 > 0 && l3_per_cpu <= l3);
+}
+
+#ifdef EIGEN_CPU_CACHE_SYSFS
+
+using internal::CpuCacheTopology;
+
+bool same_topology(const CpuCacheTopology& a, const CpuCacheTopology& b) {
+  return a.l1 == b.l1 && a.l2 == b.l2 && a.l3 == b.l3 && a.l3_per_cpu == b.l3_per_cpu;
+}
+
+CpuCacheTopology topology_of(std::ptrdiff_t l1, std::ptrdiff_t l2, std::ptrdiff_t l3, std::ptrdiff_t l3_per_cpu) {
+  CpuCacheTopology topology;
+  topology.l1 = l1;
+  topology.l2 = l2;
+  topology.l3 = l3;
+  topology.l3_per_cpu = l3_per_cpu;
+  return topology;
+}
+
+void cache_sizes_parsers() {
+  VERIFY(internal::parseCpuCacheSize("64K\n") == 64 * 1024);
+  VERIFY(internal::parseCpuCacheSize("2048K\n") == 2048 * 1024);
+  VERIFY(internal::parseCpuCacheSize("32M\n") == 32 * 1024 * 1024);
+  // A size Eigen cannot make sense of has to read as "unknown", never as a few bytes.
+  VERIFY(internal::parseCpuCacheSize("bogus") == 0);
+  VERIFY(internal::parseCpuCacheSize("0K") == 0);
+  // A bare count is bytes, not kibibytes.
+  VERIFY(internal::parseCpuCacheSize("512\n") == 512);
+
+  VERIFY(internal::parseCpuListCount("0\n") == 1);
+  VERIFY(internal::parseCpuListCount("0-3\n") == 4);
+  VERIFY(internal::parseCpuListCount("0-3,8-11\n") == 8);
+  VERIFY(internal::parseCpuListCount("0,2,4\n") == 3);
+  VERIFY(internal::parseCpuListCount("") == 0);
+  VERIFY(internal::parseCpuListCount("3-0") == 0);
+  VERIFY(internal::parseCpuListCount("0-3\r\n") == 4);
+  // Trailing text means the format is not the one assumed, so the count is not trustworthy:
+  // a small count here would inflate l3_per_cpu rather than leave the share unknown.
+  VERIFY(internal::parseCpuListCount("0-3junk") == 0);
+  VERIFY(internal::parseCpuListCount("0-3 8-11") == 0);
+  VERIFY(internal::parseCpuListCount("0-3,") == 0);
+  VERIFY(internal::parseCpuListCount("0-3,junk") == 0);
+  VERIFY(internal::parseCpuListCount("junk") == 0);
+  // strtol would accept a sign, but no CPU has a negative id, and none has one beyond what a kernel can number.
+  VERIFY(internal::parseCpuListCount("-1") == 0);
+  VERIFY(internal::parseCpuListCount("0-70000") == 0);
+
+  // The ranges are handed over one at a time, and a list that turns out malformed is reported as such even
+  // though its leading ranges were already visited.
+  int ranges = 0, cpus = 0;
+  const auto tally = [&](int first, int last) {
+    ++ranges;
+    cpus += last - first + 1;
+  };
+  VERIFY(internal::parseCpuList("0-3,8,10-11\n", tally));
+  VERIFY(ranges == 3 && cpus == 7);
+  VERIFY(!internal::parseCpuList("0-3,8,10-11junk\n", tally));
+}
+
+// A sysfs tree laid out exactly as Linux publishes it, describing whatever machine a test needs.
+struct SysfsFixture {
+  std::string root;
+  std::vector<std::string> created;
+
+  SysfsFixture() {
+    const char* base = std::getenv("TMPDIR");
+    const std::string pattern = std::string(base != nullptr ? base : "/tmp") + "/eigen-cache-sizes-XXXXXX";
+    std::vector<char> buffer(pattern.begin(), pattern.end());
+    buffer.push_back('\0');
+    if (mkdtemp(buffer.data()) != nullptr) {
+      root = buffer.data();
+      created.push_back(root);
+    }
+  }
+  ~SysfsFixture() {
+    for (auto it = created.rbegin(); it != created.rend(); ++it) std::remove(it->c_str());
+  }
+
+  void directory(const std::string& path) {
+    if (mkdir(path.c_str(), 0700) == 0) created.push_back(path);
+  }
+  void file(const std::string& relative, const char* text) {
+    const std::string path = root + "/" + relative;
+    std::FILE* stream = std::fopen(path.c_str(), "w");
+    VERIFY(stream != nullptr);
+    std::fputs(text, stream);
+    std::fclose(stream);
+    created.push_back(path);
+  }
+  void cpu(int id) {
+    directory(root + "/cpu" + std::to_string(id));
+    directory(root + "/cpu" + std::to_string(id) + "/cache");
+  }
+  void cache(int id, int index, const char* level, const char* type, const char* size, const char* shared) {
+    const std::string dir = "cpu" + std::to_string(id) + "/cache/index" + std::to_string(index);
+    directory(root + "/" + dir);
+    file(dir + "/level", level);
+    file(dir + "/type", type);
+    file(dir + "/size", size);
+    file(dir + "/shared_cpu_list", shared);
+  }
+};
+
+void cache_sizes_fixture_topology() {
+  SysfsFixture fixture;
+  if (fixture.root.empty()) return;
+  const char* const root = fixture.root.c_str();
+
+  // Two big cores (0 and 3) with a 16MB L3 between them, and two little cores (1 and 2) with a 2MB
+  // cluster L3. CPU 3 is online but publishes no cache directory at all, and CPU 2 has no L2, so its
+  // L3 sits at the index the others use for L2.
+  fixture.cpu(0);
+  fixture.cache(0, 0, "1\n", "Data\n", "64K\n", "0\n");
+  fixture.cache(0, 1, "1\n", "Instruction\n", "128K\n", "0\n");
+  fixture.cache(0, 2, "2\n", "Unified\n", "1024K\n", "0\n");
+  fixture.cache(0, 3, "3\n", "Unified\n", "16384K\n", "0,3\n");
+  fixture.cpu(1);
+  fixture.cache(1, 0, "1\n", "Data\n", "32K\n", "1\n");
+  fixture.cache(1, 1, "1\n", "Instruction\n", "32K\n", "1\n");
+  fixture.cache(1, 2, "2\n", "Unified\n", "256K\n", "1\n");
+  fixture.cache(1, 3, "3\n", "Unified\n", "2048K\n", "1-2\n");
+  fixture.cpu(2);
+  fixture.cache(2, 0, "1\n", "Data\n", "32K\n", "2\n");
+  fixture.cache(2, 1, "1\n", "Instruction\n", "32K\n", "2\n");
+  fixture.cache(2, 2, "3\n", "Unified\n", "2048K\n", "1-2\n");
+  fixture.directory(fixture.root + "/cpu3");
+  fixture.file("online", "0-3\n");
+
+  const CpuCacheTopology big = topology_of(64 * 1024, 1024 * 1024, 16384 * 1024, 8192 * 1024);
+  const CpuCacheTopology little = topology_of(32 * 1024, 256 * 1024, 2048 * 1024, 1024 * 1024);
+  const CpuCacheTopology unknown = topology_of(0, 0, 0, 0);
+
+  // Each CPU on its own. The larger instruction cache must not pass for the L1 data cache.
+  VERIFY(same_topology(internal::readCpuCacheTopologySysfs(root, 0), big));
+  VERIFY(same_topology(internal::readCpuCacheTopologySysfs(root, 1), little));
+  VERIFY(
+      same_topology(internal::readCpuCacheTopologySysfs(root, 2), topology_of(32 * 1024, 0, 2048 * 1024, 1024 * 1024)));
+  VERIFY(same_topology(internal::readCpuCacheTopologySysfs(root, 3), unknown));
+
+  // A thread that may land on any CPU has to block for the smallest caches among them.
+  const auto every_cpu = [](int) { return true; };
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, every_cpu), little));
+  // One confined to the big cores sees only their geometry, and a mask that excludes CPU 0 must not carry
+  // CPU 0's geometry along.
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, [](int cpu) { return cpu == 0; }), big));
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, [](int cpu) { return cpu == 0 || cpu == 3; }), big));
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, [](int cpu) { return cpu != 0; }), little));
+  VERIFY(
+      same_topology(internal::queryCpuCacheTopologySysfs(root, [](int cpu) { return cpu == 1 || cpu == 3; }), little));
+  // A CPU that reports nothing, or no CPU at all, leaves the geometry unknown rather than defaulted.
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, [](int cpu) { return cpu == 3; }), unknown));
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, [](int) { return false; }), unknown));
+
+  // An online list that cannot be trusted, or that is missing, means no CPU is known.
+  fixture.file("online", "0-3junk\n");
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, every_cpu), unknown));
+  fixture.file("online", "0-3");
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, every_cpu), unknown));
+  std::remove((fixture.root + "/online").c_str());
+  VERIFY(same_topology(internal::queryCpuCacheTopologySysfs(root, every_cpu), unknown));
+}
+
+void cache_sizes_affinity() {
+  // On a kernel that publishes the topology, Eigen has to pick it up instead of falling back to
+  // its compiled-in defaults. glibc's sysconf answers only on x86, so before the sysfs fallback
+  // this failed on every other Linux architecture.
+  std::ptrdiff_t l1, l2, l3, l3_per_cpu;
+  internal::queryCacheSizes(l1, l2, l3, l3_per_cpu);
+  const CpuCacheTopology mine = internal::queryCpuCacheTopologySysfs();
+  if (mine.l1 > 0) VERIFY(l1 > 0);
+  VERIFY(l3_per_cpu == mine.l3_per_cpu);
+
+  // Confine the thread to every CPU it may use but CPU 0: the detected geometry has to follow the mask.
+  cpu_set_t original;
+  if (sched_getaffinity(0, sizeof(original), &original) != 0) return;
+  if (CPU_COUNT(&original) < 2 || !CPU_ISSET(0, &original)) return;
+  cpu_set_t restricted = original;
+  CPU_CLR(0, &restricted);
+  VERIFY(sched_setaffinity(0, sizeof(restricted), &restricted) == 0);
+  const CpuCacheTopology seen = internal::queryCpuCacheTopologySysfs();
+  const CpuCacheTopology expected = internal::queryCpuCacheTopologySysfs(
+      "/sys/devices/system/cpu", [&restricted](int cpu) { return cpu < CPU_SETSIZE && CPU_ISSET(cpu, &restricted); });
+  VERIFY(sched_setaffinity(0, sizeof(original), &original) == 0);
+  VERIFY(same_topology(seen, expected));
+}
+
+#endif  // EIGEN_CPU_CACHE_SYSFS
+
+EIGEN_DECLARE_TEST(cache_sizes) {
+  CALL_SUBTEST(cache_sizes_plausible());
+#ifdef EIGEN_CPU_CACHE_SYSFS
+  CALL_SUBTEST(cache_sizes_parsers());
+  CALL_SUBTEST(cache_sizes_fixture_topology());
+  CALL_SUBTEST(cache_sizes_affinity());
+#endif
+}
diff --git a/test/cholesky.cpp b/test/cholesky.cpp
index 1c1e18e..d313dae 100644
--- a/test/cholesky.cpp
+++ b/test/cholesky.cpp
@@ -6,21 +6,16 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
+#define EIGEN_RUNTIME_NO_MALLOC
 
 #include "main.h"
 #include <Eigen/Cholesky>
 #include <Eigen/QR>
 #include "solverbase.h"
 
-template <typename MatrixType, int UpLo>
-typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
-  if (m.cols() == 0) return typename MatrixType::RealScalar(0);
-  MatrixType symm = m.template selfadjointView<UpLo>();
-  return symm.cwiseAbs().colwise().sum().maxCoeff();
-}
-
 template <typename MatrixType, template <typename, int> class CholType>
 void test_chol_update(const MatrixType& symm) {
   typedef typename MatrixType::Scalar Scalar;
@@ -51,6 +46,94 @@
   }
 }
 
+// A^-1 from an LLT factorization. The kernels fill one triangle and mirror it, so the result is
+// exactly self-adjoint, and accuracy is checked as the backward error of the corresponding solve.
+template <typename MatrixType, int UpLo>
+void check_llt_inverse(const MatrixType& symm) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using DynMatrixType = Matrix<Scalar, Dynamic, Dynamic>;
+  using DynVectorType = Matrix<Scalar, Dynamic, 1>;
+  const Index n = symm.rows();
+
+  const MatrixType tri = symm.template triangularView<UpLo>();
+  LLT<MatrixType, UpLo> llt(tri);
+  VERIFY(llt.info() == Success);
+
+  const MatrixType inv = llt.inverse();
+  VERIFY_IS_EQUAL(inv.rows(), n);
+  VERIFY_IS_EQUAL(inv.cols(), n);
+  VERIFY_IS_CWISE_EQUAL(inv, inv.adjoint());
+
+  // |A X - I| <= c*n*eps*|A|*|X| for a Cholesky solve (Higham, Accuracy and Stability of Numerical
+  // Algorithms, 2nd ed., Thm 10.4). The factor 16 absorbs c and the entrywise-to-norm step; the
+  // largest ratio measured over this family is 2, at n = 1.
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  const RealScalar residual_bound = RealScalar(16 * n) * eps * symm.norm() * inv.norm();
+  VERIFY((numext::isfinite)(residual_bound));
+  VERIFY((symm * inv - MatrixType::Identity(n, n)).norm() <= residual_bound);
+
+  // The same answer as solving against an explicit identity, to within the forward error, which the
+  // residual bound multiplied by cond(A) <= |A|*|X| bounds in turn.
+  const MatrixType reference = llt.solve(MatrixType::Identity(n, n));
+  const RealScalar forward_bound = residual_bound * inv.norm();
+  VERIFY((numext::isfinite)(forward_bound));
+  VERIFY((inv - reference).norm() <= forward_bound);
+
+  // The destination need not be a plain object.
+  DynMatrixType host = DynMatrixType::Random(n + 2, n + 2);
+  host.bottomRightCorner(n, n) = llt.inverse();
+  VERIFY((symm * host.bottomRightCorner(n, n) - MatrixType::Identity(n, n)).norm() <= residual_bound);
+
+  // Nor need its inner stride be known at compile time. extract_data() is null for such a destination,
+  // which leaves the alias with the factor unknown rather than excluded, so this takes POTRI at every
+  // size, and the gaps between the mapped coefficients hold the kernels to the storage they were given.
+  using StrideType = Stride<Dynamic, Dynamic>;
+  const Index inner = 2, outer = 2 * n + 3;
+  const Index buffer_size = numext::maxi(Index(1), (n - 1) * (outer + inner) + 1);
+  DynVectorType buffer = DynVectorType::Random(buffer_size);
+  const DynVectorType before = buffer;
+  Map<MatrixType, 0, StrideType> strided(buffer.data(), n, n, StrideType(outer, inner));
+  strided = llt.inverse();
+  VERIFY_IS_CWISE_EQUAL(strided, strided.adjoint());
+  VERIFY((symm * strided - MatrixType::Identity(n, n)).norm() <= residual_bound);
+  std::vector<bool> mapped(buffer_size, false);
+  for (Index j = 0; j < n; ++j)
+    for (Index i = 0; i < n; ++i) mapped[static_cast<std::size_t>(&strided.coeffRef(i, j) - buffer.data())] = true;
+  for (Index k = 0; k < buffer_size; ++k)
+    if (!mapped[k]) VERIFY_IS_EQUAL(buffer[k], before[k]);
+
+  // An in-place decomposition may overwrite its own factor, whichever arm the size selects: the solve
+  // fallback would read the factor after setIdentity() had destroyed it, so the alias takes POTRI.
+  MatrixType storage = tri;
+  LLT<Ref<MatrixType>, UpLo> inplace(storage);
+  VERIFY(inplace.info() == Success);
+  storage = inplace.inverse();
+  VERIFY_IS_CWISE_EQUAL(storage, storage.adjoint());
+  VERIFY((symm * storage - MatrixType::Identity(n, n)).norm() <= residual_bound);
+}
+
+// LLT::inverse() dispatches on EIGEN_LLT_INVERSE_POTRI_THRESHOLD, so straddle it deterministically:
+// the random sizes above reach only whichever side of it EIGEN_TEST_MAX_SIZE happens to allow. Only
+// real scalars are thresholded, so only they have a boundary to straddle.
+template <typename Scalar>
+void llt_inverse_threshold_boundary() {
+  static_assert(!NumTraits<Scalar>::IsComplex, "only real scalars are thresholded");
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic>;
+
+  const Index threshold = EIGEN_LLT_INVERSE_POTRI_THRESHOLD;
+  const Index sizes[] = {threshold - 1, threshold, threshold + 1};
+  for (Index n : sizes) {
+    MatrixType r = MatrixType::Random(n, n);
+    MatrixType symm = r * r.adjoint();
+    symm.diagonal().array() += RealScalar(n);
+
+    check_llt_inverse<MatrixType, Lower>(symm);
+    check_llt_inverse<MatrixType, Upper>(symm);
+  }
+}
+
 template <typename MatrixType>
 void cholesky(const MatrixType& m) {
   /* this test covers the following files:
@@ -75,8 +158,8 @@
   }
 
   {
-    STATIC_CHECK((internal::is_same<typename LLT<MatrixType, Lower>::StorageIndex, int>::value));
-    STATIC_CHECK((internal::is_same<typename LLT<MatrixType, Upper>::StorageIndex, int>::value));
+    STATIC_CHECK((std::is_same<typename LLT<MatrixType, Lower>::StorageIndex, int>::value));
+    STATIC_CHECK((std::is_same<typename LLT<MatrixType, Upper>::StorageIndex, int>::value));
 
     SquareMatrixType symmUp = symm.template triangularView<Upper>();
     SquareMatrixType symmLo = symm.template triangularView<Lower>();
@@ -111,6 +194,9 @@
     rcond_est = cholup.rcond();
     VERIFY(rcond_est >= rcond / 10 && rcond_est <= rcond * 10);
 
+    check_llt_inverse<SquareMatrixType, Lower>(symm);
+    check_llt_inverse<SquareMatrixType, Upper>(symm);
+
     MatrixType neg = -symmLo;
     chollo.compute(neg);
     VERIFY(neg.size() == 0 || chollo.info() == NumericalIssue);
@@ -138,8 +224,8 @@
 
   // LDLT
   {
-    STATIC_CHECK((internal::is_same<typename LDLT<MatrixType, Lower>::StorageIndex, int>::value));
-    STATIC_CHECK((internal::is_same<typename LDLT<MatrixType, Upper>::StorageIndex, int>::value));
+    STATIC_CHECK((std::is_same<typename LDLT<MatrixType, Lower>::StorageIndex, int>::value));
+    STATIC_CHECK((std::is_same<typename LDLT<MatrixType, Upper>::StorageIndex, int>::value));
 
     int sign = internal::random<int>() % 2 ? 1 : -1;
 
@@ -437,6 +523,294 @@
   }
 }
 
+// Accumulates I + sum_k w_k w_k^* out of rank-1 updates alone, which is the path rankUpdate() takes while the
+// decomposition holds no factorization, and checks the reported status against the factorization it produced.
+template <typename MatrixType, int UpLo>
+void check_ldlt_rankupdate_from_scratch(LDLT<MatrixType, UpLo>& ldlt, Index size) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using VectorType = Matrix<Scalar, MatrixType::RowsAtCompileTime, 1>;
+
+  // Build up the identity first so that the accumulated matrix is well conditioned whatever the random terms are.
+  MatrixType ref = MatrixType::Identity(size, size);
+  for (Index k = 0; k < size; ++k) ldlt.rankUpdate(VectorType::Unit(size, k), RealScalar(1));
+
+  for (int k = 0; k < 3; ++k) {
+    VectorType w = VectorType::Random(size);
+    ldlt.rankUpdate(w, RealScalar(1));
+    ref += w * w.adjoint();
+  }
+
+  VERIFY(ldlt.info() == Success);
+  // Success has to be earned: check that the factorization really is one, so that reporting Success unconditionally
+  // would not pass either.
+  VERIFY_IS_APPROX(ref, ldlt.reconstructedMatrix());
+  VectorType vecB = VectorType::Random(size);
+  VectorType vecX = ldlt.solve(vecB);
+  VERIFY_IS_APPROX(ref * vecX, vecB);
+}
+
+// LDLT::rankUpdate() takes one of two paths: it updates the factorization the decomposition already holds, or, when
+// there is none, it builds one from scratch. The from-scratch path left the status untouched, so info() reported
+// whatever was left over -- InvalidInput from construction, or a failure from an earlier compute() -- for a
+// factorization that was in fact sound. Updating an existing factorization keeps a failure already reported for it.
+template <typename MatrixType>
+void cholesky_ldlt_rankupdate_info(const MatrixType& m) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using VectorType = Matrix<Scalar, MatrixType::RowsAtCompileTime, 1>;
+
+  const Index size = m.rows();
+  eigen_assert(size >= 2);
+
+  // A zero diagonal with non-zero off-diagonal entries makes the first pivot invalid while the matrix is not: this
+  // is the 2x2 failure case of cholesky_faillure_cases() at size `size`.
+  const MatrixType indefinite = MatrixType::Ones(size, size) - MatrixType::Identity(size, size);
+
+  // The decomposition has never factored anything, so its status is the constructor's InvalidInput.
+  {
+    LDLT<MatrixType, Lower> ldltlo(size);
+    check_ldlt_rankupdate_from_scratch(ldltlo, size);
+
+    LDLT<MatrixType, Upper> ldltup(size);
+    check_ldlt_rankupdate_from_scratch(ldltup, size);
+  }
+
+  // The decomposition is reused after a compute() that failed, and setZero() discards that factorization, so the
+  // stale failure must not be reported for the one the rank updates build.
+  {
+    LDLT<MatrixType, Lower> ldltlo(indefinite);
+    VERIFY(ldltlo.info() == NumericalIssue);
+    ldltlo.setZero();
+    check_ldlt_rankupdate_from_scratch(ldltlo, size);
+
+    LDLT<MatrixType, Upper> ldltup(indefinite);
+    VERIFY(ldltup.info() == NumericalIssue);
+    ldltup.setZero();
+    check_ldlt_rankupdate_from_scratch(ldltup, size);
+  }
+
+  // Without setZero() the update applies to the failed factorization, whose status stands.
+  {
+    VectorType vec = VectorType::Random(size);
+
+    LDLT<MatrixType, Lower> ldltlo(indefinite);
+    VERIFY(ldltlo.info() == NumericalIssue);
+    ldltlo.rankUpdate(vec, RealScalar(1));
+    VERIFY(ldltlo.info() == NumericalIssue);
+
+    LDLT<MatrixType, Upper> ldltup(indefinite);
+    VERIFY(ldltup.info() == NumericalIssue);
+    ldltup.rankUpdate(vec, RealScalar(1));
+    VERIFY(ldltup.info() == NumericalIssue);
+  }
+}
+
+// Applies a single rank update that has to succeed, and checks the factorization it left behind rather than the
+// reported status alone, so that reporting Success unconditionally would not pass either.
+template <typename MatrixType, int UpLo, typename VectorType>
+void check_ldlt_rankupdate(LDLT<MatrixType, UpLo>& ldlt, const VectorType& w,
+                           const typename MatrixType::RealScalar& sigma, const MatrixType& ref) {
+  ldlt.rankUpdate(w, sigma);
+  VERIFY(ldlt.info() == Success);
+  VERIFY_IS_APPROX(ref, ldlt.reconstructedMatrix());
+}
+
+// A component of w that is exactly zero contributes nothing, but the update used to compute that contribution as a
+// division whose denominator can be zero at the same position: the pivot is zero all along the from-scratch path, and
+// the running alpha reaches zero when a downdate cancels the matrix exactly. The resulting 0/0 either landed straight
+// in the factorization or reached the low-rank termination, which read it as a signal to abandon the rest of the
+// update. The update has to survive a zero in any position, including the first.
+template <typename MatrixType>
+void cholesky_ldlt_rankupdate_zero_components(const MatrixType& m) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using VectorType = Matrix<Scalar, MatrixType::RowsAtCompileTime, 1>;
+
+  const Index size = m.rows();
+  const MatrixType identity = MatrixType::Identity(size, size);
+
+  for (Index zero_at = 0; zero_at < size; ++zero_at) {
+    VectorType w = VectorType::Random(size);
+    w(zero_at) = Scalar(0);
+    const MatrixType ref = w * w.adjoint();
+
+    LDLT<MatrixType, Lower> ldltlo(size);
+    check_ldlt_rankupdate(ldltlo, w, RealScalar(1), ref);
+
+    LDLT<MatrixType, Upper> ldltup(size);
+    check_ldlt_rankupdate(ldltup, w, RealScalar(1), ref);
+  }
+
+  // Consecutive zeros have to be skipped one after another, not collapse the update at the first of them.
+  {
+    VectorType w = VectorType::Random(size);
+    w.head(size / 2).setZero();
+    const MatrixType ref = w * w.adjoint();
+
+    LDLT<MatrixType, Lower> ldltlo(size);
+    check_ldlt_rankupdate(ldltlo, w, RealScalar(1), ref);
+
+    LDLT<MatrixType, Upper> ldltup(size);
+    check_ldlt_rankupdate(ldltup, w, RealScalar(1), ref);
+  }
+
+  // The hazard is not confined to the from-scratch path: compute() accepts a rank-deficient matrix, and a zero of w
+  // meeting one of its zero pivots is the same 0/0. An existing factorization whose pivots are all non-zero, such as
+  // the identity, cannot reach it -- the zero of w always meets a non-zero denominator there.
+  if (size >= 3) {
+    MatrixType rank_deficient = MatrixType::Zero(size, size);
+    rank_deficient(0, 0) = Scalar(1);
+
+    // Leave a non-zero component after the zeroed one, whose contribution the 0/0 used to discard.
+    for (Index zero_at = 1; zero_at + 1 < size; ++zero_at) {
+      VectorType w = VectorType::Random(size);
+      w(zero_at) = Scalar(0);
+      const MatrixType ref = rank_deficient + w * w.adjoint();
+
+      LDLT<MatrixType, Lower> ldlt(rank_deficient);
+      VERIFY(ldlt.info() == Success);
+      check_ldlt_rankupdate(ldlt, w, RealScalar(1), ref);
+    }
+  }
+
+  // Downdating the identity by one of its own basis directions drives alpha to exactly zero, so every later position
+  // -- where w is zero -- met a zero denominator on an ordinary, fully initialized factorization. The factorization
+  // came back full of NaN, and info() still reported Success.
+  for (Index k = 0; k < size; ++k) {
+    const VectorType w = VectorType::Unit(size, k);
+    const MatrixType ref = identity - w * w.adjoint();
+
+    LDLT<MatrixType, Lower> ldltlo(identity);
+    check_ldlt_rankupdate(ldltlo, w, RealScalar(-1), ref);
+
+    LDLT<MatrixType, Upper> ldltup(identity);
+    check_ldlt_rankupdate(ldltup, w, RealScalar(-1), ref);
+  }
+}
+
+// A = Q D Q^*, with Q unitary and D real, is Hermitian with det(A) = prod(D_ii).
+// Drawing the |D_ii| from an annulus keeps A well conditioned and log|det(A)| away from zero.
+template <typename MatrixType>
+void cholesky_determinant(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+
+  MatrixType q = MatrixType::Random(size, size).householderQr().householderQ();
+  RealVectorType d(size);
+  for (Index i = 0; i < size; ++i) d(i) = internal::random<RealScalar>(RealScalar(1.2), RealScalar(2.8));
+
+  const RealScalar absdet = d.prod();
+  const RealScalar logabsdet = d.array().log().sum();
+  MatrixType spd = q * d.template cast<Scalar>().asDiagonal() * q.adjoint();
+
+  LLT<MatrixType, Lower> lltlo(spd);
+  VERIFY(lltlo.info() == Success);
+  check_determinant(lltlo, Scalar(absdet), logabsdet);
+
+  LLT<MatrixType, Upper> lltup(spd);
+  VERIFY(lltup.info() == Success);
+  check_determinant(lltup, Scalar(absdet), logabsdet);
+
+  // Negating D leaves |det(A)| alone and makes A negative definite, so det(A) picks up a factor (-1)^n.
+  // LDLT's D is purely diagonal and so does not cover the indefinite case; BunchKaufman does, and
+  // test/bunchkaufman.cpp checks the same identities there.
+  d = -d;
+  const RealScalar det = d.prod();
+  const MatrixType negdef = q * d.template cast<Scalar>().asDiagonal() * q.adjoint();
+
+  LDLT<MatrixType, Lower> ldltlo(negdef);
+  VERIFY(ldltlo.info() == Success);
+  check_determinant(ldltlo, Scalar(det), logabsdet);
+
+  LDLT<MatrixType, Upper> ldltup(negdef);
+  VERIFY(ldltup.info() == Success);
+  check_determinant(ldltup, Scalar(det), logabsdet);
+}
+
+// The determinant of an empty matrix is the empty product, 1.
+template <typename MatrixType>
+void cholesky_determinant_empty() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  MatrixType empty(0, 0);
+
+  LLT<MatrixType> llt(empty);
+  VERIFY_IS_EQUAL(llt.determinant(), Scalar(1));
+  VERIFY_IS_EQUAL(llt.absDeterminant(), RealScalar(1));
+  VERIFY_IS_EQUAL(llt.logAbsDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(llt.signDeterminant(), Scalar(1));
+
+  LDLT<MatrixType> ldlt(empty);
+  VERIFY_IS_EQUAL(ldlt.determinant(), Scalar(1));
+  VERIFY_IS_EQUAL(ldlt.absDeterminant(), RealScalar(1));
+  VERIFY_IS_EQUAL(ldlt.logAbsDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(ldlt.signDeterminant(), Scalar(1));
+}
+
+// logAbsDeterminant() exists to survive the range where the determinant itself does not: with n = 200 and
+// a diagonal of 10^4, det = 10^800 overflows every supported float type while log|det| = 800 log 10 does not.
+template <typename MatrixType>
+void cholesky_determinant_overflow() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  const Index size = 200;
+  for (bool overflow : {true, false}) {
+    const RealScalar scale = overflow ? RealScalar(1e4) : RealScalar(1e-4);
+    const MatrixType a = MatrixType::Identity(size, size) * Scalar(scale);
+    const RealScalar logabsdet = RealScalar(size) * numext::log(scale);
+
+    LLT<MatrixType> llt(a);
+    VERIFY(llt.info() == Success);
+    VERIFY(determinant_out_of_range(llt.absDeterminant(), overflow));
+    VERIFY_IS_APPROX(llt.logAbsDeterminant(), logabsdet);
+    VERIFY_IS_EQUAL(llt.signDeterminant(), Scalar(1));
+
+    LDLT<MatrixType> ldlt(a);
+    VERIFY(ldlt.info() == Success);
+    VERIFY(determinant_out_of_range(ldlt.absDeterminant(), overflow));
+    VERIFY_IS_APPROX(ldlt.logAbsDeterminant(), logabsdet);
+    VERIFY_IS_EQUAL(ldlt.signDeterminant(), Scalar(1));
+  }
+}
+
+// A failed factorization does not represent the input, so the four accessors assert rather than answer from
+// it: for [[0,1],[1,0]] LDLT reports NumericalIssue with D = 0, where det = -1. m_isInitialized alone does
+// not catch that, since compute() sets it either way.
+template <typename MatrixType>
+void cholesky_determinant_failed_factorization(Index size) {
+  eigen_assert(size >= 2);
+
+  // A zero diagonal with non-zero off-diagonal entries makes the first pivot invalid while the matrix is
+  // not; both factorizations give up on it.
+  const MatrixType indefinite = MatrixType::Ones(size, size) - MatrixType::Identity(size, size);
+
+  LDLT<MatrixType, Lower> ldltlo(indefinite);
+  VERIFY(ldltlo.info() == NumericalIssue);
+  VERIFY(!ldltlo.reconstructedMatrix().isApprox(indefinite));
+  VERIFY_RAISES_ASSERT(ldltlo.determinant())
+  VERIFY_RAISES_ASSERT(ldltlo.absDeterminant())
+  VERIFY_RAISES_ASSERT(ldltlo.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(ldltlo.signDeterminant())
+
+  LDLT<MatrixType, Upper> ldltup(indefinite);
+  VERIFY(ldltup.info() == NumericalIssue);
+  VERIFY_RAISES_ASSERT(ldltup.determinant())
+  VERIFY_RAISES_ASSERT(ldltup.absDeterminant())
+  VERIFY_RAISES_ASSERT(ldltup.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(ldltup.signDeterminant())
+
+  LLT<MatrixType, Lower> lltlo(indefinite);
+  VERIFY(lltlo.info() == NumericalIssue);
+  VERIFY_RAISES_ASSERT(lltlo.determinant())
+  VERIFY_RAISES_ASSERT(lltlo.absDeterminant())
+  VERIFY_RAISES_ASSERT(lltlo.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(lltlo.signDeterminant())
+}
+
 template <typename MatrixType>
 void cholesky_verify_assert() {
   MatrixType tmp;
@@ -448,6 +822,10 @@
   VERIFY_RAISES_ASSERT(llt.transpose().solve(tmp))
   VERIFY_RAISES_ASSERT(llt.adjoint().solve(tmp))
   VERIFY_RAISES_ASSERT(llt.solveInPlace(tmp))
+  VERIFY_RAISES_ASSERT(llt.determinant())
+  VERIFY_RAISES_ASSERT(llt.absDeterminant())
+  VERIFY_RAISES_ASSERT(llt.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(llt.signDeterminant())
 
   LDLT<MatrixType> ldlt;
   VERIFY_RAISES_ASSERT(ldlt.matrixL())
@@ -459,28 +837,152 @@
   VERIFY_RAISES_ASSERT(ldlt.transpose().solve(tmp))
   VERIFY_RAISES_ASSERT(ldlt.adjoint().solve(tmp))
   VERIFY_RAISES_ASSERT(ldlt.solveInPlace(tmp))
+  VERIFY_RAISES_ASSERT(ldlt.determinant())
+  VERIFY_RAISES_ASSERT(ldlt.absDeterminant())
+  VERIFY_RAISES_ASSERT(ldlt.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(ldlt.signDeterminant())
+}
+
+// Test Cholesky decomposition at blocking and vectorization boundaries.
+// LLT uses blocks of size max(8, min(size/8 rounded to 16, 128)).
+// Sizes near these boundaries exercise the transition between full
+// blocked and unblocked paths, including triangular solve boundaries.
+template <typename Scalar>
+void cholesky_blocking_boundary() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+
+  const Index PS = internal::packet_traits<Scalar>::size;
+  const Index sizes[] = {1, 2, 3,  PS - 1, PS, PS + 1, 2 * PS - 1, 2 * PS, 2 * PS + 1, 4 * PS, 4 * PS + 1, 7,
+                         8, 9, 15, 16,     17, 31,     32,         33,     63,         64,     65};
+  for (Index si = 0; si < Index(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    Index n = sizes[si];
+    if (n < 1) continue;
+
+    // Create a symmetric positive definite matrix: A = R'*R + n*I
+    MatrixType R = MatrixType::Random(n, n);
+    MatrixType m = R.adjoint() * R;
+    m.diagonal().array() += RealScalar(n);
+
+    // LLT
+    LLT<MatrixType> llt(m);
+    VERIFY(llt.info() == Success);
+    VERIFY_IS_APPROX(m, llt.reconstructedMatrix());
+    VectorType rhs = VectorType::Random(n);
+    VectorType x = llt.solve(rhs);
+    VERIFY_IS_APPROX(m * x, rhs);
+
+    // LDLT
+    LDLT<MatrixType> ldlt(m);
+    VERIFY(ldlt.info() == Success);
+    VERIFY_IS_APPROX(m, ldlt.reconstructedMatrix());
+    x = ldlt.solve(rhs);
+    VERIFY_IS_APPROX(m * x, rhs);
+  }
+}
+
+// Test Cholesky with RowMajor storage at blocking boundaries.
+template <typename Scalar>
+void cholesky_rowmajor_boundary() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMatrixType;
+
+  const Index sizes[] = {7, 8, 9, 15, 16, 17, 31, 32, 33};
+  for (Index si = 0; si < Index(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    Index n = sizes[si];
+    RowMatrixType R = RowMatrixType::Random(n, n);
+    RowMatrixType m = R.adjoint() * R;
+    m.diagonal().array() += RealScalar(n);
+
+    LLT<RowMatrixType> llt(m);
+    VERIFY(llt.info() == Success);
+    VERIFY_IS_APPROX(m, llt.reconstructedMatrix());
+
+    LDLT<RowMatrixType> ldlt(m);
+    VERIFY(ldlt.info() == Success);
+    VERIFY_IS_APPROX(m, ldlt.reconstructedMatrix());
+  }
+}
+
+// Preallocated decompositions of dynamic-size matrices stay allocation-free, including the 1-norm
+// they take for rcond(), whose workspace comes from the stack.
+template <typename Scalar>
+void cholesky_dynamic_preallocated_no_malloc() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  Index size = 8;
+  MatrixType A = MatrixType::Random(size, size);
+  MatrixType spd = A * A.adjoint() + MatrixType::Identity(size, size) * Scalar(size);
+  LLT<MatrixType> llt(size);
+  LDLT<MatrixType> ldlt(size);
+  internal::set_is_malloc_allowed(false);
+  llt.compute(spd);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+  ldlt.compute(spd);
+  VERIFY_IS_EQUAL(ldlt.info(), Success);
+  VERIFY(spd.template selfadjointView<Lower>().l1Norm() > 0);
+  internal::set_is_malloc_allowed(true);
+  VERIFY(llt.rcond() > 0);
 }
 
 EIGEN_DECLARE_TEST(cholesky) {
   int s = 0;
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(cholesky(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_1(cholesky_dynamic_preallocated_no_malloc<double>());
+    CALL_SUBTEST_1(cholesky_dynamic_preallocated_no_malloc<std::complex<double> >());
     CALL_SUBTEST_3(cholesky(Matrix2d()));
     CALL_SUBTEST_3(cholesky_bug241(Matrix2d()));
     CALL_SUBTEST_3(cholesky_definiteness(Matrix2d()));
     CALL_SUBTEST_4(cholesky(Matrix3f()));
     CALL_SUBTEST_5(cholesky(Matrix4d()));
 
+    CALL_SUBTEST_3(cholesky_ldlt_rankupdate_info(Matrix2d()));
+    CALL_SUBTEST_4(cholesky_ldlt_rankupdate_info(Matrix3f()));
+    CALL_SUBTEST_5(cholesky_ldlt_rankupdate_info(Matrix4d()));
+
+    CALL_SUBTEST_1(cholesky_ldlt_rankupdate_zero_components(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_3(cholesky_ldlt_rankupdate_zero_components(Matrix2d()));
+    CALL_SUBTEST_4(cholesky_ldlt_rankupdate_zero_components(Matrix3f()));
+    CALL_SUBTEST_5(cholesky_ldlt_rankupdate_zero_components(Matrix4d()));
+
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
     CALL_SUBTEST_2(cholesky(MatrixXd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
     CALL_SUBTEST_6(cholesky_cplx(MatrixXcd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    // cholesky_ldlt_rankupdate_info() needs at least two rows for its NumericalIssue case.
+    s = internal::random<int>(2, EIGEN_TEST_MAX_SIZE / 4);
+    CALL_SUBTEST_2(cholesky_ldlt_rankupdate_info(MatrixXd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    s = internal::random<int>(2, EIGEN_TEST_MAX_SIZE / 8);
+    CALL_SUBTEST_6(cholesky_ldlt_rankupdate_info(MatrixXcd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    // Quadratic in the size, since every position of the zero is tried in turn.
+    s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 16);
+    CALL_SUBTEST_2(cholesky_ldlt_rankupdate_zero_components(MatrixXd(s, s)));
+    CALL_SUBTEST_6(cholesky_ldlt_rankupdate_zero_components(MatrixXcd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    // Bounded so that the determinant itself, not just its logarithm, stays in range.
+    s = internal::random<int>(1, 30);
+    CALL_SUBTEST_2(cholesky_determinant<MatrixXd>(s));
+    CALL_SUBTEST_8(cholesky_determinant<MatrixXf>(s));
+    CALL_SUBTEST_6(cholesky_determinant<MatrixXcd>(s));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
   // empty matrix, regression test for Bug 785:
   CALL_SUBTEST_2(cholesky(MatrixXd(0, 0)));
+  CALL_SUBTEST_2(cholesky_determinant_empty<MatrixXd>());
+  CALL_SUBTEST_8(cholesky_determinant_overflow<MatrixXf>());
+  CALL_SUBTEST_3(cholesky_determinant_failed_factorization<Matrix2d>(2));
+  CALL_SUBTEST_2(cholesky_determinant_failed_factorization<MatrixXd>(internal::random<int>(2, 20)));
+  CALL_SUBTEST_6(cholesky_determinant_failed_factorization<MatrixXcd>(internal::random<int>(2, 20)));
 
   // This does not work yet:
   // CALL_SUBTEST_2( cholesky(Matrix<double,0,0>()) );
@@ -496,5 +998,14 @@
 
   CALL_SUBTEST_2(cholesky_faillure_cases<void>());
 
-  TEST_SET_BUT_UNUSED_VARIABLE(nb_temporaries)
+  // Blocking and vectorization boundary tests (deterministic, outside g_repeat).
+  CALL_SUBTEST_2(cholesky_blocking_boundary<double>());
+  CALL_SUBTEST_8(cholesky_blocking_boundary<float>());
+  CALL_SUBTEST_6(cholesky_blocking_boundary<std::complex<double> >());
+  CALL_SUBTEST_2(cholesky_rowmajor_boundary<double>());
+  CALL_SUBTEST_8(cholesky_rowmajor_boundary<float>());
+  CALL_SUBTEST_2(llt_inverse_threshold_boundary<double>());
+  CALL_SUBTEST_8(llt_inverse_threshold_boundary<float>());
+
+  TEST_SET_BUT_UNUSED_VARIABLE(nb_temporaries);
 }
diff --git a/test/cholmod_support.cpp b/test/cholmod_support.cpp
index 0666749..3317a0a 100644
--- a/test/cholmod_support.cpp
+++ b/test/cholmod_support.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #include "sparse_solver.h"
@@ -76,6 +77,4 @@
   CALL_SUBTEST_21((test_cholmod_T<std::complex<double>, ColMajor, int>()));
   CALL_SUBTEST_22((test_cholmod_T<std::complex<double>, ColMajor, long>()));
   // TODO complex row-major matrices do not work at the moment:
-  // CALL_SUBTEST_23( (test_cholmod_T<std::complex<double>, RowMajor, int >()) );
-  // CALL_SUBTEST_24( (test_cholmod_T<std::complex<double>, RowMajor, long>()) );
 }
diff --git a/test/clz.cpp b/test/clz.cpp
index b56d328..b032617 100644
--- a/test/clz.cpp
+++ b/test/clz.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -32,8 +33,20 @@
 }
 
 template <typename T>
+int ref_popcount(T val) {
+  constexpr int num_bits = sizeof(T) * CHAR_BIT;
+  T lsb_mask = T(1);
+  int n = 0;
+  for (int i = 0; i < num_bits; ++i) {
+    n += (val & lsb_mask) != 0;
+    val >>= 1;
+  }
+  return n;
+}
+
+template <typename T>
 void test_clz_ctz() {
-  T step = sizeof(T) <= 2 ? 1 : (Eigen::NumTraits<T>::highest() / (T(1) << 16));
+  T step = sizeof(T) <= 2 ? T(1) : (Eigen::NumTraits<T>::highest() / (T(1) << 16));
   T iters = Eigen::NumTraits<T>::highest() / step;
   for (T i = 0; i < iters; ++i) {
     T val = i * step;
@@ -44,7 +57,16 @@
     int expected_ctz = ref_ctz(val);
     int actual_ctz = Eigen::internal::ctz(val);
     VERIFY(expected_ctz == actual_ctz);
+
+    int expected_popcount = ref_popcount(val);
+    int actual_popcount = Eigen::internal::popcount(val);
+    VERIFY(expected_popcount == actual_popcount);
   }
+
+  // The loop above stops one step short of `NumTraits<T>::highest()`; check extrema
+  // explicitly for `popcount`.
+  VERIFY(Eigen::internal::popcount(T(0)) == 0);
+  VERIFY(Eigen::internal::popcount(Eigen::NumTraits<T>::highest()) == int(sizeof(T) * CHAR_BIT));
 }
 
 template <typename T>
@@ -58,6 +80,10 @@
     int expected_ctz = ref_ctz(val);
     int actual_ctz = Eigen::internal::ctz(val);
     VERIFY(expected_ctz == actual_ctz);
+
+    int expected_popcount = ref_popcount(val);
+    int actual_popcount = Eigen::internal::popcount(val);
+    VERIFY(expected_popcount == actual_popcount);
   }
 }
 
diff --git a/test/cmake_project_version.cmake b/test/cmake_project_version.cmake
new file mode 100644
index 0000000..68ad5bf
--- /dev/null
+++ b/test/cmake_project_version.cmake
@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Checks the variables that project(Eigen3 VERSION ...) is responsible for
+# populating. Their values as observed during Eigen's own configure are baked
+# into the test command, so a variable that project() left unset arrives here as
+# an empty string rather than as an undefined one.
+
+if(NOT DEFINED EIGEN_EXPECTED_VERSION OR EIGEN_EXPECTED_VERSION STREQUAL "")
+  message(FATAL_ERROR "EIGEN_EXPECTED_VERSION was not passed to this script.")
+endif()
+
+set(names PROJECT_VERSION Eigen3_VERSION)
+# CMAKE_PROJECT_VERSION belongs to the outermost project, which is Eigen3 only
+# when Eigen is not being consumed as a sub-project.
+if(EIGEN_IS_TOP_LEVEL)
+  list(APPEND names CMAKE_PROJECT_VERSION)
+endif()
+
+foreach(name IN LISTS names)
+  if(NOT "${OBSERVED_${name}}" STREQUAL "${EIGEN_EXPECTED_VERSION}")
+    message(FATAL_ERROR "${name} was \"${OBSERVED_${name}}\", expected "
+                        "\"${EIGEN_EXPECTED_VERSION}\": the top-level project() call "
+                        "must declare VERSION.")
+  endif()
+endforeach()
diff --git a/test/commainitializer.cpp b/test/commainitializer.cpp
index 771ab6f..e0ae722 100644
--- a/test/commainitializer.cpp
+++ b/test/commainitializer.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -72,9 +73,7 @@
 
   VERIFY_RAISES_ASSERT((m3 << 1, 2, 3, 4, 5, 6, 7, 8));
 
-#ifndef _MSC_VER
   VERIFY_RAISES_ASSERT((m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-#endif
 
   double data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   Matrix3d ref = Map<Matrix<double, 3, 3, RowMajor> >(data);
diff --git a/test/complex_components.cpp b/test/complex_components.cpp
new file mode 100644
index 0000000..c6bef59
--- /dev/null
+++ b/test/complex_components.cpp
@@ -0,0 +1,177 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/Core>
+
+// Component access must not assume that a user-defined complex scalar has std::complex's layout.
+struct PaddedComplex : std::complex<double> {
+  using std::complex<double>::complex;
+  double padding = 123;
+};
+
+template <>
+struct Eigen::NumTraits<PaddedComplex> : Eigen::NumTraits<std::complex<double>> {};
+
+template <typename Derived>
+void check_component(const DenseBase<Derived>& component) {
+  using Real = typename Derived::Scalar;
+  Matrix<Real, Dynamic, Dynamic, Derived::IsRowMajor ? RowMajor : ColMajor> copy = component;
+  Real sum = 0, minimum = component(0, 0), maximum = minimum, abs_maximum = numext::abs(minimum);
+  for (Index col = 0; col < component.cols(); ++col) {
+    for (Index row = 0; row < component.rows(); ++row) {
+      const Real value = component(row, col);
+      VERIFY_IS_EQUAL(copy(row, col), value);
+      sum += value;
+      if (value < minimum) minimum = value;
+      if (value > maximum) maximum = value;
+      if (numext::abs(value) > abs_maximum) abs_maximum = numext::abs(value);
+    }
+  }
+  VERIFY_IS_EQUAL(component.sum(), sum);
+  VERIFY_IS_EQUAL(component.template minCoeff<PropagateNaN>(), minimum);
+  VERIFY_IS_EQUAL(component.template maxCoeff<PropagateNaN>(), maximum);
+  VERIFY_IS_EQUAL(component.derived().cwiseAbs().template maxCoeff<PropagateNaN>(), abs_maximum);
+  VERIFY_IS_CWISE_EQUAL(component.derived().colwise().sum().eval(), copy.colwise().sum().eval());
+  VERIFY_IS_CWISE_EQUAL(component.derived().rowwise().sum().eval(), copy.rowwise().sum().eval());
+}
+
+template <typename MatrixType>
+void component_expressions(Index rows, Index cols) {
+  using Complex = typename MatrixType::Scalar;
+  using Real = typename NumTraits<Complex>::Real;
+  MatrixType values(rows, cols);
+  for (Index i = 0; i < values.size(); ++i) values.data()[i] = Complex(Real(i % 13 - 6), Real(i % 17 + 1));
+  const MatrixType& const_values = values;
+  check_component(values.real());
+  check_component(values.imag());
+  check_component(const_values.real());
+  check_component(const_values.imag());
+  check_component(values.transpose().real());
+  check_component(values.transpose().imag());
+  check_component(values.conjugate().real());
+  check_component(values.conjugate().imag());
+  check_component(values.block(0, 0, rows - 1, cols - 1).real());
+  check_component(values.block(0, 0, rows - 1, cols - 1).imag());
+  check_component(const_values.block(0, 0, rows - 1, cols - 1).real());
+  check_component(const_values.block(0, 0, rows - 1, cols - 1).imag());
+  const auto real = values.real();
+  const auto imag = values.imag();
+  check_component(real.block(0, 0, rows - 1, cols - 1));
+  check_component(imag.block(0, 0, rows - 1, cols - 1));
+
+  MatrixType original = values;
+  values.real() = original.imag();
+  values.imag() = original.real();
+  for (Index i = 0; i < values.size(); ++i) {
+    VERIFY_IS_EQUAL(values.data()[i], Complex(original.data()[i].imag(), original.data()[i].real()));
+  }
+  values.real().block(0, 0, rows - 1, cols - 1).setConstant(Real(3));
+  values.imag().array() += Real(2);
+  for (Index col = 0; col < cols; ++col) {
+    for (Index row = 0; row < rows; ++row) {
+      VERIFY_IS_EQUAL(values(row, col).imag(), original(row, col).real() + Real(2));
+      VERIFY_IS_EQUAL(values(row, col).real(), row < rows - 1 && col < cols - 1 ? Real(3) : original(row, col).imag());
+    }
+  }
+}
+
+template <typename Real>
+void component_reductions() {
+  using Complex = std::complex<Real>;
+  using Vector = Matrix<Complex, Dynamic, 1>;
+  constexpr bool vectorizable = (std::is_same<Real, float>::value || std::is_same<Real, double>::value) &&
+                                internal::packet_traits<Real>::Vectorizable;
+  using View = decltype(std::declval<Vector&>().real());
+  using ConstOp = decltype(std::declval<const Vector&>().imag());
+  STATIC_CHECK(bool(internal::redux_evaluator<View>::Flags & PacketAccessBit) == vectorizable);
+  STATIC_CHECK(bool(internal::evaluator<ConstOp>::Flags & PacketAccessBit) == vectorizable);
+  STATIC_CHECK(!(internal::evaluator<View>::Flags & PacketAccessBit));
+  using Strided = Map<Vector, Unaligned, InnerStride<2>>;
+  using StridedView = decltype(std::declval<Strided&>().real());
+  STATIC_CHECK(!(internal::redux_evaluator<StridedView>::Flags & PacketAccessBit));
+  using DynamicStride = Map<Vector, Unaligned, InnerStride<Dynamic>>;
+  using DynamicView = decltype(std::declval<const DynamicStride&>().imag());
+  STATIC_CHECK(!(internal::evaluator<DynamicView>::Flags & PacketAccessBit));
+  using SumView = decltype((std::declval<Vector>() + std::declval<Vector>()).real());
+  STATIC_CHECK(!(internal::evaluator<SumView>::Flags & PacketAccessBit));
+
+  const Real nan = NumTraits<Real>::quiet_NaN();
+  const Real inf = NumTraits<Real>::infinity();
+  constexpr Index packet_size = internal::packet_traits<Real>::size;
+  for (Index size : {Index(1), packet_size, packet_size + 1, 2 * packet_size - 1, Index(65)}) {
+    Vector buffer(2 * size + 1);
+    buffer.setConstant(Complex(Real(7), Real(-3)));
+    Map<Vector> values(buffer.data() + 1, size);
+    const auto& const_values = values;
+    check_component(values.real());
+    check_component(values.imag());
+    Strided strided(buffer.data() + 1, size);
+    check_component(strided.real());
+    check_component(strided.imag());
+    DynamicStride dynamic(buffer.data() + 1, size, InnerStride<Dynamic>(2));
+    check_component(dynamic.real());
+    check_component(dynamic.imag());
+    for (Index i = 0; i < size; ++i) {
+      for (Real special : {nan, inf, -inf, Real(0), -Real(0), std::numeric_limits<Real>::denorm_min()}) {
+        values.setConstant(Complex(Real(7), Real(-3)));
+        values(i) = Complex(special, Real(-3));
+        Matrix<Real, Dynamic, 1> real = const_values.real();
+        if ((numext::isnan)(special)) {
+          VERIFY((numext::isnan)(real(i)));
+          VERIFY((numext::isnan)(values.real().template maxCoeff<PropagateNaN>()));
+          VERIFY((numext::isnan)(const_values.real().template minCoeff<PropagateNaN>()));
+          if (size > 1) VERIFY_IS_EQUAL(values.real().template maxCoeff<PropagateNumbers>(), Real(7));
+        } else {
+          VERIFY_IS_EQUAL(real(i), special);
+          VERIFY_IS_EQUAL((std::signbit)(real(i)), (std::signbit)(special));
+        }
+        VERIFY_IS_EQUAL(values.imag().template maxCoeff<PropagateNaN>(), Real(-3));
+        values(i) = Complex(Real(7), special);
+        Matrix<Real, Dynamic, 1> imag = const_values.imag();
+        if ((numext::isnan)(special)) {
+          VERIFY((numext::isnan)(imag(i)));
+          VERIFY((numext::isnan)(values.imag().template minCoeff<PropagateNaN>()));
+          VERIFY((numext::isnan)(const_values.imag().template maxCoeff<PropagateNaN>()));
+          if (size > 1) VERIFY_IS_EQUAL(values.imag().template minCoeff<PropagateNumbers>(), Real(-3));
+        } else {
+          VERIFY_IS_EQUAL(imag(i), special);
+          VERIFY_IS_EQUAL((std::signbit)(imag(i)), (std::signbit)(special));
+        }
+        VERIFY_IS_EQUAL(values.real().template minCoeff<PropagateNaN>(), Real(7));
+      }
+    }
+  }
+}
+
+void component_custom_scalar() {
+  using Vector = Matrix<PaddedComplex, Dynamic, 1>;
+  Vector values(17);
+  for (Index i = 0; i < values.size(); ++i) values(i) = PaddedComplex(double(i), double(2 * i + 1));
+  const Vector& const_values = values;
+  using RealView = decltype(const_values.real());
+  using ImagView = decltype(const_values.imag());
+  STATIC_CHECK(!(internal::evaluator<RealView>::Flags & PacketAccessBit));
+  STATIC_CHECK(!(internal::evaluator<ImagView>::Flags & PacketAccessBit));
+  check_component(const_values.real());
+  check_component(const_values.imag());
+}
+
+EIGEN_DECLARE_TEST(complex_components) {
+  CALL_SUBTEST_1(component_reductions<float>());
+  CALL_SUBTEST_2(component_reductions<double>());
+  CALL_SUBTEST_3(component_reductions<long double>());
+  CALL_SUBTEST_3(component_custom_scalar());
+  for (Index rows : {Index(2), Index(7), Index(17)}) {
+    for (Index cols : {Index(3), Index(9)}) {
+      EIGEN_UNUSED_VARIABLE(rows);
+      EIGEN_UNUSED_VARIABLE(cols);
+      CALL_SUBTEST_1((component_expressions<Matrix<std::complex<float>, Dynamic, Dynamic, ColMajor>>(rows, cols)));
+      CALL_SUBTEST_1((component_expressions<Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>>(rows, cols)));
+      CALL_SUBTEST_2((component_expressions<Matrix<std::complex<double>, Dynamic, Dynamic, ColMajor>>(rows, cols)));
+      CALL_SUBTEST_2((component_expressions<Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>>(rows, cols)));
+    }
+  }
+  CALL_SUBTEST_1((component_expressions<Matrix<std::complex<float>, 3, 5>>(3, 5)));
+  CALL_SUBTEST_2((component_expressions<Matrix<std::complex<double>, 2, 2>>(2, 2)));
+}
diff --git a/test/complex_qz.cpp b/test/complex_qz.cpp
index 28ab08e..2a84421 100644
--- a/test/complex_qz.cpp
+++ b/test/complex_qz.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_RUNTIME_NO_MALLOC
 #include "main.h"
@@ -56,7 +57,119 @@
   VERIFY_IS_APPROX(qz.matrixZ() * qz.matrixZ().adjoint(), MatrixType::Identity(dim, dim));
 }
 
+template <typename MatrixType, typename QZType>
+void verify_complex_qz_convergence(const MatrixType& a, const MatrixType& b, const QZType& qz) {
+  using RealScalar = typename MatrixType::RealScalar;
+  // Accumulated rounding in the unitary transformations is O(n * epsilon).
+  const RealScalar tolerance = RealScalar(128 * a.rows()) * NumTraits<RealScalar>::epsilon();
+  VERIFY_IS_EQUAL(qz.info(), Success);
+  VERIFY((a - qz.matrixQ() * qz.matrixS() * qz.matrixZ()).norm() <= tolerance * a.norm());
+  VERIFY((b - qz.matrixQ() * qz.matrixT() * qz.matrixZ()).norm() <= tolerance * b.norm());
+  VERIFY(qz.matrixQ().isUnitary(tolerance));
+  VERIFY(qz.matrixZ().isUnitary(tolerance));
+  const MatrixType lowerS = qz.matrixS().template triangularView<StrictlyLower>();
+  const MatrixType lowerT = qz.matrixT().template triangularView<StrictlyLower>();
+  VERIFY(lowerS.norm() <= tolerance * a.norm());
+  VERIFY(lowerT.norm() <= tolerance * b.norm());
+}
+
+template <typename MatrixType>
+void complex_qz_exceptional_shift() {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  for (Index dim : {3, 4, 5, 8}) {
+    for (Scalar phase : {Scalar(1), Scalar(0, 1)}) {
+      // With corner -1 and phase 1, the exceptional shift 2 is equidistant from the eigenvalues exp(+-i*pi/dim).
+      for (RealScalar corner : {RealScalar(1), RealScalar(-1)}) {
+        // The trailing 2x2 block has two zero shifts: ordinary double shifts cycle without deflation.
+        MatrixType a = MatrixType::Zero(dim, dim), b = MatrixType::Identity(dim, dim);
+        a.diagonal(-1).setConstant(phase);
+        a(0, dim - 1) = corner * phase;
+        for (Index j = 0; j < dim; ++j) {
+          b(j, j) = Scalar(1 << (j % 3));
+          a.col(j) *= b(j, j);
+        }
+        const RealScalar tolerance = RealScalar(128 * dim) * NumTraits<RealScalar>::epsilon();
+
+        ComplexQZ<MatrixType> qz(a, b);
+        verify_complex_qz_convergence(a, b, qz);
+        // a*b^-1 = phase*P with P^dim = corner*I, so lambda_k = phase*w_k with w_k^dim = corner. These are
+        // 2*sin(pi/dim) apart with unit condition number (y^* b x = 1 for unit left y and |x| <= 1), so each moves by
+        // at most the backward error, including the dropped strictly lower parts of S and T.
+        const Matrix<Scalar, Dynamic, 1> lambda = qz.matrixS().diagonal().cwiseQuotient(qz.matrixT().diagonal());
+        const RealScalar eigenvalueTolerance = RealScalar(2) * tolerance * (a.norm() + b.norm());
+        for (Index k = 0; k < dim; ++k) {
+          const RealScalar angle = (RealScalar(2 * k) + (corner < 0 ? RealScalar(1) : RealScalar(0))) *
+                                   RealScalar(EIGEN_PI) / RealScalar(dim);
+          const Scalar expected = phase * std::polar(RealScalar(1), angle);
+          VERIFY((lambda.array() - expected).abs().minCoeff() <= eigenvalueTolerance);
+        }
+
+        ComplexQZ<MatrixType> limited(a, b, true, 1);
+        VERIFY_IS_EQUAL(limited.info(), NoConvergence);
+        VERIFY_IS_EQUAL(limited.iterations(), 1);
+
+        MatrixType inplaceA = a, inplaceB = b;
+        ComplexQZ<Ref<MatrixType>> inplace(inplaceA, inplaceB);
+        verify_complex_qz_convergence(a, b, inplace);
+
+        const MatrixType s = qz.matrixS(), t = qz.matrixT();
+        qz.compute(a, b, false);
+        VERIFY_IS_EQUAL(qz.info(), Success);
+        VERIFY((qz.matrixS() - s).norm() <= tolerance * a.norm());
+        VERIFY((qz.matrixT() - t).norm() <= tolerance * b.norm());
+        qz.compute(a, b);
+        verify_complex_qz_convergence(a, b, qz);
+      }
+    }
+  }
+}
+
+// Block Householder operations still allocate at larger sizes (issue #3163).
+template <typename MatrixType>
+void complex_qz_no_malloc() {
+  const Index dim = 24;
+  MatrixType A = MatrixType::Random(dim, dim), B = MatrixType::Random(dim, dim);
+  ComplexQZ<MatrixType> qz(dim);
+  internal::set_is_malloc_allowed(false);
+  qz.compute(A, B, false);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(qz.info(), Success);
+  const MatrixType S = qz.matrixS(), T = qz.matrixT();
+
+  ComplexQZ<MatrixType> resized(1, false);
+  resized.compute(A, B, false);
+  internal::set_is_malloc_allowed(false);
+  resized.compute(A, B, false);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(resized.info(), Success);
+  VERIFY_IS_APPROX(resized.matrixS(), S);
+  VERIFY_IS_APPROX(resized.matrixT(), T);
+
+  for (int i = 0; i < 2; ++i) {
+    internal::set_is_malloc_allowed(false);
+    qz.compute(A, B, true);
+    internal::set_is_malloc_allowed(true);
+    VERIFY_IS_EQUAL(qz.info(), Success);
+    VERIFY_IS_APPROX(qz.matrixS(), S);
+    VERIFY_IS_APPROX(qz.matrixT(), T);
+    VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixS() * qz.matrixZ(), A);
+    VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixT() * qz.matrixZ(), B);
+    VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixQ().adjoint(), MatrixType::Identity(dim, dim));
+    VERIFY_IS_APPROX(qz.matrixZ() * qz.matrixZ().adjoint(), MatrixType::Identity(dim, dim));
+  }
+}
+
 EIGEN_DECLARE_TEST(complex_qz) {
+  CALL_SUBTEST_3((complex_qz_no_malloc<MatrixXcf>()));
+  CALL_SUBTEST_4((complex_qz_no_malloc<MatrixXcd>()));
+  CALL_SUBTEST_5((complex_qz_no_malloc<Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_6((complex_qz_no_malloc<Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_7((complex_qz_exceptional_shift<MatrixXcf>()));
+  CALL_SUBTEST_8((complex_qz_exceptional_shift<MatrixXcd>()));
+  CALL_SUBTEST_9((complex_qz_exceptional_shift<Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_10((complex_qz_exceptional_shift<Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>>()));
+
   for (int i = 0; i < g_repeat; i++) {
     // Check for very small, fixed-sized double- and float complex matrices
     Eigen::Matrix2cd A_2x2, B_2x2;
@@ -75,10 +188,14 @@
     Eigen::MatrixXcf A_float, B_float;
     generate_random_matrix_pair(dim, A_float, B_float);
     CALL_SUBTEST_3(complex_qz(A_float, B_float));
+    CALL_SUBTEST_5((complex_qz(Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>(A_float),
+                               Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>(B_float))));
 
     // Test for double complex matrices
     Eigen::MatrixXcd A_double, B_double;
     generate_random_matrix_pair(dim, A_double, B_double);
     CALL_SUBTEST_4(complex_qz(A_double, B_double));
+    CALL_SUBTEST_6((complex_qz(Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>(A_double),
+                               Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>(B_double))));
   }
 }
diff --git a/test/complex_sqrt.cpp b/test/complex_sqrt.cpp
new file mode 100644
index 0000000..74d210e
--- /dev/null
+++ b/test/complex_sqrt.cpp
@@ -0,0 +1,155 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "CustomComplex.h"
+#include "fp_control.h"
+
+template <typename T>
+void check_root_component(T actual, T expected) {
+  if ((numext::isnan)(expected)) {
+    VERIFY((numext::isnan)(actual));
+  } else if ((numext::isinf)(expected) || numext::is_exactly_zero(expected)) {
+    VERIFY_IS_EQUAL(actual, expected);
+    VERIFY_IS_EQUAL(std::signbit(actual), std::signbit(expected));
+  } else {
+    VERIFY((numext::isfinite)(actual));
+    // Two square roots, divisions and scaling: allow a few rounding errors per component.
+    const T bound =
+        T(4) * NumTraits<T>::epsilon() * numext::abs(expected) + T(2) * std::numeric_limits<T>::denorm_min();
+    VERIFY(numext::abs(actual - expected) <= bound);
+  }
+}
+
+template <typename T>
+void check_complex_roots(const std::complex<T>& input, const std::complex<T>& root,
+                         const std::complex<T>& reciprocal_root) {
+  const auto actual = numext::sqrt(input);
+  const auto reciprocal_actual = numext::rsqrt(input);
+  check_root_component(actual.real(), root.real());
+  check_root_component(actual.imag(), root.imag());
+  check_root_component(reciprocal_actual.real(), reciprocal_root.real());
+  check_root_component(reciprocal_actual.imag(), reciprocal_root.imag());
+
+  const auto custom = numext::sqrt(CustomComplex<T>(input.real(), input.imag()));
+  check_root_component(numext::real(custom), root.real());
+  check_root_component(numext::imag(custom), root.imag());
+}
+
+template <typename T>
+void complex_roots_special_values() {
+  using C = std::complex<T>;
+  const T zero = T(0);
+  const T inf = NumTraits<T>::infinity();
+  const T nan = NumTraits<T>::quiet_NaN();
+  for (T sign : {T(-1), T(1)}) {
+    const T y = sign * zero;
+    check_complex_roots(C(zero, y), C(zero, y), C(inf, nan));
+    check_complex_roots(C(-zero, y), C(zero, y), C(inf, nan));
+    check_complex_roots(C(T(4), y), C(T(2), y), C(T(0.5), -y));
+    check_complex_roots(C(T(-4), y), C(zero, sign * T(2)), C(zero, -sign * T(0.5)));
+    for (T x : {zero, T(1), T(-1), inf, -inf, nan}) {
+      check_complex_roots(C(x, sign * inf), C(inf, sign * inf), C(zero, -y));
+    }
+    for (T magnitude : {zero, T(1)}) {
+      check_complex_roots(C(inf, sign * magnitude), C(inf, y), C(zero, -y));
+      check_complex_roots(C(-inf, sign * magnitude), C(zero, sign * inf), C(zero, -y));
+    }
+  }
+  for (T value : {zero, T(1), T(-1), nan}) {
+    check_complex_roots(C(value, nan), C(nan, nan), C(nan, nan));
+    check_complex_roots(C(nan, value), C(nan, nan), C(nan, nan));
+  }
+  const auto positive_inf_nan = numext::sqrt(C(inf, nan));
+  const auto negative_inf_nan = numext::sqrt(C(-inf, nan));
+  check_root_component(positive_inf_nan.real(), inf);
+  VERIFY((numext::isnan)(positive_inf_nan.imag()));
+  VERIFY((numext::isnan)(negative_inf_nan.real()));
+  VERIFY((numext::isinf)(negative_inf_nan.imag()));
+}
+
+template <typename T>
+void complex_roots_finite() {
+  using C = std::complex<T>;
+  const bool flushes_inputs = ScopedFlushToZero::hardwareFlushesSubnormalInputs();
+  const int minimum_exponent = std::numeric_limits<T>::min_exponent - std::numeric_limits<T>::digits;
+  // sqrt((3 + 4i) * 2^(2k)) = (2 + i) * 2^k, exactly.
+  for (int exponent = minimum_exponent; exponent <= std::numeric_limits<T>::max_exponent - 3; ++exponent) {
+    if (exponent % 2 != 0 || (flushes_inputs && exponent < std::numeric_limits<T>::min_exponent - 1)) continue;
+    const T scale = std::ldexp(T(1), exponent);
+    const T root_scale = std::ldexp(T(1), exponent / 2);
+    for (T sign_x : {T(-1), T(1)}) {
+      for (T sign_y : {T(-1), T(1)}) {
+        const T u = sign_x > 0 ? T(2) : T(1);
+        const T v = sign_x > 0 ? T(1) : T(2);
+        check_complex_roots(C(sign_x * T(3) * scale, sign_y * T(4) * scale), C(u * root_scale, sign_y * v * root_scale),
+                            C((u / T(5)) / root_scale, (-sign_y * v / T(5)) / root_scale));
+      }
+    }
+  }
+
+  const T minimum = (std::numeric_limits<T>::min)();
+  const T maximum = NumTraits<T>::highest();
+  const T lower = T(2) * minimum;
+  const T upper = maximum / T(4);
+  const T values[] = {std::numeric_limits<T>::denorm_min(),
+                      minimum,
+                      std::nextafter(lower, T(0)),
+                      lower,
+                      std::nextafter(lower, maximum),
+                      std::nextafter(upper, T(0)),
+                      upper,
+                      std::nextafter(upper, maximum),
+                      maximum};
+  // MPFR, 256 bits: components of sqrt(1+i) and 1/sqrt(1+i).
+  const T a = T(1.0986841134678099660398011952406783785L);
+  const T b = T(0.4550898605622273413043577578224685696L);
+  const T c = T(0.7768869870150186536720794765315734741L);
+  const T d = T(0.3217971264527913123677217187091049045L);
+  for (T p : values) {
+    if (p == T(0) || (flushes_inputs && p < minimum)) continue;
+    const T root_p = numext::sqrt(p);
+    for (T sign : {T(-1), T(1)}) {
+      check_complex_roots(C(p, sign * p), C(a * root_p, sign * b * root_p), C(c / root_p, -sign * d / root_p));
+      check_complex_roots(C(-p, sign * p), C(b * root_p, sign * a * root_p), C(d / root_p, -sign * c / root_p));
+      const T half_root = root_p * T(0.7071067811865475244008443621048490393L);
+      const T inverse_half_root = T(0.7071067811865475244008443621048490393L) / root_p;
+      check_complex_roots(C(T(0), sign * p), C(half_root, sign * half_root),
+                          C(inverse_half_root, -sign * inverse_half_root));
+    }
+  }
+
+  const T large = std::ldexp(T(1), std::numeric_limits<T>::max_exponent - 2);
+  const T small = std::ldexp(T(1), -std::numeric_limits<T>::max_exponent / 3);
+  const T root_large = numext::sqrt(large);
+  // small/large underflows, but the smaller component of sqrt(large + i*small) does not.
+  check_complex_roots(C(large, small), C(root_large, small / (T(2) * root_large)), C(T(1) / root_large, -T(0)));
+  check_complex_roots(C(-large, -small), C(small / (T(2) * root_large), -root_large), C(T(0), T(1) / root_large));
+
+  // A strided input selects scalar evaluation even on backends with complex packets.
+  Array<C, 34, 1> storage;
+  Map<Array<C, 17, 1>, Unaligned, InnerStride<2>> input(storage.data());
+  for (Index i = 0; i < input.size(); ++i) {
+    const int exponent = i % 2 ? std::numeric_limits<T>::max_exponent - 4 : std::numeric_limits<T>::min_exponent;
+    const T scale = std::ldexp(T(1), exponent - exponent % 2);
+    input(i) = C(T(3) * scale, T(4) * scale);
+  }
+  const Array<C, 17, 1> roots = input.sqrt();
+  const Array<C, 17, 1> reciprocal_roots = input.rsqrt();
+  for (Index i = 0; i < input.size(); ++i) {
+    const T scale = numext::sqrt(input(i).imag() / T(4));
+    check_root_component(roots(i).real(), T(2) * scale);
+    check_root_component(roots(i).imag(), scale);
+    check_root_component(reciprocal_roots(i).real(), (T(2) / T(5)) / scale);
+    check_root_component(reciprocal_roots(i).imag(), (T(-1) / T(5)) / scale);
+  }
+}
+
+EIGEN_DECLARE_TEST(complex_sqrt) {
+  CALL_SUBTEST(complex_roots_special_values<float>());
+  CALL_SUBTEST(complex_roots_special_values<double>());
+  CALL_SUBTEST(complex_roots_special_values<long double>());
+  CALL_SUBTEST(complex_roots_finite<float>());
+  CALL_SUBTEST(complex_roots_finite<double>());
+  CALL_SUBTEST(complex_roots_finite<long double>());
+}
diff --git a/test/concat.cpp b/test/concat.cpp
new file mode 100644
index 0000000..f0f70b7
--- /dev/null
+++ b/test/concat.cpp
@@ -0,0 +1,981 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Pavel Guzenfeld
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+using namespace Eigen;
+
+// ============================================================================
+// Test 1: Dynamic-size matrix concatenation (basic correctness)
+// ============================================================================
+template <typename MatrixType>
+void test_concat_dynamic(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  MatrixType b = MatrixType::Random(rows, cols);
+
+  // Vertical concatenation: stack rows
+  {
+    MatrixX expected(2 * rows, cols);
+    expected.topRows(rows) = a;
+    expected.bottomRows(rows) = b;
+    VERIFY_IS_APPROX(expected, vcat(a, b).eval());
+  }
+
+  // Horizontal concatenation: stack columns
+  {
+    MatrixX expected(rows, 2 * cols);
+    expected.leftCols(cols) = a;
+    expected.rightCols(cols) = b;
+    VERIFY_IS_APPROX(expected, hcat(a, b).eval());
+  }
+
+  // Test with different-sized operands
+  {
+    MatrixX c = MatrixX::Random(rows + 2, cols);
+    MatrixX vresult = vcat(a, c);
+    VERIFY_IS_EQUAL(vresult.rows(), 2 * rows + 2);
+    VERIFY_IS_EQUAL(vresult.cols(), cols);
+    MatrixX vexpected(2 * rows + 2, cols);
+    vexpected.topRows(rows) = a;
+    vexpected.bottomRows(rows + 2) = c;
+    VERIFY_IS_APPROX(vexpected, vresult);
+  }
+
+  {
+    MatrixX d = MatrixX::Random(rows, cols + 3);
+    MatrixX hresult = hcat(a, d);
+    VERIFY_IS_EQUAL(hresult.rows(), rows);
+    VERIFY_IS_EQUAL(hresult.cols(), 2 * cols + 3);
+    MatrixX hexpected(rows, 2 * cols + 3);
+    hexpected.leftCols(cols) = a;
+    hexpected.rightCols(cols + 3) = d;
+    VERIFY_IS_APPROX(hexpected, hresult);
+  }
+}
+
+// ============================================================================
+// Test 2: Expression inputs (not plain objects)
+// Verifies that Concat works with CwiseBinaryOp, CwiseUnaryOp, etc.
+// ============================================================================
+template <typename MatrixType>
+void test_concat_with_expressions(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType a = MatrixType::Random(rows, cols);
+  MatrixType b = MatrixType::Random(rows, cols);
+
+  // Concat with scalar-multiply expressions
+  {
+    MatrixX expected(2 * rows, cols);
+    expected.topRows(rows) = 2.0 * a;
+    expected.bottomRows(rows) = 3.0 * b;
+    VERIFY_IS_APPROX(expected, vcat(2.0 * a, 3.0 * b).eval());
+  }
+
+  // Concat with sum/difference expressions
+  {
+    MatrixX expected(rows, 2 * cols);
+    expected.leftCols(cols) = a + b;
+    expected.rightCols(cols) = a - b;
+    VERIFY_IS_APPROX(expected, hcat(a + b, a - b).eval());
+  }
+
+  // Concat with transpose expressions
+  {
+    MatrixX expected(cols, 2 * rows);
+    expected.leftCols(rows) = a.transpose();
+    expected.rightCols(rows) = b.transpose();
+    VERIFY_IS_APPROX(expected, hcat(a.transpose(), b.transpose()).eval());
+  }
+
+  // Concat with block expressions
+  {
+    if (rows >= 2 && cols >= 2) {
+      auto block_a = a.topLeftCorner(rows - 1, cols);
+      auto block_b = b.bottomRightCorner(1, cols);
+      MatrixX expected(rows, cols);
+      expected.topRows(rows - 1) = block_a;
+      expected.bottomRows(1) = block_b;
+      VERIFY_IS_APPROX(expected, vcat(block_a, block_b).eval());
+    }
+  }
+}
+
+// ============================================================================
+// Test 3: Fixed-size concat with compile-time dimension propagation
+// ============================================================================
+template <typename Scalar, int LhsRows, int CommonCols, int RhsRows>
+void test_vcat_fixed() {
+  typedef Matrix<Scalar, LhsRows, CommonCols> LhsType;
+  typedef Matrix<Scalar, RhsRows, CommonCols> RhsType;
+
+  LhsType a = LhsType::Random();
+  RhsType b = RhsType::Random();
+
+  auto vc = vcat(a, b);
+  VERIFY_IS_EQUAL(vc.rows(), a.rows() + b.rows());
+  VERIFY_IS_EQUAL(vc.cols(), a.cols());
+
+  typedef Concat<Vertical, LhsType, RhsType> VConcatType;
+  VERIFY((int(VConcatType::RowsAtCompileTime) == LhsRows + RhsRows));
+  VERIFY((int(VConcatType::ColsAtCompileTime) == CommonCols));
+  VERIFY((int(VConcatType::MaxRowsAtCompileTime) == LhsRows + RhsRows));
+  VERIFY((int(VConcatType::MaxColsAtCompileTime) == CommonCols));
+
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  MatrixX expected(a.rows() + b.rows(), a.cols());
+  expected.topRows(a.rows()) = a;
+  expected.bottomRows(b.rows()) = b;
+  VERIFY_IS_APPROX(expected, MatrixX(vc));
+}
+
+template <typename Scalar, int CommonRows, int LhsCols, int RhsCols>
+void test_hcat_fixed() {
+  typedef Matrix<Scalar, CommonRows, LhsCols> LhsType;
+  typedef Matrix<Scalar, CommonRows, RhsCols> RhsType;
+
+  LhsType a = LhsType::Random();
+  RhsType b = RhsType::Random();
+
+  auto hc = hcat(a, b);
+  VERIFY_IS_EQUAL(hc.rows(), a.rows());
+  VERIFY_IS_EQUAL(hc.cols(), a.cols() + b.cols());
+
+  typedef Concat<Horizontal, LhsType, RhsType> HConcatType;
+  VERIFY((int(HConcatType::RowsAtCompileTime) == CommonRows));
+  VERIFY((int(HConcatType::ColsAtCompileTime) == LhsCols + RhsCols));
+  VERIFY((int(HConcatType::MaxRowsAtCompileTime) == CommonRows));
+  VERIFY((int(HConcatType::MaxColsAtCompileTime) == LhsCols + RhsCols));
+
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  MatrixX expected(a.rows(), a.cols() + b.cols());
+  expected.leftCols(a.cols()) = a;
+  expected.rightCols(b.cols()) = b;
+  VERIFY_IS_APPROX(expected, MatrixX(hc));
+}
+
+// ============================================================================
+// Test 4: Mixed fixed/dynamic dimension concat
+// Verifies that compile-time dimensions become Dynamic when appropriate
+// ============================================================================
+template <typename Scalar>
+void test_concat_mixed_fixed_dynamic() {
+  typedef Matrix<Scalar, 3, 3> Fixed33;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, Dynamic, 3> MatrixX3;
+
+  Fixed33 a = Fixed33::Random();
+  MatrixX b = MatrixX::Random(4, 3);
+
+  // Vertical: fixed + dynamic => dynamic rows, but cols known at compile time
+  {
+    auto vc = vcat(a, b);
+    VERIFY_IS_EQUAL(vc.rows(), 7);
+    VERIFY_IS_EQUAL(vc.cols(), 3);
+
+    // Compile-time: rows should be Dynamic (fixed + dynamic = dynamic)
+    typedef decltype(vc) VCType;
+    VERIFY((int(VCType::RowsAtCompileTime) == Dynamic));
+    // Cols: fixed 3 and dynamic => 3 (size_prefer_fixed picks the fixed one)
+    VERIFY((int(VCType::ColsAtCompileTime) == 3));
+
+    MatrixX expected(7, 3);
+    expected.topRows(3) = a;
+    expected.bottomRows(4) = b;
+    VERIFY_IS_APPROX(expected, MatrixX(vc));
+  }
+
+  // Vertical: fixed + MatrixX3 (cols both = 3) => dynamic rows
+  {
+    MatrixX3 c = MatrixX3::Random(5, 3);
+    auto vc = vcat(a, c);
+    VERIFY_IS_EQUAL(vc.rows(), 8);
+    VERIFY_IS_EQUAL(vc.cols(), 3);
+
+    typedef decltype(vc) VCType;
+    VERIFY((int(VCType::RowsAtCompileTime) == Dynamic));
+
+    MatrixX expected(8, 3);
+    expected.topRows(3) = a;
+    expected.bottomRows(5) = c;
+    VERIFY_IS_APPROX(expected, MatrixX(vc));
+  }
+
+  // Horizontal: fixed + dynamic
+  {
+    MatrixX d = MatrixX::Random(3, 5);
+    auto hc = hcat(a, d);
+    VERIFY_IS_EQUAL(hc.rows(), 3);
+    VERIFY_IS_EQUAL(hc.cols(), 8);
+
+    typedef decltype(hc) HCType;
+    VERIFY((int(HCType::ColsAtCompileTime) == Dynamic));
+
+    MatrixX expected(3, 8);
+    expected.leftCols(3) = a;
+    expected.rightCols(5) = d;
+    VERIFY_IS_APPROX(expected, MatrixX(hc));
+  }
+
+  // Dynamic + fixed (reversed order)
+  {
+    MatrixX3 e = MatrixX3::Random(5, 3);
+    auto vc = vcat(e, a);
+    VERIFY_IS_EQUAL(vc.rows(), 8);
+    VERIFY_IS_EQUAL(vc.cols(), 3);
+
+    MatrixX expected(8, 3);
+    expected.topRows(5) = e;
+    expected.bottomRows(3) = a;
+    VERIFY_IS_APPROX(expected, MatrixX(vc));
+  }
+}
+
+// ============================================================================
+// Test 5: Rvalue temporary lifetime safety
+// Verifies ref_selector properly copies temporaries instead of dangling refs
+// ============================================================================
+template <typename Scalar>
+void test_concat_rvalue_temporaries() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+
+  MatrixX a = MatrixX::Random(3, 3);
+  MatrixX b = MatrixX::Random(3, 3);
+
+  // Test 5a: Additive temporaries
+  {
+    MatrixX result = hcat(a + MatrixX::Zero(3, 3), b + MatrixX::Zero(3, 3));
+    MatrixX expected(3, 6);
+    expected.leftCols(3) = a;
+    expected.rightCols(3) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Test 5c: Store expression with auto and evaluate later
+  // This is the critical rvalue lifetime test: the expression must
+  // keep the temporary alive until evaluation
+  {
+    auto expr = vcat(a * MatrixX::Identity(3, 3), b * MatrixX::Identity(3, 3));
+    // At this point, the temporaries from a*I and b*I must still be valid
+    MatrixX result = expr;
+    MatrixX expected(6, 3);
+    expected.topRows(3) = a;
+    expected.bottomRows(3) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Test 5d: Auto with hcat
+  {
+    auto expr = hcat(a + b, a - b);
+    MatrixX result = expr;
+    MatrixX expected(3, 6);
+    expected.leftCols(3) = a + b;
+    expected.rightCols(3) = a - b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Test 5e: Nested auto expressions (chained concat of temporaries)
+  {
+    MatrixX c = MatrixX::Random(3, 3);
+    auto inner = vcat(a + b, c * MatrixX::Identity(3, 3));
+    auto outer = vcat(inner, a - b);
+    MatrixX result = outer;
+    VERIFY_IS_EQUAL(result.rows(), 9);
+    VERIFY_IS_EQUAL(result.cols(), 3);
+    MatrixX expected(9, 3);
+    expected.topRows(3) = a + b;
+    expected.middleRows(3, 3) = c;
+    expected.bottomRows(3) = a - b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+}
+
+// ============================================================================
+// Test 6: Chained concatenation (binary API, no variadic needed)
+// ============================================================================
+template <typename Scalar>
+void test_concat_chained() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+
+  MatrixX a = MatrixX::Random(2, 3);
+  MatrixX b = MatrixX::Random(2, 3);
+  MatrixX c = MatrixX::Random(2, 3);
+
+  // Chain: vcat(vcat(a, b), c) should be 6x3
+  {
+    MatrixX result = vcat(vcat(a, b), c);
+    VERIFY_IS_EQUAL(result.rows(), 6);
+    VERIFY_IS_EQUAL(result.cols(), 3);
+
+    MatrixX expected(6, 3);
+    expected.topRows(2) = a;
+    expected.middleRows(2, 2) = b;
+    expected.bottomRows(2) = c;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Chain: hcat(hcat(a, b), c) should be 2x9
+  {
+    MatrixX result = hcat(hcat(a, b), c);
+    VERIFY_IS_EQUAL(result.rows(), 2);
+    VERIFY_IS_EQUAL(result.cols(), 9);
+
+    MatrixX expected(2, 9);
+    expected.leftCols(3) = a;
+    expected.middleCols(3, 3) = b;
+    expected.rightCols(3) = c;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Mixed chain: vcat then hcat
+  {
+    MatrixX e = MatrixX::Random(4, 5);
+    MatrixX vert = vcat(a, b);  // 4x3
+    MatrixX result = hcat(vert, e);
+    VERIFY_IS_EQUAL(result.rows(), 4);
+    VERIFY_IS_EQUAL(result.cols(), 8);
+
+    MatrixX expected(4, 8);
+    expected.leftCols(3) = vert;
+    expected.rightCols(5) = e;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // 4-way chain
+  {
+    MatrixX d = MatrixX::Random(2, 3);
+    MatrixX result = vcat(vcat(vcat(a, b), c), d);
+    VERIFY_IS_EQUAL(result.rows(), 8);
+    VERIFY_IS_EQUAL(result.cols(), 3);
+
+    MatrixX expected(8, 3);
+    expected.block(0, 0, 2, 3) = a;
+    expected.block(2, 0, 2, 3) = b;
+    expected.block(4, 0, 2, 3) = c;
+    expected.block(6, 0, 2, 3) = d;
+    VERIFY_IS_APPROX(expected, result);
+  }
+}
+
+// ============================================================================
+// Test 7: Vector concatenation
+// ============================================================================
+template <typename Scalar>
+void test_concat_vectors() {
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+  typedef Matrix<Scalar, 1, Dynamic> RowVectorX;
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Matrix<Scalar, 4, 1> Vector4;
+  typedef Matrix<Scalar, 1, 3> RowVector3;
+  typedef Matrix<Scalar, 1, 4> RowVector4;
+
+  // Column vectors: vcat
+  {
+    VectorX a = VectorX::Random(3);
+    VectorX b = VectorX::Random(5);
+    VectorX result = vcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 8);
+    VERIFY_IS_EQUAL(result.cols(), 1);
+    VectorX expected(8);
+    expected.head(3) = a;
+    expected.tail(5) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Row vectors: hcat
+  {
+    RowVectorX a = RowVectorX::Random(3);
+    RowVectorX b = RowVectorX::Random(5);
+    RowVectorX result = hcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 1);
+    VERIFY_IS_EQUAL(result.cols(), 8);
+    RowVectorX expected(8);
+    expected.head(3) = a;
+    expected.tail(5) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Fixed-size column vectors: compile-time dimensions
+  {
+    Vector3 a = Vector3::Random();
+    Vector4 b = Vector4::Random();
+    auto result = vcat(a, b);
+
+    typedef Concat<Vertical, Vector3, Vector4> VConcatType;
+    VERIFY((int(VConcatType::RowsAtCompileTime) == 7));
+    VERIFY((int(VConcatType::ColsAtCompileTime) == 1));
+
+    typedef Matrix<Scalar, Dynamic, 1> VecX;
+    VecX expected(7);
+    expected.head(3) = a;
+    expected.tail(4) = b;
+    VecX actual(result);
+    VERIFY_IS_APPROX(expected, actual);
+  }
+
+  // Fixed-size row vectors: compile-time dimensions
+  {
+    RowVector3 a = RowVector3::Random();
+    RowVector4 b = RowVector4::Random();
+    auto result = hcat(a, b);
+
+    typedef Concat<Horizontal, RowVector3, RowVector4> HConcatType;
+    VERIFY((int(HConcatType::RowsAtCompileTime) == 1));
+    VERIFY((int(HConcatType::ColsAtCompileTime) == 7));
+
+    typedef Matrix<Scalar, 1, Dynamic> RowVecX;
+    RowVecX expected(7);
+    expected.head(3) = a;
+    expected.tail(4) = b;
+    RowVecX actual(result);
+    VERIFY_IS_APPROX(expected, actual);
+  }
+}
+
+// ============================================================================
+// Test 8: Array concatenation (verifies XprKind propagation)
+// ============================================================================
+template <typename Scalar>
+void test_concat_array() {
+  typedef Array<Scalar, Dynamic, Dynamic> ArrayX;
+  typedef Array<Scalar, 2, 3> FixedArray23;
+
+  // Dynamic arrays
+  {
+    ArrayX a = ArrayX::Random(3, 4);
+    ArrayX b = ArrayX::Random(3, 4);
+
+    // vcat with arrays
+    ArrayX expected(6, 4);
+    expected.topRows(3) = a;
+    expected.bottomRows(3) = b;
+    ArrayX result = vcat(a, b);
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  {
+    ArrayX a = ArrayX::Random(3, 4);
+    ArrayX b = ArrayX::Random(3, 4);
+
+    // hcat with arrays
+    ArrayX expected(3, 8);
+    expected.leftCols(4) = a;
+    expected.rightCols(4) = b;
+    ArrayX result = hcat(a, b);
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Fixed-size arrays
+  {
+    FixedArray23 a = FixedArray23::Random();
+    FixedArray23 b = FixedArray23::Random();
+
+    typedef Concat<Vertical, FixedArray23, FixedArray23> VConcatType;
+    VERIFY((int(VConcatType::RowsAtCompileTime) == 4));
+    VERIFY((int(VConcatType::ColsAtCompileTime) == 3));
+
+    ArrayX expected(4, 3);
+    expected.topRows(2) = a;
+    expected.bottomRows(2) = b;
+    ArrayX result = vcat(a, b);
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Array expressions (coefficient-wise operations)
+  {
+    ArrayX a = ArrayX::Random(3, 4);
+    ArrayX b = ArrayX::Random(3, 4);
+    ArrayX result = vcat(a * b, a + b);
+    VERIFY_IS_EQUAL(result.rows(), 6);
+    VERIFY_IS_EQUAL(result.cols(), 4);
+    ArrayX expected(6, 4);
+    expected.topRows(3) = a * b;
+    expected.bottomRows(3) = a + b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+}
+
+// ============================================================================
+// Test 9: Coefficient-level access verification
+// ============================================================================
+template <typename Scalar>
+void test_concat_coeff_access() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+
+  MatrixX a = MatrixX::Random(3, 4);
+  MatrixX b = MatrixX::Random(2, 4);
+
+  // Verify each coefficient of vcat
+  {
+    auto vc = vcat(a, b);
+    for (Index j = 0; j < 4; ++j) {
+      for (Index i = 0; i < 3; ++i) {
+        VERIFY_IS_APPROX(vc(i, j), a(i, j));
+      }
+      for (Index i = 0; i < 2; ++i) {
+        VERIFY_IS_APPROX(vc(3 + i, j), b(i, j));
+      }
+    }
+  }
+
+  // Verify each coefficient of hcat
+  {
+    MatrixX c = MatrixX::Random(3, 2);
+    auto hc = hcat(a, c);
+    for (Index i = 0; i < 3; ++i) {
+      for (Index j = 0; j < 4; ++j) {
+        VERIFY_IS_APPROX(hc(i, j), a(i, j));
+      }
+      for (Index j = 0; j < 2; ++j) {
+        VERIFY_IS_APPROX(hc(i, 4 + j), c(i, j));
+      }
+    }
+  }
+}
+
+// ============================================================================
+// Test 10: Expression used in further Eigen operations
+// Verifies Concat integrates with Eigen's expression machinery
+// ============================================================================
+template <typename Scalar>
+void test_concat_in_expressions() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+
+  MatrixX a = MatrixX::Random(3, 3);
+  MatrixX b = MatrixX::Random(3, 3);
+
+  // Use concat result in matrix multiplication
+  {
+    MatrixX wide = hcat(a, b);  // 3x6
+    VectorX v = VectorX::Random(6);
+    VectorX result = wide * v;
+    MatrixX wide_eval = wide;
+    VectorX expected = wide_eval * v;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Use concat result in sum
+  {
+    auto vc = vcat(a, b);
+    Scalar s = vc.sum();
+    Scalar expected_sum = a.sum() + b.sum();
+    VERIFY_IS_APPROX(expected_sum, s);
+  }
+
+  // Use concat in norm computation
+  {
+    VectorX va = VectorX::Random(4);
+    VectorX vb = VectorX::Random(3);
+    auto vc = vcat(va, vb);
+    Scalar n2 = vc.squaredNorm();
+    Scalar expected_n2 = va.squaredNorm() + vb.squaredNorm();
+    VERIFY_IS_APPROX(expected_n2, n2);
+  }
+
+  // Concat result assigned to a block
+  {
+    MatrixX target = MatrixX::Zero(6, 3);
+    target = vcat(a, b);
+    MatrixX expected(6, 3);
+    expected.topRows(3) = a;
+    expected.bottomRows(3) = b;
+    VERIFY_IS_APPROX(expected, target);
+  }
+}
+
+// ============================================================================
+// Test 11: Single row / single column edge cases
+// ============================================================================
+template <typename Scalar>
+void test_concat_single_row_col() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, 1, Dynamic> RowVectorX;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+
+  // Single-row matrices: vcat
+  {
+    RowVectorX a = RowVectorX::Random(5);
+    RowVectorX b = RowVectorX::Random(5);
+    MatrixX result = vcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 2);
+    VERIFY_IS_EQUAL(result.cols(), 5);
+    VERIFY_IS_APPROX(result.row(0), a);
+    VERIFY_IS_APPROX(result.row(1), b);
+  }
+
+  // Single-column matrices: hcat
+  {
+    VectorX a = VectorX::Random(5);
+    VectorX b = VectorX::Random(5);
+    MatrixX result = hcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 5);
+    VERIFY_IS_EQUAL(result.cols(), 2);
+    VERIFY_IS_APPROX(result.col(0), a);
+    VERIFY_IS_APPROX(result.col(1), b);
+  }
+
+  // 1x1 matrices
+  {
+    MatrixX a = MatrixX::Random(1, 1);
+    MatrixX b = MatrixX::Random(1, 1);
+    MatrixX vr = vcat(a, b);
+    VERIFY_IS_EQUAL(vr.rows(), 2);
+    VERIFY_IS_EQUAL(vr.cols(), 1);
+    VERIFY_IS_APPROX(vr(0, 0), a(0, 0));
+    VERIFY_IS_APPROX(vr(1, 0), b(0, 0));
+
+    MatrixX hr = hcat(a, b);
+    VERIFY_IS_EQUAL(hr.rows(), 1);
+    VERIFY_IS_EQUAL(hr.cols(), 2);
+    VERIFY_IS_APPROX(hr(0, 0), a(0, 0));
+    VERIFY_IS_APPROX(hr(0, 1), b(0, 0));
+  }
+}
+
+// ============================================================================
+// Test 12: RowMajor matrices
+// Verifies IsRowMajor flag logic in Concat traits
+// ============================================================================
+template <typename Scalar>
+void test_concat_row_major() {
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMajorMatrix;
+  // Explicit ColMajor so the mixed-order cases below stay mixed under EIGEN_DEFAULT_TO_ROW_MAJOR.
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> ColMajorMatrix;
+  typedef Matrix<Scalar, 3, 3, RowMajor> FixedRowMajor33;
+
+  // RowMajor + RowMajor
+  {
+    RowMajorMatrix a = RowMajorMatrix::Random(3, 4);
+    RowMajorMatrix b = RowMajorMatrix::Random(2, 4);
+    ColMajorMatrix result = vcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 5);
+    VERIFY_IS_EQUAL(result.cols(), 4);
+    ColMajorMatrix expected(5, 4);
+    expected.topRows(3) = a;
+    expected.bottomRows(2) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  {
+    RowMajorMatrix a = RowMajorMatrix::Random(3, 4);
+    RowMajorMatrix b = RowMajorMatrix::Random(3, 2);
+    ColMajorMatrix result = hcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 3);
+    VERIFY_IS_EQUAL(result.cols(), 6);
+    ColMajorMatrix expected(3, 6);
+    expected.leftCols(4) = a;
+    expected.rightCols(2) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Mixed: RowMajor + ColMajor
+  {
+    RowMajorMatrix a = RowMajorMatrix::Random(3, 4);
+    ColMajorMatrix b = ColMajorMatrix::Random(2, 4);
+    ColMajorMatrix result = vcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 5);
+    VERIFY_IS_EQUAL(result.cols(), 4);
+    ColMajorMatrix expected(5, 4);
+    expected.topRows(3) = a;
+    expected.bottomRows(2) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Mixed storage-order operands with the destination matching the Concat's claimed order, so
+  // the packet path engages. Regression: packets used to be loaded along the mismatched
+  // operand's own inner direction, producing wrong results.
+  {
+    RowMajorMatrix a = RowMajorMatrix::Random(3, 11);
+    ColMajorMatrix b = ColMajorMatrix::Random(2, 11);
+    RowMajorMatrix result = vcat(a, b);
+    RowMajorMatrix expected(5, 11);
+    expected.topRows(3) = a;
+    expected.bottomRows(2) = b;
+    VERIFY_IS_APPROX(expected, result);
+
+    STATIC_CHECK(!(internal::evaluator<std::decay_t<decltype(vcat(a, b))>>::Flags & PacketAccessBit));
+    // With matching operand orders the Concat keeps packet access exactly when the operand
+    // evaluators have it; comparing against the operand's own flag keeps this valid on backends
+    // where this Scalar is not vectorizable.
+    RowMajorMatrix c(2, 11);
+    STATIC_CHECK((internal::evaluator<std::decay_t<decltype(vcat(a, c))>>::Flags & PacketAccessBit) ==
+                 (internal::evaluator<RowMajorMatrix>::Flags & PacketAccessBit));
+  }
+  {
+    ColMajorMatrix a = ColMajorMatrix::Random(5, 8);
+    RowMajorMatrix b = RowMajorMatrix::Random(9, 8);
+    ColMajorMatrix result = vcat(a, b);
+    ColMajorMatrix expected(14, 8);
+    expected.topRows(5) = a;
+    expected.bottomRows(9) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+  {
+    ColMajorMatrix a = ColMajorMatrix::Random(9, 3);
+    RowMajorMatrix b = RowMajorMatrix::Random(9, 4);
+    ColMajorMatrix result = hcat(a, b);
+    ColMajorMatrix expected(9, 7);
+    expected.leftCols(3) = a;
+    expected.rightCols(4) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+  {
+    RowMajorMatrix a = RowMajorMatrix::Random(6, 5);
+    ColMajorMatrix b = ColMajorMatrix::Random(6, 7);
+    RowMajorMatrix result = hcat(a, b);
+    RowMajorMatrix expected(6, 12);
+    expected.leftCols(5) = a;
+    expected.rightCols(7) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+
+  // Fixed-size RowMajor
+  {
+    FixedRowMajor33 a = FixedRowMajor33::Random();
+    FixedRowMajor33 b = FixedRowMajor33::Random();
+    ColMajorMatrix result = vcat(a, b);
+    VERIFY_IS_EQUAL(result.rows(), 6);
+    VERIFY_IS_EQUAL(result.cols(), 3);
+    ColMajorMatrix expected(6, 3);
+    expected.topRows(3) = a;
+    expected.bottomRows(3) = b;
+    VERIFY_IS_APPROX(expected, result);
+  }
+}
+
+// ============================================================================
+// Test 13: Self-concatenation and aliasing
+// ============================================================================
+template <typename Scalar>
+void test_concat_self() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+
+  // Self-concat: vcat(a, a)
+  {
+    MatrixX a = MatrixX::Random(3, 4);
+    MatrixX result = vcat(a, a);
+    VERIFY_IS_EQUAL(result.rows(), 6);
+    VERIFY_IS_EQUAL(result.cols(), 4);
+    VERIFY_IS_APPROX(result.topRows(3), a);
+    VERIFY_IS_APPROX(result.bottomRows(3), a);
+  }
+
+  // Self-concat: hcat(a, a)
+  {
+    MatrixX a = MatrixX::Random(3, 4);
+    MatrixX result = hcat(a, a);
+    VERIFY_IS_EQUAL(result.rows(), 3);
+    VERIFY_IS_EQUAL(result.cols(), 8);
+    VERIFY_IS_APPROX(result.leftCols(4), a);
+    VERIFY_IS_APPROX(result.rightCols(4), a);
+  }
+
+  // Self-concat vector
+  {
+    VectorX v = VectorX::Random(5);
+    VectorX result = vcat(v, v);
+    VERIFY_IS_EQUAL(result.rows(), 10);
+    VERIFY_IS_APPROX(result.head(5), v);
+    VERIFY_IS_APPROX(result.tail(5), v);
+  }
+
+  // Concat with self-expression: vcat(a, a.transpose().transpose())
+  {
+    MatrixX a = MatrixX::Random(3, 4);
+    MatrixX result = vcat(a, a + MatrixX::Zero(3, 4));
+    VERIFY_IS_EQUAL(result.rows(), 6);
+    VERIFY_IS_APPROX(result.topRows(3), a);
+    VERIFY_IS_APPROX(result.bottomRows(3), a);
+  }
+}
+
+// ============================================================================
+// Test 14: Runtime assertion for mismatched dimensions
+// ============================================================================
+template <typename Scalar>
+void test_concat_mismatched_dimensions() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+
+  MatrixX a(3, 4);
+  MatrixX b(3, 5);
+  VERIFY_RAISES_ASSERT(vcat(a, b));  // cols don't match
+
+  MatrixX c(3, 4);
+  MatrixX d(2, 4);
+  VERIFY_RAISES_ASSERT(hcat(c, d));  // rows don't match
+}
+
+// ============================================================================
+// Test 15: packetSegment path — covers tail of linear vectorized assignment.
+//
+// Regression: evaluator<Concat> originally provided packet() but not
+// packetSegment(), so AssignEvaluator's tail loop failed to compile on AVX/
+// AVX-512 (where has_packet_segment<PacketN> is true). This test exercises:
+//   - sizes that are NOT a multiple of the packet width (forces tail loop)
+//   - col-major vertical concat with lhs.rows not a multiple of packetSize
+//     (forces boundary straddle on the main packet loop)
+//   - row-major horizontal concat with lhs.cols not a multiple of packetSize
+//     (same, along inner=cols)
+//   - chained concat where the inner Concat itself serves as lhs/rhs
+// ============================================================================
+template <typename Scalar>
+void test_concat_packet_segment() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMajorMatrix;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+
+  // Sweep sizes chosen to exercise: inside-lhs, straddle-boundary, inside-rhs
+  // for every packet-width scenario (float: 4/8/16, double: 2/4/8).
+  for (int lhsInner : {1, 2, 3, 5, 7, 9, 11, 13, 15, 17}) {
+    // Horizontal, col-major: inner=rows — packet extends along rows —
+    // never crosses col boundary. Verifies non-straddle path still works.
+    {
+      MatrixX a = MatrixX::Random(lhsInner, 3);
+      MatrixX b = MatrixX::Random(lhsInner, 5);
+      MatrixX result = hcat(a, b);
+      VERIFY_IS_EQUAL(result.rows(), lhsInner);
+      VERIFY_IS_EQUAL(result.cols(), 8);
+      VERIFY_IS_APPROX(result.leftCols(3), a);
+      VERIFY_IS_APPROX(result.rightCols(5), b);
+    }
+
+    for (int rhsInner : {1, 2, 3, 5, 7, 9, 11}) {
+      const int outer = 3;
+
+      // Vertical, col-major: inner=rows, packet extends along rows —
+      // may straddle the row boundary at m_lhsRows.
+      {
+        MatrixX a = MatrixX::Random(lhsInner, outer);
+        MatrixX b = MatrixX::Random(rhsInner, outer);
+        MatrixX result = vcat(a, b);
+        VERIFY_IS_EQUAL(result.rows(), lhsInner + rhsInner);
+        VERIFY_IS_EQUAL(result.cols(), outer);
+        VERIFY_IS_APPROX(result.topRows(lhsInner), a);
+        VERIFY_IS_APPROX(result.bottomRows(rhsInner), b);
+      }
+
+      // Horizontal, row-major: inner=cols, packet extends along cols —
+      // may straddle the col boundary at m_lhsCols.
+      {
+        RowMajorMatrix a = RowMajorMatrix::Random(outer, lhsInner);
+        RowMajorMatrix b = RowMajorMatrix::Random(outer, rhsInner);
+        RowMajorMatrix result = hcat(a, b);
+        VERIFY_IS_EQUAL(result.rows(), outer);
+        VERIFY_IS_EQUAL(result.cols(), lhsInner + rhsInner);
+        VERIFY_IS_APPROX(result.leftCols(lhsInner), a);
+        VERIFY_IS_APPROX(result.rightCols(rhsInner), b);
+      }
+    }
+  }
+
+  // Linear-access path: vcat of column vectors exposes LinearAccessBit,
+  // so assignment goes through packetSegment(index, begin, count).
+  for (int lhsLen : {1, 3, 5, 7, 9, 15, 17, 31, 33}) {
+    for (int rhsLen : {1, 2, 4, 8, 11}) {
+      VectorX a = VectorX::Random(lhsLen);
+      VectorX b = VectorX::Random(rhsLen);
+      VectorX result = vcat(a, b);
+      VERIFY_IS_EQUAL(result.size(), lhsLen + rhsLen);
+      VERIFY_IS_APPROX(result.head(lhsLen), a);
+      VERIFY_IS_APPROX(result.tail(rhsLen), b);
+    }
+  }
+
+  // Chained concat — packetSegment delegated through multiple Concat layers.
+  {
+    VectorX a = VectorX::Random(5);
+    VectorX b = VectorX::Random(7);
+    VectorX c = VectorX::Random(3);
+    VectorX result = vcat(vcat(a, b), c);
+    VERIFY_IS_EQUAL(result.size(), 15);
+    VERIFY_IS_APPROX(result.segment(0, 5), a);
+    VERIFY_IS_APPROX(result.segment(5, 7), b);
+    VERIFY_IS_APPROX(result.segment(12, 3), c);
+  }
+}
+
+EIGEN_DECLARE_TEST(concat) {
+  for (int i = 0; i < g_repeat; i++) {
+    // Dynamic-size matrix concat
+    CALL_SUBTEST_1(test_concat_dynamic(MatrixXf(4, 3)));
+    CALL_SUBTEST_1(test_concat_dynamic(MatrixXd(5, 7)));
+    CALL_SUBTEST_1(test_concat_dynamic(MatrixXcf(3, 4)));
+
+    // Expression inputs
+    CALL_SUBTEST_2(test_concat_with_expressions(MatrixXf(4, 3)));
+    CALL_SUBTEST_2(test_concat_with_expressions(MatrixXd(5, 7)));
+
+    // Fixed-size concat with compile-time dimension checks
+    CALL_SUBTEST_3((test_vcat_fixed<float, 2, 3, 4>()));   // vcat: 2x3 + 4x3
+    CALL_SUBTEST_3((test_hcat_fixed<double, 3, 2, 5>()));  // hcat: 3x2 + 3x5
+    CALL_SUBTEST_3((test_vcat_fixed<float, 4, 4, 4>()));   // square vcat: 4x4 + 4x4
+    CALL_SUBTEST_3((test_hcat_fixed<float, 4, 4, 4>()));   // square hcat: 4x4 + 4x4
+
+    // Mixed fixed/dynamic
+    CALL_SUBTEST_4(test_concat_mixed_fixed_dynamic<float>());
+    CALL_SUBTEST_4(test_concat_mixed_fixed_dynamic<double>());
+
+    // Rvalue temporaries (lifetime safety)
+    CALL_SUBTEST_5(test_concat_rvalue_temporaries<float>());
+    CALL_SUBTEST_5(test_concat_rvalue_temporaries<double>());
+
+    // Chained concat (binary API)
+    CALL_SUBTEST_6(test_concat_chained<float>());
+    CALL_SUBTEST_6(test_concat_chained<double>());
+
+    // Vector concat
+    CALL_SUBTEST_7(test_concat_vectors<float>());
+    CALL_SUBTEST_7(test_concat_vectors<double>());
+
+    // Array concat (XprKind propagation)
+    CALL_SUBTEST_8(test_concat_array<float>());
+    CALL_SUBTEST_8(test_concat_array<double>());
+
+    // Coefficient-level access
+    CALL_SUBTEST_9(test_concat_coeff_access<float>());
+    CALL_SUBTEST_9(test_concat_coeff_access<double>());
+
+    // Integration with other Eigen operations
+    CALL_SUBTEST_10(test_concat_in_expressions<float>());
+    CALL_SUBTEST_10(test_concat_in_expressions<double>());
+
+    // Single row/column edge cases
+    CALL_SUBTEST_11(test_concat_single_row_col<float>());
+    CALL_SUBTEST_11(test_concat_single_row_col<double>());
+
+    // RowMajor matrices
+    CALL_SUBTEST_12(test_concat_row_major<float>());
+    CALL_SUBTEST_12(test_concat_row_major<double>());
+
+    // Self-concatenation and aliasing
+    CALL_SUBTEST_13(test_concat_self<float>());
+    CALL_SUBTEST_13(test_concat_self<double>());
+
+    // Runtime assertion for mismatched dimensions
+    CALL_SUBTEST_14(test_concat_mismatched_dimensions<float>());
+    CALL_SUBTEST_14(test_concat_mismatched_dimensions<double>());
+
+    // Packet segment tail path (AVX/AVX-512 has_packet_segment)
+    CALL_SUBTEST_15(test_concat_packet_segment<float>());
+    CALL_SUBTEST_15(test_concat_packet_segment<double>());
+  }
+}
diff --git a/test/condition_estimator.cpp b/test/condition_estimator.cpp
index ce65f6e..7f18bae 100644
--- a/test/condition_estimator.cpp
+++ b/test/condition_estimator.cpp
@@ -6,14 +6,11 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Dense>
-
-template <typename MatrixType>
-typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
-  return m.cwiseAbs().colwise().sum().maxCoeff();
-}
+#include "solverbase.h"
 
 template <typename MatrixType>
 void rcond_partial_piv_lu() {
diff --git a/test/conjugate_gradient.cpp b/test/conjugate_gradient.cpp
index 87e1f8c..dc0c782 100644
--- a/test/conjugate_gradient.cpp
+++ b/test/conjugate_gradient.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 #include <Eigen/IterativeLinearSolvers>
@@ -26,8 +27,40 @@
   CALL_SUBTEST(check_sparse_spd_solving(cg_colmajor_upper_I));
 }
 
+// Regression for issue #1704: default-constructing an iterative solver
+// templated on a fixed-size MatrixType tripped a resize(0,0) size assertion.
+template <typename MatrixType>
+void test_default_construct_fixed_size() {
+  ConjugateGradient<MatrixType> cg;
+  BiCGSTAB<MatrixType> bicg;
+  LeastSquaresConjugateGradient<MatrixType> lscg;
+}
+
+void test_conjugate_gradient_extreme_rhs() {
+  const Matrix2d mat = Matrix2d::Identity();
+  const Vector2d direction = (Vector2d() << 1, -1).finished();
+  ConjugateGradient<Matrix2d, Lower | Upper, IdentityPreconditioner> solver(mat);
+  solver.setTolerance(1e-12);
+
+  for (double scale : {1e-200, 1e200}) {
+    const Vector2d rhs = scale * direction;
+    const Vector2d guess = 0.5 * rhs;
+    Vector2d x = solver.solve(rhs);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+
+    x = solver.solveWithGuess(rhs, guess);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+  }
+}
+
 EIGEN_DECLARE_TEST(conjugate_gradient) {
   CALL_SUBTEST_1((test_conjugate_gradient_T<double, int>()));
   CALL_SUBTEST_2((test_conjugate_gradient_T<std::complex<double>, int>()));
   CALL_SUBTEST_3((test_conjugate_gradient_T<double, long int>()));
+  CALL_SUBTEST_4(test_default_construct_fixed_size<Matrix3d>());
+  CALL_SUBTEST_5(test_conjugate_gradient_extreme_rhs());
 }
diff --git a/test/conservative_resize.cpp b/test/conservative_resize.cpp
index 73e34a6..d4a2651 100644
--- a/test/conservative_resize.cpp
+++ b/test/conservative_resize.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/constexpr.cpp b/test/constexpr.cpp
index 5eb462e..98687aa 100644
--- a/test/constexpr.cpp
+++ b/test/constexpr.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_TESTING_CONSTEXPR
 #include "main.h"
@@ -17,6 +18,20 @@
   Matrix<Scalar, Rows, Rows> A;
 };
 
+template <typename Scalar, int Rows>
+struct ConstexprArrayTest {
+  constexpr ConstexprArrayTest(const Array<Scalar, Rows, Rows>& B) { A = B; }
+
+  Array<Scalar, Rows, Rows> A;
+};
+
+template <typename Scalar, int Rows>
+struct ConstexprArrayMoveTest {
+  constexpr ConstexprArrayMoveTest(Array<Scalar, Rows, Rows> B) { A = std::move(B); }
+
+  Array<Scalar, Rows, Rows> A;
+};
+
 EIGEN_DECLARE_TEST(constexpr) {
   // Clang accepts (some of) this code when using C++14/C++17, but GCC does not like
   // the fact that `T array[Size]` inside Eigen::internal::plain_array is not initialized
@@ -52,6 +67,16 @@
   static_assert(obj2.A(0) == 1);
   static_assert(obj2.A.coeff(0, 1) == 2);
 
+  constexpr ConstexprArrayTest<double, 2> arr_obj1(Array22d({{1, 2}, {3, 4}}));
+  VERIFY_IS_EQUAL(arr_obj1.A.size(), 4);
+  static_assert(arr_obj1.A(0, 0) == 1);
+  static_assert(arr_obj1.A(0) == 1);
+  static_assert(arr_obj1.A.coeff(0, 1) == 2);
+
+  constexpr ConstexprArrayMoveTest<double, 2> arr_move_obj(Array22d({{1, 2}, {3, 4}}));
+  static_assert(arr_move_obj.A(0, 0) == 1);
+  static_assert(arr_move_obj.A.coeff(0, 1) == 2);
+
   // Also check dynamic size arrays/matrices with fixed-size storage (currently
   // only works if all elements are initialized, since otherwise the compiler
   // complains about uninitialized trailing elements.
@@ -101,3 +126,21 @@
   static_assert(global_mat.coeff(0, 0) == 1);
 }
 #endif  // __cpp_constexpr >= 201907L
+
+// Check that preprocessor correctly parses and expands EIGEN_IF_CONSTEXPR arguments containing commas
+EIGEN_DECLARE_TEST(constexpr_if) {
+  int true_branch_executed = 0;
+  int false_branch_executed = 0;
+  EIGEN_IF_CONSTEXPR (std::is_same<int, int>::value) {
+    true_branch_executed++;
+  } else {
+    false_branch_executed++;
+  }
+  EIGEN_IF_CONSTEXPR (std::is_same<int, float>::value) {
+    true_branch_executed++;
+  } else {
+    false_branch_executed++;
+  }
+  VERIFY_IS_EQUAL(true_branch_executed, 1);
+  VERIFY_IS_EQUAL(false_branch_executed, 1);
+}
\ No newline at end of file
diff --git a/test/constructor.cpp b/test/constructor.cpp
index fb125c4..263cc5f 100644
--- a/test/constructor.cpp
+++ b/test/constructor.cpp
@@ -6,10 +6,86 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 
 #include "main.h"
+#include "random_for_arithmetic.h"
+
+struct AssignableScalar {
+  double value = 0;
+  AssignableScalar& operator=(double x) {
+    value = x;
+    return *this;
+  }
+};
+
+struct ConvertingReturnValue;
+namespace Eigen {
+template <typename BinaryOp>
+struct ScalarBinaryOpTraits<AssignableScalar, double, BinaryOp> {
+  using ReturnType = AssignableScalar;
+};
+namespace internal {
+template <>
+struct traits<ConvertingReturnValue> {
+  using ReturnType = Vector3d;
+};
+}  // namespace internal
+}  // namespace Eigen
+
+struct ConvertingReturnValue : ReturnByValue<ConvertingReturnValue> {
+  Index rows() const { return 3; }
+  Index cols() const { return 1; }
+  template <typename Destination>
+  void evalTo(Destination& dst) const {
+    dst.setConstant(7);
+  }
+};
+
+bool selects_matrix(const Matrix3d&) { return true; }
+bool selects_matrix(const Array<double, 3, 3>&) { return false; }
+
+void implicit_matrix_construction() {
+  static_assert(!std::is_convertible<Vector3d, Vector3i>::value, "Mixed scalars require an explicit cast");
+  static_assert(!std::is_convertible<Vector3cd, Vector3d>::value,
+                "Complex coefficients cannot be assigned to real ones");
+  const Vector3d source(1, 2, 3);
+  const Vector3d expression = source + source;
+  VERIFY_IS_EQUAL(expression, 2 * source);
+  const Vector3i cast = source.cast<int>();
+  VERIFY_IS_EQUAL(cast, Vector3i(1, 2, 3));
+  const Vector3cd complex = source;
+  VERIFY_IS_EQUAL(complex.real(), source);
+  const Matrix<AssignableScalar, 3, 1> custom = source;
+  for (Index i = 0; i < source.size(); ++i) VERIFY_IS_EQUAL(custom(i).value, source(i));
+  const ConvertingReturnValue value;
+  const Vector3i converted = value;
+  VERIFY_IS_EQUAL(converted, Vector3i::Constant(7));
+  const EigenBase<ReturnByValue<ConvertingReturnValue>>& base = value;
+  const Vector3i converted_base = base;
+  VERIFY_IS_EQUAL(converted_base, converted);
+  PermutationMatrix<3> permutation;
+  permutation.setIdentity();
+  const Matrix3d identity = permutation;
+  VERIFY_IS_EQUAL(identity, Matrix3d::Identity());
+  static_assert(!std::is_convertible<PermutationMatrix<3>, Array<double, 3, 3>>::value,
+                "Permutations must not become implicit Array conversion candidates");
+  VERIFY(selects_matrix(permutation));
+
+  static_assert(!std::is_convertible<Array3d, Array3i>::value, "Mixed scalars require an explicit cast");
+  static_assert(!std::is_convertible<Array3cd, Array3d>::value, "Complex coefficients cannot be assigned to real ones");
+  const Array3d array_source = source.array();
+  const Array3i array_cast = array_source.cast<int>();
+  VERIFY((array_cast == cast.array()).all());
+  const Array3cd array_complex = array_source;
+  VERIFY((array_complex.real() == array_source).all());
+  const Array<AssignableScalar, 3, 1> array_custom = array_source;
+  for (Index i = 0; i < source.size(); ++i) VERIFY_IS_EQUAL(array_custom(i).value, source(i));
+  const Array3i array_converted = base;
+  VERIFY((array_converted == converted.array()).all());
+}
 
 template <typename MatrixType>
 struct Wrapper {
@@ -27,7 +103,7 @@
   Index rows = m.rows();
   Index cols = m.cols();
 
-  MatrixType m0 = MatrixType::Random(rows, cols);
+  MatrixType m0 = random_for_arithmetic<MatrixType>(rows, cols);
 
   VERIFY_EVALUATION_COUNT(MatrixType m1(m0), 1);
   VERIFY_EVALUATION_COUNT(MatrixType m2(m0 + m0), 1);
@@ -38,6 +114,7 @@
 }
 
 EIGEN_DECLARE_TEST(constructor) {
+  CALL_SUBTEST_1(implicit_matrix_construction());
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(ctor_init1(Matrix<float, 1, 1>()));
     CALL_SUBTEST_1(ctor_init1(Matrix4d()));
diff --git a/test/constructor_variant.cpp b/test/constructor_variant.cpp
new file mode 100644
index 0000000..aa7395f
--- /dev/null
+++ b/test/constructor_variant.cpp
@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <variant>
+
+EIGEN_DECLARE_TEST(constructor_variant) {
+  PermutationMatrix<3> permutation;
+  permutation.setIdentity();
+  std::variant<Matrix3d, Array<double, 3, 3>> permutation_variant(permutation);
+  VERIFY_IS_EQUAL(permutation_variant.index(), std::size_t(0));
+  VERIFY_IS_EQUAL(std::get<Matrix3d>(permutation_variant), Matrix3d::Identity());
+  std::variant<Array<double, 3, 3>, Matrix3d> permutation_reversed(permutation);
+  VERIFY_IS_EQUAL(permutation_reversed.index(), std::size_t(1));
+  permutation.indices() << 2, 0, 1;
+  permutation_variant = permutation;
+  VERIFY_IS_EQUAL(std::get<Matrix3d>(permutation_variant), Matrix3d(permutation));
+
+  const Array3d array_source(1, 2, 3);
+  const Array3i array_integers(1, 2, 3);
+  static_assert(!std::is_convertible<Array3d, Array3i>::value, "Mixed scalars require an explicit cast");
+  static_assert(!std::is_convertible<Array3cd, Array3d>::value, "Complex-to-real requires an explicit cast");
+  std::variant<Array3d, Array3i> array_variant(array_source);
+  VERIFY_IS_EQUAL(array_variant.index(), std::size_t(0));
+  VERIFY((std::get<Array3d>(array_variant) == array_source).all());
+  array_variant = array_integers;
+  VERIFY((std::get<Array3i>(array_variant) == array_integers).all());
+  std::variant<Array3i, Array3d> array_reversed(array_source);
+  VERIFY((std::get<Array3d>(array_reversed) == array_source).all());
+  std::variant<ArrayXd, ArrayXi> array_dynamic(array_source + array_source);
+  VERIFY((std::get<ArrayXd>(array_dynamic) == 2 * array_source).all());
+  const Array3cd array_complex = array_source.cast<std::complex<double>>() * std::complex<double>(1, 2);
+  std::variant<Array3d, Array3cd> array_complex_variant(array_complex);
+  VERIFY((std::get<Array3cd>(array_complex_variant) == array_complex).all());
+  array_complex_variant = array_source;
+  VERIFY((std::get<Array3d>(array_complex_variant) == array_source).all());
+  std::variant<Array3cd, Array3d> array_complex_reversed(array_complex);
+  VERIFY((std::get<Array3cd>(array_complex_reversed) == array_complex).all());
+  std::variant<ArrayXd, ArrayXcd> array_complex_expression(array_complex + array_complex);
+  VERIFY((std::get<ArrayXcd>(array_complex_expression) == 2 * array_complex).all());
+  array_complex_expression = array_complex + array_complex;
+  VERIFY((std::get<ArrayXcd>(array_complex_expression) == 2 * array_complex).all());
+
+  const Vector3d source(1, 2, 3);
+  const Vector3i integers(1, 2, 3);
+  std::variant<Vector3d, Vector3i> variant(source);
+  VERIFY_IS_EQUAL(variant.index(), std::size_t(0));
+  VERIFY_IS_EQUAL(std::get<Vector3d>(variant), source);
+  variant = integers;
+  VERIFY_IS_EQUAL(std::get<Vector3i>(variant), integers);
+  std::variant<Vector3i, Vector3d> reversed(source);
+  VERIFY_IS_EQUAL(std::get<Vector3d>(reversed), source);
+  std::variant<VectorXd, VectorXi> dynamic(source + source);
+  VERIFY_IS_EQUAL(std::get<VectorXd>(dynamic), 2 * source);
+
+  const Vector3cd complex = source.cast<std::complex<double>>() * std::complex<double>(1, 2);
+  std::variant<Vector3d, Vector3cd> complex_variant(complex);
+  VERIFY_IS_EQUAL(std::get<Vector3cd>(complex_variant), complex);
+  complex_variant = source;
+  VERIFY_IS_EQUAL(std::get<Vector3d>(complex_variant), source);
+  complex_variant = complex;
+  VERIFY_IS_EQUAL(std::get<Vector3cd>(complex_variant), complex);
+  std::variant<Vector3cd, Vector3d> complex_reversed(complex);
+  VERIFY_IS_EQUAL(std::get<Vector3cd>(complex_reversed), complex);
+  std::variant<VectorXd, VectorXcd> complex_expression(complex + complex);
+  VERIFY_IS_EQUAL(std::get<VectorXcd>(complex_expression), 2 * complex);
+  complex_expression = complex + complex;
+  VERIFY_IS_EQUAL(std::get<VectorXcd>(complex_expression), 2 * complex);
+}
diff --git a/test/corners.cpp b/test/corners.cpp
index 8bbb3f8..c045d19 100644
--- a/test/corners.cpp
+++ b/test/corners.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/ctorleak.cpp b/test/ctorleak.cpp
index eb25897..77b5b8d 100644
--- a/test/ctorleak.cpp
+++ b/test/ctorleak.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include "main.h"
 
 #include <exception>  // std::exception
diff --git a/test/denseLM.cpp b/test/denseLM.cpp
deleted file mode 100644
index 471e946..0000000
--- a/test/denseLM.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
-// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-
-#include "main.h"
-#include <Eigen/LevenbergMarquardt>
-using namespace std;
-using namespace Eigen;
-
-template <typename Scalar>
-struct DenseLM : DenseFunctor<Scalar> {
-  typedef DenseFunctor<Scalar> Base;
-  typedef typename Base::JacobianType JacobianType;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-
-  DenseLM(int n, int m) : DenseFunctor<Scalar>(n, m) {}
-
-  VectorType model(const VectorType& uv, VectorType& x) {
-    VectorType y;  // Should change to use expression template
-    int m = Base::values();
-    int n = Base::inputs();
-    eigen_assert(uv.size() % 2 == 0);
-    eigen_assert(uv.size() == n);
-    eigen_assert(x.size() == m);
-    y.setZero(m);
-    int half = n / 2;
-    VectorBlock<const VectorType> u(uv, 0, half);
-    VectorBlock<const VectorType> v(uv, half, half);
-    for (int j = 0; j < m; j++) {
-      for (int i = 0; i < half; i++) y(j) += u(i) * std::exp(-(x(j) - i) * (x(j) - i) / (v(i) * v(i)));
-    }
-    return y;
-  }
-  void initPoints(VectorType& uv_ref, VectorType& x) {
-    m_x = x;
-    m_y = this->model(uv_ref, x);
-  }
-
-  int operator()(const VectorType& uv, VectorType& fvec) {
-    int m = Base::values();
-    int n = Base::inputs();
-    eigen_assert(uv.size() % 2 == 0);
-    eigen_assert(uv.size() == n);
-    eigen_assert(fvec.size() == m);
-    int half = n / 2;
-    VectorBlock<const VectorType> u(uv, 0, half);
-    VectorBlock<const VectorType> v(uv, half, half);
-    for (int j = 0; j < m; j++) {
-      fvec(j) = m_y(j);
-      for (int i = 0; i < half; i++) {
-        fvec(j) -= u(i) * std::exp(-(m_x(j) - i) * (m_x(j) - i) / (v(i) * v(i)));
-      }
-    }
-
-    return 0;
-  }
-  int df(const VectorType& uv, JacobianType& fjac) {
-    int m = Base::values();
-    int n = Base::inputs();
-    eigen_assert(n == uv.size());
-    eigen_assert(fjac.rows() == m);
-    eigen_assert(fjac.cols() == n);
-    int half = n / 2;
-    VectorBlock<const VectorType> u(uv, 0, half);
-    VectorBlock<const VectorType> v(uv, half, half);
-    for (int j = 0; j < m; j++) {
-      for (int i = 0; i < half; i++) {
-        fjac.coeffRef(j, i) = -std::exp(-(m_x(j) - i) * (m_x(j) - i) / (v(i) * v(i)));
-        fjac.coeffRef(j, i + half) = -2. * u(i) * (m_x(j) - i) * (m_x(j) - i) / (std::pow(v(i), 3)) *
-                                     std::exp(-(m_x(j) - i) * (m_x(j) - i) / (v(i) * v(i)));
-      }
-    }
-    return 0;
-  }
-  VectorType m_x, m_y;  // Data Points
-};
-
-template <typename FunctorType, typename VectorType>
-int test_minimizeLM(FunctorType& functor, VectorType& uv) {
-  LevenbergMarquardt<FunctorType> lm(functor);
-  LevenbergMarquardtSpace::Status info;
-
-  info = lm.minimize(uv);
-
-  VERIFY_IS_EQUAL(info, 1);
-  // FIXME Check other parameters
-  return info;
-}
-
-template <typename FunctorType, typename VectorType>
-int test_lmder(FunctorType& functor, VectorType& uv) {
-  typedef typename VectorType::Scalar Scalar;
-  LevenbergMarquardtSpace::Status info;
-  LevenbergMarquardt<FunctorType> lm(functor);
-  info = lm.lmder1(uv);
-
-  VERIFY_IS_EQUAL(info, 1);
-  // FIXME Check other parameters
-  return info;
-}
-
-template <typename FunctorType, typename VectorType>
-int test_minimizeSteps(FunctorType& functor, VectorType& uv) {
-  LevenbergMarquardtSpace::Status info;
-  LevenbergMarquardt<FunctorType> lm(functor);
-  info = lm.minimizeInit(uv);
-  if (info == LevenbergMarquardtSpace::ImproperInputParameters) return info;
-  do {
-    info = lm.minimizeOneStep(uv);
-  } while (info == LevenbergMarquardtSpace::Running);
-
-  VERIFY_IS_EQUAL(info, 1);
-  // FIXME Check other parameters
-  return info;
-}
-
-template <typename T>
-void test_denseLM_T() {
-  typedef Matrix<T, Dynamic, 1> VectorType;
-
-  int inputs = 10;
-  int values = 1000;
-  DenseLM<T> dense_gaussian(inputs, values);
-  VectorType uv(inputs), uv_ref(inputs);
-  VectorType x(values);
-
-  // Generate the reference solution
-  uv_ref << -2, 1, 4, 8, 6, 1.8, 1.2, 1.1, 1.9, 3;
-
-  // Generate the reference data points
-  x.setRandom();
-  x = 10 * x;
-  x.array() += 10;
-  dense_gaussian.initPoints(uv_ref, x);
-
-  // Generate the initial parameters
-  VectorBlock<VectorType> u(uv, 0, inputs / 2);
-  VectorBlock<VectorType> v(uv, inputs / 2, inputs / 2);
-
-  // Solve the optimization problem
-
-  // Solve in one go
-  u.setOnes();
-  v.setOnes();
-  test_minimizeLM(dense_gaussian, uv);
-
-  // Solve until the machine precision
-  u.setOnes();
-  v.setOnes();
-  test_lmder(dense_gaussian, uv);
-
-  // Solve step by step
-  v.setOnes();
-  u.setOnes();
-  test_minimizeSteps(dense_gaussian, uv);
-}
-
-EIGEN_DECLARE_TEST(denseLM) {
-  CALL_SUBTEST_2(test_denseLM_T<double>());
-
-  // CALL_SUBTEST_2(test_sparseLM_T<std::complex<double>());
-}
diff --git a/test/dense_storage.cpp b/test/dense_storage.cpp
index d394a94..898ed89 100644
--- a/test/dense_storage.cpp
+++ b/test/dense_storage.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_TESTING_PLAINOBJECT_CTOR
 
@@ -202,12 +203,12 @@
   constexpr int ColsAtCompileTime = PlainType::ColsAtCompileTime;
   constexpr int MaxRowsAtCompileTime = PlainType::MaxRowsAtCompileTime;
   constexpr int MaxColsAtCompileTime = PlainType::MaxColsAtCompileTime;
-  const Index expectedDefaultRows = RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime;
-  const Index expectedDefaultCols = ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime;
-  const Index minRows = RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime;
-  const Index minCols = ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime;
-  const Index maxRows = MaxRowsAtCompileTime == Dynamic ? 100 : MaxRowsAtCompileTime;
-  const Index maxCols = MaxColsAtCompileTime == Dynamic ? 100 : MaxColsAtCompileTime;
+  constexpr Index expectedDefaultRows = RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime;
+  constexpr Index expectedDefaultCols = ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime;
+  constexpr Index minRows = RowsAtCompileTime == Dynamic ? 0 : RowsAtCompileTime;
+  constexpr Index minCols = ColsAtCompileTime == Dynamic ? 0 : ColsAtCompileTime;
+  constexpr Index maxRows = MaxRowsAtCompileTime == Dynamic ? 100 : MaxRowsAtCompileTime;
+  constexpr Index maxCols = MaxColsAtCompileTime == Dynamic ? 100 : MaxColsAtCompileTime;
   const Index rows = internal::random<Index>(minRows, maxRows);
   const Index cols = internal::random<Index>(minCols, maxCols);
   // default construction
@@ -282,4 +283,4 @@
   }
 }
 
-#undef EIGEN_TESTING_PLAINOBJECT_CTOR
\ No newline at end of file
+#undef EIGEN_TESTING_PLAINOBJECT_CTOR
diff --git a/test/determinant.cpp b/test/determinant.cpp
index 0f2d4f8..741a7f4 100644
--- a/test/determinant.cpp
+++ b/test/determinant.cpp
@@ -7,9 +7,116 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/LU>
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+template <typename Scalar>
+struct determinant_reference_scalar {
+  typedef long double type;
+};
+
+template <typename RealScalar>
+struct determinant_reference_scalar<std::complex<RealScalar> > {
+  typedef std::complex<long double> type;
+};
+
+template <typename MatrixType>
+typename determinant_reference_scalar<typename MatrixType::Scalar>::type brute_force_determinant(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename determinant_reference_scalar<Scalar>::type ReferenceScalar;
+  const Index size = m.rows();
+  std::vector<Index> permutation(size);
+  for (Index i = 0; i < size; ++i) permutation[i] = i;
+
+  ReferenceScalar result(0);
+  do {
+    int inversions = 0;
+    for (Index i = 0; i < size; ++i)
+      for (Index j = i + 1; j < size; ++j)
+        if (permutation[i] > permutation[j]) ++inversions;
+
+    ReferenceScalar term(1);
+    for (Index i = 0; i < size; ++i) term *= ReferenceScalar(m(i, permutation[i]));
+    result += inversions % 2 ? -term : term;
+  } while (std::next_permutation(permutation.begin(), permutation.end()));
+
+  return result;
+}
+
+template <typename MatrixType>
+void verify_determinant_against_reference(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  Scalar expected = Scalar(brute_force_determinant(m));
+  Scalar actual = m.determinant();
+  const RealScalar max_abs = (std::max)(RealScalar(1), m.cwiseAbs().maxCoeff());
+  RealScalar scale = max_abs;
+  for (Index i = 1; i < m.rows(); ++i) scale *= max_abs;
+  RealScalar tolerance = RealScalar(100000) * NumTraits<RealScalar>::epsilon() * scale;
+  RealScalar error = numext::abs(actual - expected);
+  if (error > tolerance) std::cerr << "determinant error " << error << " exceeds tolerance " << tolerance << std::endl;
+  VERIFY(error <= tolerance);
+}
+
+template <typename MatrixType>
+void determinant_lu_fallback_reference(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index size = m.rows();
+
+  MatrixType random(size, size);
+  random.setRandom();
+  verify_determinant_against_reference(random);
+
+  MatrixType ill_conditioned = random;
+  ill_conditioned.col(0) = ill_conditioned.col(1) + RealScalar(1e-8) * ill_conditioned.col(0);
+  verify_determinant_against_reference(ill_conditioned);
+
+  MatrixType scaled = RealScalar(1e6) * random;
+  verify_determinant_against_reference(scaled);
+
+  MatrixType tiny = MatrixType::Identity(size, size);
+  tiny(0, 0) = Scalar((std::numeric_limits<RealScalar>::min)());
+  verify_determinant_against_reference(tiny);
+
+#if !EIGEN_ARCH_ARM
+  MatrixType subnormal = MatrixType::Identity(size, size);
+  subnormal(0, 0) = Scalar(std::numeric_limits<RealScalar>::denorm_min() * RealScalar(16));
+  verify_determinant_against_reference(subnormal);
+#endif
+}
+
+template <typename MatrixType>
+void verify_non_finite_lu_determinant(MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  m.setIdentity();
+  m(0, 0) = Scalar(std::numeric_limits<RealScalar>::quiet_NaN());
+  VERIFY((numext::isnan)(m.determinant()));
+
+  m.setIdentity();
+  m(0, 0) = Scalar(std::numeric_limits<RealScalar>::infinity());
+  VERIFY((numext::isinf)(m.determinant()));
+}
+
+void determinant_non_finite_lu_fallback() {
+  Matrix<double, 5, 5> fixed;
+  verify_non_finite_lu_determinant(fixed);
+
+  MatrixXd dynamic(5, 5);
+  verify_non_finite_lu_determinant(dynamic);
+
+  std::vector<double> storage(25);
+  Map<Matrix<double, Dynamic, Dynamic> > mapped(storage.data(), 5, 5);
+  verify_non_finite_lu_determinant(mapped);
+}
 
 template <typename MatrixType>
 void determinant(const MatrixType& m) {
@@ -57,9 +164,13 @@
     CALL_SUBTEST_2(determinant(Matrix<double, 2, 2>()));
     CALL_SUBTEST_3(determinant(Matrix<double, 3, 3>()));
     CALL_SUBTEST_4(determinant(Matrix<double, 4, 4>()));
-    CALL_SUBTEST_5(determinant(Matrix<std::complex<double>, 10, 10>()));
+    CALL_SUBTEST_5(determinant(Matrix<double, 5, 5>()));
+    CALL_SUBTEST_6(determinant(Matrix<std::complex<double>, 10, 10>()));
+    CALL_SUBTEST_7(determinant_lu_fallback_reference(Matrix<double, 5, 5>()));
+    CALL_SUBTEST_8(determinant_lu_fallback_reference(MatrixXcd(5, 5)));
+    CALL_SUBTEST_9(determinant_non_finite_lu_fallback());
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
-    CALL_SUBTEST_6(determinant(MatrixXd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    CALL_SUBTEST_10(determinant(MatrixXd(s, s)));
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 }
diff --git a/test/dgmres.cpp b/test/dgmres.cpp
new file mode 100644
index 0000000..7cfad3d
--- /dev/null
+++ b/test/dgmres.cpp
@@ -0,0 +1,150 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
+// Copyright (C) 2012 desire Nuentsa <desire.nuentsa_wakam@inria.fr
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T>
+void test_dgmres_T() {
+  DGMRES<SparseMatrix<T>, DiagonalPreconditioner<T> > dgmres_colmajor_diag;
+  DGMRES<SparseMatrix<T>, IdentityPreconditioner> dgmres_colmajor_I;
+  DGMRES<SparseMatrix<T>, IncompleteLUT<T> > dgmres_colmajor_ilut;
+  // GMRES<SparseMatrix<T>, SSORPreconditioner<T> >     dgmres_colmajor_ssor;
+
+  CALL_SUBTEST(check_sparse_square_solving(dgmres_colmajor_diag));
+  //   CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_I)     );
+  CALL_SUBTEST(check_sparse_square_solving(dgmres_colmajor_ilut));
+  // CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_ssor)     );
+}
+
+// Regression: Arnoldi breakdown used to divide by zero (producing NaN in the
+// Krylov basis) and solve a singular triangular system, silently returning
+// Inf with info() == Success. Exercise both the pathological (rank-deficient
+// pivot) and benign (exact Krylov subspace) breakdown paths.
+template <typename T>
+void test_dgmres_breakdown_T() {
+  typedef SparseMatrix<T> Mat;
+  typedef Matrix<T, 2, 1> Vec;
+
+  // Nilpotent A with singular Hessenberg pivot on the first step.
+  Mat A(2, 2);
+  A.insert(0, 1) = T(1);
+  A.makeCompressed();
+  Vec b;
+  b << T(1), T(0);
+
+  DGMRES<Mat, IdentityPreconditioner> solver;
+  solver.compute(A);
+  Vec x = solver.solve(b);
+  VERIFY(x.allFinite());
+  VERIFY(solver.info() != Success);
+
+  // Diagonal A with b in an eigenspace: Arnoldi converges after one step.
+  Mat D(2, 2);
+  D.insert(0, 0) = T(2);
+  D.insert(1, 1) = T(2);
+  D.makeCompressed();
+  Vec d;
+  d << T(2), T(2);
+
+  DGMRES<Mat, DiagonalPreconditioner<T> > solver2;
+  solver2.compute(D);
+  Vec y = solver2.solve(d);
+  VERIFY_IS_EQUAL(solver2.info(), Success);
+  VERIFY_IS_APPROX(y, (Vec() << T(1), T(1)).finished());
+}
+
+// Regression: dgmres() used m_iterations only as the iteration cap and never
+// wrote the performed count back, so iterations() returned maxIterations()
+// after every solve, however quickly it converged.
+template <typename T>
+void test_dgmres_iterations_T() {
+  using Mat = SparseMatrix<T>;
+  using DenseMat = Matrix<T, Dynamic, Dynamic>;
+  using Vec = Matrix<T, Dynamic, 1>;
+  using RealScalar = typename NumTraits<T>::Real;
+
+  // Well-conditioned tridiagonal system. Its size stays below the default
+  // restart length of 30, so a converged solve ends inside the first cycle.
+  const Index n = 20;
+  Mat A(n, n);
+  A.reserve(3 * n);
+  for (Index i = 0; i < n; ++i) {
+    if (i > 0) A.insert(i, i - 1) = T(-1);
+    A.insert(i, i) = T(4);
+    if (i + 1 < n) A.insert(i, i + 1) = T(-1);
+  }
+  A.makeCompressed();
+
+  const Index max_iters = 500;
+  // The system is well conditioned, so the true residual tracks the tolerance
+  // the solver converged to, which defaults to NumTraits<Scalar>::epsilon().
+  const RealScalar res_bound = RealScalar(64) * NumTraits<RealScalar>::epsilon();
+
+  Vec b = Vec::Constant(n, T(1));
+  DGMRES<Mat, DiagonalPreconditioner<T> > solver;
+  solver.setMaxIterations(max_iters);
+  solver.compute(A);
+  Vec x = solver.solve(b);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY(solver.iterations() > 0);
+  VERIFY(solver.iterations() < solver.maxIterations());
+  VERIFY((A * x - b).norm() <= res_bound * b.norm());
+
+  // Zero right hand side: the early return reports no iteration at all.
+  Vec zero = Vec::Zero(n);
+  Vec x0 = solver.solve(zero);
+  VERIFY(x0.isZero());
+  VERIFY_IS_EQUAL(solver.iterations(), Index(0));
+
+  // Several right hand sides: the cap is restored for every column, so a cheap
+  // first column must not throttle a costlier second one.
+  DenseMat B = DenseMat::Zero(n, 2);
+  B.col(0).setConstant(T(1));
+  B(0, 1) = T(1);
+  DGMRES<Mat, DiagonalPreconditioner<T> > multi;
+  multi.setMaxIterations(max_iters);
+  multi.compute(A);
+  DenseMat X = multi.solve(B);
+  VERIFY_IS_EQUAL(multi.info(), Success);
+  VERIFY(multi.iterations() > 0);
+  VERIFY(multi.iterations() < multi.maxIterations());
+  VERIFY((A * X - B).norm() <= res_bound * B.norm());
+
+  // Non-converging direction: GMRES stagnates on a cyclic shift matrix, so the
+  // reported count saturates at the cap and never exceeds it.
+  const Index m = 16;
+  Mat S(m, m);
+  S.reserve(m);
+  for (Index i = 0; i < m; ++i) S.insert((i + 1) % m, i) = T(1);
+  S.makeCompressed();
+  Vec e = Vec::Zero(m);
+  e(0) = T(1);
+  for (Index k = 1; k <= 3; ++k) {
+    DGMRES<Mat, IdentityPreconditioner> stalled;
+    stalled.setMaxIterations(k);
+    stalled.compute(S);
+    Vec xs = stalled.solve(e);
+    VERIFY(xs.allFinite());
+    VERIFY_IS_EQUAL(stalled.info(), NoConvergence);
+    VERIFY(stalled.iterations() <= stalled.maxIterations());
+    VERIFY_IS_EQUAL(stalled.iterations(), k);
+  }
+}
+
+EIGEN_DECLARE_TEST(dgmres) {
+  CALL_SUBTEST_1(test_dgmres_T<double>());
+  CALL_SUBTEST_2(test_dgmres_T<std::complex<double> >());
+  CALL_SUBTEST_3(test_dgmres_breakdown_T<double>());
+  CALL_SUBTEST_4(test_dgmres_breakdown_T<std::complex<double> >());
+  CALL_SUBTEST_5(test_dgmres_iterations_T<double>());
+  CALL_SUBTEST_6(test_dgmres_iterations_T<std::complex<double> >());
+}
diff --git a/test/diagonal.cpp b/test/diagonal.cpp
index e7c4bf2..8ed9ef7 100644
--- a/test/diagonal.cpp
+++ b/test/diagonal.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 
 template <typename MatrixType>
 void diagonal(const MatrixType& m) {
@@ -16,9 +18,9 @@
   Index rows = m.rows();
   Index cols = m.cols();
 
-  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols);
+  MatrixType m1 = random_for_arithmetic<MatrixType>(rows, cols), m2 = random_for_arithmetic<MatrixType>(rows, cols);
 
-  Scalar s1 = internal::random<Scalar>();
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>();
 
   // check diagonal()
   VERIFY_IS_APPROX(m1.diagonal(), m1.transpose().diagonal());
@@ -81,6 +83,34 @@
   VERIFY_RAISES_ASSERT(m1.diagonal(-(rows + 1)));
 }
 
+template <int Options, int OuterStride, int InnerStride>
+void diagonal_strided() {
+  using Mat = Matrix<int, 4, 4, Options>;
+  using StridedMap = Map<Mat, 0, Stride<OuterStride, InnerStride>>;
+  using Diag = typename StridedMap::DiagonalReturnType;
+  static_assert(Diag::InnerStrideAtCompileTime == (OuterStride == Dynamic || InnerStride == Dynamic ? Dynamic : 13),
+                "The diagonal stride must include both matrix strides");
+  VERIFY_IS_EQUAL(internal::traits<Diag>::InnerStrideAtCompileTime, Diag::InnerStrideAtCompileTime);
+  Matrix<int, 48, 1> storage = Matrix<int, 48, 1>::LinSpaced(48, 0, 47);
+  Matrix<int, 48, 1> expected = storage;
+  StridedMap matrix(storage.data() + 1, 4, 4, Stride<OuterStride, InnerStride>(11, 2));
+  for (Index offset : {Index(-2), Index(0), Index(1)}) {
+    auto diagonal = matrix.diagonal(offset);
+    VERIFY_IS_EQUAL(diagonal.innerStride(), 13);
+    Ref<Matrix<int, Dynamic, 1>, 0, Eigen::InnerStride<Dynamic>> view(diagonal);
+    for (Index i = 0; i < diagonal.size(); ++i) {
+      const Index row = i + (offset < 0 ? -offset : 0);
+      const Index col = i + (offset > 0 ? offset : 0);
+      VERIFY_IS_EQUAL(view(i), matrix(row, col));
+      const Index index = 1 + (Options == RowMajor ? row * 11 + col * 2 : row * 2 + col * 11);
+      expected(index) -= 3;
+    }
+    // A block uses the diagonal's direct-access stride rather than its coefficient accessor.
+    diagonal.head(diagonal.size()).array() -= 3;
+    VERIFY_IS_EQUAL(storage, expected);
+  }
+}
+
 // Test that (A * B).diagonal() gives the same result as (A * B).eval().diagonal().
 // The diagonal-of-product path uses LazyProduct evaluation (see ProductEvaluators.h),
 // which avoids computing the full product. Verify this optimization is correct.
@@ -95,8 +125,8 @@
     Index n = sizes[si];
     if (n <= 0) continue;
 
-    Mat A = Mat::Random(n, n);
-    Mat B = Mat::Random(n, n);
+    Mat A = random_for_arithmetic<Mat>(n, n);
+    Mat B = random_for_arithmetic<Mat>(n, n);
 
     // Lazy diagonal vs explicit product diagonal
     Vec diag_lazy = (A * B).diagonal();
@@ -106,8 +136,8 @@
     // Also test non-square: A is m×k, B is k×n
     for (int k : {1, 3, (int)n}) {
       if (k <= 0) continue;
-      Mat C = Mat::Random(n, k);
-      Mat D = Mat::Random(k, n);
+      Mat C = random_for_arithmetic<Mat>(n, k);
+      Mat D = random_for_arithmetic<Mat>(k, n);
       Vec diag_lazy2 = (C * D).diagonal();
       Vec diag_explicit2 = (C * D).eval().diagonal();
       VERIFY_IS_APPROX(diag_lazy2, diag_explicit2);
@@ -155,6 +185,14 @@
 }
 
 EIGEN_DECLARE_TEST(diagonal) {
+  CALL_SUBTEST_5((diagonal_strided<ColMajor, 11, 2>()));
+  CALL_SUBTEST_5((diagonal_strided<RowMajor, 11, 2>()));
+  CALL_SUBTEST_5((diagonal_strided<ColMajor, Dynamic, 2>()));
+  CALL_SUBTEST_5((diagonal_strided<RowMajor, Dynamic, 2>()));
+  CALL_SUBTEST_5((diagonal_strided<ColMajor, 11, Dynamic>()));
+  CALL_SUBTEST_5((diagonal_strided<RowMajor, 11, Dynamic>()));
+  CALL_SUBTEST_5((diagonal_strided<ColMajor, Dynamic, Dynamic>()));
+  CALL_SUBTEST_5((diagonal_strided<RowMajor, Dynamic, Dynamic>()));
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(diagonal(Matrix<float, 1, 1>()));
     CALL_SUBTEST_1(diagonal(Matrix<float, 4, 9>()));
diff --git a/test/diagonal_matrix_variadic_ctor.cpp b/test/diagonal_matrix_variadic_ctor.cpp
index e3e51aa..efafaf0 100644
--- a/test/diagonal_matrix_variadic_ctor.cpp
+++ b/test/diagonal_matrix_variadic_ctor.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -70,70 +71,25 @@
   {
     DiagonalMatrixX a{{}};
     VERIFY(a.rows() == 0);
-    VERIFY(a.rows() == 0);
+    VERIFY(a.cols() == 0);
     typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
     for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
   }
   {
     DiagonalMatrixX a{{raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6]}};
     VERIFY(a.rows() == 7);
-    VERIFY(a.rows() == 7);
+    VERIFY(a.cols() == 7);
     typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
     for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
   }
 }
 
-template <>
-void constructorTest<float>() {
-  typedef float Scalar;
+void implicitConversionTest() {
+  using Scalar = float;
+  using DiagonalMatrix3 = DiagonalMatrix<Scalar, 3>;
+  using DiagonalMatrix4 = DiagonalMatrix<Scalar, 4>;
+  using DiagonalMatrix5 = DiagonalMatrix<Scalar, 5>;
 
-  typedef DiagonalMatrix<Scalar, 0> DiagonalMatrix0;
-  typedef DiagonalMatrix<Scalar, 3> DiagonalMatrix3;
-  typedef DiagonalMatrix<Scalar, 4> DiagonalMatrix4;
-  typedef DiagonalMatrix<Scalar, 5> DiagonalMatrix5;
-  typedef DiagonalMatrix<Scalar, Dynamic> DiagonalMatrixX;
-
-  Scalar raw[7];
-  for (int k = 0; k < 7; ++k) raw[k] = internal::random<Scalar>();
-
-  // Fixed-sized matrices
-  {
-    DiagonalMatrix0 a{{}};
-    VERIFY(a.rows() == 0);
-    VERIFY(a.cols() == 0);
-    typename DiagonalMatrix0::DenseMatrixType m = a.toDenseMatrix();
-    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
-  }
-  {
-    DiagonalMatrix3 a{{raw[0], raw[1], raw[2]}};
-    VERIFY(a.rows() == 3);
-    VERIFY(a.cols() == 3);
-    typename DiagonalMatrix3::DenseMatrixType m = a.toDenseMatrix();
-    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
-  }
-  {
-    DiagonalMatrix4 a{{raw[0], raw[1], raw[2], raw[3]}};
-    VERIFY(a.rows() == 4);
-    VERIFY(a.cols() == 4);
-    typename DiagonalMatrix4::DenseMatrixType m = a.toDenseMatrix();
-    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
-  }
-
-  // dynamically sized matrices
-  {
-    DiagonalMatrixX a{{}};
-    VERIFY(a.rows() == 0);
-    VERIFY(a.rows() == 0);
-    typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
-    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
-  }
-  {
-    DiagonalMatrixX a{{raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6]}};
-    VERIFY(a.rows() == 7);
-    VERIFY(a.rows() == 7);
-    typename DiagonalMatrixX::DenseMatrixType m = a.toDenseMatrix();
-    for (Index k = 0; k < a.rows(); ++k) VERIFY(m(k, k) == raw[k]);
-  }
   { VERIFY_IMPLICIT_CONVERSION_3(DiagonalMatrix3, 1.2647, 2.56f, -3); }
   { VERIFY_IMPLICIT_CONVERSION_4(DiagonalMatrix4, 1.2647, 2.56f, -3, 3.23f); }
   { VERIFY_IMPLICIT_CONVERSION_5(DiagonalMatrix5, 1.2647, 2.56f, -3, 3.23f, 2); }
@@ -142,9 +98,9 @@
 EIGEN_DECLARE_TEST(diagonal_matrix_variadic_ctor) {
   CALL_SUBTEST_2(constructorTest<unsigned char>());
   CALL_SUBTEST_2(constructorTest<float>());
+  CALL_SUBTEST_2(implicitConversionTest());
   CALL_SUBTEST_2(constructorTest<Index>());
   CALL_SUBTEST_2(constructorTest<int>());
   CALL_SUBTEST_2(constructorTest<long int>());
-  CALL_SUBTEST_2(constructorTest<std::ptrdiff_t>());
   CALL_SUBTEST_2(constructorTest<std::complex<double>>());
 }
diff --git a/test/diagonalmatrices.cpp b/test/diagonalmatrices.cpp
index 62450ab..12e4e78 100644
--- a/test/diagonalmatrices.cpp
+++ b/test/diagonalmatrices.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // discard stack allocation as that too bypasses malloc
 #define EIGEN_STACK_ALLOCATION_LIMIT 0
@@ -13,6 +14,9 @@
 #define EIGEN_RUNTIME_NO_MALLOC
 
 #include "main.h"
+#include <Eigen/Core>
+#include "MovableScalar.h"
+#include "random_for_arithmetic.h"
 using namespace std;
 template <typename MatrixType>
 void diagonalmatrices(const MatrixType& m) {
@@ -28,14 +32,14 @@
   Index rows = m.rows();
   Index cols = m.cols();
 
-  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols);
-  VectorType v1 = VectorType::Random(rows), v2 = VectorType::Random(rows);
-  RowVectorType rv1 = RowVectorType::Random(cols), rv2 = RowVectorType::Random(cols);
+  MatrixType m1 = random_for_arithmetic<MatrixType>(rows, cols), m2 = random_for_arithmetic<MatrixType>(rows, cols);
+  VectorType v1 = random_for_arithmetic<VectorType>(rows), v2 = random_for_arithmetic<VectorType>(rows);
+  RowVectorType rv1 = random_for_arithmetic<RowVectorType>(cols), rv2 = random_for_arithmetic<RowVectorType>(cols);
 
   LeftDiagonalMatrix ldm1(v1), ldm2(v2);
   RightDiagonalMatrix rdm1(rv1), rdm2(rv2);
 
-  Scalar s1 = internal::random<Scalar>();
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>();
 
   SquareMatrixType sq_m1(v1.asDiagonal());
   VERIFY_IS_APPROX(sq_m1, v1.asDiagonal().toDenseMatrix());
@@ -109,13 +113,13 @@
   VERIFY_IS_APPROX(m1 * (s1 * rdm1), (m1 * rdm1) * s1);
 
   // Diagonal to dense
-  sq_m1.setRandom();
+  sq_m1 = random_for_arithmetic<SquareMatrixType>(rows, rows);
   sq_m2 = sq_m1;
   VERIFY_IS_APPROX((sq_m1 += (s1 * v1).asDiagonal()), sq_m2 += (s1 * v1).asDiagonal().toDenseMatrix());
   VERIFY_IS_APPROX((sq_m1 -= (s1 * v1).asDiagonal()), sq_m2 -= (s1 * v1).asDiagonal().toDenseMatrix());
   VERIFY_IS_APPROX((sq_m1 = (s1 * v1).asDiagonal()), (s1 * v1).asDiagonal().toDenseMatrix());
 
-  sq_m1.setRandom();
+  sq_m1 = random_for_arithmetic<SquareMatrixType>(rows, rows);
   sq_m2 = v1.asDiagonal();
   sq_m2 = sq_m1 * sq_m2;
   VERIFY_IS_APPROX((sq_m1 * v1.asDiagonal()).col(i), sq_m2.col(i));
@@ -147,9 +151,9 @@
   Index rows = m.rows();
   Index depth = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
 
-  VectorType v1 = VectorType::Random(rows);
-  DynVectorType dv1 = DynVectorType::Random(depth);
-  DynRowVectorType drv1 = DynRowVectorType::Random(depth);
+  VectorType v1 = random_for_arithmetic<VectorType>(rows);
+  DynVectorType dv1 = random_for_arithmetic<DynVectorType>(depth);
+  DynRowVectorType drv1 = random_for_arithmetic<DynRowVectorType>(depth);
   DynMatrixType dm1 = dv1;
   DynMatrixType drm1 = drv1;
 
@@ -172,6 +176,410 @@
   VERIFY_IS_APPROX((res1 = points.topLeftCorner<2, 2>() * diag.asDiagonal()), res2 = tmp2 * diag.asDiagonal());
 }
 
+template <int>
+void bug2013() {
+  Matrix3d m = Matrix3d::Random();
+  Vector3d d = Vector3d::Random();
+
+  Matrix3d ref_unit_lower = m.template triangularView<UnitLower>();
+  Matrix3d ref_unit_upper = m.template triangularView<UnitUpper>();
+  Matrix3d ref_lower = m.template triangularView<Lower>();
+  Matrix3d ref_upper = m.template triangularView<Upper>();
+
+  VERIFY_IS_APPROX((m.template triangularView<UnitLower>() * d.asDiagonal()).eval(), ref_unit_lower * d.asDiagonal());
+  VERIFY_IS_APPROX((d.asDiagonal() * m.template triangularView<UnitLower>()).eval(), d.asDiagonal() * ref_unit_lower);
+
+  VERIFY_IS_APPROX((m.template triangularView<UnitUpper>() * d.asDiagonal()).eval(), ref_unit_upper * d.asDiagonal());
+  VERIFY_IS_APPROX((d.asDiagonal() * m.template triangularView<UnitUpper>()).eval(), d.asDiagonal() * ref_unit_upper);
+
+  Matrix3d actual = Matrix3d::Random();
+  Matrix3d expected = actual;
+  actual = m;
+  expected = m;
+  actual.template triangularView<Upper>() = actual.template triangularView<Upper>() * d.asDiagonal();
+  expected.template triangularView<Upper>() = Matrix3d(ref_upper * d.asDiagonal());
+  VERIFY_IS_APPROX(actual, expected);
+
+  actual = m;
+  expected = m;
+  actual.template triangularView<Lower>() = d.asDiagonal() * actual.template triangularView<Lower>();
+  expected.template triangularView<Lower>() = Matrix3d(d.asDiagonal() * ref_lower);
+  VERIFY_IS_APPROX(actual, expected);
+
+  actual.setRandom();
+  expected = actual;
+  actual.noalias() += m.template triangularView<UnitLower>() * d.asDiagonal();
+  expected.noalias() += ref_unit_lower * d.asDiagonal();
+  VERIFY_IS_APPROX(actual, expected);
+
+  actual.setRandom();
+  expected = actual;
+  actual.noalias() -= d.asDiagonal() * m.template triangularView<UnitUpper>();
+  expected.noalias() -= d.asDiagonal() * ref_unit_upper;
+  VERIFY_IS_APPROX(actual, expected);
+
+  MatrixXd dynamic_m = MatrixXd::Random(4, 4);
+  VectorXd dynamic_d = VectorXd::Random(4);
+  MatrixXd dynamic_expected(4, 4);
+  MatrixXd no_malloc_result(4, 4);
+
+  dynamic_expected = MatrixXd(dynamic_m.template triangularView<UnitLower>()) * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.noalias() = dynamic_m.template triangularView<UnitLower>() * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+
+  dynamic_expected = dynamic_d.asDiagonal() * MatrixXd(dynamic_m.template triangularView<UnitUpper>());
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.noalias() = dynamic_d.asDiagonal() * dynamic_m.template triangularView<UnitUpper>();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+
+  // Triangular destination assignment from a structured*diagonal product must go through the
+  // lazy product_evaluator and avoid materializing a full PlainObject temporary.
+  no_malloc_result = dynamic_m;
+  dynamic_expected = dynamic_m;
+  dynamic_expected.template triangularView<Upper>() =
+      MatrixXd(dynamic_m.template triangularView<Upper>()) * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.template triangularView<Upper>() =
+      dynamic_m.template triangularView<Upper>() * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+
+  no_malloc_result = dynamic_m;
+  dynamic_expected = dynamic_m;
+  dynamic_expected.template triangularView<Lower>() =
+      dynamic_d.asDiagonal() * MatrixXd(dynamic_m.template triangularView<Lower>());
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.template triangularView<Lower>() =
+      dynamic_d.asDiagonal() * dynamic_m.template triangularView<Lower>();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+}
+
+template <int>
+void selfadjoint_diagonal_products() {
+  Matrix3cd m = Matrix3cd::Random();
+  m.diagonal() = m.diagonal().real();
+  Vector3cd d = Vector3cd::Random();
+
+  Matrix3cd ref_lower = m.template selfadjointView<Lower>();
+  Matrix3cd ref_upper = m.template selfadjointView<Upper>();
+
+  VERIFY_IS_APPROX((m.template selfadjointView<Lower>() * d.asDiagonal()).eval(), ref_lower * d.asDiagonal());
+  VERIFY_IS_APPROX((d.asDiagonal() * m.template selfadjointView<Lower>()).eval(), d.asDiagonal() * ref_lower);
+
+  VERIFY_IS_APPROX((m.template selfadjointView<Upper>() * d.asDiagonal()).eval(), ref_upper * d.asDiagonal());
+  VERIFY_IS_APPROX((d.asDiagonal() * m.template selfadjointView<Upper>()).eval(), d.asDiagonal() * ref_upper);
+
+  Matrix3cd actual = Matrix3cd::Random();
+  Matrix3cd expected = actual;
+  actual = m;
+  expected = m;
+  actual.template selfadjointView<Upper>() = actual.template selfadjointView<Upper>() * d.asDiagonal();
+  expected.template triangularView<Upper>() = Matrix3cd(ref_upper * d.asDiagonal());
+  VERIFY_IS_APPROX(actual, expected);
+
+  actual = m;
+  expected = m;
+  actual.template selfadjointView<Lower>() = d.asDiagonal() * actual.template selfadjointView<Lower>();
+  expected.template triangularView<Lower>() = Matrix3cd(d.asDiagonal() * ref_lower);
+  VERIFY_IS_APPROX(actual, expected);
+
+  actual.setRandom();
+  expected = actual;
+  actual.noalias() += m.template selfadjointView<Lower>() * d.asDiagonal();
+  expected.noalias() += ref_lower * d.asDiagonal();
+  VERIFY_IS_APPROX(actual, expected);
+
+  actual.setRandom();
+  expected = actual;
+  actual.noalias() -= d.asDiagonal() * m.template selfadjointView<Upper>();
+  expected.noalias() -= d.asDiagonal() * ref_upper;
+  VERIFY_IS_APPROX(actual, expected);
+
+  MatrixXcd dynamic_m = MatrixXcd::Random(4, 4);
+  dynamic_m.diagonal() = dynamic_m.diagonal().real();
+  VectorXcd dynamic_d = VectorXcd::Random(4);
+  MatrixXcd dynamic_expected(4, 4);
+  MatrixXcd no_malloc_result(4, 4);
+
+  dynamic_expected = MatrixXcd(dynamic_m.template selfadjointView<Lower>()) * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.noalias() = dynamic_m.template selfadjointView<Lower>() * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+
+  dynamic_expected = dynamic_d.asDiagonal() * MatrixXcd(dynamic_m.template selfadjointView<Upper>());
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.noalias() = dynamic_d.asDiagonal() * dynamic_m.template selfadjointView<Upper>();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+
+  // Triangular destination assignment from selfadjoint*diagonal must use the lazy
+  // product_evaluator (with conjugate-mirror coeffs) and not materialize a temporary.
+  no_malloc_result = dynamic_m;
+  dynamic_expected = dynamic_m;
+  dynamic_expected.template triangularView<Lower>() =
+      MatrixXcd(dynamic_m.template selfadjointView<Upper>()) * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.template triangularView<Lower>() =
+      dynamic_m.template selfadjointView<Upper>() * dynamic_d.asDiagonal();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+
+  no_malloc_result = dynamic_m;
+  dynamic_expected = dynamic_m;
+  dynamic_expected.template triangularView<Upper>() =
+      dynamic_d.asDiagonal() * MatrixXcd(dynamic_m.template selfadjointView<Lower>());
+  internal::set_is_malloc_allowed(false);
+  no_malloc_result.template triangularView<Upper>() =
+      dynamic_d.asDiagonal() * dynamic_m.template selfadjointView<Lower>();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(no_malloc_result, dynamic_expected);
+}
+
+// Exercise the block-tile path of the dense selfadjoint x diagonal kernel
+// (BlockSize = 32 in ProductEvaluators.h). Picks a few sizes that hit
+// full blocks (size = 64), partial blocks (size = 33, 65), and a tiny size
+// that bypasses the block loop entirely (size = 8). Also verifies the
+// overwrite path leaves no stale data when dst is pre-filled.
+template <typename Scalar>
+void selfadjoint_diagonal_products_at(Index n) {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatType;
+  typedef Matrix<Scalar, Dynamic, 1> VecType;
+
+  MatType m = MatType::Random(n, n);
+  m.diagonal() = m.diagonal().real().template cast<Scalar>();  // Hermitian diagonal
+  VecType d = VecType::Random(n);
+
+  MatType ref_lower = m.template selfadjointView<Lower>();
+  MatType ref_upper = m.template selfadjointView<Upper>();
+
+  // Plain assignment goes through evalTo (overwrite kernel).
+  // Pre-fill dst with garbage to verify no stale entries remain.
+  MatType dst = MatType::Constant(n, n, Scalar(42));
+  dst.noalias() = m.template selfadjointView<Upper>() * d.asDiagonal();
+  VERIFY_IS_APPROX(dst, ref_upper * d.asDiagonal());
+
+  dst = MatType::Constant(n, n, Scalar(-7));
+  dst.noalias() = m.template selfadjointView<Lower>() * d.asDiagonal();
+  VERIFY_IS_APPROX(dst, ref_lower * d.asDiagonal());
+
+  dst = MatType::Constant(n, n, Scalar(13));
+  dst.noalias() = d.asDiagonal() * m.template selfadjointView<Upper>();
+  VERIFY_IS_APPROX(dst, d.asDiagonal() * ref_upper);
+
+  dst = MatType::Constant(n, n, Scalar(99));
+  dst.noalias() = d.asDiagonal() * m.template selfadjointView<Lower>();
+  VERIFY_IS_APPROX(dst, d.asDiagonal() * ref_lower);
+
+  // Accumulating paths (scaleAndAddTo).
+  MatType base = MatType::Random(n, n);
+  dst = base;
+  dst.noalias() += m.template selfadjointView<Upper>() * d.asDiagonal();
+  VERIFY_IS_APPROX(dst, base + ref_upper * d.asDiagonal());
+
+  dst = base;
+  dst.noalias() -= d.asDiagonal() * m.template selfadjointView<Lower>();
+  VERIFY_IS_APPROX(dst, base - d.asDiagonal() * ref_lower);
+
+  // Scalar-scaled products: the "Dense ?= scalar * Product" rewriting rule
+  // folds alpha into the SelfAdjointView. For a complex alpha that fold is
+  // not Hermitian, so the dispatch must restore alpha rather than apply it
+  // straight to the kernel — verify all four orientation x triangle combos.
+  Scalar alpha = internal::random<Scalar>();
+  dst = base;
+  dst.noalias() += alpha * (m.template selfadjointView<Lower>() * d.asDiagonal());
+  VERIFY_IS_APPROX(dst, base + alpha * (ref_lower * d.asDiagonal()));
+
+  dst = base;
+  dst.noalias() -= alpha * (m.template selfadjointView<Upper>() * d.asDiagonal());
+  VERIFY_IS_APPROX(dst, base - alpha * (ref_upper * d.asDiagonal()));
+
+  dst = base;
+  dst.noalias() += alpha * (d.asDiagonal() * m.template selfadjointView<Upper>());
+  VERIFY_IS_APPROX(dst, base + alpha * (d.asDiagonal() * ref_upper));
+
+  dst = base;
+  dst.noalias() -= alpha * (d.asDiagonal() * m.template selfadjointView<Lower>());
+  VERIFY_IS_APPROX(dst, base - alpha * (d.asDiagonal() * ref_lower));
+
+  // Overwrite-with-scalar path: hits evalTo's HasScalarFactor branch.
+  dst = MatType::Constant(n, n, Scalar(17));
+  dst.noalias() = alpha * (m.template selfadjointView<Lower>() * d.asDiagonal());
+  VERIFY_IS_APPROX(dst, alpha * (ref_lower * d.asDiagonal()));
+
+  dst = MatType::Constant(n, n, Scalar(-3));
+  dst.noalias() = alpha * (d.asDiagonal() * m.template selfadjointView<Upper>());
+  VERIFY_IS_APPROX(dst, alpha * (d.asDiagonal() * ref_upper));
+
+  // Conjugated nested expressions go through the same blas_traits extraction
+  // path. The extracted matrix must keep NeedToConjugate, otherwise the kernel
+  // computes with m instead of m.conjugate().
+  MatType conj_ref_lower = m.conjugate().template selfadjointView<Lower>();
+  MatType conj_ref_upper = m.conjugate().template selfadjointView<Upper>();
+
+  dst = MatType::Constant(n, n, Scalar(23));
+  dst.noalias() = m.conjugate().template selfadjointView<Upper>() * d.asDiagonal();
+  VERIFY_IS_APPROX(dst, conj_ref_upper * d.asDiagonal());
+
+  dst = MatType::Constant(n, n, Scalar(-29));
+  dst.noalias() = d.asDiagonal() * m.conjugate().template selfadjointView<Lower>();
+  VERIFY_IS_APPROX(dst, d.asDiagonal() * conj_ref_lower);
+
+  dst = base;
+  dst.noalias() += alpha * (m.conjugate().template selfadjointView<Lower>() * d.asDiagonal());
+  VERIFY_IS_APPROX(dst, base + alpha * (conj_ref_lower * d.asDiagonal()));
+
+  dst = base;
+  dst.noalias() -= alpha * (d.asDiagonal() * m.conjugate().template selfadjointView<Upper>());
+  VERIFY_IS_APPROX(dst, base - alpha * (d.asDiagonal() * conj_ref_upper));
+}
+
+template <int>
+void selfadjoint_diagonal_products_block_path() {
+  selfadjoint_diagonal_products_at<double>(8);
+  selfadjoint_diagonal_products_at<double>(33);  // partial off-diagonal block
+  selfadjoint_diagonal_products_at<double>(64);  // exact multiple of BlockSize
+  selfadjoint_diagonal_products_at<double>(65);  // off-by-one
+  selfadjoint_diagonal_products_at<std::complex<double>>(33);
+  selfadjoint_diagonal_products_at<std::complex<double>>(65);
+}
+
+// In-place patterns where the diagonal operand shares storage with the destination view.
+// The fast path in triangular_product_assignment_dispatcher detects the run-time overlap
+// and materializes a temporary, so the result must match a reference computed against a
+// materialized source. The structured (triangular/selfadjoint) operand can safely share
+// storage with dst because the kernel reads each cell before writing it.
+template <unsigned int Mode, typename Mat>
+void verify_triangular_in_place_with_aliased_diagonal(const Mat& m) {
+  // diagonal * tri_view
+  {
+    Mat actual = m, expected = m;
+    Mat ref_diag = actual.diagonal().asDiagonal();
+    Mat ref_tri = actual.template triangularView<Mode>();
+    expected.template triangularView<Mode>() = (ref_diag * ref_tri).eval();
+    actual.template triangularView<Mode>() = actual.diagonal().asDiagonal() * actual.template triangularView<Mode>();
+    VERIFY_IS_APPROX(actual, expected);
+  }
+  // tri_view * diagonal
+  {
+    Mat actual = m, expected = m;
+    Mat ref_diag = actual.diagonal().asDiagonal();
+    Mat ref_tri = actual.template triangularView<Mode>();
+    expected.template triangularView<Mode>() = (ref_tri * ref_diag).eval();
+    actual.template triangularView<Mode>() = actual.template triangularView<Mode>() * actual.diagonal().asDiagonal();
+    VERIFY_IS_APPROX(actual, expected);
+  }
+}
+
+template <unsigned int Mode, typename Mat>
+void verify_selfadjoint_in_place_with_aliased_diagonal(const Mat& m) {
+  // diagonal * sa_view
+  {
+    Mat actual = m, expected = m;
+    Mat ref_diag = actual.diagonal().asDiagonal();
+    Mat ref_sa = actual.template selfadjointView<Mode>();
+    expected.template triangularView<Mode>() = (ref_diag * ref_sa).eval();
+    actual.template selfadjointView<Mode>() = actual.diagonal().asDiagonal() * actual.template selfadjointView<Mode>();
+    VERIFY_IS_APPROX(actual.template triangularView<Mode>().toDenseMatrix(),
+                     expected.template triangularView<Mode>().toDenseMatrix());
+  }
+  // sa_view * diagonal
+  {
+    Mat actual = m, expected = m;
+    Mat ref_diag = actual.diagonal().asDiagonal();
+    Mat ref_sa = actual.template selfadjointView<Mode>();
+    expected.template triangularView<Mode>() = (ref_sa * ref_diag).eval();
+    actual.template selfadjointView<Mode>() = actual.template selfadjointView<Mode>() * actual.diagonal().asDiagonal();
+    VERIFY_IS_APPROX(actual.template triangularView<Mode>().toDenseMatrix(),
+                     expected.template triangularView<Mode>().toDenseMatrix());
+  }
+}
+
+template <int>
+void structured_diagonal_aliasing() {
+  for (int n : {3, 5, 8, 17, 32, 33, 64, 65}) {
+    MatrixXcd m = MatrixXcd::Random(n, n);
+    m.diagonal() = m.diagonal().real();  // Hermitian-friendly diagonal
+
+    verify_triangular_in_place_with_aliased_diagonal<Upper>(m);
+    verify_triangular_in_place_with_aliased_diagonal<Lower>(m);
+    verify_selfadjoint_in_place_with_aliased_diagonal<Upper>(m);
+    verify_selfadjoint_in_place_with_aliased_diagonal<Lower>(m);
+  }
+}
+
+template <typename DiagonalType>
+void diagonal_matrix_move(Index size) {
+  using Scalar = typename DiagonalType::Scalar;
+  using VectorType = typename DiagonalType::DiagonalVectorType;
+  STATIC_CHECK(std::is_nothrow_move_constructible<DiagonalType>::value ==
+               std::is_nothrow_move_constructible<VectorType>::value);
+  STATIC_CHECK(VectorType::MaxSizeAtCompileTime != Dynamic || std::is_nothrow_move_assignable<DiagonalType>::value ==
+                                                                  std::is_nothrow_move_assignable<VectorType>::value);
+
+  DiagonalType source;
+  source.resize(size);
+  for (Index i = 0; i < size; ++i) {
+    const Scalar value = Scalar(i + 1);
+    source.diagonal()(i) = value;
+  }
+  const DiagonalType expected(source);
+  DiagonalType copied;
+  copied = source;
+  const Scalar* original_data = source.diagonal().data();
+
+  internal::set_is_malloc_allowed(false);
+  DiagonalType constructed(std::move(source));
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(constructed.rows(), size);
+  if (VectorType::MaxSizeAtCompileTime == Dynamic) VERIFY(constructed.diagonal().data() == original_data);
+  for (Index i = 0; i < size; ++i) {
+    VERIFY_IS_EQUAL(constructed.diagonal()(i), expected.diagonal()(i));
+    VERIFY_IS_EQUAL(copied.diagonal()(i), expected.diagonal()(i));
+  }
+
+  source = expected;
+  DiagonalType assigned;
+  internal::set_is_malloc_allowed(false);
+  assigned = std::move(constructed);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(assigned.rows(), size);
+  if (VectorType::MaxSizeAtCompileTime == Dynamic) VERIFY(assigned.diagonal().data() == original_data);
+  for (Index i = 0; i < size; ++i) VERIFY_IS_EQUAL(assigned.diagonal()(i), expected.diagonal()(i));
+
+  constructed = expected;
+  // Also move into an existing allocation, with a different size when storage is dynamic.
+  if (VectorType::SizeAtCompileTime == Dynamic) assigned.resize(size == 0 ? 1 : size - 1);
+  original_data = constructed.diagonal().data();
+  internal::set_is_malloc_allowed(false);
+  assigned = std::move(constructed);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(assigned.rows(), size);
+  if (VectorType::MaxSizeAtCompileTime == Dynamic) VERIFY(assigned.diagonal().data() == original_data);
+  for (Index i = 0; i < size; ++i) VERIFY_IS_EQUAL(assigned.diagonal()(i), expected.diagonal()(i));
+
+  constructed = expected;
+  for (Index i = 0; i < size; ++i) {
+    VERIFY_IS_EQUAL(source.diagonal()(i), expected.diagonal()(i));
+    VERIFY_IS_EQUAL(constructed.diagonal()(i), expected.diagonal()(i));
+  }
+}
+
+template <typename Scalar>
+void diagonal_matrix_moves() {
+  diagonal_matrix_move<DiagonalMatrix<Scalar, 0>>(0);
+  diagonal_matrix_move<DiagonalMatrix<Scalar, 1>>(1);
+  diagonal_matrix_move<DiagonalMatrix<Scalar, 4>>(4);
+  for (Index size : {0, 1, 4, 17}) {
+    diagonal_matrix_move<DiagonalMatrix<Scalar, Dynamic>>(size);
+    diagonal_matrix_move<DiagonalMatrix<Scalar, Dynamic, 17>>(size);
+  }
+}
+
 EIGEN_DECLARE_TEST(diagonalmatrices) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(diagonalmatrices(Matrix<float, 1, 1>()));
@@ -194,4 +602,13 @@
     CALL_SUBTEST_9(as_scalar_product(MatrixXf(1, 1)));
   }
   CALL_SUBTEST_10(bug987<0>());
+  CALL_SUBTEST_10(bug2013<0>());
+  CALL_SUBTEST_10(selfadjoint_diagonal_products<0>());
+  CALL_SUBTEST_10(selfadjoint_diagonal_products_block_path<0>());
+  CALL_SUBTEST_10(structured_diagonal_aliasing<0>());
+  CALL_SUBTEST_11(diagonal_matrix_moves<float>());
+  CALL_SUBTEST_11(diagonal_matrix_moves<double>());
+  CALL_SUBTEST_11(diagonal_matrix_moves<int>());
+  CALL_SUBTEST_11(diagonal_matrix_moves<std::complex<double>>());
+  CALL_SUBTEST_11(diagonal_matrix_moves<MovableScalar<float>>());
 }
diff --git a/test/diagonalview.cpp b/test/diagonalview.cpp
index 0d83c8e..1fb4dbb 100644
--- a/test/diagonalview.cpp
+++ b/test/diagonalview.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // discard stack allocation as that too bypasses malloc
 #define EIGEN_STACK_ALLOCATION_LIMIT 0
diff --git a/test/dontalign.cpp b/test/dontalign.cpp
index 2210bad..f8158c5 100644
--- a/test/dontalign.cpp
+++ b/test/dontalign.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #if defined EIGEN_TEST_PART_1 || defined EIGEN_TEST_PART_2 || defined EIGEN_TEST_PART_3 || defined EIGEN_TEST_PART_4
 #define EIGEN_DONT_ALIGN
@@ -19,6 +20,7 @@
 template <typename MatrixType>
 void dontalign(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
 
@@ -29,7 +31,12 @@
   SquareMatrixType square = SquareMatrixType::Random(rows, rows);
   VectorType v = VectorType::Random(rows);
 
-  VERIFY_IS_APPROX(v, square * square.colPivHouseholderQr().solve(v));
+  const VectorType solution = square.colPivHouseholderQr().solve(v);
+  // Bound the normwise backward error ||Ax-b||_2 / (||A||_F * ||x||_2 + ||b||_2) by 10*n*epsilon.
+  const RealScalar scale = square.norm() * solution.norm() + v.norm();
+  const RealScalar bound = RealScalar(10 * rows) * NumTraits<RealScalar>::epsilon() * scale;
+  VERIFY((numext::isfinite)(bound));
+  VERIFY((square * solution - v).norm() <= bound);
   square = square.inverse().eval();
   a = square * a;
   square = square * square;
diff --git a/test/dynalloc.cpp b/test/dynalloc.cpp
index 8732f68..86df9d1 100644
--- a/test/dynalloc.cpp
+++ b/test/dynalloc.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/eigen2support.cpp b/test/eigen2support.cpp
deleted file mode 100644
index 878352b..0000000
--- a/test/eigen2support.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN2_SUPPORT
-
-#include "main.h"
-
-template <typename MatrixType>
-void eigen2support(const MatrixType& m) {
-  typedef typename MatrixType::Scalar Scalar;
-
-  Index rows = m.rows();
-  Index cols = m.cols();
-
-  MatrixType m1 = MatrixType::Random(rows, cols), m3(rows, cols);
-
-  Scalar s1 = internal::random<Scalar>(), s2 = internal::random<Scalar>();
-
-  // scalar addition
-  VERIFY_IS_APPROX(m1.cwise() + s1, s1 + m1.cwise());
-  VERIFY_IS_APPROX(m1.cwise() + s1, MatrixType::Constant(rows, cols, s1) + m1);
-  VERIFY_IS_APPROX((m1 * Scalar(2)).cwise() - s2, (m1 + m1) - MatrixType::Constant(rows, cols, s2));
-  m3 = m1;
-  m3.cwise() += s2;
-  VERIFY_IS_APPROX(m3, m1.cwise() + s2);
-  m3 = m1;
-  m3.cwise() -= s1;
-  VERIFY_IS_APPROX(m3, m1.cwise() - s1);
-
-  VERIFY_IS_EQUAL((m1.corner(TopLeft, 1, 1)), (m1.block(0, 0, 1, 1)));
-  VERIFY_IS_EQUAL((m1.template corner<1, 1>(TopLeft)), (m1.template block<1, 1>(0, 0)));
-  VERIFY_IS_EQUAL((m1.col(0).start(1)), (m1.col(0).segment(0, 1)));
-  VERIFY_IS_EQUAL((m1.col(0).template start<1>()), (m1.col(0).segment(0, 1)));
-  VERIFY_IS_EQUAL((m1.col(0).end(1)), (m1.col(0).segment(rows - 1, 1)));
-  VERIFY_IS_EQUAL((m1.col(0).template end<1>()), (m1.col(0).segment(rows - 1, 1)));
-
-  using numext::abs2;
-  using numext::real;
-  using std::cos;
-  VERIFY_IS_EQUAL(ei_cos(s1), cos(s1));
-  VERIFY_IS_EQUAL(ei_real(s1), real(s1));
-  VERIFY_IS_EQUAL(ei_abs2(s1), abs2(s1));
-
-  m1.minor(0, 0);
-}
-
-EIGEN_DECLARE_TEST(eigen2support) {
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_1(eigen2support(Matrix<double, 1, 1>()));
-    CALL_SUBTEST_2(eigen2support(MatrixXd(1, 1)));
-    CALL_SUBTEST_4(eigen2support(Matrix3f()));
-    CALL_SUBTEST_5(eigen2support(Matrix4d()));
-    CALL_SUBTEST_2(eigen2support(MatrixXf(200, 200)));
-    CALL_SUBTEST_6(eigen2support(MatrixXcd(100, 100)));
-  }
-}
diff --git a/test/eigensolver_complex.cpp b/test/eigensolver_complex.cpp
index 1590092..190c726 100644
--- a/test/eigensolver_complex.cpp
+++ b/test/eigensolver_complex.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <limits>
@@ -131,7 +132,6 @@
     a.setZero();
     ComplexEigenSolver<MatrixType> ei3(a);
     VERIFY_IS_EQUAL(ei3.info(), Success);
-    VERIFY_IS_MUCH_SMALLER_THAN(ei3.eigenvalues().norm(), RealScalar(1));
     RealScalar tol = 2 * a.cols() * NumTraits<RealScalar>::epsilon();
     VERIFY((ei3.eigenvectors().adjoint() * ei3.eigenvectors()).eval().isIdentity(tol));
   }
@@ -148,6 +148,23 @@
   VERIFY_RAISES_ASSERT(eig.eigenvectors());
 }
 
+void custom_complex_stable_normalization() {
+  typedef CustomComplex<double> Scalar;
+  typedef Matrix<Scalar, 2, 1> Vector2;
+
+  Vector2 input;
+  input << Scalar(3.0, 4.0), Scalar(0.0, 0.0);
+  const Vector2 normalized = input.stableNormalized();
+  VERIFY_IS_APPROX(normalized(0).re, 0.6);
+  VERIFY_IS_APPROX(normalized(0).im, 0.8);
+  VERIFY_IS_EQUAL(normalized(1), Scalar(0.0, 0.0));
+
+  input.stableNormalize();
+  VERIFY_IS_APPROX(input(0).re, 0.6);
+  VERIFY_IS_APPROX(input(0).im, 0.8);
+  VERIFY_IS_EQUAL(input(1), Scalar(0.0, 0.0));
+}
+
 EIGEN_DECLARE_TEST(eigensolver_complex) {
   int s = 0;
   for (int i = 0; i < g_repeat; i++) {
@@ -156,7 +173,7 @@
     CALL_SUBTEST_2(eigensolver(MatrixXcd(s, s)));
     CALL_SUBTEST_3(eigensolver(Matrix<std::complex<float>, 1, 1>()));
     CALL_SUBTEST_4(eigensolver(Matrix3f()));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
   CALL_SUBTEST_1(eigensolver_verify_assert(Matrix4cf()));
   s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
@@ -169,6 +186,7 @@
 
   // Test custom complex scalar type.
   CALL_SUBTEST_6(eigensolver(Matrix<CustomComplex<double>, 5, 5>()));
+  CALL_SUBTEST_6(custom_complex_stable_normalization());
 
-  TEST_SET_BUT_UNUSED_VARIABLE(s)
+  TEST_SET_BUT_UNUSED_VARIABLE(s);
 }
diff --git a/test/eigensolver_generalized_real.cpp b/test/eigensolver_generalized_real.cpp
index eb3f884..7c20efe 100644
--- a/test/eigensolver_generalized_real.cpp
+++ b/test/eigensolver_generalized_real.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_RUNTIME_NO_MALLOC
 #include "main.h"
@@ -52,11 +53,7 @@
   // non symmetric case:
   {
     GeneralizedEigenSolver<MatrixType> eig(rows);
-    // TODO enable full-prealocation of required memory, this probably requires an in-place mode for
-    // HessenbergDecomposition
-    // Eigen::internal::set_is_malloc_allowed(false);
     eig.compute(a, b);
-    // Eigen::internal::set_is_malloc_allowed(true);
     for (Index k = 0; k < cols; ++k) {
       Matrix<ComplexScalar, Dynamic, Dynamic> tmp =
           (eig.betas()(k) * a).template cast<ComplexScalar>() - eig.alphas()(k) * b;
@@ -121,7 +118,34 @@
   VERIFY_RAISES_ASSERT(eig.betas());
 }
 
+// Use an unbounded dynamic matrix below the block Householder threshold.
+template <typename MatrixType>
+void generalized_eigensolver_no_malloc() {
+  const Index dim = 24;
+  MatrixType A = MatrixType::Random(dim, dim), B = MatrixType::Random(dim, dim);
+  GeneralizedEigenSolver<MatrixType> eig(dim);
+  internal::set_is_malloc_allowed(false);
+  eig.compute(A, B, false);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(eig.info(), Success);
+  const auto alphas = eig.alphas().eval();
+  const auto betas = eig.betas().eval();
+
+  for (int i = 0; i < 2; ++i) {
+    internal::set_is_malloc_allowed(false);
+    eig.compute(A, B, true);
+    internal::set_is_malloc_allowed(true);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    VERIFY_IS_APPROX(eig.alphas(), alphas);
+    VERIFY_IS_APPROX(eig.betas(), betas);
+    VERIFY_IS_APPROX(A * eig.eigenvectors() * eig.betas().asDiagonal(),
+                     B * eig.eigenvectors() * eig.alphas().asDiagonal());
+  }
+}
+
 EIGEN_DECLARE_TEST(eigensolver_generalized_real) {
+  CALL_SUBTEST_2(generalized_eigensolver_no_malloc<MatrixXd>());
+  CALL_SUBTEST_2((generalized_eigensolver_no_malloc<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
   for (int i = 0; i < g_repeat; i++) {
     int s = 0;
     CALL_SUBTEST_1(generalized_eigensolver_real(Matrix4f()));
@@ -134,6 +158,6 @@
     CALL_SUBTEST_3(generalized_eigensolver_real(Matrix<double, 1, 1>()));
     CALL_SUBTEST_4(generalized_eigensolver_real(Matrix2d()));
     CALL_SUBTEST_5(generalized_eigensolver_assert<MatrixXd>());
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 }
diff --git a/test/eigensolver_generic.cpp b/test/eigensolver_generic.cpp
index dafaf99..effd7f6 100644
--- a/test/eigensolver_generic.cpp
+++ b/test/eigensolver_generic.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <limits>
@@ -16,7 +17,7 @@
 void check_eigensolver_for_given_mat(const EigType& eig, const MatType& a) {
   typedef typename NumTraits<typename MatType::Scalar>::Real RealScalar;
   typedef Matrix<RealScalar, MatType::RowsAtCompileTime, 1> RealVectorType;
-  typedef typename std::complex<RealScalar> Complex;
+  typedef std::complex<RealScalar> Complex;
   Index n = a.rows();
   VERIFY_IS_EQUAL(eig.info(), Success);
   VERIFY_IS_APPROX(a * eig.pseudoEigenvectors(), eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix());
@@ -36,7 +37,7 @@
 
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef typename std::complex<RealScalar> Complex;
+  typedef std::complex<RealScalar> Complex;
 
   MatrixType a = MatrixType::Random(rows, cols);
   MatrixType a1 = MatrixType::Random(rows, cols);
@@ -202,13 +203,15 @@
     CALL_SUBTEST_1(eigensolver(Matrix4f()));
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
     CALL_SUBTEST_2(eigensolver(MatrixXd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     // some trivial but implementation-wise tricky cases
     CALL_SUBTEST_2(eigensolver(MatrixXd(1, 1)));
     CALL_SUBTEST_2(eigensolver(MatrixXd(2, 2)));
     CALL_SUBTEST_3(eigensolver(Matrix<double, 1, 1>()));
     CALL_SUBTEST_4(eigensolver(Matrix2d()));
+    CALL_SUBTEST_6((eigensolver(Matrix<float, Dynamic, Dynamic, RowMajor>(17, 17))));
+    CALL_SUBTEST_7((eigensolver(Matrix<double, Dynamic, Dynamic, RowMajor>(17, 17))));
   }
 
   CALL_SUBTEST_1(eigensolver_verify_assert(Matrix4f()));
@@ -230,5 +233,5 @@
 
   CALL_SUBTEST_2(eigensolver_generic_extra<0>());
 
-  TEST_SET_BUT_UNUSED_VARIABLE(s)
+  TEST_SET_BUT_UNUSED_VARIABLE(s);
 }
diff --git a/test/eigensolver_selfadjoint.cpp b/test/eigensolver_selfadjoint.cpp
index 7cc4d63..cab5f8d 100644
--- a/test/eigensolver_selfadjoint.cpp
+++ b/test/eigensolver_selfadjoint.cpp
@@ -7,13 +7,54 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Enables the runtime malloc tracking that generalizedselfadjointeigensolver_no_malloc() needs.
+// Allocation stays allowed by default; only the explicit set_is_malloc_allowed(false) window checks.
+#define EIGEN_RUNTIME_NO_MALLOC
 
 #include "main.h"
 #include "svd_fill.h"
+#include "tridiag_test_matrices.h"
+#include "fp_control.h"
 #include <limits>
 #include <Eigen/Eigenvalues>
 #include <Eigen/SparseCore>
-#include <unsupported/Eigen/MatrixFunctions>
+#include <contrib/Eigen/MatrixFunctions>
+
+template <typename Scalar>
+struct selfadjoint_eigensolver_test_rescale {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  explicit selfadjoint_eigensolver_test_rescale(RealScalar scale) : m_scale(scale) {}
+
+  Scalar operator()(const Scalar& value) const { return value / m_scale; }
+
+  RealScalar m_scale;
+};
+
+template <>
+struct selfadjoint_eigensolver_test_rescale<float> {
+  explicit selfadjoint_eigensolver_test_rescale(float scale) : m_scale(scale) {}
+
+  // A scalar widened division keeps the residual calculation independent of NEON's subnormal flushing.
+  float operator()(float value) const { return float(double(value) / double(m_scale)); }
+
+  float m_scale;
+};
+
+template <typename MatrixType>
+MatrixType scaled_selfadjoint_for_residual(const MatrixType& matrix, typename MatrixType::RealScalar scale) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  MatrixType dense = matrix.template selfadjointView<Lower>();
+  if (!internal::is_same<Scalar, float>::value ||
+      scale >= RealScalar((std::numeric_limits<float>::min)() / NumTraits<float>::epsilon())) {
+    dense /= scale;
+    return dense;
+  }
+  return dense.unaryExpr(selfadjoint_eigensolver_test_rescale<Scalar>(scale));
+}
 
 template <typename MatrixType>
 void selfadjointeigensolver_essential_check(const MatrixType& m) {
@@ -25,17 +66,38 @@
   SelfAdjointEigenSolver<MatrixType> eiSymm(m);
   VERIFY_IS_EQUAL(eiSymm.info(), Success);
 
+  Index n = m.cols();
   RealScalar scaling = m.cwiseAbs().maxCoeff();
-  RealScalar unitary_error_factor = RealScalar(16);
 
   if (scaling < (std::numeric_limits<RealScalar>::min)()) {
     VERIFY(eiSymm.eigenvalues().cwiseAbs().maxCoeff() <= (std::numeric_limits<RealScalar>::min)());
   } else {
-    VERIFY_IS_APPROX((m.template selfadjointView<Lower>() * eiSymm.eigenvectors()) / scaling,
-                     (eiSymm.eigenvectors() * eiSymm.eigenvalues().asDiagonal()) / scaling);
+    // Columnwise residual check: for each eigenpair (lambda_i, v_i),
+    //   ||A*v_i - lambda_i*v_i|| / ||A||_max <= c * n * eps
+    // This ensures accuracy for every eigenpair, including those corresponding
+    // to small eigenvalues (which a Frobenius norm check would miss).
+    // Computed in scaled space (dividing by ||A||_max) to avoid overflow.
+    const MatrixType scaledA = scaled_selfadjoint_for_residual(m, scaling);
+    MatrixType residual =
+        scaledA * eiSymm.eigenvectors() - eiSymm.eigenvectors() * (eiSymm.eigenvalues() / scaling).asDiagonal();
+    RealScalar tol = RealScalar(8) * RealScalar(numext::maxi(Index(1), n)) * NumTraits<RealScalar>::epsilon();
+    for (Index i = 0; i < n; ++i) {
+      VERIFY(residual.col(i).norm() <= tol);
+    }
   }
   VERIFY_IS_APPROX(m.template selfadjointView<Lower>().eigenvalues(), eiSymm.eigenvalues());
-  VERIFY(eiSymm.eigenvectors().isUnitary(test_precision<RealScalar>() * unitary_error_factor));
+
+  // Eigenvectors must be unitary. Use a tolerance proportional to n*epsilon,
+  // which is the expected rounding error for Householder-based orthogonal transformations.
+  RealScalar unitary_tol = RealScalar(8) * RealScalar(numext::maxi(Index(1), n)) * NumTraits<RealScalar>::epsilon();
+  // But don't go below the test_precision floor (matters for float).
+  unitary_tol = numext::maxi(unitary_tol, test_precision<RealScalar>());
+  VERIFY(eiSymm.eigenvectors().isUnitary(unitary_tol));
+
+  // Verify eigenvalues are sorted in non-decreasing order.
+  for (Index i = 1; i < n; ++i) {
+    VERIFY(eiSymm.eigenvalues()(i) >= eiSymm.eigenvalues()(i - 1));
+  }
 
   if (m.cols() <= 4) {
     SelfAdjointEigenSolver<MatrixType> eiDirect;
@@ -53,12 +115,21 @@
       VERIFY(eiDirect.eigenvalues().cwiseAbs().maxCoeff() <= (std::numeric_limits<RealScalar>::min)());
     } else {
       VERIFY_IS_APPROX(eiSymm.eigenvalues() / scaling, eiDirect.eigenvalues() / scaling);
-      VERIFY_IS_APPROX((m.template selfadjointView<Lower>() * eiDirect.eigenvectors()) / scaling,
-                       (eiDirect.eigenvectors() * eiDirect.eigenvalues().asDiagonal()) / scaling);
+      // TODO: the direct 3x3 solver can produce large backward errors (>>n*eps*||A||)
+      // on some matrices. Investigate and fix, then tighten this to a Frobenius norm check.
+      const MatrixType scaledA = scaled_selfadjoint_for_residual(m, scaling);
+      VERIFY_IS_APPROX(scaledA * eiDirect.eigenvectors(),
+                       eiDirect.eigenvectors() * (eiDirect.eigenvalues() / scaling).asDiagonal());
       VERIFY_IS_APPROX(m.template selfadjointView<Lower>().eigenvalues() / scaling, eiDirect.eigenvalues() / scaling);
     }
 
-    VERIFY(eiDirect.eigenvectors().isUnitary(test_precision<RealScalar>() * unitary_error_factor));
+    // Direct solver eigenvectors must also be unitary.
+    VERIFY(eiDirect.eigenvectors().isUnitary(unitary_tol));
+
+    // Direct solver eigenvalues must also be sorted.
+    for (Index i = 1; i < n; ++i) {
+      VERIFY(eiDirect.eigenvalues()(i) >= eiDirect.eigenvalues()(i - 1));
+    }
   }
 }
 
@@ -80,7 +151,7 @@
   MatrixType symmA = a.adjoint() * a + a1.adjoint() * a1;
   MatrixType symmC = symmA;
 
-  svd_fill_random(symmA, Symmetric);
+  svd_fill_random(symmA, SelfAdjoint);
 
   symmA.template triangularView<StrictlyUpper>().setZero();
   symmC.template triangularView<StrictlyUpper>().setZero();
@@ -149,11 +220,16 @@
   VERIFY_IS_APPROX(tridiag.diagonal(), tridiag.matrixT().diagonal());
   VERIFY_IS_APPROX(tridiag.subDiagonal(), tridiag.matrixT().template diagonal<-1>());
   Matrix<RealScalar, Dynamic, Dynamic> T = tridiag.matrixT();
-  if (rows > 1 && cols > 1) {
-    // FIXME check that upper and lower part are 0:
-    // VERIFY(T.topRightCorner(rows-2, cols-2).template triangularView<Upper>().isZero());
+  if (rows > 2) {
+    // Verify that the tridiagonal matrix is actually tridiagonal (zero outside the three central diagonals).
+    for (Index i = 0; i < rows; ++i) {
+      for (Index j = 0; j < cols; ++j) {
+        if (numext::abs(i - j) > 1) {
+          VERIFY(numext::is_exactly_zero(T(i, j)));
+        }
+      }
+    }
   }
-  VERIFY_IS_APPROX(tridiag.diagonal(), T.diagonal());
   VERIFY_IS_APPROX(tridiag.subDiagonal(), T.template diagonal<1>());
   VERIFY_IS_APPROX(MatrixType(symmC.template selfadjointView<Lower>()),
                    tridiag.matrixQ() * tridiag.matrixT().eval() * MatrixType(tridiag.matrixQ()).adjoint());
@@ -170,7 +246,7 @@
                                             eiSymmTridiag.eigenvectors().real().transpose());
   }
 
-  // Test matrix expponential from eigendecomposition.
+  // Test matrix exponential from eigendecomposition.
   // First scale to avoid overflow.
   symmB = symmB / symmB.norm();
   eiSymm.compute(symmB);
@@ -202,6 +278,482 @@
   }
 }
 
+// Test matrices with exact eigenvalue multiplicities.
+template <typename MatrixType>
+void selfadjointeigensolver_repeated_eigenvalues(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  Index n = m.rows();
+  if (n < 2) return;
+
+  // Create a random unitary matrix via QR.
+  MatrixType q = MatrixType::Random(n, n);
+  HouseholderQR<MatrixType> qr(q);
+  q = qr.householderQ();
+
+  // All eigenvalues equal (scalar multiple of identity).
+  {
+    RealScalar lambda = internal::random<RealScalar>(-10, 10);
+    MatrixType A = lambda * MatrixType::Identity(n, n);
+    selfadjointeigensolver_essential_check(A);
+  }
+
+  // Eigenvalue of multiplicity n-1 (one distinct, rest equal).
+  {
+    Matrix<RealScalar, Dynamic, 1> d = Matrix<RealScalar, Dynamic, 1>::Constant(n, RealScalar(3));
+    d(0) = RealScalar(-2);
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+
+  // Two clusters: first half one value, second half another.
+  if (n >= 4) {
+    Matrix<RealScalar, Dynamic, 1> d(n);
+    for (Index i = 0; i < n / 2; ++i) d(i) = RealScalar(1);
+    for (Index i = n / 2; i < n; ++i) d(i) = RealScalar(5);
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+
+  // Nearly repeated eigenvalues: separated by O(epsilon).
+  {
+    Matrix<RealScalar, Dynamic, 1> d(n);
+    for (Index i = 0; i < n; ++i) {
+      d(i) = RealScalar(1) + RealScalar(i) * NumTraits<RealScalar>::epsilon() * RealScalar(10);
+    }
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+}
+
+// Test matrices with extreme condition numbers and eigenvalue ranges.
+template <typename MatrixType>
+void selfadjointeigensolver_extreme_eigenvalues(const MatrixType& m) {
+  using std::pow;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  Index n = m.rows();
+  if (n < 2) return;
+
+  // Create a random unitary matrix.
+  MatrixType q = MatrixType::Random(n, n);
+  HouseholderQR<MatrixType> qr(q);
+  q = qr.householderQ();
+
+  // Eigenvalues spanning many orders of magnitude (high condition number).
+  {
+    RealScalar maxExp = RealScalar(std::numeric_limits<RealScalar>::max_exponent10) / RealScalar(4);
+    Matrix<RealScalar, Dynamic, 1> d(n);
+    for (Index i = 0; i < n; ++i) {
+      RealScalar exponent = -maxExp + RealScalar(2) * maxExp * RealScalar(i) / RealScalar(n - 1);
+      d(i) = pow(RealScalar(10), exponent);
+    }
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+
+    SelfAdjointEigenSolver<MatrixType> eig(A);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    // For ill-conditioned matrices we can only check the relative residual.
+    // ||A*V - V*D|| / ||A|| should be O(n * epsilon).
+    RealScalar Anorm = A.template selfadjointView<Lower>().operatorNorm();
+    if (Anorm > (std::numeric_limits<RealScalar>::min)()) {
+      MatrixType residual = A.template selfadjointView<Lower>() * eig.eigenvectors() -
+                            eig.eigenvectors() * eig.eigenvalues().asDiagonal();
+      RealScalar rel_err = residual.norm() / Anorm;
+      RealScalar tol = RealScalar(4) * RealScalar(n) * NumTraits<RealScalar>::epsilon();
+      VERIFY(rel_err <= tol);
+    }
+    // Eigenvalues must still be sorted.
+    for (Index i = 1; i < n; ++i) {
+      VERIFY(eig.eigenvalues()(i) >= eig.eigenvalues()(i - 1));
+    }
+  }
+
+  // Very tiny eigenvalues (near underflow).
+  {
+    RealScalar tiny = (std::numeric_limits<RealScalar>::min)() * RealScalar(100);
+    Matrix<RealScalar, Dynamic, 1> d(n);
+    for (Index i = 0; i < n; ++i) {
+      d(i) = tiny * (RealScalar(1) + RealScalar(i));
+    }
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+
+  // Very large eigenvalues (near overflow).
+  {
+    RealScalar huge = (std::numeric_limits<RealScalar>::max)() / (RealScalar(n) * RealScalar(100));
+    Matrix<RealScalar, Dynamic, 1> d(n);
+    for (Index i = 0; i < n; ++i) {
+      d(i) = huge * (RealScalar(1) + RealScalar(i) * RealScalar(0.01));
+    }
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+
+  // Mix of positive and negative eigenvalues.
+  {
+    Matrix<RealScalar, Dynamic, 1> d(n);
+    for (Index i = 0; i < n; ++i) {
+      d(i) = (i % 2 == 0) ? RealScalar(i + 1) : RealScalar(-(i + 1));
+    }
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+
+  // One zero eigenvalue among non-zero ones (rank-deficient).
+  {
+    Matrix<RealScalar, Dynamic, 1> d = Matrix<RealScalar, Dynamic, 1>::LinSpaced(n, RealScalar(0), RealScalar(n - 1));
+    MatrixType A = (q * d.template cast<Scalar>().asDiagonal() * q.adjoint()).eval();
+    A.template triangularView<StrictlyUpper>().setZero();
+    selfadjointeigensolver_essential_check(A);
+  }
+}
+
+void selfadjointeigensolver_subnormal_coefficients() {
+  volatile float normalMinInput = (std::numeric_limits<float>::min)();
+  const double scale = 256.0 * double(normalMinInput);
+  const auto scaled = [scale](float value) { return float(double(value) * scale); };
+
+  // The 1/512 entries are subnormal but significant relative to the matrix norm.
+  Matrix2f matrix2 = Matrix2f::Zero();
+  matrix2(0, 0) = scaled(1.0f);
+  matrix2(1, 0) = scaled(1.0f / 512.0f);
+  matrix2(1, 1) = scaled(0.5f);
+
+  Matrix3f matrix3 = Matrix3f::Zero();
+  matrix3(0, 0) = scaled(1.0f);
+  matrix3(1, 0) = scaled(0.25f);
+  matrix3(1, 1) = scaled(0.75f);
+  matrix3(2, 0) = scaled(1.0f / 512.0f);
+  matrix3(2, 1) = scaled(-0.125f);
+  matrix3(2, 2) = scaled(0.5f);
+
+  if (!numext::is_exactly_zero(matrix2(1, 0))) {
+    selfadjointeigensolver_essential_check(matrix2);
+    selfadjointeigensolver_essential_check(matrix3);
+  }
+}
+
+// Test computeFromTridiagonal with scaled inputs (regression for missing scaling).
+template <typename MatrixType>
+void selfadjointeigensolver_tridiagonal_scaled(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  Index n = m.rows();
+  if (n < 2) return;
+
+  // Create a tridiagonal matrix with large entries.
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+  RealVectorType diag(n), subdiag(n - 1);
+
+  // Case 1: Large values.
+  RealScalar scale = (std::numeric_limits<RealScalar>::max)() / (RealScalar(n) * RealScalar(100));
+  for (Index i = 0; i < n; ++i) diag(i) = scale * RealScalar(i + 1);
+  for (Index i = 0; i < n - 1; ++i) subdiag(i) = scale * RealScalar(0.5);
+
+  SelfAdjointEigenSolver<MatrixType> eig1;
+  eig1.computeFromTridiagonal(diag, subdiag, ComputeEigenvectors);
+  VERIFY_IS_EQUAL(eig1.info(), Success);
+
+  // Reconstruct tridiagonal and check residual.
+  Matrix<RealScalar, Dynamic, Dynamic> T = Matrix<RealScalar, Dynamic, Dynamic>::Zero(n, n);
+  T.diagonal() = diag;
+  T.template diagonal<1>() = subdiag;
+  T.template diagonal<-1>() = subdiag;
+  VERIFY_IS_APPROX(
+      T, eig1.eigenvectors().real() * eig1.eigenvalues().asDiagonal() * eig1.eigenvectors().real().transpose());
+
+  // Case 2: Tiny values.
+  scale = (std::numeric_limits<RealScalar>::min)() * RealScalar(100);
+  for (Index i = 0; i < n; ++i) diag(i) = scale * RealScalar(i + 1);
+  for (Index i = 0; i < n - 1; ++i) subdiag(i) = scale * RealScalar(0.5);
+
+  SelfAdjointEigenSolver<MatrixType> eig2;
+  eig2.computeFromTridiagonal(diag, subdiag, ComputeEigenvectors);
+  VERIFY_IS_EQUAL(eig2.info(), Success);
+
+  // Eigenvalues-only mode should produce the same eigenvalues.
+  SelfAdjointEigenSolver<MatrixType> eig2v;
+  eig2v.computeFromTridiagonal(diag, subdiag, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(eig2v.info(), Success);
+  VERIFY_IS_APPROX(eig2.eigenvalues(), eig2v.eigenvalues());
+}
+
+template <typename RealScalar>
+void selfadjointeigensolver_dense_deflation_scale_invariance() {
+  const RealScalar epsilon = NumTraits<RealScalar>::epsilon();
+  const RealScalar scales[] = {RealScalar(1), RealScalar(2)};
+  for (RealScalar scale : scales) {
+    Matrix<RealScalar, 2, 1> diag = Matrix<RealScalar, 2, 1>::Constant(scale);
+    Matrix<RealScalar, Dynamic, 1> subdiag(1);
+    subdiag[0] = RealScalar(1.25) * epsilon * scale;
+    Matrix<std::complex<RealScalar>, Dynamic, Dynamic> eigenvectors =
+        Matrix<std::complex<RealScalar>, Dynamic, Dynamic>::Identity(2, 2);
+
+    const ComputationInfo info = internal::computeFromTridiagonal_impl<false>(diag, subdiag, 30, true, eigenvectors);
+    VERIFY_IS_EQUAL(info, Success);
+    VERIFY(diag[0] < diag[1]);
+  }
+}
+
+// Test computeFromTridiagonal with wide dynamic range across decoupled blocks.
+// This exercises the per-block scaling in computeFromTridiagonal_impl: a zero on the
+// subdiagonal decouples the matrix into blocks with vastly different scales. Global
+// scaling would underflow the small block; per-block scaling handles both correctly.
+template <typename RealScalar>
+void selfadjointeigensolver_tridiagonal_wide_range() {
+  using std::sqrt;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixType;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+
+  // Block 1: entries near overflow threshold.
+  // Block 2: entries near 1.
+  // Separated by a zero subdiagonal entry.
+  const RealScalar big = sqrt(NumTraits<RealScalar>::highest()) / RealScalar(10);
+  const Index n = 6;
+  VectorType diag(n), subdiag(n - 1);
+
+  // First block: [0..2], large scale.
+  diag(0) = big;
+  diag(1) = big * RealScalar(1.1);
+  diag(2) = big * RealScalar(0.9);
+  subdiag(0) = big * RealScalar(0.01);
+  subdiag(1) = big * RealScalar(0.02);
+  // Zero subdiagonal decouples the two blocks.
+  subdiag(2) = RealScalar(0);
+  // Second block: [3..5], O(1) scale.
+  diag(3) = RealScalar(1);
+  diag(4) = RealScalar(2);
+  diag(5) = RealScalar(3);
+  subdiag(3) = RealScalar(0.5);
+  subdiag(4) = RealScalar(0.3);
+
+  // Build the full tridiagonal matrix for residual checking.
+  MatrixType T = MatrixType::Zero(n, n);
+  T.diagonal() = diag;
+  T.template diagonal<1>() = subdiag;
+  T.template diagonal<-1>() = subdiag;
+
+  SelfAdjointEigenSolver<MatrixType> eig;
+  eig.computeFromTridiagonal(diag, subdiag, ComputeEigenvectors);
+  VERIFY_IS_EQUAL(eig.info(), Success);
+
+  // Eigenvalues must be sorted.
+  for (Index i = 1; i < n; ++i) {
+    VERIFY(eig.eigenvalues()(i) >= eig.eigenvalues()(i - 1));
+  }
+
+  // Eigenvectors must be orthonormal.
+  RealScalar unitary_tol = RealScalar(4) * RealScalar(n) * NumTraits<RealScalar>::epsilon();
+  VERIFY(eig.eigenvectors().isUnitary(unitary_tol));
+
+  // Full residual check in scaled coordinates.
+  RealScalar Tnorm = T.cwiseAbs().maxCoeff();
+  MatrixType Tscaled = T / Tnorm;
+  MatrixType residual = Tscaled * eig.eigenvectors() - eig.eigenvectors() * (eig.eigenvalues() / Tnorm).asDiagonal();
+  RealScalar rel_err = residual.norm() / Tscaled.norm();
+  VERIFY(rel_err <= RealScalar(8) * RealScalar(n) * NumTraits<RealScalar>::epsilon());
+
+  // The small eigenvalues (~1,2,3) must be accurate, not lost to underflow.
+  // With global scaling to [-1,1], dividing by 'big' would underflow these to zero.
+  // Verify the small eigenvalues are within O(eps) of their true values.
+  // The small block is exactly [[1, 0.5, 0], [0.5, 2, 0.3], [0, 0.3, 3]].
+  MatrixType T_small(3, 3);
+  T_small << RealScalar(1), RealScalar(0.5), RealScalar(0), RealScalar(0.5), RealScalar(2), RealScalar(0.3),
+      RealScalar(0), RealScalar(0.3), RealScalar(3);
+  SelfAdjointEigenSolver<MatrixType> eig_small(T_small);
+  VectorType small_evals = eig_small.eigenvalues();
+
+  // Find the 3 smallest eigenvalues from the combined solver (they should be sorted first).
+  VectorType combined_small = eig.eigenvalues().head(3);
+  VERIFY_IS_APPROX(combined_small, small_evals);
+
+  // Eigenvalues-only mode must agree.
+  SelfAdjointEigenSolver<MatrixType> eig_vals;
+  eig_vals.computeFromTridiagonal(diag, subdiag, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(eig_vals.info(), Success);
+  VERIFY_IS_APPROX(eig.eigenvalues() / Tnorm, eig_vals.eigenvalues() / Tnorm);
+}
+
+// Test computeFromTridiagonal with structured hard-case matrices from the literature.
+template <typename RealScalar>
+void selfadjointeigensolver_structured_tridiagonal() {
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixType;
+
+  test::for_all_symmetric_tridiag_test_matrices<RealScalar>([](const auto& diag, const auto& offdiag) {
+    Index n = diag.size();
+
+    // Build the full symmetric tridiagonal matrix for residual checking.
+    MatrixType T = MatrixType::Zero(n, n);
+    T.diagonal() = diag;
+    if (n > 1) {
+      T.template diagonal<1>() = offdiag;
+      T.template diagonal<-1>() = offdiag;
+    }
+    RealScalar Tnorm = T.cwiseAbs().maxCoeff();
+
+    // Test with eigenvectors.
+    SelfAdjointEigenSolver<MatrixType> eig;
+    eig.computeFromTridiagonal(diag, offdiag, ComputeEigenvectors);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+
+    // Eigenvalues must be sorted.
+    for (Index i = 1; i < n; ++i) {
+      VERIFY(eig.eigenvalues()(i) >= eig.eigenvalues()(i - 1));
+    }
+
+    // Eigenvectors must be orthonormal.
+    RealScalar unitary_tol =
+        numext::maxi(RealScalar(4) * RealScalar(n) * NumTraits<RealScalar>::epsilon(), test_precision<RealScalar>());
+    VERIFY(eig.eigenvectors().isUnitary(unitary_tol));
+
+    // Residual check: ||T*V - V*D||_F / ||T||_max should be O(n*eps).
+    // Scale T to avoid overflow in the matrix product when entries span extreme ranges.
+    if (Tnorm > (std::numeric_limits<RealScalar>::min)()) {
+      MatrixType Tscaled = T / Tnorm;
+      MatrixType residual =
+          Tscaled * eig.eigenvectors() - eig.eigenvectors() * (eig.eigenvalues() / Tnorm).asDiagonal();
+      RealScalar rel_err = residual.norm() / Tscaled.norm();
+      VERIFY(rel_err <= RealScalar(8) * RealScalar(n) * NumTraits<RealScalar>::epsilon());
+    }
+
+    // Eigenvalues-only mode must produce the same eigenvalues.
+    SelfAdjointEigenSolver<MatrixType> eig_vals;
+    eig_vals.computeFromTridiagonal(diag, offdiag, EigenvaluesOnly);
+    VERIFY_IS_EQUAL(eig_vals.info(), Success);
+    if (Tnorm > (std::numeric_limits<RealScalar>::min)()) {
+      VERIFY_IS_APPROX(eig.eigenvalues() / Tnorm, eig_vals.eigenvalues() / Tnorm);
+    }
+  });
+}
+
+// Test with diagonal matrices (tridiagonalization is trivial).
+template <typename MatrixType>
+void selfadjointeigensolver_diagonal(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  Index n = m.rows();
+
+  // Random diagonal matrix.
+  MatrixType diag = MatrixType::Zero(n, n);
+  for (Index i = 0; i < n; ++i) {
+    diag(i, i) = internal::random<RealScalar>(-100, 100);
+  }
+  selfadjointeigensolver_essential_check(diag);
+
+  // The eigenvalues should be the diagonal entries, sorted.
+  SelfAdjointEigenSolver<MatrixType> eig(diag);
+  VERIFY_IS_EQUAL(eig.info(), Success);
+
+  Matrix<RealScalar, Dynamic, 1> expected_evals(n);
+  for (Index i = 0; i < n; ++i) expected_evals(i) = numext::real(diag(i, i));
+  std::sort(expected_evals.data(), expected_evals.data() + n);
+  VERIFY_IS_APPROX(eig.eigenvalues(), expected_evals);
+}
+
+// Test operatorInverseSqrt more thoroughly.
+template <typename MatrixType>
+void selfadjointeigensolver_inverse_sqrt(const MatrixType& m) {
+  Index n = m.rows();
+  if (n < 1) return;
+
+  // Create a positive-definite matrix.
+  MatrixType a = MatrixType::Random(n, n);
+  MatrixType spd = a.adjoint() * a + MatrixType::Identity(n, n);
+  spd.template triangularView<StrictlyUpper>().setZero();
+
+  SelfAdjointEigenSolver<MatrixType> eig(spd);
+  VERIFY_IS_EQUAL(eig.info(), Success);
+
+  MatrixType sqrtA = eig.operatorSqrt();
+  MatrixType invSqrtA = eig.operatorInverseSqrt();
+
+  // sqrtA * invSqrtA should be identity.
+  VERIFY_IS_APPROX(sqrtA * invSqrtA, MatrixType::Identity(n, n));
+
+  // invSqrtA * A * invSqrtA should be identity.
+  VERIFY_IS_APPROX(invSqrtA * spd.template selfadjointView<Lower>() * invSqrtA, MatrixType::Identity(n, n));
+
+  // invSqrtA should be symmetric/selfadjoint.
+  VERIFY_IS_APPROX(invSqrtA, invSqrtA.adjoint());
+}
+
+// Test that RowMajor matrices work correctly with computeDirect.
+template <int>
+void selfadjointeigensolver_rowmajor() {
+  typedef Matrix<double, 3, 3, RowMajor> RowMajorMatrix3d;
+  typedef Matrix<double, 2, 2, RowMajor> RowMajorMatrix2d;
+  typedef Matrix<float, 3, 3, RowMajor> RowMajorMatrix3f;
+  typedef Matrix<float, 2, 2, RowMajor> RowMajorMatrix2f;
+
+  // 3x3 RowMajor double
+  {
+    RowMajorMatrix3d a = RowMajorMatrix3d::Random();
+    RowMajorMatrix3d symmA = a.transpose() * a;
+    SelfAdjointEigenSolver<RowMajorMatrix3d> eig;
+    eig.computeDirect(symmA);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    // Compare with iterative solver.
+    SelfAdjointEigenSolver<RowMajorMatrix3d> eigRef(symmA);
+    VERIFY_IS_APPROX(eigRef.eigenvalues(), eig.eigenvalues());
+  }
+
+  // 2x2 RowMajor double
+  {
+    RowMajorMatrix2d a = RowMajorMatrix2d::Random();
+    RowMajorMatrix2d symmA = a.transpose() * a;
+    SelfAdjointEigenSolver<RowMajorMatrix2d> eig;
+    eig.computeDirect(symmA);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    SelfAdjointEigenSolver<RowMajorMatrix2d> eigRef(symmA);
+    VERIFY_IS_APPROX(eigRef.eigenvalues(), eig.eigenvalues());
+  }
+
+  // 3x3 RowMajor float
+  {
+    RowMajorMatrix3f a = RowMajorMatrix3f::Random();
+    RowMajorMatrix3f symmA = a.transpose() * a;
+    SelfAdjointEigenSolver<RowMajorMatrix3f> eig;
+    eig.computeDirect(symmA);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    SelfAdjointEigenSolver<RowMajorMatrix3f> eigRef(symmA);
+    VERIFY_IS_APPROX(eigRef.eigenvalues(), eig.eigenvalues());
+  }
+
+  // 2x2 RowMajor float
+  {
+    RowMajorMatrix2f a = RowMajorMatrix2f::Random();
+    RowMajorMatrix2f symmA = a.transpose() * a;
+    SelfAdjointEigenSolver<RowMajorMatrix2f> eig;
+    eig.computeDirect(symmA);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    SelfAdjointEigenSolver<RowMajorMatrix2f> eigRef(symmA);
+    VERIFY_IS_APPROX(eigRef.eigenvalues(), eig.eigenvalues());
+  }
+
+  // Dynamic RowMajor with iterative solver
+  {
+    typedef Matrix<double, Dynamic, Dynamic, RowMajor> RowMajorMatrixXd;
+    int s = internal::random<int>(2, 20);
+    RowMajorMatrixXd a = RowMajorMatrixXd::Random(s, s);
+    RowMajorMatrixXd symmA = a.transpose() * a;
+    SelfAdjointEigenSolver<RowMajorMatrixXd> eig(symmA);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    double scaling = symmA.cwiseAbs().maxCoeff();
+    if (scaling > (std::numeric_limits<double>::min)()) {
+      VERIFY_IS_APPROX((symmA.template selfadjointView<Lower>() * eig.eigenvectors()) / scaling,
+                       (eig.eigenvectors() * eig.eigenvalues().asDiagonal()) / scaling);
+    }
+  }
+}
+
 template <int>
 void bug_854() {
   Matrix3d m;
@@ -227,56 +779,691 @@
   VERIFY_IS_APPROX(eig1.eigenvalues(), eig2.eigenvalues());
 }
 
+// Verify that non-finite inputs are detected for all sizes, including 1x1.
+template <int>
+void selfadjointeigensolver_nonfinite() {
+  const double inf = std::numeric_limits<double>::infinity();
+  const double nan = std::numeric_limits<double>::quiet_NaN();
+
+  // 1x1 Inf.
+  {
+    Matrix<double, 1, 1> m;
+    m << inf;
+    SelfAdjointEigenSolver<Matrix<double, 1, 1>> eig(m);
+    VERIFY_IS_EQUAL(eig.info(), NoConvergence);
+  }
+  // 1x1 NaN.
+  {
+    Matrix<double, 1, 1> m;
+    m << nan;
+    SelfAdjointEigenSolver<Matrix<double, 1, 1>> eig(m);
+    VERIFY_IS_EQUAL(eig.info(), NoConvergence);
+  }
+  // 1x1 -Inf.
+  {
+    Matrix<double, 1, 1> m;
+    m << -inf;
+    SelfAdjointEigenSolver<Matrix<double, 1, 1>> eig(m);
+    VERIFY_IS_EQUAL(eig.info(), NoConvergence);
+  }
+  // 3x3 with Inf.
+  {
+    Matrix3d m = Matrix3d::Identity();
+    m(1, 1) = inf;
+    SelfAdjointEigenSolver<Matrix3d> eig(m);
+    VERIFY_IS_EQUAL(eig.info(), NoConvergence);
+  }
+  // 3x3 with NaN.
+  {
+    Matrix3d m = Matrix3d::Identity();
+    m(0, 1) = m(1, 0) = nan;
+    SelfAdjointEigenSolver<Matrix3d> eig(m);
+    VERIFY_IS_EQUAL(eig.info(), NoConvergence);
+  }
+  // Dynamic size with Inf.
+  {
+    MatrixXd m = MatrixXd::Identity(5, 5);
+    m(3, 3) = inf;
+    SelfAdjointEigenSolver<MatrixXd> eig(m);
+    VERIFY_IS_EQUAL(eig.info(), NoConvergence);
+  }
+}
+
 template <int>
 void bug_1204() {
   SparseMatrix<double> A(2, 2);
   A.setIdentity();
-  SelfAdjointEigenSolver<Eigen::SparseMatrix<double> > eig(A);
+  SelfAdjointEigenSolver<Eigen::SparseMatrix<double>> eig(A);
 }
 
+template <int>
+void selfadjointeigensolver_tridiagonal_zerosized() {
+  SelfAdjointEigenSolver<MatrixXd> eig;
+  VectorXd diag(0), subdiag(0);
+
+  eig.computeFromTridiagonal(diag, subdiag, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(eig.info(), Success);
+  VERIFY_IS_EQUAL(eig.eigenvalues().size(), 0);
+  VERIFY_RAISES_ASSERT(eig.eigenvectors());
+
+  eig.computeFromTridiagonal(diag, subdiag, ComputeEigenvectors);
+  VERIFY_IS_EQUAL(eig.info(), Success);
+  VERIFY_IS_EQUAL(eig.eigenvalues().size(), 0);
+  VERIFY_IS_EQUAL(eig.eigenvectors().rows(), 0);
+  VERIFY_IS_EQUAL(eig.eigenvectors().cols(), 0);
+}
+
+// Specific 3x3 test cases that stress the direct solver.
+template <int>
+void direct_3x3_stress() {
+  // Near-planar point cloud covariance: two large eigenvalues, one near-zero.
+  {
+    Matrix3d m;
+    m << 100, 50, 0.001, 50, 100, 0.002, 0.001, 0.002, 1e-10;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // All equal diagonal entries (triple eigenvalue).
+  {
+    Matrix3d m = Matrix3d::Identity() * 7.0;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Two exactly equal eigenvalues (from explicit construction).
+  {
+    Matrix3d q;
+    q << 1, 0, 0, 0, 1.0 / std::sqrt(2.0), 1.0 / std::sqrt(2.0), 0, -1.0 / std::sqrt(2.0), 1.0 / std::sqrt(2.0);
+    Vector3d d(1.0, 5.0, 5.0);
+    Matrix3d m = q * d.asDiagonal() * q.transpose();
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Large off-diagonal relative to diagonal.
+  {
+    Matrix3d m;
+    m << 1, 1000, 1000, 1000, 1, 1000, 1000, 1000, 1;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Nearly singular: one eigenvalue much smaller than others.
+  {
+    Matrix3d m;
+    m << 1, 0.5, 0.3, 0.5, 1, 0.4, 0.3, 0.4, 1;
+    m *= 1e15;
+    Matrix3d perturbation = Matrix3d::Zero();
+    perturbation(0, 0) = 1e-15;
+    m += perturbation;
+    selfadjointeigensolver_essential_check(m);
+  }
+}
+
+// Specific 2x2 test cases that stress the direct solver.
+template <int>
+void direct_2x2_stress() {
+  // Equal eigenvalues.
+  {
+    Matrix2d m = Matrix2d::Identity() * 42.0;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Very small off-diagonal.
+  {
+    Matrix2d m;
+    m << 1.0, 1e-15, 1e-15, 1.0;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Huge ratio between diagonal entries.
+  {
+    Matrix2d m;
+    m << 1e100, 0, 0, 1e-100;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Anti-diagonal dominant.
+  {
+    Matrix2d m;
+    m << 0, 1e10, 1e10, 0;
+    selfadjointeigensolver_essential_check(m);
+  }
+
+  // Negative entries.
+  {
+    Matrix2d m;
+    m << -5.0, 3.0, 3.0, -5.0;
+    selfadjointeigensolver_essential_check(m);
+  }
+}
+
+// Regression test for issue #1739: a solver constructed with its size must not
+// allocate in compute(), for any of the three generalized problem types.
+template <typename MatrixType>
+void generalizedselfadjointeigensolver_no_malloc() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index n = 20;
+
+  MatrixType a = MatrixType::Random(n, n);
+  MatrixType symmA = a + a.adjoint();
+  MatrixType b = MatrixType::Random(n, n);
+  // Make b positive definite so that its Cholesky decomposition succeeds.
+  MatrixType symmB = b * b.adjoint() + RealScalar(n) * MatrixType::Identity(n, n);
+
+  const int types[] = {Ax_lBx, ABx_lx, BAx_lx};
+  for (int type : types) {
+    for (int vecs : {int(ComputeEigenvectors), int(EigenvaluesOnly)}) {
+      GeneralizedSelfAdjointEigenSolver<MatrixType> eig(n);
+      internal::set_is_malloc_allowed(false);
+      eig.compute(symmA, symmB, vecs | type);
+      internal::set_is_malloc_allowed(true);
+      VERIFY_IS_EQUAL(eig.info(), Success);
+    }
+  }
+
+  // The reused workspaces must not change the result.
+  GeneralizedSelfAdjointEigenSolver<MatrixType> reused(n);
+  reused.compute(symmA, symmB);
+  reused.compute(symmA, symmB);
+  GeneralizedSelfAdjointEigenSolver<MatrixType> fresh(symmA, symmB);
+  VERIFY_IS_APPROX(reused.eigenvalues(), fresh.eigenvalues());
+  VERIFY_IS_APPROX(symmA * reused.eigenvectors(), symmB * reused.eigenvectors() * reused.eigenvalues().asDiagonal());
+}
+
+#if defined(EIGEN_TEST_PART_20) || defined(EIGEN_TEST_PART_ALL)
+void selfadjoint_iterative_scaling_rounding() {
+  Matrix4f matrix = Matrix4f::Zero();
+  matrix.diagonal() << numext::bit_cast<float>(numext::uint32_t(0x44123456)),
+      numext::bit_cast<float>(numext::uint32_t(0x4f123456)), numext::bit_cast<float>(numext::uint32_t(0x537dcf0e)),
+      numext::bit_cast<float>(numext::uint32_t(0x58f6aaed));
+  // A diagonal input requires no rotations: normalization must not round its representable eigenvalues.
+  for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+    SelfAdjointEigenSolver<Matrix4f> fixed(matrix, options);
+    SelfAdjointEigenSolver<MatrixXf> dynamic(matrix, options);
+    VERIFY_IS_EQUAL(fixed.info(), Success);
+    VERIFY_IS_EQUAL(dynamic.info(), Success);
+    VERIFY_IS_EQUAL(fixed.eigenvalues(), matrix.diagonal());
+    VERIFY_IS_EQUAL(dynamic.eigenvalues(), matrix.diagonal());
+  }
+  Matrix2f small = Matrix2f::Zero();
+  small.diagonal() << numext::bit_cast<float>(numext::uint32_t(0x06aceabe)),
+      numext::bit_cast<float>(numext::uint32_t(0x072319ed));
+  // compute(), not computeDirect(): fixed-size matrices also use the iterative entry point.
+  SelfAdjointEigenSolver<Matrix2f> solver(small);
+  VERIFY_IS_EQUAL(solver.eigenvalues(), small.diagonal());
+
+  Vector2f diagonal = Vector2f::Zero();
+  Matrix<float, 1, 1> offDiagonal;
+  offDiagonal[0] = numext::bit_cast<float>(numext::uint32_t(0x54fca0e4));
+  solver.computeFromTridiagonal(diagonal, offDiagonal, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_EQUAL(solver.eigenvalues()[0], -offDiagonal[0]);
+  VERIFY_IS_EQUAL(solver.eigenvalues()[1], offDiagonal[0]);
+}
+
+template <typename Scalar, int Options>
+void selfadjoint_iterative_scaling_blocks() {
+  using Real = typename NumTraits<Scalar>::Real;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Options>;
+  using Vector = Matrix<Real, Dynamic, 1>;
+  MatrixType base = MatrixType::Zero(4, 4);
+  base.diagonal() << Scalar(2), Scalar(2), Scalar(10), Scalar(10);
+  Scalar phase = Scalar(1);
+  EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsComplex) {
+    phase = numext::sqrt(Scalar(-1));
+  }
+  base(1, 0) = phase;
+  base(0, 1) = numext::conj(phase);
+  base(3, 2) = Scalar(2) * phase;
+  base(2, 3) = numext::conj(base(3, 2));
+  Vector expected(4);
+  expected << Real(1), Real(3), Real(8), Real(12);
+  // 16*n*epsilon bounds the accumulated rotations and reconstruction for these well-separated 4x4 spectra.
+  const Real tolerance = Real(64) * NumTraits<Real>::epsilon();
+  for (int exponent : {-60, 0, 60}) {
+    const Real scale = numext::ldexp(Real(1), exponent);
+    MatrixType input = base * scale;
+    input.template triangularView<StrictlyUpper>().setConstant(Scalar(std::numeric_limits<Real>::quiet_NaN()));
+    for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+      SelfAdjointEigenSolver<MatrixType> solver(input, options);
+      VERIFY_IS_EQUAL(solver.info(), Success);
+      const Vector values = solver.eigenvalues() / scale;
+      VERIFY(values.allFinite());
+      VERIFY((values - expected).norm() <= tolerance * expected.norm());
+      if (options == ComputeEigenvectors) {
+        const MatrixType& vectors = solver.eigenvectors();
+        VERIFY(vectors.allFinite());
+        VERIFY((base * vectors - vectors * values.asDiagonal()).norm() <= tolerance * base.norm());
+        VERIFY((vectors.adjoint() * vectors - MatrixType::Identity(4, 4)).norm() <= tolerance);
+      }
+    }
+  }
+
+  // Two nontrivial blocks at different scales exercise restoration when the active block changes.
+  Vector diagonal = Vector::Zero(4), offDiagonal(3);
+  const Real large = numext::ldexp(Real(1.5), 60);
+  offDiagonal << Real(1.5), Real(0), large;
+  expected << -large, Real(-1.5), Real(1.5), large;
+  for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+    SelfAdjointEigenSolver<MatrixType> solver;
+    solver.computeFromTridiagonal(diagonal, offDiagonal, options);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(solver.eigenvalues().allFinite());
+    VERIFY(((solver.eigenvalues() - expected).array().abs() <= tolerance * expected.array().abs()).all());
+    if (options == ComputeEigenvectors) {
+      MatrixType matrix = MatrixType::Zero(4, 4);
+      matrix(0, 1) = matrix(1, 0) = Scalar(1.5);
+      matrix(2, 3) = matrix(3, 2) = Scalar(large);
+      const MatrixType& vectors = solver.eigenvectors();
+      VERIFY(vectors.allFinite());
+      const MatrixType residual = matrix * vectors - vectors * solver.eigenvalues().asDiagonal();
+      // Normalize each block separately so the large block cannot mask errors in the small one.
+      VERIFY((residual.template topRows<2>() / Real(1.5)).norm() <= tolerance);
+      VERIFY((residual.template bottomRows<2>() / large).norm() <= tolerance);
+      VERIFY((vectors.adjoint() * vectors - MatrixType::Identity(4, 4)).norm() <= tolerance);
+    }
+  }
+  // An interrupted QR iteration must still restore the active block's units.
+  diagonal << Real(1), Real(2), Real(3), Real(4);
+  offDiagonal.setOnes();
+  Vector scaledDiagonal = diagonal * large, scaledOffDiagonal = offDiagonal * large;
+  MatrixType unused;
+  const auto info = internal::computeFromTridiagonal_impl<true>(diagonal, offDiagonal, 1, false, unused);
+  const auto scaledInfo =
+      internal::computeFromTridiagonal_impl<true>(scaledDiagonal, scaledOffDiagonal, 1, false, unused);
+  VERIFY_IS_EQUAL(info, NoConvergence);
+  VERIFY_IS_EQUAL(scaledInfo, info);
+  VERIFY((scaledDiagonal / large - diagonal).norm() <= tolerance * diagonal.norm());
+  VERIFY((scaledOffDiagonal / large - offDiagonal).norm() <= tolerance * offDiagonal.norm());
+}
+#endif
+
+#if defined(EIGEN_TEST_PART_21) || defined(EIGEN_TEST_PART_ALL)
+template <typename Scalar, int Size, int Options>
+void direct_selfadjoint_safe_scaling() {
+  using MatrixType = Matrix<Scalar, Size, Size, Options>;
+  using WideMatrix = Matrix<long double, Size, Size>;
+  using WideVector = Matrix<long double, Size, 1>;
+  const long double epsilon = static_cast<long double>(NumTraits<Scalar>::epsilon());
+  // Well-separated spectra: allow 32*n*epsilon for the direct formulas and reconstruction.
+  const long double tolerance = 32 * Size * epsilon;
+  MatrixType base = MatrixType::Zero();
+  base(0, 0) = Scalar(1);
+  base(1, 1) = Scalar(1);
+  base(0, 1) = base(1, 0) = Scalar(0.5);
+  EIGEN_IF_CONSTEXPR (Size == 3) {
+    base(2, 2) = Scalar(2);
+  }
+  const Scalar minimum = (std::numeric_limits<Scalar>::min)();
+  const Scalar maximum = NumTraits<Scalar>::highest();
+  for (Scalar scale : {Scalar(1), minimum, Scalar(minimum / Scalar(16)), Scalar(maximum / Scalar(8))}) {
+    for (bool zeroTrace : {false, true}) {
+      MatrixType input;
+      // ARMv7 NEON flushes subnormal products even outside ScopedFlushToZero.
+      // Construct the intended coefficients without packet arithmetic.
+      for (Index j = 0; j < Size; ++j)
+        for (Index i = 0; i < Size; ++i) {
+          volatile Scalar coefficient = base(i, j);
+          input(i, j) = coefficient * scale;
+        }
+      if (zeroTrace) input.diagonal().setZero();
+      const WideMatrix normalized = input.template cast<long double>() / static_cast<long double>(scale);
+      input.template triangularView<StrictlyUpper>().setConstant(Scalar(std::numeric_limits<Scalar>::quiet_NaN()));
+      for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+#if EIGEN_ARCH_i386_OR_x86_64 && defined(_MM_SET_DENORMALS_ZERO_MODE)
+        for (int flushMode : {0, 1, 2, 3}) {
+          // Binary64 long double has no encoding-based scaling path yet.
+          if (flushMode != 0 && std::is_same<Scalar, long double>::value &&
+              std::numeric_limits<long double>::digits == std::numeric_limits<double>::digits)
+            continue;
+          SelfAdjointEigenSolver<MatrixType> solver;
+          {
+            // Preserve the caller's FP state; select FTZ and DAZ independently inside this scope.
+            ScopedFlushToZero mode;
+            const unsigned int ftz = (flushMode & 1) ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF;
+            const unsigned int daz = (flushMode & 2) ? _MM_DENORMALS_ZERO_ON : _MM_DENORMALS_ZERO_OFF;
+            _MM_SET_FLUSH_ZERO_MODE(ftz);
+            _MM_SET_DENORMALS_ZERO_MODE(daz);
+            VERIFY(mode.isSupported());
+            VERIFY_IS_EQUAL(_MM_GET_FLUSH_ZERO_MODE(), ftz);
+            VERIFY_IS_EQUAL(_MM_GET_DENORMALS_ZERO_MODE(), daz);
+            solver.computeDirect(input, options);
+          }
+#else
+        for (bool flush : {false, true}) {
+          if (flush && std::is_same<Scalar, long double>::value &&
+              std::numeric_limits<long double>::digits == std::numeric_limits<double>::digits)
+            continue;
+          SelfAdjointEigenSolver<MatrixType> solver;
+          if (flush) {
+            ScopedFlushToZero mode;
+            solver.computeDirect(input, options);
+          } else {
+            solver.computeDirect(input, options);
+          }
+#endif
+          VERIFY_IS_EQUAL(solver.info(), Success);
+          VERIFY(solver.eigenvalues().allFinite());
+          const WideVector values = solver.eigenvalues().template cast<long double>() / static_cast<long double>(scale);
+          SelfAdjointEigenSolver<WideMatrix> reference(normalized, EigenvaluesOnly);
+          const long double quantum =
+              static_cast<long double>(std::numeric_limits<Scalar>::denorm_min()) / static_cast<long double>(scale);
+          VERIFY((values - reference.eigenvalues()).norm() <= tolerance * normalized.norm() + Size * quantum);
+          for (Index i = 1; i < Size; ++i) VERIFY(values[i - 1] <= values[i]);
+          if (options == ComputeEigenvectors) {
+            VERIFY(solver.eigenvectors().allFinite());
+            const WideMatrix vectors = solver.eigenvectors().template cast<long double>();
+            VERIFY((normalized * vectors - vectors * values.asDiagonal()).norm() <=
+                   tolerance * normalized.norm() + Size * quantum);
+            VERIFY((vectors.transpose() * vectors - WideMatrix::Identity()).norm() <= tolerance);
+          }
+        }
+      }
+    }
+  }
+  // Same-sign traces and mixed-sign centering can overflow even though every eigenvalue is representable.
+  for (int negativeCount = 0; negativeCount <= Size; ++negativeCount) {
+    MatrixType input = MatrixType::Identity() * maximum;
+    for (int i = 0; i < negativeCount; ++i) input(i, i) = -maximum;
+    for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+      SelfAdjointEigenSolver<MatrixType> solver;
+      solver.computeDirect(input, options);
+      VERIFY_IS_EQUAL(solver.info(), Success);
+      VERIFY(solver.eigenvalues().allFinite());
+      const WideVector values = solver.eigenvalues().template cast<long double>() / static_cast<long double>(maximum);
+      for (Index i = 0; i < Size; ++i) {
+        VERIFY(numext::abs(values[i] - (i < negativeCount ? -1.L : 1.L)) <= tolerance);
+      }
+      if (options == ComputeEigenvectors) {
+        const WideMatrix vectors = solver.eigenvectors().template cast<long double>();
+        const WideMatrix normalized = input.template cast<long double>() / static_cast<long double>(maximum);
+        VERIFY((normalized * vectors - vectors * values.asDiagonal()).norm() <= tolerance * normalized.norm());
+        VERIFY((vectors.transpose() * vectors - WideMatrix::Identity()).norm() <= tolerance);
+      }
+    }
+  }
+}
+template <typename Scalar, int Options>
+void direct_selfadjoint_rotated_boundary() {
+  using MatrixType = Matrix<Scalar, 3, 3, Options>;
+  using WideMatrix = Matrix<long double, 3, 3>;
+  using WideVector = Matrix<long double, 3, 1>;
+  const long double epsilon = NumTraits<Scalar>::epsilon();
+  const Scalar scale = numext::ldexp(Scalar(1), std::numeric_limits<Scalar>::max_exponent - 1);
+  const long double repeated = 2 - 64 * epsilon;
+  const long double tolerance = 48 * epsilon;
+  for (int i = 0; i < 32; ++i) {
+    WideVector axis;
+    axis << i + 1, (7 * i) % 17 + 1, (11 * i) % 23 + 1;
+    axis.normalize();
+    for (long double distinct : {0.5L, -1.5L}) {
+      // Rank-one perturbation: eigenvalues distinct, repeated, repeated.
+      // The 64*epsilon boundary margin dominates coefficient rounding.
+      const WideMatrix exact = repeated * WideMatrix::Identity() + (distinct - repeated) * axis * axis.transpose();
+      const MatrixType input = exact.template cast<Scalar>() * scale;
+      const WideMatrix normalized = input.template cast<long double>() / static_cast<long double>(scale);
+      WideVector expected;
+      expected << distinct, repeated, repeated;
+      // Weyl's bound includes coefficient rounding in the stored matrix.
+      VERIFY(expected.maxCoeff() + (normalized - exact).norm() <
+             static_cast<long double>(NumTraits<Scalar>::highest()) / static_cast<long double>(scale));
+      for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+        SelfAdjointEigenSolver<MatrixType> solver;
+        solver.computeDirect(input, options);
+        VERIFY_IS_EQUAL(solver.info(), Success);
+        VERIFY(solver.eigenvalues().allFinite());
+        const WideVector values = solver.eigenvalues().template cast<long double>() / static_cast<long double>(scale);
+        VERIFY((values - expected).norm() <= tolerance * normalized.norm());
+        if (options == ComputeEigenvectors) {
+          const WideMatrix vectors = solver.eigenvectors().template cast<long double>();
+          VERIFY((normalized * vectors - vectors * values.asDiagonal()).norm() <= tolerance * normalized.norm());
+          VERIFY((vectors.transpose() * vectors - WideMatrix::Identity()).norm() <= tolerance);
+        }
+      }
+    }
+  }
+}
+
+template <typename Scalar, int Size>
+void direct_selfadjoint_scaling_window() {
+  using MatrixType = Matrix<Scalar, Size, Size>;
+  using WideMatrix = Matrix<long double, Size, Size>;
+  using WideVector = Matrix<long double, Size, 1>;
+  // Independently tabulated float/double limits: test inside, on and outside both edges.
+  const int lower = Size == 2 ? (sizeof(Scalar) == 4 ? -45 : -479) : (sizeof(Scalar) == 4 ? -15 : -159);
+  const int upper = Size == 2 ? (sizeof(Scalar) == 4 ? 57 : 505) : (sizeof(Scalar) == 4 ? 19 : 168);
+  MatrixType base = MatrixType::Zero();
+  base(0, 0) = Scalar(-1);
+  base(Size - 1, Size - 1) = Scalar(1);
+  for (Index i = 1; i < Size; ++i) base(i, i - 1) = base(i - 1, i) = Scalar(0.25);
+  const WideMatrix normalized = base.template cast<long double>();
+  SelfAdjointEigenSolver<WideMatrix> reference(normalized);
+  const long double tolerance = 32 * Size * static_cast<long double>(NumTraits<Scalar>::epsilon());
+  for (int exponent : {lower - 1, lower, lower + 1, upper - 1, upper, upper + 1}) {
+    const Scalar scale = numext::ldexp(Scalar(1), exponent);
+    const MatrixType input = base * scale;
+    for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+      for (bool flush : {false, true}) {
+        SelfAdjointEigenSolver<MatrixType> solver;
+        if (flush) {
+          ScopedFlushToZero mode;
+          solver.computeDirect(input, options);
+        } else {
+          solver.computeDirect(input, options);
+        }
+        VERIFY_IS_EQUAL(solver.info(), Success);
+        const WideVector values = solver.eigenvalues().template cast<long double>() / static_cast<long double>(scale);
+        VERIFY((values - reference.eigenvalues()).norm() <= tolerance);
+        if (options == ComputeEigenvectors) {
+          const WideMatrix vectors = solver.eigenvectors().template cast<long double>();
+          VERIFY((normalized * vectors - vectors * values.asDiagonal()).norm() <= tolerance);
+          VERIFY((vectors.transpose() * vectors - WideMatrix::Identity()).norm() <= tolerance);
+        }
+      }
+    }
+  }
+}
+
+template <typename Scalar, int Options>
+void direct_selfadjoint_clustered_boundary() {
+  using MatrixType = Matrix<Scalar, 3, 3, Options>;
+  using WideMatrix = Matrix<long double, 3, 3>;
+  using WideVector = Matrix<long double, 3, 1>;
+  const long double epsilon = static_cast<long double>(NumTraits<Scalar>::epsilon());
+  const Scalar scale = numext::ldexp(Scalar(1), std::numeric_limits<Scalar>::max_exponent - 1);
+  const long double normalizedMaximum =
+      static_cast<long double>(NumTraits<Scalar>::highest()) / static_cast<long double>(scale);
+  const long double diagonal = normalizedMaximum - 0.25L - 4 * epsilon;
+  // A/scale = (d+b)*I - b*ones(3,3), b=1/4: eigenvalues d-2*b, d+b, d+b.
+  // Keep the repeated roots below the actual boundary: highest()/scale is not
+  // 2-epsilon for IBM double-double long double.
+  MatrixType input = MatrixType::Constant(Scalar(-0.25) * scale);
+  input.diagonal().setConstant(Scalar(diagonal) * scale);
+  const WideMatrix normalized = input.template cast<long double>() / static_cast<long double>(scale);
+  WideVector expected;
+  expected << diagonal - 0.5L, diagonal + 0.25L, diagonal + 0.25L;
+  VERIFY(expected.maxCoeff() < normalizedMaximum);
+  VERIFY(input.cwiseAbs().maxCoeff() > (NumTraits<Scalar>::highest() * Scalar(0.5)) / Scalar(3));
+  // Confirm that tridiagonalization leaves a coupling requiring QR iteration.
+  Tridiagonalization<MatrixType> tridiagonal(normalized.template cast<Scalar>());
+  Matrix<Scalar, 3, 1> diag = tridiagonal.diagonal();
+  Matrix<Scalar, 2, 1> subdiag = tridiagonal.subDiagonal();
+  MatrixType unusedVectors;
+  VERIFY_IS_EQUAL(internal::computeFromTridiagonal_impl<false>(diag, subdiag, 0, false, unusedVectors), NoConvergence);
+  // A 3x3 QR solve is backward stable to O(n*epsilon); allow 16*n rounding errors.
+  const long double tolerance = 48 * epsilon;
+  for (int options : {EigenvaluesOnly, ComputeEigenvectors}) {
+    SelfAdjointEigenSolver<MatrixType> solver;
+    solver.computeDirect(input, options);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(solver.eigenvalues().allFinite());
+    const WideVector values = solver.eigenvalues().template cast<long double>() / static_cast<long double>(scale);
+    VERIFY((values - expected).norm() <= tolerance * normalized.norm());
+    VERIFY(values[0] <= values[1] && values[1] <= values[2]);
+    if (options == ComputeEigenvectors) {
+      VERIFY(solver.eigenvectors().allFinite());
+      const WideMatrix vectors = solver.eigenvectors().template cast<long double>();
+      VERIFY((normalized * vectors - vectors * values.asDiagonal()).norm() <= tolerance * normalized.norm());
+      VERIFY((vectors.transpose() * vectors - WideMatrix::Identity()).norm() <= tolerance);
+    }
+  }
+}
+
+template <typename Scalar, int Size>
+void direct_selfadjoint_low_precision_boundary() {
+  using MatrixType = Matrix<Scalar, Size, Size>;
+  using WideMatrix = Matrix<double, Size, Size>;
+  const Scalar maximum = NumTraits<Scalar>::highest();
+  MatrixType input = MatrixType::Identity() * maximum;
+  for (int negativeCount = 0; negativeCount <= Size; ++negativeCount) {
+    if (negativeCount > 0) input(negativeCount - 1, negativeCount - 1) = -maximum;
+    SelfAdjointEigenSolver<MatrixType> solver;
+    solver.computeDirect(input);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    for (Index i = 0; i < Size; ++i) VERIFY_IS_EQUAL(solver.eigenvalues()[i], i < negativeCount ? -maximum : maximum);
+    const WideMatrix vectors = solver.eigenvectors().template cast<double>();
+    const WideMatrix normalized = input.template cast<double>() / double(maximum);
+    const auto values = solver.eigenvalues().template cast<double>() / double(maximum);
+    const double tolerance = 8 * Size * double(NumTraits<Scalar>::epsilon());
+    VERIFY((normalized * vectors - vectors * values.asDiagonal()).norm() <= tolerance);
+    VERIFY((vectors.transpose() * vectors - WideMatrix::Identity()).norm() <= tolerance);
+  }
+}
+#endif
+
 EIGEN_DECLARE_TEST(eigensolver_selfadjoint) {
+  CALL_SUBTEST_20(selfadjoint_iterative_scaling_rounding());
+  CALL_SUBTEST_20((selfadjoint_iterative_scaling_blocks<float, ColMajor>()));
+  CALL_SUBTEST_20((selfadjoint_iterative_scaling_blocks<double, RowMajor>()));
+  CALL_SUBTEST_20((selfadjoint_iterative_scaling_blocks<std::complex<float>, RowMajor>()));
+  CALL_SUBTEST_20((selfadjoint_iterative_scaling_blocks<std::complex<double>, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_clustered_boundary<float, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_rotated_boundary<float, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_rotated_boundary<double, RowMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_scaling_window<float, 2>()));
+  CALL_SUBTEST_21((direct_selfadjoint_scaling_window<float, 3>()));
+  CALL_SUBTEST_21((direct_selfadjoint_scaling_window<double, 2>()));
+  CALL_SUBTEST_21((direct_selfadjoint_scaling_window<double, 3>()));
+  CALL_SUBTEST_21((direct_selfadjoint_clustered_boundary<double, RowMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_clustered_boundary<long double, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_clustered_boundary<half, RowMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_clustered_boundary<bfloat16, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_safe_scaling<float, 2, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_safe_scaling<float, 3, RowMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_safe_scaling<double, 2, RowMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_safe_scaling<double, 3, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_safe_scaling<long double, 3, ColMajor>()));
+  CALL_SUBTEST_21((direct_selfadjoint_low_precision_boundary<half, 2>()));
+  CALL_SUBTEST_21((direct_selfadjoint_low_precision_boundary<half, 3>()));
+  CALL_SUBTEST_21((direct_selfadjoint_low_precision_boundary<bfloat16, 2>()));
+  CALL_SUBTEST_21((direct_selfadjoint_low_precision_boundary<bfloat16, 3>()));
   int s = 0;
+  CALL_SUBTEST_4(generalizedselfadjointeigensolver_no_malloc<MatrixXd>());
+  CALL_SUBTEST_5(generalizedselfadjointeigensolver_no_malloc<MatrixXcd>());
+  CALL_SUBTEST_5(selfadjointeigensolver_dense_deflation_scale_invariance<float>());
+  CALL_SUBTEST_5(selfadjointeigensolver_dense_deflation_scale_invariance<double>());
+  CALL_SUBTEST_13(selfadjointeigensolver_subnormal_coefficients());
+
   for (int i = 0; i < g_repeat; i++) {
     // trivial test for 1x1 matrices:
     CALL_SUBTEST_1(selfadjointeigensolver(Matrix<float, 1, 1>()));
-    CALL_SUBTEST_1(selfadjointeigensolver(Matrix<double, 1, 1>()));
-    CALL_SUBTEST_1(selfadjointeigensolver(Matrix<std::complex<double>, 1, 1>()));
+    CALL_SUBTEST_10(selfadjointeigensolver(Matrix<double, 1, 1>()));
+    CALL_SUBTEST_11(selfadjointeigensolver(Matrix<std::complex<double>, 1, 1>()));
 
     // very important to test 3x3 and 2x2 matrices since we provide special paths for them
     CALL_SUBTEST_12(selfadjointeigensolver(Matrix2f()));
-    CALL_SUBTEST_12(selfadjointeigensolver(Matrix2d()));
-    CALL_SUBTEST_12(selfadjointeigensolver(Matrix2cd()));
+    CALL_SUBTEST_15(selfadjointeigensolver(Matrix2d()));
+    CALL_SUBTEST_16(selfadjointeigensolver(Matrix2cd()));
     CALL_SUBTEST_13(selfadjointeigensolver(Matrix3f()));
-    CALL_SUBTEST_13(selfadjointeigensolver(Matrix3d()));
-    CALL_SUBTEST_13(selfadjointeigensolver(Matrix3cd()));
+    CALL_SUBTEST_17(selfadjointeigensolver(Matrix3d()));
+    CALL_SUBTEST_18(selfadjointeigensolver(Matrix3cd()));
     CALL_SUBTEST_2(selfadjointeigensolver(Matrix4d()));
-    CALL_SUBTEST_2(selfadjointeigensolver(Matrix4cd()));
+    CALL_SUBTEST_14(selfadjointeigensolver(Matrix4cd()));
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
     CALL_SUBTEST_3(selfadjointeigensolver(MatrixXf(s, s)));
     CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(s, s)));
     CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(s, s)));
     CALL_SUBTEST_9(selfadjointeigensolver(Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     // some trivial but implementation-wise tricky cases
     CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(1, 1)));
     CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(2, 2)));
     CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(1, 1)));
     CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(2, 2)));
-    CALL_SUBTEST_6(selfadjointeigensolver(Matrix<double, 1, 1>()));
-    CALL_SUBTEST_7(selfadjointeigensolver(Matrix<double, 2, 2>()));
+
+    // repeated eigenvalues
+    CALL_SUBTEST_17(selfadjointeigensolver_repeated_eigenvalues(Matrix3d()));
+    CALL_SUBTEST_15(selfadjointeigensolver_repeated_eigenvalues(Matrix2d()));
+    CALL_SUBTEST_2(selfadjointeigensolver_repeated_eigenvalues(Matrix4d()));
+    CALL_SUBTEST_4(selfadjointeigensolver_repeated_eigenvalues(MatrixXd(s, s)));
+    CALL_SUBTEST_13(selfadjointeigensolver_repeated_eigenvalues(Matrix3f()));
+    CALL_SUBTEST_12(selfadjointeigensolver_repeated_eigenvalues(Matrix2f()));
+    CALL_SUBTEST_18(selfadjointeigensolver_repeated_eigenvalues(Matrix3cd()));
+
+    // extreme eigenvalues (near overflow/underflow, high condition number)
+    CALL_SUBTEST_17(selfadjointeigensolver_extreme_eigenvalues(Matrix3d()));
+    CALL_SUBTEST_2(selfadjointeigensolver_extreme_eigenvalues(Matrix4d()));
+    CALL_SUBTEST_4(selfadjointeigensolver_extreme_eigenvalues(MatrixXd(s, s)));
+    CALL_SUBTEST_13(selfadjointeigensolver_extreme_eigenvalues(Matrix3f()));
+    CALL_SUBTEST_3(selfadjointeigensolver_extreme_eigenvalues(MatrixXf(s, s)));
+
+    // computeFromTridiagonal with scaled inputs
+    CALL_SUBTEST_4(selfadjointeigensolver_tridiagonal_scaled(MatrixXd(s, s)));
+    CALL_SUBTEST_3(selfadjointeigensolver_tridiagonal_scaled(MatrixXf(s, s)));
+
+    // structured tridiagonal hard cases from the literature
+    CALL_SUBTEST_4(selfadjointeigensolver_structured_tridiagonal<double>());
+    CALL_SUBTEST_3(selfadjointeigensolver_structured_tridiagonal<float>());
+
+    // wide dynamic range tridiagonal (per-block scaling regression)
+    CALL_SUBTEST_4(selfadjointeigensolver_tridiagonal_wide_range<double>());
+    CALL_SUBTEST_3(selfadjointeigensolver_tridiagonal_wide_range<float>());
+
+    // diagonal matrices
+    CALL_SUBTEST_17(selfadjointeigensolver_diagonal(Matrix3d()));
+    CALL_SUBTEST_4(selfadjointeigensolver_diagonal(MatrixXd(s, s)));
+
+    // operatorInverseSqrt
+    CALL_SUBTEST_17(selfadjointeigensolver_inverse_sqrt(Matrix3d()));
+    CALL_SUBTEST_2(selfadjointeigensolver_inverse_sqrt(Matrix4d()));
+    CALL_SUBTEST_4(selfadjointeigensolver_inverse_sqrt(MatrixXd(s, s)));
+    CALL_SUBTEST_13(selfadjointeigensolver_inverse_sqrt(Matrix3f()));
+
+    // RowMajor
+    CALL_SUBTEST_19(selfadjointeigensolver_rowmajor<0>());
+
+    // Larger matrices to exercise the blocked tridiagonalization path (n >= 96).
+    CALL_SUBTEST_4(selfadjointeigensolver(MatrixXd(256, 256)));
+    CALL_SUBTEST_5(selfadjointeigensolver(MatrixXcd(256, 256)));
+    CALL_SUBTEST_3(selfadjointeigensolver(MatrixXf(256, 256)));
+    CALL_SUBTEST_9(selfadjointeigensolver(Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>(256, 256)));
+
+    // Deterministic blocked-path stress: clustered + extreme spectra at n=128
+    // (>= the n>=96 blocking threshold). The repeated/near-repeated and high-
+    // dynamic-range cases are the ones most likely to expose a stability
+    // regression in the rank-2k trailing update.
+    CALL_SUBTEST_4(selfadjointeigensolver_repeated_eigenvalues(MatrixXd(128, 128)));
+    CALL_SUBTEST_4(selfadjointeigensolver_extreme_eigenvalues(MatrixXd(128, 128)));
+    CALL_SUBTEST_3(selfadjointeigensolver_repeated_eigenvalues(MatrixXf(128, 128)));
+    CALL_SUBTEST_5(selfadjointeigensolver_repeated_eigenvalues(MatrixXcd(128, 128)));
   }
 
-  CALL_SUBTEST_13(bug_854<0>());
-  CALL_SUBTEST_13(bug_1014<0>());
-  CALL_SUBTEST_13(bug_1204<0>());
-  CALL_SUBTEST_13(bug_1225<0>());
+  CALL_SUBTEST_17(bug_854<0>());
+  CALL_SUBTEST_17(bug_1014<0>());
+  CALL_SUBTEST_17(bug_1204<0>());
+  CALL_SUBTEST_17(bug_1225<0>());
+  CALL_SUBTEST_17(selfadjointeigensolver_nonfinite<0>());
+  CALL_SUBTEST_8(selfadjointeigensolver_tridiagonal_zerosized<0>());
+
+  // Stress tests for direct 3x3 and 2x2 solvers.
+  CALL_SUBTEST_17(direct_3x3_stress<0>());
+  CALL_SUBTEST_15(direct_2x2_stress<0>());
 
   // Test problem size constructors
   s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4);
   CALL_SUBTEST_8(SelfAdjointEigenSolver<MatrixXf> tmp1(s));
   CALL_SUBTEST_8(Tridiagonalization<MatrixXf> tmp2(s));
 
-  TEST_SET_BUT_UNUSED_VARIABLE(s)
+  TEST_SET_BUT_UNUSED_VARIABLE(s);
 }
diff --git a/test/eigensolver_selfadjoint_fastmath.cpp b/test/eigensolver_selfadjoint_fastmath.cpp
new file mode 100644
index 0000000..c0ebbf1
--- /dev/null
+++ b/test/eigensolver_selfadjoint_fastmath.cpp
@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+
+#include <limits>
+
+#include <Eigen/Eigenvalues>
+
+template <typename RealScalar>
+void wilkinson_shift_avoids_squared_subdiagonal() {
+  using std::sqrt;
+
+  // Keep sqrt(min)/16 and all dependent expressions out of constant folding so they observe the active FTZ mode.
+  volatile RealScalar normal_min = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar subdiag_before = sqrt(normal_min) / RealScalar(16);
+  VERIFY(numext::is_exactly_zero(subdiag_before * subdiag_before));
+  for (int td_sign = -1; td_sign <= 1; td_sign += 2) {
+    for (int subdiag_sign = -1; subdiag_sign <= 1; subdiag_sign += 2) {
+      const RealScalar td = RealScalar(td_sign) * subdiag_before * NumTraits<RealScalar>::epsilon();
+      RealScalar diag[2] = {td, -td};
+      RealScalar subdiag[1] = {RealScalar(subdiag_sign) * subdiag_before};
+
+      internal::tridiagonal_qr_step<RealScalar, int, Matrix<RealScalar, 2, 2>>(diag, subdiag, 0, 1, nullptr);
+
+      // A Wilkinson shift nearly diagonalizes this 2x2 block in one step. Reassociating its fallback through e^2
+      // under fast-math makes the correction underflow under FTZ and instead leaves the off-diagonal unchanged.
+      const RealScalar kDeflated = RealScalar(8) * NumTraits<RealScalar>::epsilon() * subdiag_before;
+      VERIFY(numext::abs(subdiag[0]) <= kDeflated);
+    }
+  }
+}
+
+template <typename RealScalar>
+void selfadjoint_eigensolver_preserves_tiny_block() {
+  using std::sqrt;
+
+  const RealScalar epsilon = NumTraits<RealScalar>::epsilon();
+  volatile RealScalar normal_min = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar e = sqrt(normal_min) / RealScalar(16);
+  // e survives deflation, (e/epsilon)^2 > 2*abs(td), while e^2 underflows.
+  // Keep the ratio separate so fast-math cannot reassociate the test setup itself through e^2.
+  volatile RealScalar ratio = (e / (epsilon * epsilon)) / RealScalar(16);
+  const RealScalar td = e * ratio;
+  VERIFY(numext::is_exactly_zero(e * e));
+  volatile RealScalar scaled_e = e / epsilon;
+  VERIFY(scaled_e * scaled_e > RealScalar(2) * numext::abs(td));
+  Matrix<RealScalar, 3, 3> matrix;
+  matrix << RealScalar(1), RealScalar(0), RealScalar(0), RealScalar(0), td, e, RealScalar(0), e, -td;
+
+  SelfAdjointEigenSolver<Matrix<RealScalar, 3, 3>> solver(matrix, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  const RealScalar kRelative = RealScalar(8) * epsilon;
+  VERIFY(numext::abs(solver.eigenvalues()(0) + e) <= kRelative * e);
+  VERIFY(numext::abs(solver.eigenvalues()(1) - e) <= kRelative * e);
+}
+
+EIGEN_DECLARE_TEST(eigensolver_selfadjoint_fastmath) {
+  Eigen::ScopedFlushToZero flush_to_zero;
+  if (flush_to_zero.isSupported()) {
+    CALL_SUBTEST(selfadjoint_eigensolver_preserves_tiny_block<float>());
+    CALL_SUBTEST(selfadjoint_eigensolver_preserves_tiny_block<double>());
+    CALL_SUBTEST(wilkinson_shift_avoids_squared_subdiagonal<float>());
+    CALL_SUBTEST(wilkinson_shift_avoids_squared_subdiagonal<double>());
+  }
+}
diff --git a/test/evaluator_common.h b/test/evaluator_common.h
index e69de29..320e283 100644
--- a/test/evaluator_common.h
+++ b/test/evaluator_common.h
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_EVALUATOR_COMMON_H
+#define EIGEN_TEST_EVALUATOR_COMMON_H
+
+#endif  // EIGEN_TEST_EVALUATOR_COMMON_H
diff --git a/test/evaluators.cpp b/test/evaluators.cpp
index 2941536..4e12d23 100644
--- a/test/evaluators.cpp
+++ b/test/evaluators.cpp
@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/exceptions.cpp b/test/exceptions.cpp
index 751e291..6e4538c 100644
--- a/test/exceptions.cpp
+++ b/test/exceptions.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // Various sanity tests with exceptions and non trivially copyable scalar type.
 //  - no memory leak when a custom scalar type throw an exceptions
diff --git a/test/fastmath.cpp b/test/fastmath.cpp
index 6d91fe9..98fcbea 100644
--- a/test/fastmath.cpp
+++ b/test/fastmath.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include <Eigen/QR>
 
 void check(bool b, bool ref) {
   std::cout << b;
@@ -17,23 +19,6 @@
     std::cout << " BAD ";
 }
 
-#if EIGEN_COMP_MSVC && EIGEN_COMP_MSVC < 1800
-namespace std {
-template <typename T>
-bool(isfinite)(T x) {
-  return _finite(x);
-}
-template <typename T>
-bool(isnan)(T x) {
-  return _isnan(x);
-}
-template <typename T>
-bool(isinf)(T x) {
-  return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
-}
-}  // namespace std
-#endif
-
 template <typename T>
 void check_inf_nan(bool dryrun) {
   Matrix<T, Dynamic, 1> m(10);
@@ -195,6 +180,202 @@
   }
 }
 
+template <typename RealScalar>
+void check_complex_rowmajor_adjoint_product() {
+  typedef std::complex<RealScalar> Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMatrix;
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> ColMatrix;
+
+  RowMatrix mat(2, 2);
+  mat << Scalar(1, 2), Scalar(3, -4), Scalar(-5, 6), Scalar(7, 8);
+
+  RowMatrix expected(2, 2);
+  expected << Scalar(66, 0), Scalar(8, -92), Scalar(8, 92), Scalar(138, 0);
+
+  const RowMatrix row_major_result = mat.adjoint() * mat;
+  const ColMatrix col_major_result = mat.adjoint() * mat;
+
+  VERIFY_IS_APPROX(mat.adjoint() * mat, expected);
+  VERIFY_IS_APPROX(row_major_result, expected);
+  VERIFY_IS_APPROX(col_major_result, expected);
+}
+
+template <typename RealScalar>
+void check_complex_packet_arithmetic() {
+  typedef std::complex<RealScalar> Scalar;
+  typedef Matrix<Scalar, 2, 1> Vector2;
+
+  Vector2 values;
+  values << Scalar(RealScalar(0.53645928880954319), RealScalar(-0.60489662966980218)),
+      Scalar(RealScalar(0.25774142970757641), RealScalar(0.10793998506041591));
+  Scalar divisor(RealScalar(1.6611441458336193), RealScalar(-0.21123424512127231));
+  Scalar factor(RealScalar(1.2499121678643004), RealScalar(0.36146968008699221));
+
+  Vector2 quotient = values / divisor;
+  Vector2 expected_quotient;
+  expected_quotient << values.coeff(0) / divisor, values.coeff(1) / divisor;
+  VERIFY_IS_APPROX(quotient, expected_quotient);
+
+  Vector2 inverse = values.array().inverse();
+  Vector2 expected_inverse;
+  expected_inverse << Scalar(RealScalar(1)) / values.coeff(0), Scalar(RealScalar(1)) / values.coeff(1);
+  VERIFY_IS_APPROX(inverse, expected_inverse);
+
+  Vector2 product = values * factor;
+  Vector2 expected_product;
+  expected_product << values.coeff(0) * factor, values.coeff(1) * factor;
+  VERIFY_IS_APPROX(product, expected_product);
+
+  Vector2 conjugate_product = values.conjugate().cwiseProduct(Vector2::Constant(factor));
+  Vector2 expected_conjugate_product;
+  expected_conjugate_product << numext::conj(values.coeff(0)) * factor, numext::conj(values.coeff(1)) * factor;
+  VERIFY_IS_APPROX(conjugate_product, expected_conjugate_product);
+
+  // numext::divide guards against intermediate overflow (c^2 + d^2) near max representable bounds.
+  const RealScalar max_val = (std::numeric_limits<RealScalar>::max)();
+  const Scalar big_num(RealScalar(0.9) * max_val, RealScalar(0));
+  const Scalar big_denom(max_val, RealScalar(0));
+  const Scalar safe_div_result = numext::divide(big_num, big_denom);
+  VERIFY((numext::isfinite)(safe_div_result.real()));
+  VERIFY_IS_APPROX(safe_div_result, Scalar(RealScalar(0.9), RealScalar(0)));
+  VERIFY_IS_APPROX(numext::divide(RealScalar(0.9) * max_val, max_val), RealScalar(0.9));
+
+  // Verify vectorized expression division (vec / denom) on numbers that would cause
+  // intermediate overflow (c^2 + d^2 > max) in naive complex division.
+  const RealScalar intermediate_scale = numext::sqrt(max_val) * RealScalar(2);
+  const Scalar intermediate_num(RealScalar(0.9) * intermediate_scale, RealScalar(0));
+  const Scalar intermediate_denom(intermediate_scale, RealScalar(0));
+  Matrix<Scalar, Dynamic, 1> vec(8);
+  vec.fill(intermediate_num);
+  Matrix<Scalar, Dynamic, 1> vec_div = vec / intermediate_denom;
+  for (Index i = 0; i < vec.size(); ++i) {
+    VERIFY((numext::isfinite)(vec_div(i).real()));
+    VERIFY_IS_APPROX(vec_div(i), Scalar(RealScalar(0.9), RealScalar(0)));
+  }
+}
+
+template <typename RealScalar>
+void check_complex_packet_math_functions() {
+  typedef std::complex<RealScalar> Scalar;
+  typedef Matrix<Scalar, 4, 1> Vector4;
+
+  Vector4 values;
+  values << Scalar(RealScalar(0.53645928880954319), RealScalar(-0.60489662966980218)),
+      Scalar(RealScalar(0.25774142970757641), RealScalar(0.10793998506041591)),
+      Scalar(RealScalar(-0.83239073966000054), RealScalar(0.026801457199547407)),
+      Scalar(RealScalar(1.6611441458336193), RealScalar(-0.21123424512127231));
+
+  Vector4 sqrt_result = values.array().sqrt();
+  Vector4 log_result = values.array().log();
+  Vector4 exp_result = values.array().exp();
+
+  Vector4 expected_sqrt, expected_log, expected_exp;
+  for (Index i = 0; i < values.size(); ++i) {
+    expected_sqrt[i] = std::sqrt(values[i]);
+    expected_log[i] = std::log(values[i]);
+    expected_exp[i] = std::exp(values[i]);
+  }
+
+  VERIFY_IS_APPROX(sqrt_result, expected_sqrt);
+  VERIFY_IS_APPROX(log_result, expected_log);
+  VERIFY_IS_APPROX(exp_result, expected_exp);
+}
+
+template <typename RealScalar>
+void check_complex_householder_qr() {
+  typedef std::complex<RealScalar> Scalar;
+  typedef Matrix<Scalar, 3, 2> Matrix32;
+  typedef Matrix<Scalar, 2, 2> Matrix22;
+
+  Matrix32 mat;
+  mat << Scalar(RealScalar(0.59688070592806186), RealScalar(-0.21123424512127231)),
+      Scalar(RealScalar(0.83239073966000054), RealScalar(0.026801457199547407)),
+      Scalar(RealScalar(0.53645928880954319), RealScalar(-0.60489662966980218)),
+      Scalar(RealScalar(0.21393694076781777), RealScalar(0.43459380694554106)),
+      Scalar(RealScalar(0.25774142970757641), RealScalar(0.10793998506041591)),
+      Scalar(RealScalar(0.60835279200704262), RealScalar(-0.51422689790671194));
+
+  HouseholderQR<Matrix32> qr(mat);
+  Matrix32 q = qr.householderQ() * Matrix32::Identity();
+  Matrix22 r = qr.matrixQR().template topRows<2>().template triangularView<Upper>();
+  VERIFY_IS_APPROX(mat, q * r);
+}
+
+// The complex self-adjoint 1-norm takes sqrt(re^2 + im^2) in packets and falls back to the scalar
+// abs when a component is too large to square. The decision must not depend on an infinity or
+// NaN surviving fast-math: an approximate packet sqrt can turn the overflow into a NaN that a
+// maximum then discards. Large entries both on the diagonal and inside a packet of a column.
+template <typename RealScalar>
+void check_complex_selfadjoint_l1norm() {
+  typedef std::complex<RealScalar> Scalar;
+  RealScalar big = numext::sqrt(NumTraits<RealScalar>::highest()) * RealScalar(1e3);
+  Matrix<Scalar, 8, 8> m = Matrix<Scalar, 8, 8>::Identity() * big;
+  VERIFY_IS_APPROX(m.template selfadjointView<Lower>().l1Norm(), big);
+  VERIFY_IS_APPROX(m.template selfadjointView<Upper>().l1Norm(), big);
+  m.setIdentity();
+  m(2, 0) = m(0, 2) = Scalar(big, big);
+  RealScalar expected = numext::abs(Scalar(big, big)) + RealScalar(1);
+  VERIFY_IS_APPROX(m.template selfadjointView<Lower>().l1Norm(), expected);
+  VERIFY_IS_APPROX(m.template selfadjointView<Upper>().l1Norm(), expected);
+}
+
+template <typename RealScalar>
+void check_complex_fastmath() {
+  check_complex_rowmajor_adjoint_product<RealScalar>();
+  check_complex_packet_arithmetic<RealScalar>();
+  check_complex_packet_math_functions<RealScalar>();
+  check_complex_householder_qr<RealScalar>();
+  check_complex_selfadjoint_l1norm<RealScalar>();
+}
+
+// The packet implementations of these functions manipulate signs of non-zero values through a
+// -0.0 bitmask. Under fast-math flags compilers consider -0.0 and +0.0 interchangeable and may
+// substitute one such constant for the other (GCC's value numbering does this on RISC-V), which
+// silently zeroes the mask unless it is constructed from integer bits (see psignmask and
+// https://gitlab.com/libeigen/eigen/-/merge_requests/2698). Sign handling of *non-zero* inputs
+// and outputs is not relaxed by fast-math, so these checks must hold.
+template <typename Scalar>
+void check_sign_dependent_functions() {
+  typedef Array<Scalar, Dynamic, 1> ArrayType;
+  const Index n = 64;
+
+  ArrayType ya(n), xa(n);
+  for (Index i = 0; i < n; ++i) {
+    Scalar s = Scalar(1) + Scalar(i) / Scalar(n);
+    // All four quadrants.
+    ya[i] = (i & 1) ? s : -s;
+    xa[i] = (i & 2) ? Scalar(2) * s : Scalar(-2) * s;
+  }
+  // Cover the |x| == |y| special path of patan2 in all four quadrants.
+  ya[0] = Scalar(1), xa[0] = Scalar(1);
+  ya[1] = Scalar(1), xa[1] = Scalar(-1);
+  ya[2] = Scalar(-1), xa[2] = Scalar(1);
+  ya[3] = Scalar(-1), xa[3] = Scalar(-1);
+
+  const ArrayType atan2_result = ya.atan2(xa);
+  for (Index i = 0; i < n; ++i) {
+    VERIFY_IS_APPROX(atan2_result[i], std::atan2(ya[i], xa[i]));
+  }
+
+  // Mixed-sign inputs, no exact zeros, |w| up to ~3 to hit the small- and large-|x| branches.
+  const ArrayType w = ArrayType::LinSpaced(n, Scalar(-3), Scalar(3)) + Scalar(0.017);
+  const ArrayType w_unit = w / Scalar(3.2);  // in (-1, 1) for atanh
+  const ArrayType atan_result = w.atan();
+  const ArrayType sinh_result = w.sinh();
+  const ArrayType tanh_result = w.tanh();
+  const ArrayType asinh_result = w.asinh();
+  const ArrayType atanh_result = w_unit.atanh();
+  const ArrayType cbrt_result = w.cbrt();
+  for (Index i = 0; i < n; ++i) {
+    VERIFY_IS_APPROX(atan_result[i], std::atan(w[i]));
+    VERIFY_IS_APPROX(sinh_result[i], std::sinh(w[i]));
+    VERIFY_IS_APPROX(tanh_result[i], std::tanh(w[i]));
+    VERIFY_IS_APPROX(asinh_result[i], std::asinh(w[i]));
+    VERIFY_IS_APPROX(atanh_result[i], std::atanh(w_unit[i]));
+    VERIFY_IS_APPROX(cbrt_result[i], std::cbrt(w[i]));
+  }
+}
+
 EIGEN_DECLARE_TEST(fastmath) {
   std::cout << "*** float *** \n\n";
   check_inf_nan<float>(true);
@@ -206,4 +387,9 @@
   check_inf_nan<float>(false);
   check_inf_nan<double>(false);
   check_inf_nan<long double>(false);
+
+  CALL_SUBTEST_1(check_complex_fastmath<float>());
+  CALL_SUBTEST_2(check_complex_fastmath<double>());
+  CALL_SUBTEST_3(check_sign_dependent_functions<float>());
+  CALL_SUBTEST_4(check_sign_dependent_functions<double>());
 }
diff --git a/test/first_aligned.cpp b/test/first_aligned.cpp
index 6695785..b3b545e 100644
--- a/test/first_aligned.cpp
+++ b/test/first_aligned.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/float_conversion.cpp b/test/float_conversion.cpp
index 6ea8a37..1a3f89c 100644
--- a/test/float_conversion.cpp
+++ b/test/float_conversion.cpp
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include <sstream>
 
diff --git a/test/fp_control.h b/test/fp_control.h
new file mode 100644
index 0000000..a526152
--- /dev/null
+++ b/test/fp_control.h
@@ -0,0 +1,276 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_FP_CONTROL_H
+#define EIGEN_TEST_FP_CONTROL_H
+
+#include <cfenv>
+#include <cstdint>
+#include <limits>
+
+#include <Eigen/Core>
+
+#if defined(EIGEN_GPU_COMPILE_PHASE) || defined(SYCL_DEVICE_ONLY)
+#define EIGEN_TEST_DEVICE_COMPILE 1
+#else
+#define EIGEN_TEST_DEVICE_COMPILE 0
+#endif
+
+#if EIGEN_ARCH_ARM || defined(_M_ARM)
+#define EIGEN_TEST_ARCH_ARM32 1
+#else
+#define EIGEN_TEST_ARCH_ARM32 0
+#endif
+
+#if !EIGEN_TEST_DEVICE_COMPILE && EIGEN_ARCH_i386_OR_x86_64 && \
+    (defined(__SSE__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1))
+#include <xmmintrin.h>
+// The DAZ controls live here, not in <xmmintrin.h>.
+#include <pmmintrin.h>
+#define EIGEN_TEST_HAS_X86_FTZ 1
+#else
+#define EIGEN_TEST_HAS_X86_FTZ 0
+#endif
+
+#if !EIGEN_TEST_DEVICE_COMPILE && defined(_MSC_VER) && (EIGEN_TEST_ARCH_ARM32 || EIGEN_ARCH_ARM64)
+#include <float.h>
+#include <intrin.h>
+#endif
+
+#if !EIGEN_TEST_DEVICE_COMPILE &&                                                              \
+    (EIGEN_TEST_HAS_X86_FTZ || EIGEN_ARCH_ARM64 ||                                             \
+     (EIGEN_TEST_ARCH_ARM32 && ((defined(__ARM_FP) && __ARM_FP != 0) || defined(_MSC_VER))) || \
+     (EIGEN_ARCH_MIPS && defined(__mips_hard_float)))
+#define EIGEN_TEST_HAS_RUNTIME_FTZ 1
+#else
+#define EIGEN_TEST_HAS_RUNTIME_FTZ 0
+#endif
+
+namespace Eigen {
+
+// C++14 has no standard FTZ control. <cfenv> preserves the standard state;
+// architecture-specific registers preserve and control FTZ.
+//
+// PowerPC has no portable FTZ mode; ZVector, LSX, and RVV have no runtime FTZ
+// control; Hexagon/HVX has fixed QFloat subnormal semantics (Qualcomm Hexagon
+// V68 HVX Programmer's Reference Manual). Device compiler modes are unchanged.
+// Control-bit definitions follow the Intel 64 and IA-32 Architectures
+// Software Developer's Manual (MXCSR), the Arm Architecture Reference Manual
+// (FPSCR/FPCR FZ and FZ16), and MIPS Architecture for Programmers Volumes I
+// and IV-j (FCSR/MSACSR FS).
+class ScopedFlushToZero {
+ public:
+  ScopedFlushToZero() {
+#if EIGEN_TEST_HAS_RUNTIME_FTZ
+    environment_saved_ = std::fegetenv(&environment_) == 0;
+
+#if EIGEN_TEST_HAS_X86_FTZ
+    control_state_ = static_cast<std::uint32_t>(_mm_getcsr());
+    _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
+    active_ = true;
+#elif EIGEN_ARCH_ARM64 && defined(_MSC_VER)
+    control_state_ = arm64ControlState();
+    const std::uint64_t flush_to_zero = control_state_ | arm64FlushToZeroMask();
+    _WriteStatusReg(0x5a20, static_cast<__int64>(flush_to_zero));
+    __isb(_ARM64_BARRIER_SY);
+    active_ = true;
+#elif EIGEN_ARCH_ARM64 && (defined(__GNUC__) || defined(__clang__))
+    asm volatile("mrs %0, fpcr" : "=r"(control_state_));
+    const std::uint64_t flush_to_zero = control_state_ | arm64FlushToZeroMask();
+    asm volatile("msr fpcr, %0" : : "r"(flush_to_zero) : "memory");
+    asm volatile("isb" : : : "memory");
+    active_ = true;
+#elif EIGEN_TEST_ARCH_ARM32 && defined(_MSC_VER)
+    unsigned int current_control = 0;
+    if (_controlfp_s(&current_control, 0, 0) == 0) {
+      control_state_ = current_control;
+      active_ = _controlfp_s(&current_control, _DN_FLUSH, _MCW_DN) == 0;
+    }
+#elif EIGEN_TEST_ARCH_ARM32 && (defined(__GNUC__) || defined(__clang__))
+    std::uint32_t fpscr = 0;
+    asm volatile("vmrs %0, fpscr" : "=r"(fpscr));
+    control_state_ = fpscr;
+    fpscr |= armFlushToZeroMask();
+    asm volatile("vmsr fpscr, %0" : : "r"(fpscr) : "memory");
+    asm volatile("isb" : : : "memory");
+    active_ = true;
+#elif EIGEN_ARCH_MIPS && defined(__mips_hard_float) && (defined(__GNUC__) || defined(__clang__))
+    std::uint32_t fcsr = 0;
+    asm volatile("cfc1 %0, $31" : "=r"(fcsr));
+    control_state_ = fcsr;
+    fcsr |= mipsFlushToZeroMask();
+    asm volatile("ctc1 %0, $31" : : "r"(fcsr) : "memory");
+#if defined(__mips_msa)
+    asm volatile("cfcmsa %0, $1" : "=r"(vector_control_state_));
+    const std::uint32_t msacsr = vector_control_state_ | mipsFlushToZeroMask();
+    asm volatile("ctcmsa $1, %0" : : "r"(msacsr) : "memory");
+#endif
+    active_ = true;
+#endif
+#endif
+  }
+
+  ~ScopedFlushToZero() {
+#if EIGEN_TEST_HAS_RUNTIME_FTZ
+    if (!active_) return;
+
+    // Restore both forms because the C++ floating-point environment is not
+    // required to represent non-standard FTZ controls.
+    if (environment_saved_) {
+      std::fesetenv(&environment_);
+    }
+
+#if EIGEN_TEST_HAS_X86_FTZ
+    _mm_setcsr(static_cast<unsigned int>(control_state_));
+#elif EIGEN_ARCH_ARM64 && defined(_MSC_VER)
+    _WriteStatusReg(0x5a20, static_cast<__int64>(control_state_));
+    __isb(_ARM64_BARRIER_SY);
+#elif EIGEN_ARCH_ARM64 && (defined(__GNUC__) || defined(__clang__))
+    asm volatile("msr fpcr, %0" : : "r"(control_state_) : "memory");
+    asm volatile("isb" : : : "memory");
+#elif EIGEN_TEST_ARCH_ARM32 && defined(_MSC_VER)
+    unsigned int current_control = 0;
+    _controlfp_s(&current_control, static_cast<unsigned int>(control_state_), _MCW_DN);
+#elif EIGEN_TEST_ARCH_ARM32 && (defined(__GNUC__) || defined(__clang__))
+    const std::uint32_t fpscr = static_cast<std::uint32_t>(control_state_);
+    asm volatile("vmsr fpscr, %0" : : "r"(fpscr) : "memory");
+    asm volatile("isb" : : : "memory");
+#elif EIGEN_ARCH_MIPS && defined(__mips_hard_float) && (defined(__GNUC__) || defined(__clang__))
+#if defined(__mips_msa)
+    asm volatile("ctcmsa $1, %0" : : "r"(vector_control_state_) : "memory");
+#endif
+    const std::uint32_t fcsr = static_cast<std::uint32_t>(control_state_);
+    asm volatile("ctc1 %0, $31" : : "r"(fcsr) : "memory");
+#endif
+#endif
+  }
+
+  bool isSupported() const { return active_; }
+
+  // Whether the hardware currently flushes subnormal inputs to zero, read from
+  // the registers the constructor writes.  On x86 that is DAZ; the FTZ bit the
+  // constructor sets only flushes results.  The Arm and MIPS controls flush
+  // both.  A compiler told it may treat subnormals as zero leaves every bit
+  // clear, so this is a diagnostic, not a gate.  Returns false where there is
+  // no runtime control to read.
+  static bool hardwareFlushesSubnormalInputs() {
+#if !EIGEN_TEST_HAS_RUNTIME_FTZ
+    return false;
+#elif EIGEN_TEST_HAS_X86_FTZ
+    return _MM_GET_DENORMALS_ZERO_MODE() == _MM_DENORMALS_ZERO_ON;
+#elif EIGEN_ARCH_ARM64 && defined(_MSC_VER)
+    return (arm64ControlState() & arm64FlushToZeroMask()) != 0;
+#elif EIGEN_ARCH_ARM64 && (defined(__GNUC__) || defined(__clang__))
+    std::uint64_t fpcr = 0;
+    asm volatile("mrs %0, fpcr" : "=r"(fpcr));
+    return (fpcr & arm64FlushToZeroMask()) != 0;
+#elif EIGEN_TEST_ARCH_ARM32 && defined(_MSC_VER)
+    unsigned int current_control = 0;
+    if (_controlfp_s(&current_control, 0, 0) != 0) return false;
+    return (current_control & _MCW_DN) == _DN_FLUSH;
+#elif EIGEN_TEST_ARCH_ARM32 && (defined(__GNUC__) || defined(__clang__))
+    std::uint32_t fpscr = 0;
+    asm volatile("vmrs %0, fpscr" : "=r"(fpscr));
+    return (fpscr & armFlushToZeroMask()) != 0;
+#elif EIGEN_ARCH_MIPS && defined(__mips_hard_float) && (defined(__GNUC__) || defined(__clang__))
+    std::uint32_t fcsr = 0;
+    asm volatile("cfc1 %0, $31" : "=r"(fcsr));
+    return (fcsr & mipsFlushToZeroMask()) != 0;
+#else
+    return false;
+#endif
+  }
+
+  ScopedFlushToZero(const ScopedFlushToZero&) = delete;
+  ScopedFlushToZero& operator=(const ScopedFlushToZero&) = delete;
+
+ private:
+  static std::uint32_t armFlushToZeroMask() { return std::uint32_t(1) << 24; }
+
+  static std::uint64_t arm64FlushToZeroMask() {
+    std::uint64_t mask = std::uint64_t(1) << 24;
+#if defined(__ARM_FEATURE_FP16_SCALAR_ARITHMETIC) || defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+    mask |= std::uint64_t(1) << 19;
+#endif
+    return mask;
+  }
+
+#if EIGEN_ARCH_ARM64 && defined(_MSC_VER)
+  static std::uint64_t arm64ControlState() { return static_cast<std::uint64_t>(_ReadStatusReg(0x5a20)); }
+#endif
+
+  static std::uint32_t mipsFlushToZeroMask() { return std::uint32_t(1) << 24; }
+
+  // Declared only on the paths that use them: GCC 10 ignores `unused` on data
+  // members, and clang warns on a private field no member function touches.
+  bool active_ = false;
+#if EIGEN_TEST_HAS_RUNTIME_FTZ
+  std::fenv_t environment_;
+  bool environment_saved_ = false;
+  std::uint64_t control_state_ = 0;
+#if defined(__mips_msa)
+  std::uint32_t vector_control_state_ = 0;
+#endif
+#endif
+};
+
+// min * 1/2 is subnormal, so the product is exactly zero precisely when results
+// are flushed to zero. The volatile operands keep the compiler from folding the
+// probe under IEEE semantics the run time does not use.
+template <typename Scalar>
+EIGEN_DONT_INLINE Scalar underflowProbe() {
+  volatile Scalar normal_min = (std::numeric_limits<Scalar>::min)();
+  volatile Scalar one_half = Scalar(0.5);
+  return normal_min * one_half;
+}
+
+// Whether dividing a normal value by a subnormal divisor yields its IEEE 754
+// quotient here.  Two things defeat it: hardware that flushes subnormal inputs
+// (x86 DAZ, Arm FZ, MIPS FS) reads the divisor as zero, and a compiler
+// permitted to relax floating point may rewrite `x / c` as
+// `x * (Scalar(1) / c)`, whose reciprocal overflows.  The x86 FTZ bit alone
+// does not: it flushes results, and this quotient is normal.
+//
+// The division is the packet primitive that `Matrix / scalar` lowers to, plain
+// `/` where `Scalar` is not vectorized, because a compiler may relax the one
+// and leave the other alone: MSVC /fp:fast rewrites scalar division but not
+// _mm_div_pd.  The lanes are distinct runtime values, all of them checked, so
+// the packet division cannot be narrowed back to a scalar one.  The divisor
+// stays a compile-time constant, because the rewrite is a folding step the
+// compiler only reaches while it can see the value.  The numerators are read
+// through `volatile`, because a compiler free to fold the whole quotient never
+// forms the reciprocal at all; EIGEN_OPTIMIZATION_BARRIER would not do, since
+// it expands to nothing on MSVC cl.exe.  The result is compared with the exact
+// quotient rather than tested for finiteness: under -ffinite-math-only GCC
+// folds `quotient <= max` to true before the division runs.
+template <typename Scalar>
+bool subnormalDivisionIsExact() {
+  using Packet = typename internal::packet_traits<Scalar>::type;
+  constexpr int packet_size = internal::packet_traits<Scalar>::size;
+
+  volatile Scalar opaque_numerator;
+  Scalar numerators[packet_size];
+  for (int k = 0; k < packet_size; ++k) {
+    opaque_numerator = Scalar(k + 1) * (std::numeric_limits<Scalar>::min)();
+    numerators[k] = opaque_numerator;
+  }
+
+  const Packet divisor = internal::pset1<Packet>((std::numeric_limits<Scalar>::denorm_min)());
+  Scalar quotients[packet_size];
+  internal::pstoreu(quotients, internal::pdiv<Packet>(internal::ploadu<Packet>(numerators), divisor));
+
+  // (k + 1) * min / denorm_min == (k + 1) * 2^(digits - 1) == (k + 1) / epsilon.
+  for (int k = 0; k < packet_size; ++k) {
+    if (quotients[k] != Scalar(k + 1) / std::numeric_limits<Scalar>::epsilon()) return false;
+  }
+  return true;
+}
+
+}  // namespace Eigen
+
+#undef EIGEN_TEST_HAS_RUNTIME_FTZ
+#undef EIGEN_TEST_HAS_X86_FTZ
+#undef EIGEN_TEST_ARCH_ARM32
+#undef EIGEN_TEST_DEVICE_COMPILE
+
+#endif  // EIGEN_TEST_FP_CONTROL_H
diff --git a/test/geo_alignedbox.cpp b/test/geo_alignedbox.cpp
index 67ca27e..22afcc6 100644
--- a/test/geo_alignedbox.cpp
+++ b/test/geo_alignedbox.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Geometry>
diff --git a/test/geo_eulerangles.cpp b/test/geo_eulerangles.cpp
index 11c0449..4bc3a68 100644
--- a/test/geo_eulerangles.cpp
+++ b/test/geo_eulerangles.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // Silence warnings about using the deprecated non-canonical .eulerAngles(), which are still being tested.
 #define EIGEN_NO_DEPRECATED_WARNING
@@ -162,22 +163,22 @@
   // Similar to above, but with pi instead of pi/2
   Vector3 ea_pi = ea;
   ea_pi[1] = kPi;
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] = -kPi;
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] = kPi;
   ea_pi[2] = ea_pi[0];
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] = -kPi;
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
   ea_pi[1] += internal::random<Scalar>(-smallVal, smallVal);
-  test_with_some_zeros(ea_gl);
+  test_with_some_zeros(ea_pi);
 
   ea[2] = ea[0] = internal::random<Scalar>(0, kPi);
   check_all_var(ea);
diff --git a/test/geo_homogeneous.cpp b/test/geo_homogeneous.cpp
index c5ee736..53941a8 100644
--- a/test/geo_homogeneous.cpp
+++ b/test/geo_homogeneous.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Geometry>
diff --git a/test/geo_hyperplane.cpp b/test/geo_hyperplane.cpp
index bf0a181..7ce79b1 100644
--- a/test/geo_hyperplane.cpp
+++ b/test/geo_hyperplane.cpp
@@ -7,12 +7,37 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Geometry>
 #include <Eigen/LU>
 #include <Eigen/QR>
 
+// A complex plane equation may be scaled by any nonzero gamma without moving its zero set, which
+// carries (normal, offset) to (conj(gamma) * normal, gamma * offset) because dot() is
+// conjugate-linear in the normal. Neither |gamma| = 1 nor a real gamma is required; i and 3 - i
+// are both far enough from 1 for isApprox() to separate the two equations.
+template <typename HyperplaneType>
+void hyperplane_complex_scaling(const HyperplaneType &, std::false_type) {}
+
+template <typename HyperplaneType>
+void hyperplane_complex_scaling(const HyperplaneType &plane, std::true_type) {
+  using Scalar = typename HyperplaneType::Scalar;
+  using VectorType = typename HyperplaneType::VectorType;
+
+  for (const Scalar gamma : {Scalar(0, 1), Scalar(3, -1)}) {
+    HyperplaneType rescaled(numext::conj(gamma) * plane.normal(), gamma * plane.offset());
+    VERIFY(plane.isCoincident(rescaled));
+    VERIFY(rescaled.isCoincident(plane));
+    VERIFY(!plane.isApprox(rescaled));
+
+    // The scaling is exactly what signedDistance() reports, so the two zero sets agree.
+    const VectorType p = VectorType::Random(plane.dim());
+    VERIFY_IS_APPROX(rescaled.signedDistance(p), gamma * plane.signedDistance(p));
+  }
+}
+
 template <typename HyperplaneType>
 void hyperplane(const HyperplaneType &_plane) {
   /* this test covers the following files:
@@ -49,6 +74,65 @@
   VERIFY_IS_MUCH_SMALLER_THAN(pl1.signedDistance(pl1.projection(p0)), Scalar(1));
   VERIFY_IS_MUCH_SMALLER_THAN(pl1.absDistance(p1 + pl1.normal().unitOrthogonal() * s1), Scalar(1));
 
+  // isCoincident() compares hyperplanes as point sets, so it ignores the orientation that
+  // isApprox() distinguishes (issue #2033).
+  {
+    HyperplaneType flipped(-pl1.normal(), -pl1.offset());
+    VERIFY(pl1.isCoincident(pl1));
+    VERIFY(pl1.isCoincident(flipped));
+    VERIFY(flipped.isCoincident(pl1));
+    VERIFY(!pl1.isApprox(flipped));
+    // Same normal, shifted by one unit along it: still a hyperplane, no longer the same one.
+    HyperplaneType shifted(pl1.normal(), pl1.offset() + Scalar(1));
+    VERIFY(!pl1.isCoincident(shifted));
+    VERIFY(!shifted.isCoincident(pl1));
+
+    // Rescaling an equation by a nonzero factor does not move its zero set, so neither the
+    // verdict nor its independence of the argument order may depend on the coefficient
+    // magnitudes.
+    HyperplaneType hundredfold = pl1;
+    hundredfold.coeffs() *= Scalar(100);
+    HyperplaneType thousandth = pl1;
+    thousandth.coeffs() *= Scalar(RealScalar(1) / RealScalar(1024));
+    VERIFY(pl1.isCoincident(hundredfold));
+    VERIFY(hundredfold.isCoincident(pl1));
+    VERIFY(pl1.isCoincident(thousandth));
+    VERIFY(thousandth.isCoincident(pl1));
+    VERIFY(hundredfold.isCoincident(thousandth));
+    VERIFY(thousandth.isCoincident(hundredfold));
+
+    // Nearly coincident, with equations a decade apart in magnitude: what decides is the sine of
+    // the angle between them, which is at most `tilt` here and is symmetric, so a precision above
+    // it accepts and one below it rejects in both argument orders. Projecting one normal onto the
+    // other instead makes the tolerance scale with the operand order, and this pair is accepted
+    // one way and rejected the other.
+    const RealScalar tilt(0.05);
+    HyperplaneType tilted = pl1;
+    tilted.coeffs() *= Scalar(RealScalar(0.1));
+    tilted.normal() += pl1.normal().unitOrthogonal() * Scalar(RealScalar(0.1) * tilt);
+    VERIFY(pl1.isCoincident(tilted, RealScalar(2) * tilt));
+    VERIFY(tilted.isCoincident(pl1, RealScalar(2) * tilt));
+    VERIFY(!pl1.isCoincident(tilted, RealScalar(0.1) * tilt));
+    VERIFY(!tilted.isCoincident(pl1, RealScalar(0.1) * tilt));
+
+    // Rescaling the ambient coordinates by s carries (n, d) to (n, s * d) without moving anything,
+    // so the verdict may not depend on it, and a distant hyperplane may not relax the comparison of
+    // the normals: comparing the coefficient vectors as a whole gets both of these wrong once |d|
+    // dominates ||n||, and reports even perpendicular hyperplanes as coincident.
+    for (const RealScalar coordinate_scale : {RealScalar(1), RealScalar(1000), RealScalar(1000000)}) {
+      HyperplaneType distant(pl1.normal(), Scalar(coordinate_scale));
+      HyperplaneType perpendicular(pl1.normal().unitOrthogonal(), Scalar(coordinate_scale));
+      HyperplaneType nudged(pl1.normal(), Scalar(coordinate_scale * RealScalar(1.001)));
+      VERIFY(distant.isCoincident(distant));
+      VERIFY(!distant.isCoincident(perpendicular));
+      VERIFY(!perpendicular.isCoincident(distant));
+      VERIFY(!distant.isCoincident(nudged));
+      VERIFY(!nudged.isCoincident(distant));
+    }
+
+    hyperplane_complex_scaling(pl1, internal::bool_constant<NumTraits<Scalar>::IsComplex>());
+  }
+
   // transform
   if (!NumTraits<Scalar>::IsComplex) {
     MatrixType rot = MatrixType::Random(dim, dim).householderQr().householderQ();
diff --git a/test/geo_misc.cpp b/test/geo_misc.cpp
new file mode 100644
index 0000000..ab0886d
--- /dev/null
+++ b/test/geo_misc.cpp
@@ -0,0 +1,605 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2025 Rasmus Munk Larsen <rmlarsen@google.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Tests for Geometry module classes that lack dedicated test coverage:
+//   - AngleAxis edge cases
+//   - Rotation2D standalone tests
+//   - Translation standalone tests
+//   - Scaling standalone tests
+//   - Quaternion fromRotationMatrix with non-orthogonal input
+//   - Quaternion slerp edge cases
+//   - Umeyama degenerate input
+//   - Transform shear ground truth
+
+#include "main.h"
+#include <Eigen/Geometry>
+#include <Eigen/LU>
+#include <Eigen/SVD>
+
+template <typename Scalar>
+void angleaxis_edge_cases() {
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Matrix<Scalar, 3, 3> Matrix3;
+  typedef AngleAxis<Scalar> AngleAxisx;
+  typedef Quaternion<Scalar> Quaternionx;
+
+  Scalar eps = test_precision<Scalar>();
+
+  // Identity rotation (angle = 0)
+  {
+    AngleAxisx aa(Scalar(0), Vector3::UnitZ());
+    Matrix3 m = aa.toRotationMatrix();
+    VERIFY_IS_APPROX(m, Matrix3::Identity());
+    // Verify orthogonality: R^T * R = I
+    VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
+    VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+    Quaternionx q(aa);
+    VERIFY_IS_APPROX(q.toRotationMatrix(), Matrix3::Identity());
+    VERIFY_IS_APPROX(q.norm(), Scalar(1));
+  }
+
+  // 180-degree rotation around each axis
+  {
+    for (int axis = 0; axis < 3; ++axis) {
+      Vector3 ax = Vector3::Zero();
+      ax(axis) = Scalar(1);
+      AngleAxisx aa(Scalar(EIGEN_PI), ax);
+      Matrix3 m = aa.toRotationMatrix();
+      // Should be its own inverse
+      VERIFY_IS_APPROX(m * m, Matrix3::Identity());
+      // Verify orthogonality
+      VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
+      VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+      // Diagonal entry for the rotation axis should be +1, others -1
+      VERIFY_IS_APPROX(m(axis, axis), Scalar(1));
+      for (int j = 0; j < 3; ++j) {
+        if (j != axis) VERIFY_IS_APPROX(m(j, j), Scalar(-1));
+      }
+    }
+  }
+
+  // Very small angle: verify Rodrigues formula accuracy
+  {
+    Scalar tiny = Scalar(10) * NumTraits<Scalar>::epsilon();
+    AngleAxisx aa(tiny, Vector3::UnitX());
+    Matrix3 m = aa.toRotationMatrix();
+    VERIFY((m - Matrix3::Identity()).norm() < Scalar(4) * tiny);
+    // Orthogonality should hold to machine precision even for tiny angles
+    VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
+    VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+    // Round-trip through quaternion
+    Quaternionx q(aa);
+    AngleAxisx aa2(q);
+    VERIFY(numext::abs(aa2.angle()) < Scalar(4) * tiny);
+  }
+
+  // Round-trip: AngleAxis -> Matrix -> AngleAxis
+  {
+    Scalar a = internal::random<Scalar>(Scalar(0.1), Scalar(EIGEN_PI) - Scalar(0.1));
+    Vector3 axis = Vector3::Random().normalized();
+    AngleAxisx aa(a, axis);
+    Matrix3 m = aa.toRotationMatrix();
+    VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
+    VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+    AngleAxisx aa2;
+    aa2.fromRotationMatrix(m);
+    VERIFY_IS_APPROX(aa.toRotationMatrix(), aa2.toRotationMatrix());
+    // Verify angle is preserved
+    VERIFY(numext::abs(aa2.angle() - a) < eps);
+  }
+
+  // Round-trip for near-180-degree rotation
+  {
+    Scalar a = Scalar(EIGEN_PI) - Scalar(10) * NumTraits<Scalar>::epsilon();
+    Vector3 axis = Vector3::Random().normalized();
+    AngleAxisx aa(a, axis);
+    Matrix3 m = aa.toRotationMatrix();
+    VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
+    VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+    AngleAxisx aa2(m);
+    // The rotation should be equivalent even if axis flips sign
+    VERIFY_IS_APPROX(aa.toRotationMatrix(), aa2.toRotationMatrix());
+  }
+
+  // Accessors
+  {
+    Vector3 axis = Vector3::Random().normalized();
+    Scalar angle = internal::random<Scalar>(Scalar(-EIGEN_PI), Scalar(EIGEN_PI));
+    AngleAxisx aa(angle, axis);
+    VERIFY_IS_APPROX(aa.angle(), angle);
+    VERIFY_IS_APPROX(aa.axis(), axis);
+
+    // Mutable accessors
+    aa.angle() = Scalar(1);
+    aa.axis() = Vector3::UnitZ();
+    VERIFY_IS_APPROX(aa.angle(), Scalar(1));
+    VERIFY_IS_APPROX(aa.axis(), Vector3::UnitZ());
+  }
+
+  // inverse
+  {
+    Scalar a = internal::random<Scalar>(Scalar(0.1), Scalar(EIGEN_PI));
+    Vector3 axis = Vector3::Random().normalized();
+    AngleAxisx aa(a, axis);
+    VERIFY_IS_APPROX((aa * aa.inverse()).toRotationMatrix(), Matrix3::Identity());
+  }
+
+  // isApprox
+  {
+    Scalar a = internal::random<Scalar>(Scalar(0.1), Scalar(EIGEN_PI));
+    Vector3 axis = Vector3::Random().normalized();
+    AngleAxisx aa1(a, axis);
+    AngleAxisx aa2(a + eps / Scalar(10), axis);
+    VERIFY(aa1.isApprox(aa2, eps));
+  }
+
+  // Quaternion round-trip: AngleAxis -> Quaternion -> AngleAxis
+  {
+    Scalar a = internal::random<Scalar>(Scalar(0.1), Scalar(EIGEN_PI) - Scalar(0.1));
+    Vector3 axis = Vector3::Random().normalized();
+    AngleAxisx aa(a, axis);
+    Quaternionx q(aa);
+    VERIFY_IS_APPROX(q.norm(), Scalar(1));
+    AngleAxisx aa2(q);
+    VERIFY(numext::abs(aa2.angle() - a) < eps);
+    // Axis should agree (possibly with sign flip for angle > pi)
+    VERIFY(aa2.axis().isApprox(axis, eps) || aa2.axis().isApprox(-axis, eps));
+  }
+}
+
+template <typename Scalar>
+void rotation2d_standalone() {
+  typedef Matrix<Scalar, 2, 1> Vector2;
+  typedef Matrix<Scalar, 2, 2> Matrix2;
+  typedef Rotation2D<Scalar> Rotation2Dx;
+
+  Scalar eps = test_precision<Scalar>();
+
+  // Construction and basic properties
+  {
+    Rotation2Dx r(Scalar(0));
+    VERIFY_IS_APPROX(r.toRotationMatrix(), Matrix2::Identity());
+  }
+
+  // 90-degree rotation
+  {
+    Rotation2Dx r(Scalar(EIGEN_PI) / Scalar(2));
+    Vector2 v(1, 0);
+    Vector2 rv = r * v;
+    VERIFY_IS_APPROX(rv, Vector2(0, 1));
+  }
+
+  // 180-degree rotation
+  {
+    Rotation2Dx r(Scalar(EIGEN_PI));
+    Vector2 v(1, 0);
+    Vector2 rv = r * v;
+    VERIFY_IS_APPROX(rv, Vector2(-1, 0));
+  }
+
+  // inverse
+  {
+    Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+    Rotation2Dx r(a);
+    VERIFY_IS_APPROX((r * r.inverse()).toRotationMatrix(), Matrix2::Identity());
+  }
+
+  // composition
+  {
+    Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+    Scalar b = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+    Rotation2Dx ra(a), rb(b);
+    VERIFY_IS_APPROX((ra * rb).toRotationMatrix(), ra.toRotationMatrix() * rb.toRotationMatrix());
+  }
+
+  // fromRotationMatrix round-trip: angle should agree to tight tolerance
+  {
+    Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+    Rotation2Dx r(a);
+    Matrix2 m = r.toRotationMatrix();
+    // Verify orthogonality
+    VERIFY_IS_APPROX(m.transpose() * m, Matrix2::Identity());
+    VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+    Rotation2Dx r2(m);
+    // Angles should agree mod 2*pi. Use rotation matrices for exact comparison.
+    VERIFY_IS_APPROX(r2.toRotationMatrix(), r.toRotationMatrix());
+  }
+
+  // Rotation2D slerp interpolation: verify linearity of angle
+  {
+    Scalar a0 = internal::random<Scalar>(Scalar(-EIGEN_PI), Scalar(EIGEN_PI));
+    Scalar a1 = a0 + internal::random<Scalar>(Scalar(0.1), Scalar(1.0));
+    Rotation2Dx r0(a0), r1(a1);
+    Scalar t = Scalar(0.3);
+    Rotation2Dx rt = r0.slerp(t, r1);
+    // Slerp for 2D rotations is just linear interpolation of angle along shortest path.
+    Scalar expected = a0 + t * Rotation2Dx(a1 - a0).smallestAngle();
+    VERIFY(numext::abs(Rotation2Dx(rt.angle() - expected).smallestAngle()) < eps);
+  }
+}
+
+template <typename Scalar>
+void translation_standalone() {
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Translation<Scalar, 3> Translation3;
+  typedef Transform<Scalar, 3, Isometry> Isometry3;
+
+  // Construction
+  {
+    Vector3 v(1, 2, 3);
+    Translation3 t(v);
+    VERIFY_IS_APPROX(t.vector(), v);
+
+    Translation3 t2(Scalar(1), Scalar(2), Scalar(3));
+    VERIFY_IS_APPROX(t.vector(), t2.vector());
+  }
+
+  // Identity
+  {
+    Translation3 t = Translation3::Identity();
+    VERIFY_IS_APPROX(t.vector(), Vector3::Zero());
+  }
+
+  // Composition
+  {
+    Vector3 v1(1, 2, 3), v2(4, 5, 6);
+    Translation3 t1(v1), t2(v2);
+    Translation3 t3 = t1 * t2;
+    VERIFY_IS_APPROX(t3.vector(), v1 + v2);
+  }
+
+  // Inverse
+  {
+    Vector3 v(1, 2, 3);
+    Translation3 t(v);
+    Translation3 tinv = t.inverse();
+    VERIFY_IS_APPROX(tinv.vector(), -v);
+    VERIFY_IS_APPROX((t * tinv).vector(), Vector3::Zero());
+  }
+
+  // Translation * vector (via transform)
+  {
+    Vector3 v(1, 2, 3), p(10, 20, 30);
+    Translation3 t(v);
+    VERIFY_IS_APPROX(t * p, v + p);
+  }
+
+  // Casting
+  {
+    Translation3 t(Vector3(1, 2, 3));
+    Translation<float, 3> tf = t.template cast<float>();
+    VERIFY_IS_APPROX(tf.template cast<Scalar>().vector(), t.vector());
+  }
+
+  // Convert to Isometry
+  {
+    Vector3 v(1, 2, 3);
+    Translation3 t(v);
+    Isometry3 iso(t);
+    VERIFY_IS_APPROX(iso.translation(), v);
+    typedef Matrix<Scalar, 3, 3> Matrix3;
+    VERIFY_IS_APPROX(iso.linear(), Matrix3::Identity());
+  }
+}
+
+template <typename Scalar>
+void scaling_standalone() {
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Translation<Scalar, 3> Translation3;
+  typedef Transform<Scalar, 3, Affine> Affine3;
+  typedef UniformScaling<Scalar> UniformScalingx;
+
+  // UniformScaling construction
+  {
+    UniformScalingx s(Scalar(2));
+    VERIFY_IS_APPROX(s.factor(), Scalar(2));
+  }
+
+  // UniformScaling * vector
+  {
+    UniformScalingx s(Scalar(3));
+    Vector3 v(1, 2, 3);
+    // UniformScaling * Translation
+    Translation3 t(v);
+    Affine3 result = s * t;
+    VERIFY_IS_APPROX(result.translation(), v * Scalar(3));
+  }
+
+  // UniformScaling composition
+  {
+    UniformScalingx s1(Scalar(2)), s2(Scalar(3));
+    UniformScalingx s3 = s1 * s2;
+    VERIFY_IS_APPROX(s3.factor(), Scalar(6));
+  }
+
+  // UniformScaling inverse
+  {
+    UniformScalingx s(Scalar(4));
+    UniformScalingx si = s.inverse();
+    VERIFY_IS_APPROX(si.factor(), Scalar(1) / Scalar(4));
+    VERIFY_IS_APPROX((s * si).factor(), Scalar(1));
+  }
+
+  // Scaling convenience functions
+  {
+    Scalar s = Scalar(3);
+    auto su = Eigen::Scaling(s);
+    VERIFY_IS_APPROX(su.factor(), s);
+
+    Vector3 sv(1, 2, 3);
+    auto sd = Eigen::Scaling(sv);
+    VERIFY_IS_APPROX(Vector3(sd.diagonal()), sv);
+  }
+}
+
+template <typename Scalar>
+void quaternion_from_non_orthogonal_matrix() {
+  typedef Matrix<Scalar, 3, 3> Matrix3;
+  typedef Quaternion<Scalar> Quaternionx;
+
+  // Slightly non-orthogonal matrix should not produce NaN
+  {
+    Matrix3 m = Matrix3::Identity();
+    // Perturb to make slightly non-orthogonal
+    m(0, 0) += Scalar(1e-6);
+    m(1, 1) -= Scalar(1e-6);
+    Quaternionx q(m);
+    // Should not be NaN
+    VERIFY(!(numext::isnan)(q.w()));
+    VERIFY(!(numext::isnan)(q.x()));
+    VERIFY(!(numext::isnan)(q.y()));
+    VERIFY(!(numext::isnan)(q.z()));
+    // Should still be approximately a rotation
+    VERIFY(numext::abs(q.norm() - Scalar(1)) < Scalar(0.01));
+  }
+
+  // Negative trace case with non-orthogonal matrix
+  {
+    // 180-degree rotation around Z axis, slightly perturbed
+    Matrix3 m;
+    m << Scalar(-1), Scalar(0), Scalar(0), Scalar(0), Scalar(-1), Scalar(0), Scalar(0), Scalar(0), Scalar(1);
+    m(0, 0) += Scalar(1e-6);
+    Quaternionx q(m);
+    VERIFY(!(numext::isnan)(q.w()));
+    VERIFY(!(numext::isnan)(q.x()));
+    VERIFY(!(numext::isnan)(q.y()));
+    VERIFY(!(numext::isnan)(q.z()));
+  }
+
+  // Matrix with trace very close to -1 (worst case for positive trace branch)
+  {
+    Matrix3 m;
+    m << Scalar(-1), Scalar(0), Scalar(0), Scalar(0), Scalar(-0.5), Scalar(0), Scalar(0), Scalar(0), Scalar(-0.5);
+    // trace = -2, negative trace path
+    Quaternionx q(m);
+    VERIFY(!(numext::isnan)(q.w()));
+    VERIFY(!(numext::isnan)(q.x()));
+  }
+
+  // Verify graceful handling of arbitrary non-rotation matrices.
+  // Shoemake's argmax-diagonal selection makes the sqrt argument non-negative
+  // for any real matrix, but the numext::maxi guard provides additional safety.
+  {
+    Matrix3 m;
+    m << Scalar(-0.4), Scalar(0.5), Scalar(0), Scalar(-0.5), Scalar(-0.4), Scalar(0), Scalar(0), Scalar(0),
+        Scalar(-0.4);
+    Quaternionx q(m);
+    VERIFY(!(numext::isnan)(q.w()));
+    VERIFY(!(numext::isnan)(q.x()));
+    VERIFY(!(numext::isnan)(q.y()));
+    VERIFY(!(numext::isnan)(q.z()));
+  }
+}
+
+template <typename Scalar>
+void quaternion_slerp_edge_cases() {
+  typedef Quaternion<Scalar> Quaternionx;
+  typedef AngleAxis<Scalar> AngleAxisx;
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Matrix<Scalar, 3, 3> Matrix3;
+
+  // The slerp formula preserves unit norm to O(epsilon^2) for unit inputs.
+  Scalar tight = Scalar(32) * NumTraits<Scalar>::epsilon();
+
+  // slerp with identical quaternions
+  {
+    Quaternionx q = Quaternionx::UnitRandom();
+    Quaternionx r = q.slerp(Scalar(0.5), q);
+    VERIFY_IS_APPROX(r.coeffs(), q.coeffs());
+    VERIFY(numext::abs(r.norm() - Scalar(1)) < tight);
+  }
+
+  // slerp at t=0 and t=1
+  {
+    Quaternionx q0 = Quaternionx::UnitRandom();
+    Quaternionx q1 = Quaternionx::UnitRandom();
+    Quaternionx r0 = q0.slerp(Scalar(0), q1);
+    Quaternionx r1 = q0.slerp(Scalar(1), q1);
+    VERIFY(numext::abs(r0.norm() - Scalar(1)) < tight);
+    VERIFY(numext::abs(r1.norm() - Scalar(1)) < tight);
+    VERIFY_IS_APPROX(r0.toRotationMatrix(), q0.toRotationMatrix());
+    VERIFY_IS_APPROX(r1.toRotationMatrix(), q1.toRotationMatrix());
+  }
+
+  // slerp with antipodal quaternions (represent same rotation)
+  {
+    Quaternionx q = Quaternionx::UnitRandom();
+    Quaternionx qn;
+    qn.coeffs() = -q.coeffs();
+    for (Scalar t = 0; t <= Scalar(1.001); t += Scalar(0.25)) {
+      Quaternionx r = q.slerp(t, qn);
+      VERIFY(numext::abs(r.norm() - Scalar(1)) < tight);
+      // Should stay at the same rotation
+      VERIFY_IS_APPROX(r.toRotationMatrix(), q.toRotationMatrix());
+    }
+  }
+
+  // slerp with 180-degree apart quaternions
+  {
+    Vector3 axis1 = Vector3::UnitX();
+    Quaternionx q0(AngleAxisx(Scalar(0), axis1));
+    Quaternionx q1(AngleAxisx(Scalar(EIGEN_PI), axis1));
+    Quaternionx mid = q0.slerp(Scalar(0.5), q1);
+    VERIFY(numext::abs(mid.norm() - Scalar(1)) < tight);
+    // Midpoint should be a 90-degree rotation
+    AngleAxisx aa(mid);
+    VERIFY(numext::abs(aa.angle() - Scalar(EIGEN_PI) / Scalar(2)) < test_precision<Scalar>());
+  }
+
+  // slerp unit-norm preservation and rotation matrix orthogonality
+  {
+    Quaternionx q0 = Quaternionx::UnitRandom();
+    Quaternionx q1 = Quaternionx::UnitRandom();
+    for (Scalar t = 0; t <= Scalar(1.001); t += Scalar(0.05)) {
+      Quaternionx r = q0.slerp(t, q1);
+      VERIFY(numext::abs(r.norm() - Scalar(1)) < tight);
+      Matrix3 m = r.toRotationMatrix();
+      VERIFY_IS_APPROX(m.transpose() * m, Matrix3::Identity());
+      VERIFY_IS_APPROX(m.determinant(), Scalar(1));
+    }
+  }
+
+  // slerp monotonicity: angle from q0 should increase monotonically
+  {
+    Quaternionx q0 = Quaternionx::UnitRandom();
+    Quaternionx q1 = Quaternionx::UnitRandom();
+    Scalar prev_angle = Scalar(0);
+    for (Scalar t = Scalar(0); t <= Scalar(1.001); t += Scalar(0.05)) {
+      Quaternionx r = q0.slerp(t, q1);
+      Scalar angle = AngleAxisx(r * q0.inverse()).angle();
+      if (angle > Scalar(EIGEN_PI)) angle = Scalar(2) * Scalar(EIGEN_PI) - angle;
+      VERIFY(angle >= prev_angle - tight);
+      prev_angle = angle;
+    }
+  }
+}
+
+template <typename Scalar>
+void umeyama_degenerate() {
+  typedef Matrix<Scalar, 3, Dynamic> Points3;
+  typedef Matrix<Scalar, 3, 1> Vector3;
+  typedef Matrix<Scalar, 3, 3> Matrix3;
+  typedef Matrix<Scalar, 4, 4> Matrix4;
+
+  // All source points identical
+  {
+    int n = 10;
+    Points3 src(3, n);
+    src.colwise() = Vector3(1, 2, 3);
+    Points3 dst = Points3::Random(3, n);
+
+    Matrix4 T = umeyama(src, dst);
+    // Result should NOT be NaN
+    VERIFY(!(numext::isnan)(T(0, 0)));
+    VERIFY(!(numext::isnan)(T(0, 3)));
+  }
+
+  // All destination points identical
+  {
+    int n = 10;
+    Points3 src = Points3::Random(3, n);
+    Points3 dst(3, n);
+    dst.colwise() = Vector3(4, 5, 6);
+
+    Matrix4 T = umeyama(src, dst);
+    VERIFY(!(numext::isnan)(T(0, 0)));
+  }
+
+  // Pure translation (no rotation or scaling)
+  {
+    int n = 20;
+    Points3 src = Points3::Random(3, n);
+    Vector3 offset(10, 20, 30);
+    Points3 dst = src.colwise() + offset;
+
+    Matrix4 T = umeyama(src, dst);
+    // Translation should be recovered
+    Vector3 t_recovered = T.template block<3, 1>(0, 3);
+    VERIFY_IS_APPROX(t_recovered, offset);
+    // Rotation should be identity
+    Matrix3 R = T.template block<3, 3>(0, 0);
+    VERIFY(R.isApprox(Matrix3::Identity(), test_precision<Scalar>()));
+  }
+}
+
+template <typename Scalar>
+void shear_ground_truth() {
+  typedef Transform<Scalar, 2, Affine> Transform2;
+  typedef Matrix<Scalar, 2, 1> Vector2;
+
+  // Verify the actual matrix produced by shear()
+  // Note: Eigen's shear(sx, sy) applies the matrix [[1, sy], [sx, 1]] to columns,
+  // meaning sx controls the y-component shear and sy controls the x-component shear.
+  {
+    Transform2 t;
+    t.setIdentity();
+    t.shear(Scalar(2), Scalar(0));
+    // After shear(2, 0), linear part should be [[1, 0], [2, 1]]
+    VERIFY_IS_APPROX(t.linear()(0, 0), Scalar(1));
+    VERIFY_IS_APPROX(t.linear()(0, 1), Scalar(0));
+    VERIFY_IS_APPROX(t.linear()(1, 0), Scalar(2));
+    VERIFY_IS_APPROX(t.linear()(1, 1), Scalar(1));
+  }
+
+  {
+    Transform2 t;
+    t.setIdentity();
+    t.shear(Scalar(0), Scalar(3));
+    // After shear(0, 3), linear part should be [[1, 3], [0, 1]]
+    VERIFY_IS_APPROX(t.linear()(0, 0), Scalar(1));
+    VERIFY_IS_APPROX(t.linear()(0, 1), Scalar(3));
+    VERIFY_IS_APPROX(t.linear()(1, 0), Scalar(0));
+    VERIFY_IS_APPROX(t.linear()(1, 1), Scalar(1));
+  }
+
+  // Verify shear on a point
+  {
+    Transform2 t;
+    t.setIdentity();
+    t.shear(Scalar(2), Scalar(3));
+    Vector2 v(1, 0);
+    Vector2 result = t.linear() * v;
+    // [[1, 3], [2, 1]] * [1, 0]^T = [1, 2]
+    VERIFY_IS_APPROX(result, Vector2(1, 2));
+
+    v = Vector2(0, 1);
+    result = t.linear() * v;
+    // [[1, 3], [2, 1]] * [0, 1]^T = [3, 1]
+    VERIFY_IS_APPROX(result, Vector2(3, 1));
+  }
+}
+
+EIGEN_DECLARE_TEST(geo_misc) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(angleaxis_edge_cases<float>());
+    CALL_SUBTEST_2(angleaxis_edge_cases<double>());
+
+    CALL_SUBTEST_3(rotation2d_standalone<float>());
+    CALL_SUBTEST_4(rotation2d_standalone<double>());
+
+    CALL_SUBTEST_5(translation_standalone<float>());
+    CALL_SUBTEST_5(translation_standalone<double>());
+
+    CALL_SUBTEST_6(scaling_standalone<float>());
+    CALL_SUBTEST_6(scaling_standalone<double>());
+
+    CALL_SUBTEST_7(quaternion_from_non_orthogonal_matrix<float>());
+    CALL_SUBTEST_7(quaternion_from_non_orthogonal_matrix<double>());
+
+    CALL_SUBTEST_8(quaternion_slerp_edge_cases<float>());
+    CALL_SUBTEST_8(quaternion_slerp_edge_cases<double>());
+
+    CALL_SUBTEST_9(umeyama_degenerate<float>());
+    CALL_SUBTEST_9(umeyama_degenerate<double>());
+
+    CALL_SUBTEST_10(shear_ground_truth<float>());
+    CALL_SUBTEST_10(shear_ground_truth<double>());
+  }
+}
diff --git a/test/geo_orthomethods.cpp b/test/geo_orthomethods.cpp
index 5ee0f47..aa87bd4 100644
--- a/test/geo_orthomethods.cpp
+++ b/test/geo_orthomethods.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Geometry>
diff --git a/test/geo_parametrizedline.cpp b/test/geo_parametrizedline.cpp
index 856261e..c57a9eb 100644
--- a/test/geo_parametrizedline.cpp
+++ b/test/geo_parametrizedline.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Geometry>
@@ -40,7 +41,8 @@
   VERIFY_IS_MUCH_SMALLER_THAN(l0.distance(p0 + s0 * d0), RealScalar(1));
   VERIFY_IS_APPROX((l0.projection(p1) - p1).norm(), l0.distance(p1));
   VERIFY_IS_MUCH_SMALLER_THAN(l0.distance(l0.projection(p1)), RealScalar(1));
-  VERIFY_IS_APPROX(Scalar(l0.distance((p0 + s0 * d0) + d0.unitOrthogonal() * s1)), s1);
+  VectorType orthogonal = d0.unitOrthogonal();
+  VERIFY_IS_APPROX(Scalar(LineType(VectorType::Zero(dim), d0).distance(orthogonal * s1)), s1);
 
   // casting
   const int Dim = LineType::AmbientDimAtCompileTime;
diff --git a/test/geo_quaternion.cpp b/test/geo_quaternion.cpp
index 159a937..dd94cba 100644
--- a/test/geo_quaternion.cpp
+++ b/test/geo_quaternion.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Geometry>
@@ -37,7 +38,7 @@
     Scalar theta = AA(q * q0.inverse()).angle();
     VERIFY(abs(q.norm() - 1) < largeEps);
     if (theta_tot == 0)
-      VERIFY(theta_tot == 0);
+      VERIFY(theta < largeEps);
     else
       VERIFY(abs(theta - t * theta_tot) < largeEps);
   }
@@ -49,13 +50,15 @@
      Quaternion.h
   */
   using std::abs;
+  using std::cos;
+  using std::sin;
+  using std::sqrt;
   typedef Matrix<Scalar, 3, 1> Vector3;
   typedef Matrix<Scalar, 3, 3> Matrix3;
   typedef Quaternion<Scalar, Options> Quaternionx;
   typedef AngleAxis<Scalar> AngleAxisx;
 
   Scalar largeEps = test_precision<Scalar>();
-  if (internal::is_same<Scalar, float>::value) largeEps = Scalar(1e-3);
 
   Scalar eps = internal::random<Scalar>() * Scalar(1e-2);
 
@@ -105,6 +108,15 @@
     VERIFY_IS_MUCH_SMALLER_THAN(abs(q1.angularDistance(q2) - refangle), Scalar(1));
   }
 
+  // angular distance with non-unit quaternions (scale-invariance)
+  {
+    Quaternionx qunit(AngleAxisx(Scalar(EIGEN_PI / 2), Vector3::UnitX()));
+    Quaternionx qscaled;
+    qscaled.coeffs() = qunit.coeffs() * Scalar(2);
+    VERIFY_IS_APPROX(qscaled.angularDistance(Quaternionx::Identity()), Scalar(EIGEN_PI / 2));
+    VERIFY_IS_APPROX(Quaternionx::Identity().angularDistance(qscaled), Scalar(EIGEN_PI / 2));
+  }
+
   // Action on vector by the q v q* formula
   VERIFY_IS_APPROX(q1 * v2, (q1 * Quaternionx(Scalar(0), v2) * q1.inverse()).vec());
   VERIFY_IS_APPROX(q1.inverse() * v2, (q1.inverse() * Quaternionx(Scalar(0), v2) * q1).vec());
@@ -139,7 +151,7 @@
   VERIFY_IS_APPROX(v2.normalized(), (q2.setFromTwoVectors(v1, v2) * v1).normalized());
   VERIFY_IS_APPROX(v1.normalized(), (q2.setFromTwoVectors(v1, v1) * v1).normalized());
   VERIFY_IS_APPROX(-v1.normalized(), (q2.setFromTwoVectors(v1, -v1) * v1).normalized());
-  if (internal::is_same<Scalar, double>::value) {
+  if (std::is_same<Scalar, double>::value) {
     v3 = (v1.array() + eps).matrix();
     VERIFY_IS_APPROX(v3.normalized(), (q2.setFromTwoVectors(v1, v3) * v1).normalized());
     VERIFY_IS_APPROX(-v3.normalized(), (q2.setFromTwoVectors(v1, -v3) * v1).normalized());
@@ -149,7 +161,7 @@
   VERIFY_IS_APPROX(v2.normalized(), (Quaternionx::FromTwoVectors(v1, v2) * v1).normalized());
   VERIFY_IS_APPROX(v1.normalized(), (Quaternionx::FromTwoVectors(v1, v1) * v1).normalized());
   VERIFY_IS_APPROX(-v1.normalized(), (Quaternionx::FromTwoVectors(v1, -v1) * v1).normalized());
-  if (internal::is_same<Scalar, double>::value) {
+  if (std::is_same<Scalar, double>::value) {
     v3 = (v1.array() + eps).matrix();
     VERIFY_IS_APPROX(v3.normalized(), (Quaternionx::FromTwoVectors(v1, v3) * v1).normalized());
     VERIFY_IS_APPROX(-v3.normalized(), (Quaternionx::FromTwoVectors(v1, -v3) * v1).normalized());
@@ -165,10 +177,133 @@
   Quaternion<double> q1d = q1.template cast<double>();
   VERIFY_IS_APPROX(q1d.template cast<Scalar>(), q1);
 
+  // test assignment from 4D quaternion vector
+  {
+    Matrix<Scalar, 4, 1> vec4 = q1.coeffs();
+    AngleAxisx aa;
+    aa = vec4;
+    VERIFY_IS_APPROX(Quaternionx(aa), q1);
+  }
+
   // test bug 369 - improper alignment.
   Quaternionx* q = new Quaternionx;
   delete q;
 
+  // ---- setFromScaledAxis / toScaledAxis (SO(3) exp/log) ----
+  // Identity round-trip.
+  VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(Vector3::Zero()).coeffs(), Quaternionx::Identity().coeffs());
+  VERIFY_IS_EQUAL(Quaternionx::Identity().toScaledAxis(), Vector3::Zero());
+
+  // Canonical axis rotations: 90/180/60 degrees.
+  {
+    Vector3 sa = Vector3::UnitX() * Scalar(EIGEN_PI / 2);
+    Scalar c = sqrt(Scalar(2)) * Scalar(0.5);
+    VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa), Quaternionx(c, c, Scalar(0), Scalar(0)));
+    VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa), Quaternionx(AngleAxisx(Scalar(EIGEN_PI / 2), Vector3::UnitX())));
+  }
+  VERIFY_IS_APPROX(Quaternionx(Scalar(0), Scalar(0), Scalar(1), Scalar(0)).toScaledAxis(),
+                   Vector3(Scalar(0), Scalar(EIGEN_PI), Scalar(0)));
+  VERIFY_IS_APPROX(Quaternionx(sqrt(Scalar(3)) / Scalar(2), Scalar(0), Scalar(0), Scalar(0.5)).toScaledAxis(),
+                   Scalar(EIGEN_PI / 3) * Vector3::UnitZ());
+
+  // Small but normal angle: agrees with the closed-form half-angle quaternion.
+  {
+    Scalar theta = Scalar(1e-2);
+    Vector3 sa = Vector3::UnitX() * theta;
+    VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa),
+                     Quaternionx(cos(theta / Scalar(2)), sin(theta / Scalar(2)), Scalar(0), Scalar(0)));
+    VERIFY_IS_APPROX(Quaternionx(AngleAxisx(theta, Vector3::UnitX())).toScaledAxis(), sa);
+  }
+
+  // Tiny angle (sqrt of the smallest normal): the squared-norm formulation would have
+  // flushed to zero here, so this exercises the stableNorm() path. The closed form is
+  // still used (no Taylor expansion) and must agree with the math.
+  {
+    const Scalar theta_base = (numext::numeric_limits<Scalar>::min)();
+    const Scalar theta = sqrt(theta_base);
+    Vector3 sa = Vector3::UnitX() * theta;
+    VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa),
+                     Quaternionx(cos(theta / Scalar(2)), sin(theta / Scalar(2)), Scalar(0), Scalar(0)));
+    VERIFY_IS_APPROX(Quaternionx(AngleAxisx(theta, Vector3::UnitX())).toScaledAxis(), sa);
+  }
+
+  // Exact-zero handling: identity quaternion out / zero vector out, no NaN.
+  {
+    Quaternionx qid = Quaternionx::FromScaledAxis(Vector3::Zero());
+    VERIFY_IS_EQUAL(qid.w(), Scalar(1));
+    VERIFY_IS_EQUAL(qid.vec(), Vector3::Zero());
+    VERIFY_IS_EQUAL(Quaternionx::Identity().toScaledAxis(), Vector3::Zero());
+    // -1 quaternion (same rotation as identity) also maps to zero.
+    Quaternionx qneg(Scalar(-1), Scalar(0), Scalar(0), Scalar(0));
+    VERIFY_IS_EQUAL(qneg.toScaledAxis(), Vector3::Zero());
+  }
+
+  // Negative-w quaternion: the canonical magnitude of the rotation vector is in [0, pi].
+  {
+    Vector3 axis = Vector3::UnitX();
+    Quaternionx q_pos(AngleAxisx(Scalar(EIGEN_PI / 3), axis));
+    Quaternionx q_neg(-q_pos.w(), -q_pos.x(), -q_pos.y(), -q_pos.z());
+    Vector3 sa_pos = q_pos.toScaledAxis();
+    Vector3 sa_neg = q_neg.toScaledAxis();
+    VERIFY(sa_pos.norm() <= Scalar(EIGEN_PI) + test_precision<Scalar>());
+    VERIFY(sa_neg.norm() <= Scalar(EIGEN_PI) + test_precision<Scalar>());
+    // Both quaternions represent the same rotation, so re-applying exp gives back q_pos
+    // up to sign.
+    Quaternionx q_round = Quaternionx::FromScaledAxis(sa_neg);
+    VERIFY_IS_APPROX(numext::abs(q_round.dot(q_pos)), Scalar(1));
+  }
+
+  // Near-pi rotations: sin(theta/2) is near 1 and cos(theta/2) is near 0, so the
+  // canonicalisation branch (the abs(w)/(w<0) split) is stress-tested. Stay in [0, pi]:
+  // for theta > pi the canonical answer is (2*pi - theta) * (-axis), which is an
+  // important behaviour but is covered by the "Negative-w quaternion" test.
+  {
+    Vector3 axis = Vector3(Scalar(1), Scalar(2), Scalar(3)).normalized();
+    for (Scalar gap : {Scalar(1e-3), Scalar(1e-6)}) {
+      Scalar theta = Scalar(EIGEN_PI) - gap;
+      Quaternionx near_pi_quat(AngleAxisx(theta, axis));
+      Vector3 sa = near_pi_quat.toScaledAxis();
+      VERIFY_IS_APPROX(sa.stableNorm(), theta);
+      VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sa), near_pi_quat);
+    }
+  }
+
+  // w == -0.0 corner case (and its +0.0 counterpart).
+  {
+    // (w=+0, x=0, y=0, z=1) and (w=-0, ...) both represent rotation by pi about z.
+    Quaternionx qp(Scalar(0), Scalar(0), Scalar(0), Scalar(1));
+    Quaternionx qn(-Scalar(0), Scalar(0), Scalar(0), Scalar(1));
+    Vector3 sap = qp.toScaledAxis();
+    Vector3 san = qn.toScaledAxis();
+    VERIFY_IS_APPROX(sap.stableNorm(), Scalar(EIGEN_PI));
+    VERIFY_IS_APPROX(san.stableNorm(), Scalar(EIGEN_PI));
+    VERIFY_IS_APPROX(Quaternionx::FromScaledAxis(sap), qp);
+    // qp and qn represent the same rotation, so the recovered quaternions must agree up
+    // to sign.
+    VERIFY_IS_APPROX(numext::abs(Quaternionx::FromScaledAxis(san).dot(qp)), Scalar(1));
+  }
+
+  // Round-trip across the full canonical range. Includes near-pi by construction.
+  {
+    static const int kNumOctants = 8;
+    const Scalar angle_base = internal::random<Scalar>(Scalar(0), Scalar(EIGEN_PI));
+    for (int octant = 0; octant < kNumOctants; ++octant) {
+      // Sweep through magnitude as well, including the antipodal boundary at pi.
+      Scalar angle =
+          angle_base * Scalar(octant) / Scalar(kNumOctants - 1);  // 0 .. angle_base, hits pi when angle_base = pi
+      Scalar theta = -Scalar(EIGEN_PI) + Scalar(2 * EIGEN_PI) * Scalar(octant) / Scalar(kNumOctants);
+      Scalar phi = Scalar(EIGEN_PI) * Scalar(octant + 1) / Scalar(kNumOctants + 1);
+      Vector3 sa(angle * sin(phi) * cos(theta), angle * sin(phi) * sin(theta), angle * cos(phi));
+      Quaternionx roundtrip_quat = Quaternionx::FromScaledAxis(sa);
+      VERIFY_IS_APPROX(roundtrip_quat.norm(), Scalar(1));
+      Vector3 sa_rt = roundtrip_quat.toScaledAxis();
+      VERIFY_IS_APPROX(sa_rt, sa);
+      // And the other direction (quaternion -> sa -> quaternion).
+      Quaternionx roundtrip_quat2 = Quaternionx::FromScaledAxis(sa_rt);
+      VERIFY_IS_APPROX(roundtrip_quat2, roundtrip_quat);
+    }
+  }
+
   q1 = Quaternionx::UnitRandom();
   q2 = Quaternionx::UnitRandom();
   check_slerp(q1, q2);
@@ -199,8 +334,8 @@
   Vector3 v0 = Vector3::Random(), v1 = Vector3::Random();
   Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
 
-  EIGEN_ALIGN_MAX Scalar array1[4];
-  EIGEN_ALIGN_MAX Scalar array2[4];
+  EIGEN_ALIGN_TO_BOUNDARY(Aligned) Scalar array1[4];
+  EIGEN_ALIGN_TO_BOUNDARY(Aligned) Scalar array2[4];
   EIGEN_ALIGN_MAX Scalar array3[4 + 1];
   Scalar* array3unaligned = array3 + 1;
 
@@ -301,7 +436,6 @@
 
 // Regression for bug 1573
 struct MovableClass {
-  // The following line is a workaround for gcc 4.7 and 4.8 (see bug 1573 comments).
   static_assert(std::is_nothrow_move_constructible<Quaternionf>::value, "");
   MovableClass() = default;
   MovableClass(const MovableClass&) = default;
diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp
index d10281a..233b094 100644
--- a/test/geo_transformations.cpp
+++ b/test/geo_transformations.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include <Eigen/Eigenvalues>
 #include <Eigen/Geometry>
 #include <Eigen/LU>
 #include <Eigen/SVD>
@@ -17,11 +19,121 @@
   return Matrix<T, 2, 1>(std::cos(a), std::sin(a));
 }
 
-// This permits to workaround a bug in clang/llvm code generation.
-template <typename T>
-EIGEN_DONT_INLINE void dont_over_optimize(T& x) {
-  volatile typename T::Scalar tmp = x(0);
-  x(0) = tmp;
+struct CustomScalarOffset {
+  double value;
+  explicit CustomScalarOffset(double x = 0) : value(x) {}
+};
+inline double operator*(double x, CustomScalarOffset y) { return x * y.value; }
+inline double operator*(CustomScalarOffset x, double y) { return x.value * y; }
+inline double operator+(double x, CustomScalarOffset y) { return x + y.value; }
+inline double& operator+=(double& x, CustomScalarOffset y) { return x += y.value; }
+
+struct CustomPromotedScalar {
+  double value;
+  explicit CustomPromotedScalar(double x = 0) : value(x) {}
+  operator float() const { return static_cast<float>(value); }
+};
+inline CustomPromotedScalar operator*(float x, CustomPromotedScalar y) { return CustomPromotedScalar(double(x) * y.value); }
+inline CustomPromotedScalar operator*(CustomPromotedScalar x, float y) { return CustomPromotedScalar(x.value * double(y)); }
+inline CustomPromotedScalar operator+(float x, CustomPromotedScalar y) { return CustomPromotedScalar(double(x) + y.value); }
+inline CustomPromotedScalar operator+(CustomPromotedScalar x, float y) { return CustomPromotedScalar(x.value + double(y)); }
+inline CustomPromotedScalar operator+(CustomPromotedScalar x, CustomPromotedScalar y) { return CustomPromotedScalar(x.value + y.value); }
+inline float& operator+=(float& x, CustomPromotedScalar y) {
+  x = static_cast<float>(double(x) + y.value);
+  return x;
+}
+
+namespace Eigen {
+template <>
+struct NumTraits<CustomScalarOffset> : NumTraits<double> {
+  static constexpr int RequireInitialization = 1;
+};
+template <typename Op>
+struct ScalarBinaryOpTraits<double, CustomScalarOffset, Op> {
+  using ReturnType = double;
+};
+template <typename Op>
+struct ScalarBinaryOpTraits<CustomScalarOffset, double, Op> {
+  using ReturnType = double;
+};
+
+template <>
+struct NumTraits<CustomPromotedScalar> : NumTraits<double> {
+  static constexpr int RequireInitialization = 1;
+};
+template <typename Op>
+struct ScalarBinaryOpTraits<float, CustomPromotedScalar, Op> {
+  using ReturnType = CustomPromotedScalar;
+};
+template <typename Op>
+struct ScalarBinaryOpTraits<CustomPromotedScalar, float, Op> {
+  using ReturnType = CustomPromotedScalar;
+};
+}  // namespace Eigen
+
+void custom_scalar_test() {
+  {
+    Transform<float, 3, Affine> tf = Transform<float, 3, Affine>::Identity();
+    Matrix<double, 3, 1> vd(1.0, 2.0, 3.0);
+    tf.pretranslate(vd);
+    tf.translate(vd);
+  }
+
+  // Promoted arithmetic where trait result type differs from destination scalar
+  {
+    Transform<float, 3, Affine> t = Transform<float, 3, Affine>::Identity();
+    t.translation().setConstant(16777216.0f);
+    Matrix<CustomPromotedScalar, 3, 1> v;
+    v.setConstant(CustomPromotedScalar(-16777217.0));
+    Transform<float, 3, Affine> pre = t;
+    pre.pretranslate(v);
+    t.translate(v);
+    Vector3f expected(-1.0f, -1.0f, -1.0f);
+    VERIFY_IS_APPROX(t.translation(), expected);
+    VERIFY_IS_APPROX(pre.translation(), expected);
+  }
+
+  using CustomVector3 = Matrix<CustomScalarOffset, 3, 1>;
+  using CustomMatrix3 = Matrix<CustomScalarOffset, 3, 3>;
+
+  // Affine
+  {
+    Affine3d t = Affine3d::Identity();
+    CustomVector3 v;
+    v << CustomScalarOffset(1), CustomScalarOffset(2), CustomScalarOffset(3);
+    t.translate(v);
+    t.pretranslate(v);
+    Vector3d expected(2.0, 4.0, 6.0);
+    VERIFY_IS_APPROX(t.translation(), expected);
+
+    CustomMatrix3 r;
+    r << CustomScalarOffset(1), CustomScalarOffset(0), CustomScalarOffset(0), CustomScalarOffset(0),
+        CustomScalarOffset(1), CustomScalarOffset(0), CustomScalarOffset(0), CustomScalarOffset(0),
+        CustomScalarOffset(1);
+    t.rotate(r);
+    t.prerotate(r);
+    VERIFY_IS_APPROX(t.translation(), expected);
+  }
+
+  // Projective
+  {
+    Projective3d t = Projective3d::Identity();
+    t.matrix().row(3) << 0.1, 0.2, 0.3, 1.0;
+    Matrix4d t_orig = t.matrix();
+
+    CustomVector3 v;
+    v << CustomScalarOffset(1), CustomScalarOffset(2), CustomScalarOffset(3);
+    Matrix4d H = Matrix4d::Identity();
+    H.block<3, 1>(0, 3) << 1.0, 2.0, 3.0;
+
+    Projective3d t_trans = t;
+    t_trans.translate(v);
+    VERIFY_IS_APPROX(t_trans.matrix(), (t_orig * H).eval());
+
+    Projective3d t_pretrans = t;
+    t_pretrans.pretranslate(v);
+    VERIFY_IS_APPROX(t_pretrans.matrix(), (H * t_orig).eval());
+  }
 }
 
 template <typename Scalar, int Mode, int Options>
@@ -135,14 +247,6 @@
 
   // angle-axis conversion
   AngleAxisx aa = AngleAxisx(q1);
-  VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);
-
-  // The following test is stable only if 2*angle != angle and v1 is not colinear with axis
-  if ((abs(aa.angle()) > test_precision<Scalar>()) &&
-      (abs(aa.axis().dot(v1.normalized())) < (Scalar(1) - Scalar(4) * test_precision<Scalar>()))) {
-    VERIFY(!(q1 * v1).isApprox(Quaternionx(AngleAxisx(aa.angle() * 2, aa.axis())) * v1));
-  }
-
   aa.fromRotationMatrix(aa.toRotationMatrix());
   VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);
   // The following test is stable only if 2*angle != angle and v1 is not colinear with axis
@@ -160,6 +264,12 @@
   aa1 = m;
   VERIFY_IS_APPROX(AngleAxisx(m).toRotationMatrix(), Quaternionx(m).toRotationMatrix());
 
+  // Regression test for #3082: constructing AngleAxis from a 3x3 sub-block of a
+  // larger matrix expression (rather than a plain Matrix3) must compile.
+  Matrix<Scalar, 4, 4> m44 = Matrix<Scalar, 4, 4>::Identity();
+  m44.template topLeftCorner<3, 3>() = m;
+  VERIFY_IS_APPROX(AngleAxisx(m44.template block<3, 3>(0, 0)).toRotationMatrix(), m);
+
   // Transform
   // TODO complete the tests !
   a = internal::random<Scalar>(-Scalar(0.4) * Scalar(EIGEN_PI), Scalar(0.4) * Scalar(EIGEN_PI));
@@ -224,7 +334,6 @@
   VERIFY_IS_APPROX(t3.matrix(), t4.matrix());
 
   v3 = Vector3::Random();
-  dont_over_optimize(v3);
   for (int k = 0; k < 3; ++k) {
     if (numext::abs(v3(k)) < NumTraits<Scalar>::epsilon()) v3(k) = NumTraits<Scalar>::epsilon();
   }
@@ -246,6 +355,89 @@
   t4 *= sv3;
   VERIFY_IS_APPROX(t6.matrix(), t4.matrix());
 
+  // mixed-scalar operations
+  {
+    using OtherScalar = std::conditional_t<std::is_same<Scalar, float>::value, double, float>;
+    typedef Matrix<OtherScalar, 3, 1> Vector3Other;
+    typedef Matrix<OtherScalar, 3, 3> Matrix3Other;
+    typedef Quaternion<OtherScalar> QuaternionOther;
+    typedef AngleAxis<OtherScalar> AngleAxisOther;
+
+    Vector3Other v_other(OtherScalar(1), OtherScalar(2), OtherScalar(3));
+    Matrix4 H_trans = Matrix4::Identity();
+    H_trans.template block<3, 1>(0, 3) = v_other.template cast<Scalar>();
+
+    Matrix4 full_t3 = Matrix4::Identity();
+    full_t3.template topRows<int(Mode) == int(AffineCompact) ? 3 : 4>() = t3.matrix();
+
+    Transform3 t_trans = t3;
+    t_trans.translate(v_other);
+    Matrix4 expected_trans = (full_t3 * H_trans).eval();
+    VERIFY_IS_APPROX(t_trans.matrix(), (expected_trans.template topRows<int(Mode) == int(AffineCompact) ? 3 : 4>()));
+
+    Transform3 t_pretrans = t3;
+    t_pretrans.pretranslate(v_other);
+    Matrix4 expected_pretrans = (H_trans * full_t3).eval();
+    VERIFY_IS_APPROX(t_pretrans.matrix(),
+                     (expected_pretrans.template topRows<int(Mode) == int(AffineCompact) ? 3 : 4>()));
+
+    AngleAxisOther aa_other(OtherScalar(0.5),
+                            Vector3Other(OtherScalar(1), OtherScalar(2), OtherScalar(3)).normalized());
+    Matrix3Other rot_mat_other = aa_other.toRotationMatrix();
+    QuaternionOther q_other(aa_other);
+
+    Matrix4 H_rot = Matrix4::Identity();
+    H_rot.template block<3, 3>(0, 0) = rot_mat_other.template cast<Scalar>();
+
+    Matrix4 expected_rotate = (full_t3 * H_rot).eval();
+    Matrix4 expected_prerotate = (H_rot * full_t3).eval();
+
+    Transform3 t_rot_mat = t3;
+    t_rot_mat.rotate(rot_mat_other);
+    VERIFY_IS_APPROX(t_rot_mat.matrix(), (expected_rotate.template topRows<int(Mode) == int(AffineCompact) ? 3 : 4>()));
+
+    Transform3 t_rot_aa = t3;
+    t_rot_aa.rotate(aa_other);
+    VERIFY_IS_APPROX(t_rot_aa.matrix(), t_rot_mat.matrix());
+
+    Transform3 t_rot_q = t3;
+    t_rot_q.rotate(q_other);
+    VERIFY_IS_APPROX(t_rot_q.matrix(), t_rot_mat.matrix());
+
+    Transform3 t_prerot_mat = t3;
+    t_prerot_mat.prerotate(rot_mat_other);
+    VERIFY_IS_APPROX(t_prerot_mat.matrix(),
+                     (expected_prerotate.template topRows<int(Mode) == int(AffineCompact) ? 3 : 4>()));
+
+    Transform3 t_prerot_aa = t3;
+    t_prerot_aa.prerotate(aa_other);
+    VERIFY_IS_APPROX(t_prerot_aa.matrix(), t_prerot_mat.matrix());
+
+    Transform3 t_prerot_q = t3;
+    t_prerot_q.prerotate(q_other);
+    VERIFY_IS_APPROX(t_prerot_q.matrix(), t_prerot_mat.matrix());
+
+    // Projective translation with nontrivial last row
+    {
+      Transform<Scalar, 3, Projective> t_proj;
+      t_proj.matrix() = Matrix4::Random();
+      t_proj.matrix().row(3) << Scalar(0.2), Scalar(-0.1), Scalar(0.5), Scalar(1.2);
+      Matrix4 t_proj_mat = t_proj.matrix();
+
+      Vector3Other v_proj(OtherScalar(1.5), OtherScalar(-2.5), OtherScalar(3.5));
+      Matrix4 H_proj = Matrix4::Identity();
+      H_proj.template block<3, 1>(0, 3) = v_proj.template cast<Scalar>();
+
+      Transform<Scalar, 3, Projective> t_trans_proj = t_proj;
+      t_trans_proj.translate(v_proj);
+      VERIFY_IS_APPROX(t_trans_proj.matrix(), (t_proj_mat * H_proj).eval());
+
+      Transform<Scalar, 3, Projective> t_pretrans_proj = t_proj;
+      t_pretrans_proj.pretranslate(v_proj);
+      VERIFY_IS_APPROX(t_pretrans_proj.matrix(), (H_proj * t_proj_mat).eval());
+    }
+  }
+
   // matrix * transform
   VERIFY_IS_APPROX((t3.matrix() * t4).matrix(), (t3 * t4).matrix());
 
@@ -279,6 +471,40 @@
   t21.preshear(Scalar(2), Scalar(3));
   VERIFY_IS_APPROX(t21, t23);
 
+  // mixed-scalar 2D rotate and prerotate
+  {
+    using OtherScalar = std::conditional_t<std::is_same<Scalar, float>::value, double, float>;
+    typedef Matrix<Scalar, 3, 3> Matrix3_2D;
+    Rotation2D<OtherScalar> r2d_other(OtherScalar(0.4));
+    Matrix<Scalar, 2, 2> r2d_mat = r2d_other.toRotationMatrix().template cast<Scalar>();
+    Matrix3_2D H2_rot = Matrix3_2D::Identity();
+    H2_rot.template block<2, 2>(0, 0) = r2d_mat;
+
+    Matrix3_2D full_t21 = Matrix3_2D::Identity();
+    full_t21.template topRows<int(Mode) == int(AffineCompact) ? 2 : 3>() = t21.matrix();
+
+    Matrix3_2D expected_2d_rotate = (full_t21 * H2_rot).eval();
+    Matrix3_2D expected_2d_prerotate = (H2_rot * full_t21).eval();
+
+    Transform2 t2_rot_mat = t21;
+    t2_rot_mat.rotate(r2d_other.toRotationMatrix());
+    VERIFY_IS_APPROX(t2_rot_mat.matrix(),
+                     (expected_2d_rotate.template topRows<int(Mode) == int(AffineCompact) ? 2 : 3>()));
+
+    Transform2 t2_rot_r2d = t21;
+    t2_rot_r2d.rotate(r2d_other);
+    VERIFY_IS_APPROX(t2_rot_r2d.matrix(), t2_rot_mat.matrix());
+
+    Transform2 t2_prerot_mat = t21;
+    t2_prerot_mat.prerotate(r2d_other.toRotationMatrix());
+    VERIFY_IS_APPROX(t2_prerot_mat.matrix(),
+                     (expected_2d_prerotate.template topRows<int(Mode) == int(AffineCompact) ? 2 : 3>()));
+
+    Transform2 t2_prerot_r2d = t21;
+    t2_prerot_r2d.prerotate(r2d_other);
+    VERIFY_IS_APPROX(t2_prerot_r2d.matrix(), t2_prerot_mat.matrix());
+  }
+
   // Transform - new API
   // 3D
   t0.setIdentity();
@@ -387,12 +613,19 @@
   t044(3, 3) = 1;
   t044.block(0, 0, t0.matrix().rows(), 4) = t0.matrix();
   VERIFY_IS_APPROX(t0.inverse(Affine).matrix(), t044.inverse().block(0, 0, t0.matrix().rows(), 4));
+  Transform3 t0_general = t0;
+  Matrix4 t044_general = t044;
   t0.setIdentity();
   t0.translate(v0).rotate(q1);
   t044 = Matrix4::Zero();
   t044(3, 3) = 1;
   t044.block(0, 0, t0.matrix().rows(), 4) = t0.matrix();
   VERIFY_IS_APPROX(t0.inverse(Isometry).matrix(), t044.inverse().block(0, 0, t0.matrix().rows(), 4));
+  // #Projective is the "assume nothing" hint, so it must invert both transforms whatever the Mode is. Each check
+  // inverts the transform the preceding call did not, so that a stale result cannot pass for the right answer.
+  VERIFY_IS_APPROX(t0_general.inverse(Projective).matrix(),
+                   t044_general.inverse().block(0, 0, t0_general.matrix().rows(), 4));
+  VERIFY_IS_APPROX(t0.inverse(Projective).matrix(), t044.inverse().block(0, 0, t0.matrix().rows(), 4));
 
   Matrix3 mat_rotation, mat_scaling;
   t0.setIdentity();
@@ -608,6 +841,20 @@
   VERIFY_IS_APPROX((ac * p).matrix(), a_m * p_m);
 }
 
+template <int>
+void permutation_transpose_product_issue_1322() {
+  Affine3d transform;
+  transform.setIdentity();
+
+  Matrix3d m = Vector3d(1.0, 2.0, 3.0).asDiagonal();
+  SelfAdjointEigenSolver<Matrix3d> solver(m);
+  const PermutationMatrix<3, 3> p(Vector3i::LinSpaced(0, 2).reverse());
+
+  const Vector3d expected = p.transpose().operator*(solver.eigenvalues());
+  const Vector3d result = p.transpose() * solver.eigenvalues();
+  VERIFY_IS_APPROX(result, expected);
+}
+
 template <typename Scalar, int Mode, int Options>
 void transformations_no_scale() {
   /* this test covers the following files:
@@ -662,6 +909,10 @@
   // Verify implicit last row is initialized.
   VERIFY_IS_APPROX(Vector4(m3.row(3)), Vector4(0.0, 0.0, 0.0, 1.0));
 
+  // t3 is a genuine isometry, so every hint must invert it, including the no-assumption Projective one.
+  VERIFY_IS_APPROX(t3.inverse(Projective).matrix(), m3.inverse().block(0, 0, t3.matrix().rows(), 4));
+  VERIFY_IS_APPROX(t3.inverse(Projective).matrix(), t3.inverse().matrix());
+
   VERIFY_IS_APPROX(t3.rotation(), t3.linear());
   if (Mode == Isometry) VERIFY(t3.rotation().data() == t3.linear().data());
 }
@@ -696,6 +947,7 @@
     CALL_SUBTEST_1((transformations<double, Affine, AutoAlign>()));
     CALL_SUBTEST_1((non_projective_only<double, Affine, AutoAlign>()));
     CALL_SUBTEST_1((transformations_computed_scaling_continuity<double, Affine, AutoAlign>()));
+    CALL_SUBTEST_1(custom_scalar_test());
 
     CALL_SUBTEST_2((transformations<float, AffineCompact, AutoAlign>()));
     CALL_SUBTEST_2((non_projective_only<float, AffineCompact, AutoAlign>()));
@@ -706,6 +958,7 @@
     CALL_SUBTEST_3((transform_alignment<double>()));
 
     CALL_SUBTEST_4((transformations<float, Affine, RowMajor | AutoAlign>()));
+    CALL_SUBTEST_4((transformations<float, Projective, AutoAlign>()));
     CALL_SUBTEST_4((non_projective_only<float, Affine, RowMajor>()));
 
     CALL_SUBTEST_5((transformations<double, AffineCompact, RowMajor | AutoAlign>()));
@@ -716,6 +969,7 @@
 
     CALL_SUBTEST_7((transform_products<double, 3, RowMajor | AutoAlign>()));
     CALL_SUBTEST_7((transform_products<float, 2, AutoAlign>()));
+    CALL_SUBTEST_7(permutation_transpose_product_issue_1322<0>());
 
     CALL_SUBTEST_8((transform_associativity<double, 2, ColMajor>(
         Rotation2D<double>(internal::random<double>() * double(EIGEN_PI)))));
diff --git a/test/gmres.cpp b/test/gmres.cpp
new file mode 100644
index 0000000..5637ff9
--- /dev/null
+++ b/test/gmres.cpp
@@ -0,0 +1,87 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
+// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T>
+void test_gmres_T() {
+  GMRES<SparseMatrix<T>, DiagonalPreconditioner<T> > gmres_colmajor_diag;
+  GMRES<SparseMatrix<T>, IdentityPreconditioner> gmres_colmajor_I;
+  GMRES<SparseMatrix<T>, IncompleteLUT<T> > gmres_colmajor_ilut;
+  // GMRES<SparseMatrix<T>, SSORPreconditioner<T> >     gmres_colmajor_ssor;
+
+  CALL_SUBTEST(check_sparse_square_solving(gmres_colmajor_diag));
+  //   CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_I)     );
+  CALL_SUBTEST(check_sparse_square_solving(gmres_colmajor_ilut));
+  // CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_ssor)     );
+}
+
+void test_gmres_solve_with_guess_tolerance() {
+  const SparseMatrix<double>::StorageIndex size = 20;
+  SparseMatrix<double> matrix(size, size);
+  std::vector<Triplet<double> > triplets;
+  for (SparseMatrix<double>::StorageIndex i = 0; i < size; ++i) {
+    triplets.emplace_back(i, i, 2.0 + double(i) / double(size));
+    if (i > 0) triplets.emplace_back(i, i - 1, -0.25);
+    if (i + 1 < size) triplets.emplace_back(i, i + 1, 0.125);
+  }
+  matrix.setFromTriplets(triplets.begin(), triplets.end());
+
+  VectorXd rhs = VectorXd::Ones(size);
+  VectorXd guess(size);
+  for (Index i = 0; i < size; ++i) {
+    guess[i] = ((i % 2) ? 1.0 : -1.0) * 1e8;
+  }
+
+  GMRES<SparseMatrix<double>, DiagonalPreconditioner<double> > gmres;
+  gmres.compute(matrix);
+  gmres.setTolerance(1e-6);
+  gmres.setMaxIterations(size);
+  gmres.set_restart(size);
+
+  VectorXd x = gmres.solveWithGuess(rhs, guess);
+  DiagonalPreconditioner<double> preconditioner(matrix);
+  const VectorXd residual = matrix * x - rhs;
+  const double relativeResidual = preconditioner.solve(residual).norm() / preconditioner.solve(rhs).norm();
+  VERIFY(gmres.info() == Success);
+  VERIFY(gmres.iterations() > 1);
+  VERIFY(relativeResidual < gmres.tolerance());
+  VERIFY(gmres.error() < gmres.tolerance());
+}
+
+void test_gmres_large_restart() {
+  const SparseMatrix<double>::StorageIndex size = 4;
+  SparseMatrix<double> matrix(size, size);
+  std::vector<Triplet<double> > triplets;
+  for (SparseMatrix<double>::StorageIndex i = 0; i < size; ++i) {
+    triplets.emplace_back(i, i, 2.0 + double(i));
+  }
+  matrix.setFromTriplets(triplets.begin(), triplets.end());
+
+  const VectorXd rhs = VectorXd::LinSpaced(size, 1.0, 4.0);
+  GMRES<SparseMatrix<double>, IdentityPreconditioner> gmres;
+  gmres.compute(matrix);
+  gmres.setTolerance(1e-12);
+  gmres.setMaxIterations(size);
+  gmres.set_restart(1000000);
+
+  VectorXd x = gmres.solve(rhs);
+  VERIFY(gmres.info() == Success);
+  VERIFY_IS_APPROX(matrix * x, rhs);
+}
+
+EIGEN_DECLARE_TEST(gmres) {
+  CALL_SUBTEST_1(test_gmres_T<double>());
+  CALL_SUBTEST_2(test_gmres_T<std::complex<double> >());
+  CALL_SUBTEST_3(test_gmres_solve_with_guess_tolerance());
+  CALL_SUBTEST_4(test_gmres_large_restart());
+}
diff --git a/test/gpu_basic.cu b/test/gpu_basic.cu
index 5e69fb7..8f0a683 100644
--- a/test/gpu_basic.cu
+++ b/test/gpu_basic.cu
@@ -6,12 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// workaround issue between gcc >= 4.7 and cuda 5.5
-#if (defined __GNUC__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 7)
-#undef _GLIBCXX_ATOMIC_BUILTINS
-#undef _GLIBCXX_USE_INT128
-#endif
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_TEST_NO_LONGDOUBLE
 #define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
@@ -39,6 +34,30 @@
 //   }
 // };
 
+template <typename Scalar>
+struct scaled_permutation_product {
+  EIGEN_DEVICE_FUNC void operator()(int i, const float* in, float* out) const {
+    using MatrixType = Eigen::Matrix<Scalar, 3, 3>;
+    Eigen::ScaledPermutationMatrix<Scalar, 3> scaled;
+    scaled.setIdentity();
+    scaled.indices() << 1, 2, 0;
+    scaled.scales() << Scalar(2), Scalar(3), Scalar(-1);
+    const MatrixType matrix = Eigen::Map<const Eigen::Matrix3f>(in + i).template cast<Scalar>();
+    MatrixType result = scaled * matrix;
+    result.noalias() += matrix * scaled;
+    result.noalias() -= scaled * matrix;
+    result = scaled * result;
+    result = result * scaled;
+    result += scaled;
+    result -= scaled;
+    result += scaled.toDenseMatrix();
+    result = result + scaled;
+    result.noalias() += scaled * matrix.template triangularView<Eigen::Lower>();
+    result.noalias() += matrix.template selfadjointView<Eigen::Upper>() * scaled;
+    Eigen::Map<Eigen::Matrix3f>(out + 9 * i) = result.template cast<float>();
+  }
+};
+
 template <typename T>
 struct coeff_wise {
   EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
@@ -52,6 +71,83 @@
   }
 };
 
+template <int Order>
+struct scaled_structured_product {
+  EIGEN_DEVICE_FUNC void operator()(int i, const float* in, float* out) const {
+    using Mat = Eigen::Matrix<float, 3, 3, Order>;
+    const Eigen::Map<const Mat> matrix(in + i);
+    Eigen::Map<Mat> result(out + i * 9);
+    result.noalias() = 3.0f * (matrix.template triangularView<Eigen::UnitLower>() * matrix.diagonal().asDiagonal());
+    result += 2.0f * (matrix.diagonal().asDiagonal() * matrix) + Mat::Zero();
+  }
+};
+
+template <int Order>
+struct scaled_outer_product {
+  EIGEN_DEVICE_FUNC void operator()(int i, const float* in, float* out) const {
+    // More than 16 rows select the scaled outer-product functor.
+    using Lhs = Eigen::Matrix<float, 17, 1>;
+    using Rhs = Eigen::RowVector3f;
+    using ProductImpl =
+        Eigen::internal::generic_product_impl<Lhs, Rhs, Eigen::DenseShape, Eigen::DenseShape, Eigen::OuterProduct>;
+    const Lhs lhs(in + i);
+    const Rhs rhs(in + i + 17);
+    Eigen::Map<Eigen::Matrix<float, 17, 3, Order>> result(out + i * 51);
+    result.setZero();
+    ProductImpl::scaleAndAddTo(result, lhs, rhs, 2.0f);
+  }
+};
+
+struct make_householder_small_tail {
+  EIGEN_DEVICE_FUNC void operator()(int i, const float* /*in*/, float* out) const {
+    Eigen::Vector3f vector;
+    vector << 0.0f, 1e-20f, -2e-20f;
+    Eigen::Vector2f essential;
+    float tau;
+    float beta;
+    vector.makeHouseholder(essential, tau, beta);
+    out[4 * i] = tau;
+    out[4 * i + 1] = beta;
+    out[4 * i + 2] = essential[0];
+    out[4 * i + 3] = essential[1];
+  }
+};
+
+struct make_householder_complex_zero_tail {
+  EIGEN_DEVICE_FUNC void operator()(int i, const std::complex<float>* /*in*/, std::complex<float>* out) const {
+    Eigen::Vector2cf vector;
+    vector << std::complex<float>(0.0f, 1e-20f), std::complex<float>(0.0f, 0.0f);
+    Eigen::Matrix<std::complex<float>, 1, 1> essential;
+    std::complex<float> tau;
+    float beta;
+    vector.makeHouseholder(essential, tau, beta);
+    out[3 * i] = tau;
+    out[3 * i + 1] = std::complex<float>(beta, 0.0f);
+    out[3 * i + 2] = essential[0];
+  }
+};
+
+// Applies the complex operators inside Eigen's own templates, which see the device overloads only through
+// Eigen/Core's include order; complex_operators below finds them through its using-directive.
+template <typename ComplexType>
+struct complex_internal_operators {
+  EIGEN_DEVICE_FUNC void operator()(int i, const ComplexType* in, ComplexType* out) const {
+    const int num_operators = 8;
+    int out_idx = i * num_operators;
+    const ComplexType a = in[i];
+    const ComplexType b = in[i + 1];
+
+    out[out_idx++] = numext::negate(a);
+    out[out_idx++] = numext::conj(a);
+    out[out_idx++] = internal::padd(a, b);
+    out[out_idx++] = internal::psub(a, b);
+    out[out_idx++] = internal::pmul(a, b);
+    out[out_idx++] = internal::pdiv(a, b);
+    out[out_idx++] = internal::pnegate(a);
+    out[out_idx++] = internal::pconj(a);
+  }
+};
+
 template <typename T>
 struct complex_sqrt {
   EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
@@ -295,6 +391,39 @@
 };
 
 template <typename T>
+struct jacobi_rotations {
+  EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
+    using Scalar = typename T::Scalar;
+    constexpr int size = T::SizeAtCompileTime;
+    const Eigen::JacobiRotation<Scalar> rotation(Scalar(3) / Scalar(5), Scalar(4) / Scalar(5));
+
+    T fixed(in + i);
+    fixed.applyOnTheLeft(0, 1, rotation);
+    fixed.applyOnTheRight(0, 1, rotation);
+    Eigen::Map<T>(out + 2 * i * size) = fixed;
+
+    using DynamicMatrix = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, T::Options>;
+    Eigen::Map<DynamicMatrix> dynamic(out + (2 * i + 1) * size, T::RowsAtCompileTime, T::ColsAtCompileTime);
+    dynamic = T(in + i);
+    dynamic.applyOnTheLeft(0, 1, rotation);
+    dynamic.applyOnTheRight(0, 1, rotation);
+  }
+};
+
+template <typename Scalar, int Options>
+void test_jacobi_rotations() {
+  constexpr int n = 4;
+  Eigen::Array<Scalar, Eigen::Dynamic, 1> in(n * 512), out(n * 512);
+  in.setRandom();
+  out.setZero();
+
+  // Sizes 3, 4 and 9 cover scalar fallback, aligned packets, and dynamic packets with a tail.
+  run_and_compare_to_gpu(jacobi_rotations<Eigen::Matrix<Scalar, 3, 3, Options>>(), n, in, out);
+  run_and_compare_to_gpu(jacobi_rotations<Eigen::Matrix<Scalar, 4, 4, Options>>(), n, in, out);
+  run_and_compare_to_gpu(jacobi_rotations<Eigen::Matrix<Scalar, 9, 9, Options>>(), n, in, out);
+}
+
+template <typename T>
 struct eigenvalues_direct {
   EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
     using namespace Eigen;
@@ -322,6 +451,30 @@
   }
 };
 
+template <typename T, int UpLo>
+struct selfadjoint_rank2_update {
+  EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
+    using namespace Eigen;
+    typedef Matrix<typename T::Scalar, T::RowsAtCompileTime, 1> Vec;
+    T M(in + i);
+    Vec u(in + i + T::MaxSizeAtCompileTime);
+    Vec v(in + i + T::MaxSizeAtCompileTime + Vec::MaxSizeAtCompileTime);
+    Map<T> res(out + i * T::MaxSizeAtCompileTime);
+    res = M;
+    res.template selfadjointView<UpLo>().rankUpdate(u, v, typename T::Scalar(0.25));
+  }
+};
+
+template <typename T, int UpLo>
+struct selfadjoint_l1_norm {
+  EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
+    using namespace Eigen;
+    T M(in + i);
+    // l1Norm() has a separate device implementation, so the host result is the reference.
+    out[i] = M.template selfadjointView<UpLo>().l1Norm();
+  }
+};
+
 template <typename T>
 struct matrix_inverse {
   EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
@@ -335,7 +488,7 @@
 template <typename T>
 struct numeric_limits_test {
   EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
-    EIGEN_UNUSED_VARIABLE(in)
+    EIGEN_UNUSED_VARIABLE(in);
     int out_idx = i * 5;
     out[out_idx++] = numext::numeric_limits<float>::epsilon();
     out[out_idx++] = (numext::numeric_limits<float>::max)();
@@ -345,6 +498,79 @@
   }
 };
 
+struct custom_less_scalar {
+  int value;
+
+  EIGEN_DEVICE_FUNC explicit custom_less_scalar(int x = 0) : value(x) {}
+};
+
+EIGEN_DEVICE_FUNC bool operator<(const custom_less_scalar& x, const custom_less_scalar& y) { return x.value < y.value; }
+
+struct custom_less_scalar_minmax_test {
+  EIGEN_DEVICE_FUNC void operator()(int i, const int* in, int* out) const {
+    EIGEN_UNUSED_VARIABLE(i);
+    const custom_less_scalar x(in[0]);
+    const custom_less_scalar y(in[1]);
+    out[0] = Eigen::numext::mini(x, y).value;
+    out[1] = Eigen::numext::maxi(x, y).value;
+  }
+};
+
+void test_custom_less_scalar_minmax() {
+  Eigen::ArrayXi in(2), out_ref(2), out_gpu(2);
+  in << 1, 2;
+  out_ref.setConstant(-1);
+  out_gpu.setConstant(-1);
+
+  run_on_cpu(custom_less_scalar_minmax_test(), 1, in, out_ref);
+  run_on_gpu(custom_less_scalar_minmax_test(), 1, in, out_gpu);
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+  VERIFY_IS_EQUAL(out_ref(0), out_gpu(0));
+  VERIFY_IS_EQUAL(out_ref(1), out_gpu(1));
+#endif
+}
+
+struct float_nan_minmax_test {
+  EIGEN_DEVICE_FUNC void operator()(int i, const float* in, float* out) const {
+    EIGEN_UNUSED_VARIABLE(i);
+    const float nan = in[0];
+    const float one = in[1];
+    out[0] = Eigen::numext::mini(nan, one);
+    out[1] = Eigen::numext::mini(one, nan);
+    out[2] = Eigen::numext::maxi(nan, one);
+    out[3] = Eigen::numext::maxi(one, nan);
+    out[4] = Eigen::numext::mini(nan, nan);
+    out[5] = Eigen::numext::maxi(nan, nan);
+  }
+};
+
+void test_float_nan_minmax() {
+  Eigen::ArrayXf in(2), out_ref(6), out_gpu(6);
+  in << std::numeric_limits<float>::quiet_NaN(), 1.f;
+  out_ref.setConstant(-1.f);
+  out_gpu.setConstant(-1.f);
+
+  run_on_cpu(float_nan_minmax_test(), 1, in, out_ref);
+  run_on_gpu(float_nan_minmax_test(), 1, in, out_gpu);
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+  VERIFY_IS_CWISE_EQUAL(out_ref, out_gpu);
+#if defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC)
+  VERIFY((numext::isnan)(out_ref(0)));
+  VERIFY((numext::isnan)(out_ref(2)));
+#else
+  // Without relaxed constexpr, numext::mini/maxi select the number-preferring fmin/fmax overloads.
+  VERIFY_IS_EQUAL(out_ref(0), 1.f);
+  VERIFY_IS_EQUAL(out_ref(2), 1.f);
+#endif
+  VERIFY_IS_EQUAL(out_ref(1), 1.f);
+  VERIFY_IS_EQUAL(out_ref(3), 1.f);
+  VERIFY((numext::isnan)(out_ref(4)));
+  VERIFY((numext::isnan)(out_ref(5)));
+#endif
+}
+
 template <typename Type1, typename Type2>
 bool verifyIsApproxWithInfsNans(const Type1& a, const Type2& b,
                                 typename Type1::Scalar* = 0)  // Enabled for Eigen's type only
@@ -366,6 +592,31 @@
   return true;
 }
 
+#if defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE)
+// Host-side check that converting between Eigen::half and the vendor __half type preserves the
+// raw bits. This is a regression test for builds where Eigen::half stores a native fp16 type
+// (e.g. __fp16 on arm64): the host phase used to perform numeric value conversions instead of
+// bit reinterpretations, corrupting every raw-bit constant (NumTraits, numeric_limits, ...).
+void test_half_raw_bit_interop() {
+  const numext::uint16_t raw_bits[] = {0x0000, 0x3c00 /*1*/, 0x7c00 /*inf*/, 0x7e00 /*qNaN*/, 0xfbff /*lowest*/};
+  for (int i = 0; i < 5; ++i) {
+    const numext::uint16_t raw = raw_bits[i];
+    const Eigen::half h = numext::bit_cast<Eigen::half>(raw);
+    // Eigen::half -> __half must preserve the bits (sizeof(__half) == 2 on both CUDA and HIP).
+    // Call the conversion operator explicitly: a static_cast would be ambiguous because
+    // Eigen::half also converts to __half via operator float() and __half(float).
+    const __half v = h.operator __half();
+    VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(v), raw);
+    // __half -> Eigen::half must preserve the bits as well.
+    const Eigen::half h2(v);
+    VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(h2), raw);
+  }
+  // Raw-bit constants must survive the host phase of a GPU build.
+  VERIFY((numext::isinf)(NumTraits<Eigen::half>::infinity()));
+  VERIFY((numext::isnan)(NumTraits<Eigen::half>::quiet_NaN()));
+}
+#endif
+
 template <typename Kernel, typename Input, typename Output>
 void test_with_infs_nans(const Kernel& ker, int n, const Input& in, Output& out) {
   Output out_ref, out_gpu;
@@ -382,6 +633,63 @@
 #endif
 }
 
+// `preverse` falls back to returning the packet unchanged for any packet type
+// that does not override it, which is only correct for a packet of one element.
+// A GPU translation unit resolves both the host and the device side to the same
+// packet type, so running the same reversal on both and comparing them cannot
+// catch a missing override: check the reversed values instead.
+template <typename T>
+struct reverse_test {
+  EIGEN_DEVICE_FUNC void operator()(int i, const typename T::Scalar* in, typename T::Scalar* out) const {
+    constexpr int size = T::SizeAtCompileTime;
+    Eigen::Map<T>(out + i * size) = T(in + i * size).reverse();
+  }
+};
+
+template <typename Scalar>
+struct packet_any_test {
+  EIGEN_DEVICE_FUNC void operator()(int i, const float* /*in*/, float* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    using Packet = typename Eigen::internal::packet_traits<Scalar>::type;
+    const Packet zero = Eigen::internal::pzero(Packet());
+    const Packet sequence = Eigen::internal::plset<Packet>(Scalar(0));
+    const Packet mixed = Eigen::internal::pcmp_eq(sequence, Eigen::internal::pset1<Packet>(Scalar(1)));
+    out[3 * i] = float(Eigen::internal::predux_any(zero));
+    out[3 * i + 1] = float(Eigen::internal::predux_any(Eigen::internal::ptrue(zero)));
+    out[3 * i + 2] = float(Eigen::internal::predux_any(mixed));
+#else
+    out[3 * i] = 0;
+    out[3 * i + 1] = 1;
+    out[3 * i + 2] = 1;
+#endif
+  }
+};
+
+template <typename T>
+void test_reverse() {
+  typedef typename T::Scalar Scalar;
+  constexpr int size = T::SizeAtCompileTime;
+  constexpr int n = 4;
+
+  Eigen::Array<Scalar, Eigen::Dynamic, 1> in(n * size), out_ref(n * size), out_gpu(n * size);
+  for (int i = 0; i < n * size; ++i) in(i) = static_cast<Scalar>(i + 1);
+  out_ref.setZero();
+  out_gpu.setZero();
+
+  run_on_cpu(reverse_test<T>(), n, in, out_ref);
+  run_on_gpu(reverse_test<T>(), n, in, out_gpu);
+
+#if !defined(EIGEN_GPU_COMPILE_PHASE)
+  for (int i = 0; i < n; ++i) {
+    for (int j = 0; j < size; ++j) {
+      const Scalar expected = in(i * size + size - 1 - j);
+      VERIFY_IS_EQUAL(out_ref(i * size + j), expected);
+      VERIFY_IS_EQUAL(out_gpu(i * size + j), expected);
+    }
+  }
+#endif
+}
+
 EIGEN_DECLARE_TEST(gpu_basic) {
   ei_test_init_gpu();
 
@@ -399,6 +707,8 @@
 
   CALL_SUBTEST(run_and_compare_to_gpu(coeff_wise<Vector3f>(), nthreads, in, out));
   CALL_SUBTEST(run_and_compare_to_gpu(coeff_wise<Array44f>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(make_householder_small_tail(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(make_householder_complex_zero_tail(), nthreads, cfin, cfout));
 
 #if !defined(EIGEN_USE_HIP)
   // FIXME
@@ -420,6 +730,12 @@
 
   CALL_SUBTEST(run_and_compare_to_gpu(prod_test<Matrix3f, Matrix3f>(), nthreads, in, out));
   CALL_SUBTEST(run_and_compare_to_gpu(prod_test<Matrix4f, Vector4f>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(scaled_structured_product<RowMajor>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(scaled_structured_product<ColMajor>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(scaled_outer_product<RowMajor>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(scaled_outer_product<ColMajor>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(scaled_permutation_product<float>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(scaled_permutation_product<double>(), nthreads, in, out));
 
   CALL_SUBTEST(run_and_compare_to_gpu(diagonal<Matrix3f, Vector3f>(), nthreads, in, out));
   CALL_SUBTEST(run_and_compare_to_gpu(diagonal<Matrix4f, Vector4f>(), nthreads, in, out));
@@ -428,20 +744,47 @@
   CALL_SUBTEST(run_and_compare_to_gpu(matrix_inverse<Matrix3f>(), nthreads, in, out));
   CALL_SUBTEST(run_and_compare_to_gpu(matrix_inverse<Matrix4f>(), nthreads, in, out));
 
+  CALL_SUBTEST((test_jacobi_rotations<float, ColMajor>()));
+  CALL_SUBTEST((test_jacobi_rotations<float, RowMajor>()));
+  CALL_SUBTEST((test_jacobi_rotations<double, ColMajor>()));
+  CALL_SUBTEST((test_jacobi_rotations<double, RowMajor>()));
+
   CALL_SUBTEST(run_and_compare_to_gpu(eigenvalues_direct<Matrix3f>(), nthreads, in, out));
   CALL_SUBTEST(run_and_compare_to_gpu(eigenvalues_direct<Matrix2f>(), nthreads, in, out));
 
   // Test std::complex.
   CALL_SUBTEST(run_and_compare_to_gpu(complex_operators<Vector3cf>(), nthreads, cfin, cfout));
+  CALL_SUBTEST(run_and_compare_to_gpu(complex_internal_operators<std::complex<float>>(), nthreads, cfin, cfout));
   CALL_SUBTEST(test_with_infs_nans(complex_sqrt<Vector3cf>(), nthreads, cfin, cfout));
 
   // numeric_limits
   CALL_SUBTEST(test_with_infs_nans(numeric_limits_test<Vector3f>(), 1, in, out));
 
-  // These tests require dynamic-sized matrix multiplication, which isn't currently
-  // supported on GPU.
+  // Eigen::half <-> __half raw-bit interop on the host.
+#if defined(EIGEN_HAS_GPU_FP16) && !defined(EIGEN_GPU_COMPILE_PHASE)
+  CALL_SUBTEST(test_half_raw_bit_interop());
+#endif
 
-  // CALL_SUBTEST( run_and_compare_to_gpu(eigenvalues<Matrix4f>(), nthreads, in, out) );
-  // typedef Matrix<float,6,6> Matrix6f;
-  // CALL_SUBTEST( run_and_compare_to_gpu(eigenvalues<Matrix6f>(), nthreads, in, out) );
+  CALL_SUBTEST(test_custom_less_scalar_minmax());
+  CALL_SUBTEST(test_float_nan_minmax());
+
+  // `preverse` on every GPU packet type. 32 elements cover several packets of
+  // each, including `Packet4h2`, the widest at 8.
+  CALL_SUBTEST((test_reverse<Eigen::Array<float, 32, 1>>()));
+  CALL_SUBTEST((test_reverse<Eigen::Array<double, 32, 1>>()));
+  CALL_SUBTEST((test_reverse<Eigen::Array<Eigen::half, 32, 1>>()));
+  CALL_SUBTEST(run_and_compare_to_gpu(packet_any_test<float>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(packet_any_test<double>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(packet_any_test<Eigen::half>(), nthreads, in, out));
+
+  typedef Matrix<float, 6, 6> Matrix6f;
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_rank2_update<Matrix4f, Lower>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_rank2_update<Matrix4f, Upper>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_rank2_update<Matrix6f, Lower>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_rank2_update<Matrix6f, Upper>(), nthreads, in, out));
+
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_l1_norm<Matrix4f, Lower>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_l1_norm<Matrix4f, Upper>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_l1_norm<Matrix6f, Lower>(), nthreads, in, out));
+  CALL_SUBTEST(run_and_compare_to_gpu(selfadjoint_l1_norm<Matrix6f, Upper>(), nthreads, in, out));
 }
diff --git a/test/gpu_common.h b/test/gpu_common.h
index 8c7049b..efd09c1 100644
--- a/test/gpu_common.h
+++ b/test/gpu_common.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef EIGEN_TEST_GPU_COMMON_H
 #define EIGEN_TEST_GPU_COMMON_H
 
@@ -51,9 +54,9 @@
   gpuDeviceSynchronize();
 
 #ifdef EIGEN_USE_HIP
-  hipLaunchKernelGGL(HIP_KERNEL_NAME(run_on_gpu_meta_kernel<Kernel, typename std::decay<decltype(*d_in)>::type,
-                                                            typename std::decay<decltype(*d_out)>::type>),
-                     dim3(Grids), dim3(Blocks), 0, 0, ker, n, d_in, d_out);
+  hipLaunchKernelGGL(
+      HIP_KERNEL_NAME(run_on_gpu_meta_kernel<Kernel, std::decay_t<decltype(*d_in)>, std::decay_t<decltype(*d_out)>>),
+      dim3(Grids), dim3(Blocks), 0, 0, ker, n, d_in, d_out);
 #else
   // Various versions of clang-format incorrectly add spaces to the kernel launch brackets.
   // clang-format off
@@ -104,7 +107,7 @@
 struct compile_time_device_info {
   EIGEN_DEVICE_FUNC void operator()(int i, const int* /*in*/, int* info) const {
     if (i == 0) {
-      EIGEN_UNUSED_VARIABLE(info)
+      EIGEN_UNUSED_VARIABLE(info);
 #if defined(__CUDA_ARCH__)
       info[0] = int(__CUDA_ARCH__ + 0);
 #endif
diff --git a/test/gpu_example.cu b/test/gpu_example.cu
index 03b2ec5..5583e6e 100644
--- a/test/gpu_example.cu
+++ b/test/gpu_example.cu
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // The following is an example GPU test.
 
diff --git a/test/gpu_test_helper.h b/test/gpu_test_helper.h
index ee6c70b..31bdcfe 100644
--- a/test/gpu_test_helper.h
+++ b/test/gpu_test_helper.h
@@ -1,15 +1,17 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef GPU_TEST_HELPER_H
 #define GPU_TEST_HELPER_H
 
 #include <Eigen/Core>
 
 // Allow gpu** macros for generic tests.
+#define EIGEN_PERMANENTLY_ENABLE_GPU_HIP_CUDA_DEFINES
 #include <Eigen/src/Core/util/GpuHipCudaDefines.inc>
 
-// std::tuple cannot be used on device, and there is a bug in cuda < 9.2 that
-// doesn't allow std::tuple to compile for host code either. In these cases,
-// use our custom implementation.
-#if defined(EIGEN_GPU_COMPILE_PHASE) || (defined(EIGEN_CUDACC) && EIGEN_CUDA_SDK_VER < 92000)
+// std::tuple cannot be used on device, so use our custom implementation there.
+#if defined(EIGEN_GPU_COMPILE_PHASE)
 #define EIGEN_USE_CUSTOM_TUPLE 1
 #else
 #define EIGEN_USE_CUSTOM_TUPLE 0
@@ -42,6 +44,9 @@
 #undef EIGEN_USE_CUSTOM_TUPLE
 }  // namespace test_detail
 
+template <typename Func, typename... Args>
+using kernel_result_t = decltype(std::declval<Func>()(std::declval<Args>()...));
+
 template <size_t N, size_t Idx, typename OutputIndexSequence, typename... Ts>
 struct extract_output_indices_helper;
 
@@ -60,10 +65,10 @@
 struct extract_output_indices_helper<N, Idx, std::index_sequence<OutputIndices...>, T1, Ts...> {
   using type = typename extract_output_indices_helper<
       N - 1, Idx + 1,
-      typename std::conditional<
+      std::conditional_t<
           // If is a non-const l-value reference, append index.
           std::is_lvalue_reference<T1>::value && !std::is_const<std::remove_reference_t<T1>>::value,
-          std::index_sequence<OutputIndices..., Idx>, std::index_sequence<OutputIndices...>>::type,
+          std::index_sequence<OutputIndices..., Idx>, std::index_sequence<OutputIndices...>>,
       Ts...>::type;
 };
 
@@ -85,28 +90,28 @@
 
   // Converts void -> Void, T otherwise.
   template <typename T>
-  using ReturnType = typename std::conditional<std::is_same<T, void>::value, Void, T>::type;
+  using ReturnType = std::conditional_t<std::is_same<T, void>::value, Void, T>;
 
   // Non-void return value.
   template <typename Func, typename... Args>
   static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC auto call(Func&& func, Args&&... args)
-      -> std::enable_if_t<!std::is_same<decltype(func(args...)), void>::value, decltype(func(args...))> {
+      -> std::enable_if_t<!std::is_same<kernel_result_t<Func&&, Args&&...>, void>::value,
+                          kernel_result_t<Func&&, Args&&...>> {
     return func(std::forward<Args>(args)...);
   }
 
   // Void return value.
   template <typename Func, typename... Args>
   static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC auto call(Func&& func, Args&&... args)
-      -> std::enable_if_t<std::is_same<decltype(func(args...)), void>::value, Void> {
+      -> std::enable_if_t<std::is_same<kernel_result_t<Func&&, Args&&...>, void>::value, Void> {
     func(std::forward<Args>(args)...);
     return Void{};
   }
 
   // Restores the original return type, Void -> void, T otherwise.
   template <typename T>
-  static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC
-      std::enable_if_t<!std::is_same<typename std::decay<T>::type, Void>::value, T>
-      restore(T&& val) {
+  static EIGEN_ALWAYS_INLINE EIGEN_DEVICE_FUNC std::enable_if_t<!std::is_same<std::decay_t<T>, Void>::value, T> restore(
+      T&& val) {
     return val;
   }
 
@@ -135,18 +140,18 @@
   const uint8_t* read_end = buffer + capacity;
   read_ptr = Eigen::deserialize(read_ptr, read_end, input_size);
   // Create value-type instances to populate.
-  auto args = make_tuple(typename std::decay<Args>::type{}...);
-  EIGEN_UNUSED_VARIABLE(args)  // Avoid NVCC compile warning.
+  auto args = make_tuple(std::decay_t<Args>{}...);
+  EIGEN_UNUSED_VARIABLE(args);  // Avoid NVCC compile warning.
   // NVCC 9.1 requires us to spell out the template parameters explicitly.
-  read_ptr = Eigen::deserialize(read_ptr, read_end, get<Indices, typename std::decay<Args>::type...>(args)...);
+  read_ptr = Eigen::deserialize(read_ptr, read_end, get<Indices, std::decay_t<Args>...>(args)...);
 
   // Call function, with void->Void conversion so we are guaranteed a complete
   // output type.
-  auto result = void_helper::call(kernel, get<Indices, typename std::decay<Args>::type...>(args)...);
+  auto result = void_helper::call(kernel, get<Indices, std::decay_t<Args>...>(args)...);
 
   // Determine required output size.
   size_t output_size = Eigen::serialize_size(capacity);
-  output_size += Eigen::serialize_size(get<OutputIndices, typename std::decay<Args>::type...>(args)...);
+  output_size += Eigen::serialize_size(get<OutputIndices, std::decay_t<Args>...>(args)...);
   output_size += Eigen::serialize_size(result);
 
   // Always serialize required buffer size.
@@ -157,7 +162,7 @@
   // Serialize outputs if they fit in the buffer.
   if (output_size <= capacity) {
     // Collect outputs and result.
-    write_ptr = Eigen::serialize(write_ptr, write_end, get<OutputIndices, typename std::decay<Args>::type...>(args)...);
+    write_ptr = Eigen::serialize(write_ptr, write_end, get<OutputIndices, std::decay_t<Args>...>(args)...);
     write_ptr = Eigen::serialize(write_ptr, write_end, result);
   }
 }
@@ -262,7 +267,7 @@
 
   // Deserialize outputs.
   auto args_tuple = test_detail::tie(args...);
-  EIGEN_UNUSED_VARIABLE(args_tuple)  // Avoid NVCC compile warning.
+  EIGEN_UNUSED_VARIABLE(args_tuple);  // Avoid NVCC compile warning.
   c_host_ptr = Eigen::deserialize(c_host_ptr, host_data_end, test_detail::get<OutputIndices, Args&...>(args_tuple)...);
 
   // Maybe deserialize return value, properly handling void.
@@ -282,7 +287,7 @@
  * \return kernel(args...).
  */
 template <typename Kernel, typename... Args>
-auto run_on_cpu(Kernel kernel, Args&&... args) -> decltype(kernel(args...)) {
+auto run_on_cpu(Kernel kernel, Args&&... args) -> internal::kernel_result_t<Kernel, Args&&...> {
   return kernel(std::forward<Args>(args)...);
 }
 
@@ -301,7 +306,7 @@
  * \return kernel(args...).
  */
 template <typename Kernel, typename... Args>
-auto run_on_gpu(Kernel kernel, Args&&... args) -> decltype(kernel(args...)) {
+auto run_on_gpu(Kernel kernel, Args&&... args) -> internal::kernel_result_t<Kernel, Args&&...> {
   return internal::run_serialized_on_gpu<Kernel, Args...>(
       /*buffer_capacity_hint=*/0, std::make_index_sequence<sizeof...(Args)>{},
       internal::extract_output_indices<Args...>{}, kernel, std::forward<Args>(args)...);
@@ -322,76 +327,13 @@
  * \sa run_on_gpu
  */
 template <typename Kernel, typename... Args>
-auto run_on_gpu_with_hint(size_t buffer_capacity_hint, Kernel kernel, Args&&... args) -> decltype(kernel(args...)) {
+auto run_on_gpu_with_hint(size_t buffer_capacity_hint, Kernel kernel, Args&&... args)
+    -> internal::kernel_result_t<Kernel, Args&&...> {
   return internal::run_serialized_on_gpu<Kernel, Args...>(
       buffer_capacity_hint, std::make_index_sequence<sizeof...(Args)>{}, internal::extract_output_indices<Args...>{},
       kernel, std::forward<Args>(args)...);
 }
 
-/**
- * Kernel for determining basic Eigen compile-time information
- * (i.e. the cuda/hip arch)
- */
-struct CompileTimeDeviceInfoKernel {
-  struct Info {
-    int cuda;
-    int hip;
-  };
-
-  EIGEN_DEVICE_FUNC Info operator()() const {
-    Info info = {-1, -1};
-#if defined(__CUDA_ARCH__)
-    info.cuda = static_cast<int>(__CUDA_ARCH__ + 0);
-#endif
-#if defined(EIGEN_HIP_DEVICE_COMPILE)
-    info.hip = static_cast<int>(EIGEN_HIP_DEVICE_COMPILE + 0);
-#endif
-    return info;
-  }
-};
-
-/**
- * Queries and prints the compile-time and runtime GPU info.
- */
-void print_gpu_device_info() {
-  int device = 0;
-  gpuDeviceProp_t deviceProp;
-  gpuGetDeviceProperties(&deviceProp, device);
-
-  auto info = run_on_gpu(CompileTimeDeviceInfoKernel());
-
-  std::cout << "GPU compile-time info:\n";
-
-#ifdef EIGEN_CUDACC
-  std::cout << "  EIGEN_CUDACC:                " << int(EIGEN_CUDACC) << std::endl;
-#endif
-
-#ifdef EIGEN_CUDA_SDK_VER
-  std::cout << "  EIGEN_CUDA_SDK_VER:          " << int(EIGEN_CUDA_SDK_VER) << std::endl;
-#endif
-
-#if EIGEN_COMP_NVCC
-  std::cout << "  EIGEN_COMP_NVCC:             " << int(EIGEN_COMP_NVCC) << std::endl;
-#endif
-
-#ifdef EIGEN_HIPCC
-  std::cout << "  EIGEN_HIPCC:                 " << int(EIGEN_HIPCC) << std::endl;
-#endif
-
-  std::cout << "  EIGEN_CUDA_ARCH:             " << info.cuda << std::endl;
-  std::cout << "  EIGEN_HIP_DEVICE_COMPILE:    " << info.hip << std::endl;
-
-  std::cout << "GPU device info:\n";
-  std::cout << "  name:                        " << deviceProp.name << std::endl;
-  std::cout << "  capability:                  " << deviceProp.major << "." << deviceProp.minor << std::endl;
-  std::cout << "  multiProcessorCount:         " << deviceProp.multiProcessorCount << std::endl;
-  std::cout << "  maxThreadsPerMultiProcessor: " << deviceProp.maxThreadsPerMultiProcessor << std::endl;
-  std::cout << "  warpSize:                    " << deviceProp.warpSize << std::endl;
-  std::cout << "  regsPerBlock:                " << deviceProp.regsPerBlock << std::endl;
-  std::cout << "  concurrentKernels:           " << deviceProp.concurrentKernels << std::endl;
-  std::cout << "  canMapHostMemory:            " << deviceProp.canMapHostMemory << "\n";
-}
-
 #endif  // EIGEN_GPUCC
 
 /**
@@ -409,7 +351,7 @@
  * \return kernel(args...).
  */
 template <typename Kernel, typename... Args>
-auto run(Kernel kernel, Args&&... args) -> decltype(kernel(args...)) {
+auto run(Kernel kernel, Args&&... args) -> internal::kernel_result_t<Kernel, Args&&...> {
 #ifdef EIGEN_GPUCC
   return run_on_gpu(kernel, std::forward<Args>(args)...);
 #else
@@ -432,11 +374,12 @@
  * \sa run
  */
 template <typename Kernel, typename... Args>
-auto run_with_hint(size_t buffer_capacity_hint, Kernel kernel, Args&&... args) -> decltype(kernel(args...)) {
+auto run_with_hint(size_t buffer_capacity_hint, Kernel kernel, Args&&... args)
+    -> internal::kernel_result_t<Kernel, Args&&...> {
 #ifdef EIGEN_GPUCC
   return run_on_gpu_with_hint(buffer_capacity_hint, kernel, std::forward<Args>(args)...);
 #else
-  EIGEN_UNUSED_VARIABLE(buffer_capacity_hint)
+  EIGEN_UNUSED_VARIABLE(buffer_capacity_hint);
   return run_on_cpu(kernel, std::forward<Args>(args)...);
 #endif
 }
diff --git a/test/half_float.cpp b/test/half_float.cpp
index aabe896..2db9fdf 100644
--- a/test/half_float.cpp
+++ b/test/half_float.cpp
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include <sstream>
 
@@ -125,6 +127,14 @@
 
   VERIFY(NumTraits<half>::IsSigned);
 
+  // The fp16 machine epsilon is 2^-10 = 0x1400, and NumTraits must agree with
+  // std::numeric_limits (NumTraits used to return 2^-13, making every
+  // epsilon-based threshold 8x too tight).
+  VERIFY_HALF_BITS_EQUAL(NumTraits<half>::epsilon(), 0x1400);
+  VERIFY_HALF_BITS_EQUAL(std::numeric_limits<half>::epsilon(), 0x1400);
+  VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(NumTraits<half>::epsilon()),
+                  numext::bit_cast<numext::uint16_t>(std::numeric_limits<half>::epsilon()));
+
   VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(std::numeric_limits<half>::infinity()),
                   numext::bit_cast<numext::uint16_t>(half(std::numeric_limits<float>::infinity())));
   // There is no guarantee that casting a 32-bit NaN to 16-bit has a precise
@@ -332,6 +342,41 @@
   VERIFY_IS_APPROX(Ch.noalias() += Ah * Bh, (Cf.noalias() += Af * Bf).cast<half>());
 }
 
+void test_nextafter() {
+  VERIFY((numext::isnan)(numext::nextafter(std::numeric_limits<half>::quiet_NaN(), half(1.0f))));
+  VERIFY((numext::isnan)(numext::nextafter(half(1.0f), std::numeric_limits<half>::quiet_NaN())));
+  VERIFY(numext::nextafter(half(0.0f), half(0.0f)) == half(0.0f));
+  VERIFY(numext::nextafter(half(1.0f), half(1.0f)) == half(1.0f));
+  VERIFY(numext::nextafter(half(-1.0f), half(-1.0f)) == half(-1.0f));
+  VERIFY(numext::nextafter(std::numeric_limits<half>::infinity(), std::numeric_limits<half>::infinity()) ==
+         std::numeric_limits<half>::infinity());
+  VERIFY(numext::nextafter(std::numeric_limits<half>::infinity(), half(0.0f)) == (std::numeric_limits<half>::max)());
+  VERIFY(numext::nextafter(-std::numeric_limits<half>::infinity(), half(0.0f)) == -(std::numeric_limits<half>::max)());
+  VERIFY(numext::nextafter(half(1.0f), std::numeric_limits<half>::infinity()) ==
+         half(1.0f) + std::numeric_limits<half>::epsilon());
+  VERIFY(numext::nextafter(half(1.0f), -std::numeric_limits<half>::infinity()) ==
+         half(1.0f) - std::numeric_limits<half>::epsilon() / half(2.0f));
+  VERIFY(numext::nextafter(half(-1.0f), -std::numeric_limits<half>::infinity()) ==
+         half(-1.0f) - std::numeric_limits<half>::epsilon());
+  VERIFY(numext::nextafter(half(-1.0f), std::numeric_limits<half>::infinity()) ==
+         half(-1.0f) + std::numeric_limits<half>::epsilon() / half(2.0f));
+  VERIFY(numext::nextafter((std::numeric_limits<half>::max)(), std::numeric_limits<half>::infinity()) ==
+         std::numeric_limits<half>::infinity());
+  VERIFY(numext::nextafter(-(std::numeric_limits<half>::max)(), -std::numeric_limits<half>::infinity()) ==
+         -std::numeric_limits<half>::infinity());
+  // The neighbors of ±0 are the smallest subnormals with the sign of the
+  // direction, matching std::nextafter (IEEE-754 nextUp/nextDown of zero).
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(0.0f), half(1.0f)), 0x0001);
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(-0.0f), half(1.0f)), 0x0001);
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(0.0f), half(-1.0f)), 0x8001);
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(-0.0f), half(-1.0f)), 0x8001);
+  // from == to returns to, preserving the sign of zero.
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(0.0f), half(-0.0f)), 0x8000);
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(-0.0f), half(0.0f)), 0x0000);
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(0.0f), half(0.0f)), 0x0000);
+  VERIFY_HALF_BITS_EQUAL(numext::nextafter(half(-0.0f), half(-0.0f)), 0x8000);
+}
+
 EIGEN_DECLARE_TEST(half_float) {
   CALL_SUBTEST(test_numtraits());
   for (int i = 0; i < g_repeat; i++) {
@@ -342,5 +387,6 @@
     CALL_SUBTEST(test_trigonometric_functions());
     CALL_SUBTEST(test_array());
     CALL_SUBTEST(test_product());
+    CALL_SUBTEST(test_nextafter());
   }
 }
diff --git a/test/hessenberg.cpp b/test/hessenberg.cpp
index 90364f1..594ae18 100644
--- a/test/hessenberg.cpp
+++ b/test/hessenberg.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/Eigenvalues>
diff --git a/test/householder.cpp b/test/householder.cpp
index 0107759..8e20328 100644
--- a/test/householder.cpp
+++ b/test/householder.cpp
@@ -6,10 +6,90 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "fp_control.h"
+#include "NonCommutativeScalar.h"
 #include <Eigen/QR>
 
+namespace reordered_complex {
+
+template <typename Real>
+struct Complex {
+  Complex() : imag_value(0), real_value(0) {}
+  Complex(Real real) : imag_value(0), real_value(real) {}
+  Complex(Real real, Real imag) : imag_value(imag), real_value(real) {}
+
+  Complex operator+(const Complex& other) const {
+    return Complex(real_value + other.real_value, imag_value + other.imag_value);
+  }
+  Complex operator-() const { return Complex(-real_value, -imag_value); }
+  Complex operator-(const Complex& other) const {
+    return Complex(real_value - other.real_value, imag_value - other.imag_value);
+  }
+  Complex operator*(const Complex& other) const {
+    return Complex(real_value * other.real_value - imag_value * other.imag_value,
+                   real_value * other.imag_value + imag_value * other.real_value);
+  }
+  Complex operator/(const Complex& other) const {
+    const Real denominator = other.real_value * other.real_value + other.imag_value * other.imag_value;
+    return Complex((real_value * other.real_value + imag_value * other.imag_value) / denominator,
+                   (imag_value * other.real_value - real_value * other.imag_value) / denominator);
+  }
+
+  bool operator==(const Complex& other) const {
+    return real_value == other.real_value && imag_value == other.imag_value;
+  }
+  bool operator!=(const Complex& other) const { return !(*this == other); }
+
+  friend Complex operator+(const Real& lhs, const Complex& rhs) {
+    return Complex(lhs + rhs.real_value, rhs.imag_value);
+  }
+  friend Complex operator-(const Real& lhs, const Complex& rhs) {
+    return Complex(lhs - rhs.real_value, -rhs.imag_value);
+  }
+  friend Complex operator*(const Real& lhs, const Complex& rhs) {
+    return Complex(lhs * rhs.real_value, lhs * rhs.imag_value);
+  }
+  friend Complex operator*(const Complex& lhs, const Real& rhs) {
+    return Complex(lhs.real_value * rhs, lhs.imag_value * rhs);
+  }
+  friend Complex operator/(const Complex& lhs, const Real& rhs) {
+    return Complex(lhs.real_value / rhs, lhs.imag_value / rhs);
+  }
+
+  // The reversed order is intentional: algorithms must not infer component access from IsComplex.
+  Real imag_value;
+  Real real_value;
+};
+
+template <typename Real>
+Real real(const Complex<Real>& value) {
+  return value.real_value;
+}
+template <typename Real>
+Real imag(const Complex<Real>& value) {
+  return value.imag_value;
+}
+template <typename Real>
+Complex<Real> conj(const Complex<Real>& value) {
+  return Complex<Real>(value.real_value, -value.imag_value);
+}
+template <typename Real>
+Real abs(const Complex<Real>& value) {
+  return numext::hypot(value.real_value, value.imag_value);
+}
+
+}  // namespace reordered_complex
+
+namespace Eigen {
+template <typename Real>
+struct NumTraits<reordered_complex::Complex<Real>> : NumTraits<Real> {
+  static constexpr bool IsComplex = true;
+};
+}  // namespace Eigen
+
 template <typename MatrixType>
 void householder(const MatrixType& m) {
   static bool even = true;
@@ -23,7 +103,7 @@
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
-  typedef Matrix<Scalar, internal::decrement_size<MatrixType::RowsAtCompileTime>::ret, 1> EssentialVectorType;
+  typedef Matrix<Scalar, internal::decrement_size<MatrixType::RowsAtCompileTime>::value, 1> EssentialVectorType;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
   typedef Matrix<Scalar, Dynamic, MatrixType::ColsAtCompileTime> HBlockMatrixType;
   typedef Matrix<Scalar, Dynamic, 1> HCoeffsVectorType;
@@ -213,6 +293,680 @@
   }
 }
 
+template <typename Scalar>
+void householder_blocked_right_regression() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+  typedef HouseholderSequence<MatrixX, VectorX> LeftSequence;
+  typedef HouseholderSequence<MatrixX, VectorX, OnTheRight> RightSequence;
+
+  const Index rows = 256;
+  const Index cols = 128;
+  const Index shift = 17;
+
+  // Force the blocked path added for right-side Householder application.
+  VERIFY(cols >= 48 && rows - shift >= 4 * 48);
+
+  MatrixX input = MatrixX::Random(rows, cols);
+  MatrixX qr_input = input.block(shift, 0, rows - shift, cols);
+  HouseholderQR<MatrixX> qr(qr_input);
+
+  MatrixX packed = input;
+  packed.block(shift, 0, rows - shift, cols) = qr.matrixQR();
+  VectorX hcoeffs = qr.hCoeffs().conjugate();
+
+  LeftSequence hseq(packed, hcoeffs);
+  hseq.setLength(hcoeffs.size()).setShift(shift);
+  MatrixX dense_left = MatrixX(hseq);
+
+  MatrixX packed_transposed = packed.transpose();
+  RightSequence rhseq(packed_transposed, hcoeffs);
+  rhseq.setLength(hcoeffs.size()).setShift(shift);
+  MatrixX dense_right = MatrixX(rhseq);
+
+  MatrixX left_rhs = MatrixX::Random(rows, rows + 9);
+  MatrixX right_lhs = MatrixX::Random(rows + 7, rows);
+
+  VERIFY_IS_APPROX(hseq * left_rhs, dense_left * left_rhs);
+  VERIFY_IS_APPROX(hseq.adjoint() * left_rhs, dense_left.adjoint() * left_rhs);
+  VERIFY_IS_APPROX(right_lhs * hseq, right_lhs * dense_left);
+  VERIFY_IS_APPROX(right_lhs * hseq.adjoint(), right_lhs * dense_left.adjoint());
+
+  VERIFY_IS_APPROX(rhseq * left_rhs, dense_right * left_rhs);
+  VERIFY_IS_APPROX(rhseq.adjoint() * left_rhs, dense_right.adjoint() * left_rhs);
+  VERIFY_IS_APPROX(right_lhs * rhseq, right_lhs * dense_right);
+  VERIFY_IS_APPROX(right_lhs * rhseq.adjoint(), right_lhs * dense_right.adjoint());
+}
+
+template <typename VectorType, typename EssentialType>
+void verify_real_householder_result(const VectorType& vector, const EssentialType& essential,
+                                    const typename VectorType::Scalar& tau,
+                                    const typename VectorType::RealScalar& beta) {
+  typedef typename VectorType::RealScalar RealScalar;
+  const long double epsilon = static_cast<long double>(NumTraits<RealScalar>::epsilon());
+  long double input_squared_norm = 0;
+  long double householder_squared_norm = 1;
+  long double inner_product = static_cast<long double>(vector.coeff(0));
+  for (Index i = 0; i < vector.size(); ++i) {
+    const long double value = static_cast<long double>(vector.coeff(i));
+    input_squared_norm += value * value;
+    if (i > 0) {
+      const long double essential_value = static_cast<long double>(essential.coeff(i - 1));
+      householder_squared_norm += essential_value * essential_value;
+      inner_product += essential_value * value;
+    }
+  }
+
+  const long double input_norm = std::sqrt(input_squared_norm);
+  const long double tau_wide = static_cast<long double>(tau);
+  const long double bound = 64 * epsilon * input_norm;
+  const long double transformed_head = static_cast<long double>(vector.coeff(0)) - tau_wide * inner_product;
+  VERIFY(std::abs(transformed_head - static_cast<long double>(beta)) <= bound);
+
+  long double transformed_tail_squared_norm = 0;
+  for (Index i = 1; i < vector.size(); ++i) {
+    const long double essential_value = static_cast<long double>(essential.coeff(i - 1));
+    const long double transformed =
+        static_cast<long double>(vector.coeff(i)) - tau_wide * essential_value * inner_product;
+    transformed_tail_squared_norm += transformed * transformed;
+  }
+  VERIFY(std::sqrt(transformed_tail_squared_norm) <= bound);
+  VERIFY(std::abs(2 * tau_wide - tau_wide * tau_wide * householder_squared_norm) <= 64 * epsilon);
+}
+
+template <typename RealScalar>
+void verify_complex_zero_tail(RealScalar coefficient) {
+  typedef std::complex<RealScalar> Scalar;
+  typedef std::complex<long double> WideScalar;
+  Matrix<Scalar, 2, 1> vector;
+  vector << Scalar(0, coefficient), Scalar(0, 0);
+  Matrix<Scalar, 1, 1> essential;
+  Scalar tau;
+  RealScalar beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  const WideScalar x0(0, static_cast<long double>(coefficient));
+  const WideScalar x1(0, 0);
+  const WideScalar essential_wide(static_cast<long double>(numext::real(essential[0])),
+                                  static_cast<long double>(numext::imag(essential[0])));
+  const WideScalar tau_wide(static_cast<long double>(numext::real(tau)), static_cast<long double>(numext::imag(tau)));
+  const WideScalar inner_product = x0 + std::conj(essential_wide) * x1;
+  const WideScalar transformed_head = x0 - tau_wide * inner_product;
+  const WideScalar transformed_tail = x1 - tau_wide * essential_wide * inner_product;
+  const long double epsilon = static_cast<long double>(NumTraits<RealScalar>::epsilon());
+  const long double bound = 16 * epsilon * std::abs(x0);
+
+  VERIFY(std::abs(transformed_head - WideScalar(static_cast<long double>(beta), 0)) <= bound);
+  VERIFY(std::abs(transformed_tail) <= bound);
+  VERIFY(std::abs(2 * numext::real(tau_wide) - std::norm(tau_wide) * (1 + std::norm(essential_wide))) <= 16 * epsilon);
+}
+
+template <typename RealScalar>
+void verify_low_precision_complex_zero_tail() {
+  typedef std::complex<RealScalar> Scalar;
+  const RealScalar zero = RealScalar(0);
+  const RealScalar coefficient = RealScalar(0.25f);
+  Matrix<Scalar, 2, 1> vector;
+  vector << Scalar(zero, coefficient), Scalar(zero, zero);
+  Matrix<Scalar, 1, 1> essential;
+  Scalar tau;
+  RealScalar beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  VERIFY_IS_EQUAL(numext::real(tau), RealScalar(1));
+  VERIFY_IS_EQUAL(numext::imag(tau), RealScalar(-1));
+  VERIFY_IS_EQUAL(beta, -coefficient);
+  VERIFY_IS_EQUAL(numext::real(essential[0]), zero);
+  VERIFY_IS_EQUAL(numext::imag(essential[0]), zero);
+}
+
+template <typename RealScalar>
+void verify_complex_nan_head() {
+  typedef std::complex<RealScalar> Scalar;
+  const RealScalar nan = NumTraits<RealScalar>::quiet_NaN();
+  Matrix<Scalar, 2, 1> vector;
+  vector << Scalar(1, nan), Scalar(0, 0);
+  Matrix<Scalar, 1, 1> essential;
+  Scalar tau;
+  RealScalar beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  VERIFY((numext::isnan)(beta));
+}
+
+void verify_custom_complex_small_tail() {
+  typedef reordered_complex::Complex<float> Scalar;
+  const float coefficient = 2e-16f;
+  Matrix<Scalar, 2, 1> vector;
+  vector << Scalar(0), Scalar(coefficient);
+  Matrix<Scalar, 1, 1> essential;
+  Scalar tau;
+  float beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  VERIFY_IS_EQUAL(numext::real(tau), 1.0f);
+  VERIFY_IS_EQUAL(numext::imag(tau), 0.0f);
+  VERIFY_IS_EQUAL(beta, -coefficient);
+  VERIFY_IS_EQUAL(numext::real(essential[0]), 1.0f);
+  VERIFY_IS_EQUAL(numext::imag(essential[0]), 0.0f);
+}
+
+EIGEN_DONT_INLINE void verify_householder_flushed_tail() {
+  volatile float normal_min_input = (std::numeric_limits<float>::min)();
+  const float normal_min = normal_min_input;
+  const float normal_root = numext::sqrt(normal_min);
+  const float dominant = normal_root * numext::sqrt(1.1f);
+  const float minor = normal_root * numext::sqrt(0.1f / 7.0f);
+  VectorXf vector = VectorXf::Constant(9, minor);
+  vector[0] = 0.0f;
+  vector[1] = dominant;
+  VectorXf essential(8);
+  float tau;
+  float beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  verify_real_householder_result(vector, essential, tau, beta);
+}
+
+EIGEN_DONT_INLINE void verify_householder_dimension_scaled_tail() {
+  // The dominant square is just above the length-independent threshold, while the many minor squares are normal
+  // inputs whose individually subnormal products become significant in aggregate.
+  constexpr Index size = 262145;
+  const double normal_min = static_cast<double>((std::numeric_limits<float>::min)());
+  const double epsilon = static_cast<double>(NumTraits<float>::epsilon());
+  const float dominant = static_cast<float>(std::sqrt(1.01 * normal_min / epsilon));
+  const float minor = static_cast<float>(std::sqrt(0.5 * normal_min));
+  VectorXf vector = VectorXf::Constant(size, minor);
+  vector[0] = 0.0f;
+  vector[1] = dominant;
+  VectorXf essential(size - 1);
+  float tau;
+  float beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  verify_real_householder_result(vector, essential, tau, beta);
+  const double expected_norm =
+      std::sqrt(double(dominant) * double(dominant) + double(size - 2) * double(minor) * double(minor));
+  VERIFY(std::abs(double(beta) + expected_norm) <= 8 * epsilon * expected_norm);
+}
+
+void householder_small_tail_layouts() {
+  const float coefficient = 1e-20f;
+  Vector4f column;
+  column << 0.0f, coefficient, -2.0f * coefficient, 3.0f * coefficient;
+  Vector3f column_essential;
+  float tau;
+  float beta;
+  column.makeHouseholder(column_essential, tau, beta);
+  verify_real_householder_result(column, column_essential, tau, beta);
+
+  RowVector4f row = column.transpose();
+  RowVector3f row_essential;
+  row.makeHouseholder(row_essential, tau, beta);
+  verify_real_householder_result(row, row_essential, tau, beta);
+
+  Vector4f in_place = column;
+  in_place.makeHouseholderInPlace(tau, beta);
+  verify_real_householder_result(column, in_place.tail<3>(), tau, beta);
+
+  Vector4f aliased = column;
+  const Vector4f original = aliased;
+  auto aliased_essential = aliased.tail<3>();
+  aliased.makeHouseholder(aliased_essential, tau, beta);
+  verify_real_householder_result(original, aliased_essential, tau, beta);
+
+  float input_storage[8] = {0.0f, 11.0f, coefficient, 12.0f, -2.0f * coefficient, 13.0f, 3.0f * coefficient, 14.0f};
+  float essential_storage[6] = {0.0f, 21.0f, 0.0f, 22.0f, 0.0f, 23.0f};
+  typedef Map<VectorXf, Unaligned, InnerStride<2>> StridedVector;
+  StridedVector strided_input(input_storage, 4, InnerStride<2>());
+  StridedVector strided_essential(essential_storage, 3, InnerStride<2>());
+  strided_input.makeHouseholder(strided_essential, tau, beta);
+  verify_real_householder_result(strided_input, strided_essential, tau, beta);
+  VERIFY_IS_EQUAL(input_storage[1], 11.0f);
+  VERIFY_IS_EQUAL(input_storage[3], 12.0f);
+  VERIFY_IS_EQUAL(input_storage[5], 13.0f);
+  VERIFY_IS_EQUAL(input_storage[7], 14.0f);
+  VERIFY_IS_EQUAL(essential_storage[1], 21.0f);
+  VERIFY_IS_EQUAL(essential_storage[3], 22.0f);
+  VERIFY_IS_EQUAL(essential_storage[5], 23.0f);
+}
+
+void householder_small_tail() {
+  {
+    const float coefficient = 1e-20f;
+    Vector2f vector(0.0f, coefficient);
+    VectorXf essential(1);
+    float tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    VERIFY_IS_APPROX(tau, 1.0f);
+    VERIFY_IS_APPROX(beta, -coefficient);
+    VERIFY_IS_APPROX(essential[0], 1.0f);
+  }
+
+  {
+    const float largest = (std::numeric_limits<float>::max)();
+    Vector2f vector(largest, 1e-20f);
+    VectorXf essential(1);
+    float tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    VERIFY_IS_EQUAL(tau, 0.0f);
+    VERIFY_IS_EQUAL(beta, largest);
+    VERIFY_IS_EQUAL(essential[0], 0.0f);
+  }
+
+  {
+    const float largest = (std::numeric_limits<float>::max)();
+    const Vector2cf vector(std::complex<float>(0.0f, largest), std::complex<float>(1e-20f, 0.0f));
+    VectorXcf essential(1);
+    std::complex<float> tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    VERIFY_IS_EQUAL(tau, std::complex<float>(1.0f, -1.0f));
+    VERIFY_IS_EQUAL(beta, -largest);
+    VERIFY_IS_EQUAL(essential[0], std::complex<float>(0.0f, 0.0f));
+    Vector2cf householder;
+    householder << std::complex<float>(1.0f, 0.0f), essential;
+    const Matrix2cf transform = Matrix2cf::Identity() - tau * householder * householder.adjoint();
+    VERIFY_IS_APPROX(transform.adjoint() * transform, Matrix2cf::Identity());
+  }
+
+  {
+    volatile float denormInput = (std::numeric_limits<float>::denorm_min)();
+    const float denorm = denormInput;
+    // Subnormal operands are indistinguishable from zero when the target flushes them.
+    if (denorm > 0.0f && denorm + denorm > 0.0f) {
+      const Vector2f vector = Vector2f::Constant(denorm);
+      VectorXf essential(1);
+      float tau;
+      float beta;
+
+      vector.makeHouseholder(essential, tau, beta);
+
+      Vector2f householder;
+      householder << 1.0f, essential;
+      const Matrix2f transform = Matrix2f::Identity() - tau * householder * householder.transpose();
+      VERIFY_IS_APPROX(transform.transpose() * transform, Matrix2f::Identity());
+      const Vector2d transformed = transform.cast<double>() * vector.cast<double>();
+      const Vector2d expected(-numext::sqrt(2.0) * double(denorm), 0.0);
+      VERIFY((transformed - expected).norm() <= 4.0 * double(NumTraits<float>::epsilon()) * expected.norm());
+
+      const std::complex<float> complexDenorm(denorm, denorm);
+      const Vector2cf complexVector = Vector2cf::Constant(complexDenorm);
+      VectorXcf complexEssential(1);
+      std::complex<float> complexTau;
+      float complexBeta;
+
+      complexVector.makeHouseholder(complexEssential, complexTau, complexBeta);
+
+      Vector2cf complexHouseholder;
+      complexHouseholder[0] = std::complex<float>(1.0f, 0.0f);
+      complexHouseholder[1] = complexEssential[0];
+      const Matrix2cf complexTransform =
+          Matrix2cf::Identity() - complexTau * complexHouseholder * complexHouseholder.adjoint();
+      VERIFY_IS_APPROX(complexTransform.adjoint() * complexTransform, Matrix2cf::Identity());
+      const Vector2cd complexTransformed =
+          complexTransform.cast<std::complex<double>>() * complexVector.cast<std::complex<double>>();
+      const Vector2cd complexExpected(std::complex<double>(-2.0 * double(denorm), 0.0), std::complex<double>(0.0, 0.0));
+      VERIFY((complexTransformed - complexExpected).norm() <=
+             8.0 * double(NumTraits<float>::epsilon()) * complexExpected.norm());
+    }
+  }
+
+  {
+    Vector2d vector(0.0, 1e-160);
+    VectorXd essential(1);
+    double tau;
+    double beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    verify_real_householder_result(vector, essential, tau, beta);
+  }
+
+  verify_complex_zero_tail<float>(1e-20f);
+  verify_complex_zero_tail<double>(1e-160);
+  verify_low_precision_complex_zero_tail<half>();
+  verify_low_precision_complex_zero_tail<bfloat16>();
+  verify_complex_nan_head<float>();
+  verify_complex_nan_head<double>();
+  verify_custom_complex_small_tail();
+
+  {
+    const float coefficient = 1e-20f;
+    const Matrix2cf matrix = std::complex<float>(0.0f, coefficient) * Matrix2cf::Identity();
+    const HouseholderQR<Matrix2cf> qr(matrix);
+    const Matrix2cf q = qr.householderQ();
+    const Matrix2cf r = qr.matrixQR().template triangularView<Upper>();
+    const Matrix2cd matrix_wide = matrix.cast<std::complex<double>>();
+    const Matrix2cd reconstructed = (q * r).cast<std::complex<double>>();
+    const double relative_residual = (reconstructed - matrix_wide).norm() / matrix_wide.norm();
+    VERIFY(relative_residual <= 16 * double(NumTraits<float>::epsilon()));
+  }
+
+  verify_householder_flushed_tail();
+  verify_householder_dimension_scaled_tail();
+  {
+    Eigen::ScopedFlushToZero flush_to_zero;
+    if (flush_to_zero.isSupported()) {
+      verify_householder_flushed_tail();
+      verify_householder_dimension_scaled_tail();
+    }
+  }
+
+  householder_small_tail_layouts();
+
+  constexpr Index size = 65;
+  const float coefficient = 1e-22f;
+  VectorXf vector = VectorXf::Constant(size, coefficient);
+  VectorXf essential(size - 1);
+  float tau;
+  float beta;
+
+  vector.makeHouseholder(essential, tau, beta);
+
+  VERIFY(!numext::is_exactly_zero(tau));
+  VERIFY_IS_APPROX(beta / coefficient, -numext::sqrt(float(size)));
+  VERIFY_IS_APPROX(2.0f * tau, tau * tau * (1.0f + essential.squaredNorm()));
+}
+
+// tau and the essential vector are scale invariant and beta is homogeneous, so rescaling by a power of two is exact.
+// It keeps the long double reference below the squaring overflow that this path exists to avoid, which matters where
+// long double is only as wide as double.
+template <typename VectorType, typename EssentialType>
+void verify_large_householder_result(const VectorType& vector, const EssentialType& essential,
+                                     const typename VectorType::Scalar& tau,
+                                     const typename VectorType::RealScalar& beta) {
+  typedef typename VectorType::RealScalar RealScalar;
+  int exponent = 0;
+  (void)std::frexp(vector.cwiseAbs().maxCoeff(), &exponent);
+  const RealScalar scale = std::ldexp(RealScalar(1), exponent);
+  verify_real_householder_result((vector / scale).eval(), essential, tau, RealScalar(beta / scale));
+}
+
+void householder_large_components() {
+  {
+    // The head coefficient squares out of the float range; the tail coefficient does not. The direct
+    // construction forms their sum regardless, so it produced beta = -inf and tau = NaN.
+    Vector2f vector(4e19f, -5.2e18f);
+    Matrix<float, 1, 1> essential;
+    float tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    VERIFY((numext::isfinite)(tau));
+    VERIFY((numext::isfinite)(beta));
+    VERIFY((numext::isfinite)(essential[0]));
+    verify_large_householder_result(vector, essential, tau, beta);
+  }
+
+  {
+    VectorXf vector(3);
+    vector << 1e20f, 2e20f, 3e20f;
+    VectorXf essential(2);
+    float tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    verify_large_householder_result(vector, essential, tau, beta);
+  }
+
+  {
+    // Accumulated overflow: every square is representable, their sum is not.
+    VectorXf vector = VectorXf::Constant(65, 1e19f);
+    VectorXf essential(64);
+    float tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    verify_large_householder_result(vector, essential, tau, beta);
+  }
+
+  {
+    VectorXd vector(3);
+    vector << 1e160, -2e160, 3e160;
+    VectorXd essential(2);
+    double tau;
+    double beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    verify_large_householder_result(vector, essential, tau, beta);
+  }
+
+  {
+    const float largest = (std::numeric_limits<float>::max)();
+    const Vector2cf vector(std::complex<float>(largest, 0.0f), std::complex<float>(largest, 0.0f));
+    Matrix<std::complex<float>, 1, 1> essential;
+    std::complex<float> tau;
+    float beta;
+
+    vector.makeHouseholder(essential, tau, beta);
+
+    // The true norm exceeds the float range, so beta cannot be represented; the reflector itself still must be.
+    VERIFY((numext::isfinite)(numext::real(tau)));
+    VERIFY((numext::isfinite)(numext::imag(tau)));
+    VERIFY((numext::isfinite)(numext::real(essential[0])));
+    VERIFY((numext::isfinite)(numext::imag(essential[0])));
+    Vector2cf householder;
+    householder << std::complex<float>(1.0f, 0.0f), essential;
+    const Matrix2cf transform = Matrix2cf::Identity() - tau * householder * householder.adjoint();
+    VERIFY_IS_APPROX(transform.adjoint() * transform, Matrix2cf::Identity());
+  }
+
+  {
+    // Reflectors this large must still compose into a usable decomposition.
+    MatrixXf matrix(6, 4);
+    for (Index i = 0; i < matrix.rows(); ++i)
+      for (Index j = 0; j < matrix.cols(); ++j) matrix(i, j) = 1e19f * float(internal::random<double>(-1.0, 1.0));
+    const HouseholderQR<MatrixXf> qr(matrix);
+    const MatrixXf q = qr.householderQ() * MatrixXf::Identity(6, 4);
+    const MatrixXf r = qr.matrixQR().topRows(4).template triangularView<Upper>();
+    const MatrixXd scaled = (matrix / 1e19f).cast<double>();
+    const double relative_residual = ((q * r).cast<double>() / 1e19 - scaled).norm() / scaled.norm();
+    VERIFY(relative_residual <= 64 * double(NumTraits<float>::epsilon()));
+  }
+}
+
+template <typename Scalar, int Size, int StorageOrder>
+void householder_short_strided() {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Vector = Matrix<Scalar, Size, 1>;
+  using Essential = Matrix<Scalar, Size - 1, 1>;
+  const Vector vector = Vector::Random();
+  Essential essential;
+  Scalar tau;
+  RealScalar beta;
+  vector.makeHouseholder(essential, tau, beta);
+  Vector v;
+  v << Scalar(1), essential;
+  const Matrix<Scalar, Size, Size> h = Matrix<Scalar, Size, Size>::Identity() - tau * v * v.adjoint();
+
+  for (Index cols : {0, 1, 2, 17, 32, 33, 500, 512}) {
+    for (Index innerStride : {1, 2}) {
+      for (Index outerStride : {2048, 2055}) {
+        Matrix<Scalar, Dynamic, 1> storage =
+            Matrix<Scalar, Dynamic, 1>::Random(outerStride * (StorageOrder == ColMajor ? cols + 2 : Size + 2));
+        Map<Mat, 0, Stride<Dynamic, Dynamic>> mapped(storage.data(), Size + 2, cols + 2,
+                                                     Stride<Dynamic, Dynamic>(outerStride, innerStride));
+        const auto originalStorage = storage.eval();
+        const Mat original = mapped;
+        auto block = mapped.block(1, 1, Size, cols);
+        const Mat expected = h * original.block(1, 1, Size, cols);
+        Matrix<Scalar, Dynamic, 1> workspace(cols + 2);
+        workspace.setConstant(Scalar(7));
+        // Fixed essential length selects the fused column-major path even with dynamic block dimensions.
+        block.applyHouseholderOnTheLeft(essential, tau, workspace.data() + 1);
+        const RealScalar bound = RealScalar(16 * Size) * NumTraits<RealScalar>::epsilon() * original.norm();
+        VERIFY((block - expected).norm() <= bound);
+        VERIFY_IS_EQUAL(workspace[0], Scalar(7));
+        VERIFY_IS_EQUAL(workspace[cols + 1], Scalar(7));
+        Mat expectedFull = original;
+        expectedFull.block(1, 1, Size, cols) = block;
+        const auto resultStorage = storage.eval();
+        storage = originalStorage;
+        mapped = expectedFull;
+        VERIFY_IS_EQUAL(storage, resultStorage);
+
+        block.applyHouseholderOnTheLeft(essential, Scalar(0), workspace.data() + 1);
+        VERIFY_IS_EQUAL(storage, resultStorage);
+
+        storage = originalStorage;
+        const Matrix<Scalar, Dynamic, 1> dynamicEssential = essential;
+        block.applyHouseholderOnTheLeft(dynamicEssential, tau, workspace.data() + 1);
+        VERIFY((block - expected).norm() <= bound);
+
+        if (cols > 0) {
+          storage = originalStorage;
+          const Scalar aliasedTau = block.coeff(0, 0);
+          const Matrix<Scalar, Size, Size> aliasedH =
+              Matrix<Scalar, Size, Size>::Identity() - aliasedTau * v * v.adjoint();
+          const Mat aliasedExpected = aliasedH * original.block(1, 1, Size, cols);
+          block.applyHouseholderOnTheLeft(essential, block.coeffRef(0, 0), workspace.data() + 1);
+          VERIFY((block - aliasedExpected).norm() <= bound);
+        }
+      }
+    }
+  }
+}
+
+// Reference for H * a with v = [1; essential] and the operation order of applyHouseholderOnTheLeft, which a
+// noncommutative scalar distinguishes: w_j = tau * (a_0j + sum_i conj(e_i) a_(i+1)j), a_0j -= w_j, a_(i+1)j -= e_i w_j.
+template <typename MatrixType, typename EssentialType>
+MatrixType householder_left_reference(const MatrixType& a, const EssentialType& essential,
+                                      const typename MatrixType::Scalar& tau) {
+  using Scalar = typename MatrixType::Scalar;
+  MatrixType result = a;
+  for (Index j = 0; j < a.cols(); ++j) {
+    Scalar dot = a(0, j);
+    for (Index i = 0; i < essential.size(); ++i) dot += numext::conj(essential(i)) * a(i + 1, j);
+    const Scalar w = tau * dot;
+    result(0, j) -= w;
+    for (Index i = 0; i < essential.size(); ++i) result(i + 1, j) -= essential(i) * w;
+  }
+  return result;
+}
+
+// Whether applyHouseholderOnTheLeft on Derived with this essential type selects the fused column loop.
+template <typename Derived, typename EssentialPart>
+constexpr bool householder_fused() {
+  return std::is_same<internal::householder_apply_left_impl<Derived, EssentialPart>,
+                      internal::householder_apply_left_impl<Derived, EssentialPart, true>>::value;
+}
+
+template <bool ExpectFused, typename MatrixType, typename EssentialType>
+void verify_householder_left(MatrixType a, const EssentialType& essential, const typename MatrixType::Scalar& tau) {
+  using RealScalar = typename NumTraits<typename MatrixType::Scalar>::Real;
+  STATIC_CHECK((householder_fused<MatrixType, EssentialType>() == ExpectFused));
+  const MatrixType expected = householder_left_reference(a, essential.eval(), tau);
+  // Applying a reflector is backward stable; both evaluations carry O(rows * eps * |a|) rounding.
+  const RealScalar bound = RealScalar(16 * a.rows()) * NumTraits<RealScalar>::epsilon() * a.norm();
+  Matrix<typename MatrixType::Scalar, Dynamic, 1> workspace(a.cols());
+  a.applyHouseholderOnTheLeft(essential, tau, workspace.data());
+  VERIFY((a - expected).norm() <= bound);
+}
+
+// The essential part may be any column-vector expression, not only a plain vector: a runtime one-column block
+// (no compile-time vector shape), the adjoint of a row tail as CompleteOrthogonalDecomposition passes, or a
+// fixed-size segment of either. Each must compile in C++14, where no branch of the dispatch is discarded, and
+// only the fixed-size ones on column-major storage select the fused loop.
+template <typename Scalar, int StorageOrder>
+void householder_essential_expressions() {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using RowMajorMat = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  constexpr bool kFusedIfFixed = StorageOrder == ColMajor;
+  const Index cols = internal::random<Index>(1, 20);
+  for (Index rows : {Index(2), Index(3), internal::random<Index>(4, 20)}) {
+    const Mat a = Mat::Random(rows, cols);
+    Scalar tau;
+    typename NumTraits<Scalar>::Real beta;
+    VectorType essential(rows - 1);
+    // Materialize first: makeHouseholder reads its argument several times, and a lazy Random expression
+    // redraws on every read, so essential and tau would not describe one reflector.
+    const VectorType reflected = VectorType::Random(rows);
+    reflected.makeHouseholder(essential, tau, beta);
+
+    Mat column(rows + 1, 3);
+    column.col(1).tail(rows - 1) = essential;
+    verify_householder_left<false>(a, column.block(2, 1, rows - 1, 1), tau);
+
+    Mat row(3, rows + 1);
+    row.row(1).tail(rows - 1) = essential.adjoint();
+    verify_householder_left<false>(a, row.row(1).tail(rows - 1).adjoint(), tau);
+
+    RowMajorMat rowMajorColumn(rows + 1, 3);
+    rowMajorColumn.col(1).tail(rows - 1) = essential;
+    verify_householder_left<false>(a, rowMajorColumn.col(1).tail(rows - 1), tau);
+
+    if (rows == 2) {
+      verify_householder_left<kFusedIfFixed>(a, row.row(1).template segment<1>(2).adjoint(), tau);
+      verify_householder_left<kFusedIfFixed>(a, rowMajorColumn.col(1).template tail<1>(), tau);
+    }
+    if (rows == 3) {
+      verify_householder_left<kFusedIfFixed>(a, row.row(1).template segment<2>(2).adjoint(), tau);
+      verify_householder_left<kFusedIfFixed>(a, rowMajorColumn.col(1).template tail<2>(), tau);
+    }
+  }
+}
+
+// The fused loop must multiply in the order the general update's expressions spell out, essential * tmp with
+// tmp = tau * (essential.adjoint() * column + top), which only a noncommutative scalar observes. Small integer
+// components keep every operation exact. The general path is not a reference here: its product kernels reorder
+// operands (the gemv selector transposes essential.adjoint() * bottom, the column-major outer-product selector
+// forms tmp_j * essential).
+template <int Size>
+void householder_noncommutative_scalar() {
+  using Scalar = noncommutative_scalar::Quaternion;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic>;
+  using EssentialType = Matrix<Scalar, Size - 1, 1>;
+  STATIC_CHECK((householder_fused<Mat, EssentialType>()));
+  const Scalar i(0, 1), j(0, 0, 1), k(0, 0, 0, 1);
+  {
+    // With essential = [i, 0...]^T, tau = 1 and input [j, 0...]^T, the second entry becomes -i * j = -k.
+    Mat a = Mat::Constant(Size, 1, Scalar(0));
+    a(0, 0) = j;
+    EssentialType essential = EssentialType::Constant(Scalar(0));
+    essential(0) = i;
+    Scalar workspace[1];
+    a.applyHouseholderOnTheLeft(essential, Scalar(1), workspace);
+    VERIFY(a(0, 0) == Scalar(0));
+    VERIFY(a(1, 0) == -k);
+  }
+  const Index cols = internal::random<Index>(1, 7);
+  Mat a(Size, cols);
+  for (Index c = 0; c < cols; ++c)
+    for (Index r = 0; r < Size; ++r)
+      a(r, c) = Scalar(internal::random<int>(-2, 2), internal::random<int>(-2, 2), internal::random<int>(-2, 2),
+                       internal::random<int>(-2, 2));
+  EssentialType essential;
+  for (Index r = 0; r + 1 < Size; ++r)
+    essential(r) = Scalar(internal::random<int>(-2, 2), internal::random<int>(-2, 2), internal::random<int>(-2, 2),
+                          internal::random<int>(-2, 2));
+  const Scalar tau(internal::random<int>(-2, 2), internal::random<int>(-2, 2), internal::random<int>(-2, 2), 1);
+  const Mat expected = householder_left_reference(a, essential, tau);
+  Matrix<Scalar, Dynamic, 1> workspace(cols);
+  a.applyHouseholderOnTheLeft(essential, tau, workspace.data());
+  VERIFY(a == expected);
+}
+
 EIGEN_DECLARE_TEST(householder) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(householder(Matrix<double, 2, 2>()));
@@ -232,4 +986,28 @@
     CALL_SUBTEST_9(householder_update(
         MatrixXcf(internal::random<Index>(1, EIGEN_TEST_MAX_SIZE), internal::random<Index>(1, EIGEN_TEST_MAX_SIZE))));
   }
+
+  CALL_SUBTEST_10(householder_blocked_right_regression<double>());
+  CALL_SUBTEST_11(householder_blocked_right_regression<std::complex<double>>());
+  CALL_SUBTEST_12(householder_small_tail());
+  CALL_SUBTEST_13(householder_large_components());
+  CALL_SUBTEST_14((householder_short_strided<float, 2, ColMajor>()));
+  CALL_SUBTEST_14((householder_short_strided<float, 3, ColMajor>()));
+  CALL_SUBTEST_15((householder_short_strided<double, 2, ColMajor>()));
+  CALL_SUBTEST_15((householder_short_strided<double, 3, ColMajor>()));
+  CALL_SUBTEST_16((householder_short_strided<std::complex<float>, 2, ColMajor>()));
+  CALL_SUBTEST_16((householder_short_strided<std::complex<float>, 3, ColMajor>()));
+  CALL_SUBTEST_17((householder_short_strided<std::complex<double>, 2, ColMajor>()));
+  CALL_SUBTEST_17((householder_short_strided<std::complex<double>, 3, ColMajor>()));
+  CALL_SUBTEST_18((householder_short_strided<double, 2, RowMajor>()));
+  CALL_SUBTEST_18((householder_short_strided<double, 3, RowMajor>()));
+  CALL_SUBTEST_19((householder_short_strided<std::complex<double>, 3, RowMajor>()));
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_20((householder_essential_expressions<double, ColMajor>()));
+    CALL_SUBTEST_20((householder_essential_expressions<double, RowMajor>()));
+    CALL_SUBTEST_21((householder_essential_expressions<std::complex<double>, ColMajor>()));
+    CALL_SUBTEST_21((householder_essential_expressions<std::complex<double>, RowMajor>()));
+    CALL_SUBTEST_22(householder_noncommutative_scalar<2>());
+    CALL_SUBTEST_22(householder_noncommutative_scalar<3>());
+  }
 }
diff --git a/test/householder_fastmath.cpp b/test/householder_fastmath.cpp
new file mode 100644
index 0000000..53a4736
--- /dev/null
+++ b/test/householder_fastmath.cpp
@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/QR>
+
+// -ffinite-math-only lets the compiler assume every result is finite, so isfinite(), isinf(), and isnan() fold to
+// constants in this translation unit and cannot be used to check a result. A comparison against a finite bound is
+// still evaluated, and rejects infinities and NaNs alike.
+template <typename RealScalar>
+bool is_representable(const RealScalar& x) {
+  return numext::abs(x) <= NumTraits<RealScalar>::highest();
+}
+
+// makeHouseholder must reach the scaled path whenever the direct construction would square the input out of range.
+// The dispatch has to be decided from the input magnitudes, because a test on the overflowed sum does not survive
+// here.
+template <typename RealScalar>
+void householder_overflow(const Matrix<RealScalar, Dynamic, 1>& vector) {
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixType;
+  const Index size = vector.size();
+
+  VectorType essential(size - 1);
+  RealScalar tau;
+  RealScalar beta;
+  vector.makeHouseholder(essential, tau, beta);
+
+  VERIFY(is_representable(tau));
+  VERIFY(is_representable(beta));
+  VERIFY(is_representable(essential.cwiseAbs().maxCoeff()));
+
+  // tau and the essential vector are scale invariant and beta is homogeneous, so applying the reflector to a
+  // power-of-two rescaling of the input is exact and keeps the check itself inside the range.
+  int exponent = 0;
+  (void)std::frexp(vector.cwiseAbs().maxCoeff(), &exponent);
+  const RealScalar scale = std::ldexp(RealScalar(1), exponent);
+  const VectorType scaled = vector / scale;
+
+  VectorType v(size);
+  v[0] = RealScalar(1);
+  v.tail(size - 1) = essential;
+  const MatrixType reflector = MatrixType::Identity(size, size) - tau * v * v.transpose();
+
+  VERIFY_IS_APPROX(reflector.transpose() * reflector, MatrixType::Identity(size, size));
+  const VectorType reflected = reflector * scaled;
+  VERIFY_IS_APPROX(reflected[0], beta / scale);
+  VERIFY_IS_MUCH_SMALLER_THAN(reflected.tail(size - 1).cwiseAbs().maxCoeff(), RealScalar(1));
+}
+
+template <typename RealScalar>
+void householder_overflow_cases() {
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  const RealScalar huge = numext::sqrt(NumTraits<RealScalar>::highest()) * RealScalar(4);
+
+  // The head alone squares out of range.
+  VectorType head(2);
+  head << huge, huge / RealScalar(8);
+  householder_overflow<RealScalar>(head);
+
+  // A tail component alone squares out of range, with a zero head.
+  VectorType tail(3);
+  tail << RealScalar(0), huge * RealScalar(0.6), huge * RealScalar(0.8);
+  householder_overflow<RealScalar>(tail);
+
+  // Accumulated overflow: every square is representable, their sum is not.
+  householder_overflow<RealScalar>(VectorType::Constant(65, huge / RealScalar(4)));
+
+  // A QR factorization of a matrix at this scale has to compose from those reflectors.
+  const Index rows = 6, cols = 4;
+  Matrix<RealScalar, Dynamic, Dynamic> matrix(rows, cols);
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) matrix(i, j) = huge * RealScalar(internal::random<double>(-1.0, 1.0));
+  const HouseholderQR<Matrix<RealScalar, Dynamic, Dynamic> > qr(matrix);
+  const Matrix<RealScalar, Dynamic, Dynamic> q =
+      qr.householderQ() * Matrix<RealScalar, Dynamic, Dynamic>::Identity(rows, cols);
+  const Matrix<RealScalar, Dynamic, Dynamic> r =
+      qr.matrixQR().topRows(cols).template triangularView<Upper>().toDenseMatrix();
+  const Matrix<RealScalar, Dynamic, Dynamic> scaledMatrix = matrix / huge;
+  VERIFY_IS_APPROX((q * r) / huge, scaledMatrix);
+}
+
+EIGEN_DECLARE_TEST(householder_fastmath) {
+  CALL_SUBTEST_1(householder_overflow_cases<float>());
+  CALL_SUBTEST_2(householder_overflow_cases<double>());
+}
diff --git a/test/idrs.cpp b/test/idrs.cpp
new file mode 100644
index 0000000..91a356b
--- /dev/null
+++ b/test/idrs.cpp
@@ -0,0 +1,27 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
+// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T>
+void test_idrs_T() {
+  IDRS<SparseMatrix<T>, DiagonalPreconditioner<T> > idrs_colmajor_diag;
+  IDRS<SparseMatrix<T>, IncompleteLUT<T> > idrs_colmajor_ilut;
+
+  CALL_SUBTEST(check_sparse_square_solving(idrs_colmajor_diag));
+  CALL_SUBTEST(check_sparse_square_solving(idrs_colmajor_ilut));
+}
+
+EIGEN_DECLARE_TEST(idrs) {
+  CALL_SUBTEST_1(test_idrs_T<double>());
+  CALL_SUBTEST_2(test_idrs_T<std::complex<double> >());
+}
diff --git a/test/idrstabl.cpp b/test/idrstabl.cpp
new file mode 100644
index 0000000..58da6e4
--- /dev/null
+++ b/test/idrstabl.cpp
@@ -0,0 +1,29 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T>
+void test_idrstabl_T() {
+  IDRSTABL<SparseMatrix<T>, DiagonalPreconditioner<T> > idrstabl_colmajor_diag;
+  IDRSTABL<SparseMatrix<T>, IncompleteLUT<T> > idrstabl_colmajor_ilut;
+
+  idrstabl_colmajor_diag.setTolerance(NumTraits<T>::epsilon() * 4);
+  idrstabl_colmajor_ilut.setTolerance(NumTraits<T>::epsilon() * 4);
+
+  CALL_SUBTEST(check_sparse_square_solving(idrstabl_colmajor_diag));
+  CALL_SUBTEST(check_sparse_square_solving(idrstabl_colmajor_ilut));
+}
+
+EIGEN_DECLARE_TEST(idrstabl) {
+  CALL_SUBTEST_1((test_idrstabl_T<double>()));
+  CALL_SUBTEST_2((test_idrstabl_T<std::complex<double> >()));
+}
diff --git a/test/incomplete_LUT.cpp b/test/incomplete_LUT.cpp
index 7213ecc..315ecc1 100644
--- a/test/incomplete_LUT.cpp
+++ b/test/incomplete_LUT.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 #include <Eigen/IterativeLinearSolvers>
@@ -48,36 +49,151 @@
 
   Eigen::SparseMatrix<T> expectedMatL(5, 5);
   std::vector<Eigen::Triplet<T>> tripletsExL;
-  tripletsExL.emplace_back(0, 0, 1);
-  tripletsExL.emplace_back(1, 0, -0.25);
-  tripletsExL.emplace_back(1, 1, 1);
-  tripletsExL.emplace_back(2, 0, -0.25);
-  tripletsExL.emplace_back(2, 1, -0.0666667);
-  tripletsExL.emplace_back(2, 2, 1);
-  tripletsExL.emplace_back(3, 2, -0.25);
-  tripletsExL.emplace_back(3, 3, 1);
-  tripletsExL.emplace_back(4, 1, -0.266667);
-  tripletsExL.emplace_back(4, 3, -0.266667);
-  tripletsExL.emplace_back(4, 4, 1);
+  tripletsExL.emplace_back(0, 0, T(1));
+  tripletsExL.emplace_back(1, 0, T(-0.25));
+  tripletsExL.emplace_back(1, 1, T(1));
+  tripletsExL.emplace_back(2, 0, T(-0.25));
+  tripletsExL.emplace_back(2, 1, T(-0.0666667));
+  tripletsExL.emplace_back(2, 2, T(1));
+  tripletsExL.emplace_back(3, 2, T(-0.25));
+  tripletsExL.emplace_back(3, 3, T(1));
+  tripletsExL.emplace_back(4, 1, T(-0.266667));
+  tripletsExL.emplace_back(4, 3, T(-0.266667));
+  tripletsExL.emplace_back(4, 4, T(1));
   expectedMatL.setFromTriplets(tripletsExL.begin(), tripletsExL.end());
 
   Eigen::SparseMatrix<T> expectedMatU(5, 5);
   std::vector<Eigen::Triplet<T>> tripletsExU;
-  tripletsExU.emplace_back(0, 0, 4);
-  tripletsExU.emplace_back(0, 1, -1);
-  tripletsExU.emplace_back(1, 1, 3.75);
-  tripletsExU.emplace_back(1, 4, -1);
-  tripletsExU.emplace_back(2, 2, 4);
-  tripletsExU.emplace_back(2, 3, -1);
-  tripletsExU.emplace_back(3, 3, 3.75);
-  tripletsExU.emplace_back(3, 4, -1);
-  tripletsExU.emplace_back(4, 4, 3.46667);
+  tripletsExU.emplace_back(0, 0, T(4));
+  tripletsExU.emplace_back(0, 1, T(-1));
+  tripletsExU.emplace_back(1, 1, T(3.75));
+  tripletsExU.emplace_back(1, 4, T(-1));
+  tripletsExU.emplace_back(2, 2, T(4));
+  tripletsExU.emplace_back(2, 3, T(-1));
+  tripletsExU.emplace_back(3, 3, T(3.75));
+  tripletsExU.emplace_back(3, 4, T(-1));
+  tripletsExU.emplace_back(4, 4, T(3.46667));
   expectedMatU.setFromTriplets(tripletsExU.begin(), tripletsExU.end());
 
   VERIFY_IS_APPROX(expectedMatL, matL);
   VERIFY_IS_APPROX(expectedMatU, matU);
 }
 
+// https://gitlab.com/libeigen/eigen/-/issues/2626
+// IncompleteLUT must apply a static row permutation so that matrices whose
+// natural diagonal has zeros (but admit a full bipartite matching on the
+// sparsity pattern) can still be factorized. Without it, ILUT silently
+// produces a useless preconditioner.
+template <typename T>
+void test_zero_diagonal_2626() {
+  typedef Eigen::SparseMatrix<T> SparseMatrixT;
+  typedef Eigen::Matrix<T, Eigen::Dynamic, 1> Vector;
+
+  const int n = 50;
+  // 1D Laplacian: SPD, fully nonzero diagonal.
+  std::vector<Eigen::Triplet<T>> triplets;
+  for (int i = 0; i < n; ++i) {
+    triplets.emplace_back(i, i, T(2));
+    if (i > 0) triplets.emplace_back(i, i - 1, T(-1));
+    if (i + 1 < n) triplets.emplace_back(i, i + 1, T(-1));
+  }
+  SparseMatrixT base(n, n);
+  base.setFromTriplets(triplets.begin(), triplets.end());
+
+  // Cyclic-shift row permutation by 2: separates the natural diagonal from
+  // the tridiagonal nonzero band, so all diagonal entries of (Pshift * base)
+  // are zero. A valid row matching must find the inverse shift.
+  Eigen::PermutationMatrix<Eigen::Dynamic> Pshift(n);
+  for (int i = 0; i < n; ++i) Pshift.indices()(i) = (i + 2) % n;
+  SparseMatrixT A = Pshift * base;
+
+  // Verify the test setup: every diagonal is zero.
+  int nz_diag = 0;
+  for (int i = 0; i < n; ++i)
+    if (A.coeff(i, i) != T(0)) ++nz_diag;
+  VERIFY(nz_diag == 0);
+
+  // BiCGSTAB + IncompleteLUT must converge to a reasonable residual.
+  Vector b = Vector::Random(n);
+  Eigen::BiCGSTAB<SparseMatrixT, Eigen::IncompleteLUT<T>> solver;
+  solver.setTolerance(typename Eigen::NumTraits<T>::Real(16) * Eigen::NumTraits<T>::epsilon());
+  solver.compute(A);
+  VERIFY(solver.preconditioner().info() == Eigen::Success);
+  Vector x = solver.solve(b);
+  VERIFY(solver.info() == Eigen::Success);
+  Vector residual = b - A * x;
+  // Solver was set to tol = 16*eps; allow some slack for the residual check.
+  typename Eigen::NumTraits<T>::Real residual_bound =
+      typename Eigen::NumTraits<T>::Real(1024) * Eigen::NumTraits<T>::epsilon() * b.norm();
+  VERIFY(residual.norm() < residual_bound);
+}
+
+// A structurally singular matrix (empty row) cannot be made diagonal-nonzero
+// by any row permutation; the factorization must report NumericalIssue.
+// This covers the rownorm == 0 early-return path.
+template <typename T>
+void test_structurally_singular() {
+  typedef Eigen::SparseMatrix<T> SparseMatrixT;
+  std::vector<Eigen::Triplet<T>> triplets;
+  triplets.emplace_back(0, 0, T(2));
+  triplets.emplace_back(0, 1, T(1));
+  triplets.emplace_back(1, 0, T(1));
+  triplets.emplace_back(1, 1, T(2));
+  // row 2 is intentionally empty
+  triplets.emplace_back(3, 0, T(1));
+  triplets.emplace_back(3, 3, T(2));
+  SparseMatrixT A(4, 4);
+  A.setFromTriplets(triplets.begin(), triplets.end());
+
+  Eigen::IncompleteLUT<T> ilut;
+  ilut.compute(A);
+  VERIFY(ilut.info() == Eigen::NumericalIssue);
+}
+
+// A matrix where every row is structurally non-empty (so rownorm != 0) but
+// no full bipartite matching exists, forcing at least one pivot to be shifted.
+// Rows 0 and 1 only have entries in column 0, so columns 1 and 2 cannot both
+// be matched. This exercises the shifted-pivot path that flips info() to
+// NumericalIssue.
+template <typename T>
+void test_zero_pivot_numerical_issue() {
+  typedef Eigen::SparseMatrix<T> SparseMatrixT;
+  SparseMatrixT A(3, 3);
+  std::vector<Eigen::Triplet<T>> triplets;
+  triplets.emplace_back(0, 0, T(1));
+  triplets.emplace_back(1, 0, T(2));  // row 1 competes with row 0 for column 0
+  triplets.emplace_back(2, 2, T(3));
+  A.setFromTriplets(triplets.begin(), triplets.end());
+
+  Eigen::IncompleteLUT<T> ilut;
+  ilut.compute(A);
+  VERIFY(ilut.info() == Eigen::NumericalIssue);
+}
+
+// analyzePattern() must depend only on the stored sparsity pattern and not on
+// numerical values. Otherwise, the two-step API contract breaks: the same
+// analysis would no longer be reusable for any matrix sharing this stored
+// pattern. Repro: analyze a pattern with all-zero placeholder values, then
+// factorize a numerically nonzero matrix sharing that pattern.
+template <typename T>
+void test_pattern_value_separation() {
+  typedef Eigen::SparseMatrix<T> SparseMatrixT;
+  SparseMatrixT pattern(2, 2);
+  pattern.insert(0, 1) = T(0);
+  pattern.insert(1, 0) = T(0);
+  pattern.makeCompressed();
+
+  SparseMatrixT A(2, 2);
+  A.insert(0, 1) = T(1);
+  A.insert(1, 0) = T(1);
+  A.makeCompressed();
+
+  Eigen::IncompleteLUT<T> ilut;
+  ilut.analyzePattern(pattern);
+  ilut.factorize(A);
+  VERIFY(ilut.info() == Eigen::Success);
+}
+
 EIGEN_DECLARE_TEST(incomplete_LUT) {
   CALL_SUBTEST_1((test_incompleteLUT_T<double, int>()));
   CALL_SUBTEST_1((test_incompleteLUT_T<float, int>()));
@@ -86,4 +202,10 @@
 
   CALL_SUBTEST_4(test_extract_LU<double>());
   CALL_SUBTEST_4(test_extract_LU<float>());
+
+  CALL_SUBTEST_5(test_zero_diagonal_2626<double>());
+  CALL_SUBTEST_5(test_zero_diagonal_2626<float>());
+  CALL_SUBTEST_5(test_structurally_singular<double>());
+  CALL_SUBTEST_5(test_zero_pivot_numerical_issue<double>());
+  CALL_SUBTEST_5(test_pattern_value_separation<double>());
 }
diff --git a/test/incomplete_cholesky.cpp b/test/incomplete_cholesky.cpp
index fccc207..d6db9f2 100644
--- a/test/incomplete_cholesky.cpp
+++ b/test/incomplete_cholesky.cpp
@@ -8,6 +8,7 @@
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 // #define EIGEN_DONT_VECTORIZE
 // #define EIGEN_MAX_ALIGN_BYTES 0
+// SPDX-License-Identifier: MPL-2.0
 #include "sparse_solver.h"
 #include <Eigen/IterativeLinearSolvers>
 
diff --git a/test/indexed_view.cpp b/test/indexed_view.cpp
index 1801695..cb43d4c 100644
--- a/test/indexed_view.cpp
+++ b/test/indexed_view.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include <vector>
 
@@ -37,7 +38,7 @@
 #define MATCH(X, R) match(X, R, #X)
 
 template <typename T1, typename T2>
-std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_eq(const T1& a, const T2& b) {
+std::enable_if_t<std::is_same<T1, T2>::value, bool> is_same_eq(const T1& a, const T2& b) {
   return (a == b).all();
 }
 
@@ -53,13 +54,12 @@
 }
 
 template <typename T1, typename T2>
-std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_seq_type(const T1& a, const T2& b) {
+std::enable_if_t<std::is_same<T1, T2>::value, bool> is_same_seq_type(const T1& a, const T2& b) {
   return is_same_seq(a, b);
 }
 
 #define VERIFY_EQ_INT(A, B) VERIFY_IS_APPROX(int(A), int(B))
 
-// C++03 does not allow local or unnamed enums as index
 enum DummyEnum { XX = 0, YY = 1 };
 
 void check_indexed_view() {
@@ -134,11 +134,13 @@
   VERIFY(MATCH(b(all), "0  1  2  3  4  5  6  7  8  9"));
   VERIFY(MATCH(b(eii), "3  1  6  5"));
 
-  Array44i B;
+  // The fixed-size strides below are spelled for column-major storage, so pin B's order.
+  Array<int, 4, 4, ColMajor> B;
   B.setRandom();
   VERIFY((A(seqN(2, 5), 5)).ColsAtCompileTime == 1);
   VERIFY((A(seqN(2, 5), 5)).RowsAtCompileTime == Dynamic);
-  VERIFY_EQ_INT((A(seqN(2, 5), 5)).InnerStrideAtCompileTime, A.InnerStrideAtCompileTime);
+  // A single-column view is column major whatever A is, so it walks A's columns.
+  VERIFY_EQ_INT((A(seqN(2, 5), 5)).InnerStrideAtCompileTime, A.col(5).InnerStrideAtCompileTime);
   VERIFY_EQ_INT((A(seqN(2, 5), 5)).OuterStrideAtCompileTime, A.col(5).OuterStrideAtCompileTime);
 
   VERIFY_EQ_INT((A(5, seqN(2, 5))).InnerStrideAtCompileTime, A.row(5).InnerStrideAtCompileTime);
@@ -152,7 +154,8 @@
   VERIFY_EQ_INT((B(seqN(1, 2), seq(1, 3))).OuterStrideAtCompileTime, B.OuterStrideAtCompileTime);
   VERIFY_EQ_INT((A(seqN(2, 5, 2), seq(1, 3, 2))).InnerStrideAtCompileTime, Dynamic);
   VERIFY_EQ_INT((A(seqN(2, 5, 2), seq(1, 3, 2))).OuterStrideAtCompileTime, Dynamic);
-  VERIFY_EQ_INT((A(seqN(2, 5, fix<2>), seq(1, 3, fix<3>))).InnerStrideAtCompileTime, 2);
+  // The inner increment is the row increment when A is column major, the column one otherwise.
+  VERIFY_EQ_INT((A(seqN(2, 5, fix<2>), seq(1, 3, fix<3>))).InnerStrideAtCompileTime, A.IsRowMajor ? 3 : 2);
   VERIFY_EQ_INT((A(seqN(2, 5, fix<2>), seq(1, 3, fix<3>))).OuterStrideAtCompileTime, Dynamic);
   VERIFY_EQ_INT((B(seqN(1, 2, fix<2>), seq(1, 3, fix<3>))).InnerStrideAtCompileTime, 2);
   VERIFY_EQ_INT((B(seqN(1, 2, fix<2>), seq(1, 3, fix<3>))).OuterStrideAtCompileTime, 3 * 4);
@@ -221,7 +224,6 @@
   VERIFY_IS_APPROX(A(seq(n - 1 - 5, n - 1 - 2), seq(n - 1 - 5, n - 1 - 2)),
                    A(seq(last - 5, last - 2), seq(last - 5, last - 2)));
 
-  VERIFY_IS_APPROX(A.col(A.cols() - 1), A(all, last));
   VERIFY_IS_APPROX(A(A.rows() - 2, A.cols() / 2), A(last - 1, lastp1 / 2));
   VERIFY_IS_APPROX(a(a.size() - 2), a(last - 1));
   VERIFY_IS_APPROX(a(a.size() / 2), a((last + 1) / 2));
@@ -302,18 +304,12 @@
     VERIFY_IS_CWISE_EQUAL(r({idx[0], idx[1], idx[2]}), r(c_array));
     VERIFY_IS_CWISE_EQUAL(r({idx[0], idx[1], idx[2]}), r(std_vector));
     VERIFY_IS_CWISE_EQUAL(r({idx[0], idx[1], idx[2]}), r(eigen_matrix));
-    VERIFY_IS_CWISE_EQUAL(r(std_vector), r(c_array));
-    VERIFY_IS_CWISE_EQUAL(r(std_vector), r(eigen_matrix));
-    VERIFY_IS_CWISE_EQUAL(r(eigen_matrix), r(c_array));
 
     const ArrayXd& r_ref = r;
     // const access
     VERIFY_IS_CWISE_EQUAL(r_ref({idx[0], idx[1], idx[2]}), r_ref(c_array));
     VERIFY_IS_CWISE_EQUAL(r_ref({idx[0], idx[1], idx[2]}), r_ref(std_vector));
     VERIFY_IS_CWISE_EQUAL(r_ref({idx[0], idx[1], idx[2]}), r_ref(eigen_matrix));
-    VERIFY_IS_CWISE_EQUAL(r_ref(std_vector), r_ref(c_array));
-    VERIFY_IS_CWISE_EQUAL(r_ref(std_vector), r_ref(eigen_matrix));
-    VERIFY_IS_CWISE_EQUAL(r_ref(eigen_matrix), r_ref(c_array));
   }
 
   {
@@ -339,9 +335,6 @@
                           R(std_vector_rows, std_vector_cols));
     VERIFY_IS_CWISE_EQUAL(R({r_idx[0], r_idx[1], r_idx[2]}, {c_idx[0], c_idx[1], c_idx[2], c_idx[3]}),
                           R(eigen_matrix_rows, eigen_matrix_cols));
-    VERIFY_IS_CWISE_EQUAL(R(std_vector_rows, std_vector_cols), R(c_array_rows, c_array_cols));
-    VERIFY_IS_CWISE_EQUAL(R(std_vector_rows, std_vector_cols), R(eigen_matrix_rows, eigen_matrix_cols));
-    VERIFY_IS_CWISE_EQUAL(R(eigen_matrix_rows, eigen_matrix_cols), R(c_array_rows, c_array_cols));
 
     const ArrayXXd& R_ref = R;
     // const access
@@ -411,7 +404,6 @@
   // Check compilation of enums as index type:
   a(XX) = 1;
   A(XX, YY) = 1;
-  // Anonymous enums only work with C++11
   enum { X = 0, Y = 1 };
   a(X) = 1;
   A(X, Y) = 1;
@@ -530,7 +522,10 @@
 void check_tutorial_examples() {
   constexpr int kRows = 11;
   constexpr int kCols = 21;
-  Matrix<double, kRows, kCols> A = Matrix<double, kRows, kCols>::Random();
+  // Several slices below are checked against a Map built from A.data() with column-major
+  // offsets and strides, so pin A's storage order.
+  using MatrixA = Matrix<double, kRows, kCols, ColMajor>;
+  MatrixA A = MatrixA::Random();
   Vector<double, kRows> v = Vector<double, kRows>::Random();
 
   {
@@ -622,15 +617,16 @@
   // Even columns of A.
   {
     auto slice = A(all, seq(0, last, 2));
-    auto block =
-        Eigen::Map<Eigen::Matrix<double, kRows, Dynamic>, 0, OuterStride<2 * kRows>>(A.data(), kRows, (kCols + 1) / 2);
+    auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic, ColMajor>, 0, OuterStride<2 * kRows>>(
+        A.data(), kRows, (kCols + 1) / 2);
     VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
     VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
     VERIFY_IS_EQUAL(slice, block);
   }
   {
     auto slice = A(all, seq(fix<0>, last, fix<2>));
-    auto block = Eigen::Map<Eigen::Matrix<double, kRows, (kCols + 1) / 2>, 0, OuterStride<2 * kRows>>(A.data());
+    auto block =
+        Eigen::Map<Eigen::Matrix<double, kRows, (kCols + 1) / 2, ColMajor>, 0, OuterStride<2 * kRows>>(A.data());
     VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
     VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
     VERIFY_IS_EQUAL(slice, block);
@@ -640,7 +636,8 @@
   {
     Index n = 3;
     auto slice = A(seqN(1, n, 2), all);
-    auto block = Eigen::Map<Eigen::Matrix<double, Dynamic, kCols>, 0, Stride<kRows, 2>>(A.data() + 1, n, kCols);
+    auto block =
+        Eigen::Map<Eigen::Matrix<double, Dynamic, kCols, ColMajor>, 0, Stride<kRows, 2>>(A.data() + 1, n, kCols);
     VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
     VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
     VERIFY_IS_EQUAL(slice, block);
@@ -648,7 +645,7 @@
   {
     auto n = fix<3>;
     auto slice = A(seqN(fix<1>, n, fix<2>), all);
-    auto block = Eigen::Map<Eigen::Matrix<double, 3, kCols>, 0, Stride<kRows, 2>>(A.data() + 1);
+    auto block = Eigen::Map<Eigen::Matrix<double, 3, kCols, ColMajor>, 0, Stride<kRows, 2>>(A.data() + 1);
     VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
     VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
     VERIFY_IS_EQUAL(slice, block);
@@ -765,7 +762,7 @@
     Index n = 4;
     constexpr Index stride = 3;
     auto slice = A(all, lastN(n, stride));
-    auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic>, 0, OuterStride<stride * kRows>>(
+    auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic, ColMajor>, 0, OuterStride<stride * kRows>>(
         A.data() + (kCols - 1 - (n - 1) * stride) * kRows, A.rows(), n);
     VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
     VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
@@ -775,7 +772,7 @@
     constexpr auto n = fix<4>;
     constexpr auto stride = fix<3>;
     auto slice = A(all, lastN(n, stride));
-    auto block = Eigen::Map<Eigen::Matrix<double, kRows, n>, 0, OuterStride<stride * kRows>>(
+    auto block = Eigen::Map<Eigen::Matrix<double, kRows, n, ColMajor>, 0, OuterStride<stride * kRows>>(
         A.data() + (kCols - 1 - (n - 1) * stride) * kRows, A.rows(), n);
     VERIFY_IS_EQUAL(int(slice.RowsAtCompileTime), int(block.RowsAtCompileTime));
     VERIFY_IS_EQUAL(int(slice.ColsAtCompileTime), int(block.ColsAtCompileTime));
@@ -790,7 +787,7 @@
     VERIFY_IS_EQUAL(int(slice1.SizeAtCompileTime), 6);
     VERIFY_IS_EQUAL(int(slice2.SizeAtCompileTime), 6);
     auto slice3 = A(all, seq(fix<0>, last, fix<2>));
-    TEST_SET_BUT_UNUSED_VARIABLE(slice3)
+    TEST_SET_BUT_UNUSED_VARIABLE(slice3);
     VERIFY_IS_EQUAL(int(slice3.RowsAtCompileTime), kRows);
     VERIFY_IS_EQUAL(int(slice3.ColsAtCompileTime), (kCols + 1) / 2);
   }
@@ -798,7 +795,7 @@
   // Reverse order.
   {
     auto slice = A(all, seq(20, 10, fix<-2>));
-    auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic>, 0, OuterStride<-2 * kRows>>(
+    auto block = Eigen::Map<Eigen::Matrix<double, kRows, Dynamic, ColMajor>, 0, OuterStride<-2 * kRows>>(
         A.data() + 20 * kRows, A.rows(), (20 - 10 + 2) / 2);
     VERIFY_IS_EQUAL(slice, block);
   }
@@ -840,6 +837,119 @@
   }
 }
 
+// Regression test for bug #1943: IndexedView with temporary expression indices.
+void check_expression_indices() {
+  MatrixXd m(3, 4);
+  m << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12;
+
+  // Reshaped temporary as column index (was segfault before fix).
+  {
+    auto view = m(all, Array<int, 1, 1>{0}.reshaped());
+    VectorXd result = view;
+    VERIFY_IS_APPROX(result, m.col(0));
+  }
+
+  // Block expression as index.
+  {
+    ArrayXi idx(3);
+    idx << 0, 1, 2;
+    auto view = m(all, idx.head(2));
+    MatrixXd result = view;
+    VERIFY_IS_APPROX(result, m.leftCols(2));
+  }
+
+  // CwiseBinaryOp expression as index.
+  {
+    Array<int, 2, 1> base;
+    base << 0, 1;
+    auto view = m(all, base + 0);
+    MatrixXd result = view;
+    VERIFY_IS_APPROX(result, m.leftCols(2));
+  }
+
+  // Reverse expression as index.
+  {
+    Array<int, 3, 1> idx;
+    idx << 2, 1, 0;
+    auto view = m(all, idx.reverse());
+    MatrixXd result = view;
+    MatrixXd expected(3, 3);
+    expected << m.col(0), m.col(1), m.col(2);
+    VERIFY_IS_APPROX(result, expected);
+  }
+
+  // 1D vector indexed view (VectorIndexedViewSelector path).
+  {
+    VectorXd v(5);
+    v << 10, 20, 30, 40, 50;
+    ArrayXi idx(3);
+    idx << 4, 2, 0;
+    auto view = v(idx.reverse());
+    VectorXd result = view;
+    VectorXd expected(3);
+    expected << 10, 30, 50;
+    VERIFY_IS_APPROX(result, expected);
+  }
+}
+
+// Regression test for bug #3092: IndexedView nested in a comparison-based select expression.
+void check_indexed_view_select() {
+  ArrayXXd values(3, 4);
+  values << 0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11;
+
+  ArrayXi indices(5);
+  indices << 0, 1, 2, 1, 0;
+  ArrayXd condition = ArrayXd::Zero(5);
+
+  ArrayXd expected(5);
+  expected << 3, 4, 5, 4, 3;
+  ArrayXd result = (condition > 0.0).select(0.0, values(indices, 1));
+  VERIFY_IS_APPROX(result, expected);
+
+  result = (condition > 0.0).select(condition, values(indices, 1));
+  VERIFY_IS_APPROX(result, expected);
+
+  expected << 6, 7, 8, 7, 6;
+  result = (condition == 0.0).select(values(indices, 2), 0.0);
+  VERIFY_IS_APPROX(result, expected);
+
+  expected << 0, 1, 1, 1, 0;
+  result = (values(indices, 0) > 0.0).select(1.0, condition);
+  VERIFY_IS_APPROX(result, expected);
+}
+
+// A single-column IndexedView is column major and a single-row one is row major
+// whatever the nested expression is. Inheriting the nested RowMajorBit on top of
+// that contradicted it: the plain object of a Dynamic-by-1 row-major expression
+// is an invalid Matrix/Array type, so forming one failed to compile.
+void check_indexed_view_storage_order() {
+  Array<double, Dynamic, Dynamic, RowMajor> values(3, 4);
+  values << 0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11;
+
+  ArrayXi indices(5);
+  indices << 0, 1, 2, 1, 0;
+
+  using ColumnView = std::decay_t<decltype(values(indices, 1))>;
+  using RowView = std::decay_t<decltype(values(1, indices))>;
+  STATIC_CHECK((int(internal::traits<ColumnView>::Flags) & RowMajorBit) == 0);
+  STATIC_CHECK((int(internal::traits<RowView>::Flags) & RowMajorBit) == RowMajorBit);
+
+  ArrayXd condition = ArrayXd::Zero(5);
+  ArrayXd expected(5);
+  expected << 0, 1, 1, 1, 0;
+  ArrayXd result = (values(indices, 0) > 0.0).select(1.0, condition);
+  VERIFY_IS_APPROX(result, expected);
+
+  expected << 3, 4, 5, 4, 3;
+  result = (condition > 0.0).select(0.0, values(indices, 1));
+  VERIFY_IS_APPROX(result, expected);
+
+  Array<double, 1, Dynamic> row_expected(4);
+  row_expected << 1, 4, 7, 4;
+  Array<double, 1, Dynamic> row_result = (values(1, indices.head(4)) > 0.0).select(values(1, indices.head(4)), 0.0);
+  VERIFY_IS_APPROX(row_result, row_expected);
+}
+
 void check_aliasing() {
   Eigen::Vector<float, 5> z = {0.0f, 1.1f, 2.2f, 3.3f, 4.4f};
   std::vector<int> left_indices = {0, 1, 3, 4};
@@ -854,6 +964,9 @@
     CALL_SUBTEST_1(check_indexed_view());
   }
   CALL_SUBTEST_1(check_tutorial_examples());
+  CALL_SUBTEST_1(check_expression_indices());
+  CALL_SUBTEST_1(check_indexed_view_select());
+  CALL_SUBTEST_1(check_indexed_view_storage_order());
   CALL_SUBTEST_1(check_aliasing());
 
   // static checks of some internals:
diff --git a/test/initializer_list_construction.cpp b/test/initializer_list_construction.cpp
index 2c3f185..54b9d42 100644
--- a/test/initializer_list_construction.cpp
+++ b/test/initializer_list_construction.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #if defined(__GNUC__) && __GNUC__ >= 10
 // GCC 10+ has a bug for unsigned char that thinks we're writing past the
@@ -226,6 +227,23 @@
     }
     VERIFY_IS_EQUAL(m, m2);
   }
+  // Test braced-init-list assignment.
+  {
+    Matrix<Scalar, 4, 1> m;
+    m = {Scalar(11), Scalar(12), Scalar(13), Scalar(14)};
+    VERIFY_IS_EQUAL(m(0), Scalar(11));
+    VERIFY_IS_EQUAL(m(1), Scalar(12));
+    VERIFY_IS_EQUAL(m(2), Scalar(13));
+    VERIFY_IS_EQUAL(m(3), Scalar(14));
+  }
+  {
+    Matrix<Scalar, 1, 4> m;
+    m = {Scalar(11), Scalar(12), Scalar(13), Scalar(14)};
+    VERIFY_IS_EQUAL(m(0), Scalar(11));
+    VERIFY_IS_EQUAL(m(1), Scalar(12));
+    VERIFY_IS_EQUAL(m(2), Scalar(13));
+    VERIFY_IS_EQUAL(m(3), Scalar(14));
+  }
 }
 
 template <typename Scalar>
@@ -290,6 +308,23 @@
     }
     VERIFY_IS_APPROX(m, m2);
   }
+  // Test braced-init-list assignment.
+  {
+    Array<Scalar, 4, 1> a;
+    a = {Scalar(11), Scalar(12), Scalar(13), Scalar(14)};
+    VERIFY_IS_EQUAL(a(0), Scalar(11));
+    VERIFY_IS_EQUAL(a(1), Scalar(12));
+    VERIFY_IS_EQUAL(a(2), Scalar(13));
+    VERIFY_IS_EQUAL(a(3), Scalar(14));
+  }
+  {
+    Array<Scalar, 1, 4> a;
+    a = {Scalar(11), Scalar(12), Scalar(13), Scalar(14)};
+    VERIFY_IS_EQUAL(a(0), Scalar(11));
+    VERIFY_IS_EQUAL(a(1), Scalar(12));
+    VERIFY_IS_EQUAL(a(2), Scalar(13));
+    VERIFY_IS_EQUAL(a(3), Scalar(14));
+  }
 }
 
 template <typename Scalar>
diff --git a/test/inner_product_bounded.cpp b/test/inner_product_bounded.cpp
new file mode 100644
index 0000000..6a1a9be
--- /dev/null
+++ b/test/inner_product_bounded.cpp
@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/LU>
+
+using BoundedVector3d = Matrix<double, Dynamic, 1, ColMajor, 3, 1>;
+using BoundedMatrix3d = Matrix<double, Dynamic, Dynamic, ColMajor, 3, 3>;
+
+// Keep the solve result visible to GCC's bounds analysis after inlining dot().
+EIGEN_DONT_INLINE BoundedVector3d bounded_update(const BoundedMatrix3d& tangent, const BoundedVector3d& residual,
+                                                 const BoundedMatrix3d& transformation) {
+  const BoundedVector3d increment = tangent.fullPivLu().solve(residual);
+  if (increment.dot(residual) > 0) return transformation * increment;
+  return transformation * residual;
+}
+
+template <typename Scalar, int Capacity>
+void bounded_inner_products(const Scalar& imaginary_unit = Scalar(0)) {
+  using Bounded = Matrix<Scalar, Dynamic, 1, ColMajor, Capacity, 1>;
+  using DynamicVector = Matrix<Scalar, Dynamic, 1>;
+  using Op = internal::scalar_inner_product_op<Scalar, Scalar, true>;
+  using LeftEvaluator = internal::inner_product_evaluator<Op, Bounded, DynamicVector>;
+  using RightEvaluator = internal::inner_product_evaluator<Op, DynamicVector, Bounded>;
+  STATIC_CHECK(LeftEvaluator::MaxSizeAtCompileTime == Capacity);
+  STATIC_CHECK(RightEvaluator::MaxSizeAtCompileTime == Capacity);
+  for (Index size = 0; size <= Capacity; ++size) {
+    Bounded a(size), b(size);
+    Scalar dot = 0, product = 0;
+    for (Index i = 0; i < size; ++i) {
+      a(i) = Scalar(i % 5 - 2) + imaginary_unit * Scalar(i % 3 - 1);
+      b(i) = Scalar(i % 3 + 1) + imaginary_unit * Scalar(i % 2);
+      dot += numext::conj(a(i)) * b(i);
+      product += a(i) * b(i);
+    }
+    const DynamicVector dynamic = b;
+    VERIFY_IS_EQUAL(a.dot(b), dot);
+    VERIFY_IS_EQUAL(a.dot(dynamic), dot);
+    VERIFY_IS_EQUAL(dynamic.dot(a), numext::conj(dot));
+    VERIFY_IS_EQUAL(a.transpose().dot(b.transpose()), dot);
+    VERIFY_IS_EQUAL((a.transpose() * b).value(), product);
+  }
+}
+
+EIGEN_DECLARE_TEST(inner_product_bounded) {
+  for (Index size = 1; size <= 3; ++size) {
+    BoundedMatrix3d tangent = BoundedMatrix3d::Identity(size, size);
+    const BoundedMatrix3d transformation = BoundedMatrix3d::Identity(size, size);
+    BoundedVector3d residual(size);
+    for (Index i = 0; i < size; ++i) tangent(i, i) = residual(i) = double(i + 2);
+    VERIFY_IS_EQUAL(bounded_update(tangent, residual, transformation), BoundedVector3d::Ones(size));
+    tangent = -tangent;
+    VERIFY_IS_EQUAL(bounded_update(tangent, residual, transformation), residual);
+  }
+  bounded_inner_products<double, 3>();
+  bounded_inner_products<double, 5>();
+  bounded_inner_products<double, 7>();
+  bounded_inner_products<double, 17>();
+  constexpr int packet_size = internal::packet_traits<double>::size;
+  bounded_inner_products<double, 5 * packet_size + 1>();
+  bounded_inner_products<double, 6 * packet_size + 1>();
+  bounded_inner_products<double, 7 * packet_size + 1>();
+  bounded_inner_products<float, 3>();
+  bounded_inner_products<float, 7>();
+  bounded_inner_products<float, 15>();
+  bounded_inner_products<float, 33>();
+  bounded_inner_products<std::complex<double>, 9>(std::complex<double>(0, 1));
+}
diff --git a/test/inplace_decomposition.cpp b/test/inplace_decomposition.cpp
index a57596c..73b0c39 100644
--- a/test/inplace_decomposition.cpp
+++ b/test/inplace_decomposition.cpp
@@ -6,13 +6,16 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/LU>
 #include <Eigen/Cholesky>
 #include <Eigen/QR>
+#include <Eigen/Eigenvalues>
 
-// This file test inplace decomposition through Ref<>, as supported by Cholesky, LU, and QR decompositions.
+// This file test inplace decomposition through Ref<>, as supported by the Cholesky, LU, and QR decompositions, the
+// Hessenberg, tridiagonal, Schur and QZ reductions, and the dense eigensolvers.
 
 template <typename DecType, typename MatrixType>
 void inplace(bool square = false, bool SPD = false) {
@@ -70,9 +73,348 @@
   }
 }
 
+template <typename MatrixType>
+void inplace_fullpivlu_subspaces() {
+  using RealScalar = typename MatrixType::RealScalar;
+  MatrixType input(3, 3);
+  input << 1, 0, 1, 0, 1, 1, 0, 0, 0;
+  MatrixType working = input;
+  FullPivLU<Ref<MatrixType>> lu(working);
+  Ref<MatrixType> original(input);
+  const auto kernel = lu.kernel().eval();
+  const auto image = lu.image(original).eval();
+  STATIC_CHECK((int(decltype(kernel)::IsRowMajor) == int(MatrixType::IsRowMajor)));
+  STATIC_CHECK((int(decltype(image)::IsRowMajor) == int(MatrixType::IsRowMajor)));
+  VERIFY_IS_EQUAL(kernel.cols(), 1);
+  VERIFY_IS_EQUAL(image.cols(), 2);
+  const RealScalar tolerance = RealScalar(128 * input.rows()) * NumTraits<RealScalar>::epsilon();
+  VERIFY((input * kernel).norm() <= tolerance * input.norm() * kernel.norm());
+  VERIFY_IS_EQUAL(kernel.fullPivLu().rank(), kernel.cols());
+  VERIFY_IS_EQUAL(image.fullPivLu().rank(), image.cols());
+  VERIFY((image * image.fullPivLu().solve(input) - input).norm() <= tolerance * input.norm());
+}
+
+template <typename MatrixType>
+MatrixType random_selfadjoint(Index n) {
+  MatrixType a = MatrixType::Random(n, n);
+  return a + a.adjoint();
+}
+
+template <typename MatrixType, typename BasisType, typename FormType>
+void verify_inplace_similarity(const MatrixType& input, const BasisType& basis, const FormType& form) {
+  using RealScalar = typename MatrixType::RealScalar;
+  const RealScalar tolerance = RealScalar(128 * input.rows()) * NumTraits<RealScalar>::epsilon();
+  VERIFY((input - basis * form * basis.adjoint()).norm() <= tolerance * input.norm());
+  VERIFY(basis.isUnitary(tolerance));
+}
+
+template <typename MatrixType, typename QZType>
+void verify_inplace_qz(const MatrixType& a, const MatrixType& b, const QZType& qz) {
+  using RealScalar = typename MatrixType::RealScalar;
+  const RealScalar tolerance = RealScalar(128 * a.rows()) * NumTraits<RealScalar>::epsilon();
+  VERIFY_IS_EQUAL(qz.info(), Success);
+  VERIFY((a - qz.matrixQ() * qz.matrixS() * qz.matrixZ()).norm() <= tolerance * a.norm());
+  VERIFY((b - qz.matrixQ() * qz.matrixT() * qz.matrixZ()).norm() <= tolerance * b.norm());
+  VERIFY(qz.matrixQ().isUnitary(tolerance));
+  VERIFY(qz.matrixZ().isUnitary(tolerance));
+}
+
+template <typename MatrixType>
+void inplace_reductions(Index size) {
+  using Scalar = typename MatrixType::Scalar;
+  {
+    MatrixType A = MatrixType::Random(size, size), A0 = A;
+    HessenbergDecomposition<Ref<MatrixType>> hess(A);
+    VERIFY(internal::is_same_dense(hess.packedMatrix(), A));
+    MatrixType Q = hess.matrixQ(), H = hess.matrixH();
+    verify_inplace_similarity(A0, Q, H);
+    MatrixType twiceH = Scalar(2) * hess.matrixH();
+    VERIFY_IS_EQUAL(twiceH, Scalar(2) * H);
+
+    // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): Snapshot verifies compute() preserves its input.
+    MatrixType A1 = MatrixType::Random(size, size), A1c = A1;
+    hess.compute(A1);
+    VERIFY_IS_EQUAL(A1, A1c);
+    VERIFY(internal::is_same_dense(hess.packedMatrix(), A));
+    Q = hess.matrixQ();
+    H = hess.matrixH();
+    verify_inplace_similarity(A1, Q, H);
+  }
+  {
+    MatrixType A = random_selfadjoint<MatrixType>(size), A0 = A;
+    Tridiagonalization<Ref<MatrixType>> tri(A);
+    VERIFY(internal::is_same_dense(tri.packedMatrix(), A));
+    MatrixType Q = tri.matrixQ(), T = tri.matrixT().eval().template cast<Scalar>();
+    verify_inplace_similarity(A0, Q, T);
+  }
+}
+
+template <typename MatrixType, template <typename> class SchurType>
+void inplace_schur(Index size) {
+  using RealScalar = typename MatrixType::RealScalar;
+  const RealScalar tolerance = RealScalar(128 * size) * NumTraits<RealScalar>::epsilon();
+  MatrixType A = MatrixType::Random(size, size), A0 = A;
+  SchurType<Ref<MatrixType>> schur(A);
+  VERIFY_IS_EQUAL(schur.info(), Success);
+  VERIFY(internal::is_same_dense(schur.matrixT(), A));
+  verify_inplace_similarity(A0, schur.matrixU(), schur.matrixT());
+
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): Snapshot verifies compute() preserves its input.
+  MatrixType A1 = MatrixType::Random(size, size), A1c = A1;
+  schur.compute(A1);
+  VERIFY_IS_EQUAL(schur.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  VERIFY(internal::is_same_dense(schur.matrixT(), A));
+  verify_inplace_similarity(A1, schur.matrixU(), schur.matrixT());
+  MatrixType T = schur.matrixT();
+  schur.compute(A1, false);
+  VERIFY_IS_EQUAL(schur.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  VERIFY((schur.matrixT() - T).norm() <= tolerance * A1.norm());
+}
+
+template <typename MatrixType>
+void inplace_selfadjoint_eigensolver(Index size) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  const RealScalar tolerance = RealScalar(128 * size) * NumTraits<RealScalar>::epsilon();
+  MatrixType A = random_selfadjoint<MatrixType>(size), A0 = A;
+  A.template triangularView<StrictlyUpper>().setConstant(Scalar(std::numeric_limits<RealScalar>::quiet_NaN()));
+  SelfAdjointEigenSolver<Ref<MatrixType>> es(A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  VERIFY(internal::is_same_dense(es.eigenvectors(), A));
+  VERIFY((A0 * A - A * es.eigenvalues().asDiagonal()).norm() <= tolerance * A0.norm());
+  VERIFY(A.isUnitary(tolerance));
+
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): Snapshot verifies compute() preserves its input.
+  MatrixType A1 = random_selfadjoint<MatrixType>(size), A1c = A1;
+  es.compute(A1, EigenvaluesOnly);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  const auto values = es.eigenvalues().eval();
+  es.compute(A1);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  VERIFY(internal::is_same_dense(es.eigenvectors(), A));
+  VERIFY((es.eigenvalues() - values).norm() <= tolerance * A1.norm());
+  VERIFY((A1 * A - A * es.eigenvalues().asDiagonal()).norm() <= tolerance * A1.norm());
+  VERIFY(A.isUnitary(tolerance));
+
+  if (MatrixType::RowsAtCompileTime == Dynamic) {
+    MatrixType big = MatrixType::Random(size + 3, size + 2);
+    Ref<MatrixType> B = big.block(2, 1, size, size);
+    B = random_selfadjoint<MatrixType>(size);
+    MatrixType Bin = B;
+    SelfAdjointEigenSolver<Ref<MatrixType>> esb(B);
+    VERIFY_IS_EQUAL(esb.info(), Success);
+    VERIFY(internal::is_same_dense(esb.eigenvectors(), B));
+    VERIFY((Bin * B - B * esb.eigenvalues().asDiagonal()).norm() <= tolerance * Bin.norm());
+    VERIFY(B.isUnitary(tolerance));
+  }
+
+  MatrixType Ag = random_selfadjoint<MatrixType>(size);
+  MatrixType Bg = MatrixType::Random(size, size);
+  Bg = Bg * Bg.adjoint() + RealScalar(size) * MatrixType::Identity(size, size);
+  for (int type : {int(Ax_lBx), int(ABx_lx), int(BAx_lx)}) {
+    MatrixType A2 = Ag, B2 = Bg;
+    GeneralizedSelfAdjointEigenSolver<Ref<MatrixType>> ges(A2, B2, ComputeEigenvectors | type);
+    VERIFY_IS_EQUAL(ges.info(), Success);
+    VERIFY(internal::is_same_dense(ges.eigenvectors(), A2));
+    const MatrixType& V = ges.eigenvectors();
+    MatrixType VD = V * ges.eigenvalues().asDiagonal();
+    if (type == Ax_lBx) {
+      VERIFY((Ag * V - Bg * VD).norm() <= tolerance * (Ag.norm() * V.norm() + Bg.norm() * VD.norm()));
+    } else if (type == ABx_lx) {
+      VERIFY((Ag * (Bg * V) - VD).norm() <= tolerance * (Ag.norm() * Bg.norm() * V.norm() + VD.norm()));
+    } else {
+      VERIFY((Bg * (Ag * V) - VD).norm() <= tolerance * (Ag.norm() * Bg.norm() * V.norm() + VD.norm()));
+    }
+    MatrixType metric;
+    if (type == BAx_lx) {
+      metric = V.adjoint() * Bg.llt().solve(V);
+    } else {
+      metric = V.adjoint() * Bg * V;
+    }
+    VERIFY((metric - MatrixType::Identity(size, size)).norm() <= tolerance * RealScalar(size));
+
+    MatrixType A3 = Ag, B3 = Bg;
+    GeneralizedSelfAdjointEigenSolver<Ref<MatrixType>> gesv(A3, B3, EigenvaluesOnly | type);
+    VERIFY_IS_EQUAL(gesv.info(), Success);
+    VERIFY((gesv.eigenvalues() - ges.eigenvalues()).norm() <= tolerance * ges.eigenvalues().norm());
+  }
+}
+
+template <typename MatrixType>
+void inplace_special_values(Index size) {
+  using RealScalar = typename MatrixType::RealScalar;
+  for (Index kind = 0; kind <= 2 * size; ++kind) {
+    MatrixType A0 = MatrixType::Zero(size, size);
+    if (kind > 0) {
+      const Index index = (kind - 1) % size;
+      A0(index, index) =
+          kind <= size ? std::numeric_limits<RealScalar>::quiet_NaN() : std::numeric_limits<RealScalar>::infinity();
+    }
+    MatrixType A = A0;
+    RealSchur<Ref<MatrixType>> schur(A);
+    RealSchur<MatrixType> schur0(A0);
+    VERIFY_IS_EQUAL(schur.info(), schur0.info());
+    VERIFY_IS_EQUAL(schur.info(), kind == 0 ? Success : NoConvergence);
+    if (schur.info() == Success && kind == 0) verify_inplace_similarity(A0, schur.matrixU(), schur.matrixT());
+
+    MatrixType B = A0;
+    SelfAdjointEigenSolver<Ref<MatrixType>> saes(B);
+    SelfAdjointEigenSolver<MatrixType> saes0(A0);
+    VERIFY_IS_EQUAL(saes.info(), saes0.info());
+    VERIFY_IS_EQUAL(saes.info(), kind == 0 ? Success : NoConvergence);
+    if (saes.info() == Success && kind == 0) {
+      VERIFY_IS_EQUAL(saes.eigenvalues(), saes0.eigenvalues());
+      VERIFY(saes.eigenvectors().isUnitary(RealScalar(128 * size) * NumTraits<RealScalar>::epsilon()));
+    }
+
+    MatrixType C = A0;
+    EigenSolver<Ref<MatrixType>> es(C);
+    EigenSolver<MatrixType> es0(A0);
+    VERIFY_IS_EQUAL(es.info(), es0.info());
+    VERIFY_IS_EQUAL(es.info(), kind == 0 ? Success : NumericalIssue);
+    if (es.info() == Success && kind == 0) {
+      VERIFY_IS_EQUAL(es.eigenvalues(), es0.eigenvalues());
+      VERIFY((es.eigenvectors().colwise().norm().array() > RealScalar(0)).all());
+    }
+  }
+}
+
+template <typename MatrixType, template <typename> class SolverType>
+void inplace_eigensolver(Index size) {
+  using RealScalar = typename MatrixType::RealScalar;
+  using ComplexScalar = std::complex<RealScalar>;
+  using ComplexMatrix = typename EigenSolver<MatrixType>::EigenvectorsType;
+  const RealScalar tolerance = RealScalar(128 * size) * NumTraits<RealScalar>::epsilon();
+  MatrixType A = MatrixType::Random(size, size), A0 = A;
+  SolverType<Ref<MatrixType>> es(A);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  ComplexMatrix V = es.eigenvectors();
+  VERIFY((A0.template cast<ComplexScalar>() * V - V * es.eigenvalues().asDiagonal()).norm() <=
+         tolerance * A0.norm() * V.norm());
+  VERIFY((V.colwise().norm().array() - RealScalar(1)).abs().maxCoeff() <= tolerance);
+
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): Snapshot verifies compute() preserves its input.
+  MatrixType A1 = MatrixType::Random(size, size), A1c = A1;
+  es.compute(A1);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  V = es.eigenvectors();
+  VERIFY((A1.template cast<ComplexScalar>() * V - V * es.eigenvalues().asDiagonal()).norm() <=
+         tolerance * A1.norm() * V.norm());
+  const auto values = es.eigenvalues().eval();
+  es.compute(A1, false);
+  VERIFY_IS_EQUAL(es.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  VERIFY((es.eigenvalues() - values).norm() <= tolerance * A1.norm());
+}
+
+template <typename MatrixType, template <typename> class QZType>
+void inplace_qz(Index size) {
+  MatrixType A = MatrixType::Random(size, size), B = MatrixType::Random(size, size), A0 = A, Bin = B;
+  QZType<Ref<MatrixType>> qz(A, B);
+  VERIFY(internal::is_same_dense(qz.matrixS(), A));
+  VERIFY(internal::is_same_dense(qz.matrixT(), B));
+  verify_inplace_qz(A0, Bin, qz);
+
+  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): Snapshots verify compute() preserves both inputs.
+  MatrixType A1 = MatrixType::Random(size, size), B1 = MatrixType::Random(size, size), A1c = A1, B1c = B1;
+  qz.compute(A1, B1);
+  VERIFY_IS_EQUAL(A1, A1c);
+  VERIFY_IS_EQUAL(B1, B1c);
+  VERIFY(internal::is_same_dense(qz.matrixS(), A));
+  VERIFY(internal::is_same_dense(qz.matrixT(), B));
+  verify_inplace_qz(A1, B1, qz);
+  const MatrixType S = qz.matrixS(), T = qz.matrixT();
+  qz.compute(A1, B1, false);
+  VERIFY_IS_EQUAL(qz.info(), Success);
+  VERIFY_IS_EQUAL(A1, A1c);
+  VERIFY_IS_EQUAL(B1, B1c);
+  using RealScalar = typename MatrixType::RealScalar;
+  const RealScalar tolerance = RealScalar(128 * size) * NumTraits<RealScalar>::epsilon();
+  VERIFY((qz.matrixS() - S).norm() <= tolerance * A1.norm());
+  VERIFY((qz.matrixT() - T).norm() <= tolerance * B1.norm());
+}
+
+template <typename MatrixType>
+void inplace_generalized_eigensolver(Index size) {
+  using RealScalar = typename MatrixType::RealScalar;
+  using ComplexScalar = std::complex<RealScalar>;
+  using EigenvectorsType = typename GeneralizedEigenSolver<MatrixType>::EigenvectorsType;
+  MatrixType A = MatrixType::Random(size, size), B = MatrixType::Random(size, size), A0 = A, Binput = B;
+  GeneralizedEigenSolver<Ref<MatrixType>> ges(A, B);
+  VERIFY_IS_EQUAL(ges.info(), Success);
+  EigenvectorsType V = ges.eigenvectors();
+  const EigenvectorsType lhs =
+      A0.template cast<ComplexScalar>() * V * ges.betas().template cast<ComplexScalar>().asDiagonal();
+  const EigenvectorsType rhs = Binput.template cast<ComplexScalar>() * V * ges.alphas().asDiagonal();
+  const RealScalar tolerance = RealScalar(128 * size) * NumTraits<RealScalar>::epsilon();
+  VERIFY((lhs - rhs).norm() <= tolerance * (lhs.norm() + rhs.norm()));
+  VERIFY((V.colwise().norm().array() - RealScalar(1)).abs().maxCoeff() <= tolerance);
+}
+
+template <typename Scalar, template <typename> class QZType, int Options>
+void inplace_qz_inner_stride() {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Options>;
+  using StridedRef = Ref<MatrixType, 0, Stride<Dynamic, Dynamic>>;
+  for (Index inner : {Index(1), Index(2)}) {
+    MatrixType storageA = MatrixType::Random(8, 5), storageB = MatrixType::Random(8, 5);
+    const Stride<Dynamic, Dynamic> stride(8, inner);
+    Map<MatrixType, 0, Stride<Dynamic, Dynamic>> a(storageA.data(), 4, 4, stride), b(storageB.data(), 4, 4, stride);
+    const MatrixType A0 = a, Binput = b;
+    const MatrixType savedA = storageA, savedB = storageB;
+    StridedRef ar(a), br(b);
+    QZType<StridedRef> qz(ar, br);
+    VERIFY(internal::is_same_dense(qz.matrixS(), a));
+    VERIFY(internal::is_same_dense(qz.matrixT(), b));
+    verify_inplace_qz(A0, Binput, qz);
+    // The Map's strides determine its footprint in either storage order.
+    for (Index offset = 0; offset < storageA.size(); ++offset) {
+      const Index outer = offset / stride.outer();
+      const Index innerOffset = offset % stride.outer();
+      if (outer < 4 && innerOffset % inner == 0 && innerOffset / inner < 4) continue;
+      VERIFY_IS_EQUAL(storageA.data()[offset], savedA.data()[offset]);
+      VERIFY_IS_EQUAL(storageB.data()[offset], savedB.data()[offset]);
+    }
+  }
+}
+
+struct InplaceLowerOnly {
+  double operator()(Index row, Index col) const {
+    VERIFY(row >= col);
+    return row == col ? 4.0 : 1.0;
+  }
+};
+
+void inplace_plain_lower_triangle() {
+  auto input = MatrixXd::NullaryExpr(3, 3, InplaceLowerOnly());
+  SelfAdjointEigenSolver<MatrixXd> mutableSolver(input);
+  const auto constInput = input;
+  SelfAdjointEigenSolver<MatrixXd> constSolver(constInput);
+  VERIFY_IS_EQUAL(mutableSolver.info(), Success);
+  VERIFY_IS_EQUAL(mutableSolver.eigenvalues(), constSolver.eigenvalues());
+}
+
 EIGEN_DECLARE_TEST(inplace_decomposition) {
+  CALL_SUBTEST_4((inplace_fullpivlu_subspaces<Matrix<double, Dynamic, Dynamic, ColMajor>>()));
+  CALL_SUBTEST_4((inplace_fullpivlu_subspaces<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_4((inplace_fullpivlu_subspaces<Matrix<double, 3, 3, RowMajor | DontAlign>>()));
+  CALL_SUBTEST_10((inplace_special_values<MatrixXd>(2)));
+  CALL_SUBTEST_10((inplace_special_values<MatrixXd>(1)));
+  CALL_SUBTEST_11(inplace_plain_lower_triangle());
+  CALL_SUBTEST_12((inplace_eigensolver<MatrixXd, EigenSolver>(128)));
+  CALL_SUBTEST_12((inplace_eigensolver<MatrixXd, EigenSolver>(129)));
+  CALL_SUBTEST_14((inplace_qz_inner_stride<double, RealQZ, ColMajor>()));
+  CALL_SUBTEST_14((inplace_qz_inner_stride<double, RealQZ, RowMajor>()));
+  CALL_SUBTEST_14((inplace_qz_inner_stride<std::complex<double>, ComplexQZ, ColMajor>()));
+  CALL_SUBTEST_14((inplace_qz_inner_stride<std::complex<double>, ComplexQZ, RowMajor>()));
   EIGEN_UNUSED typedef Matrix<double, 4, 3> Matrix43d;
   for (int i = 0; i < g_repeat; i++) {
+    EIGEN_UNUSED const Index size = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE / 4);
+
     CALL_SUBTEST_1((inplace<LLT<Ref<MatrixXd> >, MatrixXd>(true, true)));
     CALL_SUBTEST_1((inplace<LLT<Ref<Matrix4d> >, Matrix4d>(true, true)));
 
@@ -96,5 +438,50 @@
 
     CALL_SUBTEST_8((inplace<CompleteOrthogonalDecomposition<Ref<MatrixXd> >, MatrixXd>(false, false)));
     CALL_SUBTEST_8((inplace<CompleteOrthogonalDecomposition<Ref<Matrix43d> >, Matrix43d>(false, false)));
+
+    CALL_SUBTEST_2((inplace<BunchKaufman<Ref<MatrixXd>>, MatrixXd>(true, true)));
+    CALL_SUBTEST_2((inplace<BunchKaufman<Ref<Matrix4d>>, Matrix4d>(true, true)));
+
+    CALL_SUBTEST_9((inplace_reductions<MatrixXd>(size)));
+    CALL_SUBTEST_9((inplace_reductions<MatrixXcd>(size)));
+    CALL_SUBTEST_9((inplace_reductions<MatrixXd>(1)));
+    CALL_SUBTEST_9((inplace_reductions<Matrix4f>(4)));
+
+    CALL_SUBTEST_10((inplace_schur<MatrixXd, RealSchur>(size)));
+    CALL_SUBTEST_10((inplace_schur<MatrixXd, RealSchur>(1)));
+    CALL_SUBTEST_10((inplace_schur<Matrix4f, RealSchur>(4)));
+    CALL_SUBTEST_10((inplace_schur<MatrixXcd, ComplexSchur>(size)));
+    CALL_SUBTEST_10((inplace_schur<MatrixXcd, ComplexSchur>(1)));
+    CALL_SUBTEST_10((inplace_schur<Matrix4cf, ComplexSchur>(4)));
+    CALL_SUBTEST_10((inplace_special_values<MatrixXd>(size)));
+    CALL_SUBTEST_10((inplace_special_values<Matrix4f>(4)));
+
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<MatrixXd>(size)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<MatrixXcd>(size)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<MatrixXd>(1)));
+    // Fixed sizes whose columns are packet-aligned take the vectorized rotation kernel.
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<Matrix2d>(2)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<Matrix3d>(3)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<Matrix4f>(4)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<Matrix4d>(4)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<Matrix<float, Dynamic, Dynamic, RowMajor>>(size)));
+    // Large enough for the blocked tridiagonalization, on strided and row-major storage.
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<MatrixXd>(100)));
+    CALL_SUBTEST_11((inplace_selfadjoint_eigensolver<Matrix<float, Dynamic, Dynamic, RowMajor>>(100)));
+
+    CALL_SUBTEST_12((inplace_eigensolver<MatrixXd, EigenSolver>(size)));
+    CALL_SUBTEST_12((inplace_eigensolver<MatrixXd, EigenSolver>(1)));
+    CALL_SUBTEST_12((inplace_eigensolver<Matrix4f, EigenSolver>(4)));
+    CALL_SUBTEST_12((inplace_eigensolver<MatrixXcd, ComplexEigenSolver>(size)));
+    CALL_SUBTEST_12((inplace_eigensolver<MatrixXcd, ComplexEigenSolver>(1)));
+    CALL_SUBTEST_12((inplace_eigensolver<Matrix4cf, ComplexEigenSolver>(4)));
+
+    CALL_SUBTEST_13((inplace_qz<MatrixXd, RealQZ>(size)));
+    CALL_SUBTEST_13((inplace_generalized_eigensolver<MatrixXd>(size)));
+    CALL_SUBTEST_13((inplace_generalized_eigensolver<Matrix4d>(4)));
+    CALL_SUBTEST_13((inplace_qz<MatrixXd, RealQZ>(1)));
+    CALL_SUBTEST_13((inplace_qz<Matrix4d, RealQZ>(4)));
+    CALL_SUBTEST_13((inplace_qz<MatrixXcd, ComplexQZ>(size)));
+    CALL_SUBTEST_13((inplace_qz<MatrixXcd, ComplexQZ>(1)));
   }
 }
diff --git a/test/inplace_decomposition_lapacke.cpp b/test/inplace_decomposition_lapacke.cpp
new file mode 100644
index 0000000..863b2e9
--- /dev/null
+++ b/test/inplace_decomposition_lapacke.cpp
@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_LAPACKE
+#include "main.h"
+#include <Eigen/Eigenvalues>
+
+namespace {
+int real_schur_calls = 0;
+int complex_schur_calls = 0;
+int selfadjoint_calls = 0;
+}  // namespace
+
+// Dispatch probes return a failure code before Eigen can consume any unwritten output.
+extern "C" lapack_int LAPACKE_dgees(int, char, char, LAPACK_D_SELECT2, lapack_int, double*, lapack_int, lapack_int*,
+                                    double*, double*, double*, lapack_int) {
+  ++real_schur_calls;
+  return 1;
+}
+extern "C" lapack_int LAPACKE_zgees(int, char, char, LAPACK_Z_SELECT1, lapack_int, lapack_complex_double*, lapack_int,
+                                    lapack_int*, lapack_complex_double*, lapack_complex_double*, lapack_int) {
+  ++complex_schur_calls;
+  return 1;
+}
+extern "C" lapack_int LAPACKE_dsyev(int, char, char, lapack_int, double*, lapack_int, double*) {
+  ++selfadjoint_calls;
+  return 1;
+}
+
+template <int Options>
+void inplace_plain_lapacke_dispatch() {
+  using RealMatrix = Matrix<double, Dynamic, Dynamic, Options>;
+  using ComplexMatrix = Matrix<std::complex<double>, Dynamic, Dynamic, Options>;
+  RealMatrix real = RealMatrix::Identity(3, 3);
+  ComplexMatrix complex = ComplexMatrix::Identity(3, 3);
+  const RealMatrix constReal = RealMatrix::Identity(3, 3);
+  const ComplexMatrix constComplex = ComplexMatrix::Identity(3, 3);
+  const int realBefore = real_schur_calls, complexBefore = complex_schur_calls, selfadjointBefore = selfadjoint_calls;
+  RealSchur<RealMatrix> mutableRealSchur(real), constRealSchur(constReal);
+  ComplexSchur<ComplexMatrix> mutableComplexSchur(complex), constComplexSchur(constComplex);
+  SelfAdjointEigenSolver<RealMatrix> mutableSelfAdjoint(real), constSelfAdjoint(constReal);
+  VERIFY_IS_EQUAL(real_schur_calls, realBefore + 2);
+  VERIFY_IS_EQUAL(complex_schur_calls, complexBefore + 2);
+  VERIFY_IS_EQUAL(selfadjoint_calls, selfadjointBefore + 2);
+  VERIFY_IS_EQUAL(mutableRealSchur.info(), NoConvergence);
+  VERIFY_IS_EQUAL(constRealSchur.info(), NoConvergence);
+  VERIFY_IS_EQUAL(mutableComplexSchur.info(), NoConvergence);
+  VERIFY_IS_EQUAL(constComplexSchur.info(), NoConvergence);
+  VERIFY_IS_EQUAL(mutableSelfAdjoint.info(), NoConvergence);
+  VERIFY_IS_EQUAL(constSelfAdjoint.info(), NoConvergence);
+  VERIFY_IS_EQUAL(real, constReal);
+  VERIFY_IS_EQUAL(complex, constComplex);
+}
+
+EIGEN_DECLARE_TEST(inplace_decomposition_lapacke) {
+  inplace_plain_lapacke_dispatch<ColMajor>();
+  inplace_plain_lapacke_dispatch<RowMajor>();
+}
diff --git a/test/integer_types.cpp b/test/integer_types.cpp
index 142854c..b65d7a8 100644
--- a/test/integer_types.cpp
+++ b/test/integer_types.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -17,6 +18,7 @@
 template <typename MatrixType>
 void signed_integer_type_tests(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
+  constexpr Scalar kMax = (Scalar(1) << ((8 * sizeof(Scalar) - 2) / 2)) - 1;
 
   enum { is_signed = (Scalar(-1) > Scalar(0)) ? 0 : 1 };
   VERIFY(is_signed == 1);
@@ -24,26 +26,12 @@
   Index rows = m.rows();
   Index cols = m.cols();
 
-  MatrixType m1(rows, cols), m2 = MatrixType::Random(rows, cols), mzero = MatrixType::Zero(rows, cols);
-
-  {
-    int guard = 0;
-    do {
-      m1 = MatrixType::Random(rows, cols);
-    } while ((m1 == mzero || m1 == m2) && (++guard) < 100);
-    VERIFY(guard < 100);
-  }
+  MatrixType m1 = RandomMatrix<MatrixType>(rows, cols, Scalar(0), kMax);
+  MatrixType m2 = RandomMatrix<MatrixType>(rows, cols, Scalar(0), kMax);
 
   // check linear structure
 
-  Scalar s1;
-  {
-    int guard = 0;
-    do {
-      s1 = internal::random<Scalar>();
-    } while (s1 == 0 && (++guard) < 100);
-    VERIFY(guard < 100);
-  }
+  Scalar s1 = internal::random<Scalar>(1, kMax);
 
   VERIFY_IS_EQUAL(-(-m1), m1);
   VERIFY_IS_EQUAL(-m2 + m1 + m2, m1);
@@ -53,46 +41,36 @@
 template <typename MatrixType>
 void integer_type_tests(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
+  constexpr Scalar kMax = (Scalar(1) << ((8 * sizeof(Scalar) - 2) / 2)) - 1;
 
   VERIFY(NumTraits<Scalar>::IsInteger);
   enum { is_signed = (Scalar(-1) > Scalar(0)) ? 0 : 1 };
   VERIFY(int(NumTraits<Scalar>::IsSigned) == is_signed);
 
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
 
   Index rows = m.rows();
   Index cols = m.cols();
 
-  // this test relies a lot on Random.h, and there's not much more that we can do
-  // to test it, hence I consider that we will have tested Random.h
-  MatrixType m1(rows, cols), m2 = MatrixType::Random(rows, cols), m3(rows, cols), mzero = MatrixType::Zero(rows, cols);
+  MatrixType m1 = RandomMatrix<MatrixType>(rows, cols, Scalar(0), kMax);
+  MatrixType m2 = RandomMatrix<MatrixType>(rows, cols, Scalar(0), kMax);
+  MatrixType m3 = RandomMatrix<MatrixType>(rows, cols, Scalar(0), kMax);
+  SquareMatrixType square = RandomMatrix<SquareMatrixType>(rows, rows, Scalar(0), kMax);
+  VectorType v1 = RandomMatrix<VectorType, Scalar>(rows, Index(1), Scalar(0), NumTraits<Scalar>::highest() / Scalar(2));
 
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
-  SquareMatrixType identity = SquareMatrixType::Identity(rows, rows), square = SquareMatrixType::Random(rows, rows);
-  VectorType v1(rows), v2 = VectorType::Random(rows), vzero = VectorType::Zero(rows);
-
-  {
-    int guard = 0;
-    do {
-      m1 = MatrixType::Random(rows, cols);
-    } while ((m1 == mzero || m1 == m2) && (++guard) < 100);
-    VERIFY(guard < 100);
-  }
-
-  {
-    int guard = 0;
-    do {
-      v1 = VectorType::Random(rows);
-    } while ((v1 == vzero || v1 == v2) && (++guard) < 100);
-    VERIFY(guard < 100);
-  }
+  // The checks below require m1 != 2 * m1, m1 != m2, and v1 != 2 * v1, which random draws do not
+  // guarantee (in particular for 1x1 matrices); patch one entry to rule out the degenerate cases.
+  if (m1 == MatrixType::Zero(rows, cols) || m1 == m2) m1(0, 0) = m2(0, 0) + Scalar(1);
+  if (v1 == VectorType::Zero(rows)) v1(0) = Scalar(1);
 
   VERIFY_IS_APPROX(v1, v1);
   VERIFY_IS_NOT_APPROX(v1, 2 * v1);
-  VERIFY_IS_APPROX(vzero, v1 - v1);
+  VERIFY_IS_APPROX(VectorType::Zero(rows), v1 - v1);
+
   VERIFY_IS_APPROX(m1, m1);
   VERIFY_IS_NOT_APPROX(m1, 2 * m1);
-  VERIFY_IS_APPROX(mzero, m1 - m1);
+  VERIFY_IS_APPROX(MatrixType::Zero(rows, cols), m1 - m1);
 
   VERIFY_IS_APPROX(m3 = m1, m1);
   MatrixType m4;
@@ -113,10 +91,7 @@
 
   // check linear structure
 
-  Scalar s1;
-  do {
-    s1 = internal::random<Scalar>();
-  } while (s1 == 0);
+  Scalar s1 = internal::random<Scalar>(1, kMax);
 
   VERIFY_IS_EQUAL(m1 + m1, 2 * m1);
   VERIFY_IS_EQUAL(m1 + m2 - m1, m2);
@@ -134,10 +109,73 @@
 
   // check matrix product.
 
-  VERIFY_IS_APPROX(identity * m1, m1);
-  VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
-  VERIFY_IS_APPROX((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
-  VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
+  if (!NumTraits<Scalar>::IsSigned) {
+    VERIFY_IS_APPROX(SquareMatrixType::Identity(rows, rows) * m1, m1);
+    VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
+    VERIFY_IS_APPROX((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
+    VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
+  }
+}
+
+// Unsigned operands narrower than int are promoted to int before multiplication, so a product above
+// INT_MAX overflows the signed intermediate although the wrapped result, the exact product modulo
+// 2^(8*sizeof(Scalar)), is representable. A multiply that keeps the promoted signed type fails this
+// under UBSan by report rather than by comparison.
+template <typename Scalar>
+void unsigned_wraparound_tests() {
+  using WideScalar = unsigned long long;
+  using ArrayType = Array<Scalar, Dynamic, 1>;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic>;
+  EIGEN_STATIC_ASSERT(sizeof(Scalar) < sizeof(WideScalar), THIS_TYPE_IS_NOT_SUPPORTED)
+  const Scalar highest = NumTraits<Scalar>::highest();
+  const WideScalar modulus = WideScalar(highest) + 1;
+  const Scalar values[] = {Scalar(0), Scalar(1), Scalar(highest / 2), Scalar(highest - 1), highest};
+  const Index numValues = Index(sizeof(values) / sizeof(values[0]));
+
+  // Long enough to exercise whole packets as well as the scalar tail.
+  const Index size = 8 * internal::packet_traits<Scalar>::size + 3;
+  ArrayType a(size), b(size);
+  for (Index i = 0; i < size; ++i) {
+    a(i) = values[i % numValues];
+    b(i) = values[(size - i) % numValues];
+  }
+
+  const ArrayType product = a * b;
+  const ArrayType square = a.square();
+  const ArrayType cube = a.cube();
+  const ArrayType abs2 = a.abs2();
+  const ArrayType pow2 = a.pow(Scalar(2));
+  const ArrayType pow3 = a.pow(Scalar(3));
+  for (Index i = 0; i < size; ++i) {
+    const WideScalar x = a(i), y = b(i);
+    const WideScalar x2 = x * x % modulus;
+    const WideScalar x3 = x2 * x % modulus;
+    VERIFY_IS_EQUAL(product(i), Scalar(x * y % modulus));
+    VERIFY_IS_EQUAL(square(i), Scalar(x2));
+    VERIFY_IS_EQUAL(cube(i), Scalar(x3));
+    VERIFY_IS_EQUAL(abs2(i), Scalar(x2));
+    VERIFY_IS_EQUAL(pow2(i), Scalar(x2));
+    VERIFY_IS_EQUAL(pow3(i), Scalar(x3));
+    VERIFY_IS_EQUAL(numext::abs2(a(i)), Scalar(x2));
+    VERIFY_IS_EQUAL(numext::pow(a(i), Scalar(2)), Scalar(x2));
+    VERIFY_IS_EQUAL(internal::pmul(a(i), b(i)), Scalar(x * y % modulus));
+  }
+
+  // predux_mul reduces through the same multiply; keep every factor away from zero.
+  const Index reduxSize = 3 * internal::packet_traits<Scalar>::size + 1;
+  ArrayType c(reduxSize);
+  WideScalar expectedProd = 1;
+  for (Index i = 0; i < reduxSize; ++i) {
+    c(i) = Scalar(highest - Scalar(i % 3));
+    expectedProd = expectedProd * WideScalar(c(i)) % modulus;
+  }
+  VERIFY_IS_EQUAL(c.prod(), Scalar(expectedProd));
+
+  // The matrix product multiplies through pmul, at magnitudes integer_type_tests never reaches.
+  const MatrixType m = MatrixType::Constant(4, 4, highest);
+  const MatrixType mm = m * m;
+  const WideScalar h = highest;
+  VERIFY_IS_EQUAL(mm(0, 0), Scalar(4 * (h * h % modulus) % modulus));
 }
 
 template <int>
@@ -154,6 +192,7 @@
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(integer_type_tests(Matrix<unsigned int, 1, 1>()));
     CALL_SUBTEST_1(integer_type_tests(Matrix<unsigned long, 3, 4>()));
+    CALL_SUBTEST_1(unsigned_wraparound_tests<unsigned int>());
 
     CALL_SUBTEST_2(integer_type_tests(Matrix<long, 2, 2>()));
     CALL_SUBTEST_2(signed_integer_type_tests(Matrix<long, 2, 2>()));
@@ -163,11 +202,13 @@
 
     CALL_SUBTEST_4(integer_type_tests(Matrix<unsigned char, 3, 3>()));
     CALL_SUBTEST_4(integer_type_tests(Matrix<unsigned char, Dynamic, Dynamic>(20, 20)));
+    CALL_SUBTEST_4(unsigned_wraparound_tests<unsigned char>());
 
     CALL_SUBTEST_5(integer_type_tests(Matrix<short, Dynamic, 4>(7, 4)));
     CALL_SUBTEST_5(signed_integer_type_tests(Matrix<short, Dynamic, 4>(7, 4)));
 
     CALL_SUBTEST_6(integer_type_tests(Matrix<unsigned short, 4, 4>()));
+    CALL_SUBTEST_6(unsigned_wraparound_tests<unsigned short>());
 
     CALL_SUBTEST_7(integer_type_tests(Matrix<long long, 11, 13>()));
     CALL_SUBTEST_7(signed_integer_type_tests(Matrix<long long, 11, 13>()));
diff --git a/test/inverse.cpp b/test/inverse.cpp
index d564db4..e6755e2 100644
--- a/test/inverse.cpp
+++ b/test/inverse.cpp
@@ -7,15 +7,16 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/LU>
 
-template <typename MatrixType>
-void inverse_for_fixed_size(const MatrixType&, std::enable_if_t<MatrixType::SizeAtCompileTime == Dynamic>* = 0) {}
+template <typename MatrixType, std::enable_if_t<MatrixType::SizeAtCompileTime == Dynamic, int> = 0>
+void inverse_for_fixed_size(const MatrixType&) {}
 
-template <typename MatrixType>
-void inverse_for_fixed_size(const MatrixType& m1, std::enable_if_t<MatrixType::SizeAtCompileTime != Dynamic>* = 0) {
+template <typename MatrixType, std::enable_if_t<MatrixType::SizeAtCompileTime != Dynamic, int> = 0>
+void inverse_for_fixed_size(const MatrixType& m1) {
   using std::abs;
 
   MatrixType m2, identity = MatrixType::Identity();
@@ -58,6 +59,32 @@
     VERIFY_IS_APPROX((m5.template topLeftCorner<MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>()),
                      m2.inverse());
   }
+
+  // check that computeInverseAndDetWithCheck resizes dynamic result matrix (issue #2917)
+  {
+    typedef Matrix<Scalar, Dynamic, Dynamic> DynamicMatrix;
+    DynamicMatrix m_dyn_inv;
+    Scalar det_dyn;
+    bool inv_dyn;
+    m1.computeInverseAndDetWithCheck(m_dyn_inv, det_dyn, inv_dyn);
+    VERIFY(inv_dyn);
+    VERIFY_IS_EQUAL(m_dyn_inv.rows(), m1.rows());
+    VERIFY_IS_EQUAL(m_dyn_inv.cols(), m1.cols());
+    VERIFY_IS_APPROX(identity, m1 * m_dyn_inv);
+    VERIFY_IS_APPROX(det_dyn, m1.determinant());
+  }
+
+  // check that computeInverseWithCheck resizes dynamic result matrix
+  {
+    typedef Matrix<Scalar, Dynamic, Dynamic> DynamicMatrix;
+    DynamicMatrix m_dyn_inv;
+    bool inv_dyn;
+    m1.computeInverseWithCheck(m_dyn_inv, inv_dyn);
+    VERIFY(inv_dyn);
+    VERIFY_IS_EQUAL(m_dyn_inv.rows(), m1.rows());
+    VERIFY_IS_EQUAL(m_dyn_inv.cols(), m1.cols());
+    VERIFY_IS_APPROX(identity, m1 * m_dyn_inv);
+  }
 }
 
 template <typename MatrixType>
@@ -124,14 +151,14 @@
 
     s = internal::random<int>(50, 320);
     CALL_SUBTEST_5(inverse(MatrixXf(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
     CALL_SUBTEST_5(inverse_zerosized<float>());
     CALL_SUBTEST_5(inverse(MatrixXf(0, 0)));
     CALL_SUBTEST_5(inverse(MatrixXf(1, 1)));
 
     s = internal::random<int>(25, 100);
     CALL_SUBTEST_6(inverse(MatrixXcd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     CALL_SUBTEST_7(inverse(Matrix4d()));
     CALL_SUBTEST_7(inverse(Matrix<double, 4, 4, DontAlign>()));
diff --git a/test/io.cpp b/test/io.cpp
index 637f02d..155b253 100644
--- a/test/io.cpp
+++ b/test/io.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include <sstream>
 
diff --git a/test/is_same_dense.cpp b/test/is_same_dense.cpp
index 18c07e6..3641e6e 100644
--- a/test/is_same_dense.cpp
+++ b/test/is_same_dense.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/jacobi.cpp b/test/jacobi.cpp
index 7634604..5316bab 100644
--- a/test/jacobi.cpp
+++ b/test/jacobi.cpp
@@ -7,8 +7,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "fp_control.h"
 #include <Eigen/SVD>
 
 template <typename MatrixType, typename JacobiScalar>
@@ -53,8 +55,270 @@
   }
 }
 
+// Verify that JacobiRotation::makeGivens(p, q, &r) produces a rotation that
+// zeros out q, even when (p, q) straddle the over-/underflow thresholds
+// where the direct formula r = p * sqrt(1 + (q/p)^2) would over- or
+// underflow.  Eigen's convention is r >= 0 with sign carried in c.
+template <typename Scalar>
+void verify_makeGivens(const Scalar& p, const Scalar& q) {
+  using std::abs;
+  Scalar r;
+  JacobiRotation<Scalar> rot;
+  rot.makeGivens(p, q, &r);
+
+  // Eigen's J^T * [p; q] = [r; 0] with J = [c s; -s c]. Verify the homogeneous relation after scaling the inputs so
+  // the check itself does not overflow or flush intermediate products to zero.
+  const Scalar scale = numext::maxi(numext::maxi(abs(p), abs(q)), (std::numeric_limits<Scalar>::min)());
+  const Scalar scaledP = p / scale;
+  const Scalar scaledQ = q / scale;
+  const Scalar scaledR = r / scale;
+  const Scalar rotated0 = rot.c() * scaledP - rot.s() * scaledQ;
+  const Scalar rotated1 = rot.s() * scaledP + rot.c() * scaledQ;
+
+  const Scalar tol = NumTraits<Scalar>::epsilon() * (abs(scaledR) + (std::numeric_limits<Scalar>::min)()) * Scalar(64);
+  VERIFY(abs(rotated0 - scaledR) <= tol);
+  VERIFY(abs(rotated1) <= tol);
+  VERIFY(r >= Scalar(0));
+  VERIFY_IS_APPROX(numext::abs2(rot.c()) + numext::abs2(rot.s()), Scalar(1));
+}
+
+template <typename Scalar>
+void jacobi_makegivens_safe_scaling() {
+  using std::sqrt;
+  const Scalar safmin = (std::numeric_limits<Scalar>::min)();
+  const Scalar safmax = Scalar(1) / safmin;
+  const Scalar rtmin = sqrt(safmin);
+  const Scalar rtmax = sqrt(safmax / Scalar(2));
+  const Scalar one(1);
+  const Scalar two(2);
+  const Scalar half(0.5L);
+
+  // Safe-range cases (regression — must keep existing fast path working).
+  verify_makeGivens<Scalar>(Scalar(0), Scalar(0));
+  verify_makeGivens<Scalar>(Scalar(3), Scalar(4));
+  verify_makeGivens<Scalar>(Scalar(-3), Scalar(4));
+  verify_makeGivens<Scalar>(Scalar(3), Scalar(-4));
+  verify_makeGivens<Scalar>(Scalar(-3), Scalar(-4));
+
+  // Both inputs near overflow: direct formula r = p * sqrt(1+(q/p)^2) would
+  // overflow because sqrt(1+1) > 1.  Prescaling avoids this.
+  verify_makeGivens<Scalar>(rtmax * two, rtmax);
+  verify_makeGivens<Scalar>(-rtmax * two, rtmax);
+  verify_makeGivens<Scalar>(rtmax, rtmax);
+  verify_makeGivens<Scalar>(rtmax * Scalar(1.5), rtmax * Scalar(1.5));
+
+  // Both inputs near underflow / subnormal: direct (q/p)^2 underflows to 0.
+  verify_makeGivens<Scalar>(rtmin * half, rtmin * half);
+  verify_makeGivens<Scalar>(safmin, safmin);
+  verify_makeGivens<Scalar>(-safmin, safmin);
+
+  // Mixed: one near overflow, one normal.
+  verify_makeGivens<Scalar>(rtmax * Scalar(1.5), one);
+  verify_makeGivens<Scalar>(one, rtmax * Scalar(1.5));
+  verify_makeGivens<Scalar>(-rtmax * Scalar(1.5), one);
+
+  // Mixed: one near underflow, one normal.
+  verify_makeGivens<Scalar>(safmin, one);
+  verify_makeGivens<Scalar>(one, safmin);
+
+  // Mixed: subnormal and near-overflow simultaneously.
+  verify_makeGivens<Scalar>(safmin, rtmax);
+  verify_makeGivens<Scalar>(rtmax, safmin);
+}
+
+template <typename Scalar>
+void jacobi_makegivens_subnormal() {
+  const Scalar minimum = (std::numeric_limits<Scalar>::min)();
+  const Scalar tiny = std::numeric_limits<Scalar>::denorm_min();
+  JacobiRotation<Scalar> zero;
+  zero.makeGivens(-Scalar(0), Scalar(0));
+  VERIFY_IS_EQUAL(zero.c(), Scalar(1));
+  VERIFY_IS_EQUAL(zero.s(), Scalar(0));
+  for (Scalar scale : {minimum, Scalar(minimum / Scalar(16)), tiny}) {
+    for (int i = -3; i <= 3; ++i) {
+      for (int j = -3; j <= 3; ++j) {
+        if (i == 0 && j == 0) continue;
+        const Scalar p = i == 0 ? -Scalar(0) : Scalar(i) * scale;
+        const Scalar q = Scalar(j) * scale;
+        const long double expected = std::sqrt(static_cast<long double>(i * i + j * j));
+        for (int mode = 0; mode < 4; ++mode) {
+          JacobiRotation<Scalar> rotation, withoutR;
+          Scalar r;
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY) && EIGEN_ARCH_i386_OR_x86_64 && \
+    (defined(__SSE__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1))
+          {
+            struct RestoreMxcsr {
+              unsigned saved = _mm_getcsr();
+              ~RestoreMxcsr() { _mm_setcsr(saved); }
+            } restore;
+            const unsigned mask = _MM_FLUSH_ZERO_MASK | _MM_DENORMALS_ZERO_MASK;
+            const unsigned requested = ((mode & 1) ? _MM_FLUSH_ZERO_ON : 0) | ((mode & 2) ? _MM_DENORMALS_ZERO_ON : 0);
+            _mm_setcsr((restore.saved & ~mask) | requested);
+            VERIFY_IS_EQUAL(_mm_getcsr() & mask, requested);
+            rotation.makeGivens(p, q, &r);
+            withoutR.makeGivens(p, q);
+            VERIFY_IS_EQUAL(_mm_getcsr() & mask, requested);
+          }
+#else
+          if (mode > 1) continue;
+          if (mode == 1) {
+            ScopedFlushToZero flush;
+            if (!flush.isSupported()) continue;
+            rotation.makeGivens(p, q, &r);
+            withoutR.makeGivens(p, q);
+          } else {
+            rotation.makeGivens(p, q, &r);
+            withoutR.makeGivens(p, q);
+          }
+#endif
+          const long double c = static_cast<long double>(rotation.c()), s = static_cast<long double>(rotation.s());
+          const long double tolerance = 16 * static_cast<long double>(NumTraits<Scalar>::epsilon());
+          VERIFY(numext::abs(c * c + s * s - 1) <= tolerance);
+          VERIFY(numext::abs(s * i + c * j) <= tolerance * expected);
+          VERIFY(numext::abs(c * i - s * j - expected) <= tolerance * expected);
+          VERIFY_IS_EQUAL(rotation.c(), withoutR.c());
+          VERIFY_IS_EQUAL(rotation.s(), withoutR.s());
+          const long double normalizedR = static_cast<long double>(r) / static_cast<long double>(scale);
+          const long double quantum = static_cast<long double>(tiny) / static_cast<long double>(scale);
+          VERIFY(normalizedR > 0);
+          VERIFY(numext::abs(normalizedR - expected) <= tolerance * expected + quantum / 2);
+          if (i == 0 || j == 0) VERIFY_IS_EQUAL(r, numext::abs(i == 0 ? q : p));
+        }
+      }
+    }
+  }
+  const Scalar maximum = NumTraits<Scalar>::highest();
+  verify_makeGivens(Scalar(maximum / Scalar(2)), Scalar(maximum / Scalar(3)));
+  JacobiRotation<Scalar> overflow, withoutR;
+  Scalar r;
+  overflow.makeGivens(maximum, maximum, &r);
+  withoutR.makeGivens(maximum, maximum);
+  VERIFY((numext::isinf)(r));
+  VERIFY_IS_EQUAL(overflow.c(), withoutR.c());
+  VERIFY_IS_EQUAL(overflow.s(), withoutR.s());
+  VERIFY(numext::abs(overflow.c() + overflow.s()) <= NumTraits<Scalar>::epsilon());
+  VERIFY(numext::abs(overflow.c() * overflow.c() + overflow.s() * overflow.s() - Scalar(1)) <=
+         Scalar(8) * NumTraits<Scalar>::epsilon());
+}
+
+template <typename Scalar>
+void jacobi_makejacobi_large_tau() {
+  using std::abs;
+  using std::sqrt;
+
+  const Scalar rtmax = sqrt((std::numeric_limits<Scalar>::max)());
+  for (int factor = 1; factor <= 2; ++factor) {
+    const Scalar deno = Scalar(1) / (Scalar(factor) * rtmax);
+    const Scalar y = deno * Scalar(0.5);
+    for (int delta_sign = -1; delta_sign <= 1; delta_sign += 2) {
+      const Scalar x = delta_sign > 0 ? Scalar(1) : Scalar(0);
+      const Scalar z = delta_sign > 0 ? Scalar(0) : Scalar(1);
+      JacobiRotation<Scalar> rotation;
+      rotation.makeJacobi(x, y, z);
+
+      const Scalar offdiag =
+          rotation.c() * rotation.s() * (x - z) + (rotation.c() * rotation.c() - rotation.s() * rotation.s()) * y;
+      VERIFY(!numext::is_exactly_zero(rotation.s()));
+      VERIFY(abs(offdiag) <= NumTraits<Scalar>::epsilon() * abs(y));
+    }
+  }
+}
+
+template <typename Scalar>
+void jacobi_makejacobi_complex() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using std::abs;
+  using std::sqrt;
+
+  const RealScalar rtmax = sqrt((std::numeric_limits<RealScalar>::max)());
+  // Allow rounding in the rotation and in the complex off-diagonal residual.
+  const RealScalar tolerance = RealScalar(16) * NumTraits<RealScalar>::epsilon();
+  for (const RealScalar magnitude :
+       {RealScalar(0.5) / rtmax, RealScalar(0.25) / rtmax, RealScalar(0.25), RealScalar(0.5), RealScalar(1)}) {
+    for (int real_sign : {-1, 1}) {
+      for (int imag_sign : {-1, 1}) {
+        const Scalar y(RealScalar(real_sign) * RealScalar(0.6) * magnitude,
+                       RealScalar(imag_sign) * RealScalar(0.8) * magnitude);
+        for (int delta_sign : {-1, 0, 1}) {
+          const RealScalar x = RealScalar(delta_sign);
+          const RealScalar z = RealScalar(0);
+          JacobiRotation<Scalar> rotation;
+          VERIFY(rotation.makeJacobi(x, y, z));
+
+          const Scalar c = rotation.c();
+          const Scalar s = rotation.s();
+          VERIFY_IS_EQUAL(numext::imag(c), RealScalar(0));
+          VERIFY(numext::real(c) > RealScalar(0));
+          VERIFY(abs(s) > RealScalar(0));
+          VERIFY(abs(numext::abs2(c) + numext::abs2(s) - RealScalar(1)) <= tolerance);
+
+          // (J* B J)(0,1), with J = [c conj(s); -s c] and B = [x y; conj(y) z].
+          const Scalar conjugate_s = numext::conj(s);
+          const Scalar offdiag = c * conjugate_s * (x - z) + c * c * y - conjugate_s * conjugate_s * numext::conj(y);
+          VERIFY(abs(offdiag) <= tolerance * abs(y));
+        }
+      }
+    }
+  }
+}
+
+template <typename Scalar>
+void jacobi_makejacobi_extreme_phase() {
+  const Scalar tolerance = Scalar(8) * NumTraits<Scalar>::epsilon();
+  const Scalar expected = numext::sqrt(Scalar(0.5));
+  ScopedFlushToZero flushToZero;
+  for (const Scalar magnitude :
+       {(std::numeric_limits<Scalar>::max)() / Scalar(4), (std::numeric_limits<Scalar>::min)() * Scalar(4)}) {
+    for (const Scalar sign : {Scalar(-1), Scalar(1)}) {
+      JacobiRotation<Scalar> rotation;
+      rotation.makeJacobi(Scalar(0), sign * magnitude, Scalar(0));
+      VERIFY(numext::abs(rotation.c() - expected) <= tolerance);
+      VERIFY(numext::abs(rotation.s() - sign * expected) <= tolerance);
+    }
+  }
+}
+
+template <typename Scalar>
+void jacobi_makejacobi_ratio_boundaries() {
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  // Allow rounding in the rotation and the scaled 2x2 residual.
+  const Scalar tolerance = Scalar(8) * eps;
+  for (const Scalar scale : {(std::numeric_limits<Scalar>::min)() * Scalar(4), Scalar(1),
+                             (std::numeric_limits<Scalar>::max)() / Scalar(8)}) {
+    for (const Scalar ratio : {Scalar(0), eps, Scalar(0.5), Scalar(1) - eps, Scalar(1), Scalar(1) + eps, Scalar(2)}) {
+      for (const Scalar sign : {Scalar(-1), Scalar(1)}) {
+        JacobiRotation<Scalar> rotation;
+        VERIFY(rotation.makeJacobi(scale * ratio, sign * scale * Scalar(0.5), Scalar(0)));
+        const Scalar c = rotation.c();
+        const Scalar s = rotation.s();
+        VERIFY(c > Scalar(0));
+        VERIFY(numext::abs(c * c + s * s - Scalar(1)) <= tolerance);
+        const Scalar residual = c * s * ratio + (c * c - s * s) * sign * Scalar(0.5);
+        VERIFY(numext::abs(residual) <= tolerance);
+      }
+    }
+  }
+}
+
 EIGEN_DECLARE_TEST(jacobi) {
   for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_7((jacobi_makegivens_safe_scaling<float>()));
+    CALL_SUBTEST_7((jacobi_makegivens_subnormal<float>()));
+    CALL_SUBTEST_7((jacobi_makegivens_subnormal<double>()));
+    CALL_SUBTEST_7((jacobi_makegivens_safe_scaling<double>()));
+    CALL_SUBTEST_7((jacobi_makegivens_safe_scaling<long double>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_large_tau<float>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_large_tau<double>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_extreme_phase<float>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_extreme_phase<double>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_ratio_boundaries<float>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_ratio_boundaries<double>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_ratio_boundaries<long double>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_ratio_boundaries<half>()));
+    CALL_SUBTEST_7((jacobi_makejacobi_ratio_boundaries<bfloat16>()));
+    CALL_SUBTEST_8((jacobi_makejacobi_complex<std::complex<float>>()));
+    CALL_SUBTEST_8((jacobi_makejacobi_complex<std::complex<double>>()));
+
     CALL_SUBTEST_1((jacobi<Matrix3f, float>()));
     CALL_SUBTEST_2((jacobi<Matrix4d, double>()));
     CALL_SUBTEST_3((jacobi<Matrix4cf, float>()));
diff --git a/test/jacobisvd.cpp b/test/jacobisvd.cpp
index 7a6d490..fd1b02a 100644
--- a/test/jacobisvd.cpp
+++ b/test/jacobisvd.cpp
@@ -7,12 +7,15 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // discard stack allocation as that too bypasses malloc
 #define EIGEN_STACK_ALLOCATION_LIMIT 0
 #define EIGEN_RUNTIME_NO_MALLOC
 #include "main.h"
 #include <Eigen/SVD>
+#include <cfenv>
+#include "fp_control.h"
 
 #define SVD_DEFAULT(M) JacobiSVD<M>
 #define SVD_FOR_MIN_NORM(M) JacobiSVD<M, ColPivHouseholderQRPreconditioner>
@@ -34,40 +37,21 @@
 }
 
 template <typename MatrixType>
-void jacobisvd_thin_options(const MatrixType& input = MatrixType()) {
-  MatrixType m(input.rows(), input.cols());
-  svd_fill_random(m);
-
-  svd_thin_option_checks<MatrixType, 0>(m);
-  svd_thin_option_checks<MatrixType, ColPivHouseholderQRPreconditioner>(m);
-  svd_thin_option_checks<MatrixType, HouseholderQRPreconditioner>(m);
-}
-
-template <typename MatrixType>
-void jacobisvd_full_options(const MatrixType& input = MatrixType()) {
-  MatrixType m(input.rows(), input.cols());
-  svd_fill_random(m);
-
-  svd_option_checks_full_only<MatrixType, 0>(m);
-  svd_option_checks_full_only<MatrixType, ColPivHouseholderQRPreconditioner>(m);
-  svd_option_checks_full_only<MatrixType, HouseholderQRPreconditioner>(m);
+void jacobisvd_thin_full_options(const MatrixType& input = MatrixType()) {
+  svd_thin_full_option_checks<MatrixType, 0>(input);
+  svd_thin_full_option_checks<MatrixType, HouseholderQRPreconditioner>(input);
   svd_option_checks_full_only<MatrixType, FullPivHouseholderQRPreconditioner>(
-      m);  // FullPiv only used when computing full unitaries
+      input);  // FullPiv only used when computing full unitaries
 }
 
 template <typename MatrixType>
-void jacobisvd_verify_assert(const MatrixType& input = MatrixType()) {
+void jacobisvd_vector_asserts(const MatrixType& input = MatrixType()) {
   MatrixType m(input.rows(), input.cols());
   svd_fill_random(m);
-  svd_verify_assert<MatrixType, 0>(m);
-  svd_verify_assert<MatrixType, ColPivHouseholderQRPreconditioner>(m);
+
+  svd_verify_assert<MatrixType>(m);
   svd_verify_assert<MatrixType, HouseholderQRPreconditioner>(m);
   svd_verify_assert_full_only<MatrixType, FullPivHouseholderQRPreconditioner>(m);
-
-  svd_verify_constructor_options_assert<JacobiSVD<MatrixType>>(m);
-  svd_verify_constructor_options_assert<JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>>(m);
-  svd_verify_constructor_options_assert<JacobiSVD<MatrixType, HouseholderQRPreconditioner>>(m);
-  svd_verify_constructor_options_assert<JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>>(m);
 }
 
 template <typename MatrixType>
@@ -108,8 +92,6 @@
 }
 
 namespace Foo {
-// older compiler require a default constructor for Bar
-// cf: https://stackoverflow.com/questions/7411515/
 class Bar {
  public:
   Bar() {}
@@ -122,112 +104,187 @@
   const Foo::Bar a;
   const Foo::Bar b;
   const Foo::Bar c = std::max EIGEN_NOT_A_MACRO(a, b);
-  EIGEN_UNUSED_VARIABLE(c)
+  EIGEN_UNUSED_VARIABLE(c);
+}
+
+void jacobisvd_mixed_option_enum_regression() {
+  using NoQrFullSVD = JacobiSVD<MatrixXd, NoQRPreconditioner | ComputeFullU | ComputeFullV>;
+  using ReversedMixedSVD = JacobiSVD<MatrixXd, ComputeThinU | HouseholderQRPreconditioner | ComputeFullV>;
+
+  STATIC_CHECK((int(NoQrFullSVD::QRPreconditioner) == int(NoQRPreconditioner)));
+  STATIC_CHECK(((int(NoQrFullSVD::Options) & ComputeFullU) != 0));
+  STATIC_CHECK(((int(NoQrFullSVD::Options) & ComputeFullV) != 0));
+  STATIC_CHECK(((int(NoQrFullSVD::Options) & ComputeThinU) == 0));
+  STATIC_CHECK(((int(NoQrFullSVD::Options) & ComputeThinV) == 0));
+
+  STATIC_CHECK((int(ReversedMixedSVD::QRPreconditioner) == int(HouseholderQRPreconditioner)));
+  STATIC_CHECK(((int(ReversedMixedSVD::Options) & ComputeThinU) != 0));
+  STATIC_CHECK(((int(ReversedMixedSVD::Options) & ComputeFullV) != 0));
+  STATIC_CHECK(((int(ReversedMixedSVD::Options) & ComputeFullU) == 0));
+  STATIC_CHECK(((int(ReversedMixedSVD::Options) & ComputeThinV) == 0));
+}
+
+void jacobisvd_large_tau_regression() {
+  Matrix3f m;
+  m << 3.7855173218304116745e-07f, 0.0f, 500.0f, -4.9999995231628417969f, -0.0f, -1.9106853686029490191e-12f,
+      -8.6602544784545898438f, 0.0f, 2.1855694285477511585f;
+
+#ifdef FE_OVERFLOW
+  std::fenv_t environment;
+  const bool check_overflow = std::feholdexcept(&environment) == 0;
+  if (!check_overflow) std::cout << "SKIP: JacobiSVD overflow flag check: feholdexcept failed.\n";
+#else
+  std::cout << "SKIP: JacobiSVD overflow flag check: FE_OVERFLOW is unavailable.\n";
+#endif
+  JacobiSVD<Matrix3f> svd(m, ComputeFullU | ComputeFullV);
+#ifdef FE_OVERFLOW
+  if (check_overflow) {
+    const int overflow = std::fetestexcept(FE_OVERFLOW);
+    const int restored = std::fesetenv(&environment);
+    VERIFY_IS_EQUAL(restored, 0);
+    VERIFY_IS_EQUAL(overflow, 0);
+  }
+#endif
+  svd_check_full(m, svd);
+}
+
+void jacobisvd_power_of_two_scaling() {
+  // Reciprocal scaling rounds the smaller singular value up by one ULP.
+  Matrix2f matrix = Matrix2f::Zero();
+  matrix(0, 0) = numext::bit_cast<float>(numext::uint32_t(0x58f6aaed));
+  matrix(1, 1) = numext::bit_cast<float>(numext::uint32_t(0x537dcf0e));
+
+  const JacobiSVD<Matrix2f> svd(matrix);
+  VERIFY_IS_EQUAL(svd.singularValues()(0), matrix(0, 0));
+  VERIFY_IS_EQUAL(svd.singularValues()(1), matrix(1, 1));
+
+  Matrix<float, 3, 2> rectangular = Matrix<float, 3, 2>::Zero();
+  rectangular.template topRows<2>() = matrix;
+  const JacobiSVD<Matrix<float, 3, 2>> rectangularSvd(rectangular);
+  VERIFY_IS_EQUAL(rectangularSvd.singularValues(), matrix.diagonal());
+
+  const auto checkSubnormalScaling = [] {
+    volatile float normalMinInput = (std::numeric_limits<float>::min)();
+    const float inputScale = 256.0f * normalMinInput;
+    Matrix2cf normalized = Matrix2cf::Identity();
+    normalized(1, 0) = std::complex<float>(1.0f / 512.0f, -1.0f / 1024.0f);
+    Matrix2cf tiny = Matrix2cf::Identity() * inputScale;
+    // Narrowing an arithmetic product to float would flush the fixture before the solver sees it.
+    tiny(1, 0) = std::complex<float>(numext::bit_cast<float>(numext::uint32_t(0x00400000)),
+                                     numext::bit_cast<float>(numext::uint32_t(0x80200000)));
+    const JacobiSVD<Matrix2cf> normalizedSvd(normalized);
+    const JacobiSVD<Matrix2cf> tinySvd(tiny);
+    // These well-conditioned, nearly identity problems should agree to a few rounding errors.
+    const float tolerance = 8 * NumTraits<float>::epsilon();
+    VERIFY((tinySvd.singularValues() / inputScale - normalizedSvd.singularValues()).norm() <= tolerance);
+
+    Matrix<std::complex<float>, 3, 2> tinyTall = Matrix<std::complex<float>, 3, 2>::Zero();
+    tinyTall.template topRows<2>() = tiny;
+    const JacobiSVD<Matrix<std::complex<float>, 3, 2>> tinyTallSvd(tinyTall);
+    VERIFY((tinyTallSvd.singularValues() / inputScale - normalizedSvd.singularValues()).norm() <= tolerance);
+
+    const Matrix<std::complex<float>, 2, 3> tinyWide = tinyTall.adjoint();
+    const JacobiSVD<Matrix<std::complex<float>, 2, 3>> tinyWideSvd(tinyWide);
+    VERIFY((tinyWideSvd.singularValues() / inputScale - normalizedSvd.singularValues()).norm() <= tolerance);
+  };
+  checkSubnormalScaling();
+  {
+    ScopedFlushToZero flushToZero;
+    checkSubnormalScaling();
+  }
+
+  volatile float denormMinInput = std::numeric_limits<float>::denorm_min();
+  const float denormMin = denormMinInput;
+  if (!(denormMin > 0.0f)) return;
+  matrix.diagonal() << 1.5f, denormMin;
+  const JacobiSVD<Matrix2f> tailSvd(matrix);
+  VERIFY_IS_EQUAL(tailSvd.singularValues()(1), denormMin);
 }
 
 EIGEN_DECLARE_TEST(jacobisvd) {
+  CALL_SUBTEST_60((svd_normal_equation_roundoff<float, ColMajor>()));
+  CALL_SUBTEST_60((svd_normal_equation_roundoff<double, RowMajor>()));
+  CALL_SUBTEST_61((svd_normal_equation_roundoff<std::complex<float>, RowMajor>()));
+  CALL_SUBTEST_61((svd_normal_equation_roundoff<std::complex<double>, ColMajor>()));
+
   CALL_SUBTEST_1((jacobisvd_verify_inputs<Matrix4d>()));
   CALL_SUBTEST_2((jacobisvd_verify_inputs(Matrix<float, 5, Dynamic>(5, 6))));
   CALL_SUBTEST_3((jacobisvd_verify_inputs<Matrix<std::complex<double>, 7, 5>>()));
+  CALL_SUBTEST_4((jacobisvd_mixed_option_enum_regression()));
+  CALL_SUBTEST_4((jacobisvd_large_tau_regression()));
 
-  CALL_SUBTEST_4((jacobisvd_verify_assert<Matrix3f>()));
-  CALL_SUBTEST_5((jacobisvd_verify_assert<Matrix4d>()));
-  CALL_SUBTEST_6((jacobisvd_verify_assert<Matrix<float, 10, 12>>()));
-  CALL_SUBTEST_7((jacobisvd_verify_assert<Matrix<float, 12, 10>>()));
-  CALL_SUBTEST_8((jacobisvd_verify_assert<MatrixXf>(MatrixXf(10, 12))));
-  CALL_SUBTEST_9((jacobisvd_verify_assert<MatrixXcd>(MatrixXcd(7, 5))));
-
-  CALL_SUBTEST_10(svd_all_trivial_2x2(jacobisvd_thin_options<Matrix2cd>));
-  CALL_SUBTEST_11(svd_all_trivial_2x2(jacobisvd_thin_options<Matrix2d>));
+  CALL_SUBTEST_11((jacobisvd_thin_full_options<Matrix2cd>()));
+  CALL_SUBTEST_12((jacobisvd_thin_full_options<Matrix2d>()));
 
   for (int i = 0; i < g_repeat; i++) {
     int r = internal::random<int>(1, 30), c = internal::random<int>(1, 30);
 
-    TEST_SET_BUT_UNUSED_VARIABLE(r)
-    TEST_SET_BUT_UNUSED_VARIABLE(c)
+    TEST_SET_BUT_UNUSED_VARIABLE(r);
+    TEST_SET_BUT_UNUSED_VARIABLE(c);
 
-    CALL_SUBTEST_12((jacobisvd_thin_options<Matrix3f>()));
-    CALL_SUBTEST_13((jacobisvd_full_options<Matrix3f>()));
-    CALL_SUBTEST_14((jacobisvd_thin_options<Matrix4d>()));
-    CALL_SUBTEST_15((jacobisvd_full_options<Matrix4d>()));
-    CALL_SUBTEST_16((jacobisvd_thin_options<Matrix<float, 2, 3>>()));
-    CALL_SUBTEST_17((jacobisvd_full_options<Matrix<float, 2, 3>>()));
-    CALL_SUBTEST_18((jacobisvd_thin_options<Matrix<double, 4, 7>>()));
-    CALL_SUBTEST_19((jacobisvd_full_options<Matrix<double, 4, 7>>()));
-    CALL_SUBTEST_20((jacobisvd_thin_options<Matrix<double, 7, 4>>()));
-    CALL_SUBTEST_21((jacobisvd_full_options<Matrix<double, 7, 4>>()));
-    CALL_SUBTEST_22((jacobisvd_thin_options<Matrix<double, Dynamic, 5>>(Matrix<double, Dynamic, 5>(r, 5))));
-    CALL_SUBTEST_23((jacobisvd_full_options<Matrix<double, Dynamic, 5>>(Matrix<double, Dynamic, 5>(r, 5))));
-    CALL_SUBTEST_24((jacobisvd_thin_options<Matrix<double, 5, Dynamic>>(Matrix<double, 5, Dynamic>(5, c))));
-    CALL_SUBTEST_25((jacobisvd_full_options<Matrix<double, 5, Dynamic>>(Matrix<double, 5, Dynamic>(5, c))));
-    CALL_SUBTEST_26((jacobisvd_thin_options<MatrixXf>(MatrixXf(r, c))));
-    CALL_SUBTEST_27((jacobisvd_full_options<MatrixXf>(MatrixXf(r, c))));
-    CALL_SUBTEST_28((jacobisvd_thin_options<MatrixXcd>(MatrixXcd(r, c))));
-    CALL_SUBTEST_29((jacobisvd_full_options<MatrixXcd>(MatrixXcd(r, c))));
-    CALL_SUBTEST_30((jacobisvd_thin_options<MatrixXd>(MatrixXd(r, c))));
-    CALL_SUBTEST_31((jacobisvd_full_options<MatrixXd>(MatrixXd(r, c))));
-    CALL_SUBTEST_32((jacobisvd_thin_options<Matrix<double, 5, 7, RowMajor>>()));
-    CALL_SUBTEST_33((jacobisvd_full_options<Matrix<double, 5, 7, RowMajor>>()));
-    CALL_SUBTEST_34((jacobisvd_thin_options<Matrix<double, 7, 5, RowMajor>>()));
-    CALL_SUBTEST_35((jacobisvd_full_options<Matrix<double, 7, 5, RowMajor>>()));
+    CALL_SUBTEST_13((jacobisvd_thin_full_options<Matrix3f>()));
+    CALL_SUBTEST_15((jacobisvd_thin_full_options<Matrix4d>()));
+    CALL_SUBTEST_17((jacobisvd_thin_full_options<Matrix<float, 2, 3>>()));
+    CALL_SUBTEST_19((jacobisvd_thin_full_options<Matrix<double, 4, 7>>()));
+    CALL_SUBTEST_21((jacobisvd_thin_full_options<Matrix<double, 7, 4>>()));
+    CALL_SUBTEST_23((jacobisvd_thin_full_options<Matrix<double, Dynamic, 5>>(Matrix<double, Dynamic, 5>(r, 5))));
+    CALL_SUBTEST_25((jacobisvd_thin_full_options<Matrix<double, 5, Dynamic>>(Matrix<double, 5, Dynamic>(5, c))));
+    CALL_SUBTEST_27((jacobisvd_thin_full_options<MatrixXf>(MatrixXf(r, c))));
+    CALL_SUBTEST_29((jacobisvd_thin_full_options<MatrixXcd>(MatrixXcd(r, c))));
+    CALL_SUBTEST_31((jacobisvd_thin_full_options<MatrixXd>(MatrixXd(r, c))));
+    CALL_SUBTEST_33((jacobisvd_thin_full_options<Matrix<double, 5, 7, RowMajor>>()));
+    CALL_SUBTEST_35((jacobisvd_thin_full_options<Matrix<double, 7, 5, RowMajor>>()));
 
     MatrixXcd noQRTest = MatrixXcd(r, r);
-    svd_fill_random(noQRTest);
-    CALL_SUBTEST_36((svd_thin_option_checks<MatrixXcd, NoQRPreconditioner>(noQRTest)));
-    CALL_SUBTEST_36((svd_option_checks_full_only<MatrixXcd, NoQRPreconditioner>(noQRTest)));
+    CALL_SUBTEST_37((svd_thin_full_option_checks<MatrixXcd, NoQRPreconditioner>(noQRTest)));
 
-    CALL_SUBTEST_37((
+    CALL_SUBTEST_38((
         svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, ColMajor, 13, 15>, ColPivHouseholderQRPreconditioner>(
             r, c)));
-    CALL_SUBTEST_38(
+    CALL_SUBTEST_39(
         (svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, ColMajor, 15, 13>, HouseholderQRPreconditioner>(r,
                                                                                                                    c)));
-    CALL_SUBTEST_39((
+    CALL_SUBTEST_40((
         svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, RowMajor, 13, 15>, ColPivHouseholderQRPreconditioner>(
             r, c)));
-    CALL_SUBTEST_40(
+    CALL_SUBTEST_41(
         (svd_check_max_size_matrix<Matrix<float, Dynamic, Dynamic, RowMajor, 15, 13>, HouseholderQRPreconditioner>(r,
                                                                                                                    c)));
 
     // Test on inf/nan matrix
-    CALL_SUBTEST_41((svd_inf_nan<MatrixXf>()));
-    CALL_SUBTEST_42((svd_inf_nan<MatrixXd>()));
+    CALL_SUBTEST_42((svd_inf_nan<MatrixXf>()));
+    CALL_SUBTEST_43((svd_inf_nan<MatrixXd>()));
 
-    CALL_SUBTEST_43((jacobisvd_verify_assert<Matrix<double, 6, 1>>()));
-    CALL_SUBTEST_44((jacobisvd_verify_assert<Matrix<double, 1, 6>>()));
-    CALL_SUBTEST_45((jacobisvd_verify_assert<Matrix<double, Dynamic, 1>>(Matrix<double, Dynamic, 1>(r))));
-    CALL_SUBTEST_46((jacobisvd_verify_assert<Matrix<double, 1, Dynamic>>(Matrix<double, 1, Dynamic>(c))));
+    CALL_SUBTEST_44((jacobisvd_vector_asserts<Matrix<double, 6, 1>>()));
+    CALL_SUBTEST_45((jacobisvd_vector_asserts<Matrix<double, 1, 6>>()));
+    CALL_SUBTEST_46((jacobisvd_vector_asserts<Matrix<double, Dynamic, 1>>(Matrix<double, Dynamic, 1>(r))));
+    CALL_SUBTEST_47((jacobisvd_vector_asserts<Matrix<double, 1, Dynamic>>(Matrix<double, 1, Dynamic>(c))));
   }
 
-  CALL_SUBTEST_47((jacobisvd_thin_options<MatrixXd>(
+  CALL_SUBTEST_48((jacobisvd_thin_full_options<MatrixXd>(
       MatrixXd(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2),
                internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
-  CALL_SUBTEST_48((jacobisvd_full_options<MatrixXd>(
-      MatrixXd(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2),
-               internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 2)))));
-  CALL_SUBTEST_49((jacobisvd_thin_options<MatrixXcd>(
-      MatrixXcd(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 3),
-                internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 3)))));
-  CALL_SUBTEST_50((jacobisvd_full_options<MatrixXcd>(
+  CALL_SUBTEST_50((jacobisvd_thin_full_options<MatrixXcd>(
       MatrixXcd(internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 3),
                 internal::random<int>(EIGEN_TEST_MAX_SIZE / 4, EIGEN_TEST_MAX_SIZE / 3)))));
 
   // test matrixbase method
-  CALL_SUBTEST_51((jacobisvd_method<Matrix2cd>()));
-  CALL_SUBTEST_52((jacobisvd_method<Matrix3f>()));
+  CALL_SUBTEST_52((jacobisvd_method<Matrix2cd>()));
+  CALL_SUBTEST_53((jacobisvd_method<Matrix3f>()));
 
   // Test problem size constructors
-  CALL_SUBTEST_53(JacobiSVD<MatrixXf>(10, 10));
+  CALL_SUBTEST_54(JacobiSVD<MatrixXf>(10, 10));
 
   // Check that preallocation avoids subsequent mallocs
-  CALL_SUBTEST_54(svd_preallocate<void>());
+  CALL_SUBTEST_55(svd_preallocate<void>());
 
-  CALL_SUBTEST_55(svd_underoverflow<void>());
+  CALL_SUBTEST_56(svd_underoverflow<void>());
+  CALL_SUBTEST_56(jacobisvd_power_of_two_scaling());
 
   // Check that the TriangularBase constructor works
-  CALL_SUBTEST_56((svd_triangular_matrix<Matrix3d>()));
-  CALL_SUBTEST_57((svd_triangular_matrix<Matrix4f>()));
-  CALL_SUBTEST_58((svd_triangular_matrix<Matrix<double, 10, 10>>()));
+  CALL_SUBTEST_57((svd_triangular_matrix<Matrix3d>()));
+  CALL_SUBTEST_58((svd_triangular_matrix<Matrix4f>()));
+  CALL_SUBTEST_59((svd_triangular_matrix<Matrix<double, 10, 10>>()));
 
   msvc_workaround();
 }
diff --git a/test/jacobisvd_blocked.cpp b/test/jacobisvd_blocked.cpp
new file mode 100644
index 0000000..4a8f2e6
--- /dev/null
+++ b/test/jacobisvd_blocked.cpp
@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_JACOBI_SVD_BLOCKING_THRESHOLD 16
+#include "main.h"
+#include <Eigen/SVD>
+
+template <typename MatrixType>
+void jacobisvd_blocked(const MatrixType& input) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  const Index n = input.rows();
+  MatrixType matrix = input;
+  JacobiSVD<MatrixType, ComputeFullU | ComputeFullV> svd(n, n);
+  JacobiSVD<MatrixType> valuesOnly(n, n);
+  // O(n*eps) backward error and orthogonality bounds for accumulated rotations.
+  const RealScalar tolerance = RealScalar(64 * n) * NumTraits<RealScalar>::epsilon();
+  for (int pattern = 0; pattern < 4; ++pattern) {
+    if (pattern == 1) matrix.col(n - 1) = matrix.col(0);
+    if (pattern == 2) matrix.setIdentity();
+    if (pattern == 3) matrix.setZero();
+    svd.compute(matrix);
+    valuesOnly.compute(matrix);
+    VERIFY_IS_EQUAL(svd.info(), Success);
+    VERIFY_IS_EQUAL(valuesOnly.info(), Success);
+    const MatrixType reconstructed =
+        svd.matrixU() * svd.singularValues().template cast<Scalar>().asDiagonal() * svd.matrixV().adjoint();
+    VERIFY_LE((matrix - reconstructed).norm(), tolerance * matrix.norm());
+    VERIFY_LE((svd.matrixU().adjoint() * svd.matrixU() - MatrixType::Identity(n, n)).norm(), tolerance);
+    VERIFY_LE((svd.matrixV().adjoint() * svd.matrixV() - MatrixType::Identity(n, n)).norm(), tolerance);
+    VERIFY_LE((valuesOnly.singularValues() - svd.singularValues()).norm(), tolerance * matrix.norm());
+  }
+}
+
+EIGEN_DECLARE_TEST(jacobisvd_blocked) {
+  for (int repeat = 0; repeat < g_repeat; ++repeat) {
+    // Default block size is 32: cover scalar tails, contiguous blocks, and distant rows.
+    for (Index n : {31, 32, 33, 34, 65}) {
+      TEST_SET_BUT_UNUSED_VARIABLE(n);
+      CALL_SUBTEST_1(jacobisvd_blocked(MatrixXf(MatrixXf::Random(n, n))));
+      CALL_SUBTEST_2((jacobisvd_blocked(Matrix<double, Dynamic, Dynamic, RowMajor>::Random(n, n).eval())));
+      CALL_SUBTEST_3((jacobisvd_blocked(Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>::Random(n, n).eval())));
+      CALL_SUBTEST_4(jacobisvd_blocked(MatrixXcd(MatrixXcd::Random(n, n))));
+      CALL_SUBTEST_5((jacobisvd_blocked(Matrix<double, Dynamic, Dynamic, RowMajor, 65, 65>::Random(n, n).eval())));
+    }
+    CALL_SUBTEST_6((jacobisvd_blocked(Matrix<double, 34, 34>::Random().eval())));
+  }
+}
diff --git a/test/klu_support.cpp b/test/klu_support.cpp
index b4f1f43..76c68ca 100644
--- a/test/klu_support.cpp
+++ b/test/klu_support.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #include "sparse_solver.h"
diff --git a/test/linearstructure.cpp b/test/linearstructure.cpp
index 082fa47..0560230 100644
--- a/test/linearstructure.cpp
+++ b/test/linearstructure.cpp
@@ -7,12 +7,15 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 static bool g_called;
 #define EIGEN_SCALAR_BINARY_OP_PLUGIN \
-  { g_called |= (!internal::is_same<LhsScalar, RhsScalar>::value); }
+  { g_called |= (!std::is_same<LhsScalar, RhsScalar>::value); }
 
 #include "main.h"
+#include "random_for_arithmetic.h"
+#include "fp_control.h"
 
 template <typename MatrixType>
 void linearStructure(const MatrixType& m) {
@@ -21,15 +24,17 @@
      CwiseUnaryOp.h, CwiseBinaryOp.h, SelfCwiseBinaryOp.h
   */
   typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
 
   Index rows = m.rows();
   Index cols = m.cols();
 
   // this test relies a lot on Random.h, and there's not much more that we can do
   // to test it, hence I consider that we will have tested Random.h
-  MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols), m3(rows, cols);
+  MatrixType m1 = random_for_arithmetic<MatrixType>(rows, cols), m2 = random_for_arithmetic<MatrixType>(rows, cols),
+             m3(rows, cols);
 
-  Scalar s1 = internal::random<Scalar>();
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>();
   if (s1 == Scalar(0)) s1 = Scalar(1);
 
   Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
@@ -39,8 +44,17 @@
   VERIFY_IS_APPROX(m1 + m2 - m1, m2);
   VERIFY_IS_APPROX(-m2 + m1 + m2, m1);
   VERIFY_IS_APPROX(m1 * s1, s1 * m1);
-  VERIFY_IS_APPROX((m1 + m2) * s1, s1 * m1 + s1 * m2);
-  VERIFY_IS_APPROX((-m1 + m2) * s1, -s1 * m1 + s1 * m2);
+  if (NumTraits<Scalar>::IsInteger) {
+    // Bounded integer arithmetic is exactly distributive.
+    VERIFY_IS_APPROX((m1 + m2) * s1, s1 * m1 + s1 * m2);
+    VERIFY_IS_APPROX((-m1 + m2) * s1, -s1 * m1 + s1 * m2);
+  } else {
+    // Both forms of the distributive law round to within eps * |s1| * (|m1| + |m2|) of the exact value,
+    // which is unbounded relative to a result formed by cancellation.
+    const RealScalar scale = numext::abs(s1) * (max_abs_coeff(m1) + max_abs_coeff(m2));
+    VERIFY_IS_APPROX_SCALED((m1 + m2) * s1, s1 * m1 + s1 * m2, scale);
+    VERIFY_IS_APPROX_SCALED((-m1 + m2) * s1, -s1 * m1 + s1 * m2, scale);
+  }
   m3 = m2;
   m3 += m1;
   VERIFY_IS_APPROX(m3, m1 + m2);
@@ -123,8 +137,8 @@
   for (int si = 0; si < 7; ++si) {
     Index n = sizes[si];
     if (n <= 0) continue;
-    ColMat mc = ColMat::Random(n, n);
-    RowMat mr = RowMat::Random(n, n);
+    ColMat mc = random_for_arithmetic<ColMat>(n, n);
+    RowMat mr = random_for_arithmetic<RowMat>(n, n);
 
     // ColMajor + RowMajor → ColMajor
     ColMat sum_c = mc + mr;
@@ -159,10 +173,47 @@
   }
 }
 
+// Regression test for the seed-dependent failure of the distributive law checks above: when m1 and m2
+// agree to all but the last few bits, m1 + m2 (resp. -m1 + m2) is formed by cancellation while the
+// rounding error of s1 * m1 + s1 * m2 stays proportional to |s1| * (|m1| + |m2|).
+template <typename Scalar>
+void linearStructure_cancellation() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, 1, 1> MatrixType;
+
+  const RealScalar close = RealScalar(1) - RealScalar(64) * NumTraits<RealScalar>::epsilon();
+  const Scalar s1 = Scalar(RealScalar(-0.465));
+  MatrixType m1, m2;
+  m1(0, 0) = Scalar(RealScalar(0.35));
+
+  for (int i = 0; i < 2; ++i) {
+    // i == 0 cancels in m1 + m2, i == 1 cancels in -m1 + m2.
+    m2(0, 0) = (i == 0 ? -m1(0, 0) : m1(0, 0)) * close;
+    const RealScalar scale = numext::abs(s1) * (max_abs_coeff(m1) + max_abs_coeff(m2));
+    VERIFY_IS_APPROX_SCALED((m1 + m2) * s1, s1 * m1 + s1 * m2, scale);
+    VERIFY_IS_APPROX_SCALED((-m1 + m2) * s1, -s1 * m1 + s1 * m2, scale);
+  }
+}
+
 template <int>
 void linearstructure_overflow() {
   // make sure that /=scalar and /scalar do not overflow
   // rational: 1.0/4.94e-320 overflow, but m/4.94e-320 should not
+  //
+  // The claim is about Eigen: that it divides rather than multiplying by a
+  // reciprocal.  An environment that flushes subnormal operands, or whose
+  // compiler performs that rewrite itself, cannot answer it -- the quotient is
+  // infinite either way, so a failure would not distinguish Eigen's arithmetic
+  // from the compiler's.  NVHPC is such an environment by default, through
+  // -Knoieee.
+  if (!subnormalDivisionIsExact<double>()) {
+    const char* reason = ScopedFlushToZero::hardwareFlushesSubnormalInputs() ? "the hardware flushes subnormal inputs"
+                                                                             : "the compiler relaxed the division";
+    std::cout << "SKIP: linearstructure_overflow needs an environment that divides by subnormals per IEEE 754 ("
+              << reason << ")." << std::endl;
+    return;
+  }
+
   Matrix4d m2, m3;
   m3 = m2 = Matrix4d::Random() * 1e-20;
   m2 = m2 / 4.9e-320;
@@ -198,7 +249,12 @@
   }
   CALL_SUBTEST_4(linearstructure_overflow<0>());
 
-  // Mixed storage order tests (deterministic, outside g_repeat).
+  // Deterministic tests, outside g_repeat.
+  CALL_SUBTEST_12(linearStructure_cancellation<float>());
+  CALL_SUBTEST_12(linearStructure_cancellation<double>());
+  CALL_SUBTEST_12(linearStructure_cancellation<std::complex<float>>());
+
+  // Mixed storage order tests.
   CALL_SUBTEST_12(linearStructure_mixed_storage<float>());
   CALL_SUBTEST_12(linearStructure_mixed_storage<double>());
   CALL_SUBTEST_12(linearStructure_mixed_storage<std::complex<float>>());
diff --git a/test/lru_cache.cpp b/test/lru_cache.cpp
new file mode 100644
index 0000000..20f0ade
--- /dev/null
+++ b/test/lru_cache.cpp
@@ -0,0 +1,227 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <Eigen/src/Core/util/LruCache.h>
+
+using Eigen::internal::LruCache;
+
+// Move-only value with a side-effecting destructor, used to assert that
+// eviction and clear() actually destroy values.
+struct DestructorTracer {
+  int id;
+  std::vector<int>* sink;
+
+  DestructorTracer(int id_, std::vector<int>* sink_) : id(id_), sink(sink_) {}
+  DestructorTracer(const DestructorTracer&) = delete;
+  DestructorTracer& operator=(const DestructorTracer&) = delete;
+  DestructorTracer(DestructorTracer&& o) noexcept : id(o.id), sink(o.sink) { o.sink = nullptr; }
+  DestructorTracer& operator=(DestructorTracer&&) = delete;
+  ~DestructorTracer() {
+    if (sink) sink->push_back(id);
+  }
+};
+
+static void test_basic_get_and_miss() {
+  LruCache<int, std::string> cache(3);
+  VERIFY(cache.empty());
+  VERIFY_IS_EQUAL(cache.size(), std::size_t(0));
+  VERIFY_IS_EQUAL(cache.capacity(), std::size_t(3));
+  VERIFY(cache.find(42) == nullptr);
+
+  cache.insert(1, "one");
+  cache.insert(2, "two");
+  VERIFY_IS_EQUAL(cache.size(), std::size_t(2));
+  VERIFY(!cache.empty());
+
+  std::string* p = cache.find(1);
+  VERIFY(p != nullptr);
+  VERIFY_IS_EQUAL(*p, std::string("one"));
+  VERIFY(cache.find(2) != nullptr);
+  VERIFY(cache.find(3) == nullptr);
+}
+
+static void test_lru_eviction() {
+  LruCache<int, int> cache(3);
+  cache.insert(1, 100);
+  cache.insert(2, 200);
+  cache.insert(3, 300);
+
+  // Fourth insert evicts 1 (least-recently-used so far).
+  cache.insert(4, 400);
+  VERIFY_IS_EQUAL(cache.size(), std::size_t(3));
+  VERIFY(cache.find(1) == nullptr);
+  VERIFY(cache.find(2) != nullptr);
+  VERIFY(cache.find(3) != nullptr);
+  VERIFY(cache.find(4) != nullptr);
+}
+
+static void test_hit_promotes_to_mru() {
+  LruCache<int, int> cache(3);
+  cache.insert(1, 100);
+  cache.insert(2, 200);
+  cache.insert(3, 300);
+
+  // Touch 1 — it is now MRU, so 2 becomes LRU.
+  VERIFY(cache.find(1) != nullptr);
+  cache.insert(4, 400);
+  VERIFY(cache.find(1) != nullptr);
+  VERIFY(cache.find(2) == nullptr);
+  VERIFY(cache.find(3) != nullptr);
+  VERIFY(cache.find(4) != nullptr);
+}
+
+static void test_replace_existing_key() {
+  LruCache<int, std::string> cache(3);
+  cache.insert(1, "one");
+  cache.insert(2, "two");
+
+  // Re-inserting the same key replaces the value and promotes to MRU.
+  std::string* p = cache.insert(1, "ONE");
+  VERIFY(p != nullptr);
+  VERIFY_IS_EQUAL(*p, std::string("ONE"));
+  VERIFY_IS_EQUAL(cache.size(), std::size_t(2));
+
+  // Re-inserting 1 made 2 the LRU; filling to capacity then exceeding evicts 2.
+  cache.insert(3, "three");
+  cache.insert(4, "four");
+  VERIFY(cache.find(1) != nullptr);
+  VERIFY(cache.find(2) == nullptr);
+  VERIFY(cache.find(3) != nullptr);
+  VERIFY(cache.find(4) != nullptr);
+}
+
+static void test_replace_destroys_old_value() {
+  std::vector<int> destructions;
+  LruCache<int, DestructorTracer> cache(2);
+  cache.insert(1, DestructorTracer{1, &destructions});
+  cache.insert(2, DestructorTracer{2, &destructions});
+  destructions.clear();
+
+  // Replacement destroys the old entry and does not require Value to be
+  // move-assignable.
+  DestructorTracer* p = cache.insert(1, DestructorTracer{10, &destructions});
+  VERIFY(p != nullptr);
+  VERIFY_IS_EQUAL(p->id, 10);
+  VERIFY_IS_EQUAL(destructions.size(), std::size_t(1));
+  VERIFY_IS_EQUAL(destructions.front(), 1);
+
+  // Replacing 1 promoted it to MRU, so the next insert evicts 2.
+  destructions.clear();
+  cache.insert(3, DestructorTracer{3, &destructions});
+  VERIFY_IS_EQUAL(destructions.size(), std::size_t(1));
+  VERIFY_IS_EQUAL(destructions.front(), 2);
+  VERIFY(cache.find(1) != nullptr);
+  VERIFY(cache.find(3) != nullptr);
+}
+
+static void test_evicted_value_is_destroyed() {
+  std::vector<int> destructions;
+  {
+    LruCache<int, DestructorTracer> cache(2);
+    cache.insert(1, DestructorTracer{1, &destructions});
+    cache.insert(2, DestructorTracer{2, &destructions});
+    destructions.clear();  // discard any destructor calls from the temporaries above
+
+    // Insert 3 — entry 1 (LRU) must be destroyed before 3 is added.
+    cache.insert(3, DestructorTracer{3, &destructions});
+    VERIFY_IS_EQUAL(destructions.size(), std::size_t(1));
+    VERIFY_IS_EQUAL(destructions.front(), 1);
+
+    destructions.clear();
+  }
+  // Destruction of the cache destroys the remaining entries (2 and 3, in some
+  // order). We do not pin down the order, only the multiset.
+  VERIFY_IS_EQUAL(destructions.size(), std::size_t(2));
+  std::sort(destructions.begin(), destructions.end());
+  VERIFY_IS_EQUAL(destructions[0], 2);
+  VERIFY_IS_EQUAL(destructions[1], 3);
+}
+
+static void test_clear() {
+  std::vector<int> destructions;
+  LruCache<int, DestructorTracer> cache(4);
+  cache.insert(1, DestructorTracer{1, &destructions});
+  cache.insert(2, DestructorTracer{2, &destructions});
+  destructions.clear();
+
+  cache.clear();
+  VERIFY(cache.empty());
+  VERIFY_IS_EQUAL(destructions.size(), std::size_t(2));
+  VERIFY(cache.find(1) == nullptr);
+
+  // Reusable after clear.
+  cache.insert(7, DestructorTracer{7, &destructions});
+  VERIFY(cache.find(7) != nullptr);
+}
+
+static void test_move_semantics() {
+  LruCache<int, int> a(2);
+  a.insert(1, 100);
+  a.insert(2, 200);
+
+  LruCache<int, int> b(std::move(a));
+  VERIFY_IS_EQUAL(b.size(), std::size_t(2));
+  VERIFY(b.find(1) != nullptr);
+  VERIFY(b.find(2) != nullptr);
+
+  LruCache<int, int> c(1);
+  c = std::move(b);
+  VERIFY_IS_EQUAL(c.size(), std::size_t(2));  // capacity moved too
+  VERIFY_IS_EQUAL(c.capacity(), std::size_t(2));
+  VERIFY(c.find(1) != nullptr);
+}
+
+static void test_capacity_one() {
+  LruCache<int, int> cache(1);
+  cache.insert(1, 100);
+  VERIFY(cache.find(1) != nullptr);
+  cache.insert(2, 200);
+  VERIFY(cache.find(1) == nullptr);
+  VERIFY(cache.find(2) != nullptr);
+}
+
+static void test_complex_key() {
+  // Verify the cache works with a user-supplied Hash / KeyEqual.
+  struct Key {
+    int a;
+    int b;
+    bool operator==(const Key& o) const { return a == o.a && b == o.b; }
+  };
+  struct KeyHash {
+    std::size_t operator()(const Key& k) const noexcept { return std::hash<int>{}(k.a) * 31u + std::hash<int>{}(k.b); }
+  };
+  LruCache<Key, int, KeyHash> cache(2);
+  cache.insert(Key{1, 2}, 12);
+  cache.insert(Key{3, 4}, 34);
+  int* p = cache.find(Key{1, 2});
+  VERIFY(p != nullptr);
+  VERIFY_IS_EQUAL(*p, 12);
+  VERIFY(cache.find(Key{9, 9}) == nullptr);
+}
+
+EIGEN_DECLARE_TEST(lru_cache) {
+  CALL_SUBTEST(test_basic_get_and_miss());
+  CALL_SUBTEST(test_lru_eviction());
+  CALL_SUBTEST(test_hit_promotes_to_mru());
+  CALL_SUBTEST(test_replace_existing_key());
+  CALL_SUBTEST(test_replace_destroys_old_value());
+  CALL_SUBTEST(test_evicted_value_is_destroyed());
+  CALL_SUBTEST(test_clear());
+  CALL_SUBTEST(test_move_semantics());
+  CALL_SUBTEST(test_capacity_one());
+  CALL_SUBTEST(test_complex_key());
+}
diff --git a/test/lscg.cpp b/test/lscg.cpp
index 1c94e0a..b39407a 100644
--- a/test/lscg.cpp
+++ b/test/lscg.cpp
@@ -6,11 +6,27 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 #include <Eigen/IterativeLinearSolvers>
 
 template <typename T>
+void test_least_square_diagonal_preconditioner_zero_columns() {
+  SparseMatrix<T, RowMajor> mat(3, 3);
+  mat.insert(0, 0) = T(2);
+  mat.insert(2, 2) = T(4);
+  mat.makeCompressed();
+
+  LeastSquareDiagonalPreconditioner<T> precond(mat);
+  Matrix<T, 3, 1> rhs = Matrix<T, 3, 1>::Ones();
+  Matrix<T, 3, 1> expected;
+  expected << T(0.25), T(1), T(0.0625);
+
+  VERIFY_IS_APPROX(precond.solve(rhs), expected);
+}
+
+template <typename T>
 void test_lscg_T() {
   LeastSquaresConjugateGradient<SparseMatrix<T> > lscg_colmajor_diag;
   LeastSquaresConjugateGradient<SparseMatrix<T>, IdentityPreconditioner> lscg_colmajor_I;
@@ -30,7 +46,31 @@
   CALL_SUBTEST(check_sparse_leastsquare_solving(lscg_rowmajor_I));
 }
 
+void test_lscg_extreme_rhs() {
+  const Matrix2d mat = Matrix2d::Identity();
+  const Vector2d direction = (Vector2d() << 1, -1).finished();
+  LeastSquaresConjugateGradient<Matrix2d, IdentityPreconditioner> solver(mat);
+  solver.setTolerance(1e-12);
+
+  for (double scale : {1e-200, 1e200}) {
+    const Vector2d rhs = scale * direction;
+    const Vector2d guess = 0.5 * rhs;
+    Vector2d x = solver.solve(rhs);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+
+    x = solver.solveWithGuess(rhs, guess);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+  }
+}
+
 EIGEN_DECLARE_TEST(lscg) {
   CALL_SUBTEST_1(test_lscg_T<double>());
   CALL_SUBTEST_2(test_lscg_T<std::complex<double> >());
+  CALL_SUBTEST_3(test_least_square_diagonal_preconditioner_zero_columns<double>());
+  CALL_SUBTEST_4(test_least_square_diagonal_preconditioner_zero_columns<std::complex<double> >());
+  CALL_SUBTEST_5(test_lscg_extreme_rhs());
 }
diff --git a/test/lsmr.cpp b/test/lsmr.cpp
new file mode 100644
index 0000000..fac5d1f
--- /dev/null
+++ b/test/lsmr.cpp
@@ -0,0 +1,246 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+// Sparse square and least-squares solving with the default (identity) and the
+// least-squares diagonal preconditioner, in both storage orders.
+template <typename T>
+void test_lsmr_T() {
+  LSMR<SparseMatrix<T> > lsmr_colmajor_I;
+  LSMR<SparseMatrix<T>, LeastSquareDiagonalPreconditioner<T> > lsmr_colmajor_diag;
+  LSMR<SparseMatrix<T, RowMajor> > lsmr_rowmajor_I;
+  LSMR<SparseMatrix<T, RowMajor>, LeastSquareDiagonalPreconditioner<T> > lsmr_rowmajor_diag;
+
+  CALL_SUBTEST(check_sparse_square_solving(lsmr_colmajor_I));
+  CALL_SUBTEST(check_sparse_square_solving(lsmr_colmajor_diag));
+
+  CALL_SUBTEST(check_sparse_leastsquare_solving(lsmr_colmajor_I));
+  CALL_SUBTEST(check_sparse_leastsquare_solving(lsmr_colmajor_diag));
+
+  CALL_SUBTEST(check_sparse_square_solving(lsmr_rowmajor_I));
+  CALL_SUBTEST(check_sparse_leastsquare_solving(lsmr_rowmajor_diag));
+}
+
+// LSMR on dense, rectangular, overdetermined problems: the solution must match
+// the dense QR least-squares solution.
+template <typename T>
+void test_lsmr_dense() {
+  typedef typename NumTraits<T>::Real RealScalar;
+  typedef Matrix<T, Dynamic, Dynamic> DenseMatrix;
+  typedef Matrix<T, Dynamic, 1> DenseVector;
+
+  for (int k = 0; k < g_repeat; ++k) {
+    Index rows = internal::random<Index>(20, 80);
+    Index cols = internal::random<Index>(4, rows);
+    DenseMatrix A = DenseMatrix::Random(rows, cols);
+    DenseVector b = DenseVector::Random(rows);
+
+    LSMR<DenseMatrix> lsmr(A);
+    lsmr.setTolerance(NumTraits<RealScalar>::epsilon() * RealScalar(100));
+    DenseVector x = lsmr.solve(b);
+    VERIFY_IS_EQUAL(lsmr.info(), Success);
+
+    DenseVector xref = A.householderQr().solve(b);
+    VERIFY_IS_APPROX(x, xref);
+  }
+}
+
+// solveWithGuess() must actually consume the initial guess. Starting from the
+// exact solution, the normal-equation residual A^T(b - A x0) is ~0, so LSMR
+// converges in very few iterations -- far fewer than from x = 0. Were the guess
+// silently dropped, both runs would start from x = 0 and use the same count, so
+// the strict iteration-count comparison below is load-bearing. We use cols >= 10
+// so that the from-zero run needs many iterations, giving a wide margin.
+template <typename T>
+void test_lsmr_guess() {
+  typedef typename NumTraits<T>::Real RealScalar;
+  typedef Matrix<T, Dynamic, Dynamic> DenseMatrix;
+  typedef Matrix<T, Dynamic, 1> DenseVector;
+
+  for (int k = 0; k < g_repeat; ++k) {
+    Index cols = internal::random<Index>(10, 20);
+    Index rows = cols + internal::random<Index>(10, 40);
+    DenseMatrix A = DenseMatrix::Random(rows, cols);
+    DenseVector b = DenseVector::Random(rows);
+    DenseVector xref = A.householderQr().solve(b);
+
+    LSMR<DenseMatrix> lsmr(A);
+    lsmr.setTolerance(NumTraits<RealScalar>::epsilon() * RealScalar(100));
+
+    DenseVector x0 = lsmr.solve(b);
+    VERIFY_IS_EQUAL(lsmr.info(), Success);
+    VERIFY_IS_APPROX(x0, xref);
+    const Index iters_from_zero = lsmr.iterations();
+
+    DenseVector xg = lsmr.solveWithGuess(b, xref);
+    VERIFY_IS_EQUAL(lsmr.info(), Success);
+    VERIFY_IS_APPROX(xg, xref);
+    VERIFY(lsmr.iterations() < iters_from_zero);
+  }
+}
+
+// On rank-deficient or underdetermined (rows < cols) problems the least-squares
+// solution is not unique. Started from x = 0, LSMR returns the *minimum-norm*
+// least-squares solution -- exactly what completeOrthogonalDecomposition
+// returns, whereas householderQr would return some other valid LS solution.
+template <typename T>
+void test_lsmr_minnorm() {
+  typedef typename NumTraits<T>::Real RealScalar;
+  typedef Matrix<T, Dynamic, Dynamic> DenseMatrix;
+  typedef Matrix<T, Dynamic, 1> DenseVector;
+
+  for (int k = 0; k < g_repeat; ++k) {
+    // (a) Underdetermined, full row rank: rows < cols, many exact solutions.
+    {
+      Index rows = internal::random<Index>(10, 30);
+      Index cols = rows + internal::random<Index>(5, 30);
+      DenseMatrix A = DenseMatrix::Random(rows, cols);
+      DenseVector b = DenseVector::Random(rows);
+
+      LSMR<DenseMatrix> lsmr(A);
+      lsmr.setTolerance(NumTraits<RealScalar>::epsilon() * RealScalar(100));
+      DenseVector x = lsmr.solve(b);
+      VERIFY_IS_EQUAL(lsmr.info(), Success);
+
+      DenseVector xref = A.completeOrthogonalDecomposition().solve(b);
+      VERIFY_IS_APPROX(x, xref);
+    }
+    // (b) Explicitly rank-deficient, overdetermined: a duplicated column.
+    {
+      Index rows = internal::random<Index>(30, 60);
+      Index cols = internal::random<Index>(5, 15);
+      DenseMatrix A = DenseMatrix::Random(rows, cols);
+      A.col(1) = A.col(0);  // make A rank-deficient
+      DenseVector b = DenseVector::Random(rows);
+
+      LSMR<DenseMatrix> lsmr(A);
+      lsmr.setTolerance(NumTraits<RealScalar>::epsilon() * RealScalar(100));
+      DenseVector x = lsmr.solve(b);
+      VERIFY_IS_EQUAL(lsmr.info(), Success);
+
+      DenseVector xref = A.completeOrthogonalDecomposition().solve(b);
+      VERIFY_IS_APPROX(x, xref);
+    }
+  }
+}
+
+// With damping lambda > 0 LSMR solves the regularized problem
+//   min ||Ax-b||^2 + lambda^2 ||x||^2,
+// whose solution satisfies the (well-conditioned) normal equation
+//   (A^T A + lambda^2 I) x = A^T b.
+template <typename T>
+void test_lsmr_damping() {
+  typedef typename NumTraits<T>::Real RealScalar;
+  typedef Matrix<T, Dynamic, Dynamic> DenseMatrix;
+  typedef Matrix<T, Dynamic, 1> DenseVector;
+
+  for (int k = 0; k < g_repeat; ++k) {
+    Index rows = internal::random<Index>(20, 60);
+    Index cols = internal::random<Index>(4, rows);
+    DenseMatrix A = DenseMatrix::Random(rows, cols);
+    DenseVector b = DenseVector::Random(rows);
+    RealScalar lambda = internal::random<RealScalar>(RealScalar(0.2), RealScalar(2));
+
+    LSMR<DenseMatrix> lsmr(A);
+    lsmr.setDamping(lambda);
+    lsmr.setTolerance(NumTraits<RealScalar>::epsilon() * RealScalar(100));
+    DenseVector x = lsmr.solve(b);
+    VERIFY_IS_EQUAL(lsmr.info(), Success);
+
+    DenseMatrix normalMat = A.adjoint() * A + (lambda * lambda) * DenseMatrix::Identity(cols, cols);
+    DenseVector xref = normalMat.ldlt().solve(A.adjoint() * b);
+    VERIFY_IS_APPROX(x, xref);
+  }
+}
+
+// Robustness against extreme right-hand-side scaling: LSMR normalizes by ||b||
+// immediately, so the solution should scale linearly with b.
+void test_lsmr_extreme_rhs() {
+  const Matrix2d mat = Matrix2d::Identity();
+  const Vector2d direction = (Vector2d() << 1, -1).finished();
+  LSMR<Matrix2d> solver(mat);
+  solver.setTolerance(1e-12);
+
+  for (double scale : {1e-200, 1e200}) {
+    const Vector2d rhs = scale * direction;
+    Vector2d x = solver.solve(rhs);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+  }
+}
+
+// The atol/btol stopping tolerances can be set independently. setTolerance()
+// sets both; setToleranceA()/setToleranceB() override each one, and an unset
+// component falls back to tolerance(). A tight atol must still reach the QR
+// least-squares solution even when btol is left loose.
+template <typename T>
+void test_lsmr_tolerances() {
+  typedef typename NumTraits<T>::Real RealScalar;
+  typedef Matrix<T, Dynamic, Dynamic> DenseMatrix;
+  typedef Matrix<T, Dynamic, 1> DenseVector;
+
+  const RealScalar def = NumTraits<RealScalar>::epsilon();
+  const RealScalar tight = def * RealScalar(100);
+
+  // By default both tolerances track tolerance().
+  LSMR<DenseMatrix> lsmr;
+  VERIFY_IS_EQUAL(lsmr.toleranceA(), def);
+  VERIFY_IS_EQUAL(lsmr.toleranceB(), def);
+
+  // setTolerance() sets both.
+  lsmr.setTolerance(tight);
+  VERIFY_IS_EQUAL(lsmr.toleranceA(), tight);
+  VERIFY_IS_EQUAL(lsmr.toleranceB(), tight);
+
+  // An explicit override wins; the other component still tracks tolerance().
+  lsmr.setToleranceA(def);
+  VERIFY_IS_EQUAL(lsmr.toleranceA(), def);
+  VERIFY_IS_EQUAL(lsmr.toleranceB(), tight);
+  lsmr.setToleranceB(def);
+  VERIFY_IS_EQUAL(lsmr.toleranceB(), def);
+
+  // Use a strongly overdetermined, inconsistent system (rows >> cols) so the
+  // minimum-residual ratio ||A x_LS - b|| / ||b|| stays well above btol. That
+  // keeps the residual stopping rule (istop 1, governed by btol) from firing,
+  // leaving the tight atol to drive convergence to the least-squares solution.
+  // A near-square system would let ||r||/||b|| dip below btol first, stopping
+  // LSMR early on an iterate that is nowhere near the QR solution.
+  for (int k = 0; k < g_repeat; ++k) {
+    Index rows = internal::random<Index>(40, 80);
+    Index cols = internal::random<Index>(4, rows / 4);
+    DenseMatrix A = DenseMatrix::Random(rows, cols);
+    DenseVector b = DenseVector::Random(rows);
+    DenseVector xref = A.householderQr().solve(b);
+
+    // Tight atol drives the least-squares stopping rule, so the solution must
+    // match QR even with btol left loose.
+    LSMR<DenseMatrix> solver(A);
+    solver.setToleranceA(tight).setToleranceB(RealScalar(0.1));
+    DenseVector x = solver.solve(b);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY_IS_APPROX(x, xref);
+  }
+}
+
+EIGEN_DECLARE_TEST(lsmr) {
+  CALL_SUBTEST_1(test_lsmr_T<double>());
+  CALL_SUBTEST_2(test_lsmr_T<std::complex<double> >());
+  CALL_SUBTEST_3(test_lsmr_dense<double>());
+  CALL_SUBTEST_4(test_lsmr_dense<std::complex<double> >());
+  CALL_SUBTEST_5(test_lsmr_damping<double>());
+  CALL_SUBTEST_6(test_lsmr_extreme_rhs());
+  CALL_SUBTEST_7(test_lsmr_minnorm<double>());
+  CALL_SUBTEST_8(test_lsmr_damping<std::complex<double> >());
+  CALL_SUBTEST_9(test_lsmr_minnorm<std::complex<double> >());
+  CALL_SUBTEST_10(test_lsmr_guess<double>());
+  CALL_SUBTEST_11(test_lsmr_tolerances<double>());
+}
diff --git a/test/lu.cpp b/test/lu.cpp
index 7946c0b..d837e3e 100644
--- a/test/lu.cpp
+++ b/test/lu.cpp
@@ -6,18 +6,15 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/LU>
+#include <Eigen/QR>
 #include "solverbase.h"
 using namespace std;
 
 template <typename MatrixType>
-typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
-  return m.cwiseAbs().colwise().sum().maxCoeff();
-}
-
-template <typename MatrixType>
 void lu_non_invertible() {
   typedef typename MatrixType::RealScalar RealScalar;
   /* this test covers the following files:
@@ -37,8 +34,9 @@
   }
 
   enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime };
-  typedef typename internal::kernel_retval_base<FullPivLU<MatrixType> >::ReturnType KernelMatrixType;
-  typedef typename internal::image_retval_base<FullPivLU<MatrixType> >::ReturnType ImageMatrixType;
+  using KernelMatrixType = typename decltype(std::declval<FullPivLU<MatrixType>>().kernel())::PlainObject;
+  using ImageMatrixType =
+      typename decltype(std::declval<FullPivLU<MatrixType>>().image(std::declval<const MatrixType&>()))::PlainObject;
   typedef Matrix<typename MatrixType::Scalar, ColsAtCompileTime, ColsAtCompileTime> CMatrixType;
   typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, RowsAtCompileTime> RMatrixType;
 
@@ -164,6 +162,129 @@
   VERIFY(rcond_est > rcond / 10 && rcond_est < rcond * 10);
 }
 
+// Regression test: FullPivLU took the maximum of an empty column-sum vector when computing its l1 norm,
+// so it could not be constructed at all from a matrix with zero columns. PartialPivLU already guarded the
+// same reduction. The determinant of an empty matrix is the empty product, 1.
+template <typename MatrixType>
+void lu_empty() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index n = 5;
+
+  FullPivLU<MatrixType> lu{MatrixType(0, 0)};
+  VERIFY_IS_EQUAL(lu.rank(), Index(0));
+  VERIFY(lu.isInvertible());
+  VERIFY_IS_EQUAL(lu.determinant(), Scalar(1));
+  VERIFY_IS_EQUAL(lu.absDeterminant(), RealScalar(1));
+  VERIFY_IS_EQUAL(lu.logAbsDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(lu.signDeterminant(), Scalar(1));
+
+  lu.compute(MatrixType(0, n));
+  VERIFY_IS_EQUAL(lu.rank(), Index(0));
+  VERIFY_IS_EQUAL(lu.dimensionOfKernel(), n);
+  VERIFY(!lu.isInjective());
+
+  lu.compute(MatrixType(n, 0));
+  VERIFY_IS_EQUAL(lu.rank(), Index(0));
+  VERIFY_IS_EQUAL(lu.dimensionOfKernel(), Index(0));
+  VERIFY(!lu.isSurjective());
+
+  PartialPivLU<MatrixType> plu{MatrixType(0, 0)};
+  VERIFY_IS_EQUAL(plu.determinant(), Scalar(1));
+  VERIFY_IS_EQUAL(plu.absDeterminant(), RealScalar(1));
+  VERIFY_IS_EQUAL(plu.logAbsDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(plu.signDeterminant(), Scalar(1));
+}
+
+// A = Q D Q^*, with Q unitary, has det(A) = det(D) because det(Q) det(Q^*) = |det(Q)|^2 = 1.
+template <typename MatrixType>
+void lu_determinant(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  MatrixType d = MatrixType::Zero(size, size);
+  setRandomWellConditionedDiagonal(d);
+  const MatrixType q = MatrixType::Random(size, size).householderQr().householderQ();
+  const MatrixType a = q * d * q.adjoint();
+
+  const Scalar det = d.diagonal().prod();
+  const RealScalar logabsdet = d.diagonal().cwiseAbs().array().log().sum();
+
+  check_determinant(FullPivLU<MatrixType>(a), det, logabsdet);
+  check_determinant(PartialPivLU<MatrixType>(a), det, logabsdet);
+}
+
+// logAbsDeterminant() exists to survive the range where the determinant itself does not: with n = 200 and
+// a diagonal of 10^4, det = 10^800 overflows every supported float type while log|det| = 800 log 10 does not.
+template <typename MatrixType>
+void lu_determinant_overflow() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  const Index size = 200;
+  for (bool overflow : {true, false}) {
+    const RealScalar scale = overflow ? RealScalar(1e4) : RealScalar(1e-4);
+    const MatrixType a = MatrixType::Identity(size, size) * Scalar(scale);
+    const RealScalar logabsdet = RealScalar(size) * numext::log(scale);
+
+    PartialPivLU<MatrixType> plu(a);
+    VERIFY(determinant_out_of_range(plu.absDeterminant(), overflow));
+    VERIFY_IS_APPROX(plu.logAbsDeterminant(), logabsdet);
+    VERIFY_IS_EQUAL(plu.signDeterminant(), Scalar(1));
+
+    FullPivLU<MatrixType> lu(a);
+    VERIFY(determinant_out_of_range(lu.absDeterminant(), overflow));
+    VERIFY_IS_APPROX(lu.logAbsDeterminant(), logabsdet);
+    VERIFY_IS_EQUAL(lu.signDeterminant(), Scalar(1));
+  }
+}
+
+// A rank-deficient decomposition has no determinant worth reporting, and FullPivLU is the one LU that
+// knows it. The three accessors that can express that gate on rank, so they agree with the rank-revealing
+// QR decompositions; determinant() keeps its documented behaviour of returning the pivot product.
+template <typename MatrixType>
+void lu_determinant_rank_deficient(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  const Index rank = internal::random<Index>(1, size - 1);
+  MatrixType a(size, size);
+  createRandomPIMatrixOfRank(rank, size, size, a);
+
+  // The generated singular values are 0 or 1, so any threshold well inside that gap recovers the rank.
+  const RealScalar threshold(0.01);
+
+  FullPivLU<MatrixType> lu;
+  lu.setThreshold(threshold);
+  lu.compute(a);
+  VERIFY_IS_EQUAL(lu.rank(), rank);
+  VERIFY(!lu.isInvertible());
+  VERIFY_IS_EQUAL(lu.absDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(lu.logAbsDeterminant(), -NumTraits<RealScalar>::infinity());
+  VERIFY_IS_EQUAL(lu.signDeterminant(), Scalar(0));
+
+  ColPivHouseholderQR<MatrixType> qr;
+  qr.setThreshold(threshold);
+  qr.compute(a);
+  VERIFY_IS_EQUAL(qr.rank(), rank);
+  VERIFY_IS_EQUAL(qr.absDeterminant(), lu.absDeterminant());
+  VERIFY_IS_EQUAL(qr.logAbsDeterminant(), lu.logAbsDeterminant());
+  VERIFY_IS_EQUAL(qr.signDeterminant(), lu.signDeterminant());
+
+  // determinant() is deliberately not gated. Pin that on a matrix whose smallest pivot is below the
+  // threshold but nonzero, where the two answers are visibly different rather than both roundoff.
+  MatrixType b = MatrixType::Identity(size, size);
+  b(size - 1, size - 1) = Scalar(RealScalar(1e-30));
+  FullPivLU<MatrixType> blu;
+  blu.setThreshold(RealScalar(1e-3));
+  blu.compute(b);
+  VERIFY_IS_EQUAL(blu.rank(), size - 1);
+  VERIFY_IS_EQUAL(blu.absDeterminant(), RealScalar(0));
+  VERIFY_IS_EQUAL(blu.logAbsDeterminant(), -NumTraits<RealScalar>::infinity());
+  VERIFY_IS_EQUAL(blu.signDeterminant(), Scalar(0));
+  VERIFY_IS_APPROX(numext::abs(blu.determinant()), RealScalar(1e-30));
+}
+
 template <typename MatrixType>
 void lu_verify_assert() {
   MatrixType tmp;
@@ -178,6 +299,9 @@
   VERIFY_RAISES_ASSERT(lu.transpose().solve(tmp))
   VERIFY_RAISES_ASSERT(lu.adjoint().solve(tmp))
   VERIFY_RAISES_ASSERT(lu.determinant())
+  VERIFY_RAISES_ASSERT(lu.absDeterminant())
+  VERIFY_RAISES_ASSERT(lu.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(lu.signDeterminant())
   VERIFY_RAISES_ASSERT(lu.rank())
   VERIFY_RAISES_ASSERT(lu.dimensionOfKernel())
   VERIFY_RAISES_ASSERT(lu.isInjective())
@@ -192,6 +316,9 @@
   VERIFY_RAISES_ASSERT(plu.transpose().solve(tmp))
   VERIFY_RAISES_ASSERT(plu.adjoint().solve(tmp))
   VERIFY_RAISES_ASSERT(plu.determinant())
+  VERIFY_RAISES_ASSERT(plu.absDeterminant())
+  VERIFY_RAISES_ASSERT(plu.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(plu.signDeterminant())
   VERIFY_RAISES_ASSERT(plu.inverse())
 }
 
@@ -218,7 +345,169 @@
   VERIFY_IS_EQUAL(rcond, 0.0);
 }
 
+// Test LU decomposition at blocking and vectorization boundaries.
+// PartialPivLU uses blocks of size max(8, min(size/8 rounded to 16, 256)).
+// Sizes near these boundaries exercise transitions between full blocks
+// and remainder tails, including pivot propagation across block edges.
+template <typename Scalar>
+void lu_blocking_boundary() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+
+  const Index PS = internal::packet_traits<Scalar>::size;
+  const Index sizes[] = {1, 2, 3,  PS - 1, PS, PS + 1, 2 * PS - 1, 2 * PS, 2 * PS + 1, 4 * PS, 4 * PS + 1, 7,
+                         8, 9, 15, 16,     17, 31,     32,         33,     63,         64,     65};
+  for (Index si = 0; si < Index(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    Index n = sizes[si];
+    if (n < 1) continue;
+
+    // Create a diagonally dominant (invertible) matrix.
+    MatrixType m = MatrixType::Random(n, n);
+    m.diagonal().array() += RealScalar(2 * n);
+
+    // PartialPivLU
+    PartialPivLU<MatrixType> plu(m);
+    VERIFY_IS_APPROX(m, plu.reconstructedMatrix());
+    MatrixType rhs = MatrixType::Random(n, 3);
+    MatrixType x = plu.solve(rhs);
+    VERIFY_IS_APPROX(m * x, rhs);
+
+    // FullPivLU
+    FullPivLU<MatrixType> flu(m);
+    VERIFY_IS_APPROX(m, flu.reconstructedMatrix());
+    VERIFY(flu.isInvertible());
+    x = flu.solve(rhs);
+    VERIFY_IS_APPROX(m * x, rhs);
+  }
+
+  // Non-square matrices at boundary sizes for FullPivLU.
+  const Index rect_sizes[][2] = {{PS, 2 * PS}, {2 * PS, PS}, {15, 33}, {33, 15}, {1, 5}, {5, 1}};
+  for (Index si = 0; si < Index(sizeof(rect_sizes) / sizeof(rect_sizes[0])); ++si) {
+    Index rows = rect_sizes[si][0];
+    Index cols = rect_sizes[si][1];
+    MatrixType m = MatrixType::Random(rows, cols);
+    FullPivLU<MatrixType> flu(m);
+    VERIFY_IS_APPROX(m, flu.reconstructedMatrix());
+  }
+}
+
+// Test PartialPivLU with RowMajor storage order at blocking boundaries.
+template <typename Scalar>
+void lu_rowmajor_boundary() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMatrixType;
+
+  const Index sizes[] = {7, 8, 9, 15, 16, 17, 31, 32, 33};
+  for (Index si = 0; si < Index(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    Index n = sizes[si];
+    RowMatrixType m = RowMatrixType::Random(n, n);
+    m.diagonal().array() += RealScalar(2 * n);
+    PartialPivLU<RowMatrixType> plu(m);
+    VERIFY_IS_APPROX(m, plu.reconstructedMatrix());
+  }
+}
+
+template <typename Scalar, int StorageOrder>
+void lu_strided_pivots() {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  for (Index n : {17, 32, 33, 127, 128, 129, 256, 512}) {
+    Mat a = Mat::Random(n, n);
+    // A cyclic permutation forces overlapping row swaps across panel boundaries.
+    const Index shift = n / 2 + 1;
+    a.bottomLeftCorner(n - shift, n - shift).diagonal().array() += RealScalar(2 * n);
+    a.topRightCorner(shift, shift).diagonal().array() += RealScalar(2 * n);
+    for (Index padding : {0, 7}) {
+      const Index stride = n + padding;
+      Matrix<Scalar, Dynamic, 1> storage = Matrix<Scalar, Dynamic, 1>::Constant(stride * n + 2, Scalar(7));
+      Map<Mat, 0, OuterStride<>> work(storage.data() + 1, n, n, OuterStride<>(stride));
+      work = a;
+      PartialPivLU<Ref<Mat>> lu(work);
+      VERIFY_IS_EQUAL(lu.matrixLU().data(), work.data());
+      const RealScalar bound = RealScalar(32 * n) * NumTraits<RealScalar>::epsilon() * a.norm();
+      const Mat lower = work.template triangularView<UnitLower>();
+      const Mat upper = work.template triangularView<Upper>();
+      VERIFY((lu.permutationP() * a - lower * upper).norm() <= bound);
+      VERIFY_IS_EQUAL(lu.permutationP().indices()[0], n - shift);
+      VERIFY_IS_EQUAL(storage[0], Scalar(7));
+      VERIFY_IS_EQUAL(storage[storage.size() - 1], Scalar(7));
+      for (Index j = 0; j < n; ++j)
+        for (Index i = n; i < stride; ++i) VERIFY_IS_EQUAL(storage[1 + j * stride + i], Scalar(7));
+    }
+  }
+}
+
+template <typename Scalar, int Options>
+void lu_subspace_expressions() {
+  using Mat = Matrix<Scalar, 4, 4, Options>;
+  Mat original = Mat::Zero();
+  original(0, 3) = Scalar(8);
+  original(2, 1) = Scalar(2);
+  original(2, 2) = Scalar(1);
+  FullPivLU<Mat, long> lu(original);
+  const auto kernel = lu.kernel();
+  const auto image = lu.image(original);
+  using KernelMatrix = typename decltype(kernel)::PlainObject;
+  using ImageMatrix = typename decltype(image)::PlainObject;
+  STATIC_CHECK(KernelMatrix::RowsAtCompileTime == 4);
+  STATIC_CHECK(KernelMatrix::MaxColsAtCompileTime == 4);
+  STATIC_CHECK(ImageMatrix::RowsAtCompileTime == 4);
+  STATIC_CHECK(ImageMatrix::MaxColsAtCompileTime == 4);
+  STATIC_CHECK(KernelMatrix::IsRowMajor == (Options == RowMajor));
+  STATIC_CHECK(ImageMatrix::IsRowMajor == (Options == RowMajor));
+
+  VERIFY_IS_EQUAL(kernel.rows(), 4);
+  VERIFY_IS_EQUAL(kernel.cols(), 2);
+  VERIFY_IS_EQUAL(image.rows(), 4);
+  VERIFY_IS_EQUAL(image.cols(), 2);
+  const KernelMatrix nullspace = kernel;
+  const ImageMatrix range = image;
+  VERIFY_IS_EQUAL(nullspace.fullPivLu().rank(), 2);
+  VERIFY_IS_EQUAL((original * kernel).norm(), typename Mat::RealScalar(0));
+  VERIFY_IS_APPROX(kernel + kernel, Scalar(2) * nullspace);
+  VERIFY_IS_APPROX(image + image, Scalar(2) * range);
+  VERIFY_IS_APPROX(range.col(0), original.col(3));
+  VERIFY_IS_APPROX(range.col(1), original.col(1));
+
+  Mat destination = Mat::Constant(Scalar(7));
+  destination.template leftCols<2>() = kernel;
+  destination.template rightCols<2>() = image;
+  VERIFY_IS_APPROX(destination.template leftCols<2>(), nullspace);
+  VERIFY_IS_APPROX(destination.template rightCols<2>(), range);
+
+  Mat factorStorage = original;
+  FullPivLU<Ref<Mat>, long> inplace(factorStorage);
+  factorStorage.template middleCols<2>(1) = inplace.image(original);
+  VERIFY_IS_APPROX(factorStorage.template middleCols<2>(1), range);
+
+  original.setZero();
+  lu.compute(original);
+  VERIFY_IS_EQUAL(lu.image(original).cols(), 1);
+  VERIFY_IS_EQUAL(lu.image(original).eval().norm(), typename Mat::RealScalar(0));
+  VERIFY_IS_APPROX(lu.kernel(), Mat::Identity());
+  original.setIdentity();
+  lu.compute(original);
+  VERIFY_IS_EQUAL(lu.kernel().cols(), 1);
+  VERIFY_IS_EQUAL(lu.kernel().eval().norm(), typename Mat::RealScalar(0));
+  VERIFY_IS_APPROX(lu.image(original), original);
+
+  // The pivots are 8, 1, -2, 0: thresholding must select columns 0 and 2, not a prefix.
+  original.setZero();
+  original(0, 0) = Scalar(8);
+  original.template block<2, 2>(1, 1) << Scalar(1), Scalar(1), Scalar(1), Scalar(-1);
+  lu.compute(original).setThreshold(typename Mat::RealScalar(0.1875));
+  VERIFY_IS_EQUAL(lu.rank(), 2);
+  const ImageMatrix thresholded = lu.image(original);
+  VERIFY_IS_APPROX(thresholded.col(0), original.col(0));
+  VERIFY_IS_APPROX(thresholded.col(1), original.col(2));
+}
+
 EIGEN_DECLARE_TEST(lu) {
+  CALL_SUBTEST_16((lu_subspace_expressions<float, ColMajor>()));
+  CALL_SUBTEST_16((lu_subspace_expressions<double, RowMajor>()));
+  CALL_SUBTEST_16((lu_subspace_expressions<std::complex<float>, RowMajor>()));
+  CALL_SUBTEST_16((lu_subspace_expressions<std::complex<double>, ColMajor>()));
+
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(lu_non_invertible<Matrix3f>());
     CALL_SUBTEST_1(lu_invertible<Matrix3f>());
@@ -234,20 +523,29 @@
     CALL_SUBTEST_3(lu_non_invertible<MatrixXf>());
     CALL_SUBTEST_3(lu_invertible<MatrixXf>());
     CALL_SUBTEST_3(lu_verify_assert<MatrixXf>());
+    CALL_SUBTEST_3(lu_determinant<MatrixXf>(internal::random<int>(1, 30)));
 
     CALL_SUBTEST_4(lu_non_invertible<MatrixXd>());
     CALL_SUBTEST_4(lu_invertible<MatrixXd>());
     CALL_SUBTEST_4(lu_partial_piv<MatrixXd>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
     CALL_SUBTEST_4(lu_verify_assert<MatrixXd>());
+    CALL_SUBTEST_4(lu_empty<MatrixXd>());
+    CALL_SUBTEST_4(lu_determinant<MatrixXd>(internal::random<int>(1, 30)));
+    CALL_SUBTEST_4(lu_determinant_rank_deficient<MatrixXd>(internal::random<int>(2, 30)));
+    CALL_SUBTEST_3(lu_determinant_overflow<MatrixXf>());
 
     CALL_SUBTEST_5(lu_non_invertible<MatrixXcf>());
     CALL_SUBTEST_5(lu_invertible<MatrixXcf>());
     CALL_SUBTEST_5(lu_verify_assert<MatrixXcf>());
+    CALL_SUBTEST_5(lu_determinant<MatrixXcf>(internal::random<int>(1, 30)));
 
     CALL_SUBTEST_6(lu_non_invertible<MatrixXcd>());
     CALL_SUBTEST_6(lu_invertible<MatrixXcd>());
     CALL_SUBTEST_6(lu_partial_piv<MatrixXcd>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
     CALL_SUBTEST_6(lu_verify_assert<MatrixXcd>());
+    CALL_SUBTEST_6(lu_empty<MatrixXcd>());
+    CALL_SUBTEST_6(lu_determinant<MatrixXcd>(internal::random<int>(1, 30)));
+    CALL_SUBTEST_6(lu_determinant_rank_deficient<MatrixXcd>(internal::random<int>(2, 30)));
 
     CALL_SUBTEST_7((lu_non_invertible<Matrix<float, Dynamic, 16> >()));
 
@@ -257,4 +555,19 @@
 
     CALL_SUBTEST_9(test_2889());
   }
+
+  CALL_SUBTEST_10((lu_strided_pivots<float, ColMajor>()));
+  CALL_SUBTEST_11((lu_strided_pivots<double, ColMajor>()));
+  CALL_SUBTEST_12((lu_strided_pivots<std::complex<float>, ColMajor>()));
+  CALL_SUBTEST_13((lu_strided_pivots<std::complex<double>, ColMajor>()));
+  CALL_SUBTEST_14((lu_strided_pivots<double, RowMajor>()));
+  CALL_SUBTEST_15((lu_strided_pivots<std::complex<double>, RowMajor>()));
+
+  // Blocking and vectorization boundary tests (deterministic, outside g_repeat).
+  CALL_SUBTEST_3(lu_blocking_boundary<float>());
+  CALL_SUBTEST_4(lu_blocking_boundary<double>());
+  CALL_SUBTEST_5(lu_blocking_boundary<std::complex<float> >());
+  CALL_SUBTEST_6(lu_blocking_boundary<std::complex<double> >());
+  CALL_SUBTEST_4(lu_rowmajor_boundary<double>());
+  CALL_SUBTEST_5(lu_rowmajor_boundary<std::complex<float> >());
 }
diff --git a/test/main.h b/test/main.h
index 7ba0dc8..75a05cb 100644
--- a/test/main.h
+++ b/test/main.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include <cstdlib>
 #include <cerrno>
@@ -52,10 +53,13 @@
 #include <queue>
 #include <cassert>
 #include <list>
-#if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L)
 #include <random>
 #include <chrono>
-#endif
+// libstdc++'s <unordered_map> uses std::numeric_limits<size_t>::max() internally
+// (in <bits/hashtable_policy.h>); pre-include here so the macro definitions of
+// min/max below don't break it on toolchains where it isn't pulled in by
+// another pre-included header (e.g. cuda-11.5 / gcc-10).
+#include <unordered_map>
 #if __cplusplus > 201703L
 // libstdc++ 9's <memory> indirectly uses max() via <bit>.
 // libstdc++ 10's <memory> indirectly uses max() via ranges headers.
@@ -76,10 +80,8 @@
 #include <cuda.h>
 #include <cuda_runtime.h>
 #include <cuda_runtime_api.h>
-#if CUDA_VERSION >= 7050
 #include <cuda_fp16.h>
 #endif
-#endif
 
 #if defined(EIGEN_CUDACC) || defined(EIGEN_HIPCC)
 #define EIGEN_TEST_NO_LONGDOUBLE
@@ -130,8 +132,15 @@
 // _res is defined by resolv.h
 #define _res FORBIDDEN_IDENTIFIER
 
-// Unit tests calling Eigen's blas library must preserve the default blocking size
-// to avoid troubles.
+// Shrink the cache model used by computeProductBlockingSizes so that test-sized
+// products (see EIGEN_TEST_MAX_SIZE) exercise multi-pass GEMM blocking; with real
+// cache sizes nothing in the suite would ever block. Any new architecture-specific
+// blocking heuristic must honor this macro, or the blocking sentinels in
+// product_extra.cpp (compute_block_size) will fail on that target.
+// Exception: tests linking the eigen_blas/eigen_lapack shim libraries (the
+// *_support sparse-solver tests) must opt out via EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS.
+// Those libraries are compiled without this macro, and mixing the two configurations
+// in one binary is an ODR violation on the inline blocking/kernel code.
 #ifndef EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #define EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
 #endif
@@ -224,8 +233,6 @@
   void EIGEN_CAT(test_, X)()
 }  // namespace Eigen
 
-#define TRACK std::cerr << __FILE__ << " " << __LINE__ << std::endl
-
 #define EIGEN_DEFAULT_IO_FORMAT IOFormat(4, 0, "  ", "\n", "", "", "", "")
 
 #if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(__CUDA_ARCH__) && !defined(__HIP_DEVICE_COMPILE__) && \
@@ -330,10 +337,6 @@
 #define VERIFY_RAISES_ASSERT(a) std::cout << "Can't VERIFY_RAISES_ASSERT( " #a " ) with exceptions disabled\n";
 #endif
 
-#if !defined(__CUDACC__) && !defined(__HIPCC__) && !defined(SYCL_DEVICE_ONLY)
-#define EIGEN_USE_CUSTOM_ASSERT
-#endif
-
 #else  // EIGEN_NO_ASSERTION_CHECKING
 
 #define VERIFY_RAISES_ASSERT(a) \
@@ -365,19 +368,6 @@
 #define VERIFY_GE(a, b) ::verify_impl(a >= b, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a >= b))
 #define VERIFY_LE(a, b) ::verify_impl(a <= b, g_test_stack.back().c_str(), __FILE__, __LINE__, EIGEN_MAKESTRING(a <= b))
 
-#define VERIFY_IS_EQUAL(a, b) VERIFY(test_is_equal(a, b, true))
-#define VERIFY_IS_NOT_EQUAL(a, b) VERIFY(test_is_equal(a, b, false))
-#define VERIFY_IS_APPROX(a, b) VERIFY(verifyIsApprox(a, b))
-#define VERIFY_IS_NOT_APPROX(a, b) VERIFY(!test_isApprox(a, b))
-#define VERIFY_IS_MUCH_SMALLER_THAN(a, b) VERIFY(test_isMuchSmallerThan(a, b))
-#define VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b) VERIFY(!test_isMuchSmallerThan(a, b))
-#define VERIFY_IS_APPROX_OR_LESS_THAN(a, b) VERIFY(test_isApproxOrLessThan(a, b))
-#define VERIFY_IS_NOT_APPROX_OR_LESS_THAN(a, b) VERIFY(!test_isApproxOrLessThan(a, b))
-#define VERIFY_IS_CWISE_EQUAL(a, b) VERIFY(verifyIsCwiseApprox(a, b, true))
-#define VERIFY_IS_CWISE_APPROX(a, b) VERIFY(verifyIsCwiseApprox(a, b, false))
-
-#define VERIFY_IS_UNITARY(a) VERIFY(test_isUnitary(a))
-
 #define STATIC_CHECK(COND) EIGEN_STATIC_ASSERT((COND), EIGEN_INTERNAL_ERROR_PLEASE_FILE_A_BUG_REPORT)
 
 #define CALL_SUBTEST(FUNC)                          \
@@ -387,444 +377,11 @@
     g_test_stack.pop_back();                        \
   } while (0)
 
-// Forward declarations to avoid ICC warnings
-#if EIGEN_COMP_ICC
-
-template <typename T>
-std::string type_name();
-
-namespace Eigen {
-
-template <typename T, typename U>
-bool test_is_equal(const T& actual, const U& expected, bool expect_equal = true);
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_COMP_ICC
-
-namespace Eigen {
-
-template <typename T1, typename T2>
-std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_type(const T1&, const T2&) {
-  return true;
-}
-
-template <typename T>
-inline typename NumTraits<T>::Real test_precision() {
-  return NumTraits<T>::dummy_precision();
-}
-template <>
-inline float test_precision<float>() {
-  return 1e-3f;
-}
-template <>
-inline double test_precision<double>() {
-  return 1e-6;
-}
-template <>
-inline long double test_precision<long double>() {
-  return 1e-6l;
-}
-template <>
-inline float test_precision<std::complex<float> >() {
-  return test_precision<float>();
-}
-template <>
-inline double test_precision<std::complex<double> >() {
-  return test_precision<double>();
-}
-template <>
-inline long double test_precision<std::complex<long double> >() {
-  return test_precision<long double>();
-}
-
-#define EIGEN_TEST_SCALAR_TEST_OVERLOAD(TYPE)                                          \
-  inline bool test_isApprox(TYPE a, TYPE b) {                                          \
-    return numext::equal_strict(a, b) || ((numext::isnan)(a) && (numext::isnan)(b)) || \
-           (internal::isApprox(a, b, test_precision<TYPE>()));                         \
-  }                                                                                    \
-  inline bool test_isCwiseApprox(TYPE a, TYPE b, bool exact) {                         \
-    return numext::equal_strict(a, b) || ((numext::isnan)(a) && (numext::isnan)(b)) || \
-           (!exact && internal::isApprox(a, b, test_precision<TYPE>()));               \
-  }                                                                                    \
-  inline bool test_isMuchSmallerThan(TYPE a, TYPE b) {                                 \
-    return internal::isMuchSmallerThan(a, b, test_precision<TYPE>());                  \
-  }                                                                                    \
-  inline bool test_isApproxOrLessThan(TYPE a, TYPE b) {                                \
-    return internal::isApproxOrLessThan(a, b, test_precision<TYPE>());                 \
-  }
-
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(short)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned short)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(int)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned int)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(long)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned long)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(long long)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned long long)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(float)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(double)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(half)
-EIGEN_TEST_SCALAR_TEST_OVERLOAD(bfloat16)
-
-#undef EIGEN_TEST_SCALAR_TEST_OVERLOAD
-
-#ifndef EIGEN_TEST_NO_COMPLEX
-inline bool test_isApprox(const std::complex<float>& a, const std::complex<float>& b) {
-  return internal::isApprox(a, b, test_precision<std::complex<float> >());
-}
-inline bool test_isMuchSmallerThan(const std::complex<float>& a, const std::complex<float>& b) {
-  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<float> >());
-}
-
-inline bool test_isApprox(const std::complex<double>& a, const std::complex<double>& b) {
-  return internal::isApprox(a, b, test_precision<std::complex<double> >());
-}
-inline bool test_isMuchSmallerThan(const std::complex<double>& a, const std::complex<double>& b) {
-  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<double> >());
-}
-
-#ifndef EIGEN_TEST_NO_LONGDOUBLE
-inline bool test_isApprox(const std::complex<long double>& a, const std::complex<long double>& b) {
-  return internal::isApprox(a, b, test_precision<std::complex<long double> >());
-}
-inline bool test_isMuchSmallerThan(const std::complex<long double>& a, const std::complex<long double>& b) {
-  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<long double> >());
-}
-#endif
-#endif
-
-#ifndef EIGEN_TEST_NO_LONGDOUBLE
-inline bool test_isApprox(const long double& a, const long double& b) {
-  bool ret = internal::isApprox(a, b, test_precision<long double>());
-  if (!ret)
-    std::cerr << std::endl << "    actual   = " << a << std::endl << "    expected = " << b << std::endl << std::endl;
-  return ret;
-}
-
-inline bool test_isMuchSmallerThan(const long double& a, const long double& b) {
-  return internal::isMuchSmallerThan(a, b, test_precision<long double>());
-}
-inline bool test_isApproxOrLessThan(const long double& a, const long double& b) {
-  return internal::isApproxOrLessThan(a, b, test_precision<long double>());
-}
-#endif  // EIGEN_TEST_NO_LONGDOUBLE
-
-// test_relative_error returns the relative difference between a and b as a real scalar as used in isApprox.
-template <typename T1, typename T2>
-typename NumTraits<typename T1::RealScalar>::NonInteger test_relative_error(const EigenBase<T1>& a,
-                                                                            const EigenBase<T2>& b) {
-  using std::sqrt;
-  typedef typename NumTraits<typename T1::RealScalar>::NonInteger RealScalar;
-  typename internal::nested_eval<T1, 2>::type ea(a.derived());
-  typename internal::nested_eval<T2, 2>::type eb(b.derived());
-  return sqrt(RealScalar((ea.matrix() - eb.matrix()).cwiseAbs2().sum()) /
-              RealScalar((std::min)(eb.cwiseAbs2().sum(), ea.cwiseAbs2().sum())));
-}
-
-template <typename T1, typename T2>
-typename T1::RealScalar test_relative_error(const T1& a, const T2& b, const typename T1::Coefficients* = 0) {
-  return test_relative_error(a.coeffs(), b.coeffs());
-}
-
-template <typename T1, typename T2>
-typename T1::Scalar test_relative_error(const T1& a, const T2& b, const typename T1::MatrixType* = 0) {
-  return test_relative_error(a.matrix(), b.matrix());
-}
-
-template <typename S, int D>
-S test_relative_error(const Translation<S, D>& a, const Translation<S, D>& b) {
-  return test_relative_error(a.vector(), b.vector());
-}
-
-template <typename S, int D, int O>
-S test_relative_error(const ParametrizedLine<S, D, O>& a, const ParametrizedLine<S, D, O>& b) {
-  return (std::max)(test_relative_error(a.origin(), b.origin()), test_relative_error(a.origin(), b.origin()));
-}
-
-template <typename S, int D>
-S test_relative_error(const AlignedBox<S, D>& a, const AlignedBox<S, D>& b) {
-  return (std::max)(test_relative_error((a.min)(), (b.min)()), test_relative_error((a.max)(), (b.max)()));
-}
-
-template <typename Derived>
-class SparseMatrixBase;
-template <typename T1, typename T2>
-typename T1::RealScalar test_relative_error(const MatrixBase<T1>& a, const SparseMatrixBase<T2>& b) {
-  return test_relative_error(a, b.toDense());
-}
-
-template <typename Derived>
-class SparseMatrixBase;
-template <typename T1, typename T2>
-typename T1::RealScalar test_relative_error(const SparseMatrixBase<T1>& a, const MatrixBase<T2>& b) {
-  return test_relative_error(a.toDense(), b);
-}
-
-template <typename Derived>
-class SparseMatrixBase;
-template <typename T1, typename T2>
-typename T1::RealScalar test_relative_error(const SparseMatrixBase<T1>& a, const SparseMatrixBase<T2>& b) {
-  return test_relative_error(a.toDense(), b.toDense());
-}
-
-template <typename T1, typename T2>
-typename NumTraits<typename NumTraits<T1>::Real>::NonInteger test_relative_error(
-    const T1& a, const T2& b, std::enable_if_t<internal::is_arithmetic<typename NumTraits<T1>::Real>::value, T1>* = 0) {
-  typedef typename NumTraits<typename NumTraits<T1>::Real>::NonInteger RealScalar;
-  return numext::sqrt(RealScalar(numext::abs2(a - b)) /
-                      (numext::mini)(RealScalar(numext::abs2(a)), RealScalar(numext::abs2(b))));
-}
-
-template <typename T>
-T test_relative_error(const Rotation2D<T>& a, const Rotation2D<T>& b) {
-  return test_relative_error(a.angle(), b.angle());
-}
-
-template <typename T>
-T test_relative_error(const AngleAxis<T>& a, const AngleAxis<T>& b) {
-  return (std::max)(test_relative_error(a.angle(), b.angle()), test_relative_error(a.axis(), b.axis()));
-}
-
-template <typename Type1, typename Type2>
-inline bool test_isApprox(const Type1& a, const Type2& b, typename Type1::Scalar* = 0)  // Enabled for Eigen's type only
-{
-  return a.isApprox(b, test_precision<typename Type1::Scalar>());
-}
-
-// get_test_precision is a small wrapper to test_precision allowing to return the scalar precision for either scalars or
-// expressions
-template <typename T>
-typename NumTraits<typename T::Scalar>::Real get_test_precision(const T&, const typename T::Scalar* = 0) {
-  return test_precision<typename NumTraits<typename T::Scalar>::Real>();
-}
-
-template <typename T>
-typename NumTraits<T>::Real get_test_precision(
-    const T&, std::enable_if_t<internal::is_arithmetic<typename NumTraits<T>::Real>::value, T>* = 0) {
-  return test_precision<typename NumTraits<T>::Real>();
-}
-
-// verifyIsApprox is a wrapper to test_isApprox that outputs the relative difference magnitude if the test fails.
-template <typename Type1, typename Type2>
-inline bool verifyIsApprox(const Type1& a, const Type2& b) {
-  bool ret = test_isApprox(a, b);
-  if (!ret) {
-    std::cerr << "Difference too large wrt tolerance " << get_test_precision(a)
-              << ", relative error is: " << test_relative_error(a, b) << std::endl;
-  }
-  return ret;
-}
-
-// verifyIsCwiseApprox is a wrapper to test_isCwiseApprox that outputs the relative difference magnitude if the test
-// fails.
-template <typename Type1, typename Type2>
-inline bool verifyIsCwiseApprox(const Type1& a, const Type2& b, bool exact) {
-  bool ret = test_isCwiseApprox(a, b, exact);
-  if (!ret) {
-    if (exact) {
-      std::cerr << "Values are not an exact match";
-    } else {
-      std::cerr << "Difference too large wrt tolerance " << get_test_precision(a);
-    }
-    std::cerr << ", relative error is: " << test_relative_error(a, b) << std::endl;
-  }
-  return ret;
-}
-
-// The idea behind this function is to compare the two scalars a and b where
-// the scalar ref is a hint about the expected order of magnitude of a and b.
-// WARNING: the scalar a and b must be positive
-// Therefore, if a and b happen to be very small compared to ref,
-// we won't issue a false negative.
-// This test could be: abs(a-b) <= eps * ref
-// However, it seems that simply comparing a+ref and b+ref is more sensitive to true error.
-template <typename Scalar, typename ScalarRef>
-inline bool test_isApproxWithRef(const Scalar& a, const Scalar& b, const ScalarRef& ref) {
-  return test_isApprox(a + ref, b + ref);
-}
-
-template <typename Derived1, typename Derived2>
-inline bool test_isMuchSmallerThan(const MatrixBase<Derived1>& m1, const MatrixBase<Derived2>& m2) {
-  return m1.isMuchSmallerThan(m2, test_precision<typename internal::traits<Derived1>::Scalar>());
-}
-
-template <typename Derived>
-inline bool test_isMuchSmallerThan(const MatrixBase<Derived>& m,
-                                   const typename NumTraits<typename internal::traits<Derived>::Scalar>::Real& s) {
-  return m.isMuchSmallerThan(s, test_precision<typename internal::traits<Derived>::Scalar>());
-}
-
-template <typename Derived>
-inline bool test_isUnitary(const MatrixBase<Derived>& m) {
-  return m.isUnitary(test_precision<typename internal::traits<Derived>::Scalar>());
-}
-
-// Checks component-wise, works with infs and nans.
-template <typename Derived1, typename Derived2>
-bool test_isCwiseApprox(const DenseBase<Derived1>& m1, const DenseBase<Derived2>& m2, bool exact) {
-  if (m1.rows() != m2.rows()) {
-    return false;
-  }
-  if (m1.cols() != m2.cols()) {
-    return false;
-  }
-  for (Index r = 0; r < m1.rows(); ++r) {
-    for (Index c = 0; c < m1.cols(); ++c) {
-      if (m1(r, c) != m2(r, c) && !((numext::isnan)(m1(r, c)) && (numext::isnan)(m2(r, c))) &&
-          (exact || !test_isApprox(m1(r, c), m2(r, c)))) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-template <typename Derived1, typename Derived2>
-bool test_isCwiseApprox(const SparseMatrixBase<Derived1>& m1, const SparseMatrixBase<Derived2>& m2, bool exact) {
-  return test_isCwiseApprox(m1.toDense(), m2.toDense(), exact);
-}
-
-template <typename T, typename U>
-bool test_is_equal(const T& actual, const U& expected, bool expect_equal) {
-  if (numext::equal_strict(actual, expected) == expect_equal) return true;
-  // false:
-  std::cerr << "\n    actual   = " << actual << "\n    expected " << (expect_equal ? "= " : "!=") << expected << "\n\n";
-  return false;
-}
-
-/**
- * Check if number is "not a number" (NaN).
- *
- * @tparam T input type
- * @param x input value
- * @return true, if input value is "not a number" (NaN)
- */
-template <typename T>
-bool isNotNaN(const T& x) {
-  return x == x;
-}
-
-/**
- * Check if number is plus infinity.
- *
- * @tparam T input type
- * @param x input value
- * @return true, if input value is plus infinity
- */
-template <typename T>
-bool isPlusInf(const T& x) {
-  return x > NumTraits<T>::highest();
-}
-
-/**
- * Check if number is minus infinity.
- *
- * @tparam T input type
- * @param x input value
- * @return true, if input value is minus infinity
- */
-template <typename T>
-bool isMinusInf(const T& x) {
-  return x < NumTraits<T>::lowest();
-}
-
-}  // end namespace Eigen
+#include "numerical_test_helpers.h"
 
 #include "random_matrix_helper.h"
 
-template <typename T>
-struct GetDifferentType;
-
-template <>
-struct GetDifferentType<float> {
-  typedef double type;
-};
-template <>
-struct GetDifferentType<double> {
-  typedef float type;
-};
-template <typename T>
-struct GetDifferentType<std::complex<T> > {
-  typedef std::complex<typename GetDifferentType<T>::type> type;
-};
-
-template <typename T>
-std::string type_name(T) {
-  return typeid(T).name();
-}
-template <>
-std::string type_name<float>(float) {
-  return "float";
-}
-template <>
-std::string type_name<double>(double) {
-  return "double";
-}
-template <>
-std::string type_name<long double>(long double) {
-  return "long double";
-}
-template <>
-std::string type_name<Eigen::half>(Eigen::half) {
-  return "half";
-}
-template <>
-std::string type_name<Eigen::bfloat16>(Eigen::bfloat16) {
-  return "bfloat16";
-}
-template <>
-std::string type_name<int8_t>(int8_t) {
-  return "int8_t";
-}
-template <>
-std::string type_name<int16_t>(int16_t) {
-  return "int16_t";
-}
-template <>
-std::string type_name<int32_t>(int32_t) {
-  return "int32_t";
-}
-template <>
-std::string type_name<int64_t>(int64_t) {
-  return "int64_t";
-}
-template <>
-std::string type_name<uint8_t>(uint8_t) {
-  return "uint8_t";
-}
-template <>
-std::string type_name<uint16_t>(uint16_t) {
-  return "uint16_t";
-}
-template <>
-std::string type_name<uint32_t>(uint32_t) {
-  return "uint32_t";
-}
-template <>
-std::string type_name<uint64_t>(uint64_t) {
-  return "uint64_t";
-}
-template <>
-std::string type_name<std::complex<float> >(std::complex<float>) {
-  return "complex<float>";
-}
-template <>
-std::string type_name<std::complex<double> >(std::complex<double>) {
-  return "complex<double>";
-}
-template <>
-std::string type_name<std::complex<long double> >(std::complex<long double>) {
-  return "complex<long double>";
-}
-template <>
-std::string type_name<std::complex<int> >(std::complex<int>) {
-  return "complex<int>";
-}
-template <typename T>
-std::string type_name() {
-  return type_name(T());
-}
+#include "type_test_helpers.h"
 
 using namespace Eigen;
 
@@ -864,6 +421,63 @@
   g_seed = static_cast<decltype(g_seed)>(ns);
 }
 
+// Reports the test as skipped and exits with 77, the code CTest maps to "skipped"
+// (SKIP_RETURN_CODE in cmake/EigenTesting.cmake).
+[[noreturn]] inline void skip_test(const char* reason) {
+  std::cout << "SKIP: " << reason << std::endl;
+  std::exit(77);
+}
+
+#if defined(EIGEN_USE_GPU)
+inline int maybe_skip_gpu_tests() {
+#if defined(EIGEN_USE_HIP)
+  int device_count = 0;
+  hipError_t status = hipGetDeviceCount(&device_count);
+  if (status != hipSuccess) {
+    std::cout << "SKIP: HIP GPU tests require a visible ROCm device. hipGetDeviceCount failed with: "
+              << hipGetErrorString(status) << std::endl;
+    return 77;
+  }
+  if (device_count <= 0) {
+    std::cout << "SKIP: HIP GPU tests require a visible ROCm device." << std::endl;
+    return 77;
+  }
+#elif defined(EIGEN_CUDACC)
+  int device_count = 0;
+  cudaError_t status = cudaGetDeviceCount(&device_count);
+  if (status != cudaSuccess) {
+    std::cout << "SKIP: CUDA GPU tests require a visible CUDA device. cudaGetDeviceCount failed with: "
+              << cudaGetErrorString(status) << std::endl;
+    return 77;
+  }
+  if (device_count <= 0) {
+    std::cout << "SKIP: CUDA GPU tests require a visible CUDA device." << std::endl;
+    return 77;
+  }
+#endif
+  return 0;
+}
+#endif
+
+// GCC's AddressSanitizer instrumentation relocates a function's locals into the fake stack it uses
+// for stack-use-after-return detection, and it lays that frame out on a 32-byte grid. A frame GCC
+// aligned to more than that then faults on its own aligned vector accesses, since vmovdqa64 raises
+// #GP off an address that is not 64-byte aligned. An AVX-512 build under ASan therefore dies with
+// a SEGV unrelated to the code under test, in whichever frame the layout happens to hit. Opt those
+// builds out of the fake stack; clang aligns its fake frames correctly and keeps the detector.
+// ASAN_OPTIONS from the environment still overrides this.
+//
+// The condition asks what alignment compiled stack objects require, which is
+// EIGEN_MAX_STATIC_ALIGN_BYTES rather than the dynamic-allocation bound EIGEN_MAX_ALIGN_BYTES --
+// the latter is only an upper bound for it, so it is 64 even in a default-ISA build that aligns no
+// local past 16. EIGEN_VECTORIZE_AVX512 is checked as well because the AVX-512 backend declares
+// EIGEN_ALIGN64 locals and spills 64-byte vectors unconditionally, whatever the user caps the
+// Eigen alignment macros at.
+#if defined(__SANITIZE_ADDRESS__) && EIGEN_COMP_GNUC_STRICT && \
+    (EIGEN_MAX_STATIC_ALIGN_BYTES > 32 || defined(EIGEN_VECTORIZE_AVX512))
+extern "C" const char* __asan_default_options() { return "detect_stack_use_after_return=0"; }
+#endif
+
 int main(int argc, char* argv[]) {
   g_has_set_repeat = false;
   g_has_set_seed = false;
@@ -912,6 +526,13 @@
   srand(g_seed);
   std::cout << "Repeating each test " << g_repeat << " times" << std::endl;
 
+#if defined(EIGEN_USE_GPU)
+  {
+    const int skip_code = maybe_skip_gpu_tests();
+    if (skip_code != 0) return skip_code;
+  }
+#endif
+
   VERIFY(EigenTest::all().size() > 0);
 
   for (std::size_t i = 0; i < EigenTest::all().size(); ++i) {
diff --git a/test/mapped_matrix.cpp b/test/mapped_matrix.cpp
index 71ecb34..a921c21 100644
--- a/test/mapped_matrix.cpp
+++ b/test/mapped_matrix.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 
 #define EIGEN_TESTMAP_MAX_SIZE 256
 
@@ -51,7 +53,7 @@
   typedef typename MatrixType::Scalar Scalar;
 
   Index rows = m.rows(), cols = m.cols(), size = rows * cols;
-  Scalar s1 = internal::random<Scalar>();
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>();
 
   // array1 and array2 -> aligned heap allocation
   Scalar* array1 = internal::aligned_new<Scalar>(size);
@@ -92,7 +94,7 @@
   map3.setZero();
   VERIFY_IS_EQUAL(map3, MatrixType::Zero(rows, cols));
 
-  map1 = MatrixType::Random(rows, cols);
+  map1 = random_for_arithmetic<MatrixType>(rows, cols);
   map2 = map1;
   map3 = map1;
   MatrixType ma1 = map1;
@@ -185,7 +187,7 @@
     if (n <= 0) continue;
     typedef Matrix<Scalar, Dynamic, 1> Vec;
     // InnerStride<2>: every other element
-    Vec data = Vec::Random(2 * n);
+    Vec data = random_for_arithmetic<Vec>(2 * n);
     Map<Vec, 0, InnerStride<2>> strided(data.data(), n);
 
     // Test assignment to/from strided map
@@ -197,7 +199,7 @@
     for (Index k = 0; k < n; ++k) VERIFY_IS_APPROX(result(k), Scalar(2) * data(2 * k));
 
     // Test strided map + dense vector
-    Vec other = Vec::Random(n);
+    Vec other = random_for_arithmetic<Vec>(n);
     Vec sum_result = strided + other;
     for (Index k = 0; k < n; ++k) VERIFY_IS_APPROX(sum_result(k), data(2 * k) + other(k));
 
@@ -222,7 +224,7 @@
     Index rows = inner_sizes[si];
     if (rows <= 0) continue;
     typedef Matrix<Scalar, Dynamic, 1> Vec;
-    Vec data = Vec::Random(outer_stride * cols);
+    Vec data = random_for_arithmetic<Vec>(outer_stride * cols);
     Map<Mat, 0, OuterStride<>> mapped(data.data(), rows, cols, OuterStride<>(outer_stride));
 
     // Test that mapped values match expected layout
@@ -237,7 +239,7 @@
     VERIFY_IS_APPROX(mapped.sum(), ref_sum);
 
     // Test matrix product with mapped matrix
-    Vec x = Vec::Random(cols);
+    Vec x = random_for_arithmetic<Vec>(cols);
     Vec y = mapped * x;
     Vec y_ref = dense * x;
     VERIFY_IS_APPROX(y, y_ref);
diff --git a/test/mapstaticmethods.cpp b/test/mapstaticmethods.cpp
index b18b24a..72904de 100644
--- a/test/mapstaticmethods.cpp
+++ b/test/mapstaticmethods.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/mapstride.cpp b/test/mapstride.cpp
index 1a9f50c..b951a6a 100644
--- a/test/mapstride.cpp
+++ b/test/mapstride.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 
 template <int Alignment, typename VectorType>
 void map_class_vector(const VectorType& m) {
@@ -53,8 +55,8 @@
 
   Index rows = _m.rows(), cols = _m.cols();
 
-  MatrixType m = MatrixType::Random(rows, cols);
-  Scalar s1 = internal::random<Scalar>();
+  MatrixType m = random_for_arithmetic<MatrixType>(rows, cols);
+  Scalar s1 = random_scalar_for_arithmetic<Scalar>();
 
   Index arraysize = 4 * (rows + 4) * (cols + 4);
 
diff --git a/test/matrix_cwise.cpp b/test/matrix_cwise.cpp
index 56cd2d6..ae8d43d 100644
--- a/test/matrix_cwise.cpp
+++ b/test/matrix_cwise.cpp
@@ -6,10 +6,16 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
+#include <type_traits>
 #include <vector>
 #include "main.h"
 
+static_assert(std::is_same<MatrixXf::CwiseAbsReturnType,
+                           std::remove_const_t<decltype(std::declval<const MatrixXf&>().cwiseAbs())>>::value,
+              "MatrixBase unary return type aliases must match their corresponding expressions");
+
 template <typename MatrixType, typename NewScalar>
 struct matrix_of {
   using type = MatrixType;
@@ -20,6 +26,24 @@
   using type = Eigen::Matrix<NewScalar, Rows, Cols, Options, MaxRows, MaxCols>;
 };
 
+struct pointer_result_payload {
+  double value;
+};
+
+struct pointer_result_holder {
+  pointer_result_payload* ptr;
+};
+
+struct unary_pointer_result_op {
+  pointer_result_payload* operator()(const pointer_result_holder& x) const { return x.ptr; }
+};
+
+struct binary_pointer_result_op {
+  pointer_result_payload* operator()(const pointer_result_holder& x, const pointer_result_holder&) const {
+    return x.ptr;
+  }
+};
+
 // Unary function reference.
 template <typename MatrixType, typename Func,
           typename OutMatrixType = typename matrix_of<
@@ -49,6 +73,59 @@
   return out;
 }
 
+void test_cwise_pointer_result() {
+  pointer_result_payload p0 = {0.0};
+  pointer_result_payload p1 = {1.0};
+  pointer_result_payload p2 = {2.0};
+  pointer_result_payload p3 = {3.0};
+
+  Matrix<pointer_result_holder, 2, 2> holders;
+  holders(0, 0).ptr = &p0;
+  holders(1, 0).ptr = &p1;
+  holders(0, 1).ptr = &p2;
+  holders(1, 1).ptr = &p3;
+
+  const auto unary = holders.unaryExpr(unary_pointer_result_op());
+  VERIFY((std::is_same<typename Eigen::internal::traits<decltype(unary)>::Scalar, pointer_result_payload*>::value));
+  Matrix<pointer_result_payload*, 2, 2> unary_out = unary;
+  VERIFY_IS_EQUAL(unary_out(0, 0), &p0);
+  VERIFY_IS_EQUAL(unary_out(1, 0), &p1);
+  VERIFY_IS_EQUAL(unary_out(0, 1), &p2);
+  VERIFY_IS_EQUAL(unary_out(1, 1), &p3);
+
+  const auto binary = holders.binaryExpr(holders, binary_pointer_result_op());
+  VERIFY((std::is_same<typename Eigen::internal::traits<decltype(binary)>::Scalar, pointer_result_payload*>::value));
+  Matrix<pointer_result_payload*, 2, 2> binary_out = binary;
+  VERIFY_IS_EQUAL(binary_out(0, 0), &p0);
+  VERIFY_IS_EQUAL(binary_out(1, 0), &p1);
+  VERIFY_IS_EQUAL(binary_out(0, 1), &p2);
+  VERIFY_IS_EQUAL(binary_out(1, 1), &p3);
+
+  Array<bool, 2, 2> mask;
+  mask(0, 0) = true;
+  mask(1, 0) = false;
+  mask(0, 1) = false;
+  mask(1, 1) = true;
+  Array<pointer_result_payload*, 2, 2> then_values;
+  then_values(0, 0) = &p0;
+  then_values(1, 0) = &p1;
+  then_values(0, 1) = &p2;
+  then_values(1, 1) = &p3;
+  Array<pointer_result_payload*, 2, 2> else_values;
+  else_values(0, 0) = &p3;
+  else_values(1, 0) = &p2;
+  else_values(0, 1) = &p1;
+  else_values(1, 1) = &p0;
+
+  const auto selected = mask.select(then_values, else_values);
+  VERIFY((std::is_same<typename Eigen::internal::traits<decltype(selected)>::Scalar, pointer_result_payload*>::value));
+  Array<pointer_result_payload*, 2, 2> selected_out = selected;
+  VERIFY_IS_EQUAL(selected_out(0, 0), &p0);
+  VERIFY_IS_EQUAL(selected_out(1, 0), &p2);
+  VERIFY_IS_EQUAL(selected_out(0, 1), &p1);
+  VERIFY_IS_EQUAL(selected_out(1, 1), &p3);
+}
+
 template <typename MatrixType>
 void test_cwise_real(const MatrixType& m) {
   using Scalar = typename MatrixType::Scalar;
@@ -69,7 +146,14 @@
   VERIFY_IS_CWISE_APPROX(m2.cwiseInverse(), cwise_ref(m2, [](const Scalar& x) { return Scalar(Scalar(1) / x); }));
   VERIFY_IS_CWISE_APPROX(m1.cwiseArg(), cwise_ref(m1, [](const Scalar& x) { return Eigen::numext::arg(x); }));
   // Only take sqrt of positive values.
-  m2 = m1.cwiseAbs();
+  // For signed integers, abs(min_value) overflows, so clamp it first.
+  m2 = m1;
+  if (Eigen::NumTraits<Scalar>::IsInteger && std::is_signed<Scalar>::value) {
+    m2 = m1.unaryExpr([](const Scalar& x) {
+      return x == (std::numeric_limits<Scalar>::min)() ? (std::numeric_limits<Scalar>::max)() : x;
+    });
+  }
+  m2 = m2.cwiseAbs();
   VERIFY_IS_CWISE_APPROX(m2.cwiseSqrt(), cwise_ref(m2, [](const Scalar& x) { return Eigen::numext::sqrt(x); }));
   // Only find Square/Abs2 of +/- sqrt values so we don't overflow.
   m2 = m2.cwiseSqrt().array() * m1.cwiseSign().array();
@@ -81,16 +165,12 @@
   // Supported binary ops.
   m1.setRandom(rows, cols);
   m2.setRandom(rows, cols);
-  VERIFY_IS_CWISE_EQUAL(m1.cwiseMin(m2),
-                        cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateFast>(m2),
                         cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNaN>(m2),
                         cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNumbers>(m2),
                         cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
-  VERIFY_IS_CWISE_EQUAL(m1.cwiseMax(m2),
-                        cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateFast>(m2),
                         cwise_ref(m1, m2, [](const Scalar& x, const Scalar& y) { return Eigen::numext::maxi(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMax<PropagateNaN>(m2),
@@ -100,8 +180,6 @@
   // Scalar comparison.
   Scalar mean = Eigen::NumTraits<Scalar>::highest() / Scalar(2) + Eigen::NumTraits<Scalar>::lowest() / Scalar(2);
   m4.setConstant(rows, cols, mean);
-  VERIFY_IS_CWISE_EQUAL(m1.cwiseMin(mean),
-                        cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateFast>(mean),
                         cwise_ref(m1, m4, [](const Scalar& x, const Scalar& y) { return Eigen::numext::mini(x, y); }));
   VERIFY_IS_CWISE_EQUAL(m1.template cwiseMin<PropagateNaN>(mean),
@@ -298,5 +376,6 @@
     CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint16_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
     CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint32_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
     CALL_SUBTEST_4(test_cwise_real(Eigen::Matrix<uint64_t, Eigen::Dynamic, Eigen::Dynamic>(20, 20)));
+    CALL_SUBTEST_5(test_cwise_pointer_result());
   }
 }
diff --git a/test/maxsizevector.cpp b/test/maxsizevector.cpp
index 82aa257..b99e390 100644
--- a/test/maxsizevector.cpp
+++ b/test/maxsizevector.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #include "main.h"
 
 #ifdef EIGEN_EXCEPTIONS
diff --git a/test/meta.cpp b/test/meta.cpp
index 46269b5..4656c6a 100644
--- a/test/meta.cpp
+++ b/test/meta.cpp
@@ -6,164 +6,34 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
 #include <array>
 #include <Eigen/src/Core/util/Meta.h>
 
-template <typename From, typename To>
-bool check_is_convertible(const From&, const To&) {
-  return internal::is_convertible<From, To>::value;
-}
-
 struct FooReturnType {
   typedef int ReturnType;
 };
 
-struct MyInterface {
-  virtual void func() = 0;
-  virtual ~MyInterface() {}
-};
-struct MyImpl : public MyInterface {
-  void func() {}
-};
-
-EIGEN_DECLARE_TEST(meta) {
-  VERIFY((internal::is_same<float, float>::value));
-  VERIFY((!internal::is_same<float, double>::value));
-  VERIFY((!internal::is_same<float, float&>::value));
-  VERIFY((!internal::is_same<float, const float&>::value));
-
-  VERIFY((internal::is_same<float, internal::remove_all_t<const float&>>::value));
-  VERIFY((internal::is_same<float, internal::remove_all_t<const float*>>::value));
-  VERIFY((internal::is_same<float, internal::remove_all_t<const float*&>>::value));
-  VERIFY((internal::is_same<float, internal::remove_all_t<float**>>::value));
-  VERIFY((internal::is_same<float, internal::remove_all_t<float**&>>::value));
-  VERIFY((internal::is_same<float, internal::remove_all_t<float* const*&>>::value));
-  VERIFY((internal::is_same<float, internal::remove_all_t<float* const>>::value));
-
-  // test add_const_on_value_type
-  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float&>, float const&>::value));
-  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float*>, float const*>::value));
-
-  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float>, const float>::value));
-  VERIFY((internal::is_same<internal::add_const_on_value_type_t<const float>, const float>::value));
-
-  VERIFY((internal::is_same<internal::add_const_on_value_type_t<const float* const>, const float* const>::value));
-  VERIFY((internal::is_same<internal::add_const_on_value_type_t<float* const>, const float* const>::value));
-
-  // is_convertible
-  STATIC_CHECK((internal::is_convertible<float, double>::value));
-  STATIC_CHECK((internal::is_convertible<int, double>::value));
-  STATIC_CHECK((internal::is_convertible<int, short>::value));
-  STATIC_CHECK((internal::is_convertible<short, int>::value));
-  STATIC_CHECK((internal::is_convertible<double, int>::value));
-  STATIC_CHECK((internal::is_convertible<double, std::complex<double>>::value));
-  STATIC_CHECK((!internal::is_convertible<std::complex<double>, double>::value));
-  STATIC_CHECK((internal::is_convertible<Array33f, Matrix3f>::value));
-  STATIC_CHECK((internal::is_convertible<Matrix3f&, Matrix3f>::value));
-  STATIC_CHECK((internal::is_convertible<Matrix3f&, Matrix3f&>::value));
-  STATIC_CHECK((internal::is_convertible<Matrix3f&, const Matrix3f&>::value));
-  STATIC_CHECK((internal::is_convertible<const Matrix3f&, Matrix3f>::value));
-  STATIC_CHECK((internal::is_convertible<const Matrix3f&, const Matrix3f&>::value));
-  STATIC_CHECK((!internal::is_convertible<const Matrix3f&, Matrix3f&>::value));
-  STATIC_CHECK((!internal::is_convertible<const Matrix3f, Matrix3f&>::value));
-  STATIC_CHECK(!(internal::is_convertible<Matrix3f, Matrix3f&>::value));
-
-  STATIC_CHECK(!(internal::is_convertible<int, int&>::value));
-  STATIC_CHECK((internal::is_convertible<const int, const int&>::value));
-
-  // STATIC_CHECK((!internal::is_convertible<Matrix3f,Matrix3d>::value )); //does not even compile because the
-  // conversion is prevented by a static assertion
-  STATIC_CHECK((!internal::is_convertible<Array33f, int>::value));
-  STATIC_CHECK((!internal::is_convertible<MatrixXf, float>::value));
-  {
-    float f = 0.0f;
-    MatrixXf A, B;
-    VectorXf a, b;
-    VERIFY((check_is_convertible(a.dot(b), f)));
-    VERIFY((check_is_convertible(a.transpose() * b, f)));
-    VERIFY((!check_is_convertible(A * B, f)));
-    VERIFY((check_is_convertible(A * B, A)));
-  }
-
-#if (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC <= 990) || (EIGEN_COMP_CLANG_STRICT && EIGEN_COMP_CLANG <= 990) || \
-    (EIGEN_COMP_MSVC && EIGEN_COMP_MSVC <= 1914)
-  // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1752,
-  // basically, a fix in the c++ standard breaks our c++98 implementation
-  // of is_convertible for abstract classes.
-  // So the following tests are expected to fail with recent compilers.
-
-  STATIC_CHECK((!internal::is_convertible<MyInterface, MyImpl>::value));
-  STATIC_CHECK((!internal::is_convertible<MyImpl, MyInterface>::value));
-  STATIC_CHECK((internal::is_convertible<MyImpl, const MyInterface&>::value));
-
-#endif
-
-  {
-    int i = 0;
-    VERIFY((check_is_convertible(fix<3>(), i)));
-    VERIFY((!check_is_convertible(i, fix<DynamicIndex>())));
-  }
-
-  VERIFY((internal::has_ReturnType<FooReturnType>::value));
-  VERIFY((internal::has_ReturnType<ScalarBinaryOpTraits<int, int>>::value));
-  VERIFY((!internal::has_ReturnType<MatrixXf>::value));
-  VERIFY((!internal::has_ReturnType<int>::value));
-
-  VERIFY(internal::meta_sqrt<1>::ret == 1);
-#define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(std::sqrt(double(X))))
-  VERIFY_META_SQRT(2);
-  VERIFY_META_SQRT(3);
-  VERIFY_META_SQRT(4);
-  VERIFY_META_SQRT(5);
-  VERIFY_META_SQRT(6);
-  VERIFY_META_SQRT(8);
-  VERIFY_META_SQRT(9);
-  VERIFY_META_SQRT(15);
-  VERIFY_META_SQRT(16);
-  VERIFY_META_SQRT(17);
-  VERIFY_META_SQRT(255);
-  VERIFY_META_SQRT(256);
-  VERIFY_META_SQRT(257);
-  VERIFY_META_SQRT(1023);
-  VERIFY_META_SQRT(1024);
-  VERIFY_META_SQRT(1025);
-}
-
 using Eigen::internal::apply_op_from_left;
 using Eigen::internal::apply_op_from_right;
 using Eigen::internal::arg_prod;
 using Eigen::internal::arg_sum;
-using Eigen::internal::array_apply;
-using Eigen::internal::array_apply_and_reduce;
 using Eigen::internal::array_prod;
 using Eigen::internal::array_reduce;
-using Eigen::internal::array_reverse;
 using Eigen::internal::array_sum;
-using Eigen::internal::array_zip;
-using Eigen::internal::array_zip_and_reduce;
 using Eigen::internal::concat;
 using Eigen::internal::contained_in_list;
 using Eigen::internal::contained_in_list_gf;
-using Eigen::internal::gen_numeric_list;
-using Eigen::internal::gen_numeric_list_repeated;
-using Eigen::internal::gen_numeric_list_reversed;
-using Eigen::internal::gen_numeric_list_swapped_pair;
-using Eigen::internal::get;
-using Eigen::internal::id_numeric;
-using Eigen::internal::id_type;
-using Eigen::internal::instantiate_by_c_array;
-using Eigen::internal::is_same;
+// Eigen::internal::get is intentionally left fully-qualified below: test/main.h
+// does `using namespace Eigen;`, and Eigen/src/Core/StructuredBindings.h defines
+// free functions `Eigen::get` that would otherwise clash with this metafunction.
 using Eigen::internal::is_same_gf;
 using Eigen::internal::mconcat;
-using Eigen::internal::numeric_list;
-using Eigen::internal::product_op;
-using Eigen::internal::repeat;
 using Eigen::internal::skip;
 using Eigen::internal::slice;
-using Eigen::internal::sum_op;
 using Eigen::internal::take;
 using Eigen::internal::type_list;
 
@@ -173,6 +43,13 @@
 struct dummy_d {};
 struct dummy_e {};
 
+struct widening_sum_op {
+  template <typename A, typename B>
+  EIGEN_DEVICE_FUNC constexpr static long long run(A a, B b) {
+    return static_cast<long long>(a) + static_cast<long long>(b);
+  }
+};
+
 // dummy operation for testing apply
 template <typename A, typename B>
 struct dummy_op;
@@ -234,198 +111,72 @@
   constexpr static int global_flags = 4;
 };
 
-struct times2_op {
-  template <typename A>
-  static A run(A v) {
-    return v * 2;
-  }
-};
-
-struct dummy_inst {
-  int c;
-
-  dummy_inst() : c(0) {}
-  explicit dummy_inst(int) : c(1) {}
-  dummy_inst(int, int) : c(2) {}
-  dummy_inst(int, int, int) : c(3) {}
-  dummy_inst(int, int, int, int) : c(4) {}
-  dummy_inst(int, int, int, int, int) : c(5) {}
-};
-
-static void test_gen_numeric_list() {
-  VERIFY((is_same<typename gen_numeric_list<int, 0>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 1>::type, numeric_list<int, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 2>::type, numeric_list<int, 0, 1>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 5>::type, numeric_list<int, 0, 1, 2, 3, 4>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 10>::type, numeric_list<int, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9>>::value));
-
-  VERIFY((is_same<typename gen_numeric_list<int, 0, 42>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 1, 42>::type, numeric_list<int, 42>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 2, 42>::type, numeric_list<int, 42, 43>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 5, 42>::type, numeric_list<int, 42, 43, 44, 45, 46>>::value));
-  VERIFY((is_same<typename gen_numeric_list<int, 10, 42>::type,
-                  numeric_list<int, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51>>::value));
-
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 0>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 1>::type, numeric_list<int, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 2>::type, numeric_list<int, 1, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 5>::type, numeric_list<int, 4, 3, 2, 1, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 10>::type,
-                  numeric_list<int, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0>>::value));
-
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 0, 42>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 1, 42>::type, numeric_list<int, 42>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 2, 42>::type, numeric_list<int, 43, 42>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 5, 42>::type, numeric_list<int, 46, 45, 44, 43, 42>>::value));
-  VERIFY((is_same<typename gen_numeric_list_reversed<int, 10, 42>::type,
-                  numeric_list<int, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42>>::value));
-
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 0, 2, 3>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 1, 2, 3>::type, numeric_list<int, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 2, 2, 3>::type, numeric_list<int, 0, 1>>::value));
-  VERIFY(
-      (is_same<typename gen_numeric_list_swapped_pair<int, 5, 2, 3>::type, numeric_list<int, 0, 1, 3, 2, 4>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 10, 2, 3>::type,
-                  numeric_list<int, 0, 1, 3, 2, 4, 5, 6, 7, 8, 9>>::value));
-
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 0, 44, 45, 42>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 1, 44, 45, 42>::type, numeric_list<int, 42>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 2, 44, 45, 42>::type, numeric_list<int, 42, 43>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 5, 44, 45, 42>::type,
-                  numeric_list<int, 42, 43, 45, 44, 46>>::value));
-  VERIFY((is_same<typename gen_numeric_list_swapped_pair<int, 10, 44, 45, 42>::type,
-                  numeric_list<int, 42, 43, 45, 44, 46, 47, 48, 49, 50, 51>>::value));
-
-  VERIFY((is_same<typename gen_numeric_list_repeated<int, 0, 0>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename gen_numeric_list_repeated<int, 1, 0>::type, numeric_list<int, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_repeated<int, 2, 0>::type, numeric_list<int, 0, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_repeated<int, 5, 0>::type, numeric_list<int, 0, 0, 0, 0, 0>>::value));
-  VERIFY((is_same<typename gen_numeric_list_repeated<int, 10, 0>::type,
-                  numeric_list<int, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0>>::value));
-}
-
 static void test_concat() {
-  VERIFY(
-      (is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<>>::type, type_list<dummy_a, dummy_a>>::value));
-  VERIFY(
-      (is_same<typename concat<type_list<>, type_list<dummy_a, dummy_a>>::type, type_list<dummy_a, dummy_a>>::value));
-  VERIFY((is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<dummy_a, dummy_a>>::type,
-                  type_list<dummy_a, dummy_a, dummy_a, dummy_a>>::value));
-  VERIFY((is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<dummy_b, dummy_c>>::type,
-                  type_list<dummy_a, dummy_a, dummy_b, dummy_c>>::value));
-  VERIFY((is_same<typename concat<type_list<dummy_a>, type_list<dummy_b, dummy_c>>::type,
-                  type_list<dummy_a, dummy_b, dummy_c>>::value));
+  VERIFY((std::is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<>>::type,
+                       type_list<dummy_a, dummy_a>>::value));
+  VERIFY((std::is_same<typename concat<type_list<>, type_list<dummy_a, dummy_a>>::type,
+                       type_list<dummy_a, dummy_a>>::value));
+  VERIFY((std::is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<dummy_a, dummy_a>>::type,
+                       type_list<dummy_a, dummy_a, dummy_a, dummy_a>>::value));
+  VERIFY((std::is_same<typename concat<type_list<dummy_a, dummy_a>, type_list<dummy_b, dummy_c>>::type,
+                       type_list<dummy_a, dummy_a, dummy_b, dummy_c>>::value));
+  VERIFY((std::is_same<typename concat<type_list<dummy_a>, type_list<dummy_b, dummy_c>>::type,
+                       type_list<dummy_a, dummy_b, dummy_c>>::value));
 
-  VERIFY((is_same<typename concat<numeric_list<int, 0, 0>, numeric_list<int>>::type, numeric_list<int, 0, 0>>::value));
-  VERIFY((is_same<typename concat<numeric_list<int>, numeric_list<int, 0, 0>>::type, numeric_list<int, 0, 0>>::value));
-  VERIFY((is_same<typename concat<numeric_list<int, 0, 0>, numeric_list<int, 0, 0>>::type,
-                  numeric_list<int, 0, 0, 0, 0>>::value));
-  VERIFY((is_same<typename concat<numeric_list<int, 0, 0>, numeric_list<int, 1, 2>>::type,
-                  numeric_list<int, 0, 0, 1, 2>>::value));
-  VERIFY((is_same<typename concat<numeric_list<int, 0>, numeric_list<int, 1, 2>>::type,
-                  numeric_list<int, 0, 1, 2>>::value));
-
-  VERIFY((is_same<typename mconcat<type_list<dummy_a>>::type, type_list<dummy_a>>::value));
-  VERIFY((is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b>>::type, type_list<dummy_a, dummy_b>>::value));
-  VERIFY((is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b>, type_list<dummy_c>>::type,
-                  type_list<dummy_a, dummy_b, dummy_c>>::value));
-  VERIFY((is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b, dummy_c>>::type,
-                  type_list<dummy_a, dummy_b, dummy_c>>::value));
-  VERIFY((is_same<typename mconcat<type_list<dummy_a, dummy_b>, type_list<dummy_c>>::type,
-                  type_list<dummy_a, dummy_b, dummy_c>>::value));
-
-  VERIFY((is_same<typename mconcat<numeric_list<int, 0>>::type, numeric_list<int, 0>>::value));
-  VERIFY((is_same<typename mconcat<numeric_list<int, 0>, numeric_list<int, 1>>::type, numeric_list<int, 0, 1>>::value));
-  VERIFY((is_same<typename mconcat<numeric_list<int, 0>, numeric_list<int, 1>, numeric_list<int, 2>>::type,
-                  numeric_list<int, 0, 1, 2>>::value));
-  VERIFY((is_same<typename mconcat<numeric_list<int, 0>, numeric_list<int, 1, 2>>::type,
-                  numeric_list<int, 0, 1, 2>>::value));
-  VERIFY((is_same<typename mconcat<numeric_list<int, 0, 1>, numeric_list<int, 2>>::type,
-                  numeric_list<int, 0, 1, 2>>::value));
+  VERIFY((std::is_same<typename mconcat<type_list<dummy_a>>::type, type_list<dummy_a>>::value));
+  VERIFY((std::is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b>>::type,
+                       type_list<dummy_a, dummy_b>>::value));
+  VERIFY((std::is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b>, type_list<dummy_c>>::type,
+                       type_list<dummy_a, dummy_b, dummy_c>>::value));
+  VERIFY((std::is_same<typename mconcat<type_list<dummy_a>, type_list<dummy_b, dummy_c>>::type,
+                       type_list<dummy_a, dummy_b, dummy_c>>::value));
+  VERIFY((std::is_same<typename mconcat<type_list<dummy_a, dummy_b>, type_list<dummy_c>>::type,
+                       type_list<dummy_a, dummy_b, dummy_c>>::value));
 }
 
 static void test_slice() {
   typedef type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c> tl;
-  typedef numeric_list<int, 0, 1, 2, 3, 4, 5> il;
 
-  VERIFY((is_same<typename take<0, tl>::type, type_list<>>::value));
-  VERIFY((is_same<typename take<1, tl>::type, type_list<dummy_a>>::value));
-  VERIFY((is_same<typename take<2, tl>::type, type_list<dummy_a, dummy_a>>::value));
-  VERIFY((is_same<typename take<3, tl>::type, type_list<dummy_a, dummy_a, dummy_b>>::value));
-  VERIFY((is_same<typename take<4, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b>>::value));
-  VERIFY((is_same<typename take<5, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c>>::value));
-  VERIFY((is_same<typename take<6, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
+  VERIFY((std::is_same<typename take<0, tl>::type, type_list<>>::value));
+  VERIFY((std::is_same<typename take<1, tl>::type, type_list<dummy_a>>::value));
+  VERIFY((std::is_same<typename take<2, tl>::type, type_list<dummy_a, dummy_a>>::value));
+  VERIFY((std::is_same<typename take<3, tl>::type, type_list<dummy_a, dummy_a, dummy_b>>::value));
+  VERIFY((std::is_same<typename take<4, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b>>::value));
+  VERIFY((std::is_same<typename take<5, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c>>::value));
+  VERIFY((std::is_same<typename take<6, tl>::type,
+                       type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
 
-  VERIFY((is_same<typename take<0, il>::type, numeric_list<int>>::value));
-  VERIFY((is_same<typename take<1, il>::type, numeric_list<int, 0>>::value));
-  VERIFY((is_same<typename take<2, il>::type, numeric_list<int, 0, 1>>::value));
-  VERIFY((is_same<typename take<3, il>::type, numeric_list<int, 0, 1, 2>>::value));
-  VERIFY((is_same<typename take<4, il>::type, numeric_list<int, 0, 1, 2, 3>>::value));
-  VERIFY((is_same<typename take<5, il>::type, numeric_list<int, 0, 1, 2, 3, 4>>::value));
-  VERIFY((is_same<typename take<6, il>::type, numeric_list<int, 0, 1, 2, 3, 4, 5>>::value));
+  VERIFY((std::is_same<typename skip<0, tl>::type,
+                       type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
+  VERIFY((std::is_same<typename skip<1, tl>::type, type_list<dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
+  VERIFY((std::is_same<typename skip<2, tl>::type, type_list<dummy_b, dummy_b, dummy_c, dummy_c>>::value));
+  VERIFY((std::is_same<typename skip<3, tl>::type, type_list<dummy_b, dummy_c, dummy_c>>::value));
+  VERIFY((std::is_same<typename skip<4, tl>::type, type_list<dummy_c, dummy_c>>::value));
+  VERIFY((std::is_same<typename skip<5, tl>::type, type_list<dummy_c>>::value));
+  VERIFY((std::is_same<typename skip<6, tl>::type, type_list<>>::value));
+  VERIFY((std::is_same<typename skip<7, tl>::type, type_list<>>::value));
 
-  VERIFY((is_same<typename skip<0, tl>::type, type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
-  VERIFY((is_same<typename skip<1, tl>::type, type_list<dummy_a, dummy_b, dummy_b, dummy_c, dummy_c>>::value));
-  VERIFY((is_same<typename skip<2, tl>::type, type_list<dummy_b, dummy_b, dummy_c, dummy_c>>::value));
-  VERIFY((is_same<typename skip<3, tl>::type, type_list<dummy_b, dummy_c, dummy_c>>::value));
-  VERIFY((is_same<typename skip<4, tl>::type, type_list<dummy_c, dummy_c>>::value));
-  VERIFY((is_same<typename skip<5, tl>::type, type_list<dummy_c>>::value));
-  VERIFY((is_same<typename skip<6, tl>::type, type_list<>>::value));
-
-  VERIFY((is_same<typename skip<0, il>::type, numeric_list<int, 0, 1, 2, 3, 4, 5>>::value));
-  VERIFY((is_same<typename skip<1, il>::type, numeric_list<int, 1, 2, 3, 4, 5>>::value));
-  VERIFY((is_same<typename skip<2, il>::type, numeric_list<int, 2, 3, 4, 5>>::value));
-  VERIFY((is_same<typename skip<3, il>::type, numeric_list<int, 3, 4, 5>>::value));
-  VERIFY((is_same<typename skip<4, il>::type, numeric_list<int, 4, 5>>::value));
-  VERIFY((is_same<typename skip<5, il>::type, numeric_list<int, 5>>::value));
-  VERIFY((is_same<typename skip<6, il>::type, numeric_list<int>>::value));
-
-  VERIFY((is_same<typename slice<0, 3, tl>::type, typename take<3, tl>::type>::value));
-  VERIFY((is_same<typename slice<0, 3, il>::type, typename take<3, il>::type>::value));
-  VERIFY((is_same<typename slice<1, 3, tl>::type, type_list<dummy_a, dummy_b, dummy_b>>::value));
-  VERIFY((is_same<typename slice<1, 3, il>::type, numeric_list<int, 1, 2, 3>>::value));
+  VERIFY((std::is_same<typename slice<0, 3, tl>::type, typename take<3, tl>::type>::value));
+  VERIFY((std::is_same<typename slice<1, 3, tl>::type, type_list<dummy_a, dummy_b, dummy_b>>::value));
 }
 
 static void test_get() {
   typedef type_list<dummy_a, dummy_a, dummy_b, dummy_b, dummy_c, dummy_c> tl;
-  typedef numeric_list<int, 4, 8, 15, 16, 23, 42> il;
+  typedef std::integer_sequence<int, 4, 8, 15, 16, 23, 42> il;
 
-  VERIFY((is_same<typename get<0, tl>::type, dummy_a>::value));
-  VERIFY((is_same<typename get<1, tl>::type, dummy_a>::value));
-  VERIFY((is_same<typename get<2, tl>::type, dummy_b>::value));
-  VERIFY((is_same<typename get<3, tl>::type, dummy_b>::value));
-  VERIFY((is_same<typename get<4, tl>::type, dummy_c>::value));
-  VERIFY((is_same<typename get<5, tl>::type, dummy_c>::value));
+  VERIFY((std::is_same<typename Eigen::internal::get<0, tl>::type, dummy_a>::value));
+  VERIFY((std::is_same<typename Eigen::internal::get<1, tl>::type, dummy_a>::value));
+  VERIFY((std::is_same<typename Eigen::internal::get<2, tl>::type, dummy_b>::value));
+  VERIFY((std::is_same<typename Eigen::internal::get<3, tl>::type, dummy_b>::value));
+  VERIFY((std::is_same<typename Eigen::internal::get<4, tl>::type, dummy_c>::value));
+  VERIFY((std::is_same<typename Eigen::internal::get<5, tl>::type, dummy_c>::value));
 
-  VERIFY_IS_EQUAL(((int)get<0, il>::value), 4);
-  VERIFY_IS_EQUAL(((int)get<1, il>::value), 8);
-  VERIFY_IS_EQUAL(((int)get<2, il>::value), 15);
-  VERIFY_IS_EQUAL(((int)get<3, il>::value), 16);
-  VERIFY_IS_EQUAL(((int)get<4, il>::value), 23);
-  VERIFY_IS_EQUAL(((int)get<5, il>::value), 42);
-}
-
-static void test_id_helper(dummy_a a, dummy_a b, dummy_a c) {
-  (void)a;
-  (void)b;
-  (void)c;
-}
-
-template <int... ii>
-static void test_id_numeric() {
-  test_id_helper(typename id_numeric<int, ii, dummy_a>::type()...);
-}
-
-template <typename... tt>
-static void test_id_type() {
-  test_id_helper(typename id_type<tt, dummy_a>::type()...);
-}
-
-static void test_id() {
-  // don't call VERIFY here, just assume it works if it compiles
-  // (otherwise it will complain that it can't find the function)
-  test_id_numeric<1, 4, 6>();
-  test_id_type<dummy_a, dummy_b, dummy_c>();
+  VERIFY_IS_EQUAL(((int)Eigen::internal::get<0, il>::value), 4);
+  VERIFY_IS_EQUAL(((int)Eigen::internal::get<1, il>::value), 8);
+  VERIFY_IS_EQUAL(((int)Eigen::internal::get<2, il>::value), 15);
+  VERIFY_IS_EQUAL(((int)Eigen::internal::get<3, il>::value), 16);
+  VERIFY_IS_EQUAL(((int)Eigen::internal::get<4, il>::value), 23);
+  VERIFY_IS_EQUAL(((int)Eigen::internal::get<5, il>::value), 42);
 }
 
 static void test_is_same_gf() {
@@ -437,20 +188,22 @@
 
 static void test_apply_op() {
   typedef type_list<dummy_a, dummy_b, dummy_c> tl;
-  VERIFY((!!is_same<typename apply_op_from_left<dummy_op, dummy_a, tl>::type,
-                    type_list<dummy_e, dummy_c, dummy_d>>::value));
-  VERIFY((!!is_same<typename apply_op_from_right<dummy_op, dummy_a, tl>::type,
-                    type_list<dummy_e, dummy_d, dummy_b>>::value));
+  VERIFY((!!std::is_same<typename apply_op_from_left<dummy_op, dummy_a, tl>::type,
+                         type_list<dummy_e, dummy_c, dummy_d>>::value));
+  VERIFY((!!std::is_same<typename apply_op_from_right<dummy_op, dummy_a, tl>::type,
+                         type_list<dummy_e, dummy_d, dummy_b>>::value));
+  VERIFY((!!std::is_same<typename apply_op_from_left<dummy_op, dummy_a, type_list<>>::type, type_list<>>::value));
+  VERIFY((!!std::is_same<typename apply_op_from_right<dummy_op, dummy_a, type_list<>>::type, type_list<>>::value));
 }
 
 static void test_contained_in_list() {
   typedef type_list<dummy_a, dummy_b, dummy_c> tl;
 
-  VERIFY((!!contained_in_list<is_same, dummy_a, tl>::value));
-  VERIFY((!!contained_in_list<is_same, dummy_b, tl>::value));
-  VERIFY((!!contained_in_list<is_same, dummy_c, tl>::value));
-  VERIFY((!contained_in_list<is_same, dummy_d, tl>::value));
-  VERIFY((!contained_in_list<is_same, dummy_e, tl>::value));
+  VERIFY((!!contained_in_list<std::is_same, dummy_a, tl>::value));
+  VERIFY((!!contained_in_list<std::is_same, dummy_b, tl>::value));
+  VERIFY((!!contained_in_list<std::is_same, dummy_c, tl>::value));
+  VERIFY((!contained_in_list<std::is_same, dummy_d, tl>::value));
+  VERIFY((!contained_in_list<std::is_same, dummy_e, tl>::value));
 
   VERIFY((!!contained_in_list_gf<dummy_test, dummy_a, tl>::value));
   VERIFY((!!contained_in_list_gf<dummy_test, dummy_b, tl>::value));
@@ -472,62 +225,115 @@
   VERIFY_IS_APPROX(arg_prod(0.5, 2, 5), 5.0);
 }
 
-static void test_array_reverse_and_reduce() {
-  array<int, 6> a{{4, 8, 15, 16, 23, 42}};
-  array<int, 6> b{{42, 23, 16, 15, 8, 4}};
+static void test_array_reductions() {
+  array<int, 6> a{4, 8, 15, 16, 23, 42};
+  array<int, 6> b{42, 23, 16, 15, 8, 4};
+  array<unsigned char, 0> empty{};
+  array<unsigned char, 1> singleton{200};
+  array<unsigned char, 2> narrow{200, 100};
+  array<unsigned char, 3> custom{200, 100, 50};
 
-  // there is no operator<< for std::array, so VERIFY_IS_EQUAL will
-  // not compile
-  VERIFY((array_reverse(a) == b));
-  VERIFY((array_reverse(b) == a));
   VERIFY_IS_EQUAL((array_sum(a)), 108);
   VERIFY_IS_EQUAL((array_sum(b)), 108);
   VERIFY_IS_EQUAL((array_prod(a)), 7418880);
   VERIFY_IS_EQUAL((array_prod(b)), 7418880);
+  VERIFY((std::is_same<decltype(array_sum(empty)), unsigned char>::value));
+  VERIFY((std::is_same<decltype(array_sum(singleton)), unsigned char>::value));
+  VERIFY((std::is_same<decltype(array_sum(narrow)), int>::value));
+  VERIFY((std::is_same<decltype(array_prod(narrow)), int>::value));
+  VERIFY_IS_EQUAL((array_sum(empty)), 0);
+  VERIFY_IS_EQUAL((array_prod(empty)), 1);
+  VERIFY_IS_EQUAL((array_sum(singleton)), 200);
+  VERIFY_IS_EQUAL((array_prod(singleton)), 200);
+  VERIFY_IS_EQUAL((array_sum(narrow)), 300);
+  VERIFY_IS_EQUAL((array_prod(narrow)), 20000);
+  VERIFY(
+      (std::is_same<decltype(array_reduce<widening_sum_op>(custom, static_cast<unsigned char>(0))), long long>::value));
+  VERIFY_IS_EQUAL((array_reduce<widening_sum_op>(custom, static_cast<unsigned char>(0))), 350);
 }
 
-static void test_array_zip_and_apply() {
-  array<int, 6> a{{4, 8, 15, 16, 23, 42}};
-  array<int, 6> b{{0, 1, 2, 3, 4, 5}};
-  array<int, 6> c{{4, 9, 17, 19, 27, 47}};
-  array<int, 6> d{{0, 8, 30, 48, 92, 210}};
-  array<int, 6> e{{0, 2, 4, 6, 8, 10}};
+EIGEN_DECLARE_TEST(meta) {
+  VERIFY((std::is_same<float, float>::value));
+  VERIFY((!std::is_same<float, double>::value));
+  VERIFY((!std::is_same<float, float&>::value));
+  VERIFY((!std::is_same<float, const float&>::value));
 
-  VERIFY((array_zip<sum_op>(a, b) == c));
-  VERIFY((array_zip<product_op>(a, b) == d));
-  VERIFY((array_apply<times2_op>(b) == e));
-  VERIFY_IS_EQUAL((array_apply_and_reduce<sum_op, times2_op>(a)), 216);
-  VERIFY_IS_EQUAL((array_apply_and_reduce<sum_op, times2_op>(b)), 30);
-  VERIFY_IS_EQUAL((array_zip_and_reduce<product_op, sum_op>(a, b)), 14755932);
-  VERIFY_IS_EQUAL((array_zip_and_reduce<sum_op, product_op>(a, b)), 388);
-}
+  VERIFY((std::is_same<float, internal::remove_all_t<const float&>>::value));
+  VERIFY((std::is_same<float, internal::remove_all_t<const float*>>::value));
+  VERIFY((std::is_same<float, internal::remove_all_t<const float*&>>::value));
+  VERIFY((std::is_same<float, internal::remove_all_t<float**>>::value));
+  VERIFY((std::is_same<float, internal::remove_all_t<float**&>>::value));
+  VERIFY((std::is_same<float, internal::remove_all_t<float* const*&>>::value));
+  VERIFY((std::is_same<float, internal::remove_all_t<float* const>>::value));
 
-static void test_array_misc() {
-  array<int, 3> a3{{1, 1, 1}};
-  array<int, 6> a6{{2, 2, 2, 2, 2, 2}};
-  VERIFY((repeat<3, int>(1) == a3));
-  VERIFY((repeat<6, int>(2) == a6));
+  // test add_const_on_value_type
+  VERIFY((std::is_same<internal::add_const_on_value_type_t<float&>, float const&>::value));
+  VERIFY((std::is_same<internal::add_const_on_value_type_t<float*>, float const*>::value));
 
-  int data[5] = {0, 1, 2, 3, 4};
-  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 0>(data).c), 0);
-  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 1>(data).c), 1);
-  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 2>(data).c), 2);
-  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 3>(data).c), 3);
-  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 4>(data).c), 4);
-  VERIFY_IS_EQUAL((instantiate_by_c_array<dummy_inst, int, 5>(data).c), 5);
-}
+  VERIFY((std::is_same<internal::add_const_on_value_type_t<float>, const float>::value));
+  VERIFY((std::is_same<internal::add_const_on_value_type_t<const float>, const float>::value));
 
-EIGEN_DECLARE_TEST(cxx11_meta) {
-  CALL_SUBTEST(test_gen_numeric_list());
+  VERIFY((std::is_same<internal::add_const_on_value_type_t<const float* const>, const float* const>::value));
+  VERIFY((std::is_same<internal::add_const_on_value_type_t<float* const>, const float* const>::value));
+
+  // is_convertible
+  STATIC_CHECK((std::is_convertible<float, double>::value));
+  STATIC_CHECK((std::is_convertible<int, double>::value));
+  STATIC_CHECK((std::is_convertible<int, short>::value));
+  STATIC_CHECK((std::is_convertible<short, int>::value));
+  STATIC_CHECK((std::is_convertible<double, int>::value));
+  STATIC_CHECK((std::is_convertible<double, std::complex<double>>::value));
+  STATIC_CHECK((!std::is_convertible<std::complex<double>, double>::value));
+  STATIC_CHECK((std::is_convertible<Array33f, Matrix3f>::value));
+  STATIC_CHECK((std::is_convertible<Matrix3f&, Matrix3f>::value));
+  STATIC_CHECK((std::is_convertible<Matrix3f&, Matrix3f&>::value));
+  STATIC_CHECK((std::is_convertible<Matrix3f&, const Matrix3f&>::value));
+  STATIC_CHECK((std::is_convertible<const Matrix3f&, Matrix3f>::value));
+  STATIC_CHECK((std::is_convertible<const Matrix3f&, const Matrix3f&>::value));
+  STATIC_CHECK((!std::is_convertible<const Matrix3f&, Matrix3f&>::value));
+  STATIC_CHECK((!std::is_convertible<const Matrix3f, Matrix3f&>::value));
+  STATIC_CHECK(!(std::is_convertible<Matrix3f, Matrix3f&>::value));
+
+  STATIC_CHECK(!(std::is_convertible<int, int&>::value));
+  STATIC_CHECK((std::is_convertible<const int, const int&>::value));
+
+  // STATIC_CHECK((!std::is_convertible<Matrix3f,Matrix3d>::value )); //does not even compile because the
+  // conversion is prevented by a static assertion
+  STATIC_CHECK((!std::is_convertible<Array33f, int>::value));
+  STATIC_CHECK((!std::is_convertible<MatrixXf, float>::value));
+  {
+    MatrixXf A, B;
+    VectorXf a, b;
+    VERIFY((std::is_convertible<decltype(a.dot(b)), float>::value));
+    VERIFY((std::is_convertible<decltype(a.transpose() * b), float>::value));
+    VERIFY((!std::is_convertible<decltype(A * B), float>::value));
+    VERIFY((std::is_convertible<decltype(A * B), MatrixXf>::value));
+  }
+
+  {
+    VERIFY((std::is_convertible<decltype(fix<3>()), int>::value));
+    VERIFY((!std::is_convertible<int, decltype(fix<DynamicIndex>())>::value));
+  }
+
+  VERIFY((internal::has_ReturnType<FooReturnType>::value));
+  VERIFY((internal::has_ReturnType<ScalarBinaryOpTraits<int, int>>::value));
+  VERIFY((!internal::has_ReturnType<MatrixXf>::value));
+  VERIFY((!internal::has_ReturnType<int>::value));
+
+  // size_at_compile_time falls back to Dynamic rather than overflowing int
+  // (46341^2 is the first square past INT_MAX).
+  STATIC_CHECK((internal::size_at_compile_time(0, Dynamic) == 0));
+  STATIC_CHECK((internal::size_at_compile_time(3, Dynamic) == Dynamic));
+  STATIC_CHECK((internal::size_at_compile_time(46340, 46340) == 46340 * 46340));
+  STATIC_CHECK((internal::size_at_compile_time(46341, 46341) == Dynamic));
+  STATIC_CHECK((internal::size_at_compile_time(1 << 16, 1 << 16) == Dynamic));
+
   CALL_SUBTEST(test_concat());
   CALL_SUBTEST(test_slice());
   CALL_SUBTEST(test_get());
-  CALL_SUBTEST(test_id());
   CALL_SUBTEST(test_is_same_gf());
   CALL_SUBTEST(test_apply_op());
   CALL_SUBTEST(test_contained_in_list());
   CALL_SUBTEST(test_arg_reductions());
-  CALL_SUBTEST(test_array_reverse_and_reduce());
-  CALL_SUBTEST(test_array_zip_and_apply());
-  CALL_SUBTEST(test_array_misc());
+  CALL_SUBTEST(test_array_reductions());
 }
diff --git a/test/metis_support.cpp b/test/metis_support.cpp
index cfbea3a..e782db0 100644
--- a/test/metis_support.cpp
+++ b/test/metis_support.cpp
@@ -6,11 +6,12 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 #include <Eigen/SparseLU>
 #include <Eigen/MetisSupport>
-#include <unsupported/Eigen/SparseExtra>
+#include <contrib/Eigen/SparseExtra>
 
 template <typename T>
 void test_metis_T() {
diff --git a/test/minres.cpp b/test/minres.cpp
new file mode 100644
index 0000000..5957d79
--- /dev/null
+++ b/test/minres.cpp
@@ -0,0 +1,63 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2012 Giacomo Po <gpo@ucla.edu>
+// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+#include <cmath>
+
+#include "sparse_solver.h"
+#include <Eigen/IterativeLinearSolvers>
+
+template <typename T>
+void test_minres_T() {
+  // Identity preconditioner
+  MINRES<SparseMatrix<T>, Lower, IdentityPreconditioner> minres_colmajor_lower_I;
+  MINRES<SparseMatrix<T>, Upper, IdentityPreconditioner> minres_colmajor_upper_I;
+
+  // Diagonal preconditioner
+  MINRES<SparseMatrix<T>, Lower, DiagonalPreconditioner<T> > minres_colmajor_lower_diag;
+  MINRES<SparseMatrix<T>, Upper, DiagonalPreconditioner<T> > minres_colmajor_upper_diag;
+  MINRES<SparseMatrix<T>, Lower | Upper, DiagonalPreconditioner<T> > minres_colmajor_uplo_diag;
+
+  // call tests for SPD matrix
+  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_lower_I));
+  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_upper_I));
+
+  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_lower_diag));
+  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_upper_diag));
+  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_uplo_diag));
+
+  // TO DO: symmetric semi-definite matrix
+  // TO DO: symmetric indefinite matrix
+}
+
+void test_minres_extreme_rhs() {
+  const Matrix2d mat = Matrix2d::Identity();
+  const Vector2d direction = (Vector2d() << 1, -1).finished();
+  MINRES<Matrix2d, Lower | Upper, IdentityPreconditioner> solver(mat);
+  solver.setTolerance(1e-12);
+
+  for (double scale : {1e-200, 1e200}) {
+    const Vector2d rhs = scale * direction;
+    const Vector2d guess = 0.5 * rhs;
+    Vector2d x = solver.solve(rhs);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+
+    x = solver.solveWithGuess(rhs, guess);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY(x.allFinite());
+    VERIFY_IS_APPROX(x / scale, direction);
+  }
+}
+
+EIGEN_DECLARE_TEST(minres) {
+  CALL_SUBTEST_1(test_minres_T<double>());
+  CALL_SUBTEST_3(test_minres_extreme_rhs());
+}
diff --git a/test/miscmatrices.cpp b/test/miscmatrices.cpp
index e3506af..823cc68 100644
--- a/test/miscmatrices.cpp
+++ b/test/miscmatrices.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/mixingtypes.cpp b/test/mixingtypes.cpp
index 78032b5..c714467 100644
--- a/test/mixingtypes.cpp
+++ b/test/mixingtypes.cpp
@@ -7,23 +7,12 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
-#if defined(EIGEN_TEST_PART_7)
-
-// ignore double-promotion diagnostic for clang and gcc, if we check for static assertion anyway:
-// TODO do the same for MSVC?
-#if defined(__clang__)
-#if (__clang_major__ * 100 + __clang_minor__) >= 308
-#pragma clang diagnostic ignored "-Wdouble-promotion"
-#endif
-#elif defined(__GNUC__)
-// TODO is there a minimal GCC version for this? At least g++-4.7 seems to be fine with this.
-#pragma GCC diagnostic ignored "-Wdouble-promotion"
-#endif
-
-#endif
-
-#if defined(EIGEN_TEST_PART_1) || defined(EIGEN_TEST_PART_2) || defined(EIGEN_TEST_PART_3)
+// Subtests 1, 2, 3, 8 and 9 build without vectorization; 4, 5, 6, 10 and 11 are their
+// vectorized counterparts.
+#if defined(EIGEN_TEST_PART_1) || defined(EIGEN_TEST_PART_2) || defined(EIGEN_TEST_PART_3) || \
+    defined(EIGEN_TEST_PART_8) || defined(EIGEN_TEST_PART_9)
 
 #ifndef EIGEN_DONT_VECTORIZE
 #define EIGEN_DONT_VECTORIZE
@@ -33,7 +22,7 @@
 
 static bool g_called;
 #define EIGEN_SCALAR_BINARY_OP_PLUGIN \
-  { g_called |= (!internal::is_same<LhsScalar, RhsScalar>::value); }
+  { g_called |= (!std::is_same<LhsScalar, RhsScalar>::value); }
 
 #include "main.h"
 
@@ -44,8 +33,9 @@
   VERIFY_IS_APPROX(XPR, REF);       \
   VERIFY(g_called&& #XPR " not properly optimized");
 
+// Scalar and coefficient-wise mixed-type operations, and compound assignment.
 template <int SizeAtCompileType>
-void mixingtypes(int size = SizeAtCompileType) {
+void mixingtypes_scalar(int size = SizeAtCompileType) {
   typedef std::complex<float> CF;
   typedef std::complex<double> CD;
   typedef Matrix<float, SizeAtCompileType, SizeAtCompileType> Mat_f;
@@ -89,9 +79,9 @@
   VERIFY_MIX_SCALAR(scd * vd, scd * vd.template cast<complex<double> >());
 
   VERIFY_MIX_SCALAR(vcf * 2, vcf * complex<float>(2));
-  VERIFY_MIX_SCALAR(vcf * 2.1, vcf * complex<float>(2.1));
+  VERIFY_MIX_SCALAR(vcf * 2.1, vcf * complex<float>(2.1f));
   VERIFY_MIX_SCALAR(2 * vcf, vcf * complex<float>(2));
-  VERIFY_MIX_SCALAR(2.1 * vcf, vcf * complex<float>(2.1));
+  VERIFY_MIX_SCALAR(2.1 * vcf, vcf * complex<float>(2.1f));
 
   // check scalar quotients
   VERIFY_MIX_SCALAR(vcf / sf, vcf / complex<float>(sf));
@@ -136,38 +126,126 @@
   // check outer product
   VERIFY_IS_APPROX((vf * vcf.transpose()).eval(), (vf.template cast<complex<float> >() * vcf.transpose()).eval());
 
-  // coeff wise product
+  rcd.setZero();
+  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = sd * mcd * md),
+                   Mat_cd((sd * mcd * md.template cast<CD>().eval()).template triangularView<Upper>()));
+  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = sd * md * mcd),
+                   Mat_cd((sd * md.template cast<CD>().eval() * mcd).template triangularView<Upper>()));
+  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = scd * mcd * md),
+                   Mat_cd((scd * mcd * md.template cast<CD>().eval()).template triangularView<Upper>()));
+  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = scd * md * mcd),
+                   Mat_cd((scd * md.template cast<CD>().eval() * mcd).template triangularView<Upper>()));
 
-  VERIFY_IS_APPROX((vf * vcf.transpose()).eval(), (vf.template cast<complex<float> >() * vcf.transpose()).eval());
+  VERIFY_IS_APPROX(md.array() * mcd.array(), md.template cast<CD>().eval().array() * mcd.array());
+  VERIFY_IS_APPROX(mcd.array() * md.array(), mcd.array() * md.template cast<CD>().eval().array());
 
-  Mat_cd mcd2 = mcd;
-  VERIFY_IS_APPROX(mcd.array() *= md.array(), mcd2.array() *= md.array().template cast<std::complex<double> >());
+  VERIFY_IS_APPROX(md.array() + mcd.array(), md.template cast<CD>().eval().array() + mcd.array());
+  VERIFY_IS_APPROX(mcd.array() + md.array(), mcd.array() + md.template cast<CD>().eval().array());
 
-  // check matrix-matrix products
-  VERIFY_IS_APPROX(sd * md * mcd, (sd * md).template cast<CD>().eval() * mcd);
-  VERIFY_IS_APPROX(sd * mcd * md, sd * mcd * md.template cast<CD>());
-  VERIFY_IS_APPROX(scd * md * mcd, scd * md.template cast<CD>().eval() * mcd);
-  VERIFY_IS_APPROX(scd * mcd * md, scd * mcd * md.template cast<CD>());
+  VERIFY_IS_APPROX(md.array() - mcd.array(), md.template cast<CD>().eval().array() - mcd.array());
+  VERIFY_IS_APPROX(mcd.array() - md.array(), mcd.array() - md.template cast<CD>().eval().array());
 
+  if (mcd.array().abs().minCoeff() > epsd) {
+    VERIFY_IS_APPROX(md.array() / mcd.array(), md.template cast<CD>().eval().array() / mcd.array());
+  }
+  if (md.array().abs().minCoeff() > epsd) {
+    VERIFY_IS_APPROX(mcd.array() / md.array(), mcd.array() / md.template cast<CD>().eval().array());
+  }
+
+  // Norm-based comparisons require finite powers; zero bases are checked separately below.
+  const Mat_d power_base_d = (md.array().abs() > epsd).select(md.array(), 1.0);
+  const Mat_cd power_base_cd = (mcd.array().abs() > epsd).select(mcd.array(), CD(1));
+  VERIFY_IS_APPROX(power_base_d.array().pow(mcd.array()),
+                   power_base_d.template cast<CD>().eval().array().pow(mcd.array()));
+  VERIFY_IS_APPROX(power_base_cd.array().pow(md.array()),
+                   power_base_cd.array().pow(md.template cast<CD>().eval().array()));
+
+  VERIFY_IS_APPROX(pow(power_base_d.array(), mcd.array()),
+                   power_base_d.template cast<CD>().eval().array().pow(mcd.array()));
+  VERIFY_IS_APPROX(pow(power_base_cd.array(), md.array()),
+                   power_base_cd.array().pow(md.template cast<CD>().eval().array()));
+
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd = md, md.template cast<CD>().eval());
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd += md, mcd + md.template cast<CD>().eval());
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd -= md, mcd - md.template cast<CD>().eval());
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd.array() *= md.array(), mcd.array() * md.template cast<CD>().eval().array());
+  rcd = mcd;
+  if (md.array().abs().minCoeff() > epsd) {
+    VERIFY_IS_APPROX(rcd.array() /= md.array(), mcd.array() / md.template cast<CD>().eval().array());
+  }
+
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd.noalias() += md + mcd * md,
+                   mcd + (md.template cast<CD>().eval()) + mcd * (md.template cast<CD>().eval()));
+
+  VERIFY_IS_APPROX(rcd.noalias() = md * md, ((md * md).eval().template cast<CD>()));
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd.noalias() += md * md, mcd + ((md * md).eval().template cast<CD>()));
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd.noalias() -= md * md, mcd - ((md * md).eval().template cast<CD>()));
+
+  VERIFY_IS_APPROX(rcd.noalias() = mcd + md * md, mcd + ((md * md).eval().template cast<CD>()));
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd.noalias() += mcd + md * md, mcd + mcd + ((md * md).eval().template cast<CD>()));
+  rcd = mcd;
+  VERIFY_IS_APPROX(rcd.noalias() -= mcd + md * md, -((md * md).eval().template cast<CD>()));
+}
+
+// Mixed-type products in the float / complex<float> family. Split from the double
+// family because each carries its own GEMM and GEMV instantiations; together they made
+// the two Dynamic subtests the slowest units in the official test suite.
+template <int SizeAtCompileType>
+void mixingtypes_product_f(int size = SizeAtCompileType) {
+  typedef std::complex<float> CF;
+  typedef Matrix<float, SizeAtCompileType, SizeAtCompileType> Mat_f;
+  typedef Matrix<std::complex<float>, SizeAtCompileType, SizeAtCompileType> Mat_cf;
+  typedef Matrix<float, SizeAtCompileType, 1> Vec_f;
+  typedef Matrix<std::complex<float>, SizeAtCompileType, 1> Vec_cf;
+
+  Mat_f mf = Mat_f::Random(size, size);
+  Mat_cf mcf = Mat_cf::Random(size, size);
+  Vec_f vf = Vec_f::Random(size, 1);
+  Vec_cf vcf = Vec_cf::Random(size, 1);
+  float sf = internal::random<float>();
+  complex<float> scf = internal::random<complex<float> >();
+
+  float epsf = std::sqrt(std::numeric_limits<float>::min EIGEN_EMPTY());
+
+  if (std::abs(sf) < epsf) sf = 1.0f;
+  if (std::abs(scf) < epsf) scf = CF(1);
+
+  // check matrix-matrix, matrix-vector and compound products
   VERIFY_IS_APPROX(sf * mf * mcf, sf * mf.template cast<CF>() * mcf);
   VERIFY_IS_APPROX(sf * mcf * mf, sf * mcf * mf.template cast<CF>());
   VERIFY_IS_APPROX(scf * mf * mcf, scf * mf.template cast<CF>() * mcf);
   VERIFY_IS_APPROX(scf * mcf * mf, scf * mcf * mf.template cast<CF>());
 
-  VERIFY_IS_APPROX(sd * md.adjoint() * mcd, (sd * md).template cast<CD>().eval().adjoint() * mcd);
-  VERIFY_IS_APPROX(sd * mcd.adjoint() * md, sd * mcd.adjoint() * md.template cast<CD>());
-  VERIFY_IS_APPROX(sd * md.adjoint() * mcd.adjoint(), (sd * md).template cast<CD>().eval().adjoint() * mcd.adjoint());
-  VERIFY_IS_APPROX(sd * mcd.adjoint() * md.adjoint(), sd * mcd.adjoint() * md.template cast<CD>().adjoint());
-  VERIFY_IS_APPROX(sd * md * mcd.adjoint(), (sd * md).template cast<CD>().eval() * mcd.adjoint());
-  VERIFY_IS_APPROX(sd * mcd * md.adjoint(), sd * mcd * md.template cast<CD>().adjoint());
-
   VERIFY_IS_APPROX(sf * mf.adjoint() * mcf, (sf * mf).template cast<CF>().eval().adjoint() * mcf);
   VERIFY_IS_APPROX(sf * mcf.adjoint() * mf, sf * mcf.adjoint() * mf.template cast<CF>());
   VERIFY_IS_APPROX(sf * mf.adjoint() * mcf.adjoint(), (sf * mf).template cast<CF>().eval().adjoint() * mcf.adjoint());
   VERIFY_IS_APPROX(sf * mcf.adjoint() * mf.adjoint(), sf * mcf.adjoint() * mf.template cast<CF>().adjoint());
+
   VERIFY_IS_APPROX(sf * mf * mcf.adjoint(), (sf * mf).template cast<CF>().eval() * mcf.adjoint());
   VERIFY_IS_APPROX(sf * mcf * mf.adjoint(), sf * mcf * mf.template cast<CF>().adjoint());
 
+  // Mixed-type fixed-size compound products (noalias() += / -=) must fall back to the generic
+  // (scalar) path: the small-fixed packet cascade only engages when lhs and rhs share a scalar
+  // type, otherwise it would read a wrong-width packet out of an operand. See
+  // product_packet_cascade_traits::Enable (this previously failed to compile for fixed sizes).
+  {
+    Mat_cf acc = Mat_cf::Random(size, size), refcf = acc;
+    acc.noalias() += mf * mcf;
+    refcf += mf.template cast<CF>().eval() * mcf;
+    VERIFY_IS_APPROX(acc, refcf);
+    acc.noalias() -= mcf * mf;
+    refcf -= mcf * mf.template cast<CF>().eval();
+    VERIFY_IS_APPROX(acc, refcf);
+  }
+
   VERIFY_IS_APPROX(sf * mf * vcf, (sf * mf).template cast<CF>().eval() * vcf);
   VERIFY_IS_APPROX(scf * mf * vcf, (scf * mf.template cast<CF>()).eval() * vcf);
   VERIFY_IS_APPROX(sf * mcf * vf, sf * mcf * vf.template cast<CF>());
@@ -177,6 +255,59 @@
   VERIFY_IS_APPROX(scf * vcf.adjoint() * mf, scf * vcf.adjoint() * mf.template cast<CF>().eval());
   VERIFY_IS_APPROX(sf * vf.adjoint() * mcf, sf * vf.adjoint().template cast<CF>().eval() * mcf);
   VERIFY_IS_APPROX(scf * vf.adjoint() * mcf, scf * vf.adjoint().template cast<CF>().eval() * mcf);
+}
+
+// Mixed-type products in the double / complex<double> family.
+template <int SizeAtCompileType>
+void mixingtypes_product_d(int size = SizeAtCompileType) {
+  typedef std::complex<double> CD;
+  typedef Matrix<float, SizeAtCompileType, SizeAtCompileType> Mat_f;
+  typedef Matrix<double, SizeAtCompileType, SizeAtCompileType> Mat_d;
+  typedef Matrix<std::complex<float>, SizeAtCompileType, SizeAtCompileType> Mat_cf;
+  typedef Matrix<std::complex<double>, SizeAtCompileType, SizeAtCompileType> Mat_cd;
+  typedef Matrix<float, SizeAtCompileType, 1> Vec_f;
+  typedef Matrix<double, SizeAtCompileType, 1> Vec_d;
+  typedef Matrix<std::complex<float>, SizeAtCompileType, 1> Vec_cf;
+  typedef Matrix<std::complex<double>, SizeAtCompileType, 1> Vec_cd;
+
+  Mat_f mf = Mat_f::Random(size, size);
+  Mat_d md = mf.template cast<double>();
+  Mat_cf mcf = Mat_cf::Random(size, size);
+  Mat_cd mcd = mcf.template cast<complex<double> >();
+  Vec_f vf = Vec_f::Random(size, 1);
+  Vec_d vd = vf.template cast<double>();
+  Vec_cf vcf = Vec_cf::Random(size, 1);
+  Vec_cd vcd = vcf.template cast<complex<double> >();
+  double sd = internal::random<double>();
+  complex<double> scd = internal::random<complex<double> >();
+
+  double epsd = std::sqrt(std::numeric_limits<double>::min EIGEN_EMPTY());
+
+  if (std::abs(sd) < epsd) sd = 1.0;
+  if (std::abs(scd) < epsd) scd = CD(1);
+
+  // check matrix-matrix, matrix-vector and compound products
+  VERIFY_IS_APPROX(sd * md * mcd, (sd * md).template cast<CD>().eval() * mcd);
+  VERIFY_IS_APPROX(sd * mcd * md, sd * mcd * md.template cast<CD>());
+  VERIFY_IS_APPROX(scd * md * mcd, scd * md.template cast<CD>().eval() * mcd);
+  VERIFY_IS_APPROX(scd * mcd * md, scd * mcd * md.template cast<CD>());
+
+  VERIFY_IS_APPROX(sd * md.adjoint() * mcd, (sd * md).template cast<CD>().eval().adjoint() * mcd);
+  VERIFY_IS_APPROX(sd * mcd.adjoint() * md, sd * mcd.adjoint() * md.template cast<CD>());
+  VERIFY_IS_APPROX(sd * md.adjoint() * mcd.adjoint(), (sd * md).template cast<CD>().eval().adjoint() * mcd.adjoint());
+  VERIFY_IS_APPROX(sd * mcd.adjoint() * md.adjoint(), sd * mcd.adjoint() * md.template cast<CD>().adjoint());
+  VERIFY_IS_APPROX(sd * md * mcd.adjoint(), (sd * md).template cast<CD>().eval() * mcd.adjoint());
+  VERIFY_IS_APPROX(sd * mcd * md.adjoint(), sd * mcd * md.template cast<CD>().adjoint());
+
+  {
+    Mat_cd acc = Mat_cd::Random(size, size), refcd = acc;
+    acc.noalias() += md * mcd;
+    refcd += md.template cast<CD>().eval() * mcd;
+    VERIFY_IS_APPROX(acc, refcd);
+    acc.noalias() -= mcd * md;
+    refcd -= mcd * md.template cast<CD>().eval();
+    VERIFY_IS_APPROX(acc, refcd);
+  }
 
   VERIFY_IS_APPROX(sd * md * vcd, (sd * md).template cast<CD>().eval() * vcd);
   VERIFY_IS_APPROX(scd * md * vcd, (scd * md.template cast<CD>()).eval() * vcd);
@@ -227,80 +358,65 @@
   //   VERIFY_IS_APPROX(sd*vd.adjoint()*mcd.template selfadjointView<Upper>(),  sd*vd.adjoint().template
   //   cast<CD>().eval()*mcd.template selfadjointView<Upper>()); VERIFY_IS_APPROX(scd*vd.adjoint()*mcd.template
   //   selfadjointView<Upper>(), scd*vd.adjoint().template cast<CD>().eval()*mcd.template selfadjointView<Upper>());
+}
 
-  rcd.setZero();
-  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = sd * mcd * md),
-                   Mat_cd((sd * mcd * md.template cast<CD>().eval()).template triangularView<Upper>()));
-  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = sd * md * mcd),
-                   Mat_cd((sd * md.template cast<CD>().eval() * mcd).template triangularView<Upper>()));
-  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = scd * mcd * md),
-                   Mat_cd((scd * mcd * md.template cast<CD>().eval()).template triangularView<Upper>()));
-  VERIFY_IS_APPROX(Mat_cd(rcd.template triangularView<Upper>() = scd * md * mcd),
-                   Mat_cd((scd * md.template cast<CD>().eval() * mcd).template triangularView<Upper>()));
-
-  VERIFY_IS_APPROX(md.array() * mcd.array(), md.template cast<CD>().eval().array() * mcd.array());
-  VERIFY_IS_APPROX(mcd.array() * md.array(), mcd.array() * md.template cast<CD>().eval().array());
-
-  VERIFY_IS_APPROX(md.array() + mcd.array(), md.template cast<CD>().eval().array() + mcd.array());
-  VERIFY_IS_APPROX(mcd.array() + md.array(), mcd.array() + md.template cast<CD>().eval().array());
-
-  VERIFY_IS_APPROX(md.array() - mcd.array(), md.template cast<CD>().eval().array() - mcd.array());
-  VERIFY_IS_APPROX(mcd.array() - md.array(), mcd.array() - md.template cast<CD>().eval().array());
-
-  if (mcd.array().abs().minCoeff() > epsd) {
-    VERIFY_IS_APPROX(md.array() / mcd.array(), md.template cast<CD>().eval().array() / mcd.array());
+template <typename Real>
+void mixingtypes_zero_power() {
+  using Complex = std::complex<Real>;
+  // Runtime inputs avoid compiler folding of 0^0 that differs from the library call.
+  volatile Real zero = 0;
+  volatile Real exponents[5][2] = {{2, 0}, {0, 0}, {-1, 0}, {Real(-0.329765), Real(0.755738)}, {Real(0.5), Real(0.25)}};
+  const Array<Real, 5, 1> real_bases = Array<Real, 5, 1>::Constant(Real(zero));
+  const Array<Complex, 5, 1> complex_bases = Array<Complex, 5, 1>::Constant(Complex(Real(zero)));
+  Array<Complex, 5, 1> complex_exponents;
+  for (Index i = 0; i < real_bases.size(); ++i)
+    complex_exponents[i] = Complex(Real(exponents[i][0]), Real(exponents[i][1]));
+  const Array<Real, 5, 1> real_exponents = complex_exponents.real();
+  Array<Complex, 5, 2> expected, member_power, free_power;
+  for (Index i = 0; i < real_bases.size(); ++i) {
+    // The real/complex std::pow overloads can differ at zero; compare each component, including NaN and Inf.
+    expected(i, 0) = std::pow(real_bases[i], complex_exponents[i]);
+    expected(i, 1) = std::pow(complex_bases[i], real_exponents[i]);
   }
-  if (md.array().abs().minCoeff() > epsd) {
-    VERIFY_IS_APPROX(mcd.array() / md.array(), mcd.array() / md.template cast<CD>().eval().array());
-  }
+  member_power.col(0) = real_bases.pow(complex_exponents);
+  member_power.col(1) = complex_bases.pow(real_exponents);
+  free_power.col(0) = Eigen::pow(real_bases, complex_exponents);
+  free_power.col(1) = Eigen::pow(complex_bases, real_exponents);
+  VERIFY_IS_CWISE_EQUAL(member_power.real(), expected.real());
+  VERIFY_IS_CWISE_EQUAL(member_power.imag(), expected.imag());
+  VERIFY_IS_CWISE_EQUAL(free_power.real(), expected.real());
+  VERIFY_IS_CWISE_EQUAL(free_power.imag(), expected.imag());
+  VERIFY_IS_EQUAL(member_power(0, 0), Complex(0));
+  VERIFY_IS_EQUAL(member_power(0, 1), Complex(0));
+}
 
-  if (md.array().abs().minCoeff() > epsd || mcd.array().abs().minCoeff() > epsd) {
-    VERIFY_IS_APPROX(md.array().pow(mcd.array()), md.template cast<CD>().eval().array().pow(mcd.array()));
-    VERIFY_IS_APPROX(mcd.array().pow(md.array()), mcd.array().pow(md.template cast<CD>().eval().array()));
-
-    VERIFY_IS_APPROX(pow(md.array(), mcd.array()), md.template cast<CD>().eval().array().pow(mcd.array()));
-    VERIFY_IS_APPROX(pow(mcd.array(), md.array()), mcd.array().pow(md.template cast<CD>().eval().array()));
-  }
-
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd = md, md.template cast<CD>().eval());
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd += md, mcd + md.template cast<CD>().eval());
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd -= md, mcd - md.template cast<CD>().eval());
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd.array() *= md.array(), mcd.array() * md.template cast<CD>().eval().array());
-  rcd = mcd;
-  if (md.array().abs().minCoeff() > epsd) {
-    VERIFY_IS_APPROX(rcd.array() /= md.array(), mcd.array() / md.template cast<CD>().eval().array());
-  }
-
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd.noalias() += md + mcd * md,
-                   mcd + (md.template cast<CD>().eval()) + mcd * (md.template cast<CD>().eval()));
-
-  VERIFY_IS_APPROX(rcd.noalias() = md * md, ((md * md).eval().template cast<CD>()));
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd.noalias() += md * md, mcd + ((md * md).eval().template cast<CD>()));
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd.noalias() -= md * md, mcd - ((md * md).eval().template cast<CD>()));
-
-  VERIFY_IS_APPROX(rcd.noalias() = mcd + md * md, mcd + ((md * md).eval().template cast<CD>()));
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd.noalias() += mcd + md * md, mcd + mcd + ((md * md).eval().template cast<CD>()));
-  rcd = mcd;
-  VERIFY_IS_APPROX(rcd.noalias() -= mcd + md * md, -((md * md).eval().template cast<CD>()));
+template <int SizeAtCompileType>
+void mixingtypes(int size = SizeAtCompileType) {
+  mixingtypes_scalar<SizeAtCompileType>(size);
+  mixingtypes_product_f<SizeAtCompileType>(size);
+  mixingtypes_product_d<SizeAtCompileType>(size);
 }
 
 EIGEN_DECLARE_TEST(mixingtypes) {
-  g_called = false;  // Silence -Wunneeded-internal-declaration.
+  g_called = false;  // Silence -Wunneeded-internal-declaration and set_but_not_used.
+  VERIFY(true || g_called);
+  CALL_SUBTEST_3(mixingtypes_zero_power<float>());
+  CALL_SUBTEST_3(mixingtypes_zero_power<double>());
+  CALL_SUBTEST_6(mixingtypes_zero_power<float>());
+  CALL_SUBTEST_6(mixingtypes_zero_power<double>());
   for (int i = 0; i < g_repeat; i++) {
+    // The fixed sizes stay whole. Only the Dynamic cases are worth three units each: they
+    // are the ones that instantiate the full GEMM and GEMV machinery.
     CALL_SUBTEST_1(mixingtypes<3>());
     CALL_SUBTEST_2(mixingtypes<4>());
-    CALL_SUBTEST_3(mixingtypes<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+    CALL_SUBTEST_3(mixingtypes_scalar<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+    CALL_SUBTEST_8(mixingtypes_product_f<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+    CALL_SUBTEST_9(mixingtypes_product_d<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
 
     CALL_SUBTEST_4(mixingtypes<3>());
     CALL_SUBTEST_5(mixingtypes<4>());
-    CALL_SUBTEST_6(mixingtypes<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+    CALL_SUBTEST_6(mixingtypes_scalar<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+    CALL_SUBTEST_10(mixingtypes_product_f<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+    CALL_SUBTEST_11(mixingtypes_product_d<Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
   }
 }
diff --git a/test/mixingtypes_generic_32.cpp b/test/mixingtypes_generic_32.cpp
new file mode 100644
index 0000000..c60a834
--- /dev/null
+++ b/test/mixingtypes_generic_32.cpp
@@ -0,0 +1,6 @@
+// Force the generic clang vector backend with 32-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+#define EIGEN_VECTORIZE_GENERIC 1
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 32
+#include "mixingtypes.cpp"
diff --git a/test/mixingtypes_generic_64.cpp b/test/mixingtypes_generic_64.cpp
new file mode 100644
index 0000000..42ee7ee
--- /dev/null
+++ b/test/mixingtypes_generic_64.cpp
@@ -0,0 +1,6 @@
+// Force the generic clang vector backend with 64-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+#define EIGEN_VECTORIZE_GENERIC 1
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 64
+#include "mixingtypes.cpp"
diff --git a/test/nestbyvalue.cpp b/test/nestbyvalue.cpp
index f65621a..52cba6d 100644
--- a/test/nestbyvalue.cpp
+++ b/test/nestbyvalue.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 
diff --git a/test/nesting_ops.cpp b/test/nesting_ops.cpp
index ec47e21..c7037db 100644
--- a/test/nesting_ops.cpp
+++ b/test/nesting_ops.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 
@@ -24,7 +25,7 @@
 template <int N, typename ReferenceType, typename XprType>
 bool verify_eval_type(const XprType&, const ReferenceType&) {
   typedef typename internal::nested_eval<XprType, N>::type EvalType;
-  return internal::is_same<internal::remove_all_t<EvalType>, internal::remove_all_t<ReferenceType>>::value;
+  return std::is_same<internal::remove_all_t<EvalType>, internal::remove_all_t<ReferenceType>>::value;
 }
 
 template <typename MatrixType>
@@ -97,5 +98,5 @@
   CALL_SUBTEST_2(run_nesting_ops_2(MatrixXcd(s, s)));
   CALL_SUBTEST_3(run_nesting_ops_2(Matrix4f()));
   CALL_SUBTEST_4(run_nesting_ops_2(Matrix2d()));
-  TEST_SET_BUT_UNUSED_VARIABLE(s)
+  TEST_SET_BUT_UNUSED_VARIABLE(s);
 }
diff --git a/test/no_automatic_resizing.cpp b/test/no_automatic_resizing.cpp
index 6156471..66d1a78 100644
--- a/test/no_automatic_resizing.cpp
+++ b/test/no_automatic_resizing.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // Test that EIGEN_NO_AUTOMATIC_RESIZING still allows assignment to
 // default-constructed (empty) matrices and arrays.
diff --git a/test/nomalloc.cpp b/test/nomalloc.cpp
index c9956d3..01fe6fd 100644
--- a/test/nomalloc.cpp
+++ b/test/nomalloc.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // discard stack allocation as that too bypasses malloc
 #define EIGEN_STACK_ALLOCATION_LIMIT 0
@@ -25,6 +26,7 @@
   /* this test check no dynamic memory allocation are issued with fixed-size matrices
    */
   typedef typename MatrixType::Scalar Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
 
   Index rows = m.rows();
   Index cols = m.cols();
@@ -77,6 +79,12 @@
   m2.template selfadjointView<Upper>().rankUpdate(m1.row(0), -1);
   m2.template selfadjointView<Lower>().rankUpdate(m1.col(0), m1.col(0));  // rank-2
 
+  MatrixType spd = m1 * m1.adjoint();
+  spd.diagonal().array() += RealScalar(rows);
+  LLT<MatrixType> llt(spd);
+  VERIFY_IS_EQUAL(llt.info(), Success);
+  llt.rankUpdate(m1.col(0), RealScalar(1));
+
   // The following fancy matrix-matrix products are not safe yet regarding static allocation
   m2.template selfadjointView<Lower>().rankUpdate(m1);
   m2 += m2.template triangularView<Upper>() * m1;
@@ -108,6 +116,9 @@
   LLT.compute(A);
   X = LLT.solve(B);
   x = LLT.solve(b);
+  LLT.compute(saA);
+  VERIFY_IS_EQUAL(LLT.info(), Eigen::Success);
+  LLT.rankUpdate(b, Scalar(1));
   Eigen::LDLT<Matrix> LDLT;
   LDLT.compute(A);
   X = LDLT.solve(B);
@@ -156,6 +167,17 @@
   jSVD.compute(A);
 }
 
+template <typename Scalar>
+void selfadjoint_eigensolver_large_fixed_no_malloc() {
+  typedef Eigen::Matrix<Scalar, 96, 96> Matrix;
+  Matrix A = Matrix::Random();
+  Matrix saA = A.adjoint() * A;
+
+  Eigen::SelfAdjointEigenSolver<Matrix> solver;
+  solver.compute(saA);
+  VERIFY_IS_EQUAL(solver.info(), Eigen::Success);
+}
+
 void test_zerosized() {
   // default constructors:
   Eigen::MatrixXd A;
@@ -219,6 +241,8 @@
 
   // Check decomposition modules with dynamic matrices that have a known compile-time max size (ctms)
   CALL_SUBTEST_4(ctms_decompositions<float>());
+  CALL_SUBTEST_9(selfadjoint_eigensolver_large_fixed_no_malloc<float>());
+  CALL_SUBTEST_10(selfadjoint_eigensolver_large_fixed_no_malloc<double>());
 
   CALL_SUBTEST_5(test_zerosized());
 
diff --git a/test/nullary.cpp b/test/nullary.cpp
index a54c618..30e51a9 100644
--- a/test/nullary.cpp
+++ b/test/nullary.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -34,8 +35,8 @@
   typedef typename VectorType::Scalar Scalar;
   typedef typename VectorType::RealScalar RealScalar;
 
-  RealScalar prec = internal::is_same<RealScalar, float>::value ? NumTraits<RealScalar>::dummy_precision() * 10
-                                                                : NumTraits<RealScalar>::dummy_precision() / 10;
+  RealScalar prec = std::is_same<RealScalar, float>::value ? NumTraits<RealScalar>::dummy_precision() * 10
+                                                           : NumTraits<RealScalar>::dummy_precision() / 10;
   Index size = v.size();
 
   if (size < 20) return;
@@ -106,19 +107,13 @@
     // random access version
     m = VectorType::LinSpaced(size, low, high);
     VERIFY_IS_APPROX(m, n);
-    VERIFY(internal::isApprox(m(m.size() - 1), high));
-    VERIFY(size == 1 || internal::isApprox(m(0), low));
     VERIFY_IS_EQUAL(m(m.size() - 1), high);
     if (!NumTraits<Scalar>::IsInteger) CALL_SUBTEST(check_extremity_accuracy(m, low, high));
   }
 
-  VERIFY(numext::real(m(m.size() - 1)) <= numext::real(high));
   VERIFY((m.array().real() <= numext::real(high)).all());
   VERIFY((m.array().real() >= numext::real(low)).all());
-
-  VERIFY(numext::real(m(m.size() - 1)) >= numext::real(low));
   if (size >= 1) {
-    VERIFY(internal::isApprox(m(0), low));
     VERIFY_IS_EQUAL(m(0), low);
   }
 
@@ -155,11 +150,11 @@
     VERIFY(m.size() == n0);
 
     if (VectorType::SizeAtCompileTime == Dynamic) {
-      VERIFY_IS_EQUAL(VectorType::LinSpaced(n0, 0, Scalar(n0 - 1)).sum(), Scalar(0));
+      VERIFY_IS_EQUAL(VectorType::LinSpaced(n0, 0, Scalar(RealScalar(n0 - 1))).sum(), Scalar(0));
       VERIFY_IS_EQUAL(VectorType::LinSpaced(n0, low, low - RealScalar(1)).sum(), Scalar(0));
     }
 
-    m.setLinSpaced(n0, 0, Scalar(n0 - 1));
+    m.setLinSpaced(n0, 0, Scalar(RealScalar(n0 - 1)));
     VERIFY(m.size() == n0);
     m.setLinSpaced(n0, low, low - RealScalar(1));
     VERIFY(m.size() == n0);
@@ -170,18 +165,18 @@
     VERIFY_IS_APPROX(m, VectorType::Constant(size, low));
 
     if (NumTraits<Scalar>::IsInteger) {
-      VERIFY_IS_APPROX(VectorType::LinSpaced(size, low, low + Scalar(size - 1)),
-                       VectorType::LinSpaced(size, low + Scalar(size - 1), low).reverse());
+      VERIFY_IS_APPROX(VectorType::LinSpaced(size, low, low + Scalar(RealScalar(size - 1))),
+                       VectorType::LinSpaced(size, low + Scalar(RealScalar(size - 1)), low).reverse());
 
       if (VectorType::SizeAtCompileTime == Dynamic) {
         // Check negative multiplicator path:
         for (Index k = 1; k < 5; ++k)
-          VERIFY_IS_APPROX(VectorType::LinSpaced(size, low, low + Scalar((size - 1) * k)),
-                           VectorType::LinSpaced(size, low + Scalar((size - 1) * k), low).reverse());
+          VERIFY_IS_APPROX(VectorType::LinSpaced(size, low, low + Scalar(RealScalar((size - 1) * k))),
+                           VectorType::LinSpaced(size, low + Scalar(RealScalar((size - 1) * k)), low).reverse());
         // Check negative divisor path:
         for (Index k = 1; k < 5; ++k)
-          VERIFY_IS_APPROX(VectorType::LinSpaced(size * k, low, low + Scalar(size - 1)),
-                           VectorType::LinSpaced(size * k, low + Scalar(size - 1), low).reverse());
+          VERIFY_IS_APPROX(VectorType::LinSpaced(size * k, low, low + Scalar(RealScalar(size - 1))),
+                           VectorType::LinSpaced(size * k, low + Scalar(RealScalar(size - 1)), low).reverse());
       }
     }
   }
@@ -255,17 +250,17 @@
   VERIFY((internal::has_nullary_operator<internal::scalar_constant_op<double> >::value));
   VERIFY((!internal::has_unary_operator<internal::scalar_constant_op<double> >::value));
   VERIFY((!internal::has_binary_operator<internal::scalar_constant_op<double> >::value));
-  VERIFY((internal::functor_has_linear_access<internal::scalar_constant_op<double> >::ret));
+  VERIFY((internal::functor_has_linear_access<internal::scalar_constant_op<double> >::value));
 
   VERIFY((!internal::has_nullary_operator<internal::scalar_identity_op<double> >::value));
   VERIFY((!internal::has_unary_operator<internal::scalar_identity_op<double> >::value));
   VERIFY((internal::has_binary_operator<internal::scalar_identity_op<double> >::value));
-  VERIFY((!internal::functor_has_linear_access<internal::scalar_identity_op<double> >::ret));
+  VERIFY((!internal::functor_has_linear_access<internal::scalar_identity_op<double> >::value));
 
   VERIFY((!internal::has_nullary_operator<internal::linspaced_op<float> >::value));
   VERIFY((internal::has_unary_operator<internal::linspaced_op<float> >::value));
   VERIFY((!internal::has_binary_operator<internal::linspaced_op<float> >::value));
-  VERIFY((internal::functor_has_linear_access<internal::linspaced_op<float> >::ret));
+  VERIFY((internal::functor_has_linear_access<internal::linspaced_op<float> >::value));
 
   // Regression unit test for an MSVC bug.
   // Search "nullary_wrapper_workaround_msvc" in CoreEvaluators.h for the details.
@@ -284,12 +279,12 @@
     VERIFY((internal::has_nullary_operator<internal::scalar_constant_op<float> >::value));
     VERIFY((!internal::has_unary_operator<internal::scalar_constant_op<float> >::value));
     VERIFY((!internal::has_binary_operator<internal::scalar_constant_op<float> >::value));
-    VERIFY((internal::functor_has_linear_access<internal::scalar_constant_op<float> >::ret));
+    VERIFY((internal::functor_has_linear_access<internal::scalar_constant_op<float> >::value));
 
     VERIFY((!internal::has_nullary_operator<internal::linspaced_op<int> >::value));
     VERIFY((internal::has_unary_operator<internal::linspaced_op<int> >::value));
     VERIFY((!internal::has_binary_operator<internal::linspaced_op<int> >::value));
-    VERIFY((internal::functor_has_linear_access<internal::linspaced_op<int> >::ret));
+    VERIFY((internal::functor_has_linear_access<internal::linspaced_op<int> >::value));
   }
 }
 
diff --git a/test/num_dimensions.cpp b/test/num_dimensions.cpp
index dacd8ac..19a2478 100644
--- a/test/num_dimensions.cpp
+++ b/test/num_dimensions.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/SparseCore>
diff --git a/test/numerical_test_helpers.h b/test/numerical_test_helpers.h
new file mode 100644
index 0000000..137dca8
--- /dev/null
+++ b/test/numerical_test_helpers.h
@@ -0,0 +1,397 @@
+// SPDX-FileCopyrightText: 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// SPDX-FileCopyrightText: 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_NUMERICAL_TEST_HELPERS_H
+#define EIGEN_TEST_NUMERICAL_TEST_HELPERS_H
+
+#include <algorithm>
+#include <complex>
+#include <iostream>
+#include <type_traits>
+
+#include <Eigen/Core>
+
+#define VERIFY_IS_EQUAL(a, b) VERIFY(test_is_equal(a, b, true))
+#define VERIFY_IS_NOT_EQUAL(a, b) VERIFY(test_is_equal(a, b, false))
+#define VERIFY_IS_APPROX(a, b) VERIFY(verifyIsApprox(a, b))
+#define VERIFY_IS_NOT_APPROX(a, b) VERIFY(!test_isApprox(a, b))
+#define VERIFY_IS_MUCH_SMALLER_THAN(a, b) VERIFY(test_isMuchSmallerThan(a, b))
+#define VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b) VERIFY(!test_isMuchSmallerThan(a, b))
+#define VERIFY_IS_APPROX_OR_LESS_THAN(a, b) VERIFY(test_isApproxOrLessThan(a, b))
+#define VERIFY_IS_CWISE_EQUAL(a, b) VERIFY(verifyIsCwiseApprox(a, b, true))
+#define VERIFY_IS_CWISE_APPROX(a, b) VERIFY(verifyIsCwiseApprox(a, b, false))
+#define VERIFY_IS_APPROX_SCALED(a, b, scale) VERIFY(verifyIsApproxScaled(a, b, scale))
+
+#define VERIFY_IS_UNITARY(a) VERIFY(test_isUnitary(a))
+
+namespace Eigen {
+
+#if EIGEN_COMP_ICC
+template <typename T, typename U>
+bool test_is_equal(const T& actual, const U& expected, bool expect_equal = true);
+#endif
+
+template <typename T>
+inline typename NumTraits<T>::Real test_precision() {
+  return NumTraits<T>::dummy_precision();
+}
+template <>
+inline float test_precision<float>() {
+  return 1e-3f;
+}
+template <>
+inline double test_precision<double>() {
+  return 1e-6;
+}
+template <>
+inline long double test_precision<long double>() {
+  return 1e-6l;
+}
+template <>
+inline float test_precision<std::complex<float>>() {
+  return test_precision<float>();
+}
+template <>
+inline double test_precision<std::complex<double>>() {
+  return test_precision<double>();
+}
+template <>
+inline long double test_precision<std::complex<long double>>() {
+  return test_precision<long double>();
+}
+
+#define EIGEN_TEST_SCALAR_TEST_OVERLOAD(TYPE)                                          \
+  inline bool test_isApprox(TYPE a, TYPE b) {                                          \
+    return numext::equal_strict(a, b) || ((numext::isnan)(a) && (numext::isnan)(b)) || \
+           (internal::isApprox(a, b, test_precision<TYPE>()));                         \
+  }                                                                                    \
+  inline bool test_isCwiseApprox(TYPE a, TYPE b, bool exact) {                         \
+    return numext::equal_strict(a, b) || ((numext::isnan)(a) && (numext::isnan)(b)) || \
+           (!exact && internal::isApprox(a, b, test_precision<TYPE>()));               \
+  }                                                                                    \
+  inline bool test_isMuchSmallerThan(TYPE a, TYPE b) {                                 \
+    return internal::isMuchSmallerThan(a, b, test_precision<TYPE>());                  \
+  }                                                                                    \
+  inline bool test_isApproxOrLessThan(TYPE a, TYPE b) {                                \
+    return internal::isApproxOrLessThan(a, b, test_precision<TYPE>());                 \
+  }
+
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(short)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned short)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(int)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned int)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(long)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned long)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(long long)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(unsigned long long)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(float)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(double)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(half)
+EIGEN_TEST_SCALAR_TEST_OVERLOAD(bfloat16)
+
+#undef EIGEN_TEST_SCALAR_TEST_OVERLOAD
+
+#ifndef EIGEN_TEST_NO_COMPLEX
+inline bool test_isApprox(const std::complex<float>& a, const std::complex<float>& b) {
+  return internal::isApprox(a, b, test_precision<std::complex<float>>());
+}
+inline bool test_isMuchSmallerThan(const std::complex<float>& a, const std::complex<float>& b) {
+  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<float>>());
+}
+
+inline bool test_isApprox(const std::complex<double>& a, const std::complex<double>& b) {
+  return internal::isApprox(a, b, test_precision<std::complex<double>>());
+}
+inline bool test_isMuchSmallerThan(const std::complex<double>& a, const std::complex<double>& b) {
+  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<double>>());
+}
+
+#ifndef EIGEN_TEST_NO_LONGDOUBLE
+inline bool test_isApprox(const std::complex<long double>& a, const std::complex<long double>& b) {
+  return internal::isApprox(a, b, test_precision<std::complex<long double>>());
+}
+inline bool test_isMuchSmallerThan(const std::complex<long double>& a, const std::complex<long double>& b) {
+  return internal::isMuchSmallerThan(a, b, test_precision<std::complex<long double>>());
+}
+#endif
+#endif
+
+#ifndef EIGEN_TEST_NO_LONGDOUBLE
+inline bool test_isApprox(const long double& a, const long double& b) {
+  bool ret = internal::isApprox(a, b, test_precision<long double>());
+  if (!ret)
+    std::cerr << std::endl << "    actual   = " << a << std::endl << "    expected = " << b << std::endl << std::endl;
+  return ret;
+}
+
+inline bool test_isMuchSmallerThan(const long double& a, const long double& b) {
+  return internal::isMuchSmallerThan(a, b, test_precision<long double>());
+}
+inline bool test_isApproxOrLessThan(const long double& a, const long double& b) {
+  return internal::isApproxOrLessThan(a, b, test_precision<long double>());
+}
+#endif  // EIGEN_TEST_NO_LONGDOUBLE
+
+// Boolean subtraction is rejected at compile time, so Boolean coefficients are differenced as int.
+template <typename Scalar>
+using test_difference_scalar_t = std::conditional_t<std::is_same<Scalar, bool>::value, int, Scalar>;
+
+// test_relative_error returns the relative difference between a and b as a real scalar as used in isApprox.
+template <typename T1, typename T2>
+typename NumTraits<typename T1::RealScalar>::NonInteger test_relative_error(const EigenBase<T1>& a,
+                                                                            const EigenBase<T2>& b) {
+  using std::sqrt;
+  typedef typename NumTraits<typename T1::RealScalar>::NonInteger RealScalar;
+  using DiffScalar1 = test_difference_scalar_t<typename T1::Scalar>;
+  using DiffScalar2 = test_difference_scalar_t<typename T2::Scalar>;
+  typename internal::nested_eval<T1, 2>::type ea(a.derived());
+  typename internal::nested_eval<T2, 2>::type eb(b.derived());
+  return sqrt(
+      RealScalar(
+          (ea.matrix().template cast<DiffScalar1>() - eb.matrix().template cast<DiffScalar2>()).cwiseAbs2().sum()) /
+      RealScalar((std::min)(eb.cwiseAbs2().sum(), ea.cwiseAbs2().sum())));
+}
+
+template <typename T1, typename T2>
+typename T1::RealScalar test_relative_error(const T1& a, const T2& b, const typename T1::Coefficients* = 0) {
+  return test_relative_error(a.coeffs(), b.coeffs());
+}
+
+template <typename T1, typename T2>
+typename T1::Scalar test_relative_error(const T1& a, const T2& b, const typename T1::MatrixType* = 0) {
+  return test_relative_error(a.matrix(), b.matrix());
+}
+
+template <typename S, int D>
+S test_relative_error(const Translation<S, D>& a, const Translation<S, D>& b) {
+  return test_relative_error(a.vector(), b.vector());
+}
+
+template <typename S, int D, int O>
+S test_relative_error(const ParametrizedLine<S, D, O>& a, const ParametrizedLine<S, D, O>& b) {
+  return (std::max)(test_relative_error(a.origin(), b.origin()), test_relative_error(a.origin(), b.origin()));
+}
+
+template <typename S, int D>
+S test_relative_error(const AlignedBox<S, D>& a, const AlignedBox<S, D>& b) {
+  return (std::max)(test_relative_error((a.min)(), (b.min)()), test_relative_error((a.max)(), (b.max)()));
+}
+
+template <typename Derived>
+class SparseMatrixBase;
+template <typename T1, typename T2>
+typename T1::RealScalar test_relative_error(const MatrixBase<T1>& a, const SparseMatrixBase<T2>& b) {
+  return test_relative_error(a, b.toDense());
+}
+
+template <typename Derived>
+class SparseMatrixBase;
+template <typename T1, typename T2>
+typename T1::RealScalar test_relative_error(const SparseMatrixBase<T1>& a, const MatrixBase<T2>& b) {
+  return test_relative_error(a.toDense(), b);
+}
+
+template <typename Derived>
+class SparseMatrixBase;
+template <typename T1, typename T2>
+typename T1::RealScalar test_relative_error(const SparseMatrixBase<T1>& a, const SparseMatrixBase<T2>& b) {
+  return test_relative_error(a.toDense(), b.toDense());
+}
+
+template <typename T1, typename T2,
+          std::enable_if_t<internal::is_arithmetic<typename NumTraits<T1>::Real>::value, int> = 0>
+typename NumTraits<typename NumTraits<T1>::Real>::NonInteger test_relative_error(const T1& a, const T2& b) {
+  typedef typename NumTraits<typename NumTraits<T1>::Real>::NonInteger RealScalar;
+  return numext::sqrt(RealScalar(numext::abs2(a - b)) /
+                      (numext::mini)(RealScalar(numext::abs2(a)), RealScalar(numext::abs2(b))));
+}
+
+template <typename T>
+T test_relative_error(const Rotation2D<T>& a, const Rotation2D<T>& b) {
+  return test_relative_error(a.angle(), b.angle());
+}
+
+template <typename T>
+T test_relative_error(const AngleAxis<T>& a, const AngleAxis<T>& b) {
+  return (std::max)(test_relative_error(a.angle(), b.angle()), test_relative_error(a.axis(), b.axis()));
+}
+
+template <typename Type1, typename Type2>
+inline bool test_isApprox(const Type1& a, const Type2& b, typename Type1::Scalar* = 0)  // Enabled for Eigen's type only
+{
+  return a.isApprox(b, test_precision<typename Type1::Scalar>());
+}
+
+// get_test_precision is a small wrapper to test_precision allowing to return the scalar precision for either scalars or
+// expressions
+template <typename T>
+typename NumTraits<typename T::Scalar>::Real get_test_precision(const T&, const typename T::Scalar* = 0) {
+  return test_precision<typename NumTraits<typename T::Scalar>::Real>();
+}
+
+template <typename T, std::enable_if_t<internal::is_arithmetic<typename NumTraits<T>::Real>::value, int> = 0>
+typename NumTraits<T>::Real get_test_precision(const T&) {
+  return test_precision<typename NumTraits<T>::Real>();
+}
+
+// verifyIsApprox is a wrapper to test_isApprox that outputs the relative difference magnitude if the test fails.
+template <typename Type1, typename Type2>
+inline bool verifyIsApprox(const Type1& a, const Type2& b) {
+  bool ret = test_isApprox(a, b);
+  if (!ret) {
+    std::cerr << "Difference too large wrt tolerance " << get_test_precision(a)
+              << ", relative error is: " << test_relative_error(a, b) << std::endl;
+  }
+  return ret;
+}
+
+// verifyIsCwiseApprox is a wrapper to test_isCwiseApprox that outputs the relative difference magnitude if the test
+// fails.
+template <typename Type1, typename Type2>
+inline bool verifyIsCwiseApprox(const Type1& a, const Type2& b, bool exact) {
+  bool ret = test_isCwiseApprox(a, b, exact);
+  if (!ret) {
+    if (exact) {
+      std::cerr << "Values are not an exact match";
+    } else {
+      std::cerr << "Difference too large wrt tolerance " << get_test_precision(a);
+    }
+    std::cerr << ", relative error is: " << test_relative_error(a, b) << std::endl;
+  }
+  return ret;
+}
+
+// Largest coefficient magnitude of a matrix or of an array expression.
+template <typename Derived>
+typename NumTraits<typename Derived::Scalar>::Real max_abs_coeff(const MatrixBase<Derived>& m) {
+  return m.cwiseAbs().maxCoeff();
+}
+template <typename Derived>
+typename NumTraits<typename Derived::Scalar>::Real max_abs_coeff(const ArrayBase<Derived>& a) {
+  return a.abs().maxCoeff();
+}
+
+// Matrix and array counterpart of test_isApproxWithRef: compares two expressions that are mathematically equal but
+// whose evaluations differ by rounding proportional to `scale` rather than to the result. verifyIsApprox measures the
+// error relative to the result, which no implementation can meet once the result is formed by cancellation.
+template <typename Type1, typename Type2>
+inline bool verifyIsApproxScaled(const Type1& a, const Type2& b,
+                                 const typename NumTraits<typename Type1::Scalar>::Real& scale) {
+  typedef typename NumTraits<typename Type1::Scalar>::Real RealScalar;
+  const RealScalar error = max_abs_coeff((a - b).eval());
+  const RealScalar tolerance = test_precision<typename Type1::Scalar>() * scale;
+  // An infinite or NaN bound would admit any result, so treat it as a failure of the caller rather
+  // than as a passing comparison.
+  if (!((numext::isfinite)(tolerance))) {
+    std::cerr << "Invalid tolerance " << tolerance << " for scale " << scale << std::endl;
+    return false;
+  }
+  if (!(error <= tolerance)) {
+    std::cerr << "Difference " << error << " too large wrt tolerance " << tolerance << std::endl;
+    return false;
+  }
+  return true;
+}
+
+// The idea behind this function is to compare the two scalars a and b where
+// the scalar ref is a hint about the expected order of magnitude of a and b.
+// WARNING: the scalar a and b must be positive
+// Therefore, if a and b happen to be very small compared to ref,
+// we won't issue a false negative.
+// This test could be: abs(a-b) <= eps * ref
+// However, it seems that simply comparing a+ref and b+ref is more sensitive to true error.
+template <typename Scalar, typename ScalarRef>
+inline bool test_isApproxWithRef(const Scalar& a, const Scalar& b, const ScalarRef& ref) {
+  return test_isApprox(a + ref, b + ref);
+}
+
+template <typename Derived1, typename Derived2>
+inline bool test_isMuchSmallerThan(const MatrixBase<Derived1>& m1, const MatrixBase<Derived2>& m2) {
+  return m1.isMuchSmallerThan(m2, test_precision<typename internal::traits<Derived1>::Scalar>());
+}
+
+template <typename Derived>
+inline bool test_isMuchSmallerThan(const MatrixBase<Derived>& m,
+                                   const typename NumTraits<typename internal::traits<Derived>::Scalar>::Real& s) {
+  return m.isMuchSmallerThan(s, test_precision<typename internal::traits<Derived>::Scalar>());
+}
+
+template <typename Derived>
+inline bool test_isUnitary(const MatrixBase<Derived>& m) {
+  return m.isUnitary(test_precision<typename internal::traits<Derived>::Scalar>());
+}
+
+// Checks component-wise, works with infs and nans.
+template <typename Derived1, typename Derived2>
+bool test_isCwiseApprox(const DenseBase<Derived1>& m1, const DenseBase<Derived2>& m2, bool exact) {
+  if (m1.rows() != m2.rows()) {
+    return false;
+  }
+  if (m1.cols() != m2.cols()) {
+    return false;
+  }
+  for (Index r = 0; r < m1.rows(); ++r) {
+    for (Index c = 0; c < m1.cols(); ++c) {
+      if (m1(r, c) != m2(r, c) && !((numext::isnan)(m1(r, c)) && (numext::isnan)(m2(r, c))) &&
+          (exact || !test_isApprox(m1(r, c), m2(r, c)))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+template <typename Derived1, typename Derived2>
+bool test_isCwiseApprox(const SparseMatrixBase<Derived1>& m1, const SparseMatrixBase<Derived2>& m2, bool exact) {
+  return test_isCwiseApprox(m1.toDense(), m2.toDense(), exact);
+}
+
+template <typename T, typename U>
+bool test_is_equal(const T& actual, const U& expected, bool expect_equal) {
+  if (numext::equal_strict(actual, expected) == expect_equal) return true;
+  // false:
+  std::cerr << "\n    actual   = " << actual << "\n    expected " << (expect_equal ? "= " : "!=") << expected << "\n\n";
+  return false;
+}
+
+/**
+ * Check if number is "not a number" (NaN).
+ *
+ * @tparam T input type
+ * @param x input value
+ * @return true, if input value is "not a number" (NaN)
+ */
+template <typename T>
+bool isNotNaN(const T& x) {
+  return x == x;
+}
+
+/**
+ * Check if number is plus infinity.
+ *
+ * @tparam T input type
+ * @param x input value
+ * @return true, if input value is plus infinity
+ */
+template <typename T>
+bool isPlusInf(const T& x) {
+  return x > NumTraits<T>::highest();
+}
+
+/**
+ * Check if number is minus infinity.
+ *
+ * @tparam T input type
+ * @param x input value
+ * @return true, if input value is minus infinity
+ */
+template <typename T>
+bool isMinusInf(const T& x) {
+  return x < NumTraits<T>::lowest();
+}
+
+}  // end namespace Eigen
+
+#endif  // EIGEN_TEST_NUMERICAL_TEST_HELPERS_H
diff --git a/test/numext.cpp b/test/numext.cpp
index ebe9fb0..053aa95 100644
--- a/test/numext.cpp
+++ b/test/numext.cpp
@@ -6,8 +6,15 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "twoprod_helpers.h"
+#include "fp_control.h"
+
+#if EIGEN_COMP_MSVC
+#include <cfenv>
+#endif
 
 template <typename T, typename U>
 bool check_if_equal_or_nans(const T& actual, const U& expected) {
@@ -34,6 +41,101 @@
 #define VERIFY_IS_EQUAL_OR_NANS(a, b) VERIFY(test_is_equal_or_nans(a, b))
 
 template <typename T>
+struct check_copysign_impl {
+  static void run() {
+    const T pos_zero = T(0);
+    const T pos_one = T(1);
+
+    // Tests valid for all types.
+    VERIFY_IS_EQUAL(numext::copysign(pos_one, pos_one), pos_one);
+    VERIFY_IS_EQUAL(numext::copysign(pos_zero, pos_one), pos_zero);
+
+    // Tests valid for all signed types (integer and floating-point).
+    if (NumTraits<T>::IsSigned) {
+      const T neg_one = numext::negate(pos_one);
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, neg_one), neg_one);
+      VERIFY_IS_EQUAL(numext::copysign(neg_one, pos_one), pos_one);
+      VERIFY_IS_EQUAL(numext::copysign(neg_one, neg_one), neg_one);
+    }
+
+    // Tests specific to floating-point types (negative zero, infinity, NaN).
+    if (!NumTraits<T>::IsInteger) {
+      const T neg_zero = numext::negate(pos_zero);
+      const T neg_one = numext::negate(pos_one);
+      const T pos_inf = std::numeric_limits<T>::infinity();
+      const T neg_inf = numext::negate(pos_inf);
+      const T pos_nan = std::numeric_limits<T>::quiet_NaN();
+      const T neg_nan = numext::negate(pos_nan);
+      // Sign transferred from zero.
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, pos_zero), pos_one);
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, neg_zero), neg_one);
+      // Sign transferred from infinity.
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, pos_inf), pos_one);
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, neg_inf), neg_one);
+      // Sign transferred from NaN.
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, pos_nan), pos_one);
+      VERIFY_IS_EQUAL(numext::copysign(pos_one, neg_nan), neg_one);
+    }
+
+    for (int k = 0; k < 100; ++k) {
+      // For signed integers avoid lowest() so that abs(a) does not overflow.
+      const T a = (NumTraits<T>::IsSigned && NumTraits<T>::IsInteger)
+                      ? internal::random<T>(numext::negate(NumTraits<T>::highest()), NumTraits<T>::highest())
+                      : internal::random<T>();
+      const T b = internal::random<T>();
+      const T result = numext::copysign(a, b);
+      // Magnitude is preserved.
+      VERIFY_IS_EQUAL(numext::abs(result), numext::abs(a));
+      // Sign matches sign source. Integers have no negative zero, so the sign
+      // of the result is only meaningful when a != 0.
+      if (!NumTraits<T>::IsInteger || a != T(0)) {
+        VERIFY_IS_EQUAL(numext::copysign(pos_one, result), numext::copysign(pos_one, b));
+      }
+    }
+  }
+};
+
+template <typename T>
+struct check_copysign_impl<std::complex<T>> {
+  static void run() {
+    typedef std::complex<T> ComplexT;
+    const T pos_one = T(1);
+    const T neg_one = numext::negate(pos_one);
+
+    // Complex copysign is applied component-wise.
+    VERIFY_IS_EQUAL(numext::copysign(ComplexT(pos_one, pos_one), ComplexT(pos_one, neg_one)),
+                    ComplexT(pos_one, neg_one));
+    VERIFY_IS_EQUAL(numext::copysign(ComplexT(neg_one, pos_one), ComplexT(pos_one, neg_one)),
+                    ComplexT(pos_one, neg_one));
+    VERIFY_IS_EQUAL(numext::copysign(ComplexT(pos_one, neg_one), ComplexT(neg_one, pos_one)),
+                    ComplexT(neg_one, pos_one));
+
+    for (int k = 0; k < 100; ++k) {
+      const ComplexT a = internal::random<ComplexT>();
+      const ComplexT b = internal::random<ComplexT>();
+      const ComplexT result = numext::copysign(a, b);
+      // Each component is independently copysigned.
+      VERIFY_IS_EQUAL(numext::real(result), numext::copysign(numext::real(a), numext::real(b)));
+      VERIFY_IS_EQUAL(numext::imag(result), numext::copysign(numext::imag(a), numext::imag(b)));
+    }
+  }
+};
+
+template <typename T>
+void check_copysign() {
+  check_copysign_impl<T>::run();
+}
+
+template <>
+void check_copysign<bool>() {
+  for (bool a : {false, true}) {
+    for (bool b : {false, true}) {
+      VERIFY_IS_EQUAL(numext::copysign(a, b), a);
+    }
+  }
+}
+
+template <typename T>
 void check_negate() {
   Index size = 1000;
   for (Index i = 0; i < size; i++) {
@@ -44,6 +146,67 @@
   }
 }
 
+#if EIGEN_COMP_MSVC
+#pragma float_control(precise, on, push)
+#pragma fenv_access(on)
+#endif
+
+template <typename T>
+void check_complex_exp() {
+  using Complex = std::complex<T>;
+  const T highest = (std::numeric_limits<T>::max)();
+  const T inf = std::numeric_limits<T>::infinity();
+  const T nan = std::numeric_limits<T>::quiet_NaN();
+
+  const Complex finite_inf = numext::exp(Complex(T(1), inf));
+  VERIFY((numext::isnan)(finite_inf.real()));
+  VERIFY((numext::isnan)(finite_inf.imag()));
+
+  const Complex finite_nan = numext::exp(Complex(T(1), nan));
+  VERIFY((numext::isnan)(finite_nan.real()));
+  VERIFY((numext::isnan)(finite_nan.imag()));
+
+#if EIGEN_COMP_MSVC
+  std::feclearexcept(FE_ALL_EXCEPT);
+#endif
+  const Complex highest_inf = numext::exp(Complex(highest, inf));
+  VERIFY((numext::isnan)(highest_inf.real()));
+  VERIFY((numext::isnan)(highest_inf.imag()));
+#if EIGEN_COMP_MSVC
+  VERIFY((std::fetestexcept(FE_INVALID) & FE_INVALID) != 0);
+  std::feclearexcept(FE_ALL_EXCEPT);
+#endif
+
+  const Complex inf_nan = numext::exp(Complex(inf, nan));
+  VERIFY((numext::isinf)(inf_nan.real()));
+  VERIFY((numext::isnan)(inf_nan.imag()));
+}
+
+#if EIGEN_COMP_MSVC
+#pragma fenv_access(off)
+#pragma float_control(pop)
+#endif
+
+template <typename T>
+std::enable_if_t<NumTraits<T>::IsInteger && NumTraits<T>::IsSigned, T> random_abs2_input() {
+  const T safeAbs2Input = static_cast<T>(std::sqrt(static_cast<long double>(NumTraits<T>::highest())));
+  return internal::random<T>(-safeAbs2Input, safeAbs2Input);
+}
+
+// Note: bool resolves here (IsInteger && !IsSigned), but check_abs<bool> is fully
+// specialized and never calls random_abs2_input<bool>().
+template <typename T>
+std::enable_if_t<NumTraits<T>::IsInteger && !NumTraits<T>::IsSigned, T> random_abs2_input() {
+  const T safeAbs2Input = static_cast<T>(std::sqrt(static_cast<long double>(NumTraits<T>::highest())));
+  return internal::random<T>(T(0), safeAbs2Input);
+}
+
+template <typename T>
+std::enable_if_t<!NumTraits<T>::IsInteger, T> random_abs2_input() {
+  typedef typename NumTraits<T>::Real Real;
+  return internal::random<T>() / Real(2);
+}
+
 template <typename T>
 void check_abs() {
   typedef typename NumTraits<T>::Real Real;
@@ -54,8 +217,7 @@
   VERIFY_IS_EQUAL(numext::abs(T(1)), T(1));
 
   for (int k = 0; k < 100; ++k) {
-    T x = internal::random<T>();
-    x = x / Real(2);
+    T x = random_abs2_input<T>();
     if (NumTraits<T>::IsSigned) {
       VERIFY_IS_EQUAL(numext::abs(x), numext::abs(numext::negate(x)));
       VERIFY(numext::abs(numext::negate(x)) >= zero);
@@ -74,12 +236,96 @@
   }
 }
 
+// numext::sign(z) = z / |z| for complex z. The interesting inputs are the ends of the range, where
+// forming 1/|z| first would overflow (subnormal |z|) or itself be subnormal, hence inexact (|z| near max).
+template <typename T>
+void check_complex_sign() {
+  typedef typename NumTraits<T>::Real Real;
+  const Real zero(0), one(1);
+
+  VERIFY_IS_EQUAL(numext::sign(T(zero, zero)), T(zero, zero));
+  VERIFY_IS_EQUAL(numext::sign(T(one, zero)), T(one, zero));
+  VERIFY_IS_EQUAL(numext::sign(T(zero, -one)), T(zero, -one));
+
+  for (Real r : {std::numeric_limits<Real>::denorm_min(), (std::numeric_limits<Real>::min)(),
+                 (std::numeric_limits<Real>::max)()}) {
+    VERIFY_IS_EQUAL(numext::sign(T(r, zero)), T(one, zero));
+    VERIFY_IS_EQUAL(numext::sign(T(-r, zero)), T(-one, zero));
+    VERIFY_IS_EQUAL(numext::sign(T(zero, r)), T(zero, one));
+  }
+
+  // Off the axes the magnitude is only as accurate as abs() itself, which cannot resolve |z| for a z
+  // whose components are at the bottom of the subnormal range; from the smallest normal upwards it can.
+  for (Real r : {(std::numeric_limits<Real>::min)(), one, (std::numeric_limits<Real>::max)() / Real(2)}) {
+    const T s = numext::sign(T(r, r));
+    VERIFY_IS_APPROX(numext::abs(s), one);
+    VERIFY_IS_EQUAL(numext::real(s), numext::imag(s));
+  }
+}
+
+// The FMA implementation must retain the product's rounding error even when scalar madd is unfused.
+template <typename T>
+void check_twoprod_pair(const T& x, const T& y) {
+  T hi, lo;
+  internal::twoprod(x, y, hi, lo);
+  VERIFY_IS_EQUAL(hi, x * y);
+  // fma is exact by IEEE-754 contract, so this is the definition of the low word rather than an
+  // independent approximation of it.
+  EIGEN_USING_STD(fma);
+  VERIFY_IS_EQUAL(lo, fma(x, y, -hi));
+  VERIFY_IS_EQUAL(internal::twoprod_low(x, y, hi), fma(x, y, -hi));
+}
+
+template <typename T>
+void check_twoprod() {
+  // (1 + epsilon) * (1 - epsilon) = 1 - epsilon^2 exposes a lost low word in every IEEE type.
+  const T epsilon = NumTraits<T>::epsilon();
+  check_twoprod_pair(T(1) + epsilon, T(1) - epsilon);
+  for (int k = 0; k < 100; ++k) {
+    check_twoprod_pair(internal::random<T>(T(-1), T(1)), internal::random<T>(T(-1), T(1)));
+  }
+}
+
+#ifdef EIGEN_VECTORIZE_FMA
+// Custom scalars can return a lazy expression from unary minus.
+struct TwoprodScalar {
+  struct Negation {
+    const TwoprodScalar& operand;
+  };
+
+  TwoprodScalar() = default;
+  explicit TwoprodScalar(double v) : value(v) {}
+  TwoprodScalar(const Negation& negation) : value(-negation.operand.value) {}
+
+  Negation operator-() const { return {*this}; }
+  TwoprodScalar operator*(const TwoprodScalar& other) const { return TwoprodScalar(value * other.value); }
+
+  friend TwoprodScalar fma(const TwoprodScalar& x, const TwoprodScalar& y, const TwoprodScalar& z) {
+    return TwoprodScalar(std::fma(x.value, y.value, z.value));
+  }
+
+  double value = 0;
+};
+
+void check_twoprod_negation_expression() {
+  STATIC_CHECK(internal::is_scalar<TwoprodScalar>::value);
+  STATIC_CHECK(internal::has_fma<TwoprodScalar>::value);
+  STATIC_CHECK((!std::is_same<decltype(-std::declval<TwoprodScalar>()), TwoprodScalar>::value));
+  const double epsilon = NumTraits<double>::epsilon();
+  for (double sign : {-1.0, 1.0}) {
+    const TwoprodScalar x(sign * (1 + epsilon)), y(1 - epsilon);
+    TwoprodScalar hi, lo;
+    internal::twoprod(x, y, hi, lo);
+    VERIFY_IS_EQUAL(hi.value, sign);
+    VERIFY_IS_EQUAL(lo.value, -sign * epsilon * epsilon);
+    VERIFY_IS_EQUAL(internal::twoprod_low(x, y, hi).value, -sign * epsilon * epsilon);
+  }
+}
+#endif
+
 template <typename T>
 void check_arg() {
   typedef typename NumTraits<T>::Real Real;
-  VERIFY_IS_EQUAL(numext::abs(T(0)), T(0));
-  VERIFY_IS_EQUAL(numext::abs(T(1)), T(1));
-
   for (int k = 0; k < 100; ++k) {
     T x = internal::random<T>();
     Real y = numext::arg(x);
@@ -109,9 +355,9 @@
 };
 
 template <typename T>
-struct check_sqrt_impl<std::complex<T> > {
+struct check_sqrt_impl<std::complex<T>> {
   static void run() {
-    typedef typename std::complex<T> ComplexT;
+    typedef std::complex<T> ComplexT;
 
     for (int i = 0; i < 1000; ++i) {
       const ComplexT x = internal::random<ComplexT>();
@@ -177,9 +423,9 @@
 };
 
 template <typename T>
-struct check_rsqrt_impl<std::complex<T> > {
+struct check_rsqrt_impl<std::complex<T>> {
   static void run() {
-    typedef typename std::complex<T> ComplexT;
+    typedef std::complex<T> ComplexT;
     const T zero = T(0);
     const T one = T(1);
     const T inf = std::numeric_limits<T>::infinity();
@@ -293,6 +539,156 @@
 }
 
 template <typename T>
+void check_nextafter() {
+  const T zero(0);
+  const T one(1);
+  const T two(2);
+  // NumTraits::epsilon() is the ulp at 1. std::numeric_limits reports the far smaller representational gap for the
+  // non-IEEE IBM double-double `long double`, which is not the step nextafter takes.
+  const T eps = NumTraits<T>::epsilon();
+  const T denorm_min = std::numeric_limits<T>::denorm_min();
+  const T inf = std::numeric_limits<T>::infinity();
+  const T nan = std::numeric_limits<T>::quiet_NaN();
+  const T max = (std::numeric_limits<T>::max)();
+
+  // from == to returns to.
+  VERIFY(numext::equal_strict(numext::nextafter(one, one), one));
+  // Stepping up from 1 and back down returns 1.
+  VERIFY(numext::equal_strict(numext::nextafter(numext::nextafter(one, two), zero), one));
+  // One-ulp steps around 1.
+  VERIFY(numext::equal_strict(numext::nextafter(one, two), one + eps));
+  VERIFY(numext::equal_strict(numext::nextafter(one + eps, zero), one));
+  // The neighbors of ±0 are the smallest subnormals, with the sign of the direction.
+  VERIFY(numext::equal_strict(numext::nextafter(zero, one), denorm_min));
+  VERIFY(numext::equal_strict(numext::nextafter(zero, -one), -denorm_min));
+  VERIFY(numext::equal_strict(numext::nextafter(-zero, one), denorm_min));
+  VERIFY(numext::equal_strict(numext::copysign(one, numext::nextafter(zero, -one)), -one));
+  // Stepping the smallest subnormals toward the other sign lands on the zero
+  // of the starting sign (IEEE-754 nextUp/nextDown).
+  VERIFY(numext::equal_strict(numext::nextafter(denorm_min, -one), zero));
+  VERIFY(numext::equal_strict(numext::copysign(one, numext::nextafter(denorm_min, -one)), one));
+  VERIFY(numext::equal_strict(numext::copysign(one, numext::nextafter(-denorm_min, one)), -one));
+  // Infinities saturate and unsaturate by one step.
+  VERIFY(numext::equal_strict(numext::nextafter(max, inf), inf));
+  VERIFY(numext::equal_strict(numext::nextafter(inf, zero), max));
+  // NaNs propagate.
+  VERIFY((numext::isnan)(numext::nextafter(nan, one)));
+  VERIFY((numext::isnan)(numext::nextafter(one, nan)));
+}
+
+template <typename T>
+void check_strict_equal() {
+  const T zero(0);
+  const T one(1);
+  const T two(2);
+  const T half = one / two;
+
+  VERIFY(numext::equal_strict(zero, zero));
+  VERIFY(numext::equal_strict(one, one));
+  VERIFY(numext::equal_strict(half, half));
+  VERIFY(!numext::equal_strict(zero, one));
+  VERIFY(!numext::equal_strict(one, two));
+
+  VERIFY(numext::not_equal_strict(zero, one));
+  VERIFY(numext::not_equal_strict(one, two));
+  VERIFY(!numext::not_equal_strict(one, one));
+
+  VERIFY(numext::is_exactly_zero(zero));
+  VERIFY(!numext::is_exactly_zero(one));
+  VERIFY(numext::is_exactly_zero_no_flush(zero));
+  VERIFY(!numext::is_exactly_zero_no_flush(one));
+  VERIFY(numext::is_exactly_one(one));
+  VERIFY(!numext::is_exactly_one(zero));
+}
+
+void check_zero_no_flush_custom_scalar() {
+  struct EqualityOnly {
+    explicit EqualityOnly(int x) : value(x) {}
+    ~EqualityOnly() {}  // Non-trivially-copyable: encoding-based classification must not be instantiated.
+    bool operator==(const EqualityOnly& other) const { return value == other.value; }
+    int value;
+  };
+  VERIFY(numext::is_exactly_zero_no_flush(EqualityOnly(0)));
+  VERIFY(!numext::is_exactly_zero_no_flush(EqualityOnly(1)));
+}
+
+template <typename Scalar>
+EIGEN_DONT_INLINE bool zero_no_flush_predicate(Scalar value) {
+  return numext::is_exactly_zero_no_flush(value);
+}
+
+template <typename Scalar>
+EIGEN_DONT_INLINE void check_zero_no_flush_values(const Scalar* values, int count) {
+  for (int i = 0; i < count; ++i) {
+    VERIFY_IS_EQUAL(numext::is_exactly_zero_no_flush(values[i]), i < 2);
+    VERIFY_IS_EQUAL(zero_no_flush_predicate(values[i]), i < 2);
+  }
+}
+
+template <typename Scalar>
+void check_zero_no_flush() {
+  using Binary = internal::binary_floating_point_traits<Scalar>;
+  const Scalar largest_subnormal = numext::bit_cast<Scalar>(Binary::kFractionMask);
+  const Scalar tiny = std::numeric_limits<Scalar>::denorm_min();
+  const Scalar minimum = (std::numeric_limits<Scalar>::min)();
+  const Scalar infinity = std::numeric_limits<Scalar>::infinity();
+  const Scalar values[] = {Scalar(0),
+                           -Scalar(0),
+                           tiny,
+                           -tiny,
+                           largest_subnormal,
+                           numext::bit_cast<Scalar>(Binary::kSignBit | Binary::kFractionMask),
+                           minimum,
+                           -minimum,
+                           Scalar(1),
+                           -Scalar(1),
+                           infinity,
+                           -infinity,
+                           std::numeric_limits<Scalar>::quiet_NaN()};
+  const int count = sizeof(values) / sizeof(values[0]);
+  for (int mode = 0; mode < 4; ++mode) {
+#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY) && EIGEN_ARCH_i386_OR_x86_64 && \
+    defined(_MM_SET_DENORMALS_ZERO_MODE)
+    ScopedFlushToZero restore;
+    const unsigned mask = _MM_FLUSH_ZERO_MASK | _MM_DENORMALS_ZERO_MASK;
+    const unsigned requested = ((mode & 1) ? _MM_FLUSH_ZERO_ON : 0) | ((mode & 2) ? _MM_DENORMALS_ZERO_ON : 0);
+    _mm_setcsr((_mm_getcsr() & ~mask) | requested);
+    VERIFY(restore.isSupported());
+    VERIFY_IS_EQUAL(_mm_getcsr() & mask, requested);
+    check_zero_no_flush_values(values, count);
+    VERIFY_IS_EQUAL(_mm_getcsr() & mask, requested);
+#else
+    if (mode > 1) continue;
+    if (mode == 1) {
+      ScopedFlushToZero flush;
+      if (flush.isSupported()) check_zero_no_flush_values(values, count);
+    } else {
+      check_zero_no_flush_values(values, count);
+    }
+#endif
+  }
+}
+
+template <typename T>
+void check_ceil_power_of_two() {
+  const T zero(0);
+  const T one(1);
+  const T two(2);
+  const T min = (std::numeric_limits<T>::min)();
+  const T denormMin = std::numeric_limits<T>::denorm_min();
+  const T inf = std::numeric_limits<T>::infinity();
+
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(zero), zero);
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(denormMin), min);
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(min), min);
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(T(0.75)), one);
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(one), one);
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(one + NumTraits<T>::epsilon()), two);
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two(T(3)), T(4));
+  VERIFY_IS_EQUAL(numext::ceil_power_of_two((std::numeric_limits<T>::max)()), inf);
+}
+
+template <typename T>
 void check_shift() {
   using SignedT = typename numext::get_integer_by_size<sizeof(T)>::signed_type;
   using UnsignedT = typename numext::get_integer_by_size<sizeof(T)>::unsigned_type;
@@ -301,13 +697,16 @@
     const T a = internal::random<T>();
     for (int s = 1; s < kNumBits; s++) {
       T a_bsll = numext::logical_shift_left(a, s);
-      T a_bsll_ref = a << s;
+      T a_bsll_ref = numext::bit_cast<T, UnsignedT>(numext::bit_cast<UnsignedT, T>(a) << s);
       VERIFY_IS_EQUAL(a_bsll, a_bsll_ref);
       T a_bsrl = numext::logical_shift_right(a, s);
       T a_bsrl_ref = numext::bit_cast<T, UnsignedT>(numext::bit_cast<UnsignedT, T>(a) >> s);
       VERIFY_IS_EQUAL(a_bsrl, a_bsrl_ref);
       T a_bsra = numext::arithmetic_shift_right(a, s);
-      T a_bsra_ref = numext::bit_cast<T, SignedT>(numext::bit_cast<SignedT, T>(a) >> s);
+      // An unsigned T has no sign bit to propagate, so the arithmetic shift must agree with the
+      // logical one; this is what every backend's parithmetic_shift_right on unsigned packets does.
+      T a_bsra_ref =
+          NumTraits<T>::IsSigned ? numext::bit_cast<T, SignedT>(numext::bit_cast<SignedT, T>(a) >> s) : a_bsrl_ref;
       VERIFY_IS_EQUAL(a_bsra, a_bsra_ref);
     }
   }
@@ -315,6 +714,24 @@
 
 EIGEN_DECLARE_TEST(numext) {
   for (int k = 0; k < g_repeat; ++k) {
+    CALL_SUBTEST(check_copysign<half>());
+    CALL_SUBTEST(check_copysign<bfloat16>());
+    CALL_SUBTEST(check_copysign<float>());
+    CALL_SUBTEST(check_copysign<double>());
+    CALL_SUBTEST(check_copysign<long double>());
+    CALL_SUBTEST(check_copysign<std::complex<float>>());
+    CALL_SUBTEST(check_copysign<std::complex<double>>());
+
+    CALL_SUBTEST(check_copysign<bool>());
+    CALL_SUBTEST(check_copysign<int8_t>());
+    CALL_SUBTEST(check_copysign<int16_t>());
+    CALL_SUBTEST(check_copysign<int32_t>());
+    CALL_SUBTEST(check_copysign<int64_t>());
+    CALL_SUBTEST(check_copysign<uint8_t>());
+    CALL_SUBTEST(check_copysign<uint16_t>());
+    CALL_SUBTEST(check_copysign<uint32_t>());
+    CALL_SUBTEST(check_copysign<uint64_t>());
+
     CALL_SUBTEST(check_negate<signed char>());
     CALL_SUBTEST(check_negate<unsigned char>());
     CALL_SUBTEST(check_negate<short>());
@@ -328,8 +745,11 @@
     CALL_SUBTEST(check_negate<float>());
     CALL_SUBTEST(check_negate<double>());
     CALL_SUBTEST(check_negate<long double>());
-    CALL_SUBTEST(check_negate<std::complex<float> >());
-    CALL_SUBTEST(check_negate<std::complex<double> >());
+    CALL_SUBTEST(check_negate<std::complex<float>>());
+    CALL_SUBTEST(check_negate<std::complex<double>>());
+
+    CALL_SUBTEST(check_complex_exp<float>());
+    CALL_SUBTEST(check_complex_exp<double>());
 
     CALL_SUBTEST(check_abs<bool>());
     CALL_SUBTEST(check_abs<signed char>());
@@ -345,21 +765,35 @@
     CALL_SUBTEST(check_abs<float>());
     CALL_SUBTEST(check_abs<double>());
     CALL_SUBTEST(check_abs<long double>());
-    CALL_SUBTEST(check_abs<std::complex<float> >());
-    CALL_SUBTEST(check_abs<std::complex<double> >());
+    CALL_SUBTEST(check_abs<std::complex<float>>());
+    CALL_SUBTEST(check_abs<std::complex<double>>());
 
-    CALL_SUBTEST(check_arg<std::complex<float> >());
-    CALL_SUBTEST(check_arg<std::complex<double> >());
+    CALL_SUBTEST(check_complex_sign<std::complex<float>>());
+    CALL_SUBTEST(check_complex_sign<std::complex<double>>());
+
+    CALL_SUBTEST(check_twoprod<float>());
+    CALL_SUBTEST(check_twoprod<double>());
+    CALL_SUBTEST(check_twoprod<long double>());
+    CALL_SUBTEST(check_twoprod<half>());
+    CALL_SUBTEST(check_twoprod<bfloat16>());
+    CALL_SUBTEST(check_twoprod_contraction<float>());
+    CALL_SUBTEST(check_twoprod_contraction<double>());
+#ifdef EIGEN_VECTORIZE_FMA
+    CALL_SUBTEST(check_twoprod_negation_expression());
+#endif
+
+    CALL_SUBTEST(check_arg<std::complex<float>>());
+    CALL_SUBTEST(check_arg<std::complex<double>>());
 
     CALL_SUBTEST(check_sqrt<float>());
     CALL_SUBTEST(check_sqrt<double>());
-    CALL_SUBTEST(check_sqrt<std::complex<float> >());
-    CALL_SUBTEST(check_sqrt<std::complex<double> >());
+    CALL_SUBTEST(check_sqrt<std::complex<float>>());
+    CALL_SUBTEST(check_sqrt<std::complex<double>>());
 
     CALL_SUBTEST(check_rsqrt<float>());
     CALL_SUBTEST(check_rsqrt<double>());
-    CALL_SUBTEST(check_rsqrt<std::complex<float> >());
-    CALL_SUBTEST(check_rsqrt<std::complex<double> >());
+    CALL_SUBTEST(check_rsqrt<std::complex<float>>());
+    CALL_SUBTEST(check_rsqrt<std::complex<double>>());
 
     CALL_SUBTEST(check_signbit<half>());
     CALL_SUBTEST(check_signbit<bfloat16>());
@@ -376,6 +810,29 @@
     CALL_SUBTEST(check_signbit<int32_t>());
     CALL_SUBTEST(check_signbit<int64_t>());
 
+    CALL_SUBTEST(check_nextafter<half>());
+    CALL_SUBTEST(check_nextafter<bfloat16>());
+    CALL_SUBTEST(check_nextafter<float>());
+    CALL_SUBTEST(check_nextafter<double>());
+    CALL_SUBTEST(check_nextafter<long double>());
+
+    CALL_SUBTEST(check_ceil_power_of_two<half>());
+    CALL_SUBTEST(check_ceil_power_of_two<bfloat16>());
+    CALL_SUBTEST(check_ceil_power_of_two<float>());
+    CALL_SUBTEST(check_ceil_power_of_two<double>());
+    CALL_SUBTEST(check_ceil_power_of_two<long double>());
+
+    CALL_SUBTEST(check_strict_equal<half>());
+    CALL_SUBTEST(check_strict_equal<bfloat16>());
+    CALL_SUBTEST(check_strict_equal<float>());
+    CALL_SUBTEST(check_strict_equal<double>());
+    CALL_SUBTEST(check_strict_equal<long double>());
+    CALL_SUBTEST(check_strict_equal<int>());
+    CALL_SUBTEST(check_strict_equal<std::complex<double>>());
+    CALL_SUBTEST(check_zero_no_flush<float>());
+    CALL_SUBTEST(check_zero_no_flush<double>());
+    CALL_SUBTEST(check_zero_no_flush_custom_scalar());
+
     CALL_SUBTEST(check_shift<int8_t>());
     CALL_SUBTEST(check_shift<int16_t>());
     CALL_SUBTEST(check_shift<int32_t>());
diff --git a/test/numext_fma_contraction.cpp b/test/numext_fma_contraction.cpp
new file mode 100644
index 0000000..339949b
--- /dev/null
+++ b/test/numext_fma_contraction.cpp
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "twoprod_helpers.h"
+
+#if defined(EIGEN_VECTORIZE_FMA) || !defined(FP_FAST_FMA) || !defined(FP_FAST_FMAF)
+#error This test requires fast scalar FMA without EIGEN_VECTORIZE_FMA.
+#endif
+
+EIGEN_DECLARE_TEST(numext_fma_contraction) {
+  CALL_SUBTEST(check_twoprod_contraction<float>());
+  CALL_SUBTEST(check_twoprod_contraction<double>());
+}
diff --git a/test/numext_fma_off.cpp b/test/numext_fma_off.cpp
new file mode 100644
index 0000000..0619b94
--- /dev/null
+++ b/test/numext_fma_off.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#undef EIGEN_SCALAR_MADD_USE_FMA
+#define EIGEN_SCALAR_MADD_USE_FMA 0
+#include "numext.cpp"  // NOLINT(bugprone-suspicious-include): Compile the suite with a different configuration.
diff --git a/test/packet_segment.cpp b/test/packet_segment.cpp
index 8a5469c..a18ce37 100644
--- a/test/packet_segment.cpp
+++ b/test/packet_segment.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/packetmath.cpp b/test/packetmath.cpp
index b4300b3..5e72aaa 100644
--- a/test/packetmath.cpp
+++ b/test/packetmath.cpp
@@ -7,22 +7,15 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
+#include <utility>
 #include "packetmath_test_shared.h"
 #include "random_without_cast_overflow.h"
+#include "fp_control.h"
+#include "packetmath_data_movement.h"
 
-template <typename T>
-inline T REF_ADD(const T& a, const T& b) {
-  return a + b;
-}
-template <typename T>
-inline T REF_SUB(const T& a, const T& b) {
-  return a - b;
-}
-template <typename T>
-inline T REF_MUL(const T& a, const T& b) {
-  return a * b;
-}
+using internal::unpacket_traits;
 
 template <typename Scalar, typename EnableIf = void>
 struct madd_impl {
@@ -41,8 +34,33 @@
 };
 
 template <typename Scalar>
-struct madd_impl<Scalar,
-                 std::enable_if_t<Eigen::internal::is_scalar<Scalar>::value && Eigen::NumTraits<Scalar>::IsSigned>> {
+struct madd_impl<Scalar, std::enable_if_t<NumTraits<Scalar>::IsInteger && !std::is_same<Scalar, bool>::value>> {
+  // Unsigned type at least as wide as int, so sub-int operands are not promoted
+  // back to signed int (whose products/sums can overflow); results wrap modulo
+  // 2^bits like the packet madd/msub ops.
+  using UnsignedScalar = std::common_type_t<std::make_unsigned_t<Scalar>, unsigned>;
+
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar madd(const Scalar& a, const Scalar& b, const Scalar& c) {
+    return static_cast<Scalar>(static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b) +
+                               static_cast<UnsignedScalar>(c));
+  }
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar msub(const Scalar& a, const Scalar& b, const Scalar& c) {
+    return static_cast<Scalar>(static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b) -
+                               static_cast<UnsignedScalar>(c));
+  }
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar nmadd(const Scalar& a, const Scalar& b, const Scalar& c) {
+    return static_cast<Scalar>(static_cast<UnsignedScalar>(c) -
+                               static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b));
+  }
+  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar nmsub(const Scalar& a, const Scalar& b, const Scalar& c) {
+    return static_cast<Scalar>(UnsignedScalar(0) - (static_cast<UnsignedScalar>(a) * static_cast<UnsignedScalar>(b) +
+                                                    static_cast<UnsignedScalar>(c)));
+  }
+};
+
+template <typename Scalar>
+struct madd_impl<Scalar, std::enable_if_t<Eigen::internal::is_scalar<Scalar>::value &&
+                                          Eigen::NumTraits<Scalar>::IsSigned && !NumTraits<Scalar>::IsInteger>> {
   static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar madd(const Scalar& a, const Scalar& b, const Scalar& c) {
     return numext::madd(a, b, c);
   }
@@ -74,10 +92,6 @@
   return madd_impl<T>::nmsub(a, b, c);
 }
 template <typename T>
-inline T REF_DIV(const T& a, const T& b) {
-  return a / b;
-}
-template <typename T>
 inline T REF_RECIPROCAL(const T& a) {
   return T(1) / a;
 }
@@ -86,6 +100,23 @@
   return a > b ? a - b : b - a;
 }
 
+template <typename Packet>
+struct predux_reference_scalar {
+  using Scalar = typename internal::unpacket_traits<Packet>::type;
+  static constexpr bool WidensToFloat = std::is_same<Scalar, bfloat16>::value
+#if defined(EIGEN_VECTORIZE_AVX) && !defined(EIGEN_VECTORIZE_AVX512FP16)
+                                        || std::is_same<Packet, internal::Packet8h>::value
+#endif
+#if defined(EIGEN_VECTORIZE_AVX512) && !defined(EIGEN_VECTORIZE_AVX512FP16)
+                                        || std::is_same<Packet, internal::Packet16h>::value
+#endif
+      ;
+  using type = std::conditional_t<WidensToFloat, float, Scalar>;
+};
+
+template <typename Packet>
+using predux_reference_scalar_t = typename predux_reference_scalar<Packet>::type;
+
 // MacOS apple-clang has an issue with pcmp_eq for half when inlined,
 // resulting in an ICE, but only in this specific test.
 template <typename Packet>
@@ -95,26 +126,10 @@
 
 // Specializations for bool.
 template <>
-inline bool REF_ADD(const bool& a, const bool& b) {
-  return a || b;
-}
-template <>
-inline bool REF_SUB(const bool& a, const bool& b) {
-  return a ^ b;
-}
-template <>
-inline bool REF_MUL(const bool& a, const bool& b) {
-  return a && b;
-}
-template <>
 inline bool REF_MADD(const bool& a, const bool& b, const bool& c) {
   return (a && b) || c;
 }
 template <>
-inline bool REF_DIV(const bool& a, const bool& b) {
-  return a && b;
-}
-template <>
 inline bool REF_RECIPROCAL(const bool& a) {
   return a;
 }
@@ -261,7 +276,7 @@
     }
 
     for (int i = 0; i < DataSize; ++i) {
-      ref[i] = static_cast<const TgtScalar>(data1[i]);
+      ref[i] = static_cast<TgtScalar>(data1[i]);
     }
 
     pcast_array<SrcPacket, TgtPacket, SrcCoeffRatio, TgtCoeffRatio>::cast(data1, DataSize, data2);
@@ -296,7 +311,7 @@
 template <typename SrcPacket, typename TgtScalar,
           typename TgtPacket = typename internal::packet_traits<TgtScalar>::type,
           bool Vectorized = internal::packet_traits<TgtScalar>::Vectorizable,
-          bool HasHalf = !internal::is_same<typename internal::unpacket_traits<TgtPacket>::half, TgtPacket>::value>
+          bool HasHalf = !std::is_same<typename internal::unpacket_traits<TgtPacket>::half, TgtPacket>::value>
 struct test_cast_runner;
 
 template <typename SrcPacket, typename TgtScalar, typename TgtPacket>
@@ -354,9 +369,9 @@
   using RealScalar = typename NumTraits<Scalar>::Real;
   const int PacketSize = internal::unpacket_traits<Packet>::size;
   const int size = 2 * PacketSize;
-  EIGEN_ALIGN_MAX Scalar data1[size];
-  EIGEN_ALIGN_MAX Scalar data2[size];
-  EIGEN_ALIGN_MAX Scalar ref[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[size];
 
   for (int i = 0; i < size; ++i) {
     data1[i] = internal::random<Scalar>();
@@ -389,8 +404,8 @@
 void packetmath_boolean_mask_ops_real() {
   const int PacketSize = internal::unpacket_traits<Packet>::size;
   const int size = 2 * PacketSize;
-  EIGEN_ALIGN_MAX Scalar data1[size];
-  EIGEN_ALIGN_MAX Scalar data2[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
 
   for (int i = 0; i < PacketSize; ++i) {
     data1[i] = internal::random<Scalar>();
@@ -421,13 +436,12 @@
 
 template <typename Scalar, typename Packet>
 struct packetmath_boolean_mask_ops_notcomplex_test<
-    Scalar, Packet,
-    std::enable_if_t<internal::packet_traits<Scalar>::HasCmp && !internal::is_same<Scalar, bool>::value>> {
+    Scalar, Packet, std::enable_if_t<internal::packet_traits<Scalar>::HasCmp && !std::is_same<Scalar, bool>::value>> {
   static void run() {
     const int PacketSize = internal::unpacket_traits<Packet>::size;
     const int size = 2 * PacketSize;
-    EIGEN_ALIGN_MAX Scalar data1[size];
-    EIGEN_ALIGN_MAX Scalar data2[size];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
 
     for (int i = 0; i < PacketSize; ++i) {
       data1[i] = internal::random<Scalar>();
@@ -456,6 +470,65 @@
 };
 
 template <typename Scalar, typename Packet, typename EnableIf = void>
+struct packetmath_split_half_compare_test {
+  static void run() {}
+};
+
+// An emulated wide compare that combines per-half compares lexicographically is correct only if the
+// low half is ordered as unsigned. Operands sharing a high half are what reach that path, and
+// packetmath_boolean_mask_ops_notcomplex_test builds none: it pairs each value with itself or zero.
+template <typename Scalar, typename Packet>
+struct packetmath_split_half_compare_test<
+    Scalar, Packet,
+    std::enable_if_t<std::is_integral<Scalar>::value && internal::packet_traits<Scalar>::HasCmp &&
+                     !std::is_same<Scalar, bool>::value>> {
+  // Class scope keeps these usable as array bounds inside a lambda, which MSVC otherwise treats as
+  // captured and therefore non-constant.
+  static constexpr int PacketSize = internal::unpacket_traits<Packet>::size;
+  static constexpr int size = 2 * PacketSize;
+
+  static void run() {
+    using Unsigned = std::make_unsigned_t<Scalar>;
+    constexpr int kHalfBits = 4 * int(sizeof(Scalar));
+    constexpr Unsigned kHalfSignBit = Unsigned(Unsigned(1) << (kHalfBits - 1));
+    constexpr Unsigned kLowMask = Unsigned(Unsigned(kHalfSignBit << 1) - Unsigned(1));
+
+    const Unsigned low_parts[] = {Unsigned(0), Unsigned(1), Unsigned(kHalfSignBit - Unsigned(1)), kHalfSignBit,
+                                  kLowMask};
+    constexpr int kNumLow = int(sizeof(low_parts) / sizeof(low_parts[0]));
+    // The second high half sets the lane's own sign bit, exercising the high compare for signed and
+    // unsigned Scalar alike.
+    const Unsigned high_parts[] = {Unsigned(0), kLowMask};
+    constexpr int kNumHigh = int(sizeof(high_parts) / sizeof(high_parts[0]));
+
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[size];
+
+    const auto compose = [&](int high_index, int low_index) {
+      return Scalar(Unsigned(Unsigned(high_parts[high_index] << kHalfBits) | low_parts[low_index]));
+    };
+
+    for (int high_index = 0; high_index < kNumHigh; ++high_index) {
+      for (int lhs_low_index = 0; lhs_low_index < kNumLow; ++lhs_low_index) {
+        for (int rhs_low_index = 0; rhs_low_index < kNumLow; ++rhs_low_index) {
+          for (int lane = 0; lane < PacketSize; ++lane) {
+            data1[lane] = compose(high_index, lhs_low_index);
+            data1[lane + PacketSize] = compose(high_index, rhs_low_index);
+          }
+          CHECK_CWISE2_MASK(internal::pcmp_le, internal::pcmp_le);
+          CHECK_CWISE2_MASK(internal::pcmp_lt, internal::pcmp_lt);
+          CHECK_CWISE2_MASK(REF_PCMP_EQ, internal::pcmp_eq);
+          CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasMin, (std::min), internal::pmin);
+          CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasMax, (std::max), internal::pmax);
+          CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasAbsDiff, REF_ABS_DIFF, internal::pabsdiff);
+        }
+      }
+    }
+  }
+};
+
+template <typename Scalar, typename Packet, typename EnableIf = void>
 struct packetmath_minus_zero_add_test {
   static void run() {}
 };
@@ -465,15 +538,151 @@
   static void run() {
     const int PacketSize = internal::unpacket_traits<Packet>::size;
     const int size = 2 * PacketSize;
-    EIGEN_ALIGN_MAX Scalar data1[size] = {};
-    EIGEN_ALIGN_MAX Scalar data2[size] = {};
-    EIGEN_ALIGN_MAX Scalar ref[size] = {};
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size] = {};
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size] = {};
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[size] = {};
 
     for (int i = 0; i < PacketSize; ++i) {
       data1[i] = Scalar(-0.0);
       data1[i + PacketSize] = Scalar(-0.0);
     }
-    CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasAdd, REF_ADD, internal::padd);
+    CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasAdd, test::REF_ADD, internal::padd);
+  }
+};
+
+template <typename Scalar, typename Packet, typename EnableIf = void>
+struct packetmath_integer_predicates_test {
+  static void run() {}
+};
+
+// Integer scalars have no NaN or infinity: pisnan/pisinf must be all-false and pisfinite
+// all-true for every input, including |a| == 2^(digits-1), whose bit pattern matches the
+// constant synthesized by pinf<Packet>().
+template <typename Scalar, typename Packet>
+struct packetmath_integer_predicates_test<
+    Scalar, Packet, std::enable_if_t<NumTraits<Scalar>::IsInteger && !std::is_same<Scalar, bool>::value>> {
+  static void run() {
+    const int PacketSize = internal::unpacket_traits<Packet>::size;
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar res[PacketSize];
+    // "True" is Scalar(1) in the scalar mask convention and all-ones bits in the packet one;
+    // ptrue of the tested Packet type yields the right one either way (the runner also
+    // instantiates Packet = Scalar).
+    const Scalar scalar_true = internal::ptrue(Scalar(0));
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar lane_true[PacketSize];
+    internal::pstore(lane_true, internal::ptrue(internal::pset1<Packet>(Scalar(0))));
+    const Scalar values[] = {Scalar(0),
+                             Scalar(1),
+                             static_cast<Scalar>(-1),
+                             Scalar(Scalar(1) << (std::numeric_limits<Scalar>::digits - 1)),
+                             NumTraits<Scalar>::highest(),
+                             NumTraits<Scalar>::lowest()};
+    const int num_values = sizeof(values) / sizeof(values[0]);
+    for (int i = 0; i < num_values; ++i) {
+      VERIFY(numext::is_exactly_zero(internal::pisnan(values[i])) && "scalar integer pisnan");
+      VERIFY(numext::is_exactly_zero(internal::pisinf(values[i])) && "scalar integer pisinf");
+      VERIFY(internal::pisfinite(values[i]) == scalar_true && "scalar integer pisfinite");
+    }
+    for (int i = 0; i < PacketSize; ++i) data[i] = values[i % num_values];
+    internal::pstore(res, internal::pisnan(internal::pload<Packet>(data)));
+    for (int i = 0; i < PacketSize; ++i) VERIFY(numext::is_exactly_zero(res[i]) && "integer pisnan");
+    internal::pstore(res, internal::pisinf(internal::pload<Packet>(data)));
+    for (int i = 0; i < PacketSize; ++i) VERIFY(numext::is_exactly_zero(res[i]) && "integer pisinf");
+    internal::pstore(res, internal::pisfinite(internal::pload<Packet>(data)));
+    for (int i = 0; i < PacketSize; ++i) VERIFY(res[i] == lane_true[i] && "integer pisfinite");
+  }
+};
+
+template <typename Scalar, typename Packet, typename = void>
+struct packetmath_64bit_boundary_test {
+  static void run() {}
+};
+
+// Focused coverage for 64-bit lanes: non-ARM64 `pcmp_eq<Packet2{,u}l>` splits each lane into 32-bit
+// halves and `AND`s the two half-comparisons together. The generic `packetmath_boolean_mask_ops`
+// only feeds 0/1 values, whose high half is always zero, so a broken half-pairing/`AND` there can
+// go undetected. Here lanes vary only the high half, only the low half, or neither, and boundary
+// values cross the 2^32 seam.
+template <typename Scalar, typename Packet>
+struct packetmath_64bit_boundary_test<Scalar, Packet,
+                                      std::enable_if_t<NumTraits<Scalar>::IsInteger && sizeof(Scalar) == 8>> {
+  static constexpr int PacketSize = unpacket_traits<Packet>::size;
+  static constexpr int size = 2 * PacketSize;
+
+  static void run() {
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
+    EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[size];
+
+    const auto ref_abs = [](const Scalar& x) { return x < Scalar(0) ? test::negate(x) : x; };
+    const auto check_ops = [&] {
+      CHECK_CWISE2_MASK(REF_PCMP_EQ, internal::pcmp_eq);
+      CHECK_CWISE2_MASK(internal::pcmp_lt, internal::pcmp_lt);
+      CHECK_CWISE2_MASK(internal::pcmp_le, internal::pcmp_le);
+      CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasMin, (std::min), internal::pmin);
+      CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasMax, (std::max), internal::pmax);
+      CHECK_CWISE2_IF(internal::packet_traits<Scalar>::HasMul, test::REF_MUL, internal::pmul);
+      CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasNegate, test::negate, internal::pnegate);
+      CHECK_CWISE1(ref_abs, internal::pabs);
+    };
+
+    constexpr Scalar high = 0x11111111;
+    constexpr Scalar low = 0x00000001;
+    constexpr Scalar reference = (high << 32) | low;
+    constexpr Scalar high_shifted = (high << 33) | low;
+    constexpr Scalar low_shifted = (high << 32) | (low << 1);
+
+    static constexpr Scalar half_lanes[] = {high_shifted, low_shifted, reference};
+    constexpr int half_lanes_count = sizeof(half_lanes) / sizeof(half_lanes[0]);
+
+    constexpr int half_lanes_chunks = numext::div_ceil(half_lanes_count, PacketSize);
+    for (int chunk = 0; chunk < half_lanes_chunks; ++chunk) {
+      Map<ArrayX<Scalar>>(data1, PacketSize).setConstant(reference);
+      for (int i = 0; i < PacketSize; ++i)
+        data1[i + PacketSize] = half_lanes[(chunk * PacketSize + i) % half_lanes_count];
+      check_ops();
+
+      for (int i = 0; i < PacketSize; ++i) std::swap(data1[i], data1[i + PacketSize]);
+      check_ops();
+    }
+
+    const auto from_bits = [](unsigned long long bits) { return numext::bit_cast<Scalar>(bits); };
+    const Scalar boundary_values[] = {
+        Scalar(0),
+        Scalar(1),
+        from_bits(0xFFFFFFFFFFFFFFFFull),  // -1 (signed) / UINT64_MAX (unsigned)
+        from_bits(0x8000000000000000ull),  // INT64_MIN (signed) / 2^63 (unsigned)
+        from_bits(0x7FFFFFFFFFFFFFFFull),  // INT64_MAX
+        from_bits(0x00000000FFFFFFFFull),  // 2^32 - 1
+        from_bits(0x0000000100000000ull),  // 2^32
+        from_bits(0x00000001FFFFFFFFull),  // 2^33 - 1
+    };
+    constexpr int num_boundary = sizeof(boundary_values) / sizeof(boundary_values[0]);
+
+    // Test every distinct pair of `boundary_values` entries against each other.  Broadcast each
+    // pair across all lanes; lane-position coverage is already exercised above and in the
+    // self-value sweep below.
+    for (int i = 0; i < num_boundary; ++i) {
+      for (int j = i + 1; j < num_boundary; ++j) {
+        for (int k = 0; k < PacketSize; ++k) {
+          data1[k] = boundary_values[i];
+          data1[k + PacketSize] = boundary_values[j];
+        }
+        check_ops();
+
+        for (int k = 0; k < PacketSize; ++k) std::swap(data1[k], data1[k + PacketSize]);
+        check_ops();
+      }
+    }
+
+    constexpr int num_self_chunks = numext::div_ceil(num_boundary, PacketSize);
+    for (int chunk = 0; chunk < num_self_chunks; ++chunk) {
+      for (int i = 0; i < PacketSize; ++i) {
+        const int idx = (chunk * PacketSize + i) % num_boundary;
+        data1[i] = data1[i + PacketSize] = boundary_values[idx];
+      }
+      check_ops();
+    }
   }
 };
 
@@ -488,8 +697,8 @@
 
 template <typename Packet>
 struct eigen_optimization_barrier_test<
-    Packet, std::enable_if_t<!NumTraits<Packet>::IsComplex && !internal::is_same<Packet, Eigen::half>::value &&
-                             !internal::is_same<Packet, Eigen::bfloat16>::value>> {
+    Packet, std::enable_if_t<!NumTraits<Packet>::IsComplex && !std::is_same<Packet, Eigen::half>::value &&
+                             !std::is_same<Packet, Eigen::bfloat16>::value>> {
   static void run() {
     typedef typename internal::unpacket_traits<Packet>::type Scalar;
     Scalar s = internal::random<Scalar>();
@@ -535,12 +744,12 @@
     std::cerr << "=== Testing packet of type '" << typeid(Packet).name() << "' and scalar type '"
               << typeid(Scalar).name() << "' and size '" << PacketSize << "' ===\n";
 
-  const int max_size = PacketSize > 4 ? PacketSize : 4;
+  constexpr int max_size = PacketSize > 4 ? PacketSize : 4;
   const int size = PacketSize * max_size;
-  EIGEN_ALIGN_MAX Scalar data1[size];
-  EIGEN_ALIGN_MAX Scalar data2[size];
-  EIGEN_ALIGN_MAX Scalar data3[size];
-  EIGEN_ALIGN_MAX Scalar ref[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data3[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[size];
   RealScalar refvalue = RealScalar(0);
 
   eigen_optimization_barrier_test<Packet>::run();
@@ -553,17 +762,13 @@
   }
 
   internal::pstore(data2, internal::pload<Packet>(data1));
-  VERIFY(test::areApprox(data1, data2, PacketSize) && "aligned load/store");
+  VERIFY(test::areEqualBits(data1, data2, PacketSize, false) && "aligned load/store");
 
-  for (int offset = 0; offset < PacketSize; ++offset) {
-    internal::pstore(data2, internal::ploadu<Packet>(data1 + offset));
-    VERIFY(test::areApprox(data1 + offset, data2, PacketSize) && "internal::ploadu");
-  }
-
-  for (int offset = 0; offset < PacketSize; ++offset) {
-    internal::pstoreu(data2 + offset, internal::pload<Packet>(data1));
-    VERIFY(test::areApprox(data1, data2 + offset, PacketSize) && "internal::pstoreu");
-  }
+  const test::Buffer<Scalar> movement_input = Map<const test::Buffer<Scalar>>(data1, size);
+  test::packetmath_data_movement<Packet>(movement_input,
+                                         [](const auto& kernel, int count, const auto& input, auto& output) {
+                                           for (int i = 0; i < count; ++i) kernel(i, input.data(), output.data());
+                                         });
 
   for (int M = 0; M < PacketSize; ++M) {
     for (int N = 0; N <= PacketSize; ++N) {
@@ -575,23 +780,23 @@
 
       if (M == 0) {
         internal::pstore_partial(data2, internal::pload_partial<Packet>(data1, N), N);
-        VERIFY(test::areApprox(data1, data2, N) && "aligned loadN/storeN");
+        VERIFY(test::areEqualBits(data1, data2, N, false) && "aligned loadN/storeN");
 
         for (int offset = 0; offset < PacketSize; ++offset) {
           internal::pstore_partial(data2, internal::ploadu_partial<Packet>(data1 + offset, N), N);
-          VERIFY(test::areApprox(data1 + offset, data2, N) && "internal::ploadu_partial");
+          VERIFY(test::areEqualBits(data1 + offset, data2, N, false) && "internal::ploadu_partial");
         }
 
         for (int offset = 0; offset < PacketSize; ++offset) {
           internal::pstoreu_partial(data2 + offset, internal::pload_partial<Packet>(data1, N), N);
-          VERIFY(test::areApprox(data1, data2 + offset, N) && "internal::pstoreu_partial");
+          VERIFY(test::areEqualBits(data1, data2 + offset, N, false) && "internal::pstoreu_partial");
         }
       }
 
       if (N + M > PacketSize) continue;  // Don't read or write past end of Packet
 
       internal::pstore_partial(data2, internal::pload_partial<Packet>(data1, N, M), N, M);
-      VERIFY(test::areApprox(data1, data2, N) && "aligned offset loadN/storeN");
+      VERIFY(test::areEqualBits(data1, data2, N, false) && "aligned offset loadN/storeN");
     }
   }
 
@@ -603,7 +808,7 @@
       for (unsigned long long umask = 0; umask < max_umask; ++umask) {
         h.store(data2, h.load(data1 + offset, umask));
         for (int k = 0; k < PacketSize; ++k) data3[k] = ((umask & (0x1ull << k)) >> k) ? data1[k + offset] : Scalar(0);
-        VERIFY(test::areApprox(data3, data2, PacketSize) && "internal::ploadu masked");
+        VERIFY(test::areEqualBits(data3, data2, PacketSize, false) && "internal::ploadu masked");
       }
     }
   }
@@ -617,7 +822,7 @@
         internal::pstore(data2, internal::pset1<Packet>(Scalar(0)));
         h.store(data2, h.loadu(data1 + offset), umask);
         for (int k = 0; k < PacketSize; ++k) data3[k] = ((umask & (0x1ull << k)) >> k) ? data1[k + offset] : Scalar(0);
-        VERIFY(test::areApprox(data3, data2, PacketSize) && "internal::pstoreu masked");
+        VERIFY(test::areEqualBits(data3, data2, PacketSize, false) && "internal::pstoreu masked");
       }
     }
   }
@@ -626,10 +831,10 @@
   VERIFY((!PacketTraits::Vectorizable) || PacketTraits::HasSub);
   VERIFY((!PacketTraits::Vectorizable) || PacketTraits::HasMul);
 
-  CHECK_CWISE2_IF(PacketTraits::HasAdd, REF_ADD, internal::padd);
-  CHECK_CWISE2_IF(PacketTraits::HasSub, REF_SUB, internal::psub);
-  CHECK_CWISE2_IF(PacketTraits::HasMul, REF_MUL, internal::pmul);
-  CHECK_CWISE2_IF(PacketTraits::HasDiv, REF_DIV, internal::pdiv);
+  CHECK_CWISE2_IF(PacketTraits::HasAdd, test::REF_ADD, internal::padd);
+  CHECK_CWISE2_IF(PacketTraits::HasSub, test::REF_SUB, internal::psub);
+  CHECK_CWISE2_IF(PacketTraits::HasMul, test::REF_MUL, internal::pmul);
+  CHECK_CWISE2_IF(PacketTraits::HasDiv, test::REF_DIV, internal::pdiv);
 
   negate_test<Scalar, Packet>(data1, data2, ref, PacketSize);
   CHECK_CWISE1_IF(PacketTraits::HasReciprocal, REF_RECIPROCAL, internal::preciprocal);
@@ -637,12 +842,6 @@
 
   CHECK_CWISE1_IF(PacketTraits::HasSign, numext::sign, internal::psign);
 
-  for (int offset = 0; offset < 3; ++offset) {
-    for (int i = 0; i < PacketSize; ++i) ref[i] = data1[offset];
-    internal::pstore(data2, internal::pset1<Packet>(data1[offset]));
-    VERIFY(test::areApprox(ref, data2, PacketSize) && "internal::pset1");
-  }
-
   {
     for (int i = 0; i < PacketSize * 4; ++i) ref[i] = data1[i / PacketSize];
     Packet A0, A1, A2, A3;
@@ -651,7 +850,7 @@
     internal::pstore(data2 + 1 * PacketSize, A1);
     internal::pstore(data2 + 2 * PacketSize, A2);
     internal::pstore(data2 + 3 * PacketSize, A3);
-    VERIFY(test::areApprox(ref, data2, 4 * PacketSize) && "internal::pbroadcast4");
+    VERIFY(test::areEqualBits(ref, data2, 4 * PacketSize, false) && "internal::pbroadcast4");
   }
 
   {
@@ -660,38 +859,34 @@
     internal::pbroadcast2<Packet>(data1, A0, A1);
     internal::pstore(data2 + 0 * PacketSize, A0);
     internal::pstore(data2 + 1 * PacketSize, A1);
-    VERIFY(test::areApprox(ref, data2, 2 * PacketSize) && "internal::pbroadcast2");
+    VERIFY(test::areEqualBits(ref, data2, 2 * PacketSize, false) && "internal::pbroadcast2");
   }
 
   VERIFY(internal::isApprox(data1[0], internal::pfirst(internal::pload<Packet>(data1))) && "internal::pfirst");
 
-  if (PacketSize > 1) {
-    // apply different offsets to check that ploaddup is robust to unaligned inputs
-    for (int offset = 0; offset < 4; ++offset) {
-      for (int i = 0; i < PacketSize / 2; ++i) ref[2 * i + 0] = ref[2 * i + 1] = data1[offset + i];
-      internal::pstore(data2, internal::ploaddup<Packet>(data1 + offset));
-      VERIFY(test::areApprox(ref, data2, PacketSize) && "ploaddup");
-    }
-  }
-
   if (PacketSize > 2) {
     // apply different offsets to check that ploadquad is robust to unaligned inputs
     for (int offset = 0; offset < 4; ++offset) {
       for (int i = 0; i < PacketSize / 4; ++i)
         ref[4 * i + 0] = ref[4 * i + 1] = ref[4 * i + 2] = ref[4 * i + 3] = data1[offset + i];
       internal::pstore(data2, internal::ploadquad<Packet>(data1 + offset));
-      VERIFY(test::areApprox(ref, data2, PacketSize) && "ploadquad");
+      VERIFY(test::areEqualBits(ref, data2, PacketSize, false) && "ploadquad");
     }
   }
 
-  ref[0] = Scalar(0);
-  for (int i = 0; i < PacketSize; ++i) ref[0] += data1[i];
+  // Match the packet reduction's accumulation precision. test::REF_ADD also preserves signed wrapping and Boolean OR
+  // semantics and avoids MSVC C4804 for raw Boolean addition.
+  using ReduxReferenceScalar = predux_reference_scalar_t<Packet>;
+  ReduxReferenceScalar redux_ref(0);
+  for (int i = 0; i < PacketSize; ++i)
+    redux_ref = test::REF_ADD(redux_ref, static_cast<ReduxReferenceScalar>(data1[i]));
+  ref[0] = static_cast<Scalar>(redux_ref);
   VERIFY(test::isApproxAbs(ref[0], internal::predux(internal::pload<Packet>(data1)), refvalue) && "internal::predux");
 
-  if (!internal::is_same<Packet, typename internal::unpacket_traits<Packet>::half>::value) {
+  if (!std::is_same<Packet, typename internal::unpacket_traits<Packet>::half>::value) {
     int HalfPacketSize = PacketSize > 4 ? PacketSize / 2 : PacketSize;
     for (int i = 0; i < HalfPacketSize; ++i) ref[i] = Scalar(0);
-    for (int i = 0; i < PacketSize; ++i) ref[i % HalfPacketSize] += data1[i];
+    for (int i = 0; i < PacketSize; ++i) ref[i % HalfPacketSize] = test::REF_ADD(ref[i % HalfPacketSize], data1[i]);
     internal::pstore(data2, internal::predux_half(internal::pload<Packet>(data1)));
     VERIFY(test::areApprox(ref, data2, HalfPacketSize) && "internal::predux_half");
   }
@@ -709,30 +904,14 @@
     // Prevent very small product results by adjusting range.  Otherwise,
     // we may end up with multiplying e.g. 32 Eigen::halfs with values < 1.
     for (int i = 0; i < PacketSize; ++i) {
-      data1[i] = REF_MUL(internal::random<Scalar>(Scalar(0.5), Scalar(1)),
-                         (internal::random<bool>() ? Scalar(-1) : Scalar(1)));
+      data1[i] = test::REF_MUL(internal::random<Scalar>(Scalar(0.5), Scalar(1)),
+                               (internal::random<bool>() ? Scalar(-1) : Scalar(1)));
     }
   }
   ref[0] = Scalar(1);
-  for (int i = 0; i < PacketSize; ++i) ref[0] = REF_MUL(ref[0], data1[i]);
+  for (int i = 0; i < PacketSize; ++i) ref[0] = test::REF_MUL(ref[0], data1[i]);
   VERIFY(internal::isApprox(ref[0], internal::predux_mul(internal::pload<Packet>(data1))) && "internal::predux_mul");
 
-  for (int i = 0; i < PacketSize; ++i) ref[i] = data1[PacketSize - i - 1];
-  internal::pstore(data2, internal::preverse(internal::pload<Packet>(data1)));
-  VERIFY(test::areApprox(ref, data2, PacketSize) && "internal::preverse");
-
-  internal::PacketBlock<Packet> kernel;
-  for (int i = 0; i < PacketSize; ++i) {
-    kernel.packet[i] = internal::pload<Packet>(data1 + i * PacketSize);
-  }
-  ptranspose(kernel);
-  for (int i = 0; i < PacketSize; ++i) {
-    internal::pstore(data2, kernel.packet[i]);
-    for (int j = 0; j < PacketSize; ++j) {
-      VERIFY(test::isApproxAbs(data2[j], data1[i + j * PacketSize], refvalue) && "ptranspose");
-    }
-  }
-
   // GeneralBlockPanelKernel also checks PacketBlock<Packet,(PacketSize%4)==0?4:PacketSize>;
   if (PacketSize > 4 && PacketSize % 4 == 0) {
     internal::PacketBlock<Packet, PacketSize % 4 == 0 ? 4 : PacketSize> kernel2;
@@ -781,6 +960,8 @@
   packetmath_boolean_mask_ops<Scalar, Packet>();
   packetmath_pcast_ops_runner<Scalar, Packet>::run();
   packetmath_minus_zero_add_test<Scalar, Packet>::run();
+  packetmath_integer_predicates_test<Scalar, Packet>::run();
+  packetmath_64bit_boundary_test<Scalar, Packet>::run();
 
   CHECK_CWISE3_IF(true, REF_MADD, internal::pmadd);
   if (!std::is_same<Scalar, bool>::value && NumTraits<Scalar>::IsSigned) {
@@ -806,7 +987,7 @@
 }
 
 // Notice that this definition works for complex types as well.
-// c++11 has std::log2 for real, but not for complex types.
+// std::log2 only supports real types, not complex.
 template <typename Scalar>
 Scalar log2(Scalar x) {
   return Scalar(EIGEN_LOG2E) * std::log(x);
@@ -818,16 +999,16 @@
   const int PacketSize = internal::unpacket_traits<Packet>::size;
 
   const int size = PacketSize * 4;
-  EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4] = {};
-  EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4] = {};
-  EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4] = {};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[PacketSize * 4] = {};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[PacketSize * 4] = {};
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[PacketSize * 4] = {};
 
   // Negate with -0.
   if (PacketTraits::HasNegate) {
     test::packet_helper<PacketTraits::HasNegate, Packet> h;
     data1[0] = Scalar{-0};
     h.store(data2, internal::pnegate(h.load(data1)));
-    typedef typename internal::make_unsigned<typename internal::make_integer<Scalar>::type>::type Bits;
+    typedef std::make_unsigned_t<typename internal::make_integer<Scalar>::type> Bits;
     Bits bits = numext::bit_cast<Bits>(data2[0]);
     VERIFY_IS_EQUAL(bits, static_cast<Bits>(Bits(1) << (sizeof(Scalar) * CHAR_BIT - 1)));
   }
@@ -841,6 +1022,7 @@
 
   CHECK_CWISE1_IF(PacketTraits::HasLog, std::log, internal::plog);
   CHECK_CWISE1_IF(PacketTraits::HasLog, log2, internal::plog2);
+  CHECK_CWISE1_IF(PacketTraits::HasLog10, std::log10, internal::plog10);
   CHECK_CWISE1_IF(PacketTraits::HasRsqrt, numext::rsqrt, internal::prsqrt);
 
   for (int i = 0; i < size; ++i) {
@@ -985,6 +1167,35 @@
     data1[0] = Scalar(std::ldexp(Scalar(1.0), NumTraits<Scalar>::max_exponent() - 1));
     data1[PacketSize] = Scalar(+NumTraits<Scalar>::min_exponent() - NumTraits<Scalar>::max_exponent());
     CHECK_CWISE2_IF(PacketTraits::HasExp, REF_LDEXP, internal::pldexp);
+    // Near-max magnitude with small negative exponents.  Regression guard for
+    // the 4-way scale-factor split: the remainder factor c2 = 2^(e-3*floor(e/4))
+    // is > 1 for e in {-1, -2, -5, -6, ...}, so the multiply tree must apply
+    // the downscale c1 before c2 -- otherwise (numext::abs(a)) * c2 spuriously
+    // overflows to inf for finite results like ldexp((numext::numeric_limits)
+    // <Scalar>::max(), -1).
+    for (int i = 0; i < PacketSize; ++i) {
+      data1[i] = (numext::numeric_limits<Scalar>::max)();
+      data1[i + PacketSize] = Scalar(-1 - (i % 8));  // -1, -2, ..., -8
+    }
+    CHECK_CWISE2_IF(PacketTraits::HasExp, REF_LDEXP, internal::pldexp);
+    // For |e| >= 2 * max_exponent, reassociated scale factors overflow and can
+    // turn zero into NaN or finite denormal results into infinity.
+#if !EIGEN_ARCH_ARM
+    const Scalar tiny = std::numeric_limits<Scalar>::denorm_min();
+#else
+    // 32-bit ARM flushes denormal inputs to zero.
+    const Scalar tiny = (std::numeric_limits<Scalar>::min)();
+#endif
+    for (int i = 0; i < PacketSize; ++i) {
+      data1[i] = (i % 2) ? tiny : Scalar(0);
+      data1[i + PacketSize] = Scalar(2 * NumTraits<Scalar>::max_exponent() + (i % 4));
+    }
+    CHECK_CWISE2_IF(PacketTraits::HasExp, REF_LDEXP, internal::pldexp);
+    for (int i = 0; i < PacketSize; ++i) {
+      data1[i] = (i % 2) ? Scalar(1) : Scalar(0);
+      data1[i + PacketSize] = Scalar(-2 * NumTraits<Scalar>::max_exponent() - (i % 4));
+    }
+    CHECK_CWISE2_IF(PacketTraits::HasExp, REF_LDEXP, internal::pldexp);
   }
 
   for (int i = 0; i < size; ++i) {
@@ -1019,14 +1230,20 @@
     h.store(data2, internal::pexp(h.load(data1)));
     VERIFY_IS_APPROX(std::exp(std::numeric_limits<Scalar>::denorm_min()), data2[0]);
     VERIFY_IS_APPROX(std::exp(-std::numeric_limits<Scalar>::denorm_min()), data2[1]);
-  }
 
-  if (PacketTraits::HasTanh) {
-    // NOTE this test might fail with GCC prior to 6.3, see MathFunctionsImpl.h for details.
-    data1[0] = NumTraits<Scalar>::quiet_NaN();
-    test::packet_helper<internal::packet_traits<Scalar>::HasTanh, Packet> h;
-    h.store(data2, internal::ptanh(h.load(data1)));
-    VERIFY((numext::isnan)(data2[0]));
+    // pexp must produce subnormal outputs for inputs in
+    // [log(denorm_min), log(min)).
+#if !EIGEN_ARCH_ARM  // 32-bit ARM flushes subnormals.
+    if (std::numeric_limits<Scalar>::has_denorm == std::denorm_present) {
+      const Scalar log_min = numext::log((std::numeric_limits<Scalar>::min)());
+      const Scalar log_denorm_min = numext::log(std::numeric_limits<Scalar>::denorm_min());
+      data1[0] = log_min - Scalar(0.5);                     // just inside subnormal cliff
+      data1[1] = Scalar(0.5) * (log_min + log_denorm_min);  // mid-subnormal
+      h.store(data2, internal::pexp(h.load(data1)));
+      VERIFY_IS_APPROX(numext::exp(data1[0]), data2[0]);
+      VERIFY_IS_APPROX(numext::exp(data1[1]), data2[1]);
+    }
+#endif
   }
 
   if (PacketTraits::HasExp) {
@@ -1042,14 +1259,12 @@
     }
   }
 
-#if EIGEN_HAS_C99_MATH
   data1[0] = NumTraits<Scalar>::infinity();
   data1[1] = Scalar(-1);
   CHECK_CWISE1_IF(PacketTraits::HasLog1p, std::log1p, internal::plog1p);
   data1[0] = NumTraits<Scalar>::infinity();
   data1[1] = -NumTraits<Scalar>::infinity();
   CHECK_CWISE1_IF(PacketTraits::HasExpm1, std::expm1, internal::pexpm1);
-#endif
 
   if (PacketSize >= 2) {
     data1[0] = NumTraits<Scalar>::quiet_NaN();
@@ -1059,7 +1274,7 @@
       h.store(data2, internal::plog(h.load(data1)));
       VERIFY((numext::isnan)(data2[0]));
       // TODO(cantonios): Re-enable for bfloat16.
-      if (!internal::is_same<Scalar, bfloat16>::value) {
+      if (!std::is_same<Scalar, bfloat16>::value) {
         VERIFY_IS_APPROX(std::log(data1[1]), data2[1]);
       }
 
@@ -1073,32 +1288,18 @@
       data1[1] = -(std::numeric_limits<Scalar>::min)();
       h.store(data2, internal::plog(h.load(data1)));
       // TODO(cantonios): Re-enable for bfloat16.
-      if (!internal::is_same<Scalar, bfloat16>::value) {
+      if (!std::is_same<Scalar, bfloat16>::value) {
         VERIFY_IS_APPROX(std::log((std::numeric_limits<Scalar>::min)()), data2[0]);
       }
       VERIFY((numext::isnan)(data2[1]));
-
-      // Note: 32-bit arm always flushes denorms to zero.
-#if !EIGEN_ARCH_ARM
-      if (std::numeric_limits<Scalar>::has_denorm == std::denorm_present) {
-        data1[0] = std::numeric_limits<Scalar>::denorm_min();
-        data1[1] = -std::numeric_limits<Scalar>::denorm_min();
-        h.store(data2, internal::plog(h.load(data1)));
-        // TODO(rmlarsen): Re-enable for bfloat16.
-        if (!internal::is_same<Scalar, bfloat16>::value) {
-          VERIFY_IS_APPROX(std::log(std::numeric_limits<Scalar>::denorm_min()), data2[0]);
-        }
-        VERIFY((numext::isnan)(data2[1]));
-      }
-#endif
-
-      data1[0] = Scalar(-1.0f);
-      h.store(data2, internal::plog(h.load(data1)));
-      VERIFY((numext::isnan)(data2[0]));
-
-      data1[0] = NumTraits<Scalar>::infinity();
-      h.store(data2, internal::plog(h.load(data1)));
-      VERIFY((numext::isinf)(data2[0]));
+    }
+    if (PacketTraits::HasLog10) {
+      test::packet_helper<PacketTraits::HasLog10, Packet> h;
+      data1[0] = Scalar(0);
+      data1[1] = NumTraits<Scalar>::infinity();
+      h.store(data2, internal::plog10(h.load(data1)));
+      VERIFY_IS_EQUAL(std::log10(Scalar(0)), data2[0]);
+      VERIFY_IS_EQUAL(std::log10(NumTraits<Scalar>::infinity()), data2[1]);
     }
     if (PacketTraits::HasLog1p) {
       test::packet_helper<PacketTraits::HasLog1p, Packet> h;
@@ -1110,8 +1311,7 @@
     }
 
     // TODO(rmlarsen): Re-enable for half and bfloat16.
-    if (PacketTraits::HasCos && !internal::is_same<Scalar, half>::value &&
-        !internal::is_same<Scalar, bfloat16>::value) {
+    if (PacketTraits::HasCos && !std::is_same<Scalar, half>::value && !std::is_same<Scalar, bfloat16>::value) {
       test::packet_helper<PacketTraits::HasCos, Packet> h;
       for (Scalar k = Scalar(1); k < Scalar(10000) / NumTraits<Scalar>::epsilon(); k *= Scalar(2)) {
         for (int k1 = 0; k1 <= 1; ++k1) {
@@ -1134,22 +1334,6 @@
         }
       }
 
-      data1[0] = NumTraits<Scalar>::infinity();
-      data1[1] = -NumTraits<Scalar>::infinity();
-      h.store(data2, internal::psin(h.load(data1)));
-      VERIFY((numext::isnan)(data2[0]));
-      VERIFY((numext::isnan)(data2[1]));
-
-      h.store(data2, internal::pcos(h.load(data1)));
-      VERIFY((numext::isnan)(data2[0]));
-      VERIFY((numext::isnan)(data2[1]));
-
-      data1[0] = NumTraits<Scalar>::quiet_NaN();
-      h.store(data2, internal::psin(h.load(data1)));
-      VERIFY((numext::isnan)(data2[0]));
-      h.store(data2, internal::pcos(h.load(data1)));
-      VERIFY((numext::isnan)(data2[0]));
-
       data1[0] = -Scalar(0.);
       h.store(data2, internal::psin(h.load(data1)));
       VERIFY(test::biteq(data2[0], data1[0]));
@@ -1175,14 +1359,6 @@
   }
 }
 
-#define CAST_CHECK_CWISE1_IF(COND, REFOP, POP, SCALAR, REFTYPE)                                  \
-  if (COND) {                                                                                    \
-    test::packet_helper<COND, Packet> h;                                                         \
-    for (int i = 0; i < PacketSize; ++i) ref[i] = SCALAR(REFOP(static_cast<REFTYPE>(data1[i]))); \
-    h.store(data2, POP(h.load(data1)));                                                          \
-    VERIFY(test::areApprox(ref, data2, PacketSize) && #POP);                                     \
-  }
-
 template <typename Scalar>
 Scalar propagate_nan_max(const Scalar& a, const Scalar& b) {
   if ((numext::isnan)(a)) return a;
@@ -1211,6 +1387,85 @@
   return (numext::mini)(a, b);
 }
 
+// pmin/pmax<PropagateNaN> may differ from plain pmin/pmax only where a NaN is involved: on two
+// ordered operands both must select the same one, down to the sign of a zero result. Signed
+// zeros are the only operands that compare equal while differing in their bits, and isApprox
+// cannot tell them apart, so compare the bits. Which operand a tie selects stays unspecified:
+// it varies with the backend and with the packet width wherever the hardware min/max resolves
+// a tie by sign rather than by position (issue #3116).
+template <typename Scalar, typename Packet, typename EnableIf = void>
+struct packetmath_minmax_propagation_test {
+  static void run() {}
+};
+
+template <typename Scalar, typename Packet>
+struct packetmath_minmax_propagation_test<Scalar, Packet, std::enable_if_t<!NumTraits<Scalar>::IsInteger>> {
+  using PacketTraits = internal::packet_traits<Scalar>;
+
+  // NaN payloads are not pinned down across backends, so a NaN result only has to stay a NaN.
+  static void verify_semantics(const Scalar& a, const Scalar& b, const Scalar& plain, const Scalar& fast,
+                               const Scalar& nan, const Scalar& numbers) {
+    const bool a_is_nan = (numext::isnan)(a), b_is_nan = (numext::isnan)(b);
+    if (a_is_nan || b_is_nan) {
+      VERIFY((numext::isnan)(nan));
+      if (a_is_nan && b_is_nan) {
+        VERIFY((numext::isnan)(numbers));
+      } else {
+        VERIFY(test::biteq(numbers, a_is_nan ? b : a));
+      }
+    } else {
+      VERIFY(test::biteq(nan, plain));
+      VERIFY(test::biteq(fast, plain));
+    }
+  }
+
+  static void run() {
+    constexpr int PacketSize = internal::unpacket_traits<Packet>::size;
+    const std::vector<Scalar> values = test::special_values<Scalar>();
+    const int kNumValues = int(values.size());
+
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<Packet>::alignment) Scalar lhs[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<Packet>::alignment) Scalar rhs[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<Packet>::alignment) Scalar plain[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<Packet>::alignment) Scalar fast[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<Packet>::alignment) Scalar nan[PacketSize];
+    EIGEN_ALIGN_TO_BOUNDARY(internal::unpacket_traits<Packet>::alignment) Scalar numbers[PacketSize];
+
+    // Without HasMin/HasMax the helper degrades to the scalar op and writes only one element.
+    constexpr int kMinLanes = PacketTraits::HasMin ? PacketSize : 1;
+    constexpr int kMaxLanes = PacketTraits::HasMax ? PacketSize : 1;
+
+    test::packet_helper<PacketTraits::HasMin, Packet> hmin;
+    test::packet_helper<PacketTraits::HasMax, Packet> hmax;
+    for (int i = 0; i < kNumValues; ++i) {
+      const Scalar& a = values[i];
+      for (int j = 0; j < kNumValues; ++j) {
+        const Scalar& b = values[j];
+        verify_semantics(a, b, internal::pmin(a, b), internal::pmin<PropagateFast>(a, b),
+                         internal::pmin<PropagateNaN>(a, b), internal::pmin<PropagateNumbers>(a, b));
+        verify_semantics(a, b, internal::pmax(a, b), internal::pmax<PropagateFast>(a, b),
+                         internal::pmax<PropagateNaN>(a, b), internal::pmax<PropagateNumbers>(a, b));
+
+        for (int k = 0; k < PacketSize; ++k) {
+          lhs[k] = a;
+          rhs[k] = b;
+        }
+        hmin.store(plain, internal::pmin(hmin.load(lhs), hmin.load(rhs)));
+        hmin.store(fast, internal::pmin<PropagateFast>(hmin.load(lhs), hmin.load(rhs)));
+        hmin.store(nan, internal::pmin<PropagateNaN>(hmin.load(lhs), hmin.load(rhs)));
+        hmin.store(numbers, internal::pmin<PropagateNumbers>(hmin.load(lhs), hmin.load(rhs)));
+        for (int k = 0; k < kMinLanes; ++k) verify_semantics(a, b, plain[k], fast[k], nan[k], numbers[k]);
+
+        hmax.store(plain, internal::pmax(hmax.load(lhs), hmax.load(rhs)));
+        hmax.store(fast, internal::pmax<PropagateFast>(hmax.load(lhs), hmax.load(rhs)));
+        hmax.store(nan, internal::pmax<PropagateNaN>(hmax.load(lhs), hmax.load(rhs)));
+        hmax.store(numbers, internal::pmax<PropagateNumbers>(hmax.load(lhs), hmax.load(rhs)));
+        for (int k = 0; k < kMaxLanes; ++k) verify_semantics(a, b, plain[k], fast[k], nan[k], numbers[k]);
+      }
+    }
+  }
+};
+
 template <bool Cond, typename Scalar, typename Packet, bool SkipDenorms = EIGEN_ARCH_ARM, typename FunctorT>
 std::enable_if_t<!Cond, void> run_ieee_cases(const FunctorT&) {}
 
@@ -1234,9 +1489,9 @@
   }
 
   constexpr int size = PacketSize * 2;
-  EIGEN_ALIGN_MAX Scalar data1[size];
-  EIGEN_ALIGN_MAX Scalar data2[size];
-  EIGEN_ALIGN_MAX Scalar ref[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[size];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[size];
   for (int i = 0; i < size; ++i) {
     data1[i] = data2[i] = ref[i] = Scalar(0);
   }
@@ -1310,15 +1565,127 @@
 }
 
 template <typename Scalar, typename Packet>
+void packetmath_redux_infinities() {
+  const Scalar infinity = NumTraits<Scalar>::infinity();
+  const Packet positive_infinity = internal::pset1<Packet>(infinity);
+  VERIFY_IS_EQUAL(internal::predux_min(positive_infinity), infinity);
+  VERIFY_IS_EQUAL(internal::predux_max(positive_infinity), infinity);
+
+  const Packet negative_infinity = internal::pset1<Packet>(-infinity);
+  VERIFY_IS_EQUAL(internal::predux_min(negative_infinity), -infinity);
+  VERIFY_IS_EQUAL(internal::predux_max(negative_infinity), -infinity);
+}
+
+#if defined(EIGEN_VECTORIZE_SSE2)
+void packetmath_packet16b_reductions() {
+  const internal::Packet16b packet(_mm_setr_epi8(0, 1, -1, 2, 0, -128, 127, 0, 0, 0, 3, -2, 0, 42, 0, -1));
+  VERIFY_IS_EQUAL(internal::predux_count(packet), 9);
+  VERIFY(!internal::predux_all(packet));
+
+  const internal::Packet16b all_nonzero(_mm_set1_epi8(-1));
+  VERIFY(internal::predux_all(all_nonzero));
+
+  EIGEN_ALIGN16 bool values[16];
+  for (int i = 0; i < 16; ++i) values[i] = i % 3 != 0;
+  const internal::Packet16b canonical_packet = internal::pload<internal::Packet16b>(values);
+  VERIFY_IS_EQUAL(internal::predux_count_impl<internal::Packet16b>::run(canonical_packet), 10);
+}
+
+void packetmath_packet16b_select() {
+  EIGEN_ALIGN16 bool condition[16];
+  EIGEN_ALIGN16 bool then_values[16];
+  EIGEN_ALIGN16 bool else_values[16];
+  EIGEN_ALIGN16 bool actual[16];
+
+  for (int i = 0; i < 16; ++i) {
+    condition[i] = (i % 3) == 0;
+    then_values[i] = (i % 2) == 0;
+    else_values[i] = (i % 5) == 0;
+  }
+
+  const internal::Packet16b condition_packet = internal::pload<internal::Packet16b>(condition);
+  const internal::Packet16b mask = internal::pcmp_eq(condition_packet, internal::pzero(condition_packet));
+  const internal::Packet16b selected = internal::pselect(mask, internal::pload<internal::Packet16b>(else_values),
+                                                         internal::pload<internal::Packet16b>(then_values));
+  internal::pstore(actual, selected);
+
+  for (int i = 0; i < 16; ++i) {
+    VERIFY_IS_EQUAL(actual[i], condition[i] ? then_values[i] : else_values[i]);
+  }
+}
+#endif
+
+template <typename Scalar, typename Packet>
+void packetmath_abs_bits() {
+  using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  constexpr int PacketSize = unpacket_traits<Packet>::size;
+  constexpr Bits Sign = Bits(1) << (8 * sizeof(Scalar) - 1);
+  constexpr Bits MinNormal = Bits(1) << (std::numeric_limits<Scalar>::digits - 1);
+  constexpr Bits Inf = (Sign - 1) ^ (MinNormal - 1);
+  // Move operands between the Scalar arrays and their bit patterns with memcpy only. Reading output[i] through
+  // bit_cast lets GCC 14 on ppc64le extract the lane from the pabs result with the signaling xscvspdp conversion,
+  // which quiets a signaling NaN before its bits are compared.
+  Bits input_bits[PacketSize], output_bits[PacketSize];
+  Scalar input[PacketSize], output[PacketSize];
+  const auto check = [&] {
+    std::memcpy(input, input_bits, sizeof(input));
+    internal::pstoreu(output, internal::pabs(internal::ploadu<Packet>(input)));
+    std::memcpy(output_bits, output, sizeof(output));
+    for (int i = 0; i < PacketSize; ++i) {
+      const Bits expected = input_bits[i] & (Sign - 1);
+      const Bits actual = output_bits[i];
+      if (std::is_same<Scalar, Packet>::value && std::is_floating_point<Scalar>::value && expected > Inf) {
+        // Scalar floating-point loads/stores (notably x87) may quiet signaling NaNs. Preserve all other bits.
+        VERIFY(actual == expected || actual == Bits(expected | (MinNormal >> 1)));
+      } else {
+        VERIFY_IS_EQUAL(actual, expected);
+      }
+    }
+  };
+  const auto run = [&] {
+    EIGEN_IF_CONSTEXPR (sizeof(Scalar) == 2) {
+      // Exhaust half/bfloat16 encodings, including signaling NaNs and their payloads.
+      for (int first = 0; first < 65536; first += PacketSize) {
+        for (int i = 0; i < PacketSize; ++i) input_bits[i] = Bits(first + i);
+        check();
+      }
+    } else {
+      const Bits samples[] = {Bits(0),
+                              Bits(1),
+                              Bits(2),
+                              Bits(MinNormal - 1),
+                              MinNormal,
+                              Bits(MinNormal + 1),
+                              numext::bit_cast<Bits>(Scalar(1)),
+                              Bits(Inf - 1),
+                              Inf,
+                              Bits(Inf | 1),
+                              Bits(Inf | (MinNormal >> 1)),
+                              Bits(Sign - 1)};
+      const int count = sizeof(samples) / sizeof(samples[0]);
+      for (int offset = 0; offset < count; ++offset) {
+        for (Bits sign : {Bits(0), Sign}) {
+          for (int i = 0; i < PacketSize; ++i) input_bits[i] = Bits(samples[(offset + i) % count] | sign);
+          check();
+        }
+      }
+    }
+  };
+  run();
+  ScopedFlushToZero flush_to_zero;
+  run();
+}
+
+template <typename Scalar, typename Packet>
 void packetmath_notcomplex() {
   packetmath_ieee_special_values<Scalar, Packet>();
 
   typedef internal::packet_traits<Scalar> PacketTraits;
   const int PacketSize = internal::unpacket_traits<Packet>::size;
 
-  EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4];
-  EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4];
-  EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[PacketSize * 4];
 
   Array<Scalar, Dynamic, 1>::Map(data1, PacketSize * 4).setRandom();
 
@@ -1355,15 +1722,13 @@
 
   {
     unsigned char* data1_bits = reinterpret_cast<unsigned char*>(data1);
-    // predux_all - not needed yet
-    // for (unsigned int i=0; i<PacketSize*sizeof(Scalar); ++i) data1_bits[i] = 0xff;
-    // VERIFY(internal::predux_all(internal::pload<Packet>(data1)) && "internal::predux_all(1111)");
-    // for(int k=0; k<PacketSize; ++k)
-    // {
-    //   for (unsigned int i=0; i<sizeof(Scalar); ++i) data1_bits[k*sizeof(Scalar)+i] = 0x0;
-    //   VERIFY( (!internal::predux_all(internal::pload<Packet>(data1))) && "internal::predux_all(0101)");
-    //   for (unsigned int i=0; i<sizeof(Scalar); ++i) data1_bits[k*sizeof(Scalar)+i] = 0xff;
-    // }
+    for (unsigned int i = 0; i < PacketSize * sizeof(Scalar); ++i) data1_bits[i] = 0xff;
+    VERIFY(internal::predux_all(internal::pload<Packet>(data1)) && "internal::predux_all(1111)");
+    for (int k = 0; k < PacketSize; ++k) {
+      for (unsigned int i = 0; i < sizeof(Scalar); ++i) data1_bits[k * sizeof(Scalar) + i] = 0x0;
+      VERIFY((!internal::predux_all(internal::pload<Packet>(data1))) && "internal::predux_all(0101)");
+      for (unsigned int i = 0; i < sizeof(Scalar); ++i) data1_bits[k * sizeof(Scalar) + i] = 0xff;
+    }
 
     // predux_any
     for (unsigned int i = 0; i < PacketSize * sizeof(Scalar); ++i) data1_bits[i] = 0x0;
@@ -1371,12 +1736,30 @@
     for (int k = 0; k < PacketSize; ++k) {
       for (unsigned int i = 0; i < sizeof(Scalar); ++i) data1_bits[k * sizeof(Scalar) + i] = 0xff;
       VERIFY(internal::predux_any(internal::pload<Packet>(data1)) && "internal::predux_any(0101)");
+      VERIFY_IS_EQUAL(internal::predux_count(internal::pload<Packet>(data1)), k + 1);
+    }
+    for (int k = 0; k < PacketSize; ++k) {
       for (unsigned int i = 0; i < sizeof(Scalar); ++i) data1_bits[k * sizeof(Scalar) + i] = 0x00;
     }
+    data1[0] = Scalar(-0.0);
+    VERIFY_IS_EQUAL(internal::predux_count(internal::pload<Packet>(data1)), 0);
+
+    for (int k = 0; k < PacketSize; ++k) {
+      data1[k] = Scalar(1);
+      VERIFY_IS_EQUAL(internal::predux_count(internal::pload<Packet>(data1)), k + 1);
+    }
+
+    if (!NumTraits<Scalar>::IsInteger) {
+      for (int k = 0; k < PacketSize; ++k) data2[k] = Scalar(0);
+      data2[PacketSize - 1] = NumTraits<Scalar>::quiet_NaN();
+      VERIFY_IS_EQUAL(internal::predux_count(internal::pload<Packet>(data2)), 1);
+    }
   }
 
   // Test NaN propagation.
   if (!NumTraits<Scalar>::IsInteger) {
+    packetmath_minmax_propagation_test<Scalar, Packet>::run();
+
     // Test reductions with no NaNs.
     ref[0] = data1[0];
     for (int i = 0; i < PacketSize; ++i) ref[0] = internal::pmin<PropagateNumbers>(ref[0], data1[i]);
@@ -1421,6 +1804,7 @@
   }
 
   packetmath_boolean_mask_ops_notcomplex_test<Scalar, Packet>::run();
+  packetmath_split_half_compare_test<Scalar, Packet>::run();
 }
 
 template <typename Scalar, typename Packet, bool ConjLhs, bool ConjRhs>
@@ -1600,12 +1984,12 @@
   const int PacketSize = internal::unpacket_traits<Packet>::size;
 
   const int size = PacketSize * 4;
-  EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4];
-  EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4];
-  EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4];
-  EIGEN_ALIGN_MAX Scalar pval[PacketSize * 4];
-  EIGEN_ALIGN_MAX RealScalar realdata[PacketSize * 4];
-  EIGEN_ALIGN_MAX RealScalar realref[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data2[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar ref[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar pval[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) RealScalar realdata[PacketSize * 4];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) RealScalar realref[PacketSize * 4];
 
   for (int i = 0; i < size; ++i) {
     data1[i] = internal::random<Scalar>() * Scalar(1e2);
@@ -1645,6 +2029,23 @@
     }
   }
 
+  // Test pisnan.
+  {
+    const Scalar values[4] = {Scalar(one, one), Scalar(nan, zero), Scalar(zero, nan), Scalar(nan, nan)};
+    const bool expect_nan[4] = {false, true, true, true};
+    // The scalar instantiation must remain callable with plain std::complex arguments.
+    for (int i = 0; i < 4; ++i) {
+      VERIFY(numext::is_exactly_zero(internal::pisnan(values[i])) == !expect_nan[i] && "scalar pisnan");
+    }
+    for (int i = 0; i < size; ++i) data1[i] = values[i % 4];
+    for (int j = 0; j < size; j += PacketSize) {
+      internal::pstore(data2 + j, internal::pisnan(internal::pload<Packet>(data1 + j)));
+    }
+    for (int i = 0; i < size; ++i) {
+      VERIFY(numext::is_exactly_zero(data2[i]) == !expect_nan[i % 4] && "pisnan");
+    }
+  }
+
   // Multiplication and Division.
   {
     std::array<RealScalar, 8> special_values = {zero, one, inf, nan, -zero, -one, -inf, -nan};
@@ -1667,7 +2068,6 @@
       data1[i] = Scalar(internal::random<RealScalar>(), internal::random<RealScalar>());
     }
     CHECK_CWISE1_N(numext::sqrt, internal::psqrt, size);
-    CHECK_CWISE1_IF(PacketTraits::HasSign, numext::sign, internal::psign);
 
     // Test misc. corner cases.
     data1[0] = Scalar(zero, zero);
@@ -1745,7 +2145,7 @@
 void packetmath_scatter_gather() {
   typedef typename NumTraits<Scalar>::Real RealScalar;
   const int PacketSize = internal::unpacket_traits<Packet>::size;
-  EIGEN_ALIGN_MAX Scalar data1[PacketSize];
+  EIGEN_ALIGN_TO_BOUNDARY(unpacket_traits<Packet>::alignment) Scalar data1[PacketSize];
   RealScalar refvalue = RealScalar(0);
   for (int i = 0; i < PacketSize; ++i) {
     data1[i] = internal::random<Scalar>();
@@ -1807,12 +2207,46 @@
   }
 }
 
+// At saturated unsigned short operands the scalar pmul family must wrap, not overflow the int that
+// integral promotion would otherwise multiply in.
+void packetmath_unsigned_short() {
+  // Volatile inputs keep sanitizer builds from folding away the promotions.
+  volatile unsigned short values[] = {0, 1, 32768, 40232, 58075, 65535};
+  const unsigned short c = 65535;
+  for (unsigned short a : values) {
+    for (unsigned short b : values) {
+      VERIFY_IS_EQUAL(internal::pmul(a, b), test::REF_MUL(a, b));
+      VERIFY_IS_EQUAL(internal::pmadd(a, b, c), REF_MADD(a, b, c));
+      VERIFY_IS_EQUAL(internal::pmsub(a, b, c), REF_MSUB(a, b, c));
+      VERIFY_IS_EQUAL(internal::pnmadd(a, b, c), REF_NMADD(a, b, c));
+      VERIFY_IS_EQUAL(internal::pnmsub(a, b, c), REF_NMSUB(a, b, c));
+    }
+  }
+}
+
+void packetmath_bfloat16_abs_array() {
+  // Keep public evaluator coverage with complete packets and a scalar tail.
+  constexpr Index count = 2 * internal::packet_traits<bfloat16>::size + 1;
+  const numext::uint16_t samples[] = {0x8000, 0x8001, 0x807f, 0x8080, 0xbf80, 0xff80, 0xff81, 0xffff};
+  Array<bfloat16, Dynamic, 1> input(count), result(count);
+  for (Index i = 0; i < count; ++i) {
+    input(i) = numext::bit_cast<bfloat16>(samples[i % 8]);
+  }
+  input(count - 1) = numext::bit_cast<bfloat16>(numext::uint16_t(0xffff));
+  result = input.abs();
+  for (Index i = 0; i < count; ++i) {
+    const auto expected = static_cast<numext::uint16_t>(numext::bit_cast<numext::uint16_t>(input(i)) & 0x7fff);
+    VERIFY_IS_EQUAL(numext::bit_cast<numext::uint16_t>(result(i)), expected);
+  }
+}
+
 namespace Eigen {
 namespace test {
 
 template <typename Scalar, typename PacketType>
 struct runall<Scalar, PacketType, false, false> {  // i.e. float or double
   static void run() {
+    if (g_first_pass) packetmath_abs_bits<Scalar, PacketType>();
     packetmath<Scalar, PacketType>();
     packetmath_scatter_gather<Scalar, PacketType>();
     packetmath_notcomplex<Scalar, PacketType>();
@@ -1850,6 +2284,7 @@
     CALL_SUBTEST_4(test::runner<uint8_t>::run());
     CALL_SUBTEST_5(test::runner<int16_t>::run());
     CALL_SUBTEST_6(test::runner<uint16_t>::run());
+    CALL_SUBTEST_6(packetmath_unsigned_short());
     CALL_SUBTEST_7(test::runner<int32_t>::run());
     CALL_SUBTEST_8(test::runner<uint32_t>::run());
     CALL_SUBTEST_9(test::runner<int64_t>::run());
@@ -1859,7 +2294,31 @@
     CALL_SUBTEST_13(test::runner<half>::run());
     CALL_SUBTEST_14((packetmath<bool, internal::packet_traits<bool>::type>()));
     CALL_SUBTEST_14((packetmath_scatter_gather<bool, internal::packet_traits<bool>::type>()));
+#if defined(EIGEN_VECTORIZE_SSE2)
+    CALL_SUBTEST_14(packetmath_packet16b_reductions());
+    CALL_SUBTEST_14(packetmath_packet16b_select());
+#endif
     CALL_SUBTEST_15(test::runner<bfloat16>::run());
     g_first_pass = false;
   }
+
+  CALL_SUBTEST_15(packetmath_bfloat16_abs_array());
+  CALL_SUBTEST_15({
+    ScopedFlushToZero flush_to_zero;
+    packetmath_bfloat16_abs_array();
+  });
+
+#if defined(EIGEN_VECTORIZE_RVV10)
+  CALL_SUBTEST_1((packetmath_redux_infinities<float, internal::Packet1Xf>()));
+  CALL_SUBTEST_1((packetmath_redux_infinities<float, internal::Packet2Xf>()));
+  CALL_SUBTEST_1((packetmath_redux_infinities<float, internal::Packet4Xf>()));
+  CALL_SUBTEST_2((packetmath_redux_infinities<double, internal::Packet1Xd>()));
+  CALL_SUBTEST_2((packetmath_redux_infinities<double, internal::Packet2Xd>()));
+  CALL_SUBTEST_2((packetmath_redux_infinities<double, internal::Packet4Xd>()));
+#endif
+
+#if defined(EIGEN_VECTORIZE_RVV10FP16)
+  CALL_SUBTEST_13((packetmath_redux_infinities<half, internal::Packet1Xh>()));
+  CALL_SUBTEST_13((packetmath_redux_infinities<half, internal::Packet2Xh>()));
+#endif
 }
diff --git a/test/packetmath_data_movement.h b/test/packetmath_data_movement.h
new file mode 100644
index 0000000..9abc13d
--- /dev/null
+++ b/test/packetmath_data_movement.h
@@ -0,0 +1,224 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_PACKETMATH_DATA_MOVEMENT_H
+#define EIGEN_TEST_PACKETMATH_DATA_MOVEMENT_H
+
+#include "packetmath_test_shared.h"
+
+namespace Eigen {
+namespace test {
+
+template <typename Scalar>
+using Buffer = Array<Scalar, Dynamic, 1>;
+
+// Loads and stores with their own addressing. `offset` misaligns the unaligned forms.
+template <typename Packet>
+struct ploadu_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  int offset;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstore(out + i * kSize, internal::ploadu<Packet>(in + i * kSize + offset));
+#endif
+  }
+};
+template <typename Packet>
+struct pstoreu_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  int offset;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstoreu(out + i * kSize + offset, internal::pload<Packet>(in + i * kSize));
+#endif
+  }
+};
+template <typename Packet, int Alignment>
+struct ploadt_ro_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  int offset;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstore(out + i * kSize, internal::ploadt_ro<Packet, Alignment>(in + i * kSize + offset));
+#endif
+  }
+};
+template <typename Packet>
+struct ploaddup_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  int offset;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstore(out + i * kSize, internal::ploaddup<Packet>(in + i * (kSize / 2) + offset));
+#endif
+  }
+};
+template <typename Packet>
+struct pset1_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstore(out + i * kSize, internal::pset1<Packet>(in[i]));
+#endif
+  }
+};
+template <typename Packet>
+struct pgather_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  int stride;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstore(out + i * kSize, internal::pgather<Scalar, Packet>(in + i * kSize * stride, stride));
+#endif
+  }
+};
+template <typename Packet>
+struct pscatter_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  int stride;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pscatter<Scalar, Packet>(out + i * kSize * stride, internal::pload<Packet>(in + i * kSize), stride);
+#endif
+  }
+};
+template <typename Packet>
+struct ptranspose_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::PacketBlock<Packet, kSize> block;
+    for (int r = 0; r < kSize; ++r) block.packet[r] = internal::pload<Packet>(in + (i * kSize + r) * kSize);
+    internal::ptranspose(block);
+    for (int r = 0; r < kSize; ++r) internal::pstore(out + (i * kSize + r) * kSize, block.packet[r]);
+#endif
+  }
+};
+// Thread i copies its first (i mod (kSize + 1)) lanes; the rest of the output keeps its sentinel.
+template <typename Packet>
+struct partial_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    const Index n = i % (kSize + 1);
+    internal::pstore_partial(out + i * kSize, internal::pload_partial<Packet>(in + i * kSize, n), n);
+#endif
+  }
+};
+template <typename Packet>
+struct preverse_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if EIGEN_PACKET_TEST_KERNEL_BODY
+    internal::pstore(out + i * kSize, internal::preverse(internal::pload<Packet>(in + i * kSize)));
+#endif
+  }
+};
+
+// The input owns aligned storage and contains at least max(4, packet size) complete packets.
+// run(kernel, count, input, output) executes one kernel invocation per packet (or transpose block).
+// With `nan_payloads` false, any NaN matches any NaN: the GPU half packets quiet a signalling NaN in transit.
+template <typename Packet, typename Run>
+void packetmath_data_movement(const Buffer<typename packet_layout<Packet>::Scalar>& in, const Run& run,
+                              bool nan_payloads = true) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  constexpr int kSize = packet_layout<Packet>::kSize;
+  const bool nan_is_nan = !nan_payloads;
+  VERIFY(in.size() >= kSize * (kSize > 4 ? kSize : 4) && in.size() % kSize == 0);
+  const int n = int(in.size()) / kSize;
+  {
+    Buffer<Scalar> out(in.size()), padded(in.size() + kSize), out_padded(in.size() + kSize),
+        expected_padded(in.size() + kSize);
+    padded << in, Buffer<Scalar>::Constant(kSize, Scalar(1));
+    for (int offset = 0; offset < kSize; ++offset) {
+      out.setConstant(Scalar(-7));
+      run(ploadu_kernel<Packet>{offset}, n, padded, out);
+      VERIFY(areEqualBits(padded.data() + offset, out.data(), int(in.size()), nan_is_nan) && "ploadu");
+      run(ploadt_ro_kernel<Packet, Unaligned>{offset}, n, padded, out);
+      VERIFY(areEqualBits(padded.data() + offset, out.data(), int(in.size()), nan_is_nan) && "ploadt_ro<Unaligned>");
+      out_padded.setConstant(Scalar(-7));
+      expected_padded.setConstant(Scalar(-7));
+      expected_padded.segment(offset, in.size()) = in;
+      run(pstoreu_kernel<Packet>{offset}, n, in, out_padded);
+      VERIFY(areEqualBits(expected_padded.data(), out_padded.data(), int(out_padded.size()), nan_is_nan) && "pstoreu");
+    }
+  }
+  {
+    Buffer<Scalar> out(in.size());
+    out.setConstant(Scalar(-7));
+    run(ploadt_ro_kernel<Packet, Aligned>{0}, n, in, out);
+    VERIFY(areEqualBits(in.data(), out.data(), int(in.size()), nan_is_nan) && "ploadt_ro<Aligned>");
+    Buffer<Scalar> expected(in.size());
+    if (kSize > 1) {
+      for (int offset = 0; offset < 4; ++offset) {
+        run(ploaddup_kernel<Packet>{offset}, n, in, out);
+        for (Index k = 0; k < in.size(); ++k) expected[k] = in[(k / kSize) * (kSize / 2) + (k % kSize) / 2 + offset];
+        VERIFY(areEqualBits(expected.data(), out.data(), int(in.size()), nan_is_nan) && "ploaddup");
+      }
+    }
+    run(pset1_kernel<Packet>(), n, in, out);
+    for (Index k = 0; k < in.size(); ++k) expected[k] = in[k / kSize];
+    VERIFY(areEqualBits(expected.data(), out.data(), int(in.size()), nan_is_nan) && "pset1");
+    out.setConstant(Scalar(-7));
+    run(partial_kernel<Packet>(), n, in, out);
+    for (Index k = 0; k < in.size(); ++k) {
+      const Index lanes = (k / kSize) % (kSize + 1);
+      expected[k] = (k % kSize) < lanes ? in[k] : Scalar(-7);
+    }
+    VERIFY(areEqualBits(expected.data(), out.data(), int(in.size()), nan_is_nan) && "pload_partial/pstore_partial");
+  }
+  {
+    const int stride = 3;
+    Buffer<Scalar> strided(in.size() * stride);
+    strided.setConstant(Scalar(-7));
+    for (Index k = 0; k < in.size(); ++k) strided[k * stride] = in[k];
+    Buffer<Scalar> out(in.size());
+    out.setConstant(Scalar(-7));
+    run(pgather_kernel<Packet>{stride}, n, strided, out);
+    VERIFY(areEqualBits(in.data(), out.data(), int(in.size()), nan_is_nan) && "pgather");
+    Buffer<Scalar> scattered(in.size() * stride);
+    scattered.setConstant(Scalar(-7));
+    run(pscatter_kernel<Packet>{stride}, n, in, scattered);
+    VERIFY(areEqualBits(strided.data(), scattered.data(), int(strided.size()), nan_is_nan) && "pscatter");
+  }
+  {
+    // A kSize x kSize block per thread.
+    const int blocks = n / kSize;
+    const int block_elements = kSize * kSize;
+    Buffer<Scalar> out(blocks * block_elements);
+    out.setConstant(Scalar(-7));
+    run(ptranspose_kernel<Packet>(), blocks, in, out);
+    Buffer<Scalar> expected(blocks * block_elements);
+    for (int block = 0; block < blocks; ++block) {
+      for (int r = 0; r < kSize; ++r) {
+        for (int c = 0; c < kSize; ++c) {
+          expected[block * block_elements + r * kSize + c] = in[block * block_elements + c * kSize + r];
+        }
+      }
+    }
+    VERIFY(areEqualBits(expected.data(), out.data(), int(out.size()), nan_is_nan) && "ptranspose");
+  }
+  {
+    Buffer<Scalar> out(in.size());
+    out.setConstant(Scalar(-7));
+    run(preverse_kernel<Packet>(), n, in, out);
+    Buffer<Scalar> expected(in.size());
+    for (Index k = 0; k < in.size(); ++k) expected[k] = in[(k / kSize) * kSize + (kSize - 1 - k % kSize)];
+    VERIFY(areEqualBits(expected.data(), out.data(), int(in.size()), nan_is_nan) && "preverse");
+  }
+}
+
+}  // namespace test
+}  // namespace Eigen
+
+#endif  // EIGEN_TEST_PACKETMATH_DATA_MOVEMENT_H
diff --git a/test/packetmath_fastmath.cpp b/test/packetmath_fastmath.cpp
new file mode 100644
index 0000000..8a085e0
--- /dev/null
+++ b/test/packetmath_fastmath.cpp
@@ -0,0 +1,329 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <cstring>
+
+#include "main.h"
+#include "fp_control.h"
+
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE void store_ptrue(Scalar* output) {
+  const Packet zero = Eigen::internal::pset1<Packet>(Scalar(0));
+  Eigen::internal::pstoreu<Scalar, Packet>(output, Eigen::internal::ptrue(zero));
+}
+
+// The out-of-line boundary keeps the mask opaque at the packet-op call site, so
+// the compiler must emit the mask test instead of folding it against the known
+// lane values.
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE void select_with_mask(const Scalar* mask, const Scalar* a, const Scalar* b, Scalar* output) {
+  const Packet selected = Eigen::internal::pselect(
+      Eigen::internal::ploadu<Packet>(mask), Eigen::internal::ploadu<Packet>(a), Eigen::internal::ploadu<Packet>(b));
+  Eigen::internal::pstoreu<Scalar, Packet>(output, selected);
+}
+
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE bool mask_any(const Scalar* mask) {
+  return Eigen::internal::predux_any(Eigen::internal::ploadu<Packet>(mask));
+}
+
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE bool mask_all(const Scalar* mask) {
+  return Eigen::internal::predux_all(Eigen::internal::ploadu<Packet>(mask));
+}
+
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE Index mask_count(const Scalar* mask) {
+  return Eigen::internal::predux_count(Eigen::internal::ploadu<Packet>(mask));
+}
+
+template <typename Scalar, typename Packet>
+void verify_mask_reduction_impl() {
+  constexpr int packet_size = Eigen::internal::unpacket_traits<Packet>::size;
+  Scalar mask[packet_size];
+
+  std::memset(static_cast<void*>(mask), 0, sizeof(mask));
+  VERIFY(!(mask_any<Scalar, Packet>(mask)));
+  VERIFY(!(mask_all<Scalar, Packet>(mask)));
+  VERIFY_IS_EQUAL((mask_count<Scalar, Packet>(mask)), 0);
+
+  for (int lane = 0; lane < packet_size; ++lane) {
+    std::memset(static_cast<void*>(mask), 0, sizeof(mask));
+    std::memset(static_cast<void*>(mask + lane), 0xff, sizeof(Scalar));
+    VERIFY((mask_any<Scalar, Packet>(mask)));
+    VERIFY_IS_EQUAL((mask_all<Scalar, Packet>(mask)), packet_size == 1);
+    VERIFY_IS_EQUAL((mask_count<Scalar, Packet>(mask)), 1);
+  }
+
+  std::memset(static_cast<void*>(mask), 0xff, sizeof(mask));
+  VERIFY((mask_all<Scalar, Packet>(mask)));
+  VERIFY_IS_EQUAL((mask_count<Scalar, Packet>(mask)), packet_size);
+}
+
+template <typename Scalar, typename Packet>
+void verify_mask_reduction() {
+  verify_mask_reduction_impl<Scalar, Packet>();
+  const Eigen::ScopedFlushToZero flush_to_zero;
+  if (flush_to_zero.isSupported()) verify_mask_reduction_impl<Scalar, Packet>();
+}
+
+template <typename Scalar, typename Packet>
+void verify_16bit_reductions() {
+  using Bits = Eigen::numext::uint16_t;
+  static_assert(sizeof(Scalar) == sizeof(Bits), "requires 16-bit scalars");
+  constexpr int packet_size = Eigen::internal::unpacket_traits<Packet>::size;
+  Scalar values[packet_size];
+  for (unsigned int bits = 0; bits < 65536; ++bits) {
+    for (int lane = 0; lane < packet_size; ++lane) {
+      for (int i = 0; i < packet_size; ++i) {
+        const Bits value = i == lane ? static_cast<Bits>(bits) : Bits(i % 2 ? 0x8000 : 0);
+        std::memcpy(static_cast<void*>(values + i), &value, sizeof(value));
+      }
+      VERIFY_IS_EQUAL((mask_count<Scalar, Packet>(values)), Index((bits & 0x7fff) != 0));
+      VERIFY(!(mask_all<Scalar, Packet>(values)));
+      for (int i = 0; i < packet_size; ++i) {
+        const Bits value = i == lane ? static_cast<Bits>(bits) : Bits(0xffff);
+        std::memcpy(static_cast<void*>(values + i), &value, sizeof(value));
+      }
+      VERIFY_IS_EQUAL((mask_all<Scalar, Packet>(values)), (bits & 0x7fff) != 0);
+      VERIFY_IS_EQUAL((mask_count<Scalar, Packet>(values)), Index(packet_size - 1 + ((bits & 0x7fff) != 0)));
+    }
+  }
+}
+
+// For bit-test backends, a low-bit truth mask must survive FTZ even though its floating-point encoding is subnormal.
+// Do not apply this to backends that consume only the sign bits of canonical comparison masks.
+template <typename Scalar, typename Packet>
+void verify_low_bit_mask_any_ftz() {
+  const Eigen::ScopedFlushToZero flush_to_zero;
+  VERIFY(flush_to_zero.isSupported());
+  constexpr int packet_size = Eigen::internal::unpacket_traits<Packet>::size;
+  using Bits = typename Eigen::numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  const Bits true_bits = 1;
+  Scalar mask[packet_size];
+  std::memset(static_cast<void*>(mask), 0, sizeof(mask));
+  VERIFY(!(mask_any<Scalar, Packet>(mask)));
+  for (int lane = 0; lane < packet_size; ++lane) {
+    std::memset(static_cast<void*>(mask), 0, sizeof(mask));
+    std::memcpy(static_cast<void*>(mask + lane), &true_bits, sizeof(Scalar));
+    VERIFY((mask_any<Scalar, Packet>(mask)));
+  }
+  for (int lane = 0; lane < packet_size; ++lane) {
+    std::memcpy(static_cast<void*>(mask + lane), &true_bits, sizeof(Scalar));
+  }
+  VERIFY((mask_any<Scalar, Packet>(mask)));
+}
+
+// Keep the finite inputs opaque while compiling the reduction itself with fast-math optimizations.
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE void reduce_minmax(const Scalar* input, Scalar* output) {
+  const Packet packet = Eigen::internal::ploadu<Packet>(input);
+  output[0] = Eigen::internal::predux_min(packet);
+  output[1] = Eigen::internal::predux_max(packet);
+}
+
+template <typename Scalar, typename Packet>
+void verify_minmax_reduction() {
+  constexpr int packet_size = Eigen::internal::unpacket_traits<Packet>::size;
+  Scalar input[packet_size];
+  for (int i = 0; i < packet_size; ++i) {
+    input[i] = Scalar(i + 1);
+  }
+
+  Scalar output[2];
+  reduce_minmax<Scalar, Packet>(input, output);
+  VERIFY_IS_EQUAL(output[0], Scalar(1));
+  VERIFY_IS_EQUAL(output[1], Scalar(packet_size));
+}
+
+// Complementary to the opaque-mask calls: the all-ones mask flows straight
+// from ptrue into the packet op, the way comparison-mask producers feed it,
+// which gives constant folding under -ffinite-math-only a chance to see the
+// NaN bit pattern.
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE bool ptrue_mask_any() {
+  const Packet zero = Eigen::internal::pset1<Packet>(Scalar(0));
+  return Eigen::internal::predux_any(Eigen::internal::ptrue(zero));
+}
+
+template <typename Scalar, typename Packet>
+EIGEN_DONT_INLINE void select_with_ptrue_mask(const Scalar* a, const Scalar* b, Scalar* output) {
+  const Packet zero = Eigen::internal::pset1<Packet>(Scalar(0));
+  const Packet selected = Eigen::internal::pselect(Eigen::internal::ptrue(zero), Eigen::internal::ploadu<Packet>(a),
+                                                   Eigen::internal::ploadu<Packet>(b));
+  Eigen::internal::pstoreu<Scalar, Packet>(output, selected);
+}
+
+template <typename Scalar>
+EIGEN_DONT_INLINE void store_extended_scalar_constants(Scalar* output) {
+  output[0] = Eigen::internal::psignmask<Scalar>();
+  output[1] = Eigen::internal::pinf<Scalar>();
+  output[2] = Eigen::internal::pnan<Scalar>();
+}
+
+template <typename Scalar>
+EIGEN_DONT_INLINE Eigen::numext::uint32_t extended_to_float_bits(const volatile Scalar* input) {
+  const float narrowed = static_cast<float>(*input);
+  return Eigen::numext::bit_cast<Eigen::numext::uint32_t>(narrowed);
+}
+
+template <typename Scalar, bool Vectorizable = Eigen::internal::packet_traits<Scalar>::Vectorizable>
+struct packetmath_fastmath_runner {
+  static void run() {}
+};
+
+template <typename Scalar>
+struct packetmath_fastmath_runner<Scalar, true> {
+  static void run() {
+    typedef typename Eigen::internal::packet_traits<Scalar>::type Packet;
+    const int packet_size = Eigen::internal::packet_traits<Scalar>::size;
+    Scalar output[packet_size];
+    for (int i = 0; i < packet_size; ++i) {
+      output[i] = Scalar(0);
+    }
+
+    store_ptrue<Scalar, Packet>(output);
+
+    for (int i = 0; i < packet_size; ++i) {
+      const unsigned char* lane_bytes = reinterpret_cast<const unsigned char*>(output + i);
+      bool has_nonzero_byte = false;
+      for (std::size_t j = 0; j < sizeof(Scalar); ++j) {
+        has_nonzero_byte = has_nonzero_byte || lane_bytes[j] != 0;
+      }
+      VERIFY(has_nonzero_byte);
+    }
+
+    // pselect and predux_any consume comparison masks whose "true" lanes are
+    // all-ones bit patterns, i.e. NaN when reinterpreted as floating point. An
+    // implementation that tests such a mask with a floating-point compare
+    // invites -ffinite-math-only to drop the unordered case and mishandle the
+    // "true" lanes, so exercise all-zero, all-ones, and single-lane masks here.
+    Scalar mask[packet_size];
+    Scalar a[packet_size];
+    Scalar b[packet_size];
+    Scalar selected[packet_size];
+    for (int i = 0; i < packet_size; ++i) {
+      a[i] = Scalar(i + 1);
+      b[i] = Scalar(-(i + 1));
+    }
+
+    std::memset(static_cast<void*>(mask), 0, sizeof(mask));
+    select_with_mask<Scalar, Packet>(mask, a, b, selected);
+    for (int i = 0; i < packet_size; ++i) {
+      VERIFY_IS_EQUAL(selected[i], b[i]);
+    }
+    VERIFY(!(mask_any<Scalar, Packet>(mask)));
+
+    std::memset(static_cast<void*>(mask), 0xff, sizeof(mask));
+    select_with_mask<Scalar, Packet>(mask, a, b, selected);
+    for (int i = 0; i < packet_size; ++i) {
+      VERIFY_IS_EQUAL(selected[i], a[i]);
+    }
+    VERIFY((mask_any<Scalar, Packet>(mask)));
+
+    select_with_ptrue_mask<Scalar, Packet>(a, b, selected);
+    for (int i = 0; i < packet_size; ++i) {
+      VERIFY_IS_EQUAL(selected[i], a[i]);
+    }
+    VERIFY((ptrue_mask_any<Scalar, Packet>()));
+
+    for (int lane = 0; lane < packet_size; ++lane) {
+      std::memset(static_cast<void*>(mask), 0, sizeof(mask));
+      std::memset(static_cast<void*>(mask + lane), 0xff, sizeof(Scalar));
+      select_with_mask<Scalar, Packet>(mask, a, b, selected);
+      for (int i = 0; i < packet_size; ++i) {
+        VERIFY_IS_EQUAL(selected[i], i == lane ? a[i] : b[i]);
+      }
+      VERIFY((mask_any<Scalar, Packet>(mask)));
+    }
+
+    verify_mask_reduction<Scalar, Packet>();
+    verify_minmax_reduction<Scalar, Packet>();
+  }
+};
+
+template <typename Scalar,
+          bool HasIntegerBits =
+              !std::is_void<typename Eigen::numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type>::value>
+struct extended_scalar_constant_runner {
+  static void run() {}
+};
+
+template <typename Scalar>
+struct extended_scalar_constant_runner<Scalar, false> {
+  static void run() {
+    Scalar actual[3];
+    store_extended_scalar_constants(actual);
+
+    // Floating-point classification is optimized away under -ffinite-math-only. Narrow through a volatile pointer and
+    // inspect the resulting integer bits instead; this also avoids indeterminate padding in x87 long double objects.
+    typedef Eigen::numext::uint32_t Bits;
+    const Bits sign_bits = extended_to_float_bits(actual + 0);
+    const Bits inf_bits = extended_to_float_bits(actual + 1);
+    const Bits nan_bits = extended_to_float_bits(actual + 2);
+    VERIFY_IS_EQUAL(sign_bits, Bits(0x80000000u));
+    VERIFY_IS_EQUAL(inf_bits, Bits(0x7f800000u));
+    VERIFY_IS_EQUAL(nan_bits & Bits(0x7fc00000u), Bits(0x7fc00000u));
+  }
+};
+
+EIGEN_DECLARE_TEST(packetmath_fastmath) {
+  CALL_SUBTEST(packetmath_fastmath_runner<float>::run());
+  CALL_SUBTEST(packetmath_fastmath_runner<double>::run());
+  CALL_SUBTEST(packetmath_fastmath_runner<Eigen::half>::run());
+  CALL_SUBTEST(packetmath_fastmath_runner<Eigen::bfloat16>::run());
+  CALL_SUBTEST(extended_scalar_constant_runner<long double>::run());
+
+#if defined(EIGEN_VECTORIZE_AVX512)
+#if !defined(EIGEN_VECTORIZE_AVX512FP16)
+  CALL_SUBTEST((verify_16bit_reductions<Eigen::half, Eigen::internal::Packet16h>()));
+#endif
+  CALL_SUBTEST((verify_16bit_reductions<Eigen::bfloat16, Eigen::internal::Packet16bf>()));
+#endif
+
+#if defined(EIGEN_VECTORIZE_RVV10)
+  CALL_SUBTEST((verify_mask_reduction<float, Eigen::internal::Packet1Xf>()));
+  CALL_SUBTEST((verify_mask_reduction<float, Eigen::internal::Packet2Xf>()));
+  CALL_SUBTEST((verify_mask_reduction<float, Eigen::internal::Packet4Xf>()));
+  CALL_SUBTEST((verify_mask_reduction<double, Eigen::internal::Packet1Xd>()));
+  CALL_SUBTEST((verify_mask_reduction<double, Eigen::internal::Packet2Xd>()));
+  CALL_SUBTEST((verify_mask_reduction<double, Eigen::internal::Packet4Xd>()));
+  CALL_SUBTEST((verify_minmax_reduction<float, Eigen::internal::Packet1Xf>()));
+  CALL_SUBTEST((verify_minmax_reduction<float, Eigen::internal::Packet2Xf>()));
+  CALL_SUBTEST((verify_minmax_reduction<float, Eigen::internal::Packet4Xf>()));
+  CALL_SUBTEST((verify_minmax_reduction<double, Eigen::internal::Packet1Xd>()));
+  CALL_SUBTEST((verify_minmax_reduction<double, Eigen::internal::Packet2Xd>()));
+  CALL_SUBTEST((verify_minmax_reduction<double, Eigen::internal::Packet4Xd>()));
+#endif
+
+#if defined(EIGEN_VECTORIZE_RVV10FP16)
+  CALL_SUBTEST((verify_mask_reduction<Eigen::half, Eigen::internal::Packet1Xh>()));
+  CALL_SUBTEST((verify_mask_reduction<Eigen::half, Eigen::internal::Packet2Xh>()));
+  CALL_SUBTEST((verify_minmax_reduction<Eigen::half, Eigen::internal::Packet1Xh>()));
+  CALL_SUBTEST((verify_minmax_reduction<Eigen::half, Eigen::internal::Packet2Xh>()));
+#endif
+
+#if defined(EIGEN_VECTORIZE_RVV10BF16)
+  CALL_SUBTEST((verify_mask_reduction<Eigen::bfloat16, Eigen::internal::Packet1Xbf>()));
+  CALL_SUBTEST((verify_mask_reduction<Eigen::bfloat16, Eigen::internal::Packet2Xbf>()));
+#endif
+
+#if defined(EIGEN_VECTORIZE_NEON)
+  CALL_SUBTEST((verify_mask_reduction<float, Eigen::internal::Packet2f>()));
+  CALL_SUBTEST((verify_low_bit_mask_any_ftz<float, Eigen::internal::Packet2f>()));
+  CALL_SUBTEST((verify_low_bit_mask_any_ftz<Eigen::bfloat16, Eigen::internal::Packet4bf>()));
+#if EIGEN_ARCH_ARM64
+  CALL_SUBTEST((verify_low_bit_mask_any_ftz<double, Eigen::internal::Packet2d>()));
+#endif
+#endif
+
+#if defined(EIGEN_VECTORIZE_AVX512FP16)
+  CALL_SUBTEST((verify_mask_reduction<Eigen::half, Eigen::internal::Packet16h>()));
+  CALL_SUBTEST((verify_mask_reduction<Eigen::half, Eigen::internal::Packet8h>()));
+  VERIFY((ptrue_mask_any<Eigen::half, Eigen::internal::Packet16h>()));
+  VERIFY((ptrue_mask_any<Eigen::half, Eigen::internal::Packet8h>()));
+  CALL_SUBTEST((verify_low_bit_mask_any_ftz<Eigen::half, Eigen::internal::Packet32h>()));
+  CALL_SUBTEST((verify_low_bit_mask_any_ftz<Eigen::half, Eigen::internal::Packet16h>()));
+  CALL_SUBTEST((verify_low_bit_mask_any_ftz<Eigen::half, Eigen::internal::Packet8h>()));
+#endif
+}
diff --git a/test/packetmath_fastmath_generic_16.cpp b/test/packetmath_fastmath_generic_16.cpp
new file mode 100644
index 0000000..2cd2287
--- /dev/null
+++ b/test/packetmath_fastmath_generic_16.cpp
@@ -0,0 +1,7 @@
+// Force the generic clang vector backend with 16-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_VECTORIZE_GENERIC 1
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 16
+#include "packetmath_fastmath.cpp"
diff --git a/test/packetmath_fastmath_generic_32.cpp b/test/packetmath_fastmath_generic_32.cpp
new file mode 100644
index 0000000..852f184
--- /dev/null
+++ b/test/packetmath_fastmath_generic_32.cpp
@@ -0,0 +1,7 @@
+// Force the generic clang vector backend with 32-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_VECTORIZE_GENERIC 1
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 32
+#include "packetmath_fastmath.cpp"
diff --git a/test/packetmath_fastmath_generic_64.cpp b/test/packetmath_fastmath_generic_64.cpp
new file mode 100644
index 0000000..dd53b8d
--- /dev/null
+++ b/test/packetmath_fastmath_generic_64.cpp
@@ -0,0 +1,7 @@
+// Force the generic clang vector backend with 64-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_VECTORIZE_GENERIC 1
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 64
+#include "packetmath_fastmath.cpp"
diff --git a/test/packetmath_gather.cpp b/test/packetmath_gather.cpp
new file mode 100644
index 0000000..f88e6c4
--- /dev/null
+++ b/test/packetmath_gather.cpp
@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "packetmath_test_shared.h"
+#include <memory>
+
+namespace Eigen {
+namespace test {
+
+template <typename Scalar, typename Packet>
+struct runall<Scalar, Packet, false, false> {
+  static void run() {
+    constexpr int PacketSize = internal::unpacket_traits<Packet>::size;
+    auto samples = special_values<Scalar>();
+    using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+    const Bits nan_payload = numext::bit_cast<Bits>(NumTraits<Scalar>::quiet_NaN()) | Bits(0x123);
+    samples.push_back(numext::bit_cast<Scalar>(nan_payload));
+    Scalar actual[PacketSize], expected[PacketSize];
+    for (Index stride : {Index(-7), Index(-2), Index(-1), Index(0), Index(1), Index(2), Index(3), Index(7)}) {
+      const Index span = (PacketSize - 1) * numext::abs(stride) + 1;
+      for (Index offset = 0; offset < PacketSize; ++offset) {
+        // Exact-size new[] lets sanitizers detect reads past the last gathered coefficient.
+        std::unique_ptr<Scalar[]> storage(new Scalar[span + offset]);
+        Scalar* data = storage.get() + offset;
+        const Scalar* from = stride < 0 ? data + span - 1 : data;
+        for (Index rotation = 0; rotation < Index(samples.size()); ++rotation) {
+          for (Index i = 0; i < span; ++i) data[i] = samples[(i + rotation) % samples.size()];
+          for (Index i = 0; i < PacketSize; ++i) expected[i] = from[i * stride];
+          volatile Index runtime_stride = stride;
+          internal::pstoreu(actual, internal::pgather<Scalar, Packet>(from, runtime_stride));
+          VERIFY(areEqualBits(expected, actual, PacketSize, false));
+          if (stride == 2) {
+            internal::pstoreu(actual, internal::pgather<Scalar, Packet>(from, 2));
+            VERIFY(areEqualBits(expected, actual, PacketSize, false));
+          }
+        }
+      }
+    }
+  }
+};
+
+}  // namespace test
+}  // namespace Eigen
+
+EIGEN_DECLARE_TEST(packetmath_gather) {
+  CALL_SUBTEST_1(test::runner<float>::run());
+  CALL_SUBTEST_2(test::runner<double>::run());
+}
diff --git a/test/packetmath_generic_16.cpp b/test/packetmath_generic_16.cpp
index 612a75c..1bf1d83 100644
--- a/test/packetmath_generic_16.cpp
+++ b/test/packetmath_generic_16.cpp
@@ -1,4 +1,6 @@
 // Force the generic clang vector backend with 16-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 #define EIGEN_VECTORIZE_GENERIC 1
 #define EIGEN_GENERIC_VECTOR_SIZE_BYTES 16
 #include "packetmath.cpp"
diff --git a/test/packetmath_generic_32.cpp b/test/packetmath_generic_32.cpp
index 9816f9f..e2fb485 100644
--- a/test/packetmath_generic_32.cpp
+++ b/test/packetmath_generic_32.cpp
@@ -1,4 +1,6 @@
 // Force the generic clang vector backend with 32-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 #define EIGEN_VECTORIZE_GENERIC 1
 #define EIGEN_GENERIC_VECTOR_SIZE_BYTES 32
 #include "packetmath.cpp"
diff --git a/test/packetmath_generic_64.cpp b/test/packetmath_generic_64.cpp
index 6957544..a881659 100644
--- a/test/packetmath_generic_64.cpp
+++ b/test/packetmath_generic_64.cpp
@@ -1,4 +1,6 @@
 // Force the generic clang vector backend with 64-byte vectors.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 #define EIGEN_VECTORIZE_GENERIC 1
 #define EIGEN_GENERIC_VECTOR_SIZE_BYTES 64
 #include "packetmath.cpp"
diff --git a/test/packetmath_gpu.cu b/test/packetmath_gpu.cu
new file mode 100644
index 0000000..58baf42
--- /dev/null
+++ b/test/packetmath_gpu.cu
@@ -0,0 +1,1331 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Device-side packet math: test/packetmath.cpp never runs on a GPU. Thread i applies one operation to packet i
+// (gpu_common.h's run_on_gpu); the host compares against a reference using bit-exact results, full-bit masks, or a
+// named ULP budget. Parts: 1/3 float4/double2 core, 2/4 float4/double2 math, 5/6 half core/math, 7 scalar fallbacks
+// and preinterpret.
+
+#define EIGEN_TEST_NO_LONGDOUBLE
+#define EIGEN_TEST_NO_COMPLEX
+#define EIGEN_USE_GPU
+
+// packetmath_test_shared.h brings in main.h, which has no include guard.
+#include "packetmath_test_shared.h"
+#include "gpu_common.h"
+#include "packetmath_data_movement.h"
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <vector>
+
+// Packet4h2 is an alias of ulonglong2, which exists in both passes but has unpacket_traits only in the device pass:
+// eight halves in four half2 lanes.
+namespace Eigen {
+namespace test {
+template <>
+struct packet_layout<ulonglong2> {
+  using Scalar = half;
+  static constexpr int kSize = 8;
+};
+}  // namespace test
+}  // namespace Eigen
+
+namespace {
+
+using Eigen::Index;
+using Eigen::internal::packet_traits;
+namespace test = Eigen::test;
+using Eigen::numext::bit_cast;
+using test::special_values;
+
+using test::Buffer;
+using test::packet_layout;
+
+// Named budgets. rsqrt is the one approximate intrinsic among the core operations: the CUDA Math API documents
+// 2 ulp for rsqrtf and 1 ulp for rsqrt. The float reference rounds 1/sqrt from double. The double reference uses
+// long double, which is double itself under MSVC; rounding y = sqrt(x) and then 1/y is still within 1.5 ulp of
+// 1/sqrt(x), so a device result within 1 ulp is at most 2 representable steps from the reference.
+const uint64_t kRsqrtFloatUlps = 3;
+const uint64_t kRsqrtDoubleUlps = 2;
+// The CUDA Math API's documented maximum error for each function, plus one for the rounding of the reference from
+// the wider type. The Windows CRT expm1 reference can be 3 ulps off, and its long double has no extra precision.
+struct MathUlpBudget {
+  uint64_t log, log1p, exp, exp2, expm1;
+};
+const MathUlpBudget kFloatUlps = {2, 2, 3, 3, 2};
+const MathUlpBudget kDoubleUlps = {2, 2, 2, 2, EIGEN_COMP_MSVC ? 3 : 2};
+
+// The reference uses the next floating-point type; long double is not wider on MSVC.
+template <typename Scalar>
+struct wider_type {
+  using type = double;
+};
+template <>
+struct wider_type<double> {
+  using type = long double;
+};
+
+// nvcc compiles sqrtf to a correctly rounded sqrt (-prec-sqrt=true is its default); clang as the CUDA compiler
+// lowers it to an approximation one ulp off, and only the __fsqrt_rn intrinsic is exact there. Double sqrt is
+// correctly rounded under both.
+#if EIGEN_COMP_NVCC
+const uint64_t kSqrtFloatUlps = 0;
+#else
+const uint64_t kSqrtFloatUlps = 1;
+#endif
+
+// ------------------------------------------------------------------------------------------------------------------
+// Operations: a static run() per packet type, with device-only bodies (EIGEN_PACKET_TEST_FUNC).
+
+#define EIGEN_GPU_TEST_UNARY_OP(NAME, EXPR)           \
+  struct NAME {                                       \
+    static const char* name() { return #NAME; }       \
+    template <typename P>                             \
+    EIGEN_PACKET_TEST_FUNC static P run(const P& a) { \
+      return EXPR;                                    \
+    }                                                 \
+  };
+#define EIGEN_GPU_TEST_BINARY_OP(NAME, EXPR)                      \
+  struct NAME {                                                   \
+    static const char* name() { return #NAME; }                   \
+    template <typename P>                                         \
+    EIGEN_PACKET_TEST_FUNC static P run(const P& a, const P& b) { \
+      return EXPR;                                                \
+    }                                                             \
+  };
+#define EIGEN_GPU_TEST_TERNARY_OP(NAME, EXPR)                                 \
+  struct NAME {                                                               \
+    static const char* name() { return #NAME; }                               \
+    template <typename P>                                                     \
+    EIGEN_PACKET_TEST_FUNC static P run(const P& a, const P& b, const P& c) { \
+      return EXPR;                                                            \
+    }                                                                         \
+  };
+#define EIGEN_GPU_TEST_REDUX_OP(NAME, EXPR)                                           \
+  struct NAME {                                                                       \
+    static const char* name() { return #NAME; }                                       \
+    template <typename P>                                                             \
+    EIGEN_PACKET_TEST_FUNC static typename packet_layout<P>::Scalar run(const P& a) { \
+      return EXPR;                                                                    \
+    }                                                                                 \
+  };
+
+EIGEN_GPU_TEST_UNARY_OP(op_identity, a)
+EIGEN_GPU_TEST_UNARY_OP(op_pnegate, Eigen::internal::pnegate(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pconj, Eigen::internal::pconj(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pabs, Eigen::internal::pabs(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pfloor, Eigen::internal::pfloor(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pceil, Eigen::internal::pceil(a))
+EIGEN_GPU_TEST_UNARY_OP(op_print, Eigen::internal::print(a))
+EIGEN_GPU_TEST_UNARY_OP(op_ptrunc, Eigen::internal::ptrunc(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pround, Eigen::internal::pround(a))
+EIGEN_GPU_TEST_UNARY_OP(op_psqrt, Eigen::internal::psqrt(a))
+EIGEN_GPU_TEST_UNARY_OP(op_prsqrt, Eigen::internal::prsqrt(a))
+EIGEN_GPU_TEST_UNARY_OP(op_plog, Eigen::internal::plog(a))
+EIGEN_GPU_TEST_UNARY_OP(op_plog1p, Eigen::internal::plog1p(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pexp, Eigen::internal::pexp(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pexp2, Eigen::internal::pexp2(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pexpm1, Eigen::internal::pexpm1(a))
+EIGEN_GPU_TEST_UNARY_OP(op_ptrue, Eigen::internal::ptrue(a))
+EIGEN_GPU_TEST_UNARY_OP(op_pzero, Eigen::internal::pzero(a))
+EIGEN_GPU_TEST_UNARY_OP(op_preinterpret_self, Eigen::internal::preinterpret<P>(a))
+EIGEN_GPU_TEST_UNARY_OP(op_psign, Eigen::internal::psign(a))
+
+EIGEN_GPU_TEST_BINARY_OP(op_padd, Eigen::internal::padd(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_psub, Eigen::internal::psub(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmul, Eigen::internal::pmul(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pdiv, Eigen::internal::pdiv(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmin, Eigen::internal::pmin(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmax, Eigen::internal::pmax(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmin_numbers, Eigen::internal::pmin<Eigen::PropagateNumbers>(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmax_numbers, Eigen::internal::pmax<Eigen::PropagateNumbers>(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmin_nan, Eigen::internal::pmin<Eigen::PropagateNaN>(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pmax_nan, Eigen::internal::pmax<Eigen::PropagateNaN>(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pand, Eigen::internal::pand(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_por, Eigen::internal::por(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pxor, Eigen::internal::pxor(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pandnot, Eigen::internal::pandnot(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pcmp_eq, Eigen::internal::pcmp_eq(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pcmp_lt, Eigen::internal::pcmp_lt(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pcmp_le, Eigen::internal::pcmp_le(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pcmp_lt_or_nan, Eigen::internal::pcmp_lt_or_nan(a, b))
+EIGEN_GPU_TEST_BINARY_OP(op_pabsdiff, Eigen::internal::pabsdiff(a, b))
+
+EIGEN_GPU_TEST_TERNARY_OP(op_pmadd, Eigen::internal::pmadd(a, b, c))
+EIGEN_GPU_TEST_TERNARY_OP(op_pselect, Eigen::internal::pselect(a, b, c))
+
+EIGEN_GPU_TEST_REDUX_OP(op_pfirst, Eigen::internal::pfirst(a))
+EIGEN_GPU_TEST_REDUX_OP(op_predux, Eigen::internal::predux(a))
+EIGEN_GPU_TEST_REDUX_OP(op_predux_mul, Eigen::internal::predux_mul(a))
+EIGEN_GPU_TEST_REDUX_OP(op_predux_min, Eigen::internal::predux_min(a))
+EIGEN_GPU_TEST_REDUX_OP(op_predux_max, Eigen::internal::predux_max(a))
+
+// ------------------------------------------------------------------------------------------------------------------
+// Kernels: thread i owns packet i. pload<float4> and pload<double2> dereference their argument as the packet, whose
+// alignment is Aligned16. Every aligned load and store here addresses a whole number of 16-byte packets past a
+// gpuMalloc base, which cudaMalloc documents as "suitably aligned for any kind of variable" (hipMalloc documents no
+// alignment).
+
+template <typename Packet, typename Op>
+struct unary_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    Eigen::internal::pstore(out + i * kSize, Op::run(Eigen::internal::pload<Packet>(in + i * kSize)));
+#endif
+  }
+};
+
+// The operands of packet i are stored back to back: a at 2i, b at 2i + 1 (and c at 3i + 2 for three operands).
+template <typename Packet, typename Op>
+struct binary_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    const Packet a = Eigen::internal::pload<Packet>(in + (2 * i) * kSize);
+    const Packet b = Eigen::internal::pload<Packet>(in + (2 * i + 1) * kSize);
+    Eigen::internal::pstore(out + i * kSize, Op::run(a, b));
+#endif
+  }
+};
+
+template <typename Packet, typename Op>
+struct ternary_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    const Packet a = Eigen::internal::pload<Packet>(in + (3 * i) * kSize);
+    const Packet b = Eigen::internal::pload<Packet>(in + (3 * i + 1) * kSize);
+    const Packet c = Eigen::internal::pload<Packet>(in + (3 * i + 2) * kSize);
+    Eigen::internal::pstore(out + i * kSize, Op::run(a, b, c));
+#endif
+  }
+};
+
+template <typename Packet, typename Op>
+struct redux_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    out[i] = Op::run(Eigen::internal::pload<Packet>(in + i * kSize));
+#endif
+  }
+};
+
+template <typename Packet>
+struct plset_kernel {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  static constexpr int kSize = packet_layout<Packet>::kSize;
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Scalar* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    Eigen::internal::pstore(out + i * kSize, Eigen::internal::plset<Packet>(in[i]));
+#endif
+  }
+};
+
+// preinterpret between a scalar and its same-size integer, as the evaluator's cast path uses it on the device.
+template <typename Scalar, typename Bits>
+struct preinterpret_scalar_kernel {
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Scalar* in, Bits* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    out[i] = Eigen::internal::preinterpret<Bits>(in[i]);
+#endif
+  }
+};
+
+// Casts. The evaluator hands the narrowing form two source packets and the widening form one, from which it
+// takes the leading DstPacketSize lanes; these kernels use exactly those two forms.
+struct half_to_float_kernel {
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const Eigen::half* in, float* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    const ulonglong2 a = Eigen::internal::pload<ulonglong2>(in + 8 * i);
+    Eigen::internal::pstore(out + 4 * i, Eigen::internal::pcast<ulonglong2, float4>(a));
+#else
+    EIGEN_UNUSED_VARIABLE(i);
+    EIGEN_UNUSED_VARIABLE(in);
+    EIGEN_UNUSED_VARIABLE(out);
+#endif
+  }
+};
+
+struct float_to_half_kernel {
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const float* in, Eigen::half* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    const float4 a = Eigen::internal::pload<float4>(in + 8 * i);
+    const float4 b = Eigen::internal::pload<float4>(in + 8 * i + 4);
+    Eigen::internal::pstore(out + 8 * i, Eigen::internal::pcast<float4, ulonglong2>(a, b));
+#else
+    EIGEN_UNUSED_VARIABLE(i);
+    EIGEN_UNUSED_VARIABLE(in);
+    EIGEN_UNUSED_VARIABLE(out);
+#endif
+  }
+};
+
+// The device pass's packet traits, written into an int array: the flags the host selects operations by are the
+// device's, not the host pass's, where the half packets and their traits do not exist.
+#define EIGEN_GPU_TEST_TRAIT_FLAGS(X) \
+  X(Vectorizable)                     \
+  X(size)                             \
+  X(HasAdd)                           \
+  X(HasSub)                           \
+  X(HasMul)                           \
+  X(HasDiv)                           \
+  X(HasNegate)                        \
+  X(HasAbs)                           \
+  X(HasMin)                           \
+  X(HasMax)                           \
+  X(HasCmp)                           \
+  X(HasRound)                         \
+  X(HasSqrt)                          \
+  X(HasRsqrt)                         \
+  X(HasSign) X(HasAbsDiff) X(HasSetLinear) X(HasConj) X(HasReciprocal) X(HasExp) X(HasExpm1) X(HasLog) X(HasLog1p)
+#define EIGEN_GPU_TEST_TRAIT_NAME(FLAG) #FLAG,
+#define EIGEN_GPU_TEST_TRAIT_ENUM(FLAG) k##FLAG,
+#define EIGEN_GPU_TEST_TRAIT_VALUE(FLAG) out[k++] = static_cast<int>(packet_traits<Scalar>::FLAG);
+const char* const kTraitNames[] = {EIGEN_GPU_TEST_TRAIT_FLAGS(EIGEN_GPU_TEST_TRAIT_NAME)};
+enum Trait { EIGEN_GPU_TEST_TRAIT_FLAGS(EIGEN_GPU_TEST_TRAIT_ENUM) kNumTraits };
+
+template <typename Scalar>
+struct traits_kernel {
+  EIGEN_PACKET_TEST_FUNC void operator()(int i, const int*, int* out) const {
+#if defined(EIGEN_GPU_COMPILE_PHASE)
+    if (i != 0) return;
+    int k = 0;
+    EIGEN_GPU_TEST_TRAIT_FLAGS(EIGEN_GPU_TEST_TRAIT_VALUE)
+#endif
+  }
+};
+
+template <typename Scalar>
+std::vector<int> device_traits() {
+  Buffer<int> dummy(1), report(kNumTraits);
+  dummy.setZero();  // the kernel ignores it, but it is still copied to the device
+  report.setConstant(-1);
+  run_on_gpu(traits_kernel<Scalar>(), 1, dummy, report);
+  return std::vector<int>(report.data(), report.data() + kNumTraits);
+}
+
+// Every flag the device advertises must be covered by a part of this test or deferred to a reserved part by name.
+void check_advertised_ops_are_covered(const std::vector<int>& traits, const std::vector<Trait>& covered_here) {
+  const std::vector<Trait> deferred = {kHasExp, kHasExpm1, kHasLog, kHasLog1p};
+  for (int k = kHasAdd; k < kNumTraits; ++k) {
+    const Trait flag = static_cast<Trait>(k);
+    if (traits[k] == 0) continue;
+    const auto covered = [flag](const std::vector<Trait>& list) {
+      return std::find(list.begin(), list.end(), flag) != list.end();
+    };
+    const bool ok = covered(covered_here) || covered(deferred);
+    if (!ok) std::cout << "advertised device op without a test: " << kTraitNames[k] << std::endl;
+    VERIFY(ok);
+  }
+}
+
+// ------------------------------------------------------------------------------------------------------------------
+// Inputs.
+
+// Every exponent step of the type, at a few mantissas, both signs.
+template <typename Scalar>
+std::vector<Scalar> exponent_grid(int exponent_step) {
+  using L = std::numeric_limits<Scalar>;
+  std::vector<Scalar> values;
+  const Scalar mantissas[] = {Scalar(1), Scalar(1.25), Scalar(1.5), Scalar(1.75), Scalar(2) - L::epsilon()};
+  for (int e = L::min_exponent - L::digits + 1; e <= L::max_exponent - 1; e += exponent_step) {
+    for (Scalar m : mantissas) {
+      const Scalar v = std::ldexp(m, e);
+      if ((std::isfinite)(v) && v != Scalar(0)) {
+        values.push_back(v);
+        values.push_back(-v);
+      }
+    }
+  }
+  return values;
+}
+
+template <typename Scalar>
+std::vector<Scalar> random_values(int count) {
+  std::vector<Scalar> values(count);
+  for (Scalar& v : values) {
+    v = Eigen::internal::random<Scalar>(Scalar(-1), Scalar(1)) *
+        std::ldexp(Scalar(1), Eigen::internal::random<int>(-30, 30));
+  }
+  return values;
+}
+
+// The special values at every lane position (a run of ones shifts them), then the grid and the random values,
+// padded to whole packets with ones.
+template <typename Scalar>
+Buffer<Scalar> unary_inputs(int packet_size, int random_count) {
+  std::vector<Scalar> values;
+  const std::vector<Scalar> specials = special_values<Scalar>();
+  for (int shift = 0; shift < packet_size; ++shift) {
+    values.insert(values.end(), shift, Scalar(1));
+    values.insert(values.end(), specials.begin(), specials.end());
+  }
+  const std::vector<Scalar> grid = exponent_grid<Scalar>(std::is_same<Scalar, double>::value ? 8 : 2);
+  values.insert(values.end(), grid.begin(), grid.end());
+  const std::vector<Scalar> random = random_values<Scalar>(random_count);
+  values.insert(values.end(), random.begin(), random.end());
+  while (values.size() % packet_size != 0) values.push_back(Scalar(1));
+  return Eigen::Map<const Buffer<Scalar>>(values.data(), values.size());
+}
+
+template <typename Scalar>
+struct binary_inputs {
+  std::vector<Scalar> a, b;
+  binary_inputs() = default;
+  // The cross product of the special values, then random pairs, then a shifted copy of the specials so that a
+  // pair reaches every lane. `exclude` drops pairs the operation leaves implementation-defined.
+  template <typename Exclude>
+  binary_inputs(int packet_size, int random_count, Exclude exclude) {
+    const std::vector<Scalar> specials = special_values<Scalar>();
+    for (int shift = 0; shift < packet_size; ++shift) {
+      for (int k = 0; k < shift; ++k) push(Scalar(1), Scalar(1));
+      for (Scalar x : specials) {
+        for (Scalar y : specials) {
+          if (!exclude(x, y)) push(x, y);
+        }
+      }
+    }
+    const std::vector<Scalar> ra = random_values<Scalar>(random_count);
+    const std::vector<Scalar> rb = random_values<Scalar>(random_count);
+    for (int k = 0; k < random_count; ++k) {
+      if (!exclude(ra[k], rb[k])) push(ra[k], rb[k]);
+    }
+    while (a.size() % packet_size != 0) push(Scalar(1), Scalar(1));
+  }
+  void push(Scalar x, Scalar y) {
+    a.push_back(x);
+    b.push_back(y);
+  }
+  int size() const { return int(a.size()); }
+  // Packet-interleaved device layout: a-packet, b-packet, a-packet, ...
+  Buffer<Scalar> interleaved(int packet_size) const {
+    Buffer<Scalar> in(2 * size());
+    for (int p = 0; p < size() / packet_size; ++p) {
+      for (int l = 0; l < packet_size; ++l) {
+        in[(2 * p) * packet_size + l] = a[p * packet_size + l];
+        in[(2 * p + 1) * packet_size + l] = b[p * packet_size + l];
+      }
+    }
+    return in;
+  }
+};
+
+// Every value a half can hold, in bit-pattern order. 65536 lanes is 8192 packets, which the device sweeps in
+// microseconds, so the unary operations are tested exhaustively rather than sampled.
+std::vector<Eigen::half> all_half_values() {
+  std::vector<Eigen::half> values;
+  values.reserve(1 << 16);
+  for (int bits = 0; bits < (1 << 16); ++bits) {
+    values.push_back(Eigen::numext::bit_cast<Eigen::half>(static_cast<Eigen::numext::uint16_t>(bits)));
+  }
+  return values;
+}
+
+// Pairs covering the whole domain in both operands: every value against a value a stride away, plus the cross
+// product of the special values. 40503 is coprime with 65536, so the second operand also runs over everything.
+binary_inputs<Eigen::half> all_half_pairs(bool exclude_nan) {
+  const std::vector<Eigen::half> values = all_half_values();
+  binary_inputs<Eigen::half> pairs;
+  for (std::size_t i = 0; i < values.size(); ++i) {
+    const Eigen::half a = values[i], b = values[(i * 40503) % values.size()];
+    if (exclude_nan && ((Eigen::numext::isnan)(a) || (Eigen::numext::isnan)(b))) continue;
+    pairs.push(a, b);
+  }
+  const std::vector<float> specials = special_values<float>();
+  for (float x : specials) {
+    for (float y : specials) {
+      const Eigen::half a(x), b(y);
+      if (exclude_nan && ((Eigen::numext::isnan)(a) || (Eigen::numext::isnan)(b))) continue;
+      pairs.push(a, b);
+    }
+  }
+  while (pairs.size() % 8 != 0) pairs.push(Eigen::half(1), Eigen::half(1));
+  return pairs;
+}
+
+template <typename Scalar>
+bool never(Scalar, Scalar) {
+  return false;
+}
+template <typename Scalar>
+bool either_nan(Scalar x, Scalar y) {
+  return (std::isnan)(x) || (std::isnan)(y);
+}
+
+// ------------------------------------------------------------------------------------------------------------------
+// Comparators.
+
+template <typename Scalar>
+struct compare_bits {
+  bool nan_is_nan;
+  bool operator()(const Scalar* ref, const Scalar* vec, int n) const {
+    return test::areEqualBits(ref, vec, n, nan_is_nan);
+  }
+};
+template <typename Scalar>
+struct compare_ulps {
+  uint64_t ulps;
+  bool operator()(const Scalar* ref, const Scalar* vec, int n) const { return test::areWithinUlps(ref, vec, n, ulps); }
+};
+
+// ------------------------------------------------------------------------------------------------------------------
+// Drivers.
+
+// VERIFY with the operation's name in the failure report.
+#define VERIFY_OP(COND)                                                      \
+  do {                                                                       \
+    const bool ok_ = (COND);                                                 \
+    if (!ok_) std::cout << "failing operation: " << Op::name() << std::endl; \
+    VERIFY(ok_);                                                             \
+  } while (0)
+
+template <typename Packet, typename Op, typename Ref, typename Compare>
+void check_unary(const Buffer<typename packet_layout<Packet>::Scalar>& in, Ref ref, Compare compare) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  Buffer<Scalar> out(in.size());
+  out.setConstant(Scalar(-7));
+  run_on_gpu(unary_kernel<Packet, Op>(), int(in.size()) / kSize, in, out);
+  Buffer<Scalar> expected(in.size());
+  for (Index k = 0; k < in.size(); ++k) expected[k] = ref(in[k]);
+  VERIFY_OP(compare(expected.data(), out.data(), int(in.size())));
+}
+
+template <typename Packet, typename Op, typename Ref, typename Compare>
+void check_binary(const binary_inputs<typename packet_layout<Packet>::Scalar>& inputs, Ref ref, Compare compare) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  const Buffer<Scalar> in = inputs.interleaved(kSize);
+  Buffer<Scalar> out(inputs.size());
+  out.setConstant(Scalar(-7));
+  run_on_gpu(binary_kernel<Packet, Op>(), inputs.size() / kSize, in, out);
+  Buffer<Scalar> expected(inputs.size());
+  for (int k = 0; k < inputs.size(); ++k) expected[k] = ref(inputs.a[k], inputs.b[k]);
+  VERIFY_OP(compare(expected.data(), out.data(), inputs.size()));
+}
+
+// A comparison must return an all-ones lane where the predicate holds and an all-zero lane elsewhere.
+template <typename Packet, typename Op, typename Pred>
+void check_compare(const binary_inputs<typename packet_layout<Packet>::Scalar>& inputs, Pred pred) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  const Buffer<Scalar> in = inputs.interleaved(kSize);
+  Buffer<Scalar> out(inputs.size());
+  out.setConstant(Scalar(-7));
+  run_on_gpu(binary_kernel<Packet, Op>(), inputs.size() / kSize, in, out);
+  Buffer<bool> zero_mask(inputs.size());
+  for (int k = 0; k < inputs.size(); ++k) zero_mask[k] = !pred(inputs.a[k], inputs.b[k]);
+  VERIFY_OP(test::areFullBitMasks(out.data(), zero_mask.data(), inputs.size()));
+}
+
+template <typename Packet, typename Op, typename Compare>
+void check_ternary(const std::vector<typename packet_layout<Packet>::Scalar>& a,
+                   const std::vector<typename packet_layout<Packet>::Scalar>& b,
+                   const std::vector<typename packet_layout<Packet>::Scalar>& c,
+                   const Buffer<typename packet_layout<Packet>::Scalar>& expected, Compare compare) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  const int n = int(a.size());
+  Buffer<Scalar> in(3 * n);
+  for (int p = 0; p < n / kSize; ++p) {
+    for (int l = 0; l < kSize; ++l) {
+      in[(3 * p) * kSize + l] = a[p * kSize + l];
+      in[(3 * p + 1) * kSize + l] = b[p * kSize + l];
+      in[(3 * p + 2) * kSize + l] = c[p * kSize + l];
+    }
+  }
+  Buffer<Scalar> out(n);
+  out.setConstant(Scalar(-7));
+  run_on_gpu(ternary_kernel<Packet, Op>(), n / kSize, in, out);
+  VERIFY_OP(compare(expected.data(), out.data(), n));
+}
+
+template <typename Packet, typename Op, typename Ref, typename Compare>
+void check_redux(const Buffer<typename packet_layout<Packet>::Scalar>& in, Ref ref, Compare compare) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  const int n = int(in.size()) / kSize;
+  Buffer<Scalar> out(n);
+  out.setConstant(Scalar(-7));
+  run_on_gpu(redux_kernel<Packet, Op>(), n, in, out);
+  Buffer<Scalar> expected(n);
+  for (int p = 0; p < n; ++p) expected[p] = ref(in.data() + p * kSize);
+  VERIFY_OP(compare(expected.data(), out.data(), n));
+}
+
+// Runs a kernel once per packet on the device, for the shared data-movement cases.
+struct launch_on_gpu {
+  template <typename Kernel, typename Input, typename Output>
+  void operator()(const Kernel& kernel, int count, const Input& input, Output& output) const {
+    run_on_gpu(kernel, count, input, output);
+  }
+};
+
+// plset with every input as a base, large values and negative zero included. `ref` adds a lane index in the type's
+// own arithmetic, since a half sum has to round exactly once; that addition need not keep a NaN payload.
+template <typename Packet, typename Ref>
+void check_plset(const Buffer<typename packet_layout<Packet>::Scalar>& in, Ref ref) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  Buffer<Scalar> out(in.size() * kSize), expected(in.size() * kSize);
+  out.setConstant(Scalar(-7));
+  run_on_gpu(plset_kernel<Packet>(), int(in.size()), in, out);
+  for (Index k = 0; k < out.size(); ++k) {
+    expected[k] = (k % kSize == 0) ? in[k / kSize] : ref(in[k / kSize], int(k % kSize));
+  }
+  VERIFY(test::areEqualBits(expected.data(), out.data(), int(out.size())) && "plset");
+}
+
+// ptrue and pzero: every bit of every lane set, or every bit cleared.
+template <typename Packet, typename Op>
+void check_full_mask(const Buffer<typename packet_layout<Packet>::Scalar>& in, bool expect_zero) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  Buffer<Scalar> out(in.size());
+  out.setConstant(Scalar(-7));
+  run_on_gpu(unary_kernel<Packet, Op>(), int(in.size()) / packet_layout<Packet>::kSize, in, out);
+  const Buffer<bool> zero_mask = Buffer<bool>::Constant(in.size(), expect_zero);
+  VERIFY_OP(test::areFullBitMasks(out.data(), zero_mask.data(), int(in.size())));
+}
+
+// Points where the standard fixes the result exactly, whatever the implementation's accuracy elsewhere. The
+// comparison is bitwise, so the sign of a zero counts; NaN matches NaN whatever the payload.
+template <typename Packet, typename Op>
+void check_special_values(
+    const std::vector<std::pair<typename packet_layout<Packet>::Scalar, typename packet_layout<Packet>::Scalar>>&
+        cases) {
+  using Scalar = typename packet_layout<Packet>::Scalar;
+  const int kSize = packet_layout<Packet>::kSize;
+  std::vector<Scalar> in_values, expected_values;
+  for (const auto& one : cases) {
+    in_values.push_back(one.first);
+    expected_values.push_back(one.second);
+  }
+  // Pad to a whole number of packets by repeating the first case; only the real cases are compared.
+  while (in_values.size() % kSize != 0) {
+    in_values.push_back(cases[0].first);
+    expected_values.push_back(cases[0].second);
+  }
+  const Buffer<Scalar> in = Eigen::Map<const Buffer<Scalar>>(in_values.data(), in_values.size());
+  Buffer<Scalar> out(in.size());
+  out.setConstant(Scalar(-7));
+  run_on_gpu(unary_kernel<Packet, Op>(), int(in.size()) / kSize, in, out);
+  VERIFY_OP(test::areEqualBits(expected_values.data(), out.data(), int(cases.size())));
+}
+
+// ------------------------------------------------------------------------------------------------------------------
+// Parts 2 and 4: the transcendental operations. Accuracy over the ordinary range is a named ULP budget against a
+// host reference; the values the standard fixes are checked exactly.
+
+template <typename Scalar>
+void packetmath_gpu_real_math() {
+  using Packet = typename packet_traits<Scalar>::type;
+  using Wider = typename wider_type<Scalar>::type;
+  const int kSize = packet_layout<Packet>::kSize;
+  const MathUlpBudget& budget = std::is_same<Scalar, double>::value ? kDoubleUlps : kFloatUlps;
+
+  const std::vector<int> traits = device_traits<Scalar>();
+  VERIFY_IS_EQUAL(traits[kHasExp], 1);
+  VERIFY_IS_EQUAL(traits[kHasLog], 1);
+
+  const Scalar zero(0), one(1), inf = std::numeric_limits<Scalar>::infinity();
+  const Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
+  const Scalar lowest = std::numeric_limits<Scalar>::lowest(), largest = (std::numeric_limits<Scalar>::max)();
+
+  // Inputs the logarithms accept: positive, plus the special values, which the budgeted comparison tolerates
+  // because a NaN reference matches a NaN result.
+  Buffer<Scalar> in = unary_inputs<Scalar>(kSize, 1 << 18);
+  // Seed 1549110488 on Windows: the CRT reference was 3 ulps from the correctly rounded GPU result.
+  const double regression_input = -0.56978050887642206;
+  in.conservativeResize(in.size() + kSize);
+  in.tail(kSize).setConstant(Scalar(regression_input));
+  EIGEN_IF_CONSTEXPR (std::is_same<Scalar, double>::value) {
+    // Keep a 1-ulp check against MPFR (256 bits, round-to-nearest), independent of the CRT reference.
+    const Buffer<Scalar> regression = in.tail(kSize);
+    check_unary<Packet, op_pexpm1>(
+        regression, [](Scalar) { return Scalar(-0.43435041986303746); }, compare_ulps<Scalar>{1});
+  }
+  Buffer<Scalar> positive(in.size());
+  for (Index k = 0; k < in.size(); ++k) positive[k] = std::abs(in[k]);
+  // log1p's domain is (-1, +inf), and the interesting half of it is the run just above -1: |x| - 0.5 never
+  // reaches below -0.5, so it would leave the argument reduction there untested. Even lanes therefore hold
+  // -1 + u with u drawn log-uniformly over [2^-digits, 1), which walks (-1, 0) from a single ulp above -1 up to
+  // 0; odd lanes keep |x| - 0.5, which covers (-0.5, +inf) and carries the special values.
+  Buffer<Scalar> above_minus_one(in.size());
+  for (Index k = 0; k < in.size(); ++k) {
+    if (k % 2 == 0) {
+      const int exponent = Eigen::internal::random<int>(1, Eigen::NumTraits<Scalar>::digits());
+      const Scalar significand = Eigen::internal::random<Scalar>(Scalar(1), Scalar(2));
+      above_minus_one[k] = Scalar(-1) + std::ldexp(significand, -exponent);
+    } else {
+      above_minus_one[k] = std::abs(in[k]) - Scalar(0.5);
+    }
+  }
+
+  check_unary<Packet, op_pexp>(
+      in, [](Scalar x) { return static_cast<Scalar>(std::exp(static_cast<Wider>(x))); },
+      compare_ulps<Scalar>{budget.exp});
+  check_unary<Packet, op_pexp2>(
+      in, [](Scalar x) { return static_cast<Scalar>(std::exp2(static_cast<Wider>(x))); },
+      compare_ulps<Scalar>{budget.exp2});
+  check_unary<Packet, op_pexpm1>(
+      in, [](Scalar x) { return static_cast<Scalar>(std::expm1(static_cast<Wider>(x))); },
+      compare_ulps<Scalar>{budget.expm1});
+  check_unary<Packet, op_plog>(
+      positive, [](Scalar x) { return static_cast<Scalar>(std::log(static_cast<Wider>(x))); },
+      compare_ulps<Scalar>{budget.log});
+  check_unary<Packet, op_plog1p>(
+      above_minus_one, [](Scalar x) { return static_cast<Scalar>(std::log1p(static_cast<Wider>(x))); },
+      compare_ulps<Scalar>{budget.log1p});
+
+  check_special_values<Packet, op_pexp>(
+      {{zero, one}, {-zero, one}, {-inf, zero}, {inf, inf}, {nan, nan}, {lowest, zero}, {largest, inf}});
+  check_special_values<Packet, op_pexp2>(
+      {{zero, one}, {-zero, one}, {one, Scalar(2)}, {-inf, zero}, {inf, inf}, {nan, nan}});
+  // expm1 preserves the sign of a zero, and saturates to -1 at minus infinity.
+  check_special_values<Packet, op_pexpm1>(
+      {{zero, zero}, {-zero, -zero}, {-inf, Scalar(-1)}, {inf, inf}, {nan, nan}, {lowest, Scalar(-1)}});
+  check_special_values<Packet, op_plog>(
+      {{one, zero}, {zero, -inf}, {-zero, -inf}, {-one, nan}, {-inf, nan}, {inf, inf}, {nan, nan}});
+  check_special_values<Packet, op_plog1p>(
+      {{zero, zero}, {-zero, -zero}, {Scalar(-1), -inf}, {Scalar(-2), nan}, {-inf, nan}, {inf, inf}, {nan, nan}});
+}
+
+// ------------------------------------------------------------------------------------------------------------------
+// The core of a floating-point packet type: loads and stores, arithmetic, min/max, rounding, bit operations,
+// comparisons, select, reductions, sqrt and rsqrt.
+
+template <typename Scalar>
+Scalar rsqrt_reference(Scalar x) {
+  using Wider = typename wider_type<Scalar>::type;
+  return static_cast<Scalar>(Wider(1) / std::sqrt(static_cast<Wider>(x)));
+}
+
+template <typename Scalar>
+void packetmath_gpu_real_core() {
+  using Packet = typename packet_traits<Scalar>::type;
+  const int kSize = packet_layout<Packet>::kSize;
+  using Bits = typename Eigen::numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  const compare_bits<Scalar> bits{true};
+  const compare_bits<Scalar> bits_and_payload{false};
+  const auto values = test::areEqual<Scalar>;
+  const uint64_t rsqrt_ulps = std::is_same<Scalar, double>::value ? kRsqrtDoubleUlps : kRsqrtFloatUlps;
+
+  // The device's view of the type, and what this part covers of it.
+  const std::vector<int> traits = device_traits<Scalar>();
+  std::cout << "device packet_traits<" << typeid(Scalar).name() << ">:";
+  for (int k = 0; k < kNumTraits; ++k) std::cout << " " << kTraitNames[k] << "=" << traits[k];
+  std::cout << std::endl;
+  VERIFY_IS_EQUAL(traits[kVectorizable], 1);
+  VERIFY_IS_EQUAL(traits[ksize], kSize);
+  VERIFY_IS_EQUAL(traits[kHasCmp], 1);
+  check_advertised_ops_are_covered(
+      traits, {kHasAdd, kHasSub, kHasMul, kHasDiv, kHasNegate, kHasAbs, kHasMin, kHasMax, kHasCmp, kHasRound, kHasSqrt,
+               kHasRsqrt, kHasSign, kHasAbsDiff, kHasSetLinear, kHasConj});
+
+  const Buffer<Scalar> in = unary_inputs<Scalar>(kSize, 1 << 18);
+  const int n = int(in.size()) / kSize;
+
+  // Loads and stores keep every bit, NaN payloads included.
+  check_unary<Packet, op_identity>(
+      in, [](Scalar x) { return x; }, bits_and_payload);
+  test::packetmath_data_movement<Packet>(in, launch_on_gpu());
+  check_plset<Packet>(in, [](Scalar base, int lane) { return Scalar(base + Scalar(lane)); });
+
+  // Sign manipulation and rounding: fixed bit for bit, including the sign of a zero.
+  check_unary<Packet, op_pnegate>(
+      in, [](Scalar x) { return -x; }, bits);
+  check_unary<Packet, op_pconj>(
+      in, [](Scalar x) { return x; }, bits);
+  check_unary<Packet, op_pabs>(
+      in, [](Scalar x) { return std::abs(x); }, bits);
+  check_unary<Packet, op_pfloor>(
+      in, [](Scalar x) { return std::floor(x); }, bits);
+  check_unary<Packet, op_pceil>(
+      in, [](Scalar x) { return std::ceil(x); }, bits);
+  check_unary<Packet, op_print>(
+      in, [](Scalar x) { return std::rint(x); }, bits);
+  check_unary<Packet, op_ptrunc>(
+      in, [](Scalar x) { return std::trunc(x); }, bits);
+  check_unary<Packet, op_pround>(
+      in, [](Scalar x) { return std::round(x); }, bits);
+  check_unary<Packet, op_preinterpret_self>(
+      in, [](Scalar x) { return x; }, bits_and_payload);
+  check_unary<Packet, op_psign>(
+      in, [](Scalar x) { return Eigen::numext::sign(x); }, bits);
+  // No ULP budget admits a lost zero sign or an overflow.
+  const uint64_t kFar = (std::numeric_limits<uint64_t>::max)();
+  VERIFY_IS_EQUAL(test::ulp_distance(Scalar(0), Scalar(-0.0)), kFar);
+  VERIFY_IS_EQUAL(test::ulp_distance(std::numeric_limits<Scalar>::infinity(), (std::numeric_limits<Scalar>::max)()),
+                  kFar);
+  VERIFY_IS_EQUAL(test::ulp_distance(Scalar(0), std::numeric_limits<Scalar>::denorm_min()), uint64_t(1));
+  if (std::is_same<Scalar, float>::value) {
+    check_unary<Packet, op_psqrt>(
+        in, [](Scalar x) { return std::sqrt(x); }, compare_ulps<Scalar>{kSqrtFloatUlps});
+  } else {
+    check_unary<Packet, op_psqrt>(
+        in, [](Scalar x) { return std::sqrt(x); }, bits);
+  }
+  check_unary<Packet, op_prsqrt>(in, rsqrt_reference<Scalar>, compare_ulps<Scalar>{rsqrt_ulps});
+  check_full_mask<Packet, op_ptrue>(in, /*expect_zero=*/false);
+  check_full_mask<Packet, op_pzero>(in, /*expect_zero=*/true);
+
+  // Arithmetic: IEEE operations, so the host's own results are the reference, bit for bit.
+  const binary_inputs<Scalar> pairs(kSize, 1 << 17, never<Scalar>);
+  check_binary<Packet, op_padd>(pairs, test::REF_ADD<Scalar>, bits);
+  check_binary<Packet, op_psub>(pairs, test::REF_SUB<Scalar>, bits);
+  check_binary<Packet, op_pmul>(pairs, test::REF_MUL<Scalar>, bits);
+  check_binary<Packet, op_pdiv>(pairs, test::REF_DIV<Scalar>, bits);
+  // The sign of a zero difference is not part of pabsdiff's contract.
+  check_binary<Packet, op_pabsdiff>(
+      pairs, [](Scalar x, Scalar y) { return x < y ? y - x : x - y; }, values);
+  // Plain pmin/pmax leave NaN operands implementation-defined (the device uses fminf/fmaxf); the propagating
+  // variants fix them.
+  const binary_inputs<Scalar> number_pairs(kSize, 1 << 16, either_nan<Scalar>);
+  check_binary<Packet, op_pmin>(
+      number_pairs, [](Scalar x, Scalar y) { return (std::min)(x, y); }, values);
+  check_binary<Packet, op_pmax>(
+      number_pairs, [](Scalar x, Scalar y) { return (std::max)(x, y); }, values);
+  check_binary<Packet, op_pmin_numbers>(
+      pairs, [](Scalar x, Scalar y) { return std::fmin(x, y); }, values);
+  check_binary<Packet, op_pmax_numbers>(
+      pairs, [](Scalar x, Scalar y) { return std::fmax(x, y); }, values);
+  check_binary<Packet, op_pmin_nan>(
+      pairs,
+      [](Scalar x, Scalar y) {
+        return ((std::isnan)(x) || (std::isnan)(y)) ? std::numeric_limits<Scalar>::quiet_NaN() : (std::min)(x, y);
+      },
+      values);
+  check_binary<Packet, op_pmax_nan>(
+      pairs,
+      [](Scalar x, Scalar y) {
+        return ((std::isnan)(x) || (std::isnan)(y)) ? std::numeric_limits<Scalar>::quiet_NaN() : (std::max)(x, y);
+      },
+      values);
+
+  // Bit operations act on the representation, payloads included.
+  check_binary<Packet, op_pand>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) & bit_cast<Bits>(y))); },
+      bits_and_payload);
+  check_binary<Packet, op_por>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) | bit_cast<Bits>(y))); },
+      bits_and_payload);
+  check_binary<Packet, op_pxor>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) ^ bit_cast<Bits>(y))); },
+      bits_and_payload);
+  check_binary<Packet, op_pandnot>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) & ~bit_cast<Bits>(y))); },
+      bits_and_payload);
+
+  // Comparisons: full-bit masks, false on any NaN operand.
+  check_compare<Packet, op_pcmp_eq>(pairs, [](Scalar x, Scalar y) { return x == y; });
+  check_compare<Packet, op_pcmp_lt>(pairs, [](Scalar x, Scalar y) { return x < y; });
+  check_compare<Packet, op_pcmp_le>(pairs, [](Scalar x, Scalar y) { return x <= y; });
+  check_compare<Packet, op_pcmp_lt_or_nan>(pairs, [](Scalar x, Scalar y) { return !(x >= y); });
+
+  {
+    // pmadd may or may not be contracted by the device compiler (ptxas fuses a*b+c by default): either the
+    // fused or the separately rounded result is acceptable until the backend provides an explicit fma.
+    const int count = 1 << 16;
+    std::vector<Scalar> a = random_values<Scalar>(count), b = random_values<Scalar>(count),
+                        c = random_values<Scalar>(count);
+    const Scalar epsilon = NumTraits<Scalar>::epsilon();
+    const int rounding_case = int(a.size());
+    a.push_back(Scalar(1) + epsilon);
+    b.push_back(Scalar(1) - epsilon);
+    c.push_back(Scalar(-1));
+    const std::vector<Scalar> specials = special_values<Scalar>();
+    for (Scalar x : specials) {
+      for (Scalar y : specials) {
+        a.push_back(x);
+        b.push_back(y);
+        c.push_back(specials[(a.size() * 7) % specials.size()]);
+      }
+    }
+    while (a.size() % kSize != 0) {
+      a.push_back(Scalar(1));
+      b.push_back(Scalar(1));
+      c.push_back(Scalar(1));
+    }
+    const int n3 = int(a.size());
+    Buffer<Scalar> fused(n3), unfused(n3);
+    for (int k = 0; k < n3; ++k) {
+      fused[k] = std::fma(a[k], b[k], c[k]);
+      // A statement boundary alone still permits contraction with -ffp-contract=fast.
+      const volatile Scalar product = a[k] * b[k];
+      unfused[k] = product + c[k];
+    }
+    VERIFY_IS_EQUAL(fused[rounding_case], -epsilon * epsilon);
+    VERIFY_IS_EQUAL(unfused[rounding_case], Scalar(0));
+    const auto fused_or_not = [&](const Scalar* ref, const Scalar* vec, int m) {
+      for (int k = 0; k < m; ++k) {
+        const bool ok = test::ulp_distance(ref[k], vec[k]) == 0 || test::ulp_distance(unfused[k], vec[k]) == 0;
+        if (!ok) {
+          std::cout << "pmadd lane " << k << ": " << vec[k] << " is neither fma " << ref[k] << " nor a*b+c "
+                    << unfused[k] << std::endl;
+          return false;
+        }
+      }
+      return true;
+    };
+    check_ternary<Packet, op_pmadd>(a, b, c, fused, fused_or_not);
+
+    // pselect with full-bit masks picks the second operand where the mask is set, bit for bit.
+    std::vector<Scalar> mask(n3);
+    Buffer<Scalar> selected(n3);
+    const Scalar all_ones = Eigen::numext::bit_cast<Scalar>(Bits(~Bits(0)));
+    for (int k = 0; k < n3; ++k) {
+      mask[k] = Eigen::internal::random<bool>() ? all_ones : Scalar(0);
+      selected[k] = Eigen::numext::bit_cast<Bits>(mask[k]) != Bits(0) ? a[k] : b[k];
+    }
+    check_ternary<Packet, op_pselect>(mask, a, b, selected, bits_and_payload);
+  }
+
+  // Reductions. Sums and products follow the device's lane order, which the host reproduces.
+  check_redux<Packet, op_pfirst>(
+      in, [](const Scalar* p) { return p[0]; }, bits_and_payload);
+  check_redux<Packet, op_predux>(
+      in,
+      [kSize](const Scalar* p) {
+        Scalar s = p[0];
+        for (int l = 1; l < kSize; ++l) s = s + p[l];
+        return s;
+      },
+      bits);
+  check_redux<Packet, op_predux_mul>(
+      in,
+      [kSize](const Scalar* p) {
+        Scalar s = p[0];
+        for (int l = 1; l < kSize; ++l) s = s * p[l];
+        return s;
+      },
+      bits);
+  Buffer<Scalar> numbers(in.size());
+  for (Index k = 0; k < in.size(); ++k) numbers[k] = (std::isnan)(in[k]) ? Scalar(1) : in[k];
+  check_redux<Packet, op_predux_min>(
+      numbers,
+      [kSize](const Scalar* p) {
+        Scalar s = p[0];
+        for (int l = 1; l < kSize; ++l) s = (std::min)(s, p[l]);
+        return s;
+      },
+      values);
+  check_redux<Packet, op_predux_max>(
+      numbers,
+      [kSize](const Scalar* p) {
+        Scalar s = p[0];
+        for (int l = 1; l < kSize; ++l) s = (std::max)(s, p[l]);
+        return s;
+      },
+      values);
+}
+
+// ------------------------------------------------------------------------------------------------------------------
+// Parts 5 and 6: the half packets. Packet4h2 is eight halves in four half2 lanes and exists only in the device
+// pass. References are computed in float and rounded once, which is exact for the arithmetic operations because a
+// float mantissa is at least twice a half's plus two bits.
+
+using HalfPacket = ulonglong2;
+
+// A half operation whose reference is the float computation rounded back.
+Eigen::half half_of(float x) { return Eigen::half(x); }
+Eigen::half half_add(Eigen::half a, Eigen::half b) { return half_of(float(a) + float(b)); }
+Eigen::half half_mul(Eigen::half a, Eigen::half b) { return half_of(float(a) * float(b)); }
+
+void packetmath_gpu_half_core() {
+  using Scalar = Eigen::half;
+  using Packet = HalfPacket;
+  using Bits = uint16_t;
+  const int kSize = packet_layout<Packet>::kSize;
+  const compare_bits<Scalar> bits{true};
+  const compare_bits<Scalar> bits_and_payload{false};
+  const auto values = test::areEqual<Scalar>;
+
+  const std::vector<int> traits = device_traits<Scalar>();
+  std::cout << "device packet_traits<half>:";
+  for (int k = 0; k < kNumTraits; ++k) std::cout << " " << kTraitNames[k] << "=" << traits[k];
+  std::cout << std::endl;
+  VERIFY_IS_EQUAL(traits[kVectorizable], 1);
+  VERIFY_IS_EQUAL(traits[ksize], kSize);
+  // The hygiene sweep turned these off: there is no rounding operation and no psign for the half packets.
+  VERIFY_IS_EQUAL(traits[kHasRound], 0);
+  VERIFY_IS_EQUAL(traits[kHasSign], 0);
+  check_advertised_ops_are_covered(traits, {kHasAdd, kHasSub, kHasMul, kHasDiv, kHasNegate, kHasAbs, kHasMin, kHasMax,
+                                            kHasSqrt, kHasRsqrt, kHasSetLinear, kHasConj, kHasAbsDiff});
+
+  // Exhaustive: every value a half can hold.
+  const std::vector<Scalar> all = all_half_values();
+  const Buffer<Scalar> in = Eigen::Map<const Buffer<Scalar>>(all.data(), all.size());
+  const int n = int(in.size()) / kSize;
+
+  check_unary<Packet, op_identity>(
+      in, [](Scalar x) { return x; }, bits_and_payload);
+  // The sign of a NaN survives neither __hneg2 nor __habs2, as on the float packets; the value stays NaN.
+  check_unary<Packet, op_pnegate>(
+      in, [](Scalar x) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) ^ 0x8000u)); }, bits);
+  check_unary<Packet, op_pabs>(
+      in, [](Scalar x) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) & 0x7fffu)); }, bits);
+  check_unary<Packet, op_pconj>(
+      in, [](Scalar x) { return x; }, bits_and_payload);
+
+  // The half2 intrinsics quiet a signalling NaN, so data movement matches NaNs by value. The lane index is added in
+  // half, so the plset reference rounds once, as the packet does.
+  test::packetmath_data_movement<Packet>(in, launch_on_gpu(), /*nan_payloads=*/false);
+  check_plset<Packet>(in, [](Scalar base, int lane) { return half_add(base, half_of(float(lane))); });
+
+  // Arithmetic. Rounding once from float is the correctly rounded half result.
+  const binary_inputs<Scalar> pairs = all_half_pairs(/*exclude_nan=*/false);
+  const binary_inputs<Scalar> numbers = all_half_pairs(/*exclude_nan=*/true);
+  check_binary<Packet, op_padd>(pairs, half_add, bits);
+  check_binary<Packet, op_psub>(
+      pairs, [](Scalar x, Scalar y) { return half_of(float(x) - float(y)); }, bits);
+  check_binary<Packet, op_pmul>(pairs, half_mul, bits);
+  check_binary<Packet, op_pdiv>(
+      pairs, [](Scalar x, Scalar y) { return half_of(float(x) / float(y)); }, bits);
+  // Plain min/max leave a NaN operand implementation-defined, as for the float packets.
+  check_binary<Packet, op_pmin>(
+      numbers, [](Scalar x, Scalar y) { return float(x) < float(y) ? x : y; }, values);
+  check_binary<Packet, op_pmax>(
+      numbers, [](Scalar x, Scalar y) { return float(x) > float(y) ? x : y; }, values);
+
+  // Bit operations act on the 16-bit representation.
+  check_binary<Packet, op_pand>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) & bit_cast<Bits>(y))); },
+      bits_and_payload);
+  check_binary<Packet, op_por>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) | bit_cast<Bits>(y))); },
+      bits_and_payload);
+  check_binary<Packet, op_pxor>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) ^ bit_cast<Bits>(y))); },
+      bits_and_payload);
+  check_binary<Packet, op_pandnot>(
+      pairs, [](Scalar x, Scalar y) { return bit_cast<Scalar>(Bits(bit_cast<Bits>(x) & ~bit_cast<Bits>(y))); },
+      bits_and_payload);
+
+  // Comparisons produce all-ones or all-zero 16-bit lanes.
+  check_compare<Packet, op_pcmp_eq>(pairs, [](Scalar x, Scalar y) { return float(x) == float(y); });
+  check_compare<Packet, op_pcmp_lt>(pairs, [](Scalar x, Scalar y) { return float(x) < float(y); });
+  check_compare<Packet, op_pcmp_le>(pairs, [](Scalar x, Scalar y) { return float(x) <= float(y); });
+
+  check_full_mask<Packet, op_ptrue>(in, /*expect_zero=*/false);
+  check_full_mask<Packet, op_pzero>(in, /*expect_zero=*/true);
+  {
+    // pselect with full-bit masks picks lane by lane.
+    const int count = numbers.size();
+    std::vector<Scalar> mask(count);
+    Buffer<Scalar> selected(count);
+    for (int k = 0; k < count; ++k) {
+      const bool set = Eigen::internal::random<bool>();
+      mask[k] = set ? bit_cast<Scalar>(Bits(0xffffu)) : bit_cast<Scalar>(Bits(0x0000u));
+      selected[k] = set ? numbers.a[k] : numbers.b[k];
+    }
+    check_ternary<Packet, op_pselect>(mask, numbers.a, numbers.b, selected, bits_and_payload);
+  }
+  {
+    // pmadd is __hfma2: one rounding, so the reference is the float fma rounded once.
+    const int count = numbers.size();
+    Buffer<Scalar> expected(count);
+    for (int k = 0; k < count; ++k) {
+      expected[k] = half_of(std::fma(float(numbers.a[k]), float(numbers.b[k]), float(numbers.a[k])));
+    }
+    check_ternary<Packet, op_pmadd>(numbers.a, numbers.b, numbers.a, expected, bits);
+  }
+
+  // Adjacent opposite-sign lanes cancel before any cross-pair addition can overflow.
+  Buffer<Scalar> cancellation(8);
+  cancellation << Scalar(60000), Scalar(-60000), Scalar(60000), Scalar(-60000), Scalar(0), Scalar(0), Scalar(0),
+      Scalar(0);
+  check_redux<Packet, op_predux>(
+      cancellation, [](const Scalar*) { return Scalar(0); }, bits);
+
+  // Reductions follow the lane tree of the implementation, so the reference rounds in the same order.
+  const Buffer<Scalar> finite = [&] {
+    std::vector<Scalar> v;
+    for (Index k = 0; k < in.size(); ++k) {
+      const float x = float(in[k]);
+      v.push_back((std::isfinite)(x) && std::abs(x) < 4.0f ? in[k] : Scalar(1));
+    }
+    return Eigen::Map<const Buffer<Scalar>>(v.data(), v.size()).eval();
+  }();
+  check_redux<Packet, op_predux>(
+      finite,
+      [](const Scalar* p) {
+        return half_add(half_add(half_add(half_add(p[0], p[1]), half_add(p[2], p[3])), half_add(p[4], p[5])),
+                        half_add(p[6], p[7]));
+      },
+      bits);
+  check_redux<Packet, op_predux_mul>(
+      finite,
+      [](const Scalar* p) {
+        return half_mul(half_mul(half_mul(p[0], p[2]), half_mul(p[4], p[6])),
+                        half_mul(half_mul(p[1], p[3]), half_mul(p[5], p[7])));
+      },
+      bits);
+  check_redux<Packet, op_predux_min>(
+      finite,
+      [](const Scalar* p) {
+        Scalar m = p[0];
+        for (int l = 1; l < 8; ++l) m = float(p[l]) < float(m) ? p[l] : m;
+        return m;
+      },
+      values);
+  check_redux<Packet, op_predux_max>(
+      finite,
+      [](const Scalar* p) {
+        Scalar m = p[0];
+        for (int l = 1; l < 8; ++l) m = float(p[l]) > float(m) ? p[l] : m;
+        return m;
+      },
+      values);
+  check_redux<Packet, op_pfirst>(
+      in, [](const Scalar* p) { return p[0]; }, bits_and_payload);
+
+  // Casts, in the two forms the evaluator uses.
+  {
+    const int packets = int(in.size()) / kSize;
+    Buffer<float> as_float(packets * 4);
+    as_float.setConstant(-7.0f);
+    run_on_gpu(half_to_float_kernel(), packets, in, as_float);
+    for (int k = 0; k < packets * 4; ++k) {
+      const float want = static_cast<float>(in[(k / 4) * kSize + (k % 4)]);
+      VERIFY(test::areEqualBits(&want, as_float.data() + k, 1) && "pcast<Packet4h2, float4>");
+    }
+
+    // The narrowing cast has to round, so its inputs must not be representable as half to begin with: a float
+    // widened from a half is, and would let any rounding rule pass. Every tie of the half grid is generated
+    // instead -- the midpoint between each pair of adjacent halves, from the subnormals up to the largest finite
+    // one -- with the neighbours of each tie, then the overflow and underflow boundaries.
+    std::vector<float> float_values;
+    for (unsigned bits = 0; bits + 1 < 0x7c00u; ++bits) {
+      const float below = float(bit_cast<Scalar>(Bits(bits)));
+      const float above = float(bit_cast<Scalar>(Bits(bits + 1)));
+      const float tie = 0.5f * (below + above);  // rounds to even, so to one of the two only every other time
+      for (float value : {tie, std::nextafterf(tie, below), std::nextafterf(tie, above)}) {
+        float_values.push_back(value);
+        float_values.push_back(-value);
+      }
+    }
+    const float largest_half = float(bit_cast<Scalar>(Bits(0x7bffu)));
+    const float overflow_tie = 65520.0f;  // halfway from the largest half to where the next one would be
+    for (float value :
+         {largest_half, std::nextafterf(largest_half, 1e30f), std::nextafterf(overflow_tie, 0.0f), overflow_tie,
+          std::nextafterf(overflow_tie, 1e30f), 65536.0f, (std::numeric_limits<float>::max)(),
+          std::numeric_limits<float>::infinity(), std::numeric_limits<float>::denorm_min(), 0.0f}) {
+      float_values.push_back(value);
+      float_values.push_back(-value);
+    }
+    while (float_values.size() % 8 != 0) float_values.push_back(0.0f);
+
+    const int cast_packets = int(float_values.size()) / 8;
+    const Buffer<float> floats = Eigen::Map<const Buffer<float>>(float_values.data(), Index(float_values.size()));
+    Buffer<Scalar> as_half(float_values.size());
+    as_half.setConstant(Scalar(-7));
+    run_on_gpu(float_to_half_kernel(), cast_packets, floats, as_half);
+    Buffer<Scalar> want(float_values.size());
+    for (Index k = 0; k < want.size(); ++k) want[k] = half_of(floats[k]);
+    VERIFY(test::areEqualBits(want.data(), as_half.data(), int(want.size())) && "pcast<float4, Packet4h2>");
+  }
+}
+
+void packetmath_gpu_half_math() {
+  using Scalar = Eigen::half;
+  using Packet = HalfPacket;
+  using Bits = uint16_t;
+
+  const std::vector<Scalar> all = all_half_values();
+  const Buffer<Scalar> in = Eigen::Map<const Buffer<Scalar>>(all.data(), all.size());
+  Buffer<Scalar> positive(in.size());
+  for (Index k = 0; k < in.size(); ++k) positive[k] = bit_cast<Scalar>(Bits(bit_cast<Bits>(in[k]) & 0x7fffu));
+
+  // h2sqrt, h2rsqrt, h2log and h2exp against the float computation rounded to half. The device functions are not
+  // documented to be correctly rounded in half, so allow one half ULP.
+  const uint64_t kHalfMathUlps = 1;
+  check_unary<Packet, op_psqrt>(
+      positive, [](Scalar x) { return half_of(std::sqrt(float(x))); }, compare_ulps<Scalar>{kHalfMathUlps});
+  check_unary<Packet, op_prsqrt>(
+      positive, [](Scalar x) { return half_of(1.0f / std::sqrt(float(x))); }, compare_ulps<Scalar>{kHalfMathUlps});
+  check_unary<Packet, op_plog>(
+      positive, [](Scalar x) { return half_of(std::log(float(x))); }, compare_ulps<Scalar>{kHalfMathUlps});
+  check_unary<Packet, op_pexp>(
+      in, [](Scalar x) { return half_of(std::exp(float(x))); }, compare_ulps<Scalar>{kHalfMathUlps});
+  check_unary<Packet, op_plog1p>(
+      in, [](Scalar x) { return half_of(std::log1p(float(x))); }, compare_ulps<Scalar>{kHalfMathUlps});
+  check_unary<Packet, op_pexpm1>(
+      in, [](Scalar x) { return half_of(std::expm1(float(x))); }, compare_ulps<Scalar>{kHalfMathUlps});
+
+  const Scalar zero(0.0f), one(1.0f), inf = std::numeric_limits<Scalar>::infinity();
+  const Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
+  check_special_values<Packet, op_pexp>({{zero, one}, {-zero, one}, {-inf, zero}, {inf, inf}, {nan, nan}});
+  check_special_values<Packet, op_plog>({{one, zero}, {zero, -inf}, {-one, nan}, {inf, inf}, {nan, nan}});
+  check_special_values<Packet, op_psqrt>({{zero, zero}, {-zero, -zero}, {one, one}, {inf, inf}, {nan, nan}});
+}
+
+// ------------------------------------------------------------------------------------------------------------------
+// Part 7: types without a device packet run the scalar fallbacks of GenericPacketMath.h, which must agree with the
+// host's scalar fallbacks bit for bit; preinterpret is the bit_cast the cast path relies on.
+
+template <typename Scalar>
+void check_scalar_fallback_common(const binary_inputs<Scalar>& pairs, const Buffer<Scalar>& in) {
+  const compare_bits<Scalar> bits{true};
+  const std::vector<int> traits = device_traits<Scalar>();
+  VERIFY_IS_EQUAL(traits[kVectorizable], 0);
+  VERIFY_IS_EQUAL(traits[ksize], 1);
+  check_binary<Scalar, op_padd>(pairs, test::REF_ADD<Scalar>, bits);
+  check_binary<Scalar, op_pmul>(pairs, test::REF_MUL<Scalar>, bits);
+  check_binary<Scalar, op_pmin>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pmin(x, y); }, bits);
+  check_binary<Scalar, op_pmax>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pmax(x, y); }, bits);
+  check_binary<Scalar, op_pand>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pand(x, y); }, bits);
+  check_binary<Scalar, op_por>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::por(x, y); }, bits);
+  check_binary<Scalar, op_pxor>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pxor(x, y); }, bits);
+  check_binary<Scalar, op_pcmp_eq>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pcmp_eq(x, y); }, bits);
+  check_binary<Scalar, op_pcmp_lt>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pcmp_lt(x, y); }, bits);
+  check_binary<Scalar, op_pcmp_le>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pcmp_le(x, y); }, bits);
+  check_unary<Scalar, op_identity>(
+      in, [](Scalar x) { return x; }, bits);
+  {
+    // pselect on a scalar is a ternary on the mask's truth value.
+    const int n = pairs.size();
+    std::vector<Scalar> mask(n);
+    Buffer<Scalar> selected(n);
+    for (int k = 0; k < n; ++k) {
+      mask[k] = Eigen::internal::random<bool>() ? Eigen::internal::ptrue(Scalar(0)) : Eigen::internal::pzero(Scalar(0));
+      selected[k] = Eigen::internal::pselect(Scalar(mask[k]), Scalar(pairs.a[k]), Scalar(pairs.b[k]));
+    }
+    check_ternary<Scalar, op_pselect>(mask, pairs.a, pairs.b, selected, bits);
+  }
+}
+
+template <typename Scalar>
+binary_inputs<Scalar> integer_pairs(int count) {
+  binary_inputs<Scalar> pairs;
+  // Signed operands stay within 100 in magnitude, so their sums and products stay in range; unsigned operands reach
+  // 200, whose uint8_t sums and products wrap, as the REF_* references do.
+  const Scalar bound = Scalar(NumTraits<Scalar>::IsSigned ? 100 : 200);
+  for (int k = 0; k < count; ++k) {
+    pairs.push(Eigen::internal::random<Scalar>(NumTraits<Scalar>::IsSigned ? Scalar(-bound) : Scalar(0), bound),
+               Eigen::internal::random<Scalar>(NumTraits<Scalar>::IsSigned ? Scalar(-bound) : Scalar(0), bound));
+  }
+  return pairs;
+}
+
+template <typename Scalar>
+void packetmath_gpu_integer_fallback() {
+  const compare_bits<Scalar> bits{true};
+  const binary_inputs<Scalar> pairs = integer_pairs<Scalar>(1 << 12);
+  const Buffer<Scalar> in = Eigen::Map<const Buffer<Scalar>>(pairs.a.data(), pairs.size());
+  check_scalar_fallback_common<Scalar>(pairs, in);
+  check_unary<Scalar, op_pnegate>(in, test::negate<Scalar>, bits);
+  check_unary<Scalar, op_pabs>(
+      in, [](Scalar x) { return Eigen::internal::pabs(x); }, bits);
+  check_binary<Scalar, op_psub>(pairs, test::REF_SUB<Scalar>, bits);
+  binary_inputs<Scalar> nonzero = pairs;
+  for (Scalar& y : nonzero.b) {
+    if (y == Scalar(0)) y = Scalar(1);
+  }
+  check_binary<Scalar, op_pdiv>(nonzero, test::REF_DIV<Scalar>, bits);
+  check_binary<Scalar, op_pandnot>(
+      pairs, [](Scalar x, Scalar y) { return Eigen::internal::pandnot(x, y); }, bits);
+}
+
+void packetmath_gpu_bool_fallback() {
+  binary_inputs<bool> pairs;
+  for (int k = 0; k < 1 << 10; ++k) pairs.push(Eigen::internal::random<bool>(), Eigen::internal::random<bool>());
+  // std::vector<bool> has no data(): copy lane by lane.
+  Buffer<bool> in(pairs.size());
+  for (int k = 0; k < pairs.size(); ++k) in[k] = pairs.a[k];
+  check_scalar_fallback_common<bool>(pairs, in);
+}
+
+void packetmath_gpu_bfloat16_fallback() {
+  using Scalar = Eigen::bfloat16;
+  const compare_bits<Scalar> bits{true};
+  const std::vector<float> specials = special_values<float>();
+  binary_inputs<Scalar> pairs;
+  for (float x : specials) {
+    for (float y : specials) pairs.push(Scalar(x), Scalar(y));
+  }
+  for (int k = 0; k < 1 << 12; ++k) {
+    pairs.push(Scalar(Eigen::internal::random<float>(-4.0f, 4.0f)),
+               Scalar(Eigen::internal::random<float>(-4.0f, 4.0f)));
+  }
+  const Buffer<Scalar> in = Eigen::Map<const Buffer<Scalar>>(pairs.a.data(), pairs.size());
+  check_scalar_fallback_common<Scalar>(pairs, in);
+  check_unary<Scalar, op_pnegate>(in, test::negate<Scalar>, bits);
+  check_unary<Scalar, op_pabs>(
+      in, [](Scalar x) { return Eigen::internal::pabs(x); }, bits);
+  check_binary<Scalar, op_psub>(pairs, test::REF_SUB<Scalar>, bits);
+  check_binary<Scalar, op_pdiv>(pairs, test::REF_DIV<Scalar>, bits);
+  // A one-ulp sqrtf error can cross a bfloat16 rounding boundary.
+  check_unary<Scalar, op_psqrt>(
+      in, [](Scalar x) { return Eigen::internal::psqrt(x); }, compare_ulps<Scalar>{kSqrtFloatUlps});
+  check_unary<Scalar, op_pfloor>(
+      in, [](Scalar x) { return Eigen::internal::pfloor(x); }, bits);
+}
+
+template <typename Scalar>
+void packetmath_gpu_preinterpret() {
+  using Bits = typename Eigen::numext::get_integer_by_size<sizeof(Scalar)>::signed_type;
+  const int kSize = packet_layout<typename packet_traits<Scalar>::type>::kSize;
+  const Buffer<Scalar> in = unary_inputs<Scalar>(kSize, 1 << 10);
+  Buffer<Bits> out(in.size());
+  out.setZero();
+  run_on_gpu(preinterpret_scalar_kernel<Scalar, Bits>(), int(in.size()), in, out);
+  for (Index k = 0; k < in.size(); ++k) {
+    VERIFY_IS_EQUAL(out[k], Eigen::numext::bit_cast<Bits>(in[k]));
+  }
+}
+
+// Compiled in the host pass as well as the device pass: with EIGEN_USE_GPU defined, packet_traits<float>::type is
+// float4 in both, so an expression reaching psign, a comparison or a bit operation has to compile on the host too.
+// It did not before those operations moved out of the device-only block.
+void host_pass_instantiation() {
+  Eigen::Array<float, 32, 1> a = Eigen::Array<float, 32, 1>::Random();
+  a(0) = std::numeric_limits<float>::quiet_NaN();
+  const Eigen::Array<float, 32, 1> s = a.sign();
+  const Eigen::Array<bool, 32, 1> nans = a.isNaN();
+  const Eigen::Array<float, 32, 1> clamped = a.cwiseMax(0.0f).cwiseMin(1.0f);
+  VERIFY((Eigen::numext::isnan)(s(0)));
+  VERIFY(nans(0));
+  VERIFY(clamped(1) >= 0.0f && clamped(1) <= 1.0f);
+}
+
+}  // namespace
+
+EIGEN_DECLARE_TEST(packetmath_gpu) {
+  ei_test_init_gpu();
+  CALL_SUBTEST_1(host_pass_instantiation());
+  CALL_SUBTEST_1(packetmath_gpu_real_core<float>());
+  CALL_SUBTEST_2(packetmath_gpu_real_math<float>());
+  CALL_SUBTEST_3(packetmath_gpu_real_core<double>());
+  CALL_SUBTEST_4(packetmath_gpu_real_math<double>());
+  CALL_SUBTEST_5(packetmath_gpu_half_core());
+  CALL_SUBTEST_6(packetmath_gpu_half_math());
+  CALL_SUBTEST_7(packetmath_gpu_integer_fallback<int32_t>());
+  CALL_SUBTEST_7(packetmath_gpu_integer_fallback<int64_t>());
+  CALL_SUBTEST_7(packetmath_gpu_integer_fallback<uint8_t>());
+  CALL_SUBTEST_7(packetmath_gpu_bool_fallback());
+  CALL_SUBTEST_7(packetmath_gpu_bfloat16_fallback());
+  CALL_SUBTEST_7(packetmath_gpu_preinterpret<float>());
+  CALL_SUBTEST_7(packetmath_gpu_preinterpret<double>());
+}
diff --git a/test/packetmath_test_shared.h b/test/packetmath_test_shared.h
index 64b13e3..5f79618 100644
--- a/test/packetmath_test_shared.h
+++ b/test/packetmath_test_shared.h
@@ -7,6 +7,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_PACKETMATH_TEST_SHARED_H
+#define EIGEN_TEST_PACKETMATH_TEST_SHARED_H
 
 #include "main.h"
 #include <typeinfo>
@@ -18,11 +22,142 @@
 
 bool g_first_pass = true;
 
+// Marks the body of a packet test kernel or operation. CUDA and HIP compile it for the device only, since their host
+// pass can lack the packet operations it calls, so there it runs only through run_on_gpu; ordinary C++ compiles it for
+// the host.
+#if defined(EIGEN_GPUCC)
+#define EIGEN_PACKET_TEST_FUNC __device__
+#else
+#define EIGEN_PACKET_TEST_FUNC
+#endif
+// Whether such a body is compiled at all: always in ordinary C++, and only in the device pass of CUDA or HIP, whose
+// host pass may not know the packet types a body uses (the GPU half packets).
+#if !defined(EIGEN_GPUCC) || defined(EIGEN_GPU_COMPILE_PHASE)
+#define EIGEN_PACKET_TEST_KERNEL_BODY 1
+#else
+#define EIGEN_PACKET_TEST_KERNEL_BODY 0
+#endif
+
 namespace Eigen {
 
 namespace test {
 
-template <typename T, std::enable_if_t<NumTraits<T>::IsSigned, bool> = true>
+// The scalar type and lane count of a packet as host code sees them. A test whose packets have unpacket_traits only
+// in a GPU device pass (the half packets) specializes it.
+template <typename Packet>
+struct packet_layout {
+  using Scalar = typename internal::unpacket_traits<Packet>::type;
+  static constexpr int kSize = internal::unpacket_traits<Packet>::size;
+};
+
+template <typename Scalar>
+std::vector<Scalar> special_values() {
+  using L = std::numeric_limits<Scalar>;
+  const Scalar largest_subnormal = (L::min)() - L::denorm_min();
+  return {Scalar(0),
+          Scalar(-0.0),
+          Scalar(1),
+          Scalar(-1),
+          Scalar(0.5),
+          Scalar(-0.5),
+          Scalar(2),
+          Scalar(-2),
+          Scalar(3),
+          Scalar(-3),
+          Scalar(0.25),
+          Scalar(0.75),
+          Scalar(1.5),
+          Scalar(-1.5),
+          Scalar(2.5),
+          Scalar(-2.5),
+          Scalar(-0.4),
+          Scalar(0.4),
+          Scalar(1e-3),
+          Scalar(-1e-3),
+          L::epsilon(),
+          -L::epsilon(),
+          Scalar(1) + L::epsilon(),
+          Scalar(1) - L::epsilon() / Scalar(2),
+          L::denorm_min(),
+          -L::denorm_min(),
+          largest_subnormal,
+          -largest_subnormal,
+          (L::min)(),
+          -(L::min)(),
+          (L::max)(),
+          -(L::max)(),
+          L::infinity(),
+          -L::infinity(),
+          L::quiet_NaN(),
+          -L::quiet_NaN()};
+}
+
+template <typename T, std::enable_if_t<!NumTraits<T>::IsInteger || !NumTraits<T>::IsSigned, int> = 0>
+inline T REF_ADD(const T& a, const T& b) {
+  return a + b;
+}
+template <typename T, std::enable_if_t<NumTraits<T>::IsInteger && NumTraits<T>::IsSigned, int> = 0>
+inline T REF_ADD(const T& a, const T& b) {
+  using UnsignedT = std::make_unsigned_t<T>;
+  return static_cast<T>(static_cast<UnsignedT>(a) + static_cast<UnsignedT>(b));
+}
+template <typename T, std::enable_if_t<!NumTraits<T>::IsInteger || !NumTraits<T>::IsSigned, int> = 0>
+inline T REF_SUB(const T& a, const T& b) {
+  return a - b;
+}
+template <typename T, std::enable_if_t<NumTraits<T>::IsInteger && NumTraits<T>::IsSigned, int> = 0>
+inline T REF_SUB(const T& a, const T& b) {
+  using UnsignedT = std::make_unsigned_t<T>;
+  return static_cast<T>(static_cast<UnsignedT>(a) - static_cast<UnsignedT>(b));
+}
+template <typename T, std::enable_if_t<!NumTraits<T>::IsInteger || std::is_same<T, bool>::value, int> = 0>
+inline T REF_MUL(const T& a, const T& b) {
+  return a * b;
+}
+template <typename T, std::enable_if_t<NumTraits<T>::IsInteger && !std::is_same<T, bool>::value, int> = 0>
+inline T REF_MUL(const T& a, const T& b) {
+  // Evaluate in an unsigned type at least as wide as int so that sub-int
+  // operands are not promoted back to signed int (whose product can overflow);
+  // the result then wraps modulo 2^bits just like pmul.
+  using UnsignedT = std::common_type_t<std::make_unsigned_t<T>, unsigned>;
+  return static_cast<T>(static_cast<UnsignedT>(a) * static_cast<UnsignedT>(b));
+}
+
+template <typename T>
+inline T REF_DIV(const T& a, const T& b) {
+  return a / b;
+}
+
+template <>
+inline bool REF_ADD(const bool& a, const bool& b) {
+  return a || b;
+}
+
+template <>
+inline bool REF_SUB(const bool& a, const bool& b) {
+  return a ^ b;
+}
+
+template <>
+inline bool REF_MUL(const bool& a, const bool& b) {
+  return a && b;
+}
+
+template <>
+inline bool REF_DIV(const bool& a, const bool& b) {
+  return a && b;
+}
+
+template <typename T, std::enable_if_t<NumTraits<T>::IsSigned && NumTraits<T>::IsInteger, bool> = true>
+T negate(const T& x) {
+  // `-x` is UB at the minimum representable value; go through the unsigned type instead, the
+  // same way the unsigned overload below does. This wraps to match what the vectorized
+  // `pnegate` actually computes there.
+  using UnsignedT = typename std::make_unsigned<T>::type;
+  return static_cast<T>(UnsignedT(0) - static_cast<UnsignedT>(x));
+}
+
+template <typename T, std::enable_if_t<NumTraits<T>::IsSigned && !NumTraits<T>::IsInteger, bool> = true>
 T negate(const T& x) {
   return -x;
 }
@@ -49,7 +184,15 @@
 }
 
 template <typename Scalar>
-inline void print_mismatch(const Scalar* ref, const Scalar* vec, int size) {
+inline void print_mismatch(const Scalar* ref, const Scalar* vec, int size, int at = -1) {
+  if (at >= 0 && size > 8) {
+    const int begin = (std::max)(0, at - 4);
+    const int end = (std::min)(size, begin + 8);
+    std::cout << "lanes [" << begin << ", " << end << ") ";
+    ref += begin;
+    vec += begin;
+    size = end - begin;
+  }
   std::cout << "ref: [" << Map<const Matrix<Scalar, 1, Dynamic> >(ref, size) << "]"
             << " != vec: [" << Map<const Matrix<Scalar, 1, Dynamic> >(vec, size) << "]\n";
 }
@@ -58,7 +201,7 @@
 bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits<Scalar>::Real& refvalue) {
   for (int i = 0; i < size; ++i) {
     if (!isApproxAbs(a[i], b[i], refvalue)) {
-      print_mismatch(a, b, size);
+      print_mismatch(a, b, size, i);
       std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                 << std::endl;
       return false;
@@ -72,7 +215,7 @@
   for (int i = 0; i < size; ++i) {
     if (numext::not_equal_strict(a[i], b[i]) && !internal::isApprox(a[i], b[i]) &&
         !((numext::isnan)(a[i]) && (numext::isnan)(b[i]))) {
-      print_mismatch(a, b, size);
+      print_mismatch(a, b, size, i);
       std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                 << std::endl;
       return false;
@@ -85,7 +228,7 @@
 bool areEqual(const Scalar* a, const Scalar* b, int size) {
   for (int i = 0; i < size; ++i) {
     if (numext::not_equal_strict(a[i], b[i]) && !((numext::isnan)(a[i]) && (numext::isnan)(b[i]))) {
-      print_mismatch(a, b, size);
+      print_mismatch(a, b, size, i);
       std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                 << std::endl;
       return false;
@@ -94,12 +237,90 @@
   return true;
 }
 
+// Checks that each lane of `data` is a full bit mask: all bits set when `zero_mask[i]` is false, all
+// bits cleared when it is true. Packet comparisons must return all-ones masks on true lanes so that
+// the result can be consumed bitwise (pselect, pand, pandnot, ...); a lane that is merely nonzero
+// (e.g. a NaN produced by an arithmetic float-to-half conversion of the mask) is not enough.
+template <typename Scalar>
+bool areFullBitMasks(const Scalar* data, const bool* zero_mask, int size) {
+  for (int i = 0; i < size; ++i) {
+    const unsigned char expected = zero_mask[i] ? 0x00 : 0xff;
+    if (!(bits(data[i]) == expected).all()) {
+      std::cout << "Mask lane " << i << " should be all-" << (zero_mask[i] ? "zero" : "one")
+                << " bits, got bytes:" << std::hex;
+      for (std::size_t k = 0; k < sizeof(Scalar); ++k) std::cout << " 0x" << static_cast<int>(bits(data[i])[k]);
+      std::cout << std::dec << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+// Bitwise equality lane by lane; with `nan_is_nan`, two NaNs match whatever their payloads. Use it where a
+// contract fixes the result bit for bit (loads and stores, bit operations, correctly rounded arithmetic, the sign of
+// a zero) and areEqual's value comparison would pass +0 for -0.
+template <typename Scalar>
+bool areEqualBits(const Scalar* a, const Scalar* b, int size, bool nan_is_nan = true) {
+  for (int i = 0; i < size; ++i) {
+    const bool both_nan = nan_is_nan && (numext::isnan)(a[i]) && (numext::isnan)(b[i]);
+    if (!both_nan && !biteq(a[i], b[i])) {
+      print_mismatch(a, b, size, i);
+      std::cout << std::setprecision(16) << "Bits differ in position " << i << ": " << a[i] << " vs " << b[i]
+                << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+// The position of x among the values of its type: the sign-magnitude bit pattern folded onto a monotone integer
+// line, so that adjacent representable values are one apart, +0 and -0 coincide, and the infinities sit at the ends.
+template <typename Scalar>
+typename numext::get_integer_by_size<sizeof(Scalar)>::signed_type ordered_position(Scalar x) {
+  using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::signed_type;
+  const Bits bits = numext::bit_cast<Bits>(x);
+  return bits < 0 ? Bits((std::numeric_limits<Bits>::min)() - bits) : bits;
+}
+
+// Distance in units in the last place between two values of the same floating-point type. Two NaNs are zero apart,
+// a NaN and a number as far apart as possible. Infinities and the sign of zero are exact: an infinity is as far as
+// possible from any other value, and +0 from -0, so no budget admits an overflow or a lost sign. (test/ulp_accuracy
+// measures signed errors with its own fold, which maps -0 below +0 and treats infinities as incomparable; the budgets
+// it reports are not this distance.)
+template <typename Scalar>
+uint64_t ulp_distance(Scalar a, Scalar b) {
+  constexpr uint64_t kFar = (std::numeric_limits<uint64_t>::max)();
+  const bool a_nan = (numext::isnan)(a);
+  const bool b_nan = (numext::isnan)(b);
+  if (a_nan || b_nan) return (a_nan && b_nan) ? 0 : kFar;
+  if ((numext::isinf)(a) || (numext::isinf)(b) || (numext::is_exactly_zero(a) && numext::is_exactly_zero(b))) {
+    return biteq(a, b) ? 0 : kFar;
+  }
+  const int64_t pa = static_cast<int64_t>(ordered_position(a));
+  const int64_t pb = static_cast<int64_t>(ordered_position(b));
+  return pa > pb ? uint64_t(pa) - uint64_t(pb) : uint64_t(pb) - uint64_t(pa);
+}
+
+template <typename Scalar>
+bool areWithinUlps(const Scalar* ref, const Scalar* vec, int size, uint64_t max_ulps) {
+  for (int i = 0; i < size; ++i) {
+    const uint64_t distance = ulp_distance(ref[i], vec[i]);
+    if (distance > max_ulps) {
+      print_mismatch(ref, vec, size, i);
+      std::cout << std::setprecision(16) << "Values differ in position " << i << " by " << distance << " ulps (budget "
+                << max_ulps << "): " << ref[i] << " vs " << vec[i] << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
 template <typename Scalar>
 bool areApprox(const Scalar* a, const Scalar* b, int size, const typename NumTraits<Scalar>::Real& precision) {
   for (int i = 0; i < size; ++i) {
     if (numext::not_equal_strict(a[i], b[i]) && !internal::isApprox(a[i], b[i], precision) &&
         !((numext::isnan)(a[i]) && (numext::isnan)(b[i]))) {
-      print_mismatch(a, b, size);
+      print_mismatch(a, b, size, i);
       std::cout << std::setprecision(16) << "Values differ in position " << i << ": " << a[i] << " vs " << b[i]
                 << std::endl;
       return false;
@@ -137,6 +358,11 @@
       data_mask[i] = numext::is_exactly_zero(data2[i]);                                                        \
     }                                                                                                          \
     VERIFY(test::areEqual(ref_mask, data_mask, PacketSize) && #POP);                                           \
+    /* Vectorized comparisons must produce all-ones bit masks on true lanes. Scalar fallbacks return */        \
+    /* Scalar(1) and bool packets store `true` (loading 0xff into a bool is UB), so those are exempt. */       \
+    if (internal::unpacket_traits<Packet>::vectorizable && !std::is_same<Scalar, bool>::value) {               \
+      VERIFY(test::areFullBitMasks(data2, ref_mask, PacketSize) && #POP);                                      \
+    }                                                                                                          \
   }
 
 // Checks component-wise for input of size N. All of data1, data2, and ref
@@ -294,7 +520,7 @@
 
 template <typename Scalar, typename PacketType = typename internal::packet_traits<Scalar>::type,
           bool Vectorized = internal::packet_traits<Scalar>::Vectorizable,
-          bool HasHalf = !internal::is_same<typename internal::unpacket_traits<PacketType>::half, PacketType>::value>
+          bool HasHalf = !std::is_same<typename internal::unpacket_traits<PacketType>::half, PacketType>::value>
 struct runner;
 
 template <typename Scalar, typename PacketType>
@@ -317,3 +543,5 @@
 
 }  // namespace test
 }  // namespace Eigen
+
+#endif  // EIGEN_TEST_PACKETMATH_TEST_SHARED_H
diff --git a/test/pardiso_support.cpp b/test/pardiso_support.cpp
index 8358541..02b94cf 100644
--- a/test/pardiso_support.cpp
+++ b/test/pardiso_support.cpp
@@ -1,6 +1,7 @@
 /*
    Intel Copyright (C) ....
 */
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 #include <Eigen/PardisoSupport>
diff --git a/test/pastix_support.cpp b/test/pastix_support.cpp
index e487dd1..ff665f8 100644
--- a/test/pastix_support.cpp
+++ b/test/pastix_support.cpp
@@ -7,11 +7,12 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #include "sparse_solver.h"
 #include <Eigen/PaStiXSupport>
-#include <unsupported/Eigen/SparseExtra>
+#include <contrib/Eigen/SparseExtra>
 
 template <typename T>
 void test_pastix_T() {
diff --git a/test/permutationmatrices.cpp b/test/permutationmatrices.cpp
index ee794b2..00ccc4a 100644
--- a/test/permutationmatrices.cpp
+++ b/test/permutationmatrices.cpp
@@ -6,10 +6,13 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 
 #include "main.h"
+#include <Eigen/Core>
+#include <cstdint>
 
 using namespace std;
 template <typename MatrixType>
@@ -190,6 +193,81 @@
   }
 }
 
+template <typename PermutationType, typename OtherPermutationType = PermutationType>
+void permutation_inverse_product(Index size) {
+  PermutationType lhs(size), result(size);
+  OtherPermutationType rhs(size);
+  randomPermutationVector(lhs.indices(), size);
+  randomPermutationVector(rhs.indices(), size);
+  const MatrixXi lhsDense = lhs.toDenseMatrix().template cast<int>();
+  const MatrixXi rhsDense = rhs.toDenseMatrix().template cast<int>();
+  const MatrixXi expected = lhsDense * rhsDense.transpose();
+  result = lhs * rhs.inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  result = lhs * rhs.transpose();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  result = lhs.indices().asPermutation() * rhs.indices().asPermutation().inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  result = Map<PermutationType>(lhs.indices().data(), size) *
+           Map<OtherPermutationType>(rhs.indices().data(), size).inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  using OtherStorageIndex = typename OtherPermutationType::StorageIndex;
+  Matrix<OtherStorageIndex, Dynamic, 1> storage(2 * size);
+  Map<Matrix<OtherStorageIndex, Dynamic, 1>, 0, InnerStride<2>> strided(storage.data(), size);
+  strided = rhs.indices();
+  result = lhs * strided.asPermutation().inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  result = lhs;
+  result = result * rhs.inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  result.indices() = rhs.indices().template cast<typename PermutationType::StorageIndex>();
+  result = lhs * result.inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+  result = lhs;
+  result = result * result.inverse();
+  VERIFY(result.toDenseMatrix().isIdentity());
+  result = lhs.inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == lhsDense.transpose());
+  result = lhs;
+  result = result.inverse();
+  VERIFY(result.toDenseMatrix().template cast<int>() == lhsDense.transpose());
+  const OtherPermutationType inverse = strided.asPermutation().inverse();
+  VERIFY(inverse.toDenseMatrix().template cast<int>() == rhsDense.transpose());
+}
+
+template <typename PermutationType>
+void permutation_left_transposition(Index size) {
+  PermutationType original(size);
+  randomPermutationVector(original.indices(), size);
+  const MatrixXi dense = original.toDenseMatrix().template cast<int>();
+  PermutationType result(size);
+  MatrixXi expected(size, size);
+  for (Index i = 0; i < size; ++i) {
+    for (Index j = 0; j < size; ++j) {
+      result = original;
+      expected = dense;
+      expected.row(i).swap(expected.row(j));
+      VERIFY(&result.applyTranspositionOnTheLeft(i, j) == &result);
+      VERIFY(result.toDenseMatrix().template cast<int>() == expected);
+    }
+  }
+}
+
+void permutation_inverse_product_temporaries() {
+  PermutationMatrix<Dynamic> lhs(17), rhs(17), result(17);
+  randomPermutationVector(lhs.indices(), lhs.size());
+  randomPermutationVector(rhs.indices(), rhs.size());
+  VERIFY_EVALUATION_COUNT(result = lhs * rhs.inverse(), 1);
+  const MatrixXi expected = lhs.toDenseMatrix() * rhs.toDenseMatrix().transpose();
+  VERIFY(result.toDenseMatrix() == expected);
+  PermutationMatrix<Dynamic> mismatched(18);
+  mismatched.setIdentity();
+  VERIFY_RAISES_ASSERT(lhs * mismatched.inverse());
+  PermutationMatrix<Dynamic> empty(0);
+  VERIFY_EVALUATION_COUNT(result = empty * empty.inverse(), 0);
+  VERIFY_IS_EQUAL(result.size(), 0);
+}
+
 EIGEN_DECLARE_TEST(permutationmatrices) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(permutationmatrices(Matrix<float, 1, 1>()));
@@ -202,6 +280,27 @@
     CALL_SUBTEST_7(permutationmatrices(
         MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
   }
+  CALL_SUBTEST_8(permutation_inverse_product_temporaries());
+  CALL_SUBTEST_8((permutation_inverse_product<PermutationMatrix<4>>(4)));
+  CALL_SUBTEST_8((permutation_inverse_product<PermutationMatrix<Dynamic, 17>>(17)));
+  for (Index size : {0, 1, 2, 7, 8, 9, 15, 16, 17}) {
+    EIGEN_UNUSED_VARIABLE(size);
+    CALL_SUBTEST_8((permutation_inverse_product<PermutationMatrix<Dynamic>>(size)));
+    CALL_SUBTEST_8((permutation_inverse_product<PermutationMatrix<Dynamic, Dynamic, std::int8_t>>(size)));
+    CALL_SUBTEST_8((permutation_inverse_product<PermutationMatrix<Dynamic, Dynamic, std::uint32_t>>(size)));
+    CALL_SUBTEST_8(
+        (permutation_inverse_product<PermutationMatrix<Dynamic>, PermutationMatrix<Dynamic, Dynamic, std::int64_t>>(
+            size)));
+  }
+  CALL_SUBTEST_9((permutation_left_transposition<PermutationMatrix<4>>(4)));
+  CALL_SUBTEST_9((permutation_left_transposition<PermutationMatrix<Dynamic, 17>>(17)));
+  for (Index size : {1, 2, 7, 8, 9, 15, 16, 17, 33}) {
+    EIGEN_UNUSED_VARIABLE(size);
+    CALL_SUBTEST_9((permutation_left_transposition<PermutationMatrix<Dynamic>>(size)));
+    CALL_SUBTEST_9((permutation_left_transposition<PermutationMatrix<Dynamic, Dynamic, std::int8_t>>(size)));
+    CALL_SUBTEST_9((permutation_left_transposition<PermutationMatrix<Dynamic, Dynamic, std::uint32_t>>(size)));
+    CALL_SUBTEST_9((permutation_left_transposition<PermutationMatrix<Dynamic, Dynamic, std::int64_t>>(size)));
+  }
   CALL_SUBTEST_5(bug890<double>());
   CALL_SUBTEST_4(test_aliasing());
 }
diff --git a/test/prec_inverse_4x4.cpp b/test/prec_inverse_4x4.cpp
index 3864ecf..867c12d 100644
--- a/test/prec_inverse_4x4.cpp
+++ b/test/prec_inverse_4x4.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/LU>
@@ -40,8 +41,7 @@
   double error_avg = error_sum / repeat;
   EIGEN_DEBUG_VAR(error_avg);
   EIGEN_DEBUG_VAR(error_max);
-  // FIXME: that 1.25 used to be 1.0 until the NumTraits changes on 28 April 2010.
-  // FIXME that 1.25 used to be 1.2 until we tested gcc 4.1 on 30 June 2010 and got 1.21.
+  // Keep the historical 1.25 tolerance after NumTraits and compiler-codegen changes observed in 2010.
   VERIFY(error_avg < (NumTraits<Scalar>::IsComplex ? 8.0 : 1.25));
   VERIFY(error_max < (NumTraits<Scalar>::IsComplex ? 64.0 : 20.0));
 
diff --git a/test/preprocessor_directives.cpp b/test/preprocessor_directives.cpp
new file mode 100644
index 0000000..42a6094
--- /dev/null
+++ b/test/preprocessor_directives.cpp
@@ -0,0 +1,99 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Checks that the configuration macros documented in
+// doc/TopicPreprocessorDirectives.dox are still honored by the declarations
+// that spell them.
+//
+// A mechanical rewrite of such a declaration prints the *resolved* type, so
+// `typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE Index;` silently becomes
+// `using Index = std::ptrdiff_t;`. Every default-configured build stays green;
+// only a translation unit that overrides the macro notices. Each part below
+// therefore compiles with a different configuration.
+
+#if defined(EIGEN_TEST_PART_2)
+#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
+#elif defined(EIGEN_TEST_PART_3)
+#define EIGEN_64BIT_BLAS
+#elif defined(EIGEN_TEST_PART_4)
+#define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING EIGEN_ALIGN_TO_BOUNDARY(256)
+#endif
+
+#include "main.h"
+
+// The index type must follow EIGEN_DEFAULT_DENSE_INDEX_TYPE in every configuration.
+static_assert(std::is_same<Eigen::Index, EIGEN_DEFAULT_DENSE_INDEX_TYPE>::value,
+              "Eigen::Index no longer follows EIGEN_DEFAULT_DENSE_INDEX_TYPE");
+static_assert(std::is_same<Eigen::DenseIndex, EIGEN_DEFAULT_DENSE_INDEX_TYPE>::value,
+              "Eigen::DenseIndex no longer follows EIGEN_DEFAULT_DENSE_INDEX_TYPE");
+
+// Outside of MKL, the BLAS integer type must follow EIGEN_BLAS_INT, which the
+// external BLAS prototypes in Eigen/src/Core/util/blas.h are declared with.
+#if !defined(EIGEN_USE_MKL)
+static_assert(std::is_same<Eigen::BlasIndex, EIGEN_BLAS_INT>::value,
+              "Eigen::BlasIndex no longer follows EIGEN_BLAS_INT");
+#endif
+
+// Buffers that Eigen aligns itself must be mapped with EIGEN_DEFAULT_ALIGN_BYTES,
+// not with whatever that happened to expand to on the machine of the last edit.
+static_assert(int(Eigen::internal::traits<
+                  Eigen::internal::local_nested_eval_wrapper<Eigen::MatrixXd, 2, true>::ObjectType>::Alignment) ==
+                  EIGEN_DEFAULT_ALIGN_BYTES,
+              "local_nested_eval_wrapper no longer follows EIGEN_DEFAULT_ALIGN_BYTES");
+
+// EIGEN_ALIGN_TO_AVOID_FALSE_SHARING must honor pre-existing definitions and stay pinned to 128 by default.
+struct AvoidFalseSharingAligned {
+  EIGEN_ALIGN_TO_AVOID_FALSE_SHARING char c;
+};
+
+#if defined(EIGEN_TEST_PART_4)
+static_assert(alignof(AvoidFalseSharingAligned) == 256,
+              "Pre-existing EIGEN_ALIGN_TO_AVOID_FALSE_SHARING definition was not preserved");
+#else
+static_assert(alignof(AvoidFalseSharingAligned) == 128,
+              "EIGEN_ALIGN_TO_AVOID_FALSE_SHARING should be pinned to 128 bytes by default");
+#endif
+
+// Per-part checks that the override actually took effect.
+#if defined(EIGEN_TEST_PART_2)
+static_assert(std::is_same<Eigen::Index, int>::value, "EIGEN_DEFAULT_DENSE_INDEX_TYPE was ignored");
+#endif
+#if defined(EIGEN_TEST_PART_3) && !defined(EIGEN_USE_MKL)
+static_assert(sizeof(Eigen::BlasIndex) == 8, "EIGEN_64BIT_BLAS was ignored");
+#endif
+
+void check_index_type() {
+  VERIFY_IS_EQUAL(int(sizeof(Eigen::Index)), int(sizeof(EIGEN_DEFAULT_DENSE_INDEX_TYPE)));
+  // The configured index type is the one the containers actually index with.
+  MatrixXd m(3, 4);
+  VERIFY_IS_EQUAL(m.rows(), Eigen::Index(3));
+  VERIFY_IS_EQUAL(m.cols(), Eigen::Index(4));
+}
+
+void check_blas_index() {
+#if !defined(EIGEN_USE_MKL)
+  VERIFY_IS_EQUAL(int(sizeof(Eigen::BlasIndex)), int(sizeof(EIGEN_BLAS_INT)));
+#endif
+}
+
+void check_false_sharing_alignment() {
+#if defined(EIGEN_TEST_PART_4)
+  VERIFY_IS_EQUAL(std::size_t(alignof(AvoidFalseSharingAligned)), std::size_t(256));
+#else
+  VERIFY_IS_EQUAL(std::size_t(alignof(AvoidFalseSharingAligned)), std::size_t(128));
+#endif
+}
+
+EIGEN_DECLARE_TEST(preprocessor_directives) {
+  CALL_SUBTEST_1(check_index_type());
+  CALL_SUBTEST_1(check_false_sharing_alignment());
+  CALL_SUBTEST_2(check_index_type());
+  CALL_SUBTEST_3(check_blas_index());
+  CALL_SUBTEST_4(check_false_sharing_alignment());
+}
diff --git a/test/product.h b/test/product.h
index 21b4701..f411fa9 100644
--- a/test/product.h
+++ b/test/product.h
@@ -6,8 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_PRODUCT_H
+#define EIGEN_TEST_PRODUCT_H
 
 #include "main.h"
+#include "product_test_helpers.h"
+#include "random_for_arithmetic.h"
 #include <Eigen/QR>
 
 template <typename Derived1, typename Derived2>
@@ -52,15 +58,16 @@
   /* this test covers the following files:
      Identity.h Product.h
   */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> RowVectorType;
-  typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> ColVectorType;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> RowSquareMatrixType;
-  typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, MatrixType::ColsAtCompileTime> ColSquareMatrixType;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
-                 MatrixType::Flags & RowMajorBit ? ColMajor : RowMajor>
-      OtherMajorMatrixType;
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename MatrixType::RealScalar;
+  using RowVectorType = Matrix<Scalar, MatrixType::RowsAtCompileTime, 1>;
+  using ColVectorType = Matrix<Scalar, MatrixType::ColsAtCompileTime, 1>;
+  using RowSquareMatrixType = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>;
+  using ColSquareMatrixType = Matrix<Scalar, MatrixType::ColsAtCompileTime, MatrixType::ColsAtCompileTime>;
+  using RealMatrixType = Matrix<RealScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>;
+  using RealRowSquareMatrixType = Matrix<RealScalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>;
+  using OtherMajorMatrixType = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime,
+                                      MatrixType::Flags & RowMajorBit ? ColMajor : RowMajor>;
 
   // We want a tighter epsilon for not-approx tests.  Otherwise, for certain
   // low-precision types (e.g. bfloat16), the bound ends up being relatively large
@@ -81,15 +88,24 @@
 
   // Prevent overflows for integer types.
   if (Eigen::NumTraits<Scalar>::IsInteger) {
-    Scalar kMaxVal = Scalar(10000);
+    Scalar kMaxVal = Scalar(8);
     m1.array() = m1.array() - kMaxVal * (m1.array() / kMaxVal);
     m2.array() = m2.array() - kMaxVal * (m2.array() / kMaxVal);
+    square.array() = square.array() - kMaxVal * (square.array() / kMaxVal);
+    res.array() = res.array() - kMaxVal * (res.array() / kMaxVal);
+    square2.array() = square2.array() - kMaxVal * (square2.array() / kMaxVal);
+    res2.array() = res2.array() - kMaxVal * (res2.array() / kMaxVal);
     v1.array() = v1.array() - kMaxVal * (v1.array() / kMaxVal);
+    vc2.array() = vc2.array() - kMaxVal * (vc2.array() / kMaxVal);
   }
 
   OtherMajorMatrixType tm1 = m1;
 
   Scalar s1 = internal::random<Scalar>();
+  if (Eigen::NumTraits<Scalar>::IsInteger) {
+    Scalar kMaxVal = Scalar(8);
+    s1 = s1 - kMaxVal * (s1 / kMaxVal);
+  }
 
   Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1),
         c2 = internal::random<Index>(0, cols - 1);
@@ -97,18 +113,26 @@
   // begin testing Product.h: only associativity for now
   // (we use Transpose.h but this doesn't count as a test for it)
   {
-    // Increase tolerance, since coefficients here can get relatively large.
-    RealScalar tol = RealScalar(2) * get_test_precision(m1);
-    VERIFY(verifyIsApprox((m1 * m1.transpose()) * m2, m1 * (m1.transpose() * m2), tol));
+    // Associativity: (m1 * m1^T) * m2 vs m1 * (m1^T * m2). Both sides chain two
+    // products, so each carries an error of order eps * |m1| |m1|^T |m2|, while
+    // the result itself vanishes as m1^T * m2 does. The difference must
+    // therefore be bounded against the magnitude of the intermediates, not
+    // against a multiple of the result.
+    const RealMatrixType abs_m1 = m1.cwiseAbs(), abs_m2 = m2.cwiseAbs();
+    VERIFY(verifyProduct((m1 * m1.transpose()) * m2, m1 * (m1.transpose() * m2), (abs_m1 * abs_m1.transpose()).eval(),
+                         abs_m2, 3));
   }
   m3 = m1;
   m3 *= m1.transpose() * m2;
   VERIFY_IS_APPROX(m3, m1 * (m1.transpose() * m2));
-  VERIFY_IS_APPROX(m3, m1 * (m1.transpose() * m2));
 
   // continue testing Product.h: distributivity
-  VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
-  VERIFY_IS_APPROX(square * (m1 - m2), square * m1 - square * m2);
+  {
+    // Increase tolerance, since coefficients here can get relatively large.
+    RealScalar tol = RealScalar(2) * get_test_precision(m1);
+    VERIFY(verifyIsApprox(square * (m1 + m2), square * m1 + square * m2, tol));
+    VERIFY(verifyIsApprox(square * (m1 - m2), square * m1 - square * m2, tol));
+  }
 
   // continue testing Product.h: compatibility with ScalarMultiple.h
   VERIFY_IS_APPROX(s1 * (square * m1), (s1 * square) * m1);
@@ -126,7 +150,10 @@
 
   // test the previous tests were not screwed up because operator* returns 0
   // (we use the more accurate default epsilon)
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1) {
+  // Skip non-commutativity check for very low-precision types (e.g. bfloat16) where
+  // random small matrices can produce products that are approximately equal.
+  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1 &&
+      NumTraits<RealScalar>::dummy_precision() < RealScalar(0.04)) {
     VERIFY(areNotApprox(m1.transpose() * m2, m2.transpose() * m1, not_approx_epsilon));
   }
 
@@ -134,7 +161,8 @@
   res = square;
   res.noalias() += m1 * m2.transpose();
   VERIFY_IS_APPROX(res, square + m1 * m2.transpose());
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1) {
+  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1 &&
+      NumTraits<RealScalar>::dummy_precision() < RealScalar(0.04)) {
     VERIFY(areNotApprox(res, square + m2 * m1.transpose(), not_approx_epsilon));
   }
   vcres = vc2;
@@ -145,7 +173,8 @@
   res = square;
   res.noalias() -= m1 * m2.transpose();
   VERIFY_IS_APPROX(res, square - (m1 * m2.transpose()));
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1) {
+  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1 &&
+      NumTraits<RealScalar>::dummy_precision() < RealScalar(0.04)) {
     VERIFY(areNotApprox(res, square - m2 * m1.transpose(), not_approx_epsilon));
   }
   vcres = vc2;
@@ -179,21 +208,35 @@
   res.noalias() -= square - m1 * m2.transpose();
   VERIFY_IS_APPROX(res, square - m1 * m2.transpose());
 
-  tm1 = m1;
-  VERIFY_IS_APPROX(tm1.transpose() * v1, m1.transpose() * v1);
-  VERIFY_IS_APPROX(v1.transpose() * tm1, v1.transpose() * m1);
+  // Row-major vs col-major GEMV: different accumulation orders produce
+  // rounding differences bounded by O(sqrt(n)) * epsilon per inner product.
+  // tm1.transpose() * v1 has inner dimension rows; v1^T * tm1 has inner dim cols.
+  {
+    RealScalar gemv_tol = (std::max)(get_test_precision(m1),
+                                     numext::sqrt(RealScalar((std::max)(rows, cols))) * NumTraits<Scalar>::epsilon());
+    tm1 = m1;
+    VERIFY(verifyIsApprox(tm1.transpose() * v1, m1.transpose() * v1, gemv_tol));
+    VERIFY(verifyIsApprox(v1.transpose() * tm1, v1.transpose() * m1, gemv_tol));
+  }
 
   // test submatrix and matrix/vector product
-  for (int i = 0; i < rows; ++i) res.row(i) = m1.row(i) * m2.transpose();
-  VERIFY_IS_APPROX(res, m1 * m2.transpose());
-  // the other way round:
-  for (int i = 0; i < rows; ++i) res.col(i) = m1 * m2.transpose().col(i);
-  VERIFY_IS_APPROX(res, m1 * m2.transpose());
+  // Row-by-row vs full GEMM: different evaluation strategies can differ
+  // by O(sqrt(n)) * epsilon for low-precision types.
+  {
+    RealScalar prod_tol =
+        (std::max)(get_test_precision(m1), numext::sqrt(RealScalar(cols)) * NumTraits<Scalar>::epsilon());
+    for (int i = 0; i < rows; ++i) res.row(i) = m1.row(i) * m2.transpose();
+    VERIFY(verifyIsApprox(res, m1 * m2.transpose(), prod_tol));
+    // the other way round:
+    for (int i = 0; i < rows; ++i) res.col(i) = m1 * m2.transpose().col(i);
+    VERIFY(verifyIsApprox(res, m1 * m2.transpose(), prod_tol));
+  }
 
   res2 = square2;
   res2.noalias() += m1.transpose() * m2;
   VERIFY_IS_APPROX(res2, square2 + m1.transpose() * m2);
-  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1) {
+  if (!NumTraits<Scalar>::IsInteger && (std::min)(rows, cols) > 1 &&
+      NumTraits<RealScalar>::dummy_precision() < RealScalar(0.04)) {
     VERIFY(areNotApprox(res2, square2 + m2.transpose() * m1, not_approx_epsilon));
   }
 
@@ -272,12 +315,12 @@
   // Aliasing
   {
     ColVectorType x(cols);
-    x.setRandom();
+    x = random_for_arithmetic<ColVectorType>(cols);
     ColVectorType z(x);
     ColVectorType y(cols);
     y.setZero();
     ColSquareMatrixType A(cols, cols);
-    A.setRandom();
+    A = random_for_arithmetic<ColSquareMatrixType>(cols, cols);
     // CwiseBinaryOp
     VERIFY_IS_APPROX(x = y + A * x, A * z);
     x = z;
@@ -289,20 +332,26 @@
 
   // regression for blas_trais
   {
-    // Increase test tolerance, since coefficients can get relatively large.
-    RealScalar tol = RealScalar(2) * get_test_precision(square);
-    VERIFY(
-        verifyIsApprox(square * (square * square).transpose(), square * square.transpose() * square.transpose(), tol));
-    VERIFY(verifyIsApprox(square * (-(square * square)), -square * square * square, tol));
-    VERIFY(verifyIsApprox(square * (s1 * (square * square)), s1 * square * square * square, tol));
-    VERIFY(
-        verifyIsApprox(square * (square * square).conjugate(), square * square.conjugate() * square.conjugate(), tol));
+    // Triple products of rows x rows matrices, each side chaining two or three
+    // products. As above, the error scales with the magnitude of the
+    // intermediates. Conjugation leaves that magnitude at |square|^3;
+    // transposition keeps every entry's magnitude but reorders the chain, so
+    // square * (square * square)^T is bounded by |square| * (|square|^2)^T.
+    const RealRowSquareMatrixType abs_sq = square.cwiseAbs();
+    const RealRowSquareMatrixType abs_sq2 = abs_sq * abs_sq;
+    VERIFY(verifyProduct(square * (square * square).transpose(), square * square.transpose() * square.transpose(),
+                         abs_sq, abs_sq2.transpose(), 4));
+    VERIFY(verifyProduct(square * (-(square * square)), -square * square * square, abs_sq2, abs_sq, 4));
+    VERIFY(verifyProduct(square * (s1 * (square * square)), s1 * square * square * square, abs_sq2,
+                         (numext::abs(s1) * abs_sq).eval(), 4));
+    VERIFY(verifyProduct(square * (square * square).conjugate(), square * square.conjugate() * square.conjugate(),
+                         abs_sq2, abs_sq, 4));
   }
 
   // destination with a non-default inner-stride
   // see bug 1741
   if (!MatrixType::IsRowMajor) {
-    typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+    using MatrixX = Matrix<Scalar, Dynamic, Dynamic>;
     MatrixX buffer(2 * rows, 2 * rows);
     Map<RowSquareMatrixType, 0, Stride<Dynamic, 2> > map1(buffer.data(), rows, rows, Stride<Dynamic, 2>(2 * rows, 2));
     buffer.setZero();
@@ -313,3 +362,5 @@
     VERIFY_IS_APPROX(map1.noalias() += m1 * m2.transpose(), (m1 * m2.transpose()).eval());
   }
 }
+
+#endif  // EIGEN_TEST_PRODUCT_H
diff --git a/test/product_evaluators.cpp b/test/product_evaluators.cpp
new file mode 100644
index 0000000..f07e5bc
--- /dev/null
+++ b/test/product_evaluators.cpp
@@ -0,0 +1,153 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/Core>
+
+template <typename ProductType, typename Mat>
+void check_scaled_product(const ProductType& product, const Mat& expected) {
+  Mat actual = product;
+  VERIFY_IS_EQUAL(actual, expected);
+  actual = product + Mat::Zero(expected.rows(), expected.cols());
+  VERIFY_IS_EQUAL(actual, expected);
+  actual.setZero();
+  actual.noalias() += product;
+  VERIFY_IS_EQUAL(actual, expected);
+  actual.noalias() -= product;
+  VERIFY_IS_EQUAL(actual, Mat::Zero(expected.rows(), expected.cols()));
+  Mat triangle = Mat::Constant(expected.rows(), expected.cols(), typename Mat::Scalar(7));
+  Mat triangleExpected = triangle;
+  triangle.template triangularView<Upper>() = product;
+  triangleExpected.template triangularView<Upper>() = expected;
+  VERIFY_IS_EQUAL(triangle, triangleExpected);
+  triangle.template triangularView<Lower>() = product;
+  triangleExpected.template triangularView<Lower>() = expected;
+  VERIFY_IS_EQUAL(triangle, triangleExpected);
+}
+
+template <typename Scalar, int Mode, int Order>
+void scaled_unit_triangular_product() {
+  using Mat = Matrix<Scalar, 3, 3, Order>;
+  Mat matrix;
+  matrix << 9, 2, 3, 4, 9, 6, 7, 8, 9;
+  const Mat rhs = Mat::Constant(2);
+  const Matrix<Scalar, 3, 1> diagonal = Matrix<Scalar, 3, 1>::Constant(2);
+  Mat expected = Mat::Zero(), expectedDiagonal = Mat::Zero();
+  for (Index j = 0; j < 3; ++j) {
+    for (Index i = 0; i < 3; ++i) {
+      for (Index k = 0; k < 3; ++k) {
+        const bool stored = Mode == UnitLower ? i > k : i < k;
+        const Scalar value = i == k ? Scalar(1) : stored ? matrix(i, k) : Scalar(0);
+        expected(i, j) += Scalar(3) * value * rhs(k, j);
+      }
+      const bool stored = Mode == UnitLower ? i > j : i < j;
+      expectedDiagonal(i, j) = Scalar(3) * (i == j ? Scalar(1) : stored ? matrix(i, j) : Scalar(0)) * diagonal(j);
+    }
+  }
+  check_scaled_product(Scalar(3) * (matrix.template triangularView<Mode>() * rhs), expected);
+  check_scaled_product(Scalar(3) * (matrix.template triangularView<Mode>() * diagonal.asDiagonal()), expectedDiagonal);
+  Mat aliased = matrix;
+  aliased = Scalar(3) * (aliased.template triangularView<Mode>() * rhs);
+  VERIFY_IS_EQUAL(aliased, expected);
+}
+
+template <typename Scalar, int Order>
+void scaled_permutation_product() {
+  using Mat = Matrix<Scalar, 3, 3, Order>;
+  Mat matrix;
+  matrix << 1, 2, 3, 4, 5, 6, 7, 8, 9;
+  PermutationMatrix<3> permutation;
+  permutation.indices() << 2, 0, 1;
+  Mat expected;
+  for (Index j = 0; j < 3; ++j)
+    for (Index i = 0; i < 3; ++i) expected(permutation.indices()(i), j) = Scalar(3) * matrix(i, j);
+  check_scaled_product(Scalar(3) * (permutation * matrix), expected);
+  Mat aliased = matrix;
+  aliased = Scalar(3) * (permutation * aliased);
+  VERIFY_IS_EQUAL(aliased, expected);
+  for (Index j = 0; j < 3; ++j)
+    for (Index i = 0; i < 3; ++i) expected(i, j) = Scalar(3) * matrix(permutation.indices()(i), j);
+  check_scaled_product(Scalar(3) * (permutation.inverse() * matrix), expected);
+}
+
+template <int Order>
+void scaled_structured_product() {
+  using Scalar = std::complex<double>;
+  using Mat = Matrix<Scalar, 3, 3, Order>;
+  Mat matrix;
+  matrix << Scalar(1), Scalar(2, 1), Scalar(3, 2), Scalar(4, 3), Scalar(5), Scalar(6, 4), Scalar(7, 5), Scalar(8, 6),
+      Scalar(9);
+  const Scalar alpha(2, 3);
+  const Mat rhs = Mat::Constant(Scalar(2, 1));
+  const Matrix<Scalar, 3, 1> diagonal = Matrix<Scalar, 3, 1>::Constant(Scalar(3, 2));
+  Mat expected;
+  for (Index j = 0; j < 3; ++j)
+    for (Index i = 0; i < 3; ++i) expected(i, j) = alpha * (diagonal(i) * matrix(i, j));
+  check_scaled_product(alpha * (diagonal.asDiagonal() * matrix), expected);
+  const DiagonalMatrix<Scalar, 3> ownedDiagonal(diagonal);
+  check_scaled_product(alpha * (ownedDiagonal * matrix), expected);
+
+  expected.setZero();
+  for (Index j = 0; j < 3; ++j)
+    for (Index i = 0; i < 3; ++i)
+      for (Index k = 0; k <= i; ++k) expected(i, j) += alpha * (matrix(i, k) * rhs(k, j));
+  check_scaled_product(alpha * (matrix.template triangularView<Lower>() * rhs), expected);
+
+  expected.setZero();
+  for (Index j = 0; j < 3; ++j)
+    for (Index i = 0; i < 3; ++i)
+      for (Index k = 0; k < 3; ++k) {
+        const Scalar value = i >= k ? matrix(i, k) : numext::conj(matrix(k, i));
+        expected(i, j) += alpha * (value * rhs(k, j));
+      }
+  check_scaled_product(alpha * (matrix.template selfadjointView<Lower>() * rhs), expected);
+}
+
+template <int Mode, int Order>
+void scaled_selfadjoint_diagonal_product() {
+  using Scalar = std::complex<double>;
+  using Mat = Matrix<Scalar, 3, 3, Order>;
+  Mat matrix;
+  matrix << Scalar(1), Scalar(2, 1), Scalar(3, 2), Scalar(4, 3), Scalar(5), Scalar(6, 4), Scalar(7, 5), Scalar(8, 6),
+      Scalar(9);
+  Matrix<Scalar, 3, 1> diagonal;
+  diagonal << Scalar(1, -1), Scalar(2, 3), Scalar(-4, 2);
+  const Scalar alpha(2, 3);
+  Mat expected, expectedLeft;
+  for (Index j = 0; j < 3; ++j) {
+    for (Index i = 0; i < 3; ++i) {
+      const bool stored = Mode == Lower ? i >= j : i <= j;
+      const Scalar value = stored ? matrix(i, j) : numext::conj(matrix(j, i));
+      expected(i, j) = alpha * (value * diagonal(j));
+      expectedLeft(i, j) = alpha * (diagonal(i) * value);
+    }
+  }
+  check_scaled_product(alpha * (matrix.template selfadjointView<Mode>() * diagonal.asDiagonal()), expected);
+  const DiagonalMatrix<Scalar, 3> ownedDiagonal(diagonal);
+  check_scaled_product(alpha * (matrix.template selfadjointView<Mode>() * ownedDiagonal), expected);
+  check_scaled_product(alpha * (diagonal.asDiagonal() * matrix.template selfadjointView<Mode>()), expectedLeft);
+  Mat aliased = matrix;
+  aliased = alpha * (aliased.template selfadjointView<Mode>() * diagonal.asDiagonal()) + Mat::Zero();
+  VERIFY_IS_EQUAL(aliased, expected);
+}
+
+EIGEN_DECLARE_TEST(product_evaluators) {
+  for (int repeat = 0; repeat < g_repeat; ++repeat) {
+    CALL_SUBTEST_1((scaled_unit_triangular_product<double, UnitLower, ColMajor>()));
+    CALL_SUBTEST_1((scaled_unit_triangular_product<double, UnitLower, RowMajor>()));
+    CALL_SUBTEST_1((scaled_unit_triangular_product<double, UnitUpper, ColMajor>()));
+    CALL_SUBTEST_1((scaled_unit_triangular_product<double, UnitUpper, RowMajor>()));
+    CALL_SUBTEST_1((scaled_unit_triangular_product<std::complex<double>, UnitLower, ColMajor>()));
+    CALL_SUBTEST_1((scaled_unit_triangular_product<std::complex<double>, UnitUpper, RowMajor>()));
+    CALL_SUBTEST_2((scaled_permutation_product<double, ColMajor>()));
+    CALL_SUBTEST_2((scaled_permutation_product<double, RowMajor>()));
+    CALL_SUBTEST_2((scaled_permutation_product<std::complex<double>, ColMajor>()));
+    CALL_SUBTEST_2((scaled_permutation_product<std::complex<double>, RowMajor>()));
+    CALL_SUBTEST_3((scaled_structured_product<ColMajor>()));
+    CALL_SUBTEST_3((scaled_structured_product<RowMajor>()));
+    CALL_SUBTEST_3((scaled_selfadjoint_diagonal_product<Lower, ColMajor>()));
+    CALL_SUBTEST_3((scaled_selfadjoint_diagonal_product<Lower, RowMajor>()));
+    CALL_SUBTEST_3((scaled_selfadjoint_diagonal_product<Upper, ColMajor>()));
+    CALL_SUBTEST_3((scaled_selfadjoint_diagonal_product<Upper, RowMajor>()));
+  }
+}
diff --git a/test/product_extra.cpp b/test/product_extra.cpp
index 1e3c665..90555e7 100644
--- a/test/product_extra.cpp
+++ b/test/product_extra.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -67,9 +68,6 @@
   VERIFY_IS_APPROX((s1 * v1.conjugate()) * (-m1.conjugate() * s2),
                    (s1 * v1.conjugate()).eval() * (-m1.conjugate() * s2).eval());
 
-  VERIFY_IS_APPROX((-m1.adjoint() * s2) * (s1 * v1.adjoint()),
-                   (-m1.adjoint() * s2).eval() * (s1 * v1.adjoint()).eval());
-
   // test the vector-matrix product with non aligned starts
   Index i = internal::random<Index>(0, m1.rows() - 2);
   Index j = internal::random<Index>(0, m1.cols() - 2);
@@ -129,7 +127,7 @@
 void zero_sized_objects(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
   const int PacketSize = internal::packet_traits<Scalar>::size;
-  const int PacketSize1 = PacketSize > 1 ? PacketSize - 1 : 1;
+  constexpr int PacketSize1 = PacketSize > 1 ? PacketSize - 1 : 1;
   Index rows = m.rows();
   Index cols = m.cols();
 
@@ -217,6 +215,13 @@
 }
 
 template <int>
+void triangular_product_assignment_size_mismatch() {
+  MatrixXd m1 = MatrixXd::Random(5, 5);
+  MatrixXd m2(6, 6);
+  VERIFY_RAISES_ASSERT(m2.triangularView<Lower>() = m1 * m1);
+}
+
+template <int>
 void unaligned_objects() {
   // Regression test for the bug reported here:
   // http://forum.kde.org/viewtopic.php?f=74&t=107541
@@ -651,7 +656,148 @@
   (void)PS_d;
 }
 
+// Locks the BLAS contract that GEMM/GEMV leave the destination unchanged when
+// alpha == 0, including under non-finite inputs in A/x/B that would otherwise
+// taint the result via 0 * Inf = NaN.
+// A zero scalar factor must leave the destination untouched for every
+// assignment form: += and -= return early, while = zeroes the destination.
+// Inf/NaN operands make a kernel that ran anyway visible as a NaN.
+template <typename Scalar, int Order>
+void alpha_zero_skips_gemm(Index m, Index k, Index n) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, Order> Mat;
+
+  const Scalar pos_zero = Scalar(0);
+  const Scalar neg_zero = Scalar(-RealScalar(0));
+
+  Mat A = Mat::Random(m, k);
+  Mat B = Mat::Random(k, n);
+  A(0, 0) = Scalar(NumTraits<RealScalar>::infinity());
+  B(1, 1) = Scalar(NumTraits<RealScalar>::quiet_NaN());
+
+  const Mat C_ref = Mat::Random(m, n);
+  const Mat zero = Mat::Zero(m, n);
+
+  for (const Scalar& alpha : {pos_zero, neg_zero}) {
+    Mat C = C_ref;
+    C.noalias() += alpha * A * B;
+    VERIFY_IS_CWISE_EQUAL(C, C_ref);
+
+    C = C_ref;
+    C.noalias() -= alpha * A * B;
+    VERIFY_IS_CWISE_EQUAL(C, C_ref);
+
+    C = C_ref;
+    C.noalias() = alpha * A * B;
+    VERIFY_IS_CWISE_EQUAL(C, zero);
+  }
+}
+
+template <typename Scalar>
+void alpha_zero_skips_kernel() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> ColMat;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMat;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+
+  const Index m = 17, k = 13, n = 11;
+  const Scalar inf = Scalar(NumTraits<RealScalar>::infinity());
+  const Scalar nan = Scalar(NumTraits<RealScalar>::quiet_NaN());
+  const Scalar pos_zero = Scalar(0);
+  const Scalar neg_zero = Scalar(-RealScalar(0));
+
+  // GEMM, both storage orders. 17x13x11 sums to 41 and so takes the GEMM path
+  // on a default build; 5x5x5 sums to 15 and reaches the coeff-based path,
+  // which has its own zero-factor exit. Without the small shape the latter is
+  // only covered where the threshold is raised (SME), i.e. by one nightly job.
+  alpha_zero_skips_gemm<Scalar, ColMajor>(m, k, n);
+  alpha_zero_skips_gemm<Scalar, ColMajor>(5, 5, 5);
+  alpha_zero_skips_gemm<Scalar, RowMajor>(m, k, n);
+  alpha_zero_skips_gemm<Scalar, RowMajor>(5, 5, 5);
+
+  // GEMV col-major.
+  {
+    ColMat A = ColMat::Random(m, k);
+    Vec x = Vec::Random(k);
+    A(0, 0) = inf;
+    x(1) = nan;
+
+    Vec y = Vec::Random(m);
+    const Vec y_ref = y;
+
+    y.noalias() += pos_zero * (A * x);
+    VERIFY_IS_CWISE_EQUAL(y, y_ref);
+
+    y.noalias() += neg_zero * (A * x);
+    VERIFY_IS_CWISE_EQUAL(y, y_ref);
+  }
+
+  // GEMV row-major.
+  {
+    RowMat A = RowMat::Random(m, k);
+    Vec x = Vec::Random(k);
+    A(0, 0) = inf;
+    x(1) = nan;
+
+    Vec y = Vec::Random(m);
+    const Vec y_ref = y;
+
+    y.noalias() += pos_zero * (A * x);
+    VERIFY_IS_CWISE_EQUAL(y, y_ref);
+
+    y.noalias() += neg_zero * (A * x);
+    VERIFY_IS_CWISE_EQUAL(y, y_ref);
+  }
+}
+
+template <typename RealScalar, int Options>
+void complex_gemm_scalar_accumulation() {
+  using Scalar = std::complex<RealScalar>;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Options>;
+  for (Index n : {5, 8, 9}) {
+    Matrix<Scalar, Dynamic, Dynamic> lhs(n, n);
+    Matrix<Scalar, Dynamic, Dynamic, RowMajor> rhs(n, n);
+    for (Index j = 0; j < n; ++j) {
+      for (Index i = 0; i < n; ++i) {
+        lhs(i, j) = Scalar(RealScalar((i + j) % 5 - 2), RealScalar((2 * i + j) % 3 - 1));
+        rhs(i, j) = Scalar(RealScalar((i + 2 * j) % 3 - 1), RealScalar((i + j) % 5 - 2));
+      }
+    }
+    const auto check = [&](const auto& a, const auto& b) {
+      MatrixType expected = MatrixType::Zero(n, n);
+      for (Index j = 0; j < n; ++j)
+        for (Index i = 0; i < n; ++i)
+          for (Index k = 0; k < n; ++k) expected(i, j) += a.coeff(i, k) * b.coeff(k, j);
+      MatrixType actual(n, n);
+      actual.noalias() = a * b;
+      VERIFY_IS_EQUAL(actual, expected);
+      // Integer components keep every operation exact, including a non-real alpha.
+      const Scalar alpha(2, -1);
+      actual.setOnes();
+      actual.noalias() += alpha * (a * b);
+      VERIFY_IS_EQUAL(actual, MatrixType(MatrixType::Ones(n, n) + alpha * expected));
+      VERIFY_IS_EQUAL((expected - a * b).cwiseAbs().maxCoeff(), RealScalar(0));
+    };
+    check(lhs, rhs);
+    check(lhs.conjugate(), rhs);
+    check(lhs, rhs.conjugate());
+    check(lhs.conjugate(), rhs.conjugate());
+  }
+
+  const MatrixType u = MatrixType::Identity(8, 8) * Scalar(0, 1);
+  const MatrixType t = MatrixType::Constant(8, 8, Scalar(0, 1));
+  VERIFY_IS_EQUAL((t - u * t * u.adjoint()).cwiseAbs().maxCoeff(), RealScalar(0));
+}
+
 EIGEN_DECLARE_TEST(product_extra) {
+  CALL_SUBTEST_13((complex_gemm_scalar_accumulation<float, ColMajor>()));
+  CALL_SUBTEST_13((complex_gemm_scalar_accumulation<float, RowMajor>()));
+  CALL_SUBTEST_13((complex_gemm_scalar_accumulation<double, ColMajor>()));
+  CALL_SUBTEST_13((complex_gemm_scalar_accumulation<double, RowMajor>()));
+#ifndef EIGEN_TEST_NO_LONGDOUBLE
+  CALL_SUBTEST_13((complex_gemm_scalar_accumulation<long double, ColMajor>()));
+  CALL_SUBTEST_13((complex_gemm_scalar_accumulation<long double, RowMajor>()));
+#endif
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(product_extra(
         MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
@@ -666,6 +812,7 @@
         MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
   }
   CALL_SUBTEST_5(bug_127<0>());
+  CALL_SUBTEST_5(triangular_product_assignment_size_mismatch<0>());
   CALL_SUBTEST_5(bug_817<0>());
   CALL_SUBTEST_5(bug_1308<0>());
   CALL_SUBTEST_6(unaligned_objects<0>());
@@ -678,4 +825,10 @@
 
   // Complex GEMV conjugation at varied sizes (deterministic, outside g_repeat).
   CALL_SUBTEST_11(gemv_complex_conjugate<0>());
+
+  // alpha==0 fast path: GEMM/GEMV must leave the destination unchanged.
+  CALL_SUBTEST_12(alpha_zero_skips_kernel<float>());
+  CALL_SUBTEST_12(alpha_zero_skips_kernel<double>());
+  CALL_SUBTEST_12(alpha_zero_skips_kernel<std::complex<float> >());
+  CALL_SUBTEST_12(alpha_zero_skips_kernel<std::complex<double> >());
 }
diff --git a/test/product_large.cpp b/test/product_large.cpp
index 2fdc261..1a5ceab 100644
--- a/test/product_large.cpp
+++ b/test/product_large.cpp
@@ -6,10 +6,44 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "product.h"
 #include <Eigen/LU>
 
+#if (defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)) && defined(__unix__)
+#include <sys/mman.h>
+#include <unistd.h>
+
+template <int>
+void gemv_bfloat16_strided_tail() {
+  using MatrixType = Matrix<bfloat16, Dynamic, Dynamic, RowMajor>;
+  using VectorType = Matrix<bfloat16, Dynamic, 1>;
+  const long page_size = sysconf(_SC_PAGESIZE);
+  VERIFY(page_size > 0);
+  char* storage =
+      static_cast<char*>(mmap(nullptr, 2 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  VERIFY(storage != MAP_FAILED);
+  VERIFY_IS_EQUAL(mprotect(storage + page_size, page_size, PROT_NONE), 0);
+
+  // Put the last result coefficient against an inaccessible page: even one excess gather must fail.
+  for (Index rows : {1, 2, 3, 4, 5, 7, 8, 9, 12, 15, 16, 17, 31, 32, 33}) {
+    for (Index stride : {1, 2, 3, 17}) {
+      const Index span = (rows - 1) * stride + 1;
+      VERIFY(span * Index(sizeof(bfloat16)) <= page_size);
+      bfloat16* values = reinterpret_cast<bfloat16*>(storage + page_size - span * sizeof(bfloat16));
+      for (Index i = 0; i < rows; ++i) new (values + i * stride) bfloat16(1);
+      Map<VectorType, 0, InnerStride<Dynamic>> result(values, rows, InnerStride<Dynamic>(stride));
+      const MatrixType A = MatrixType::Ones(rows, 65);
+      const VectorType x = VectorType::Ones(65);
+      result.noalias() += A * x;
+      VERIFY_IS_CWISE_EQUAL(result, VectorType::Constant(rows, bfloat16(66)));
+    }
+  }
+  VERIFY_IS_EQUAL(munmap(storage, 2 * page_size), 0);
+}
+#endif
+
 template <typename T>
 void test_aliasing() {
   int rows = internal::random<int>(1, 12);
@@ -54,17 +88,38 @@
   {
     // check the functions to setup blocking sizes compile and do not segfault
     // FIXME check they do what they are supposed to do !!
+    std::ptrdiff_t old_l1 = l1CacheSize();
+    std::ptrdiff_t old_l2 = l2CacheSize();
+    std::ptrdiff_t old_l3 = l3CacheSize();
     std::ptrdiff_t l1 = internal::random<int>(10000, 20000);
     std::ptrdiff_t l2 = internal::random<int>(100000, 200000);
     std::ptrdiff_t l3 = internal::random<int>(1000000, 2000000);
     setCpuCacheSizes(l1, l2, l3);
     VERIFY(l1 == l1CacheSize());
     VERIFY(l2 == l2CacheSize());
-    std::ptrdiff_t k1 = internal::random<int>(10, 100) * 16;
-    std::ptrdiff_t m1 = internal::random<int>(10, 100) * 16;
-    std::ptrdiff_t n1 = internal::random<int>(10, 100) * 16;
-    // only makes sure it compiles fine
-    internal::computeProductBlockingSizes<float, float, std::ptrdiff_t>(k1, m1, n1, 1);
+
+    // Regression test for small synthetic caches with AVX512 and multiple threads.
+    // The L2 model can report that fewer than one nr-wide RHS panel fits.
+    setCpuCacheSizes(10000, 100000, 1000000);
+    std::ptrdiff_t k2 = 5000;
+    std::ptrdiff_t m2 = 5000;
+    std::ptrdiff_t n2 = 256;
+    internal::computeProductBlockingSizes<double, double, std::ptrdiff_t>(k2, m2, n2, 32);
+    VERIFY(k2 > 0);
+    VERIFY(m2 > 0);
+    VERIFY(n2 > 0);
+
+    // An explicit override has to govern blocking on its own. The detected per-CPU L3 share also
+    // feeds the rhs-panel budget, so leaving it set would silently overrule callers that force
+    // small cache sizes to exercise multi-pass blocking (contrib/test/tensor_contraction.cpp
+    // does exactly that).
+    setCpuCacheSizes(896, 1920, 2944);
+    std::ptrdiff_t forced_l1, forced_l2, forced_l3, forced_l3_per_cpu = -1;
+    internal::manage_caching_sizes(GetAction, &forced_l1, &forced_l2, &forced_l3, &forced_l3_per_cpu);
+    VERIFY(forced_l1 == 896 && forced_l2 == 1920 && forced_l3 == 2944);
+    VERIFY(forced_l3_per_cpu == 0);
+
+    setCpuCacheSizes(old_l1, old_l2, old_l3);
   }
 
   {
@@ -101,60 +156,22 @@
 // matrices, since the Householder application uses row-major GEMV internally.
 template <int>
 void bug_gemv_rowmajor_large_stride() {
-  // Direct GEMV test: row-major A with stride (= cols) triggering n8=0.
-  // The threshold is stride * sizeof(Scalar) > 32000.
-  // For double: cols > 4000. For float: cols > 8000.
-  {
-    const int rows = 100;
-    const int cols = 5000;  // cols * sizeof(double) = 40000 > 32000
-    Matrix<double, Dynamic, Dynamic, RowMajor> A(rows, cols);
-    A.setRandom();
-    VectorXd x = VectorXd::Random(cols);
-    VectorXd y = A * x;
-    VectorXd y_ref = VectorXd::Zero(rows);
-    for (int i = 0; i < rows; ++i)
-      for (int j = 0; j < cols; ++j) y_ref(i) += A(i, j) * x(j);
-    VERIFY_IS_APPROX(y, y_ref);
-  }
-
-  // QR orthogonality test: this is the high-level symptom.
-  // HouseholderQR of a col-major (m x n) matrix with m > 4000
-  // uses row-major GEMV internally during Householder application.
-  {
-    const int m = 5000;
-    const int n = 50;
-    MatrixXd A = MatrixXd::Random(m, n);
-    MatrixXd Q = A.householderQr().householderQ() * MatrixXd::Identity(m, n);
-    MatrixXd QtQ = Q.adjoint() * Q;
-    VERIFY_IS_APPROX(QtQ, MatrixXd::Identity(n, n));
-  }
-}
-
-// Regression test for row-major GEMV run_small_cols bug.
-// When cols is small (e.g., 2), and loop variables (like n8) are 0 due
-// to row or stride limits, the remainder loops previously used `if` checks
-// like `if (i < n4)`. This incorrectly skips rows if multiple remainder
-// blocks are needed (e.g., 9 rows).
-template <int>
-void bug_gemv_run_small_cols() {
-  const int rows = 9;       // > 8, covers 8-row loop step but tests remainder cleanup
-  const int cols = 2;       // triggers run_small_cols (cols < PacketSize)
-  const int stride = 5000;  // 5000 * sizeof(double) > 32000, forces n8 = 0
-
-  Matrix<double, Dynamic, Dynamic, RowMajor> A_full(rows, stride);
-  A_full.setRandom();
-  auto A = A_full.leftCols(cols);
-
-  VectorXd x = VectorXd::Random(cols);
-  VectorXd y = A * x;
-  VectorXd y_ref = A.eval() * x;  // No stride.
-
-  VERIFY_IS_APPROX(y, y_ref);
+  // HouseholderQR of a col-major (m x n) matrix with m > 4000 uses row-major GEMV
+  // internally during Householder application. The direct GEMV check at this stride
+  // is gemv_rowmajor_large_stride_varied_rows.
+  const int m = 5000;
+  const int n = 50;
+  MatrixXd A = MatrixXd::Random(m, n);
+  MatrixXd Q = A.householderQr().householderQ() * MatrixXd::Identity(m, n);
+  MatrixXd QtQ = Q.adjoint() * Q;
+  VERIFY_IS_APPROX(QtQ, MatrixXd::Identity(n, n));
 }
 
 // Systematic test of row-major GEMV run_small_cols and main run() remainder paths.
 // Varies cols from 1-7 (covers float PacketSize=8 and double PacketSize=4 boundaries)
-// and rows across values that exercise all n8/n4/n2/n1 remainder combinations.
+// and rows across values that exercise all n8/n4/n2/n1 remainder combinations. The
+// large-stride block covers the run_small_cols regression where remainder loops used
+// `if (i < n4)` and skipped rows once several remainder blocks were needed (rows = 9).
 template <int>
 void gemv_small_cols_systematic() {
   const int test_cols[] = {1, 2, 3, 4, 5, 6, 7};
@@ -318,6 +335,9 @@
 }
 
 EIGEN_DECLARE_TEST(product_large) {
+#if (defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)) && defined(__unix__)
+  CALL_SUBTEST_11(gemv_bfloat16_strided_tail<0>());
+#endif
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(product(
         MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
@@ -352,7 +372,6 @@
 
   CALL_SUBTEST_6(product_large_regressions<0>());
   CALL_SUBTEST_6(bug_gemv_rowmajor_large_stride<0>());
-  CALL_SUBTEST_6(bug_gemv_run_small_cols<0>());
   CALL_SUBTEST_6(gemv_small_cols_systematic<0>());
   CALL_SUBTEST_6(gemv_rowmajor_large_stride_varied_rows<0>());
   CALL_SUBTEST_6(product_extreme_aspect_ratios<0>());
diff --git a/test/product_mmtr.cpp b/test/product_mmtr.cpp
index f177b69..70fbd30 100644
--- a/test/product_mmtr.cpp
+++ b/test/product_mmtr.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -101,11 +102,43 @@
   }
 }
 
+template <typename MatrixType>
+void mmtr_empty_product(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> LhsType;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RhsType;
+
+  LhsType lhs(size, 0);
+  RhsType rhs(0, size);
+
+  MatrixType dst = MatrixType::Random(size, size);
+  MatrixType ref = dst;
+
+  dst.template triangularView<Lower>() += lhs * rhs;
+  VERIFY_IS_APPROX(dst, ref);
+
+  dst.template triangularView<Upper>() -= lhs * rhs;
+  VERIFY_IS_APPROX(dst, ref);
+
+  dst.template triangularView<Lower>() = lhs * rhs;
+  ref.template triangularView<Lower>().setZero();
+  VERIFY_IS_APPROX(dst, ref);
+
+  dst = MatrixType::Random(size, size);
+  ref = dst;
+  dst.template selfadjointView<Lower>() = lhs * rhs;
+  ref.template triangularView<Lower>().setZero();
+  VERIFY_IS_APPROX(dst, ref);
+}
+
 EIGEN_DECLARE_TEST(product_mmtr) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1((mmtr<float>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_2((mmtr<double>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_3((mmtr<std::complex<float> >(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
     CALL_SUBTEST_4((mmtr<std::complex<double> >(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
+
+    CALL_SUBTEST_5((mmtr_empty_product<MatrixXd>(48)));
+    CALL_SUBTEST_6((mmtr_empty_product<Matrix<double, Dynamic, Dynamic, RowMajor> >(48)));
   }
 }
diff --git a/test/product_notemporary.cpp b/test/product_notemporary.cpp
index 84ce3c6..6dbe4f3 100644
--- a/test/product_notemporary.cpp
+++ b/test/product_notemporary.cpp
@@ -6,11 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 #define TEST_IGNORE_STACK_ALLOCATED_TEMPORARY
+#define EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
 
 #include "main.h"
+#include "AnnoyingScalar.h"
 
 template <typename Dst, typename Lhs, typename Rhs>
 void check_scalar_multiple3(Dst& dst, const Lhs& A, const Rhs& B) {
@@ -108,6 +111,11 @@
 
   VERIFY_EVALUATION_COUNT(m3.template triangularView<Upper>() = (m1 * m2.adjoint()), 0);
   VERIFY_EVALUATION_COUNT(m3.template triangularView<Upper>() -= (m1 * m2.adjoint()), 0);
+  VERIFY_EVALUATION_COUNT(m3.template selfadjointView<Lower>() = m1.template triangularView<Upper>(), 0);
+  VERIFY_EVALUATION_COUNT(m3.template selfadjointView<Upper>() = m1.template selfadjointView<Lower>(), 0);
+  VERIFY_EVALUATION_COUNT(m3.template selfadjointView<Lower>() =
+                              s1 * m1.template selfadjointView<Lower>() + m2.template selfadjointView<Lower>(),
+                          0);
 
   // NOTE this is because the blas_traits require innerstride==1 to avoid a temporary, but that doesn't seem to be
   // actually needed for the triangular products
@@ -208,17 +216,48 @@
   }
 }
 
+template <int Size>
+void triangular_product_with_initialized_scalar() {
+  constexpr Index kSize = 6;
+  using MatrixType = Matrix<AnnoyingScalar, Size, Size, RowMajor>;
+  using RhsStorage = Matrix<AnnoyingScalar, Size, 2, RowMajor>;
+  using ResultType = Matrix<AnnoyingScalar, Size, 1>;
+
+  const int initial_instances = AnnoyingScalar::instances;
+  {
+    MatrixType lhs(kSize, kSize);
+    RhsStorage rhs_storage(kSize, 2);
+    ResultType result(kSize);
+    lhs.setOnes();
+    rhs_storage.setZero();
+    for (Index i = 0; i < kSize; ++i) rhs_storage(i, 0) = AnnoyingScalar(i + 1);
+
+    auto rhs = rhs_storage.col(0);
+    STATIC_CHECK((decltype(rhs)::InnerStrideAtCompileTime != 1));
+    result.noalias() = lhs.template triangularView<Upper>() * rhs;
+
+    for (Index i = 0; i < kSize; ++i) {
+      const int expected = int((i + 1 + kSize) * (kSize - i) / 2);
+      VERIFY_IS_EQUAL(result(i), AnnoyingScalar(expected));
+    }
+  }
+  VERIFY_IS_EQUAL(AnnoyingScalar::instances, initial_instances);
+}
+
 EIGEN_DECLARE_TEST(product_notemporary) {
+  CALL_SUBTEST_5((triangular_product_with_initialized_scalar<6>()));
+  CALL_SUBTEST_5((triangular_product_with_initialized_scalar<Dynamic>()));
+
   int s;
   for (int i = 0; i < g_repeat; i++) {
     s = internal::random<int>(16, EIGEN_TEST_MAX_SIZE);
     CALL_SUBTEST_1(product_notemporary(MatrixXf(s, s)));
     CALL_SUBTEST_2(product_notemporary(MatrixXd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(16, EIGEN_TEST_MAX_SIZE / 2);
     CALL_SUBTEST_3(product_notemporary(MatrixXcf(s, s)));
     CALL_SUBTEST_4(product_notemporary(MatrixXcd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 }
diff --git a/test/product_selfadjoint.cpp b/test/product_selfadjoint.cpp
index 96c089f..e017e67 100644
--- a/test/product_selfadjoint.cpp
+++ b/test/product_selfadjoint.cpp
@@ -6,12 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
 template <typename MatrixType>
 void product_selfadjoint(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
   typedef Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> RowVectorType;
 
@@ -29,6 +31,102 @@
 
   m1 = (m1.adjoint() + m1).eval();
 
+  // Dense selfadjoint assignment is documented as writing only the referenced triangle.
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Upper>() = m1 + m1.adjoint();
+  m3.template triangularView<Upper>() = m1 + m1.adjoint();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Upper>().setZero();
+  m3.template triangularView<Upper>().setZero();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Lower>().setOnes();
+  m3.template triangularView<Lower>().setOnes();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Upper>().setConstant(s1);
+  m3.template triangularView<Upper>().setConstant(s1);
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Lower>().fill(s2);
+  m3.template triangularView<Lower>().fill(s2);
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Upper>().setIdentity();
+  m3.template triangularView<Upper>().setIdentity();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Lower>().setRandom();
+  VERIFY_IS_APPROX(m2.template triangularView<StrictlyUpper>().toDenseMatrix(),
+                   m3.template triangularView<StrictlyUpper>().toDenseMatrix());
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Upper>() += m1;
+  m3.template triangularView<Upper>() += m1;
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Lower>() -= m1;
+  m3.template triangularView<Lower>() -= m1;
+  VERIFY_IS_APPROX(m2, m3);
+
+  // SelfAdjointView in-place scaling/division accept real scalars only: scaling only the
+  // stored triangle by a non-real factor would leave conj(other) on the unstored half.
+  const RealScalar real_s1 = numext::real(s1);
+  const RealScalar real_divisor = numext::real(s2) + RealScalar(2);
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Upper>() *= real_s1;
+  m3.template triangularView<Upper>() *= real_s1;
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m3 = m2;
+  m2.template selfadjointView<Lower>() /= real_divisor;
+  m3.template triangularView<Lower>() /= real_divisor;
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m2.template selfadjointView<Lower>() = m1.template selfadjointView<Lower>();
+  m3 = m1.template selfadjointView<Lower>().toDenseMatrix();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m2.template selfadjointView<Lower>() = m1.template selfadjointView<Upper>();
+  m3 = m1.template selfadjointView<Upper>().toDenseMatrix();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m2.template selfadjointView<Lower>() = m1.template triangularView<Upper>();
+  m3 = m1.template triangularView<Upper>().toDenseMatrix();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m2.template selfadjointView<Lower>() = m1.template triangularView<UnitUpper>();
+  m3 = m1.template triangularView<UnitUpper>().toDenseMatrix();
+  VERIFY_IS_APPROX(m2, m3);
+
+  m2.setRandom();
+  m2.template selfadjointView<Upper>() = m1.template triangularView<StrictlyLower>();
+  m3 = m1.template triangularView<StrictlyLower>().toDenseMatrix();
+  VERIFY_IS_APPROX(m2, m3);
+
   // rank2 update
   m2 = m1.template triangularView<Lower>();
   m2.template selfadjointView<Lower>().rankUpdate(v1, v2);
@@ -136,19 +234,19 @@
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
     CALL_SUBTEST_4(product_selfadjoint(MatrixXcf(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
     CALL_SUBTEST_5(product_selfadjoint(MatrixXcd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
     CALL_SUBTEST_6(product_selfadjoint(MatrixXd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
     CALL_SUBTEST_7(product_selfadjoint(Matrix<float, Dynamic, Dynamic, RowMajor>(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 
   // Deterministic blocking boundary tests (outside g_repeat).
diff --git a/test/product_small.cpp b/test/product_small.cpp
index 1ad06f6..054c637 100644
--- a/test/product_small.cpp
+++ b/test/product_small.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "product.h"
 #include <Eigen/LU>
@@ -34,6 +35,14 @@
   return C;
 }
 
+// The sweeps below compare an optimized product against ref_prod() with verifyProduct() rather than
+// VERIFY_IS_APPROX. Both sides accumulate k terms in the working precision, so each carries rounding
+// proportional to the magnitude of the summands, i.e. to |A|*|B| -- not to the result. Measuring the
+// error relative to the result, as VERIFY_IS_APPROX does, is meaningless once the sum cancels: at
+// bfloat16 precision a 10-term dot product can lose every significant digit, and the apparent
+// relative error then swings by several times the tolerance from one seed to the next while the
+// underlying discrepancy stays around one epsilon of |A|*|B|.
+
 template <typename T, int Rows, int Cols, int Depth, int OC, int OA, int OB>
 std::enable_if_t<!((Rows == 1 && Depth != 1 && OA == ColMajor) || (Depth == 1 && Rows != 1 && OA == RowMajor) ||
                    (Cols == 1 && Depth != 1 && OB == RowMajor) || (Depth == 1 && Cols != 1 && OB == ColMajor) ||
@@ -63,11 +72,24 @@
   MatrixX C(rows, cols);
   C.setRandom();
   MatrixX D(C);
+  MatrixX original(C);
   for (Index i = 0; i < C.rows(); ++i)
     for (Index j = 0; j < C.cols(); ++j)
       for (Index k = 0; k < A.cols(); ++k) D.coeffRef(i, j) |= (A.coeff(i, k) && B.coeff(k, j));
   C += A * B;
   VERIFY_IS_EQUAL(C, D);
+  C = original;
+  C.noalias() += A * B;
+  VERIFY_IS_EQUAL(C, D);
+
+  MatrixXi difference = A.cast<int>() * B.cast<int>() - A.cast<int>() * B.cast<int>();
+  VERIFY_IS_EQUAL(difference, MatrixXi::Zero(rows, cols));
+  difference.noalias() -= A.cast<int>() * B.cast<int>();
+  MatrixXi expected = MatrixXi::Zero(rows, cols);
+  for (Index i = 0; i < rows; ++i)
+    for (Index j = 0; j < cols; ++j)
+      for (Index k = 0; k < depth; ++k) expected(i, j) -= int(A(i, k)) * int(B(k, j));
+  VERIFY_IS_EQUAL(difference, expected);
 
   MatrixX E = B.transpose();
   for (Index i = 0; i < B.rows(); ++i)
@@ -181,7 +203,6 @@
   CALL_SUBTEST((test_lazy_all_layout<T, 6, 5, 4>()));
   CALL_SUBTEST((test_lazy_all_layout<T, 4, 4, 5>()));
   CALL_SUBTEST((test_lazy_all_layout<T, 3, 4, 6>()));
-  CALL_SUBTEST((test_lazy_all_layout<T, 2, 6, 4>()));
   CALL_SUBTEST((test_lazy_all_layout<T, 7, 8, 8>()));
   CALL_SUBTEST((test_lazy_all_layout<T, 8, -1, 4>(8, cols)));
   CALL_SUBTEST((test_lazy_all_layout<T, 3, 4, -1>(3, 4, depth)));
@@ -273,6 +294,50 @@
          ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)));
     VERIFY_IS_APPROX(B, C);
   }
+
+  {
+    // A square fixed-size product takes the coeff-based path while
+    // Rows + Cols + Depth stays below the threshold, so the boundary is derived
+    // rather than hard-coded. It is read back off product_type itself, not off
+    // the macro: the effective threshold is per scalar pair (SME raises it only
+    // for the pairs its kernel claims), so a build where double falls back to
+    // the generic kernel would otherwise disagree with whichever value the macro
+    // holds -- silently, since no SME job builds this test.
+    typedef Eigen::Matrix<double, 10, 10> Matrix10;
+    constexpr int kGemm = (internal::product_type<Matrix10, Matrix10>::FixedSizeThreshold + 2) / 3;
+    typedef Eigen::Matrix<double, kGemm - 1, kGemm - 1> MatrixBelow;
+    typedef Eigen::Matrix<double, kGemm, kGemm> MatrixAt;
+    VERIFY((internal::product_type<Matrix10, Matrix10>::value == CoeffBasedProductMode));
+    VERIFY((internal::product_type<MatrixBelow, MatrixBelow>::value == CoeffBasedProductMode));
+    VERIFY((internal::product_type<MatrixAt, MatrixAt>::value == GemmProduct));
+
+    Matrix10 A = Matrix10::Random();
+    Matrix10 B = Matrix10::Random();
+    Matrix10 C = Matrix10::Random();
+    Matrix10 ref = C;
+
+    C = A * B;
+    ref = A.lazyProduct(B);
+    VERIFY_IS_APPROX(C, ref);
+
+    C.setRandom();
+    ref = C;
+    C.noalias() += A * B;
+    ref.noalias() += A.lazyProduct(B);
+    VERIFY_IS_APPROX(C, ref);
+
+    C.setRandom();
+    ref = C;
+    C.noalias() -= A * B;
+    ref.noalias() -= A.lazyProduct(B);
+    VERIFY_IS_APPROX(C, ref);
+
+    C.setRandom();
+    ref = C;
+    C.noalias() += (2.0 * A) * (B * 3.0);
+    ref.noalias() += 6.0 * A.lazyProduct(B);
+    VERIFY_IS_APPROX(C, ref);
+  }
 }
 
 // Test products at sizes near critical code-path transitions:
@@ -294,7 +359,7 @@
         C = A * B;
         Cref.setZero();
         ref_prod(Cref, A, B);
-        VERIFY_IS_APPROX(C, Cref);
+        VERIFY(verifyProduct(C, Cref, A, B));
       }
     }
   }
@@ -313,12 +378,47 @@
         C = A * B;
         Cref.setZero();
         ref_prod(Cref, A, B);
-        VERIFY_IS_APPROX(C, Cref);
+        VERIFY(verifyProduct(C, Cref, A, B));
       }
     }
   }
 }
 
+// The bound for S * (S * S)^T is |S| * (|S| * |S|)^T, not |S|^3: transposition keeps every entry's
+// magnitude but reorders the chain. For the nilpotent S below the two differ in kind — |S|^3 is
+// identically zero while the two evaluation orders still disagree by a rounding error.
+template <int>
+void product_transposed_triple_bound() {
+  Matrix3d square;
+  square << 0, 0.3, 0, 0, 0, 0.7, 0, 0, 0;
+  const Matrix3d abs_sq = square.cwiseAbs();
+  const Matrix3d abs_sq2 = abs_sq * abs_sq;
+  VERIFY((abs_sq2 * abs_sq).isZero(0));
+  VERIFY(product_error_bound(abs_sq, abs_sq2.transpose(), 4) > 0);
+  VERIFY(verifyProduct(square * (square * square).transpose(), square * square.transpose() * square.transpose(), abs_sq,
+                       abs_sq2.transpose(), 4));
+}
+
+// verifyProduct() must not accept an overflowed result. Narrowed to half, the triple-product bound
+// for all-one 100x100 operands is already infinite, and inf <= inf would then pass any result.
+template <int>
+void product_verify_rejects_nonfinite() {
+  using MatrixXh = Matrix<half, Dynamic, Dynamic>;
+  const Index n = 100;
+  const MatrixXh abs_a = MatrixXh::Constant(n, n, half(float(n)));
+  const MatrixXh abs_b = MatrixXh::Constant(n, n, half(1.0f));
+  const double bound = product_error_bound(abs_a, abs_b, 4);
+  VERIFY((numext::isfinite)(bound));
+  VERIFY(bound > static_cast<double>(NumTraits<half>::highest()));
+
+  const MatrixXh zero = MatrixXh::Zero(n, n);
+  const MatrixXh inf = MatrixXh::Constant(n, n, half(std::numeric_limits<float>::infinity()));
+  const MatrixXh nan = MatrixXh::Constant(n, n, half(std::numeric_limits<float>::quiet_NaN()));
+  VERIFY(verifyProduct(zero, zero, abs_a, abs_b, 4));
+  VERIFY(!verifyProduct(inf, zero, abs_a, abs_b, 4));
+  VERIFY(!verifyProduct(nan, zero, abs_a, abs_b, 4));
+}
+
 EIGEN_DECLARE_TEST(product_small) {
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(product(Matrix<float, 3, 2>()));
@@ -363,6 +463,8 @@
   }
 
   CALL_SUBTEST_6(product_small_regressions<0>());
+  CALL_SUBTEST_6(product_transposed_triple_bound<0>());
+  CALL_SUBTEST_6(product_verify_rejects_nonfinite<0>());
 
   // Deterministic sweep at transition boundaries (outside g_repeat).
   CALL_SUBTEST_54(product_transition_sizes<float>());
diff --git a/test/product_sme.cpp b/test/product_sme.cpp
new file mode 100644
index 0000000..f676904
--- /dev/null
+++ b/test/product_sme.cpp
@@ -0,0 +1,897 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// SME GEMM kernel tests.
+// Requires a compiler targeting SME2, e.g. -march=armv9.2-a+sme2, which selects
+// the backend on its own; -DEIGEN_ARM64_USE_SME then makes a toolchain that
+// cannot provide it fail the build rather than fall back to NEON.
+// double and complex<double> additionally need FEAT_SME_F64F64 (+sme-f64f64, or
+// a -mcpu that implies it); without it EIGEN_VECTORIZE_SME_F64F64 is undefined
+// and they keep the generic kernel, so their subtests pack their cases through
+// that path instead.
+
+#include "product.h"
+
+// Without the right -march flags, __ARM_FEATURE_SME is undefined and
+// EIGEN_VECTORIZE_SME never fires - the test would silently compile
+// against the NEON GEBP kernel and pass, making this a useless no-op.
+// Fail the build instead.
+#if !defined(EIGEN_VECTORIZE_SME)
+#error \
+    "product_sme requires the SME backend.  Build with -march=armv9.2-a+sme2 " \
+    "(see -DEIGEN_TEST_SME=ON in test/CMakeLists.txt for the typical CMake " \
+    "invocation)."
+#endif
+
+// The backend is chosen from the compiler's target features; EIGEN_ARM64_USE_SME,
+// which this test's CMake option passes, only turns a toolchain that cannot
+// provide it into a build error. Assert that here, so a regression making
+// selection depend on the opt-in again is caught rather than masked by it.
+#if !defined(EIGEN_ARM64_SME_SELECTED)
+#error "the SME backend was forced by EIGEN_ARM64_USE_SME rather than selected from the compiler's target features."
+#endif
+
+template <typename Scalar>
+using SmeColMajorMat = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+template <typename Scalar>
+using SmeRowMajorMat = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+template <typename Scalar>
+using SmeVector = Matrix<Scalar, Dynamic, 1>;
+template <typename Scalar>
+using SmeColMajorStridedMat = Map<SmeColMajorMat<Scalar>, 0, Stride<Dynamic, Dynamic>>;
+template <typename Scalar>
+using SmeRowMajorStridedMat = Map<SmeRowMajorMat<Scalar>, 0, Stride<Dynamic, Dynamic>>;
+
+// The logical micro-kernel block for Scalar (kSmeMr/kSmeNr for float and so
+// on).  Sizes below are expressed in terms of it so each scalar sweeps its own
+// block boundaries; sme_tile() is the ZA tile side at the SVL=512 design point,
+// which is where the intra-block splits fall.  Complex scalars pair two tiles
+// per accumulator, so their block is not square.
+template <typename Scalar>
+static constexpr int sme_mr() {
+  return internal::sme_block<Scalar>::mr;
+}
+template <typename Scalar>
+static constexpr int sme_nr() {
+  return internal::sme_block<Scalar>::nr;
+}
+template <typename Scalar>
+static constexpr int sme_tile() {
+  return internal::sme_block<Scalar>::mr / internal::sme_block<Scalar>::kGridRows;
+}
+
+// svwhilelt_b* is overloaded only on the four fixed-width types, so forwarding
+// the caller's own type would leave Index ambiguous wherever it is `long` while
+// int64_t is `long long`, and deducing one type from both arguments would reject
+// the literal-plus-Index bounds the packers pass.  Name every spelling Index
+// takes, mix the two argument types, and check the predicate so the traits'
+// widening cannot change which lanes are active.
+template <typename Scalar, typename Begin, typename End = Begin>
+__arm_locally_streaming static bool sme_whilelt_covers_first_lane_only() {
+  using Traits = internal::sme_traits<Scalar>;
+  const svbool_t pg = Traits::whilelt(Begin(0), End(1));
+  return svptest_first(Traits::ptrue(), pg) && svcntp_b8(Traits::ptrue(), pg) == 1;
+}
+
+template <typename Scalar>
+static void test_whilelt_operand_types() {
+  VERIFY((sme_whilelt_covers_first_lane_only<Scalar, int>()));
+  VERIFY((sme_whilelt_covers_first_lane_only<Scalar, long>()));
+  VERIFY((sme_whilelt_covers_first_lane_only<Scalar, long long>()));
+  VERIFY((sme_whilelt_covers_first_lane_only<Scalar, Index>()));
+  VERIFY((sme_whilelt_covers_first_lane_only<Scalar, int, Index>()));
+}
+
+// Write one element into a packed panel of width w, in the layout the SME
+// kernel reads: a real scalar lands at dst[k*w + r], a complex one splits into
+// the depth step's real and imaginary halves.
+template <typename Scalar>
+static void set_packed(Scalar* panel, Index w, Index k, Index r, const Scalar& v) {
+  panel[k * w + r] = v;
+}
+template <typename RealScalar>
+static void set_packed(std::complex<RealScalar>* panel, Index w, Index k, Index r, const std::complex<RealScalar>& v) {
+  RealScalar* p = reinterpret_cast<RealScalar*>(panel + k * w);
+  p[r] = numext::real(v);
+  p[w + r] = numext::imag(v);
+}
+
+template <typename InputMat, typename ResultMat, typename ResultMap>
+static void verify_strided_result(int n, ResultMat& storage, const Stride<Dynamic, Dynamic>& stride) {
+  InputMat A = InputMat::Random(n, n);
+  InputMat B = InputMat::Random(n, n);
+  ResultMap C(storage.data(), n, n, stride);
+  C = ResultMat::Random(n, n);
+  ResultMat c_before = C.eval();
+
+  C.noalias() += A * B;
+
+  ResultMat ref = c_before + (A.lazyProduct(B)).eval();
+  ResultMat got = C;
+  VERIFY_IS_APPROX(got, ref);
+}
+
+template <typename Scalar, typename InputMat>
+static void test_general_strided_result(int n) {
+  // General-stride C path: InputMat selects the source packers, while both C
+  // strides are non-unit so sme_store_za_tile uses scalar scatter.
+  SmeColMajorMat<Scalar> storage = SmeColMajorMat<Scalar>::Zero(2 * n, n);
+  verify_strided_result<InputMat, SmeColMajorMat<Scalar>, SmeColMajorStridedMat<Scalar>>(
+      n, storage, Stride<Dynamic, Dynamic>(/*outer=*/2 * n, /*inner=*/2));
+
+  // Padding rows skipped by the strided Map should not be touched.
+  for (int i = 0; i < n; ++i) {
+    for (int j = 0; j < n; ++j) {
+      VERIFY(storage(2 * i + 1, j) == Scalar(0));
+    }
+  }
+}
+
+template <typename Scalar>
+static void test_rowmajor_strided_result(int n) {
+  // RowMajor C path: inner stride is one, with padded columns after the Map.
+  SmeRowMajorMat<Scalar> storage = SmeRowMajorMat<Scalar>::Zero(n, 2 * n);
+  verify_strided_result<SmeRowMajorMat<Scalar>, SmeRowMajorMat<Scalar>, SmeRowMajorStridedMat<Scalar>>(
+      n, storage, Stride<Dynamic, Dynamic>(/*outer=*/2 * n, /*inner=*/1));
+
+  // Padding columns skipped by the strided Map should not be touched.
+  for (int i = 0; i < n; ++i) {
+    for (int j = n; j < 2 * n; ++j) {
+      VERIFY(storage(i, j) == Scalar(0));
+    }
+  }
+}
+
+// A non-trivial alpha: complex where the scalar is, so the store's rotation of
+// the accumulator is exercised rather than a plain rescale.
+template <typename Scalar>
+struct nontrivial_alpha_impl {
+  static Scalar run() { return Scalar(1.375); }
+};
+template <typename RealScalar>
+struct nontrivial_alpha_impl<std::complex<RealScalar>> {
+  static std::complex<RealScalar> run() { return std::complex<RealScalar>(RealScalar(1.375), RealScalar(-0.625)); }
+};
+
+// Conjugated operands and a non-real alpha.
+//
+// blas_traits folds .adjoint()/.conjugate() and a scalar factor into the
+// gebp_kernel's ConjugateLhs/ConjugateRhs and alpha rather than materializing a
+// temporary, so these expressions are the only thing that reaches the complex
+// kernel's FMOPA/FMOPS sign choices and its alpha-scaled store. The references
+// materialize the conjugation first and multiply coefficient-wise, so they do
+// not share a code path with what they check.
+template <typename Scalar, typename LhsMat, typename RhsMat, typename ResMat>
+static void verify_conjugated_products(int n) {
+  const LhsMat A = LhsMat::Random(n, n);
+  const RhsMat B = RhsMat::Random(n, n);
+  const SmeColMajorMat<Scalar> Ap = A, Bp = B;
+  const SmeColMajorMat<Scalar> Aa = Ap.adjoint().eval(), Ac = Ap.conjugate().eval();
+  const SmeColMajorMat<Scalar> Ba = Bp.adjoint().eval(), Bc = Bp.conjugate().eval();
+  const Scalar alpha = nontrivial_alpha_impl<Scalar>::run();
+
+  ResMat C(n, n);
+  C.setZero();
+  C.noalias() += A.adjoint() * B;
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(Aa.lazyProduct(Bp)));
+  C.setZero();
+  C.noalias() += A * B.adjoint();
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(Ap.lazyProduct(Ba)));
+  C.setZero();
+  C.noalias() += A.adjoint() * B.adjoint();
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(Aa.lazyProduct(Ba)));
+  C.setZero();
+  C.noalias() += A.conjugate() * B;
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(Ac.lazyProduct(Bp)));
+  C.setZero();
+  C.noalias() += A * B.conjugate();
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(Ap.lazyProduct(Bc)));
+  C.setZero();
+  C.noalias() += A.conjugate() * B.conjugate();
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(Ac.lazyProduct(Bc)));
+  C.setZero();
+  C.noalias() += alpha * (A.adjoint() * B);
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), SmeColMajorMat<Scalar>(alpha * Aa.lazyProduct(Bp)));
+}
+
+// Exercise the kc split path just above the SME blocking heuristic's depth cap
+// (sme_max_kc in GeneralBlockPanelKernel.h, scaled by the scalar width).
+template <typename Scalar>
+static void test_deep_k_split() {
+  constexpr int rows = 64;
+  const int depth = int(2 * (Index(EIGEN_SME_MAX_KC) * Index(sizeof(float)) / Index(sizeof(Scalar)))) + 2;
+  constexpr int cols = 64;
+  SmeColMajorMat<Scalar> A = SmeColMajorMat<Scalar>::Random(rows, depth);
+  SmeColMajorMat<Scalar> B = SmeColMajorMat<Scalar>::Random(depth, cols);
+  SmeColMajorMat<Scalar> C = SmeColMajorMat<Scalar>::Random(rows, cols);
+  SmeColMajorMat<Scalar> c_before = C;
+
+  C.noalias() += A * B;
+
+  VERIFY_IS_APPROX(C, c_before + (A.lazyProduct(B)).eval());
+}
+
+// ---------------------------------------------------------------------------
+// Raw packed-buffer tests.
+//
+// The product tests above validate the packers only transitively through a full
+// product, where the gebp_kernel can mask a mispack, or where a bug only shows
+// at a specific SVL/region boundary.  The tests below call the SME packers
+// directly and compare the packed buffer exactly against a scalar reference
+// (equality is exact).  This pins every region -- in particular a dropped
+// row-group in the two-pass trailing transpose, and a SYMM packer that copies
+// the unused triangle instead of mirroring -- at whatever SVL the run uses.
+// ---------------------------------------------------------------------------
+
+// A distinctive marker for buffer cells the packer must leave untouched, and
+// for the unused triangle of a lower-triangular operand. Random values live in
+// [-1, 1], so it never collides with a real packed value. The complex marker's
+// imaginary part differs from its real one, so a packer that fills only the
+// real half of a split depth step is caught.
+template <typename Scalar>
+struct pack_sentinel_impl {
+  static Scalar run() { return Scalar(98765); }
+};
+template <typename RealScalar>
+struct pack_sentinel_impl<std::complex<RealScalar>> {
+  static std::complex<RealScalar> run() { return std::complex<RealScalar>(RealScalar(98765), RealScalar(-54321)); }
+};
+template <typename Scalar>
+static Scalar pack_sentinel() {
+  return pack_sentinel_impl<Scalar>::run();
+}
+
+// ---------------------------------------------------------------------------
+// NEON small-block path: sme_gebp_neon called directly on hand-packed panels,
+// over every row, column and depth tail of the tile ladder, both conjugation
+// flags, a non-trivial alpha, panel-mode stride/offset and a general-stride C.
+// ---------------------------------------------------------------------------
+template <typename Scalar, bool ConjLhs, bool ConjRhs>
+static void verify_neon_small_block(Index rows, Index cols, Index depth, bool panel_mode, bool strided_c) {
+  const Index MR = sme_mr<Scalar>();
+  const Index NR = sme_nr<Scalar>();
+  const Index strideA = panel_mode ? depth + 3 : depth;
+  const Index strideB = panel_mode ? depth + 5 : depth;
+  const Index offsetA = panel_mode ? 2 : 0;
+  const Index offsetB = panel_mode ? 1 : 0;
+  const SmeColMajorMat<Scalar> A = SmeColMajorMat<Scalar>::Random(rows, depth);
+  const SmeColMajorMat<Scalar> B = SmeColMajorMat<Scalar>::Random(depth, cols);
+
+  SmeVector<Scalar> packedA =
+      SmeVector<Scalar>::Constant((rows + MR) * strideA + offsetA * MR, pack_sentinel<Scalar>());
+  SmeVector<Scalar> packedB =
+      SmeVector<Scalar>::Constant((cols + NR) * strideB + offsetB * NR, pack_sentinel<Scalar>());
+  for (Index i = 0; i < rows; i += MR) {
+    const Index w = numext::mini(MR, rows - i);
+    for (Index k = 0; k < depth; ++k)
+      for (Index r = 0; r < w; ++r) set_packed(packedA.data() + i * strideA + offsetA * w, w, k, r, A(i + r, k));
+  }
+  for (Index j = 0; j < cols; j += NR) {
+    const Index w = numext::mini(NR, cols - j);
+    for (Index k = 0; k < depth; ++k)
+      for (Index c = 0; c < w; ++c) set_packed(packedB.data() + j * strideB + offsetB * w, w, k, c, B(k, j + c));
+  }
+
+  const Scalar alpha = nontrivial_alpha_impl<Scalar>::run();
+  const Index rs = strided_c ? 2 : 1;
+  const Index cs = strided_c ? 3 * rows : rows;
+  SmeVector<Scalar> storage = SmeVector<Scalar>::Random(cs * cols);
+  SmeColMajorStridedMat<Scalar> C(storage.data(), rows, cols, Stride<Dynamic, Dynamic>(cs, rs));
+  const SmeColMajorMat<Scalar> c_before = C;
+  const SmeVector<Scalar> storage_before = storage;
+
+  internal::sme_gebp_neon<Scalar, ConjLhs, ConjRhs, Index>(storage.data(), rs, cs, packedA.data(), packedB.data(), rows,
+                                                           depth, cols, alpha, strideA, strideB, offsetA, offsetB);
+
+  const SmeColMajorMat<Scalar> Ac = ConjLhs ? A.conjugate().eval() : A;
+  const SmeColMajorMat<Scalar> Bc = ConjRhs ? B.conjugate().eval() : B;
+  const SmeColMajorMat<Scalar> ref = c_before + alpha * Ac.lazyProduct(Bc);
+  VERIFY_IS_APPROX(SmeColMajorMat<Scalar>(C), ref);
+
+  // Cells the strided map skips stay untouched.
+  if (strided_c) {
+    for (Index j = 0; j < cols; ++j)
+      for (Index i = 0; i < rows; ++i)
+        VERIFY_IS_EQUAL(storage(j * cs + i * rs + 1), storage_before(j * cs + i * rs + 1));
+  }
+}
+
+template <typename Scalar>
+static void test_neon_small_blocks() {
+  const Index PS = Index(internal::packet_traits<typename NumTraits<Scalar>::Real>::size);
+  const Index MR = sme_mr<Scalar>();
+  const Index NR = sme_nr<Scalar>();
+  const Index widths[] = {1, 2, 3, PS, PS + 1, 2 * PS + 1, 4 * PS, 4 * PS + 3, MR - 1, MR, MR + 1, 2 * MR + 5};
+  const Index col_widths[] = {1, 2, 3, 4, 5, 9, NR - 1, NR, NR + 1, 2 * NR + 2};
+  const Index depths[] = {1, 2, 3, 4, 5, 8, 9, 35};
+  for (Index rows : widths) {
+    for (Index cols : col_widths) {
+      for (Index depth : depths) {
+        const bool panel_mode = (rows + cols + depth) % 2 == 0;
+        const bool strided_c = (rows + depth) % 3 == 0;
+        verify_neon_small_block<Scalar, false, false>(rows, cols, depth, panel_mode, strided_c);
+        if (NumTraits<Scalar>::IsComplex) {
+          verify_neon_small_block<Scalar, true, false>(rows, cols, depth, panel_mode, strided_c);
+          verify_neon_small_block<Scalar, false, true>(rows, cols, depth, panel_mode, strided_c);
+          verify_neon_small_block<Scalar, true, true>(rows, cols, depth, panel_mode, strided_c);
+        }
+      }
+    }
+  }
+}
+
+// Lower-triangular n x n operand plus the dense selfadjoint reference the packer
+// must emit. The unused triangle is filled with the sentinel so a packer that
+// copies the dense matrix and never mirrors fails VERIFY_IS_EQUAL.
+// product_selfadjoint_matrix stores the valid triangle where row >= col
+// (after the Upper/RowMajor xor), so the packer must read stored(row,col)
+// below the diagonal and conj(stored(col,row)) above it. Averaging with the
+// adjoint cancels the diagonal's imaginary part exactly, which is what a
+// selfadjoint view defines it to be.
+template <typename Scalar, int StorageOrder>
+static void make_lower_stored_selfadjoint(Index n, Matrix<Scalar, Dynamic, Dynamic, StorageOrder>& stored,
+                                          Matrix<Scalar, Dynamic, Dynamic, StorageOrder>& full) {
+  full = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>::Random(n, n);
+  full = ((full + full.adjoint()) * Scalar(0.5)).eval();
+  stored = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>::Constant(n, n, pack_sentinel<Scalar>());
+  for (Index i = 0; i < n; ++i)
+    for (Index j = 0; j <= i; ++j) stored(i, j) = full(i, j);
+}
+
+// LHS SYMM packer: a square selfadjoint diagonal block of size n, packed into
+// uniform mr-wide depth-major panels.  Reference: full(i+r, k).
+template <typename Scalar, int StorageOrder>
+static void verify_symm_pack_lhs(Index n) {
+  const Index MR = sme_mr<Scalar>();
+  Matrix<Scalar, Dynamic, Dynamic, StorageOrder> stored, full;
+  make_lower_stored_selfadjoint<Scalar, StorageOrder>(n, stored, full);
+
+  SmeVector<Scalar> packed = SmeVector<Scalar>::Constant(n * n, pack_sentinel<Scalar>());
+  SmeVector<Scalar> ref = SmeVector<Scalar>::Constant(n * n, pack_sentinel<Scalar>());
+  for (Index i = 0; i < n; i += MR) {
+    const Index w = numext::mini(MR, n - i);
+    for (Index k = 0; k < n; ++k)
+      for (Index r = 0; r < w; ++r) set_packed(ref.data() + i * n, w, k, r, Scalar(full(i + r, k)));
+  }
+
+  internal::symm_pack_lhs<Scalar, Index, sme_mr<Scalar>(), 1, StorageOrder> pack;
+  pack(packed.data(), stored.data(), stored.outerStride(), /*cols(depth)=*/n, /*rows=*/n);
+  VERIFY_IS_EQUAL(packed, ref);
+}
+
+// RHS SYMM packer: a depth block [k2, k2 + depth) x cols columns of an N x N
+// selfadjoint matrix, packed into nr-wide depth-major panels.  Reference:
+// full(k2 + k, j + c).  A k2 > 0 offset makes the transposed region non-empty,
+// so partial-width panels reach the two-pass transpose.
+template <typename Scalar, int StorageOrder>
+static void verify_symm_pack_rhs(Index N, Index depth, Index cols, Index k2) {
+  eigen_assert(k2 + depth <= N && cols <= N);
+  const Index NR = sme_nr<Scalar>();
+  Matrix<Scalar, Dynamic, Dynamic, StorageOrder> stored, full;
+  make_lower_stored_selfadjoint<Scalar, StorageOrder>(N, stored, full);
+
+  SmeVector<Scalar> packed = SmeVector<Scalar>::Constant(cols * depth, pack_sentinel<Scalar>());
+  SmeVector<Scalar> ref = SmeVector<Scalar>::Constant(cols * depth, pack_sentinel<Scalar>());
+  for (Index j = 0; j < cols; j += NR) {
+    const Index w = numext::mini(NR, cols - j);
+    for (Index k = 0; k < depth; ++k)
+      for (Index c = 0; c < w; ++c) set_packed(ref.data() + j * depth, w, k, c, Scalar(full(k2 + k, j + c)));
+  }
+
+  internal::symm_pack_rhs<Scalar, Index, sme_nr<Scalar>(), StorageOrder> pack;
+  pack(packed.data(), stored.data(), stored.outerStride(), /*rows(depth)=*/depth, /*cols=*/cols, k2);
+  VERIFY_IS_EQUAL(packed, ref);
+}
+
+template <typename Scalar>
+static void test_symm_pack() {
+  // The last panel width sweeps a range of partial widths; at each SVL the
+  // two-pass trailing transpose (the if->loop fix) fires when a partial width
+  // leaves a trailing row-group remainder in (svl, 2*svl).  The spread below
+  // hits that for svl in {2, 4, 8, 16, 32, 64} -- fp32 SVL 128..2048 and the
+  // fp64 lane counts, which are half of those.
+  const int sizes[] = {1, 5, 7, 17, 31, 32, 33, 37, 39, 45, 48, 49, 55, 57, 63, 64, 65, 79, 96, 97};
+  for (int n : sizes) {
+    verify_symm_pack_lhs<Scalar, ColMajor>(n);
+    verify_symm_pack_lhs<Scalar, RowMajor>(n);
+    // RHS, single depth block anchored at the diagonal (k2 == 0).
+    verify_symm_pack_rhs<Scalar, ColMajor>(n, n, n, 0);
+    verify_symm_pack_rhs<Scalar, RowMajor>(n, n, n, 0);
+  }
+
+  // RHS depth blocks offset from the diagonal (k2 > 0): the transposed region is
+  // non-empty, so the RowMajor operand drives partial-width panels through the
+  // two-pass transpose and the ColMajor operand through the partial copy.
+  struct RhsCase {
+    int N, depth, cols, k2;
+  };
+  const RhsCase rhs_cases[] = {
+      {100, 32, 39, 16}, {100, 24, 39, 32}, {100, 40, 64, 8}, {100, 39, 39, 33}, {128, 57, 57, 40}, {128, 33, 45, 60},
+  };
+  for (const RhsCase& c : rhs_cases) {
+    verify_symm_pack_rhs<Scalar, ColMajor>(c.N, c.depth, c.cols, c.k2);
+    verify_symm_pack_rhs<Scalar, RowMajor>(c.N, c.depth, c.cols, c.k2);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Mapper-based packing fallback (sme_pack_{lhs,rhs}_fallback).
+//
+// Taken by by-value tensor sub-mappers and inner-strided blas mappers, which
+// the raw pointer + stride packers cannot walk.  The product suite reaches these
+// only through tensor contractions (nightly, SVL=512) and TriangularSolver
+// (random sizes), so here we drive the fallback directly with both mapper
+// families and compare the packed buffer against a scalar reference.
+// ---------------------------------------------------------------------------
+
+// Minimal stand-ins for by-value sub-mappers. ColMajor packets advance the
+// first index, while RowMajor packets follow the normal storage-inner second
+// index. operator() returns by value so both take the no-direct-access dispatch.
+template <typename Scalar>
+struct ByValueColMajorLhsMapper {
+  const Scalar* data;
+  Index stride;  // element(i, k) = data[i + k * stride], contiguous in i
+  Scalar operator()(Index i, Index k) const { return data[i + k * stride]; }
+  template <typename Packet>
+  EIGEN_ALWAYS_INLINE Packet loadPacket(Index i, Index k) const {
+    return internal::ploadu<Packet>(data + i + k * stride);
+  }
+};
+
+template <typename Scalar>
+struct ByValueRowMajorLhsMapper {
+  const Scalar* data;
+  Index stride;  // element(i, k) = data[i * stride + k], contiguous in k
+  Scalar operator()(Index i, Index k) const { return data[i * stride + k]; }
+  template <typename Packet>
+  EIGEN_ALWAYS_INLINE Packet loadPacket(Index i, Index k) const {
+    return internal::ploadu<Packet>(data + i * stride + k);
+  }
+};
+
+template <typename Scalar>
+struct ByValueColMajorRhsMapper {
+  struct LinearMapper {
+    const Scalar* p;  // &element(0, col); contiguous in depth
+    Scalar operator()(Index k) const { return p[k]; }
+    template <typename Packet>
+    EIGEN_ALWAYS_INLINE Packet loadPacket(Index k) const {
+      return internal::ploadu<Packet>(p + k);
+    }
+  };
+  const Scalar* data;
+  Index stride;  // element(k, col) = data[k + col * stride], contiguous in k
+  Scalar operator()(Index k, Index col) const { return data[k + col * stride]; }
+  LinearMapper getLinearMapper(Index k, Index col) const { return LinearMapper{data + k + col * stride}; }
+};
+
+template <typename Scalar>
+struct ByValueRowMajorRhsMapper {
+  struct LinearMapper {
+    const Scalar* p;  // &element(row, col); packet offsets advance columns
+    Scalar operator()(Index offset) const { return p[offset]; }
+    template <typename Packet>
+    EIGEN_ALWAYS_INLINE Packet loadPacket(Index offset) const {
+      return internal::ploadu<Packet>(p + offset);
+    }
+  };
+  const Scalar* data;
+  Index stride;  // element(k, col) = data[k * stride + col], contiguous in col
+  Scalar operator()(Index k, Index col) const { return data[k * stride + col]; }
+  LinearMapper getLinearMapper(Index k, Index col) const { return LinearMapper{data + k * stride + col}; }
+};
+
+// Length of the packed LHS buffer for the given panel-mode layout, matching the
+// dst_panel formula in sme_pack_lhs_fallback.
+template <bool PanelMode>
+static Index packed_len(Index outer, Index depth, Index unit, Index dst_stride, Index dst_offset) {
+  // `outer` is rows (LHS) or cols (RHS); `unit` is the panel width mr or nr.
+  if (!PanelMode) return outer * depth;
+  Index end = 0;
+  for (Index i = 0; i < outer; i += unit) {
+    const Index w = numext::mini(unit, outer - i);
+    end = numext::maxi(end, i * dst_stride + dst_offset * w + depth * w);
+  }
+  return end;
+}
+
+template <typename Scalar, bool PanelMode, bool Conjugate, typename MatrixType>
+static void fill_lhs_ref(SmeVector<Scalar>& ref, const MatrixType& V, Index rows, Index depth, Index dst_stride,
+                         Index dst_offset) {
+  const Index MR = sme_mr<Scalar>();
+  ref.setConstant(pack_sentinel<Scalar>());
+  for (Index i = 0; i < rows; i += MR) {
+    const Index w = numext::mini(MR, rows - i);
+    const Index base = PanelMode ? i * dst_stride + dst_offset * w : i * depth;
+    for (Index k = 0; k < depth; ++k)
+      for (Index r = 0; r < w; ++r) {
+        const Scalar v = V(i + r, k);
+        set_packed(ref.data() + base, w, k, r, Conjugate ? numext::conj(v) : v);
+      }
+  }
+}
+
+template <typename Scalar, bool PanelMode, bool Conjugate, typename MatrixType>
+static void fill_rhs_ref(SmeVector<Scalar>& ref, const MatrixType& V, Index cols, Index depth, Index dst_stride,
+                         Index dst_offset) {
+  const Index NR = sme_nr<Scalar>();
+  ref.setConstant(pack_sentinel<Scalar>());
+  for (Index j = 0; j < cols; j += NR) {
+    const Index w = numext::mini(NR, cols - j);
+    const Index base = PanelMode ? j * dst_stride + dst_offset * w : j * depth;
+    for (Index k = 0; k < depth; ++k)
+      for (Index c = 0; c < w; ++c) {
+        const Scalar v = V(k, j + c);
+        set_packed(ref.data() + base, w, k, c, Conjugate ? numext::conj(v) : v);
+      }
+  }
+}
+
+// Every packer check below is the same nine lines -- fill a sentinel buffer,
+// build the scalar reference, run the packer, compare exactly -- over a
+// different mapper. The mapper is what each check is really about, so it is
+// built by the caller and the rest lives here once.
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate, typename Mapper, typename MatrixType>
+static void check_packed_lhs(const Mapper& mapper, const MatrixType& V, Index rows, Index depth) {
+  const Index dst_stride = PanelMode ? depth + 5 : 0;
+  const Index dst_offset = PanelMode ? 3 : 0;
+  const Index len = packed_len<PanelMode>(rows, depth, sme_mr<Scalar>(), dst_stride, dst_offset);
+  SmeVector<Scalar> packed = SmeVector<Scalar>::Constant(len, pack_sentinel<Scalar>());
+  SmeVector<Scalar> ref(len);
+  fill_lhs_ref<Scalar, PanelMode, Conjugate>(ref, V, rows, depth, dst_stride, dst_offset);
+
+  internal::gemm_pack_lhs<Scalar, Index, Mapper, sme_mr<Scalar>(), 1, typename internal::packet_traits<Scalar>::type,
+                          StorageOrder, Conjugate, PanelMode>
+      pack;
+  pack(packed.data(), mapper, depth, rows, dst_stride, dst_offset);
+  VERIFY_IS_EQUAL(packed, ref);
+}
+
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate, typename Mapper, typename MatrixType>
+static void check_packed_rhs(const Mapper& mapper, const MatrixType& V, Index depth, Index cols) {
+  const Index dst_stride = PanelMode ? depth + 5 : 0;
+  const Index dst_offset = PanelMode ? 3 : 0;
+  const Index len = packed_len<PanelMode>(cols, depth, sme_nr<Scalar>(), dst_stride, dst_offset);
+  SmeVector<Scalar> packed = SmeVector<Scalar>::Constant(len, pack_sentinel<Scalar>());
+  SmeVector<Scalar> ref(len);
+  fill_rhs_ref<Scalar, PanelMode, Conjugate>(ref, V, cols, depth, dst_stride, dst_offset);
+
+  internal::gemm_pack_rhs<Scalar, Index, Mapper, sme_nr<Scalar>(), StorageOrder, Conjugate, PanelMode> pack;
+  pack(packed.data(), mapper, depth, cols, dst_stride, dst_offset);
+  VERIFY_IS_EQUAL(packed, ref);
+}
+
+// The raw pointer + stride packers, taken whenever the mapper grants direct
+// unit-inner-stride access.
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate>
+static void verify_pack_lhs_direct(Index rows, Index depth) {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using Mapper = internal::const_blas_data_mapper<Scalar, Index, StorageOrder>;
+  MatrixType V = MatrixType::Random(rows, depth);
+  check_packed_lhs<Scalar, StorageOrder, PanelMode, Conjugate>(Mapper(V.data(), V.outerStride()), V, rows, depth);
+}
+
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate>
+static void verify_pack_rhs_direct(Index depth, Index cols) {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using Mapper = internal::const_blas_data_mapper<Scalar, Index, StorageOrder>;
+  MatrixType V = MatrixType::Random(depth, cols);
+  check_packed_rhs<Scalar, StorageOrder, PanelMode, Conjugate>(Mapper(V.data(), V.outerStride()), V, depth, cols);
+}
+
+// Inner-strided blas mapper LHS: element(i, k) laid out with inner stride
+// `incr`.  ColMajor takes the vectorised gather path; RowMajor takes the scalar
+// path (its packets would run along depth, not rows).
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate>
+static void verify_fallback_lhs_strided(Index rows, Index depth, Index incr) {
+  using Mapper = internal::blas_data_mapper<Scalar, Index, StorageOrder, Unaligned, Dynamic>;
+  Matrix<Scalar, Dynamic, Dynamic> V = Matrix<Scalar, Dynamic, Dynamic>::Random(rows, depth);
+  const Index mstride = (StorageOrder == ColMajor ? rows : depth) * incr;
+  SmeVector<Scalar> buf = SmeVector<Scalar>::Zero((StorageOrder == ColMajor ? depth : rows) * mstride + incr);
+  for (Index k = 0; k < depth; ++k)
+    for (Index i = 0; i < rows; ++i)
+      buf[StorageOrder == ColMajor ? i * incr + k * mstride : k * incr + i * mstride] = V(i, k);
+  check_packed_lhs<Scalar, StorageOrder, PanelMode, Conjugate>(Mapper(buf.data(), mstride, incr), V, rows, depth);
+}
+
+// By-value LHS mappers exercise both packet directions. RowMajor must stay
+// scalar because its packets advance depth rather than rows.
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate>
+static void verify_fallback_lhs_byvalue(Index rows, Index depth) {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using Mapper = typename std::conditional<StorageOrder == ColMajor, ByValueColMajorLhsMapper<Scalar>,
+                                           ByValueRowMajorLhsMapper<Scalar>>::type;
+  MatrixType V = MatrixType::Random(rows, depth);
+  check_packed_lhs<Scalar, StorageOrder, PanelMode, Conjugate>(Mapper{V.data(), V.outerStride()}, V, rows, depth);
+}
+
+// Inner-strided blas mapper RHS: element(k, col) with inner stride `incr`.
+// ColMajor takes the vectorised transpose path; RowMajor takes the scalar path.
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate>
+static void verify_fallback_rhs_strided(Index depth, Index cols, Index incr) {
+  using Mapper = internal::blas_data_mapper<Scalar, Index, StorageOrder, Unaligned, Dynamic>;
+  Matrix<Scalar, Dynamic, Dynamic> V = Matrix<Scalar, Dynamic, Dynamic>::Random(depth, cols);
+  const Index mstride = (StorageOrder == ColMajor ? depth : cols) * incr;
+  SmeVector<Scalar> buf = SmeVector<Scalar>::Zero((StorageOrder == ColMajor ? cols : depth) * mstride + incr);
+  for (Index col = 0; col < cols; ++col)
+    for (Index k = 0; k < depth; ++k)
+      buf[StorageOrder == ColMajor ? k * incr + col * mstride : col * incr + k * mstride] = V(k, col);
+  check_packed_rhs<Scalar, StorageOrder, PanelMode, Conjugate>(Mapper(buf.data(), mstride, incr), V, depth, cols);
+}
+
+// By-value RHS mappers likewise cover both packet directions. RowMajor packets
+// advance columns, so the depth-oriented transpose fallback must stay scalar.
+template <typename Scalar, int StorageOrder, bool PanelMode, bool Conjugate>
+static void verify_fallback_rhs_byvalue(Index depth, Index cols) {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using Mapper = typename std::conditional<StorageOrder == ColMajor, ByValueColMajorRhsMapper<Scalar>,
+                                           ByValueRowMajorRhsMapper<Scalar>>::type;
+  MatrixType V = MatrixType::Random(depth, cols);
+  check_packed_rhs<Scalar, StorageOrder, PanelMode, Conjugate>(Mapper{V.data(), V.outerStride()}, V, depth, cols);
+}
+
+// Each packer is swept over all four (PanelMode, Conjugate) combinations.
+// Conjugate=true is the identity on real scalars; for complex ones it negates
+// the packed imaginary half, and reaches the direct packers from the SYMM
+// above-diagonal transposed pack and the fallbacks from an inner-strided
+// selfadjoint operand.
+template <typename Scalar, int SO>
+static void sweep_pack_direct(Index n, Index depth) {
+  verify_pack_lhs_direct<Scalar, SO, false, false>(n, depth);
+  verify_pack_lhs_direct<Scalar, SO, false, true>(n, depth);
+  verify_pack_lhs_direct<Scalar, SO, true, false>(n, depth);
+  verify_pack_lhs_direct<Scalar, SO, true, true>(n, depth);
+  verify_pack_rhs_direct<Scalar, SO, false, false>(depth, n);
+  verify_pack_rhs_direct<Scalar, SO, false, true>(depth, n);
+  verify_pack_rhs_direct<Scalar, SO, true, false>(depth, n);
+  verify_pack_rhs_direct<Scalar, SO, true, true>(depth, n);
+}
+
+template <typename Scalar, int SO>
+static void sweep_fallback_strided(Index n, Index depth, Index incr) {
+  verify_fallback_lhs_strided<Scalar, SO, false, false>(n, depth, incr);
+  verify_fallback_lhs_strided<Scalar, SO, false, true>(n, depth, incr);
+  verify_fallback_lhs_strided<Scalar, SO, true, false>(n, depth, incr);
+  verify_fallback_lhs_strided<Scalar, SO, true, true>(n, depth, incr);
+  verify_fallback_rhs_strided<Scalar, SO, false, false>(depth, n, incr);
+  verify_fallback_rhs_strided<Scalar, SO, false, true>(depth, n, incr);
+  verify_fallback_rhs_strided<Scalar, SO, true, false>(depth, n, incr);
+  verify_fallback_rhs_strided<Scalar, SO, true, true>(depth, n, incr);
+}
+
+template <typename Scalar, int SO>
+static void sweep_fallback_byvalue(Index n, Index depth) {
+  verify_fallback_lhs_byvalue<Scalar, SO, false, false>(n, depth);
+  verify_fallback_lhs_byvalue<Scalar, SO, false, true>(n, depth);
+  verify_fallback_lhs_byvalue<Scalar, SO, true, false>(n, depth);
+  verify_fallback_lhs_byvalue<Scalar, SO, true, true>(n, depth);
+  verify_fallback_rhs_byvalue<Scalar, SO, false, false>(depth, n);
+  verify_fallback_rhs_byvalue<Scalar, SO, false, true>(depth, n);
+  verify_fallback_rhs_byvalue<Scalar, SO, true, false>(depth, n);
+  verify_fallback_rhs_byvalue<Scalar, SO, true, true>(depth, n);
+}
+
+template <typename Scalar>
+static void test_pack_direct() {
+  const int TILE = sme_tile<Scalar>();
+  const int MR = sme_mr<Scalar>();
+  const int NR = sme_nr<Scalar>();
+  // Widths around the tile side and both panel widths, which differ for
+  // complex scalars.
+  const int widths[] = {1, TILE - 1, TILE, TILE + 1, MR, MR + 1, NR, NR + 1, 2 * NR + 1};
+  // Depths up to sme_neon_max_depth (24 / 16 / 16 / 8 by scalar) reach pack_neon,
+  // the deeper ones the streaming pack_direct and its predicated tails.
+  const int depths[] = {1, 3, 8, 9, 17, 25, 27, 35};
+  for (int d : depths) {
+    for (int n : widths) {
+      sweep_pack_direct<Scalar, ColMajor>(n, d);
+      sweep_pack_direct<Scalar, RowMajor>(n, d);
+    }
+  }
+}
+
+template <typename Scalar>
+static void test_mapper_fallback() {
+  const int MR = sme_mr<Scalar>();
+  const int widths[] = {4, 5, MR, MR + 1, 2 * MR + 1};  // rows/cols around 4 and the panel width
+  const int depths[] = {1, 3, 8, 35};                   // depth remainders 1..3 and larger
+  for (int n : widths) {
+    for (int d : depths) {
+      // RowMajor mappers take the scalar path: their packets advance the index
+      // the fallback does not transpose.
+      for (int incr : {2, 3}) {
+        sweep_fallback_strided<Scalar, ColMajor>(n, d, incr);
+        sweep_fallback_strided<Scalar, RowMajor>(n, d, incr);
+      }
+      sweep_fallback_byvalue<Scalar, ColMajor>(n, d);
+      sweep_fallback_byvalue<Scalar, RowMajor>(n, d);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Product-level coverage, swept relative to the scalar's own block width.
+// ---------------------------------------------------------------------------
+
+// Sizes that land just on and off the block tails and the intra-block ZA-tile
+// splits, for both panel widths (they differ for complex scalars) and the tile
+// side at the SVL=512 design point.
+template <typename Scalar>
+static std::vector<int> sme_edge_sizes() {
+  const int T = sme_tile<Scalar>();
+  const int MR = sme_mr<Scalar>();
+  const int NR = sme_nr<Scalar>();
+  std::vector<int> sizes = {1,  T - 1,  T,          T + 1,  MR - 1,     MR,         MR + 1, NR - 1,
+                            NR, NR + 1, 2 * MR - 1, 2 * MR, 2 * MR + 1, 2 * NR - 1, 2 * NR, 2 * NR + 1};
+  std::sort(sizes.begin(), sizes.end());
+  sizes.erase(std::unique(sizes.begin(), sizes.end()), sizes.end());
+  return sizes;
+}
+
+// The dimension-sum and output-area bounds in GeneralProduct.h route a small
+// square product to the coeff-based evaluator, so the n x n sweeps above stop
+// reaching the SME kernel once n gets small -- which is exactly where the
+// intra-block ZA tile-split edges (T-1, T, T+1) live for double and
+// complex<double>.  Repeat the same widths over a depth that clears both
+// bounds, so every m and n edge still reaches the kernel, and check the
+// conjugated forms too: at those sizes test_conjugated_products compares a
+// lazyProduct against a lazyProduct and cannot fail.
+template <typename Scalar>
+static void test_edge_sizes_deep_k() {
+  const int depth = 4 * sme_mr<Scalar>();
+  for (int n : sme_edge_sizes<Scalar>()) {
+    if (n < 2) continue;
+    const SmeColMajorMat<Scalar> A = SmeColMajorMat<Scalar>::Random(n, depth);
+    const SmeColMajorMat<Scalar> B = SmeColMajorMat<Scalar>::Random(depth, n);
+    const SmeColMajorMat<Scalar> Aa = A.adjoint().eval();
+    const SmeColMajorMat<Scalar> Ba = B.adjoint().eval();
+    const SmeColMajorMat<Scalar> c_before = SmeColMajorMat<Scalar>::Random(n, n);
+    const SmeColMajorMat<Scalar> expected = c_before + A.lazyProduct(B);
+
+    SmeColMajorMat<Scalar> C = c_before;
+    C.noalias() += A * B;
+    VERIFY_IS_APPROX(C, expected);
+
+    C = c_before;
+    C.noalias() += Aa.adjoint() * B;
+    VERIFY_IS_APPROX(C, expected);
+
+    C = c_before;
+    C.noalias() += A * Ba.adjoint();
+    VERIFY_IS_APPROX(C, expected);
+  }
+}
+
+template <typename Scalar>
+static void test_conjugated_products() {
+  for (int n : sme_edge_sizes<Scalar>()) {
+    verify_conjugated_products<Scalar, SmeColMajorMat<Scalar>, SmeColMajorMat<Scalar>, SmeColMajorMat<Scalar>>(n);
+    verify_conjugated_products<Scalar, SmeRowMajorMat<Scalar>, SmeColMajorMat<Scalar>, SmeColMajorMat<Scalar>>(n);
+    verify_conjugated_products<Scalar, SmeColMajorMat<Scalar>, SmeRowMajorMat<Scalar>, SmeRowMajorMat<Scalar>>(n);
+    verify_conjugated_products<Scalar, SmeRowMajorMat<Scalar>, SmeRowMajorMat<Scalar>, SmeColMajorMat<Scalar>>(n);
+  }
+}
+
+template <typename Scalar>
+static void test_products() {
+  const int MR = sme_mr<Scalar>();
+
+  // Square edge cases around the block and tile boundaries.
+  for (int n : sme_edge_sizes<Scalar>()) product(SmeColMajorMat<Scalar>(n, n));
+
+  // Thin / wide rectangular cases (M x 1, 1 x N) and non-square cases that
+  // exercise tail paths for both M and N.
+  product(SmeColMajorMat<Scalar>(MR, 1));
+  product(SmeColMajorMat<Scalar>(1, MR));
+  product(SmeColMajorMat<Scalar>(1, 2 * MR));
+  product(SmeColMajorMat<Scalar>(2 * MR, 1));
+  product(SmeColMajorMat<Scalar>(MR + 1, 2 * MR + 1));
+  product(SmeColMajorMat<Scalar>(2 * MR + 1, MR + 1));
+  product(SmeColMajorMat<Scalar>(MR - 1, 2 * MR - 1));
+  product(SmeColMajorMat<Scalar>(MR + 1, 7));
+  product(SmeColMajorMat<Scalar>(7, MR + 1));
+  product(SmeColMajorMat<Scalar>(4 * MR, 3));
+  product(SmeColMajorMat<Scalar>(3, 4 * MR));
+
+  test_deep_k_split<Scalar>();
+  test_edge_sizes_deep_k<Scalar>();
+
+  // Random sizes
+  for (int i = 0; i < g_repeat; i++) {
+    product(SmeColMajorMat<Scalar>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                   internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+  }
+
+  // Exercise the RowMajor packers and RowMajor result path.  When the input
+  // MatrixType is RowMajor, product() instantiates m1/m2/m3/res in RowMajor,
+  // so every matrix-matrix product in the suite flows through:
+  //   - the RowMajor LHS packer (gemm_pack_lhs<..., RowMajor>)
+  //   - the RowMajor RHS packer (gemm_pack_rhs<..., RowMajor>)
+  //   - the RowMajor-C dispatch in GeneralMatrixMatrix.h (which transposes
+  //     the computation: C^T = B^T * A^T).
+  for (int n : sme_edge_sizes<Scalar>()) {
+    if (n > 1) product(SmeRowMajorMat<Scalar>(n, n));
+  }
+  product(SmeRowMajorMat<Scalar>(MR + 1, 2 * MR + 1));
+  product(SmeRowMajorMat<Scalar>(2 * MR + 1, MR + 1));
+  for (int i = 0; i < g_repeat; i++) {
+    product(SmeRowMajorMat<Scalar>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
+                                   internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
+  }
+
+  // Exercise the general-stride branch of sme_store_za_tile: fires when both
+  // C_stride_row != 1 and C_stride_col != 1, e.g. a Map<Matrix> with an
+  // explicit non-unit inner stride.  product.h never builds such a result, so
+  // without this subtest the scalar-scatter path is effectively untested.
+  for (int n : sme_edge_sizes<Scalar>()) {
+    if (n < 2) continue;
+    test_general_strided_result<Scalar, SmeColMajorMat<Scalar>>(n);
+    test_general_strided_result<Scalar, SmeRowMajorMat<Scalar>>(n);
+    test_rowmajor_strided_result<Scalar>(n);
+  }
+
+  // Row-LHS x Row-RHS -> Col-C: the one LHS/RHS/C storage combination that
+  // product.h's transpose-style expressions never build directly (it always
+  // flips one side of the multiplication).  The code paths are the same as
+  // other combinations via Eigen's dispatch, but exercise them explicitly.
+  for (int n : sme_edge_sizes<Scalar>()) {
+    if (n < 2) continue;
+    SmeRowMajorMat<Scalar> A = SmeRowMajorMat<Scalar>::Random(n, n);
+    SmeRowMajorMat<Scalar> B = SmeRowMajorMat<Scalar>::Random(n, n);
+    SmeColMajorMat<Scalar> C = SmeColMajorMat<Scalar>::Zero(n, n);
+    C.noalias() += A * B;
+    VERIFY_IS_APPROX(C, (A.lazyProduct(B)).eval());
+  }
+}
+
+EIGEN_DECLARE_TEST(product_sme) {
+  CALL_SUBTEST_1(test_whilelt_operand_types<float>());
+  CALL_SUBTEST_1(test_products<float>());
+  CALL_SUBTEST_1(test_conjugated_products<float>());
+  CALL_SUBTEST_1(test_symm_pack<float>());
+  CALL_SUBTEST_1(test_pack_direct<float>());
+  CALL_SUBTEST_1(test_mapper_fallback<float>());
+  CALL_SUBTEST_1(test_neon_small_blocks<float>());
+
+  // double reaches the SME kernel and packers only with FEAT_SME_F64F64; the
+  // product sweep is meaningful either way, but the packed-layout tests name
+  // specializations that only exist when it is available.
+  CALL_SUBTEST_2(test_products<double>());
+  CALL_SUBTEST_2(test_conjugated_products<double>());
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+  CALL_SUBTEST_2(test_whilelt_operand_types<double>());
+  CALL_SUBTEST_2(test_symm_pack<double>());
+  CALL_SUBTEST_2(test_pack_direct<double>());
+  CALL_SUBTEST_2(test_mapper_fallback<double>());
+  CALL_SUBTEST_2(test_neon_small_blocks<double>());
+#endif
+
+  CALL_SUBTEST_3(test_products<std::complex<float>>());
+  CALL_SUBTEST_3(test_conjugated_products<std::complex<float>>());
+  CALL_SUBTEST_3(test_symm_pack<std::complex<float>>());
+  CALL_SUBTEST_3(test_pack_direct<std::complex<float>>());
+  CALL_SUBTEST_3(test_mapper_fallback<std::complex<float>>());
+  CALL_SUBTEST_3(test_neon_small_blocks<std::complex<float>>());
+
+  // complex<double> accumulates into ZA.D tiles, so it needs FEAT_SME_F64F64
+  // exactly as double does.
+  CALL_SUBTEST_4(test_products<std::complex<double>>());
+  CALL_SUBTEST_4(test_conjugated_products<std::complex<double>>());
+#ifdef EIGEN_VECTORIZE_SME_F64F64
+  CALL_SUBTEST_4(test_symm_pack<std::complex<double>>());
+  CALL_SUBTEST_4(test_pack_direct<std::complex<double>>());
+  CALL_SUBTEST_4(test_mapper_fallback<std::complex<double>>());
+  CALL_SUBTEST_4(test_neon_small_blocks<std::complex<double>>());
+#endif
+
+  // A scalar type SME does not specialize, proving it still routes through the
+  // generic product path inside an SME build -- where packet traits, alignment
+  // and cache blocking all differ from a plain NEON build.
+  CALL_SUBTEST_5(product(Matrix<long double, Dynamic, Dynamic>(33, 17)));
+}
diff --git a/test/product_symm.cpp b/test/product_symm.cpp
index 0b92932..ed84763 100644
--- a/test/product_symm.cpp
+++ b/test/product_symm.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -93,12 +94,51 @@
   VERIFY_IS_APPROX(rhs22 = (rhs2) * (m2).template selfadjointView<Lower>(), rhs23 = (rhs2) * (m1));
   VERIFY_IS_APPROX(rhs22 = (s2 * rhs2) * (s1 * m2).template selfadjointView<Lower>(), rhs23 = (s2 * rhs2) * (s1 * m1));
 
+  // Self-adjoint times self-adjoint or triangular view: the right factor is densified and the
+  // product runs the SYMM kernel, including the scalar factor folded into the left view.
+  {
+    MatrixType m4 = MatrixType::Random(rows, cols), m5(rows, cols), m6(rows, cols), m7(rows, cols);
+    m4 = (m4 + m4.adjoint()).eval();
+    m5 = m4.template triangularView<Upper>();
+    const MatrixType tri4 = m4.template triangularView<UnitLower>();
+    VERIFY_IS_APPROX(m6 = m2.template selfadjointView<Lower>() * m5.template selfadjointView<Upper>(), m7 = m1 * m4);
+    VERIFY_IS_APPROX(m6.noalias() = (s1 * m2).template selfadjointView<Lower>() * m5.template selfadjointView<Upper>(),
+                     m7 = (s1 * m1) * m4);
+    VERIFY_IS_APPROX(m6 = m2.template selfadjointView<Lower>() * m4.template triangularView<UnitLower>(),
+                     m7 = m1 * tri4);
+    VERIFY_IS_APPROX(m6.noalias() = m4.template triangularView<UnitLower>() * m2.template selfadjointView<Lower>(),
+                     m7 = tri4 * m1);
+    VERIFY_IS_APPROX(
+        m6 = m2.adjoint().template selfadjointView<Upper>() * m5.transpose().template selfadjointView<Lower>(),
+        m7 = m1.adjoint() * m4.transpose());
+    m6.setRandom();
+    m7 = m6;
+    VERIFY_IS_APPROX(m6.noalias() += m2.template selfadjointView<Lower>() * m5.template selfadjointView<Upper>(),
+                     m7 += m1 * m4);
+    VERIFY_IS_APPROX(m6.noalias() -= s1 * (m2.template selfadjointView<Lower>() * m5.template selfadjointView<Upper>()),
+                     m7 -= s1 * (m1 * m4));
+    // A scalar folded into the densified self-adjoint factor multiplies the mirrored triangle too, as the SYMM
+    // kernel does for the structured factor; plain evaluation of the view would conjugate it for complex s1.
+    VERIFY_IS_APPROX(m6 = m4.template triangularView<UnitLower>() * (s1 * m2.template selfadjointView<Lower>()),
+                     m7 = tri4 * (s1 * m1));
+    VERIFY_IS_APPROX(m6 = (s1 * m2.template selfadjointView<Lower>()) * m4.template triangularView<UnitLower>(),
+                     m7 = (s1 * m1) * tri4);
+    VERIFY_IS_APPROX(m6 = m2.template selfadjointView<Lower>() * (s1 * m5.template selfadjointView<Upper>()),
+                     m7 = m1 * (s1 * m4));
+    // s1 cannot fold into the unit diagonal, so s1 * (UnitTri * SA) evaluates the product first and scales it.
+    VERIFY_IS_APPROX(m6 = s1 * (m4.template triangularView<UnitLower>() * m2.template selfadjointView<Lower>()),
+                     m7 = s1 * (tri4 * m1));
+  }
+
   // destination with a non-default inner-stride
   // see bug 1741
   {
     typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
     MatrixX buffer(2 * cols, 2 * othersize);
-    Map<Rhs1, 0, Stride<Dynamic, 2> > map1(buffer.data(), cols, othersize, Stride<Dynamic, 2>(2 * rows, 2));
+    // As for map2 below, the outer stride spans Rhs1's outer dimension, which is not rows() when
+    // Rhs1 is row major.
+    Map<Rhs1, 0, Stride<Dynamic, 2> > map1(buffer.data(), cols, othersize,
+                                           Stride<Dynamic, 2>(2 * rhs13.outerStride(), 2));
     buffer.setZero();
     VERIFY_IS_APPROX(map1.noalias() = (s1 * m2).template selfadjointView<Lower>() * (s2 * rhs1),
                      rhs13 = (s1 * m1) * (s2 * rhs1));
@@ -110,6 +150,35 @@
   }
 }
 
+// Physical RowMajor selfadjoint operand.  symm<> above always builds a ColMajor
+// operand, so the RowMajor packers -- symm_pack_lhs/symm_pack_rhs specialized on
+// RowMajor, including the SME versions whose transposed regions carry the
+// two-pass trailing transpose -- are otherwise never reached through the public
+// API.  Both operand positions (selfadjoint on the LHS and on the RHS) and both
+// stored triangles are checked against a dense reference.
+template <typename Scalar, int DenseStorageOrder = EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION>
+void symm_rowmajor_selfadjoint(Index size, Index othersize) {
+  using RowMat = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+  using DenseMat = Matrix<Scalar, Dynamic, Dynamic, DenseStorageOrder>;
+
+  RowMat m1 = RowMat::Random(size, size);
+  m1 = (m1 + m1.adjoint()).eval();  // exactly self-adjoint
+  RowMat lo = m1.template triangularView<Lower>();
+  RowMat up = m1.template triangularView<Upper>();
+
+  // Selfadjoint on the LHS: packs the RowMajor operand via symm_pack_lhs.
+  DenseMat rhs = DenseMat::Random(size, othersize);
+  DenseMat ref = m1 * rhs;
+  VERIFY_IS_APPROX(DenseMat(lo.template selfadjointView<Lower>() * rhs), ref);
+  VERIFY_IS_APPROX(DenseMat(up.template selfadjointView<Upper>() * rhs), ref);
+
+  // Selfadjoint on the RHS: packs the RowMajor operand via symm_pack_rhs.
+  DenseMat lhs = DenseMat::Random(othersize, size);
+  DenseMat ref2 = lhs * m1;
+  VERIFY_IS_APPROX(DenseMat(lhs * lo.template selfadjointView<Lower>()), ref2);
+  VERIFY_IS_APPROX(DenseMat(lhs * up.template selfadjointView<Upper>()), ref2);
+}
+
 // Test symmetric products at blocking boundary sizes.
 // The existing test uses random sizes; these deterministic sizes exercise
 // transitions in GEBP blocking (early-return at 48, block size changes).
@@ -128,6 +197,137 @@
     // complex float, matrix RHS
     symm<std::complex<float>, Dynamic, Dynamic>(n, 3);
   }
+
+  // RowMajor selfadjoint operand.  The partial last-panel widths in this list
+  // drive the RowMajor packers' transposed regions through the two-pass trailing
+  // transpose for streaming vector lengths from SVL=128 (svlw=4) up to SVL=2048
+  // (svlw=64): a partial width w in (svlw, 2*svlw) needs two predicated passes.
+  const int sa_sizes[] = {1, 5, 7, 17, 32, 33, 39, 45, 48, 49, 55, 57, 63, 64, 65, 96};
+  for (int n : sa_sizes) {
+    symm_rowmajor_selfadjoint<float>(n, 7);
+    symm_rowmajor_selfadjoint<float>(n, 1);
+    symm_rowmajor_selfadjoint<double>(n, 4);
+  }
+}
+
+// Packed-buffer contract: symm_pack_lhs/rhs applied to a stored triangle must
+// be bit-identical to gemm_pack_lhs/rhs applied to the reconstructed dense
+// matrix -- gebp_kernel cannot tell the two apart. Sentinels in the unused
+// triangle catch reads of the wrong half; a marker past the packed range (in
+// both buffers) catches writing too much or too little.
+
+template <typename Scalar>
+Scalar symm_pack_sentinel() {
+  return Scalar(typename NumTraits<Scalar>::Real(98765));
+}
+
+// Build an n x n Hermitian `full` and its triangle-only image `stored`
+// (row >= col valid, sentinel elsewhere).
+template <typename MatrixType>
+void make_stored_triangle(Index n, MatrixType& stored, MatrixType& full) {
+  full = MatrixType::Random(n, n);
+  full = (full + full.adjoint()).eval();
+  stored = MatrixType::Constant(n, n, symm_pack_sentinel<typename MatrixType::Scalar>());
+  stored.template triangularView<Lower>() = full;
+}
+
+// A buffer holding `packed_size` packed entries followed by overrun markers.
+template <typename Scalar>
+Matrix<Scalar, Dynamic, 1> make_marked_buffer(Index packed_size) {
+  return Matrix<Scalar, Dynamic, 1>::Constant(packed_size + 32, Scalar(typename NumTraits<Scalar>::Real(-31415)));
+}
+
+template <typename Scalar, int StorageOrder>
+void check_symm_pack_lhs(Index kc) {
+  using Traits = internal::gebp_traits<Scalar, Scalar>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using Mapper = internal::const_blas_data_mapper<Scalar, Index, StorageOrder>;
+  Mat stored, full;
+  make_stored_triangle<Mat>(kc, stored, full);
+
+  Matrix<Scalar, Dynamic, 1> packed = make_marked_buffer<Scalar>(kc * kc);
+  Matrix<Scalar, Dynamic, 1> ref = packed;
+
+  internal::symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, StorageOrder>()(packed.data(), stored.data(),
+                                                                                          stored.outerStride(), kc, kc);
+  internal::gemm_pack_lhs<Scalar, Index, Mapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing,
+                          StorageOrder, false, false>()(ref.data(), Mapper(full.data(), full.outerStride()), kc, kc);
+  VERIFY_IS_EQUAL(packed, ref);
+}
+
+template <typename Scalar, int StorageOrder>
+void check_symm_pack_rhs(Index n, Index rows, Index k2) {
+  using Traits = internal::gebp_traits<Scalar, Scalar>;
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using Mapper = internal::const_blas_data_mapper<Scalar, Index, StorageOrder>;
+  Mat stored, full;
+  make_stored_triangle<Mat>(n, stored, full);
+
+  Matrix<Scalar, Dynamic, 1> packed = make_marked_buffer<Scalar>(rows * n);
+  Matrix<Scalar, Dynamic, 1> ref = packed;
+
+  internal::symm_pack_rhs<Scalar, Index, Traits::nr, StorageOrder>()(packed.data(), stored.data(), stored.outerStride(),
+                                                                     rows, n, k2);
+  internal::gemm_pack_rhs<Scalar, Index, Mapper, Traits::nr, StorageOrder, false, false>()(
+      ref.data(), Mapper(full.data(), full.outerStride()).getSubMapper(k2, 0), rows, n);
+  VERIFY_IS_EQUAL(packed, ref);
+}
+
+template <typename Scalar>
+void symm_pack_buffers() {
+  using Traits = internal::gebp_traits<Scalar, Scalar>;
+  constexpr Index mr = Traits::mr;
+  constexpr Index nr = Traits::nr;
+  constexpr Index ps = internal::packet_traits<Scalar>::size;
+
+  // LHS: every panel width up to a full panel plus a packet, then multi-panel
+  // borders around the 2*mr/3*mr transitions and the half-packet tail.
+  for (Index kc = 1; kc <= mr + ps + 2; ++kc) {
+    check_symm_pack_lhs<Scalar, ColMajor>(kc);
+    check_symm_pack_lhs<Scalar, RowMajor>(kc);
+  }
+  const Index lhs_borders[] = {2 * mr - 1, 2 * mr, 2 * mr + 1, 3 * mr, 3 * mr + ps / 2, 3 * mr + ps / 2 + 1, 97};
+  for (Index kc : lhs_borders) {
+    check_symm_pack_lhs<Scalar, ColMajor>(kc);
+    check_symm_pack_lhs<Scalar, RowMajor>(kc);
+  }
+
+  // RHS: sizes on and off the 8/4-column panel grid, with every depth block
+  // the driver's blocking can produce (k2 a multiple of 8; a block ends
+  // 8-aligned or at the matrix edge).
+  const Index rhs_sizes[] = {1,  2,  3,  nr - 1, nr, nr + 1, 2 * nr + 1, 15, 16, 17,
+                             23, 24, 25, 31,     32, 33,     47,         48, 49, 97};
+  for (Index n : rhs_sizes) {
+    if (n < 1) continue;
+    for (Index k2 = 0; k2 < n; k2 += 8) {
+      check_symm_pack_rhs<Scalar, ColMajor>(n, n - k2, k2);
+      check_symm_pack_rhs<Scalar, RowMajor>(n, n - k2, k2);
+      for (Index rows = 8; k2 + rows <= (n / 8) * 8; rows += 8) {
+        check_symm_pack_rhs<Scalar, ColMajor>(n, rows, k2);
+        check_symm_pack_rhs<Scalar, RowMajor>(n, rows, k2);
+      }
+    }
+  }
+}
+
+template <int>
+void symm_packers_and_rowmajor_operands() {
+  symm_pack_buffers<float>();
+  symm_pack_buffers<double>();
+  symm_pack_buffers<std::complex<float> >();
+  symm_pack_buffers<std::complex<double> >();
+
+  const Index sizes[] = {1, 2, 7, 8, 9, 24, 25, 31, 32, 33, 47, 48, 49, 65};
+  for (Index n : sizes) {
+    for (Index m : {1, 3, 17}) {
+      symm_rowmajor_selfadjoint<float, ColMajor>(n, m);
+      symm_rowmajor_selfadjoint<double, ColMajor>(n, m);
+      symm_rowmajor_selfadjoint<std::complex<float>, ColMajor>(n, m);
+      symm_rowmajor_selfadjoint<float, RowMajor>(n, m);
+      symm_rowmajor_selfadjoint<double, RowMajor>(n, m);
+      symm_rowmajor_selfadjoint<std::complex<float>, RowMajor>(n, m);
+    }
+  }
 }
 
 EIGEN_DECLARE_TEST(product_symm) {
@@ -149,4 +349,7 @@
 
   // Deterministic blocking boundary tests (outside g_repeat).
   CALL_SUBTEST_9(product_symm_boundary<0>());
+
+  // Packed-buffer contract checks and RowMajor selfadjoint operands.
+  CALL_SUBTEST_10(symm_packers_and_rowmajor_operands<0>());
 }
diff --git a/test/product_syrk.cpp b/test/product_syrk.cpp
index d50f4c4..6189948 100644
--- a/test/product_syrk.cpp
+++ b/test/product_syrk.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "product_test_helpers.h"
 
 template <typename MatrixType>
 void syrk(const MatrixType& m) {
@@ -38,28 +40,32 @@
   VERIFY_IS_APPROX((m2.template selfadjointView<Lower>().rankUpdate(rhs2, s1)._expression()),
                    ((s1 * rhs2 * rhs2.adjoint()).eval().template triangularView<Lower>().toDenseMatrix()));
   m2.setZero();
-  VERIFY_IS_APPROX(((m2.template triangularView<Lower>() += s1 * rhs2 * rhs22.adjoint()).nestedExpression()),
-                   ((s1 * rhs2 * rhs22.adjoint()).eval().template triangularView<Lower>().toDenseMatrix()));
+  VERIFY(verifyProduct((m2.template triangularView<Lower>() += s1 * rhs2 * rhs22.adjoint()).nestedExpression(),
+                       (s1 * rhs2 * rhs22.adjoint()).eval().template triangularView<Lower>().toDenseMatrix(), s1 * rhs2,
+                       rhs22.adjoint()));
 
   m2.setZero();
   VERIFY_IS_APPROX(m2.template selfadjointView<Upper>().rankUpdate(rhs2, s1)._expression(),
                    (s1 * rhs2 * rhs2.adjoint()).eval().template triangularView<Upper>().toDenseMatrix());
   m2.setZero();
-  VERIFY_IS_APPROX((m2.template triangularView<Upper>() += s1 * rhs22 * rhs2.adjoint()).nestedExpression(),
-                   (s1 * rhs22 * rhs2.adjoint()).eval().template triangularView<Upper>().toDenseMatrix());
+  VERIFY(verifyProduct((m2.template triangularView<Upper>() += s1 * rhs22 * rhs2.adjoint()).nestedExpression(),
+                       (s1 * rhs22 * rhs2.adjoint()).eval().template triangularView<Upper>().toDenseMatrix(),
+                       s1 * rhs22, rhs2.adjoint()));
 
   m2.setZero();
   VERIFY_IS_APPROX(m2.template selfadjointView<Lower>().rankUpdate(rhs1.adjoint(), s1)._expression(),
                    (s1 * rhs1.adjoint() * rhs1).eval().template triangularView<Lower>().toDenseMatrix());
   m2.setZero();
-  VERIFY_IS_APPROX((m2.template triangularView<Lower>() += s1 * rhs11.adjoint() * rhs1).nestedExpression(),
-                   (s1 * rhs11.adjoint() * rhs1).eval().template triangularView<Lower>().toDenseMatrix());
+  VERIFY(verifyProduct((m2.template triangularView<Lower>() += s1 * rhs11.adjoint() * rhs1).nestedExpression(),
+                       (s1 * rhs11.adjoint() * rhs1).eval().template triangularView<Lower>().toDenseMatrix(),
+                       s1 * rhs11.adjoint(), rhs1));
 
   m2.setZero();
   VERIFY_IS_APPROX(m2.template selfadjointView<Upper>().rankUpdate(rhs1.adjoint(), s1)._expression(),
                    (s1 * rhs1.adjoint() * rhs1).eval().template triangularView<Upper>().toDenseMatrix());
-  VERIFY_IS_APPROX((m2.template triangularView<Upper>() = s1 * rhs1.adjoint() * rhs11).nestedExpression(),
-                   (s1 * rhs1.adjoint() * rhs11).eval().template triangularView<Upper>().toDenseMatrix());
+  VERIFY(verifyProduct((m2.template triangularView<Upper>() = s1 * rhs1.adjoint() * rhs11).nestedExpression(),
+                       (s1 * rhs1.adjoint() * rhs11).eval().template triangularView<Upper>().toDenseMatrix(),
+                       s1 * rhs1.adjoint(), rhs11));
 
   m2.setZero();
   VERIFY_IS_APPROX(m2.template selfadjointView<Lower>().rankUpdate(rhs3.adjoint(), s1)._expression(),
@@ -147,18 +153,39 @@
   }
 }
 
+template <typename MatrixType>
+void syrk_empty_update(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> UpdateType;
+
+  MatrixType m = MatrixType::Random(size, size);
+  MatrixType ref = m;
+  UpdateType empty_update(size, 0);
+
+  m.template selfadjointView<Lower>().rankUpdate(empty_update, Scalar(1));
+  VERIFY_IS_APPROX(m, ref);
+
+  m.template selfadjointView<Upper>().rankUpdate(empty_update, Scalar(1));
+  VERIFY_IS_APPROX(m, ref);
+}
+
 EIGEN_DECLARE_TEST(product_syrk) {
+  typedef Matrix<double, Dynamic, Dynamic, RowMajor> RowMajorMatrixXd EIGEN_UNUSED;
+
   for (int i = 0; i < g_repeat; i++) {
     int s;
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
     CALL_SUBTEST_1(syrk(MatrixXf(s, s)));
     CALL_SUBTEST_2(syrk(MatrixXd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
     CALL_SUBTEST_3(syrk(MatrixXcf(s, s)));
     CALL_SUBTEST_4(syrk(MatrixXcd(s, s)));
     CALL_SUBTEST_5(syrk(Matrix<bfloat16, Dynamic, Dynamic>(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
+
+    CALL_SUBTEST_6(syrk_empty_update<MatrixXd>(48));
+    CALL_SUBTEST_7(syrk_empty_update<RowMajorMatrixXd>(48));
   }
 }
diff --git a/test/product_test_helpers.h b/test/product_test_helpers.h
new file mode 100644
index 0000000..746de37
--- /dev/null
+++ b/test/product_test_helpers.h
@@ -0,0 +1,87 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_PRODUCT_TEST_HELPERS_H
+#define EIGEN_TEST_PRODUCT_TEST_HELPERS_H
+
+#include <iostream>
+
+#include <Eigen/Core>
+
+namespace Eigen {
+
+// Rounding error bounds for matrix products, based on:
+//
+//   Deterministic: Higham, "Accuracy and Stability of Numerical Algorithms",
+//     Thm 3.5: |fl(A*B) - A*B| <= gamma_k * |A| * |B|,  gamma_k ~ k * epsilon.
+//
+//   Probabilistic: Higham & Mary, "A New Approach to Probabilistic Rounding
+//     Error Analysis", SISC 2019, Thm 3.4: under the assumption that rounding
+//     errors are independent with mean zero:
+//       |fl(A*B) - A*B| <= gamma_tilde_k * |A| * |B|,
+//       gamma_tilde_k ~ lambda * sqrt(k) * epsilon,
+//     holding with probability >= 1 - 2*exp(-lambda^2/2) per inner product.
+//
+// The bound is absolute rather than relative on purpose: || |A|*|B| ||_F /
+// ||A*B||_F is unbounded, so no multiple of epsilon bounds the relative error
+// of a product whose result cancels. Random operands do reach that regime — for
+// A = m1*m1^T, B = m2, the result vanishes as m1^T*m2 does.
+//
+// Parameters:
+//   num_products: number of independent products contributing error (default 1).
+//                 Use 2 when comparing two different evaluations of A*B.
+//   lambda:       probability parameter; P(lambda) = 1 - 2*exp(-lambda^2/2).
+//                 lambda=5 gives P > 0.9999 per inner product.
+
+// Returns lambda * sqrt(k) * epsilon * num_products * || |A|*|B| ||_F, with epsilon that of the
+// operand scalar but the value kept in double: narrowed to half, a triple-product bound already
+// overflows at k = 100 for all-one operands.
+//
+// || |A|*|B| ||_F is accumulated in double with an explicit loop rather than formed as
+// (A.cwiseAbs() * B.cwiseAbs()).norm(): a bound built with the product implementation would inherit
+// that implementation's defects, and one that overflowed to infinity would admit any result at all.
+template <typename DerivedA, typename DerivedB>
+double product_error_bound(const MatrixBase<DerivedA>& A, const MatrixBase<DerivedB>& B, int num_products = 1,
+                           double lambda = 5) {
+  using Scalar = typename DerivedA::Scalar;
+  const Index k = A.cols();
+  double squared_norm = 0.0;
+  for (Index i = 0; i < A.rows(); ++i)
+    for (Index j = 0; j < B.cols(); ++j) {
+      double sum = 0.0;
+      for (Index l = 0; l < k; ++l)
+        sum += static_cast<double>(numext::abs(A.coeff(i, l))) * static_cast<double>(numext::abs(B.coeff(l, j)));
+      squared_norm += sum * sum;
+    }
+  return lambda * numext::sqrt(double(k)) * static_cast<double>(NumTraits<Scalar>::epsilon()) * double(num_products) *
+         numext::sqrt(squared_norm);
+}
+
+// Verify that two computations of A*B agree within the Higham-Mary bound.
+// Returns true if ||actual - expected||_F <= product_error_bound(A, B, ...).
+//
+// The error norm is accumulated in double like the bound, so that it overflows only when the
+// difference itself does. A non-finite error or bound fails: inf <= inf would otherwise accept
+// an overflowed result.
+template <typename D1, typename D2, typename DA, typename DB>
+inline bool verifyProduct(const MatrixBase<D1>& actual, const MatrixBase<D2>& expected, const MatrixBase<DA>& A,
+                          const MatrixBase<DB>& B, int num_products = 2, double lambda = 5) {
+  const double bound = product_error_bound(A, B, num_products, lambda);
+  const typename D1::PlainObject diff = actual - expected;
+  double squared_error = 0.0;
+  for (Index j = 0; j < diff.cols(); ++j)
+    for (Index i = 0; i < diff.rows(); ++i) {
+      const double d = static_cast<double>(numext::abs(diff.coeff(i, j)));
+      squared_error += d * d;
+    }
+  const double error = numext::sqrt(squared_error);
+  if (!((numext::isfinite)(bound) && error <= bound)) {
+    std::cerr << "Product verification failed: error " << error << " exceeds bound " << bound << std::endl;
+    return false;
+  }
+  return true;
+}
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TEST_PRODUCT_TEST_HELPERS_H
diff --git a/test/product_threaded.cpp b/test/product_threaded.cpp
index 6bd9397..6b5c960 100644
--- a/test/product_threaded.cpp
+++ b/test/product_threaded.cpp
@@ -6,41 +6,68 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_GEMM_THREADPOOL
 #include "main.h"
 
+// Eigen::setGemmThreadPool(nullptr) is the *getter*: Parallelizer.h only stores the pointer when
+// it is non-null, so once any test registers a pool it stays registered for the rest of the
+// process.  A "serial" reference computed after that point is really a threaded one, and the
+// comparison degenerates into threaded-against-threaded.
+//
+// parallelize_gemm decides on min(nbThreads(), work-derived bound) <= 1 before it ever reaches the
+// pool, so forcing the thread count is what actually pins the serial path.  It also makes the
+// stale registration harmless.
+struct ScopedSerialGemm {
+  ScopedSerialGemm() : saved_threads_(Eigen::nbThreads()) { Eigen::setNbThreads(1); }
+  // In a thread-pool build nbThreads() reports the raw -1 that means "never set", and
+  // setNbThreads rejects a negative count.  0 is its documented "back to the pool's count".
+  ~ScopedSerialGemm() { Eigen::setNbThreads(saved_threads_ > 0 ? saved_threads_ : 0); }
+  ScopedSerialGemm(const ScopedSerialGemm&) = delete;
+  ScopedSerialGemm& operator=(const ScopedSerialGemm&) = delete;
+
+ private:
+  int saved_threads_;
+};
+
 void test_parallelize_gemm() {
   constexpr int n = 1024;
   constexpr int num_threads = 4;
   MatrixXf a = MatrixXf::Random(n, n);
   MatrixXf b = MatrixXf::Random(n, n);
   MatrixXf c = MatrixXf::Random(n, n);
-  c.noalias() = a * b;
+  {
+    ScopedSerialGemm serial;
+    c.noalias() = a * b;
+  }
 
-  ThreadPool pool(num_threads);
+  // static: setGemmThreadPool cannot unregister, so a pool with narrower lifetime than the process
+  // would leave a dangling pointer registered for whatever runs next.
+  static ThreadPool pool(num_threads);
   Eigen::setGemmThreadPool(&pool);
   MatrixXf c_threaded(n, n);
   c_threaded.noalias() = a * b;
 
   VERIFY_IS_APPROX(c, c_threaded);
-  Eigen::setGemmThreadPool(nullptr);
 }
 
 void test_parallelize_gemm_varied() {
   constexpr int num_threads = 4;
-  ThreadPool pool(num_threads);
+  static ThreadPool pool(num_threads);
 
   // Non-square float
   {
     MatrixXf a = MatrixXf::Random(512, 2048);
     MatrixXf b = MatrixXf::Random(2048, 256);
     MatrixXf c_serial(512, 256);
-    c_serial.noalias() = a * b;
+    {
+      ScopedSerialGemm serial;
+      c_serial.noalias() = a * b;
+    }
     Eigen::setGemmThreadPool(&pool);
     MatrixXf c_threaded(512, 256);
     c_threaded.noalias() = a * b;
-    Eigen::setGemmThreadPool(nullptr);
     VERIFY_IS_APPROX(c_serial, c_threaded);
   }
 
@@ -49,11 +76,13 @@
     MatrixXd a = MatrixXd::Random(512, 512);
     MatrixXd b = MatrixXd::Random(512, 512);
     MatrixXd c_serial(512, 512);
-    c_serial.noalias() = a * b;
+    {
+      ScopedSerialGemm serial;
+      c_serial.noalias() = a * b;
+    }
     Eigen::setGemmThreadPool(&pool);
     MatrixXd c_threaded(512, 512);
     c_threaded.noalias() = a * b;
-    Eigen::setGemmThreadPool(nullptr);
     VERIFY_IS_APPROX(c_serial, c_threaded);
   }
 
@@ -62,16 +91,72 @@
     MatrixXcd a = MatrixXcd::Random(256, 256);
     MatrixXcd b = MatrixXcd::Random(256, 256);
     MatrixXcd c_serial(256, 256);
-    c_serial.noalias() = a * b;
+    {
+      ScopedSerialGemm serial;
+      c_serial.noalias() = a * b;
+    }
     Eigen::setGemmThreadPool(&pool);
     MatrixXcd c_threaded(256, 256);
     c_threaded.noalias() = a * b;
-    Eigen::setGemmThreadPool(nullptr);
     VERIFY_IS_APPROX(c_serial, c_threaded);
   }
 }
 
+void test_balanced_gemm_range() {
+  static const Index totals[] = {0, 1, 3, 4, 7, 12, 63, 100, 4096, 8192, 9216};
+  static const Index part_counts[] = {1, 2, 3, 7, 8, 32, 64, 72};
+  static const Index grains[] = {1, 4, 6, 8, 12};
+  for (Index total : totals) {
+    for (Index parts : part_counts) {
+      for (Index grain : grains) {
+        Index expected_start = 0;
+        Index min_chunks = NumTraits<Index>::highest();
+        Index max_chunks = 0;
+        for (Index part = 0; part < parts; ++part) {
+          Index start = -1, length = -1;
+          internal::balanced_gemm_range<Index>(total, parts, grain, part, start, length);
+          // Gaps or overlaps corrupt the packed-lhs handoff, which indexes blockA by lhs_start.
+          VERIFY(start == expected_start);
+          VERIFY(length >= 0);
+          expected_start = start + length;
+          const Index chunks = numext::div_ceil(length, grain);
+          min_chunks = numext::mini(min_chunks, chunks);
+          max_chunks = numext::maxi(max_chunks, chunks);
+        }
+        VERIFY(expected_start == total);
+        // A single oversized range throttles every other thread.
+        VERIFY(max_chunks - min_chunks <= Index(1));
+      }
+    }
+  }
+}
+
+template <typename MatrixType>
+void verify_threaded_product(ThreadPool& pool, Index rows, Index depth, Index cols) {
+  MatrixType a = MatrixType::Random(rows, depth), b = MatrixType::Random(depth, cols);
+  MatrixType c_serial;
+  {
+    ScopedSerialGemm serial;
+    c_serial = a * b;
+  }
+  Eigen::setGemmThreadPool(&pool);
+  MatrixType c_threaded = a * b;
+  VERIFY_IS_APPROX(c_serial, c_threaded);
+}
+
+void test_parallelize_gemm_indivisible() {
+  // Shapes deliberately not divisible by the thread count, where the split has to spread the
+  // remainder rather than append it to the last thread.
+  static ThreadPool pool(8);
+  verify_threaded_product<MatrixXf>(pool, 517, 331, 523);
+  verify_threaded_product<MatrixXf>(pool, 1021, 331, 259);
+  verify_threaded_product<MatrixXf>(pool, 64, 331, 4099);
+  verify_threaded_product<MatrixXf>(pool, 4099, 331, 64);
+}
+
 EIGEN_DECLARE_TEST(product_threaded) {
   CALL_SUBTEST_1(test_parallelize_gemm());
   CALL_SUBTEST_2(test_parallelize_gemm_varied());
+  CALL_SUBTEST_3(test_balanced_gemm_range());
+  CALL_SUBTEST_4(test_parallelize_gemm_indivisible());
 }
diff --git a/test/product_trmm.cpp b/test/product_trmm.cpp
index a8a4220..6d53745 100644
--- a/test/product_trmm.cpp
+++ b/test/product_trmm.cpp
@@ -6,13 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
 template <typename T>
 int get_random_size() {
   const int factor = NumTraits<T>::ReadCost;
-  const int max_test_size = EIGEN_TEST_MAX_SIZE > 2 * factor ? EIGEN_TEST_MAX_SIZE / factor : EIGEN_TEST_MAX_SIZE;
+  constexpr int max_test_size = EIGEN_TEST_MAX_SIZE > 2 * factor ? EIGEN_TEST_MAX_SIZE / factor : EIGEN_TEST_MAX_SIZE;
   return internal::random<int>(1, max_test_size);
 }
 
@@ -89,6 +90,55 @@
 
   // TODO check with sub-matrix expressions ?
 
+  // Triangular times triangular or self-adjoint view: the right factor is densified and the product
+  // runs the TRMM kernel of the left one.
+  {
+    typedef Matrix<Scalar, Dynamic, Dynamic> MatrixX;
+    typedef Matrix<Scalar, Dynamic, Dynamic, ResOrder> ResXX;
+    // Hermitian operands, so that the self-adjoint views below have the real diagonal the SYMM kernel assumes.
+    TriMatrix mat2 = TriMatrix::Random(cols, cols), mat3 = TriMatrix::Random(rows, rows);
+    mat2 = (mat2 + mat2.adjoint()).eval();
+    mat3 = (mat3 + mat3.adjoint()).eval();
+    const MatrixX tri2 = mat2.template triangularView<UnitUpper>();
+    const MatrixX tri3 = mat3.template triangularView<StrictlyLower>();
+    const MatrixX sa2 = mat2.template selfadjointView<Lower>();
+    const MatrixX sa3 = mat3.template selfadjointView<Upper>();
+    ResXX res(rows, cols), res_save(rows, cols);
+
+    VERIFY_IS_APPROX(res = mat.template triangularView<Mode>() * mat2.template triangularView<UnitUpper>(), tri * tri2);
+    VERIFY_IS_APPROX(
+        res.noalias() = mat3.template triangularView<StrictlyLower>() * mat.template triangularView<Mode>(),
+        tri3 * tri);
+    VERIFY_IS_APPROX(res = mat.template triangularView<Mode>() * mat2.template selfadjointView<Lower>(), tri * sa2);
+    VERIFY_IS_APPROX(res.noalias() = mat3.template selfadjointView<Upper>() * mat.template triangularView<Mode>(),
+                     sa3 * tri);
+    VERIFY_IS_APPROX(res = (s1 * mat.transpose()).template triangularView<Mode>() *
+                           mat3.transpose().template triangularView<StrictlyUpper>(),
+                     s1triTr * tri3.transpose());
+
+    res.setRandom(rows, cols);
+    res_save = res;
+    VERIFY_IS_APPROX(res.noalias() += mat.template triangularView<Mode>() * mat2.template triangularView<UnitUpper>(),
+                     res_save + tri * tri2);
+    res_save = res;
+    VERIFY_IS_APPROX(res.noalias() -= mat3.template selfadjointView<Upper>() * mat.template triangularView<Mode>(),
+                     res_save - sa3 * tri);
+
+    // s1 cannot fold into a unit diagonal, so s1 * (UnitTri * V) evaluates the product first and scales it afterwards.
+    const MatrixX unit3 = mat3.template triangularView<UnitLower>();
+    VERIFY_IS_APPROX(res = s1 * (mat3.template triangularView<UnitLower>() * mat.template triangularView<Mode>()),
+                     s1 * (unit3 * tri));
+    ResXX res3(rows, rows);
+    VERIFY_IS_APPROX(
+        res3.noalias() = s1 * (mat3.template triangularView<UnitLower>() * mat3.template selfadjointView<Upper>()),
+        s1 * (unit3 * sa3));
+    res.setRandom(rows, cols);
+    res_save = res;
+    VERIFY_IS_APPROX(
+        res.noalias() -= s1 * (mat3.template triangularView<UnitLower>() * mat.template triangularView<Mode>()),
+        res_save - s1 * (unit3 * tri));
+  }
+
   // destination with a non-default inner-stride
   // see bug 1741
   {
@@ -141,4 +191,8 @@
     CALL_ALL(3, std::complex<float>);   //  EIGEN_SUFFIXES;13;113;23;123;33;133
     CALL_ALL(4, std::complex<double>);  //  EIGEN_SUFFIXES;14;114;24;124;34;134
   }
+  // 1x1 and blocking-boundary sizes for the view-times-view products.
+  CALL_SUBTEST_11((trmm<float, Lower, ColMajor, ColMajor, ColMajor>(1, 1, 1)));
+  CALL_SUBTEST_14((trmm<std::complex<double>, Upper, RowMajor, ColMajor, RowMajor>(1, 1, 1)));
+  CALL_SUBTEST_12((trmm<double, Upper, ColMajor, ColMajor, ColMajor>(EIGEN_TEST_MAX_SIZE, EIGEN_TEST_MAX_SIZE, 1)));
 }
diff --git a/test/product_trmv.cpp b/test/product_trmv.cpp
index 447243f..f912cfb 100644
--- a/test/product_trmv.cpp
+++ b/test/product_trmv.cpp
@@ -6,17 +6,16 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "product_test_helpers.h"
 
 template <typename MatrixType>
 void trmv(const MatrixType& m) {
   typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
 
-  RealScalar largerEps = 10 * test_precision<RealScalar>();
-
   Index rows = m.rows();
   Index cols = m.cols();
 
@@ -29,46 +28,53 @@
 
   // check with a column-major matrix
   m3 = m1.template triangularView<Eigen::Lower>();
-  VERIFY((m3 * v1).isApprox(m1.template triangularView<Eigen::Lower>() * v1, largerEps));
+  VERIFY(verifyProduct(m3 * v1, m1.template triangularView<Eigen::Lower>() * v1, m3, v1));
   m3 = m1.template triangularView<Eigen::Upper>();
-  VERIFY((m3 * v1).isApprox(m1.template triangularView<Eigen::Upper>() * v1, largerEps));
+  VERIFY(verifyProduct(m3 * v1, m1.template triangularView<Eigen::Upper>() * v1, m3, v1));
   m3 = m1.template triangularView<Eigen::UnitLower>();
-  VERIFY((m3 * v1).isApprox(m1.template triangularView<Eigen::UnitLower>() * v1, largerEps));
+  VERIFY(verifyProduct(m3 * v1, m1.template triangularView<Eigen::UnitLower>() * v1, m3, v1));
   m3 = m1.template triangularView<Eigen::UnitUpper>();
-  VERIFY((m3 * v1).isApprox(m1.template triangularView<Eigen::UnitUpper>() * v1, largerEps));
+  VERIFY(verifyProduct(m3 * v1, m1.template triangularView<Eigen::UnitUpper>() * v1, m3, v1));
 
   // check conjugated and scalar multiple expressions (col-major)
   m3 = m1.template triangularView<Eigen::Lower>();
-  VERIFY(((s1 * m3).conjugate() * v1)
-             .isApprox((s1 * m1).conjugate().template triangularView<Eigen::Lower>() * v1, largerEps));
+  VERIFY(verifyProduct((s1 * m3).conjugate() * v1, (s1 * m1).conjugate().template triangularView<Eigen::Lower>() * v1,
+                       (s1 * m3).conjugate(), v1));
   m3 = m1.template triangularView<Eigen::Upper>();
-  VERIFY((m3.conjugate() * v1.conjugate())
-             .isApprox(m1.conjugate().template triangularView<Eigen::Upper>() * v1.conjugate(), largerEps));
+  VERIFY(verifyProduct(m3.conjugate() * v1.conjugate(),
+                       m1.conjugate().template triangularView<Eigen::Upper>() * v1.conjugate(), m3.conjugate(),
+                       v1.conjugate()));
 
   // check with a row-major matrix
   m3 = m1.template triangularView<Eigen::Upper>();
-  VERIFY((m3.transpose() * v1).isApprox(m1.transpose().template triangularView<Eigen::Lower>() * v1, largerEps));
+  VERIFY(verifyProduct(m3.transpose() * v1, m1.transpose().template triangularView<Eigen::Lower>() * v1, m3.transpose(),
+                       v1));
   m3 = m1.template triangularView<Eigen::Lower>();
-  VERIFY((m3.transpose() * v1).isApprox(m1.transpose().template triangularView<Eigen::Upper>() * v1, largerEps));
+  VERIFY(verifyProduct(m3.transpose() * v1, m1.transpose().template triangularView<Eigen::Upper>() * v1, m3.transpose(),
+                       v1));
   m3 = m1.template triangularView<Eigen::UnitUpper>();
-  VERIFY((m3.transpose() * v1).isApprox(m1.transpose().template triangularView<Eigen::UnitLower>() * v1, largerEps));
+  VERIFY(verifyProduct(m3.transpose() * v1, m1.transpose().template triangularView<Eigen::UnitLower>() * v1,
+                       m3.transpose(), v1));
   m3 = m1.template triangularView<Eigen::UnitLower>();
-  VERIFY((m3.transpose() * v1).isApprox(m1.transpose().template triangularView<Eigen::UnitUpper>() * v1, largerEps));
+  VERIFY(verifyProduct(m3.transpose() * v1, m1.transpose().template triangularView<Eigen::UnitUpper>() * v1,
+                       m3.transpose(), v1));
 
   // check conjugated and scalar multiple expressions (row-major)
   m3 = m1.template triangularView<Eigen::Upper>();
-  VERIFY((m3.adjoint() * v1).isApprox(m1.adjoint().template triangularView<Eigen::Lower>() * v1, largerEps));
+  VERIFY(verifyProduct(m3.adjoint() * v1, m1.adjoint().template triangularView<Eigen::Lower>() * v1, m3.adjoint(), v1));
   m3 = m1.template triangularView<Eigen::Lower>();
-  VERIFY((m3.adjoint() * (s1 * v1.conjugate()))
-             .isApprox(m1.adjoint().template triangularView<Eigen::Upper>() * (s1 * v1.conjugate()), largerEps));
+  VERIFY(verifyProduct(m3.adjoint() * (s1 * v1.conjugate()),
+                       m1.adjoint().template triangularView<Eigen::Upper>() * (s1 * v1.conjugate()), m3.adjoint(),
+                       (s1 * v1.conjugate()).eval()));
   m3 = m1.template triangularView<Eigen::UnitUpper>();
 
   // check transposed cases:
   m3 = m1.template triangularView<Eigen::Lower>();
-  VERIFY((v1.transpose() * m3).isApprox(v1.transpose() * m1.template triangularView<Eigen::Lower>(), largerEps));
-  VERIFY((v1.adjoint() * m3).isApprox(v1.adjoint() * m1.template triangularView<Eigen::Lower>(), largerEps));
-  VERIFY((v1.adjoint() * m3.adjoint())
-             .isApprox(v1.adjoint() * m1.template triangularView<Eigen::Lower>().adjoint(), largerEps));
+  VERIFY(verifyProduct(v1.transpose() * m3, v1.transpose() * m1.template triangularView<Eigen::Lower>(), v1.transpose(),
+                       m3));
+  VERIFY(verifyProduct(v1.adjoint() * m3, v1.adjoint() * m1.template triangularView<Eigen::Lower>(), v1.adjoint(), m3));
+  VERIFY(verifyProduct(v1.adjoint() * m3.adjoint(), v1.adjoint() * m1.template triangularView<Eigen::Lower>().adjoint(),
+                       v1.adjoint(), m3.adjoint()));
 
   // TODO check with sub-matrices
 }
@@ -83,10 +89,10 @@
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2);
     CALL_SUBTEST_4(trmv(MatrixXcf(s, s)));
     CALL_SUBTEST_5(trmv(MatrixXcd(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
 
     s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
     CALL_SUBTEST_6(trmv(Matrix<float, Dynamic, Dynamic, RowMajor>(s, s)));
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 }
diff --git a/test/product_trsolve.cpp b/test/product_trsolve.cpp
index c7dfb25..ea7b7a1 100644
--- a/test/product_trsolve.cpp
+++ b/test/product_trsolve.cpp
@@ -6,6 +6,11 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Enables the runtime malloc tracking that trsolve_no_malloc() needs. Allocation stays allowed
+// by default; only the explicit set_is_malloc_allowed(false) windows below check it.
+#define EIGEN_RUNTIME_NO_MALLOC
 
 #include "main.h"
 
@@ -93,6 +98,21 @@
     VERIFY_TRSM(cmLhs.conjugate().template triangularView<Lower>(), map1);
     buffer.setZero();
     VERIFY_TRSM(cmLhs.template triangularView<Lower>(), map2);
+
+    // A runtime inner stride reaches the blocked kernels as OtherInnerStride == Dynamic, which the
+    // compile-time 2 above does not; their panel offsets once multiplied by that constant.
+    Map<Matrix<Scalar, Size, Cols, colmajor>, 0, Stride<Dynamic, Dynamic> > map3(
+        buffer.data(), cmRhs.rows(), cmRhs.cols(), Stride<Dynamic, Dynamic>(2 * cmRhs.outerStride(), 2));
+    Map<Matrix<Scalar, Size, Cols, rowmajor>, 0, Stride<Dynamic, Dynamic> > map4(
+        buffer.data(), rmRhs.rows(), rmRhs.cols(), Stride<Dynamic, Dynamic>(2 * rmRhs.outerStride(), 2));
+    buffer.setZero();
+    VERIFY_TRSM(cmLhs.template triangularView<Lower>(), map3);
+    buffer.setZero();
+    VERIFY_TRSM(cmLhs.template triangularView<Upper>(), map4);
+    buffer.setZero();
+    VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Lower>(), map3);
+    buffer.setZero();
+    VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Upper>(), map4);
   }
 
   if (Size == Dynamic) {
@@ -152,6 +172,24 @@
       VERIFY_IS_APPROX(lhs.triangularView<Upper>().toDenseMatrix() * MatrixX(map), ref);
     }
 
+    // Runtime inner stride (OtherInnerStride == Dynamic), both sides
+    {
+      int cols = 5;
+      MatrixX buffer(2 * n, 2 * cols);
+      Map<MatrixX, 0, Stride<Dynamic, Dynamic> > map(buffer.data(), n, cols, Stride<Dynamic, Dynamic>(2 * n, 2));
+      MatrixX ref(n, cols);
+      buffer.setZero();
+      map.setRandom();
+      ref = map;
+      lhs.triangularView<Lower>().solveInPlace(map);
+      VERIFY_IS_APPROX(lhs.triangularView<Lower>().toDenseMatrix() * MatrixX(map), ref);
+      buffer.setZero();
+      map.setRandom();
+      ref = map;
+      lhs.triangularView<Upper>().template solveInPlace<OnTheRight>(map.transpose());
+      VERIFY_IS_APPROX(MatrixX(map.transpose()) * lhs.triangularView<Upper>().toDenseMatrix(), ref.transpose());
+    }
+
     // InnerStride = 2: UnitLower (tests the UnitDiag path without diagonal scaling)
     {
       int cols = 3;
@@ -221,6 +259,196 @@
   }
 }
 
+void trsolve_indexed_view() {
+  typedef Matrix<double, Dynamic, Dynamic> MatrixX;
+  typedef Matrix<double, Dynamic, 1> VectorX;
+
+  MatrixX lhs = MatrixX::Random(8, 8);
+  lhs *= 0.1;
+  lhs.diagonal().array() += 1.0;
+
+  VectorX rhs = VectorX::Random(8);
+  std::vector<int> indices{0, 1, 2, 7};
+
+  MatrixX lhs_slice = lhs(indices, indices);
+  VectorX rhs_slice = rhs(indices);
+  VectorX expected = lhs_slice.triangularView<Upper>().solve(rhs_slice);
+
+  VectorX actual = lhs(indices, indices).triangularView<Upper>().solve(rhs(indices));
+  VERIFY_IS_APPROX(actual, expected);
+
+  VectorX assigned = VectorX::Random(8);
+  VectorX assigned_ref = assigned;
+  assigned(indices) = lhs_slice.triangularView<Upper>().solve(rhs_slice);
+  assigned_ref(indices) = expected;
+  VERIFY_IS_APPROX(assigned, assigned_ref);
+
+  VectorX inplace = rhs;
+  VectorX inplace_ref = rhs;
+  lhs_slice.triangularView<Upper>().solveInPlace(inplace(indices));
+  inplace_ref(indices) = expected;
+  VERIFY_IS_APPROX(inplace, inplace_ref);
+}
+
+#define VERIFY_TRSM_NO_MALLOC(TRI, XB, REF)                \
+  {                                                        \
+    (XB) = (REF);                                          \
+    internal::set_is_malloc_allowed(false);                \
+    (TRI).solveInPlace(XB);                                \
+    internal::set_is_malloc_allowed(true);                 \
+    VERIFY_IS_APPROX((TRI).toDenseMatrix() * (XB), (REF)); \
+  }
+
+#define VERIFY_TRSM_NO_MALLOC_ONTHERIGHT(TRI, XB, REF)     \
+  {                                                        \
+    (XB) = (REF);                                          \
+    internal::set_is_malloc_allowed(false);                \
+    (TRI).template solveInPlace<OnTheRight>(XB);           \
+    internal::set_is_malloc_allowed(true);                 \
+    VERIFY_IS_APPROX((XB) * (TRI).toDenseMatrix(), (REF)); \
+  }
+
+// Regression test for issue #3115: while malloc is disallowed, the AVX-512 trsm kernels delegate
+// to the unspecialized kernel, which takes an upper-triangular panel by the opposite corner. The
+// delegation used to keep the AVX-512 origin and solve outside the panel, reading and writing
+// past the ends of both operands.
+template <typename Scalar, int TriOptions>
+void trsolve_no_malloc(int size, int cols) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic, TriOptions> TriMatrix;
+  typedef Matrix<Scalar, Dynamic, Dynamic> RhsMatrix;
+
+  TriMatrix lhs = TriMatrix::Random(size, size) * RealScalar(0.1);
+  lhs.diagonal().array() += RealScalar(1);
+
+  RhsMatrix ref = RhsMatrix::Random(size, cols);
+  RhsMatrix x(size, cols);
+
+  VERIFY_TRSM_NO_MALLOC(lhs.template triangularView<Upper>(), x, ref);
+  VERIFY_TRSM_NO_MALLOC(lhs.template triangularView<Lower>(), x, ref);
+  VERIFY_TRSM_NO_MALLOC(lhs.template triangularView<UnitUpper>(), x, ref);
+  VERIFY_TRSM_NO_MALLOC(lhs.template triangularView<UnitLower>(), x, ref);
+  // The adjoint swaps the triangular operand's storage order.
+  VERIFY_TRSM_NO_MALLOC(lhs.adjoint().template triangularView<Upper>(), x, ref);
+  VERIFY_TRSM_NO_MALLOC(lhs.adjoint().template triangularView<Lower>(), x, ref);
+
+  RhsMatrix refRight = RhsMatrix::Random(cols, size);
+  RhsMatrix xRight(cols, size);
+
+  VERIFY_TRSM_NO_MALLOC_ONTHERIGHT(lhs.template triangularView<Upper>(), xRight, refRight);
+  VERIFY_TRSM_NO_MALLOC_ONTHERIGHT(lhs.template triangularView<Lower>(), xRight, refRight);
+  VERIFY_TRSM_NO_MALLOC_ONTHERIGHT(lhs.adjoint().template triangularView<Upper>(), xRight, refRight);
+  VERIFY_TRSM_NO_MALLOC_ONTHERIGHT(lhs.adjoint().template triangularView<Lower>(), xRight, refRight);
+}
+
+template <int>
+void trsolve_no_malloc_all() {
+  // The packed solver walks the triangular matrix in panels of max(mr, nr) columns; these sizes
+  // straddle that width for both float and double. They also stay small enough that the solver's
+  // blocking buffers come off the stack, since a heap allocation inside the windows below would
+  // trip the guard for an unrelated reason.
+  const int sizes[] = {1, 4, 17, 20, 24, 25, 40, 64};
+  const int colCounts[] = {1, 5, 20};
+  for (int size : sizes) {
+    for (int cols : colCounts) {
+      trsolve_no_malloc<float, ColMajor>(size, cols);
+      trsolve_no_malloc<float, RowMajor>(size, cols);
+      trsolve_no_malloc<double, ColMajor>(size, cols);
+      trsolve_no_malloc<double, RowMajor>(size, cols);
+      trsolve_no_malloc<std::complex<double>, ColMajor>(size, cols);
+    }
+  }
+}
+
+// The blocked solvers take their k-block depth, and a solve on the left its column panels, from the
+// cache sizes (issue #3162). Both take effect only for operands larger than the cache, which test-sized
+// solves are not on most hosts, so the caches are set here for a budget of 520 columns of the operand:
+// 1100 right-hand sides then span two full panels and a partial one, and on x86 the depth rises above
+// the blocking's on either side. Both storage orders of the right-hand side reach both kernels from
+// either side, since the dispatcher transposes a row-major operand.
+template <typename Scalar>
+void trsolve_panels(int size, int cols, bool allCases) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using MatrixX = Matrix<Scalar, Dynamic, Dynamic>;
+  using RowMatrixX = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+
+  const std::ptrdiff_t l1 = 32768, l2 = 65536;
+  const std::ptrdiff_t panelL3 = 4 * 520 * std::ptrdiff_t(size) * std::ptrdiff_t(sizeof(Scalar));
+  setCpuCacheSizes(l1, l2, panelL3);
+  const std::ptrdiff_t budget = internal::triangular_solve_budget<Scalar>(l2, panelL3);
+  // Reach: the budget holds fewer columns than the right-hand side has, and the operand exceeds it,
+  // which deepens the k-blocks wherever the blocking leaves room.
+  VERIFY(internal::triangular_solve_panel_columns(Index(size), Index(cols), budget,
+                                                  Index(internal::gebp_traits<Scalar, Scalar>::nr)) < cols);
+  VERIFY(std::ptrdiff_t(size) * cols > budget);
+
+  // Scaling the off-diagonal part by 1/size keeps the triangles well conditioned whether the diagonal
+  // is used or, for the unit views, taken as 1.
+  MatrixX cmLhs = MatrixX::Random(size, size) / RealScalar(size);
+  cmLhs.diagonal().array() += RealScalar(1);
+  RowMatrixX rmLhs = cmLhs;
+  MatrixX cmRhs(size, cols);
+  RowMatrixX rmRhs(size, cols);
+  MatrixX ref(size, cols);
+
+  VERIFY_TRSM(cmLhs.template triangularView<Lower>(), cmRhs);
+  VERIFY_TRSM(cmLhs.template triangularView<Upper>(), cmRhs);
+  VERIFY_TRSM(cmLhs.template triangularView<Lower>(), rmRhs);
+  VERIFY_TRSM(cmLhs.template triangularView<Upper>(), rmRhs);
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Lower>(), cmRhs);
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Upper>(), cmRhs);
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Lower>(), rmRhs);
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Upper>(), rmRhs);
+  if (!allCases) return;
+
+  VERIFY_TRSM(cmLhs.template triangularView<UnitLower>(), cmRhs);
+  VERIFY_TRSM(cmLhs.adjoint().template triangularView<Upper>(), rmRhs);
+  VERIFY_TRSM(rmLhs.template triangularView<Lower>(), cmRhs);
+  VERIFY_TRSM(rmLhs.conjugate().template triangularView<UnitUpper>(), rmRhs);
+
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<UnitUpper>(), rmRhs);
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.adjoint().template triangularView<Lower>(), cmRhs);
+  VERIFY_TRSM_ONTHERIGHT(rmLhs.template triangularView<Lower>(), rmRhs);
+  VERIFY_TRSM_ONTHERIGHT(rmLhs.conjugate().template triangularView<UnitUpper>(), cmRhs);
+
+  // A runtime inner stride, by which the panel origins must not be scaled.
+  MatrixX buffer(2 * size, 2 * cols);
+  Map<MatrixX, 0, Stride<Dynamic, Dynamic> > cmMap(buffer.data(), size, cols, Stride<Dynamic, Dynamic>(2 * size, 2));
+  Map<RowMatrixX, 0, Stride<Dynamic, Dynamic> > rmMap(buffer.data(), size, cols, Stride<Dynamic, Dynamic>(2 * cols, 2));
+  buffer.setZero();
+  VERIFY_TRSM(cmLhs.template triangularView<Lower>(), cmMap);
+  buffer.setZero();
+  VERIFY_TRSM(cmLhs.template triangularView<Upper>(), rmMap);
+  buffer.setZero();
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Upper>(), cmMap);
+  buffer.setZero();
+  VERIFY_TRSM_ONTHERIGHT(cmLhs.template triangularView<Lower>(), rmMap);
+
+  // A few rows beside a column-major triangle half of which exceeds the budget: only the triangle makes
+  // this solve on the right deep.
+  const std::ptrdiff_t triangleL3 = std::ptrdiff_t(size) * size * std::ptrdiff_t(sizeof(Scalar));
+  setCpuCacheSizes(l1, l2, triangleL3);
+  const std::ptrdiff_t triangleBudget = internal::triangular_solve_budget<Scalar>(l2, triangleL3);
+  VERIFY(std::ptrdiff_t(size) * size / 2 > triangleBudget && std::ptrdiff_t(size) * 7 <= triangleBudget);
+  RowMatrixX fewRows(size, 7);
+  VERIFY_TRSM_ONTHERIGHT(rmLhs.template triangularView<Lower>(), fewRows);
+  VERIFY_TRSM_ONTHERIGHT(rmLhs.template triangularView<Upper>(), fewRows);
+}
+
+template <int>
+void trsolve_panels_all() {
+  std::ptrdiff_t l1, l2, l3, l3_per_cpu;
+  internal::manage_caching_sizes(GetAction, &l1, &l2, &l3, &l3_per_cpu);
+  // 193 raises the depth of every x86 build except SSE2 float and double, which 391 raises; both leave a
+  // partial last k-block at every depth they reach.
+  trsolve_panels<float>(193, 1100, true);
+  trsolve_panels<double>(193, 1100, true);
+  trsolve_panels<std::complex<double> >(193, 1100, true);
+  trsolve_panels<float>(391, 1100, false);
+  trsolve_panels<double>(391, 1100, false);
+  internal::manage_caching_sizes(SetAction, &l1, &l2, &l3, &l3_per_cpu);
+}
+
 EIGEN_DECLARE_TEST(product_trsolve) {
   for (int i = 0; i < g_repeat; i++) {
     // matrices
@@ -250,4 +478,7 @@
 
   // Strided solve at blocking boundaries (deterministic, outside g_repeat).
   CALL_SUBTEST_15(trsolve_strided_boundary<0>());
+  CALL_SUBTEST_16(trsolve_indexed_view());
+  CALL_SUBTEST_17(trsolve_no_malloc_all<0>());
+  CALL_SUBTEST_18(trsolve_panels_all<0>());
 }
diff --git a/test/qr.cpp b/test/qr.cpp
index f7f6990..3647f76 100644
--- a/test/qr.cpp
+++ b/test/qr.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/QR>
@@ -34,6 +35,15 @@
   enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
   typedef typename MatrixType::Scalar Scalar;
   Matrix<Scalar, Rows, Cols> m1 = Matrix<Scalar, Rows, Cols>::Random();
+  if (Rows < Cols) {
+    // Transposed solves depend on R_11, which has the singular values of the leading square block.
+    static constexpr int Size = (Rows < Cols) ? Rows : Cols;
+    using RealScalar = typename MatrixType::RealScalar;
+    using SingularValues = Matrix<RealScalar, Size, 1>;
+    const SingularValues svs = setupRangeSvs<SingularValues>(Size, RealScalar(0.5), RealScalar(1));
+    auto leading = m1.template topLeftCorner<Size, Size>();
+    generateRandomMatrixSvs(svs, Size, Size, leading);
+  }
   HouseholderQR<Matrix<Scalar, Rows, Cols> > qr(m1);
 
   Matrix<Scalar, Rows, Cols> r = qr.matrixQR();
@@ -51,19 +61,17 @@
 void qr_invertible() {
   using std::abs;
   using std::log;
-  using std::max;
-  using std::pow;
   typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
-  STATIC_CHECK((internal::is_same<typename HouseholderQR<MatrixType>::StorageIndex, int>::value));
+  STATIC_CHECK((std::is_same<typename HouseholderQR<MatrixType>::StorageIndex, int>::value));
 
   int size = internal::random<int>(10, 50);
 
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   m1 = MatrixType::Random(size, size);
 
-  if (internal::is_same<RealScalar, float>::value) {
+  if (std::is_same<RealScalar, float>::value) {
     // let's build a matrix more stable to inverse
     MatrixType a = MatrixType::Random(size, size * 4);
     m1 += a * a.adjoint();
@@ -75,7 +83,7 @@
 
   // now construct a matrix with prescribed determinant
   m1.setZero();
-  for (int i = 0; i < size; i++) m1(i, i) = internal::random<Scalar>();
+  setRandomWellConditionedDiagonal(m1);
   Scalar det = m1.diagonal().prod();
   RealScalar absdet = abs(det);
   m3 = qr.householderQ();  // get a unitary
@@ -83,12 +91,8 @@
   qr.compute(m1);
   VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
   VERIFY_IS_APPROX(numext::sign(det), qr.signDeterminant());
-  // This test is tricky if the determinant becomes too small.
-  // Since we generate random numbers with magnitude range [0,1], the average determinant is 0.5^size
-  RealScalar tol =
-      numext::maxi(RealScalar(pow(0.5, size)), numext::maxi<RealScalar>(abs(absdet), abs(qr.absDeterminant())));
-  VERIFY_IS_MUCH_SMALLER_THAN(abs(det - qr.determinant()), tol);
-  VERIFY_IS_MUCH_SMALLER_THAN(abs(absdet - qr.absDeterminant()), tol);
+  VERIFY_IS_APPROX(det, qr.determinant());
+  VERIFY_IS_APPROX(absdet, qr.absDeterminant());
 }
 
 template <typename MatrixType>
diff --git a/test/qr_colpivoting.cpp b/test/qr_colpivoting.cpp
index 651eb37..980d1fd 100644
--- a/test/qr_colpivoting.cpp
+++ b/test/qr_colpivoting.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/QR>
@@ -61,9 +62,7 @@
   // now construct a (square) matrix with prescribed determinant
   Index size = internal::random<Index>(2, 20);
   matrix.setZero(size, size);
-  for (int i = 0; i < size; i++) {
-    matrix(i, i) = internal::random<Scalar>();
-  }
+  setRandomWellConditionedDiagonal(matrix);
   Scalar det = matrix.diagonal().prod();
   RealScalar absdet = numext::abs(det);
   CompleteOrthogonalDecomposition<MatrixType> cod2(matrix);
@@ -262,7 +261,7 @@
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   m1 = MatrixType::Random(size, size);
 
-  if (internal::is_same<RealScalar, float>::value) {
+  if (std::is_same<RealScalar, float>::value) {
     // let's build a matrix more stable to inverse
     MatrixType a = MatrixType::Random(size, size * 2);
     m1 += a * a.adjoint();
@@ -274,7 +273,7 @@
 
   // now construct a matrix with prescribed determinant
   m1.setZero();
-  for (int i = 0; i < size; i++) m1(i, i) = internal::random<Scalar>();
+  setRandomWellConditionedDiagonal(m1);
   Scalar det = m1.diagonal().prod();
   RealScalar absdet = abs(det);
   m3 = qr.householderQ();  // get a unitary
@@ -428,6 +427,8 @@
     CALL_SUBTEST_1(qr<MatrixXf>());
     CALL_SUBTEST_2(qr<MatrixXd>());
     CALL_SUBTEST_3(qr<MatrixXcd>());
+    CALL_SUBTEST_10((qr<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
+    CALL_SUBTEST_11((qr<Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>>()));
     CALL_SUBTEST_4((qr_fixedsize<Matrix<float, 3, 5>, 4>()));
     CALL_SUBTEST_5((qr_fixedsize<Matrix<double, 6, 2>, 3>()));
     CALL_SUBTEST_5((qr_fixedsize<Matrix<double, 1, 1>, 1>()));
diff --git a/test/qr_fullpivoting.cpp b/test/qr_fullpivoting.cpp
index d3dd2d1..b24dd12 100644
--- a/test/qr_fullpivoting.cpp
+++ b/test/qr_fullpivoting.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/QR>
@@ -81,7 +82,7 @@
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   m1 = MatrixType::Random(size, size);
 
-  if (internal::is_same<RealScalar, float>::value) {
+  if (std::is_same<RealScalar, float>::value) {
     // let's build a matrix more stable to inverse
     MatrixType a = MatrixType::Random(size, size * 2);
     m1 += a * a.adjoint();
@@ -96,7 +97,7 @@
 
   // now construct a matrix with prescribed determinant
   m1.setZero();
-  for (int i = 0; i < size; i++) m1(i, i) = internal::random<Scalar>();
+  setRandomWellConditionedDiagonal(m1);
   Scalar det = m1.diagonal().prod();
   RealScalar absdet = abs(det);
   m3 = qr.matrixQ();  // get a unitary
diff --git a/test/qr_rand_colpivoting.cpp b/test/qr_rand_colpivoting.cpp
new file mode 100644
index 0000000..aa95a82
--- /dev/null
+++ b/test/qr_rand_colpivoting.cpp
@@ -0,0 +1,721 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/QR>
+#include <Eigen/SVD>
+#include "solverbase.h"
+
+// Use a small fixed block size in the tests so the blocked path actually
+// triggers on the modest matrix sizes the unit tests exercise.
+template <typename QRType>
+void configure_small(QRType& qr) {
+  qr.setBlockSize(4).setOversampling(2);
+}
+
+template <typename MatrixType>
+void rqr() {
+  using std::sqrt;
+
+  Index rows = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE), cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE),
+        cols2 = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
+  Index rank = internal::random<Index>(1, (std::min)(rows, cols) - 1);
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> MatrixQType;
+  MatrixType m1;
+  createRandomPIMatrixOfRank(rank, rows, cols, m1);
+  RandColPivHouseholderQR<MatrixType> qr;
+  configure_small(qr);
+  qr.compute(m1);
+  VERIFY_IS_EQUAL(rank, qr.rank());
+  VERIFY_IS_EQUAL(cols - qr.rank(), qr.dimensionOfKernel());
+  VERIFY(!qr.isInjective());
+  VERIFY(!qr.isInvertible());
+  VERIFY(!qr.isSurjective());
+
+  MatrixQType q = qr.householderQ();
+  VERIFY_IS_UNITARY(q);
+
+  MatrixType r = qr.matrixQR().template triangularView<Upper>();
+  MatrixType c = q * r * qr.colsPermutation().inverse();
+  VERIFY_IS_APPROX(m1, c);
+
+  // BQRRP-style randomized QRCP picks pivots on a Gaussian sketch with
+  // partial-pivoted LU and then runs *unpivoted* QR on the chosen
+  // panel; the diagonal of R is therefore not strictly monotonic, even
+  // within a block. Verify the weaker rank-revealing property: every
+  // R(i, i) above the rank threshold dominates the smallest later
+  // diagonal entry by at most an O(sqrt(rows)) slack factor.
+  RealScalar threshold = sqrt(RealScalar(rows)) * numext::abs(r(0, 0)) * NumTraits<Scalar>::epsilon();
+  RealScalar slack = sqrt(RealScalar(rows));
+  for (Index i = 0; i < (std::min)(rows, cols) - 1; ++i) {
+    RealScalar x = numext::abs(r(i, i));
+    RealScalar y_min = x;
+    for (Index j = i + 1; j < (std::min)(rows, cols); ++j) y_min = (std::min)(y_min, numext::abs(r(j, j)));
+    if (x < threshold && y_min < threshold) continue;
+    VERIFY_IS_APPROX_OR_LESS_THAN(y_min, slack * x);
+  }
+
+  check_solverbase<MatrixType, MatrixType>(m1, qr, rows, cols, cols2);
+
+  {
+    MatrixType m2, m3;
+    Index size = rows;
+    m1 = MatrixType::Random(size, size);
+    m1.diagonal().array() += Scalar(2 * size);
+    qr.compute(m1);
+    MatrixType m1_inv = qr.inverse();
+    m3 = m1 * MatrixType::Random(size, cols2);
+    m2 = qr.solve(m3);
+    VERIFY_IS_APPROX(m2, m1_inv * m3);
+  }
+}
+
+template <typename MatrixType, int Cols2>
+void rqr_fixedsize() {
+  enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
+  typedef typename MatrixType::Scalar Scalar;
+  int rank = internal::random<int>(1, (std::min)(int(Rows), int(Cols)) - 1);
+  MatrixType m1;
+  createRandomPIMatrixOfRank(rank, Rows, Cols, m1);
+  RandColPivHouseholderQR<MatrixType> qr;
+  configure_small(qr);
+  qr.compute(m1);
+  VERIFY_IS_EQUAL(rank, qr.rank());
+  VERIFY_IS_EQUAL(Cols - qr.rank(), qr.dimensionOfKernel());
+  VERIFY_IS_EQUAL(qr.isInjective(), (rank == Rows));
+  VERIFY_IS_EQUAL(qr.isSurjective(), (rank == Cols));
+  VERIFY_IS_EQUAL(qr.isInvertible(), (qr.isInjective() && qr.isSurjective()));
+
+  MatrixType r = qr.matrixQR().template triangularView<Upper>();
+  MatrixType c = qr.householderQ() * r * qr.colsPermutation().inverse();
+  VERIFY_IS_APPROX(m1, c);
+
+  check_solverbase<Matrix<Scalar, Cols, Cols2>, Matrix<Scalar, Rows, Cols2>>(m1, qr, Rows, Cols, Cols2);
+}
+
+// Round-trip verification on the Kahan matrix (the canonical
+// counter-example for naive QR pivoting). The randomized strategy does
+// not promise diagonal monotonicity across block boundaries, so we check
+// reconstruction only.
+template <typename MatrixType>
+void rqr_kahan_matrix() {
+  using std::sqrt;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  Index rows = 200, cols = rows;
+
+  MatrixType m1;
+  m1.setZero(rows, cols);
+  RealScalar s = std::pow(NumTraits<RealScalar>::epsilon(), 1.0 / rows);
+  RealScalar c_kahan = std::sqrt(1 - s * s);
+  RealScalar pow_s_i(1.0);
+  for (Index i = 0; i < rows; ++i) {
+    m1(i, i) = pow_s_i;
+    m1.row(i).tail(rows - i - 1) = -pow_s_i * c_kahan * MatrixType::Ones(1, rows - i - 1);
+    pow_s_i *= s;
+  }
+  m1 = (m1 + m1.transpose()).eval();
+
+  RandColPivHouseholderQR<MatrixType> qr;
+  configure_small(qr);
+  qr.setSeed(0xC0FFEE);  // fix seed for reproducibility
+  qr.compute(m1);
+  MatrixType r = qr.matrixQR().template triangularView<Upper>();
+
+  // Reconstruction round-trip is the strongest correctness check.
+  MatrixType q = qr.householderQ();
+  MatrixType reconstructed = q * r * qr.colsPermutation().inverse();
+  VERIFY_IS_APPROX(m1, reconstructed);
+}
+
+template <typename MatrixType>
+void rqr_invertible() {
+  using std::abs;
+  using std::log;
+  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
+  typedef typename MatrixType::Scalar Scalar;
+
+  int size = internal::random<int>(10, 50);
+
+  MatrixType m1(size, size), m2(size, size), m3(size, size);
+  m1 = MatrixType::Random(size, size);
+
+  if (std::is_same<RealScalar, float>::value) {
+    MatrixType a = MatrixType::Random(size, size * 2);
+    m1 += a * a.adjoint();
+  }
+
+  RandColPivHouseholderQR<MatrixType> qr;
+  configure_small(qr);
+  qr.compute(m1);
+
+  check_solverbase<MatrixType, MatrixType>(m1, qr, size, size, size);
+
+  // Now construct a matrix with prescribed determinant and verify det/sign.
+  m1.setZero();
+  setRandomWellConditionedDiagonal(m1);
+  Scalar det = m1.diagonal().prod();
+  RealScalar absdet = abs(det);
+  m3 = qr.householderQ();
+  m1 = m3 * m1 * m3.adjoint();
+  qr.compute(m1);
+  VERIFY_IS_APPROX(det, qr.determinant());
+  VERIFY_IS_APPROX(absdet, qr.absDeterminant());
+  VERIFY_IS_APPROX(log(absdet), qr.logAbsDeterminant());
+  VERIFY_IS_APPROX(numext::sign(det), qr.signDeterminant());
+}
+
+template <typename MatrixType>
+void rqr_verify_assert() {
+  MatrixType tmp;
+
+  RandColPivHouseholderQR<MatrixType> qr;
+  VERIFY_RAISES_ASSERT(qr.matrixQR())
+  VERIFY_RAISES_ASSERT(qr.solve(tmp))
+  VERIFY_RAISES_ASSERT(qr.transpose().solve(tmp))
+  VERIFY_RAISES_ASSERT(qr.adjoint().solve(tmp))
+  VERIFY_RAISES_ASSERT(qr.householderQ())
+  VERIFY_RAISES_ASSERT(qr.dimensionOfKernel())
+  VERIFY_RAISES_ASSERT(qr.isInjective())
+  VERIFY_RAISES_ASSERT(qr.isSurjective())
+  VERIFY_RAISES_ASSERT(qr.isInvertible())
+  VERIFY_RAISES_ASSERT(qr.inverse())
+  VERIFY_RAISES_ASSERT(qr.determinant())
+  VERIFY_RAISES_ASSERT(qr.absDeterminant())
+  VERIFY_RAISES_ASSERT(qr.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(qr.signDeterminant())
+}
+
+// Regression: compute() on degenerate empty inputs (0-row or 0-col) must
+// not trigger integer division-by-zero in the auto-block-size heuristic
+// (UBSan caught one on MatrixXd(0, 3) at MR SHA c2860f27). The expected
+// behavior is that the unblocked path runs with no work and rank() == 0.
+template <typename MatrixType>
+void rqr_empty_input() {
+  const std::pair<Index, Index> cases[] = {{0, 3}, {3, 0}, {0, 0}};
+  for (const auto& dims : cases) {
+    const Index rows = dims.first;
+    const Index cols = dims.second;
+    MatrixType a(rows, cols);
+    RandColPivHouseholderQR<MatrixType> qr;
+    qr.compute(a);
+    VERIFY_IS_EQUAL(qr.rank(), Index(0));
+    VERIFY_IS_EQUAL(qr.rows(), rows);
+    VERIFY_IS_EQUAL(qr.cols(), cols);
+  }
+}
+
+template <typename MatrixType>
+void rcod() {
+  Index rows = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
+  Index cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
+  Index cols2 = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
+  Index rank = internal::random<Index>(1, (std::min)(rows, cols) - 1);
+
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> MatrixQType;
+  MatrixType matrix;
+  createRandomPIMatrixOfRank(rank, rows, cols, matrix);
+  RandCompleteOrthogonalDecomposition<MatrixType> cod;
+  cod.setBlockSize(4).setSeed(0x5eed);
+  cod.compute(matrix);
+  VERIFY(rank == cod.rank());
+  VERIFY(cols - cod.rank() == cod.dimensionOfKernel());
+  VERIFY(!cod.isInjective());
+  VERIFY(!cod.isInvertible());
+  VERIFY(!cod.isSurjective());
+
+  MatrixQType q = cod.householderQ();
+  VERIFY_IS_UNITARY(q);
+
+  MatrixType z = cod.matrixZ();
+  VERIFY_IS_UNITARY(z);
+
+  MatrixType t;
+  t.setZero(rows, cols);
+  t.topLeftCorner(rank, rank) = cod.matrixT().topLeftCorner(rank, rank).template triangularView<Upper>();
+
+  MatrixType c = q * t * z * cod.colsPermutation().inverse();
+  VERIFY_IS_APPROX(matrix, c);
+
+  check_solverbase<MatrixType, MatrixType>(matrix, cod, rows, cols, cols2);
+
+  MatrixType exact_solution = MatrixType::Random(cols, cols2);
+  MatrixType rhs = matrix * exact_solution;
+  MatrixType cod_solution = cod.solve(rhs);
+  JacobiSVD<MatrixType, ComputeThinU | ComputeThinV> svd(matrix);
+  MatrixType svd_solution = svd.solve(rhs);
+  VERIFY_IS_APPROX(cod_solution, svd_solution);
+
+  MatrixType pinv = cod.pseudoInverse();
+  VERIFY_IS_APPROX(cod_solution, pinv * rhs);
+
+  Index size = internal::random<Index>(2, 20);
+  matrix.setZero(size, size);
+  setRandomWellConditionedDiagonal(matrix);
+  Scalar det = matrix.diagonal().prod();
+  RealScalar absdet = numext::abs(det);
+  RandCompleteOrthogonalDecomposition<MatrixType> cod2;
+  cod2.setBlockSize(4).setSeed(0xc0d2);
+  cod2.compute(matrix);
+  q = cod2.householderQ();
+  matrix = q * matrix * q.adjoint();
+  cod2.compute(matrix);
+  VERIFY_IS_APPROX(det, cod2.determinant());
+  VERIFY_IS_APPROX(absdet, cod2.absDeterminant());
+  VERIFY_IS_APPROX(numext::log(absdet), cod2.logAbsDeterminant());
+  VERIFY_IS_APPROX(numext::sign(det), cod2.signDeterminant());
+}
+
+template <typename MatrixType, int Cols2>
+void rcod_fixedsize() {
+  enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
+  typedef typename MatrixType::Scalar Scalar;
+  typedef RandCompleteOrthogonalDecomposition<MatrixType> COD;
+  int rank = internal::random<int>(1, (std::min)(int(Rows), int(Cols)) - 1);
+  MatrixType matrix;
+  createRandomPIMatrixOfRank(rank, Rows, Cols, matrix);
+  COD cod;
+  cod.setBlockSize(4).setSeed(0xfed1);
+  cod.compute(matrix);
+  VERIFY(rank == cod.rank());
+  VERIFY(Cols - cod.rank() == cod.dimensionOfKernel());
+  VERIFY(cod.isInjective() == (rank == Rows));
+  VERIFY(cod.isSurjective() == (rank == Cols));
+  VERIFY(cod.isInvertible() == (cod.isInjective() && cod.isSurjective()));
+
+  check_solverbase<Matrix<Scalar, Cols, Cols2>, Matrix<Scalar, Rows, Cols2>>(matrix, cod, Rows, Cols, Cols2);
+
+  Matrix<Scalar, Cols, Cols2> exact_solution;
+  exact_solution.setRandom(Cols, Cols2);
+  Matrix<Scalar, Rows, Cols2> rhs = matrix * exact_solution;
+  Matrix<Scalar, Cols, Cols2> cod_solution = cod.solve(rhs);
+  JacobiSVD<MatrixType, ComputeFullU | ComputeFullV> svd(matrix);
+  Matrix<Scalar, Cols, Cols2> svd_solution = svd.solve(rhs);
+  VERIFY_IS_APPROX(cod_solution, svd_solution);
+
+  typename Inverse<COD>::PlainObject pinv = cod.pseudoInverse();
+  VERIFY_IS_APPROX(cod_solution, pinv * rhs);
+}
+
+template <typename MatrixType>
+void rcod_verify_assert() {
+  MatrixType tmp;
+
+  RandCompleteOrthogonalDecomposition<MatrixType> cod;
+  VERIFY_RAISES_ASSERT(cod.matrixQTZ())
+  VERIFY_RAISES_ASSERT(cod.solve(tmp))
+  VERIFY_RAISES_ASSERT(cod.transpose().solve(tmp))
+  VERIFY_RAISES_ASSERT(cod.adjoint().solve(tmp))
+  VERIFY_RAISES_ASSERT(cod.householderQ())
+  VERIFY_RAISES_ASSERT(cod.dimensionOfKernel())
+  VERIFY_RAISES_ASSERT(cod.isInjective())
+  VERIFY_RAISES_ASSERT(cod.isSurjective())
+  VERIFY_RAISES_ASSERT(cod.isInvertible())
+  VERIFY_RAISES_ASSERT(cod.pseudoInverse())
+  VERIFY_RAISES_ASSERT(cod.determinant())
+  VERIFY_RAISES_ASSERT(cod.absDeterminant())
+  VERIFY_RAISES_ASSERT(cod.logAbsDeterminant())
+  VERIFY_RAISES_ASSERT(cod.signDeterminant())
+}
+
+// Exercise the blocked path by using a matrix sufficiently larger than 2*b.
+// At b=4 we need at least 8 columns to enter the blocked branch.
+// Stress the rank-detection threshold under the blocked path. With b=4
+// we run multiple blocks; the rank-revealing column lands at index 8, 12,
+// or 20 — i.e. in the third block or later. A panel-local threshold
+// would deflate as norms shrink across blocks and could miscount the
+// rank. Only a global threshold (precomputed from the original column
+// norms, as ColPivHouseholderQR does) is correct.
+template <typename MatrixType>
+void rqr_rank_in_late_block() {
+  const Index rows = 30;
+  const Index cols = 24;
+  for (Index target_rank : {Index(8), Index(12), Index(20)}) {
+    MatrixType m1;
+    createRandomPIMatrixOfRank(target_rank, rows, cols, m1);
+
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(m1);
+    VERIFY_IS_EQUAL(target_rank, qr.rank());
+
+    MatrixType r = qr.matrixQR().template triangularView<Upper>();
+    MatrixType q = qr.householderQ();
+    VERIFY_IS_APPROX(m1, MatrixType(q * r * qr.colsPermutation().inverse()));
+
+    // Cross-check against classical column pivoting on the same input.
+    ColPivHouseholderQR<MatrixType> cpqr(m1);
+    VERIFY_IS_EQUAL(qr.rank(), cpqr.rank());
+  }
+}
+
+template <typename MatrixType>
+void rqr_blocked_path() {
+  Index rows = 40, cols = 30;
+  MatrixType m1 = MatrixType::Random(rows, cols);
+  RandColPivHouseholderQR<MatrixType> qr;
+  configure_small(qr);
+  qr.setSeed(42);
+  qr.compute(m1);
+
+  MatrixType r = qr.matrixQR().template triangularView<Upper>();
+  MatrixType q = qr.householderQ();
+  VERIFY_IS_UNITARY(q);
+  MatrixType reconstructed = q * r * qr.colsPermutation().inverse();
+  VERIFY_IS_APPROX(m1, reconstructed);
+
+  // Same input + same seed must reproduce the exact same factorization.
+  RandColPivHouseholderQR<MatrixType> qr2;
+  configure_small(qr2);
+  qr2.setSeed(42);
+  qr2.compute(m1);
+  VERIFY_IS_EQUAL(qr.colsPermutation().indices(), qr2.colsPermutation().indices());
+  VERIFY_IS_APPROX(qr.matrixQR(), qr2.matrixQR());
+}
+
+// Mirrors qr_rank_detection_stress from qr_colpivoting.cpp: many random
+// partial-isometry trials across aspect ratios. With configure_small (b=4)
+// most of these matrices engage the blocked path.
+template <typename MatrixType>
+void rqr_rank_detection_stress() {
+  const Index sizes[][2] = {{10, 10}, {20, 20}, {50, 50}, {100, 100}, {40, 10}, {100, 10}, {10, 40}, {10, 100}};
+  for (const auto& sz : sizes) {
+    const Index rows = sz[0], cols = sz[1];
+    const Index min_dim = (std::min)(rows, cols);
+    for (Index rank : {Index(1), (std::max)(Index(1), min_dim / 2), min_dim - 1}) {
+      if (rank >= min_dim) continue;
+      for (int trial = 0; trial < 10; ++trial) {
+        MatrixType m1;
+        createRandomPIMatrixOfRank(rank, rows, cols, m1);
+        RandColPivHouseholderQR<MatrixType> qr;
+        configure_small(qr);
+        qr.compute(m1);
+        VERIFY_IS_EQUAL(rank, qr.rank());
+      }
+    }
+  }
+}
+
+// Mirrors qr_threshold_efficiency: matrices with smallest SV well above
+// the rank-detection threshold must come back as full-rank.
+template <typename MatrixType>
+void rqr_threshold_efficiency() {
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+  const Index sizes[][2] = {{10, 10}, {50, 50}, {100, 100}, {40, 10}, {10, 40}};
+  for (const auto& sz : sizes) {
+    const Index rows = sz[0], cols = sz[1];
+    const Index min_dim = (std::min)(rows, cols);
+    RealScalar sigma_min = RealScalar(400) * RealScalar(min_dim) * NumTraits<RealScalar>::epsilon();
+    RealVectorType svs = setupRangeSvs<RealVectorType>(min_dim, sigma_min, RealScalar(1));
+    MatrixType m1;
+    generateRandomMatrixSvs(svs, rows, cols, m1);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(m1);
+    VERIFY_IS_EQUAL(min_dim, qr.rank());
+  }
+}
+
+// Mirrors qr_rank_gap_test: geometric signal SVs decaying to sigma_rank,
+// then noise SVs near eps. The clear gap at `rank` should be detected.
+template <typename MatrixType>
+void rqr_rank_gap_test() {
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+  const Index sizes[][2] = {{20, 20}, {50, 50}, {100, 100}, {50, 20}, {20, 50}};
+  for (const auto& sz : sizes) {
+    const Index rows = sz[0], cols = sz[1];
+    const Index min_dim = (std::min)(rows, cols);
+    const Index rank = (std::max)(Index(1), min_dim / 2);
+    RealScalar sigma_rank = RealScalar(0.1);
+    RealScalar eps_level = NumTraits<RealScalar>::epsilon();
+    RealVectorType svs(min_dim);
+    for (Index i = 0; i < rank; ++i) {
+      RealScalar t = (rank > 1) ? RealScalar(i) / RealScalar(rank - 1) : RealScalar(0);
+      svs(i) = std::pow(sigma_rank, t);
+    }
+    for (Index i = rank; i < min_dim; ++i) svs(i) = eps_level * RealScalar(min_dim - i);
+    MatrixType m1;
+    generateRandomMatrixSvs(svs, rows, cols, m1);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(m1);
+    VERIFY_IS_EQUAL(rank, qr.rank());
+  }
+}
+
+// SV-decay classes from the RQRCP/HQRRP papers' section 4.2: slow linear
+// decay, fast exponential decay, and a low-rank case. The papers' central
+// empirical claim is that the randomized strategy reports the same rank as
+// classical column pivoting on these distributions; we verify that here.
+template <typename MatrixType>
+void rqr_sv_decay_classes() {
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+  const Index n = 60;
+
+  // Slow decay: linear from 1 to 0.01.
+  {
+    RealVectorType svs(n);
+    for (Index i = 0; i < n; ++i) svs(i) = RealScalar(1) - (RealScalar(0.99) * RealScalar(i)) / RealScalar(n - 1);
+    MatrixType m1;
+    generateRandomMatrixSvs(svs, n, n, m1);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(m1);
+    ColPivHouseholderQR<MatrixType> cp(m1);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+
+  // Fast exponential decay: sigma_i = exp(-c * i), c chosen so the tail
+  // hits roughly e^-20.
+  {
+    RealVectorType svs(n);
+    RealScalar c = RealScalar(20) / RealScalar(n);
+    for (Index i = 0; i < n; ++i) svs(i) = std::exp(-c * RealScalar(i));
+    MatrixType m1;
+    generateRandomMatrixSvs(svs, n, n, m1);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(m1);
+    ColPivHouseholderQR<MatrixType> cp(m1);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+
+  // Low-rank: rank-12 signal block at [1, 0.5], rest at machine eps.
+  {
+    const Index r = 12;
+    RealVectorType svs(n);
+    for (Index i = 0; i < r; ++i) svs(i) = RealScalar(1) - (RealScalar(0.5) * i) / RealScalar(r - 1);
+    for (Index i = r; i < n; ++i) svs(i) = NumTraits<RealScalar>::epsilon();
+    MatrixType m1;
+    generateRandomMatrixSvs(svs, n, n, m1);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(m1);
+    VERIFY_IS_EQUAL(r, qr.rank());
+  }
+}
+
+// Suite of well-known matrices from the numerical linear algebra
+// literature that are commonly used to stress rank-revealing QR:
+//   - Hilbert    H[i,j] = 1/(i+j+1)               (Hilbert 1894; cond ~ exp(3.5n))
+//   - Vandermonde V[i,j] = x_i^j with x_i = i/n   (cond grows exponentially)
+//   - Kahan A = S K                               (Kahan 1966 counterexample;
+//                                                  HQRRP paper's "Matrix 4")
+//   - HQRRP Matrix 1 (fast exponential SV decay,  d_j = β^((j-1)/(n-1)),
+//                                                  β = 10^-5)
+//   - HQRRP Matrix 2 (S-shaped SV decay; high
+//                     plateau, knee, low plateau at 10^-6)
+//
+// Reconstruction must hold within a forgiving tolerance proportional to the
+// matrix conditioning. Where the matrix is unambiguously full-rank or has a
+// clear rank cutoff, we cross-check the reported rank against
+// ColPivHouseholderQR on the same input — the central empirical claim of
+// the RQRCP/HQRRP papers.
+template <typename MatrixType>
+void rqr_literature_matrices() {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef Matrix<RealScalar, Dynamic, 1> RealVectorType;
+
+  // 1. Hilbert (n = 10): full rank in theory; cond ~ 1e13 in double. The
+  // Q*R*P^-1 reconstruction is backward stable, so the round-trip error is
+  // O(eps) independent of the conditioning.
+  {
+    const Index n = 10;
+    MatrixType H(n, n);
+    for (Index i = 0; i < n; ++i)
+      for (Index j = 0; j < n; ++j) H(i, j) = Scalar(RealScalar(1) / RealScalar(i + j + 1));
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(H);
+    MatrixType R = qr.matrixQR().template triangularView<Upper>();
+    MatrixType Q = qr.householderQ();
+    RealScalar err = (H - Q * R * qr.colsPermutation().inverse()).norm() / H.norm();
+    VERIFY(err < RealScalar(16) * NumTraits<RealScalar>::epsilon());
+    ColPivHouseholderQR<MatrixType> cp(H);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+
+  // 2. Vandermonde with equispaced nodes (n = 12): also classically ill-
+  // conditioned. Same round-trip + rank-match check.
+  {
+    const Index n = 12;
+    MatrixType V(n, n);
+    for (Index i = 0; i < n; ++i) {
+      Scalar xi = Scalar(RealScalar(i + 1) / RealScalar(n));
+      Scalar p(1);
+      for (Index j = 0; j < n; ++j) {
+        V(i, j) = p;
+        p *= xi;
+      }
+    }
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(V);
+    MatrixType R = qr.matrixQR().template triangularView<Upper>();
+    MatrixType Q = qr.householderQ();
+    RealScalar err = (V - Q * R * qr.colsPermutation().inverse()).norm() / V.norm();
+    VERIFY(err < RealScalar(16) * NumTraits<RealScalar>::epsilon());
+    ColPivHouseholderQR<MatrixType> cp(V);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+
+  // 3. Canonical (non-symmetrized) Kahan A = S K. HQRRP paper "Matrix 4",
+  // designed specifically to trip up classical column pivoting. Full rank;
+  // classical QRP gets the rank-k truncation error wrong, but the
+  // reconstruction round-trip and reported rank are still well-defined.
+  {
+    const Index n = 32;
+    RealScalar zeta = RealScalar(0.99999);
+    RealScalar phi = std::sqrt(RealScalar(1) - zeta * zeta);
+    MatrixType S = MatrixType::Zero(n, n);
+    MatrixType K = MatrixType::Zero(n, n);
+    RealScalar zpow(1);
+    for (Index i = 0; i < n; ++i) {
+      S(i, i) = Scalar(zpow);
+      zpow *= zeta;
+      K(i, i) = Scalar(1);
+      for (Index j = i + 1; j < n; ++j) K(i, j) = Scalar(-phi);
+    }
+    MatrixType A = S * K;
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(A);
+    MatrixType R = qr.matrixQR().template triangularView<Upper>();
+    MatrixType Q = qr.householderQ();
+    RealScalar err = (A - Q * R * qr.colsPermutation().inverse()).norm() / A.norm();
+    VERIFY(err < RealScalar(16) * NumTraits<RealScalar>::epsilon());
+    ColPivHouseholderQR<MatrixType> cp(A);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+
+  // 4. HQRRP "Matrix 1": exponential SV decay d_j = beta^((j-1)/(n-1))
+  // with beta = 10^-5. All SVs are well above eps so rank should be n.
+  {
+    const Index n = 40;
+    RealVectorType svs(n);
+    RealScalar beta = RealScalar(1e-5);
+    for (Index j = 0; j < n; ++j) svs(j) = std::pow(beta, RealScalar(j) / RealScalar(n - 1));
+    MatrixType A;
+    generateRandomMatrixSvs(svs, n, n, A);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(A);
+    ColPivHouseholderQR<MatrixType> cp(A);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+
+  // 5. HQRRP "Matrix 2": S-shaped SV decay. High plateau (~1), sharp knee
+  // around k = n/2, low plateau (~10^-6). The rank-revealing pivot strategy
+  // should locate the knee.
+  {
+    const Index n = 40;
+    const Index knee = n / 2;
+    RealVectorType svs(n);
+    RealScalar lo = RealScalar(1e-6);
+    for (Index j = 0; j < n; ++j) {
+      // sigmoid centered at `knee`, scaled to [lo, 1]
+      RealScalar x = RealScalar(j - knee) * RealScalar(2);
+      RealScalar s = RealScalar(1) / (RealScalar(1) + std::exp(x));
+      svs(j) = lo + (RealScalar(1) - lo) * s;
+    }
+    MatrixType A;
+    generateRandomMatrixSvs(svs, n, n, A);
+    RandColPivHouseholderQR<MatrixType> qr;
+    configure_small(qr);
+    qr.compute(A);
+    ColPivHouseholderQR<MatrixType> cp(A);
+    VERIFY_IS_EQUAL(qr.rank(), cp.rank());
+  }
+}
+
+EIGEN_DECLARE_TEST(qr_rand_colpivoting) {
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(rqr<MatrixXf>());
+    CALL_SUBTEST_2(rqr<MatrixXd>());
+    CALL_SUBTEST_3(rqr<MatrixXcd>());
+    CALL_SUBTEST_4((rqr_fixedsize<Matrix<float, 8, 10>, 4>()));
+    CALL_SUBTEST_5((rqr_fixedsize<Matrix<double, 12, 6>, 3>()));
+
+    // The panel factorization wraps a block of the stored matrix in a Ref, so it has to follow
+    // MatrixType's storage order rather than the workspaces' column-major one.
+    CALL_SUBTEST_1((rqr<Matrix<float, Dynamic, Dynamic, RowMajor>>()));
+    CALL_SUBTEST_2((rqr<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
+    CALL_SUBTEST_4((rqr_fixedsize<Matrix<float, 8, 10, RowMajor>, 4>()));
+
+    CALL_SUBTEST_1(rcod<MatrixXf>());
+    CALL_SUBTEST_2(rcod<MatrixXd>());
+    CALL_SUBTEST_3(rcod<MatrixXcd>());
+    CALL_SUBTEST_4((rcod_fixedsize<Matrix<float, 8, 10>, 4>()));
+    CALL_SUBTEST_5((rcod_fixedsize<Matrix<double, 12, 6>, 3>()));
+
+    CALL_SUBTEST_2((rcod<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
+    CALL_SUBTEST_4((rcod_fixedsize<Matrix<float, 8, 10, RowMajor>, 4>()));
+  }
+
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(rqr_invertible<MatrixXf>());
+    CALL_SUBTEST_2(rqr_invertible<MatrixXd>());
+    CALL_SUBTEST_6(rqr_invertible<MatrixXcf>());
+    CALL_SUBTEST_3(rqr_invertible<MatrixXcd>());
+  }
+
+  CALL_SUBTEST_7(rqr_verify_assert<Matrix3f>());
+  CALL_SUBTEST_8(rqr_verify_assert<Matrix3d>());
+  CALL_SUBTEST_1(rqr_verify_assert<MatrixXf>());
+  CALL_SUBTEST_2(rqr_verify_assert<MatrixXd>());
+  CALL_SUBTEST_6(rqr_verify_assert<MatrixXcf>());
+  CALL_SUBTEST_3(rqr_verify_assert<MatrixXcd>());
+
+  CALL_SUBTEST_7(rcod_verify_assert<Matrix3f>());
+  CALL_SUBTEST_8(rcod_verify_assert<Matrix3d>());
+  CALL_SUBTEST_1(rcod_verify_assert<MatrixXf>());
+  CALL_SUBTEST_2(rcod_verify_assert<MatrixXd>());
+  CALL_SUBTEST_6(rcod_verify_assert<MatrixXcf>());
+  CALL_SUBTEST_3(rcod_verify_assert<MatrixXcd>());
+
+  // Test problem-size constructor.
+  CALL_SUBTEST_9(RandColPivHouseholderQR<MatrixXf>(10, 20));
+
+  CALL_SUBTEST_1(rqr_empty_input<MatrixXf>());
+  CALL_SUBTEST_2(rqr_empty_input<MatrixXd>());
+  CALL_SUBTEST_3(rqr_empty_input<MatrixXcd>());
+
+  CALL_SUBTEST_1(rqr_kahan_matrix<MatrixXf>());
+  CALL_SUBTEST_2(rqr_kahan_matrix<MatrixXd>());
+
+  CALL_SUBTEST_2(rqr_blocked_path<MatrixXd>());
+  CALL_SUBTEST_3(rqr_blocked_path<MatrixXcd>());
+
+  CALL_SUBTEST_1(rqr_rank_in_late_block<MatrixXf>());
+  CALL_SUBTEST_2(rqr_rank_in_late_block<MatrixXd>());
+  CALL_SUBTEST_3(rqr_rank_in_late_block<MatrixXcd>());
+
+  CALL_SUBTEST_1(rqr_rank_detection_stress<MatrixXf>());
+  CALL_SUBTEST_2(rqr_rank_detection_stress<MatrixXd>());
+
+  CALL_SUBTEST_1(rqr_threshold_efficiency<MatrixXf>());
+  CALL_SUBTEST_2(rqr_threshold_efficiency<MatrixXd>());
+
+  CALL_SUBTEST_1(rqr_rank_gap_test<MatrixXf>());
+  CALL_SUBTEST_2(rqr_rank_gap_test<MatrixXd>());
+
+  CALL_SUBTEST_2(rqr_sv_decay_classes<MatrixXd>());
+  CALL_SUBTEST_3(rqr_sv_decay_classes<MatrixXcd>());
+
+  CALL_SUBTEST_2(rqr_literature_matrices<MatrixXd>());
+}
diff --git a/test/qtvector.cpp b/test/qtvector.cpp
index 0f2d907..f545a4e 100644
--- a/test/qtvector.cpp
+++ b/test/qtvector.cpp
@@ -7,8 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_WORK_AROUND_QT_BUG_CALLING_WRONG_OPERATOR_NEW_FIXED_IN_QT_4_5
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <QtCore/QVector>
@@ -138,5 +137,5 @@
 
   // some Quaternion
   CALL_SUBTEST(check_qtvector_quaternion(Quaternionf()));
-  CALL_SUBTEST(check_qtvector_quaternion(Quaternionf()));
+  CALL_SUBTEST(check_qtvector_quaternion(Quaterniond()));
 }
diff --git a/test/rand.cpp b/test/rand.cpp
index eb70777..4ed1a88 100644
--- a/test/rand.cpp
+++ b/test/rand.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include <cstdlib>
 #include "main.h"
@@ -87,7 +88,7 @@
   using type = std::conditional_t<(sizeof(T) < sizeof(int)), unsigned int, std::make_unsigned_t<T>>;
 };
 template <typename T>
-struct get_range_type<SafeScalar<T>> : internal::make_unsigned<T> {};
+struct get_range_type<SafeScalar<T>> : std::make_unsigned<T> {};
 
 template <typename Scalar>
 class HistogramHelper<Scalar, std::enable_if_t<Eigen::NumTraits<Scalar>::IsInteger>> {
@@ -130,6 +131,24 @@
   RangeType bin_width_;
 };
 
+// A bin of probability p receives Binomial(count, p) samples, so the normalized hist(i) has
+// standard deviation sqrt((1 - p) / (count * p)) about 1. Bonferroni over the bins: k solving
+// erfc(k / sqrt(2)) = kFalseFailureRate / bins caps at kFalseFailureRate the probability that
+// any bin strays past k sigma.
+inline double histogram_k_sigma(int bins) {
+  constexpr double kFalseFailureRate = 1e-9;
+  const double target = kFalseFailureRate / double(bins);
+  double lo = 0.0, hi = 40.0;
+  for (int iter = 0; iter < 100; ++iter) {
+    const double mid = 0.5 * (lo + hi);
+    if (std::erfc(mid / std::sqrt(2.0)) > target)
+      lo = mid;
+    else
+      hi = mid;
+  }
+  return hi;
+}
+
 template <typename Scalar>
 void check_histogram(Scalar x, Scalar y, int bins) {
   constexpr int repeats = 10000;
@@ -142,12 +161,16 @@
       int bin = hist_helper.bin(r);
       hist(bin)++;
     }
-  //  Normalize bins by probability.
+  //  Normalize bins by probability, and bound each by its own sampling standard deviation.
   hist /= count;
+  const double k = histogram_k_sigma(bins);
+  Eigen::VectorXd tol(bins);
   for (int i = 0; i < bins; ++i) {
-    hist(i) = hist(i) / hist_helper.uniform_bin_probability(i);
+    const double p = hist_helper.uniform_bin_probability(i);
+    hist(i) = hist(i) / p;
+    tol(i) = k * std::sqrt((1.0 - p) / (count * p));
   }
-  VERIFY(((hist.array() - 1.0).abs() < 0.05).all());
+  VERIFY(((hist.array() - 1.0).abs() < tol.array()).all());
 }
 
 template <typename Scalar>
@@ -162,12 +185,16 @@
       int bin = hist_helper.bin(r);
       hist(bin)++;
     }
-  //  Normalize bins by probability.
+  //  Normalize bins by probability, and bound each by its own sampling standard deviation.
   hist /= count;
+  const double k = histogram_k_sigma(bins);
+  Eigen::VectorXd tol(bins);
   for (int i = 0; i < bins; ++i) {
-    hist(i) = hist(i) / hist_helper.uniform_bin_probability(i);
+    const double p = hist_helper.uniform_bin_probability(i);
+    hist(i) = hist(i) / p;
+    tol(i) = k * std::sqrt((1.0 - p) / (count * p));
   }
-  VERIFY(((hist.array() - 1.0).abs() < 0.05).all());
+  VERIFY(((hist.array() - 1.0).abs() < tol.array()).all());
 }
 
 template <>
@@ -262,7 +289,7 @@
 
   CALL_SUBTEST_11(check_histogram<int32_t>(-5, 5, 11));
   int bins = 100;
-  EIGEN_UNUSED_VARIABLE(bins)
+  EIGEN_UNUSED_VARIABLE(bins);
   CALL_SUBTEST_11(check_histogram<int32_t>(-3333, -3333 + bins * (3333 / bins) - 1, bins));
   bins = 1000;
   CALL_SUBTEST_11(check_histogram<int32_t>(-RAND_MAX + 10, -RAND_MAX + 10 + bins * (RAND_MAX / bins) - 1, bins));
diff --git a/test/random_for_arithmetic.h b/test/random_for_arithmetic.h
new file mode 100644
index 0000000..45de082
--- /dev/null
+++ b/test/random_for_arithmetic.h
@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_RANDOM_FOR_ARITHMETIC_H
+#define EIGEN_TEST_RANDOM_FOR_ARITHMETIC_H
+
+#include <Eigen/Core>
+
+namespace Eigen {
+
+// Small integer operands leave room for the sums and products in arithmetic tests.
+// Floating-point tests retain the usual Random() distribution.
+template <typename Scalar>
+Scalar random_scalar_for_arithmetic() {
+  EIGEN_IF_CONSTEXPR (NumTraits<Scalar>::IsInteger) {
+    return internal::random<Scalar>(Scalar(NumTraits<Scalar>::IsSigned ? -7 : 0), Scalar(7));
+  }
+  return internal::random<Scalar>();
+}
+
+template <typename MatrixType, typename... Sizes>
+MatrixType random_for_arithmetic(Sizes... sizes) {
+  return MatrixType::NullaryExpr(sizes...,
+                                 []() { return random_scalar_for_arithmetic<typename MatrixType::Scalar>(); });
+}
+
+}  // namespace Eigen
+
+#endif  // EIGEN_TEST_RANDOM_FOR_ARITHMETIC_H
diff --git a/test/random_matrix.cpp b/test/random_matrix.cpp
index e95ca47..978d370 100644
--- a/test/random_matrix.cpp
+++ b/test/random_matrix.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/SVD>
diff --git a/test/random_matrix_helper.h b/test/random_matrix_helper.h
index 818d686..b96a371 100644
--- a/test/random_matrix_helper.h
+++ b/test/random_matrix_helper.h
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_RANDOM_MATRIX_HELPER
 #define EIGEN_RANDOM_MATRIX_HELPER
@@ -38,6 +39,9 @@
 template <typename VectorType, typename RealScalar>
 VectorType setupRangeSvs(const Index dim, const RealScalar min, const RealScalar max);
 
+template <typename MatrixType>
+void setRandomWellConditionedDiagonal(MatrixType& m);
+
 }  // end namespace Eigen
 
 #endif  // EIGEN_COMP_ICC
@@ -237,6 +241,54 @@
   return min * (VectorType::Ones(dim) - svs) + max * svs;
 }
 
+/**
+ * Overwrites the diagonal of a matrix with random entries of modulus in [1/2, 1],
+ * leaving the other entries untouched.
+ *
+ * For a diagonal matrix built this way the condition number is at most 2 and
+ * `|det| >= 2^-dim`, which is what makes a determinant check against the product of
+ * the entries meaningful. Drawing unconstrained entries instead leaves the
+ * conditioning unbounded. For real scalars, the smallest magnitude among `dim`
+ * uniform draws from [-1, 1) falls below the `4*dim*eps*maxPivot` rank threshold
+ * with probability about `4*dim^2*eps` when `maxPivot` is of order one. Complex
+ * draws use independent real and imaginary components, so their near-zero
+ * probability is quadratic in the threshold, but they can likewise make the
+ * determinant check ill-conditioned.
+ *
+ * @tparam MatrixType type of the matrix whose diagonal is set
+ * @param m matrix whose diagonal is overwritten
+ */
+template <typename MatrixType>
+void setRandomWellConditionedDiagonal(MatrixType& m) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  for (Index i = 0; i < m.diagonalSize(); ++i) {
+    // numext::sign is the unit-modulus phase for complex scalars and +-1 for real ones.
+    const Scalar z = internal::random<Scalar>();
+    const Scalar phase = numext::is_exactly_zero(z) ? Scalar(1) : numext::sign(z);
+    m.diagonal()(i) = phase * internal::random<RealScalar>(RealScalar(0.5), RealScalar(1));
+  }
+}
+
 }  // end namespace Eigen
 
+template <typename DataContainer>
+void setRandomDataInRange(DataContainer& data_container, typename DataContainer::Scalar min_value,
+                          typename DataContainer::Scalar max_value) {
+  for (Eigen::Index i = 0; i < data_container.size(); ++i) {
+    data_container.data()[i] = Eigen::internal::random<typename DataContainer::Scalar>(min_value, max_value);
+  }
+}
+
+template <typename MatrixType, typename Scalar = typename MatrixType::Scalar>
+MatrixType RandomMatrix(Eigen::Index rows, Eigen::Index cols, Scalar min, Scalar max) {
+  MatrixType M(rows, cols);
+  for (Eigen::Index i = 0; i < rows; ++i) {
+    for (Eigen::Index j = 0; j < cols; ++j) {
+      M(i, j) = Eigen::internal::random<Scalar>(min, max);
+    }
+  }
+  return M;
+}
+
 #endif  // EIGEN_RANDOM_MATRIX_HELPER
diff --git a/test/random_without_cast_overflow.h b/test/random_without_cast_overflow.h
index c176c07..b39bcb5 100644
--- a/test/random_without_cast_overflow.h
+++ b/test/random_without_cast_overflow.h
@@ -6,10 +6,14 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // Utilities for generating random numbers without overflows, which might
 // otherwise result in undefined behavior.
 
+#ifndef EIGEN_TEST_RANDOM_WITHOUT_CAST_OVERFLOW_H
+#define EIGEN_TEST_RANDOM_WITHOUT_CAST_OVERFLOW_H
+
 namespace Eigen {
 namespace internal {
 
@@ -189,3 +193,5 @@
 
 }  // namespace internal
 }  // namespace Eigen
+
+#endif  // EIGEN_TEST_RANDOM_WITHOUT_CAST_OVERFLOW_H
diff --git a/test/real_qz.cpp b/test/real_qz.cpp
index 50c1e60..a525012 100644
--- a/test/real_qz.cpp
+++ b/test/real_qz.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_RUNTIME_NO_MALLOC
 #include "main.h"
@@ -43,11 +44,7 @@
   }
 
   RealQZ<MatrixType> qz(dim);
-  // TODO enable full-prealocation of required memory, this probably requires an in-place mode for
-  // HessenbergDecomposition
-  // Eigen::internal::set_is_malloc_allowed(false);
   qz.compute(A, B);
-  // Eigen::internal::set_is_malloc_allowed(true);
 
   VERIFY_IS_EQUAL(qz.info(), Success);
   // check for zeros
@@ -76,7 +73,57 @@
   VERIFY_IS_APPROX(qz.matrixZ() * qz.matrixZ().adjoint(), MatrixType::Identity(dim, dim));
 }
 
+// Regression test for the iteration-cap accounting bug in
+// RealQZ::compute. On a 3x3 all-zero pencil (a degenerate case observed
+// in production), every iteration of the inner while loop took the
+// pushDownZero branch and made no progress: pushDownZero(2, 0, 2) is a
+// no-op because its inner for(zz=z; zz<l; ++zz) loop runs zero times
+// and the trailing Givens rotation operates on already-zero entries.
+// Before the fix, local_iter was not incremented on the pushDownZero
+// branch, so the m_maxIters cap never engaged and compute() looped
+// indefinitely. After the fix, every "no convergence yet" iteration
+// counts toward the cap, so the loop exits with NoConvergence.
+template <typename MatrixType>
+void real_qz_iteration_cap_regression() {
+  MatrixType A = MatrixType::Zero(3, 3);
+  MatrixType B = MatrixType::Zero(3, 3);
+  RealQZ<MatrixType> qz(3);
+  qz.setMaxIterations(50);
+  qz.compute(A, B);
+  VERIFY_IS_EQUAL(qz.info(), NoConvergence);
+}
+
+// Block Householder operations still allocate at larger sizes (issue #3163).
+template <typename MatrixType>
+void real_qz_no_malloc() {
+  const Index dim = 24;
+  MatrixType A = MatrixType::Random(dim, dim), B = MatrixType::Random(dim, dim);
+  RealQZ<MatrixType> qz(dim);
+  internal::set_is_malloc_allowed(false);
+  qz.compute(A, B, false);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_EQUAL(qz.info(), Success);
+  const MatrixType S = qz.matrixS(), T = qz.matrixT();
+
+  for (int i = 0; i < 2; ++i) {
+    internal::set_is_malloc_allowed(false);
+    qz.compute(A, B, true);
+    internal::set_is_malloc_allowed(true);
+    VERIFY_IS_EQUAL(qz.info(), Success);
+    VERIFY_IS_APPROX(qz.matrixS(), S);
+    VERIFY_IS_APPROX(qz.matrixT(), T);
+    VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixS() * qz.matrixZ(), A);
+    VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixT() * qz.matrixZ(), B);
+    VERIFY_IS_APPROX(qz.matrixQ() * qz.matrixQ().adjoint(), MatrixType::Identity(dim, dim));
+    VERIFY_IS_APPROX(qz.matrixZ() * qz.matrixZ().adjoint(), MatrixType::Identity(dim, dim));
+  }
+}
+
 EIGEN_DECLARE_TEST(real_qz) {
+  CALL_SUBTEST_2((real_qz_no_malloc<MatrixXd>()));
+  CALL_SUBTEST_5((real_qz_no_malloc<Matrix<float, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_6((real_qz_no_malloc<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
+
   int s = 0;
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(real_qz(Matrix4f()));
@@ -88,7 +135,11 @@
     CALL_SUBTEST_2(real_qz(MatrixXd(2, 2)));
     CALL_SUBTEST_3(real_qz(Matrix<double, 1, 1>()));
     CALL_SUBTEST_4(real_qz(Matrix2d()));
+    CALL_SUBTEST_5((real_qz(Matrix<float, Dynamic, Dynamic, RowMajor>(17, 17))));
+    CALL_SUBTEST_6((real_qz(Matrix<double, Dynamic, Dynamic, RowMajor>(17, 17))));
+
+    CALL_SUBTEST_2(real_qz_iteration_cap_regression<MatrixXd>());
   }
 
-  TEST_SET_BUT_UNUSED_VARIABLE(s)
+  TEST_SET_BUT_UNUSED_VARIABLE(s);
 }
diff --git a/test/realview.cpp b/test/realview.cpp
index 7cefe6c..159c3fe 100644
--- a/test/realview.cpp
+++ b/test/realview.cpp
@@ -6,20 +6,20 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
 // wrapper that disables array-oriented access to real and imaginary components
 struct TestComplex : public std::complex<float> {
   TestComplex() = default;
-  TestComplex(const TestComplex&) = default;
   TestComplex(std::complex<float> x) : std::complex<float>(x){};
   TestComplex(float x) : std::complex<float>(x){};
 };
 template <>
-struct NumTraits<TestComplex> : NumTraits<std::complex<float>> {};
+struct Eigen::NumTraits<TestComplex> : Eigen::NumTraits<std::complex<float>> {};
 template <>
-struct internal::random_impl<TestComplex> : internal::random_impl<std::complex<float>> {};
+struct Eigen::internal::random_impl<TestComplex> : Eigen::internal::random_impl<std::complex<float>> {};
 
 template <typename T>
 void test_realview_readonly(const T&) {
@@ -46,6 +46,12 @@
 
   A.setRandom();
   VERIFY_IS_APPROX(A.matrix().cwiseAbs2().sum(), A.realView().matrix().cwiseAbs2().sum());
+  for (Index col = 0; col < cols; ++col) {
+    VERIFY_IS_APPROX(A.colwise().squaredNorm()(col), A.col(col).matrix().squaredNorm());
+  }
+  for (Index row = 0; row < rows; ++row) {
+    VERIFY_IS_APPROX(A.rowwise().squaredNorm()(row), A.row(row).matrix().squaredNorm());
+  }
 
   RealScalar alpha = internal::random(RealScalar(1), RealScalar(2));
 
@@ -129,8 +135,8 @@
   Index malloc_size = (rows * cols * sizeof(Scalar)) + sizeof(RealScalar);
   void* data1 = internal::aligned_malloc(malloc_size);
   void* data2 = internal::aligned_malloc(malloc_size);
-  Scalar* ptr1 = reinterpret_cast<Scalar*>(reinterpret_cast<uint8_t*>(data1) + sizeof(RealScalar));
-  Scalar* ptr2 = reinterpret_cast<Scalar*>(reinterpret_cast<uint8_t*>(data2) + sizeof(RealScalar));
+  Scalar* ptr1 = static_cast<Scalar*>(static_cast<void*>(static_cast<uint8_t*>(data1) + sizeof(RealScalar)));
+  Scalar* ptr2 = static_cast<Scalar*>(static_cast<void*>(static_cast<uint8_t*>(data2) + sizeof(RealScalar)));
   Map<T> C(ptr1, rows, cols), D(ptr2, rows, cols);
 
   C.setRandom();
@@ -230,9 +236,17 @@
   test_realview_readwrite<std::complex<float>, Rows, Cols, MaxRows, MaxCols>();
   test_realview_readwrite<double, Rows, Cols, MaxRows, MaxCols>();
   test_realview_readwrite<std::complex<double>, Rows, Cols, MaxRows, MaxCols>();
+  test_realview_readonly<TestComplex, Rows, Cols, MaxRows, MaxCols>();
+}
+
+// packet_traits<long double>::size is 1 on every supported target, so RealView's
+// vectorized paths are unreachable for it and repeating it over the shape matrix
+// only re-instantiates the same scalar fallback. Cover it on the fully dynamic
+// and fully fixed shapes, which are the two storage layouts it can distinguish.
+template <int Rows, int Cols, int MaxRows = Rows, int MaxCols = Cols>
+void test_realview_long_double() {
   test_realview_readwrite<long double, Rows, Cols, MaxRows, MaxCols>();
   test_realview_readwrite<std::complex<long double>, Rows, Cols, MaxRows, MaxCols>();
-  test_realview_readonly<TestComplex, Rows, Cols, MaxRows, MaxCols>();
 }
 
 EIGEN_DECLARE_TEST(realview) {
@@ -249,5 +263,7 @@
     CALL_SUBTEST_10((test_realview<1, 1>()));
     CALL_SUBTEST_11(test_edge_cases(std::complex<float>()));
     CALL_SUBTEST_12(test_edge_cases(std::complex<double>()));
+    CALL_SUBTEST_13((test_realview_long_double<Dynamic, Dynamic, Dynamic, Dynamic>()));
+    CALL_SUBTEST_13((test_realview_long_double<17, 19, 17, 19>()));
   }
 }
diff --git a/test/redux.cpp b/test/redux.cpp
index ad3ff1f..7cbb914 100644
--- a/test/redux.cpp
+++ b/test/redux.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
@@ -32,7 +33,7 @@
   m2.setRandom();
   // Prevent overflows for integer types.
   if (Eigen::NumTraits<Scalar>::IsInteger) {
-    Scalar kMaxVal = Scalar(10000);
+    Scalar kMaxVal = Scalar(8);
     m1.array() = m1.array() - kMaxVal * (m1.array() / kMaxVal);
     m2.array() = m2.array() - kMaxVal * (m2.array() / kMaxVal);
   }
@@ -72,8 +73,8 @@
   VERIFY_IS_APPROX(m1.block(r0, c0, r1, c1).real().maxCoeff(), m1.block(r0, c0, r1, c1).real().eval().maxCoeff());
 
   // regression for bug 1090
-  const int R1 = MatrixType::RowsAtCompileTime >= 2 ? MatrixType::RowsAtCompileTime / 2 : 6;
-  const int C1 = MatrixType::ColsAtCompileTime >= 2 ? MatrixType::ColsAtCompileTime / 2 : 6;
+  constexpr int R1 = MatrixType::RowsAtCompileTime >= 2 ? MatrixType::RowsAtCompileTime / 2 : 6;
+  constexpr int C1 = MatrixType::ColsAtCompileTime >= 2 ? MatrixType::ColsAtCompileTime / 2 : 6;
   if (R1 <= rows - r0 && C1 <= cols - c0) {
     VERIFY_IS_APPROX((m1.template block<R1, C1>(r0, c0).sum()), m1.block(r0, c0, R1, C1).sum());
   }
@@ -98,6 +99,11 @@
 
   VectorType v = VectorType::Random(size);
   VectorType v_for_prod = VectorType::Ones(size) + Scalar(0.2) * v;  // see comment above declaration of m1_for_prod
+  if (Eigen::NumTraits<Scalar>::IsInteger) {
+    Scalar kMaxVal = Scalar(8);
+    v.array() = v.array() - kMaxVal * (v.array() / kMaxVal);
+    v_for_prod = VectorType::Ones(size) + Scalar(0.2) * v;
+  }
 
   for (int i = 1; i < size; i++) {
     Scalar s(0), p(1);
@@ -180,8 +186,19 @@
     }
   VERIFY_IS_EQUAL(mixed.count(), expected_count);
   if (rows > 0 && cols > 0) {
+    BoolArray random = BoolArray::Random(rows, cols);
+    BoolArray last_false = all_true;
+    last_false(rows - 1, cols - 1) = false;
+    BoolArray last_true = all_false;
+    last_true(rows - 1, cols - 1) = true;
     VERIFY(mixed.any());
     VERIFY(mixed.all() == (expected_count == rows * cols));
+    VERIFY(!last_false.all());
+    VERIFY_IS_EQUAL(last_false.any(), rows * cols > 1);
+    VERIFY(last_true.any());
+    VERIFY_IS_EQUAL(last_true.all(), rows * cols == 1);
+    VERIFY_IS_EQUAL(random.sum(), random.any());
+    VERIFY_IS_EQUAL(random.prod(), random.all());
   }
 
   // Partial reductions
@@ -193,34 +210,86 @@
   }
 }
 
+// Compare the vectorized reductions of v against scalar references. v_for_prod carries the same
+// values shifted near one, so that prod() neither underflows (float) nor overflows (int).
+template <typename VecType>
+void redux_vec_boundary_check(const VecType& v, const VecType& v_for_prod) {
+  typedef typename VecType::Scalar Scalar;
+  const Index n = v.size();
+  Scalar ref_sum(0), ref_prod(1);
+  typename NumTraits<Scalar>::Real ref_min = numext::real(v(0)), ref_max = numext::real(v(0));
+  for (Index k = 0; k < n; ++k) {
+    ref_sum += v(k);
+    ref_prod *= v_for_prod(k);
+    ref_min = (std::min)(ref_min, numext::real(v(k)));
+    ref_max = (std::max)(ref_max, numext::real(v(k)));
+  }
+  VERIFY_IS_APPROX(v.sum(), ref_sum);
+  VERIFY_IS_APPROX(v_for_prod.prod(), ref_prod);
+  VERIFY_IS_APPROX(v.real().minCoeff(), ref_min);
+  VERIFY_IS_APPROX(v.real().maxCoeff(), ref_max);
+}
+
 // Test reductions at sizes that hit vectorization boundaries in Redux.h:
-// LinearVectorizedTraversal with 2-way unrolled packet loop, scalar pre/post loops.
+// LinearVectorizedTraversal with a 4-way unrolled packet loop, scalar pre/post loops.
 template <typename Scalar>
 void redux_vec_boundary() {
   const Index PS = internal::packet_traits<Scalar>::size;
-  // Critical sizes: around packet multiples and at 2-way unroll boundaries
-  const Index sizes[] = {1,      PS - 1,     PS,         PS + 1, 2 * PS - 1, 2 * PS, 2 * PS + 1,
-                         3 * PS, 3 * PS + 1, 4 * PS - 1, 4 * PS, 4 * PS + 1, 8 * PS, 8 * PS + 1};
-  for (int si = 0; si < 14; ++si) {
-    const Index n = sizes[si];
+  // Critical sizes: around packet multiples, at the 4-way unroll boundary, and at each of the one-,
+  // two- and three-packet residuals that the 4-way loop leaves to the straight-line merge.
+  const Index sizes[] = {1,          PS - 1, PS,         PS + 1, 2 * PS - 1, 2 * PS, 2 * PS + 1, 3 * PS,    3 * PS + 1,
+                         4 * PS - 1, 4 * PS, 4 * PS + 1, 5 * PS, 6 * PS,     7 * PS, 8 * PS,     8 * PS + 1};
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  for (const Index n : sizes) {
     if (n <= 0) continue;
-    typedef Matrix<Scalar, Dynamic, 1> Vec;
     Vec v = Vec::Random(n);
     // For prod, use values near 1 to avoid underflow (float) or overflow (int).
     Vec v_for_prod = Vec::Ones(n) + Scalar(typename NumTraits<Scalar>::Real(0.2)) * v;
-    // Reference: scalar loops
-    Scalar ref_sum(0), ref_prod(1);
-    typename NumTraits<Scalar>::Real ref_min = numext::real(v(0)), ref_max = numext::real(v(0));
-    for (Index k = 0; k < n; ++k) {
-      ref_sum += v(k);
-      ref_prod *= v_for_prod(k);
-      ref_min = (std::min)(ref_min, numext::real(v(k)));
-      ref_max = (std::max)(ref_max, numext::real(v(k)));
+    redux_vec_boundary_check(v, v_for_prod);
+
+    // Vec::Random() is always default-aligned, so a Map at a non-zero offset is the only way to
+    // reach alignedStart > 0 together with the 4-way loop.
+    Vec buf = Vec::Random(n + PS);
+    Vec buf_for_prod = Vec::Ones(n + PS) + Scalar(typename NumTraits<Scalar>::Real(0.2)) * buf;
+    for (Index offset = 1; offset < PS; ++offset) {
+      Map<const Vec, Unaligned> mapped(buf.data() + offset, n);
+      Map<const Vec, Unaligned> mapped_for_prod(buf_for_prod.data() + offset, n);
+      redux_vec_boundary_check(mapped, mapped_for_prod);
     }
-    VERIFY_IS_APPROX(v.sum(), ref_sum);
-    VERIFY_IS_APPROX(v_for_prod.prod(), ref_prod);
-    VERIFY_IS_APPROX(v.real().minCoeff(), ref_min);
-    VERIFY_IS_APPROX(v.real().maxCoeff(), ref_max);
+  }
+}
+
+// Test block reductions at sizes that hit the boundaries of SliceVectorizedTraversal in Redux.h:
+// panels of one to eight packets, the 4-way unroll inside a panel and each of its residuals, and
+// the narrow panels whose accumulators have to come from the outer dimension instead.
+template <typename Scalar>
+void redux_block_boundary() {
+  const Index PS = internal::packet_traits<Scalar>::size;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index innerSizes[] = {1,      PS - 1, PS,     PS + 1, 2 * PS,     3 * PS,    4 * PS - 1,
+                              4 * PS, 5 * PS, 6 * PS, 7 * PS, 8 * PS - 1, 8 * PS + 1};
+  // Panel counts below, at and above the four the outer-dimension accumulators consume at a time.
+  const Index outerSizes[] = {1, 2, 3, 4, 5, 8, 9};
+  for (const Index rows : innerSizes) {
+    if (rows <= 0) continue;  // PS - 1 where Scalar is not vectorized
+    for (const Index cols : outerSizes) {
+      // A strict sub-block keeps the reduction off the linear path.
+      Mat m = Mat::Random(rows + 3, cols + 3);
+      Scalar ref_sum(0);
+      RealScalar ref_min = numext::real(m(0, 0)), ref_max = numext::real(m(0, 0)), ref_sqnorm(0);
+      for (Index j = 0; j < cols; ++j)
+        for (Index i = 0; i < rows; ++i) {
+          ref_sum += m(i, j);
+          ref_sqnorm += numext::abs2(m(i, j));
+          ref_min = (std::min)(ref_min, numext::real(m(i, j)));
+          ref_max = (std::max)(ref_max, numext::real(m(i, j)));
+        }
+      VERIFY_IS_APPROX(m.block(0, 0, rows, cols).sum(), ref_sum);
+      VERIFY_IS_APPROX(m.block(0, 0, rows, cols).squaredNorm(), ref_sqnorm);
+      VERIFY_IS_APPROX(m.block(0, 0, rows, cols).real().minCoeff(), ref_min);
+      VERIFY_IS_APPROX(m.block(0, 0, rows, cols).real().maxCoeff(), ref_max);
+    }
   }
 }
 
@@ -256,6 +325,322 @@
   }
 }
 
+// redux() documents that its functor must be associative; it is not required to be commutative.
+// An implementation may therefore re-associate, but must not reorder the operands. These two
+// functors are associative and non-commutative: each projects onto one end of the operand
+// sequence, so together they pin both ends of the traversal order. Independent per-lane
+// accumulators, for instance, leave keep_first intact but move keep_last onto whichever lane
+// happens to end last. Sizes straddle the unrolled block, its ragged tail, and the fallback.
+struct keep_first_op {
+  template <typename Scalar>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& /*b*/) const {
+    return a;
+  }
+};
+
+struct keep_last_op {
+  template <typename Scalar>
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& /*a*/, const Scalar& b) const {
+    return b;
+  }
+};
+
+template <typename Scalar>
+void redux_operand_order() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  // Sizes straddle the small-size fallback, the ordered-tree cutoff, and its ragged tail.
+  const Index sizes[] = {1, 2, 5, 7, 8, 9, 15, 16, 17, 23, 24, 31, 32, 33, 64, 129, 191, 192, 193, 250};
+  keep_first_op first;
+  keep_last_op last;
+  for (int si = 0; si < 20; ++si) {
+    const Index n = sizes[si];
+    // Distinct values so that any reordering is observable.
+    Vec v(n);
+    for (Index i = 0; i < n; ++i) v.coeffRef(i) = Scalar(i + 1);
+    // LinearTraversal: operands run 0 .. n-1.
+    VERIFY_IS_EQUAL(v.redux(first), v.coeff(0));
+    VERIFY_IS_EQUAL(v.redux(last), v.coeff(n - 1));
+
+    // DefaultTraversal: a non-inner-panel block drops LinearAccessBit, and is traversed
+    // outer-then-inner, so the operands run from (0,0) to (innerSize-1, outerSize-1).
+    Mat m(n + 1, n + 1);
+    for (Index c = 0; c < n + 1; ++c)
+      for (Index r = 0; r < n + 1; ++r) m.coeffRef(r, c) = Scalar(c * (n + 1) + r + 1);
+    Block<Mat, Dynamic, Dynamic, false> b(m, 1, 1, n, n);
+    VERIFY_IS_EQUAL(b.redux(first), b.coeff(0, 0));
+    VERIFY_IS_EQUAL(b.redux(last), b.coeff(n - 1, n - 1));
+  }
+}
+
+// A functor marked commutative via internal::functor_is_commutative: reductions may reorder its
+// operands. Values are integers (exactly representable for every tested Scalar), so a reordered
+// reduction must still match the serial reference bit-for-bit.
+template <typename Scalar>
+struct marked_commutative_sum_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const { return a + b; }
+};
+
+namespace Eigen {
+namespace internal {
+template <typename Scalar>
+struct functor_is_commutative<marked_commutative_sum_op<Scalar>> : std::true_type {};
+}  // namespace internal
+}  // namespace Eigen
+
+template <typename Scalar>
+void redux_commutative() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  const Index sizes[] = {1, 2, 7, 8, 9, 15, 16, 17, 24, 31, 32, 33, 63, 64, 65, 129, 192, 250};
+  marked_commutative_sum_op<Scalar> op;
+  for (int si = 0; si < 18; ++si) {
+    const Index n = sizes[si];
+    Vec v(n);
+    Scalar vref(0);
+    for (Index i = 0; i < n; ++i) {
+      v.coeffRef(i) = Scalar(i % 9 + 1);
+      vref = vref + v.coeff(i);
+    }
+    VERIFY_IS_EQUAL(v.redux(op), vref);
+
+    Mat m(n + 1, n + 1);
+    m.setZero();
+    Scalar bref(0);
+    for (Index c = 1; c < n + 1; ++c)
+      for (Index r = 1; r < n + 1; ++r) {
+        m.coeffRef(r, c) = Scalar((r * 3 + c) % 7 + 1);
+        bref = bref + m.coeff(r, c);
+      }
+    Block<Mat, Dynamic, Dynamic, false> b(m, 1, 1, n, n);
+    VERIFY_IS_EQUAL(b.redux(op), bref);
+  }
+}
+
+// min/max are marked commutative, so the reordering reduction paths may see their NaN operands
+// in any order. The reordered result must still honor each NaN mode's contract: PropagateNaN
+// returns NaN if any operand is NaN, PropagateNumbers returns the min/max of the non-NaN
+// operands (NaN only when all are NaN). PropagateFast leaves NaN results unspecified, so it is
+// only checked on NaN-free data. Strided expressions have no packet access, which forces the
+// scalar reduction paths: a strided vector Map takes LinearTraversal, a strided matrix Map takes
+// DefaultTraversal. NaN positions cover the first lane, other lanes, the unrolled-region end,
+// and the serial tail.
+template <typename Scalar>
+void redux_minmax_nan() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  const Scalar kNaN = std::numeric_limits<Scalar>::quiet_NaN();
+  const Index sizes[] = {2, 3, 7, 8, 9, 15, 16, 17, 31, 33, 64, 129, 250};
+  for (int si = 0; si < 13; ++si) {
+    const Index n = sizes[si];
+
+    // Strided vector view: LinearTraversal without packet access.
+    Vec backing(2 * n);
+    backing.setZero();
+    Map<Vec, 0, InnerStride<2>> v(backing.data(), n, InnerStride<2>(2));
+    for (Index i = 0; i < n; ++i) v.coeffRef(i) = Scalar((i * 7) % 13) - Scalar(6);
+    const Scalar refMin = v.minCoeff();  // reference from NaN-free data
+    const Scalar refMax = v.maxCoeff();
+
+    // NaN-free: all modes must agree with the reference.
+    VERIFY_IS_EQUAL((v.template minCoeff<PropagateNaN>()), refMin);
+    VERIFY_IS_EQUAL((v.template maxCoeff<PropagateNaN>()), refMax);
+    VERIFY_IS_EQUAL((v.template minCoeff<PropagateNumbers>()), refMin);
+    VERIFY_IS_EQUAL((v.template maxCoeff<PropagateNumbers>()), refMax);
+
+    const Index nanPositions[] = {0, 1, 7, 8, n / 2, n - 9, n - 2, n - 1};
+    for (int pi = 0; pi < 8; ++pi) {
+      const Index p = nanPositions[pi];
+      if (p < 0 || p >= n) continue;
+      const Scalar saved = v.coeff(p);
+      v.coeffRef(p) = kNaN;
+      // Reference over the remaining numbers, computed serially.
+      Scalar numMin = NumTraits<Scalar>::highest(), numMax = NumTraits<Scalar>::lowest();
+      bool allNaN = true;
+      for (Index i = 0; i < n; ++i) {
+        if ((numext::isnan)(v.coeff(i))) continue;
+        allNaN = false;
+        numMin = numext::mini(numMin, v.coeff(i));
+        numMax = numext::maxi(numMax, v.coeff(i));
+      }
+      VERIFY((numext::isnan)(v.template minCoeff<PropagateNaN>()));
+      VERIFY((numext::isnan)(v.template maxCoeff<PropagateNaN>()));
+      if (!allNaN) {
+        VERIFY_IS_EQUAL((v.template minCoeff<PropagateNumbers>()), numMin);
+        VERIFY_IS_EQUAL((v.template maxCoeff<PropagateNumbers>()), numMax);
+      }
+      v.coeffRef(p) = saved;
+    }
+
+    // Two NaNs in different lanes, and every coefficient NaN.
+    if (n >= 2) {
+      const Scalar s0 = v.coeff(0), s1 = v.coeff(n - 1);
+      v.coeffRef(0) = kNaN;
+      v.coeffRef(n - 1) = kNaN;
+      VERIFY((numext::isnan)(v.template minCoeff<PropagateNaN>()));
+      if (n > 2) {
+        Scalar numMin = NumTraits<Scalar>::highest();
+        for (Index i = 1; i < n - 1; ++i) numMin = numext::mini(numMin, v.coeff(i));
+        VERIFY_IS_EQUAL((v.template minCoeff<PropagateNumbers>()), numMin);
+      }
+      v.coeffRef(0) = s0;
+      v.coeffRef(n - 1) = s1;
+    }
+    v.setConstant(kNaN);
+    VERIFY((numext::isnan)(v.template minCoeff<PropagateNaN>()));
+    VERIFY((numext::isnan)(v.template minCoeff<PropagateNumbers>()));
+    VERIFY((numext::isnan)(v.template maxCoeff<PropagateNaN>()));
+    VERIFY((numext::isnan)(v.template maxCoeff<PropagateNumbers>()));
+
+    // Strided matrix view: DefaultTraversal without packet access. NaN in the interior.
+    if (n >= 3) {
+      Mat mbacking(2 * n, n);
+      mbacking.setZero();
+      Map<Mat, 0, Stride<Dynamic, 2>> m(mbacking.data(), n, n, Stride<Dynamic, 2>(2 * n, 2));
+      for (Index c = 0; c < n; ++c)
+        for (Index r = 0; r < n; ++r) m.coeffRef(r, c) = Scalar((r * 5 + c * 3) % 11) - Scalar(5);
+      const Scalar mrefMin = m.minCoeff();
+      VERIFY_IS_EQUAL((m.template minCoeff<PropagateNaN>()), mrefMin);
+      VERIFY_IS_EQUAL((m.template minCoeff<PropagateNumbers>()), mrefMin);
+      m.coeffRef(n / 2, n / 2) = kNaN;
+      Scalar numMin = NumTraits<Scalar>::highest(), numMax = NumTraits<Scalar>::lowest();
+      for (Index c = 0; c < n; ++c)
+        for (Index r = 0; r < n; ++r) {
+          if ((numext::isnan)(m.coeff(r, c))) continue;
+          numMin = numext::mini(numMin, m.coeff(r, c));
+          numMax = numext::maxi(numMax, m.coeff(r, c));
+        }
+      VERIFY((numext::isnan)(m.template minCoeff<PropagateNaN>()));
+      VERIFY((numext::isnan)(m.template maxCoeff<PropagateNaN>()));
+      VERIFY_IS_EQUAL((m.template minCoeff<PropagateNumbers>()), numMin);
+      VERIFY_IS_EQUAL((m.template maxCoeff<PropagateNumbers>()), numMax);
+    }
+  }
+}
+
+// A custom scalar whose comparison ignores its tag, so equivalent values are observably
+// distinct. The generic std::min/std::max keep the first operand of a tie, and custom scalars
+// are excluded from the min/max commutativity opt-in, so minCoeff()/maxCoeff() must return the
+// first extremum in traversal order.
+struct TaggedScalar {
+  double v;
+  int tag;
+  TaggedScalar() : v(0), tag(0) {}
+  TaggedScalar(double v_, int tag_) : v(v_), tag(tag_) {}
+  bool operator<(const TaggedScalar& other) const { return v < other.v; }
+};
+
+namespace Eigen {
+template <>
+struct NumTraits<TaggedScalar> : GenericNumTraits<TaggedScalar> {};
+}  // namespace Eigen
+
+void redux_custom_scalar_min_ties() {
+  typedef Matrix<TaggedScalar, Dynamic, 1> Vec;
+  STATIC_CHECK(
+      !(internal::functor_is_commutative<internal::scalar_min_op<TaggedScalar, TaggedScalar, PropagateFast>>::value));
+  // Sizes on both sides of the ordered-tree cutoff, extrema in different unroll regions.
+  const Index sizes[] = {10, 33, 250, 1000};
+  for (int si = 0; si < 4; ++si) {
+    const Index n = sizes[si];
+    Vec x(n);
+    for (Index i = 0; i < n; ++i) x.coeffRef(i) = TaggedScalar(double(i % 17), int(i));
+    // Two equal minima (v == -1): the first in traversal order must win.
+    x.coeffRef(2) = TaggedScalar(-1.0, 2);
+    x.coeffRef(n - 2) = TaggedScalar(-1.0, int(n - 2));
+    VERIFY_IS_EQUAL(x.minCoeff().tag, 2);
+    // Two equal maxima (v == 100).
+    x.coeffRef(3) = TaggedScalar(100.0, 3);
+    x.coeffRef(n - 3) = TaggedScalar(100.0, int(n - 3));
+    VERIFY_IS_EQUAL(x.maxCoeff().tag, 3);
+    // All coefficients equivalent: the very first must win.
+    Vec y(n);
+    for (Index i = 0; i < n; ++i) y.coeffRef(i) = TaggedScalar(5.0, int(i));
+    VERIFY_IS_EQUAL(y.minCoeff().tag, 0);
+    VERIFY_IS_EQUAL(y.maxCoeff().tag, 0);
+  }
+}
+
+// Test reductions on expressions whose inner stride is NOT statically 1 (so they lose
+// compile-time vectorization) but ARE contiguous at runtime: a dynamic-inner-stride Map with
+// runtime stride 1, a row of a 1xN dynamic matrix, and a fully-packed dynamic-stride matrix Ref.
+// These exercise the runtime unit-stride fast path in redux_dispatch (Redux.h) and the matching
+// squaredNorm()/norm() fast path (squared_norm_impl in Dot.h). The last check confirms the
+// fallback path stays correct when the runtime inner stride is genuinely != 1.
+template <typename Scalar>
+void redux_runtime_contiguous() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  const Index sizes[] = {1, 2, 7, 8, 9, 16, 17, 64, 255, 256, 257};
+  for (int si = 0; si < 11; ++si) {
+    const Index n = sizes[si];
+    Vec data = Vec::Random(2 * n);
+    Vec data_for_prod = Vec::Ones(2 * n) + Scalar(RealScalar(0.2)) * data;
+    Scalar rs(0), rp(1);
+    RealScalar rmin = numext::real(data(0)), rmax = numext::real(data(0)), rsqn(0);
+    for (Index k = 0; k < n; ++k) {
+      rs += data(k);
+      rp *= data_for_prod(k);
+      rmin = (std::min)(rmin, numext::real(data(k)));
+      rmax = (std::max)(rmax, numext::real(data(k)));
+      rsqn += numext::abs2(data(k));
+    }
+
+    // (a) dynamic-inner-stride Map with runtime stride 1 -> fast path.
+    Map<Vec, 0, InnerStride<Dynamic>> m(data.data(), n, InnerStride<Dynamic>(1));
+    VERIFY_IS_APPROX(m.sum(), rs);
+    VERIFY_IS_APPROX(m.mean(), rs / Scalar(RealScalar(n)));
+    VERIFY_IS_APPROX(m.real().minCoeff(), rmin);
+    VERIFY_IS_APPROX(m.real().maxCoeff(), rmax);
+    VERIFY_IS_APPROX(m.squaredNorm(), rsqn);  // squaredNorm/norm fast path (squared_norm_impl)
+    VERIFY_IS_APPROX(m.norm(), numext::sqrt(rsqn));
+    Map<Vec, 0, InnerStride<Dynamic>> mp(data_for_prod.data(), n, InnerStride<Dynamic>(1));
+    VERIFY_IS_APPROX(mp.prod(), rp);
+
+    // (a') an *aligned* dynamic-inner-stride Map with runtime stride 1 exercises the aligned-load
+    // fast path: the runtime-contiguous Map inherits evaluator<Derived>::Alignment, so an aligned
+    // source must reduce correctly and must not trip the Map alignment assertion. The data buffer
+    // comes from an Eigen Vec, which is allocated AlignedMax-aligned.
+    Map<Vec, AlignedMax, InnerStride<Dynamic>> ma(data.data(), n, InnerStride<Dynamic>(1));
+    VERIFY_IS_APPROX(ma.sum(), rs);
+    VERIFY_IS_APPROX(ma.real().minCoeff(), rmin);
+    VERIFY_IS_APPROX(ma.real().maxCoeff(), rmax);
+    VERIFY_IS_APPROX(ma.squaredNorm(), rsqn);
+    VERIFY_IS_APPROX(ma.norm(), numext::sqrt(rsqn));
+
+    // (b) a row of a 1xN dynamic matrix is contiguous at runtime (inner stride == 1).
+    Mat r = Mat::Random(1, n);
+    Scalar row_sum(0);
+    RealScalar row_sqn(0);
+    for (Index j = 0; j < n; ++j) {
+      row_sum += r(0, j);
+      row_sqn += numext::abs2(r(0, j));
+    }
+    VERIFY_IS_APPROX(r.row(0).sum(), row_sum);
+    VERIFY_IS_APPROX(r.row(0).squaredNorm(), row_sqn);
+
+    // (c) fully-packed dynamic-stride matrix Ref -> fast path; must match the dense result.
+    if (n >= 2) {
+      Mat M = Mat::Random(n, 3);
+      Ref<Mat, 0, Stride<Dynamic, Dynamic>> mref(M);
+      VERIFY_IS_APPROX(mref.sum(), M.sum());
+      VERIFY_IS_APPROX(mref.real().minCoeff(), M.real().minCoeff());
+    }
+
+    // (d) fallback: a genuinely strided (stride 2) dynamic Map must still reduce correctly.
+    Map<Vec, 0, InnerStride<Dynamic>> m2(data.data(), n, InnerStride<Dynamic>(2));
+    Scalar rs2(0);
+    RealScalar rsqn2(0);
+    for (Index k = 0; k < n; ++k) {
+      rs2 += data(2 * k);
+      rsqn2 += numext::abs2(data(2 * k));
+    }
+    VERIFY_IS_APPROX(m2.sum(), rs2);
+    VERIFY_IS_APPROX(m2.squaredNorm(), rsqn2);
+  }
+}
+
 EIGEN_DECLARE_TEST(redux) {
   // the max size cannot be too large, otherwise reduxion operations obviously generate large errors.
   int maxsize = (std::min)(100, EIGEN_TEST_MAX_SIZE);
@@ -307,7 +692,6 @@
     CALL_SUBTEST_10(vectorRedux(ArrayX<int64_t>(size)));
   }
   // Bool reductions (deterministic, outside g_repeat)
-  CALL_SUBTEST_11(boolRedux(1, 1));
   CALL_SUBTEST_11(boolRedux(4, 4));
   CALL_SUBTEST_11(boolRedux(7, 13));
   CALL_SUBTEST_11(boolRedux(63, 63));
@@ -331,9 +715,34 @@
   // Integer reductions are already tested by matrixRedux/vectorRedux with clamped values.
   CALL_SUBTEST_12(redux_vec_boundary<float>());
   CALL_SUBTEST_12(redux_vec_boundary<double>());
+  CALL_SUBTEST_12(redux_block_boundary<float>());
+  CALL_SUBTEST_12(redux_block_boundary<double>());
+  CALL_SUBTEST_12(redux_block_boundary<std::complex<float>>());
 
   // Strided (non-contiguous) reductions.
   CALL_SUBTEST_13(redux_strided<float>());
   CALL_SUBTEST_13(redux_strided<double>());
   CALL_SUBTEST_13(redux_strided<std::complex<float>>());
+
+  // Operand order must survive the scalar unrolled paths (associative, non-commutative functor).
+  CALL_SUBTEST_13(redux_operand_order<float>());
+  CALL_SUBTEST_13(redux_operand_order<double>());
+  CALL_SUBTEST_13(redux_operand_order<int>());
+
+  // Functors marked commutative may be reordered but must stay exact on integer values.
+  CALL_SUBTEST_13(redux_commutative<int>());
+  CALL_SUBTEST_13(redux_commutative<double>());
+
+  // min/max NaN contracts must survive reordered scalar reductions.
+  CALL_SUBTEST_13(redux_minmax_nan<float>());
+  CALL_SUBTEST_13(redux_minmax_nan<double>());
+
+  // Custom scalars stay on the order-preserving path: first extremum wins ties.
+  CALL_SUBTEST_13(redux_custom_scalar_min_ties());
+
+  // Runtime unit-stride fast path (redux_dispatch in Redux.h).
+  CALL_SUBTEST_13(redux_runtime_contiguous<float>());
+  CALL_SUBTEST_13(redux_runtime_contiguous<double>());
+  CALL_SUBTEST_13(redux_runtime_contiguous<std::complex<float>>());
+  CALL_SUBTEST_13(redux_runtime_contiguous<std::complex<double>>());
 }
diff --git a/test/redux_bounded.cpp b/test/redux_bounded.cpp
new file mode 100644
index 0000000..8ab7ad8
--- /dev/null
+++ b/test/redux_bounded.cpp
@@ -0,0 +1,177 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+using BoundedVector4d = Matrix<double, Dynamic, 1, ColMajor, 4, 1>;
+using BoundedMatrix4d = Matrix<double, Dynamic, Dynamic, ColMajor, 4, 4>;
+
+EIGEN_DONT_INLINE MatrixXd bounded_transform(const MatrixXd& vertices, const BoundedMatrix4d& transform) {
+  MatrixXd transformed(vertices.rows(), vertices.cols());
+  for (Index col = 0; col < vertices.cols(); ++col) {
+    BoundedVector4d homogeneous = BoundedVector4d::Ones(vertices.rows() + 1);
+    homogeneous.head(vertices.rows()) = vertices.col(col);
+    transformed.col(col) = (transform * homogeneous).head(vertices.rows());
+  }
+  return transformed;
+}
+
+struct BoundedFirst {
+  int operator()(int first, int) const { return first; }
+};
+
+template <int Order>
+void mixed_bounded_products() {
+  using BoundedVector = Matrix<double, Dynamic, 1, ColMajor, 3, 1>;
+  using DynamicMatrix = Matrix<double, Dynamic, Dynamic, Order>;
+  for (Index size = 1; size <= 3; ++size) {
+    const DynamicMatrix matrix = DynamicMatrix::Random(size, size);
+    const BoundedVector vector = BoundedVector::Random(size);
+    const VectorXd dynamic = vector;
+    const auto left = dynamic.cwiseProduct(vector);
+    const auto right = vector.cwiseProduct(dynamic);
+    STATIC_CHECK(decltype(left)::MaxSizeAtCompileTime == Dynamic);
+    STATIC_CHECK(decltype(right)::MaxSizeAtCompileTime == 3);
+    STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(left)>>::Size == 3);
+    STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(right)>>::Size == 3);
+    VERIFY_IS_EQUAL(left.sum(), right.sum());
+    const BoundedVector result = matrix * vector;
+    const auto reversed = (vector.transpose() * matrix.transpose()).eval();
+    for (Index row = 0; row < size; ++row) {
+      double expected = 0;
+      for (Index col = 0; col < size; ++col) expected += matrix(row, col) * vector(col);
+      VERIFY(numext::abs(result(row) - expected) <= 8 * NumTraits<double>::epsilon());
+      VERIFY(numext::abs(reversed(row) - expected) <= 8 * NumTraits<double>::epsilon());
+    }
+  }
+}
+
+template <int Order>
+void heap_backed_expression_bounds() {
+  using RowsBounded = Matrix<double, Dynamic, Dynamic, Order, 200, Dynamic>;
+  using ColsBounded = Matrix<double, Dynamic, Dynamic, Order, Dynamic, 200>;
+  const RowsBounded a = RowsBounded::Ones(2, 2);
+  const ColsBounded b = ColsBounded::Ones(2, 2);
+  using Bounds = internal::redux_max_size<internal::remove_all_t<decltype(a + b)>>;
+  STATIC_CHECK(Bounds::Rows == 200);
+  STATIC_CHECK(Bounds::Cols == 200);
+  STATIC_CHECK(Bounds::Size == 40000);
+  const auto sum = (a + b).eval();
+  const auto reversed = (b + a).eval();
+  STATIC_CHECK((std::is_same<internal::remove_all_t<decltype(sum)>, RowsBounded>::value));
+  STATIC_CHECK((std::is_same<internal::remove_all_t<decltype(reversed)>, ColsBounded>::value));
+  VERIFY_IS_EQUAL(sum, RowsBounded::Constant(2, 2, 2));
+  VERIFY_IS_EQUAL(reversed, ColsBounded::Constant(2, 2, 2));
+  VERIFY_IS_EQUAL((a + b).sum(), 8);
+}
+
+template <int Order>
+void complementary_reduction_bounds() {
+  using RowsBounded = Matrix<int, Dynamic, Dynamic, Order, 4, Dynamic>;
+  using ColsBounded = Matrix<int, Dynamic, Dynamic, Order, Dynamic, 4>;
+  const RowsBounded a = RowsBounded::Constant(3, 4, 2);
+  const ColsBounded b = ColsBounded::Constant(3, 4, 3);
+  using Bounds = internal::redux_max_size<internal::remove_all_t<decltype(a + b)>>;
+  STATIC_CHECK(Bounds::Size == 16);
+  VERIFY_IS_EQUAL((a + b).sum(), 60);
+  VERIFY_IS_EQUAL((a + b).redux(BoundedFirst()), 5);
+  VERIFY_IS_EQUAL((b + a).redux(BoundedFirst()), 5);
+
+  const Matrix<bool, Dynamic, Dynamic, Order> condition = Matrix<bool, Dynamic, Dynamic, Order>::Constant(3, 4, true);
+  const auto selected = condition.select(a, b);
+  const auto reversed = condition.select(b, a);
+  using SelectedBounds = internal::redux_max_size<internal::remove_all_t<decltype(selected)>>;
+  using ReversedBounds = internal::redux_max_size<internal::remove_all_t<decltype(reversed)>>;
+  STATIC_CHECK(SelectedBounds::Rows == 4 && SelectedBounds::Cols == 4 && SelectedBounds::Size == 16);
+  STATIC_CHECK(ReversedBounds::Size == 16);
+  STATIC_CHECK(decltype(selected)::MaxSizeAtCompileTime == Dynamic);
+  VERIFY_IS_EQUAL(selected.sum(), 24);
+  VERIFY_IS_EQUAL(reversed.sum(), 36);
+  VERIFY_IS_EQUAL(selected.redux(BoundedFirst()), 2);
+  VERIFY_IS_EQUAL(reversed.redux(BoundedFirst()), 3);
+
+  using Bounded = Matrix<int, Dynamic, Dynamic, Order, 4, 4>;
+  const Bounded bounded = Bounded::Constant(3, 4, 7);
+  const Matrix<int, Dynamic, Dynamic, Order> dynamic = bounded;
+  const auto bounded_second = condition.select(bounded, dynamic);
+  const auto bounded_third = condition.select(dynamic, bounded);
+  const auto bounded_first = (bounded.array() > 0).select(dynamic.array(), dynamic.array());
+  STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(bounded_second)>>::Size == 16);
+  STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(bounded_third)>>::Size == 16);
+  STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(bounded_first)>>::Size == 16);
+  VERIFY_IS_EQUAL(bounded_second.sum(), 84);
+  VERIFY_IS_EQUAL(bounded_third.sum(), 84);
+  VERIFY_IS_EQUAL(bounded_first.sum(), 84);
+
+  using HugeRows = Matrix<int, Dynamic, Dynamic, Order, 100000, Dynamic>;
+  using HugeCols = Matrix<int, Dynamic, Dynamic, Order, Dynamic, 100000>;
+  using HugeExpression = decltype(std::declval<HugeRows>() + std::declval<HugeCols>());
+  STATIC_CHECK(internal::redux_max_size<HugeExpression>::Size == Dynamic);
+}
+
+template <typename Scalar, int Capacity>
+void mixed_packet_reductions() {
+  using Bounded = Matrix<Scalar, Dynamic, 1, ColMajor, Capacity, 1>;
+  using DynamicVector = Matrix<Scalar, Dynamic, 1>;
+  for (Index size = 0; size <= Capacity; ++size) {
+    Bounded bounded(size);
+    DynamicVector dynamic(size);
+    Scalar expected = 0;
+    for (Index i = 0; i < size; ++i) {
+      bounded(i) = Scalar(i % 5 - 2);
+      dynamic(i) = Scalar(i % 3 + 1);
+      expected += bounded(i) * dynamic(i);
+    }
+    const auto left = dynamic.cwiseProduct(bounded);
+    const auto right = bounded.cwiseProduct(dynamic);
+    STATIC_CHECK(decltype(left)::MaxSizeAtCompileTime == Dynamic);
+    STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(left)>>::Size == Capacity);
+    STATIC_CHECK(internal::redux_max_size<internal::remove_all_t<decltype(right)>>::Size == Capacity);
+    VERIFY_IS_EQUAL(left.sum(), expected);
+    VERIFY_IS_EQUAL(right.sum(), expected);
+  }
+}
+
+template <int Order>
+void bounded_reductions() {
+  for (Index size : {1, 4, 15, 16, 31, 32, 33, 64}) {
+    Matrix<int, Dynamic, Dynamic, Order, 64, 64> matrix(size, size);
+    for (Index row = 0; row < size; ++row)
+      for (Index col = 0; col < size; ++col) matrix(row, col) = int(row + col + 1);
+    VERIFY_IS_EQUAL(matrix.sum(), size * size * size);
+    VERIFY_IS_EQUAL(matrix.redux(BoundedFirst()), 1);
+    VERIFY_IS_EQUAL(matrix.topLeftCorner(size, size).sum(), size * size * size);
+    VERIFY_IS_EQUAL(matrix.topLeftCorner(size, size).redux(BoundedFirst()), 1);
+  }
+}
+
+EIGEN_DECLARE_TEST(redux_bounded) {
+  mixed_packet_reductions<float, 3>();
+  mixed_packet_reductions<float, 7>();
+  mixed_packet_reductions<float, 15>();
+  mixed_packet_reductions<float, 17>();
+  mixed_packet_reductions<double, 3>();
+  mixed_packet_reductions<double, 7>();
+  mixed_packet_reductions<double, 15>();
+  mixed_packet_reductions<double, 17>();
+  for (Index size = 0; size <= 3; ++size) {
+    const MatrixXd vertices = MatrixXd::Random(size, 10);
+    const BoundedMatrix4d transform = BoundedMatrix4d::Random(size + 1, size + 1);
+    const MatrixXd result = bounded_transform(vertices, transform);
+    for (Index row = 0; row < size; ++row) {
+      for (Index col = 0; col < vertices.cols(); ++col) {
+        double expected = transform(row, size);
+        for (Index k = 0; k < size; ++k) expected += transform(row, k) * vertices(k, col);
+        VERIFY(numext::abs(result(row, col) - expected) <= 32 * NumTraits<double>::epsilon());
+      }
+    }
+  }
+  bounded_reductions<ColMajor>();
+  bounded_reductions<RowMajor>();
+  mixed_bounded_products<ColMajor>();
+  mixed_bounded_products<RowMajor>();
+  heap_backed_expression_bounds<ColMajor>();
+  heap_backed_expression_bounds<RowMajor>();
+  complementary_reduction_bounds<ColMajor>();
+  complementary_reduction_bounds<RowMajor>();
+}
diff --git a/test/redux_bounded_compile.cpp b/test/redux_bounded_compile.cpp
new file mode 100644
index 0000000..98d45c1
--- /dev/null
+++ b/test/redux_bounded_compile.cpp
@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include <Eigen/Core>
+
+using BoundedVector4d = Eigen::Matrix<double, Eigen::Dynamic, 1, Eigen::ColMajor, 4, 1>;
+using BoundedMatrix4d = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, 4, 4>;
+
+Eigen::MatrixXd bounded_transform(const Eigen::MatrixXd& vertices, const BoundedMatrix4d& transform) {
+  Eigen::MatrixXd transformed(vertices.rows(), vertices.cols());
+  for (Eigen::Index col = 0; col < vertices.cols(); ++col) {
+    BoundedVector4d homogeneous = BoundedVector4d::Ones(vertices.rows() + 1);
+    homogeneous.head(vertices.rows()) = vertices.col(col);
+    transformed.col(col) = (transform * homogeneous).head(vertices.rows());
+  }
+  return transformed;
+}
+
+int main() {}
diff --git a/test/ref.cpp b/test/ref.cpp
index 8b19355..21cfc30 100644
--- a/test/ref.cpp
+++ b/test/ref.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This unit test cannot be easily written to work with EIGEN_DEFAULT_TO_ROW_MAJOR
 #ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
@@ -15,6 +16,7 @@
 #define TEST_ENABLE_TEMPORARY_TRACKING
 #define TEST_CHECK_STATIC_ASSERTIONS
 #include "main.h"
+#include "random_for_arithmetic.h"
 
 // test Ref.h
 
@@ -44,7 +46,7 @@
 
   Index rows = m.rows(), cols = m.cols();
 
-  MatrixType m1 = MatrixType::Random(rows, cols), m2 = m1;
+  MatrixType m1 = random_for_arithmetic<MatrixType>(rows, cols), m2 = m1;
 
   Index i = internal::random<Index>(0, rows - 1);
   Index j = internal::random<Index>(0, cols - 1);
@@ -61,7 +63,7 @@
   m2.block(i, j, brows, bcols).setOnes();
   VERIFY_IS_EQUAL(m1, m2);
 
-  m2.block(i, j, brows, bcols).setRandom();
+  m2.block(i, j, brows, bcols) = random_for_arithmetic<DynMatrixType>(brows, bcols);
   rm2 = m2.block(i, j, brows, bcols);
   VERIFY_IS_EQUAL(m1, m2);
 
@@ -92,8 +94,9 @@
 
   Index size = m.size();
 
-  VectorType v1 = VectorType::Random(size), v2 = v1;
-  MatrixType mat1 = MatrixType::Random(size, size), mat2 = mat1, mat3 = MatrixType::Random(size, size);
+  VectorType v1 = random_for_arithmetic<VectorType>(size), v2 = v1;
+  MatrixType mat1 = random_for_arithmetic<MatrixType>(size, size), mat2 = mat1,
+             mat3 = random_for_arithmetic<MatrixType>(size, size);
 
   Index i = internal::random<Index>(0, size - 1);
   Index bsize = internal::random<Index>(1, size - i);
@@ -121,7 +124,7 @@
   v2.segment(i, bsize).setOnes();
   VERIFY_IS_EQUAL(v1, v2);
 
-  v2.segment(i, bsize).setRandom();
+  v2.segment(i, bsize) = random_for_arithmetic<DynMatrixType>(bsize);
   rv2 = v2.segment(i, bsize);
   VERIFY_IS_EQUAL(v1, v2);
 
@@ -218,6 +221,34 @@
   VERIFY(!(Ref<ConstPlainObjectType, Aligned>::Flags & LvalueBit));
 }
 
+void test_ref_alignment_matching() {
+  using PlainObject = Matrix<float, Dynamic, 1, DontAlign>;
+  using UnalignedMap = Map<PlainObject, Unaligned>;
+  using Aligned8Map = Map<PlainObject, Aligned8>;
+  using Aligned16Map = Map<PlainObject, Aligned16>;
+  using Aligned32Map = Map<PlainObject, Aligned32>;
+  using UnalignedRefTraits = internal::traits<Ref<PlainObject, Unaligned>>;
+  using Aligned16RefTraits = internal::traits<Ref<PlainObject, Aligned16>>;
+
+  static_assert(int(internal::traits<PlainObject>::Alignment) == int(Unaligned),
+                "the test plain object must not provide an alignment guarantee");
+  static_assert(UnalignedRefTraits::template match<UnalignedMap>::AlignmentMatch,
+                "an unaligned Ref must accept an unaligned source");
+  static_assert(!Aligned16RefTraits::template match<UnalignedMap>::AlignmentMatch,
+                "an aligned Ref must reject a source without an alignment guarantee");
+  static_assert(!Aligned16RefTraits::template match<Aligned8Map>::AlignmentMatch,
+                "the source alignment must satisfy the Ref alignment");
+  static_assert(Aligned16RefTraits::template match<Aligned16Map>::AlignmentMatch,
+                "a Ref must accept a source with matching alignment");
+  static_assert(Aligned16RefTraits::template match<Aligned32Map>::AlignmentMatch,
+                "a Ref must accept a source with stronger alignment");
+
+  alignas(16) float data[8] = {};
+  Aligned16Map map(data, 8);
+  Ref<PlainObject, Aligned16> ref(map);
+  VERIFY(ref.data() == data);
+}
+
 template <typename B>
 EIGEN_DONT_INLINE void call_ref_1(Ref<VectorXf> a, const B &b) {
   VERIFY_IS_EQUAL(a, b);
@@ -255,14 +286,12 @@
   RowVector3f c = RowVector3f::Random();
   const VectorXf &ac(a);
   VectorBlock<VectorXf> ab(a, 0, 3);
-  const VectorBlock<VectorXf> abc(a, 0, 3);
 
   VERIFY_EVALUATION_COUNT(call_ref_1(a, a), 0);
   VERIFY_EVALUATION_COUNT(call_ref_1(b, b.transpose()), 0);
   //   call_ref_1(ac,a<c);           // does not compile because ac is const
   VERIFY_EVALUATION_COUNT(call_ref_1(ab, ab), 0);
   VERIFY_EVALUATION_COUNT(call_ref_1(a.head(4), a.head(4)), 0);
-  VERIFY_EVALUATION_COUNT(call_ref_1(abc, abc), 0);
   VERIFY_EVALUATION_COUNT(call_ref_1(A.col(3), A.col(3)), 0);
   //   call_ref_1(A.row(3),A.row(3));    // does not compile because innerstride!=1
   VERIFY_EVALUATION_COUNT(call_ref_3(A.row(3), A.row(3).transpose()), 0);
@@ -272,7 +301,6 @@
   MatrixXf tmp = A * A.col(1);
   VERIFY_EVALUATION_COUNT(call_ref_2(A * A.col(1), tmp), 1);  // evaluated into a temp
   VERIFY_EVALUATION_COUNT(call_ref_2(ac.head(5), ac.head(5)), 0);
-  VERIFY_EVALUATION_COUNT(call_ref_2(ac, ac), 0);
   VERIFY_EVALUATION_COUNT(call_ref_2(a, a), 0);
   VERIFY_EVALUATION_COUNT(call_ref_2(ab, ab), 0);
   VERIFY_EVALUATION_COUNT(call_ref_2(a.head(4), a.head(4)), 0);
@@ -406,4 +434,5 @@
   CALL_SUBTEST_10(test_contiguous_ref_no_copy(Vector3d()));
   CALL_SUBTEST_10(test_contiguous_ref_no_copy(MatrixXd(9, 5)));
   CALL_SUBTEST_10(test_contiguous_ref_no_copy(Matrix3d()));
+  CALL_SUBTEST_10(test_ref_alignment_matching());
 }
diff --git a/test/reshape.cpp b/test/reshape.cpp
index 417d18a..eaf3e24 100644
--- a/test/reshape.cpp
+++ b/test/reshape.cpp
@@ -7,14 +7,16 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 
 using Eigen::placeholders::all;
 using Eigen::placeholders::last;
 
 template <typename T1, typename T2>
-std::enable_if_t<internal::is_same<T1, T2>::value, bool> is_same_eq(const T1& a, const T2& b) {
+std::enable_if_t<std::is_same<T1, T2>::value, bool> is_same_eq(const T1& a, const T2& b) {
   return (a.array() == b.array()).all();
 }
 
@@ -130,7 +132,7 @@
   check_auto_reshape4x4<RowMajor>(m);
   check_auto_reshape4x4<AutoOrder>(m);
   check_auto_reshape4x4<ColMajor>(m.transpose());
-  check_auto_reshape4x4<ColMajor>(m.transpose());
+  check_auto_reshape4x4<RowMajor>(m.transpose());
   check_auto_reshape4x4<AutoOrder>(m.transpose());
 
   check_direct_access_reshape4x4(m, fix<MatType::Flags & RowMajorBit>);
@@ -187,6 +189,186 @@
   }
 }
 
+// A direct-access reshape with unit inner stride is the nested expression's buffer with a new
+// shape, and an expression-sourced reshape whose enumeration order matches the nested evaluator's
+// forwards the nested linear accesses one-to-one. Both must preserve the nested evaluator's packet
+// access and alignment; without them, copies through Reshaped silently fall back to scalar
+// traversal.
+template <typename Scalar>
+void check_reshaped_evaluator_flags() {
+  // Storage orders are pinned so the checks keep their meaning under EIGEN_DEFAULT_TO_ROW_MAJOR.
+  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> Mat;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMat;
+  typedef Matrix<Scalar, Dynamic, 1, ColMajor> Vec;
+  enum { BasePacket = int(internal::evaluator<Mat>::Flags) & PacketAccessBit };
+
+  // Direct access with unit inner stride: packet access and alignment carry over.
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Mat, Dynamic, 1, ColMajor> >::Flags) & PacketAccessBit) ==
+               int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Mat, Dynamic, Dynamic, ColMajor> >::Flags) & PacketAccessBit) ==
+               int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Mat, 1, Dynamic, ColMajor> >::Flags) & PacketAccessBit) ==
+               int(BasePacket));
+  // Vector-shaped reshape of a row-major expression: the canonical storage order differs from the
+  // nested one, but the view is still contiguous.
+  STATIC_CHECK((int(internal::evaluator<Reshaped<RowMat, Dynamic, 1, RowMajor> >::Flags) & PacketAccessBit) ==
+               (int(internal::evaluator<RowMat>::Flags) & PacketAccessBit));
+  STATIC_CHECK(int(internal::evaluator<Reshaped<Mat, Dynamic, 1, ColMajor> >::Alignment) ==
+               int(internal::evaluator<Mat>::Alignment));
+
+  // Expression source with matching enumeration order: linear accesses and packets forward to the
+  // nested evaluator, so matrix-shaped reshapes gain linear access as well.
+  typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar, Scalar>, const Mat, const Mat> Sum;
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Sum, Dynamic, Dynamic, ColMajor> >::Flags) & PacketAccessBit) ==
+               int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Sum, Dynamic, Dynamic, ColMajor> >::Flags) & LinearAccessBit) ==
+               LinearAccessBit);
+  STATIC_CHECK(int(internal::evaluator<Reshaped<Sum, Dynamic, Dynamic, ColMajor> >::Alignment) ==
+               int(internal::evaluator<Sum>::Alignment));
+  // A vector source does not make a matrix-shaped result's storage order immaterial.
+  typedef CwiseBinaryOp<internal::scalar_sum_op<Scalar, Scalar>, const Vec, const Vec> VecSum;
+  STATIC_CHECK((int(internal::evaluator<Reshaped<VecSum, Dynamic, Dynamic, RowMajor>>::Flags) & PacketAccessBit) == 0);
+  STATIC_CHECK((int(internal::evaluator<Reshaped<VecSum, Dynamic, Dynamic, RowMajor>>::Flags) & LinearAccessBit) == 0);
+  STATIC_CHECK((int(internal::evaluator<Reshaped<VecSum, Dynamic, Dynamic, ColMajor>>::Flags) & PacketAccessBit) ==
+               int(BasePacket));
+  STATIC_CHECK((int(internal::evaluator<Reshaped<VecSum, 1, Dynamic, ColMajor>>::Flags) & PacketAccessBit) ==
+               int(BasePacket));
+  using RowVec = Matrix<Scalar, 1, Dynamic, RowMajor>;
+  STATIC_CHECK((int(internal::evaluator<Reshaped<RowVec, Dynamic, Dynamic, ColMajor>>::Flags) &
+                (LinearAccessBit | PacketAccessBit)) == 0);
+
+  // No packet access: cross-order reshape (no direct access),
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Mat, Dynamic, Dynamic, RowMajor> >::Flags) & PacketAccessBit) == 0);
+  // a cross-order expression source (a genuine element permutation),
+  STATIC_CHECK((int(internal::evaluator<Reshaped<Sum, Dynamic, Dynamic, RowMajor> >::Flags) & PacketAccessBit) == 0);
+  // and a non-unit inner stride.
+  typedef Map<Vec, 0, InnerStride<2> > StridedVec;
+  STATIC_CHECK((int(internal::evaluator<Reshaped<StridedVec, Dynamic, Dynamic, ColMajor> >::Flags) & PacketAccessBit) ==
+               0);
+}
+
+// Exercise the (possibly vectorized) assignment kernels with sizes that have partial-packet tails.
+template <typename Scalar>
+void reshape_copies(Index rows, Index cols) {
+  typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
+  typedef Matrix<Scalar, Dynamic, Dynamic, RowMajor> RowMat;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  Mat m = random_for_arithmetic<Mat>(rows, cols);
+
+  Vec v = m.reshaped();
+  for (Index k = 0; k < m.size(); ++k) VERIFY_IS_EQUAL(v(k), m(k % rows, k / rows));
+
+  Mat r = m.reshaped(cols, rows);
+  for (Index k = 0; k < m.size(); ++k) VERIFY_IS_EQUAL(r(k % cols, k / cols), m(k % rows, k / rows));
+
+  Mat d(rows, cols);
+  d.reshaped() = v;
+  VERIFY_IS_EQUAL(d, m);
+
+  Vec w = random_for_arithmetic<Vec>(m.size());
+  Vec expected = w + v;
+  w += m.reshaped();
+  VERIFY_IS_EQUAL(w, expected);
+
+  RowMat rm = random_for_arithmetic<RowMat>(rows, cols);
+  Vec rv = rm.template reshaped<AutoOrder>();
+  for (Index k = 0; k < rm.size(); ++k) VERIFY_IS_EQUAL(rv(k), rm(k / cols, k % cols));
+
+  // Expression-sourced reshapes forward the nested evaluator's linear accesses and packets.
+  Mat a = random_for_arithmetic<Mat>(rows, cols), b = random_for_arithmetic<Mat>(rows, cols);
+  Mat s = a + b;
+  Vec ev = (a + b).reshaped();
+  for (Index k = 0; k < s.size(); ++k) VERIFY_IS_EQUAL(ev(k), s(k % rows, k / rows));
+
+  Mat er = (a + b).reshaped(cols, rows);
+  for (Index k = 0; k < s.size(); ++k) VERIFY_IS_EQUAL(er(k % cols, k / cols), s(k % rows, k / rows));
+
+  VERIFY_IS_APPROX((a + b).reshaped().sum(), s.sum());
+
+  // Linear scalar accesses into a matrix-shaped row-major reshape must forward the index as-is.
+  RowMat ra = random_for_arithmetic<RowMat>(rows, cols), rb = random_for_arithmetic<RowMat>(rows, cols);
+  RowMat rer = (ra + rb).template reshaped<RowMajor>(cols, rows);
+  for (Index k = 0; k < rer.size(); ++k) {
+    VERIFY_IS_EQUAL(rer(k / rows, k % rows), ra(k / cols, k % cols) + rb(k / cols, k % cols));
+  }
+
+  // A reshaped lvalue expression without direct access exercises the forwarded packet writes.
+  Vec vr(m.size());
+  vr.reverse().reshaped(rows, cols) = m;
+  for (Index k = 0; k < m.size(); ++k) VERIFY_IS_EQUAL(vr(m.size() - 1 - k), m(k % rows, k / rows));
+
+  RowMat rvr(rows, cols);
+  RowMat rw = random_for_arithmetic<RowMat>(cols, rows);
+  rvr.reverse().template reshaped<RowMajor>(cols, rows) = rw;
+  for (Index k = 0; k < rw.size(); ++k) {
+    const Index reversed = rw.size() - 1 - k;
+    VERIFY_IS_EQUAL(rvr(reversed / cols, reversed % cols), rw(k / rows, k % rows));
+  }
+}
+
+template <int Order, typename VectorType, typename RowsType, typename ColsType>
+void reshape_vector_order(RowsType rows, ColsType cols) {
+  using Scalar = typename VectorType::Scalar;
+  using ColMatrix = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  using RowMatrix = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+  const Index nrows = internal::get_runtime_value(rows), ncols = internal::get_runtime_value(cols);
+  VectorType vector(nrows * ncols);
+  for (Index k = 0; k < vector.size(); ++k) vector(k) = Scalar(k + 1);
+  ColMatrix expected(nrows, ncols);
+  const bool rowOrder = Order == RowMajor || (Order == AutoOrder && VectorType::IsRowMajor);
+  for (Index j = 0; j < ncols; ++j)
+    for (Index i = 0; i < nrows; ++i) expected(i, j) = Scalar(1 + (rowOrder ? i * ncols + j : j * nrows + i));
+
+  const VectorType& source = vector;
+  const auto view = source.template reshaped<Order>(rows, cols);
+  VERIFY_IS_EQUAL(ColMatrix(view), expected);
+  VERIFY_IS_EQUAL(RowMatrix(view), expected);
+  VERIFY_IS_EQUAL(ColMatrix(view.transpose()), expected.transpose());
+  VERIFY_IS_EQUAL(RowMatrix(view.transpose()), expected.transpose());
+  if (Order != AutoOrder) {
+    VERIFY_IS_EQUAL(ColMatrix(source.transpose().template reshaped<Order>(rows, cols).transpose()),
+                    expected.transpose());
+    VERIFY_IS_EQUAL(RowMatrix(source.transpose().template reshaped<Order>(rows, cols).transpose()),
+                    expected.transpose());
+  }
+  VERIFY_IS_EQUAL(ColMatrix((source + source).template reshaped<Order>(rows, cols)), 2 * expected);
+  VERIFY_IS_EQUAL(RowMatrix((source + source).template reshaped<Order>(rows, cols)), 2 * expected);
+  for (Index j = 0; j < ncols; ++j)
+    for (Index i = 0; i < nrows; ++i) VERIFY_IS_EQUAL(view.coeff(i, j), expected(i, j));
+  if (Order == ColMajor) VERIFY_IS_EQUAL(ColMatrix(source.reshaped(rows, cols).transpose()), expected.transpose());
+
+  VectorType destination(vector.size());
+  destination.template reshaped<Order>(rows, cols) = expected;
+  VERIFY_IS_EQUAL(destination, vector);
+  const RowMatrix rowExpected = expected;
+  destination.setZero();
+  destination.template reshaped<Order>(rows, cols) = rowExpected;
+  VERIFY_IS_EQUAL(destination, vector);
+  destination.template reshaped<Order>(rows, cols) += rowExpected;
+  VERIFY_IS_EQUAL(destination, 2 * vector);
+  auto reversed = destination.reverse().template reshaped<Order>(rows, cols);
+  using AssignmentTraits =
+      internal::copy_using_evaluator_traits<internal::evaluator<decltype(reversed)>, internal::evaluator<RowMatrix>,
+                                            internal::assign_op<Scalar, Scalar>>;
+  VERIFY(!AssignmentTraits::Vectorized);
+  reversed = rowExpected;
+  VERIFY_IS_EQUAL(destination, vector.reverse());
+  reversed += rowExpected;
+  VERIFY_IS_EQUAL(destination, 2 * vector.reverse());
+  reversed -= rowExpected;
+  VERIFY_IS_EQUAL(destination, vector.reverse());
+}
+
+template <typename Scalar, int Order>
+void reshape_vector_orders() {
+  reshape_vector_order<Order, Matrix<Scalar, Dynamic, 1>>(3, 2);
+  reshape_vector_order<Order, Matrix<Scalar, 1, Dynamic>>(3, 2);
+  reshape_vector_order<Order, Matrix<Scalar, Dynamic, 1>>(5, 7);
+  reshape_vector_order<Order, Matrix<Scalar, 1, Dynamic>>(5, 7);
+  reshape_vector_order<Order, Matrix<Scalar, 6, 1>>(fix<3>, fix<2>);
+  reshape_vector_order<Order, Matrix<Scalar, 1, 6>>(fix<3>, fix<2>);
+}
+
 template <typename BlockType>
 void reshape_block(const BlockType& M) {
   auto dense = M.eval();
@@ -203,6 +385,37 @@
   }
 }
 
+void reshape_reversed_swap() {
+  constexpr int packet_size = internal::packet_traits<double>::size;
+  using VectorType = Matrix<double, 1, 3 * packet_size>;
+  using MatrixType = Matrix<double, 3, packet_size, packet_size == 1 ? ColMajor : RowMajor>;
+  VectorType destination;
+  MatrixType source;
+  for (Index i = 0; i < destination.size(); ++i) {
+    destination(i) = double(i + 1);
+    source.data()[i] = double(i + 101);
+  }
+  const VectorType original = destination;
+  const MatrixType originalSource = source;
+  auto view = destination.reverse().reshaped<RowMajor>(fix<3>, fix<packet_size>);
+  using SwapTraits =
+      internal::copy_using_evaluator_traits<internal::evaluator<decltype(view)>, internal::evaluator<MatrixType>,
+                                            internal::swap_assign_op<double>>;
+  using AssignTraits =
+      internal::copy_using_evaluator_traits<internal::evaluator<decltype(view)>, internal::evaluator<MatrixType>,
+                                            internal::assign_op<double, double>>;
+  VERIFY(!AssignTraits::Vectorized);
+  if (internal::packet_traits<double>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE) VERIFY(SwapTraits::Vectorized);
+  view.swap(source);
+  for (Index i = 0; i < destination.size(); ++i) {
+    VERIFY_IS_EQUAL(destination(i), originalSource.data()[destination.size() - 1 - i]);
+    VERIFY_IS_EQUAL(source.data()[i], original(destination.size() - 1 - i));
+  }
+  source.swap(view);
+  VERIFY_IS_EQUAL(destination, original);
+  VERIFY_IS_EQUAL(source, originalSource);
+}
+
 EIGEN_DECLARE_TEST(reshape) {
   typedef Matrix<int, Dynamic, Dynamic, RowMajor> RowMatrixXi;
   typedef Matrix<int, 4, 4, RowMajor> RowMatrix4i;
@@ -212,15 +425,37 @@
   RowMatrix4i rm4 = RowMatrix4i::Random(4, 4);
 
   // test dynamic-size matrix
-  CALL_SUBTEST(reshape4x4(mx));
+  CALL_SUBTEST_1(reshape4x4(mx));
   // test static-size matrix
-  CALL_SUBTEST(reshape4x4(m4));
-  // test dynamic-size const matrix
-  CALL_SUBTEST(reshape4x4(static_cast<const MatrixXi>(mx)));
-  // test static-size const matrix
-  CALL_SUBTEST(reshape4x4(static_cast<const Matrix4i>(m4)));
+  CALL_SUBTEST_2(reshape4x4(m4));
 
-  CALL_SUBTEST(reshape4x4(rmx));
-  CALL_SUBTEST(reshape4x4(rm4));
-  CALL_SUBTEST(reshape_block(rm4.col(1)));
+  CALL_SUBTEST_3(reshape4x4(rmx));
+  CALL_SUBTEST_4(reshape4x4(rm4));
+  CALL_SUBTEST_5(reshape_block(rm4.col(1)));
+
+  CALL_SUBTEST_6(check_reshaped_evaluator_flags<float>());
+  CALL_SUBTEST_6(check_reshaped_evaluator_flags<double>());
+  CALL_SUBTEST_6(check_reshaped_evaluator_flags<int>());
+
+  CALL_SUBTEST_8((reshape_vector_orders<float, ColMajor>()));
+  CALL_SUBTEST_8((reshape_vector_orders<float, RowMajor>()));
+  CALL_SUBTEST_8((reshape_vector_orders<double, ColMajor>()));
+  CALL_SUBTEST_8((reshape_vector_orders<double, RowMajor>()));
+  CALL_SUBTEST_8((reshape_vector_orders<double, AutoOrder>()));
+  CALL_SUBTEST_8((reshape_vector_orders<int, ColMajor>()));
+  CALL_SUBTEST_8((reshape_vector_orders<int, RowMajor>()));
+  CALL_SUBTEST_8(reshape_reversed_swap());
+
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_7(reshape_copies<float>(17, 13));
+    CALL_SUBTEST_7(reshape_copies<float>(1, 19));
+    CALL_SUBTEST_7(reshape_copies<double>(16, 8));
+    CALL_SUBTEST_7(reshape_copies<double>(5, 7));
+    CALL_SUBTEST_7(reshape_copies<int>(13, 11));
+  }
+
+  TEST_SET_BUT_UNUSED_VARIABLE(mx);
+  TEST_SET_BUT_UNUSED_VARIABLE(m4);
+  TEST_SET_BUT_UNUSED_VARIABLE(rmx);
+  TEST_SET_BUT_UNUSED_VARIABLE(rm4);
 }
diff --git a/test/resize.cpp b/test/resize.cpp
index 69db9b4..a91e092 100644
--- a/test/resize.cpp
+++ b/test/resize.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/rvalue_types.cpp b/test/rvalue_types.cpp
index 5db28b8..4ad58c8 100644
--- a/test/rvalue_types.cpp
+++ b/test/rvalue_types.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_RUNTIME_NO_MALLOC
 
diff --git a/test/safe_scaling.cpp b/test/safe_scaling.cpp
new file mode 100644
index 0000000..74eae29
--- /dev/null
+++ b/test/safe_scaling.cpp
@@ -0,0 +1,532 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+#define EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+#include "AnnoyingScalar.h"
+
+template <typename T>
+void check_power_of_two_scaling_factor() {
+  static_assert(internal::supports_power_of_two_scaling<T>::value, "power-of-two scaling must be enabled");
+  using Factors = internal::safe_scaling_factors<T>;
+
+  const auto check_factor = [](const T& value) {
+    const auto factors = internal::safe_scaling<T>::compute_floor_factors(value);
+    VERIFY(factors.scale >= (std::numeric_limits<T>::min)());
+    VERIFY(factors.invScale >= (std::numeric_limits<T>::min)());
+    VERIFY_IS_EQUAL(factors.scale * factors.invScale, T(1));
+    return factors;
+  };
+
+  const auto check_round_trip = [&](const T& value) {
+    const auto factors = check_factor(value);
+    Matrix<T, 1, 1> input;
+    input(0) = value;
+    Matrix<T, 1, 1> scaled;
+    const auto scaleToFactors = internal::safe_scaling<T>::scale_to(scaled, input, value);
+    VERIFY_IS_EQUAL(scaleToFactors.scale, factors.scale);
+    VERIFY_IS_EQUAL(scaleToFactors.invScale, factors.invScale);
+    Matrix<T, 1, 1> scaledInPlace;
+    scaledInPlace(0) = value;
+    internal::safe_scaling<T>::scale_in_place(scaledInPlace, value, factors);
+    VERIFY_IS_EQUAL(scaledInPlace, scaled);
+    scaledInPlace(0) = value;
+    const auto inPlaceFactors = internal::safe_scaling<T>::scale_in_place(scaledInPlace, value);
+    VERIFY_IS_EQUAL(inPlaceFactors.scale, factors.scale);
+    VERIFY_IS_EQUAL(inPlaceFactors.invScale, factors.invScale);
+    VERIFY_IS_EQUAL(scaledInPlace, scaled);
+
+    T restored;
+    internal::safe_scaling<T>::unscale_to(restored, scaled(0), factors);
+    VERIFY_IS_EQUAL(restored, value);
+    Matrix<T, 1, 1> restoredMatrix;
+    internal::safe_scaling<T>::unscale_to(restoredMatrix, scaled, value, factors);
+    VERIFY_IS_EQUAL(restoredMatrix, input);
+    internal::safe_scaling<T>::unscale_in_place(scaled, factors);
+    VERIFY_IS_EQUAL(scaled(0), value);
+  };
+
+  const auto denormFactors = check_factor(std::numeric_limits<T>::denorm_min());
+  VERIFY_IS_EQUAL(denormFactors.scale, (std::numeric_limits<T>::min)());
+  Factors normalReciprocalFactors;
+  VERIFY(internal::safe_scaling<T>::try_compute_ceiling_factors_with_normal_reciprocal(
+      std::numeric_limits<T>::denorm_min(), (std::numeric_limits<T>::min)(), normalReciprocalFactors));
+  VERIFY_IS_EQUAL(normalReciprocalFactors.scale, denormFactors.scale);
+  VERIFY_IS_EQUAL(normalReciprocalFactors.invScale, denormFactors.invScale);
+
+  // bfloat16 arithmetic widens to float, whose subnormal inputs may be flushed before scaling can recover them.
+  if (!std::is_same<T, bfloat16>::value || !ScopedFlushToZero::hardwareFlushesSubnormalInputs()) {
+    using InputScalar = std::conditional_t<std::is_floating_point<T>::value, T, float>;
+    volatile InputScalar denormInput = static_cast<InputScalar>(std::numeric_limits<T>::denorm_min());
+    const T denormMin = static_cast<T>(denormInput);
+    Matrix<T, 1, 1> denormInputMatrix;
+    denormInputMatrix(0) = denormMin;
+    Matrix<T, 1, 1> scaledDenorm;
+    const auto factors = internal::safe_scaling<T>::scale_to(scaledDenorm, denormInputMatrix, denormMin);
+    Matrix<T, 1, 1> scaledDenormInPlace;
+    scaledDenormInPlace(0) = denormMin;
+    internal::safe_scaling<T>::scale_in_place(scaledDenormInPlace, denormMin, factors);
+    VERIFY_IS_EQUAL(scaledDenormInPlace, scaledDenorm);
+    VERIFY(scaledDenorm(0) > T(0));
+  }
+
+  check_round_trip((std::numeric_limits<T>::min)());
+  check_round_trip(T(0.75));
+  check_round_trip(T(1.5));
+  check_round_trip(T(3));
+  check_round_trip((std::numeric_limits<T>::max)());
+
+  const auto floorFactors = internal::safe_scaling<T>::compute_floor_factors(T(1.5));
+  const auto ceilingFactors = internal::safe_scaling<T>::compute_ceiling_factors_with_normal_reciprocal(T(1.5));
+  VERIFY_IS_EQUAL(floorFactors.scale, T(1));
+  VERIFY_IS_EQUAL(ceilingFactors.scale, T(2));
+
+  const T highest = (std::numeric_limits<T>::max)();
+  const auto highestCeilingFactors = internal::safe_scaling<T>::compute_ceiling_factors_with_normal_reciprocal(highest);
+  VERIFY_IS_EQUAL(highestCeilingFactors.scale, check_factor(highest).scale);
+  VERIFY_IS_EQUAL(highestCeilingFactors.scale * highestCeilingFactors.invScale, T(1));
+  const T scaledHighest = highest * highestCeilingFactors.invScale;
+  VERIFY(scaledHighest >= T(1));
+  if (std::numeric_limits<T>::max_exponent + std::numeric_limits<T>::min_exponent <= 3) {
+    VERIFY(scaledHighest < T(4));
+  }
+}
+
+template <typename T>
+void check_safe_scaling_special_values() {
+  using Scaling = internal::safe_scaling<T>;
+  using Factors = internal::safe_scaling_factors<T>;
+
+  const Factors identity;
+  VERIFY_IS_EQUAL(identity.scale, T(1));
+  VERIFY_IS_EQUAL(identity.invScale, T(1));
+
+  Matrix<T, 1, 1> zero = Matrix<T, 1, 1>::Zero();
+  Matrix<T, 1, 1> scaledZero;
+  const auto zeroFactors = Scaling::scale_to(scaledZero, zero, T(0));
+  VERIFY_IS_EQUAL(zeroFactors.scale, T(1));
+  VERIFY_IS_EQUAL(zeroFactors.invScale, T(1));
+  VERIFY_IS_EQUAL(scaledZero(0), T(0));
+
+  for (const T special : {std::numeric_limits<T>::infinity(), std::numeric_limits<T>::quiet_NaN()}) {
+    Matrix<T, 2, 1> input;
+    input << special, T(2);
+    Matrix<T, 2, 1> scaled;
+    const auto factors = Scaling::scale_to(scaled, input, special);
+    VERIFY_IS_EQUAL(factors.scale, T(1));
+    VERIFY_IS_EQUAL(factors.invScale, T(1));
+    VERIFY_IS_EQUAL(scaled(1), T(2));
+    if ((numext::isnan)(special)) {
+      VERIFY((numext::isnan)(scaled(0)));
+    } else {
+      VERIFY((numext::isinf)(scaled(0)));
+    }
+  }
+}
+
+void check_safe_scaling_special_value_frontends() {
+  using Scaling = internal::safe_scaling<float>;
+  using Factors = internal::safe_scaling_factors<float>;
+
+  for (const float special : {std::numeric_limits<float>::infinity(), std::numeric_limits<float>::quiet_NaN()}) {
+    Vector2f input(special, 2.0f);
+    Vector2f scaledTo;
+    const auto scaleToFactors = Scaling::scale_to(scaledTo, input, special);
+    VERIFY_IS_EQUAL(scaleToFactors.scale, 1.0f);
+    VERIFY_IS_EQUAL(scaleToFactors.invScale, 1.0f);
+
+    Vector2f scaledExpression;
+    const Factors expressionFactors =
+        Scaling::with_scaled(input, special, [&](const auto& expression) { scaledExpression = expression; });
+    VERIFY_IS_EQUAL(expressionFactors.scale, 1.0f);
+    VERIFY_IS_EQUAL(expressionFactors.invScale, 1.0f);
+    VERIFY_IS_EQUAL(scaledTo(1), 2.0f);
+    VERIFY_IS_EQUAL(scaledExpression(1), 2.0f);
+    if ((numext::isnan)(special)) {
+      VERIFY((numext::isnan)(scaledTo(0)));
+      VERIFY((numext::isnan)(scaledExpression(0)));
+    } else {
+      VERIFY((numext::isinf)(scaledTo(0)));
+      VERIFY((numext::isinf)(scaledExpression(0)));
+    }
+  }
+}
+
+void check_arithmetic_safe_scaling_fallback() {
+  using Scaling = internal::safe_scaling<double, false>;
+  using Factors = internal::safe_scaling_factors<double>;
+
+  Matrix<double, 2, 1> input;
+  input << 3.0, 6.0;
+  Matrix<double, 2, 1> scaled;
+  const auto factors = Scaling::scale_to(scaled, input, 3.0);
+  VERIFY_IS_EQUAL(factors.scale, 3.0);
+  VERIFY_IS_EQUAL(factors.invScale, 1.0);
+  VERIFY_IS_EQUAL(scaled(0), 1.0);
+  VERIFY_IS_EQUAL(scaled(1), 2.0);
+  Matrix<double, 2, 1> restored;
+  Scaling::unscale_to(restored, scaled, 3.0, factors);
+  VERIFY_IS_EQUAL(restored, input);
+  Scaling::unscale_in_place(scaled, factors);
+  VERIFY_IS_EQUAL(scaled, input);
+
+  const auto check_extreme_unscale = [](const double value) {
+    const Factors extremeFactors = Scaling::compute_floor_factors(value);
+    double restored;
+    Scaling::unscale_to(restored, 1.0, extremeFactors);
+    VERIFY_IS_EQUAL(restored, value);
+    restored = 1.0;
+    Scaling::unscale_in_place(restored, extremeFactors);
+    VERIFY_IS_EQUAL(restored, value);
+  };
+  check_extreme_unscale((std::numeric_limits<double>::max)());
+  volatile double denormMinInput = std::numeric_limits<double>::denorm_min();
+  const double denormMin = denormMinInput;
+  if (denormMin > 0.0) check_extreme_unscale(denormMin);
+
+  Factors normalReciprocalFactors;
+  const double normalMin = (std::numeric_limits<double>::min)();
+  VERIFY(Scaling::try_compute_ceiling_factors_with_normal_reciprocal(3.0, normalMin, normalReciprocalFactors));
+  VERIFY_IS_EQUAL(normalReciprocalFactors.scale, 3.0);
+  VERIFY_IS_EQUAL(normalReciprocalFactors.invScale, 1.0 / 3.0);
+  VERIFY(!Scaling::try_compute_ceiling_factors_with_normal_reciprocal(std::numeric_limits<double>::denorm_min(),
+                                                                      normalMin, normalReciprocalFactors));
+  VERIFY(!Scaling::try_compute_ceiling_factors_with_normal_reciprocal((std::numeric_limits<double>::max)(), normalMin,
+                                                                      normalReciprocalFactors));
+}
+
+void check_custom_scalar_scaling_exceptions() {
+  using Scalar = AnnoyingScalar;
+  using Scaling = internal::safe_scaling<Scalar>;
+  static_assert(!internal::supports_power_of_two_scaling<Scalar>::value, "exercise arithmetic scaling");
+  volatile float denormInput = std::numeric_limits<float>::denorm_min();
+  const float denorm = denormInput;
+  const float twiceDenorm = denorm + denorm;
+  if (!(denorm > 0.0f && twiceDenorm > 0.0f)) return;  // No custom-scalar subnormal recovery is promised.
+
+  Matrix<Scalar, 2, 1> input;
+  input << Scalar(denorm), Scalar(twiceDenorm);
+  Matrix<Scalar, 2, 1> scaled;
+  std::fenv_t savedEnvironment;
+  if (std::feholdexcept(&savedEnvironment) != 0) return;
+  const auto factors = Scaling::scale_to(scaled, input, Scalar(twiceDenorm));
+  const int overflow = std::fetestexcept(FE_OVERFLOW);
+  std::fesetenv(&savedEnvironment);
+  VERIFY_IS_EQUAL(overflow, 0);
+  VERIFY_IS_EQUAL(scaled(0), Scalar(0.5));
+  VERIFY_IS_EQUAL(scaled(1), Scalar(1));
+  Matrix<Scalar, 2, 1> restored;
+  Scaling::unscale_to(restored, scaled, Scalar(twiceDenorm), factors);
+  VERIFY_IS_EQUAL(restored, input);
+  Scaling::unscale_in_place(scaled, factors);
+  VERIFY_IS_EQUAL(scaled, input);
+}
+
+template <typename Scalar>
+void check_scale_binary_by_power_of_two() {
+  using Binary = internal::binary_floating_point_traits<Scalar>;
+  using Bits = typename Binary::Bits;
+  constexpr int kMinFactorExponent = 1 - std::numeric_limits<Scalar>::min_exponent - Binary::kFractionBits;
+  constexpr int kMaxFactorExponent = 1 - std::numeric_limits<Scalar>::min_exponent;
+  const Bits magnitudes[] = {Bits(0),
+                             Bits(1),
+                             Bits(3),
+                             Binary::kFractionMask,
+                             Binary::kExponentUnit,
+                             Binary::kExponentUnit + (Binary::kExponentUnit >> 1)};
+
+  ScopedFlushToZero flushToZero;
+  // Cover the entire factor range selected by tiny-input recovery. Form the reference from integer significands,
+  // not subnormal floating-point inputs, so it remains valid under FTZ/DAZ.
+  for (int exponent = kMinFactorExponent; exponent <= kMaxFactorExponent; ++exponent) {
+    const Scalar factor = numext::ldexp(Scalar(1), exponent);
+    for (Bits magnitude : magnitudes) {
+      const Scalar expected = numext::ldexp(Scalar(magnitude), std::numeric_limits<Scalar>::min_exponent -
+                                                                   std::numeric_limits<Scalar>::digits + exponent);
+      for (Bits sign : {Bits(0), Bits(Binary::kSignBit)}) {
+        const Scalar value = numext::bit_cast<Scalar>(sign | magnitude);
+        const Scalar actual = internal::scale_binary_by_power_of_two(value, factor);
+        VERIFY_IS_EQUAL(Binary::bits(actual), sign | Binary::bits(expected));
+      }
+    }
+  }
+}
+
+// Rounds a subnormal result exactly where hardware arithmetic may flush it: the exact product m * 2^-k denorm_min is
+// normal in double, and its nearest integer, ties to even, is the expected magnitude's bit pattern (a carry into the
+// exponent field encodes the smallest normal).
+template <typename Scalar>
+void check_scale_binary_by_power_of_two_rounding() {
+  using Binary = internal::binary_floating_point_traits<Scalar>;
+  using Bits = typename Binary::Bits;
+  // Leading-bit significands in [kExponentUnit, 2 * kExponentUnit): ties and their neighbours at small shifts, and an
+  // all-ones tail that carries into the smallest normal.
+  const Bits significands[] = {Binary::kExponentUnit,
+                               Binary::kExponentUnit | Bits(1),
+                               Binary::kExponentUnit | Bits(2),
+                               Binary::kExponentUnit | Bits(3),
+                               Binary::kExponentUnit | Bits(5),
+                               Binary::kExponentUnit + (Binary::kExponentUnit >> 1),
+                               (Binary::kExponentUnit << 1) - Bits(1)};
+  // A biased input exponent e scales m by 2^(e - 1); the factor 2^-(e - 1 + k) cancels it and shifts by k.
+  const int exponentFields[] = {1, 2, Binary::kExponentBias - Binary::kFractionBits - 3};
+
+  ScopedFlushToZero flushToZero;
+  for (int field : exponentFields) {
+    for (int k = 0; k <= Binary::kFractionBits + 3; ++k) {
+      const Scalar factor = numext::ldexp(Scalar(1), -(field - 1 + k));
+      for (Bits m : significands) {
+        const Bits expected = Bits(std::nearbyint(std::ldexp(double(m), -k)));
+        for (Bits sign : {Bits(0), Bits(Binary::kSignBit)}) {
+          const Scalar value =
+              numext::bit_cast<Scalar>(sign | (Bits(field) << Binary::kFractionBits) | (m & Binary::kFractionMask));
+          VERIFY_IS_EQUAL(Binary::bits(internal::scale_binary_by_power_of_two(value, factor)), sign | expected);
+        }
+      }
+    }
+  }
+  // Subnormal inputs normalize before they round.
+  for (Bits magnitude : {Bits(1), Bits(3), Binary::kExponentUnit >> 1, Binary::kFractionMask}) {
+    for (int k = 1; k <= Binary::kFractionBits + 2; ++k) {
+      const Bits expected = Bits(std::nearbyint(std::ldexp(double(magnitude), -k)));
+      for (Bits sign : {Bits(0), Bits(Binary::kSignBit)}) {
+        const Scalar actual = internal::scale_binary_by_power_of_two(numext::bit_cast<Scalar>(sign | magnitude),
+                                                                     numext::ldexp(Scalar(1), -k));
+        VERIFY_IS_EQUAL(Binary::bits(actual), sign | expected);
+      }
+    }
+  }
+}
+
+// Under DAZ a comparison reads a subnormal as zero, so compare representations.
+template <typename RealScalar>
+bool same_bits(const RealScalar& a, const RealScalar& b) {
+  using Binary = internal::binary_floating_point_traits<RealScalar>;
+  return Binary::bits(a) == Binary::bits(b);
+}
+
+template <typename RealScalar>
+bool same_bits(const std::complex<RealScalar>& a, const std::complex<RealScalar>& b) {
+  return same_bits(a.real(), b.real()) && same_bits(a.imag(), b.imag());
+}
+
+template <typename Scalar>
+struct scaling_test_value {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  static Scalar run(RealScalar real, RealScalar) { return real; }
+};
+
+template <typename RealScalar>
+struct scaling_test_value<std::complex<RealScalar>> {
+  static std::complex<RealScalar> run(RealScalar real, RealScalar imag) { return std::complex<RealScalar>(real, imag); }
+};
+
+template <typename Scalar>
+void check_arithmetic_scaling_expression() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Scaling = internal::safe_scaling<RealScalar, false>;
+  using Vector2 = Matrix<Scalar, 2, 1>;
+  using Value = scaling_test_value<Scalar>;
+
+  // Lazy scaling and its adjoint must retain the division policy even below the binary-recovery threshold.
+  for (const RealScalar maxCoeff :
+       {RealScalar(3), numext::ldexp(RealScalar(1.5), std::numeric_limits<RealScalar>::min_exponent + 7)}) {
+    Vector2 input;
+    input << Value::run(maxCoeff, RealScalar(0)), Value::run(maxCoeff / RealScalar(2), -maxCoeff / RealScalar(4));
+    Vector2 expected;
+    expected << Value::run(RealScalar(1), RealScalar(0)), Value::run(RealScalar(0.5), RealScalar(-0.25));
+    Vector2 materialized;
+    const auto factors = Scaling::scale_to(materialized, input, maxCoeff);
+    Vector2 lazy;
+    Matrix<Scalar, 1, 2> adjoint;
+    const auto expressionFactors = Scaling::with_scaled(input, maxCoeff, [&](const auto& expression) {
+      lazy = expression;
+      adjoint = expression.adjoint();
+    });
+    VERIFY_IS_EQUAL(materialized, expected);
+    VERIFY_IS_EQUAL(lazy, expected);
+    VERIFY_IS_EQUAL(adjoint, expected.adjoint());
+    VERIFY_IS_EQUAL(expressionFactors.scale, factors.scale);
+    VERIFY_IS_EQUAL(expressionFactors.invScale, factors.invScale);
+    Vector2 inPlace = input;
+    const auto inPlaceFactors = Scaling::scale_in_place(inPlace, maxCoeff);
+    VERIFY_IS_EQUAL(inPlace, expected);
+    VERIFY_IS_EQUAL(inPlaceFactors.scale, factors.scale);
+    VERIFY_IS_EQUAL(inPlaceFactors.invScale, factors.invScale);
+  }
+}
+
+template <typename Scalar>
+void check_subnormal_preserving_scaling() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Binary = internal::binary_floating_point_traits<RealScalar>;
+  using Bits = typename Binary::Bits;
+  const RealScalar maxCoeff = numext::ldexp((std::numeric_limits<RealScalar>::min)(), 8);
+  // Arithmetic or narrowing conversions could flush these inputs before they reach the scaling helper.
+  const RealScalar subnormalMaxCoeff = numext::bit_cast<RealScalar>(Bits(64));
+  const auto factors = internal::safe_scaling<RealScalar>::compute_floor_factors(maxCoeff);
+
+  Matrix<Scalar, 2, 1> input;
+  input(0) = scaling_test_value<Scalar>::run(maxCoeff, -maxCoeff);
+  input(1) = scaling_test_value<Scalar>::run(numext::bit_cast<RealScalar>(Binary::kExponentUnit >> 1),
+                                             numext::bit_cast<RealScalar>(Binary::kExponentUnit >> 2));
+  Matrix<Scalar, 1, 1> subnormalInput;
+  subnormalInput(0) = scaling_test_value<Scalar>::run(subnormalMaxCoeff, RealScalar(0));
+  ScopedFlushToZero flushToZero;
+  Matrix<Scalar, 2, 1> scaled;
+  internal::safe_scaling<RealScalar>::scale_to(scaled, input, maxCoeff, factors);
+
+  Matrix<Scalar, 2, 1> scaledExpression;
+  const auto expressionFactors = internal::safe_scaling<RealScalar>::with_scaled(
+      input, maxCoeff, [&](const auto& expression) { scaledExpression = expression; });
+
+  VERIFY_IS_EQUAL(scaled(0), scaling_test_value<Scalar>::run(RealScalar(1), RealScalar(-1)));
+  VERIFY_IS_EQUAL(scaled(1),
+                  scaling_test_value<Scalar>::run(RealScalar(1) / RealScalar(512), RealScalar(1) / RealScalar(1024)));
+  VERIFY_IS_EQUAL(expressionFactors.scale, factors.scale);
+  VERIFY_IS_EQUAL(expressionFactors.invScale, factors.invScale);
+  VERIFY_IS_EQUAL(scaledExpression, scaled);
+
+  Matrix<Scalar, 2, 1> scaledInPlace = input;
+  const auto inPlaceFactors = internal::safe_scaling<RealScalar>::scale_in_place(scaledInPlace, maxCoeff);
+  VERIFY_IS_EQUAL(inPlaceFactors.scale, factors.scale);
+  VERIFY_IS_EQUAL(inPlaceFactors.invScale, factors.invScale);
+  VERIFY_IS_EQUAL(scaledInPlace, scaled);
+
+  Matrix<Scalar, 1, 1> scaledSubnormal;
+  const auto subnormalFactors =
+      internal::safe_scaling<RealScalar>::scale_to(scaledSubnormal, subnormalInput, subnormalMaxCoeff);
+  VERIFY(subnormalFactors.scale != RealScalar(1) || subnormalFactors.invScale != RealScalar(1));
+  VERIFY(numext::abs(scaledSubnormal(0)) > RealScalar(0));
+
+  // Unscaling restores the subnormal components exactly, still under FTZ.
+  Matrix<Scalar, 2, 1> restored;
+  internal::safe_scaling<RealScalar>::unscale_to(restored, scaled, maxCoeff, factors);
+  for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(restored(i), input(i)));
+  internal::safe_scaling<RealScalar>::unscale_in_place(scaled, maxCoeff, factors);
+  internal::safe_scaling<RealScalar>::unscale_in_place(scaledSubnormal, subnormalMaxCoeff, subnormalFactors);
+  for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(scaled(i), input(i)));
+  VERIFY(same_bits(scaledSubnormal(0), subnormalInput(0)));
+
+  // A NaN, infinite or zero maxCoeff selects identity factors, and unscaling leaves the coefficients alone.
+  for (const RealScalar special :
+       {std::numeric_limits<RealScalar>::quiet_NaN(), std::numeric_limits<RealScalar>::infinity(), RealScalar(0)}) {
+    Matrix<Scalar, 2, 1> unchanged;
+    const auto specialFactors = internal::safe_scaling<RealScalar>::scale_to(unchanged, input, special);
+    internal::safe_scaling<RealScalar>::unscale_in_place(unchanged, special, specialFactors);
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(unchanged(i), input(i)));
+    const auto inPlaceSpecialFactors = internal::safe_scaling<RealScalar>::scale_in_place(unchanged, special);
+    VERIFY_IS_EQUAL(inPlaceSpecialFactors.scale, RealScalar(1));
+    VERIFY_IS_EQUAL(inPlaceSpecialFactors.invScale, RealScalar(1));
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(unchanged(i), input(i)));
+  }
+}
+
+// Unscaling rounds through integer significands exactly when 0 < maxCoeff < min / eps. With floor factors, eps / 2
+// unscales to min / 2 at the threshold and to min / 4 one ulp below it; FTZ flushes only the former.
+template <typename Scalar>
+void check_unscale_recovery_threshold() {
+  using Binary = internal::binary_floating_point_traits<Scalar>;
+  using Scaling = internal::safe_scaling<Scalar>;
+  const Scalar threshold = (std::numeric_limits<Scalar>::min)() / NumTraits<Scalar>::epsilon();
+  const Scalar belowThreshold = numext::nextafter(threshold, Scalar(0));
+  // Read through volatile so the products are formed at run time, under FTZ.
+  volatile Scalar halfEpsilon = NumTraits<Scalar>::epsilon() / Scalar(2);
+  Matrix<Scalar, 1, 1> atThreshold, below;
+  atThreshold(0) = halfEpsilon;
+  below(0) = halfEpsilon;
+
+  ScopedFlushToZero flushToZero;
+  Scaling::unscale_in_place(below, belowThreshold, Scaling::compute_floor_factors(belowThreshold));
+  VERIFY(same_bits(below(0), numext::bit_cast<Scalar>(Binary::kExponentUnit >> 2)));
+  Scaling::unscale_in_place(atThreshold, threshold, Scaling::compute_floor_factors(threshold));
+  if (flushToZero.isSupported()) VERIFY(same_bits(atThreshold(0), Scalar(0)));
+}
+
+template <typename Scalar>
+void check_identity_scaling() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Binary = internal::binary_floating_point_traits<RealScalar>;
+  using Scaling = internal::safe_scaling<RealScalar>;
+  Matrix<Scalar, 2, 1> input;
+  input(0) = scaling_test_value<Scalar>::run(RealScalar(1), RealScalar(-1));
+  input(1) = scaling_test_value<Scalar>::run(numext::bit_cast<RealScalar>(Binary::kExponentUnit >> 1),
+                                             numext::bit_cast<RealScalar>(+Binary::kSignBit));
+  const ScopedFlushToZero flush;
+  for (RealScalar maxCoeff : {RealScalar(0), RealScalar(1), RealScalar(1.5), NumTraits<RealScalar>::infinity(),
+                              NumTraits<RealScalar>::quiet_NaN()}) {
+    // Keep the factor selection at run time, where a compiler can merge a copy with multiplication by one.
+    volatile RealScalar runtimeMaxCoeff = maxCoeff;
+    Matrix<Scalar, 2, 1> scaled, restored;
+    const auto factors = Scaling::scale_to(scaled, input, RealScalar(runtimeMaxCoeff));
+    VERIFY_IS_EQUAL(factors.scale, RealScalar(1));
+    VERIFY_IS_EQUAL(factors.invScale, RealScalar(1));
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(scaled(i), input(i)));
+    Scaling::unscale_to(restored, input, factors);
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(restored(i), input(i)));
+    Scaling::with_scaled(input, RealScalar(runtimeMaxCoeff), [&](const auto& expression) { scaled = expression; });
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(scaled(i), input(i)));
+    Scaling::scale_in_place(scaled, RealScalar(runtimeMaxCoeff));
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(scaled(i), input(i)));
+    Scaling::unscale_in_place(scaled, factors);
+    for (Index i = 0; i < input.size(); ++i) VERIFY(same_bits(scaled(i), input(i)));
+  }
+}
+
+// A reduction that flushes subnormal inputs returns zero; the rescan reads the largest real or imaginary magnitude from
+// the representation instead, and leaves a nonzero maximum alone.
+template <typename Scalar>
+void check_recover_flushed_max_coeff() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Binary = internal::binary_floating_point_traits<RealScalar>;
+  using Bits = typename Binary::Bits;
+  using Scaling = internal::safe_scaling<RealScalar>;
+  using Value = scaling_test_value<Scalar>;
+  const RealScalar small = numext::bit_cast<RealScalar>(Bits(3));
+  const RealScalar large = numext::bit_cast<RealScalar>(Bits(Binary::kFractionMask));
+  Matrix<Scalar, 2, 2> m;
+  m << Value::run(small, RealScalar(0)), Value::run(-small, -large), Value::run(RealScalar(0), small),
+      Value::run(-small, RealScalar(0));
+  const RealScalar expected = NumTraits<Scalar>::IsComplex ? large : small;
+  VERIFY(same_bits(Scaling::recover_flushed_max_coeff(m, RealScalar(0)), expected));
+  VERIFY(same_bits(Scaling::recover_flushed_max_coeff(m, RealScalar(1)), RealScalar(1)));
+  VERIFY(same_bits(Scaling::recover_flushed_max_coeff(Matrix<Scalar, 2, 2>::Zero(), RealScalar(0)), RealScalar(0)));
+}
+
+EIGEN_DECLARE_TEST(safe_scaling) {
+  CALL_SUBTEST(check_identity_scaling<float>());
+  CALL_SUBTEST(check_identity_scaling<double>());
+  CALL_SUBTEST(check_identity_scaling<std::complex<float>>());
+  CALL_SUBTEST(check_identity_scaling<std::complex<double>>());
+  CALL_SUBTEST(check_power_of_two_scaling_factor<half>());
+  CALL_SUBTEST(check_power_of_two_scaling_factor<bfloat16>());
+  CALL_SUBTEST(check_power_of_two_scaling_factor<float>());
+  CALL_SUBTEST(check_power_of_two_scaling_factor<double>());
+  CALL_SUBTEST(check_power_of_two_scaling_factor<long double>());
+  CALL_SUBTEST(check_safe_scaling_special_values<half>());
+  CALL_SUBTEST(check_safe_scaling_special_values<bfloat16>());
+  CALL_SUBTEST(check_safe_scaling_special_values<float>());
+  CALL_SUBTEST(check_safe_scaling_special_values<double>());
+  CALL_SUBTEST(check_safe_scaling_special_value_frontends());
+  CALL_SUBTEST(check_arithmetic_safe_scaling_fallback());
+  CALL_SUBTEST(check_custom_scalar_scaling_exceptions());
+  CALL_SUBTEST(check_arithmetic_scaling_expression<float>());
+  CALL_SUBTEST(check_arithmetic_scaling_expression<double>());
+  CALL_SUBTEST(check_arithmetic_scaling_expression<std::complex<float>>());
+  CALL_SUBTEST(check_arithmetic_scaling_expression<std::complex<double>>());
+  CALL_SUBTEST(check_scale_binary_by_power_of_two<float>());
+  CALL_SUBTEST(check_scale_binary_by_power_of_two<double>());
+  CALL_SUBTEST(check_scale_binary_by_power_of_two_rounding<float>());
+  CALL_SUBTEST(check_scale_binary_by_power_of_two_rounding<double>());
+  CALL_SUBTEST(check_subnormal_preserving_scaling<float>());
+  CALL_SUBTEST(check_subnormal_preserving_scaling<std::complex<float>>());
+  CALL_SUBTEST(check_subnormal_preserving_scaling<double>());
+  CALL_SUBTEST(check_subnormal_preserving_scaling<std::complex<double>>());
+  CALL_SUBTEST(check_unscale_recovery_threshold<float>());
+  CALL_SUBTEST(check_unscale_recovery_threshold<double>());
+  CALL_SUBTEST(check_recover_flushed_max_coeff<float>());
+  CALL_SUBTEST(check_recover_flushed_max_coeff<std::complex<float>>());
+  CALL_SUBTEST(check_recover_flushed_max_coeff<double>());
+  CALL_SUBTEST(check_recover_flushed_max_coeff<std::complex<double>>());
+}
diff --git a/test/scaled_permutation.cpp b/test/scaled_permutation.cpp
new file mode 100644
index 0000000..eab4ac0
--- /dev/null
+++ b/test/scaled_permutation.cpp
@@ -0,0 +1,249 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define TEST_ENABLE_TEMPORARY_TRACKING
+
+#include "main.h"
+#include <Eigen/Core>
+#include "NonCommutativeScalar.h"
+
+// The scaled permutation P * D of a permutation and a diagonal matrix. Every closed-form operation below moves
+// or multiplies single coefficients, so the comparisons with the dense references are exact.
+template <typename Scalar, int Size>
+void scaled_permutation(Index size) {
+  using PermutationType = PermutationMatrix<Size>;
+  using DiagonalType = DiagonalMatrix<Scalar, Size>;
+  using ScaledType = ScaledPermutationMatrix<Scalar, Size>;
+  using MatrixType = Matrix<Scalar, Size, Size>;
+  using VectorType = Matrix<Scalar, Size, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+
+  Matrix<int, Size, 1> indices, indices2;
+  randomPermutationVector(indices, size);
+  randomPermutationVector(indices2, size);
+  const PermutationType perm(indices), perm2(indices2);
+  const DiagonalType diag(VectorType::Random(size)), diag2(VectorType::Random(size));
+  const MatrixType permDense = perm.toDenseMatrix().template cast<Scalar>();
+  const MatrixType perm2Dense = perm2.toDenseMatrix().template cast<Scalar>();
+  const MatrixType inverseDense = perm.inverse().toDenseMatrix().template cast<Scalar>();
+  const MatrixType diagDense = diag.toDenseMatrix();
+  const MatrixType diag2Dense = diag2.toDenseMatrix();
+  const Scalar alpha = internal::random<Scalar>();
+
+  // P * D and the three sibling products are scaled permutations, not dense expressions.
+  STATIC_CHECK((internal::is_same<decltype(perm * diag), ScaledType>::value));
+  STATIC_CHECK((internal::is_same<decltype(diag * perm.inverse()), ScaledType>::value));
+  const ScaledType scaled = perm * diag;
+  const MatrixType scaledDense = permDense * diagDense;
+  VERIFY_IS_EQUAL(scaled.toDenseMatrix(), scaledDense);
+  VERIFY_IS_EQUAL(MatrixType(diag * perm), MatrixType(diagDense * permDense));
+  VERIFY_IS_EQUAL(MatrixType(perm.inverse() * diag), MatrixType(inverseDense * diagDense));
+  VERIFY_IS_EQUAL(MatrixType(perm.transpose() * diag), MatrixType(inverseDense * diagDense));
+  VERIFY_IS_EQUAL(MatrixType(diag * perm.inverse()), MatrixType(diagDense * inverseDense));
+  VERIFY_IS_EQUAL(MatrixType(indices.asPermutation() * diag.diagonal().asDiagonal()), scaledDense);
+  VERIFY_IS_EQUAL(MatrixType(diag * Map<PermutationType>(indices.data(), size)), MatrixType(diagDense * permDense));
+  VERIFY_IS_EQUAL(MatrixType(ScaledType(perm)), permDense);
+  VERIFY_IS_EQUAL(MatrixType(ScaledType(diag)), diagDense);
+  for (Index i = 0; i < size; ++i)
+    for (Index j = 0; j < size; ++j) VERIFY_IS_EQUAL(scaled.coeff(i, j), scaledDense(i, j));
+
+  // Assignment to dense.
+  MatrixType result = MatrixType::Random(size, size), expected = result;
+  result = scaled;
+  VERIFY_IS_EQUAL(result, scaledDense);
+  result = expected;
+  result += scaled;
+  expected += scaledDense;
+  VERIFY_IS_EQUAL(result, expected);
+  result -= scaled;
+  expected -= scaledDense;
+  VERIFY_IS_EQUAL(result, expected);
+
+  // Products of scales are complex multiplications, whose rounding depends on the kernel: compare approximately.
+  // Closed-form algebra: every result is a scaled permutation and costs O(n).
+  VERIFY_IS_APPROX(MatrixType(scaled * diag2), MatrixType(scaledDense * diag2Dense));
+  VERIFY_IS_APPROX(MatrixType(diag2 * scaled), MatrixType(diag2Dense * scaledDense));
+  VERIFY_IS_EQUAL(MatrixType(scaled * perm2), MatrixType(scaledDense * perm2Dense));
+  VERIFY_IS_EQUAL(MatrixType(perm2 * scaled), MatrixType(perm2Dense * scaledDense));
+  VERIFY_IS_EQUAL(MatrixType(scaled * perm2.inverse()), MatrixType(scaledDense * perm2Dense.transpose()));
+  VERIFY_IS_EQUAL(MatrixType(perm2.inverse() * scaled), MatrixType(perm2Dense.transpose() * scaledDense));
+  const ScaledType scaled2 = diag2 * perm2;
+  VERIFY_IS_APPROX(MatrixType(scaled * scaled2), MatrixType(scaledDense * scaled2.toDenseMatrix()));
+  VERIFY_IS_APPROX(MatrixType(alpha * scaled), MatrixType(alpha * scaledDense));
+  VERIFY_IS_APPROX(MatrixType(scaled * alpha), MatrixType(scaledDense * alpha));
+  VERIFY_IS_EQUAL(MatrixType(-scaled), MatrixType(-scaledDense));
+  VERIFY_IS_EQUAL(MatrixType(scaled.transpose()), MatrixType(scaledDense.transpose()));
+  VERIFY_IS_EQUAL(MatrixType(scaled.adjoint()), MatrixType(scaledDense.adjoint()));
+  STATIC_CHECK((internal::is_same<decltype(perm * diag * perm.inverse()), ScaledType>::value));
+  VERIFY_IS_EQUAL(MatrixType(perm * diag * perm.inverse()), MatrixType(permDense * diagDense * inverseDense));
+  VERIFY_IS_APPROX(MatrixType(scaled.inverse() * scaled), MatrixType::Identity(size, size));
+  VERIFY_IS_APPROX(MatrixType(scaled.inverse()), scaledDense.inverse());
+  // The dense determinant underflows for large sizes; the sign of a unit-scale permutation is exact at any size.
+  if (size <= 8) VERIFY_IS_APPROX(scaled.determinant(), scaledDense.determinant());
+  VERIFY_IS_EQUAL(ScaledType(perm).determinant(), Scalar(RealScalar(perm.determinant())));
+
+  // Products with dense operands scale and permute rows or columns; no n x n intermediate. Complex products round
+  // differently in the dense kernels, so those comparisons are approximate.
+  const MatrixType a = MatrixType::Random(size, size);
+  const VectorType x = VectorType::Random(size);
+  VectorType y(size);
+  VERIFY_EVALUATION_COUNT(y.noalias() = scaled * x, 0);
+  VERIFY_IS_APPROX(y, VectorType(scaledDense * x));
+  VERIFY_EVALUATION_COUNT(result.noalias() = scaled * a, 0);
+  VERIFY_IS_APPROX(result, MatrixType(scaledDense * a));
+  VERIFY_EVALUATION_COUNT(result.noalias() = a * scaled, 0);
+  VERIFY_IS_APPROX(result, MatrixType(a * scaledDense));
+  VERIFY_IS_APPROX(VectorType(perm * diag * x), VectorType(scaledDense * x));
+  VERIFY_IS_APPROX(VectorType(x.transpose() * (diag * perm)).eval(),
+                   VectorType((x.transpose() * diagDense * permDense).eval()));
+  result = a;
+  expected = a;
+  result.noalias() += scaled * a;
+  expected += scaledDense * a;
+  VERIFY_IS_APPROX(result, expected);
+  result.noalias() -= a * scaled.inverse();
+  expected -= a * scaledDense.inverse();
+  VERIFY_IS_APPROX(result, expected);
+  result = alpha * (scaled * a);
+  VERIFY_IS_APPROX(result, alpha * scaledDense * a);
+  result = a * (scaled * a);
+  VERIFY_IS_APPROX(result, a * scaledDense * a);
+  result = scaled * (a * a);
+  VERIFY_IS_APPROX(result, scaledDense * a * a);
+  // In-place: the dense permutation kernel detects the aliasing.
+  result = a;
+  result.noalias() = scaled * result;
+  VERIFY_IS_APPROX(result, MatrixType(scaledDense * a));
+  result = a;
+  result = result * scaled;
+  VERIFY_IS_APPROX(result, MatrixType(a * scaledDense));
+
+  // Triangular and self-adjoint operands are densified, as toDenseMatrix() does.
+  const MatrixType lower = a.template triangularView<Lower>();
+  const MatrixType upperSelfadjoint = a.template selfadjointView<Upper>();
+  VERIFY_IS_APPROX(MatrixType(scaled * a.template triangularView<Lower>()), MatrixType(scaledDense * lower));
+  VERIFY_IS_APPROX(MatrixType(a.template triangularView<Lower>() * scaled), MatrixType(lower * scaledDense));
+  VERIFY_IS_APPROX(MatrixType(scaled * a.template selfadjointView<Upper>()),
+                   MatrixType(scaledDense * upperSelfadjoint));
+  VERIFY_IS_APPROX(MatrixType(a.template selfadjointView<Upper>() * scaled),
+                   MatrixType(upperSelfadjoint * scaledDense));
+
+  // Lazy sums with a dense matrix.
+  STATIC_CHECK(
+      (internal::is_same<decltype(a + scaled), const CwiseBinaryOp<internal::scalar_sum_op<Scalar, Scalar>,
+                                                                   const MatrixType, const ScaledType>>::value));
+  VERIFY_IS_EQUAL(MatrixType(a + scaled), MatrixType(a + scaledDense));
+  VERIFY_IS_EQUAL(MatrixType(scaled + a), MatrixType(scaledDense + a));
+  VERIFY_IS_EQUAL(MatrixType(a - scaled), MatrixType(a - scaledDense));
+  VERIFY_IS_EQUAL(MatrixType(scaled - a), MatrixType(scaledDense - a));
+  VERIFY_IS_APPROX((a + scaled) * x, (a + scaledDense) * x);
+  VERIFY_IS_APPROX((a + scaled).sum(), (a + scaledDense).sum());
+
+  // Storage and setters.
+  ScaledType identity(size);
+  identity.setIdentity();
+  VERIFY_IS_EQUAL(MatrixType(identity), MatrixType::Identity(size, size));
+  VERIFY_IS_EQUAL(MatrixType(identity * scaled), scaledDense);
+  ScaledType copy = scaled;
+  copy.scales() *= alpha;
+  VERIFY_IS_APPROX(MatrixType(copy), MatrixType(alpha * scaledDense));
+  copy = scaled2;
+  VERIFY_IS_EQUAL(MatrixType(copy), scaled2.toDenseMatrix());
+}
+
+template <typename Real>
+void scaled_permutation_mixed_scalars() {
+  using Complex = std::complex<Real>;
+  using Dense = Matrix<Complex, 3, 3>;
+  ScaledPermutationMatrix<Real, 3> real;
+  ScaledPermutationMatrix<Complex, Dynamic> complex(3);
+  real.indices() << 1, 2, 0;
+  real.scales() << 2, 3, 5;
+  complex.indices() << 2, 0, 1;
+  complex.scales() << Complex(1, 2), Complex(3, -1), Complex(-2, 4);
+  const DiagonalMatrix<Real, 3> realDiagonal(real.scales());
+  const DiagonalMatrix<Complex, 3> complexDiagonal(complex.scales());
+  const Dense realDense = real.toDenseMatrix().template cast<Complex>();
+  const Dense complexDense = complex.toDenseMatrix();
+  const Dense realDiagonalDense = realDiagonal.toDenseMatrix().template cast<Complex>();
+  const Dense complexDiagonalDense = complexDiagonal.toDenseMatrix();
+  const auto product = real * complex;
+  STATIC_CHECK((internal::is_same<typename decltype(product)::Scalar, Complex>::value));
+  STATIC_CHECK(decltype(product)::RowsAtCompileTime == 3);
+  VERIFY_IS_EQUAL(Dense(product), Dense(realDense * complexDense));
+  VERIFY_IS_EQUAL(Dense(complex * real), Dense(complexDense * realDense));
+  VERIFY_IS_EQUAL(Dense(real * complexDiagonal), Dense(realDense * complexDiagonalDense));
+  VERIFY_IS_EQUAL(Dense(complexDiagonal * real), Dense(complexDiagonalDense * realDense));
+  VERIFY_IS_EQUAL(Dense(complex * realDiagonal), Dense(complexDense * realDiagonalDense));
+  VERIFY_IS_EQUAL(Dense(realDiagonal * complex), Dense(realDiagonalDense * complexDense));
+  VERIFY_IS_EQUAL(Dense(real * complexDense), Dense(realDense * complexDense));
+  VERIFY_IS_EQUAL(Dense(complexDense * real), Dense(complexDense * realDense));
+  Dense accumulated = Dense::Zero();
+  accumulated.noalias() += real * complexDense;
+  VERIFY_IS_EQUAL(accumulated, Dense(realDense * complexDense));
+  accumulated.setZero();
+  accumulated.noalias() += complexDense * real;
+  VERIFY_IS_EQUAL(accumulated, Dense(complexDense * realDense));
+}
+
+template <int Order>
+void scaled_permutation_noncommutative() {
+  using Scalar = noncommutative_scalar::Quaternion;
+  using Dense = Matrix<Scalar, 3, 3, Order>;
+  ScaledPermutationMatrix<Scalar, 3> scaled;
+  scaled.indices() << 1, 2, 0;
+  scaled.scales() << Scalar(1, 2, 0, -1), Scalar(2, -1, 3, 0), Scalar(-1, 0, 2, 1);
+  Dense matrix, left, right;
+  for (Index i = 0; i < 3; ++i)
+    for (Index j = 0; j < 3; ++j) matrix(i, j) = Scalar(i + 1, j + 1, i - j, i + j);
+  for (Index k = 0; k < 3; ++k) {
+    for (Index j = 0; j < 3; ++j) left(scaled.indices()(k), j) = scaled.scales()(k) * matrix(k, j);
+    for (Index i = 0; i < 3; ++i) right(i, k) = matrix(i, scaled.indices()(k)) * scaled.scales()(k);
+  }
+  Dense result = scaled * matrix;
+  VERIFY((result.array() == left.array()).all());
+  result = matrix * scaled;
+  VERIFY((result.array() == right.array()).all());
+  result = matrix;
+  result = scaled * result;
+  VERIFY((result.array() == left.array()).all());
+  result = matrix;
+  result = result * scaled;
+  VERIFY((result.array() == right.array()).all());
+  result.setZero();
+  result.noalias() += scaled * matrix;
+  VERIFY((result.array() == left.array()).all());
+  result.setZero();
+  result.noalias() += matrix * scaled;
+  VERIFY((result.array() == right.array()).all());
+  const Scalar alpha(1, -2, 3, 1);
+  result.setZero();
+  result.noalias() += alpha * (scaled * matrix);
+  for (Index i = 0; i < 3; ++i)
+    for (Index j = 0; j < 3; ++j) VERIFY(result(i, j) == alpha * left(i, j));
+  result.setZero();
+  result.noalias() -= alpha * (matrix * scaled);
+  for (Index i = 0; i < 3; ++i)
+    for (Index j = 0; j < 3; ++j) VERIFY(result(i, j) == -(alpha * right(i, j)));
+}
+
+EIGEN_DECLARE_TEST(scaled_permutation) {
+  CALL_SUBTEST_1((scaled_permutation<float, 1>(1)));
+  CALL_SUBTEST_1((scaled_permutation<double, 3>(3)));
+  CALL_SUBTEST_1((scaled_permutation<std::complex<double>, 4>(4)));
+  CALL_SUBTEST_4(scaled_permutation_mixed_scalars<float>());
+  CALL_SUBTEST_4(scaled_permutation_mixed_scalars<double>());
+  CALL_SUBTEST_5(scaled_permutation_noncommutative<ColMajor>());
+  CALL_SUBTEST_5(scaled_permutation_noncommutative<RowMajor>());
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_2((scaled_permutation<float, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_2((scaled_permutation<double, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_3((scaled_permutation<std::complex<double>, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
+  }
+}
diff --git a/test/schur_complex.cpp b/test/schur_complex.cpp
index 0449896..e1d3ad0 100644
--- a/test/schur_complex.cpp
+++ b/test/schur_complex.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "fp_control.h"
 #include <limits>
 #include <Eigen/Eigenvalues>
 
@@ -79,6 +81,194 @@
   }
 }
 
+// The Hessenberg reduction treats a subdiagonal tail whose squared norm underflows as already zero. ComplexSchur used
+// to reduce the caller's matrix directly, so at this scale it returned the diagonal of the input as the Schur form.
+template <typename MatrixType>
+void schur_underflow_scale(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename ComplexSchur<MatrixType>::ComplexScalar ComplexScalar;
+  typedef typename ComplexSchur<MatrixType>::ComplexMatrixType ComplexMatrixType;
+
+  // Representable, but every product of two coefficients underflows.
+  const RealScalar scale = numext::sqrt((std::numeric_limits<RealScalar>::min)()) / RealScalar(1024);
+  const MatrixType A = MatrixType::Random(size, size) * Scalar(scale);
+
+  ComplexSchur<MatrixType> schurOfA(A);
+  VERIFY_IS_EQUAL(schurOfA.info(), Success);
+  const ComplexMatrixType& U = schurOfA.matrixU();
+  const ComplexMatrixType& T = schurOfA.matrixT();
+
+  // isApprox squares its operands, and every square here is subnormal: under flush-to-zero both sides of the
+  // reconstruction collapse to zero and any T passes. scale is an exact power of two, so multiplying by its
+  // reciprocal is lossless and puts the comparison back in the normal range.
+  const ComplexScalar invScale = ComplexScalar(RealScalar(1) / scale);
+  VERIFY_IS_APPROX(ComplexMatrixType(A.template cast<ComplexScalar>() * invScale),
+                   ComplexMatrixType(U * T * U.adjoint() * invScale));
+  VERIFY_IS_APPROX(U * U.adjoint(), ComplexMatrixType::Identity(size, size));
+  for (Index row = 1; row < size; ++row)
+    for (Index col = 0; col < row; ++col) VERIFY(numext::is_exactly_zero(T(row, col)));
+}
+
+// Under flush-to-zero, targets with runtime control see what ARMv7 NEON always does to subnormal SIMD results, and Arm
+// flushes subnormal inputs as well. The decomposition runs inside the scope; callers verify outside it.
+template <typename MatrixType>
+bool compute_schur(ComplexSchur<MatrixType>& schur, const MatrixType& A, bool flushToZero) {
+  if (!flushToZero) {
+    schur.compute(A);
+    return true;
+  }
+  ScopedFlushToZero scope;
+  if (scope.isSupported()) schur.compute(A);
+  return scope.isSupported();
+}
+
+// A matrix whose coefficients are all subnormal is still a matrix with a Schur decomposition, not the zero matrix.
+// Scaling by a power of two moves it into the normal range exactly, so the factorization stays accurate to the
+// quantization of the subnormal input.
+template <typename MatrixType>
+void schur_subnormal_scale(Index size, bool flushToZero) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename ComplexSchur<MatrixType>::ComplexMatrixType ComplexMatrixType;
+  using WideScalar = std::complex<long double>;
+  using WideMatrix = Matrix<WideScalar, Dynamic, Dynamic>;
+
+  const RealScalar denormalMin = std::numeric_limits<RealScalar>::denorm_min();
+  const RealScalar normalMin = (std::numeric_limits<RealScalar>::min)();
+  if (!(denormalMin < normalMin)) return;  // Target has no subnormals, or flushes them to zero.
+
+  // Every coefficient lands in the top of the subnormal range: none of them is normal, yet each still carries most of
+  // its mantissa, so an accurate decomposition remains possible. Maxima and reconstructions are taken in long double,
+  // whose arithmetic is scalar: a SIMD unit that flushes subnormals (ARMv7 NEON) would zero them.
+  const MatrixType A = MatrixType::Random(size, size) * Scalar(normalMin / RealScalar(2));
+  const WideMatrix wideA = A.template cast<WideScalar>();
+  const long double maxA = wideA.cwiseAbs().maxCoeff();
+  VERIFY(maxA > 0 && maxA < static_cast<long double>(normalMin));
+
+  ComplexSchur<MatrixType> schurOfA(size);
+  if (!compute_schur(schurOfA, A, flushToZero)) return;
+  VERIFY_IS_EQUAL(schurOfA.info(), Success);
+  const ComplexMatrixType& U = schurOfA.matrixU();
+  const ComplexMatrixType& T = schurOfA.matrixT();
+  const WideMatrix wideU = U.template cast<WideScalar>();
+  const WideMatrix wideT = T.template cast<WideScalar>();
+
+  // Unitary invariance gives ||T||_F = ||A||_F, so the largest coefficient of T cannot be more than a factor of the
+  // dimension below the largest coefficient of A. Returning the zero matrix, as the unscaled reduction did, fails
+  // this; isZero() would not, because every coefficient here is much smaller than one.
+  VERIFY(wideT.cwiseAbs().maxCoeff() >= maxA / static_cast<long double>(size));
+  VERIFY_IS_APPROX(U * U.adjoint(), ComplexMatrixType::Identity(size, size));
+  // T rounds back into the subnormal range, where the spacing is denorm_min rather than eps times the coefficient, so
+  // bound the residual by that spacing instead of by a relative tolerance.
+  const long double residual = (wideA - wideU * wideT * wideU.adjoint()).cwiseAbs().maxCoeff();
+  VERIFY(residual <= static_cast<long double>(4 * size * size) * static_cast<long double>(denormalMin));
+
+  // A triangular matrix is its own Schur form and power-of-two scaling is exact, so T reproduces it bit for bit.
+  MatrixType triangular = A;
+  triangular.template triangularView<StrictlyLower>().setZero();
+  compute_schur(schurOfA, triangular, flushToZero);
+  VERIFY_IS_EQUAL(schurOfA.info(), Success);
+  VERIFY_IS_EQUAL(U, ComplexMatrixType::Identity(size, size));
+  VERIFY_IS_EQUAL(WideMatrix(T.template cast<WideScalar>()), WideMatrix(triangular.template cast<WideScalar>()));
+}
+
+// Scaling divides by a power of two, so coefficients more than the exponent range below the largest one flush to zero.
+// That perturbation is bounded by the smallest subnormal relative to the largest coefficient, far below eps, and the
+// unscaled reduction squares such a matrix into overflow anyway.
+template <typename MatrixType>
+void schur_dynamic_range(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef typename ComplexSchur<MatrixType>::ComplexScalar ComplexScalar;
+  typedef typename ComplexSchur<MatrixType>::ComplexMatrixType ComplexMatrixType;
+
+  const RealScalar huge = numext::sqrt((std::numeric_limits<RealScalar>::max)());
+  MatrixType A = MatrixType::Random(size, size) * Scalar(huge);
+  A(size - 1, 0) = Scalar(std::numeric_limits<RealScalar>::denorm_min());
+
+  ComplexSchur<MatrixType> schurOfA(A);
+  VERIFY_IS_EQUAL(schurOfA.info(), Success);
+  const ComplexMatrixType& U = schurOfA.matrixU();
+  const ComplexMatrixType& T = schurOfA.matrixT();
+
+  VERIFY(U.allFinite() && T.allFinite());
+  VERIFY_IS_APPROX(U * U.adjoint(), ComplexMatrixType::Identity(size, size));
+  // Both Frobenius norms overflow at this scale, so isApprox would compare infinity against infinity and any T would
+  // pass. Compare at unit scale instead; huge is not a power of two, so this costs one rounding per coefficient.
+  const ComplexScalar invHuge = ComplexScalar(RealScalar(1) / huge);
+  VERIFY_IS_APPROX(ComplexMatrixType(A.template cast<ComplexScalar>() * invHuge),
+                   ComplexMatrixType(U * T * U.adjoint() * invHuge));
+}
+
+// A NaN must not be scaled away. maxCoeff has to propagate it, or a matrix that is zero apart from a NaN looks like
+// the zero matrix and reports a successful decomposition. Which coefficient carries the NaN matters, because the
+// default max reduction keeps whichever operand it visits first.
+template <typename MatrixType>
+void schur_nan_only(Index size) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  for (Index k = 0; k < size; ++k) {
+    MatrixType A = MatrixType::Zero(size, size);
+    A(k, k) = Scalar(std::numeric_limits<RealScalar>::quiet_NaN());
+
+    ComplexSchur<MatrixType> schurOfA(A);
+    VERIFY_IS_NOT_EQUAL(schurOfA.info(), Success);
+  }
+}
+
+// The zero matrix has no exponent to normalize by; it must still decompose trivially.
+template <typename MatrixType>
+void schur_zero(Index size) {
+  typedef typename ComplexSchur<MatrixType>::ComplexMatrixType ComplexMatrixType;
+
+  const MatrixType A = MatrixType::Zero(size, size);
+  ComplexSchur<MatrixType> schurOfA(A);
+  VERIFY_IS_EQUAL(schurOfA.info(), Success);
+  VERIFY(schurOfA.matrixT().isZero());
+  VERIFY_IS_EQUAL(schurOfA.matrixU(), ComplexMatrixType::Identity(size, size));
+}
+
+template <typename RealScalar>
+void schur_shift_scaling() {
+  using Scalar = std::complex<RealScalar>;
+  using MatrixType = Matrix<Scalar, 2, 2>;
+  MatrixType base;
+  base << Scalar(1, 1), Scalar(2, -1), Scalar(-3, 1), Scalar(4, -2);
+  const MatrixType identity = MatrixType::Identity();
+  const int exponents[] = {std::numeric_limits<RealScalar>::min_exponent + 4,
+                           std::numeric_limits<RealScalar>::min_exponent / 2 - 8,
+                           -1,
+                           0,
+                           1,
+                           std::numeric_limits<RealScalar>::max_exponent / 2 - 8,
+                           std::numeric_limits<RealScalar>::max_exponent - 5};
+  for (int exponent : exponents) {
+    const RealScalar scale = numext::ldexp(RealScalar(1), exponent);
+    const MatrixType matrix = base * scale;
+    ComplexSchur<MatrixType> schur;
+    // Bypass compute()'s input normalization. The nonzero subdiagonal requires a QR shift at the requested scale.
+    schur.setMaxIterations(0).computeFromHessenberg(matrix, identity);
+    VERIFY_IS_EQUAL(schur.info(), NoConvergence);
+    schur.setMaxIterations(ComplexSchur<MatrixType>::m_maxIterationsPerRow * 2);
+    schur.computeFromHessenberg(matrix, identity);
+    VERIFY_IS_EQUAL(schur.info(), Success);
+    const MatrixType unitary = schur.matrixU();
+    const MatrixType normalizedT = schur.matrixT() * (RealScalar(1) / scale);
+    VERIFY(normalizedT.allFinite());
+    VERIFY(unitary.allFinite());
+    VERIFY_IS_EQUAL(normalizedT(1, 0), Scalar(0));
+    // Two-dimensional QR and reconstruction incur a bounded number of rounding errors per iteration.
+    const RealScalar tolerance = RealScalar(128) * NumTraits<RealScalar>::epsilon();
+    VERIFY((base - unitary * normalizedT * unitary.adjoint()).norm() <= tolerance * base.norm());
+    VERIFY((unitary * unitary.adjoint() - identity).norm() <= tolerance);
+    schur.computeFromHessenberg(matrix, identity, false);
+    VERIFY_IS_EQUAL(schur.info(), Success);
+    VERIFY_IS_EQUAL(schur.matrixT() * (RealScalar(1) / scale), normalizedT);
+  }
+}
+
 EIGEN_DECLARE_TEST(schur_complex) {
   CALL_SUBTEST_1((schur<Matrix4cd>()));
   CALL_SUBTEST_2((schur<MatrixXcf>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4))));
@@ -87,4 +277,40 @@
 
   // Test problem size constructors
   CALL_SUBTEST_5(ComplexSchur<MatrixXf>(10));
+  CALL_SUBTEST_11((schur<MatrixXcd>(128)));
+
+  CALL_SUBTEST_6((schur_underflow_scale<Matrix4cd>(4)));
+  CALL_SUBTEST_6((schur_underflow_scale<MatrixXcf>(8)));
+  CALL_SUBTEST_6((schur_underflow_scale<MatrixXf>(8)));
+  {
+    // Every square this reconstruction compares is subnormal, so run it again with subnormals flushed to zero: that
+    // is the configuration in which the unscaled reduction it guards against also passes.
+    Eigen::ScopedFlushToZero flush_to_zero;
+    if (flush_to_zero.isSupported()) {
+      CALL_SUBTEST_6((schur_underflow_scale<Matrix4cd>(4)));
+      CALL_SUBTEST_6((schur_underflow_scale<MatrixXcf>(8)));
+      CALL_SUBTEST_6((schur_underflow_scale<MatrixXf>(8)));
+    }
+  }
+
+  CALL_SUBTEST_7((schur_subnormal_scale<Matrix4cd>(4, false)));
+  CALL_SUBTEST_7((schur_subnormal_scale<MatrixXcf>(8, false)));
+  CALL_SUBTEST_7((schur_subnormal_scale<MatrixXf>(8, false)));
+  CALL_SUBTEST_7((schur_subnormal_scale<Matrix4cd>(4, true)));
+  CALL_SUBTEST_7((schur_subnormal_scale<MatrixXcf>(8, true)));
+  CALL_SUBTEST_7((schur_subnormal_scale<MatrixXf>(8, true)));
+
+  CALL_SUBTEST_8((schur_dynamic_range<Matrix4cd>(4)));
+  CALL_SUBTEST_8((schur_dynamic_range<MatrixXcf>(8)));
+  CALL_SUBTEST_8((schur_dynamic_range<MatrixXf>(8)));
+
+  CALL_SUBTEST_9((schur_nan_only<Matrix4cd>(4)));
+  CALL_SUBTEST_9((schur_nan_only<MatrixXcf>(8)));
+  CALL_SUBTEST_9((schur_nan_only<MatrixXf>(8)));
+
+  CALL_SUBTEST_10((schur_zero<Matrix4cd>(4)));
+  CALL_SUBTEST_10((schur_zero<MatrixXcf>(8)));
+  CALL_SUBTEST_10((schur_zero<MatrixXf>(8)));
+  CALL_SUBTEST_10(schur_shift_scaling<float>());
+  CALL_SUBTEST_10(schur_shift_scaling<double>());
 }
diff --git a/test/schur_real.cpp b/test/schur_real.cpp
index 4a9dd89..11d467f 100644
--- a/test/schur_real.cpp
+++ b/test/schur_real.cpp
@@ -6,8 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
+#include "fp_control.h"
 #include <limits>
 #include <Eigen/Eigenvalues>
 
@@ -104,14 +106,185 @@
   VERIFY(schur.info() == Eigen::Success);
 }
 
+void real_schur_power_of_two_scaling() {
+  // Reciprocal scaling rounds the smaller diagonal entry up by one ULP.
+  Matrix2f matrix = Matrix2f::Zero();
+  matrix(0, 0) = numext::bit_cast<float>(numext::uint32_t(0x58f6aaed));
+  matrix(0, 1) = numext::bit_cast<float>(numext::uint32_t(0x52123456));
+  matrix(1, 1) = numext::bit_cast<float>(numext::uint32_t(0x537dcf0e));
+
+  const RealSchur<Matrix2f> schur(matrix);
+  VERIFY_IS_EQUAL(schur.info(), Success);
+  VERIFY_IS_EQUAL(schur.matrixT(), matrix);
+
+  // Probe arithmetic, not just loads: FTZ can preserve an input yet flush a subnormal result.
+  volatile float normalMinInput = (std::numeric_limits<float>::min)();
+  volatile float epsilonInput = std::numeric_limits<float>::epsilon();
+  const float denormMin = normalMinInput * epsilonInput;
+  if (!(denormMin > 0.0f)) return;
+  matrix.setZero();
+  matrix.diagonal() << 1.5f, denormMin;
+  const RealSchur<Matrix2f> tailSchur(matrix);
+  VERIFY_IS_EQUAL(tailSchur.matrixT()(1, 1), denormMin);
+}
+
+template <typename MatrixType>
+void real_schur_subnormal_restoration(Index n = MatrixType::RowsAtCompileTime) {
+  using Scalar = typename MatrixType::Scalar;
+  using Bits = typename numext::get_integer_by_size<sizeof(Scalar)>::unsigned_type;
+  const Scalar normal_min = (std::numeric_limits<Scalar>::min)();
+  const Bits half_min_bits = numext::bit_cast<Bits>(normal_min) >> 1;
+  MatrixType matrix = MatrixType::Zero(n, n);
+  matrix(0, 0) = normal_min;
+  matrix(1, 1) = numext::bit_cast<Scalar>(half_min_bits);
+  const ScopedFlushToZero flush;
+  for (bool compute_u : {false, true}) {
+    const RealSchur<MatrixType> schur(matrix, compute_u);
+    VERIFY_IS_EQUAL(schur.info(), Success);
+    // Compare representations: DAZ can make an erroneous zero compare equal to a subnormal.
+    VERIFY_IS_EQUAL(numext::bit_cast<Bits>(schur.matrixT()(1, 1)), half_min_bits);
+    VERIFY_IS_EQUAL(numext::bit_cast<Bits>(schur.matrixT()(0, 0)), numext::bit_cast<Bits>(normal_min));
+  }
+}
+
+template <typename Scalar, int StorageOrder>
+void schur_workspace_stride() {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  // The middle size selects the padded workspace for both float and double; its neighbours do not.
+  const Index strideSize = 1024 / sizeof(Scalar);
+  for (Index n : {strideSize - 1, strideSize, strideSize + 1}) {
+    const Mat identity = Mat::Identity(n, n);
+    Mat a = Mat::Random(n, n);
+    const Scalar bound = Scalar(64 * n) * NumTraits<Scalar>::epsilon();
+    RealSchur<Mat> solver(n);
+    solver.compute(a);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    const Mat u = solver.matrixU(), t = solver.matrixT();
+    verifyIsQuasiTriangular(t);
+    VERIFY((a - u * t * u.transpose()).norm() <= bound * a.norm());
+    VERIFY((u.transpose() * u - identity).norm() <= bound);
+
+    solver.compute(a, false);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY_IS_EQUAL(solver.matrixT(), t);
+
+    HessenbergDecomposition<Mat> hess(a);
+    const Mat h = hess.matrixH(), q = hess.matrixQ();
+    solver.computeFromHessenberg(h, q, true);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY((a - solver.matrixU() * solver.matrixT() * solver.matrixU().transpose()).norm() <= bound * a.norm());
+
+    solver.setMaxIterations(1).computeFromHessenberg(h, q, true);
+    VERIFY_IS_EQUAL(solver.info(), NoConvergence);
+    // Partial results must be copied out of the workspace too.
+    VERIFY((a - solver.matrixU() * solver.matrixT() * solver.matrixU().transpose()).norm() <= bound * a.norm());
+    solver.setMaxIterations(-1);
+
+    // A decoupled trailing block exercises active windows smaller than the padded matrix.
+    a.bottomLeftCorner(n / 2, n - n / 2).setZero();
+    EigenSolver<Mat> eig(a);
+    VERIFY_IS_EQUAL(eig.info(), Success);
+    VERIFY((a * eig.pseudoEigenvectors() - eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix()).norm() <=
+           bound * a.norm() * eig.pseudoEigenvectors().norm());
+    solver.compute(identity);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    VERIFY_IS_EQUAL(solver.matrixT(), identity);
+    VERIFY_IS_EQUAL(solver.matrixU(), identity);
+
+    // Exercise subnormal restoration across the padded-workspace boundary too.
+    real_schur_subnormal_restoration<Mat>(n);
+
+    a.setZero();
+    for (Scalar nonfinite : {NumTraits<Scalar>::quiet_NaN(), NumTraits<Scalar>::infinity()}) {
+      a(n - 1, n - 1) = nonfinite;
+      solver.compute(a);
+      VERIFY_IS_EQUAL(solver.info(), NoConvergence);
+      VERIFY(!(numext::isfinite)(solver.matrixT()(n - 1, n - 1)));
+      VERIFY_RAISES_ASSERT(solver.matrixU());
+      eig.compute(a, false);
+      VERIFY_IS_EQUAL(eig.info(), NumericalIssue);
+    }
+  }
+}
+
+template <typename Scalar, int StorageOrder>
+void schur_workspace_ref() {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  using StridedRef = Ref<Mat, 0, Stride<Dynamic, Dynamic>>;
+  const Index strideSize = 1024 / sizeof(Scalar);
+  for (Index n : {strideSize - 1, strideSize}) {
+    const Mat a = Mat::Random(n, n);
+    const Mat identity = Mat::Identity(n, n);
+    const Scalar bound = Scalar(64 * n) * NumTraits<Scalar>::epsilon();
+    HessenbergDecomposition<Mat> hess(a);
+    const Mat h = hess.matrixH(), q = hess.matrixQ();
+    for (Index inner : {Index(1), Index(2)}) {
+      for (Index extra : {Index(0), Index(1)}) {
+        const Index outer = n * inner + extra;
+        Matrix<Scalar, Dynamic, 1> storage = Matrix<Scalar, Dynamic, 1>::Constant(n * outer + 2, Scalar(17));
+        Map<Mat, 0, Stride<Dynamic, Dynamic>> matrix(storage.data() + 1, n, n, Stride<Dynamic, Dynamic>(outer, inner));
+        matrix = a;
+        RealSchur<StridedRef> solver(matrix);
+        VERIFY_IS_EQUAL(solver.info(), Success);
+        VERIFY(internal::is_same_dense(matrix, solver.matrixT()));
+        VERIFY((a - solver.matrixU() * matrix * solver.matrixU().transpose()).norm() <= bound * a.norm());
+        VERIFY((solver.matrixU().transpose() * solver.matrixU() - identity).norm() <= bound);
+
+        const Mat input = a * Scalar(8);
+        solver.compute(input, false);
+        VERIFY_IS_EQUAL(solver.info(), Success);
+        VERIFY_IS_EQUAL(input, a * Scalar(8));
+        VERIFY_RAISES_ASSERT(solver.matrixU());
+        for (Index maxIters : {Index(1), Index(-1)}) {
+          solver.setMaxIterations(maxIters).compute(input);
+          VERIFY_IS_EQUAL(solver.info(), maxIters == -1 ? Success : NoConvergence);
+          VERIFY((input - solver.matrixU() * matrix * solver.matrixU().transpose()).norm() <= bound * input.norm());
+          solver.computeFromHessenberg(h, q, true);
+          VERIFY_IS_EQUAL(solver.info(), maxIters == -1 ? Success : NoConvergence);
+          VERIFY((a - solver.matrixU() * matrix * solver.matrixU().transpose()).norm() <= bound * a.norm());
+        }
+        // Exercise aliased input with an already suitable stride as well as a cache-conflicting one.
+        matrix = h;
+        solver.computeFromHessenberg(matrix, q, true);
+        VERIFY_IS_EQUAL(solver.info(), Success);
+        VERIFY((a - solver.matrixU() * matrix * solver.matrixU().transpose()).norm() <= bound * a.norm());
+        solver.compute(Mat::Zero(n, n));
+        VERIFY_IS_EQUAL(solver.info(), Success);
+        VERIFY_IS_EQUAL(matrix, Mat::Zero(n, n));
+        VERIFY_IS_EQUAL(solver.matrixU(), identity);
+        VERIFY(internal::is_same_dense(matrix, solver.matrixT()));
+        for (Index i = 0; i < storage.size(); ++i) {
+          const Index offset = i - 1;
+          const bool inMatrix =
+              offset >= 0 && offset / outer < n && offset % outer < n * inner && offset % outer % inner == 0;
+          if (!inMatrix) VERIFY_IS_EQUAL(storage(i), Scalar(17));
+        }
+      }
+    }
+  }
+}
+
 EIGEN_DECLARE_TEST(schur_real) {
   CALL_SUBTEST_1((schur<Matrix4f>()));
   CALL_SUBTEST_2((schur<MatrixXd>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 4))));
   CALL_SUBTEST_3((schur<Matrix<float, 1, 1> >()));
   CALL_SUBTEST_4((schur<Matrix<double, 3, 3, Eigen::RowMajor> >()));
+  CALL_SUBTEST_1((schur<Matrix<float, Dynamic, Dynamic, RowMajor>>(17)));
+  CALL_SUBTEST_2((schur<Matrix<double, Dynamic, Dynamic, RowMajor>>(17)));
 
   // Test problem size constructors
   CALL_SUBTEST_5(RealSchur<MatrixXf>(10));
 
   CALL_SUBTEST_6((test_bug2633()));
+  CALL_SUBTEST_6((real_schur_power_of_two_scaling()));
+  CALL_SUBTEST_6(real_schur_subnormal_restoration<Matrix2f>());
+  CALL_SUBTEST_6(real_schur_subnormal_restoration<Matrix2d>());
+  CALL_SUBTEST_7((schur_workspace_stride<float, ColMajor>()));
+  CALL_SUBTEST_8((schur_workspace_stride<double, ColMajor>()));
+  CALL_SUBTEST_9((schur_workspace_stride<float, RowMajor>()));
+  CALL_SUBTEST_10((schur_workspace_stride<double, RowMajor>()));
+  CALL_SUBTEST_11((schur_workspace_ref<float, ColMajor>()));
+  CALL_SUBTEST_12((schur_workspace_ref<double, ColMajor>()));
+  CALL_SUBTEST_13((schur_workspace_ref<float, RowMajor>()));
+  CALL_SUBTEST_14((schur_workspace_ref<double, RowMajor>()));
 }
diff --git a/test/schur_real_nomalloc.cpp b/test/schur_real_nomalloc.cpp
new file mode 100644
index 0000000..68a855c
--- /dev/null
+++ b/test/schur_real_nomalloc.cpp
@@ -0,0 +1,97 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#if defined(EIGEN_TEST_PART_2)
+#define EIGEN_NO_MALLOC
+#else
+#define EIGEN_RUNTIME_NO_MALLOC
+#endif
+
+#include "main.h"
+#include <Eigen/Eigenvalues>
+
+template <typename MatrixType>
+void schur_no_malloc() {
+  using Scalar = typename MatrixType::Scalar;
+  using VectorType = typename RealSchur<MatrixType>::ColumnVectorType;
+  // These sizes would select padding if allocation and deallocation were allowed.
+  const Index n = 1024 / sizeof(Scalar);
+  MatrixType h = MatrixType::Random(n, n);
+  h.bottomLeftCorner(n - 2, n - 2).template triangularView<Lower>().setZero();
+  MatrixType q = MatrixType::Identity(n, n);
+  for (Index i = 0; i < n; i += 2) q(i, i) = Scalar(-1);
+  const MatrixType a = q.diagonal().asDiagonal() * h * q.diagonal().asDiagonal();
+  const Scalar bound = Scalar(64 * n) * NumTraits<Scalar>::epsilon();
+  MatrixType referenceT(n, n);
+  VectorType residual(n);
+  RealSchur<MatrixType> solver(n);
+
+#ifdef EIGEN_RUNTIME_NO_MALLOC
+  for (int restriction : {1, 2, 3, 0}) {
+    internal::set_is_malloc_allowed((restriction & 1) == 0);
+    internal::set_is_free_allowed((restriction & 2) == 0);
+#endif
+    solver.setMaxIterations(-1).compute(a, false);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    // An already Hessenberg input has no reflectors, so forming its initial Q must not allocate.
+    solver.compute(h, true);
+#ifdef EIGEN_RUNTIME_NO_MALLOC
+    internal::set_is_malloc_allowed(true);
+    internal::set_is_free_allowed(true);
+#endif
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    Scalar hessenbergError(0);
+    for (Index j = 0; j < n; ++j) {
+      residual.noalias() = h * solver.matrixU().col(j);
+      residual.noalias() -= solver.matrixU() * solver.matrixT().col(j);
+      hessenbergError += residual.squaredNorm();
+    }
+    VERIFY(numext::sqrt(hessenbergError) <= bound * h.norm());
+    for (Index maxIters : {Index(-1), Index(1)}) {
+      solver.setMaxIterations(maxIters);
+      for (bool computeU : {true, false}) {
+#ifdef EIGEN_RUNTIME_NO_MALLOC
+        internal::set_is_malloc_allowed((restriction & 1) == 0);
+        internal::set_is_free_allowed((restriction & 2) == 0);
+#endif
+        solver.computeFromHessenberg(h, q, computeU);
+#ifdef EIGEN_RUNTIME_NO_MALLOC
+        internal::set_is_malloc_allowed(true);
+        internal::set_is_free_allowed(true);
+#endif
+        VERIFY_IS_EQUAL(solver.info(), maxIters == -1 ? Success : NoConvergence);
+        if (computeU) {
+          referenceT = solver.matrixT();
+          const MatrixType& u = solver.matrixU();
+          Scalar reconstructionError(0), orthogonalityError(0);
+          // Matrix-vector products also keep verification allocation-free in the compile-time no-malloc part.
+          for (Index j = 0; j < n; ++j) {
+            residual.noalias() = a * u.col(j);
+            residual.noalias() -= u * referenceT.col(j);
+            reconstructionError += residual.squaredNorm();
+            residual.noalias() = u.transpose() * u.col(j);
+            residual(j) -= Scalar(1);
+            orthogonalityError += residual.squaredNorm();
+          }
+          VERIFY(numext::sqrt(reconstructionError) <= bound * a.norm());
+          VERIFY(numext::sqrt(orthogonalityError) <= bound);
+        } else {
+          VERIFY_IS_EQUAL(solver.matrixT(), referenceT);
+        }
+      }
+    }
+#ifdef EIGEN_RUNTIME_NO_MALLOC
+  }
+#endif
+}
+
+EIGEN_DECLARE_TEST(schur_real_nomalloc) {
+  CALL_SUBTEST_1((schur_no_malloc<Matrix<float, Dynamic, Dynamic, ColMajor>>()));
+  CALL_SUBTEST_1((schur_no_malloc<Matrix<float, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_1((schur_no_malloc<Matrix<double, Dynamic, Dynamic, ColMajor>>()));
+  CALL_SUBTEST_1((schur_no_malloc<Matrix<double, Dynamic, Dynamic, RowMajor>>()));
+  CALL_SUBTEST_2((schur_no_malloc<Matrix<double, 128, 128, ColMajor>>()));
+  CALL_SUBTEST_2((schur_no_malloc<Matrix<double, 128, 128, RowMajor>>()));
+  CALL_SUBTEST_2((schur_no_malloc<Matrix<double, Dynamic, Dynamic, ColMajor, 128, 128>>()));
+  CALL_SUBTEST_2((schur_no_malloc<Matrix<double, Dynamic, Dynamic, RowMajor, 128, 128>>()));
+}
diff --git a/test/selfadjoint.cpp b/test/selfadjoint.cpp
index 38075ee..708b102 100644
--- a/test/selfadjoint.cpp
+++ b/test/selfadjoint.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_CHECK_STATIC_ASSERTIONS
 #include "main.h"
@@ -42,11 +43,107 @@
   m4 = m2;
   m4 -= m1.template selfadjointView<Lower>();
   VERIFY_IS_APPROX(m4, m2 - m3);
+
+  Scalar s = internal::random<Scalar>();
+
+  m4 = s * m1.template selfadjointView<Upper>();
+  VERIFY_IS_APPROX(m4, MatrixType((s * m1).template selfadjointView<Upper>()));
+  m4 = m1.template selfadjointView<Upper>() * s;
+  VERIFY_IS_APPROX(m4, MatrixType((m1 * s).template selfadjointView<Upper>()));
+
+  m4 = s * m1.template selfadjointView<Lower>();
+  VERIFY_IS_APPROX(m4, MatrixType((s * m1).template selfadjointView<Lower>()));
+  m4 = m1.template selfadjointView<Lower>() * s;
+  VERIFY_IS_APPROX(m4, MatrixType((m1 * s).template selfadjointView<Lower>()));
+
+  // l1Norm: reads only the stored triangle but must agree with the L1 norm of
+  // the materialized full matrix. Upper and Lower views of the same (stored-
+  // full) self-adjoint matrix must return the same value; complex scalars
+  // behave identically since |conj(x)| = |x|.
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  m3 = m1.template selfadjointView<Upper>();  // m3 is now fully self-adjoint
+  RealScalar ref_l1 = m3.cwiseAbs().colwise().sum().maxCoeff();
+  VERIFY_IS_APPROX(m3.template selfadjointView<Upper>().l1Norm(), ref_l1);
+  VERIFY_IS_APPROX(m3.template selfadjointView<Lower>().l1Norm(), ref_l1);
+  // Either triangle alone still gives the correct L1 norm even if the other
+  // half is zero (the view conjure it back via symmetry).
+  MatrixType upperOnly = MatrixType::Zero(rows, cols);
+  upperOnly.template triangularView<Upper>() = m3;
+  VERIFY_IS_APPROX(upperOnly.template selfadjointView<Upper>().l1Norm(), ref_l1);
+  MatrixType lowerOnly = MatrixType::Zero(rows, cols);
+  lowerOnly.template triangularView<Lower>() = m3;
+  VERIFY_IS_APPROX(lowerOnly.template selfadjointView<Lower>().l1Norm(), ref_l1);
+}
+
+// l1Norm switches from a per-column to a streaming form at a small size and its column pass has
+// packet tails, so sweep sizes around the switch and across packet boundaries: a mis-sized
+// segment would otherwise hide between the random sizes above.
+template <typename Scalar>
+void selfadjoint_l1norm_sizes() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  for (Index n : {Index(0), Index(1), Index(2), Index(15), Index(16), Index(17), Index(63), Index(64), Index(65),
+                  Index(127), Index(128), Index(129)}) {
+    MatrixType m = MatrixType::Random(n, n);
+    MatrixType full = m.template selfadjointView<Lower>();
+    RealScalar ref = n == 0 ? RealScalar(0) : full.cwiseAbs().colwise().sum().maxCoeff();
+    VERIFY_IS_APPROX(m.template selfadjointView<Lower>().l1Norm(), ref);
+    VERIFY_IS_APPROX(full.template selfadjointView<Upper>().l1Norm(), ref);
+  }
+}
+
+// The vectorized complex path squares the parts, so entries beyond the square-root range of the
+// scalar must come back through the scalar fallback: squares that overflow, and squares that
+// land in the denormals and lose precision.
+template <typename Scalar>
+void selfadjoint_l1norm_range() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  Index n = 70;
+  MatrixType m = MatrixType::Random(n, n);
+  RealScalar big = numext::sqrt(NumTraits<RealScalar>::highest()) * RealScalar(1e3);
+  RealScalar small = numext::sqrt((std::numeric_limits<RealScalar>::min)()) * RealScalar(1e-3);
+  for (RealScalar scale : {big, small}) {
+    MatrixType ms = m * scale;
+    MatrixType full = ms.template selfadjointView<Lower>();
+    RealScalar ref = full.cwiseAbs().colwise().sum().maxCoeff();
+    VERIFY_IS_APPROX(ms.template selfadjointView<Lower>().l1Norm(), ref);
+    VERIFY_IS_APPROX(full.template selfadjointView<Upper>().l1Norm(), ref);
+  }
+}
+
+// half and bfloat16 accumulate the norm in float, so only the final rounding to the scalar separates
+// the result from a float reference, not the size of the matrix.
+template <typename Scalar>
+void selfadjoint_l1norm_lowprec() {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+  for (Index n : {Index(8), Index(64), Index(300)}) {
+    MatrixType m = MatrixType::Random(n, n).template selfadjointView<Lower>();
+    float ref = m.template cast<float>().cwiseAbs().colwise().sum().maxCoeff();
+    float tol = 2 * float(NumTraits<Scalar>::epsilon()) * ref;
+    VERIFY(numext::abs(float(m.template selfadjointView<Lower>().l1Norm()) - ref) <= tol);
+    VERIFY(numext::abs(float(m.template selfadjointView<Upper>().l1Norm()) - ref) <= tol);
+  }
+}
+
+// Narrow integers promote when added: the column totals must be materialized in the scalar type
+// before they are compared (n=2 takes the per-column form, n=8 the column pass).
+template <typename Scalar>
+void selfadjoint_l1norm_integer() {
+  for (Index n : {Index(2), Index(8)}) {
+    typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+    // Random() spans the whole range; keep the column sums representable.
+    MatrixType m = (MatrixType::Random(n, n) / Scalar(NumTraits<Scalar>::highest() / 16)).eval();
+    m = m.template selfadjointView<Lower>();
+    Scalar ref = m.template cast<int>().cwiseAbs().colwise().sum().maxCoeff();
+    VERIFY_IS_EQUAL(m.template selfadjointView<Lower>().l1Norm(), ref);
+    VERIFY_IS_EQUAL(m.template selfadjointView<Upper>().l1Norm(), ref);
+  }
 }
 
 void bug_159() {
   Matrix3d m = Matrix3d::Random().selfadjointView<Lower>();
-  EIGEN_UNUSED_VARIABLE(m)
+  EIGEN_UNUSED_VARIABLE(m);
 }
 
 EIGEN_DECLARE_TEST(selfadjoint) {
@@ -58,9 +155,19 @@
     CALL_SUBTEST_3(selfadjoint(Matrix3cf()));
     CALL_SUBTEST_4(selfadjoint(MatrixXcd(s, s)));
     CALL_SUBTEST_5(selfadjoint(Matrix<float, Dynamic, Dynamic, RowMajor>(s, s)));
+    CALL_SUBTEST_6(selfadjoint(Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>(s, s)));
 
-    TEST_SET_BUT_UNUSED_VARIABLE(s)
+    TEST_SET_BUT_UNUSED_VARIABLE(s);
   }
 
   CALL_SUBTEST_1(bug_159());
+  CALL_SUBTEST_4(selfadjoint_l1norm_sizes<double>());
+  CALL_SUBTEST_4(selfadjoint_l1norm_sizes<std::complex<double> >());
+  CALL_SUBTEST_6(selfadjoint_l1norm_sizes<std::complex<float> >());
+  CALL_SUBTEST_4(selfadjoint_l1norm_range<std::complex<double> >());
+  CALL_SUBTEST_6(selfadjoint_l1norm_range<std::complex<float> >());
+  CALL_SUBTEST_1(selfadjoint_l1norm_integer<short>());
+  CALL_SUBTEST_1(selfadjoint_l1norm_integer<int>());
+  CALL_SUBTEST_7(selfadjoint_l1norm_lowprec<half>());
+  CALL_SUBTEST_7(selfadjoint_l1norm_lowprec<bfloat16>());
 }
diff --git a/test/serializer.cpp b/test/serializer.cpp
index 0c8416f..93342e1 100644
--- a/test/serializer.cpp
+++ b/test/serializer.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/simplicial_cholesky.cpp b/test/simplicial_cholesky.cpp
index ed93218..6f058d5 100644
--- a/test/simplicial_cholesky.cpp
+++ b/test/simplicial_cholesky.cpp
@@ -6,9 +6,65 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse_solver.h"
 
+template <typename Solver>
+void verify_determinant_asserts(const Solver& solver) {
+  VERIFY_RAISES_ASSERT(solver.determinant());
+  VERIFY_RAISES_ASSERT(solver.absDeterminant());
+  VERIFY_RAISES_ASSERT(solver.logAbsDeterminant());
+  VERIFY_RAISES_ASSERT(solver.signDeterminant());
+}
+
+// factorize_preordered() breaks out of its column loop on a bad pivot but still sets m_factorizationIsOk,
+// leaving the tail of D -- and of L's diagonal -- unwritten. The determinant accessors read exactly those,
+// so they check info() too, as the dense LLT ones do.
+template <typename SparseMatrixType>
+void test_simplicial_cholesky_determinant_asserts() {
+  typedef typename SparseMatrixType::Scalar Scalar;
+  const Index n = 6;
+
+  // A zero pivot stops all four classes; SimplicialLLT alone also rejects a negative one.
+  SparseMatrixType zero_pivot(n, n), negative_pivot(n, n);
+  for (Index i = 0; i < n; ++i) {
+    zero_pivot.insert(i, i) = (i == 0) ? Scalar(0) : Scalar(1);
+    negative_pivot.insert(i, i) = (i == n - 1) ? Scalar(-1) : Scalar(1);
+  }
+  zero_pivot.makeCompressed();
+  negative_pivot.makeCompressed();
+
+  SimplicialLLT<SparseMatrixType> llt(zero_pivot);
+  VERIFY(llt.info() == NumericalIssue);
+  verify_determinant_asserts(llt);
+
+  SimplicialLLT<SparseMatrixType> indefinite_llt(negative_pivot);
+  VERIFY(indefinite_llt.info() == NumericalIssue);
+  verify_determinant_asserts(indefinite_llt);
+
+  SimplicialLDLT<SparseMatrixType> ldlt(zero_pivot);
+  VERIFY(ldlt.info() == NumericalIssue);
+  verify_determinant_asserts(ldlt);
+
+  SimplicialNonHermitianLLT<SparseMatrixType> nhllt(zero_pivot);
+  VERIFY(nhllt.info() == NumericalIssue);
+  verify_determinant_asserts(nhllt);
+
+  SimplicialNonHermitianLDLT<SparseMatrixType> nhldlt(zero_pivot);
+  VERIFY(nhldlt.info() == NumericalIssue);
+  verify_determinant_asserts(nhldlt);
+
+  // The deprecated SimplicialCholesky exposes determinant() alone, and reads the same tail.
+  SimplicialCholesky<SparseMatrixType> deprecated(zero_pivot);
+  VERIFY(deprecated.info() == NumericalIssue);
+  VERIFY_RAISES_ASSERT(deprecated.determinant());
+
+  // info() alone would not reject an unfactorized decomposition: it is constructed Success.
+  SimplicialLDLT<SparseMatrixType> unfactorized;
+  verify_determinant_asserts(unfactorized);
+}
+
 template <typename T, typename I_, int flag>
 void test_simplicial_cholesky_T() {
   typedef SparseMatrix<T, flag, I_> SparseMatrixType;
@@ -49,13 +105,64 @@
   check_sparse_nonhermitian_determinant(nhldlt_colmajor_lower_amd);
   check_sparse_nonhermitian_determinant(nhldlt_colmajor_upper_amd);
 
+  check_sparse_spd_log_abs_determinant(llt_colmajor_lower_amd);
+  check_sparse_spd_log_abs_determinant(llt_colmajor_upper_amd);
+  check_sparse_spd_log_abs_determinant(ldlt_colmajor_lower_amd);
+  check_sparse_spd_log_abs_determinant(ldlt_colmajor_upper_amd);
+  check_sparse_nonhermitian_log_abs_determinant(nhllt_colmajor_lower_amd);
+  check_sparse_nonhermitian_log_abs_determinant(nhllt_colmajor_upper_amd);
+  check_sparse_nonhermitian_log_abs_determinant(nhldlt_colmajor_lower_amd);
+  check_sparse_nonhermitian_log_abs_determinant(nhldlt_colmajor_upper_amd);
+
+  test_simplicial_cholesky_determinant_asserts<SparseMatrixType>();
+
   check_sparse_spd_solving(ldlt_colmajor_lower_nat, (std::min)(300, EIGEN_TEST_MAX_SIZE), 1000);
   check_sparse_spd_solving(ldlt_colmajor_upper_nat, (std::min)(300, EIGEN_TEST_MAX_SIZE), 1000);
   check_sparse_nonhermitian_solving(nhldlt_colmajor_lower_nat, (std::min)(300, EIGEN_TEST_MAX_SIZE), 1000);
   check_sparse_nonhermitian_solving(nhldlt_colmajor_upper_nat, (std::min)(300, EIGEN_TEST_MAX_SIZE), 1000);
 }
 
+template <typename Scalar>
+void test_simplicial_cholesky_scatter(Index bandwidth) {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using DenseMatrix = Matrix<Scalar, Dynamic, Dynamic>;
+  using SparseMatrixType = SparseMatrix<Scalar, ColMajor, long long>;
+  const Index n = 67;
+  DenseMatrix matrix = DenseMatrix::Zero(n, n);
+  for (Index j = 0; j < n; ++j) {
+    matrix(j, j) = Scalar(2 * bandwidth + 1);
+    for (Index i = j + 1; i < (std::min)(n, j + bandwidth + 1); ++i) {
+      matrix(i, j) = Scalar(0.125) + Scalar(0.0625) * internal::random<Scalar>();
+      matrix(j, i) = numext::conj(matrix(i, j));
+    }
+  }
+  SparseMatrixType sparse = matrix.sparseView();
+  SimplicialLLT<SparseMatrixType, Lower, NaturalOrdering<long long>> solver;
+  SimplicialLDLT<SparseMatrixType, Lower, NaturalOrdering<long long>> ldlt;
+  solver.analyzePattern(sparse);
+  ldlt.analyzePattern(sparse);
+  // Reconstruction error scales with the O(n * epsilon) factorization backward error.
+  const RealScalar tolerance = RealScalar(16 * n) * NumTraits<RealScalar>::epsilon();
+  DenseMatrix lower;
+  for (int repeat = 0; repeat < 2; ++repeat) {
+    solver.factorize(sparse);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    lower = solver.matrixL();
+    VERIFY((lower * lower.adjoint() - matrix).norm() <= tolerance * matrix.norm());
+    ldlt.factorize(sparse);
+    VERIFY_IS_EQUAL(ldlt.info(), Success);
+    lower = ldlt.matrixL();
+    VERIFY((lower * ldlt.vectorD().asDiagonal() * lower.adjoint() - matrix).norm() <= tolerance * matrix.norm());
+    matrix.diagonal().array() += Scalar(1);
+    sparse.diagonal().array() += Scalar(1);
+  }
+}
+
 EIGEN_DECLARE_TEST(simplicial_cholesky) {
+  CALL_SUBTEST_31(test_simplicial_cholesky_scatter<float>(3));
+  CALL_SUBTEST_31(test_simplicial_cholesky_scatter<float>(37));
+  CALL_SUBTEST_32(test_simplicial_cholesky_scatter<std::complex<float>>(3));
+  CALL_SUBTEST_32(test_simplicial_cholesky_scatter<std::complex<float>>(37));
   CALL_SUBTEST_11((test_simplicial_cholesky_T<double, int, ColMajor>()));
   CALL_SUBTEST_12((test_simplicial_cholesky_T<std::complex<double>, int, ColMajor>()));
   CALL_SUBTEST_13((test_simplicial_cholesky_T<double, long int, ColMajor>()));
diff --git a/test/sizeof.cpp b/test/sizeof.cpp
index b75645f..ef74ad6 100644
--- a/test/sizeof.cpp
+++ b/test/sizeof.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/sizeoverflow.cpp b/test/sizeoverflow.cpp
index 612067f..c6fdf29 100644
--- a/test/sizeoverflow.cpp
+++ b/test/sizeoverflow.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/skew_symmetric_matrix3.cpp b/test/skew_symmetric_matrix3.cpp
index 48d490d..bf57285 100644
--- a/test/skew_symmetric_matrix3.cpp
+++ b/test/skew_symmetric_matrix3.cpp
@@ -4,6 +4,8 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/LU>
@@ -81,6 +83,44 @@
   VERIFY_IS_APPROX((sk1 + sk1).vector(), 2 * v1);
   VERIFY((sk1 - sk1).vector().isZero());
   VERIFY((sk1 - sk1).toDenseMatrix().isZero());
+
+  // Mixed dense / skew-symmetric +/- operators (see issue #2925, MR !2308).
+  // Cases c1/c2/c3 below are exactly the three expressions from the issue.
+  {
+    const SquareMatrix A = SquareMatrix::Random();
+    const Vector b = Vector::Random();
+
+    const SquareMatrix skA = (A * b).asSkewSymmetric().toDenseMatrix();
+    const SquareMatrix skB = v1.asSkewSymmetric().toDenseMatrix();
+    const SquareMatrix skB_times_A = v1.asSkewSymmetric().toDenseMatrix() * A;
+    const SquareMatrix A_times_skB = A * v1.asSkewSymmetric().toDenseMatrix();
+
+    // c1: dense - skew
+    const SquareMatrix c1 = A - SkewSymmetricMatrix3<Scalar>(A * b);
+    VERIFY_IS_APPROX(c1, A - skA);
+
+    // c2: Product<dense,skew> - skew
+    const SquareMatrix c2 = A * SkewSymmetricMatrix3<Scalar>(v1) - SkewSymmetricMatrix3<Scalar>(A * b);
+    VERIFY_IS_APPROX(c2, A_times_skB - skA);
+
+    // c3: Product<skew,dense> - skew
+    const SquareMatrix c3 = SkewSymmetricMatrix3<Scalar>(v1) * A - SkewSymmetricMatrix3<Scalar>(A * b);
+    VERIFY_IS_APPROX(c3, skB_times_A - skA);
+
+    // M + S and S + M (commutativity check).
+    VERIFY_IS_APPROX(SquareMatrix(A + sk1), A + skB);
+    VERIFY_IS_APPROX(SquareMatrix(sk1 + A), skB + A);
+    VERIFY_IS_APPROX(SquareMatrix(A + sk1), SquareMatrix(sk1 + A));
+
+    // M - S and S - M (anti-commutativity sanity).
+    VERIFY_IS_APPROX(SquareMatrix(A - sk1), A - skB);
+    VERIFY_IS_APPROX(SquareMatrix(sk1 - A), skB - A);
+    VERIFY_IS_APPROX(SquareMatrix(A - sk1), -SquareMatrix(sk1 - A));
+
+    // Product expression on the LHS should still fuse (no explicit
+    // .toDenseMatrix() needed on the dense side).
+    VERIFY_IS_APPROX(SquareMatrix(A * A - sk1), (A * A).eval() - skB);
+  }
 }
 
 template <typename Scalar>
@@ -111,6 +151,34 @@
   VERIFY((sk2 * v2).isZero());
 }
 
+template <typename Scalar>
+void skewSymmetricDiagonalProducts() {
+  using Vector = Matrix<Scalar, 3, 1>;
+  using SquareMatrix = Matrix<Scalar, 3, 3>;
+
+  const Vector v = Vector::Random();
+  const Vector d = Vector::Random();
+  const SkewSymmetricMatrix3<Scalar> sk = v.asSkewSymmetric();
+  const DiagonalMatrix<Scalar, 3> dm(d);
+  const SquareMatrix skDense = sk.toDenseMatrix();
+  const SquareMatrix dmDense = dm.toDenseMatrix();
+
+  SquareMatrix result = sk * dm;
+  VERIFY_IS_APPROX(result, skDense * dmDense);
+  result = dm * sk;
+  VERIFY_IS_APPROX(result, dmDense * skDense);
+  result = v.asSkewSymmetric() * d.asDiagonal();
+  VERIFY_IS_APPROX(result, skDense * dmDense);
+  result = d.asDiagonal() * v.asSkewSymmetric();
+  VERIFY_IS_APPROX(result, dmDense * skDense);
+
+  result.setZero();
+  result += sk * dm;
+  result -= dm * sk;
+  VERIFY_IS_APPROX(result, skDense * dmDense - dmDense * skDense);
+  VERIFY_IS_APPROX((sk * dm) * v, skDense * (dmDense * v));
+}
+
 template <typename Matrix>
 void skewSymmetricMultiplication(const Matrix& m) {
   typedef Eigen::Matrix<typename Matrix::Scalar, 3, 1> Vector;
@@ -198,6 +266,8 @@
     CALL_SUBTEST_2(multiplyScale<double>());
     CALL_SUBTEST_2(skewSymmetricMultiplication(MatrixXf(3, internal::random<int>(3, EIGEN_TEST_MAX_SIZE))));
     CALL_SUBTEST_2(skewSymmetricMultiplication(MatrixXd(3, internal::random<int>(3, EIGEN_TEST_MAX_SIZE))));
+    CALL_SUBTEST_2(skewSymmetricDiagonalProducts<float>());
+    CALL_SUBTEST_2(skewSymmetricDiagonalProducts<double>());
     CALL_SUBTEST_2(traceAndDet<float>());
     CALL_SUBTEST_2(traceAndDet<double>());
     CALL_SUBTEST_2(transpose<float>());
diff --git a/test/smallvectors.cpp b/test/smallvectors.cpp
index 682b118..52b2bad 100644
--- a/test/smallvectors.cpp
+++ b/test/smallvectors.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/solverbase.h b/test/solverbase.h
index f353943..e8f2e53 100644
--- a/test/solverbase.h
+++ b/test/solverbase.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
 #ifndef TEST_SOLVERBASE_H
 #define TEST_SOLVERBASE_H
 
@@ -36,4 +39,39 @@
   VERIFY_IS_APPROX(matrix * m2, matrix * solver_solution);
 }
 
+// Induced 1-norm, the reference for condition estimates.
+template <typename MatrixType>
+typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
+  return m.cwiseAbs().colwise().sum().maxCoeff();
+}
+
+// Induced 1-norm of the self-adjoint matrix stored in the UpLo triangle of m.
+template <typename MatrixType, int UpLo>
+typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
+  if (m.cols() == 0) return typename MatrixType::RealScalar(0);
+  MatrixType symm = m.template selfadjointView<UpLo>();
+  return symm.cwiseAbs().colwise().sum().maxCoeff();
+}
+
+// Checks the four determinant accessors of a decomposition against a reference determinant \a det and a
+// reference \a logabsdet = log|det| formed independently of it. Callers must keep \a det itself in range.
+template <typename SolverType, typename Scalar>
+void check_determinant(const SolverType& solver, const Scalar& det, const typename NumTraits<Scalar>::Real& logabsdet) {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  VERIFY_IS_APPROX(solver.determinant(), det);
+  VERIFY_IS_APPROX(solver.absDeterminant(), numext::abs(det));
+  // log|det| passes through zero, where a relative comparison says nothing; bound the error absolutely.
+  VERIFY_IS_MUCH_SMALLER_THAN(solver.logAbsDeterminant() - logabsdet, RealScalar(1));
+  VERIFY_IS_APPROX(solver.signDeterminant(), numext::sign(det));
+}
+
+// True when |det| has left the representable range in the direction it was expected to: exactly infinity
+// where the determinant overflowed, exactly zero where it underflowed. logAbsDeterminant() is still
+// meaningful there; determinant() and absDeterminant() are not. A NaN is neither, and testing !isfinite()
+// would accept one -- with it any inf - inf or 0 * inf artifact.
+template <typename RealScalar>
+bool determinant_out_of_range(const RealScalar& absdet, bool overflow) {
+  return overflow ? numext::equal_strict(absdet, NumTraits<RealScalar>::infinity()) : numext::is_exactly_zero(absdet);
+}
+
 #endif  // TEST_SOLVERBASE_H
diff --git a/test/sparse.h b/test/sparse.h
index 1f4a166..ade6d7c 100644
--- a/test/sparse.h
+++ b/test/sparse.h
@@ -6,12 +6,11 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_TESTSPARSE_H
 #define EIGEN_TESTSPARSE_H
 
-#define EIGEN_YES_I_KNOW_SPARSE_MODULE_IS_NOT_STABLE_YET
-
 #include "main.h"
 
 #ifdef min
@@ -23,7 +22,6 @@
 #endif
 
 #include <unordered_map>
-#define EIGEN_UNORDERED_MAP_SUPPORT
 
 #include <Eigen/Cholesky>
 #include <Eigen/LU>
diff --git a/test/sparseLM.cpp b/test/sparseLM.cpp
deleted file mode 100644
index 0cb4d3a..0000000
--- a/test/sparseLM.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
-// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-
-#include "main.h"
-#include <Eigen/LevenbergMarquardt>
-
-using namespace std;
-using namespace Eigen;
-
-template <typename Scalar>
-struct sparseGaussianTest : SparseFunctor<Scalar, int> {
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef SparseFunctor<Scalar, int> Base;
-  typedef typename Base::JacobianType JacobianType;
-  sparseGaussianTest(int inputs, int values) : SparseFunctor<Scalar, int>(inputs, values) {}
-
-  VectorType model(const VectorType& uv, VectorType& x) {
-    VectorType y;  // Change this to use expression template
-    int m = Base::values();
-    int n = Base::inputs();
-    eigen_assert(uv.size() % 2 == 0);
-    eigen_assert(uv.size() == n);
-    eigen_assert(x.size() == m);
-    y.setZero(m);
-    int half = n / 2;
-    VectorBlock<const VectorType> u(uv, 0, half);
-    VectorBlock<const VectorType> v(uv, half, half);
-    Scalar coeff;
-    for (int j = 0; j < m; j++) {
-      for (int i = 0; i < half; i++) {
-        coeff = (x(j) - i) / v(i);
-        coeff *= coeff;
-        if (coeff < 1. && coeff > 0.) y(j) += u(i) * std::pow((1 - coeff), 2);
-      }
-    }
-    return y;
-  }
-  void initPoints(VectorType& uv_ref, VectorType& x) {
-    m_x = x;
-    m_y = this->model(uv_ref, x);
-  }
-  int operator()(const VectorType& uv, VectorType& fvec) {
-    int m = Base::values();
-    int n = Base::inputs();
-    eigen_assert(uv.size() % 2 == 0);
-    eigen_assert(uv.size() == n);
-    int half = n / 2;
-    VectorBlock<const VectorType> u(uv, 0, half);
-    VectorBlock<const VectorType> v(uv, half, half);
-    fvec = m_y;
-    Scalar coeff;
-    for (int j = 0; j < m; j++) {
-      for (int i = 0; i < half; i++) {
-        coeff = (m_x(j) - i) / v(i);
-        coeff *= coeff;
-        if (coeff < 1. && coeff > 0.) fvec(j) -= u(i) * std::pow((1 - coeff), 2);
-      }
-    }
-    return 0;
-  }
-
-  int df(const VectorType& uv, JacobianType& fjac) {
-    int m = Base::values();
-    int n = Base::inputs();
-    eigen_assert(n == uv.size());
-    eigen_assert(fjac.rows() == m);
-    eigen_assert(fjac.cols() == n);
-    int half = n / 2;
-    VectorBlock<const VectorType> u(uv, 0, half);
-    VectorBlock<const VectorType> v(uv, half, half);
-    Scalar coeff;
-
-    // Derivatives with respect to u
-    for (int col = 0; col < half; col++) {
-      for (int row = 0; row < m; row++) {
-        coeff = (m_x(row) - col) / v(col);
-        coeff = coeff * coeff;
-        if (coeff < 1. && coeff > 0.) {
-          fjac.coeffRef(row, col) = -(1 - coeff) * (1 - coeff);
-        }
-      }
-    }
-    // Derivatives with respect to v
-    for (int col = 0; col < half; col++) {
-      for (int row = 0; row < m; row++) {
-        coeff = (m_x(row) - col) / v(col);
-        coeff = coeff * coeff;
-        if (coeff < 1. && coeff > 0.) {
-          fjac.coeffRef(row, col + half) = -4 * (u(col) / v(col)) * coeff * (1 - coeff);
-        }
-      }
-    }
-    return 0;
-  }
-
-  VectorType m_x, m_y;  // Data points
-};
-
-template <typename T>
-void test_sparseLM_T() {
-  typedef Matrix<T, Dynamic, 1> VectorType;
-
-  int inputs = 10;
-  int values = 2000;
-  sparseGaussianTest<T> sparse_gaussian(inputs, values);
-  VectorType uv(inputs), uv_ref(inputs);
-  VectorType x(values);
-  // Generate the reference solution
-  uv_ref << -2, 1, 4, 8, 6, 1.8, 1.2, 1.1, 1.9, 3;
-  // Generate the reference data points
-  x.setRandom();
-  x = 10 * x;
-  x.array() += 10;
-  sparse_gaussian.initPoints(uv_ref, x);
-
-  // Generate the initial parameters
-  VectorBlock<VectorType> u(uv, 0, inputs / 2);
-  VectorBlock<VectorType> v(uv, inputs / 2, inputs / 2);
-  v.setOnes();
-  // Generate u or Solve for u from v
-  u.setOnes();
-
-  // Solve the optimization problem
-  LevenbergMarquardt<sparseGaussianTest<T> > lm(sparse_gaussian);
-  int info;
-  //   info = lm.minimize(uv);
-
-  VERIFY_IS_EQUAL(info, 1);
-  // Do a step by step solution and save the residual
-  int maxiter = 200;
-  int iter = 0;
-  MatrixXd Err(values, maxiter);
-  MatrixXd Mod(values, maxiter);
-  LevenbergMarquardtSpace::Status status;
-  status = lm.minimizeInit(uv);
-  if (status == LevenbergMarquardtSpace::ImproperInputParameters) return;
-}
-EIGEN_DECLARE_TEST(sparseLM) {
-  CALL_SUBTEST_1(test_sparseLM_T<double>());
-
-  // CALL_SUBTEST_2(test_sparseLM_T<std::complex<double>());
-}
diff --git a/test/sparse_basic.cpp b/test/sparse_basic.cpp
index f1fd6b7..12b1f70 100644
--- a/test/sparse_basic.cpp
+++ b/test/sparse_basic.cpp
@@ -8,6 +8,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_SPARSE_TEST_INCLUDED_FROM_SPARSE_EXTRA
 static long g_realloc_count = 0;
@@ -54,7 +55,7 @@
     // test coeff and coeffRef
     for (std::size_t i = 0; i < zeroCoords.size(); ++i) {
       VERIFY_IS_MUCH_SMALLER_THAN(m.coeff(zeroCoords[i].x(), zeroCoords[i].y()), eps);
-      if (internal::is_same<SparseMatrixType, SparseMatrix<Scalar, Flags>>::value)
+      if (std::is_same<SparseMatrixType, SparseMatrix<Scalar, Flags>>::value)
         VERIFY_RAISES_ASSERT(m.coeffRef(zeroCoords[i].x(), zeroCoords[i].y()) = 5);
     }
     VERIFY_IS_APPROX(m, refMat);
@@ -339,10 +340,6 @@
     VERIFY_IS_APPROX((RealScalar(0.5) * refM4 + m3.cwiseProduct(m3)).eval(),
                      RealScalar(0.5) * refM4 + refM3.cwiseProduct(refM3));
 
-    VERIFY_IS_APPROX((RealScalar(0.5) * refM4 + RealScalar(0.5) * m3).eval(),
-                     RealScalar(0.5) * refM4 + RealScalar(0.5) * refM3);
-    VERIFY_IS_APPROX((RealScalar(0.5) * refM4 + m3 * RealScalar(0.5)).eval(),
-                     RealScalar(0.5) * refM4 + RealScalar(0.5) * refM3);
     VERIFY_IS_APPROX((RealScalar(0.5) * refM4 + (m3 + m3)).eval(), RealScalar(0.5) * refM4 + (refM3 + refM3));
     VERIFY_IS_APPROX(((refM3 + m3) + RealScalar(0.5) * m3).eval(), RealScalar(0.5) * refM3 + (refM3 + refM3));
     VERIFY_IS_APPROX((RealScalar(0.5) * refM4 + (refM3 + m3)).eval(), RealScalar(0.5) * refM4 + (refM3 + refM3));
@@ -548,6 +545,9 @@
       triplets.push_back(TripletType(r, c, v));
       refMat_sum(r, c) += v;
     }
+    triplets.emplace_back(0, 0, Scalar(0));
+    triplets.emplace_back(0, 0, Scalar(2));
+    refMat_sum(0, 0) += Scalar(2);
 
     std::vector<TripletType> moreTriplets;
     moreTriplets.reserve(ntriplets);
@@ -560,6 +560,9 @@
       moreTriplets.push_back(TripletType(r, c, v));
       refMat_sum_more(r, c) += v;
     }
+    moreTriplets.emplace_back(0, 0, Scalar(0));
+    moreTriplets.emplace_back(0, 0, Scalar(3));
+    refMat_sum_more(0, 0) += Scalar(3);
 
     // setFromTriplets sorts internally by (outer, inner), so non-commutative
     // reductions (std::multiplies, "last wins") depend on sorted order.
@@ -573,14 +576,17 @@
 
     DenseMatrix refMat_prod = DenseMatrix::Zero(rows, cols);
     DenseMatrix refMat_last = DenseMatrix::Zero(rows, cols);
+    // A stored zero still participates in duplicate reductions.
+    Matrix<bool, Dynamic, Dynamic> visited = Matrix<bool, Dynamic, Dynamic>::Constant(rows, cols, false);
     {
       auto sorted = triplets;
       std::stable_sort(sorted.begin(), sorted.end(), triplet_comp());
       for (const auto& t : sorted) {
-        if (std::abs(refMat_prod(t.row(), t.col())) == 0)
+        if (!visited(t.row(), t.col()))
           refMat_prod(t.row(), t.col()) = t.value();
         else
           refMat_prod(t.row(), t.col()) *= t.value();
+        visited(t.row(), t.col()) = true;
         refMat_last(t.row(), t.col()) = t.value();
       }
     }
@@ -591,10 +597,11 @@
       auto sorted = moreTriplets;
       std::stable_sort(sorted.begin(), sorted.end(), triplet_comp());
       for (const auto& t : sorted) {
-        if (std::abs(refMat_prod_more(t.row(), t.col())) == 0)
+        if (!visited(t.row(), t.col()))
           refMat_prod_more(t.row(), t.col()) = t.value();
         else
           refMat_prod_more(t.row(), t.col()) *= t.value();
+        visited(t.row(), t.col()) = true;
         refMat_last_more(t.row(), t.col()) = t.value();
       }
     }
@@ -796,10 +803,28 @@
     m3 -= m2.template selfadjointView<Lower>();
     VERIFY_IS_APPROX(m3, refMat3);
 
+    Scalar s2 = internal::random<Scalar>();
+    refMat3 = DenseMatrix(refMat2.template selfadjointView<Upper>());
+    refMat3 *= s2;
+    SparseMatrixType m4 = s2 * m2.template selfadjointView<Upper>();
+    VERIFY_IS_APPROX(m4, refMat3);
+    refMat3 = DenseMatrix(refMat2.template selfadjointView<Upper>());
+    refMat3 *= s2;
+    m4 = m2.template selfadjointView<Upper>() * s2;
+    VERIFY_IS_APPROX(m4, refMat3);
+    refMat3 = DenseMatrix(refMat2.template selfadjointView<Lower>());
+    refMat3 *= s2;
+    m4 = s2 * m2.template selfadjointView<Lower>();
+    VERIFY_IS_APPROX(m4, refMat3);
+    refMat3 = DenseMatrix(refMat2.template selfadjointView<Lower>());
+    refMat3 *= s2;
+    m4 = m2.template selfadjointView<Lower>() * s2;
+    VERIFY_IS_APPROX(m4, refMat3);
+
     // selfadjointView only works for square matrices:
-    SparseMatrixType m4(rows, rows + 1);
-    VERIFY_RAISES_ASSERT(m4.template selfadjointView<Lower>());
-    VERIFY_RAISES_ASSERT(m4.template selfadjointView<Upper>());
+    SparseMatrixType m5(rows, rows + 1);
+    VERIFY_RAISES_ASSERT(m5.template selfadjointView<Lower>());
+    VERIFY_RAISES_ASSERT(m5.template selfadjointView<Upper>());
   }
 
   // test sparseView
@@ -916,6 +941,38 @@
     }
   }
 
+  // test resize / conservativeResize with Eigen::NoChange (bug #656)
+  {
+    SparseMatrixType m1(rows, cols);
+    DenseMatrix refMat1 = DenseMatrix::Zero(rows, cols);
+    initSparse<Scalar>(density, refMat1, m1);
+
+    SparseMatrixType m2 = m1;
+
+    m1.conservativeResize(NoChange, cols + 2);
+    refMat1.conservativeResize(NoChange, cols + 2);
+    refMat1.rightCols(2).setZero();
+    VERIFY_IS_APPROX(m1, refMat1);
+
+    m1.conservativeResize(rows + 1, NoChange);
+    refMat1.conservativeResize(rows + 1, NoChange);
+    refMat1.bottomRows(1).setZero();
+    VERIFY_IS_APPROX(m1, refMat1);
+
+    m2.resize(NoChange, cols + 4);
+    VERIFY(m2.rows() == rows && m2.cols() == cols + 4);
+    VERIFY(m2.nonZeros() == 0);
+
+    m2.resize(rows + 2, NoChange);
+    VERIFY(m2.rows() == rows + 2 && m2.cols() == cols + 4);
+
+    SparseVector<Scalar, ColMajor, StorageIndex> v(rows);
+    v.resize(NoChange, 1);
+    VERIFY(v.size() == rows);
+    v.resize(rows + 3, NoChange);
+    VERIFY(v.size() == rows + 3);
+  }
+
   // test Identity matrix
   {
     DenseMatrix refMat1 = DenseMatrix::Identity(rows, rows);
@@ -962,6 +1019,32 @@
     iters[1] = IteratorType(m2, m2.outerSize() - 1);
   }
 
+  // test InnerIterator equality (bug #1192)
+  {
+    typedef typename SparseMatrixType::InnerIterator IteratorType;
+    SparseMatrixType m2(rows, cols);
+    DenseMatrix refMat2 = DenseMatrix::Zero(rows, cols);
+    initSparse<Scalar>(density, refMat2, m2);
+    Index outer_with_two = -1;
+    for (Index o = 0; o < m2.outerSize(); ++o)
+      if (m2.innerVector(o).nonZeros() >= 2) {
+        outer_with_two = o;
+        break;
+      }
+    if (outer_with_two >= 0) {
+      IteratorType a(m2, outer_with_two), b(m2, outer_with_two);
+      VERIFY(a == b);
+      ++b;
+      VERIFY(a != b);
+      VERIFY(!(a == b));
+      ++a;
+      VERIFY(a == b);
+      while (a) ++a;
+      while (b) ++b;
+      VERIFY(a == b);
+    }
+  }
+
   // test reserve with empty rows/columns
   {
     SparseMatrixType m1(0, cols);
@@ -1017,6 +1100,235 @@
   VERIFY_IS_APPROX(sum, m.sum());
 }
 
+// Regression test: SparseMatrixBase::operator-=(const EigenBase&) must subtract, not overwrite.
+// SparseSelfAdjointView inherits EigenBase (not SparseMatrixBase), so it exercises this overload.
+template <int>
+void sparse_sub_assign_eigenbase() {
+  Index n = 10;
+  SparseMatrix<double> A(n, n), B(n, n);
+  A.setIdentity();
+  B.setIdentity();
+  B *= 3.0;
+
+  // Make B symmetric so selfadjointView is valid
+  MatrixXd refA = MatrixXd(A);
+  MatrixXd refB = MatrixXd(B);
+
+  // operator-= going through the EigenBase<OtherDerived> overload
+  A -= B.selfadjointView<Lower>();
+  refA -= refB.selfadjointView<Lower>();
+  VERIFY_IS_APPROX(MatrixXd(A), refA);
+
+  // Also test operator+= for symmetry
+  A += B.selfadjointView<Lower>();
+  refA += refB.selfadjointView<Lower>();
+  VERIFY_IS_APPROX(MatrixXd(A), refA);
+}
+
+// Regression test: AmbiVector::coeff() must return the correct linked-list element.
+template <int>
+void ambivector_coeff() {
+  using namespace Eigen::internal;
+  const Index size = 20;
+  AmbiVector<double, int> vec(size);
+  vec.setBounds(0, size);
+
+  // Test in sparse (linked-list) mode
+  vec.init(IsSparse);
+  vec.restart();
+  // Insert elements out of order to stress linked-list traversal:
+  // Insert at indices 2, 5, 10, 15 with distinct values
+  vec.coeffRef(2) = 2.0;
+  vec.coeffRef(5) = 5.0;
+  vec.coeffRef(10) = 10.0;
+  vec.coeffRef(15) = 15.0;
+
+  // coeff() should return the correct value for each inserted element
+  VERIFY_IS_APPROX(vec.coeff(2), 2.0);
+  VERIFY_IS_APPROX(vec.coeff(5), 5.0);
+  VERIFY_IS_APPROX(vec.coeff(10), 10.0);
+  VERIFY_IS_APPROX(vec.coeff(15), 15.0);
+
+  // coeff() should return zero for non-inserted elements
+  VERIFY_IS_EQUAL(vec.coeff(0), 0.0);
+  VERIFY_IS_EQUAL(vec.coeff(3), 0.0);
+  VERIFY_IS_EQUAL(vec.coeff(7), 0.0);
+  VERIFY_IS_EQUAL(vec.coeff(18), 0.0);
+
+  // Verify coeff() still works after coeffRef() advances m_llCurrent.
+  // This is the specific scenario that triggered the bug: coeffRef(15)
+  // leaves m_llCurrent pointing at element 15, then coeff(2) should
+  // still return 2.0, not 15.0.
+  vec.restart();
+  vec.coeffRef(15) += 0.0;  // advances m_llCurrent to element at index 15
+  VERIFY_IS_APPROX(vec.coeff(2), 2.0);
+  VERIFY_IS_APPROX(vec.coeff(5), 5.0);
+
+  // Test in dense mode as well (simpler, but for completeness)
+  vec.init(IsDense);
+  vec.setZero();
+  vec.coeffRef(3) = 3.0;
+  vec.coeffRef(7) = 7.0;
+  VERIFY_IS_APPROX(vec.coeff(3), 3.0);
+  VERIFY_IS_APPROX(vec.coeff(7), 7.0);
+  VERIFY_IS_EQUAL(vec.coeff(0), 0.0);
+}
+
+template <typename Pattern, typename SparseMatrixType>
+void verify_sparsity_pattern_ref_matches(const Pattern& pattern, const SparseMatrixType& expected) {
+  VERIFY_IS_EQUAL(pattern.outerSize, expected.cols());
+  VERIFY_IS_EQUAL(pattern.innerSize, expected.rows());
+
+  Index pattern_nonzeros = 0;
+  for (Index j = 0; j < pattern.outerSize; ++j) {
+    const Index nz = pattern.nonZeros(j);
+    pattern_nonzeros += nz;
+    for (Index k = pattern.outer[j], end = k + nz; k < end; ++k) {
+      VERIFY(expected.coeff(pattern.inner[k], j) != typename SparseMatrixType::Scalar(0));
+    }
+  }
+  VERIFY_IS_EQUAL(pattern_nonzeros, expected.nonZeros());
+}
+
+template <int>
+void sparsity_pattern_ref_sparse_expressions() {
+  typedef std::complex<double> Scalar;
+  typedef SparseMatrix<Scalar, ColMajor, int> SparseMatrixType;
+  typedef SparseMatrix<double, ColMajor, int> RealSparseMatrixType;
+  typedef SparseMatrix<double, RowMajor, int> RowMajorSparseMatrixType;
+  typedef Matrix<int, Dynamic, 1> VectorI;
+
+  SparseMatrixType a(3, 3);
+  std::vector<Triplet<Scalar, int>> triplets;
+  triplets.emplace_back(0, 0, Scalar(1.0, 1.0));
+  triplets.emplace_back(1, 0, Scalar(2.0, -1.0));
+  triplets.emplace_back(2, 1, Scalar(3.0, 2.0));
+  triplets.emplace_back(2, 2, Scalar(4.0, -3.0));
+  a.setFromTriplets(triplets.begin(), triplets.end());
+
+  PermutationMatrix<Dynamic, Dynamic, int> p(3);
+  p.indices() << 1, 2, 0;
+
+  VectorI outer, inner;
+  SparseMatrixType permuted = p * a;
+  const internal::SparsityPatternRef<int> permuted_pattern = internal::make_col_major_pattern_ref(p * a, outer, inner);
+  verify_sparsity_pattern_ref_matches(permuted_pattern, permuted);
+
+  RealSparseMatrixType real_part = a.real();
+  const internal::SparsityPatternRef<int> real_pattern = internal::make_col_major_pattern_ref(a.real(), outer, inner);
+  verify_sparsity_pattern_ref_matches(real_pattern, real_part);
+
+  RowMajorSparseMatrixType row_major = real_part;
+  const internal::SparsityPatternRef<int> row_major_pattern =
+      internal::make_col_major_pattern_ref(row_major, outer, inner);
+  verify_sparsity_pattern_ref_matches(row_major_pattern, real_part);
+}
+
+// Verify that two compressed column-major sparse matrices have the same
+// sparsity pattern (rows, cols, and per-column inner indices).
+template <typename SparseA, typename SparseB>
+void verify_same_pattern(const SparseA& got, const SparseB& expected) {
+  VERIFY_IS_EQUAL(got.rows(), expected.rows());
+  VERIFY_IS_EQUAL(got.cols(), expected.cols());
+  for (Index j = 0; j < expected.cols(); ++j) {
+    std::vector<Index> got_rows, expected_rows;
+    for (typename SparseA::InnerIterator it(got, j); it; ++it) got_rows.push_back(it.row());
+    for (typename SparseB::InnerIterator it(expected, j); it; ++it) expected_rows.push_back(it.row());
+    std::sort(got_rows.begin(), got_rows.end());
+    std::sort(expected_rows.begin(), expected_rows.end());
+    VERIFY_IS_EQUAL(Index(got_rows.size()), Index(expected_rows.size()));
+    for (size_t k = 0; k < got_rows.size(); ++k) VERIFY_IS_EQUAL(got_rows[k], expected_rows[k]);
+  }
+}
+
+template <int>
+void materialize_at_plus_a_pattern_basic() {
+  typedef SparseMatrix<double, ColMajor, int> SparseMatrixType;
+  typedef SparseMatrix<signed char, ColMajor, int> PatternMatrixType;
+  typedef Matrix<int, Dynamic, 1> VectorI;
+
+  // Asymmetric pattern: (0,0), (1,0), (2,1), (0,2), (2,2). Its A^T+A pattern
+  // adds (0,1), (1,2), (2,0).
+  SparseMatrixType a(3, 3);
+  std::vector<Triplet<double, int>> triplets;
+  triplets.emplace_back(0, 0, 1.0);
+  triplets.emplace_back(1, 0, 2.0);
+  triplets.emplace_back(2, 1, 3.0);
+  triplets.emplace_back(0, 2, 4.0);
+  triplets.emplace_back(2, 2, 5.0);
+  a.setFromTriplets(triplets.begin(), triplets.end());
+
+  VectorI outer, inner;
+  internal::SparsityPatternRef<int> pat = internal::make_col_major_pattern_ref(a, outer, inner);
+
+  PatternMatrixType got;
+  internal::materialize_at_plus_a_pattern(pat, got);
+
+  // Reference: pattern of (a + a.transpose()), keeping structural nonzeros.
+  SparseMatrixType expected = a + SparseMatrixType(a.transpose());
+  verify_same_pattern(got, expected);
+  // Output values must be the placeholder sentinel.
+  const signed char one = 1;
+  for (Index j = 0; j < got.cols(); ++j) {
+    for (PatternMatrixType::InnerIterator it(got, j); it; ++it) {
+      VERIFY_IS_EQUAL(it.value(), one);
+    }
+  }
+}
+
+template <int>
+void materialize_at_plus_a_pattern_random() {
+  typedef SparseMatrix<double, ColMajor, int> SparseMatrixType;
+  typedef SparseMatrix<signed char, ColMajor, int> PatternMatrixType;
+  typedef Matrix<double, Dynamic, Dynamic, ColMajor> DenseMatrixType;
+  typedef Matrix<int, Dynamic, 1> VectorI;
+
+  const int n = internal::random<int>(8, 64);
+  DenseMatrixType ref(n, n);
+  SparseMatrixType a(n, n);
+  initSparse<double>(0.4, ref, a, ForceNonZeroDiag);
+
+  VectorI outer, inner;
+  internal::SparsityPatternRef<int> pat = internal::make_col_major_pattern_ref(a, outer, inner);
+  PatternMatrixType got;
+  internal::materialize_at_plus_a_pattern(pat, got);
+
+  SparseMatrixType expected = a + SparseMatrixType(a.transpose());
+  verify_same_pattern(got, expected);
+}
+
+template <unsigned int UpLo>
+void materialize_selfadjoint_pattern_random_impl() {
+  typedef SparseMatrix<double, ColMajor, int> SparseMatrixType;
+  typedef SparseMatrix<signed char, ColMajor, int> PatternMatrixType;
+  typedef Matrix<double, Dynamic, Dynamic, ColMajor> DenseMatrixType;
+  typedef Matrix<int, Dynamic, 1> VectorI;
+
+  // Build a random sparse matrix that may have entries on both triangles; the
+  // selfadjoint pattern must filter to only the requested triangle.
+  const int n = internal::random<int>(8, 64);
+  DenseMatrixType ref(n, n);
+  SparseMatrixType a(n, n);
+  initSparse<double>(0.4, ref, a, ForceNonZeroDiag);
+  a.makeCompressed();
+
+  VectorI outer, inner;
+  internal::SparsityPatternRef<int> pat = internal::make_col_major_pattern_ref(a, outer, inner);
+  PatternMatrixType got;
+  internal::materialize_selfadjoint_pattern<UpLo>(pat, got);
+
+  // Reference: explicit symmetrization of the requested triangle.
+  SparseMatrixType expected(n, n);
+  expected = a.template selfadjointView<UpLo>();
+  verify_same_pattern(got, expected);
+}
+
+template <int>
+void materialize_selfadjoint_pattern_lower_upper() {
+  materialize_selfadjoint_pattern_random_impl<Lower>();
+  materialize_selfadjoint_pattern_random_impl<Upper>();
+}
+
 template <int>
 void bug1105() {
   // Regression test for bug 1105
@@ -1066,5 +1378,13 @@
   CALL_SUBTEST_5((big_sparse_triplet<SparseMatrix<double, ColMajor, long int>>(10000, 10000, 0.125)));
 
   CALL_SUBTEST_5(bug1105<0>());
+  CALL_SUBTEST_1(sparse_sub_assign_eigenbase<0>());
+  CALL_SUBTEST_1(ambivector_coeff<0>());
+  CALL_SUBTEST_1(sparsity_pattern_ref_sparse_expressions<0>());
+  CALL_SUBTEST_1(materialize_at_plus_a_pattern_basic<0>());
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1(materialize_at_plus_a_pattern_random<0>());
+    CALL_SUBTEST_1(materialize_selfadjoint_pattern_lower_upper<0>());
+  }
 }
 #endif
diff --git a/test/sparse_block.cpp b/test/sparse_block.cpp
index 398658c..14433ee 100644
--- a/test/sparse_block.cpp
+++ b/test/sparse_block.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse.h"
 #include "AnnoyingScalar.h"
@@ -20,6 +21,152 @@
   return A.col(i);
 }
 
+template <typename T>
+typename T::Map make_map(T& A) {
+  return typename T::Map(A.rows(), A.cols(), A.nonZeros(), A.outerIndexPtr(), A.innerIndexPtr(), A.valuePtr(),
+                         A.innerNonZeroPtr());
+}
+
+template <typename T>
+auto innerpanel(T& A, Index start, Index size)
+    -> std::enable_if_t<(T::Flags & RowMajorBit) == RowMajorBit, decltype(A.middleRows(start, size))> {
+  return A.middleRows(start, size);
+}
+
+template <typename T>
+auto innerpanel(T& A, Index start, Index size)
+    -> std::enable_if_t<(T::Flags & RowMajorBit) == 0, decltype(A.middleCols(start, size))> {
+  return A.middleCols(start, size);
+}
+
+template <int Options>
+void init_inner_panel_diag(SparseMatrix<double, Options>& m) {
+  m.resize(4, 4);
+  m.insert(0, 0) = 10.0;
+  m.insert(1, 1) = 20.0;
+  m.insert(2, 2) = 30.0;
+  m.insert(3, 3) = 40.0;
+  m.makeCompressed();
+}
+
+template <typename MatrixType>
+std::enable_if_t<(MatrixType::Flags & RowMajorBit) == 0> init_inner_panel_offset(MatrixType& m) {
+  m.resize(4, 4);
+  m.insert(3, 0) = 13.0;
+  m.insert(1, 1) = 11.0;
+  m.insert(0, 2) = 20.0;
+  m.insert(2, 2) = 30.0;
+  m.insert(3, 3) = 40.0;
+  m.makeCompressed();
+}
+
+template <typename MatrixType>
+std::enable_if_t<(MatrixType::Flags & RowMajorBit) == RowMajorBit> init_inner_panel_offset(MatrixType& m) {
+  m.resize(4, 4);
+  m.insert(0, 3) = 13.0;
+  m.insert(1, 1) = 11.0;
+  m.insert(2, 0) = 20.0;
+  m.insert(2, 2) = 30.0;
+  m.insert(3, 3) = 40.0;
+  m.makeCompressed();
+}
+
+template <typename MatrixType, typename Init, typename Verify>
+void verify_plain_ref_map(const Init& init, const Verify& verify) {
+  {
+    MatrixType matrix;
+    init(matrix);
+    verify(matrix, matrix, 0);
+  }
+
+  {
+    MatrixType matrix;
+    init(matrix);
+    Ref<MatrixType> ref(matrix);
+    verify(ref, matrix, 1);
+  }
+
+  {
+    MatrixType matrix;
+    init(matrix);
+    auto map = make_map(matrix);
+    verify(map, matrix, 2);
+  }
+}
+
+template <typename XprType, typename MatrixType>
+void verify_inner_panel_coeffs(XprType& xpr, MatrixType& storage, int variant) {
+  auto middle = innerpanel(xpr, 1, 2);
+  auto coeffs = middle.coeffs();
+  const double updated0 = 200.0 + 10.0 * variant;
+  const double updated1 = 300.0 + 10.0 * variant;
+  VERIFY_IS_EQUAL(coeffs.size(), 2);
+  VERIFY_IS_EQUAL(coeffs[0], 20.0);
+  VERIFY_IS_EQUAL(coeffs[1], 30.0);
+
+  coeffs[0] = updated0;
+  coeffs[1] = updated1;
+  VERIFY_IS_EQUAL(storage.coeff(0, 0), 10.0);
+  VERIFY_IS_EQUAL(storage.coeff(1, 1), updated0);
+  VERIFY_IS_EQUAL(storage.coeff(2, 2), updated1);
+}
+
+template <typename XprType, typename MatrixType>
+void verify_inner_vector_reverse_and_sortedness(XprType& xpr, MatrixType& storage, int) {
+  auto inner = innervec(xpr, 2);
+  VERIFY_IS_EQUAL(inner.innerIndicesAreSorted(), 1);
+
+  typedef decltype(inner) InnerType;
+  typename InnerType::ReverseInnerIterator rit(inner);
+  VERIFY(rit);
+  VERIFY_IS_EQUAL(rit.index(), 2);
+  VERIFY_IS_EQUAL(rit.value(), 30.0);
+  --rit;
+  VERIFY(rit);
+  VERIFY_IS_EQUAL(rit.index(), 0);
+  VERIFY_IS_EQUAL(rit.value(), 20.0);
+  --rit;
+  VERIFY(!rit);
+
+  const Index offset = storage.outerIndexPtr()[2];
+  typename MatrixType::StorageIndex tmp_inner = storage.innerIndexPtr()[offset];
+  storage.innerIndexPtr()[offset] = storage.innerIndexPtr()[offset + 1];
+  storage.innerIndexPtr()[offset + 1] = tmp_inner;
+  double tmp_value = storage.valuePtr()[offset];
+  storage.valuePtr()[offset] = storage.valuePtr()[offset + 1];
+  storage.valuePtr()[offset + 1] = tmp_value;
+
+  VERIFY_IS_EQUAL(inner.innerIndicesAreSorted(), 0);
+  inner.sortInnerIndices();
+  VERIFY_IS_EQUAL(inner.innerIndicesAreSorted(), 1);
+
+  typename InnerType::InnerIterator it(inner);
+  VERIFY(it);
+  VERIFY_IS_EQUAL(it.index(), 0);
+  VERIFY_IS_EQUAL(it.value(), 20.0);
+  ++it;
+  VERIFY(it);
+  VERIFY_IS_EQUAL(it.index(), 2);
+  VERIFY_IS_EQUAL(it.value(), 30.0);
+  ++it;
+  VERIFY(!it);
+}
+
+void check_inner_panel_compressed_api() {
+  verify_plain_ref_map<SparseMatrix<double>>(
+      [](SparseMatrix<double>& matrix) { init_inner_panel_diag(matrix); },
+      [](auto& xpr, auto& matrix, int variant) { verify_inner_panel_coeffs(xpr, matrix, variant); });
+  verify_plain_ref_map<SparseMatrix<double, RowMajor>>(
+      [](SparseMatrix<double, RowMajor>& matrix) { init_inner_panel_diag(matrix); },
+      [](auto& xpr, auto& matrix, int variant) { verify_inner_panel_coeffs(xpr, matrix, variant); });
+  verify_plain_ref_map<SparseMatrix<double>>(
+      [](SparseMatrix<double>& matrix) { init_inner_panel_offset(matrix); },
+      [](auto& xpr, auto& matrix, int variant) { verify_inner_vector_reverse_and_sortedness(xpr, matrix, variant); });
+  verify_plain_ref_map<SparseMatrix<double, RowMajor>>(
+      [](SparseMatrix<double, RowMajor>& matrix) { init_inner_panel_offset(matrix); },
+      [](auto& xpr, auto& matrix, int variant) { verify_inner_vector_reverse_and_sortedness(xpr, matrix, variant); });
+}
+
 template <typename SparseMatrixType>
 void sparse_block(const SparseMatrixType& ref) {
   const Index rows = ref.rows();
@@ -64,7 +211,6 @@
         VERIFY_IS_APPROX(m.block(i, j, h, w).row(r), refMat.block(i, j, h, w).row(r));
         for (Index c = 0; c < w; c++) {
           VERIFY_IS_APPROX(m.block(i, j, h, w).row(r).coeff(c), refMat.block(i, j, h, w).row(r).coeff(c));
-          VERIFY_IS_APPROX(m.block(i, j, h, w).coeff(r, c), refMat.block(i, j, h, w).coeff(r, c));
         }
       }
 
@@ -82,9 +228,6 @@
           if (!numext::is_exactly_zero(m.middleCols(j, w).coeff(r, c))) {
             VERIFY_IS_APPROX(m.middleCols(j, w).coeffRef(r, c), refMat.middleCols(j, w).coeff(r, c));
           }
-          if (!numext::is_exactly_zero(m.middleRows(i, h).coeff(r, c))) {
-            VERIFY_IS_APPROX(m.middleRows(i, h).coeff(r, c), refMat.middleRows(i, h).coeff(r, c));
-          }
         }
       }
       for (Index c = 0; c < w; c++) {
@@ -286,11 +429,7 @@
       VERIFY_IS_EQUAL(v.innerNonZeroPtr(), (const StorageIndex*)0);
     } else {
       VERIFY(!v.isCompressed());
-      if (SparseMatrixType::IsRowMajor) {
-        VERIFY_IS_EQUAL(v.innerNonZeroPtr(), m2.innerNonZeroPtr() + j0);
-      } else {
-        VERIFY_IS_EQUAL(v.innerNonZeroPtr(), m2.innerNonZeroPtr() + j0);
-      }
+      VERIFY_IS_EQUAL(v.innerNonZeroPtr(), m2.innerNonZeroPtr() + j0);
     }
     VERIFY_IS_EQUAL(v.valuePtr(), m2.valuePtr());
     VERIFY_IS_EQUAL(v.innerIndexPtr(), m2.innerIndexPtr());
@@ -326,5 +465,6 @@
     AnnoyingScalar::dont_throw = true;
 #endif
     CALL_SUBTEST_5((sparse_block(SparseMatrix<AnnoyingScalar>(r, c))));
+    CALL_SUBTEST_6(check_inner_panel_compressed_api());
   }
 }
diff --git a/test/sparse_ordering.cpp b/test/sparse_ordering.cpp
new file mode 100644
index 0000000..3998021
--- /dev/null
+++ b/test/sparse_ordering.cpp
@@ -0,0 +1,103 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "sparse.h"
+#include <Eigen/OrderingMethods>
+
+template <typename Idx>
+void verify_is_permutation(const PermutationMatrix<Dynamic, Dynamic, Idx>& perm) {
+  typedef Matrix<Idx, Dynamic, 1> Vec;
+  Vec sorted = perm.indices();
+  std::sort(sorted.data(), sorted.data() + sorted.size());
+  Vec expected = Vec::LinSpaced(perm.size(), 0, Idx(perm.size() - 1));
+  VERIFY_IS_EQUAL(sorted, expected);
+}
+
+template <typename Scalar>
+void test_colamd_uncompressed() {
+  typedef int Idx;
+  typedef SparseMatrix<Scalar, ColMajor, Idx> SpMat;
+  const int n = 32;
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 5));
+  for (int j = 0; j < n; ++j) {
+    A.insert(j, j) = Scalar(2) + Scalar(j);
+    if (j > 0) A.insert(j - 1, j) = Scalar(-1);
+    if (j + 1 < n) A.insert(j + 1, j) = Scalar(-1);
+  }
+  A.insert(0, n - 1) = Scalar(0.5);
+  A.insert(n - 1, 0) = Scalar(0.25);
+  VERIFY(!A.isCompressed());
+
+  // Regression for #649: COLAMD on uncompressed input used to silently corrupt
+  // the permutation in release builds.
+  PermutationMatrix<Dynamic, Dynamic, Idx> perm_u, perm_c;
+  COLAMDOrdering<Idx> ord;
+  ord(A, perm_u);
+  verify_is_permutation(perm_u);
+
+  SpMat B = A;
+  B.makeCompressed();
+  ord(B, perm_c);
+  verify_is_permutation(perm_c);
+
+  VERIFY_IS_EQUAL(perm_u.indices(), perm_c.indices());
+}
+
+void test_colamd_mixed_index_types() {
+  typedef SparseMatrix<double, ColMajor, int> SpMat;
+  const int n = 8;
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 3));
+  for (int j = 0; j < n; ++j) {
+    A.insert(j, j) = 2.0 + j;
+    if (j > 0) A.insert(j - 1, j) = -1.0;
+    if (j + 1 < n) A.insert(j + 1, j) = -1.0;
+  }
+  A.makeCompressed();
+
+  // COLAMDOrdering<StorageIndex> is a public API choice independent of the
+  // source matrix's StorageIndex.  Keep accepting mixed index types.
+  PermutationMatrix<Dynamic, Dynamic, long> perm;
+  COLAMDOrdering<long> ord;
+  ord(A, perm);
+  verify_is_permutation(perm);
+}
+
+template <typename Scalar>
+void test_amd_uncompressed() {
+  typedef int Idx;
+  typedef SparseMatrix<Scalar, ColMajor, Idx> SpMat;
+  const int n = 24;
+  SpMat A(n, n);
+  A.reserve(VectorXi::Constant(n, 4));
+  for (int j = 0; j < n; ++j) {
+    A.insert(j, j) = Scalar(2) + Scalar(j);
+    if (j > 0) {
+      A.insert(j - 1, j) = Scalar(-1);
+      A.insert(j, j - 1) = Scalar(-1);
+    }
+  }
+  VERIFY(!A.isCompressed());
+
+  PermutationMatrix<Dynamic, Dynamic, Idx> perm;
+  AMDOrdering<Idx> ord;
+  ord(A, perm);
+  verify_is_permutation(perm);
+}
+
+EIGEN_DECLARE_TEST(sparse_ordering) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1(test_colamd_uncompressed<double>());
+    CALL_SUBTEST_2(test_colamd_uncompressed<std::complex<double> >());
+    CALL_SUBTEST_3(test_amd_uncompressed<double>());
+    CALL_SUBTEST_4(test_colamd_mixed_index_types());
+  }
+}
diff --git a/test/sparse_permutations.cpp b/test/sparse_permutations.cpp
index 1657236..8481c18 100644
--- a/test/sparse_permutations.cpp
+++ b/test/sparse_permutations.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 static long int nb_transposed_copies;
 #define EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN \
@@ -233,12 +234,12 @@
     CALL_SUBTEST_2((sparse_permutations_all<std::complex<double> >(s)));
   }
 
-  VERIFY((internal::is_same<
+  VERIFY((std::is_same<
           internal::permutation_matrix_product<SparseMatrix<double>, OnTheRight, false, SparseShape>::ReturnType,
           internal::nested_eval<Product<SparseMatrix<double>, PermutationMatrix<Dynamic, Dynamic>, AliasFreeProduct>,
                                 1>::type>::value));
 
-  VERIFY((internal::is_same<
+  VERIFY((std::is_same<
           internal::permutation_matrix_product<SparseMatrix<double>, OnTheLeft, false, SparseShape>::ReturnType,
           internal::nested_eval<Product<PermutationMatrix<Dynamic, Dynamic>, SparseMatrix<double>, AliasFreeProduct>,
                                 1>::type>::value));
diff --git a/test/sparse_product.cpp b/test/sparse_product.cpp
index 426a375..8cdc09d 100644
--- a/test/sparse_product.cpp
+++ b/test/sparse_product.cpp
@@ -6,12 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-// This unit test takes forever to compile in Release mode with MSVC 2013,
-// multiple hours. So let's switch off optimization for this one.
-#pragma optimize("", off)
-#endif
+// SPDX-License-Identifier: MPL-2.0
 
 static long int nb_temporaries;
 
@@ -25,6 +20,9 @@
 
 #include "sparse.h"
 
+#define EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+#include "AnnoyingScalar.h"
+
 #define VERIFY_EVALUATION_COUNT(XPR, N)                                                   \
   {                                                                                       \
     nb_temporaries = 0;                                                                   \
@@ -33,6 +31,37 @@
     VERIFY((#XPR) && nb_temporaries == N);                                                \
   }
 
+template <typename Lhs, typename Rhs, typename = void>
+struct has_product : std::false_type {};
+
+template <typename Lhs, typename Rhs>
+struct has_product<Lhs, Rhs, internal::void_t<decltype(std::declval<const Lhs&>() * std::declval<const Rhs&>())>>
+    : std::true_type {};
+
+template <typename SparseMatrixType>
+void sparse_structured_view_product_sfinae() {
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DenseVectorType;
+  typedef decltype(std::declval<SparseMatrixType&>().template triangularView<Lower>()) TriangularViewType;
+  typedef decltype(std::declval<SparseMatrixType&>().template selfadjointView<Lower>()) SelfAdjointViewType;
+  typedef decltype(std::declval<const DenseVectorType&>().asDiagonal()) DiagonalType;
+
+  STATIC_CHECK((has_product<TriangularViewType, SparseMatrixType>::value));
+  STATIC_CHECK((has_product<SparseMatrixType, TriangularViewType>::value));
+  STATIC_CHECK((has_product<TriangularViewType, DenseMatrixType>::value));
+  STATIC_CHECK((has_product<DenseMatrixType, TriangularViewType>::value));
+  STATIC_CHECK((has_product<TriangularViewType, DiagonalType>::value));
+  STATIC_CHECK((has_product<DiagonalType, TriangularViewType>::value));
+
+  STATIC_CHECK((has_product<SelfAdjointViewType, SparseMatrixType>::value));
+  STATIC_CHECK((has_product<SparseMatrixType, SelfAdjointViewType>::value));
+  STATIC_CHECK((has_product<SelfAdjointViewType, DenseMatrixType>::value));
+  STATIC_CHECK((has_product<DenseMatrixType, SelfAdjointViewType>::value));
+  STATIC_CHECK((has_product<SelfAdjointViewType, DiagonalType>::value));
+  STATIC_CHECK((has_product<DiagonalType, SelfAdjointViewType>::value));
+}
+
 template <typename SparseMatrixType>
 void sparse_product() {
   typedef typename SparseMatrixType::StorageIndex StorageIndex;
@@ -148,7 +177,6 @@
     VERIFY_IS_APPROX(dm4 = m2t.transpose() * refMat3t.transpose(),
                      refMat4 = refMat2t.transpose() * refMat3t.transpose());
 
-    VERIFY_IS_APPROX(dm4 = m2 * refMat3, refMat4 = refMat2 * refMat3);
     VERIFY_IS_APPROX(dm4 = dm4 + m2 * refMat3, refMat4 = refMat4 + refMat2 * refMat3);
     VERIFY_IS_APPROX(dm4 += m2 * refMat3, refMat4 += refMat2 * refMat3);
     VERIFY_IS_APPROX(dm4 -= m2 * refMat3, refMat4 -= refMat2 * refMat3);
@@ -334,12 +362,34 @@
     VERIFY_IS_APPROX(x.noalias() -= mLo.template selfadjointView<Lower>() * b, refX -= refS * b);
     VERIFY_IS_APPROX(x.noalias() += mS.template selfadjointView<Upper | Lower>() * b, refX += refS * b);
 
+    DenseVector scale = DenseVector::Random(rows);
+    VERIFY_IS_APPROX(x = mLo.template selfadjointView<Lower>() * scale.asDiagonal(), refX = refS * scale.asDiagonal());
+    VERIFY_IS_APPROX(x = scale.asDiagonal() * mLo.template selfadjointView<Lower>(), refX = scale.asDiagonal() * refS);
+    VERIFY_IS_APPROX(x = mUp.template selfadjointView<Upper>() * scale.asDiagonal(), refX = refS * scale.asDiagonal());
+    VERIFY_IS_APPROX(x = scale.asDiagonal() * mUp.template selfadjointView<Upper>(), refX = scale.asDiagonal() * refS);
+    VERIFY_IS_APPROX(x = mS.template selfadjointView<Upper | Lower>() * scale.asDiagonal(),
+                     refX = refS * scale.asDiagonal());
+    VERIFY_IS_APPROX(x = scale.asDiagonal() * mS.template selfadjointView<Upper | Lower>(),
+                     refX = scale.asDiagonal() * refS);
+
     // sparse selfadjointView with sparse matrices
     SparseMatrixType mSres(rows, rows);
     VERIFY_IS_APPROX(mSres = mLo.template selfadjointView<Lower>() * mS,
                      refX = refLo.template selfadjointView<Lower>() * refS);
     VERIFY_IS_APPROX(mSres = mS * mLo.template selfadjointView<Lower>(),
                      refX = refS * refLo.template selfadjointView<Lower>());
+    VERIFY_IS_APPROX(mSres = mLo.template selfadjointView<Lower>() * scale.asDiagonal(),
+                     refX = refS * scale.asDiagonal());
+    VERIFY_IS_APPROX(mSres = scale.asDiagonal() * mLo.template selfadjointView<Lower>(),
+                     refX = scale.asDiagonal() * refS);
+    VERIFY_IS_APPROX(mSres = mUp.template selfadjointView<Upper>() * scale.asDiagonal(),
+                     refX = refS * scale.asDiagonal());
+    VERIFY_IS_APPROX(mSres = scale.asDiagonal() * mUp.template selfadjointView<Upper>(),
+                     refX = scale.asDiagonal() * refS);
+    VERIFY_IS_APPROX(mSres = mS.template selfadjointView<Upper | Lower>() * scale.asDiagonal(),
+                     refX = refS * scale.asDiagonal());
+    VERIFY_IS_APPROX(mSres = scale.asDiagonal() * mS.template selfadjointView<Upper | Lower>(),
+                     refX = scale.asDiagonal() * refS);
 
     // sparse triangularView with dense matrices
     VERIFY_IS_APPROX(x = mA.template triangularView<Upper>() * b, refX = refA.template triangularView<Upper>() * b);
@@ -356,6 +406,15 @@
                      refX = refA.template triangularView<Upper>() * refS);
     VERIFY_IS_APPROX(mSres = mS * mA.template triangularView<Upper>(),
                      refX = refS * refA.template triangularView<Upper>());
+
+    VERIFY_IS_APPROX(mSres = mA.template triangularView<UnitLower>() * scale.asDiagonal(),
+                     refX = DenseMatrix(refA.template triangularView<UnitLower>()) * scale.asDiagonal());
+    VERIFY_IS_APPROX(mSres = scale.asDiagonal() * mA.template triangularView<UnitLower>(),
+                     refX = scale.asDiagonal() * DenseMatrix(refA.template triangularView<UnitLower>()));
+    VERIFY_IS_APPROX(mSres = mA.template triangularView<UnitUpper>() * scale.asDiagonal(),
+                     refX = DenseMatrix(refA.template triangularView<UnitUpper>()) * scale.asDiagonal());
+    VERIFY_IS_APPROX(mSres = scale.asDiagonal() * mA.template triangularView<UnitUpper>(),
+                     refX = scale.asDiagonal() * DenseMatrix(refA.template triangularView<UnitUpper>()));
   }
 }
 
@@ -542,6 +601,283 @@
   test_mixed_storage_imp<ColMajor, ColMajor, ColMajor>();
 }
 
+// The pruned sparse*sparse product accumulates each column into an AmbiVector,
+// which stores its coefficients either in a dense buffer or in a linked list of
+// (index, value) nodes depending on the estimated density. Both storage modes
+// must construct, move, and destroy the coefficients properly for
+// non-trivially-copyable scalars (issue #2873).
+void test_pruned_product_custom_scalar() {
+  typedef SparseMatrix<AnnoyingScalar> SpMat;
+  typedef Matrix<AnnoyingScalar, Dynamic, Dynamic> DenseMat;
+  int instances_before = AnnoyingScalar::instances;
+  {
+    // Low density runs the AmbiVector in linked-list mode, high density in
+    // dense-buffer mode.
+    for (double density : {0.02, 0.3}) {
+      const Index n = 50;
+      SpMat A(n, n), B(n, n);
+      for (Index k = 0; k < Index(density * n * n); ++k) {
+        A.coeffRef(internal::random<Index>(0, n - 1), internal::random<Index>(0, n - 1)) =
+            AnnoyingScalar(internal::random<float>());
+        B.coeffRef(internal::random<Index>(0, n - 1), internal::random<Index>(0, n - 1)) =
+            AnnoyingScalar(internal::random<float>());
+      }
+      SpMat C = (A * B).pruned();
+      DenseMat refC = DenseMat(A).lazyProduct(DenseMat(B));
+      VERIFY_IS_APPROX(DenseMat(C), refC);
+    }
+    // A single dense column in a large matrix overflows the initial node
+    // capacity and exercises the linked-list reallocation path.
+    {
+      const Index n = 1200;
+      SpMat A(n, n), B(n, n);
+      for (Index i = 0; i < 900; ++i) A.coeffRef(i, 0) = AnnoyingScalar(float(i % 7) + 1.0f);
+      B.coeffRef(0, 0) = AnnoyingScalar(2.0f);
+      SpMat C = (A * B).pruned();
+      VERIFY_IS_EQUAL(C.nonZeros(), 900);
+      for (Index i = 0; i < 900; i += 123) {
+        VERIFY_IS_APPROX(C.coeff(i, 0), AnnoyingScalar(2.0f * (float(i % 7) + 1.0f)));
+      }
+    }
+  }
+  // Every constructed AnnoyingScalar must have been destroyed again.
+  VERIFY_IS_EQUAL(AnnoyingScalar::instances, instances_before);
+}
+
+// setZero() drops the AmbiVector's whole linked list, and the pruned product
+// reaches it through init(), which drops the list too. Neither may abandon the
+// coefficients the dropped nodes own, and neither may leave a node behind for
+// the next coeffRef() to construct over.
+void test_ambivector_discard_custom_scalar() {
+  typedef internal::AmbiVector<AnnoyingScalar, int> AmbiVec;
+  const Index n = 32;
+  int instances_before = AnnoyingScalar::instances;
+  {
+    AmbiVec v(n);
+    for (int discard = 0; discard < 2; ++discard) {
+      v.init(IsSparse);
+      v.restart();
+      for (Index i = 0; i < n; i += 3) v.coeffRef(i) = AnnoyingScalar(float(i) + 1.0f);
+      VERIFY_IS_EQUAL(v.nonZeros(), (n + 2) / 3);
+
+      if (discard == 0)
+        v.setZero();
+      else
+        v.init(IsSparse);
+      VERIFY_IS_EQUAL(v.nonZeros(), 0);
+
+      // Reinserting must find storage no live node occupies.
+      v.restart();
+      v.coeffRef(1) = AnnoyingScalar(5.0f);
+      VERIFY_IS_APPROX(v.coeff(1), AnnoyingScalar(5.0f));
+      VERIFY_IS_APPROX(v.coeff(0), AnnoyingScalar(0.0f));
+    }
+  }
+  VERIFY_IS_EQUAL(AnnoyingScalar::instances, instances_before);
+}
+
+// resize() reuses its allocation whenever the new size still fits, and the
+// sub-vector bounds an iterator walks describe the size the vector had before.
+void test_ambivector_resize_bounds() {
+  typedef internal::AmbiVector<double, int> AmbiVec;
+  {
+    AmbiVec v(20);
+    v.init(IsDense);
+    v.setZero();
+    v.coeffRef(15) = 15.0;
+
+    // Shrinking below the coefficient just written: iteration must end at the
+    // new size rather than reaching a coefficient that is no longer part of the
+    // vector.
+    v.resize(10);
+    VERIFY_IS_EQUAL(v.size(), 10);
+    v.init(IsDense);
+    Index count = 0;
+    for (AmbiVec::Iterator it(v); it; ++it) {
+      VERIFY(it.index() < v.size());
+      ++count;
+    }
+    VERIFY_IS_EQUAL(count, 0);
+  }
+  {
+    // Growing within the spare capacity: iteration must reach the coefficients
+    // the new size added.
+    AmbiVec v(10);
+    v.init(IsDense);
+    v.setZero();
+    v.resize(20);
+    VERIFY_IS_EQUAL(v.size(), 20);
+    v.init(IsDense);
+    v.setZero();
+    v.coeffRef(19) = 19.0;
+    Index count = 0;
+    for (AmbiVec::Iterator it(v); it; ++it) {
+      VERIFY_IS_EQUAL(it.index(), 19);
+      VERIFY_IS_APPROX(it.value(), 19.0);
+      ++count;
+    }
+    VERIFY_IS_EQUAL(count, 1);
+  }
+}
+
+#if defined(EIGEN_EXCEPTIONS)
+namespace ambivector_throwing {
+struct scalar_exception {};
+
+// A scalar that counts its live instances and can be made to throw from the
+// constructor AmbiVector builds a node's coefficient with, or from relocating an
+// already stored coefficient when the list outgrows its capacity. Relocation is
+// keyed on a nonzero source value, which a freshly built node never has, so that
+// each flag selects exactly one of the two paths whether or not the compiler
+// elides the initialization of a node's coefficient from Scalar(0).
+struct ThrowingScalar {
+  static int live;
+  static bool throw_on_construction;
+  static bool throw_on_relocation;
+
+  float value;
+
+  ThrowingScalar() : value(0) { ++live; }
+  ThrowingScalar(int v) : value(float(v)) {
+    if (throw_on_construction) throw scalar_exception();
+    ++live;
+  }
+  ThrowingScalar(const ThrowingScalar& other) : value(other.value) {
+    if (throw_on_relocation && other.value != 0) throw scalar_exception();
+    ++live;
+  }
+  ThrowingScalar(ThrowingScalar&& other) {
+    if (throw_on_relocation && other.value != 0) throw scalar_exception();
+    value = other.value;
+    ++live;
+  }
+  ThrowingScalar& operator=(const ThrowingScalar& other) {
+    value = other.value;
+    return *this;
+  }
+  ThrowingScalar& operator=(ThrowingScalar&& other) {
+    value = other.value;
+    return *this;
+  }
+  ~ThrowingScalar() { --live; }
+};
+
+int ThrowingScalar::live = 0;
+bool ThrowingScalar::throw_on_construction = false;
+bool ThrowingScalar::throw_on_relocation = false;
+}  // namespace ambivector_throwing
+
+// A coefficient that fails to construct leaves no node: the count of live nodes
+// the destructor walks may not include it, and the vector must remain usable.
+void test_ambivector_failed_insertion() {
+  using ambivector_throwing::ThrowingScalar;
+  typedef internal::AmbiVector<ThrowingScalar, int> AmbiVec;
+  const int live_before = ThrowingScalar::live;
+  {
+    AmbiVec v(8);
+    v.init(IsSparse);
+    v.restart();
+
+    ThrowingScalar::throw_on_construction = true;
+    bool threw = false;
+    try {
+      v.coeffRef(0);
+    } catch (const ambivector_throwing::scalar_exception&) {
+      threw = true;
+    }
+    ThrowingScalar::throw_on_construction = false;
+    VERIFY(threw);
+    VERIFY_IS_EQUAL(v.nonZeros(), 0);
+
+    v.restart();
+    v.coeffRef(0) = ThrowingScalar(3);
+    v.coeffRef(4) = ThrowingScalar(4);
+    VERIFY_IS_EQUAL(v.nonZeros(), 2);
+
+    // The same for the two remaining insertion branches, which reach a node through the list
+    // rather than starting one: a new lowest index, and an index past the last node.
+    v.setZero();
+    v.restart();
+    v.coeffRef(5) = ThrowingScalar(5);
+
+    ThrowingScalar::throw_on_construction = true;
+    threw = false;
+    try {
+      v.coeffRef(0);
+    } catch (const ambivector_throwing::scalar_exception&) {
+      threw = true;
+    }
+    ThrowingScalar::throw_on_construction = false;
+    VERIFY(threw);
+    VERIFY_IS_EQUAL(v.nonZeros(), 1);
+
+    ThrowingScalar::throw_on_construction = true;
+    threw = false;
+    try {
+      v.coeffRef(7);
+    } catch (const ambivector_throwing::scalar_exception&) {
+      threw = true;
+    }
+    ThrowingScalar::throw_on_construction = false;
+    VERIFY(threw);
+    VERIFY_IS_EQUAL(v.nonZeros(), 1);
+
+    v.restart();
+    v.coeffRef(0) = ThrowingScalar(1);
+    v.coeffRef(7) = ThrowingScalar(7);
+    VERIFY_IS_EQUAL(v.nonZeros(), 3);
+  }
+  VERIFY_IS_EQUAL(ThrowingScalar::live, live_before);
+}
+
+// A throwing relocation must release the buffer it was relocating into and
+// leave the capacity describing the buffer the vector still owns, so that the
+// next insertion relocates again instead of writing past its end. The leak
+// itself shows up under a leak checker; the retry below is what fails when the
+// capacity has already been advanced.
+void test_ambivector_failed_reallocation() {
+  using ambivector_throwing::ThrowingScalar;
+  typedef internal::AmbiVector<ThrowingScalar, int> AmbiVec;
+  const int live_before = ThrowingScalar::live;
+  {
+    // Sized so that the initial node capacity is a fraction of the vector's own
+    // size, which is what makes the reallocation path reachable at all.
+    const Index n = 1200;
+    AmbiVec v(n);
+    v.init(IsSparse);
+    v.restart();
+
+    // Insert until the list has to grow, which is the first insertion that
+    // relocates an already stored coefficient and therefore the first that
+    // throws.
+    ThrowingScalar::throw_on_relocation = true;
+    Index inserted = 0;
+    bool threw = false;
+    while (!threw) {
+      VERIFY(inserted < n);
+      try {
+        // In C++14 mode, NVHPC 22.9 through at least 26.5 do not destroy the right-hand temporary if a combined
+        // assignment's coeffRef() throws.
+        ThrowingScalar& value = v.coeffRef(inserted);
+        value = ThrowingScalar(1);
+        ++inserted;
+      } catch (const ambivector_throwing::scalar_exception&) {
+        threw = true;
+      }
+    }
+    ThrowingScalar::throw_on_relocation = false;
+    VERIFY(inserted > 0);
+    VERIFY_IS_EQUAL(v.nonZeros(), inserted);
+
+    // Same insertion again, now relocating for real.
+    v.restart();
+    v.coeffRef(inserted) = ThrowingScalar(2);
+    VERIFY_IS_EQUAL(v.nonZeros(), inserted + 1);
+  }
+  VERIFY_IS_EQUAL(ThrowingScalar::live, live_before);
+}
+#endif  // EIGEN_EXCEPTIONS
+
 void test_sparse_vector_dense_product() {
   SparseVector<double> sv(3);
   sv.insert(0) = 1.0;
@@ -554,18 +890,29 @@
 }
 
 EIGEN_DECLARE_TEST(sparse_product) {
+  sparse_structured_view_product_sfinae<SparseMatrix<double, ColMajor>>();
+  sparse_structured_view_product_sfinae<SparseMatrix<double, RowMajor>>();
+
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1((test_sparse_vector_dense_product()));
-    CALL_SUBTEST_1((sparse_product<SparseMatrix<double, ColMajor> >()));
-    CALL_SUBTEST_1((sparse_product<SparseMatrix<double, RowMajor> >()));
+    CALL_SUBTEST_1((sparse_product<SparseMatrix<double, ColMajor>>()));
+    CALL_SUBTEST_1((sparse_product<SparseMatrix<double, RowMajor>>()));
     CALL_SUBTEST_1((bug_942<double>()));
-    CALL_SUBTEST_2((sparse_product<SparseMatrix<std::complex<double>, ColMajor> >()));
-    CALL_SUBTEST_2((sparse_product<SparseMatrix<std::complex<double>, RowMajor> >()));
-    CALL_SUBTEST_3((sparse_product<SparseMatrix<float, ColMajor, long int> >()));
-    CALL_SUBTEST_4((
-        sparse_product_regression_test<SparseMatrix<double, RowMajor>, Matrix<double, Dynamic, Dynamic, RowMajor> >()));
+    CALL_SUBTEST_2((sparse_product<SparseMatrix<std::complex<double>, ColMajor>>()));
+    CALL_SUBTEST_2((sparse_product<SparseMatrix<std::complex<double>, RowMajor>>()));
+    CALL_SUBTEST_3((sparse_product<SparseMatrix<float, ColMajor, long int>>()));
+    CALL_SUBTEST_4(
+        (sparse_product_regression_test<SparseMatrix<double, RowMajor>, Matrix<double, Dynamic, Dynamic, RowMajor>>()));
 
     CALL_SUBTEST_5((test_mixing_types<float>()));
     CALL_SUBTEST_5((test_mixed_storage()));
+
+    CALL_SUBTEST_6((test_pruned_product_custom_scalar()));
+    CALL_SUBTEST_6((test_ambivector_discard_custom_scalar()));
+    CALL_SUBTEST_6((test_ambivector_resize_bounds()));
+#if defined(EIGEN_EXCEPTIONS)
+    CALL_SUBTEST_6((test_ambivector_failed_insertion()));
+    CALL_SUBTEST_6((test_ambivector_failed_reallocation()));
+#endif
   }
 }
diff --git a/test/sparse_ref.cpp b/test/sparse_ref.cpp
index bfedcd9..ecf6ba0 100644
--- a/test/sparse_ref.cpp
+++ b/test/sparse_ref.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // This unit test cannot be easily written to work with EIGEN_DEFAULT_TO_ROW_MAJOR
 #ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
@@ -37,19 +38,29 @@
 void check_const_correctness(const PlainObjectType &) {
   // verify that ref-to-const don't have LvalueBit
   typedef std::add_const_t<PlainObjectType> ConstPlainObjectType;
-  VERIFY(!(internal::traits<Ref<ConstPlainObjectType> >::Flags & LvalueBit));
-  VERIFY(!(internal::traits<Ref<ConstPlainObjectType, Aligned> >::Flags & LvalueBit));
+  VERIFY(!(internal::traits<Ref<ConstPlainObjectType>>::Flags & LvalueBit));
+  VERIFY(!(internal::traits<Ref<ConstPlainObjectType, Aligned>>::Flags & LvalueBit));
   VERIFY(!(Ref<ConstPlainObjectType>::Flags & LvalueBit));
   VERIFY(!(Ref<ConstPlainObjectType, Aligned>::Flags & LvalueBit));
 }
 
 template <typename B>
-EIGEN_DONT_INLINE void call_ref_1(Ref<SparseMatrix<float> > a, const B &b) {
+EIGEN_DONT_INLINE void call_ref_1(Ref<SparseMatrix<float>> a, const B &b) {
   VERIFY_IS_EQUAL(a.toDense(), b.toDense());
 }
 
 template <typename B>
-EIGEN_DONT_INLINE void call_ref_2(const Ref<const SparseMatrix<float> > &a, const B &b) {
+EIGEN_DONT_INLINE void call_ref_2(const Ref<const SparseMatrix<float>> &a, const B &b) {
+  VERIFY_IS_EQUAL(a.toDense(), b.toDense());
+}
+
+template <typename B>
+EIGEN_DONT_INLINE void call_ref_rm_1(Ref<SparseMatrix<float, RowMajor>> a, const B &b) {
+  VERIFY_IS_EQUAL(a.toDense(), b.toDense());
+}
+
+template <typename B>
+EIGEN_DONT_INLINE void call_ref_rm_2(const Ref<const SparseMatrix<float, RowMajor>> &a, const B &b) {
   VERIFY_IS_EQUAL(a.toDense(), b.toDense());
 }
 
@@ -60,23 +71,236 @@
 }
 
 template <typename B>
-EIGEN_DONT_INLINE void call_ref_4(Ref<SparseVector<float> > a, const B &b) {
+EIGEN_DONT_INLINE void call_ref_4(Ref<SparseVector<float>> a, const B &b) {
   VERIFY_IS_EQUAL(a.toDense(), b.toDense());
 }
 
 template <typename B>
-EIGEN_DONT_INLINE void call_ref_5(const Ref<const SparseVector<float> > &a, const B &b) {
+EIGEN_DONT_INLINE void call_ref_5(const Ref<const SparseVector<float>> &a, const B &b) {
   VERIFY_IS_EQUAL(a.toDense(), b.toDense());
 }
 
+template <typename T>
+typename T::Map make_map(T &xpr) {
+  return typename T::Map(xpr.rows(), xpr.cols(), xpr.nonZeros(), xpr.outerIndexPtr(), xpr.innerIndexPtr(),
+                         xpr.valuePtr(), xpr.innerNonZeroPtr());
+}
+
+template <typename T>
+auto innerpanel(T &xpr, Index start, Index size)
+    -> std::enable_if_t<(T::Flags & RowMajorBit) == RowMajorBit, decltype(xpr.middleRows(start, size))> {
+  return xpr.middleRows(start, size);
+}
+
+template <typename T>
+auto innerpanel(T &xpr, Index start, Index size)
+    -> std::enable_if_t<(T::Flags & RowMajorBit) == 0, decltype(xpr.middleCols(start, size))> {
+  return xpr.middleCols(start, size);
+}
+
+template <typename T>
+auto innervector(T &xpr, Index index)
+    -> std::enable_if_t<(T::Flags & RowMajorBit) == RowMajorBit, decltype(xpr.row(index))> {
+  return xpr.row(index);
+}
+
+template <typename T>
+auto innervector(T &xpr, Index index) -> std::enable_if_t<(T::Flags & RowMajorBit) == 0, decltype(xpr.col(index))> {
+  return xpr.col(index);
+}
+
+template <typename XprType, typename ExpectedType>
+void verify_coeffs(const XprType &xpr, const ExpectedType &expected) {
+  auto coeffs = xpr.coeffs();
+  VERIFY_IS_EQUAL(coeffs.size(), expected.size());
+  for (Index i = 0; i < expected.size(); ++i) VERIFY_IS_EQUAL(coeffs[i], expected[i]);
+}
+
+template <int Options>
+void init_diag(SparseMatrix<float, Options> &m) {
+  m.resize(4, 4);
+  m.insert(0, 0) = 10.f;
+  m.insert(1, 1) = 20.f;
+  m.insert(2, 2) = 30.f;
+  m.insert(3, 3) = 40.f;
+  m.makeCompressed();
+}
+
+template <typename MatrixType>
+std::enable_if_t<(MatrixType::Flags & RowMajorBit) == 0> init_noncompressed_inner_panel(MatrixType &m) {
+  m.resize(4, 4);
+  m.reserve(VectorXi::Constant(4, 2));
+  m.insert(1, 1) = 11.f;
+  m.insert(2, 1) = 12.f;
+  m.insert(0, 2) = 20.f;
+  m.insert(2, 2) = 30.f;
+  m.insert(3, 3) = 40.f;
+}
+
+template <typename MatrixType>
+std::enable_if_t<(MatrixType::Flags & RowMajorBit) == RowMajorBit> init_noncompressed_inner_panel(MatrixType &m) {
+  m.resize(4, 4);
+  m.reserve(VectorXi::Constant(4, 2));
+  m.insert(1, 1) = 11.f;
+  m.insert(1, 2) = 12.f;
+  m.insert(2, 0) = 20.f;
+  m.insert(2, 2) = 30.f;
+  m.insert(3, 3) = 40.f;
+}
+
+template <typename MatrixType, typename Init, typename Verify>
+void verify_ref_and_map(const Init &init, const Verify &verify) {
+  {
+    MatrixType matrix;
+    init(matrix);
+    Ref<MatrixType> ref(matrix);
+    verify(ref, matrix, 0);
+  }
+
+  {
+    MatrixType matrix;
+    init(matrix);
+    auto map = make_map(matrix);
+    verify(map, matrix, 1);
+  }
+}
+
+template <typename XprType, typename MatrixType>
+void verify_slice_coeffs(XprType &xpr, MatrixType &storage, int variant) {
+  Array<float, 2, 1> expected;
+  expected << 20.f, 30.f;
+
+  Ref<MatrixType> middle(innerpanel(xpr, 1, 2));
+  Ref<const MatrixType> const_middle(innerpanel(xpr, 1, 2));
+  const float updated0 = 210.f + 10.f * variant;
+  const float updated1 = 310.f + 10.f * variant;
+
+  verify_coeffs(middle, expected);
+  verify_coeffs(const_middle, expected);
+  auto coeffs = middle.coeffs();
+  coeffs[0] = updated0;
+  coeffs[1] = updated1;
+  VERIFY_IS_EQUAL(storage.coeff(0, 0), 10.f);
+  VERIFY_IS_EQUAL(storage.coeff(1, 1), updated0);
+  VERIFY_IS_EQUAL(storage.coeff(2, 2), updated1);
+}
+
+template <typename MatrixType, typename XprType>
+float innerpanel_coeff(const XprType &xpr, Index outer, Index inner) {
+  if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) return xpr.coeff(outer, inner);
+  return xpr.coeff(inner, outer);
+}
+
+template <typename MatrixType, typename XprType>
+void set_innerpanel_coeff(XprType &xpr, Index outer, Index inner, float value) {
+  if ((MatrixType::Flags & RowMajorBit) == RowMajorBit)
+    xpr.coeffRef(outer, inner) = value;
+  else
+    xpr.coeffRef(inner, outer) = value;
+}
+
+template <typename MatrixType>
+float storage_innerpanel_coeff(const MatrixType &storage, Index outer, Index inner) {
+  if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) return storage.coeff(outer + 1, inner);
+  return storage.coeff(inner, outer + 1);
+}
+
+template <typename MatrixType>
+float storage_innervector_coeff(const MatrixType &storage, Index outer, Index inner) {
+  if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) return storage.coeff(outer, inner);
+  return storage.coeff(inner, outer);
+}
+
+template <typename XprType, typename MatrixType>
+void verify_noncompressed_middle_binding(XprType &xpr, MatrixType &storage, int variant) {
+  struct Entry {
+    Index outer;
+    Index inner;
+    float value;
+  };
+
+  Ref<MatrixType> middle(innerpanel(xpr, 1, 2));
+  Ref<const MatrixType> const_middle(innerpanel(xpr, 1, 2));
+  const float updated0 = 111.f + variant;
+  const float updated1 = 121.f + variant;
+  const Entry expected[] = {{0, 1, 11.f}, {0, 2, 12.f}, {1, 0, 20.f}, {1, 2, 30.f}};
+
+  VERIFY(!middle.isCompressed());
+  VERIFY_IS_EQUAL(middle.nonZeros(), 4);
+  VERIFY(!const_middle.isCompressed());
+  VERIFY_IS_EQUAL(const_middle.nonZeros(), 4);
+  for (const auto &entry : expected) {
+    VERIFY_IS_EQUAL(innerpanel_coeff<MatrixType>(middle, entry.outer, entry.inner), entry.value);
+    VERIFY_IS_EQUAL(innerpanel_coeff<MatrixType>(const_middle, entry.outer, entry.inner), entry.value);
+  }
+
+  set_innerpanel_coeff<MatrixType>(middle, 0, 1, updated0);
+  set_innerpanel_coeff<MatrixType>(middle, 1, 0, updated1);
+  VERIFY_IS_EQUAL(storage_innerpanel_coeff(storage, 0, 1), updated0);
+  VERIFY_IS_EQUAL(storage_innerpanel_coeff(storage, 1, 0), updated1);
+}
+
+template <typename XprType, typename MatrixType>
+void verify_noncompressed_inner_vector_binding(XprType &xpr, MatrixType &storage, int variant) {
+  Array<float, 2, 1> expected;
+  expected << 20.f, 30.f;
+
+  Ref<SparseVector<float>> inner(innervector(xpr, 2));
+  Ref<const SparseVector<float>> const_inner(innervector(xpr, 2));
+  const float updated0 = 211.f + variant;
+  const float updated1 = 221.f + variant;
+
+  VERIFY(inner.isCompressed());
+  VERIFY_IS_EQUAL(inner.rows(), 4);
+  VERIFY_IS_EQUAL(inner.cols(), 1);
+  VERIFY_IS_EQUAL(inner.nonZeros(), 2);
+  VERIFY(const_inner.isCompressed());
+  VERIFY_IS_EQUAL(const_inner.rows(), 4);
+  VERIFY_IS_EQUAL(const_inner.cols(), 1);
+  VERIFY_IS_EQUAL(const_inner.nonZeros(), 2);
+  verify_coeffs(inner, expected);
+  verify_coeffs(const_inner, expected);
+
+  auto coeffs = inner.coeffs();
+  coeffs[0] = updated0;
+  coeffs[1] = updated1;
+  VERIFY_IS_EQUAL(storage_innervector_coeff(storage, 2, 0), updated0);
+  VERIFY_IS_EQUAL(storage_innervector_coeff(storage, 2, 2), updated1);
+}
+
+void check_ref_slice_coeffs() {
+  verify_ref_and_map<SparseMatrix<float>>(
+      [](SparseMatrix<float> &matrix) { init_diag(matrix); },
+      [](auto &xpr, auto &matrix, int variant) { verify_slice_coeffs(xpr, matrix, variant); });
+  verify_ref_and_map<SparseMatrix<float, RowMajor>>(
+      [](SparseMatrix<float, RowMajor> &matrix) { init_diag(matrix); },
+      [](auto &xpr, auto &matrix, int variant) { verify_slice_coeffs(xpr, matrix, variant); });
+}
+
+void check_noncompressed_ref_slices() {
+  verify_ref_and_map<SparseMatrix<float>>(
+      [](SparseMatrix<float> &matrix) { init_noncompressed_inner_panel(matrix); },
+      [](auto &xpr, auto &matrix, int variant) { verify_noncompressed_middle_binding(xpr, matrix, variant); });
+  verify_ref_and_map<SparseMatrix<float, RowMajor>>(
+      [](SparseMatrix<float, RowMajor> &matrix) { init_noncompressed_inner_panel(matrix); },
+      [](auto &xpr, auto &matrix, int variant) { verify_noncompressed_middle_binding(xpr, matrix, variant); });
+}
+
+void check_noncompressed_ref_inner_vectors() {
+  verify_ref_and_map<SparseMatrix<float>>(
+      [](SparseMatrix<float> &matrix) { init_noncompressed_inner_panel(matrix); },
+      [](auto &xpr, auto &matrix, int variant) { verify_noncompressed_inner_vector_binding(xpr, matrix, variant); });
+  verify_ref_and_map<SparseMatrix<float, RowMajor>>(
+      [](SparseMatrix<float, RowMajor> &matrix) { init_noncompressed_inner_panel(matrix); },
+      [](auto &xpr, auto &matrix, int variant) { verify_noncompressed_inner_vector_binding(xpr, matrix, variant); });
+}
+
 void call_ref() {
   SparseMatrix<float> A = MatrixXf::Random(10, 10).sparseView(0.5, 1);
   SparseMatrix<float, RowMajor> B = MatrixXf::Random(10, 10).sparseView(0.5, 1);
   SparseMatrix<float> C = MatrixXf::Random(10, 10).sparseView(0.5, 1);
   C.reserve(VectorXi::Constant(C.outerSize(), 2));
   const SparseMatrix<float> &Ac(A);
-  Block<SparseMatrix<float> > Ab(A, 0, 1, 3, 3);
-  const Block<SparseMatrix<float> > Abc(A, 0, 1, 3, 3);
   SparseVector<float> vc = VectorXf::Random(10).sparseView(0.5, 1);
   SparseVector<float, RowMajor> vr = VectorXf::Random(10).sparseView(0.5, 1);
   SparseMatrix<float> AA = A * A;
@@ -101,17 +325,37 @@
   VERIFY(!C.isCompressed());
   VERIFY_EVALUATION_COUNT(call_ref_3(C, C), 1);
 
-  Ref<SparseMatrix<float> > Ar(A);
+  Ref<SparseMatrix<float>> Ar(A);
   VERIFY_IS_APPROX(Ar + Ar, A + A);
   VERIFY_EVALUATION_COUNT(call_ref_1(Ar, A), 0);
   VERIFY_EVALUATION_COUNT(call_ref_2(Ar, A), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_1(Ar.middleCols(1, 3), A.middleCols(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_2(Ar.middleCols(1, 3), A.middleCols(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_4(Ar.col(2), A.col(2)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_5(Ar.col(2), A.col(2)), 0);
 
-  Ref<SparseMatrix<float, RowMajor> > Br(B);
+  Ref<SparseMatrix<float, RowMajor>> Br(B);
   VERIFY_EVALUATION_COUNT(call_ref_1(Br.transpose(), Br.transpose()), 0);
   VERIFY_EVALUATION_COUNT(call_ref_2(Br, Br), 1);
   VERIFY_EVALUATION_COUNT(call_ref_2(Br.transpose(), Br.transpose()), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_rm_1(Br.middleRows(1, 3), B.middleRows(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_rm_2(Br.middleRows(1, 3), B.middleRows(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_4(Br.row(2), B.row(2).transpose()), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_5(Br.row(2), B.row(2).transpose()), 0);
 
-  Ref<const SparseMatrix<float> > Arc(A);
+  auto Am = make_map(A);
+  VERIFY_EVALUATION_COUNT(call_ref_1(Am.middleCols(1, 3), A.middleCols(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_2(Am.middleCols(1, 3), A.middleCols(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_4(Am.col(2), A.col(2)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_5(Am.col(2), A.col(2)), 0);
+
+  auto Bm = make_map(B);
+  VERIFY_EVALUATION_COUNT(call_ref_rm_1(Bm.middleRows(1, 3), B.middleRows(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_rm_2(Bm.middleRows(1, 3), B.middleRows(1, 3)), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_4(Bm.row(2), B.row(2).transpose()), 0);
+  VERIFY_EVALUATION_COUNT(call_ref_5(Bm.row(2), B.row(2).transpose()), 0);
+
+  Ref<const SparseMatrix<float>> Arc(A);
   //   VERIFY_EVALUATION_COUNT( call_ref_1(Arc, Arc),  0); // does not compile on purpose
   VERIFY_EVALUATION_COUNT(call_ref_2(Arc, Arc), 0);
 
@@ -140,6 +384,9 @@
     CALL_SUBTEST_1(check_const_correctness(SparseMatrix<float>()));
     CALL_SUBTEST_1(check_const_correctness(SparseMatrix<double, RowMajor>()));
     CALL_SUBTEST_2(call_ref());
+    CALL_SUBTEST_4(check_ref_slice_coeffs());
+    CALL_SUBTEST_4(check_noncompressed_ref_slices());
+    CALL_SUBTEST_4(check_noncompressed_ref_inner_vectors());
 
     CALL_SUBTEST_3(check_const_correctness(SparseVector<float>()));
     CALL_SUBTEST_3(check_const_correctness(SparseVector<double, RowMajor>()));
diff --git a/test/sparse_scatter.cpp b/test/sparse_scatter.cpp
new file mode 100644
index 0000000..f944d70
--- /dev/null
+++ b/test/sparse_scatter.cpp
@@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/SparseCore>
+#define EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+#include "AnnoyingScalar.h"
+
+template <typename Scalar, typename StorageIndex, typename Values>
+Index apply_sparse_scatter(Scalar* dense, const StorageIndex* indices, const MatrixBase<Values>& values) {
+  const Index processed = internal::sparse_scatter_sub_packets(dense, indices, values);
+  VERIFY(processed >= 0 && processed <= values.size());
+  if (values.size() < 32 || NumTraits<Scalar>::IsComplex || !(internal::evaluator<Values>::Flags & PacketAccessBit))
+    VERIFY_IS_EQUAL(processed, Index(0));
+  else {
+    using Packet = typename internal::find_best_packet<Scalar, 4>::type;
+    VERIFY_IS_EQUAL(processed, values.size() - values.size() % internal::unpacket_traits<Packet>::size);
+  }
+  for (Index i = processed; i < values.size(); ++i) dense[indices[i]] -= values[i];
+  return processed;
+}
+
+template <typename Scalar, typename StorageIndex>
+void sparse_scatter() {
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  const Index capacity = 257;
+  Vector initial = Vector::Random(capacity), actual(capacity), expected(capacity);
+  Vector storage = Vector::Random(2 * capacity + 1);
+  Matrix<StorageIndex, Dynamic, 1> indices(capacity);
+  for (Index i = 0; i < capacity; ++i) indices[i] = StorageIndex((37 * i) % capacity);
+  const Scalar scale = internal::random<Scalar>();
+  // |inputs| <= sqrt(2): allow rounding in one product and one subtraction.
+  const RealScalar tolerance = RealScalar(8) * NumTraits<RealScalar>::epsilon();
+
+  for (Index size = 0; size <= 65; ++size) {
+    const Map<const Vector> values(storage.data() + 1, size);
+    actual = expected = initial;
+    for (Index i = 0; i < size; ++i) expected[indices[i]] -= scale * numext::conj(values[i]);
+    const Index expectedProcessed = apply_sparse_scatter(actual.data(), indices.data(), scale * values.conjugate());
+    VERIFY((actual - expected).cwiseAbs().maxCoeff() <= tolerance);
+
+    actual = initial;
+    const Index processed =
+        internal::sparse_scatter_sub_packets<true>(actual.data(), indices.data(), values.data(), size, scale);
+    VERIFY_IS_EQUAL(processed, expectedProcessed);
+    for (Index i = processed; i < size; ++i) actual[indices[i]] -= numext::conj(values[i]) * scale;
+    VERIFY((actual - expected).cwiseAbs().maxCoeff() <= tolerance);
+
+    const Map<const Vector, Unaligned, InnerStride<2>> strided(storage.data() + 1, size);
+    actual = expected = initial;
+    for (Index i = 0; i < size; ++i) expected[indices[i]] -= strided[i] * scale;
+    apply_sparse_scatter(actual.data(), indices.data(), strided * scale);
+    VERIFY((actual - expected).cwiseAbs().maxCoeff() <= tolerance);
+  }
+}
+
+void sparse_scatter_custom_scalar() {
+  Matrix<AnnoyingScalar, Dynamic, 1> values(33), actual(67);
+  VectorXi indices(33);
+  for (Index i = 0; i < actual.size(); ++i) actual[i] = AnnoyingScalar(3);
+  for (Index i = 0; i < values.size(); ++i) {
+    values[i] = AnnoyingScalar(int(i));
+    indices[i] = int(2 * i);
+  }
+  const AnnoyingScalar scale(2);
+  VERIFY_IS_EQUAL(
+      internal::sparse_scatter_sub_packets<false>(actual.data(), indices.data(), values.data(), values.size(), scale),
+      Index(0));
+  apply_sparse_scatter(actual.data(), indices.data(), values * AnnoyingScalar(2));
+  for (Index i = 0; i < actual.size(); ++i) {
+    const AnnoyingScalar expected(i % 2 == 0 && i < 66 ? 3 - int(i) : 3);
+    VERIFY_IS_EQUAL(actual[i], expected);
+  }
+}
+
+template <typename Scalar>
+void sparse_scatter_special_values() {
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  Vector values = Vector::Zero(65), actual = Vector::Zero(64), expected = actual;
+  VectorXi indices(64);
+  for (Index i = 0; i < indices.size(); ++i) indices[i] = int(63 - i);
+  values[1] = NumTraits<Scalar>::quiet_NaN();
+  values[2] = NumTraits<Scalar>::infinity();
+  values[3] = -NumTraits<Scalar>::infinity();
+  values[4] = -Scalar(0);
+  for (Index i = 0; i < actual.size(); ++i) expected[indices[i]] -= Scalar(2) * values[i + 1];
+  apply_sparse_scatter(actual.data(), indices.data(), Scalar(2) * values.tail(64));
+  for (Index i = 0; i < actual.size(); ++i) {
+    if ((numext::isnan)(expected[i])) {
+      VERIFY((numext::isnan)(actual[i]));
+    } else {
+      VERIFY_IS_EQUAL(actual[i], expected[i]);
+      VERIFY_IS_EQUAL(bool((numext::signbit)(actual[i])), bool((numext::signbit)(expected[i])));
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(sparse_scatter) {
+  CALL_SUBTEST_1((sparse_scatter<float, int>()));
+  CALL_SUBTEST_1((sparse_scatter<double, long long>()));
+  CALL_SUBTEST_1(sparse_scatter_special_values<float>());
+  CALL_SUBTEST_1(sparse_scatter_special_values<double>());
+  CALL_SUBTEST_2((sparse_scatter<std::complex<float>, int>()));
+  CALL_SUBTEST_2((sparse_scatter<std::complex<double>, long long>()));
+  CALL_SUBTEST_3(sparse_scatter_custom_scalar());
+}
diff --git a/test/sparse_solver.h b/test/sparse_solver.h
index 50cb463..60dfdd1 100644
--- a/test/sparse_solver.h
+++ b/test/sparse_solver.h
@@ -6,6 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_SPARSE_SOLVER_H
+#define EIGEN_TEST_SPARSE_SOLVER_H
 
 #include "sparse.h"
 #include <Eigen/SparseCore>
@@ -100,8 +104,10 @@
     // Test with a Map and non-unit stride.
     Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> out(2 * xm.rows(), 2 * xm.cols());
     out.setZero();
+    // The outer stride spans DenseRhs's outer dimension, so it must be taken from outerStride()
+    // rather than from rows(): the two differ when DenseRhs is row major.
     Eigen::Map<DenseRhs, 0, Stride<Eigen::Dynamic, 2>> outm(out.data(), xm.rows(), xm.cols(),
-                                                            Stride<Eigen::Dynamic, 2>(2 * xm.rows(), 2));
+                                                            Stride<Eigen::Dynamic, 2>(2 * xm.outerStride(), 2));
     outm = solver.solve(bm);
     VERIFY(outm.isApprox(refX, test_precision<Scalar>()));
   }
@@ -149,6 +155,8 @@
   }
 }
 
+#endif  // EIGEN_TEST_SPARSE_SOLVER_H
+
 // specialization of generic check_sparse_solving for SuperLU in order to also test adjoint and transpose solves
 template <typename Scalar, typename Rhs, typename DenseMat, typename DenseRhs>
 void check_sparse_solving(Eigen::SparseLU<Eigen::SparseMatrix<Scalar>>& solver,
@@ -335,6 +343,28 @@
 }
 
 template <typename Solver, typename DenseMat>
+void check_sparse_log_abs_determinant(Solver& solver, const typename Solver::MatrixType& A, const DenseMat& dA) {
+  typedef typename Solver::MatrixType Mat;
+  typedef typename Mat::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+
+  solver.compute(A);
+  if (solver.info() != Success) {
+    std::cerr << "WARNING | sparse solver testing: factorization failed (check_sparse_log_abs_determinant)\n";
+    return;
+  }
+
+  Scalar refDet = dA.determinant();
+  RealScalar refAbsDet = numext::abs(refDet);
+  VERIFY_IS_APPROX(refAbsDet, solver.absDeterminant());
+  VERIFY_IS_APPROX(numext::sign(refDet), solver.signDeterminant());
+  // log|det| crosses zero, so the meaningful bound here is absolute once |log|det|| drops below one.
+  RealScalar refLogAbsDet = numext::log(refAbsDet);
+  VERIFY_IS_MUCH_SMALLER_THAN(solver.logAbsDeterminant() - refLogAbsDet,
+                              numext::maxi(RealScalar(1), numext::abs(refLogAbsDet)));
+}
+
+template <typename Solver, typename DenseMat>
 int generate_sparse_spd_problem(Solver&, typename Solver::MatrixType& A, typename Solver::MatrixType& halfA,
                                 DenseMat& dA, int maxSize = 300) {
   typedef typename Solver::MatrixType Mat;
@@ -365,7 +395,7 @@
 template <typename Scalar>
 inline std::string get_matrixfolder() {
   std::string mat_folder = TEST_REAL_CASES;
-  if (internal::is_same<Scalar, std::complex<float>>::value || internal::is_same<Scalar, std::complex<double>>::value)
+  if (std::is_same<Scalar, std::complex<float>>::value || std::is_same<Scalar, std::complex<double>>::value)
     mat_folder = mat_folder + static_cast<std::string>("/complex/");
   else
     mat_folder = mat_folder + static_cast<std::string>("/real/");
@@ -434,7 +464,7 @@
   // First, get the folder
 #ifdef TEST_REAL_CASES
   // Test real problems with double precision only
-  if (internal::is_same<typename NumTraits<Scalar>::Real, double>::value) {
+  if (std::is_same<typename NumTraits<Scalar>::Real, double>::value) {
     std::string mat_folder = get_matrixfolder<Scalar>();
     MatrixMarketIterator<Scalar> it(mat_folder);
     for (; it; ++it) {
@@ -478,10 +508,23 @@
   DenseMatrix dA;
   generate_sparse_spd_problem(solver, A, halfA, dA, 30);
 
-  for (int i = 0; i < g_repeat; i++) {
-    check_sparse_determinant(solver, A, dA);
-    check_sparse_determinant(solver, halfA, dA);
-  }
+  check_sparse_determinant(solver, A, dA);
+  check_sparse_determinant(solver, halfA, dA);
+}
+
+template <typename Solver>
+void check_sparse_spd_log_abs_determinant(Solver& solver) {
+  typedef typename Solver::MatrixType Mat;
+  typedef typename Mat::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
+
+  // generate the problem
+  Mat A, halfA;
+  DenseMatrix dA;
+  generate_sparse_spd_problem(solver, A, halfA, dA, 30);
+
+  check_sparse_log_abs_determinant(solver, A, dA);
+  check_sparse_log_abs_determinant(solver, halfA, dA);
 }
 
 template <typename Solver, typename DenseMat>
@@ -575,6 +618,23 @@
 }
 
 template <typename Solver>
+void check_sparse_nonhermitian_log_abs_determinant(Solver& solver) {
+  typedef typename Solver::MatrixType Mat;
+  typedef typename Mat::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
+
+  // generate the problem
+  Mat A, halfA;
+  DenseMatrix dA;
+  generate_sparse_nonhermitian_problem(solver, A, halfA, dA, 30);
+
+  for (int i = 0; i < g_repeat; i++) {
+    check_sparse_log_abs_determinant(solver, A, dA);
+    check_sparse_log_abs_determinant(solver, halfA, dA);
+  }
+}
+
+template <typename Solver>
 void check_sparse_zero_matrix(Solver& solver) {
   typedef typename Solver::MatrixType Mat;
 
@@ -656,7 +716,7 @@
   // First, get the folder
 #ifdef TEST_REAL_CASES
   // Test real problems with double precision only
-  if (internal::is_same<typename NumTraits<Scalar>::Real, double>::value) {
+  if (std::is_same<typename NumTraits<Scalar>::Real, double>::value) {
     std::string mat_folder = get_matrixfolder<Scalar>();
     MatrixMarketIterator<Scalar> it(mat_folder);
     for (; it; ++it) {
diff --git a/test/sparse_solvers.cpp b/test/sparse_solvers.cpp
index 199dfff..1d9ff96 100644
--- a/test/sparse_solvers.cpp
+++ b/test/sparse_solvers.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse.h"
 
@@ -90,10 +91,143 @@
     m2.template triangularView<Upper>().solveInPlace(matB);
     VERIFY_IS_APPROX(matB, refMatB);
 
-    // test deprecated API
-    initSparse<Scalar>(density, refMat2, m2, ForceNonZeroDiag | MakeLowerTriangular, &zeroCoords, &nonzeroCoords);
-    VERIFY_IS_APPROX(refMat2.template triangularView<Lower>().solve(vec2),
-                     m2.template triangularView<Lower>().solve(vec3));
+    // A triangularView is a view of the triangular PART of a possibly-general matrix,
+    // so the stored matrix need not be strictly triangular. Exercise a general lhs, a
+    // SparseVector rhs, a mismatched-StorageIndex rhs, an uncompressed lhs, an
+    // expression lhs, and a unit diagonal -- none of which the checks above cover.
+    {
+      SparseMatrix<Scalar> mg(rows, rows);
+      DenseMatrix refMatG = DenseMatrix::Zero(rows, rows);
+      initSparse<Scalar>(density, refMatG, mg, ForceNonZeroDiag);  // GENERAL (both triangles stored)
+      initSparse<Scalar>(density, refMatB, matB);
+
+      // general matrix through a lower / upper / unit-upper view, sparse rhs
+      for (int mode = 0; mode < 3; ++mode) {
+        DenseMatrix rb = refMatB;
+        SparseMatrix<Scalar> mb = matB;
+        if (mode == 0) {
+          refMatG.template triangularView<Lower>().solveInPlace(rb);
+          mg.template triangularView<Lower>().solveInPlace(mb);
+        } else if (mode == 1) {
+          refMatG.template triangularView<Upper>().solveInPlace(rb);
+          mg.template triangularView<Upper>().solveInPlace(mb);
+        } else {
+          refMatG.template triangularView<UnitUpper>().solveInPlace(rb);
+          mg.template triangularView<UnitUpper>().solveInPlace(mb);
+        }
+        VERIFY_IS_APPROX(mb.toDense(), rb);
+      }
+
+      // expression lhs (no raw storage -> iterator path)
+      {
+        DenseMatrix rb = refMatB;
+        SparseMatrix<Scalar> mb = matB;
+        refMatG.template triangularView<Upper>().solveInPlace(rb);
+        (Scalar(1) * mg).template triangularView<Upper>().solveInPlace(mb);
+        VERIFY_IS_APPROX(mb.toDense(), rb);
+      }
+
+      // uncompressed lhs (innerNonZeroPtr != null)
+      {
+        DenseMatrix rb = refMatB;
+        SparseMatrix<Scalar> mb = matB, mu = mg;
+        mu.reserve(Matrix<int, Dynamic, 1>::Constant(mu.cols(), rows));  // -> uncompressed
+        refMatG.template triangularView<Lower>().solveInPlace(rb);
+        mu.template triangularView<Lower>().solveInPlace(mb);
+        VERIFY_IS_APPROX(mb.toDense(), rb);
+      }
+
+      // mismatched-StorageIndex rhs (-> InnerIterator fallback)
+      {
+        DenseMatrix rb = refMatB;
+        SparseMatrix<Scalar, ColMajor, long> mbl = matB;
+        refMatG.template triangularView<Lower>().solveInPlace(rb);
+        mg.template triangularView<Lower>().solveInPlace(mbl);
+        VERIFY_IS_APPROX(DenseMatrix(mbl), rb);
+      }
+
+      // SparseVector rhs (sets CompressedAccessBit but its outerIndexPtr() is null)
+      {
+        DenseVector rv = DenseVector::Zero(rows);
+        SparseVector<Scalar> vb(rows);
+        for (Index i = 0; i < rows; ++i)
+          if (internal::random<int>(0, 2) == 0) {
+            Scalar s = internal::random<Scalar>();
+            vb.coeffRef(i) = s;
+            rv(i) = s;
+          }
+        DenseVector rref = refMatG.template triangularView<Lower>().solve(rv);
+        SparseVector<Scalar> vx = vb;
+        mg.template triangularView<Lower>().solveInPlace(vx);
+        VERIFY_IS_APPROX(DenseVector(vx), rref);
+      }
+
+      // explicitly-stored zero rhs entries must not expand into stored zeros: the reach
+      // is a structural bound, so a zero rhs coefficient (or one that cancels to zero)
+      // is pruned at insertion rather than materialized across the whole reach.
+      {
+        SparseMatrix<Scalar> mb(rows, matB.cols());
+        DenseMatrix rb = DenseMatrix::Zero(rows, matB.cols());
+        for (Index c = 0; c < mb.cols(); ++c)
+          for (Index i = 0; i < rows; ++i)
+            if (internal::random<int>(0, 3) == 0) {
+              Scalar s = internal::random<int>(0, 2) == 0 ? Scalar(0) : internal::random<Scalar>();  // some explicit 0
+              mb.insert(i, c) = s;
+              rb(i, c) = s;
+            }
+        mb.makeCompressed();
+        refMatG.template triangularView<Lower>().solveInPlace(rb);
+        mg.template triangularView<Lower>().solveInPlace(mb);
+        VERIFY_IS_APPROX(mb.toDense(), rb);
+        for (Index c = 0; c < mb.cols(); ++c)
+          for (typename SparseMatrix<Scalar>::InnerIterator it(mb, c); it; ++it)
+            VERIFY(!numext::is_exactly_zero(it.value()));  // no stored zeros
+      }
+
+      // A reached column with no stored diagonal (non-unit) is out of contract: it must
+      // assert in debug on every path (pointer/iterator x lower/upper), rather than the
+      // failure being silently keyed to has_compressed_access. In release these divide by
+      // zero -> inf/NaN with no out-of-bounds read (covered by the sanitizer drivers).
+      {
+        SparseMatrix<Scalar> us(3, 3);
+        us.insert(0, 1) = Scalar(1);
+        us.insert(1, 1) = Scalar(2);
+        us.insert(2, 2) = Scalar(3);
+        us.makeCompressed();  // column 0 empty -> reached from rhs(0) but no diagonal
+        SparseMatrix<Scalar> ub(3, 1);
+        ub.insert(0, 0) = Scalar(1);
+        ub.makeCompressed();
+        SparseMatrix<Scalar> up = ub, ui = ub;
+        VERIFY_RAISES_ASSERT(us.template triangularView<Upper>().solveInPlace(up));                // pointer upper
+        VERIFY_RAISES_ASSERT((Scalar(1) * us).template triangularView<Upper>().solveInPlace(ui));  // iterator upper
+
+        SparseMatrix<Scalar> ls(3, 3);
+        ls.insert(0, 0) = Scalar(2);
+        ls.insert(1, 1) = Scalar(3);
+        ls.makeCompressed();  // column 2 empty (last) -> reached from rhs(2) but no diagonal
+        SparseMatrix<Scalar> lb(3, 1);
+        lb.insert(2, 0) = Scalar(1);
+        lb.makeCompressed();
+        SparseMatrix<Scalar> lp = lb, li = lb;
+        VERIFY_RAISES_ASSERT(ls.template triangularView<Lower>().solveInPlace(lp));                // pointer lower
+        VERIFY_RAISES_ASSERT((Scalar(1) * ls).template triangularView<Lower>().solveInPlace(li));  // iterator lower
+      }
+
+      // mixed-scalar rhs: a real lhs applied to a rhs must accumulate in the rhs scalar.
+      // For real Scalar this is the ordinary path; for complex Scalar it is the
+      // real-factor / complex-data case that must both compile and be correct.
+      {
+        typedef typename NumTraits<Scalar>::Real Real;
+        SparseMatrix<Real> mr(rows, rows);
+        Matrix<Real, Dynamic, Dynamic> refMatR = Matrix<Real, Dynamic, Dynamic>::Zero(rows, rows);
+        initSparse<Real>(density, refMatR, mr, ForceNonZeroDiag);
+        DenseMatrix rb = refMatB;
+        SparseMatrix<Scalar> mb = matB;
+        refMatR.template cast<Scalar>().template triangularView<Lower>().solveInPlace(rb);
+        mr.template triangularView<Lower>().solveInPlace(mb);  // SparseMatrix<Real> lhs, <Scalar> rhs
+        VERIFY_IS_APPROX(mb.toDense(), rb);
+      }
+    }
 
     // test empty triangular matrix
     {
diff --git a/test/sparse_threaded_product.cpp b/test/sparse_threaded_product.cpp
new file mode 100644
index 0000000..ecc1de9
--- /dev/null
+++ b/test/sparse_threaded_product.cpp
@@ -0,0 +1,228 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_USE_THREADS 1
+#include "sparse.h"
+
+// Pulls in the ThreadedSparseProduct header via the SparseCore module.
+// (Eigen/Sparse -> Eigen/SparseCore conditional include under EIGEN_USE_THREADS.)
+#include <Eigen/SparseCore>
+
+template <typename SparseMatrixType, typename DenseVectorType>
+void verify_threaded_spmv(Index rows, Index cols, double density) {
+  typedef typename SparseMatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
+
+  DenseMatrix refMat(rows, cols);
+  SparseMatrixType A(rows, cols);
+  initSparse<Scalar>(density, refMat, A);
+  A.makeCompressed();
+
+  DenseVectorType x_fwd = DenseVectorType::Random(cols);
+  DenseVectorType x_adj = DenseVectorType::Random(rows);
+
+  // Reference results via the existing dense path.
+  DenseVectorType y_fwd_ref = refMat * x_fwd;
+  DenseVectorType y_adj_ref = refMat.adjoint() * x_adj;
+
+  ThreadedSparseProduct<SparseMatrixType> op(A);
+  VERIFY(op.rows() == A.rows());
+  VERIFY(op.cols() == A.cols());
+
+  // Overwriting forms.
+  {
+    DenseVectorType y(rows);
+    y.setRandom();
+    op.apply(x_fwd, y);
+    VERIFY_IS_APPROX(y, y_fwd_ref);
+  }
+  {
+    DenseVectorType y(cols);
+    y.setRandom();
+    op.applyAdjoint(x_adj, y);
+    VERIFY_IS_APPROX(y, y_adj_ref);
+  }
+
+  // Accumulating forms: y += alpha * A * x, with both alpha = 1 and a
+  // non-trivial alpha.
+  for (Scalar alpha : {Scalar(1), Scalar(internal::random<Scalar>())}) {
+    {
+      DenseVectorType y0 = DenseVectorType::Random(rows);
+      DenseVectorType y_ref = y0 + alpha * y_fwd_ref;
+      DenseVectorType y = y0;
+      op.applyAddTo(x_fwd, y, alpha);
+      VERIFY_IS_APPROX(y, y_ref);
+    }
+    {
+      DenseVectorType y0 = DenseVectorType::Random(cols);
+      DenseVectorType y_ref = y0 + alpha * y_adj_ref;
+      DenseVectorType y = y0;
+      op.applyAdjointAddTo(x_adj, y, alpha);
+      VERIFY_IS_APPROX(y, y_ref);
+    }
+  }
+
+  // Calling adjoint must have materialized the mirror; calling it again must
+  // not rebuild (no easy assertion for "not rebuilt", but verify the path is
+  // consistent across repeated calls).
+  VERIFY(op.hasMirror());
+  {
+    DenseVectorType y(cols);
+    op.applyAdjoint(x_adj, y);
+    VERIFY_IS_APPROX(y, y_adj_ref);
+  }
+
+  // Re-running analyzePattern must invalidate the mirror.
+  op.analyzePattern(A);
+  VERIFY(!op.hasMirror());
+  {
+    DenseVectorType y(cols);
+    op.applyAdjoint(x_adj, y);
+    VERIFY_IS_APPROX(y, y_adj_ref);
+  }
+
+  // Coefficient-only invalidation: mutate the bound matrix's stored values
+  // (same sparsity pattern), call refreshValues(), and verify the next
+  // mirror-using direction picks up the new coefficients. The mirror is
+  // materialized lazily by the direction that needs the transposed view --
+  // forward for ColMajor A, adjoint for RowMajor A -- so call both to warm
+  // it regardless of storage order.
+  {
+    DenseVectorType y_fwd(rows);
+    DenseVectorType y_adj(cols);
+    op.apply(x_fwd, y_fwd);
+    op.applyAdjoint(x_adj, y_adj);
+    VERIFY(op.hasMirror());
+  }
+  for (Index k = 0; k < A.nonZeros(); ++k) A.valuePtr()[k] *= Scalar(2);
+  refMat *= Scalar(2);
+  DenseVectorType y_fwd_ref_updated = refMat * x_fwd;
+  DenseVectorType y_adj_ref_updated = refMat.adjoint() * x_adj;
+  op.refreshValues();
+  VERIFY(!op.hasMirror());
+  {
+    DenseVectorType y(rows);
+    op.apply(x_fwd, y);
+    VERIFY_IS_APPROX(y, y_fwd_ref_updated);
+  }
+  {
+    DenseVectorType y(cols);
+    op.applyAdjoint(x_adj, y);
+    VERIFY_IS_APPROX(y, y_adj_ref_updated);
+  }
+}
+
+// IEEE-754 propagation through the ColMajor SpMV OMP scatter/reduce path
+// (Eigen/src/SparseCore/SparseDenseProduct.h). With OpenMP enabled, the
+// kernel sums per-thread scratch buffers into y; NaN/Inf in any thread's
+// contribution must propagate to the reduced sum. Without OpenMP this still
+// exercises the serial scatter, where the same propagation must hold.
+template <typename Scalar>
+void verify_threaded_scatter_ieee754() {
+  typedef SparseMatrix<Scalar, ColMajor> SpMat;
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  typedef typename NumTraits<Scalar>::Real Real;
+
+  // Pin the OMP team size so the scatter/reduce gate (nnz >= threads * m)
+  // is deterministic across runs.
+  const int prev_threads = Eigen::nbThreads();
+  Eigen::setNbThreads(4);
+
+  // 300x300 with diagonal + (i+j)%4==0 entries -> ~22600 nnz, above the
+  // 20000-nnz threshold and well above threads*m = 4*300 for the gate.
+  const Index n = 300;
+  std::vector<Triplet<Scalar> > triplets;
+  triplets.reserve(static_cast<std::size_t>(n) * (n / 4 + 1));
+  // Simple deterministic LCG so we don't depend on <random> being included
+  // transitively. Modulo-bounded so we don't rely on a specific integer width.
+  unsigned rng = 0xC0FFEEu;
+  for (int j = 0; j < int(n); ++j) {
+    for (int i = 0; i < int(n); ++i) {
+      if (i == j || (i + j) % 4 == 0) {
+        rng = (rng * 1664525u + 1013904223u) & 0xFFFFu;
+        const Real v = Real(0.1) + Real(0.9) * Real(rng) / Real(0xFFFF);
+        triplets.push_back(Triplet<Scalar>(i, j, Scalar(v)));
+      }
+    }
+  }
+  SpMat A(n, n);
+  A.setFromTriplets(triplets.begin(), triplets.end());
+  A.makeCompressed();
+  VERIFY(A.nonZeros() > 20000);
+
+  // Inject NaN/Inf into three rows of column 0 by overwriting valuePtr().
+  // Pick rows that are guaranteed in column 0's pattern: row 0 (diagonal),
+  // row 4 ((4+0)%4==0), row 8 ((8+0)%4==0).
+  const Real nan_r = std::numeric_limits<Real>::quiet_NaN();
+  const Real inf_r = std::numeric_limits<Real>::infinity();
+  const Index i_nan = 0, i_pinf = 4, i_ninf = 8;
+  bool set_nan = false, set_pinf = false, set_ninf = false;
+  for (Index k = A.outerIndexPtr()[0]; k < A.outerIndexPtr()[1]; ++k) {
+    const Index i = A.innerIndexPtr()[k];
+    if (i == i_nan) {
+      A.valuePtr()[k] = Scalar(nan_r);
+      set_nan = true;
+    } else if (i == i_pinf) {
+      A.valuePtr()[k] = Scalar(inf_r);
+      set_pinf = true;
+    } else if (i == i_ninf) {
+      A.valuePtr()[k] = Scalar(-inf_r);
+      set_ninf = true;
+    }
+  }
+  VERIFY(set_nan && set_pinf && set_ninf);
+
+  Vec x = Vec::Random(n);
+  // Ensure x[0] is finite and strictly positive (real part), so the injected
+  // ±Inf contributions don't cancel against a zero-multiplier or flip sign.
+  x[0] = Scalar(1);
+
+  Vec y = A * x;
+
+  VERIFY((numext::isnan)(numext::real(y[i_nan])));
+  VERIFY((numext::isinf)(numext::real(y[i_pinf])) && numext::real(y[i_pinf]) > Real(0));
+  VERIFY((numext::isinf)(numext::real(y[i_ninf])) && numext::real(y[i_ninf]) < Real(0));
+
+  Eigen::setNbThreads(prev_threads);
+}
+
+template <typename Scalar>
+void run_grid() {
+  typedef Matrix<Scalar, Dynamic, 1> Vec;
+  // Cover both storage orders, square and rectangular, small (serial path,
+  // nnz < threshold) and larger (threaded path).
+  for (int order = 0; order < 2; ++order) {
+    if (order == 0) {
+      verify_threaded_spmv<SparseMatrix<Scalar, ColMajor>, Vec>(8, 8, 0.5);
+      verify_threaded_spmv<SparseMatrix<Scalar, ColMajor>, Vec>(13, 21, 0.3);
+      verify_threaded_spmv<SparseMatrix<Scalar, ColMajor>, Vec>(500, 500, 0.15);
+      verify_threaded_spmv<SparseMatrix<Scalar, ColMajor>, Vec>(800, 400, 0.10);
+      // Large enough that nnz > kThreadingThreshold (20000) to exercise the
+      // multi-threaded dispatch path.
+      verify_threaded_spmv<SparseMatrix<Scalar, ColMajor>, Vec>(1500, 1500, 0.02);
+    } else {
+      verify_threaded_spmv<SparseMatrix<Scalar, RowMajor>, Vec>(8, 8, 0.5);
+      verify_threaded_spmv<SparseMatrix<Scalar, RowMajor>, Vec>(21, 13, 0.3);
+      verify_threaded_spmv<SparseMatrix<Scalar, RowMajor>, Vec>(500, 500, 0.15);
+      verify_threaded_spmv<SparseMatrix<Scalar, RowMajor>, Vec>(400, 800, 0.10);
+      verify_threaded_spmv<SparseMatrix<Scalar, RowMajor>, Vec>(1500, 1500, 0.02);
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(sparse_threaded_product) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1(run_grid<float>());
+    CALL_SUBTEST_2(run_grid<double>());
+    CALL_SUBTEST_3(run_grid<std::complex<double> >());
+    CALL_SUBTEST_4(verify_threaded_scatter_ieee754<double>());
+    CALL_SUBTEST_4(verify_threaded_scatter_ieee754<float>());
+  }
+}
diff --git a/test/sparse_vector.cpp b/test/sparse_vector.cpp
index e4b1963..18a8c0c 100644
--- a/test/sparse_vector.cpp
+++ b/test/sparse_vector.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "sparse.h"
 
@@ -26,7 +27,12 @@
   DenseVector refV1 = DenseVector::Random(rows), refV2 = DenseVector::Random(rows), refV3 = DenseVector::Random(rows);
 
   std::vector<int> zerocoords, nonzerocoords;
-  initSparse<Scalar>(densityVec, refV1, v1, &zerocoords, &nonzerocoords);
+  // Retry until at least one nonzero is produced: code below indexes nonzerocoords[0].
+  do {
+    zerocoords.clear();
+    nonzerocoords.clear();
+    initSparse<Scalar>(densityVec, refV1, v1, &zerocoords, &nonzerocoords);
+  } while (nonzerocoords.empty());
   initSparse<Scalar>(densityMat, refM1, m1);
 
   initSparse<Scalar>(densityVec, refV2, v2);
diff --git a/test/sparselu.cpp b/test/sparselu.cpp
index d933136..95e0963 100644
--- a/test/sparselu.cpp
+++ b/test/sparselu.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 // SparseLU solve does not accept column major matrices for the destination.
 // However, as expected, the generic check_sparse_square_solving routines produces row-major
@@ -16,6 +17,7 @@
 #endif
 
 #include "sparse_solver.h"
+#include "fp_control.h"
 #include <Eigen/SparseLU>
 
 template <typename T>
@@ -35,9 +37,164 @@
   check_sparse_square_determinant(sparselu_amd);
 }
 
+template <typename T>
+void test_sparselu_rowmajor_compressed_input() {
+  typedef SparseMatrix<T, RowMajor> RowMajorSparseMatrix;
+  typedef Matrix<T, Dynamic, 1> Vector;
+
+  Vector b(2);
+  b << T(1.1), T(3.14);
+
+  Vector expected(2);
+  expected << T(1.1 - 0.0001 * 3.14), T(3.14);
+
+  RowMajorSparseMatrix compressed(2, 2);
+  compressed.insert(0, 0) = T(1.0);
+  compressed.insert(0, 1) = T(0.0001);
+  compressed.insert(1, 1) = T(1.0);
+  compressed.makeCompressed();
+
+  RowMajorSparseMatrix uncompressed(2, 2);
+  uncompressed.insert(0, 0) = T(1.0);
+  uncompressed.insert(0, 1) = T(0.0001);
+  uncompressed.insert(1, 1) = T(1.0);
+
+  SparseLU<RowMajorSparseMatrix> compressed_solver;
+  compressed_solver.compute(compressed);
+  VERIFY_IS_EQUAL(compressed_solver.info(), Success);
+  VERIFY_IS_APPROX(compressed_solver.solve(b), expected);
+
+  SparseLU<RowMajorSparseMatrix> two_step_solver;
+  two_step_solver.analyzePattern(compressed);
+  two_step_solver.factorize(compressed);
+  VERIFY_IS_EQUAL(two_step_solver.info(), Success);
+  VERIFY_IS_APPROX(two_step_solver.solve(b), expected);
+
+  SparseLU<RowMajorSparseMatrix> uncompressed_solver;
+  uncompressed_solver.compute(uncompressed);
+  VERIFY_IS_EQUAL(uncompressed_solver.info(), Success);
+  VERIFY_IS_APPROX(uncompressed_solver.solve(b), expected);
+}
+
+template <typename T>
+void test_sparselu_colmajor_uncompressed_input() {
+  typedef SparseMatrix<T, ColMajor> ColMajorSparseMatrix;
+  typedef Matrix<T, Dynamic, 1> Vector;
+
+  Vector b(2);
+  b << T(1.1), T(3.14);
+
+  Vector expected(2);
+  expected << T(1.1 - 0.0001 * 3.14), T(3.14);
+
+  ColMajorSparseMatrix uncompressed(2, 2);
+  uncompressed.insert(0, 0) = T(1.0);
+  uncompressed.insert(0, 1) = T(0.0001);
+  uncompressed.insert(1, 1) = T(1.0);
+
+  SparseLU<ColMajorSparseMatrix> uncompressed_solver;
+  uncompressed_solver.compute(uncompressed);
+  VERIFY_IS_EQUAL(uncompressed_solver.info(), Success);
+  VERIFY_IS_APPROX(uncompressed_solver.solve(b), expected);
+}
+
+// Regression for issue #1908: lastErrorMessage() must not carry over from a
+// previous failed factorize() once a subsequent factorize() succeeds.
+template <typename T>
+void test_sparselu_clear_error_state() {
+  typedef SparseMatrix<T, ColMajor> ColMajorSparseMatrix;
+
+  ColMajorSparseMatrix singular(3, 3);  // structurally singular: no nonzeros
+
+  ColMajorSparseMatrix non_singular(3, 3);
+  non_singular.insert(0, 0) = T(1);
+  non_singular.insert(1, 1) = T(1);
+  non_singular.insert(2, 2) = T(1);
+  non_singular.makeCompressed();
+
+  SparseLU<ColMajorSparseMatrix> solver;
+  solver.compute(singular);
+  VERIFY(solver.info() != Success);
+  VERIFY(!solver.lastErrorMessage().empty());
+
+  solver.compute(non_singular);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY(solver.lastErrorMessage().empty());
+}
+
+// A = M diag(1, .., s, .., 1), M = n I + ones, with s and the pivot of the scaled column subnormal: A is well
+// conditioned up to that column scaling, but 1 / pivot overflows, which used to fill the column of L with Inf
+// while info() reported Success. det A = +-2 n^n s, and the solve is judged by its componentwise backward error
+// max_i |b - A x|_i / (|A| |x| + |b|)_i, which a column scaling leaves unchanged.
+template <typename T, typename Ordering>
+void test_sparselu_subnormal_pivot(Index n, Index scaledColumn, const T& phase) {
+  using Real = typename NumTraits<T>::Real;
+  using DenseMatrix = Matrix<T, Dynamic, Dynamic>;
+  using DenseVector = Matrix<T, Dynamic, 1>;
+  using RealVector = Matrix<Real, Dynamic, 1>;
+
+  if (!subnormalDivisionIsExact<Real>() || underflowProbe<Real>() == Real(0)) {
+    std::cout << "SKIP: test_sparselu_subnormal_pivot needs gradual underflow and IEEE 754 division by subnormals."
+              << std::endl;
+    return;
+  }
+
+  // 1 / pivot overflows for |pivot| < min / 4, and the pivot is about (n + 1) s. A subnormal near s carries
+  // only log2(s / denorm_min) bits, hence the unit roundoff u.
+  const Real s = (std::numeric_limits<Real>::min)() / Real(32);
+  const Real u = numext::maxi(NumTraits<Real>::epsilon(), (std::numeric_limits<Real>::denorm_min)() / s);
+  const Real tolerance = Real(16 * n) * u;
+  Real detM = Real(2);
+  for (Index i = 0; i < n; ++i) detM *= Real(n);
+
+  for (int swap = 0; swap < 2; ++swap) {
+    DenseMatrix dense = DenseMatrix::Ones(n, n);
+    dense.diagonal().array() += T(Real(n));
+    dense.col(scaledColumn) *= T(s) * phase;
+    if (swap) dense.row(0).swap(dense.row(1));
+    // Inserted explicitly: sparseView() prunes on a squared magnitude, which underflows here.
+    SparseMatrix<T> sparse(n, n);
+    sparse.reserve(VectorXi::Constant(n, int(n)));
+    for (Index j = 0; j < n; ++j)
+      for (Index i = 0; i < n; ++i) sparse.insert(i, j) = dense(i, j);
+    sparse.makeCompressed();
+
+    SparseLU<SparseMatrix<T>, Ordering> lu(sparse);
+    VERIFY_IS_EQUAL(lu.info(), Success);
+
+    const T expectedDet = T(swap ? -detM : detM) * T(s) * phase;
+    VERIFY(numext::abs(lu.determinant() - expectedDet) <= tolerance * numext::abs(expectedDet));
+
+    // x = (.., 2^-10 / s, ..) keeps both A x and the solution representable.
+    DenseVector x = DenseVector::Ones(n);
+    x(scaledColumn) = T(Real(1) / (Real(1024) * s));
+    const DenseVector b = dense * x;
+    x = lu.solve(b);
+    VERIFY(x.allFinite());
+    const RealVector residual = (b - dense * x).cwiseAbs();
+    const RealVector scale = dense.cwiseAbs() * x.cwiseAbs() + b.cwiseAbs();
+    VERIFY((residual.array() <= tolerance * scale.array()).all());
+  }
+}
+
 EIGEN_DECLARE_TEST(sparselu) {
   CALL_SUBTEST_1(test_sparselu_T<float>());
   CALL_SUBTEST_2(test_sparselu_T<double>());
   CALL_SUBTEST_3(test_sparselu_T<std::complex<float> >());
   CALL_SUBTEST_4(test_sparselu_T<std::complex<double> >());
+  CALL_SUBTEST_5(test_sparselu_rowmajor_compressed_input<float>());
+  CALL_SUBTEST_6(test_sparselu_rowmajor_compressed_input<double>());
+  CALL_SUBTEST_7(test_sparselu_colmajor_uncompressed_input<float>());
+  CALL_SUBTEST_8(test_sparselu_colmajor_uncompressed_input<double>());
+  CALL_SUBTEST_9(test_sparselu_clear_error_state<float>());
+  CALL_SUBTEST_10(test_sparselu_clear_error_state<double>());
+  // The scaled column leads a supernode (0) or lies inside one (1); COLAMD is free to move it.
+  for (Index scaledColumn = 0; scaledColumn < 2; ++scaledColumn) {
+    CALL_SUBTEST_9((test_sparselu_subnormal_pivot<float, NaturalOrdering<int> >(4, scaledColumn, 1.0f)));
+    CALL_SUBTEST_9((test_sparselu_subnormal_pivot<float, COLAMDOrdering<int> >(2, scaledColumn, 1.0f)));
+    CALL_SUBTEST_10((test_sparselu_subnormal_pivot<double, NaturalOrdering<int> >(4, scaledColumn, 1.0)));
+    CALL_SUBTEST_10((test_sparselu_subnormal_pivot<double, COLAMDOrdering<int> >(2, scaledColumn, 1.0)));
+    CALL_SUBTEST_10((test_sparselu_subnormal_pivot<std::complex<double>, NaturalOrdering<int> >(
+        4, scaledColumn, std::complex<double>(0, 1))));
+  }
 }
diff --git a/test/sparseqr.cpp b/test/sparseqr.cpp
index 51ed398..09e4d8b 100644
--- a/test/sparseqr.cpp
+++ b/test/sparseqr.cpp
@@ -6,6 +6,7 @@
 //
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
+// SPDX-License-Identifier: MPL-2.0
 #include "sparse.h"
 #include <Eigen/SparseQR>
 
@@ -132,9 +133,190 @@
   dQ = solver.matrixQ();
   VERIFY_IS_APPROX(Q, dQ);
 }
+
+void test_sparseqr_factorize_uncompressed_input() {
+  typedef SparseMatrix<double, ColMajor> MatrixType;
+  typedef VectorXd Vector;
+  typedef SparseQR<MatrixType, NaturalOrdering<int> > Solver;
+
+  MatrixType uncompressed(2, 2);
+  VectorXi reserve(2);
+  reserve << 2, 3;
+  uncompressed.reserve(reserve);
+  uncompressed.insert(0, 0) = 1.0;
+  uncompressed.insert(0, 1) = 0.5;
+  uncompressed.insert(1, 1) = 1.0;
+
+  // Poison inactive capacity so factorize() must ignore unused slots in the
+  // uncompressed input instead of treating reserved space as structural nnz.
+  uncompressed.innerIndexPtr()[1] = 1;
+  uncompressed.valuePtr()[1] = 7.0;
+
+  MatrixType compressed = uncompressed;
+  compressed.makeCompressed();
+
+  Vector b(2);
+  b << 1.0, 2.0;
+  Vector expected(2);
+  expected << 0.0, 2.0;
+
+  Solver compressed_solver;
+  compressed_solver.compute(compressed);
+  VERIFY_IS_EQUAL(compressed_solver.info(), Success);
+  VERIFY_IS_APPROX(compressed_solver.solve(b), expected);
+
+  Solver two_step_solver;
+  two_step_solver.analyzePattern(compressed);
+  two_step_solver.factorize(uncompressed);
+  VERIFY_IS_EQUAL(two_step_solver.info(), Success);
+  VERIFY_IS_APPROX(two_step_solver.solve(b), expected);
+}
+
+template <typename OrderingType, typename DenseMat, typename DenseRhs>
+void verify_sparseqr_solves(const DenseMat& denseA, const DenseRhs& b, Index expectedRank) {
+  typedef typename DenseMat::Scalar Scalar;
+  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> SolutionType;
+
+  MatrixType A = denseA.sparseView();
+  A.makeCompressed();
+
+  SparseQR<MatrixType, OrderingType> solver(A);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_EQUAL(solver.rank(), expectedRank);
+  VERIFY(!solver.lastPivotLookAheadSkipped());
+
+  SolutionType x = solver.solve(b);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_APPROX(denseA * x, b);
+}
+
+void test_sparseqr_lookahead_rejects_replaceable_weak_pivot() {
+  Matrix<double, 4, 5> denseA;
+  denseA << 10.875, 0.0, 0.0, 0.0, 0.0, -0.397597, 12.1403, 0.0, 0.0, 0.0317254, -0.851737, -0.0269339, 11.3113,
+      0.0130592, 0.0, -0.676106, 0.0, 0.138752, 8.57745, 0.0;
+  Matrix<double, 4, 1> b;
+  b << 10.3612, -2.27836, -10.3179, -7.49344;
+
+  verify_sparseqr_solves<COLAMDOrdering<int> >(denseA, b, 4);
+}
+
+void test_sparseqr_tiny_independent_column() {
+  Matrix<double, 2, 3> denseA;
+  Matrix<double, 2, 1> b;
+
+  denseA << 0.5, 0.0, 0.0, 0.0, 1e12, 0.0;
+  b << 0.5, 0.0;
+  verify_sparseqr_solves<COLAMDOrdering<int> >(denseA, b, 2);
+
+  denseA << 1e12, 1e12, 0.0, 0.0, 0.5, 0.0;
+  b << 0.0, 0.5;
+  verify_sparseqr_solves<COLAMDOrdering<int> >(denseA, b, 2);
+}
+
+void test_sparseqr_lookahead_preserves_needed_weak_direction() {
+  Matrix<double, 3, 4> denseA;
+  Matrix<double, 3, 1> b;
+
+  denseA << 1.0, 1.0, 0.0, 0.0, 0.0, 5e-13, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0;
+  b << 0.0, 5.0, 0.0;
+  verify_sparseqr_solves<NaturalOrdering<int> >(denseA, b, 3);
+
+  denseA << 1.0, 1.0, 0.0, 0.0, 0.0, 5e-13, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0;
+  b << 0.0, 5.0, 0.0;
+  verify_sparseqr_solves<NaturalOrdering<int> >(denseA, b, 3);
+}
+
+void test_sparseqr_explicit_threshold_disables_lookahead() {
+  typedef SparseMatrix<double, ColMajor> MatrixType;
+  typedef SparseQR<MatrixType, NaturalOrdering<int> > Solver;
+
+  Matrix<double, 2, 3> denseA;
+  const double weak_pivot = 5e-13;
+  denseA << 1.0, 1.0, 0.0, 0.0, weak_pivot, 1.0;
+
+  MatrixType A = denseA.sparseView();
+  A.makeCompressed();
+
+  Solver default_solver(A);
+  VERIFY_IS_EQUAL(default_solver.info(), Success);
+  VERIFY_IS_EQUAL(default_solver.rank(), 2);
+  VERIFY(!default_solver.lastPivotLookAheadSkipped());
+
+  const Solver::PermutationType::IndicesType& defaultPerm = default_solver.colsPermutation().indices();
+  VERIFY_IS_EQUAL(defaultPerm.size(), 3);
+  for (Index j = 0; j < defaultPerm.size(); ++j) {
+    VERIFY(defaultPerm(j) >= 0);
+    VERIFY(defaultPerm(j) < defaultPerm.size());
+    for (Index k = j + 1; k < defaultPerm.size(); ++k) {
+      VERIFY_IS_NOT_EQUAL(defaultPerm(j), defaultPerm(k));
+    }
+  }
+  Matrix<double, 2, 1> b;
+  b << 1.0, 1.0;
+  VectorXd x = default_solver.solve(b);
+  VERIFY_IS_EQUAL(default_solver.info(), Success);
+  VERIFY_IS_APPROX(denseA * x, b);
+
+  Solver explicit_threshold_solver;
+  explicit_threshold_solver.setPivotThreshold(1e-14);
+  explicit_threshold_solver.compute(A);
+  VERIFY_IS_EQUAL(explicit_threshold_solver.info(), Success);
+  VERIFY_IS_EQUAL(explicit_threshold_solver.rank(), 2);
+  VERIFY(!explicit_threshold_solver.lastPivotLookAheadSkipped());
+  VERIFY_IS_EQUAL(explicit_threshold_solver.colsPermutation().indices()(0), 0);
+  VERIFY_IS_EQUAL(explicit_threshold_solver.colsPermutation().indices()(1), 1);
+  VERIFY_IS_EQUAL(explicit_threshold_solver.colsPermutation().indices()(2), 2);
+}
+
+template <typename Scalar>
+void test_sparseqr_16bit_default_threshold(int n, float tol) {
+  // Factorize a well-conditioned, full-rank, diagonally dominant tridiagonal
+  // (4 on the diagonal, -1 off-diagonal) system with the default pivot
+  // threshold. The default threshold 20*(m+n)*max2Norm*epsilon used to be
+  // computed entirely in the 16-bit scalar type, where 20*(m+n)*epsilon
+  // exceeds 1 for m+n as small as 52 (half) or 7 (bfloat16) -- so every pivot
+  // was rejected and the reported rank collapsed to 0 with info()==Success.
+  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
+  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
+
+  MatrixType A(n, n);
+  A.reserve(VectorXi::Constant(n, 3));
+  for (int j = 0; j < n; ++j) {
+    if (j > 0) A.insert(j - 1, j) = Scalar(-1);
+    A.insert(j, j) = Scalar(4);
+    if (j + 1 < n) A.insert(j + 1, j) = Scalar(-1);
+  }
+  A.makeCompressed();
+
+  SparseQR<MatrixType, COLAMDOrdering<int> > solver(A);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_EQUAL(solver.rank(), Index(n));
+
+  const DenseVector b = A * DenseVector::Ones(n);
+  const DenseVector x = solver.solve(b);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  // Check the relative residual in float: 16-bit norms of length-n vectors are
+  // unreliable. A is diagonally dominant with cond(A) <= 3, so a small
+  // residual also implies an accurate solution.
+  const VectorXf residual = (A * x - b).template cast<float>();
+  VERIFY(residual.norm() <= tol * b.template cast<float>().norm());
+}
+
 EIGEN_DECLARE_TEST(sparseqr) {
   for (int i = 0; i < g_repeat; ++i) {
     CALL_SUBTEST_1(test_sparseqr_scalar<double>());
     CALL_SUBTEST_2(test_sparseqr_scalar<std::complex<double> >());
   }
+  CALL_SUBTEST_3(test_sparseqr_factorize_uncompressed_input());
+  CALL_SUBTEST_4(test_sparseqr_lookahead_rejects_replaceable_weak_pivot());
+  CALL_SUBTEST_5(test_sparseqr_tiny_independent_column());
+  CALL_SUBTEST_6(test_sparseqr_explicit_threshold_disables_lookahead());
+  CALL_SUBTEST_7(test_sparseqr_lookahead_preserves_needed_weak_direction());
+  // The relative residual is a small multiple of the scalar's epsilon; bfloat16's coarser mantissa (7 bits vs
+  // half's 10) loses more per operation, so it needs the larger factor despite the smaller system.
+  CALL_SUBTEST_8(
+      test_sparseqr_16bit_default_threshold<Eigen::half>(400, static_cast<float>(NumTraits<Eigen::half>::epsilon())));
+  CALL_SUBTEST_8(test_sparseqr_16bit_default_threshold<Eigen::bfloat16>(
+      64, 4 * static_cast<float>(NumTraits<Eigen::bfloat16>::epsilon())));
 }
diff --git a/test/special_members.cpp b/test/special_members.cpp
new file mode 100644
index 0000000..d3af8b2
--- /dev/null
+++ b/test/special_members.cpp
@@ -0,0 +1,108 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#include <Eigen/Geometry>
+#include <Eigen/IterativeLinearSolvers>
+#include <Eigen/SVD>
+#include <Eigen/SparseCholesky>
+
+static_assert(std::is_trivially_destructible<AlignedBox<double, 3>>::value,
+              "AlignedBox should have a trivial destructor");
+static_assert(std::is_trivially_destructible<Hyperplane<double, 3>>::value,
+              "Hyperplane should have a trivial destructor");
+static_assert(std::is_trivially_destructible<ParametrizedLine<double, 3>>::value,
+              "ParametrizedLine should have a trivial destructor");
+
+static_assert(std::is_move_constructible<SimplicialLLT<SparseMatrix<double>>>::value,
+              "SimplicialLLT should be move constructible");
+static_assert(std::is_move_constructible<ConjugateGradient<SparseMatrix<double>, Lower | Upper>>::value,
+              "ConjugateGradient should be move constructible");
+static_assert(std::is_move_constructible<BiCGSTAB<SparseMatrix<double>>>::value,
+              "BiCGSTAB should be move constructible");
+
+using StorageVal = internal::StorageVal<double, int>;
+static_assert(std::is_copy_constructible<StorageVal>::value, "StorageVal should remain copy constructible");
+static_assert(std::is_move_constructible<StorageVal>::value, "StorageVal should remain move constructible");
+static_assert(!std::is_copy_assignable<StorageVal>::value, "StorageVal should not become copy assignable");
+static_assert(!std::is_move_assignable<StorageVal>::value, "StorageVal should not become move assignable");
+
+SparseMatrix<double> make_spd_matrix() {
+  SparseMatrix<double> matrix(3, 3);
+  std::vector<Triplet<double>> triplets;
+  triplets.push_back(Triplet<double>(0, 0, 4.0));
+  triplets.push_back(Triplet<double>(0, 1, -1.0));
+  triplets.push_back(Triplet<double>(1, 0, -1.0));
+  triplets.push_back(Triplet<double>(1, 1, 4.0));
+  triplets.push_back(Triplet<double>(1, 2, -1.0));
+  triplets.push_back(Triplet<double>(2, 1, -1.0));
+  triplets.push_back(Triplet<double>(2, 2, 3.0));
+  matrix.setFromTriplets(triplets.begin(), triplets.end());
+  matrix.makeCompressed();
+  return matrix;
+}
+
+template <typename Solver, typename MatrixType>
+Solver move_computed_solver(const MatrixType& matrix) {
+  Solver source;
+  source.compute(matrix);
+  VERIFY_IS_EQUAL(source.info(), Success);
+  Solver moved(std::move(source));
+  return moved;
+}
+
+void test_move_initialized_bdcsvd() {
+  MatrixXd matrix(3, 3);
+  matrix << 4.0, 1.0, 0.0, 1.0, 3.0, 1.0, 0.0, 1.0, 2.0;
+  VectorXd expected(3);
+  expected << 1.0, -2.0, 3.0;
+  const VectorXd rhs = matrix * expected;
+
+  typedef BDCSVD<MatrixXd, ComputeThinU | ComputeThinV> Solver;
+  Solver solver = move_computed_solver<Solver>(matrix);
+  const VectorXd actual = solver.solve(rhs);
+
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_APPROX(actual, expected);
+}
+
+void test_move_initialized_simplicial_llt() {
+  const SparseMatrix<double> matrix = make_spd_matrix();
+  VectorXd expected(3);
+  expected << 1.0, -2.0, 3.0;
+  const VectorXd rhs = matrix * expected;
+
+  typedef SimplicialLLT<SparseMatrix<double>> Solver;
+  Solver solver = move_computed_solver<Solver>(matrix);
+  const VectorXd actual = solver.solve(rhs);
+
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_APPROX(actual, expected);
+}
+
+template <typename Solver>
+void test_move_initialized_iterative_solver() {
+  const SparseMatrix<double> matrix = make_spd_matrix();
+  VectorXd expected(3);
+  expected << 1.0, -2.0, 3.0;
+  const VectorXd rhs = matrix * expected;
+
+  Solver solver = move_computed_solver<Solver>(matrix);
+  solver.setMaxIterations(100);
+  solver.setTolerance(NumTraits<double>::epsilon() * 100);
+  const VectorXd actual = solver.solve(rhs);
+
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_APPROX(actual, expected);
+}
+
+EIGEN_DECLARE_TEST(special_members) {
+  CALL_SUBTEST_1(test_move_initialized_bdcsvd());
+  CALL_SUBTEST_2(test_move_initialized_simplicial_llt());
+  CALL_SUBTEST_3((test_move_initialized_iterative_solver<ConjugateGradient<SparseMatrix<double>, Lower | Upper>>()));
+  CALL_SUBTEST_4((test_move_initialized_iterative_solver<BiCGSTAB<SparseMatrix<double>>>()));
+}
diff --git a/test/special_numbers.cpp b/test/special_numbers.cpp
index 943f650..c583d2b 100644
--- a/test/special_numbers.cpp
+++ b/test/special_numbers.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/split_test_helper.h b/test/split_test_helper.h
index 63c809c..ff5a205 100644
--- a/test/split_test_helper.h
+++ b/test/split_test_helper.h
@@ -1,3 +1,9 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_SPLIT_TEST_HELPER_H
+#define EIGEN_TEST_SPLIT_TEST_HELPER_H
+
 #if defined(EIGEN_TEST_PART_1) || defined(EIGEN_TEST_PART_ALL)
 #define CALL_SUBTEST_1(FUNC) CALL_SUBTEST(FUNC)
 #else
@@ -5991,3 +5997,5 @@
 #else
 #define CALL_SUBTEST_999(FUNC)
 #endif
+
+#endif  // EIGEN_TEST_SPLIT_TEST_HELPER_H
diff --git a/test/spqr_support.cpp b/test/spqr_support.cpp
index cd75825..5bda3f5 100644
--- a/test/spqr_support.cpp
+++ b/test/spqr_support.cpp
@@ -5,6 +5,7 @@
 //
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #include "sparse.h"
@@ -53,7 +54,104 @@
   refX = dA.colPivHouseholderQr().solve(b);
   VERIFY(x.isApprox(refX, test_precision<Scalar>()));
 }
+
+void test_spqr_fixed_ordering_uses_identity_permutation() {
+  typedef SparseMatrix<double, ColMajor> MatrixType;
+  typedef Matrix<double, Dynamic, Dynamic> DenseMatrix;
+  typedef Matrix<double, Dynamic, 1> DenseVector;
+
+  DenseMatrix dA(6, 4);
+  dA << 4.0, 1.0, 0.0, 0.0,  //
+      1.0, 0.0, 2.0, 0.0,    //
+      -2.0, 3.0, 0.0, 6.0,   //
+      0.0, 5.0, -1.0, 0.0,   //
+      0.0, 0.0, 7.0, 2.0,    //
+      0.0, 0.0, 0.0, 3.0;
+
+  MatrixType A = dA.sparseView();
+  A.makeCompressed();
+
+  DenseVector b(6);
+  b << 1.0, -2.0, 0.5, 4.0, -1.0, 3.0;
+
+  SPQR<MatrixType> solver;
+  solver.setSPQROrdering(SPQR_ORDERING_FIXED);
+  solver.setPivotThreshold(SPQR_NO_TOL);
+  solver.compute(A);
+
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_EQUAL(solver.rank(), A.cols());
+
+  const auto permutation = solver.colsPermutation();
+  VERIFY_IS_EQUAL(permutation.size(), A.cols());
+  for (Index i = 0; i < permutation.size(); ++i) {
+    VERIFY_IS_EQUAL(permutation.indices()(i), i);
+  }
+
+  const DenseVector refX = dA.colPivHouseholderQr().solve(b);
+  DenseVector x = solver.solve(b);
+  VERIFY_IS_EQUAL(solver.info(), Success);
+  VERIFY_IS_APPROX(x, refX);
+}
+
+void test_spqr_matrix_q_times_identity_expression() {
+  typedef SparseMatrix<double, ColMajor> MatrixType;
+  typedef Matrix<double, Dynamic, Dynamic> DenseMatrix;
+  typedef SPQR<MatrixType> SolverType;
+  typedef typename SolverType::MatrixType SolverSparseMatrix;
+  typedef Matrix<double, Dynamic, 1> DenseVector;
+
+  DenseMatrix dA(6, 4);
+  dA << 4.0, 1.0, 0.0, 0.0,  //
+      1.0, 0.0, 2.0, 0.0,    //
+      -2.0, 3.0, 0.0, 6.0,   //
+      0.0, 5.0, -1.0, 0.0,   //
+      0.0, 0.0, 7.0, 2.0,    //
+      0.0, 0.0, 0.0, 3.0;
+
+  MatrixType A = dA.sparseView();
+  A.makeCompressed();
+
+  SolverType solver;
+  solver.compute(A);
+
+  VERIFY_IS_EQUAL(solver.info(), Success);
+
+  const DenseMatrix Q = solver.matrixQ() * DenseMatrix::Identity(A.rows(), A.rows());
+  const DenseMatrix denseIdentity = DenseMatrix::Identity(A.rows(), A.rows());
+  const auto qProduct = solver.matrixQ() * denseIdentity;
+  VERIFY_IS_EQUAL(qProduct.rows(), A.rows());
+  VERIFY_IS_EQUAL(qProduct.cols(), A.rows());
+  const DenseMatrix qFromDenseIdentity = qProduct;
+  DenseMatrix denseAssignedQ;
+  denseAssignedQ = solver.matrixQ();
+  VERIFY_IS_EQUAL(Q.rows(), A.rows());
+  VERIFY_IS_EQUAL(Q.cols(), A.rows());
+  VERIFY_IS_APPROX(Q.transpose() * Q, DenseMatrix::Identity(A.rows(), A.rows()));
+  VERIFY_IS_APPROX(qFromDenseIdentity, Q);
+  VERIFY_IS_APPROX(denseAssignedQ, Q);
+
+  const DenseMatrix R = DenseMatrix(solver.matrixR().template triangularView<Upper>());
+  const auto sparseR = solver.matrixR().template triangularView<Upper>();
+  SolverSparseMatrix sparseIdentity(A.rows(), A.rows());
+  sparseIdentity.setIdentity();
+  SolverSparseMatrix sparseAssignedQ(A.rows(), A.rows());
+  sparseAssignedQ = solver.matrixQ();
+  SolverSparseMatrix sparseProductQ(A.rows(), A.rows());
+  sparseProductQ = solver.matrixQ() * sparseIdentity;
+  const DenseVector rhs = DenseVector::LinSpaced(A.cols(), 1.0, double(A.cols()));
+  const DenseVector x = sparseR.solve(rhs);
+  const DenseVector expected = R.template triangularView<Upper>().solve(rhs);
+  const DenseMatrix recoveredA = Q.leftCols(A.cols()) * R * solver.colsPermutation().transpose();
+  VERIFY_IS_APPROX(x, expected);
+  VERIFY_IS_APPROX(DenseMatrix(sparseAssignedQ), denseAssignedQ);
+  VERIFY_IS_APPROX(DenseMatrix(sparseProductQ), denseAssignedQ);
+  VERIFY_IS_APPROX(recoveredA, dA);
+}
+
 EIGEN_DECLARE_TEST(spqr_support) {
   CALL_SUBTEST_1(test_spqr_scalar<double>());
   CALL_SUBTEST_2(test_spqr_scalar<std::complex<double> >());
+  CALL_SUBTEST_3(test_spqr_fixed_ordering_uses_identity_permutation());
+  CALL_SUBTEST_3(test_spqr_matrix_q_times_identity_expression());
 }
diff --git a/test/stable_norm.cpp b/test/stable_norm.cpp
index c0ef4b6..519ccc9 100644
--- a/test/stable_norm.cpp
+++ b/test/stable_norm.cpp
@@ -6,14 +6,31 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_RUNTIME_NO_MALLOC
 
 #include "main.h"
+#include "fp_control.h"
+#define EIGEN_TEST_ANNOYING_SCALAR_DONT_THROW
+#include "AnnoyingScalar.h"
 
 template <typename T>
 EIGEN_DONT_INLINE T copy(const T& x) {
   return x;
 }
 
+struct StableNormCountingOp {
+  explicit StableNormCountingOp(Index* counter) : count(counter) {}
+
+  EIGEN_DONT_INLINE double operator()(Index index) const {
+    ++*count;
+    return double(index + 1);
+  }
+
+  Index* count;
+};
+
 template <typename MatrixType>
 void stable_norm(const MatrixType& m) {
   /* this test covers the following files:
@@ -212,6 +229,470 @@
   VERIFY_IS_EQUAL(empty.stableNorm(), 0.0f);
 }
 
+template <typename RealScalar>
+void stable_normalize_extremes() {
+  typedef Matrix<RealScalar, 2, 1> Vector2;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorX;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixX;
+  using std::signbit;
+  using std::sqrt;
+
+  const RealScalar highest = (std::numeric_limits<RealScalar>::max)();
+  volatile RealScalar denormInput = std::numeric_limits<RealScalar>::denorm_min();
+  const RealScalar denorm = denormInput;
+  const RealScalar infinity = std::numeric_limits<RealScalar>::infinity();
+  const RealScalar nan = std::numeric_limits<RealScalar>::quiet_NaN();
+  const RealScalar inv_sqrt_two = RealScalar(1) / sqrt(RealScalar(2));
+
+  {
+    const Vector2 input = Vector2::Constant(highest);
+    const Vector2 expected = Vector2::Constant(inv_sqrt_two);
+    VERIFY_IS_APPROX(input.stableNormalized(), expected);
+    Vector2 actual = input;
+    actual.stableNormalize();
+    VERIFY_IS_APPROX(actual, expected);
+    VERIFY_IS_APPROX(actual.norm(), RealScalar(1));
+  }
+
+  {
+    Vector2 input;
+    input << highest, highest / RealScalar(2);
+    Vector2 expected;
+    expected << RealScalar(1), RealScalar(0.5);
+    expected.normalize();
+    VERIFY_IS_APPROX(input.stableNormalized(), expected);
+    input.stableNormalize();
+    VERIFY_IS_APPROX(input, expected);
+  }
+
+  if (std::numeric_limits<RealScalar>::has_denorm == std::denorm_present) {
+    const Vector2 input = Vector2::Constant(denorm);
+    const Vector2 expected = Vector2::Constant(inv_sqrt_two);
+    std::fenv_t savedEnvironment;
+    const bool environmentSaved = std::feholdexcept(&savedEnvironment) == 0;
+    const Vector2 normalized = input.stableNormalized();
+    const int normalizedOverflow = std::fetestexcept(FE_OVERFLOW);
+    std::feclearexcept(FE_ALL_EXCEPT);
+    Vector2 actual = input;
+    actual.stableNormalize();
+    const int normalizeOverflow = std::fetestexcept(FE_OVERFLOW);
+    if (environmentSaved) std::fesetenv(&savedEnvironment);
+    VERIFY_IS_EQUAL(normalizedOverflow, 0);
+    VERIFY_IS_EQUAL(normalizeOverflow, 0);
+    VERIFY((normalized - expected).norm() <= RealScalar(4) * NumTraits<RealScalar>::epsilon());
+    VERIFY((actual - expected).norm() <= RealScalar(4) * NumTraits<RealScalar>::epsilon());
+  }
+
+  {
+    Vector2 zero;
+    zero << RealScalar(0), -RealScalar(0);
+    const Vector2 normalized = zero.stableNormalized();
+    VERIFY_IS_EQUAL(normalized(0), RealScalar(0));
+    VERIFY_IS_EQUAL(normalized(1), -RealScalar(0));
+    VERIFY(!signbit(normalized(0)));
+    VERIFY(signbit(normalized(1)));
+    zero.stableNormalize();
+    VERIFY(!signbit(zero(0)));
+    VERIFY(signbit(zero(1)));
+  }
+
+  {
+    Vector2 input;
+    input << infinity, RealScalar(1);
+    const Vector2 normalized = input.stableNormalized();
+    VERIFY(isPlusInf(normalized(0)));
+    VERIFY_IS_EQUAL(normalized(1), RealScalar(1));
+    input.stableNormalize();
+    VERIFY(isPlusInf(input(0)));
+    VERIFY_IS_EQUAL(input(1), RealScalar(1));
+  }
+
+  {
+    Vector2 input;
+    input << nan, RealScalar(1);
+    const Vector2 normalized = input.stableNormalized();
+    VERIFY((numext::isnan)(normalized(0)));
+    VERIFY_IS_EQUAL(normalized(1), RealScalar(1));
+    input.stableNormalize();
+    VERIFY((numext::isnan)(input(0)));
+    VERIFY_IS_EQUAL(input(1), RealScalar(1));
+  }
+
+  {
+    Vector2 input;
+    input << RealScalar(1), nan;
+    const Vector2 normalized = input.stableNormalized();
+    VERIFY_IS_EQUAL(normalized(0), RealScalar(1));
+    VERIFY((numext::isnan)(normalized(1)));
+    input.stableNormalize();
+    VERIFY_IS_EQUAL(input(0), RealScalar(1));
+    VERIFY((numext::isnan)(input(1)));
+  }
+
+  {
+    VectorX empty_vector(0);
+    VERIFY_IS_EQUAL(empty_vector.stableNormalized().size(), 0);
+    empty_vector.stableNormalize();
+    VERIFY_IS_EQUAL(empty_vector.size(), 0);
+
+    MatrixX empty_rows(0, 3);
+    MatrixX empty_cols(3, 0);
+    VERIFY_IS_EQUAL(empty_rows.stableNormalized().size(), 0);
+    VERIFY_IS_EQUAL(empty_cols.stableNormalized().size(), 0);
+    empty_rows.stableNormalize();
+    empty_cols.stableNormalize();
+    VERIFY_IS_EQUAL(empty_rows.rows(), 0);
+    VERIFY_IS_EQUAL(empty_rows.cols(), 3);
+    VERIFY_IS_EQUAL(empty_cols.rows(), 3);
+    VERIFY_IS_EQUAL(empty_cols.cols(), 0);
+    VERIFY_IS_EQUAL(empty_rows.blueNorm(), RealScalar(0));
+    VERIFY_IS_EQUAL(empty_cols.blueNorm(), RealScalar(0));
+    VERIFY_IS_EQUAL(empty_rows.hypotNorm(), RealScalar(0));
+    VERIFY_IS_EQUAL(empty_cols.hypotNorm(), RealScalar(0));
+  }
+}
+
+template <typename Scalar>
+void stable_normalize_daz() {
+#if EIGEN_ARCH_i386_OR_x86_64 && (defined(__SSE__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1))
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using Binary = internal::binary_floating_point_traits<RealScalar>;
+  using Bits = typename Binary::Bits;
+  using Vector2 = Matrix<Scalar, 2, 1>;
+  Vector2 input;
+  Vector2 expected;
+  decltype(auto) components = input.realView();
+  decltype(auto) expectedComponents = expected.realView();
+  const RealScalar magnitude = RealScalar(1) / numext::sqrt(RealScalar(components.size()));
+  // Runtime bit patterns keep the all-subnormal input out of constant-folded floating-point arithmetic.
+  volatile Bits subnormalBits = Bits(1);
+  for (Index i = 0; i < components.size(); ++i) {
+    const Bits sign = i % 2 == 0 ? Bits(0) : Binary::kSignBit;
+    components.coeffRef(i) = numext::bit_cast<RealScalar>(Bits(subnormalBits) | sign);
+    expectedComponents.coeffRef(i) = i % 2 == 0 ? magnitude : -magnitude;
+  }
+  const unsigned int originalControl = _mm_getcsr();
+  for (const unsigned int ftzMode : {_MM_FLUSH_ZERO_OFF, _MM_FLUSH_ZERO_ON}) {
+    // ScopedFlushToZero restores the complete MXCSR, including this test's additional DAZ setting.
+    ScopedFlushToZero savedState;
+    _MM_SET_FLUSH_ZERO_MODE(ftzMode);
+    _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
+    VERIFY(ScopedFlushToZero::hardwareFlushesSubnormalInputs());
+    const Vector2 normalized = input.stableNormalized();
+    Vector2 inPlace = input;
+    inPlace.stableNormalize();
+    VERIFY((normalized - expected).norm() <= RealScalar(4) * NumTraits<RealScalar>::epsilon());
+    VERIFY((inPlace - expected).norm() <= RealScalar(4) * NumTraits<RealScalar>::epsilon());
+  }
+  VERIFY_IS_EQUAL(_mm_getcsr(), originalControl);
+#endif
+}
+
+template <typename RealScalar>
+void stable_normalize_complex_extremes() {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Complex, Dynamic, 1> VectorX;
+  using std::sqrt;
+
+  const RealScalar highest = (std::numeric_limits<RealScalar>::max)();
+  const RealScalar denorm = std::numeric_limits<RealScalar>::denorm_min();
+  const RealScalar inv_sqrt_two = RealScalar(1) / sqrt(RealScalar(2));
+
+  {
+    VectorX input(1);
+    input(0) = Complex(highest, highest);
+    const Complex expected(inv_sqrt_two, inv_sqrt_two);
+    const VectorX normalized = input.stableNormalized();
+    VERIFY_IS_APPROX(normalized(0), expected);
+    input.stableNormalize();
+    VERIFY_IS_APPROX(input(0), expected);
+    VERIFY_IS_APPROX(input.norm(), RealScalar(1));
+  }
+
+  if (std::numeric_limits<RealScalar>::has_denorm == std::denorm_present) {
+    VectorX input(1);
+    input(0) = Complex(denorm, -denorm);
+    const Complex expected(inv_sqrt_two, -inv_sqrt_two);
+    VERIFY_IS_APPROX(input.stableNormalized()(0), expected);
+    input.stableNormalize();
+    VERIFY_IS_APPROX(input(0), expected);
+  }
+}
+
+template <typename RealScalar>
+void stable_norm_extreme_cross_product() {
+  typedef Matrix<RealScalar, 2, 1> Vector2;
+  using std::sqrt;
+
+  const RealScalar denorm = std::numeric_limits<RealScalar>::denorm_min();
+  const RealScalar smallest = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar highest = (std::numeric_limits<RealScalar>::max)();
+  const RealScalar epsilon = NumTraits<RealScalar>::epsilon();
+  const RealScalar values[] = {RealScalar(0),
+                               denorm,
+                               smallest,
+                               sqrt(smallest),
+                               epsilon,
+                               RealScalar(1),
+                               RealScalar(1) / epsilon,
+                               sqrt(highest) / RealScalar(2),
+                               highest / RealScalar(2),
+                               highest};
+  const int value_count = int(sizeof(values) / sizeof(values[0]));
+
+  for (int i = 0; i < value_count; ++i) {
+    for (int j = 0; j < value_count; ++j) {
+      Vector2 input;
+      input << values[i], values[j];
+      const RealScalar reference = numext::hypot(values[i], values[j]);
+      if ((numext::isinf)(reference)) {
+        VERIFY(isPlusInf(input.stableNorm()));
+        VERIFY(isPlusInf(input.blueNorm()));
+        VERIFY(isPlusInf(input.hypotNorm()));
+      } else {
+        VERIFY_IS_APPROX(input.stableNorm(), reference);
+        VERIFY_IS_APPROX(input.blueNorm(), reference);
+        VERIFY_IS_APPROX(input.hypotNorm(), reference);
+      }
+    }
+  }
+}
+
+template <typename RealScalar>
+void stable_norm_mixed_underflow() {
+  typedef Matrix<RealScalar, Dynamic, 1> VectorX;
+  using std::abs;
+  using std::sqrt;
+
+  if (std::numeric_limits<RealScalar>::has_denorm != std::denorm_present) return;
+
+  const Index size = 4096;
+  const RealScalar large = sqrt((std::numeric_limits<RealScalar>::min)());
+  const RealScalar small = sqrt(std::numeric_limits<RealScalar>::denorm_min()) * RealScalar(0.5);
+  VectorX input = VectorX::Constant(size, small);
+  input(0) = large;
+
+  const RealScalar reference = numext::hypot(large, sqrt(RealScalar(size - 1)) * small);
+  const RealScalar relative_error = abs(input.stableNorm() - reference) / reference;
+  // Leave room for the SIMD reduction order while still detecting the roughly
+  // 512-epsilon loss caused by squaring this block without scaling.
+  const RealScalar tolerance = RealScalar(128) * NumTraits<RealScalar>::epsilon();
+  VERIFY(relative_error <= tolerance);
+}
+
+template <typename RealScalar>
+void stable_norm_denormal_rounding() {
+  typedef Matrix<RealScalar, 2, 1> Vector2;
+  volatile RealScalar denormInput = std::numeric_limits<RealScalar>::denorm_min();
+  const RealScalar denorm = denormInput;
+  if (std::numeric_limits<RealScalar>::has_denorm != std::denorm_present || !(denorm > RealScalar(0))) return;
+
+  // sqrt(2) * denorm_min rounds back to denorm_min.  An approximate check at
+  // this scale can accept zero because its own error calculation underflows.
+  const Vector2 input = Vector2::Constant(denorm);
+  VERIFY_IS_EQUAL(input.stableNorm(), denorm);
+  VERIFY_IS_EQUAL(input.blueNorm(), denorm);
+  VERIFY_IS_EQUAL(input.hypotNorm(), denorm);
+}
+
+void stable_norm_power_of_two_scaling() {
+  // Reciprocal scaling rounds these norms two ULPs away from their correctly rounded values. Allow the fused and
+  // non-fused reduction paths to differ by one ULP while still rejecting the previous results.
+  Vector2f input_float;
+  input_float << numext::bit_cast<float>(numext::uint32_t(0x8d6e3421u)),
+      numext::bit_cast<float>(numext::uint32_t(0x0e36c209u));
+  const numext::uint32_t expected_float = 0x0e403728u;
+  const numext::uint32_t actual_float = numext::bit_cast<numext::uint32_t>(input_float.stableNorm());
+  VERIFY(actual_float >= expected_float - 1 && actual_float <= expected_float + 1);
+
+  Vector2d input_double;
+  input_double << numext::bit_cast<double>(numext::uint64_t(0x360514835c78c940ull)),
+      numext::bit_cast<double>(numext::uint64_t(0x3614674ff894db20ull));
+  const numext::uint64_t expected_double = 0x3616f714760d1964ull;
+  const numext::uint64_t actual_double = numext::bit_cast<numext::uint64_t>(input_double.stableNorm());
+  VERIFY(actual_double >= expected_double - 1 && actual_double <= expected_double + 1);
+
+  // Arbitrary reciprocal scaling rounds both normalized coefficients two ULPs away from their reference values.
+  Vector2f normalize_input;
+  normalize_input << numext::bit_cast<float>(numext::uint32_t(0x0971a50d)),
+      numext::bit_cast<float>(numext::uint32_t(0x07536745));
+  Vector2f expected_normalized;
+  expected_normalized << numext::bit_cast<float>(numext::uint32_t(0x3f7f9e41)),
+      numext::bit_cast<float>(numext::uint32_t(0x3d5fa0cb));
+  VERIFY_IS_EQUAL(normalize_input.stableNormalized(), expected_normalized);
+  normalize_input.stableNormalize();
+  VERIFY_IS_EQUAL(normalize_input, expected_normalized);
+}
+
+template <typename RealScalar>
+void stable_norm_power_of_two_ftz() {
+  typedef Matrix<RealScalar, 2, 1> Vector2;
+  Vector2 input;
+  input << (std::numeric_limits<RealScalar>::max)(), RealScalar(0);
+
+  ScopedFlushToZero flush_to_zero;
+  if (flush_to_zero.isSupported()) {
+    VERIFY_IS_EQUAL(input.stableNorm(), (std::numeric_limits<RealScalar>::max)());
+  }
+}
+
+template <typename Scalar>
+void stable_norm_low_precision() {
+  typedef Matrix<Scalar, Dynamic, 1> VectorX;
+  using std::abs;
+  using std::sqrt;
+
+  const Index size = 65536;
+  const Scalar value(0.001f);
+  const float value_as_float = static_cast<float>(value);
+  const float reference = sqrt(static_cast<float>(size)) * abs(value_as_float);
+  const float relative_tolerance = 8.0f * static_cast<float>(NumTraits<Scalar>::epsilon());
+  VectorX input = VectorX::Constant(size, value);
+
+  const float stable_norm = static_cast<float>(input.stableNorm());
+  const float blue_norm = static_cast<float>(input.blueNorm());
+  const float hypot_norm = static_cast<float>(input.hypotNorm());
+  VERIFY(abs(stable_norm - reference) <= relative_tolerance * reference);
+  VERIFY(abs(blue_norm - reference) <= relative_tolerance * reference);
+  VERIFY(abs(hypot_norm - reference) <= relative_tolerance * reference);
+
+  const VectorX normalized = input.stableNormalized();
+  const float promoted_norm = normalized.template cast<float>().norm();
+  VERIFY(abs(promoted_norm - 1.0f) <= relative_tolerance);
+  input.stableNormalize();
+  const float promoted_in_place_norm = input.template cast<float>().norm();
+  VERIFY(abs(promoted_in_place_norm - 1.0f) <= relative_tolerance);
+}
+
+template <typename RealScalar>
+void stable_norm_complex_low_precision() {
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Complex, 1, 1> Vector1;
+  using std::abs;
+
+  Vector1 input;
+  input(0) = Complex(RealScalar(3), RealScalar(4));
+  const float tolerance = 8.0f * static_cast<float>(NumTraits<RealScalar>::epsilon());
+  VERIFY(abs(static_cast<float>(input.stableNorm()) - 5.0f) <= tolerance);
+  const Complex normalized = input.stableNormalized()(0);
+  VERIFY(abs(static_cast<float>(normalized.real()) - 0.6f) <= tolerance);
+  VERIFY(abs(static_cast<float>(normalized.imag()) - 0.8f) <= tolerance);
+  input.stableNormalize();
+  VERIFY(abs(static_cast<float>(input(0).real()) - 0.6f) <= tolerance);
+  VERIFY(abs(static_cast<float>(input(0).imag()) - 0.8f) <= tolerance);
+}
+
+void stable_normalize_promoted_factor() {
+  typedef Matrix<half, Dynamic, 1> VectorX;
+  using std::abs;
+
+  // The combined normalization factor is just below half's first subnormal,
+  // while every final coefficient is representable.  Applying the factor in
+  // float before converting each result must therefore not produce zeros.
+  const Index size = 4194305;
+  const half value(16384.0f);
+  const float tolerance = 8.0f * static_cast<float>(NumTraits<half>::epsilon());
+  VectorX input = VectorX::Constant(size, value);
+
+  const VectorX normalized = input.stableNormalized();
+  VERIFY(static_cast<float>(normalized(0)) > 0.0f);
+  VERIFY(abs(normalized.template cast<float>().norm() - 1.0f) <= tolerance);
+
+  input.stableNormalize();
+  VERIFY(static_cast<float>(input(0)) > 0.0f);
+  VERIFY(abs(input.template cast<float>().norm() - 1.0f) <= tolerance);
+}
+
+void stable_normalize_no_malloc() {
+  VectorXd input = VectorXd::Constant(2, (std::numeric_limits<double>::max)());
+  const Vector2d expected = Vector2d::Constant(1.0 / std::sqrt(2.0));
+
+  internal::set_is_malloc_allowed(false);
+  input.stableNormalize();
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(input, expected);
+}
+
+void stable_norm_expression_and_stride() {
+  const Index size = 31;
+  Index evaluation_count = 0;
+  const auto expression = VectorXd::NullaryExpr(size, StableNormCountingOp(&evaluation_count));
+  const double expected = std::sqrt(double(size) * double(size + 1) * double(2 * size + 1) / 6.0);
+  VERIFY_IS_APPROX(expression.stableNorm(), expected);
+  VERIFY_IS_EQUAL(evaluation_count, size);
+  evaluation_count = 0;
+  const VectorXd expression_normalized = expression.stableNormalized();
+  VERIFY_IS_APPROX(expression_normalized.norm(), 1.0);
+  VERIFY_IS_EQUAL(evaluation_count, size);
+
+  VectorXd storage = VectorXd::Zero(2 * size);
+  for (Index i = 0; i < size; ++i) storage(2 * i) = double(i + 1);
+  typedef InnerStride<Dynamic> VectorStride;
+  Map<VectorXd, Unaligned, VectorStride> strided(storage.data(), size, VectorStride(2));
+  VERIFY_IS_APPROX(strided.stableNorm(), expected);
+  strided.stableNormalize();
+  VERIFY_IS_APPROX(strided.norm(), 1.0);
+  for (Index i = 0; i < size; ++i) VERIFY_IS_EQUAL(storage(2 * i + 1), 0.0);
+
+  RowVectorXd packed_storage = RowVectorXd::LinSpaced(size, 1.0, double(size));
+  Map<RowVectorXd, Unaligned, VectorStride> runtime_packed(packed_storage.data(), size, VectorStride(1));
+  VERIFY_IS_APPROX(runtime_packed.stableNorm(), expected);
+  const RowVectorXd normalized = runtime_packed.stableNormalized();
+  VERIFY_IS_EQUAL(normalized.rows(), 1);
+  VERIFY_IS_EQUAL(normalized.cols(), size);
+  VERIFY_IS_APPROX(normalized.norm(), 1.0);
+  runtime_packed.stableNormalize();
+  VERIFY_IS_APPROX(runtime_packed.norm(), 1.0);
+
+  // Flattening must preserve total size for fixed rows and multi-column matrices.
+  typedef Matrix<double, 1, 4> FixedRowVector;
+  FixedRowVector fixed_row_storage;
+  fixed_row_storage << 1.0, 2.0, 3.0, 4.0;
+  Map<FixedRowVector, Unaligned, VectorStride> fixed_row(fixed_row_storage.data(), VectorStride(1));
+  const double fixed_row_norm = std::sqrt(30.0);
+  const FixedRowVector expected_fixed_row = fixed_row_storage / fixed_row_norm;
+  VERIFY_IS_APPROX(fixed_row.stableNorm(), fixed_row_norm);
+  const FixedRowVector fixed_row_normalized = fixed_row.stableNormalized();
+  VERIFY_IS_APPROX(fixed_row_normalized, expected_fixed_row);
+  VERIFY_IS_APPROX(fixed_row_normalized.norm(), 1.0);
+  fixed_row.stableNormalize();
+  VERIFY_IS_APPROX(fixed_row, expected_fixed_row);
+  VERIFY_IS_APPROX(fixed_row.norm(), 1.0);
+
+  typedef Stride<Dynamic, Dynamic> MatrixStride;
+  typedef Matrix<double, 2, 3> FixedMatrix;
+  FixedMatrix fixed_matrix_storage;
+  fixed_matrix_storage << 1.0, 2.0, 3.0, 4.0, 5.0, 6.0;
+  Map<FixedMatrix, Unaligned, MatrixStride> fixed_matrix(fixed_matrix_storage.data(),
+                                                         MatrixStride(fixed_matrix_storage.outerStride(), 1));
+  const double fixed_matrix_norm = std::sqrt(91.0);
+  const FixedMatrix expected_fixed_matrix = fixed_matrix_storage / fixed_matrix_norm;
+  VERIFY_IS_APPROX(fixed_matrix.stableNorm(), fixed_matrix_norm);
+  const FixedMatrix fixed_matrix_normalized = fixed_matrix.stableNormalized();
+  VERIFY_IS_APPROX(fixed_matrix_normalized, expected_fixed_matrix);
+  VERIFY_IS_APPROX(fixed_matrix_normalized.norm(), 1.0);
+  fixed_matrix.stableNormalize();
+  VERIFY_IS_APPROX(fixed_matrix, expected_fixed_matrix);
+  VERIFY_IS_APPROX(fixed_matrix.norm(), 1.0);
+
+  const double padding_value = 42.0;
+  VectorXd matrix_storage = VectorXd::Constant(20, padding_value);
+  Map<Matrix<double, Dynamic, Dynamic>, Unaligned, MatrixStride> gapped_matrix(matrix_storage.data(), 3, 4,
+                                                                               MatrixStride(5, 1));
+  gapped_matrix.setRandom();
+  VERIFY_IS_APPROX(gapped_matrix.stableNorm(), gapped_matrix.norm());
+  MatrixXd packed_matrix = gapped_matrix;
+  VERIFY_IS_APPROX(gapped_matrix.stableNormalized(), packed_matrix.stableNormalized());
+  gapped_matrix.stableNormalize();
+  packed_matrix.stableNormalize();
+  VERIFY_IS_APPROX(gapped_matrix, packed_matrix);
+  for (Index outer = 0; outer < gapped_matrix.outerSize(); ++outer) {
+    for (Index inner = gapped_matrix.innerSize(); inner < gapped_matrix.outerStride(); ++inner) {
+      VERIFY_IS_EQUAL(matrix_storage(outer * gapped_matrix.outerStride() + inner), padding_value);
+    }
+  }
+}
+
 template <typename Scalar>
 void test_hypot() {
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -236,6 +717,31 @@
   VERIFY((numext::isnan)(numext::hypot(a, nan)));
 }
 
+template <typename Scalar>
+void stable_norm_complex_infinity() {
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, Dynamic, 1> VecType;
+
+  const RealScalar inf = std::numeric_limits<RealScalar>::infinity();
+  const Scalar finite(RealScalar(3), RealScalar(-4));
+  const Scalar both_inf(inf, inf);
+  const Scalar real_inf(inf, RealScalar(1));
+  const Scalar imag_inf(RealScalar(1), -inf);
+
+  VERIFY(isPlusInf(numext::abs(both_inf)));
+  VERIFY(isPlusInf(numext::abs(real_inf)));
+  VERIFY(isPlusInf(numext::abs(imag_inf)));
+  VERIFY(isPlusInf(numext::hypot(both_inf, finite)));
+
+  VecType v(4);
+  v << both_inf, finite, real_inf, imag_inf;
+
+  VERIFY(isPlusInf(v.cwiseAbs().maxCoeff()));
+  VERIFY(isPlusInf(v.stableNorm()));
+  VERIFY(isPlusInf(v.blueNorm()));
+  VERIFY(isPlusInf(v.hypotNorm()));
+}
+
 // Test stableNorm at the 4096-element block boundary.
 // stable_norm_impl_inner_step processes vectors in blocks of 4096.
 // Sizes near this boundary exercise the transition between full blocks
@@ -301,6 +807,23 @@
   }
 }
 
+void stable_normalize_custom_scalar() {
+  using Scalar = AnnoyingScalar;
+  Matrix<Scalar, 2, 1> expected;
+  expected << Scalar(0.6f), Scalar(0.8f);
+  for (float scale : {1.0f, 1e-30f, 1e30f}) {
+    Matrix<Scalar, 2, 1> input;
+    input << Scalar(3.0f * scale), Scalar(4.0f * scale);
+    const Matrix<Scalar, 2, 1> normalized = input.stableNormalized();
+    input.stableNormalize();
+    for (Index i = 0; i < input.size(); ++i) {
+      const Scalar tolerance(4 * NumTraits<float>::epsilon());
+      VERIFY(numext::abs(normalized(i) - expected(i)) <= tolerance);
+      VERIFY(numext::abs(input(i) - expected(i)) <= tolerance);
+    }
+  }
+}
+
 EIGEN_DECLARE_TEST(stable_norm) {
   CALL_SUBTEST_1(test_empty());
 
@@ -322,4 +845,36 @@
   // Block boundary and scale transition tests (deterministic, outside g_repeat).
   CALL_SUBTEST_7(stable_norm_block_boundary<float>());
   CALL_SUBTEST_7(stable_norm_block_boundary<double>());
+  CALL_SUBTEST_7(stable_norm_block_boundary<long double>());
+  CALL_SUBTEST_8(stable_norm_complex_infinity<std::complex<float> >());
+  CALL_SUBTEST_8(stable_norm_complex_infinity<std::complex<double> >());
+  CALL_SUBTEST_8(stable_norm_complex_infinity<std::complex<long double>>());
+  CALL_SUBTEST_9(stable_normalize_extremes<float>());
+  CALL_SUBTEST_9(stable_normalize_extremes<double>());
+  CALL_SUBTEST_9(stable_normalize_extremes<long double>());
+  CALL_SUBTEST_9(stable_normalize_daz<float>());
+  CALL_SUBTEST_9(stable_normalize_daz<double>());
+  CALL_SUBTEST_10(stable_normalize_complex_extremes<float>());
+  CALL_SUBTEST_10(stable_normalize_complex_extremes<double>());
+  CALL_SUBTEST_10(stable_normalize_complex_extremes<long double>());
+  CALL_SUBTEST_10(stable_normalize_daz<std::complex<float>>());
+  CALL_SUBTEST_10(stable_normalize_daz<std::complex<double>>());
+  CALL_SUBTEST_11(stable_norm_extreme_cross_product<float>());
+  CALL_SUBTEST_11(stable_norm_extreme_cross_product<double>());
+  CALL_SUBTEST_11(stable_norm_extreme_cross_product<long double>());
+  CALL_SUBTEST_11(stable_norm_mixed_underflow<float>());
+  CALL_SUBTEST_11(stable_norm_mixed_underflow<double>());
+  CALL_SUBTEST_11(stable_norm_denormal_rounding<float>());
+  CALL_SUBTEST_11(stable_norm_denormal_rounding<double>());
+  CALL_SUBTEST_11(stable_norm_power_of_two_scaling());
+  CALL_SUBTEST_11(stable_norm_power_of_two_ftz<float>());
+  CALL_SUBTEST_11(stable_norm_power_of_two_ftz<double>());
+  CALL_SUBTEST_12(stable_norm_low_precision<half>());
+  CALL_SUBTEST_12(stable_norm_low_precision<bfloat16>());
+  CALL_SUBTEST_12(stable_norm_complex_low_precision<half>());
+  CALL_SUBTEST_12(stable_norm_complex_low_precision<bfloat16>());
+  CALL_SUBTEST_12(stable_normalize_promoted_factor());
+  CALL_SUBTEST_13(stable_norm_expression_and_stride());
+  CALL_SUBTEST_13(stable_normalize_no_malloc());
+  CALL_SUBTEST_13(stable_normalize_custom_scalar());
 }
diff --git a/test/stable_norm_fastmath.cpp b/test/stable_norm_fastmath.cpp
new file mode 100644
index 0000000..bd7d60c
--- /dev/null
+++ b/test/stable_norm_fastmath.cpp
@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "fp_control.h"
+
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) && EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
+EIGEN_DONT_INLINE half fp16_underflow_probe(half normal_min, half one_half) { return normal_min * one_half; }
+
+// Volatile dispatch prevents constant-propagation clones from bypassing the changed FPCR.
+typedef half (*Fp16UnderflowProbe)(half, half);
+static Fp16UnderflowProbe volatile fp16_underflow_probe_runtime = &fp16_underflow_probe;
+
+void scoped_flush_to_zero_fp16() {
+  const half normal_min = (std::numeric_limits<half>::min)();
+  const half one_half(0.5f);
+  const half underflow_before = fp16_underflow_probe_runtime(normal_min, one_half);
+  bool flush_to_zero_supported = false;
+  {
+    Eigen::ScopedFlushToZero flush_to_zero;
+    flush_to_zero_supported = flush_to_zero.isSupported();
+    VERIFY(flush_to_zero_supported);
+    VERIFY_IS_EQUAL(static_cast<float>(fp16_underflow_probe_runtime(normal_min, one_half)), 0.0f);
+  }
+  VERIFY_IS_EQUAL(static_cast<float>(fp16_underflow_probe_runtime(normal_min, one_half)),
+                  static_cast<float>(underflow_before));
+}
+#endif
+
+template <typename RealScalar>
+void stable_normalize_fastmath() {
+  typedef Matrix<RealScalar, 2, 1> Vector2;
+  typedef std::complex<RealScalar> Complex;
+  typedef Matrix<Complex, 1, 1> ComplexVector1;
+  using std::sqrt;
+
+  const RealScalar highest = (std::numeric_limits<RealScalar>::max)();
+  const RealScalar smallest = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar inv_sqrt_two = RealScalar(1) / sqrt(RealScalar(2));
+  const Vector2 expected = Vector2::Constant(inv_sqrt_two);
+
+  Vector2 large = Vector2::Constant(highest);
+  VERIFY_IS_APPROX(large.stableNormalized(), expected);
+  large.stableNormalize();
+  VERIFY_IS_APPROX(large, expected);
+
+  Vector2 small = Vector2::Constant(smallest);
+  VERIFY_IS_APPROX(small.stableNormalized(), expected);
+  small.stableNormalize();
+  VERIFY_IS_APPROX(small, expected);
+
+  ComplexVector1 complex_large;
+  complex_large(0) = Complex(highest, highest);
+  const Complex expected_complex(inv_sqrt_two, inv_sqrt_two);
+  VERIFY_IS_APPROX(complex_large.stableNormalized()(0), expected_complex);
+  complex_large.stableNormalize();
+  VERIFY_IS_APPROX(complex_large(0), expected_complex);
+}
+
+template <typename RealScalar>
+void stable_norm_ftz_boundaries() {
+  typedef Matrix<RealScalar, 2, 1> Vector2;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorX;
+  using std::sqrt;
+
+  const RealScalar normal_min = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar inv_sqrt_two = RealScalar(1) / sqrt(RealScalar(2));
+  const Vector2 expected_normalized = Vector2::Constant(inv_sqrt_two);
+  Vector2 reciprocal_boundary = Vector2::Constant(RealScalar(1) / normal_min);
+
+  const Index block_size = 4096;
+  const RealScalar large = RealScalar(128) * sqrt(normal_min);
+  const RealScalar small = RealScalar(0.5) * sqrt(normal_min);
+  VectorX mixed = VectorX::Constant(block_size, small);
+  mixed(0) = large;
+  const RealScalar expected_norm = large * sqrt(RealScalar(1) + RealScalar(block_size - 1) / RealScalar(65536));
+
+  const RealScalar underflow_before = underflowProbe<RealScalar>();
+  bool flush_to_zero_supported = false;
+  {
+    Eigen::ScopedFlushToZero flush_to_zero;
+    flush_to_zero_supported = flush_to_zero.isSupported();
+    if (flush_to_zero_supported) VERIFY_IS_EQUAL(underflowProbe<RealScalar>(), RealScalar(0));
+    VERIFY_IS_APPROX(reciprocal_boundary.stableNormalized(), expected_normalized);
+    reciprocal_boundary.stableNormalize();
+    VERIFY_IS_APPROX(reciprocal_boundary, expected_normalized);
+    VERIFY_IS_APPROX(mixed.stableNorm(), expected_norm);
+  }
+  if (flush_to_zero_supported) VERIFY_IS_EQUAL(underflowProbe<RealScalar>(), underflow_before);
+}
+
+template <typename RealScalar>
+void stable_norm_multiblock_fastmath() {
+  typedef Matrix<RealScalar, Dynamic, 1> VectorX;
+  using std::sqrt;
+
+  const Index block_size = 4096;
+  const RealScalar scale = sqrt((std::numeric_limits<RealScalar>::max)());
+  VectorX input = VectorX::Zero(2 * block_size);
+  input(0) = scale;
+  input.tail(block_size).setConstant(scale / RealScalar(128));
+  const RealScalar expected = scale * sqrt(RealScalar(1.25));
+  VERIFY_IS_APPROX(input.stableNorm(), expected);
+}
+
+EIGEN_DECLARE_TEST(stable_norm_fastmath) {
+  CALL_SUBTEST_1(stable_normalize_fastmath<float>());
+  CALL_SUBTEST_2(stable_normalize_fastmath<double>());
+  CALL_SUBTEST_1(stable_norm_multiblock_fastmath<float>());
+  CALL_SUBTEST_2(stable_norm_multiblock_fastmath<double>());
+  CALL_SUBTEST_1(stable_norm_ftz_boundaries<float>());
+  CALL_SUBTEST_2(stable_norm_ftz_boundaries<double>());
+#if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC) && EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
+  CALL_SUBTEST_1(scoped_flush_to_zero_fp16());
+#endif
+}
diff --git a/test/stack_allocation_limit.cpp b/test/stack_allocation_limit.cpp
new file mode 100644
index 0000000..3dc7971
--- /dev/null
+++ b/test/stack_allocation_limit.cpp
@@ -0,0 +1,32 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// A backend whose blocked kernels need a larger stack panel may raise Eigen's own default limit --
+// see the SVE and RVV blocks in ConfigureVectorization.h -- but an explicit EIGEN_STACK_ALLOCATION_LIMIT
+// is a caller policy on stack safety and must reach DenseStorage.h and Memory.h unchanged. Rewriting
+// one upward turns OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG off for objects the caller wanted rejected and
+// switches internal buffers from the heap back to alloca.
+//
+// 1 is below anything a backend could derive, so this never passes vacuously, and nothing here
+// allocates a fixed-size Eigen object that the limit would then reject.
+#define EIGEN_STACK_ALLOCATION_LIMIT 1
+#include "main.h"
+
+static_assert(EIGEN_STACK_ALLOCATION_LIMIT == 1, "an explicit EIGEN_STACK_ALLOCATION_LIMIT must survive");
+
+// Memory.h reads the macro at each use rather than through a saved constant, so check the users too.
+void check_stack_allocation_is_disabled() {
+  VERIFY_IS_EQUAL(int(sizeof(double) * 4 <= EIGEN_STACK_ALLOCATION_LIMIT), 0);
+  ei_declare_aligned_stack_constructed_variable(double, buffer, 4, 0);
+  VERIFY(buffer != nullptr);
+  for (Index i = 0; i < 4; ++i) buffer[i] = double(i);
+  for (Index i = 0; i < 4; ++i) VERIFY_IS_EQUAL(buffer[i], double(i));
+}
+
+EIGEN_DECLARE_TEST(stack_allocation_limit) { CALL_SUBTEST(check_stack_allocation_is_disabled()); }
diff --git a/test/stddeque.cpp b/test/stddeque.cpp
index 45608d7..822d309 100644
--- a/test/stddeque.cpp
+++ b/test/stddeque.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/StdDeque>
diff --git a/test/stddeque_overload.cpp b/test/stddeque_overload.cpp
index d0fb261..282f1bd 100644
--- a/test/stddeque_overload.cpp
+++ b/test/stddeque_overload.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/stdlist.cpp b/test/stdlist.cpp
index fe32067..cb65eff 100644
--- a/test/stdlist.cpp
+++ b/test/stdlist.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/StdList>
diff --git a/test/stdlist_overload.cpp b/test/stdlist_overload.cpp
index 77781db..26558d8 100644
--- a/test/stdlist_overload.cpp
+++ b/test/stdlist_overload.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/stdvector.cpp b/test/stdvector.cpp
index 93acfa5..0dd8f88 100644
--- a/test/stdvector.cpp
+++ b/test/stdvector.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/StdVector>
diff --git a/test/stdvector_overload.cpp b/test/stdvector_overload.cpp
index 57d06ca..c084a52 100644
--- a/test/stdvector_overload.cpp
+++ b/test/stdvector_overload.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/stl_iterators.cpp b/test/stl_iterators.cpp
index fee8ef5..c560020 100644
--- a/test/stl_iterators.cpp
+++ b/test/stl_iterators.cpp
@@ -6,11 +6,24 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+// Include <ranges> before main.h because main.h redefines min/max as
+// error macros, which conflicts with std::ranges internals.
+#if __cplusplus >= 202002L
+#include <ranges>
+#include <concepts>
+#endif
 
 #include "main.h"
+#include "random_for_arithmetic.h"
 #include <iterator>
 #include <numeric>
 
+#if __cplusplus >= 202002L && defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
+#define EIGEN_TEST_CXX20_RANGES 1
+#endif
+
 template <class Iterator>
 std::reverse_iterator<Iterator> make_reverse_iterator(Iterator i) {
   return std::reverse_iterator<Iterator>(i);
@@ -18,6 +31,17 @@
 
 using std::is_sorted;
 
+template <typename VectorwiseType>
+void check_reverse_subscript(VectorwiseType xpr) {
+  const Index size = xpr.end() - xpr.begin();
+  for (Index i = 0; i < size; ++i) {
+    VERIFY_IS_EQUAL(xpr.rbegin()[i], xpr.begin()[size - 1 - i]);
+    VERIFY_IS_EQUAL(xpr.crbegin()[i], xpr.cbegin()[size - 1 - i]);
+    VERIFY_IS_EQUAL((xpr.rend() - 1)[-i], xpr.begin()[i]);
+    VERIFY_IS_EQUAL((xpr.crend() - 1)[-i], xpr.cbegin()[i]);
+  }
+}
+
 template <typename XprType>
 bool is_pointer_based_stl_iterator(const internal::pointer_based_stl_iterator<XprType>&) {
   return true;
@@ -102,17 +126,92 @@
   }
 }
 
+template <typename Iterator, typename OtherIterator>
+void check_iterator_order(Iterator first, OtherIterator otherFirst, Index size) {
+  for (Index i = 0; i <= size; ++i) {
+    for (Index j = 0; j <= size; ++j) {
+      const auto a = first + i;
+      const auto b = otherFirst + j;
+      VERIFY_IS_EQUAL(a - b, i - j);
+      VERIFY_IS_EQUAL(a == b, i == j);
+      VERIFY_IS_EQUAL(a != b, i != j);
+      VERIFY_IS_EQUAL(a < b, i < j);
+      VERIFY_IS_EQUAL(a <= b, i <= j);
+      VERIFY_IS_EQUAL(a > b, i > j);
+      VERIFY_IS_EQUAL(a >= b, i >= j);
+    }
+  }
+}
+
+template <int Stride, int Options>
+void test_strided_iterator_order(Index stride) {
+  using VectorType = Matrix<int, Dynamic, 1>;
+  using MappedVector = Matrix<int, Options == RowMajor ? 1 : Dynamic, Options == RowMajor ? Dynamic : 1, Options>;
+  VectorType storage = VectorType::Random(20);
+  // Keep both forward and reverse end pointers within the allocation, including with negative strides.
+  Map<MappedVector, Unaligned, InnerStride<Stride>> map(storage.data() + 9, 4, InnerStride<Stride>(stride));
+  const auto& constMap = map;
+  check_begin_end_for_loop(map);
+  check_iterator_order(map.begin(), map.begin(), map.size());
+  check_iterator_order(map.begin(), constMap.begin(), map.size());
+  check_iterator_order(constMap.begin(), map.begin(), map.size());
+  check_iterator_order(constMap.begin(), constMap.begin(), map.size());
+  const auto reverseBegin = make_reverse_iterator(map.end());
+  const auto constReverseBegin = make_reverse_iterator(constMap.end());
+  check_iterator_order(reverseBegin, reverseBegin, map.size());
+  check_iterator_order(reverseBegin, constReverseBegin, map.size());
+  check_iterator_order(constReverseBegin, reverseBegin, map.size());
+  check_iterator_order(constReverseBegin, constReverseBegin, map.size());
+  Map<const MappedVector, Unaligned, InnerStride<Stride>> readOnly(map.data(), map.size(), InnerStride<Stride>(stride));
+  check_iterator_order(readOnly.begin(), readOnly.end() - readOnly.size(), readOnly.size());
+
+  std::sort(map.begin(), map.end());
+  for (Index i = 1; i < map.size(); ++i) VERIFY(map[i - 1] <= map[i]);
+}
+
+template <typename Iterator, typename ConstIterator>
+void check_iterator_const_conversion(Iterator first, Iterator last, ConstIterator constFirst) {
+  STATIC_CHECK((std::is_convertible<Iterator, ConstIterator>::value));
+  STATIC_CHECK((std::is_assignable<ConstIterator&, Iterator>::value));
+  STATIC_CHECK((
+      std::is_same<decltype(std::declval<ConstIterator&>() = std::declval<const Iterator&>()), ConstIterator&>::value));
+  STATIC_CHECK((!std::is_convertible<ConstIterator, Iterator>::value));
+  STATIC_CHECK((!std::is_assignable<Iterator&, ConstIterator>::value));
+  const Index size = last - first;
+  for (Index i = 0; i <= size; ++i) {
+    const Iterator it = first + i;
+    ConstIterator converted = it;
+    ConstIterator assigned;
+    VERIFY(&(assigned = it) == &assigned);
+    VERIFY(converted == constFirst + i);
+    VERIFY(assigned == converted);
+    VERIFY(converted == it && it == converted);
+    VERIFY_IS_EQUAL(converted - first, i);
+    VERIFY_IS_EQUAL(last - converted, size - i);
+    if (i < size) {
+      VERIFY_IS_EQUAL(*converted, *it);
+      VERIFY_IS_EQUAL(*(assigned = it), *it);
+    }
+  }
+}
+
+template <typename VectorwiseType>
+void check_subvector_const_conversion(VectorwiseType xpr) {
+  check_iterator_const_conversion(xpr.begin(), xpr.end(), xpr.cbegin());
+  check_iterator_const_conversion(xpr.rbegin(), xpr.rend(), xpr.crbegin());
+}
+
 template <typename Scalar, int Rows, int Cols>
 void test_stl_iterators(int rows = Rows, int cols = Cols) {
   typedef Matrix<Scalar, Rows, 1> VectorType;
   typedef Matrix<Scalar, 1, Cols> RowVectorType;
   typedef Matrix<Scalar, Rows, Cols, ColMajor> ColMatrixType;
   typedef Matrix<Scalar, Rows, Cols, RowMajor> RowMatrixType;
-  VectorType v = VectorType::Random(rows);
+  VectorType v = random_for_arithmetic<VectorType>(rows);
   const VectorType& cv(v);
-  ColMatrixType A = ColMatrixType::Random(rows, cols);
+  ColMatrixType A = random_for_arithmetic<ColMatrixType>(rows, cols);
   const ColMatrixType& cA(A);
-  RowMatrixType B = RowMatrixType::Random(rows, cols);
+  RowMatrixType B = random_for_arithmetic<RowMatrixType>(rows, cols);
   using Eigen::placeholders::last;
 
   Index i, j;
@@ -360,11 +459,11 @@
       typename ColMatrixType::ColXpr Acol = A.col(j);
       std::sort(Acol.begin(), Acol.end());
       VERIFY(is_sorted(Acol.cbegin(), Acol.cend()));
-      A.setRandom();
+      A = random_for_arithmetic<ColMatrixType>(A.rows(), A.cols());
 
       std::sort(A.col(j).begin(), A.col(j).end());
       VERIFY(is_sorted(A.col(j).cbegin(), A.col(j).cend()));
-      A.setRandom();
+      A = random_for_arithmetic<ColMatrixType>(A.rows(), A.cols());
     }
 
     // on a row of a rowmajor matrix -> pointer-based iterator and runtime increment
@@ -374,11 +473,11 @@
       VERIFY_IS_EQUAL(std::distance(Arow.begin(), Arow.end()), cols);
       std::sort(Arow.begin(), Arow.end());
       VERIFY(is_sorted(Arow.cbegin(), Arow.cend()));
-      A.setRandom();
+      A = random_for_arithmetic<ColMatrixType>(A.rows(), A.cols());
 
       std::sort(A.row(i).begin(), A.row(i).end());
       VERIFY(is_sorted(A.row(i).cbegin(), A.row(i).cend()));
-      A.setRandom();
+      A = random_for_arithmetic<ColMatrixType>(A.rows(), A.cols());
     }
 
     // with a generic iterator
@@ -386,12 +485,12 @@
       Reshaped<RowMatrixType, RowMatrixType::SizeAtCompileTime, 1> B1 = B.reshaped();
       std::sort(B1.begin(), B1.end());
       VERIFY(is_sorted(B1.cbegin(), B1.cend()));
-      B.setRandom();
+      B = random_for_arithmetic<RowMatrixType>(B.rows(), B.cols());
 
       // assertion because nested expressions are different
       // std::sort(B.reshaped().begin(),B.reshaped().end());
       // VERIFY(is_sorted(B.reshaped().cbegin(),B.reshaped().cend()));
-      // B.setRandom();
+      // B = random_for_arithmetic<RowMatrixType>(B.rows(), B.cols());
     }
   }
 
@@ -409,13 +508,13 @@
 
   // stress random access as required by std::nth_element
   if (rows >= 3) {
-    v.setRandom();
+    v = random_for_arithmetic<VectorType>(v.rows(), v.cols());
     VectorType v1 = v;
     std::sort(v1.begin(), v1.end());
     std::nth_element(v.begin(), v.begin() + rows / 2, v.end());
     VERIFY_IS_APPROX(v1(rows / 2), v(rows / 2));
 
-    v.setRandom();
+    v = random_for_arithmetic<VectorType>(v.rows(), v.cols());
     v1 = v;
     std::sort(v1.begin() + rows / 2, v1.end());
     std::nth_element(v.begin() + rows / 2, v.begin() + rows / 4, v.end());
@@ -446,7 +545,7 @@
       ++j;
     }
     VERIFY_IS_APPROX(A, B);
-    B.setRandom();
+    B = random_for_arithmetic<RowMatrixType>(B.rows(), B.cols());
 
     i = 0;
     for (auto r : A.rowwise()) {
@@ -460,10 +559,26 @@
     }
   }
 
+  check_subvector_const_conversion(A.rowwise());
+  check_subvector_const_conversion(A.colwise());
+  check_subvector_const_conversion(B.rowwise());
+  check_subvector_const_conversion(B.colwise());
+
+  check_reverse_subscript(A.rowwise());
+  check_reverse_subscript(A.colwise());
+  check_reverse_subscript(B.rowwise());
+  check_reverse_subscript(B.colwise());
+  const ColMatrixType& constA = A;
+  const RowMatrixType& constB = B;
+  check_reverse_subscript(constA.rowwise());
+  check_reverse_subscript(constA.colwise());
+  check_reverse_subscript(constB.rowwise());
+  check_reverse_subscript(constB.colwise());
+
   // check rows/cols iterators with STL algorithms
   {
-    RowVectorType row = RowVectorType::Random(cols);
-    VectorType col = VectorType::Random(rows);
+    RowVectorType row = random_for_arithmetic<RowVectorType>(cols);
+    VectorType col = random_for_arithmetic<VectorType>(rows);
     // Prevent overflows for integer types.
     if (Eigen::NumTraits<Scalar>::IsInteger) {
       Scalar kMaxVal = Scalar(1000);
@@ -493,7 +608,8 @@
     }));
 
     i = internal::random<Index>(0, A.rows() - 1);
-    A.setRandom();
+    A = random_for_arithmetic<ColMatrixType>(A.rows(), A.cols());
+    A.col(0).setOnes();  // every row is nonzero before row i is zeroed
     A.row(i).setZero();
     VERIFY_IS_EQUAL(
         std::find_if(A.rowwise().begin(), A.rowwise().end(),
@@ -507,7 +623,8 @@
         (A.rows() - 1) - i);
 
     j = internal::random<Index>(0, A.cols() - 1);
-    A.setRandom();
+    A = random_for_arithmetic<ColMatrixType>(A.rows(), A.cols());
+    A.row(0).setOnes();  // every column is nonzero before column j is zeroed
     A.col(j).setZero();
     VERIFY_IS_EQUAL(
         std::find_if(A.colwise().begin(), A.colwise().end(),
@@ -523,11 +640,10 @@
 
   {
     using VecOp = VectorwiseOp<ArrayXXi, 0>;
-    STATIC_CHECK((internal::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cbegin())>::value));
-    STATIC_CHECK((internal::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cend())>::value));
-    STATIC_CHECK(
-        (internal::is_same<VecOp::const_iterator, decltype(std::cbegin(std::declval<const VecOp&>()))>::value));
-    STATIC_CHECK((internal::is_same<VecOp::const_iterator, decltype(std::cend(std::declval<const VecOp&>()))>::value));
+    STATIC_CHECK((std::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cbegin())>::value));
+    STATIC_CHECK((std::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cend())>::value));
+    STATIC_CHECK((std::is_same<VecOp::const_iterator, decltype(std::cbegin(std::declval<const VecOp&>()))>::value));
+    STATIC_CHECK((std::is_same<VecOp::const_iterator, decltype(std::cend(std::declval<const VecOp&>()))>::value));
   }
 }
 
@@ -579,7 +695,54 @@
   VERIFY_IS_EQUAL(IsContainerType<RowMatrixType>(0), rows == 1 || cols == 1);
 }
 
+#ifdef EIGEN_TEST_CXX20_RANGES
+template <typename Scalar, int Rows, int Cols>
+void test_cxx20_ranges(int rows = Rows, int cols = Cols) {
+  typedef Matrix<Scalar, Rows, 1> VectorType;
+  typedef Matrix<Scalar, Dynamic, 1> DynVectorType;
+  typedef Matrix<Scalar, Rows, Cols, ColMajor> ColMatrixType;
+
+  // Vectors with unit stride satisfy contiguous_range.
+  static_assert(std::contiguous_iterator<typename VectorType::iterator>);
+  static_assert(std::contiguous_iterator<typename VectorType::const_iterator>);
+  static_assert(std::ranges::contiguous_range<VectorType>);
+  static_assert(std::ranges::contiguous_range<const VectorType>);
+
+  // Dynamic vectors too.
+  static_assert(std::contiguous_iterator<typename DynVectorType::iterator>);
+  static_assert(std::ranges::contiguous_range<DynVectorType>);
+  static_assert(std::ranges::contiguous_range<const DynVectorType>);
+
+  // Sized range.
+  static_assert(std::ranges::sized_range<VectorType>);
+  static_assert(std::ranges::sized_range<DynVectorType>);
+
+  // Runtime checks with std::ranges algorithms.
+  VectorType v = VectorType::Random(rows);
+  auto it = std::ranges::find(v, v(0));
+  VERIFY(it == v.begin());
+
+  // ranges::data returns the same pointer as data().
+  VERIFY(std::ranges::data(v) == v.data());
+  VERIFY(static_cast<Index>(std::ranges::size(v)) == v.size());
+
+  // Column expression of a column-major matrix is contiguous.
+  ColMatrixType A = ColMatrixType::Random(rows, cols);
+  auto col = A.col(0);
+  VERIFY(std::ranges::data(col) == col.data());
+  auto col_it = std::ranges::find(col, col(0));
+  VERIFY(col_it == col.begin());
+}
+#endif
+
 EIGEN_DECLARE_TEST(stl_iterators) {
+  for (Index stride : {-2, -1, 1, 2}) {
+    CALL_SUBTEST_1((test_strided_iterator_order<Dynamic, ColMajor>(stride)));
+    CALL_SUBTEST_1((test_strided_iterator_order<Dynamic, RowMajor>(stride)));
+  }
+  CALL_SUBTEST_1((test_strided_iterator_order<-2, ColMajor>(-2)));
+  CALL_SUBTEST_1((test_strided_iterator_order<2, ColMajor>(2)));
+  CALL_SUBTEST_1((test_strided_iterator_order<1, ColMajor>(1)));
   for (int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1((test_stl_iterators<double, 2, 3>()));
     CALL_SUBTEST_1((test_stl_iterators<float, 7, 5>()));
@@ -591,4 +754,10 @@
 
   CALL_SUBTEST_1((test_stl_container_detection<float, 1, 1>()));
   CALL_SUBTEST_1((test_stl_container_detection<float, 5, 5>()));
+
+#ifdef EIGEN_TEST_CXX20_RANGES
+  CALL_SUBTEST_1((test_cxx20_ranges<double, 4, 3>()));
+  CALL_SUBTEST_1(
+      (test_cxx20_ranges<float, Dynamic, Dynamic>(internal::random<int>(5, 10), internal::random<int>(5, 10))));
+#endif
 }
diff --git a/test/structured_bindings.cpp b/test/structured_bindings.cpp
new file mode 100644
index 0000000..58344cc
--- /dev/null
+++ b/test/structured_bindings.cpp
@@ -0,0 +1,209 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Pavel Guzenfeld
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+#if EIGEN_MAX_CPP_VER >= 17 && EIGEN_COMP_CXXVER >= 17
+
+template <typename Scalar>
+void check_vector_bindings() {
+  // Vector2
+  {
+    Matrix<Scalar, 2, 1> v;
+    v << Scalar(1), Scalar(2);
+    auto [x, y] = v;
+    VERIFY_IS_EQUAL(x, Scalar(1));
+    VERIFY_IS_EQUAL(y, Scalar(2));
+  }
+
+  // Vector3
+  {
+    Matrix<Scalar, 3, 1> v;
+    v << Scalar(3), Scalar(4), Scalar(5);
+    auto [x, y, z] = v;
+    VERIFY_IS_EQUAL(x, Scalar(3));
+    VERIFY_IS_EQUAL(y, Scalar(4));
+    VERIFY_IS_EQUAL(z, Scalar(5));
+  }
+
+  // Vector4
+  {
+    Matrix<Scalar, 4, 1> v;
+    v << Scalar(6), Scalar(7), Scalar(8), Scalar(9);
+    auto [a, b, c, d] = v;
+    VERIFY_IS_EQUAL(a, Scalar(6));
+    VERIFY_IS_EQUAL(b, Scalar(7));
+    VERIFY_IS_EQUAL(c, Scalar(8));
+    VERIFY_IS_EQUAL(d, Scalar(9));
+  }
+
+  // 1x1 matrix (scalar-like)
+  {
+    Matrix<Scalar, 1, 1> s;
+    s << Scalar(42);
+    auto [val] = s;
+    VERIFY_IS_EQUAL(val, Scalar(42));
+  }
+
+  // RowVector
+  {
+    Matrix<Scalar, 1, 3> rv;
+    rv << Scalar(10), Scalar(20), Scalar(30);
+    auto [a, b, c] = rv;
+    VERIFY_IS_EQUAL(a, Scalar(10));
+    VERIFY_IS_EQUAL(b, Scalar(20));
+    VERIFY_IS_EQUAL(c, Scalar(30));
+  }
+}
+
+template <typename Scalar>
+void check_array_bindings() {
+  // Array3
+  {
+    Array<Scalar, 3, 1> a;
+    a << Scalar(100), Scalar(200), Scalar(300);
+    auto [x, y, z] = a;
+    VERIFY_IS_EQUAL(x, Scalar(100));
+    VERIFY_IS_EQUAL(y, Scalar(200));
+    VERIFY_IS_EQUAL(z, Scalar(300));
+  }
+
+  // Array2
+  {
+    Array<Scalar, 2, 1> a;
+    a << Scalar(10), Scalar(20);
+    auto [x, y] = a;
+    VERIFY_IS_EQUAL(x, Scalar(10));
+    VERIFY_IS_EQUAL(y, Scalar(20));
+  }
+}
+
+template <typename Scalar>
+void check_reference_bindings() {
+  // Mutable reference binding
+  {
+    Matrix<Scalar, 3, 1> v;
+    v << Scalar(1), Scalar(2), Scalar(3);
+    auto& [x, y, z] = v;
+    x = Scalar(10);
+    y = Scalar(20);
+    z = Scalar(30);
+    VERIFY_IS_EQUAL(v(0), Scalar(10));
+    VERIFY_IS_EQUAL(v(1), Scalar(20));
+    VERIFY_IS_EQUAL(v(2), Scalar(30));
+  }
+
+  // Const reference binding
+  {
+    const Matrix<Scalar, 3, 1> v(Scalar(4), Scalar(5), Scalar(6));
+    const auto& [x, y, z] = v;
+    VERIFY_IS_EQUAL(x, Scalar(4));
+    VERIFY_IS_EQUAL(y, Scalar(5));
+    VERIFY_IS_EQUAL(z, Scalar(6));
+  }
+
+  // Array mutable reference binding
+  {
+    Array<Scalar, 2, 1> a;
+    a << Scalar(7), Scalar(8);
+    auto& [x, y] = a;
+    x = Scalar(70);
+    VERIFY_IS_EQUAL(a(0), Scalar(70));
+    VERIFY_IS_EQUAL(a(1), Scalar(8));
+  }
+}
+
+template <typename Scalar>
+void check_matrix_bindings() {
+  // 2D ColMajor matrix decomposes in column-major order: (0,0),(1,0),(0,1),(1,1).
+  // 2D RowMajor is rejected via static_assert — see failtest/structured_bindings_rowmajor.cpp.
+  {
+    Matrix<Scalar, 2, 2, ColMajor> m;
+    m << Scalar(1), Scalar(2), Scalar(3), Scalar(4);
+    auto [m00, m10, m01, m11] = m;
+    VERIFY_IS_EQUAL(m00, Scalar(1));
+    VERIFY_IS_EQUAL(m10, Scalar(3));
+    VERIFY_IS_EQUAL(m01, Scalar(2));
+    VERIFY_IS_EQUAL(m11, Scalar(4));
+  }
+}
+
+void check_tuple_size() {
+  STATIC_CHECK((std::tuple_size<Vector2d>::value == 2));
+  STATIC_CHECK((std::tuple_size<Vector3f>::value == 3));
+  STATIC_CHECK((std::tuple_size<Vector4i>::value == 4));
+  STATIC_CHECK((std::tuple_size<Matrix2d>::value == 4));
+  STATIC_CHECK((std::tuple_size<Matrix3f>::value == 9));
+  STATIC_CHECK((std::tuple_size<Array3i>::value == 3));
+  STATIC_CHECK((std::tuple_size<Array<double, 2, 1>>::value == 2));
+  STATIC_CHECK((std::tuple_size<Matrix<float, 1, 1>>::value == 1));
+  STATIC_CHECK((std::tuple_size<RowVector3d>::value == 3));
+}
+
+void check_tuple_element() {
+  STATIC_CHECK((std::is_same<std::tuple_element_t<0, Vector3d>, double>::value));
+  STATIC_CHECK((std::is_same<std::tuple_element_t<1, Vector3f>, float>::value));
+  STATIC_CHECK((std::is_same<std::tuple_element_t<2, Vector4i>, int>::value));
+  STATIC_CHECK((std::is_same<std::tuple_element_t<0, Array3i>, int>::value));
+}
+
+// Emulates generic tuple-like detection as done by fmt's range formatter
+// (issue #3103): probing tuple_size<T>::value in a SFINAE context must be a
+// substitution failure for dynamic-size types, not a hard error.
+template <typename T, typename = void>
+struct is_tuple_like : std::false_type {};
+
+template <typename T>
+struct is_tuple_like<T, internal::void_t<decltype(std::tuple_size<T>::value)>> : std::true_type {};
+
+template <typename T, typename = void>
+struct has_tuple_element0 : std::false_type {};
+
+template <typename T>
+struct has_tuple_element0<T, internal::void_t<typename std::tuple_element<0, T>::type>> : std::true_type {};
+
+void check_sfinae_friendly_detection() {
+  STATIC_CHECK((is_tuple_like<Vector3d>::value));
+  STATIC_CHECK((is_tuple_like<Matrix2f>::value));
+  STATIC_CHECK((is_tuple_like<Array3i>::value));
+  STATIC_CHECK((!is_tuple_like<VectorXd>::value));
+  STATIC_CHECK((!is_tuple_like<MatrixXf>::value));
+  STATIC_CHECK((!is_tuple_like<ArrayXd>::value));
+  STATIC_CHECK((!is_tuple_like<Matrix<double, 3, Dynamic>>::value));
+  STATIC_CHECK((!is_tuple_like<Matrix<double, Dynamic, 3>>::value));
+  STATIC_CHECK((has_tuple_element0<Vector3d>::value));
+  STATIC_CHECK((has_tuple_element0<Array3i>::value));
+  STATIC_CHECK((!has_tuple_element0<VectorXd>::value));
+  STATIC_CHECK((!has_tuple_element0<ArrayXXf>::value));
+}
+
+EIGEN_DECLARE_TEST(structured_bindings) {
+  CALL_SUBTEST_1(check_vector_bindings<double>());
+  CALL_SUBTEST_1(check_vector_bindings<float>());
+  CALL_SUBTEST_1(check_vector_bindings<int>());
+  CALL_SUBTEST_2(check_array_bindings<double>());
+  CALL_SUBTEST_2(check_array_bindings<int>());
+  CALL_SUBTEST_3(check_reference_bindings<double>());
+  CALL_SUBTEST_3(check_reference_bindings<float>());
+  CALL_SUBTEST_4(check_matrix_bindings<double>());
+  CALL_SUBTEST_4(check_matrix_bindings<int>());
+  CALL_SUBTEST_5(check_tuple_size());
+  CALL_SUBTEST_5(check_tuple_element());
+  CALL_SUBTEST_5(check_sfinae_friendly_detection());
+}
+
+#else
+
+EIGEN_DECLARE_TEST(structured_bindings) {
+  // Structured bindings require C++17.
+  VERIFY(true);
+}
+
+#endif
diff --git a/test/structured_norm.cpp b/test/structured_norm.cpp
new file mode 100644
index 0000000..488944d
--- /dev/null
+++ b/test/structured_norm.cpp
@@ -0,0 +1,96 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_RUNTIME_NO_MALLOC
+#include "main.h"
+#include <Eigen/Core>
+
+template <unsigned int UpLo, bool Hessenberg, typename Derived>
+void check_structured_abs_sum(const MatrixBase<Derived>& matrix) {
+  using RealScalar = typename Derived::RealScalar;
+  long double expected = 0;
+  for (Index row = 0; row < matrix.rows(); ++row) {
+    for (Index col = 0; col < matrix.cols(); ++col) {
+      if (UpLo == Upper ? row - col <= Index(Hessenberg) : col - row <= Index(Hessenberg)) {
+        const long double real = static_cast<long double>(numext::real(matrix(row, col)));
+        const long double imag = static_cast<long double>(numext::imag(matrix(row, col)));
+        expected += std::sqrt(real * real + imag * imag);
+      }
+    }
+  }
+  internal::set_is_malloc_allowed(false);
+  const RealScalar actual =
+      Hessenberg ? internal::hessenberg_abs_sum<UpLo>(matrix) : internal::triangular_abs_sum<UpLo>(matrix);
+  internal::set_is_malloc_allowed(true);
+  // Each magnitude and addition contributes O(eps); the reference accumulates in long double.
+  const long double bound = 8 * static_cast<long double>(matrix.size()) *
+                            static_cast<long double>(NumTraits<RealScalar>::epsilon()) * expected;
+  VERIFY((numext::isfinite)(actual));
+  VERIFY(std::abs(static_cast<long double>(actual) - expected) <= bound);
+}
+
+template <typename Derived>
+void check_structured_abs_sums(const MatrixBase<Derived>& matrix) {
+  check_structured_abs_sum<Upper, false>(matrix);
+  check_structured_abs_sum<Lower, false>(matrix);
+  check_structured_abs_sum<Upper, true>(matrix);
+  check_structured_abs_sum<Lower, true>(matrix);
+}
+
+template <typename Scalar, int StorageOrder>
+void structured_abs_sums() {
+  using Mat = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  const Matrix<Scalar, 3, 5, StorageOrder> fixed = Matrix<Scalar, 3, 5, StorageOrder>::Random();
+  check_structured_abs_sums(fixed);
+  check_structured_abs_sums(fixed.transpose());
+  for (Index rows : {0, 1, 2, 7, 16, 17, 33}) {
+    for (Index cols : {0, 1, 2, 7, 16, 17, 33}) {
+      Mat matrix = Mat::Random(rows, cols);
+      check_structured_abs_sums(matrix);
+      check_structured_abs_sums(matrix.transpose());
+      check_structured_abs_sums(matrix * Scalar(2));
+      Mat storage = Mat::Random(rows + 2, cols + 3);
+      check_structured_abs_sums(storage.block(1, 2, rows, cols));
+      using StridedMap = Map<const Mat, Unaligned, Stride<Dynamic, 2>>;
+      Mat stridedStorage = Mat::Random(2 * (rows + 1), 2 * (cols + 1));
+      StridedMap strided(stridedStorage.data(), rows, cols, Stride<Dynamic, 2>(stridedStorage.outerStride(), 2));
+      check_structured_abs_sums(strided);
+    }
+  }
+
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  const Scalar nan((std::numeric_limits<RealScalar>::quiet_NaN)());
+  for (Index extra : {0, 1}) {
+    Mat matrix = Mat::Random(17, 17);
+    for (Index row = 0; row < matrix.rows(); ++row)
+      for (Index col = 0; col + extra < row; ++col) matrix(row, col) = nan;
+    if (extra == 0) {
+      check_structured_abs_sum<Upper, false>(matrix);
+      check_structured_abs_sum<Lower, false>(matrix.transpose());
+    } else {
+      check_structured_abs_sum<Upper, true>(matrix);
+      check_structured_abs_sum<Lower, true>(matrix.transpose());
+    }
+  }
+
+  Mat matrix = Mat::Zero(17, 17);
+  matrix(0, 0) = nan;
+  VERIFY((numext::isnan)(internal::triangular_abs_sum<Upper>(matrix)));
+  VERIFY((numext::isnan)(internal::hessenberg_abs_sum<Lower>(matrix)));
+  matrix(0, 0) = Scalar((std::numeric_limits<RealScalar>::infinity)());
+  VERIFY((numext::isinf)(internal::triangular_abs_sum<Lower>(matrix)));
+  VERIFY((numext::isinf)(internal::hessenberg_abs_sum<Upper>(matrix)));
+}
+
+EIGEN_DECLARE_TEST(structured_norm) {
+  CALL_SUBTEST_1((structured_abs_sums<float, ColMajor>()));
+  CALL_SUBTEST_1((structured_abs_sums<float, RowMajor>()));
+  CALL_SUBTEST_2((structured_abs_sums<double, ColMajor>()));
+  CALL_SUBTEST_2((structured_abs_sums<double, RowMajor>()));
+  CALL_SUBTEST_3((structured_abs_sums<std::complex<float>, ColMajor>()));
+  CALL_SUBTEST_3((structured_abs_sums<std::complex<float>, RowMajor>()));
+  CALL_SUBTEST_4((structured_abs_sums<std::complex<double>, ColMajor>()));
+  CALL_SUBTEST_4((structured_abs_sums<std::complex<double>, RowMajor>()));
+  CALL_SUBTEST_5((structured_abs_sums<long double, ColMajor>()));
+  CALL_SUBTEST_5((structured_abs_sums<long double, RowMajor>()));
+}
diff --git a/test/superlu_support.cpp b/test/superlu_support.cpp
index 51cc3df..287a9a3 100644
--- a/test/superlu_support.cpp
+++ b/test/superlu_support.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #include "sparse_solver.h"
diff --git a/test/svd_common.h b/test/svd_common.h
index a9aa3b2..a54b571 100644
--- a/test/svd_common.h
+++ b/test/svd_common.h
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef SVD_DEFAULT
 #error a macro SVD_DEFAULT(MatrixType) must be defined prior to including svd_common.h
@@ -51,50 +52,28 @@
   VERIFY_IS_UNITARY(v);
 }
 
-// Compare partial SVD defined by computationOptions to a full SVD referenceSvd
-template <typename MatrixType, typename SvdType, int Options>
-void svd_compare_to_full(const MatrixType& m, const SvdType& referenceSvd) {
-  typedef typename MatrixType::RealScalar RealScalar;
-  Index rows = m.rows();
-  Index cols = m.cols();
-  Index diagSize = (std::min)(rows, cols);
-  RealScalar prec = test_precision<RealScalar>();
-
-  SVD_STATIC_OPTIONS(MatrixType, Options) svd(m);
-
-  VERIFY_IS_APPROX(svd.singularValues(), referenceSvd.singularValues());
-
-  if (Options & (ComputeFullV | ComputeThinV)) {
-    VERIFY((svd.matrixV().adjoint() * svd.matrixV()).isIdentity(prec));
-    VERIFY_IS_APPROX(svd.matrixV().leftCols(diagSize) * svd.singularValues().asDiagonal() *
-                         svd.matrixV().leftCols(diagSize).adjoint(),
-                     referenceSvd.matrixV().leftCols(diagSize) * referenceSvd.singularValues().asDiagonal() *
-                         referenceSvd.matrixV().leftCols(diagSize).adjoint());
-  }
-
-  if (Options & (ComputeFullU | ComputeThinU)) {
-    VERIFY((svd.matrixU().adjoint() * svd.matrixU()).isIdentity(prec));
-    VERIFY_IS_APPROX(svd.matrixU().leftCols(diagSize) * svd.singularValues().cwiseAbs2().asDiagonal() *
-                         svd.matrixU().leftCols(diagSize).adjoint(),
-                     referenceSvd.matrixU().leftCols(diagSize) *
-                         referenceSvd.singularValues().cwiseAbs2().asDiagonal() *
-                         referenceSvd.matrixU().leftCols(diagSize).adjoint());
-  }
-
-  // The following checks are not critical.
-  // For instance, with Dived&Conquer SVD, if only the factor 'V' is computed then different matrix-matrix product
-  // implementation will be used and the resulting 'V' factor might be significantly different when the SVD
-  // decomposition is not unique, especially with single precision float.
-  ++g_test_level;
-  if (Options & ComputeFullU) VERIFY_IS_APPROX(svd.matrixU(), referenceSvd.matrixU());
-  if (Options & ComputeThinU) VERIFY_IS_APPROX(svd.matrixU(), referenceSvd.matrixU().leftCols(diagSize));
-  if (Options & ComputeFullV) VERIFY_IS_APPROX(svd.matrixV().cwiseAbs(), referenceSvd.matrixV().cwiseAbs());
-  if (Options & ComputeThinV) VERIFY_IS_APPROX(svd.matrixV(), referenceSvd.matrixV().leftCols(diagSize));
-  --g_test_level;
+template <typename MatrixType, typename SvdType, typename RhsType, typename SolutionType>
+bool svd_check_normal_equation(const MatrixType& m, const SvdType& svd, const RhsType& rhs, const SolutionType& x) {
+  using RealScalar = typename MatrixType::RealScalar;
+  const RealScalar matrix_norm = m.stableNorm();
+  const RealScalar rhs_norm = rhs.stableNorm();
+  // Truncation gives A^H (A X - B) = -sum_{i >= rank} sigma_i v_i u_i^H B.
+  const RealScalar truncated =
+      svd.rank() < svd.singularValues().size() ? svd.singularValues()(svd.rank()) * rhs_norm : RealScalar(0);
+  const typename SolutionType::PlainObject normal_lhs = m.adjoint() * (m * x);
+  const typename SolutionType::PlainObject normal_rhs = m.adjoint() * rhs;
+  const RealScalar normal_error = (normal_lhs - normal_rhs).stableNorm();
+  // For C = A^H A and D = A^H B, perturbations bounded by eta*||A||^2 and eta*||A||*||B|| give
+  // ||C X - D|| <= eta*||A||*(||A||*||X|| + ||B||). This includes cancellation in A*X.
+  // Use eta = 8*(rows + cols)*eps as the backward-error budget for the decomposition,
+  // solve, and checking products (including complex arithmetic).
+  const RealScalar roundoff = 8 * RealScalar(m.rows() + m.cols()) * NumTraits<RealScalar>::epsilon();
+  const RealScalar normal_tolerance = (roundoff * matrix_norm) * (matrix_norm * x.stableNorm() + rhs_norm) + truncated;
+  return (numext::isfinite)(normal_tolerance) && normal_error <= normal_tolerance;
 }
 
-template <typename SvdType, typename MatrixType>
-void svd_least_square(const MatrixType& m) {
+template <typename MatrixType, typename SvdType>
+void svd_least_square(const MatrixType& m, SvdType& svd) {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename MatrixType::RealScalar RealScalar;
   Index rows = m.rows();
@@ -106,11 +85,10 @@
   typedef Matrix<Scalar, ColsAtCompileTime, Dynamic> SolutionType;
 
   RhsType rhs = RhsType::Random(rows, internal::random<Index>(1, cols));
-  SvdType svd(m);
 
-  if (internal::is_same<RealScalar, double>::value)
+  if (std::is_same<RealScalar, double>::value)
     svd.setThreshold(RealScalar(1e-8));
-  else if (internal::is_same<RealScalar, float>::value)
+  else if (std::is_same<RealScalar, float>::value)
     svd.setThreshold(RealScalar(2e-4));
 
   SolutionType x = svd.solve(rhs);
@@ -121,15 +99,12 @@
     // ^^^ If the residual is very small, then we have an exact solution, so we are already good.
 
     // evaluate normal equation which works also for least-squares solutions
-    if (internal::is_same<RealScalar, double>::value || svd.rank() == m.diagonal().size()) {
-      using std::sqrt;
-      // This test is not stable with single precision.
-      // This is likely because squaring m significantly affects the precision.
-      if (internal::is_same<RealScalar, float>::value) ++g_test_level;
+    if (std::is_same<RealScalar, double>::value || svd.rank() == m.diagonal().size()) {
+      if (std::is_same<RealScalar, float>::value) ++g_test_level;
 
-      VERIFY_IS_APPROX(m.adjoint() * (m * x), m.adjoint() * rhs);
+      VERIFY(svd_check_normal_equation(m, svd, rhs, x));
 
-      if (internal::is_same<RealScalar, float>::value) --g_test_level;
+      if (std::is_same<RealScalar, float>::value) --g_test_level;
     }
 
     // Check that there is no significantly better solution in the neighborhood of x
@@ -140,18 +115,81 @@
       y.row(k) = (RealScalar(1) + 2 * NumTraits<RealScalar>::epsilon()) * x.row(k);
       RealScalar residual_y = (m * y - rhs).norm();
       VERIFY(test_isMuchSmallerThan(abs(residual_y - residual), rhs_norm) || residual < residual_y);
-      if (internal::is_same<RealScalar, float>::value) ++g_test_level;
+      if (std::is_same<RealScalar, float>::value) ++g_test_level;
       VERIFY(test_isApprox(residual_y, residual) || residual < residual_y);
-      if (internal::is_same<RealScalar, float>::value) --g_test_level;
+      if (std::is_same<RealScalar, float>::value) --g_test_level;
 
       y.row(k) = (RealScalar(1) - 2 * NumTraits<RealScalar>::epsilon()) * x.row(k);
       residual_y = (m * y - rhs).norm();
       VERIFY(test_isMuchSmallerThan(abs(residual_y - residual), rhs_norm) || residual < residual_y);
-      if (internal::is_same<RealScalar, float>::value) ++g_test_level;
+      if (std::is_same<RealScalar, float>::value) ++g_test_level;
       VERIFY(test_isApprox(residual_y, residual) || residual < residual_y);
-      if (internal::is_same<RealScalar, float>::value) --g_test_level;
+      if (std::is_same<RealScalar, float>::value) --g_test_level;
     }
   }
+  svd.setThreshold(Default);
+}
+
+template <typename Scalar, int StorageOrder>
+void svd_normal_equation_roundoff() {
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, StorageOrder>;
+  const RealScalar delta = std::is_same<RealScalar, float>::value ? RealScalar(1) / 32 : RealScalar(1) / 1048576;
+  const RealScalar large_scale = numext::sqrt((std::numeric_limits<RealScalar>::max)()) * RealScalar(16);
+  const RealScalar scales[] = {RealScalar(1), large_scale, RealScalar(1) / large_scale};
+  MatrixType m(3, 2), rhs(3, 2), x(2, 2), exact(2, 2);
+  rhs << 0, 0, 1, -2, 1, 3;
+  // [3 7; delta -delta; 0 0] has x = [0.7; -0.3]/delta for b = [0; 1; 1].
+  // Rounding x perturbs the cancelling first row by O(eps/delta).
+  exact << RealScalar(0.7) / delta, -RealScalar(1.4) / delta, -RealScalar(0.3) / delta, RealScalar(0.6) / delta;
+  Scalar phase(1);
+  maybe_set_imag_part<Scalar>::run(phase, RealScalar(1));
+  for (RealScalar scale : scales) {
+    m << 3, 7, delta, -delta, 0, 0;
+    m.col(0) *= phase;
+    m *= scale;
+    SVD_STATIC_OPTIONS(MatrixType, ComputeFullU | ComputeFullV) svd(m);
+    VERIFY_IS_EQUAL(svd.info(), Success);
+    VERIFY_IS_EQUAL(svd.rank(), 2);
+    x = svd.solve(rhs);
+    VERIFY(svd_check_normal_equation(m, svd, rhs, x));
+    x = exact / scale;
+    x.row(0) /= phase;
+    VERIFY(svd_check_normal_equation(m, svd, rhs, x));
+    x.setZero();
+    VERIFY(!svd_check_normal_equation(m, svd, rhs, x));
+  }
+
+  // Sharpness: C = D = 1, delta_C = -eta, delta_D = eta gives
+  // X = (1 + eta)/(1 - eta), |X - 1| = eta*(|X| + 1).
+  // Here eta = 16*eps: the rounded X is accepted, but one more ULP is rejected.
+  m = MatrixType::Ones(1, 1);
+  rhs = MatrixType::Ones(1, 1);
+  x.resize(1, 1);
+  SVD_STATIC_OPTIONS(MatrixType, ComputeFullU | ComputeFullV) scalar_svd(m);
+  x(0, 0) = Scalar(RealScalar(1) + 32 * NumTraits<RealScalar>::epsilon());
+  VERIFY(svd_check_normal_equation(m, scalar_svd, rhs, x));
+  x(0, 0) = Scalar(RealScalar(1) + 33 * NumTraits<RealScalar>::epsilon());
+  VERIFY(!svd_check_normal_equation(m, scalar_svd, rhs, x));
+
+  // A discarded singular direction must contribute its truncation allowance.
+  m.setZero(3, 2);
+  rhs.resize(3, 2);
+  m(0, 0) = Scalar(1);
+  m(1, 1) = Scalar(numext::sqrt(NumTraits<RealScalar>::epsilon()));
+  rhs << 1, -2, 1, -2, 1, 3;
+  SVD_STATIC_OPTIONS(MatrixType, ComputeFullU | ComputeFullV) svd(m);
+  svd.setThreshold(2 * numext::sqrt(NumTraits<RealScalar>::epsilon()));
+  VERIFY_IS_EQUAL(svd.rank(), 1);
+  x = svd.solve(rhs);
+  VERIFY(svd_check_normal_equation(m, svd, rhs, x));
+  x.setZero();
+  VERIFY(!svd_check_normal_equation(m, svd, rhs, x));
+
+  x.setConstant(Scalar(std::numeric_limits<RealScalar>::infinity()));
+  VERIFY(!svd_check_normal_equation(m, svd, rhs, x));
+  x.setConstant(Scalar(std::numeric_limits<RealScalar>::quiet_NaN()));
+  VERIFY(!svd_check_normal_equation(m, svd, rhs, x));
 }
 
 // check minimal norm solutions, the input matrix m is only used to recover problem size
@@ -164,15 +202,15 @@
 
   typedef Matrix<Scalar, ColsAtCompileTime, Dynamic> SolutionType;
 
-  // generate a full-rank m x n problem with m<n
-  enum {
-    RankAtCompileTime2 = ColsAtCompileTime == Dynamic ? Dynamic : (ColsAtCompileTime) / 2 + 1,
-    RowsAtCompileTime3 = ColsAtCompileTime == Dynamic ? Dynamic : ColsAtCompileTime + 1
-  };
+  // Generate a full-rank m x n problem with m<n. Keep fixed columns from the
+  // caller, but do not encode generated row counts into the helper matrix types.
+  // Otherwise fixed-column callers instantiate extra fully fixed SVD shapes.
+  constexpr int RankAtCompileTime2 = Dynamic;
+  constexpr int RowsAtCompileTime3 = Dynamic;
   typedef Matrix<Scalar, RankAtCompileTime2, ColsAtCompileTime> MatrixType2;
   typedef Matrix<Scalar, RankAtCompileTime2, 1> RhsType2;
   typedef Matrix<Scalar, ColsAtCompileTime, RankAtCompileTime2> MatrixType2T;
-  Index rank = RankAtCompileTime2 == Dynamic ? internal::random<Index>(1, cols) : Index(RankAtCompileTime2);
+  Index rank = ColsAtCompileTime == Dynamic ? internal::random<Index>(1, cols) : Index(ColsAtCompileTime / 2 + 1);
   MatrixType2 m2(rank, cols);
   m2.setRandom();
   if (SVD_FOR_MIN_NORM(MatrixType2)(m2).setThreshold(test_precision<Scalar>()).rank() != rank) {
@@ -198,7 +236,8 @@
   // Now check with a rank deficient matrix
   typedef Matrix<Scalar, RowsAtCompileTime3, ColsAtCompileTime> MatrixType3;
   typedef Matrix<Scalar, RowsAtCompileTime3, 1> RhsType3;
-  Index rows3 = RowsAtCompileTime3 == Dynamic ? internal::random<Index>(rank + 1, 2 * cols) : Index(RowsAtCompileTime3);
+  Index rows3 =
+      ColsAtCompileTime == Dynamic ? internal::random<Index>(rank + 1, 2 * cols) : Index(ColsAtCompileTime + 1);
   Matrix<Scalar, RowsAtCompileTime3, Dynamic> C = Matrix<Scalar, RowsAtCompileTime3, Dynamic>::Random(rows3, rank);
   MatrixType3 m3 = C * m2;
   RhsType3 rhs3 = C * rhs2;
@@ -226,18 +265,33 @@
   check_solverbase<CMatrixType, MatrixType>(m, solver, rows, cols, cols2);
 }
 
-// work around stupid msvc error when constructing at compile time an expression that involves
-// a division by zero, even if the numeric type has floating point
-template <typename Scalar>
-EIGEN_DONT_INLINE Scalar zero() {
-  return Scalar(0);
-}
+template <typename MatrixType, int Options,
+          bool HasQrPreconditioner = (Options & internal::QRPreconditionerBits) != NoQRPreconditioner>
+struct svd_min_norm_if {
+  static void run(const MatrixType& m) { svd_min_norm<MatrixType, Options>(m); }
+};
 
-// workaround aggressive optimization in ICC
-template <typename T>
-EIGEN_DONT_INLINE T sub(T a, T b) {
-  return a - b;
-}
+template <typename MatrixType, int Options>
+struct svd_min_norm_if<MatrixType, Options, false> {
+  static void run(const MatrixType&) {}
+};
+
+template <typename MatrixType, int Options, typename SVDType,
+          bool ComputesBothUnitaries =
+              (Options & (ComputeThinU | ComputeFullU)) != 0 && (Options & (ComputeThinV | ComputeFullV)) != 0>
+struct svd_solver_checks_if {
+  static void run(const MatrixType&, SVDType&) {}
+};
+
+template <typename MatrixType, int Options, typename SVDType>
+struct svd_solver_checks_if<MatrixType, Options, SVDType, true> {
+  static void run(const MatrixType& m, SVDType& staticSvd) {
+    svd_test_solvers(m, staticSvd);
+    svd_least_square(m, staticSvd);
+    // svd_min_norm generates non-square matrices so it can't be used with NoQRPreconditioner.
+    svd_min_norm_if<MatrixType, Options>::run(m);
+  }
+};
 
 // This function verifies we don't iterate infinitely on nan/inf values,
 // and that info() returns InvalidInput.
@@ -245,8 +299,8 @@
 void svd_inf_nan() {
   SVD_STATIC_OPTIONS(MatrixType, ComputeFullU | ComputeFullV) svd;
   typedef typename MatrixType::Scalar Scalar;
-  Scalar some_inf = Scalar(1) / zero<Scalar>();
-  VERIFY(sub(some_inf, some_inf) != sub(some_inf, some_inf));
+  const Scalar some_inf = (std::numeric_limits<Scalar>::infinity)();
+  VERIFY((numext::isinf)(some_inf));
   svd.compute(MatrixType::Constant(10, 10, some_inf));
   VERIFY(svd.info() == InvalidInput);
 
@@ -327,28 +381,6 @@
   CALL_SUBTEST(svd_check_full(M3, svd3));
 }
 
-template <typename MatrixType>
-void svd_all_trivial_2x2(void (*cb)(const MatrixType&)) {
-  MatrixType M;
-  VectorXd value_set(3);
-  value_set << 0, 1, -1;
-  Array4i id(0, 0, 0, 0);
-  int k = 0;
-  do {
-    M << value_set(id(0)), value_set(id(1)), value_set(id(2)), value_set(id(3));
-
-    cb(M);
-
-    id(k)++;
-    if (id(k) >= value_set.size()) {
-      while (k < 3 && id(k) >= value_set.size()) id(++k)++;
-      id.head(k).setZero();
-      k = 0;
-    }
-
-  } while ((id < int(value_set.size())).all());
-}
-
 template <typename>
 void svd_preallocate() {
   Vector3f v(3.f, 2.f, 1.f);
@@ -373,17 +405,26 @@
   internal::set_is_malloc_allowed(false);
   svd2.compute(m);
   internal::set_is_malloc_allowed(true);
+
+  MatrixXf tall = MatrixXf::Random(4, 3);
+  MatrixXf wide = MatrixXf::Random(3, 4);
+  SVD_STATIC_OPTIONS(MatrixXf, ComputeThinU | ComputeThinV) tallSvd(4, 3);
+  SVD_STATIC_OPTIONS(MatrixXf, ComputeThinU | ComputeThinV) wideSvd(3, 4);
+  internal::set_is_malloc_allowed(false);
+  tallSvd.compute(tall);
+  wideSvd.compute(wide);
+  internal::set_is_malloc_allowed(true);
+  VERIFY_IS_APPROX(tall, tallSvd.matrixU() * tallSvd.singularValues().asDiagonal() * tallSvd.matrixV().adjoint());
+  VERIFY_IS_APPROX(wide, wideSvd.matrixU() * wideSvd.singularValues().asDiagonal() * wideSvd.matrixV().adjoint());
 }
 
 template <typename MatrixType, int QRPreconditioner = 0>
-void svd_verify_assert_full_only(const MatrixType& input = MatrixType()) {
+void svd_verify_assert_full_only(const MatrixType& m) {
   enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime };
 
   typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, 1> RhsType;
-  RhsType rhs = RhsType::Zero(input.rows());
+  RhsType rhs = RhsType::Zero(m.rows());
   EIGEN_UNUSED_VARIABLE(rhs);  // Only used if asserts are enabled.
-  MatrixType m(input.rows(), input.cols());
-  svd_fill_random(m);
 
   SVD_STATIC_OPTIONS(MatrixType, QRPreconditioner) svd0;
   VERIFY_RAISES_ASSERT((svd0.matrixU()));
@@ -407,13 +448,11 @@
 }
 
 template <typename MatrixType, int QRPreconditioner = 0>
-void svd_verify_assert(const MatrixType& input = MatrixType()) {
+void svd_verify_assert(const MatrixType& m) {
   enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime };
   typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, 1> RhsType;
-  RhsType rhs = RhsType::Zero(input.rows());
+  RhsType rhs = RhsType::Zero(m.rows());
   EIGEN_UNUSED_VARIABLE(rhs);  // Only used if asserts are enabled.
-  MatrixType m(input.rows(), input.cols());
-  svd_fill_random(m);
 
   SVD_STATIC_OPTIONS(MatrixType, QRPreconditioner | ComputeThinU) svdThinU(m);
   VERIFY_RAISES_ASSERT((svdThinU.matrixV()));
@@ -460,19 +499,26 @@
   if (staticSvd.computeU()) VERIFY(staticSvd.matrixU().isUnitary());
   if (staticSvd.computeV()) VERIFY(staticSvd.matrixV().isUnitary());
 
-  if (staticSvd.computeU() && staticSvd.computeV()) {
-    svd_test_solvers(m, staticSvd);
-    svd_least_square<SVDType, MatrixType>(m);
-    // svd_min_norm generates non-square matrices so it can't be used with NoQRPreconditioner
-    if ((Options & internal::QRPreconditionerBits) != NoQRPreconditioner) svd_min_norm<MatrixType, Options>(m);
-  }
+  svd_solver_checks_if<MatrixType, Options, SVDType>::run(m, staticSvd);
 }
 
 template <typename MatrixType, int QRPreconditioner = 0>
-void svd_thin_option_checks(const MatrixType& input) {
+void svd_full_option_checks(const MatrixType& m) {
+  svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullU>(m);
+  svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullV>(m);
+  svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullU | ComputeFullV>(m);
+
+  SVD_STATIC_OPTIONS(MatrixType, QRPreconditioner | ComputeFullU | ComputeFullV) fullSvd(m);
+  svd_check_full(m, fullSvd);
+}
+
+template <typename MatrixType, int QRPreconditioner = 0>
+void svd_thin_full_option_checks(const MatrixType& input) {
   MatrixType m(input.rows(), input.cols());
   svd_fill_random(m);
 
+  svd_verify_assert<MatrixType, QRPreconditioner>(m);
+
   svd_compute_checks<MatrixType, QRPreconditioner>(m);
   svd_compute_checks<MatrixType, QRPreconditioner | ComputeThinU>(m);
   svd_compute_checks<MatrixType, QRPreconditioner | ComputeThinV>(m);
@@ -481,22 +527,15 @@
   svd_compute_checks<MatrixType, QRPreconditioner | ComputeThinU | ComputeFullV>(m);
   svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullU | ComputeThinV>(m);
 
-  typedef SVD_STATIC_OPTIONS(MatrixType, QRPreconditioner | ComputeFullU | ComputeFullV) FullSvdType;
-  FullSvdType fullSvd(m);
-  svd_check_full(m, fullSvd);
-  svd_compare_to_full<MatrixType, FullSvdType, QRPreconditioner | ComputeFullU | ComputeFullV>(m, fullSvd);
+  svd_full_option_checks<MatrixType, QRPreconditioner>(m);
 }
 
 template <typename MatrixType, int QRPreconditioner = 0>
 void svd_option_checks_full_only(const MatrixType& input) {
   MatrixType m(input.rows(), input.cols());
   svd_fill_random(m);
-  svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullU>(m);
-  svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullV>(m);
-  svd_compute_checks<MatrixType, QRPreconditioner | ComputeFullU | ComputeFullV>(m);
-
-  SVD_STATIC_OPTIONS(MatrixType, QRPreconditioner | ComputeFullU | ComputeFullV) fullSvd(m);
-  svd_check_full(m, fullSvd);
+  svd_verify_assert_full_only<MatrixType, QRPreconditioner>(m);
+  svd_full_option_checks<MatrixType, QRPreconditioner>(m);
 }
 
 template <typename MatrixType, int QRPreconditioner = 0>
@@ -531,25 +570,6 @@
   VERIFY_RAISES_ASSERT(fullSvd.compute(dynamicMatrix));
 }
 
-template <typename SvdType, typename MatrixType>
-void svd_verify_constructor_options_assert(const MatrixType& m) {
-  typedef typename MatrixType::Scalar Scalar;
-  Index rows = m.rows();
-
-  enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime };
-
-  typedef Matrix<Scalar, RowsAtCompileTime, 1> RhsType;
-  RhsType rhs(rows);
-  svd_fill_random(rhs);
-  SvdType svd;
-  VERIFY_RAISES_ASSERT(svd.matrixU())
-  VERIFY_RAISES_ASSERT(svd.singularValues())
-  VERIFY_RAISES_ASSERT(svd.matrixV())
-  VERIFY_RAISES_ASSERT(svd.solve(rhs))
-  VERIFY_RAISES_ASSERT(svd.transpose().solve(rhs))
-  VERIFY_RAISES_ASSERT(svd.adjoint().solve(rhs))
-}
-
 #undef SVD_DEFAULT
 #undef SVD_FOR_MIN_NORM
 #undef SVD_STATIC_OPTIONS
diff --git a/test/svd_fill.h b/test/svd_fill.h
index 3ef7c9a..bc82bff 100644
--- a/test/svd_fill.h
+++ b/test/svd_fill.h
@@ -6,6 +6,10 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_SVD_FILL_H
+#define EIGEN_TEST_SVD_FILL_H
 
 template <typename T>
 Array<T, 4, 1> four_denorms();
@@ -33,7 +37,7 @@
 };
 
 template <typename MatrixType>
-void svd_fill_random(MatrixType &m, int Option = 0) {
+void svd_fill_random(MatrixType& m, int Option = 0) {
   using std::pow;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename MatrixType::RealScalar RealScalar;
@@ -132,3 +136,5 @@
     }
   }
 }
+
+#endif  // EIGEN_TEST_SVD_FILL_H
diff --git a/test/sve_vector_length.cpp b/test/sve_vector_length.cpp
new file mode 100644
index 0000000..aef9936
--- /dev/null
+++ b/test/sve_vector_length.cpp
@@ -0,0 +1,77 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// SVE packet types are fixed-length vectors of exactly EIGEN_ARM64_SVE_VL bits. Running such a
+// binary where the hardware vector length differs makes every packet type a lie and lets the
+// rest of the suite pass vacuously. qemu is the common way in: above 512 bits it keeps the
+// default 512-bit task vector length, so `-cpu max,sve2048=on` alone runs at 512 unless
+// `sve-default-vector-length=<bytes>` is also given.
+
+// The backend raises Eigen's own default to fit its blocked kernel panels, but an explicit limit
+// is the caller's policy and must survive. 1 is below the requirement at every vector length, so
+// the assertion is never vacuous, and nothing in this file allocates a fixed-size Eigen object.
+#define EIGEN_STACK_ALLOCATION_LIMIT 1
+#include "main.h"
+static_assert(EIGEN_STACK_ALLOCATION_LIMIT == 1, "SVE must preserve an explicit stack allocation limit");
+
+// Registered only under EIGEN_TEST_SVE (test/CMakeLists.txt). Without an SVE -march this would
+// compile against NEON and trivially pass.
+#if !defined(EIGEN_VECTORIZE_SVE)
+#error \
+    "sve_vector_length requires the SVE backend.  Build with an SVE -march (e.g. " \
+    "-march=armv8.2-a+sve) and -DEIGEN_TEST_SVE=ON, which supplies -DEIGEN_ARM64_USE_SVE and " \
+    "-msve-vector-bits."
+#endif
+
+// Must stay inline asm: under -msve-vector-bits the compiler folds svcntb() to the compile-time
+// constant, making the comparison below a tautology that holds on a mismatched machine.
+static EIGEN_DONT_INLINE int runtime_vector_length_bits() {
+  numext::uint64_t vl_bytes;
+  asm("rdvl %0, #1" : "=r"(vl_bytes));
+  return int(vl_bytes) * CHAR_BIT;
+}
+
+void check_runtime_vector_length() { VERIFY_IS_EQUAL(runtime_vector_length_bits(), int(EIGEN_ARM64_SVE_VL)); }
+
+// Cross-checked against RDVL rather than svcntw()/svcntd(), which fold as above.
+void check_packet_sizes() {
+  const int vl = runtime_vector_length_bits();
+  VERIFY_IS_EQUAL(int(internal::packet_traits<numext::int32_t>::size), vl / (8 * int(sizeof(numext::int32_t))));
+  VERIFY_IS_EQUAL(int(internal::packet_traits<float>::size), vl / (8 * int(sizeof(float))));
+  VERIFY_IS_EQUAL(int(internal::packet_traits<double>::size), vl / (8 * int(sizeof(double))));
+}
+
+// The opaque barriers keep the store/reload from being constant-folded away; on a narrower
+// machine the tail of the buffer then keeps its sentinel.
+template <typename Scalar, typename Packet>
+void check_full_width_store() {
+  constexpr int PacketSize = internal::unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_MAX Scalar buffer[PacketSize];
+  Scalar value = Scalar(1);
+
+  Scalar* p = buffer;
+  asm volatile("" : "+r"(p) : : "memory");
+  for (int i = 0; i < PacketSize; ++i) p[i] = Scalar(-12345);
+  asm volatile("" : "+r"(p), "+r"(value) : : "memory");
+
+  internal::pstore(p, internal::pset1<Packet>(value));
+  asm volatile("" : "+r"(p) : : "memory");
+
+  for (int i = 0; i < PacketSize; ++i) {
+    VERIFY_IS_EQUAL(p[i], Scalar(1));
+  }
+}
+
+EIGEN_DECLARE_TEST(sve_vector_length) {
+  CALL_SUBTEST(check_runtime_vector_length());
+  CALL_SUBTEST(check_packet_sizes());
+  CALL_SUBTEST((check_full_width_store<numext::int32_t, internal::PacketXi>()));
+  CALL_SUBTEST((check_full_width_store<float, internal::PacketXf>()));
+  CALL_SUBTEST((check_full_width_store<double, internal::PacketXd>()));
+}
diff --git a/test/swap.cpp b/test/swap.cpp
index 7bfabc3..04ae2a0 100644
--- a/test/swap.cpp
+++ b/test/swap.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -39,7 +40,7 @@
   typedef typename other_matrix_type<MatrixType>::type OtherMatrixType;
   typedef typename MatrixType::Scalar Scalar;
 
-  eigen_assert((!internal::is_same<MatrixType, OtherMatrixType>::value));
+  eigen_assert((!std::is_same<MatrixType, OtherMatrixType>::value));
   Index rows = m.rows();
   Index cols = m.cols();
 
@@ -119,5 +120,5 @@
   CALL_SUBTEST_2(swap(Matrix4d()));      // fixed size, possible vectorization
   CALL_SUBTEST_3(swap(MatrixXd(s, s)));  // dyn size, no vectorization
   CALL_SUBTEST_4(swap(MatrixXf(s, s)));  // dyn size, possible vectorization
-  TEST_SET_BUT_UNUSED_VARIABLE(s)
+  TEST_SET_BUT_UNUSED_VARIABLE(s);
 }
diff --git a/test/sycl_basic.cpp b/test/sycl_basic.cpp
index 06f03c4..ad9ba04 100644
--- a/test/sycl_basic.cpp
+++ b/test/sycl_basic.cpp
@@ -9,6 +9,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_TEST_NO_LONGDOUBLE
 #define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
@@ -328,7 +329,7 @@
 template <typename DataType, typename Input, typename Output>
 void test_numeric_limits(const Input& in, Output& out) {
   auto operation = [](const typename DataType::Scalar* in, typename DataType::Scalar* out) {
-    EIGEN_UNUSED_VARIABLE(in)
+    EIGEN_UNUSED_VARIABLE(in);
     out[0] = numext::numeric_limits<float>::epsilon();
     out[1] = (numext::numeric_limits<float>::max)();
     out[2] = (numext::numeric_limits<float>::min)();
@@ -338,6 +339,73 @@
   run_and_verify<true, true>(operation, 1, in, out);
 }
 
+template <typename Operation>
+void test_predux_any(Operation& operation) {
+  VectorXf in(1);
+  Matrix<int, 3, 1> out;
+  in.setZero();
+  out.setZero();
+
+  run_and_verify<false, true>(operation, 1, in, out);
+}
+
+void test_predux_any_float() {
+  auto operation = [](const float* in, int* out) {
+#ifdef SYCL_DEVICE_ONLY
+    const cl::sycl::cl_int4 int_none(0);
+    const cl::sycl::cl_int4 int_some(0, -1, 0, 0);
+    const cl::sycl::cl_int4 int_all(-1);
+    out[0] = internal::predux_any(int_none.template as<cl::sycl::cl_float4>());
+    out[1] = internal::predux_any(int_some.template as<cl::sycl::cl_float4>());
+    out[2] = internal::predux_any(int_all.template as<cl::sycl::cl_float4>());
+#else
+    EIGEN_UNUSED_VARIABLE(in);
+    out[0] = 0;
+    out[1] = 1;
+    out[2] = 1;
+#endif
+  };
+  test_predux_any(operation);
+}
+
+void test_predux_any_half() {
+  auto operation = [](const float* in, int* out) {
+#ifdef SYCL_DEVICE_ONLY
+    const cl::sycl::cl_short8 short_none(0);
+    const cl::sycl::cl_short8 short_some(0, -1, 0, 0, 0, 0, 0, 0);
+    const cl::sycl::cl_short8 short_all(-1);
+    out[0] = internal::predux_any(short_none.template as<cl::sycl::cl_half8>());
+    out[1] = internal::predux_any(short_some.template as<cl::sycl::cl_half8>());
+    out[2] = internal::predux_any(short_all.template as<cl::sycl::cl_half8>());
+#else
+    EIGEN_UNUSED_VARIABLE(in);
+    out[0] = 0;
+    out[1] = 1;
+    out[2] = 1;
+#endif
+  };
+  test_predux_any(operation);
+}
+
+void test_predux_any_double() {
+  auto operation = [](const float* in, int* out) {
+#ifdef SYCL_DEVICE_ONLY
+    const cl::sycl::cl_long2 long_none(0);
+    const cl::sycl::cl_long2 long_some(0, -1);
+    const cl::sycl::cl_long2 long_all(-1);
+    out[0] = internal::predux_any(long_none.template as<cl::sycl::cl_double2>());
+    out[1] = internal::predux_any(long_some.template as<cl::sycl::cl_double2>());
+    out[2] = internal::predux_any(long_all.template as<cl::sycl::cl_double2>());
+#else
+    EIGEN_UNUSED_VARIABLE(in);
+    out[0] = 0;
+    out[1] = 1;
+    out[2] = 1;
+#endif
+  };
+  test_predux_any(operation);
+}
+
 EIGEN_DECLARE_TEST(sycl_basic) {
   Eigen::VectorXf in, out;
   Eigen::VectorXcf cfin, cfout;
@@ -379,4 +447,8 @@
   CALL_SUBTEST(test_matrix_inverse<Matrix4f>(num_elements, in, out));
 
   CALL_SUBTEST(test_numeric_limits<Vector3f>(in, out));
+  CALL_SUBTEST(test_predux_any_float());
+  const sycl::device device{sycl::default_selector_v};
+  if (device.has(sycl::aspect::fp16)) CALL_SUBTEST(test_predux_any_half());
+  if (device.has(sycl::aspect::fp64)) CALL_SUBTEST(test_predux_any_double());
 }
diff --git a/test/symbolic_index.cpp b/test/symbolic_index.cpp
index 1bd5bd8..7dbcafe 100644
--- a/test/symbolic_index.cpp
+++ b/test/symbolic_index.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/threads_eventcount.cpp b/test/threads_eventcount.cpp
index a40bd00..09eb24a 100644
--- a/test/threads_eventcount.cpp
+++ b/test/threads_eventcount.cpp
@@ -7,12 +7,11 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_USE_THREADS
-// clang-format off
 #include "main.h"
 #include <Eigen/ThreadPool>
-// clang-format on
 
 #include <algorithm>
 #include <atomic>
@@ -24,7 +23,7 @@
 // Visual studio doesn't implement a rand_r() function since its
 // implementation of rand() is already thread safe
 int rand_reentrant(unsigned int* s) {
-#if EIGEN_COMP_MSVC_STRICT  // NOLINT(misc-include-cleaner)
+#if EIGEN_COMP_MSVC_STRICT
   EIGEN_UNUSED_VARIABLE(s);
   return rand();
 #else
@@ -33,7 +32,7 @@
 }
 
 static void test_basic_eventcount() {
-  MaxSizeVector<EventCount::Waiter> waiters(1);  // NOLINT(misc-include-cleaner)
+  MaxSizeVector<EventCount::Waiter> waiters(1);
   waiters.resize(1);
   EventCount ec(waiters);
   EventCount::Waiter& w = waiters[0];
@@ -46,7 +45,7 @@
 }
 
 static void test_cancel_wait_signal_forwarding() {
-  MaxSizeVector<EventCount::Waiter> waiters(2);  // NOLINT(misc-include-cleaner)
+  MaxSizeVector<EventCount::Waiter> waiters(2);
   waiters.resize(2);
   EventCount ec(waiters);
 
@@ -63,21 +62,19 @@
   while (!t0_started.load()) {
     std::this_thread::yield();
   }
+  // Brief delay to allow t0 to enter CommitWait and park on stack.
   std::this_thread::sleep_for(std::chrono::milliseconds(50));
 
-  // Thread 1 calls Prewait, so waiters count becomes 1 (with t0 on the waiter
-  // stack).
+  // Thread 1 calls Prewait, so waiters count becomes 1 (with t0 on the waiter stack).
   ec.Prewait();
   // Main thread signals a waiter.
   // Because waiters count is 1 and signals count is 0 (signals < waiters),
-  // Notify(false) increments signals count rather than unparking t0 from the
-  // stack.
+  // Notify(false) increments signals count rather than unparking t0 from the stack.
   ec.Notify(false);
   // Thread 1 cancels its wait.
-  // Without the fix, CancelWait decrements signals count to maintain signals <=
-  // waiters, discarding the notification and leaving t0 parked on the stack
-  // forever. With the fix, CancelWait calls Notify(false) to forward the
-  // discarded signal to the parked waiter (t0).
+  // Without the fix, CancelWait decrements signals count to maintain signals <= waiters,
+  // discarding the notification and leaving t0 parked on the stack forever.
+  // With the fix, CancelWait calls Notify(false) to forward the discarded signal to t0.
   ec.CancelWait();
 
   auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
@@ -135,14 +132,12 @@
   static const int kEvents = 1 << 16;
   static const int kQueues = 10;
 
-  MaxSizeVector<EventCount::Waiter> waiters(
-      kThreads);  // NOLINT(misc-include-cleaner)
+  MaxSizeVector<EventCount::Waiter> waiters(kThreads);
   waiters.resize(kThreads);
   EventCount ec(waiters);
   TestQueue queues[kQueues];
 
   std::vector<std::unique_ptr<std::thread>> producers;
-  producers.reserve(kThreads);
   for (int i = 0; i < kThreads; i++) {
     producers.emplace_back(new std::thread([&ec, &queues]() {
       unsigned int rnd = static_cast<unsigned int>(std::hash<std::thread::id>()(std::this_thread::get_id()));
@@ -159,7 +154,6 @@
   }
 
   std::vector<std::unique_ptr<std::thread>> consumers;
-  consumers.reserve(kThreads);
   for (int i = 0; i < kThreads; i++) {
     consumers.emplace_back(new std::thread([&ec, &queues, &waiters, i]() {
       EventCount::Waiter& w = waiters[i];
@@ -191,7 +185,7 @@
   }
 }
 
-EIGEN_DECLARE_TEST(cxx11_eventcount) {
+EIGEN_DECLARE_TEST(threads_eventcount) {
   CALL_SUBTEST(test_basic_eventcount());
   CALL_SUBTEST(test_cancel_wait_signal_forwarding());
   CALL_SUBTEST(test_stress_eventcount());
diff --git a/test/threads_fork_join.cpp b/test/threads_fork_join.cpp
index ec75bb7..ee899c9 100644
--- a/test/threads_fork_join.cpp
+++ b/test/threads_fork_join.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_USE_THREADS
 #include "main.h"
diff --git a/test/threads_non_blocking_thread_pool.cpp b/test/threads_non_blocking_thread_pool.cpp
index 862dc4c..ec36704 100644
--- a/test/threads_non_blocking_thread_pool.cpp
+++ b/test/threads_non_blocking_thread_pool.cpp
@@ -7,17 +7,11 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_USE_THREADS
-// clang-format off
 #include "main.h"
 #include "Eigen/ThreadPool"
-// clang-format on
-
-#include <atomic>
-#include <chrono>
-#include <functional>
-#include <thread>
 
 // Spin-wait with yielding until the condition is met, or fail after a timeout.
 // Returns true if the condition was met before the deadline.
@@ -50,10 +44,8 @@
     Task(Task&&) = default;
     Task& operator=(Task&& other) {
       f = std::move(other.f);
-      // Widen the interval between taking a task and retiring the worker's
-      // spinner.
-      if (f && delaying_environment_worker)
-        std::this_thread::sleep_for(std::chrono::microseconds(100));
+      // Widen the interval between taking a task and retiring the worker's spinner.
+      if (f && delaying_environment_worker) std::this_thread::sleep_for(std::chrono::microseconds(100));
       return *this;
     }
   };
@@ -218,7 +210,7 @@
   }
 }
 
-EIGEN_DECLARE_TEST(cxx11_non_blocking_thread_pool) {
+EIGEN_DECLARE_TEST(threads_non_blocking_thread_pool) {
   CALL_SUBTEST(test_parallelism<DelayingThreadEnvironment>(true, 4));
   CALL_SUBTEST(test_create_destroy_empty_pool());
   CALL_SUBTEST(test_parallelism(true));
diff --git a/test/threads_runqueue.cpp b/test/threads_runqueue.cpp
index 4847eae..65c0836 100644
--- a/test/threads_runqueue.cpp
+++ b/test/threads_runqueue.cpp
@@ -7,6 +7,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_USE_THREADS
 #include <cstdlib>
@@ -157,10 +158,10 @@
 void test_stress_runqueue() {
   static const int kEvents = 1 << 18;
   RunQueue<int, 8> q;
-  std::atomic<int> total(0);
+  std::atomic<int64_t> total(0);
   std::vector<std::unique_ptr<std::thread>> threads;
   threads.emplace_back(new std::thread([&q, &total]() {
-    int sum = 0;
+    int64_t sum = 0;
     int pushed = 1;
     int popped = 1;
     while (pushed < kEvents || popped < kEvents) {
@@ -182,7 +183,7 @@
   }));
   for (int i = 0; i < 2; i++) {
     threads.emplace_back(new std::thread([&q, &total]() {
-      int sum = 0;
+      int64_t sum = 0;
       for (int j = 1; j < kEvents; j++) {
         if (q.PushBack(j) == 0) {
           sum += j;
@@ -194,7 +195,7 @@
       total += sum;
     }));
     threads.emplace_back(new std::thread([&q, &total]() {
-      int sum = 0;
+      int64_t sum = 0;
       std::vector<int> stolen;
       for (int j = 1; j < kEvents;) {
         if (q.PopBackHalf(&stolen) == 0) {
@@ -223,7 +224,7 @@
   VERIFY(total.load() == 0);
 }
 
-EIGEN_DECLARE_TEST(cxx11_runqueue) {
+EIGEN_DECLARE_TEST(threads_runqueue) {
   CALL_SUBTEST_1(test_basic_runqueue());
   CALL_SUBTEST_2(test_empty_runqueue());
   CALL_SUBTEST_3(test_stress_runqueue());
diff --git a/test/triangular.cpp b/test/triangular.cpp
index 210228d..ce00fae 100644
--- a/test/triangular.cpp
+++ b/test/triangular.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #if defined(EIGEN_TEST_PART_100) || defined(EIGEN_TEST_PART_ALL)
 #define EIGEN_NO_DEPRECATED_WARNING
@@ -13,6 +14,159 @@
 
 #include "main.h"
 
+template <typename ViewType, typename = void>
+struct has_left_scalar_multiply : std::false_type {};
+
+template <typename ViewType>
+struct has_left_scalar_multiply<
+    ViewType, internal::void_t<decltype(std::declval<typename ViewType::Scalar>() * std::declval<const ViewType&>())>>
+    : std::true_type {};
+
+template <typename ViewType, typename = void>
+struct has_right_scalar_multiply : std::false_type {};
+
+template <typename ViewType>
+struct has_right_scalar_multiply<
+    ViewType, internal::void_t<decltype(std::declval<const ViewType&>() * std::declval<typename ViewType::Scalar>())>>
+    : std::true_type {};
+
+template <typename ViewType, typename = void>
+struct has_structured_sum : std::false_type {};
+
+template <typename ViewType>
+struct has_structured_sum<ViewType,
+                          internal::void_t<decltype(std::declval<const ViewType&>() + std::declval<const ViewType&>())>>
+    : std::true_type {};
+
+template <unsigned int Mode, typename MatrixType>
+void triangular_scalar_multiply(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+
+  const Index rows = m.rows();
+  const Index cols = m.cols();
+
+  const Scalar s = internal::random<Scalar>();
+  const MatrixType triangular = MatrixType::Random(rows, cols);
+
+  VERIFY_IS_APPROX((s * triangular.template triangularView<Mode>()).toDenseMatrix(),
+                   (s * triangular).template triangularView<Mode>().toDenseMatrix());
+  VERIFY_IS_APPROX((triangular.template triangularView<Mode>() * s).toDenseMatrix(),
+                   (triangular * s).template triangularView<Mode>().toDenseMatrix());
+}
+
+template <unsigned int Mode, typename MatrixType, bool IsSelfAdjointMode = Mode == Upper || Mode == Lower>
+struct selfadjoint_structured_sum_impl {
+  typedef typename MatrixType::Scalar Scalar;
+
+  static void run(const Scalar&, const MatrixType&, const MatrixType&, MatrixType&, MatrixType&) {}
+};
+
+template <unsigned int Mode, typename MatrixType>
+struct selfadjoint_structured_sum_impl<Mode, MatrixType, true> {
+  typedef typename MatrixType::Scalar Scalar;
+
+  static void run(const Scalar& s, const MatrixType& a, const MatrixType& b, MatrixType& result,
+                  MatrixType& reference) {
+    if (a.rows() != a.cols()) return;
+
+    result.setRandom();
+    result.template selfadjointView<Mode>() =
+        s * a.template selfadjointView<Mode>() + b.template selfadjointView<Mode>();
+    reference = (s * a + b).template selfadjointView<Mode>().toDenseMatrix();
+    VERIFY_IS_APPROX(result, reference);
+
+    result.setRandom();
+    result.template selfadjointView<Mode>() =
+        a.template selfadjointView<Mode>() - s * b.template selfadjointView<Mode>();
+    reference = (a - s * b).template selfadjointView<Mode>().toDenseMatrix();
+    VERIFY_IS_APPROX(result, reference);
+  }
+};
+
+template <unsigned int Mode, typename MatrixType>
+void triangular_structured_sum(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+
+  const Index rows = m.rows();
+  const Index cols = m.cols();
+
+  const Scalar s = internal::random<Scalar>();
+  const MatrixType a = MatrixType::Random(rows, cols);
+  const MatrixType b = MatrixType::Random(rows, cols);
+
+  MatrixType result = MatrixType::Random(rows, cols);
+  MatrixType reference = result;
+
+  result.template triangularView<Mode>() = s * a.template triangularView<Mode>() + b.template triangularView<Mode>();
+  reference.template triangularView<Mode>() = s * a + b;
+  VERIFY_IS_APPROX(result, reference);
+
+  result.setRandom();
+  reference = result;
+  result.template triangularView<Mode>() = a.template triangularView<Mode>() - s * b.template triangularView<Mode>();
+  reference.template triangularView<Mode>() = a - s * b;
+  VERIFY_IS_APPROX(result, reference);
+
+  selfadjoint_structured_sum_impl<Mode, MatrixType>::run(s, a, b, result, reference);
+}
+
+template <typename MatrixType>
+void triangular_setters(const MatrixType& m) {
+  const Index rows = m.rows();
+  const Index cols = m.cols();
+
+  MatrixType result = MatrixType::Random(rows, cols);
+  MatrixType reference = result;
+
+  result.template triangularView<Upper>().setIdentity();
+  reference.template triangularView<Upper>() = MatrixType::Identity(rows, cols);
+  VERIFY_IS_APPROX(result, reference);
+
+  result.setRandom();
+  reference = result;
+  result.template triangularView<Lower>().setIdentity();
+  reference.template triangularView<Lower>() = MatrixType::Identity(rows, cols);
+  VERIFY_IS_APPROX(result, reference);
+
+  result.setRandom();
+  reference = result;
+  result.template triangularView<Upper>().setRandom();
+  VERIFY_IS_APPROX(result.template triangularView<StrictlyLower>().toDenseMatrix(),
+                   reference.template triangularView<StrictlyLower>().toDenseMatrix());
+
+  result.setRandom();
+  reference = result;
+  result.template triangularView<StrictlyLower>().setRandom();
+  VERIFY_IS_APPROX(result.template triangularView<Upper>().toDenseMatrix(),
+                   reference.template triangularView<Upper>().toDenseMatrix());
+}
+
+template <typename MatrixType>
+void triangular_scalar_multiply_sfinae() {
+  typedef decltype(std::declval<MatrixType&>().template triangularView<Upper>()) UpperView;
+  typedef decltype(std::declval<MatrixType&>().template triangularView<Lower>()) LowerView;
+  typedef decltype(std::declval<MatrixType&>().template triangularView<StrictlyLower>()) StrictlyLowerView;
+  typedef decltype(std::declval<MatrixType&>().template triangularView<StrictlyUpper>()) StrictlyUpperView;
+  typedef decltype(std::declval<MatrixType&>().template triangularView<UnitLower>()) UnitLowerView;
+
+  STATIC_CHECK((has_left_scalar_multiply<UpperView>::value));
+  STATIC_CHECK((has_right_scalar_multiply<UpperView>::value));
+  STATIC_CHECK((has_left_scalar_multiply<LowerView>::value));
+  STATIC_CHECK((has_right_scalar_multiply<LowerView>::value));
+  STATIC_CHECK((has_left_scalar_multiply<StrictlyLowerView>::value));
+  STATIC_CHECK((has_right_scalar_multiply<StrictlyLowerView>::value));
+  STATIC_CHECK((has_left_scalar_multiply<StrictlyUpperView>::value));
+  STATIC_CHECK((has_right_scalar_multiply<StrictlyUpperView>::value));
+  STATIC_CHECK((!has_left_scalar_multiply<UnitLowerView>::value));
+  STATIC_CHECK((!has_right_scalar_multiply<UnitLowerView>::value));
+
+  STATIC_CHECK((has_structured_sum<UpperView>::value));
+  STATIC_CHECK((has_structured_sum<LowerView>::value));
+  STATIC_CHECK((has_structured_sum<StrictlyLowerView>::value));
+  STATIC_CHECK((has_structured_sum<StrictlyUpperView>::value));
+  STATIC_CHECK((!has_structured_sum<UnitLowerView>::value));
+}
+
 template <typename MatrixType>
 void triangular_deprecated(const MatrixType& m) {
   Index rows = m.rows();
@@ -42,6 +196,13 @@
   typedef typename NumTraits<Scalar>::Real RealScalar;
   typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
 
+  triangular_scalar_multiply_sfinae<MatrixType>();
+  triangular_structured_sum<Upper>(m);
+  triangular_structured_sum<Lower>(m);
+  triangular_structured_sum<StrictlyUpper>(m);
+  triangular_structured_sum<StrictlyLower>(m);
+  triangular_setters(m);
+
   RealScalar largerEps = 10 * test_precision<RealScalar>();
 
   Index rows = m.rows();
@@ -151,6 +312,10 @@
   m6.setRandom();
   VERIFY_IS_APPROX(m1.template triangularView<Upper>() * m5, m3 * m5);
   VERIFY_IS_APPROX(m6 * m1.template triangularView<Upper>(), m6 * m3);
+  triangular_scalar_multiply<Upper>(m1);
+  triangular_scalar_multiply<Lower>(m1);
+  triangular_scalar_multiply<StrictlyUpper>(m1);
+  triangular_scalar_multiply<StrictlyLower>(m1);
 
   m1up = m1.template triangularView<Upper>();
   VERIFY_IS_APPROX(m1.template selfadjointView<Upper>().template triangularView<Upper>().toDenseMatrix(), m1up);
@@ -228,6 +393,15 @@
   m1.setZero();
   m1.template triangularView<StrictlyLower>() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView<StrictlyLower>().toDenseMatrix(), m1);
+  triangular_scalar_multiply<Upper>(m1);
+  triangular_scalar_multiply<Lower>(m1);
+  triangular_scalar_multiply<StrictlyUpper>(m1);
+  triangular_scalar_multiply<StrictlyLower>(m1);
+  triangular_structured_sum<Upper>(m1);
+  triangular_structured_sum<Lower>(m1);
+  triangular_structured_sum<StrictlyUpper>(m1);
+  triangular_structured_sum<StrictlyLower>(m1);
+  triangular_setters(m1);
   m1.setRandom();
   m2 = m1.template triangularView<Upper>();
   VERIFY(m2.isUpperTriangular());
@@ -258,6 +432,44 @@
   VERIFY_IS_APPROX(m2, m3);
 }
 
+// isLowerTriangular() and isUpperTriangular() must inspect every off-diagonal coefficient. In a wide matrix the
+// columns past the diagonal block are strictly upper down to their last row, which an off-by-one row bound in
+// isLowerTriangular() used to skip.
+template <typename MatrixType>
+void triangular_predicates(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+
+  const Index rows = m.rows();
+  const Index cols = m.cols();
+
+  const MatrixType m1 = MatrixType::Random(rows, cols);
+  const MatrixType lower = m1.template triangularView<Lower>();
+  const MatrixType upper = m1.template triangularView<Upper>();
+  VERIFY(lower.isLowerTriangular());
+  VERIFY(upper.isUpperTriangular());
+
+  MatrixType diag = MatrixType::Zero(rows, cols);
+  diag.diagonal().setConstant(Scalar(1));
+  VERIFY(diag.isLowerTriangular());
+  VERIFY(diag.isUpperTriangular());
+
+  // A single large coefficient off the diagonal must be caught by exactly one of the two predicates, wherever it sits.
+  const Scalar offending = Scalar(100);
+  for (Index j = 0; j < cols; ++j)
+    for (Index i = 0; i < rows; ++i) {
+      if (i == j) continue;
+      MatrixType m2 = diag;
+      m2(i, j) = offending;
+      if (i < j) {
+        VERIFY(!m2.isLowerTriangular());
+        VERIFY(m2.isUpperTriangular());
+      } else {
+        VERIFY(!m2.isUpperTriangular());
+        VERIFY(m2.isLowerTriangular());
+      }
+    }
+}
+
 // Test triangular solve and product at sizes that exercise GEBP blocking.
 // The standard test caps at maxsize=20, which never triggers the blocked code paths
 // in TriangularSolverMatrix.h (requires size >= 48 with EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS).
@@ -325,16 +537,16 @@
 
 void bug_159() {
   Matrix3d m = Matrix3d::Random().triangularView<Lower>();
-  EIGEN_UNUSED_VARIABLE(m)
+  EIGEN_UNUSED_VARIABLE(m);
 }
 
 EIGEN_DECLARE_TEST(triangular) {
   int maxsize = (std::min)(EIGEN_TEST_MAX_SIZE, 20);
   for (int i = 0; i < g_repeat; i++) {
     int r = internal::random<int>(2, maxsize);
-    TEST_SET_BUT_UNUSED_VARIABLE(r)
+    TEST_SET_BUT_UNUSED_VARIABLE(r);
     int c = internal::random<int>(2, maxsize);
-    TEST_SET_BUT_UNUSED_VARIABLE(c)
+    TEST_SET_BUT_UNUSED_VARIABLE(c);
 
     CALL_SUBTEST_1(triangular_square(Matrix<float, 1, 1>()));
     CALL_SUBTEST_2(triangular_square(Matrix<float, 2, 2>()));
@@ -351,6 +563,21 @@
 
     CALL_SUBTEST_100(triangular_deprecated(Matrix<float, 5, 7>()));
     CALL_SUBTEST_100(triangular_deprecated(MatrixXd(r, c)));
+
+    // isLowerTriangular()/isUpperTriangular() on wide, tall and square shapes, including the 1xN and Nx1 edges.
+    CALL_SUBTEST_12(triangular_predicates(MatrixXd(2, 3)));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXd(3, 2)));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXd(3, 3)));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXd(1, 4)));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXd(4, 1)));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXd(1, 1)));
+    CALL_SUBTEST_12(triangular_predicates(Matrix<float, 2, 5>()));
+    CALL_SUBTEST_12(triangular_predicates(Matrix<double, 5, 2>()));
+    CALL_SUBTEST_12(triangular_predicates(Matrix<std::complex<float>, 3, 7>()));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXcd(r, c)));
+    CALL_SUBTEST_12(triangular_predicates(MatrixXcd(c, r)));
+    CALL_SUBTEST_12(triangular_predicates(Matrix<float, Dynamic, Dynamic, RowMajor>(2, 5)));
+    CALL_SUBTEST_12(triangular_predicates(Matrix<float, Dynamic, Dynamic, RowMajor>(r, c)));
   }
 
   CALL_SUBTEST_1(bug_159());
diff --git a/test/triangular_in_place.cpp b/test/triangular_in_place.cpp
new file mode 100644
index 0000000..e1e510b
--- /dev/null
+++ b/test/triangular_in_place.cpp
@@ -0,0 +1,192 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+
+// Substitution is backward stable: the computed inverse X of a triangular T satisfies
+// |T X - I| <= c*n*eps*|T|*|X| entrywise, for a small constant c (Higham, Accuracy and Stability of
+// Numerical Algorithms, 2nd ed., Thm 8.5). The factors below absorb c and the entrywise-to-norm step;
+// the largest ratio measured over the families tested here is 2, at n = 1.
+static constexpr int kResidualFactor = 16;
+// Forward error against the reference solve, bounded by the residual bound times cond(T) <= |T|*|X|.
+static constexpr int kForwardFactor = 16;
+
+// The part of the storage that a triangularView<mode>() does not own, and that an in-place kernel must
+// therefore leave bit for bit unchanged: the opposite triangle, plus the diagonal under UnitDiag.
+constexpr unsigned int untouched_mode(unsigned int mode) {
+  return ((mode & Lower) != 0 ? unsigned(Upper) : unsigned(Lower)) | ((mode & UnitDiag) != 0 ? 0u : unsigned(ZeroDiag));
+}
+
+template <unsigned int Mode, typename MatrixType, typename OperandType>
+void check_triangular_inverse(const MatrixType& t, OperandType& x, bool well_conditioned) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using DenseType = Matrix<Scalar, Dynamic, Dynamic>;
+
+  const Index n = t.rows();
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+
+  x = t;
+  x.template triangularView<Mode>().inverseInPlace();
+
+  constexpr unsigned int kUntouched = untouched_mode(Mode);
+  VERIFY_IS_CWISE_EQUAL(x.template triangularView<kUntouched>().toDenseMatrix(),
+                        t.template triangularView<kUntouched>().toDenseMatrix());
+
+  const DenseType td = t.template triangularView<Mode>().toDenseMatrix();
+  const DenseType xd = x.template triangularView<Mode>().toDenseMatrix();
+  const RealScalar residual = (td * xd - DenseType::Identity(n, n)).norm();
+  const RealScalar residual_bound = RealScalar(kResidualFactor * n) * eps * td.norm() * xd.norm();
+  VERIFY((numext::isfinite)(residual_bound));
+  VERIFY(residual <= residual_bound);
+
+  if (!well_conditioned) return;
+  MatrixType reference = MatrixType::Identity(n, n);
+  t.template triangularView<Mode>().solveInPlace(reference);
+  const DenseType referenced = reference.template triangularView<Mode>().toDenseMatrix();
+  const RealScalar forward_bound = RealScalar(kForwardFactor * n) * eps * td.norm() * xd.norm() * xd.norm();
+  VERIFY((numext::isfinite)(forward_bound));
+  VERIFY((xd - referenced).norm() <= forward_bound);
+}
+
+// Strictly diagonally dominant, so cond(T) stays O(1) and the forward comparison is meaningful. The
+// scaling also holds with a unit diagonal, where the stored diagonal is ignored.
+template <typename MatrixType>
+MatrixType well_conditioned_triangular(Index n) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  MatrixType t = MatrixType::Random(n, n) / RealScalar(n + 1);
+  t.diagonal().array() += Scalar(1);
+  return t;
+}
+
+// Unscaled off-diagonals, so |T^-1| can grow exponentially in n; only the residual bound applies.
+template <typename MatrixType>
+MatrixType ill_conditioned_triangular(Index n) {
+  using Scalar = typename MatrixType::Scalar;
+  MatrixType t = MatrixType::Random(n, n);
+  t.diagonal().array() += Scalar(2);
+  return t;
+}
+
+template <typename MatrixType, typename OperandType>
+void check_inverse_all_modes(const MatrixType& t, OperandType& x, bool well_conditioned) {
+  check_triangular_inverse<Lower>(t, x, well_conditioned);
+  check_triangular_inverse<Upper>(t, x, well_conditioned);
+  check_triangular_inverse<UnitLower>(t, x, well_conditioned);
+  check_triangular_inverse<UnitUpper>(t, x, well_conditioned);
+}
+
+template <typename MatrixType>
+void triangular_inverse_all_modes(Index n) {
+  MatrixType x(n, n);
+  check_inverse_all_modes(well_conditioned_triangular<MatrixType>(n), x, /*well_conditioned=*/true);
+  check_inverse_all_modes(ill_conditioned_triangular<MatrixType>(n), x, /*well_conditioned=*/false);
+}
+
+// The destination of LLT::inverse() need not be a plain object, so run the kernel through a block of a
+// larger matrix: a non-zero offset and an outer stride that does not match the block width.
+template <typename MatrixType>
+void triangular_inverse_on_block(Index n) {
+  const Index row_offset = 2, col_offset = 3;
+  MatrixType host = MatrixType::Random(n + 3, n + 5);
+  MatrixType expected = host;
+  Block<MatrixType> x(host, row_offset, col_offset, n, n);
+
+  check_triangular_inverse<Lower>(well_conditioned_triangular<MatrixType>(n), x, /*well_conditioned=*/true);
+
+  // Nothing outside the block moved.
+  expected.block(row_offset, col_offset, n, n) = x;
+  VERIFY_IS_CWISE_EQUAL(host, expected);
+}
+
+// An operand whose inner stride is a run-time value, which is what a Map or Ref with a dynamic inner
+// stride hands the blocked kernels: their TRSM and TRMM steps must reach each panel through that
+// value, since the compile-time InnerStrideAtCompileTime they also carry is Dynamic.
+template <typename MatrixType>
+void triangular_inverse_on_strided_map(Index n) {
+  using Scalar = typename MatrixType::Scalar;
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  using StrideType = Stride<Dynamic, Dynamic>;
+  const Index inner = 2, outer = 2 * n + 3;
+  const Index buffer_size = numext::maxi(Index(1), (n - 1) * (outer + inner) + 1);
+  VectorType buffer = VectorType::Random(buffer_size);
+  const VectorType before = buffer;
+  Map<MatrixType, 0, StrideType> x(buffer.data(), n, n, StrideType(outer, inner));
+
+  check_triangular_inverse<Lower>(well_conditioned_triangular<MatrixType>(n), x, /*well_conditioned=*/true);
+  check_triangular_inverse<Upper>(well_conditioned_triangular<MatrixType>(n), x, /*well_conditioned=*/true);
+
+  // Nothing in the gaps between the mapped coefficients moved.
+  std::vector<bool> mapped(buffer_size, false);
+  for (Index j = 0; j < n; ++j)
+    for (Index i = 0; i < n; ++i) mapped[static_cast<std::size_t>(&x.coeffRef(i, j) - buffer.data())] = true;
+  for (Index k = 0; k < buffer_size; ++k)
+    if (!mapped[k]) VERIFY_IS_EQUAL(buffer[k], before[k]);
+}
+
+// internal::triangular_adjoint_square_in_place() is what LLT::inverse() uses to turn L^-1 into
+// L^-* L^-1. It is not public API, but it needs coverage of its own: a Cholesky factor always has a
+// real diagonal, so the conjugations in the kernel are unobservable through LLT.
+template <int UpLo, typename MatrixType>
+void adjoint_square_in_place(Index n) {
+  using Scalar = typename MatrixType::Scalar;
+  using RealScalar = typename NumTraits<Scalar>::Real;
+  using DenseType = Matrix<Scalar, Dynamic, Dynamic>;
+
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  const MatrixType t = ill_conditioned_triangular<MatrixType>(n);
+  MatrixType a = t;
+  internal::triangular_adjoint_square_in_place<UpLo>(a);
+  VERIFY((a.diagonal().imag().array() == RealScalar(0)).all());
+
+  const DenseType td = t.template triangularView<UpLo>().toDenseMatrix();
+  const DenseType expected = UpLo == Lower ? DenseType(td.adjoint() * td) : DenseType(td * td.adjoint());
+  const DenseType computed = a.template triangularView<UpLo>().toDenseMatrix();
+  // n accumulations of products of entries of T, so the rounding error is bounded by ~n*eps*|T|^2.
+  const RealScalar bound = RealScalar(kResidualFactor * n) * eps * td.norm() * td.norm();
+  VERIFY((numext::isfinite)(bound));
+  VERIFY((computed - expected.template triangularView<UpLo>().toDenseMatrix()).norm() <= bound);
+
+  constexpr unsigned int kUntouched = untouched_mode(UpLo);
+  VERIFY_IS_CWISE_EQUAL(a.template triangularView<kUntouched>().toDenseMatrix(),
+                        t.template triangularView<kUntouched>().toDenseMatrix());
+}
+
+template <typename MatrixType>
+void adjoint_square_both_triangles(Index n) {
+  adjoint_square_in_place<Lower, MatrixType>(n);
+  adjoint_square_in_place<Upper, MatrixType>(n);
+}
+
+EIGEN_DECLARE_TEST(triangular_in_place) {
+  // 31/32 straddles the unblocked-to-blocked switch, 40 and 65 are not multiples of the block size,
+  // and at 256 the heuristic first picks a block big enough for the nested kernels to block in turn.
+  const Index sizes[] = {0, 1, 2, 3, 7, 16, 31, 32, 33, 40, 64, 65, 128, 256};
+  for (int i = 0; i < g_repeat; i++) {
+    for (Index n : sizes) {
+      EIGEN_UNUSED_VARIABLE(n);  // the part-6 build compiles no subtest that takes n
+      CALL_SUBTEST_1(triangular_inverse_all_modes<MatrixXd>(n));
+      CALL_SUBTEST_2(triangular_inverse_all_modes<MatrixXcd>(n));
+      CALL_SUBTEST_3(triangular_inverse_all_modes<MatrixXf>(n));
+      CALL_SUBTEST_4((triangular_inverse_all_modes<Matrix<double, Dynamic, Dynamic, RowMajor>>(n)));
+      CALL_SUBTEST_5(triangular_inverse_on_block<MatrixXd>(n));
+      CALL_SUBTEST_5(triangular_inverse_on_strided_map<MatrixXd>(n));
+      CALL_SUBTEST_7(adjoint_square_both_triangles<MatrixXd>(n));
+      CALL_SUBTEST_8(adjoint_square_both_triangles<MatrixXcd>(n));
+      CALL_SUBTEST_8((adjoint_square_both_triangles<Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>>(n)));
+      CALL_SUBTEST_9(adjoint_square_both_triangles<MatrixXf>(n));
+      CALL_SUBTEST_10((adjoint_square_both_triangles<Matrix<double, Dynamic, Dynamic, RowMajor>>(n)));
+    }
+    CALL_SUBTEST_6((triangular_inverse_all_modes<Matrix<double, 1, 1>>(1)));
+    CALL_SUBTEST_6(triangular_inverse_all_modes<Matrix4d>(4));
+    CALL_SUBTEST_6((triangular_inverse_all_modes<Matrix<std::complex<float>, 8, 8>>(8)));
+  }
+}
diff --git a/test/tridiag_test_matrices.h b/test/tridiag_test_matrices.h
new file mode 100644
index 0000000..d95d6c2
--- /dev/null
+++ b/test/tridiag_test_matrices.h
@@ -0,0 +1,482 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2025 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_TRIDIAG_TEST_MATRICES_H
+#define EIGEN_TEST_TRIDIAG_TEST_MATRICES_H
+
+// Structured tridiagonal test matrices from the numerical linear algebra
+// literature. Used by both the bidiagonal SVD and symmetric eigenvalue tests.
+//
+// Each generator writes into pre-allocated (diag, offdiag) vectors.
+// For SVD, offdiag is the superdiagonal of a bidiagonal matrix.
+// For eigenvalues, offdiag is the subdiagonal of a symmetric tridiagonal matrix.
+//
+// Usage:
+//   Matrix<RealScalar, Dynamic, 1> diag(n), offdiag(n-1);
+//   tridiag_identity(diag, offdiag);           // fills diag and offdiag
+//   my_verify(diag, offdiag);                  // solver-specific verification
+
+#include <Eigen/Core>
+
+namespace Eigen {
+namespace test {
+
+// 1. Identity: d=[1,...,1], e=[0,...,0]
+template <typename VectorType>
+void tridiag_identity(VectorType& diag, VectorType& offdiag) {
+  diag.setOnes();
+  offdiag.setZero();
+}
+
+// 2. Zero: d=[0,...,0], e=[0,...,0]
+template <typename VectorType>
+void tridiag_zero(VectorType& diag, VectorType& offdiag) {
+  diag.setZero();
+  offdiag.setZero();
+}
+
+// 3. Constant: d=[c,...,c], e=[c,...,c]
+template <typename VectorType>
+void tridiag_constant(VectorType& diag, VectorType& offdiag,
+                      typename VectorType::Scalar c = typename VectorType::Scalar(2.5)) {
+  diag.setConstant(c);
+  offdiag.setConstant(c);
+}
+
+// 4. 1-2-1 Toeplitz: d=[2,...,2], e=[1,...,1]
+// Eigenvalues: 2 - 2*cos(k*pi/(n+1)) for k=1,...,n
+template <typename VectorType>
+void tridiag_1_2_1(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  diag.setConstant(Scalar(2));
+  offdiag.setOnes();
+}
+
+// 5. Wilkinson W_{2m+1}: d_i = |m - i|, e=[1,...,1]
+// Has pairs of eigenvalues agreeing to many digits; stresses deflation.
+template <typename VectorType>
+void tridiag_wilkinson(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = numext::abs(Scalar(n / 2) - Scalar(i));
+  offdiag.setOnes();
+}
+
+// 6. Clement matrix: d=[0,...,0], e_i = sqrt(i*(n-1-i))
+// Known eigenvalues: -(n-1), -(n-3), ..., (n-3), (n-1)
+template <typename VectorType>
+void tridiag_clement(VectorType& diag, VectorType& offdiag) {
+  EIGEN_USING_STD(sqrt);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  diag.setZero();
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = sqrt(Scalar(i + 1) * Scalar(n - 1 - i));
+}
+
+// 7. Kahan-style: d_i = s^i, e_i = -c*s^i with s=sin(theta), c=cos(theta).
+// Geometric decay with controlled condition number.
+template <typename VectorType>
+void tridiag_kahan(VectorType& diag, VectorType& offdiag,
+                   typename VectorType::Scalar theta = typename VectorType::Scalar(0.3)) {
+  EIGEN_USING_STD(sin);
+  EIGEN_USING_STD(cos);
+  EIGEN_USING_STD(pow);
+  EIGEN_USING_STD(log);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  const Scalar s = sin(theta);
+  const Scalar c = cos(theta);
+  const Scalar maxPower = -log(eps) / (-log(s));
+  for (Index i = 0; i < n; ++i) diag(i) = pow(s, numext::mini(Scalar(i), maxPower));
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = -c * pow(s, numext::mini(Scalar(i), maxPower));
+}
+
+// 8. Graded: d_i = base^(-i), e_i = base^(-i)
+template <typename VectorType>
+void tridiag_graded(VectorType& diag, VectorType& offdiag,
+                    typename VectorType::Scalar base = typename VectorType::Scalar(10)) {
+  EIGEN_USING_STD(pow);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = pow(base, -Scalar(i));
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = pow(base, -Scalar(i));
+}
+
+// 9. Geometric decay diagonal: d_i = base^i, e=[0,...,0]
+template <typename VectorType>
+void tridiag_geometric_diagonal(VectorType& diag, VectorType& offdiag,
+                                typename VectorType::Scalar base = typename VectorType::Scalar(0.5)) {
+  EIGEN_USING_STD(pow);
+  EIGEN_USING_STD(log);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  const Scalar maxPower = -log(eps) / (-log(base));
+  for (Index i = 0; i < n; ++i) diag(i) = pow(base, numext::mini(Scalar(i), maxPower));
+  offdiag.setZero();
+}
+
+// 10. Geometric decay offdiagonal: d=[1,...,1], e_i = base^i
+template <typename VectorType>
+void tridiag_geometric_offdiag(VectorType& diag, VectorType& offdiag,
+                               typename VectorType::Scalar base = typename VectorType::Scalar(0.5)) {
+  EIGEN_USING_STD(pow);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  diag.setOnes();
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = pow(base, Scalar(i));
+}
+
+// 11. Clustered eigenvalues: d_i = 1 + i*eps, e=[0,...,0]
+template <typename VectorType>
+void tridiag_clustered(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  for (Index i = 0; i < n; ++i) diag(i) = Scalar(1) + Scalar(i) * eps;
+  offdiag.setZero();
+}
+
+// 12. Two clusters: half at 1, half at eps.
+template <typename VectorType>
+void tridiag_two_clusters(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  for (Index i = 0; i < n; ++i) diag(i) = (i < n / 2) ? Scalar(1) : eps;
+  offdiag.setZero();
+}
+
+// 13. Single tiny value: d=[1,...,1,eps], e=[eps^2,...,eps^2]
+template <typename VectorType>
+void tridiag_single_tiny(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  diag.setOnes();
+  diag(n - 1) = eps;
+  offdiag.setConstant(eps * eps);
+}
+
+// 14. Overflow/underflow: alternating big/tiny diagonal and offdiagonal.
+template <typename VectorType>
+void tridiag_overflow_underflow(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar big = (std::numeric_limits<Scalar>::max)() / Scalar(1000);
+  const Scalar tiny = (std::numeric_limits<Scalar>::min)() * Scalar(1000);
+  for (Index i = 0; i < n; ++i) diag(i) = (i % 2 == 0) ? big : tiny;
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = (i % 2 == 0) ? tiny : big;
+}
+
+// 15. Prescribed condition number: d_i = kappa^(-i/(n-1)), e_i = eps * random.
+template <typename VectorType>
+void tridiag_prescribed_cond(VectorType& diag, VectorType& offdiag) {
+  EIGEN_USING_STD(pow);
+  EIGEN_USING_STD(abs);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  const Scalar kappa = Scalar(1) / eps;
+  for (Index i = 0; i < n; ++i) diag(i) = pow(kappa, -Scalar(i) / Scalar(n - 1));
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = eps * abs(internal::random<Scalar>());
+}
+
+// 16. Rank-deficient: d=[1,..,0,..,0,..,1], e=[0,...,0]
+template <typename VectorType>
+void tridiag_rank_deficient(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = (i < n / 3 || i >= 2 * n / 3) ? Scalar(1) : Scalar(0);
+  offdiag.setZero();
+}
+
+// 17. Arrowhead-like: d_i = linspace(1,n), e_i = 1/(i+1)
+template <typename VectorType>
+void tridiag_arrowhead(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = Scalar(1) + Scalar(i);
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = Scalar(1) / Scalar(i + 1);
+}
+
+// 18. Repeated values: d=[1,2,3,1,2,3,...], e=[0,...,0]
+template <typename VectorType>
+void tridiag_repeated(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = Scalar((i % 3) + 1);
+  offdiag.setZero();
+}
+
+// 19. Glued blocks: d=[1,...,1], e=0 except e[n/2-1]=eps.
+// Two identity blocks coupled by a tiny off-diagonal entry.
+template <typename VectorType>
+void tridiag_glued(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  diag.setOnes();
+  offdiag.setZero();
+  if (n > 2) offdiag(n / 2 - 1) = NumTraits<Scalar>::epsilon();
+}
+
+// 20. Nearly diagonal: random diag, eps * random offdiag.
+template <typename VectorType>
+void tridiag_nearly_diagonal(VectorType& diag, VectorType& offdiag) {
+  EIGEN_USING_STD(abs);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  const Scalar eps = NumTraits<Scalar>::epsilon();
+  diag = VectorType::Random(n).cwiseAbs() + VectorType::Constant(n, Scalar(0.1));
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = eps * (Scalar(0.5) + abs(internal::random<Scalar>()));
+}
+
+// 21. Negative eigenvalues: d_i = -i, e=[1,...,1]
+// (Only meaningful for symmetric eigenvalue problems, not SVD.)
+template <typename VectorType>
+void tridiag_negative(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = -Scalar(i + 1);
+  offdiag.setOnes();
+}
+
+// 22. Mixed sign diagonal: d_i = (-1)^i * (i+1), e=[1,...,1]
+// (Only meaningful for symmetric eigenvalue problems, not SVD.)
+template <typename VectorType>
+void tridiag_mixed_sign(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = ((i % 2 == 0) ? Scalar(1) : Scalar(-1)) * Scalar(i + 1);
+  offdiag.setOnes();
+}
+
+// 23. General symmetric tridiagonal Toeplitz [a, b, a]: d=b, e=a.
+// Eigenvalues: b + 2*a*cos(k*pi/(n+1)), k=1..n (closed form). The default (a=1, b=0)
+// gives a spectrum straddling zero, complementing the positive-definite 1-2-1 case (#4).
+template <typename VectorType>
+void tridiag_toeplitz(VectorType& diag, VectorType& offdiag,
+                      typename VectorType::Scalar a = typename VectorType::Scalar(1),
+                      typename VectorType::Scalar b = typename VectorType::Scalar(0)) {
+  diag.setConstant(b);
+  offdiag.setConstant(a);
+}
+
+// 24. Signed Wilkinson W-_{2m+1}: d_i = (n-1)/2 - i (signed, not |.|), e=1.
+// The anti-symmetric diagonal plus constant off-diagonal makes T orthogonally similar
+// to -T, so the spectrum is exactly symmetric about 0 (an algebraic invariant that
+// needs no reference solver). Eigenvalues are well-separated, complementing the
+// close-pair W+ matrix (#5).  (Wilkinson, The Algebraic Eigenvalue Problem, 1965.)
+template <typename VectorType>
+void tridiag_wilkinson_signed(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = Scalar(n - 1) / Scalar(2) - Scalar(i);
+  offdiag.setOnes();
+}
+
+// 25. Glued Wilkinson: copies of W+_{blk} (blk odd) laid end-to-end, with the
+// inter-block off-diagonal set to a small "glue" value. The large eigenvalues of each
+// W+ block are nearly identical across copies, producing clusters of eigenvalues equal
+// to working precision -- the canonical stress test for cluster counting/resolution.
+// (Dhillon, Parlett & Vomel, "Glued Matrices and the MRRR Algorithm", SISC 2005;
+// Marques, Demmel, Parlett & Vomel, ACM TOMS Algorithm 880, 2008.)
+template <typename VectorType>
+void tridiag_glued_wilkinson(VectorType& diag, VectorType& offdiag, Index blk = 15,
+                             typename VectorType::Scalar glue = typename VectorType::Scalar(1e-3)) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  if (blk < 1) blk = 1;
+  const Index m = (blk - 1) / 2;
+  for (Index i = 0; i < n; ++i) {
+    const Index j = i % blk;  // position within the current block
+    diag(i) = numext::abs(Scalar(m) - Scalar(j));
+  }
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = ((i + 1) % blk == 0) ? glue : Scalar(1);
+}
+
+// 26. Laguerre Jacobi matrix (alpha=0): d_i = 2i+1, e_i = i+1. Eigenvalues are the
+// Gauss-Laguerre nodes: all positive, spanning a wide range (~1/n to ~4n), which
+// exercises definiteness/range handling. (Golub & Welsch, 1969.)
+template <typename VectorType>
+void tridiag_laguerre(VectorType& diag, VectorType& offdiag) {
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  for (Index i = 0; i < n; ++i) diag(i) = Scalar(2 * i + 1);
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = Scalar(i + 1);
+}
+
+// 27. Hermite Jacobi matrix: d=0, e_i = sqrt((i+1)/2). Eigenvalues are the
+// Gauss-Hermite nodes, exactly symmetric about 0. (Golub & Welsch, 1969.)
+template <typename VectorType>
+void tridiag_hermite(VectorType& diag, VectorType& offdiag) {
+  EIGEN_USING_STD(sqrt);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  diag.setZero();
+  for (Index i = 0; i < n - 1; ++i) offdiag(i) = sqrt(Scalar(i + 1) / Scalar(2));
+}
+
+// 28. Legendre Jacobi matrix: d=0, e_i = (i+1)/sqrt((2i+1)(2i+3)). Eigenvalues are the
+// Gauss-Legendre nodes in (-1, 1), exactly symmetric about 0. (Golub & Welsch, 1969.)
+template <typename VectorType>
+void tridiag_legendre(VectorType& diag, VectorType& offdiag) {
+  EIGEN_USING_STD(sqrt);
+  typedef typename VectorType::Scalar Scalar;
+  Index n = diag.size();
+  diag.setZero();
+  for (Index i = 0; i < n - 1; ++i) {
+    const Scalar k = Scalar(i + 1);
+    offdiag(i) = k / sqrt((Scalar(2) * k - Scalar(1)) * (Scalar(2) * k + Scalar(1)));
+  }
+}
+
+// Helper: iterate over a set of sizes and call a functor with each (diag, offdiag) pair
+// generated by a generator function.
+//
+// Usage:
+//   for_tridiag_sizes([](auto& diag, auto& offdiag) {
+//       tridiag_wilkinson(diag, offdiag);
+//       my_verify(diag, offdiag);
+//   });
+template <typename Scalar, typename Func>
+void for_tridiag_sizes(Func&& func) {
+  const int sizes[] = {1, 2, 3, 5, 10, 16, 20, 50, 100};
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+  for (int si = 0; si < int(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    const Index n = sizes[si];
+    VectorType diag(n), offdiag(n > 1 ? n - 1 : 0);
+    func(diag, offdiag);
+  }
+}
+
+// Helper: run all generators (suitable for both SVD and eigenvalue problems).
+// The callback receives (diag, offdiag) after each generator fills them.
+template <typename Scalar, typename Func>
+void for_all_tridiag_test_matrices(Func&& verify) {
+  const int sizes[] = {1, 2, 3, 5, 10, 16, 20, 50, 100};
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+
+  for (int si = 0; si < int(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    const Index n = sizes[si];
+    VectorType diag(n), offdiag(n > 1 ? n - 1 : 0);
+
+    tridiag_identity(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_zero(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_constant(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_1_2_1(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_wilkinson(diag, offdiag);
+    verify(diag, offdiag);
+
+    if (n > 1) {
+      tridiag_clement(diag, offdiag);
+      verify(diag, offdiag);
+    }
+
+    tridiag_kahan(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_graded(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_geometric_diagonal(diag, offdiag);
+    verify(diag, offdiag);
+
+    if (n > 1) {
+      tridiag_geometric_offdiag(diag, offdiag);
+      verify(diag, offdiag);
+    }
+
+    tridiag_clustered(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_two_clusters(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_single_tiny(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_overflow_underflow(diag, offdiag);
+    verify(diag, offdiag);
+
+    if (n > 1) {
+      tridiag_prescribed_cond(diag, offdiag);
+      verify(diag, offdiag);
+    }
+
+    tridiag_rank_deficient(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_arrowhead(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_repeated(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_glued(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_nearly_diagonal(diag, offdiag);
+    verify(diag, offdiag);
+  }
+}
+
+// Helper: run all generators, including those with negative values
+// (suitable only for symmetric eigenvalue problems, not SVD).
+template <typename Scalar, typename Func>
+void for_all_symmetric_tridiag_test_matrices(Func&& verify) {
+  for_all_tridiag_test_matrices<Scalar>(verify);
+
+  const int sizes[] = {1, 2, 3, 5, 10, 16, 20, 50, 100};
+  typedef Matrix<Scalar, Dynamic, 1> VectorType;
+
+  for (int si = 0; si < int(sizeof(sizes) / sizeof(sizes[0])); ++si) {
+    const Index n = sizes[si];
+    VectorType diag(n), offdiag(n > 1 ? n - 1 : 0);
+
+    tridiag_negative(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_mixed_sign(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_toeplitz(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_wilkinson_signed(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_glued_wilkinson(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_laguerre(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_hermite(diag, offdiag);
+    verify(diag, offdiag);
+
+    tridiag_legendre(diag, offdiag);
+    verify(diag, offdiag);
+  }
+}
+
+}  // namespace test
+}  // namespace Eigen
+
+#endif  // EIGEN_TEST_TRIDIAG_TEST_MATRICES_H
diff --git a/test/tridiagonal_eigensolver.cpp b/test/tridiagonal_eigensolver.cpp
new file mode 100644
index 0000000..1ddb1a9
--- /dev/null
+++ b/test/tridiagonal_eigensolver.cpp
@@ -0,0 +1,757 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2026 Rasmus Munk Larsen <rmlarsen@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "tridiag_test_matrices.h"
+#include <limits>
+#include <Eigen/Eigenvalues>
+
+template <typename Packet>
+EIGEN_DONT_INLINE Packet packet_product_runtime(const Packet& lhs, const Packet& rhs) {
+  return internal::pmul(lhs, rhs);
+}
+
+// Some SIMD units flush subnormal operands and results to zero regardless of any library-side care
+// (ARMv7 NEON is hard-wired FTZ while its scalar VFP unit honors subnormals). Sections that feed
+// genuinely subnormal data through vectorized kernels cannot even observe their inputs on such
+// hardware, so they are gated on this runtime probe of the packet path. The volatile load prevents
+// constant folding, while the EIGEN_DONT_INLINE wrapper prevents Clang from scalarizing the packet
+// product and applying scalar IEEE semantics.
+template <typename RealScalar>
+bool packet_path_flushes_subnormals() {
+  typedef typename internal::packet_traits<RealScalar>::type Packet;
+  volatile RealScalar vtiny = (std::numeric_limits<RealScalar>::min)();
+  const RealScalar tiny = vtiny;
+  const RealScalar half_tiny =
+      internal::pfirst(packet_product_runtime(internal::pset1<Packet>(tiny), internal::pset1<Packet>(RealScalar(0.5))));
+  return numext::is_exactly_zero(half_tiny);
+}
+
+// Dense (n x n) symmetric tridiagonal matrix from its diagonal d and sub-diagonal e, for
+// residual / reconstruction checks against the solver output.
+template <typename DiagType, typename SubType>
+Matrix<typename DiagType::Scalar, Dynamic, Dynamic> dense_symmetric_tridiag(const DiagType& d, const SubType& e) {
+  typedef typename DiagType::Scalar RealScalar;
+  const Index n = d.size();
+  Matrix<RealScalar, Dynamic, Dynamic> T = Matrix<RealScalar, Dynamic, Dynamic>::Zero(n, n);
+  T.diagonal() = d;
+  if (n > 1) {
+    T.diagonal(-1) = e;
+    T.diagonal(1) = e;
+  }
+  return T;
+}
+
+// Test TridiagonalEigenSolver (SIMD Sturm-sequence spectral bisection) on the full
+// structured-tridiagonal catalog: compare against the implicit-QR path of
+// SelfAdjointEigenSolver::computeFromTridiagonal(), exercise index/value range subset
+// selection, and verify absolute accuracy against matrices with known spectra.
+template <typename RealScalar>
+void tridiagonal_eigensolver_bisection() {
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixType;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  const RealScalar tiny = (std::numeric_limits<RealScalar>::min)();
+
+  // (a) Compare bisection against the QR path over every structured matrix, and exercise
+  // index- and value-range subset selection.
+  test::for_all_symmetric_tridiag_test_matrices<RealScalar>([&](const VectorType& diag, const VectorType& offdiag) {
+    const Index n = diag.size();
+
+    SelfAdjointEigenSolver<MatrixType> qr;
+    qr.computeFromTridiagonal(diag, offdiag, EigenvaluesOnly);
+    if (qr.info() != Success) return;  // skip pathological inputs the QR path itself rejects
+    const VectorType w = qr.eigenvalues();
+
+    TridiagonalEigenSolver<RealScalar> bz;
+    bz.computeEigenvalues(diag, offdiag);
+    VERIFY_IS_EQUAL(bz.info(), Success);
+    VERIFY_IS_EQUAL(bz.eigenvalues().size(), n);
+    for (Index i = 1; i < n; ++i) VERIFY(bz.eigenvalues()(i) >= bz.eigenvalues()(i - 1));
+
+    // Bisection has an absolute accuracy floor of ~pivmin (the smallest safe pivot),
+    // so the tolerance carries an absolute term in addition to the eps*||T|| term.
+    const RealScalar radius = w.cwiseAbs().maxCoeff();
+    const RealScalar tol = RealScalar(64) * RealScalar(n) * (eps * radius + tiny);
+    VERIFY((bz.eigenvalues() - w).cwiseAbs().maxCoeff() <= tol);
+
+    // Index-range subsets: the k smallest and the k largest.
+    if (n >= 4) {
+      const Index k = n / 3;
+      TridiagonalEigenSolver<RealScalar> lo, hi;
+      lo.computeEigenvalues(diag, offdiag, EigenvalueRange::indices(0, k));
+      VERIFY_IS_EQUAL(lo.eigenvalues().size(), k);
+      VERIFY((lo.eigenvalues() - w.head(k)).cwiseAbs().maxCoeff() <= tol);
+      hi.computeEigenvalues(diag, offdiag, EigenvalueRange::indices(n - k, n));
+      VERIFY_IS_EQUAL(hi.eigenvalues().size(), k);
+      VERIFY((hi.eigenvalues() - w.tail(k)).cwiseAbs().maxCoeff() <= tol);
+    }
+
+    // Value-range subset [vl, vu) about the spectrum center. The count is compared strictly
+    // only when no eigenvalue sits within tol of a boundary (otherwise it is legitimately
+    // ambiguous which side the boundary eigenvalue falls on).
+    if (n >= 2 && radius > tiny) {
+      const RealScalar vl = -RealScalar(0.3) * radius, vu = RealScalar(0.3) * radius;
+      TridiagonalEigenSolver<RealScalar> bv;
+      bv.computeEigenvalues(diag, offdiag,
+                            EigenvalueRange::values(static_cast<long double>(vl), static_cast<long double>(vu)));
+      for (Index i = 0; i < bv.eigenvalues().size(); ++i)
+        VERIFY(bv.eigenvalues()(i) >= vl - tol && bv.eigenvalues()(i) < vu + tol);
+      const bool clean = (w.array() - vl).abs().minCoeff() > tol && (w.array() - vu).abs().minCoeff() > tol;
+      if (clean) {
+        const Index expected = (w.array() >= vl && w.array() < vu).count();
+        VERIFY_IS_EQUAL(bv.eigenvalues().size(), expected);
+        if (expected > 0) {
+          Index first = 0;
+          while (first < n && w(first) < vl) ++first;
+          VERIFY((bv.eigenvalues() - w.segment(first, expected)).cwiseAbs().maxCoeff() <= tol);
+        }
+      }
+    }
+  });
+
+  // (a2) Half-open value-range convention, fixed-size inputs, and input validation.
+  {
+    // values(vl, vu) selects the eigenvalues in the lower-closed, upper-open interval [vl, vu) (like
+    // indices()): an eigenvalue exactly equal to vl is included, one exactly equal to vu is not. Use a
+    // diagonal matrix (zero off-diagonal) with the exact integer spectrum {1, 2, 3} so the endpoints
+    // land precisely on eigenvalues.
+    VectorType d(3), e(2);
+    d << RealScalar(1), RealScalar(2), RealScalar(3);
+    e.setZero();
+    TridiagonalEigenSolver<RealScalar> bmid;
+    bmid.computeEigenvalues(d, e, EigenvalueRange::values(1.0L, 3.0L));
+    VERIFY_IS_EQUAL(bmid.eigenvalues().size(), Index(2));  // [1, 3) = {1, 2}: lower end closed, upper end open
+    VERIFY_IS_APPROX(bmid.eigenvalues()(0), RealScalar(1));
+    VERIFY_IS_APPROX(bmid.eigenvalues()(1), RealScalar(2));
+    TridiagonalEigenSolver<RealScalar> bopen;
+    bopen.computeEigenvalues(d, e, EigenvalueRange::values(0.0L, 1.0L));
+    VERIFY_IS_EQUAL(bopen.eigenvalues().size(), Index(0));  // [0, 1) excludes the eigenvalue at the open end 1
+    TridiagonalEigenSolver<RealScalar> blow;
+    blow.computeEigenvalues(d, e, EigenvalueRange::values(1.0L, 2.0L));
+    VERIFY_IS_EQUAL(blow.eigenvalues().size(), Index(1));  // [1, 2) = {1}: includes the eigenvalue at the closed end 1
+    VERIFY_IS_APPROX(blow.eigenvalues()(0), RealScalar(1));
+
+    // The half-open endpoint semantics must survive rounding in the Sturm recurrence, not just the
+    // exact-count diagonal case above: [[-3, 2], [2, -3]] has spectrum {-5, -1} exactly, but the
+    // recurrence rounds through 2/3-type values, so counts taken exactly at an endpoint eigenvalue
+    // are a coin flip (float used to drop -5 entirely, double used to keep -1). The endpoint
+    // resolution against the converged eigenvalues must return exactly {-5}.
+    VectorType dcross(2), ecross(1);
+    dcross << RealScalar(-3), RealScalar(-3);
+    ecross << RealScalar(2);
+    TridiagonalEigenSolver<RealScalar> bcross;
+    bcross.computeEigenvalues(dcross, ecross, EigenvalueRange::values(-5.0L, -1.0L));
+    VERIFY_IS_EQUAL(bcross.eigenvalues().size(), Index(1));
+    VERIFY_IS_APPROX(bcross.eigenvalues()(0), RealScalar(-5));
+
+    // Infinite endpoints mean unbounded on that side; the endpoint-tolerance arithmetic must not
+    // poison the result (inf - inf = NaN used to return an empty spectrum). A finite long double
+    // endpoint that narrows to infinity in RealScalar (1e300 for float) behaves the same way.
+    TridiagonalEigenSolver<RealScalar> binf;
+    binf.computeEigenvalues(d, e,
+                            EigenvalueRange::values(-std::numeric_limits<long double>::infinity(),
+                                                    std::numeric_limits<long double>::infinity()));
+    VERIFY_IS_EQUAL(binf.eigenvalues().size(), Index(3));
+    binf.computeEigenvalues(d, e, EigenvalueRange::values(1.5L, std::numeric_limits<long double>::infinity()));
+    VERIFY_IS_EQUAL(binf.eigenvalues().size(), Index(2));
+    VERIFY_IS_APPROX(binf.eigenvalues()(0), RealScalar(2));
+    binf.computeEigenvalues(d, e, EigenvalueRange::values(1.5L, 1e300L));
+    VERIFY_IS_EQUAL(binf.eigenvalues().size(), Index(2));
+
+    // Fixed-size input vectors work, including subset selection (the solver's own storage is
+    // dynamic, so a subset shorter than the input is not a problem).
+    Matrix<RealScalar, 3, 1> fd;
+    fd << RealScalar(1), RealScalar(2), RealScalar(3);
+    Matrix<RealScalar, 2, 1> fe;
+    fe.setZero();
+    TridiagonalEigenSolver<RealScalar> fz;
+    fz.computeEigenvalues(fd, fe);
+    VERIFY_IS_EQUAL(fz.eigenvalues().size(), Index(3));
+    fz.computeEigenvalues(fd, fe, EigenvalueRange::indices(0, 1));
+    VERIFY_IS_EQUAL(fz.eigenvalues().size(), Index(1));
+    VERIFY_IS_APPROX(fz.eigenvalues()(0), RealScalar(1));
+
+    // Querying an uninitialized solver is a usage error.
+    TridiagonalEigenSolver<RealScalar> uninit;
+    VERIFY_RAISES_ASSERT(uninit.eigenvalues());
+    VERIFY_RAISES_ASSERT(uninit.info());
+
+    // A non-finite input (NaN or Inf, diagonal or sub-diagonal) is rejected up front and
+    // reported via info().
+    VectorType dbad = d;
+    dbad(1) = std::numeric_limits<RealScalar>::quiet_NaN();
+    TridiagonalEigenSolver<RealScalar> bnan;
+    bnan.computeEigenvalues(dbad, e);
+    VERIFY_IS_EQUAL(bnan.info(), NoConvergence);
+    dbad(1) = std::numeric_limits<RealScalar>::infinity();
+    bnan.computeEigenvalues(dbad, e);
+    VERIFY_IS_EQUAL(bnan.info(), NoConvergence);
+    VectorType ebad = e;
+    ebad(0) = std::numeric_limits<RealScalar>::quiet_NaN();
+    bnan.computeEigenvalues(d, ebad);
+    VERIFY_IS_EQUAL(bnan.info(), NoConvergence);
+  }
+
+  // (b) Absolute-accuracy checks against matrices with known spectra (independent of QR).
+  // A subnormal-magnitude matrix exercises the normalization: dividing entries by the (subnormal) max
+  // magnitude keeps the scaled matrix O(1), whereas multiplying by 1/scale would overflow to infinity
+  // and return wrong eigenvalues. Compare against the same matrix in a normal range, scaled back down.
+  // Skipped on flush-to-zero packet hardware, where the subnormal inputs read as zero (see the probe).
+  if (!packet_path_flushes_subnormals<RealScalar>()) {
+    const Index nn = 7;
+    VectorType bd(nn), be(nn - 1);
+    test::tridiag_1_2_1(bd, be);
+    const RealScalar sub_scale = (std::numeric_limits<RealScalar>::min)() / RealScalar(64);  // subnormal
+    TridiagonalEigenSolver<RealScalar> bref, bsub;
+    bref.computeEigenvalues(bd, be);
+    bsub.computeEigenvalues(VectorType(bd * sub_scale), VectorType(be * sub_scale));
+    VERIFY_IS_EQUAL(bsub.info(), Success);
+    // The subnormal eigenvalues, scaled back to O(1), agree with the reference to the subnormal
+    // granularity at this magnitude (denorm_min / sub_scale) plus the usual bisection error.
+    const RealScalar radius = bref.eigenvalues().cwiseAbs().maxCoeff();
+    const RealScalar gran = (std::numeric_limits<RealScalar>::denorm_min)() / sub_scale;
+    VERIFY((bsub.eigenvalues() / sub_scale - bref.eigenvalues()).cwiseAbs().maxCoeff() <=
+           RealScalar(16) * (RealScalar(nn) * eps + gran) * radius);
+  }
+  const double pi = 3.14159265358979323846;
+  for (Index n : {7, 16, 33, 64}) {
+    VectorType d(n), e(n - 1), wexact(n);
+
+    // 1-2-1 Toeplitz: lambda_k = 2 - 2 cos(k*pi/(n+1)), ascending for k = 1..n.
+    test::tridiag_1_2_1(d, e);
+    TridiagonalEigenSolver<RealScalar> b121;
+    b121.computeEigenvalues(d, e);
+    for (Index k = 0; k < n; ++k) wexact(k) = RealScalar(2.0 - 2.0 * std::cos(double(k + 1) * pi / double(n + 1)));
+    VERIFY((b121.eigenvalues() - wexact).cwiseAbs().maxCoeff() <= RealScalar(64) * RealScalar(n) * eps * RealScalar(4));
+
+    // Clement / Kac: integer spectrum -(n-1), -(n-3), ..., (n-1).
+    test::tridiag_clement(d, e);
+    TridiagonalEigenSolver<RealScalar> bcl;
+    bcl.computeEigenvalues(d, e);
+    for (Index k = 0; k < n; ++k) wexact(k) = RealScalar(-(n - 1) + 2 * k);
+    VERIFY((bcl.eigenvalues() - wexact).cwiseAbs().maxCoeff() <= RealScalar(64) * RealScalar(n) * eps * RealScalar(n));
+
+    // Spectra exactly symmetric about 0: signed Wilkinson, Hermite, Legendre, [1,0,1] Toeplitz.
+    auto check_symmetric = [&](const VectorType& dd, const VectorType& ee) {
+      TridiagonalEigenSolver<RealScalar> bs;
+      bs.computeEigenvalues(dd, ee);
+      const VectorType s = bs.eigenvalues();
+      const RealScalar rad = s.cwiseAbs().maxCoeff();
+      const RealScalar tol = RealScalar(64) * RealScalar(n) * (eps * rad + tiny);
+      for (Index i = 0; i < n; ++i) VERIFY(numext::abs(s(i) + s(n - 1 - i)) <= tol);
+    };
+    test::tridiag_wilkinson_signed(d, e);
+    check_symmetric(d, e);
+    test::tridiag_hermite(d, e);
+    check_symmetric(d, e);
+    test::tridiag_legendre(d, e);
+    check_symmetric(d, e);
+    test::tridiag_toeplitz(d, e);  // default a = 1, b = 0
+    check_symmetric(d, e);
+  }
+}
+
+// Test the inverse-iteration eigenvector stage (LAPACK xSTEIN analog): staged
+// (computeEigenvalues() followed by computeEigenvectors()), one-call compute(), and the direct
+// computeEigenvectors(diag, subdiag, eigenvalues) API.
+template <typename RealScalar>
+void tridiagonal_eigensolver_eigenvectors() {
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixType;
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+  const RealScalar tiny = (std::numeric_limits<RealScalar>::min)();
+  const double pi = 3.14159265358979323846;
+
+  // (a) Eigenvectors over the structured catalog: staged and direct APIs.
+  test::for_all_symmetric_tridiag_test_matrices<RealScalar>([&](const VectorType& diag, const VectorType& offdiag) {
+    const Index n = diag.size();
+
+    // Dense form of T for residual / reconstruction checks.
+    const MatrixType T = dense_symmetric_tridiag(diag, offdiag);
+    RealScalar scale = T.cwiseAbs().maxCoeff();
+    if (!(numext::isfinite)(scale)) return;  // skip non-finite inputs, like the eigenvalue path
+    if (numext::is_exactly_zero(scale)) scale = RealScalar(1);
+
+    TridiagonalEigenSolver<RealScalar> es;
+    es.computeEigenvalues(diag, offdiag);
+    if (es.info() != Success) return;
+    es.computeEigenvectors();  // staged inverse-iteration pass
+    VERIFY_IS_EQUAL(es.info(), Success);
+    const VectorType w = es.eigenvalues();
+    const MatrixType V = es.eigenvectors();
+    VERIFY_IS_EQUAL(V.rows(), n);
+    VERIFY_IS_EQUAL(V.cols(), n);
+
+    const RealScalar tol = RealScalar(128) * RealScalar(n) * (eps * scale + tiny);
+    const RealScalar otol = RealScalar(128) * RealScalar(n) * eps;
+    // Per-column residual; stableNorm() since the catalog includes near-overflow entries.
+    for (Index i = 0; i < n; ++i) VERIFY((T * V.col(i) - w(i) * V.col(i)).stableNorm() <= tol);
+    // Orthonormality and full-spectrum reconstruction (the latter in scaled coordinates so the
+    // extreme-magnitude catalog entries cannot overflow the products).
+    VERIFY((V.transpose() * V - MatrixType::Identity(n, n)).cwiseAbs().maxCoeff() <= otol);
+    const RealScalar recon =
+        ((V * (w / scale).asDiagonal() * V.transpose()) - (T / scale)).cwiseAbs().maxCoeff() * scale;
+    VERIFY(recon <= tol);
+
+    // The one-call compute() reproduces the staged result exactly.
+    TridiagonalEigenSolver<RealScalar> onecall;
+    onecall.compute(diag, offdiag);
+    VERIFY_IS_EQUAL(onecall.info(), Success);
+    VERIFY_IS_EQUAL((onecall.eigenvalues() - w).cwiseAbs().maxCoeff(), RealScalar(0));
+    VERIFY_IS_EQUAL((onecall.eigenvectors() - V).cwiseAbs().maxCoeff(), RealScalar(0));
+
+    // The direct API reproduces the staged result exactly (same eigenvalues -> same deterministic vectors).
+    TridiagonalEigenSolver<RealScalar> dir;
+    dir.computeEigenvectors(diag, offdiag, w);
+    VERIFY_IS_EQUAL(dir.eigenvectors().rows(), n);
+    VERIFY_IS_EQUAL(dir.eigenvectors().cols(), n);
+    VERIFY_IS_EQUAL((dir.eigenvectors() - V).cwiseAbs().maxCoeff(), RealScalar(0));
+    VERIFY_IS_EQUAL(dir.info(), Success);
+    VERIFY_IS_EQUAL(dir.eigenvalues(), w);
+    const MatrixType& supplied_vectors = dir.eigenvectors();
+    for (Index i = 0; i < n; ++i)
+      VERIFY((T * supplied_vectors.col(i) - w(i) * supplied_vectors.col(i)).stableNorm() <= tol);
+    VERIFY((supplied_vectors.transpose() * supplied_vectors - MatrixType::Identity(n, n)).cwiseAbs().maxCoeff() <=
+           otol);
+
+    // Index-subset eigenvectors: the bisection range selects a band, inverse iteration produces just
+    // those columns; check residual and that they are orthonormal among themselves.
+    if (n >= 4) {
+      const Index il = n / 4, iu = n - n / 4;
+      TridiagonalEigenSolver<RealScalar> sub;
+      sub.compute(diag, offdiag, ComputeEigenvectors, EigenvalueRange::indices(il, iu));
+      const MatrixType Vs = sub.eigenvectors();
+      const VectorType ws = sub.eigenvalues();
+      VERIFY_IS_EQUAL(Vs.rows(), n);
+      VERIFY_IS_EQUAL(Vs.cols(), iu - il);
+      for (Index k = 0; k < iu - il; ++k) VERIFY((T * Vs.col(k) - ws(k) * Vs.col(k)).stableNorm() <= tol);
+      VERIFY((Vs.transpose() * Vs - MatrixType::Identity(iu - il, iu - il)).cwiseAbs().maxCoeff() <= otol);
+    }
+  });
+
+  // (b) Closed-form 1-2-1 Toeplitz eigenvectors: v_k(j) = sin(j*(n-k)*pi/(n+1)) for the k-th
+  // (ascending) eigenvalue. An analytic, solver-independent check of the inverse-iteration vectors.
+  for (Index n : {5, 16, 33, 64}) {
+    VectorType d(n), e(n - 1);
+    test::tridiag_1_2_1(d, e);
+    TridiagonalEigenSolver<RealScalar> es(d, e);
+    const MatrixType V = es.eigenvectors();
+    for (Index k = 0; k < n; ++k) {
+      VectorType exact(n);
+      for (Index j = 0; j < n; ++j) exact(j) = RealScalar(std::sin(double(j + 1) * double(n - k) * pi / double(n + 1)));
+      exact.normalize();
+      const RealScalar err = (std::min)((V.col(k) - exact).norm(), (V.col(k) + exact).norm());
+      VERIFY(err <= RealScalar(256) * RealScalar(n) * eps);
+    }
+  }
+
+  // (c) Edge cases: fixed-size inputs, eigenvalues-only requests, subnormal-magnitude matrices,
+  // and convergence reporting.
+  {
+    // Fixed-size input vectors work for the full eigendecomposition and for subsets (the solver's
+    // own storage is dynamic).
+    Matrix<RealScalar, 4, 1> fdiag = Matrix<RealScalar, 4, 1>::Random();
+    Matrix<RealScalar, 3, 1> fsub = Matrix<RealScalar, 3, 1>::Random();
+    TridiagonalEigenSolver<RealScalar> fz;
+    fz.compute(fdiag, fsub);
+    VERIFY_IS_EQUAL(fz.info(), Success);
+    VERIFY_IS_EQUAL(fz.eigenvectors().cols(), Index(4));
+    {
+      const MatrixType Tf = dense_symmetric_tridiag(fdiag, fsub);
+      const MatrixType Vf = fz.eigenvectors();
+      VERIFY((Vf.transpose() * Vf - MatrixType::Identity(4, 4)).cwiseAbs().maxCoeff() <= RealScalar(64) * eps);
+      VERIFY((Tf * Vf - Vf * fz.eigenvalues().asDiagonal()).cwiseAbs().maxCoeff() <=
+             RealScalar(64) * eps * Tf.cwiseAbs().maxCoeff());
+    }
+
+    // An EigenvaluesOnly compute() does not produce eigenvectors; querying them is a usage error,
+    // and the staged computeEigenvectors() supplies them afterwards.
+    TridiagonalEigenSolver<RealScalar> staged;
+    staged.compute(fdiag, fsub, EigenvaluesOnly);
+    VERIFY_IS_EQUAL(staged.info(), Success);
+    VERIFY_RAISES_ASSERT(staged.eigenvectors());
+    staged.computeEigenvectors();
+    VERIFY_IS_EQUAL(staged.info(), Success);
+    VERIFY_IS_EQUAL((staged.eigenvectors() - fz.eigenvectors()).cwiseAbs().maxCoeff(), RealScalar(0));
+
+    // A matrix whose entries are all subnormal must still yield genuine unit-norm, orthonormal
+    // eigenvectors rather than all-zero columns. Normalization must avoid forming 1/scale when
+    // that reciprocal overflows; subnormal blocks require two finite scaling steps. The eigenvalues are
+    // taken from the same matrix in a normal magnitude range (then scaled back down), so this exercises
+    // the eigenvector normalization in isolation from the eigenvalue solver.
+    // Skipped on flush-to-zero packet hardware, where the subnormal inputs read as zero (see the probe).
+    if (!packet_path_flushes_subnormals<RealScalar>()) {
+      const Index n = 6;
+      VectorType base_d(n), base_e(n - 1);
+      test::tridiag_1_2_1(base_d, base_e);
+      // sub_scale is subnormal and small enough that 1/sub_scale overflows to infinity.
+      const RealScalar sub_scale = (std::numeric_limits<RealScalar>::min)() / RealScalar(64);
+      const VectorType d = base_d * sub_scale, e = base_e * sub_scale;
+
+      TridiagonalEigenSolver<RealScalar> ref;
+      ref.computeEigenvalues(base_d, base_e);
+      const VectorType w_sub = ref.eigenvalues() * sub_scale;
+
+      TridiagonalEigenSolver<RealScalar> se;
+      se.computeEigenvectors(d, e, w_sub);
+      VERIFY_IS_EQUAL(se.info(), Success);
+      const MatrixType V = se.eigenvectors();
+      for (Index i = 0; i < n; ++i)
+        VERIFY(numext::abs(V.col(i).norm() - RealScalar(1)) <= RealScalar(64) * eps);  // unit norm, not all-zero
+      VERIFY((V.transpose() * V - MatrixType::Identity(n, n)).cwiseAbs().maxCoeff() <=
+             RealScalar(64) * RealScalar(n) * eps);
+      // Residual in normal-range coordinates (the eigenvectors are invariant under the uniform scale).
+      const MatrixType Tn = dense_symmetric_tridiag(base_d, base_e);
+      for (Index i = 0; i < n; ++i)
+        VERIFY((Tn * V.col(i) - ref.eigenvalues()(i) * V.col(i)).norm() <= RealScalar(256) * RealScalar(n) * eps);
+    }
+
+    // Numerically disconnected blocks at wildly different scales: each 1x1 block's eigenvector is
+    // the corresponding unit vector, exactly (components outside the owning block are exact zeros).
+    // Processing the blocks with one global perturbation floor (eps * ||T||) would swamp the pivots
+    // of the small blocks and return arbitrary mixtures of the first four vectors instead.
+    {
+      VectorType d(5), e = VectorType::Zero(4);
+      d << RealScalar(1), RealScalar(2), RealScalar(3), RealScalar(4), RealScalar(1e16);
+      TridiagonalEigenSolver<RealScalar> blocks;
+      blocks.computeEigenvectors(d, e, d);  // the diagonal is the exact (ascending) spectrum
+      VERIFY_IS_EQUAL(blocks.info(), Success);
+      VERIFY_IS_EQUAL((blocks.eigenvectors() - MatrixType::Identity(5, 5)).cwiseAbs().maxCoeff(), RealScalar(0));
+
+      // Any single requested eigenvalue must select its own block. The localization windows are
+      // expressed at each block's own scale; a window at the global scale (~ eps * 1e16 here) spans
+      // all four small blocks at once and used to hand w = (3) to the first block.
+      for (Index j = 0; j < 5; ++j) {
+        VectorType wone(1);
+        wone << d(j);
+        TridiagonalEigenSolver<RealScalar> one;
+        one.computeEigenvectors(d, e, wone);
+        VERIFY_IS_EQUAL(one.info(), Success);
+        VERIFY_IS_EQUAL((one.eigenvectors().col(0) - MatrixType::Identity(5, 5).col(j)).cwiseAbs().maxCoeff(),
+                        RealScalar(0));
+      }
+    }
+
+    // Small-block shifts need local accuracy even above the old global clustering cutoff.
+    for (RealScalar c : {RealScalar(0.125), RealScalar(2), RealScalar(3.9), RealScalar(4), RealScalar(4.1),
+                         RealScalar(5), RealScalar(10), RealScalar(100), RealScalar(1000)}) {
+      VectorType d(3), e(2);
+      d << RealScalar(1), RealScalar(0), RealScalar(0);
+      e << RealScalar(0), c * eps;
+      for (const auto& range : {EigenvalueRange::all(), EigenvalueRange::indices(0, 2), EigenvalueRange::indices(1, 2),
+                                EigenvalueRange::values(-0.5, 0.5)}) {
+        TridiagonalEigenSolver<RealScalar> blocks;
+        blocks.computeEigenvalues(d, e, range);
+        const VectorType values = blocks.eigenvalues();
+        blocks.computeEigenvectors();
+        VERIFY_IS_EQUAL(blocks.info(), Success);
+        VERIFY_IS_EQUAL(blocks.eigenvalues(), values);
+        const MatrixType V = blocks.eigenvectors();
+        VERIFY(V.allFinite());
+        VERIFY((V.transpose() * V - MatrixType::Identity(V.cols(), V.cols())).cwiseAbs().maxCoeff() <=
+               RealScalar(32) * eps);
+        VERIFY((dense_symmetric_tridiag(d, e) * V - V * values.asDiagonal()).cwiseAbs().maxCoeff() <=
+               RealScalar(32) * eps);
+        // Independent local eigenvectors are (1,+/-1)/sqrt(2), irrespective of global shift error.
+        for (Index j = 0; j < V.cols(); ++j) {
+          if (numext::abs(values(j)) < RealScalar(0.5))
+            VERIFY(numext::abs(numext::abs(V(1, j)) - numext::abs(V(2, j))) <= RealScalar(32) * eps);
+        }
+      }
+    }
+
+    // Accurate supplied shifts must not inherit the unrelated block's scale, even after solver reuse.
+    {
+      const Index nb = 16;
+      VectorType d = VectorType::Constant(nb + 1, RealScalar(2));
+      VectorType e = VectorType::Ones(nb), w(nb);
+      d(0) = numext::ldexp(RealScalar(1), 60);
+      e(0) = RealScalar(0);
+      for (Index k = 0; k < nb; ++k) {
+        const RealScalar angle = RealScalar(EIGEN_PI) * RealScalar(k + 1) / RealScalar(2 * (nb + 1));
+        w(k) = RealScalar(4) * numext::abs2(numext::sin(angle));
+      }
+      TridiagonalEigenSolver<RealScalar> supplied, local;
+      supplied.computeEigenvalues(d, e);
+      supplied.computeEigenvectors(d, e, w);
+      local.computeEigenvectors(d.tail(nb).eval(), e.tail(nb - 1).eval(), w);
+      VERIFY_IS_EQUAL(supplied.info(), Success);
+      VERIFY_IS_EQUAL(local.info(), Success);
+      VERIFY_IS_EQUAL(supplied.eigenvalues(), w);
+      VERIFY_IS_EQUAL(supplied.eigenvectors().bottomRows(nb), local.eigenvectors());
+      VERIFY_IS_EQUAL(supplied.eigenvectors().row(0).squaredNorm(), RealScalar(0));
+    }
+
+    // A zero block's normalization placeholder must not change clustering under power-of-two scaling.
+    {
+      VectorType d(4), e(3), w(4);
+      d << RealScalar(0), RealScalar(2), RealScalar(2), RealScalar(2);
+      e << RealScalar(0), RealScalar(1), RealScalar(1);
+      const RealScalar root2 = numext::sqrt(RealScalar(2));
+      w << RealScalar(0), RealScalar(2) - root2, RealScalar(2), RealScalar(2) + root2;
+      TridiagonalEigenSolver<RealScalar> reference, scaled;
+      reference.computeEigenvectors(d, e, w);
+      const RealScalar scale = numext::ldexp(RealScalar(1), -60);
+      scaled.computeEigenvectors((d * scale).eval(), (e * scale).eval(), (w * scale).eval());
+      VERIFY_IS_EQUAL(reference.info(), Success);
+      VERIFY_IS_EQUAL(scaled.info(), Success);
+      VERIFY_IS_EQUAL((scaled.eigenvectors() - reference.eigenvectors()).cwiseAbs().maxCoeff(), RealScalar(0));
+    }
+
+    // A huge disconnected block must not force splitting of a strongly connected small block: a
+    // splitting safety floor expressed at the global scale used to break the trailing 2x2 into
+    // singletons, returning coordinate vectors with O(1) local residual.
+    {
+      const RealScalar big = (std::numeric_limits<RealScalar>::max)() / RealScalar(1e10);
+      VectorType d(3), e(2), w(3);
+      d << big, RealScalar(1), RealScalar(2);
+      e << RealScalar(0), RealScalar(0.5);
+      // Exact spectrum: big and (3 -+ sqrt(2))/2 from the trailing 2x2 block.
+      w << RealScalar((3.0 - std::sqrt(2.0)) / 2.0), RealScalar((3.0 + std::sqrt(2.0)) / 2.0), big;
+      TridiagonalEigenSolver<RealScalar> conn;
+      conn.computeEigenvectors(d, e, w);
+      VERIFY_IS_EQUAL(conn.info(), Success);
+      const MatrixType Vc = conn.eigenvectors();
+      const MatrixType Tc = dense_symmetric_tridiag(d, e);
+      for (Index j = 0; j < 3; ++j)
+        VERIFY((Tc * Vc.col(j) - w(j) * Vc.col(j)).stableNorm() <=
+               RealScalar(64) * eps * numext::maxi(RealScalar(1), numext::abs(w(j))));
+      // The small-block vectors have no support on the big block, exactly.
+      VERIFY_IS_EQUAL(numext::abs(Vc(0, 0)), RealScalar(0));
+      VERIFY_IS_EQUAL(numext::abs(Vc(0, 1)), RealScalar(0));
+      VERIFY(numext::abs(Vc.col(0).dot(Vc.col(1))) <= RealScalar(8) * eps);
+    }
+
+    // Non-finite input to the direct eigenvector path is rejected up front and reported via info(),
+    // mirroring computeEigenvalues(): NaN data or shifts must not produce NaN vectors with Success.
+    {
+      VectorType d = VectorType::Ones(3), e = VectorType::Zero(2), w = VectorType::Ones(3);
+      TridiagonalEigenSolver<RealScalar> bad;
+      VectorType dnan = d;
+      dnan(1) = std::numeric_limits<RealScalar>::quiet_NaN();
+      bad.computeEigenvectors(dnan, e, w);
+      VERIFY_IS_EQUAL(bad.info(), NoConvergence);
+      VectorType wnan = w;
+      wnan(2) = std::numeric_limits<RealScalar>::quiet_NaN();
+      bad.computeEigenvectors(d, e, wnan);
+      VERIFY_IS_EQUAL(bad.info(), NoConvergence);
+    }
+
+    // Convergence is reported through info() rather than hard-coded to Success: inverse iteration
+    // counts the eigenvectors that fail to converge within its step limit (cf. LAPACK xSTEIN), and a
+    // well-conditioned spectrum converges fully, so that count is zero and info() is Success.
+    {
+      const Index n = 32;
+      VectorType d = VectorType::Random(n), e = VectorType::Random(n - 1);
+      TridiagonalEigenSolver<RealScalar> es2(d, e);
+      VERIFY_IS_EQUAL(es2.info(), Success);
+    }
+  }
+}
+
+// Scalar types narrower than float (half, bfloat16) are computed internally in float (see
+// TridiagonalEigenSolver::ComputeScalar): Sturm counts and bisection targets stay exact past the
+// narrow type's ~1/eps integer ceiling, the start-vector RNG cannot overflow to infinity, and the
+// coincident-shift perturbation (~0.08|x| at bfloat16 precision) cannot jump into a neighbouring
+// eigenspace. Each block below used to fail in the corresponding way.
+template <typename RealScalar>
+void tridiagonal_eigensolver_narrow() {
+  typedef Matrix<RealScalar, Dynamic, 1> VectorType;
+  typedef Matrix<RealScalar, Dynamic, Dynamic> MatrixType;
+  const RealScalar eps = NumTraits<RealScalar>::epsilon();
+
+  // (a) 2x2 [2, 1; 1, 2]: exact eigenpairs (1, 3) with vectors (1, -1)/sqrt(2), (1, 1)/sqrt(2).
+  // With the RNG overflow this returned an all-NaN eigenvector matrix with info() == Success.
+  {
+    VectorType d(2), e(1);
+    d << RealScalar(2), RealScalar(2);
+    e << RealScalar(1);
+    TridiagonalEigenSolver<RealScalar> es(d, e);
+    VERIFY_IS_EQUAL(es.info(), Success);
+    VERIFY(es.eigenvectors().allFinite());
+    VERIFY_IS_APPROX(es.eigenvalues()(0), RealScalar(1));
+    VERIFY_IS_APPROX(es.eigenvalues()(1), RealScalar(3));
+    const MatrixType V = es.eigenvectors();
+    VERIFY((V.transpose() * V - MatrixType::Identity(2, 2)).cwiseAbs().maxCoeff() <= RealScalar(8) * eps);
+    const MatrixType T = dense_symmetric_tridiag(d, e);
+    VERIFY((T * V - V * es.eigenvalues().asDiagonal()).cwiseAbs().maxCoeff() <= RealScalar(16) * eps);
+  }
+
+  // (b) Identity of dimension 257 (> 1/eps for bfloat16): every eigenvalue is exactly 1. With the
+  // Sturm counts held in the narrow type this returned eigenvalues as large as 5.19.
+  {
+    const Index n = 257;
+    const VectorType d = VectorType::Constant(n, RealScalar(1));
+    const VectorType e = VectorType::Zero(n - 1);
+    TridiagonalEigenSolver<RealScalar> es;
+    es.computeEigenvalues(d, e);
+    VERIFY_IS_EQUAL(es.info(), Success);
+    VERIFY_IS_EQUAL(es.eigenvalues().size(), n);
+    for (Index i = 0; i < n; ++i) VERIFY_IS_EQUAL(es.eigenvalues()(i), RealScalar(1));
+  }
+
+  // (c) diag (1, 1, 1 + 2^-4), zero off-diagonal: the eigenvectors for the two eigenvalues at 1
+  // must span exactly the first two coordinates. An un-capped shift perturbation at this precision
+  // used to select the third eigenspace for the second vector.
+  {
+    VectorType d(3), e = VectorType::Zero(2), w(2);
+    d << RealScalar(1), RealScalar(1), RealScalar(1.0625f);
+    w << RealScalar(1), RealScalar(1);
+    TridiagonalEigenSolver<RealScalar> es;
+    es.computeEigenvectors(d, e, w);
+    VERIFY_IS_EQUAL(es.info(), Success);
+    const MatrixType V = es.eigenvectors();
+    VERIFY_IS_EQUAL(numext::abs(V(2, 0)), RealScalar(0));
+    VERIFY_IS_EQUAL(numext::abs(V(2, 1)), RealScalar(0));
+    VERIFY((V.transpose() * V - MatrixType::Identity(2, 2)).cwiseAbs().maxCoeff() <= RealScalar(8) * eps);
+  }
+
+  // (d) 1-2-1 Toeplitz of dimension 64, staged full solve: the eigenvector pass must shift by the
+  // retained unrounded float eigenvalues. Shifts rounded to RealScalar collapse neighbouring
+  // eigenvalues and used to return near-parallel columns (Gram error ~0.4 in bfloat16).
+  {
+    const Index n = 64;
+    const VectorType d = VectorType::Constant(n, RealScalar(2.0f));
+    const VectorType e = VectorType::Constant(n - 1, RealScalar(1.0f));
+    TridiagonalEigenSolver<RealScalar> es(d, e);
+    VERIFY_IS_EQUAL(es.info(), Success);
+    const MatrixType V = es.eigenvectors();
+    VERIFY((V.transpose() * V - MatrixType::Identity(n, n)).cwiseAbs().maxCoeff() <= RealScalar(16) * eps);
+  }
+}
+
+void tridiagonal_eigensolver_power_of_two_scaling() {
+  // An input sensitive to normalization rounding; bisection promises normwise accuracy, not correct rounding.
+  Vector3f diag;
+  diag << numext::bit_cast<float>(numext::uint32_t(0xf055994f)), numext::bit_cast<float>(numext::uint32_t(0x6fb2331a)),
+      numext::bit_cast<float>(numext::uint32_t(0x70d02374));
+  Vector2f subdiag;
+  subdiag << numext::bit_cast<float>(numext::uint32_t(0x70b84b8a)),
+      numext::bit_cast<float>(numext::uint32_t(0x6fc495b1));
+  Vector3f expected;
+  expected << numext::bit_cast<float>(numext::uint32_t(0xf0e811b7)),
+      numext::bit_cast<float>(numext::uint32_t(0x708f34f5)), numext::bit_cast<float>(numext::uint32_t(0x70eac055));
+
+  TridiagonalEigenSolver<float> eigenvalues;
+  eigenvalues.computeEigenvalues(diag, subdiag);
+  VERIFY_IS_EQUAL(eigenvalues.info(), Success);
+  VERIFY(eigenvalues.eigenvalues().allFinite());
+  const Matrix3d bisectionMatrix = dense_symmetric_tridiag(diag, subdiag).cast<double>();
+  const double bisectionNorm = bisectionMatrix.cwiseAbs().rowwise().sum().maxCoeff();
+  // Allow O(n*eps*||T||_inf) Sturm-count displacement, the final bracket width and reference rounding.
+  // Eight covers the 2.1*n*eps bracket expansion on both sides, with room for the latter two terms.
+  const double eigenvalueTolerance = 8.0 * double(diag.size()) * double(NumTraits<float>::epsilon()) * bisectionNorm;
+  VERIFY((eigenvalues.eigenvalues().cast<double>() - expected.cast<double>()).cwiseAbs().maxCoeff() <=
+         eigenvalueTolerance);
+
+  // Exercise normalization-sensitive inverse iteration with rounded supplied eigenvalues.
+  diag << numext::bit_cast<float>(numext::uint32_t(0x44d75b8b)), numext::bit_cast<float>(numext::uint32_t(0x45b9403d)),
+      numext::bit_cast<float>(numext::uint32_t(0x4554211f));
+  subdiag << numext::bit_cast<float>(numext::uint32_t(0x45609c76)),
+      numext::bit_cast<float>(numext::uint32_t(0xc590ed04));
+  expected << numext::bit_cast<float>(numext::uint32_t(0xc4e47d7d)),
+      numext::bit_cast<float>(numext::uint32_t(0x45173159)), numext::bit_cast<float>(numext::uint32_t(0x46235731));
+
+  TridiagonalEigenSolver<float> eigenvectors;
+  eigenvectors.computeEigenvectors(diag, subdiag, expected);
+  VERIFY_IS_EQUAL(eigenvectors.info(), Success);
+  const Matrix3d matrix = dense_symmetric_tridiag(diag, subdiag).cast<double>();
+  const Matrix3d vectors = eigenvectors.eigenvectors().cast<double>();
+  VERIFY(vectors.allFinite());
+  const double residual = (matrix * vectors - vectors * expected.cast<double>().asDiagonal()).cwiseAbs().maxCoeff();
+  // Match the inverse-iteration suite's 128*n*eps allowance for perturbed pivots, repeated solves and normalization.
+  const double tolerance = 128.0 * double(diag.size()) * double(NumTraits<float>::epsilon());
+  VERIFY(residual <= tolerance * matrix.cwiseAbs().maxCoeff());
+  VERIFY((vectors.transpose() * vectors - Matrix3d::Identity()).cwiseAbs().maxCoeff() <= tolerance);
+}
+
+template <typename Scalar>
+void tridiagonal_eigensolver_scaling_units() {
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic>;
+  Vector diag(4), subdiag(3);
+  diag << Scalar(2), Scalar(2), Scalar(10), Scalar(10);
+  subdiag << Scalar(1), Scalar(0), Scalar(2);
+  Vector expected(4);
+  expected << Scalar(1), Scalar(3), Scalar(8), Scalar(12);
+  const MatrixType matrix = dense_symmetric_tridiag(diag, subdiag);
+  const Scalar tolerance = Scalar(32) * NumTraits<Scalar>::epsilon();
+  for (int exponent : {-60, 0, 60}) {
+    const Scalar scale = numext::ldexp(Scalar(1), exponent);
+    const Vector d = diag * scale, e = subdiag * scale;
+    TridiagonalEigenSolver<Scalar> solver(d, e);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    const Vector values = solver.eigenvalues() / scale;
+    VERIFY(values.allFinite());
+    VERIFY((values - expected).cwiseAbs().maxCoeff() <= tolerance * Scalar(12));
+    const MatrixType vectors = solver.eigenvectors();
+    VERIFY(vectors.allFinite());
+    VERIFY((matrix * vectors - vectors * values.asDiagonal()).norm() <= tolerance * matrix.norm());
+    VERIFY((vectors.transpose() * vectors - MatrixType::Identity(4, 4)).norm() <= tolerance);
+    solver.computeEigenvalues(
+        d, e, EigenvalueRange::values(static_cast<long double>(scale) * 2, static_cast<long double>(scale) * 9));
+    VERIFY_IS_EQUAL(solver.eigenvalues().size(), 2);
+    VERIFY((solver.eigenvalues() / scale - expected.segment(1, 2)).cwiseAbs().maxCoeff() <= tolerance * Scalar(12));
+
+    // The internal absolute tolerance is in input units, not normalized units.
+    Vector approximate;
+    const Scalar abs_tol = scale / Scalar(128);
+    internal::tridiagonal_bisection(d, e, EigenvalueRange::all(), abs_tol, approximate);
+    VERIFY((approximate / scale - expected).cwiseAbs().maxCoeff() <= Scalar(1) / Scalar(128) + tolerance);
+  }
+}
+
+template <typename Scalar>
+void tridiagonal_eigensolver_subnormal_staged() {
+  if (packet_path_flushes_subnormals<Scalar>()) return;
+  using Vector = Matrix<Scalar, 4, 1>;
+  using Subdiag = Matrix<Scalar, 3, 1>;
+  using MatrixType = Matrix<Scalar, 4, 4>;
+  const Vector diag = Vector::Constant(Scalar(2));
+  const Subdiag subdiag = Subdiag::Ones();
+  const MatrixType matrix = dense_symmetric_tridiag(diag, subdiag);
+  for (int divisor : {64, 1024, 4096}) {
+    const Scalar scale = (std::numeric_limits<Scalar>::min)() / Scalar(divisor);
+    const Vector d = diag * scale;
+    const Subdiag e = subdiag * scale;
+    TridiagonalEigenSolver<Scalar> solver;
+    solver.computeEigenvalues(d, e);
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    solver.computeEigenvectors();
+    VERIFY_IS_EQUAL(solver.info(), Success);
+    const Vector values = solver.eigenvalues() / scale;
+    const MatrixType vectors = solver.eigenvectors();
+    VERIFY(values.allFinite());
+    VERIFY(vectors.allFinite());
+    // Restored eigenvalues have absolute quantization denorm_min/scale. This matrix has
+    // norm <= 4 and minimum eigenvalue gap 1, so both residual and orthogonality see this error.
+    const Scalar quantization = std::numeric_limits<Scalar>::denorm_min() / scale;
+    const Scalar tolerance = Scalar(128 * 4) * NumTraits<Scalar>::epsilon() + Scalar(8 * 4) * quantization;
+    VERIFY((matrix * vectors - vectors * values.asDiagonal()).norm() <= tolerance);
+    VERIFY((vectors.transpose() * vectors - MatrixType::Identity()).norm() <= tolerance);
+  }
+}
+
+EIGEN_DECLARE_TEST(tridiagonal_eigensolver) {
+  CALL_SUBTEST_1(tridiagonal_eigensolver_subnormal_staged<double>());
+  CALL_SUBTEST_2(tridiagonal_eigensolver_subnormal_staged<float>());
+  CALL_SUBTEST_2(tridiagonal_eigensolver_power_of_two_scaling());
+  CALL_SUBTEST_2(tridiagonal_eigensolver_scaling_units<float>());
+  CALL_SUBTEST_1(tridiagonal_eigensolver_scaling_units<double>());
+  for (int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST_1(tridiagonal_eigensolver_bisection<double>());
+    CALL_SUBTEST_2(tridiagonal_eigensolver_bisection<float>());
+    CALL_SUBTEST_3(tridiagonal_eigensolver_eigenvectors<double>());
+    CALL_SUBTEST_4(tridiagonal_eigensolver_eigenvectors<float>());
+    CALL_SUBTEST_5(tridiagonal_eigensolver_narrow<Eigen::half>());
+    CALL_SUBTEST_6(tridiagonal_eigensolver_narrow<Eigen::bfloat16>());
+  }
+}
diff --git a/test/trsm_packet.cpp b/test/trsm_packet.cpp
new file mode 100644
index 0000000..9d75350
--- /dev/null
+++ b/test/trsm_packet.cpp
@@ -0,0 +1,150 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include <Eigen/Core>
+
+template <typename Scalar, int TriOrder, int OtherOrder, int Side, unsigned int Mode, int InnerStride>
+void trsm_packet_case(Index n, Index nrhs, Index inner, bool well_conditioned = true, Scalar magnitude = Scalar(1)) {
+  using Triangle = Matrix<Scalar, Dynamic, Dynamic, TriOrder>;
+  using Operand = Matrix<Scalar, Dynamic, Dynamic, OtherOrder>;
+  using Vector = Matrix<Scalar, Dynamic, 1>;
+  using Strides = Stride<Dynamic, InnerStride>;
+  const Index rows = Side == OnTheLeft ? n : nrhs, cols = Side == OnTheLeft ? nrhs : n;
+  const Index outer = inner * (OtherOrder == ColMajor ? rows : cols) + 3;
+  Vector storage = Vector::Constant(outer * (OtherOrder == ColMajor ? cols : rows) + 2, Scalar(17));
+  const Vector before = storage;
+  Map<Operand, Unaligned, Strides> x(storage.data() + 1, rows, cols, Strides(outer, inner));
+  Triangle a = Triangle::Random(n, n);
+  if (well_conditioned) a /= Scalar(n + 1);
+  a.diagonal().setOnes();
+  a *= magnitude;
+  const Triangle saved = a;
+  const Operand b = Operand::Random(rows, cols);
+  x = b;
+  // Poison every coefficient that the solve must not read, including a unit diagonal.
+  a.template triangularView<(Mode & Lower) ? StrictlyUpper : StrictlyLower>().setConstant(
+      NumTraits<Scalar>::quiet_NaN());
+  if (Mode & UnitDiag) a.diagonal().setConstant(NumTraits<Scalar>::quiet_NaN());
+  a.template triangularView<Mode>().template solveInPlace<Side>(x);
+
+  // |A X - B| <= O(n*eps) * (|A|*|X| + |B|). The factor 8 covers blocked updates
+  // and the independent residual accumulation in wider precision.
+  const long double gamma = 8 * n * static_cast<long double>(NumTraits<Scalar>::epsilon());
+  for (Index j = 0; j < cols; ++j) {
+    for (Index i = 0; i < rows; ++i) {
+      long double sum = 0, scale = numext::abs(static_cast<long double>(b(i, j)));
+      for (Index k = 0; k < n; ++k) {
+        const Index r = Side == OnTheLeft ? i : k, c = Side == OnTheLeft ? k : j;
+        if ((Mode & Lower) ? r < c : r > c) continue;
+        const long double t = r == c && (Mode & UnitDiag) ? 1 : static_cast<long double>(saved(r, c));
+        const long double v = Side == OnTheLeft ? static_cast<long double>(x(k, j)) : static_cast<long double>(x(i, k));
+        sum += t * v;
+        scale += numext::abs(t * v);
+      }
+      VERIFY((numext::isfinite)(scale));
+      VERIFY(numext::abs(sum - static_cast<long double>(b(i, j))) <= gamma * scale);
+    }
+  }
+  Vector expected = before;
+  Map<Operand, Unaligned, Strides> mapped(expected.data() + 1, rows, cols, Strides(outer, inner));
+  mapped = x;
+  VERIFY_IS_CWISE_EQUAL(storage, expected);
+}
+
+template <typename Scalar, int TriOrder, int OtherOrder, int Side, int InnerStride = 1>
+void trsm_packet_modes(Index n, Index nrhs, Index inner = 1) {
+  trsm_packet_case<Scalar, TriOrder, OtherOrder, Side, Lower, InnerStride>(n, nrhs, inner);
+  trsm_packet_case<Scalar, TriOrder, OtherOrder, Side, Upper, InnerStride>(n, nrhs, inner);
+  trsm_packet_case<Scalar, TriOrder, OtherOrder, Side, UnitLower, InnerStride>(n, nrhs, inner);
+  trsm_packet_case<Scalar, TriOrder, OtherOrder, Side, UnitUpper, InnerStride>(n, nrhs, inner);
+}
+
+template <typename Scalar>
+void trsm_packet_cache_sizes() {
+  using Traits = internal::triangular_solve_packet_traits<Scalar>;
+  std::ptrdiff_t saved_l1, saved_l2, saved_l3, saved_l3_per_cpu;
+  internal::manage_caching_sizes(GetAction, &saved_l1, &saved_l2, &saved_l3, &saved_l3_per_cpu);
+  const Index packet = Traits::PacketSize;
+  const Index widths[] = {packet, Traits::RhsPackets * packet, Traits::RhsPackets * packet + 1};
+  const auto cutoff_for = [](Index nrhs) {
+    Index cutoff = 0;
+    for (Index n = Traits::RegisterRows; n <= Traits::WorkspaceRows; ++n) {
+      if (!Traits::use_unblocked(n, nrhs, l1CacheSize())) break;
+      cutoff = n;
+    }
+    return cutoff;
+  };
+  Index previous = 0;
+  for (std::ptrdiff_t l1 : {512, 2048, 8192, 32768}) {
+    setCpuCacheSizes(l1, 4 * l1, 16 * l1);
+    const Index wide_cutoff = cutoff_for(widths[1]);
+    VERIFY(wide_cutoff >= previous);
+    previous = wide_cutoff;
+    for (Index nrhs : widths) {
+      const Index cutoff = cutoff_for(nrhs);
+      VERIFY(cutoff >= 0 && cutoff <= Traits::WorkspaceRows);
+      if (nrhs == packet) VERIFY(cutoff >= wide_cutoff);
+      // Exercise both algorithms at the configured crossover, plus the allocation bound.
+      const Index sizes[] = {
+          (numext::maxi)(Index(Traits::RegisterRows), cutoff - 1), (numext::maxi)(Index(Traits::RegisterRows), cutoff),
+          (numext::maxi)(Index(Traits::RegisterRows), cutoff + 1), Traits::WorkspaceRows, Traits::WorkspaceRows + 1};
+      for (Index n : sizes) {
+        trsm_packet_modes<Scalar, ColMajor, ColMajor, OnTheLeft>(n, nrhs);
+        trsm_packet_modes<Scalar, RowMajor, ColMajor, OnTheLeft>(n, nrhs);
+        trsm_packet_modes<Scalar, ColMajor, RowMajor, OnTheRight>(n, nrhs);
+        trsm_packet_modes<Scalar, RowMajor, RowMajor, OnTheRight>(n, nrhs);
+      }
+    }
+  }
+  VERIFY(!Traits::use_unblocked(Index(Traits::RegisterRows), packet - 1, saved_l1));
+  VERIFY(!Traits::use_unblocked(Index(Traits::RegisterRows), packet, std::ptrdiff_t(0)));
+  VERIFY(!Traits::use_unblocked(Index(Traits::RegisterRows), packet, (std::numeric_limits<std::ptrdiff_t>::min)()));
+  VERIFY(
+      !Traits::use_unblocked(Index(Traits::WorkspaceRows + 1), packet, (std::numeric_limits<std::ptrdiff_t>::max)()));
+  VERIFY(Traits::use_unblocked(Index(Traits::WorkspaceRows), widths[1], (std::numeric_limits<std::ptrdiff_t>::max)()) ==
+         Traits::UseUnblocked);
+  VERIFY(!Traits::use_unblocked((std::numeric_limits<Index>::max)(), packet,
+                                (std::numeric_limits<std::ptrdiff_t>::max)()));
+  internal::manage_caching_sizes(SetAction, &saved_l1, &saved_l2, &saved_l3, &saved_l3_per_cpu);
+}
+
+template <typename Scalar>
+void trsm_packet() {
+  STATIC_CHECK((internal::triangular_solve_packet_traits<Scalar>::Enabled ==
+                bool(internal::packet_traits<Scalar>::Vectorizable && std::numeric_limits<Scalar>::is_iec559 &&
+                     std::numeric_limits<Scalar>::radix == 2)));
+  STATIC_CHECK((!internal::triangular_solve_packet_traits<std::complex<Scalar>>::Enabled));
+  const Index packet = internal::packet_traits<Scalar>::size;
+  const Index widths[] = {1, 2, packet, 2 * packet - 1, 2 * packet, 2 * packet + 1, 4 * packet + 3};
+  const Index sizes[] = {0, 1, 3, 4, 7, 8, 11, 12, 16, 23, 24, 25, 31, 64, 127, 128, 129, 257};
+  for (Index n : sizes) {
+    for (Index nrhs : widths) {
+      trsm_packet_modes<Scalar, ColMajor, ColMajor, OnTheLeft>(n, nrhs);
+      trsm_packet_modes<Scalar, RowMajor, ColMajor, OnTheLeft>(n, nrhs);
+      trsm_packet_modes<Scalar, ColMajor, RowMajor, OnTheRight>(n, nrhs);
+      trsm_packet_modes<Scalar, RowMajor, RowMajor, OnTheRight>(n, nrhs);
+    }
+  }
+  trsm_packet_modes<Scalar, ColMajor, ColMajor, OnTheLeft, Dynamic>(65, 19, 1);
+  trsm_packet_modes<Scalar, RowMajor, ColMajor, OnTheLeft, Dynamic>(65, 19, 2);
+  trsm_packet_modes<Scalar, ColMajor, RowMajor, OnTheRight, 2>(65, 19, 2);
+  // Unscaled off-diagonals allow inverse growth; only backward error is checked.
+  trsm_packet_case<Scalar, ColMajor, ColMajor, OnTheLeft, Lower, 1>(33, 19, 1, false);
+  trsm_packet_case<Scalar, RowMajor, ColMajor, OnTheLeft, Upper, 1>(33, 19, 1, false);
+  trsm_packet_case<Scalar, ColMajor, RowMajor, OnTheRight, UnitLower, 1>(33, 19, 1, false);
+  trsm_packet_case<Scalar, RowMajor, RowMajor, OnTheRight, UnitUpper, 1>(33, 19, 1, false);
+  for (int exponent : {-40, 40}) {
+    const Scalar magnitude = numext::ldexp(Scalar(1), exponent);
+    trsm_packet_case<Scalar, ColMajor, ColMajor, OnTheLeft, Lower, 1>(65, 19, 1, true, magnitude);
+    trsm_packet_case<Scalar, RowMajor, ColMajor, OnTheLeft, Upper, 1>(65, 19, 1, true, magnitude);
+  }
+  trsm_packet_cache_sizes<Scalar>();
+}
+
+EIGEN_DECLARE_TEST(trsm_packet) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1(trsm_packet<float>());
+    CALL_SUBTEST_2(trsm_packet<double>());
+  }
+}
diff --git a/test/trsm_packet_cancellation.cpp b/test/trsm_packet_cancellation.cpp
new file mode 100644
index 0000000..81f9b11
--- /dev/null
+++ b/test/trsm_packet_cancellation.cpp
@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// Exercise the shared kernel even when an ISA-specific TRSM implementation is available.
+#define EIGEN_USE_AVX512_TRSM_KERNELS 0
+// Keep the cancelling terms in one diagonal panel; synthetic kc=1 moves them into separate GEMM updates.
+#define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
+
+#include "main.h"
+#include <Eigen/Core>
+
+template <typename Scalar>
+void trsm_packet_cancellation() {
+  STATIC_CHECK((internal::triangular_solve_packet_traits<Scalar>::UseUnblocked ==
+                internal::triangular_solve_packet_traits<Scalar>::Enabled));
+  using Triangle = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
+  using Operand = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
+  std::ptrdiff_t saved_l1, saved_l2, saved_l3, saved_l3_per_cpu;
+  internal::manage_caching_sizes(GetAction, &saved_l1, &saved_l2, &saved_l3, &saved_l3_per_cpu);
+  // Deterministic panels for the blocked cases, including AVX-512 double precision.
+  setCpuCacheSizes(64 * 1024, 2 * 1024 * 1024, 16 * 1024 * 1024);
+  const Index packet = internal::packet_traits<Scalar>::size;
+  const Scalar half_max = (std::numeric_limits<Scalar>::max)() / Scalar(2);
+  const Scalar large = ((std::numeric_limits<Scalar>::max)() / Scalar(4)) * Scalar(3);
+  for (Index n : {4, 8, 16, 128, 256}) {
+    for (Index offset : {Index(0), n - 4}) {
+      Triangle a = Triangle::Identity(n, n);
+      a(offset + 3, offset) = -half_max;
+      a(offset + 3, offset + 1) = half_max;
+      a.template triangularView<StrictlyUpper>().setConstant(NumTraits<Scalar>::quiet_NaN());
+      const Index widths[] = {packet, 2 * packet, 2 * packet + 1, 4 * packet + 3};
+      for (Index nrhs : widths) {
+        Operand b = Operand::Ones(n, nrhs), x(n, nrhs);
+        b.row(offset + 3).setConstant(large);
+        // Only alternating columns overflow, exercising mixed packet lanes and scalar tails.
+        for (Index j = 1; j < nrhs; j += 2) b(offset + 3, j) = Scalar(1);
+        x = b;
+        a.template triangularView<Lower>().solveInPlace(x);
+        VERIFY(x.array().isFinite().all());
+        // Four eps covers reciprocal/multiply rounding, including fast-math reciprocals.
+        VERIFY(((x - b).cwiseAbs().array() <= Scalar(4) * NumTraits<Scalar>::epsilon() * b.array()).all());
+
+        Triangle upper = a.reverse();
+        const Operand reversed = b.colwise().reverse();
+        x = reversed;
+        upper.template triangularView<Upper>().solveInPlace(x);
+        VERIFY(x.array().isFinite().all());
+        VERIFY(
+            ((x - reversed).cwiseAbs().array() <= Scalar(4) * NumTraits<Scalar>::epsilon() * reversed.array()).all());
+
+        a.diagonal().setConstant(NumTraits<Scalar>::quiet_NaN());
+        upper.diagonal().setConstant(NumTraits<Scalar>::quiet_NaN());
+        x = b;
+        a.template triangularView<UnitLower>().solveInPlace(x);
+        VERIFY(x.array().isFinite().all());
+        VERIFY_IS_CWISE_EQUAL(x, b);
+        x = reversed;
+        upper.template triangularView<UnitUpper>().solveInPlace(x);
+        VERIFY(x.array().isFinite().all());
+        VERIFY_IS_CWISE_EQUAL(x, reversed);
+
+        Matrix<Scalar, Dynamic, Dynamic, RowMajor> right = b.transpose();
+        a.transpose().template triangularView<UnitUpper>().template solveInPlace<OnTheRight>(right);
+        VERIFY(right.array().isFinite().all());
+        VERIFY_IS_CWISE_EQUAL(right, b.transpose());
+        a.diagonal().setOnes();
+      }
+    }
+  }
+  internal::manage_caching_sizes(SetAction, &saved_l1, &saved_l2, &saved_l3, &saved_l3_per_cpu);
+}
+
+EIGEN_DECLARE_TEST(trsm_packet_cancellation) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1(trsm_packet_cancellation<float>());
+    CALL_SUBTEST_2(trsm_packet_cancellation<double>());
+  }
+}
diff --git a/test/trsm_packet_cancellation_fastmath.cpp b/test/trsm_packet_cancellation_fastmath.cpp
new file mode 100644
index 0000000..8bb19bf
--- /dev/null
+++ b/test/trsm_packet_cancellation_fastmath.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+// EIGEN_SUFFIXES;1;2
+// Nonfinite detection must survive the compiler's finite-math assumptions.
+#include "trsm_packet_cancellation.cpp"  // NOLINT(bugprone-suspicious-include)
diff --git a/test/tuple_test.cpp b/test/tuple_test.cpp
index 33bebd2..52f23d0 100644
--- a/test/tuple_test.cpp
+++ b/test/tuple_test.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -23,24 +24,23 @@
   tuple<int, float, double> tuple3{7, 11.0f, 13.0};
   // Default construction.
   tuple<> tuple0default;
-  EIGEN_UNUSED_VARIABLE(tuple0default)
+  EIGEN_UNUSED_VARIABLE(tuple0default);
   tuple<int> tuple1default;
-  EIGEN_UNUSED_VARIABLE(tuple1default)
+  EIGEN_UNUSED_VARIABLE(tuple1default);
   tuple<int, float> tuple2default;
-  EIGEN_UNUSED_VARIABLE(tuple2default)
+  EIGEN_UNUSED_VARIABLE(tuple2default);
   tuple<int, float, double> tuple3default;
-  EIGEN_UNUSED_VARIABLE(tuple3default)
+  EIGEN_UNUSED_VARIABLE(tuple3default);
 
   // Assignment.
   tuple<> tuple0b = tuple0;
-  EIGEN_UNUSED_VARIABLE(tuple0b)
+  EIGEN_UNUSED_VARIABLE(tuple0b);
   decltype(tuple1) tuple1b = tuple1;
-  EIGEN_UNUSED_VARIABLE(tuple1b)
+  EIGEN_UNUSED_VARIABLE(tuple1b);
   decltype(tuple2) tuple2b = tuple2;
-  EIGEN_UNUSED_VARIABLE(tuple2b)
+  EIGEN_UNUSED_VARIABLE(tuple2b);
   decltype(tuple3) tuple3b = tuple3;
-  EIGEN_UNUSED_VARIABLE(tuple3b)
-
+  EIGEN_UNUSED_VARIABLE(tuple3b);
   // get.
   VERIFY_IS_EQUAL(tuple_impl::get<0>(tuple3), 7);
   VERIFY_IS_EQUAL(tuple_impl::get<1>(tuple3), 11.0f);
@@ -61,8 +61,7 @@
   VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(tuple3cat0)>::value, size_t(3));
   auto singlecat = tuple_impl::tuple_cat(tuple3);
   VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(singlecat)>::value, size_t(3));
-  auto emptycat = tuple_impl::tuple_cat();
-  VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(emptycat)>::value, size_t(0));
+  VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(tuple_impl::tuple_cat())>::value, size_t(0));
   auto tuple0cat1cat2cat3 = tuple_impl::tuple_cat(tuple0, tuple1, tuple2, tuple3);
   VERIFY_IS_EQUAL(tuple_impl::tuple_size<decltype(tuple0cat1cat2cat3)>::value, size_t(6));
 
diff --git a/test/twoprod.cpp b/test/twoprod.cpp
new file mode 100644
index 0000000..0d1479e
--- /dev/null
+++ b/test/twoprod.cpp
@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#include "main.h"
+#include "twoprod_helpers.h"
+
+template <typename Scalar, typename Packet>
+void check_doubleword_product(const Scalar (&data)[7]) {
+  constexpr Index size = internal::unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_MAX Scalar hi[size], lo[size];
+  const Scalar epsilon = NumTraits<Scalar>::epsilon();
+  const Scalar bound = Scalar(1.25) * epsilon * epsilon * numext::abs(data[4]);  // 5*u^2, u = eps/2.
+  for (int exponent : {-20, 0, 20}) {
+    // Keep the operands runtime so constant folding cannot replace the arithmetic under test.
+    volatile Scalar x_scale = numext::ldexp(Scalar(1), exponent), y_scale = numext::ldexp(Scalar(1), -exponent);
+    for (int sign : {-1, 1}) {
+      const Scalar x_hi = Scalar(sign) * data[0] * x_scale;
+      const Scalar x_lo = Scalar(sign) * data[1] * x_scale;
+      const Scalar y_hi = data[2] * y_scale;
+      const Scalar y_lo = data[3] * y_scale;
+      VERIFY_IS_EQUAL(x_hi + x_lo, x_hi);
+      VERIFY_IS_EQUAL(y_hi + y_lo, y_hi);
+      Packet p_hi, p_lo;
+      internal::twoprod(internal::pset1<Packet>(x_hi), internal::pset1<Packet>(x_lo), internal::pset1<Packet>(y_hi),
+                        internal::pset1<Packet>(y_lo), p_hi, p_lo);
+      internal::pstore(hi, p_hi);
+      internal::pstore(lo, p_lo);
+      for (Index i = 0; i < size; ++i) {
+        VERIFY_IS_EQUAL(hi[i], Scalar(sign) * data[4]);
+        const Scalar error = numext::abs((lo[i] - Scalar(sign) * data[5]) - Scalar(sign) * data[6]);
+        VERIFY(error < bound);
+      }
+    }
+  }
+}
+
+EIGEN_DECLARE_TEST(twoprod) {
+  using FloatPacket = internal::packet_traits<float>::type;
+  using DoublePacket = internal::packet_traits<double>::type;
+  check_twoprod_packet<float>();
+  check_twoprod_packet<double>();
+  check_twoprod_packet<FloatPacket>();
+  check_twoprod_packet<DoublePacket>();
+
+  // {x_hi, x_lo, y_hi, y_lo, ref_hi, ref_lo, ref_tail}. The reference product is
+  // decomposed with 600-bit MPFR, rounding each word to the tested scalar type.
+  // These normalized inputs exceed the former 2*u^2 bound in both precisions.
+  const float float_data[] = {1.1675887107849121f,     -3.9186936362511915e-08f, 1.7997856140136719f,
+                              5.2592689314678864e-08f, 2.1014094352722168f,      -7.963821957446271e-08f,
+                              1.2973732602550997e-15f};
+  const double double_data[] = {1.4946183601517316,      9.493375847471864e-17, 1.4603476327002127,
+                                -8.3856771222625945e-17, 2.182662384037855,     1.9088477361435543e-16,
+                                -3.7615759087187478e-33};
+  check_doubleword_product<float, float>(float_data);
+  check_doubleword_product<double, double>(double_data);
+  check_doubleword_product<float, FloatPacket>(float_data);
+  check_doubleword_product<double, DoublePacket>(double_data);
+}
diff --git a/test/twoprod_generic.cpp b/test/twoprod_generic.cpp
new file mode 100644
index 0000000..b68beeb
--- /dev/null
+++ b/test/twoprod_generic.cpp
@@ -0,0 +1,6 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_VECTORIZE_GENERIC 1
+#define EIGEN_GENERIC_VECTOR_SIZE_BYTES 16
+#include "twoprod.cpp"  // NOLINT(bugprone-suspicious-include): the same suite on the generic vector backend.
diff --git a/test/twoprod_helpers.h b/test/twoprod_helpers.h
new file mode 100644
index 0000000..0cea862
--- /dev/null
+++ b/test/twoprod_helpers.h
@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_TWOPROD_HELPERS_H
+#define EIGEN_TEST_TWOPROD_HELPERS_H
+
+template <typename Packet>
+void check_twoprod_packet() {
+  using Scalar = typename internal::unpacket_traits<Packet>::type;
+  constexpr Index size = internal::unpacket_traits<Packet>::size;
+  EIGEN_ALIGN_MAX Scalar x[size], y[size], hi[size], lo[size], residual[size];
+  const Scalar epsilon = NumTraits<Scalar>::epsilon();
+  volatile int one = 1;
+  for (int sign : {-1, 1}) {
+    for (Index i = 0; i < size; ++i) {
+      x[i] = Scalar(i % 2 ? -sign : sign) * (Scalar(one) + epsilon);
+      y[i] = Scalar(one) - epsilon;
+    }
+    const Packet px = internal::pload<Packet>(x), py = internal::pload<Packet>(y);
+    Packet p_hi, p_lo;
+    internal::twoprod(px, py, p_hi, p_lo);
+    internal::pstore(hi, p_hi);
+    internal::pstore(lo, p_lo);
+    internal::pstore(residual, internal::twoprod_low(px, py, p_hi));
+    for (Index i = 0; i < size; ++i) {
+      const Scalar lane_sign = Scalar(i % 2 ? -sign : sign);
+      // (1 + eps)(1 - eps) = 1 - eps^2; an unfused pmsub loses the residual.
+      VERIFY_IS_EQUAL(hi[i], lane_sign);
+      VERIFY_IS_EQUAL(lo[i], -lane_sign * epsilon * epsilon);
+      VERIFY_IS_EQUAL(residual[i], -lane_sign * epsilon * epsilon);
+    }
+  }
+}
+
+// Where a hardware fma exists, GCC's C++ default -ffp-contract=fast may fuse fl(x*y) into the sums that consume it, and
+// Dekker's splitting product is then no longer error-free. The double-word product exposes it:
+// (1 + eps)(1 - eps) = 1 - eps^2, whose fl(x*y) = 1 feeds the renormalizing sums.
+template <typename T>
+void check_twoprod_contraction() {
+  const T epsilon = NumTraits<T>::epsilon();
+  // Runtime operands: constant folding would round every step before contraction could apply.
+  volatile T one = T(1);
+  for (int sign : {-1, 1}) {
+    const T x = T(sign) * (one + epsilon), y = one - epsilon;
+    T hi, lo;
+    internal::twoprod(x, T(0), y, hi, lo);
+    VERIFY_IS_EQUAL(hi, T(sign));
+    VERIFY_IS_EQUAL(lo, -T(sign) * epsilon * epsilon);
+  }
+}
+
+#endif  // EIGEN_TEST_TWOPROD_HELPERS_H
diff --git a/test/type_alias.cpp b/test/type_alias.cpp
index 1619d83..647e4b0 100644
--- a/test/type_alias.cpp
+++ b/test/type_alias.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -13,29 +14,29 @@
   using namespace internal;
 
   // To warm up, some basic checks:
-  STATIC_CHECK((is_same<MatrixXd, Matrix<double, Dynamic, Dynamic> >::value));
-  STATIC_CHECK((is_same<Matrix2f, Matrix<float, 2, 2> >::value));
-  STATIC_CHECK((is_same<Array33i, Array<int, 3, 3> >::value));
+  STATIC_CHECK((std::is_same<MatrixXd, Matrix<double, Dynamic, Dynamic> >::value));
+  STATIC_CHECK((std::is_same<Matrix2f, Matrix<float, 2, 2> >::value));
+  STATIC_CHECK((std::is_same<Array33i, Array<int, 3, 3> >::value));
 
-  STATIC_CHECK((is_same<MatrixX<double>, MatrixXd>::value));
-  STATIC_CHECK((is_same<MatrixX<int>, MatrixXi>::value));
-  STATIC_CHECK((is_same<Matrix2<int>, Matrix2i>::value));
-  STATIC_CHECK((is_same<Matrix2X<float>, Matrix2Xf>::value));
-  STATIC_CHECK((is_same<MatrixX4<double>, MatrixX4d>::value));
-  STATIC_CHECK((is_same<VectorX<int>, VectorXi>::value));
-  STATIC_CHECK((is_same<Vector2<float>, Vector2f>::value));
-  STATIC_CHECK((is_same<RowVectorX<int>, RowVectorXi>::value));
-  STATIC_CHECK((is_same<RowVector2<float>, RowVector2f>::value));
+  STATIC_CHECK((std::is_same<MatrixX<double>, MatrixXd>::value));
+  STATIC_CHECK((std::is_same<MatrixX<int>, MatrixXi>::value));
+  STATIC_CHECK((std::is_same<Matrix2<int>, Matrix2i>::value));
+  STATIC_CHECK((std::is_same<Matrix2X<float>, Matrix2Xf>::value));
+  STATIC_CHECK((std::is_same<MatrixX4<double>, MatrixX4d>::value));
+  STATIC_CHECK((std::is_same<VectorX<int>, VectorXi>::value));
+  STATIC_CHECK((std::is_same<Vector2<float>, Vector2f>::value));
+  STATIC_CHECK((std::is_same<RowVectorX<int>, RowVectorXi>::value));
+  STATIC_CHECK((std::is_same<RowVector2<float>, RowVector2f>::value));
 
-  STATIC_CHECK((is_same<ArrayXX<float>, ArrayXXf>::value));
-  STATIC_CHECK((is_same<Array33<int>, Array33i>::value));
-  STATIC_CHECK((is_same<Array2X<float>, Array2Xf>::value));
-  STATIC_CHECK((is_same<ArrayX4<double>, ArrayX4d>::value));
-  STATIC_CHECK((is_same<ArrayX<double>, ArrayXd>::value));
-  STATIC_CHECK((is_same<Array4<double>, Array4d>::value));
+  STATIC_CHECK((std::is_same<ArrayXX<float>, ArrayXXf>::value));
+  STATIC_CHECK((std::is_same<Array33<int>, Array33i>::value));
+  STATIC_CHECK((std::is_same<Array2X<float>, Array2Xf>::value));
+  STATIC_CHECK((std::is_same<ArrayX4<double>, ArrayX4d>::value));
+  STATIC_CHECK((std::is_same<ArrayX<double>, ArrayXd>::value));
+  STATIC_CHECK((std::is_same<Array4<double>, Array4d>::value));
 
-  STATIC_CHECK((is_same<Vector<float, 3>, Vector3f>::value));
-  STATIC_CHECK((is_same<Vector<int, Dynamic>, VectorXi>::value));
-  STATIC_CHECK((is_same<RowVector<float, 3>, RowVector3f>::value));
-  STATIC_CHECK((is_same<RowVector<int, Dynamic>, RowVectorXi>::value));
+  STATIC_CHECK((std::is_same<Vector<float, 3>, Vector3f>::value));
+  STATIC_CHECK((std::is_same<Vector<int, Dynamic>, VectorXi>::value));
+  STATIC_CHECK((std::is_same<RowVector<float, 3>, RowVector3f>::value));
+  STATIC_CHECK((std::is_same<RowVector<int, Dynamic>, RowVectorXi>::value));
 }
diff --git a/test/type_test_helpers.h b/test/type_test_helpers.h
new file mode 100644
index 0000000..6c1485d
--- /dev/null
+++ b/test/type_test_helpers.h
@@ -0,0 +1,124 @@
+// SPDX-FileCopyrightText: 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// SPDX-FileCopyrightText: 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#ifndef EIGEN_TEST_TYPE_TEST_HELPERS_H
+#define EIGEN_TEST_TYPE_TEST_HELPERS_H
+
+#include <complex>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+
+#include <Eigen/Core>
+
+#if EIGEN_COMP_ICC
+template <typename T>
+inline std::string type_name();
+#endif
+
+namespace Eigen {
+
+template <typename T1, typename T2>
+std::enable_if_t<std::is_same<T1, T2>::value, bool> is_same_type(const T1&, const T2&) {
+  return true;
+}
+
+}  // namespace Eigen
+
+template <typename T>
+struct GetDifferentType;
+
+template <>
+struct GetDifferentType<float> {
+  typedef double type;
+};
+template <>
+struct GetDifferentType<double> {
+  typedef float type;
+};
+template <typename T>
+struct GetDifferentType<std::complex<T>> {
+  typedef std::complex<typename GetDifferentType<T>::type> type;
+};
+
+template <typename T>
+inline std::string type_name(T) {
+  return typeid(T).name();
+}
+template <>
+inline std::string type_name<float>(float) {
+  return "float";
+}
+template <>
+inline std::string type_name<double>(double) {
+  return "double";
+}
+template <>
+inline std::string type_name<long double>(long double) {
+  return "long double";
+}
+template <>
+inline std::string type_name<Eigen::half>(Eigen::half) {
+  return "half";
+}
+template <>
+inline std::string type_name<Eigen::bfloat16>(Eigen::bfloat16) {
+  return "bfloat16";
+}
+template <>
+inline std::string type_name<int8_t>(int8_t) {
+  return "int8_t";
+}
+template <>
+inline std::string type_name<int16_t>(int16_t) {
+  return "int16_t";
+}
+template <>
+inline std::string type_name<int32_t>(int32_t) {
+  return "int32_t";
+}
+template <>
+inline std::string type_name<int64_t>(int64_t) {
+  return "int64_t";
+}
+template <>
+inline std::string type_name<uint8_t>(uint8_t) {
+  return "uint8_t";
+}
+template <>
+inline std::string type_name<uint16_t>(uint16_t) {
+  return "uint16_t";
+}
+template <>
+inline std::string type_name<uint32_t>(uint32_t) {
+  return "uint32_t";
+}
+template <>
+inline std::string type_name<uint64_t>(uint64_t) {
+  return "uint64_t";
+}
+template <>
+inline std::string type_name<std::complex<float>>(std::complex<float>) {
+  return "complex<float>";
+}
+template <>
+inline std::string type_name<std::complex<double>>(std::complex<double>) {
+  return "complex<double>";
+}
+template <>
+inline std::string type_name<std::complex<long double>>(std::complex<long double>) {
+  return "complex<long double>";
+}
+template <>
+inline std::string type_name<std::complex<int>>(std::complex<int>) {
+  return "complex<int>";
+}
+template <typename T>
+inline std::string type_name() {
+  return type_name(T());
+}
+
+#endif  // EIGEN_TEST_TYPE_TEST_HELPERS_H
diff --git a/test/ulp_accuracy/mpfr_reference.h b/test/ulp_accuracy/mpfr_reference.h
index 37c6911..02ec374 100644
--- a/test/ulp_accuracy/mpfr_reference.h
+++ b/test/ulp_accuracy/mpfr_reference.h
@@ -5,6 +5,8 @@
 // between float/double and mpfr_t.
 //
 // Only compiled when EIGEN_HAS_MPFR is defined (i.e., MPFR and GMP are found).
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #ifndef EIGEN_ULP_ACCURACY_MPFR_REFERENCE_H
 #define EIGEN_ULP_ACCURACY_MPFR_REFERENCE_H
diff --git a/test/ulp_accuracy/ulp_accuracy.cpp b/test/ulp_accuracy/ulp_accuracy.cpp
index 658d234..eef7c8b 100644
--- a/test/ulp_accuracy/ulp_accuracy.cpp
+++ b/test/ulp_accuracy/ulp_accuracy.cpp
@@ -12,14 +12,17 @@
 //
 // Build:
 //   cd build && cmake .. && make ulp_accuracy
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 
 #include <Eigen/Core>
-#include <unsupported/Eigen/SpecialFunctions>
+#include <contrib/Eigen/SpecialFunctions>
 
 #ifdef EIGEN_HAS_MPFR
 #include <mpfr.h>
 #endif
 
+#include <atomic>
 #include <cfloat>
 #include <chrono>
 #include <cmath>
@@ -84,7 +87,7 @@
 // ============================================================================
 
 template <typename Scalar>
-struct alignas(128) ThreadResult {
+struct ThreadResult {
   int64_t max_abs_ulp = 0;
   Scalar max_ulp_at = Scalar(0);
   Scalar max_ulp_eigen = Scalar(0);
@@ -256,41 +259,62 @@
   return diff == UINT64_MAX ? UINT64_MAX : diff + 1;
 }
 
-// Advances a scalar by n ULPs in the linear representation.
-static float advance_scalar(float x, uint64_t n) {
-  int64_t lin = scalar_to_linear(x);
-  lin += static_cast<int64_t>(n);
-  int32_t ibits;
-  if (lin < 0) {
-    ibits = static_cast<int32_t>(INT32_MIN) - static_cast<int32_t>(lin) - 1;
-  } else {
-    ibits = static_cast<int32_t>(lin);
-  }
+// ============================================================================
+// Inverse of scalar_to_linear: maps a linear integer back to a scalar.
+// ============================================================================
+
+static float linear_to_scalar(int64_t lin, float /*tag*/) {
+  int32_t ibits = static_cast<int32_t>(lin);
+  if (ibits < 0) ibits = static_cast<int32_t>(INT32_MIN) - ibits - 1;
   float result;
   std::memcpy(&result, &ibits, sizeof(result));
   return result;
 }
 
-static double advance_scalar(double x, uint64_t n) {
-  int64_t lin = scalar_to_linear(x);
-  lin += static_cast<int64_t>(n);
-  int64_t ibits;
-  if (lin < 0) {
-    ibits = static_cast<int64_t>(INT64_MIN) - lin - 1;
-  } else {
-    ibits = lin;
-  }
+static double linear_to_scalar(int64_t lin, double /*tag*/) {
+  int64_t ibits = lin;
+  if (ibits < 0) ibits = static_cast<int64_t>(INT64_MIN) - ibits - 1;
   double result;
   std::memcpy(&result, &ibits, sizeof(result));
   return result;
 }
 
 // ============================================================================
-// Worker thread: evaluates Eigen and reference over a subrange
+// Dynamic work queue: threads atomically claim chunks for load balancing
 // ============================================================================
 
 template <typename Scalar>
-static void worker(const FuncEntry<Scalar>& func, Scalar lo, Scalar hi, int batch_size, bool use_mpfr, double step_eps,
+struct WorkQueue {
+  int64_t range_hi_lin;
+  int64_t chunk_size;
+  double step_eps;
+  std::atomic<int64_t> next_lin;
+
+  void init(Scalar lo, Scalar hi, int64_t csz, double step) {
+    range_hi_lin = scalar_to_linear(hi);
+    chunk_size = csz;
+    step_eps = step;
+    next_lin.store(scalar_to_linear(lo), std::memory_order_relaxed);
+  }
+
+  // Claim the next chunk. Returns false when no work remains.
+  bool claim(Scalar& chunk_lo, Scalar& chunk_hi) {
+    int64_t lo_lin = next_lin.fetch_add(chunk_size, std::memory_order_relaxed);
+    if (lo_lin > range_hi_lin) return false;
+    int64_t hi_lin = lo_lin + chunk_size - 1;
+    if (hi_lin > range_hi_lin) hi_lin = range_hi_lin;
+    chunk_lo = linear_to_scalar(lo_lin, Scalar(0));
+    chunk_hi = linear_to_scalar(hi_lin, Scalar(0));
+    return true;
+  }
+};
+
+// ============================================================================
+// Worker thread: dynamically claims chunks from a shared work queue
+// ============================================================================
+
+template <typename Scalar>
+static void worker(const FuncEntry<Scalar>& func, WorkQueue<Scalar>& queue, int batch_size, bool use_mpfr,
                    ThreadResult<Scalar>& result) {
   using ArrayType = Eigen::Array<Scalar, Eigen::Dynamic, 1>;
   ArrayType input(batch_size);
@@ -326,29 +350,32 @@
     }
   };
 
-  int idx = 0;
-  Scalar x = lo;
-  for (;;) {
-    input[idx] = x;
-    idx++;
+  Scalar chunk_lo, chunk_hi;
+  while (queue.claim(chunk_lo, chunk_hi)) {
+    int idx = 0;
+    Scalar x = chunk_lo;
+    for (;;) {
+      input[idx] = x;
+      idx++;
 
-    if (idx == batch_size) {
-      func.eigen_eval(eigen_out, input);
-      process_batch(batch_size, input, eigen_out);
-      idx = 0;
+      if (idx == batch_size) {
+        func.eigen_eval(eigen_out, input);
+        process_batch(batch_size, input, eigen_out);
+        idx = 0;
+      }
+
+      if (x >= chunk_hi) break;
+      Scalar next = advance_by_step(x, queue.step_eps);
+      x = (next > chunk_hi) ? chunk_hi : next;
     }
 
-    if (x >= hi) break;
-    Scalar next = advance_by_step(x, step_eps);
-    x = (next > hi) ? hi : next;
-  }
-
-  // Process remaining partial batch.
-  if (idx > 0) {
-    auto partial_in = input.head(idx);
-    auto partial_eigen = eigen_out.head(idx);
-    func.eigen_eval(partial_eigen, partial_in);
-    process_batch(idx, input, eigen_out);
+    // Process remaining partial batch.  Pad unused slots with the last valid
+    // input so the full-size vectorized eval doesn't read uninitialized memory.
+    if (idx > 0) {
+      for (int i = idx; i < batch_size; i++) input[i] = input[idx - 1];
+      func.eigen_eval(eigen_out, input);
+      process_batch(idx, input, eigen_out);
+    }
   }
 
 #ifdef EIGEN_HAS_MPFR
@@ -378,8 +405,8 @@
 
 template <typename Scalar>
 static int run_test(const Options& opts) {
-  const int kDigits = std::is_same<Scalar, float>::value ? 9 : 17;
-  const char* kTypeName = std::is_same<Scalar, float>::value ? "float" : "double";
+  constexpr int kDigits = std::is_same<Scalar, float>::value ? 9 : 17;
+  constexpr const char* kTypeName = std::is_same<Scalar, float>::value ? "float" : "double";
 
   auto table = build_func_table<Scalar>();
 
@@ -424,10 +451,6 @@
   std::printf("\n");
   std::fflush(stdout);
 
-  // Split range across threads.
-  if (total_scalars > 0 && static_cast<uint64_t>(num_threads) > total_scalars) {
-    num_threads = static_cast<int>(total_scalars);
-  }
   if (num_threads < 1) num_threads = 1;
 
   // Heap-allocate each ThreadResult separately to avoid false sharing.
@@ -438,22 +461,20 @@
     results.back()->init(opts.hist_width);
   }
 
-  std::vector<std::thread> threads;
-  uint64_t scalars_per_thread = total_scalars / num_threads;
-  Scalar chunk_lo = lo;
+  // Use dynamic work distribution: threads claim small chunks from a shared
+  // queue.  This ensures even load balancing regardless of how per-value
+  // work varies across the range (e.g. log on negatives is trivial).
+  // Choose chunk_size so we get ~16 chunks per thread for good balancing.
+  int64_t chunk_size = std::max(int64_t(1), static_cast<int64_t>(total_scalars / (num_threads * 16)));
+  WorkQueue<Scalar> queue;
+  queue.init(lo, hi, chunk_size, opts.step_eps);
 
+  std::vector<std::thread> threads;
   auto start_time = std::chrono::steady_clock::now();
 
   for (int t = 0; t < num_threads; t++) {
-    Scalar chunk_hi;
-    if (t == num_threads - 1) {
-      chunk_hi = hi;
-    } else {
-      chunk_hi = advance_scalar(chunk_lo, scalars_per_thread - 1);
-    }
-    threads.emplace_back(worker<Scalar>, std::cref(*entry), chunk_lo, chunk_hi, opts.batch_size, opts.use_mpfr,
-                         opts.step_eps, std::ref(*results[t]));
-    chunk_lo = std::nextafter(chunk_hi, std::numeric_limits<Scalar>::infinity());
+    threads.emplace_back(worker<Scalar>, std::cref(*entry), std::ref(queue), opts.batch_size, opts.use_mpfr,
+                         std::ref(*results[t]));
   }
 
   for (auto& t : threads) t.join();
diff --git a/test/umeyama.cpp b/test/umeyama.cpp
index e329f91..5701da9 100644
--- a/test/umeyama.cpp
+++ b/test/umeyama.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
diff --git a/test/umfpack_support.cpp b/test/umfpack_support.cpp
index 94aa5cc..48570bb 100644
--- a/test/umfpack_support.cpp
+++ b/test/umfpack_support.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 #include "sparse_solver.h"
diff --git a/test/unalignedcount.cpp b/test/unalignedcount.cpp
index f508b1a..1bf94d4 100644
--- a/test/unalignedcount.cpp
+++ b/test/unalignedcount.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 static int nb_load;
 static int nb_loadu;
@@ -32,7 +33,31 @@
 
 #include "main.h"
 
+template <typename Scalar>
+void assignment_packet_boundaries() {
+  using VectorType = Matrix<Scalar, Dynamic, 1>;
+  constexpr int packetSize = internal::packet_traits<Scalar>::size;
+  for (Index offset = 0; offset < packetSize; ++offset) {
+    for (Index size = 0; size <= 2 * packetSize + 1; ++size) {
+      VectorType source(size), storage(size + 2 * packetSize);
+      for (Index i = 0; i < size; ++i) source(i) = Scalar(i + 1);
+      storage.setConstant(Scalar(-1));
+      Map<VectorType> destination(storage.data() + offset, size);
+      destination = source;
+      for (Index i = 0; i < size; ++i) VERIFY_IS_EQUAL(destination(i), Scalar(i + 1));
+      destination += source;
+      for (Index i = 0; i < size; ++i) VERIFY_IS_EQUAL(destination(i), Scalar(2 * (i + 1)));
+      destination -= source;
+      for (Index i = 0; i < size; ++i) VERIFY_IS_EQUAL(destination(i), Scalar(i + 1));
+      for (Index i = 0; i < offset; ++i) VERIFY_IS_EQUAL(storage(i), Scalar(-1));
+      for (Index i = offset + size; i < storage.size(); ++i) VERIFY_IS_EQUAL(storage(i), Scalar(-1));
+    }
+  }
+}
+
 EIGEN_DECLARE_TEST(unalignedcount) {
+  CALL_SUBTEST(assignment_packet_boundaries<float>());
+  CALL_SUBTEST(assignment_packet_boundaries<double>());
 #if defined(EIGEN_VECTORIZE_AVX512)
   VectorXf a(48), b(48);
   a.fill(0);
diff --git a/test/unaryview.cpp b/test/unaryview.cpp
index 58e95d6..4f4db8b 100644
--- a/test/unaryview.cpp
+++ b/test/unaryview.cpp
@@ -6,9 +6,50 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
+#include <type_traits>
 #include "main.h"
 
+struct UnaryViewBox {
+  explicit UnaryViewBox(double v = 0.) : value(v) {}
+
+  double value;
+};
+
+namespace Eigen {
+template <>
+struct NumTraits<UnaryViewBox> : NumTraits<double> {
+  typedef UnaryViewBox Real;
+  typedef UnaryViewBox NonInteger;
+  typedef UnaryViewBox Nested;
+  enum {
+    IsComplex = 0,
+    IsInteger = 0,
+    IsSigned = 1,
+    RequireInitialization = 1,
+    ReadCost = NumTraits<double>::ReadCost,
+    AddCost = NumTraits<double>::AddCost,
+    MulCost = NumTraits<double>::MulCost
+  };
+};
+
+namespace internal {
+struct unaryview_box_ref_op {
+  EIGEN_EMPTY_STRUCT_CTOR(unaryview_box_ref_op)
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double& operator()(const UnaryViewBox& box) const {
+    return numext::real_ref(*const_cast<double*>(&box.value));
+  }
+};
+
+template <>
+struct functor_traits<unaryview_box_ref_op> {
+  enum { Cost = 0, PacketAccess = false };
+};
+}  // namespace internal
+}  // namespace Eigen
+
 template <int OuterStride, int InnerStride, typename VectorType>
 void unaryview_stride(const VectorType& m) {
   typedef typename VectorType::Scalar Scalar;
@@ -48,6 +89,39 @@
   }
 }
 
+void test_unaryview_pointer_result() {
+  struct Payload {
+    double value;
+  };
+
+  struct Holder {
+    Payload* ptr;
+  };
+
+  struct pointer_view_op {
+    Payload*& operator()(Holder& x) const { return x.ptr; }
+    Payload* const& operator()(const Holder& x) const { return x.ptr; }
+  };
+
+  Payload p0 = {0.0};
+  Payload p1 = {1.0};
+  Payload p2 = {2.0};
+
+  Eigen::Vector<Holder, 2> holders;
+  holders(0).ptr = &p0;
+  holders(1).ptr = &p1;
+
+  auto view = holders.unaryViewExpr(pointer_view_op());
+  VERIFY((std::is_same<typename Eigen::internal::traits<decltype(view)>::Scalar, Payload*>::value));
+
+  Eigen::Vector<Payload*, 2> out = view;
+  VERIFY_IS_EQUAL(out(0), &p0);
+  VERIFY_IS_EQUAL(out(1), &p1);
+
+  view(0) = &p2;
+  VERIFY_IS_EQUAL(holders(0).ptr, &p2);
+}
+
 void test_unaryview_solve() {
   // Random upper-triangular system.
   Eigen::MatrixXd A = Eigen::MatrixXd::Random(5, 5);
@@ -97,6 +171,33 @@
   //             .solve(mat_in.unaryViewExpr([&](const auto& x){ return std::real(x); }));
 }
 
+void test_unaryview_direct_access_product() {
+  typedef Matrix<UnaryViewBox, Dynamic, Dynamic> BoxMatrix;
+
+  BoxMatrix a(4, 4), b(4, 4);
+  MatrixXd a_values(4, 4), b_values(4, 4);
+
+  for (Index j = 0; j < a.cols(); ++j) {
+    for (Index i = 0; i < a.rows(); ++i) {
+      a_values(i, j) = 1. + 0.5 * i + 0.25 * j;
+      b_values(i, j) = -0.75 + 0.125 * i - 0.5 * j;
+      a(i, j).value = a_values(i, j);
+      b(i, j).value = b_values(i, j);
+    }
+  }
+
+  CwiseUnaryView<internal::unaryview_box_ref_op, BoxMatrix> a_view(a);
+  CwiseUnaryView<internal::unaryview_box_ref_op, BoxMatrix> b_view(b);
+
+  const auto& const_a_view = a_view;
+  const auto& const_b_view = b_view;
+  VERIFY_IS_EQUAL(&const_a_view.coeffRef(0, 0), &a(0, 0).value);
+  VERIFY_IS_EQUAL(&const_b_view.coeffRef(0, 0), &b(0, 0).value);
+
+  MatrixXd actual = a_view * b_view;
+  VERIFY_IS_APPROX(actual, a_values * b_values);
+}
+
 EIGEN_DECLARE_TEST(unaryviewstride) {
   CALL_SUBTEST_1((unaryview_stride<1, 2>(MatrixXf())));
   CALL_SUBTEST_1((unaryview_stride<0, 0>(MatrixXf())));
@@ -105,5 +206,7 @@
   CALL_SUBTEST_3((unaryview_stride<1, 2>(RowVectorXf())));
   CALL_SUBTEST_3((unaryview_stride<0, 0>(RowVectorXf())));
   CALL_SUBTEST_4(test_mutable_unaryview());
+  CALL_SUBTEST_4(test_unaryview_pointer_result());
   CALL_SUBTEST_4(test_unaryview_solve());
+  CALL_SUBTEST_4(test_unaryview_direct_access_product());
 }
diff --git a/test/upperbidiagonalization.cpp b/test/upperbidiagonalization.cpp
index ce4647f..cf27cfe 100644
--- a/test/upperbidiagonalization.cpp
+++ b/test/upperbidiagonalization.cpp
@@ -6,21 +6,22 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 #include <Eigen/SVD>
 
+// Verify that U * B * V^T ≈ A for the bidiagonal decomposition.
 template <typename MatrixType>
-void upperbidiag(const MatrixType& m) {
-  const Index rows = m.rows();
-  const Index cols = m.cols();
+void upperbidiag_verify(const MatrixType& a) {
+  const Index rows = a.rows();
+  const Index cols = a.cols();
 
   typedef Matrix<typename MatrixType::RealScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>
       RealMatrixType;
   typedef Matrix<typename MatrixType::Scalar, MatrixType::ColsAtCompileTime, MatrixType::RowsAtCompileTime>
       TransposeMatrixType;
 
-  MatrixType a = MatrixType::Random(rows, cols);
   internal::UpperBidiagonalization<MatrixType> ubd(a);
   RealMatrixType b(rows, cols);
   b.setZero();
@@ -31,8 +32,92 @@
   VERIFY_IS_APPROX(a.adjoint(), d);
 }
 
+// Verify the unblocked path directly.
+template <typename MatrixType>
+void upperbidiag_verify_unblocked(const MatrixType& a) {
+  const Index rows = a.rows();
+  const Index cols = a.cols();
+
+  typedef Matrix<typename MatrixType::RealScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>
+      RealMatrixType;
+
+  internal::UpperBidiagonalization<MatrixType> ubd(rows, cols);
+  ubd.computeUnblocked(a);
+  RealMatrixType b(rows, cols);
+  b.setZero();
+  b.block(0, 0, cols, cols) = ubd.bidiagonal();
+  MatrixType c = ubd.householderU() * b * ubd.householderV().adjoint();
+  VERIFY_IS_APPROX(a, c);
+}
+
+// Test with a random matrix of given dimensions.
+template <typename MatrixType>
+void upperbidiag(const MatrixType& m) {
+  MatrixType a = MatrixType::Random(m.rows(), m.cols());
+  upperbidiag_verify(a);
+}
+
+template <typename MatrixType>
+void upperbidiag_default_construct() {
+  internal::UpperBidiagonalization<MatrixType> bidiag;
+  VERIFY_IS_EQUAL(bidiag.householder().rows(),
+                  MatrixType::RowsAtCompileTime == Dynamic ? 0 : MatrixType::RowsAtCompileTime);
+  VERIFY_IS_EQUAL(bidiag.householder().cols(),
+                  MatrixType::ColsAtCompileTime == Dynamic ? 0 : MatrixType::ColsAtCompileTime);
+  VERIFY_IS_EQUAL(bidiag.bidiagonal().rows(),
+                  MatrixType::ColsAtCompileTime == Dynamic ? 0 : MatrixType::ColsAtCompileTime);
+  VERIFY_IS_EQUAL(bidiag.bidiagonal().cols(),
+                  MatrixType::ColsAtCompileTime == Dynamic ? 0 : MatrixType::ColsAtCompileTime);
+}
+
+// Test with structured/ill-conditioned matrices.
+template <typename Scalar>
+void upperbidiag_structured(Index rows, Index cols) {
+  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
+
+  // Zero matrix.
+  {
+    MatrixType a = MatrixType::Zero(rows, cols);
+    upperbidiag_verify(a);
+  }
+
+  // Identity (padded if non-square).
+  {
+    MatrixType a = MatrixType::Zero(rows, cols);
+    a.block(0, 0, cols, cols).setIdentity();
+    upperbidiag_verify(a);
+  }
+
+  // Matrix with large dynamic range (graded singular values).
+  {
+    MatrixType U = MatrixType::Random(rows, rows);
+    MatrixType V = MatrixType::Random(cols, cols);
+    // Orthogonalize via QR.
+    Eigen::HouseholderQR<MatrixType> qrU(U), qrV(V);
+    MatrixType Q_U = qrU.householderQ() * MatrixType::Identity(rows, rows);
+    MatrixType Q_V = qrV.householderQ() * MatrixType::Identity(cols, cols);
+    // Graded singular values: 1, 1e-2, 1e-4, ...
+    MatrixType sigma = MatrixType::Zero(rows, cols);
+    typedef typename NumTraits<Scalar>::Real RealScalar;
+    for (Index i = 0; i < cols; ++i) {
+      sigma(i, i) = static_cast<RealScalar>(std::pow(RealScalar(10), -RealScalar(2) * i / (cols > 1 ? cols - 1 : 1)));
+    }
+    MatrixType a = Q_U * sigma * Q_V.adjoint();
+    upperbidiag_verify(a);
+  }
+
+  // Rank-1 matrix.
+  {
+    Matrix<Scalar, Dynamic, 1> u = Matrix<Scalar, Dynamic, 1>::Random(rows);
+    Matrix<Scalar, 1, Dynamic> v = Matrix<Scalar, 1, Dynamic>::Random(cols);
+    MatrixType a = u * v;
+    upperbidiag_verify(a);
+  }
+}
+
 EIGEN_DECLARE_TEST(upperbidiagonalization) {
   for (int i = 0; i < g_repeat; i++) {
+    // Original small/fixed-size tests (unblocked path, bcols < 48).
     CALL_SUBTEST_1(upperbidiag(MatrixXf(3, 3)));
     CALL_SUBTEST_2(upperbidiag(MatrixXd(17, 12)));
     CALL_SUBTEST_3(upperbidiag(MatrixXcf(20, 20)));
@@ -40,5 +125,27 @@
     CALL_SUBTEST_5(upperbidiag(Matrix<float, 6, 4>()));
     CALL_SUBTEST_6(upperbidiag(Matrix<float, 5, 5>()));
     CALL_SUBTEST_7(upperbidiag(Matrix<double, 4, 3>()));
+
+    // Larger sizes that exercise the blocked path (bcols >= 48).
+    CALL_SUBTEST_8(upperbidiag(MatrixXf(64, 64)));
+    CALL_SUBTEST_9(upperbidiag(MatrixXd(100, 80)));
+    CALL_SUBTEST_10(upperbidiag(MatrixXd(200, 200)));
+    CALL_SUBTEST_11(upperbidiag(MatrixXf(300, 100)));
+
+    // Tall-skinny matrices.
+    CALL_SUBTEST_12(upperbidiag(MatrixXd(500, 10)));
+    CALL_SUBTEST_13(upperbidiag(MatrixXf(1000, 50)));
+
+    // Explicit unblocked path tests.
+    CALL_SUBTEST_14(upperbidiag_default_construct<MatrixXd>());
+    CALL_SUBTEST_14(upperbidiag_default_construct<Matrix3d>());
+    CALL_SUBTEST_14(upperbidiag_verify_unblocked(MatrixXf(MatrixXf::Random(10, 8))));
+    CALL_SUBTEST_14(upperbidiag_verify_unblocked(MatrixXd(MatrixXd::Random(64, 64))));
+    CALL_SUBTEST_14(upperbidiag_verify_unblocked(MatrixXd(MatrixXd::Random(100, 80))));
+
+    // Structured/ill-conditioned matrices.
+    CALL_SUBTEST_15(upperbidiag_structured<float>(20, 15));
+    CALL_SUBTEST_15(upperbidiag_structured<double>(100, 80));
+    CALL_SUBTEST_15(upperbidiag_structured<double>(200, 200));
   }
 }
diff --git a/test/vectorization_logic.cpp b/test/vectorization_logic.cpp
index 49f93fc..7f50af5 100644
--- a/test/vectorization_logic.cpp
+++ b/test/vectorization_logic.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #ifdef EIGEN_TEST_PART_1
 #define EIGEN_UNALIGNED_VECTORIZE 1
@@ -114,63 +115,40 @@
     HalfPacketSize = internal::unpacket_traits<HalfPacketType>::size
   };
   static void run() {
-    typedef Matrix<Scalar, PacketSize, 1> Vector1;
+    typedef Matrix<Scalar, PacketSize, 1> Vector1 EIGEN_UNUSED;
     typedef Matrix<Scalar, Dynamic, 1> VectorX;
     typedef Matrix<Scalar, Dynamic, Dynamic> MatrixXX;
     typedef Matrix<Scalar, PacketSize, PacketSize> Matrix11;
     typedef Matrix<Scalar, (Matrix11::Flags & RowMajorBit) ? 8 : 2 * PacketSize,
                    (Matrix11::Flags & RowMajorBit) ? 2 * PacketSize : 8>
-        Matrix22;
+        Matrix22 EIGEN_UNUSED;
     typedef Matrix<Scalar, (Matrix11::Flags & RowMajorBit) ? 16 : 4 * PacketSize,
                    (Matrix11::Flags & RowMajorBit) ? 4 * PacketSize : 16>
-        Matrix44;
+        Matrix44 EIGEN_UNUSED;
     typedef Matrix<Scalar, (Matrix11::Flags & RowMajorBit) ? 16 : 4 * PacketSize,
                    (Matrix11::Flags & RowMajorBit) ? 4 * PacketSize : 16,
                    DontAlign | EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION>
-        Matrix44u;
-    typedef Matrix<Scalar, 4 * PacketSize, 4 * PacketSize, ColMajor> Matrix44c;
-    typedef Matrix<Scalar, 4 * PacketSize, 4 * PacketSize, RowMajor> Matrix44r;
+        Matrix44u EIGEN_UNUSED;
+    typedef Matrix<Scalar, 4 * PacketSize, 4 * PacketSize, ColMajor> Matrix44c EIGEN_UNUSED;
+    typedef Matrix<Scalar, 4 * PacketSize, 4 * PacketSize, RowMajor> Matrix44r EIGEN_UNUSED;
 
-    typedef Matrix<Scalar,
-                   (PacketSize == 16  ? 8
-                    : PacketSize == 8 ? 4
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 1
-                                      : /*PacketSize==1 ?*/ 1),
-                   (PacketSize == 16  ? 2
-                    : PacketSize == 8 ? 2
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 2
-                                      : /*PacketSize==1 ?*/ 1)>
-        Matrix1;
+    typedef Matrix<Scalar, (PacketSize >= 2 ? PacketSize / 2 : 1), (PacketSize >= 2 ? 2 : 1)> Matrix1;
 
-    typedef Matrix<Scalar,
-                   (PacketSize == 16  ? 8
-                    : PacketSize == 8 ? 4
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 1
-                                      : /*PacketSize==1 ?*/ 1),
-                   (PacketSize == 16  ? 2
-                    : PacketSize == 8 ? 2
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 2
-                                      : /*PacketSize==1 ?*/ 1),
+    typedef Matrix<Scalar, (PacketSize >= 2 ? PacketSize / 2 : 1), (PacketSize >= 2 ? 2 : 1),
                    DontAlign | ((Matrix1::Flags & RowMajorBit) ? RowMajor : ColMajor)>
-        Matrix1u;
+        Matrix1u EIGEN_UNUSED;
 
     // this type is made such that it can only be vectorized when viewed as a linear 1D vector
     typedef Matrix<Scalar,
-                   (PacketSize == 16  ? 4
-                    : PacketSize == 8 ? 4
+                   (PacketSize >= 8   ? 4
                     : PacketSize == 4 ? 6
                     : PacketSize == 2 ? ((Matrix11::Flags & RowMajorBit) ? 2 : 3)
                                       : /*PacketSize==1 ?*/ 1),
-                   (PacketSize == 16  ? 12
-                    : PacketSize == 8 ? 6
+                   (PacketSize >= 8   ? 3 * PacketSize / 4
                     : PacketSize == 4 ? 2
                     : PacketSize == 2 ? ((Matrix11::Flags & RowMajorBit) ? 3 : 2)
                                       : /*PacketSize==1 ?*/ 3)>
-        Matrix3;
+        Matrix3 EIGEN_UNUSED;
 
 #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
     VERIFY(test_assign(Vector1(), Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
@@ -215,18 +193,35 @@
       // Vectorization and unrolling depend on too many factors (packet size, etc.) - ignore both.
       VERIFY(test_assign(Matrix<Scalar, 17, 17>(), Matrix<Scalar, 17, 17>() + Matrix<Scalar, 17, 17>(), -1, -1));
 
-      VERIFY(test_assign(Matrix11(), Matrix11() + Matrix11(), InnerVectorizedTraversal, CompleteUnrolling));
+      // Complete unrolling is budgeted at EIGEN_UNROLLING_LIMIT * PacketSize while Matrix11 is
+      // PacketSize^2 coefficients, so the object outgrows the budget once the vector is wide and
+      // Eigen falls back to InnerUnrolling. Spell the budget out rather than assert a constant.
+      using Sum11 = decltype(Matrix11() + Matrix11());
+      constexpr int Cost11 =
+          int(internal::evaluator<Matrix11>::CoeffReadCost) + int(internal::evaluator<Sum11>::CoeffReadCost);
+      constexpr bool Unrolls11 = int(Matrix11::SizeAtCompileTime) * Cost11 <= EIGEN_UNROLLING_LIMIT * int(PacketSize);
+      VERIFY(test_assign(Matrix11(), Matrix11() + Matrix11(), InnerVectorizedTraversal,
+                         Unrolls11 ? CompleteUnrolling : InnerUnrolling));
 
-      VERIFY(test_assign(Matrix11(),
-                         Matrix<Scalar, 21, 21>().template block<PacketSize, PacketSize>(2, 3) +
-                             Matrix<Scalar, 21, 21>().template block<PacketSize, PacketSize>(3, 2),
-                         (EIGEN_UNALIGNED_VECTORIZE) ? InnerVectorizedTraversal : DefaultTraversal,
-                         CompleteUnrolling | InnerUnrolling));
+      VERIFY(
+          test_assign(Matrix11(),
+                      Matrix<Scalar, PacketSize + 5, PacketSize + 5>().template block<PacketSize, PacketSize>(2, 3) +
+                          Matrix<Scalar, PacketSize + 5, PacketSize + 5>().template block<PacketSize, PacketSize>(3, 2),
+                      (EIGEN_UNALIGNED_VECTORIZE) ? InnerVectorizedTraversal : DefaultTraversal,
+                      CompleteUnrolling | InnerUnrolling));
 
       VERIFY(test_assign(Vector1(), Matrix11() * Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
 
+      // Same budget, and a lazyProduct's coefficients are dear enough that a wide vector outgrows
+      // the inner allowance too. Assert the exact choice rather than accept any of the three.
+      using Prod11 = decltype(Matrix11().lazyProduct(Matrix11()));
+      constexpr int CostP11 =
+          int(internal::evaluator<Matrix11>::CoeffReadCost) + int(internal::evaluator<Prod11>::CoeffReadCost);
+      constexpr int BudgetP11 = EIGEN_UNROLLING_LIMIT * int(PacketSize);
       VERIFY(test_assign(Matrix11(), Matrix11().lazyProduct(Matrix11()), InnerVectorizedTraversal,
-                         InnerUnrolling + CompleteUnrolling));
+                         int(Matrix11::SizeAtCompileTime) * CostP11 <= BudgetP11        ? CompleteUnrolling
+                         : int(Matrix11::InnerSizeAtCompileTime) * CostP11 <= BudgetP11 ? InnerUnrolling
+                                                                                        : NoUnrolling));
     }
 
     VERIFY(test_redux(Vector1(), LinearVectorizedTraversal, CompleteUnrolling));
@@ -287,6 +282,34 @@
                         Matrix<Scalar, PacketSize, internal::plain_enum_min(2, PacketSize)>() *
                             Matrix<Scalar, internal::plain_enum_min(2, PacketSize), PacketSize>(),
                         InnerVectorizedTraversal, CompleteUnrolling)));
+
+    if (PacketSize > 1) {
+      // Matrix22 is column-major here, since EIGEN_DEFAULT_TO_ROW_MAJOR is #undef'd above; Matrix22r
+      // is its row-major twin, so the pair below isolates the effect of storage order alone.
+      using Matrix22r = Matrix<Scalar, 2 * PacketSize, 8, RowMajor>;
+      using VectorFlat = Matrix<Scalar, Matrix22::SizeAtCompileTime, 1>;
+      using Matrix2x16 = Matrix<Scalar, 2 * PacketSize, 16, ColMajor>;
+      VERIFY(test_assign(VectorFlat(), Matrix22().reshaped(), InnerVectorizedTraversal, -1));
+      VERIFY(test_assign(VectorFlat(), (Matrix22() + Matrix22()).reshaped(), InnerVectorizedTraversal, -1));
+      // A cross-order flat view cannot serve packets, but stays linear...
+      VERIFY(test_assign(VectorFlat(), Matrix22r().reshaped(), LinearTraversal, -1));
+      // ... and vectorizes again when the requested order follows the storage order.
+      VERIFY(test_assign(VectorFlat(), Matrix22r().template reshaped<AutoOrder>(), InnerVectorizedTraversal, -1));
+      VERIFY(test_redux(Matrix22().reshaped(), LinearVectorizedTraversal, CompleteUnrolling));
+      VERIFY(test_assign(VectorX(160), MatrixXX(10, 16).reshaped(), LinearVectorizedTraversal, NoUnrolling));
+
+      // Replicate serves packets only when the inner (storage-order) direction is not replicated.
+      VERIFY(test_assign(Matrix2x16(), Matrix22().template replicate<1, 2>(), InnerVectorizedTraversal, -1));
+      VERIFY(test_assign(MatrixXX(10, 8), MatrixXX(10, 4).template replicate<1, 2>(), SliceVectorizedTraversal,
+                         NoUnrolling));
+      // Replicating the inner direction would need wrap-around loads: scalar fallback.
+      VERIFY(test_assign(Matrix44(), Matrix2x16().template replicate<2, 1>(), DefaultTraversal, -1));
+      // A replicated vector keeps linear access even when packets are unavailable.
+      VERIFY(
+          test_assign(Matrix<Scalar, 2 * PacketSize, 1>(), Vector1().template replicate<2, 1>(), LinearTraversal, -1));
+      // Runtime factors cannot prove the inner direction intact: no packets, no linear access.
+      VERIFY(test_assign(MatrixXX(10, 8), MatrixXX(10, 4).replicate(1, 2), DefaultTraversal, NoUnrolling));
+    }
 #endif
 
     VERIFY(test_assign(MatrixXX(10, 10), MatrixXX(20, 20).block(10, 10, 2, 3), SliceVectorizedTraversal, NoUnrolling));
@@ -300,9 +323,10 @@
   static void run() {}
 };
 
-template <typename Scalar, bool Enable = !internal::is_same<
-                               typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half,
-                               typename internal::packet_traits<Scalar>::type>::value>
+template <typename Scalar,
+          bool Enable =
+              !std::is_same<typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half,
+                            typename internal::packet_traits<Scalar>::type>::value>
 struct vectorization_logic_half {
   using RealScalar = typename NumTraits<Scalar>::Real;
   typedef internal::packet_traits<Scalar> PacketTraits;
@@ -320,52 +344,29 @@
                                  ? PacketSize
                                  : (EIGEN_MIN_ALIGN_BYTES + sizeof(Scalar) - 1) / sizeof(Scalar);
 
-    typedef Matrix<Scalar, MinVSize, 1> Vector1;
+    typedef Matrix<Scalar, MinVSize, 1> Vector1 EIGEN_UNUSED;
     typedef Matrix<Scalar, MinVSize, MinVSize> Matrix11;
-    typedef Matrix<Scalar, 5 * MinVSize, 7, ColMajor> Matrix57;
-    typedef Matrix<Scalar, 3 * MinVSize, 5, ColMajor> Matrix35;
-    typedef Matrix<Scalar, 5 * MinVSize, 7, DontAlign | ColMajor> Matrix57u;
+    typedef Matrix<Scalar, 5 * MinVSize, 7, ColMajor> Matrix57 EIGEN_UNUSED;
+    typedef Matrix<Scalar, 3 * MinVSize, 5, ColMajor> Matrix35 EIGEN_UNUSED;
+    typedef Matrix<Scalar, 5 * MinVSize, 7, DontAlign | ColMajor> Matrix57u EIGEN_UNUSED;
 
-    typedef Matrix<Scalar,
-                   (PacketSize == 16  ? 8
-                    : PacketSize == 8 ? 4
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 1
-                                      : /*PacketSize==1 ?*/ 1),
-                   (PacketSize == 16  ? 2
-                    : PacketSize == 8 ? 2
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 2
-                                      : /*PacketSize==1 ?*/ 1)>
-        Matrix1;
+    typedef Matrix<Scalar, (PacketSize >= 2 ? PacketSize / 2 : 1), (PacketSize >= 2 ? 2 : 1)> Matrix1;
 
-    typedef Matrix<Scalar,
-                   (PacketSize == 16  ? 8
-                    : PacketSize == 8 ? 4
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 1
-                                      : /*PacketSize==1 ?*/ 1),
-                   (PacketSize == 16  ? 2
-                    : PacketSize == 8 ? 2
-                    : PacketSize == 4 ? 2
-                    : PacketSize == 2 ? 2
-                                      : /*PacketSize==1 ?*/ 1),
+    typedef Matrix<Scalar, (PacketSize >= 2 ? PacketSize / 2 : 1), (PacketSize >= 2 ? 2 : 1),
                    DontAlign | ((Matrix1::Flags & RowMajorBit) ? RowMajor : ColMajor)>
-        Matrix1u;
+        Matrix1u EIGEN_UNUSED;
 
     // this type is made such that it can only be vectorized when viewed as a linear 1D vector
     typedef Matrix<Scalar,
-                   (MinVSize == 16  ? 4
-                    : MinVSize == 8 ? 4
+                   (MinVSize >= 8   ? 4
                     : MinVSize == 4 ? 6
                     : MinVSize == 2 ? ((Matrix11::Flags & RowMajorBit) ? 2 : 3)
-                                    : /*PacketSize==1 ?*/ 1),
-                   (MinVSize == 16  ? 12
-                    : MinVSize == 8 ? 6
+                                    : /*MinVSize==1 ?*/ 1),
+                   (MinVSize >= 8   ? 3 * MinVSize / 4
                     : MinVSize == 4 ? 2
                     : MinVSize == 2 ? ((Matrix11::Flags & RowMajorBit) ? 3 : 2)
-                                    : /*PacketSize==1 ?*/ 3)>
-        Matrix3;
+                                    : /*MinVSize==1 ?*/ 3)>
+        Matrix3 EIGEN_UNUSED;
 
 #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
     VERIFY(test_assign(Vector1(), Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
@@ -397,23 +398,22 @@
                        CompleteUnrolling));
 
     if (PacketSize > 1) {
-      typedef Matrix<Scalar, 3, 3, ColMajor> Matrix33c;
-      VERIFY(
-          test_assign(Matrix33c().row(2), Matrix33c().row(1) + Matrix33c().row(1), LinearTraversal, CompleteUnrolling));
-
       // Unrolling depends on read costs and unroll limits, which vary - ignore.
       VERIFY(test_assign(Matrix3(), Matrix3().cwiseQuotient(Matrix3()),
                          PacketTraits::HasDiv ? LinearVectorizedTraversal : LinearTraversal, -1));
 
+      // Unrolling further depends on the linear packet width: find_assign_linear_packet
+      // may pick a full-width packet here (e.g. Packet16i on AVX-512), which scales the
+      // unrolling limit - ignore.
       VERIFY(test_assign(Matrix<Scalar, 17, 17>(), Matrix<Scalar, 17, 17>() + Matrix<Scalar, 17, 17>(),
                          sizeof(Scalar) == 16
                              ? InnerVectorizedTraversal
                              : (EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal),
-                         NoUnrolling));
+                         -1));
 
       VERIFY(test_assign(Matrix11(),
-                         Matrix<Scalar, 17, 17>().template block<MinVSize, MinVSize>(2, 3) +
-                             Matrix<Scalar, 17, 17>().template block<MinVSize, MinVSize>(8, 4),
+                         Matrix<Scalar, MinVSize + 9, MinVSize + 9>().template block<MinVSize, MinVSize>(2, 3) +
+                             Matrix<Scalar, MinVSize + 9, MinVSize + 9>().template block<MinVSize, MinVSize>(8, 4),
                          EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : DefaultTraversal,
                          InnerUnrolling + CompleteUnrolling));
 
@@ -470,31 +470,31 @@
   CALL_SUBTEST(vectorization_logic_half<std::complex<float> >::run());
   CALL_SUBTEST(vectorization_logic_half<std::complex<double> >::run());
 
+  // For backends without sub-packet types (e.g. the generic clang backend),
+  // find_best_packet may return a packet larger than the matrix, making
+  // MayLinearVectorize false in the assignment path (which requires
+  // SizeAtCompileTime >= PacketSize). The redux path has no such constraint.
   if (internal::packet_traits<float>::Vectorizable) {
-    VERIFY(test_assign(Matrix<float, 3, 3>(), Matrix<float, 3, 3>() + Matrix<float, 3, 3>(),
-                       internal::packet_traits<float>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
-                           ? LinearVectorizedTraversal
-                           : LinearTraversal,
-                       CompleteUnrolling));
+    constexpr int kFloatBestPacketSize3x3 =
+        internal::unpacket_traits<typename internal::find_best_packet<float, 9>::type>::size;
+    VERIFY(test_assign(
+        Matrix<float, 3, 3>(), Matrix<float, 3, 3>() + Matrix<float, 3, 3>(),
+        EIGEN_UNALIGNED_VECTORIZE && kFloatBestPacketSize3x3 <= 9 ? LinearVectorizedTraversal : LinearTraversal,
+        CompleteUnrolling));
 
-    VERIFY(test_redux(Matrix<float, 5, 2>(),
-                      internal::packet_traits<float>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
-                          ? LinearVectorizedTraversal
-                          : LinearTraversal,
+    VERIFY(test_redux(Matrix<float, 5, 2>(), EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,
                       CompleteUnrolling));
   }
 
   if (internal::packet_traits<double>::Vectorizable) {
-    VERIFY(test_assign(Matrix<double, 3, 3>(), Matrix<double, 3, 3>() + Matrix<double, 3, 3>(),
-                       internal::packet_traits<double>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
-                           ? LinearVectorizedTraversal
-                           : LinearTraversal,
-                       CompleteUnrolling));
+    constexpr int kDoubleBestPacketSize3x3 =
+        internal::unpacket_traits<typename internal::find_best_packet<double, 9>::type>::size;
+    VERIFY(test_assign(
+        Matrix<double, 3, 3>(), Matrix<double, 3, 3>() + Matrix<double, 3, 3>(),
+        EIGEN_UNALIGNED_VECTORIZE && kDoubleBestPacketSize3x3 <= 9 ? LinearVectorizedTraversal : LinearTraversal,
+        CompleteUnrolling));
 
-    VERIFY(test_redux(Matrix<double, 7, 3>(),
-                      internal::packet_traits<double>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
-                          ? LinearVectorizedTraversal
-                          : LinearTraversal,
+    VERIFY(test_redux(Matrix<double, 7, 3>(), EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal,
                       CompleteUnrolling));
   }
 #endif  // EIGEN_VECTORIZE
diff --git a/test/vectorwise_norm.cpp b/test/vectorwise_norm.cpp
new file mode 100644
index 0000000..71b2bd7
--- /dev/null
+++ b/test/vectorwise_norm.cpp
@@ -0,0 +1,218 @@
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+
+#define EIGEN_RUNTIME_NO_MALLOC
+#define TEST_ENABLE_TEMPORARY_TRACKING
+#include "main.h"
+#include <Eigen/Core>
+#include "CustomComplex.h"
+
+template <typename Derived>
+void check_vectorwise_norms(const DenseBase<Derived>& input) {
+  using Real = typename Derived::RealScalar;
+  const Derived& matrix = input.derived();
+  const Index rows = matrix.rows();
+  const Index cols = matrix.cols();
+  Matrix<Real, 1, Dynamic> columnSquares(cols), columnNorms(cols);
+  Matrix<Real, Dynamic, 1> rowSquares(rows), rowNorms(rows);
+
+  using ColumnNorm = decltype(matrix.colwise().squaredNorm());
+  using RowNorm = decltype(matrix.rowwise().squaredNorm());
+  STATIC_CHECK(ColumnNorm::RowsAtCompileTime == 1);
+  STATIC_CHECK(int(ColumnNorm::ColsAtCompileTime) == int(Derived::ColsAtCompileTime));
+  STATIC_CHECK(int(RowNorm::RowsAtCompileTime) == int(Derived::RowsAtCompileTime));
+  STATIC_CHECK(RowNorm::ColsAtCompileTime == 1);
+  STATIC_CHECK((internal::is_same<typename internal::traits<ColumnNorm>::XprKind,
+                                  typename internal::traits<Derived>::XprKind>::value));
+
+  internal::set_is_malloc_allowed(false);
+  columnSquares = matrix.colwise().squaredNorm();
+  rowSquares = matrix.rowwise().squaredNorm();
+  columnNorms = matrix.colwise().norm();
+  rowNorms = matrix.rowwise().norm();
+  internal::set_is_malloc_allowed(true);
+
+  for (int direction = 0; direction < 2; ++direction) {
+    const Index count = direction == 0 ? cols : rows;
+    const Index length = direction == 0 ? rows : cols;
+    for (Index k = 0; k < count; ++k) {
+      long double reference = 0;
+      for (Index i = 0; i < length; ++i) {
+        const auto value = direction == 0 ? matrix.coeff(i, k) : matrix.coeff(k, i);
+        const long double real = static_cast<long double>(numext::real(value));
+        const long double imag = static_cast<long double>(numext::imag(value));
+        reference += real * real + imag * imag;
+      }
+      const Real square = direction == 0 ? columnSquares(k) : rowSquares(k);
+      const Real norm = direction == 0 ? columnNorms(k) : rowNorms(k);
+      // FMA contraction can round coefficient access and vector reductions differently.
+      const Real coefficientSquare =
+          direction == 0 ? matrix.colwise().squaredNorm()(k) : matrix.rowwise().squaredNorm()(k);
+      const Real vectorSquare =
+          direction == 0 ? matrix.col(k).matrix().squaredNorm() : matrix.row(k).matrix().squaredNorm();
+      // Two squares and at most two additions per complex coefficient, plus sqrt rounding.
+      const long double relativeBound = (4 * length + 4) * static_cast<long double>(NumTraits<Real>::epsilon());
+      VERIFY(numext::abs(static_cast<long double>(square) - reference) <= relativeBound * reference);
+      VERIFY(numext::abs(static_cast<long double>(coefficientSquare) - reference) <= relativeBound * reference);
+      VERIFY(numext::abs(static_cast<long double>(vectorSquare) - reference) <= relativeBound * reference);
+      VERIFY(numext::abs(static_cast<long double>(norm) - numext::sqrt(reference)) <=
+             relativeBound * numext::sqrt(reference));
+    }
+  }
+}
+
+template <typename Derived>
+void check_vectorwise_norm_evaluations(const DenseBase<Derived>& input) {
+  using Scalar = typename Derived::Scalar;
+  using Real = typename Derived::RealScalar;
+  Index calls = 0;
+  const auto expression = input.derived().unaryExpr([&calls](const Scalar& value) {
+    ++calls;
+    return value;
+  });
+  using Expression = internal::remove_all_t<decltype(expression)>;
+  STATIC_CHECK((int(internal::evaluator<Expression>::Flags) & (DirectAccessBit | PacketAccessBit)) == 0);
+  Matrix<Real, 1, Dynamic> columns(input.cols());
+  Matrix<Real, Dynamic, 1> rows(input.rows());
+  const Matrix<Real, 1, Dynamic> columnSquares = input.colwise().squaredNorm();
+  const Matrix<Real, 1, Dynamic> columnNorms = input.colwise().norm();
+  const Matrix<Real, Dynamic, 1> rowSquares = input.rowwise().squaredNorm();
+  const Matrix<Real, Dynamic, 1> rowNorms = input.rowwise().norm();
+  const auto check = [&](const auto& actual, const auto& expected) {
+    VERIFY_IS_EQUAL(calls, input.size());
+    VERIFY_IS_APPROX(actual, expected);
+    calls = 0;
+  };
+  internal::set_is_malloc_allowed(false);
+  columns = expression.colwise().squaredNorm();
+  check(columns, columnSquares);
+  columns = expression.colwise().norm();
+  check(columns, columnNorms);
+  rows = expression.rowwise().squaredNorm();
+  check(rows, rowSquares);
+  rows = expression.rowwise().norm();
+  check(rows, rowNorms);
+  internal::set_is_malloc_allowed(true);
+}
+
+template <typename Scalar, int Order>
+void vectorwise_norm_layout() {
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Order>;
+  using Real = typename NumTraits<Scalar>::Real;
+  // Only complex scalars with array-oriented access use the shared squaredNorm kernel.
+  constexpr bool useVectorNorm = NumTraits<Scalar>::IsComplex && internal::complex_array_access<Scalar>::value;
+  using InnerReduction =
+      typename VectorwiseOp<const MatrixType, Order == RowMajor ? Horizontal : Vertical>::SquaredNormReturnType;
+  using InnerInput = internal::remove_all_t<decltype(std::declval<InnerReduction>().nestedExpression())>;
+  using InnerScalar = std::conditional_t<useVectorNorm, Scalar, Real>;
+  STATIC_CHECK((internal::is_same<typename InnerInput::Scalar, InnerScalar>::value));
+  using OuterReduction =
+      typename VectorwiseOp<const MatrixType, Order == RowMajor ? Vertical : Horizontal>::SquaredNormReturnType;
+  if (!NumTraits<Scalar>::IsComplex) {
+    VERIFY(bool(internal::evaluator<OuterReduction>::Flags & PacketAccessBit) ==
+           bool(internal::evaluator<MatrixType>::Flags & PacketAccessBit));
+  }
+
+  for (Index rows : {0, 1, 2, 7, 8, 9, 17}) {
+    for (Index cols : {0, 1, 3, 7, 8, 9, 19}) {
+      MatrixType matrix = MatrixType::Random(rows, cols);
+      check_vectorwise_norms(matrix);
+      check_vectorwise_norms(matrix.array());
+      check_vectorwise_norms(matrix.transpose());
+      check_vectorwise_norms(matrix + matrix);
+    }
+  }
+
+  Matrix<Scalar, 3, 5, Order> fixed = Matrix<Scalar, 3, 5, Order>::Random();
+  check_vectorwise_norms(fixed);
+  Matrix<Scalar, Dynamic, Dynamic, Order, 9, 13> bounded(7, 11);
+  bounded.setRandom();
+  check_vectorwise_norms(bounded);
+
+  MatrixType storage = MatrixType::Random(23, 29);
+  check_vectorwise_norms(storage.block(1, 2, 17, 19));
+  check_vectorwise_norm_evaluations(storage);
+  check_vectorwise_norm_evaluations(storage.array());
+  for (Index innerStride : {1, 2, 3}) {
+    const Index innerSize = Order == RowMajor ? 19 : 17;
+    const Index outerSize = Order == RowMajor ? 17 : 19;
+    const Index outerStride = innerSize * innerStride + 5;
+    Matrix<Scalar, Dynamic, 1> buffer = Matrix<Scalar, Dynamic, 1>::Random(outerSize * outerStride + 1);
+    Map<const MatrixType, Unaligned, Stride<Dynamic, Dynamic>> strided(
+        buffer.data() + 1, 17, 19, Stride<Dynamic, Dynamic>(outerStride, innerStride));
+    check_vectorwise_norms(strided);
+  }
+
+  MatrixType matrix = MatrixType::Random(17, 19);
+  const auto delayed = (matrix + matrix).colwise().squaredNorm();
+  Matrix<Real, 1, Dynamic> actual = delayed;
+  VERIFY_IS_APPROX(actual, (matrix + matrix).eval().colwise().squaredNorm());
+  MatrixType product = matrix.adjoint() * matrix;
+  Matrix<Real, 1, Dynamic> productNorms(19);
+  // The abs2 path materializes the product and its squared coefficients.
+  const int expectedTemporaries = useVectorNorm ? 1 : 2;
+  VERIFY_EVALUATION_COUNT(productNorms = (matrix.adjoint() * matrix).colwise().squaredNorm(), expectedTemporaries);
+  VERIFY_IS_APPROX(productNorms, product.colwise().squaredNorm());
+
+  matrix.setZero();
+  for (Index i = 0; i < matrix.size(); ++i) {
+    matrix.data()[i] = Scalar(-Real(0));
+  }
+  const Matrix<Real, 1, Dynamic> zeros = matrix.colwise().squaredNorm();
+  for (Index i = 0; i < zeros.size(); ++i) {
+    VERIFY_IS_EQUAL(zeros(i), Real(0));
+    VERIFY(!numext::signbit(zeros(i)));
+  }
+  matrix(3, 5) = Scalar(NumTraits<Real>::infinity());
+  VERIFY((numext::isinf)(matrix.colwise().norm()(5)));
+  VERIFY((numext::isinf)(matrix.rowwise().squaredNorm()(3)));
+  matrix(3, 5) = Scalar(NumTraits<Real>::quiet_NaN());
+  VERIFY((numext::isnan)(matrix.colwise().squaredNorm()(5)));
+  VERIFY((numext::isnan)(matrix.rowwise().norm()(3)));
+}
+
+template <typename Real, int Order>
+void vectorwise_norm_mixed_special_values() {
+  using Scalar = std::complex<Real>;
+  Matrix<Scalar, Dynamic, Dynamic, Order> matrix = Matrix<Scalar, Dynamic, Dynamic, Order>::Zero(17, 19);
+  matrix(0, 0) = Scalar(NumTraits<Real>::infinity(), Real(0));
+  matrix(1, 0) = matrix(0, 1) = Scalar(Real(0), NumTraits<Real>::quiet_NaN());
+  VERIFY((numext::isnan)(matrix.colwise().squaredNorm()(0)));
+  VERIFY((numext::isnan)(matrix.colwise().norm()(0)));
+  VERIFY((numext::isnan)(matrix.rowwise().squaredNorm()(0)));
+  VERIFY((numext::isnan)(matrix.rowwise().norm()(0)));
+}
+
+EIGEN_DECLARE_TEST(vectorwise_norm) {
+  for (int i = 0; i < g_repeat; ++i) {
+    CALL_SUBTEST_1((vectorwise_norm_layout<float, ColMajor>()));
+    CALL_SUBTEST_2((vectorwise_norm_layout<float, RowMajor>()));
+    CALL_SUBTEST_3((vectorwise_norm_layout<double, ColMajor>()));
+    CALL_SUBTEST_4((vectorwise_norm_layout<double, RowMajor>()));
+    CALL_SUBTEST_5((vectorwise_norm_layout<std::complex<float>, ColMajor>()));
+    CALL_SUBTEST_6((vectorwise_norm_layout<std::complex<float>, RowMajor>()));
+    CALL_SUBTEST_7((vectorwise_norm_layout<std::complex<double>, ColMajor>()));
+    CALL_SUBTEST_8((vectorwise_norm_layout<std::complex<double>, RowMajor>()));
+    CALL_SUBTEST_5((vectorwise_norm_mixed_special_values<float, ColMajor>()));
+    CALL_SUBTEST_6((vectorwise_norm_mixed_special_values<float, RowMajor>()));
+    CALL_SUBTEST_7((vectorwise_norm_mixed_special_values<double, ColMajor>()));
+    CALL_SUBTEST_8((vectorwise_norm_mixed_special_values<double, RowMajor>()));
+    CALL_SUBTEST_10((vectorwise_norm_layout<CustomComplex<float>, ColMajor>()));
+    CALL_SUBTEST_11((vectorwise_norm_layout<CustomComplex<float>, RowMajor>()));
+    CALL_SUBTEST_12((vectorwise_norm_layout<CustomComplex<double>, ColMajor>()));
+    CALL_SUBTEST_13((vectorwise_norm_layout<CustomComplex<double>, RowMajor>()));
+    CALL_SUBTEST_9(([] {
+      Matrix<int, 2, 2> integers;
+      integers << 3, 0, 4, 5;
+      VERIFY_IS_EQUAL(integers.colwise().squaredNorm().eval(), RowVector2i(25, 25));
+      VERIFY_IS_EQUAL(integers.transpose().rowwise().squaredNorm().eval(), Vector2i(25, 25));
+      Array<bool, 2, 2> flags;
+      flags << false, true, true, false;
+      VERIFY(flags.colwise().squaredNorm().all());
+      VERIFY(flags.rowwise().squaredNorm().all());
+      flags.setZero();
+      VERIFY(!flags.colwise().squaredNorm().any());
+      VERIFY(!flags.rowwise().squaredNorm().any());
+    }()));
+  }
+}
diff --git a/test/vectorwiseop.cpp b/test/vectorwiseop.cpp
index b30142d..dd0734d 100644
--- a/test/vectorwiseop.cpp
+++ b/test/vectorwiseop.cpp
@@ -7,10 +7,19 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #define TEST_ENABLE_TEMPORARY_TRACKING
 
 #include "main.h"
+#include <Eigen/Geometry>
+
+template <typename Scalar>
+struct broadcast_affine_op {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& lhs, const Scalar& rhs) const {
+    return lhs + Scalar(2) * rhs;
+  }
+};
 
 template <typename ArrayType>
 void vectorwiseop_array(const ArrayType& m) {
@@ -31,11 +40,13 @@
   m2 = m1;
   m2.colwise() += colvec;
   VERIFY_IS_APPROX(m2, m1.colwise() + colvec);
+  VERIFY_IS_APPROX(m2, colvec + m1.colwise());
   VERIFY_IS_APPROX(m2.col(c), m1.col(c) + colvec);
 
   m2 = m1;
   m2.rowwise() += rowvec;
   VERIFY_IS_APPROX(m2, m1.rowwise() + rowvec);
+  VERIFY_IS_APPROX(m2, rowvec + m1.rowwise());
   VERIFY_IS_APPROX(m2.row(r), m1.row(r) + rowvec);
 
   // test subtraction
@@ -53,11 +64,13 @@
   m2 = m1;
   m2.colwise() *= colvec;
   VERIFY_IS_APPROX(m2, m1.colwise() * colvec);
+  VERIFY_IS_APPROX(m2, colvec * m1.colwise());
   VERIFY_IS_APPROX(m2.col(c), m1.col(c) * colvec);
 
   m2 = m1;
   m2.rowwise() *= rowvec;
   VERIFY_IS_APPROX(m2, m1.rowwise() * rowvec);
+  VERIFY_IS_APPROX(m2, rowvec * m1.rowwise());
   VERIFY_IS_APPROX(m2.row(r), m1.row(r) * rowvec);
 
   // test quotient
@@ -71,13 +84,63 @@
   VERIFY_IS_APPROX(m2, m1.rowwise() / rowvec);
   VERIFY_IS_APPROX(m2.row(r), m1.row(r) / rowvec);
 
+  // test assignment
   m2 = m1;
-  // yes, there might be an aliasing issue there but ".rowwise() /="
-  // is supposed to evaluate " m2.colwise().sum()" into a temporary to avoid
-  // evaluating the reduction multiple times
-  if (ArrayType::RowsAtCompileTime > 2 || ArrayType::RowsAtCompileTime == Dynamic) {
-    m2.rowwise() /= m2.colwise().sum();
-    VERIFY_IS_APPROX(m2, m1.rowwise() / m1.colwise().sum());
+  m2.rowwise() = rowvec;
+  for (Index k = 0; k < rows; ++k) {
+    VERIFY_IS_APPROX(m2.row(k), rowvec);
+  }
+  m2 = m1;
+  m2.colwise() = colvec;
+  for (Index k = 0; k < cols; ++k) {
+    VERIFY_IS_APPROX(m2.col(k), colvec);
+  }
+
+  // Block rhs: nested_eval must bind by reference, not materialize.
+  {
+    ArrayType other = ArrayType::Random(rows, cols);
+    m2 = m1;
+    m2.rowwise() += other.row(0);
+    VERIFY_IS_APPROX(m2, m1.rowwise() + RowVectorType(other.row(0)));
+    m2 = m1;
+    m2.rowwise() -= other.row(0);
+    VERIFY_IS_APPROX(m2, m1.rowwise() - RowVectorType(other.row(0)));
+    m2 = m1;
+    m2.colwise() *= other.col(0);
+    VERIFY_IS_APPROX(m2, m1.colwise() * ColVectorType(other.col(0)));
+    m2 = m1;
+    m2.colwise() = other.col(0);
+    for (Index k = 0; k < cols; ++k) {
+      VERIFY_IS_APPROX(m2.col(k), ColVectorType(other.col(0)));
+    }
+  }
+
+  // Issue #1731: aliased rhs across all five compound operators (used to
+  // fail on `/=` when RowsAtCompileTime == 2).
+  m2 = m1;
+  m2.rowwise() /= m2.colwise().sum();
+  VERIFY_IS_APPROX(m2, m1.rowwise() / m1.colwise().sum());
+
+  m2 = m1;
+  m2.colwise() /= m2.rowwise().sum();
+  VERIFY_IS_APPROX(m2, m1.colwise() / m1.rowwise().sum());
+
+  m2 = m1;
+  m2.rowwise() += m2.colwise().sum();
+  VERIFY_IS_APPROX(m2, m1.rowwise() + m1.colwise().sum());
+
+  m2 = m1;
+  m2.rowwise() -= m2.colwise().sum();
+  VERIFY_IS_APPROX(m2, m1.rowwise() - m1.colwise().sum());
+
+  m2 = m1;
+  m2.rowwise() *= m2.colwise().sum();
+  VERIFY_IS_APPROX(m2, m1.rowwise() * m1.colwise().sum());
+
+  m2 = m1;
+  m2.rowwise() = m2.colwise().sum();
+  for (Index k = 0; k < rows; ++k) {
+    VERIFY_IS_APPROX(m2.row(k), m1.colwise().sum());
   }
 
   // all/any
@@ -137,11 +200,13 @@
   m2 = m1;
   m2.colwise() += colvec;
   VERIFY_IS_APPROX(m2, m1.colwise() + colvec);
+  VERIFY_IS_APPROX(m2, colvec + m1.colwise());
   VERIFY_IS_APPROX(m2.col(c), m1.col(c) + colvec);
 
   m2 = m1;
   m2.rowwise() += rowvec;
   VERIFY_IS_APPROX(m2, m1.rowwise() + rowvec);
+  VERIFY_IS_APPROX(m2, rowvec + m1.rowwise());
   VERIFY_IS_APPROX(m2.row(r), m1.row(r) + rowvec);
 
   // test subtraction
@@ -155,6 +220,38 @@
   VERIFY_IS_APPROX(m2, m1.rowwise() - rowvec);
   VERIFY_IS_APPROX(m2.row(r), m1.row(r) - rowvec);
 
+  // Block rhs: nested_eval must bind by reference, not materialize.
+  {
+    MatrixType other = MatrixType::Random(rows, cols);
+    m2 = m1;
+    m2.rowwise() += other.row(0);
+    VERIFY_IS_APPROX(m2, m1.rowwise() + RowVectorType(other.row(0)));
+    m2 = m1;
+    m2.colwise() -= other.col(0);
+    VERIFY_IS_APPROX(m2, m1.colwise() - ColVectorType(other.col(0)));
+    m2 = m1;
+    m2.colwise() = other.col(0);
+    for (Index k = 0; k < cols; ++k) {
+      VERIFY_IS_APPROX(m2.col(k), ColVectorType(other.col(0)));
+    }
+  }
+
+  // Issue #1731: aliased rhs across `=`/`+=`/`-=` on matrices (Array's
+  // `*=`/`/=` variants are exercised in vectorwiseop_array).
+  m2 = m1;
+  m2.rowwise() += m2.colwise().sum();
+  VERIFY_IS_APPROX(m2, m1.rowwise() + m1.colwise().sum());
+
+  m2 = m1;
+  m2.colwise() -= m2.rowwise().sum();
+  VERIFY_IS_APPROX(m2, m1.colwise() - m1.rowwise().sum());
+
+  m2 = m1;
+  m2.rowwise() = m2.colwise().sum();
+  for (Index k = 0; k < rows; ++k) {
+    VERIFY_IS_APPROX(m2.row(k), m1.colwise().sum());
+  }
+
   // ------ partial reductions ------
 
 #define TEST_PARTIAL_REDUX_BASIC(FUNC, ROW, COL, PREPROCESS)                              \
@@ -318,7 +415,176 @@
 
   Matrix4cd c = a.array().rowwise() * b.array().transpose();
   Matrix4cd d = a.array().rowwise() * b_real.array().transpose();
+  Matrix4cd e = b.array().transpose() * a.array().rowwise();
+  Matrix4cd f = b_real.array().transpose() * a.array().rowwise();
   VERIFY_IS_CWISE_EQUAL(c, d);
+  VERIFY_IS_CWISE_EQUAL(c, e);
+  VERIFY_IS_CWISE_EQUAL(d, f);
+}
+
+template <typename ArrayType>
+void vectorwiseop_array_extensions(const ArrayType& m) {
+  typedef typename ArrayType::Scalar Scalar;
+  typedef Array<Scalar, ArrayType::RowsAtCompileTime, 1> ColVectorType;
+  typedef Array<Scalar, 1, ArrayType::ColsAtCompileTime> RowVectorType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  ArrayType m1 = ArrayType::Random(rows, cols) + ArrayType::Constant(rows, cols, Scalar(2));
+  ArrayType expected(rows, cols);
+  ColVectorType colvec = ColVectorType::Random(rows);
+  RowVectorType rowvec = RowVectorType::Random(cols);
+  broadcast_affine_op<Scalar> op;
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = colvec - m1.col(j);
+  VERIFY_IS_APPROX(expected, colvec - m1.colwise());
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = rowvec - m1.row(i);
+  VERIFY_IS_APPROX(expected, rowvec - m1.rowwise());
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = colvec / m1.col(j);
+  VERIFY_IS_APPROX(expected, colvec / m1.colwise());
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = rowvec / m1.row(i);
+  VERIFY_IS_APPROX(expected, rowvec / m1.rowwise());
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = m1.col(j).binaryExpr(colvec, op);
+  VERIFY_IS_APPROX(expected, m1.colwise().binaryExpr(colvec, op));
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = m1.row(i).binaryExpr(rowvec, op);
+  VERIFY_IS_APPROX(expected, m1.rowwise().binaryExpr(rowvec, op));
+
+  m1 = ArrayType::Random(rows, cols);
+  m1(0, 0) = Scalar(-2);
+  m1(rows - 1, cols - 1) = Scalar(2);
+  for (Index j = 0; j < cols; ++j) expected.col(j) = m1.col(j).cwiseMin(colvec);
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMin(colvec));
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = m1.row(i).cwiseMin(rowvec);
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMin(rowvec));
+
+  expected = m1.cwiseMin(Scalar(0.25));
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMin(Scalar(0.25)));
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMin(Scalar(0.25)));
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = m1.col(j).cwiseMax(colvec);
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMax(colvec));
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = m1.row(i).cwiseMax(rowvec);
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMax(rowvec));
+
+  expected = m1.cwiseMax(Scalar(-0.25));
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMax(Scalar(-0.25)));
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMax(Scalar(-0.25)));
+}
+
+template <typename MatrixType>
+void vectorwiseop_matrix_extensions(const MatrixType& m) {
+  typedef typename MatrixType::Scalar Scalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> ColVectorType;
+  typedef Matrix<Scalar, 1, MatrixType::ColsAtCompileTime> RowVectorType;
+
+  Index rows = m.rows();
+  Index cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols), expected(rows, cols);
+  ColVectorType colvec = ColVectorType::Random(rows);
+  RowVectorType rowvec = RowVectorType::Random(cols);
+  broadcast_affine_op<Scalar> op;
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = colvec - m1.col(j);
+  VERIFY_IS_APPROX(expected, colvec - m1.colwise());
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = rowvec - m1.row(i);
+  VERIFY_IS_APPROX(expected, rowvec - m1.rowwise());
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = m1.col(j).binaryExpr(colvec, op);
+  VERIFY_IS_APPROX(expected, m1.colwise().binaryExpr(colvec, op));
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = m1.row(i).binaryExpr(rowvec, op);
+  VERIFY_IS_APPROX(expected, m1.rowwise().binaryExpr(rowvec, op));
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = m1.col(j).cwiseMin(colvec);
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMin(colvec));
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = m1.row(i).cwiseMin(rowvec);
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMin(rowvec));
+
+  expected = m1.cwiseMin(Scalar(0.25));
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMin(Scalar(0.25)));
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMin(Scalar(0.25)));
+
+  for (Index j = 0; j < cols; ++j) expected.col(j) = m1.col(j).cwiseMax(colvec);
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMax(colvec));
+
+  for (Index i = 0; i < rows; ++i) expected.row(i) = m1.row(i).cwiseMax(rowvec);
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMax(rowvec));
+
+  expected = m1.cwiseMax(Scalar(-0.25));
+  VERIFY_IS_APPROX(expected, m1.colwise().cwiseMax(Scalar(-0.25)));
+  VERIFY_IS_APPROX(expected, m1.rowwise().cwiseMax(Scalar(-0.25)));
+}
+
+void vectorwiseop_operand_order() {
+  Array<std::string, 2, 3> strings;
+  strings.setConstant("R");
+  Array<std::string, 2, 1> column;
+  column.setConstant("L");
+  Array<std::string, 1, 3> row;
+  row.setConstant("L");
+  const Array<std::string, 2, 3> column_sum = column + strings.colwise();
+  const Array<std::string, 2, 3> row_sum = row + strings.rowwise();
+  for (Index i = 0; i < strings.size(); ++i) {
+    VERIFY_IS_EQUAL(column_sum(i), std::string("LR"));
+    VERIFY_IS_EQUAL(row_sum(i), std::string("LR"));
+  }
+
+  Array<Quaterniond, 2, 3> quaternions;
+  quaternions.setConstant(Quaterniond(0, 0, 1, 0));
+  Array<Quaterniond, 2, 1> column_quaternions;
+  column_quaternions.setConstant(Quaterniond(0, 1, 0, 0));
+  Array<Quaterniond, 1, 3> row_quaternions;
+  row_quaternions.setConstant(Quaterniond(0, 1, 0, 0));
+  const Array<Quaterniond, 2, 3> column_product = column_quaternions * quaternions.colwise();
+  const Array<Quaterniond, 2, 3> row_product = row_quaternions * quaternions.rowwise();
+  const Quaterniond expected(0, 0, 0, 1);  // i*j = k, whereas j*i = -k.
+  for (Index i = 0; i < quaternions.size(); ++i) {
+    VERIFY_IS_CWISE_EQUAL(column_product(i).coeffs(), expected.coeffs());
+    VERIFY_IS_CWISE_EQUAL(row_product(i).coeffs(), expected.coeffs());
+  }
+}
+
+template <int NaNPropagation>
+void vectorwiseop_minmax_nan() {
+  const double nan = NumTraits<double>::quiet_NaN();
+  Array22d a;
+  a << nan, 2, -3, nan;
+  Array2d v;
+  v << 1, nan;
+  const Array22d min_col = a.colwise().cwiseMin<NaNPropagation>(v);
+  const Array22d max_col = a.colwise().cwiseMax<NaNPropagation>(v);
+  const Array22d min_row = a.transpose().rowwise().cwiseMin<NaNPropagation>(v.transpose());
+  const Array22d max_row = a.transpose().rowwise().cwiseMax<NaNPropagation>(v.transpose());
+  for (Index i = 0; i < 2; ++i) {
+    for (Index j = 0; j < 2; ++j) {
+      const bool a_nan = (numext::isnan)(a(i, j));
+      const bool v_nan = (numext::isnan)(v(i));
+      const bool expect_nan = NaNPropagation == PropagateNaN ? a_nan || v_nan : a_nan && v_nan;
+      VERIFY_IS_EQUAL((numext::isnan)(min_col(i, j)), expect_nan);
+      VERIFY_IS_EQUAL((numext::isnan)(max_col(i, j)), expect_nan);
+      VERIFY_IS_EQUAL((numext::isnan)(min_row(j, i)), expect_nan);
+      VERIFY_IS_EQUAL((numext::isnan)(max_row(j, i)), expect_nan);
+      if (!expect_nan) {
+        const double lo = a_nan ? v(i) : v_nan ? a(i, j) : (std::min)(a(i, j), v(i));
+        const double hi = a_nan ? v(i) : v_nan ? a(i, j) : (std::max)(a(i, j), v(i));
+        VERIFY_IS_EQUAL(min_col(i, j), lo);
+        VERIFY_IS_EQUAL(max_col(i, j), hi);
+        VERIFY_IS_EQUAL(min_row(j, i), lo);
+        VERIFY_IS_EQUAL(max_row(j, i), hi);
+      }
+    }
+  }
 }
 
 // Test partial reductions on RowMajor matrices.
@@ -369,14 +635,21 @@
 
   VERIFY_IS_APPROX(ColMajorMatrix(mc.colwise() + cv), ColMajorMatrix(mr.colwise() + cv));
   VERIFY_IS_APPROX(ColMajorMatrix(mc.rowwise() + rv), ColMajorMatrix(mr.rowwise() + rv));
+  VERIFY_IS_APPROX(ColMajorMatrix(cv + mc.colwise()), ColMajorMatrix(cv + mr.colwise()));
+  VERIFY_IS_APPROX(ColMajorMatrix(rv + mc.rowwise()), ColMajorMatrix(rv + mr.rowwise()));
   VERIFY_IS_APPROX(ColMajorMatrix(mc.colwise() - cv), ColMajorMatrix(mr.colwise() - cv));
   VERIFY_IS_APPROX(ColMajorMatrix(mc.rowwise() - rv), ColMajorMatrix(mr.rowwise() - rv));
 }
 
 EIGEN_DECLARE_TEST(vectorwiseop) {
+  CALL_SUBTEST_11(vectorwiseop_operand_order());
+  CALL_SUBTEST_11(vectorwiseop_minmax_nan<PropagateNaN>());
+  CALL_SUBTEST_11(vectorwiseop_minmax_nan<PropagateNumbers>());
   CALL_SUBTEST_1(vectorwiseop_array(Array22cd()));
   CALL_SUBTEST_2(vectorwiseop_array(Array<double, 3, 2>()));
   CALL_SUBTEST_3(vectorwiseop_array(ArrayXXf(3, 4)));
+  // Issue #1731: compile-time 2-row Array used to alias on rowwise() /= colwise().sum().
+  CALL_SUBTEST_3(vectorwiseop_array(Array<double, 2, Dynamic>(2, internal::random<int>(2, EIGEN_TEST_MAX_SIZE))));
   CALL_SUBTEST_4(vectorwiseop_matrix(Matrix4cf()));
   CALL_SUBTEST_5(vectorwiseop_matrix(Matrix4f()));
   CALL_SUBTEST_5(vectorwiseop_matrix(Vector4f()));
@@ -393,4 +666,8 @@
   CALL_SUBTEST_10(vectorwiseop_rowmajor<float>());
   CALL_SUBTEST_10(vectorwiseop_rowmajor<double>());
   CALL_SUBTEST_10(vectorwiseop_rowmajor<std::complex<float>>());
+  CALL_SUBTEST_11(vectorwiseop_array_extensions(Array<float, 3, 4>()));
+  CALL_SUBTEST_11(vectorwiseop_array_extensions(ArrayXXd(3, 4)));
+  CALL_SUBTEST_12(vectorwiseop_matrix_extensions(Matrix<float, 4, 5>()));
+  CALL_SUBTEST_12(vectorwiseop_matrix_extensions(MatrixXd(3, 4)));
 }
diff --git a/test/visitor.cpp b/test/visitor.cpp
index 0aa1f65..ce49aad 100644
--- a/test/visitor.cpp
+++ b/test/visitor.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -202,34 +203,76 @@
   }
 }
 
-template <typename Derived, bool Vectorizable>
+template <typename Derived, bool Vectorizable, bool Linear = false>
 struct TrackedVisitor {
   using Scalar = typename DenseBase<Derived>::Scalar;
   static constexpr int PacketSize = Eigen::internal::packet_traits<Scalar>::size;
   static constexpr bool RowMajor = Derived::IsRowMajor;
 
-  void init(Scalar v, Index i, Index j) { return this->operator()(v, i, j); }
+  explicit TrackedVisitor(const Derived& input) : matrix(input) {}
+
+  void init(Scalar v, Index i, Index j) {
+    ++initCalls;
+    this->operator()(v, i, j);
+  }
   template <typename Packet>
   void initpacket(Packet p, Index i, Index j) {
-    return this->packet(p, i, j);
+    ++initCalls;
+    this->packet(p, i, j);
   }
   void operator()(Scalar v, Index i, Index j) {
-    EIGEN_UNUSED_VARIABLE(v)
+    VERIFY_IS_EQUAL(v, matrix.coeff(i, j));
     visited.emplace_back(i, j);
     scalarOps++;
   }
 
   template <typename Packet>
   void packet(Packet p, Index i, Index j) {
-    EIGEN_UNUSED_VARIABLE(p)
-    for (int k = 0; k < PacketSize; k++)
+    Scalar values[PacketSize];
+    internal::pstoreu(values, p);
+    for (int k = 0; k < PacketSize; k++) {
+      VERIFY_IS_EQUAL(values[k], matrix.coeff(RowMajor ? i : i + k, RowMajor ? j + k : j));
       if (RowMajor)
         visited.emplace_back(i, j + k);
       else
         visited.emplace_back(i + k, j);
+    }
     vectorOps++;
   }
+
+  void init(Scalar v, Index index) {
+    ++initCalls;
+    this->operator()(v, index);
+  }
+  void operator()(Scalar v, Index index) {
+    VERIFY_IS_EQUAL(v, matrix.coeff(index));
+    recordIndex(index);
+    ++scalarOps;
+  }
+  template <typename Packet>
+  void initpacket(Packet p, Index index) {
+    ++initCalls;
+    this->packet(p, index);
+  }
+  template <typename Packet>
+  void packet(Packet p, Index index) {
+    Scalar values[PacketSize];
+    internal::pstoreu(values, p);
+    for (int k = 0; k < PacketSize; ++k) {
+      VERIFY_IS_EQUAL(values[k], matrix.coeff(index + k));
+      recordIndex(index + k);
+    }
+    ++vectorOps;
+  }
+  void recordIndex(Index index) {
+    const Index innerSize = RowMajor ? matrix.cols() : matrix.rows();
+    const Index inner = index % innerSize;
+    const Index outer = index / innerSize;
+    visited.emplace_back(RowMajor ? outer : inner, RowMajor ? inner : outer);
+  }
+  const Derived& matrix;
   std::vector<std::pair<Index, Index>> visited;
+  Index initCalls = 0;
   Index scalarOps = 0;
   Index vectorOps = 0;
 };
@@ -239,22 +282,42 @@
 
 template <typename T, bool Vectorizable>
 struct functor_traits<TrackedVisitor<T, Vectorizable>> {
-  enum { PacketAccess = Vectorizable, Cost = 1 };
+  static constexpr bool PacketAccess = Vectorizable;
+  static constexpr int Cost = 1;
+};
+
+template <typename T>
+struct functor_traits<TrackedVisitor<T, false>> {
+  static constexpr bool PacketAccess = false;
+  static constexpr bool LinearAccess = false;
+  static constexpr int Cost = 1;
+};
+
+template <typename T, bool Vectorizable>
+struct functor_traits<TrackedVisitor<T, Vectorizable, true>> {
+  static constexpr bool PacketAccess = Vectorizable;
+  static constexpr bool LinearAccess = true;
+  static constexpr int Cost = 1;
 };
 
 }  // namespace internal
 }  // namespace Eigen
 
-template <typename Derived, bool Vectorized>
-void checkOptimalTraversal_impl(const DenseBase<Derived>& mat) {
+template <typename Derived, bool Vectorized, bool Linear = false>
+void checkTraversal(const DenseBase<Derived>& mat) {
   using Scalar = typename DenseBase<Derived>::Scalar;
   static constexpr int PacketSize = Eigen::internal::packet_traits<Scalar>::size;
   static constexpr bool RowMajor = Derived::IsRowMajor;
-  Derived X(mat.rows(), mat.cols());
-  X.setRandom();
-  TrackedVisitor<Derived, Vectorized> visitor;
+  const Derived& X = mat.derived();
+  using Visitor = TrackedVisitor<Derived, Vectorized, Linear>;
+  using VisitImpl = Eigen::internal::visit_impl<Derived, Visitor, false>;
+  STATIC_CHECK((internal::visitor_has_linear_access<Visitor>::value == Linear));
+  STATIC_CHECK((VisitImpl::LinearAccess == (Linear && bool(internal::evaluator<Derived>::Flags & LinearAccessBit))));
+  Visitor visitor(X);
   visitor.visited.reserve(X.size());
   X.visit(visitor);
+  VERIFY_IS_EQUAL(visitor.visited.size(), static_cast<std::size_t>(X.size()));
+  VERIFY_IS_EQUAL(visitor.initCalls, X.size() == 0 ? 0 : 1);
   Index count = 0;
   for (Index j = 0; j < X.outerSize(); ++j) {
     for (Index i = 0; i < X.innerSize(); ++i) {
@@ -265,35 +328,167 @@
       ++count;
     }
   }
-  Index vectorOps = Vectorized ? ((X.innerSize() / PacketSize) * X.outerSize()) : 0;
+  Index vectorOps = VisitImpl::Vectorize ? (VisitImpl::LinearAccess ? X.size() / PacketSize
+                                                                    : (X.innerSize() / PacketSize) * X.outerSize())
+                                         : 0;
   Index scalarOps = X.size() - (vectorOps * PacketSize);
   VERIFY_IS_EQUAL(vectorOps, visitor.vectorOps);
   VERIFY_IS_EQUAL(scalarOps, visitor.scalarOps);
 }
 
+template <typename Derived, bool Vectorized, bool Linear = false>
+void checkOptimalTraversal_impl(const DenseBase<Derived>& mat) {
+  Derived matrix = Derived::Random(mat.rows(), mat.cols());
+  checkTraversal<Derived, Vectorized, Linear>(matrix);
+}
+
+template <int Options>
+void checkLinearTraversal() {
+  using MatrixType = Matrix<float, Dynamic, Dynamic, Options>;
+  constexpr int PacketSize = internal::packet_traits<float>::size;
+  using FixedMatrix =
+      Matrix<float, Options == RowMajor ? 2 : PacketSize + 1, Options == RowMajor ? PacketSize + 1 : 2, Options>;
+  using FixedVisitor = TrackedVisitor<FixedMatrix, true, true>;
+  STATIC_CHECK((internal::visit_impl<FixedMatrix, FixedVisitor, false>::Unroll));
+  checkOptimalTraversal_impl<FixedMatrix, false, true>(FixedMatrix());
+  checkOptimalTraversal_impl<FixedMatrix, true, true>(FixedMatrix());
+  checkOptimalTraversal_impl<Matrix<float, 0, 0, Options>, true, true>(Matrix<float, 0, 0, Options>());
+
+  const Index sizes[] = {0, 1, PacketSize - 1, PacketSize, PacketSize + 1, 2 * PacketSize + 1};
+  for (Index inner : sizes) {
+    const Index rows = Options == RowMajor ? 3 : inner;
+    const Index cols = Options == RowMajor ? inner : 3;
+    MatrixType matrix = MatrixType::Random(rows, cols);
+    checkTraversal<MatrixType, false, true>(matrix);
+    checkTraversal<MatrixType, true, true>(matrix);
+
+    MatrixType storage = MatrixType::Random(rows + 2, cols + 2);
+    auto block = storage.block(1, 1, rows, cols);
+    STATIC_CHECK(!(internal::evaluator<decltype(block)>::Flags & LinearAccessBit));
+    checkTraversal<decltype(block), true, true>(block);
+    checkTraversal<decltype(block), false, false>(block);
+
+    using UnalignedMap = Map<MatrixType, Unaligned>;
+    UnalignedMap unaligned(storage.data() + 1, rows, cols);
+    checkTraversal<UnalignedMap, true, true>(unaligned);
+  }
+
+  VectorXf storage = VectorXf::Random(6 * PacketSize + 4);
+  using StridedMap = Map<VectorXf, Unaligned, InnerStride<2>>;
+  StridedMap strided(storage.data(), 3 * PacketSize + 2);
+  checkTraversal<StridedMap, true, true>(strided);
+}
+
+template <typename Derived>
+void checkBooleanVisitors(const DenseBase<Derived>& matrix) {
+  using Scalar = typename Derived::Scalar;
+  Index count = 0;
+  for (Index col = 0; col < matrix.cols(); ++col)
+    for (Index row = 0; row < matrix.rows(); ++row) count += matrix(row, col) != Scalar(0);
+  VERIFY_IS_EQUAL(matrix.count(), count);
+  VERIFY_IS_EQUAL(matrix.all(), count == matrix.size());
+  VERIFY_IS_EQUAL(matrix.any(), count != 0);
+}
+
+template <typename Scalar, int Options>
+void checkBooleanVisitorTraversal() {
+  STATIC_CHECK((internal::visitor_has_linear_access<internal::all_visitor<Scalar>>::value));
+  STATIC_CHECK((internal::visitor_has_linear_access<internal::any_visitor<Scalar>>::value));
+  STATIC_CHECK((internal::visitor_has_linear_access<internal::count_visitor<Scalar>>::value));
+  constexpr int PacketSize = internal::packet_traits<Scalar>::size;
+  using MatrixType = Matrix<Scalar, Dynamic, Dynamic, Options>;
+  const Index sizes[] = {0, 1, PacketSize - 1, PacketSize, PacketSize + 1, 2 * PacketSize + 1};
+  for (Index inner : sizes) {
+    MatrixType matrix(Options == RowMajor ? 3 : inner, Options == RowMajor ? inner : 3);
+    for (int value = 0; value <= 1; ++value) {
+      matrix.setConstant(Scalar(value));
+      checkBooleanVisitors(matrix);
+      for (Index index = 0; index < matrix.size(); ++index) {
+        matrix(index) = Scalar(!value);
+        checkBooleanVisitors(matrix);
+        checkBooleanVisitors(matrix.block(0, 0, matrix.rows(), matrix.cols()));
+        checkBooleanVisitors(matrix.array() != Scalar(0));
+        matrix(index) = Scalar(value);
+      }
+    }
+  }
+  Matrix<Scalar, PacketSize + 1, 2, Options> fixed;
+  fixed.setOnes();
+  checkBooleanVisitors(fixed);
+  fixed(fixed.size() - 1) = Scalar(0);
+  checkBooleanVisitors(fixed);
+}
+
+template <bool Vectorize = false>
+struct CountVisitorReads {
+  Index* reads;
+  float operator()(float value) const {
+    ++*reads;
+    return value;
+  }
+  template <typename Packet>
+  Packet packetOp(const Packet& value) const {
+    *reads += internal::unpacket_traits<Packet>::size;
+    return value;
+  }
+};
+
+namespace Eigen {
+namespace internal {
+template <bool Vectorize>
+struct functor_traits<CountVisitorReads<Vectorize>> {
+  static constexpr int Cost = 1;
+  static constexpr bool PacketAccess = Vectorize;
+};
+}  // namespace internal
+}  // namespace Eigen
+
+template <int Options, bool Vectorize = false>
+void checkVisitorShortCircuit() {
+  using MatrixType = Matrix<float, Dynamic, Dynamic, Options>;
+  const Index inner = Vectorize ? 1 : 7;
+  const Index outer = 35;
+  MatrixType matrix(Options == RowMajor ? outer : inner, Options == RowMajor ? inner : outer);
+  for (Index index : {Index(0), Index(1), matrix.size() - 1}) {
+    Index reads = 0;
+    auto counted = matrix.unaryExpr(CountVisitorReads<Vectorize>{&reads});
+    for (int value = 0; value <= 1; ++value) {
+      matrix.setConstant(float(value));
+      matrix(index) = float(!value);
+      reads = 0;
+      VERIFY_IS_EQUAL(value ? counted.all() : counted.any(), !value);
+      VERIFY_IS_EQUAL(reads, index + 1);
+      reads = 0;
+      auto block = counted.block(0, 0, matrix.rows(), matrix.cols());
+      VERIFY_IS_EQUAL(value ? block.all() : block.any(), !value);
+      VERIFY_IS_EQUAL(reads, index + 1);
+    }
+  }
+}
+
 void checkOptimalTraversal() {
   using Scalar = float;
   constexpr int PacketSize = Eigen::internal::packet_traits<Scalar>::size;
   // use sizes that mix vector and scalar ops
-  constexpr int Rows = 3 * PacketSize + 1;
-  constexpr int Cols = 4 * PacketSize + 1;
+  constexpr int Rows = PacketSize + 1;
+  constexpr int Cols = 2;
   int rows = internal::random(PacketSize + 1, EIGEN_TEST_MAX_SIZE);
   int cols = internal::random(PacketSize + 1, EIGEN_TEST_MAX_SIZE);
 
   using UnrollColMajor = Matrix<Scalar, Rows, Cols, ColMajor>;
-  using UnrollRowMajor = Matrix<Scalar, Rows, Cols, RowMajor>;
+  using UnrollRowMajor = Matrix<Scalar, Cols, Rows, RowMajor>;
   using DynamicColMajor = Matrix<Scalar, Dynamic, Dynamic, ColMajor>;
   using DynamicRowMajor = Matrix<Scalar, Dynamic, Dynamic, RowMajor>;
 
   // Scalar-only visitors
   checkOptimalTraversal_impl<UnrollColMajor, false>(UnrollColMajor(Rows, Cols));
-  checkOptimalTraversal_impl<UnrollRowMajor, false>(UnrollRowMajor(Rows, Cols));
+  checkOptimalTraversal_impl<UnrollRowMajor, false>(UnrollRowMajor(Cols, Rows));
   checkOptimalTraversal_impl<DynamicColMajor, false>(DynamicColMajor(rows, cols));
   checkOptimalTraversal_impl<DynamicRowMajor, false>(DynamicRowMajor(rows, cols));
 
   // Vectorized visitors
   checkOptimalTraversal_impl<UnrollColMajor, true>(UnrollColMajor(Rows, Cols));
-  checkOptimalTraversal_impl<UnrollRowMajor, true>(UnrollRowMajor(Rows, Cols));
+  checkOptimalTraversal_impl<UnrollRowMajor, true>(UnrollRowMajor(Cols, Rows));
   checkOptimalTraversal_impl<DynamicColMajor, true>(DynamicColMajor(rows, cols));
   checkOptimalTraversal_impl<DynamicRowMajor, true>(DynamicRowMajor(rows, cols));
 
@@ -387,4 +582,17 @@
   CALL_SUBTEST_12(visitor_vec_boundary<float>());
   CALL_SUBTEST_12(visitor_vec_boundary<double>());
   CALL_SUBTEST_12(visitor_vec_boundary<int>());
+
+  CALL_SUBTEST_13(checkLinearTraversal<ColMajor>());
+  CALL_SUBTEST_13(checkLinearTraversal<RowMajor>());
+  CALL_SUBTEST_14((checkBooleanVisitorTraversal<bool, ColMajor>()));
+  CALL_SUBTEST_14((checkBooleanVisitorTraversal<bool, RowMajor>()));
+  CALL_SUBTEST_14((checkBooleanVisitorTraversal<float, ColMajor>()));
+  CALL_SUBTEST_14((checkBooleanVisitorTraversal<double, RowMajor>()));
+  CALL_SUBTEST_14((checkBooleanVisitorTraversal<int, ColMajor>()));
+  CALL_SUBTEST_14((checkBooleanVisitorTraversal<std::complex<float>, RowMajor>()));
+  CALL_SUBTEST_14(checkVisitorShortCircuit<ColMajor>());
+  CALL_SUBTEST_14(checkVisitorShortCircuit<RowMajor>());
+  CALL_SUBTEST_14((checkVisitorShortCircuit<ColMajor, true>()));
+  CALL_SUBTEST_14((checkVisitorShortCircuit<RowMajor, true>()));
 }
diff --git a/test/zerosized.cpp b/test/zerosized.cpp
index 2df2f29..3ad3a89 100644
--- a/test/zerosized.cpp
+++ b/test/zerosized.cpp
@@ -6,6 +6,7 @@
 // This Source Code Form is subject to the terms of the Mozilla
 // Public License v. 2.0. If a copy of the MPL was not distributed
 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// SPDX-License-Identifier: MPL-2.0
 
 #include "main.h"
 
@@ -79,7 +80,7 @@
   if (VectorType::SizeAtCompileTime == Dynamic || VectorType::SizeAtCompileTime == 0) {
     zeroReduction(t1);
     VERIFY(t1.size() == 0);
-    VectorType t2(DenseIndex(0));  // DenseIndex disambiguates with 0-the-null-pointer (error with gcc 4.4 and MSVC8)
+    VectorType t2(DenseIndex(0));  // Select the size constructor.
     VERIFY(t2.size() == 0);
     zeroReduction(t2);
 
diff --git a/unsupported/CMakeLists.txt b/unsupported/CMakeLists.txt
index 3904601..5312d54 100644
--- a/unsupported/CMakeLists.txt
+++ b/unsupported/CMakeLists.txt
@@ -1,11 +1,9 @@
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+
+# Backward-compatibility shell for the legacy unsupported/ tree. The real
+# content moved to ../contrib/ in Eigen 5.x; only forwarding headers remain
+# here so that existing user code with #include <unsupported/Eigen/...> keeps
+# building. Tests, docs, and benchmarks live under ../contrib/.
+
 add_subdirectory(Eigen)
-if(EIGEN_BUILD_DOC)
-  add_subdirectory(doc EXCLUDE_FROM_ALL)
-endif()
-if(EIGEN_BUILD_TESTING)
-  if(EIGEN_LEAVE_TEST_IN_ALL_TARGET)
-    add_subdirectory(test) # CTest automatic test building relies on the "all" target.
-  else()
-    add_subdirectory(test EXCLUDE_FROM_ALL)
-  endif()
-endif()
diff --git a/unsupported/Eigen/AdolcForward b/unsupported/Eigen/AdolcForward
index 7da9997..2050bb0 100644
--- a/unsupported/Eigen/AdolcForward
+++ b/unsupported/Eigen/AdolcForward
@@ -1,153 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/AdolcForward>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_ADLOC_FORWARD_MODULE_H
-#define EIGEN_ADLOC_FORWARD_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_ADOLCFORWARD_FORWARD_H
+#define EIGEN_UNSUPPORTED_ADOLCFORWARD_FORWARD_H
 
-//--------------------------------------------------------------------------------
-//
-// This file provides support for adolc's adouble type in forward mode.
-// ADOL-C is a C++ automatic differentiation library,
-// see https://projects.coin-or.org/ADOL-C for more information.
-//
-// Note that the maximal number of directions is controlled by
-// the preprocessor token NUMBER_DIRECTIONS. The default is 2.
-//
-//--------------------------------------------------------------------------------
+#include "../../contrib/Eigen/AdolcForward"  // IWYU pragma: export
 
-#define ADOLC_TAPELESS
-#ifndef NUMBER_DIRECTIONS
-#define NUMBER_DIRECTIONS 2
-#endif
-#include <adolc/adtl.h>
-
-// adolc defines some very stupid macros:
-#if defined(malloc)
-#undef malloc
-#endif
-
-#if defined(calloc)
-#undef calloc
-#endif
-
-#if defined(realloc)
-#undef realloc
-#endif
-
-#include "../../Eigen/Core"
-
-namespace Eigen {
-
-/**
- * \defgroup AdolcForward_Module Adolc forward module
- * This module provides support for adolc's adouble type in forward mode.
- * ADOL-C is a C++ automatic differentiation library,
- * see https://projects.coin-or.org/ADOL-C for more information.
- * It mainly consists in:
- *  - a struct Eigen::NumTraits<adtl::adouble> specialization
- *  - overloads of internal::* math function for adtl::adouble type.
- *
- * Note that the maximal number of directions is controlled by
- * the preprocessor token NUMBER_DIRECTIONS. The default is 2.
- *
- * \code
- * #include <unsupported/Eigen/AdolcSupport>
- * \endcode
- */
-//@{
-
-}  // namespace Eigen
-
-// Eigen's require a few additional functions which must be defined in the same namespace
-// than the custom scalar type own namespace
-namespace adtl {
-
-inline const adouble& conj(const adouble& x) { return x; }
-inline const adouble& real(const adouble& x) { return x; }
-inline adouble imag(const adouble&) { return 0.; }
-inline adouble abs(const adouble& x) { return fabs(x); }
-inline adouble abs2(const adouble& x) { return x * x; }
-
-inline bool(isinf)(const adouble& x) { return (Eigen::numext::isinf)(x.getValue()); }
-inline bool(isnan)(const adouble& x) { return (Eigen::numext::isnan)(x.getValue()); }
-
-}  // namespace adtl
-
-namespace Eigen {
-
-template <>
-struct NumTraits<adtl::adouble> : NumTraits<double> {
-  typedef adtl::adouble Real;
-  typedef adtl::adouble NonInteger;
-  typedef adtl::adouble Nested;
-  enum {
-    IsComplex = 0,
-    IsInteger = 0,
-    IsSigned = 1,
-    RequireInitialization = 1,
-    ReadCost = 1,
-    AddCost = 1,
-    MulCost = 1
-  };
-};
-
-template <typename Functor>
-class AdolcForwardJacobian : public Functor {
-  typedef adtl::adouble ActiveScalar;
-
- public:
-  AdolcForwardJacobian() : Functor() {}
-  AdolcForwardJacobian(const Functor& f) : Functor(f) {}
-
-  // forward constructors
-  template <typename T0>
-  AdolcForwardJacobian(const T0& a0) : Functor(a0) {}
-  template <typename T0, typename T1>
-  AdolcForwardJacobian(const T0& a0, const T1& a1) : Functor(a0, a1) {}
-  template <typename T0, typename T1, typename T2>
-  AdolcForwardJacobian(const T0& a0, const T1& a1, const T1& a2) : Functor(a0, a1, a2) {}
-
-  typedef typename Functor::InputType InputType;
-  typedef typename Functor::ValueType ValueType;
-  typedef typename Functor::JacobianType JacobianType;
-
-  typedef Matrix<ActiveScalar, InputType::SizeAtCompileTime, 1> ActiveInput;
-  typedef Matrix<ActiveScalar, ValueType::SizeAtCompileTime, 1> ActiveValue;
-
-  void operator()(const InputType& x, ValueType* v, JacobianType* _jac) const {
-    eigen_assert(v != 0);
-    if (!_jac) {
-      Functor::operator()(x, v);
-      return;
-    }
-
-    JacobianType& jac = *_jac;
-
-    ActiveInput ax = x.template cast<ActiveScalar>();
-    ActiveValue av(jac.rows());
-
-    for (int j = 0; j < jac.cols(); j++)
-      for (int i = 0; i < jac.cols(); i++) ax[i].setADValue(j, i == j ? 1 : 0);
-
-    Functor::operator()(ax, &av);
-
-    for (int i = 0; i < jac.rows(); i++) {
-      (*v)[i] = av[i].getValue();
-      for (int j = 0; j < jac.cols(); j++) jac.coeffRef(i, j) = av[i].getADValue(j);
-    }
-  }
-
- protected:
-};
-
-//@}
-
-}  // namespace Eigen
-
-#endif  // EIGEN_ADLOC_FORWARD_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_ADOLCFORWARD_FORWARD_H
diff --git a/unsupported/Eigen/AlignedVector3 b/unsupported/Eigen/AlignedVector3
index f2d6416..1e63deb 100644
--- a/unsupported/Eigen/AlignedVector3
+++ b/unsupported/Eigen/AlignedVector3
@@ -1,211 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/AlignedVector3>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_ALIGNED_VECTOR3_MODULE_H
-#define EIGEN_ALIGNED_VECTOR3_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_ALIGNEDVECTOR3_FORWARD_H
+#define EIGEN_UNSUPPORTED_ALIGNEDVECTOR3_FORWARD_H
 
-#include "../../Eigen/Geometry"
+#include "../../contrib/Eigen/AlignedVector3"  // IWYU pragma: export
 
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-namespace Eigen {
-
-/**
- * \defgroup AlignedVector3_Module Aligned vector3 module
- *
- * \code
- * #include <unsupported/Eigen/AlignedVector3>
- * \endcode
- */
-//@{
-
-/** \class AlignedVector3
- *
- * \brief A vectorization friendly 3D vector
- *
- * This class represents a 3D vector internally using a 4D vector
- * such that vectorization can be seamlessly enabled. Of course,
- * the same result can be achieved by directly using a 4D vector.
- * This class makes this process simpler.
- *
- */
-// TODO: Specialize Cwise.
-template <typename Scalar_>
-class AlignedVector3;
-
-namespace internal {
-template <typename Scalar_>
-struct traits<AlignedVector3<Scalar_> > : traits<Matrix<Scalar_, 3, 1, 0, 4, 1> > {};
-}  // namespace internal
-
-template <typename Scalar_>
-class AlignedVector3 : public MatrixBase<AlignedVector3<Scalar_> > {
-  typedef Matrix<Scalar_, 4, 1> CoeffType;
-  CoeffType m_coeffs;
-
- public:
-  typedef MatrixBase<AlignedVector3<Scalar_> > Base;
-  EIGEN_DENSE_PUBLIC_INTERFACE(AlignedVector3)
-  using Base::operator*;
-
-  inline Index rows() const { return 3; }
-  inline Index cols() const { return 1; }
-
-  Scalar* data() { return m_coeffs.data(); }
-  const Scalar* data() const { return m_coeffs.data(); }
-  Index innerStride() const { return 1; }
-  Index outerStride() const { return 3; }
-
-  inline const Scalar& coeff(Index row, Index col) const { return m_coeffs.coeff(row, col); }
-
-  inline Scalar& coeffRef(Index row, Index col) { return m_coeffs.coeffRef(row, col); }
-
-  inline const Scalar& coeff(Index index) const { return m_coeffs.coeff(index); }
-
-  inline Scalar& coeffRef(Index index) { return m_coeffs.coeffRef(index); }
-
-  inline AlignedVector3() {}
-
-  inline AlignedVector3(const Scalar& x, const Scalar& y, const Scalar& z) : m_coeffs(x, y, z, Scalar(0)) {}
-
-  inline AlignedVector3(const AlignedVector3& other) : Base(), m_coeffs(other.m_coeffs) {}
-
-  template <typename XprType, int Size = XprType::SizeAtCompileTime>
-  struct generic_assign_selector {};
-
-  template <typename XprType>
-  struct generic_assign_selector<XprType, 4> {
-    inline static void run(AlignedVector3& dest, const XprType& src) { dest.m_coeffs = src; }
-  };
-
-  template <typename XprType>
-  struct generic_assign_selector<XprType, 3> {
-    inline static void run(AlignedVector3& dest, const XprType& src) {
-      dest.m_coeffs.template head<3>() = src;
-      dest.m_coeffs.w() = Scalar(0);
-    }
-  };
-
-  template <typename Derived>
-  inline AlignedVector3(const MatrixBase<Derived>& other) {
-    generic_assign_selector<Derived>::run(*this, other.derived());
-  }
-
-  inline AlignedVector3& operator=(const AlignedVector3& other) {
-    m_coeffs = other.m_coeffs;
-    return *this;
-  }
-
-  template <typename Derived>
-  inline AlignedVector3& operator=(const MatrixBase<Derived>& other) {
-    generic_assign_selector<Derived>::run(*this, other.derived());
-    return *this;
-  }
-
-  inline AlignedVector3 operator+(const AlignedVector3& other) const {
-    return AlignedVector3(m_coeffs + other.m_coeffs);
-  }
-
-  inline AlignedVector3& operator+=(const AlignedVector3& other) {
-    m_coeffs += other.m_coeffs;
-    return *this;
-  }
-
-  inline AlignedVector3 operator-(const AlignedVector3& other) const {
-    return AlignedVector3(m_coeffs - other.m_coeffs);
-  }
-
-  inline AlignedVector3 operator-() const { return AlignedVector3(-m_coeffs); }
-
-  inline AlignedVector3 operator-=(const AlignedVector3& other) {
-    m_coeffs -= other.m_coeffs;
-    return *this;
-  }
-
-  inline AlignedVector3 operator*(const Scalar& s) const { return AlignedVector3(m_coeffs * s); }
-
-  inline friend AlignedVector3 operator*(const Scalar& s, const AlignedVector3& vec) {
-    return AlignedVector3(s * vec.m_coeffs);
-  }
-
-  inline AlignedVector3& operator*=(const Scalar& s) {
-    m_coeffs *= s;
-    return *this;
-  }
-
-  inline AlignedVector3 operator/(const Scalar& s) const { return AlignedVector3(m_coeffs / s); }
-
-  inline AlignedVector3& operator/=(const Scalar& s) {
-    m_coeffs /= s;
-    return *this;
-  }
-
-  inline Scalar dot(const AlignedVector3& other) const {
-    eigen_assert(m_coeffs.w() == Scalar(0));
-    eigen_assert(other.m_coeffs.w() == Scalar(0));
-    return m_coeffs.dot(other.m_coeffs);
-  }
-
-  inline void normalize() { m_coeffs /= norm(); }
-
-  inline AlignedVector3 normalized() const { return AlignedVector3(m_coeffs / norm()); }
-
-  inline Scalar sum() const {
-    eigen_assert(m_coeffs.w() == Scalar(0));
-    return m_coeffs.sum();
-  }
-
-  inline Scalar squaredNorm() const {
-    eigen_assert(m_coeffs.w() == Scalar(0));
-    return m_coeffs.squaredNorm();
-  }
-
-  inline Scalar norm() const {
-    using std::sqrt;
-    return sqrt(squaredNorm());
-  }
-
-  inline AlignedVector3 cross(const AlignedVector3& other) const {
-    return AlignedVector3(m_coeffs.cross3(other.m_coeffs));
-  }
-
-  template <typename Derived>
-  inline bool isApprox(const MatrixBase<Derived>& other,
-                       const RealScalar& eps = NumTraits<Scalar>::dummy_precision()) const {
-    return m_coeffs.template head<3>().isApprox(other, eps);
-  }
-
-  CoeffType& coeffs() { return m_coeffs; }
-  const CoeffType& coeffs() const { return m_coeffs; }
-};
-
-namespace internal {
-
-template <typename Scalar_>
-struct eval<AlignedVector3<Scalar_>, Dense> {
-  typedef const AlignedVector3<Scalar_>& type;
-};
-
-template <typename Scalar>
-struct evaluator<AlignedVector3<Scalar> > : evaluator<Matrix<Scalar, 4, 1> > {
-  typedef AlignedVector3<Scalar> XprType;
-  typedef evaluator<Matrix<Scalar, 4, 1> > Base;
-
-  evaluator(const XprType& m) : Base(m.coeffs()) {}
-};
-
-}  // namespace internal
-
-//@}
-
-}  // namespace Eigen
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_ALIGNED_VECTOR3_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_ALIGNEDVECTOR3_FORWARD_H
diff --git a/unsupported/Eigen/ArpackSupport b/unsupported/Eigen/ArpackSupport
index 3987f7c..c1f7e77 100644
--- a/unsupported/Eigen/ArpackSupport
+++ b/unsupported/Eigen/ArpackSupport
@@ -1,33 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/ArpackSupport>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_ARPACKSUPPORT_MODULE_H
-#define EIGEN_ARPACKSUPPORT_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_ARPACKSUPPORT_FORWARD_H
+#define EIGEN_UNSUPPORTED_ARPACKSUPPORT_FORWARD_H
 
-#include "../../Eigen/Core"
+#include "../../contrib/Eigen/ArpackSupport"  // IWYU pragma: export
 
-/** \defgroup ArpackSupport_Module Arpack support module
- *
- * This module provides a wrapper to Arpack, a library for sparse eigenvalue decomposition.
- *
- * \code
- * #include <Eigen/ArpackSupport>
- * \endcode
- */
-
-#include "../../Eigen/SparseCholesky"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#include "src/Eigenvalues/ArpackSelfAdjointEigenSolver.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_ARPACKSUPPORT_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_ARPACKSUPPORT_FORWARD_H
diff --git a/unsupported/Eigen/AutoDiff b/unsupported/Eigen/AutoDiff
index 0480c69..13918d2 100644
--- a/unsupported/Eigen/AutoDiff
+++ b/unsupported/Eigen/AutoDiff
@@ -1,48 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/AutoDiff>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_AUTODIFF_MODULE_H
-#define EIGEN_AUTODIFF_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_AUTODIFF_FORWARD_H
+#define EIGEN_UNSUPPORTED_AUTODIFF_FORWARD_H
 
-#include "../../Eigen/Core"
+#include "../../contrib/Eigen/AutoDiff"  // IWYU pragma: export
 
-namespace Eigen {
-
-/**
- * \defgroup AutoDiff_Module Auto Diff module
- *
- * This module features forward automatic differentation via a simple
- * templated scalar type wrapper AutoDiffScalar.
- *
- * Warning : this should NOT be confused with numerical differentiation, which
- * is a different method and has its own module in Eigen : \ref NumericalDiff_Module.
- *
- * \code
- * #include <unsupported/Eigen/AutoDiff>
- * \endcode
- */
-//@{
-
-}  // namespace Eigen
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#include "src/AutoDiff/CoherentPadOp.h"
-#include "src/AutoDiff/AutoDiffScalar.h"
-// #include "src/AutoDiff/AutoDiffVector.h"
-#include "src/AutoDiff/AutoDiffJacobian.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-namespace Eigen {
-//@}
-}
-
-#endif  // EIGEN_AUTODIFF_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_AUTODIFF_FORWARD_H
diff --git a/unsupported/Eigen/BVH b/unsupported/Eigen/BVH
index 58fb72f..c6cd8e9 100644
--- a/unsupported/Eigen/BVH
+++ b/unsupported/Eigen/BVH
@@ -1,108 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/BVH>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_BVH_MODULE_H
-#define EIGEN_BVH_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_BVH_FORWARD_H
+#define EIGEN_UNSUPPORTED_BVH_FORWARD_H
 
-#include "../../Eigen/Core"
-#include "../../Eigen/Geometry"
-#include "../../Eigen/StdVector"
-#include <algorithm>
-#include <queue>
+#include "../../contrib/Eigen/BVH"  // IWYU pragma: export
 
-namespace Eigen {
-
-/**
-  * \defgroup BVH_Module BVH module
-  * \brief This module provides generic bounding volume hierarchy algorithms
-  * and reference tree implementations.
-  *
-  *
-  * \code
-  * #include <unsupported/Eigen/BVH>
-  * \endcode
-  *
-  * A bounding volume hierarchy (BVH) can accelerate many geometric queries.  This module provides a generic
-  implementation
-  * of the two basic algorithms over a BVH: intersection of a query object against all objects in the hierarchy and
-  minimization
-  * of a function over the objects in the hierarchy.  It also provides intersection and minimization over a cartesian
-  product of
-  * two BVH's.  A BVH accelerates intersection by using the fact that if a query object does not intersect a volume,
-  then it cannot
-  * intersect any object contained in that volume.  Similarly, a BVH accelerates minimization because the minimum of a
-  function
-  * over a volume is no greater than the minimum of a function over any object contained in it.
-  *
-  * Some sample queries that can be written in terms of intersection are:
-  *   - Determine all points where a ray intersects a triangle mesh
-  *   - Given a set of points, determine which are contained in a query sphere
-  *   - Given a set of spheres, determine which contain the query point
-  *   - Given a set of disks, determine if any is completely contained in a query rectangle (represent each 2D disk as a
-  point \f$(x,y,r)\f$
-  *     in 3D and represent the rectangle as a pyramid based on the original rectangle and shrinking in the \f$r\f$
-  direction)
-  *   - Given a set of points, count how many pairs are \f$d\pm\epsilon\f$ apart (done by looking at the cartesian
-  product of the set
-  *     of points with itself)
-  *
-  * Some sample queries that can be written in terms of function minimization over a set of objects are:
-  *   - Find the intersection between a ray and a triangle mesh closest to the ray origin (function is infinite off the
-  ray)
-  *   - Given a polyline and a query point, determine the closest point on the polyline to the query
-  *   - Find the diameter of a point cloud (done by looking at the cartesian product and using negative distance as the
-  function)
-  *   - Determine how far two meshes are from colliding (this is also a cartesian product query)
-  *
-  * This implementation decouples the basic algorithms both from the type of hierarchy (and the types of the bounding
-  volumes) and
-  * from the particulars of the query.  To enable abstraction from the BVH, the BVH is required to implement a generic
-  mechanism
-  * for traversal.  To abstract from the query, the query is responsible for keeping track of results.
-  *
-  * To be used in the algorithms, a hierarchy must implement the following traversal mechanism (see KdBVH for a sample
-  implementation): \code typedef Volume  //the type of bounding volume typedef Object  //the type of object in the
-  hierarchy typedef Index   //a reference to a node in the hierarchy--typically an int or a pointer typedef
-  VolumeIterator //an iterator type over node children--returns Index typedef ObjectIterator //an iterator over object
-  (leaf) children--returns const Object & Index getRootIndex() const //returns the index of the hierarchy root const
-  Volume &getVolume(Index index) const //returns the bounding volume of the node at given index void getChildren(Index
-  index, VolumeIterator &outVBegin, VolumeIterator &outVEnd, ObjectIterator &outOBegin, ObjectIterator &outOEnd) const
-      //getChildren takes a node index and makes [outVBegin, outVEnd) range over its node children
-      //and [outOBegin, outOEnd) range over its object children
-    \endcode
-  *
-  * To use the hierarchy, call BVIntersect or BVMinimize, passing it a BVH (or two, for cartesian product) and a
-  minimizer or intersector.
-  * For an intersection query on a single BVH, the intersector encapsulates the query and must provide two functions:
-  * \code
-      bool intersectVolume(const Volume &volume) //returns true if the query intersects the volume
-      bool intersectObject(const Object &object) //returns true if the intersection search should terminate immediately
-    \endcode
-  * The guarantee that BVIntersect provides is that intersectObject will be called on every object whose bounding volume
-  * intersects the query (but possibly on other objects too) unless the search is terminated prematurely.  It is the
-  * responsibility of the intersectObject function to keep track of the results in whatever manner is appropriate.
-  * The cartesian product intersection and the BVMinimize queries are similar--see their individual documentation.
-  *
-  * The following is a simple but complete example for how to use the BVH to accelerate the search for a closest
-  red-blue point pair:
-  * \include BVH_Example.cpp
-  * Output: \verbinclude BVH_Example.out
-  */
-}
-
-//@{
-
-// IWYU pragma: begin_exports
-#include "src/BVH/BVAlgorithms.h"
-#include "src/BVH/KdBVH.h"
-// IWYU pragma: end_exports
-
-//@}
-
-#endif  // EIGEN_BVH_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_BVH_FORWARD_H
diff --git a/unsupported/Eigen/CMakeLists.txt b/unsupported/Eigen/CMakeLists.txt
index 6d3c57e..c6620e5 100644
--- a/unsupported/Eigen/CMakeLists.txt
+++ b/unsupported/Eigen/CMakeLists.txt
@@ -1,4 +1,10 @@
-set(Eigen_HEADERS
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+#
+# Forwarding shims for the legacy <unsupported/Eigen/...> include paths.
+# The actual module headers live under ../../contrib/Eigen/.
+
+set(Eigen_LegacyShim_HEADERS
   AdolcForward
   AlignedVector3
   ArpackSupport
@@ -6,6 +12,7 @@
   BVH
   EulerAngles
   FFT
+  GPU
   IterativeSolvers
   KroneckerProduct
   LevenbergMarquardt
@@ -19,16 +26,17 @@
   SparseExtra
   SpecialFunctions
   Splines
+  StructuredMatrices
   Tensor
   TensorSymmetry
   ThreadPool
   )
 
-install(FILES
-  ${Eigen_HEADERS}
-  DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen COMPONENT Devel
-  )
-
-install(DIRECTORY src DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen COMPONENT Devel FILES_MATCHING PATTERN "*.h")
+if(EIGEN_INSTALL)
+  install(FILES
+    ${Eigen_LegacyShim_HEADERS}
+    DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen COMPONENT Devel
+    )
+endif()
 
 add_subdirectory(CXX11)
diff --git a/unsupported/Eigen/CXX11/CMakeLists.txt b/unsupported/Eigen/CXX11/CMakeLists.txt
index f31b4bc..b538799 100644
--- a/unsupported/Eigen/CXX11/CMakeLists.txt
+++ b/unsupported/Eigen/CXX11/CMakeLists.txt
@@ -1,7 +1,17 @@
-# Forwarding headers for backward compatibility.
-set(Eigen_CXX11_HEADERS Tensor TensorSymmetry ThreadPool)
+# SPDX-FileCopyrightText: The Eigen Authors
+# SPDX-License-Identifier: MPL-2.0
+#
+# Forwarding shims for the legacy <unsupported/Eigen/CXX11/...> include paths.
 
-install(FILES
-  ${Eigen_CXX11_HEADERS}
-  DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/CXX11 COMPONENT Devel
+set(Eigen_LegacyShim_CXX11_HEADERS
+  Tensor
+  TensorSymmetry
+  ThreadPool
   )
+
+if(EIGEN_INSTALL)
+  install(FILES
+    ${Eigen_LegacyShim_CXX11_HEADERS}
+    DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/CXX11 COMPONENT Devel
+    )
+endif()
diff --git a/unsupported/Eigen/CXX11/Tensor b/unsupported/Eigen/CXX11/Tensor
index c80aa42..2d5fda4 100644
--- a/unsupported/Eigen/CXX11/Tensor
+++ b/unsupported/Eigen/CXX11/Tensor
@@ -1,2 +1,15 @@
-// Forwarding header for backward compatibility.
-#include "../Tensor"  // IWYU pragma: export
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x, and the CXX11/ subdirectory no longer
+// exists at the new location. New code should use
+//   #include <contrib/Eigen/Tensor>
+// directly. This shim preserves the legacy include path.
+
+// Forward every inclusion so the Tensor module can detect a newly enabled
+// backend and complete its device type.
+#include "../../../contrib/Eigen/Tensor"  // IWYU pragma: export
diff --git a/unsupported/Eigen/CXX11/TensorSymmetry b/unsupported/Eigen/CXX11/TensorSymmetry
index 5222978..0e49eba 100644
--- a/unsupported/Eigen/CXX11/TensorSymmetry
+++ b/unsupported/Eigen/CXX11/TensorSymmetry
@@ -1,2 +1,18 @@
-// Forwarding header for backward compatibility.
-#include "../TensorSymmetry"  // IWYU pragma: export
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x, and the CXX11/ subdirectory no longer
+// exists at the new location. New code should use
+//   #include <contrib/Eigen/TensorSymmetry>
+// directly. This shim preserves the legacy include path.
+
+#ifndef EIGEN_UNSUPPORTED_CXX11_TENSORSYMMETRY_FORWARD_H
+#define EIGEN_UNSUPPORTED_CXX11_TENSORSYMMETRY_FORWARD_H
+
+#include "../../../contrib/Eigen/TensorSymmetry"  // IWYU pragma: export
+
+#endif  // EIGEN_UNSUPPORTED_CXX11_TENSORSYMMETRY_FORWARD_H
diff --git a/unsupported/Eigen/CXX11/ThreadPool b/unsupported/Eigen/CXX11/ThreadPool
index c215d5f..1162513 100644
--- a/unsupported/Eigen/CXX11/ThreadPool
+++ b/unsupported/Eigen/CXX11/ThreadPool
@@ -1,2 +1,17 @@
-// Forwarding header for backward compatibility.
-#include "../ThreadPool"  // IWYU pragma: export
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: ThreadPool was promoted to a core Eigen module in
+// Eigen 5.x. New code should use
+//   #include <Eigen/ThreadPool>
+// directly. This shim preserves the legacy include path.
+
+#ifndef EIGEN_UNSUPPORTED_CXX11_THREADPOOL_FORWARD_H
+#define EIGEN_UNSUPPORTED_CXX11_THREADPOOL_FORWARD_H
+
+#include "../../../Eigen/ThreadPool"  // IWYU pragma: export
+
+#endif  // EIGEN_UNSUPPORTED_CXX11_THREADPOOL_FORWARD_H
diff --git a/unsupported/Eigen/EulerAngles b/unsupported/Eigen/EulerAngles
index e95dd81..bfba8fa 100644
--- a/unsupported/Eigen/EulerAngles
+++ b/unsupported/Eigen/EulerAngles
@@ -1,44 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/EulerAngles>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_EULERANGLES_MODULE_H
-#define EIGEN_EULERANGLES_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_EULERANGLES_FORWARD_H
+#define EIGEN_UNSUPPORTED_EULERANGLES_FORWARD_H
 
-#include "../../Eigen/Core"
-#include "../../Eigen/Geometry"
+#include "../../contrib/Eigen/EulerAngles"  // IWYU pragma: export
 
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-namespace Eigen {
-
-/**
- * \defgroup EulerAngles_Module EulerAngles module
- * \brief This module provides generic euler angles rotation.
- *
- * Euler angles are a way to represent 3D rotation.
- *
- * In order to use this module in your code, include this header:
- * \code
- * #include <unsupported/Eigen/EulerAngles>
- * \endcode
- *
- * See \ref EulerAngles for more information.
- *
- */
-
-}
-
-// IWYU pragma: begin_exports
-#include "src/EulerAngles/EulerSystem.h"
-#include "src/EulerAngles/EulerAngles.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_EULERANGLES_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_EULERANGLES_FORWARD_H
diff --git a/unsupported/Eigen/FFT b/unsupported/Eigen/FFT
index 4b7f239..3190a9d 100644
--- a/unsupported/Eigen/FFT
+++ b/unsupported/Eigen/FFT
@@ -1,430 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Mark Borgerding mark a borgerding net
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/FFT>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_FFT_MODULE_H
-#define EIGEN_FFT_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_FFT_FORWARD_H
+#define EIGEN_UNSUPPORTED_FFT_FORWARD_H
 
-#include <complex>
-#include <vector>
-#include <map>
-#include "../../Eigen/Core"
+#include "../../contrib/Eigen/FFT"  // IWYU pragma: export
 
-/**
- * \defgroup FFT_Module Fast Fourier Transform module
- *
- * \code
- * #include <unsupported/Eigen/FFT>
- * \endcode
- *
- * This module provides Fast Fourier transformation, with a configurable backend
- * implementation.
- *
- * The default implementation is based on kissfft. It is a small, free, and
- * reasonably efficient default.
- *
- * There are currently four implementation backend:
- *
- * - kissfft(https://github.com/mborgerding/kissfft) : Simple and not so fast, BSD-3-Clause.
- *   It is a mixed-radix Fast Fourier Transform based up on the principle, "Keep It Simple, Stupid."
- *   Notice that:kissfft fails to handle "atypically-sized" inputs(i.e., sizes with large factors),a workaround is using
- * fftw or pocketfft.
- * - fftw (http://www.fftw.org) : faster, GPL -- incompatible with Eigen in LGPL form, bigger code size.
- * - MKL (https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl-download.html) : fastest, free -- may be
- * incompatible with Eigen in GPL form.
- * - PocketFFT/DUCC (https://gitlab.mpcdf.mpg.de/mtr/pocketfft, https://gitlab.mpcdf.mpg.de/mtr/ducc) : faster than kissfft, BSD 3-clause.
- *   It is a heavily modified implementation of FFTPack, with the following advantages:
- *   1.strictly C++11 compliant
- *   2.more accurate twiddle factor computation
- *   3.very fast plan generation
- *   4.worst case complexity for transform sizes with large prime factors is N*log(N), because Bluestein's algorithm is
- *   According to the author, DUCC contains the "evolution" of pocketfft, though the interface is very similar.
- * used for these cases
- *
- * \section FFTDesign Design
- *
- * The following design decisions were made concerning scaling and
- * half-spectrum for real FFT.
- *
- * The intent is to facilitate generic programming and ease migrating code
- * from  Matlab/octave.
- * We think the default behavior of Eigen/FFT should favor correctness and
- * generality over speed. Of course, the caller should be able to "opt-out" from this
- * behavior and get the speed increase if they want it.
- *
- * 1) %Scaling:
- * Other libraries (FFTW,IMKL,KISSFFT)  do not perform scaling, so there
- * is a constant gain incurred after the forward&inverse transforms , so
- * IFFT(FFT(x)) = Kx;  this is done to avoid a vector-by-value multiply.
- * The downside is that algorithms that worked correctly in Matlab/octave
- * don't behave the same way once implemented in C++.
- *
- * How Eigen/FFT differs: invertible scaling is performed so IFFT( FFT(x) ) = x.
- *
- * 2) Real FFT half-spectrum
- * Other libraries use only half the frequency spectrum (plus one extra
- * sample for the Nyquist bin) for a real FFT, the other half is the
- * conjugate-symmetric of the first half.  This saves them a copy and some
- * memory.  The downside is the caller needs to have special logic for the
- * number of bins in complex vs real.
- *
- * How Eigen/FFT differs: The full spectrum is returned from the forward
- * transform.  This facilitates generic template programming by obviating
- * separate specializations for real vs complex.  On the inverse
- * transform, only half the spectrum is actually used if the output type is real.
- */
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-
-#ifdef EIGEN_FFTW_DEFAULT
-// FFTW: faster, GPL -- incompatible with Eigen in LGPL form, bigger code size
-#include <fftw3.h>
-#include "src/FFT/fftw_impl.h"
-namespace Eigen {
-// template <typename T> typedef struct internal::fftw_impl  default_fft_impl; this does not work
-template <typename T>
-struct default_fft_impl : public internal::fftw_impl<T> {};
-}  // namespace Eigen
-#elif defined EIGEN_MKL_DEFAULT
-// intel Math Kernel Library: fastest, free -- may be incompatible with Eigen in GPL form
-#include "src/FFT/imklfft_impl.h"
-namespace Eigen {
-template <typename T>
-struct default_fft_impl : public internal::imklfft::imklfft_impl<T> {};
-}  // namespace Eigen
-#elif defined EIGEN_POCKETFFT_DEFAULT
-// internal::pocketfft_impl: a heavily modified implementation of FFTPack, with many advantages.
-#include <pocketfft_hdronly.h>
-#include "src/FFT/pocketfft_impl.h"
-namespace Eigen {
-template <typename T>
-struct default_fft_impl : public internal::pocketfft_impl<T> {};
-}  // namespace Eigen
-#elif defined EIGEN_DUCCFFT_DEFAULT
-#include <ducc0/fft/fft.h>
-#include <ducc0/infra/string_utils.h>
-#include <ducc0/fft/fft.h>
-#include <ducc0/fft/fftnd_impl.h>
-#include "src/FFT/duccfft_impl.h"
-namespace Eigen {
-template <typename T>
-struct default_fft_impl : public internal::duccfft_impl<T> {};
-}  // namespace Eigen
-#else
-// internal::kissfft_impl:  small, free, reasonably efficient default, derived from kissfft
-#include "src/FFT/kissfft_impl.h"
-namespace Eigen {
-template <typename T>
-struct default_fft_impl : public internal::kissfft_impl<T> {};
-}  // namespace Eigen
-#endif
-
-// IWYU pragma: end_exports
-
-namespace Eigen {
-
-//
-template <typename T_SrcMat, typename T_FftIfc>
-struct fft_fwd_proxy;
-template <typename T_SrcMat, typename T_FftIfc>
-struct fft_inv_proxy;
-
-namespace internal {
-template <typename T_SrcMat, typename T_FftIfc>
-struct traits<fft_fwd_proxy<T_SrcMat, T_FftIfc> > {
-  typedef typename T_SrcMat::PlainObject ReturnType;
-};
-template <typename T_SrcMat, typename T_FftIfc>
-struct traits<fft_inv_proxy<T_SrcMat, T_FftIfc> > {
-  typedef typename T_SrcMat::PlainObject ReturnType;
-};
-}  // namespace internal
-
-template <typename T_SrcMat, typename T_FftIfc>
-struct fft_fwd_proxy : public ReturnByValue<fft_fwd_proxy<T_SrcMat, T_FftIfc> > {
-  typedef DenseIndex Index;
-
-  fft_fwd_proxy(const T_SrcMat& src, T_FftIfc& fft, Index nfft) : m_src(src), m_ifc(fft), m_nfft(nfft) {}
-
-  template <typename T_DestMat>
-  void evalTo(T_DestMat& dst) const;
-
-  Index rows() const { return m_src.rows(); }
-  Index cols() const { return m_src.cols(); }
-
- protected:
-  const T_SrcMat& m_src;
-  T_FftIfc& m_ifc;
-  Index m_nfft;
-};
-
-template <typename T_SrcMat, typename T_FftIfc>
-struct fft_inv_proxy : public ReturnByValue<fft_inv_proxy<T_SrcMat, T_FftIfc> > {
-  typedef DenseIndex Index;
-
-  fft_inv_proxy(const T_SrcMat& src, T_FftIfc& fft, Index nfft) : m_src(src), m_ifc(fft), m_nfft(nfft) {}
-
-  template <typename T_DestMat>
-  void evalTo(T_DestMat& dst) const;
-
-  Index rows() const { return m_src.rows(); }
-  Index cols() const { return m_src.cols(); }
-
- protected:
-  const T_SrcMat& m_src;
-  T_FftIfc& m_ifc;
-  Index m_nfft;
-};
-
-template <typename T_Scalar, typename T_Impl = default_fft_impl<T_Scalar> >
-class FFT {
- public:
-  typedef T_Impl impl_type;
-  typedef DenseIndex Index;
-  typedef typename impl_type::Scalar Scalar;
-  typedef typename impl_type::Complex Complex;
-
-  using Flag = int;
-  static constexpr Flag Default = 0;
-  static constexpr Flag Unscaled = 1;
-  static constexpr Flag HalfSpectrum = 2;
-  static constexpr Flag Speedy = 32767;
-
-  FFT(const impl_type& impl = impl_type(), Flag flags = Default) : m_impl(impl), m_flag(flags) {
-    eigen_assert((flags == Default || flags == Unscaled || flags == HalfSpectrum || flags == Speedy) &&
-                 "invalid flags argument");
-  }
-
-  inline bool HasFlag(Flag f) const { return (m_flag & (int)f) == f; }
-
-  inline void SetFlag(Flag f) { m_flag |= (int)f; }
-
-  inline void ClearFlag(Flag f) { m_flag &= (~(int)f); }
-
-  inline void fwd(Complex* dst, const Scalar* src, Index nfft) {
-    m_impl.fwd(dst, src, static_cast<int>(nfft));
-    if (HasFlag(HalfSpectrum) == false) ReflectSpectrum(dst, nfft);
-  }
-
-  inline void fwd(Complex* dst, const Complex* src, Index nfft) { m_impl.fwd(dst, src, static_cast<int>(nfft)); }
-
-#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
-    defined EIGEN_MKL_DEFAULT
-  inline void fwd2(Complex* dst, const Complex* src, int n0, int n1) { m_impl.fwd2(dst, src, n0, n1); }
-#endif
-
-  template <typename Input_>
-  inline void fwd(std::vector<Complex>& dst, const std::vector<Input_>& src) {
-    if (NumTraits<Input_>::IsComplex == 0 && HasFlag(HalfSpectrum))
-      dst.resize((src.size() >> 1) + 1);  // half the bins + Nyquist bin
-    else
-      dst.resize(src.size());
-    fwd(&dst[0], &src[0], src.size());
-  }
-
-  template <typename InputDerived, typename ComplexDerived>
-  inline void fwd(MatrixBase<ComplexDerived>& dst, const MatrixBase<InputDerived>& src, Index nfft = -1) {
-    typedef typename ComplexDerived::Scalar dst_type;
-    typedef typename InputDerived::Scalar src_type;
-    EIGEN_STATIC_ASSERT_VECTOR_ONLY(InputDerived)
-    EIGEN_STATIC_ASSERT_VECTOR_ONLY(ComplexDerived)
-    EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(ComplexDerived, InputDerived)  // size at compile-time
-    EIGEN_STATIC_ASSERT(
-        (internal::is_same<dst_type, Complex>::value),
-        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
-    EIGEN_STATIC_ASSERT(int(InputDerived::Flags) & int(ComplexDerived::Flags) & DirectAccessBit,
-                        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
-
-    if (nfft < 1) nfft = src.size();
-
-    Index dst_size = nfft;
-    if (NumTraits<src_type>::IsComplex == 0 && HasFlag(HalfSpectrum)) {
-      dst_size = (nfft >> 1) + 1;
-    }
-    dst.derived().resize(dst_size);
-
-    if (src.innerStride() != 1 || src.size() < nfft) {
-      Matrix<src_type, 1, Dynamic> tmp;
-      if (src.size() < nfft) {
-        tmp.setZero(nfft);
-        tmp.block(0, 0, src.size(), 1) = src;
-      } else {
-        tmp = src;
-      }
-      if (dst.innerStride() != 1) {
-        Matrix<dst_type, 1, Dynamic> out(1, dst_size);
-        fwd(&out[0], &tmp[0], nfft);
-        dst.derived() = out;
-      } else {
-        fwd(&dst[0], &tmp[0], nfft);
-      }
-    } else {
-      if (dst.innerStride() != 1) {
-        Matrix<dst_type, 1, Dynamic> out(1, dst_size);
-        fwd(&out[0], &src[0], nfft);
-        dst.derived() = out;
-      } else {
-        fwd(&dst[0], &src[0], nfft);
-      }
-    }
-  }
-
-  template <typename InputDerived>
-  inline fft_fwd_proxy<MatrixBase<InputDerived>, FFT<T_Scalar, T_Impl> > fwd(const MatrixBase<InputDerived>& src,
-                                                                             Index nfft = -1) {
-    return fft_fwd_proxy<MatrixBase<InputDerived>, FFT<T_Scalar, T_Impl> >(src, *this, nfft);
-  }
-
-  template <typename InputDerived>
-  inline fft_inv_proxy<MatrixBase<InputDerived>, FFT<T_Scalar, T_Impl> > inv(const MatrixBase<InputDerived>& src,
-                                                                             Index nfft = -1) {
-    return fft_inv_proxy<MatrixBase<InputDerived>, FFT<T_Scalar, T_Impl> >(src, *this, nfft);
-  }
-
-  inline void inv(Complex* dst, const Complex* src, Index nfft) {
-    m_impl.inv(dst, src, static_cast<int>(nfft));
-    if (HasFlag(Unscaled) == false) scale(dst, Scalar(1. / nfft), nfft);  // scale the time series
-  }
-
-  inline void inv(Scalar* dst, const Complex* src, Index nfft) {
-    m_impl.inv(dst, src, static_cast<int>(nfft));
-    if (HasFlag(Unscaled) == false) scale(dst, Scalar(1. / nfft), nfft);  // scale the time series
-  }
-
-  template <typename OutputDerived, typename ComplexDerived>
-  inline void inv(MatrixBase<OutputDerived>& dst, const MatrixBase<ComplexDerived>& src, Index nfft = -1) {
-    typedef typename ComplexDerived::Scalar src_type;
-    typedef typename ComplexDerived::RealScalar real_type;
-    typedef typename OutputDerived::Scalar dst_type;
-    const bool realfft = (NumTraits<dst_type>::IsComplex == 0);
-    EIGEN_STATIC_ASSERT_VECTOR_ONLY(OutputDerived)
-    EIGEN_STATIC_ASSERT_VECTOR_ONLY(ComplexDerived)
-    EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(ComplexDerived, OutputDerived)  // size at compile-time
-    EIGEN_STATIC_ASSERT(
-        (internal::is_same<src_type, Complex>::value),
-        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
-    EIGEN_STATIC_ASSERT(int(OutputDerived::Flags) & int(ComplexDerived::Flags) & DirectAccessBit,
-                        THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
-
-    if (nfft < 1) {  // automatic FFT size determination
-      if (realfft && HasFlag(HalfSpectrum))
-        nfft = 2 * (src.size() - 1);  // assume even fft size
-      else
-        nfft = src.size();
-    }
-    dst.derived().resize(nfft);
-
-    // check for nfft that does not fit the input data size
-    Index resize_input = (realfft && HasFlag(HalfSpectrum)) ? ((nfft / 2 + 1) - src.size()) : (nfft - src.size());
-
-    if (src.innerStride() != 1 || resize_input) {
-      // if the vector is strided, then we need to copy it to a packed temporary
-      Matrix<src_type, 1, Dynamic> tmp;
-      if (resize_input) {
-        size_t ncopy = (std::min)(src.size(), src.size() + resize_input);
-        tmp.setZero(src.size() + resize_input);
-        if (realfft && HasFlag(HalfSpectrum)) {
-          // pad at the Nyquist bin
-          tmp.head(ncopy) = src.head(ncopy);
-          tmp(ncopy - 1) = real(tmp(ncopy - 1));  // enforce real-only Nyquist bin
-        } else {
-          size_t nhead, ntail;
-          nhead = 1 + ncopy / 2 - 1;  // range  [0:pi)
-          ntail = ncopy / 2 - 1;      // range (-pi:0)
-          tmp.head(nhead) = src.head(nhead);
-          tmp.tail(ntail) = src.tail(ntail);
-          if (resize_input <
-              0) {  // shrinking -- create the Nyquist bin as the average of the two bins that fold into it
-            tmp(nhead) = (src(nfft / 2) + src(src.size() - nfft / 2)) * real_type(.5);
-          } else {  // expanding -- split the old Nyquist bin into two halves
-            tmp(nhead) = src(nhead) * real_type(.5);
-            tmp(tmp.size() - nhead) = tmp(nhead);
-          }
-        }
-      } else {
-        tmp = src;
-      }
-
-      if (dst.innerStride() != 1) {
-        Matrix<dst_type, 1, Dynamic> out(1, nfft);
-        inv(&out[0], &tmp[0], nfft);
-        dst.derived() = out;
-      } else {
-        inv(&dst[0], &tmp[0], nfft);
-      }
-    } else {
-      if (dst.innerStride() != 1) {
-        Matrix<dst_type, 1, Dynamic> out(1, nfft);
-        inv(&out[0], &src[0], nfft);
-        dst.derived() = out;
-      } else {
-        inv(&dst[0], &src[0], nfft);
-      }
-    }
-  }
-
-  template <typename Output_>
-  inline void inv(std::vector<Output_>& dst, const std::vector<Complex>& src, Index nfft = -1) {
-    if (nfft < 1)
-      nfft = (NumTraits<Output_>::IsComplex == 0 && HasFlag(HalfSpectrum)) ? 2 * (src.size() - 1) : src.size();
-    dst.resize(nfft);
-    inv(&dst[0], &src[0], nfft);
-  }
-
-#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
-    defined EIGEN_MKL_DEFAULT
-  inline void inv2(Complex* dst, const Complex* src, int n0, int n1) {
-    m_impl.inv2(dst, src, n0, n1);
-    if (HasFlag(Unscaled) == false) scale(dst, Scalar(1) / (n0 * n1), n0 * n1);
-  }
-#endif
-
-  inline impl_type& impl() { return m_impl; }
-
- private:
-  template <typename T_Data>
-  inline void scale(T_Data* x, Scalar s, Index nx) {
-#if 1
-    for (int k = 0; k < nx; ++k) *x++ *= s;
-#else
-    if (((ptrdiff_t)x) & 15)
-      Matrix<T_Data, Dynamic, 1>::Map(x, nx) *= s;
-    else
-      Matrix<T_Data, Dynamic, 1>::MapAligned(x, nx) *= s;
-#endif
-  }
-
-  inline void ReflectSpectrum(Complex* freq, Index nfft) {
-    // create the implicit right-half spectrum (conjugate-mirror of the left-half)
-    Index nhbins = (nfft >> 1) + 1;
-    for (Index k = nhbins; k < nfft; ++k) freq[k] = conj(freq[nfft - k]);
-  }
-
-  impl_type m_impl;
-  int m_flag;
-};
-
-template <typename T_SrcMat, typename T_FftIfc>
-template <typename T_DestMat>
-inline void fft_fwd_proxy<T_SrcMat, T_FftIfc>::evalTo(T_DestMat& dst) const {
-  m_ifc.fwd(dst, m_src, m_nfft);
-}
-
-template <typename T_SrcMat, typename T_FftIfc>
-template <typename T_DestMat>
-inline void fft_inv_proxy<T_SrcMat, T_FftIfc>::evalTo(T_DestMat& dst) const {
-  m_ifc.inv(dst, m_src, m_nfft);
-}
-
-}  // namespace Eigen
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif
+#endif  // EIGEN_UNSUPPORTED_FFT_FORWARD_H
diff --git a/unsupported/Eigen/GPU b/unsupported/Eigen/GPU
new file mode 100644
index 0000000..e567d94
--- /dev/null
+++ b/unsupported/Eigen/GPU
@@ -0,0 +1,17 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/GPU>
+// directly. This shim preserves the legacy include path.
+
+#ifndef EIGEN_UNSUPPORTED_GPU_FORWARD_H
+#define EIGEN_UNSUPPORTED_GPU_FORWARD_H
+
+#include "../../contrib/Eigen/GPU"  // IWYU pragma: export
+
+#endif  // EIGEN_UNSUPPORTED_GPU_FORWARD_H
diff --git a/unsupported/Eigen/IterativeSolvers b/unsupported/Eigen/IterativeSolvers
index 4ae0975..8998bbe 100644
--- a/unsupported/Eigen/IterativeSolvers
+++ b/unsupported/Eigen/IterativeSolvers
@@ -1,92 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/IterativeSolvers>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_ITERATIVE_SOLVERS_MODULE_H
-#define EIGEN_ITERATIVE_SOLVERS_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_ITERATIVESOLVERS_FORWARD_H
+#define EIGEN_UNSUPPORTED_ITERATIVESOLVERS_FORWARD_H
 
-#include "../../Eigen/Sparse"
-#include "../../Eigen/Jacobi"
-#include "../../Eigen/Householder"
+#include "../../contrib/Eigen/IterativeSolvers"  // IWYU pragma: export
 
-/**
- * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
- * This module aims to provide various iterative linear and non linear solver algorithms.
- * It currently provides:
- *  - a Householder GMRES implementation
- *  - an IDR(s) implementation
- *  - a BiCGSTAB(L) implementation
- *  - a DGMRES implementation
- *  - a MINRES implementation
- *  - a IDRSTABL implementation
- *
- * Choosing the best solver for solving \c A \c x = \c b depends a lot on the preconditioner chosen as well as the
- *properties of \c A. The following flowchart might help you.
- * \dot width=50% 
- * digraph g {
- *   node [ fontname=Arial, fontsize=11];
- *   edge [ fontname=Helvetica, fontsize=10 ];
- *   A1[label="hermitian", shape="box"];
- *   A2[label="positive definite", shape="box"];
- *   CG[shape="plaintext"];
- *   A3[label="ill conditioned", shape="box"];
- *   A4[label="good preconditioner", shape="box"];
- *   A5[label="flexible preconditioner", shape="box"];
- *   A6[label="strongly indefinite", shape="box"];
- *   A8[label="large imaginary eigenvalue", shape="box"];
- *   A7[label="large imaginary eigenvalue",shape="box"];
- *
- *   SYMMLQ[shape="plaintext"];
- *   MINRES[shape="plaintext"];
- *   GCR[shape="plaintext"];
- *   GMRES[shape="plaintext"];
- *   IDRSTABL[shape="plaintext"];
- *   IDRS[shape="plaintext"];
- *   BICGSTABL[shape="plaintext"];
- *   BICGSTAB[shape="plaintext"];
- *
- *	 A1 -> A2 [label="yes"];
- *	 A2 -> CG [label="yes"];
- *	 A2 -> A3 [label="no"];
- *	 A3 -> SYMMLQ [label="yes"];
- *	 A3 -> MINRES [label="no"];
- *
- *	 A1 -> A4 [label="no"];
- *	 A4 -> A5 [label="yes"];
- *	 A5 -> GCR [label="yes"];
- *	 A5 -> GMRES [label="no"];
- *
- *	 A4 -> A6 [label="no"];
- *	 A6 -> A8 [label="yes"];
- *	 A6 -> A7 [label="no"];
- *	 A7 -> BICGSTABL [label="yes"];
- *	 A7 -> BICGSTAB [label="no"];
- *	 A8 -> IDRSTABL [label="yes"];
- *	 A8 -> IDRS [label="no"];
- * }
- * \enddot
- * \code
- * #include <unsupported/Eigen/IterativeSolvers>
- * \endcode
- */
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#include "src/IterativeSolvers/IncompleteLU.h"
-#include "src/IterativeSolvers/GMRES.h"
-#include "src/IterativeSolvers/DGMRES.h"
-#include "src/IterativeSolvers/MINRES.h"
-#include "src/IterativeSolvers/IDRS.h"
-#include "src/IterativeSolvers/BiCGSTABL.h"
-#include "src/IterativeSolvers/IDRSTABL.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_ITERATIVE_SOLVERS_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_ITERATIVESOLVERS_FORWARD_H
diff --git a/unsupported/Eigen/KroneckerProduct b/unsupported/Eigen/KroneckerProduct
index 80432ea..847612d 100644
--- a/unsupported/Eigen/KroneckerProduct
+++ b/unsupported/Eigen/KroneckerProduct
@@ -1,35 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/KroneckerProduct>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_KRONECKER_PRODUCT_MODULE_H
-#define EIGEN_KRONECKER_PRODUCT_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_KRONECKERPRODUCT_FORWARD_H
+#define EIGEN_UNSUPPORTED_KRONECKERPRODUCT_FORWARD_H
 
-#include "../../Eigen/Core"
-#include "../../Eigen/SparseCore"
+#include "../../contrib/Eigen/KroneckerProduct"  // IWYU pragma: export
 
-namespace Eigen {
-
-/**
- * \defgroup KroneckerProduct_Module KroneckerProduct module
- *
- * This module contains an experimental Kronecker product implementation.
- *
- * \code
- * #include <Eigen/KroneckerProduct>
- * \endcode
- */
-
-}  // namespace Eigen
-
-// IWYU pragma: begin_exports
-#include "src/KroneckerProduct/KroneckerTensorProduct.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_KRONECKER_PRODUCT_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_KRONECKERPRODUCT_FORWARD_H
diff --git a/unsupported/Eigen/LevenbergMarquardt b/unsupported/Eigen/LevenbergMarquardt
index 72c6da2..e0991c2 100644
--- a/unsupported/Eigen/LevenbergMarquardt
+++ b/unsupported/Eigen/LevenbergMarquardt
@@ -1,49 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/LevenbergMarquardt>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_LEVENBERGMARQUARDT_MODULE_H
-#define EIGEN_LEVENBERGMARQUARDT_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_LEVENBERGMARQUARDT_FORWARD_H
+#define EIGEN_UNSUPPORTED_LEVENBERGMARQUARDT_FORWARD_H
 
-// #include <vector>
+#include "../../contrib/Eigen/LevenbergMarquardt"  // IWYU pragma: export
 
-#include "../../Eigen/Core"
-#include "../../Eigen/Jacobi"
-#include "../../Eigen/QR"
-#include "NumericalDiff"
-
-#include "../../Eigen/SparseQR"
-
-/**
- * \defgroup LevenbergMarquardt_Module Levenberg-Marquardt module
- *
- * \code
- * #include </Eigen/LevenbergMarquardt>
- * \endcode
- *
- *
- */
-
-#include "../../Eigen/SparseCore"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-#include "src/LevenbergMarquardt/LMqrsolv.h"
-#include "src/LevenbergMarquardt/LMcovar.h"
-#include "src/LevenbergMarquardt/LMpar.h"
-#endif
-
-#include "src/LevenbergMarquardt/LevenbergMarquardt.h"
-#include "src/LevenbergMarquardt/LMonestep.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_LEVENBERGMARQUARDT_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_LEVENBERGMARQUARDT_FORWARD_H
diff --git a/unsupported/Eigen/MPRealSupport b/unsupported/Eigen/MPRealSupport
index 322ff45..526c007 100644
--- a/unsupported/Eigen/MPRealSupport
+++ b/unsupported/Eigen/MPRealSupport
@@ -1,214 +1,17 @@
-// This file is part of a joint effort between Eigen, a lightweight C++ template library
-// for linear algebra, and MPFR C++, a C++ interface to MPFR library (http://www.holoborodko.com/pavel/)
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
 //
-// Copyright (C) 2010-2012 Pavel Holoborodko <pavel@holoborodko.com>
-// Copyright (C) 2010 Konstantin Holoborodko <konstantin@holoborodko.com>
-// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/MPRealSupport>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_MPREALSUPPORT_MODULE_H
-#define EIGEN_MPREALSUPPORT_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_MPREALSUPPORT_FORWARD_H
+#define EIGEN_UNSUPPORTED_MPREALSUPPORT_FORWARD_H
 
-#include "../../Eigen/Core"
-#include <mpreal.h>
+#include "../../contrib/Eigen/MPRealSupport"  // IWYU pragma: export
 
-namespace Eigen {
-
-/**
-  * \defgroup MPRealSupport_Module MPFRC++ Support module
-  * \code
-  * #include <Eigen/MPRealSupport>
-  * \endcode
-  *
-  * This module provides support for multi precision floating point numbers
-  * via the <a href="http://www.holoborodko.com/pavel/mpfr">MPFR C++</a>
-  * library which itself is built upon <a href="http://www.mpfr.org/">MPFR</a>/<a href="http://gmplib.org/">GMP</a>.
-  *
-  * \warning MPFR C++ is licensed under the GPL.
-  *
-  * You can find a copy of MPFR C++ that is known to be compatible in the unsupported/test/mpreal folder.
-  *
-  * Here is an example:
-  *
-\code
-#include <iostream>
-#include <Eigen/MPRealSupport>
-#include <Eigen/LU>
-using namespace mpfr;
-using namespace Eigen;
-int main()
-{
-  // set precision to 256 bits (double has only 53 bits)
-  mpreal::set_default_prec(256);
-  // Declare matrix and vector types with multi-precision scalar type
-  typedef Matrix<mpreal,Dynamic,Dynamic>  MatrixXmp;
-  typedef Matrix<mpreal,Dynamic,1>        VectorXmp;
-
-  MatrixXmp A = MatrixXmp::Random(100,100);
-  VectorXmp b = VectorXmp::Random(100);
-
-  // Solve Ax=b using LU
-  VectorXmp x = A.lu().solve(b);
-  std::cout << "relative error: " << (A*x - b).norm() / b.norm() << std::endl;
-  return 0;
-}
-\endcode
-  *
-  */
-
-template <>
-struct NumTraits<mpfr::mpreal> : GenericNumTraits<mpfr::mpreal> {
-  enum {
-    IsInteger = 0,
-    IsSigned = 1,
-    IsComplex = 0,
-    RequireInitialization = 1,
-    ReadCost = HugeCost,
-    AddCost = HugeCost,
-    MulCost = HugeCost
-  };
-
-  typedef mpfr::mpreal Real;
-  typedef mpfr::mpreal NonInteger;
-
-  static inline Real highest(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::maxval(Precision); }
-  static inline Real lowest(long Precision = mpfr::mpreal::get_default_prec()) { return -mpfr::maxval(Precision); }
-
-  // Constants
-  static inline Real Pi(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::const_pi(Precision); }
-  static inline Real Euler(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::const_euler(Precision); }
-  static inline Real Log2(long Precision = mpfr::mpreal::get_default_prec()) { return mpfr::const_log2(Precision); }
-  static inline Real Catalan(long Precision = mpfr::mpreal::get_default_prec()) {
-    return mpfr::const_catalan(Precision);
-  }
-
-  static inline Real epsilon(long Precision = mpfr::mpreal::get_default_prec()) {
-    return mpfr::machine_epsilon(Precision);
-  }
-  static inline Real epsilon(const Real& x) { return mpfr::machine_epsilon(x); }
-
-#ifdef MPREAL_HAVE_DYNAMIC_STD_NUMERIC_LIMITS
-  static inline int digits10(long Precision = mpfr::mpreal::get_default_prec()) {
-    return std::numeric_limits<Real>::digits10(Precision);
-  }
-  static inline int digits10(const Real& x) { return std::numeric_limits<Real>::digits10(x); }
- 
-  static inline int max_digits10(long Precision = mpfr::mpreal::get_default_prec()) {
-    return std::numeric_limits<Real>::max_digits10(Precision);
-  }
-
-  static inline int digits() { return std::numeric_limits<Real>::digits(); }
-  static inline int digits(const Real& x) { return std::numeric_limits<Real>::digits(x); }
-#endif
-
-  static inline Real dummy_precision() {
-    mpfr_prec_t weak_prec = ((mpfr::mpreal::get_default_prec() - 1) * 90) / 100;
-    return mpfr::machine_epsilon(weak_prec);
-  }
-};
-
-namespace internal {
-
-template <>
-inline mpfr::mpreal random<mpfr::mpreal>() {
-  return mpfr::random();
-}
-
-template <>
-inline mpfr::mpreal random<mpfr::mpreal>(const mpfr::mpreal& a, const mpfr::mpreal& b) {
-  return a + (b - a) * random<mpfr::mpreal>();
-}
-
-inline bool isMuchSmallerThan(const mpfr::mpreal& a, const mpfr::mpreal& b, const mpfr::mpreal& eps) {
-  return mpfr::abs(a) <= mpfr::abs(b) * eps;
-}
-
-inline bool isApprox(const mpfr::mpreal& a, const mpfr::mpreal& b, const mpfr::mpreal& eps) {
-  return mpfr::isEqualFuzzy(a, b, eps);
-}
-
-inline bool isApproxOrLessThan(const mpfr::mpreal& a, const mpfr::mpreal& b, const mpfr::mpreal& eps) {
-  return a <= b || mpfr::isEqualFuzzy(a, b, eps);
-}
-
-template <>
-inline long double cast<mpfr::mpreal, long double>(const mpfr::mpreal& x) {
-  return x.toLDouble();
-}
-
-template <>
-inline double cast<mpfr::mpreal, double>(const mpfr::mpreal& x) {
-  return x.toDouble();
-}
-
-template <>
-inline long cast<mpfr::mpreal, long>(const mpfr::mpreal& x) {
-  return x.toLong();
-}
-
-template <>
-inline int cast<mpfr::mpreal, int>(const mpfr::mpreal& x) {
-  return int(x.toLong());
-}
-
-// Specialize GEBP kernel and traits for mpreal (no need for peeling, nor complicated stuff)
-// This also permits to directly call mpfr's routines and avoid many temporaries produced by mpreal
-template <>
-class gebp_traits<mpfr::mpreal, mpfr::mpreal, false, false> {
- public:
-  typedef mpfr::mpreal ResScalar;
-  enum {
-    Vectorizable = false,
-    LhsPacketSize = 1,
-    RhsPacketSize = 1,
-    ResPacketSize = 1,
-    NumberOfRegisters = 1,
-    nr = 1,
-    mr = 1,
-    LhsProgress = 1,
-    RhsProgress = 1
-  };
-  typedef ResScalar LhsPacket;
-  typedef ResScalar RhsPacket;
-  typedef ResScalar ResPacket;
-  typedef LhsPacket LhsPacket4Packing;
-};
-
-template <typename Index, typename DataMapper, bool ConjugateLhs, bool ConjugateRhs>
-struct gebp_kernel<mpfr::mpreal, mpfr::mpreal, Index, DataMapper, 1, 1, ConjugateLhs, ConjugateRhs> {
-  typedef mpfr::mpreal mpreal;
-
-  EIGEN_DONT_INLINE void operator()(const DataMapper& res, const mpreal* blockA, const mpreal* blockB, Index rows,
-                                    Index depth, Index cols, const mpreal& alpha, Index strideA = -1,
-                                    Index strideB = -1, Index offsetA = 0, Index offsetB = 0) {
-    if (rows == 0 || cols == 0 || depth == 0) return;
-
-    mpreal acc1(0, mpfr_get_prec(blockA[0].mpfr_srcptr())), tmp(0, mpfr_get_prec(blockA[0].mpfr_srcptr()));
-
-    if (strideA == -1) strideA = depth;
-    if (strideB == -1) strideB = depth;
-
-    for (Index i = 0; i < rows; ++i) {
-      for (Index j = 0; j < cols; ++j) {
-        const mpreal* A = blockA + i * strideA + offsetA;
-        const mpreal* B = blockB + j * strideB + offsetB;
-
-        acc1 = 0;
-        for (Index k = 0; k < depth; k++) {
-          mpfr_mul(tmp.mpfr_ptr(), A[k].mpfr_srcptr(), B[k].mpfr_srcptr(), mpreal::get_default_rnd());
-          mpfr_add(acc1.mpfr_ptr(), acc1.mpfr_ptr(), tmp.mpfr_ptr(), mpreal::get_default_rnd());
-        }
-
-        mpfr_mul(acc1.mpfr_ptr(), acc1.mpfr_srcptr(), alpha.mpfr_srcptr(), mpreal::get_default_rnd());
-        mpfr_add(res(i, j).mpfr_ptr(), res(i, j).mpfr_srcptr(), acc1.mpfr_srcptr(), mpreal::get_default_rnd());
-      }
-    }
-  }
-};
-}  // end namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_MPREALSUPPORT_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_MPREALSUPPORT_FORWARD_H
diff --git a/unsupported/Eigen/MatrixFunctions b/unsupported/Eigen/MatrixFunctions
index 845ee0b..b097a1f 100644
--- a/unsupported/Eigen/MatrixFunctions
+++ b/unsupported/Eigen/MatrixFunctions
@@ -1,504 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Jitse Niesen <jitse@maths.leeds.ac.uk>
-// Copyright (C) 2012 Chen-Pang He <jdh8@ms63.hinet.net>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/MatrixFunctions>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_MATRIX_FUNCTIONS_MODULE_H
-#define EIGEN_MATRIX_FUNCTIONS_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_MATRIXFUNCTIONS_FORWARD_H
+#define EIGEN_UNSUPPORTED_MATRIXFUNCTIONS_FORWARD_H
 
-#include <cfloat>
-#include <list>
+#include "../../contrib/Eigen/MatrixFunctions"  // IWYU pragma: export
 
-#include "../../Eigen/Core"
-#include "../../Eigen/LU"
-#include "../../Eigen/Eigenvalues"
-
-/**
- * \defgroup MatrixFunctions_Module Matrix functions module
- * \brief This module aims to provide various methods for the computation of
- * matrix functions.
- *
- * To use this module, add
- * \code
- * #include <unsupported/Eigen/MatrixFunctions>
- * \endcode
- * at the start of your source file.
- *
- * This module defines the following MatrixBase methods.
- *  - \ref matrixbase_cos "MatrixBase::cos()", for computing the matrix cosine
- *  - \ref matrixbase_cosh "MatrixBase::cosh()", for computing the matrix hyperbolic cosine
- *  - \ref matrixbase_exp "MatrixBase::exp()", for computing the matrix exponential
- *  - \ref matrixbase_log "MatrixBase::log()", for computing the matrix logarithm
- *  - \ref matrixbase_pow "MatrixBase::pow()", for computing the matrix power
- *  - \ref matrixbase_matrixfunction "MatrixBase::matrixFunction()", for computing general matrix functions
- *  - \ref matrixbase_sin "MatrixBase::sin()", for computing the matrix sine
- *  - \ref matrixbase_sinh "MatrixBase::sinh()", for computing the matrix hyperbolic sine
- *  - \ref matrixbase_sqrt "MatrixBase::sqrt()", for computing the matrix square root
- *
- * These methods are the main entry points to this module.
- *
- * %Matrix functions are defined as follows.  Suppose that \f$ f \f$
- * is an entire function (that is, a function on the complex plane
- * that is everywhere complex differentiable).  Then its Taylor
- * series
- * \f[ f(0) + f'(0) x + \frac{f''(0)}{2} x^2 + \frac{f'''(0)}{3!} x^3 + \cdots \f]
- * converges to \f$ f(x) \f$. In this case, we can define the matrix
- * function by the same series:
- * \f[ f(M) = f(0) + f'(0) M + \frac{f''(0)}{2} M^2 + \frac{f'''(0)}{3!} M^3 + \cdots \f]
- *
- */
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#include "src/MatrixFunctions/MatrixExponential.h"
-#include "src/MatrixFunctions/MatrixFunction.h"
-#include "src/MatrixFunctions/MatrixSquareRoot.h"
-#include "src/MatrixFunctions/MatrixLogarithm.h"
-#include "src/MatrixFunctions/MatrixPower.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-/**
-\page matrixbaseextra_page
-\ingroup MatrixFunctions_Module
-
-\section matrixbaseextra MatrixBase methods defined in the MatrixFunctions module
-
-The remainder of the page documents the following MatrixBase methods
-which are defined in the MatrixFunctions module.
-
-
-
-\subsection matrixbase_cos MatrixBase::cos()
-
-Compute the matrix cosine.
-
-\code
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cos() const
-\endcode
-
-\param[in]  M  a square matrix.
-\returns  expression representing \f$ \cos(M) \f$.
-
-This function computes the matrix cosine. Use ArrayBase::cos() for computing the entry-wise cosine.
-
-The implementation calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::cos().
-
-\sa \ref matrixbase_sin "sin()" for an example.
-
-
-
-\subsection matrixbase_cosh MatrixBase::cosh()
-
-Compute the matrix hyberbolic cosine.
-
-\code
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cosh() const
-\endcode
-
-\param[in]  M  a square matrix.
-\returns  expression representing \f$ \cosh(M) \f$
-
-This function calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::cosh().
-
-\sa \ref matrixbase_sinh "sinh()" for an example.
-
-
-
-\subsection matrixbase_exp MatrixBase::exp()
-
-Compute the matrix exponential.
-
-\code
-const MatrixExponentialReturnValue<Derived> MatrixBase<Derived>::exp() const
-\endcode
-
-\param[in]  M  matrix whose exponential is to be computed.
-\returns    expression representing the matrix exponential of \p M.
-
-The matrix exponential of \f$ M \f$ is defined by
-\f[ \exp(M) = \sum_{k=0}^\infty \frac{M^k}{k!}. \f]
-The matrix exponential can be used to solve linear ordinary
-differential equations: the solution of \f$ y' = My \f$ with the
-initial condition \f$ y(0) = y_0 \f$ is given by
-\f$ y(t) = \exp(M) y_0 \f$.
-
-The matrix exponential is different from applying the exp function to all the entries in the matrix.
-Use ArrayBase::exp() if you want to do the latter.
-
-The cost of the computation is approximately \f$ 20 n^3 \f$ for
-matrices of size \f$ n \f$. The number 20 depends weakly on the
-norm of the matrix.
-
-The matrix exponential is computed using the scaling-and-squaring
-method combined with Pad&eacute; approximation. The matrix is first
-rescaled, then the exponential of the reduced matrix is computed
-approximant, and then the rescaling is undone by repeated
-squaring. The degree of the Pad&eacute; approximant is chosen such
-that the approximation error is less than the round-off
-error. However, errors may accumulate during the squaring phase.
-
-Details of the algorithm can be found in: Nicholas J. Higham, "The
-scaling and squaring method for the matrix exponential revisited,"
-<em>SIAM J. %Matrix Anal. Applic.</em>, <b>26</b>:1179&ndash;1193,
-2005.
-
-Example: The following program checks that
-\f[ \exp \left[ \begin{array}{ccc}
-      0 & \frac14\pi & 0 \\
-      -\frac14\pi & 0 & 0 \\
-      0 & 0 & 0
-    \end{array} \right] = \left[ \begin{array}{ccc}
-      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
-      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
-      0 & 0 & 1
-    \end{array} \right]. \f]
-This corresponds to a rotation of \f$ \frac14\pi \f$ radians around
-the z-axis.
-
-\include MatrixExponential.cpp
-Output: \verbinclude MatrixExponential.out
-
-\note \p M has to be a matrix of \c float, \c double, `long double`
-\c complex<float>, \c complex<double>, or `complex<long double>` .
-
-
-\subsection matrixbase_log MatrixBase::log()
-
-Compute the matrix logarithm.
-
-\code
-const MatrixLogarithmReturnValue<Derived> MatrixBase<Derived>::log() const
-\endcode
-
-\param[in]  M  invertible matrix whose logarithm is to be computed.
-\returns    expression representing the matrix logarithm root of \p M.
-
-The matrix logarithm of \f$ M \f$ is a matrix \f$ X \f$ such that
-\f$ \exp(X) = M \f$ where exp denotes the matrix exponential. As for
-the scalar logarithm, the equation \f$ \exp(X) = M \f$ may have
-multiple solutions; this function returns a matrix whose eigenvalues
-have imaginary part in the interval \f$ (-\pi,\pi] \f$.
-
-The matrix logarithm is different from applying the log function to all the entries in the matrix.
-Use ArrayBase::log() if you want to do the latter.
-
-In the real case, the matrix \f$ M \f$ should be invertible and
-it should have no eigenvalues which are real and negative (pairs of
-complex conjugate eigenvalues are allowed). In the complex case, it
-only needs to be invertible.
-
-This function computes the matrix logarithm using the Schur-Parlett
-algorithm as implemented by MatrixBase::matrixFunction(). The
-logarithm of an atomic block is computed by MatrixLogarithmAtomic,
-which uses direct computation for 1-by-1 and 2-by-2 blocks and an
-inverse scaling-and-squaring algorithm for bigger blocks, with the
-square roots computed by MatrixBase::sqrt().
-
-Details of the algorithm can be found in Section 11.6.2 of:
-Nicholas J. Higham,
-<em>Functions of Matrices: Theory and Computation</em>,
-SIAM 2008. ISBN 978-0-898716-46-7.
-
-Example: The following program checks that
-\f[ \log \left[ \begin{array}{ccc}
-      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
-      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
-      0 & 0 & 1
-    \end{array} \right] = \left[ \begin{array}{ccc}
-      0 & \frac14\pi & 0 \\
-      -\frac14\pi & 0 & 0 \\
-      0 & 0 & 0
-    \end{array} \right]. \f]
-This corresponds to a rotation of \f$ \frac14\pi \f$ radians around
-the z-axis. This is the inverse of the example used in the
-documentation of \ref matrixbase_exp "exp()".
-
-\include MatrixLogarithm.cpp
-Output: \verbinclude MatrixLogarithm.out
-
-\note \p M has to be a matrix of \c float, \c double, `long
-double`, \c complex<float>, \c complex<double>, or `complex<long double>`.
-
-\sa MatrixBase::exp(), MatrixBase::matrixFunction(),
-    class MatrixLogarithmAtomic, MatrixBase::sqrt().
-
-
-\subsection matrixbase_pow MatrixBase::pow()
-
-Compute the matrix raised to arbitrary real power.
-
-\code
-const MatrixPowerReturnValue<Derived> MatrixBase<Derived>::pow(RealScalar p) const
-\endcode
-
-\param[in]  M  base of the matrix power, should be a square matrix.
-\param[in]  p  exponent of the matrix power.
-
-The matrix power \f$ M^p \f$ is defined as \f$ \exp(p \log(M)) \f$,
-where exp denotes the matrix exponential, and log denotes the matrix
-logarithm. This is different from raising all the entries in the matrix
-to the p-th power. Use ArrayBase::pow() if you want to do the latter.
-
-If \p p is complex, the scalar type of \p M should be the type of \p
-p . \f$ M^p \f$ simply evaluates into \f$ \exp(p \log(M)) \f$.
-Therefore, the matrix \f$ M \f$ should meet the conditions to be an
-argument of matrix logarithm.
-
-If \p p is real, it is casted into the real scalar type of \p M. Then
-this function computes the matrix power using the Schur-Pad&eacute;
-algorithm as implemented by class MatrixPower. The exponent is split
-into integral part and fractional part, where the fractional part is
-in the interval \f$ (-1, 1) \f$. The main diagonal and the first
-super-diagonal is directly computed.
-
-If \p M is singular with a semisimple zero eigenvalue and \p p is
-positive, the Schur factor \f$ T \f$ is reordered with Givens
-rotations, i.e.
-
-\f[ T = \left[ \begin{array}{cc}
-      T_1 & T_2 \\
-      0   & 0
-    \end{array} \right] \f]
-
-where \f$ T_1 \f$ is invertible. Then \f$ T^p \f$ is given by
-
-\f[ T^p = \left[ \begin{array}{cc}
-      T_1^p & T_1^{-1} T_1^p T_2 \\
-      0     & 0
-    \end{array}. \right] \f]
-
-\warning Fractional power of a matrix with a non-semisimple zero
-eigenvalue is not well-defined. We introduce an assertion failure
-against inaccurate result, e.g. \code
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-int main()
-{
-  Eigen::Matrix4d A;
-  A << 0, 0, 2, 3,
-       0, 0, 4, 5,
-       0, 0, 6, 7,
-       0, 0, 8, 9;
-  std::cout << A.pow(0.37) << std::endl;
-
-  // The 1 makes eigenvalue 0 non-semisimple.
-  A.coeffRef(0, 1) = 1;
-
-  // This fails if EIGEN_NO_DEBUG is undefined.
-  std::cout << A.pow(0.37) << std::endl;
-
-  return 0;
-}
-\endcode
-
-Details of the algorithm can be found in: Nicholas J. Higham and
-Lijing Lin, "A Schur-Pad&eacute; algorithm for fractional powers of a
-matrix," <em>SIAM J. %Matrix Anal. Applic.</em>,
-<b>32(3)</b>:1056&ndash;1078, 2011.
-
-Example: The following program checks that
-\f[ \left[ \begin{array}{ccc}
-      \cos1 & -\sin1 & 0 \\
-      \sin1 & \cos1 & 0 \\
-      0 & 0 & 1
-    \end{array} \right]^{\frac14\pi} = \left[ \begin{array}{ccc}
-      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
-      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
-      0 & 0 & 1
-    \end{array} \right]. \f]
-This corresponds to \f$ \frac14\pi \f$ rotations of 1 radian around
-the z-axis.
-
-\include MatrixPower.cpp
-Output: \verbinclude MatrixPower.out
-
-MatrixBase::pow() is user-friendly. However, there are some
-circumstances under which you should use class MatrixPower directly.
-MatrixPower can save the result of Schur decomposition, so it's
-better for computing various powers for the same matrix.
-
-Example:
-\include MatrixPower_optimal.cpp
-Output: \verbinclude MatrixPower_optimal.out
-
-\note \p M has to be a matrix of \c float, \c double, `long
-double`, \c complex<float>, \c complex<double>, or
-\c complex<long double> .
-
-\sa MatrixBase::exp(), MatrixBase::log(), class MatrixPower.
-
-
-\subsection matrixbase_matrixfunction MatrixBase::matrixFunction()
-
-Compute a matrix function.
-
-\code
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(typename internal::stem_function<typename
-internal::traits<Derived>::Scalar>::type f) const \endcode
-
-\param[in]  M  argument of matrix function, should be a square matrix.
-\param[in]  f  an entire function; \c f(x,n) should compute the n-th
-derivative of f at x.
-\returns  expression representing \p f applied to \p M.
-
-Suppose that \p M is a matrix whose entries have type \c Scalar.
-Then, the second argument, \p f, should be a function with prototype
-\code
-ComplexScalar f(ComplexScalar, int)
-\endcode
-where \c ComplexScalar = \c std::complex<Scalar> if \c Scalar is
-real (e.g., \c float or \c double) and \c ComplexScalar =
-\c Scalar if \c Scalar is complex. The return value of \c f(x,n)
-should be \f$ f^{(n)}(x) \f$, the n-th derivative of f at x.
-
-This routine uses the algorithm described in:
-Philip Davies and Nicholas J. Higham,
-"A Schur-Parlett algorithm for computing matrix functions",
-<em>SIAM J. %Matrix Anal. Applic.</em>, <b>25</b>:464&ndash;485, 2003.
-
-The actual work is done by the MatrixFunction class.
-
-Example: The following program checks that
-\f[ \exp \left[ \begin{array}{ccc}
-      0 & \frac14\pi & 0 \\
-      -\frac14\pi & 0 & 0 \\
-      0 & 0 & 0
-    \end{array} \right] = \left[ \begin{array}{ccc}
-      \frac12\sqrt2 & -\frac12\sqrt2 & 0 \\
-      \frac12\sqrt2 & \frac12\sqrt2 & 0 \\
-      0 & 0 & 1
-    \end{array} \right]. \f]
-This corresponds to a rotation of \f$ \frac14\pi \f$ radians around
-the z-axis. This is the same example as used in the documentation
-of \ref matrixbase_exp "exp()".
-
-\include MatrixFunction.cpp
-Output: \verbinclude MatrixFunction.out
-
-Note that the function \c expfn is defined for complex numbers
-\c x, even though the matrix \c A is over the reals. Instead of
-\c expfn, we could also have used StdStemFunctions::exp:
-\code
-A.matrixFunction(StdStemFunctions<std::complex<double> >::exp, &B);
-\endcode
-
-
-
-\subsection matrixbase_sin MatrixBase::sin()
-
-Compute the matrix sine.
-
-\code
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sin() const
-\endcode
-
-\param[in]  M  a square matrix.
-\returns  expression representing \f$ \sin(M) \f$.
-
-This function computes the matrix sine. Use ArrayBase::sin() for computing the entry-wise sine.
-
-The implementation calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::sin().
-
-Example: \include MatrixSine.cpp
-Output: \verbinclude MatrixSine.out
-
-
-
-\subsection matrixbase_sinh MatrixBase::sinh()
-
-Compute the matrix hyperbolic sine.
-
-\code
-MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sinh() const
-\endcode
-
-\param[in]  M  a square matrix.
-\returns  expression representing \f$ \sinh(M) \f$
-
-This function calls \ref matrixbase_matrixfunction "matrixFunction()" with StdStemFunctions::sinh().
-
-Example: \include MatrixSinh.cpp
-Output: \verbinclude MatrixSinh.out
-
-
-\subsection matrixbase_sqrt MatrixBase::sqrt()
-
-Compute the matrix square root.
-
-\code
-const MatrixSquareRootReturnValue<Derived> MatrixBase<Derived>::sqrt() const
-\endcode
-
-\param[in]  M  invertible matrix whose square root is to be computed.
-\returns    expression representing the matrix square root of \p M.
-
-The matrix square root of \f$ M \f$ is the matrix \f$ M^{1/2} \f$
-whose square is the original matrix; so if \f$ S = M^{1/2} \f$ then
-\f$ S^2 = M \f$. This is different from taking the square root of all
-the entries in the matrix; use ArrayBase::sqrt() if you want to do the
-latter.
-
-In the <b>real case</b>, the matrix \f$ M \f$ should be invertible and
-it should have no eigenvalues which are real and negative (pairs of
-complex conjugate eigenvalues are allowed). In that case, the matrix
-has a square root which is also real, and this is the square root
-computed by this function.
-
-The matrix square root is computed by first reducing the matrix to
-quasi-triangular form with the real Schur decomposition. The square
-root of the quasi-triangular matrix can then be computed directly. The
-cost is approximately \f$ 25 n^3 \f$ real flops for the real Schur
-decomposition and \f$ 3\frac13 n^3 \f$ real flops for the remainder
-(though the computation time in practice is likely more than this
-indicates).
-
-Details of the algorithm can be found in: Nicholas J. Highan,
-"Computing real square roots of a real matrix", <em>Linear Algebra
-Appl.</em>, 88/89:405&ndash;430, 1987.
-
-If the matrix is <b>positive-definite symmetric</b>, then the square
-root is also positive-definite symmetric. In this case, it is best to
-use SelfAdjointEigenSolver::operatorSqrt() to compute it.
-
-In the <b>complex case</b>, the matrix \f$ M \f$ should be invertible;
-this is a restriction of the algorithm. The square root computed by
-this algorithm is the one whose eigenvalues have an argument in the
-interval \f$ (-\frac12\pi, \frac12\pi] \f$. This is the usual branch
-cut.
-
-The computation is the same as in the real case, except that the
-complex Schur decomposition is used to reduce the matrix to a
-triangular matrix. The theoretical cost is the same. Details are in:
-&Aring;ke Bj&ouml;rck and Sven Hammarling, "A Schur method for the
-square root of a matrix", <em>Linear Algebra Appl.</em>,
-52/53:127&ndash;140, 1983.
-
-Example: The following program checks that the square root of
-\f[ \left[ \begin{array}{cc}
-              \cos(\frac13\pi) & -\sin(\frac13\pi) \\
-              \sin(\frac13\pi) & \cos(\frac13\pi)
-    \end{array} \right], \f]
-corresponding to a rotation over 60 degrees, is a rotation over 30 degrees:
-\f[ \left[ \begin{array}{cc}
-              \cos(\frac16\pi) & -\sin(\frac16\pi) \\
-              \sin(\frac16\pi) & \cos(\frac16\pi)
-    \end{array} \right]. \f]
-
-\include MatrixSquareRoot.cpp
-Output: \verbinclude MatrixSquareRoot.out
-
-\sa class RealSchur, class ComplexSchur, class MatrixSquareRoot,
-    SelfAdjointEigenSolver::operatorSqrt().
-
-*/
-
-#endif  // EIGEN_MATRIX_FUNCTIONS_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_MATRIXFUNCTIONS_FORWARD_H
diff --git a/unsupported/Eigen/NNLS b/unsupported/Eigen/NNLS
index fcafc08..04ff1a9 100644
--- a/unsupported/Eigen/NNLS
+++ b/unsupported/Eigen/NNLS
@@ -1,388 +1,17 @@
-/* Non-Negagive Least Squares Algorithm for Eigen.
- *
- * Copyright (C) 2021 Essex Edwards, <essex.edwards@gmail.com>
- * Copyright (C) 2013 Hannes Matuschek, hannes.matuschek at uni-potsdam.de
- *
- * This Source Code Form is subject to the terms of the Mozilla
- * Public License v. 2.0. If a copy of the MPL was not distributed
- * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
- */
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/NNLS>
+// directly. This shim preserves the legacy include path.
 
-/** \defgroup nnls Non-Negative Least Squares (NNLS) Module
- * This module provides a single class @c Eigen::NNLS implementing the NNLS algorithm.
- * The algorithm is described in "SOLVING LEAST SQUARES PROBLEMS", by Charles L. Lawson and
- * Richard J. Hanson, Prentice-Hall, 1974 and solves optimization problems of the form
- *
- * \f[ \min \left\Vert Ax-b\right\Vert_2^2\quad s.t.\, x\ge 0\,.\f]
- *
- * The algorithm solves the constrained least-squares problem above by iteratively improving
- * an estimate of which constraints are active (elements of \f$x\f$ equal to zero)
- * and which constraints are inactive (elements of \f$x\f$ greater than zero).
- * Each iteration, an unconstrained linear least-squares problem solves for the
- * components of \f$x\f$ in the (estimated) inactive set and the sets are updated.
- * The unconstrained problem minimizes \f$\left\Vert A^Nx^N-b\right\Vert_2^2\f$,
- * where \f$A^N\f$ is a matrix formed by selecting all columns of A which are
- * in the inactive set \f$N\f$.
- *
- */
+#ifndef EIGEN_UNSUPPORTED_NNLS_FORWARD_H
+#define EIGEN_UNSUPPORTED_NNLS_FORWARD_H
 
-#ifndef EIGEN_NNLS_H
-#define EIGEN_NNLS_H
+#include "../../contrib/Eigen/NNLS"  // IWYU pragma: export
 
-#include "../../Eigen/Core"
-#include "../../Eigen/QR"
-
-#include <limits>
-
-namespace Eigen {
-
-/** \ingroup nnls
- * \class NNLS
- * \brief Implementation of the Non-Negative Least Squares (NNLS) algorithm.
- * \tparam MatrixType The type of the system matrix \f$A\f$.
- *
- * This class implements the NNLS algorithm as described in "SOLVING LEAST SQUARES PROBLEMS",
- * Charles L. Lawson and Richard J. Hanson, Prentice-Hall, 1974. This algorithm solves a least
- * squares problem iteratively and ensures that the solution is non-negative. I.e.
- *
- * \f[ \min \left\Vert Ax-b\right\Vert_2^2\quad s.t.\, x\ge 0 \f]
- *
- * The algorithm solves the constrained least-squares problem above by iteratively improving
- * an estimate of which constraints are active (elements of \f$x\f$ equal to zero)
- * and which constraints are inactive (elements of \f$x\f$ greater than zero).
- * Each iteration, an unconstrained linear least-squares problem solves for the
- * components of \f$x\f$ in the (estimated) inactive set and the sets are updated.
- * The unconstrained problem minimizes \f$\left\Vert A^Nx^N-b\right\Vert_2^2\f$,
- * where \f$A^N\f$ is a matrix formed by selecting all columns of A which are
- * in the inactive set \f$N\f$.
- *
- * See <a href="https://en.wikipedia.org/wiki/Non-negative_least_squares">the
- * wikipedia page on non-negative least squares</a> for more background information.
- *
- * \note Please note that it is possible to construct an NNLS problem for which the
- *       algorithm does not converge. In practice these cases are extremely rare.
- */
-template <class MatrixType_>
-class NNLS {
- public:
-  typedef MatrixType_ MatrixType;
-
-  enum {
-    RowsAtCompileTime = MatrixType::RowsAtCompileTime,
-    ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-    Options = MatrixType::Options,
-    MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
-    MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
-  };
-
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef typename MatrixType::Index Index;
-
-  /** Type of a row vector of the system matrix \f$A\f$. */
-  typedef Matrix<Scalar, ColsAtCompileTime, 1> SolutionVectorType;
-  /** Type of a column vector of the system matrix \f$A\f$. */
-  typedef Matrix<Scalar, RowsAtCompileTime, 1> RhsVectorType;
-  typedef Matrix<Index, ColsAtCompileTime, 1> IndicesType;
-
-  /** */
-  NNLS();
-
-  /** \brief Constructs a NNLS solver and initializes it with the given system matrix @c A.
-   * \param A Specifies the system matrix.
-   * \param max_iter Specifies the maximum number of iterations to solve the system.
-   * \param tol Specifies the precision of the optimum.
-   *        This is an absolute tolerance on the gradient of the Lagrangian, \f$A^T(Ax-b)-\lambda\f$
-   *        (with Lagrange multipliers \f$\lambda\f$).
-   */
-  NNLS(const MatrixType &A, Index max_iter = -1, Scalar tol = NumTraits<Scalar>::dummy_precision());
-
-  /** Initializes the solver with the matrix \a A for further solving NNLS problems.
-   *
-   * This function mostly initializes/computes the preconditioner. In the future
-   * we might, for instance, implement column reordering for faster matrix vector products.
-   */
-  template <typename MatrixDerived>
-  NNLS<MatrixType> &compute(const EigenBase<MatrixDerived> &A);
-
-  /** \brief Solves the NNLS problem.
-   *
-   * The dimension of @c b must be equal to the number of rows of @c A, given to the constructor.
-   *
-   * \returns The approximate solution vector \f$ x \f$. Use info() to determine if the solve was a success or not.
-   * \sa info()
-   */
-  const SolutionVectorType &solve(const RhsVectorType &b);
-
-  /** \brief Returns the solution if a problem was solved.
-   * If not, an uninitialized vector may be returned. */
-  const SolutionVectorType &x() const { return x_; }
-
-  /** \returns the tolerance threshold used by the stopping criteria.
-   * \sa setTolerance()
-   */
-  Scalar tolerance() const { return tolerance_; }
-
-  /** Sets the tolerance threshold used by the stopping criteria.
-   *
-   * This is an absolute tolerance on the gradient of the Lagrangian, \f$A^T(Ax-b)-\lambda\f$
-   * (with Lagrange multipliers \f$\lambda\f$).
-   */
-  NNLS<MatrixType> &setTolerance(const Scalar &tolerance) {
-    tolerance_ = tolerance;
-    return *this;
-  }
-
-  /** \returns the max number of iterations.
-   * It is either the value set by setMaxIterations or, by default, twice the number of columns of the matrix.
-   */
-  Index maxIterations() const { return max_iter_ < 0 ? 2 * A_.cols() : max_iter_; }
-
-  /** Sets the max number of iterations.
-   * Default is twice the number of columns of the matrix.
-   * The algorithm requires at least k iterations to produce a solution vector with k non-zero entries.
-   */
-  NNLS<MatrixType> &setMaxIterations(Index maxIters) {
-    max_iter_ = maxIters;
-    return *this;
-  }
-
-  /** \returns the number of iterations (least-squares solves) performed during the last solve */
-  Index iterations() const { return iterations_; }
-
-  /** \returns Success if the iterations converged, and an error values otherwise. */
-  ComputationInfo info() const { return info_; }
-
- private:
-  /** \internal Adds the given index @c idx to the inactive set N and updates the QR decomposition of \f$A^N\f$. */
-  void moveToInactiveSet_(Index idx);
-
-  /** \internal Removes the given index idx from the inactive set N and updates the QR decomposition of \f$A^N\f$. */
-  void moveToActiveSet_(Index idx);
-
-  /** \internal Solves the least-squares problem \f$\left\Vert y-A^Nx\right\Vert_2^2\f$. */
-  void solveInactiveSet_(const RhsVectorType &b);
-
- private:
-  typedef Matrix<Scalar, ColsAtCompileTime, ColsAtCompileTime> MatrixAtAType;
-
-  /** \internal Holds the maximum number of iterations for the NNLS algorithm.
-   *  @c -1 means to use the default value. */
-  Index max_iter_;
-  /** \internal Holds the number of iterations. */
-  Index iterations_;
-  /** \internal Holds success/fail of the last solve. */
-  ComputationInfo info_;
-  /** \internal Size of the inactive set. */
-  Index numInactive_;
-  /** \internal Accuracy of the algorithm w.r.t the optimality of the solution (gradient). */
-  Scalar tolerance_;
-  /** \internal The system matrix, a copy of the one given to the constructor. */
-  MatrixType A_;
-  /** \internal Precomputed product \f$A^TA\f$. */
-  MatrixAtAType AtA_;
-  /** \internal Will hold the solution. */
-  SolutionVectorType x_;
-  /** \internal Will hold the current gradient.\f$A^Tb - A^TAx\f$ */
-  SolutionVectorType gradient_;
-  /** \internal Will hold the partial solution. */
-  SolutionVectorType y_;
-  /** \internal Precomputed product \f$A^Tb\f$. */
-  SolutionVectorType Atb_;
-  /** \internal Holds the current permutation partitioning the active and inactive sets.
-   * The first @c numInactive_ elements form the inactive set and the rest the active set. */
-  IndicesType index_sets_;
-  /** \internal QR decomposition to solve the (inactive) sub system (together with @c qrCoeffs_). */
-  MatrixType QR_;
-  /** \internal QR decomposition to solve the (inactive) sub system (together with @c QR_). */
-  SolutionVectorType qrCoeffs_;
-  /** \internal Some workspace for QR decomposition. */
-  SolutionVectorType tempSolutionVector_;
-  RhsVectorType tempRhsVector_;
-};
-
-/* ********************************************************************************************
- * Implementation
- * ******************************************************************************************** */
-
-template <typename MatrixType>
-NNLS<MatrixType>::NNLS()
-    : max_iter_(-1),
-      iterations_(0),
-      info_(ComputationInfo::InvalidInput),
-      numInactive_(0),
-      tolerance_(NumTraits<Scalar>::dummy_precision()) {}
-
-template <typename MatrixType>
-NNLS<MatrixType>::NNLS(const MatrixType &A, Index max_iter, Scalar tol) : max_iter_(max_iter), tolerance_(tol) {
-  compute(A);
-}
-
-template <typename MatrixType>
-template <typename MatrixDerived>
-NNLS<MatrixType> &NNLS<MatrixType>::compute(const EigenBase<MatrixDerived> &A) {
-  // Ensure Scalar type is real. The non-negativity constraint doesn't obviously extend to complex numbers.
-  EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
-
-  // max_iter_: unchanged
-  iterations_ = 0;
-  info_ = ComputationInfo::Success;
-  numInactive_ = 0;
-  // tolerance: unchanged
-  A_ = A.derived();
-  AtA_.noalias() = A_.transpose() * A_;
-  x_.resize(A_.cols());
-  gradient_.resize(A_.cols());
-  y_.resize(A_.cols());
-  Atb_.resize(A_.cols());
-  index_sets_.resize(A_.cols());
-  QR_.resize(A_.rows(), A_.cols());
-  qrCoeffs_.resize(A_.cols());
-  tempSolutionVector_.resize(A_.cols());
-  tempRhsVector_.resize(A_.rows());
-
-  return *this;
-}
-
-template <typename MatrixType>
-const typename NNLS<MatrixType>::SolutionVectorType &NNLS<MatrixType>::solve(const RhsVectorType &b) {
-  // Initialize solver
-  iterations_ = 0;
-  info_ = ComputationInfo::NumericalIssue;
-  x_.setZero();
-
-  index_sets_ = IndicesType::LinSpaced(A_.cols(), 0, A_.cols() - 1);  // Identity permutation.
-  numInactive_ = 0;
-
-  // Precompute A^T*b
-  Atb_.noalias() = A_.transpose() * b;
-
-  const Index maxIterations = this->maxIterations();
-
-  // OUTER LOOP
-  while (true) {
-    // Early exit if all variables are inactive, which breaks 'maxCoeff' below.
-    if (A_.cols() == numInactive_) {
-      info_ = ComputationInfo::Success;
-      return x_;
-    }
-
-    // Find the maximum element of the gradient in the active set.
-    // If it is small or negative, then we have converged.
-    // Else, we move that variable to the inactive set.
-    gradient_.noalias() = Atb_ - AtA_ * x_;
-
-    const Index numActive = A_.cols() - numInactive_;
-    Index argmaxGradient = -1;
-    const Scalar maxGradient = gradient_(index_sets_.tail(numActive)).maxCoeff(&argmaxGradient);
-    argmaxGradient += numInactive_;  // because tail() skipped the first numInactive_ elements
-
-    if (maxGradient < tolerance_) {
-      info_ = ComputationInfo::Success;
-      return x_;
-    }
-
-    moveToInactiveSet_(argmaxGradient);
-
-    // INNER LOOP
-    while (true) {
-      // Check if max. number of iterations is reached
-      if (iterations_ >= maxIterations) {
-        info_ = ComputationInfo::NoConvergence;
-        return x_;
-      }
-
-      // Solve least-squares problem in inactive set only,
-      // this step is rather trivial as moveToInactiveSet_ & moveToActiveSet_
-      // updates the QR decomposition of inactive columns A^N.
-      // solveInactiveSet_ puts the solution in y_
-      solveInactiveSet_(b);
-      ++iterations_;  // The solve is expensive, so that is what we count as an iteration.
-
-      // Check feasibility...
-      bool feasible = true;
-      Scalar alpha = NumTraits<Scalar>::highest();
-      Index infeasibleIdx = -1;  // Which variable became infeasible first.
-      for (Index i = 0; i < numInactive_; i++) {
-        Index idx = index_sets_[i];
-        if (y_(idx) < 0) {
-          // t should always be in [0,1].
-          Scalar t = -x_(idx) / (y_(idx) - x_(idx));
-          if (alpha > t) {
-            alpha = t;
-            infeasibleIdx = i;
-            feasible = false;
-          }
-        }
-      }
-      eigen_assert(feasible || 0 <= infeasibleIdx);
-
-      // If solution is feasible, exit to outer loop
-      if (feasible) {
-        x_ = y_;
-        break;
-      }
-
-      // Infeasible solution -> interpolate to feasible one
-      for (Index i = 0; i < numInactive_; i++) {
-        Index idx = index_sets_[i];
-        x_(idx) += alpha * (y_(idx) - x_(idx));
-      }
-
-      // Remove these indices from the inactive set and update QR decomposition
-      moveToActiveSet_(infeasibleIdx);
-    }
-  }
-}
-
-template <typename MatrixType>
-void NNLS<MatrixType>::moveToInactiveSet_(Index idx) {
-  // Update permutation matrix:
-  std::swap(index_sets_(idx), index_sets_(numInactive_));
-  numInactive_++;
-
-  // Perform rank-1 update of the QR decomposition stored in QR_ & qrCoeff_
-  internal::householder_qr_inplace_update(QR_, qrCoeffs_, A_.col(index_sets_(numInactive_ - 1)), numInactive_ - 1,
-                                          tempSolutionVector_.data());
-}
-
-template <typename MatrixType>
-void NNLS<MatrixType>::moveToActiveSet_(Index idx) {
-  // swap index with last inactive one & reduce number of inactive columns
-  std::swap(index_sets_(idx), index_sets_(numInactive_ - 1));
-  numInactive_--;
-  // Update QR decomposition starting from the removed index up to the end [idx, ..., numInactive_]
-  for (Index i = idx; i < numInactive_; i++) {
-    Index col = index_sets_(i);
-    internal::householder_qr_inplace_update(QR_, qrCoeffs_, A_.col(col), i, tempSolutionVector_.data());
-  }
-}
-
-template <typename MatrixType>
-void NNLS<MatrixType>::solveInactiveSet_(const RhsVectorType &b) {
-  eigen_assert(numInactive_ > 0);
-
-  tempRhsVector_ = b;
-
-  // tmpRHS(0:numInactive_-1) := Q'*b
-  // tmpRHS(numInactive_:end) := useless stuff we would rather not compute at all.
-  tempRhsVector_.applyOnTheLeft(
-      householderSequence(QR_.leftCols(numInactive_), qrCoeffs_.head(numInactive_)).transpose());
-
-  // tempSol(0:numInactive_-1) := inv(R) * Q' * b
-  //  = the least-squares solution for the inactive variables.
-  tempSolutionVector_.head(numInactive_) =            //
-      QR_.topLeftCorner(numInactive_, numInactive_)   //
-          .template triangularView<Upper>()           //
-          .solve(tempRhsVector_.head(numInactive_));  //
-
-  // tempSol(numInactive_:end) := 0 = the value for the constrained variables.
-  tempSolutionVector_.tail(y_.size() - numInactive_).setZero();
-
-  // Back permute into original column order of A
-  y_.noalias() = index_sets_.asPermutation() * tempSolutionVector_.head(y_.size());
-}
-
-}  // namespace Eigen
-
-#endif  // EIGEN_NNLS_H
+#endif  // EIGEN_UNSUPPORTED_NNLS_FORWARD_H
diff --git a/unsupported/Eigen/NonLinearOptimization b/unsupported/Eigen/NonLinearOptimization
index 486dd4a..f1b37c7 100644
--- a/unsupported/Eigen/NonLinearOptimization
+++ b/unsupported/Eigen/NonLinearOptimization
@@ -1,141 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/NonLinearOptimization>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_NONLINEAROPTIMIZATION_MODULE_H
-#define EIGEN_NONLINEAROPTIMIZATION_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_NONLINEAROPTIMIZATION_FORWARD_H
+#define EIGEN_UNSUPPORTED_NONLINEAROPTIMIZATION_FORWARD_H
 
-#include <vector>
+#include "../../contrib/Eigen/NonLinearOptimization"  // IWYU pragma: export
 
-#include "../../Eigen/Core"
-#include "../../Eigen/Jacobi"
-#include "../../Eigen/QR"
-#include "NumericalDiff"
-
-/**
- * \defgroup NonLinearOptimization_Module Non linear optimization module
- *
- * \code
- * #include <unsupported/Eigen/NonLinearOptimization>
- * \endcode
- *
- * This module provides implementation of two important algorithms in non linear
- * optimization. In both cases, we consider a system of non linear functions. Of
- * course, this should work, and even work very well if those functions are
- * actually linear. But if this is so, you should probably better use other
- * methods more fitted to this special case.
- *
- * One algorithm allows to find a least-squares solution of such a system
- * (Levenberg-Marquardt algorithm) and the second one is used to find
- * a zero for the system (Powell hybrid "dogleg" method).
- *
- * This code is a port of minpack (http://en.wikipedia.org/wiki/MINPACK).
- * Minpack is a very famous, old, robust and well renowned package, written in
- * fortran. Those implementations have been carefully tuned, tested, and used
- * for several decades.
- *
- * The original fortran code was automatically translated using f2c (http://en.wikipedia.org/wiki/F2c) in C,
- * then c++, and then cleaned by several different authors.
- * The last one of those cleanings being our starting point :
- * http://devernay.free.fr/hacks/cminpack.html
- *
- * Finally, we ported this code to Eigen, creating classes and API
- * coherent with Eigen. When possible, we switched to Eigen
- * implementation, such as most linear algebra (vectors, matrices, stable norms).
- *
- * Doing so, we were very careful to check the tests we setup at the very
- * beginning, which ensure that the same results are found.
- *
- * \section Tests Tests
- *
- * The tests are placed in the file unsupported/test/NonLinear.cpp.
- *
- * There are two kinds of tests : those that come from examples bundled with cminpack.
- * They guaranty we get the same results as the original algorithms (value for 'x',
- * for the number of evaluations of the function, and for the number of evaluations
- * of the Jacobian if ever).
- *
- * Other tests were added by myself at the very beginning of the
- * process and check the results for Levenberg-Marquardt using the reference data
- * on http://www.itl.nist.gov/div898/strd/nls/nls_main.shtml. Since then i've
- * carefully checked that the same results were obtained when modifying the
- * code. Please note that we do not always get the exact same decimals as they do,
- * but this is ok : they use 128bits float, and we do the tests using the C type 'double',
- * which is 64 bits on most platforms (x86 and amd64, at least).
- * I've performed those tests on several other implementations of Levenberg-Marquardt, and
- * (c)minpack performs VERY well compared to those, both in accuracy and speed.
- *
- * The documentation for running the tests is on the wiki
- * http://eigen.tuxfamily.org/index.php?title=Tests
- *
- * \section API API: overview of methods
- *
- * Both algorithms needs a functor computing the Jacobian. It can be computed by
- * hand, using auto-differentiation (see \ref AutoDiff_Module), or using numerical
- * differences (see \ref NumericalDiff_Module). For instance:
- *\code
- * MyFunc func;
- * NumericalDiff<MyFunc> func_with_num_diff(func);
- * LevenbergMarquardt<NumericalDiff<MyFunc> > lm(func_with_num_diff);
- * \endcode
- * For HybridNonLinearSolver, the method solveNumericalDiff() does the above wrapping for
- * you.
- *
- * The methods LevenbergMarquardt.lmder1()/lmdif1()/lmstr1() and
- * HybridNonLinearSolver.hybrj1()/hybrd1() are specific methods from the original
- * minpack package that you probably should NOT use until you are porting a code that
- * was previously using minpack. They just define a 'simple' API with default values
- * for some parameters.
- *
- * All algorithms are provided using two APIs :
- *     - one where the user inits the algorithm, and uses '*OneStep()' as much as he wants :
- * this way the caller have control over the steps
- *     - one where the user just calls a method (optimize() or solve()) which will
- * handle the loop: init + loop until a stop condition is met. Those are provided for
- *  convenience.
- *
- * As an example, the method LevenbergMarquardt::minimize() is
- * implemented as follow:
- * \code
- * Status LevenbergMarquardt<FunctorType,Scalar>::minimize(FVectorType  &x, const int mode)
- * {
- *     Status status = minimizeInit(x, mode);
- *     do {
- *         status = minimizeOneStep(x, mode);
- *     } while (status==Running);
- *     return status;
- * }
- * \endcode
- *
- * \section examples Examples
- *
- * The easiest way to understand how to use this module is by looking at the many examples in the file
- * unsupported/test/NonLinearOptimization.cpp.
- */
-
-// IWYU pragma: begin_exports
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-
-#include "src/NonLinearOptimization/qrsolv.h"
-#include "src/NonLinearOptimization/r1updt.h"
-#include "src/NonLinearOptimization/r1mpyq.h"
-#include "src/NonLinearOptimization/rwupdt.h"
-#include "src/NonLinearOptimization/fdjac1.h"
-#include "src/NonLinearOptimization/lmpar.h"
-#include "src/NonLinearOptimization/dogleg.h"
-#include "src/NonLinearOptimization/covar.h"
-
-#include "src/NonLinearOptimization/chkder.h"
-
-#endif
-
-#include "src/NonLinearOptimization/HybridNonLinearSolver.h"
-#include "src/NonLinearOptimization/LevenbergMarquardt.h"
-// IWYU pragma: end_exports
-
-#endif  // EIGEN_NONLINEAROPTIMIZATION_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_NONLINEAROPTIMIZATION_FORWARD_H
diff --git a/unsupported/Eigen/NumericalDiff b/unsupported/Eigen/NumericalDiff
index ed236c8..ce05349 100644
--- a/unsupported/Eigen/NumericalDiff
+++ b/unsupported/Eigen/NumericalDiff
@@ -1,57 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/NumericalDiff>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_NUMERICALDIFF_MODULE_H
-#define EIGEN_NUMERICALDIFF_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_NUMERICALDIFF_FORWARD_H
+#define EIGEN_UNSUPPORTED_NUMERICALDIFF_FORWARD_H
 
-#include "../../Eigen/Core"
+#include "../../contrib/Eigen/NumericalDiff"  // IWYU pragma: export
 
-namespace Eigen {
-
-/**
- * \defgroup NumericalDiff_Module Numerical differentiation module
- *
- * \code
- * #include <unsupported/Eigen/NumericalDiff>
- * \endcode
- *
- * See http://en.wikipedia.org/wiki/Numerical_differentiation
- *
- * Warning : this should NOT be confused with automatic differentiation, which
- * is a different method and has its own module in Eigen : \ref
- * AutoDiff_Module.
- *
- * Currently only "Forward" and "Central" schemes are implemented. Those
- * are basic methods, and there exist some more elaborated way of
- * computing such approximates. They are implemented using both
- * proprietary and free software, and usually requires linking to an
- * external library. It is very easy for you to write a functor
- * using such software, and the purpose is quite orthogonal to what we
- * want to achieve with Eigen.
- *
- * This is why we will not provide wrappers for every great numerical
- * differentiation software that exist, but should rather stick with those
- * basic ones, that still are useful for testing.
- *
- * Also, the \ref NonLinearOptimization_Module needs this in order to
- * provide full features compatibility with the original (c)minpack
- * package.
- *
- */
-}
-
-//@{
-
-// IWYU pragma: begin_exports
-#include "src/NumericalDiff/NumericalDiff.h"
-// IWYU pragma: end_exports
-
-//@}
-
-#endif  // EIGEN_NUMERICALDIFF_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_NUMERICALDIFF_FORWARD_H
diff --git a/unsupported/Eigen/OpenGLSupport b/unsupported/Eigen/OpenGLSupport
index f22ae56..1061371 100644
--- a/unsupported/Eigen/OpenGLSupport
+++ b/unsupported/Eigen/OpenGLSupport
@@ -1,350 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/OpenGLSupport>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_OPENGL_MODULE_H
-#define EIGEN_OPENGL_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_OPENGLSUPPORT_FORWARD_H
+#define EIGEN_UNSUPPORTED_OPENGLSUPPORT_FORWARD_H
 
-#include "../../Eigen/Geometry"
+#include "../../contrib/Eigen/OpenGLSupport"  // IWYU pragma: export
 
-#if defined(__APPLE_CC__)
-#include <OpenGL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
-
-namespace Eigen {
-
-/**
- * \defgroup OpenGLSUpport_Module OpenGL Support module
- *
- * This module provides wrapper functions for a couple of OpenGL functions
- * which simplify the way to pass Eigen's object to openGL.
- * Here is an example:
- *
- * \code
- * // You need to add path_to_eigen/unsupported to your include path.
- * #include <Eigen/OpenGLSupport>
- * // ...
- * Vector3f x, y;
- * Matrix3f rot;
- *
- * glVertex(y + x * rot);
- *
- * Quaternion q;
- * glRotate(q);
- *
- * // ...
- * \endcode
- *
- */
-//@{
-
-#define EIGEN_GL_FUNC_DECLARATION(FUNC)                                                                          \
-  namespace internal {                                                                                           \
-  template <typename XprType, typename Scalar = typename XprType::Scalar, int Rows = XprType::RowsAtCompileTime, \
-            int Cols = XprType::ColsAtCompileTime,                                                               \
-            bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags & LinearAccessBit) &&                 \
-                                  bool(XprType::Flags & DirectAccessBit) &&                                      \
-                                  (XprType::IsVectorAtCompileTime || (XprType::Flags & RowMajorBit) == 0)>       \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl);                                                                 \
-                                                                                                                 \
-  template <typename XprType, typename Scalar, int Rows, int Cols>                                               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, Scalar, Rows, Cols, false> {                            \
-    inline static void run(const XprType& p) {                                                                   \
-      EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<typename plain_matrix_type_column_major<XprType>::type>::run(p);    \
-    }                                                                                                            \
-  };                                                                                                             \
-  }                                                                                                              \
-                                                                                                                 \
-  template <typename Derived>                                                                                    \
-  inline void FUNC(const Eigen::DenseBase<Derived>& p) {                                                         \
-    EIGEN_CAT(EIGEN_CAT(internal::gl_, FUNC), _impl)<Derived>::run(p.derived());                                 \
-  }
-
-#define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC, SCALAR, ROWS, COLS, SUFFIX)           \
-  namespace internal {                                                               \
-  template <typename XprType>                                                        \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, ROWS, COLS, true> { \
-    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }             \
-  };                                                                                 \
-  }
-
-#define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC, SCALAR, SIZE, SUFFIX)              \
-  namespace internal {                                                            \
-  template <typename XprType>                                                     \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, SIZE, 1, true> { \
-    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }          \
-  };                                                                              \
-  template <typename XprType>                                                     \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, 1, SIZE, true> { \
-    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }          \
-  };                                                                              \
-  }
-
-EIGEN_GL_FUNC_DECLARATION(glVertex)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 2, 2iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 2, 2sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 2, 2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 2, 2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 3, 3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 3, 3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 3, 3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 3, 3dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 4, 4iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 4, 4sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 4, 4fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 4, 4dv)
-
-EIGEN_GL_FUNC_DECLARATION(glTexCoord)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 2, 2iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 2, 2sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 2, 2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 2, 2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 3, 3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 3, 3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 3, 3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 3, 3dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 4, 4iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 4, 4sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 4, 4fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 4, 4dv)
-
-EIGEN_GL_FUNC_DECLARATION(glColor)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 2, 2iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 2, 2sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 2, 2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 2, 2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 3, 3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 3, 3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 3, 3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 3, 3dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 4, 4iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 4, 4sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 4, 4fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 4, 4dv)
-
-EIGEN_GL_FUNC_DECLARATION(glNormal)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, int, 3, 3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, short, 3, 3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, float, 3, 3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, double, 3, 3dv)
-
-inline void glScale2fv(const float* v) { glScalef(v[0], v[1], 1.f); }
-inline void glScale2dv(const double* v) { glScaled(v[0], v[1], 1.0); }
-inline void glScale3fv(const float* v) { glScalef(v[0], v[1], v[2]); }
-inline void glScale3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
-
-EIGEN_GL_FUNC_DECLARATION(glScale)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, float, 2, 2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, double, 2, 2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, float, 3, 3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, double, 3, 3dv)
-
-template <typename Scalar>
-void glScale(const UniformScaling<Scalar>& s) {
-  glScale(Matrix<Scalar, 3, 1>::Constant(s.factor()));
-}
-
-inline void glTranslate2fv(const float* v) { glTranslatef(v[0], v[1], 0.f); }
-inline void glTranslate2dv(const double* v) { glTranslated(v[0], v[1], 0.0); }
-inline void glTranslate3fv(const float* v) { glTranslatef(v[0], v[1], v[2]); }
-inline void glTranslate3dv(const double* v) { glTranslated(v[0], v[1], v[2]); }
-
-EIGEN_GL_FUNC_DECLARATION(glTranslate)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, float, 2, 2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, double, 2, 2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, float, 3, 3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, double, 3, 3dv)
-
-template <typename Scalar>
-void glTranslate(const Translation<Scalar, 2>& t) {
-  glTranslate(t.vector());
-}
-template <typename Scalar>
-void glTranslate(const Translation<Scalar, 3>& t) {
-  glTranslate(t.vector());
-}
-
-EIGEN_GL_FUNC_DECLARATION(glMultMatrix)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix, float, 4, 4, f)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix, double, 4, 4, d)
-
-template <typename Scalar>
-void glMultMatrix(const Transform<Scalar, 3, Affine>& t) {
-  glMultMatrix(t.matrix());
-}
-template <typename Scalar>
-void glMultMatrix(const Transform<Scalar, 3, Projective>& t) {
-  glMultMatrix(t.matrix());
-}
-template <typename Scalar>
-void glMultMatrix(const Transform<Scalar, 3, AffineCompact>& t) {
-  glMultMatrix(Transform<Scalar, 3, Affine>(t).matrix());
-}
-
-EIGEN_GL_FUNC_DECLARATION(glLoadMatrix)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix, float, 4, 4, f)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix, double, 4, 4, d)
-
-template <typename Scalar>
-void glLoadMatrix(const Transform<Scalar, 3, Affine>& t) {
-  glLoadMatrix(t.matrix());
-}
-template <typename Scalar>
-void glLoadMatrix(const Transform<Scalar, 3, Projective>& t) {
-  glLoadMatrix(t.matrix());
-}
-template <typename Scalar>
-void glLoadMatrix(const Transform<Scalar, 3, AffineCompact>& t) {
-  glLoadMatrix(Transform<Scalar, 3, Affine>(t).matrix());
-}
-
-inline void glRotate(const Rotation2D<float>& rot) { glRotatef(rot.angle() * 180.f / float(EIGEN_PI), 0.f, 0.f, 1.f); }
-inline void glRotate(const Rotation2D<double>& rot) {
-  glRotated(rot.angle() * 180.0 / double(EIGEN_PI), 0.0, 0.0, 1.0);
-}
-
-template <typename Derived>
-void glRotate(const RotationBase<Derived, 3>& rot) {
-  Transform<typename Derived::Scalar, 3, Projective> tr(rot);
-  glMultMatrix(tr.matrix());
-}
-
-#define EIGEN_GL_MAKE_CONST_const const
-#define EIGEN_GL_MAKE_CONST__
-#define EIGEN_GL_EVAL(X) X
-
-#define EIGEN_GL_FUNC1_DECLARATION(FUNC, ARG1, CONST)                                                            \
-  namespace internal {                                                                                           \
-  template <typename XprType, typename Scalar = typename XprType::Scalar, int Rows = XprType::RowsAtCompileTime, \
-            int Cols = XprType::ColsAtCompileTime,                                                               \
-            bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags & LinearAccessBit) &&                 \
-                                  bool(XprType::Flags & DirectAccessBit) &&                                      \
-                                  (XprType::IsVectorAtCompileTime || (XprType::Flags & RowMajorBit) == 0)>       \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl);                                                                 \
-                                                                                                                 \
-  template <typename XprType, typename Scalar, int Rows, int Cols>                                               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, Scalar, Rows, Cols, false> {                            \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) {                      \
-      EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<typename plain_matrix_type_column_major<XprType>::type>::run(a, p); \
-    }                                                                                                            \
-  };                                                                                                             \
-  }                                                                                                              \
-                                                                                                                 \
-  template <typename Derived>                                                                                    \
-  inline void FUNC(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) {            \
-    EIGEN_CAT(EIGEN_CAT(internal::gl_, FUNC), _impl)<Derived>::run(a, p.derived());                              \
-  }
-
-#define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC, ARG1, CONST, SCALAR, ROWS, COLS, SUFFIX)    \
-  namespace internal {                                                                      \
-  template <typename XprType>                                                               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, ROWS, COLS, true> {        \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
-      FUNC##SUFFIX(a, p.data());                                                            \
-    }                                                                                       \
-  };                                                                                        \
-  }
-
-#define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC, ARG1, CONST, SCALAR, SIZE, SUFFIX)          \
-  namespace internal {                                                                      \
-  template <typename XprType>                                                               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, SIZE, 1, true> {           \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
-      FUNC##SUFFIX(a, p.data());                                                            \
-    }                                                                                       \
-  };                                                                                        \
-  template <typename XprType>                                                               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, 1, SIZE, true> {           \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
-      FUNC##SUFFIX(a, p.data());                                                            \
-    }                                                                                       \
-  };                                                                                        \
-  }
-
-EIGEN_GL_FUNC1_DECLARATION(glGet, GLenum, _)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet, GLenum, _, float, 4, 4, Floatv)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet, GLenum, _, double, 4, 4, Doublev)
-
-// glUniform API
-
-#ifdef GL_VERSION_2_0
-
-inline void glUniform2fv_ei(GLint loc, const float* v) { glUniform2fv(loc, 1, v); }
-inline void glUniform2iv_ei(GLint loc, const int* v) { glUniform2iv(loc, 1, v); }
-
-inline void glUniform3fv_ei(GLint loc, const float* v) { glUniform3fv(loc, 1, v); }
-inline void glUniform3iv_ei(GLint loc, const int* v) { glUniform3iv(loc, 1, v); }
-
-inline void glUniform4fv_ei(GLint loc, const float* v) { glUniform4fv(loc, 1, v); }
-inline void glUniform4iv_ei(GLint loc, const int* v) { glUniform4iv(loc, 1, v); }
-
-inline void glUniformMatrix2fv_ei(GLint loc, const float* v) { glUniformMatrix2fv(loc, 1, false, v); }
-inline void glUniformMatrix3fv_ei(GLint loc, const float* v) { glUniformMatrix3fv(loc, 1, false, v); }
-inline void glUniformMatrix4fv_ei(GLint loc, const float* v) { glUniformMatrix4fv(loc, 1, false, v); }
-
-EIGEN_GL_FUNC1_DECLARATION(glUniform, GLint, const)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 2, 2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 2, 2iv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 3, 3fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 3, 3iv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 4, 4fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 4, 4iv_ei)
-
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 2, Matrix2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 3, Matrix3fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 4, Matrix4fv_ei)
-
-#endif
-
-#ifdef GL_VERSION_2_1
-
-inline void glUniformMatrix2x3fv_ei(GLint loc, const float* v) { glUniformMatrix2x3fv(loc, 1, false, v); }
-inline void glUniformMatrix3x2fv_ei(GLint loc, const float* v) { glUniformMatrix3x2fv(loc, 1, false, v); }
-inline void glUniformMatrix2x4fv_ei(GLint loc, const float* v) { glUniformMatrix2x4fv(loc, 1, false, v); }
-inline void glUniformMatrix4x2fv_ei(GLint loc, const float* v) { glUniformMatrix4x2fv(loc, 1, false, v); }
-inline void glUniformMatrix3x4fv_ei(GLint loc, const float* v) { glUniformMatrix3x4fv(loc, 1, false, v); }
-inline void glUniformMatrix4x3fv_ei(GLint loc, const float* v) { glUniformMatrix4x3fv(loc, 1, false, v); }
-
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 3, Matrix2x3fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 2, Matrix3x2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 4, Matrix2x4fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 2, Matrix4x2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 4, Matrix3x4fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 3, Matrix4x3fv_ei)
-
-#endif
-
-#ifdef GL_VERSION_3_0
-
-inline void glUniform2uiv_ei(GLint loc, const unsigned int* v) { glUniform2uiv(loc, 1, v); }
-inline void glUniform3uiv_ei(GLint loc, const unsigned int* v) { glUniform3uiv(loc, 1, v); }
-inline void glUniform4uiv_ei(GLint loc, const unsigned int* v) { glUniform4uiv(loc, 1, v); }
-
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 2, 2uiv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 3, 3uiv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 4, 4uiv_ei)
-
-#endif
-
-#ifdef GL_ARB_gpu_shader_fp64
-inline void glUniform2dv_ei(GLint loc, const double* v) { glUniform2dv(loc, 1, v); }
-inline void glUniform3dv_ei(GLint loc, const double* v) { glUniform3dv(loc, 1, v); }
-inline void glUniform4dv_ei(GLint loc, const double* v) { glUniform4dv(loc, 1, v); }
-
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 2, 2dv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 3, 3dv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 4, 4dv_ei)
-#endif
-
-//@}
-
-}  // namespace Eigen
-
-#endif  // EIGEN_OPENGL_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_OPENGLSUPPORT_FORWARD_H
diff --git a/unsupported/Eigen/Polynomials b/unsupported/Eigen/Polynomials
index aa9aa8e..ddf1f85 100644
--- a/unsupported/Eigen/Polynomials
+++ b/unsupported/Eigen/Polynomials
@@ -1,140 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/Polynomials>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_POLYNOMIALS_MODULE_H
-#define EIGEN_POLYNOMIALS_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_POLYNOMIALS_FORWARD_H
+#define EIGEN_UNSUPPORTED_POLYNOMIALS_FORWARD_H
 
-#include "../../Eigen/Core"
+#include "../../contrib/Eigen/Polynomials"  // IWYU pragma: export
 
-#include "../../Eigen/Eigenvalues"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
-#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS >= 2)
-#ifndef EIGEN_HIDE_HEAVY_CODE
-#define EIGEN_HIDE_HEAVY_CODE
-#endif
-#elif defined EIGEN_HIDE_HEAVY_CODE
-#undef EIGEN_HIDE_HEAVY_CODE
-#endif
-
-/**
- * \defgroup Polynomials_Module Polynomials module
- * \brief This module provides a QR based polynomial solver.
- *
- * To use this module, add
- * \code
- * #include <unsupported/Eigen/Polynomials>
- * \endcode
- * at the start of your source file.
- */
-
-// IWYU pragma: begin_exports
-#include "src/Polynomials/PolynomialUtils.h"
-#include "src/Polynomials/Companion.h"
-#include "src/Polynomials/PolynomialSolver.h"
-// IWYU pragma: end_exports
-
-/**
-        \page polynomials Polynomials defines functions for dealing with polynomials
-        and a QR based polynomial solver.
-        \ingroup Polynomials_Module
-
-        The remainder of the page documents first the functions for evaluating, computing
-        polynomials, computing estimates about polynomials and next the QR based polynomial
-        solver.
-
-        \section polynomialUtils convenient functions to deal with polynomials
-        \subsection roots_to_monicPolynomial
-        The function
-        \code
-        void roots_to_monicPolynomial( const RootVector& rv, Polynomial& poly )
-        \endcode
-        computes the coefficients \f$ a_i \f$ of
-
-        \f$ p(x) = a_0 + a_{1}x + ... + a_{n-1}x^{n-1} + x^n \f$
-
-        where \f$ p \f$ is known through its roots i.e. \f$ p(x) = (x-r_1)(x-r_2)...(x-r_n) \f$.
-
-        \subsection poly_eval
-        The function
-        \code
-        T poly_eval( const Polynomials& poly, const T& x )
-        \endcode
-        evaluates a polynomial at a given point using stabilized H&ouml;rner method.
-
-        The following code: first computes the coefficients in the monomial basis of the monic polynomial that has the
-  provided roots; then, it evaluates the computed polynomial, using a stabilized H&ouml;rner method.
-
-        \include PolynomialUtils1.cpp
-  Output: \verbinclude PolynomialUtils1.out
-
-        \subsection Cauchy bounds
-        The function
-        \code
-        Real cauchy_max_bound( const Polynomial& poly )
-        \endcode
-        provides a maximum bound (the Cauchy one: \f$C(p)\f$) for the absolute value of a root of the given polynomial
-  i.e. \f$ \forall r_i \f$ root of \f$ p(x) = \sum_{k=0}^d a_k x^k \f$, \f$ |r_i| \le C(p) = \sum_{k=0}^{d} \left |
-  \frac{a_k}{a_d} \right | \f$ The leading coefficient \f$ p \f$: should be non zero \f$a_d \neq 0\f$.
-
-
-        The function
-        \code
-        Real cauchy_min_bound( const Polynomial& poly )
-        \endcode
-        provides a minimum bound (the Cauchy one: \f$c(p)\f$) for the absolute value of a non zero root of the given
-  polynomial i.e. \f$ \forall r_i \neq 0 \f$ root of \f$ p(x) = \sum_{k=0}^d a_k x^k \f$, \f$ |r_i| \ge c(p) = \left(
-  \sum_{k=0}^{d} \left | \frac{a_k}{a_0} \right | \right)^{-1} \f$
-
-
-
-
-        \section QR polynomial solver class
-        Computes the complex roots of a polynomial by computing the eigenvalues of the associated companion matrix with
-  the QR algorithm.
-
-        The roots of \f$ p(x) = a_0 + a_1 x + a_2 x^2 + a_{3} x^3 + x^4 \f$ are the eigenvalues of
-        \f$
-        \left [
-        \begin{array}{cccc}
-        0 & 0 &  0 & a_0 \\
-        1 & 0 &  0 & a_1 \\
-        0 & 1 &  0 & a_2 \\
-        0 & 0 &  1 & a_3
-        \end{array} \right ]
-        \f$
-
-        However, the QR algorithm is not guaranteed to converge when there are several eigenvalues with same modulus.
-
-        Therefore the current polynomial solver is guaranteed to provide a correct result only when the complex roots
-  \f$r_1,r_2,...,r_d\f$ have distinct moduli i.e.
-
-        \f$ \forall i,j \in [1;d],~ \| r_i \| \neq \| r_j \| \f$.
-
-        With 32bit (float) floating types this problem shows up frequently.
-  However, almost always, correct accuracy is reached even in these cases for 64bit
-  (double) floating types and small polynomial degree (<20).
-
-        \include PolynomialSolver1.cpp
-
-        In the above example:
-
-        -# a simple use of the polynomial solver is shown;
-        -# the accuracy problem with the QR algorithm is presented: a polynomial with almost conjugate roots is provided
-  to the solver. Those roots have almost same module therefore the QR algorithm failed to converge: the accuracy of the
-  last root is bad;
-        -# a simple way to circumvent the problem is shown: use doubles instead of floats.
-
-  Output: \verbinclude PolynomialSolver1.out
-*/
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_POLYNOMIALS_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_POLYNOMIALS_FORWARD_H
diff --git a/unsupported/Eigen/SparseExtra b/unsupported/Eigen/SparseExtra
index 00a87c5..2674df1 100644
--- a/unsupported/Eigen/SparseExtra
+++ b/unsupported/Eigen/SparseExtra
@@ -1,60 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/SparseExtra>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_SPARSE_EXTRA_MODULE_H
-#define EIGEN_SPARSE_EXTRA_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_SPARSEEXTRA_FORWARD_H
+#define EIGEN_UNSUPPORTED_SPARSEEXTRA_FORWARD_H
 
-#include "../../Eigen/Sparse"
+#include "../../contrib/Eigen/SparseExtra"  // IWYU pragma: export
 
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-#include <vector>
-#include <map>
-#include <unordered_map>
-#include <cstdlib>
-#include <cstring>
-#include <algorithm>
-#include <fstream>
-#include <sstream>
-
-#ifdef EIGEN_GOOGLEHASH_SUPPORT
-#include <google/dense_hash_map>
-#include <google/sparse_hash_map>
-#endif
-
-/**
- * \defgroup SparseExtra_Module SparseExtra module
- *
- * This module contains some experimental features extending the sparse module:
- * - A RandomSetter which is a wrapper object allowing to set/update a sparse matrix with random access.
- * - A SparseInverse which calculates a sparse subset of the inverse of a sparse matrix corresponding to nonzeros of the
- * input
- * - MatrixMarket format(https://math.nist.gov/MatrixMarket/formats.html) readers and writers for sparse and dense
- * matrices.
- *
- * \code
- * #include <unsupported/Eigen/SparseExtra>
- * \endcode
- */
-
-// IWYU pragma: begin_exports
-#include "src/SparseExtra/RandomSetter.h"
-#include "src/SparseExtra/SparseInverse.h"
-
-#include "src/SparseExtra/MarketIO.h"
-
-#if !defined(_WIN32)
-#include <dirent.h>
-#include "src/SparseExtra/MatrixMarketIterator.h"
-#endif
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_SPARSE_EXTRA_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_SPARSEEXTRA_FORWARD_H
diff --git a/unsupported/Eigen/SpecialFunctions b/unsupported/Eigen/SpecialFunctions
index 376b025..45189ca 100644
--- a/unsupported/Eigen/SpecialFunctions
+++ b/unsupported/Eigen/SpecialFunctions
@@ -1,107 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2016 Gael Guennebaud <g.gael@free.fr>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/SpecialFunctions>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_SPECIALFUNCTIONS_MODULE_H
-#define EIGEN_SPECIALFUNCTIONS_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_SPECIALFUNCTIONS_FORWARD_H
+#define EIGEN_UNSUPPORTED_SPECIALFUNCTIONS_FORWARD_H
 
-#include <math.h>
+#include "../../contrib/Eigen/SpecialFunctions"  // IWYU pragma: export
 
-#include "../../Eigen/Core"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-namespace Eigen {
-
-/**
- * \defgroup SpecialFunctions_Module Special math functions module
- *
- * This module features additional coefficient-wise math functions available
- * within the numext:: namespace for the scalar version, and as method and/or free
- * functions of Array. Those include:
- *
- * - erf
- * - erfc
- * - lgamma
- * - igamma
- * - igamma_der_a
- * - gamma_sample_der_alpha
- * - igammac
- * - digamma
- * - ndtri
- * - polygamma
- * - zeta
- * - betainc
- *
- * Bessel Functions
- * - bessel_i0
- * - bessel_i0e
- * - bessel_i1
- * - bessel_i1e
- * - bessel_j0
- * - bessel_j1
- * - bessel_k0
- * - bessel_k0e
- * - bessel_k1
- * - bessel_k1e
- * - bessel_y0
- * - bessel_y1
- *
- * \code
- * #include <unsupported/Eigen/SpecialFunctions>
- * \endcode
- */
-//@{
-
-}  // namespace Eigen
-
-// IWYU pragma: begin_exports
-#include "src/SpecialFunctions/BesselFunctionsImpl.h"
-#include "src/SpecialFunctions/BesselFunctionsBFloat16.h"
-#include "src/SpecialFunctions/BesselFunctionsHalf.h"
-#include "src/SpecialFunctions/BesselFunctionsPacketMath.h"
-#include "src/SpecialFunctions/BesselFunctionsFunctors.h"
-#include "src/SpecialFunctions/BesselFunctionsArrayAPI.h"
-#include "src/SpecialFunctions/SpecialFunctionsImpl.h"
-#if defined(EIGEN_HIPCC)
-#include "src/SpecialFunctions/HipVectorCompatibility.h"
-#endif
-#include "src/SpecialFunctions/SpecialFunctionsBFloat16.h"
-#include "src/SpecialFunctions/SpecialFunctionsHalf.h"
-#include "src/SpecialFunctions/SpecialFunctionsPacketMath.h"
-#include "src/SpecialFunctions/SpecialFunctionsFunctors.h"
-#include "src/SpecialFunctions/SpecialFunctionsArrayAPI.h"
-
-#ifndef EIGEN_VECTORIZE_GENERIC
-// TODO(rmlarsen): Make these work with generic vectorization if possible.
-#if defined EIGEN_VECTORIZE_AVX512
-#include "src/SpecialFunctions/arch/AVX/BesselFunctions.h"
-#include "src/SpecialFunctions/arch/AVX/SpecialFunctions.h"
-#include "src/SpecialFunctions/arch/AVX512/BesselFunctions.h"
-#include "src/SpecialFunctions/arch/AVX512/SpecialFunctions.h"
-#elif defined EIGEN_VECTORIZE_AVX
-#include "src/SpecialFunctions/arch/AVX/BesselFunctions.h"
-#include "src/SpecialFunctions/arch/AVX/SpecialFunctions.h"
-#elif defined EIGEN_VECTORIZE_NEON
-#include "src/SpecialFunctions/arch/NEON/BesselFunctions.h"
-#include "src/SpecialFunctions/arch/NEON/SpecialFunctions.h"
-#endif
-
-#if defined EIGEN_VECTORIZE_GPU
-#include "src/SpecialFunctions/arch/GPU/SpecialFunctions.h"
-#endif
-#endif
-// IWYU pragma: end_exports
-
-namespace Eigen {
-//@}
-}
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_SPECIALFUNCTIONS_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_SPECIALFUNCTIONS_FORWARD_H
diff --git a/unsupported/Eigen/Splines b/unsupported/Eigen/Splines
index 632095d..6587f37 100644
--- a/unsupported/Eigen/Splines
+++ b/unsupported/Eigen/Splines
@@ -1,36 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 20010-2011 Hauke Heibel <hauke.heibel@gmail.com>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/Splines>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_SPLINES_MODULE_H
-#define EIGEN_SPLINES_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_SPLINES_FORWARD_H
+#define EIGEN_UNSUPPORTED_SPLINES_FORWARD_H
 
-namespace Eigen {
-/**
- * \defgroup Splines_Module Spline and spline fitting module
- *
- * This module provides a simple multi-dimensional spline class while
- * offering most basic functionality to fit a spline to point sets.
- *
- * \code
- * #include <unsupported/Eigen/Splines>
- * \endcode
- */
-}
+#include "../../contrib/Eigen/Splines"  // IWYU pragma: export
 
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#include "src/Splines/SplineFwd.h"
-#include "src/Splines/Spline.h"
-#include "src/Splines/SplineFitting.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_SPLINES_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_SPLINES_FORWARD_H
diff --git a/unsupported/Eigen/StructuredMatrices b/unsupported/Eigen/StructuredMatrices
new file mode 100644
index 0000000..3f5f268
--- /dev/null
+++ b/unsupported/Eigen/StructuredMatrices
@@ -0,0 +1,17 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/StructuredMatrices>
+// directly. This shim preserves the legacy include path.
+
+#ifndef EIGEN_UNSUPPORTED_STRUCTUREDMATRICES_FORWARD_H
+#define EIGEN_UNSUPPORTED_STRUCTUREDMATRICES_FORWARD_H
+
+#include "../../contrib/Eigen/StructuredMatrices"  // IWYU pragma: export
+
+#endif  // EIGEN_UNSUPPORTED_STRUCTUREDMATRICES_FORWARD_H
diff --git a/unsupported/Eigen/Tensor b/unsupported/Eigen/Tensor
index 6053b01..7e5d6c0 100644
--- a/unsupported/Eigen/Tensor
+++ b/unsupported/Eigen/Tensor
@@ -1,142 +1,14 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/Tensor>
+// directly. This shim preserves the legacy include path.
 
-// #ifndef EIGEN_CXX11_TENSOR_MODULE_H
-#define EIGEN_CXX11_TENSOR_MODULE_H
-
-#include "../../Eigen/Core"
-
-#include "SpecialFunctions"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-// IWYU pragma: begin_exports
-#include "../../Eigen/src/Core/util/Meta.h"
-#include "../../Eigen/src/Core/util/MaxSizeVector.h"
-// IWYU pragma: end_exports
-
-/** \defgroup CXX11_Tensor_Module Tensor Module
- *
- * This module provides a Tensor class for storing arbitrarily indexed
- * objects.
- *
- * \code
- * #include <unsupported/Eigen/Tensor>
- * \endcode
- *
- * Much of the documentation can be found \ref eigen_tensors "here".
- */
-
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <cstddef>
-#include <cstring>
-#include <iterator>
-#include <numeric>
-#include <random>
-#include <thread>
-
-#if defined(EIGEN_USE_THREADS) || defined(EIGEN_USE_SYCL)
-#include "../../Eigen/ThreadPool"
-#endif
-
-#ifdef EIGEN_USE_GPU
-#include <iostream>
-#if defined(EIGEN_USE_HIP)
-#include <hip/hip_runtime.h>
-#else
-#include <cuda_runtime.h>
-#endif
-#endif
-
-// IWYU pragma: begin_exports
-#include "src/Tensor/TensorMacros.h"
-#include "src/Tensor/TensorForwardDeclarations.h"
-#include "src/Tensor/TensorMeta.h"
-#include "src/Tensor/TensorFunctors.h"
-#include "src/Tensor/TensorCostModel.h"
-#include "src/Tensor/TensorDeviceDefault.h"
-#include "src/Tensor/TensorDeviceThreadPool.h"
-#include "src/Tensor/TensorDeviceGpu.h"
-#ifndef gpu_assert
-#define gpu_assert(x)
-#endif
-#include "src/Tensor/TensorDeviceSycl.h"
-#include "src/Tensor/TensorIndexList.h"
-#include "src/Tensor/TensorDimensionList.h"
-#include "src/Tensor/TensorDimensions.h"
-#include "src/Tensor/TensorInitializer.h"
-#include "src/Tensor/TensorTraits.h"
-#include "src/Tensor/TensorRandom.h"
-#include "src/Tensor/TensorUInt128.h"
-#include "src/Tensor/TensorIntDiv.h"
-#include "src/Tensor/TensorGlobalFunctions.h"
-
-#include "src/Tensor/TensorIO.h"
-
-#include "src/Tensor/TensorBase.h"
-#include "src/Tensor/TensorBlock.h"
-
-#include "src/Tensor/TensorEvaluator.h"
-#include "src/Tensor/TensorExpr.h"
-#include "src/Tensor/TensorReduction.h"
-#include "src/Tensor/TensorReductionGpu.h"
-#include "src/Tensor/TensorArgMax.h"
-#include "src/Tensor/TensorConcatenation.h"
-#include "src/Tensor/TensorContractionMapper.h"
-#include "src/Tensor/TensorContractionBlocking.h"
-#include "src/Tensor/TensorContraction.h"
-#include "src/Tensor/TensorContractionThreadPool.h"
-#include "src/Tensor/TensorContractionGpu.h"
-#include "src/Tensor/TensorConversion.h"
-#include "src/Tensor/TensorConvolution.h"
-#include "src/Tensor/TensorFFT.h"
-#include "src/Tensor/TensorPatch.h"
-#include "src/Tensor/TensorImagePatch.h"
-#include "src/Tensor/TensorVolumePatch.h"
-#include "src/Tensor/TensorBroadcasting.h"
-#include "src/Tensor/TensorChipping.h"
-#include "src/Tensor/TensorInflation.h"
-#include "src/Tensor/TensorLayoutSwap.h"
-#include "src/Tensor/TensorMorphing.h"
-#include "src/Tensor/TensorPadding.h"
-#include "src/Tensor/TensorReverse.h"
-#include "src/Tensor/TensorRoll.h"
-#include "src/Tensor/TensorShuffling.h"
-#include "src/Tensor/TensorStriding.h"
-#include "src/Tensor/TensorCustomOp.h"
-#include "src/Tensor/TensorEvalTo.h"
-#include "src/Tensor/TensorForcedEval.h"
-#include "src/Tensor/TensorGenerator.h"
-#include "src/Tensor/TensorAssign.h"
-#include "src/Tensor/TensorScan.h"
-#include "src/Tensor/TensorTrace.h"
-
-#ifdef EIGEN_USE_SYCL
-#include "src/Tensor/TensorReductionSycl.h"
-#include "src/Tensor/TensorConvolutionSycl.h"
-#include "src/Tensor/TensorContractionSycl.h"
-#include "src/Tensor/TensorScanSycl.h"
-#endif
-
-#include "src/Tensor/TensorExecutor.h"
-#include "src/Tensor/TensorDevice.h"
-
-#include "src/Tensor/TensorStorage.h"
-#include "src/Tensor/Tensor.h"
-#include "src/Tensor/TensorFixedSize.h"
-#include "src/Tensor/TensorMap.h"
-#include "src/Tensor/TensorRef.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-// #endif // EIGEN_CXX11_TENSOR_MODULE_H
+// Forward every inclusion so the Tensor module can detect a newly enabled
+// backend and complete its device type.
+#include "../../contrib/Eigen/Tensor"  // IWYU pragma: export
diff --git a/unsupported/Eigen/TensorSymmetry b/unsupported/Eigen/TensorSymmetry
index 2981da7..8e454e3 100644
--- a/unsupported/Eigen/TensorSymmetry
+++ b/unsupported/Eigen/TensorSymmetry
@@ -1,40 +1,17 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
 //
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Forwarding header: the top-level unsupported/ directory was renamed
+// to contrib/ in Eigen 5.x. New code should use
+//   #include <contrib/Eigen/TensorSymmetry>
+// directly. This shim preserves the legacy include path.
 
-#ifndef EIGEN_CXX11_TENSORSYMMETRY_MODULE_H
-#define EIGEN_CXX11_TENSORSYMMETRY_MODULE_H
+#ifndef EIGEN_UNSUPPORTED_TENSORSYMMETRY_FORWARD_H
+#define EIGEN_UNSUPPORTED_TENSORSYMMETRY_FORWARD_H
 
-#include "Tensor"
+#include "../../contrib/Eigen/TensorSymmetry"  // IWYU pragma: export
 
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-#include "src/TensorUtil/CXX11Meta.h"
-
-/** \defgroup TensorSymmetry_Module Tensor Symmetry Module
- *
- * This module provides a classes that allow for the definition of
- * symmetries w.r.t. tensor indices.
- *
- * Including this module will implicitly include the Tensor module.
- *
- * \code
- * #include <Eigen/TensorSymmetry>
- * \endcode
- */
-
-// IWYU pragma: begin_exports
-#include "src/TensorSymmetry/util/TemplateGroupTheory.h"
-#include "src/TensorSymmetry/Symmetry.h"
-#include "src/TensorSymmetry/StaticSymmetry.h"
-#include "src/TensorSymmetry/DynamicSymmetry.h"
-// IWYU pragma: end_exports
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif  // EIGEN_CXX11_TENSORSYMMETRY_MODULE_H
+#endif  // EIGEN_UNSUPPORTED_TENSORSYMMETRY_FORWARD_H
diff --git a/unsupported/Eigen/ThreadPool b/unsupported/Eigen/ThreadPool
index 6012171..d125502 100644
--- a/unsupported/Eigen/ThreadPool
+++ b/unsupported/Eigen/ThreadPool
@@ -1 +1,17 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// SPDX-FileCopyrightText: The Eigen Authors
+// SPDX-License-Identifier: MPL-2.0
+//
+// Forwarding header: ThreadPool was promoted to a core Eigen module in
+// Eigen 5.x. New code should use
+//   #include <Eigen/ThreadPool>
+// directly. This shim preserves the legacy include path.
+
+#ifndef EIGEN_UNSUPPORTED_THREADPOOL_FORWARD_H
+#define EIGEN_UNSUPPORTED_THREADPOOL_FORWARD_H
+
 #include "../../Eigen/ThreadPool"  // IWYU pragma: export
+
+#endif  // EIGEN_UNSUPPORTED_THREADPOOL_FORWARD_H
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h b/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h
deleted file mode 100644
index a83bdc3..0000000
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_AUTODIFF_JACOBIAN_H
-#define EIGEN_AUTODIFF_JACOBIAN_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename Functor>
-class AutoDiffJacobian : public Functor {
- public:
-  AutoDiffJacobian() : Functor() {}
-  AutoDiffJacobian(const Functor& f) : Functor(f) {}
-
-  // forward constructors
-  template <typename... T>
-  AutoDiffJacobian(const T&... Values) : Functor(Values...) {}
-
-  typedef typename Functor::InputType InputType;
-  typedef typename Functor::ValueType ValueType;
-  typedef typename ValueType::Scalar Scalar;
-
-  enum { InputsAtCompileTime = InputType::RowsAtCompileTime, ValuesAtCompileTime = ValueType::RowsAtCompileTime };
-
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-  typedef typename JacobianType::Index Index;
-
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> DerivativeType;
-  typedef AutoDiffScalar<DerivativeType> ActiveScalar;
-
-  typedef Matrix<ActiveScalar, InputsAtCompileTime, 1> ActiveInput;
-  typedef Matrix<ActiveScalar, ValuesAtCompileTime, 1> ActiveValue;
-
-  // Some compilers don't accept variadic parameters after a default parameter,
-  // i.e., we can't just write _jac=0 but we need to overload operator():
-  EIGEN_STRONG_INLINE void operator()(const InputType& x, ValueType* v) const { this->operator()(x, v, 0); }
-  template <typename... ParamsType>
-  void operator()(const InputType& x, ValueType* v, JacobianType* _jac, const ParamsType&... Params) const {
-    eigen_assert(v != 0);
-
-    if (!_jac) {
-      Functor::operator()(x, v, Params...);
-      return;
-    }
-
-    JacobianType& jac = *_jac;
-
-    ActiveInput ax = x.template cast<ActiveScalar>();
-    ActiveValue av(jac.rows());
-
-    if (InputsAtCompileTime == Dynamic)
-      for (Index j = 0; j < jac.rows(); j++) av[j].derivatives().resize(x.rows());
-
-    for (Index i = 0; i < jac.cols(); i++) ax[i].derivatives() = DerivativeType::Unit(x.rows(), i);
-
-    Functor::operator()(ax, &av, Params...);
-
-    for (Index i = 0; i < jac.rows(); i++) {
-      (*v)[i] = av[i].value();
-      jac.row(i) = av[i].derivatives();
-    }
-  }
-};
-
-}  // namespace Eigen
-
-#endif  // EIGEN_AUTODIFF_JACOBIAN_H
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
deleted file mode 100644
index ea481fc..0000000
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
+++ /dev/null
@@ -1,571 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_AUTODIFF_SCALAR_H
-#define EIGEN_AUTODIFF_SCALAR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename DerivativeType, bool Enable>
-struct auto_diff_special_op;
-
-template <typename DerivativeType, typename OtherDerivativeType, typename EnableIf = void>
-struct maybe_coherent_pad_helper {
-  static constexpr int SizeAtCompileTime =
-      max_size_prefer_dynamic(DerivativeType::SizeAtCompileTime, OtherDerivativeType::SizeAtCompileTime);
-  using type = CoherentPadOp<DerivativeType, SizeAtCompileTime>;
-  static type pad(const DerivativeType& x, const OtherDerivativeType& y) {
-    // CoherentPadOp uses variable_if_dynamic<SizeAtCompileTime>.  In this case, `SizeAtCompileTime` might
-    // by Dynamic, so we need to take the runtime maximum of x, y.
-    return CoherentPadOp<DerivativeType, SizeAtCompileTime>(x, numext::maxi(x.size(), y.size()));
-  }
-};
-
-// Both are fixed-sized and equal, don't need to pad.
-// Both are fixed-size and this is larger than other, don't need to pad.
-template <typename DerivativeType, typename OtherDerivativeType>
-struct maybe_coherent_pad_helper<
-    DerivativeType, OtherDerivativeType,
-    std::enable_if_t<enum_ge_not_dynamic(DerivativeType::SizeAtCompileTime, OtherDerivativeType::SizeAtCompileTime)>> {
-  using type = const DerivativeType&;
-  static const DerivativeType& pad(const DerivativeType& x, const OtherDerivativeType& /*y*/) { return x; }
-};
-
-template <typename DerivativeType, typename OtherDerivativeType>
-typename maybe_coherent_pad_helper<DerivativeType, OtherDerivativeType>::type MaybeCoherentPad(
-    const DerivativeType& x, const OtherDerivativeType& y) {
-  return maybe_coherent_pad_helper<DerivativeType, OtherDerivativeType>::pad(x, y);
-}
-
-template <typename Op, typename LhsDerivativeType, typename RhsDerivativeType>
-auto MakeCoherentCwiseBinaryOp(const LhsDerivativeType& x, const RhsDerivativeType& y, Op op = Op()) {
-  const auto& lhs = MaybeCoherentPad(x, y);
-  const auto& rhs = MaybeCoherentPad(y, x);
-  return CwiseBinaryOp<Op, remove_all_t<decltype(lhs)>, remove_all_t<decltype(rhs)>>(lhs, rhs, op);
-}
-
-}  // namespace internal
-
-template <typename DerivativeType>
-class AutoDiffScalar;
-
-template <typename NewDerType>
-inline AutoDiffScalar<NewDerType> MakeAutoDiffScalar(const typename NewDerType::Scalar& value, const NewDerType& der) {
-  return AutoDiffScalar<NewDerType>(value, der);
-}
-
-/** \class AutoDiffScalar
- * \brief A scalar type replacement with automatic differentiation capability
- *
- * \param DerivativeType the vector type used to store/represent the derivatives. The base scalar type
- *                 as well as the number of derivatives to compute are determined from this type.
- *                 Typical choices include, e.g., \c Vector4f for 4 derivatives, or \c VectorXf
- *                 if the number of derivatives is not known at compile time, and/or, the number
- *                 of derivatives is large.
- *                 Note that DerivativeType can also be a reference (e.g., \c VectorXf&) to wrap a
- *                 existing vector into an AutoDiffScalar.
- *                 Finally, DerivativeType can also be any Eigen compatible expression.
- *
- * This class represents a scalar value while tracking its respective derivatives using Eigen's expression
- * template mechanism.
- *
- * It supports the following list of global math function:
- *  - std::abs, std::sqrt, std::pow, std::exp, std::log, std::sin, std::cos,
- *  - internal::abs, internal::sqrt, numext::pow, internal::exp, internal::log, internal::sin, internal::cos,
- *  - internal::conj, internal::real, internal::imag, numext::abs2.
- *
- * AutoDiffScalar can be used as the scalar type of an Eigen::Matrix object. However,
- * in that case, the expression template mechanism only occurs at the top Matrix level,
- * while derivatives are computed right away.
- *
- */
-
-template <typename DerivativeType>
-class AutoDiffScalar
-    : public internal::auto_diff_special_op<
-          DerivativeType, !internal::is_same<typename internal::traits<internal::remove_all_t<DerivativeType>>::Scalar,
-                                             typename NumTraits<typename internal::traits<
-                                                 internal::remove_all_t<DerivativeType>>::Scalar>::Real>::value> {
- public:
-  typedef internal::auto_diff_special_op<
-      DerivativeType,
-      !internal::is_same<
-          typename internal::traits<internal::remove_all_t<DerivativeType>>::Scalar,
-          typename NumTraits<typename internal::traits<internal::remove_all_t<DerivativeType>>::Scalar>::Real>::value>
-      Base;
-  typedef internal::remove_all_t<DerivativeType> DerType;
-  typedef typename internal::traits<DerType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real Real;
-
-  using Base::operator+;
-  using Base::operator*;
-
-  /** Default constructor without any initialization. */
-  AutoDiffScalar() {}
-
-  /** Constructs an active scalar from its \a value,
-      and initializes the \a nbDer derivatives such that it corresponds to the \a derNumber -th variable */
-  AutoDiffScalar(const Scalar& value, int nbDer, int derNumber) : m_value(value), m_derivatives(DerType::Zero(nbDer)) {
-    m_derivatives.coeffRef(derNumber) = Scalar(1);
-  }
-
-  /** Conversion from a scalar constant to an active scalar.
-   * The derivatives are set to zero. */
-  /*explicit*/ AutoDiffScalar(const Real& value) : m_value(value) {
-    if (m_derivatives.size() > 0) m_derivatives.setZero();
-  }
-
-  /** Constructs an active scalar from its \a value and derivatives \a der */
-  AutoDiffScalar(const Scalar& value, const DerType& der) : m_value(value), m_derivatives(der) {}
-
-  template <typename OtherDerType>
-  AutoDiffScalar(
-      const AutoDiffScalar<OtherDerType>& other
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-      ,
-      std::enable_if_t<
-          internal::is_same<Scalar, typename internal::traits<internal::remove_all_t<OtherDerType>>::Scalar>::value &&
-              internal::is_convertible<OtherDerType, DerType>::value,
-          void*> = 0
-#endif
-      )
-      : m_value(other.value()), m_derivatives(other.derivatives()) {
-  }
-
-  friend std::ostream& operator<<(std::ostream& s, const AutoDiffScalar& a) { return s << a.value(); }
-
-  AutoDiffScalar(const AutoDiffScalar& other) : m_value(other.value()), m_derivatives(other.derivatives()) {}
-
-  template <typename OtherDerType>
-  inline AutoDiffScalar& operator=(const AutoDiffScalar<OtherDerType>& other) {
-    m_value = other.value();
-    m_derivatives = other.derivatives();
-    return *this;
-  }
-
-  inline AutoDiffScalar& operator=(const AutoDiffScalar& other) {
-    m_value = other.value();
-    m_derivatives = other.derivatives();
-    return *this;
-  }
-
-  inline AutoDiffScalar& operator=(const Scalar& other) {
-    m_value = other;
-    if (m_derivatives.size() > 0) m_derivatives.setZero();
-    return *this;
-  }
-
-  //     inline operator const Scalar& () const { return m_value; }
-  //     inline operator Scalar& () { return m_value; }
-
-  inline const Scalar& value() const { return m_value; }
-  inline Scalar& value() { return m_value; }
-
-  inline const DerType& derivatives() const { return m_derivatives; }
-  inline DerType& derivatives() { return m_derivatives; }
-
-  inline bool operator<(const Scalar& other) const { return m_value < other; }
-  inline bool operator<=(const Scalar& other) const { return m_value <= other; }
-  inline bool operator>(const Scalar& other) const { return m_value > other; }
-  inline bool operator>=(const Scalar& other) const { return m_value >= other; }
-  inline bool operator==(const Scalar& other) const { return m_value == other; }
-  inline bool operator!=(const Scalar& other) const { return m_value != other; }
-
-  friend inline bool operator<(const Scalar& a, const AutoDiffScalar& b) { return a < b.value(); }
-  friend inline bool operator<=(const Scalar& a, const AutoDiffScalar& b) { return a <= b.value(); }
-  friend inline bool operator>(const Scalar& a, const AutoDiffScalar& b) { return a > b.value(); }
-  friend inline bool operator>=(const Scalar& a, const AutoDiffScalar& b) { return a >= b.value(); }
-  friend inline bool operator==(const Scalar& a, const AutoDiffScalar& b) { return a == b.value(); }
-  friend inline bool operator!=(const Scalar& a, const AutoDiffScalar& b) { return a != b.value(); }
-
-  template <typename OtherDerType>
-  inline bool operator<(const AutoDiffScalar<OtherDerType>& b) const {
-    return m_value < b.value();
-  }
-  template <typename OtherDerType>
-  inline bool operator<=(const AutoDiffScalar<OtherDerType>& b) const {
-    return m_value <= b.value();
-  }
-  template <typename OtherDerType>
-  inline bool operator>(const AutoDiffScalar<OtherDerType>& b) const {
-    return m_value > b.value();
-  }
-  template <typename OtherDerType>
-  inline bool operator>=(const AutoDiffScalar<OtherDerType>& b) const {
-    return m_value >= b.value();
-  }
-  template <typename OtherDerType>
-  inline bool operator==(const AutoDiffScalar<OtherDerType>& b) const {
-    return m_value == b.value();
-  }
-  template <typename OtherDerType>
-  inline bool operator!=(const AutoDiffScalar<OtherDerType>& b) const {
-    return m_value != b.value();
-  }
-
-  inline AutoDiffScalar<DerType&> operator+(const Scalar& other) const {
-    return AutoDiffScalar<DerType&>(m_value + other, m_derivatives);
-  }
-
-  friend inline AutoDiffScalar<DerType&> operator+(const Scalar& a, const AutoDiffScalar& b) {
-    return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
-  }
-
-  inline AutoDiffScalar& operator+=(const Scalar& other) {
-    value() += other;
-    return *this;
-  }
-
-  template <typename OtherDerType>
-  inline auto operator+(const AutoDiffScalar<OtherDerType>& other) const {
-    return MakeAutoDiffScalar(
-        m_value + other.value(),
-        internal::MakeCoherentCwiseBinaryOp<internal::scalar_sum_op<Scalar>>(m_derivatives, other.derivatives()));
-  }
-
-  template <typename OtherDerType>
-  inline AutoDiffScalar& operator+=(const AutoDiffScalar<OtherDerType>& other) {
-    (*this) = (*this) + other;
-    return *this;
-  }
-
-  inline AutoDiffScalar<DerType&> operator-(const Scalar& b) const {
-    return AutoDiffScalar<DerType&>(m_value - b, m_derivatives);
-  }
-
-  friend inline AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>> operator-(
-      const Scalar& a, const AutoDiffScalar& b) {
-    return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>>(a - b.value(),
-                                                                                             -b.derivatives());
-  }
-
-  inline AutoDiffScalar& operator-=(const Scalar& other) {
-    value() -= other;
-    return *this;
-  }
-
-  template <typename OtherDerType>
-  inline auto operator-(const AutoDiffScalar<OtherDerType>& other) const {
-    return MakeAutoDiffScalar(m_value - other.value(),
-                              internal::MakeCoherentCwiseBinaryOp<internal::scalar_difference_op<Scalar>>(
-                                  m_derivatives, other.derivatives()));
-  }
-
-  template <typename OtherDerType>
-  inline AutoDiffScalar& operator-=(const AutoDiffScalar<OtherDerType>& other) {
-    *this = *this - other;
-    return *this;
-  }
-
-  inline AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>> operator-() const {
-    return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const DerType>>(-m_value, -m_derivatives);
-  }
-
-  inline auto operator*(const Scalar& other) const {
-    return MakeAutoDiffScalar(m_value * other, m_derivatives * other);
-  }
-
-  friend inline auto operator*(const Scalar& other, const AutoDiffScalar& a) {
-    return MakeAutoDiffScalar(a.value() * other, a.derivatives() * other);
-  }
-
-  inline auto operator/(const Scalar& other) const {
-    return MakeAutoDiffScalar(m_value / other, (m_derivatives * (Scalar(1) / other)));
-  }
-
-  friend inline auto operator/(const Scalar& other, const AutoDiffScalar& a) {
-    return MakeAutoDiffScalar(other / a.value(), a.derivatives() * (Scalar(-other) / (a.value() * a.value())));
-  }
-
-  template <typename OtherDerType>
-  inline auto operator/(const AutoDiffScalar<OtherDerType>& other) const {
-    return MakeAutoDiffScalar(m_value / other.value(),
-                              internal::MakeCoherentCwiseBinaryOp<internal::scalar_difference_op<Scalar>>(
-                                  m_derivatives * other.value(), (other.derivatives() * m_value)) *
-                                  (Scalar(1) / (other.value() * other.value())));
-  }
-
-  template <typename OtherDerType>
-  inline auto operator*(const AutoDiffScalar<OtherDerType>& other) const {
-    return MakeAutoDiffScalar(m_value * other.value(),
-                              internal::MakeCoherentCwiseBinaryOp<internal::scalar_sum_op<Scalar>>(
-                                  m_derivatives * other.value(), other.derivatives() * m_value));
-  }
-
-  inline AutoDiffScalar& operator*=(const Scalar& other) {
-    *this = *this * other;
-    return *this;
-  }
-
-  template <typename OtherDerType>
-  inline AutoDiffScalar& operator*=(const AutoDiffScalar<OtherDerType>& other) {
-    *this = *this * other;
-    return *this;
-  }
-
-  inline AutoDiffScalar& operator/=(const Scalar& other) {
-    *this = *this / other;
-    return *this;
-  }
-
-  template <typename OtherDerType>
-  inline AutoDiffScalar& operator/=(const AutoDiffScalar<OtherDerType>& other) {
-    *this = *this / other;
-    return *this;
-  }
-
- protected:
-  Scalar m_value;
-  DerType m_derivatives;
-};
-
-namespace internal {
-
-template <typename DerivativeType>
-struct auto_diff_special_op<DerivativeType, true>
-//   : auto_diff_scalar_op<DerivativeType, typename NumTraits<Scalar>::Real,
-//                            is_same<Scalar,typename NumTraits<Scalar>::Real>::value>
-{
-  typedef remove_all_t<DerivativeType> DerType;
-  typedef typename traits<DerType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real Real;
-
-  const AutoDiffScalar<DerivativeType>& derived() const {
-    return *static_cast<const AutoDiffScalar<DerivativeType>*>(this);
-  }
-  AutoDiffScalar<DerivativeType>& derived() { return *static_cast<AutoDiffScalar<DerivativeType>*>(this); }
-
-  inline AutoDiffScalar<DerType&> operator+(const Real& other) const {
-    return AutoDiffScalar<DerType&>(derived().value() + other, derived().derivatives());
-  }
-
-  friend inline AutoDiffScalar<DerType&> operator+(const Real& a, const AutoDiffScalar<DerivativeType>& b) {
-    return AutoDiffScalar<DerType&>(a + b.value(), b.derivatives());
-  }
-
-  inline AutoDiffScalar<DerivativeType>& operator+=(const Real& other) {
-    derived().value() += other;
-    return derived();
-  }
-
-  inline AutoDiffScalar<typename CwiseUnaryOp<bind2nd_op<scalar_product_op<Scalar, Real>>, DerType>::Type> operator*(
-      const Real& other) const {
-    return AutoDiffScalar<typename CwiseUnaryOp<bind2nd_op<scalar_product_op<Scalar, Real>>, DerType>::Type>(
-        derived().value() * other, derived().derivatives() * other);
-  }
-
-  friend inline AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real, Scalar>>, DerType>::Type>
-  operator*(const Real& other, const AutoDiffScalar<DerivativeType>& a) {
-    return AutoDiffScalar<typename CwiseUnaryOp<bind1st_op<scalar_product_op<Real, Scalar>>, DerType>::Type>(
-        a.value() * other, a.derivatives() * other);
-  }
-
-  inline AutoDiffScalar<DerivativeType>& operator*=(const Scalar& other) {
-    *this = *this * other;
-    return derived();
-  }
-};
-
-template <typename DerivativeType>
-struct auto_diff_special_op<DerivativeType, false> {
-  void operator*() const;
-  void operator-() const;
-  void operator+() const;
-};
-
-}  // end namespace internal
-
-template <typename DerType, typename BinOp>
-struct ScalarBinaryOpTraits<AutoDiffScalar<DerType>, typename DerType::Scalar, BinOp> {
-  typedef AutoDiffScalar<DerType> ReturnType;
-};
-
-template <typename DerType, typename BinOp>
-struct ScalarBinaryOpTraits<typename DerType::Scalar, AutoDiffScalar<DerType>, BinOp> {
-  typedef AutoDiffScalar<DerType> ReturnType;
-};
-
-#define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC, CODE)                                              \
-  template <typename DerType>                                                                        \
-  inline auto FUNC(const Eigen::AutoDiffScalar<DerType>& x) {                                        \
-    using namespace Eigen;                                                                           \
-    typedef typename Eigen::internal::traits<Eigen::internal::remove_all_t<DerType>>::Scalar Scalar; \
-    EIGEN_UNUSED_VARIABLE(sizeof(Scalar));                                                           \
-    CODE;                                                                                            \
-  }
-
-template <typename DerType>
-struct CleanedUpDerType {
-  typedef AutoDiffScalar<typename Eigen::internal::remove_all_t<DerType>::PlainObject> type;
-};
-
-template <typename DerType>
-inline const AutoDiffScalar<DerType>& conj(const AutoDiffScalar<DerType>& x) {
-  return x;
-}
-template <typename DerType>
-inline const AutoDiffScalar<DerType>& real(const AutoDiffScalar<DerType>& x) {
-  return x;
-}
-template <typename DerType>
-inline typename DerType::Scalar imag(const AutoDiffScalar<DerType>&) {
-  return 0.;
-}
-template <typename DerType, typename T>
-inline typename CleanedUpDerType<DerType>::type(min)(const AutoDiffScalar<DerType>& x, const T& y) {
-  typedef typename CleanedUpDerType<DerType>::type ADS;
-  return (x <= y ? ADS(x) : ADS(y));
-}
-template <typename DerType, typename T>
-inline typename CleanedUpDerType<DerType>::type(max)(const AutoDiffScalar<DerType>& x, const T& y) {
-  typedef typename CleanedUpDerType<DerType>::type ADS;
-  return (x >= y ? ADS(x) : ADS(y));
-}
-template <typename DerType, typename T>
-inline typename CleanedUpDerType<DerType>::type(min)(const T& x, const AutoDiffScalar<DerType>& y) {
-  typedef typename CleanedUpDerType<DerType>::type ADS;
-  return (x < y ? ADS(x) : ADS(y));
-}
-template <typename DerType, typename T>
-inline typename CleanedUpDerType<DerType>::type(max)(const T& x, const AutoDiffScalar<DerType>& y) {
-  typedef typename CleanedUpDerType<DerType>::type ADS;
-  return (x > y ? ADS(x) : ADS(y));
-}
-template <typename DerType>
-inline
-    typename CleanedUpDerType<DerType>::type(min)(const AutoDiffScalar<DerType>& x, const AutoDiffScalar<DerType>& y) {
-  return (x.value() < y.value() ? x : y);
-}
-template <typename DerType>
-inline
-    typename CleanedUpDerType<DerType>::type(max)(const AutoDiffScalar<DerType>& x, const AutoDiffScalar<DerType>& y) {
-  return (x.value() >= y.value() ? x : y);
-}
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs, using std::abs;
-                                    return Eigen::MakeAutoDiffScalar(abs(x.value()),
-                                                                     x.derivatives() * (x.value() < 0 ? -1 : 1));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2, using numext::abs2;
-                                    return Eigen::MakeAutoDiffScalar(abs2(x.value()),
-                                                                     x.derivatives() * (Scalar(2) * x.value()));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sqrt, using std::sqrt; Scalar sqrtx = sqrt(x.value());
-                                    return Eigen::MakeAutoDiffScalar(sqrtx, x.derivatives() * (Scalar(0.5) / sqrtx));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos, using std::cos; using std::sin;
-                                    return Eigen::MakeAutoDiffScalar(cos(x.value()),
-                                                                     x.derivatives() * (-sin(x.value())));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sin, using std::sin; using std::cos;
-                                    return Eigen::MakeAutoDiffScalar(sin(x.value()), x.derivatives() * cos(x.value()));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp, using std::exp; Scalar expx = exp(x.value());
-                                    return Eigen::MakeAutoDiffScalar(expx, x.derivatives() * expx);)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(log, using std::log;
-                                    return Eigen::MakeAutoDiffScalar(log(x.value()),
-                                                                     x.derivatives() * (Scalar(1) / x.value()));)
-
-template <typename DerType>
-inline auto pow(const Eigen::AutoDiffScalar<DerType>& x,
-                const typename internal::traits<internal::remove_all_t<DerType>>::Scalar& y) {
-  using namespace Eigen;
-  using std::pow;
-  return Eigen::MakeAutoDiffScalar(pow(x.value(), y), x.derivatives() * (y * pow(x.value(), y - 1)));
-}
-
-template <typename DerTypeA, typename DerTypeB>
-inline AutoDiffScalar<Matrix<typename internal::traits<internal::remove_all_t<DerTypeA>>::Scalar, Dynamic, 1>> atan2(
-    const AutoDiffScalar<DerTypeA>& a, const AutoDiffScalar<DerTypeB>& b) {
-  using std::atan2;
-  typedef typename internal::traits<internal::remove_all_t<DerTypeA>>::Scalar Scalar;
-  typedef AutoDiffScalar<Matrix<Scalar, Dynamic, 1>> PlainADS;
-  PlainADS ret;
-  ret.value() = atan2(a.value(), b.value());
-
-  Scalar squared_hypot = a.value() * a.value() + b.value() * b.value();
-
-  // if (squared_hypot==0) the derivation is undefined and the following results in a NaN:
-  ret.derivatives() = (a.derivatives() * b.value() - a.value() * b.derivatives()) / squared_hypot;
-
-  return ret;
-}
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(tan, using std::tan; using std::cos; return Eigen::MakeAutoDiffScalar(
-                                        tan(x.value()), x.derivatives() * (Scalar(1) / numext::abs2(cos(x.value()))));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(asin, using std::sqrt; using std::asin; return Eigen::MakeAutoDiffScalar(
-                                        asin(x.value()),
-                                        x.derivatives() * (Scalar(1) / sqrt(1 - numext::abs2(x.value()))));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(acos, using std::sqrt; using std::acos; return Eigen::MakeAutoDiffScalar(
-                                        acos(x.value()),
-                                        x.derivatives() * (Scalar(-1) / sqrt(1 - numext::abs2(x.value()))));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(
-    tanh, using std::cosh; using std::tanh;
-    return Eigen::MakeAutoDiffScalar(tanh(x.value()), x.derivatives() * (Scalar(1) / numext::abs2(cosh(x.value()))));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sinh, using std::sinh; using std::cosh;
-                                    return Eigen::MakeAutoDiffScalar(sinh(x.value()),
-                                                                     x.derivatives() * cosh(x.value()));)
-
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cosh, using std::sinh; using std::cosh;
-                                    return Eigen::MakeAutoDiffScalar(cosh(x.value()),
-                                                                     x.derivatives() * sinh(x.value()));)
-
-#undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY
-
-template <typename DerType>
-struct NumTraits<AutoDiffScalar<DerType>>
-    : NumTraits<typename NumTraits<typename internal::remove_all_t<DerType>::Scalar>::Real> {
-  typedef internal::remove_all_t<DerType> DerTypeCleaned;
-  typedef AutoDiffScalar<Matrix<typename NumTraits<typename DerTypeCleaned::Scalar>::Real,
-                                DerTypeCleaned::RowsAtCompileTime, DerTypeCleaned::ColsAtCompileTime, 0,
-                                DerTypeCleaned::MaxRowsAtCompileTime, DerTypeCleaned::MaxColsAtCompileTime>>
-      Real;
-  typedef AutoDiffScalar<DerType> NonInteger;
-  typedef AutoDiffScalar<DerType> Nested;
-  typedef typename NumTraits<typename DerTypeCleaned::Scalar>::Literal Literal;
-  enum { RequireInitialization = 1 };
-};
-
-namespace internal {
-template <typename DerivativeType>
-struct is_identically_zero_impl<AutoDiffScalar<DerivativeType>> {
-  static inline bool run(const AutoDiffScalar<DerivativeType>& s) {
-    const DerivativeType& derivatives = s.derivatives();
-    for (int i = 0; i < derivatives.size(); ++i) {
-      if (!numext::is_exactly_zero(derivatives[i])) {
-        return false;
-      }
-    }
-    return numext::is_exactly_zero(s.value());
-  }
-};
-}  // namespace internal
-}  // namespace Eigen
-
-namespace std {
-
-template <typename T>
-class numeric_limits<Eigen::AutoDiffScalar<T>> : public numeric_limits<typename T::Scalar> {};
-
-template <typename T>
-class numeric_limits<Eigen::AutoDiffScalar<T&>> : public numeric_limits<typename T::Scalar> {};
-
-}  // namespace std
-
-#endif  // EIGEN_AUTODIFF_SCALAR_H
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h b/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
deleted file mode 100644
index 892980e..0000000
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
+++ /dev/null
@@ -1,169 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_AUTODIFF_VECTOR_H
-#define EIGEN_AUTODIFF_VECTOR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/* \class AutoDiffScalar
- * \brief A scalar type replacement with automatic differentation capability
- *
- * \param DerType the vector type used to store/represent the derivatives (e.g. Vector3f)
- *
- * This class represents a scalar value while tracking its respective derivatives.
- *
- * It supports the following list of global math function:
- *  - std::abs, std::sqrt, std::pow, std::exp, std::log, std::sin, std::cos,
- *  - internal::abs, internal::sqrt, numext::pow, internal::exp, internal::log, internal::sin, internal::cos,
- *  - internal::conj, internal::real, internal::imag, numext::abs2.
- *
- * AutoDiffScalar can be used as the scalar type of an Eigen::Matrix object. However,
- * in that case, the expression template mechanism only occurs at the top Matrix level,
- * while derivatives are computed right away.
- *
- */
-template <typename ValueType, typename JacobianType>
-class AutoDiffVector {
- public:
-  typedef typename internal::traits<ValueType>::Scalar BaseScalar;
-  typedef AutoDiffScalar<Matrix<BaseScalar, JacobianType::RowsAtCompileTime, 1> > ActiveScalar;
-  typedef ActiveScalar Scalar;
-  typedef AutoDiffScalar<typename JacobianType::ColXpr> CoeffType;
-  typedef typename JacobianType::Index Index;
-
-  inline AutoDiffVector() {}
-
-  inline AutoDiffVector(const ValueType& values) : m_values(values) { m_jacobian.setZero(); }
-
-  CoeffType operator[](Index i) { return CoeffType(m_values[i], m_jacobian.col(i)); }
-  const CoeffType operator[](Index i) const { return CoeffType(m_values[i], m_jacobian.col(i)); }
-
-  CoeffType operator()(Index i) { return CoeffType(m_values[i], m_jacobian.col(i)); }
-  const CoeffType operator()(Index i) const { return CoeffType(m_values[i], m_jacobian.col(i)); }
-
-  CoeffType coeffRef(Index i) { return CoeffType(m_values[i], m_jacobian.col(i)); }
-  const CoeffType coeffRef(Index i) const { return CoeffType(m_values[i], m_jacobian.col(i)); }
-
-  Index size() const { return m_values.size(); }
-
-  // FIXME: Here we could return an expression of the sum.
-  Scalar sum() const { return Scalar(m_values.sum(), m_jacobian.rowwise().sum()); }
-
-  inline AutoDiffVector(const ValueType& values, const JacobianType& jac) : m_values(values), m_jacobian(jac) {}
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline AutoDiffVector(const AutoDiffVector<OtherValueType, OtherJacobianType>& other)
-      : m_values(other.values()), m_jacobian(other.jacobian()) {}
-
-  inline AutoDiffVector(const AutoDiffVector& other) : m_values(other.values()), m_jacobian(other.jacobian()) {}
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline AutoDiffVector& operator=(const AutoDiffVector<OtherValueType, OtherJacobianType>& other) {
-    m_values = other.values();
-    m_jacobian = other.jacobian();
-    return *this;
-  }
-
-  inline AutoDiffVector& operator=(const AutoDiffVector& other) {
-    m_values = other.values();
-    m_jacobian = other.jacobian();
-    return *this;
-  }
-
-  inline const ValueType& values() const { return m_values; }
-  inline ValueType& values() { return m_values; }
-
-  inline const JacobianType& jacobian() const { return m_jacobian; }
-  inline JacobianType& jacobian() { return m_jacobian; }
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline const AutoDiffVector<
-      typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>, ValueType, OtherValueType>::Type,
-      typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>, JacobianType, OtherJacobianType>::Type>
-  operator+(const AutoDiffVector<OtherValueType, OtherJacobianType>& other) const {
-    return AutoDiffVector<
-        typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>, ValueType, OtherValueType>::Type,
-        typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>, JacobianType, OtherJacobianType>::Type>(
-        m_values + other.values(), m_jacobian + other.jacobian());
-  }
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline AutoDiffVector& operator+=(const AutoDiffVector<OtherValueType, OtherJacobianType>& other) {
-    m_values += other.values();
-    m_jacobian += other.jacobian();
-    return *this;
-  }
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline const AutoDiffVector<
-      typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>, ValueType, OtherValueType>::Type,
-      typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>, JacobianType, OtherJacobianType>::Type>
-  operator-(const AutoDiffVector<OtherValueType, OtherJacobianType>& other) const {
-    return AutoDiffVector<
-        typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>, ValueType, OtherValueType>::Type,
-        typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>, JacobianType, OtherJacobianType>::Type>(
-        m_values - other.values(), m_jacobian - other.jacobian());
-  }
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline AutoDiffVector& operator-=(const AutoDiffVector<OtherValueType, OtherJacobianType>& other) {
-    m_values -= other.values();
-    m_jacobian -= other.jacobian();
-    return *this;
-  }
-
-  inline const AutoDiffVector<typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, ValueType>::Type,
-                              typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, JacobianType>::Type>
-  operator-() const {
-    return AutoDiffVector<typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, ValueType>::Type,
-                          typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, JacobianType>::Type>(
-        -m_values, -m_jacobian);
-  }
-
-  inline const AutoDiffVector<typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type,
-                              typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type>
-  operator*(const BaseScalar& other) const {
-    return AutoDiffVector<typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type,
-                          typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type>(
-        m_values * other, m_jacobian * other);
-  }
-
-  friend inline const AutoDiffVector<
-      typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type,
-      typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type>
-  operator*(const Scalar& other, const AutoDiffVector& v) {
-    return AutoDiffVector<typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type,
-                          typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type>(
-        v.values() * other, v.jacobian() * other);
-  }
-
-  inline AutoDiffVector& operator*=(const Scalar& other) {
-    m_values *= other;
-    m_jacobian *= other;
-    return *this;
-  }
-
-  template <typename OtherValueType, typename OtherJacobianType>
-  inline AutoDiffVector& operator*=(const AutoDiffVector<OtherValueType, OtherJacobianType>& other) {
-    *this = *this * other;
-    return *this;
-  }
-
- protected:
-  ValueType m_values;
-  JacobianType m_jacobian;
-};
-
-}  // namespace Eigen
-
-#endif  // EIGEN_AUTODIFF_VECTOR_H
diff --git a/unsupported/Eigen/src/AutoDiff/CoherentPadOp.h b/unsupported/Eigen/src/AutoDiff/CoherentPadOp.h
deleted file mode 100644
index 0659e9a..0000000
--- a/unsupported/Eigen/src/AutoDiff/CoherentPadOp.h
+++ /dev/null
@@ -1,152 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020 The Eigen Team.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_COHERENT_PAD_OP_H
-#define EIGEN_COHERENT_PAD_OP_H
-
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// Pads a vector with zeros to a given size.
-template <typename XprType, int SizeAtCompileTime_>
-struct CoherentPadOp;
-
-template <typename XprType, int SizeAtCompileTime_>
-struct traits<CoherentPadOp<XprType, SizeAtCompileTime_>> : public traits<XprType> {
-  typedef typename internal::remove_all<XprType>::type PlainXprType;
-  typedef typename internal::ref_selector<XprType>::type XprNested;
-  typedef typename std::remove_reference_t<XprNested> XprNested_;
-  enum : int {
-    IsRowMajor = traits<PlainXprType>::Flags & RowMajorBit,
-    SizeAtCompileTime = SizeAtCompileTime_,
-    RowsAtCompileTime = IsRowMajor ? 1 : SizeAtCompileTime,
-    ColsAtCompileTime = IsRowMajor ? SizeAtCompileTime : 1,
-    MaxRowsAtCompileTime = RowsAtCompileTime,
-    MaxColsAtCompileTime = ColsAtCompileTime,
-    Flags = traits<XprType>::Flags & ~NestByRefBit,
-  };
-};
-
-// Pads a vector with zeros to a given size.
-template <typename XprType, int SizeAtCompileTime_>
-struct CoherentPadOp : public dense_xpr_base<CoherentPadOp<XprType, SizeAtCompileTime_>>::type {
-  typedef typename internal::generic_xpr_base<CoherentPadOp<XprType, SizeAtCompileTime_>>::type Base;
-  EIGEN_GENERIC_PUBLIC_INTERFACE(CoherentPadOp)
-
-  using XprNested = typename traits<CoherentPadOp>::XprNested;
-  using XprNested_ = typename traits<CoherentPadOp>::XprNested_;
-  using NestedExpression = XprNested_;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp() = delete;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp(const CoherentPadOp&) = default;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp(CoherentPadOp&& other) = default;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoherentPadOp(const XprType& xpr, Index size) : m_xpr(xpr), m_size(size) {
-    static_assert(XprNested_::IsVectorAtCompileTime, "input type must be a vector");
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const XprNested_& nestedExpression() const { return m_xpr; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_size.value(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const {
-    return traits<CoherentPadOp>::IsRowMajor ? Index(1) : size();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const {
-    return traits<CoherentPadOp>::IsRowMajor ? size() : Index(1);
-  }
-
- private:
-  XprNested m_xpr;
-  const internal::variable_if_dynamic<Index, SizeAtCompileTime> m_size;
-};
-
-// Adapted from the Replicate evaluator.
-template <typename ArgType, int SizeAtCompileTime>
-struct unary_evaluator<CoherentPadOp<ArgType, SizeAtCompileTime>>
-    : evaluator_base<CoherentPadOp<ArgType, SizeAtCompileTime>> {
-  typedef CoherentPadOp<ArgType, SizeAtCompileTime> XprType;
-  typedef typename internal::remove_all_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename internal::nested_eval<ArgType, 1>::type ArgTypeNested;
-  typedef internal::remove_all_t<ArgTypeNested> ArgTypeNestedCleaned;
-
-  enum {
-    CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
-    LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
-    Flags = evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits | LinearAccessMask | RowMajorBit),
-    Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& pad)
-      : m_arg(pad.nestedExpression()), m_argImpl(m_arg), m_size(pad.nestedExpression().size()) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const {
-    EIGEN_IF_CONSTEXPR(XprType::IsRowMajor) {
-      if (col < m_size.value()) {
-        return m_argImpl.coeff(1, col);
-      }
-    }
-    else {
-      if (row < m_size.value()) {
-        return m_argImpl.coeff(row, 1);
-      }
-    }
-    return CoeffReturnType(0);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    if (index < m_size.value()) {
-      return m_argImpl.coeff(index);
-    }
-    return CoeffReturnType(0);
-  }
-
-  template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const {
-    // AutoDiff scalar's derivative must be a vector, which is enforced by static assert.
-    // Defer to linear access for simplicity.
-    EIGEN_IF_CONSTEXPR(XprType::IsRowMajor) { return packet(col); }
-    return packet(row);
-  }
-
-  template <int LoadMode, typename PacketType>
-  EIGEN_STRONG_INLINE PacketType packet(Index index) const {
-    constexpr int kPacketSize = unpacket_traits<PacketType>::size;
-    if (index + kPacketSize <= m_size.value()) {
-      return m_argImpl.template packet<LoadMode, PacketType>(index);
-    } else if (index < m_size.value()) {
-      // Partial packet.
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[kPacketSize];
-      const int partial = m_size.value() - index;
-      for (int i = 0; i < partial && i < kPacketSize; ++i) {
-        values[i] = m_argImpl.coeff(index + i);
-      }
-      for (int i = partial; i < kPacketSize; ++i) {
-        values[i] = CoeffReturnType(0);
-      }
-      return pload<PacketType>(values);
-    }
-    return pset1<PacketType>(CoeffReturnType(0));
-  }
-
- protected:
-  const ArgTypeNested m_arg;
-  evaluator<ArgTypeNestedCleaned> m_argImpl;
-  const variable_if_dynamic<Index, ArgTypeNestedCleaned::SizeAtCompileTime> m_size;
-};
-
-}  // namespace internal
-
-}  // namespace Eigen
-
-#endif  // EIGEN_CWISE_BINARY_OP_H
diff --git a/unsupported/Eigen/src/AutoDiff/InternalHeaderCheck.h b/unsupported/Eigen/src/AutoDiff/InternalHeaderCheck.h
deleted file mode 100644
index 1584337..0000000
--- a/unsupported/Eigen/src/AutoDiff/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_AUTODIFF_MODULE_H
-#error "Please include unsupported/Eigen/AutoDiff instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/BVH/BVAlgorithms.h b/unsupported/Eigen/src/BVH/BVAlgorithms.h
deleted file mode 100644
index d9e41da..0000000
--- a/unsupported/Eigen/src/BVH/BVAlgorithms.h
+++ /dev/null
@@ -1,291 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BVALGORITHMS_H
-#define EIGEN_BVALGORITHMS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-template <typename BVH, typename Intersector>
-bool intersect_helper(const BVH &tree, Intersector &intersector, typename BVH::Index root) {
-  typedef typename BVH::Index Index;
-  typedef typename BVH::VolumeIterator VolIter;
-  typedef typename BVH::ObjectIterator ObjIter;
-
-  VolIter vBegin = VolIter(), vEnd = VolIter();
-  ObjIter oBegin = ObjIter(), oEnd = ObjIter();
-
-  std::vector<Index> todo(1, root);
-
-  while (!todo.empty()) {
-    tree.getChildren(todo.back(), vBegin, vEnd, oBegin, oEnd);
-    todo.pop_back();
-
-    for (; vBegin != vEnd; ++vBegin)  // go through child volumes
-      if (intersector.intersectVolume(tree.getVolume(*vBegin))) todo.push_back(*vBegin);
-
-    for (; oBegin != oEnd; ++oBegin)                          // go through child objects
-      if (intersector.intersectObject(*oBegin)) return true;  // intersector said to stop query
-  }
-  return false;
-}
-#endif  // not EIGEN_PARSED_BY_DOXYGEN
-
-template <typename Volume1, typename Object1, typename Object2, typename Intersector>
-struct intersector_helper1 {
-  intersector_helper1(const Object2 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
-  bool intersectVolume(const Volume1 &vol) { return intersector.intersectVolumeObject(vol, stored); }
-  bool intersectObject(const Object1 &obj) { return intersector.intersectObjectObject(obj, stored); }
-  Object2 stored;
-  Intersector &intersector;
-
- private:
-  intersector_helper1 &operator=(const intersector_helper1 &);
-};
-
-template <typename Volume2, typename Object2, typename Object1, typename Intersector>
-struct intersector_helper2 {
-  intersector_helper2(const Object1 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
-  bool intersectVolume(const Volume2 &vol) { return intersector.intersectObjectVolume(stored, vol); }
-  bool intersectObject(const Object2 &obj) { return intersector.intersectObjectObject(stored, obj); }
-  Object1 stored;
-  Intersector &intersector;
-
- private:
-  intersector_helper2 &operator=(const intersector_helper2 &);
-};
-
-}  // end namespace internal
-
-/**  Given a BVH, runs the query encapsulated by \a intersector.
-  *  The Intersector type must provide the following members: \code
-     bool intersectVolume(const BVH::Volume &volume) //returns true if volume intersects the query
-     bool intersectObject(const BVH::Object &object) //returns true if the search should terminate immediately
-  \endcode
-  */
-template <typename BVH, typename Intersector>
-void BVIntersect(const BVH &tree, Intersector &intersector) {
-  internal::intersect_helper(tree, intersector, tree.getRootIndex());
-}
-
-/**  Given two BVH's, runs the query on their Cartesian product encapsulated by \a intersector.
-  *  The Intersector type must provide the following members: \code
-     bool intersectVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2) //returns true if product of volumes
-  intersects the query bool intersectVolumeObject(const BVH1::Volume &v1, const BVH2::Object &o2) //returns true if the
-  volume-object product intersects the query bool intersectObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)
-  //returns true if the volume-object product intersects the query bool intersectObjectObject(const BVH1::Object &o1,
-  const BVH2::Object &o2) //returns true if the search should terminate immediately \endcode
-  */
-template <typename BVH1, typename BVH2, typename Intersector>
-void BVIntersect(const BVH1 &tree1, const BVH2 &tree2,
-                 Intersector &intersector)  // TODO: tandem descent when it makes sense
-{
-  typedef typename BVH1::Index Index1;
-  typedef typename BVH2::Index Index2;
-  typedef internal::intersector_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object,
-                                        Intersector>
-      Helper1;
-  typedef internal::intersector_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object,
-                                        Intersector>
-      Helper2;
-  typedef typename BVH1::VolumeIterator VolIter1;
-  typedef typename BVH1::ObjectIterator ObjIter1;
-  typedef typename BVH2::VolumeIterator VolIter2;
-  typedef typename BVH2::ObjectIterator ObjIter2;
-
-  VolIter1 vBegin1 = VolIter1(), vEnd1 = VolIter1();
-  ObjIter1 oBegin1 = ObjIter1(), oEnd1 = ObjIter1();
-  VolIter2 vBegin2 = VolIter2(), vEnd2 = VolIter2(), vCur2 = VolIter2();
-  ObjIter2 oBegin2 = ObjIter2(), oEnd2 = ObjIter2(), oCur2 = ObjIter2();
-
-  std::vector<std::pair<Index1, Index2> > todo(1, std::make_pair(tree1.getRootIndex(), tree2.getRootIndex()));
-
-  while (!todo.empty()) {
-    tree1.getChildren(todo.back().first, vBegin1, vEnd1, oBegin1, oEnd1);
-    tree2.getChildren(todo.back().second, vBegin2, vEnd2, oBegin2, oEnd2);
-    todo.pop_back();
-
-    for (; vBegin1 != vEnd1; ++vBegin1) {  // go through child volumes of first tree
-      const typename BVH1::Volume &vol1 = tree1.getVolume(*vBegin1);
-      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
-        if (intersector.intersectVolumeVolume(vol1, tree2.getVolume(*vCur2)))
-          todo.push_back(std::make_pair(*vBegin1, *vCur2));
-      }
-
-      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {  // go through child objects of second tree
-        Helper1 helper(*oCur2, intersector);
-        if (internal::intersect_helper(tree1, helper, *vBegin1)) return;  // intersector said to stop query
-      }
-    }
-
-    for (; oBegin1 != oEnd1; ++oBegin1) {               // go through child objects of first tree
-      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
-        Helper2 helper(*oBegin1, intersector);
-        if (internal::intersect_helper(tree2, helper, *vCur2)) return;  // intersector said to stop query
-      }
-
-      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {                    // go through child objects of second tree
-        if (intersector.intersectObjectObject(*oBegin1, *oCur2)) return;  // intersector said to stop query
-      }
-    }
-  }
-}
-
-namespace internal {
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-template <typename BVH, typename Minimizer>
-typename Minimizer::Scalar minimize_helper(const BVH &tree, Minimizer &minimizer, typename BVH::Index root,
-                                           typename Minimizer::Scalar minimum) {
-  typedef typename Minimizer::Scalar Scalar;
-  typedef typename BVH::Index Index;
-  typedef std::pair<Scalar, Index> QueueElement;  // first element is priority
-  typedef typename BVH::VolumeIterator VolIter;
-  typedef typename BVH::ObjectIterator ObjIter;
-
-  VolIter vBegin = VolIter(), vEnd = VolIter();
-  ObjIter oBegin = ObjIter(), oEnd = ObjIter();
-  std::priority_queue<QueueElement, std::vector<QueueElement>, std::greater<QueueElement> >
-      todo;  // smallest is at the top
-
-  todo.push(std::make_pair(Scalar(), root));
-
-  while (!todo.empty()) {
-    tree.getChildren(todo.top().second, vBegin, vEnd, oBegin, oEnd);
-    todo.pop();
-
-    for (; oBegin != oEnd; ++oBegin)  // go through child objects
-      minimum = (std::min)(minimum, minimizer.minimumOnObject(*oBegin));
-
-    for (; vBegin != vEnd; ++vBegin) {  // go through child volumes
-      Scalar val = minimizer.minimumOnVolume(tree.getVolume(*vBegin));
-      if (val < minimum) todo.push(std::make_pair(val, *vBegin));
-    }
-  }
-
-  return minimum;
-}
-#endif  // not EIGEN_PARSED_BY_DOXYGEN
-
-template <typename Volume1, typename Object1, typename Object2, typename Minimizer>
-struct minimizer_helper1 {
-  typedef typename Minimizer::Scalar Scalar;
-  minimizer_helper1(const Object2 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
-  Scalar minimumOnVolume(const Volume1 &vol) { return minimizer.minimumOnVolumeObject(vol, stored); }
-  Scalar minimumOnObject(const Object1 &obj) { return minimizer.minimumOnObjectObject(obj, stored); }
-  Object2 stored;
-  Minimizer &minimizer;
-
- private:
-  minimizer_helper1 &operator=(const minimizer_helper1 &);
-};
-
-template <typename Volume2, typename Object2, typename Object1, typename Minimizer>
-struct minimizer_helper2 {
-  typedef typename Minimizer::Scalar Scalar;
-  minimizer_helper2(const Object1 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
-  Scalar minimumOnVolume(const Volume2 &vol) { return minimizer.minimumOnObjectVolume(stored, vol); }
-  Scalar minimumOnObject(const Object2 &obj) { return minimizer.minimumOnObjectObject(stored, obj); }
-  Object1 stored;
-  Minimizer &minimizer;
-
- private:
-  minimizer_helper2 &operator=(const minimizer_helper2 &);
-};
-
-}  // end namespace internal
-
-/**  Given a BVH, runs the query encapsulated by \a minimizer.
-  *  \returns the minimum value.
-  *  The Minimizer type must provide the following members: \code
-     typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has
-  one) Scalar minimumOnVolume(const BVH::Volume &volume) Scalar minimumOnObject(const BVH::Object &object) \endcode
-  */
-template <typename BVH, typename Minimizer>
-typename Minimizer::Scalar BVMinimize(const BVH &tree, Minimizer &minimizer) {
-  return internal::minimize_helper(tree, minimizer, tree.getRootIndex(),
-                                   (std::numeric_limits<typename Minimizer::Scalar>::max)());
-}
-
-/**  Given two BVH's, runs the query on their cartesian product encapsulated by \a minimizer.
-  *  \returns the minimum value.
-  *  The Minimizer type must provide the following members: \code
-     typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has
-  one) Scalar minimumOnVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2) Scalar minimumOnVolumeObject(const
-  BVH1::Volume &v1, const BVH2::Object &o2) Scalar minimumOnObjectVolume(const BVH1::Object &o1, const BVH2::Volume &v2)
-     Scalar minimumOnObjectObject(const BVH1::Object &o1, const BVH2::Object &o2)
-  \endcode
-  */
-template <typename BVH1, typename BVH2, typename Minimizer>
-typename Minimizer::Scalar BVMinimize(const BVH1 &tree1, const BVH2 &tree2, Minimizer &minimizer) {
-  typedef typename Minimizer::Scalar Scalar;
-  typedef typename BVH1::Index Index1;
-  typedef typename BVH2::Index Index2;
-  typedef internal::minimizer_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Minimizer>
-      Helper1;
-  typedef internal::minimizer_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Minimizer>
-      Helper2;
-  typedef std::pair<Scalar, std::pair<Index1, Index2> > QueueElement;  // first element is priority
-  typedef typename BVH1::VolumeIterator VolIter1;
-  typedef typename BVH1::ObjectIterator ObjIter1;
-  typedef typename BVH2::VolumeIterator VolIter2;
-  typedef typename BVH2::ObjectIterator ObjIter2;
-
-  VolIter1 vBegin1 = VolIter1(), vEnd1 = VolIter1();
-  ObjIter1 oBegin1 = ObjIter1(), oEnd1 = ObjIter1();
-  VolIter2 vBegin2 = VolIter2(), vEnd2 = VolIter2(), vCur2 = VolIter2();
-  ObjIter2 oBegin2 = ObjIter2(), oEnd2 = ObjIter2(), oCur2 = ObjIter2();
-  std::priority_queue<QueueElement, std::vector<QueueElement>, std::greater<QueueElement> >
-      todo;  // smallest is at the top
-
-  Scalar minimum = (std::numeric_limits<Scalar>::max)();
-  todo.push(std::make_pair(Scalar(), std::make_pair(tree1.getRootIndex(), tree2.getRootIndex())));
-
-  while (!todo.empty()) {
-    tree1.getChildren(todo.top().second.first, vBegin1, vEnd1, oBegin1, oEnd1);
-    tree2.getChildren(todo.top().second.second, vBegin2, vEnd2, oBegin2, oEnd2);
-    todo.pop();
-
-    for (; oBegin1 != oEnd1; ++oBegin1) {               // go through child objects of first tree
-      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {  // go through child objects of second tree
-        minimum = (std::min)(minimum, minimizer.minimumOnObjectObject(*oBegin1, *oCur2));
-      }
-
-      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
-        Helper2 helper(*oBegin1, minimizer);
-        minimum = (std::min)(minimum, internal::minimize_helper(tree2, helper, *vCur2, minimum));
-      }
-    }
-
-    for (; vBegin1 != vEnd1; ++vBegin1) {  // go through child volumes of first tree
-      const typename BVH1::Volume &vol1 = tree1.getVolume(*vBegin1);
-
-      for (oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {  // go through child objects of second tree
-        Helper1 helper(*oCur2, minimizer);
-        minimum = (std::min)(minimum, internal::minimize_helper(tree1, helper, *vBegin1, minimum));
-      }
-
-      for (vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) {  // go through child volumes of second tree
-        Scalar val = minimizer.minimumOnVolumeVolume(vol1, tree2.getVolume(*vCur2));
-        if (val < minimum) todo.push(std::make_pair(val, std::make_pair(*vBegin1, *vCur2)));
-      }
-    }
-  }
-  return minimum;
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_BVALGORITHMS_H
diff --git a/unsupported/Eigen/src/BVH/InternalHeaderCheck.h b/unsupported/Eigen/src/BVH/InternalHeaderCheck.h
deleted file mode 100644
index 7aade9b..0000000
--- a/unsupported/Eigen/src/BVH/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_BVH_MODULE_H
-#error "Please include unsupported/Eigen/BVH instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/BVH/KdBVH.h b/unsupported/Eigen/src/BVH/KdBVH.h
deleted file mode 100644
index 631aef7..0000000
--- a/unsupported/Eigen/src/BVH/KdBVH.h
+++ /dev/null
@@ -1,223 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef KDBVH_H_INCLUDED
-#define KDBVH_H_INCLUDED
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// internal pair class for the BVH--used instead of std::pair because of alignment
-template <typename Scalar, int Dim>
-struct vector_int_pair {
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Dim)
-  typedef Matrix<Scalar, Dim, 1> VectorType;
-
-  vector_int_pair(const VectorType &v, int i) : first(v), second(i) {}
-
-  VectorType first;
-  int second;
-};
-
-// these templates help the tree initializer get the bounding boxes either from a provided
-// iterator range or using bounding_box in a unified way
-template <typename ObjectList, typename VolumeList, typename BoxIter>
-struct get_boxes_helper {
-  void operator()(const ObjectList &objects, BoxIter boxBegin, BoxIter boxEnd, VolumeList &outBoxes) const {
-    outBoxes.insert(outBoxes.end(), boxBegin, boxEnd);
-    eigen_assert(outBoxes.size() == objects.size());
-    EIGEN_ONLY_USED_FOR_DEBUG(objects);
-  }
-};
-
-template <typename ObjectList, typename VolumeList>
-struct get_boxes_helper<ObjectList, VolumeList, int> {
-  void operator()(const ObjectList &objects, int, int, VolumeList &outBoxes) const {
-    outBoxes.reserve(objects.size());
-    for (int i = 0; i < (int)objects.size(); ++i) outBoxes.push_back(bounding_box(objects[i]));
-  }
-};
-
-}  // end namespace internal
-
-/** \class KdBVH
- *  \brief A simple bounding volume hierarchy based on AlignedBox
- *
- *  \param Scalar_ The underlying scalar type of the bounding boxes
- *  \param Dim_ The dimension of the space in which the hierarchy lives
- *  \param Object_ The object type that lives in the hierarchy.  It must have value semantics.  Either
- *                 `bounding_box(Object_)` must be defined and return an `AlignedBox<Scalar_, Dim_>` or bounding boxes
- *                  must be provided to the tree initializer.
- *
- * This class provides a simple (as opposed to optimized) implementation of a bounding volume hierarchy analogous to a
- * Kd-tree. Given a sequence of objects, it computes their bounding boxes, constructs a Kd-tree of their centers and
- * builds a BVH with the structure of that Kd-tree.  When the elements of the tree are too expensive to be copied
- * around, it is useful for `Object_` to be a pointer.
- */
-template <typename Scalar_, int Dim_, typename Object_>
-class KdBVH {
- public:
-  enum { Dim = Dim_ };
-  typedef Object_ Object;
-  typedef std::vector<Object, aligned_allocator<Object> > ObjectList;
-  typedef Scalar_ Scalar;
-  typedef AlignedBox<Scalar, Dim> Volume;
-  typedef std::vector<Volume, aligned_allocator<Volume> > VolumeList;
-  typedef int Index;
-  typedef const int *VolumeIterator;  // the iterators are just pointers into the tree's vectors
-  typedef const Object *ObjectIterator;
-
-  KdBVH() {}
-
-  /** Given an iterator range over \a Object references, constructs the BVH.  Requires that bounding_box(Object) return
-   * a Volume. */
-  template <typename Iter>
-  KdBVH(Iter begin, Iter end) {
-    init(begin, end, 0, 0);
-  }  // int is recognized by init as not being an iterator type
-
-  /** Given an iterator range over \a Object references and an iterator range over their bounding boxes, constructs the
-   * BVH */
-  template <typename OIter, typename BIter>
-  KdBVH(OIter begin, OIter end, BIter boxBegin, BIter boxEnd) {
-    init(begin, end, boxBegin, boxEnd);
-  }
-
-  /** Given an iterator range over \a Object references, constructs the BVH, overwriting whatever is in there currently.
-   * Requires that bounding_box(Object) return a Volume. */
-  template <typename Iter>
-  void init(Iter begin, Iter end) {
-    init(begin, end, 0, 0);
-  }
-
-  /** Given an iterator range over \a Object references and an iterator range over their bounding boxes,
-   * constructs the BVH, overwriting whatever is in there currently. */
-  template <typename OIter, typename BIter>
-  void init(OIter begin, OIter end, BIter boxBegin, BIter boxEnd) {
-    objects.clear();
-    boxes.clear();
-    children.clear();
-
-    objects.insert(objects.end(), begin, end);
-    int n = static_cast<int>(objects.size());
-
-    if (n < 2) return;  // if we have at most one object, we don't need any internal nodes
-
-    VolumeList objBoxes;
-    VIPairList objCenters;
-
-    // compute the bounding boxes depending on BIter type
-    internal::get_boxes_helper<ObjectList, VolumeList, BIter>()(objects, boxBegin, boxEnd, objBoxes);
-
-    objCenters.reserve(n);
-    boxes.reserve(n - 1);
-    children.reserve(2 * n - 2);
-
-    for (int i = 0; i < n; ++i) objCenters.push_back(VIPair(objBoxes[i].center(), i));
-
-    build(objCenters, 0, n, objBoxes, 0);  // the recursive part of the algorithm
-
-    ObjectList tmp(n);
-    tmp.swap(objects);
-    for (int i = 0; i < n; ++i) objects[i] = tmp[objCenters[i].second];
-  }
-
-  /** \returns the index of the root of the hierarchy */
-  inline Index getRootIndex() const { return (int)boxes.size() - 1; }
-
-  /** Given an \a index of a node, on exit, \a outVBegin and \a outVEnd range over the indices of the volume children of
-   * the node and \a outOBegin and \a outOEnd range over the object children of the node */
-  EIGEN_STRONG_INLINE void getChildren(Index index, VolumeIterator &outVBegin, VolumeIterator &outVEnd,
-                                       ObjectIterator &outOBegin, ObjectIterator &outOEnd)
-      const {  // inlining this function should open lots of optimization opportunities to the compiler
-    if (index < 0) {
-      outVBegin = outVEnd;
-      if (!objects.empty()) outOBegin = &(objects[0]);
-      outOEnd = outOBegin + objects.size();  // output all objects--necessary when the tree has only one object
-      return;
-    }
-
-    int numBoxes = static_cast<int>(boxes.size());
-
-    int idx = index * 2;
-    if (children[idx + 1] < numBoxes) {  // second index is always bigger
-      outVBegin = &(children[idx]);
-      outVEnd = outVBegin + 2;
-      outOBegin = outOEnd;
-    } else if (children[idx] >= numBoxes) {  // if both children are objects
-      outVBegin = outVEnd;
-      outOBegin = &(objects[children[idx] - numBoxes]);
-      outOEnd = outOBegin + 2;
-    } else {  // if the first child is a volume and the second is an object
-      outVBegin = &(children[idx]);
-      outVEnd = outVBegin + 1;
-      outOBegin = &(objects[children[idx + 1] - numBoxes]);
-      outOEnd = outOBegin + 1;
-    }
-  }
-
-  /** \returns the bounding box of the node at \a index */
-  inline const Volume &getVolume(Index index) const { return boxes[index]; }
-
- private:
-  typedef internal::vector_int_pair<Scalar, Dim> VIPair;
-  typedef std::vector<VIPair, aligned_allocator<VIPair> > VIPairList;
-  typedef Matrix<Scalar, Dim, 1> VectorType;
-  struct VectorComparator  // compares vectors, or more specifically, VIPairs along a particular dimension
-  {
-    VectorComparator(int inDim) : dim(inDim) {}
-    inline bool operator()(const VIPair &v1, const VIPair &v2) const { return v1.first[dim] < v2.first[dim]; }
-    int dim;
-  };
-
-  // Build the part of the tree between objects[from] and objects[to] (not including objects[to]).
-  // This routine partitions the objCenters in [from, to) along the dimension dim, recursively constructs
-  // the two halves, and adds their parent node.  TODO: a cache-friendlier layout
-  void build(VIPairList &objCenters, int from, int to, const VolumeList &objBoxes, int dim) {
-    eigen_assert(to - from > 1);
-    if (to - from == 2) {
-      boxes.push_back(objBoxes[objCenters[from].second].merged(objBoxes[objCenters[from + 1].second]));
-      children.push_back(from + (int)objects.size() - 1);  // there are objects.size() - 1 tree nodes
-      children.push_back(from + (int)objects.size());
-    } else if (to - from == 3) {
-      int mid = from + 2;
-      std::nth_element(objCenters.begin() + from, objCenters.begin() + mid, objCenters.begin() + to,
-                       VectorComparator(dim));  // partition
-      build(objCenters, from, mid, objBoxes, (dim + 1) % Dim);
-      int idx1 = (int)boxes.size() - 1;
-      boxes.push_back(boxes[idx1].merged(objBoxes[objCenters[mid].second]));
-      children.push_back(idx1);
-      children.push_back(mid + (int)objects.size() - 1);
-    } else {
-      int mid = from + (to - from) / 2;
-      nth_element(objCenters.begin() + from, objCenters.begin() + mid, objCenters.begin() + to,
-                  VectorComparator(dim));  // partition
-      build(objCenters, from, mid, objBoxes, (dim + 1) % Dim);
-      int idx1 = (int)boxes.size() - 1;
-      build(objCenters, mid, to, objBoxes, (dim + 1) % Dim);
-      int idx2 = (int)boxes.size() - 1;
-      boxes.push_back(boxes[idx1].merged(boxes[idx2]));
-      children.push_back(idx1);
-      children.push_back(idx2);
-    }
-  }
-
-  std::vector<int> children;  // children of x are children[2x] and children[2x+1], indices bigger than boxes.size()
-                              // index into objects.
-  VolumeList boxes;
-  ObjectList objects;
-};
-
-}  // end namespace Eigen
-
-#endif  // KDBVH_H_INCLUDED
diff --git a/unsupported/Eigen/src/Eigenvalues/ArpackSelfAdjointEigenSolver.h b/unsupported/Eigen/src/Eigenvalues/ArpackSelfAdjointEigenSolver.h
deleted file mode 100644
index b110aee..0000000
--- a/unsupported/Eigen/src/Eigenvalues/ArpackSelfAdjointEigenSolver.h
+++ /dev/null
@@ -1,699 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 David Harmon <dharmon@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_ARPACKGENERALIZEDSELFADJOINTEIGENSOLVER_H
-#define EIGEN_ARPACKGENERALIZEDSELFADJOINTEIGENSOLVER_H
-
-#include "../../../../Eigen/Dense"
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Scalar, typename RealScalar>
-struct arpack_wrapper;
-template <typename MatrixSolver, typename MatrixType, typename Scalar, bool BisSPD>
-struct OP;
-}  // namespace internal
-
-template <typename MatrixType, typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>
-class ArpackGeneralizedSelfAdjointEigenSolver {
- public:
-  /** \brief Scalar type for matrices of type \p MatrixType. */
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::Index Index;
-
-  /** \brief Real scalar type for \p MatrixType.
-   *
-   * This is just \c Scalar if #Scalar is real (e.g., \c float or
-   * \c Scalar), and the type of the real part of \c Scalar if #Scalar is
-   * complex.
-   */
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  /** \brief Type for vector of eigenvalues as returned by eigenvalues().
-   *
-   * This is a column vector with entries of type #RealScalar.
-   * The length of the vector is the size of \p nbrEigenvalues.
-   */
-  typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType;
-
-  /** \brief Default constructor.
-   *
-   * The default constructor is for cases in which the user intends to
-   * perform decompositions via compute().
-   *
-   */
-  ArpackGeneralizedSelfAdjointEigenSolver()
-      : m_eivec(),
-        m_eivalues(),
-        m_isInitialized(false),
-        m_eigenvectorsOk(false),
-        m_nbrConverged(0),
-        m_nbrIterations(0) {}
-
-  /** \brief Constructor; computes generalized eigenvalues of given matrix with respect to another matrix.
-   *
-   * \param[in] A Self-adjoint matrix whose eigenvalues / eigenvectors will
-   *    computed. By default, the upper triangular part is used, but can be changed
-   *    through the template parameter.
-   * \param[in] B Self-adjoint matrix for the generalized eigenvalue problem.
-   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
-   *    Must be less than the size of the input matrix, or an error is returned.
-   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
-   *    respective meanings to find the largest magnitude , smallest magnitude,
-   *    largest algebraic, or smallest algebraic eigenvalues. Alternatively, this
-   *    value can contain floating point value in string form, in which case the
-   *    eigenvalues closest to this value will be found.
-   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
-   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
-   *    means machine precision.
-   *
-   * This constructor calls compute(const MatrixType&, const MatrixType&, Index, string, int, RealScalar)
-   * to compute the eigenvalues of the matrix \p A with respect to \p B. The eigenvectors are computed if
-   * \p options equals #ComputeEigenvectors.
-   *
-   */
-  ArpackGeneralizedSelfAdjointEigenSolver(const MatrixType &A, const MatrixType &B, Index nbrEigenvalues,
-                                          std::string eigs_sigma = "LM", int options = ComputeEigenvectors,
-                                          RealScalar tol = 0.0)
-      : m_eivec(),
-        m_eivalues(),
-        m_isInitialized(false),
-        m_eigenvectorsOk(false),
-        m_nbrConverged(0),
-        m_nbrIterations(0) {
-    compute(A, B, nbrEigenvalues, eigs_sigma, options, tol);
-  }
-
-  /** \brief Constructor; computes eigenvalues of given matrix.
-   *
-   * \param[in] A Self-adjoint matrix whose eigenvalues / eigenvectors will
-   *    computed. By default, the upper triangular part is used, but can be changed
-   *    through the template parameter.
-   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
-   *    Must be less than the size of the input matrix, or an error is returned.
-   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
-   *    respective meanings to find the largest magnitude , smallest magnitude,
-   *    largest algebraic, or smallest algebraic eigenvalues. Alternatively, this
-   *    value can contain floating point value in string form, in which case the
-   *    eigenvalues closest to this value will be found.
-   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
-   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
-   *    means machine precision.
-   *
-   * This constructor calls compute(const MatrixType&, Index, string, int, RealScalar)
-   * to compute the eigenvalues of the matrix \p A. The eigenvectors are computed if
-   * \p options equals #ComputeEigenvectors.
-   *
-   */
-
-  ArpackGeneralizedSelfAdjointEigenSolver(const MatrixType &A, Index nbrEigenvalues, std::string eigs_sigma = "LM",
-                                          int options = ComputeEigenvectors, RealScalar tol = 0.0)
-      : m_eivec(),
-        m_eivalues(),
-        m_isInitialized(false),
-        m_eigenvectorsOk(false),
-        m_nbrConverged(0),
-        m_nbrIterations(0) {
-    compute(A, nbrEigenvalues, eigs_sigma, options, tol);
-  }
-
-  /** \brief Computes generalized eigenvalues / eigenvectors of given matrix using the external ARPACK library.
-   *
-   * \param[in]  A  Selfadjoint matrix whose eigendecomposition is to be computed.
-   * \param[in]  B  Selfadjoint matrix for generalized eigenvalues.
-   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
-   *    Must be less than the size of the input matrix, or an error is returned.
-   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
-   *    respective meanings to find the largest magnitude , smallest magnitude,
-   *    largest algebraic, or smallest algebraic eigenvalues. Alternatively, this
-   *    value can contain floating point value in string form, in which case the
-   *    eigenvalues closest to this value will be found.
-   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
-   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
-   *    means machine precision.
-   *
-   * \returns    Reference to \c *this
-   *
-   * This function computes the generalized eigenvalues of \p A with respect to \p B using ARPACK.  The eigenvalues()
-   * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
-   * then the eigenvectors are also computed and can be retrieved by
-   * calling eigenvectors().
-   *
-   */
-  ArpackGeneralizedSelfAdjointEigenSolver &compute(const MatrixType &A, const MatrixType &B, Index nbrEigenvalues,
-                                                   std::string eigs_sigma = "LM", int options = ComputeEigenvectors,
-                                                   RealScalar tol = 0.0);
-
-  /** \brief Computes eigenvalues / eigenvectors of given matrix using the external ARPACK library.
-   *
-   * \param[in]  A  Selfadjoint matrix whose eigendecomposition is to be computed.
-   * \param[in] nbrEigenvalues The number of eigenvalues / eigenvectors to compute.
-   *    Must be less than the size of the input matrix, or an error is returned.
-   * \param[in] eigs_sigma String containing either "LM", "SM", "LA", or "SA", with
-   *    respective meanings to find the largest magnitude , smallest magnitude,
-   *    largest algebraic, or smallest algebraic eigenvalues. Alternatively, this
-   *    value can contain floating point value in string form, in which case the
-   *    eigenvalues closest to this value will be found.
-   * \param[in]  options Can be #ComputeEigenvectors (default) or #EigenvaluesOnly.
-   * \param[in] tol What tolerance to find the eigenvalues to. Default is 0, which
-   *    means machine precision.
-   *
-   * \returns    Reference to \c *this
-   *
-   * This function computes the eigenvalues of \p A using ARPACK.  The eigenvalues()
-   * function can be used to retrieve them.  If \p options equals #ComputeEigenvectors,
-   * then the eigenvectors are also computed and can be retrieved by
-   * calling eigenvectors().
-   *
-   */
-  ArpackGeneralizedSelfAdjointEigenSolver &compute(const MatrixType &A, Index nbrEigenvalues,
-                                                   std::string eigs_sigma = "LM", int options = ComputeEigenvectors,
-                                                   RealScalar tol = 0.0);
-
-  /** \brief Returns the eigenvectors of given matrix.
-   *
-   * \returns  A const reference to the matrix whose columns are the eigenvectors.
-   *
-   * \pre The eigenvectors have been computed before.
-   *
-   * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
-   * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
-   * eigenvectors are normalized to have (Euclidean) norm equal to one. If
-   * this object was used to solve the eigenproblem for the selfadjoint
-   * matrix \f$ A \f$, then the matrix returned by this function is the
-   * matrix \f$ V \f$ in the eigendecomposition \f$ A V = D V \f$.
-   * For the generalized eigenproblem, the matrix returned is the solution \f$ A V = D B V \f$
-   *
-   * Example: \include SelfAdjointEigenSolver_eigenvectors.cpp
-   * Output: \verbinclude SelfAdjointEigenSolver_eigenvectors.out
-   *
-   * \sa eigenvalues()
-   */
-  const Matrix<Scalar, Dynamic, Dynamic> &eigenvectors() const {
-    eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
-    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
-    return m_eivec;
-  }
-
-  /** \brief Returns the eigenvalues of given matrix.
-   *
-   * \returns A const reference to the column vector containing the eigenvalues.
-   *
-   * \pre The eigenvalues have been computed before.
-   *
-   * The eigenvalues are repeated according to their algebraic multiplicity,
-   * so there are as many eigenvalues as rows in the matrix. The eigenvalues
-   * are sorted in increasing order.
-   *
-   * Example: \include SelfAdjointEigenSolver_eigenvalues.cpp
-   * Output: \verbinclude SelfAdjointEigenSolver_eigenvalues.out
-   *
-   * \sa eigenvectors(), MatrixBase::eigenvalues()
-   */
-  const Matrix<Scalar, Dynamic, 1> &eigenvalues() const {
-    eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
-    return m_eivalues;
-  }
-
-  /** \brief Computes the positive-definite square root of the matrix.
-   *
-   * \returns the positive-definite square root of the matrix
-   *
-   * \pre The eigenvalues and eigenvectors of a positive-definite matrix
-   * have been computed before.
-   *
-   * The square root of a positive-definite matrix \f$ A \f$ is the
-   * positive-definite matrix whose square equals \f$ A \f$. This function
-   * uses the eigendecomposition \f$ A = V D V^{-1} \f$ to compute the
-   * square root as \f$ A^{1/2} = V D^{1/2} V^{-1} \f$.
-   *
-   * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
-   * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
-   *
-   * \sa operatorInverseSqrt(),
-   *     \ref MatrixFunctions_Module "MatrixFunctions Module"
-   */
-  Matrix<Scalar, Dynamic, Dynamic> operatorSqrt() const {
-    eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
-    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
-    return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
-  }
-
-  /** \brief Computes the inverse square root of the matrix.
-   *
-   * \returns the inverse positive-definite square root of the matrix
-   *
-   * \pre The eigenvalues and eigenvectors of a positive-definite matrix
-   * have been computed before.
-   *
-   * This function uses the eigendecomposition \f$ A = V D V^{-1} \f$ to
-   * compute the inverse square root as \f$ V D^{-1/2} V^{-1} \f$. This is
-   * cheaper than first computing the square root with operatorSqrt() and
-   * then its inverse with MatrixBase::inverse().
-   *
-   * Example: \include SelfAdjointEigenSolver_operatorInverseSqrt.cpp
-   * Output: \verbinclude SelfAdjointEigenSolver_operatorInverseSqrt.out
-   *
-   * \sa operatorSqrt(), MatrixBase::inverse(),
-   *     \ref MatrixFunctions_Module "MatrixFunctions Module"
-   */
-  Matrix<Scalar, Dynamic, Dynamic> operatorInverseSqrt() const {
-    eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
-    eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
-    return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
-  }
-
-  /** \brief Reports whether previous computation was successful.
-   *
-   * \returns \c Success if computation was successful, \c NoConvergence otherwise.
-   */
-  ComputationInfo info() const {
-    eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
-    return m_info;
-  }
-
-  size_t getNbrConvergedEigenValues() const { return m_nbrConverged; }
-
-  size_t getNbrIterations() const { return m_nbrIterations; }
-
- protected:
-  Matrix<Scalar, Dynamic, Dynamic> m_eivec;
-  Matrix<Scalar, Dynamic, 1> m_eivalues;
-  ComputationInfo m_info;
-  bool m_isInitialized;
-  bool m_eigenvectorsOk;
-
-  size_t m_nbrConverged;
-  size_t m_nbrIterations;
-};
-
-template <typename MatrixType, typename MatrixSolver, bool BisSPD>
-ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD> &
-ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD>::compute(const MatrixType &A,
-                                                                                   Index nbrEigenvalues,
-                                                                                   std::string eigs_sigma, int options,
-                                                                                   RealScalar tol) {
-  MatrixType B(0, 0);
-  compute(A, B, nbrEigenvalues, eigs_sigma, options, tol);
-
-  return *this;
-}
-
-template <typename MatrixType, typename MatrixSolver, bool BisSPD>
-ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD> &
-ArpackGeneralizedSelfAdjointEigenSolver<MatrixType, MatrixSolver, BisSPD>::compute(const MatrixType &A,
-                                                                                   const MatrixType &B,
-                                                                                   Index nbrEigenvalues,
-                                                                                   std::string eigs_sigma, int options,
-                                                                                   RealScalar tol) {
-  eigen_assert(A.cols() == A.rows());
-  eigen_assert(B.cols() == B.rows());
-  eigen_assert(B.rows() == 0 || A.cols() == B.rows());
-  eigen_assert((options & ~(EigVecMask | GenEigMask)) == 0 && (options & EigVecMask) != EigVecMask &&
-               "invalid option parameter");
-
-  bool isBempty = (B.rows() == 0) || (B.cols() == 0);
-
-  // For clarity, all parameters match their ARPACK name
-  //
-  // Always 0 on the first call
-  //
-  int ido = 0;
-
-  int n = (int)A.cols();
-
-  // User options: "LA", "SA", "SM", "LM", "BE"
-  //
-  char whch[3] = "LM";
-
-  // Specifies the shift if iparam[6] = { 3, 4, 5 }, not used if iparam[6] = { 1, 2 }
-  //
-  RealScalar sigma = 0.0;
-
-  if (eigs_sigma.length() >= 2 && isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1])) {
-    eigs_sigma[0] = toupper(eigs_sigma[0]);
-    eigs_sigma[1] = toupper(eigs_sigma[1]);
-
-    // In the following special case we're going to invert the problem, since solving
-    // for larger magnitude is much much faster
-    // i.e., if 'SM' is specified, we're going to really use 'LM', the default
-    //
-    if (eigs_sigma.substr(0, 2) != "SM") {
-      whch[0] = eigs_sigma[0];
-      whch[1] = eigs_sigma[1];
-    }
-  } else {
-    eigen_assert(false && "Specifying clustered eigenvalues is not yet supported!");
-
-    // If it's not scalar values, then the user may be explicitly
-    // specifying the sigma value to cluster the evs around
-    //
-    sigma = atof(eigs_sigma.c_str());
-
-    // If atof fails, it returns 0.0, which is a fine default
-    //
-  }
-
-  // "I" means normal eigenvalue problem, "G" means generalized
-  //
-  char bmat[2] = "I";
-  if (eigs_sigma.substr(0, 2) == "SM" || !(isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1])) || (!isBempty && !BisSPD))
-    bmat[0] = 'G';
-
-  // Now we determine the mode to use
-  //
-  int mode = (bmat[0] == 'G') + 1;
-  if (eigs_sigma.substr(0, 2) == "SM" || !(isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1]))) {
-    // We're going to use shift-and-invert mode, and basically find
-    // the largest eigenvalues of the inverse operator
-    //
-    mode = 3;
-  }
-
-  // The user-specified number of eigenvalues/vectors to compute
-  //
-  int nev = (int)nbrEigenvalues;
-
-  // Allocate space for ARPACK to store the residual
-  //
-  Scalar *resid = new Scalar[n];
-
-  // Number of Lanczos vectors, must satisfy nev < ncv <= n
-  // Note that this indicates that nev != n, and we cannot compute
-  // all eigenvalues of a mtrix
-  //
-  int ncv = std::min(std::max(2 * nev, 20), n);
-
-  // The working n x ncv matrix, also store the final eigenvectors (if computed)
-  //
-  Scalar *v = new Scalar[n * ncv];
-  int ldv = n;
-
-  // Working space
-  //
-  Scalar *workd = new Scalar[3 * n];
-  int lworkl = ncv * ncv + 8 * ncv;  // Must be at least this length
-  Scalar *workl = new Scalar[lworkl];
-
-  int *iparam = new int[11];
-  iparam[0] = 1;  // 1 means we let ARPACK perform the shifts, 0 means we'd have to do it
-  iparam[2] = std::max(300, (int)std::ceil(2 * n / std::max(ncv, 1)));
-  iparam[6] = mode;  // The mode, 1 is standard ev problem, 2 for generalized ev, 3 for shift-and-invert
-
-  // Used during reverse communicate to notify where arrays start
-  //
-  int *ipntr = new int[11];
-
-  // Error codes are returned in here, initial value of 0 indicates a random initial
-  // residual vector is used, any other values means resid contains the initial residual
-  // vector, possibly from a previous run
-  //
-  int info = 0;
-
-  Scalar scale = 1.0;
-
-  MatrixSolver OP;
-  if (mode == 1 || mode == 2) {
-    if (!isBempty) OP.compute(B);
-  } else if (mode == 3) {
-    if (sigma == 0.0) {
-      OP.compute(A);
-    } else {
-      // Note: We will never enter here because sigma must be 0.0
-      //
-      if (isBempty) {
-        MatrixType AminusSigmaB(A);
-        for (Index i = 0; i < A.rows(); ++i) AminusSigmaB.coeffRef(i, i) -= sigma;
-
-        OP.compute(AminusSigmaB);
-      } else {
-        MatrixType AminusSigmaB = A - sigma * B;
-        OP.compute(AminusSigmaB);
-      }
-    }
-  }
-
-  if (!(mode == 1 && isBempty) && !(mode == 2 && isBempty) && OP.info() != Success) {
-    m_info = OP.info();
-    delete[] v;
-    delete[] iparam;
-    delete[] ipntr;
-    delete[] workd;
-    delete[] workl;
-    delete[] resid;
-    m_isInitialized = false;
-    return *this;
-  }
-
-  do {
-    internal::arpack_wrapper<Scalar, RealScalar>::saupd(&ido, bmat, &n, whch, &nev, &tol, resid, &ncv, v, &ldv, iparam,
-                                                        ipntr, workd, workl, &lworkl, &info);
-
-    if (ido == -1 || ido == 1) {
-      Scalar *in = workd + ipntr[0] - 1;
-      Scalar *out = workd + ipntr[1] - 1;
-
-      if (ido == 1 && mode != 2) {
-        Scalar *out2 = workd + ipntr[2] - 1;
-        if (isBempty || mode == 1)
-          Matrix<Scalar, Dynamic, 1>::Map(out2, n) = Matrix<Scalar, Dynamic, 1>::Map(in, n);
-        else
-          Matrix<Scalar, Dynamic, 1>::Map(out2, n) = B * Matrix<Scalar, Dynamic, 1>::Map(in, n);
-
-        in = workd + ipntr[2] - 1;
-      }
-
-      if (mode == 1) {
-        if (isBempty) {
-          // OP = A
-          //
-          Matrix<Scalar, Dynamic, 1>::Map(out, n) = A * Matrix<Scalar, Dynamic, 1>::Map(in, n);
-        } else {
-          // OP = L^{-1}AL^{-T}
-          //
-          internal::OP<MatrixSolver, MatrixType, Scalar, BisSPD>::applyOP(OP, A, n, in, out);
-        }
-      } else if (mode == 2) {
-        if (ido == 1) Matrix<Scalar, Dynamic, 1>::Map(in, n) = A * Matrix<Scalar, Dynamic, 1>::Map(in, n);
-
-        // OP = B^{-1} A
-        //
-        Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
-      } else if (mode == 3) {
-        // OP = (A-\sigmaB)B (\sigma could be 0, and B could be I)
-        // The B * in is already computed and stored at in if ido == 1
-        //
-        if (ido == 1 || isBempty)
-          Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
-        else
-          Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(B * Matrix<Scalar, Dynamic, 1>::Map(in, n));
-      }
-    } else if (ido == 2) {
-      Scalar *in = workd + ipntr[0] - 1;
-      Scalar *out = workd + ipntr[1] - 1;
-
-      if (isBempty || mode == 1)
-        Matrix<Scalar, Dynamic, 1>::Map(out, n) = Matrix<Scalar, Dynamic, 1>::Map(in, n);
-      else
-        Matrix<Scalar, Dynamic, 1>::Map(out, n) = B * Matrix<Scalar, Dynamic, 1>::Map(in, n);
-    }
-  } while (ido != 99);
-
-  if (info == 1)
-    m_info = NoConvergence;
-  else if (info == 3)
-    m_info = NumericalIssue;
-  else if (info < 0)
-    m_info = InvalidInput;
-  else if (info != 0)
-    eigen_assert(false && "Unknown ARPACK return value!");
-  else {
-    // Do we compute eigenvectors or not?
-    //
-    int rvec = (options & ComputeEigenvectors) == ComputeEigenvectors;
-
-    // "A" means "All", use "S" to choose specific eigenvalues (not yet supported in ARPACK))
-    //
-    char howmny[2] = "A";
-
-    // if howmny == "S", specifies the eigenvalues to compute (not implemented in ARPACK)
-    //
-    int *select = new int[ncv];
-
-    // Final eigenvalues
-    //
-    m_eivalues.resize(nev, 1);
-
-    internal::arpack_wrapper<Scalar, RealScalar>::seupd(&rvec, howmny, select, m_eivalues.data(), v, &ldv, &sigma, bmat,
-                                                        &n, whch, &nev, &tol, resid, &ncv, v, &ldv, iparam, ipntr,
-                                                        workd, workl, &lworkl, &info);
-
-    if (info == -14)
-      m_info = NoConvergence;
-    else if (info != 0)
-      m_info = InvalidInput;
-    else {
-      if (rvec) {
-        m_eivec.resize(A.rows(), nev);
-        for (int i = 0; i < nev; i++)
-          for (int j = 0; j < n; j++) m_eivec(j, i) = v[i * n + j] / scale;
-
-        if (mode == 1 && !isBempty && BisSPD)
-          internal::OP<MatrixSolver, MatrixType, Scalar, BisSPD>::project(OP, n, nev, m_eivec.data());
-
-        m_eigenvectorsOk = true;
-      }
-
-      m_nbrIterations = iparam[2];
-      m_nbrConverged = iparam[4];
-
-      m_info = Success;
-    }
-
-    delete[] select;
-  }
-
-  delete[] v;
-  delete[] iparam;
-  delete[] ipntr;
-  delete[] workd;
-  delete[] workl;
-  delete[] resid;
-
-  m_isInitialized = (m_info == Success);
-
-  return *this;
-}
-
-// Single precision
-//
-extern "C" void ssaupd_(int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv,
-                        float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl,
-                        int *info);
-
-extern "C" void sseupd_(int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat,
-                        int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv,
-                        int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr);
-
-// Double precision
-//
-extern "C" void dsaupd_(int *ido, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv,
-                        double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl,
-                        int *info);
-
-extern "C" void dseupd_(int *rvec, char *All, int *select, double *d, double *z, int *ldz, double *sigma, char *bmat,
-                        int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv,
-                        int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *ierr);
-
-namespace internal {
-
-template <typename Scalar, typename RealScalar>
-struct arpack_wrapper {
-  static inline void saupd(int *ido, char *bmat, int *n, char *which, int *nev, RealScalar *tol, Scalar *resid,
-                           int *ncv, Scalar *v, int *ldv, int *iparam, int *ipntr, Scalar *workd, Scalar *workl,
-                           int *lworkl, int *info) {
-    EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
-  }
-
-  static inline void seupd(int *rvec, char *All, int *select, Scalar *d, Scalar *z, int *ldz, RealScalar *sigma,
-                           char *bmat, int *n, char *which, int *nev, RealScalar *tol, Scalar *resid, int *ncv,
-                           Scalar *v, int *ldv, int *iparam, int *ipntr, Scalar *workd, Scalar *workl, int *lworkl,
-                           int *ierr) {
-    EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL)
-  }
-};
-
-template <>
-struct arpack_wrapper<float, float> {
-  static inline void saupd(int *ido, char *bmat, int *n, char *which, int *nev, float *tol, float *resid, int *ncv,
-                           float *v, int *ldv, int *iparam, int *ipntr, float *workd, float *workl, int *lworkl,
-                           int *info) {
-    ssaupd_(ido, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd, workl, lworkl, info);
-  }
-
-  static inline void seupd(int *rvec, char *All, int *select, float *d, float *z, int *ldz, float *sigma, char *bmat,
-                           int *n, char *which, int *nev, float *tol, float *resid, int *ncv, float *v, int *ldv,
-                           int *iparam, int *ipntr, float *workd, float *workl, int *lworkl, int *ierr) {
-    sseupd_(rvec, All, select, d, z, ldz, sigma, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd,
-            workl, lworkl, ierr);
-  }
-};
-
-template <>
-struct arpack_wrapper<double, double> {
-  static inline void saupd(int *ido, char *bmat, int *n, char *which, int *nev, double *tol, double *resid, int *ncv,
-                           double *v, int *ldv, int *iparam, int *ipntr, double *workd, double *workl, int *lworkl,
-                           int *info) {
-    dsaupd_(ido, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd, workl, lworkl, info);
-  }
-
-  static inline void seupd(int *rvec, char *All, int *select, double *d, double *z, int *ldz, double *sigma, char *bmat,
-                           int *n, char *which, int *nev, double *tol, double *resid, int *ncv, double *v, int *ldv,
-                           int *iparam, int *ipntr, double *workd, double *workl, int *lworkl, int *ierr) {
-    dseupd_(rvec, All, select, d, v, ldv, sigma, bmat, n, which, nev, tol, resid, ncv, v, ldv, iparam, ipntr, workd,
-            workl, lworkl, ierr);
-  }
-};
-
-template <typename MatrixSolver, typename MatrixType, typename Scalar, bool BisSPD>
-struct OP {
-  static inline void applyOP(MatrixSolver &OP, const MatrixType &A, int n, Scalar *in, Scalar *out);
-  static inline void project(MatrixSolver &OP, int n, int k, Scalar *vecs);
-};
-
-template <typename MatrixSolver, typename MatrixType, typename Scalar>
-struct OP<MatrixSolver, MatrixType, Scalar, true> {
-  static inline void applyOP(MatrixSolver &OP, const MatrixType &A, int n, Scalar *in, Scalar *out) {
-    // OP = L^{-1} A L^{-T}  (B = LL^T)
-    //
-    // First solve L^T out = in
-    //
-    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.matrixU().solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
-    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.permutationPinv() * Matrix<Scalar, Dynamic, 1>::Map(out, n);
-
-    // Then compute out = A out
-    //
-    Matrix<Scalar, Dynamic, 1>::Map(out, n) = A * Matrix<Scalar, Dynamic, 1>::Map(out, n);
-
-    // Then solve L out = out
-    //
-    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.permutationP() * Matrix<Scalar, Dynamic, 1>::Map(out, n);
-    Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.matrixL().solve(Matrix<Scalar, Dynamic, 1>::Map(out, n));
-  }
-
-  static inline void project(MatrixSolver &OP, int n, int k, Scalar *vecs) {
-    // Solve L^T out = in
-    //
-    Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k) =
-        OP.matrixU().solve(Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k));
-    Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k) =
-        OP.permutationPinv() * Matrix<Scalar, Dynamic, Dynamic>::Map(vecs, n, k);
-  }
-};
-
-template <typename MatrixSolver, typename MatrixType, typename Scalar>
-struct OP<MatrixSolver, MatrixType, Scalar, false> {
-  static inline void applyOP(MatrixSolver &OP, const MatrixType &A, int n, Scalar *in, Scalar *out) {
-    eigen_assert(false && "Should never be in here...");
-  }
-
-  static inline void project(MatrixSolver &OP, int n, int k, Scalar *vecs) {
-    eigen_assert(false && "Should never be in here...");
-  }
-};
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_ARPACKSELFADJOINTEIGENSOLVER_H
diff --git a/unsupported/Eigen/src/Eigenvalues/InternalHeaderCheck.h b/unsupported/Eigen/src/Eigenvalues/InternalHeaderCheck.h
deleted file mode 100644
index c00cb57..0000000
--- a/unsupported/Eigen/src/Eigenvalues/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_EIGENVALUES_MODULE_H
-#error "Please include unsupported/Eigen/Eigenvalues instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/EulerAngles/CMakeLists.txt b/unsupported/Eigen/src/EulerAngles/CMakeLists.txt
deleted file mode 100644
index 22088eb..0000000
--- a/unsupported/Eigen/src/EulerAngles/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-file(GLOB Eigen_EulerAngles_SRCS "*.h")
-
-install(FILES
-  ${Eigen_EulerAngles_SRCS}
-  DESTINATION ${INCLUDE_INSTALL_DIR}/unsupported/Eigen/src/EulerAngles COMPONENT Devel
-  )
diff --git a/unsupported/Eigen/src/EulerAngles/EulerAngles.h b/unsupported/Eigen/src/EulerAngles/EulerAngles.h
deleted file mode 100644
index b0b3617..0000000
--- a/unsupported/Eigen/src/EulerAngles/EulerAngles.h
+++ /dev/null
@@ -1,350 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_EULERANGLESCLASS_H  // TODO: Fix previous "EIGEN_EULERANGLES_H" definition?
-#define EIGEN_EULERANGLESCLASS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-/** \class EulerAngles
- *
- * \ingroup EulerAngles_Module
- *
- * \brief Represents a rotation in a 3 dimensional space as three Euler angles.
- *
- * Euler rotation is a set of three rotation of three angles over three fixed axes, defined by the EulerSystem given as
- * a template parameter.
- *
- * Here is how intrinsic Euler angles works:
- *  - first, rotate the axes system over the alpha axis in angle alpha
- *  - then, rotate the axes system over the beta axis(which was rotated in the first stage) in angle beta
- *  - then, rotate the axes system over the gamma axis(which was rotated in the two stages above) in angle gamma
- *
- * \note This class support only intrinsic Euler angles for simplicity,
- *  see EulerSystem how to easily overcome this for extrinsic systems.
- *
- * ### Rotation representation and conversions ###
- *
- * It has been proved(see Wikipedia link below) that every rotation can be represented
- *  by Euler angles, but there is no single representation (e.g. unlike rotation matrices).
- * Therefore, you can convert from Eigen rotation and to them
- *  (including rotation matrices, which is not called "rotations" by Eigen design).
- *
- * Euler angles usually used for:
- *  - convenient human representation of rotation, especially in interactive GUI.
- *  - gimbal systems and robotics
- *  - efficient encoding(i.e. 3 floats only) of rotation for network protocols.
- *
- * However, Euler angles are slow comparing to quaternion or matrices,
- *  because their unnatural math definition, although it's simple for human.
- * To overcome this, this class provide easy movement from the math friendly representation
- *  to the human friendly representation, and vise-versa.
- *
- * All the user need to do is a safe simple C++ type conversion,
- *  and this class take care for the math.
- * Additionally, some axes related computation is done in compile time.
- *
- * #### Euler angles ranges in conversions ####
- * Rotations representation as EulerAngles are not single (unlike matrices),
- *  and even have infinite EulerAngles representations.<BR>
- * For example, add or subtract 2*PI from either angle of EulerAngles
- *  and you'll get the same rotation.
- * This is the general reason for infinite representation,
- *  but it's not the only general reason for not having a single representation.
- *
- * When converting rotation to EulerAngles, this class convert it to specific ranges
- * When converting some rotation to EulerAngles, the rules for ranges are as follow:
- * - If the rotation we converting from is an EulerAngles
- *  (even when it represented as RotationBase explicitly), angles ranges are __undefined__.
- * - otherwise, alpha and gamma angles will be in the range [-PI, PI].<BR>
- *   As for Beta angle:
- *    - If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
- *    - otherwise:
- *      - If the beta axis is positive, the beta angle will be in the range [0, PI]
- *      - If the beta axis is negative, the beta angle will be in the range [-PI, 0]
- *
- * \sa EulerAngles(const MatrixBase<Derived>&)
- * \sa EulerAngles(const RotationBase<Derived, 3>&)
- *
- * ### Convenient user typedefs ###
- *
- * Convenient typedefs for EulerAngles exist for float and double scalar,
- *  in a form of EulerAngles{A}{B}{C}{scalar},
- *  e.g. \ref EulerAnglesXYZd, \ref EulerAnglesZYZf.
- *
- * Only for positive axes{+x,+y,+z} Euler systems are have convenient typedef.
- * If you need negative axes{-x,-y,-z}, it is recommended to create you own typedef with
- *  a word that represent what you need.
- *
- * ### Example ###
- *
- * \include EulerAngles.cpp
- * Output: \verbinclude EulerAngles.out
- *
- * ### Additional reading ###
- *
- * If you're want to get more idea about how Euler system work in Eigen see EulerSystem.
- *
- * More information about Euler angles: https://en.wikipedia.org/wiki/Euler_angles
- *
- * \tparam Scalar_ the scalar type, i.e. the type of the angles.
- *
- * \tparam _System the EulerSystem to use, which represents the axes of rotation.
- */
-template <typename Scalar_, class _System>
-class EulerAngles : public RotationBase<EulerAngles<Scalar_, _System>, 3> {
- public:
-  typedef RotationBase<EulerAngles<Scalar_, _System>, 3> Base;
-
-  /** the scalar type of the angles */
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  /** the EulerSystem to use, which represents the axes of rotation. */
-  typedef _System System;
-
-  typedef Matrix<Scalar, 3, 3> Matrix3;      /*!< the equivalent rotation matrix type */
-  typedef Matrix<Scalar, 3, 1> Vector3;      /*!< the equivalent 3 dimension vector type */
-  typedef Quaternion<Scalar> QuaternionType; /*!< the equivalent quaternion type */
-  typedef AngleAxis<Scalar> AngleAxisType;   /*!< the equivalent angle-axis type */
-
-  /** \returns the axis vector of the first (alpha) rotation */
-  static Vector3 AlphaAxisVector() {
-    const Vector3& u = Vector3::Unit(System::AlphaAxisAbs - 1);
-    return System::IsAlphaOpposite ? -u : u;
-  }
-
-  /** \returns the axis vector of the second (beta) rotation */
-  static Vector3 BetaAxisVector() {
-    const Vector3& u = Vector3::Unit(System::BetaAxisAbs - 1);
-    return System::IsBetaOpposite ? -u : u;
-  }
-
-  /** \returns the axis vector of the third (gamma) rotation */
-  static Vector3 GammaAxisVector() {
-    const Vector3& u = Vector3::Unit(System::GammaAxisAbs - 1);
-    return System::IsGammaOpposite ? -u : u;
-  }
-
- private:
-  Vector3 m_angles;
-
- public:
-  /** Default constructor without initialization. */
-  EulerAngles() {}
-  /** Constructs and initialize an EulerAngles (\p alpha, \p beta, \p gamma). */
-  EulerAngles(const Scalar& alpha, const Scalar& beta, const Scalar& gamma) : m_angles(alpha, beta, gamma) {}
-
-  // TODO: Test this constructor
-  /** Constructs and initialize an EulerAngles from the array data {alpha, beta, gamma} */
-  explicit EulerAngles(const Scalar* data) : m_angles(data) {}
-
-  /** Constructs and initializes an EulerAngles from either:
-   *  - a 3x3 rotation matrix expression(i.e. pure orthogonal matrix with determinant of +1),
-   *  - a 3D vector expression representing Euler angles.
-   *
-   * \note If \p other is a 3x3 rotation matrix, the angles range rules will be as follow:<BR>
-   *  Alpha and gamma angles will be in the range [-PI, PI].<BR>
-   *  As for Beta angle:
-   *   - If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
-   *   - otherwise:
-   *     - If the beta axis is positive, the beta angle will be in the range [0, PI]
-   *     - If the beta axis is negative, the beta angle will be in the range [-PI, 0]
-   */
-  template <typename Derived>
-  explicit EulerAngles(const MatrixBase<Derived>& other) {
-    *this = other;
-  }
-
-  /** Constructs and initialize Euler angles from a rotation \p rot.
-   *
-   * \note If \p rot is an EulerAngles (even when it represented as RotationBase explicitly),
-   *  angles ranges are __undefined__.
-   *  Otherwise, alpha and gamma angles will be in the range [-PI, PI].<BR>
-   *  As for Beta angle:
-   *   - If the system is Tait-Bryan, the beta angle will be in the range [-PI/2, PI/2].
-   *   - otherwise:
-   *     - If the beta axis is positive, the beta angle will be in the range [0, PI]
-   *     - If the beta axis is negative, the beta angle will be in the range [-PI, 0]
-   */
-  template <typename Derived>
-  EulerAngles(const RotationBase<Derived, 3>& rot) {
-    System::CalcEulerAngles(*this, rot.toRotationMatrix());
-  }
-
-  /*EulerAngles(const QuaternionType& q)
-  {
-    // TODO: Implement it in a faster way for quaternions
-    // According to http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/
-    //  we can compute only the needed matrix cells and then convert to euler angles. (see ZYX example below)
-    // Currently we compute all matrix cells from quaternion.
-
-    // Special case only for ZYX
-    //Scalar y2 = q.y() * q.y();
-    //m_angles[0] = std::atan2(2*(q.w()*q.z() + q.x()*q.y()), (1 - 2*(y2 + q.z()*q.z())));
-    //m_angles[1] = std::asin( 2*(q.w()*q.y() - q.z()*q.x()));
-    //m_angles[2] = std::atan2(2*(q.w()*q.x() + q.y()*q.z()), (1 - 2*(q.x()*q.x() + y2)));
-  }*/
-
-  /** \returns The angle values stored in a vector (alpha, beta, gamma). */
-  const Vector3& angles() const { return m_angles; }
-  /** \returns A read-write reference to the angle values stored in a vector (alpha, beta, gamma). */
-  Vector3& angles() { return m_angles; }
-
-  /** \returns The value of the first angle. */
-  Scalar alpha() const { return m_angles[0]; }
-  /** \returns A read-write reference to the angle of the first angle. */
-  Scalar& alpha() { return m_angles[0]; }
-
-  /** \returns The value of the second angle. */
-  Scalar beta() const { return m_angles[1]; }
-  /** \returns A read-write reference to the angle of the second angle. */
-  Scalar& beta() { return m_angles[1]; }
-
-  /** \returns The value of the third angle. */
-  Scalar gamma() const { return m_angles[2]; }
-  /** \returns A read-write reference to the angle of the third angle. */
-  Scalar& gamma() { return m_angles[2]; }
-
-  /** \returns The Euler angles rotation inverse (which is as same as the negative),
-   *  (-alpha, -beta, -gamma).
-   */
-  EulerAngles inverse() const {
-    EulerAngles res;
-    res.m_angles = -m_angles;
-    return res;
-  }
-
-  /** \returns The Euler angles rotation negative (which is as same as the inverse),
-   *  (-alpha, -beta, -gamma).
-   */
-  EulerAngles operator-() const { return inverse(); }
-
-  /** Set \c *this from either:
-   *  - a 3x3 rotation matrix expression(i.e. pure orthogonal matrix with determinant of +1),
-   *  - a 3D vector expression representing Euler angles.
-   *
-   * See EulerAngles(const MatrixBase<Derived, 3>&) for more information about
-   *  angles ranges output.
-   */
-  template <class Derived>
-  EulerAngles& operator=(const MatrixBase<Derived>& other) {
-    EIGEN_STATIC_ASSERT(
-        (internal::is_same<Scalar, typename Derived::Scalar>::value),
-        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
-
-    internal::eulerangles_assign_impl<System, Derived>::run(*this, other.derived());
-    return *this;
-  }
-
-  // TODO: Assign and construct from another EulerAngles (with different system)
-
-  /** Set \c *this from a rotation.
-   *
-   * See EulerAngles(const RotationBase<Derived, 3>&) for more information about
-   *  angles ranges output.
-   */
-  template <typename Derived>
-  EulerAngles& operator=(const RotationBase<Derived, 3>& rot) {
-    System::CalcEulerAngles(*this, rot.toRotationMatrix());
-    return *this;
-  }
-
-  /** \returns \c true if \c *this is approximately equal to \a other, within the precision
-   * determined by \a prec.
-   *
-   * \sa MatrixBase::isApprox() */
-  bool isApprox(const EulerAngles& other, const RealScalar& prec = NumTraits<Scalar>::dummy_precision()) const {
-    return angles().isApprox(other.angles(), prec);
-  }
-
-  /** \returns an equivalent 3x3 rotation matrix. */
-  Matrix3 toRotationMatrix() const {
-    // TODO: Calc it faster
-    return static_cast<QuaternionType>(*this).toRotationMatrix();
-  }
-
-  /** Convert the Euler angles to quaternion. */
-  operator QuaternionType() const {
-    return AngleAxisType(alpha(), AlphaAxisVector()) * AngleAxisType(beta(), BetaAxisVector()) *
-           AngleAxisType(gamma(), GammaAxisVector());
-  }
-
-  friend std::ostream& operator<<(std::ostream& s, const EulerAngles<Scalar, System>& eulerAngles) {
-    s << eulerAngles.angles().transpose();
-    return s;
-  }
-
-  /** \returns \c *this with scalar type casted to \a NewScalarType */
-  template <typename NewScalarType>
-  EulerAngles<NewScalarType, System> cast() const {
-    EulerAngles<NewScalarType, System> e;
-    e.angles() = angles().template cast<NewScalarType>();
-    return e;
-  }
-};
-
-#define EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(AXES, SCALAR_TYPE, SCALAR_POSTFIX) \
-  /** \ingroup EulerAngles_Module */                                         \
-  typedef EulerAngles<SCALAR_TYPE, EulerSystem##AXES> EulerAngles##AXES##SCALAR_POSTFIX;
-
-#define EIGEN_EULER_ANGLES_TYPEDEFS(SCALAR_TYPE, SCALAR_POSTFIX)      \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XYZ, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XYX, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XZY, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(XZX, SCALAR_TYPE, SCALAR_POSTFIX) \
-                                                                      \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YZX, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YZY, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YXZ, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(YXY, SCALAR_TYPE, SCALAR_POSTFIX) \
-                                                                      \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZXY, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZXZ, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZYX, SCALAR_TYPE, SCALAR_POSTFIX) \
-  EIGEN_EULER_ANGLES_SINGLE_TYPEDEF(ZYZ, SCALAR_TYPE, SCALAR_POSTFIX)
-
-EIGEN_EULER_ANGLES_TYPEDEFS(float, f)
-EIGEN_EULER_ANGLES_TYPEDEFS(double, d)
-
-// Specifically-referenced instantiations.
-/** \typedef EulerAnglesXYZd
- * \ingroup EulerAngles_Module
- * Euler XYZ system with type double entries.
- */
-/** \typedef EulerAnglesZYZf
- * \ingroup EulerAngles_Module
- * Euler ZYZ system with type float entries.
- */
-
-namespace internal {
-template <typename Scalar_, class _System>
-struct traits<EulerAngles<Scalar_, _System> > {
-  typedef Scalar_ Scalar;
-};
-
-// set from a rotation matrix
-template <class System, class Other>
-struct eulerangles_assign_impl<System, Other, 3, 3> {
-  typedef typename Other::Scalar Scalar;
-  static void run(EulerAngles<Scalar, System>& e, const Other& m) { System::CalcEulerAngles(e, m); }
-};
-
-// set from a vector of Euler angles
-template <class System, class Other>
-struct eulerangles_assign_impl<System, Other, 3, 1> {
-  typedef typename Other::Scalar Scalar;
-  static void run(EulerAngles<Scalar, System>& e, const Other& vec) { e.angles() = vec; }
-};
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_EULERANGLESCLASS_H
diff --git a/unsupported/Eigen/src/EulerAngles/EulerSystem.h b/unsupported/Eigen/src/EulerAngles/EulerSystem.h
deleted file mode 100644
index c4b190b..0000000
--- a/unsupported/Eigen/src/EulerAngles/EulerSystem.h
+++ /dev/null
@@ -1,283 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_EULERSYSTEM_H
-#define EIGEN_EULERSYSTEM_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-// Forward declarations
-template <typename Scalar_, class _System>
-class EulerAngles;
-
-namespace internal {
-// TODO: Add this trait to the Eigen internal API?
-template <int Num, bool IsPositive = (Num > 0)>
-struct Abs {
-  enum { value = Num };
-};
-
-template <int Num>
-struct Abs<Num, false> {
-  enum { value = -Num };
-};
-
-template <int Axis>
-struct IsValidAxis {
-  enum { value = Axis != 0 && Abs<Axis>::value <= 3 };
-};
-
-template <typename System, typename Other, int OtherRows = Other::RowsAtCompileTime,
-          int OtherCols = Other::ColsAtCompileTime>
-struct eulerangles_assign_impl;
-}  // namespace internal
-
-#define EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(COND, MSG) typedef char static_assertion_##MSG[(COND) ? 1 : -1]
-
-/** \brief Representation of a fixed signed rotation axis for EulerSystem.
- *
- * \ingroup EulerAngles_Module
- *
- * Values here represent:
- *  - The axis of the rotation: X, Y or Z.
- *  - The sign (i.e. direction of the rotation along the axis): positive(+) or negative(-)
- *
- * Therefore, this could express all the axes {+X,+Y,+Z,-X,-Y,-Z}
- *
- * For positive axis, use +EULER_{axis}, and for negative axis use -EULER_{axis}.
- */
-enum EulerAxis {
-  EULER_X = 1, /*!< the X axis */
-  EULER_Y = 2, /*!< the Y axis */
-  EULER_Z = 3  /*!< the Z axis */
-};
-
-/** \class EulerSystem
- *
- * \ingroup EulerAngles_Module
- *
- * \brief Represents a fixed Euler rotation system.
- *
- * This meta-class goal is to represent the Euler system in compilation time, for EulerAngles.
- *
- * You can use this class to get two things:
- *  - Build an Euler system, and then pass it as a template parameter to EulerAngles.
- *  - Query some compile time data about an Euler system. (e.g. Whether it's Tait-Bryan)
- *
- * Euler rotation is a set of three rotation on fixed axes. (see \ref EulerAngles)
- * This meta-class store constantly those signed axes. (see \ref EulerAxis)
- *
- * ### Types of Euler systems ###
- *
- * All and only valid 3 dimension Euler rotation over standard
- *  signed axes{+X,+Y,+Z,-X,-Y,-Z} are supported:
- *  - all axes X, Y, Z in each valid order (see below what order is valid)
- *  - rotation over the axis is supported both over the positive and negative directions.
- *  - both Tait-Bryan and proper/classic Euler angles (i.e. the opposite).
- *
- * Since EulerSystem support both positive and negative directions,
- *  you may call this rotation distinction in other names:
- *  - _right handed_ or _left handed_
- *  - _counterclockwise_ or _clockwise_
- *
- * Notice all axed combination are valid, and would trigger a static assertion.
- * Same unsigned axes can't be neighbors, e.g. {X,X,Y} is invalid.
- * This yield two and only two classes:
- *  - _Tait-Bryan_ - all unsigned axes are distinct, e.g. {X,Y,Z}
- *  - _proper/classic Euler angles_ - The first and the third unsigned axes is equal,
- *     and the second is different, e.g. {X,Y,X}
- *
- * ### Intrinsic vs extrinsic Euler systems ###
- *
- * Only intrinsic Euler systems are supported for simplicity.
- *  If you want to use extrinsic Euler systems,
- *   just use the equal intrinsic opposite order for axes and angles.
- *  I.e axes (A,B,C) becomes (C,B,A), and angles (a,b,c) becomes (c,b,a).
- *
- * ### Convenient user typedefs ###
- *
- * Convenient typedefs for EulerSystem exist (only for positive axes Euler systems),
- *  in a form of EulerSystem{A}{B}{C}, e.g. \ref EulerSystemXYZ.
- *
- * ### Additional reading ###
- *
- * More information about Euler angles: https://en.wikipedia.org/wiki/Euler_angles
- *
- * \tparam _AlphaAxis the first fixed EulerAxis
- *
- * \tparam _BetaAxis the second fixed EulerAxis
- *
- * \tparam _GammaAxis the third fixed EulerAxis
- */
-template <int _AlphaAxis, int _BetaAxis, int _GammaAxis>
-class EulerSystem {
- public:
-  // Defined as static constexpr rather than enum to ensure support for negative values.
-
-  /** The first rotation axis */
-  static constexpr int AlphaAxis = _AlphaAxis;
-
-  /** The second rotation axis */
-  static constexpr int BetaAxis = _BetaAxis;
-
-  /** The third rotation axis */
-  static constexpr int GammaAxis = _GammaAxis;
-
-  enum {
-    AlphaAxisAbs = internal::Abs<AlphaAxis>::value, /*!< the first rotation axis unsigned */
-    BetaAxisAbs = internal::Abs<BetaAxis>::value,   /*!< the second rotation axis unsigned */
-    GammaAxisAbs = internal::Abs<GammaAxis>::value, /*!< the third rotation axis unsigned */
-
-    IsAlphaOpposite = (AlphaAxis < 0) ? 1 : 0, /*!< whether alpha axis is negative */
-    IsBetaOpposite = (BetaAxis < 0) ? 1 : 0,   /*!< whether beta axis is negative */
-    IsGammaOpposite = (GammaAxis < 0) ? 1 : 0, /*!< whether gamma axis is negative */
-
-    // Parity is even if alpha axis X is followed by beta axis Y, or Y is followed
-    // by Z, or Z is followed by X; otherwise it is odd.
-    IsOdd = ((AlphaAxisAbs) % 3 == (BetaAxisAbs - 1) % 3) ? 0 : 1, /*!< whether the Euler system is odd */
-    IsEven = IsOdd ? 0 : 1,                                        /*!< whether the Euler system is even */
-
-    IsTaitBryan =
-        ((unsigned)AlphaAxisAbs != (unsigned)GammaAxisAbs) ? 1 : 0 /*!< whether the Euler system is Tait-Bryan */
-  };
-
- private:
-  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(internal::IsValidAxis<AlphaAxis>::value, ALPHA_AXIS_IS_INVALID);
-
-  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(internal::IsValidAxis<BetaAxis>::value, BETA_AXIS_IS_INVALID);
-
-  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT(internal::IsValidAxis<GammaAxis>::value, GAMMA_AXIS_IS_INVALID);
-
-  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT((unsigned)AlphaAxisAbs != (unsigned)BetaAxisAbs,
-                                         ALPHA_AXIS_CANT_BE_EQUAL_TO_BETA_AXIS);
-
-  EIGEN_EULER_ANGLES_CLASS_STATIC_ASSERT((unsigned)BetaAxisAbs != (unsigned)GammaAxisAbs,
-                                         BETA_AXIS_CANT_BE_EQUAL_TO_GAMMA_AXIS);
-
-  static const int
-      // I, J, K are the pivot indexes permutation for the rotation matrix, that match this Euler system.
-      // They are used in this class converters.
-      // They are always different from each other, and their possible values are: 0, 1, or 2.
-      I_ = AlphaAxisAbs - 1,
-      J_ = (AlphaAxisAbs - 1 + 1 + IsOdd) % 3, K_ = (AlphaAxisAbs - 1 + 2 - IsOdd) % 3;
-
-  // TODO: Get @mat parameter in form that avoids double evaluation.
-  template <typename Derived>
-  static void CalcEulerAngles_imp(Matrix<typename MatrixBase<Derived>::Scalar, 3, 1>& res,
-                                  const MatrixBase<Derived>& mat, internal::true_type /*isTaitBryan*/) {
-    using std::atan2;
-    using std::sqrt;
-
-    typedef typename Derived::Scalar Scalar;
-
-    const Scalar plusMinus = IsEven ? 1 : -1;
-    const Scalar minusPlus = IsOdd ? 1 : -1;
-
-    const Scalar Rsum = sqrt((mat(I_, I_) * mat(I_, I_) + mat(I_, J_) * mat(I_, J_) + mat(J_, K_) * mat(J_, K_) +
-                              mat(K_, K_) * mat(K_, K_)) /
-                             2);
-    res[1] = atan2(plusMinus * mat(I_, K_), Rsum);
-
-    // There is a singularity when cos(beta) == 0
-    if (Rsum > 4 * NumTraits<Scalar>::epsilon()) {  // cos(beta) != 0
-      res[0] = atan2(minusPlus * mat(J_, K_), mat(K_, K_));
-      res[2] = atan2(minusPlus * mat(I_, J_), mat(I_, I_));
-    } else if (plusMinus * mat(I_, K_) > 0) {               // cos(beta) == 0 and sin(beta) == 1
-      Scalar spos = mat(J_, I_) + plusMinus * mat(K_, J_);  // 2*sin(alpha + plusMinus * gamma
-      Scalar cpos = mat(J_, J_) + minusPlus * mat(K_, I_);  // 2*cos(alpha + plusMinus * gamma)
-      Scalar alphaPlusMinusGamma = atan2(spos, cpos);
-      res[0] = alphaPlusMinusGamma;
-      res[2] = 0;
-    } else {                                                              // cos(beta) == 0 and sin(beta) == -1
-      Scalar sneg = plusMinus * (mat(K_, J_) + minusPlus * mat(J_, I_));  // 2*sin(alpha + minusPlus*gamma)
-      Scalar cneg = mat(J_, J_) + plusMinus * mat(K_, I_);                // 2*cos(alpha + minusPlus*gamma)
-      Scalar alphaMinusPlusBeta = atan2(sneg, cneg);
-      res[0] = alphaMinusPlusBeta;
-      res[2] = 0;
-    }
-  }
-
-  template <typename Derived>
-  static void CalcEulerAngles_imp(Matrix<typename MatrixBase<Derived>::Scalar, 3, 1>& res,
-                                  const MatrixBase<Derived>& mat, internal::false_type /*isTaitBryan*/) {
-    using std::atan2;
-    using std::sqrt;
-
-    typedef typename Derived::Scalar Scalar;
-
-    const Scalar plusMinus = IsEven ? 1 : -1;
-    const Scalar minusPlus = IsOdd ? 1 : -1;
-
-    const Scalar Rsum = sqrt((mat(I_, J_) * mat(I_, J_) + mat(I_, K_) * mat(I_, K_) + mat(J_, I_) * mat(J_, I_) +
-                              mat(K_, I_) * mat(K_, I_)) /
-                             2);
-
-    res[1] = atan2(Rsum, mat(I_, I_));
-
-    // There is a singularity when sin(beta) == 0
-    if (Rsum > 4 * NumTraits<Scalar>::epsilon()) {  // sin(beta) != 0
-      res[0] = atan2(mat(J_, I_), minusPlus * mat(K_, I_));
-      res[2] = atan2(mat(I_, J_), plusMinus * mat(I_, K_));
-    } else if (mat(I_, I_) > 0) {                                       // sin(beta) == 0 and cos(beta) == 1
-      Scalar spos = plusMinus * mat(K_, J_) + minusPlus * mat(J_, K_);  // 2*sin(alpha + gamma)
-      Scalar cpos = mat(J_, J_) + mat(K_, K_);                          // 2*cos(alpha + gamma)
-      res[0] = atan2(spos, cpos);
-      res[2] = 0;
-    } else {                                                            // sin(beta) == 0 and cos(beta) == -1
-      Scalar sneg = plusMinus * mat(K_, J_) + plusMinus * mat(J_, K_);  // 2*sin(alpha - gamma)
-      Scalar cneg = mat(J_, J_) - mat(K_, K_);                          // 2*cos(alpha - gamma)
-      res[0] = atan2(sneg, cneg);
-      res[2] = 0;
-    }
-  }
-
-  template <typename Scalar>
-  static void CalcEulerAngles(EulerAngles<Scalar, EulerSystem>& res,
-                              const typename EulerAngles<Scalar, EulerSystem>::Matrix3& mat) {
-    CalcEulerAngles_imp(res.angles(), mat,
-                        std::conditional_t<IsTaitBryan, internal::true_type, internal::false_type>());
-
-    if (IsAlphaOpposite) res.alpha() = -res.alpha();
-
-    if (IsBetaOpposite) res.beta() = -res.beta();
-
-    if (IsGammaOpposite) res.gamma() = -res.gamma();
-  }
-
-  template <typename Scalar_, class _System>
-  friend class Eigen::EulerAngles;
-
-  template <typename System, typename Other, int OtherRows, int OtherCols>
-  friend struct internal::eulerangles_assign_impl;
-};
-
-#define EIGEN_EULER_SYSTEM_TYPEDEF(A, B, C) typedef EulerSystem<EULER_##A, EULER_##B, EULER_##C> EulerSystem##A##B##C;
-
-/** Default XYZ Euler coordinate system.
- * \ingroup EulerAngles_Module
- */
-EIGEN_EULER_SYSTEM_TYPEDEF(X, Y, Z)
-EIGEN_EULER_SYSTEM_TYPEDEF(X, Y, X)
-EIGEN_EULER_SYSTEM_TYPEDEF(X, Z, Y)
-EIGEN_EULER_SYSTEM_TYPEDEF(X, Z, X)
-
-EIGEN_EULER_SYSTEM_TYPEDEF(Y, Z, X)
-EIGEN_EULER_SYSTEM_TYPEDEF(Y, Z, Y)
-EIGEN_EULER_SYSTEM_TYPEDEF(Y, X, Z)
-EIGEN_EULER_SYSTEM_TYPEDEF(Y, X, Y)
-
-EIGEN_EULER_SYSTEM_TYPEDEF(Z, X, Y)
-EIGEN_EULER_SYSTEM_TYPEDEF(Z, X, Z)
-EIGEN_EULER_SYSTEM_TYPEDEF(Z, Y, X)
-EIGEN_EULER_SYSTEM_TYPEDEF(Z, Y, Z)
-}  // namespace Eigen
-
-#endif  // EIGEN_EULERSYSTEM_H
diff --git a/unsupported/Eigen/src/EulerAngles/InternalHeaderCheck.h b/unsupported/Eigen/src/EulerAngles/InternalHeaderCheck.h
deleted file mode 100644
index 0c00a30..0000000
--- a/unsupported/Eigen/src/EulerAngles/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_EULERANGLES_MODULE_H
-#error "Please include unsupported/Eigen/EulerAngles instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/FFT/InternalHeaderCheck.h b/unsupported/Eigen/src/FFT/InternalHeaderCheck.h
deleted file mode 100644
index 801e245..0000000
--- a/unsupported/Eigen/src/FFT/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_FFT_MODULE_H
-#error "Please include unsupported/Eigen/FFT instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/FFT/duccfft_impl.h b/unsupported/Eigen/src/FFT/duccfft_impl.h
deleted file mode 100644
index 781716d..0000000
--- a/unsupported/Eigen/src/FFT/duccfft_impl.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename _Scalar>
-struct duccfft_impl {
-  using Scalar = _Scalar;
-  using Complex = std::complex<Scalar>;
-  using shape_t = ducc0::fmav_info::shape_t;
-  using stride_t = ducc0::fmav_info::stride_t;
-
-  inline void clear() {}
-
-  inline void fwd(Complex* dst, const Scalar* src, int nfft) {
-    const shape_t axes{0};
-    ducc0::cfmav<Scalar> m_in(src, shape_t{static_cast<size_t>(nfft)});
-    ducc0::vfmav<Complex> m_out(dst, shape_t{static_cast<size_t>(nfft) / 2 + 1});
-    ducc0::r2c(m_in, m_out, axes, /*forward=*/true, /*scale=*/static_cast<Scalar>(1));
-  }
-
-  inline void fwd(Complex* dst, const Complex* src, int nfft) {
-    const shape_t axes{0};
-    ducc0::cfmav<Complex> m_in(src, shape_t{static_cast<size_t>(nfft)});
-    ducc0::vfmav<Complex> m_out(dst, shape_t{static_cast<size_t>(nfft)});
-    ducc0::c2c(m_in, m_out, axes, /*forward=*/true, /*scale=*/static_cast<Scalar>(1));
-  }
-
-  inline void inv(Scalar* dst, const Complex* src, int nfft) {
-    const shape_t axes{0};
-    ducc0::cfmav<Complex> m_in(src, shape_t{static_cast<size_t>(nfft) / 2 + 1});
-    ducc0::vfmav<Scalar> m_out(dst, shape_t{static_cast<size_t>(nfft)});
-    ducc0::c2r(m_in, m_out, axes, /*forward=*/false, /*scale=*/static_cast<Scalar>(1));
-  }
-
-  inline void inv(Complex* dst, const Complex* src, int nfft) {
-    const shape_t axes{0};
-    ducc0::cfmav<Complex> m_in(src, shape_t{static_cast<size_t>(nfft)});
-    ducc0::vfmav<Complex> m_out(dst, shape_t{static_cast<size_t>(nfft)});
-    ducc0::c2c(m_in, m_out, axes, /*forward=*/false, /*scale=*/static_cast<Scalar>(1));
-  }
-
-  inline void fwd2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
-    const shape_t axes{0, 1};
-    const shape_t in_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
-    const shape_t out_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
-    const stride_t stride{static_cast<ptrdiff_t>(nfft1), static_cast<ptrdiff_t>(1)};
-    ducc0::cfmav<Complex> m_in(src, in_shape, stride);
-    ducc0::vfmav<Complex> m_out(dst, out_shape, stride);
-    ducc0::c2c(m_in, m_out, axes, /*forward=*/true, /*scale=*/static_cast<Scalar>(1));
-  }
-
-  inline void inv2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
-    const shape_t axes{0, 1};
-    const shape_t in_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
-    const shape_t out_shape{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
-    const stride_t stride{static_cast<ptrdiff_t>(nfft1), static_cast<ptrdiff_t>(1)};
-    ducc0::cfmav<Complex> m_in(src, in_shape, stride);
-    ducc0::vfmav<Complex> m_out(dst, out_shape, stride);
-    ducc0::c2c(m_in, m_out, axes, /*forward=*/false, /*scale=*/static_cast<Scalar>(1));
-  }
-};
-
-}  // namespace internal
-}  // namespace Eigen
diff --git a/unsupported/Eigen/src/FFT/fftw_impl.h b/unsupported/Eigen/src/FFT/fftw_impl.h
deleted file mode 100644
index 588d09e..0000000
--- a/unsupported/Eigen/src/FFT/fftw_impl.h
+++ /dev/null
@@ -1,216 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Mark Borgerding mark a borgerding net
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include <memory>
-
-namespace Eigen {
-
-namespace internal {
-
-// FFTW uses non-const arguments,
-// so const_cast is needed for all the args it uses.
-//
-// This should be safe as long as
-// 1. we use FFTW_ESTIMATE for all our planning
-//       see the FFTW docs section 4.3.2 "Planner Flags"
-// 2. fftw_complex is compatible with std::complex
-//    This assumes std::complex<T> layout is array of size 2 with real,imag
-template <typename T>
-inline T *fftw_cast(const T *p) {
-  return const_cast<T *>(p);
-}
-
-inline fftw_complex *fftw_cast(const std::complex<double> *p) {
-  return const_cast<fftw_complex *>(reinterpret_cast<const fftw_complex *>(p));
-}
-
-inline fftwf_complex *fftw_cast(const std::complex<float> *p) {
-  return const_cast<fftwf_complex *>(reinterpret_cast<const fftwf_complex *>(p));
-}
-
-inline fftwl_complex *fftw_cast(const std::complex<long double> *p) {
-  return const_cast<fftwl_complex *>(reinterpret_cast<const fftwl_complex *>(p));
-}
-
-template <typename T>
-struct fftw_plan {};
-
-template <>
-struct fftw_plan<float> {
-  typedef float scalar_type;
-  typedef fftwf_complex complex_type;
-  std::shared_ptr<fftwf_plan_s> m_plan;
-  fftw_plan() = default;
-
-  void set_plan(fftwf_plan p) { m_plan.reset(p, fftwf_destroy_plan); }
-  inline void fwd(complex_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwf_plan_dft_1d(nfft, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwf_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void inv(complex_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwf_plan_dft_1d(nfft, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwf_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void fwd(complex_type *dst, scalar_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwf_plan_dft_r2c_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwf_execute_dft_r2c(m_plan.get(), src, dst);
-  }
-  inline void inv(scalar_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwf_plan_dft_c2r_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwf_execute_dft_c2r(m_plan.get(), src, dst);
-  }
-
-  inline void fwd2(complex_type *dst, complex_type *src, int n0, int n1) {
-    if (m_plan == NULL)
-      set_plan(fftwf_plan_dft_2d(n0, n1, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwf_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void inv2(complex_type *dst, complex_type *src, int n0, int n1) {
-    if (m_plan == NULL)
-      set_plan(fftwf_plan_dft_2d(n0, n1, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwf_execute_dft(m_plan.get(), src, dst);
-  }
-};
-template <>
-struct fftw_plan<double> {
-  typedef double scalar_type;
-  typedef fftw_complex complex_type;
-  std::shared_ptr<fftw_plan_s> m_plan;
-  fftw_plan() = default;
-
-  void set_plan(::fftw_plan p) { m_plan.reset(p, fftw_destroy_plan); }
-  inline void fwd(complex_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftw_plan_dft_1d(nfft, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftw_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void inv(complex_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftw_plan_dft_1d(nfft, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftw_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void fwd(complex_type *dst, scalar_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftw_plan_dft_r2c_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftw_execute_dft_r2c(m_plan.get(), src, dst);
-  }
-  inline void inv(scalar_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftw_plan_dft_c2r_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftw_execute_dft_c2r(m_plan.get(), src, dst);
-  }
-  inline void fwd2(complex_type *dst, complex_type *src, int n0, int n1) {
-    if (m_plan == NULL) set_plan(fftw_plan_dft_2d(n0, n1, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftw_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void inv2(complex_type *dst, complex_type *src, int n0, int n1) {
-    if (m_plan == NULL)
-      set_plan(fftw_plan_dft_2d(n0, n1, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftw_execute_dft(m_plan.get(), src, dst);
-  }
-};
-template <>
-struct fftw_plan<long double> {
-  typedef long double scalar_type;
-  typedef fftwl_complex complex_type;
-  std::shared_ptr<fftwl_plan_s> m_plan;
-  fftw_plan() = default;
-
-  void set_plan(fftwl_plan p) { m_plan.reset(p, fftwl_destroy_plan); }
-  inline void fwd(complex_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwl_plan_dft_1d(nfft, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwl_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void inv(complex_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwl_plan_dft_1d(nfft, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwl_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void fwd(complex_type *dst, scalar_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwl_plan_dft_r2c_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwl_execute_dft_r2c(m_plan.get(), src, dst);
-  }
-  inline void inv(scalar_type *dst, complex_type *src, int nfft) {
-    if (m_plan == NULL) set_plan(fftwl_plan_dft_c2r_1d(nfft, src, dst, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwl_execute_dft_c2r(m_plan.get(), src, dst);
-  }
-  inline void fwd2(complex_type *dst, complex_type *src, int n0, int n1) {
-    if (m_plan == NULL)
-      set_plan(fftwl_plan_dft_2d(n0, n1, src, dst, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwl_execute_dft(m_plan.get(), src, dst);
-  }
-  inline void inv2(complex_type *dst, complex_type *src, int n0, int n1) {
-    if (m_plan == NULL)
-      set_plan(fftwl_plan_dft_2d(n0, n1, src, dst, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT));
-    fftwl_execute_dft(m_plan.get(), src, dst);
-  }
-};
-
-template <typename Scalar_>
-struct fftw_impl {
-  typedef Scalar_ Scalar;
-  typedef std::complex<Scalar> Complex;
-
-  inline void clear() { m_plans.clear(); }
-
-  // complex-to-complex forward FFT
-  inline void fwd(Complex *dst, const Complex *src, int nfft) {
-    get_plan(nfft, false, dst, src).fwd(fftw_cast(dst), fftw_cast(src), nfft);
-  }
-
-  // real-to-complex forward FFT
-  inline void fwd(Complex *dst, const Scalar *src, int nfft) {
-    get_plan(nfft, false, dst, src).fwd(fftw_cast(dst), fftw_cast(src), nfft);
-  }
-
-  // 2-d complex-to-complex
-  inline void fwd2(Complex *dst, const Complex *src, int n0, int n1) {
-    get_plan(n0, n1, false, dst, src).fwd2(fftw_cast(dst), fftw_cast(src), n0, n1);
-  }
-
-  // inverse complex-to-complex
-  inline void inv(Complex *dst, const Complex *src, int nfft) {
-    get_plan(nfft, true, dst, src).inv(fftw_cast(dst), fftw_cast(src), nfft);
-  }
-
-  // half-complex to scalar
-  inline void inv(Scalar *dst, const Complex *src, int nfft) {
-    get_plan(nfft, true, dst, src).inv(fftw_cast(dst), fftw_cast(src), nfft);
-  }
-
-  // 2-d complex-to-complex
-  inline void inv2(Complex *dst, const Complex *src, int n0, int n1) {
-    get_plan(n0, n1, true, dst, src).inv2(fftw_cast(dst), fftw_cast(src), n0, n1);
-  }
-
- protected:
-  typedef fftw_plan<Scalar> PlanData;
-
-  typedef Eigen::numext::int64_t int64_t;
-
-  typedef std::map<int64_t, PlanData> PlanMap;
-
-  PlanMap m_plans;
-
-  inline PlanData &get_plan(int nfft, bool inverse, void *dst, const void *src) {
-    bool inplace = (dst == src);
-    bool aligned = ((reinterpret_cast<size_t>(src) & 15) | (reinterpret_cast<size_t>(dst) & 15)) == 0;
-    int64_t key = ((nfft << 3) | (inverse << 2) | (inplace << 1) | aligned) << 1;
-    return m_plans[key];
-  }
-
-  inline PlanData &get_plan(int n0, int n1, bool inverse, void *dst, const void *src) {
-    bool inplace = (dst == src);
-    bool aligned = ((reinterpret_cast<size_t>(src) & 15) | (reinterpret_cast<size_t>(dst) & 15)) == 0;
-    int64_t key = (((((int64_t)n0) << 30) | (n1 << 3) | (inverse << 2) | (inplace << 1) | aligned) << 1) + 1;
-    return m_plans[key];
-  }
-};
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/FFT/imklfft_impl.h b/unsupported/Eigen/src/FFT/imklfft_impl.h
deleted file mode 100644
index 0c5bb26..0000000
--- a/unsupported/Eigen/src/FFT/imklfft_impl.h
+++ /dev/null
@@ -1,248 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <mkl_dfti.h>
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include <complex>
-#include <memory>
-
-namespace Eigen {
-namespace internal {
-namespace imklfft {
-
-#define RUN_OR_ASSERT(EXPR, ERROR_MSG)                    \
-  {                                                       \
-    MKL_LONG status = (EXPR);                             \
-    eigen_assert(status == DFTI_NO_ERROR && (ERROR_MSG)); \
-  };
-
-inline MKL_Complex16* complex_cast(const std::complex<double>* p) {
-  return const_cast<MKL_Complex16*>(reinterpret_cast<const MKL_Complex16*>(p));
-}
-
-inline MKL_Complex8* complex_cast(const std::complex<float>* p) {
-  return const_cast<MKL_Complex8*>(reinterpret_cast<const MKL_Complex8*>(p));
-}
-
-/*
- * Parameters:
- * precision: enum, Precision of the transform: DFTI_SINGLE or DFTI_DOUBLE.
- * forward_domain: enum, Forward domain of the transform: DFTI_COMPLEX or
- * DFTI_REAL. dimension: MKL_LONG Dimension of the transform. sizes: MKL_LONG if
- * dimension = 1.Length of the transform for a one-dimensional transform. sizes:
- * Array of type MKL_LONG otherwise. Lengths of each dimension for a
- * multi-dimensional transform.
- */
-inline void configure_descriptor(std::shared_ptr<DFTI_DESCRIPTOR>& handl, enum DFTI_CONFIG_VALUE precision,
-                                 enum DFTI_CONFIG_VALUE forward_domain, MKL_LONG dimension, MKL_LONG* sizes) {
-  eigen_assert(dimension == 1 || dimension == 2 && "Transformation dimension must be less than 3.");
-
-  DFTI_DESCRIPTOR_HANDLE res = nullptr;
-  if (dimension == 1) {
-    RUN_OR_ASSERT(DftiCreateDescriptor(&res, precision, forward_domain, dimension, *sizes),
-                  "DftiCreateDescriptor failed.")
-    handl.reset(res, [](DFTI_DESCRIPTOR_HANDLE handle) { DftiFreeDescriptor(&handle); });
-    if (forward_domain == DFTI_REAL) {
-      // Set CCE storage
-      RUN_OR_ASSERT(DftiSetValue(handl.get(), DFTI_CONJUGATE_EVEN_STORAGE, DFTI_COMPLEX_COMPLEX),
-                    "DftiSetValue failed.")
-    }
-  } else {
-    RUN_OR_ASSERT(DftiCreateDescriptor(&res, precision, DFTI_COMPLEX, dimension, sizes), "DftiCreateDescriptor failed.")
-    handl.reset(res, [](DFTI_DESCRIPTOR_HANDLE handle) { DftiFreeDescriptor(&handle); });
-  }
-
-  RUN_OR_ASSERT(DftiSetValue(handl.get(), DFTI_PLACEMENT, DFTI_NOT_INPLACE), "DftiSetValue failed.")
-  RUN_OR_ASSERT(DftiCommitDescriptor(handl.get()), "DftiCommitDescriptor failed.")
-}
-
-template <typename T>
-struct plan {};
-
-template <>
-struct plan<float> {
-  typedef float scalar_type;
-  typedef MKL_Complex8 complex_type;
-
-  std::shared_ptr<DFTI_DESCRIPTOR> m_plan;
-
-  plan() = default;
-
-  enum DFTI_CONFIG_VALUE precision = DFTI_SINGLE;
-
-  inline void forward(complex_type* dst, complex_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
-  }
-
-  inline void inverse(complex_type* dst, complex_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
-  }
-
-  inline void forward(complex_type* dst, scalar_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
-  }
-
-  inline void inverse(scalar_type* dst, complex_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
-  }
-
-  inline void forward2(complex_type* dst, complex_type* src, int n0, int n1) {
-    if (m_plan == 0) {
-      MKL_LONG sizes[2] = {n0, n1};
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
-    }
-    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
-  }
-
-  inline void inverse2(complex_type* dst, complex_type* src, int n0, int n1) {
-    if (m_plan == 0) {
-      MKL_LONG sizes[2] = {n0, n1};
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
-    }
-    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
-  }
-};
-
-template <>
-struct plan<double> {
-  typedef double scalar_type;
-  typedef MKL_Complex16 complex_type;
-
-  std::shared_ptr<DFTI_DESCRIPTOR> m_plan;
-
-  plan() = default;
-
-  enum DFTI_CONFIG_VALUE precision = DFTI_DOUBLE;
-
-  inline void forward(complex_type* dst, complex_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
-  }
-
-  inline void inverse(complex_type* dst, complex_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
-  }
-
-  inline void forward(complex_type* dst, scalar_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
-  }
-
-  inline void inverse(scalar_type* dst, complex_type* src, MKL_LONG nfft) {
-    if (m_plan == 0) {
-      configure_descriptor(m_plan, precision, DFTI_REAL, 1, &nfft);
-    }
-    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
-  }
-
-  inline void forward2(complex_type* dst, complex_type* src, int n0, int n1) {
-    if (m_plan == 0) {
-      MKL_LONG sizes[2] = {n0, n1};
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
-    }
-    RUN_OR_ASSERT(DftiComputeForward(m_plan.get(), src, dst), "DftiComputeForward failed.")
-  }
-
-  inline void inverse2(complex_type* dst, complex_type* src, int n0, int n1) {
-    if (m_plan == 0) {
-      MKL_LONG sizes[2] = {n0, n1};
-      configure_descriptor(m_plan, precision, DFTI_COMPLEX, 2, sizes);
-    }
-    RUN_OR_ASSERT(DftiComputeBackward(m_plan.get(), src, dst), "DftiComputeBackward failed.")
-  }
-};
-
-template <typename Scalar_>
-struct imklfft_impl {
-  typedef Scalar_ Scalar;
-  typedef std::complex<Scalar> Complex;
-
-  inline void clear() { m_plans.clear(); }
-
-  // complex-to-complex forward FFT
-  inline void fwd(Complex* dst, const Complex* src, int nfft) {
-    MKL_LONG size = nfft;
-    get_plan(nfft, dst, src).forward(complex_cast(dst), complex_cast(src), size);
-  }
-
-  // real-to-complex forward FFT
-  inline void fwd(Complex* dst, const Scalar* src, int nfft) {
-    MKL_LONG size = nfft;
-    get_plan(nfft, dst, src).forward(complex_cast(dst), const_cast<Scalar*>(src), nfft);
-  }
-
-  // 2-d complex-to-complex
-  inline void fwd2(Complex* dst, const Complex* src, int n0, int n1) {
-    get_plan(n0, n1, dst, src).forward2(complex_cast(dst), complex_cast(src), n0, n1);
-  }
-
-  // inverse complex-to-complex
-  inline void inv(Complex* dst, const Complex* src, int nfft) {
-    MKL_LONG size = nfft;
-    get_plan(nfft, dst, src).inverse(complex_cast(dst), complex_cast(src), nfft);
-  }
-
-  // half-complex to scalar
-  inline void inv(Scalar* dst, const Complex* src, int nfft) {
-    MKL_LONG size = nfft;
-    get_plan(nfft, dst, src).inverse(const_cast<Scalar*>(dst), complex_cast(src), nfft);
-  }
-
-  // 2-d complex-to-complex
-  inline void inv2(Complex* dst, const Complex* src, int n0, int n1) {
-    get_plan(n0, n1, dst, src).inverse2(complex_cast(dst), complex_cast(src), n0, n1);
-  }
-
- private:
-  std::map<int64_t, plan<Scalar>> m_plans;
-
-  inline plan<Scalar>& get_plan(int nfft, void* dst, const void* src) {
-    int inplace = dst == src ? 1 : 0;
-    int aligned = ((reinterpret_cast<size_t>(src) & 15) | (reinterpret_cast<size_t>(dst) & 15)) == 0 ? 1 : 0;
-    int64_t key = ((nfft << 2) | (inplace << 1) | aligned) << 1;
-
-    // Create element if key does not exist.
-    return m_plans[key];
-  }
-
-  inline plan<Scalar>& get_plan(int n0, int n1, void* dst, const void* src) {
-    int inplace = (dst == src) ? 1 : 0;
-    int aligned = ((reinterpret_cast<size_t>(src) & 15) | (reinterpret_cast<size_t>(dst) & 15)) == 0 ? 1 : 0;
-    int64_t key = (((((int64_t)n0) << 31) | (n1 << 2) | (inplace << 1) | aligned) << 1) + 1;
-
-    // Create element if key does not exist.
-    return m_plans[key];
-  }
-};
-
-#undef RUN_OR_ASSERT
-
-}  // namespace imklfft
-}  // namespace internal
-}  // namespace Eigen
diff --git a/unsupported/Eigen/src/FFT/kissfft_impl.h b/unsupported/Eigen/src/FFT/kissfft_impl.h
deleted file mode 100644
index c7e5960..0000000
--- a/unsupported/Eigen/src/FFT/kissfft_impl.h
+++ /dev/null
@@ -1,416 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Mark Borgerding mark a borgerding net
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// This FFT implementation was derived from kissfft http:sourceforge.net/projects/kissfft
-// Copyright 2003-2009 Mark Borgerding
-
-template <typename Scalar_>
-struct kiss_cpx_fft {
-  typedef Scalar_ Scalar;
-  typedef std::complex<Scalar> Complex;
-  std::vector<Complex> m_twiddles;
-  std::vector<int> m_stageRadix;
-  std::vector<int> m_stageRemainder;
-  std::vector<Complex> m_scratchBuf;
-  bool m_inverse;
-
-  static const Scalar m_pi4;  // constant pi / 4
-
-  inline void make_twiddles(int nfft, bool inverse) {
-    using numext::cos;
-    using numext::sin;
-    m_inverse = inverse;
-    m_twiddles.resize(nfft);
-    Scalar phinc = m_pi4 / nfft;
-    Scalar flip = inverse ? Scalar(1) : Scalar(-1);
-    m_twiddles[0] = Complex(Scalar(1), Scalar(0));
-    if ((nfft & 1) == 0) m_twiddles[nfft / 2] = Complex(Scalar(-1), Scalar(0));
-    int i = 1;
-    for (; i * 8 < nfft; ++i) {
-      Scalar c = Scalar(cos(i * 8 * phinc));
-      Scalar s = Scalar(sin(i * 8 * phinc));
-      m_twiddles[i] = Complex(c, s * flip);
-      m_twiddles[nfft - i] = Complex(c, -s * flip);
-    }
-    for (; i * 4 < nfft; ++i) {
-      Scalar c = Scalar(cos((2 * nfft - 8 * i) * phinc));
-      Scalar s = Scalar(sin((2 * nfft - 8 * i) * phinc));
-      m_twiddles[i] = Complex(s, c * flip);
-      m_twiddles[nfft - i] = Complex(s, -c * flip);
-    }
-    for (; i * 8 < 3 * nfft; ++i) {
-      Scalar c = Scalar(cos((8 * i - 2 * nfft) * phinc));
-      Scalar s = Scalar(sin((8 * i - 2 * nfft) * phinc));
-      m_twiddles[i] = Complex(-s, c * flip);
-      m_twiddles[nfft - i] = Complex(-s, -c * flip);
-    }
-    for (; i * 2 < nfft; ++i) {
-      Scalar c = Scalar(cos((4 * nfft - 8 * i) * phinc));
-      Scalar s = Scalar(sin((4 * nfft - 8 * i) * phinc));
-      m_twiddles[i] = Complex(-c, s * flip);
-      m_twiddles[nfft - i] = Complex(-c, -s * flip);
-    }
-  }
-
-  void factorize(int nfft) {
-    // start factoring out 4's, then 2's, then 3,5,7,9,...
-    int n = nfft;
-    int p = 4;
-    do {
-      while (n % p) {
-        switch (p) {
-          case 4:
-            p = 2;
-            break;
-          case 2:
-            p = 3;
-            break;
-          default:
-            p += 2;
-            break;
-        }
-        if (p * p > n) p = n;  // impossible to have a factor > sqrt(n)
-      }
-      n /= p;
-      m_stageRadix.push_back(p);
-      m_stageRemainder.push_back(n);
-      if (p > 5) m_scratchBuf.resize(p);  // scratchbuf will be needed in bfly_generic
-    } while (n > 1);
-  }
-
-  template <typename Src_>
-  inline void work(int stage, Complex *xout, const Src_ *xin, size_t fstride, size_t in_stride) {
-    int p = m_stageRadix[stage];
-    int m = m_stageRemainder[stage];
-    Complex *Fout_beg = xout;
-    Complex *Fout_end = xout + p * m;
-
-    if (m > 1) {
-      do {
-        // recursive call:
-        // DFT of size m*p performed by doing
-        // p instances of smaller DFTs of size m,
-        // each one takes a decimated version of the input
-        work(stage + 1, xout, xin, fstride * p, in_stride);
-        xin += fstride * in_stride;
-      } while ((xout += m) != Fout_end);
-    } else {
-      do {
-        *xout = *xin;
-        xin += fstride * in_stride;
-      } while (++xout != Fout_end);
-    }
-    xout = Fout_beg;
-
-    // recombine the p smaller DFTs
-    switch (p) {
-      case 2:
-        bfly2(xout, fstride, m);
-        break;
-      case 3:
-        bfly3(xout, fstride, m);
-        break;
-      case 4:
-        bfly4(xout, fstride, m);
-        break;
-      case 5:
-        bfly5(xout, fstride, m);
-        break;
-      default:
-        bfly_generic(xout, fstride, m, p);
-        break;
-    }
-  }
-
-  inline void bfly2(Complex *Fout, const size_t fstride, int m) {
-    for (int k = 0; k < m; ++k) {
-      Complex t = Fout[m + k] * m_twiddles[k * fstride];
-      Fout[m + k] = Fout[k] - t;
-      Fout[k] += t;
-    }
-  }
-
-  inline void bfly4(Complex *Fout, const size_t fstride, const size_t m) {
-    Complex scratch[6];
-    int negative_if_inverse = m_inverse * -2 + 1;
-    for (size_t k = 0; k < m; ++k) {
-      scratch[0] = Fout[k + m] * m_twiddles[k * fstride];
-      scratch[1] = Fout[k + 2 * m] * m_twiddles[k * fstride * 2];
-      scratch[2] = Fout[k + 3 * m] * m_twiddles[k * fstride * 3];
-      scratch[5] = Fout[k] - scratch[1];
-
-      Fout[k] += scratch[1];
-      scratch[3] = scratch[0] + scratch[2];
-      scratch[4] = scratch[0] - scratch[2];
-      scratch[4] = Complex(scratch[4].imag() * negative_if_inverse, -scratch[4].real() * negative_if_inverse);
-
-      Fout[k + 2 * m] = Fout[k] - scratch[3];
-      Fout[k] += scratch[3];
-      Fout[k + m] = scratch[5] + scratch[4];
-      Fout[k + 3 * m] = scratch[5] - scratch[4];
-    }
-  }
-
-  inline void bfly3(Complex *Fout, const size_t fstride, const size_t m) {
-    size_t k = m;
-    const size_t m2 = 2 * m;
-    Complex *tw1, *tw2;
-    Complex scratch[5];
-    Complex epi3;
-    epi3 = m_twiddles[fstride * m];
-
-    tw1 = tw2 = &m_twiddles[0];
-
-    do {
-      scratch[1] = Fout[m] * *tw1;
-      scratch[2] = Fout[m2] * *tw2;
-
-      scratch[3] = scratch[1] + scratch[2];
-      scratch[0] = scratch[1] - scratch[2];
-      tw1 += fstride;
-      tw2 += fstride * 2;
-      Fout[m] = Complex(Fout->real() - Scalar(.5) * scratch[3].real(), Fout->imag() - Scalar(.5) * scratch[3].imag());
-      scratch[0] *= epi3.imag();
-      *Fout += scratch[3];
-      Fout[m2] = Complex(Fout[m].real() + scratch[0].imag(), Fout[m].imag() - scratch[0].real());
-      Fout[m] += Complex(-scratch[0].imag(), scratch[0].real());
-      ++Fout;
-    } while (--k);
-  }
-
-  inline void bfly5(Complex *Fout, const size_t fstride, const size_t m) {
-    Complex *Fout0, *Fout1, *Fout2, *Fout3, *Fout4;
-    size_t u;
-    Complex scratch[13];
-    Complex *twiddles = &m_twiddles[0];
-    Complex *tw;
-    Complex ya, yb;
-    ya = twiddles[fstride * m];
-    yb = twiddles[fstride * 2 * m];
-
-    Fout0 = Fout;
-    Fout1 = Fout0 + m;
-    Fout2 = Fout0 + 2 * m;
-    Fout3 = Fout0 + 3 * m;
-    Fout4 = Fout0 + 4 * m;
-
-    tw = twiddles;
-    for (u = 0; u < m; ++u) {
-      scratch[0] = *Fout0;
-
-      scratch[1] = *Fout1 * tw[u * fstride];
-      scratch[2] = *Fout2 * tw[2 * u * fstride];
-      scratch[3] = *Fout3 * tw[3 * u * fstride];
-      scratch[4] = *Fout4 * tw[4 * u * fstride];
-
-      scratch[7] = scratch[1] + scratch[4];
-      scratch[10] = scratch[1] - scratch[4];
-      scratch[8] = scratch[2] + scratch[3];
-      scratch[9] = scratch[2] - scratch[3];
-
-      *Fout0 += scratch[7];
-      *Fout0 += scratch[8];
-
-      scratch[5] = scratch[0] + Complex((scratch[7].real() * ya.real()) + (scratch[8].real() * yb.real()),
-                                        (scratch[7].imag() * ya.real()) + (scratch[8].imag() * yb.real()));
-
-      scratch[6] = Complex((scratch[10].imag() * ya.imag()) + (scratch[9].imag() * yb.imag()),
-                           -(scratch[10].real() * ya.imag()) - (scratch[9].real() * yb.imag()));
-
-      *Fout1 = scratch[5] - scratch[6];
-      *Fout4 = scratch[5] + scratch[6];
-
-      scratch[11] = scratch[0] + Complex((scratch[7].real() * yb.real()) + (scratch[8].real() * ya.real()),
-                                         (scratch[7].imag() * yb.real()) + (scratch[8].imag() * ya.real()));
-
-      scratch[12] = Complex(-(scratch[10].imag() * yb.imag()) + (scratch[9].imag() * ya.imag()),
-                            (scratch[10].real() * yb.imag()) - (scratch[9].real() * ya.imag()));
-
-      *Fout2 = scratch[11] + scratch[12];
-      *Fout3 = scratch[11] - scratch[12];
-
-      ++Fout0;
-      ++Fout1;
-      ++Fout2;
-      ++Fout3;
-      ++Fout4;
-    }
-  }
-
-  /* perform the butterfly for one stage of a mixed radix FFT */
-  inline void bfly_generic(Complex *Fout, const size_t fstride, int m, int p) {
-    int u, k, q1, q;
-    Complex *twiddles = &m_twiddles[0];
-    Complex t;
-    int Norig = static_cast<int>(m_twiddles.size());
-    Complex *scratchbuf = &m_scratchBuf[0];
-
-    for (u = 0; u < m; ++u) {
-      k = u;
-      for (q1 = 0; q1 < p; ++q1) {
-        scratchbuf[q1] = Fout[k];
-        k += m;
-      }
-
-      k = u;
-      for (q1 = 0; q1 < p; ++q1) {
-        int twidx = 0;
-        Fout[k] = scratchbuf[0];
-        for (q = 1; q < p; ++q) {
-          twidx += static_cast<int>(fstride) * k;
-          if (twidx >= Norig) twidx -= Norig;
-          t = scratchbuf[q] * twiddles[twidx];
-          Fout[k] += t;
-        }
-        k += m;
-      }
-    }
-  }
-};
-
-template <typename _Scalar>
-const typename kiss_cpx_fft<_Scalar>::Scalar kiss_cpx_fft<_Scalar>::m_pi4 =
-    numext::atan(kiss_cpx_fft<_Scalar>::Scalar(1));
-
-template <typename Scalar_>
-struct kissfft_impl {
-  typedef Scalar_ Scalar;
-  typedef std::complex<Scalar> Complex;
-
-  void clear() {
-    m_plans.clear();
-    m_realTwiddles.clear();
-  }
-
-  inline void fwd(Complex *dst, const Complex *src, int nfft) { get_plan(nfft, false).work(0, dst, src, 1, 1); }
-
-  inline void fwd2(Complex *dst, const Complex *src, int n0, int n1) {
-    EIGEN_UNUSED_VARIABLE(dst);
-    EIGEN_UNUSED_VARIABLE(src);
-    EIGEN_UNUSED_VARIABLE(n0);
-    EIGEN_UNUSED_VARIABLE(n1);
-  }
-
-  inline void inv2(Complex *dst, const Complex *src, int n0, int n1) {
-    EIGEN_UNUSED_VARIABLE(dst);
-    EIGEN_UNUSED_VARIABLE(src);
-    EIGEN_UNUSED_VARIABLE(n0);
-    EIGEN_UNUSED_VARIABLE(n1);
-  }
-
-  // real-to-complex forward FFT
-  // perform two FFTs of src even and src odd
-  // then twiddle to recombine them into the half-spectrum format
-  // then fill in the conjugate symmetric half
-  inline void fwd(Complex *dst, const Scalar *src, int nfft) {
-    if (nfft & 3) {
-      // use generic mode for odd
-      m_tmpBuf1.resize(nfft);
-      get_plan(nfft, false).work(0, &m_tmpBuf1[0], src, 1, 1);
-      std::copy(m_tmpBuf1.begin(), m_tmpBuf1.begin() + (nfft >> 1) + 1, dst);
-    } else {
-      int ncfft = nfft >> 1;
-      int ncfft2 = nfft >> 2;
-      Complex *rtw = real_twiddles(ncfft2);
-
-      // use optimized mode for even real
-      fwd(dst, reinterpret_cast<const Complex *>(src), ncfft);
-      Complex dc(dst[0].real() + dst[0].imag());
-      Complex nyquist(dst[0].real() - dst[0].imag());
-      int k;
-      for (k = 1; k <= ncfft2; ++k) {
-        Complex fpk = dst[k];
-        Complex fpnk = conj(dst[ncfft - k]);
-        Complex f1k = fpk + fpnk;
-        Complex f2k = fpk - fpnk;
-        Complex tw = f2k * rtw[k - 1];
-        dst[k] = (f1k + tw) * Scalar(.5);
-        dst[ncfft - k] = conj(f1k - tw) * Scalar(.5);
-      }
-      dst[0] = dc;
-      dst[ncfft] = nyquist;
-    }
-  }
-
-  // inverse complex-to-complex
-  inline void inv(Complex *dst, const Complex *src, int nfft) { get_plan(nfft, true).work(0, dst, src, 1, 1); }
-
-  // half-complex to scalar
-  inline void inv(Scalar *dst, const Complex *src, int nfft) {
-    if (nfft & 3) {
-      m_tmpBuf1.resize(nfft);
-      m_tmpBuf2.resize(nfft);
-      std::copy(src, src + (nfft >> 1) + 1, m_tmpBuf1.begin());
-      for (int k = 1; k < (nfft >> 1) + 1; ++k) m_tmpBuf1[nfft - k] = conj(m_tmpBuf1[k]);
-      inv(&m_tmpBuf2[0], &m_tmpBuf1[0], nfft);
-      for (int k = 0; k < nfft; ++k) dst[k] = m_tmpBuf2[k].real();
-    } else {
-      // optimized version for multiple of 4
-      int ncfft = nfft >> 1;
-      int ncfft2 = nfft >> 2;
-      Complex *rtw = real_twiddles(ncfft2);
-      m_tmpBuf1.resize(ncfft);
-      m_tmpBuf1[0] = Complex(src[0].real() + src[ncfft].real(), src[0].real() - src[ncfft].real());
-      for (int k = 1; k <= ncfft / 2; ++k) {
-        Complex fk = src[k];
-        Complex fnkc = conj(src[ncfft - k]);
-        Complex fek = fk + fnkc;
-        Complex tmp = fk - fnkc;
-        Complex fok = tmp * conj(rtw[k - 1]);
-        m_tmpBuf1[k] = fek + fok;
-        m_tmpBuf1[ncfft - k] = conj(fek - fok);
-      }
-      get_plan(ncfft, true).work(0, reinterpret_cast<Complex *>(dst), &m_tmpBuf1[0], 1, 1);
-    }
-  }
-
- protected:
-  typedef kiss_cpx_fft<Scalar> PlanData;
-  typedef std::map<int, PlanData> PlanMap;
-
-  PlanMap m_plans;
-  std::map<int, std::vector<Complex> > m_realTwiddles;
-  std::vector<Complex> m_tmpBuf1;
-  std::vector<Complex> m_tmpBuf2;
-
-  inline int PlanKey(int nfft, bool isinverse) const { return (nfft << 1) | int(isinverse); }
-
-  inline PlanData &get_plan(int nfft, bool inverse) {
-    // TODO: look for PlanKey(nfft, ! inverse) and conjugate the twiddles
-    PlanData &pd = m_plans[PlanKey(nfft, inverse)];
-    if (pd.m_twiddles.size() == 0) {
-      pd.make_twiddles(nfft, inverse);
-      pd.factorize(nfft);
-    }
-    return pd;
-  }
-
-  inline Complex *real_twiddles(int ncfft2) {
-    using std::acos;
-    std::vector<Complex> &twidref = m_realTwiddles[ncfft2];  // creates new if not there
-    if ((int)twidref.size() != ncfft2) {
-      twidref.resize(ncfft2);
-      int ncfft = ncfft2 << 1;
-      Scalar pi = acos(Scalar(-1));
-      for (int k = 1; k <= ncfft2; ++k) twidref[k - 1] = exp(Complex(0, -pi * (Scalar(k) / ncfft + Scalar(.5))));
-    }
-    return &twidref[0];
-  }
-};
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/FFT/pocketfft_impl.h b/unsupported/Eigen/src/FFT/pocketfft_impl.h
deleted file mode 100644
index fce105b..0000000
--- a/unsupported/Eigen/src/FFT/pocketfft_impl.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename _Scalar>
-struct pocketfft_impl {
-  using Scalar = _Scalar;
-  using Complex = std::complex<Scalar>;
-  using shape_t = pocketfft::shape_t;
-  using stride_t = pocketfft::stride_t;
-
-  inline void clear() {}
-
-  inline void fwd(Complex* dst, const Scalar* src, int nfft) {
-    const shape_t shape_{static_cast<size_t>(nfft)};
-    const shape_t axes_{0};
-    const stride_t stride_in{sizeof(Scalar)};
-    const stride_t stride_out{sizeof(Complex)};
-    pocketfft::r2c(shape_, stride_in, stride_out, axes_, pocketfft::FORWARD, src, dst, static_cast<Scalar>(1));
-  }
-
-  inline void fwd(Complex* dst, const Complex* src, int nfft) {
-    const shape_t shape_{static_cast<size_t>(nfft)};
-    const shape_t axes_{0};
-    const stride_t stride_{sizeof(Complex)};
-    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::FORWARD, src, dst, static_cast<Scalar>(1));
-  }
-
-  inline void inv(Scalar* dst, const Complex* src, int nfft) {
-    const shape_t shape_{static_cast<size_t>(nfft)};
-    const shape_t axes_{0};
-    const stride_t stride_in{sizeof(Complex)};
-    const stride_t stride_out{sizeof(Scalar)};
-    pocketfft::c2r(shape_, stride_in, stride_out, axes_, pocketfft::BACKWARD, src, dst, static_cast<Scalar>(1));
-  }
-
-  inline void inv(Complex* dst, const Complex* src, int nfft) {
-    const shape_t shape_{static_cast<size_t>(nfft)};
-    const shape_t axes_{0};
-    const stride_t stride_{sizeof(Complex)};
-    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::BACKWARD, src, dst, static_cast<Scalar>(1));
-  }
-
-  inline void fwd2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
-    const shape_t shape_{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
-    const shape_t axes_{0, 1};
-    const stride_t stride_{static_cast<ptrdiff_t>(sizeof(Complex) * nfft1), static_cast<ptrdiff_t>(sizeof(Complex))};
-    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::FORWARD, src, dst, static_cast<Scalar>(1));
-  }
-
-  inline void inv2(Complex* dst, const Complex* src, int nfft0, int nfft1) {
-    const shape_t shape_{static_cast<size_t>(nfft0), static_cast<size_t>(nfft1)};
-    const shape_t axes_{0, 1};
-    const stride_t stride_{static_cast<ptrdiff_t>(sizeof(Complex) * nfft1), static_cast<ptrdiff_t>(sizeof(Complex))};
-    pocketfft::c2c(shape_, stride_, stride_, axes_, pocketfft::BACKWARD, src, dst, static_cast<Scalar>(1));
-  }
-};
-
-}  // namespace internal
-}  // namespace Eigen
diff --git a/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h b/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h
deleted file mode 100644
index 0469a5a..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h
+++ /dev/null
@@ -1,339 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
-// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
-// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
-// Copyright (C) 2020 Adithya Vijaykumar
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-/*
-
-  This implementation of BiCGStab(L) is based on the papers
-      General algorithm:
-      1. G.L.G. Sleijpen, D.R. Fokkema. (1993). BiCGstab(l) for linear equations
-  involving unsymmetric matrices with complex spectrum. Electronic Transactions
-  on Numerical Analysis. Polynomial step update:
-      2. G.L.G. Sleijpen, M.B. Van Gijzen. (2010) Exploiting BiCGstab(l)
-  strategies to induce dimension reduction SIAM Journal on Scientific Computing.
-      3. Fokkema, Diederik R. Enhanced implementation of BiCGstab (l) for
-  solving linear systems of equations. Universiteit Utrecht. Mathematisch
-  Instituut, 1996
-      4. Sleijpen, G. L., & van der Vorst, H. A. (1996). Reliable updated
-  residuals in hybrid Bi-CG methods. Computing, 56(2), 141-163.
-*/
-
-#ifndef EIGEN_BICGSTABL_H
-#define EIGEN_BICGSTABL_H
-
-namespace Eigen {
-
-namespace internal {
-/**     \internal Low-level bi conjugate gradient stabilized algorithm with L
-   additional residual minimization steps \param mat The matrix A \param rhs The
-   right hand side vector b \param x On input and initial solution, on output
-   the computed solution. \param precond A preconditioner being able to
-   efficiently solve for an approximation of Ax=b (regardless of b) \param iters
-   On input the max number of iteration, on output the number of performed
-   iterations. \param tol_error On input the tolerance error, on output an
-   estimation of the relative error. \param L On input Number of additional
-   GMRES steps to take. If L is too large (~20) instabilities occur. \return
-   false in the case of numerical issue, for example a break down of BiCGSTABL.
-*/
-template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-bool bicgstabl(const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters,
-               typename Dest::RealScalar &tol_error, Index L) {
-  using numext::abs;
-  using numext::sqrt;
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  const Index N = rhs.size();
-  L = L < x.rows() ? L : x.rows();
-
-  Index k = 0;
-
-  const RealScalar tol = tol_error;
-  const Index maxIters = iters;
-
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
-
-  DenseMatrixType rHat(N, L + 1);
-  DenseMatrixType uHat(N, L + 1);
-
-  // We start with an initial guess x_0 and let us set r_0 as (residual
-  // calculated from x_0)
-  VectorType x0 = x;
-  rHat.col(0) = rhs - mat * x0;  // r_0
-
-  x.setZero();  // This will contain the updates to the solution.
-  // rShadow is arbitrary, but must never be orthogonal to any residual.
-  VectorType rShadow = VectorType::Random(N);
-
-  VectorType x_prime = x;
-
-  // Redundant: x is already set to 0
-  // x.setZero();
-  VectorType b_prime = rHat.col(0);
-
-  // Other vectors and scalars initialization
-  Scalar rho0 = 1.0;
-  Scalar alpha = 0.0;
-  Scalar omega = 1.0;
-
-  uHat.col(0).setZero();
-
-  bool bicg_convergence = false;
-
-  const RealScalar normb = rhs.stableNorm();
-  if (internal::isApprox(normb, RealScalar(0))) {
-    x.setZero();
-    iters = 0;
-    return true;
-  }
-  RealScalar normr = rHat.col(0).stableNorm();
-  RealScalar Mx = normr;
-  RealScalar Mr = normr;
-
-  // Keep track of the solution with the lowest residual
-  RealScalar normr_min = normr;
-  VectorType x_min = x_prime + x;
-
-  // Criterion for when to apply the group-wise update, conform ref 3.
-  const RealScalar delta = 0.01;
-
-  bool compute_res = false;
-  bool update_app = false;
-
-  while (normr > tol * normb && k < maxIters) {
-    rho0 *= -omega;
-
-    for (Index j = 0; j < L; ++j) {
-      const Scalar rho1 = rShadow.dot(rHat.col(j));
-
-      if (!(numext::isfinite)(rho1) || rho0 == RealScalar(0.0)) {
-        // We cannot continue computing, return the best solution found.
-        x += x_prime;
-
-        // Check if x is better than the best stored solution thus far.
-        normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm();
-
-        if (normr > normr_min || !(numext::isfinite)(normr)) {
-          // x_min is a better solution than x, return x_min
-          x = x_min;
-          normr = normr_min;
-        }
-        tol_error = normr / normb;
-        iters = k;
-        // x contains the updates to x0, add those back to obtain the solution
-        x = precond.solve(x);
-        x += x0;
-        return (normr < tol * normb);
-      }
-
-      const Scalar beta = alpha * (rho1 / rho0);
-      rho0 = rho1;
-      // Update search directions
-      uHat.leftCols(j + 1) = rHat.leftCols(j + 1) - beta * uHat.leftCols(j + 1);
-      uHat.col(j + 1) = mat * precond.solve(uHat.col(j));
-      const Scalar sigma = rShadow.dot(uHat.col(j + 1));
-      alpha = rho1 / sigma;
-      // Update residuals
-      rHat.leftCols(j + 1) -= alpha * uHat.middleCols(1, j + 1);
-      rHat.col(j + 1) = mat * precond.solve(rHat.col(j));
-      // Complete BiCG iteration by updating x
-      x += alpha * uHat.col(0);
-      normr = rHat.col(0).stableNorm();
-      // Check for early exit
-      if (normr < tol * normb) {
-        /*
-          Convergence was achieved during BiCG step.
-          Without this check BiCGStab(L) fails for trivial matrices, such as
-          when the preconditioner already is the inverse, or the input matrix is
-          identity.
-        */
-        bicg_convergence = true;
-        break;
-      } else if (normr < normr_min) {
-        // We found an x with lower residual, keep this one.
-        x_min = x + x_prime;
-        normr_min = normr;
-      }
-    }
-    if (!bicg_convergence) {
-      /*
-        The polynomial/minimize residual step.
-
-        QR Householder method for argmin is more stable than (modified)
-        Gram-Schmidt, in the sense that there is less loss of orthogonality. It
-        is more accurate than solving the normal equations, since the normal
-        equations scale with condition number squared.
-      */
-      const VectorType gamma = rHat.rightCols(L).householderQr().solve(rHat.col(0));
-      x += rHat.leftCols(L) * gamma;
-      rHat.col(0) -= rHat.rightCols(L) * gamma;
-      uHat.col(0) -= uHat.rightCols(L) * gamma;
-      normr = rHat.col(0).stableNorm();
-      omega = gamma(L - 1);
-    }
-    if (normr < normr_min) {
-      // We found an x with lower residual, keep this one.
-      x_min = x + x_prime;
-      normr_min = normr;
-    }
-
-    k++;
-
-    /*
-      Reliable update part
-
-      The recursively computed residual can deviate from the actual residual
-      after several iterations. However, computing the residual from the
-      definition costs extra MVs and should not be done at each iteration. The
-      reliable update strategy computes the true residual from the definition:
-      r=b-A*x at strategic intervals. Furthermore a "group wise update" strategy
-      is used to combine updates, which improves accuracy.
-    */
-
-    // Maximum norm of residuals since last update of x.
-    Mx = numext::maxi(Mx, normr);
-    // Maximum norm of residuals since last computation of the true residual.
-    Mr = numext::maxi(Mr, normr);
-
-    if (normr < delta * normb && normb <= Mx) {
-      update_app = true;
-    }
-
-    if (update_app || (normr < delta * Mr && normb <= Mr)) {
-      compute_res = true;
-    }
-
-    if (bicg_convergence) {
-      update_app = true;
-      compute_res = true;
-      bicg_convergence = false;
-    }
-
-    if (compute_res) {
-      // Explicitly compute residual from the definition
-
-      // This is equivalent to the shifted version of rhs - mat *
-      // (precond.solve(x)+x0)
-      rHat.col(0) = b_prime - mat * precond.solve(x);
-      normr = rHat.col(0).stableNorm();
-      Mr = normr;
-
-      if (update_app) {
-        // After the group wise update, the original problem is translated to a
-        // shifted one.
-        x_prime += x;
-        x.setZero();
-        b_prime = rHat.col(0);
-        Mx = normr;
-      }
-    }
-    if (normr < normr_min) {
-      // We found an x with lower residual, keep this one.
-      x_min = x + x_prime;
-      normr_min = normr;
-    }
-
-    compute_res = false;
-    update_app = false;
-  }
-
-  // Convert internal variable to the true solution vector x
-  x += x_prime;
-
-  normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm();
-  if (normr > normr_min || !(numext::isfinite)(normr)) {
-    // x_min is a better solution than x, return x_min
-    x = x_min;
-    normr = normr_min;
-  }
-  tol_error = normr / normb;
-  iters = k;
-
-  // x contains the updates to x0, add those back to obtain the solution
-  x = precond.solve(x);
-  x += x0;
-  return true;
-}
-
-}  // namespace internal
-
-template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar>>
-class BiCGSTABL;
-
-namespace internal {
-
-template <typename MatrixType_, typename Preconditioner_>
-struct traits<Eigen::BiCGSTABL<MatrixType_, Preconditioner_>> {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
-};
-
-}  // namespace internal
-
-template <typename MatrixType_, typename Preconditioner_>
-class BiCGSTABL : public IterativeSolverBase<BiCGSTABL<MatrixType_, Preconditioner_>> {
-  typedef IterativeSolverBase<BiCGSTABL> Base;
-  using Base::m_error;
-  using Base::m_info;
-  using Base::m_isInitialized;
-  using Base::m_iterations;
-  using Base::matrix;
-  Index m_L;
-
- public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
-
-  /** Default constructor. */
-  BiCGSTABL() : m_L(2) {}
-
-  /**
-  Initialize the solver with matrix \a A for further \c Ax=b solving.
-
-  This constructor is a shortcut for the default constructor followed
-  by a call to compute().
-
-  \warning this class stores a reference to the matrix A as well as some
-  precomputed values that depend on it. Therefore, if \a A is changed
-  this class becomes invalid. Call compute() to update it with the new
-  matrix A, or modify a copy of A.
-  */
-  template <typename MatrixDerived>
-  explicit BiCGSTABL(const EigenBase<MatrixDerived> &A) : Base(A.derived()), m_L(2) {}
-
-  /** \internal */
-  /** Loops over the number of columns of b and does the following:
-    1. sets the tolerance and maxIterations
-    2. Calls the function that has the core solver routine
-  */
-  template <typename Rhs, typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs &b, Dest &x) const {
-    m_iterations = Base::maxIterations();
-
-    m_error = Base::m_tolerance;
-
-    bool ret = internal::bicgstabl(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_L);
-    m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
-  }
-
-  /** Sets the parameter L, indicating how many minimize residual steps are
-   * used. Default: 2 */
-  void setL(Index L) {
-    eigen_assert(L >= 1 && "L needs to be positive");
-    m_L = L;
-  }
-};
-
-}  // namespace Eigen
-
-#endif /* EIGEN_BICGSTABL_H */
diff --git a/unsupported/Eigen/src/IterativeSolvers/DGMRES.h b/unsupported/Eigen/src/IterativeSolvers/DGMRES.h
deleted file mode 100644
index 2c10509..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/DGMRES.h
+++ /dev/null
@@ -1,490 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_DGMRES_H
-#define EIGEN_DGMRES_H
-
-#include "../../../../Eigen/Eigenvalues"
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> >
-class DGMRES;
-
-namespace internal {
-
-template <typename MatrixType_, typename Preconditioner_>
-struct traits<DGMRES<MatrixType_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
-};
-
-/** \brief Computes a permutation vector to have a sorted sequence
- * \param vec The vector to reorder.
- * \param perm gives the sorted sequence on output. Must be initialized with 0..n-1
- * \param ncut Put  the ncut smallest elements at the end of the vector
- * WARNING This is an expensive sort, so should be used only
- * for small size vectors
- * TODO: Use modified QuickSplit or std::nth_element to get the smallest values
- */
-template <typename VectorType, typename IndexType>
-void sortWithPermutation(VectorType& vec, IndexType& perm, typename IndexType::Scalar& ncut) {
-  eigen_assert(vec.size() == perm.size());
-  bool flag;
-  for (Index k = 0; k < ncut; k++) {
-    flag = false;
-    for (Index j = 0; j < vec.size() - 1; j++) {
-      if (vec(perm(j)) < vec(perm(j + 1))) {
-        std::swap(perm(j), perm(j + 1));
-        flag = true;
-      }
-      if (!flag) break;  // The vector is in sorted order
-    }
-  }
-}
-
-}  // namespace internal
-/**
- * \ingroup IterativeLinearSolvers_Module
- * \brief A Restarted GMRES with deflation.
- * This class implements a modification of the GMRES solver for
- * sparse linear systems. The basis is built with modified
- * Gram-Schmidt. At each restart, a few approximated eigenvectors
- * corresponding to the smallest eigenvalues are used to build a
- * preconditioner for the next cycle. This preconditioner
- * for deflation can be combined with any other preconditioner,
- * the IncompleteLUT for instance. The preconditioner is applied
- * at right of the matrix and the combination is multiplicative.
- *
- * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
- * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
- * Typical usage :
- * \code
- * SparseMatrix<double> A;
- * VectorXd x, b;
- * //Fill A and b ...
- * DGMRES<SparseMatrix<double> > solver;
- * solver.set_restart(30); // Set restarting value
- * solver.setEigenv(1); // Set the number of eigenvalues to deflate
- * solver.compute(A);
- * x = solver.solve(b);
- * \endcode
- *
- * DGMRES can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
- *
- * References :
- * [1] D. NUENTSA WAKAM and F. PACULL, Memory Efficient Hybrid
- *  Algebraic Solvers for Linear Systems Arising from Compressible
- *  Flows, Computers and Fluids, In Press,
- *  https://doi.org/10.1016/j.compfluid.2012.03.023
- * [2] K. Burrage and J. Erhel, On the performance of various
- * adaptive preconditioned GMRES strategies, 5(1998), 101-121.
- * [3] J. Erhel, K. Burrage and B. Pohl, Restarted GMRES
- *  preconditioned by deflation,J. Computational and Applied
- *  Mathematics, 69(1996), 303-318.
-
- *
- */
-template <typename MatrixType_, typename Preconditioner_>
-class DGMRES : public IterativeSolverBase<DGMRES<MatrixType_, Preconditioner_> > {
-  typedef IterativeSolverBase<DGMRES> Base;
-  using Base::m_error;
-  using Base::m_info;
-  using Base::m_isInitialized;
-  using Base::m_iterations;
-  using Base::m_tolerance;
-  using Base::matrix;
-
- public:
-  using Base::_solve_impl;
-  using Base::_solve_with_guess_impl;
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::StorageIndex StorageIndex;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef Preconditioner_ Preconditioner;
-  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
-  typedef Matrix<RealScalar, Dynamic, Dynamic> DenseRealMatrix;
-  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
-  typedef Matrix<RealScalar, Dynamic, 1> DenseRealVector;
-  typedef Matrix<ComplexScalar, Dynamic, 1> ComplexVector;
-
-  /** Default constructor. */
-  DGMRES()
-      : Base(), m_restart(30), m_neig(0), m_r(0), m_maxNeig(5), m_isDeflAllocated(false), m_isDeflInitialized(false) {}
-
-  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
-   *
-   * This constructor is a shortcut for the default constructor followed
-   * by a call to compute().
-   *
-   * \warning this class stores a reference to the matrix A as well as some
-   * precomputed values that depend on it. Therefore, if \a A is changed
-   * this class becomes invalid. Call compute() to update it with the new
-   * matrix A, or modify a copy of A.
-   */
-  template <typename MatrixDerived>
-  explicit DGMRES(const EigenBase<MatrixDerived>& A)
-      : Base(A.derived()),
-        m_restart(30),
-        m_neig(0),
-        m_r(0),
-        m_maxNeig(5),
-        m_isDeflAllocated(false),
-        m_isDeflInitialized(false) {}
-
-  ~DGMRES() {}
-
-  /** \internal */
-  template <typename Rhs, typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
-    EIGEN_STATIC_ASSERT(Rhs::ColsAtCompileTime == 1 || Dest::ColsAtCompileTime == 1,
-                        YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX);
-
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-
-    dgmres(matrix(), b, x, Base::m_preconditioner);
-  }
-
-  /**
-   * Get the restart value
-   */
-  Index restart() const { return m_restart; }
-
-  /**
-   * Set the restart value (default is 30)
-   */
-  void set_restart(const Index restart) { m_restart = restart; }
-
-  /**
-   * Set the number of eigenvalues to deflate at each restart
-   */
-  void setEigenv(const Index neig) {
-    m_neig = neig;
-    if (neig + 1 > m_maxNeig) m_maxNeig = neig + 1;  // To allow for complex conjugates
-  }
-
-  /**
-   * Get the size of the deflation subspace size
-   */
-  Index deflSize() const { return m_r; }
-
-  /**
-   * Set the maximum size of the deflation subspace
-   */
-  void setMaxEigenv(const Index maxNeig) { m_maxNeig = maxNeig; }
-
- protected:
-  // DGMRES algorithm
-  template <typename Rhs, typename Dest>
-  void dgmres(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond) const;
-  // Perform one cycle of GMRES
-  template <typename Dest>
-  Index dgmresCycle(const MatrixType& mat, const Preconditioner& precond, Dest& x, DenseVector& r0, RealScalar& beta,
-                    const RealScalar& normRhs, Index& nbIts) const;
-  // Compute data to use for deflation
-  Index dgmresComputeDeflationData(const MatrixType& mat, const Preconditioner& precond, const Index& it,
-                                   StorageIndex& neig) const;
-  // Apply deflation to a vector
-  template <typename RhsType, typename DestType>
-  Index dgmresApplyDeflation(const RhsType& In, DestType& Out) const;
-  ComplexVector schurValues(const ComplexSchur<DenseMatrix>& schurofH) const;
-  ComplexVector schurValues(const RealSchur<DenseMatrix>& schurofH) const;
-  // Init data for deflation
-  void dgmresInitDeflation(Index& rows) const;
-  mutable DenseMatrix m_V;                  // Krylov basis vectors
-  mutable DenseMatrix m_H;                  // Hessenberg matrix
-  mutable DenseMatrix m_Hes;                // Initial hessenberg matrix without Givens rotations applied
-  mutable Index m_restart;                  // Maximum size of the Krylov subspace
-  mutable DenseMatrix m_U;                  // Vectors that form the basis of the invariant subspace
-  mutable DenseMatrix m_MU;                 // matrix operator applied to m_U (for next cycles)
-  mutable DenseMatrix m_T;                  /* T=U^T*M^{-1}*A*U */
-  mutable PartialPivLU<DenseMatrix> m_luT;  // LU factorization of m_T
-  mutable StorageIndex m_neig;              // Number of eigenvalues to extract at each restart
-  mutable Index m_r;                        // Current number of deflated eigenvalues, size of m_U
-  mutable Index m_maxNeig;                  // Maximum number of eigenvalues to deflate
-  mutable RealScalar m_lambdaN;             // Modulus of the largest eigenvalue of A
-  mutable bool m_isDeflAllocated;
-  mutable bool m_isDeflInitialized;
-
-  // Adaptive strategy
-  mutable RealScalar m_smv;  // Smaller multiple of the remaining number of steps allowed
-  mutable bool m_force;      // Force the use of deflation at each restart
-};
-/**
- * \brief Perform several cycles of restarted GMRES with modified Gram Schmidt,
- *
- * A right preconditioner is used combined with deflation.
- *
- */
-template <typename MatrixType_, typename Preconditioner_>
-template <typename Rhs, typename Dest>
-void DGMRES<MatrixType_, Preconditioner_>::dgmres(const MatrixType& mat, const Rhs& rhs, Dest& x,
-                                                  const Preconditioner& precond) const {
-  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
-
-  RealScalar normRhs = rhs.norm();
-  if (normRhs <= considerAsZero) {
-    x.setZero();
-    m_error = 0;
-    return;
-  }
-
-  // Initialization
-  m_isDeflInitialized = false;
-  Index n = mat.rows();
-  DenseVector r0(n);
-  Index nbIts = 0;
-  m_H.resize(m_restart + 1, m_restart);
-  m_Hes.resize(m_restart, m_restart);
-  m_V.resize(n, m_restart + 1);
-  // Initial residual vector and initial norm
-  if (x.squaredNorm() == 0) x = precond.solve(rhs);
-  r0 = rhs - mat * x;
-  RealScalar beta = r0.norm();
-
-  m_error = beta / normRhs;
-  if (m_error < m_tolerance)
-    m_info = Success;
-  else
-    m_info = NoConvergence;
-
-  // Iterative process
-  while (nbIts < m_iterations && m_info == NoConvergence) {
-    dgmresCycle(mat, precond, x, r0, beta, normRhs, nbIts);
-
-    // Compute the new residual vector for the restart
-    if (nbIts < m_iterations && m_info == NoConvergence) {
-      r0 = rhs - mat * x;
-      beta = r0.norm();
-    }
-  }
-}
-
-/**
- * \brief Perform one restart cycle of DGMRES
- * \param mat The coefficient matrix
- * \param precond The preconditioner
- * \param x the new approximated solution
- * \param r0 The initial residual vector
- * \param beta The norm of the residual computed so far
- * \param normRhs The norm of the right hand side vector
- * \param nbIts The number of iterations
- */
-template <typename MatrixType_, typename Preconditioner_>
-template <typename Dest>
-Index DGMRES<MatrixType_, Preconditioner_>::dgmresCycle(const MatrixType& mat, const Preconditioner& precond, Dest& x,
-                                                        DenseVector& r0, RealScalar& beta, const RealScalar& normRhs,
-                                                        Index& nbIts) const {
-  // Initialization
-  DenseVector g(m_restart + 1);  // Right hand side of the least square problem
-  g.setZero();
-  g(0) = Scalar(beta);
-  m_V.col(0) = r0 / beta;
-  m_info = NoConvergence;
-  std::vector<JacobiRotation<Scalar> > gr(m_restart);  // Givens rotations
-  Index it = 0;                                        // Number of inner iterations
-  Index n = mat.rows();
-  DenseVector tv1(n), tv2(n);  // Temporary vectors
-  while (m_info == NoConvergence && it < m_restart && nbIts < m_iterations) {
-    // Apply preconditioner(s) at right
-    if (m_isDeflInitialized) {
-      dgmresApplyDeflation(m_V.col(it), tv1);  // Deflation
-      tv2 = precond.solve(tv1);
-    } else {
-      tv2 = precond.solve(m_V.col(it));  // User's selected preconditioner
-    }
-    tv1 = mat * tv2;
-
-    // Orthogonalize it with the previous basis in the basis using modified Gram-Schmidt
-    Scalar coef;
-    for (Index i = 0; i <= it; ++i) {
-      coef = tv1.dot(m_V.col(i));
-      tv1 = tv1 - coef * m_V.col(i);
-      m_H(i, it) = coef;
-      m_Hes(i, it) = coef;
-    }
-    // Normalize the vector
-    coef = tv1.norm();
-    m_V.col(it + 1) = tv1 / coef;
-    m_H(it + 1, it) = coef;
-    //     m_Hes(it+1,it) = coef;
-
-    // FIXME: Check for happy breakdown.
-
-    // Update Hessenberg matrix with Givens rotations
-    for (Index i = 1; i <= it; ++i) {
-      m_H.col(it).applyOnTheLeft(i - 1, i, gr[i - 1].adjoint());
-    }
-    // Compute the new plane rotation
-    gr[it].makeGivens(m_H(it, it), m_H(it + 1, it));
-    // Apply the new rotation
-    m_H.col(it).applyOnTheLeft(it, it + 1, gr[it].adjoint());
-    g.applyOnTheLeft(it, it + 1, gr[it].adjoint());
-
-    beta = std::abs(g(it + 1));
-    m_error = beta / normRhs;
-    it++;
-    nbIts++;
-
-    if (m_error < m_tolerance) {
-      // The method has converged
-      m_info = Success;
-      break;
-    }
-  }
-
-  // Compute the new coefficients by solving the least square problem
-  // FIXME: Check first if the matrix is singular (zero diagonal).
-  DenseVector nrs(m_restart);
-  nrs = m_H.topLeftCorner(it, it).template triangularView<Upper>().solve(g.head(it));
-
-  // Form the new solution
-  if (m_isDeflInitialized) {
-    tv1 = m_V.leftCols(it) * nrs;
-    dgmresApplyDeflation(tv1, tv2);
-    x = x + precond.solve(tv2);
-  } else
-    x = x + precond.solve(m_V.leftCols(it) * nrs);
-
-  // Go for a new cycle and compute data for deflation
-  if (nbIts < m_iterations && m_info == NoConvergence && m_neig > 0 && (m_r + m_neig) < m_maxNeig)
-    dgmresComputeDeflationData(mat, precond, it, m_neig);
-  return 0;
-}
-
-template <typename MatrixType_, typename Preconditioner_>
-void DGMRES<MatrixType_, Preconditioner_>::dgmresInitDeflation(Index& rows) const {
-  m_U.resize(rows, m_maxNeig);
-  m_MU.resize(rows, m_maxNeig);
-  m_T.resize(m_maxNeig, m_maxNeig);
-  m_lambdaN = 0.0;
-  m_isDeflAllocated = true;
-}
-
-template <typename MatrixType_, typename Preconditioner_>
-inline typename DGMRES<MatrixType_, Preconditioner_>::ComplexVector DGMRES<MatrixType_, Preconditioner_>::schurValues(
-    const ComplexSchur<DenseMatrix>& schurofH) const {
-  return schurofH.matrixT().diagonal();
-}
-
-template <typename MatrixType_, typename Preconditioner_>
-inline typename DGMRES<MatrixType_, Preconditioner_>::ComplexVector DGMRES<MatrixType_, Preconditioner_>::schurValues(
-    const RealSchur<DenseMatrix>& schurofH) const {
-  const DenseMatrix& T = schurofH.matrixT();
-  Index it = T.rows();
-  ComplexVector eig(it);
-  Index j = 0;
-  while (j < it - 1) {
-    if (T(j + 1, j) == Scalar(0)) {
-      eig(j) = ComplexScalar(T(j, j), RealScalar(0));
-      j++;
-    } else {
-      eig(j) = ComplexScalar(T(j, j), T(j + 1, j));
-      eig(j + 1) = ComplexScalar(T(j, j + 1), T(j + 1, j + 1));
-      j++;
-    }
-  }
-  if (j < it - 1) eig(j) = ComplexScalar(T(j, j), RealScalar(0));
-  return eig;
-}
-
-template <typename MatrixType_, typename Preconditioner_>
-Index DGMRES<MatrixType_, Preconditioner_>::dgmresComputeDeflationData(const MatrixType& mat,
-                                                                       const Preconditioner& precond, const Index& it,
-                                                                       StorageIndex& neig) const {
-  // First, find the Schur form of the Hessenberg matrix H
-  std::conditional_t<NumTraits<Scalar>::IsComplex, ComplexSchur<DenseMatrix>, RealSchur<DenseMatrix> > schurofH;
-  bool computeU = true;
-  DenseMatrix matrixQ(it, it);
-  matrixQ.setIdentity();
-  schurofH.computeFromHessenberg(m_Hes.topLeftCorner(it, it), matrixQ, computeU);
-
-  ComplexVector eig(it);
-  Matrix<StorageIndex, Dynamic, 1> perm(it);
-  eig = this->schurValues(schurofH);
-
-  // Reorder the absolute values of Schur values
-  DenseRealVector modulEig(it);
-  for (Index j = 0; j < it; ++j) modulEig(j) = std::abs(eig(j));
-  perm.setLinSpaced(it, 0, internal::convert_index<StorageIndex>(it - 1));
-  internal::sortWithPermutation(modulEig, perm, neig);
-
-  if (!m_lambdaN) {
-    m_lambdaN = (std::max)(modulEig.maxCoeff(), m_lambdaN);
-  }
-  // Count the real number of extracted eigenvalues (with complex conjugates)
-  Index nbrEig = 0;
-  while (nbrEig < neig) {
-    if (eig(perm(it - nbrEig - 1)).imag() == RealScalar(0))
-      nbrEig++;
-    else
-      nbrEig += 2;
-  }
-  // Extract the  Schur vectors corresponding to the smallest Ritz values
-  DenseMatrix Sr(it, nbrEig);
-  Sr.setZero();
-  for (Index j = 0; j < nbrEig; j++) {
-    Sr.col(j) = schurofH.matrixU().col(perm(it - j - 1));
-  }
-
-  // Form the Schur vectors of the initial matrix using the Krylov basis
-  DenseMatrix X;
-  X = m_V.leftCols(it) * Sr;
-  if (m_r) {
-    // Orthogonalize X against m_U using modified Gram-Schmidt
-    for (Index j = 0; j < nbrEig; j++)
-      for (Index k = 0; k < m_r; k++) X.col(j) = X.col(j) - (m_U.col(k).dot(X.col(j))) * m_U.col(k);
-  }
-
-  // Compute m_MX = A * M^-1 * X
-  Index m = m_V.rows();
-  if (!m_isDeflAllocated) dgmresInitDeflation(m);
-  DenseMatrix MX(m, nbrEig);
-  DenseVector tv1(m);
-  for (Index j = 0; j < nbrEig; j++) {
-    tv1 = mat * X.col(j);
-    MX.col(j) = precond.solve(tv1);
-  }
-
-  // Update m_T = [U'MU U'MX; X'MU X'MX]
-  m_T.block(m_r, m_r, nbrEig, nbrEig) = X.transpose() * MX;
-  if (m_r) {
-    m_T.block(0, m_r, m_r, nbrEig) = m_U.leftCols(m_r).transpose() * MX;
-    m_T.block(m_r, 0, nbrEig, m_r) = X.transpose() * m_MU.leftCols(m_r);
-  }
-
-  // Save X into m_U and m_MX in m_MU
-  for (Index j = 0; j < nbrEig; j++) m_U.col(m_r + j) = X.col(j);
-  for (Index j = 0; j < nbrEig; j++) m_MU.col(m_r + j) = MX.col(j);
-  // Increase the size of the invariant subspace
-  m_r += nbrEig;
-
-  // Factorize m_T into m_luT
-  m_luT.compute(m_T.topLeftCorner(m_r, m_r));
-
-  // FIXME: Check if the factorization was correctly done (nonsingular matrix).
-  m_isDeflInitialized = true;
-  return 0;
-}
-template <typename MatrixType_, typename Preconditioner_>
-template <typename RhsType, typename DestType>
-Index DGMRES<MatrixType_, Preconditioner_>::dgmresApplyDeflation(const RhsType& x, DestType& y) const {
-  DenseVector x1 = m_U.leftCols(m_r).transpose() * x;
-  y = x + m_U.leftCols(m_r) * (m_lambdaN * m_luT.solve(x1) - x1);
-  return 0;
-}
-
-}  // end namespace Eigen
-#endif
diff --git a/unsupported/Eigen/src/IterativeSolvers/GMRES.h b/unsupported/Eigen/src/IterativeSolvers/GMRES.h
deleted file mode 100644
index f2c85ff..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/GMRES.h
+++ /dev/null
@@ -1,315 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2012, 2014 Kolja Brix <brix@igpm.rwth-aaachen.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_GMRES_H
-#define EIGEN_GMRES_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/**
- * Generalized Minimal Residual Algorithm based on the
- * Arnoldi algorithm implemented with Householder reflections.
- *
- * Parameters:
- *  \param mat       matrix of linear system of equations
- *  \param rhs       right hand side vector of linear system of equations
- *  \param x         on input: initial guess, on output: solution
- *  \param precond   preconditioner used
- *  \param iters     on input: maximum number of iterations to perform
- *                   on output: number of iterations performed
- *  \param restart   number of iterations for a restart
- *  \param tol_error on input: relative residual tolerance
- *                   on output: residuum achieved
- *
- * \sa IterativeMethods::bicgstab()
- *
- *
- * For references, please see:
- *
- * Saad, Y. and Schultz, M. H.
- * GMRES: A Generalized Minimal Residual Algorithm for Solving Nonsymmetric Linear Systems.
- * SIAM J.Sci.Stat.Comp. 7, 1986, pp. 856 - 869.
- *
- * Saad, Y.
- * Iterative Methods for Sparse Linear Systems.
- * Society for Industrial and Applied Mathematics, Philadelphia, 2003.
- *
- * Walker, H. F.
- * Implementations of the GMRES method.
- * Comput.Phys.Comm. 53, 1989, pp. 311 - 320.
- *
- * Walker, H. F.
- * Implementation of the GMRES Method using Householder Transformations.
- * SIAM J.Sci.Stat.Comp. 9, 1988, pp. 152 - 163.
- *
- */
-template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-bool gmres(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond, Index& iters,
-           const Index& restart, typename Dest::RealScalar& tol_error) {
-  using std::abs;
-  using std::sqrt;
-
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> FMatrixType;
-
-  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
-
-  if (rhs.norm() <= considerAsZero) {
-    x.setZero();
-    tol_error = 0;
-    return true;
-  }
-
-  RealScalar tol = tol_error;
-  const Index maxIters = iters;
-  iters = 0;
-
-  const Index m = mat.rows();
-
-  // residual and preconditioned residual
-  VectorType p0 = rhs - mat * x;
-  VectorType r0 = precond.solve(p0);
-
-  const RealScalar r0Norm = r0.norm();
-
-  // is initial guess already good enough?
-  if (r0Norm == 0) {
-    tol_error = 0;
-    return true;
-  }
-
-  // storage for Hessenberg matrix and Householder data
-  FMatrixType H = FMatrixType::Zero(m, restart + 1);
-  VectorType w = VectorType::Zero(restart + 1);
-  VectorType tau = VectorType::Zero(restart + 1);
-
-  // storage for Jacobi rotations
-  std::vector<JacobiRotation<Scalar> > G(restart);
-
-  // storage for temporaries
-  VectorType t(m), v(m), workspace(m), x_new(m);
-
-  // generate first Householder vector
-  Ref<VectorType> H0_tail = H.col(0).tail(m - 1);
-  RealScalar beta;
-  r0.makeHouseholder(H0_tail, tau.coeffRef(0), beta);
-  w(0) = Scalar(beta);
-
-  for (Index k = 1; k <= restart; ++k) {
-    ++iters;
-
-    v = VectorType::Unit(m, k - 1);
-
-    // apply Householder reflections H_{1} ... H_{k-1} to v
-    // TODO: use a HouseholderSequence
-    for (Index i = k - 1; i >= 0; --i) {
-      v.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
-    }
-
-    // apply matrix M to v:  v = mat * v;
-    t.noalias() = mat * v;
-    v = precond.solve(t);
-
-    // apply Householder reflections H_{k-1} ... H_{1} to v
-    // TODO: use a HouseholderSequence
-    for (Index i = 0; i < k; ++i) {
-      v.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
-    }
-
-    if (v.tail(m - k).norm() != 0.0) {
-      if (k <= restart) {
-        // generate new Householder vector
-        Ref<VectorType> Hk_tail = H.col(k).tail(m - k - 1);
-        v.tail(m - k).makeHouseholder(Hk_tail, tau.coeffRef(k), beta);
-
-        // apply Householder reflection H_{k} to v
-        v.tail(m - k).applyHouseholderOnTheLeft(Hk_tail, tau.coeffRef(k), workspace.data());
-      }
-    }
-
-    if (k > 1) {
-      for (Index i = 0; i < k - 1; ++i) {
-        // apply old Givens rotations to v
-        v.applyOnTheLeft(i, i + 1, G[i].adjoint());
-      }
-    }
-
-    if (k < m && v(k) != (Scalar)0) {
-      // determine next Givens rotation
-      G[k - 1].makeGivens(v(k - 1), v(k));
-
-      // apply Givens rotation to v and w
-      v.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
-      w.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
-    }
-
-    // insert coefficients into upper matrix triangle
-    H.col(k - 1).head(k) = v.head(k);
-
-    tol_error = abs(w(k)) / r0Norm;
-    bool stop = (k == m || tol_error < tol || iters == maxIters);
-
-    if (stop || k == restart) {
-      // solve upper triangular system
-      Ref<VectorType> y = w.head(k);
-      H.topLeftCorner(k, k).template triangularView<Upper>().solveInPlace(y);
-
-      // use Horner-like scheme to calculate solution vector
-      x_new.setZero();
-      for (Index i = k - 1; i >= 0; --i) {
-        x_new(i) += y(i);
-        // apply Householder reflection H_{i} to x_new
-        x_new.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
-      }
-
-      x += x_new;
-
-      if (stop) {
-        return true;
-      } else {
-        k = 0;
-
-        // reset data for restart
-        p0.noalias() = rhs - mat * x;
-        r0 = precond.solve(p0);
-
-        // clear Hessenberg matrix and Householder data
-        H.setZero();
-        w.setZero();
-        tau.setZero();
-
-        // generate first Householder vector
-        r0.makeHouseholder(H0_tail, tau.coeffRef(0), beta);
-        w(0) = Scalar(beta);
-      }
-    }
-  }
-
-  return false;
-}
-
-}  // namespace internal
-
-template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> >
-class GMRES;
-
-namespace internal {
-
-template <typename MatrixType_, typename Preconditioner_>
-struct traits<GMRES<MatrixType_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
-};
-
-}  // namespace internal
-
-/** \ingroup IterativeLinearSolvers_Module
- * \brief A GMRES solver for sparse square problems
- *
- * This class allows to solve for A.x = b sparse linear problems using a generalized minimal
- * residual method. The vectors x and b can be either dense or sparse.
- *
- * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
- * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
- *
- * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
- * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
- * and NumTraits<Scalar>::epsilon() for the tolerance.
- *
- * This class can be used as the direct solver classes. Here is a typical usage example:
- * \code
- * int n = 10000;
- * VectorXd x(n), b(n);
- * SparseMatrix<double> A(n,n);
- * // fill A and b
- * GMRES<SparseMatrix<double> > solver(A);
- * x = solver.solve(b);
- * std::cout << "#iterations:     " << solver.iterations() << std::endl;
- * std::cout << "estimated error: " << solver.error()      << std::endl;
- * // update b, and solve again
- * x = solver.solve(b);
- * \endcode
- *
- * By default the iterations start with x=0 as an initial guess of the solution.
- * One can control the start using the solveWithGuess() method.
- *
- * GMRES can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
- *
- * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
- */
-template <typename MatrixType_, typename Preconditioner_>
-class GMRES : public IterativeSolverBase<GMRES<MatrixType_, Preconditioner_> > {
-  typedef IterativeSolverBase<GMRES> Base;
-  using Base::m_error;
-  using Base::m_info;
-  using Base::m_isInitialized;
-  using Base::m_iterations;
-  using Base::matrix;
-
- private:
-  Index m_restart;
-
- public:
-  using Base::_solve_impl;
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
-
- public:
-  /** Default constructor. */
-  GMRES() : Base(), m_restart(30) {}
-
-  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
-   *
-   * This constructor is a shortcut for the default constructor followed
-   * by a call to compute().
-   *
-   * \warning this class stores a reference to the matrix A as well as some
-   * precomputed values that depend on it. Therefore, if \a A is changed
-   * this class becomes invalid. Call compute() to update it with the new
-   * matrix A, or modify a copy of A.
-   */
-  template <typename MatrixDerived>
-  explicit GMRES(const EigenBase<MatrixDerived>& A) : Base(A.derived()), m_restart(30) {}
-
-  ~GMRES() {}
-
-  /** Get the number of iterations after that a restart is performed.
-   */
-  Index get_restart() const { return m_restart; }
-
-  /** Set the number of iterations after that a restart is performed.
-   *  \param restart   number of iterations for a restarti, default is 30.
-   */
-  void set_restart(const Index restart) { m_restart = restart; }
-
-  /** \internal */
-  template <typename Rhs, typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-    bool ret = internal::gmres(matrix(), b, x, Base::m_preconditioner, m_iterations, m_restart, m_error);
-    m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
-  }
-
- protected:
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_GMRES_H
diff --git a/unsupported/Eigen/src/IterativeSolvers/IDRS.h b/unsupported/Eigen/src/IterativeSolvers/IDRS.h
deleted file mode 100644
index 09568e1..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/IDRS.h
+++ /dev/null
@@ -1,395 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
-// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
-// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_IDRS_H
-#define EIGEN_IDRS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-/**     \internal Low-level Induced Dimension Reduction algorithm
-        \param A The matrix A
-        \param b The right hand side vector b
-        \param x On input and initial solution, on output the computed solution.
-        \param precond A preconditioner being able to efficiently solve for an
-                  approximation of Ax=b (regardless of b)
-        \param iter On input the max number of iteration, on output the number of performed iterations.
-        \param relres On input the tolerance error, on output an estimation of the relative error.
-        \param S On input Number of the dimension of the shadow space.
-                \param smoothing switches residual smoothing on.
-                \param angle small omega lead to faster convergence at the expense of numerical stability
-                \param replacement switches on a residual replacement strategy to increase accuracy of residual at the
-   expense of more Mat*vec products \return false in the case of numerical issue, for example a break down of IDRS.
-*/
-template <typename Vector, typename RealScalar>
-typename Vector::Scalar omega(const Vector& t, const Vector& s, RealScalar angle) {
-  using numext::abs;
-  typedef typename Vector::Scalar Scalar;
-  const RealScalar ns = s.stableNorm();
-  const RealScalar nt = t.stableNorm();
-  const Scalar ts = t.dot(s);
-  const RealScalar rho = abs(ts / (nt * ns));
-
-  if (rho < angle) {
-    if (ts == Scalar(0)) {
-      return Scalar(0);
-    }
-    // Original relation for om is given by
-    // om = om * angle / rho;
-    // To alleviate potential (near) division by zero this can be rewritten as
-    // om = angle * (ns / nt) * (ts / abs(ts)) = angle * (ns / nt) * sgn(ts)
-    return angle * (ns / nt) * (ts / abs(ts));
-  }
-  return ts / (nt * nt);
-}
-
-template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-bool idrs(const MatrixType& A, const Rhs& b, Dest& x, const Preconditioner& precond, Index& iter,
-          typename Dest::RealScalar& relres, Index S, bool smoothing, typename Dest::RealScalar angle,
-          bool replacement) {
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
-  const Index N = b.size();
-  S = S < x.rows() ? S : x.rows();
-  const RealScalar tol = relres;
-  const Index maxit = iter;
-
-  bool trueres = false;
-
-  FullPivLU<DenseMatrixType> lu_solver;
-
-  DenseMatrixType P;
-  {
-    HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S));
-    P = (qr.householderQ() * DenseMatrixType::Identity(N, S));
-  }
-
-  const RealScalar normb = b.stableNorm();
-
-  if (internal::isApprox(normb, RealScalar(0))) {
-    // Solution is the zero vector
-    x.setZero();
-    iter = 0;
-    relres = 0;
-    return true;
-  }
-  // from http://homepage.tudelft.nl/1w5b5/IDRS/manual.pdf
-  // A peak in the residual is considered dangerously high if‖ri‖/‖b‖> C(tol/epsilon).
-  // With epsilon the relative machine precision. The factor tol/epsilon corresponds
-  // to the size of a finite precision number that is so large that the absolute
-  // round-off error in this number, when propagated through the process, makes it
-  // impossible to achieve the required accuracy. The factor C accounts for the
-  // accumulation of round-off errors. This parameter has been set to 10^{-3}.
-  // mp is epsilon/C 10^3 * eps is very conservative, so normally no residual
-  // replacements will take place. It only happens if things go very wrong. Too many
-  // restarts may ruin the convergence.
-  const RealScalar mp = RealScalar(1e3) * NumTraits<Scalar>::epsilon();
-
-  // Compute initial residual
-  const RealScalar tolb = tol * normb;  // Relative tolerance
-  VectorType r = b - A * x;
-
-  VectorType x_s, r_s;
-
-  if (smoothing) {
-    x_s = x;
-    r_s = r;
-  }
-
-  RealScalar normr = r.stableNorm();
-
-  if (normr <= tolb) {
-    // Initial guess is a good enough solution
-    iter = 0;
-    relres = normr / normb;
-    return true;
-  }
-
-  DenseMatrixType G = DenseMatrixType::Zero(N, S);
-  DenseMatrixType U = DenseMatrixType::Zero(N, S);
-  DenseMatrixType M = DenseMatrixType::Identity(S, S);
-  VectorType t(N), v(N);
-  Scalar om = 1.;
-
-  // Main iteration loop, guild G-spaces:
-  iter = 0;
-
-  while (normr > tolb && iter < maxit) {
-    // New right hand size for small system:
-    VectorType f = (r.adjoint() * P).adjoint();
-
-    for (Index k = 0; k < S; ++k) {
-      // Solve small system and make v orthogonal to P:
-      // c = M(k:s,k:s)\f(k:s);
-      lu_solver.compute(M.block(k, k, S - k, S - k));
-      VectorType c = lu_solver.solve(f.segment(k, S - k));
-      // v = r - G(:,k:s)*c;
-      v = r - G.rightCols(S - k) * c;
-      // Preconditioning
-      v = precond.solve(v);
-
-      // Compute new U(:,k) and G(:,k), G(:,k) is in space G_j
-      U.col(k) = U.rightCols(S - k) * c + om * v;
-      G.col(k) = A * U.col(k);
-
-      // Bi-Orthogonalise the new basis vectors:
-      for (Index i = 0; i < k - 1; ++i) {
-        // alpha =  ( P(:,i)'*G(:,k) )/M(i,i);
-        Scalar alpha = P.col(i).dot(G.col(k)) / M(i, i);
-        G.col(k) = G.col(k) - alpha * G.col(i);
-        U.col(k) = U.col(k) - alpha * U.col(i);
-      }
-
-      // New column of M = P'*G  (first k-1 entries are zero)
-      // M(k:s,k) = (G(:,k)'*P(:,k:s))';
-      M.block(k, k, S - k, 1) = (G.col(k).adjoint() * P.rightCols(S - k)).adjoint();
-
-      if (internal::isApprox(M(k, k), Scalar(0))) {
-        return false;
-      }
-
-      // Make r orthogonal to q_i, i = 0..k-1
-      Scalar beta = f(k) / M(k, k);
-      r = r - beta * G.col(k);
-      x = x + beta * U.col(k);
-      normr = r.stableNorm();
-
-      if (replacement && normr > tolb / mp) {
-        trueres = true;
-      }
-
-      // Smoothing:
-      if (smoothing) {
-        t = r_s - r;
-        // gamma is a Scalar, but the conversion is not allowed
-        Scalar gamma = t.dot(r_s) / t.stableNorm();
-        r_s = r_s - gamma * t;
-        x_s = x_s - gamma * (x_s - x);
-        normr = r_s.stableNorm();
-      }
-
-      if (normr < tolb || iter == maxit) {
-        break;
-      }
-
-      // New f = P'*r (first k  components are zero)
-      if (k < S - 1) {
-        f.segment(k + 1, S - (k + 1)) = f.segment(k + 1, S - (k + 1)) - beta * M.block(k + 1, k, S - (k + 1), 1);
-      }
-    }  // end for
-
-    if (normr < tolb || iter == maxit) {
-      break;
-    }
-
-    // Now we have sufficient vectors in G_j to compute residual in G_j+1
-    // Note: r is already perpendicular to P so v = r
-    // Preconditioning
-    v = r;
-    v = precond.solve(v);
-
-    // Matrix-vector multiplication:
-    t = A * v;
-
-    // Computation of a new omega
-    om = internal::omega(t, r, angle);
-
-    if (om == RealScalar(0.0)) {
-      return false;
-    }
-
-    r = r - om * t;
-    x = x + om * v;
-    normr = r.stableNorm();
-
-    if (replacement && normr > tolb / mp) {
-      trueres = true;
-    }
-
-    // Residual replacement?
-    if (trueres && normr < normb) {
-      r = b - A * x;
-      trueres = false;
-    }
-
-    // Smoothing:
-    if (smoothing) {
-      t = r_s - r;
-      Scalar gamma = t.dot(r_s) / t.stableNorm();
-      r_s = r_s - gamma * t;
-      x_s = x_s - gamma * (x_s - x);
-      normr = r_s.stableNorm();
-    }
-
-    iter++;
-
-  }  // end while
-
-  if (smoothing) {
-    x = x_s;
-  }
-  relres = normr / normb;
-  return true;
-}
-
-}  // namespace internal
-
-template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> >
-class IDRS;
-
-namespace internal {
-
-template <typename MatrixType_, typename Preconditioner_>
-struct traits<Eigen::IDRS<MatrixType_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
-};
-
-}  // namespace internal
-
-/** \ingroup IterativeLinearSolvers_Module
- * \brief The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square
- * problems.
- *
- * This class allows to solve for A.x = b sparse linear problems. The vectors x and b can be either dense or sparse.
- * he Induced Dimension Reduction method, IDR(), is a robust and efficient short-recurrence Krylov subspace method for
- * solving large nonsymmetric systems of linear equations.
- *
- * For indefinite systems IDR(S) outperforms both BiCGStab and BiCGStab(L). Additionally, IDR(S) can handle matrices
- * with complex eigenvalues more efficiently than BiCGStab.
- *
- * Many problems that do not converge for BiCGSTAB converge for IDR(s) (for larger values of s). And if both methods
- * converge the convergence for IDR(s) is typically much faster for difficult systems (for example indefinite problems).
- *
- * IDR(s) is a limited memory finite termination method. In exact arithmetic it converges in at most N+N/s iterations,
- * with N the system size.  It uses a fixed number of 4+3s vector. In comparison, BiCGSTAB terminates in 2N iterations
- * and uses 7 vectors. GMRES terminates in at most N iterations, and uses I+3 vectors, with I the number of iterations.
- * Restarting GMRES limits the memory consumption, but destroys the finite termination property.
- *
- * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
- * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
- *
- * \implsparsesolverconcept
- *
- * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
- * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
- * and NumTraits<Scalar>::epsilon() for the tolerance.
- *
- * The tolerance corresponds to the relative residual error: |Ax-b|/|b|
- *
- * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format.
- * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled.
- * See \ref TopicMultiThreading for details.
- *
- * By default the iterations start with x=0 as an initial guess of the solution.
- * One can control the start using the solveWithGuess() method.
- *
- * IDR(s) can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
- *
- * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
- */
-template <typename MatrixType_, typename Preconditioner_>
-class IDRS : public IterativeSolverBase<IDRS<MatrixType_, Preconditioner_> > {
- public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
-
- private:
-  typedef IterativeSolverBase<IDRS> Base;
-  using Base::m_error;
-  using Base::m_info;
-  using Base::m_isInitialized;
-  using Base::m_iterations;
-  using Base::matrix;
-  Index m_S;
-  bool m_smoothing;
-  RealScalar m_angle;
-  bool m_residual;
-
- public:
-  /** Default constructor. */
-  IDRS() : m_S(4), m_smoothing(false), m_angle(RealScalar(0.7)), m_residual(false) {}
-
-  /**     Initialize the solver with matrix \a A for further \c Ax=b solving.
-
-          This constructor is a shortcut for the default constructor followed
-          by a call to compute().
-
-          \warning this class stores a reference to the matrix A as well as some
-          precomputed values that depend on it. Therefore, if \a A is changed
-          this class becomes invalid. Call compute() to update it with the new
-          matrix A, or modify a copy of A.
-  */
-  template <typename MatrixDerived>
-  explicit IDRS(const EigenBase<MatrixDerived>& A)
-      : Base(A.derived()), m_S(4), m_smoothing(false), m_angle(RealScalar(0.7)), m_residual(false) {}
-
-  /** \internal */
-  /**     Loops over the number of columns of b and does the following:
-                  1. sets the tolerance and maxIterations
-                  2. Calls the function that has the core solver routine
-  */
-  template <typename Rhs, typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-
-    bool ret = internal::idrs(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_S, m_smoothing, m_angle,
-                              m_residual);
-
-    m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence;
-  }
-
-  /** Sets the parameter S, indicating the dimension of the shadow space. Default is 4*/
-  void setS(Index S) {
-    if (S < 1) {
-      S = 4;
-    }
-
-    m_S = S;
-  }
-
-  /** Switches off and on smoothing.
-  Residual smoothing results in monotonically decreasing residual norms at
-  the expense of two extra vectors of storage and a few extra vector
-  operations. Although monotonic decrease of the residual norms is a
-  desirable property, the rate of convergence of the unsmoothed process and
-  the smoothed process is basically the same. Default is off */
-  void setSmoothing(bool smoothing) { m_smoothing = smoothing; }
-
-  /** The angle must be a real scalar. In IDR(s), a value for the
-  iteration parameter omega must be chosen in every s+1th step. The most
-  natural choice is to select a value to minimize the norm of the next residual.
-  This corresponds to the parameter omega = 0. In practice, this may lead to
-  values of omega that are so small that the other iteration parameters
-  cannot be computed with sufficient accuracy. In such cases it is better to
-  increase the value of omega sufficiently such that a compromise is reached
-  between accurate computations and reduction of the residual norm. The
-  parameter angle =0.7 (”maintaining the convergence strategy”)
-  results in such a compromise. */
-  void setAngle(RealScalar angle) { m_angle = angle; }
-
-  /** The parameter replace is a logical that determines whether a
-  residual replacement strategy is employed to increase the accuracy of the
-  solution. */
-  void setResidualUpdate(bool update) { m_residual = update; }
-};
-
-}  // namespace Eigen
-
-#endif /* EIGEN_IDRS_H */
diff --git a/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h b/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h
deleted file mode 100644
index a08a71d..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h
+++ /dev/null
@@ -1,476 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl>
-// Copyright (C) 2020 Mischa Senders <m.j.senders@student.tue.nl>
-// Copyright (C) 2020 Lex Kuijpers <l.kuijpers@student.tue.nl>
-// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl>
-// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl>
-// Copyright (C) 2020 Adithya Vijaykumar
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-/*
-
-The IDR(S)Stab(L) method is a combination of IDR(S) and BiCGStab(L)
-
-This implementation of IDRSTABL is based on
-1. Aihara, K., Abe, K., & Ishiwata, E. (2014). A variant of IDRstab with
-reliable update strategies for solving sparse linear systems. Journal of
-Computational and Applied Mathematics, 259, 244-258.
-   doi:10.1016/j.cam.2013.08.028
-                2. Aihara, K., Abe, K., & Ishiwata, E. (2015). Preconditioned
-IDRSTABL Algorithms for Solving Nonsymmetric Linear Systems. International
-Journal of Applied Mathematics, 45(3).
-                3. Saad, Y. (2003). Iterative Methods for Sparse Linear Systems:
-Second Edition. Philadelphia, PA: SIAM.
-                4. Sonneveld, P., & Van Gijzen, M. B. (2009). IDR(s): A Family
-of Simple and Fast Algorithms for Solving Large Nonsymmetric Systems of Linear
-Equations. SIAM Journal on Scientific Computing, 31(2), 1035-1062.
-   doi:10.1137/070685804
-                5. Sonneveld, P. (2012). On the convergence behavior of IDR (s)
-and related methods. SIAM Journal on Scientific Computing, 34(5), A2576-A2598.
-
-    Right-preconditioning based on Ref. 3 is implemented here.
-*/
-
-#ifndef EIGEN_IDRSTABL_H
-#define EIGEN_IDRSTABL_H
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-bool idrstabl(const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters,
-              typename Dest::RealScalar &tol_error, Index L, Index S) {
-  /*
-    Setup and type definitions.
-  */
-  using numext::abs;
-  using numext::sqrt;
-  typedef typename Dest::Scalar Scalar;
-  typedef typename Dest::RealScalar RealScalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
-
-  const Index N = x.rows();
-
-  Index k = 0;  // Iteration counter
-  const Index maxIters = iters;
-
-  const RealScalar rhs_norm = rhs.stableNorm();
-  const RealScalar tol = tol_error * rhs_norm;
-
-  if (rhs_norm == 0) {
-    /*
-      If b==0, then the exact solution is x=0.
-      rhs_norm is needed for other calculations anyways, this exit is a freebie.
-    */
-    x.setZero();
-    tol_error = 0.0;
-    return true;
-  }
-  // Construct decomposition objects beforehand.
-  FullPivLU<DenseMatrixType> lu_solver;
-
-  if (S >= N || L >= N) {
-    /*
-      The matrix is very small, or the choice of L and S is very poor
-      in that case solving directly will be best.
-    */
-    lu_solver.compute(DenseMatrixType(mat));
-    x = lu_solver.solve(rhs);
-    tol_error = (rhs - mat * x).stableNorm() / rhs_norm;
-    return true;
-  }
-
-  // Define maximum sizes to prevent any reallocation later on.
-  DenseMatrixType u(N, L + 1);
-  DenseMatrixType r(N, L + 1);
-
-  DenseMatrixType V(N * (L + 1), S);
-
-  VectorType alpha(S);
-  VectorType gamma(L);
-  VectorType update(N);
-
-  /*
-    Main IDRSTABL algorithm
-  */
-  // Set up the initial residual
-  VectorType x0 = x;
-  r.col(0) = rhs - mat * x;
-  x.setZero();  // The final solution will be x0+x
-
-  tol_error = r.col(0).stableNorm();
-
-  // FOM = Full orthogonalisation method
-  DenseMatrixType h_FOM = DenseMatrixType::Zero(S, S - 1);
-
-  // Construct an initial U matrix of size N x S
-  DenseMatrixType U(N * (L + 1), S);
-  for (Index col_index = 0; col_index < S; ++col_index) {
-    // Arnoldi-like process to generate a set of orthogonal vectors spanning
-    // {u,A*u,A*A*u,...,A^(S-1)*u}. This construction can be combined with the
-    // Full Orthogonalization Method (FOM) from Ref.3 to provide a possible
-    // early exit with no additional MV.
-    if (col_index != 0) {
-      /*
-      Modified Gram-Schmidt strategy:
-      */
-      VectorType w = mat * precond.solve(u.col(0));
-      for (Index i = 0; i < col_index; ++i) {
-        auto v = U.col(i).head(N);
-        h_FOM(i, col_index - 1) = v.dot(w);
-        w -= h_FOM(i, col_index - 1) * v;
-      }
-      u.col(0) = w;
-      h_FOM(col_index, col_index - 1) = u.col(0).stableNorm();
-
-      if (abs(h_FOM(col_index, col_index - 1)) != RealScalar(0)) {
-        /*
-        This only happens if u is NOT exactly zero. In case it is exactly zero
-        it would imply that that this u has no component in the direction of the
-        current residual.
-
-        By then setting u to zero it will not contribute any further (as it
-        should). Whereas attempting to normalize results in division by zero.
-
-        Such cases occur if:
-        1. The basis of dimension <S is sufficient to exactly solve the linear
-        system. I.e. the current residual is in span{r,Ar,...A^{m-1}r}, where
-        (m-1)<=S.
-        2. Two vectors vectors generated from r, Ar,... are (numerically)
-        parallel.
-
-        In case 1, the exact solution to the system can be obtained from the
-        "Full Orthogonalization Method" (Algorithm 6.4 in the book of Saad),
-        without any additional MV.
-
-        Contrary to what one would suspect, the comparison with ==0.0 for
-        floating-point types is intended here. Any arbitrary non-zero u is fine
-        to continue, however if u contains either NaN or Inf the algorithm will
-        break down.
-        */
-        u.col(0) /= h_FOM(col_index, col_index - 1);
-      }
-    } else {
-      u.col(0) = r.col(0);
-      u.col(0).normalize();
-    }
-
-    U.col(col_index).head(N) = u.col(0);
-  }
-
-  if (S > 1) {
-    // Check for early FOM exit.
-    Scalar beta = r.col(0).stableNorm();
-    VectorType e1 = VectorType::Zero(S - 1);
-    e1(0) = beta;
-    lu_solver.compute(h_FOM.topLeftCorner(S - 1, S - 1));
-    VectorType y = lu_solver.solve(e1);
-    VectorType x2 = x + U.topLeftCorner(N, S - 1) * y;
-
-    // Using proposition 6.7 in Saad, one MV can be saved to calculate the
-    // residual
-    RealScalar FOM_residual = (h_FOM(S - 1, S - 2) * y(S - 2) * U.col(S - 1).head(N)).stableNorm();
-
-    if (FOM_residual < tol) {
-      // Exit, the FOM algorithm was already accurate enough
-      iters = k;
-      // Convert back to the unpreconditioned solution
-      x = precond.solve(x2);
-      // x contains the updates to x0, add those back to obtain the solution
-      x += x0;
-      tol_error = FOM_residual / rhs_norm;
-      return true;
-    }
-  }
-
-  /*
-    Select an initial (N x S) matrix R0.
-    1. Generate random R0, orthonormalize the result.
-    2. This results in R0, however to save memory and compute we only need the
-    adjoint of R0. This is given by the matrix R_T.\ Additionally, the matrix
-    (mat.adjoint()*R_tilde).adjoint()=R_tilde.adjoint()*mat by the
-    anti-distributivity property of the adjoint. This results in AR_T, which is
-    constant if R_T does not have to be regenerated and can be precomputed.
-    Based on reference 4, this has zero probability in exact arithmetic.
-  */
-
-  // Original IDRSTABL and Kensuke choose S random vectors:
-  const HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S));
-  DenseMatrixType R_T = (qr.householderQ() * DenseMatrixType::Identity(N, S)).adjoint();
-  DenseMatrixType AR_T = DenseMatrixType(R_T * mat);
-
-  // Pre-allocate sigma.
-  DenseMatrixType sigma(S, S);
-
-  bool reset_while = false;  // Should the while loop be reset?
-
-  while (k < maxIters) {
-    for (Index j = 1; j <= L; ++j) {
-      /*
-        The IDR Step
-      */
-      // Construction of the sigma-matrix, and the decomposition of sigma.
-      for (Index i = 0; i < S; ++i) {
-        sigma.col(i).noalias() = AR_T * precond.solve(U.block(N * (j - 1), i, N, 1));
-      }
-
-      lu_solver.compute(sigma);
-      // Obtain the update coefficients alpha
-      if (j == 1) {
-        // alpha=inverse(sigma)*(R_T*r_0);
-        alpha.noalias() = lu_solver.solve(R_T * r.col(0));
-      } else {
-        // alpha=inverse(sigma)*(AR_T*r_{j-2})
-        alpha.noalias() = lu_solver.solve(AR_T * precond.solve(r.col(j - 2)));
-      }
-
-      // Obtain new solution and residual from this update
-      update.noalias() = U.topRows(N) * alpha;
-      r.col(0) -= mat * precond.solve(update);
-      x += update;
-
-      for (Index i = 1; i <= j - 2; ++i) {
-        // This only affects the case L>2
-        r.col(i) -= U.block(N * (i + 1), 0, N, S) * alpha;
-      }
-      if (j > 1) {
-        // r=[r;A*r_{j-2}]
-        r.col(j - 1).noalias() = mat * precond.solve(r.col(j - 2));
-      }
-      tol_error = r.col(0).stableNorm();
-
-      if (tol_error < tol) {
-        // If at this point the algorithm has converged, exit.
-        reset_while = true;
-        break;
-      }
-
-      bool break_normalization = false;
-      for (Index q = 1; q <= S; ++q) {
-        if (q == 1) {
-          // u = r;
-          u.leftCols(j + 1) = r.leftCols(j + 1);
-        } else {
-          // u=[u_1;u_2;...;u_j]
-          u.leftCols(j) = u.middleCols(1, j);
-        }
-
-        // Obtain the update coefficients beta implicitly
-        // beta=lu_sigma.solve(AR_T * u.block(N * (j - 1), 0, N, 1)
-        u.reshaped().head(u.rows() * j) -= U.topRows(N * j) * lu_solver.solve(AR_T * precond.solve(u.col(j - 1)));
-
-        // u=[u;Au_{j-1}]
-        u.col(j).noalias() = mat * precond.solve(u.col(j - 1));
-
-        // Orthonormalize u_j to the columns of V_j(:,1:q-1)
-        if (q > 1) {
-          /*
-          Modified Gram-Schmidt-like procedure to make u orthogonal to the
-          columns of V from Ref. 1.
-
-          The vector mu from Ref. 1 is obtained implicitly:
-          mu=V.block(N * j, 0, N, q - 1).adjoint() * u.block(N * j, 0, N, 1).
-          */
-          for (Index i = 0; i <= q - 2; ++i) {
-            auto v = V.col(i).segment(N * j, N);
-            Scalar h = v.squaredNorm();
-            h = v.dot(u.col(j)) / h;
-            u.reshaped().head(u.rows() * (j + 1)) -= h * V.block(0, i, N * (j + 1), 1);
-          }
-        }
-        // Normalize u and assign to a column of V
-        Scalar normalization_constant = u.col(j).stableNorm();
-        //  If u is exactly zero, this will lead to a NaN. Small, non-zero u is
-        //  fine.
-        if (normalization_constant == RealScalar(0.0)) {
-          break_normalization = true;
-          break;
-        } else {
-          u.leftCols(j + 1) /= normalization_constant;
-        }
-
-        V.block(0, q - 1, N * (j + 1), 1).noalias() = u.reshaped().head(u.rows() * (j + 1));
-      }
-
-      if (break_normalization == false) {
-        U = V;
-      }
-    }
-    if (reset_while) {
-      break;
-    }
-
-    // r=[r;mat*r_{L-1}]
-    r.col(L).noalias() = mat * precond.solve(r.col(L - 1));
-
-    /*
-            The polynomial step
-    */
-    ColPivHouseholderQR<DenseMatrixType> qr_solver(r.rightCols(L));
-    gamma.noalias() = qr_solver.solve(r.col(0));
-
-    // Update solution and residual using the "minimized residual coefficients"
-    update.noalias() = r.leftCols(L) * gamma;
-    x += update;
-    r.col(0) -= mat * precond.solve(update);
-
-    // Update iteration info
-    ++k;
-    tol_error = r.col(0).stableNorm();
-
-    if (tol_error < tol) {
-      // Slightly early exit by moving the criterion before the update of U,
-      // after the main while loop the result of that calculation would not be
-      // needed.
-      break;
-    }
-
-    /*
-    U=U0-sum(gamma_j*U_j)
-    Consider the first iteration. Then U only contains U0, so at the start of
-    the while-loop U should be U0. Therefore only the first N rows of U have to
-    be updated.
-    */
-    for (Index i = 1; i <= L; ++i) {
-      U.topRows(N) -= U.block(N * i, 0, N, S) * gamma(i - 1);
-    }
-  }
-
-  /*
-          Exit after the while loop terminated.
-  */
-  iters = k;
-  // Convert back to the unpreconditioned solution
-  x = precond.solve(x);
-  // x contains the updates to x0, add those back to obtain the solution
-  x += x0;
-  tol_error = tol_error / rhs_norm;
-  return true;
-}
-
-}  // namespace internal
-
-template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar>>
-class IDRSTABL;
-
-namespace internal {
-
-template <typename MatrixType_, typename Preconditioner_>
-struct traits<IDRSTABL<MatrixType_, Preconditioner_>> {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
-};
-
-}  // namespace internal
-
-/** \ingroup IterativeLinearSolvers_Module
- * \brief The IDR(s)STAB(l) is a combination of IDR(s) and BiCGSTAB(l). It is a
- * short-recurrences Krylov method for sparse square problems. It can outperform
- * both IDR(s) and BiCGSTAB(l). IDR(s)STAB(l) generally closely follows the
- * optimal GMRES convergence in terms of the number of Matrix-Vector products.
- * However, without the increasing cost per iteration of GMRES. IDR(s)STAB(l) is
- * suitable for both indefinite systems and systems with complex eigenvalues.
- *
- * This class allows solving for A.x = b sparse linear problems. The vectors x
- * and b can be either dense or sparse.
- *
- * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a
- * sparse matrix. \tparam Preconditioner_ the type of the preconditioner.
- * Default is DiagonalPreconditioner
- *
- * \implsparsesolverconcept
- *
- * The maximum number of iterations and tolerance value can be controlled via
- * the setMaxIterations() and setTolerance() methods. The defaults are the size
- * of the problem for the maximum number of iterations and
- * NumTraits<Scalar>::epsilon() for the tolerance.
- *
- * The tolerance is the maximum relative residual error: |Ax-b|/|b| for which
- * the linear system is considered solved.
- *
- * \b Performance: When using sparse matrices, best performance is achieved for
- * a row-major sparse matrix format. Moreover, in this case multi-threading can
- * be exploited if the user code is compiled with OpenMP enabled. See \ref
- * TopicMultiThreading for details.
- *
- * By default the iterations start with x=0 as an initial guess of the solution.
- * One can control the start using the solveWithGuess() method.
- *
- * IDR(s)STAB(l) can also be used in a matrix-free context, see the following
- * \link MatrixfreeSolverExample example \endlink.
- *
- * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
- */
-
-template <typename MatrixType_, typename Preconditioner_>
-class IDRSTABL : public IterativeSolverBase<IDRSTABL<MatrixType_, Preconditioner_>> {
-  typedef IterativeSolverBase<IDRSTABL> Base;
-  using Base::m_error;
-  using Base::m_info;
-  using Base::m_isInitialized;
-  using Base::m_iterations;
-  using Base::matrix;
-  Index m_L;
-  Index m_S;
-
- public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
-
- public:
-  /** Default constructor. */
-  IDRSTABL() : m_L(2), m_S(4) {}
-
-  /**   Initialize the solver with matrix \a A for further \c Ax=b solving.
-
-  This constructor is a shortcut for the default constructor followed
-  by a call to compute().
-
-  \warning this class stores a reference to the matrix A as well as some
-  precomputed values that depend on it. Therefore, if \a A is changed
-  this class becomes invalid. Call compute() to update it with the new
-  matrix A, or modify a copy of A.
-          */
-  template <typename MatrixDerived>
-  explicit IDRSTABL(const EigenBase<MatrixDerived> &A) : Base(A.derived()), m_L(2), m_S(4) {}
-
-  /** \internal */
-  /**     Loops over the number of columns of b and does the following:
-                                  1. sets the tolerance and maxIterations
-                                  2. Calls the function that has the core solver
-     routine
-  */
-  template <typename Rhs, typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs &b, Dest &x) const {
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-    bool ret = internal::idrstabl(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_L, m_S);
-
-    m_info = (!ret) ? NumericalIssue : m_error <= 10 * Base::m_tolerance ? Success : NoConvergence;
-  }
-
-  /** Sets the parameter L, indicating the amount of minimize residual steps are
-   * used. */
-  void setL(Index L) {
-    eigen_assert(L >= 1 && "L needs to be positive");
-    m_L = L;
-  }
-  /** Sets the parameter S, indicating the dimension of the shadow residual
-   * space.. */
-  void setS(Index S) {
-    eigen_assert(S >= 1 && "S needs to be positive");
-    m_S = S;
-  }
-};
-
-}  // namespace Eigen
-
-#endif /* EIGEN_IDRSTABL_H */
diff --git a/unsupported/Eigen/src/IterativeSolvers/IncompleteLU.h b/unsupported/Eigen/src/IterativeSolvers/IncompleteLU.h
deleted file mode 100644
index 1a2edca..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/IncompleteLU.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_INCOMPLETE_LU_H
-#define EIGEN_INCOMPLETE_LU_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename Scalar_>
-class IncompleteLU : public SparseSolverBase<IncompleteLU<Scalar_> > {
- protected:
-  typedef SparseSolverBase<IncompleteLU<Scalar_> > Base;
-  using Base::m_isInitialized;
-
-  typedef Scalar_ Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> Vector;
-  typedef typename Vector::Index Index;
-  typedef SparseMatrix<Scalar, RowMajor> FactorType;
-
- public:
-  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
-
-  IncompleteLU() {}
-
-  template <typename MatrixType>
-  IncompleteLU(const MatrixType& mat) {
-    compute(mat);
-  }
-
-  Index rows() const { return m_lu.rows(); }
-  Index cols() const { return m_lu.cols(); }
-
-  template <typename MatrixType>
-  IncompleteLU& compute(const MatrixType& mat) {
-    m_lu = mat;
-    int size = mat.cols();
-    Vector diag(size);
-    for (int i = 0; i < size; ++i) {
-      typename FactorType::InnerIterator k_it(m_lu, i);
-      for (; k_it && k_it.index() < i; ++k_it) {
-        int k = k_it.index();
-        k_it.valueRef() /= diag(k);
-
-        typename FactorType::InnerIterator j_it(k_it);
-        typename FactorType::InnerIterator kj_it(m_lu, k);
-        while (kj_it && kj_it.index() <= k) ++kj_it;
-        for (++j_it; j_it;) {
-          if (kj_it.index() == j_it.index()) {
-            j_it.valueRef() -= k_it.value() * kj_it.value();
-            ++j_it;
-            ++kj_it;
-          } else if (kj_it.index() < j_it.index())
-            ++kj_it;
-          else
-            ++j_it;
-        }
-      }
-      if (k_it && k_it.index() == i)
-        diag(i) = k_it.value();
-      else
-        diag(i) = 1;
-    }
-    m_isInitialized = true;
-    return *this;
-  }
-
-  template <typename Rhs, typename Dest>
-  void _solve_impl(const Rhs& b, Dest& x) const {
-    x = m_lu.template triangularView<UnitLower>().solve(b);
-    x = m_lu.template triangularView<Upper>().solve(x);
-  }
-
- protected:
-  FactorType m_lu;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_INCOMPLETE_LU_H
diff --git a/unsupported/Eigen/src/IterativeSolvers/InternalHeaderCheck.h b/unsupported/Eigen/src/IterativeSolvers/InternalHeaderCheck.h
deleted file mode 100644
index 3d6ee41..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/InternalHeaderCheck.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef EIGEN_ITERATIVE_SOLVERS_MODULE_H
-#error \
-    "Please include unsupported/Eigen/IterativeSolvers instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/IterativeSolvers/MINRES.h b/unsupported/Eigen/src/IterativeSolvers/MINRES.h
deleted file mode 100644
index 9daf568..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/MINRES.h
+++ /dev/null
@@ -1,254 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Giacomo Po <gpo@ucla.edu>
-// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2018 David Hyde <dabh@stanford.edu>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MINRES_H
-#define EIGEN_MINRES_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \internal Low-level MINRES algorithm
- * \param mat The matrix A
- * \param rhs The right hand side vector b
- * \param x On input and initial solution, on output the computed solution.
- * \param precond A right preconditioner being able to efficiently solve for an
- *                approximation of Ax=b (regardless of b)
- * \param iters On input the max number of iteration, on output the number of performed iterations.
- * \param tol_error On input the tolerance error, on output an estimation of the relative error.
- */
-template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
-EIGEN_DONT_INLINE void minres(const MatrixType& mat, const Rhs& rhs, Dest& x, const Preconditioner& precond,
-                              Index& iters, typename Dest::RealScalar& tol_error) {
-  using std::sqrt;
-  typedef typename Dest::RealScalar RealScalar;
-  typedef typename Dest::Scalar Scalar;
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-
-  // Check for zero rhs
-  const RealScalar rhsNorm2(rhs.squaredNorm());
-  if (rhsNorm2 == 0) {
-    x.setZero();
-    iters = 0;
-    tol_error = 0;
-    return;
-  }
-
-  // initialize
-  const Index maxIters(iters);                                    // initialize maxIters to iters
-  const Index N(mat.cols());                                      // the size of the matrix
-  const RealScalar threshold2(tol_error * tol_error * rhsNorm2);  // convergence threshold (compared to residualNorm2)
-
-  // Initialize preconditioned Lanczos
-  VectorType v_old(N);                // will be initialized inside loop
-  VectorType v(VectorType::Zero(N));  // initialize v
-  VectorType v_new(rhs - mat * x);    // initialize v_new
-  RealScalar residualNorm2(v_new.squaredNorm());
-  VectorType w(N);                         // will be initialized inside loop
-  VectorType w_new(precond.solve(v_new));  // initialize w_new
-                                           //            RealScalar beta; // will be initialized inside loop
-  RealScalar beta_new2(v_new.dot(w_new));
-  eigen_assert(beta_new2 >= 0.0 && "PRECONDITIONER IS NOT POSITIVE DEFINITE");
-  RealScalar beta_new(sqrt(beta_new2));
-  const RealScalar beta_one(beta_new);
-  // Initialize other variables
-  RealScalar c(1.0);  // the cosine of the Givens rotation
-  RealScalar c_old(1.0);
-  RealScalar s(0.0);                      // the sine of the Givens rotation
-  RealScalar s_old(0.0);                  // the sine of the Givens rotation
-  VectorType p_oold(N);                   // will be initialized in loop
-  VectorType p_old(VectorType::Zero(N));  // initialize p_old=0
-  VectorType p(p_old);                    // initialize p=0
-  RealScalar eta(1.0);
-
-  iters = 0;  // reset iters
-  while (iters < maxIters) {
-    // Preconditioned Lanczos
-    /* Note that there are 4 variants on the Lanczos algorithm. These are
-     * described in Paige, C. C. (1972). Computational variants of
-     * the Lanczos method for the eigenproblem. IMA Journal of Applied
-     * Mathematics, 10(3), 373-381. The current implementation corresponds
-     * to the case A(2,7) in the paper. It also corresponds to
-     * algorithm 6.14 in Y. Saad, Iterative Methods for Sparse Linear
-     * Systems, 2003 p.173. For the preconditioned version see
-     * A. Greenbaum, Iterative Methods for Solving Linear Systems, SIAM (1987).
-     */
-    const RealScalar beta(beta_new);
-    v_old = v;          // update: at first time step, this makes v_old = 0 so value of beta doesn't matter
-    v_new /= beta_new;  // overwrite v_new for next iteration
-    w_new /= beta_new;  // overwrite w_new for next iteration
-    v = v_new;          // update
-    w = w_new;          // update
-    v_new.noalias() = mat * w - beta * v_old;  // compute v_new
-    const RealScalar alpha = v_new.dot(w);
-    v_new -= alpha * v;            // overwrite v_new
-    w_new = precond.solve(v_new);  // overwrite w_new
-    beta_new2 = v_new.dot(w_new);  // compute beta_new
-    eigen_assert(beta_new2 >= 0.0 && "PRECONDITIONER IS NOT POSITIVE DEFINITE");
-    beta_new = sqrt(beta_new2);  // compute beta_new
-
-    // Givens rotation
-    const RealScalar r2 = s * alpha + c * c_old * beta;  // s, s_old, c and c_old are still from previous iteration
-    const RealScalar r3 = s_old * beta;                  // s, s_old, c and c_old are still from previous iteration
-    const RealScalar r1_hat = c * alpha - c_old * s * beta;
-    const RealScalar r1 = sqrt(std::pow(r1_hat, 2) + std::pow(beta_new, 2));
-    c_old = c;          // store for next iteration
-    s_old = s;          // store for next iteration
-    c = r1_hat / r1;    // new cosine
-    s = beta_new / r1;  // new sine
-
-    // Update solution
-    p_oold = p_old;
-    p_old = p;
-    p.noalias() = (w - r2 * p_old - r3 * p_oold) / r1;  // IS NOALIAS REQUIRED?
-    x += beta_one * c * eta * p;
-
-    /* Update the squared residual. Note that this is the estimated residual.
-    The real residual |Ax-b|^2 may be slightly larger */
-    residualNorm2 *= s * s;
-
-    if (residualNorm2 < threshold2) {
-      break;
-    }
-
-    eta = -s * eta;  // update eta
-    iters++;         // increment iteration number (for output purposes)
-  }
-
-  /* Compute error. Note that this is the estimated error. The real
-   error |Ax-b|/|b| may be slightly larger */
-  tol_error = std::sqrt(residualNorm2 / rhsNorm2);
-}
-
-}  // namespace internal
-
-template <typename MatrixType_, int UpLo_ = Lower, typename Preconditioner_ = IdentityPreconditioner>
-class MINRES;
-
-namespace internal {
-
-template <typename MatrixType_, int UpLo_, typename Preconditioner_>
-struct traits<MINRES<MatrixType_, UpLo_, Preconditioner_> > {
-  typedef MatrixType_ MatrixType;
-  typedef Preconditioner_ Preconditioner;
-};
-
-}  // namespace internal
-
-/** \ingroup IterativeLinearSolvers_Module
- * \brief A minimal residual solver for sparse symmetric problems
- *
- * This class allows to solve for A.x = b sparse linear problems using the MINRES algorithm
- * of Paige and Saunders (1975). The sparse matrix A must be symmetric (possibly indefinite).
- * The vectors x and b can be either dense or sparse.
- *
- * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix.
- * \tparam UpLo_ the triangular part that will be used for the computations. It can be Lower,
- *               Upper, or Lower|Upper in which the full matrix entries will be considered. Default is Lower.
- * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner
- *
- * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations()
- * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations
- * and NumTraits<Scalar>::epsilon() for the tolerance.
- *
- * This class can be used as the direct solver classes. Here is a typical usage example:
- * \code
- * int n = 10000;
- * VectorXd x(n), b(n);
- * SparseMatrix<double> A(n,n);
- * // fill A and b
- * MINRES<SparseMatrix<double> > mr;
- * mr.compute(A);
- * x = mr.solve(b);
- * std::cout << "#iterations:     " << mr.iterations() << std::endl;
- * std::cout << "estimated error: " << mr.error()      << std::endl;
- * // update b, and solve again
- * x = mr.solve(b);
- * \endcode
- *
- * By default the iterations start with x=0 as an initial guess of the solution.
- * One can control the start using the solveWithGuess() method.
- *
- * MINRES can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink.
- *
- * \sa class ConjugateGradient, BiCGSTAB, SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner
- */
-template <typename MatrixType_, int UpLo_, typename Preconditioner_>
-class MINRES : public IterativeSolverBase<MINRES<MatrixType_, UpLo_, Preconditioner_> > {
-  typedef IterativeSolverBase<MINRES> Base;
-  using Base::m_error;
-  using Base::m_info;
-  using Base::m_isInitialized;
-  using Base::m_iterations;
-  using Base::matrix;
-
- public:
-  using Base::_solve_impl;
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef Preconditioner_ Preconditioner;
-
-  enum { UpLo = UpLo_ };
-
- public:
-  /** Default constructor. */
-  MINRES() : Base() {}
-
-  /** Initialize the solver with matrix \a A for further \c Ax=b solving.
-   *
-   * This constructor is a shortcut for the default constructor followed
-   * by a call to compute().
-   *
-   * \warning this class stores a reference to the matrix A as well as some
-   * precomputed values that depend on it. Therefore, if \a A is changed
-   * this class becomes invalid. Call compute() to update it with the new
-   * matrix A, or modify a copy of A.
-   */
-  template <typename MatrixDerived>
-  explicit MINRES(const EigenBase<MatrixDerived>& A) : Base(A.derived()) {}
-
-  /** Destructor. */
-  ~MINRES() {}
-
-  /** \internal */
-  template <typename Rhs, typename Dest>
-  void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const {
-    typedef typename Base::MatrixWrapper MatrixWrapper;
-    typedef typename Base::ActualMatrixType ActualMatrixType;
-    enum {
-      TransposeInput = (!MatrixWrapper::MatrixFree) && (UpLo == (Lower | Upper)) && (!MatrixType::IsRowMajor) &&
-                       (!NumTraits<Scalar>::IsComplex)
-    };
-    typedef std::conditional_t<TransposeInput, Transpose<const ActualMatrixType>, ActualMatrixType const&>
-        RowMajorWrapper;
-    EIGEN_STATIC_ASSERT(internal::check_implication(MatrixWrapper::MatrixFree, UpLo == (Lower | Upper)),
-                        MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY);
-    typedef std::conditional_t<UpLo == (Lower | Upper), RowMajorWrapper,
-                               typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type>
-        SelfAdjointWrapper;
-
-    m_iterations = Base::maxIterations();
-    m_error = Base::m_tolerance;
-    RowMajorWrapper row_mat(matrix());
-    internal::minres(SelfAdjointWrapper(row_mat), b, x, Base::m_preconditioner, m_iterations, m_error);
-    m_info = m_error <= Base::m_tolerance ? Success : NoConvergence;
-  }
-
- protected:
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MINRES_H
diff --git a/unsupported/Eigen/src/IterativeSolvers/Scaling.h b/unsupported/Eigen/src/IterativeSolvers/Scaling.h
deleted file mode 100644
index 045c24a..0000000
--- a/unsupported/Eigen/src/IterativeSolvers/Scaling.h
+++ /dev/null
@@ -1,172 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Desire NUENTSA WAKAM <desire.nuentsa_wakam@inria.fr
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_ITERSCALING_H
-#define EIGEN_ITERSCALING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/**
- * \ingroup IterativeLinearSolvers_Module
- * \brief iterative scaling algorithm to equilibrate rows and column norms in matrices
- *
- * This class can be used as a preprocessing tool to accelerate the convergence of iterative methods
- *
- * This feature is  useful to limit the pivoting amount during LU/ILU factorization
- * The  scaling strategy as presented here preserves the symmetry of the problem
- * NOTE It is assumed that the matrix does not have empty row or column,
- *
- * Example with key steps
- * \code
- * VectorXd x(n), b(n);
- * SparseMatrix<double> A;
- * // fill A and b;
- * IterScaling<SparseMatrix<double> > scal;
- * // Compute the left and right scaling vectors. The matrix is equilibrated at output
- * scal.computeRef(A);
- * // Scale the right hand side
- * b = scal.LeftScaling().cwiseProduct(b);
- * // Now, solve the equilibrated linear system with any available solver
- *
- * // Scale back the computed solution
- * x = scal.RightScaling().cwiseProduct(x);
- * \endcode
- *
- * \tparam MatrixType_ the type of the matrix. It should be a real square sparsematrix
- *
- * References : D. Ruiz and B. Ucar, A Symmetry Preserving Algorithm for Matrix Scaling, INRIA Research report RR-7552
- *
- * \sa \ref IncompleteLUT
- */
-template <typename MatrixType_>
-class IterScaling {
- public:
-  typedef MatrixType_ MatrixType;
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::Index Index;
-
- public:
-  IterScaling() { init(); }
-
-  IterScaling(const MatrixType& matrix) {
-    init();
-    compute(matrix);
-  }
-
-  ~IterScaling() {}
-
-  /**
-   * Compute the left and right diagonal matrices to scale the input matrix @p mat
-   *
-   * FIXME: This algorithm will be modified such that the diagonal elements are permuted on the diagonal.
-   *
-   * \sa LeftScaling() RightScaling()
-   */
-  void compute(const MatrixType& mat) {
-    using std::abs;
-    int m = mat.rows();
-    int n = mat.cols();
-    eigen_assert((m > 0 && m == n) && "Please give a non - empty matrix");
-    m_left.resize(m);
-    m_right.resize(n);
-    m_left.setOnes();
-    m_right.setOnes();
-    m_matrix = mat;
-    VectorXd Dr, Dc, DrRes, DcRes;  // Temporary Left and right scaling vectors
-    Dr.resize(m);
-    Dc.resize(n);
-    DrRes.resize(m);
-    DcRes.resize(n);
-    double EpsRow = 1.0, EpsCol = 1.0;
-    int its = 0;
-    do {  // Iterate until the infinite norm of each row and column is approximately 1
-      // Get the maximum value in each row and column
-      Dr.setZero();
-      Dc.setZero();
-      for (int k = 0; k < m_matrix.outerSize(); ++k) {
-        for (typename MatrixType::InnerIterator it(m_matrix, k); it; ++it) {
-          if (Dr(it.row()) < abs(it.value())) Dr(it.row()) = abs(it.value());
-
-          if (Dc(it.col()) < abs(it.value())) Dc(it.col()) = abs(it.value());
-        }
-      }
-      for (int i = 0; i < m; ++i) {
-        Dr(i) = std::sqrt(Dr(i));
-      }
-      for (int i = 0; i < n; ++i) {
-        Dc(i) = std::sqrt(Dc(i));
-      }
-      // Save the scaling factors
-      for (int i = 0; i < m; ++i) {
-        m_left(i) /= Dr(i);
-      }
-      for (int i = 0; i < n; ++i) {
-        m_right(i) /= Dc(i);
-      }
-      // Scale the rows and the columns of the matrix
-      DrRes.setZero();
-      DcRes.setZero();
-      for (int k = 0; k < m_matrix.outerSize(); ++k) {
-        for (typename MatrixType::InnerIterator it(m_matrix, k); it; ++it) {
-          it.valueRef() = it.value() / (Dr(it.row()) * Dc(it.col()));
-          // Accumulate the norms of the row and column vectors
-          if (DrRes(it.row()) < abs(it.value())) DrRes(it.row()) = abs(it.value());
-
-          if (DcRes(it.col()) < abs(it.value())) DcRes(it.col()) = abs(it.value());
-        }
-      }
-      DrRes.array() = (1 - DrRes.array()).abs();
-      EpsRow = DrRes.maxCoeff();
-      DcRes.array() = (1 - DcRes.array()).abs();
-      EpsCol = DcRes.maxCoeff();
-      its++;
-    } while ((EpsRow > m_tol || EpsCol > m_tol) && (its < m_maxits));
-    m_isInitialized = true;
-  }
-  /** Compute the left and right vectors to scale the vectors
-   * the input matrix is scaled with the computed vectors at output
-   *
-   * \sa compute()
-   */
-  void computeRef(MatrixType& mat) {
-    compute(mat);
-    mat = m_matrix;
-  }
-  /** Get the vector to scale the rows of the matrix
-   */
-  VectorXd& LeftScaling() { return m_left; }
-
-  /** Get the vector to scale the columns of the matrix
-   */
-  VectorXd& RightScaling() { return m_right; }
-
-  /** Set the tolerance for the convergence of the iterative scaling algorithm
-   */
-  void setTolerance(double tol) { m_tol = tol; }
-
- protected:
-  void init() {
-    m_tol = 1e-10;
-    m_maxits = 5;
-    m_isInitialized = false;
-  }
-
-  MatrixType m_matrix;
-  mutable ComputationInfo m_info;
-  bool m_isInitialized;
-  VectorXd m_left;   // Left scaling vector
-  VectorXd m_right;  // Right scaling vector
-  double m_tol;
-  int m_maxits;  // Maximum number of iterations allowed
-};
-}  // namespace Eigen
-#endif
diff --git a/unsupported/Eigen/src/KroneckerProduct/InternalHeaderCheck.h b/unsupported/Eigen/src/KroneckerProduct/InternalHeaderCheck.h
deleted file mode 100644
index 3cf30d9..0000000
--- a/unsupported/Eigen/src/KroneckerProduct/InternalHeaderCheck.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef EIGEN_KRONECKER_PRODUCT_MODULE_H
-#error \
-    "Please include unsupported/Eigen/KroneckerProduct instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h b/unsupported/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h
deleted file mode 100644
index 038bf42..0000000
--- a/unsupported/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h
+++ /dev/null
@@ -1,284 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Kolja Brix <brix@igpm.rwth-aachen.de>
-// Copyright (C) 2011 Andreas Platen <andiplaten@gmx.de>
-// Copyright (C) 2012 Chen-Pang He <jdh8@ms63.hinet.net>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef KRONECKER_TENSOR_PRODUCT_H
-#define KRONECKER_TENSOR_PRODUCT_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/*!
- * \ingroup KroneckerProduct_Module
- *
- * \brief The base class of dense and sparse Kronecker product.
- *
- * \tparam Derived is the derived type.
- */
-template <typename Derived>
-class KroneckerProductBase : public ReturnByValue<Derived> {
- private:
-  typedef typename internal::traits<Derived> Traits;
-  typedef typename Traits::Scalar Scalar;
-
- protected:
-  typedef typename Traits::Lhs Lhs;
-  typedef typename Traits::Rhs Rhs;
-
- public:
-  /*! \brief Constructor. */
-  KroneckerProductBase(const Lhs& A, const Rhs& B) : m_A(A), m_B(B) {}
-
-  inline Index rows() const { return m_A.rows() * m_B.rows(); }
-  inline Index cols() const { return m_A.cols() * m_B.cols(); }
-
-  /*!
-   * This overrides ReturnByValue::coeff because this function is
-   * efficient enough.
-   */
-  Scalar coeff(Index row, Index col) const {
-    return m_A.coeff(row / m_B.rows(), col / m_B.cols()) * m_B.coeff(row % m_B.rows(), col % m_B.cols());
-  }
-
-  /*!
-   * This overrides ReturnByValue::coeff because this function is
-   * efficient enough.
-   */
-  Scalar coeff(Index i) const {
-    EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
-    return m_A.coeff(i / m_A.size()) * m_B.coeff(i % m_A.size());
-  }
-
- protected:
-  typename Lhs::Nested m_A;
-  typename Rhs::Nested m_B;
-};
-
-/*!
- * \ingroup KroneckerProduct_Module
- *
- * \brief Kronecker tensor product helper class for dense matrices
- *
- * This class is the return value of kroneckerProduct(MatrixBase,
- * MatrixBase). Use the function rather than construct this class
- * directly to avoid specifying template parameters.
- *
- * \tparam Lhs  Type of the left-hand side, a matrix expression.
- * \tparam Rhs  Type of the rignt-hand side, a matrix expression.
- */
-template <typename Lhs, typename Rhs>
-class KroneckerProduct : public KroneckerProductBase<KroneckerProduct<Lhs, Rhs> > {
- private:
-  typedef KroneckerProductBase<KroneckerProduct> Base;
-  using Base::m_A;
-  using Base::m_B;
-
- public:
-  /*! \brief Constructor. */
-  KroneckerProduct(const Lhs& A, const Rhs& B) : Base(A, B) {}
-
-  /*! \brief Evaluate the Kronecker tensor product. */
-  template <typename Dest>
-  void evalTo(Dest& dst) const;
-};
-
-/*!
- * \ingroup KroneckerProduct_Module
- *
- * \brief Kronecker tensor product helper class for sparse matrices
- *
- * If at least one of the operands is a sparse matrix expression,
- * then this class is returned and evaluates into a sparse matrix.
- *
- * This class is the return value of kroneckerProduct(EigenBase,
- * EigenBase). Use the function rather than construct this class
- * directly to avoid specifying template parameters.
- *
- * \tparam Lhs  Type of the left-hand side, a matrix expression.
- * \tparam Rhs  Type of the rignt-hand side, a matrix expression.
- */
-template <typename Lhs, typename Rhs>
-class KroneckerProductSparse : public KroneckerProductBase<KroneckerProductSparse<Lhs, Rhs> > {
- private:
-  typedef KroneckerProductBase<KroneckerProductSparse> Base;
-  using Base::m_A;
-  using Base::m_B;
-
- public:
-  /*! \brief Constructor. */
-  KroneckerProductSparse(const Lhs& A, const Rhs& B) : Base(A, B) {}
-
-  /*! \brief Evaluate the Kronecker tensor product. */
-  template <typename Dest>
-  void evalTo(Dest& dst) const;
-};
-
-template <typename Lhs, typename Rhs>
-template <typename Dest>
-void KroneckerProduct<Lhs, Rhs>::evalTo(Dest& dst) const {
-  const int BlockRows = Rhs::RowsAtCompileTime, BlockCols = Rhs::ColsAtCompileTime;
-  const Index Br = m_B.rows(), Bc = m_B.cols();
-  for (Index i = 0; i < m_A.rows(); ++i)
-    for (Index j = 0; j < m_A.cols(); ++j)
-      Block<Dest, BlockRows, BlockCols>(dst, i * Br, j * Bc, Br, Bc) = m_A.coeff(i, j) * m_B;
-}
-
-template <typename Lhs, typename Rhs>
-template <typename Dest>
-void KroneckerProductSparse<Lhs, Rhs>::evalTo(Dest& dst) const {
-  Index Br = m_B.rows(), Bc = m_B.cols();
-  dst.resize(this->rows(), this->cols());
-  dst.resizeNonZeros(0);
-
-  // 1 - evaluate the operands if needed:
-  typedef typename internal::nested_eval<Lhs, Dynamic>::type Lhs1;
-  typedef internal::remove_all_t<Lhs1> Lhs1Cleaned;
-  const Lhs1 lhs1(m_A);
-  typedef typename internal::nested_eval<Rhs, Dynamic>::type Rhs1;
-  typedef internal::remove_all_t<Rhs1> Rhs1Cleaned;
-  const Rhs1 rhs1(m_B);
-
-  // 2 - construct respective iterators
-  typedef Eigen::InnerIterator<Lhs1Cleaned> LhsInnerIterator;
-  typedef Eigen::InnerIterator<Rhs1Cleaned> RhsInnerIterator;
-
-  // compute number of non-zeros per innervectors of dst
-  {
-    // TODO: VectorXi is not necessarily big enough!
-    VectorXi nnzA = VectorXi::Zero(Dest::IsRowMajor ? m_A.rows() : m_A.cols());
-    for (Index kA = 0; kA < m_A.outerSize(); ++kA)
-      for (LhsInnerIterator itA(lhs1, kA); itA; ++itA) nnzA(Dest::IsRowMajor ? itA.row() : itA.col())++;
-
-    VectorXi nnzB = VectorXi::Zero(Dest::IsRowMajor ? m_B.rows() : m_B.cols());
-    for (Index kB = 0; kB < m_B.outerSize(); ++kB)
-      for (RhsInnerIterator itB(rhs1, kB); itB; ++itB) nnzB(Dest::IsRowMajor ? itB.row() : itB.col())++;
-
-    Matrix<int, Dynamic, Dynamic, ColMajor> nnzAB = nnzB * nnzA.transpose();
-    dst.reserve(VectorXi::Map(nnzAB.data(), nnzAB.size()));
-  }
-
-  for (Index kA = 0; kA < m_A.outerSize(); ++kA) {
-    for (Index kB = 0; kB < m_B.outerSize(); ++kB) {
-      for (LhsInnerIterator itA(lhs1, kA); itA; ++itA) {
-        for (RhsInnerIterator itB(rhs1, kB); itB; ++itB) {
-          Index i = itA.row() * Br + itB.row(), j = itA.col() * Bc + itB.col();
-          dst.insert(i, j) = itA.value() * itB.value();
-        }
-      }
-    }
-  }
-}
-
-namespace internal {
-
-template <typename Lhs_, typename Rhs_>
-struct traits<KroneckerProduct<Lhs_, Rhs_> > {
-  typedef remove_all_t<Lhs_> Lhs;
-  typedef remove_all_t<Rhs_> Rhs;
-  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
-  typedef typename promote_index_type<typename Lhs::StorageIndex, typename Rhs::StorageIndex>::type StorageIndex;
-
-  enum {
-    Rows = size_at_compile_time(traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime),
-    Cols = size_at_compile_time(traits<Lhs>::ColsAtCompileTime, traits<Rhs>::ColsAtCompileTime),
-    MaxRows = size_at_compile_time(traits<Lhs>::MaxRowsAtCompileTime, traits<Rhs>::MaxRowsAtCompileTime),
-    MaxCols = size_at_compile_time(traits<Lhs>::MaxColsAtCompileTime, traits<Rhs>::MaxColsAtCompileTime)
-  };
-
-  typedef Matrix<Scalar, Rows, Cols> ReturnType;
-};
-
-template <typename Lhs_, typename Rhs_>
-struct traits<KroneckerProductSparse<Lhs_, Rhs_> > {
-  typedef MatrixXpr XprKind;
-  typedef remove_all_t<Lhs_> Lhs;
-  typedef remove_all_t<Rhs_> Rhs;
-  typedef typename ScalarBinaryOpTraits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
-  typedef typename cwise_promote_storage_type<typename traits<Lhs>::StorageKind, typename traits<Rhs>::StorageKind,
-                                              scalar_product_op<typename Lhs::Scalar, typename Rhs::Scalar> >::ret
-      StorageKind;
-  typedef typename promote_index_type<typename Lhs::StorageIndex, typename Rhs::StorageIndex>::type StorageIndex;
-
-  enum {
-    LhsFlags = Lhs::Flags,
-    RhsFlags = Rhs::Flags,
-
-    RowsAtCompileTime = size_at_compile_time(traits<Lhs>::RowsAtCompileTime, traits<Rhs>::RowsAtCompileTime),
-    ColsAtCompileTime = size_at_compile_time(traits<Lhs>::ColsAtCompileTime, traits<Rhs>::ColsAtCompileTime),
-    MaxRowsAtCompileTime = size_at_compile_time(traits<Lhs>::MaxRowsAtCompileTime, traits<Rhs>::MaxRowsAtCompileTime),
-    MaxColsAtCompileTime = size_at_compile_time(traits<Lhs>::MaxColsAtCompileTime, traits<Rhs>::MaxColsAtCompileTime),
-
-    EvalToRowMajor = (int(LhsFlags) & int(RhsFlags) & RowMajorBit),
-    RemovedBits = ~(EvalToRowMajor ? 0 : RowMajorBit),
-
-    Flags = ((int(LhsFlags) | int(RhsFlags)) & HereditaryBits & RemovedBits) | EvalBeforeNestingBit,
-    CoeffReadCost = HugeCost
-  };
-
-  typedef SparseMatrix<Scalar, 0, StorageIndex> ReturnType;
-};
-
-}  // end namespace internal
-
-/*!
- * \ingroup KroneckerProduct_Module
- *
- * Computes Kronecker tensor product of two dense matrices
- *
- * \warning If you want to replace a matrix by its Kronecker product
- *          with some matrix, do \b NOT do this:
- * \code
- * A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect
- * \endcode
- * instead, use eval() to work around this:
- * \code
- * A = kroneckerProduct(A,B).eval();
- * \endcode
- *
- * \param a  Dense matrix a
- * \param b  Dense matrix b
- * \return   Kronecker tensor product of a and b
- */
-template <typename A, typename B>
-KroneckerProduct<A, B> kroneckerProduct(const MatrixBase<A>& a, const MatrixBase<B>& b) {
-  return KroneckerProduct<A, B>(a.derived(), b.derived());
-}
-
-/*!
- * \ingroup KroneckerProduct_Module
- *
- * Computes Kronecker tensor product of two matrices, at least one of
- * which is sparse
- *
- * \warning If you want to replace a matrix by its Kronecker product
- *          with some matrix, do \b NOT do this:
- * \code
- * A = kroneckerProduct(A,B); // bug!!! caused by aliasing effect
- * \endcode
- * instead, use eval() to work around this:
- * \code
- * A = kroneckerProduct(A,B).eval();
- * \endcode
- *
- * \param a  Dense/sparse matrix a
- * \param b  Dense/sparse matrix b
- * \return   Kronecker tensor product of a and b, stored in a sparse
- *           matrix
- */
-template <typename A, typename B>
-KroneckerProductSparse<A, B> kroneckerProduct(const EigenBase<A>& a, const EigenBase<B>& b) {
-  return KroneckerProductSparse<A, B>(a.derived(), b.derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // KRONECKER_TENSOR_PRODUCT_H
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h b/unsupported/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h
deleted file mode 100644
index a9a646f..0000000
--- a/unsupported/Eigen/src/LevenbergMarquardt/InternalHeaderCheck.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef EIGEN_LEVENBERGMARQUARDT_MODULE_H
-#error \
-    "Please include unsupported/Eigen/LevenbergMarquardt instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/LMcovar.h b/unsupported/Eigen/src/LevenbergMarquardt/LMcovar.h
deleted file mode 100644
index b81d5a3..0000000
--- a/unsupported/Eigen/src/LevenbergMarquardt/LMcovar.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This code initially comes from MINPACK whose original authors are:
-// Copyright Jorge More - Argonne National Laboratory
-// Copyright Burt Garbow - Argonne National Laboratory
-// Copyright Ken Hillstrom - Argonne National Laboratory
-//
-// This Source Code Form is subject to the terms of the Minpack license
-// (a BSD-like license) described in the campaigned CopyrightMINPACK.txt file.
-
-#ifndef EIGEN_LMCOVAR_H
-#define EIGEN_LMCOVAR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void covar(Matrix<Scalar, Dynamic, Dynamic>& r, const VectorXi& ipvt,
-           Scalar tol = std::sqrt(NumTraits<Scalar>::epsilon())) {
-  using std::abs;
-  /* Local variables */
-  Index i, j, k, l, ii, jj;
-  bool sing;
-  Scalar temp;
-
-  /* Function Body */
-  const Index n = r.cols();
-  const Scalar tolr = tol * abs(r(0, 0));
-  Matrix<Scalar, Dynamic, 1> wa(n);
-  eigen_assert(ipvt.size() == n);
-
-  /* form the inverse of r in the full upper triangle of r. */
-  l = -1;
-  for (k = 0; k < n; ++k)
-    if (abs(r(k, k)) > tolr) {
-      r(k, k) = 1. / r(k, k);
-      for (j = 0; j <= k - 1; ++j) {
-        temp = r(k, k) * r(j, k);
-        r(j, k) = 0.;
-        r.col(k).head(j + 1) -= r.col(j).head(j + 1) * temp;
-      }
-      l = k;
-    }
-
-  /* form the full upper triangle of the inverse of (r transpose)*r */
-  /* in the full upper triangle of r. */
-  for (k = 0; k <= l; ++k) {
-    for (j = 0; j <= k - 1; ++j) r.col(j).head(j + 1) += r.col(k).head(j + 1) * r(j, k);
-    r.col(k).head(k + 1) *= r(k, k);
-  }
-
-  /* form the full lower triangle of the covariance matrix */
-  /* in the strict lower triangle of r and in wa. */
-  for (j = 0; j < n; ++j) {
-    jj = ipvt[j];
-    sing = j > l;
-    for (i = 0; i <= j; ++i) {
-      if (sing) r(i, j) = 0.;
-      ii = ipvt[i];
-      if (ii > jj) r(ii, jj) = r(i, j);
-      if (ii < jj) r(jj, ii) = r(i, j);
-    }
-    wa[jj] = r(j, j);
-  }
-
-  /* symmetrize the covariance matrix in r. */
-  r.topLeftCorner(n, n).template triangularView<StrictlyUpper>() = r.topLeftCorner(n, n).transpose();
-  r.diagonal() = wa;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_LMCOVAR_H
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/LMonestep.h b/unsupported/Eigen/src/LevenbergMarquardt/LMonestep.h
deleted file mode 100644
index f0697ce..0000000
--- a/unsupported/Eigen/src/LevenbergMarquardt/LMonestep.h
+++ /dev/null
@@ -1,187 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-//
-// This code initially comes from MINPACK whose original authors are:
-// Copyright Jorge More - Argonne National Laboratory
-// Copyright Burt Garbow - Argonne National Laboratory
-// Copyright Ken Hillstrom - Argonne National Laboratory
-//
-// This Source Code Form is subject to the terms of the Minpack license
-// (a BSD-like license) described in the campaigned CopyrightMINPACK.txt file.
-
-#ifndef EIGEN_LMONESTEP_H
-#define EIGEN_LMONESTEP_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename FunctorType>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::minimizeOneStep(FVectorType &x) {
-  using std::abs;
-  using std::sqrt;
-  RealScalar temp, temp1, temp2;
-  RealScalar ratio;
-  RealScalar pnorm, xnorm, fnorm1, actred, dirder, prered;
-  eigen_assert(x.size() == n);  // check the caller is not cheating us
-
-  temp = 0.0;
-  xnorm = 0.0;
-  /* calculate the jacobian matrix. */
-  Index df_ret = m_functor.df(x, m_fjac);
-  if (df_ret < 0) return LevenbergMarquardtSpace::UserAsked;
-  if (df_ret > 0)
-    // numerical diff, we evaluated the function df_ret times
-    m_nfev += df_ret;
-  else
-    m_njev++;
-
-  /* compute the qr factorization of the jacobian. */
-  for (int j = 0; j < x.size(); ++j) m_wa2(j) = m_fjac.col(j).blueNorm();
-  QRSolver qrfac(m_fjac);
-  if (qrfac.info() != Success) {
-    m_info = NumericalIssue;
-    return LevenbergMarquardtSpace::ImproperInputParameters;
-  }
-  // Make a copy of the first factor with the associated permutation
-  m_rfactor = qrfac.matrixR();
-  m_permutation = (qrfac.colsPermutation());
-
-  /* on the first iteration and if external scaling is not used, scale according */
-  /* to the norms of the columns of the initial jacobian. */
-  if (m_iter == 1) {
-    if (!m_useExternalScaling)
-      for (Index j = 0; j < n; ++j) m_diag[j] = (m_wa2[j] == 0.) ? 1. : m_wa2[j];
-
-    /* on the first iteration, calculate the norm of the scaled x */
-    /* and initialize the step bound m_delta. */
-    xnorm = m_diag.cwiseProduct(x).stableNorm();
-    m_delta = m_factor * xnorm;
-    if (m_delta == 0.) m_delta = m_factor;
-  }
-
-  /* form (q transpose)*m_fvec and store the first n components in */
-  /* m_qtf. */
-  m_wa4 = m_fvec;
-  m_wa4 = qrfac.matrixQ().adjoint() * m_fvec;
-  m_qtf = m_wa4.head(n);
-
-  /* compute the norm of the scaled gradient. */
-  m_gnorm = 0.;
-  if (m_fnorm != 0.)
-    for (Index j = 0; j < n; ++j)
-      if (m_wa2[m_permutation.indices()[j]] != 0.)
-        m_gnorm = (std::max)(m_gnorm, abs(m_rfactor.col(j).head(j + 1).dot(m_qtf.head(j + 1) / m_fnorm) /
-                                          m_wa2[m_permutation.indices()[j]]));
-
-  /* test for convergence of the gradient norm. */
-  if (m_gnorm <= m_gtol) {
-    m_info = Success;
-    return LevenbergMarquardtSpace::CosinusTooSmall;
-  }
-
-  /* rescale if necessary. */
-  if (!m_useExternalScaling) m_diag = m_diag.cwiseMax(m_wa2);
-
-  do {
-    /* determine the levenberg-marquardt parameter. */
-    internal::lmpar2(qrfac, m_diag, m_qtf, m_delta, m_par, m_wa1);
-
-    /* store the direction p and x + p. calculate the norm of p. */
-    m_wa1 = -m_wa1;
-    m_wa2 = x + m_wa1;
-    pnorm = m_diag.cwiseProduct(m_wa1).stableNorm();
-
-    /* on the first iteration, adjust the initial step bound. */
-    if (m_iter == 1) m_delta = (std::min)(m_delta, pnorm);
-
-    /* evaluate the function at x + p and calculate its norm. */
-    if (m_functor(m_wa2, m_wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
-    ++m_nfev;
-    fnorm1 = m_wa4.stableNorm();
-
-    /* compute the scaled actual reduction. */
-    actred = -1.;
-    if (Scalar(.1) * fnorm1 < m_fnorm) actred = 1. - numext::abs2(fnorm1 / m_fnorm);
-
-    /* compute the scaled predicted reduction and */
-    /* the scaled directional derivative. */
-    m_wa3 = m_rfactor.template triangularView<Upper>() * (m_permutation.inverse() * m_wa1);
-    temp1 = numext::abs2(m_wa3.stableNorm() / m_fnorm);
-    temp2 = numext::abs2(sqrt(m_par) * pnorm / m_fnorm);
-    prered = temp1 + temp2 / Scalar(.5);
-    dirder = -(temp1 + temp2);
-
-    /* compute the ratio of the actual to the predicted */
-    /* reduction. */
-    ratio = 0.;
-    if (prered != 0.) ratio = actred / prered;
-
-    /* update the step bound. */
-    if (ratio <= Scalar(.25)) {
-      if (actred >= 0.) temp = RealScalar(.5);
-      if (actred < 0.) temp = RealScalar(.5) * dirder / (dirder + RealScalar(.5) * actred);
-      if (RealScalar(.1) * fnorm1 >= m_fnorm || temp < RealScalar(.1)) temp = Scalar(.1);
-      /* Computing MIN */
-      m_delta = temp * (std::min)(m_delta, pnorm / RealScalar(.1));
-      m_par /= temp;
-    } else if (!(m_par != 0. && ratio < RealScalar(.75))) {
-      m_delta = pnorm / RealScalar(.5);
-      m_par = RealScalar(.5) * m_par;
-    }
-
-    /* test for successful iteration. */
-    if (ratio >= RealScalar(1e-4)) {
-      /* successful iteration. update x, m_fvec, and their norms. */
-      x = m_wa2;
-      m_wa2 = m_diag.cwiseProduct(x);
-      m_fvec = m_wa4;
-      xnorm = m_wa2.stableNorm();
-      m_fnorm = fnorm1;
-      ++m_iter;
-    }
-
-    /* tests for convergence. */
-    if (abs(actred) <= m_ftol && prered <= m_ftol && Scalar(.5) * ratio <= 1. && m_delta <= m_xtol * xnorm) {
-      m_info = Success;
-      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
-    }
-    if (abs(actred) <= m_ftol && prered <= m_ftol && Scalar(.5) * ratio <= 1.) {
-      m_info = Success;
-      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
-    }
-    if (m_delta <= m_xtol * xnorm) {
-      m_info = Success;
-      return LevenbergMarquardtSpace::RelativeErrorTooSmall;
-    }
-
-    /* tests for termination and stringent tolerances. */
-    if (m_nfev >= m_maxfev) {
-      m_info = NoConvergence;
-      return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
-    }
-    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
-        Scalar(.5) * ratio <= 1.) {
-      m_info = Success;
-      return LevenbergMarquardtSpace::FtolTooSmall;
-    }
-    if (m_delta <= NumTraits<Scalar>::epsilon() * xnorm) {
-      m_info = Success;
-      return LevenbergMarquardtSpace::XtolTooSmall;
-    }
-    if (m_gnorm <= NumTraits<Scalar>::epsilon()) {
-      m_info = Success;
-      return LevenbergMarquardtSpace::GtolTooSmall;
-    }
-
-  } while (ratio < Scalar(1e-4));
-
-  return LevenbergMarquardtSpace::Running;
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_LMONESTEP_H
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/LMpar.h b/unsupported/Eigen/src/LevenbergMarquardt/LMpar.h
deleted file mode 100644
index 75ca4e8..0000000
--- a/unsupported/Eigen/src/LevenbergMarquardt/LMpar.h
+++ /dev/null
@@ -1,146 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This code initially comes from MINPACK whose original authors are:
-// Copyright Jorge More - Argonne National Laboratory
-// Copyright Burt Garbow - Argonne National Laboratory
-// Copyright Ken Hillstrom - Argonne National Laboratory
-//
-// This Source Code Form is subject to the terms of the Minpack license
-// (a BSD-like license) described in the campaigned CopyrightMINPACK.txt file.
-
-#ifndef EIGEN_LMPAR_H
-#define EIGEN_LMPAR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename QRSolver, typename VectorType>
-void lmpar2(const QRSolver &qr, const VectorType &diag, const VectorType &qtb, typename VectorType::Scalar m_delta,
-            typename VectorType::Scalar &par, VectorType &x)
-
-{
-  using std::abs;
-  using std::sqrt;
-  typedef typename QRSolver::MatrixType MatrixType;
-  typedef typename QRSolver::Scalar Scalar;
-  /* Local variables */
-  Index j;
-  Scalar fp;
-  Scalar parc, parl;
-  Index iter;
-  Scalar temp, paru;
-  Scalar gnorm;
-  Scalar dxnorm;
-
-  // Make a copy of the triangular factor.
-  // This copy is modified during call the qrsolv
-  MatrixType s;
-  s = qr.matrixR();
-
-  /* Function Body */
-  const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
-  const Index n = qr.matrixR().cols();
-  eigen_assert(n == diag.size());
-  eigen_assert(n == qtb.size());
-
-  VectorType wa1, wa2;
-
-  /* compute and store in x the gauss-newton direction. if the */
-  /* jacobian is rank-deficient, obtain a least squares solution. */
-
-  const Index rank = qr.rank();  // use a threshold
-  wa1 = qtb;
-  wa1.tail(n - rank).setZero();
-  // FIXME: There is no solve-in-place for sparse triangularView.
-  wa1.head(rank) = s.topLeftCorner(rank, rank).template triangularView<Upper>().solve(qtb.head(rank));
-
-  x = qr.colsPermutation() * wa1;
-
-  /* initialize the iteration counter. */
-  /* evaluate the function at the origin, and test */
-  /* for acceptance of the gauss-newton direction. */
-  iter = 0;
-  wa2 = diag.cwiseProduct(x);
-  dxnorm = wa2.blueNorm();
-  fp = dxnorm - m_delta;
-  if (fp <= Scalar(0.1) * m_delta) {
-    par = 0;
-    return;
-  }
-
-  /* if the jacobian is not rank deficient, the newton */
-  /* step provides a lower bound, parl, for the zero of */
-  /* the function. otherwise set this bound to zero. */
-  parl = 0.;
-  if (rank == n) {
-    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2) / dxnorm;
-    s.topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
-    temp = wa1.blueNorm();
-    parl = fp / m_delta / temp / temp;
-  }
-
-  /* calculate an upper bound, paru, for the zero of the function. */
-  for (j = 0; j < n; ++j) wa1[j] = s.col(j).head(j + 1).dot(qtb.head(j + 1)) / diag[qr.colsPermutation().indices()(j)];
-
-  gnorm = wa1.stableNorm();
-  paru = gnorm / m_delta;
-  if (paru == 0.) paru = dwarf / (std::min)(m_delta, Scalar(0.1));
-
-  /* if the input par lies outside of the interval (parl,paru), */
-  /* set par to the closer endpoint. */
-  par = (std::max)(par, parl);
-  par = (std::min)(par, paru);
-  if (par == 0.) par = gnorm / dxnorm;
-
-  /* beginning of an iteration. */
-  while (true) {
-    ++iter;
-
-    /* evaluate the function at the current value of par. */
-    if (par == 0.) par = (std::max)(dwarf, Scalar(.001) * paru); /* Computing MAX */
-    wa1 = sqrt(par) * diag;
-
-    VectorType sdiag(n);
-    lmqrsolv(s, qr.colsPermutation(), wa1, qtb, x, sdiag);
-
-    wa2 = diag.cwiseProduct(x);
-    dxnorm = wa2.blueNorm();
-    temp = fp;
-    fp = dxnorm - m_delta;
-
-    /* if the function is small enough, accept the current value */
-    /* of par. also test for the exceptional cases where parl */
-    /* is zero or the number of iterations has reached 10. */
-    if (abs(fp) <= Scalar(0.1) * m_delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10) break;
-
-    /* compute the newton correction. */
-    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2 / dxnorm);
-    // we could almost use this here, but the diagonal is outside qr, in sdiag[]
-    for (j = 0; j < n; ++j) {
-      wa1[j] /= sdiag[j];
-      temp = wa1[j];
-      for (Index i = j + 1; i < n; ++i) wa1[i] -= s.coeff(i, j) * temp;
-    }
-    temp = wa1.blueNorm();
-    parc = fp / m_delta / temp / temp;
-
-    /* depending on the sign of the function, update parl or paru. */
-    if (fp > 0.) parl = (std::max)(parl, par);
-    if (fp < 0.) paru = (std::min)(paru, par);
-
-    /* compute an improved estimate for par. */
-    par = (std::max)(parl, par + parc);
-  }
-  if (iter == 0) par = 0.;
-  return;
-}
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_LMPAR_H
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/LMqrsolv.h b/unsupported/Eigen/src/LevenbergMarquardt/LMqrsolv.h
deleted file mode 100644
index 49bf6e1..0000000
--- a/unsupported/Eigen/src/LevenbergMarquardt/LMqrsolv.h
+++ /dev/null
@@ -1,178 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
-//
-// This code initially comes from MINPACK whose original authors are:
-// Copyright Jorge More - Argonne National Laboratory
-// Copyright Burt Garbow - Argonne National Laboratory
-// Copyright Ken Hillstrom - Argonne National Laboratory
-//
-// This Source Code Form is subject to the terms of the Minpack license
-// (a BSD-like license) described in the campaigned CopyrightMINPACK.txt file.
-
-#ifndef EIGEN_LMQRSOLV_H
-#define EIGEN_LMQRSOLV_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar, int Rows, int Cols, typename PermIndex>
-void lmqrsolv(Matrix<Scalar, Rows, Cols> &s, const PermutationMatrix<Dynamic, Dynamic, PermIndex> &iPerm,
-              const Matrix<Scalar, Dynamic, 1> &diag, const Matrix<Scalar, Dynamic, 1> &qtb,
-              Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &sdiag) {
-  /* Local variables */
-  Index i, j, k;
-  Scalar temp;
-  Index n = s.cols();
-  Matrix<Scalar, Dynamic, 1> wa(n);
-  JacobiRotation<Scalar> givens;
-
-  /* Function Body */
-  // the following will only change the lower triangular part of s, including
-  // the diagonal, though the diagonal is restored afterward
-
-  /*     copy r and (q transpose)*b to preserve input and initialize s. */
-  /*     in particular, save the diagonal elements of r in x. */
-  x = s.diagonal();
-  wa = qtb;
-
-  s.topLeftCorner(n, n).template triangularView<StrictlyLower>() = s.topLeftCorner(n, n).transpose();
-  /*     eliminate the diagonal matrix d using a givens rotation. */
-  for (j = 0; j < n; ++j) {
-    /*        prepare the row of d to be eliminated, locating the */
-    /*        diagonal element using p from the qr factorization. */
-    const PermIndex l = iPerm.indices()(j);
-    if (diag[l] == 0.) break;
-    sdiag.tail(n - j).setZero();
-    sdiag[j] = diag[l];
-
-    /*        the transformations to eliminate the row of d */
-    /*        modify only a single element of (q transpose)*b */
-    /*        beyond the first n, which is initially zero. */
-    Scalar qtbpj = 0.;
-    for (k = j; k < n; ++k) {
-      /*           determine a givens rotation which eliminates the */
-      /*           appropriate element in the current row of d. */
-      givens.makeGivens(-s(k, k), sdiag[k]);
-
-      /*           compute the modified diagonal element of r and */
-      /*           the modified element of ((q transpose)*b,0). */
-      s(k, k) = givens.c() * s(k, k) + givens.s() * sdiag[k];
-      temp = givens.c() * wa[k] + givens.s() * qtbpj;
-      qtbpj = -givens.s() * wa[k] + givens.c() * qtbpj;
-      wa[k] = temp;
-
-      /*           accumulate the transformation in the row of s. */
-      for (i = k + 1; i < n; ++i) {
-        temp = givens.c() * s(i, k) + givens.s() * sdiag[i];
-        sdiag[i] = -givens.s() * s(i, k) + givens.c() * sdiag[i];
-        s(i, k) = temp;
-      }
-    }
-  }
-
-  /*     solve the triangular system for z. if the system is */
-  /*     singular, then obtain a least squares solution. */
-  Index nsing;
-  for (nsing = 0; nsing < n && sdiag[nsing] != 0; nsing++) {
-  }
-
-  wa.tail(n - nsing).setZero();
-  s.topLeftCorner(nsing, nsing).transpose().template triangularView<Upper>().solveInPlace(wa.head(nsing));
-
-  // restore
-  sdiag = s.diagonal();
-  s.diagonal() = x;
-
-  /* permute the components of z back to components of x. */
-  x = iPerm * wa;
-}
-
-template <typename Scalar, int Options_, typename Index>
-void lmqrsolv(SparseMatrix<Scalar, Options_, Index> &s, const PermutationMatrix<Dynamic, Dynamic> &iPerm,
-              const Matrix<Scalar, Dynamic, 1> &diag, const Matrix<Scalar, Dynamic, 1> &qtb,
-              Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &sdiag) {
-  /* Local variables */
-  typedef SparseMatrix<Scalar, RowMajor, Index> FactorType;
-  Index i, j, k, l;
-  Scalar temp;
-  Index n = s.cols();
-  Matrix<Scalar, Dynamic, 1> wa(n);
-  JacobiRotation<Scalar> givens;
-
-  /* Function Body */
-  // the following will only change the lower triangular part of s, including
-  // the diagonal, though the diagonal is restored afterward
-
-  /*     copy r and (q transpose)*b to preserve input and initialize R. */
-  wa = qtb;
-  FactorType R(s);
-  // Eliminate the diagonal matrix d using a givens rotation
-  for (j = 0; j < n; ++j) {
-    // Prepare the row of d to be eliminated, locating the
-    // diagonal element using p from the qr factorization
-    l = iPerm.indices()(j);
-    if (diag(l) == Scalar(0)) break;
-    sdiag.tail(n - j).setZero();
-    sdiag[j] = diag[l];
-    // the transformations to eliminate the row of d
-    // modify only a single element of (q transpose)*b
-    // beyond the first n, which is initially zero.
-
-    Scalar qtbpj = 0;
-    // Browse the nonzero elements of row j of the upper triangular s
-    for (k = j; k < n; ++k) {
-      typename FactorType::InnerIterator itk(R, k);
-      for (; itk; ++itk) {
-        if (itk.index() < k)
-          continue;
-        else
-          break;
-      }
-      // At this point, we have the diagonal element R(k,k)
-      //  Determine a givens rotation which eliminates
-      //  the appropriate element in the current row of d
-      givens.makeGivens(-itk.value(), sdiag(k));
-
-      // Compute the modified diagonal element of r and
-      // the modified element of ((q transpose)*b,0).
-      itk.valueRef() = givens.c() * itk.value() + givens.s() * sdiag(k);
-      temp = givens.c() * wa(k) + givens.s() * qtbpj;
-      qtbpj = -givens.s() * wa(k) + givens.c() * qtbpj;
-      wa(k) = temp;
-
-      // Accumulate the transformation in the remaining k row/column of R
-      for (++itk; itk; ++itk) {
-        i = itk.index();
-        temp = givens.c() * itk.value() + givens.s() * sdiag(i);
-        sdiag(i) = -givens.s() * itk.value() + givens.c() * sdiag(i);
-        itk.valueRef() = temp;
-      }
-    }
-  }
-
-  // Solve the triangular system for z. If the system is
-  // singular, then obtain a least squares solution
-  Index nsing;
-  for (nsing = 0; nsing < n && sdiag(nsing) != 0; nsing++) {
-  }
-
-  wa.tail(n - nsing).setZero();
-  //     x = wa;
-  wa.head(nsing) = R.topLeftCorner(nsing, nsing).template triangularView<Upper>().solve /*InPlace*/ (wa.head(nsing));
-
-  sdiag = R.diagonal();
-  // Permute the components of z back to components of x
-  x = iPerm * wa;
-}
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_LMQRSOLV_H
diff --git a/unsupported/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h b/unsupported/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h
deleted file mode 100644
index eea424c..0000000
--- a/unsupported/Eigen/src/LevenbergMarquardt/LevenbergMarquardt.h
+++ /dev/null
@@ -1,360 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-// Copyright (C) 2012 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
-//
-// The algorithm of this class initially comes from MINPACK whose original authors are:
-// Copyright Jorge More - Argonne National Laboratory
-// Copyright Burt Garbow - Argonne National Laboratory
-// Copyright Ken Hillstrom - Argonne National Laboratory
-//
-// This Source Code Form is subject to the terms of the Minpack license
-// (a BSD-like license) described in the campaigned CopyrightMINPACK.txt file.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_LEVENBERGMARQUARDT_H
-#define EIGEN_LEVENBERGMARQUARDT_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace LevenbergMarquardtSpace {
-enum Status {
-  NotStarted = -2,
-  Running = -1,
-  ImproperInputParameters = 0,
-  RelativeReductionTooSmall = 1,
-  RelativeErrorTooSmall = 2,
-  RelativeErrorAndReductionTooSmall = 3,
-  CosinusTooSmall = 4,
-  TooManyFunctionEvaluation = 5,
-  FtolTooSmall = 6,
-  XtolTooSmall = 7,
-  GtolTooSmall = 8,
-  UserAsked = 9
-};
-}
-
-template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
-struct DenseFunctor {
-  typedef Scalar_ Scalar;
-  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-  typedef ColPivHouseholderQR<JacobianType> QRSolver;
-  const int m_inputs, m_values;
-
-  DenseFunctor() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
-  DenseFunctor(int inputs, int values) : m_inputs(inputs), m_values(values) {}
-
-  int inputs() const { return m_inputs; }
-  int values() const { return m_values; }
-
-  // int operator()(const InputType &x, ValueType& fvec) { }
-  //  should be defined in derived classes
-
-  // int df(const InputType &x, JacobianType& fjac) { }
-  //  should be defined in derived classes
-};
-
-template <typename Scalar_, typename Index_>
-struct SparseFunctor {
-  typedef Scalar_ Scalar;
-  typedef Index_ Index;
-  typedef Matrix<Scalar, Dynamic, 1> InputType;
-  typedef Matrix<Scalar, Dynamic, 1> ValueType;
-  typedef SparseMatrix<Scalar, ColMajor, Index> JacobianType;
-  typedef SparseQR<JacobianType, COLAMDOrdering<int> > QRSolver;
-  enum { InputsAtCompileTime = Dynamic, ValuesAtCompileTime = Dynamic };
-
-  SparseFunctor(int inputs, int values) : m_inputs(inputs), m_values(values) {}
-
-  int inputs() const { return m_inputs; }
-  int values() const { return m_values; }
-
-  const int m_inputs, m_values;
-  // int operator()(const InputType &x, ValueType& fvec) { }
-  //  to be defined in the functor
-
-  // int df(const InputType &x, JacobianType& fjac) { }
-  //  to be defined in the functor if no automatic differentiation
-};
-namespace internal {
-template <typename QRSolver, typename VectorType>
-void lmpar2(const QRSolver &qr, const VectorType &diag, const VectorType &qtb, typename VectorType::Scalar m_delta,
-            typename VectorType::Scalar &par, VectorType &x);
-}
-/**
- * \ingroup NonLinearOptimization_Module
- * \brief Performs non linear optimization over a non-linear function,
- * using a variant of the Levenberg Marquardt algorithm.
- *
- * Check wikipedia for more information.
- * http://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm
- */
-template <typename FunctorType_>
-class LevenbergMarquardt : internal::no_assignment_operator {
- public:
-  typedef FunctorType_ FunctorType;
-  typedef typename FunctorType::QRSolver QRSolver;
-  typedef typename FunctorType::JacobianType JacobianType;
-  typedef typename JacobianType::Scalar Scalar;
-  typedef typename JacobianType::RealScalar RealScalar;
-  typedef typename QRSolver::StorageIndex PermIndex;
-  typedef Matrix<Scalar, Dynamic, 1> FVectorType;
-  typedef PermutationMatrix<Dynamic, Dynamic, int> PermutationType;
-
- public:
-  LevenbergMarquardt(FunctorType &functor)
-      : m_functor(functor),
-        m_nfev(0),
-        m_njev(0),
-        m_fnorm(0.0),
-        m_gnorm(0),
-        m_isInitialized(false),
-        m_info(InvalidInput) {
-    resetParameters();
-    m_useExternalScaling = false;
-  }
-
-  LevenbergMarquardtSpace::Status minimize(FVectorType &x);
-  LevenbergMarquardtSpace::Status minimizeInit(FVectorType &x);
-  LevenbergMarquardtSpace::Status minimizeOneStep(FVectorType &x);
-  LevenbergMarquardtSpace::Status lmder1(FVectorType &x, const Scalar tol = std::sqrt(NumTraits<Scalar>::epsilon()));
-  static LevenbergMarquardtSpace::Status lmdif1(FunctorType &functor, FVectorType &x, Index *nfev,
-                                                const Scalar tol = std::sqrt(NumTraits<Scalar>::epsilon()));
-
-  /** Sets the default parameters */
-  void resetParameters() {
-    using std::sqrt;
-
-    m_factor = 100.;
-    m_maxfev = 400;
-    m_ftol = sqrt(NumTraits<RealScalar>::epsilon());
-    m_xtol = sqrt(NumTraits<RealScalar>::epsilon());
-    m_gtol = 0.;
-    m_epsfcn = 0.;
-  }
-
-  /** Sets the tolerance for the norm of the solution vector*/
-  void setXtol(RealScalar xtol) { m_xtol = xtol; }
-
-  /** Sets the tolerance for the norm of the vector function*/
-  void setFtol(RealScalar ftol) { m_ftol = ftol; }
-
-  /** Sets the tolerance for the norm of the gradient of the error vector*/
-  void setGtol(RealScalar gtol) { m_gtol = gtol; }
-
-  /** Sets the step bound for the diagonal shift */
-  void setFactor(RealScalar factor) { m_factor = factor; }
-
-  /** Sets the error precision  */
-  void setEpsilon(RealScalar epsfcn) { m_epsfcn = epsfcn; }
-
-  /** Sets the maximum number of function evaluation */
-  void setMaxfev(Index maxfev) { m_maxfev = maxfev; }
-
-  /** Use an external Scaling. If set to true, pass a nonzero diagonal to diag() */
-  void setExternalScaling(bool value) { m_useExternalScaling = value; }
-
-  /** \returns the tolerance for the norm of the solution vector */
-  RealScalar xtol() const { return m_xtol; }
-
-  /** \returns the tolerance for the norm of the vector function */
-  RealScalar ftol() const { return m_ftol; }
-
-  /** \returns the tolerance for the norm of the gradient of the error vector */
-  RealScalar gtol() const { return m_gtol; }
-
-  /** \returns the step bound for the diagonal shift */
-  RealScalar factor() const { return m_factor; }
-
-  /** \returns the error precision */
-  RealScalar epsilon() const { return m_epsfcn; }
-
-  /** \returns the maximum number of function evaluation */
-  Index maxfev() const { return m_maxfev; }
-
-  /** \returns a reference to the diagonal of the jacobian */
-  FVectorType &diag() { return m_diag; }
-
-  /** \returns the number of iterations performed */
-  Index iterations() const { return m_iter; }
-
-  /** \returns the number of functions evaluation */
-  Index nfev() const { return m_nfev; }
-
-  /** \returns the number of jacobian evaluation */
-  Index njev() const { return m_njev; }
-
-  /** \returns the norm of current vector function */
-  RealScalar fnorm() const { return m_fnorm; }
-
-  /** \returns the norm of the gradient of the error */
-  RealScalar gnorm() const { return m_gnorm; }
-
-  /** \returns the LevenbergMarquardt parameter */
-  RealScalar lm_param(void) const { return m_par; }
-
-  /** \returns a reference to the  current vector function
-   */
-  FVectorType &fvec() { return m_fvec; }
-
-  /** \returns a reference to the matrix where the current Jacobian matrix is stored
-   */
-  JacobianType &jacobian() { return m_fjac; }
-
-  /** \returns a reference to the triangular matrix R from the QR of the jacobian matrix.
-   * \sa jacobian()
-   */
-  JacobianType &matrixR() { return m_rfactor; }
-
-  /** the permutation used in the QR factorization
-   */
-  PermutationType permutation() const { return m_permutation; }
-
-  /**
-   * \brief Reports whether the minimization was successful
-   * \returns \c Success if the minimization was successful,
-   *         \c NumericalIssue if a numerical problem arises during the
-   *          minimization process, for example during the QR factorization
-   *         \c NoConvergence if the minimization did not converge after
-   *          the maximum number of function evaluation allowed
-   *          \c InvalidInput if the input matrix is invalid
-   */
-  ComputationInfo info() const { return m_info; }
-
- private:
-  JacobianType m_fjac;
-  JacobianType m_rfactor;  // The triangular matrix R from the QR of the jacobian matrix m_fjac
-  FunctorType &m_functor;
-  FVectorType m_fvec, m_qtf, m_diag;
-  Index n;
-  Index m;
-  Index m_nfev;
-  Index m_njev;
-  RealScalar m_fnorm;   // Norm of the current vector function
-  RealScalar m_gnorm;   // Norm of the gradient of the error
-  RealScalar m_factor;  //
-  Index m_maxfev;       // Maximum number of function evaluation
-  RealScalar m_ftol;    // Tolerance in the norm of the vector function
-  RealScalar m_xtol;    //
-  RealScalar m_gtol;    // tolerance of the norm of the error gradient
-  RealScalar m_epsfcn;  //
-  Index m_iter;         // Number of iterations performed
-  RealScalar m_delta;
-  bool m_useExternalScaling;
-  PermutationType m_permutation;
-  FVectorType m_wa1, m_wa2, m_wa3, m_wa4;  // Temporary vectors
-  RealScalar m_par;
-  bool m_isInitialized;  // Check whether the minimization step has been called
-  ComputationInfo m_info;
-};
-
-template <typename FunctorType>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::minimize(FVectorType &x) {
-  LevenbergMarquardtSpace::Status status = minimizeInit(x);
-  if (status == LevenbergMarquardtSpace::ImproperInputParameters) {
-    m_isInitialized = true;
-    return status;
-  }
-  do {
-    status = minimizeOneStep(x);
-  } while (status == LevenbergMarquardtSpace::Running);
-  m_isInitialized = true;
-  return status;
-}
-
-template <typename FunctorType>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::minimizeInit(FVectorType &x) {
-  n = x.size();
-  m = m_functor.values();
-
-  m_wa1.resize(n);
-  m_wa2.resize(n);
-  m_wa3.resize(n);
-  m_wa4.resize(m);
-  m_fvec.resize(m);
-  // FIXME: Sparse case: allocate space for the Jacobian.
-  m_fjac.resize(m, n);
-  if (!m_useExternalScaling) m_diag.resize(n);
-  eigen_assert((!m_useExternalScaling || m_diag.size() == n) &&
-               "When m_useExternalScaling is set, the caller must provide a valid 'm_diag'");
-  m_qtf.resize(n);
-
-  /* Function Body */
-  m_nfev = 0;
-  m_njev = 0;
-
-  /*     check the input parameters for errors. */
-  if (n <= 0 || m < n || m_ftol < 0. || m_xtol < 0. || m_gtol < 0. || m_maxfev <= 0 || m_factor <= 0.) {
-    m_info = InvalidInput;
-    return LevenbergMarquardtSpace::ImproperInputParameters;
-  }
-
-  if (m_useExternalScaling)
-    for (Index j = 0; j < n; ++j)
-      if (m_diag[j] <= 0.) {
-        m_info = InvalidInput;
-        return LevenbergMarquardtSpace::ImproperInputParameters;
-      }
-
-  /*     evaluate the function at the starting point */
-  /*     and calculate its norm. */
-  m_nfev = 1;
-  if (m_functor(x, m_fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
-  m_fnorm = m_fvec.stableNorm();
-
-  /*     initialize levenberg-marquardt parameter and iteration counter. */
-  m_par = 0.;
-  m_iter = 1;
-
-  return LevenbergMarquardtSpace::NotStarted;
-}
-
-template <typename FunctorType>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::lmder1(FVectorType &x, const Scalar tol) {
-  n = x.size();
-  m = m_functor.values();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  resetParameters();
-  m_ftol = tol;
-  m_xtol = tol;
-  m_maxfev = 100 * (n + 1);
-
-  return minimize(x);
-}
-
-template <typename FunctorType>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType>::lmdif1(FunctorType &functor, FVectorType &x,
-                                                                        Index *nfev, const Scalar tol) {
-  Index n = x.size();
-  Index m = functor.values();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  NumericalDiff<FunctorType> numDiff(functor);
-  // embedded LevenbergMarquardt
-  LevenbergMarquardt<NumericalDiff<FunctorType> > lm(numDiff);
-  lm.setFtol(tol);
-  lm.setXtol(tol);
-  lm.setMaxfev(200 * (n + 1));
-
-  LevenbergMarquardtSpace::Status info = LevenbergMarquardtSpace::Status(lm.minimize(x));
-  if (nfev) *nfev = lm.nfev();
-  return info;
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_LEVENBERGMARQUARDT_H
diff --git a/unsupported/Eigen/src/MatrixFunctions/InternalHeaderCheck.h b/unsupported/Eigen/src/MatrixFunctions/InternalHeaderCheck.h
deleted file mode 100644
index 4fc840e..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/InternalHeaderCheck.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef EIGEN_MATRIX_FUNCTIONS_MODULE_H
-#error \
-    "Please include unsupported/Eigen/MatrixFunctions instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h b/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
deleted file mode 100644
index f4e0428..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
+++ /dev/null
@@ -1,457 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009, 2010, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
-// Copyright (C) 2011, 2013 Chen-Pang He <jdh8@ms63.hinet.net>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MATRIX_EXPONENTIAL
-#define EIGEN_MATRIX_EXPONENTIAL
-
-#include "StemFunction.h"
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-/** \brief Scaling operator.
- *
- * This struct is used by CwiseUnaryOp to scale a matrix by \f$ 2^{-s} \f$.
- */
-template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
-struct MatrixExponentialScalingOp {
-  using RealScalar = typename NumTraits<Scalar>::Real;
-
-  /** \brief Constructor.
-   *
-   * \param[in] squarings  The integer \f$ s \f$ in this document.
-   */
-  MatrixExponentialScalingOp(int squarings) : m_squarings(squarings) {}
-
-  /** \brief Scale a matrix coefficient.
-   *
-   * \param[in,out] x  The scalar to be scaled, becoming \f$ 2^{-s} x \f$.
-   */
-  inline const Scalar operator()(const Scalar& x) const {
-    using std::ldexp;
-    return Scalar(ldexp(Eigen::numext::real(x), -m_squarings), ldexp(Eigen::numext::imag(x), -m_squarings));
-  }
-
- private:
-  int m_squarings;
-};
-
-template <typename Scalar>
-struct MatrixExponentialScalingOp<Scalar, /*IsComplex=*/false> {
-  /** \brief Constructor.
-   *
-   * \param[in] squarings  The integer \f$ s \f$ in this document.
-   */
-  MatrixExponentialScalingOp(int squarings) : m_squarings(squarings) {}
-
-  /** \brief Scale a matrix coefficient.
-   *
-   * \param[in,out] x  The scalar to be scaled, becoming \f$ 2^{-s} x \f$.
-   */
-  inline const Scalar operator()(const Scalar& x) const {
-    using std::ldexp;
-    return ldexp(x, -m_squarings);
-  }
-
- private:
-  int m_squarings;
-};
-
-/** \brief Compute the (3,3)-Pad&eacute; approximant to the exponential.
- *
- *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
- *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
- */
-template <typename MatA, typename MatU, typename MatV>
-void matrix_exp_pade3(const MatA& A, MatU& U, MatV& V) {
-  typedef typename MatA::PlainObject MatrixType;
-  typedef typename NumTraits<typename traits<MatA>::Scalar>::Real RealScalar;
-  const RealScalar b[] = {120.L, 60.L, 12.L, 1.L};
-  const MatrixType A2 = A * A;
-  const MatrixType tmp = b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
-  U.noalias() = A * tmp;
-  V = b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
-}
-
-/** \brief Compute the (5,5)-Pad&eacute; approximant to the exponential.
- *
- *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
- *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
- */
-template <typename MatA, typename MatU, typename MatV>
-void matrix_exp_pade5(const MatA& A, MatU& U, MatV& V) {
-  typedef typename MatA::PlainObject MatrixType;
-  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
-  const RealScalar b[] = {30240.L, 15120.L, 3360.L, 420.L, 30.L, 1.L};
-  const MatrixType A2 = A * A;
-  const MatrixType A4 = A2 * A2;
-  const MatrixType tmp = b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
-  U.noalias() = A * tmp;
-  V = b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
-}
-
-/** \brief Compute the (7,7)-Pad&eacute; approximant to the exponential.
- *
- *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
- *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
- */
-template <typename MatA, typename MatU, typename MatV>
-void matrix_exp_pade7(const MatA& A, MatU& U, MatV& V) {
-  typedef typename MatA::PlainObject MatrixType;
-  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
-  const RealScalar b[] = {17297280.L, 8648640.L, 1995840.L, 277200.L, 25200.L, 1512.L, 56.L, 1.L};
-  const MatrixType A2 = A * A;
-  const MatrixType A4 = A2 * A2;
-  const MatrixType A6 = A4 * A2;
-  const MatrixType tmp = b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
-  U.noalias() = A * tmp;
-  V = b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
-}
-
-/** \brief Compute the (9,9)-Pad&eacute; approximant to the exponential.
- *
- *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
- *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
- */
-template <typename MatA, typename MatU, typename MatV>
-void matrix_exp_pade9(const MatA& A, MatU& U, MatV& V) {
-  typedef typename MatA::PlainObject MatrixType;
-  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
-  const RealScalar b[] = {17643225600.L, 8821612800.L, 2075673600.L, 302702400.L, 30270240.L,
-                          2162160.L,     110880.L,     3960.L,       90.L,        1.L};
-  const MatrixType A2 = A * A;
-  const MatrixType A4 = A2 * A2;
-  const MatrixType A6 = A4 * A2;
-  const MatrixType A8 = A6 * A2;
-  const MatrixType tmp =
-      b[9] * A8 + b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
-  U.noalias() = A * tmp;
-  V = b[8] * A8 + b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
-}
-
-/** \brief Compute the (13,13)-Pad&eacute; approximant to the exponential.
- *
- *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
- *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
- */
-template <typename MatA, typename MatU, typename MatV>
-void matrix_exp_pade13(const MatA& A, MatU& U, MatV& V) {
-  typedef typename MatA::PlainObject MatrixType;
-  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
-  const RealScalar b[] = {64764752532480000.L,
-                          32382376266240000.L,
-                          7771770303897600.L,
-                          1187353796428800.L,
-                          129060195264000.L,
-                          10559470521600.L,
-                          670442572800.L,
-                          33522128640.L,
-                          1323241920.L,
-                          40840800.L,
-                          960960.L,
-                          16380.L,
-                          182.L,
-                          1.L};
-  const MatrixType A2 = A * A;
-  const MatrixType A4 = A2 * A2;
-  const MatrixType A6 = A4 * A2;
-  V = b[13] * A6 + b[11] * A4 + b[9] * A2;  // used for temporary storage
-  MatrixType tmp = A6 * V;
-  tmp += b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
-  U.noalias() = A * tmp;
-  tmp = b[12] * A6 + b[10] * A4 + b[8] * A2;
-  V.noalias() = A6 * tmp;
-  V += b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
-}
-
-/** \brief Compute the (17,17)-Pad&eacute; approximant to the exponential.
- *
- *  After exit, \f$ (V+U)(V-U)^{-1} \f$ is the Pad&eacute;
- *  approximant of \f$ \exp(A) \f$ around \f$ A = 0 \f$.
- *
- *  This function activates only if your long double is double-double or quadruple.
- */
-#if LDBL_MANT_DIG > 64
-template <typename MatA, typename MatU, typename MatV>
-void matrix_exp_pade17(const MatA& A, MatU& U, MatV& V) {
-  typedef typename MatA::PlainObject MatrixType;
-  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
-  const RealScalar b[] = {830034394580628357120000.L,
-                          415017197290314178560000.L,
-                          100610229646136770560000.L,
-                          15720348382208870400000.L,
-                          1774878043152614400000.L,
-                          153822763739893248000.L,
-                          10608466464820224000.L,
-                          595373117923584000.L,
-                          27563570274240000.L,
-                          1060137318240000.L,
-                          33924394183680.L,
-                          899510451840.L,
-                          19554575040.L,
-                          341863200.L,
-                          4651200.L,
-                          46512.L,
-                          306.L,
-                          1.L};
-  const MatrixType A2 = A * A;
-  const MatrixType A4 = A2 * A2;
-  const MatrixType A6 = A4 * A2;
-  const MatrixType A8 = A4 * A4;
-  V = b[17] * A8 + b[15] * A6 + b[13] * A4 + b[11] * A2;  // used for temporary storage
-  MatrixType tmp = A8 * V;
-  tmp += b[9] * A8 + b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
-  U.noalias() = A * tmp;
-  tmp = b[16] * A8 + b[14] * A6 + b[12] * A4 + b[10] * A2;
-  V.noalias() = tmp * A8;
-  V += b[8] * A8 + b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
-}
-#endif
-
-template <typename MatrixType, typename RealScalar = typename NumTraits<typename traits<MatrixType>::Scalar>::Real>
-struct matrix_exp_computeUV {
-  /** \brief Compute Pad&eacute; approximant to the exponential.
-   *
-   * Computes \c U, \c V and \c squarings such that \f$ (V+U)(V-U)^{-1} \f$ is a Pad&eacute;
-   * approximant of \f$ \exp(2^{-\mbox{squarings}}M) \f$ around \f$ M = 0 \f$, where \f$ M \f$
-   * denotes the matrix \c arg. The degree of the Pad&eacute; approximant and the value of squarings
-   * are chosen such that the approximation error is no more than the round-off error.
-   */
-  static void run(const MatrixType& arg, MatrixType& U, MatrixType& V, int& squarings);
-};
-
-template <typename MatrixType>
-struct matrix_exp_computeUV<MatrixType, float> {
-  using Scalar = typename traits<MatrixType>::Scalar;
-  template <typename ArgType>
-  static void run(const ArgType& arg, MatrixType& U, MatrixType& V, int& squarings) {
-    using std::frexp;
-    using std::pow;
-    const float l1norm = arg.cwiseAbs().colwise().sum().maxCoeff();
-    squarings = 0;
-    if (l1norm < 4.258730016922831e-001f) {
-      matrix_exp_pade3(arg, U, V);
-    } else if (l1norm < 1.880152677804762e+000f) {
-      matrix_exp_pade5(arg, U, V);
-    } else {
-      const float maxnorm = 3.925724783138660f;
-      frexp(l1norm / maxnorm, &squarings);
-      if (squarings < 0) squarings = 0;
-      MatrixType A = arg.unaryExpr(MatrixExponentialScalingOp<Scalar>(squarings));
-      matrix_exp_pade7(A, U, V);
-    }
-  }
-};
-
-template <typename MatrixType>
-struct matrix_exp_computeUV<MatrixType, double> {
-  using Scalar = typename traits<MatrixType>::Scalar;
-  template <typename ArgType>
-  static void run(const ArgType& arg, MatrixType& U, MatrixType& V, int& squarings) {
-    using std::frexp;
-    using std::pow;
-    const double l1norm = arg.cwiseAbs().colwise().sum().maxCoeff();
-    squarings = 0;
-    if (l1norm < 1.495585217958292e-002) {
-      matrix_exp_pade3(arg, U, V);
-    } else if (l1norm < 2.539398330063230e-001) {
-      matrix_exp_pade5(arg, U, V);
-    } else if (l1norm < 9.504178996162932e-001) {
-      matrix_exp_pade7(arg, U, V);
-    } else if (l1norm < 2.097847961257068e+000) {
-      matrix_exp_pade9(arg, U, V);
-    } else {
-      const double maxnorm = 5.371920351148152;
-      frexp(l1norm / maxnorm, &squarings);
-      if (squarings < 0) squarings = 0;
-      MatrixType A = arg.unaryExpr(MatrixExponentialScalingOp<Scalar>(squarings));
-      matrix_exp_pade13(A, U, V);
-    }
-  }
-};
-
-template <typename MatrixType>
-struct matrix_exp_computeUV<MatrixType, long double> {
-  template <typename ArgType>
-  static void run(const ArgType& arg, MatrixType& U, MatrixType& V, int& squarings) {
-#if LDBL_MANT_DIG == 53  // double precision
-    matrix_exp_computeUV<MatrixType, double>::run(arg, U, V, squarings);
-
-#else
-
-    using Scalar = typename traits<MatrixType>::Scalar;
-
-    using std::frexp;
-    using std::pow;
-    const long double l1norm = arg.cwiseAbs().colwise().sum().maxCoeff();
-    squarings = 0;
-
-#if LDBL_MANT_DIG <= 64  // extended precision
-
-    if (l1norm < 4.1968497232266989671e-003L) {
-      matrix_exp_pade3(arg, U, V);
-    } else if (l1norm < 1.1848116734693823091e-001L) {
-      matrix_exp_pade5(arg, U, V);
-    } else if (l1norm < 5.5170388480686700274e-001L) {
-      matrix_exp_pade7(arg, U, V);
-    } else if (l1norm < 1.3759868875587845383e+000L) {
-      matrix_exp_pade9(arg, U, V);
-    } else {
-      const long double maxnorm = 4.0246098906697353063L;
-      frexp(l1norm / maxnorm, &squarings);
-      if (squarings < 0) squarings = 0;
-      MatrixType A = arg.unaryExpr(MatrixExponentialScalingOp<Scalar>(squarings));
-      matrix_exp_pade13(A, U, V);
-    }
-
-#elif LDBL_MANT_DIG <= 106  // double-double
-
-    if (l1norm < 3.2787892205607026992947488108213e-005L) {
-      matrix_exp_pade3(arg, U, V);
-    } else if (l1norm < 6.4467025060072760084130906076332e-003L) {
-      matrix_exp_pade5(arg, U, V);
-    } else if (l1norm < 6.8988028496595374751374122881143e-002L) {
-      matrix_exp_pade7(arg, U, V);
-    } else if (l1norm < 2.7339737518502231741495857201670e-001L) {
-      matrix_exp_pade9(arg, U, V);
-    } else if (l1norm < 1.3203382096514474905666448850278e+000L) {
-      matrix_exp_pade13(arg, U, V);
-    } else {
-      const long double maxnorm = 3.2579440895405400856599663723517L;
-      frexp(l1norm / maxnorm, &squarings);
-      if (squarings < 0) squarings = 0;
-      MatrixType A = arg.unaryExpr(MatrixExponentialScalingOp<Scalar>(squarings));
-      matrix_exp_pade17(A, U, V);
-    }
-
-#elif LDBL_MANT_DIG <= 113  // quadruple precision
-
-    if (l1norm < 1.639394610288918690547467954466970e-005L) {
-      matrix_exp_pade3(arg, U, V);
-    } else if (l1norm < 4.253237712165275566025884344433009e-003L) {
-      matrix_exp_pade5(arg, U, V);
-    } else if (l1norm < 5.125804063165764409885122032933142e-002L) {
-      matrix_exp_pade7(arg, U, V);
-    } else if (l1norm < 2.170000765161155195453205651889853e-001L) {
-      matrix_exp_pade9(arg, U, V);
-    } else if (l1norm < 1.125358383453143065081397882891878e+000L) {
-      matrix_exp_pade13(arg, U, V);
-    } else {
-      const long double maxnorm = 2.884233277829519311757165057717815L;
-      frexp(l1norm / maxnorm, &squarings);
-      if (squarings < 0) squarings = 0;
-      MatrixType A = arg.unaryExpr(MatrixExponentialScalingOp<Scalar>(squarings));
-      matrix_exp_pade17(A, U, V);
-    }
-
-#else
-
-    // this case should be handled in compute()
-    eigen_assert(false && "Bug in MatrixExponential");
-
-#endif
-#endif  // LDBL_MANT_DIG
-  }
-};
-
-template <typename T>
-struct is_exp_known_type : false_type {};
-template <>
-struct is_exp_known_type<float> : true_type {};
-template <>
-struct is_exp_known_type<double> : true_type {};
-#if LDBL_MANT_DIG <= 113
-template <>
-struct is_exp_known_type<long double> : true_type {};
-#endif
-
-template <typename ArgType, typename ResultType>
-void matrix_exp_compute(const ArgType& arg, ResultType& result, true_type)  // natively supported scalar type
-{
-  typedef typename ArgType::PlainObject MatrixType;
-  MatrixType U, V;
-  int squarings;
-  matrix_exp_computeUV<MatrixType>::run(arg, U, V, squarings);  // Pade approximant is (U+V) / (-U+V)
-  MatrixType numer = U + V;
-  MatrixType denom = -U + V;
-  result = denom.partialPivLu().solve(numer);
-  for (int i = 0; i < squarings; i++) result *= result;  // undo scaling by repeated squaring
-}
-
-/* Computes the matrix exponential
- *
- * \param arg    argument of matrix exponential (should be plain object)
- * \param result variable in which result will be stored
- */
-template <typename ArgType, typename ResultType>
-void matrix_exp_compute(const ArgType& arg, ResultType& result, false_type)  // default
-{
-  typedef typename ArgType::PlainObject MatrixType;
-  typedef make_complex_t<typename traits<MatrixType>::Scalar> ComplexScalar;
-  result = arg.matrixFunction(internal::stem_function_exp<ComplexScalar>);
-}
-
-}  // namespace internal
-
-/** \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix exponential of some matrix (expression).
- *
- * \tparam Derived  Type of the argument to the matrix exponential.
- *
- * This class holds the argument to the matrix exponential until it is assigned or evaluated for
- * some other reason (so the argument should not be changed in the meantime). It is the return type
- * of MatrixBase::exp() and most of the time this is the only way it is used.
- */
-template <typename Derived>
-struct MatrixExponentialReturnValue : public ReturnByValue<MatrixExponentialReturnValue<Derived> > {
- public:
-  /** \brief Constructor.
-   *
-   * \param src %Matrix (expression) forming the argument of the matrix exponential.
-   */
-  MatrixExponentialReturnValue(const Derived& src) : m_src(src) {}
-
-  /** \brief Compute the matrix exponential.
-   *
-   * \param result the matrix exponential of \p src in the constructor.
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    const typename internal::nested_eval<Derived, 10>::type tmp(m_src);
-    internal::matrix_exp_compute(tmp, result, internal::is_exp_known_type<typename Derived::RealScalar>());
-  }
-
-  Index rows() const { return m_src.rows(); }
-  Index cols() const { return m_src.cols(); }
-
- protected:
-  const typename internal::ref_selector<Derived>::type m_src;
-};
-
-namespace internal {
-template <typename Derived>
-struct traits<MatrixExponentialReturnValue<Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
-};
-}  // namespace internal
-
-template <typename Derived>
-const MatrixExponentialReturnValue<Derived> MatrixBase<Derived>::exp() const {
-  eigen_assert(rows() == cols());
-  return MatrixExponentialReturnValue<Derived>(derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MATRIX_EXPONENTIAL
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h b/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h
deleted file mode 100644
index 0014700..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h
+++ /dev/null
@@ -1,543 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009-2011, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MATRIX_FUNCTION_H
-#define EIGEN_MATRIX_FUNCTION_H
-
-#include "StemFunction.h"
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \brief Maximum distance allowed between eigenvalues to be considered "close". */
-static const float matrix_function_separation = 0.1f;
-
-/** \ingroup MatrixFunctions_Module
- * \class MatrixFunctionAtomic
- * \brief Helper class for computing matrix functions of atomic matrices.
- *
- * Here, an atomic matrix is a triangular matrix whose diagonal entries are close to each other.
- */
-template <typename MatrixType>
-class MatrixFunctionAtomic {
- public:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename stem_function<Scalar>::type StemFunction;
-
-  /** \brief Constructor
-   * \param[in]  f  matrix function to compute.
-   */
-  MatrixFunctionAtomic(StemFunction f) : m_f(f) {}
-
-  /** \brief Compute matrix function of atomic matrix
-   * \param[in]  A  argument of matrix function, should be upper triangular and atomic
-   * \returns  f(A), the matrix function evaluated at the given matrix
-   */
-  MatrixType compute(const MatrixType& A);
-
- private:
-  StemFunction* m_f;
-};
-
-template <typename MatrixType>
-typename NumTraits<typename MatrixType::Scalar>::Real matrix_function_compute_mu(const MatrixType& A) {
-  typedef typename plain_col_type<MatrixType>::type VectorType;
-  Index rows = A.rows();
-  const MatrixType N = MatrixType::Identity(rows, rows) - A;
-  VectorType e = VectorType::Ones(rows);
-  N.template triangularView<Upper>().solveInPlace(e);
-  return e.cwiseAbs().maxCoeff();
-}
-
-template <typename MatrixType>
-MatrixType MatrixFunctionAtomic<MatrixType>::compute(const MatrixType& A) {
-  // TODO: Use that A is upper triangular
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  Index rows = A.rows();
-  Scalar avgEival = A.trace() / Scalar(RealScalar(rows));
-  MatrixType Ashifted = A - avgEival * MatrixType::Identity(rows, rows);
-  RealScalar mu = matrix_function_compute_mu(Ashifted);
-  MatrixType F = m_f(avgEival, 0) * MatrixType::Identity(rows, rows);
-  MatrixType P = Ashifted;
-  MatrixType Fincr;
-  for (Index s = 1; double(s) < 1.1 * double(rows) + 10.0; s++) {  // upper limit is fairly arbitrary
-    Fincr = m_f(avgEival, static_cast<int>(s)) * P;
-    F += Fincr;
-    P = Scalar(RealScalar(1) / RealScalar(s + 1)) * P * Ashifted;
-
-    // test whether Taylor series converged
-    const RealScalar F_norm = F.cwiseAbs().rowwise().sum().maxCoeff();
-    const RealScalar Fincr_norm = Fincr.cwiseAbs().rowwise().sum().maxCoeff();
-    if (Fincr_norm < NumTraits<Scalar>::epsilon() * F_norm) {
-      RealScalar delta = 0;
-      RealScalar rfactorial = 1;
-      for (Index r = 0; r < rows; r++) {
-        RealScalar mx = 0;
-        for (Index i = 0; i < rows; i++)
-          mx = (std::max)(mx, std::abs(m_f(Ashifted(i, i) + avgEival, static_cast<int>(s + r))));
-        if (r != 0) rfactorial *= RealScalar(r);
-        delta = (std::max)(delta, RealScalar(mx / rfactorial));
-      }
-      const RealScalar P_norm = P.cwiseAbs().rowwise().sum().maxCoeff();
-      if (mu * delta * P_norm < NumTraits<Scalar>::epsilon() * F_norm)  // series converged
-        break;
-    }
-  }
-  return F;
-}
-
-/** \brief Find cluster in \p clusters containing some value
- * \param[in] key Value to find
- * \returns Iterator to cluster containing \p key, or \c clusters.end() if no cluster in \p m_clusters
- * contains \p key.
- */
-template <typename Index, typename ListOfClusters>
-typename ListOfClusters::iterator matrix_function_find_cluster(Index key, ListOfClusters& clusters) {
-  typename std::list<Index>::iterator j;
-  for (typename ListOfClusters::iterator i = clusters.begin(); i != clusters.end(); ++i) {
-    j = std::find(i->begin(), i->end(), key);
-    if (j != i->end()) return i;
-  }
-  return clusters.end();
-}
-
-/** \brief Partition eigenvalues in clusters of ei'vals close to each other
- *
- * \param[in]  eivals    Eigenvalues
- * \param[out] clusters  Resulting partition of eigenvalues
- *
- * The partition satisfies the following two properties:
- * # Any eigenvalue in a certain cluster is at most matrix_function_separation() away from another eigenvalue
- *   in the same cluster.
- * # The distance between two eigenvalues in different clusters is more than matrix_function_separation().
- * The implementation follows Algorithm 4.1 in the paper of Davies and Higham.
- */
-template <typename EivalsType, typename Cluster>
-void matrix_function_partition_eigenvalues(const EivalsType& eivals, std::list<Cluster>& clusters) {
-  typedef typename EivalsType::RealScalar RealScalar;
-  for (Index i = 0; i < eivals.rows(); ++i) {
-    // Find cluster containing i-th ei'val, adding a new cluster if necessary
-    typename std::list<Cluster>::iterator qi = matrix_function_find_cluster(i, clusters);
-    if (qi == clusters.end()) {
-      Cluster l;
-      l.push_back(i);
-      clusters.push_back(l);
-      qi = clusters.end();
-      --qi;
-    }
-
-    // Look for other element to add to the set
-    for (Index j = i + 1; j < eivals.rows(); ++j) {
-      if (abs(eivals(j) - eivals(i)) <= RealScalar(matrix_function_separation) &&
-          std::find(qi->begin(), qi->end(), j) == qi->end()) {
-        typename std::list<Cluster>::iterator qj = matrix_function_find_cluster(j, clusters);
-        if (qj == clusters.end()) {
-          qi->push_back(j);
-        } else {
-          qi->insert(qi->end(), qj->begin(), qj->end());
-          clusters.erase(qj);
-        }
-      }
-    }
-  }
-}
-
-/** \brief Compute size of each cluster given a partitioning */
-template <typename ListOfClusters, typename Index>
-void matrix_function_compute_cluster_size(const ListOfClusters& clusters, Matrix<Index, Dynamic, 1>& clusterSize) {
-  const Index numClusters = static_cast<Index>(clusters.size());
-  clusterSize.setZero(numClusters);
-  Index clusterIndex = 0;
-  for (typename ListOfClusters::const_iterator cluster = clusters.begin(); cluster != clusters.end(); ++cluster) {
-    clusterSize[clusterIndex] = cluster->size();
-    ++clusterIndex;
-  }
-}
-
-/** \brief Compute start of each block using clusterSize */
-template <typename VectorType>
-void matrix_function_compute_block_start(const VectorType& clusterSize, VectorType& blockStart) {
-  blockStart.resize(clusterSize.rows());
-  blockStart(0) = 0;
-  for (Index i = 1; i < clusterSize.rows(); i++) {
-    blockStart(i) = blockStart(i - 1) + clusterSize(i - 1);
-  }
-}
-
-/** \brief Compute mapping of eigenvalue indices to cluster indices */
-template <typename EivalsType, typename ListOfClusters, typename VectorType>
-void matrix_function_compute_map(const EivalsType& eivals, const ListOfClusters& clusters, VectorType& eivalToCluster) {
-  eivalToCluster.resize(eivals.rows());
-  Index clusterIndex = 0;
-  for (typename ListOfClusters::const_iterator cluster = clusters.begin(); cluster != clusters.end(); ++cluster) {
-    for (Index i = 0; i < eivals.rows(); ++i) {
-      if (std::find(cluster->begin(), cluster->end(), i) != cluster->end()) {
-        eivalToCluster[i] = clusterIndex;
-      }
-    }
-    ++clusterIndex;
-  }
-}
-
-/** \brief Compute permutation which groups ei'vals in same cluster together */
-template <typename DynVectorType, typename VectorType>
-void matrix_function_compute_permutation(const DynVectorType& blockStart, const DynVectorType& eivalToCluster,
-                                         VectorType& permutation) {
-  DynVectorType indexNextEntry = blockStart;
-  permutation.resize(eivalToCluster.rows());
-  for (Index i = 0; i < eivalToCluster.rows(); i++) {
-    Index cluster = eivalToCluster[i];
-    permutation[i] = indexNextEntry[cluster];
-    ++indexNextEntry[cluster];
-  }
-}
-
-/** \brief Permute Schur decomposition in U and T according to permutation */
-template <typename VectorType, typename MatrixType>
-void matrix_function_permute_schur(VectorType& permutation, MatrixType& U, MatrixType& T) {
-  for (Index i = 0; i < permutation.rows() - 1; i++) {
-    Index j;
-    for (j = i; j < permutation.rows(); j++) {
-      if (permutation(j) == i) break;
-    }
-    eigen_assert(permutation(j) == i);
-    for (Index k = j - 1; k >= i; k--) {
-      JacobiRotation<typename MatrixType::Scalar> rotation;
-      rotation.makeGivens(T(k, k + 1), T(k + 1, k + 1) - T(k, k));
-      T.applyOnTheLeft(k, k + 1, rotation.adjoint());
-      T.applyOnTheRight(k, k + 1, rotation);
-      U.applyOnTheRight(k, k + 1, rotation);
-      std::swap(permutation.coeffRef(k), permutation.coeffRef(k + 1));
-    }
-  }
-}
-
-/** \brief Compute block diagonal part of matrix function.
- *
- * This routine computes the matrix function applied to the block diagonal part of \p T (which should be
- * upper triangular), with the blocking given by \p blockStart and \p clusterSize. The matrix function of
- * each diagonal block is computed by \p atomic. The off-diagonal parts of \p fT are set to zero.
- */
-template <typename MatrixType, typename AtomicType, typename VectorType>
-void matrix_function_compute_block_atomic(const MatrixType& T, AtomicType& atomic, const VectorType& blockStart,
-                                          const VectorType& clusterSize, MatrixType& fT) {
-  fT.setZero(T.rows(), T.cols());
-  for (Index i = 0; i < clusterSize.rows(); ++i) {
-    fT.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)) =
-        atomic.compute(T.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)));
-  }
-}
-
-/** \brief Solve a triangular Sylvester equation AX + XB = C
- *
- * \param[in]  A  the matrix A; should be square and upper triangular
- * \param[in]  B  the matrix B; should be square and upper triangular
- * \param[in]  C  the matrix C; should have correct size.
- *
- * \returns the solution X.
- *
- * If A is m-by-m and B is n-by-n, then both C and X are m-by-n.  The (i,j)-th component of the Sylvester
- * equation is
- * \f[
- *     \sum_{k=i}^m A_{ik} X_{kj} + \sum_{k=1}^j X_{ik} B_{kj} = C_{ij}.
- * \f]
- * This can be re-arranged to yield:
- * \f[
- *     X_{ij} = \frac{1}{A_{ii} + B_{jj}} \Bigl( C_{ij}
- *     - \sum_{k=i+1}^m A_{ik} X_{kj} - \sum_{k=1}^{j-1} X_{ik} B_{kj} \Bigr).
- * \f]
- * It is assumed that A and B are such that the numerator is never zero (otherwise the Sylvester equation
- * does not have a unique solution). In that case, these equations can be evaluated in the order
- * \f$ i=m,\ldots,1 \f$ and \f$ j=1,\ldots,n \f$.
- */
-template <typename MatrixType>
-MatrixType matrix_function_solve_triangular_sylvester(const MatrixType& A, const MatrixType& B, const MatrixType& C) {
-  eigen_assert(A.rows() == A.cols());
-  eigen_assert(A.isUpperTriangular());
-  eigen_assert(B.rows() == B.cols());
-  eigen_assert(B.isUpperTriangular());
-  eigen_assert(C.rows() == A.rows());
-  eigen_assert(C.cols() == B.rows());
-
-  typedef typename MatrixType::Scalar Scalar;
-
-  Index m = A.rows();
-  Index n = B.rows();
-  MatrixType X(m, n);
-
-  for (Index i = m - 1; i >= 0; --i) {
-    for (Index j = 0; j < n; ++j) {
-      // Compute AX = \sum_{k=i+1}^m A_{ik} X_{kj}
-      Scalar AX;
-      if (i == m - 1) {
-        AX = 0;
-      } else {
-        Matrix<Scalar, 1, 1> AXmatrix = A.row(i).tail(m - 1 - i) * X.col(j).tail(m - 1 - i);
-        AX = AXmatrix(0, 0);
-      }
-
-      // Compute XB = \sum_{k=1}^{j-1} X_{ik} B_{kj}
-      Scalar XB;
-      if (j == 0) {
-        XB = 0;
-      } else {
-        Matrix<Scalar, 1, 1> XBmatrix = X.row(i).head(j) * B.col(j).head(j);
-        XB = XBmatrix(0, 0);
-      }
-
-      X(i, j) = (C(i, j) - AX - XB) / (A(i, i) + B(j, j));
-    }
-  }
-  return X;
-}
-
-/** \brief Compute part of matrix function above block diagonal.
- *
- * This routine completes the computation of \p fT, denoting a matrix function applied to the triangular
- * matrix \p T. It assumes that the block diagonal part of \p fT has already been computed. The part below
- * the diagonal is zero, because \p T is upper triangular.
- */
-template <typename MatrixType, typename VectorType>
-void matrix_function_compute_above_diagonal(const MatrixType& T, const VectorType& blockStart,
-                                            const VectorType& clusterSize, MatrixType& fT) {
-  typedef internal::traits<MatrixType> Traits;
-  typedef typename MatrixType::Scalar Scalar;
-  static const int Options = MatrixType::Options;
-  typedef Matrix<Scalar, Dynamic, Dynamic, Options, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime> DynMatrixType;
-
-  for (Index k = 1; k < clusterSize.rows(); k++) {
-    for (Index i = 0; i < clusterSize.rows() - k; i++) {
-      // compute (i, i+k) block
-      DynMatrixType A = T.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i));
-      DynMatrixType B = -T.block(blockStart(i + k), blockStart(i + k), clusterSize(i + k), clusterSize(i + k));
-      DynMatrixType C = fT.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)) *
-                        T.block(blockStart(i), blockStart(i + k), clusterSize(i), clusterSize(i + k));
-      C -= T.block(blockStart(i), blockStart(i + k), clusterSize(i), clusterSize(i + k)) *
-           fT.block(blockStart(i + k), blockStart(i + k), clusterSize(i + k), clusterSize(i + k));
-      for (Index m = i + 1; m < i + k; m++) {
-        C += fT.block(blockStart(i), blockStart(m), clusterSize(i), clusterSize(m)) *
-             T.block(blockStart(m), blockStart(i + k), clusterSize(m), clusterSize(i + k));
-        C -= T.block(blockStart(i), blockStart(m), clusterSize(i), clusterSize(m)) *
-             fT.block(blockStart(m), blockStart(i + k), clusterSize(m), clusterSize(i + k));
-      }
-      fT.block(blockStart(i), blockStart(i + k), clusterSize(i), clusterSize(i + k)) =
-          matrix_function_solve_triangular_sylvester(A, B, C);
-    }
-  }
-}
-
-/** \ingroup MatrixFunctions_Module
- * \brief Class for computing matrix functions.
- * \tparam  MatrixType  type of the argument of the matrix function,
- *                      expected to be an instantiation of the Matrix class template.
- * \tparam  AtomicType  type for computing matrix function of atomic blocks.
- * \tparam  IsComplex   used internally to select correct specialization.
- *
- * This class implements the Schur-Parlett algorithm for computing matrix functions. The spectrum of the
- * matrix is divided in clustered of eigenvalues that lies close together. This class delegates the
- * computation of the matrix function on every block corresponding to these clusters to an object of type
- * \p AtomicType and uses these results to compute the matrix function of the whole matrix. The class
- * \p AtomicType should have a \p compute() member function for computing the matrix function of a block.
- *
- * \sa class MatrixFunctionAtomic, class MatrixLogarithmAtomic
- */
-template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
-struct matrix_function_compute {
-  /** \brief Compute the matrix function.
-   *
-   * \param[in]  A       argument of matrix function, should be a square matrix.
-   * \param[in]  atomic  class for computing matrix function of atomic blocks.
-   * \param[out] result  the function \p f applied to \p A, as
-   * specified in the constructor.
-   *
-   * See MatrixBase::matrixFunction() for details on how this computation
-   * is implemented.
-   */
-  template <typename AtomicType, typename ResultType>
-  static void run(const MatrixType& A, AtomicType& atomic, ResultType& result);
-};
-
-/** \internal \ingroup MatrixFunctions_Module
- * \brief Partial specialization of MatrixFunction for real matrices
- *
- * This converts the real matrix to a complex matrix, compute the matrix function of that matrix, and then
- * converts the result back to a real matrix.
- */
-template <typename MatrixType>
-struct matrix_function_compute<MatrixType, 0> {
-  template <typename MatA, typename AtomicType, typename ResultType>
-  static void run(const MatA& A, AtomicType& atomic, ResultType& result) {
-    typedef internal::traits<MatrixType> Traits;
-    typedef typename Traits::Scalar Scalar;
-    static const int Rows = Traits::RowsAtCompileTime, Cols = Traits::ColsAtCompileTime;
-    static const int MaxRows = Traits::MaxRowsAtCompileTime, MaxCols = Traits::MaxColsAtCompileTime;
-
-    typedef internal::make_complex_t<Scalar> ComplexScalar;
-    typedef Matrix<ComplexScalar, Rows, Cols, 0, MaxRows, MaxCols> ComplexMatrix;
-
-    ComplexMatrix CA = A.template cast<ComplexScalar>();
-    ComplexMatrix Cresult;
-    matrix_function_compute<ComplexMatrix>::run(CA, atomic, Cresult);
-    result = Cresult.real();
-  }
-};
-
-/** \internal \ingroup MatrixFunctions_Module
- * \brief Partial specialization of MatrixFunction for complex matrices
- */
-template <typename MatrixType>
-struct matrix_function_compute<MatrixType, 1> {
-  template <typename MatA, typename AtomicType, typename ResultType>
-  static void run(const MatA& A, AtomicType& atomic, ResultType& result) {
-    typedef internal::traits<MatrixType> Traits;
-
-    // compute Schur decomposition of A
-    const ComplexSchur<MatrixType> schurOfA(A);
-    eigen_assert(schurOfA.info() == Success);
-    MatrixType T = schurOfA.matrixT();
-    MatrixType U = schurOfA.matrixU();
-
-    // partition eigenvalues into clusters of ei'vals "close" to each other
-    std::list<std::list<Index> > clusters;
-    matrix_function_partition_eigenvalues(T.diagonal(), clusters);
-
-    // compute size of each cluster
-    Matrix<Index, Dynamic, 1> clusterSize;
-    matrix_function_compute_cluster_size(clusters, clusterSize);
-
-    // blockStart[i] is row index at which block corresponding to i-th cluster starts
-    Matrix<Index, Dynamic, 1> blockStart;
-    matrix_function_compute_block_start(clusterSize, blockStart);
-
-    // compute map so that eivalToCluster[i] = j means that i-th ei'val is in j-th cluster
-    Matrix<Index, Dynamic, 1> eivalToCluster;
-    matrix_function_compute_map(T.diagonal(), clusters, eivalToCluster);
-
-    // compute permutation which groups ei'vals in same cluster together
-    Matrix<Index, Traits::RowsAtCompileTime, 1> permutation;
-    matrix_function_compute_permutation(blockStart, eivalToCluster, permutation);
-
-    // permute Schur decomposition
-    matrix_function_permute_schur(permutation, U, T);
-
-    // compute result
-    MatrixType fT;  // matrix function applied to T
-    matrix_function_compute_block_atomic(T, atomic, blockStart, clusterSize, fT);
-    matrix_function_compute_above_diagonal(T, blockStart, clusterSize, fT);
-    result = U * (fT.template triangularView<Upper>() * U.adjoint());
-  }
-};
-
-}  // end of namespace internal
-
-/** \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix function of some matrix (expression).
- *
- * \tparam Derived  Type of the argument to the matrix function.
- *
- * This class holds the argument to the matrix function until it is assigned or evaluated for some other
- * reason (so the argument should not be changed in the meantime). It is the return type of
- * matrixBase::matrixFunction() and related functions and most of the time this is the only way it is used.
- */
-template <typename Derived>
-class MatrixFunctionReturnValue : public ReturnByValue<MatrixFunctionReturnValue<Derived> > {
- public:
-  typedef typename Derived::Scalar Scalar;
-  typedef typename internal::stem_function<Scalar>::type StemFunction;
-
- protected:
-  typedef typename internal::ref_selector<Derived>::type DerivedNested;
-
- public:
-  /** \brief Constructor.
-   *
-   * \param[in] A  %Matrix (expression) forming the argument of the matrix function.
-   * \param[in] f  Stem function for matrix function under consideration.
-   */
-  MatrixFunctionReturnValue(const Derived& A, StemFunction f) : m_A(A), m_f(f) {}
-
-  /** \brief Compute the matrix function.
-   *
-   * \param[out] result \p f applied to \p A, where \p f and \p A are as in the constructor.
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    typedef typename internal::nested_eval<Derived, 10>::type NestedEvalType;
-    typedef internal::remove_all_t<NestedEvalType> NestedEvalTypeClean;
-    typedef internal::traits<NestedEvalTypeClean> Traits;
-    typedef internal::make_complex_t<Scalar> ComplexScalar;
-    typedef Matrix<ComplexScalar, Dynamic, Dynamic, 0, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime>
-        DynMatrixType;
-
-    typedef internal::MatrixFunctionAtomic<DynMatrixType> AtomicType;
-    AtomicType atomic(m_f);
-
-    internal::matrix_function_compute<typename NestedEvalTypeClean::PlainObject>::run(m_A, atomic, result);
-  }
-
-  Index rows() const { return m_A.rows(); }
-  Index cols() const { return m_A.cols(); }
-
- private:
-  const DerivedNested m_A;
-  StemFunction* m_f;
-};
-
-namespace internal {
-template <typename Derived>
-struct traits<MatrixFunctionReturnValue<Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
-};
-}  // namespace internal
-
-/********** MatrixBase methods **********/
-
-template <typename Derived>
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(
-    typename internal::stem_function<typename internal::traits<Derived>::Scalar>::type f) const {
-  eigen_assert(rows() == cols());
-  return MatrixFunctionReturnValue<Derived>(derived(), f);
-}
-
-template <typename Derived>
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sin() const {
-  eigen_assert(rows() == cols());
-  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
-  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_sin<ComplexScalar>);
-}
-
-template <typename Derived>
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cos() const {
-  eigen_assert(rows() == cols());
-  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
-  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_cos<ComplexScalar>);
-}
-
-template <typename Derived>
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sinh() const {
-  eigen_assert(rows() == cols());
-  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
-  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_sinh<ComplexScalar>);
-}
-
-template <typename Derived>
-const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cosh() const {
-  eigen_assert(rows() == cols());
-  typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar;
-  return MatrixFunctionReturnValue<Derived>(derived(), internal::stem_function_cosh<ComplexScalar>);
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MATRIX_FUNCTION_H
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixLogarithm.h b/unsupported/Eigen/src/MatrixFunctions/MatrixLogarithm.h
deleted file mode 100644
index 40e1b1d..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixLogarithm.h
+++ /dev/null
@@ -1,366 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
-// Copyright (C) 2011 Chen-Pang He <jdh8@ms63.hinet.net>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MATRIX_LOGARITHM
-#define EIGEN_MATRIX_LOGARITHM
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-struct matrix_log_min_pade_degree {
-  static const int value = 3;
-};
-
-template <typename Scalar>
-struct matrix_log_max_pade_degree {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  static const int value = std::numeric_limits<RealScalar>::digits <= 24 ? 5 :  // single precision
-                               std::numeric_limits<RealScalar>::digits <= 53 ? 7
-                                                                             :  // double precision
-                               std::numeric_limits<RealScalar>::digits <= 64 ? 8
-                                                                             :  // extended precision
-                               std::numeric_limits<RealScalar>::digits <= 106 ? 10
-                                                                              :  // double-double
-                               11;                                               // quadruple precision
-};
-
-/** \brief Compute logarithm of 2x2 triangular matrix. */
-template <typename MatrixType>
-void matrix_log_compute_2x2(const MatrixType& A, MatrixType& result) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  using std::abs;
-  using std::ceil;
-  using std::imag;
-  using std::log;
-
-  Scalar logA00 = log(A(0, 0));
-  Scalar logA11 = log(A(1, 1));
-
-  result(0, 0) = logA00;
-  result(1, 0) = Scalar(0);
-  result(1, 1) = logA11;
-
-  Scalar y = A(1, 1) - A(0, 0);
-  if (y == Scalar(0)) {
-    result(0, 1) = A(0, 1) / A(0, 0);
-  } else if ((abs(A(0, 0)) < RealScalar(0.5) * abs(A(1, 1))) || (abs(A(0, 0)) > 2 * abs(A(1, 1)))) {
-    result(0, 1) = A(0, 1) * (logA11 - logA00) / y;
-  } else {
-    // computation in previous branch is inaccurate if A(1,1) \approx A(0,0)
-    RealScalar unwindingNumber = ceil((imag(logA11 - logA00) - RealScalar(EIGEN_PI)) / RealScalar(2 * EIGEN_PI));
-    result(0, 1) = A(0, 1) * (numext::log1p(y / A(0, 0)) + Scalar(0, RealScalar(2 * EIGEN_PI) * unwindingNumber)) / y;
-  }
-}
-
-/* \brief Get suitable degree for Pade approximation. (specialized for RealScalar = float) */
-inline int matrix_log_get_pade_degree(float normTminusI) {
-  const float maxNormForPade[] = {2.5111573934555054e-1 /* degree = 3 */, 4.0535837411880493e-1, 5.3149729967117310e-1};
-  const int minPadeDegree = matrix_log_min_pade_degree<float>::value;
-  const int maxPadeDegree = matrix_log_max_pade_degree<float>::value;
-  int degree = minPadeDegree;
-  for (; degree <= maxPadeDegree; ++degree)
-    if (normTminusI <= maxNormForPade[degree - minPadeDegree]) break;
-  return degree;
-}
-
-/* \brief Get suitable degree for Pade approximation. (specialized for RealScalar = double) */
-inline int matrix_log_get_pade_degree(double normTminusI) {
-  const double maxNormForPade[] = {1.6206284795015624e-2 /* degree = 3 */, 5.3873532631381171e-2, 1.1352802267628681e-1,
-                                   1.8662860613541288e-1, 2.642960831111435e-1};
-  const int minPadeDegree = matrix_log_min_pade_degree<double>::value;
-  const int maxPadeDegree = matrix_log_max_pade_degree<double>::value;
-  int degree = minPadeDegree;
-  for (; degree <= maxPadeDegree; ++degree)
-    if (normTminusI <= maxNormForPade[degree - minPadeDegree]) break;
-  return degree;
-}
-
-/* \brief Get suitable degree for Pade approximation. (specialized for RealScalar = long double) */
-inline int matrix_log_get_pade_degree(long double normTminusI) {
-#if LDBL_MANT_DIG == 53  // double precision
-  const long double maxNormForPade[] = {1.6206284795015624e-2L /* degree = 3 */, 5.3873532631381171e-2L,
-                                        1.1352802267628681e-1L, 1.8662860613541288e-1L, 2.642960831111435e-1L};
-#elif LDBL_MANT_DIG <= 64   // extended precision
-  const long double maxNormForPade[] = {5.48256690357782863103e-3L /* degree = 3 */,
-                                        2.34559162387971167321e-2L,
-                                        5.84603923897347449857e-2L,
-                                        1.08486423756725170223e-1L,
-                                        1.68385767881294446649e-1L,
-                                        2.32777776523703892094e-1L};
-#elif LDBL_MANT_DIG <= 106  // double-double
-  const long double maxNormForPade[] = {8.58970550342939562202529664318890e-5L /* degree = 3 */,
-                                        9.34074328446359654039446552677759e-4L,
-                                        4.26117194647672175773064114582860e-3L,
-                                        1.21546224740281848743149666560464e-2L,
-                                        2.61100544998339436713088248557444e-2L,
-                                        4.66170074627052749243018566390567e-2L,
-                                        7.32585144444135027565872014932387e-2L,
-                                        1.05026503471351080481093652651105e-1L};
-#else                       // quadruple precision
-  const long double maxNormForPade[] = {4.7419931187193005048501568167858103e-5L /* degree = 3 */,
-                                        5.8853168473544560470387769480192666e-4L,
-                                        2.9216120366601315391789493628113520e-3L,
-                                        8.8415758124319434347116734705174308e-3L,
-                                        1.9850836029449446668518049562565291e-2L,
-                                        3.6688019729653446926585242192447447e-2L,
-                                        5.9290962294020186998954055264528393e-2L,
-                                        8.6998436081634343903250580992127677e-2L,
-                                        1.1880960220216759245467951592883642e-1L};
-#endif
-  const int minPadeDegree = matrix_log_min_pade_degree<long double>::value;
-  const int maxPadeDegree = matrix_log_max_pade_degree<long double>::value;
-  int degree = minPadeDegree;
-  for (; degree <= maxPadeDegree; ++degree)
-    if (normTminusI <= maxNormForPade[degree - minPadeDegree]) break;
-  return degree;
-}
-
-/* \brief Compute Pade approximation to matrix logarithm */
-template <typename MatrixType>
-void matrix_log_compute_pade(MatrixType& result, const MatrixType& T, int degree) {
-  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
-  const int minPadeDegree = 3;
-  const int maxPadeDegree = 11;
-  eigen_assert(degree >= minPadeDegree && degree <= maxPadeDegree);
-  // FIXME: This creates float-conversion warnings if these are enabled.
-  // Either manually convert each value, or disable the warning locally
-  const RealScalar nodes[][maxPadeDegree] = {
-      {0.1127016653792583114820734600217600L, 0.5000000000000000000000000000000000L,  // degree 3
-       0.8872983346207416885179265399782400L},
-      {0.0694318442029737123880267555535953L, 0.3300094782075718675986671204483777L,  // degree 4
-       0.6699905217924281324013328795516223L, 0.9305681557970262876119732444464048L},
-      {0.0469100770306680036011865608503035L, 0.2307653449471584544818427896498956L,  // degree 5
-       0.5000000000000000000000000000000000L, 0.7692346550528415455181572103501044L,
-       0.9530899229693319963988134391496965L},
-      {0.0337652428984239860938492227530027L, 0.1693953067668677431693002024900473L,  // degree 6
-       0.3806904069584015456847491391596440L, 0.6193095930415984543152508608403560L,
-       0.8306046932331322568306997975099527L, 0.9662347571015760139061507772469973L},
-      {0.0254460438286207377369051579760744L, 0.1292344072003027800680676133596058L,  // degree 7
-       0.2970774243113014165466967939615193L, 0.5000000000000000000000000000000000L,
-       0.7029225756886985834533032060384807L, 0.8707655927996972199319323866403942L,
-       0.9745539561713792622630948420239256L},
-      {0.0198550717512318841582195657152635L, 0.1016667612931866302042230317620848L,  // degree 8
-       0.2372337950418355070911304754053768L, 0.4082826787521750975302619288199080L,
-       0.5917173212478249024697380711800920L, 0.7627662049581644929088695245946232L,
-       0.8983332387068133697957769682379152L, 0.9801449282487681158417804342847365L},
-      {0.0159198802461869550822118985481636L, 0.0819844463366821028502851059651326L,  // degree 9
-       0.1933142836497048013456489803292629L, 0.3378732882980955354807309926783317L,
-       0.5000000000000000000000000000000000L, 0.6621267117019044645192690073216683L,
-       0.8066857163502951986543510196707371L, 0.9180155536633178971497148940348674L,
-       0.9840801197538130449177881014518364L},
-      {0.0130467357414141399610179939577740L, 0.0674683166555077446339516557882535L,  // degree 10
-       0.1602952158504877968828363174425632L, 0.2833023029353764046003670284171079L,
-       0.4255628305091843945575869994351400L, 0.5744371694908156054424130005648600L,
-       0.7166976970646235953996329715828921L, 0.8397047841495122031171636825574368L,
-       0.9325316833444922553660483442117465L, 0.9869532642585858600389820060422260L},
-      {0.0108856709269715035980309994385713L, 0.0564687001159523504624211153480364L,  // degree 11
-       0.1349239972129753379532918739844233L, 0.2404519353965940920371371652706952L,
-       0.3652284220238275138342340072995692L, 0.5000000000000000000000000000000000L,
-       0.6347715779761724861657659927004308L, 0.7595480646034059079628628347293048L,
-       0.8650760027870246620467081260155767L, 0.9435312998840476495375788846519636L,
-       0.9891143290730284964019690005614287L}};
-
-  const RealScalar weights[][maxPadeDegree] = {
-      {0.2777777777777777777777777777777778L, 0.4444444444444444444444444444444444L,  // degree 3
-       0.2777777777777777777777777777777778L},
-      {0.1739274225687269286865319746109997L, 0.3260725774312730713134680253890003L,  // degree 4
-       0.3260725774312730713134680253890003L, 0.1739274225687269286865319746109997L},
-      {0.1184634425280945437571320203599587L, 0.2393143352496832340206457574178191L,  // degree 5
-       0.2844444444444444444444444444444444L, 0.2393143352496832340206457574178191L,
-       0.1184634425280945437571320203599587L},
-      {0.0856622461895851725201480710863665L, 0.1803807865240693037849167569188581L,  // degree 6
-       0.2339569672863455236949351719947755L, 0.2339569672863455236949351719947755L,
-       0.1803807865240693037849167569188581L, 0.0856622461895851725201480710863665L},
-      {0.0647424830844348466353057163395410L, 0.1398526957446383339507338857118898L,  // degree 7
-       0.1909150252525594724751848877444876L, 0.2089795918367346938775510204081633L,
-       0.1909150252525594724751848877444876L, 0.1398526957446383339507338857118898L,
-       0.0647424830844348466353057163395410L},
-      {0.0506142681451881295762656771549811L, 0.1111905172266872352721779972131204L,  // degree 8
-       0.1568533229389436436689811009933007L, 0.1813418916891809914825752246385978L,
-       0.1813418916891809914825752246385978L, 0.1568533229389436436689811009933007L,
-       0.1111905172266872352721779972131204L, 0.0506142681451881295762656771549811L},
-      {0.0406371941807872059859460790552618L, 0.0903240803474287020292360156214564L,  // degree 9
-       0.1303053482014677311593714347093164L, 0.1561735385200014200343152032922218L,
-       0.1651196775006298815822625346434870L, 0.1561735385200014200343152032922218L,
-       0.1303053482014677311593714347093164L, 0.0903240803474287020292360156214564L,
-       0.0406371941807872059859460790552618L},
-      {0.0333356721543440687967844049466659L, 0.0747256745752902965728881698288487L,  // degree 10
-       0.1095431812579910219977674671140816L, 0.1346333596549981775456134607847347L,
-       0.1477621123573764350869464973256692L, 0.1477621123573764350869464973256692L,
-       0.1346333596549981775456134607847347L, 0.1095431812579910219977674671140816L,
-       0.0747256745752902965728881698288487L, 0.0333356721543440687967844049466659L},
-      {0.0278342835580868332413768602212743L, 0.0627901847324523123173471496119701L,  // degree 11
-       0.0931451054638671257130488207158280L, 0.1165968822959952399592618524215876L,
-       0.1314022722551233310903444349452546L, 0.1364625433889503153572417641681711L,
-       0.1314022722551233310903444349452546L, 0.1165968822959952399592618524215876L,
-       0.0931451054638671257130488207158280L, 0.0627901847324523123173471496119701L,
-       0.0278342835580868332413768602212743L}};
-
-  MatrixType TminusI = T - MatrixType::Identity(T.rows(), T.rows());
-  result.setZero(T.rows(), T.rows());
-  for (int k = 0; k < degree; ++k) {
-    RealScalar weight = weights[degree - minPadeDegree][k];
-    RealScalar node = nodes[degree - minPadeDegree][k];
-    result +=
-        weight *
-        (MatrixType::Identity(T.rows(), T.rows()) + node * TminusI).template triangularView<Upper>().solve(TminusI);
-  }
-}
-
-/** \brief Compute logarithm of triangular matrices with size > 2.
- * \details This uses a inverse scale-and-square algorithm. */
-template <typename MatrixType>
-void matrix_log_compute_big(const MatrixType& A, MatrixType& result) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  using std::pow;
-
-  int numberOfSquareRoots = 0;
-  int numberOfExtraSquareRoots = 0;
-  int degree;
-  MatrixType T = A, sqrtT;
-
-  const int maxPadeDegree = matrix_log_max_pade_degree<Scalar>::value;
-  const RealScalar maxNormForPade = RealScalar(maxPadeDegree <= 5 ? 5.3149729967117310e-1L :  // single precision
-                                                   maxPadeDegree <= 7 ? 2.6429608311114350e-1L
-                                                                      :  // double precision
-                                                   maxPadeDegree <= 8 ? 2.32777776523703892094e-1L
-                                                                      :  // extended precision
-                                                   maxPadeDegree <= 10 ? 1.05026503471351080481093652651105e-1L
-                                                                       :                       // double-double
-                                                   1.1880960220216759245467951592883642e-1L);  // quadruple precision
-
-  while (true) {
-    RealScalar normTminusI = (T - MatrixType::Identity(T.rows(), T.rows())).cwiseAbs().colwise().sum().maxCoeff();
-    if (normTminusI < maxNormForPade) {
-      degree = matrix_log_get_pade_degree(normTminusI);
-      int degree2 = matrix_log_get_pade_degree(normTminusI / RealScalar(2));
-      if ((degree - degree2 <= 1) || (numberOfExtraSquareRoots == 1)) break;
-      ++numberOfExtraSquareRoots;
-    }
-    matrix_sqrt_triangular(T, sqrtT);
-    T = sqrtT.template triangularView<Upper>();
-    ++numberOfSquareRoots;
-  }
-
-  matrix_log_compute_pade(result, T, degree);
-  result *= pow(RealScalar(2), RealScalar(numberOfSquareRoots));  // TODO: Replace by bitshift if possible.
-}
-
-/** \ingroup MatrixFunctions_Module
- * \class MatrixLogarithmAtomic
- * \brief Helper class for computing matrix logarithm of atomic matrices.
- *
- * Here, an atomic matrix is a triangular matrix whose diagonal entries are close to each other.
- *
- * \sa class MatrixFunctionAtomic, MatrixBase::log()
- */
-template <typename MatrixType>
-class MatrixLogarithmAtomic {
- public:
-  /** \brief Compute matrix logarithm of atomic matrix
-   * \param[in]  A  argument of matrix logarithm, should be upper triangular and atomic
-   * \returns  The logarithm of \p A.
-   */
-  MatrixType compute(const MatrixType& A);
-};
-
-template <typename MatrixType>
-MatrixType MatrixLogarithmAtomic<MatrixType>::compute(const MatrixType& A) {
-  using std::log;
-  MatrixType result(A.rows(), A.rows());
-  if (A.rows() == 1)
-    result(0, 0) = log(A(0, 0));
-  else if (A.rows() == 2)
-    matrix_log_compute_2x2(A, result);
-  else
-    matrix_log_compute_big(A, result);
-  return result;
-}
-
-}  // end of namespace internal
-
-/** \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix logarithm of some matrix (expression).
- *
- * \tparam Derived  Type of the argument to the matrix function.
- *
- * This class holds the argument to the matrix function until it is
- * assigned or evaluated for some other reason (so the argument
- * should not be changed in the meantime). It is the return type of
- * MatrixBase::log() and most of the time this is the only way it
- * is used.
- */
-template <typename Derived>
-class MatrixLogarithmReturnValue : public ReturnByValue<MatrixLogarithmReturnValue<Derived> > {
- public:
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::Index Index;
-
- protected:
-  typedef typename internal::ref_selector<Derived>::type DerivedNested;
-
- public:
-  /** \brief Constructor.
-   *
-   * \param[in]  A  %Matrix (expression) forming the argument of the matrix logarithm.
-   */
-  explicit MatrixLogarithmReturnValue(const Derived& A) : m_A(A) {}
-
-  /** \brief Compute the matrix logarithm.
-   *
-   * \param[out]  result  Logarithm of \c A, where \c A is as specified in the constructor.
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    typedef typename internal::nested_eval<Derived, 10>::type DerivedEvalType;
-    typedef internal::remove_all_t<DerivedEvalType> DerivedEvalTypeClean;
-    typedef internal::traits<DerivedEvalTypeClean> Traits;
-    typedef internal::make_complex_t<Scalar> ComplexScalar;
-    typedef Matrix<ComplexScalar, Dynamic, Dynamic, 0, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime>
-        DynMatrixType;
-    typedef internal::MatrixLogarithmAtomic<DynMatrixType> AtomicType;
-    AtomicType atomic;
-
-    internal::matrix_function_compute<typename DerivedEvalTypeClean::PlainObject>::run(m_A, atomic, result);
-  }
-
-  Index rows() const { return m_A.rows(); }
-  Index cols() const { return m_A.cols(); }
-
- private:
-  const DerivedNested m_A;
-};
-
-namespace internal {
-template <typename Derived>
-struct traits<MatrixLogarithmReturnValue<Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
-};
-}  // namespace internal
-
-/********** MatrixBase method **********/
-
-template <typename Derived>
-const MatrixLogarithmReturnValue<Derived> MatrixBase<Derived>::log() const {
-  eigen_assert(rows() == cols());
-  return MatrixLogarithmReturnValue<Derived>(derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MATRIX_LOGARITHM
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixPower.h b/unsupported/Eigen/src/MatrixFunctions/MatrixPower.h
deleted file mode 100644
index 8e0a2f1..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixPower.h
+++ /dev/null
@@ -1,694 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012, 2013 Chen-Pang He <jdh8@ms63.hinet.net>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MATRIX_POWER
-#define EIGEN_MATRIX_POWER
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename MatrixType>
-class MatrixPower;
-
-/**
- * \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix power of some matrix.
- *
- * \tparam MatrixType  type of the base, a matrix.
- *
- * This class holds the arguments to the matrix power until it is
- * assigned or evaluated for some other reason (so the argument
- * should not be changed in the meantime). It is the return type of
- * MatrixPower::operator() and related functions and most of the
- * time this is the only way it is used.
- */
-/* TODO: This class is only used by MatrixPower, so it should be nested
- * into MatrixPower, like MatrixPower::ReturnValue. However, my
- * compiler complained about unused template parameter in the
- * following declaration in namespace internal.
- *
- * template<typename MatrixType>
- * struct traits<MatrixPower<MatrixType>::ReturnValue>;
- */
-template <typename MatrixType>
-class MatrixPowerParenthesesReturnValue : public ReturnByValue<MatrixPowerParenthesesReturnValue<MatrixType> > {
- public:
-  typedef typename MatrixType::RealScalar RealScalar;
-
-  /**
-   * \brief Constructor.
-   *
-   * \param[in] pow  %MatrixPower storing the base.
-   * \param[in] p    scalar, the exponent of the matrix power.
-   */
-  MatrixPowerParenthesesReturnValue(MatrixPower<MatrixType>& pow, RealScalar p) : m_pow(pow), m_p(p) {}
-
-  /**
-   * \brief Compute the matrix power.
-   *
-   * \param[out] result
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    m_pow.compute(result, m_p);
-  }
-
-  Index rows() const { return m_pow.rows(); }
-  Index cols() const { return m_pow.cols(); }
-
- private:
-  MatrixPower<MatrixType>& m_pow;
-  const RealScalar m_p;
-};
-
-/**
- * \ingroup MatrixFunctions_Module
- *
- * \brief Class for computing matrix powers.
- *
- * \tparam MatrixType  type of the base, expected to be an instantiation
- * of the Matrix class template.
- *
- * This class is capable of computing triangular real/complex matrices
- * raised to a power in the interval \f$ (-1, 1) \f$.
- *
- * \note Currently this class is only used by MatrixPower. One may
- * insist that this be nested into MatrixPower. This class is here to
- * facilitate future development of triangular matrix functions.
- */
-template <typename MatrixType>
-class MatrixPowerAtomic : internal::noncopyable {
- private:
-  enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime };
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef Block<MatrixType, Dynamic, Dynamic> ResultType;
-
-  const MatrixType& m_A;
-  RealScalar m_p;
-
-  void computePade(int degree, const MatrixType& IminusT, ResultType& res) const;
-  void compute2x2(ResultType& res, RealScalar p) const;
-  void computeBig(ResultType& res) const;
-  static int getPadeDegree(float normIminusT);
-  static int getPadeDegree(double normIminusT);
-  static int getPadeDegree(long double normIminusT);
-  static ComplexScalar computeSuperDiag(const ComplexScalar&, const ComplexScalar&, RealScalar p);
-  static RealScalar computeSuperDiag(RealScalar, RealScalar, RealScalar p);
-
- public:
-  /**
-   * \brief Constructor.
-   *
-   * \param[in] T  the base of the matrix power.
-   * \param[in] p  the exponent of the matrix power, should be in
-   * \f$ (-1, 1) \f$.
-   *
-   * The class stores a reference to T, so it should not be changed
-   * (or destroyed) before evaluation. Only the upper triangular
-   * part of T is read.
-   */
-  MatrixPowerAtomic(const MatrixType& T, RealScalar p);
-
-  /**
-   * \brief Compute the matrix power.
-   *
-   * \param[out] res  \f$ A^p \f$ where A and p are specified in the
-   * constructor.
-   */
-  void compute(ResultType& res) const;
-};
-
-template <typename MatrixType>
-MatrixPowerAtomic<MatrixType>::MatrixPowerAtomic(const MatrixType& T, RealScalar p) : m_A(T), m_p(p) {
-  eigen_assert(T.rows() == T.cols());
-  eigen_assert(p > -1 && p < 1);
-}
-
-template <typename MatrixType>
-void MatrixPowerAtomic<MatrixType>::compute(ResultType& res) const {
-  using std::pow;
-  switch (m_A.rows()) {
-    case 0:
-      break;
-    case 1:
-      res(0, 0) = pow(m_A(0, 0), m_p);
-      break;
-    case 2:
-      compute2x2(res, m_p);
-      break;
-    default:
-      computeBig(res);
-  }
-}
-
-template <typename MatrixType>
-void MatrixPowerAtomic<MatrixType>::computePade(int degree, const MatrixType& IminusT, ResultType& res) const {
-  int i = 2 * degree;
-  res = (m_p - RealScalar(degree)) / RealScalar(2 * i - 2) * IminusT;
-
-  for (--i; i; --i) {
-    res = (MatrixType::Identity(IminusT.rows(), IminusT.cols()) + res)
-              .template triangularView<Upper>()
-              .solve((i == 1  ? -m_p
-                      : i & 1 ? (-m_p - RealScalar(i / 2)) / RealScalar(2 * i)
-                              : (m_p - RealScalar(i / 2)) / RealScalar(2 * i - 2)) *
-                     IminusT)
-              .eval();
-  }
-  res += MatrixType::Identity(IminusT.rows(), IminusT.cols());
-}
-
-// This function assumes that res has the correct size (see bug 614)
-template <typename MatrixType>
-void MatrixPowerAtomic<MatrixType>::compute2x2(ResultType& res, RealScalar p) const {
-  using std::abs;
-  using std::pow;
-  res.coeffRef(0, 0) = pow(m_A.coeff(0, 0), p);
-
-  for (Index i = 1; i < m_A.cols(); ++i) {
-    res.coeffRef(i, i) = pow(m_A.coeff(i, i), p);
-    if (m_A.coeff(i - 1, i - 1) == m_A.coeff(i, i))
-      res.coeffRef(i - 1, i) = p * pow(m_A.coeff(i, i), p - 1);
-    else if (2 * abs(m_A.coeff(i - 1, i - 1)) < abs(m_A.coeff(i, i)) ||
-             2 * abs(m_A.coeff(i, i)) < abs(m_A.coeff(i - 1, i - 1)))
-      res.coeffRef(i - 1, i) =
-          (res.coeff(i, i) - res.coeff(i - 1, i - 1)) / (m_A.coeff(i, i) - m_A.coeff(i - 1, i - 1));
-    else
-      res.coeffRef(i - 1, i) = computeSuperDiag(m_A.coeff(i, i), m_A.coeff(i - 1, i - 1), p);
-    res.coeffRef(i - 1, i) *= m_A.coeff(i - 1, i);
-  }
-}
-
-template <typename MatrixType>
-void MatrixPowerAtomic<MatrixType>::computeBig(ResultType& res) const {
-  using std::ldexp;
-  const int digits = std::numeric_limits<RealScalar>::digits;
-  const RealScalar maxNormForPade =
-      RealScalar(digits <= 24    ? 4.3386528e-1L                              // single precision
-                 : digits <= 53  ? 2.789358995219730e-1L                      // double precision
-                 : digits <= 64  ? 2.4471944416607995472e-1L                  // extended precision
-                 : digits <= 106 ? 1.1016843812851143391275867258512e-1L      // double-double
-                                 : 9.134603732914548552537150753385375e-2L);  // quadruple precision
-  MatrixType IminusT, sqrtT, T = m_A.template triangularView<Upper>();
-  RealScalar normIminusT;
-  int degree, degree2, numberOfSquareRoots = 0;
-  bool hasExtraSquareRoot = false;
-
-  for (Index i = 0; i < m_A.cols(); ++i) eigen_assert(m_A(i, i) != RealScalar(0));
-
-  while (true) {
-    IminusT = MatrixType::Identity(m_A.rows(), m_A.cols()) - T;
-    normIminusT = IminusT.cwiseAbs().colwise().sum().maxCoeff();
-    if (normIminusT < maxNormForPade) {
-      degree = getPadeDegree(normIminusT);
-      degree2 = getPadeDegree(normIminusT / 2);
-      if (degree - degree2 <= 1 || hasExtraSquareRoot) break;
-      hasExtraSquareRoot = true;
-    }
-    matrix_sqrt_triangular(T, sqrtT);
-    T = sqrtT.template triangularView<Upper>();
-    ++numberOfSquareRoots;
-  }
-  computePade(degree, IminusT, res);
-
-  for (; numberOfSquareRoots; --numberOfSquareRoots) {
-    compute2x2(res, ldexp(m_p, -numberOfSquareRoots));
-    res = res.template triangularView<Upper>() * res;
-  }
-  compute2x2(res, m_p);
-}
-
-template <typename MatrixType>
-inline int MatrixPowerAtomic<MatrixType>::getPadeDegree(float normIminusT) {
-  const float maxNormForPade[] = {2.8064004e-1f /* degree = 3 */, 4.3386528e-1f};
-  int degree = 3;
-  for (; degree <= 4; ++degree)
-    if (normIminusT <= maxNormForPade[degree - 3]) break;
-  return degree;
-}
-
-template <typename MatrixType>
-inline int MatrixPowerAtomic<MatrixType>::getPadeDegree(double normIminusT) {
-  const double maxNormForPade[] = {1.884160592658218e-2 /* degree = 3 */, 6.038881904059573e-2, 1.239917516308172e-1,
-                                   1.999045567181744e-1, 2.789358995219730e-1};
-  int degree = 3;
-  for (; degree <= 7; ++degree)
-    if (normIminusT <= maxNormForPade[degree - 3]) break;
-  return degree;
-}
-
-template <typename MatrixType>
-inline int MatrixPowerAtomic<MatrixType>::getPadeDegree(long double normIminusT) {
-#if LDBL_MANT_DIG == 53
-  const int maxPadeDegree = 7;
-  const double maxNormForPade[] = {1.884160592658218e-2L /* degree = 3 */, 6.038881904059573e-2L, 1.239917516308172e-1L,
-                                   1.999045567181744e-1L, 2.789358995219730e-1L};
-#elif LDBL_MANT_DIG <= 64
-  const int maxPadeDegree = 8;
-  const long double maxNormForPade[] = {6.3854693117491799460e-3L /* degree = 3 */,
-                                        2.6394893435456973676e-2L,
-                                        6.4216043030404063729e-2L,
-                                        1.1701165502926694307e-1L,
-                                        1.7904284231268670284e-1L,
-                                        2.4471944416607995472e-1L};
-#elif LDBL_MANT_DIG <= 106
-  const int maxPadeDegree = 10;
-  const double maxNormForPade[] = {1.0007161601787493236741409687186e-4L /* degree = 3 */,
-                                   1.0007161601787493236741409687186e-3L,
-                                   4.7069769360887572939882574746264e-3L,
-                                   1.3220386624169159689406653101695e-2L,
-                                   2.8063482381631737920612944054906e-2L,
-                                   4.9625993951953473052385361085058e-2L,
-                                   7.7367040706027886224557538328171e-2L,
-                                   1.1016843812851143391275867258512e-1L};
-#else
-  const int maxPadeDegree = 10;
-  const double maxNormForPade[] = {5.524506147036624377378713555116378e-5L /* degree = 3 */,
-                                   6.640600568157479679823602193345995e-4L,
-                                   3.227716520106894279249709728084626e-3L,
-                                   9.619593944683432960546978734646284e-3L,
-                                   2.134595382433742403911124458161147e-2L,
-                                   3.908166513900489428442993794761185e-2L,
-                                   6.266780814639442865832535460550138e-2L,
-                                   9.134603732914548552537150753385375e-2L};
-#endif
-  int degree = 3;
-  for (; degree <= maxPadeDegree; ++degree)
-    if (normIminusT <= static_cast<long double>(maxNormForPade[degree - 3])) break;
-  return degree;
-}
-
-template <typename MatrixType>
-inline typename MatrixPowerAtomic<MatrixType>::ComplexScalar MatrixPowerAtomic<MatrixType>::computeSuperDiag(
-    const ComplexScalar& curr, const ComplexScalar& prev, RealScalar p) {
-  using std::ceil;
-  using std::exp;
-  using std::log;
-  using std::sinh;
-
-  ComplexScalar logCurr = log(curr);
-  ComplexScalar logPrev = log(prev);
-  RealScalar unwindingNumber =
-      ceil((numext::imag(logCurr - logPrev) - RealScalar(EIGEN_PI)) / RealScalar(2 * EIGEN_PI));
-  ComplexScalar w =
-      numext::log1p((curr - prev) / prev) / RealScalar(2) + ComplexScalar(0, RealScalar(EIGEN_PI) * unwindingNumber);
-  return RealScalar(2) * exp(RealScalar(0.5) * p * (logCurr + logPrev)) * sinh(p * w) / (curr - prev);
-}
-
-template <typename MatrixType>
-inline typename MatrixPowerAtomic<MatrixType>::RealScalar MatrixPowerAtomic<MatrixType>::computeSuperDiag(
-    RealScalar curr, RealScalar prev, RealScalar p) {
-  using std::exp;
-  using std::log;
-  using std::sinh;
-
-  RealScalar w = numext::log1p((curr - prev) / prev) / RealScalar(2);
-  return 2 * exp(p * (log(curr) + log(prev)) / 2) * sinh(p * w) / (curr - prev);
-}
-
-/**
- * \ingroup MatrixFunctions_Module
- *
- * \brief Class for computing matrix powers.
- *
- * \tparam MatrixType  type of the base, expected to be an instantiation
- * of the Matrix class template.
- *
- * This class is capable of computing real/complex matrices raised to
- * an arbitrary real power. Meanwhile, it saves the result of Schur
- * decomposition if an non-integral power has even been calculated.
- * Therefore, if you want to compute multiple (>= 2) matrix powers
- * for the same matrix, using the class directly is more efficient than
- * calling MatrixBase::pow().
- *
- * Example:
- * \include MatrixPower_optimal.cpp
- * Output: \verbinclude MatrixPower_optimal.out
- */
-template <typename MatrixType>
-class MatrixPower : internal::noncopyable {
- private:
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-
- public:
-  /**
-   * \brief Constructor.
-   *
-   * \param[in] A  the base of the matrix power.
-   *
-   * The class stores a reference to A, so it should not be changed
-   * (or destroyed) before evaluation.
-   */
-  explicit MatrixPower(const MatrixType& A) : m_A(A), m_conditionNumber(0), m_rank(A.cols()), m_nulls(0) {
-    eigen_assert(A.rows() == A.cols());
-  }
-
-  /**
-   * \brief Returns the matrix power.
-   *
-   * \param[in] p  exponent, a real scalar.
-   * \return The expression \f$ A^p \f$, where A is specified in the
-   * constructor.
-   */
-  const MatrixPowerParenthesesReturnValue<MatrixType> operator()(RealScalar p) {
-    return MatrixPowerParenthesesReturnValue<MatrixType>(*this, p);
-  }
-
-  /**
-   * \brief Compute the matrix power.
-   *
-   * \param[in]  p    exponent, a real scalar.
-   * \param[out] res  \f$ A^p \f$ where A is specified in the
-   * constructor.
-   */
-  template <typename ResultType>
-  void compute(ResultType& res, RealScalar p);
-
-  Index rows() const { return m_A.rows(); }
-  Index cols() const { return m_A.cols(); }
-
- private:
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef Matrix<ComplexScalar, Dynamic, Dynamic, 0, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>
-      ComplexMatrix;
-
-  /** \brief Reference to the base of matrix power. */
-  typename MatrixType::Nested m_A;
-
-  /** \brief Temporary storage. */
-  MatrixType m_tmp;
-
-  /** \brief Store the result of Schur decomposition. */
-  ComplexMatrix m_T, m_U;
-
-  /** \brief Store fractional power of m_T. */
-  ComplexMatrix m_fT;
-
-  /**
-   * \brief Condition number of m_A.
-   *
-   * It is initialized as 0 to avoid performing unnecessary Schur
-   * decomposition, which is the bottleneck.
-   */
-  RealScalar m_conditionNumber;
-
-  /** \brief Rank of m_A. */
-  Index m_rank;
-
-  /** \brief Rank deficiency of m_A. */
-  Index m_nulls;
-
-  /**
-   * \brief Split p into integral part and fractional part.
-   *
-   * \param[in]  p        The exponent.
-   * \param[out] p        The fractional part ranging in \f$ (-1, 1) \f$.
-   * \param[out] intpart  The integral part.
-   *
-   * Only if the fractional part is nonzero, it calls initialize().
-   */
-  void split(RealScalar& p, RealScalar& intpart);
-
-  /** \brief Perform Schur decomposition for fractional power. */
-  void initialize();
-
-  template <typename ResultType>
-  void computeIntPower(ResultType& res, RealScalar p);
-
-  template <typename ResultType>
-  void computeFracPower(ResultType& res, RealScalar p);
-
-  template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
-  static void revertSchur(Matrix<ComplexScalar, Rows, Cols, Options, MaxRows, MaxCols>& res, const ComplexMatrix& T,
-                          const ComplexMatrix& U);
-
-  template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
-  static void revertSchur(Matrix<RealScalar, Rows, Cols, Options, MaxRows, MaxCols>& res, const ComplexMatrix& T,
-                          const ComplexMatrix& U);
-};
-
-template <typename MatrixType>
-template <typename ResultType>
-void MatrixPower<MatrixType>::compute(ResultType& res, RealScalar p) {
-  using std::pow;
-  switch (cols()) {
-    case 0:
-      break;
-    case 1:
-      res(0, 0) = pow(m_A.coeff(0, 0), p);
-      break;
-    default:
-      RealScalar intpart;
-      split(p, intpart);
-
-      res = MatrixType::Identity(rows(), cols());
-      computeIntPower(res, intpart);
-      if (p) computeFracPower(res, p);
-  }
-}
-
-template <typename MatrixType>
-void MatrixPower<MatrixType>::split(RealScalar& p, RealScalar& intpart) {
-  using std::floor;
-  using std::pow;
-
-  intpart = floor(p);
-  p -= intpart;
-
-  // Perform Schur decomposition if it is not yet performed and the power is
-  // not an integer.
-  if (!m_conditionNumber && p) initialize();
-
-  // Choose the more stable of intpart = floor(p) and intpart = ceil(p).
-  if (p > RealScalar(0.5) && p > (1 - p) * pow(m_conditionNumber, p)) {
-    --p;
-    ++intpart;
-  }
-}
-
-template <typename MatrixType>
-void MatrixPower<MatrixType>::initialize() {
-  const ComplexSchur<MatrixType> schurOfA(m_A);
-  JacobiRotation<ComplexScalar> rot;
-  ComplexScalar eigenvalue;
-
-  m_fT.resizeLike(m_A);
-  m_T = schurOfA.matrixT();
-  m_U = schurOfA.matrixU();
-  m_conditionNumber = m_T.diagonal().array().abs().maxCoeff() / m_T.diagonal().array().abs().minCoeff();
-
-  // Move zero eigenvalues to the bottom right corner.
-  for (Index i = cols() - 1; i >= 0; --i) {
-    if (m_rank <= 2) return;
-    if (m_T.coeff(i, i) == RealScalar(0)) {
-      for (Index j = i + 1; j < m_rank; ++j) {
-        eigenvalue = m_T.coeff(j, j);
-        rot.makeGivens(m_T.coeff(j - 1, j), eigenvalue);
-        m_T.applyOnTheRight(j - 1, j, rot);
-        m_T.applyOnTheLeft(j - 1, j, rot.adjoint());
-        m_T.coeffRef(j - 1, j - 1) = eigenvalue;
-        m_T.coeffRef(j, j) = RealScalar(0);
-        m_U.applyOnTheRight(j - 1, j, rot);
-      }
-      --m_rank;
-    }
-  }
-
-  m_nulls = rows() - m_rank;
-  if (m_nulls) {
-    eigen_assert(m_T.bottomRightCorner(m_nulls, m_nulls).isZero() &&
-                 "Base of matrix power should be invertible or with a semisimple zero eigenvalue.");
-    m_fT.bottomRows(m_nulls).fill(RealScalar(0));
-  }
-}
-
-template <typename MatrixType>
-template <typename ResultType>
-void MatrixPower<MatrixType>::computeIntPower(ResultType& res, RealScalar p) {
-  using std::abs;
-  using std::fmod;
-  RealScalar pp = abs(p);
-
-  if (p < 0)
-    m_tmp = m_A.inverse();
-  else
-    m_tmp = m_A;
-
-  while (true) {
-    if (fmod(pp, 2) >= 1) res = m_tmp * res;
-    pp /= 2;
-    if (pp < 1) break;
-    m_tmp *= m_tmp;
-  }
-}
-
-template <typename MatrixType>
-template <typename ResultType>
-void MatrixPower<MatrixType>::computeFracPower(ResultType& res, RealScalar p) {
-  Block<ComplexMatrix, Dynamic, Dynamic> blockTp(m_fT, 0, 0, m_rank, m_rank);
-  eigen_assert(m_conditionNumber);
-  eigen_assert(m_rank + m_nulls == rows());
-
-  MatrixPowerAtomic<ComplexMatrix>(m_T.topLeftCorner(m_rank, m_rank), p).compute(blockTp);
-  if (m_nulls) {
-    m_fT.topRightCorner(m_rank, m_nulls) = m_T.topLeftCorner(m_rank, m_rank)
-                                               .template triangularView<Upper>()
-                                               .solve(blockTp * m_T.topRightCorner(m_rank, m_nulls));
-  }
-  revertSchur(m_tmp, m_fT, m_U);
-  res = m_tmp * res;
-}
-
-template <typename MatrixType>
-template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
-inline void MatrixPower<MatrixType>::revertSchur(Matrix<ComplexScalar, Rows, Cols, Options, MaxRows, MaxCols>& res,
-                                                 const ComplexMatrix& T, const ComplexMatrix& U) {
-  res.noalias() = U * (T.template triangularView<Upper>() * U.adjoint());
-}
-
-template <typename MatrixType>
-template <int Rows, int Cols, int Options, int MaxRows, int MaxCols>
-inline void MatrixPower<MatrixType>::revertSchur(Matrix<RealScalar, Rows, Cols, Options, MaxRows, MaxCols>& res,
-                                                 const ComplexMatrix& T, const ComplexMatrix& U) {
-  res.noalias() = (U * (T.template triangularView<Upper>() * U.adjoint())).real();
-}
-
-/**
- * \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix power of some matrix (expression).
- *
- * \tparam Derived  type of the base, a matrix (expression).
- *
- * This class holds the arguments to the matrix power until it is
- * assigned or evaluated for some other reason (so the argument
- * should not be changed in the meantime). It is the return type of
- * MatrixBase::pow() and related functions and most of the
- * time this is the only way it is used.
- */
-template <typename Derived>
-class MatrixPowerReturnValue : public ReturnByValue<MatrixPowerReturnValue<Derived> > {
- public:
-  typedef typename Derived::PlainObject PlainObject;
-  typedef typename Derived::RealScalar RealScalar;
-
-  /**
-   * \brief Constructor.
-   *
-   * \param[in] A  %Matrix (expression), the base of the matrix power.
-   * \param[in] p  real scalar, the exponent of the matrix power.
-   */
-  MatrixPowerReturnValue(const Derived& A, RealScalar p) : m_A(A), m_p(p) {}
-
-  /**
-   * \brief Compute the matrix power.
-   *
-   * \param[out] result  \f$ A^p \f$ where \p A and \p p are as in the
-   * constructor.
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    MatrixPower<PlainObject>(m_A.eval()).compute(result, m_p);
-  }
-
-  Index rows() const { return m_A.rows(); }
-  Index cols() const { return m_A.cols(); }
-
- private:
-  const Derived& m_A;
-  const RealScalar m_p;
-};
-
-/**
- * \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix power of some matrix (expression).
- *
- * \tparam Derived  type of the base, a matrix (expression).
- *
- * This class holds the arguments to the matrix power until it is
- * assigned or evaluated for some other reason (so the argument
- * should not be changed in the meantime). It is the return type of
- * MatrixBase::pow() and related functions and most of the
- * time this is the only way it is used.
- */
-template <typename Derived>
-class MatrixComplexPowerReturnValue : public ReturnByValue<MatrixComplexPowerReturnValue<Derived> > {
- public:
-  typedef typename Derived::PlainObject PlainObject;
-  typedef internal::make_complex_t<typename Derived::Scalar> ComplexScalar;
-
-  /**
-   * \brief Constructor.
-   *
-   * \param[in] A  %Matrix (expression), the base of the matrix power.
-   * \param[in] p  complex scalar, the exponent of the matrix power.
-   */
-  MatrixComplexPowerReturnValue(const Derived& A, const ComplexScalar& p) : m_A(A), m_p(p) {}
-
-  /**
-   * \brief Compute the matrix power.
-   *
-   * Because \p p is complex, \f$ A^p \f$ is simply evaluated as \f$
-   * \exp(p \log(A)) \f$.
-   *
-   * \param[out] result  \f$ A^p \f$ where \p A and \p p are as in the
-   * constructor.
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    result = (m_p * m_A.log()).exp();
-  }
-
-  Index rows() const { return m_A.rows(); }
-  Index cols() const { return m_A.cols(); }
-
- private:
-  const Derived& m_A;
-  const ComplexScalar m_p;
-};
-
-namespace internal {
-
-template <typename MatrixPowerType>
-struct traits<MatrixPowerParenthesesReturnValue<MatrixPowerType> > {
-  typedef typename MatrixPowerType::PlainObject ReturnType;
-};
-
-template <typename Derived>
-struct traits<MatrixPowerReturnValue<Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
-};
-
-template <typename Derived>
-struct traits<MatrixComplexPowerReturnValue<Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
-};
-
-}  // namespace internal
-
-template <typename Derived>
-const MatrixPowerReturnValue<Derived> MatrixBase<Derived>::pow(const RealScalar& p) const {
-  return MatrixPowerReturnValue<Derived>(derived(), p);
-}
-
-template <typename Derived>
-const MatrixComplexPowerReturnValue<Derived> MatrixBase<Derived>::pow(const internal::make_complex_t<Scalar>& p) const {
-  return MatrixComplexPowerReturnValue<Derived>(derived(), p);
-}
-
-}  // namespace Eigen
-
-#endif  // EIGEN_MATRIX_POWER
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixSquareRoot.h b/unsupported/Eigen/src/MatrixFunctions/MatrixSquareRoot.h
deleted file mode 100644
index 34e7531..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixSquareRoot.h
+++ /dev/null
@@ -1,345 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_MATRIX_SQUARE_ROOT
-#define EIGEN_MATRIX_SQUARE_ROOT
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// pre:  T.block(i,i,2,2) has complex conjugate eigenvalues
-// post: sqrtT.block(i,i,2,2) is square root of T.block(i,i,2,2)
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_2x2_diagonal_block(const MatrixType& T, Index i, ResultType& sqrtT) {
-  // TODO: this 2x2 complex-conjugate eigenvalue case could reuse logic from EigenSolver if exposed.
-  typedef typename traits<MatrixType>::Scalar Scalar;
-  Matrix<Scalar, 2, 2> block = T.template block<2, 2>(i, i);
-  EigenSolver<Matrix<Scalar, 2, 2> > es(block);
-  sqrtT.template block<2, 2>(i, i) =
-      (es.eigenvectors() * es.eigenvalues().cwiseSqrt().asDiagonal() * es.eigenvectors().inverse()).real();
-}
-
-// pre:  block structure of T is such that (i,j) is a 1x1 block,
-//       all blocks of sqrtT to left of and below (i,j) are correct
-// post: sqrtT(i,j) has the correct value
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
-  typedef typename traits<MatrixType>::Scalar Scalar;
-  Scalar tmp = (sqrtT.row(i).segment(i + 1, j - i - 1) * sqrtT.col(j).segment(i + 1, j - i - 1)).value();
-  sqrtT.coeffRef(i, j) = (T.coeff(i, j) - tmp) / (sqrtT.coeff(i, i) + sqrtT.coeff(j, j));
-}
-
-// similar to compute1x1offDiagonalBlock()
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_1x2_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
-  typedef typename traits<MatrixType>::Scalar Scalar;
-  Matrix<Scalar, 1, 2> rhs = T.template block<1, 2>(i, j);
-  if (j - i > 1) rhs -= sqrtT.block(i, i + 1, 1, j - i - 1) * sqrtT.block(i + 1, j, j - i - 1, 2);
-  Matrix<Scalar, 2, 2> A = sqrtT.coeff(i, i) * Matrix<Scalar, 2, 2>::Identity();
-  A += sqrtT.template block<2, 2>(j, j).transpose();
-  sqrtT.template block<1, 2>(i, j).transpose() = A.fullPivLu().solve(rhs.transpose());
-}
-
-// similar to compute1x1offDiagonalBlock()
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_2x1_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
-  typedef typename traits<MatrixType>::Scalar Scalar;
-  Matrix<Scalar, 2, 1> rhs = T.template block<2, 1>(i, j);
-  if (j - i > 2) rhs -= sqrtT.block(i, i + 2, 2, j - i - 2) * sqrtT.block(i + 2, j, j - i - 2, 1);
-  Matrix<Scalar, 2, 2> A = sqrtT.coeff(j, j) * Matrix<Scalar, 2, 2>::Identity();
-  A += sqrtT.template block<2, 2>(i, i);
-  sqrtT.template block<2, 1>(i, j) = A.fullPivLu().solve(rhs);
-}
-
-// solves the equation A X + X B = C where all matrices are 2-by-2
-template <typename MatrixType>
-void matrix_sqrt_quasi_triangular_solve_auxiliary_equation(MatrixType& X, const MatrixType& A, const MatrixType& B,
-                                                           const MatrixType& C) {
-  typedef typename traits<MatrixType>::Scalar Scalar;
-  Matrix<Scalar, 4, 4> coeffMatrix = Matrix<Scalar, 4, 4>::Zero();
-  coeffMatrix.coeffRef(0, 0) = A.coeff(0, 0) + B.coeff(0, 0);
-  coeffMatrix.coeffRef(1, 1) = A.coeff(0, 0) + B.coeff(1, 1);
-  coeffMatrix.coeffRef(2, 2) = A.coeff(1, 1) + B.coeff(0, 0);
-  coeffMatrix.coeffRef(3, 3) = A.coeff(1, 1) + B.coeff(1, 1);
-  coeffMatrix.coeffRef(0, 1) = B.coeff(1, 0);
-  coeffMatrix.coeffRef(0, 2) = A.coeff(0, 1);
-  coeffMatrix.coeffRef(1, 0) = B.coeff(0, 1);
-  coeffMatrix.coeffRef(1, 3) = A.coeff(0, 1);
-  coeffMatrix.coeffRef(2, 0) = A.coeff(1, 0);
-  coeffMatrix.coeffRef(2, 3) = B.coeff(1, 0);
-  coeffMatrix.coeffRef(3, 1) = A.coeff(1, 0);
-  coeffMatrix.coeffRef(3, 2) = B.coeff(0, 1);
-
-  Matrix<Scalar, 4, 1> rhs;
-  rhs.coeffRef(0) = C.coeff(0, 0);
-  rhs.coeffRef(1) = C.coeff(0, 1);
-  rhs.coeffRef(2) = C.coeff(1, 0);
-  rhs.coeffRef(3) = C.coeff(1, 1);
-
-  Matrix<Scalar, 4, 1> result;
-  result = coeffMatrix.fullPivLu().solve(rhs);
-
-  X.coeffRef(0, 0) = result.coeff(0);
-  X.coeffRef(0, 1) = result.coeff(1);
-  X.coeffRef(1, 0) = result.coeff(2);
-  X.coeffRef(1, 1) = result.coeff(3);
-}
-
-// similar to compute1x1offDiagonalBlock()
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_2x2_off_diagonal_block(const MatrixType& T, Index i, Index j, ResultType& sqrtT) {
-  typedef typename traits<MatrixType>::Scalar Scalar;
-  Matrix<Scalar, 2, 2> A = sqrtT.template block<2, 2>(i, i);
-  Matrix<Scalar, 2, 2> B = sqrtT.template block<2, 2>(j, j);
-  Matrix<Scalar, 2, 2> C = T.template block<2, 2>(i, j);
-  if (j - i > 2) C -= sqrtT.block(i, i + 2, 2, j - i - 2) * sqrtT.block(i + 2, j, j - i - 2, 2);
-  Matrix<Scalar, 2, 2> X;
-  matrix_sqrt_quasi_triangular_solve_auxiliary_equation(X, A, B, C);
-  sqrtT.template block<2, 2>(i, j) = X;
-}
-
-// pre:  T is quasi-upper-triangular and sqrtT is a zero matrix of the same size
-// post: the diagonal blocks of sqrtT are the square roots of the diagonal blocks of T
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_diagonal(const MatrixType& T, ResultType& sqrtT) {
-  using std::sqrt;
-  const Index size = T.rows();
-  for (Index i = 0; i < size; i++) {
-    if (i == size - 1 || T.coeff(i + 1, i) == 0) {
-      eigen_assert(T(i, i) >= 0);
-      sqrtT.coeffRef(i, i) = sqrt(T.coeff(i, i));
-    } else {
-      matrix_sqrt_quasi_triangular_2x2_diagonal_block(T, i, sqrtT);
-      ++i;
-    }
-  }
-}
-
-// pre:  T is quasi-upper-triangular and diagonal blocks of sqrtT are square root of diagonal blocks of T.
-// post: sqrtT is the square root of T.
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular_off_diagonal(const MatrixType& T, ResultType& sqrtT) {
-  const Index size = T.rows();
-  for (Index j = 1; j < size; j++) {
-    if (T.coeff(j, j - 1) != 0)  // if T(j-1:j, j-1:j) is a 2-by-2 block
-      continue;
-    for (Index i = j - 1; i >= 0; i--) {
-      if (i > 0 && T.coeff(i, i - 1) != 0)  // if T(i-1:i, i-1:i) is a 2-by-2 block
-        continue;
-      bool iBlockIs2x2 = (i < size - 1) && (T.coeff(i + 1, i) != 0);
-      bool jBlockIs2x2 = (j < size - 1) && (T.coeff(j + 1, j) != 0);
-      if (iBlockIs2x2 && jBlockIs2x2)
-        matrix_sqrt_quasi_triangular_2x2_off_diagonal_block(T, i, j, sqrtT);
-      else if (iBlockIs2x2 && !jBlockIs2x2)
-        matrix_sqrt_quasi_triangular_2x1_off_diagonal_block(T, i, j, sqrtT);
-      else if (!iBlockIs2x2 && jBlockIs2x2)
-        matrix_sqrt_quasi_triangular_1x2_off_diagonal_block(T, i, j, sqrtT);
-      else if (!iBlockIs2x2 && !jBlockIs2x2)
-        matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(T, i, j, sqrtT);
-    }
-  }
-}
-
-}  // end of namespace internal
-
-/** \ingroup MatrixFunctions_Module
- * \brief Compute matrix square root of quasi-triangular matrix.
- *
- * \tparam  MatrixType  type of \p arg, the argument of matrix square root,
- *                      expected to be an instantiation of the Matrix class template.
- * \tparam  ResultType  type of \p result, where result is to be stored.
- * \param[in]  arg      argument of matrix square root.
- * \param[out] result   matrix square root of upper Hessenberg part of \p arg.
- *
- * This function computes the square root of the upper quasi-triangular matrix stored in the upper
- * Hessenberg part of \p arg.  Only the upper Hessenberg part of \p result is updated, the rest is
- * not touched.  See MatrixBase::sqrt() for details on how this computation is implemented.
- *
- * \sa MatrixSquareRoot, MatrixSquareRootQuasiTriangular
- */
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_quasi_triangular(const MatrixType& arg, ResultType& result) {
-  eigen_assert(arg.rows() == arg.cols());
-  result.resize(arg.rows(), arg.cols());
-  internal::matrix_sqrt_quasi_triangular_diagonal(arg, result);
-  internal::matrix_sqrt_quasi_triangular_off_diagonal(arg, result);
-}
-
-/** \ingroup MatrixFunctions_Module
- * \brief Compute matrix square root of triangular matrix.
- *
- * \tparam  MatrixType  type of \p arg, the argument of matrix square root,
- *                      expected to be an instantiation of the Matrix class template.
- * \tparam  ResultType  type of \p result, where result is to be stored.
- * \param[in]  arg      argument of matrix square root.
- * \param[out] result   matrix square root of upper triangular part of \p arg.
- *
- * Only the upper triangular part (including the diagonal) of \p result is updated, the rest is not
- * touched.  See MatrixBase::sqrt() for details on how this computation is implemented.
- *
- * \sa MatrixSquareRoot, MatrixSquareRootQuasiTriangular
- */
-template <typename MatrixType, typename ResultType>
-void matrix_sqrt_triangular(const MatrixType& arg, ResultType& result) {
-  using std::sqrt;
-  typedef typename MatrixType::Scalar Scalar;
-
-  eigen_assert(arg.rows() == arg.cols());
-
-  // Compute square root of arg and store it in upper triangular part of result
-  // This uses that the square root of triangular matrices can be computed directly.
-  result.resize(arg.rows(), arg.cols());
-  for (Index i = 0; i < arg.rows(); i++) {
-    result.coeffRef(i, i) = sqrt(arg.coeff(i, i));
-  }
-  for (Index j = 1; j < arg.cols(); j++) {
-    for (Index i = j - 1; i >= 0; i--) {
-      // if i = j-1, then segment has length 0 so tmp = 0
-      Scalar tmp = (result.row(i).segment(i + 1, j - i - 1) * result.col(j).segment(i + 1, j - i - 1)).value();
-      // denominator may be zero if original matrix is singular
-      result.coeffRef(i, j) = (arg.coeff(i, j) - tmp) / (result.coeff(i, i) + result.coeff(j, j));
-    }
-  }
-}
-
-namespace internal {
-
-/** \ingroup MatrixFunctions_Module
- * \brief Helper struct for computing matrix square roots of general matrices.
- * \tparam  MatrixType  type of the argument of the matrix square root,
- *                      expected to be an instantiation of the Matrix class template.
- *
- * \sa MatrixSquareRootTriangular, MatrixSquareRootQuasiTriangular, MatrixBase::sqrt()
- */
-template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
-struct matrix_sqrt_compute {
-  /** \brief Compute the matrix square root
-   *
-   * \param[in]  arg     matrix whose square root is to be computed.
-   * \param[out] result  square root of \p arg.
-   *
-   * See MatrixBase::sqrt() for details on how this computation is implemented.
-   */
-  template <typename ResultType>
-  static void run(const MatrixType& arg, ResultType& result);
-};
-
-// ********** Partial specialization for real matrices **********
-
-template <typename MatrixType>
-struct matrix_sqrt_compute<MatrixType, 0> {
-  typedef typename MatrixType::PlainObject PlainType;
-  template <typename ResultType>
-  static void run(const MatrixType& arg, ResultType& result) {
-    eigen_assert(arg.rows() == arg.cols());
-
-    // Compute Schur decomposition of arg
-    const RealSchur<PlainType> schurOfA(arg);
-    const PlainType& T = schurOfA.matrixT();
-    const PlainType& U = schurOfA.matrixU();
-
-    // Compute square root of T
-    PlainType sqrtT = PlainType::Zero(arg.rows(), arg.cols());
-    matrix_sqrt_quasi_triangular(T, sqrtT);
-
-    // Compute square root of arg
-    result = U * sqrtT * U.adjoint();
-  }
-};
-
-// ********** Partial specialization for complex matrices **********
-
-template <typename MatrixType>
-struct matrix_sqrt_compute<MatrixType, 1> {
-  typedef typename MatrixType::PlainObject PlainType;
-  template <typename ResultType>
-  static void run(const MatrixType& arg, ResultType& result) {
-    eigen_assert(arg.rows() == arg.cols());
-
-    // Compute Schur decomposition of arg
-    const ComplexSchur<PlainType> schurOfA(arg);
-    const PlainType& T = schurOfA.matrixT();
-    const PlainType& U = schurOfA.matrixU();
-
-    // Compute square root of T
-    PlainType sqrtT;
-    matrix_sqrt_triangular(T, sqrtT);
-
-    // Compute square root of arg
-    result = U * (sqrtT.template triangularView<Upper>() * U.adjoint());
-  }
-};
-
-}  // end namespace internal
-
-/** \ingroup MatrixFunctions_Module
- *
- * \brief Proxy for the matrix square root of some matrix (expression).
- *
- * \tparam Derived  Type of the argument to the matrix square root.
- *
- * This class holds the argument to the matrix square root until it
- * is assigned or evaluated for some other reason (so the argument
- * should not be changed in the meantime). It is the return type of
- * MatrixBase::sqrt() and most of the time this is the only way it is
- * used.
- */
-template <typename Derived>
-class MatrixSquareRootReturnValue : public ReturnByValue<MatrixSquareRootReturnValue<Derived> > {
- protected:
-  typedef typename internal::ref_selector<Derived>::type DerivedNested;
-
- public:
-  /** \brief Constructor.
-   *
-   * \param[in]  src  %Matrix (expression) forming the argument of the
-   * matrix square root.
-   */
-  explicit MatrixSquareRootReturnValue(const Derived& src) : m_src(src) {}
-
-  /** \brief Compute the matrix square root.
-   *
-   * \param[out]  result  the matrix square root of \p src in the
-   * constructor.
-   */
-  template <typename ResultType>
-  inline void evalTo(ResultType& result) const {
-    typedef typename internal::nested_eval<Derived, 10>::type DerivedEvalType;
-    typedef internal::remove_all_t<DerivedEvalType> DerivedEvalTypeClean;
-    DerivedEvalType tmp(m_src);
-    internal::matrix_sqrt_compute<DerivedEvalTypeClean>::run(tmp, result);
-  }
-
-  Index rows() const { return m_src.rows(); }
-  Index cols() const { return m_src.cols(); }
-
- protected:
-  const DerivedNested m_src;
-};
-
-namespace internal {
-template <typename Derived>
-struct traits<MatrixSquareRootReturnValue<Derived> > {
-  typedef typename Derived::PlainObject ReturnType;
-};
-}  // namespace internal
-
-template <typename Derived>
-const MatrixSquareRootReturnValue<Derived> MatrixBase<Derived>::sqrt() const {
-  eigen_assert(rows() == cols());
-  return MatrixSquareRootReturnValue<Derived>(derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_MATRIX_FUNCTION
diff --git a/unsupported/Eigen/src/MatrixFunctions/StemFunction.h b/unsupported/Eigen/src/MatrixFunctions/StemFunction.h
deleted file mode 100644
index 8050c37..0000000
--- a/unsupported/Eigen/src/MatrixFunctions/StemFunction.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010, 2013 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_STEM_FUNCTION
-#define EIGEN_STEM_FUNCTION
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \brief The exponential function (and its derivatives). */
-template <typename Scalar>
-Scalar stem_function_exp(Scalar x, int) {
-  using std::exp;
-  return exp(x);
-}
-
-/** \brief Cosine (and its derivatives). */
-template <typename Scalar>
-Scalar stem_function_cos(Scalar x, int n) {
-  using std::cos;
-  using std::sin;
-  Scalar res;
-
-  switch (n % 4) {
-    case 0:
-      res = std::cos(x);
-      break;
-    case 1:
-      res = -std::sin(x);
-      break;
-    case 2:
-      res = -std::cos(x);
-      break;
-    case 3:
-      res = std::sin(x);
-      break;
-  }
-  return res;
-}
-
-/** \brief Sine (and its derivatives). */
-template <typename Scalar>
-Scalar stem_function_sin(Scalar x, int n) {
-  using std::cos;
-  using std::sin;
-  Scalar res;
-
-  switch (n % 4) {
-    case 0:
-      res = std::sin(x);
-      break;
-    case 1:
-      res = std::cos(x);
-      break;
-    case 2:
-      res = -std::sin(x);
-      break;
-    case 3:
-      res = -std::cos(x);
-      break;
-  }
-  return res;
-}
-
-/** \brief Hyperbolic cosine (and its derivatives). */
-template <typename Scalar>
-Scalar stem_function_cosh(Scalar x, int n) {
-  using std::cosh;
-  using std::sinh;
-  Scalar res;
-
-  switch (n % 2) {
-    case 0:
-      res = std::cosh(x);
-      break;
-    case 1:
-      res = std::sinh(x);
-      break;
-  }
-  return res;
-}
-
-/** \brief Hyperbolic sine (and its derivatives). */
-template <typename Scalar>
-Scalar stem_function_sinh(Scalar x, int n) {
-  using std::cosh;
-  using std::sinh;
-  Scalar res;
-
-  switch (n % 2) {
-    case 0:
-      res = std::sinh(x);
-      break;
-    case 1:
-      res = std::cosh(x);
-      break;
-  }
-  return res;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_STEM_FUNCTION
diff --git a/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h b/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
deleted file mode 100644
index 079772e..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
+++ /dev/null
@@ -1,545 +0,0 @@
-// -*- coding: utf-8
-// vim: set fileencoding=utf-8
-
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_HYBRIDNONLINEARSOLVER_H
-#define EIGEN_HYBRIDNONLINEARSOLVER_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace HybridNonLinearSolverSpace {
-enum Status {
-  Running = -1,
-  ImproperInputParameters = 0,
-  RelativeErrorTooSmall = 1,
-  TooManyFunctionEvaluation = 2,
-  TolTooSmall = 3,
-  NotMakingProgressJacobian = 4,
-  NotMakingProgressIterations = 5,
-  UserAsked = 6
-};
-}
-
-/**
- * \ingroup NonLinearOptimization_Module
- * \brief Finds a zero of a system of n
- * nonlinear functions in n variables by a modification of the Powell
- * hybrid method ("dogleg").
- *
- * The user must provide a subroutine which calculates the
- * functions. The Jacobian is either provided by the user, or approximated
- * using a forward-difference method.
- *
- */
-template <typename FunctorType, typename Scalar = double>
-class HybridNonLinearSolver {
- public:
-  typedef DenseIndex Index;
-
-  HybridNonLinearSolver(FunctorType &_functor) : functor(_functor) {
-    nfev = njev = iter = 0;
-    fnorm = 0.;
-    useExternalScaling = false;
-  }
-
-  struct Parameters {
-    Parameters()
-        : factor(Scalar(100.)),
-          maxfev(1000),
-          xtol(numext::sqrt(NumTraits<Scalar>::epsilon())),
-          nb_of_subdiagonals(-1),
-          nb_of_superdiagonals(-1),
-          epsfcn(Scalar(0.)) {}
-    Scalar factor;
-    Index maxfev;  // maximum number of function evaluation
-    Scalar xtol;
-    Index nb_of_subdiagonals;
-    Index nb_of_superdiagonals;
-    Scalar epsfcn;
-  };
-  typedef Matrix<Scalar, Dynamic, 1> FVectorType;
-  typedef Matrix<Scalar, Dynamic, Dynamic> JacobianType;
-  /* TODO: if eigen provides a triangular storage, use it here */
-  typedef Matrix<Scalar, Dynamic, Dynamic> UpperTriangularType;
-
-  HybridNonLinearSolverSpace::Status hybrj1(FVectorType &x,
-                                            const Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon()));
-
-  HybridNonLinearSolverSpace::Status solveInit(FVectorType &x);
-  HybridNonLinearSolverSpace::Status solveOneStep(FVectorType &x);
-  HybridNonLinearSolverSpace::Status solve(FVectorType &x);
-
-  HybridNonLinearSolverSpace::Status hybrd1(FVectorType &x,
-                                            const Scalar tol = numext::sqrt(NumTraits<Scalar>::epsilon()));
-
-  HybridNonLinearSolverSpace::Status solveNumericalDiffInit(FVectorType &x);
-  HybridNonLinearSolverSpace::Status solveNumericalDiffOneStep(FVectorType &x);
-  HybridNonLinearSolverSpace::Status solveNumericalDiff(FVectorType &x);
-
-  void resetParameters(void) { parameters = Parameters(); }
-  Parameters parameters;
-  FVectorType fvec, qtf, diag;
-  JacobianType fjac;
-  UpperTriangularType R;
-  Index nfev;
-  Index njev;
-  Index iter;
-  Scalar fnorm;
-  bool useExternalScaling;
-
- private:
-  FunctorType &functor;
-  Index n;
-  Scalar sum;
-  bool sing;
-  Scalar temp;
-  Scalar delta;
-  bool jeval;
-  Index ncsuc;
-  Scalar ratio;
-  Scalar pnorm, xnorm, fnorm1;
-  Index nslow1, nslow2;
-  Index ncfail;
-  Scalar actred, prered;
-  FVectorType wa1, wa2, wa3, wa4;
-
-  HybridNonLinearSolver &operator=(const HybridNonLinearSolver &);
-};
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::hybrj1(FVectorType &x,
-                                                                                      const Scalar tol) {
-  n = x.size();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || tol < 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
-
-  resetParameters();
-  parameters.maxfev = 100 * (n + 1);
-  parameters.xtol = tol;
-  diag.setConstant(n, 1.);
-  useExternalScaling = true;
-  return solve(x);
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveInit(FVectorType &x) {
-  n = x.size();
-
-  wa1.resize(n);
-  wa2.resize(n);
-  wa3.resize(n);
-  wa4.resize(n);
-  fvec.resize(n);
-  qtf.resize(n);
-  fjac.resize(n, n);
-  if (!useExternalScaling) diag.resize(n);
-  eigen_assert((!useExternalScaling || diag.size() == n) &&
-               "When useExternalScaling is set, the caller must provide a valid 'diag'");
-
-  /* Function Body */
-  nfev = 0;
-  njev = 0;
-
-  /*     check the input parameters for errors. */
-  if (n <= 0 || parameters.xtol < 0. || parameters.maxfev <= 0 || parameters.factor <= 0.)
-    return HybridNonLinearSolverSpace::ImproperInputParameters;
-  if (useExternalScaling)
-    for (Index j = 0; j < n; ++j)
-      if (diag[j] <= 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
-
-  /*     evaluate the function at the starting point */
-  /*     and calculate its norm. */
-  nfev = 1;
-  if (functor(x, fvec) < 0) return HybridNonLinearSolverSpace::UserAsked;
-  fnorm = fvec.stableNorm();
-
-  /*     initialize iteration counter and monitors. */
-  iter = 1;
-  ncsuc = 0;
-  ncfail = 0;
-  nslow1 = 0;
-  nslow2 = 0;
-
-  return HybridNonLinearSolverSpace::Running;
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveOneStep(FVectorType &x) {
-  using std::abs;
-
-  eigen_assert(x.size() == n);  // check the caller is not cheating us
-
-  Index j;
-  std::vector<JacobiRotation<Scalar> > v_givens(n), w_givens(n);
-
-  jeval = true;
-
-  /* calculate the jacobian matrix. */
-  if (functor.df(x, fjac) < 0) return HybridNonLinearSolverSpace::UserAsked;
-  ++njev;
-
-  wa2 = fjac.colwise().blueNorm();
-
-  /* on the first iteration and if external scaling is not used, scale according */
-  /* to the norms of the columns of the initial jacobian. */
-  if (iter == 1) {
-    if (!useExternalScaling)
-      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
-
-    /* on the first iteration, calculate the norm of the scaled x */
-    /* and initialize the step bound delta. */
-    xnorm = diag.cwiseProduct(x).stableNorm();
-    delta = parameters.factor * xnorm;
-    if (delta == 0.) delta = parameters.factor;
-  }
-
-  /* compute the qr factorization of the jacobian. */
-  HouseholderQR<JacobianType> qrfac(fjac);  // no pivoting:
-
-  /* copy the triangular factor of the qr factorization into r. */
-  R = qrfac.matrixQR();
-
-  /* accumulate the orthogonal factor in fjac. */
-  fjac = qrfac.householderQ();
-
-  /* form (q transpose)*fvec and store in qtf. */
-  qtf = fjac.transpose() * fvec;
-
-  /* rescale if necessary. */
-  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
-
-  while (true) {
-    /* determine the direction p. */
-    internal::dogleg<Scalar>(R, diag, qtf, delta, wa1);
-
-    /* store the direction p and x + p. calculate the norm of p. */
-    wa1 = -wa1;
-    wa2 = x + wa1;
-    pnorm = diag.cwiseProduct(wa1).stableNorm();
-
-    /* on the first iteration, adjust the initial step bound. */
-    if (iter == 1) delta = (std::min)(delta, pnorm);
-
-    /* evaluate the function at x + p and calculate its norm. */
-    if (functor(wa2, wa4) < 0) return HybridNonLinearSolverSpace::UserAsked;
-    ++nfev;
-    fnorm1 = wa4.stableNorm();
-
-    /* compute the scaled actual reduction. */
-    actred = -1.;
-    if (fnorm1 < fnorm) /* Computing 2nd power */
-      actred = 1. - numext::abs2(fnorm1 / fnorm);
-
-    /* compute the scaled predicted reduction. */
-    wa3 = R.template triangularView<Upper>() * wa1 + qtf;
-    temp = wa3.stableNorm();
-    prered = 0.;
-    if (temp < fnorm) /* Computing 2nd power */
-      prered = 1. - numext::abs2(temp / fnorm);
-
-    /* compute the ratio of the actual to the predicted reduction. */
-    ratio = 0.;
-    if (prered > 0.) ratio = actred / prered;
-
-    /* update the step bound. */
-    if (ratio < Scalar(.1)) {
-      ncsuc = 0;
-      ++ncfail;
-      delta = Scalar(.5) * delta;
-    } else {
-      ncfail = 0;
-      ++ncsuc;
-      if (ratio >= Scalar(.5) || ncsuc > 1) delta = (std::max)(delta, pnorm / Scalar(.5));
-      if (abs(ratio - 1.) <= Scalar(.1)) {
-        delta = pnorm / Scalar(.5);
-      }
-    }
-
-    /* test for successful iteration. */
-    if (ratio >= Scalar(1e-4)) {
-      /* successful iteration. update x, fvec, and their norms. */
-      x = wa2;
-      wa2 = diag.cwiseProduct(x);
-      fvec = wa4;
-      xnorm = wa2.stableNorm();
-      fnorm = fnorm1;
-      ++iter;
-    }
-
-    /* determine the progress of the iteration. */
-    ++nslow1;
-    if (actred >= Scalar(.001)) nslow1 = 0;
-    if (jeval) ++nslow2;
-    if (actred >= Scalar(.1)) nslow2 = 0;
-
-    /* test for convergence. */
-    if (delta <= parameters.xtol * xnorm || fnorm == 0.) return HybridNonLinearSolverSpace::RelativeErrorTooSmall;
-
-    /* tests for termination and stringent tolerances. */
-    if (nfev >= parameters.maxfev) return HybridNonLinearSolverSpace::TooManyFunctionEvaluation;
-    if (Scalar(.1) * (std::max)(Scalar(.1) * delta, pnorm) <= NumTraits<Scalar>::epsilon() * xnorm)
-      return HybridNonLinearSolverSpace::TolTooSmall;
-    if (nslow2 == 5) return HybridNonLinearSolverSpace::NotMakingProgressJacobian;
-    if (nslow1 == 10) return HybridNonLinearSolverSpace::NotMakingProgressIterations;
-
-    /* criterion for recalculating jacobian. */
-    if (ncfail == 2) break;  // leave inner loop and go for the next outer loop iteration
-
-    /* calculate the rank one modification to the jacobian */
-    /* and update qtf if necessary. */
-    wa1 = diag.cwiseProduct(diag.cwiseProduct(wa1) / pnorm);
-    wa2 = fjac.transpose() * wa4;
-    if (ratio >= Scalar(1e-4)) qtf = wa2;
-    wa2 = (wa2 - wa3) / pnorm;
-
-    /* compute the qr factorization of the updated jacobian. */
-    internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
-    internal::r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens);
-    internal::r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens);
-
-    jeval = false;
-  }
-  return HybridNonLinearSolverSpace::Running;
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solve(FVectorType &x) {
-  HybridNonLinearSolverSpace::Status status = solveInit(x);
-  if (status == HybridNonLinearSolverSpace::ImproperInputParameters) return status;
-  while (status == HybridNonLinearSolverSpace::Running) status = solveOneStep(x);
-  return status;
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::hybrd1(FVectorType &x,
-                                                                                      const Scalar tol) {
-  n = x.size();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || tol < 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
-
-  resetParameters();
-  parameters.maxfev = 200 * (n + 1);
-  parameters.xtol = tol;
-
-  diag.setConstant(n, 1.);
-  useExternalScaling = true;
-  return solveNumericalDiff(x);
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveNumericalDiffInit(FVectorType &x) {
-  n = x.size();
-
-  if (parameters.nb_of_subdiagonals < 0) parameters.nb_of_subdiagonals = n - 1;
-  if (parameters.nb_of_superdiagonals < 0) parameters.nb_of_superdiagonals = n - 1;
-
-  wa1.resize(n);
-  wa2.resize(n);
-  wa3.resize(n);
-  wa4.resize(n);
-  qtf.resize(n);
-  fjac.resize(n, n);
-  fvec.resize(n);
-  if (!useExternalScaling) diag.resize(n);
-  eigen_assert((!useExternalScaling || diag.size() == n) &&
-               "When useExternalScaling is set, the caller must provide a valid 'diag'");
-
-  /* Function Body */
-  nfev = 0;
-  njev = 0;
-
-  /*     check the input parameters for errors. */
-  if (n <= 0 || parameters.xtol < 0. || parameters.maxfev <= 0 || parameters.nb_of_subdiagonals < 0 ||
-      parameters.nb_of_superdiagonals < 0 || parameters.factor <= 0.)
-    return HybridNonLinearSolverSpace::ImproperInputParameters;
-  if (useExternalScaling)
-    for (Index j = 0; j < n; ++j)
-      if (diag[j] <= 0.) return HybridNonLinearSolverSpace::ImproperInputParameters;
-
-  /*     evaluate the function at the starting point */
-  /*     and calculate its norm. */
-  nfev = 1;
-  if (functor(x, fvec) < 0) return HybridNonLinearSolverSpace::UserAsked;
-  fnorm = fvec.stableNorm();
-
-  /*     initialize iteration counter and monitors. */
-  iter = 1;
-  ncsuc = 0;
-  ncfail = 0;
-  nslow1 = 0;
-  nslow2 = 0;
-
-  return HybridNonLinearSolverSpace::Running;
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveNumericalDiffOneStep(
-    FVectorType &x) {
-  using std::abs;
-  using std::sqrt;
-
-  eigen_assert(x.size() == n);  // check the caller is not cheating us
-
-  Index j;
-  std::vector<JacobiRotation<Scalar> > v_givens(n), w_givens(n);
-
-  jeval = true;
-  if (parameters.nb_of_subdiagonals < 0) parameters.nb_of_subdiagonals = n - 1;
-  if (parameters.nb_of_superdiagonals < 0) parameters.nb_of_superdiagonals = n - 1;
-
-  /* calculate the jacobian matrix. */
-  if (internal::fdjac1(functor, x, fvec, fjac, parameters.nb_of_subdiagonals, parameters.nb_of_superdiagonals,
-                       parameters.epsfcn) < 0)
-    return HybridNonLinearSolverSpace::UserAsked;
-  nfev += (std::min)(parameters.nb_of_subdiagonals + parameters.nb_of_superdiagonals + 1, n);
-
-  wa2 = fjac.colwise().blueNorm();
-
-  /* on the first iteration and if external scaling is not used, scale according */
-  /* to the norms of the columns of the initial jacobian. */
-  if (iter == 1) {
-    if (!useExternalScaling)
-      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
-
-    /* on the first iteration, calculate the norm of the scaled x */
-    /* and initialize the step bound delta. */
-    xnorm = diag.cwiseProduct(x).stableNorm();
-    delta = parameters.factor * xnorm;
-    if (delta == 0.) delta = parameters.factor;
-  }
-
-  /* compute the qr factorization of the jacobian. */
-  HouseholderQR<JacobianType> qrfac(fjac);  // no pivoting:
-
-  /* copy the triangular factor of the qr factorization into r. */
-  R = qrfac.matrixQR();
-
-  /* accumulate the orthogonal factor in fjac. */
-  fjac = qrfac.householderQ();
-
-  /* form (q transpose)*fvec and store in qtf. */
-  qtf = fjac.transpose() * fvec;
-
-  /* rescale if necessary. */
-  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
-
-  while (true) {
-    /* determine the direction p. */
-    internal::dogleg<Scalar>(R, diag, qtf, delta, wa1);
-
-    /* store the direction p and x + p. calculate the norm of p. */
-    wa1 = -wa1;
-    wa2 = x + wa1;
-    pnorm = diag.cwiseProduct(wa1).stableNorm();
-
-    /* on the first iteration, adjust the initial step bound. */
-    if (iter == 1) delta = (std::min)(delta, pnorm);
-
-    /* evaluate the function at x + p and calculate its norm. */
-    if (functor(wa2, wa4) < 0) return HybridNonLinearSolverSpace::UserAsked;
-    ++nfev;
-    fnorm1 = wa4.stableNorm();
-
-    /* compute the scaled actual reduction. */
-    actred = -1.;
-    if (fnorm1 < fnorm) /* Computing 2nd power */
-      actred = 1. - numext::abs2(fnorm1 / fnorm);
-
-    /* compute the scaled predicted reduction. */
-    wa3 = R.template triangularView<Upper>() * wa1 + qtf;
-    temp = wa3.stableNorm();
-    prered = 0.;
-    if (temp < fnorm) /* Computing 2nd power */
-      prered = 1. - numext::abs2(temp / fnorm);
-
-    /* compute the ratio of the actual to the predicted reduction. */
-    ratio = 0.;
-    if (prered > 0.) ratio = actred / prered;
-
-    /* update the step bound. */
-    if (ratio < Scalar(.1)) {
-      ncsuc = 0;
-      ++ncfail;
-      delta = Scalar(.5) * delta;
-    } else {
-      ncfail = 0;
-      ++ncsuc;
-      if (ratio >= Scalar(.5) || ncsuc > 1) delta = (std::max)(delta, pnorm / Scalar(.5));
-      if (abs(ratio - 1.) <= Scalar(.1)) {
-        delta = pnorm / Scalar(.5);
-      }
-    }
-
-    /* test for successful iteration. */
-    if (ratio >= Scalar(1e-4)) {
-      /* successful iteration. update x, fvec, and their norms. */
-      x = wa2;
-      wa2 = diag.cwiseProduct(x);
-      fvec = wa4;
-      xnorm = wa2.stableNorm();
-      fnorm = fnorm1;
-      ++iter;
-    }
-
-    /* determine the progress of the iteration. */
-    ++nslow1;
-    if (actred >= Scalar(.001)) nslow1 = 0;
-    if (jeval) ++nslow2;
-    if (actred >= Scalar(.1)) nslow2 = 0;
-
-    /* test for convergence. */
-    if (delta <= parameters.xtol * xnorm || fnorm == 0.) return HybridNonLinearSolverSpace::RelativeErrorTooSmall;
-
-    /* tests for termination and stringent tolerances. */
-    if (nfev >= parameters.maxfev) return HybridNonLinearSolverSpace::TooManyFunctionEvaluation;
-    if (Scalar(.1) * (std::max)(Scalar(.1) * delta, pnorm) <= NumTraits<Scalar>::epsilon() * xnorm)
-      return HybridNonLinearSolverSpace::TolTooSmall;
-    if (nslow2 == 5) return HybridNonLinearSolverSpace::NotMakingProgressJacobian;
-    if (nslow1 == 10) return HybridNonLinearSolverSpace::NotMakingProgressIterations;
-
-    /* criterion for recalculating jacobian. */
-    if (ncfail == 2) break;  // leave inner loop and go for the next outer loop iteration
-
-    /* calculate the rank one modification to the jacobian */
-    /* and update qtf if necessary. */
-    wa1 = diag.cwiseProduct(diag.cwiseProduct(wa1) / pnorm);
-    wa2 = fjac.transpose() * wa4;
-    if (ratio >= Scalar(1e-4)) qtf = wa2;
-    wa2 = (wa2 - wa3) / pnorm;
-
-    /* compute the qr factorization of the updated jacobian. */
-    internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
-    internal::r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens);
-    internal::r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens);
-
-    jeval = false;
-  }
-  return HybridNonLinearSolverSpace::Running;
-}
-
-template <typename FunctorType, typename Scalar>
-HybridNonLinearSolverSpace::Status HybridNonLinearSolver<FunctorType, Scalar>::solveNumericalDiff(FVectorType &x) {
-  HybridNonLinearSolverSpace::Status status = solveNumericalDiffInit(x);
-  if (status == HybridNonLinearSolverSpace::ImproperInputParameters) return status;
-  while (status == HybridNonLinearSolverSpace::Running) status = solveNumericalDiffOneStep(x);
-  return status;
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_HYBRIDNONLINEARSOLVER_H
-
-// vim: ai ts=4 sts=4 et sw=4
diff --git a/unsupported/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h b/unsupported/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h
deleted file mode 100644
index d06970f..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/InternalHeaderCheck.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef EIGEN_NONLINEAROPTIMIZATION_MODULE_H
-#error \
-    "Please include unsupported/Eigen/NonLinearOptimization instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h b/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
deleted file mode 100644
index 6503e62..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
+++ /dev/null
@@ -1,587 +0,0 @@
-// -*- coding: utf-8
-// vim: set fileencoding=utf-8
-
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_LEVENBERGMARQUARDT__H
-#define EIGEN_LEVENBERGMARQUARDT__H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace LevenbergMarquardtSpace {
-enum Status {
-  NotStarted = -2,
-  Running = -1,
-  ImproperInputParameters = 0,
-  RelativeReductionTooSmall = 1,
-  RelativeErrorTooSmall = 2,
-  RelativeErrorAndReductionTooSmall = 3,
-  CosinusTooSmall = 4,
-  TooManyFunctionEvaluation = 5,
-  FtolTooSmall = 6,
-  XtolTooSmall = 7,
-  GtolTooSmall = 8,
-  UserAsked = 9
-};
-}
-
-/**
- * \ingroup NonLinearOptimization_Module
- * \brief Performs non linear optimization over a non-linear function,
- * using a variant of the Levenberg Marquardt algorithm.
- *
- * Check wikipedia for more information.
- * http://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm
- */
-template <typename FunctorType, typename Scalar = double>
-class LevenbergMarquardt {
-  static Scalar sqrt_epsilon() {
-    using std::sqrt;
-    return sqrt(NumTraits<Scalar>::epsilon());
-  }
-
- public:
-  LevenbergMarquardt(FunctorType &_functor) : functor(_functor) {
-    nfev = njev = iter = 0;
-    fnorm = gnorm = 0.;
-    useExternalScaling = false;
-  }
-
-  typedef DenseIndex Index;
-
-  struct Parameters {
-    Parameters()
-        : factor(Scalar(100.)),
-          maxfev(400),
-          ftol(sqrt_epsilon()),
-          xtol(sqrt_epsilon()),
-          gtol(Scalar(0.)),
-          epsfcn(Scalar(0.)) {}
-    Scalar factor;
-    Index maxfev;  // maximum number of function evaluation
-    Scalar ftol;
-    Scalar xtol;
-    Scalar gtol;
-    Scalar epsfcn;
-  };
-
-  typedef Matrix<Scalar, Dynamic, 1> FVectorType;
-  typedef Matrix<Scalar, Dynamic, Dynamic> JacobianType;
-
-  LevenbergMarquardtSpace::Status lmder1(FVectorType &x, const Scalar tol = sqrt_epsilon());
-
-  LevenbergMarquardtSpace::Status minimize(FVectorType &x);
-  LevenbergMarquardtSpace::Status minimizeInit(FVectorType &x);
-  LevenbergMarquardtSpace::Status minimizeOneStep(FVectorType &x);
-
-  static LevenbergMarquardtSpace::Status lmdif1(FunctorType &functor, FVectorType &x, Index *nfev,
-                                                const Scalar tol = sqrt_epsilon());
-
-  LevenbergMarquardtSpace::Status lmstr1(FVectorType &x, const Scalar tol = sqrt_epsilon());
-
-  LevenbergMarquardtSpace::Status minimizeOptimumStorage(FVectorType &x);
-  LevenbergMarquardtSpace::Status minimizeOptimumStorageInit(FVectorType &x);
-  LevenbergMarquardtSpace::Status minimizeOptimumStorageOneStep(FVectorType &x);
-
-  void resetParameters(void) { parameters = Parameters(); }
-
-  Parameters parameters;
-  FVectorType fvec, qtf, diag;
-  JacobianType fjac;
-  PermutationMatrix<Dynamic, Dynamic> permutation;
-  Index nfev;
-  Index njev;
-  Index iter;
-  Scalar fnorm, gnorm;
-  bool useExternalScaling;
-
-  Scalar lm_param(void) const { return par; }
-
- private:
-  FunctorType &functor;
-  Index n;
-  Index m;
-  FVectorType wa1, wa2, wa3, wa4;
-
-  Scalar par, sum;
-  Scalar temp, temp1, temp2;
-  Scalar delta;
-  Scalar ratio;
-  Scalar pnorm, xnorm, fnorm1, actred, dirder, prered;
-
-  LevenbergMarquardt &operator=(const LevenbergMarquardt &);
-};
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::lmder1(FVectorType &x, const Scalar tol) {
-  n = x.size();
-  m = functor.values();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  resetParameters();
-  parameters.ftol = tol;
-  parameters.xtol = tol;
-  parameters.maxfev = 100 * (n + 1);
-
-  return minimize(x);
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimize(FVectorType &x) {
-  LevenbergMarquardtSpace::Status status = minimizeInit(x);
-  if (status == LevenbergMarquardtSpace::ImproperInputParameters) return status;
-  do {
-    status = minimizeOneStep(x);
-  } while (status == LevenbergMarquardtSpace::Running);
-  return status;
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeInit(FVectorType &x) {
-  n = x.size();
-  m = functor.values();
-
-  wa1.resize(n);
-  wa2.resize(n);
-  wa3.resize(n);
-  wa4.resize(m);
-  fvec.resize(m);
-  fjac.resize(m, n);
-  if (!useExternalScaling) diag.resize(n);
-  eigen_assert((!useExternalScaling || diag.size() == n) &&
-               "When useExternalScaling is set, the caller must provide a valid 'diag'");
-  qtf.resize(n);
-
-  /* Function Body */
-  nfev = 0;
-  njev = 0;
-
-  /*     check the input parameters for errors. */
-  if (n <= 0 || m < n || parameters.ftol < 0. || parameters.xtol < 0. || parameters.gtol < 0. ||
-      parameters.maxfev <= 0 || parameters.factor <= 0.)
-    return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  if (useExternalScaling)
-    for (Index j = 0; j < n; ++j)
-      if (diag[j] <= 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  /*     evaluate the function at the starting point */
-  /*     and calculate its norm. */
-  nfev = 1;
-  if (functor(x, fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
-  fnorm = fvec.stableNorm();
-
-  /*     initialize levenberg-marquardt parameter and iteration counter. */
-  par = 0.;
-  iter = 1;
-
-  return LevenbergMarquardtSpace::NotStarted;
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOneStep(FVectorType &x) {
-  using std::abs;
-  using std::sqrt;
-
-  eigen_assert(x.size() == n);  // check the caller is not cheating us
-
-  /* calculate the jacobian matrix. */
-  Index df_ret = functor.df(x, fjac);
-  if (df_ret < 0) return LevenbergMarquardtSpace::UserAsked;
-  if (df_ret > 0)
-    // numerical diff, we evaluated the function df_ret times
-    nfev += df_ret;
-  else
-    njev++;
-
-  /* compute the qr factorization of the jacobian. */
-  wa2 = fjac.colwise().blueNorm();
-  ColPivHouseholderQR<JacobianType> qrfac(fjac);
-  fjac = qrfac.matrixQR();
-  permutation = qrfac.colsPermutation();
-
-  /* on the first iteration and if external scaling is not used, scale according */
-  /* to the norms of the columns of the initial jacobian. */
-  if (iter == 1) {
-    if (!useExternalScaling)
-      for (Index j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
-
-    /* on the first iteration, calculate the norm of the scaled x */
-    /* and initialize the step bound delta. */
-    xnorm = diag.cwiseProduct(x).stableNorm();
-    delta = parameters.factor * xnorm;
-    if (delta == 0.) delta = parameters.factor;
-  }
-
-  /* form (q transpose)*fvec and store the first n components in */
-  /* qtf. */
-  wa4 = fvec;
-  wa4.applyOnTheLeft(qrfac.householderQ().adjoint());
-  qtf = wa4.head(n);
-
-  /* compute the norm of the scaled gradient. */
-  gnorm = 0.;
-  if (fnorm != 0.)
-    for (Index j = 0; j < n; ++j)
-      if (wa2[permutation.indices()[j]] != 0.)
-        gnorm = (std::max)(gnorm,
-                           abs(fjac.col(j).head(j + 1).dot(qtf.head(j + 1) / fnorm) / wa2[permutation.indices()[j]]));
-
-  /* test for convergence of the gradient norm. */
-  if (gnorm <= parameters.gtol) return LevenbergMarquardtSpace::CosinusTooSmall;
-
-  /* rescale if necessary. */
-  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
-
-  do {
-    /* determine the levenberg-marquardt parameter. */
-    internal::lmpar2<Scalar>(qrfac, diag, qtf, delta, par, wa1);
-
-    /* store the direction p and x + p. calculate the norm of p. */
-    wa1 = -wa1;
-    wa2 = x + wa1;
-    pnorm = diag.cwiseProduct(wa1).stableNorm();
-
-    /* on the first iteration, adjust the initial step bound. */
-    if (iter == 1) delta = (std::min)(delta, pnorm);
-
-    /* evaluate the function at x + p and calculate its norm. */
-    if (functor(wa2, wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
-    ++nfev;
-    fnorm1 = wa4.stableNorm();
-
-    /* compute the scaled actual reduction. */
-    actred = -1.;
-    if (Scalar(.1) * fnorm1 < fnorm) actred = 1. - numext::abs2(fnorm1 / fnorm);
-
-    /* compute the scaled predicted reduction and */
-    /* the scaled directional derivative. */
-    wa3.noalias() = fjac.template triangularView<Upper>() * (qrfac.colsPermutation().inverse() * wa1);
-    temp1 = numext::abs2(wa3.stableNorm() / fnorm);
-    temp2 = numext::abs2(sqrt(par) * pnorm / fnorm);
-    prered = temp1 + temp2 / Scalar(.5);
-    dirder = -(temp1 + temp2);
-
-    /* compute the ratio of the actual to the predicted */
-    /* reduction. */
-    ratio = 0.;
-    if (prered != 0.) ratio = actred / prered;
-
-    /* update the step bound. */
-    if (ratio <= Scalar(.25)) {
-      if (actred >= 0.) temp = Scalar(.5);
-      if (actred < 0.) temp = Scalar(.5) * dirder / (dirder + Scalar(.5) * actred);
-      if (Scalar(.1) * fnorm1 >= fnorm || temp < Scalar(.1)) temp = Scalar(.1);
-      /* Computing MIN */
-      delta = temp * (std::min)(delta, pnorm / Scalar(.1));
-      par /= temp;
-    } else if (!(par != 0. && ratio < Scalar(.75))) {
-      delta = pnorm / Scalar(.5);
-      par = Scalar(.5) * par;
-    }
-
-    /* test for successful iteration. */
-    if (ratio >= Scalar(1e-4)) {
-      /* successful iteration. update x, fvec, and their norms. */
-      x = wa2;
-      wa2 = diag.cwiseProduct(x);
-      fvec = wa4;
-      xnorm = wa2.stableNorm();
-      fnorm = fnorm1;
-      ++iter;
-    }
-
-    /* tests for convergence. */
-    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. &&
-        delta <= parameters.xtol * xnorm)
-      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
-    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
-      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
-    if (delta <= parameters.xtol * xnorm) return LevenbergMarquardtSpace::RelativeErrorTooSmall;
-
-    /* tests for termination and stringent tolerances. */
-    if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
-    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
-        Scalar(.5) * ratio <= 1.)
-      return LevenbergMarquardtSpace::FtolTooSmall;
-    if (delta <= NumTraits<Scalar>::epsilon() * xnorm) return LevenbergMarquardtSpace::XtolTooSmall;
-    if (gnorm <= NumTraits<Scalar>::epsilon()) return LevenbergMarquardtSpace::GtolTooSmall;
-
-  } while (ratio < Scalar(1e-4));
-
-  return LevenbergMarquardtSpace::Running;
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::lmstr1(FVectorType &x, const Scalar tol) {
-  n = x.size();
-  m = functor.values();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  resetParameters();
-  parameters.ftol = tol;
-  parameters.xtol = tol;
-  parameters.maxfev = 100 * (n + 1);
-
-  return minimizeOptimumStorage(x);
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOptimumStorageInit(FVectorType &x) {
-  n = x.size();
-  m = functor.values();
-
-  wa1.resize(n);
-  wa2.resize(n);
-  wa3.resize(n);
-  wa4.resize(m);
-  fvec.resize(m);
-  // Only R is stored in fjac. Q is only used to compute 'qtf', which is
-  // Q.transpose()*rhs. qtf will be updated using givens rotation,
-  // instead of storing them in Q.
-  // The purpose it to only use a nxn matrix, instead of mxn here, so
-  // that we can handle cases where m>>n :
-  fjac.resize(n, n);
-  if (!useExternalScaling) diag.resize(n);
-  eigen_assert((!useExternalScaling || diag.size() == n) &&
-               "When useExternalScaling is set, the caller must provide a valid 'diag'");
-  qtf.resize(n);
-
-  /* Function Body */
-  nfev = 0;
-  njev = 0;
-
-  /*     check the input parameters for errors. */
-  if (n <= 0 || m < n || parameters.ftol < 0. || parameters.xtol < 0. || parameters.gtol < 0. ||
-      parameters.maxfev <= 0 || parameters.factor <= 0.)
-    return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  if (useExternalScaling)
-    for (Index j = 0; j < n; ++j)
-      if (diag[j] <= 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  /*     evaluate the function at the starting point */
-  /*     and calculate its norm. */
-  nfev = 1;
-  if (functor(x, fvec) < 0) return LevenbergMarquardtSpace::UserAsked;
-  fnorm = fvec.stableNorm();
-
-  /*     initialize levenberg-marquardt parameter and iteration counter. */
-  par = 0.;
-  iter = 1;
-
-  return LevenbergMarquardtSpace::NotStarted;
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOptimumStorageOneStep(FVectorType &x) {
-  using std::abs;
-  using std::sqrt;
-
-  eigen_assert(x.size() == n);  // check the caller is not cheating us
-
-  Index i, j;
-  bool sing;
-
-  /* compute the qr factorization of the jacobian matrix */
-  /* calculated one row at a time, while simultaneously */
-  /* forming (q transpose)*fvec and storing the first */
-  /* n components in qtf. */
-  qtf.fill(0.);
-  fjac.fill(0.);
-  Index rownb = 2;
-  for (i = 0; i < m; ++i) {
-    if (functor.df(x, wa3, rownb) < 0) return LevenbergMarquardtSpace::UserAsked;
-    internal::rwupdt<Scalar>(fjac, wa3, qtf, fvec[i]);
-    ++rownb;
-  }
-  ++njev;
-
-  /* if the jacobian is rank deficient, call qrfac to */
-  /* reorder its columns and update the components of qtf. */
-  sing = false;
-  for (j = 0; j < n; ++j) {
-    if (fjac(j, j) == 0.) sing = true;
-    wa2[j] = fjac.col(j).head(j).stableNorm();
-  }
-  permutation.setIdentity(n);
-  if (sing) {
-    wa2 = fjac.colwise().blueNorm();
-    // TODO: We have no unit test covering this code path, do not modify
-    // until it is carefully tested
-    ColPivHouseholderQR<JacobianType> qrfac(fjac);
-    fjac = qrfac.matrixQR();
-    wa1 = fjac.diagonal();
-    fjac.diagonal() = qrfac.hCoeffs();
-    permutation = qrfac.colsPermutation();
-    // TODO: Avoid this:
-    for (Index ii = 0; ii < fjac.cols(); ii++)
-      fjac.col(ii).segment(ii + 1, fjac.rows() - ii - 1) *= fjac(ii, ii);  // rescale vectors
-
-    for (j = 0; j < n; ++j) {
-      if (fjac(j, j) != 0.) {
-        sum = 0.;
-        for (i = j; i < n; ++i) sum += fjac(i, j) * qtf[i];
-        temp = -sum / fjac(j, j);
-        for (i = j; i < n; ++i) qtf[i] += fjac(i, j) * temp;
-      }
-      fjac(j, j) = wa1[j];
-    }
-  }
-
-  /* on the first iteration and if external scaling is not used, scale according */
-  /* to the norms of the columns of the initial jacobian. */
-  if (iter == 1) {
-    if (!useExternalScaling)
-      for (j = 0; j < n; ++j) diag[j] = (wa2[j] == 0.) ? 1. : wa2[j];
-
-    /* on the first iteration, calculate the norm of the scaled x */
-    /* and initialize the step bound delta. */
-    xnorm = diag.cwiseProduct(x).stableNorm();
-    delta = parameters.factor * xnorm;
-    if (delta == 0.) delta = parameters.factor;
-  }
-
-  /* compute the norm of the scaled gradient. */
-  gnorm = 0.;
-  if (fnorm != 0.)
-    for (j = 0; j < n; ++j)
-      if (wa2[permutation.indices()[j]] != 0.)
-        gnorm = (std::max)(gnorm,
-                           abs(fjac.col(j).head(j + 1).dot(qtf.head(j + 1) / fnorm) / wa2[permutation.indices()[j]]));
-
-  /* test for convergence of the gradient norm. */
-  if (gnorm <= parameters.gtol) return LevenbergMarquardtSpace::CosinusTooSmall;
-
-  /* rescale if necessary. */
-  if (!useExternalScaling) diag = diag.cwiseMax(wa2);
-
-  do {
-    /* determine the levenberg-marquardt parameter. */
-    internal::lmpar<Scalar>(fjac, permutation.indices(), diag, qtf, delta, par, wa1);
-
-    /* store the direction p and x + p. calculate the norm of p. */
-    wa1 = -wa1;
-    wa2 = x + wa1;
-    pnorm = diag.cwiseProduct(wa1).stableNorm();
-
-    /* on the first iteration, adjust the initial step bound. */
-    if (iter == 1) delta = (std::min)(delta, pnorm);
-
-    /* evaluate the function at x + p and calculate its norm. */
-    if (functor(wa2, wa4) < 0) return LevenbergMarquardtSpace::UserAsked;
-    ++nfev;
-    fnorm1 = wa4.stableNorm();
-
-    /* compute the scaled actual reduction. */
-    actred = -1.;
-    if (Scalar(.1) * fnorm1 < fnorm) actred = 1. - numext::abs2(fnorm1 / fnorm);
-
-    /* compute the scaled predicted reduction and */
-    /* the scaled directional derivative. */
-    wa3 = fjac.topLeftCorner(n, n).template triangularView<Upper>() * (permutation.inverse() * wa1);
-    temp1 = numext::abs2(wa3.stableNorm() / fnorm);
-    temp2 = numext::abs2(sqrt(par) * pnorm / fnorm);
-    prered = temp1 + temp2 / Scalar(.5);
-    dirder = -(temp1 + temp2);
-
-    /* compute the ratio of the actual to the predicted */
-    /* reduction. */
-    ratio = 0.;
-    if (prered != 0.) ratio = actred / prered;
-
-    /* update the step bound. */
-    if (ratio <= Scalar(.25)) {
-      if (actred >= 0.) temp = Scalar(.5);
-      if (actred < 0.) temp = Scalar(.5) * dirder / (dirder + Scalar(.5) * actred);
-      if (Scalar(.1) * fnorm1 >= fnorm || temp < Scalar(.1)) temp = Scalar(.1);
-      /* Computing MIN */
-      delta = temp * (std::min)(delta, pnorm / Scalar(.1));
-      par /= temp;
-    } else if (!(par != 0. && ratio < Scalar(.75))) {
-      delta = pnorm / Scalar(.5);
-      par = Scalar(.5) * par;
-    }
-
-    /* test for successful iteration. */
-    if (ratio >= Scalar(1e-4)) {
-      /* successful iteration. update x, fvec, and their norms. */
-      x = wa2;
-      wa2 = diag.cwiseProduct(x);
-      fvec = wa4;
-      xnorm = wa2.stableNorm();
-      fnorm = fnorm1;
-      ++iter;
-    }
-
-    /* tests for convergence. */
-    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. &&
-        delta <= parameters.xtol * xnorm)
-      return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
-    if (abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
-      return LevenbergMarquardtSpace::RelativeReductionTooSmall;
-    if (delta <= parameters.xtol * xnorm) return LevenbergMarquardtSpace::RelativeErrorTooSmall;
-
-    /* tests for termination and stringent tolerances. */
-    if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
-    if (abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() &&
-        Scalar(.5) * ratio <= 1.)
-      return LevenbergMarquardtSpace::FtolTooSmall;
-    if (delta <= NumTraits<Scalar>::epsilon() * xnorm) return LevenbergMarquardtSpace::XtolTooSmall;
-    if (gnorm <= NumTraits<Scalar>::epsilon()) return LevenbergMarquardtSpace::GtolTooSmall;
-
-  } while (ratio < Scalar(1e-4));
-
-  return LevenbergMarquardtSpace::Running;
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::minimizeOptimumStorage(FVectorType &x) {
-  LevenbergMarquardtSpace::Status status = minimizeOptimumStorageInit(x);
-  if (status == LevenbergMarquardtSpace::ImproperInputParameters) return status;
-  do {
-    status = minimizeOptimumStorageOneStep(x);
-  } while (status == LevenbergMarquardtSpace::Running);
-  return status;
-}
-
-template <typename FunctorType, typename Scalar>
-LevenbergMarquardtSpace::Status LevenbergMarquardt<FunctorType, Scalar>::lmdif1(FunctorType &functor, FVectorType &x,
-                                                                                Index *nfev, const Scalar tol) {
-  Index n = x.size();
-  Index m = functor.values();
-
-  /* check the input parameters for errors. */
-  if (n <= 0 || m < n || tol < 0.) return LevenbergMarquardtSpace::ImproperInputParameters;
-
-  NumericalDiff<FunctorType> numDiff(functor);
-  // embedded LevenbergMarquardt
-  LevenbergMarquardt<NumericalDiff<FunctorType>, Scalar> lm(numDiff);
-  lm.parameters.ftol = tol;
-  lm.parameters.xtol = tol;
-  lm.parameters.maxfev = 200 * (n + 1);
-
-  LevenbergMarquardtSpace::Status info = LevenbergMarquardtSpace::Status(lm.minimize(x));
-  if (nfev) *nfev = lm.nfev;
-  return info;
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_LEVENBERGMARQUARDT__H
-
-// vim: ai ts=4 sts=4 et sw=4
diff --git a/unsupported/Eigen/src/NonLinearOptimization/chkder.h b/unsupported/Eigen/src/NonLinearOptimization/chkder.h
deleted file mode 100644
index a9311ff..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/chkder.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#define chkder_log10e 0.43429448190325182765
-#define chkder_factor 100.
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void chkder(const Matrix<Scalar, Dynamic, 1> &x, const Matrix<Scalar, Dynamic, 1> &fvec,
-            const Matrix<Scalar, Dynamic, Dynamic> &fjac, Matrix<Scalar, Dynamic, 1> &xp,
-            const Matrix<Scalar, Dynamic, 1> &fvecp, int mode, Matrix<Scalar, Dynamic, 1> &err) {
-  using std::abs;
-  using std::log;
-  using std::sqrt;
-
-  typedef DenseIndex Index;
-
-  const Scalar eps = sqrt(NumTraits<Scalar>::epsilon());
-  const Scalar epsf = chkder_factor * NumTraits<Scalar>::epsilon();
-  const Scalar epslog = chkder_log10e * log(eps);
-  Scalar temp;
-
-  const Index m = fvec.size(), n = x.size();
-
-  if (mode != 2) {
-    /* mode = 1. */
-    xp.resize(n);
-    for (Index j = 0; j < n; ++j) {
-      temp = eps * abs(x[j]);
-      if (temp == 0.) temp = eps;
-      xp[j] = x[j] + temp;
-    }
-  } else {
-    /* mode = 2. */
-    err.setZero(m);
-    for (Index j = 0; j < n; ++j) {
-      temp = abs(x[j]);
-      if (temp == 0.) temp = 1.;
-      err += temp * fjac.col(j);
-    }
-    for (Index i = 0; i < m; ++i) {
-      temp = 1.;
-      if (fvec[i] != 0. && fvecp[i] != 0. && abs(fvecp[i] - fvec[i]) >= epsf * abs(fvec[i]))
-        temp = eps * abs((fvecp[i] - fvec[i]) / eps - err[i]) / (abs(fvec[i]) + abs(fvecp[i]));
-      err[i] = 1.;
-      if (temp > NumTraits<Scalar>::epsilon() && temp < eps) err[i] = (chkder_log10e * log(temp) - epslog) / epslog;
-      if (temp >= eps) err[i] = 0.;
-    }
-  }
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/covar.h b/unsupported/Eigen/src/NonLinearOptimization/covar.h
deleted file mode 100644
index 311d998..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/covar.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void covar(Matrix<Scalar, Dynamic, Dynamic> &r, const VectorXi &ipvt,
-           Scalar tol = std::sqrt(NumTraits<Scalar>::epsilon())) {
-  using std::abs;
-  typedef DenseIndex Index;
-
-  /* Local variables */
-  Index i, j, k, l, ii, jj;
-  bool sing;
-  Scalar temp;
-
-  /* Function Body */
-  const Index n = r.cols();
-  const Scalar tolr = tol * abs(r(0, 0));
-  Matrix<Scalar, Dynamic, 1> wa(n);
-  eigen_assert(ipvt.size() == n);
-
-  /* form the inverse of r in the full upper triangle of r. */
-  l = -1;
-  for (k = 0; k < n; ++k)
-    if (abs(r(k, k)) > tolr) {
-      r(k, k) = 1. / r(k, k);
-      for (j = 0; j <= k - 1; ++j) {
-        temp = r(k, k) * r(j, k);
-        r(j, k) = 0.;
-        r.col(k).head(j + 1) -= r.col(j).head(j + 1) * temp;
-      }
-      l = k;
-    }
-
-  /* form the full upper triangle of the inverse of (r transpose)*r */
-  /* in the full upper triangle of r. */
-  for (k = 0; k <= l; ++k) {
-    for (j = 0; j <= k - 1; ++j) r.col(j).head(j + 1) += r.col(k).head(j + 1) * r(j, k);
-    r.col(k).head(k + 1) *= r(k, k);
-  }
-
-  /* form the full lower triangle of the covariance matrix */
-  /* in the strict lower triangle of r and in wa. */
-  for (j = 0; j < n; ++j) {
-    jj = ipvt[j];
-    sing = j > l;
-    for (i = 0; i <= j; ++i) {
-      if (sing) r(i, j) = 0.;
-      ii = ipvt[i];
-      if (ii > jj) r(ii, jj) = r(i, j);
-      if (ii < jj) r(jj, ii) = r(i, j);
-    }
-    wa[jj] = r(j, j);
-  }
-
-  /* symmetrize the covariance matrix in r. */
-  r.topLeftCorner(n, n).template triangularView<StrictlyUpper>() = r.topLeftCorner(n, n).transpose();
-  r.diagonal() = wa;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/dogleg.h b/unsupported/Eigen/src/NonLinearOptimization/dogleg.h
deleted file mode 100644
index d1abb9e..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/dogleg.h
+++ /dev/null
@@ -1,103 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void dogleg(const Matrix<Scalar, Dynamic, Dynamic> &qrfac, const Matrix<Scalar, Dynamic, 1> &diag,
-            const Matrix<Scalar, Dynamic, 1> &qtb, Scalar delta, Matrix<Scalar, Dynamic, 1> &x) {
-  using std::abs;
-  using std::sqrt;
-
-  typedef DenseIndex Index;
-
-  /* Local variables */
-  Index i, j;
-  Scalar sum, temp, alpha, bnorm;
-  Scalar gnorm, qnorm;
-  Scalar sgnorm;
-
-  /* Function Body */
-  const Scalar epsmch = NumTraits<Scalar>::epsilon();
-  const Index n = qrfac.cols();
-  eigen_assert(n == qtb.size());
-  eigen_assert(n == x.size());
-  eigen_assert(n == diag.size());
-  Matrix<Scalar, Dynamic, 1> wa1(n), wa2(n);
-
-  /* first, calculate the gauss-newton direction. */
-  for (j = n - 1; j >= 0; --j) {
-    temp = qrfac(j, j);
-    if (temp == 0.) {
-      temp = epsmch * qrfac.col(j).head(j + 1).maxCoeff();
-      if (temp == 0.) temp = epsmch;
-    }
-    if (j == n - 1)
-      x[j] = qtb[j] / temp;
-    else
-      x[j] = (qtb[j] - qrfac.row(j).tail(n - j - 1).dot(x.tail(n - j - 1))) / temp;
-  }
-
-  /* test whether the gauss-newton direction is acceptable. */
-  qnorm = diag.cwiseProduct(x).stableNorm();
-  if (qnorm <= delta) return;
-
-  // TODO : this path is not tested by Eigen unit tests
-
-  /* the gauss-newton direction is not acceptable. */
-  /* next, calculate the scaled gradient direction. */
-
-  wa1.fill(0.);
-  for (j = 0; j < n; ++j) {
-    wa1.tail(n - j) += qrfac.row(j).tail(n - j) * qtb[j];
-    wa1[j] /= diag[j];
-  }
-
-  /* calculate the norm of the scaled gradient and test for */
-  /* the special case in which the scaled gradient is zero. */
-  gnorm = wa1.stableNorm();
-  sgnorm = 0.;
-  alpha = delta / qnorm;
-  if (gnorm == 0.) goto algo_end;
-
-  /* calculate the point along the scaled gradient */
-  /* at which the quadratic is minimized. */
-  wa1.array() /= (diag * gnorm).array();
-  // TODO : once unit tests cover this part,:
-  // wa2 = qrfac.template triangularView<Upper>() * wa1;
-  for (j = 0; j < n; ++j) {
-    sum = 0.;
-    for (i = j; i < n; ++i) {
-      sum += qrfac(j, i) * wa1[i];
-    }
-    wa2[j] = sum;
-  }
-  temp = wa2.stableNorm();
-  sgnorm = gnorm / temp / temp;
-
-  /* test whether the scaled gradient direction is acceptable. */
-  alpha = 0.;
-  if (sgnorm >= delta) goto algo_end;
-
-  /* the scaled gradient direction is not acceptable. */
-  /* finally, calculate the point along the dogleg */
-  /* at which the quadratic is minimized. */
-  bnorm = qtb.stableNorm();
-  temp = bnorm / gnorm * (bnorm / qnorm) * (sgnorm / delta);
-  temp = temp - delta / qnorm * numext::abs2(sgnorm / delta) +
-         sqrt(numext::abs2(temp - delta / qnorm) +
-              (1. - numext::abs2(delta / qnorm)) * (1. - numext::abs2(sgnorm / delta)));
-  alpha = delta / qnorm * (1. - numext::abs2(sgnorm / delta)) / temp;
-algo_end:
-
-  /* form appropriate convex combination of the gauss-newton */
-  /* direction and the scaled gradient direction. */
-  temp = (1. - alpha) * (std::min)(sgnorm, delta);
-  x = temp * wa1 + alpha * x;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h b/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h
deleted file mode 100644
index 70da3f9..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename FunctorType, typename Scalar>
-DenseIndex fdjac1(const FunctorType &Functor, Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &fvec,
-                  Matrix<Scalar, Dynamic, Dynamic> &fjac, DenseIndex ml, DenseIndex mu, Scalar epsfcn) {
-  using std::abs;
-  using std::sqrt;
-
-  typedef DenseIndex Index;
-
-  /* Local variables */
-  Scalar h;
-  Index j, k;
-  Scalar eps, temp;
-  Index msum;
-  int iflag;
-  Index start, length;
-
-  /* Function Body */
-  const Scalar epsmch = NumTraits<Scalar>::epsilon();
-  const Index n = x.size();
-  eigen_assert(fvec.size() == n);
-  Matrix<Scalar, Dynamic, 1> wa1(n);
-  Matrix<Scalar, Dynamic, 1> wa2(n);
-
-  eps = sqrt((std::max)(epsfcn, epsmch));
-  msum = ml + mu + 1;
-  if (msum >= n) {
-    /* computation of dense approximate jacobian. */
-    for (j = 0; j < n; ++j) {
-      temp = x[j];
-      h = eps * abs(temp);
-      if (h == 0.) h = eps;
-      x[j] = temp + h;
-      iflag = Functor(x, wa1);
-      if (iflag < 0) return iflag;
-      x[j] = temp;
-      fjac.col(j) = (wa1 - fvec) / h;
-    }
-
-  } else {
-    /* computation of banded approximate jacobian. */
-    for (k = 0; k < msum; ++k) {
-      for (j = k; (msum < 0) ? (j > n) : (j < n); j += msum) {
-        wa2[j] = x[j];
-        h = eps * abs(wa2[j]);
-        if (h == 0.) h = eps;
-        x[j] = wa2[j] + h;
-      }
-      iflag = Functor(x, wa1);
-      if (iflag < 0) return iflag;
-      for (j = k; (msum < 0) ? (j > n) : (j < n); j += msum) {
-        x[j] = wa2[j];
-        h = eps * abs(wa2[j]);
-        if (h == 0.) h = eps;
-        fjac.col(j).setZero();
-        start = std::max<Index>(0, j - mu);
-        length = (std::min)(n - 1, j + ml) - start + 1;
-        fjac.col(j).segment(start, length) = (wa1.segment(start, length) - fvec.segment(start, length)) / h;
-      }
-    }
-  }
-  return 0;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/lmpar.h b/unsupported/Eigen/src/NonLinearOptimization/lmpar.h
deleted file mode 100644
index cbff829..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/lmpar.h
+++ /dev/null
@@ -1,263 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void lmpar(Matrix<Scalar, Dynamic, Dynamic> &r, const VectorXi &ipvt, const Matrix<Scalar, Dynamic, 1> &diag,
-           const Matrix<Scalar, Dynamic, 1> &qtb, Scalar delta, Scalar &par, Matrix<Scalar, Dynamic, 1> &x) {
-  using std::abs;
-  using std::sqrt;
-  typedef DenseIndex Index;
-
-  /* Local variables */
-  Index i, j, l;
-  Scalar fp;
-  Scalar parc, parl;
-  Index iter;
-  Scalar temp, paru;
-  Scalar gnorm;
-  Scalar dxnorm;
-
-  /* Function Body */
-  const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
-  const Index n = r.cols();
-  eigen_assert(n == diag.size());
-  eigen_assert(n == qtb.size());
-  eigen_assert(n == x.size());
-
-  Matrix<Scalar, Dynamic, 1> wa1, wa2;
-
-  /* compute and store in x the gauss-newton direction. if the */
-  /* jacobian is rank-deficient, obtain a least squares solution. */
-  Index nsing = n - 1;
-  wa1 = qtb;
-  for (j = 0; j < n; ++j) {
-    if (r(j, j) == 0. && nsing == n - 1) nsing = j - 1;
-    if (nsing < n - 1) wa1[j] = 0.;
-  }
-  for (j = nsing; j >= 0; --j) {
-    wa1[j] /= r(j, j);
-    temp = wa1[j];
-    for (i = 0; i < j; ++i) wa1[i] -= r(i, j) * temp;
-  }
-
-  for (j = 0; j < n; ++j) x[ipvt[j]] = wa1[j];
-
-  /* initialize the iteration counter. */
-  /* evaluate the function at the origin, and test */
-  /* for acceptance of the gauss-newton direction. */
-  iter = 0;
-  wa2 = diag.cwiseProduct(x);
-  dxnorm = wa2.blueNorm();
-  fp = dxnorm - delta;
-  if (fp <= Scalar(0.1) * delta) {
-    par = 0;
-    return;
-  }
-
-  /* if the jacobian is not rank deficient, the newton */
-  /* step provides a lower bound, parl, for the zero of */
-  /* the function. otherwise set this bound to zero. */
-  parl = 0.;
-  if (nsing >= n - 1) {
-    for (j = 0; j < n; ++j) {
-      l = ipvt[j];
-      wa1[j] = diag[l] * (wa2[l] / dxnorm);
-    }
-    // Triangular solve (forward substitution):
-    for (j = 0; j < n; ++j) {
-      Scalar sum = 0.;
-      for (i = 0; i < j; ++i) sum += r(i, j) * wa1[i];
-      wa1[j] = (wa1[j] - sum) / r(j, j);
-    }
-    temp = wa1.blueNorm();
-    parl = fp / delta / temp / temp;
-  }
-
-  /* calculate an upper bound, paru, for the zero of the function. */
-  for (j = 0; j < n; ++j) wa1[j] = r.col(j).head(j + 1).dot(qtb.head(j + 1)) / diag[ipvt[j]];
-
-  gnorm = wa1.stableNorm();
-  paru = gnorm / delta;
-  if (paru == 0.) paru = dwarf / (std::min)(delta, Scalar(0.1));
-
-  /* if the input par lies outside of the interval (parl,paru), */
-  /* set par to the closer endpoint. */
-  par = (std::max)(par, parl);
-  par = (std::min)(par, paru);
-  if (par == 0.) par = gnorm / dxnorm;
-
-  /* beginning of an iteration. */
-  while (true) {
-    ++iter;
-
-    /* evaluate the function at the current value of par. */
-    if (par == 0.) par = (std::max)(dwarf, Scalar(.001) * paru); /* Computing MAX */
-    wa1 = sqrt(par) * diag;
-
-    Matrix<Scalar, Dynamic, 1> sdiag(n);
-    qrsolv<Scalar>(r, ipvt, wa1, qtb, x, sdiag);
-
-    wa2 = diag.cwiseProduct(x);
-    dxnorm = wa2.blueNorm();
-    temp = fp;
-    fp = dxnorm - delta;
-
-    /* if the function is small enough, accept the current value */
-    /* of par. also test for the exceptional cases where parl */
-    /* is zero or the number of iterations has reached 10. */
-    if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10) break;
-
-    /* compute the newton correction. */
-    for (j = 0; j < n; ++j) {
-      l = ipvt[j];
-      wa1[j] = diag[l] * (wa2[l] / dxnorm);
-    }
-    for (j = 0; j < n; ++j) {
-      wa1[j] /= sdiag[j];
-      temp = wa1[j];
-      for (i = j + 1; i < n; ++i) wa1[i] -= r(i, j) * temp;
-    }
-    temp = wa1.blueNorm();
-    parc = fp / delta / temp / temp;
-
-    /* depending on the sign of the function, update parl or paru. */
-    if (fp > 0.) parl = (std::max)(parl, par);
-    if (fp < 0.) paru = (std::min)(paru, par);
-
-    /* compute an improved estimate for par. */
-    /* Computing MAX */
-    par = (std::max)(parl, par + parc);
-
-    /* end of an iteration. */
-  }
-
-  /* termination. */
-  if (iter == 0) par = 0.;
-  return;
-}
-
-template <typename Scalar>
-void lmpar2(const ColPivHouseholderQR<Matrix<Scalar, Dynamic, Dynamic> > &qr, const Matrix<Scalar, Dynamic, 1> &diag,
-            const Matrix<Scalar, Dynamic, 1> &qtb, Scalar delta, Scalar &par, Matrix<Scalar, Dynamic, 1> &x)
-
-{
-  using std::abs;
-  using std::sqrt;
-  typedef DenseIndex Index;
-
-  /* Local variables */
-  Index j;
-  Scalar fp;
-  Scalar parc, parl;
-  Index iter;
-  Scalar temp, paru;
-  Scalar gnorm;
-  Scalar dxnorm;
-
-  /* Function Body */
-  const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
-  const Index n = qr.matrixQR().cols();
-  eigen_assert(n == diag.size());
-  eigen_assert(n == qtb.size());
-
-  Matrix<Scalar, Dynamic, 1> wa1, wa2;
-
-  /* compute and store in x the gauss-newton direction. if the */
-  /* jacobian is rank-deficient, obtain a least squares solution. */
-
-  const Index rank = qr.rank();  // use a threshold
-  wa1 = qtb;
-  wa1.tail(n - rank).setZero();
-  qr.matrixQR().topLeftCorner(rank, rank).template triangularView<Upper>().solveInPlace(wa1.head(rank));
-
-  x = qr.colsPermutation() * wa1;
-
-  /* initialize the iteration counter. */
-  /* evaluate the function at the origin, and test */
-  /* for acceptance of the gauss-newton direction. */
-  iter = 0;
-  wa2 = diag.cwiseProduct(x);
-  dxnorm = wa2.blueNorm();
-  fp = dxnorm - delta;
-  if (fp <= Scalar(0.1) * delta) {
-    par = 0;
-    return;
-  }
-
-  /* if the jacobian is not rank deficient, the newton */
-  /* step provides a lower bound, parl, for the zero of */
-  /* the function. otherwise set this bound to zero. */
-  parl = 0.;
-  if (rank == n) {
-    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2) / dxnorm;
-    qr.matrixQR().topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
-    temp = wa1.blueNorm();
-    parl = fp / delta / temp / temp;
-  }
-
-  /* calculate an upper bound, paru, for the zero of the function. */
-  for (j = 0; j < n; ++j)
-    wa1[j] = qr.matrixQR().col(j).head(j + 1).dot(qtb.head(j + 1)) / diag[qr.colsPermutation().indices()(j)];
-
-  gnorm = wa1.stableNorm();
-  paru = gnorm / delta;
-  if (paru == 0.) paru = dwarf / (std::min)(delta, Scalar(0.1));
-
-  /* if the input par lies outside of the interval (parl,paru), */
-  /* set par to the closer endpoint. */
-  par = (std::max)(par, parl);
-  par = (std::min)(par, paru);
-  if (par == 0.) par = gnorm / dxnorm;
-
-  /* beginning of an iteration. */
-  Matrix<Scalar, Dynamic, Dynamic> s = qr.matrixQR();
-  while (true) {
-    ++iter;
-
-    /* evaluate the function at the current value of par. */
-    if (par == 0.) par = (std::max)(dwarf, Scalar(.001) * paru); /* Computing MAX */
-    wa1 = sqrt(par) * diag;
-
-    Matrix<Scalar, Dynamic, 1> sdiag(n);
-    qrsolv<Scalar>(s, qr.colsPermutation().indices(), wa1, qtb, x, sdiag);
-
-    wa2 = diag.cwiseProduct(x);
-    dxnorm = wa2.blueNorm();
-    temp = fp;
-    fp = dxnorm - delta;
-
-    /* if the function is small enough, accept the current value */
-    /* of par. also test for the exceptional cases where parl */
-    /* is zero or the number of iterations has reached 10. */
-    if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10) break;
-
-    /* compute the newton correction. */
-    wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2 / dxnorm);
-    // we could almost use this here, but the diagonal is outside qr, in sdiag[]
-    // qr.matrixQR().topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
-    for (j = 0; j < n; ++j) {
-      wa1[j] /= sdiag[j];
-      temp = wa1[j];
-      for (Index i = j + 1; i < n; ++i) wa1[i] -= s(i, j) * temp;
-    }
-    temp = wa1.blueNorm();
-    parc = fp / delta / temp / temp;
-
-    /* depending on the sign of the function, update parl or paru. */
-    if (fp > 0.) parl = (std::max)(parl, par);
-    if (fp < 0.) paru = (std::min)(paru, par);
-
-    /* compute an improved estimate for par. */
-    par = (std::max)(parl, par + parc);
-  }
-  if (iter == 0) par = 0.;
-  return;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h b/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h
deleted file mode 100644
index 2e4d036..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// TODO : once qrsolv2 is removed, use ColPivHouseholderQR or PermutationMatrix instead of ipvt
-template <typename Scalar>
-void qrsolv(Matrix<Scalar, Dynamic, Dynamic> &s,
-            // TODO : use a PermutationMatrix once lmpar is no more:
-            const VectorXi &ipvt, const Matrix<Scalar, Dynamic, 1> &diag, const Matrix<Scalar, Dynamic, 1> &qtb,
-            Matrix<Scalar, Dynamic, 1> &x, Matrix<Scalar, Dynamic, 1> &sdiag)
-
-{
-  typedef DenseIndex Index;
-
-  /* Local variables */
-  Index i, j, k, l;
-  Scalar temp;
-  Index n = s.cols();
-  Matrix<Scalar, Dynamic, 1> wa(n);
-  JacobiRotation<Scalar> givens;
-
-  /* Function Body */
-  // the following will only change the lower triangular part of s, including
-  // the diagonal, though the diagonal is restored afterward
-
-  /*     copy r and (q transpose)*b to preserve input and initialize s. */
-  /*     in particular, save the diagonal elements of r in x. */
-  x = s.diagonal();
-  wa = qtb;
-
-  s.topLeftCorner(n, n).template triangularView<StrictlyLower>() = s.topLeftCorner(n, n).transpose();
-
-  /*     eliminate the diagonal matrix d using a givens rotation. */
-  for (j = 0; j < n; ++j) {
-    /*        prepare the row of d to be eliminated, locating the */
-    /*        diagonal element using p from the qr factorization. */
-    l = ipvt[j];
-    if (diag[l] == 0.) break;
-    sdiag.tail(n - j).setZero();
-    sdiag[j] = diag[l];
-
-    /*        the transformations to eliminate the row of d */
-    /*        modify only a single element of (q transpose)*b */
-    /*        beyond the first n, which is initially zero. */
-    Scalar qtbpj = 0.;
-    for (k = j; k < n; ++k) {
-      /*           determine a givens rotation which eliminates the */
-      /*           appropriate element in the current row of d. */
-      givens.makeGivens(-s(k, k), sdiag[k]);
-
-      /*           compute the modified diagonal element of r and */
-      /*           the modified element of ((q transpose)*b,0). */
-      s(k, k) = givens.c() * s(k, k) + givens.s() * sdiag[k];
-      temp = givens.c() * wa[k] + givens.s() * qtbpj;
-      qtbpj = -givens.s() * wa[k] + givens.c() * qtbpj;
-      wa[k] = temp;
-
-      /*           accumulate the transformation in the row of s. */
-      for (i = k + 1; i < n; ++i) {
-        temp = givens.c() * s(i, k) + givens.s() * sdiag[i];
-        sdiag[i] = -givens.s() * s(i, k) + givens.c() * sdiag[i];
-        s(i, k) = temp;
-      }
-    }
-  }
-
-  /*     solve the triangular system for z. if the system is */
-  /*     singular, then obtain a least squares solution. */
-  Index nsing;
-  for (nsing = 0; nsing < n && sdiag[nsing] != 0; nsing++) {
-  }
-
-  wa.tail(n - nsing).setZero();
-  s.topLeftCorner(nsing, nsing).transpose().template triangularView<Upper>().solveInPlace(wa.head(nsing));
-
-  // restore
-  sdiag = s.diagonal();
-  s.diagonal() = x;
-
-  /*     permute the components of z back to components of x. */
-  for (j = 0; j < n; ++j) x[ipvt[j]] = wa[j];
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h b/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h
deleted file mode 100644
index ea41315..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// TODO : move this to GivensQR once there's such a thing in Eigen
-
-template <typename Scalar>
-void r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector<JacobiRotation<Scalar> > &v_givens,
-            const std::vector<JacobiRotation<Scalar> > &w_givens) {
-  typedef DenseIndex Index;
-
-  /*     apply the first set of givens rotations to a. */
-  for (Index j = n - 2; j >= 0; --j)
-    for (Index i = 0; i < m; ++i) {
-      Scalar temp = v_givens[j].c() * a[i + m * j] - v_givens[j].s() * a[i + m * (n - 1)];
-      a[i + m * (n - 1)] = v_givens[j].s() * a[i + m * j] + v_givens[j].c() * a[i + m * (n - 1)];
-      a[i + m * j] = temp;
-    }
-  /*     apply the second set of givens rotations to a. */
-  for (Index j = 0; j < n - 1; ++j)
-    for (Index i = 0; i < m; ++i) {
-      Scalar temp = w_givens[j].c() * a[i + m * j] + w_givens[j].s() * a[i + m * (n - 1)];
-      a[i + m * (n - 1)] = -w_givens[j].s() * a[i + m * j] + w_givens[j].c() * a[i + m * (n - 1)];
-      a[i + m * j] = temp;
-    }
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
deleted file mode 100644
index 201fba3..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1> &u,
-            std::vector<JacobiRotation<Scalar> > &v_givens, std::vector<JacobiRotation<Scalar> > &w_givens,
-            Matrix<Scalar, Dynamic, 1> &v, Matrix<Scalar, Dynamic, 1> &w, bool *sing) {
-  typedef DenseIndex Index;
-  const JacobiRotation<Scalar> IdentityRotation = JacobiRotation<Scalar>(1, 0);
-
-  /* Local variables */
-  const Index m = s.rows();
-  const Index n = s.cols();
-  Index i, j = 1;
-  Scalar temp;
-  JacobiRotation<Scalar> givens;
-
-  // r1updt had a broader usecase, but we don't use it here. And, more
-  // importantly, we can not test it.
-  eigen_assert(m == n);
-  eigen_assert(u.size() == m);
-  eigen_assert(v.size() == n);
-  eigen_assert(w.size() == n);
-
-  /* move the nontrivial part of the last column of s into w. */
-  w[n - 1] = s(n - 1, n - 1);
-
-  /* rotate the vector v into a multiple of the n-th unit vector */
-  /* in such a way that a spike is introduced into w. */
-  for (j = n - 2; j >= 0; --j) {
-    w[j] = 0.;
-    if (v[j] != 0.) {
-      /* determine a givens rotation which eliminates the */
-      /* j-th element of v. */
-      givens.makeGivens(-v[n - 1], v[j]);
-
-      /* apply the transformation to v and store the information */
-      /* necessary to recover the givens rotation. */
-      v[n - 1] = givens.s() * v[j] + givens.c() * v[n - 1];
-      v_givens[j] = givens;
-
-      /* apply the transformation to s and extend the spike in w. */
-      for (i = j; i < m; ++i) {
-        temp = givens.c() * s(j, i) - givens.s() * w[i];
-        w[i] = givens.s() * s(j, i) + givens.c() * w[i];
-        s(j, i) = temp;
-      }
-    } else
-      v_givens[j] = IdentityRotation;
-  }
-
-  /* add the spike from the rank 1 update to w. */
-  w += v[n - 1] * u;
-
-  /* eliminate the spike. */
-  *sing = false;
-  for (j = 0; j < n - 1; ++j) {
-    if (w[j] != 0.) {
-      /* determine a givens rotation which eliminates the */
-      /* j-th element of the spike. */
-      givens.makeGivens(-s(j, j), w[j]);
-
-      /* apply the transformation to s and reduce the spike in w. */
-      for (i = j; i < m; ++i) {
-        temp = givens.c() * s(j, i) + givens.s() * w[i];
-        w[i] = -givens.s() * s(j, i) + givens.c() * w[i];
-        s(j, i) = temp;
-      }
-
-      /* store the information necessary to recover the */
-      /* givens rotation. */
-      w_givens[j] = givens;
-    } else
-      w_givens[j] = IdentityRotation;
-
-    /* test for zero diagonal elements in the output s. */
-    if (s(j, j) == 0.) {
-      *sing = true;
-    }
-  }
-  /* move w back into the last column of the output s. */
-  s(n - 1, n - 1) = w[n - 1];
-
-  if (s(j, j) == 0.) {
-    *sing = true;
-  }
-  return;
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h b/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h
deleted file mode 100644
index 8ae5848..0000000
--- a/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Scalar>
-void rwupdt(Matrix<Scalar, Dynamic, Dynamic> &r, const Matrix<Scalar, Dynamic, 1> &w, Matrix<Scalar, Dynamic, 1> &b,
-            Scalar alpha) {
-  typedef DenseIndex Index;
-
-  const Index n = r.cols();
-  eigen_assert(r.rows() >= n);
-  std::vector<JacobiRotation<Scalar> > givens(n);
-
-  /* Local variables */
-  Scalar temp, rowj;
-
-  /* Function Body */
-  for (Index j = 0; j < n; ++j) {
-    rowj = w[j];
-
-    /* apply the previous transformations to */
-    /* r(i,j), i=0,1,...,j-1, and to w(j). */
-    for (Index i = 0; i < j; ++i) {
-      temp = givens[i].c() * r(i, j) + givens[i].s() * rowj;
-      rowj = -givens[i].s() * r(i, j) + givens[i].c() * rowj;
-      r(i, j) = temp;
-    }
-
-    /* determine a givens rotation which eliminates w(j). */
-    givens[j].makeGivens(-r(j, j), rowj);
-
-    if (rowj == 0.) continue;  // givens[j] is identity
-
-    /* apply the current transformation to r(j,j), b(j), and alpha. */
-    r(j, j) = givens[j].c() * r(j, j) + givens[j].s() * rowj;
-    temp = givens[j].c() * b[j] + givens[j].s() * alpha;
-    alpha = -givens[j].s() * b[j] + givens[j].c() * alpha;
-    b[j] = temp;
-  }
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
diff --git a/unsupported/Eigen/src/NumericalDiff/InternalHeaderCheck.h b/unsupported/Eigen/src/NumericalDiff/InternalHeaderCheck.h
deleted file mode 100644
index 8c513d2..0000000
--- a/unsupported/Eigen/src/NumericalDiff/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_NUMERICALDIFF_MODULE_H
-#error "Please include unsupported/Eigen/NumericalDiff instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h b/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h
deleted file mode 100644
index 0f4f929..0000000
--- a/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h
+++ /dev/null
@@ -1,127 +0,0 @@
-// -*- coding: utf-8
-// vim: set fileencoding=utf-8
-
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_NUMERICAL_DIFF_H
-#define EIGEN_NUMERICAL_DIFF_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-enum NumericalDiffMode { Forward, Central };
-
-/**
- * This class allows you to add a method df() to your functor, which will
- * use numerical differentiation to compute an approximate of the
- * derivative for the functor. Of course, if you have an analytical form
- * for the derivative, you should rather implement df() by yourself.
- *
- * More information on
- * http://en.wikipedia.org/wiki/Numerical_differentiation
- *
- * Currently only "Forward" and "Central" scheme are implemented.
- */
-template <typename Functor_, NumericalDiffMode mode = Forward>
-class NumericalDiff : public Functor_ {
- public:
-  typedef Functor_ Functor;
-  typedef typename Functor::Scalar Scalar;
-  typedef typename Functor::InputType InputType;
-  typedef typename Functor::ValueType ValueType;
-  typedef typename Functor::JacobianType JacobianType;
-
-  NumericalDiff(Scalar _epsfcn = 0.) : Functor(), epsfcn(_epsfcn) {}
-  NumericalDiff(const Functor& f, Scalar _epsfcn = 0.) : Functor(f), epsfcn(_epsfcn) {}
-
-  // forward constructors
-  template <typename T0>
-  NumericalDiff(const T0& a0) : Functor(a0), epsfcn(0) {}
-  template <typename T0, typename T1>
-  NumericalDiff(const T0& a0, const T1& a1) : Functor(a0, a1), epsfcn(0) {}
-  template <typename T0, typename T1, typename T2>
-  NumericalDiff(const T0& a0, const T1& a1, const T2& a2) : Functor(a0, a1, a2), epsfcn(0) {}
-
-  enum { InputsAtCompileTime = Functor::InputsAtCompileTime, ValuesAtCompileTime = Functor::ValuesAtCompileTime };
-
-  /**
-   * return the number of evaluation of functor
-   */
-  int df(const InputType& _x, JacobianType& jac) const {
-    using std::abs;
-    using std::sqrt;
-    /* Local variables */
-    Scalar h;
-    int nfev = 0;
-    const typename InputType::Index n = _x.size();
-    const Scalar eps = sqrt(((std::max)(epsfcn, NumTraits<Scalar>::epsilon())));
-    ValueType val1, val2;
-    InputType x = _x;
-    // TODO: We should do this only if the size is not already known.
-    val1.resize(Functor::values());
-    val2.resize(Functor::values());
-
-    // initialization
-    switch (mode) {
-      case Forward:
-        // compute f(x)
-        Functor::operator()(x, val1);
-        nfev++;
-        break;
-      case Central:
-        // do nothing
-        break;
-      default:
-        eigen_assert(false);
-    };
-
-    // Function Body
-    for (int j = 0; j < n; ++j) {
-      h = eps * abs(x[j]);
-      if (h == 0.) {
-        h = eps;
-      }
-      switch (mode) {
-        case Forward:
-          x[j] += h;
-          Functor::operator()(x, val2);
-          nfev++;
-          x[j] = _x[j];
-          jac.col(j) = (val2 - val1) / h;
-          break;
-        case Central:
-          x[j] += h;
-          Functor::operator()(x, val2);
-          nfev++;
-          x[j] -= 2 * h;
-          Functor::operator()(x, val1);
-          nfev++;
-          x[j] = _x[j];
-          jac.col(j) = (val2 - val1) / (2 * h);
-          break;
-        default:
-          eigen_assert(false);
-      };
-    }
-    return nfev;
-  }
-
- private:
-  Scalar epsfcn;
-
-  NumericalDiff& operator=(const NumericalDiff&);
-};
-
-}  // end namespace Eigen
-
-// vim: ai ts=4 sts=4 et sw=4
-#endif  // EIGEN_NUMERICAL_DIFF_H
diff --git a/unsupported/Eigen/src/Polynomials/Companion.h b/unsupported/Eigen/src/Polynomials/Companion.h
deleted file mode 100644
index 3000b4c..0000000
--- a/unsupported/Eigen/src/Polynomials/Companion.h
+++ /dev/null
@@ -1,255 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_COMPANION_H
-#define EIGEN_COMPANION_H
-
-// This file requires the user to include
-// * Eigen/Core
-// * Eigen/src/PolynomialSolver.h
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-
-template <int Size>
-struct decrement_if_fixed_size {
-  enum { ret = (Size == Dynamic) ? Dynamic : Size - 1 };
-};
-
-#endif
-
-template <typename Scalar_, int Deg_>
-class companion {
- public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Deg_ == Dynamic ? Dynamic : Deg_)
-
-  enum { Deg = Deg_, Deg_1 = decrement_if_fixed_size<Deg>::ret };
-
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Matrix<Scalar, Deg, 1> RightColumn;
-  typedef Matrix<Scalar, Deg_1, 1> BottomLeftDiagonal;
-
-  typedef Matrix<Scalar, Deg, Deg> DenseCompanionMatrixType;
-  typedef Matrix<Scalar, Deg_, Deg_1> LeftBlock;
-  typedef Matrix<Scalar, Deg_1, Deg_1> BottomLeftBlock;
-  typedef Matrix<Scalar, 1, Deg_1> LeftBlockFirstRow;
-
-  typedef DenseIndex Index;
-
- public:
-  EIGEN_STRONG_INLINE const Scalar_ operator()(Index row, Index col) const {
-    if (m_bl_diag.rows() > col) {
-      if (0 < row) {
-        return m_bl_diag[col];
-      } else {
-        return 0;
-      }
-    } else {
-      return m_monic[row];
-    }
-  }
-
-#ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
-  EIGEN_STRONG_INLINE const Scalar_ operator[](Index row, Index col) const { return operator()(row, col); }
-#endif
-
- public:
-  template <typename VectorType>
-  void setPolynomial(const VectorType& poly) {
-    const Index deg = poly.size() - 1;
-    m_monic = -poly.head(deg) / poly[deg];
-    m_bl_diag.setOnes(deg - 1);
-  }
-
-  template <typename VectorType>
-  companion(const VectorType& poly) {
-    setPolynomial(poly);
-  }
-
- public:
-  DenseCompanionMatrixType denseMatrix() const {
-    const Index deg = m_monic.size();
-    const Index deg_1 = deg - 1;
-    DenseCompanionMatrixType companMat(deg, deg);
-    companMat << (LeftBlock(deg, deg_1) << LeftBlockFirstRow::Zero(1, deg_1),
-                  BottomLeftBlock::Identity(deg - 1, deg - 1) * m_bl_diag.asDiagonal())
-                     .finished(),
-        m_monic;
-    return companMat;
-  }
-
- protected:
-  /** Helper function for the balancing algorithm.
-   * \returns true if the row and the column, having colNorm and rowNorm
-   * as norms, are balanced, false otherwise.
-   * colB and rowB are respectively the multipliers for
-   * the column and the row in order to balance them.
-   * */
-  bool balanced(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced, RealScalar& colB, RealScalar& rowB);
-
-  /** Helper function for the balancing algorithm.
-   * \returns true if the row and the column, having colNorm and rowNorm
-   * as norms, are balanced, false otherwise.
-   * colB and rowB are respectively the multipliers for
-   * the column and the row in order to balance them.
-   * */
-  bool balancedR(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced, RealScalar& colB, RealScalar& rowB);
-
- public:
-  /**
-   * Balancing algorithm from B. N. PARLETT and C. REINSCH (1969)
-   * "Balancing a matrix for calculation of eigenvalues and eigenvectors"
-   * adapted to the case of companion matrices.
-   * A matrix with non zero row and non zero column is balanced
-   * for a certain norm if the i-th row and the i-th column
-   * have same norm for all i.
-   */
-  void balance();
-
- protected:
-  RightColumn m_monic;
-  BottomLeftDiagonal m_bl_diag;
-};
-
-template <typename Scalar_, int Deg_>
-inline bool companion<Scalar_, Deg_>::balanced(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced,
-                                               RealScalar& colB, RealScalar& rowB) {
-  if (RealScalar(0) == colNorm || RealScalar(0) == rowNorm || !(numext::isfinite)(colNorm) ||
-      !(numext::isfinite)(rowNorm)) {
-    return true;
-  } else {
-    // To find the balancing coefficients, if the radix is 2,
-    // one finds \f$ \sigma \f$ such that
-    //  \f$ 2^{2\sigma-1} < rowNorm / colNorm \le 2^{2\sigma+1} \f$
-    //  then the balancing coefficient for the row is \f$ 1/2^{\sigma} \f$
-    //  and the balancing coefficient for the column is \f$ 2^{\sigma} \f$
-    const RealScalar radix = RealScalar(2);
-    const RealScalar radix2 = RealScalar(4);
-
-    rowB = rowNorm / radix;
-    colB = RealScalar(1);
-    const RealScalar s = colNorm + rowNorm;
-
-    // Find sigma s.t. rowNorm / 2 <= 2^(2*sigma) * colNorm
-    RealScalar scout = colNorm;
-    while (scout < rowB) {
-      colB *= radix;
-      scout *= radix2;
-    }
-
-    // We now have an upper-bound for sigma, try to lower it.
-    // Find sigma s.t. 2^(2*sigma) * colNorm / 2 < rowNorm
-    scout = colNorm * (colB / radix) * colB;  // Avoid overflow.
-    while (scout >= rowNorm) {
-      colB /= radix;
-      scout /= radix2;
-    }
-
-    // This line is used to avoid insubstantial balancing.
-    if ((rowNorm + radix * scout) < RealScalar(0.95) * s * colB) {
-      isBalanced = false;
-      rowB = RealScalar(1) / colB;
-      return false;
-    } else {
-      return true;
-    }
-  }
-}
-
-template <typename Scalar_, int Deg_>
-inline bool companion<Scalar_, Deg_>::balancedR(RealScalar colNorm, RealScalar rowNorm, bool& isBalanced,
-                                                RealScalar& colB, RealScalar& rowB) {
-  if (RealScalar(0) == colNorm || RealScalar(0) == rowNorm) {
-    return true;
-  } else {
-    /**
-     * Set the norm of the column and the row to the geometric mean
-     * of the row and column norm
-     */
-    const RealScalar q = colNorm / rowNorm;
-    if (!isApprox(q, Scalar_(1))) {
-      rowB = sqrt(colNorm / rowNorm);
-      colB = RealScalar(1) / rowB;
-
-      isBalanced = false;
-      return false;
-    } else {
-      return true;
-    }
-  }
-}
-
-template <typename Scalar_, int Deg_>
-void companion<Scalar_, Deg_>::balance() {
-  using std::abs;
-  EIGEN_STATIC_ASSERT(Deg == Dynamic || 1 < Deg, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  const Index deg = m_monic.size();
-  const Index deg_1 = deg - 1;
-
-  bool hasConverged = false;
-  while (!hasConverged) {
-    hasConverged = true;
-    RealScalar colNorm, rowNorm;
-    RealScalar colB, rowB;
-
-    // First row, first column excluding the diagonal
-    //==============================================
-    colNorm = abs(m_bl_diag[0]);
-    rowNorm = abs(m_monic[0]);
-
-    // Compute balancing of the row and the column
-    if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
-      m_bl_diag[0] *= colB;
-      m_monic[0] *= rowB;
-    }
-
-    // Middle rows and columns excluding the diagonal
-    //==============================================
-    for (Index i = 1; i < deg_1; ++i) {
-      // column norm, excluding the diagonal
-      colNorm = abs(m_bl_diag[i]);
-
-      // row norm, excluding the diagonal
-      rowNorm = abs(m_bl_diag[i - 1]) + abs(m_monic[i]);
-
-      // Compute balancing of the row and the column
-      if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
-        m_bl_diag[i] *= colB;
-        m_bl_diag[i - 1] *= rowB;
-        m_monic[i] *= rowB;
-      }
-    }
-
-    // Last row, last column excluding the diagonal
-    //============================================
-    const Index ebl = m_bl_diag.size() - 1;
-    VectorBlock<RightColumn, Deg_1> headMonic(m_monic, 0, deg_1);
-    colNorm = headMonic.array().abs().sum();
-    rowNorm = abs(m_bl_diag[ebl]);
-
-    // Compute balancing of the row and the column
-    if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
-      headMonic *= colB;
-      m_bl_diag[ebl] *= rowB;
-    }
-  }
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_COMPANION_H
diff --git a/unsupported/Eigen/src/Polynomials/InternalHeaderCheck.h b/unsupported/Eigen/src/Polynomials/InternalHeaderCheck.h
deleted file mode 100644
index b3aa50c..0000000
--- a/unsupported/Eigen/src/Polynomials/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_POLYNOMIALS_MODULE_H
-#error "Please include unsupported/Eigen/Polynomials instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/Polynomials/PolynomialSolver.h b/unsupported/Eigen/src/Polynomials/PolynomialSolver.h
deleted file mode 100644
index a79a49e..0000000
--- a/unsupported/Eigen/src/Polynomials/PolynomialSolver.h
+++ /dev/null
@@ -1,387 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_POLYNOMIAL_SOLVER_H
-#define EIGEN_POLYNOMIAL_SOLVER_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \ingroup Polynomials_Module
- *  \class PolynomialSolverBase.
- *
- * \brief Defined to be inherited by polynomial solvers: it provides
- * convenient methods such as
- *  - real roots,
- *  - greatest, smallest complex roots,
- *  - real roots with greatest, smallest absolute real value,
- *  - greatest, smallest real roots.
- *
- * It stores the set of roots as a vector of complexes.
- *
- */
-template <typename Scalar_, int Deg_>
-class PolynomialSolverBase {
- public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Deg_ == Dynamic ? Dynamic : Deg_)
-
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef internal::make_complex_t<Scalar> RootType;
-  typedef Matrix<RootType, Deg_, 1> RootsType;
-
-  typedef DenseIndex Index;
-
- protected:
-  template <typename OtherPolynomial>
-  inline void setPolynomial(const OtherPolynomial& poly) {
-    m_roots.resize(poly.size() - 1);
-  }
-
- public:
-  template <typename OtherPolynomial>
-  inline PolynomialSolverBase(const OtherPolynomial& poly) {
-    setPolynomial(poly());
-  }
-
-  inline PolynomialSolverBase() {}
-
- public:
-  /** \returns the complex roots of the polynomial */
-  inline const RootsType& roots() const { return m_roots; }
-
- public:
-  /** Clear and fills the back insertion sequence with the real roots of the polynomial
-   * i.e. the real part of the complex roots that have an imaginary part which
-   * absolute value is smaller than absImaginaryThreshold.
-   * absImaginaryThreshold takes the dummy_precision associated
-   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
-   *
-   * \param[out] bi_seq : the back insertion sequence (stl concept)
-   * \param[in]  absImaginaryThreshold : the maximum bound of the imaginary part of a complex
-   *  number that is considered as real.
-   * */
-  template <typename Stl_back_insertion_sequence>
-  inline void realRoots(Stl_back_insertion_sequence& bi_seq,
-                        const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    using std::abs;
-    bi_seq.clear();
-    for (Index i = 0; i < m_roots.size(); ++i) {
-      if (abs(m_roots[i].imag()) < absImaginaryThreshold) {
-        bi_seq.push_back(m_roots[i].real());
-      }
-    }
-  }
-
- protected:
-  template <typename Predicate>
-  inline const RootType& selectComplexRoot_withRespectToNorm(Predicate& pred) const {
-    Index res = 0;
-    RealScalar norm2 = numext::abs2(m_roots[0]);
-    for (Index i = 1; i < m_roots.size(); ++i) {
-      const RealScalar currNorm2 = numext::abs2(m_roots[i]);
-      if (pred(currNorm2, norm2)) {
-        res = i;
-        norm2 = currNorm2;
-      }
-    }
-    return m_roots[res];
-  }
-
- public:
-  /**
-   * \returns the complex root with greatest norm.
-   */
-  inline const RootType& greatestRoot() const {
-    std::greater<RealScalar> greater;
-    return selectComplexRoot_withRespectToNorm(greater);
-  }
-
-  /**
-   * \returns the complex root with smallest norm.
-   */
-  inline const RootType& smallestRoot() const {
-    std::less<RealScalar> less;
-    return selectComplexRoot_withRespectToNorm(less);
-  }
-
- protected:
-  template <typename Predicate>
-  inline const RealScalar& selectRealRoot_withRespectToAbsRealPart(
-      Predicate& pred, bool& hasArealRoot,
-      const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    using std::abs;
-    hasArealRoot = false;
-    Index res = 0;
-    RealScalar val(0);
-
-    for (Index i = 0; i < m_roots.size(); ++i) {
-      if (abs(m_roots[i].imag()) <= absImaginaryThreshold) {
-        if (!hasArealRoot) {
-          hasArealRoot = true;
-          res = i;
-          val = abs(m_roots[i].real());
-        } else {
-          const RealScalar curr = abs(m_roots[i].real());
-          if (pred(curr, val)) {
-            val = curr;
-            res = i;
-          }
-        }
-      } else if (!hasArealRoot) {
-        if (abs(m_roots[i].imag()) < abs(m_roots[res].imag())) {
-          res = i;
-        }
-      }
-    }
-    return numext::real_ref(m_roots[res]);
-  }
-
-  template <typename Predicate>
-  inline const RealScalar& selectRealRoot_withRespectToRealPart(
-      Predicate& pred, bool& hasArealRoot,
-      const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    using std::abs;
-    hasArealRoot = false;
-    Index res = 0;
-    RealScalar val(0);
-
-    for (Index i = 0; i < m_roots.size(); ++i) {
-      if (abs(m_roots[i].imag()) <= absImaginaryThreshold) {
-        if (!hasArealRoot) {
-          hasArealRoot = true;
-          res = i;
-          val = m_roots[i].real();
-        } else {
-          const RealScalar curr = m_roots[i].real();
-          if (pred(curr, val)) {
-            val = curr;
-            res = i;
-          }
-        }
-      } else {
-        if (abs(m_roots[i].imag()) < abs(m_roots[res].imag())) {
-          res = i;
-        }
-      }
-    }
-    return numext::real_ref(m_roots[res]);
-  }
-
- public:
-  /**
-   * \returns a real root with greatest absolute magnitude.
-   * A real root is defined as the real part of a complex root with absolute imaginary
-   * part smallest than absImaginaryThreshold.
-   * absImaginaryThreshold takes the dummy_precision associated
-   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
-   * If no real root is found the boolean hasArealRoot is set to false and the real part of
-   * the root with smallest absolute imaginary part is returned instead.
-   *
-   * \param[out] hasArealRoot : boolean true if a real root is found according to the
-   *  absImaginaryThreshold criterion, false otherwise.
-   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
-   *  whether or not a root is real.
-   */
-  inline const RealScalar& absGreatestRealRoot(
-      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    std::greater<RealScalar> greater;
-    return selectRealRoot_withRespectToAbsRealPart(greater, hasArealRoot, absImaginaryThreshold);
-  }
-
-  /**
-   * \returns a real root with smallest absolute magnitude.
-   * A real root is defined as the real part of a complex root with absolute imaginary
-   * part smallest than absImaginaryThreshold.
-   * absImaginaryThreshold takes the dummy_precision associated
-   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
-   * If no real root is found the boolean hasArealRoot is set to false and the real part of
-   * the root with smallest absolute imaginary part is returned instead.
-   *
-   * \param[out] hasArealRoot : boolean true if a real root is found according to the
-   *  absImaginaryThreshold criterion, false otherwise.
-   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
-   *  whether or not a root is real.
-   */
-  inline const RealScalar& absSmallestRealRoot(
-      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    std::less<RealScalar> less;
-    return selectRealRoot_withRespectToAbsRealPart(less, hasArealRoot, absImaginaryThreshold);
-  }
-
-  /**
-   * \returns the real root with greatest value.
-   * A real root is defined as the real part of a complex root with absolute imaginary
-   * part smallest than absImaginaryThreshold.
-   * absImaginaryThreshold takes the dummy_precision associated
-   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
-   * If no real root is found the boolean hasArealRoot is set to false and the real part of
-   * the root with smallest absolute imaginary part is returned instead.
-   *
-   * \param[out] hasArealRoot : boolean true if a real root is found according to the
-   *  absImaginaryThreshold criterion, false otherwise.
-   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
-   *  whether or not a root is real.
-   */
-  inline const RealScalar& greatestRealRoot(
-      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    std::greater<RealScalar> greater;
-    return selectRealRoot_withRespectToRealPart(greater, hasArealRoot, absImaginaryThreshold);
-  }
-
-  /**
-   * \returns the real root with smallest value.
-   * A real root is defined as the real part of a complex root with absolute imaginary
-   * part smallest than absImaginaryThreshold.
-   * absImaginaryThreshold takes the dummy_precision associated
-   * with the Scalar_ template parameter of the PolynomialSolver class as the default value.
-   * If no real root is found the boolean hasArealRoot is set to false and the real part of
-   * the root with smallest absolute imaginary part is returned instead.
-   *
-   * \param[out] hasArealRoot : boolean true if a real root is found according to the
-   *  absImaginaryThreshold criterion, false otherwise.
-   * \param[in] absImaginaryThreshold : threshold on the absolute imaginary part to decide
-   *  whether or not a root is real.
-   */
-  inline const RealScalar& smallestRealRoot(
-      bool& hasArealRoot, const RealScalar& absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()) const {
-    std::less<RealScalar> less;
-    return selectRealRoot_withRespectToRealPart(less, hasArealRoot, absImaginaryThreshold);
-  }
-
- protected:
-  RootsType m_roots;
-};
-
-#define EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES(BASE) \
-  typedef typename BASE::Scalar Scalar;                    \
-  typedef typename BASE::RealScalar RealScalar;            \
-  typedef typename BASE::RootType RootType;                \
-  typedef typename BASE::RootsType RootsType;
-
-/** \ingroup Polynomials_Module
- *
- * \class PolynomialSolver
- *
- * \brief A polynomial solver
- *
- * Computes the complex roots of a real polynomial.
- *
- * \param Scalar_ the scalar type, i.e., the type of the polynomial coefficients
- * \param Deg_ the degree of the polynomial, can be a compile time value or Dynamic.
- *             Notice that the number of polynomial coefficients is Deg_+1.
- *
- * This class implements a polynomial solver and provides convenient methods such as
- * - real roots,
- * - greatest, smallest complex roots,
- * - real roots with greatest, smallest absolute real value.
- * - greatest, smallest real roots.
- *
- * WARNING: this polynomial solver is experimental, part of the unsupported Eigen modules.
- *
- *
- * Currently a QR algorithm is used to compute the eigenvalues of the companion matrix of
- * the polynomial to compute its roots.
- * This supposes that the complex moduli of the roots are all distinct: e.g. there should
- * be no multiple roots or conjugate roots for instance.
- * With 32bit (float) floating types this problem shows up frequently.
- * However, almost always, correct accuracy is reached even in these cases for 64bit
- * (double) floating types and small polynomial degree (<20).
- */
-template <typename Scalar_, int Deg_>
-class PolynomialSolver : public PolynomialSolverBase<Scalar_, Deg_> {
- public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar_, Deg_ == Dynamic ? Dynamic : Deg_)
-
-  typedef PolynomialSolverBase<Scalar_, Deg_> PS_Base;
-  EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES(PS_Base)
-
-  typedef Matrix<Scalar, Deg_, Deg_> CompanionMatrixType;
-  typedef std::conditional_t<NumTraits<Scalar>::IsComplex, ComplexEigenSolver<CompanionMatrixType>,
-                             EigenSolver<CompanionMatrixType> >
-      EigenSolverType;
-  typedef internal::make_complex_t<Scalar_> ComplexScalar;
-
- public:
-  /** Computes the complex roots of a new polynomial. */
-  template <typename OtherPolynomial>
-  void compute(const OtherPolynomial& poly) {
-    eigen_assert(Scalar(0) != poly[poly.size() - 1]);
-    eigen_assert(poly.size() > 1);
-    if (poly.size() > 2) {
-      internal::companion<Scalar, Deg_> companion(poly);
-      companion.balance();
-      m_eigenSolver.compute(companion.denseMatrix());
-      eigen_assert(m_eigenSolver.info() == Eigen::Success);
-      m_roots = m_eigenSolver.eigenvalues();
-      // cleanup noise in imaginary part of real roots:
-      // if the imaginary part is rather small compared to the real part
-      // and that cancelling the imaginary part yield a smaller evaluation,
-      // then it's safe to keep the real part only.
-      RealScalar coarse_prec = RealScalar(std::pow(4, poly.size() + 1)) * NumTraits<RealScalar>::epsilon();
-      for (Index i = 0; i < m_roots.size(); ++i) {
-        if (internal::isMuchSmallerThan(numext::abs(numext::imag(m_roots[i])), numext::abs(numext::real(m_roots[i])),
-                                        coarse_prec)) {
-          ComplexScalar as_real_root = ComplexScalar(numext::real(m_roots[i]));
-          if (numext::abs(poly_eval(poly, as_real_root)) <= numext::abs(poly_eval(poly, m_roots[i]))) {
-            m_roots[i] = as_real_root;
-          }
-        }
-      }
-    } else if (poly.size() == 2) {
-      m_roots.resize(1);
-      m_roots[0] = -poly[0] / poly[1];
-    }
-  }
-
- public:
-  template <typename OtherPolynomial>
-  inline PolynomialSolver(const OtherPolynomial& poly) {
-    compute(poly);
-  }
-
-  inline PolynomialSolver() {}
-
- protected:
-  using PS_Base::m_roots;
-  EigenSolverType m_eigenSolver;
-};
-
-template <typename Scalar_>
-class PolynomialSolver<Scalar_, 1> : public PolynomialSolverBase<Scalar_, 1> {
- public:
-  typedef PolynomialSolverBase<Scalar_, 1> PS_Base;
-  EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES(PS_Base)
-
- public:
-  /** Computes the complex roots of a new polynomial. */
-  template <typename OtherPolynomial>
-  void compute(const OtherPolynomial& poly) {
-    eigen_assert(poly.size() == 2);
-    eigen_assert(Scalar(0) != poly[1]);
-    m_roots[0] = -poly[0] / poly[1];
-  }
-
- public:
-  template <typename OtherPolynomial>
-  inline PolynomialSolver(const OtherPolynomial& poly) {
-    compute(poly);
-  }
-
-  inline PolynomialSolver() {}
-
- protected:
-  using PS_Base::m_roots;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_POLYNOMIAL_SOLVER_H
diff --git a/unsupported/Eigen/src/Polynomials/PolynomialUtils.h b/unsupported/Eigen/src/Polynomials/PolynomialUtils.h
deleted file mode 100644
index 342ca9a..0000000
--- a/unsupported/Eigen/src/Polynomials/PolynomialUtils.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_POLYNOMIAL_UTILS_H
-#define EIGEN_POLYNOMIAL_UTILS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \ingroup Polynomials_Module
- * \returns the evaluation of the polynomial at x using Horner algorithm.
- *
- * \param[in] poly : the vector of coefficients of the polynomial ordered
- *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
- *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
- * \param[in] x : the value to evaluate the polynomial at.
- *
- * \note for stability:
- *   \f$ |x| \le 1 \f$
- */
-template <typename Polynomials, typename T>
-inline T poly_eval_horner(const Polynomials& poly, const T& x) {
-  T val = poly[poly.size() - 1];
-  for (DenseIndex i = poly.size() - 2; i >= 0; --i) {
-    val = val * x + poly[i];
-  }
-  return val;
-}
-
-/** \ingroup Polynomials_Module
- * \returns the evaluation of the polynomial at x using stabilized Horner algorithm.
- *
- * \param[in] poly : the vector of coefficients of the polynomial ordered
- *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
- *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
- * \param[in] x : the value to evaluate the polynomial at.
- */
-template <typename Polynomials, typename T>
-inline T poly_eval(const Polynomials& poly, const T& x) {
-  typedef typename NumTraits<T>::Real Real;
-
-  if (numext::abs2(x) <= Real(1)) {
-    return poly_eval_horner(poly, x);
-  } else {
-    T val = poly[0];
-    T inv_x = T(1) / x;
-    for (DenseIndex i = 1; i < poly.size(); ++i) {
-      val = val * inv_x + poly[i];
-    }
-
-    return numext::pow(x, (T)(poly.size() - 1)) * val;
-  }
-}
-
-/** \ingroup Polynomials_Module
- * \returns a maximum bound for the absolute value of any root of the polynomial.
- *
- * \param[in] poly : the vector of coefficients of the polynomial ordered
- *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
- *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
- *
- *  \pre
- *   the leading coefficient of the input polynomial poly must be non zero
- */
-template <typename Polynomial>
-inline typename NumTraits<typename Polynomial::Scalar>::Real cauchy_max_bound(const Polynomial& poly) {
-  using std::abs;
-  typedef typename Polynomial::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real Real;
-
-  eigen_assert(Scalar(0) != poly[poly.size() - 1]);
-  const Scalar inv_leading_coeff = Scalar(1) / poly[poly.size() - 1];
-  Real cb(0);
-
-  for (DenseIndex i = 0; i < poly.size() - 1; ++i) {
-    cb += abs(poly[i] * inv_leading_coeff);
-  }
-  return cb + Real(1);
-}
-
-/** \ingroup Polynomials_Module
- * \returns a minimum bound for the absolute value of any non zero root of the polynomial.
- * \param[in] poly : the vector of coefficients of the polynomial ordered
- *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
- *  e.g. \f$ 1 + 3x^2 \f$ is stored as a vector \f$ [ 1, 0, 3 ] \f$.
- */
-template <typename Polynomial>
-inline typename NumTraits<typename Polynomial::Scalar>::Real cauchy_min_bound(const Polynomial& poly) {
-  using std::abs;
-  typedef typename Polynomial::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real Real;
-
-  DenseIndex i = 0;
-  while (i < poly.size() - 1 && Scalar(0) == poly(i)) {
-    ++i;
-  }
-  if (poly.size() - 1 == i) {
-    return Real(1);
-  }
-
-  const Scalar inv_min_coeff = Scalar(1) / poly[i];
-  Real cb(1);
-  for (DenseIndex j = i + 1; j < poly.size(); ++j) {
-    cb += abs(poly[j] * inv_min_coeff);
-  }
-  return Real(1) / cb;
-}
-
-/** \ingroup Polynomials_Module
- * Given the roots of a polynomial compute the coefficients in the
- * monomial basis of the monic polynomial with same roots and minimal degree.
- * If RootVector is a vector of complexes, Polynomial should also be a vector
- * of complexes.
- * \param[in] rv : a vector containing the roots of a polynomial.
- * \param[out] poly : the vector of coefficients of the polynomial ordered
- *  by degrees i.e. poly[i] is the coefficient of degree i of the polynomial
- *  e.g. \f$ 3 + x^2 \f$ is stored as a vector \f$ [ 3, 0, 1 ] \f$.
- */
-template <typename RootVector, typename Polynomial>
-void roots_to_monicPolynomial(const RootVector& rv, Polynomial& poly) {
-  typedef typename Polynomial::Scalar Scalar;
-
-  poly.setZero(rv.size() + 1);
-  poly[0] = -rv[0];
-  poly[1] = Scalar(1);
-  for (DenseIndex i = 1; i < rv.size(); ++i) {
-    for (DenseIndex j = i + 1; j > 0; --j) {
-      poly[j] = poly[j - 1] - rv[i] * poly[j];
-    }
-    poly[0] = -rv[i] * poly[0];
-  }
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_POLYNOMIAL_UTILS_H
diff --git a/unsupported/Eigen/src/SparseExtra/BlockSparseMatrix.h b/unsupported/Eigen/src/SparseExtra/BlockSparseMatrix.h
deleted file mode 100644
index a7958af..0000000
--- a/unsupported/Eigen/src/SparseExtra/BlockSparseMatrix.h
+++ /dev/null
@@ -1,931 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Desire Nuentsa <desire.nuentsa_wakam@inria.fr>
-// Copyright (C) 2013 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSEBLOCKMATRIX_H
-#define EIGEN_SPARSEBLOCKMATRIX_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-/** \ingroup SparseCore_Module
- *
- * \class BlockSparseMatrix
- *
- * \brief A versatile sparse matrix representation where each element is a block
- *
- * This class provides routines to manipulate block sparse matrices stored in a
- * BSR-like representation. There are two main types :
- *
- * 1. All blocks have the same number of rows and columns, called block size
- * in the following. In this case, if this block size is known at compile time,
- * it can be given as a template parameter like
- * \code
- * BlockSparseMatrix<Scalar, 3, ColMajor> bmat(b_rows, b_cols);
- * \endcode
- * Here, bmat is a b_rows x b_cols block sparse matrix
- * where each coefficient is a 3x3 dense matrix.
- * If the block size is fixed but will be given at runtime,
- * \code
- * BlockSparseMatrix<Scalar, Dynamic, ColMajor> bmat(b_rows, b_cols);
- * bmat.setBlockSize(block_size);
- * \endcode
- *
- * 2. The second case is for variable-block sparse matrices.
- * Here each block has its own dimensions. The only restriction is that all the blocks
- * in a row (resp. a column) should have the same number of rows (resp. of columns).
- * It is thus required in this case to describe the layout of the matrix by calling
- * setBlockLayout(rowBlocks, colBlocks).
- *
- * In any of the previous case, the matrix can be filled by calling setFromTriplets().
- * A regular sparse matrix can be converted to a block sparse matrix and vice versa.
- * It is obviously required to describe the block layout beforehand by calling either
- * setBlockSize() for fixed-size blocks or setBlockLayout for variable-size blocks.
- *
- * \tparam Scalar_ The Scalar type
- * \tparam _BlockAtCompileTime The block layout option. It takes the following values
- * Dynamic : block size known at runtime
- * a numeric number : fixed-size block known at compile time
- */
-template <typename Scalar_, int _BlockAtCompileTime = Dynamic, int Options_ = ColMajor, typename StorageIndex_ = int>
-class BlockSparseMatrix;
-
-template <typename BlockSparseMatrixT>
-class BlockSparseMatrixView;
-
-namespace internal {
-template <typename Scalar_, int _BlockAtCompileTime, int Options_, typename Index_>
-struct traits<BlockSparseMatrix<Scalar_, _BlockAtCompileTime, Options_, Index_> > {
-  typedef Scalar_ Scalar;
-  typedef Index_ Index;
-  typedef Sparse StorageKind;  // FIXME: determine where StorageKind is used.
-  typedef MatrixXpr XprKind;
-  enum {
-    RowsAtCompileTime = Dynamic,
-    ColsAtCompileTime = Dynamic,
-    MaxRowsAtCompileTime = Dynamic,
-    MaxColsAtCompileTime = Dynamic,
-    BlockSize = _BlockAtCompileTime,
-    Flags = Options_ | NestByRefBit | LvalueBit,
-    CoeffReadCost = NumTraits<Scalar>::ReadCost,
-    SupportedAccessPatterns = InnerRandomAccessPattern
-  };
-};
-template <typename BlockSparseMatrixT>
-struct traits<BlockSparseMatrixView<BlockSparseMatrixT> > {
-  typedef Ref<
-      Matrix<typename BlockSparseMatrixT::Scalar, BlockSparseMatrixT::BlockSize, BlockSparseMatrixT::BlockSize> >
-      Scalar;
-  typedef Ref<
-      Matrix<typename BlockSparseMatrixT::RealScalar, BlockSparseMatrixT::BlockSize, BlockSparseMatrixT::BlockSize> >
-      RealScalar;
-};
-
-// Function object to sort a triplet list
-template <typename Iterator, bool IsColMajor>
-struct TripletComp {
-  typedef typename Iterator::value_type Triplet;
-  bool operator()(const Triplet& a, const Triplet& b) {
-    if (IsColMajor)
-      return ((a.col() == b.col() && a.row() < b.row()) || (a.col() < b.col()));
-    else
-      return ((a.row() == b.row() && a.col() < b.col()) || (a.row() < b.row()));
-  }
-};
-}  // end namespace internal
-
-/* Proxy to view the block sparse matrix as a regular sparse matrix */
-template <typename BlockSparseMatrixT>
-class BlockSparseMatrixView : public SparseMatrixBase<BlockSparseMatrixT> {
- public:
-  typedef Ref<typename BlockSparseMatrixT::BlockScalar> Scalar;
-  typedef Ref<typename BlockSparseMatrixT::BlockRealScalar> RealScalar;
-  typedef typename BlockSparseMatrixT::Index Index;
-  typedef BlockSparseMatrixT Nested;
-  enum {
-    Flags = BlockSparseMatrixT::Options,
-    Options = BlockSparseMatrixT::Options,
-    RowsAtCompileTime = BlockSparseMatrixT::RowsAtCompileTime,
-    ColsAtCompileTime = BlockSparseMatrixT::ColsAtCompileTime,
-    MaxColsAtCompileTime = BlockSparseMatrixT::MaxColsAtCompileTime,
-    MaxRowsAtCompileTime = BlockSparseMatrixT::MaxRowsAtCompileTime
-  };
-
- public:
-  BlockSparseMatrixView(const BlockSparseMatrixT& spblockmat) : m_spblockmat(spblockmat) {}
-
-  Index outerSize() const { return (Flags & RowMajorBit) == 1 ? this->rows() : this->cols(); }
-  Index cols() const { return m_spblockmat.blockCols(); }
-  Index rows() const { return m_spblockmat.blockRows(); }
-  Scalar coeff(Index row, Index col) { return m_spblockmat.coeff(row, col); }
-  Scalar coeffRef(Index row, Index col) { return m_spblockmat.coeffRef(row, col); }
-  // Wrapper to iterate over all blocks
-  class InnerIterator : public BlockSparseMatrixT::BlockInnerIterator {
-   public:
-    InnerIterator(const BlockSparseMatrixView& mat, Index outer)
-        : BlockSparseMatrixT::BlockInnerIterator(mat.m_spblockmat, outer) {}
-  };
-
- protected:
-  const BlockSparseMatrixT& m_spblockmat;
-};
-
-// Proxy to view a regular vector as a block vector
-template <typename BlockSparseMatrixT, typename VectorType>
-class BlockVectorView {
- public:
-  enum {
-    BlockSize = BlockSparseMatrixT::BlockSize,
-    ColsAtCompileTime = VectorType::ColsAtCompileTime,
-    RowsAtCompileTime = VectorType::RowsAtCompileTime,
-    Flags = VectorType::Flags
-  };
-  typedef Ref<const Matrix<typename BlockSparseMatrixT::Scalar, (RowsAtCompileTime == 1) ? 1 : BlockSize,
-                           (ColsAtCompileTime == 1) ? 1 : BlockSize> >
-      Scalar;
-  typedef typename BlockSparseMatrixT::Index Index;
-
- public:
-  BlockVectorView(const BlockSparseMatrixT& spblockmat, const VectorType& vec) : m_spblockmat(spblockmat), m_vec(vec) {}
-  inline Index cols() const { return m_vec.cols(); }
-  inline Index size() const { return m_spblockmat.blockRows(); }
-  inline Scalar coeff(Index bi) const {
-    Index startRow = m_spblockmat.blockRowsIndex(bi);
-    Index rowSize = m_spblockmat.blockRowsIndex(bi + 1) - startRow;
-    return m_vec.middleRows(startRow, rowSize);
-  }
-  inline Scalar coeff(Index bi, Index j) const {
-    Index startRow = m_spblockmat.blockRowsIndex(bi);
-    Index rowSize = m_spblockmat.blockRowsIndex(bi + 1) - startRow;
-    return m_vec.block(startRow, j, rowSize, 1);
-  }
-
- protected:
-  const BlockSparseMatrixT& m_spblockmat;
-  const VectorType& m_vec;
-};
-
-template <typename VectorType, typename Index>
-class BlockVectorReturn;
-
-// Proxy to view a regular vector as a block vector
-template <typename BlockSparseMatrixT, typename VectorType>
-class BlockVectorReturn {
- public:
-  enum {
-    ColsAtCompileTime = VectorType::ColsAtCompileTime,
-    RowsAtCompileTime = VectorType::RowsAtCompileTime,
-    Flags = VectorType::Flags
-  };
-  typedef Ref<Matrix<typename VectorType::Scalar, RowsAtCompileTime, ColsAtCompileTime> > Scalar;
-  typedef typename BlockSparseMatrixT::Index Index;
-
- public:
-  BlockVectorReturn(const BlockSparseMatrixT& spblockmat, VectorType& vec) : m_spblockmat(spblockmat), m_vec(vec) {}
-  inline Index size() const { return m_spblockmat.blockRows(); }
-  inline Scalar coeffRef(Index bi) {
-    Index startRow = m_spblockmat.blockRowsIndex(bi);
-    Index rowSize = m_spblockmat.blockRowsIndex(bi + 1) - startRow;
-    return m_vec.middleRows(startRow, rowSize);
-  }
-  inline Scalar coeffRef(Index bi, Index j) {
-    Index startRow = m_spblockmat.blockRowsIndex(bi);
-    Index rowSize = m_spblockmat.blockRowsIndex(bi + 1) - startRow;
-    return m_vec.block(startRow, j, rowSize, 1);
-  }
-
- protected:
-  const BlockSparseMatrixT& m_spblockmat;
-  VectorType& m_vec;
-};
-
-// Block version of the sparse dense product
-template <typename Lhs, typename Rhs>
-class BlockSparseTimeDenseProduct;
-
-namespace internal {
-
-template <typename BlockSparseMatrixT, typename VecType>
-struct traits<BlockSparseTimeDenseProduct<BlockSparseMatrixT, VecType> > {
-  typedef Dense StorageKind;
-  typedef MatrixXpr XprKind;
-  typedef typename BlockSparseMatrixT::Scalar Scalar;
-  typedef typename BlockSparseMatrixT::Index Index;
-  enum {
-    RowsAtCompileTime = Dynamic,
-    ColsAtCompileTime = Dynamic,
-    MaxRowsAtCompileTime = Dynamic,
-    MaxColsAtCompileTime = Dynamic,
-    Flags = 0,
-    CoeffReadCost = internal::traits<BlockSparseMatrixT>::CoeffReadCost
-  };
-};
-}  // end namespace internal
-
-template <typename Lhs, typename Rhs>
-class BlockSparseTimeDenseProduct : public ProductBase<BlockSparseTimeDenseProduct<Lhs, Rhs>, Lhs, Rhs> {
- public:
-  EIGEN_PRODUCT_PUBLIC_INTERFACE(BlockSparseTimeDenseProduct)
-
-  BlockSparseTimeDenseProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs, rhs) {}
-
-  template <typename Dest>
-  void scaleAndAddTo(Dest& dest, const typename Rhs::Scalar& alpha) const {
-    BlockVectorReturn<Lhs, Dest> tmpDest(m_lhs, dest);
-    internal::sparse_time_dense_product(BlockSparseMatrixView<Lhs>(m_lhs), BlockVectorView<Lhs, Rhs>(m_lhs, m_rhs),
-                                        tmpDest, alpha);
-  }
-
- private:
-  BlockSparseTimeDenseProduct& operator=(const BlockSparseTimeDenseProduct&);
-};
-
-template <typename Scalar_, int _BlockAtCompileTime, int Options_, typename StorageIndex_>
-class BlockSparseMatrix
-    : public SparseMatrixBase<BlockSparseMatrix<Scalar_, _BlockAtCompileTime, Options_, StorageIndex_> > {
- public:
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef StorageIndex_ StorageIndex;
-  typedef
-      typename internal::ref_selector<BlockSparseMatrix<Scalar_, _BlockAtCompileTime, Options_, StorageIndex_> >::type
-          Nested;
-
-  enum {
-    Options = Options_,
-    Flags = Options,
-    BlockSize = _BlockAtCompileTime,
-    RowsAtCompileTime = Dynamic,
-    ColsAtCompileTime = Dynamic,
-    MaxRowsAtCompileTime = Dynamic,
-    MaxColsAtCompileTime = Dynamic,
-    IsVectorAtCompileTime = 0,
-    IsColMajor = Flags & RowMajorBit ? 0 : 1
-  };
-  typedef Matrix<Scalar, _BlockAtCompileTime, _BlockAtCompileTime, IsColMajor ? ColMajor : RowMajor> BlockScalar;
-  typedef Matrix<RealScalar, _BlockAtCompileTime, _BlockAtCompileTime, IsColMajor ? ColMajor : RowMajor>
-      BlockRealScalar;
-  typedef std::conditional_t<_BlockAtCompileTime == Dynamic, Scalar, BlockScalar> BlockScalarReturnType;
-  typedef BlockSparseMatrix<Scalar, BlockSize, IsColMajor ? ColMajor : RowMajor, StorageIndex> PlainObject;
-
- public:
-  // Default constructor
-  BlockSparseMatrix()
-      : m_innerBSize(0),
-        m_outerBSize(0),
-        m_innerOffset(0),
-        m_outerOffset(0),
-        m_nonzerosblocks(0),
-        m_values(0),
-        m_blockPtr(0),
-        m_indices(0),
-        m_outerIndex(0),
-        m_blockSize(BlockSize) {}
-
-  /**
-   * \brief Construct and resize
-   *
-   */
-  BlockSparseMatrix(Index brow, Index bcol)
-      : m_innerBSize(IsColMajor ? brow : bcol),
-        m_outerBSize(IsColMajor ? bcol : brow),
-        m_innerOffset(0),
-        m_outerOffset(0),
-        m_nonzerosblocks(0),
-        m_values(0),
-        m_blockPtr(0),
-        m_indices(0),
-        m_outerIndex(0),
-        m_blockSize(BlockSize) {}
-
-  /**
-   * \brief Copy-constructor
-   */
-  BlockSparseMatrix(const BlockSparseMatrix& other)
-      : m_innerBSize(other.m_innerBSize),
-        m_outerBSize(other.m_outerBSize),
-        m_nonzerosblocks(other.m_nonzerosblocks),
-        m_nonzeros(other.m_nonzeros),
-        m_blockPtr(0),
-        m_blockSize(other.m_blockSize) {
-    // TODO: decide whether to allow copying between variable-size and fixed-size blocks.
-    eigen_assert(m_blockSize == BlockSize && " CAN NOT COPY BETWEEN FIXED-SIZE AND VARIABLE-SIZE BLOCKS");
-
-    std::copy(other.m_innerOffset, other.m_innerOffset + m_innerBSize + 1, m_innerOffset);
-    std::copy(other.m_outerOffset, other.m_outerOffset + m_outerBSize + 1, m_outerOffset);
-    std::copy(other.m_values, other.m_values + m_nonzeros, m_values);
-
-    if (m_blockSize != Dynamic) std::copy(other.m_blockPtr, other.m_blockPtr + m_nonzerosblocks, m_blockPtr);
-
-    std::copy(other.m_indices, other.m_indices + m_nonzerosblocks, m_indices);
-    std::copy(other.m_outerIndex, other.m_outerIndex + m_outerBSize, m_outerIndex);
-  }
-
-  friend void swap(BlockSparseMatrix& first, BlockSparseMatrix& second) {
-    std::swap(first.m_innerBSize, second.m_innerBSize);
-    std::swap(first.m_outerBSize, second.m_outerBSize);
-    std::swap(first.m_innerOffset, second.m_innerOffset);
-    std::swap(first.m_outerOffset, second.m_outerOffset);
-    std::swap(first.m_nonzerosblocks, second.m_nonzerosblocks);
-    std::swap(first.m_nonzeros, second.m_nonzeros);
-    std::swap(first.m_values, second.m_values);
-    std::swap(first.m_blockPtr, second.m_blockPtr);
-    std::swap(first.m_indices, second.m_indices);
-    std::swap(first.m_outerIndex, second.m_outerIndex);
-    std::swap(first.m_BlockSize, second.m_blockSize);
-  }
-
-  BlockSparseMatrix& operator=(BlockSparseMatrix other) {
-    // Copy-and-swap paradigm ... avoid leaked data if thrown
-    swap(*this, other);
-    return *this;
-  }
-
-  // Destructor
-  ~BlockSparseMatrix() {
-    delete[] m_outerIndex;
-    delete[] m_innerOffset;
-    delete[] m_outerOffset;
-    delete[] m_indices;
-    delete[] m_blockPtr;
-    delete[] m_values;
-  }
-
-  /**
-   * \brief Constructor from a sparse matrix
-   *
-   */
-  template <typename MatrixType>
-  inline BlockSparseMatrix(const MatrixType& spmat) : m_blockSize(BlockSize) {
-    EIGEN_STATIC_ASSERT((m_blockSize != Dynamic), THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE);
-
-    *this = spmat;
-  }
-
-  /**
-   * \brief Assignment from a sparse matrix with the same storage order
-   *
-   * Convert from a sparse matrix to block sparse matrix.
-   * \warning Before calling this function, tt is necessary to call
-   * either setBlockLayout() (matrices with variable-size blocks)
-   * or setBlockSize() (for fixed-size blocks).
-   */
-  template <typename MatrixType>
-  inline BlockSparseMatrix& operator=(const MatrixType& spmat) {
-    eigen_assert((m_innerBSize != 0 && m_outerBSize != 0) &&
-                 "Trying to assign to a zero-size matrix, call resize() first");
-    eigen_assert(((MatrixType::Options & RowMajorBit) != IsColMajor) && "Wrong storage order");
-    typedef SparseMatrix<bool, MatrixType::Options, typename MatrixType::Index> MatrixPatternType;
-    MatrixPatternType blockPattern(blockRows(), blockCols());
-    m_nonzeros = 0;
-
-    // First, compute the number of nonzero blocks and their locations
-    for (StorageIndex bj = 0; bj < m_outerBSize; ++bj) {
-      // Browse each outer block and compute the structure
-      std::vector<bool> nzblocksFlag(m_innerBSize, false);  // Record the existing blocks
-      blockPattern.startVec(bj);
-      for (StorageIndex j = blockOuterIndex(bj); j < blockOuterIndex(bj + 1); ++j) {
-        typename MatrixType::InnerIterator it_spmat(spmat, j);
-        for (; it_spmat; ++it_spmat) {
-          StorageIndex bi = innerToBlock(it_spmat.index());  // Index of the current nonzero block
-          if (!nzblocksFlag[bi]) {
-            // Save the index of this nonzero block
-            nzblocksFlag[bi] = true;
-            blockPattern.insertBackByOuterInnerUnordered(bj, bi) = true;
-            // Compute the total number of nonzeros (including explicit zeros in blocks)
-            m_nonzeros += blockOuterSize(bj) * blockInnerSize(bi);
-          }
-        }
-      }  // end current outer block
-    }
-    blockPattern.finalize();
-
-    // Allocate the internal arrays
-    setBlockStructure(blockPattern);
-
-    for (StorageIndex nz = 0; nz < m_nonzeros; ++nz) m_values[nz] = Scalar(0);
-    for (StorageIndex bj = 0; bj < m_outerBSize; ++bj) {
-      // Now copy the values
-      for (StorageIndex j = blockOuterIndex(bj); j < blockOuterIndex(bj + 1); ++j) {
-        // Browse the outer block column by column (for column-major matrices)
-        typename MatrixType::InnerIterator it_spmat(spmat, j);
-        for (; it_spmat; ++it_spmat) {
-          StorageIndex idx = 0;                              // Position of this block in the column block
-          StorageIndex bi = innerToBlock(it_spmat.index());  // Index of the current nonzero block
-          // Go to the inner block where this element belongs to
-          while (bi > m_indices[m_outerIndex[bj] + idx]) ++idx;  // Not expensive for ordered blocks
-          StorageIndex idxVal;  // Get the right position in the array of values for this element
-          if (m_blockSize == Dynamic) {
-            // Offset from all blocks before ...
-            idxVal = m_blockPtr[m_outerIndex[bj] + idx];
-            // ... and offset inside the block
-            idxVal += (j - blockOuterIndex(bj)) * blockOuterSize(bj) + it_spmat.index() - m_innerOffset[bi];
-          } else {
-            // All blocks before
-            idxVal = (m_outerIndex[bj] + idx) * m_blockSize * m_blockSize;
-            // inside the block
-            idxVal += (j - blockOuterIndex(bj)) * m_blockSize + (it_spmat.index() % m_blockSize);
-          }
-          // Insert the value
-          m_values[idxVal] = it_spmat.value();
-        }  // end of this column
-      }    // end of this block
-    }      // end of this outer block
-
-    return *this;
-  }
-
-  /**
-   * \brief Set the nonzero block pattern of the matrix
-   *
-   * Given a sparse matrix describing the nonzero block pattern,
-   * this function prepares the internal pointers for values.
-   * After calling this function, any *nonzero* block (bi, bj) can be set
-   * with a simple call to coeffRef(bi,bj).
-   *
-   *
-   * \warning Before calling this function, tt is necessary to call
-   * either setBlockLayout() (matrices with variable-size blocks)
-   * or setBlockSize() (for fixed-size blocks).
-   *
-   * \param blockPattern Sparse matrix of boolean elements describing the block structure
-   *
-   * \sa setBlockLayout() \sa setBlockSize()
-   */
-  template <typename MatrixType>
-  void setBlockStructure(const MatrixType& blockPattern) {
-    resize(blockPattern.rows(), blockPattern.cols());
-    reserve(blockPattern.nonZeros());
-
-    // Browse the block pattern and set up the various pointers
-    m_outerIndex[0] = 0;
-    if (m_blockSize == Dynamic) m_blockPtr[0] = 0;
-    for (StorageIndex nz = 0; nz < m_nonzeros; ++nz) m_values[nz] = Scalar(0);
-    for (StorageIndex bj = 0; bj < m_outerBSize; ++bj) {
-      // Browse each outer block
-
-      // First, copy and save the indices of nonzero blocks
-      // FIXME : find a way to avoid this ...
-      std::vector<int> nzBlockIdx;
-      typename MatrixType::InnerIterator it(blockPattern, bj);
-      for (; it; ++it) {
-        nzBlockIdx.push_back(it.index());
-      }
-      std::sort(nzBlockIdx.begin(), nzBlockIdx.end());
-
-      // Now, fill block indices and (eventually) pointers to blocks
-      for (StorageIndex idx = 0; idx < nzBlockIdx.size(); ++idx) {
-        StorageIndex offset = m_outerIndex[bj] + idx;  // offset in m_indices
-        m_indices[offset] = nzBlockIdx[idx];
-        if (m_blockSize == Dynamic)
-          m_blockPtr[offset] = m_blockPtr[offset - 1] + blockInnerSize(nzBlockIdx[idx]) * blockOuterSize(bj);
-        // There is no blockPtr for fixed-size blocks; not needed.
-      }
-      // Save the pointer to the next outer block
-      m_outerIndex[bj + 1] = m_outerIndex[bj] + nzBlockIdx.size();
-    }
-  }
-
-  /**
-   * \brief Set the number of rows and columns blocks
-   */
-  inline void resize(Index brow, Index bcol) {
-    m_innerBSize = IsColMajor ? brow : bcol;
-    m_outerBSize = IsColMajor ? bcol : brow;
-  }
-
-  /**
-   * \brief set the block size at runtime for fixed-size block layout
-   *
-   * Call this only for fixed-size blocks
-   */
-  inline void setBlockSize(Index blockSize) { m_blockSize = blockSize; }
-
-  /**
-   * \brief Set the row and column block layouts,
-   *
-   * This function set the size of each row and column block.
-   * So this function should be used only for blocks with variable size.
-   * \param rowBlocks : Number of rows per row block
-   * \param colBlocks : Number of columns per column block
-   * \sa resize(), setBlockSize()
-   */
-  inline void setBlockLayout(const VectorXi& rowBlocks, const VectorXi& colBlocks) {
-    const VectorXi& innerBlocks = IsColMajor ? rowBlocks : colBlocks;
-    const VectorXi& outerBlocks = IsColMajor ? colBlocks : rowBlocks;
-    eigen_assert(m_innerBSize == innerBlocks.size() && "CHECK THE NUMBER OF ROW OR COLUMN BLOCKS");
-    eigen_assert(m_outerBSize == outerBlocks.size() && "CHECK THE NUMBER OF ROW OR COLUMN BLOCKS");
-    m_outerBSize = outerBlocks.size();
-    //  starting index of blocks... cumulative sums
-    m_innerOffset = new StorageIndex[m_innerBSize + 1];
-    m_outerOffset = new StorageIndex[m_outerBSize + 1];
-    m_innerOffset[0] = 0;
-    m_outerOffset[0] = 0;
-    std::partial_sum(&innerBlocks[0], &innerBlocks[m_innerBSize - 1] + 1, &m_innerOffset[1]);
-    std::partial_sum(&outerBlocks[0], &outerBlocks[m_outerBSize - 1] + 1, &m_outerOffset[1]);
-
-    // Compute the total number of nonzeros
-    m_nonzeros = 0;
-    for (StorageIndex bj = 0; bj < m_outerBSize; ++bj)
-      for (StorageIndex bi = 0; bi < m_innerBSize; ++bi) m_nonzeros += outerBlocks[bj] * innerBlocks[bi];
-  }
-
-  /**
-   * \brief Allocate the internal array of pointers to blocks and their inner indices
-   *
-   * \note For fixed-size blocks, call setBlockSize() to set the block.
-   * And For variable-size blocks, call setBlockLayout() before using this function
-   *
-   * \param nonzerosblocks Number of nonzero blocks. The total number of nonzeros is
-   * is computed in setBlockLayout() for variable-size blocks
-   * \sa setBlockSize()
-   */
-  inline void reserve(const Index nonzerosblocks) {
-    eigen_assert((m_innerBSize != 0 && m_outerBSize != 0) &&
-                 "TRYING TO RESERVE ZERO-SIZE MATRICES, CALL resize() first");
-
-    // FIXME: Should free if already allocated.
-    m_outerIndex = new StorageIndex[m_outerBSize + 1];
-
-    m_nonzerosblocks = nonzerosblocks;
-    if (m_blockSize != Dynamic) {
-      m_nonzeros = nonzerosblocks * (m_blockSize * m_blockSize);
-      m_blockPtr = 0;
-    } else {
-      // m_nonzeros  is already computed in setBlockLayout()
-      m_blockPtr = new StorageIndex[m_nonzerosblocks + 1];
-    }
-    m_indices = new StorageIndex[m_nonzerosblocks + 1];
-    m_values = new Scalar[m_nonzeros];
-  }
-
-  /**
-   * \brief Fill values in a matrix  from a triplet list.
-   *
-   * Each triplet item has a block stored in an Eigen dense matrix.
-   * The InputIterator class should provide the functions row(), col() and value()
-   *
-   * \note For fixed-size blocks, call setBlockSize() before this function.
-   *
-   * FIXME: Do not accept duplicates.
-   */
-  template <typename InputIterator>
-  void setFromTriplets(const InputIterator& begin, const InputIterator& end) {
-    eigen_assert((m_innerBSize != 0 && m_outerBSize != 0) && "ZERO BLOCKS, PLEASE CALL resize() before");
-
-    /* First, sort the triplet list
-     * FIXME: This can be unnecessarily expensive since only the inner indices have to be sorted.
-     * The best approach is like in SparseMatrix::setFromTriplets()
-     */
-    internal::TripletComp<InputIterator, IsColMajor> tripletcomp;
-    std::sort(begin, end, tripletcomp);
-
-    /* Count the number of rows and column blocks,
-     * and the number of nonzero blocks per outer dimension
-     */
-    VectorXi rowBlocks(m_innerBSize);  // Size of each block row
-    VectorXi colBlocks(m_outerBSize);  // Size of each block column
-    rowBlocks.setZero();
-    colBlocks.setZero();
-    VectorXi nzblock_outer(m_outerBSize);  // Number of nz blocks per outer vector
-    VectorXi nz_outer(m_outerBSize);       // Number of nz per outer vector...for variable-size blocks
-    nzblock_outer.setZero();
-    nz_outer.setZero();
-    for (InputIterator it(begin); it != end; ++it) {
-      eigen_assert(it->row() >= 0 && it->row() < this->blockRows() && it->col() >= 0 && it->col() < this->blockCols());
-      eigen_assert((it->value().rows() == it->value().cols() && (it->value().rows() == m_blockSize)) ||
-                   (m_blockSize == Dynamic));
-
-      if (m_blockSize == Dynamic) {
-        eigen_assert((rowBlocks[it->row()] == 0 || rowBlocks[it->row()] == it->value().rows()) &&
-                     "NON CORRESPONDING SIZES FOR ROW BLOCKS");
-        eigen_assert((colBlocks[it->col()] == 0 || colBlocks[it->col()] == it->value().cols()) &&
-                     "NON CORRESPONDING SIZES FOR COLUMN BLOCKS");
-        rowBlocks[it->row()] = it->value().rows();
-        colBlocks[it->col()] = it->value().cols();
-      }
-      nz_outer(IsColMajor ? it->col() : it->row()) += it->value().rows() * it->value().cols();
-      nzblock_outer(IsColMajor ? it->col() : it->row())++;
-    }
-    // Allocate member arrays
-    if (m_blockSize == Dynamic) setBlockLayout(rowBlocks, colBlocks);
-    StorageIndex nzblocks = nzblock_outer.sum();
-    reserve(nzblocks);
-
-    // Temporary markers
-    VectorXi block_id(m_outerBSize);  // To be used as a block marker during insertion
-
-    // Setup outer index pointers and markers
-    m_outerIndex[0] = 0;
-    if (m_blockSize == Dynamic) m_blockPtr[0] = 0;
-    for (StorageIndex bj = 0; bj < m_outerBSize; ++bj) {
-      m_outerIndex[bj + 1] = m_outerIndex[bj] + nzblock_outer(bj);
-      block_id(bj) = m_outerIndex[bj];
-      if (m_blockSize == Dynamic) {
-        m_blockPtr[m_outerIndex[bj + 1]] = m_blockPtr[m_outerIndex[bj]] + nz_outer(bj);
-      }
-    }
-
-    // Fill the matrix
-    for (InputIterator it(begin); it != end; ++it) {
-      StorageIndex outer = IsColMajor ? it->col() : it->row();
-      StorageIndex inner = IsColMajor ? it->row() : it->col();
-      m_indices[block_id(outer)] = inner;
-      StorageIndex block_size = it->value().rows() * it->value().cols();
-      StorageIndex nz_marker = blockPtr(block_id[outer]);
-      memcpy(&(m_values[nz_marker]), it->value().data(), block_size * sizeof(Scalar));
-      if (m_blockSize == Dynamic) {
-        m_blockPtr[block_id(outer) + 1] = m_blockPtr[block_id(outer)] + block_size;
-      }
-      block_id(outer)++;
-    }
-  }
-
-  /**
-   * \returns the number of rows
-   */
-  inline Index rows() const { return (IsColMajor ? innerSize() : outerSize()); }
-
-  /**
-   * \returns the number of cols
-   */
-  inline Index cols() const { return (IsColMajor ? outerSize() : innerSize()); }
-
-  inline Index innerSize() const {
-    if (m_blockSize == Dynamic)
-      return m_innerOffset[m_innerBSize];
-    else
-      return (m_innerBSize * m_blockSize);
-  }
-
-  inline Index outerSize() const {
-    if (m_blockSize == Dynamic)
-      return m_outerOffset[m_outerBSize];
-    else
-      return (m_outerBSize * m_blockSize);
-  }
-  /** \returns the number of rows grouped by blocks */
-  inline Index blockRows() const { return (IsColMajor ? m_innerBSize : m_outerBSize); }
-  /** \returns the number of columns grouped by blocks */
-  inline Index blockCols() const { return (IsColMajor ? m_outerBSize : m_innerBSize); }
-
-  inline Index outerBlocks() const { return m_outerBSize; }
-  inline Index innerBlocks() const { return m_innerBSize; }
-
-  /** \returns the block index where outer belongs to */
-  inline Index outerToBlock(Index outer) const {
-    eigen_assert(outer < outerSize() && "OUTER INDEX OUT OF BOUNDS");
-
-    if (m_blockSize != Dynamic) return (outer / m_blockSize);  // Integer division
-
-    StorageIndex b_outer = 0;
-    while (m_outerOffset[b_outer] <= outer) ++b_outer;
-    return b_outer - 1;
-  }
-  /** \returns  the block index where inner belongs to */
-  inline Index innerToBlock(Index inner) const {
-    eigen_assert(inner < innerSize() && "OUTER INDEX OUT OF BOUNDS");
-
-    if (m_blockSize != Dynamic) return (inner / m_blockSize);  // Integer division
-
-    StorageIndex b_inner = 0;
-    while (m_innerOffset[b_inner] <= inner) ++b_inner;
-    return b_inner - 1;
-  }
-
-  /**
-   *\returns a reference to the (i,j) block as an Eigen Dense Matrix
-   */
-  Ref<BlockScalar> coeffRef(Index brow, Index bcol) {
-    eigen_assert(brow < blockRows() && "BLOCK ROW INDEX OUT OF BOUNDS");
-    eigen_assert(bcol < blockCols() && "BLOCK nzblocksFlagCOLUMN OUT OF BOUNDS");
-
-    StorageIndex rsize = IsColMajor ? blockInnerSize(brow) : blockOuterSize(bcol);
-    StorageIndex csize = IsColMajor ? blockOuterSize(bcol) : blockInnerSize(brow);
-    StorageIndex inner = IsColMajor ? brow : bcol;
-    StorageIndex outer = IsColMajor ? bcol : brow;
-    StorageIndex offset = m_outerIndex[outer];
-    while (offset < m_outerIndex[outer + 1] && m_indices[offset] != inner) offset++;
-    if (m_indices[offset] == inner) {
-      return Map<BlockScalar>(&(m_values[blockPtr(offset)]), rsize, csize);
-    } else {
-      // FIXME: The block does not exist; insert it.
-      eigen_assert("DYNAMIC INSERTION IS NOT YET SUPPORTED");
-    }
-  }
-
-  /**
-   * \returns the value of the (i,j) block as an Eigen Dense Matrix
-   */
-  Map<const BlockScalar> coeff(Index brow, Index bcol) const {
-    eigen_assert(brow < blockRows() && "BLOCK ROW INDEX OUT OF BOUNDS");
-    eigen_assert(bcol < blockCols() && "BLOCK COLUMN OUT OF BOUNDS");
-
-    StorageIndex rsize = IsColMajor ? blockInnerSize(brow) : blockOuterSize(bcol);
-    StorageIndex csize = IsColMajor ? blockOuterSize(bcol) : blockInnerSize(brow);
-    StorageIndex inner = IsColMajor ? brow : bcol;
-    StorageIndex outer = IsColMajor ? bcol : brow;
-    StorageIndex offset = m_outerIndex[outer];
-    while (offset < m_outerIndex[outer + 1] && m_indices[offset] != inner) offset++;
-    if (m_indices[offset] == inner) {
-      return Map<const BlockScalar>(&(m_values[blockPtr(offset)]), rsize, csize);
-    } else
-      eigen_assert("NOT YET SUPPORTED");
-  }
-
-  // Block Matrix times vector product
-  template <typename VecType>
-  BlockSparseTimeDenseProduct<BlockSparseMatrix, VecType> operator*(const VecType& lhs) const {
-    return BlockSparseTimeDenseProduct<BlockSparseMatrix, VecType>(*this, lhs);
-  }
-
-  /** \returns the number of nonzero blocks */
-  inline Index nonZerosBlocks() const { return m_nonzerosblocks; }
-  /** \returns the total number of nonzero elements, including eventual explicit zeros in blocks */
-  inline Index nonZeros() const { return m_nonzeros; }
-
-  inline BlockScalarReturnType* valuePtr() { return static_cast<BlockScalarReturnType*>(m_values); }
-  //    inline Scalar *valuePtr(){ return m_values; }
-  inline StorageIndex* innerIndexPtr() { return m_indices; }
-  inline const StorageIndex* innerIndexPtr() const { return m_indices; }
-  inline StorageIndex* outerIndexPtr() { return m_outerIndex; }
-  inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
-
-  /** \brief for compatibility purposes with the SparseMatrix class */
-  inline bool isCompressed() const { return true; }
-  /**
-   * \returns the starting index of the bi row block
-   */
-  inline Index blockRowsIndex(Index bi) const { return IsColMajor ? blockInnerIndex(bi) : blockOuterIndex(bi); }
-
-  /**
-   * \returns the starting index of the bj col block
-   */
-  inline Index blockColsIndex(Index bj) const { return IsColMajor ? blockOuterIndex(bj) : blockInnerIndex(bj); }
-
-  inline Index blockOuterIndex(Index bj) const {
-    return (m_blockSize == Dynamic) ? m_outerOffset[bj] : (bj * m_blockSize);
-  }
-  inline Index blockInnerIndex(Index bi) const {
-    return (m_blockSize == Dynamic) ? m_innerOffset[bi] : (bi * m_blockSize);
-  }
-
-  // Not needed.
-  inline Index blockInnerSize(Index bi) const {
-    return (m_blockSize == Dynamic) ? (m_innerOffset[bi + 1] - m_innerOffset[bi]) : m_blockSize;
-  }
-  inline Index blockOuterSize(Index bj) const {
-    return (m_blockSize == Dynamic) ? (m_outerOffset[bj + 1] - m_outerOffset[bj]) : m_blockSize;
-  }
-
-  /**
-   * \brief Browse the matrix by outer index
-   */
-  class InnerIterator;  // Browse column by column
-
-  /**
-   * \brief Browse the matrix by block outer index
-   */
-  class BlockInnerIterator;  // Browse block by block
-
-  friend std::ostream& operator<<(std::ostream& s, const BlockSparseMatrix& m) {
-    for (StorageIndex j = 0; j < m.outerBlocks(); ++j) {
-      BlockInnerIterator itb(m, j);
-      for (; itb; ++itb) {
-        s << "(" << itb.row() << ", " << itb.col() << ")\n";
-        s << itb.value() << "\n";
-      }
-    }
-    s << std::endl;
-    return s;
-  }
-
-  /**
-   * \returns the starting position of the block \p id in the array of values
-   */
-  Index blockPtr(Index id) const {
-    if (m_blockSize == Dynamic)
-      return m_blockPtr[id];
-    else
-      return id * m_blockSize * m_blockSize;
-  }
-
- protected:
-  // To be implemented
-  // Insert a block at a particular location... need to make a room for that
-  Map<BlockScalar> insert(Index brow, Index bcol);
-
-  Index m_innerBSize;           // Number of block rows
-  Index m_outerBSize;           // Number of block columns
-  StorageIndex* m_innerOffset;  // Starting index of each inner block (size m_innerBSize+1)
-  StorageIndex* m_outerOffset;  // Starting index of each outer block (size m_outerBSize+1)
-  Index m_nonzerosblocks;       // Total nonzeros blocks (lower than  m_innerBSize x m_outerBSize)
-  Index m_nonzeros;             // Total nonzeros elements
-  Scalar* m_values;             // Values stored block column after block column (size m_nonzeros)
-  StorageIndex* m_blockPtr;     // Pointer to the beginning of each block in m_values, size m_nonzeroblocks ... null for
-                                // fixed-size blocks
-  StorageIndex* m_indices;      // Inner block indices, size m_nonzerosblocks ... OK
-  StorageIndex* m_outerIndex;   // Starting pointer of each block column in m_indices (size m_outerBSize)... OK
-  Index m_blockSize;            // Size of a block for fixed-size blocks, otherwise -1
-};
-
-template <typename Scalar_, int _BlockAtCompileTime, int Options_, typename StorageIndex_>
-class BlockSparseMatrix<Scalar_, _BlockAtCompileTime, Options_, StorageIndex_>::BlockInnerIterator {
- public:
-  enum { Flags = Options_ };
-
-  BlockInnerIterator(const BlockSparseMatrix& mat, const Index outer)
-      : m_mat(mat), m_outer(outer), m_id(mat.m_outerIndex[outer]), m_end(mat.m_outerIndex[outer + 1]) {}
-
-  inline BlockInnerIterator& operator++() {
-    m_id++;
-    return *this;
-  }
-
-  inline const Map<const BlockScalar> value() const {
-    return Map<const BlockScalar>(&(m_mat.m_values[m_mat.blockPtr(m_id)]), rows(), cols());
-  }
-  inline Map<BlockScalar> valueRef() {
-    return Map<BlockScalar>(&(m_mat.m_values[m_mat.blockPtr(m_id)]), rows(), cols());
-  }
-  // Block inner index
-  inline Index index() const { return m_mat.m_indices[m_id]; }
-  inline Index outer() const { return m_outer; }
-  // block row index
-  inline Index row() const { return index(); }
-  // block column index
-  inline Index col() const { return outer(); }
-  // FIXME: Number of rows in the current block.
-  inline Index rows() const {
-    return (m_mat.m_blockSize == Dynamic) ? (m_mat.m_innerOffset[index() + 1] - m_mat.m_innerOffset[index()])
-                                          : m_mat.m_blockSize;
-  }
-  // Number of columns in the current block ...
-  inline Index cols() const {
-    return (m_mat.m_blockSize == Dynamic) ? (m_mat.m_outerOffset[m_outer + 1] - m_mat.m_outerOffset[m_outer])
-                                          : m_mat.m_blockSize;
-  }
-  inline operator bool() const { return (m_id < m_end); }
-
- protected:
-  const BlockSparseMatrix<Scalar_, _BlockAtCompileTime, Options_, StorageIndex>& m_mat;
-  const Index m_outer;
-  Index m_id;
-  Index m_end;
-};
-
-template <typename Scalar_, int _BlockAtCompileTime, int Options_, typename StorageIndex_>
-class BlockSparseMatrix<Scalar_, _BlockAtCompileTime, Options_, StorageIndex_>::InnerIterator {
- public:
-  InnerIterator(const BlockSparseMatrix& mat, Index outer)
-      : m_mat(mat),
-        m_outerB(mat.outerToBlock(outer)),
-        m_outer(outer),
-        itb(mat, mat.outerToBlock(outer)),
-        m_offset(outer - mat.blockOuterIndex(m_outerB)) {
-    if (itb) {
-      m_id = m_mat.blockInnerIndex(itb.index());
-      m_start = m_id;
-      m_end = m_mat.blockInnerIndex(itb.index() + 1);
-    }
-  }
-  inline InnerIterator& operator++() {
-    m_id++;
-    if (m_id >= m_end) {
-      ++itb;
-      if (itb) {
-        m_id = m_mat.blockInnerIndex(itb.index());
-        m_start = m_id;
-        m_end = m_mat.blockInnerIndex(itb.index() + 1);
-      }
-    }
-    return *this;
-  }
-  inline const Scalar& value() const { return itb.value().coeff(m_id - m_start, m_offset); }
-  inline Scalar& valueRef() { return itb.valueRef().coeff(m_id - m_start, m_offset); }
-  inline Index index() const { return m_id; }
-  inline Index outer() const { return m_outer; }
-  inline Index col() const { return outer(); }
-  inline Index row() const { return index(); }
-  inline operator bool() const { return itb; }
-
- protected:
-  const BlockSparseMatrix& m_mat;
-  const Index m_outer;
-  const Index m_outerB;
-  BlockInnerIterator itb;  // Iterator through the blocks
-  const Index m_offset;    // Position of this column in the block
-  Index m_start;           // starting inner index of this block
-  Index m_id;              // current inner index in the block
-  Index m_end;             // starting inner index of the next block
-};
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPARSEBLOCKMATRIX_H
diff --git a/unsupported/Eigen/src/SparseExtra/InternalHeaderCheck.h b/unsupported/Eigen/src/SparseExtra/InternalHeaderCheck.h
deleted file mode 100644
index 0e55251..0000000
--- a/unsupported/Eigen/src/SparseExtra/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_SPARSE_EXTRA_MODULE_H
-#error "Please include unsupported/Eigen/SparseExtra instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/SparseExtra/MarketIO.h b/unsupported/Eigen/src/SparseExtra/MarketIO.h
deleted file mode 100644
index f92622d..0000000
--- a/unsupported/Eigen/src/SparseExtra/MarketIO.h
+++ /dev/null
@@ -1,366 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2012 Desire NUENTSA WAKAM <desire.nuentsa_wakam@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSE_MARKET_IO_H
-#define EIGEN_SPARSE_MARKET_IO_H
-
-#include <iostream>
-#include <vector>
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Scalar, typename StorageIndex>
-inline void GetMarketLine(const char* line, StorageIndex& i, StorageIndex& j, Scalar& value) {
-  std::stringstream sline(line);
-  sline >> i >> j >> value;
-}
-
-template <>
-inline void GetMarketLine(const char* line, int& i, int& j, float& value) {
-  std::sscanf(line, "%d %d %g", &i, &j, &value);
-}
-
-template <>
-inline void GetMarketLine(const char* line, int& i, int& j, double& value) {
-  std::sscanf(line, "%d %d %lg", &i, &j, &value);
-}
-
-template <>
-inline void GetMarketLine(const char* line, int& i, int& j, std::complex<float>& value) {
-  std::sscanf(line, "%d %d %g %g", &i, &j, &numext::real_ref(value), &numext::imag_ref(value));
-}
-
-template <>
-inline void GetMarketLine(const char* line, int& i, int& j, std::complex<double>& value) {
-  std::sscanf(line, "%d %d %lg %lg", &i, &j, &numext::real_ref(value), &numext::imag_ref(value));
-}
-
-template <typename Scalar, typename StorageIndex>
-inline void GetMarketLine(const char* line, StorageIndex& i, StorageIndex& j, std::complex<Scalar>& value) {
-  std::stringstream sline(line);
-  Scalar valR, valI;
-  sline >> i >> j >> valR >> valI;
-  value = std::complex<Scalar>(valR, valI);
-}
-
-template <typename RealScalar>
-inline void GetDenseElt(const std::string& line, RealScalar& val) {
-  std::istringstream newline(line);
-  newline >> val;
-}
-
-template <typename RealScalar>
-inline void GetDenseElt(const std::string& line, std::complex<RealScalar>& val) {
-  RealScalar valR, valI;
-  std::istringstream newline(line);
-  newline >> valR >> valI;
-  val = std::complex<RealScalar>(valR, valI);
-}
-
-template <typename Scalar>
-inline void putMarketHeader(std::string& header, int sym) {
-  header = "%%MatrixMarket matrix coordinate ";
-  if (internal::is_same<Scalar, std::complex<float> >::value ||
-      internal::is_same<Scalar, std::complex<double> >::value) {
-    header += " complex";
-    if (sym == Symmetric)
-      header += " symmetric";
-    else if (sym == SelfAdjoint)
-      header += " Hermitian";
-    else
-      header += " general";
-  } else {
-    header += " real";
-    if (sym == Symmetric)
-      header += " symmetric";
-    else
-      header += " general";
-  }
-}
-
-template <typename Scalar, typename StorageIndex>
-inline void PutMatrixElt(Scalar value, StorageIndex row, StorageIndex col, std::ofstream& out) {
-  out << row << " " << col << " " << value << "\n";
-}
-template <typename Scalar, typename StorageIndex>
-inline void PutMatrixElt(std::complex<Scalar> value, StorageIndex row, StorageIndex col, std::ofstream& out) {
-  out << row << " " << col << " " << value.real() << " " << value.imag() << "\n";
-}
-
-template <typename Scalar>
-inline void putDenseElt(Scalar value, std::ofstream& out) {
-  out << value << "\n";
-}
-template <typename Scalar>
-inline void putDenseElt(std::complex<Scalar> value, std::ofstream& out) {
-  out << value.real() << " " << value.imag() << "\n";
-}
-
-}  // end namespace internal
-
-/**
- * \ingroup SparseExtra_Module
- * @brief Reads the header of a matrixmarket file and determines the properties of a matrix
- *
- * @param filename of the file
- * @param sym if the matrix is hermitian,symmetric or none of the latter (sym=0)
- * @param iscomplex if the matrix has complex or real coefficients
- * @param isdense if the matrix is dense or sparse
- * @return true if the file was found
- */
-inline bool getMarketHeader(const std::string& filename, int& sym, bool& iscomplex, bool& isdense) {
-  sym = 0;
-  iscomplex = false;
-  isdense = false;
-  std::ifstream in(filename.c_str(), std::ios::in);
-  if (!in) return false;
-
-  std::string line;
-  // The matrix header is always the first line in the file
-  std::getline(in, line);
-  eigen_assert(in.good());
-
-  std::stringstream fmtline(line);
-  std::string substr[5];
-  fmtline >> substr[0] >> substr[1] >> substr[2] >> substr[3] >> substr[4];
-  if (substr[2].compare("array") == 0) isdense = true;
-  if (substr[3].compare("complex") == 0) iscomplex = true;
-  if (substr[4].compare("symmetric") == 0)
-    sym = Symmetric;
-  else if (substr[4].compare("Hermitian") == 0)
-    sym = SelfAdjoint;
-
-  return true;
-}
-/**
- * \ingroup SparseExtra_Module
- * @brief Loads a sparse matrix from a matrixmarket format file.
- *
- * @tparam SparseMatrixType to read into, symmetries are not supported
- * @param mat SparseMatrix to read into, current values are overwritten
- * @param filename to parse matrix from
- * @return returns true if file exists. Returns false if the parsing did not succeed.
- */
-template <typename SparseMatrixType>
-bool loadMarket(SparseMatrixType& mat, const std::string& filename) {
-  typedef typename SparseMatrixType::Scalar Scalar;
-  typedef typename SparseMatrixType::StorageIndex StorageIndex;
-  std::ifstream input(filename.c_str(), std::ios::in);
-  if (!input) return false;
-
-  char rdbuffer[4096];
-  input.rdbuf()->pubsetbuf(rdbuffer, 4096);
-
-  const int maxBuffersize = 2048;
-  char buffer[maxBuffersize];
-
-  bool readsizes = false;
-
-  typedef Triplet<Scalar, StorageIndex> T;
-  std::vector<T> elements;
-
-  Index M(-1), N(-1), NNZ(-1);
-  Index count = 0;
-  while (input.getline(buffer, maxBuffersize)) {
-    // skip comments
-    // NOTE An appropriate test should be done on the header to get the  symmetry
-    if (buffer[0] == '%') continue;
-
-    if (!readsizes) {
-      std::stringstream line(buffer);
-      line >> M >> N >> NNZ;
-      if (M > 0 && N > 0) {
-        readsizes = true;
-        mat.resize(M, N);
-        mat.reserve(NNZ);
-        elements.reserve(NNZ);
-      }
-    } else {
-      StorageIndex i(-1), j(-1);
-      Scalar value;
-      internal::GetMarketLine(buffer, i, j, value);
-
-      i--;
-      j--;
-      if (i >= 0 && j >= 0 && i < M && j < N) {
-        ++count;
-        elements.push_back(T(i, j, value));
-      } else {
-        std::cerr << "Invalid read: " << i << "," << j << "\n";
-        return false;
-      }
-    }
-  }
-
-  mat.setFromTriplets(elements.begin(), elements.end());
-  if (count != NNZ) {
-    std::cerr << count << "!=" << NNZ << "\n";
-    return false;
-  }
-  input.close();
-  return true;
-}
-
-/**
- * \ingroup SparseExtra_Module
- * @brief Loads a dense Matrix or Vector from a matrixmarket file. If a statically sized matrix has to be parsed and the
- * file contains the wrong dimensions it is undefined behaviour.
- *
- * @tparam DenseMatrixType to read into
- * @param mat DenseMatrix to read into, current values are overwritten, symmetries are not supported
- * @param filename to parse matrix from
- * @return true if parsing was successful. Returns false if the parsing did not succeed.
- */
-template <typename DenseType>
-bool loadMarketDense(DenseType& mat, const std::string& filename) {
-  typedef typename DenseType::Scalar Scalar;
-  std::ifstream in(filename.c_str(), std::ios::in);
-  if (!in) return false;
-
-  std::string line;
-  Index rows(0), cols(0);
-  do {  // Skip comments
-    std::getline(in, line);
-    eigen_assert(in.good());
-  } while (line[0] == '%');
-  std::istringstream newline(line);
-  newline >> rows >> cols;
-
-  bool sizes_not_positive = (rows < 1 || cols < 1);
-  bool wrong_input_rows = (DenseType::MaxRowsAtCompileTime != Dynamic && rows > DenseType::MaxRowsAtCompileTime) ||
-                          (DenseType::RowsAtCompileTime != Dynamic && rows != DenseType::RowsAtCompileTime);
-  bool wrong_input_cols = (DenseType::MaxColsAtCompileTime != Dynamic && cols > DenseType::MaxColsAtCompileTime) ||
-                          (DenseType::ColsAtCompileTime != Dynamic && cols != DenseType::ColsAtCompileTime);
-
-  if (sizes_not_positive || wrong_input_rows || wrong_input_cols) {
-    if (sizes_not_positive) {
-      std::cerr << "non-positive row or column size in file" << filename << "\n";
-    } else {
-      std::cerr << "Input matrix can not be resized to" << rows << " x " << cols << "as given in " << filename << "\n";
-    }
-    in.close();
-    return false;
-  }
-
-  mat.resize(rows, cols);
-  Index row = 0;
-  Index col = 0;
-  Index n = 0;
-  Scalar value;
-  while (std::getline(in, line) && (row < rows) && (col < cols)) {
-    internal::GetDenseElt(line, value);
-    // matrixmarket format is column major
-    mat(row, col) = value;
-    row++;
-    if (row == rows) {
-      row = 0;
-      col++;
-    }
-    n++;
-  }
-  in.close();
-  if (n != mat.size()) {
-    std::cerr << "Unable to read all elements from file " << filename << "\n";
-    return false;
-  }
-  return true;
-}
-/**
- * \ingroup SparseExtra_Module
- * @brief Same functionality as loadMarketDense, deprecated
- */
-template <typename VectorType>
-bool loadMarketVector(VectorType& vec, const std::string& filename) {
-  return loadMarketDense(vec, filename);
-}
-
-/**
- * \ingroup SparseExtra_Module
- * @brief writes a sparse Matrix to a marketmarket format file
- *
- * @tparam SparseMatrixType to write to file
- * @param mat matrix to write to file
- * @param filename filename to write to
- * @param sym at the moment no symmetry operations are supported
- * @return true if writing succeeded
- */
-template <typename SparseMatrixType>
-bool saveMarket(const SparseMatrixType& mat, const std::string& filename, int sym = 0) {
-  typedef typename SparseMatrixType::Scalar Scalar;
-  typedef typename SparseMatrixType::RealScalar RealScalar;
-  std::ofstream out(filename.c_str(), std::ios::out);
-  if (!out) return false;
-
-  out.flags(std::ios_base::scientific);
-  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
-  std::string header;
-  internal::putMarketHeader<Scalar>(header, sym);
-  out << header << std::endl;
-  out << mat.rows() << " " << mat.cols() << " " << mat.nonZeros() << "\n";
-  int count = 0;
-  EIGEN_UNUSED_VARIABLE(count);
-  for (int j = 0; j < mat.outerSize(); ++j)
-    for (typename SparseMatrixType::InnerIterator it(mat, j); it; ++it) {
-      ++count;
-      internal::PutMatrixElt(it.value(), it.row() + 1, it.col() + 1, out);
-    }
-  out.close();
-  return true;
-}
-
-/**
- * \ingroup SparseExtra_Module
- * @brief writes a dense Matrix or vector to a marketmarket format file
- *
- * @tparam DenseMatrixType to write to file
- * @param mat matrix to write to file
- * @param filename filename to write to
- * @return true if writing succeeded
- */
-
-template <typename DenseType>
-bool saveMarketDense(const DenseType& mat, const std::string& filename) {
-  typedef typename DenseType::Scalar Scalar;
-  typedef typename DenseType::RealScalar RealScalar;
-  std::ofstream out(filename.c_str(), std::ios::out);
-  if (!out) return false;
-
-  out.flags(std::ios_base::scientific);
-  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
-  if (internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
-    out << "%%MatrixMarket matrix array complex general\n";
-  else
-    out << "%%MatrixMarket matrix array real general\n";
-  out << mat.rows() << " " << mat.cols() << "\n";
-  for (Index i = 0; i < mat.cols(); i++) {
-    for (Index j = 0; j < mat.rows(); j++) {
-      internal::putDenseElt(mat(j, i), out);
-    }
-  }
-  out.close();
-  return true;
-}
-
-/**
- * \ingroup SparseExtra_Module
- * @brief Same functionality as saveMarketDense, deprecated
- */
-template <typename VectorType>
-bool saveMarketVector(const VectorType& vec, const std::string& filename) {
-  return saveMarketDense(vec, filename);
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPARSE_MARKET_IO_H
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
deleted file mode 100644
index d991e75..0000000
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ /dev/null
@@ -1,217 +0,0 @@
-
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Desire NUENTSA WAKAM <desire.nuentsa_wakam@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BROWSE_MATRICES_H
-#define EIGEN_BROWSE_MATRICES_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-enum { SPD = 0x100, NonSymmetric = 0x0 };
-
-/**
- * @brief Iterator to browse matrices from a specified folder
- *
- * This is used to load all the matrices from a folder.
- * The matrices should be in Matrix Market format
- * It is assumed that the matrices are named as matname.mtx
- * and matname_SPD.mtx if the matrix is Symmetric and positive definite (or Hermitian)
- * The right hand side vectors are loaded as well, if they exist.
- * They should be named as matname_b.mtx.
- * Note that the right hand side for a SPD matrix is named as matname_SPD_b.mtx
- *
- * Sometimes a reference solution is available. In this case, it should be named as matname_x.mtx
- *
- * Sample code
- * \code
- *
- * \endcode
- *
- * \tparam Scalar The scalar type
- */
-template <typename Scalar>
-class MatrixMarketIterator {
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
- public:
-  typedef Matrix<Scalar, Dynamic, 1> VectorType;
-  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
-
- public:
-  MatrixMarketIterator(const std::string& folder)
-      : m_sym(0), m_isvalid(false), m_matIsLoaded(false), m_hasRhs(false), m_hasrefX(false), m_folder(folder) {
-    m_folder_id = opendir(folder.c_str());
-    if (m_folder_id) Getnextvalidmatrix();
-  }
-
-  ~MatrixMarketIterator() {
-    if (m_folder_id) closedir(m_folder_id);
-  }
-
-  inline MatrixMarketIterator& operator++() {
-    m_matIsLoaded = false;
-    m_hasrefX = false;
-    m_hasRhs = false;
-    Getnextvalidmatrix();
-    return *this;
-  }
-  inline operator bool() const { return m_isvalid; }
-
-  /** Return the sparse matrix corresponding to the current file */
-  inline MatrixType& matrix() {
-    // Read the matrix
-    if (m_matIsLoaded) return m_mat;
-
-    std::string matrix_file = m_folder + "/" + m_matname + ".mtx";
-    if (!loadMarket(m_mat, matrix_file)) {
-      std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"" << std::endl;
-      m_matIsLoaded = false;
-      return m_mat;
-    }
-    m_matIsLoaded = true;
-
-    if (m_sym != NonSymmetric) {
-      // Check whether we need to restore a full matrix:
-      RealScalar diag_norm = m_mat.diagonal().norm();
-      RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
-      RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
-      if (lower_norm > diag_norm && upper_norm == diag_norm) {
-        // only the lower part is stored
-        MatrixType tmp(m_mat);
-        m_mat = tmp.template selfadjointView<Lower>();
-      } else if (upper_norm > diag_norm && lower_norm == diag_norm) {
-        // only the upper part is stored
-        MatrixType tmp(m_mat);
-        m_mat = tmp.template selfadjointView<Upper>();
-      }
-    }
-    return m_mat;
-  }
-
-  /** Return the right hand side corresponding to the current matrix.
-   * If the rhs file is not provided, a random rhs is generated
-   */
-  inline VectorType& rhs() {
-    // Get the right hand side
-    if (m_hasRhs) return m_rhs;
-
-    std::string rhs_file;
-    rhs_file = m_folder + "/" + m_matname + "_b.mtx";  // The pattern is matname_b.mtx
-    m_hasRhs = Fileexists(rhs_file);
-    if (m_hasRhs) {
-      m_rhs.resize(m_mat.cols());
-      m_hasRhs = loadMarketVector(m_rhs, rhs_file);
-    }
-    if (!m_hasRhs) {
-      // Generate a random right hand side
-      if (!m_matIsLoaded) this->matrix();
-      m_refX.resize(m_mat.cols());
-      m_refX.setRandom();
-      m_rhs = m_mat * m_refX;
-      m_hasrefX = true;
-      m_hasRhs = true;
-    }
-    return m_rhs;
-  }
-
-  /** Return a reference solution
-   * If it is not provided and if the right hand side is not available
-   * then refX is randomly generated such that A*refX = b
-   * where A and b are the matrix and the rhs.
-   * Note that when a rhs is provided, refX is not available
-   */
-  inline VectorType& refX() {
-    // Check if a reference solution is provided
-    if (m_hasrefX) return m_refX;
-
-    std::string lhs_file;
-    lhs_file = m_folder + "/" + m_matname + "_x.mtx";
-    m_hasrefX = Fileexists(lhs_file);
-    if (m_hasrefX) {
-      m_refX.resize(m_mat.cols());
-      m_hasrefX = loadMarketVector(m_refX, lhs_file);
-    } else
-      m_refX.resize(0);
-    return m_refX;
-  }
-
-  inline std::string& matname() { return m_matname; }
-
-  inline int sym() const { return m_sym; }
-
-  bool hasRhs() const { return m_hasRhs; }
-  bool hasrefX() const { return m_hasrefX; }
-  bool isFolderValid() const { return bool(m_folder_id); }
-
- protected:
-  inline bool Fileexists(std::string file) const {
-    std::ifstream file_id(file.c_str());
-    if (!file_id.good()) {
-      return false;
-    } else {
-      file_id.close();
-      return true;
-    }
-  }
-
-  void Getnextvalidmatrix() {
-    m_isvalid = false;
-    // Here, we return with the next valid matrix in the folder
-    while ((m_curs_id = readdir(m_folder_id)) != NULL) {
-      m_isvalid = false;
-      std::string curfile;
-      curfile = m_folder + "/" + m_curs_id->d_name;
-      // Discard if it is a folder
-      if (m_curs_id->d_type == DT_DIR) continue;  // FIXME: This may not be available on non-BSD systems.
-
-      // Determine from the header if it is a matrix or a right hand side
-      bool isvector, iscomplex = false;
-      if (!getMarketHeader(curfile, m_sym, iscomplex, isvector)) continue;
-      if (isvector) continue;
-      if (!iscomplex) {
-        if (internal::is_same<Scalar, std::complex<float> >::value ||
-            internal::is_same<Scalar, std::complex<double> >::value)
-          continue;
-      }
-      if (iscomplex) {
-        if (internal::is_same<Scalar, float>::value || internal::is_same<Scalar, double>::value) continue;
-      }
-
-      // Get the matrix name
-      std::string filename = m_curs_id->d_name;
-      m_matname = filename.substr(0, filename.length() - 4);
-
-      // Find if the matrix is SPD
-      size_t found = m_matname.find("SPD");
-      if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
-
-      m_isvalid = true;
-      break;
-    }
-  }
-  int m_sym;              // Symmetry of the matrix
-  MatrixType m_mat;       // Current matrix
-  VectorType m_rhs;       // Current vector
-  VectorType m_refX;      // The reference solution, if exists
-  std::string m_matname;  // Matrix Name
-  bool m_isvalid;
-  bool m_matIsLoaded;  // Determine if the matrix has already been loaded from the file
-  bool m_hasRhs;       // The right hand side exists
-  bool m_hasrefX;      // A reference solution is provided
-  std::string m_folder;
-  DIR* m_folder_id;
-  struct dirent* m_curs_id;
-};
-
-}  // end namespace Eigen
-
-#endif
diff --git a/unsupported/Eigen/src/SparseExtra/RandomSetter.h b/unsupported/Eigen/src/SparseExtra/RandomSetter.h
deleted file mode 100644
index fab31f2..0000000
--- a/unsupported/Eigen/src/SparseExtra/RandomSetter.h
+++ /dev/null
@@ -1,308 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_RANDOMSETTER_H
-#define EIGEN_RANDOMSETTER_H
-
-#if defined(EIGEN_GOOGLEHASH_SUPPORT)
-// Ensure the ::google namespace exists, required for checking existence of
-// ::google::dense_hash_map and ::google::sparse_hash_map.
-namespace google {}
-#endif
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** Represents a std::map
- *
- * \see RandomSetter
- */
-template <typename Scalar>
-struct StdMapTraits {
-  typedef int KeyType;
-  typedef std::map<KeyType, Scalar> Type;
-  enum { IsSorted = 1 };
-
-  static void setInvalidKey(Type&, const KeyType&) {}
-};
-
-/** Represents a std::unordered_map
- * \see RandomSetter
- */
-template <typename Scalar>
-struct StdUnorderedMapTraits {
-  typedef int KeyType;
-  typedef std::unordered_map<KeyType, Scalar> Type;
-  enum { IsSorted = 0 };
-
-  static void setInvalidKey(Type&, const KeyType&) {}
-};
-
-#if defined(EIGEN_GOOGLEHASH_SUPPORT)
-
-namespace google {
-
-// Namespace work-around, since sometimes dense_hash_map and sparse_hash_map
-// are in the global namespace, and other times they are under ::google.
-using namespace ::google;
-
-template <typename KeyType, typename Scalar>
-struct DenseHashMap {
-  typedef dense_hash_map<KeyType, Scalar> type;
-};
-
-template <typename KeyType, typename Scalar>
-struct SparseHashMap {
-  typedef sparse_hash_map<KeyType, Scalar> type;
-};
-
-}  // namespace google
-
-/** Represents a google::dense_hash_map
- *
- * \see RandomSetter
- */
-template <typename Scalar>
-struct GoogleDenseHashMapTraits {
-  typedef int KeyType;
-  typedef typename google::DenseHashMap<KeyType, Scalar>::type Type;
-  enum { IsSorted = 0 };
-
-  static void setInvalidKey(Type& map, const KeyType& k) { map.set_empty_key(k); }
-};
-
-/** Represents a google::sparse_hash_map
- *
- * \see RandomSetter
- */
-template <typename Scalar>
-struct GoogleSparseHashMapTraits {
-  typedef int KeyType;
-  typedef typename google::SparseHashMap<KeyType, Scalar>::type Type;
-  enum { IsSorted = 0 };
-
-  static void setInvalidKey(Type&, const KeyType&) {}
-};
-#endif
-
-/** \class RandomSetter
- * \ingroup SparseExtra_Module
- * \brief The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access
- *
- * \tparam SparseMatrixType the type of the sparse matrix we are updating
- * \tparam MapTraits a traits class representing the map implementation used for the temporary sparse storage.
- *                  Its default value depends on the system.
- * \tparam OuterPacketBits defines the number of rows (or columns) manage by a single map object
- *                        as a power of two exponent.
- *
- * This class temporarily represents a sparse matrix object using a generic map implementation allowing for
- * efficient random access. The conversion from the compressed representation to a hash_map object is performed
- * in the RandomSetter constructor, while the sparse matrix is updated back at destruction time. This strategy
- * suggest the use of nested blocks as in this example:
- *
- * \code
- * SparseMatrix<double> m(rows,cols);
- * {
- *   RandomSetter<SparseMatrix<double> > w(m);
- *   // don't use m but w instead with read/write random access to the coefficients:
- *   for(;;)
- *     w(rand(),rand()) = rand;
- * }
- * // when w is deleted, the data are copied back to m
- * // and m is ready to use.
- * \endcode
- *
- * Since hash_map objects are not fully sorted, representing a full matrix as a single hash_map would
- * involve a big and costly sort to update the compressed matrix back. To overcome this issue, a RandomSetter
- * use multiple hash_map, each representing 2^OuterPacketBits columns or rows according to the storage order.
- * To reach optimal performance, this value should be adjusted according to the average number of nonzeros
- * per rows/columns.
- *
- * The possible values for the template parameter MapTraits are:
- *  - \b StdMapTraits: corresponds to std::map. (does not perform very well)
- *  - \b StdUnorderedMapTraits: corresponds to std::unordered_map
- *  - \b GoogleDenseHashMapTraits: corresponds to google::dense_hash_map (best efficiency, reasonable memory
- * consumption)
- *  - \b GoogleSparseHashMapTraits: corresponds to google::sparse_hash_map (best memory consumption, relatively good
- * performance)
- *
- * The default map implementation depends on the availability, and the preferred order is:
- * GoogleSparseHashMapTraits, StdUnorderedMapTraits, and finally StdMapTraits.
- *
- * For performance and memory consumption reasons it is highly recommended to use one of
- * Google's hash_map implementations. To enable the support for them, you must define
- * EIGEN_GOOGLEHASH_SUPPORT. This will include both <google/dense_hash_map> and
- * <google/sparse_hash_map> for you.
- *
- * \see https://github.com/sparsehash/sparsehash
- */
-template <typename SparseMatrixType,
-          template <typename T> class MapTraits =
-#if defined(EIGEN_GOOGLEHASH_SUPPORT)
-              GoogleDenseHashMapTraits
-#else
-              StdUnorderedMapTraits
-#endif
-          ,
-          int OuterPacketBits = 6>
-class RandomSetter {
-  typedef typename SparseMatrixType::Scalar Scalar;
-  typedef typename SparseMatrixType::StorageIndex StorageIndex;
-
-  struct ScalarWrapper {
-    ScalarWrapper() : value(0) {}
-    Scalar value;
-  };
-  typedef typename MapTraits<ScalarWrapper>::KeyType KeyType;
-  typedef typename MapTraits<ScalarWrapper>::Type HashMapType;
-  static constexpr int OuterPacketMask = (1 << OuterPacketBits) - 1;
-  enum {
-    SwapStorage = 1 - MapTraits<ScalarWrapper>::IsSorted,
-    TargetRowMajor = (SparseMatrixType::Flags & RowMajorBit) ? 1 : 0,
-    SetterRowMajor = SwapStorage ? 1 - TargetRowMajor : TargetRowMajor
-  };
-
- public:
-  /** Constructs a random setter object from the sparse matrix \a target
-   *
-   * Note that the initial value of \a target are imported. If you want to re-set
-   * a sparse matrix from scratch, then you must set it to zero first using the
-   * setZero() function.
-   */
-  inline RandomSetter(SparseMatrixType& target) : m_target(&target) {
-    const Index outerSize = SwapStorage ? target.innerSize() : target.outerSize();
-    const Index innerSize = SwapStorage ? target.outerSize() : target.innerSize();
-    m_outerPackets = outerSize >> OuterPacketBits;
-    if (outerSize & OuterPacketMask) m_outerPackets += 1;
-    m_hashmaps = new HashMapType[m_outerPackets];
-    // compute number of bits needed to store inner indices
-    Index aux = innerSize - 1;
-    m_keyBitsOffset = 0;
-    while (aux) {
-      ++m_keyBitsOffset;
-      aux = aux >> 1;
-    }
-    KeyType ik = (1 << (OuterPacketBits + m_keyBitsOffset));
-    for (Index k = 0; k < m_outerPackets; ++k) MapTraits<ScalarWrapper>::setInvalidKey(m_hashmaps[k], ik);
-
-    // insert current coeffs
-    for (Index j = 0; j < m_target->outerSize(); ++j)
-      for (typename SparseMatrixType::InnerIterator it(*m_target, j); it; ++it)
-        (*this)(TargetRowMajor ? j : it.index(), TargetRowMajor ? it.index() : j) = it.value();
-  }
-
-  /** Destructor updating back the sparse matrix target */
-  ~RandomSetter() {
-    KeyType keyBitsMask = (1 << m_keyBitsOffset) - 1;
-    if (!SwapStorage)  // also means the map is sorted
-    {
-      m_target->setZero();
-      m_target->makeCompressed();
-      m_target->reserve(nonZeros());
-      Index prevOuter = -1;
-      for (Index k = 0; k < m_outerPackets; ++k) {
-        const Index outerOffset = (1 << OuterPacketBits) * k;
-        typename HashMapType::iterator end = m_hashmaps[k].end();
-        for (typename HashMapType::iterator it = m_hashmaps[k].begin(); it != end; ++it) {
-          const Index outer = (it->first >> m_keyBitsOffset) + outerOffset;
-          const Index inner = it->first & keyBitsMask;
-          if (prevOuter != outer) {
-            for (Index j = prevOuter + 1; j <= outer; ++j) m_target->startVec(j);
-            prevOuter = outer;
-          }
-          m_target->insertBackByOuterInner(outer, inner) = it->second.value;
-        }
-      }
-      m_target->finalize();
-    } else {
-      VectorXi positions(m_target->outerSize());
-      positions.setZero();
-      // pass 1
-      for (Index k = 0; k < m_outerPackets; ++k) {
-        typename HashMapType::iterator end = m_hashmaps[k].end();
-        for (typename HashMapType::iterator it = m_hashmaps[k].begin(); it != end; ++it) {
-          const Index outer = it->first & keyBitsMask;
-          ++positions[outer];
-        }
-      }
-      // prefix sum
-      StorageIndex count = 0;
-      for (Index j = 0; j < m_target->outerSize(); ++j) {
-        StorageIndex tmp = positions[j];
-        m_target->outerIndexPtr()[j] = count;
-        positions[j] = count;
-        count += tmp;
-      }
-      m_target->makeCompressed();
-      m_target->outerIndexPtr()[m_target->outerSize()] = count;
-      m_target->resizeNonZeros(count);
-      // pass 2
-      for (Index k = 0; k < m_outerPackets; ++k) {
-        const Index outerOffset = (1 << OuterPacketBits) * k;
-        typename HashMapType::iterator end = m_hashmaps[k].end();
-        for (typename HashMapType::iterator it = m_hashmaps[k].begin(); it != end; ++it) {
-          const Index inner = (it->first >> m_keyBitsOffset) + outerOffset;
-          const Index outer = it->first & keyBitsMask;
-          // sorted insertion
-          // Note that we have to deal with at most 2^OuterPacketBits unsorted coefficients,
-          // moreover those 2^OuterPacketBits coeffs are likely to be sparse, an so only a
-          // small fraction of them have to be sorted, whence the following simple procedure:
-          Index posStart = m_target->outerIndexPtr()[outer];
-          Index i = (positions[outer]++) - 1;
-          while ((i >= posStart) && (m_target->innerIndexPtr()[i] > inner)) {
-            m_target->valuePtr()[i + 1] = m_target->valuePtr()[i];
-            m_target->innerIndexPtr()[i + 1] = m_target->innerIndexPtr()[i];
-            --i;
-          }
-          m_target->innerIndexPtr()[i + 1] = internal::convert_index<StorageIndex>(inner);
-          m_target->valuePtr()[i + 1] = it->second.value;
-        }
-      }
-    }
-    delete[] m_hashmaps;
-  }
-
-  /** \returns a reference to the coefficient at given coordinates \a row, \a col */
-  Scalar& operator()(Index row, Index col) {
-    const Index outer = SetterRowMajor ? row : col;
-    const Index inner = SetterRowMajor ? col : row;
-    const Index outerMajor = outer >> OuterPacketBits;  // index of the packet/map
-    const Index outerMinor = outer & OuterPacketMask;   // index of the inner vector in the packet
-    const KeyType key = internal::convert_index<KeyType>((outerMinor << m_keyBitsOffset) | inner);
-    return m_hashmaps[outerMajor][key].value;
-  }
-
-#ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
-  /** \returns a reference to the coefficient at given coordinates \a row, \a col */
-  Scalar& operator[](Index row, Index col) { return operator()(row, col); }
-#endif
-
-  /** \returns the number of non zero coefficients
-   *
-   * \note According to the underlying map/hash_map implementation,
-   * this function might be quite expensive.
-   */
-  Index nonZeros() const {
-    Index nz = 0;
-    for (Index k = 0; k < m_outerPackets; ++k) nz += static_cast<Index>(m_hashmaps[k].size());
-    return nz;
-  }
-
- protected:
-  HashMapType* m_hashmaps;
-  SparseMatrixType* m_target;
-  Index m_outerPackets;
-  unsigned char m_keyBitsOffset;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_RANDOMSETTER_H
diff --git a/unsupported/Eigen/src/SparseExtra/SparseInverse.h b/unsupported/Eigen/src/SparseExtra/SparseInverse.h
deleted file mode 100644
index b9e1c55..0000000
--- a/unsupported/Eigen/src/SparseExtra/SparseInverse.h
+++ /dev/null
@@ -1,232 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2022 Julian Kent <jkflying@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSEINVERSE_H
-#define EIGEN_SPARSEINVERSE_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include "../../../../Eigen/Sparse"
-#include "../../../../Eigen/SparseLU"
-
-namespace Eigen {
-
-/**
- * @brief Kahan algorithm based accumulator
- *
- * The Kahan sum algorithm guarantees to bound the error from floating point
- * accumulation to a fixed value, regardless of the number of accumulations
- * performed. Naive accumulation accumulates errors O(N), and pairwise O(logN).
- * However pairwise also requires O(logN) memory while Kahan summation requires
- * O(1) memory, but 4x the operations / latency.
- *
- * NB! Do not enable associative math optimizations, they may cause the Kahan
- * summation to be optimized out leaving you with naive summation again.
- *
- */
-template <typename Scalar>
-class KahanSum {
-  // Straightforward Kahan summation for accurate accumulation of a sum of numbers
-  Scalar _sum{};
-  Scalar _correction{};
-
- public:
-  Scalar value() const { return _sum; }
-
-  void operator+=(Scalar increment) {
-    const Scalar correctedIncrement = increment + _correction;
-    const Scalar previousSum = _sum;
-    _sum += correctedIncrement;
-    _correction = correctedIncrement - (_sum - previousSum);
-  }
-};
-template <typename Scalar, Index Width = 16>
-class FABSum {
-  // https://epubs.siam.org/doi/pdf/10.1137/19M1257780
-  // Fast and Accurate Blocked Summation
-  // Uses naive summation for the fast sum, and Kahan summation for the accurate sum
-  // Theoretically SIMD sum could be changed to a tree sum which would improve accuracy
-  // over naive summation
-  KahanSum<Scalar> _totalSum;
-  Matrix<Scalar, Width, 1> _block;
-  Index _blockUsed{};
-
- public:
-  Scalar value() const { return _block.topRows(_blockUsed).sum() + _totalSum.value(); }
-
-  void operator+=(Scalar increment) {
-    _block(_blockUsed++, 0) = increment;
-    if (_blockUsed == Width) {
-      _totalSum += _block.sum();
-      _blockUsed = 0;
-    }
-  }
-};
-
-/**
- * @brief computes an accurate dot product on two sparse vectors
- *
- * Uses an accurate summation algorithm for the accumulator in order to
- * compute an accurate dot product for two sparse vectors.
- *
- */
-template <typename Derived, typename OtherDerived>
-typename Derived::Scalar accurateDot(const SparseMatrixBase<Derived>& A, const SparseMatrixBase<OtherDerived>& other) {
-  typedef typename Derived::Scalar Scalar;
-  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
-  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived, OtherDerived)
-  static_assert(internal::is_same<Scalar, typename OtherDerived::Scalar>::value, "mismatched types");
-
-  internal::evaluator<Derived> thisEval(A.derived());
-  typename Derived::ReverseInnerIterator i(thisEval, 0);
-
-  internal::evaluator<OtherDerived> otherEval(other.derived());
-  typename OtherDerived::ReverseInnerIterator j(otherEval, 0);
-
-  FABSum<Scalar> res;
-  while (i && j) {
-    if (i.index() == j.index()) {
-      res += numext::conj(i.value()) * j.value();
-      --i;
-      --j;
-    } else if (i.index() > j.index())
-      --i;
-    else
-      --j;
-  }
-  return res.value();
-}
-
-/**
- * @brief calculate sparse subset of inverse of sparse matrix
- *
- * This class returns a sparse subset of the inverse of the input matrix.
- * The nonzeros correspond to the nonzeros of the input, plus any additional
- * elements required due to fill-in of the internal LU factorization. This is
- * is minimized via a applying a fill-reducing permutation as part of the LU
- * factorization.
- *
- * If there are specific entries of the input matrix which you need inverse
- * values for, which are zero for the input, you need to insert entries into
- * the input sparse matrix for them to be calculated.
- *
- * Due to the sensitive nature of matrix inversion, particularly on large
- * matrices which are made possible via sparsity, high accuracy dot products
- * based on Kahan summation are used to reduce numerical error. If you still
- * encounter numerical errors you may with to equilibrate your matrix before
- * calculating the inverse, as well as making sure it is actually full rank.
- */
-template <typename Scalar>
-class SparseInverse {
- public:
-  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
-  typedef SparseMatrix<Scalar, RowMajor> RowMatrixType;
-
-  SparseInverse() {}
-
-  /**
-   * @brief This Constructor is for if you already have a factored SparseLU and would like to use it to calculate a
-   * sparse inverse.
-   *
-   * Just call this constructor with your already factored SparseLU class and you can directly call the .inverse()
-   * method to get the result.
-   */
-  SparseInverse(const SparseLU<MatrixType>& slu) { _result = computeInverse(slu); }
-
-  /**
-   * @brief Calculate the sparse inverse from a given sparse input
-   */
-  SparseInverse& compute(const SparseMatrix<Scalar>& A) {
-    SparseLU<MatrixType> slu;
-    slu.compute(A);
-    _result = computeInverse(slu);
-    return *this;
-  }
-
-  /**
-   * @brief return the already-calculated sparse inverse, or a 0x0 matrix if it could not be computed
-   */
-  const MatrixType& inverse() const { return _result; }
-
-  /**
-   * @brief Internal function to calculate the sparse inverse in a functional way
-   * @return A sparse inverse representation, or, if the decomposition didn't complete, a 0x0 matrix.
-   */
-  static MatrixType computeInverse(const SparseLU<MatrixType>& slu) {
-    if (slu.info() != Success) {
-      return MatrixType(0, 0);
-    }
-
-    // Extract from SparseLU and decompose into L, inverse D and U terms
-    Matrix<Scalar, Dynamic, 1> invD;
-    RowMatrixType Upper;
-    {
-      RowMatrixType DU = slu.matrixU().toSparse();
-      invD = DU.diagonal().cwiseInverse();
-      Upper = (invD.asDiagonal() * DU).template triangularView<StrictlyUpper>();
-    }
-    MatrixType Lower = slu.matrixL().toSparse().template triangularView<StrictlyLower>();
-
-    // Compute the inverse and reapply the permutation matrix from the LU decomposition
-    return slu.colsPermutation().transpose() * computeInverse(Upper, invD, Lower) * slu.rowsPermutation();
-  }
-
-  /**
-   * @brief Internal function to calculate the inverse from strictly upper, diagonal and strictly lower components
-   */
-  static MatrixType computeInverse(const RowMatrixType& Upper, const Matrix<Scalar, Dynamic, 1>& inverseDiagonal,
-                                   const MatrixType& Lower) {
-    // Calculate the 'minimal set', which is the nonzeros of (L+U).transpose()
-    // It could be zeroed, but we will overwrite all non-zeros anyways.
-    MatrixType colInv = Lower.transpose().template triangularView<UnitUpper>();
-    colInv += Upper.transpose();
-
-    // We also need rowmajor representation in order to do efficient row-wise dot products
-    RowMatrixType rowInv = Upper.transpose().template triangularView<UnitLower>();
-    rowInv += Lower.transpose();
-
-    // Use the Takahashi algorithm to build the supporting elements of the inverse
-    // upwards and to the left, from the bottom right element, 1 col/row at a time
-    for (Index recurseLevel = Upper.cols() - 1; recurseLevel >= 0; recurseLevel--) {
-      const auto& col = Lower.col(recurseLevel);
-      const auto& row = Upper.row(recurseLevel);
-
-      // Calculate the inverse values for the nonzeros in this column
-      typename MatrixType::ReverseInnerIterator colIter(colInv, recurseLevel);
-      for (; recurseLevel < colIter.index(); --colIter) {
-        const Scalar element = -accurateDot(col, rowInv.row(colIter.index()));
-        colIter.valueRef() = element;
-        rowInv.coeffRef(colIter.index(), recurseLevel) = element;
-      }
-
-      // Calculate the inverse values for the nonzeros in this row
-      typename RowMatrixType::ReverseInnerIterator rowIter(rowInv, recurseLevel);
-      for (; recurseLevel < rowIter.index(); --rowIter) {
-        const Scalar element = -accurateDot(row, colInv.col(rowIter.index()));
-        rowIter.valueRef() = element;
-        colInv.coeffRef(recurseLevel, rowIter.index()) = element;
-      }
-
-      // And finally the diagonal, which corresponds to both row and col iterator now
-      const Scalar diag = inverseDiagonal(recurseLevel) - accurateDot(row, colInv.col(recurseLevel));
-      rowIter.valueRef() = diag;
-      colIter.valueRef() = diag;
-    }
-
-    return colInv;
-  }
-
- private:
-  MatrixType _result;
-};
-
-}  // namespace Eigen
-#endif
diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h
deleted file mode 100644
index 25b91b5..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsArrayAPI.h
+++ /dev/null
@@ -1,276 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BESSELFUNCTIONS_ARRAYAPI_H
-#define EIGEN_BESSELFUNCTIONS_ARRAYAPI_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \returns an expression of the coefficient-wise i0(\a x) to the given
- * arrays.
- *
- * It returns the modified Bessel function of the first kind of order zero.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of i0(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_i0()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived>
-    bessel_i0(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise i0e(\a x) to the given
- * arrays.
- *
- * It returns the exponentially scaled modified Bessel
- * function of the first kind of order zero.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of i0e(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_i0e()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived>
-    bessel_i0e(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i0e_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise i1(\a x) to the given
- * arrays.
- *
- * It returns the modified Bessel function of the first kind of order one.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of i1(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_i1()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived>
-    bessel_i1(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise i1e(\a x) to the given
- * arrays.
- *
- * It returns the exponentially scaled modified Bessel
- * function of the first kind of order one.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of i1e(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_i1e()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived>
-    bessel_i1e(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_i1e_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise k0(\a x) to the given
- * arrays.
- *
- * It returns the modified Bessel function of the second kind of order zero.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of k0(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_k0()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived>
-    bessel_k0(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise k0e(\a x) to the given
- * arrays.
- *
- * It returns the exponentially scaled modified Bessel
- * function of the second kind of order zero.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of k0e(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_k0e()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived>
-    bessel_k0e(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k0e_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise k1(\a x) to the given
- * arrays.
- *
- * It returns the modified Bessel function of the second kind of order one.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of k1(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_k1()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived>
-    bessel_k1(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise k1e(\a x) to the given
- * arrays.
- *
- * It returns the exponentially scaled modified Bessel
- * function of the second kind of order one.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of k1e(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_k1e()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived>
-    bessel_k1e(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_k1e_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise j0(\a x) to the given
- * arrays.
- *
- * It returns the Bessel function of the first kind of order zero.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of j0(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_j0()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived>
-    bessel_j0(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j0_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise y0(\a x) to the given
- * arrays.
- *
- * It returns the Bessel function of the second kind of order zero.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of y0(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_y0()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived>
-    bessel_y0(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y0_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise j1(\a x) to the given
- * arrays.
- *
- * It returns the modified Bessel function of the first kind of order one.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of j1(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_j1()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived>
-    bessel_j1(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_j1_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-/** \returns an expression of the coefficient-wise y1(\a x) to the given
- * arrays.
- *
- * It returns the Bessel function of the second kind of order one.
- *
- * \param x is the argument
- *
- * \note This function supports only float and double scalar types. To support
- * other scalar types, the user has to provide implementations of y1(T) for
- * any scalar type T to be supported.
- *
- * \sa ArrayBase::bessel_y1()
- */
-template <typename Derived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived>
-    bessel_y1(const Eigen::ArrayBase<Derived>& x) {
-  return Eigen::CwiseUnaryOp<Eigen::internal::scalar_bessel_y1_op<typename Derived::Scalar>, const Derived>(
-      x.derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_BESSELFUNCTIONS_ARRAYAPI_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h
deleted file mode 100644
index 45b70b4..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsBFloat16.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BESSELFUNCTIONS_BFLOAT16_H
-#define EIGEN_BESSELFUNCTIONS_BFLOAT16_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace numext {
-
-#if EIGEN_HAS_C99_MATH
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i0(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_i0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i0e(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_i0e(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i1(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_i1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_i1e(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_i1e(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_j0(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_j0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_j1(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_j1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_y0(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_y0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_y1(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_y1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k0(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_k0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k0e(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_k0e(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k1(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_k1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 bessel_k1e(const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::bessel_k1e(static_cast<float>(x)));
-}
-#endif
-
-}  // end namespace numext
-}  // end namespace Eigen
-
-#endif  // EIGEN_BESSELFUNCTIONS_BFLOAT16_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h
deleted file mode 100644
index d877417..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsFunctors.h
+++ /dev/null
@@ -1,323 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BESSELFUNCTIONS_FUNCTORS_H
-#define EIGEN_BESSELFUNCTIONS_FUNCTORS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \internal
- * \brief Template functor to compute the modified Bessel function of the first
- * kind of order zero.
- * \sa class CwiseUnaryOp, Cwise::bessel_i0()
- */
-template <typename Scalar>
-struct scalar_bessel_i0_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_i0;
-    return bessel_i0(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i0(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_i0_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=20 is computed.
-    // The cost is N multiplications and 2N additions. We also add
-    // the cost of an additional exp over i0e.
-    Cost = 28 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the exponentially scaled modified Bessel
- * function of the first kind of order zero
- * \sa class CwiseUnaryOp, Cwise::bessel_i0e()
- */
-template <typename Scalar>
-struct scalar_bessel_i0e_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_i0e;
-    return bessel_i0e(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i0e(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_i0e_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=20 is computed.
-    // The cost is N multiplications and 2N additions.
-    Cost = 20 * NumTraits<Scalar>::MulCost + 40 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the modified Bessel function of the first
- * kind of order one
- * \sa class CwiseUnaryOp, Cwise::bessel_i1()
- */
-template <typename Scalar>
-struct scalar_bessel_i1_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_i1;
-    return bessel_i1(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i1(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_i1_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=20 is computed.
-    // The cost is N multiplications and 2N additions. We also add
-    // the cost of an additional exp over i1e.
-    Cost = 28 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the exponentially scaled modified Bessel
- * function of the first kind of order zero
- * \sa class CwiseUnaryOp, Cwise::bessel_i1e()
- */
-template <typename Scalar>
-struct scalar_bessel_i1e_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_i1e;
-    return bessel_i1e(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_i1e(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_i1e_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=20 is computed.
-    // The cost is N multiplications and 2N additions.
-    Cost = 20 * NumTraits<Scalar>::MulCost + 40 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Bessel function of the second kind of
- * order zero
- * \sa class CwiseUnaryOp, Cwise::bessel_j0()
- */
-template <typename Scalar>
-struct scalar_bessel_j0_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_j0;
-    return bessel_j0(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_j0(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_j0_op<Scalar> > {
-  enum {
-    // 6 polynomial of order ~N=8 is computed.
-    // The cost is N multiplications and N additions each, along with a
-    // sine, cosine and rsqrt cost.
-    Cost = 63 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Bessel function of the second kind of
- * order zero
- * \sa class CwiseUnaryOp, Cwise::bessel_y0()
- */
-template <typename Scalar>
-struct scalar_bessel_y0_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_y0;
-    return bessel_y0(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_y0(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_y0_op<Scalar> > {
-  enum {
-    // 6 polynomial of order ~N=8 is computed.
-    // The cost is N multiplications and N additions each, along with a
-    // sine, cosine, rsqrt and j0 cost.
-    Cost = 126 * NumTraits<Scalar>::MulCost + 96 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Bessel function of the first kind of
- * order one
- * \sa class CwiseUnaryOp, Cwise::bessel_j1()
- */
-template <typename Scalar>
-struct scalar_bessel_j1_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_j1;
-    return bessel_j1(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_j1(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_j1_op<Scalar> > {
-  enum {
-    // 6 polynomial of order ~N=8 is computed.
-    // The cost is N multiplications and N additions each, along with a
-    // sine, cosine and rsqrt cost.
-    Cost = 63 * NumTraits<Scalar>::MulCost + 48 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Bessel function of the second kind of
- * order one
- * \sa class CwiseUnaryOp, Cwise::bessel_j1e()
- */
-template <typename Scalar>
-struct scalar_bessel_y1_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_y1;
-    return bessel_y1(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_y1(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_y1_op<Scalar> > {
-  enum {
-    // 6 polynomial of order ~N=8 is computed.
-    // The cost is N multiplications and N additions each, along with a
-    // sine, cosine, rsqrt and j1 cost.
-    Cost = 126 * NumTraits<Scalar>::MulCost + 96 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the modified Bessel function of the second
- * kind of order zero
- * \sa class CwiseUnaryOp, Cwise::bessel_k0()
- */
-template <typename Scalar>
-struct scalar_bessel_k0_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_k0;
-    return bessel_k0(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k0(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_k0_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=10 is computed.
-    // The cost is N multiplications and 2N additions. In addition we compute
-    // i0, a log, exp and prsqrt and sin and cos.
-    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the exponentially scaled modified Bessel
- * function of the second kind of order zero
- * \sa class CwiseUnaryOp, Cwise::bessel_k0e()
- */
-template <typename Scalar>
-struct scalar_bessel_k0e_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_k0e;
-    return bessel_k0e(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k0e(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_k0e_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=10 is computed.
-    // The cost is N multiplications and 2N additions. In addition we compute
-    // i0, a log, exp and prsqrt and sin and cos.
-    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the modified Bessel function of the
- * second kind of order one
- * \sa class CwiseUnaryOp, Cwise::bessel_k1()
- */
-template <typename Scalar>
-struct scalar_bessel_k1_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_k1;
-    return bessel_k1(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k1(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_k1_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=10 is computed.
-    // The cost is N multiplications and 2N additions. In addition we compute
-    // i1, a log, exp and prsqrt and sin and cos.
-    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the exponentially scaled modified Bessel
- * function of the second kind of order one
- * \sa class CwiseUnaryOp, Cwise::bessel_k1e()
- */
-template <typename Scalar>
-struct scalar_bessel_k1e_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    using numext::bessel_k1e;
-    return bessel_k1e(x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const { return internal::pbessel_k1e(x); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_bessel_k1e_op<Scalar> > {
-  enum {
-    // On average, a Chebyshev polynomial of order N=10 is computed.
-    // The cost is N multiplications and 2N additions. In addition we compute
-    // i1, a log, exp and prsqrt and sin and cos.
-    Cost = 68 * NumTraits<Scalar>::MulCost + 88 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBessel
-  };
-};
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_BESSELFUNCTIONS_FUNCTORS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h
deleted file mode 100644
index ac1ea28..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsHalf.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BESSELFUNCTIONS_HALF_H
-#define EIGEN_BESSELFUNCTIONS_HALF_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace numext {
-
-#if EIGEN_HAS_C99_MATH
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i0(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_i0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i0e(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_i0e(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i1(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_i1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_i1e(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_i1e(static_cast<float>(x)));
-}
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_j0(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_j0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_j1(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_j1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_y0(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_y0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_y1(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_y1(static_cast<float>(x)));
-}
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k0(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_k0(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k0e(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_k0e(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k1(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_k1(static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half bessel_k1e(const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::bessel_k1e(static_cast<float>(x)));
-}
-#endif
-
-}  // end namespace numext
-}  // end namespace Eigen
-
-#endif  // EIGEN_BESSELFUNCTIONS_HALF_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h
deleted file mode 100644
index 59bdaf1..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsImpl.h
+++ /dev/null
@@ -1,1638 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Eugene Brevdo <ebrevdo@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BESSEL_FUNCTIONS_H
-#define EIGEN_BESSEL_FUNCTIONS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-//  Parts of this code are based on the Cephes Math Library.
-//
-//  Cephes Math Library Release 2.8:  June, 2000
-//  Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
-//
-//  Permission has been kindly provided by the original author
-//  to incorporate the Cephes software into the Eigen codebase:
-//
-//    From: Stephen Moshier
-//    To: Eugene Brevdo
-//    Subject: Re: Permission to wrap several cephes functions in Eigen
-//
-//    Hello Eugene,
-//
-//    Thank you for writing.
-//
-//    If your licensing is similar to BSD, the formal way that has been
-//    handled is simply to add a statement to the effect that you are incorporating
-//    the Cephes software by permission of the author.
-//
-//    Good luck with your project,
-//    Steve
-
-/****************************************************************************
- * Implementation of Bessel function, based on Cephes                       *
- ****************************************************************************/
-
-template <typename Scalar>
-struct bessel_i0e_retval {
-  typedef Scalar type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_i0e {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_i0e<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  i0ef.c
-     *
-     *  Modified Bessel function of order zero,
-     *  exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, i0ef();
-     *
-     * y = i0ef( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of order zero of the argument.
-     *
-     * The function is defined as i0e(x) = exp(-|x|) j0( ix ).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,30        100000      3.7e-7      7.0e-8
-     * See i0f().
-     *
-     */
-
-    const float A[] = {-1.30002500998624804212E-8f, 6.04699502254191894932E-8f,  -2.67079385394061173391E-7f,
-                       1.11738753912010371815E-6f,  -4.41673835845875056359E-6f, 1.64484480707288970893E-5f,
-                       -5.75419501008210370398E-5f, 1.88502885095841655729E-4f,  -5.76375574538582365885E-4f,
-                       1.63947561694133579842E-3f,  -4.32430999505057594430E-3f, 1.05464603945949983183E-2f,
-                       -2.37374148058994688156E-2f, 4.93052842396707084878E-2f,  -9.49010970480476444210E-2f,
-                       1.71620901522208775349E-1f,  -3.04682672343198398683E-1f, 6.76795274409476084995E-1f};
-
-    const float B[] = {3.39623202570838634515E-9f, 2.26666899049817806459E-8f, 2.04891858946906374183E-7f,
-                       2.89137052083475648297E-6f, 6.88975834691682398426E-5f, 3.36911647825569408990E-3f,
-                       8.04490411014108831608E-1f};
-    T y = pabs(x);
-    T y_le_eight = internal::pchebevl<T, 18>::run(pmadd(pset1<T>(0.5f), y, pset1<T>(-2.0f)), A);
-    T y_gt_eight = pmul(internal::pchebevl<T, 7>::run(psub(pdiv(pset1<T>(32.0f), y), pset1<T>(2.0f)), B), prsqrt(y));
-    // TODO: Perhaps instead check whether all packet elements are in
-    // [-8, 8] and evaluate a branch based off of that. It's possible
-    // in practice most elements are in this region.
-    return pselect(pcmp_le(y, pset1<T>(8.0f)), y_le_eight, y_gt_eight);
-  }
-};
-
-template <typename T>
-struct generic_i0e<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  i0e.c
-     *
-     *  Modified Bessel function of order zero,
-     *  exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, i0e();
-     *
-     * y = i0e( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of order zero of the argument.
-     *
-     * The function is defined as i0e(x) = exp(-|x|) j0( ix ).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,30        30000       5.4e-16     1.2e-16
-     * See i0().
-     *
-     */
-
-    const double A[] = {-4.41534164647933937950E-18, 3.33079451882223809783E-17,  -2.43127984654795469359E-16,
-                        1.71539128555513303061E-15,  -1.16853328779934516808E-14, 7.67618549860493561688E-14,
-                        -4.85644678311192946090E-13, 2.95505266312963983461E-12,  -1.72682629144155570723E-11,
-                        9.67580903537323691224E-11,  -5.18979560163526290666E-10, 2.65982372468238665035E-9,
-                        -1.30002500998624804212E-8,  6.04699502254191894932E-8,   -2.67079385394061173391E-7,
-                        1.11738753912010371815E-6,   -4.41673835845875056359E-6,  1.64484480707288970893E-5,
-                        -5.75419501008210370398E-5,  1.88502885095841655729E-4,   -5.76375574538582365885E-4,
-                        1.63947561694133579842E-3,   -4.32430999505057594430E-3,  1.05464603945949983183E-2,
-                        -2.37374148058994688156E-2,  4.93052842396707084878E-2,   -9.49010970480476444210E-2,
-                        1.71620901522208775349E-1,   -3.04682672343198398683E-1,  6.76795274409476084995E-1};
-    const double B[] = {-7.23318048787475395456E-18, -4.83050448594418207126E-18, 4.46562142029675999901E-17,
-                        3.46122286769746109310E-17,  -2.82762398051658348494E-16, -3.42548561967721913462E-16,
-                        1.77256013305652638360E-15,  3.81168066935262242075E-15,  -9.55484669882830764870E-15,
-                        -4.15056934728722208663E-14, 1.54008621752140982691E-14,  3.85277838274214270114E-13,
-                        7.18012445138366623367E-13,  -1.79417853150680611778E-12, -1.32158118404477131188E-11,
-                        -3.14991652796324136454E-11, 1.18891471078464383424E-11,  4.94060238822496958910E-10,
-                        3.39623202570838634515E-9,   2.26666899049817806459E-8,   2.04891858946906374183E-7,
-                        2.89137052083475648297E-6,   6.88975834691682398426E-5,   3.36911647825569408990E-3,
-                        8.04490411014108831608E-1};
-    T y = pabs(x);
-    T y_le_eight = internal::pchebevl<T, 30>::run(pmadd(pset1<T>(0.5), y, pset1<T>(-2.0)), A);
-    T y_gt_eight = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(32.0), y), pset1<T>(2.0)), B), prsqrt(y));
-    // TODO: Perhaps instead check whether all packet elements are in
-    // [-8, 8] and evaluate a branch based off of that. It's possible
-    // in practice most elements are in this region.
-    return pselect(pcmp_le(y, pset1<T>(8.0)), y_le_eight, y_gt_eight);
-  }
-};
-
-template <typename T>
-struct bessel_i0e_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i0e<T>::run(x); }
-};
-
-template <typename Scalar>
-struct bessel_i0_retval {
-  typedef Scalar type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_i0 {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    return pmul(pexp(pabs(x)), generic_i0e<T, ScalarType>::run(x));
-  }
-};
-
-template <typename T>
-struct bessel_i0_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i0<T>::run(x); }
-};
-
-template <typename Scalar>
-struct bessel_i1e_retval {
-  typedef Scalar type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_i1e {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_i1e<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* i1ef.c
-     *
-     *  Modified Bessel function of order one,
-     *  exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, i1ef();
-     *
-     * y = i1ef( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of order one of the argument.
-     *
-     * The function is defined as i1(x) = -i exp(-|x|) j1( ix ).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       1.5e-6      1.5e-7
-     * See i1().
-     *
-     */
-    const float A[] = {9.38153738649577178388E-9f,  -4.44505912879632808065E-8f, 2.00329475355213526229E-7f,
-                       -8.56872026469545474066E-7f, 3.47025130813767847674E-6f,  -1.32731636560394358279E-5f,
-                       4.78156510755005422638E-5f,  -1.61760815825896745588E-4f, 5.12285956168575772895E-4f,
-                       -1.51357245063125314899E-3f, 4.15642294431288815669E-3f,  -1.05640848946261981558E-2f,
-                       2.47264490306265168283E-2f,  -5.29459812080949914269E-2f, 1.02643658689847095384E-1f,
-                       -1.76416518357834055153E-1f, 2.52587186443633654823E-1f};
-
-    const float B[] = {-3.83538038596423702205E-9f, -2.63146884688951950684E-8f, -2.51223623787020892529E-7f,
-                       -3.88256480887769039346E-6f, -1.10588938762623716291E-4f, -9.76109749136146840777E-3f,
-                       7.78576235018280120474E-1f};
-
-    T y = pabs(x);
-    T y_le_eight = pmul(y, internal::pchebevl<T, 17>::run(pmadd(pset1<T>(0.5f), y, pset1<T>(-2.0f)), A));
-    T y_gt_eight = pmul(internal::pchebevl<T, 7>::run(psub(pdiv(pset1<T>(32.0f), y), pset1<T>(2.0f)), B), prsqrt(y));
-    // TODO: Perhaps instead check whether all packet elements are in
-    // [-8, 8] and evaluate a branch based off of that. It's possible
-    // in practice most elements are in this region.
-    y = pselect(pcmp_le(y, pset1<T>(8.0f)), y_le_eight, y_gt_eight);
-    return pselect(pcmp_lt(x, pset1<T>(0.0f)), pnegate(y), y);
-  }
-};
-
-template <typename T>
-struct generic_i1e<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  i1e.c
-     *
-     *  Modified Bessel function of order one,
-     *  exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, i1e();
-     *
-     * y = i1e( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of order one of the argument.
-     *
-     * The function is defined as i1(x) = -i exp(-|x|) j1( ix ).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       2.0e-15     2.0e-16
-     * See i1().
-     *
-     */
-    const double A[] = {2.77791411276104639959E-18,  -2.11142121435816608115E-17, 1.55363195773620046921E-16,
-                        -1.10559694773538630805E-15, 7.60068429473540693410E-15,  -5.04218550472791168711E-14,
-                        3.22379336594557470981E-13,  -1.98397439776494371520E-12, 1.17361862988909016308E-11,
-                        -6.66348972350202774223E-11, 3.62559028155211703701E-10,  -1.88724975172282928790E-9,
-                        9.38153738649577178388E-9,   -4.44505912879632808065E-8,  2.00329475355213526229E-7,
-                        -8.56872026469545474066E-7,  3.47025130813767847674E-6,   -1.32731636560394358279E-5,
-                        4.78156510755005422638E-5,   -1.61760815825896745588E-4,  5.12285956168575772895E-4,
-                        -1.51357245063125314899E-3,  4.15642294431288815669E-3,   -1.05640848946261981558E-2,
-                        2.47264490306265168283E-2,   -5.29459812080949914269E-2,  1.02643658689847095384E-1,
-                        -1.76416518357834055153E-1,  2.52587186443633654823E-1};
-    const double B[] = {7.51729631084210481353E-18,  4.41434832307170791151E-18,  -4.65030536848935832153E-17,
-                        -3.20952592199342395980E-17, 2.96262899764595013876E-16,  3.30820231092092828324E-16,
-                        -1.88035477551078244854E-15, -3.81440307243700780478E-15, 1.04202769841288027642E-14,
-                        4.27244001671195135429E-14,  -2.10154184277266431302E-14, -4.08355111109219731823E-13,
-                        -7.19855177624590851209E-13, 2.03562854414708950722E-12,  1.41258074366137813316E-11,
-                        3.25260358301548823856E-11,  -1.89749581235054123450E-11, -5.58974346219658380687E-10,
-                        -3.83538038596423702205E-9,  -2.63146884688951950684E-8,  -2.51223623787020892529E-7,
-                        -3.88256480887769039346E-6,  -1.10588938762623716291E-4,  -9.76109749136146840777E-3,
-                        7.78576235018280120474E-1};
-    T y = pabs(x);
-    T y_le_eight = pmul(y, internal::pchebevl<T, 29>::run(pmadd(pset1<T>(0.5), y, pset1<T>(-2.0)), A));
-    T y_gt_eight = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(32.0), y), pset1<T>(2.0)), B), prsqrt(y));
-    // TODO: Perhaps instead check whether all packet elements are in
-    // [-8, 8] and evaluate a branch based off of that. It's possible
-    // in practice most elements are in this region.
-    y = pselect(pcmp_le(y, pset1<T>(8.0)), y_le_eight, y_gt_eight);
-    return pselect(pcmp_lt(x, pset1<T>(0.0)), pnegate(y), y);
-  }
-};
-
-template <typename T>
-struct bessel_i1e_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i1e<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_i1_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_i1 {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    return pmul(pexp(pabs(x)), generic_i1e<T, ScalarType>::run(x));
-  }
-};
-
-template <typename T>
-struct bessel_i1_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_i1<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_k0e_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_k0e {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_k0e<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  k0ef.c
-     *	Modified Bessel function, third kind, order zero,
-     *	exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, k0ef();
-     *
-     * y = k0ef( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of the third kind of order zero of the argument.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       8.1e-7      7.8e-8
-     * See k0().
-     *
-     */
-
-    const float A[] = {1.90451637722020886025E-9f, 2.53479107902614945675E-7f, 2.28621210311945178607E-5f,
-                       1.26461541144692592338E-3f, 3.59799365153615016266E-2f, 3.44289899924628486886E-1f,
-                       -5.35327393233902768720E-1f};
-
-    const float B[] = {-1.69753450938905987466E-9f, 8.57403401741422608519E-9f,  -4.66048989768794782956E-8f,
-                       2.76681363944501510342E-7f,  -1.83175552271911948767E-6f, 1.39498137188764993662E-5f,
-                       -1.28495495816278026384E-4f, 1.56988388573005337491E-3f,  -3.14481013119645005427E-2f,
-                       2.44030308206595545468E0f};
-    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A);
-    x_le_two = pmadd(generic_i0<T, float>::run(x), pnegate(plog(pmul(pset1<T>(0.5), x))), x_le_two);
-    x_le_two = pmul(pexp(x), x_le_two);
-    T x_gt_two = pmul(internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
-    return pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, pselect(pcmp_le(x, two), x_le_two, x_gt_two));
-  }
-};
-
-template <typename T>
-struct generic_k0e<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  k0e.c
-     *	Modified Bessel function, third kind, order zero,
-     *	exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, k0e();
-     *
-     * y = k0e( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of the third kind of order zero of the argument.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       1.4e-15     1.4e-16
-     * See k0().
-     *
-     */
-
-    const double A[] = {1.37446543561352307156E-16, 4.25981614279661018399E-14, 1.03496952576338420167E-11,
-                        1.90451637722020886025E-9,  2.53479107902614945675E-7,  2.28621210311945178607E-5,
-                        1.26461541144692592338E-3,  3.59799365153615016266E-2,  3.44289899924628486886E-1,
-                        -5.35327393233902768720E-1};
-    const double B[] = {5.30043377268626276149E-18,  -1.64758043015242134646E-17, 5.21039150503902756861E-17,
-                        -1.67823109680541210385E-16, 5.51205597852431940784E-16,  -1.84859337734377901440E-15,
-                        6.34007647740507060557E-15,  -2.22751332699166985548E-14, 8.03289077536357521100E-14,
-                        -2.98009692317273043925E-13, 1.14034058820847496303E-12,  -4.51459788337394416547E-12,
-                        1.85594911495471785253E-11,  -7.95748924447710747776E-11, 3.57739728140030116597E-10,
-                        -1.69753450938905987466E-9,  8.57403401741422608519E-9,   -4.66048989768794782956E-8,
-                        2.76681363944501510342E-7,   -1.83175552271911948767E-6,  1.39498137188764993662E-5,
-                        -1.28495495816278026384E-4,  1.56988388573005337491E-3,   -3.14481013119645005427E-2,
-                        2.44030308206595545468E0};
-    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = internal::pchebevl<T, 10>::run(pmadd(x, x, pset1<T>(-2.0)), A);
-    x_le_two = pmadd(generic_i0<T, double>::run(x), pmul(pset1<T>(-1.0), plog(pmul(pset1<T>(0.5), x))), x_le_two);
-    x_le_two = pmul(pexp(x), x_le_two);
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct bessel_k0e_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k0e<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_k0_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_k0 {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_k0<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  k0f.c
-     *	Modified Bessel function, third kind, order zero
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, k0f();
-     *
-     * y = k0f( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns modified Bessel function of the third kind
-     * of order zero of the argument.
-     *
-     * The range is partitioned into the two intervals [0,8] and
-     * (8, infinity).  Chebyshev polynomial expansions are employed
-     * in each interval.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     * Tested at 2000 random points between 0 and 8.  Peak absolute
-     * error (relative when K0 > 1) was 1.46e-14; rms, 4.26e-15.
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       7.8e-7      8.5e-8
-     *
-     * ERROR MESSAGES:
-     *
-     *   message         condition      value returned
-     *  K0 domain          x <= 0          MAXNUM
-     *
-     */
-
-    const float A[] = {1.90451637722020886025E-9f, 2.53479107902614945675E-7f, 2.28621210311945178607E-5f,
-                       1.26461541144692592338E-3f, 3.59799365153615016266E-2f, 3.44289899924628486886E-1f,
-                       -5.35327393233902768720E-1f};
-
-    const float B[] = {-1.69753450938905987466E-9f, 8.57403401741422608519E-9f,  -4.66048989768794782956E-8f,
-                       2.76681363944501510342E-7f,  -1.83175552271911948767E-6f, 1.39498137188764993662E-5f,
-                       -1.28495495816278026384E-4f, 1.56988388573005337491E-3f,  -3.14481013119645005427E-2f,
-                       2.44030308206595545468E0f};
-    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A);
-    x_le_two = pmadd(generic_i0<T, float>::run(x), pnegate(plog(pmul(pset1<T>(0.5), x))), x_le_two);
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two =
-        pmul(pmul(pexp(pnegate(x)), internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B)), prsqrt(x));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_k0<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*
-     *
-     *	Modified Bessel function, third kind, order zero,
-     *	exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, k0();
-     *
-     * y = k0( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of the third kind of order zero of the argument.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       1.4e-15     1.4e-16
-     * See k0().
-     *
-     */
-    const double A[] = {1.37446543561352307156E-16, 4.25981614279661018399E-14, 1.03496952576338420167E-11,
-                        1.90451637722020886025E-9,  2.53479107902614945675E-7,  2.28621210311945178607E-5,
-                        1.26461541144692592338E-3,  3.59799365153615016266E-2,  3.44289899924628486886E-1,
-                        -5.35327393233902768720E-1};
-    const double B[] = {5.30043377268626276149E-18,  -1.64758043015242134646E-17, 5.21039150503902756861E-17,
-                        -1.67823109680541210385E-16, 5.51205597852431940784E-16,  -1.84859337734377901440E-15,
-                        6.34007647740507060557E-15,  -2.22751332699166985548E-14, 8.03289077536357521100E-14,
-                        -2.98009692317273043925E-13, 1.14034058820847496303E-12,  -4.51459788337394416547E-12,
-                        1.85594911495471785253E-11,  -7.95748924447710747776E-11, 3.57739728140030116597E-10,
-                        -1.69753450938905987466E-9,  8.57403401741422608519E-9,   -4.66048989768794782956E-8,
-                        2.76681363944501510342E-7,   -1.83175552271911948767E-6,  1.39498137188764993662E-5,
-                        -1.28495495816278026384E-4,  1.56988388573005337491E-3,   -3.14481013119645005427E-2,
-                        2.44030308206595545468E0};
-    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = internal::pchebevl<T, 10>::run(pmadd(x, x, pset1<T>(-2.0)), A);
-    x_le_two = pmadd(generic_i0<T, double>::run(x), pnegate(plog(pmul(pset1<T>(0.5), x))), x_le_two);
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two = pmul(pmul(pexp(-x), internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B)), prsqrt(x));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct bessel_k0_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k0<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_k1e_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_k1e {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_k1e<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* k1ef.c
-     *
-     *	Modified Bessel function, third kind, order one,
-     *	exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, k1ef();
-     *
-     * y = k1ef( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of the third kind of order one of the argument:
-     *
-     *      k1e(x) = exp(x) * k1(x).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       4.9e-7      6.7e-8
-     * See k1().
-     *
-     */
-
-    const float A[] = {-2.21338763073472585583E-8f, -2.43340614156596823496E-6f, -1.73028895751305206302E-4f,
-                       -6.97572385963986435018E-3f, -1.22611180822657148235E-1f, -3.53155960776544875667E-1f,
-                       1.52530022733894777053E0f};
-    const float B[] = {2.01504975519703286596E-9f,  -1.03457624656780970260E-8f, 5.74108412545004946722E-8f,
-                       -3.50196060308781257119E-7f, 2.40648494783721712015E-6f,  -1.93619797416608296024E-5f,
-                       1.95215518471351631108E-4f,  -2.85781685962277938680E-3f, 1.03923736576817238437E-1f,
-                       2.72062619048444266945E0f};
-    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = pdiv(internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
-    x_le_two = pmadd(generic_i1<T, float>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
-    x_le_two = pmul(x_le_two, pexp(x));
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two = pmul(internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_k1e<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  k1e.c
-     *
-     *	Modified Bessel function, third kind, order one,
-     *	exponentially scaled
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, k1e();
-     *
-     * y = k1e( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns exponentially scaled modified Bessel function
-     * of the third kind of order one of the argument:
-     *
-     *      k1e(x) = exp(x) * k1(x).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       7.8e-16     1.2e-16
-     * See k1().
-     *
-     */
-    const double A[] = {-7.02386347938628759343E-18, -2.42744985051936593393E-15, -6.66690169419932900609E-13,
-                        -1.41148839263352776110E-10, -2.21338763073472585583E-8,  -2.43340614156596823496E-6,
-                        -1.73028895751305206302E-4,  -6.97572385963986435018E-3,  -1.22611180822657148235E-1,
-                        -3.53155960776544875667E-1,  1.52530022733894777053E0};
-    const double B[] = {-5.75674448366501715755E-18, 1.79405087314755922667E-17,  -5.68946255844285935196E-17,
-                        1.83809354436663880070E-16,  -6.05704724837331885336E-16, 2.03870316562433424052E-15,
-                        -7.01983709041831346144E-15, 2.47715442448130437068E-14,  -8.97670518232499435011E-14,
-                        3.34841966607842919884E-13,  -1.28917396095102890680E-12, 5.13963967348173025100E-12,
-                        -2.12996783842756842877E-11, 9.21831518760500529508E-11,  -4.19035475934189648750E-10,
-                        2.01504975519703286596E-9,   -1.03457624656780970260E-8,  5.74108412545004946722E-8,
-                        -3.50196060308781257119E-7,  2.40648494783721712015E-6,   -1.93619797416608296024E-5,
-                        1.95215518471351631108E-4,   -2.85781685962277938680E-3,  1.03923736576817238437E-1,
-                        2.72062619048444266945E0};
-    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = pdiv(internal::pchebevl<T, 11>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
-    x_le_two = pmadd(generic_i1<T, double>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
-    x_le_two = pmul(x_le_two, pexp(x));
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two = pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct bessel_k1e_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k1e<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_k1_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_k1 {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_k1<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* k1f.c
-     *	Modified Bessel function, third kind, order one
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, k1f();
-     *
-     * y = k1f( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Computes the modified Bessel function of the third kind
-     * of order one of the argument.
-     *
-     * The range is partitioned into the two intervals [0,2] and
-     * (2, infinity).  Chebyshev polynomial expansions are employed
-     * in each interval.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       4.6e-7      7.6e-8
-     *
-     * ERROR MESSAGES:
-     *
-     *   message         condition      value returned
-     * k1 domain          x <= 0          MAXNUM
-     *
-     */
-
-    const float A[] = {-2.21338763073472585583E-8f, -2.43340614156596823496E-6f, -1.73028895751305206302E-4f,
-                       -6.97572385963986435018E-3f, -1.22611180822657148235E-1f, -3.53155960776544875667E-1f,
-                       1.52530022733894777053E0f};
-    const float B[] = {2.01504975519703286596E-9f,  -1.03457624656780970260E-8f, 5.74108412545004946722E-8f,
-                       -3.50196060308781257119E-7f, 2.40648494783721712015E-6f,  -1.93619797416608296024E-5f,
-                       1.95215518471351631108E-4f,  -2.85781685962277938680E-3f, 1.03923736576817238437E-1f,
-                       2.72062619048444266945E0f};
-    const T MAXNUM = pset1<T>(NumTraits<float>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = pdiv(internal::pchebevl<T, 7>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
-    x_le_two = pmadd(generic_i1<T, float>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two =
-        pmul(pexp(pnegate(x)), pmul(internal::pchebevl<T, 10>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x)));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_k1<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  k1.c
-     *	Modified Bessel function, third kind, order one
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, k1f();
-     *
-     * y = k1f( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Computes the modified Bessel function of the third kind
-     * of order one of the argument.
-     *
-     * The range is partitioned into the two intervals [0,2] and
-     * (2, infinity).  Chebyshev polynomial expansions are employed
-     * in each interval.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 30       30000       4.6e-7      7.6e-8
-     *
-     * ERROR MESSAGES:
-     *
-     *   message         condition      value returned
-     * k1 domain          x <= 0          MAXNUM
-     *
-     */
-    const double A[] = {-7.02386347938628759343E-18, -2.42744985051936593393E-15, -6.66690169419932900609E-13,
-                        -1.41148839263352776110E-10, -2.21338763073472585583E-8,  -2.43340614156596823496E-6,
-                        -1.73028895751305206302E-4,  -6.97572385963986435018E-3,  -1.22611180822657148235E-1,
-                        -3.53155960776544875667E-1,  1.52530022733894777053E0};
-    const double B[] = {-5.75674448366501715755E-18, 1.79405087314755922667E-17,  -5.68946255844285935196E-17,
-                        1.83809354436663880070E-16,  -6.05704724837331885336E-16, 2.03870316562433424052E-15,
-                        -7.01983709041831346144E-15, 2.47715442448130437068E-14,  -8.97670518232499435011E-14,
-                        3.34841966607842919884E-13,  -1.28917396095102890680E-12, 5.13963967348173025100E-12,
-                        -2.12996783842756842877E-11, 9.21831518760500529508E-11,  -4.19035475934189648750E-10,
-                        2.01504975519703286596E-9,   -1.03457624656780970260E-8,  5.74108412545004946722E-8,
-                        -3.50196060308781257119E-7,  2.40648494783721712015E-6,   -1.93619797416608296024E-5,
-                        1.95215518471351631108E-4,   -2.85781685962277938680E-3,  1.03923736576817238437E-1,
-                        2.72062619048444266945E0};
-    const T MAXNUM = pset1<T>(NumTraits<double>::infinity());
-    const T two = pset1<T>(2.0);
-    T x_le_two = pdiv(internal::pchebevl<T, 11>::run(pmadd(x, x, pset1<T>(-2.0)), A), x);
-    x_le_two = pmadd(generic_i1<T, double>::run(x), plog(pmul(pset1<T>(0.5), x)), x_le_two);
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), MAXNUM, x_le_two);
-    T x_gt_two = pmul(pexp(-x), pmul(internal::pchebevl<T, 25>::run(psub(pdiv(pset1<T>(8.0), x), two), B), prsqrt(x)));
-    return pselect(pcmp_le(x, two), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct bessel_k1_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_k1<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_j0_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_j0 {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_j0<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* j0f.c
-     *	Bessel function of order zero
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, j0f();
-     *
-     * y = j0f( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of order zero of the argument.
-     *
-     * The domain is divided into the intervals [0, 2] and
-     * (2, infinity). In the first interval the following polynomial
-     * approximation is used:
-     *
-     *
-     *        2         2         2
-     * (w - r  ) (w - r  ) (w - r  ) P(w)
-     *       1         2         3
-     *
-     *            2
-     * where w = x  and the three r's are zeros of the function.
-     *
-     * In the second interval, the modulus and phase are approximated
-     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
-     * and Phase(x) = x + 1/x R(1/x^2) - pi/4.  The function is
-     *
-     *   j0(x) = Modulus(x) cos( Phase(x) ).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Absolute error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0, 2        100000      1.3e-7      3.6e-8
-     *    IEEE      2, 32       100000      1.9e-7      5.4e-8
-     *
-     */
-
-    const float JP[] = {-6.068350350393235E-008f, 6.388945720783375E-006f, -3.969646342510940E-004f,
-                        1.332913422519003E-002f, -1.729150680240724E-001f};
-    const float MO[] = {-6.838999669318810E-002f, 1.864949361379502E-001f,  -2.145007480346739E-001f,
-                        1.197549369473540E-001f,  -3.560281861530129E-003f, -4.969382655296620E-002f,
-                        -3.355424622293709E-006f, 7.978845717621440E-001f};
-    const float PH[] = {3.242077816988247E+001f,  -3.630592630518434E+001f, 1.756221482109099E+001f,
-                        -4.974978466280903E+000f, 1.001973420681837E+000f,  -1.939906941791308E-001f,
-                        6.490598792654666E-002f,  -1.249992184872738E-001f};
-    const T DR1 = pset1<T>(5.78318596294678452118f);
-    const T NEG_PIO4F = pset1<T>(-0.7853981633974483096f); /* -pi / 4 */
-    T y = pabs(x);
-    T z = pmul(y, y);
-    T y_le_two = pselect(pcmp_lt(y, pset1<T>(1.0e-3f)), pmadd(z, pset1<T>(-0.25f), pset1<T>(1.0f)),
-                         pmul(psub(z, DR1), internal::ppolevl<T, 4>::run(z, JP)));
-    T q = pdiv(pset1<T>(1.0f), y);
-    T w = prsqrt(y);
-    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO));
-    w = pmul(q, q);
-    T yn = pmadd(q, internal::ppolevl<T, 7>::run(w, PH), NEG_PIO4F);
-    T y_gt_two = pmul(p, pcos(padd(yn, y)));
-    return pselect(pcmp_le(y, pset1<T>(2.0)), y_le_two, y_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_j0<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  j0.c
-     *	Bessel function of order zero
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, j0();
-     *
-     * y = j0( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of order zero of the argument.
-     *
-     * The domain is divided into the intervals [0, 5] and
-     * (5, infinity). In the first interval the following rational
-     * approximation is used:
-     *
-     *
-     *        2         2
-     * (w - r  ) (w - r  ) P (w) / Q (w)
-     *       1         2    3       8
-     *
-     *            2
-     * where w = x  and the two r's are zeros of the function.
-     *
-     * In the second interval, the Hankel asymptotic expansion
-     * is employed with two rational functions of degree 6/6
-     * and 7/7.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Absolute error:
-     * arithmetic   domain     # trials      peak         rms
-     *    DEC       0, 30       10000       4.4e-17     6.3e-18
-     *    IEEE      0, 30       60000       4.2e-16     1.1e-16
-     *
-     */
-    const double PP[] = {7.96936729297347051624E-4, 8.28352392107440799803E-2, 1.23953371646414299388E0,
-                         5.44725003058768775090E0,  8.74716500199817011941E0,  5.30324038235394892183E0,
-                         9.99999999999999997821E-1};
-    const double PQ[] = {9.24408810558863637013E-4, 8.56288474354474431428E-2, 1.25352743901058953537E0,
-                         5.47097740330417105182E0,  8.76190883237069594232E0,  5.30605288235394617618E0,
-                         1.00000000000000000218E0};
-    const double QP[] = {-1.13663838898469149931E-2, -1.28252718670509318512E0, -1.95539544257735972385E1,
-                         -9.32060152123768231369E1,  -1.77681167980488050595E2, -1.47077505154951170175E2,
-                         -5.14105326766599330220E1,  -6.05014350600728481186E0};
-    const double QQ[] = {1.00000000000000000000E0, 6.43178256118178023184E1, 8.56430025976980587198E2,
-                         3.88240183605401609683E3, 7.24046774195652478189E3, 5.93072701187316984827E3,
-                         2.06209331660327847417E3, 2.42005740240291393179E2};
-    const double RP[] = {-4.79443220978201773821E9, 1.95617491946556577543E12, -2.49248344360967716204E14,
-                         9.70862251047306323952E15};
-    const double RQ[] = {1.00000000000000000000E0,  4.99563147152651017219E2,  1.73785401676374683123E5,
-                         4.84409658339962045305E7,  1.11855537045356834862E10, 2.11277520115489217587E12,
-                         3.10518229857422583814E14, 3.18121955943204943306E16, 1.71086294081043136091E18};
-    const T DR1 = pset1<T>(5.78318596294678452118E0);
-    const T DR2 = pset1<T>(3.04712623436620863991E1);
-    const T SQ2OPI = pset1<T>(7.9788456080286535587989E-1); /* sqrt(2 / pi) */
-    const T NEG_PIO4 = pset1<T>(-0.7853981633974483096);    /* pi / 4 */
-
-    T y = pabs(x);
-    T z = pmul(y, y);
-    T y_le_five = pselect(pcmp_lt(y, pset1<T>(1.0e-5)), pmadd(z, pset1<T>(-0.25), pset1<T>(1.0)),
-                          pmul(pmul(psub(z, DR1), psub(z, DR2)),
-                               pdiv(internal::ppolevl<T, 3>::run(z, RP), internal::ppolevl<T, 8>::run(z, RQ))));
-    T s = pdiv(pset1<T>(25.0), z);
-    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
-    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
-    T yn = padd(y, NEG_PIO4);
-    T w = pdiv(pset1<T>(-5.0), y);
-    p = pmadd(p, pcos(yn), pmul(w, pmul(q, psin(yn))));
-    T y_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(y)));
-    return pselect(pcmp_le(y, pset1<T>(5.0)), y_le_five, y_gt_five);
-  }
-};
-
-template <typename T>
-struct bessel_j0_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_j0<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_y0_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_y0 {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_y0<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* j0f.c
-     * 	Bessel function of the second kind, order zero
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, y0f();
-     *
-     * y = y0f( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of the second kind, of order
-     * zero, of the argument.
-     *
-     * The domain is divided into the intervals [0, 2] and
-     * (2, infinity). In the first interval a rational approximation
-     * R(x) is employed to compute
-     *
-     *                  2         2         2
-     * y0(x)  =  (w - r  ) (w - r  ) (w - r  ) R(x)  +  2/pi ln(x) j0(x).
-     *                 1         2         3
-     *
-     * Thus a call to j0() is required.  The three zeros are removed
-     * from R(x) to improve its numerical stability.
-     *
-     * In the second interval, the modulus and phase are approximated
-     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
-     * and Phase(x) = x + 1/x S(1/x^2) - pi/4.  Then the function is
-     *
-     *   y0(x) = Modulus(x) sin( Phase(x) ).
-     *
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *  Absolute error, when y0(x) < 1; else relative error:
-     *
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,  2       100000      2.4e-7      3.4e-8
-     *    IEEE      2, 32       100000      1.8e-7      5.3e-8
-     *
-     */
-
-    const float YP[] = {9.454583683980369E-008f, -9.413212653797057E-006f, 5.344486707214273E-004f,
-                        -1.584289289821316E-002f, 1.707584643733568E-001f};
-    const float MO[] = {-6.838999669318810E-002f, 1.864949361379502E-001f,  -2.145007480346739E-001f,
-                        1.197549369473540E-001f,  -3.560281861530129E-003f, -4.969382655296620E-002f,
-                        -3.355424622293709E-006f, 7.978845717621440E-001f};
-    const float PH[] = {3.242077816988247E+001f,  -3.630592630518434E+001f, 1.756221482109099E+001f,
-                        -4.974978466280903E+000f, 1.001973420681837E+000f,  -1.939906941791308E-001f,
-                        6.490598792654666E-002f,  -1.249992184872738E-001f};
-    const T YZ1 = pset1<T>(0.43221455686510834878f);
-    const T TWOOPI = pset1<T>(0.636619772367581343075535f); /* 2 / pi */
-    const T NEG_PIO4F = pset1<T>(-0.7853981633974483096f);  /* -pi / 4 */
-    const T NEG_MAXNUM = pset1<T>(-NumTraits<float>::infinity());
-    T z = pmul(x, x);
-    T x_le_two = pmul(TWOOPI, pmul(plog(x), generic_j0<T, float>::run(x)));
-    x_le_two = pmadd(psub(z, YZ1), internal::ppolevl<T, 4>::run(z, YP), x_le_two);
-    x_le_two = pselect(pcmp_le(x, pset1<T>(0.0)), NEG_MAXNUM, x_le_two);
-    T q = pdiv(pset1<T>(1.0), x);
-    T w = prsqrt(x);
-    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO));
-    T u = pmul(q, q);
-    T xn = pmadd(q, internal::ppolevl<T, 7>::run(u, PH), NEG_PIO4F);
-    T x_gt_two = pmul(p, psin(padd(xn, x)));
-    return pselect(pcmp_le(x, pset1<T>(2.0)), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_y0<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  j0.c
-     *	Bessel function of the second kind, order zero
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, y0();
-     *
-     * y = y0( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of the second kind, of order
-     * zero, of the argument.
-     *
-     * The domain is divided into the intervals [0, 5] and
-     * (5, infinity). In the first interval a rational approximation
-     * R(x) is employed to compute
-     *   y0(x)  = R(x)  +   2 * log(x) * j0(x) / PI.
-     * Thus a call to j0() is required.
-     *
-     * In the second interval, the Hankel asymptotic expansion
-     * is employed with two rational functions of degree 6/6
-     * and 7/7.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *  Absolute error, when y0(x) < 1; else relative error:
-     *
-     * arithmetic   domain     # trials      peak         rms
-     *    DEC       0, 30        9400       7.0e-17     7.9e-18
-     *    IEEE      0, 30       30000       1.3e-15     1.6e-16
-     *
-     */
-    const double PP[] = {7.96936729297347051624E-4, 8.28352392107440799803E-2, 1.23953371646414299388E0,
-                         5.44725003058768775090E0,  8.74716500199817011941E0,  5.30324038235394892183E0,
-                         9.99999999999999997821E-1};
-    const double PQ[] = {9.24408810558863637013E-4, 8.56288474354474431428E-2, 1.25352743901058953537E0,
-                         5.47097740330417105182E0,  8.76190883237069594232E0,  5.30605288235394617618E0,
-                         1.00000000000000000218E0};
-    const double QP[] = {-1.13663838898469149931E-2, -1.28252718670509318512E0, -1.95539544257735972385E1,
-                         -9.32060152123768231369E1,  -1.77681167980488050595E2, -1.47077505154951170175E2,
-                         -5.14105326766599330220E1,  -6.05014350600728481186E0};
-    const double QQ[] = {1.00000000000000000000E0, 6.43178256118178023184E1, 8.56430025976980587198E2,
-                         3.88240183605401609683E3, 7.24046774195652478189E3, 5.93072701187316984827E3,
-                         2.06209331660327847417E3, 2.42005740240291393179E2};
-    const double YP[] = {1.55924367855235737965E4,   -1.46639295903971606143E7, 5.43526477051876500413E9,
-                         -9.82136065717911466409E11, 8.75906394395366999549E13, -3.46628303384729719441E15,
-                         4.42733268572569800351E16,  -1.84950800436986690637E16};
-    const double YQ[] = {1.00000000000000000000E0,  1.04128353664259848412E3,  6.26107330137134956842E5,
-                         2.68919633393814121987E8,  8.64002487103935000337E10, 2.02979612750105546709E13,
-                         3.17157752842975028269E15, 2.50596256172653059228E17};
-    const T SQ2OPI = pset1<T>(7.9788456080286535587989E-1); /* sqrt(2 / pi) */
-    const T TWOOPI = pset1<T>(0.636619772367581343075535);  /* 2 / pi */
-    const T NEG_PIO4 = pset1<T>(-0.7853981633974483096);    /* -pi / 4 */
-    const T NEG_MAXNUM = pset1<T>(-NumTraits<double>::infinity());
-
-    T z = pmul(x, x);
-    T x_le_five = pdiv(internal::ppolevl<T, 7>::run(z, YP), internal::ppolevl<T, 7>::run(z, YQ));
-    x_le_five = pmadd(pmul(TWOOPI, plog(x)), generic_j0<T, double>::run(x), x_le_five);
-    x_le_five = pselect(pcmp_le(x, pset1<T>(0.0)), NEG_MAXNUM, x_le_five);
-    T s = pdiv(pset1<T>(25.0), z);
-    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
-    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
-    T xn = padd(x, NEG_PIO4);
-    T w = pdiv(pset1<T>(5.0), x);
-    p = pmadd(p, psin(xn), pmul(w, pmul(q, pcos(xn))));
-    T x_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(x)));
-    return pselect(pcmp_le(x, pset1<T>(5.0)), x_le_five, x_gt_five);
-  }
-};
-
-template <typename T>
-struct bessel_y0_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_y0<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_j1_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_j1 {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_j1<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* j1f.c
-     *	Bessel function of order one
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float x, y, j1f();
-     *
-     * y = j1f( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of order one of the argument.
-     *
-     * The domain is divided into the intervals [0, 2] and
-     * (2, infinity). In the first interval a polynomial approximation
-     *        2
-     * (w - r  ) x P(w)
-     *       1
-     *                     2
-     * is used, where w = x  and r is the first zero of the function.
-     *
-     * In the second interval, the modulus and phase are approximated
-     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
-     * and Phase(x) = x + 1/x R(1/x^2) - 3pi/4.  The function is
-     *
-     *   j0(x) = Modulus(x) cos( Phase(x) ).
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Absolute error:
-     * arithmetic   domain      # trials      peak       rms
-     *    IEEE      0,  2       100000       1.2e-7     2.5e-8
-     *    IEEE      2, 32       100000       2.0e-7     5.3e-8
-     *
-     *
-     */
-
-    const float JP[] = {-4.878788132172128E-009f, 6.009061827883699E-007f, -4.541343896997497E-005f,
-                        1.937383947804541E-003f, -3.405537384615824E-002f};
-    const float MO1[] = {6.913942741265801E-002f,  -2.284801500053359E-001f, 3.138238455499697E-001f,
-                         -2.102302420403875E-001f, 5.435364690523026E-003f,  1.493389585089498E-001f,
-                         4.976029650847191E-006f,  7.978845453073848E-001f};
-    const float PH1[] = {-4.497014141919556E+001f, 5.073465654089319E+001f,  -2.485774108720340E+001f,
-                         7.222973196770240E+000f,  -1.544842782180211E+000f, 3.503787691653334E-001f,
-                         -1.637986776941202E-001f, 3.749989509080821E-001f};
-    const T Z1 = pset1<T>(1.46819706421238932572E1f);
-    const T NEG_THPIO4F = pset1<T>(-2.35619449019234492885f); /* -3*pi/4 */
-
-    T y = pabs(x);
-    T z = pmul(y, y);
-    T y_le_two = pmul(psub(z, Z1), pmul(x, internal::ppolevl<T, 4>::run(z, JP)));
-    T q = pdiv(pset1<T>(1.0f), y);
-    T w = prsqrt(y);
-    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO1));
-    w = pmul(q, q);
-    T yn = pmadd(q, internal::ppolevl<T, 7>::run(w, PH1), NEG_THPIO4F);
-    T y_gt_two = pmul(p, pcos(padd(yn, y)));
-    // j1 is an odd function. This implementation differs from cephes to
-    // take this fact in to account. Cephes returns -j1(x) for y > 2 range.
-    y_gt_two = pselect(pcmp_lt(x, pset1<T>(0.0f)), pnegate(y_gt_two), y_gt_two);
-    return pselect(pcmp_le(y, pset1<T>(2.0f)), y_le_two, y_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_j1<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  j1.c
-     *	Bessel function of order one
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, j1();
-     *
-     * y = j1( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of order one of the argument.
-     *
-     * The domain is divided into the intervals [0, 8] and
-     * (8, infinity). In the first interval a 24 term Chebyshev
-     * expansion is used. In the second, the asymptotic
-     * trigonometric representation is employed using two
-     * rational functions of degree 5/5.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Absolute error:
-     * arithmetic   domain      # trials      peak         rms
-     *    DEC       0, 30       10000       4.0e-17     1.1e-17
-     *    IEEE      0, 30       30000       2.6e-16     1.1e-16
-     *
-     */
-    const double PP[] = {7.62125616208173112003E-4, 7.31397056940917570436E-2, 1.12719608129684925192E0,
-                         5.11207951146807644818E0,  8.42404590141772420927E0,  5.21451598682361504063E0,
-                         1.00000000000000000254E0};
-    const double PQ[] = {5.71323128072548699714E-4, 6.88455908754495404082E-2, 1.10514232634061696926E0,
-                         5.07386386128601488557E0,  8.39985554327604159757E0,  5.20982848682361821619E0,
-                         9.99999999999999997461E-1};
-    const double QP[] = {5.10862594750176621635E-2, 4.98213872951233449420E0, 7.58238284132545283818E1,
-                         3.66779609360150777800E2,  7.10856304998926107277E2, 5.97489612400613639965E2,
-                         2.11688757100572135698E2,  2.52070205858023719784E1};
-    const double QQ[] = {1.00000000000000000000E0, 7.42373277035675149943E1, 1.05644886038262816351E3,
-                         4.98641058337653607651E3, 9.56231892404756170795E3, 7.99704160447350683650E3,
-                         2.82619278517639096600E3, 3.36093607810698293419E2};
-    const double RP[] = {-8.99971225705559398224E8, 4.52228297998194034323E11, -7.27494245221818276015E13,
-                         3.68295732863852883286E15};
-    const double RQ[] = {1.00000000000000000000E0,  6.20836478118054335476E2,  2.56987256757748830383E5,
-                         8.35146791431949253037E7,  2.21511595479792499675E10, 4.74914122079991414898E12,
-                         7.84369607876235854894E14, 8.95222336184627338078E16, 5.32278620332680085395E18};
-    const T Z1 = pset1<T>(1.46819706421238932572E1);
-    const T Z2 = pset1<T>(4.92184563216946036703E1);
-    const T NEG_THPIO4 = pset1<T>(-2.35619449019234492885); /* -3*pi/4 */
-    const T SQ2OPI = pset1<T>(7.9788456080286535587989E-1); /* sqrt(2 / pi) */
-    T y = pabs(x);
-    T z = pmul(y, y);
-    T y_le_five = pdiv(internal::ppolevl<T, 3>::run(z, RP), internal::ppolevl<T, 8>::run(z, RQ));
-    y_le_five = pmul(pmul(pmul(y_le_five, x), psub(z, Z1)), psub(z, Z2));
-    T s = pdiv(pset1<T>(25.0), z);
-    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
-    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
-    T yn = padd(y, NEG_THPIO4);
-    T w = pdiv(pset1<T>(-5.0), y);
-    p = pmadd(p, pcos(yn), pmul(w, pmul(q, psin(yn))));
-    T y_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(y)));
-    // j1 is an odd function. This implementation differs from cephes to
-    // take this fact in to account. Cephes returns -j1(x) for y > 5 range.
-    y_gt_five = pselect(pcmp_lt(x, pset1<T>(0.0)), pnegate(y_gt_five), y_gt_five);
-    return pselect(pcmp_le(y, pset1<T>(5.0)), y_le_five, y_gt_five);
-  }
-};
-
-template <typename T>
-struct bessel_j1_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_j1<T>::run(x); }
-};
-
-template <typename T>
-struct bessel_y1_retval {
-  typedef T type;
-};
-
-template <typename T, typename ScalarType = typename unpacket_traits<T>::type>
-struct generic_y1 {
-  EIGEN_STATIC_ASSERT((internal::is_same<T, T>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T&) { return ScalarType(0); }
-};
-
-template <typename T>
-struct generic_y1<T, float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /* j1f.c
-     *	Bessel function of second kind of order one
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, y1();
-     *
-     * y = y1( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of the second kind of order one
-     * of the argument.
-     *
-     * The domain is divided into the intervals [0, 2] and
-     * (2, infinity). In the first interval a rational approximation
-     * R(x) is employed to compute
-     *
-     *                  2
-     * y0(x)  =  (w - r  ) x R(x^2)  +  2/pi (ln(x) j1(x) - 1/x) .
-     *                 1
-     *
-     * Thus a call to j1() is required.
-     *
-     * In the second interval, the modulus and phase are approximated
-     * by polynomials of the form Modulus(x) = sqrt(1/x) Q(1/x)
-     * and Phase(x) = x + 1/x S(1/x^2) - 3pi/4.  Then the function is
-     *
-     *   y0(x) = Modulus(x) sin( Phase(x) ).
-     *
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Absolute error:
-     * arithmetic   domain      # trials      peak         rms
-     *    IEEE      0,  2       100000       2.2e-7     4.6e-8
-     *    IEEE      2, 32       100000       1.9e-7     5.3e-8
-     *
-     * (error criterion relative when |y1| > 1).
-     *
-     */
-
-    const float YP[] = {8.061978323326852E-009f, -9.496460629917016E-007f, 6.719543806674249E-005f,
-                        -2.641785726447862E-003f, 4.202369946500099E-002f};
-    const float MO1[] = {6.913942741265801E-002f,  -2.284801500053359E-001f, 3.138238455499697E-001f,
-                         -2.102302420403875E-001f, 5.435364690523026E-003f,  1.493389585089498E-001f,
-                         4.976029650847191E-006f,  7.978845453073848E-001f};
-    const float PH1[] = {-4.497014141919556E+001f, 5.073465654089319E+001f,  -2.485774108720340E+001f,
-                         7.222973196770240E+000f,  -1.544842782180211E+000f, 3.503787691653334E-001f,
-                         -1.637986776941202E-001f, 3.749989509080821E-001f};
-    const T YO1 = pset1<T>(4.66539330185668857532f);
-    const T NEG_THPIO4F = pset1<T>(-2.35619449019234492885f); /* -3*pi/4 */
-    const T TWOOPI = pset1<T>(0.636619772367581343075535f);   /* 2/pi */
-    const T NEG_MAXNUM = pset1<T>(-NumTraits<float>::infinity());
-
-    T z = pmul(x, x);
-    T x_le_two = pmul(psub(z, YO1), internal::ppolevl<T, 4>::run(z, YP));
-    x_le_two = pmadd(x_le_two, x, pmul(TWOOPI, pmadd(generic_j1<T, float>::run(x), plog(x), pdiv(pset1<T>(-1.0f), x))));
-    x_le_two = pselect(pcmp_lt(x, pset1<T>(0.0f)), NEG_MAXNUM, x_le_two);
-
-    T q = pdiv(pset1<T>(1.0), x);
-    T w = prsqrt(x);
-    T p = pmul(w, internal::ppolevl<T, 7>::run(q, MO1));
-    w = pmul(q, q);
-    T xn = pmadd(q, internal::ppolevl<T, 7>::run(w, PH1), NEG_THPIO4F);
-    T x_gt_two = pmul(p, psin(padd(xn, x)));
-    return pselect(pcmp_le(x, pset1<T>(2.0)), x_le_two, x_gt_two);
-  }
-};
-
-template <typename T>
-struct generic_y1<T, double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) {
-    /*  j1.c
-     *	Bessel function of second kind of order one
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, y1();
-     *
-     * y = y1( x );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns Bessel function of the second kind of order one
-     * of the argument.
-     *
-     * The domain is divided into the intervals [0, 8] and
-     * (8, infinity). In the first interval a 25 term Chebyshev
-     * expansion is used, and a call to j1() is required.
-     * In the second, the asymptotic trigonometric representation
-     * is employed using two rational functions of degree 5/5.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     *                      Absolute error:
-     * arithmetic   domain      # trials      peak         rms
-     *    DEC       0, 30       10000       8.6e-17     1.3e-17
-     *    IEEE      0, 30       30000       1.0e-15     1.3e-16
-     *
-     * (error criterion relative when |y1| > 1).
-     *
-     */
-    const double PP[] = {7.62125616208173112003E-4, 7.31397056940917570436E-2, 1.12719608129684925192E0,
-                         5.11207951146807644818E0,  8.42404590141772420927E0,  5.21451598682361504063E0,
-                         1.00000000000000000254E0};
-    const double PQ[] = {5.71323128072548699714E-4, 6.88455908754495404082E-2, 1.10514232634061696926E0,
-                         5.07386386128601488557E0,  8.39985554327604159757E0,  5.20982848682361821619E0,
-                         9.99999999999999997461E-1};
-    const double QP[] = {5.10862594750176621635E-2, 4.98213872951233449420E0, 7.58238284132545283818E1,
-                         3.66779609360150777800E2,  7.10856304998926107277E2, 5.97489612400613639965E2,
-                         2.11688757100572135698E2,  2.52070205858023719784E1};
-    const double QQ[] = {1.00000000000000000000E0, 7.42373277035675149943E1, 1.05644886038262816351E3,
-                         4.98641058337653607651E3, 9.56231892404756170795E3, 7.99704160447350683650E3,
-                         2.82619278517639096600E3, 3.36093607810698293419E2};
-    const double YP[] = {1.26320474790178026440E9,   -6.47355876379160291031E11, 1.14509511541823727583E14,
-                         -8.12770255501325109621E15, 2.02439475713594898196E17,  -7.78877196265950026825E17};
-    const double YQ[] = {1.00000000000000000000E0,  5.94301592346128195359E2,  2.35564092943068577943E5,
-                         7.34811944459721705660E7,  1.87601316108706159478E10, 3.88231277496238566008E12,
-                         6.20557727146953693363E14, 6.87141087355300489866E16, 3.97270608116560655612E18};
-    const T SQ2OPI = pset1<T>(.79788456080286535588);
-    const T NEG_THPIO4 = pset1<T>(-2.35619449019234492885); /* -3*pi/4 */
-    const T TWOOPI = pset1<T>(0.636619772367581343075535);  /* 2/pi */
-    const T NEG_MAXNUM = pset1<T>(-NumTraits<double>::infinity());
-
-    T z = pmul(x, x);
-    T x_le_five = pdiv(internal::ppolevl<T, 5>::run(z, YP), internal::ppolevl<T, 8>::run(z, YQ));
-    x_le_five =
-        pmadd(x_le_five, x, pmul(TWOOPI, pmadd(generic_j1<T, double>::run(x), plog(x), pdiv(pset1<T>(-1.0), x))));
-
-    x_le_five = pselect(pcmp_le(x, pset1<T>(0.0)), NEG_MAXNUM, x_le_five);
-    T s = pdiv(pset1<T>(25.0), z);
-    T p = pdiv(internal::ppolevl<T, 6>::run(s, PP), internal::ppolevl<T, 6>::run(s, PQ));
-    T q = pdiv(internal::ppolevl<T, 7>::run(s, QP), internal::ppolevl<T, 7>::run(s, QQ));
-    T xn = padd(x, NEG_THPIO4);
-    T w = pdiv(pset1<T>(5.0), x);
-    p = pmadd(p, psin(xn), pmul(w, pmul(q, pcos(xn))));
-    T x_gt_five = pmul(p, pmul(SQ2OPI, prsqrt(x)));
-    return pselect(pcmp_le(x, pset1<T>(5.0)), x_le_five, x_gt_five);
-  }
-};
-
-template <typename T>
-struct bessel_y1_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T x) { return generic_y1<T>::run(x); }
-};
-
-}  // end namespace internal
-
-namespace numext {
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i0, Scalar) bessel_i0(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_i0, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i0e, Scalar) bessel_i0e(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_i0e, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i1, Scalar) bessel_i1(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_i1, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_i1e, Scalar) bessel_i1e(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_i1e, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k0, Scalar) bessel_k0(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_k0, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k0e, Scalar) bessel_k0e(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_k0e, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k1, Scalar) bessel_k1(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_k1, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_k1e, Scalar) bessel_k1e(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_k1e, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_j0, Scalar) bessel_j0(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_j0, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_y0, Scalar) bessel_y0(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_y0, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_j1, Scalar) bessel_j1(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_j1, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(bessel_y1, Scalar) bessel_y1(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(bessel_y1, Scalar)::run(x);
-}
-
-}  // end namespace numext
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_BESSEL_FUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h b/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h
deleted file mode 100644
index 1c325fc..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/BesselFunctionsPacketMath.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_BESSELFUNCTIONS_PACKETMATH_H
-#define EIGEN_BESSELFUNCTIONS_PACKETMATH_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order zero i0(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0(const Packet& x) {
-  return numext::bessel_i0(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order zero i0e(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i0e(const Packet& x) {
-  return numext::bessel_i0e(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order one i1(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1(const Packet& x) {
-  return numext::bessel_i1(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order one i1e(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_i1e(const Packet& x) {
-  return numext::bessel_i1e(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order zero j0(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j0(const Packet& x) {
-  return numext::bessel_j0(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order zero j1(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_j1(const Packet& x) {
-  return numext::bessel_j1(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order one y0(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y0(const Packet& x) {
-  return numext::bessel_y0(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order one y1(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_y1(const Packet& x) {
-  return numext::bessel_y1(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order zero k0(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0(const Packet& x) {
-  return numext::bessel_k0(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order zero k0e(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k0e(const Packet& x) {
-  return numext::bessel_k0e(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order one k1e(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1(const Packet& x) {
-  return numext::bessel_k1(x);
-}
-
-/** \internal \returns the exponentially scaled modified Bessel function of
- * order one k1e(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pbessel_k1e(const Packet& x) {
-  return numext::bessel_k1e(x);
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_BESSELFUNCTIONS_PACKETMATH_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/HipVectorCompatibility.h b/unsupported/Eigen/src/SpecialFunctions/HipVectorCompatibility.h
deleted file mode 100644
index 9119335..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/HipVectorCompatibility.h
+++ /dev/null
@@ -1,71 +0,0 @@
-#ifndef HIP_VECTOR_COMPATIBILITY_H
-#define HIP_VECTOR_COMPATIBILITY_H
-
-namespace hip_impl {
-template <typename, typename, unsigned int>
-struct Scalar_accessor;
-}  // end namespace hip_impl
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-#define HIP_SCALAR_ACCESSOR_BUILDER(NAME)           \
-  template <typename T, typename U, unsigned int n> \
-  struct NAME<hip_impl::Scalar_accessor<T, U, n>> : NAME<T> {};
-
-#define HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(NAME)                              \
-  template <typename T, typename U, unsigned int n>                           \
-  struct NAME##_impl<hip_impl::Scalar_accessor<T, U, n>> : NAME##_impl<T> {}; \
-  template <typename T, typename U, unsigned int n>                           \
-  struct NAME##_retval<hip_impl::Scalar_accessor<T, U, n>> : NAME##_retval<T> {};
-
-#define HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(NAME)                                \
-  template <typename T, typename U, unsigned int n, IgammaComputationMode mode> \
-  struct NAME<hip_impl::Scalar_accessor<T, U, n>, mode> : NAME<T, mode> {};
-
-#if EIGEN_HAS_C99_MATH
-HIP_SCALAR_ACCESSOR_BUILDER(betainc_helper)
-HIP_SCALAR_ACCESSOR_BUILDER(incbeta_cfe)
-
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(erf)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(erfc)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(igammac)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(lgamma)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(ndtri)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(polygamma)
-
-HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(igamma_generic_impl)
-#endif
-
-HIP_SCALAR_ACCESSOR_BUILDER(digamma_impl_maybe_poly)
-HIP_SCALAR_ACCESSOR_BUILDER(zeta_impl_series)
-
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_i0)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_i0e)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_i1)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_i1e)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_j0)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_j1)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_k0)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_k0e)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_k1)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_k1e)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_y0)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(bessel_y1)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(betainc)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(digamma)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(gamma_sample_der_alpha)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(igamma_der_a)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(igamma)
-HIP_SCALAR_ACCESSOR_BUILDER_RETVAL(zeta)
-
-HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(igamma_series_impl)
-HIP_SCALAR_ACCESSOR_BUILDER_IGAMMA(igammac_cf_impl)
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // HIP_VECTOR_COMPATIBILITY_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/InternalHeaderCheck.h b/unsupported/Eigen/src/SpecialFunctions/InternalHeaderCheck.h
deleted file mode 100644
index a5ef51a..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/InternalHeaderCheck.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef EIGEN_SPECIALFUNCTIONS_MODULE_H
-#error \
-    "Please include unsupported/Eigen/SpecialFunctions instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h b/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h
deleted file mode 100644
index 0920d27..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsArrayAPI.h
+++ /dev/null
@@ -1,159 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPECIALFUNCTIONS_ARRAYAPI_H
-#define EIGEN_SPECIALFUNCTIONS_ARRAYAPI_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \cpp11 \returns an expression of the coefficient-wise igamma(\a a, \a x) to the given arrays.
- *
- * This function computes the coefficient-wise incomplete gamma function.
- *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of igammac(T,T) for any scalar
- * type T to be supported.
- *
- * \sa Eigen::igammac(), Eigen::lgamma()
- */
-template <typename Derived, typename ExponentDerived>
-EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_op<typename Derived::Scalar>,
-                                               const Derived, const ExponentDerived>
-igamma(const Eigen::ArrayBase<Derived>& a, const Eigen::ArrayBase<ExponentDerived>& x) {
-  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_op<typename Derived::Scalar>, const Derived,
-                              const ExponentDerived>(a.derived(), x.derived());
-}
-
-/** \cpp11 \returns an expression of the coefficient-wise igamma_der_a(\a a, \a x) to the given arrays.
- *
- * This function computes the coefficient-wise derivative of the incomplete
- * gamma function with respect to the parameter a.
- *
- * \note This function supports only float and double scalar types in c++11
- * mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations
- * of igamma_der_a(T,T) for any scalar
- * type T to be supported.
- *
- * \sa Eigen::igamma(), Eigen::lgamma()
- */
-template <typename Derived, typename ExponentDerived>
-EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_der_a_op<typename Derived::Scalar>,
-                                               const Derived, const ExponentDerived>
-igamma_der_a(const Eigen::ArrayBase<Derived>& a, const Eigen::ArrayBase<ExponentDerived>& x) {
-  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_igamma_der_a_op<typename Derived::Scalar>, const Derived,
-                              const ExponentDerived>(a.derived(), x.derived());
-}
-
-/** \cpp11 \returns an expression of the coefficient-wise gamma_sample_der_alpha(\a alpha, \a sample) to the given
- * arrays.
- *
- * This function computes the coefficient-wise derivative of the sample
- * of a Gamma(alpha, 1) random variable with respect to the parameter alpha.
- *
- * \note This function supports only float and double scalar types in c++11
- * mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations
- * of gamma_sample_der_alpha(T,T) for any scalar
- * type T to be supported.
- *
- * \sa Eigen::igamma(), Eigen::lgamma()
- */
-template <typename AlphaDerived, typename SampleDerived>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseBinaryOp<Eigen::internal::scalar_gamma_sample_der_alpha_op<typename AlphaDerived::Scalar>,
-                         const AlphaDerived, const SampleDerived>
-    gamma_sample_der_alpha(const Eigen::ArrayBase<AlphaDerived>& alpha, const Eigen::ArrayBase<SampleDerived>& sample) {
-  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_gamma_sample_der_alpha_op<typename AlphaDerived::Scalar>,
-                              const AlphaDerived, const SampleDerived>(alpha.derived(), sample.derived());
-}
-
-/** \cpp11 \returns an expression of the coefficient-wise igammac(\a a, \a x) to the given arrays.
- *
- * This function computes the coefficient-wise complementary incomplete gamma function.
- *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of igammac(T,T) for any scalar
- * type T to be supported.
- *
- * \sa Eigen::igamma(), Eigen::lgamma()
- */
-template <typename Derived, typename ExponentDerived>
-EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_igammac_op<typename Derived::Scalar>,
-                                               const Derived, const ExponentDerived>
-igammac(const Eigen::ArrayBase<Derived>& a, const Eigen::ArrayBase<ExponentDerived>& x) {
-  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_igammac_op<typename Derived::Scalar>, const Derived,
-                              const ExponentDerived>(a.derived(), x.derived());
-}
-
-/** \cpp11 \returns an expression of the coefficient-wise polygamma(\a n, \a x) to the given arrays.
- *
- * It returns the \a n -th derivative of the digamma(psi) evaluated at \c x.
- *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of polygamma(T,T) for any scalar
- * type T to be supported.
- *
- * \sa Eigen::digamma()
- */
-// * \warning Be careful with the order of the parameters: x.polygamma(n) is equivalent to polygamma(n,x)
-// * \sa ArrayBase::polygamma()
-template <typename DerivedN, typename DerivedX>
-EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>,
-                                               const DerivedN, const DerivedX>
-polygamma(const Eigen::ArrayBase<DerivedN>& n, const Eigen::ArrayBase<DerivedX>& x) {
-  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_polygamma_op<typename DerivedX::Scalar>, const DerivedN,
-                              const DerivedX>(n.derived(), x.derived());
-}
-
-/** \cpp11 \returns an expression of the coefficient-wise betainc(\a x, \a a, \a b) to the given arrays.
- *
- * This function computes the regularized incomplete beta function (integral).
- *
- * \note This function supports only float and double scalar types in c++11 mode. To support other scalar types,
- * or float/double in non c++11 mode, the user has to provide implementations of betainc(T,T,T) for any scalar
- * type T to be supported.
- *
- * \sa Eigen::betainc(), Eigen::lgamma()
- */
-template <typename ArgADerived, typename ArgBDerived, typename ArgXDerived>
-EIGEN_STRONG_INLINE const Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>,
-                                                const ArgADerived, const ArgBDerived, const ArgXDerived>
-betainc(const Eigen::ArrayBase<ArgADerived>& a, const Eigen::ArrayBase<ArgBDerived>& b,
-        const Eigen::ArrayBase<ArgXDerived>& x) {
-  return Eigen::CwiseTernaryOp<Eigen::internal::scalar_betainc_op<typename ArgXDerived::Scalar>, const ArgADerived,
-                               const ArgBDerived, const ArgXDerived>(a.derived(), b.derived(), x.derived());
-}
-
-/** \returns an expression of the coefficient-wise zeta(\a x, \a q) to the given arrays.
- *
- * It returns the Riemann zeta function of two arguments \a x and \a q:
- *
- * \param x is the exponent, it must be > 1
- * \param q is the shift, it must be > 0
- *
- * \note This function supports only float and double scalar types. To support other scalar types, the user has
- * to provide implementations of zeta(T,T) for any scalar type T to be supported.
- *
- * \sa ArrayBase::zeta()
- */
-template <typename DerivedX, typename DerivedQ>
-EIGEN_STRONG_INLINE const
-    Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX, const DerivedQ>
-    zeta(const Eigen::ArrayBase<DerivedX>& x, const Eigen::ArrayBase<DerivedQ>& q) {
-  return Eigen::CwiseBinaryOp<Eigen::internal::scalar_zeta_op<typename DerivedX::Scalar>, const DerivedX,
-                              const DerivedQ>(x.derived(), q.derived());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPECIALFUNCTIONS_ARRAYAPI_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h b/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h
deleted file mode 100644
index 90babae..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsBFloat16.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPECIALFUNCTIONS_BFLOAT16_H
-#define EIGEN_SPECIALFUNCTIONS_BFLOAT16_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace numext {
-
-#if EIGEN_HAS_C99_MATH
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 lgamma(const Eigen::bfloat16& a) {
-  return Eigen::bfloat16(Eigen::numext::lgamma(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 digamma(const Eigen::bfloat16& a) {
-  return Eigen::bfloat16(Eigen::numext::digamma(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 zeta(const Eigen::bfloat16& x, const Eigen::bfloat16& q) {
-  return Eigen::bfloat16(Eigen::numext::zeta(static_cast<float>(x), static_cast<float>(q)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 polygamma(const Eigen::bfloat16& n, const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::polygamma(static_cast<float>(n), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 erf(const Eigen::bfloat16& a) {
-  return Eigen::bfloat16(Eigen::numext::erf(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 erfc(const Eigen::bfloat16& a) {
-  return Eigen::bfloat16(Eigen::numext::erfc(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 ndtri(const Eigen::bfloat16& a) {
-  return Eigen::bfloat16(Eigen::numext::ndtri(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 igamma(const Eigen::bfloat16& a, const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::igamma(static_cast<float>(a), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 igamma_der_a(const Eigen::bfloat16& a, const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::igamma_der_a(static_cast<float>(a), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 gamma_sample_der_alpha(const Eigen::bfloat16& alpha,
-                                                                             const Eigen::bfloat16& sample) {
-  return Eigen::bfloat16(Eigen::numext::gamma_sample_der_alpha(static_cast<float>(alpha), static_cast<float>(sample)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 igammac(const Eigen::bfloat16& a, const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::igammac(static_cast<float>(a), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::bfloat16 betainc(const Eigen::bfloat16& a, const Eigen::bfloat16& b,
-                                                              const Eigen::bfloat16& x) {
-  return Eigen::bfloat16(Eigen::numext::betainc(static_cast<float>(a), static_cast<float>(b), static_cast<float>(x)));
-}
-#endif
-
-}  // end namespace numext
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPECIALFUNCTIONS_BFLOAT16_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h b/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h
deleted file mode 100644
index 483c9ae..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsFunctors.h
+++ /dev/null
@@ -1,326 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPECIALFUNCTIONS_FUNCTORS_H
-#define EIGEN_SPECIALFUNCTIONS_FUNCTORS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \internal
- * \brief Template functor to compute the incomplete gamma function igamma(a, x)
- *
- * \sa class CwiseBinaryOp, Cwise::igamma
- */
-template <typename Scalar>
-struct scalar_igamma_op : binary_op_base<Scalar, Scalar> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a, const Scalar& x) const {
-    using numext::igamma;
-    return igamma(a, x);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& x) const {
-    return internal::pigamma(a, x);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_igamma_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 20 * NumTraits<Scalar>::MulCost + 10 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasIGamma
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the derivative of the incomplete gamma
- * function igamma_der_a(a, x)
- *
- * \sa class CwiseBinaryOp, Cwise::igamma_der_a
- */
-template <typename Scalar>
-struct scalar_igamma_der_a_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a, const Scalar& x) const {
-    using numext::igamma_der_a;
-    return igamma_der_a(a, x);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& x) const {
-    return internal::pigamma_der_a(a, x);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_igamma_der_a_op<Scalar> > {
-  enum {
-    // 2x the cost of igamma
-    Cost = 40 * NumTraits<Scalar>::MulCost + 20 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasIGammaDerA
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the derivative of the sample
- * of a Gamma(alpha, 1) random variable with respect to the parameter alpha
- * gamma_sample_der_alpha(alpha, sample)
- *
- * \sa class CwiseBinaryOp, Cwise::gamma_sample_der_alpha
- */
-template <typename Scalar>
-struct scalar_gamma_sample_der_alpha_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& alpha, const Scalar& sample) const {
-    using numext::gamma_sample_der_alpha;
-    return gamma_sample_der_alpha(alpha, sample);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& alpha, const Packet& sample) const {
-    return internal::pgamma_sample_der_alpha(alpha, sample);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_gamma_sample_der_alpha_op<Scalar> > {
-  enum {
-    // 2x the cost of igamma, minus the lgamma cost (the lgamma cancels out)
-    Cost = 30 * NumTraits<Scalar>::MulCost + 15 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasGammaSampleDerAlpha
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the complementary incomplete gamma function igammac(a, x)
- *
- * \sa class CwiseBinaryOp, Cwise::igammac
- */
-template <typename Scalar>
-struct scalar_igammac_op : binary_op_base<Scalar, Scalar> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a, const Scalar& x) const {
-    using numext::igammac;
-    return igammac(a, x);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& x) const {
-    return internal::pigammac(a, x);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_igammac_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 20 * NumTraits<Scalar>::MulCost + 10 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasIGammac
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the incomplete beta integral betainc(a, b, x)
- *
- */
-template <typename Scalar>
-struct scalar_betainc_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x, const Scalar& a,
-                                                                const Scalar& b) const {
-    using numext::betainc;
-    return betainc(x, a, b);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& x, const Packet& a, const Packet& b) const {
-    return internal::pbetainc(x, a, b);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_betainc_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 400 * NumTraits<Scalar>::MulCost + 400 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasBetaInc
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the natural log of the absolute
- * value of Gamma of a scalar
- * \sa class CwiseUnaryOp, Cwise::lgamma()
- */
-template <typename Scalar>
-struct scalar_lgamma_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
-    using numext::lgamma;
-    return lgamma(a);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::plgamma(a); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_lgamma_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasLGamma
-  };
-};
-
-/** \internal
- * \brief Template functor to compute psi, the derivative of lgamma of a scalar.
- * \sa class CwiseUnaryOp, Cwise::digamma()
- */
-template <typename Scalar>
-struct scalar_digamma_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
-    using numext::digamma;
-    return digamma(a);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::pdigamma(a); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_digamma_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasDiGamma
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Riemann Zeta function of two arguments.
- * \sa class CwiseUnaryOp, Cwise::zeta()
- */
-template <typename Scalar>
-struct scalar_zeta_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x, const Scalar& q) const {
-    using numext::zeta;
-    return zeta(x, q);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x, const Packet& q) const {
-    return internal::pzeta(x, q);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_zeta_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasZeta
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the polygamma function.
- * \sa class CwiseUnaryOp, Cwise::polygamma()
- */
-template <typename Scalar>
-struct scalar_polygamma_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& n, const Scalar& x) const {
-    using numext::polygamma;
-    return polygamma(n, x);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& n, const Packet& x) const {
-    return internal::ppolygamma(n, x);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_polygamma_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasPolygamma
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the error function of a scalar
- * \sa class CwiseUnaryOp, ArrayBase::erf()
- */
-template <typename Scalar>
-struct scalar_erf_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const { return numext::erf(a); }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& x) const {
-    return perf(x);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_erf_op<Scalar> > {
-  enum {
-    PacketAccess = packet_traits<Scalar>::HasErf,
-    Cost = (PacketAccess
-#ifdef EIGEN_VECTORIZE_FMA
-                // TODO(rmlarsen): Move the FMA cost model to a central location.
-                // Haswell can issue 2 add/mul/madd per cycle.
-                // 10 pmadd, 2 pmul, 1 div, 2 other
-                ? (2 * NumTraits<Scalar>::AddCost + 7 * NumTraits<Scalar>::MulCost +
-                   scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
-#else
-                ? (12 * NumTraits<Scalar>::AddCost + 12 * NumTraits<Scalar>::MulCost +
-                   scalar_div_cost<Scalar, packet_traits<Scalar>::HasDiv>::value)
-#endif
-                // Assume for simplicity that this is as expensive as an exp().
-                : (functor_traits<scalar_exp_op<Scalar> >::Cost))
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Complementary Error Function
- * of a scalar
- * \sa class CwiseUnaryOp, Cwise::erfc()
- */
-template <typename Scalar>
-struct scalar_erfc_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
-    using numext::erfc;
-    return erfc(a);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::perfc(a); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_erfc_op<Scalar> > {
-  enum {
-    // Guesstimate
-    Cost = 10 * NumTraits<Scalar>::MulCost + 5 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasErfc
-  };
-};
-
-/** \internal
- * \brief Template functor to compute the Inverse of the normal distribution
- * function of a scalar
- * \sa class CwiseUnaryOp, Cwise::ndtri()
- */
-template <typename Scalar>
-struct scalar_ndtri_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& a) const {
-    using numext::ndtri;
-    return ndtri(a);
-  }
-  typedef typename packet_traits<Scalar>::type Packet;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(const Packet& a) const { return internal::pndtri(a); }
-};
-template <typename Scalar>
-struct functor_traits<scalar_ndtri_op<Scalar> > {
-  enum {
-    // On average, We are evaluating rational functions with degree N=9 in the
-    // numerator and denominator. This results in 2*N additions and 2*N
-    // multiplications.
-    Cost = 18 * NumTraits<Scalar>::MulCost + 18 * NumTraits<Scalar>::AddCost,
-    PacketAccess = packet_traits<Scalar>::HasNdtri
-  };
-};
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPECIALFUNCTIONS_FUNCTORS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h b/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h
deleted file mode 100644
index baba848..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsHalf.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPECIALFUNCTIONS_HALF_H
-#define EIGEN_SPECIALFUNCTIONS_HALF_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace numext {
-
-#if EIGEN_HAS_C99_MATH
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half lgamma(const Eigen::half& a) {
-  return Eigen::half(Eigen::numext::lgamma(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half digamma(const Eigen::half& a) {
-  return Eigen::half(Eigen::numext::digamma(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half zeta(const Eigen::half& x, const Eigen::half& q) {
-  return Eigen::half(Eigen::numext::zeta(static_cast<float>(x), static_cast<float>(q)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half polygamma(const Eigen::half& n, const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::polygamma(static_cast<float>(n), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half erf(const Eigen::half& a) {
-  return Eigen::half(Eigen::numext::erf(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half erfc(const Eigen::half& a) {
-  return Eigen::half(Eigen::numext::erfc(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half ndtri(const Eigen::half& a) {
-  return Eigen::half(Eigen::numext::ndtri(static_cast<float>(a)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half igamma(const Eigen::half& a, const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::igamma(static_cast<float>(a), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half igamma_der_a(const Eigen::half& a, const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::igamma_der_a(static_cast<float>(a), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half gamma_sample_der_alpha(const Eigen::half& alpha,
-                                                                         const Eigen::half& sample) {
-  return Eigen::half(Eigen::numext::gamma_sample_der_alpha(static_cast<float>(alpha), static_cast<float>(sample)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half igammac(const Eigen::half& a, const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::igammac(static_cast<float>(a), static_cast<float>(x)));
-}
-template <>
-EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half betainc(const Eigen::half& a, const Eigen::half& b,
-                                                          const Eigen::half& x) {
-  return Eigen::half(Eigen::numext::betainc(static_cast<float>(a), static_cast<float>(b), static_cast<float>(x)));
-}
-#endif
-
-}  // end namespace numext
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPECIALFUNCTIONS_HALF_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h b/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h
deleted file mode 100644
index 83eada3..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsImpl.h
+++ /dev/null
@@ -1,2081 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Eugene Brevdo <ebrevdo@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPECIAL_FUNCTIONS_H
-#define EIGEN_SPECIAL_FUNCTIONS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-//  Parts of this code are based on the Cephes Math Library.
-//
-//  Cephes Math Library Release 2.8:  June, 2000
-//  Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
-//
-//  Permission has been kindly provided by the original author
-//  to incorporate the Cephes software into the Eigen codebase:
-//
-//    From: Stephen Moshier
-//    To: Eugene Brevdo
-//    Subject: Re: Permission to wrap several cephes functions in Eigen
-//
-//    Hello Eugene,
-//
-//    Thank you for writing.
-//
-//    If your licensing is similar to BSD, the formal way that has been
-//    handled is simply to add a statement to the effect that you are incorporating
-//    the Cephes software by permission of the author.
-//
-//    Good luck with your project,
-//    Steve
-
-/****************************************************************************
- * Implementation of lgamma, requires C++11/C99                             *
- ****************************************************************************/
-
-template <typename Scalar>
-struct lgamma_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) { return Scalar(0); }
-};
-
-template <typename Scalar>
-struct lgamma_retval {
-  typedef Scalar type;
-};
-
-#if EIGEN_HAS_C99_MATH
-// Since glibc 2.19
-#if defined(__GLIBC__) && ((__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 19) || __GLIBC__ > 2) && \
-    (defined(_DEFAULT_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE))
-#define EIGEN_HAS_LGAMMA_R
-#endif
-
-// Glibc versions before 2.19
-#if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ < 19) || __GLIBC__ < 2) && \
-    (defined(_BSD_SOURCE) || defined(_SVID_SOURCE))
-#define EIGEN_HAS_LGAMMA_R
-#endif
-
-template <>
-struct lgamma_impl<float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(float x) {
-#if !defined(EIGEN_GPU_COMPILE_PHASE) && defined(EIGEN_HAS_LGAMMA_R) && !defined(__APPLE__)
-    int dummy;
-    return ::lgammaf_r(x, &dummy);
-#elif defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::lgamma(x);
-#else
-    return ::lgammaf(x);
-#endif
-  }
-};
-
-template <>
-struct lgamma_impl<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(double x) {
-#if !defined(EIGEN_GPU_COMPILE_PHASE) && defined(EIGEN_HAS_LGAMMA_R) && !defined(__APPLE__)
-    int dummy;
-    return ::lgamma_r(x, &dummy);
-#elif defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::lgamma(x);
-#else
-    return ::lgamma(x);
-#endif
-  }
-};
-
-#undef EIGEN_HAS_LGAMMA_R
-#endif
-
-/****************************************************************************
- * Implementation of digamma (psi), based on Cephes                         *
- ****************************************************************************/
-
-template <typename Scalar>
-struct digamma_retval {
-  typedef Scalar type;
-};
-
-/*
- *
- * Polynomial evaluation helper for the Psi (digamma) function.
- *
- * digamma_impl_maybe_poly::run(s) evaluates the asymptotic Psi expansion for
- * input Scalar s, assuming s is above 10.0.
- *
- * If s is above a certain threshold for the given Scalar type, zero
- * is returned.  Otherwise the polynomial is evaluated with enough
- * coefficients for results matching Scalar machine precision.
- *
- *
- */
-template <typename Scalar>
-struct digamma_impl_maybe_poly {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) { return Scalar(0); }
-};
-
-template <>
-struct digamma_impl_maybe_poly<float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(const float s) {
-    constexpr float A[] = {-4.16666666666666666667E-3f, 3.96825396825396825397E-3f, -8.33333333333333333333E-3f,
-                           8.33333333333333333333E-2f};
-
-    float z;
-    if (s < 1.0e8f) {
-      z = 1.0f / (s * s);
-      return z * internal::ppolevl<float, 3>::run(z, A);
-    } else
-      return 0.0f;
-  }
-};
-
-template <>
-struct digamma_impl_maybe_poly<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(const double s) {
-    constexpr double A[] = {8.33333333333333333333E-2,  -2.10927960927960927961E-2, 7.57575757575757575758E-3,
-                            -4.16666666666666666667E-3, 3.96825396825396825397E-3,  -8.33333333333333333333E-3,
-                            8.33333333333333333333E-2};
-
-    double z;
-    if (s < 1.0e17) {
-      z = 1.0 / (s * s);
-      return z * internal::ppolevl<double, 6>::run(z, A);
-    } else
-      return 0.0;
-  }
-};
-
-template <typename Scalar>
-struct digamma_impl {
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar x) {
-    /*
-     *
-     *     Psi (digamma) function (modified for Eigen)
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, y, psi();
-     *
-     * y = psi( x );
-     *
-     *
-     * DESCRIPTION:
-     *
-     *              d      -
-     *   psi(x)  =  -- ln | (x)
-     *              dx
-     *
-     * is the logarithmic derivative of the gamma function.
-     * For integer x,
-     *                   n-1
-     *                    -
-     * psi(n) = -EUL  +   >  1/k.
-     *                    -
-     *                   k=1
-     *
-     * If x is negative, it is transformed to a positive argument by the
-     * reflection formula  psi(1-x) = psi(x) + pi cot(pi x).
-     * For general positive x, the argument is made greater than 10
-     * using the recurrence  psi(x+1) = psi(x) + 1/x.
-     * Then the following asymptotic expansion is applied:
-     *
-     *                           inf.   B
-     *                            -      2k
-     * psi(x) = log(x) - 1/2x -   >   -------
-     *                            -        2k
-     *                           k=1   2k x
-     *
-     * where the B2k are Bernoulli numbers.
-     *
-     * ACCURACY (float):
-     *    Relative error (except absolute when |psi| < 1):
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,30        30000       1.3e-15     1.4e-16
-     *    IEEE      -30,0       40000       1.5e-15     2.2e-16
-     *
-     * ACCURACY (double):
-     *    Absolute error,  relative when |psi| > 1 :
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      -33,0        30000      8.2e-7      1.2e-7
-     *    IEEE      0,33        100000      7.3e-7      7.7e-8
-     *
-     * ERROR MESSAGES:
-     *     message         condition      value returned
-     * psi singularity    x integer <=0      INFINITY
-     */
-
-    Scalar p, q, nz, s, w, y;
-    bool negative = false;
-
-    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
-    const Scalar m_pi = Scalar(EIGEN_PI);
-
-    const Scalar zero = Scalar(0);
-    const Scalar one = Scalar(1);
-    const Scalar half = Scalar(0.5);
-    nz = zero;
-
-    if (x <= zero) {
-      negative = true;
-      q = x;
-      p = numext::floor(q);
-      if (p == q) {
-        return nan;
-      }
-      /* Remove the zeros of tan(m_pi x)
-       * by subtracting the nearest integer from x
-       */
-      nz = q - p;
-      if (nz != half) {
-        if (nz > half) {
-          p += one;
-          nz = q - p;
-        }
-        nz = m_pi / numext::tan(m_pi * nz);
-      } else {
-        nz = zero;
-      }
-      x = one - x;
-    }
-
-    /* use the recurrence psi(x+1) = psi(x) + 1/x. */
-    s = x;
-    w = zero;
-    while (s < Scalar(10)) {
-      w += one / s;
-      s += one;
-    }
-
-    y = digamma_impl_maybe_poly<Scalar>::run(s);
-
-    y = numext::log(s) - (half / s) - y - w;
-
-    return (negative) ? y - nz : y;
-  }
-};
-
-/***************************************************************************
- * Implementation of erfc.
- ****************************************************************************/
-template <typename Scalar>
-struct generic_fast_erfc {
-  template <typename T>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& x_in);
-};
-
-template <>
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erfc<float>::run(const T& x_in) {
-  constexpr float kClamp = 11.0f;
-  const T x = pmin(pmax(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
-
-  // erfc(x) = 1 + x * S(x^2), |x| <= 1.
-  //
-  // Coefficients for S and T generated with Rminimax command:
-  // ./ratapprox --function="erfc(x)-1" --dom='[-1,1]' --type=[11,0] --num="odd"
-  //   --numF="[SG]" --denF="[SG]" --log --dispCoeff="dec"
-  constexpr float alpha[] = {5.61802298761904239654541015625e-04, -4.91381669417023658752441406250e-03,
-                             2.67075151205062866210937500000e-02, -1.12800106406211853027343750000e-01,
-                             3.76122951507568359375000000000e-01, -1.12837910652160644531250000000e+00};
-  const T x2 = pmul(x, x);
-  const T one = pset1<T>(1.0f);
-  const T erfc_small = pmadd(x, ppolevl<T, 5>::run(x2, alpha), one);
-
-  // Return early if we don't need the more expensive approximation for any
-  // entry in a.
-  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
-  if (!predux_any(x_abs_gt_one_mask)) return erfc_small;
-
-  // erfc(x) = exp(-x^2) * 1/x * P(1/x^2) / Q(1/x^2), 1 < x < 9.
-  //
-  // Coefficients for P and Q generated with Rminimax command:
-  //   ./ratapprox --function="erfc(1/sqrt(x))*exp(1/x)/sqrt(x)"
-  //     --dom='[0.01,1]' --type=[3,4] --numF="[SG]" --denF="[SG]" --log
-  //     --dispCoeff="dec"
-  constexpr float gamma[] = {1.0208116471767425537109375e-01f, 4.2920666933059692382812500e-01f,
-                             3.2379078865051269531250000e-01f, 5.3971976041793823242187500e-02f};
-  constexpr float delta[] = {1.7251677811145782470703125e-02f, 3.9137163758277893066406250e-01f,
-                             1.0000000000000000000000000e+00f, 6.2173241376876831054687500e-01f,
-                             9.5662862062454223632812500e-02f};
-  const T x2_lo = twoprod_low(x, x, x2);
-  // Here we use that
-  //   exp(-x^2) = exp(-(x2+x2_lo)^2) ~= exp(-x2)*exp(-x2_lo) ~= exp(-x2)*(1-x2_lo)
-  // since x2_lo < kClamp * eps << 1 in the region we care about. This trick reduces the max error
-  // from 34 ulps to below 5 ulps.
-  const T exp2_hi = pexp(pnegate(x2));
-  const T z = pnmadd(exp2_hi, x2_lo, exp2_hi);
-  const T q2 = preciprocal(x2);
-  const T num = ppolevl<T, 3>::run(q2, gamma);
-  const T denom = pmul(x, ppolevl<T, 4>::run(q2, delta));
-  const T r = pdiv(num, denom);
-  const T maybe_two = pselect(pcmp_lt(x, pset1<T>(0.0f)), pset1<T>(2.0f), pset1<T>(0.0f));
-  const T erfc_large = pmadd(z, r, maybe_two);
-  return pselect(x_abs_gt_one_mask, erfc_large, erfc_small);
-}
-
-// Computes erf(x)/x for |x| <= 1. Used by both erf and erfc implementations.
-// Takes x2 = x^2 as input.
-//
-// PRECONDITION: x2 <= 1.
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T erf_over_x_double_small(const T& x2) {
-  // erf(x)/x =  S(x^2) / T(x^2), x^2 <= 1.
-  //
-  // Coefficients for S and T generated with Rminimax command:
-  //  ./ratapprox --function="erf(x)" --dom='[-1,1]' --type=[9,10]
-  //  --num="odd" --numF="[D]" --den="even" --denF="[D]" --log --dispCoeff="dec"
-  constexpr double alpha[] = {1.9493725660006057018823477644531294572516344487667083740234375e-04,
-                              1.8272566210022942682217328425053892715368419885635375976562500e-03,
-                              4.5303363351690106863856044583371840417385101318359375000000000e-02,
-                              1.4215015503619179981775744181504705920815467834472656250000000e-01,
-                              1.1283791670955125585606992899556644260883331298828125000000000e+00};
-  constexpr double beta[] = {2.0294484101083099089526257108317963684385176748037338256835938e-05,
-                             6.8117805899186819641732970609382391558028757572174072265625000e-04,
-                             1.0582026056098614921752165685120417037978768348693847656250000e-02,
-                             9.3252603143757495374188692949246615171432495117187500000000000e-02,
-                             4.5931062818368939559832142549566924571990966796875000000000000e-01,
-                             1.0};
-  const T num_small = ppolevl<T, 4>::run(x2, alpha);
-  const T denom_small = ppolevl<T, 5>::run(x2, beta);
-  return pdiv(num_small, denom_small);
-}
-
-// erfc(x) = exp(-x^2) * 1/x * P(1/x^2) / Q(1/x^2), 1 < x < 28.
-//
-// Coefficients for P and Q generated with Rminimax command:
-//  ./ratapprox --function="erfc(1/sqrt(x))*exp(1/x)/sqrt(x)"  --dom='[0.0013717,1]' --type=[9,9] --numF="[D]"
-//  --denF="[D]" --log --dispCoeff="dec"
-//
-// PRECONDITION: 1 < x < 28.
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T erfc_double_large(const T& x, const T& x2) {
-  constexpr double gamma[] = {1.5252844933226974316088642158462107545346952974796295166015625e-04,
-                              1.0909912393738931124520519233556115068495273590087890625000000e-02,
-                              1.0628604636755033252537572252549580298364162445068359375000000e-01,
-                              3.3492472973137982217295416376146022230386734008789062500000000e-01,
-                              4.5065776215933289750026347064704168587923049926757812500000000e-01,
-                              2.9433039130294824659017649537418037652969360351562500000000000e-01,
-                              9.8792676360600226170838311645638896152377128601074218750000000e-02,
-                              1.7095935395503719655962981960328761488199234008789062500000000e-02,
-                              1.4249109729504577659398023570247460156679153442382812500000000e-03,
-                              4.4567378313647954771875570045835956989321857690811157226562500e-05};
-  constexpr double delta[] = {2.041985103115789845773520028160419315099716186523437500000000e-03,
-                              5.316030659946043707142493417450168635696172714233398437500000e-02,
-                              3.426242193784684864077405563875799998641014099121093750000000e-01,
-                              8.565637124308049799026321124983951449394226074218750000000000e-01,
-                              1.000000000000000000000000000000000000000000000000000000000000e+00,
-                              5.968805280570776972126623149961233139038085937500000000000000e-01,
-                              1.890922854723317836356244470152887515723705291748046875000000e-01,
-                              3.152505418656005586885981983868987299501895904541015625000000e-02,
-                              2.565085751861882583380047861965067568235099315643310546875000e-03,
-                              7.899362131678837697403017248376499992446042597293853759765625e-05};
-  // Compute exp(-x^2).
-  const T x2_lo = twoprod_low(x, x, x2);
-  // Here we use that
-  //   exp(-x^2) = exp(-(x2+x2_lo)^2) ~= exp(-x2)*exp(-x2_lo) ~= exp(-x2)*(1-x2_lo)
-  // since x2_lo < kClamp *eps << 1 in the region we care about. This trick reduces the max error
-  // from 258 ulps to below 7 ulps.
-  const T exp2_hi = pexp(pnegate(x2));
-  const T z = pnmadd(exp2_hi, x2_lo, exp2_hi);
-  // Compute r = P / Q.
-  const T q2 = preciprocal(x2);
-  const T num_large = ppolevl<T, 9>::run(q2, gamma);
-  const T denom_large = pmul(x, ppolevl<T, 9>::run(q2, delta));
-  const T r = pdiv(num_large, denom_large);
-  const T maybe_two = pselect(pcmp_lt(x, pset1<T>(0.0)), pset1<T>(2.0), pset1<T>(0.0));
-  return pmadd(z, r, maybe_two);
-}
-
-template <>
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erfc<double>::run(const T& x_in) {
-  // Clamp x to [-28:28] beyond which erfc(x) is either two or zero (below the underflow threshold).
-  // This avoids having to deal with twoprod(x,x) producing NaN for sufficiently large x.
-  constexpr double kClamp = 28.0;
-  const T x = pmin(pmax(x_in, pset1<T>(-kClamp)), pset1<T>(kClamp));
-
-  // For |x| < 1, we use erfc(x) = 1 - erf(x).
-  const T x2 = pmul(x, x);
-  const T one = pset1<T>(1.0);
-  const T erfc_small = pnmadd(x, erf_over_x_double_small(x2), one);
-
-  // Return early if we don't need the more expensive approximation for any
-  // entry in a.
-  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
-  if (!predux_any(x_abs_gt_one_mask)) return erfc_small;
-
-  const T erfc_large = erfc_double_large(x, x2);
-  return pselect(x_abs_gt_one_mask, erfc_large, erfc_small);
-}
-
-template <typename T>
-struct erfc_impl {
-  typedef typename unpacket_traits<T>::type Scalar;
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) { return generic_fast_erfc<Scalar>::run(x); }
-};
-
-template <typename Scalar>
-struct erfc_retval {
-  typedef Scalar type;
-};
-
-#if EIGEN_HAS_C99_MATH
-template <>
-struct erfc_impl<float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(const float x) {
-#if defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::erfc(x);
-#else
-    return generic_fast_erfc<float>::run(x);
-#endif
-  }
-};
-
-template <>
-struct erfc_impl<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(const double x) {
-#if defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::erfc(x);
-#else
-    return generic_fast_erfc<double>::run(x);
-#endif
-  }
-};
-#endif  // EIGEN_HAS_C99_MATH
-
-/****************************************************************************
- * Implementation of erf.
- ****************************************************************************/
-
-template <typename Scalar>
-struct generic_fast_erf {
-  template <typename T>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T run(const T& x_in);
-};
-
-/** \internal \returns the error function of \a a (coeff-wise)
-    This uses a 11/10-degree rational interpolantand is accurate to 3 ulp for
-    normalized floats.
-
-    This implementation works on both scalars and SIMD "packets".
-*/
-template <>
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erf<float>::run(const T& x) {
-  // The monomial coefficients of the numerator polynomial (odd).
-  constexpr float alpha[] = {2.123732201653183437883853912353515625e-06f, 2.861979592125862836837768554687500000e-04f,
-                             3.658048342913389205932617187500000000e-03f, 5.243302136659622192382812500000000000e-02f,
-                             1.874160766601562500000000000000000000e-01f, 1.128379106521606445312500000000000000e+00f};
-
-  // The monomial coefficients of the denominator polynomial (even).
-  constexpr float beta[] = {3.89185734093189239501953125000e-05f, 1.14329601638019084930419921875e-03f,
-                            1.47520881146192550659179687500e-02f, 1.12945675849914550781250000000e-01f,
-                            4.99425798654556274414062500000e-01f, 1.0f};
-
-  // Since the polynomials are odd/even, we need x^2.
-  // Since erf(4) == 1 in float, we clamp x^2 to 16 to avoid
-  // computing Inf/Inf below.
-  const T x2 = pmin(pset1<T>(16.0f), pmul(x, x));
-
-  // Evaluate the numerator polynomial p.
-  T p = ppolevl<T, 5>::run(x2, alpha);
-  p = pmul(x, p);
-
-  // Evaluate the denominator polynomial p.
-  T q = ppolevl<T, 5>::run(x2, beta);
-  const T r = pdiv(p, q);
-
-  // Clamp to [-1:1].
-  return pmax(pmin(r, pset1<T>(1.0f)), pset1<T>(-1.0f));
-}
-
-template <>
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_fast_erf<double>::run(const T& x) {
-  T x2 = pmul(x, x);
-  T erf_small = pmul(x, erf_over_x_double_small(x2));
-
-  // Return early if we don't need the more expensive approximation for any
-  // entry in a.
-  const T one = pset1<T>(1.0);
-  const T x_abs_gt_one_mask = pcmp_lt(one, x2);
-  if (!predux_any(x_abs_gt_one_mask)) return erf_small;
-
-  // For |x| > 1, use erf(x) = 1 - erfc(x).
-  const T erf_large = psub(one, erfc_double_large(x, x2));
-  return pselect(x_abs_gt_one_mask, erf_large, erf_small);
-}
-
-template <typename T>
-struct erf_impl {
-  typedef typename unpacket_traits<T>::type Scalar;
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T run(const T& x) { return generic_fast_erf<Scalar>::run(x); }
-};
-
-template <typename Scalar>
-struct erf_retval {
-  typedef Scalar type;
-};
-
-#if EIGEN_HAS_C99_MATH
-template <>
-struct erf_impl<float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float run(const float x) {
-#if defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::erf(x);
-#else
-    return generic_fast_erf<float>::run(x);
-#endif
-  }
-};
-
-template <>
-struct erf_impl<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double run(const double x) {
-#if defined(SYCL_DEVICE_ONLY)
-    return cl::sycl::erf(x);
-#else
-    return generic_fast_erf<double>::run(x);
-#endif
-  }
-};
-#endif  // EIGEN_HAS_C99_MATH
-
-/***************************************************************************
- * Implementation of ndtri.                                                 *
- ****************************************************************************/
-
-/* Inverse of Normal distribution function (modified for Eigen).
- *
- *
- * SYNOPSIS:
- *
- * double x, y, ndtri();
- *
- * x = ndtri( y );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the argument, x, for which the area under the
- * Gaussian probability density function (integrated from
- * minus infinity to x) is equal to y.
- *
- *
- * For small arguments 0 < y < exp(-2), the program computes
- * z = sqrt( -2.0 * log(y) );  then the approximation is
- * x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z).
- * There are two rational functions P/Q, one for 0 < y < exp(-32)
- * and the other for y up to exp(-2).  For larger arguments,
- * w = y - 0.5, and  x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)).
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain        # trials      peak         rms
- *    DEC      0.125, 1         5500       9.5e-17     2.1e-17
- *    DEC      6e-39, 0.135     3500       5.7e-17     1.3e-17
- *    IEEE     0.125, 1        20000       7.2e-16     1.3e-16
- *    IEEE     3e-308, 0.135   50000       4.6e-16     9.8e-17
- *
- *
- * ERROR MESSAGES:
- *
- *   message         condition    value returned
- * ndtri domain       x == 0        -INF
- * ndtri domain       x == 1         INF
- * ndtri domain       x < 0, x > 1   NAN
- */
-/*
-  Cephes Math Library Release 2.2: June, 1992
-  Copyright 1985, 1987, 1992 by Stephen L. Moshier
-  Direct inquiries to 30 Frost Street, Cambridge, MA 02140
-*/
-
-// TODO: Add a cheaper approximation for float.
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T flipsign(const T& should_flipsign, const T& x) {
-  typedef typename unpacket_traits<T>::type Scalar;
-  const T sign_mask = pset1<T>(Scalar(-0.0));
-  T sign_bit = pand<T>(should_flipsign, sign_mask);
-  return pxor<T>(sign_bit, x);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double flipsign<double>(const double& should_flipsign, const double& x) {
-  return should_flipsign == 0 ? x : -x;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float flipsign<float>(const float& should_flipsign, const float& x) {
-  return should_flipsign == 0 ? x : -x;
-}
-
-// We split this computation in to two so that in the scalar path
-// only one branch is evaluated (due to our template specialization of pselect
-// being an if statement.)
-
-template <typename T, typename ScalarType>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_ndtri_gt_exp_neg_two(const T& b) {
-  const ScalarType p0[] = {ScalarType(-5.99633501014107895267e1), ScalarType(9.80010754185999661536e1),
-                           ScalarType(-5.66762857469070293439e1), ScalarType(1.39312609387279679503e1),
-                           ScalarType(-1.23916583867381258016e0)};
-  const ScalarType q0[] = {ScalarType(1.0),
-                           ScalarType(1.95448858338141759834e0),
-                           ScalarType(4.67627912898881538453e0),
-                           ScalarType(8.63602421390890590575e1),
-                           ScalarType(-2.25462687854119370527e2),
-                           ScalarType(2.00260212380060660359e2),
-                           ScalarType(-8.20372256168333339912e1),
-                           ScalarType(1.59056225126211695515e1),
-                           ScalarType(-1.18331621121330003142e0)};
-  const T sqrt2pi = pset1<T>(ScalarType(2.50662827463100050242e0));
-  const T half = pset1<T>(ScalarType(0.5));
-  T c, c2, ndtri_gt_exp_neg_two;
-
-  c = psub(b, half);
-  c2 = pmul(c, c);
-  ndtri_gt_exp_neg_two =
-      pmadd(c, pmul(c2, pdiv(internal::ppolevl<T, 4>::run(c2, p0), internal::ppolevl<T, 8>::run(c2, q0))), c);
-  return pmul(ndtri_gt_exp_neg_two, sqrt2pi);
-}
-
-template <typename T, typename ScalarType>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T generic_ndtri_lt_exp_neg_two(const T& b, const T& should_flipsign) {
-  /* Approximation for interval z = sqrt(-2 log a ) between 2 and 8
-   * i.e., a between exp(-2) = .135 and exp(-32) = 1.27e-14.
-   */
-  const ScalarType p1[] = {ScalarType(4.05544892305962419923e0),   ScalarType(3.15251094599893866154e1),
-                           ScalarType(5.71628192246421288162e1),   ScalarType(4.40805073893200834700e1),
-                           ScalarType(1.46849561928858024014e1),   ScalarType(2.18663306850790267539e0),
-                           ScalarType(-1.40256079171354495875e-1), ScalarType(-3.50424626827848203418e-2),
-                           ScalarType(-8.57456785154685413611e-4)};
-  const ScalarType q1[] = {ScalarType(1.0),
-                           ScalarType(1.57799883256466749731e1),
-                           ScalarType(4.53907635128879210584e1),
-                           ScalarType(4.13172038254672030440e1),
-                           ScalarType(1.50425385692907503408e1),
-                           ScalarType(2.50464946208309415979e0),
-                           ScalarType(-1.42182922854787788574e-1),
-                           ScalarType(-3.80806407691578277194e-2),
-                           ScalarType(-9.33259480895457427372e-4)};
-  /* Approximation for interval z = sqrt(-2 log a ) between 8 and 64
-   * i.e., a between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.
-   */
-  const ScalarType p2[] = {ScalarType(3.23774891776946035970e0),  ScalarType(6.91522889068984211695e0),
-                           ScalarType(3.93881025292474443415e0),  ScalarType(1.33303460815807542389e0),
-                           ScalarType(2.01485389549179081538e-1), ScalarType(1.23716634817820021358e-2),
-                           ScalarType(3.01581553508235416007e-4), ScalarType(2.65806974686737550832e-6),
-                           ScalarType(6.23974539184983293730e-9)};
-  const ScalarType q2[] = {ScalarType(1.0),
-                           ScalarType(6.02427039364742014255e0),
-                           ScalarType(3.67983563856160859403e0),
-                           ScalarType(1.37702099489081330271e0),
-                           ScalarType(2.16236993594496635890e-1),
-                           ScalarType(1.34204006088543189037e-2),
-                           ScalarType(3.28014464682127739104e-4),
-                           ScalarType(2.89247864745380683936e-6),
-                           ScalarType(6.79019408009981274425e-9)};
-  const T eight = pset1<T>(ScalarType(8.0));
-  const T neg_two = pset1<T>(ScalarType(-2));
-  T x, x0, x1, z;
-
-  x = psqrt(pmul(neg_two, plog(b)));
-  x0 = psub(x, pdiv(plog(x), x));
-  z = preciprocal(x);
-  x1 =
-      pmul(z, pselect(pcmp_lt(x, eight), pdiv(internal::ppolevl<T, 8>::run(z, p1), internal::ppolevl<T, 8>::run(z, q1)),
-                      pdiv(internal::ppolevl<T, 8>::run(z, p2), internal::ppolevl<T, 8>::run(z, q2))));
-  return flipsign(should_flipsign, psub(x0, x1));
-}
-
-template <typename T, typename ScalarType>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T generic_ndtri(const T& a) {
-  const T maxnum = pset1<T>(NumTraits<ScalarType>::infinity());
-  const T neg_maxnum = pset1<T>(-NumTraits<ScalarType>::infinity());
-
-  const T zero = pset1<T>(ScalarType(0));
-  const T one = pset1<T>(ScalarType(1));
-  // exp(-2)
-  const T exp_neg_two = pset1<T>(ScalarType(0.13533528323661269189));
-  T b, ndtri, should_flipsign;
-
-  should_flipsign = pcmp_le(a, psub(one, exp_neg_two));
-  b = pselect(should_flipsign, a, psub(one, a));
-
-  ndtri = pselect(pcmp_lt(exp_neg_two, b), generic_ndtri_gt_exp_neg_two<T, ScalarType>(b),
-                  generic_ndtri_lt_exp_neg_two<T, ScalarType>(b, should_flipsign));
-
-  return pselect(pcmp_eq(a, zero), neg_maxnum, pselect(pcmp_eq(one, a), maxnum, ndtri));
-}
-
-template <typename Scalar>
-struct ndtri_retval {
-  typedef Scalar type;
-};
-
-#if !EIGEN_HAS_C99_MATH
-
-template <typename Scalar>
-struct ndtri_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) { return Scalar(0); }
-};
-
-#else
-
-template <typename Scalar>
-struct ndtri_impl {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar x) { return generic_ndtri<Scalar, Scalar>(x); }
-};
-
-#endif  // EIGEN_HAS_C99_MATH
-
-/**************************************************************************************************************
- * Implementation of igammac (complemented incomplete gamma integral), based on Cephes but requires C++11/C99 *
- **************************************************************************************************************/
-
-template <typename Scalar>
-struct igammac_retval {
-  typedef Scalar type;
-};
-
-// NOTE: cephes_helper is also used to implement zeta
-template <typename Scalar>
-struct cephes_helper {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar machep() {
-    eigen_assert(false && "machep not supported for this type");
-    return 0.0;
-  }
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar big() {
-    eigen_assert(false && "big not supported for this type");
-    return 0.0;
-  }
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar biginv() {
-    eigen_assert(false && "biginv not supported for this type");
-    return 0.0;
-  }
-};
-
-template <>
-struct cephes_helper<float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float machep() {
-    return NumTraits<float>::epsilon() / 2;  // 1.0 - machep == 1.0
-  }
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float big() {
-    // use epsneg (1.0 - epsneg == 1.0)
-    return 1.0f / (NumTraits<float>::epsilon() / 2);
-  }
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float biginv() {
-    // epsneg
-    return machep();
-  }
-};
-
-template <>
-struct cephes_helper<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double machep() {
-    return NumTraits<double>::epsilon() / 2;  // 1.0 - machep == 1.0
-  }
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double big() { return 1.0 / NumTraits<double>::epsilon(); }
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double biginv() {
-    // inverse of eps
-    return NumTraits<double>::epsilon();
-  }
-};
-
-enum IgammaComputationMode { VALUE, DERIVATIVE, SAMPLE_DERIVATIVE };
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar main_igamma_term(Scalar a, Scalar x) {
-  /* Compute  x**a * exp(-x) / gamma(a)  */
-  Scalar logax = a * numext::log(x) - x - lgamma_impl<Scalar>::run(a);
-  if (logax < -numext::log(NumTraits<Scalar>::highest()) ||
-      // Assuming x and a aren't Nan.
-      (numext::isnan)(logax)) {
-    return Scalar(0);
-  }
-  return numext::exp(logax);
-}
-
-template <typename Scalar, IgammaComputationMode mode>
-EIGEN_DEVICE_FUNC int igamma_num_iterations() {
-  /* Returns the maximum number of internal iterations for igamma computation.
-   */
-  if (mode == VALUE) {
-    return 2000;
-  }
-
-  if (internal::is_same<Scalar, float>::value) {
-    return 200;
-  } else if (internal::is_same<Scalar, double>::value) {
-    return 500;
-  } else {
-    return 2000;
-  }
-}
-
-template <typename Scalar, IgammaComputationMode mode>
-struct igammac_cf_impl {
-  /* Computes igamc(a, x) or derivative (depending on the mode)
-   * using the continued fraction expansion of the complementary
-   * incomplete Gamma function.
-   *
-   * Preconditions:
-   *   a > 0
-   *   x >= 1
-   *   x >= a
-   */
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
-    const Scalar zero = 0;
-    const Scalar one = 1;
-    const Scalar two = 2;
-    const Scalar machep = cephes_helper<Scalar>::machep();
-    const Scalar big = cephes_helper<Scalar>::big();
-    const Scalar biginv = cephes_helper<Scalar>::biginv();
-
-    if ((numext::isinf)(x)) {
-      return zero;
-    }
-
-    Scalar ax = main_igamma_term<Scalar>(a, x);
-    // This is independent of mode. If this value is zero,
-    // then the function value is zero. If the function value is zero,
-    // then we are in a neighborhood where the function value evaluates to zero,
-    // so the derivative is zero.
-    if (ax == zero) {
-      return zero;
-    }
-
-    // continued fraction
-    Scalar y = one - a;
-    Scalar z = x + y + one;
-    Scalar c = zero;
-    Scalar pkm2 = one;
-    Scalar qkm2 = x;
-    Scalar pkm1 = x + one;
-    Scalar qkm1 = z * x;
-    Scalar ans = pkm1 / qkm1;
-
-    Scalar dpkm2_da = zero;
-    Scalar dqkm2_da = zero;
-    Scalar dpkm1_da = zero;
-    Scalar dqkm1_da = -x;
-    Scalar dans_da = (dpkm1_da - ans * dqkm1_da) / qkm1;
-
-    for (int i = 0; i < igamma_num_iterations<Scalar, mode>(); i++) {
-      c += one;
-      y += one;
-      z += two;
-
-      Scalar yc = y * c;
-      Scalar pk = pkm1 * z - pkm2 * yc;
-      Scalar qk = qkm1 * z - qkm2 * yc;
-
-      Scalar dpk_da = dpkm1_da * z - pkm1 - dpkm2_da * yc + pkm2 * c;
-      Scalar dqk_da = dqkm1_da * z - qkm1 - dqkm2_da * yc + qkm2 * c;
-
-      if (qk != zero) {
-        Scalar ans_prev = ans;
-        ans = pk / qk;
-
-        Scalar dans_da_prev = dans_da;
-        dans_da = (dpk_da - ans * dqk_da) / qk;
-
-        if (mode == VALUE) {
-          if (numext::abs(ans_prev - ans) <= machep * numext::abs(ans)) {
-            break;
-          }
-        } else {
-          if (numext::abs(dans_da - dans_da_prev) <= machep) {
-            break;
-          }
-        }
-      }
-
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      dpkm2_da = dpkm1_da;
-      dpkm1_da = dpk_da;
-      dqkm2_da = dqkm1_da;
-      dqkm1_da = dqk_da;
-
-      if (numext::abs(pk) > big) {
-        pkm2 *= biginv;
-        pkm1 *= biginv;
-        qkm2 *= biginv;
-        qkm1 *= biginv;
-
-        dpkm2_da *= biginv;
-        dpkm1_da *= biginv;
-        dqkm2_da *= biginv;
-        dqkm1_da *= biginv;
-      }
-    }
-
-    /* Compute  x**a * exp(-x) / gamma(a)  */
-    Scalar dlogax_da = numext::log(x) - digamma_impl<Scalar>::run(a);
-    Scalar dax_da = ax * dlogax_da;
-
-    switch (mode) {
-      case VALUE:
-        return ans * ax;
-      case DERIVATIVE:
-        return ans * dax_da + dans_da * ax;
-      case SAMPLE_DERIVATIVE:
-      default:  // this is needed to suppress clang warning
-        return -(dans_da + ans * dlogax_da) * x;
-    }
-  }
-};
-
-template <typename Scalar, IgammaComputationMode mode>
-struct igamma_series_impl {
-  /* Computes igam(a, x) or its derivative (depending on the mode)
-   * using the series expansion of the incomplete Gamma function.
-   *
-   * Preconditions:
-   *   x > 0
-   *   a > 0
-   *   !(x > 1 && x > a)
-   */
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
-    const Scalar zero = 0;
-    const Scalar one = 1;
-    const Scalar machep = cephes_helper<Scalar>::machep();
-
-    Scalar ax = main_igamma_term<Scalar>(a, x);
-
-    // This is independent of mode. If this value is zero,
-    // then the function value is zero. If the function value is zero,
-    // then we are in a neighborhood where the function value evaluates to zero,
-    // so the derivative is zero.
-    if (ax == zero) {
-      return zero;
-    }
-
-    ax /= a;
-
-    /* power series */
-    Scalar r = a;
-    Scalar c = one;
-    Scalar ans = one;
-
-    Scalar dc_da = zero;
-    Scalar dans_da = zero;
-
-    for (int i = 0; i < igamma_num_iterations<Scalar, mode>(); i++) {
-      r += one;
-      Scalar term = x / r;
-      Scalar dterm_da = -x / (r * r);
-      dc_da = term * dc_da + dterm_da * c;
-      dans_da += dc_da;
-      c *= term;
-      ans += c;
-
-      if (mode == VALUE) {
-        if (c <= machep * ans) {
-          break;
-        }
-      } else {
-        if (numext::abs(dc_da) <= machep * numext::abs(dans_da)) {
-          break;
-        }
-      }
-    }
-
-    Scalar dlogax_da = numext::log(x) - digamma_impl<Scalar>::run(a + one);
-    Scalar dax_da = ax * dlogax_da;
-
-    switch (mode) {
-      case VALUE:
-        return ans * ax;
-      case DERIVATIVE:
-        return ans * dax_da + dans_da * ax;
-      case SAMPLE_DERIVATIVE:
-      default:  // this is needed to suppress clang warning
-        return -(dans_da + ans * dlogax_da) * x / a;
-    }
-  }
-};
-
-#if !EIGEN_HAS_C99_MATH
-
-template <typename Scalar>
-struct igammac_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) { return Scalar(0); }
-};
-
-#else
-
-template <typename Scalar>
-struct igammac_impl {
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
-    /*  igamc()
-     *
-     *	Incomplete gamma integral (modified for Eigen)
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double a, x, y, igamc();
-     *
-     * y = igamc( a, x );
-     *
-     * DESCRIPTION:
-     *
-     * The function is defined by
-     *
-     *
-     *  igamc(a,x)   =   1 - igam(a,x)
-     *
-     *                            inf.
-     *                              -
-     *                     1       | |  -t  a-1
-     *               =   -----     |   e   t   dt.
-     *                    -      | |
-     *                   | (a)    -
-     *                             x
-     *
-     *
-     * In this implementation both arguments must be positive.
-     * The integral is evaluated by either a power series or
-     * continued fraction expansion, depending on the relative
-     * values of a and x.
-     *
-     * ACCURACY (float):
-     *
-     *                      Relative error:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,30        30000       7.8e-6      5.9e-7
-     *
-     *
-     * ACCURACY (double):
-     *
-     * Tested at random a, x.
-     *                a         x                      Relative error:
-     * arithmetic   domain   domain     # trials      peak         rms
-     *    IEEE     0.5,100   0,100      200000       1.9e-14     1.7e-15
-     *    IEEE     0.01,0.5  0,100      200000       1.4e-13     1.6e-15
-     *
-     */
-    /*
-      Cephes Math Library Release 2.2: June, 1992
-      Copyright 1985, 1987, 1992 by Stephen L. Moshier
-      Direct inquiries to 30 Frost Street, Cambridge, MA 02140
-    */
-    const Scalar zero = 0;
-    const Scalar one = 1;
-    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
-
-    if ((x < zero) || (a <= zero)) {
-      // domain error
-      return nan;
-    }
-
-    if ((numext::isnan)(a) || (numext::isnan)(x)) {  // propagate nans
-      return nan;
-    }
-
-    if ((x < one) || (x < a)) {
-      // Clamp to [0,1] since 1-igamma can produce tiny negative values
-      // due to floating-point cancellation for extreme arguments.
-      return numext::mini(one, numext::maxi(zero, one - igamma_series_impl<Scalar, VALUE>::run(a, x)));
-    }
-
-    return igammac_cf_impl<Scalar, VALUE>::run(a, x);
-  }
-};
-
-#endif  // EIGEN_HAS_C99_MATH
-
-/************************************************************************************************
- * Implementation of igamma (incomplete gamma integral), based on Cephes but requires C++11/C99 *
- ************************************************************************************************/
-
-#if !EIGEN_HAS_C99_MATH
-
-template <typename Scalar, IgammaComputationMode mode>
-struct igamma_generic_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar a, Scalar x) { return Scalar(0); }
-};
-
-#else
-
-template <typename Scalar, IgammaComputationMode mode>
-struct igamma_generic_impl {
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar a, Scalar x) {
-    /* Depending on the mode, returns
-     * - VALUE: incomplete Gamma function igamma(a, x)
-     * - DERIVATIVE: derivative of incomplete Gamma function d/da igamma(a, x)
-     * - SAMPLE_DERIVATIVE: implicit derivative of a Gamma random variable
-     * x ~ Gamma(x | a, 1), dx/da = -1 / Gamma(x | a, 1) * d igamma(a, x) / dx
-     *
-     * Derivatives are implemented by forward-mode differentiation.
-     */
-    const Scalar zero = 0;
-    const Scalar one = 1;
-    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
-
-    if (x == zero) return zero;
-
-    if ((x < zero) || (a <= zero)) {  // domain error
-      return nan;
-    }
-
-    if ((numext::isnan)(a) || (numext::isnan)(x)) {  // propagate nans
-      return nan;
-    }
-
-    if ((x > one) && (x > a)) {
-      Scalar ret = igammac_cf_impl<Scalar, mode>::run(a, x);
-      if (mode == VALUE) {
-        // Clamp to [0,1] since 1-igammac can produce tiny negative values
-        // due to floating-point cancellation for extreme arguments.
-        return numext::mini(one, numext::maxi(zero, one - ret));
-      } else {
-        return -ret;
-      }
-    }
-
-    Scalar ret = igamma_series_impl<Scalar, mode>::run(a, x);
-    if (mode == VALUE) {
-      // Clamp to [0,1] since accumulated series terms can slightly exceed 1.0
-      // due to floating-point rounding for extreme arguments.
-      return numext::mini(one, numext::maxi(zero, ret));
-    }
-    return ret;
-  }
-};
-
-#endif  // EIGEN_HAS_C99_MATH
-
-template <typename Scalar>
-struct igamma_retval {
-  typedef Scalar type;
-};
-
-template <typename Scalar>
-struct igamma_impl : igamma_generic_impl<Scalar, VALUE> {
-  /* igam()
-   * Incomplete gamma integral.
-   *
-   * The CDF of Gamma(a, 1) random variable at the point x.
-   *
-   * Accuracy estimation. For each a in [10^-2, 10^-1...10^3] we sample
-   * 50 Gamma random variables x ~ Gamma(x | a, 1), a total of 300 points.
-   * The ground truth is computed by mpmath. Mean absolute error:
-   * float: 1.26713e-05
-   * double: 2.33606e-12
-   *
-   * Cephes documentation below.
-   *
-   * SYNOPSIS:
-   *
-   * double a, x, y, igam();
-   *
-   * y = igam( a, x );
-   *
-   * DESCRIPTION:
-   *
-   * The function is defined by
-   *
-   *                           x
-   *                            -
-   *                   1       | |  -t  a-1
-   *  igam(a,x)  =   -----     |   e   t   dt.
-   *                  -      | |
-   *                 | (a)    -
-   *                           0
-   *
-   *
-   * In this implementation both arguments must be positive.
-   * The integral is evaluated by either a power series or
-   * continued fraction expansion, depending on the relative
-   * values of a and x.
-   *
-   * ACCURACY (double):
-   *
-   *                      Relative error:
-   * arithmetic   domain     # trials      peak         rms
-   *    IEEE      0,30       200000       3.6e-14     2.9e-15
-   *    IEEE      0,100      300000       9.9e-14     1.5e-14
-   *
-   *
-   * ACCURACY (float):
-   *
-   *                      Relative error:
-   * arithmetic   domain     # trials      peak         rms
-   *    IEEE      0,30        20000       7.8e-6      5.9e-7
-   *
-   */
-  /*
-    Cephes Math Library Release 2.2: June, 1992
-    Copyright 1985, 1987, 1992 by Stephen L. Moshier
-    Direct inquiries to 30 Frost Street, Cambridge, MA 02140
-  */
-
-  /* left tail of incomplete gamma function:
-   *
-   *          inf.      k
-   *   a  -x   -       x
-   *  x  e     >   ----------
-   *           -     -
-   *          k=0   | (a+k+1)
-   *
-   */
-};
-
-template <typename Scalar>
-struct igamma_der_a_retval : igamma_retval<Scalar> {};
-
-template <typename Scalar>
-struct igamma_der_a_impl : igamma_generic_impl<Scalar, DERIVATIVE> {
-  /* Derivative of the incomplete Gamma function with respect to a.
-   *
-   * Computes d/da igamma(a, x) by forward differentiation of the igamma code.
-   *
-   * Accuracy estimation. For each a in [10^-2, 10^-1...10^3] we sample
-   * 50 Gamma random variables x ~ Gamma(x | a, 1), a total of 300 points.
-   * The ground truth is computed by mpmath. Mean absolute error:
-   * float: 6.17992e-07
-   * double: 4.60453e-12
-   *
-   * Reference:
-   * R. Moore. "Algorithm AS 187: Derivatives of the incomplete gamma
-   * integral". Journal of the Royal Statistical Society. 1982
-   */
-};
-
-template <typename Scalar>
-struct gamma_sample_der_alpha_retval : igamma_retval<Scalar> {};
-
-template <typename Scalar>
-struct gamma_sample_der_alpha_impl : igamma_generic_impl<Scalar, SAMPLE_DERIVATIVE> {
-  /* Derivative of a Gamma random variable sample with respect to alpha.
-   *
-   * Consider a sample of a Gamma random variable with the concentration
-   * parameter alpha: sample ~ Gamma(alpha, 1). The reparameterization
-   * derivative that we want to compute is dsample / dalpha =
-   * d igammainv(alpha, u) / dalpha, where u = igamma(alpha, sample).
-   * However, this formula is numerically unstable and expensive, so instead
-   * we use implicit differentiation:
-   *
-   * igamma(alpha, sample) = u, where u ~ Uniform(0, 1).
-   * Apply d / dalpha to both sides:
-   * d igamma(alpha, sample) / dalpha
-   *     + d igamma(alpha, sample) / dsample * dsample/dalpha  = 0
-   * d igamma(alpha, sample) / dalpha
-   *     + Gamma(sample | alpha, 1) dsample / dalpha = 0
-   * dsample/dalpha = - (d igamma(alpha, sample) / dalpha)
-   *                   / Gamma(sample | alpha, 1)
-   *
-   * Here Gamma(sample | alpha, 1) is the PDF of the Gamma distribution
-   * (note that the derivative of the CDF w.r.t. sample is the PDF).
-   * See the reference below for more details.
-   *
-   * The derivative of igamma(alpha, sample) is computed by forward
-   * differentiation of the igamma code. Division by the Gamma PDF is performed
-   * in the same code, increasing the accuracy and speed due to cancellation
-   * of some terms.
-   *
-   * Accuracy estimation. For each alpha in [10^-2, 10^-1...10^3] we sample
-   * 50 Gamma random variables sample ~ Gamma(sample | alpha, 1), a total of 300
-   * points. The ground truth is computed by mpmath. Mean absolute error:
-   * float: 2.1686e-06
-   * double: 1.4774e-12
-   *
-   * Reference:
-   * M. Figurnov, S. Mohamed, A. Mnih "Implicit Reparameterization Gradients".
-   * 2018
-   */
-};
-
-/*****************************************************************************
- * Implementation of Riemann zeta function of two arguments, based on Cephes *
- *****************************************************************************/
-
-template <typename Scalar>
-struct zeta_retval {
-  typedef Scalar type;
-};
-
-template <typename Scalar>
-struct zeta_impl_series {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(const Scalar) { return Scalar(0); }
-};
-
-template <>
-struct zeta_impl_series<float> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool run(float& a, float& b, float& s, const float x,
-                                                        const float machep) {
-    int i = 0;
-    while (i < 9) {
-      i += 1;
-      a += 1.0f;
-      b = numext::pow(a, -x);
-      s += b;
-      if (numext::abs(b / s) < machep) return true;
-    }
-
-    // Return whether we are done
-    return false;
-  }
-};
-
-template <>
-struct zeta_impl_series<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE bool run(double& a, double& b, double& s, const double x,
-                                                        const double machep) {
-    int i = 0;
-    while ((i < 9) || (a <= 9.0)) {
-      i += 1;
-      a += 1.0;
-      b = numext::pow(a, -x);
-      s += b;
-      if (numext::abs(b / s) < machep) return true;
-    }
-
-    // Return whether we are done
-    return false;
-  }
-};
-
-template <typename Scalar>
-struct zeta_impl {
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar x, Scalar q) {
-    /*							zeta.c
-     *
-     *	Riemann zeta function of two arguments
-     *
-     *
-     *
-     * SYNOPSIS:
-     *
-     * double x, q, y, zeta();
-     *
-     * y = zeta( x, q );
-     *
-     *
-     *
-     * DESCRIPTION:
-     *
-     *
-     *
-     *                 inf.
-     *                  -        -x
-     *   zeta(x,q)  =   >   (k+q)
-     *                  -
-     *                 k=0
-     *
-     * where x > 1 and q is not a negative integer or zero.
-     * The Euler-Maclaurin summation formula is used to obtain
-     * the expansion
-     *
-     *                n
-     *                -       -x
-     * zeta(x,q)  =   >  (k+q)
-     *                -
-     *               k=1
-     *
-     *           1-x                 inf.  B   x(x+1)...(x+2j)
-     *      (n+q)           1         -     2j
-     *  +  ---------  -  -------  +   >    --------------------
-     *        x-1              x      -                   x+2j+1
-     *                   2(n+q)      j=1       (2j)! (n+q)
-     *
-     * where the B2j are Bernoulli numbers.  Note that (see zetac.c)
-     * zeta(x,1) = zetac(x) + 1.
-     *
-     *
-     *
-     * ACCURACY:
-     *
-     * Relative error for single precision:
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,25        10000       6.9e-7      1.0e-7
-     *
-     * Large arguments may produce underflow in powf(), in which
-     * case the results are inaccurate.
-     *
-     * REFERENCE:
-     *
-     * Gradshteyn, I. S., and I. M. Ryzhik, Tables of Integrals,
-     * Series, and Products, p. 1073; Academic Press, 1980.
-     *
-     */
-
-    int i;
-    Scalar p, r, a, b, k, s, t, w;
-
-    const Scalar A[] = {
-        Scalar(12.0),
-        Scalar(-720.0),
-        Scalar(30240.0),
-        Scalar(-1209600.0),
-        Scalar(47900160.0),
-        Scalar(-1.8924375803183791606e9), /*1.307674368e12/691*/
-        Scalar(7.47242496e10),
-        Scalar(-2.950130727918164224e12),  /*1.067062284288e16/3617*/
-        Scalar(1.1646782814350067249e14),  /*5.109094217170944e18/43867*/
-        Scalar(-4.5979787224074726105e15), /*8.028576626982912e20/174611*/
-        Scalar(1.8152105401943546773e17),  /*1.5511210043330985984e23/854513*/
-        Scalar(-7.1661652561756670113e18)  /*1.6938241367317436694528e27/236364091*/
-    };
-
-    const Scalar maxnum = NumTraits<Scalar>::infinity();
-    const Scalar zero = Scalar(0.0), half = Scalar(0.5), one = Scalar(1.0);
-    const Scalar machep = cephes_helper<Scalar>::machep();
-    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
-
-    if (x == one) return maxnum;
-
-    if (x < one) {
-      return nan;
-    }
-
-    if (q <= zero) {
-      if (q == numext::floor(q)) {
-        if (numext::rint(Scalar(0.5) * x) == Scalar(0.5) * x) {
-          return maxnum;
-        } else {
-          return nan;
-        }
-      }
-      p = x;
-      r = numext::floor(p);
-      if (p != r) return nan;
-    }
-
-    /* Permit negative q but continue sum until n+q > +9 .
-     * This case should be handled by a reflection formula.
-     * If q<0 and x is an integer, there is a relation to
-     * the polygamma function.
-     */
-    s = numext::pow(q, -x);
-    a = q;
-    b = zero;
-    // Run the summation in a helper function that is specific to the floating precision
-    if (zeta_impl_series<Scalar>::run(a, b, s, x, machep)) {
-      return s;
-    }
-
-    // If b is zero, then the tail sum will also end up being zero.
-    // Exiting early here can prevent NaNs for some large inputs, where
-    // the tail sum computed below has term `a` which can overflow to `inf`.
-    if (numext::equal_strict(b, zero)) {
-      return s;
-    }
-
-    w = a;
-    s += b * w / (x - one);
-    s -= half * b;
-    a = one;
-    k = zero;
-
-    for (i = 0; i < 12; i++) {
-      a *= x + k;
-      b /= w;
-      t = a * b / A[i];
-      s = s + t;
-      t = numext::abs(t / s);
-      if (t < machep) {
-        break;
-      }
-      k += one;
-      a *= x + k;
-      b /= w;
-      k += one;
-    }
-    return s;
-  }
-};
-
-/****************************************************************************
- * Implementation of polygamma function, requires C++11/C99                 *
- ****************************************************************************/
-
-template <typename Scalar>
-struct polygamma_retval {
-  typedef Scalar type;
-};
-
-#if !EIGEN_HAS_C99_MATH
-
-template <typename Scalar>
-struct polygamma_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar n, Scalar x) { return Scalar(0); }
-};
-
-#else
-
-template <typename Scalar>
-struct polygamma_impl {
-  EIGEN_DEVICE_FUNC static Scalar run(Scalar n, Scalar x) {
-    Scalar zero = 0.0, one = 1.0;
-    Scalar nplus = n + one;
-    const Scalar nan = NumTraits<Scalar>::quiet_NaN();
-
-    // Check that n is a non-negative integer
-    if (numext::floor(n) != n || n < zero) {
-      return nan;
-    }
-    // Just return the digamma function for n = 0
-    else if (n == zero) {
-      return digamma_impl<Scalar>::run(x);
-    }
-    // Use the same implementation as scipy
-    else {
-      Scalar factorial = numext::exp(lgamma_impl<Scalar>::run(nplus));
-      return numext::pow(-one, nplus) * factorial * zeta_impl<Scalar>::run(nplus, x);
-    }
-  }
-};
-
-#endif  // EIGEN_HAS_C99_MATH
-
-/************************************************************************************************
- * Implementation of betainc (incomplete beta integral), based on Cephes but requires C++11/C99 *
- ************************************************************************************************/
-
-template <typename Scalar>
-struct betainc_retval {
-  typedef Scalar type;
-};
-
-#if !EIGEN_HAS_C99_MATH
-
-template <typename Scalar>
-struct betainc_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar a, Scalar b, Scalar x) { return Scalar(0); }
-};
-
-#else
-
-template <typename Scalar>
-struct betainc_impl {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, Scalar>::value == false), THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar, Scalar, Scalar) {
-    /*	betaincf.c
-     *
-     *	Incomplete beta integral
-     *
-     *
-     * SYNOPSIS:
-     *
-     * float a, b, x, y, betaincf();
-     *
-     * y = betaincf( a, b, x );
-     *
-     *
-     * DESCRIPTION:
-     *
-     * Returns incomplete beta integral of the arguments, evaluated
-     * from zero to x.  The function is defined as
-     *
-     *                  x
-     *     -            -
-     *    | (a+b)      | |  a-1     b-1
-     *  -----------    |   t   (1-t)   dt.
-     *   -     -     | |
-     *  | (a) | (b)   -
-     *                 0
-     *
-     * The domain of definition is 0 <= x <= 1.  In this
-     * implementation a and b are restricted to positive values.
-     * The integral from x to 1 may be obtained by the symmetry
-     * relation
-     *
-     *    1 - betainc( a, b, x )  =  betainc( b, a, 1-x ).
-     *
-     * The integral is evaluated by a continued fraction expansion.
-     * If a < 1, the function calls itself recursively after a
-     * transformation to increase a to a+1.
-     *
-     * ACCURACY (float):
-     *
-     * Tested at random points (a,b,x) with a and b in the indicated
-     * interval and x between 0 and 1.
-     *
-     * arithmetic   domain     # trials      peak         rms
-     * Relative error:
-     *    IEEE       0,30       10000       3.7e-5      5.1e-6
-     *    IEEE       0,100      10000       1.7e-4      2.5e-5
-     * The useful domain for relative error is limited by underflow
-     * of the single precision exponential function.
-     * Absolute error:
-     *    IEEE       0,30      100000       2.2e-5      9.6e-7
-     *    IEEE       0,100      10000       6.5e-5      3.7e-6
-     *
-     * Larger errors may occur for extreme ratios of a and b.
-     *
-     * ACCURACY (double):
-     * arithmetic   domain     # trials      peak         rms
-     *    IEEE      0,5         10000       6.9e-15     4.5e-16
-     *    IEEE      0,85       250000       2.2e-13     1.7e-14
-     *    IEEE      0,1000      30000       5.3e-12     6.3e-13
-     *    IEEE      0,10000    250000       9.3e-11     7.1e-12
-     *    IEEE      0,100000    10000       8.7e-10     4.8e-11
-     * Outputs smaller than the IEEE gradual underflow threshold
-     * were excluded from these statistics.
-     *
-     * ERROR MESSAGES:
-     *   message         condition      value returned
-     * incbet domain      x<0, x>1          nan
-     * incbet underflow                     nan
-     */
-    return Scalar(0);
-  }
-};
-
-/* Continued fraction expansion #1 for incomplete beta integral (small_branch = True)
- * Continued fraction expansion #2 for incomplete beta integral (small_branch = False)
- */
-template <typename Scalar>
-struct incbeta_cfe {
-  EIGEN_STATIC_ASSERT((internal::is_same<Scalar, float>::value || internal::is_same<Scalar, double>::value),
-                      THIS_TYPE_IS_NOT_SUPPORTED)
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Scalar run(Scalar a, Scalar b, Scalar x, bool small_branch) {
-    const Scalar big = cephes_helper<Scalar>::big();
-    const Scalar machep = cephes_helper<Scalar>::machep();
-    const Scalar biginv = cephes_helper<Scalar>::biginv();
-
-    const Scalar zero = 0;
-    const Scalar one = 1;
-    const Scalar two = 2;
-
-    Scalar xk, pk, pkm1, pkm2, qk, qkm1, qkm2;
-    Scalar k1, k2, k3, k4, k5, k6, k7, k8, k26update;
-    Scalar ans;
-    int n;
-
-    const int num_iters = (internal::is_same<Scalar, float>::value) ? 100 : 300;
-    const Scalar thresh = (internal::is_same<Scalar, float>::value) ? machep : Scalar(3) * machep;
-    Scalar r = (internal::is_same<Scalar, float>::value) ? zero : one;
-
-    if (small_branch) {
-      k1 = a;
-      k2 = a + b;
-      k3 = a;
-      k4 = a + one;
-      k5 = one;
-      k6 = b - one;
-      k7 = k4;
-      k8 = a + two;
-      k26update = one;
-    } else {
-      k1 = a;
-      k2 = b - one;
-      k3 = a;
-      k4 = a + one;
-      k5 = one;
-      k6 = a + b;
-      k7 = a + one;
-      k8 = a + two;
-      k26update = -one;
-      x = x / (one - x);
-    }
-
-    pkm2 = zero;
-    qkm2 = one;
-    pkm1 = one;
-    qkm1 = one;
-    ans = one;
-    n = 0;
-
-    do {
-      xk = -(x * k1 * k2) / (k3 * k4);
-      pk = pkm1 + pkm2 * xk;
-      qk = qkm1 + qkm2 * xk;
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      xk = (x * k5 * k6) / (k7 * k8);
-      pk = pkm1 + pkm2 * xk;
-      qk = qkm1 + qkm2 * xk;
-      pkm2 = pkm1;
-      pkm1 = pk;
-      qkm2 = qkm1;
-      qkm1 = qk;
-
-      if (qk != zero) {
-        r = pk / qk;
-        if (numext::abs(ans - r) < numext::abs(r) * thresh) {
-          return r;
-        }
-        ans = r;
-      }
-
-      k1 += one;
-      k2 += k26update;
-      k3 += two;
-      k4 += two;
-      k5 += one;
-      k6 -= k26update;
-      k7 += two;
-      k8 += two;
-
-      if ((numext::abs(qk) + numext::abs(pk)) > big) {
-        pkm2 *= biginv;
-        pkm1 *= biginv;
-        qkm2 *= biginv;
-        qkm1 *= biginv;
-      }
-      if ((numext::abs(qk) < biginv) || (numext::abs(pk) < biginv)) {
-        pkm2 *= big;
-        pkm1 *= big;
-        qkm2 *= big;
-        qkm1 *= big;
-      }
-    } while (++n < num_iters);
-
-    return ans;
-  }
-};
-
-/* Helper functions depending on the Scalar type */
-template <typename Scalar>
-struct betainc_helper {};
-
-template <>
-struct betainc_helper<float> {
-  /* Core implementation, assumes a large (> 1.0) */
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float incbsa(float aa, float bb, float xx) {
-    float ans, a, b, t, x, onemx;
-    bool reversed_a_b = false;
-
-    onemx = 1.0f - xx;
-
-    /* see if x is greater than the mean */
-    if (xx > (aa / (aa + bb))) {
-      reversed_a_b = true;
-      a = bb;
-      b = aa;
-      t = xx;
-      x = onemx;
-    } else {
-      a = aa;
-      b = bb;
-      t = onemx;
-      x = xx;
-    }
-
-    /* Choose expansion for optimal convergence */
-    if (b > 10.0f) {
-      if (numext::abs(b * x / a) < 0.3f) {
-        t = betainc_helper<float>::incbps(a, b, x);
-        if (reversed_a_b) t = 1.0f - t;
-        return t;
-      }
-    }
-
-    ans = x * (a + b - 2.0f) / (a - 1.0f);
-    if (ans < 1.0f) {
-      ans = incbeta_cfe<float>::run(a, b, x, true /* small_branch */);
-      t = b * numext::log(t);
-    } else {
-      ans = incbeta_cfe<float>::run(a, b, x, false /* small_branch */);
-      t = (b - 1.0f) * numext::log(t);
-    }
-
-    t += a * numext::log(x) + lgamma_impl<float>::run(a + b) - lgamma_impl<float>::run(a) - lgamma_impl<float>::run(b);
-    t += numext::log(ans / a);
-    t = numext::exp(t);
-
-    if (reversed_a_b) t = 1.0f - t;
-    return t;
-  }
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE float incbps(float a, float b, float x) {
-    float t, u, y, s;
-    const float machep = cephes_helper<float>::machep();
-
-    y = a * numext::log(x) + (b - 1.0f) * numext::log1p(-x) - numext::log(a);
-    y -= lgamma_impl<float>::run(a) + lgamma_impl<float>::run(b);
-    y += lgamma_impl<float>::run(a + b);
-
-    t = x / (1.0f - x);
-    s = 0.0f;
-    u = 1.0f;
-    do {
-      b -= 1.0f;
-      if (b == 0.0f) {
-        break;
-      }
-      a += 1.0f;
-      u *= t * b / a;
-      s += u;
-    } while (numext::abs(u) > machep);
-
-    return numext::exp(y) * (1.0f + s);
-  }
-};
-
-template <>
-struct betainc_impl<float> {
-  EIGEN_DEVICE_FUNC static float run(float a, float b, float x) {
-    const float nan = NumTraits<float>::quiet_NaN();
-    float ans, t;
-
-    if (a == 0.0f && b == 0.0f) return nan;
-    if (x < 0.0f || x > 1.0f) return nan;
-    if (a < 0.0f) return nan;
-    if (b < 0.0f) return nan;
-    if (a == 0.0f) return 1.0f;
-    if (b == 0.0f) return 0.0f;
-    if (x == 0.0f) return 0.0f;
-    if (x == 1.0f) return 1.0f;
-    // mtherr("betaincf", DOMAIN);
-
-    /* transformation for small aa */
-    if (a <= 1.0f) {
-      ans = betainc_helper<float>::incbsa(a + 1.0f, b, x);
-      t = a * numext::log(x) + b * numext::log1p(-x) + lgamma_impl<float>::run(a + b) -
-          lgamma_impl<float>::run(a + 1.0f) - lgamma_impl<float>::run(b);
-      return (ans + numext::exp(t));
-    } else {
-      return betainc_helper<float>::incbsa(a, b, x);
-    }
-  }
-};
-
-template <>
-struct betainc_helper<double> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE double incbps(double a, double b, double x) {
-    const double machep = cephes_helper<double>::machep();
-
-    double s, t, u, v, n, t1, z, ai;
-
-    ai = 1.0 / a;
-    u = (1.0 - b) * x;
-    v = u / (a + 1.0);
-    t1 = v;
-    t = u;
-    n = 2.0;
-    s = 0.0;
-    z = machep * ai;
-    while (numext::abs(v) > z) {
-      u = (n - b) * x / n;
-      t *= u;
-      v = t / (a + n);
-      s += v;
-      n += 1.0;
-    }
-    s += t1;
-    s += ai;
-
-    u = a * numext::log(x);
-    // TODO: gamma() is not directly implemented in Eigen.
-    /*
-    if ((a + b) < maxgam && numext::abs(u) < maxlog) {
-      t = gamma(a + b) / (gamma(a) * gamma(b));
-      s = s * t * pow(x, a);
-    }
-    */
-    t = lgamma_impl<double>::run(a + b) - lgamma_impl<double>::run(a) - lgamma_impl<double>::run(b) + u +
-        numext::log(s);
-    return s = numext::exp(t);
-  }
-};
-
-template <>
-struct betainc_impl<double> {
-  EIGEN_DEVICE_FUNC static double run(double aa, double bb, double xx) {
-    const double nan = NumTraits<double>::quiet_NaN();
-    const double machep = cephes_helper<double>::machep();
-    double a, b, t, x, xc, w, y;
-    bool reversed_a_b = false;
-
-    if (aa == 0.0 && bb == 0.0) return nan;
-    if (xx < 0.0 || xx > 1.0) return nan;
-    if (aa < 0.0) return nan;
-    if (bb < 0.0) return nan;
-    if (aa == 0.0) return 1.0;
-    if (bb == 0.0) return 0.0;
-    if (xx == 0.0) return 0.0;
-    if (xx == 1.0) return 1.0;
-    // mtherr("incbet", DOMAIN);
-
-    if ((bb * xx) <= 1.0 && xx <= 0.95) {
-      return betainc_helper<double>::incbps(aa, bb, xx);
-    }
-
-    w = 1.0 - xx;
-
-    /* Reverse a and b if x is greater than the mean. */
-    if (xx > (aa / (aa + bb))) {
-      reversed_a_b = true;
-      a = bb;
-      b = aa;
-      xc = xx;
-      x = w;
-    } else {
-      a = aa;
-      b = bb;
-      xc = w;
-      x = xx;
-    }
-
-    if (reversed_a_b && (b * x) <= 1.0 && x <= 0.95) {
-      t = betainc_helper<double>::incbps(a, b, x);
-      if (t <= machep) {
-        t = 1.0 - machep;
-      } else {
-        t = 1.0 - t;
-      }
-      return t;
-    }
-
-    /* Choose expansion for better convergence. */
-    y = x * (a + b - 2.0) - (a - 1.0);
-    if (y < 0.0) {
-      w = incbeta_cfe<double>::run(a, b, x, true /* small_branch */);
-    } else {
-      w = incbeta_cfe<double>::run(a, b, x, false /* small_branch */) / xc;
-    }
-
-    /* Multiply w by the factor
-         a      b   _             _     _
-        x  (1-x)   | (a+b) / ( a | (a) | (b) ) .   */
-
-    y = a * numext::log(x);
-    t = b * numext::log(xc);
-    // TODO: gamma is not directly implemented in Eigen.
-    /*
-    if ((a + b) < maxgam && numext::abs(y) < maxlog && numext::abs(t) < maxlog)
-    {
-      t = pow(xc, b);
-      t *= pow(x, a);
-      t /= a;
-      t *= w;
-      t *= gamma(a + b) / (gamma(a) * gamma(b));
-    } else {
-    */
-    /* Resort to logarithms.  */
-    y += t + lgamma_impl<double>::run(a + b) - lgamma_impl<double>::run(a) - lgamma_impl<double>::run(b);
-    y += numext::log(w / a);
-    t = numext::exp(y);
-
-    /* } */
-    // done:
-
-    if (reversed_a_b) {
-      if (t <= machep) {
-        t = 1.0 - machep;
-      } else {
-        t = 1.0 - t;
-      }
-    }
-    return t;
-  }
-};
-
-#endif  // EIGEN_HAS_C99_MATH
-
-}  // end namespace internal
-
-namespace numext {
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(lgamma, Scalar) lgamma(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(lgamma, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(digamma, Scalar) digamma(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(digamma, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(zeta, Scalar) zeta(const Scalar& x, const Scalar& q) {
-  return EIGEN_MATHFUNC_IMPL(zeta, Scalar)::run(x, q);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(polygamma, Scalar) polygamma(const Scalar& n, const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(polygamma, Scalar)::run(n, x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(erf, Scalar) erf(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(erf, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(erfc, Scalar) erfc(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(erfc, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(ndtri, Scalar) ndtri(const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(ndtri, Scalar)::run(x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(igamma, Scalar) igamma(const Scalar& a, const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(igamma, Scalar)::run(a, x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(igamma_der_a, Scalar) igamma_der_a(const Scalar& a, const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(igamma_der_a, Scalar)::run(a, x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(gamma_sample_der_alpha, Scalar)
-    gamma_sample_der_alpha(const Scalar& a, const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(gamma_sample_der_alpha, Scalar)::run(a, x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(igammac, Scalar) igammac(const Scalar& a, const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(igammac, Scalar)::run(a, x);
-}
-
-template <typename Scalar>
-EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(betainc, Scalar)
-    betainc(const Scalar& a, const Scalar& b, const Scalar& x) {
-  return EIGEN_MATHFUNC_IMPL(betainc, Scalar)::run(a, b, x);
-}
-
-}  // end namespace numext
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPECIAL_FUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h b/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h
deleted file mode 100644
index d1470db..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/SpecialFunctionsPacketMath.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPECIALFUNCTIONS_PACKETMATH_H
-#define EIGEN_SPECIALFUNCTIONS_PACKETMATH_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/** \internal \returns the ln(|gamma(\a a)|) (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plgamma(const Packet& a) {
-  using numext::lgamma;
-  return lgamma(a);
-}
-
-/** \internal \returns the derivative of lgamma, psi(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pdigamma(const Packet& a) {
-  using numext::digamma;
-  return digamma(a);
-}
-
-/** \internal \returns the zeta function of two arguments (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pzeta(const Packet& x, const Packet& q) {
-  using numext::zeta;
-  return zeta(x, q);
-}
-
-/** \internal \returns the polygamma function (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ppolygamma(const Packet& n, const Packet& x) {
-  using numext::polygamma;
-  return polygamma(n, x);
-}
-
-/** \internal \returns the erf(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perf(const Packet& a) {
-  using numext::erf;
-  return erf(a);
-}
-
-/** \internal \returns the erfc(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet perfc(const Packet& a) {
-  using numext::erfc;
-  return erfc(a);
-}
-
-/** \internal \returns the ndtri(\a a) (coeff-wise) */
-template <typename Packet>
-EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pndtri(const Packet& a) {
-  typedef typename unpacket_traits<Packet>::type ScalarType;
-  using internal::generic_ndtri;
-  return generic_ndtri<Packet, ScalarType>(a);
-}
-
-/** \internal \returns the incomplete gamma function igamma(\a a, \a x) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigamma(const Packet& a, const Packet& x) {
-  using numext::igamma;
-  return igamma(a, x);
-}
-
-/** \internal \returns the derivative of the incomplete gamma function
- * igamma_der_a(\a a, \a x) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigamma_der_a(const Packet& a, const Packet& x) {
-  using numext::igamma_der_a;
-  return igamma_der_a(a, x);
-}
-
-/** \internal \returns compute the derivative of the sample
- * of Gamma(alpha, 1) random variable with respect to the parameter a
- * gamma_sample_der_alpha(\a alpha, \a sample) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pgamma_sample_der_alpha(const Packet& alpha, const Packet& sample) {
-  using numext::gamma_sample_der_alpha;
-  return gamma_sample_der_alpha(alpha, sample);
-}
-
-/** \internal \returns the complementary incomplete gamma function igammac(\a a, \a x) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pigammac(const Packet& a, const Packet& x) {
-  using numext::igammac;
-  return igammac(a, x);
-}
-
-/** \internal \returns the complementary incomplete gamma function betainc(\a a, \a b, \a x) */
-template <typename Packet>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pbetainc(const Packet& a, const Packet& b, const Packet& x) {
-  using numext::betainc;
-  return betainc(a, b, x);
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_SPECIALFUNCTIONS_PACKETMATH_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h
deleted file mode 100644
index d1a39be..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/AVX/BesselFunctions.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef EIGEN_AVX_BESSELFUNCTIONS_H
-#define EIGEN_AVX_BESSELFUNCTIONS_H
-
-namespace Eigen {
-namespace internal {
-
-EIGEN_INSTANTIATE_BESSEL_FUNCS_F16(Packet8f, Packet8h)
-EIGEN_INSTANTIATE_BESSEL_FUNCS_BF16(Packet8f, Packet8bf)
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_AVX_BESSELFUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h
deleted file mode 100644
index a5a0805..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/AVX/SpecialFunctions.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef EIGEN_AVX_SPECIALFUNCTIONS_H
-#define EIGEN_AVX_SPECIALFUNCTIONS_H
-
-namespace Eigen {
-namespace internal {
-
-EIGEN_INSTANTIATE_SPECIAL_FUNCS_F16(Packet8f, Packet8h)
-EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(Packet8f, Packet8bf)
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_AVX_SPECIALFUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h
deleted file mode 100644
index 63ccc2d..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/BesselFunctions.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef EIGEN_AVX512_BESSELFUNCTIONS_H
-#define EIGEN_AVX512_BESSELFUNCTIONS_H
-
-namespace Eigen {
-namespace internal {
-
-EIGEN_INSTANTIATE_BESSEL_FUNCS_F16(Packet16f, Packet16h)
-EIGEN_INSTANTIATE_BESSEL_FUNCS_BF16(Packet16f, Packet16bf)
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_AVX512_BESSELFUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h
deleted file mode 100644
index d00d991..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/AVX512/SpecialFunctions.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef EIGEN_AVX512_SPECIALFUNCTIONS_H
-#define EIGEN_AVX512_SPECIALFUNCTIONS_H
-
-namespace Eigen {
-namespace internal {
-
-EIGEN_INSTANTIATE_SPECIAL_FUNCS_F16(Packet16f, Packet16h)
-EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(Packet16f, Packet16bf)
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_AVX512_SPECIALFUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h
deleted file mode 100644
index 8f3468b..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/GPU/SpecialFunctions.h
+++ /dev/null
@@ -1,317 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_GPU_SPECIALFUNCTIONS_H
-#define EIGEN_GPU_SPECIALFUNCTIONS_H
-
-namespace Eigen {
-
-namespace internal {
-
-// Make sure this is only available when targeting a GPU: we don't want to
-// introduce conflicts between these packet_traits definitions and the ones
-// we'll use on the host side (SSE, AVX, ...)
-#if defined(EIGEN_GPUCC) && defined(EIGEN_USE_GPU)
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 plgamma<float4>(const float4& a) {
-  return make_float4(lgammaf(a.x), lgammaf(a.y), lgammaf(a.z), lgammaf(a.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 plgamma<double2>(const double2& a) {
-  using numext::lgamma;
-  return make_double2(lgamma(a.x), lgamma(a.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pdigamma<float4>(const float4& a) {
-  using numext::digamma;
-  return make_float4(digamma(a.x), digamma(a.y), digamma(a.z), digamma(a.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pdigamma<double2>(const double2& a) {
-  using numext::digamma;
-  return make_double2(digamma(a.x), digamma(a.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pzeta<float4>(const float4& x, const float4& q) {
-  using numext::zeta;
-  return make_float4(zeta(x.x, q.x), zeta(x.y, q.y), zeta(x.z, q.z), zeta(x.w, q.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pzeta<double2>(const double2& x, const double2& q) {
-  using numext::zeta;
-  return make_double2(zeta(x.x, q.x), zeta(x.y, q.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 ppolygamma<float4>(const float4& n, const float4& x) {
-  using numext::polygamma;
-  return make_float4(polygamma(n.x, x.x), polygamma(n.y, x.y), polygamma(n.z, x.z), polygamma(n.w, x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 ppolygamma<double2>(const double2& n, const double2& x) {
-  using numext::polygamma;
-  return make_double2(polygamma(n.x, x.x), polygamma(n.y, x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 perf<float4>(const float4& a) {
-  return make_float4(erff(a.x), erff(a.y), erff(a.z), erff(a.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 perf<double2>(const double2& a) {
-  using numext::erf;
-  return make_double2(erf(a.x), erf(a.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 perfc<float4>(const float4& a) {
-  using numext::erfc;
-  return make_float4(erfc(a.x), erfc(a.y), erfc(a.z), erfc(a.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 perfc<double2>(const double2& a) {
-  using numext::erfc;
-  return make_double2(erfc(a.x), erfc(a.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pndtri<float4>(const float4& a) {
-  using numext::ndtri;
-  return make_float4(ndtri(a.x), ndtri(a.y), ndtri(a.z), ndtri(a.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pndtri<double2>(const double2& a) {
-  using numext::ndtri;
-  return make_double2(ndtri(a.x), ndtri(a.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pigamma<float4>(const float4& a, const float4& x) {
-  using numext::igamma;
-  return make_float4(igamma(a.x, x.x), igamma(a.y, x.y), igamma(a.z, x.z), igamma(a.w, x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pigamma<double2>(const double2& a, const double2& x) {
-  using numext::igamma;
-  return make_double2(igamma(a.x, x.x), igamma(a.y, x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pigamma_der_a<float4>(const float4& a, const float4& x) {
-  using numext::igamma_der_a;
-  return make_float4(igamma_der_a(a.x, x.x), igamma_der_a(a.y, x.y), igamma_der_a(a.z, x.z), igamma_der_a(a.w, x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pigamma_der_a<double2>(const double2& a, const double2& x) {
-  using numext::igamma_der_a;
-  return make_double2(igamma_der_a(a.x, x.x), igamma_der_a(a.y, x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pgamma_sample_der_alpha<float4>(const float4& alpha,
-                                                                             const float4& sample) {
-  using numext::gamma_sample_der_alpha;
-  return make_float4(gamma_sample_der_alpha(alpha.x, sample.x), gamma_sample_der_alpha(alpha.y, sample.y),
-                     gamma_sample_der_alpha(alpha.z, sample.z), gamma_sample_der_alpha(alpha.w, sample.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pgamma_sample_der_alpha<double2>(const double2& alpha,
-                                                                               const double2& sample) {
-  using numext::gamma_sample_der_alpha;
-  return make_double2(gamma_sample_der_alpha(alpha.x, sample.x), gamma_sample_der_alpha(alpha.y, sample.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pigammac<float4>(const float4& a, const float4& x) {
-  using numext::igammac;
-  return make_float4(igammac(a.x, x.x), igammac(a.y, x.y), igammac(a.z, x.z), igammac(a.w, x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pigammac<double2>(const double2& a, const double2& x) {
-  using numext::igammac;
-  return make_double2(igammac(a.x, x.x), igammac(a.y, x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbetainc<float4>(const float4& a, const float4& b, const float4& x) {
-  using numext::betainc;
-  return make_float4(betainc(a.x, b.x, x.x), betainc(a.y, b.y, x.y), betainc(a.z, b.z, x.z), betainc(a.w, b.w, x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbetainc<double2>(const double2& a, const double2& b, const double2& x) {
-  using numext::betainc;
-  return make_double2(betainc(a.x, b.x, x.x), betainc(a.y, b.y, x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i0e<float4>(const float4& x) {
-  using numext::bessel_i0e;
-  return make_float4(bessel_i0e(x.x), bessel_i0e(x.y), bessel_i0e(x.z), bessel_i0e(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i0e<double2>(const double2& x) {
-  using numext::bessel_i0e;
-  return make_double2(bessel_i0e(x.x), bessel_i0e(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i0<float4>(const float4& x) {
-  using numext::bessel_i0;
-  return make_float4(bessel_i0(x.x), bessel_i0(x.y), bessel_i0(x.z), bessel_i0(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i0<double2>(const double2& x) {
-  using numext::bessel_i0;
-  return make_double2(bessel_i0(x.x), bessel_i0(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i1e<float4>(const float4& x) {
-  using numext::bessel_i1e;
-  return make_float4(bessel_i1e(x.x), bessel_i1e(x.y), bessel_i1e(x.z), bessel_i1e(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i1e<double2>(const double2& x) {
-  using numext::bessel_i1e;
-  return make_double2(bessel_i1e(x.x), bessel_i1e(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_i1<float4>(const float4& x) {
-  using numext::bessel_i1;
-  return make_float4(bessel_i1(x.x), bessel_i1(x.y), bessel_i1(x.z), bessel_i1(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_i1<double2>(const double2& x) {
-  using numext::bessel_i1;
-  return make_double2(bessel_i1(x.x), bessel_i1(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k0e<float4>(const float4& x) {
-  using numext::bessel_k0e;
-  return make_float4(bessel_k0e(x.x), bessel_k0e(x.y), bessel_k0e(x.z), bessel_k0e(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k0e<double2>(const double2& x) {
-  using numext::bessel_k0e;
-  return make_double2(bessel_k0e(x.x), bessel_k0e(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k0<float4>(const float4& x) {
-  using numext::bessel_k0;
-  return make_float4(bessel_k0(x.x), bessel_k0(x.y), bessel_k0(x.z), bessel_k0(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k0<double2>(const double2& x) {
-  using numext::bessel_k0;
-  return make_double2(bessel_k0(x.x), bessel_k0(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k1e<float4>(const float4& x) {
-  using numext::bessel_k1e;
-  return make_float4(bessel_k1e(x.x), bessel_k1e(x.y), bessel_k1e(x.z), bessel_k1e(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k1e<double2>(const double2& x) {
-  using numext::bessel_k1e;
-  return make_double2(bessel_k1e(x.x), bessel_k1e(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_k1<float4>(const float4& x) {
-  using numext::bessel_k1;
-  return make_float4(bessel_k1(x.x), bessel_k1(x.y), bessel_k1(x.z), bessel_k1(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_k1<double2>(const double2& x) {
-  using numext::bessel_k1;
-  return make_double2(bessel_k1(x.x), bessel_k1(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_j0<float4>(const float4& x) {
-  using numext::bessel_j0;
-  return make_float4(bessel_j0(x.x), bessel_j0(x.y), bessel_j0(x.z), bessel_j0(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_j0<double2>(const double2& x) {
-  using numext::bessel_j0;
-  return make_double2(bessel_j0(x.x), bessel_j0(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_j1<float4>(const float4& x) {
-  using numext::bessel_j1;
-  return make_float4(bessel_j1(x.x), bessel_j1(x.y), bessel_j1(x.z), bessel_j1(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_j1<double2>(const double2& x) {
-  using numext::bessel_j1;
-  return make_double2(bessel_j1(x.x), bessel_j1(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_y0<float4>(const float4& x) {
-  using numext::bessel_y0;
-  return make_float4(bessel_y0(x.x), bessel_y0(x.y), bessel_y0(x.z), bessel_y0(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_y0<double2>(const double2& x) {
-  using numext::bessel_y0;
-  return make_double2(bessel_y0(x.x), bessel_y0(x.y));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float4 pbessel_y1<float4>(const float4& x) {
-  using numext::bessel_y1;
-  return make_float4(bessel_y1(x.x), bessel_y1(x.y), bessel_y1(x.z), bessel_y1(x.w));
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double2 pbessel_y1<double2>(const double2& x) {
-  using numext::bessel_y1;
-  return make_double2(bessel_y1(x.x), bessel_y1(x.y));
-}
-
-#endif
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_GPU_SPECIALFUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h
deleted file mode 100644
index 568abab..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/NEON/BesselFunctions.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef EIGEN_NEON_BESSELFUNCTIONS_H
-#define EIGEN_NEON_BESSELFUNCTIONS_H
-
-namespace Eigen {
-namespace internal {
-
-#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
-
-#define NEON_HALF_TO_FLOAT_FUNCTIONS(METHOD)                                              \
-  template <>                                                                             \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf METHOD<Packet8hf>(const Packet8hf& x) { \
-    const Packet4f lo = METHOD<Packet4f>(vcvt_f32_f16(vget_low_f16(x)));                  \
-    const Packet4f hi = METHOD<Packet4f>(vcvt_f32_f16(vget_high_f16(x)));                 \
-    return vcombine_f16(vcvt_f16_f32(lo), vcvt_f16_f32(hi));                              \
-  }                                                                                       \
-                                                                                          \
-  template <>                                                                             \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf METHOD<Packet4hf>(const Packet4hf& x) { \
-    return vcvt_f16_f32(METHOD<Packet4f>(vcvt_f32_f16(x)));                               \
-  }
-
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i0)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i0e)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i1)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_i1e)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_j0)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_j1)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k0)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k0e)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k1)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_k1e)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_y0)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pbessel_y1)
-
-#undef NEON_HALF_TO_FLOAT_FUNCTIONS
-#endif
-
-EIGEN_INSTANTIATE_BESSEL_FUNCS_BF16(Packet4f, Packet4bf)
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_NEON_BESSELFUNCTIONS_H
diff --git a/unsupported/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h b/unsupported/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h
deleted file mode 100644
index c31bb66..0000000
--- a/unsupported/Eigen/src/SpecialFunctions/arch/NEON/SpecialFunctions.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef EIGEN_NEON_SPECIALFUNCTIONS_H
-#define EIGEN_NEON_SPECIALFUNCTIONS_H
-
-namespace Eigen {
-namespace internal {
-
-#if EIGEN_HAS_ARM64_FP16_VECTOR_ARITHMETIC
-
-#define NEON_HALF_TO_FLOAT_FUNCTIONS(METHOD)                                              \
-  template <>                                                                             \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet8hf METHOD<Packet8hf>(const Packet8hf& x) { \
-    const Packet4f lo = METHOD<Packet4f>(vcvt_f32_f16(vget_low_f16(x)));                  \
-    const Packet4f hi = METHOD<Packet4f>(vcvt_f32_f16(vget_high_f16(x)));                 \
-    return vcombine_f16(vcvt_f16_f32(lo), vcvt_f16_f32(hi));                              \
-  }                                                                                       \
-                                                                                          \
-  template <>                                                                             \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet4hf METHOD<Packet4hf>(const Packet4hf& x) { \
-    return vcvt_f16_f32(METHOD<Packet4f>(vcvt_f32_f16(x)));                               \
-  }
-
-NEON_HALF_TO_FLOAT_FUNCTIONS(perf)
-NEON_HALF_TO_FLOAT_FUNCTIONS(pndtri)
-
-#undef NEON_HALF_TO_FLOAT_FUNCTIONS
-#endif
-
-EIGEN_INSTANTIATE_SPECIAL_FUNCS_BF16(Packet4f, Packet4bf)
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_NEON_SPECIALFUNCTIONS_H
diff --git a/unsupported/Eigen/src/Splines/InternalHeaderCheck.h b/unsupported/Eigen/src/Splines/InternalHeaderCheck.h
deleted file mode 100644
index 4a6087e..0000000
--- a/unsupported/Eigen/src/Splines/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_SPLINES_MODULE_H
-#error "Please include unsupported/Eigen/Splines instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/Splines/Spline.h b/unsupported/Eigen/src/Splines/Spline.h
deleted file mode 100644
index 77b3522..0000000
--- a/unsupported/Eigen/src/Splines/Spline.h
+++ /dev/null
@@ -1,479 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 20010-2011 Hauke Heibel <hauke.heibel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPLINE_H
-#define EIGEN_SPLINE_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include "SplineFwd.h"
-
-namespace Eigen {
-/**
- * \ingroup Splines_Module
- * \class Spline
- * \brief A class representing multi-dimensional spline curves.
- *
- * The class represents B-splines with non-uniform knot vectors. Each control
- * point of the B-spline is associated with a basis function
- * \f{align*}
- *   C(u) & = \sum_{i=0}^{n}N_{i,p}(u)P_i
- * \f}
- *
- * \tparam Scalar_ The underlying data type (typically float or double)
- * \tparam Dim_ The curve dimension (e.g. 2 or 3)
- * \tparam Degree_ Per default set to Dynamic; could be set to the actual desired
- *                degree for optimization purposes (would result in stack allocation
- *                of several temporary variables).
- **/
-template <typename Scalar_, int Dim_, int Degree_>
-class Spline {
- public:
-  typedef Scalar_ Scalar; /*!< The spline curve's scalar type. */
-  enum { Dimension = Dim_ /*!< The spline curve's dimension. */ };
-  enum { Degree = Degree_ /*!< The spline curve's degree. */ };
-
-  /** \brief The point type the spline is representing. */
-  typedef typename SplineTraits<Spline>::PointType PointType;
-
-  /** \brief The data type used to store knot vectors. */
-  typedef typename SplineTraits<Spline>::KnotVectorType KnotVectorType;
-
-  /** \brief The data type used to store parameter vectors. */
-  typedef typename SplineTraits<Spline>::ParameterVectorType ParameterVectorType;
-
-  /** \brief The data type used to store non-zero basis functions. */
-  typedef typename SplineTraits<Spline>::BasisVectorType BasisVectorType;
-
-  /** \brief The data type used to store the values of the basis function derivatives. */
-  typedef typename SplineTraits<Spline>::BasisDerivativeType BasisDerivativeType;
-
-  /** \brief The data type representing the spline's control points. */
-  typedef typename SplineTraits<Spline>::ControlPointVectorType ControlPointVectorType;
-
-  /**
-   * \brief Creates a (constant) zero spline.
-   * For Splines with dynamic degree, the resulting degree will be 0.
-   **/
-  Spline()
-      : m_knots(1, (Degree == Dynamic ? 2 : 2 * Degree + 2)),
-        m_ctrls(ControlPointVectorType::Zero(Dimension, (Degree == Dynamic ? 1 : Degree + 1))) {
-    // in theory this code can go to the initializer list but it will get pretty
-    // much unreadable ...
-    enum { MinDegree = (Degree == Dynamic ? 0 : Degree) };
-    m_knots.template segment<MinDegree + 1>(0) = Array<Scalar, 1, MinDegree + 1>::Zero();
-    m_knots.template segment<MinDegree + 1>(MinDegree + 1) = Array<Scalar, 1, MinDegree + 1>::Ones();
-  }
-
-  /**
-   * \brief Creates a spline from a knot vector and control points.
-   * \param knots The spline's knot vector.
-   * \param ctrls The spline's control point vector.
-   **/
-  template <typename OtherVectorType, typename OtherArrayType>
-  Spline(const OtherVectorType& knots, const OtherArrayType& ctrls) : m_knots(knots), m_ctrls(ctrls) {}
-
-  /**
-   * \brief Copy constructor for splines.
-   * \param spline The input spline.
-   **/
-  template <int OtherDegree>
-  Spline(const Spline<Scalar, Dimension, OtherDegree>& spline) : m_knots(spline.knots()), m_ctrls(spline.ctrls()) {}
-
-  /**
-   * \brief Returns the knots of the underlying spline.
-   **/
-  const KnotVectorType& knots() const { return m_knots; }
-
-  /**
-   * \brief Returns the ctrls of the underlying spline.
-   **/
-  const ControlPointVectorType& ctrls() const { return m_ctrls; }
-
-  /**
-   * \brief Returns the spline value at a given site \f$u\f$.
-   *
-   * The function returns
-   * \f{align*}
-   *   C(u) & = \sum_{i=0}^{n}N_{i,p}P_i
-   * \f}
-   *
-   * \param u Parameter \f$u \in [0;1]\f$ at which the spline is evaluated.
-   * \return The spline value at the given location \f$u\f$.
-   **/
-  PointType operator()(Scalar u) const;
-
-  /**
-   * \brief Evaluation of spline derivatives of up-to given order.
-   *
-   * The function returns
-   * \f{align*}
-   *   \frac{d^i}{du^i}C(u) & = \sum_{i=0}^{n} \frac{d^i}{du^i} N_{i,p}(u)P_i
-   * \f}
-   * for i ranging between 0 and order.
-   *
-   * \param u Parameter \f$u \in [0;1]\f$ at which the spline derivative is evaluated.
-   * \param order The order up to which the derivatives are computed.
-   **/
-  typename SplineTraits<Spline>::DerivativeType derivatives(Scalar u, DenseIndex order) const;
-
-  /**
-   * \copydoc Spline::derivatives
-   * Using the template version of this function is more efficieent since
-   * temporary objects are allocated on the stack whenever this is possible.
-   **/
-  template <int DerivativeOrder>
-  typename SplineTraits<Spline, DerivativeOrder>::DerivativeType derivatives(Scalar u,
-                                                                             DenseIndex order = DerivativeOrder) const;
-
-  /**
-   * \brief Computes the non-zero basis functions at the given site.
-   *
-   * Splines have local support and a point from their image is defined
-   * by exactly \f$p+1\f$ control points \f$P_i\f$ where \f$p\f$ is the
-   * spline degree.
-   *
-   * This function computes the \f$p+1\f$ non-zero basis function values
-   * for a given parameter value \f$u\f$. It returns
-   * \f{align*}{
-   *   N_{i,p}(u), \hdots, N_{i+p+1,p}(u)
-   * \f}
-   *
-   * \param u Parameter \f$u \in [0;1]\f$ at which the non-zero basis functions
-   *          are computed.
-   **/
-  typename SplineTraits<Spline>::BasisVectorType basisFunctions(Scalar u) const;
-
-  /**
-   * \brief Computes the non-zero spline basis function derivatives up to given order.
-   *
-   * The function computes
-   * \f{align*}{
-   *   \frac{d^i}{du^i} N_{i,p}(u), \hdots, \frac{d^i}{du^i} N_{i+p+1,p}(u)
-   * \f}
-   * with i ranging from 0 up to the specified order.
-   *
-   * \param u Parameter \f$u \in [0;1]\f$ at which the non-zero basis function
-   *          derivatives are computed.
-   * \param order The order up to which the basis function derivatives are computes.
-   **/
-  typename SplineTraits<Spline>::BasisDerivativeType basisFunctionDerivatives(Scalar u, DenseIndex order) const;
-
-  /**
-   * \copydoc Spline::basisFunctionDerivatives
-   * Using the template version of this function is more efficieent since
-   * temporary objects are allocated on the stack whenever this is possible.
-   **/
-  template <int DerivativeOrder>
-  typename SplineTraits<Spline, DerivativeOrder>::BasisDerivativeType basisFunctionDerivatives(
-      Scalar u, DenseIndex order = DerivativeOrder) const;
-
-  /**
-   * \brief Returns the spline degree.
-   **/
-  DenseIndex degree() const;
-
-  /**
-   * \brief Returns the span within the knot vector in which u is falling.
-   * \param u The site for which the span is determined.
-   **/
-  DenseIndex span(Scalar u) const;
-
-  /**
-   * \brief Computes the span within the provided knot vector in which u is falling.
-   **/
-  static DenseIndex Span(typename SplineTraits<Spline>::Scalar u, DenseIndex degree,
-                         const typename SplineTraits<Spline>::KnotVectorType& knots);
-
-  /**
-   * \brief Returns the spline's non-zero basis functions.
-   *
-   * The function computes and returns
-   * \f{align*}{
-   *   N_{i,p}(u), \hdots, N_{i+p+1,p}(u)
-   * \f}
-   *
-   * \param u The site at which the basis functions are computed.
-   * \param degree The degree of the underlying spline.
-   * \param knots The underlying spline's knot vector.
-   **/
-  static BasisVectorType BasisFunctions(Scalar u, DenseIndex degree, const KnotVectorType& knots);
-
-  /**
-   * \copydoc Spline::basisFunctionDerivatives
-   * \param degree The degree of the underlying spline
-   * \param knots The underlying spline's knot vector.
-   **/
-  static BasisDerivativeType BasisFunctionDerivatives(const Scalar u, const DenseIndex order, const DenseIndex degree,
-                                                      const KnotVectorType& knots);
-
- private:
-  KnotVectorType m_knots;         /*!< Knot vector. */
-  ControlPointVectorType m_ctrls; /*!< Control points. */
-
-  template <typename DerivativeType>
-  static void BasisFunctionDerivativesImpl(const typename Spline<Scalar_, Dim_, Degree_>::Scalar u,
-                                           const DenseIndex order, const DenseIndex p,
-                                           const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& U,
-                                           DerivativeType& N_);
-};
-
-template <typename Scalar_, int Dim_, int Degree_>
-DenseIndex Spline<Scalar_, Dim_, Degree_>::Span(
-    typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::Scalar u, DenseIndex degree,
-    const typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::KnotVectorType& knots) {
-  // Piegl & Tiller, "The NURBS Book", A2.1 (p. 68)
-  if (u <= knots(0)) return degree;
-  const Scalar* pos = std::upper_bound(knots.data() + degree - 1, knots.data() + knots.size() - degree - 1, u);
-  return static_cast<DenseIndex>(std::distance(knots.data(), pos) - 1);
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-typename Spline<Scalar_, Dim_, Degree_>::BasisVectorType Spline<Scalar_, Dim_, Degree_>::BasisFunctions(
-    typename Spline<Scalar_, Dim_, Degree_>::Scalar u, DenseIndex degree,
-    const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& knots) {
-  const DenseIndex p = degree;
-  const DenseIndex i = Spline::Span(u, degree, knots);
-
-  const KnotVectorType& U = knots;
-
-  BasisVectorType left(p + 1);
-  left(0) = Scalar(0);
-  BasisVectorType right(p + 1);
-  right(0) = Scalar(0);
-
-  VectorBlock<BasisVectorType, Degree>(left, 1, p) =
-      u - VectorBlock<const KnotVectorType, Degree>(U, i + 1 - p, p).reverse();
-  VectorBlock<BasisVectorType, Degree>(right, 1, p) = VectorBlock<const KnotVectorType, Degree>(U, i + 1, p) - u;
-
-  BasisVectorType N(1, p + 1);
-  N(0) = Scalar(1);
-  for (DenseIndex j = 1; j <= p; ++j) {
-    Scalar saved = Scalar(0);
-    for (DenseIndex r = 0; r < j; r++) {
-      const Scalar tmp = N(r) / (right(r + 1) + left(j - r));
-      N[r] = saved + right(r + 1) * tmp;
-      saved = left(j - r) * tmp;
-    }
-    N(j) = saved;
-  }
-  return N;
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-DenseIndex Spline<Scalar_, Dim_, Degree_>::degree() const {
-  if (Degree_ == Dynamic)
-    return m_knots.size() - m_ctrls.cols() - 1;
-  else
-    return Degree_;
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-DenseIndex Spline<Scalar_, Dim_, Degree_>::span(Scalar u) const {
-  return Spline::Span(u, degree(), knots());
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-typename Spline<Scalar_, Dim_, Degree_>::PointType Spline<Scalar_, Dim_, Degree_>::operator()(Scalar u) const {
-  enum { Order = SplineTraits<Spline>::OrderAtCompileTime };
-
-  const DenseIndex span = this->span(u);
-  const DenseIndex p = degree();
-  const BasisVectorType basis_funcs = basisFunctions(u);
-
-  const Replicate<BasisVectorType, Dimension, 1> ctrl_weights(basis_funcs);
-  const Block<const ControlPointVectorType, Dimension, Order> ctrl_pts(ctrls(), 0, span - p, Dimension, p + 1);
-  return (ctrl_weights * ctrl_pts).rowwise().sum();
-}
-
-/* --------------------------------------------------------------------------------------------- */
-
-template <typename SplineType, typename DerivativeType>
-void derivativesImpl(const SplineType& spline, typename SplineType::Scalar u, DenseIndex order, DerivativeType& der) {
-  enum { Dimension = SplineTraits<SplineType>::Dimension };
-  enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
-  enum { DerivativeOrder = DerivativeType::ColsAtCompileTime };
-
-  typedef typename SplineTraits<SplineType>::ControlPointVectorType ControlPointVectorType;
-  typedef typename SplineTraits<SplineType, DerivativeOrder>::BasisDerivativeType BasisDerivativeType;
-  typedef typename BasisDerivativeType::ConstRowXpr BasisDerivativeRowXpr;
-
-  const DenseIndex p = spline.degree();
-  const DenseIndex span = spline.span(u);
-
-  const DenseIndex n = (std::min)(p, order);
-
-  der.resize(Dimension, n + 1);
-
-  // Retrieve the basis function derivatives up to the desired order...
-  const BasisDerivativeType basis_func_ders = spline.template basisFunctionDerivatives<DerivativeOrder>(u, n + 1);
-
-  // ... and perform the linear combinations of the control points.
-  for (DenseIndex der_order = 0; der_order < n + 1; ++der_order) {
-    const Replicate<BasisDerivativeRowXpr, Dimension, 1> ctrl_weights(basis_func_ders.row(der_order));
-    const Block<const ControlPointVectorType, Dimension, Order> ctrl_pts(spline.ctrls(), 0, span - p, Dimension, p + 1);
-    der.col(der_order) = (ctrl_weights * ctrl_pts).rowwise().sum();
-  }
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::DerivativeType Spline<Scalar_, Dim_, Degree_>::derivatives(
-    Scalar u, DenseIndex order) const {
-  typename SplineTraits<Spline>::DerivativeType res;
-  derivativesImpl(*this, u, order, res);
-  return res;
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-template <int DerivativeOrder>
-typename SplineTraits<Spline<Scalar_, Dim_, Degree_>, DerivativeOrder>::DerivativeType
-Spline<Scalar_, Dim_, Degree_>::derivatives(Scalar u, DenseIndex order) const {
-  typename SplineTraits<Spline, DerivativeOrder>::DerivativeType res;
-  derivativesImpl(*this, u, order, res);
-  return res;
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisVectorType Spline<Scalar_, Dim_, Degree_>::basisFunctions(
-    Scalar u) const {
-  return Spline::BasisFunctions(u, degree(), knots());
-}
-
-/* --------------------------------------------------------------------------------------------- */
-
-template <typename Scalar_, int Dim_, int Degree_>
-template <typename DerivativeType>
-void Spline<Scalar_, Dim_, Degree_>::BasisFunctionDerivativesImpl(
-    const typename Spline<Scalar_, Dim_, Degree_>::Scalar u, const DenseIndex order, const DenseIndex p,
-    const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& U, DerivativeType& N_) {
-  typedef Spline<Scalar_, Dim_, Degree_> SplineType;
-  enum { Order = SplineTraits<SplineType>::OrderAtCompileTime };
-
-  const DenseIndex span = SplineType::Span(u, p, U);
-
-  const DenseIndex n = (std::min)(p, order);
-
-  N_.resize(n + 1, p + 1);
-
-  BasisVectorType left = BasisVectorType::Zero(p + 1);
-  BasisVectorType right = BasisVectorType::Zero(p + 1);
-
-  Matrix<Scalar, Order, Order> ndu(p + 1, p + 1);
-
-  Scalar saved, temp;  // FIXME: These were double instead of Scalar. Was there a reason for that?
-
-  ndu(0, 0) = 1.0;
-
-  DenseIndex j;
-  for (j = 1; j <= p; ++j) {
-    left[j] = u - U[span + 1 - j];
-    right[j] = U[span + j] - u;
-    saved = 0.0;
-
-    for (DenseIndex r = 0; r < j; ++r) {
-      /* Lower triangle */
-      ndu(j, r) = right[r + 1] + left[j - r];
-      temp = ndu(r, j - 1) / ndu(j, r);
-      /* Upper triangle */
-      ndu(r, j) = static_cast<Scalar>(saved + right[r + 1] * temp);
-      saved = left[j - r] * temp;
-    }
-
-    ndu(j, j) = static_cast<Scalar>(saved);
-  }
-
-  for (j = p; j >= 0; --j) N_(0, j) = ndu(j, p);
-
-  // Compute the derivatives
-  DerivativeType a(n + 1, p + 1);
-  DenseIndex r = 0;
-  for (; r <= p; ++r) {
-    DenseIndex s1, s2;
-    s1 = 0;
-    s2 = 1;  // alternate rows in array a
-    a(0, 0) = 1.0;
-
-    // Compute the k-th derivative
-    for (DenseIndex k = 1; k <= static_cast<DenseIndex>(n); ++k) {
-      Scalar d = 0.0;
-      DenseIndex rk, pk, j1, j2;
-      rk = r - k;
-      pk = p - k;
-
-      if (r >= k) {
-        a(s2, 0) = a(s1, 0) / ndu(pk + 1, rk);
-        d = a(s2, 0) * ndu(rk, pk);
-      }
-
-      if (rk >= -1)
-        j1 = 1;
-      else
-        j1 = -rk;
-
-      if (r - 1 <= pk)
-        j2 = k - 1;
-      else
-        j2 = p - r;
-
-      for (j = j1; j <= j2; ++j) {
-        a(s2, j) = (a(s1, j) - a(s1, j - 1)) / ndu(pk + 1, rk + j);
-        d += a(s2, j) * ndu(rk + j, pk);
-      }
-
-      if (r <= pk) {
-        a(s2, k) = -a(s1, k - 1) / ndu(pk + 1, r);
-        d += a(s2, k) * ndu(r, pk);
-      }
-
-      N_(k, r) = static_cast<Scalar>(d);
-      j = s1;
-      s1 = s2;
-      s2 = j;  // Switch rows
-    }
-  }
-
-  /* Multiply through by the correct factors */
-  /* (Eq. [2.9])                             */
-  r = p;
-  for (DenseIndex k = 1; k <= static_cast<DenseIndex>(n); ++k) {
-    for (j = p; j >= 0; --j) N_(k, j) *= r;
-    r *= p - k;
-  }
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType
-Spline<Scalar_, Dim_, Degree_>::basisFunctionDerivatives(Scalar u, DenseIndex order) const {
-  typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType der;
-  BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
-  return der;
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-template <int DerivativeOrder>
-typename SplineTraits<Spline<Scalar_, Dim_, Degree_>, DerivativeOrder>::BasisDerivativeType
-Spline<Scalar_, Dim_, Degree_>::basisFunctionDerivatives(Scalar u, DenseIndex order) const {
-  typename SplineTraits<Spline<Scalar_, Dim_, Degree_>, DerivativeOrder>::BasisDerivativeType der;
-  BasisFunctionDerivativesImpl(u, order, degree(), knots(), der);
-  return der;
-}
-
-template <typename Scalar_, int Dim_, int Degree_>
-typename SplineTraits<Spline<Scalar_, Dim_, Degree_> >::BasisDerivativeType
-Spline<Scalar_, Dim_, Degree_>::BasisFunctionDerivatives(
-    const typename Spline<Scalar_, Dim_, Degree_>::Scalar u, const DenseIndex order, const DenseIndex degree,
-    const typename Spline<Scalar_, Dim_, Degree_>::KnotVectorType& knots) {
-  typename SplineTraits<Spline>::BasisDerivativeType der;
-  BasisFunctionDerivativesImpl(u, order, degree, knots, der);
-  return der;
-}
-}  // namespace Eigen
-
-#endif  // EIGEN_SPLINE_H
diff --git a/unsupported/Eigen/src/Splines/SplineFitting.h b/unsupported/Eigen/src/Splines/SplineFitting.h
deleted file mode 100644
index f6a1111..0000000
--- a/unsupported/Eigen/src/Splines/SplineFitting.h
+++ /dev/null
@@ -1,393 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 20010-2011 Hauke Heibel <hauke.heibel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPLINE_FITTING_H
-#define EIGEN_SPLINE_FITTING_H
-
-#include <algorithm>
-#include <functional>
-#include <numeric>
-#include <vector>
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include "SplineFwd.h"
-
-#include "../../../../Eigen/LU"
-#include "../../../../Eigen/QR"
-
-namespace Eigen {
-/**
- * \brief Computes knot averages.
- * \ingroup Splines_Module
- *
- * The knots are computed as
- * \f{align*}
- *  u_0 & = \hdots = u_p = 0 \\
- *  u_{m-p} & = \hdots = u_{m} = 1 \\
- *  u_{j+p} & = \frac{1}{p}\sum_{i=j}^{j+p-1}\bar{u}_i \quad\quad j=1,\hdots,n-p
- * \f}
- * where \f$p\f$ is the degree and \f$m+1\f$ the number knots
- * of the desired interpolating spline.
- *
- * \param[in] parameters The input parameters. During interpolation one for each data point.
- * \param[in] degree The spline degree which is used during the interpolation.
- * \param[out] knots The output knot vector.
- *
- * \sa Les Piegl and Wayne Tiller, The NURBS book (2nd ed.), 1997, 9.2.1 Global Curve Interpolation to Point Data
- **/
-template <typename KnotVectorType>
-void KnotAveraging(const KnotVectorType& parameters, DenseIndex degree, KnotVectorType& knots) {
-  knots.resize(parameters.size() + degree + 1);
-
-  for (DenseIndex j = 1; j < parameters.size() - degree; ++j) knots(j + degree) = parameters.segment(j, degree).mean();
-
-  knots.segment(0, degree + 1) = KnotVectorType::Zero(degree + 1);
-  knots.segment(knots.size() - degree - 1, degree + 1) = KnotVectorType::Ones(degree + 1);
-}
-
-/**
- * \brief Computes knot averages when derivative constraints are present.
- * Note that this is a technical interpretation of the referenced article
- * since the algorithm contained therein is incorrect as written.
- * \ingroup Splines_Module
- *
- * \param[in] parameters The parameters at which the interpolation B-Spline
- *            will intersect the given interpolation points. The parameters
- *            are assumed to be a non-decreasing sequence.
- * \param[in] degree The degree of the interpolating B-Spline. This must be
- *            greater than zero.
- * \param[in] derivativeIndices The indices corresponding to parameters at
- *            which there are derivative constraints. The indices are assumed
- *            to be a non-decreasing sequence.
- * \param[out] knots The calculated knot vector. These will be returned as a
- *             non-decreasing sequence
- *
- * \sa Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008.
- * Curve interpolation with directional constraints for engineering design.
- * Engineering with Computers
- **/
-template <typename KnotVectorType, typename ParameterVectorType, typename IndexArray>
-void KnotAveragingWithDerivatives(const ParameterVectorType& parameters, const unsigned int degree,
-                                  const IndexArray& derivativeIndices, KnotVectorType& knots) {
-  typedef typename ParameterVectorType::Scalar Scalar;
-
-  DenseIndex numParameters = parameters.size();
-  DenseIndex numDerivatives = derivativeIndices.size();
-
-  if (numDerivatives < 1) {
-    KnotAveraging(parameters, degree, knots);
-    return;
-  }
-
-  DenseIndex startIndex;
-  DenseIndex endIndex;
-
-  DenseIndex numInternalDerivatives = numDerivatives;
-
-  if (derivativeIndices[0] == 0) {
-    startIndex = 0;
-    --numInternalDerivatives;
-  } else {
-    startIndex = 1;
-  }
-  if (derivativeIndices[numDerivatives - 1] == numParameters - 1) {
-    endIndex = numParameters - degree;
-    --numInternalDerivatives;
-  } else {
-    endIndex = numParameters - degree - 1;
-  }
-
-  // There are (endIndex - startIndex + 1) knots obtained from the averaging
-  // and 2 for the first and last parameters.
-  DenseIndex numAverageKnots = endIndex - startIndex + 3;
-  KnotVectorType averageKnots(numAverageKnots);
-  averageKnots[0] = parameters[0];
-
-  int newKnotIndex = 0;
-  for (DenseIndex i = startIndex; i <= endIndex; ++i)
-    averageKnots[++newKnotIndex] = parameters.segment(i, degree).mean();
-  averageKnots[++newKnotIndex] = parameters[numParameters - 1];
-
-  newKnotIndex = -1;
-
-  ParameterVectorType temporaryParameters(numParameters + 1);
-  KnotVectorType derivativeKnots(numInternalDerivatives);
-  for (DenseIndex i = 0; i < numAverageKnots - 1; ++i) {
-    temporaryParameters[0] = averageKnots[i];
-    ParameterVectorType parameterIndices(numParameters);
-    int temporaryParameterIndex = 1;
-    for (DenseIndex j = 0; j < numParameters; ++j) {
-      Scalar parameter = parameters[j];
-      if (parameter >= averageKnots[i] && parameter < averageKnots[i + 1]) {
-        parameterIndices[temporaryParameterIndex] = j;
-        temporaryParameters[temporaryParameterIndex++] = parameter;
-      }
-    }
-    temporaryParameters[temporaryParameterIndex] = averageKnots[i + 1];
-
-    for (int j = 0; j <= temporaryParameterIndex - 2; ++j) {
-      for (DenseIndex k = 0; k < derivativeIndices.size(); ++k) {
-        if (parameterIndices[j + 1] == derivativeIndices[k] && parameterIndices[j + 1] != 0 &&
-            parameterIndices[j + 1] != numParameters - 1) {
-          derivativeKnots[++newKnotIndex] = temporaryParameters.segment(j, 3).mean();
-          break;
-        }
-      }
-    }
-  }
-
-  KnotVectorType temporaryKnots(averageKnots.size() + derivativeKnots.size());
-
-  std::merge(averageKnots.data(), averageKnots.data() + averageKnots.size(), derivativeKnots.data(),
-             derivativeKnots.data() + derivativeKnots.size(), temporaryKnots.data());
-
-  // Number of knots (one for each point and derivative) plus spline order.
-  DenseIndex numKnots = numParameters + numDerivatives + degree + 1;
-  knots.resize(numKnots);
-
-  knots.head(degree).fill(temporaryKnots[0]);
-  knots.tail(degree).fill(temporaryKnots.template tail<1>()[0]);
-  knots.segment(degree, temporaryKnots.size()) = temporaryKnots;
-}
-
-/**
- * \brief Computes chord length parameters which are required for spline interpolation.
- * \ingroup Splines_Module
- *
- * \param[in] pts The data points to which a spline should be fit.
- * \param[out] chord_lengths The resulting chord length vector.
- *
- * \sa Les Piegl and Wayne Tiller, The NURBS book (2nd ed.), 1997, 9.2.1 Global Curve Interpolation to Point Data
- **/
-template <typename PointArrayType, typename KnotVectorType>
-void ChordLengths(const PointArrayType& pts, KnotVectorType& chord_lengths) {
-  typedef typename KnotVectorType::Scalar Scalar;
-
-  const DenseIndex n = pts.cols();
-
-  // 1. compute the column-wise norms
-  chord_lengths.resize(pts.cols());
-  chord_lengths[0] = 0;
-  chord_lengths.rightCols(n - 1) =
-      (pts.array().leftCols(n - 1) - pts.array().rightCols(n - 1)).matrix().colwise().norm();
-
-  // 2. compute the partial sums
-  std::partial_sum(chord_lengths.data(), chord_lengths.data() + n, chord_lengths.data());
-
-  // 3. normalize the data
-  chord_lengths /= chord_lengths(n - 1);
-  chord_lengths(n - 1) = Scalar(1);
-}
-
-/**
- * \brief Spline fitting methods.
- * \ingroup Splines_Module
- **/
-template <typename SplineType>
-struct SplineFitting {
-  typedef typename SplineType::KnotVectorType KnotVectorType;
-  typedef typename SplineType::ParameterVectorType ParameterVectorType;
-
-  /**
-   * \brief Fits an interpolating Spline to the given data points.
-   *
-   * \param pts The points for which an interpolating spline will be computed.
-   * \param degree The degree of the interpolating spline.
-   *
-   * \returns A spline interpolating the initially provided points.
-   **/
-  template <typename PointArrayType>
-  static SplineType Interpolate(const PointArrayType& pts, DenseIndex degree);
-
-  /**
-   * \brief Fits an interpolating Spline to the given data points.
-   *
-   * \param pts The points for which an interpolating spline will be computed.
-   * \param degree The degree of the interpolating spline.
-   * \param knot_parameters The knot parameters for the interpolation.
-   *
-   * \returns A spline interpolating the initially provided points.
-   **/
-  template <typename PointArrayType>
-  static SplineType Interpolate(const PointArrayType& pts, DenseIndex degree, const KnotVectorType& knot_parameters);
-
-  /**
-   * \brief Fits an interpolating spline to the given data points and
-   * derivatives.
-   *
-   * \param points The points for which an interpolating spline will be computed.
-   * \param derivatives The desired derivatives of the interpolating spline at interpolation
-   *                    points.
-   * \param derivativeIndices An array indicating which point each derivative belongs to. This
-   *                          must be the same size as @a derivatives.
-   * \param degree The degree of the interpolating spline.
-   *
-   * \returns A spline interpolating @a points with @a derivatives at those points.
-   *
-   * \sa Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008.
-   * Curve interpolation with directional constraints for engineering design.
-   * Engineering with Computers
-   **/
-  template <typename PointArrayType, typename IndexArray>
-  static SplineType InterpolateWithDerivatives(const PointArrayType& points, const PointArrayType& derivatives,
-                                               const IndexArray& derivativeIndices, const unsigned int degree);
-
-  /**
-   * \brief Fits an interpolating spline to the given data points and derivatives.
-   *
-   * \param points The points for which an interpolating spline will be computed.
-   * \param derivatives The desired derivatives of the interpolating spline at interpolation points.
-   * \param derivativeIndices An array indicating which point each derivative belongs to. This
-   *                          must be the same size as @a derivatives.
-   * \param degree The degree of the interpolating spline.
-   * \param parameters The parameters corresponding to the interpolation points.
-   *
-   * \returns A spline interpolating @a points with @a derivatives at those points.
-   *
-   * \sa Les A. Piegl, Khairan Rajab, Volha Smarodzinana. 2008.
-   * Curve interpolation with directional constraints for engineering design.
-   * Engineering with Computers
-   */
-  template <typename PointArrayType, typename IndexArray>
-  static SplineType InterpolateWithDerivatives(const PointArrayType& points, const PointArrayType& derivatives,
-                                               const IndexArray& derivativeIndices, const unsigned int degree,
-                                               const ParameterVectorType& parameters);
-};
-
-template <typename SplineType>
-template <typename PointArrayType>
-SplineType SplineFitting<SplineType>::Interpolate(const PointArrayType& pts, DenseIndex degree,
-                                                  const KnotVectorType& knot_parameters) {
-  typedef typename SplineType::KnotVectorType::Scalar Scalar;
-  typedef typename SplineType::ControlPointVectorType ControlPointVectorType;
-
-  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
-
-  KnotVectorType knots;
-  KnotAveraging(knot_parameters, degree, knots);
-
-  DenseIndex n = pts.cols();
-  MatrixType A = MatrixType::Zero(n, n);
-  for (DenseIndex i = 1; i < n - 1; ++i) {
-    const DenseIndex span = SplineType::Span(knot_parameters[i], degree, knots);
-
-    // The segment call should somehow be told the spline order at compile time.
-    A.row(i).segment(span - degree, degree + 1) = SplineType::BasisFunctions(knot_parameters[i], degree, knots);
-  }
-  A(0, 0) = 1.0;
-  A(n - 1, n - 1) = 1.0;
-
-  HouseholderQR<MatrixType> qr(A);
-
-  // Here, we are creating a temporary due to an Eigen issue.
-  ControlPointVectorType ctrls = qr.solve(MatrixType(pts.transpose())).transpose();
-
-  return SplineType(knots, ctrls);
-}
-
-template <typename SplineType>
-template <typename PointArrayType>
-SplineType SplineFitting<SplineType>::Interpolate(const PointArrayType& pts, DenseIndex degree) {
-  KnotVectorType chord_lengths;  // knot parameters
-  ChordLengths(pts, chord_lengths);
-  return Interpolate(pts, degree, chord_lengths);
-}
-
-template <typename SplineType>
-template <typename PointArrayType, typename IndexArray>
-SplineType SplineFitting<SplineType>::InterpolateWithDerivatives(const PointArrayType& points,
-                                                                 const PointArrayType& derivatives,
-                                                                 const IndexArray& derivativeIndices,
-                                                                 const unsigned int degree,
-                                                                 const ParameterVectorType& parameters) {
-  typedef typename SplineType::KnotVectorType::Scalar Scalar;
-  typedef typename SplineType::ControlPointVectorType ControlPointVectorType;
-
-  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
-
-  const DenseIndex n = points.cols() + derivatives.cols();
-
-  KnotVectorType knots;
-
-  KnotAveragingWithDerivatives(parameters, degree, derivativeIndices, knots);
-
-  // fill matrix
-  MatrixType A = MatrixType::Zero(n, n);
-
-  // Use these dimensions for quicker populating, then transpose for solving.
-  MatrixType b(points.rows(), n);
-
-  DenseIndex startRow;
-  DenseIndex derivativeStart;
-
-  // End derivatives.
-  if (derivativeIndices[0] == 0) {
-    A.template block<1, 2>(1, 0) << -1, 1;
-
-    Scalar y = (knots(degree + 1) - knots(0)) / degree;
-    b.col(1) = y * derivatives.col(0);
-
-    startRow = 2;
-    derivativeStart = 1;
-  } else {
-    startRow = 1;
-    derivativeStart = 0;
-  }
-  if (derivativeIndices[derivatives.cols() - 1] == points.cols() - 1) {
-    A.template block<1, 2>(n - 2, n - 2) << -1, 1;
-
-    Scalar y = (knots(knots.size() - 1) - knots(knots.size() - (degree + 2))) / degree;
-    b.col(b.cols() - 2) = y * derivatives.col(derivatives.cols() - 1);
-  }
-
-  DenseIndex row = startRow;
-  DenseIndex derivativeIndex = derivativeStart;
-  for (DenseIndex i = 1; i < parameters.size() - 1; ++i) {
-    const DenseIndex span = SplineType::Span(parameters[i], degree, knots);
-
-    if (derivativeIndex < derivativeIndices.size() && derivativeIndices[derivativeIndex] == i) {
-      A.block(row, span - degree, 2, degree + 1) =
-          SplineType::BasisFunctionDerivatives(parameters[i], 1, degree, knots);
-
-      b.col(row++) = points.col(i);
-      b.col(row++) = derivatives.col(derivativeIndex++);
-    } else {
-      A.row(row).segment(span - degree, degree + 1) = SplineType::BasisFunctions(parameters[i], degree, knots);
-      b.col(row++) = points.col(i);
-    }
-  }
-  b.col(0) = points.col(0);
-  b.col(b.cols() - 1) = points.col(points.cols() - 1);
-  A(0, 0) = 1;
-  A(n - 1, n - 1) = 1;
-
-  // Solve
-  FullPivLU<MatrixType> lu(A);
-  ControlPointVectorType controlPoints = lu.solve(MatrixType(b.transpose())).transpose();
-
-  SplineType spline(knots, controlPoints);
-
-  return spline;
-}
-
-template <typename SplineType>
-template <typename PointArrayType, typename IndexArray>
-SplineType SplineFitting<SplineType>::InterpolateWithDerivatives(const PointArrayType& points,
-                                                                 const PointArrayType& derivatives,
-                                                                 const IndexArray& derivativeIndices,
-                                                                 const unsigned int degree) {
-  ParameterVectorType parameters;
-  ChordLengths(points, parameters);
-  return InterpolateWithDerivatives(points, derivatives, derivativeIndices, degree, parameters);
-}
-}  // namespace Eigen
-
-#endif  // EIGEN_SPLINE_FITTING_H
diff --git a/unsupported/Eigen/src/Splines/SplineFwd.h b/unsupported/Eigen/src/Splines/SplineFwd.h
deleted file mode 100644
index ff648d4..0000000
--- a/unsupported/Eigen/src/Splines/SplineFwd.h
+++ /dev/null
@@ -1,109 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 20010-2011 Hauke Heibel <hauke.heibel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPLINES_FWD_H
-#define EIGEN_SPLINES_FWD_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-#include "../../../../Eigen/Core"
-
-namespace Eigen {
-template <typename Scalar, int Dim, int Degree = Dynamic>
-class Spline;
-
-template <typename SplineType, int DerivativeOrder = Dynamic>
-struct SplineTraits {};
-
-/**
- * \ingroup Splines_Module
- * \brief Compile-time attributes of the Spline class for Dynamic degree.
- **/
-template <typename Scalar_, int Dim_, int Degree_>
-struct SplineTraits<Spline<Scalar_, Dim_, Degree_>, Dynamic> {
-  typedef Scalar_ Scalar; /*!< The spline curve's scalar type. */
-  enum { Dimension = Dim_ /*!< The spline curve's dimension. */ };
-  enum { Degree = Degree_ /*!< The spline curve's degree. */ };
-
-  enum {
-    OrderAtCompileTime = Degree_ == Dynamic ? Dynamic : Degree_ + 1 /*!< The spline curve's order at compile-time. */
-  };
-  enum {
-    NumOfDerivativesAtCompileTime = OrderAtCompileTime /*!< The number of derivatives defined for the current spline. */
-  };
-
-  enum { DerivativeMemoryLayout = Dimension == 1 ? RowMajor : ColMajor /*!< The derivative type's memory layout. */ };
-
-  /** \brief The data type used to store non-zero basis functions. */
-  typedef Array<Scalar, 1, OrderAtCompileTime> BasisVectorType;
-
-  /** \brief The data type used to store the values of the basis function derivatives. */
-  typedef Array<Scalar, Dynamic, Dynamic, RowMajor, NumOfDerivativesAtCompileTime, OrderAtCompileTime>
-      BasisDerivativeType;
-
-  /** \brief The data type used to store the spline's derivative values. */
-  typedef Array<Scalar, Dimension, Dynamic, DerivativeMemoryLayout, Dimension, NumOfDerivativesAtCompileTime>
-      DerivativeType;
-
-  /** \brief The point type the spline is representing. */
-  typedef Array<Scalar, Dimension, 1> PointType;
-
-  /** \brief The data type used to store knot vectors. */
-  typedef Array<Scalar, 1, Dynamic> KnotVectorType;
-
-  /** \brief The data type used to store parameter vectors. */
-  typedef Array<Scalar, 1, Dynamic> ParameterVectorType;
-
-  /** \brief The data type representing the spline's control points. */
-  typedef Array<Scalar, Dimension, Dynamic> ControlPointVectorType;
-};
-
-/**
- * \ingroup Splines_Module
- * \brief Compile-time attributes of the Spline class for fixed degree.
- *
- * The traits class inherits all attributes from the SplineTraits of Dynamic degree.
- **/
-template <typename Scalar_, int Dim_, int Degree_, int _DerivativeOrder>
-struct SplineTraits<Spline<Scalar_, Dim_, Degree_>, _DerivativeOrder>
-    : public SplineTraits<Spline<Scalar_, Dim_, Degree_> > {
-  enum {
-    OrderAtCompileTime = Degree_ == Dynamic ? Dynamic : Degree_ + 1 /*!< The spline curve's order at compile-time. */
-  };
-  enum {
-    NumOfDerivativesAtCompileTime =
-        _DerivativeOrder == Dynamic
-            ? Dynamic
-            : _DerivativeOrder + 1 /*!< The number of derivatives defined for the current spline. */
-  };
-
-  enum { DerivativeMemoryLayout = Dim_ == 1 ? RowMajor : ColMajor /*!< The derivative type's memory layout. */ };
-
-  /** \brief The data type used to store the values of the basis function derivatives. */
-  typedef Array<Scalar_, Dynamic, Dynamic, RowMajor, NumOfDerivativesAtCompileTime, OrderAtCompileTime>
-      BasisDerivativeType;
-
-  /** \brief The data type used to store the spline's derivative values. */
-  typedef Array<Scalar_, Dim_, Dynamic, DerivativeMemoryLayout, Dim_, NumOfDerivativesAtCompileTime> DerivativeType;
-};
-
-/** \brief 2D float B-spline with dynamic degree. */
-typedef Spline<float, 2> Spline2f;
-
-/** \brief 3D float B-spline with dynamic degree. */
-typedef Spline<float, 3> Spline3f;
-
-/** \brief 2D double B-spline with dynamic degree. */
-typedef Spline<double, 2> Spline2d;
-
-/** \brief 3D double B-spline with dynamic degree. */
-typedef Spline<double, 3> Spline3d;
-}  // namespace Eigen
-
-#endif  // EIGEN_SPLINES_FWD_H
diff --git a/unsupported/Eigen/src/Tensor/InternalHeaderCheck.h b/unsupported/Eigen/src/Tensor/InternalHeaderCheck.h
deleted file mode 100644
index b741924..0000000
--- a/unsupported/Eigen/src/Tensor/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_CXX11_TENSOR_MODULE_H
-#error "Please include unsupported/Eigen/Tensor instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/Tensor/README.md b/unsupported/Eigen/src/Tensor/README.md
deleted file mode 100644
index bf65304..0000000
--- a/unsupported/Eigen/src/Tensor/README.md
+++ /dev/null
@@ -1,2856 +0,0 @@
-# Eigen Tensors {#eigen_tensors}
-
-Tensors are multidimensional arrays of elements. Elements are typically scalars,
-but more complex types such as strings are also supported.
-
-The Tensor module is part of Eigen's unsupported modules. While it is actively
-used in production (e.g. in TensorFlow), its API may change without notice.
-
-To use the Tensor module, include the following header:
-
-```cpp
-#include <unsupported/Eigen/Tensor>
-```
-
-## Quick Start
-
-```cpp
-#include <unsupported/Eigen/Tensor>
-#include <iostream>
-
-int main() {
-  // Create a 3x4 matrix as a rank-2 tensor.
-  Eigen::Tensor<float, 2> a(3, 4);
-  a.setRandom();
-
-  // Create another tensor and compute their element-wise sum.
-  Eigen::Tensor<float, 2> b(3, 4);
-  b.setConstant(1.0f);
-  Eigen::Tensor<float, 2> c = a + b;
-
-  // Reduce: compute the sum of all elements.
-  Eigen::Tensor<float, 0> total = c.sum();
-  std::cout << "Sum of all elements: " << total() << "\n";
-
-  // Reshape and broadcast.
-  Eigen::Tensor<float, 2> d = c.reshape(Eigen::array<Eigen::Index, 2>{{1, 12}})
-                                .broadcast(Eigen::array<Eigen::Index, 2>{{3, 1}});
-  std::cout << "d has shape: " << d.dimension(0) << " x " << d.dimension(1) << "\n";
-  return 0;
-}
-```
-
-## Tensor Classes
-
-You can manipulate a tensor with one of the following classes.  They all are in
-the namespace `::Eigen`.
-
-### Class Tensor\<Scalar, NumIndices, Options, IndexType\>
-
-This is the class to use to create a tensor and allocate memory for it.
-
-Template parameters:
-
-| Parameter | Description | Default |
-|-----------|-------------|---------|
-| `Scalar` | Element type (e.g. `float`, `int`, `std::string`) | (required) |
-| `NumIndices` | Rank (number of dimensions) | (required) |
-| `Options` | `ColMajor` (0) or `RowMajor` | `0` (`ColMajor`) |
-| `IndexType` | Type used for indexing (e.g. `int`, `long`) | `Eigen::DenseIndex` |
-
-Tensors of this class are resizable.  For example, if you assign a tensor of a
-different size to a Tensor, that tensor is resized to match its new value.
-
-#### Constructor Tensor\<Scalar, NumIndices\>(size0, size1, ...)
-
-Constructor for a Tensor.  The constructor must be passed `NumIndices` integers
-indicating the sizes of the instance along each of the dimensions.
-
-```cpp
-// Create a tensor of rank 3 of sizes 2, 3, 4.  This tensor owns
-// memory to hold 24 floating point values (24 = 2 x 3 x 4).
-Tensor<float, 3> t_3d(2, 3, 4);
-
-// Resize t_3d by assigning a tensor of different sizes, but same rank.
-t_3d = Tensor<float, 3>(3, 4, 3);
-```
-
-#### Constructor Tensor\<Scalar, NumIndices\>(size_array)
-
-Constructor where the sizes for the constructor are specified as an array of
-values instead of an explicit list of parameters.  The array type to use is
-`Eigen::array<Eigen::Index, NumIndices>`.  The array can be constructed
-automatically from an initializer list.
-
-```cpp
-// Create a tensor of strings of rank 2 with sizes 5, 7.
-Tensor<string, 2> t_2d({5, 7});
-```
-
-### Class TensorFixedSize\<Scalar, Sizes\<size0, size1, ...\>, Options, IndexType\>
-
-Class to use for tensors of fixed size, where the size is known at compile
-time.  Fixed sized tensors can provide very fast computations because all their
-dimensions are known by the compiler.  FixedSize tensors are not resizable.
-
-If the total number of elements in a fixed size tensor is small enough the
-tensor data is held onto the stack and does not cause heap allocation and free.
-
-```cpp
-// Create a 4 x 3 tensor of floats.
-TensorFixedSize<float, Sizes<4, 3>> t_4x3;
-```
-
-### Class TensorMap\<Tensor\<Scalar, NumIndices, Options\>\>
-
-This is the class to use to create a tensor on top of memory allocated and
-owned by another part of your code.  It allows to view any piece of allocated
-memory as a `Tensor`.  Instances of this class do not own the memory where the
-data are stored.
-
-A `TensorMap` is not resizable because it does not own the memory where its data
-are stored.
-
-An optional alignment template parameter controls whether Eigen can assume
-the data pointer is aligned: `TensorMap<Tensor<float, 2>, Aligned>`.
-
-#### Constructor TensorMap\<Tensor\<Scalar, NumIndices\>\>(data, size0, size1, ...)
-
-Constructor for a TensorMap.  The constructor must be passed a pointer to the
-storage for the data, and `NumIndices` size attributes.  The storage has to be
-large enough to hold all the data.
-
-```cpp
-// Map a tensor of ints on top of stack-allocated storage.
-int storage[128];  // 2 x 4 x 2 x 8 = 128
-TensorMap<Tensor<int, 4>> t_4d(storage, 2, 4, 2, 8);
-
-// The same storage can be viewed as a different tensor.
-// You can also pass the sizes as an array.
-TensorMap<Tensor<int, 2>> t_2d(storage, 16, 8);
-
-// You can also map fixed-size tensors.  Here we get a 1d view of
-// the 2d fixed-size tensor.
-TensorFixedSize<float, Sizes<4, 3>> t_4x3;
-TensorMap<Tensor<float, 1>> t_12(t_4x3.data(), 12);
-```
-
-#### Class TensorRef
-
-See **Assigning to a `TensorRef`**.
-
-## Accessing Tensor Elements
-
-#### Scalar tensor(index0, index1...)
-
-Return the element at position `(index0, index1...)` in tensor
-`tensor`.  You must pass as many parameters as the rank of `tensor`.
-The expression can be used as an l-value to set the value of the element at the
-specified position.  The value returned is of the datatype of the tensor.
-
-```cpp
-// Set the value of the element at position (0, 1, 0);
-Tensor<float, 3> t_3d(2, 3, 4);
-t_3d(0, 1, 0) = 12.0f;
-
-// Initialize all elements to random values.
-for (int i = 0; i < 2; ++i) {
-  for (int j = 0; j < 3; ++j) {
-    for (int k = 0; k < 4; ++k) {
-      t_3d(i, j, k) = ...some random value...;
-    }
-  }
-}
-
-// Print elements of a tensor.
-for (int i = 0; i < 2; ++i) {
-  std::cout << t_3d(i, 0, 0);
-}
-```
-
-## TensorLayout
-
-The tensor library supports 2 layouts: `ColMajor` (the default) and
-`RowMajor`.
-
-The layout of a tensor is optionally specified as the third template parameter
-(`Options`). If not specified explicitly, column major is assumed.
-
-```cpp
-Tensor<float, 3, ColMajor> col_major;  // equivalent to Tensor<float, 3>
-TensorMap<Tensor<float, 3, RowMajor>> row_major(data, ...);
-```
-
-All the arguments to an expression must use the same layout. Attempting to mix
-different layouts will result in a compilation error.
-
-It is possible to change the layout of a tensor or an expression using the
-`swap_layout()` method.  Note that this will also reverse the order of the
-dimensions.
-
-```cpp
-Tensor<float, 2, ColMajor> col_major(2, 4);
-Tensor<float, 2, RowMajor> row_major(2, 4);
-
-Tensor<float, 2> col_major_result = col_major;  // ok, layouts match
-Tensor<float, 2> col_major_result = row_major;  // will not compile
-
-// Simple layout swap
-col_major_result = row_major.swap_layout();
-eigen_assert(col_major_result.dimension(0) == 4);
-eigen_assert(col_major_result.dimension(1) == 2);
-
-// Swap the layout and preserve the order of the dimensions
-array<int, 2> shuffle{{1, 0}};
-col_major_result = row_major.swap_layout().shuffle(shuffle);
-eigen_assert(col_major_result.dimension(0) == 2);
-eigen_assert(col_major_result.dimension(1) == 4);
-```
-
-## Tensor Operations
-
-The Eigen Tensor library provides a vast library of operations on Tensors:
-numerical operations such as addition and multiplication, geometry operations
-such as slicing and shuffling, etc.  These operations are available as methods
-of the `Tensor` classes, and in some cases as operator overloads.  For example
-the following code computes the elementwise addition of two tensors:
-
-```cpp
-Tensor<float, 3> t1(2, 3, 4);
-t1.setRandom();
-Tensor<float, 3> t2(2, 3, 4);
-t2.setRandom();
-// Set t3 to the element wise sum of t1 and t2
-Tensor<float, 3> t3 = t1 + t2;
-```
-
-While the code above looks easy enough, it is important to understand that the
-expression `t1 + t2` is not actually adding the values of the tensors.  The
-expression instead constructs a "tensor operator" object of the class
-`TensorCwiseBinaryOp<scalar_sum>`, which has references to the tensors
-`t1` and `t2`.  This is a small C++ object that knows how to add
-`t1` and `t2`.  It is only when the value of the expression is assigned
-to the tensor `t3` that the addition is actually performed.  Technically,
-this happens through the overloading of `operator=` in the Tensor class.
-
-This mechanism for computing tensor expressions allows for lazy evaluation and
-optimizations which are what make the tensor library very fast.
-
-Of course, the tensor operators do nest, and the expression `t1 + t2 * 0.3f`
-is actually represented with the (approximate) tree of operators:
-
-```cpp
-TensorCwiseBinaryOp<scalar_sum>(t1, TensorCwiseUnaryOp<scalar_mul>(t2, 0.3f))
-```
-
-### Tensor Operations and C++ "auto"
-
-Because `Tensor` operations create tensor operators, the C++ `auto` keyword
-does not have its intuitive meaning.  Consider these 2 lines of code:
-
-```cpp
-Tensor<float, 3> t3 = t1 + t2;
-auto t4 = t1 + t2;
-```
-
-In the first line we allocate the tensor `t3` and it will contain the
-result of the addition of `t1` and `t2`.  In the second line, `t4`
-is actually the tree of tensor operators that will compute the addition of
-`t1` and `t2`.  In fact, `t4` is *not* a tensor and you cannot get
-the values of its elements:
-
-```cpp
-Tensor<float, 3> t3 = t1 + t2;
-std::cout << t3(0, 0, 0);  // OK prints the value of t1(0, 0, 0) + t2(0, 0, 0)
-
-auto t4 = t1 + t2;
-std::cout << t4(0, 0, 0);  // Compilation error!
-```
-
-When you use `auto` you do not get a `Tensor` as a result but instead a
-non-evaluated expression.
-So only use `auto` to delay evaluation.
-
-Unfortunately, there is no single underlying concrete type for holding
-non-evaluated expressions, hence you have to use `auto` in the case when you do
-want to hold non-evaluated expressions.
-
-When you need the results of set of tensor computations you have to assign the
-result to a `Tensor` that will be capable of holding onto them.  This can be
-either a normal `Tensor`, a `TensorFixedSize`, or a `TensorMap` on an existing
-piece of memory.  All the following will work:
-
-```cpp
-auto t4 = t1 + t2;
-
-Tensor<float, 3> result = t4;  // Could also be: result(t4);
-std::cout << result(0, 0, 0);
-
-TensorMap<Tensor<float, 3>> result2(some_float_ptr, dim0, dim1, dim2);
-result2 = t4;
-std::cout << result2(0, 0, 0);
-
-TensorFixedSize<float, Sizes<4, 4, 2>> result3 = t4;
-std::cout << result3(0, 0, 0);
-```
-
-Until you need the results, you can keep the operation around, and even reuse
-it for additional operations.  As long as you keep the expression as an
-operation, no computation is performed.
-
-```cpp
-// One way to compute exp((t1 + t2) * 0.2f);
-auto t3 = t1 + t2;
-auto t4 = t3 * 0.2f;
-auto t5 = t4.exp();
-Tensor<float, 3> result = t5;
-
-// Another way, exactly as efficient as the previous one:
-Tensor<float, 3> result = ((t1 + t2) * 0.2f).exp();
-```
-
-### Controlling When Expressions are Evaluated
-
-There are several ways to control when expressions are evaluated:
-
-*   Assignment to a `Tensor`, `TensorFixedSize`, or `TensorMap`.
-*   Use of the `eval()` method.
-*   Assignment to a `TensorRef`.
-
-#### Assigning to a Tensor, TensorFixedSize, or TensorMap.
-
-The most common way to evaluate an expression is to assign it to a `Tensor`.
-In the example below, the `auto` declarations make the intermediate values
-"Operations", not Tensors, and do not cause the expressions to be evaluated.
-The assignment to the Tensor `result` causes the evaluation of all the
-operations.
-
-```cpp
-auto t3 = t1 + t2;             // t3 is an Operation.
-auto t4 = t3 * 0.2f;           // t4 is an Operation.
-auto t5 = t4.exp();            // t5 is an Operation.
-Tensor<float, 3> result = t5;  // The operations are evaluated.
-```
-
-If you know the ranks and sizes of the Operation value you can assign the
-Operation to a `TensorFixedSize` instead of a `Tensor`, which is a bit more efficient.
-
-```cpp
-// We know that the result is a 4x4x2 tensor!
-TensorFixedSize<float, Sizes<4, 4, 2>> result = t5;
-```
-
-Similarly, assigning an expression to a `TensorMap` causes its evaluation.
-Like tensors of type `TensorFixedSize`, a `TensorMap` cannot be resized so they have to
-have the rank and sizes of the expression that are assigned to them.
-
-#### Calling eval().
-
-When you compute large composite expressions, you sometimes want to tell Eigen
-that an intermediate value in the expression tree is worth evaluating ahead of
-time.
-This is done by inserting a call to the `eval()` method of the
-expression Operation.
-
-```cpp
-// The previous example could have been written:
-Tensor<float, 3> result = ((t1 + t2) * 0.2f).exp();
-
-// If you want to compute (t1 + t2) once ahead of time you can write:
-Tensor<float, 3> result = ((t1 + t2).eval() * 0.2f).exp();
-```
-
-Semantically, calling `eval()` is equivalent to materializing the value of
-the expression in a temporary `Tensor` of the right size.
-The code above in effect does:
-
-```cpp
-// .eval() knows the size!
-TensorFixedSize<float, Sizes<4, 4, 2>> tmp = t1 + t2;
-Tensor<float, 3> result = (tmp * 0.2f).exp();
-```
-
-Note that the return value of `eval()` is itself an Operation, so the
-following code does not do what you may think:
-
-```cpp
-// Here t3 is an evaluation Operation.  t3 has not been evaluated yet.
-auto t3 = (t1 + t2).eval();
-
-// You can use t3 in another expression.  Still no evaluation.
-auto t4 = (t3 * 0.2f).exp();
-
-// The value is evaluated when you assign the Operation to a Tensor, using
-// an intermediate tensor to represent t3.
-Tensor<float, 3> result = t4;
-```
-
-While in the examples above calling `eval()` does not make a difference in
-performance, in other cases it can make a huge difference.  In the expression
-below the `broadcast()` expression causes the `X.maximum()` expression
-to be evaluated many times:
-
-```cpp
-Tensor<...> X ...;
-Tensor<...> Y = ((X - X.maximum(depth_dim).reshape(dims2d).broadcast(bcast))
-                 * beta).exp();
-```
-
-Inserting a call to `eval()` between the `maximum()` and
-`reshape()` calls guarantees that `maximum()` is only computed once and
-greatly speeds-up execution:
-
-```cpp
-Tensor<...> Y =
-  ((X - X.maximum(depth_dim).eval().reshape(dims2d).broadcast(bcast))
-    * beta).exp();
-```
-
-In the other example below, the tensor `Y` is both used in the expression and its assignment.
-This is an aliasing problem and if the evaluation is not done in the right order
-Y will be updated incrementally during the evaluation
-resulting in bogus results:
-
-```cpp
- Tensor<...> Y ...;
- Y = Y / (Y.sum(depth_dim).reshape(dims2d).broadcast(bcast));
-```
-
-Inserting a call to `eval()` between the `sum()` and `reshape()`
-expressions ensures that the sum is computed before any updates to `Y` are
-done.
-
-```cpp
- Y = Y / (Y.sum(depth_dim).eval().reshape(dims2d).broadcast(bcast));
-```
-
-Note that an eval around the full right hand side expression is not needed
-because the generated has to compute the `i`-th value of the right hand side
-before assigning it to the left hand side.
-
-However, if you were assigning the expression value to a shuffle of `Y`
-then you would need to force an eval for correctness by adding an `eval()`
-call for the right hand side:
-
-```cpp
- Y.shuffle(...) =
-    (Y / (Y.sum(depth_dim).eval().reshape(dims2d).broadcast(bcast))).eval();
-```
-
-#### Assigning to a TensorRef.
-
-If you need to access only a few elements from the value of an expression you
-can avoid materializing the value in a full tensor by using a `TensorRef`.
-
-A `TensorRef` is a small wrapper class for any Eigen Operation.  It provides
-overloads for the `()` operator that let you access individual values in
-the expression.
-`TensorRef` is convenient, because the Operation themselves do
-not provide a way to access individual elements.
-
-```cpp
-// Create a TensorRef for the expression.  The expression is not
-// evaluated yet.
-TensorRef<Tensor<float, 3>> ref = ((t1 + t2) * 0.2f).exp();
-
-// Use "ref" to access individual elements.  The expression is evaluated
-// on the fly.
-float at_0 = ref(0, 0, 0);
-std::cout << ref(0, 1, 0);
-```
-
-Only use `TensorRef` when you need a subset of the values of the expression.
-`TensorRef` only computes the values you access.
-However note that if you are going to access all the values it will be much
- faster to materialize the results in a `Tensor` first.
-
-In some cases, if the full `Tensor` result would be very large, you may save
-memory by accessing it as a `TensorRef`.
-But not always.
-So don't count on it.
-
-
-### Controlling How Expressions Are Evaluated
-
-The tensor library provides several implementations of the various operations
-such as contractions and convolutions.  The implementations are optimized for
-different environments: single threaded on CPU, multi threaded on CPU, or on a
-GPU using CUDA/HIP/SYCL.
-
-You can choose which implementation to use with the `device()` call.  If
-you do not choose an implementation explicitly the default implementation that
-uses a single thread on the CPU is used.
-
-The default implementation has been optimized for modern CPUs, taking
-advantage of SSE, AVX, AVX-512, ARM NEON, SVE, RISC-V Vector (RVV), and other
-SIMD instruction sets. Note that you need to pass compiler-dependent flags
-to enable the use of these instructions (e.g. `-mavx2`, `-march=native`).
-
-For example, the following code adds two tensors using the default
-single-threaded CPU implementation:
-
-```cpp
-Tensor<float, 2> a(30, 40);
-Tensor<float, 2> b(30, 40);
-Tensor<float, 2> c = a + b;
-```
-
-To choose a different implementation you have to insert a `device()` call
-before the assignment of the result.  For technical C++ reasons this requires
-that the `Tensor` for the result be declared on its own.
-This means that you have to know the size of the result.
-
-```cpp
-Eigen::Tensor<float, 2> c(30, 40);
-c.device(...) = a + b;
-```
-
-The call to `device()` must be the last call on the left of the operator=.
-
-You must pass to the `device()` call an Eigen device object.  There are
-presently four devices you can use: `DefaultDevice`, `ThreadPoolDevice`,
-`GpuDevice`, and `SyclDevice`.
-
-
-#### Evaluating With the DefaultDevice
-
-This is exactly the same as not inserting a `device()` call.
-
-```cpp
-DefaultDevice my_device;
-c.device(my_device) = a + b;
-```
-
-#### Evaluating with a Thread Pool
-
-To use `ThreadPoolDevice`, you must define `EIGEN_USE_THREADS` before
-including the Tensor header:
-
-```cpp
-#define EIGEN_USE_THREADS
-#include <unsupported/Eigen/Tensor>
-
-// Create the Eigen ThreadPool.
-Eigen::ThreadPool pool(8 /* number of threads in pool */);
-
-// Create the Eigen ThreadPoolDevice.
-Eigen::ThreadPoolDevice my_device(&pool, 4 /* number of threads to use */);
-
-// Now just use the device when evaluating expressions.
-Eigen::Tensor<float, 2> c(30, 50);
-c.device(my_device) = a.contract(b, dot_product_dims);
-```
-
-
-#### Evaluating On GPU
-
-To use `GpuDevice`, you must define `EIGEN_USE_GPU` before including the
-Tensor header.  GPU tensors require explicitly allocating device memory
-with CUDA or HIP APIs.
-
-```cpp
-#define EIGEN_USE_GPU
-#include <unsupported/Eigen/Tensor>
-
-// Allocate data on GPU.
-float* d_a;
-float* d_b;
-float* d_c;
-cudaMalloc((void**)&d_a, 30 * 40 * sizeof(float));
-cudaMalloc((void**)&d_b, 30 * 40 * sizeof(float));
-cudaMalloc((void**)&d_c, 30 * 40 * sizeof(float));
-
-// Copy host data to device.
-cudaMemcpy(d_a, h_a, 30 * 40 * sizeof(float), cudaMemcpyHostToDevice);
-cudaMemcpy(d_b, h_b, 30 * 40 * sizeof(float), cudaMemcpyHostToDevice);
-
-// Create device maps.
-Eigen::TensorMap<Eigen::Tensor<float, 2>> gpu_a(d_a, 30, 40);
-Eigen::TensorMap<Eigen::Tensor<float, 2>> gpu_b(d_b, 30, 40);
-Eigen::TensorMap<Eigen::Tensor<float, 2>> gpu_c(d_c, 30, 40);
-
-// Create a GPU device and evaluate.
-Eigen::GpuStreamDevice stream;
-Eigen::GpuDevice gpu_device(&stream);
-gpu_c.device(gpu_device) = gpu_a + gpu_b;
-
-// Synchronize and copy back.
-cudaStreamSynchronize(stream.stream());
-cudaMemcpy(h_c, d_c, 30 * 40 * sizeof(float), cudaMemcpyDeviceToHost);
-
-cudaFree(d_a);
-cudaFree(d_b);
-cudaFree(d_c);
-```
-
-For HIP, replace `cuda*` calls with the corresponding `hip*` calls.
-
-#### Asynchronous Device Execution
-
-You can pass a callback to the `device()` call that will be invoked when the
-computation completes.  This is supported by `ThreadPoolDevice` and `GpuDevice`.
-
-```cpp
-Eigen::Tensor<float, 2> c(30, 40);
-auto done = []() { std::cout << "Computation complete!\n"; };
-c.device(my_device, done) = a + b;
-// The callback will be invoked when evaluation finishes.
-```
-
-
-## API Reference
-
-### Datatypes
-
-In the documentation of the tensor methods and Operation we mention datatypes
-that are tensor-type specific:
-
-#### \<Tensor-Type\>::Dimensions
-
-Acts like an array of `Index`. Has a `size()` method (inherited from
-`std::array`) and a static `count` member equal to the rank. Can be
-indexed like an array to access individual values.  Used to represent the
-dimensions of a tensor.  See `dimensions()`.
-
-#### \<Tensor-Type\>::Index
-
-Acts like an `int`.  Used for indexing tensors along their dimensions.  See
-`operator()`, `dimension()`, and `size()`.
-
-#### \<Tensor-Type\>::Scalar
-
-Represents the datatype of individual tensor elements.  For example, for a
-`Tensor<float>`, `Scalar` is the type `float`.  See `setConstant()`.
-
-#### (Operation)
-
-We use this pseudo type to indicate that a tensor Operation is returned by a
-method.  We indicate in the text the type and dimensions of the tensor that the
-Operation returns after evaluation.
-
-The Operation will have to be evaluated, for example by assigning it to a
-`Tensor`, before you can access the values of the resulting tensor.  You can also
-access the values through a `TensorRef`.
-
-
-## Built-in Tensor Methods
-
-These are usual C++ methods that act on tensors immediately.  They are not
-Operations which provide delayed evaluation of their results.  Unless specified
-otherwise, all the methods listed below are available on all tensor classes:
-`Tensor`, `TensorFixedSize`, and `TensorMap`.
-
-## Metadata
-
-### int NumDimensions
-
-Constant value indicating the number of dimensions of a `Tensor`.
-This is also known as the tensor rank.
-
-```cpp
-Eigen::Tensor<float, 2> a(3, 4);
-std::cout << "Dims " << a.NumDimensions;
-// Dims 2
-```
-
-### Dimensions dimensions()
-
-Returns an array-like object representing the dimensions of the tensor.
-The actual type of the `dimensions()` result is `<Tensor-Type>::Dimensions`.
-
-```cpp
-Eigen::Tensor<float, 2> a(3, 4);
-const Eigen::Tensor<float, 2>::Dimensions& d = a.dimensions();
-std::cout << "Dim size: " << d.size() << ", dim 0: " << d[0]
-          << ", dim 1: " << d[1];
-//  Dim size: 2, dim 0: 3, dim 1: 4
-```
-
-You can use `auto` to simplify the code:
-
-```cpp
-const auto& d = a.dimensions();
-std::cout << "Dim size: " << d.size() << ", dim 0: " << d[0]
-        << ", dim 1: " << d[1];
-// Dim size: 2, dim 0: 3, dim 1: 4
-```
-
-### Index dimension(Index n)
-
-Returns the n-th dimension of the tensor.  The actual type of the
-`dimension()` result is `<Tensor-Type>::Index`, but you can
-always use it like an int.
-
-```cpp
-Eigen::Tensor<float, 2> a(3, 4);
-int dim1 = a.dimension(1);
-std::cout << "Dim 1: " << dim1;
-// Dim 1: 4
-```
-
-### Index size()
-
-Returns the total number of elements in the tensor.  This is the product of all
-the tensor dimensions.  The actual type of the `size()` result is
-`<Tensor-Type>::Index`, but you can always use it like an int.
-
-```cpp
-Eigen::Tensor<float, 2> a(3, 4);
-std::cout << "Size: " << a.size();
-/// Size: 12
-```
-
-### Getting Dimensions From An Operation
-
-A few operations provide `dimensions()` directly,
-e.g. `TensorSlicingOp`.  Most operations defer calculating dimensions
-until the operation is being evaluated.  If you need access to the dimensions
-of a deferred operation, you can wrap it in a `TensorRef` (see
-**Assigning to a TensorRef** above), which provides
-`dimensions()` and `dimension()` as above.
-
-`TensorRef` can also wrap the plain `Tensor` types, so this is a useful idiom in
-templated contexts where the underlying object could be either a raw `Tensor`
-or some deferred operation (e.g. a slice of a `Tensor`).  In this case, the
-template code can wrap the object in a TensorRef and reason about its
-dimensionality while remaining agnostic to the underlying type.
-
-
-## Constructors
-
-### Tensor
-
-Creates a tensor of the specified size. The number of arguments must be equal
-to the rank of the tensor. The content of the tensor is not initialized.
-
-```cpp
-Eigen::Tensor<float, 2> a(3, 4);
-std::cout << "NumRows: " << a.dimension(0) << " NumCols: " << a.dimension(1) << endl;
-// NumRows: 3 NumCols: 4
-```
-### TensorFixedSize
-
-Creates a tensor of the specified size. The number of arguments in the `Sizes<>`
-template parameter determines the rank of the tensor. The content of the tensor
-is not initialized.
-
-```cpp
-Eigen::TensorFixedSize<float, Sizes<3, 4>> a;
-std::cout << "Rank: " << a.rank() << endl;
-// Rank: 2
-std::cout << "NumRows: " << a.dimension(0)
-          << " NumCols: " << a.dimension(1) << endl;
-// NumRows: 3 NumCols: 4
-```
-
-### TensorMap
-
-Creates a tensor mapping an existing array of data. The data must not be freed
-until the `TensorMap` is discarded, and the size of the data must be large enough
-to accommodate the coefficients of the tensor.
-
-```cpp
-float data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
-Eigen::TensorMap<Tensor<float, 2>> a(data, 3, 4);
-std::cout << "NumRows: " << a.dimension(0) << " NumCols: " << a.dimension(1) << endl;
-// NumRows: 3 NumCols: 4
-std::cout << "a(1, 2): " << a(1, 2) << endl;
-// a(1, 2): 7
-```
-
-## Contents Initialization
-
-When a new `Tensor` or a new `TensorFixedSize` are created, memory is allocated to
-hold all the tensor elements, but the memory is not initialized.  Similarly,
-when a new `TensorMap` is created on top of non-initialized memory the memory its
-contents are not initialized.
-
-You can use one of the methods below to initialize the tensor memory.  These
-have an immediate effect on the tensor and return the tensor itself as a
-result.  These are not tensor Operations which delay evaluation.
-
-### \<Tensor-Type\> setConstant(const Scalar& val)
-
-Sets all elements of the tensor to the constant value `val`.  `Scalar`
-is the type of data stored in the tensor.  You can pass any value that is
-convertible to that type.
-
-Returns the tensor itself in case you want to chain another call.
-
-```cpp
-a.setConstant(12.3f);
-std::cout << "Constant: " << endl << a << endl << endl;
-
-// Constant:
-// 12.3 12.3 12.3 12.3
-// 12.3 12.3 12.3 12.3
-// 12.3 12.3 12.3 12.3
-```
-Note that `setConstant()` can be used on any tensor where the element type
-has a copy constructor and an `operator=()`:
-
-```cpp
-Eigen::Tensor<string, 2> a(2, 3);
-a.setConstant("yolo");
-std::cout << "String tensor: " << endl << a << endl << endl;
-
-// String tensor:
-// yolo yolo yolo
-// yolo yolo yolo
-```
-
-### \<Tensor-Type\> setZero()
-
-Fills the tensor with zeros.  Equivalent to `setConstant(Scalar(0))`.
-Returns the tensor itself in case you want to chain another call.
-
-```cpp
-a.setZero();
-std::cout << "Zeros: " << endl << a << endl << endl;
-
-// Zeros:
-// 0 0 0 0
-// 0 0 0 0
-// 0 0 0 0
-```
-
-### \<Tensor-Type\> setValues({..initializer_list})
-
-Fills the tensor with explicit values specified in a std::initializer_list.
-The type of the initializer list depends on the type and rank of the tensor.
-
-If the tensor has rank N, the initializer list must be nested N times.  The
-most deeply nested lists must contains P scalars of the `Tensor` type where P is
-the size of the last dimension of the Tensor.
-
-For example, for a `TensorFixedSize<float, Sizes<2, 3>>` the initializer list
-must contains 2 lists of 3 floats each.
-
-`setValues()` returns the tensor itself in case you want to chain another
-call.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setValues({{0.0f, 1.0f, 2.0f}, {3.0f, 4.0f, 5.0f}});
-std::cout << "a" << endl << a << endl << endl;
-
-// a
-// 0 1 2
-// 3 4 5
-```
-
-If a list is too short, the corresponding elements of the tensor will not be
-changed.  This is valid at each level of nesting.  For example the following
-code only sets the values of the first row of the tensor.
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setConstant(1000);
-a.setValues({{10, 20, 30}});
-std::cout << "a" << endl << a << endl << endl;
-// a
-// 10   20   30
-// 1000 1000 1000
-```
-
-### \<Tensor-Type\> setRandom()
-
-Fills the tensor with random values.  Returns the tensor itself in case you
-want to chain another call.
-
-```cpp
-a.setRandom();
-std::cout << "Random: " << endl << a << endl << endl;
-// Random:
-//   0.680375    0.59688  -0.329554    0.10794
-//  -0.211234   0.823295   0.536459 -0.0452059
-//   0.566198  -0.604897  -0.444451   0.257742
-```
-
-You can customize `setRandom()` by providing your own random number
-generator as a template argument:
-
-```cpp
-a.setRandom<MyRandomGenerator>();
-```
-
-Here, `MyRandomGenerator` must be a struct with the following member
-functions, where Scalar and Index are the same as `<Tensor-Type>::Scalar`
-and `<Tensor-Type>::Index`.
-
-See `struct UniformRandomGenerator` in TensorFunctors.h for an example.
-
-```cpp
-// Custom number generator for use with setRandom().
-struct MyRandomGenerator {
-  // Default and copy constructors. Both are needed
-  MyRandomGenerator() { }
-  MyRandomGenerator(const MyRandomGenerator& ) { }
-
-  // Return a random value to be used.  "element_location" is the
-  // location of the entry to set in the tensor, it can typically
-  // be ignored.
-  Scalar operator()(Eigen::DenseIndex element_location,
-                    Eigen::DenseIndex /*unused*/ = 0) const {
-    return <randomly generated value of type T>;
-  }
-
-  // Same as above but generates several numbers at a time.
-  typename internal::packet_traits<Scalar>::type packetOp(
-      Eigen::DenseIndex packet_location, Eigen::DenseIndex /*unused*/ = 0) const {
-    return <a packet of randomly generated values>;
-  }
-};
-```
-
-You can also use one of the 2 random number generators that are part of the
-tensor library:
-*   UniformRandomGenerator
-*   NormalRandomGenerator
-
-## Data Access
-
-The Tensor, TensorFixedSize, and TensorRef classes provide the following
-accessors to access the tensor coefficients:
-
-```cpp
-const Scalar& operator()(const array<Index, NumIndices>& indices)
-const Scalar& operator()(Index firstIndex, IndexTypes... otherIndices)
-Scalar& operator()(const array<Index, NumIndices>& indices)
-Scalar& operator()(Index firstIndex, IndexTypes... otherIndices)
-```
-
-The number of indices must be equal to the rank of the tensor. Moreover, these
-accessors are not available on tensor expressions. In order to access the
-values of a tensor expression, the expression must either be evaluated or
-wrapped in a TensorRef.
-
-### Scalar* data() and const Scalar* data() const
-
-Returns a pointer to the storage for the tensor.  The pointer is const if the
-tensor was const.  This allows direct access to the data.  The layout of the
-data depends on the tensor layout: `RowMajor` or `ColMajor`.
-
-This access is usually only needed for special cases, for example when mixing
-Eigen Tensor code with other libraries.
-
-Scalar is the type of data stored in the tensor.
-
-```cpp
-Eigen::Tensor<float, 2> a(3, 4);
-float* a_data = a.data();
-a_data[0] = 123.45f;
-std::cout << "a(0, 0): " << a(0, 0);
-// a(0, 0): 123.45
-```
-
-## Tensor Operations
-
-All the methods documented below return non evaluated tensor `Operations`.
-These can be chained: you can apply another `Tensor` Operation to the value
-returned by the method.
-
-The chain of Operation is evaluated lazily, typically when it is assigned to a
-tensor.  See **Controlling When Expressions are Evaluated** for more details about
-their evaluation.
-
-### (Operation) constant(const Scalar& val)
-
-Returns a tensor of the same type and dimensions as the original tensor but
-where all elements have the value `val`.
-
-This is useful, for example, when you want to add or subtract a constant from a
-tensor, or multiply every element of a tensor by a scalar.
-However, such operations can also be performed using operator overloads (see `operator+`).
-
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setConstant(1.0f);
-Eigen::Tensor<float, 2> b = a + a.constant(2.0f);
-Eigen::Tensor<float, 2> c = b * b.constant(0.2f);
-std::cout << "a" << endl << a << endl << endl;
-std::cout << "b" << endl << b << endl << endl;
-std::cout << "c" << endl << c << endl << endl;
-// a
-// 1 1 1
-// 1 1 1
-
-// b
-// 3 3 3
-// 3 3 3
-
-// c
-// 0.6 0.6 0.6
-// 0.6 0.6 0.6
-```
-
-### (Operation) random()
-
-Returns a tensor of the same type and dimensions as the current tensor
-but where all elements have random values.
-
-This is for example useful to add random values to an existing tensor.
-The generation of random values can be customized in the same manner
-as for `setRandom()`.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setConstant(1.0f);
-Eigen::Tensor<float, 2> b = a + a.random();
-std::cout << "a\n" << a << "\n\n";
-std::cout << "b\n" << b << "\n\n";
-
-// a
-// 1 1 1
-// 1 1 1
-// b
-// 1.68038   1.5662  1.82329
-// 0.788766  1.59688
-```
-
-## Unary Element Wise Operations
-
-All these operations take a single input tensor as argument and return a tensor
-of the same type and dimensions as the tensor to which they are applied.  The
-requested operations are applied to each element independently.
-
-### (Operation) operator-()
-
-Returns a tensor of the same type and dimensions as the original tensor
-containing the opposite values of the original tensor.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setConstant(1.0f);
-Eigen::Tensor<float, 2> b = -a;
-std::cout << "a\n" << a << "\n\n";
-std::cout << "b\n" << b << "\n\n";
-
-// a
-// 1 1 1
-// 1 1 1
-//
-// b
-// -1 -1 -1
-// -1 -1 -1
-```
-
-### (Operation) sqrt()
-
-Returns a tensor containing the square roots of the original tensor.
-
-### (Operation) rsqrt()
-
-Returns a tensor containing the inverse square roots (1/sqrt(x)) of the original tensor.
-
-### (Operation) square()
-
-Returns a tensor containing the squares of the original tensor values.
-
-### (Operation) cube()
-
-Returns a tensor containing the cubes (x^3) of the original tensor values.
-
-### (Operation) inverse()
-
-Returns a tensor containing the inverse (1/x) of the original tensor values.
-
-### (Operation) exp()
-
-Returns a tensor containing the exponential of the original tensor.
-
-### (Operation) expm1()
-
-Returns a tensor containing `exp(x) - 1` for each element. More accurate
-than `exp(x) - 1` for small values of x.
-
-### (Operation) log()
-
-Returns a tensor containing the natural logarithms of the original tensor.
-
-### (Operation) log1p()
-
-Returns a tensor containing `log(1 + x)` for each element. More accurate
-than `log(1 + x)` for small values of x.
-
-### (Operation) log2()
-
-Returns a tensor containing the base-2 logarithms of the original tensor.
-
-### (Operation) abs()
-
-Returns a tensor containing the absolute values of the original tensor.
-
-### (Operation) sign()
-
-Returns a tensor containing the sign (-1, 0, or +1) of each element.
-
-### (Operation) arg()
-
-Returns a tensor containing the complex argument (phase angle) of the
-values of the original tensor.
-
-### (Operation) real()
-
-Returns a tensor containing the real part of the complex values of the
-original tensor.  The result has a real-valued scalar type.
-
-### (Operation) imag()
-
-Returns a tensor containing the imaginary part of the complex values of
-the original tensor. The result has a real-valued scalar type.
-
-### (Operation) conjugate()
-
-Returns a tensor containing the complex conjugate of each element.
-For real-valued tensors, this is a no-op.
-
-### (Operation) pow(Scalar exponent)
-
-Returns a tensor containing the coefficients of the original tensor raised
-to the power of the exponent.
-
-The type of the exponent, Scalar, is always the same as the type of the
-tensor coefficients.  For example, only integer exponents can be used in
-conjunction with tensors of integer values.
-
-You can use `cast()` to lift this restriction.  For example this computes
-cubic roots of an int Tensor:
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 1, 8}, {27, 64, 125}});
-Eigen::Tensor<double, 2> b = a.cast<double>().pow(1.0 / 3.0);
-std::cout << "a" << endl << a << endl << endl;
-std::cout << "b" << endl << b << endl << endl;
-
-// a
-// 0   1   8
-// 27  64 125
-//
-// b
-// 0 1 2
-// 3 4 5
-```
-
-### (Operation) clip(Scalar min_val, Scalar max_val)
-
-Returns a tensor with each element clamped to the range `[min_val, max_val]`.
-
-```cpp
-Eigen::Tensor<float, 1> a(5);
-a.setValues({-2.0f, -0.5f, 0.0f, 0.5f, 2.0f});
-Eigen::Tensor<float, 1> b = a.clip(-1.0f, 1.0f);
-// b: -1 -0.5  0  0.5  1
-```
-
-### Rounding Operations
-
-### (Operation) round()
-
-Returns a tensor with each element rounded to the nearest integer.
-
-### (Operation) rint()
-
-Returns a tensor with each element rounded to the nearest integer
-(using the current rounding mode).
-
-### (Operation) ceil()
-
-Returns a tensor with each element rounded up to the nearest integer.
-
-### (Operation) floor()
-
-Returns a tensor with each element rounded down to the nearest integer.
-
-### Predicates
-
-### (Operation) (isnan)()
-
-Returns a bool tensor indicating which elements are NaN.
-
-```cpp
-Eigen::Tensor<float, 1> a(3);
-a.setValues({1.0f, std::numeric_limits<float>::quiet_NaN(), 3.0f});
-Eigen::Tensor<bool, 1> b = a.isnan().cast<bool>();
-// b: false true false
-```
-
-### (Operation) (isinf)()
-
-Returns a bool tensor indicating which elements are infinite.
-
-### (Operation) (isfinite)()
-
-Returns a bool tensor indicating which elements are finite (not NaN or Inf).
-
-### Hyperbolic and Activation Functions
-
-### (Operation) tanh()
-
-Returns a tensor containing the hyperbolic tangent of each element.
-
-### (Operation) sigmoid()
-
-Returns a tensor containing the logistic sigmoid (1/(1+exp(-x))) of each element.
-
-### Error Functions
-
-### (Operation) erf()
-
-Returns a tensor containing the error function of each element.
-
-### (Operation) erfc()
-
-Returns a tensor containing the complementary error function (1 - erf(x)) of each element.
-
-### (Operation) ndtri()
-
-Returns a tensor containing the inverse of the normal cumulative distribution function of each element.
-
-### Special Math Functions
-
-These require including `<unsupported/Eigen/SpecialFunctions>` in addition to
-the Tensor header.
-
-### (Operation) lgamma()
-
-Returns a tensor containing the log-gamma function of each element.
-
-### (Operation) digamma()
-
-Returns a tensor containing the digamma (psi) function of each element.
-
-### (Operation) bessel_i0(), bessel_i0e(), bessel_i1(), bessel_i1e()
-
-Modified Bessel functions of the first kind. The `e` variants are exponentially scaled.
-
-### (Operation) bessel_j0(), bessel_j1()
-
-Bessel functions of the first kind.
-
-### (Operation) bessel_y0(), bessel_y1()
-
-Bessel functions of the second kind.
-
-### (Operation) bessel_k0(), bessel_k0e(), bessel_k1(), bessel_k1e()
-
-Modified Bessel functions of the second kind. The `e` variants are exponentially scaled.
-
-### (Operation) igamma(const OtherDerived& other)
-
-Regularized lower incomplete gamma function. `this` is the parameter `a` and
-`other` is `x`.
-
-### (Operation) igammac(const OtherDerived& other)
-
-Regularized upper incomplete gamma function (1 - igamma).
-
-### (Operation) zeta(const OtherDerived& other)
-
-Riemann zeta function. `this` is `x` and `other` is `q`.
-
-### (Operation) polygamma(const OtherDerived& other)
-
-Polygamma function. `this` is `n` and `other` is `x`.
-
-### Scalar Arithmetic
-
-### (Operation) operator*(Scalar s)
-
-Multiplies every element of the input tensor by the scalar `s`:
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{1, 2, 3},
-                {4, 5, 6}});
-Eigen::Tensor<int,2> scaled_a = a * 2;
-
-std::cout << "a\n" << a << "\n";
-std::cout << "scaled_a\n" << scaled_a << "\n";
-
-// a
-// 1 2 3
-// 4 5 6
-//
-// scaled_a
-// 2  4  6
-// 8 10 12
-```
-### (Operation) operator+ (Scalar s)
-Adds `s` to every element in the tensor.
-
-### (Operation) operator- (Scalar s)
-Subtracts `s` from every element in the tensor.
-
-### (Operation) operator/ (Scalar s)
-Divides every element in the tensor by `s`.
-
-### (Operation) operator% (Scalar s)
-Computes the element-wise modulus (remainder) of each tensor element divided by `s`.
-
-**Only integer types are supported.**
-For floating-point tensors, implement a `unaryExpr` using `std::fmod`.
-
-### (Operation)  cwiseMax(Scalar threshold)
-Returns a tensor where each element is the maximum of the original element and the
-scalar threshold.
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500}});
-
-Eigen::Tensor<int, 2> b(2, 3);
-b.setValues({{-1, -2, 300}, {-4, 555, -6}});
-
-Eigen::Tensor<int, 2> c = a.cwiseMax(b);
-
-std::cout << "a\n" << a << "\n"
-            << "b\n" << b << "\n"
-            << "c\n" << c << "\n";
-
-// a
-//   0 100 200
-// 300 400 500
-
-// b
-// -1  -2 300
-// -4 555  -6
-
-// c
-//   0 100 300
-// 300 555 500
-```
-### (Operation)  cwiseMin(Scalar threshold)
-Returns a tensor where each element is the minimum of the original element and the
-scalar threshold.
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 2);
-a.setValues({{0, 100}, {300, -900}});
-
-Eigen::Tensor<int, 2> b(2, 2);
-b.setValues({{-1, -2}, {400, 555}});
-
-Eigen::Tensor<int, 2> c = a.cwiseMin(b);
-
-std::cout << "a\n" << a << "\n"
-          << "b\n" << b << "\n"
-          << "c\n" << c << "\n";
-
-// a
-//   0  100
-// 300 -900
-
-// b
-//  -1  -2
-// 400 555
-
-// c
-//  -1   -2
-// 300 -900
-```
-
-### NaN Propagation for cwiseMax and cwiseMin
-
-The `cwiseMax` and `cwiseMin` operations accept an optional template parameter
-controlling NaN propagation:
-
-*   `cwiseMax<Eigen::PropagateNaN>(other)` — if either operand is NaN, the result is NaN.
-*   `cwiseMax<Eigen::PropagateNumbers>(other)` — NaN is treated as missing; the non-NaN value wins.
-*   `cwiseMax(other)` — default behavior (fast; may or may not propagate NaN, depends on platform).
-
-```cpp
-Eigen::Tensor<float, 1> a(3), b(3);
-a.setValues({1.0f, NAN, 3.0f});
-b.setValues({2.0f, 2.0f, NAN});
-
-Eigen::Tensor<float, 1> c = a.cwiseMax<Eigen::PropagateNaN>(b);
-// c: 2.0, NaN, NaN
-
-Eigen::Tensor<float, 1> d = a.cwiseMax<Eigen::PropagateNumbers>(b);
-// d: 2.0, 2.0, 3.0
-```
-
-
-### (Operation)  unaryExpr(const CustomUnaryOp& func)
-Applies a user defined function to each element in the tensor.
-Supports lambdas or functor structs with an operator().
-
-Using lambda:
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setValues({{0, -.5, -1}, {.5, 1.5, 2.0}});
-auto my_func = [](float el){ return std::abs(el + 0.5f);};
-Eigen::Tensor<float, 2> b = a.unaryExpr(my_func);
-std::cout << "a\n" << a << "\n"
-        << "b\n" << b << "\n";
-=>
-a
-    0  -0.5   -1
-0.5   1.5    2
-b
-0.5     0  0.5
-    1     2  2.5
-```
-
-Using a functor to normalize and clamp values to `[-1.0, 1.0]`:
-
-```cpp
-template<typename Scalar>
-struct NormalizedClamp {
-NormalizedClamp(Scalar lo, Scalar hi) : _lo(lo), _hi(hi) {}
-Scalar operator()(Scalar x) const {
-    if (x < _lo) return Scalar(0);
-    if (x > _hi) return Scalar(1);
-    return (x - _lo) / (_hi - _lo);
-}
-Scalar _lo, _hi;
-};
-
-Eigen::Tensor<float, 2> c = a.unaryExpr(NormalizedClamp<float>(-1.0f, 1.0f));
-std::cout << "c\n" << c << "\n";
-
-// c
-// 0.5    0.25    0
-// 0.75   1       1
-```
-
-### Bitwise and Boolean Unary Operations
-
-### (Operation) operator~()
-
-Bitwise NOT of each element (integer types only).
-
-### (Operation) operator!()
-
-Boolean NOT of each element.
-
-
-## Binary Element Wise Operations
-
-These operations take two input tensors as arguments. The 2 input tensors should
-be of the same type and dimensions. The result is a tensor of the same
-dimensions as the tensors to which they are applied, and unless otherwise
-specified it is also of the same type. The requested operations are applied to
-each pair of elements independently.
-
-### (Operation) operator+(const OtherDerived& other)
-
-Returns a tensor of the same type and dimensions as the input tensors
-containing the coefficient wise sums of the inputs.
-
-### (Operation) operator-(const OtherDerived& other)
-
-Returns a tensor of the same type and dimensions as the input tensors
-containing the coefficient wise differences of the inputs.
-
-### (Operation) operator*(const OtherDerived& other)
-
-Returns a tensor of the same type and dimensions as the input tensors
-containing the coefficient wise products of the inputs.
-
-### (Operation) operator/(const OtherDerived& other)
-
-Returns a tensor of the same type and dimensions as the input tensors
-containing the coefficient wise quotients of the inputs.
-
-This operator is not supported for integer types.
-
-### (Operation) cwiseMax(const OtherDerived& other)
-
-Returns a tensor of the same type and dimensions as the input tensors
-containing the coefficient wise maximums of the inputs.
-
-### (Operation) cwiseMin(const OtherDerived& other)
-
-Returns a tensor of the same type and dimensions as the input tensors
-containing the coefficient wise minimums of the inputs.
-
-### (Operation) binaryExpr(const OtherDerived& other, const CustomBinaryOp& func)
-
-Applies a custom binary functor element-wise to two tensors.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3), b(2, 3);
-a.setRandom(); b.setRandom();
-auto my_op = [](float x, float y) { return x * x + y * y; };
-Eigen::Tensor<float, 2> c = a.binaryExpr(b, my_op);
-```
-
-### (Operation) Logical operators
-
-The following boolean operators are supported:
-
- * `operator&&(const OtherDerived& other)`
- * `operator||(const OtherDerived& other)`
- * `operator<(const OtherDerived& other)`
- * `operator<=(const OtherDerived& other)`
- * `operator>(const OtherDerived& other)`
- * `operator>=(const OtherDerived& other)`
- * `operator==(const OtherDerived& other)`
- * `operator!=(const OtherDerived& other)`
-
- as well as bitwise operators:
-
- * `operator&(const OtherDerived& other)`
- * `operator|(const OtherDerived& other)`
- * `operator^(const OtherDerived& other)`
-
-The resulting tensor retains the input scalar type.
-
-Scalar comparison variants are also available (e.g. `a < 0.5f`).
-
-## Selection (select(const ThenDerived& thenTensor, const ElseDerived& elseTensor)
-
-Selection is a coefficient-wise ternary operator that is the tensor equivalent
-to the if-then-else operation.
-
-```cpp
-    Tensor<bool, 3> if = ...;
-    Tensor<float, 3> then = ...;
-    Tensor<float, 3> else = ...;
-    Tensor<float, 3> result = if.select(then, else);
-```
-
-The 3 arguments must be of the same dimensions, which will also be the dimension
-of the result.  The 'if' tensor must be of type boolean, the 'then' and the
-'else' tensor must be of the same type, which will also be the type of the
-result.
-
-Each coefficient in the result is equal to the corresponding coefficient in the
-'then' tensor if the corresponding value in the 'if' tensor is true. If not, the
-resulting coefficient will come from the 'else' tensor.
-
-
-## Contraction
-
-Tensor *contractions* are a generalization of the matrix product to the
-multidimensional case.
-
-```cpp
-// Create 2 matrices using tensors of rank 2
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{1, 2, 3}, {6, 5, 4}});
-Eigen::Tensor<int, 2> b(3, 2);
-b.setValues({{1, 2}, {4, 5}, {5, 6}});
-
-// Compute the traditional matrix product
-Eigen::array<Eigen::IndexPair<int>, 1> product_dims = { Eigen::IndexPair<int>(1, 0) };
-Eigen::Tensor<int, 2> AB = a.contract(b, product_dims);
-
-// Compute the product of the transpose of the matrices
-Eigen::array<Eigen::IndexPair<int>, 1> transposed_product_dims = { Eigen::IndexPair<int>(0, 1) };
-Eigen::Tensor<int, 2> AtBt = a.contract(b, transposed_product_dims);
-
-// Contraction to scalar value using a double contraction.
-// First coordinate of both tensors are contracted as well as both second coordinates, i.e., this computes the sum of the squares of the elements.
-Eigen::array<Eigen::IndexPair<int>, 2> double_contraction_product_dims = { Eigen::IndexPair<int>(0, 0), Eigen::IndexPair<int>(1, 1) };
-Eigen::Tensor<int, 0> AdoubleContractedA = a.contract(a, double_contraction_product_dims);
-
-// Extracting the scalar value of the tensor contraction for further usage
-int value = AdoubleContractedA(0);
-```
-
-## Reduction Operations
-
-A *Reduction* operation returns a tensor with fewer dimensions than the
-original tensor.  The values in the returned tensor are computed by applying a
-*reduction operator* to slices of values from the original tensor.  You specify
-the dimensions along which the slices are made.
-
-The Eigen Tensor library provides a set of predefined reduction operators such
-as `maximum()` and `sum()` and lets you define additional operators by
-implementing a few methods from a reductor template.
-
-### Reduction Dimensions
-
-All reduction operations take a single parameter of type
-`<TensorType>::``Dimensions` which can always be specified as an array of
-ints.  These are called the "reduction dimensions."  The values are the indices
-of the dimensions of the input tensor over which the reduction is done.  The
-parameter can have at most as many element as the rank of the input tensor;
-each element must be less than the tensor rank, as it indicates one of the
-dimensions to reduce.
-
-Each dimension of the input tensor should occur at most once in the reduction
-dimensions as the implementation does not remove duplicates.
-
-The order of the values in the reduction dimensions does not affect the
-results, but the code may execute faster if you list the dimensions in
-increasing order.
-
-Example: Reduction along one dimension.
-```cpp
-// Create a tensor of 2 dimensions
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{1, 2, 3}, {6, 5, 4}});
-// Reduce it along the second dimension (1)...
-Eigen::array<int, 1> dims{1 /* dimension to reduce */};
-// ...using the "maximum" operator.
-// The result is a tensor with one dimension.  The size of
-// that dimension is the same as the first (non-reduced) dimension of a.
-Eigen::Tensor<int, 1> b = a.maximum(dims);
-std::cout << "a" << endl << a << endl << endl;
-std::cout << "b" << endl << b << endl << endl;
-
-// a
-// 1 2 3
-// 6 5 4
-
-// b
-// 3
-// 6
-```
-Example: Reduction along two dimensions.
-```cpp
-Eigen::Tensor<float, 3, Eigen::ColMajor> a(2, 3, 4);
-a.setValues({{{0.0f, 1.0f, 2.0f, 3.0f},
-                {7.0f, 6.0f, 5.0f, 4.0f},
-                {8.0f, 9.0f, 10.0f, 11.0f}},
-                {{12.0f, 13.0f, 14.0f, 15.0f},
-                {19.0f, 18.0f, 17.0f, 16.0f},
-                {20.0f, 21.0f, 22.0f, 23.0f}}});
-// The tensor a has 3 dimensions.  We reduce along the
-// first 2, resulting in a tensor with a single dimension
-// of size 4 (the last dimension of a.)
-// Note that we pass the array of reduction dimensions
-// directly to the maximum() call.
-Eigen::Tensor<float, 1, Eigen::ColMajor> b =
-    a.maximum(Eigen::array<int, 2>{0, 1});
-std::cout << "b" << endl << b << endl << endl;
-
-// b
-// 20
-// 21
-// 22
-// 23
-```
-#### Reduction along all dimensions
-
-As a special case, if you pass no parameter to a reduction operation the
-original tensor is reduced along *all* its dimensions.  The result is a
-scalar, represented as a zero-dimension tensor.
-
-```cpp
-Eigen::Tensor<float, 3> a(2, 3, 4);
-a.setValues({{{0.0f, 1.0f, 2.0f, 3.0f},
-              {7.0f, 6.0f, 5.0f, 4.0f},
-              {8.0f, 9.0f, 10.0f, 11.0f}},
-              {{12.0f, 13.0f, 14.0f, 15.0f},
-              {19.0f, 18.0f, 17.0f, 16.0f},
-              {20.0f, 21.0f, 22.0f, 23.0f}}});
-// Reduce along all dimensions using the sum() operator.
-Eigen::Tensor<float, 0> b = a.sum();
-std::cout << "b\n" << b;
-
-// b
-// 276
-```
-You can extract the scalar directly by casting the expression and extract the first and only coefficient:
-```cpp
-float sum = static_cast<Eigen::Tensor<float, 0>>(a.sum())();
-```
-
-### (Operation) sum(const Dimensions& reduction_dims)
-### (Operation) sum()
-
-Reduce a tensor using the `sum()` operator.  The resulting values
-are the sum of the reduced values.
-
-### (Operation) mean(const Dimensions& reduction_dims)
-### (Operation) mean()
-
-Reduce a tensor using the `mean()` operator.  The resulting values
-are the mean of the reduced values.
-
-### (Operation) maximum(const Dimensions& reduction_dims)
-### (Operation) maximum()
-
-Reduce a tensor using the `maximum()` operator.  The resulting values are the
-largest of the reduced values.
-
-### (Operation) minimum(const Dimensions& reduction_dims)
-### (Operation) minimum()
-
-Reduce a tensor using the `minimum()` operator.  The resulting values
-are the smallest of the reduced values.
-
-### NaN Propagation for maximum and minimum
-
-Like `cwiseMax` and `cwiseMin`, the `maximum` and `minimum` reductions accept
-an optional NaN propagation template parameter:
-
-```cpp
-// If any element along the reduction is NaN, the result is NaN.
-Eigen::Tensor<float, 1> b = a.maximum<Eigen::PropagateNaN>(dims);
-
-// NaN values are ignored during reduction.
-Eigen::Tensor<float, 1> c = a.maximum<Eigen::PropagateNumbers>(dims);
-```
-
-### (Operation) prod(const Dimensions& reduction_dims)
-### (Operation) prod()
-
-Reduce a tensor using the `prod()` operator.  The resulting values
-are the product of the reduced values.
-
-### (Operation) all(const Dimensions& reduction_dims)
-### (Operation) all()
-Reduce a tensor using the `all()` operator.  Casts tensor to bool and then checks
-whether all elements are true.  Runs through all elements rather than
-short-circuiting, so may be significantly inefficient.
-
-### (Operation) any(const Dimensions& reduction_dims)
-### (Operation) any()
-Reduce a tensor using the `any()` operator.  Casts tensor to bool and then checks
-whether any element is true.  Runs through all elements rather than
-short-circuiting, so may be significantly inefficient.
-
-
-### (Operation) argmax(const Dimensions& reduction_dim)
-### (Operation) argmax()
-
-Reduce a tensor using the `argmax()` operator.
-
-The resulting values are the indices of the largest elements along the specified dimension.
-
-Only a single `reduction_dim` is supported.
-
-If multiple elements share the maximum value, the one with the **lowest index** is returned.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setValues({{1, 4, 8}, {3, 4, 2}});
-
-Eigen::Tensor<Eigen::Index, 1> argmax_dim0 = a.argmax(0);
-
-std::cout << "a:\n" << a << "\n";
-for (int i = 0; i < argmax_dim0.size(); ++i) {
-    std::cout << "argmax along dim 0 at index " << i << " = " << argmax_dim0(i) << "\n";
-}
-
-// a:
-// 1 4 8
-// 3 4 2
-// argmax along dim 0 at index 0 = 1
-// argmax along dim 0 at index 1 = 0
-// argmax along dim 0 at index 2 = 0
-```
-
- To compute the index of the global maximum, use the overload without arguments (which flattens the tensor).
-
-
-```cpp
-Eigen::Tensor<Eigen::Index, 0> argmax_flat = a.argmax();
-std::cout << "Flat argmax index: " << argmax_flat();
-
-// Flat argmax index: 4
-```
-
-### (Operation) argmin(const Dimensions& reduction_dim)
-### (Operation) argmin()
-See `argmax`.
-
-### (Operation) reduce(const Dimensions& reduction_dims, const Reducer& reducer)
-
-Reduce a tensor using a user-defined reduction operator.  See `SumReducer`
-in TensorFunctors.h for information on how to implement a reduction operator.
-
-
-## Trace
-
-A *Trace* operation returns a tensor with fewer dimensions than the original
-tensor. It returns a tensor whose elements are the sum of the elements of the
-original tensor along the main diagonal for a list of specified dimensions, the
-"trace dimensions". Similar to the `Reduction Dimensions`, the trace dimensions
-are passed as an input parameter to the operation, are of type `<TensorType>::``Dimensions`
-, and have the same requirements when passed as an input parameter. In addition,
-the trace dimensions must have the same size.
-
-Example: Trace along 2 dimensions.
-
-```cpp
-// Create a tensor of 3 dimensions
-Eigen::Tensor<int, 3> a(2, 2, 3);
-a.setValues({{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}});
-// Specify the dimensions along which the trace will be computed.
-// In this example, the trace can only be computed along the dimensions
-// with indices 0 and 1
-Eigen::array<int, 2> dims{0, 1};
-// The output tensor contains all but the trace dimensions.
-Tensor<int, 1> a_trace = a.trace(dims);
-std::cout << "a_trace:" << endl;
-std::cout << a_trace << endl;
-
-// a_trace:
-// 11
-// 13
-// 15
-```
-
-### (Operation) trace(const Dimensions& new_dims)
-### (Operation) trace()
-
-As a special case, if no parameter is passed to the operation, trace is computed
-along *all* dimensions of the input tensor.
-
-Example: Trace along all dimensions.
-
-```cpp
-// Create a tensor of 3 dimensions, with all dimensions having the same size.
-Eigen::Tensor<int, 3> a(3, 3, 3);
-a.setValues({{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}},
-            {{10, 11, 12}, {13, 14, 15}, {16, 17, 18}},
-            {{19, 20, 21}, {22, 23, 24}, {25, 26, 27}}});
-// Result is a zero dimension tensor
-Tensor<int, 0> a_trace = a.trace();
-std::cout<<"a_trace:"<<endl;
-std::cout<<a_trace<<endl;
-
-// a_trace:
-// 42
-```
-
-## Scan Operations
-
-A *Scan* operation returns a tensor with the same dimensions as the original
-tensor. The operation performs an inclusive scan along the specified
-axis, which means it computes a running total along the axis for a given
-reduction operation.
-If the reduction operation corresponds to summation, then this computes the
-prefix sum of the tensor along the given axis.
-
-Example:
-Cumulative sum along the second dimension
-
-```cpp
-// Create a tensor of 2 dimensions
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{1, 2, 3}, {4, 5, 6}});
-// Scan it along the second dimension (1) using summation
-Eigen::Tensor<int, 2> b = a.cumsum(1);
-// The result is a tensor with the same size as the input
-std::cout << "a" << endl << a << endl << endl;
-std::cout << "b" << endl << b << endl << endl;
-
-// a
-// 1 2 3
-// 4 5 6
-
-// b
-// 1  3  6
-// 4  9 15
-```
-
-### (Operation) cumsum(const Index& axis, bool exclusive = false)
-
-Perform a scan by summing consecutive entries.
-
-When `exclusive` is true, element `i` contains the sum of all elements before
-index `i` (exclusive prefix sum). The first element along the axis is 0.
-
-```cpp
-Eigen::Tensor<int, 1> a(4);
-a.setValues({1, 2, 3, 4});
-
-Eigen::Tensor<int, 1> inclusive = a.cumsum(0);           // 1, 3, 6, 10
-Eigen::Tensor<int, 1> exclusive = a.cumsum(0, true);     // 0, 1, 3, 6
-```
-
-### (Operation) cumprod(const Index& axis, bool exclusive = false)
-
-Perform a scan by multiplying consecutive entries.
-
-When `exclusive` is true, element `i` contains the product of all elements
-before index `i`. The first element along the axis is 1.
-
-```cpp
-Eigen::Tensor<int, 1> a(4);
-a.setValues({1, 2, 3, 4});
-
-Eigen::Tensor<int, 1> inclusive = a.cumprod(0);           // 1, 2, 6, 24
-Eigen::Tensor<int, 1> exclusive = a.cumprod(0, true);     // 1, 1, 2, 6
-```
-
-## Convolutions
-
-### (Operation) convolve(const Kernel& kernel, const Dimensions& dims)
-
-Returns a tensor that is the output of the convolution of the input tensor with the kernel,
-along the specified dimensions of the input tensor. The dimension size for dimensions of the output tensor
-which were part of the convolution will be reduced by the formula:
-```cpp
-output_dim_size = input_dim_size - kernel_dim_size + 1 // (requires: input_dim_size >= kernel_dim_size).
-```
-The dimension sizes for dimensions that were not part of the convolution will remain the same.
-Performance of the convolution can depend on the length of the stride(s) of the input tensor dimension(s) along which the
-convolution is computed (the first dimension has the shortest stride for `ColMajor`, whereas `RowMajor`'s shortest stride is
-for the last dimension).
-
-```cpp
-// Compute convolution along the second and third dimension.
-Tensor<float, 4, DataLayout> input(3, 3, 7, 11);
-Tensor<float, 2, DataLayout> kernel(2, 2);
-Tensor<float, 4, DataLayout> output(3, 2, 6, 11);
-input.setRandom();
-kernel.setRandom();
-
-Eigen::array<ptrdiff_t, 2> dims{1, 2};  // Specify second and third dimension for convolution.
-output = input.convolve(kernel, dims);
-
-for (int i = 0; i < 3; ++i) {
-  for (int j = 0; j < 2; ++j) {
-    for (int k = 0; k < 6; ++k) {
-      for (int l = 0; l < 11; ++l) {
-        const float result = output(i,j,k,l);
-        const float expected = input(i,j+0,k+0,l) * kernel(0,0) +
-                               input(i,j+1,k+0,l) * kernel(1,0) +
-                               input(i,j+0,k+1,l) * kernel(0,1) +
-                               input(i,j+1,k+1,l) * kernel(1,1);
-        VERIFY_IS_APPROX(result, expected);
-      }
-    }
-  }
-}
-```
-
-## FFT (Fast Fourier Transform)
-
-### (Operation) fft\<FFTResultType, FFTDirection\>(const FFTDims& dims)
-
-Computes the Fast Fourier Transform of the input tensor along the specified
-dimensions.
-
-Template parameters:
-
-| Parameter | Values | Description |
-|-----------|--------|-------------|
-| `FFTResultType` | `RealPart`, `ImagPart`, `BothParts` | Which part(s) of the result to return |
-| `FFTDirection` | `FFT_FORWARD`, `FFT_REVERSE` | Forward or inverse transform |
-
-When `FFTResultType` is `BothParts`, the output scalar type is
-`std::complex<Scalar>`. When `RealPart` or `ImagPart`, the output retains
-the real scalar type.
-
-```cpp
-// Forward FFT of a 2D tensor along both dimensions.
-Eigen::Tensor<float, 2> input(8, 16);
-input.setRandom();
-Eigen::array<int, 2> fft_dims{{0, 1}};
-
-// Get the full complex result.
-Eigen::Tensor<std::complex<float>, 2> complex_result =
-    input.fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft_dims);
-
-// Get only the real part.
-Eigen::Tensor<float, 2> real_result =
-    input.fft<Eigen::RealPart, Eigen::FFT_FORWARD>(fft_dims);
-
-// Inverse FFT to recover the original signal.
-Eigen::Tensor<float, 2> recovered =
-    complex_result.fft<Eigen::RealPart, Eigen::FFT_REVERSE>(fft_dims);
-```
-
-The FFT uses the Cooley-Tukey algorithm for power-of-2 sizes and falls back to
-the Bluestein algorithm for arbitrary sizes.
-
-## Geometrical Operations
-
-These operations return a `Tensor` with different dimensions than the original
-`Tensor`.  They can be used to access slices of tensors, see them with different
-dimensions, or pad tensors with additional data.
-
-### (Operation) reshape(const Dimensions& new_dims)
-
-Returns a view of the input tensor that has been reshaped to the specified
-new dimensions.
-
-The argument `new_dims` is an array of Index values.
-
-The rank of the resulting tensor is equal to the number of elements in `new_dims`.
-
-The product of all the sizes in the new dimension array must be equal to
-the number of elements in the input tensor.
-
-```cpp
-// Increase the rank of the input tensor by introducing a new dimension
-// of size 1.
-Tensor<float, 2> input(7, 11);
-array<int, 3> three_dims{{7, 11, 1}};
-Tensor<float, 3> result = input.reshape(three_dims);
-
-// Decrease the rank of the input tensor by merging 2 dimensions;
-array<int, 1> one_dim{{7 * 11}};
-Tensor<float, 1> result = input.reshape(one_dim);
-```
-
-This operation does not move any data in the input tensor, so the resulting
-contents of a reshaped `Tensor` depend on the data layout of the original `Tensor`.
-
-For example this is what happens when you `reshape()` a 2D `ColMajor` tensor
-to one dimension:
-
-```cpp
-Eigen::Tensor<float, 2, Eigen::ColMajor> a(2, 3);
-a.setValues({{0.0f, 100.0f, 200.0f}, {300.0f, 400.0f, 500.0f}});
-Eigen::array<Eigen::DenseIndex, 1> one_dim{3 * 2};
-Eigen::Tensor<float, 1, Eigen::ColMajor> b = a.reshape(one_dim);
-std::cout << "b" << endl << b << endl;
-
-// b
-//   0
-// 300
-// 100
-// 400
-// 200
-// 500
-```
-
-This is what happens when the 2D `Tensor` is `RowMajor`:
-
-```cpp
-Eigen::Tensor<float, 2, Eigen::RowMajor> a(2, 3);
-a.setValues({{0.0f, 100.0f, 200.0f}, {300.0f, 400.0f, 500.0f}});
-Eigen::array<Eigen::DenseIndex, 1> one_dim{3 * 2};
-Eigen::Tensor<float, 1, Eigen::RowMajor> b = a.reshape(one_dim);
-std::cout << "b" << endl << b << endl;
-
-// b
-//   0
-// 100
-// 200
-// 300
-// 400
-// 500
-```
-
-The reshape operation is a lvalue. In other words, it can be used on the left
-side of the assignment operator.
-
-The previous example can be rewritten as follow:
-
-```cpp
-Eigen::Tensor<float, 2, Eigen::ColMajor> a(2, 3);
-a.setValues({{0.0f, 100.0f, 200.0f}, {300.0f, 400.0f, 500.0f}});
-Eigen::array<Eigen::DenseIndex, 2> two_dim{2, 3};
-Eigen::Tensor<float, 1, Eigen::ColMajor> b(6);
-b.reshape(two_dim) = a;
-std::cout << "b" << endl << b << endl;
-
-// b
-//   0
-// 300
-// 100
-// 400
-// 200
-// 500
-```
-
-Note that "b" itself was not reshaped but that instead the assignment is done to
-the reshape view of b.
-
-### (Operation) shuffle(const Shuffle& shuffle)
-
-Returns a view of the input tensor whose dimensions have been
-reordered according to the specified permutation.
-
-The argument `shuffle` is an array of `Index` values:
-* Its size is the rank of the input tensor.
-* It must contain a permutation of `[0, 1, ..., rank - 1]`.
-* The `i`-th dimension of the output tensor corresponds to the size of the dimension at position `shuffle[i]` in the input tensor. For example:
-
-```cpp
-// Shuffle all dimensions to the left by 1.
-Tensor<float, 3> input(20, 30, 50);
-// ... set some values in input.
-Tensor<float, 3> output = input.shuffle({1, 2, 0});
-
-eigen_assert(output.dimension(0) == 30);
-eigen_assert(output.dimension(1) == 50);
-eigen_assert(output.dimension(2) == 20);
-
-// Indices into the output tensor are shuffled accordingly to formulate
-// indices into the input tensor.
-eigen_assert(output(3, 7, 11) == input(11, 3, 7));
-
-// In general:
-eigen_assert(output(..., indices[shuffle[i]], ...) ==
-             input(..., indices[i], ...));
-```
-
-The shuffle operation results in a lvalue, which means that it can be assigned
-to. In other words, it can be used on the left side of the assignment operator.
-
-Let's rewrite the previous example to take advantage of this feature:
-
-```cpp
-// Shuffle all dimensions to the left by 1.
-Tensor<float, 3> input(20, 30, 50);
-input.setRandom();
-Tensor<float, 3> output(30, 50, 20);
-output.shuffle({2, 0, 1}) = input;
-```
-
-### (Operation) stride(const Strides& strides)
-
-Returns a view of the input tensor that strides (skips stride-1
-elements) along each of the dimensions.
-
-The argument strides is an array of `Index` values:
-* Its size is the rank of the input tensor.
-* Must be >= 1
-
- The dimensions of the resulting tensor are `ceil(input_dimensions[i] / strides[i])`.
-
-For example this is what happens when you `stride()` a 2D tensor:
-
-```cpp
-Eigen::Tensor<int, 2> a(4, 3);
-a.setValues({{0, 100, 200},
-             {300, 400, 500},
-             {600, 700, 800},
-             {900, 1000, 1100}});
-Eigen::array<Eigen::DenseIndex, 2> strides{3, 2};
-Eigen::Tensor<int, 2> b = a.stride(strides);
-std::cout << "b" << endl << b << endl;
-// b
-//    0   200
-//  900  1100
-```
-
-It is possible to assign a tensor to a stride:
-```cpp
-Tensor<float, 3> input(20, 30, 50);
-input.setRandom();
-Tensor<float, 3> output(40, 90, 200);
-output.stride({2, 3, 4}) = input;
-```
-
-### (Operation) slice(const StartIndices& offsets, const Sizes& extents)
-
-Returns a sub-tensor of the given tensor. For each dimension i, the slice is
-made of the coefficients stored between `offset[i]` and `offset[i] + extents[i]` in
-the input tensor.
-
-```cpp
-Eigen::Tensor<int, 2> a(4, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500},
-             {600, 700, 800}, {900, 1000, 1100}});
-Eigen::array<Eigen::Index, 2> offsets = {1, 0};
-Eigen::array<Eigen::Index, 2> extents = {2, 2};
-Eigen::Tensor<int, 2> slice = a.slice(offsets, extents);
-std::cout << "a" << endl << a << endl;
-// a
-//    0   100   200
-//  300   400   500
-//  600   700   800
-//  900  1000  1100
-
-std::cout << "slice" << endl << slice << endl;
-// slice
-//  300   400
-//  600   700
-```
-
-### (Operation) stridedSlice(const StartIndices& start, const StopIndices& stop, const Strides& strides)
-
-Returns a sub-tensor by selecting elements using `start`, `stop` (exclusive), and `strides` for each dimension.
-
-This is similar to slicing in Python using [start:stop:step].
-
-``` cpp
-Eigen::Tensor<int, 2> a(4, 6);
-a.setValues({{  0,  10,  20,  30,  40,   50},
-             {100, 110, 120, 130, 140,  150},
-             {200, 210, 220, 230, 240,  250},
-             {300, 310, 320, 330, 340,  350}});
-
-Eigen::array<Eigen::Index, 2> start = {1, 1};
-Eigen::array<Eigen::Index, 2> stop  = {4, 6}; // Stop is exclusive
-Eigen::array<Eigen::Index, 2> strides = {2, 2};
-
-Eigen::Tensor<int, 2> sub = a.stridedSlice(start, stop, strides);
-
-std::cout << "a\n" << a << "\n";
-std::cout << "sub\n" << sub << "\n";
-
-// a
-//   0  10  20  30  40  50
-// 100 110 120 130 140 150
-// 200 210 220 230 240 250
-// 300 310 320 330 340 350
-
-// sub
-// 110 130 150
-// 310 330 350
-```
-It is also possible to assign to a strided slice:
-
-``` cpp
-Eigen::Tensor<int, 2> b(sub.dimensions());
-b.setConstant(-1);
-a.stridedSlice(start, stop, strides) = b;
-std::cout << "modified a\n" << a << "\n";
-
-
-// modified a
-//   0  10  20  30  40  50
-// 100  -1 120  -1 140  -1
-// 200 210 220 230 240 250
-// 300  -1 320  -1 340  -1
-
-```
-### (Operation) chip(const Index offset, const Index dim)
-
-A chip is a special kind of slice.
-It is the subtensor at the given offset in the dimension `dim`.
-
-The returned tensor has one fewer dimension than the input tensor: the dimension dim is removed.
-
-For example, a matrix chip would be either a row or a column of the input matrix:
-
-```cpp
-Eigen::Tensor<int, 2> a(4, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500},
-             {600, 700, 800}, {900, 1000, 1100}});
-Eigen::Tensor<int, 1> row_3 = a.chip(2, 0);
-Eigen::Tensor<int, 1> col_2 = a.chip(1, 1);
-std::cout << "a\n" << a << "\n";
-
-// a
-//    0   100   200
-//  300   400   500
-//  600   700   800
-//  900  1000  1100
-
-std::cout << "row_3\n" << row_3 << "\n";
-// row_3
-//    600   700   800
-
-std::cout << "col_2\n" << col_2 << "\n";
-// col_2
-//   100   400   700    1000
-```
-
-It is possible to assign values to a tensor chip since the chip operation is a
-lvalue. For example:
-
-```cpp
-Eigen::Tensor<int, 1> a(3);
-a.setValues({{100, 200, 300}});
-Eigen::Tensor<int, 2> b(2, 3);
-b.setZero();
-b.chip(0, 0) = a;
-std::cout << "a\n" << a << "\n";
-std::cout << "b\n" << b << "\n";
-
-// a
-// 100
-// 200
-// 300
-
-// b
-//   100   200   300
-//     0     0     0
-```
-
-
-The dimension can also be passed as a template parameter:
-
-```cpp
-b.chip<0>(1) = a;  // Equivalent to b.chip(1,0) = a;
-```
-
-Note that only one dimension can be chipped at a time.
-To chip off multiple dimensions, you can chain calls
-
-```cpp
-Eigen::Tensor<int, 3> a(2, 3, 4);
-Eigen::Tensor<int, 1> b = b.chip<2>(0) // Now has shape [2,3]
-                           .chip<1>(0); // Now has shape [2]
-```
-
-Be careful in which order you chip, as each operation affects the shape of the intermediate result.
-For example:
-
-```cpp
-// AVOID THIS
-Eigen::Tensor<int, 1> c = b.chip<1>(0) // Now has shape [2,4]
-                           .chip<1>(0); // Now has shape [2]
-```
-
-In general, it's more intuitive to chip from the outermost dimension first.
-
-
-### (Operation) reverse(const ReverseDimensions& reverse)
-
-Returns a view of the input tensor that reverses the order of the coefficients
-along a subset of the dimensions.  The argument reverse is an array of boolean
-values that indicates whether or not the order of the coefficients should be
-reversed along each of the dimensions.  This operation preserves the dimensions
-of the input tensor.
-
-For example this is what happens when you `reverse()` the first dimension
-of a 2D tensor:
-
-```cpp
-Eigen::Tensor<int, 2> a(4, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500},
-            {600, 700, 800}, {900, 1000, 1100}});
-Eigen::array<bool, 2> reverse{true, false};
-Eigen::Tensor<int, 2> b = a.reverse(reverse);
-std::cout << "a\n" << a << "\n";
-std::cout << "b\n" << b << "\n";
-
-// a
-//    0   100   200
-//  300   400   500
-//  600   700   800
-//  900  1000  1100
-// b
-//  900  1000  1100
-//  600   700   800
-//  300   400   500
-//    0   100   200
-```
-
-### (Operation) roll(const Rolls& shifts)
-
-Returns a tensor with the elements **circularly shifted** (like bit rotation) along one or more dimensions.
-
-For each dimension `i`, the content is shifted by `shifts[i]` positions:
-
-- A **positive shift** of `+s` moves each value to a **lower index** by `s`.
-- A **negative shift** of `-s` moves each value to a **higher index** by `s`.
-
-```cpp
-Eigen::Tensor<int, 2> a(3, 4);
-a.setValues({{ 1,  2,  3,  4},
-             { 5,  6,  7,  8},
-             { 9, 10, 11, 12}});
-
-Eigen::array<Eigen::Index, 2> shifts = {1, -2};
-
-Eigen::Tensor<int, 2> rolled = a.roll(shifts);
-
-std::cout << "a\n" << a << "\n";
-std::cout << "rolled\n" << rolled << "\n";
-
-// a
-// 1  2  3  4
-// 5  6  7  8
-// 9 10 11 12
-//
-// rolled
-// 7  8  5  6
-// 11 12  9 10
-// 3  4  1  2
-```
-
-### (Operation) broadcast(const Broadcast& broadcast)
-
-Returns a view of the input tensor in which the input is replicated one to many
-times.
-The broadcast argument specifies how many copies of the input tensor need to be
-made in each of the dimensions.
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500}});
-Eigen::array<int, 2> bcast{3, 2};
-Eigen::Tensor<int, 2> b = a.broadcast(bcast);
-std::cout << "a" << endl << a << endl << "b" << endl << b << endl;
-// a
-//    0   100   200
-//  300   400   500
-// b
-//    0   100   200    0   100   200
-//  300   400   500  300   400   500
-//    0   100   200    0   100   200
-//  300   400   500  300   400   500
-//    0   100   200    0   100   200
-//  300   400   500  300   400   500
-```
-
-Note: Broadcasting does not increase rank.
-To broadcast into higher dimensions, you must first reshape the tensor with singleton (1) dimensions:
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500}});
-
-Eigen::array<Eigen::Index, 3> new_shape = {1, 2, 3}; //Reshape to [1, 2, 3]
-Eigen::array<int, 3> bcast = {4, 1, 1}; // Broadcast to [4, 2, 3]
-Eigen::Tensor<int, 3> b = a.reshape(new_shape).broadcast(bcast);
-
-std::cout << "b dimensions: " << b.dimensions() << "\n";
-std::cout << b << "\n";
-```
-
-### (Operation) concatenate(const OtherDerived& other, Axis axis)
-
-Returns a view of two tensors joined along a specified axis.
-The dimensions of the two tensors must match on all axes except the concatenation axis.
-The resulting tensor has the same rank as the inputs.
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500}});
-
-Eigen::Tensor<int, 2> b(2, 3);
-b.setValues({{-1, -2, -3}, {-4, -5, -6}});
-
-// Concatenate along dimension 0: resulting shape is [4, 3]
-Eigen::Tensor<int, 2> c = a.concatenate(b, 0);
-
-// Concatenate along dimension 1: resulting shape is [2, 6]
-Eigen::Tensor<int, 2> d = a.concatenate(b, 1);
-
-std::cout << "a\n" << a << "\n"
-          << "b\n" << b << "\n"
-          << "c (concatenated along dim 0)\n" << c << "\n"
-          << "d (concatenated along dim 1)\n" << d << "\n";
-// a
-//   0 100 200
-// 300 400 500
-// b
-// -1 -2 -3
-// -4 -5 -6
-// c (concatenated along dim 0)
-//   0 100 200
-// 300 400 500
-//  -1  -2  -3
-//  -4  -5  -6
-// d (concatenated along dim 1)
-//   0 100 200  -1  -2  -3
-// 300 400 500  -4  -5  -6
-```
-
-### (Operation)  pad(const PaddingDimensions& padding)
-
-Returns a view of the input tensor in which the input is padded with zeros.
-
-An optional second argument specifies the padding value (default is zero):
-`a.pad(paddings, 42)` pads with the value 42.
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 100, 200}, {300, 400, 500}});
-Eigen::array<pair<int, int>, 2> paddings;
-paddings[0] = make_pair(0, 1);
-paddings[1] = make_pair(2, 3);
-Eigen::Tensor<int, 2> b = a.pad(paddings);
-std::cout << "a" << endl << a << endl << "b" << endl << b << endl;
-// a
-//    0   100   200
-//  300   400   500
-// b
-//    0     0     0    0
-//    0     0     0    0
-//    0   100   200    0
-//  300   400   500    0
-//    0     0     0    0
-//    0     0     0    0
-//    0     0     0    0
-```
-
-### (Operation) inflate(const Strides& strides)
-
-Returns a tensor with zeros inserted between the elements of the input tensor
-along each dimension. The `strides` array specifies the inflation factor for
-each dimension: a stride of `s` inserts `s-1` zeros between consecutive
-elements in that dimension. A stride of 1 leaves the dimension unchanged.
-
-The output dimension sizes are `(input_dim - 1) * stride + 1`.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-a.setValues({{1, 2, 3}, {4, 5, 6}});
-Eigen::array<Eigen::Index, 2> strides{{2, 3}};
-Eigen::Tensor<float, 2> b = a.inflate(strides);
-std::cout << "b dimensions: " << b.dimension(0) << " x " << b.dimension(1) << "\n";
-std::cout << "b\n" << b << "\n";
-
-// b dimensions: 3 x 7
-// b
-// 1 0 0 2 0 0 3
-// 0 0 0 0 0 0 0
-// 4 0 0 5 0 0 6
-```
-
-This is the adjoint of the `stride()` operation and is useful for implementing
-transposed convolutions (deconvolutions).
-
-### (Operation)  extract_patches(const PatchDims& patch_dims)
-
-Returns a tensor of coefficient patches extracted from the input tensor, where
-each patch is of dimension specified by `patch_dims`. The returned tensor has
-one greater dimension than the input tensor, which is used to index each patch.
-The patch index in the output tensor depends on the data layout of the input
-tensor: the patch index is the last dimension `ColMajor` layout, and the first
-dimension in `RowMajor` layout.
-
-For example, given the following input tensor:
-
-```cpp
-Eigen::Tensor<float, 2, DataLayout> tensor(3,4);
-tensor.setValues({{0.0f, 1.0f, 2.0f, 3.0f},
-                  {4.0f, 5.0f, 6.0f, 7.0f},
-                  {8.0f, 9.0f, 10.0f, 11.0f}});
-
-std::cout << "tensor: " << endl << tensor << endl;
-
-// tensor:
-//  0   1   2   3
-//  4   5   6   7
-//  8   9  10  11
-```
-
-Six 2x2 patches can be extracted and indexed using the following code:
-
-```cpp
-Eigen::Tensor<float, 3, DataLayout> patch;
-Eigen::array<ptrdiff_t, 2> patch_dims;
-patch_dims[0] = 2;
-patch_dims[1] = 2;
-patch = tensor.extract_patches(patch_dims);
-for (int k = 0; k < 6; ++k) {
-  std::cout << "patch index: " << k << endl;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      if (DataLayout == ColMajor) {
-        std::cout << patch(i, j, k) << " ";
-      } else {
-        std::cout << patch(k, i, j) << " ";
-      }
-    }
-    std::cout << endl;
-  }
-}
-```
-
-This code results in the following output when the data layout is `ColMajor`:
-
-    patch index: 0
-    0 1
-    4 5
-    patch index: 1
-    4 5
-    8 9
-    patch index: 2
-    1 2
-    5 6
-    patch index: 3
-    5 6
-    9 10
-    patch index: 4
-    2 3
-    6 7
-    patch index: 5
-    6 7
-    10 11
-
-This code results in the following output when the data layout is RowMajor:
-
-**NOTE**: the set of patches is the same as in `ColMajor`, but are indexed differently
-
-    patch index: 0
-    0 1
-    4 5
-    patch index: 1
-    1 2
-    5 6
-    patch index: 2
-    2 3
-    6 7
-    patch index: 3
-    4 5
-    8 9
-    patch index: 4
-    5 6
-    9 10
-    patch index: 5
-    6 7
-    10 11
-
-### (Operation)  extract_image_patches(const Index patch_rows, const Index patch_cols, const Index row_stride, const Index col_stride, const PaddingType padding_type)
-
-Returns a tensor of coefficient image patches extracted from the input tensor,
-which is expected to have dimensions ordered as follows (depending on the data
-layout of the input tensor, and the number of additional dimensions 'N'):
-
-- `ColMajor`
-    - 1st dimension: channels (of size d)
-    - 2nd dimension: rows (of size r)
-    - 3rd dimension: columns (of size c)
-    - 4th-Nth dimension: time (for video) or batch (for bulk processing).
-
-* `RowMajor` (reverse order of `ColMajor`)
-    - 1st-Nth dimension: time (for video) or batch (for bulk processing).
-    - N+1'th dimension: columns (of size c)
-    - N+2'th dimension: rows (of size r)
-    - N+3'th dimension: channels (of size d)
-
-The returned tensor has one greater dimension than the input tensor, which is
-used to index each patch. The patch index in the output tensor depends on the
-data layout of the input tensor: the patch index is the 4'th dimension in
-`ColMajor` layout, and the 4'th from the last dimension in `RowMajor` layout.
-
-For example, given the following input tensor with the following dimension
-sizes:
-- depth:   2
-- rows:    3
-- columns: 5
-- batch:   7
-
-```cpp
-Tensor<float, 4> tensor(2,3,5,7);
-Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
-```
-
-2x2 image patches can be extracted and indexed using the following code:
-
-#### 2D patch: `ColMajor` (patch indexed by second-to-last dimension)
-
-```cpp
-Tensor<float, 5> twod_patch;
-twod_patch = tensor.extract_image_patches<2, 2>();
-// twod_patch.dimension(0) == 2
-// twod_patch.dimension(1) == 2
-// twod_patch.dimension(2) == 2
-// twod_patch.dimension(3) == 3*5
-// twod_patch.dimension(4) == 7
-```
-
-#### 2D patch: `RowMajor` (patch indexed by the second dimension)
-
-```cpp
-Tensor<float, 5, RowMajor> twod_patch_row_major;
-twod_patch_row_major = tensor_row_major.extract_image_patches<2, 2>();
-// twod_patch_row_major.dimension(0) == 7
-// twod_patch_row_major.dimension(1) == 3*5
-// twod_patch_row_major.dimension(2) == 2
-// twod_patch_row_major.dimension(3) == 2
-// twod_patch_row_major.dimension(4) == 2
-```
-
-## Generation and Custom Operations
-
-### (Operation) generate(const Generator& generator)
-
-Returns a tensor whose values are computed by the given generator functor based
-on element coordinates. The generator must define `operator()` taking an
-`array<Index, NumDims>` of coordinates and returning a `Scalar`.
-
-```cpp
-// Generator that produces the linear index of each element.
-template <typename Index, int NumDims>
-struct LinearIndexGenerator {
-  Eigen::array<Index, NumDims> dims_;
-  LinearIndexGenerator(const Eigen::array<Index, NumDims>& dims) : dims_(dims) {}
-
-  float operator()(const Eigen::array<Index, NumDims>& coords) const {
-    float idx = 0;
-    float stride = 1;
-    for (int i = 0; i < NumDims; ++i) {
-      idx += coords[i] * stride;
-      stride *= dims_[i];
-    }
-    return idx;
-  }
-};
-
-Eigen::Tensor<float, 2> t(3, 4);
-Eigen::array<Eigen::Index, 2> dims{{3, 4}};
-Eigen::Tensor<float, 2> result = t.generate(LinearIndexGenerator<Eigen::Index, 2>(dims));
-```
-
-### (Operation) customOp(const CustomUnaryFunc& func)
-
-Applies a custom operation that can produce output with different dimensions
-than the input. Unlike `unaryExpr()` which is element-wise, `customOp()`
-gives full control over how the output is computed.
-
-The functor must implement:
-- `dimensions(const InputType& input)` — returns the output dimensions.
-- `eval(const InputType& input, OutputType& output, const Device& device)` —
-  computes the result.
-
-```cpp
-struct RowSumOp {
-  // Output is a 1D tensor with size equal to the number of rows.
-  template <typename Input>
-  Eigen::DSizes<Eigen::Index, 1> dimensions(const Input& input) const {
-    return Eigen::DSizes<Eigen::Index, 1>(input.dimension(0));
-  }
-
-  template <typename Input, typename Output, typename Device>
-  void eval(const Input& input, Output& output, const Device& device) const {
-    Eigen::array<Eigen::Index, 1> reduce_dims{{1}};
-    output.device(device) = input.sum(reduce_dims);
-  }
-};
-
-Eigen::Tensor<float, 2> a(3, 4);
-a.setRandom();
-Eigen::Tensor<float, 1> row_sums = a.customOp(RowSumOp());
-```
-
-A binary variant is also available:
-```cpp
-Eigen::Tensor<float, 2> result = a.customOp(b, MyBinaryCustomOp());
-```
-
-### (Operation) nullaryExpr(const CustomNullaryOp& func)
-
-Creates a tensor from a custom nullary functor. The functor is called for
-each element position.
-
-
-## Special Operations
-
-### (Operation) cast\<T\>()
-
-Returns a tensor of type `T` with the same dimensions as the original tensor.
-The returned tensor contains the values of the original tensor converted to
-type `T`.
-
-```cpp
-Eigen::Tensor<float, 2> a(2, 3);
-Eigen::Tensor<int, 2> b = a.cast<int>();
-```
-
-This can be useful for example if you need to do element-wise division of
-Tensors of integers.
-This is not currently supported by the Tensor library
-but you can easily cast the tensors to floats to do the division:
-
-```cpp
-Eigen::Tensor<int, 2> a(2, 3);
-a.setValues({{0, 1, 2}, {3, 4, 5}});
-Eigen::Tensor<int, 2> b =
-    (a.cast<float>() / a.constant(2).cast<float>()).cast<int>();
-std::cout << "a\n" << a << "\n";
-std::cout << "b\n" << b << "\n";
-
-// a
-// 0 1 2
-// 3 4 5
-//
-// b
-// 0 0 1
-// 1 2 2
-```
-
-### (Operation)     eval()
-See **Calling eval()**.
-
-
-
-## Tensor Printing
-Tensors can be printed into a stream object (e.g. `std::cout`) using different formatting options.
-
-```cpp
-Eigen::Tensor<float, 3> tensor3d(4, 3, 2);
-tensor3d.setValues( {{{1, 2},
-                      {3, 4},
-                      {5, 6}},
-                     {{7, 8},
-                      {9, 10},
-                      {11, 12}},
-                     {{13, 14},
-                      {15, 16},
-                      {17, 18}},
-                     {{19, 20},
-                      {21, 22},
-                      {23, 24}}} );
-std::cout << tensor3d.format(Eigen::TensorIOFormat::Plain()) << "\n";
-//  1  2
-//  3  4
-//  5  6
-//
-//  7  8
-//  9 10
-// 11 12
-//
-// 13 14
-// 15 16
-// 17 18
-//
-// 19 20
-// 21 22
-// 23 24
-```
-
-In the example, we used the predefined format `Eigen::TensorIOFormat::Plain`.
-Here is the list of all predefined formats from which you can choose:
-- `Eigen::TensorIOFormat::Plain()` for a plain output without braces. Different submatrices are separated by a blank line.
-- `Eigen::TensorIOFormat::Numpy()` for numpy-like output.
-- `Eigen::TensorIOFormat::Native()` for a `c++` like output which can be directly copy-pasted to `setValues()`.
-- `Eigen::TensorIOFormat::Legacy()` for a backwards compatible printing of tensors.
-
-If you send the tensor directly to the stream the default format is called which is `Eigen::TensorIOFormat::Plain()`.
-
-You can define your own format by explicitly providing a `Eigen::TensorIOFormat` class instance. Here, you can specify:
-- The overall prefix and suffix with `std::string tenPrefix` and `std::string tenSuffix`
-- The prefix, separator and suffix for each new element, row, matrix, 3d subtensor, ... with `std::vector<std::string> prefix`, `std::vector<std::string> separator` and `std::vector<std::string> suffix`. Note that the first entry in each of the vectors refer to the last dimension of the tensor, e.g. `separator[0]` will be printed between adjacent elements,  `separator[1]` will be printed between adjacent matrices, ...
-- `char fill`: character which will be placed if the elements are aligned.
-- `int precision`
-- `int flags`: an OR-ed combination of flags, the default value is 0, the only currently available flag is `Eigen::DontAlignCols` which allows to disable the alignment of columns, resulting in faster code.
-
-## Interop with Eigen Matrix and Vector Types
-
-Tensor data can be wrapped as an Eigen `Map<Matrix>`, and vice versa, Eigen
-dense matrix/vector data can be wrapped as a `TensorMap`. This is a zero-copy
-operation that simply reinterprets the underlying memory.
-
-### Wrapping a Tensor as a Matrix
-
-```cpp
-Eigen::Tensor<float, 2> tensor(3, 4);
-tensor.setRandom();
-
-// View the tensor's data as an Eigen Matrix (no copy).
-Eigen::Map<Eigen::MatrixXf> matrix(tensor.data(), 3, 4);
-std::cout << "Matrix view:\n" << matrix << "\n";
-
-// Modifications through the map are reflected in the tensor.
-matrix(0, 0) = 42.0f;
-assert(tensor(0, 0) == 42.0f);
-```
-
-### Wrapping a Matrix as a Tensor
-
-```cpp
-Eigen::MatrixXf matrix(3, 4);
-matrix.setRandom();
-
-// View the matrix's data as a rank-2 Tensor (no copy).
-Eigen::TensorMap<Eigen::Tensor<float, 2>> tensor(matrix.data(), 3, 4);
-std::cout << "Tensor view:\n" << tensor << "\n";
-
-// You can also reshape to a different rank.
-Eigen::TensorMap<Eigen::Tensor<float, 1>> flat(matrix.data(), 12);
-```
-
-**Important**: Both the Map and TensorMap are non-owning views. The underlying
-data must remain valid for the lifetime of the view. Also note that the default
-storage order of Eigen matrices is `ColMajor`, which matches the default Tensor
-layout.
-
-## Representation of scalar values
-
-Scalar values are often represented by tensors of size 1 and rank 0.
-
-For example `Tensor<T, N>::maximum()` returns a `Tensor<T, 0>`.
-
-Similarly, the inner product of 2 1d tensors (through contractions) returns a 0d tensor.
-
-The scalar value can be extracted as explained in **Reduction along all dimensions**.
-
-
-## Limitations
-
-*   The number of tensor dimensions is currently limited to 250.
-*   On GPUs only floating point values are properly tested and optimized for.
-*   C++14 or later is required to use the Tensor module.
diff --git a/unsupported/Eigen/src/Tensor/Tensor.h b/unsupported/Eigen/src/Tensor/Tensor.h
deleted file mode 100644
index 9dc9591..0000000
--- a/unsupported/Eigen/src/Tensor/Tensor.h
+++ /dev/null
@@ -1,382 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_H
-#define EIGEN_CXX11_TENSOR_TENSOR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \class Tensor
- * \ingroup CXX11_Tensor_Module
- *
- * \brief The tensor class.
- *
- * The %Tensor class is the work-horse for all \em dense tensors within Eigen.
- *
- * The %Tensor class encompasses only dynamic-size objects so far.
- *
- * The first two template parameters are required:
- * \tparam Scalar_  Numeric type, e.g. float, double, int or `std::complex<float>`.
- *                 User defined scalar types are supported as well (see \ref user_defined_scalars "here").
- * \tparam NumIndices_ Number of indices (i.e. rank of the tensor)
- *
- * The remaining template parameters are optional -- in most cases you don't have to worry about them.
- * \tparam Options_  A combination of either \b #RowMajor or \b #ColMajor, and of either
- *                 \b #AutoAlign or \b #DontAlign.
- *                 The former controls \ref TopicStorageOrders "storage order", and defaults to column-major. The latter
- * controls alignment, which is required for vectorization. It defaults to aligning tensors. Note that tensors currently
- * do not support any operations that profit from vectorization. Support for such operations (i.e. adding two tensors
- * etc.) is planned.
- *
- * You can access elements of tensors using normal subscripting:
- *
- * \code
- * Eigen::Tensor<double, 4> t(10, 10, 10, 10);
- * t(0, 1, 2, 3) = 42.0;
- * \endcode
- *
- * This class can be extended with the help of the plugin mechanism described on the page
- * \ref TopicCustomizing_Plugins by defining the preprocessor symbol \c EIGEN_TENSOR_PLUGIN,
- * \c EIGEN_TENSORBASE_PLUGIN, and \c EIGEN_READONLY_TENSORBASE_PLUGIN.
- *
- * <i><b>Some notes:</b></i>
- *
- * <dl>
- * <dt><b>Relation to other parts of Eigen:</b></dt>
- * <dd>The midterm development goal for this class is to have a similar hierarchy as Eigen uses for matrices, so that
- * taking blocks or using tensors in expressions is easily possible, including an interface with the vector/matrix code
- * by providing .asMatrix() and .asVector() (or similar) methods for rank 2 and 1 tensors. However, currently, the
- * %Tensor class does not provide any of these features and is only available as a stand-alone class that just allows
- * for coefficient access. Also, when fixed-size tensors are implemented, the number of template arguments is likely to
- * change dramatically.</dd>
- * </dl>
- *
- * \ref TopicStorageOrders
- */
-
-template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
-class Tensor : public TensorBase<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {
- public:
-  typedef Tensor<Scalar_, NumIndices_, Options_, IndexType_> Self;
-  typedef TensorBase<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > Base;
-  typedef typename Eigen::internal::nested<Self>::type Nested;
-  typedef typename internal::traits<Self>::StorageKind StorageKind;
-  typedef typename internal::traits<Self>::Index Index;
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef typename Base::CoeffReturnType CoeffReturnType;
-
-  enum { IsAligned = (EIGEN_MAX_ALIGN_BYTES > 0) && !(Options_ & DontAlign), CoordAccess = true, RawAccess = true };
-
-  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
-  static constexpr int Options = Options_;
-  static constexpr int NumIndices = NumIndices_;
-  typedef DSizes<Index, NumIndices_> Dimensions;
-
- protected:
-  TensorStorage<Scalar, Dimensions, Options> m_storage;
-
-  template <typename CustomIndices>
-  struct isOfNormalIndex {
-    static const bool is_array = internal::is_base_of<array<Index, NumIndices>, CustomIndices>::value;
-    static const bool is_int = NumTraits<CustomIndices>::IsInteger;
-    static const bool value = is_array | is_int;
-  };
-
- public:
-  // Metadata
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return NumIndices; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(std::size_t n) const { return m_storage.dimensions()[n]; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_storage.dimensions(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_storage.size(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar* data() { return m_storage.data(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_storage.data(); }
-
-  // This makes EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
-  // work, because that uses base().coeffRef() - and we don't yet
-  // implement a similar class hierarchy
-  inline Self& base() { return *this; }
-  inline const Self& base() const { return *this; }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index firstIndex, Index secondIndex,
-                                                            IndexTypes... otherIndices) const {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return coeff(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}});
-  }
-
-  // normal indices
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(const array<Index, NumIndices>& indices) const {
-    eigen_internal_assert(checkIndexRange(indices));
-    return m_storage.data()[linearizedIndex(indices)];
-  }
-
-  // custom indices
-  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(CustomIndices& indices) const {
-    return coeff(internal::customIndices2Array<Index, NumIndices>(indices));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff() const {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return m_storage.data()[0];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const {
-    eigen_internal_assert(index >= 0 && index < size());
-    return m_storage.data()[index];
-  }
-
-  template <typename... IndexTypes>
-  inline Scalar& coeffRef(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return coeffRef(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}});
-  }
-
-  // normal indices
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) {
-    eigen_internal_assert(checkIndexRange(indices));
-    return m_storage.data()[linearizedIndex(indices)];
-  }
-
-  // custom indices
-  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(CustomIndices& indices) {
-    return coeffRef(internal::customIndices2Array<Index, NumIndices>(indices));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef() {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return m_storage.data()[0];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
-    eigen_internal_assert(index >= 0 && index < size());
-    return m_storage.data()[index];
-  }
-
-  template <typename... IndexTypes>
-  inline const Scalar& operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) const {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return this->operator()(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}});
-  }
-
-  // custom indices
-  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(CustomIndices& indices) const {
-    return coeff(internal::customIndices2Array<Index, NumIndices>(indices));
-  }
-
-  // normal indices
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(const array<Index, NumIndices>& indices) const {
-    return coeff(indices);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index index) const {
-    eigen_internal_assert(index >= 0 && index < size());
-    return coeff(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()() const {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return coeff();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator[](Index index) const {
-    // The bracket operator is only for vectors, use the parenthesis operator instead.
-    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return coeff(index);
-  }
-
-  template <typename... IndexTypes>
-  inline Scalar& operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return operator()(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}});
-  }
-
-  // normal indices
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(const array<Index, NumIndices>& indices) {
-    return coeffRef(indices);
-  }
-
-  // custom indices
-  template <typename CustomIndices, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomIndices>::value))>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(CustomIndices& indices) {
-    return coeffRef(internal::customIndices2Array<Index, NumIndices>(indices));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index index) {
-    eigen_assert(index >= 0 && index < size());
-    return coeffRef(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()() {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return coeffRef();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator[](Index index) {
-    // The bracket operator is only for vectors, use the parenthesis operator instead
-    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return coeffRef(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor() : m_storage() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(const Self& other) : Base(other), m_storage(other.m_storage) {}
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index firstDimension, IndexTypes... otherDimensions)
-      : m_storage(firstDimension, otherDimensions...) {
-    // The number of dimensions used to construct a tensor must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-  }
-
-  /** Normal Dimension */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit Tensor(const array<Index, NumIndices>& dimensions)
-      : m_storage(internal::array_prod(dimensions), dimensions) {
-    EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
-  }
-
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
-    EIGEN_STATIC_ASSERT(OtherDerived::NumDimensions == Base::NumDimensions, Number_of_dimensions_must_match)
-    typedef TensorAssignOp<Tensor, const OtherDerived> Assign;
-    Assign assign(*this, other.derived());
-    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
-    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-  }
-
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(const TensorBase<OtherDerived, WriteAccessors>& other) {
-    EIGEN_STATIC_ASSERT(OtherDerived::NumDimensions == Base::NumDimensions, Number_of_dimensions_must_match)
-    typedef TensorAssignOp<Tensor, const OtherDerived> Assign;
-    Assign assign(*this, other.derived());
-    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
-    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Self&& other) : m_storage(std::move(other.m_storage)) {}
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor& operator=(Self&& other) {
-    m_storage = std::move(other.m_storage);
-    return *this;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor& operator=(const Tensor& other) {
-    typedef TensorAssignOp<Tensor, const Tensor> Assign;
-    Assign assign(*this, other);
-    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
-    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-    return *this;
-  }
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor& operator=(const OtherDerived& other) {
-    typedef TensorAssignOp<Tensor, const OtherDerived> Assign;
-    Assign assign(*this, other);
-    resize(TensorEvaluator<const Assign, DefaultDevice>(assign, DefaultDevice()).dimensions());
-    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-    return *this;
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC void resize(Index firstDimension, IndexTypes... otherDimensions) {
-    // The number of dimensions used to resize a tensor must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    resize(array<Index, NumIndices>{{firstDimension, otherDimensions...}});
-  }
-
-  /** Normal Dimension */
-  EIGEN_DEVICE_FUNC void resize(const array<Index, NumIndices>& dimensions) {
-#ifndef EIGEN_NO_DEBUG
-    Index size = Index(1);
-    for (int i = 0; i < NumIndices; i++) {
-      internal::check_rows_cols_for_overflow<Dynamic, Dynamic, Dynamic>::run(size, dimensions[i]);
-      size *= dimensions[i];
-    }
-#else
-    Index size = internal::array_prod(dimensions);
-#endif
-
-#ifdef EIGEN_INITIALIZE_COEFFS
-    bool size_changed = size != this->size();
-    m_storage.resize(size, dimensions);
-    if (size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
-#else
-    m_storage.resize(size, dimensions);
-#endif
-  }
-
-  EIGEN_DEVICE_FUNC void resize() {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    // Nothing to do: rank 0 tensors have fixed size
-  }
-
-  template <typename FirstType, typename... OtherTypes>
-  EIGEN_DEVICE_FUNC void resize(const Eigen::IndexList<FirstType, OtherTypes...>& dimensions) {
-    array<Index, NumIndices> dims;
-    for (int i = 0; i < NumIndices; ++i) {
-      dims[i] = static_cast<Index>(dimensions[i]);
-    }
-    resize(dims);
-  }
-
-  /** Custom Dimension */
-  template <typename CustomDimension, EIGEN_SFINAE_ENABLE_IF(!(isOfNormalIndex<CustomDimension>::value))>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(CustomDimension& dimensions) {
-    resize(internal::customIndices2Array<Index, NumIndices>(dimensions));
-  }
-
-  template <typename std::ptrdiff_t... Indices>
-  EIGEN_DEVICE_FUNC void resize(const Sizes<Indices...>& dimensions) {
-    array<Index, NumIndices> dims;
-    for (int i = 0; i < NumIndices; ++i) {
-      dims[i] = static_cast<Index>(dimensions[i]);
-    }
-    resize(dims);
-  }
-
-#ifdef EIGEN_TENSOR_PLUGIN
-#include EIGEN_TENSOR_PLUGIN
-#endif
-
- protected:
-  bool checkIndexRange(const array<Index, NumIndices>& indices) const {
-    using internal::array_apply_and_reduce;
-    using internal::array_zip_and_reduce;
-    using internal::greater_equal_zero_op;
-    using internal::lesser_op;
-    using internal::logical_and_op;
-
-    return
-        // check whether the indices are all >= 0
-        array_apply_and_reduce<logical_and_op, greater_equal_zero_op>(indices) &&
-        // check whether the indices fit in the dimensions
-        array_zip_and_reduce<logical_and_op, lesser_op>(indices, m_storage.dimensions());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index linearizedIndex(const array<Index, NumIndices>& indices) const {
-    if (Options & RowMajor) {
-      return m_storage.dimensions().IndexOfRowMajor(indices);
-    } else {
-      return m_storage.dimensions().IndexOfColMajor(indices);
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_H
diff --git a/unsupported/Eigen/src/Tensor/TensorArgMax.h b/unsupported/Eigen/src/Tensor/TensorArgMax.h
deleted file mode 100644
index 5d49fa9..0000000
--- a/unsupported/Eigen/src/Tensor/TensorArgMax.h
+++ /dev/null
@@ -1,282 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Eugene Brevdo <ebrevdo@gmail.com>
-//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_ARG_MAX_H
-#define EIGEN_CXX11_TENSOR_TENSOR_ARG_MAX_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-template <typename XprType>
-struct traits<TensorIndexPairOp<XprType>> : public traits<XprType> {
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef Pair<Index, typename XprTraits::Scalar> Scalar;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-};
-
-template <typename XprType>
-struct eval<TensorIndexPairOp<XprType>, Eigen::Dense> {
-  typedef const TensorIndexPairOp<XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename XprType>
-struct nested<TensorIndexPairOp<XprType>, 1, typename eval<TensorIndexPairOp<XprType>>::type> {
-  typedef TensorIndexPairOp<XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor + Index Pair class.
- */
-template <typename XprType>
-class TensorIndexPairOp : public TensorBase<TensorIndexPairOp<XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorIndexPairOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename Eigen::internal::nested<TensorIndexPairOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorIndexPairOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorIndexPairOp>::Index Index;
-  typedef Pair<Index, typename XprType::CoeffReturnType> CoeffReturnType;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIndexPairOp(const XprType& expr) : m_xpr(expr) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-};
-
-// Eval as rvalue
-template <typename ArgType, typename Device>
-struct TensorEvaluator<const TensorIndexPairOp<ArgType>, Device> {
-  typedef TensorIndexPairOp<ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  static constexpr int NumDims = internal::array_size<Dimensions>::value;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  enum {
-    IsAligned = false,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    return CoeffReturnType(index, m_impl.coeff(index));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, 1);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- protected:
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-namespace internal {
-
-/** \class TensorPairIndex
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Converts to Tensor<Pair<Index, Scalar> > and reduces to Tensor<Index>.
- *
- */
-template <typename ReduceOp, typename Dims, typename XprType>
-struct traits<TensorPairReducerOp<ReduceOp, Dims, XprType>> : public traits<XprType> {
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef Index Scalar;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions - array_size<Dims>::value;
-  static constexpr int Layout = XprTraits::Layout;
-};
-
-template <typename ReduceOp, typename Dims, typename XprType>
-struct eval<TensorPairReducerOp<ReduceOp, Dims, XprType>, Eigen::Dense> {
-  typedef const TensorPairReducerOp<ReduceOp, Dims, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename ReduceOp, typename Dims, typename XprType>
-struct nested<TensorPairReducerOp<ReduceOp, Dims, XprType>, 1,
-              typename eval<TensorPairReducerOp<ReduceOp, Dims, XprType>>::type> {
-  typedef TensorPairReducerOp<ReduceOp, Dims, XprType> type;
-};
-
-}  // end namespace internal
-
-template <typename ReduceOp, typename Dims, typename XprType>
-class TensorPairReducerOp : public TensorBase<TensorPairReducerOp<ReduceOp, Dims, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorPairReducerOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename Eigen::internal::nested<TensorPairReducerOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorPairReducerOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorPairReducerOp>::Index Index;
-  typedef Index CoeffReturnType;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorPairReducerOp(const XprType& expr, const ReduceOp& reduce_op,
-                                                            const Index return_dim, const Dims& reduce_dims)
-      : m_xpr(expr), m_reduce_op(reduce_op), m_return_dim(return_dim), m_reduce_dims(reduce_dims) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_DEVICE_FUNC const ReduceOp& reduce_op() const { return m_reduce_op; }
-
-  EIGEN_DEVICE_FUNC const Dims& reduce_dims() const { return m_reduce_dims; }
-
-  EIGEN_DEVICE_FUNC Index return_dim() const { return m_return_dim; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const ReduceOp m_reduce_op;
-  const Index m_return_dim;
-  const Dims m_reduce_dims;
-};
-
-// Eval as rvalue
-template <typename ReduceOp, typename Dims, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorPairReducerOp<ReduceOp, Dims, ArgType>, Device> {
-  typedef TensorPairReducerOp<ReduceOp, Dims, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename TensorIndexPairOp<ArgType>::CoeffReturnType PairType;
-  typedef typename TensorEvaluator<const TensorReductionOp<ReduceOp, Dims, const TensorIndexPairOp<ArgType>>,
-                                   Device>::Dimensions Dimensions;
-  typedef typename TensorEvaluator<const TensorIndexPairOp<ArgType>, Device>::Dimensions InputDimensions;
-  static constexpr int NumDims = internal::array_size<InputDimensions>::value;
-  typedef array<Index, NumDims> StrideDims;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  typedef StorageMemory<PairType, Device> PairStorageMem;
-
-  enum {
-    IsAligned = false,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-  static constexpr int Layout =
-      TensorEvaluator<const TensorReductionOp<ReduceOp, Dims, const TensorIndexPairOp<ArgType>>, Device>::Layout;
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_orig_impl(op.expression(), device),
-        m_impl(op.expression().index_pairs().reduce(op.reduce_dims(), op.reduce_op()), device),
-        m_return_dim(op.return_dim()) {
-    gen_strides(m_orig_impl.dimensions(), m_strides);
-    if (Layout == static_cast<int>(ColMajor)) {
-      const Index total_size = internal::array_prod(m_orig_impl.dimensions());
-      m_stride_mod = (m_return_dim < NumDims - 1) ? m_strides[m_return_dim + 1] : total_size;
-    } else {
-      const Index total_size = internal::array_prod(m_orig_impl.dimensions());
-      m_stride_mod = (m_return_dim > 0) ? m_strides[m_return_dim - 1] : total_size;
-    }
-    // If m_return_dim is not a valid index, returns 1 or this can crash on Windows.
-    m_stride_div =
-        ((m_return_dim >= 0) && (m_return_dim < static_cast<Index>(m_strides.size()))) ? m_strides[m_return_dim] : 1;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    const PairType v = m_impl.coeff(index);
-    return (m_return_dim < 0) ? v.first : (v.first % m_stride_mod) / m_stride_div;
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double compute_cost =
-        1.0 + (m_return_dim < 0 ? 0.0 : (TensorOpCost::ModCost<Index>() + TensorOpCost::DivCost<Index>()));
-    return m_orig_impl.costPerCoeff(vectorized) + m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost);
-  }
-
- private:
-  EIGEN_DEVICE_FUNC void gen_strides(const InputDimensions& dims, StrideDims& strides) {
-    if (m_return_dim < 0) {
-      return;  // Won't be using the strides.
-    }
-    eigen_assert(m_return_dim < NumDims && "Asking to convert index to a dimension outside of the rank");
-
-    // Calculate m_stride_div and m_stride_mod, which are used to
-    // calculate the value of an index w.r.t. the m_return_dim.
-    if (Layout == static_cast<int>(ColMajor)) {
-      strides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        strides[i] = strides[i - 1] * dims[i - 1];
-      }
-    } else {
-      strides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        strides[i] = strides[i + 1] * dims[i + 1];
-      }
-    }
-  }
-
- protected:
-  TensorEvaluator<const TensorIndexPairOp<ArgType>, Device> m_orig_impl;
-  TensorEvaluator<const TensorReductionOp<ReduceOp, Dims, const TensorIndexPairOp<ArgType>>, Device> m_impl;
-  const Index m_return_dim;
-  StrideDims m_strides;
-  Index m_stride_mod;
-  Index m_stride_div;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_ARG_MAX_H
diff --git a/unsupported/Eigen/src/Tensor/TensorAssign.h b/unsupported/Eigen/src/Tensor/TensorAssign.h
deleted file mode 100644
index 330eae7..0000000
--- a/unsupported/Eigen/src/Tensor/TensorAssign.h
+++ /dev/null
@@ -1,211 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_ASSIGN_H
-#define EIGEN_CXX11_TENSOR_TENSOR_ASSIGN_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename LhsXprType, typename RhsXprType>
-struct traits<TensorAssignOp<LhsXprType, RhsXprType> > {
-  typedef typename LhsXprType::Scalar Scalar;
-  typedef typename traits<LhsXprType>::StorageKind StorageKind;
-  typedef
-      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
-  typedef typename LhsXprType::Nested LhsNested;
-  typedef typename RhsXprType::Nested RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
-  static constexpr std::size_t NumDimensions = internal::traits<LhsXprType>::NumDimensions;
-  static constexpr int Layout = internal::traits<LhsXprType>::Layout;
-  typedef typename traits<LhsXprType>::PointerType PointerType;
-
-  enum { Flags = 0 };
-};
-
-template <typename LhsXprType, typename RhsXprType>
-struct eval<TensorAssignOp<LhsXprType, RhsXprType>, Eigen::Dense> {
-  typedef const TensorAssignOp<LhsXprType, RhsXprType>& type;
-};
-
-template <typename LhsXprType, typename RhsXprType>
-struct nested<TensorAssignOp<LhsXprType, RhsXprType>, 1, typename eval<TensorAssignOp<LhsXprType, RhsXprType> >::type> {
-  typedef TensorAssignOp<LhsXprType, RhsXprType> type;
-};
-
-}  // end namespace internal
-
-/** The tensor assignment class.
- * \ingroup CXX11_Tensor_Module
- *
- * This class represents the assignment of the values resulting from the evaluation of
- * the rhs expression to the memory locations denoted by the lhs expression.
- */
-template <typename LhsXprType, typename RhsXprType>
-class TensorAssignOp : public TensorBase<TensorAssignOp<LhsXprType, RhsXprType> > {
- public:
-  typedef typename Eigen::internal::traits<TensorAssignOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename LhsXprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorAssignOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorAssignOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorAssignOp>::Index Index;
-
-  static constexpr int NumDims = Eigen::internal::traits<TensorAssignOp>::NumDimensions;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorAssignOp(LhsXprType& lhs, const RhsXprType& rhs)
-      : m_lhs_xpr(lhs), m_rhs_xpr(rhs) {}
-
-  /** \returns the nested expressions */
-  EIGEN_DEVICE_FUNC internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
-    return *((internal::remove_all_t<typename LhsXprType::Nested>*)&m_lhs_xpr);
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
-    return m_rhs_xpr;
-  }
-
- protected:
-  internal::remove_all_t<typename LhsXprType::Nested>& m_lhs_xpr;
-  const internal::remove_all_t<typename RhsXprType::Nested>& m_rhs_xpr;
-};
-
-template <typename LeftArgType, typename RightArgType, typename Device>
-struct TensorEvaluator<const TensorAssignOp<LeftArgType, RightArgType>, Device> {
-  typedef TensorAssignOp<LeftArgType, RightArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename TensorEvaluator<RightArgType, Device>::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  static constexpr int NumDims = XprType::NumDims;
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-
-  enum {
-    IsAligned =
-        int(TensorEvaluator<LeftArgType, Device>::IsAligned) & int(TensorEvaluator<RightArgType, Device>::IsAligned),
-    PacketAccess = int(TensorEvaluator<LeftArgType, Device>::PacketAccess) &
-                   int(TensorEvaluator<RightArgType, Device>::PacketAccess),
-    BlockAccess = int(TensorEvaluator<LeftArgType, Device>::BlockAccess) &
-                  int(TensorEvaluator<RightArgType, Device>::BlockAccess),
-    PreferBlockAccess = int(TensorEvaluator<LeftArgType, Device>::PreferBlockAccess) |
-                        int(TensorEvaluator<RightArgType, Device>::PreferBlockAccess),
-    RawAccess = TensorEvaluator<LeftArgType, Device>::RawAccess
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const RightArgType, Device>::TensorBlock RightTensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  TensorEvaluator(const XprType& op, const Device& device)
-      : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
-                         static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-  }
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
-    // The dimensions of the lhs and the rhs tensors should be equal to prevent
-    // overflows and ensure the result is fully initialized.
-    // TODO: use left impl instead if right impl dimensions are known at compile time.
-    return m_rightImpl.dimensions();
-  }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    eigen_assert(dimensions_match(m_leftImpl.dimensions(), m_rightImpl.dimensions()));
-    m_leftImpl.evalSubExprsIfNeeded(NULL);
-    // If the lhs provides raw access to its storage area (i.e. if m_leftImpl.data() returns a non
-    // null value), attempt to evaluate the rhs expression in place. Returns true iff in place
-    // evaluation isn't supported and the caller still needs to manually assign the values generated
-    // by the rhs to the lhs.
-    return m_rightImpl.evalSubExprsIfNeeded(m_leftImpl.data());
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_leftImpl.evalSubExprsIfNeededAsync(nullptr, [this, done](bool) {
-      m_rightImpl.evalSubExprsIfNeededAsync(m_leftImpl.data(), [done](bool need_assign) { done(need_assign); });
-    });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_leftImpl.cleanup();
-    m_rightImpl.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalScalar(Index i) const {
-    m_leftImpl.coeffRef(i) = m_rightImpl.coeff(i);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalPacket(Index i) const {
-    const int LhsStoreMode = TensorEvaluator<LeftArgType, Device>::IsAligned ? Aligned : Unaligned;
-    const int RhsLoadMode = TensorEvaluator<RightArgType, Device>::IsAligned ? Aligned : Unaligned;
-    m_leftImpl.template writePacket<LhsStoreMode>(i, m_rightImpl.template packet<RhsLoadMode>(i));
-  }
-  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const { return m_leftImpl.coeff(index); }
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
-    return m_leftImpl.template packet<LoadMode>(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // We assume that evalPacket or evalScalar is called to perform the
-    // assignment and account for the cost of the write here, but reduce left
-    // cost by one load because we are using m_leftImpl.coeffRef.
-    TensorOpCost left = m_leftImpl.costPerCoeff(vectorized);
-    return m_rightImpl.costPerCoeff(vectorized) +
-           TensorOpCost(numext::maxi(0.0, left.bytes_loaded() - sizeof(CoeffReturnType)), left.bytes_stored(),
-                        left.compute_cycles()) +
-           TensorOpCost(0, sizeof(CoeffReturnType), 0, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return internal::TensorBlockResourceRequirements::merge(m_leftImpl.getResourceRequirements(),
-                                                            m_rightImpl.getResourceRequirements());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalBlock(TensorBlockDesc& desc, TensorBlockScratch& scratch) {
-    if (TensorEvaluator<LeftArgType, Device>::RawAccess && m_leftImpl.data() != NULL) {
-      // If destination has raw data access, we pass it as a potential
-      // destination for a block descriptor evaluation.
-      desc.template AddDestinationBuffer<Layout>(
-          /*dst_base=*/m_leftImpl.data() + desc.offset(),
-          /*dst_strides=*/internal::strides<Layout>(m_leftImpl.dimensions()));
-    }
-
-    RightTensorBlock block = m_rightImpl.block(desc, scratch, /*root_of_expr_ast=*/true);
-    // If block was evaluated into a destination, there is no need to do assignment.
-    if (block.kind() != internal::TensorBlockKind::kMaterializedInOutput) {
-      m_leftImpl.writeBlock(desc, block);
-    }
-    block.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_leftImpl.data(); }
-
- private:
-  TensorEvaluator<LeftArgType, Device> m_leftImpl;
-  TensorEvaluator<RightArgType, Device> m_rightImpl;
-};
-
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_ASSIGN_H
diff --git a/unsupported/Eigen/src/Tensor/TensorBase.h b/unsupported/Eigen/src/Tensor/TensorBase.h
deleted file mode 100644
index f6812d4..0000000
--- a/unsupported/Eigen/src/Tensor/TensorBase.h
+++ /dev/null
@@ -1,1244 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_BASE_H
-#define EIGEN_CXX11_TENSOR_TENSOR_BASE_H
-
-// clang-format off
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \class TensorBase
-  * \ingroup CXX11_Tensor_Module
-  *
-  * \brief The tensor base class.
-  *
-  * This class is the common parent of the Tensor and TensorMap class, thus
-  * making it possible to use either class interchangeably in expressions.
-  */
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-// FIXME: Doxygen does not like the inheritance with different template parameters
-// Since there is no doxygen documentation inside, we disable it for now
-template<typename Derived>
-class TensorBase<Derived, ReadOnlyAccessors>
-{
-  public:
-    typedef internal::traits<Derived> DerivedTraits;
-    typedef typename DerivedTraits::Scalar Scalar;
-    typedef typename DerivedTraits::Index Index;
-    typedef std::remove_const_t<Scalar> CoeffReturnType;
-    static constexpr int NumDimensions = DerivedTraits::NumDimensions;
-
-    // Generic nullary operation support.
-    template <typename CustomNullaryOp> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<CustomNullaryOp, const Derived>
-    nullaryExpr(const CustomNullaryOp& func) const {
-      return TensorCwiseNullaryOp<CustomNullaryOp, const Derived>(derived(), func);
-    }
-
-    // Coefficient-wise nullary operators
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived>
-    constant(const Scalar& value) const {
-      return nullaryExpr(internal::scalar_constant_op<Scalar>(value));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<internal::UniformRandomGenerator<Scalar>, const Derived>
-    random() const {
-      return nullaryExpr(internal::UniformRandomGenerator<Scalar>());
-    }
-    template <typename RandomGenerator> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseNullaryOp<RandomGenerator, const Derived>
-    random(const RandomGenerator& gen = RandomGenerator()) const {
-      return nullaryExpr(gen);
-    }
-
-    // Tensor generation
-    template <typename Generator> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorGeneratorOp<Generator, const Derived>
-    generate(const Generator& generator) const {
-      return TensorGeneratorOp<Generator, const Derived>(derived(), generator);
-    }
-
-    // Generic unary operation support.
-    template <typename CustomUnaryOp> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<CustomUnaryOp, const Derived>
-    unaryExpr(const CustomUnaryOp& func) const {
-      return TensorCwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);
-    }
-
-    // Coefficient-wise unary operators
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived>
-    operator-() const {
-      return unaryExpr(internal::scalar_opposite_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived>
-    sqrt() const {
-      return unaryExpr(internal::scalar_sqrt_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived>
-    sign() const {
-      return unaryExpr(internal::scalar_sign_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_rsqrt_op<Scalar>, const Derived>
-    rsqrt() const {
-      return unaryExpr(internal::scalar_rsqrt_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived>
-    square() const {
-      return unaryExpr(internal::scalar_square_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived>
-    cube() const {
-      return unaryExpr(internal::scalar_cube_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived>
-    inverse() const {
-      return unaryExpr(internal::scalar_inverse_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_tanh_op<Scalar>, const Derived>
-    tanh() const {
-      return unaryExpr(internal::scalar_tanh_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_lgamma_op<Scalar>, const Derived>
-    lgamma() const {
-      return unaryExpr(internal::scalar_lgamma_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_digamma_op<Scalar>, const Derived>
-    digamma() const {
-      return unaryExpr(internal::scalar_digamma_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i0_op<Scalar>, const Derived>
-    bessel_i0() const {
-      return unaryExpr(internal::scalar_bessel_i0_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i0e_op<Scalar>, const Derived>
-    bessel_i0e() const {
-      return unaryExpr(internal::scalar_bessel_i0e_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i1_op<Scalar>, const Derived>
-    bessel_i1() const {
-      return unaryExpr(internal::scalar_bessel_i1_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_i1e_op<Scalar>, const Derived>
-    bessel_i1e() const {
-      return unaryExpr(internal::scalar_bessel_i1e_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_j0_op<Scalar>, const Derived>
-    bessel_j0() const {
-      return unaryExpr(internal::scalar_bessel_j0_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_y0_op<Scalar>, const Derived>
-    bessel_y0() const {
-      return unaryExpr(internal::scalar_bessel_y0_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_j1_op<Scalar>, const Derived>
-    bessel_j1() const {
-      return unaryExpr(internal::scalar_bessel_j1_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_y1_op<Scalar>, const Derived>
-    bessel_y1() const {
-      return unaryExpr(internal::scalar_bessel_y1_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k0_op<Scalar>, const Derived>
-    bessel_k0() const {
-      return unaryExpr(internal::scalar_bessel_k0_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k0e_op<Scalar>, const Derived>
-    bessel_k0e() const {
-      return unaryExpr(internal::scalar_bessel_k0e_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k1_op<Scalar>, const Derived>
-    bessel_k1() const {
-      return unaryExpr(internal::scalar_bessel_k1_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_bessel_k1e_op<Scalar>, const Derived>
-    bessel_k1e() const {
-      return unaryExpr(internal::scalar_bessel_k1e_op<Scalar>());
-    }
-
-    // igamma(a = this, x = other)
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_igamma_op<Scalar>, const Derived, const OtherDerived>
-    igamma(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_igamma_op<Scalar>());
-    }
-
-    // igamma_der_a(a = this, x = other)
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_igamma_der_a_op<Scalar>, const Derived, const OtherDerived>
-    igamma_der_a(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_igamma_der_a_op<Scalar>());
-    }
-
-    // gamma_sample_der_alpha(alpha = this, sample = other)
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_gamma_sample_der_alpha_op<Scalar>, const Derived, const OtherDerived>
-    gamma_sample_der_alpha(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_gamma_sample_der_alpha_op<Scalar>());
-    }
-
-    // igammac(a = this, x = other)
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_igammac_op<Scalar>, const Derived, const OtherDerived>
-    igammac(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_igammac_op<Scalar>());
-    }
-
-    // zeta(x = this, q = other)
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_zeta_op<Scalar>, const Derived, const OtherDerived>
-    zeta(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_zeta_op<Scalar>());
-    }
-
-    // polygamma(n = this, x = other)
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_polygamma_op<Scalar>, const Derived, const OtherDerived>
-    polygamma(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_polygamma_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_erf_op<Scalar>, const Derived>
-    erf() const {
-      return unaryExpr(internal::scalar_erf_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_erfc_op<Scalar>, const Derived>
-    erfc() const {
-      return unaryExpr(internal::scalar_erfc_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_ndtri_op<Scalar>, const Derived>
-    ndtri() const {
-      return unaryExpr(internal::scalar_ndtri_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_logistic_op<Scalar>, const Derived>
-    sigmoid() const {
-      return unaryExpr(internal::scalar_logistic_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived>
-    exp() const {
-      return unaryExpr(internal::scalar_exp_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_expm1_op<Scalar>, const Derived>
-    expm1() const {
-      return unaryExpr(internal::scalar_expm1_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived>
-    log() const {
-      return unaryExpr(internal::scalar_log_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_log1p_op<Scalar>, const Derived>
-    log1p() const {
-      return unaryExpr(internal::scalar_log1p_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_log2_op<Scalar>, const Derived>
-    log2() const {
-      return unaryExpr(internal::scalar_log2_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived>
-    abs() const {
-      return unaryExpr(internal::scalar_abs_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived>
-    arg() const {
-      return unaryExpr(internal::scalar_arg_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_clamp_op<Scalar>, const Derived>
-    clip(Scalar min, Scalar max) const {
-      return unaryExpr(internal::scalar_clamp_op<Scalar>(min, max));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const std::conditional_t<NumTraits<CoeffReturnType>::IsComplex,
-                                                      TensorCwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,
-                                                      Derived>
-    conjugate() const {
-      return choose(Cond<NumTraits<CoeffReturnType>::IsComplex>(), unaryExpr(internal::scalar_conjugate_op<Scalar>()), derived());
-    }
-
-    template<typename ScalarExponent>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const std::enable_if_t<internal::is_arithmetic<typename NumTraits<ScalarExponent>::Real>::value,
-        TensorCwiseUnaryOp<internal::scalar_unary_pow_op<Scalar, ScalarExponent>, const Derived>>
-        pow(ScalarExponent exponent) const
-    {
-        return unaryExpr(internal::scalar_unary_pow_op<Scalar, ScalarExponent>(exponent));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>
-    real() const {
-      return unaryExpr(internal::scalar_real_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived>
-    imag() const {
-      return unaryExpr(internal::scalar_imag_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_sum_op<Scalar,Scalar> >, const Derived>
-    operator+ (Scalar rhs) const {
-      return unaryExpr(internal::bind2nd_op<internal::scalar_sum_op<Scalar,Scalar> >(rhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE friend
-    const TensorCwiseUnaryOp<internal::bind1st_op<internal::scalar_sum_op<Scalar> >, const Derived>
-    operator+ (Scalar lhs, const Derived& rhs) {
-      return rhs.unaryExpr(internal::bind1st_op<internal::scalar_sum_op<Scalar> >(lhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_difference_op<Scalar,Scalar> >, const Derived>
-    operator- (Scalar rhs) const {
-      EIGEN_STATIC_ASSERT((NumTraits<Scalar>::IsSigned || internal::is_same<Scalar, const std::complex<float> >::value), YOU_MADE_A_PROGRAMMING_MISTAKE);
-      return unaryExpr(internal::bind2nd_op<internal::scalar_difference_op<Scalar,Scalar> >(rhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE friend
-    const TensorCwiseUnaryOp<internal::bind1st_op<internal::scalar_difference_op<Scalar> >, const Derived>
-    operator- (Scalar lhs, const Derived& rhs) {
-      return rhs.unaryExpr(internal::bind1st_op<internal::scalar_difference_op<Scalar> >(lhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_product_op<Scalar,Scalar> >, const Derived>
-    operator* (Scalar rhs) const {
-      return unaryExpr(internal::bind2nd_op<internal::scalar_product_op<Scalar,Scalar> >(rhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE friend
-    const TensorCwiseUnaryOp<internal::bind1st_op<internal::scalar_product_op<Scalar> >, const Derived>
-    operator* (Scalar lhs, const Derived& rhs) {
-      return rhs.unaryExpr(internal::bind1st_op<internal::scalar_product_op<Scalar> >(lhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::bind2nd_op<internal::scalar_quotient_op<Scalar,Scalar> >, const Derived>
-    operator/ (Scalar rhs) const {
-      return unaryExpr(internal::bind2nd_op<internal::scalar_quotient_op<Scalar,Scalar> >(rhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE friend
-    const TensorCwiseUnaryOp<internal::bind1st_op<internal::scalar_quotient_op<Scalar> >, const Derived>
-    operator/ (Scalar lhs, const Derived& rhs) {
-      return rhs.unaryExpr(internal::bind1st_op<internal::scalar_quotient_op<Scalar> >(lhs));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_mod_op<Scalar>, const Derived>
-    operator% (Scalar rhs) const {
-      EIGEN_STATIC_ASSERT(NumTraits<Scalar>::IsInteger, YOU_MADE_A_PROGRAMMING_MISTAKE_TRY_MOD);
-      return unaryExpr(internal::scalar_mod_op<Scalar>(rhs));
-    }
-
-    template <int NanPropagation=PropagateFast>
-    EIGEN_DEVICE_FUNC
-        EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar,NanPropagation>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    cwiseMax(Scalar threshold) const {
-      return cwiseMax<NanPropagation>(constant(threshold));
-    }
-
-    template <int NanPropagation=PropagateFast>
-    EIGEN_DEVICE_FUNC
-        EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar,NanPropagation>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    cwiseMin(Scalar threshold) const {
-      return cwiseMin<NanPropagation>(constant(threshold));
-    }
-
-    template<typename NewType>
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const std::conditional_t<internal::is_same<NewType, CoeffReturnType>::value,
-                                                      Derived,
-                                                      TensorConversionOp<NewType, const Derived> >
-    cast() const {
-      return choose(Cond<internal::is_same<NewType, CoeffReturnType>::value>(), derived(), TensorConversionOp<NewType, const Derived>(derived()));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_round_op<Scalar>, const Derived>
-    round() const {
-      return unaryExpr(internal::scalar_round_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_rint_op<Scalar>, const Derived>
-    rint() const {
-      return unaryExpr(internal::scalar_rint_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_ceil_op<Scalar>, const Derived>
-    ceil() const {
-      return unaryExpr(internal::scalar_ceil_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseUnaryOp<internal::scalar_floor_op<Scalar>, const Derived>
-    floor() const {
-      return unaryExpr(internal::scalar_floor_op<Scalar>());
-    }
-
-    // Generic binary operation support.
-    template <typename CustomBinaryOp, typename OtherDerived> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>
-    binaryExpr(const OtherDerived& other, const CustomBinaryOp& func) const {
-      return TensorCwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>(derived(), other, func);
-    }
-
-    // Coefficient-wise binary operators.
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_sum_op<Scalar>, const Derived, const OtherDerived>
-    operator+(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_sum_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_difference_op<Scalar>, const Derived, const OtherDerived>
-    operator-(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_difference_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_product_op<Scalar>, const Derived, const OtherDerived>
-    operator*(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_product_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>
-    operator/(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_quotient_op<Scalar>());
-    }
-
-    template<int NaNPropagation=PropagateFast, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_max_op<Scalar,Scalar, NaNPropagation>, const Derived, const OtherDerived>
-    cwiseMax(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_max_op<Scalar,Scalar, NaNPropagation>());
-    }
-
-    template<int NaNPropagation=PropagateFast, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_min_op<Scalar,Scalar, NaNPropagation>, const Derived, const OtherDerived>
-    cwiseMin(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_min_op<Scalar,Scalar, NaNPropagation>());
-    }
-
-    // logical operators
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_boolean_and_op<Scalar>, const Derived, const OtherDerived>
-    operator&&(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_boolean_and_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_boolean_or_op<Scalar>, const Derived, const OtherDerived>
-    operator||(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_boolean_or_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_bitwise_and_op<Scalar>, const Derived, const OtherDerived>
-    operator&(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_bitwise_and_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_bitwise_or_op<Scalar>, const Derived, const OtherDerived>
-    operator|(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_bitwise_or_op<Scalar>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_bitwise_xor_op<Scalar>, const Derived, const OtherDerived>
-    operator^(const OtherDerived& other) const {
-      return binaryExpr(other.derived(), internal::scalar_bitwise_xor_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseUnaryOp<internal::scalar_boolean_not_op<Scalar>, const Derived>
-    operator!() const {
-      return unaryExpr(internal::scalar_boolean_not_op<Scalar>());
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseUnaryOp<internal::scalar_bitwise_not_op<Scalar>, const Derived>
-    operator~() const {
-      return unaryExpr(internal::scalar_bitwise_not_op<Scalar>());
-    }
-
-    // Comparisons and tests.
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT>, const Derived, const OtherDerived>
-    operator<(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
-      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT>());
-    }
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE>, const Derived, const OtherDerived>
-    operator<=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
-      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE>());
-    }
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT>, const Derived, const OtherDerived>
-    operator>(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
-      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT>());
-    }
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE>, const Derived, const OtherDerived>
-    operator>=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
-      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>, const Derived, const OtherDerived>
-    operator==(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
-      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>());
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ>, const Derived, const OtherDerived>
-    operator!=(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) const {
-      return binaryExpr(other.derived(), internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ>());
-    }
-
-    // comparisons and tests for Scalars
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    operator<(Scalar threshold) const {
-      return operator<(constant(threshold));
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    operator<=(Scalar threshold) const {
-      return operator<=(constant(threshold));
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    operator>(Scalar threshold) const {
-      return operator>(constant(threshold));
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    operator>=(Scalar threshold) const {
-      return operator>=(constant(threshold));
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    operator==(Scalar threshold) const {
-      return operator==(constant(threshold));
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorCwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ>, const Derived, const TensorCwiseNullaryOp<internal::scalar_constant_op<Scalar>, const Derived> >
-    operator!=(Scalar threshold) const {
-      return operator!=(constant(threshold));
-    }
-
-    // Predicates.
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorConversionOp<bool, const TensorCwiseUnaryOp<internal::scalar_isnan_op<Scalar, true>, const Derived>>
-    (isnan)() const {
-      return unaryExpr(internal::scalar_isnan_op<Scalar, true>()).template cast<bool>();
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorConversionOp<bool, const TensorCwiseUnaryOp<internal::scalar_isinf_op<Scalar, true>, const Derived>>
-    (isinf)() const {
-      return unaryExpr(internal::scalar_isinf_op<Scalar, true>()).template cast<bool>();
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const TensorConversionOp<bool, const TensorCwiseUnaryOp<internal::scalar_isfinite_op<Scalar, true>, const Derived>>
-    (isfinite)() const {
-      return unaryExpr(internal::scalar_isfinite_op<Scalar, true>()).template cast<bool>();
-    }
-
-    // Coefficient-wise ternary operators.
-    template<typename ThenDerived, typename ElseDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorSelectOp<const Derived, const ThenDerived, const ElseDerived>
-    select(const ThenDerived& thenTensor, const ElseDerived& elseTensor) const {
-      return TensorSelectOp<const Derived, const ThenDerived, const ElseDerived>(derived(), thenTensor.derived(), elseTensor.derived());
-    }
-
-    // Contractions.
-    typedef Eigen::IndexPair<Index> DimensionPair;
-
-    template<typename OtherDerived, typename Dimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const NoOpOutputKernel>
-    contract(const OtherDerived& other, const Dimensions& dims) const {
-      return TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const NoOpOutputKernel>(derived(), other.derived(), dims);
-    }
-
-    template<typename OtherDerived, typename Dimensions, typename OutputKernel> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const OutputKernel>
-    contract(const OtherDerived& other, const Dimensions& dims, const OutputKernel& output_kernel) const {
-      return TensorContractionOp<const Dimensions, const Derived, const OtherDerived, const OutputKernel>(derived(), other.derived(), dims, output_kernel);
-    }
-
-    // Convolutions.
-    template<typename KernelDerived, typename Dimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorConvolutionOp<const Dimensions, const Derived, const KernelDerived>
-    convolve(const KernelDerived& kernel, const Dimensions& dims) const {
-      return TensorConvolutionOp<const Dimensions, const Derived, const KernelDerived>(derived(), kernel.derived(), dims);
-    }
-
-    // Fourier transforms
-    template <int FFTDataType, int FFTDirection, typename FFT> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorFFTOp<const FFT, const Derived, FFTDataType, FFTDirection>
-    fft(const FFT& dims) const {
-      return TensorFFTOp<const FFT, const Derived, FFTDataType, FFTDirection>(derived(), dims);
-    }
-
-    // Scan.
-    typedef TensorScanOp<internal::SumReducer<CoeffReturnType>, const Derived> TensorScanSumOp;
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorScanSumOp
-    cumsum(const Index& axis, bool exclusive = false) const {
-      return TensorScanSumOp(derived(), axis, exclusive);
-    }
-
-    typedef TensorScanOp<internal::ProdReducer<CoeffReturnType>, const Derived> TensorScanProdOp;
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorScanProdOp
-    cumprod(const Index& axis, bool exclusive = false) const {
-      return TensorScanProdOp(derived(), axis, exclusive);
-    }
-
-    template <typename Reducer>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorScanOp<Reducer, const Derived>
-    scan(const Index& axis, const Reducer& reducer, bool exclusive = false) const {
-      return TensorScanOp<Reducer, const Derived>(derived(), axis, exclusive, reducer);
-    }
-
-    // Reductions.
-    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::SumReducer<CoeffReturnType>, const Dims, const Derived>
-    sum(const Dims& dims) const {
-      return TensorReductionOp<internal::SumReducer<CoeffReturnType>, const Dims, const Derived>(derived(), dims, internal::SumReducer<CoeffReturnType>());
-    }
-
-    const TensorReductionOp<internal::SumReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>
-    sum() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return TensorReductionOp<internal::SumReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::SumReducer<CoeffReturnType>());
-    }
-
-    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const Dims, const Derived>
-    mean(const Dims& dims) const {
-      return TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const Dims, const Derived>(derived(), dims, internal::MeanReducer<CoeffReturnType>());
-    }
-
-    const TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>
-    mean() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return TensorReductionOp<internal::MeanReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::MeanReducer<CoeffReturnType>());
-    }
-
-    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const Dims, const Derived>
-    prod(const Dims& dims) const {
-      return TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const Dims, const Derived>(derived(), dims, internal::ProdReducer<CoeffReturnType>());
-    }
-
-    const TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>
-    prod() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return TensorReductionOp<internal::ProdReducer<CoeffReturnType>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::ProdReducer<CoeffReturnType>());
-    }
-
-    template <typename Dims,int NanPropagation=PropagateFast> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>
-    maximum(const Dims& dims) const {
-      return TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>(derived(), dims, internal::MaxReducer<CoeffReturnType,NanPropagation>());
-    }
-
-    template <int NanPropagation=PropagateFast>
-    const TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>
-    maximum() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return TensorReductionOp<internal::MaxReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::MaxReducer<CoeffReturnType,NanPropagation>());
-    }
-
-    template <typename Dims,int NanPropagation=PropagateFast> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>
-    minimum(const Dims& dims) const {
-      return TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const Dims, const Derived>(derived(), dims, internal::MinReducer<CoeffReturnType,NanPropagation>());
-    }
-
-    template <int NanPropagation=PropagateFast>
-    const TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>
-    minimum() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return TensorReductionOp<internal::MinReducer<CoeffReturnType,NanPropagation>, const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims, internal::MinReducer<CoeffReturnType,NanPropagation>());
-    }
-
-    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::AndReducer, const Dims, const std::conditional_t<internal::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
-    all(const Dims& dims) const {
-      return cast<bool>().reduce(dims, internal::AndReducer());
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::AndReducer, const DimensionList<Index, NumDimensions>, const std::conditional_t<internal::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
-    all() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return cast<bool>().reduce(in_dims, internal::AndReducer());
-    }
-
-    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::OrReducer, const Dims, const std::conditional_t<internal::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
-    any(const Dims& dims) const {
-      return cast<bool>().reduce(dims, internal::OrReducer());
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<internal::OrReducer, const DimensionList<Index, NumDimensions>, const std::conditional_t<internal::is_same<bool, CoeffReturnType>::value, Derived, TensorConversionOp<bool, const Derived> > >
-    any() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return cast<bool>().reduce(in_dims, internal::OrReducer());
-    }
-
-   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPairReducerOp<
-      internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
-      const array<Index, NumDimensions>, const Derived>
-    argmax() const {
-      array<Index, NumDimensions> in_dims;
-      for (Index d = 0; d < NumDimensions; ++d) in_dims[d] = d;
-      return TensorPairReducerOp<
-        internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
-        const array<Index, NumDimensions>,
-        const Derived>(derived(), internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >(), -1, in_dims);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPairReducerOp<
-      internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
-      const array<Index, NumDimensions>, const Derived>
-    argmin() const {
-      array<Index, NumDimensions> in_dims;
-      for (Index d = 0; d < NumDimensions; ++d) in_dims[d] = d;
-      return TensorPairReducerOp<
-        internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
-        const array<Index, NumDimensions>,
-        const Derived>(derived(), internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >(), -1, in_dims);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPairReducerOp<
-      internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
-      const array<Index, 1>, const Derived>
-    argmax(const Index return_dim) const {
-      array<Index, 1> in_dims;
-      in_dims[0] = return_dim;
-      return TensorPairReducerOp<
-        internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >,
-        const array<Index, 1>,
-        const Derived>(derived(), internal::ArgMaxPairReducer<Pair<Index, CoeffReturnType> >(), return_dim, in_dims);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPairReducerOp<
-      internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
-      const array<Index, 1>, const Derived>
-    argmin(const Index return_dim) const {
-      array<Index, 1> in_dims;
-      in_dims[0] = return_dim;
-      return TensorPairReducerOp<
-        internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >,
-        const array<Index, 1>,
-        const Derived>(derived(), internal::ArgMinPairReducer<Pair<Index, CoeffReturnType> >(), return_dim, in_dims);
-    }
-
-    template <typename Reducer, typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReductionOp<Reducer, const Dims, const Derived>
-    reduce(const Dims& dims, const Reducer& reducer) const {
-      return TensorReductionOp<Reducer, const Dims, const Derived>(derived(), dims, reducer);
-    }
-
-    template <typename Dims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorTraceOp<const Dims, const Derived>
-    trace(const Dims& dims) const {
-      return TensorTraceOp<const Dims, const Derived>(derived(), dims);
-    }
-
-    const TensorTraceOp<const DimensionList<Index, NumDimensions>, const Derived>
-    trace() const {
-      DimensionList<Index, NumDimensions> in_dims;
-      return TensorTraceOp<const DimensionList<Index, NumDimensions>, const Derived>(derived(), in_dims);
-    }
-
-    template <typename Broadcast> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorBroadcastingOp<const Broadcast, const Derived>
-    broadcast(const Broadcast& bcast) const {
-      return TensorBroadcastingOp<const Broadcast, const Derived>(derived(), bcast);
-    }
-
-    template <typename Axis, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorConcatenationOp<Axis, const Derived, const OtherDerived>
-    concatenate(const OtherDerived& other, Axis axis) const {
-      return TensorConcatenationOp<Axis, const Derived, const OtherDerived>(derived(), other.derived(), axis);
-    }
-
-    template <typename PatchDims> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPatchOp<const PatchDims, const Derived>
-    extract_patches(const PatchDims& patch_dims) const {
-      return TensorPatchOp<const PatchDims, const Derived>(derived(), patch_dims);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorImagePatchOp<Dynamic, Dynamic, const Derived>
-    extract_image_patches(const Index patch_rows = 1, const Index patch_cols = 1,
-                          const Index row_stride = 1, const Index col_stride = 1,
-                          const Index in_row_stride = 1, const Index in_col_stride = 1,
-                          const PaddingType padding_type = PADDING_SAME, const Scalar padding_value = Scalar(0)) const {
-      return TensorImagePatchOp<Dynamic, Dynamic, const Derived>(derived(), patch_rows, patch_cols, row_stride, col_stride,
-                                                                 in_row_stride, in_col_stride, 1, 1, padding_type, padding_value);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorImagePatchOp<Dynamic, Dynamic, const Derived>
-    extract_image_patches(const Index patch_rows, const Index patch_cols,
-                          const Index row_stride, const Index col_stride,
-                          const Index in_row_stride, const Index in_col_stride,
-                          const Index row_inflate_stride, const Index col_inflate_stride,
-                          const Index padding_top, const Index padding_bottom,
-                          const Index padding_left,const Index padding_right,
-                          const Scalar padding_value) const {
-      return TensorImagePatchOp<Dynamic, Dynamic, const Derived>(derived(), patch_rows, patch_cols, row_stride, col_stride,
-                                                                 in_row_stride, in_col_stride, row_inflate_stride, col_inflate_stride,
-                                                                 padding_top, padding_bottom, padding_left, padding_right, padding_value);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>
-    extract_volume_patches(const Index patch_planes, const Index patch_rows, const Index patch_cols,
-                           const Index plane_stride = 1, const Index row_stride = 1, const Index col_stride = 1,
-                           const PaddingType padding_type = PADDING_SAME, const Scalar padding_value = Scalar(0)) const {
-      return TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>(derived(), patch_planes, patch_rows, patch_cols, plane_stride, row_stride, col_stride, 1, 1, 1, 1, 1, 1, padding_type, padding_value);
-    }
-
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>
-    extract_volume_patches(const Index patch_planes, const Index patch_rows, const Index patch_cols,
-                           const Index plane_stride, const Index row_stride, const Index col_stride,
-                           const Index plane_inflate_stride, const Index row_inflate_stride, const Index col_inflate_stride,
-                           const Index padding_top_z, const Index padding_bottom_z,
-                           const Index padding_top, const Index padding_bottom,
-                           const Index padding_left, const Index padding_right, const Scalar padding_value = Scalar(0)) const {
-      return TensorVolumePatchOp<Dynamic, Dynamic, Dynamic, const Derived>(derived(), patch_planes, patch_rows, patch_cols, plane_stride, row_stride, col_stride, 1, 1, 1, plane_inflate_stride, row_inflate_stride, col_inflate_stride, padding_top_z, padding_bottom_z, padding_top, padding_bottom, padding_left, padding_right, padding_value);
-    }
-
-    // Morphing operators.
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorLayoutSwapOp<const Derived>
-    swap_layout() const {
-      return TensorLayoutSwapOp<const Derived>(derived());
-    }
-    template <typename NewDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReshapingOp<const NewDimensions, const Derived>
-    reshape(const NewDimensions& newDimensions) const {
-      return TensorReshapingOp<const NewDimensions, const Derived>(derived(), newDimensions);
-    }
-    template <typename StartIndices, typename Sizes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorSlicingOp<const StartIndices, const Sizes, const Derived>
-    slice(const StartIndices& startIndices, const Sizes& sizes) const {
-      return TensorSlicingOp<const StartIndices, const Sizes, const Derived>(derived(), startIndices, sizes);
-    }
-    template <typename StartIndices, typename StopIndices, typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides, const Derived>
-    stridedSlice(const StartIndices& startIndices, const StopIndices& stopIndices, const Strides& strides) const {
-      return TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides,
-                                const Derived>(derived(), startIndices, stopIndices, strides);
-    }
-    template <Index DimId> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorChippingOp<DimId, const Derived>
-    chip(const Index offset) const {
-      EIGEN_STATIC_ASSERT(DimId < Derived::NumDimensions && DimId >= 0, Chip_Dim_out_of_range)
-      return TensorChippingOp<DimId, const Derived>(derived(), offset, DimId);
-    }
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorChippingOp<Dynamic, const Derived>
-    chip(const Index offset, const Index dim) const {
-      return TensorChippingOp<Dynamic, const Derived>(derived(), offset, dim);
-    }
-    template <typename ReverseDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReverseOp<const ReverseDimensions, const Derived>
-    reverse(const ReverseDimensions& rev) const {
-      return TensorReverseOp<const ReverseDimensions, const Derived>(derived(), rev);
-    }
-    template <typename Rolls> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorRollOp<const Rolls, const Derived>
-    roll(const Rolls& rolls) const {
-      return TensorRollOp<const Rolls, const Derived>(derived(), rolls);
-    }
-    template <typename PaddingDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPaddingOp<const PaddingDimensions, const Derived>
-    pad(const PaddingDimensions& padding) const {
-      return TensorPaddingOp<const PaddingDimensions, const Derived>(derived(), padding, internal::scalar_cast_op<int, Scalar>()(0));
-    }
-    template <typename PaddingDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorPaddingOp<const PaddingDimensions, const Derived>
-    pad(const PaddingDimensions& padding, const Scalar padding_value) const {
-      return TensorPaddingOp<const PaddingDimensions, const Derived>(derived(), padding, padding_value);
-    }
-    template <typename Shuffle> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorShufflingOp<const Shuffle, const Derived>
-    shuffle(const Shuffle& shfl) const {
-      return TensorShufflingOp<const Shuffle, const Derived>(derived(), shfl);
-    }
-    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorStridingOp<const Strides, const Derived>
-    stride(const Strides& strides) const {
-      return TensorStridingOp<const Strides, const Derived>(derived(), strides);
-    }
-    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorInflationOp<const Strides, const Derived>
-    inflate(const Strides& strides) const {
-      return TensorInflationOp<const Strides, const Derived>(derived(), strides);
-    }
-
-    // Returns a tensor containing index/value pairs
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorIndexPairOp<const Derived>
-    index_pairs() const {
-      return TensorIndexPairOp<const Derived>(derived());
-    }
-
-    // Support for custom unary and binary operations
-    template <typename CustomUnaryFunc>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCustomUnaryOp<const CustomUnaryFunc, const Derived> customOp(const CustomUnaryFunc& op) const {
-      return TensorCustomUnaryOp<const CustomUnaryFunc, const Derived>(derived(), op);
-    }
-    template <typename OtherDerived, typename CustomBinaryFunc>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorCustomBinaryOp<const CustomBinaryFunc, const Derived, const OtherDerived> customOp(const OtherDerived& other, const CustomBinaryFunc& op) const {
-      return TensorCustomBinaryOp<const CustomBinaryFunc, const Derived, const OtherDerived>(derived(), other, op);
-    }
-
-    // Force the evaluation of the expression.
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorForcedEvalOp<const Derived> eval() const {
-      return TensorForcedEvalOp<const Derived>(derived());
-    }
-
-    // Returns a formatted tensor ready for printing to a stream
-    template<typename Format>
-    inline const TensorWithFormat<Derived,DerivedTraits::Layout,DerivedTraits::NumDimensions, Format> format(const Format& fmt) const {
-      return TensorWithFormat<Derived,DerivedTraits::Layout,DerivedTraits::NumDimensions, Format>(derived(), fmt);
-    }
-
-    #ifdef EIGEN_READONLY_TENSORBASE_PLUGIN
-    #include EIGEN_READONLY_TENSORBASE_PLUGIN
-    #endif
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const Derived& derived() const { return *static_cast<const Derived*>(this); }
-
-  protected:
-    template <typename Scalar, int NumIndices, int Options, typename IndexType> friend class Tensor;
-    template <typename Scalar, typename Dimensions, int Option, typename IndexTypes> friend class TensorFixedSize;
-    // the Eigen:: prefix is required to workaround a compilation issue with nvcc 9.0
-    template <typename OtherDerived, int AccessLevel> friend class Eigen::TensorBase;
-};
-
-template<typename Derived, int AccessLevel = internal::accessors_level<Derived>::value>
-class TensorBase : public TensorBase<Derived, ReadOnlyAccessors> {
- public:
-    typedef TensorBase<Derived, ReadOnlyAccessors> Base;
-    typedef internal::traits<Derived> DerivedTraits;
-    typedef typename DerivedTraits::Scalar Scalar;
-    typedef typename DerivedTraits::Index Index;
-    typedef Scalar CoeffReturnType;
-    static constexpr int NumDimensions = DerivedTraits::NumDimensions;
-
-    template <typename Scalar, int NumIndices, int Options, typename IndexType> friend class Tensor;
-    template <typename Scalar, typename Dimensions, int Option, typename IndexTypes> friend class TensorFixedSize;
-    // the Eigen:: prefix is required to workaround a compilation issue with nvcc 9.0
-    template <typename OtherDerived, int OtherAccessLevel> friend class Eigen::TensorBase;
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& setZero() {
-      return setConstant(Scalar(0));
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& setConstant(const Scalar& val) {
-      return derived() = this->constant(val);
-    }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& setRandom() {
-      return derived() = this->random();
-    }
-    template <typename RandomGenerator> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& setRandom() {
-      return derived() = this->template random<RandomGenerator>();
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& setValues(
-        const typename internal::Initializer<Derived, NumDimensions>::InitList& vals) {
-      TensorEvaluator<Derived, DefaultDevice> eval(derived(), DefaultDevice());
-      internal::initialize_tensor<Derived, NumDimensions>(eval, vals);
-      return derived();
-    }
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    Derived& operator+=(const OtherDerived& other) {
-      return derived() = derived() + other.derived();
-    }
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    Derived& operator-=(const OtherDerived& other) {
-      return derived() = derived() - other.derived();
-    }
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    Derived& operator*=(const OtherDerived& other) {
-      return derived() = derived() * other.derived();
-    }
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    Derived& operator/=(const OtherDerived& other) {
-      return derived() = derived() / other.derived();
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorLayoutSwapOp<const Derived>
-    swap_layout() const {
-      return TensorLayoutSwapOp<const Derived>(derived());
-    }
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorLayoutSwapOp<Derived>
-    swap_layout() {
-      return TensorLayoutSwapOp<Derived>(derived());
-    }
-
-    template <typename Axis, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorConcatenationOp<const Axis, const Derived, const OtherDerived>
-    concatenate(const OtherDerived& other, const Axis& axis) const {
-      return TensorConcatenationOp<const Axis, const Derived, const OtherDerived>(derived(), other, axis);
-    }
-    template <typename Axis, typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorConcatenationOp<const Axis, Derived, OtherDerived>
-    concatenate(const OtherDerived& other, const Axis& axis) {
-      return TensorConcatenationOp<const Axis, Derived, OtherDerived>(derived(), other, axis);
-    }
-
-    template <typename NewDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReshapingOp<const NewDimensions, const Derived>
-    reshape(const NewDimensions& newDimensions) const {
-      return TensorReshapingOp<const NewDimensions, const Derived>(derived(), newDimensions);
-    }
-    template <typename NewDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorReshapingOp<const NewDimensions, Derived>
-    reshape(const NewDimensions& newDimensions) {
-      return TensorReshapingOp<const NewDimensions, Derived>(derived(), newDimensions);
-    }
-
-    template <typename StartIndices, typename Sizes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorSlicingOp<const StartIndices, const Sizes, const Derived>
-    slice(const StartIndices& startIndices, const Sizes& sizes) const {
-      return TensorSlicingOp<const StartIndices, const Sizes, const Derived>(derived(), startIndices, sizes);
-    }
-    template <typename StartIndices, typename Sizes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorSlicingOp<const StartIndices, const Sizes, Derived>
-    slice(const StartIndices& startIndices, const Sizes& sizes) {
-      return TensorSlicingOp<const StartIndices, const Sizes, Derived>(derived(), startIndices, sizes);
-    }
-
-    template <typename StartIndices, typename StopIndices, typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides, const Derived>
-    stridedSlice(const StartIndices& startIndices, const StopIndices& stopIndices, const Strides& strides) const {
-      return TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides,
-                                const Derived>(derived(), startIndices, stopIndices, strides);
-    }
-    template <typename StartIndices, typename StopIndices, typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides, Derived>
-    stridedSlice(const StartIndices& startIndices, const StopIndices& stopIndices, const Strides& strides) {
-      return TensorStridingSlicingOp<const StartIndices, const StopIndices, const Strides,
-                                Derived>(derived(), startIndices, stopIndices, strides);
-    }
-
-    template <DenseIndex DimId> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorChippingOp<DimId, const Derived>
-    chip(const Index offset) const {
-      EIGEN_STATIC_ASSERT(DimId < Derived::NumDimensions && DimId >= 0, Chip_Dim_out_of_range)
-      return TensorChippingOp<DimId, const Derived>(derived(), offset, DimId);
-    }
-    template <Index DimId> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorChippingOp<DimId, Derived>
-    chip(const Index offset) {
-      EIGEN_STATIC_ASSERT(DimId < Derived::NumDimensions && DimId >= 0, Chip_Dim_out_of_range)
-      return TensorChippingOp<DimId, Derived>(derived(), offset, DimId);
-    }
-
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorChippingOp<Dynamic, const Derived>
-    chip(const Index offset, const Index dim) const {
-      return TensorChippingOp<Dynamic, const Derived>(derived(), offset, dim);
-    }
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorChippingOp<Dynamic, Derived>
-    chip(const Index offset, const Index dim) {
-      return TensorChippingOp<Dynamic, Derived>(derived(), offset, dim);
-    }
-
-    template <typename ReverseDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorReverseOp<const ReverseDimensions, const Derived>
-    reverse(const ReverseDimensions& rev) const {
-      return TensorReverseOp<const ReverseDimensions, const Derived>(derived(), rev);
-    }
-    template <typename ReverseDimensions> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorReverseOp<const ReverseDimensions, Derived>
-    reverse(const ReverseDimensions& rev) {
-      return TensorReverseOp<const ReverseDimensions, Derived>(derived(), rev);
-    }
-
-    template <typename Rolls> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorRollOp<const Rolls, const Derived>
-    roll(const Rolls& roll) const {
-      return TensorRollOp<const Rolls, const Derived>(derived(), roll);
-    }
-    template <typename Rolls> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorRollOp<const Rolls, Derived>
-    roll(const Rolls& roll) {
-      return TensorRollOp<const Rolls, Derived>(derived(), roll);
-    }
-
-    template <typename Shuffle> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorShufflingOp<const Shuffle, const Derived>
-    shuffle(const Shuffle& shfl) const {
-      return TensorShufflingOp<const Shuffle, const Derived>(derived(), shfl);
-    }
-    template <typename Shuffle> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorShufflingOp<const Shuffle, Derived>
-    shuffle(const Shuffle& shfl) {
-      return TensorShufflingOp<const Shuffle, Derived>(derived(), shfl);
-    }
-
-    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    const TensorStridingOp<const Strides, const Derived>
-    stride(const Strides& strides) const {
-      return TensorStridingOp<const Strides, const Derived>(derived(), strides);
-    }
-    template <typename Strides> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    TensorStridingOp<const Strides, Derived>
-    stride(const Strides& strides) {
-      return TensorStridingOp<const Strides, Derived>(derived(), strides);
-    }
-
-    // Select the device on which to evaluate the expression.
-    template <typename DeviceType>
-    TensorDevice<Derived, DeviceType> device(const DeviceType& dev) {
-      return TensorDevice<Derived, DeviceType>(dev, derived());
-    }
-
-    // Select the async device on which to evaluate the expression.
-    template <typename DeviceType, typename DoneCallback>
-    TensorAsyncDevice<Derived, DeviceType, DoneCallback> device(const DeviceType& dev, DoneCallback done) {
-      return TensorAsyncDevice<Derived, DeviceType, DoneCallback>(dev, derived(), std::move(done));
-    }
-
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& derived() { return *static_cast<Derived*>(this); }
-    EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE const Derived& derived() const { return *static_cast<const Derived*>(this); }
-
-    #ifdef EIGEN_TENSORBASE_PLUGIN
-    #include EIGEN_TENSORBASE_PLUGIN
-    #endif
-
- protected:
-    EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TensorBase)
-    EIGEN_DEFAULT_COPY_CONSTRUCTOR(TensorBase)
-
-    template<typename OtherDerived> EIGEN_DEVICE_FUNC
-    EIGEN_STRONG_INLINE Derived& operator=(const OtherDerived& other)
-    {
-      typedef TensorAssignOp<Derived, const OtherDerived> Assign;
-      Assign assign(derived(), other.derived());
-      internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-      return derived();
-    }
-};
-#endif // EIGEN_PARSED_BY_DOXYGEN
-} // end namespace Eigen
-
-#endif // EIGEN_CXX11_TENSOR_TENSOR_BASE_H
diff --git a/unsupported/Eigen/src/Tensor/TensorBlock.h b/unsupported/Eigen/src/Tensor/TensorBlock.h
deleted file mode 100644
index 00bec13..0000000
--- a/unsupported/Eigen/src/Tensor/TensorBlock.h
+++ /dev/null
@@ -1,1474 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_BLOCK_H
-#define EIGEN_CXX11_TENSOR_TENSOR_BLOCK_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-// -------------------------------------------------------------------------- //
-// Forward declarations for templates defined below.
-template <typename Scalar, typename IndexType, int NumDims, int Layout>
-class TensorBlockIO;
-
-// -------------------------------------------------------------------------- //
-// Helper function to compute strides for densely stored buffer of given
-// dimensions.
-
-// TODO(ezhulenev): We compute strides many times in different evaluators, use
-// this function instead everywhere.
-template <int Layout, typename IndexType, int NumDims>
-EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> strides(const DSizes<IndexType, NumDims>& dimensions) {
-  DSizes<IndexType, NumDims> strides;
-  if (NumDims == 0) return strides;
-
-  // TODO(ezhulenev): Use templates to unroll this loop (similar to
-  // h_array_reduce in CXX11meta.h)? Benchmark it.
-  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-    strides[0] = 1;
-    for (int i = 1; i < NumDims; ++i) {
-      strides[i] = strides[i - 1] * dimensions[i - 1];
-    }
-  } else {
-    strides[NumDims - 1] = 1;
-    for (int i = NumDims - 2; i >= 0; --i) {
-      strides[i] = strides[i + 1] * dimensions[i + 1];
-    }
-  }
-
-  return strides;
-}
-
-template <int Layout, typename IndexType, size_t NumDims>
-EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> strides(const Eigen::array<IndexType, NumDims>& dimensions) {
-  return strides<Layout>(DSizes<IndexType, NumDims>(dimensions));
-}
-
-template <int Layout, std::ptrdiff_t... Indices>
-EIGEN_STRONG_INLINE DSizes<std::ptrdiff_t, sizeof...(Indices)> strides(const Sizes<Indices...>& sizes) {
-  return strides<Layout>(DSizes<std::ptrdiff_t, sizeof...(Indices)>(sizes));
-}
-
-// -------------------------------------------------------------------------- //
-
-// Tensor block shape type defines what are the shape preference for the blocks
-// extracted from the larger tensor.
-//
-// Example: blocks of 100 elements from the large 100x100 tensor:
-// - tensor: 100x100
-// - target_block_size: 100
-//
-// TensorBlockShapeType:
-//  - kUniformAllDims: 100 blocks of size 10x10
-//  - kSkewedInnerDims: 100 blocks of size 100x1 (or 1x100 depending on a column
-//                      or row major layout)
-enum class TensorBlockShapeType { kUniformAllDims, kSkewedInnerDims };
-
-struct TensorBlockResourceRequirements {
-  TensorBlockShapeType shape_type;  // target block shape
-  size_t size;                      // target block size
-  TensorOpCost cost_per_coeff;      // cost of computing a single block element
-
-#ifdef EIGEN_HIPCC
-  // For HIPCC, we need to explicitly declare as a "device fun", the constructor
-  // which is implicitly invoked in the "merge" / "any" routines. else HIPCC
-  // errors out complaining about the lack of a matching constructor
-  EIGEN_DEVICE_FUNC TensorBlockResourceRequirements(TensorBlockShapeType shape_type_, size_t size_, TensorOpCost cost_)
-      : shape_type(shape_type_), size(size_), cost_per_coeff(cost_) {}
-#endif
-
-  template <typename Scalar>
-  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements withShapeAndSize(TensorBlockShapeType shape_type,
-                                                                            size_t size_in_bytes, TensorOpCost cost) {
-    const size_t size = numext::maxi(size_t(1), size_in_bytes / sizeof(Scalar));
-    return {shape_type, size, cost};
-  }
-
-  template <typename Scalar>
-  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements withShapeAndSize(TensorBlockShapeType shape_type,
-                                                                            size_t size_in_bytes) {
-    // This default cost per coefficient is valid for most materialized tensor
-    // block evaluation implementations, because they typically just read
-    // coefficients from the underlying tensor storage, and write to the tensor
-    // block buffer (scratch or destination memory, reads and writes have linear
-    // access pattern). We ignore the fixed cost of block evaluation, because in
-    // practice it should negligible.
-    //
-    // Lazy block evaluation adds the cost of calling a functor for each
-    // coefficient.
-    //
-    // All non-trivial block evaluation implementations must provide their own
-    // cost approximation (e.g. shuffling inner dimension has a much higher cost
-    // because it reads memory randomly, although the total number of moved
-    // bytes is the same).
-    return withShapeAndSize<Scalar>(shape_type, size_in_bytes,
-                                    {/*bytes_loaded=*/sizeof(Scalar),
-                                     /*bytes_stored=*/sizeof(Scalar),
-                                     /*compute_cycles=*/0});
-  }
-
-  template <typename Scalar>
-  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements skewed(size_t size_in_bytes) {
-    return withShapeAndSize<Scalar>(TensorBlockShapeType::kSkewedInnerDims, size_in_bytes);
-  }
-
-  template <typename Scalar>
-  EIGEN_DEVICE_FUNC static TensorBlockResourceRequirements uniform(size_t size_in_bytes) {
-    return withShapeAndSize<Scalar>(TensorBlockShapeType::kUniformAllDims, size_in_bytes);
-  }
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorBlockResourceRequirements
-  merge(const TensorBlockResourceRequirements& lhs, const TensorBlockResourceRequirements& rhs) {
-    return {merge(lhs.shape_type, rhs.shape_type),           // shape_type
-            merge(lhs.size, rhs.size),                       // size
-            merge(lhs.cost_per_coeff, rhs.cost_per_coeff)};  // cost_per_coeff
-  }
-
-  EIGEN_DEVICE_FUNC TensorBlockResourceRequirements& addCostPerCoeff(TensorOpCost cost) {
-    cost_per_coeff += cost;
-    return *this;
-  }
-
-  // This is a resource requirement that should be returned from expressions
-  // that do not have any block evaluation preference (e.g. default tensor
-  // expression with raw buffer access).
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorBlockResourceRequirements any() {
-    return {TensorBlockShapeType::kUniformAllDims, 1, {0, 0, 0}};
-  }
-
- private:
-  using Requirements = TensorBlockResourceRequirements;
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE size_t merge(size_t lhs_size, size_t rhs_size) {
-    return numext::maxi(lhs_size, rhs_size);
-  }
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorBlockShapeType merge(TensorBlockShapeType lhs,
-                                                                          TensorBlockShapeType rhs) {
-    return (lhs == TensorBlockShapeType::kSkewedInnerDims || rhs == TensorBlockShapeType::kSkewedInnerDims)
-               ? TensorBlockShapeType::kSkewedInnerDims
-               : TensorBlockShapeType::kUniformAllDims;
-  }
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE TensorOpCost merge(TensorOpCost lhs_cost, TensorOpCost rhs_cost) {
-    return lhs_cost + rhs_cost;
-  }
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockDescriptor specifies a block offset within a tensor and the block
-// sizes along each of the tensor dimensions.
-
-template <int NumDims, typename IndexType = Eigen::Index>
-class TensorBlockDescriptor {
- public:
-  typedef DSizes<IndexType, NumDims> Dimensions;
-
-  // If we evaluate a Tensor assignment, and expression on the left, already has
-  // a memory buffer, then we might do performance optimization, and evaluate
-  // the root expression directly into the final output memory. Some time it's
-  // possible to reuse it for materializing subexpressions inside an expression
-  // tree, to avoid dynamic memory allocation.
-  //
-  // The pointer type of the underlying storage is erased, because passing
-  // Scalar type through all the expression evaluation layers is way too many
-  // templates. In practice destination buffer type should always match the
-  // evaluated expression scalar type.
-  class DestinationBuffer {
-   public:
-    enum DestinationBufferKind : int {
-      // The above explicit specification of "int" as the enum basetype is
-      // needed to get around a HIPCC link error ("the field type is not
-      // amp-compatible")
-      // which is issued for class members with the enum type.
-      // TODO(rocm):
-      // remove the "int" basetype once HIPCC has been fixed to not error out
-      // in the above scenario.
-
-      // Destination buffer is not defined (`m_data` == nullptr).
-      kEmpty,
-
-      // Tensor block defined by an owning tensor block descriptor can fit
-      // contiguously into the destination buffer. In this case it's safe to
-      // materialize tensor block in the destination buffer, wrap it in a
-      // TensorMap, and use to build Eigen expression on top of it.
-      kContiguous,
-
-      // Destination buffer strides do not match strides of the contiguously
-      // stored block, and it's impossible to define a TensorMap over this
-      // buffer. However if we are evaluating a root of an expression tree, we
-      // still can materialize an output into this destination, because we can
-      // guarantee that no one will ever access it through block API.
-      //
-      // In theory it is possible to build valid TensorStriding<TensorMap>
-      // expression on top of this destination buffer, however it has
-      // inefficient coeff/packet access, and defeats the purpose of fast block
-      // evaluation API.
-      kStrided
-    };
-
-    template <typename Scalar>
-    Scalar* data() const {
-      eigen_assert(m_data_type_size == sizeof(Scalar));
-      return static_cast<Scalar*>(m_data);
-    }
-
-    const Dimensions& strides() const { return m_strides; }
-    const DestinationBufferKind& kind() const { return m_kind; }
-
-   private:
-    friend class TensorBlockDescriptor<NumDims, IndexType>;
-
-    DestinationBuffer() : m_data(NULL), m_data_type_size(0), m_kind(kEmpty) {}
-
-    template <typename Scalar>
-    DestinationBuffer(Scalar* data, const Dimensions& strides, DestinationBufferKind kind)
-        : m_data(static_cast<void*>(data)), m_data_type_size(sizeof(Scalar)), m_strides(strides), m_kind(kind) {}
-
-    template <int Layout, typename Scalar>
-    static DestinationBuffer make(const TensorBlockDescriptor& desc, Scalar* data, const Dimensions& strides) {
-      return DestinationBuffer(data, strides, kind<Layout>(desc, strides));
-    }
-
-    template <int Layout>
-    static DestinationBufferKind kind(const TensorBlockDescriptor& desc, const Dimensions& strides) {
-      const Dimensions& desc_dims = desc.dimensions();
-      const Dimensions& desc_strides = internal::strides<Layout>(desc_dims);
-      for (int i = 0; i < NumDims; ++i) {
-        if (desc_dims[i] == 1) continue;
-        if (desc_strides[i] != strides[i]) return kStrided;
-      }
-      return kContiguous;
-    }
-
-    // Storage pointer is type erased, to reduce template bloat, but we still
-    // keep the size of the underlying element type for error checking.
-    void* m_data;
-    size_t m_data_type_size;
-
-    // Destination buffer dimensions always match the dimensions of a tensor
-    // block descriptor it belongs to, however strides might be different.
-    Dimensions m_strides;
-
-    DestinationBufferKind m_kind;
-  };
-
-  TensorBlockDescriptor(const IndexType offset, const Dimensions& dimensions, const DestinationBuffer& destination)
-      : m_offset(offset), m_dimensions(dimensions), m_destination(destination) {}
-
-  TensorBlockDescriptor(const IndexType offset, const Dimensions& dimensions)
-      : m_offset(offset), m_dimensions(dimensions), m_destination(DestinationBuffer()) {}
-
-  IndexType offset() const { return m_offset; }
-  const Dimensions& dimensions() const { return m_dimensions; }
-  IndexType dimension(int index) const { return m_dimensions[index]; }
-  IndexType size() const { return array_prod<IndexType>(m_dimensions); }
-
-  const DestinationBuffer& destination() const { return m_destination; }
-
-  template <int Layout, typename Scalar>
-  void AddDestinationBuffer(Scalar* dst_base, const Dimensions& dst_strides) {
-    eigen_assert(dst_base != NULL);
-    m_destination = DestinationBuffer::template make<Layout>(*this, dst_base, dst_strides);
-  }
-
-  template <int Layout, typename Scalar, typename DstStridesIndexType>
-  void AddDestinationBuffer(Scalar* dst_base, const DSizes<DstStridesIndexType, NumDims>& dst_strides) {
-    // DSizes constructor will do index type promotion if it's safe.
-    AddDestinationBuffer<Layout>(dst_base, Dimensions(dst_strides));
-  }
-
-  TensorBlockDescriptor& DropDestinationBuffer() {
-    m_destination.m_data = NULL;
-    m_destination.m_kind = DestinationBuffer::kEmpty;
-    return *this;
-  }
-
-  bool HasDestinationBuffer() const { return m_destination.kind() != DestinationBuffer::kEmpty; }
-
-  // Returns a copy of `*this` with updated offset.
-  TensorBlockDescriptor WithOffset(IndexType offset) const {
-    return TensorBlockDescriptor(offset, m_dimensions, m_destination);
-  }
-
- private:
-  // Offset and dimensions are immutable after construction. Block descriptor
-  // can only be mutated by adding or dropping destination.
-  const IndexType m_offset;
-  const Dimensions m_dimensions;
-  DestinationBuffer m_destination;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockMapper is responsible for iterating over the blocks of a tensor.
-
-template <int NumDims, int Layout, typename IndexType = Eigen::Index>
-class TensorBlockMapper {
-  typedef TensorBlockDescriptor<NumDims, IndexType> BlockDescriptor;
-
- public:
-  typedef DSizes<IndexType, NumDims> Dimensions;
-
-  TensorBlockMapper() = default;
-  TensorBlockMapper(const DSizes<IndexType, NumDims>& dimensions, const TensorBlockResourceRequirements& requirements)
-      : m_tensor_dimensions(dimensions), m_requirements(requirements) {
-    // Compute block dimensions and the total number of blocks.
-    InitializeBlockDimensions();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType blockCount() const { return m_total_block_count; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType blockTotalSize() const { return m_block_dimensions.TotalSize(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const DSizes<IndexType, NumDims>& blockDimensions() const {
-    return m_block_dimensions;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE BlockDescriptor blockDescriptor(IndexType block_index) const {
-    static const bool isColMajor = Layout == static_cast<int>(ColMajor);
-
-    IndexType offset = 0;
-    DSizes<IndexType, NumDims> dimensions;
-
-    if (NumDims == 0) return BlockDescriptor(offset, dimensions);
-
-    // Iterate outer -> inner dimensions.
-    for (int i = NumDims - 1; i >= 0; --i) {
-      const int dim = isColMajor ? i : NumDims - i - 1;
-
-      const IndexType idx = block_index / m_block_strides[dim];
-      block_index -= idx * m_block_strides[dim];
-
-      const IndexType coord = idx * m_block_dimensions[dim];
-      dimensions[dim] = numext::mini(m_tensor_dimensions[dim] - coord, m_block_dimensions[dim]);
-      offset += coord * m_tensor_strides[dim];
-    }
-
-    return {offset, dimensions};
-  }
-
- private:
-  void InitializeBlockDimensions() {
-    // Requested block shape and size.
-    const TensorBlockShapeType shape_type = m_requirements.shape_type;
-    IndexType target_block_size = numext::maxi<IndexType>(1, static_cast<IndexType>(m_requirements.size));
-
-    IndexType tensor_size = m_tensor_dimensions.TotalSize();
-
-    // Corner case: one of the dimensions is zero. Logic below is too complex
-    // to handle this case on a general basis, just use unit block size.
-    // Note: we must not yield blocks with zero dimensions (recipe for
-    // overflows/underflows, divisions by zero and NaNs later).
-    if (tensor_size == 0) {
-      for (int i = 0; i < NumDims; ++i) {
-        m_block_dimensions[i] = 1;
-      }
-      m_total_block_count = 0;
-      return;
-    }
-
-    // If tensor fits into a target block size, evaluate it as a single block.
-    if (tensor_size <= target_block_size) {
-      m_block_dimensions = m_tensor_dimensions;
-      m_total_block_count = 1;
-      // The only valid block index is `0`, and in this case we do not need
-      // to compute real strides for tensor or blocks (see blockDescriptor).
-      for (int i = 0; i < NumDims; ++i) {
-        m_tensor_strides[i] = 0;
-        m_block_strides[i] = 1;
-      }
-      return;
-    }
-
-    static const bool isColMajor = Layout == static_cast<int>(ColMajor);
-
-    // Block shape skewed towards inner dimension.
-    if (shape_type == TensorBlockShapeType::kSkewedInnerDims) {
-      IndexType coeff_to_allocate = target_block_size;
-
-      for (int i = 0; i < NumDims; ++i) {
-        const int dim = isColMajor ? i : NumDims - i - 1;
-        m_block_dimensions[dim] = numext::mini(coeff_to_allocate, m_tensor_dimensions[dim]);
-        coeff_to_allocate =
-            numext::div_ceil(coeff_to_allocate, numext::maxi(static_cast<IndexType>(1), m_block_dimensions[dim]));
-      }
-      eigen_assert(coeff_to_allocate == 1);
-
-    } else if (shape_type == TensorBlockShapeType::kUniformAllDims) {
-      // Tensor will not fit within 'target_block_size' budget: calculate tensor
-      // block dimension sizes based on "square" dimension size target.
-      const IndexType dim_size_target = convert_index<IndexType>(
-          std::pow(static_cast<float>(target_block_size), 1.0f / static_cast<float>(m_block_dimensions.rank())));
-
-      for (int i = 0; i < NumDims; ++i) {
-        // TODO(andydavis): Adjust the inner most 'block_dim_size' to make it
-        // a multiple of the packet size. Note that reducing
-        // 'block_dim_size' in this manner can increase the number of
-        // blocks, and so will amplify any per-block overhead.
-        m_block_dimensions[i] = numext::mini(dim_size_target, m_tensor_dimensions[i]);
-      }
-
-      // Add any un-allocated coefficients to inner dimension(s).
-      IndexType total_size = m_block_dimensions.TotalSize();
-      for (int i = 0; i < NumDims; ++i) {
-        const int dim = isColMajor ? i : NumDims - i - 1;
-
-        if (m_block_dimensions[dim] < m_tensor_dimensions[dim]) {
-          const IndexType total_size_other_dims = total_size / m_block_dimensions[dim];
-          const IndexType alloc_avail = numext::div_ceil<IndexType>(target_block_size, total_size_other_dims);
-          if (alloc_avail == m_block_dimensions[dim]) {
-            // Insufficient excess coefficients to allocate.
-            break;
-          }
-          m_block_dimensions[dim] = numext::mini(m_tensor_dimensions[dim], alloc_avail);
-          total_size = total_size_other_dims * m_block_dimensions[dim];
-        }
-      }
-
-    } else {
-      eigen_assert(false);  // unknown block shape
-    }
-
-    eigen_assert(m_block_dimensions.TotalSize() >=
-                 numext::mini<IndexType>(target_block_size, m_tensor_dimensions.TotalSize()));
-
-    // Calculate block counts by dimension and total block count.
-    DSizes<IndexType, NumDims> block_count;
-    for (int i = 0; i < NumDims; ++i) {
-      block_count[i] = numext::div_ceil(m_tensor_dimensions[i], m_block_dimensions[i]);
-    }
-    m_total_block_count = array_prod(block_count);
-
-    // Calculate block strides (used for enumerating blocks).
-    m_tensor_strides = strides<Layout>(m_tensor_dimensions);
-    m_block_strides = strides<Layout>(block_count);
-  }
-
-  DSizes<IndexType, NumDims> m_tensor_dimensions;
-  TensorBlockResourceRequirements m_requirements;
-
-  DSizes<IndexType, NumDims> m_block_dimensions;
-  IndexType m_total_block_count;
-
-  DSizes<IndexType, NumDims> m_tensor_strides;
-  DSizes<IndexType, NumDims> m_block_strides;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockScratchAllocator is responsible for allocating temporary buffers
-// for block evaluation (output or input block materialization). Given that
-// Eigen expression traversal order is deterministic, all temporary allocations
-// are happening in the same order, and usually have exactly the same size.
-// Scratch allocator keeps a trace of all dynamic allocations, and after the
-// first block evaluation is completed, we should be able to reuse all the
-// temporary buffers for the next block evaluation.
-
-template <typename Device>
-class TensorBlockScratchAllocator {
- public:
-  explicit TensorBlockScratchAllocator(const Device& device) : m_device(device), m_allocation_index(0) {}
-
-  ~TensorBlockScratchAllocator() {
-    for (size_t i = 0; i < m_allocations.size(); ++i) {
-      m_device.deallocate(m_allocations[i].ptr);
-    }
-  }
-
-  void* allocate(size_t size) {
-    // TODO(ezhulenev): Remove when replaced with inlined vector.
-    if (m_allocations.capacity() == 0) m_allocations.reserve(8);
-
-    // Check if we already have an existing allocation at current index.
-    const int num_allocations = static_cast<int>(m_allocations.size());
-    const bool has_allocation = m_allocation_index < num_allocations;
-
-    // Allocation index can't be larger than the number of allocations.
-    eigen_assert(m_allocation_index <= num_allocations);
-
-    // If we have existing allocation, and its size is larger or equal to
-    // requested size, we do nothing.
-
-    // If current allocation can't fit requested size, we deallocate it, and
-    // replace with a larger allocation.
-    if (has_allocation && m_allocations[m_allocation_index].size < size) {
-      m_device.deallocate(m_allocations[m_allocation_index].ptr);
-      m_allocations[m_allocation_index].ptr = m_device.allocate(size);
-      m_allocations[m_allocation_index].size = size;
-    }
-
-    // Make a new allocation if we don't have an existing one.
-    if (!has_allocation) {
-      Allocation allocation;
-      allocation.ptr = m_device.allocate(size);
-      allocation.size = size;
-      m_allocations.push_back(allocation);
-    }
-
-    eigen_assert(m_allocations[m_allocation_index].ptr != NULL);
-    eigen_assert(m_allocations[m_allocation_index].size >= size);
-
-    return m_allocations[m_allocation_index++].ptr;
-  }
-
-  void reset() { m_allocation_index = 0; }
-
- private:
-  struct Allocation {
-    void* ptr;
-    size_t size;
-  };
-
-  const Device& m_device;
-  int m_allocation_index;
-  // TODO(ezhulenev): This should be an inlined vector.
-  std::vector<Allocation> m_allocations;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockKind represents all possible block kinds, that can be produced by
-// TensorEvaluator::evalBlock function.
-enum TensorBlockKind {
-  // Tensor block that is a lazy expression that must be assigned to a
-  // destination using TensorBlockAssign.
-  kExpr,
-
-  // Tensor block that is a view into a memory buffer owned by an underlying
-  // Tensor expression (e.g. it can be a view into a Tensor buffer).
-  kView,
-
-  // Tensor block that was materialized in a scratch memory buffer, allocated
-  // with TensorBlockScratchAllocator. This block must be copied to a
-  // destination, similar to a block of `kExpr` type.
-  kMaterializedInScratch,
-
-  // Tensor block that was materialized directly into the final output memory
-  // buffer. For example if the left side of an assignment is a Tensor, we can
-  // directly materialize the block in the destination memory.
-  //
-  // If strides in the output buffer do not match tensor block strides, the
-  // Tensor expression will be invalid, and should not be used by
-  // TensorBlockAssign or for constructing another block expression.
-  kMaterializedInOutput
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockNotImplemented should be used to define TensorBlock typedef in
-// TensorEvaluators that do not support block evaluation.
-
-class TensorBlockNotImplemented {
- public:
-  typedef void XprType;
-};
-
-// -------------------------------------------------------------------------- //
-// XprScalar extracts Scalar type from the Eigen expressions (if expression type
-// is not void). It's required to be able to define lazy block expression for
-// argument types, that do not support block evaluation.
-
-template <typename XprType>
-struct XprScalar {
-  typedef typename XprType::Scalar type;
-};
-template <>
-struct XprScalar<void> {
-  typedef void type;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorMaterializedBlock is a fully evaluated block of the original tensor,
-// and XprType is just a TensorMap over the data. This block type is typically
-// used to materialize blocks of tensor expressions, that can't be efficiently
-// represented as lazy Tensor expressions with fast coeff/packet operations,
-// e.g. we materialize all broadcasts into evaluated blocks.
-//
-// TensorMaterializedBlock does not own its memory buffer, it's either a memory
-// buffer that backs the original expression (e.g. block is just a view into a
-// Tensor), or a memory buffer allocated with scratch allocator, and in this
-// case the scratch allocator will deallocate it at the end of block based
-// expression execution.
-//
-// If the block was evaluated directly into the output buffer, and strides in
-// the output buffer do not match block strides, the TensorMap expression will
-// be invalid, and should never be used in block assignment or any other tensor
-// expression.
-
-template <typename Scalar, int NumDims, int Layout, typename IndexType = Eigen::Index>
-class TensorMaterializedBlock {
- public:
-  typedef DSizes<IndexType, NumDims> Dimensions;
-  typedef TensorMap<const Tensor<Scalar, NumDims, Layout> > XprType;
-
-  TensorMaterializedBlock(TensorBlockKind kind, const Scalar* data, const Dimensions& dimensions,
-                          bool valid_expr = true)
-      : m_kind(kind), m_data(data), m_dimensions(dimensions), m_expr(m_data, m_dimensions), m_valid_expr(valid_expr) {
-    eigen_assert(m_kind == internal::TensorBlockKind::kView ||
-                 m_kind == internal::TensorBlockKind::kMaterializedInScratch ||
-                 m_kind == internal::TensorBlockKind::kMaterializedInOutput);
-  }
-
-  TensorBlockKind kind() const { return m_kind; }
-  // NOTE(ezhulenev): Returning XprType by value like in other block types
-  // causes asan failures. The theory is that XprType::Nested doesn't work
-  // properly for TensorMap.
-  const XprType& expr() const {
-    eigen_assert(m_valid_expr);
-    return m_expr;
-  }
-  const Scalar* data() const { return m_data; }
-  void cleanup() {}
-
-  typedef internal::TensorBlockDescriptor<NumDims, IndexType> TensorBlockDesc;
-
-  // TensorMaterializedBlock can be backed by different types of storage:
-  //
-  //   (1) Contiguous block of memory allocated with scratch allocator.
-  //   (2) Contiguous block of memory reused from tensor block descriptor
-  //       destination buffer.
-  //   (3) Strided block of memory reused from tensor block descriptor
-  //       destination buffer.
-  //
-  class Storage {
-   public:
-    Scalar* data() const { return m_data; }
-    const Dimensions& dimensions() const { return m_dimensions; }
-    const Dimensions& strides() const { return m_strides; }
-
-    TensorMaterializedBlock AsTensorMaterializedBlock() const {
-      return TensorMaterializedBlock(m_materialized_in_output ? internal::TensorBlockKind::kMaterializedInOutput
-                                                              : internal::TensorBlockKind::kMaterializedInScratch,
-                                     m_data, m_dimensions, !m_strided_storage);
-    }
-
-   private:
-    friend class TensorMaterializedBlock<Scalar, NumDims, Layout, IndexType>;
-
-    Storage(Scalar* data, const Dimensions& dimensions, const Dimensions& strides, bool materialized_in_output,
-            bool strided_storage)
-        : m_data(data),
-          m_dimensions(dimensions),
-          m_strides(strides),
-          m_materialized_in_output(materialized_in_output),
-          m_strided_storage(strided_storage) {}
-
-    Scalar* m_data;
-    Dimensions m_dimensions;
-    Dimensions m_strides;
-    bool m_materialized_in_output;
-    bool m_strided_storage;
-  };
-
-  // Creates a storage for materialized block either from the block descriptor
-  // destination buffer, or allocates a new buffer with scratch allocator.
-  template <typename TensorBlockScratch>
-  EIGEN_STRONG_INLINE static Storage prepareStorage(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                    bool allow_strided_storage = false) {
-    // Try to reuse destination as an output block buffer.
-    typedef typename TensorBlockDesc::DestinationBuffer DestinationBuffer;
-
-    if (desc.destination().kind() == DestinationBuffer::kContiguous) {
-      Scalar* buffer = desc.destination().template data<Scalar>();
-      desc.DropDestinationBuffer();
-      return Storage(buffer, desc.dimensions(), internal::strides<Layout>(desc.dimensions()),
-                     /*materialized_in_output=*/true,
-                     /*strided_storage=*/false);
-
-    } else if (desc.destination().kind() == DestinationBuffer::kStrided && allow_strided_storage) {
-      Scalar* buffer = desc.destination().template data<Scalar>();
-      desc.DropDestinationBuffer();
-      return Storage(buffer, desc.dimensions(), desc.destination().strides(),
-                     /*materialized_in_output=*/true, /*strided_storage=*/true);
-
-    } else {
-      void* mem = scratch.allocate(desc.size() * sizeof(Scalar));
-      return Storage(static_cast<Scalar*>(mem), desc.dimensions(), internal::strides<Layout>(desc.dimensions()),
-                     /*materialized_in_output=*/false,
-                     /*strided_storage=*/false);
-    }
-  }
-
-  // Creates a materialized block for the given descriptor from a memory buffer.
-  template <typename DataDimensions, typename TensorBlockScratch>
-  EIGEN_STRONG_INLINE static TensorMaterializedBlock materialize(const Scalar* data, const DataDimensions& data_dims,
-                                                                 TensorBlockDesc& desc, TensorBlockScratch& scratch) {
-    eigen_assert(array_size<DataDimensions>::value == desc.dimensions().size());
-
-    // If a tensor block dimensions covers a contiguous block of the underlying
-    // memory, we can skip block buffer memory allocation, and construct a block
-    // from existing `data` memory buffer.
-    //
-    // Example: (RowMajor layout)
-    //   data_dims:          [11, 12, 13, 14]
-    //   desc.dimensions():  [1,   1,  3, 14]
-    //
-    // In this case we can construct a TensorBlock starting at
-    // `data + desc.offset()`, with a `desc.dimensions()` block sizes.
-    static const bool is_col_major = Layout == ColMajor;
-
-    // Find out how many inner dimensions have a matching size.
-    int num_matching_inner_dims = 0;
-    for (int i = 0; i < NumDims; ++i) {
-      int dim = is_col_major ? i : NumDims - i - 1;
-      if (data_dims[dim] != desc.dimensions()[dim]) break;
-      ++num_matching_inner_dims;
-    }
-
-    // All the outer dimensions must be of size `1`, except a single dimension
-    // before the matching inner dimension (`3` in the example above).
-    bool can_use_direct_access = true;
-    for (int i = num_matching_inner_dims + 1; i < NumDims; ++i) {
-      int dim = is_col_major ? i : NumDims - i - 1;
-      if (desc.dimension(dim) != 1) {
-        can_use_direct_access = false;
-        break;
-      }
-    }
-
-    if (can_use_direct_access) {
-      const Scalar* block_start = data + desc.offset();
-      return TensorMaterializedBlock(internal::TensorBlockKind::kView, block_start, desc.dimensions());
-
-    } else {
-      // Reuse destination buffer or allocate new buffer with scratch allocator.
-      const Storage storage = prepareStorage(desc, scratch);
-
-      typedef internal::TensorBlockIO<Scalar, IndexType, NumDims, Layout> TensorBlockIO;
-      typedef typename TensorBlockIO::Dst TensorBlockIODst;
-      typedef typename TensorBlockIO::Src TensorBlockIOSrc;
-
-      TensorBlockIOSrc src(internal::strides<Layout>(Dimensions(data_dims)), data, desc.offset());
-      TensorBlockIODst dst(storage.dimensions(), storage.strides(), storage.data());
-
-      TensorBlockIO::Copy(dst, src);
-      return storage.AsTensorMaterializedBlock();
-    }
-  }
-
- private:
-  TensorBlockKind m_kind;
-  const Scalar* m_data;
-  Dimensions m_dimensions;
-  XprType m_expr;
-  bool m_valid_expr;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorCwiseUnaryBlock is a lazy tensor expression block that applies UnaryOp
-// functor to the blocks produced by the underlying Tensor expression.
-
-template <typename UnaryOp, typename ArgTensorBlock>
-class TensorCwiseUnaryBlock {
-  static constexpr bool NoArgBlockAccess = internal::is_void<typename ArgTensorBlock::XprType>::value;
-
- public:
-  typedef std::conditional_t<NoArgBlockAccess, void,
-                             TensorCwiseUnaryOp<UnaryOp, const typename ArgTensorBlock::XprType> >
-      XprType;
-
-  typedef typename XprScalar<XprType>::type Scalar;
-
-  TensorCwiseUnaryBlock(const ArgTensorBlock& arg_block, const UnaryOp& functor)
-      : m_arg_block(arg_block), m_functor(functor) {}
-
-  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
-
-  XprType expr() const { return XprType(m_arg_block.expr(), m_functor); }
-  const Scalar* data() const { return NULL; }
-  void cleanup() { m_arg_block.cleanup(); }
-
- private:
-  ArgTensorBlock m_arg_block;
-  UnaryOp m_functor;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorCwiseBinaryBlock is a lazy tensor expression block that applies BinaryOp
-// functor to the blocks produced by the underlying Tensor expression.
-
-template <typename BinaryOp, typename LhsTensorBlock, typename RhsTensorBlock>
-class TensorCwiseBinaryBlock {
-  static constexpr bool NoArgBlockAccess = internal::is_void<typename LhsTensorBlock::XprType>::value ||
-                                           internal::is_void<typename RhsTensorBlock::XprType>::value;
-
- public:
-  typedef std::conditional_t<
-      NoArgBlockAccess, void,
-      TensorCwiseBinaryOp<BinaryOp, const typename LhsTensorBlock::XprType, const typename RhsTensorBlock::XprType> >
-      XprType;
-
-  typedef typename XprScalar<XprType>::type Scalar;
-
-  TensorCwiseBinaryBlock(const LhsTensorBlock& left_block, const RhsTensorBlock& right_block, const BinaryOp& functor)
-      : m_left_block(left_block), m_right_block(right_block), m_functor(functor) {}
-
-  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
-
-  XprType expr() const { return XprType(m_left_block.expr(), m_right_block.expr(), m_functor); }
-
-  const Scalar* data() const { return NULL; }
-
-  void cleanup() {
-    m_left_block.cleanup();
-    m_right_block.cleanup();
-  }
-
- private:
-  LhsTensorBlock m_left_block;
-  RhsTensorBlock m_right_block;
-  BinaryOp m_functor;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorUnaryExprBlock is a lazy tensor expression block that can construct
-// an arbitrary tensor expression from a block of the underlying type (this is a
-// generalization of the TensorCwiseUnaryBlock for arbitrary expressions).
-
-template <typename BlockFactory, typename ArgTensorBlock>
-class TensorUnaryExprBlock {
-  typedef typename ArgTensorBlock::XprType ArgXprType;
-  static constexpr bool NoArgBlockAccess = internal::is_void<ArgXprType>::value;
-
- public:
-  typedef std::conditional_t<NoArgBlockAccess, void, typename BlockFactory::template XprType<ArgXprType>::type> XprType;
-
-  typedef typename XprScalar<XprType>::type Scalar;
-
-  TensorUnaryExprBlock(const ArgTensorBlock& arg_block, const BlockFactory& factory)
-      : m_arg_block(arg_block), m_factory(factory) {}
-
-  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
-  XprType expr() const { return m_factory.expr(m_arg_block.expr()); }
-  const Scalar* data() const { return NULL; }
-  void cleanup() { m_arg_block.cleanup(); }
-
- private:
-  ArgTensorBlock m_arg_block;
-  BlockFactory m_factory;
-};
-
-// -------------------------------------------------------------------------- //
-// TensorTernaryExprBlock is a lazy tensor expression block that can construct
-// an arbitrary tensor expression from three blocks of the underlying type.
-
-template <typename BlockFactory, typename Arg1TensorBlock, typename Arg2TensorBlock, typename Arg3TensorBlock>
-class TensorTernaryExprBlock {
-  typedef typename Arg1TensorBlock::XprType Arg1XprType;
-  typedef typename Arg2TensorBlock::XprType Arg2XprType;
-  typedef typename Arg3TensorBlock::XprType Arg3XprType;
-
-  static constexpr bool NoArgBlockAccess = internal::is_void<Arg1XprType>::value ||
-                                           internal::is_void<Arg2XprType>::value ||
-                                           internal::is_void<Arg3XprType>::value;
-
- public:
-  typedef std::conditional_t<NoArgBlockAccess, void,
-                             typename BlockFactory::template XprType<Arg1XprType, Arg2XprType, Arg3XprType>::type>
-      XprType;
-
-  typedef typename XprScalar<XprType>::type Scalar;
-
-  TensorTernaryExprBlock(const Arg1TensorBlock& arg1_block, const Arg2TensorBlock& arg2_block,
-                         const Arg3TensorBlock& arg3_block, const BlockFactory& factory)
-      : m_arg1_block(arg1_block), m_arg2_block(arg2_block), m_arg3_block(arg3_block), m_factory(factory) {}
-
-  TensorBlockKind kind() const { return internal::TensorBlockKind::kExpr; }
-  XprType expr() const { return m_factory.expr(m_arg1_block.expr(), m_arg2_block.expr(), m_arg3_block.expr()); }
-  const Scalar* data() const { return NULL; }
-  void cleanup() {
-    m_arg1_block.cleanup();
-    m_arg2_block.cleanup();
-    m_arg3_block.cleanup();
-  }
-
- private:
-  Arg1TensorBlock m_arg1_block;
-  Arg2TensorBlock m_arg2_block;
-  Arg3TensorBlock m_arg3_block;
-  BlockFactory m_factory;
-};
-
-// -------------------------------------------------------------------------- //
-// StridedLinearBufferCopy provides a method to copy data between two linear
-// buffers with different strides, with optimized paths for scatter/gather.
-
-template <typename Scalar, typename IndexType>
-class StridedLinearBufferCopy {
-  typedef typename packet_traits<Scalar>::type Packet;
-  typedef typename unpacket_traits<Packet>::half HalfPacket;
-  enum {
-    Vectorizable = packet_traits<Scalar>::Vectorizable,
-    PacketSize = packet_traits<Scalar>::size,
-    HalfPacketSize = unpacket_traits<HalfPacket>::size,
-    HasHalfPacket = static_cast<int>(HalfPacketSize) < static_cast<int>(PacketSize)
-  };
-
- public:
-  // Specifying linear copy kind statically gives ~30% speedup for small sizes.
-  enum class Kind {
-    Linear = 0,       // src_stride == 1 && dst_stride == 1
-    Scatter = 1,      // src_stride == 1 && dst_stride != 1
-    FillLinear = 2,   // src_stride == 0 && dst_stride == 1
-    FillScatter = 3,  // src_stride == 0 && dst_stride != 1
-    Gather = 4,       // dst_stride == 1
-    Random = 5        // everything else
-  };
-
-  struct Dst {
-    Dst(IndexType o, IndexType s, Scalar* d) : offset(o), stride(s), data(d) {}
-
-    IndexType offset;
-    IndexType stride;
-    Scalar* data;
-  };
-
-  struct Src {
-    Src(IndexType o, IndexType s, const Scalar* d) : offset(o), stride(s), data(d) {}
-
-    IndexType offset;
-    IndexType stride;
-    const Scalar* data;
-  };
-
-  template <typename StridedLinearBufferCopy::Kind kind>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Dst& dst, const Src& src, const size_t count) {
-    Run<kind>(count, dst.offset, dst.stride, dst.data, src.offset, src.stride, src.data);
-  }
-
- private:
-  template <typename StridedLinearBufferCopy::Kind kind>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const IndexType count, const IndexType dst_offset,
-                                                        const IndexType dst_stride, Scalar* EIGEN_RESTRICT dst_data,
-                                                        const IndexType src_offset, const IndexType src_stride,
-                                                        const Scalar* EIGEN_RESTRICT src_data) {
-    const Scalar* src = &src_data[src_offset];
-    Scalar* dst = &dst_data[dst_offset];
-
-    if (!Vectorizable) {
-      for (Index i = 0; i < count; ++i) {
-        dst[i * dst_stride] = src[i * src_stride];
-      }
-      return;
-    }
-
-    const IndexType vectorized_size = PacketSize * (count / PacketSize);
-    IndexType i = 0;
-
-    if (kind == StridedLinearBufferCopy::Kind::Linear) {
-      // ******************************************************************** //
-      // Linear copy from `src` to `dst`.
-      const IndexType unrolled_size = (4 * PacketSize) * (count / (4 * PacketSize));
-      eigen_assert(src_stride == 1 && dst_stride == 1);
-      for (; i < unrolled_size; i += 4 * PacketSize) {
-        for (int j = 0; j < 4; ++j) {
-          Packet p = ploadu<Packet>(src + i + j * PacketSize);
-          pstoreu<Scalar, Packet>(dst + i + j * PacketSize, p);
-        }
-      }
-      for (; i < vectorized_size; i += PacketSize) {
-        Packet p = ploadu<Packet>(src + i);
-        pstoreu<Scalar, Packet>(dst + i, p);
-      }
-      if (HasHalfPacket) {
-        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
-        if (i < vectorized_half_size) {
-          HalfPacket p = ploadu<HalfPacket>(src + i);
-          pstoreu<Scalar, HalfPacket>(dst + i, p);
-          i += HalfPacketSize;
-        }
-      }
-      for (; i < count; ++i) {
-        dst[i] = src[i];
-      }
-      // ******************************************************************** //
-    } else if (kind == StridedLinearBufferCopy::Kind::Scatter) {
-      // Scatter from `src` to `dst`.
-      eigen_assert(src_stride == 1 && dst_stride != 1);
-      for (; i < vectorized_size; i += PacketSize) {
-        Packet p = ploadu<Packet>(src + i);
-        pscatter<Scalar, Packet>(dst + i * dst_stride, p, dst_stride);
-      }
-      if (HasHalfPacket) {
-        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
-        if (i < vectorized_half_size) {
-          HalfPacket p = ploadu<HalfPacket>(src + i);
-          pscatter<Scalar, HalfPacket>(dst + i * dst_stride, p, dst_stride);
-          i += HalfPacketSize;
-        }
-      }
-      for (; i < count; ++i) {
-        dst[i * dst_stride] = src[i];
-      }
-      // ******************************************************************** //
-    } else if (kind == StridedLinearBufferCopy::Kind::FillLinear) {
-      // Fill `dst` with value at `*src`.
-      eigen_assert(src_stride == 0 && dst_stride == 1);
-
-      const IndexType unrolled_size = (4 * PacketSize) * (count / (4 * PacketSize));
-      Scalar s = *src;
-      Packet p = pset1<Packet>(s);
-      for (; i < unrolled_size; i += 4 * PacketSize) {
-        for (int j = 0; j < 4; ++j) {
-          pstoreu<Scalar, Packet>(dst + i + j * PacketSize, p);
-        }
-      }
-      for (; i < vectorized_size; i += PacketSize) {
-        pstoreu<Scalar, Packet>(dst + i, p);
-      }
-      if (HasHalfPacket) {
-        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
-        if (i < vectorized_half_size) {
-          HalfPacket hp = pset1<HalfPacket>(s);
-          pstoreu<Scalar, HalfPacket>(dst + i, hp);
-          i += HalfPacketSize;
-        }
-      }
-      for (; i < count; ++i) {
-        dst[i] = s;
-      }
-      // ******************************************************************** //
-    } else if (kind == StridedLinearBufferCopy::Kind::FillScatter) {
-      // Scatter `*src` into `dst`.
-      eigen_assert(src_stride == 0 && dst_stride != 1);
-      Scalar s = *src;
-      Packet p = pset1<Packet>(s);
-      for (; i < vectorized_size; i += PacketSize) {
-        pscatter<Scalar, Packet>(dst + i * dst_stride, p, dst_stride);
-      }
-      if (HasHalfPacket) {
-        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
-        if (i < vectorized_half_size) {
-          HalfPacket hp = pset1<HalfPacket>(s);
-          pscatter<Scalar, HalfPacket>(dst + i * dst_stride, hp, dst_stride);
-          i += HalfPacketSize;
-        }
-      }
-      for (; i < count; ++i) {
-        dst[i * dst_stride] = s;
-      }
-      // ******************************************************************** //
-    } else if (kind == StridedLinearBufferCopy::Kind::Gather) {
-      // Gather from `src` into `dst`.
-      eigen_assert(dst_stride == 1);
-      for (; i < vectorized_size; i += PacketSize) {
-        Packet p = pgather<Scalar, Packet>(src + i * src_stride, src_stride);
-        pstoreu<Scalar, Packet>(dst + i, p);
-      }
-      if (HasHalfPacket) {
-        const IndexType vectorized_half_size = HalfPacketSize * (count / HalfPacketSize);
-        if (i < vectorized_half_size) {
-          HalfPacket p = pgather<Scalar, HalfPacket>(src + i * src_stride, src_stride);
-          pstoreu<Scalar, HalfPacket>(dst + i, p);
-          i += HalfPacketSize;
-        }
-      }
-      for (; i < count; ++i) {
-        dst[i] = src[i * src_stride];
-      }
-      // ******************************************************************** //
-    } else if (kind == StridedLinearBufferCopy::Kind::Random) {
-      // Random.
-      for (; i < count; ++i) {
-        dst[i * dst_stride] = src[i * src_stride];
-      }
-    } else {
-      eigen_assert(false);
-    }
-  }
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockIO copies data from `src` tensor block, to the `dst` tensor block.
-// It's possible to specify src->dst dimension mapping for the copy operation.
-// Dimensions of `dst` specify how many elements have to be copied, for the
-// `src` we need to know only stride to navigate through source memory buffer.
-
-template <typename Scalar, typename IndexType, int NumDims, int Layout>
-class TensorBlockIO {
-  static constexpr bool IsColMajor = (Layout == ColMajor);
-
-  typedef StridedLinearBufferCopy<Scalar, IndexType> LinCopy;
-
- public:
-  typedef DSizes<IndexType, NumDims> Dimensions;
-  typedef DSizes<int, NumDims> DimensionsMap;
-
-  struct Dst {
-    Dst(const Dimensions& dst_dims, const Dimensions& dst_strides, Scalar* dst, IndexType dst_offset = 0)
-        : dims(dst_dims), strides(dst_strides), data(dst), offset(dst_offset) {}
-
-    Dimensions dims;
-    Dimensions strides;
-    Scalar* data;
-    IndexType offset;
-  };
-
-  struct Src {
-    Src(const Dimensions& src_strides, const Scalar* src, IndexType src_offset = 0)
-        : strides(src_strides), data(src), offset(src_offset) {}
-
-    Dimensions strides;
-    const Scalar* data;
-    IndexType offset;
-  };
-
-  // Copies data to `dst` from `src`, using provided dimensions mapping:
-  //
-  //   src_dimension_index = dst_to_src_dim_map[dst_dimension_index]
-  //
-  // Returns the number of copied elements.
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType Copy(const Dst& dst, const Src& src,
-                                                              const DimensionsMap& dst_to_src_dim_map) {
-    // Copy single scalar value from `src` to `dst`.
-    if (NumDims == 0) {
-      *(dst.data + dst.offset) = *(src.data + src.offset);
-      return 1;
-    }
-
-    // Both `dst` and `src` must have contiguous innermost dimension. We also
-    // accept the special case with stride '0', because it's used as a trick to
-    // implement broadcasting.
-    {
-      int inner_dim = IsColMajor ? 0 : NumDims - 1;
-      EIGEN_UNUSED_VARIABLE(inner_dim);
-      eigen_assert(dst.strides[inner_dim] == 1 || dst.strides[inner_dim] == 0);
-      eigen_assert(src.strides[inner_dim] == 1 || src.strides[inner_dim] == 0);
-    }
-
-    // Give a shorter name to `dst_to_src_dim_map`.
-    const DimensionsMap& dim_map = dst_to_src_dim_map;
-
-    // Do not squeeze reordered inner dimensions.
-    int num_squeezable_dims = NumSqueezableInnerDims(dim_map);
-
-    // NOTE: We find the innermost dimension (contiguous in memory) in the dst
-    // block, and we write data linearly into that dimension, reading it from
-    // the src. If dimensions are reordered, we might end up reading data from
-    // the src with `stride != 1`.
-    //
-    // NOTE: Random-Read/Linear-Write can be up to ~2X faster than
-    // Linear-Read/Random-Write: https://stackoverflow.com/a/54935680
-
-    // Find the innermost dimension in the dst whose size is not 1. This is the
-    // effective inner dim.
-    int num_size_one_inner_dims = 0;
-    for (int i = 0; i < num_squeezable_dims; ++i) {
-      const int dst_dim = IsColMajor ? i : NumDims - i - 1;
-      if (dst.dims[dst_dim] != 1) break;
-      num_size_one_inner_dims++;
-    }
-
-    // If all dimensions are of size 1, just copy a scalar from `src` to `dst`.
-    if (num_size_one_inner_dims == NumDims) {
-      *(dst.data + dst.offset) = *(src.data + src.offset);
-      return 1;
-    }
-
-    // Outermost dimension in the dst with `stride == 1` (contiguous in memory).
-    const int dst_stride1_dim = IsColMajor ? num_size_one_inner_dims : NumDims - num_size_one_inner_dims - 1;
-
-    // Dimension in the src that corresponds to the dst innermost dimension.
-    const int src_dim_for_dst_stride1_dim = NumDims == 0 ? 1 : dim_map[dst_stride1_dim];
-
-    // Size of the innermost dimension (length of contiguous blocks of memory).
-    IndexType dst_inner_dim_size = NumDims == 0 ? 1 : dst.dims[dst_stride1_dim];
-
-    // Squeeze multiple inner dims into one if they are contiguous in `dst` and
-    // `src` memory, so we can do less linear copy calls.
-    for (int i = num_size_one_inner_dims + 1; i < num_squeezable_dims; ++i) {
-      const int dst_dim = IsColMajor ? i : NumDims - i - 1;
-      const IndexType dst_stride = dst.strides[dst_dim];
-      const IndexType src_stride = src.strides[dim_map[dst_dim]];
-      if (dst_inner_dim_size == dst_stride && dst_stride == src_stride) {
-        dst_inner_dim_size *= dst.dims[dst_dim];
-        ++num_size_one_inner_dims;
-      } else {
-        break;
-      }
-    }
-
-    // Setup strides to read data from `src` and write to `dst`.
-    IndexType input_offset = src.offset;
-    IndexType output_offset = dst.offset;
-    IndexType input_stride = NumDims == 0 ? 1 : src.strides[src_dim_for_dst_stride1_dim];
-    IndexType output_stride = NumDims == 0 ? 1 : dst.strides[dst_stride1_dim];
-
-    const int at_least_1_dim = NumDims <= 1 ? 1 : NumDims - 1;
-    array<BlockIteratorState, at_least_1_dim> it;
-
-    // Initialize block iterator state. Squeeze away any dimension of size 1.
-    int idx = 0;  // currently initialized iterator state index
-    for (int i = num_size_one_inner_dims; i < NumDims - 1; ++i) {
-      const int dst_dim = IsColMajor ? i + 1 : NumDims - i - 2;
-      if (dst.dims[dst_dim] == 1) continue;
-
-      it[idx].size = dst.dims[dst_dim];
-      it[idx].input_stride = src.strides[dim_map[dst_dim]];
-      it[idx].output_stride = dst.strides[dst_dim];
-
-      it[idx].input_span = it[idx].input_stride * (it[idx].size - 1);
-      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
-
-      idx++;
-    }
-
-    // Iterate copying data from src to dst.
-    const IndexType block_total_size = NumDims == 0 ? 1 : dst.dims.TotalSize();
-
-#define COPY_INNER_DIM(KIND)                                                                                      \
-  IndexType num_copied = 0;                                                                                       \
-  for (num_copied = 0; num_copied < block_total_size; num_copied += dst_inner_dim_size) {                         \
-    LinCopy::template Run<KIND>(typename LinCopy::Dst(output_offset, output_stride, dst.data),                    \
-                                typename LinCopy::Src(input_offset, input_stride, src.data), dst_inner_dim_size); \
-                                                                                                                  \
-    for (int j = 0; j < idx; ++j) {                                                                               \
-      if (++it[j].count < it[j].size) {                                                                           \
-        input_offset += it[j].input_stride;                                                                       \
-        output_offset += it[j].output_stride;                                                                     \
-        break;                                                                                                    \
-      }                                                                                                           \
-      it[j].count = 0;                                                                                            \
-      input_offset -= it[j].input_span;                                                                           \
-      output_offset -= it[j].output_span;                                                                         \
-    }                                                                                                             \
-  }                                                                                                               \
-  return num_copied;
-
-    if (input_stride == 1 && output_stride == 1) {
-      COPY_INNER_DIM(LinCopy::Kind::Linear);
-    } else if (input_stride == 1 && output_stride != 1) {
-      COPY_INNER_DIM(LinCopy::Kind::Scatter);
-    } else if (input_stride == 0 && output_stride == 1) {
-      COPY_INNER_DIM(LinCopy::Kind::FillLinear);
-    } else if (input_stride == 0 && output_stride != 1) {
-      COPY_INNER_DIM(LinCopy::Kind::FillScatter);
-    } else if (output_stride == 1) {
-      COPY_INNER_DIM(LinCopy::Kind::Gather);
-    } else {
-      COPY_INNER_DIM(LinCopy::Kind::Random);
-    }
-
-#undef COPY_INNER_DIM
-  }
-
-  // Copy from `src` to `dst` with an identity src->dst dimension map. Returns
-  // the number of copied elements.
-  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexType Copy(const Dst& dst, const Src& src) {
-    DimensionsMap dst_to_src_map;
-    for (int i = 0; i < NumDims; ++i) dst_to_src_map[i] = i;
-    return Copy(dst, src, dst_to_src_map);
-  }
-
- private:
-  struct BlockIteratorState {
-    BlockIteratorState() : size(0), count(0), input_stride(0), output_stride(0), input_span(0), output_span(0) {}
-
-    IndexType size;
-    IndexType count;
-    IndexType input_stride;
-    IndexType output_stride;
-    IndexType input_span;
-    IndexType output_span;
-  };
-
-  // Compute how many inner dimensions it's allowed to squeeze when doing IO
-  // between two tensor blocks. It's safe to squeeze inner dimensions, only
-  // if they are not reordered.
-  static int NumSqueezableInnerDims(const DimensionsMap& dim_map) {
-    int num_squeezable_dims = 0;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      if (dim_map[dim] != dim) break;
-      num_squeezable_dims++;
-    }
-    return num_squeezable_dims;
-  }
-};
-
-// -------------------------------------------------------------------------- //
-// TensorBlockAssignment assigns a block expression of type `TensorBlockExpr` to
-// a Tensor block defined by `desc`, backed by a memory buffer at `target`.
-//
-// Currently there is no way to write from a Tensor expression to a block of
-// memory, if dimensions are reordered. If you need to do that, you should
-// materialize a Tensor block expression into a memory buffer, and then use
-// TensorBlockIO to copy data between two memory buffers with a custom
-// `target->src` dimension map (see definition above).
-//
-// Also currently the innermost dimension of `target` must have a stride '1'
-// (contiguous in memory). This restriction could be lifted with a `pscatter`,
-// but in practice it's never needed, and there is a similar TensorBlockIO
-// workaround for that.
-//
-// TODO(ezhulenev): TensorBlockAssignment is a special case of TensorBlockIO
-// where `src` is a tensor expression. Explore if it is possible to rewrite IO
-// to use expressions instead of pointers, and after that TensorBlockAssignment
-// will become an alias to IO.
-template <typename Scalar, int NumDims, typename TensorBlockExpr, typename IndexType = Eigen::Index>
-class TensorBlockAssignment {
-  // We will use coeff/packet path to evaluate block expressions.
-  typedef TensorEvaluator<const TensorBlockExpr, DefaultDevice> TensorBlockEvaluator;
-
-  typedef DSizes<IndexType, NumDims> Dimensions;
-
-  enum { Vectorizable = packet_traits<Scalar>::Vectorizable, PacketSize = packet_traits<Scalar>::size };
-
-  template <bool Vectorizable, typename Evaluator>
-  struct InnerDimAssign {
-    EIGEN_ALWAYS_INLINE static void Run(Scalar* target, IndexType count, const Evaluator& eval, IndexType eval_offset) {
-      for (IndexType i = 0; i < count; ++i) {
-        target[i] = eval.coeff(eval_offset + i);
-      }
-    }
-  };
-
-  template <typename Evaluator>
-  struct InnerDimAssign<true, Evaluator> {
-    EIGEN_ALWAYS_INLINE static void Run(Scalar* target, IndexType count, const Evaluator& eval, IndexType eval_offset) {
-      typedef typename packet_traits<Scalar>::type Packet;
-
-      const IndexType unrolled_size = (4 * PacketSize) * (count / (4 * PacketSize));
-      const IndexType vectorized_size = PacketSize * (count / PacketSize);
-      IndexType i = 0;
-
-      for (; i < unrolled_size; i += 4 * PacketSize) {
-        for (int j = 0; j < 4; ++j) {
-          const IndexType idx = eval_offset + i + j * PacketSize;
-          Packet p = eval.template packet<Unaligned>(idx);
-          pstoreu<Scalar>(target + i + j * PacketSize, p);
-        }
-      }
-
-      for (; i < vectorized_size; i += PacketSize) {
-        Packet p = eval.template packet<Unaligned>(eval_offset + i);
-        pstoreu<Scalar>(target + i, p);
-      }
-
-      for (; i < count; ++i) {
-        target[i] = eval.coeff(eval_offset + i);
-      }
-    }
-  };
-
- public:
-  struct Target {
-    Target(const Dimensions& target_dims, const Dimensions& target_strides, Scalar* target_data,
-           IndexType target_offset = 0)
-        : dims(target_dims), strides(target_strides), data(target_data), offset(target_offset) {}
-
-    Dimensions dims;
-    Dimensions strides;
-    Scalar* data;
-    IndexType offset;
-  };
-
-  static Target target(const Dimensions& target_dims, const Dimensions& target_strides, Scalar* target_data,
-                       IndexType target_offset = 0) {
-    return Target(target_dims, target_strides, target_data, target_offset);
-  }
-
-  template <typename TargetDimsIndexType, typename TargetStridesIndexType>
-  static Target target(const DSizes<TargetDimsIndexType, NumDims>& target_dims,
-                       const DSizes<TargetStridesIndexType, NumDims>& target_strides, Scalar* target_data,
-                       IndexType target_offset = 0) {
-    // DSizes constructor will do index type promotion if it's safe.
-    return Target(Dimensions(target_dims), Dimensions(target_strides), target_data, target_offset);
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Target& target, const TensorBlockExpr& expr) {
-    // Prepare evaluator for block expression.
-    DefaultDevice default_device;
-    TensorBlockEvaluator eval(expr, default_device);
-
-    // Tensor block expression dimension should match destination dimensions.
-    eigen_assert(dimensions_match(target.dims, eval.dimensions()));
-
-    static const int Layout = TensorBlockEvaluator::Layout;
-    static const bool is_col_major = Layout == ColMajor;
-
-    // Initialize output inner dimension size based on a layout.
-    const IndexType output_size = NumDims == 0 ? 1 : target.dims.TotalSize();
-    const int inner_dim_idx = is_col_major ? 0 : NumDims - 1;
-    IndexType output_inner_dim_size = target.dims[inner_dim_idx];
-
-    // Target inner dimension stride must be '1'.
-    eigen_assert(target.strides[inner_dim_idx] == 1);
-
-    // Squeeze multiple inner dims into one if they are contiguous in `target`.
-    IndexType num_squeezed_dims = 0;
-    for (Index i = 1; i < NumDims; ++i) {
-      const Index dim = is_col_major ? i : NumDims - i - 1;
-      const IndexType target_stride = target.strides[dim];
-
-      if (output_inner_dim_size == target_stride) {
-        output_inner_dim_size *= target.dims[dim];
-        num_squeezed_dims++;
-      } else {
-        break;
-      }
-    }
-
-    // Initialize output block iterator state. Dimension in this array are
-    // always in inner_most -> outer_most order (col major layout).
-    array<BlockIteratorState, NumDims> it;
-
-    int idx = 0;  // currently initialized iterator state index
-    for (Index i = num_squeezed_dims; i < NumDims - 1; ++i) {
-      const Index dim = is_col_major ? i + 1 : NumDims - i - 2;
-
-      it[idx].count = 0;
-      it[idx].size = target.dims[dim];
-      it[idx].output_stride = target.strides[dim];
-      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
-      idx++;
-    }
-
-    // We read block expression from the beginning, and start writing data to
-    // `target` at given offset.
-    IndexType input_offset = 0;
-    IndexType output_offset = target.offset;
-
-    // Iterate copying data from `eval` to `target`.
-    for (IndexType i = 0; i < output_size; i += output_inner_dim_size) {
-      // Assign to `target` at current offset.
-      InnerDimAssign<Vectorizable && TensorBlockEvaluator::PacketAccess, TensorBlockEvaluator>::Run(
-          target.data + output_offset, output_inner_dim_size, eval, input_offset);
-
-      // Move input offset forward by the number of assigned coefficients.
-      input_offset += output_inner_dim_size;
-
-      // Update index.
-      for (int j = 0; j < idx; ++j) {
-        if (++it[j].count < it[j].size) {
-          output_offset += it[j].output_stride;
-          break;
-        }
-        it[j].count = 0;
-        output_offset -= it[j].output_span;
-      }
-    }
-  }
-
- private:
-  struct BlockIteratorState {
-    BlockIteratorState() : count(0), size(0), output_stride(0), output_span(0) {}
-
-    IndexType count;
-    IndexType size;
-    IndexType output_stride;
-    IndexType output_span;
-  };
-};
-
-// -------------------------------------------------------------------------- //
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_BLOCK_H
diff --git a/unsupported/Eigen/src/Tensor/TensorBroadcasting.h b/unsupported/Eigen/src/Tensor/TensorBroadcasting.h
deleted file mode 100644
index 799e513..0000000
--- a/unsupported/Eigen/src/Tensor/TensorBroadcasting.h
+++ /dev/null
@@ -1,1001 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_BROADCASTING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_BROADCASTING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Broadcast, typename XprType>
-struct traits<TensorBroadcastingOp<Broadcast, XprType>> : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-  enum {
-    // Broadcast is read-only.
-    Flags = traits<XprType>::Flags & ~LvalueBit
-  };
-};
-
-template <typename Broadcast, typename XprType>
-struct eval<TensorBroadcastingOp<Broadcast, XprType>, Eigen::Dense> {
-  typedef const TensorBroadcastingOp<Broadcast, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename Broadcast, typename XprType>
-struct nested<TensorBroadcastingOp<Broadcast, XprType>, 1,
-              typename eval<TensorBroadcastingOp<Broadcast, XprType>>::type> {
-  typedef TensorBroadcastingOp<Broadcast, XprType> type;
-};
-
-template <typename Dims>
-struct is_input_scalar {
-  static const bool value = false;
-};
-template <>
-struct is_input_scalar<Sizes<>> {
-  static const bool value = true;
-};
-template <typename std::ptrdiff_t... Indices>
-struct is_input_scalar<Sizes<Indices...>> {
-  static constexpr bool value = (Sizes<Indices...>::total_size == 1);
-};
-
-}  // end namespace internal
-
-/** Tensor broadcasting class.
- * \ingroup CXX11_Tensor_Module
- */
-template <typename Broadcast, typename XprType>
-class TensorBroadcastingOp : public TensorBase<TensorBroadcastingOp<Broadcast, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorBroadcastingOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorBroadcastingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorBroadcastingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorBroadcastingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBroadcastingOp(const XprType& expr, const Broadcast& broadcast)
-      : m_xpr(expr), m_broadcast(broadcast) {}
-
-  EIGEN_DEVICE_FUNC const Broadcast& broadcast() const { return m_broadcast; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Broadcast m_broadcast;
-};
-
-// Eval as rvalue
-template <typename Broadcast, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorBroadcastingOp<Broadcast, ArgType>, Device> {
-  typedef TensorBroadcastingOp<Broadcast, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-
- protected:  //  all the non-static fields must have the same access control, otherwise the TensorEvaluator won't be
-             //  standard layout;
-  bool isCopy, nByOne, oneByN;
-
- public:
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
-    PreferBlockAccess = true,
-    RawAccess = false
-  };
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  // We do block based broadcasting using a trick with 2x tensor rank and 0
-  // strides. See block method implementation for details.
-  typedef DSizes<Index, 2 * NumDims> BroadcastDimensions;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : isCopy(false),
-        nByOne(false),
-        oneByN(false),
-        m_device(device),
-        m_broadcast(op.broadcast()),
-        m_impl(op.expression(), device) {
-    // The broadcasting op doesn't change the rank of the tensor. One can't broadcast a scalar
-    // and store the result in a scalar. Instead one should reshape the scalar into a N-D
-    // tensor with N >= 1 of 1 element first and then broadcast.
-    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    const InputDimensions& input_dims = m_impl.dimensions();
-    isCopy = true;
-    for (int i = 0; i < NumDims; ++i) {
-      eigen_assert(input_dims[i] > 0);
-      m_dimensions[i] = input_dims[i] * m_broadcast[i];
-      if (m_broadcast[i] != 1) {
-        isCopy = false;
-      }
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputStrides[0] = 1;
-      m_outputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
-        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-      }
-    } else {
-      m_inputStrides[NumDims - 1] = 1;
-      m_outputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
-        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-      }
-    }
-
-    if (input_dims[0] == 1) {
-      oneByN = true;
-      for (int i = 1; i < NumDims; ++i) {
-        if (m_broadcast[i] != 1) {
-          oneByN = false;
-          break;
-        }
-      }
-    } else if (input_dims[NumDims - 1] == 1) {
-      nByOne = true;
-      for (int i = 0; i < NumDims - 1; ++i) {
-        if (m_broadcast[i] != 1) {
-          nByOne = false;
-          break;
-        }
-      }
-    }
-
-    // Handle special format like NCHW, its input shape is '[1, N..., 1]' and
-    // broadcast shape is '[N, 1..., N]'
-    if (!oneByN && !nByOne) {
-      if (input_dims[0] == 1 && input_dims[NumDims - 1] == 1 && NumDims > 2) {
-        nByOne = true;
-        oneByN = true;
-        for (int i = 1; i < NumDims - 1; ++i) {
-          if (m_broadcast[i] != 1) {
-            nByOne = false;
-            oneByN = false;
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffReturnType coeff(Index index) const {
-    if (internal::is_input_scalar<internal::remove_all_t<InputDimensions>>::value) {
-      return m_impl.coeff(0);
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      if (isCopy) {
-        return m_impl.coeff(index);
-      } else {
-        return coeffColMajor(index);
-      }
-    } else {
-      if (isCopy) {
-        return m_impl.coeff(index);
-      } else {
-        return coeffRowMajor(index);
-      }
-    }
-  }
-
-  // TODO: attempt to speed this up. The integer divisions and modulo are slow
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index indexColMajor(Index index) const {
-    Index inputIndex = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = NumDims - 1; i > 0; --i) {
-      const Index idx = index / m_outputStrides[i];
-      if (internal::index_statically_eq<Broadcast>(i, 1)) {
-        eigen_assert(idx < m_impl.dimensions()[i]);
-        inputIndex += idx * m_inputStrides[i];
-      } else {
-        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
-          eigen_assert(idx % m_impl.dimensions()[i] == 0);
-        } else {
-          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
-        }
-      }
-      index -= idx * m_outputStrides[i];
-    }
-    if (internal::index_statically_eq<Broadcast>(0, 1)) {
-      eigen_assert(index < m_impl.dimensions()[0]);
-      inputIndex += index;
-    } else {
-      if (internal::index_statically_eq<InputDimensions>(0, 1)) {
-        eigen_assert(index % m_impl.dimensions()[0] == 0);
-      } else {
-        inputIndex += (index % m_impl.dimensions()[0]);
-      }
-    }
-    return inputIndex;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeffColMajor(Index index) const {
-    return m_impl.coeff(indexColMajor(index));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index indexRowMajor(Index index) const {
-    Index inputIndex = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const Index idx = index / m_outputStrides[i];
-      if (internal::index_statically_eq<Broadcast>(i, 1)) {
-        eigen_assert(idx < m_impl.dimensions()[i]);
-        inputIndex += idx * m_inputStrides[i];
-      } else {
-        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
-          eigen_assert(idx % m_impl.dimensions()[i] == 0);
-        } else {
-          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
-        }
-      }
-      index -= idx * m_outputStrides[i];
-    }
-    if (internal::index_statically_eq<Broadcast>(NumDims - 1, 1)) {
-      eigen_assert(index < m_impl.dimensions()[NumDims - 1]);
-      inputIndex += index;
-    } else {
-      if (internal::index_statically_eq<InputDimensions>(NumDims - 1, 1)) {
-        eigen_assert(index % m_impl.dimensions()[NumDims - 1] == 0);
-      } else {
-        inputIndex += (index % m_impl.dimensions()[NumDims - 1]);
-      }
-    }
-    return inputIndex;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeffRowMajor(Index index) const {
-    return m_impl.coeff(indexRowMajor(index));
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketReturnType packet(Index index) const {
-    if (internal::is_input_scalar<internal::remove_all_t<InputDimensions>>::value) {
-      return internal::pset1<PacketReturnType>(m_impl.coeff(0));
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      if (isCopy) {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-        // See PR 437: on NVIDIA P100 and K20m we observed a x3-4 speed up by enforcing
-        // unaligned loads here. The reason is unclear though.
-        return m_impl.template packet<Unaligned>(index);
-#else
-        return m_impl.template packet<LoadMode>(index);
-#endif
-      } else if (oneByN && !nByOne) {
-        return packetNByOne<LoadMode>(index);
-      } else if (!oneByN && nByOne) {
-        return packetOneByN<LoadMode>(index);
-      } else if (oneByN && nByOne) {
-        return packetOneByNByOne<LoadMode>(index);
-      } else {
-        return packetColMajor<LoadMode>(index);
-      }
-    } else {
-      if (isCopy) {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-        // See above.
-        return m_impl.template packet<Unaligned>(index);
-#else
-        return m_impl.template packet<LoadMode>(index);
-#endif
-      } else if (oneByN && !nByOne) {
-        return packetOneByN<LoadMode>(index);
-      } else if (!oneByN && nByOne) {
-        return packetNByOne<LoadMode>(index);
-      } else if (oneByN && nByOne) {
-        return packetOneByNByOne<LoadMode>(index);
-      } else {
-        return packetRowMajor<LoadMode>(index);
-      }
-    }
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetOneByNByOne(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    Index startDim, endDim;
-    Index inputIndex, outputOffset, batchedIndex;
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      startDim = NumDims - 1;
-      endDim = 1;
-    } else {
-      startDim = 0;
-      endDim = NumDims - 2;
-    }
-
-    batchedIndex = index % m_outputStrides[startDim];
-    inputIndex = batchedIndex / m_outputStrides[endDim];
-    outputOffset = batchedIndex % m_outputStrides[endDim];
-
-    if (outputOffset + PacketSize <= m_outputStrides[endDim]) {
-      values[0] = m_impl.coeff(inputIndex);
-      return internal::pload1<PacketReturnType>(values);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0, cur = 0; i < PacketSize; ++i, ++cur) {
-        if (outputOffset + cur < m_outputStrides[endDim]) {
-          values[i] = m_impl.coeff(inputIndex);
-        } else {
-          ++inputIndex;
-          inputIndex = (inputIndex == m_inputStrides[startDim] ? 0 : inputIndex);
-          values[i] = m_impl.coeff(inputIndex);
-          outputOffset = 0;
-          cur = 0;
-        }
-      }
-      return internal::pload<PacketReturnType>(values);
-    }
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetOneByN(Index index) const {
-    // Consider the flattened tensor [v0, ..., vN],
-    // Concatenates m_broadcast[dim] copies,
-    //    [v0, ..., vN, v0, ..., vN, ... ]
-    // with dim == NumDims - 1 for col-major, dim == 0 for row-major.
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    // Size of flattened tensor.
-    const Index M =
-        (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? m_inputStrides[NumDims - 1] : m_inputStrides[0];
-    Index inputIndex = index % M;
-    if (inputIndex + PacketSize <= M) {
-      return m_impl.template packet<Unaligned>(inputIndex);
-    } else {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < PacketSize; ++i) {
-        if (inputIndex > M - 1) {
-          inputIndex = 0;
-        }
-        values[i] = m_impl.coeff(inputIndex++);
-      }
-      return internal::pload<PacketReturnType>(values);
-    }
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetNByOne(Index index) const {
-    // Consider the flattened tensor [v0, ..., vN],
-    // Interleaves m_broadcast[dim] copies,
-    //    [v0, v0, ..., v1, v1, ..., vN, vN, ... ]
-    // with dim == 0 for col-major, dim == NumDims - 1 for row-major.
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    const Index M =
-        (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? m_broadcast[0] : m_broadcast[NumDims - 1];
-
-    Index inputIndex = index / M;
-    Index outputOffset = index % M;
-    if (outputOffset + PacketSize <= M) {
-      return internal::pset1<PacketReturnType>(m_impl.coeff(inputIndex));
-    } else {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < PacketSize; ++i) {
-        if (outputOffset < M) {
-          values[i] = m_impl.coeff(inputIndex);
-          ++outputOffset;
-        } else {
-          values[i] = m_impl.coeff(++inputIndex);
-          outputOffset = 1;  // Next offset.
-        }
-      }
-      return internal::pload<PacketReturnType>(values);
-    }
-  }
-
-  // Ignore the LoadMode and always use unaligned loads since we can't guarantee
-  // the alignment at compile time.
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetColMajor(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    const Index originalIndex = index;
-
-    Index inputIndex = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = NumDims - 1; i > 0; --i) {
-      const Index idx = index / m_outputStrides[i];
-      if (internal::index_statically_eq<Broadcast>(i, 1)) {
-        eigen_assert(idx < m_impl.dimensions()[i]);
-        inputIndex += idx * m_inputStrides[i];
-      } else {
-        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
-          eigen_assert(idx % m_impl.dimensions()[i] == 0);
-        } else {
-          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
-        }
-      }
-      index -= idx * m_outputStrides[i];
-    }
-    Index innermostLoc;
-    if (internal::index_statically_eq<Broadcast>(0, 1)) {
-      eigen_assert(index < m_impl.dimensions()[0]);
-      innermostLoc = index;
-    } else {
-      if (internal::index_statically_eq<InputDimensions>(0, 1)) {
-        eigen_assert(index % m_impl.dimensions()[0] == 0);
-        innermostLoc = 0;
-      } else {
-        innermostLoc = index % m_impl.dimensions()[0];
-      }
-    }
-    inputIndex += innermostLoc;
-
-    // TODO: This could be extended to the second dimension if we're not
-    // broadcasting alongside the first dimension, and so on.
-    if (innermostLoc + PacketSize <= m_impl.dimensions()[0]) {
-      return m_impl.template packet<Unaligned>(inputIndex);
-    } else {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      values[0] = m_impl.coeff(inputIndex);
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < PacketSize; ++i) {
-        if (innermostLoc + i < m_impl.dimensions()[0]) {
-          values[i] = m_impl.coeff(inputIndex + i);
-        } else {
-          values[i] = coeffColMajor(originalIndex + i);
-        }
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    }
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetRowMajor(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    const Index originalIndex = index;
-
-    Index inputIndex = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const Index idx = index / m_outputStrides[i];
-      if (internal::index_statically_eq<Broadcast>(i, 1)) {
-        eigen_assert(idx < m_impl.dimensions()[i]);
-        inputIndex += idx * m_inputStrides[i];
-      } else {
-        if (internal::index_statically_eq<InputDimensions>(i, 1)) {
-          eigen_assert(idx % m_impl.dimensions()[i] == 0);
-        } else {
-          inputIndex += (idx % m_impl.dimensions()[i]) * m_inputStrides[i];
-        }
-      }
-      index -= idx * m_outputStrides[i];
-    }
-    Index innermostLoc;
-    if (internal::index_statically_eq<Broadcast>(NumDims - 1, 1)) {
-      eigen_assert(index < m_impl.dimensions()[NumDims - 1]);
-      innermostLoc = index;
-    } else {
-      if (internal::index_statically_eq<InputDimensions>(NumDims - 1, 1)) {
-        eigen_assert(index % m_impl.dimensions()[NumDims - 1] == 0);
-        innermostLoc = 0;
-      } else {
-        innermostLoc = index % m_impl.dimensions()[NumDims - 1];
-      }
-    }
-    inputIndex += innermostLoc;
-
-    // TODO: This could be extended to the second dimension if we're not
-    // broadcasting alongside the first dimension, and so on.
-    if (innermostLoc + PacketSize <= m_impl.dimensions()[NumDims - 1]) {
-      return m_impl.template packet<Unaligned>(inputIndex);
-    } else {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      values[0] = m_impl.coeff(inputIndex);
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < PacketSize; ++i) {
-        if (innermostLoc + i < m_impl.dimensions()[NumDims - 1]) {
-          values[i] = m_impl.coeff(inputIndex + i);
-        } else {
-          values[i] = coeffRowMajor(originalIndex + i);
-        }
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    double compute_cost = TensorOpCost::AddCost<Index>();
-    if (!isCopy && NumDims > 0) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        compute_cost += TensorOpCost::DivCost<Index>();
-        if (internal::index_statically_eq<Broadcast>(i, 1)) {
-          compute_cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
-        } else {
-          if (!internal::index_statically_eq<InputDimensions>(i, 1)) {
-            compute_cost +=
-                TensorOpCost::MulCost<Index>() + TensorOpCost::ModCost<Index>() + TensorOpCost::AddCost<Index>();
-          }
-        }
-        compute_cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
-      }
-    }
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    // TODO(wuke): Targeting L1 size is 30% faster than targeting L{-1} on large
-    // tensors. But this might need further tuning.
-    const size_t target_size = m_device.firstLevelCacheSize();
-    return internal::TensorBlockResourceRequirements::merge(
-        m_impl.getResourceRequirements(), internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    BlockBroadcastingParams params = blockBroadcastingParams(desc);
-
-    if (params.inner_dim_size == 0 || params.bcast_dim_size == 0) {
-      return emptyBlock();
-    }
-
-    // Prepare storage for the materialized broadcasting result.
-    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
-    ScalarNoConst* materialized_output = block_storage.data();
-
-    // We potentially will need to materialize input blocks.
-    size_t materialized_input_size = 0;
-    ScalarNoConst* materialized_input = NULL;
-
-    // Initialize block broadcating iterator state for outer dimensions (outer
-    // with regard to bcast dimension). Dimension in this array are always in
-    // inner_most -> outer_most order (col major layout).
-    array<BlockBroadcastingIteratorState, NumDims> it;
-    int idx = 0;
-
-    for (int i = params.inner_dim_count + 1; i < NumDims; ++i) {
-      const Index dim = IsColMajor ? i : NumDims - 1 - i;
-      it[idx].size = params.output_dims[dim];
-      it[idx].count = 0;
-      it[idx].output_stride = m_outputStrides[dim];
-      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
-      idx++;
-    }
-
-    // Write output into the beginning of `materialized_output`.
-    Index output_offset = 0;
-
-    // We will fill output block by broadcasting along the bcast dim, and
-    // iterating over outer dimension.
-    const Index output_size = NumDims == 0 ? 1 : params.output_dims.TotalSize();
-
-    for (Index num_output_coeffs = 0; num_output_coeffs < output_size;) {
-      ScalarNoConst* bcast_output = materialized_output + num_output_coeffs;
-      Index bcast_offset = desc.offset() + output_offset;
-
-      // Broadcast along the bcast dimension.
-      num_output_coeffs += BroadcastBlockAlongBcastDim(params, bcast_offset, scratch, bcast_output, &materialized_input,
-                                                       &materialized_input_size);
-
-      // Switch to the next outer dimension.
-      for (int j = 0; j < idx; ++j) {
-        if (++it[j].count < it[j].size) {
-          output_offset += it[j].output_stride;
-          break;
-        }
-        it[j].count = 0;
-        output_offset -= it[j].output_span;
-      }
-    }
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-
-  Broadcast functor() const { return m_broadcast; }
-
- private:
-  static constexpr bool IsColMajor = static_cast<int>(Layout) == static_cast<int>(ColMajor);
-
-  // We will build a general case block broadcasting on top of broadcasting
-  // primitive that will do broadcasting only for the inner dimension(s) along
-  // the first dimension smaller than the input size (it's called `bcast_dim`).
-  //
-  // Example:
-  //           dim:  0  1  2   (ColMajor)
-  //    input size: [9, 3, 6]
-  //    block size: [9, 2, 6]
-  //
-  // We will compute broadcasted block by iterating over the outer dimensions
-  // before `bcast_dim` (only dimension `2` in this example) and computing
-  // broadcasts along the `bcast_dim` (dimension `1` in this example).
-
-  // BlockBroadcastingParams holds precomputed parameters for broadcasting a
-  // single block along the broadcasting dimension. Sizes and strides along the
-  // `bcast_dim` might be invalid, they will be adjusted later in
-  // `BroadcastBlockAlongBcastDim`.
-  struct BlockBroadcastingParams {
-    Dimensions input_dims;      // input expression dimensions
-    Dimensions output_dims;     // output block sizes
-    Dimensions output_strides;  // output block strides
-
-    int inner_dim_count;   // count inner dimensions matching in size
-    int bcast_dim;         // broadcasting dimension index
-    Index bcast_dim_size;  // broadcasting dimension size
-    Index inner_dim_size;  // inner dimensions size
-
-    // Block sizes and strides for the input block where all dimensions before
-    // `bcast_dim` are equal to `1`.
-    Dimensions input_block_sizes;
-    Dimensions input_block_strides;
-
-    // Block sizes and strides for blocks with extra dimensions and strides `0`.
-    BroadcastDimensions bcast_block_sizes;
-    BroadcastDimensions bcast_block_strides;
-    BroadcastDimensions bcast_input_strides;
-  };
-
-  struct BlockBroadcastingIteratorState {
-    Index size;
-    Index count;
-    Index output_stride;
-    Index output_span;
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE BlockBroadcastingParams blockBroadcastingParams(TensorBlockDesc& desc) const {
-    BlockBroadcastingParams params;
-
-    params.input_dims = Dimensions(m_impl.dimensions());
-
-    // Output block sizes and strides.
-    params.output_dims = desc.dimensions();
-    params.output_strides = internal::strides<Layout>(params.output_dims);
-
-    // Find the broadcasting dimension (first dimension with output size smaller
-    // that the input size).
-    params.bcast_dim = 0;
-    params.bcast_dim_size = 1;
-    params.inner_dim_size = 1;
-
-    // Count the number of inner dimensions that have the same size in the block
-    // and in the broadcast expression.
-    params.inner_dim_count = 0;
-
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-
-      if (params.output_dims[dim] == m_dimensions[dim]) {
-        params.inner_dim_size *= params.output_dims[dim];
-        ++params.inner_dim_count;
-        continue;
-      }
-
-      // First non-matching dimension is the broadcasting dimension.
-      eigen_assert(params.output_dims[dim] < m_dimensions[dim]);
-      params.bcast_dim = dim;
-      params.bcast_dim_size = params.output_dims[dim];
-      break;
-    }
-
-    // Calculate the input block size for looking into the input.
-    for (int i = 0; i < params.inner_dim_count; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      params.input_block_sizes[dim] = params.input_dims[dim];
-    }
-    for (int i = params.inner_dim_count; i < NumDims; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      params.input_block_sizes[dim] = 1;
-    }
-    params.input_block_strides = internal::strides<Layout>(params.input_block_sizes);
-
-    // Broadcast with the 0-stride trick: Create 1 extra dim for each
-    // broadcast, set the input stride to 0.
-    //
-    // When ColMajor:
-    //
-    // - bcast_block_sizes:
-    //   [d_0, b_0, d_1, b_1, ...]
-    //
-    // - bcast_block_strides:
-    //   [output_block_strides[0], output_block_strides[0] * d_0,
-    //    output_block_strides[1], output_block_strides[1] * d_1,
-    //   ...]
-    //
-    // - bcast_input_strides:
-    //   [input_block_strides[0], 0,
-    //    input_block_strides[1], 0,
-    //   ...].
-    //
-    for (int i = 0; i < params.inner_dim_count; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-
-      const int copy_dim = IsColMajor ? 2 * i : 2 * NumDims - 2 * i - 1;
-      const int broadcast_dim = IsColMajor ? copy_dim + 1 : copy_dim - 1;
-
-      params.bcast_block_sizes[copy_dim] = params.input_dims[dim];
-      params.bcast_block_sizes[broadcast_dim] = m_broadcast[dim];
-      params.bcast_block_strides[copy_dim] = params.output_strides[dim];
-      params.bcast_block_strides[broadcast_dim] = params.output_strides[dim] * params.input_dims[dim];
-      params.bcast_input_strides[copy_dim] = params.input_block_strides[dim];
-      params.bcast_input_strides[broadcast_dim] = 0;
-    }
-
-    for (int i = 2 * params.inner_dim_count; i < 2 * NumDims; ++i) {
-      const int dim = IsColMajor ? i : 2 * NumDims - i - 1;
-      params.bcast_block_sizes[dim] = 1;
-      params.bcast_block_strides[dim] = 0;
-      params.bcast_input_strides[dim] = 0;
-    }
-
-    return params;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock emptyBlock() const {
-    DSizes<Index, NumDims> dimensions;
-    for (int i = 0; i < NumDims; ++i) dimensions[i] = 0;
-    return TensorBlock(internal::TensorBlockKind::kView, NULL, dimensions);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index BroadcastBlockAlongBcastDim(
-      BlockBroadcastingParams params, Index bcast_offset, TensorBlockScratch& scratch,
-      ScalarNoConst* materialized_output, ScalarNoConst** materialized_input, size_t* materialized_input_size) const {
-    if (params.bcast_dim_size == 1) {
-      // We just need one block read using the ready-set values above.
-      return BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
-                            params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
-                            materialized_output, materialized_input, materialized_input_size);
-
-    } else if (params.input_dims[params.bcast_dim] == 1) {
-      // Broadcast bcast dimension (< NumDims) by bcast_dim_size.
-      const int broadcast_bcast_dim =
-          IsColMajor ? 2 * params.inner_dim_count + 1 : 2 * NumDims - 2 * params.inner_dim_count - 2;
-
-      params.bcast_block_sizes[broadcast_bcast_dim] = params.bcast_dim_size;
-      params.bcast_input_strides[broadcast_bcast_dim] = 0;
-      params.bcast_block_strides[broadcast_bcast_dim] = params.output_strides[params.bcast_dim];
-
-      return BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
-                            params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
-                            materialized_output, materialized_input, materialized_input_size);
-
-    } else {
-      // Keep track of the total number of the coefficients written to the
-      // output block.
-      Index num_output_coeffs = 0;
-
-      // The general case. Let's denote the output block as
-      //
-      //   x[..., a:a+bcast_dim_size, :, ..., :]
-      //
-      // where a:a+bcast_dim_size is a slice on the bcast_dim dimension
-      // (< NumDims). We need to split the a:a+bcast_dim_size into possibly 3
-      // sub-blocks:
-      //
-      // (1) a:b, where b is the smallest multiple of
-      //     input_dims[bcast_dim_start] in [a, a+bcast_dim_size].
-      //
-      // (2) b:c, where c is the largest multiple of input_dims[bcast_dim_start]
-      //     in [a, a+bcast_dim_size].
-      //
-      // (3) c:a+bcast_dim_size .
-      //
-      // Or, when b and c do not exist, we just need to process the whole block
-      // together.
-
-      // Find a.
-      const Index bcast_dim_left_index = bcast_offset / m_outputStrides[params.bcast_dim];
-
-      // Find b and c.
-      const Index input_bcast_dim_size = params.input_dims[params.bcast_dim];
-
-      // First multiple after a. This is b when <= bcast_dim_left_index +
-      // bcast_dim_size.
-      const Index first_multiple =
-          numext::div_ceil<Index>(bcast_dim_left_index, input_bcast_dim_size) * input_bcast_dim_size;
-
-      if (first_multiple <= bcast_dim_left_index + params.bcast_dim_size) {
-        // b exists, so does c. Find it.
-        const Index last_multiple =
-            (bcast_dim_left_index + params.bcast_dim_size) / input_bcast_dim_size * input_bcast_dim_size;
-        const int copy_bcast_dim =
-            IsColMajor ? 2 * params.inner_dim_count : 2 * NumDims - 2 * params.inner_dim_count - 1;
-        const int broadcast_bcast_dim =
-            IsColMajor ? 2 * params.inner_dim_count + 1 : 2 * NumDims - 2 * params.inner_dim_count - 2;
-
-        if (first_multiple > bcast_dim_left_index) {
-          const Index head_size = first_multiple - bcast_dim_left_index;
-          params.input_block_sizes[params.bcast_dim] = head_size;
-          params.bcast_block_sizes[copy_bcast_dim] = head_size;
-          params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
-          params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
-          params.bcast_block_sizes[broadcast_bcast_dim] = 1;
-          params.bcast_input_strides[broadcast_bcast_dim] = 0;
-          params.bcast_block_strides[broadcast_bcast_dim] =
-              params.output_strides[params.bcast_dim] * params.input_dims[params.bcast_dim];
-
-          num_output_coeffs +=
-              BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
-                             params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
-                             materialized_output, materialized_input, materialized_input_size);
-        }
-        if (first_multiple < last_multiple) {
-          params.input_block_sizes[params.bcast_dim] = input_bcast_dim_size;
-          params.bcast_block_sizes[copy_bcast_dim] = input_bcast_dim_size;
-          params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
-          params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
-          params.bcast_block_sizes[broadcast_bcast_dim] = (last_multiple - first_multiple) / input_bcast_dim_size;
-          params.bcast_input_strides[broadcast_bcast_dim] = 0;
-          params.bcast_block_strides[broadcast_bcast_dim] =
-              params.output_strides[params.bcast_dim] * params.input_dims[params.bcast_dim];
-          const Index offset = (first_multiple - bcast_dim_left_index) * m_outputStrides[params.bcast_dim];
-
-          num_output_coeffs +=
-              BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
-                             params.bcast_block_strides, params.bcast_input_strides, bcast_offset, offset, scratch,
-                             materialized_output, materialized_input, materialized_input_size);
-        }
-        if (last_multiple < bcast_dim_left_index + params.bcast_dim_size) {
-          const Index tail_size = bcast_dim_left_index + params.bcast_dim_size - last_multiple;
-          params.input_block_sizes[params.bcast_dim] = tail_size;
-          params.bcast_block_sizes[copy_bcast_dim] = tail_size;
-          params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
-          params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
-          params.bcast_block_sizes[broadcast_bcast_dim] = 1;
-          params.bcast_input_strides[broadcast_bcast_dim] = 0;
-          params.bcast_block_strides[broadcast_bcast_dim] =
-              params.output_strides[params.bcast_dim] * params.input_dims[params.bcast_dim];
-          const Index offset = (last_multiple - bcast_dim_left_index) * m_outputStrides[params.bcast_dim];
-
-          num_output_coeffs +=
-              BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
-                             params.bcast_block_strides, params.bcast_input_strides, bcast_offset, offset, scratch,
-                             materialized_output, materialized_input, materialized_input_size);
-        }
-      } else {
-        // b and c do not exist.
-        const int copy_bcast_dim =
-            IsColMajor ? 2 * params.inner_dim_count : 2 * NumDims - 2 * params.inner_dim_count - 1;
-        params.input_block_sizes[params.bcast_dim] = params.bcast_dim_size;
-        params.bcast_block_sizes[copy_bcast_dim] = params.bcast_dim_size;
-        params.bcast_input_strides[copy_bcast_dim] = params.input_block_strides[params.bcast_dim];
-        params.bcast_block_strides[copy_bcast_dim] = params.output_strides[params.bcast_dim];
-
-        num_output_coeffs +=
-            BroadcastBlock(params.input_block_sizes, params.input_block_strides, params.bcast_block_sizes,
-                           params.bcast_block_strides, params.bcast_input_strides, bcast_offset, 0, scratch,
-                           materialized_output, materialized_input, materialized_input_size);
-      }
-
-      return num_output_coeffs;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index BroadcastBlock(
-      const Dimensions& input_block_sizes, const Dimensions& input_block_strides,
-      const BroadcastDimensions& bcast_block_sizes, const BroadcastDimensions& bcast_block_strides,
-      const BroadcastDimensions& bcast_input_strides, Index bcast_offset, Index offset, TensorBlockScratch& scratch,
-      ScalarNoConst* materialized_output, ScalarNoConst** materialized_input, size_t* materialized_input_size) const {
-    // ---------------------------------------------------------------------- //
-    // Tensor block descriptor for reading block from the input.
-    const Index input_offset = bcast_offset + offset;
-    TensorBlockDesc input_desc(IsColMajor ? indexColMajor(input_offset) : indexRowMajor(input_offset),
-                               input_block_sizes);
-
-    ArgTensorBlock input_block = m_impl.block(input_desc, scratch);
-
-    // ---------------------------------------------------------------------- //
-    // Materialize input block into a temporary memory buffer only if it's not
-    // already available in the arg block.
-    const ScalarNoConst* input_buffer = NULL;
-
-    if (input_block.data() != NULL) {
-      // Input block already has raw data, there is no need to materialize it.
-      input_buffer = input_block.data();
-
-    } else {
-      // Otherwise we have to do block assignment into a temporary buffer.
-
-      // Maybe reuse previously allocated buffer, or allocate a new one with a
-      // scratch allocator.
-      const size_t input_total_size = input_block_sizes.TotalSize();
-      if (*materialized_input == NULL || *materialized_input_size < input_total_size) {
-        *materialized_input_size = input_total_size;
-        void* mem = scratch.allocate(*materialized_input_size * sizeof(Scalar));
-        *materialized_input = static_cast<ScalarNoConst*>(mem);
-      }
-
-      typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename ArgTensorBlock::XprType, Index>
-          TensorBlockAssignment;
-
-      TensorBlockAssignment::Run(
-          TensorBlockAssignment::target(input_block_sizes, input_block_strides, *materialized_input),
-          input_block.expr());
-
-      input_buffer = *materialized_input;
-    }
-
-    // ---------------------------------------------------------------------- //
-    // Copy data from materialized input block to the materialized output, using
-    // given broadcast strides (strides with zeroes).
-    typedef internal::TensorBlockIO<ScalarNoConst, Index, 2 * NumDims, Layout> TensorBlockIO;
-
-    typename TensorBlockIO::Src src(bcast_input_strides, input_buffer);
-    typename TensorBlockIO::Dst dst(bcast_block_sizes, bcast_block_strides, materialized_output + offset);
-
-    return TensorBlockIO::Copy(dst, src);
-  }
-
- protected:
-  const Device EIGEN_DEVICE_REF m_device;
-  const std::remove_reference_t<Broadcast> m_broadcast;
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims> m_inputStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_BROADCASTING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorChipping.h b/unsupported/Eigen/src/Tensor/TensorChipping.h
deleted file mode 100644
index 977f96f..0000000
--- a/unsupported/Eigen/src/Tensor/TensorChipping.h
+++ /dev/null
@@ -1,469 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CHIPPING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CHIPPING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <DenseIndex DimId, typename XprType>
-struct traits<TensorChippingOp<DimId, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions - 1;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <DenseIndex DimId, typename XprType>
-struct eval<TensorChippingOp<DimId, XprType>, Eigen::Dense> {
-  typedef const TensorChippingOp<DimId, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <DenseIndex DimId, typename XprType>
-struct nested<TensorChippingOp<DimId, XprType>, 1, typename eval<TensorChippingOp<DimId, XprType> >::type> {
-  typedef TensorChippingOp<DimId, XprType> type;
-};
-
-template <DenseIndex DimId>
-struct DimensionId {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DimensionId(DenseIndex dim) {
-    EIGEN_UNUSED_VARIABLE(dim);
-    eigen_assert(dim == DimId);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex actualDim() const { return DimId; }
-};
-template <>
-struct DimensionId<Dynamic> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DimensionId(DenseIndex dim) : actual_dim(dim) { eigen_assert(dim >= 0); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex actualDim() const { return actual_dim; }
-
- private:
-  const DenseIndex actual_dim;
-};
-
-}  // end namespace internal
-
-/** A chip is a thin slice, corresponding to a column or a row in a 2-d tensor.
- * \ingroup CXX11_Tensor_Module
- */
-template <DenseIndex DimId, typename XprType>
-class TensorChippingOp : public TensorBase<TensorChippingOp<DimId, XprType> > {
- public:
-  typedef TensorBase<TensorChippingOp<DimId, XprType> > Base;
-  typedef typename Eigen::internal::traits<TensorChippingOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorChippingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorChippingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorChippingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorChippingOp(const XprType& expr, const Index offset, const Index dim)
-      : m_xpr(expr), m_offset(offset), m_dim(dim) {
-    eigen_assert(dim < XprType::NumDimensions && dim >= 0 && "Chip_Dim_out_of_range");
-  }
-
-  EIGEN_DEVICE_FUNC const Index offset() const { return m_offset; }
-  EIGEN_DEVICE_FUNC const Index dim() const { return m_dim.actualDim(); }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorChippingOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Index m_offset;
-  const internal::DimensionId<DimId> m_dim;
-};
-
-// Eval as rvalue
-template <DenseIndex DimId, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device> {
-  typedef TensorChippingOp<DimId, ArgType> XprType;
-  static constexpr int NumInputDims =
-      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  static constexpr int NumDims = NumInputDims - 1;
-  typedef typename XprType::Index Index;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-
-  enum {
-    // Alignment can't be guaranteed at compile time since it depends on the
-    // slice offsets.
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
-    // Chipping of outer-most dimension is a trivial operation, because we can
-    // read and write directly from the underlying tensor using single offset.
-    IsOuterChipping = (Layout == ColMajor && DimId == NumInputDims - 1) || (Layout == RowMajor && DimId == 0),
-    // Chipping inner-most dimension.
-    IsInnerChipping = (Layout == ColMajor && DimId == 0) || (Layout == RowMajor && DimId == NumInputDims - 1),
-    // Prefer block access if the underlying expression prefers it, otherwise
-    // only if chipping is not trivial.
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess || !IsOuterChipping,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef internal::TensorBlockDescriptor<NumInputDims, Index> ArgTensorBlockDesc;
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_dim(op.dim()), m_device(device) {
-    EIGEN_STATIC_ASSERT((NumInputDims >= 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    eigen_assert(NumInputDims > m_dim.actualDim());
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    eigen_assert(op.offset() < input_dims[m_dim.actualDim()]);
-
-    int j = 0;
-    for (int i = 0; i < NumInputDims; ++i) {
-      if (i != m_dim.actualDim()) {
-        m_dimensions[j] = input_dims[i];
-        ++j;
-      }
-    }
-
-    m_stride = 1;
-    m_inputStride = 1;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = 0; i < m_dim.actualDim(); ++i) {
-        m_stride *= input_dims[i];
-        m_inputStride *= input_dims[i];
-      }
-    } else {
-      for (int i = NumInputDims - 1; i > m_dim.actualDim(); --i) {
-        m_stride *= input_dims[i];
-        m_inputStride *= input_dims[i];
-      }
-    }
-    m_inputStride *= input_dims[m_dim.actualDim()];
-    m_inputOffset = m_stride * op.offset();
-
-    // Check if chipping is effectively inner or outer: products of dimensions
-    // before or after the chipped dimension is `1`.
-    Index after_chipped_dim_product = 1;
-    for (int i = static_cast<int>(m_dim.actualDim()) + 1; i < NumInputDims; ++i) {
-      after_chipped_dim_product *= input_dims[i];
-    }
-
-    Index before_chipped_dim_product = 1;
-    for (int i = 0; i < m_dim.actualDim(); ++i) {
-      before_chipped_dim_product *= input_dims[i];
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_isEffectivelyInnerChipping = before_chipped_dim_product == 1;
-      m_isEffectivelyOuterChipping = after_chipped_dim_product == 1;
-    } else {
-      m_isEffectivelyInnerChipping = after_chipped_dim_product == 1;
-      m_isEffectivelyOuterChipping = before_chipped_dim_product == 1;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType /*data*/, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    return m_impl.coeff(srcCoeff(index));
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    if (isInnerChipping()) {
-      // m_stride is equal to 1, so let's avoid the integer division.
-      eigen_assert(m_stride == 1);
-      Index inputIndex = index * m_inputStride + m_inputOffset;
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < PacketSize; ++i) {
-        values[i] = m_impl.coeff(inputIndex);
-        inputIndex += m_inputStride;
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    } else if (isOuterChipping()) {
-      // m_stride is always greater than index, so let's avoid the integer division.
-      eigen_assert(m_stride > index);
-      return m_impl.template packet<LoadMode>(index + m_inputOffset);
-    } else {
-      const Index idx = index / m_stride;
-      const Index rem = index - idx * m_stride;
-      if (rem + PacketSize <= m_stride) {
-        Index inputIndex = idx * m_inputStride + m_inputOffset + rem;
-        return m_impl.template packet<LoadMode>(inputIndex);
-      } else {
-        // Cross the stride boundary. Fallback to slow path.
-        EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-        EIGEN_UNROLL_LOOP
-        for (int i = 0; i < PacketSize; ++i) {
-          values[i] = coeff(index);
-          ++index;
-        }
-        PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-        return rslt;
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    double cost = 0;
-    if ((static_cast<int>(Layout) == static_cast<int>(ColMajor) && m_dim.actualDim() == 0) ||
-        (static_cast<int>(Layout) == static_cast<int>(RowMajor) && m_dim.actualDim() == NumInputDims - 1)) {
-      cost += TensorOpCost::MulCost<Index>() + TensorOpCost::AddCost<Index>();
-    } else if ((static_cast<int>(Layout) == static_cast<int>(ColMajor) && m_dim.actualDim() == NumInputDims - 1) ||
-               (static_cast<int>(Layout) == static_cast<int>(RowMajor) && m_dim.actualDim() == 0)) {
-      cost += TensorOpCost::AddCost<Index>();
-    } else {
-      cost += 3 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>() + 3 * TensorOpCost::AddCost<Index>();
-    }
-
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.lastLevelCacheSize();
-    return internal::TensorBlockResourceRequirements::merge(
-        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size), m_impl.getResourceRequirements());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool root_of_expr_ast = false) const {
-    const Index chip_dim = m_dim.actualDim();
-
-    DSizes<Index, NumInputDims> input_block_dims;
-    for (int i = 0; i < NumInputDims; ++i) {
-      input_block_dims[i] = i < chip_dim ? desc.dimension(i) : i > chip_dim ? desc.dimension(i - 1) : 1;
-    }
-
-    ArgTensorBlockDesc arg_desc(srcCoeff(desc.offset()), input_block_dims);
-
-    // Try to reuse destination buffer for materializing argument block.
-    if (desc.HasDestinationBuffer()) {
-      DSizes<Index, NumInputDims> arg_destination_strides;
-      for (int i = 0; i < NumInputDims; ++i) {
-        arg_destination_strides[i] = i < chip_dim   ? desc.destination().strides()[i]
-                                     : i > chip_dim ? desc.destination().strides()[i - 1]
-                                                    : 0;  // for dimensions of size `1` stride should never be used.
-      }
-
-      arg_desc.template AddDestinationBuffer<Layout>(desc.destination().template data<ScalarNoConst>(),
-                                                     arg_destination_strides);
-    }
-
-    ArgTensorBlock arg_block = m_impl.block(arg_desc, scratch, root_of_expr_ast);
-    if (!arg_desc.HasDestinationBuffer()) desc.DropDestinationBuffer();
-
-    if (arg_block.data() != NULL) {
-      // Forward argument block buffer if possible.
-      return TensorBlock(arg_block.kind(), arg_block.data(), desc.dimensions());
-
-    } else {
-      // Assign argument block expression to a buffer.
-
-      // Prepare storage for the materialized chipping result.
-      const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
-
-      typedef internal::TensorBlockAssignment<ScalarNoConst, NumInputDims, typename ArgTensorBlock::XprType, Index>
-          TensorBlockAssignment;
-
-      TensorBlockAssignment::Run(
-          TensorBlockAssignment::target(arg_desc.dimensions(), internal::strides<Layout>(arg_desc.dimensions()),
-                                        block_storage.data()),
-          arg_block.expr());
-
-      return block_storage.AsTensorMaterializedBlock();
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Storage::Type data() const {
-    typename Storage::Type result = constCast(m_impl.data());
-    if (isOuterChipping() && result) {
-      return result + m_inputOffset;
-    } else {
-      return NULL;
-    }
-  }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
-    Index inputIndex;
-    if (isInnerChipping()) {
-      // m_stride is equal to 1, so let's avoid the integer division.
-      eigen_assert(m_stride == 1);
-      inputIndex = index * m_inputStride + m_inputOffset;
-    } else if (isOuterChipping()) {
-      // m_stride is always greater than index, so let's avoid the integer
-      // division.
-      eigen_assert(m_stride > index);
-      inputIndex = index + m_inputOffset;
-    } else {
-      const Index idx = index / m_stride;
-      inputIndex = idx * m_inputStride + m_inputOffset;
-      index -= idx * m_stride;
-      inputIndex += index;
-    }
-    return inputIndex;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool isInnerChipping() const {
-    return IsInnerChipping || m_isEffectivelyInnerChipping;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool isOuterChipping() const {
-    return IsOuterChipping || m_isEffectivelyOuterChipping;
-  }
-
-  Dimensions m_dimensions;
-  Index m_stride;
-  Index m_inputOffset;
-  Index m_inputStride;
-  TensorEvaluator<ArgType, Device> m_impl;
-  const internal::DimensionId<DimId> m_dim;
-  const Device EIGEN_DEVICE_REF m_device;
-
-  // If product of all dimensions after or before the chipped dimension is `1`,
-  // it is effectively the same as chipping innermost or outermost dimension.
-  bool m_isEffectivelyInnerChipping;
-  bool m_isEffectivelyOuterChipping;
-};
-
-// Eval as lvalue
-template <DenseIndex DimId, typename ArgType, typename Device>
-struct TensorEvaluator<TensorChippingOp<DimId, ArgType>, Device>
-    : public TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorChippingOp<DimId, ArgType>, Device> Base;
-  typedef TensorChippingOp<DimId, ArgType> XprType;
-  static constexpr int NumInputDims =
-      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  static constexpr int NumDims = NumInputDims - 1;
-  typedef typename XprType::Index Index;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
-    Layout = TensorEvaluator<ArgType, Device>::Layout,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(this->srcCoeff(index));
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    if (this->isInnerChipping()) {
-      // m_stride is equal to 1, so let's avoid the integer division.
-      eigen_assert(this->m_stride == 1);
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-      Index inputIndex = index * this->m_inputStride + this->m_inputOffset;
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < PacketSize; ++i) {
-        this->m_impl.coeffRef(inputIndex) = values[i];
-        inputIndex += this->m_inputStride;
-      }
-    } else if (this->isOuterChipping()) {
-      // m_stride is always greater than index, so let's avoid the integer division.
-      eigen_assert(this->m_stride > index);
-      this->m_impl.template writePacket<StoreMode>(index + this->m_inputOffset, x);
-    } else {
-      const Index idx = index / this->m_stride;
-      const Index rem = index - idx * this->m_stride;
-      if (rem + PacketSize <= this->m_stride) {
-        const Index inputIndex = idx * this->m_inputStride + this->m_inputOffset + rem;
-        this->m_impl.template writePacket<StoreMode>(inputIndex, x);
-      } else {
-        // Cross stride boundary. Fallback to slow path.
-        EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-        internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-        EIGEN_UNROLL_LOOP
-        for (int i = 0; i < PacketSize; ++i) {
-          this->coeffRef(index) = values[i];
-          ++index;
-        }
-      }
-    }
-  }
-
-  template <typename TensorBlock>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
-    eigen_assert(this->m_impl.data() != NULL);
-
-    const Index chip_dim = this->m_dim.actualDim();
-
-    DSizes<Index, NumInputDims> input_block_dims;
-    for (int i = 0; i < NumInputDims; ++i) {
-      input_block_dims[i] = i < chip_dim ? desc.dimension(i) : i > chip_dim ? desc.dimension(i - 1) : 1;
-    }
-
-    typedef TensorReshapingOp<const DSizes<Index, NumInputDims>, const typename TensorBlock::XprType> TensorBlockExpr;
-
-    typedef internal::TensorBlockAssignment<Scalar, NumInputDims, TensorBlockExpr, Index> TensorBlockAssign;
-
-    TensorBlockAssign::Run(
-        TensorBlockAssign::target(input_block_dims, internal::strides<Layout>(this->m_impl.dimensions()),
-                                  this->m_impl.data(), this->srcCoeff(desc.offset())),
-        block.expr().reshape(input_block_dims));
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CHIPPING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorConcatenation.h b/unsupported/Eigen/src/Tensor/TensorConcatenation.h
deleted file mode 100644
index 29607a7..0000000
--- a/unsupported/Eigen/src/Tensor/TensorConcatenation.h
+++ /dev/null
@@ -1,351 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Axis, typename LhsXprType, typename RhsXprType>
-struct traits<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> > {
-  // Type promotion to handle the case where the types of the lhs and the rhs are different.
-  typedef typename promote_storage_type<typename LhsXprType::Scalar, typename RhsXprType::Scalar>::ret Scalar;
-  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
-                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
-  typedef
-      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
-  typedef typename LhsXprType::Nested LhsNested;
-  typedef typename RhsXprType::Nested RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
-  static constexpr int NumDimensions = traits<LhsXprType>::NumDimensions;
-  static constexpr int Layout = traits<LhsXprType>::Layout;
-  enum { Flags = 0 };
-  typedef std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
-                             typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>
-      PointerType;
-};
-
-template <typename Axis, typename LhsXprType, typename RhsXprType>
-struct eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, Eigen::Dense> {
-  typedef const TensorConcatenationOp<Axis, LhsXprType, RhsXprType>& type;
-};
-
-template <typename Axis, typename LhsXprType, typename RhsXprType>
-struct nested<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, 1,
-              typename eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >::type> {
-  typedef TensorConcatenationOp<Axis, LhsXprType, RhsXprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor concatenation class.
- */
-template <typename Axis, typename LhsXprType, typename RhsXprType>
-class TensorConcatenationOp : public TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors> {
- public:
-  typedef TensorBase<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, WriteAccessors> Base;
-  typedef typename internal::traits<TensorConcatenationOp>::Scalar Scalar;
-  typedef typename internal::traits<TensorConcatenationOp>::StorageKind StorageKind;
-  typedef typename internal::traits<TensorConcatenationOp>::Index Index;
-  typedef typename internal::nested<TensorConcatenationOp>::type Nested;
-  typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
-                                                  typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConcatenationOp(const LhsXprType& lhs, const RhsXprType& rhs, Axis axis)
-      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_axis(axis) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
-    return m_lhs_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
-    return m_rhs_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const Axis& axis() const { return m_axis; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorConcatenationOp)
- protected:
-  typename LhsXprType::Nested m_lhs_xpr;
-  typename RhsXprType::Nested m_rhs_xpr;
-  const Axis m_axis;
-};
-
-// Eval as rvalue
-template <typename Axis, typename LeftArgType, typename RightArgType, typename Device>
-struct TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> {
-  typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
-  static constexpr int RightNumDims =
-      internal::array_size<typename TensorEvaluator<RightArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess =
-        TensorEvaluator<LeftArgType, Device>::PacketAccess && TensorEvaluator<RightArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<LeftArgType, Device>::PreferBlockAccess ||
-                        TensorEvaluator<RightArgType, Device>::PreferBlockAccess,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device), m_axis(op.axis()) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
-                             static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) ||
-                         NumDims == 1),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((NumDims == RightNumDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    eigen_assert(0 <= m_axis && m_axis < NumDims);
-    const Dimensions& lhs_dims = m_leftImpl.dimensions();
-    const Dimensions& rhs_dims = m_rightImpl.dimensions();
-    {
-      int i = 0;
-      for (; i < m_axis; ++i) {
-        eigen_assert(lhs_dims[i] > 0);
-        eigen_assert(lhs_dims[i] == rhs_dims[i]);
-        m_dimensions[i] = lhs_dims[i];
-      }
-      eigen_assert(lhs_dims[i] > 0);  // Now i == m_axis.
-      eigen_assert(rhs_dims[i] > 0);
-      m_dimensions[i] = lhs_dims[i] + rhs_dims[i];
-      for (++i; i < NumDims; ++i) {
-        eigen_assert(lhs_dims[i] > 0);
-        eigen_assert(lhs_dims[i] == rhs_dims[i]);
-        m_dimensions[i] = lhs_dims[i];
-      }
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_leftStrides[0] = 1;
-      m_rightStrides[0] = 1;
-      m_outputStrides[0] = 1;
-
-      for (int j = 1; j < NumDims; ++j) {
-        m_leftStrides[j] = m_leftStrides[j - 1] * lhs_dims[j - 1];
-        m_rightStrides[j] = m_rightStrides[j - 1] * rhs_dims[j - 1];
-        m_outputStrides[j] = m_outputStrides[j - 1] * m_dimensions[j - 1];
-      }
-    } else {
-      m_leftStrides[NumDims - 1] = 1;
-      m_rightStrides[NumDims - 1] = 1;
-      m_outputStrides[NumDims - 1] = 1;
-
-      for (int j = NumDims - 2; j >= 0; --j) {
-        m_leftStrides[j] = m_leftStrides[j + 1] * lhs_dims[j + 1];
-        m_rightStrides[j] = m_rightStrides[j + 1] * rhs_dims[j + 1];
-        m_outputStrides[j] = m_outputStrides[j + 1] * m_dimensions[j + 1];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  // TODO(phli): Add short-circuit memcpy evaluation if underlying data are linear.
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_leftImpl.evalSubExprsIfNeeded(NULL);
-    m_rightImpl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_leftImpl.cleanup();
-    m_rightImpl.cleanup();
-  }
-
-  // TODO(phli): Attempt to speed this up. The integer divisions and modulo are slow.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    // Collect dimension-wise indices (subs).
-    array<Index, NumDims> subs;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        subs[i] = index / m_outputStrides[i];
-        index -= subs[i] * m_outputStrides[i];
-      }
-      subs[0] = index;
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        subs[i] = index / m_outputStrides[i];
-        index -= subs[i] * m_outputStrides[i];
-      }
-      subs[NumDims - 1] = index;
-    }
-
-    const Dimensions& left_dims = m_leftImpl.dimensions();
-    if (subs[m_axis] < left_dims[m_axis]) {
-      Index left_index;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        left_index = subs[0];
-        EIGEN_UNROLL_LOOP
-        for (int i = 1; i < NumDims; ++i) {
-          left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
-        }
-      } else {
-        left_index = subs[NumDims - 1];
-        EIGEN_UNROLL_LOOP
-        for (int i = NumDims - 2; i >= 0; --i) {
-          left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
-        }
-      }
-      return m_leftImpl.coeff(left_index);
-    } else {
-      subs[m_axis] -= left_dims[m_axis];
-      const Dimensions& right_dims = m_rightImpl.dimensions();
-      Index right_index;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        right_index = subs[0];
-        EIGEN_UNROLL_LOOP
-        for (int i = 1; i < NumDims; ++i) {
-          right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
-        }
-      } else {
-        right_index = subs[NumDims - 1];
-        EIGEN_UNROLL_LOOP
-        for (int i = NumDims - 2; i >= 0; --i) {
-          right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
-        }
-      }
-      return m_rightImpl.coeff(right_index);
-    }
-  }
-
-  // TODO(phli): Add a real vectorization.
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < packetSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
-                                           TensorOpCost::DivCost<Index>() + TensorOpCost::ModCost<Index>());
-    const double lhs_size = m_leftImpl.dimensions().TotalSize();
-    const double rhs_size = m_rightImpl.dimensions().TotalSize();
-    return (lhs_size / (lhs_size + rhs_size)) * m_leftImpl.costPerCoeff(vectorized) +
-           (rhs_size / (lhs_size + rhs_size)) * m_rightImpl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- protected:
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims> m_leftStrides;
-  array<Index, NumDims> m_rightStrides;
-  TensorEvaluator<LeftArgType, Device> m_leftImpl;
-  TensorEvaluator<RightArgType, Device> m_rightImpl;
-  const Axis m_axis;
-};
-
-// Eval as lvalue
-template <typename Axis, typename LeftArgType, typename RightArgType, typename Device>
-struct TensorEvaluator<TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
-    : public TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> {
-  typedef TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> Base;
-  typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
-  typedef typename Base::Dimensions Dimensions;
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess =
-        TensorEvaluator<LeftArgType, Device>::PacketAccess && TensorEvaluator<RightArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<LeftArgType, Device>::PreferBlockAccess ||
-                        TensorEvaluator<RightArgType, Device>::PreferBlockAccess,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(XprType& op, const Device& device) : Base(op, device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  }
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    // Collect dimension-wise indices (subs).
-    array<Index, Base::NumDims> subs;
-    for (int i = Base::NumDims - 1; i > 0; --i) {
-      subs[i] = index / this->m_outputStrides[i];
-      index -= subs[i] * this->m_outputStrides[i];
-    }
-    subs[0] = index;
-
-    const Dimensions& left_dims = this->m_leftImpl.dimensions();
-    if (subs[this->m_axis] < left_dims[this->m_axis]) {
-      Index left_index = subs[0];
-      for (int i = 1; i < Base::NumDims; ++i) {
-        left_index += (subs[i] % left_dims[i]) * this->m_leftStrides[i];
-      }
-      return this->m_leftImpl.coeffRef(left_index);
-    } else {
-      subs[this->m_axis] -= left_dims[this->m_axis];
-      const Dimensions& right_dims = this->m_rightImpl.dimensions();
-      Index right_index = subs[0];
-      for (int i = 1; i < Base::NumDims; ++i) {
-        right_index += (subs[i] % right_dims[i]) * this->m_rightStrides[i];
-      }
-      return this->m_rightImpl.coeffRef(right_index);
-    }
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + packetSize - 1 < this->dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
-    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-    for (int i = 0; i < packetSize; ++i) {
-      coeffRef(index + i) = values[i];
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorContraction.h b/unsupported/Eigen/src/Tensor/TensorContraction.h
deleted file mode 100644
index 6768814..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContraction.h
+++ /dev/null
@@ -1,955 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Dimensions, typename LhsXprType, typename RhsXprType, typename OutputKernelType>
-struct traits<TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>> {
-  // Type promotion to handle the case where the types of the lhs and the rhs are different.
-  using Scalar = typename gebp_traits<std::remove_const_t<typename LhsXprType::Scalar>,
-                                      std::remove_const_t<typename RhsXprType::Scalar>>::ResScalar;
-
-  using StorageKind = typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
-                                                    typename traits<RhsXprType>::StorageKind>::ret;
-  using Index =
-      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type;
-  using LhsNested = typename LhsXprType::Nested;
-  using RhsNested = typename RhsXprType::Nested;
-  using LhsNested_ = std::remove_reference_t<LhsNested>;
-  using RhsNested_ = std::remove_reference_t<RhsNested>;
-
-  // From NumDims below.
-  static constexpr int NumDimensions =
-      traits<LhsXprType>::NumDimensions + traits<RhsXprType>::NumDimensions - 2 * array_size<Dimensions>::value;
-  static constexpr int Layout = traits<LhsXprType>::Layout;
-  using PointerType =
-      std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
-                         typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>;
-
-  enum { Flags = 0 };
-};
-
-template <typename Dimensions, typename LhsXprType, typename RhsXprType, typename OutputKernelType>
-struct eval<TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>, Eigen::Dense> {
-  using type = const TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>&;
-};
-
-template <typename Dimensions, typename LhsXprType, typename RhsXprType, typename OutputKernelType>
-struct nested<TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>, 1,
-              typename eval<TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>>::type> {
-  using type = TensorContractionOp<Dimensions, LhsXprType, RhsXprType, OutputKernelType>;
-};
-
-template <typename Indices_, typename LeftArgType_, typename RightArgType_, typename OutputKernelType_,
-          typename Device_>
-struct traits<
-    TensorEvaluator<const TensorContractionOp<Indices_, LeftArgType_, RightArgType_, OutputKernelType_>, Device_>> {
-  using Indices = Indices_;
-  using LeftArgType = LeftArgType_;
-  using RightArgType = RightArgType_;
-  using OutputKernelType = OutputKernelType_;
-  using Device = Device_;
-
-  // From NumDims below.
-  static constexpr int NumDimensions =
-      traits<LeftArgType_>::NumDimensions + traits<RightArgType_>::NumDimensions - 2 * array_size<Indices_>::value;
-};
-
-// Helper class to allocate and deallocate temporary memory for packed buffers.
-template <typename LhsScalar, typename RhsScalar>
-struct TensorContractionBlockMemAllocator {
-  using BlockMemHandle = void*;
-
-  template <typename Device>
-  EIGEN_DEVICE_FUNC static BlockMemHandle allocate(Device& d, const Index bm, const Index bk, const Index bn,
-                                                   LhsScalar** lhs_block, RhsScalar** rhs_block) {
-    eigen_assert(lhs_block);
-    eigen_assert(rhs_block);
-    BlockSizes sz = ComputeLhsRhsBlockSizes(bm, bk, bn);
-    char* block_mem = static_cast<char*>(d.allocate(sz.lhs_size + sz.rhs_size));
-    *lhs_block = static_cast<LhsScalar*>(static_cast<void*>(block_mem));
-    *rhs_block = static_cast<RhsScalar*>(static_cast<void*>(block_mem + sz.lhs_size));
-    return block_mem;
-  }
-
-  template <typename Device>
-  EIGEN_DEVICE_FUNC static BlockMemHandle allocateSlices(Device& d, const Index bm, const Index bk, const Index bn,
-                                                         const Index num_lhs, const Index num_rhs,
-                                                         const Index num_slices, std::vector<LhsScalar*>* lhs_blocks,
-                                                         std::vector<RhsScalar*>* rhs_blocks) {
-    eigen_assert(num_slices > 0);
-    eigen_assert(num_lhs >= 0 && num_rhs >= 0);
-    eigen_assert(num_lhs == 0 || lhs_blocks);
-    eigen_assert(num_rhs == 0 || rhs_blocks);
-    BlockSizes sz = ComputeLhsRhsBlockSizes(bm, bk, bn);
-    void* block_mem = d.allocate((num_lhs * sz.lhs_size + num_rhs * sz.rhs_size) * num_slices);
-    eigen_assert(block_mem);
-    char* mem = static_cast<char*>(block_mem);
-
-    for (Index x = 0; x < num_slices; x++) {
-      if (num_lhs > 0) lhs_blocks[x].resize(num_lhs);
-      for (Index m = 0; m < num_lhs; m++) {
-        lhs_blocks[x][m] = static_cast<LhsScalar*>(static_cast<void*>(mem));
-        mem += sz.lhs_size;
-      }
-      if (num_rhs > 0) rhs_blocks[x].resize(num_rhs);
-      for (Index n = 0; n < num_rhs; n++) {
-        rhs_blocks[x][n] = static_cast<RhsScalar*>(static_cast<void*>(mem));
-        mem += sz.rhs_size;
-      }
-    }
-
-    return block_mem;
-  }
-
-  template <typename Device>
-  EIGEN_DEVICE_FUNC static void deallocate(Device& d, BlockMemHandle handle) {
-    d.deallocate(handle);
-  }
-
- private:
-  struct BlockSizes {
-    Index lhs_size;
-    Index rhs_size;
-  };
-  EIGEN_DEVICE_FUNC static BlockSizes ComputeLhsRhsBlockSizes(const Index bm, const Index bk, const Index bn) {
-    Index align = numext::maxi(EIGEN_MAX_ALIGN_BYTES, 1);
-    BlockSizes sz;
-    sz.lhs_size = numext::div_ceil<Index>(bm * bk * sizeof(LhsScalar), align) * align;
-    sz.rhs_size = numext::div_ceil<Index>(bn * bk * sizeof(RhsScalar), align) * align;
-    return sz;
-  }
-};
-
-// WARNING: In this code we assume that Lhs and Rhs tensor expressions are in
-// ColMajor storage order. This property is guaranteed by the
-// TensorContractionOp evaluator. TensorContractionKernel specifies how we pack
-// blocks of Lhs and Rhs tensor expressions, and how we invoke matrix
-// multiplication for these blocks. Default tensor contraction uses
-// gemm_pack_rhs, gemm_pack_lhs and gebp_kernel from Eigen Core (see
-// GeneralBlockPanelKernel.h for details).
-//
-// By specializing contraction kernels we can use other low level libraries to
-// perform matrix multiplication, and still rely on Eigen contraction evaluator.
-// This also includes full support in TensorContractionThreadPool, assuming that
-// underlying gemm does not use its own threading.
-//
-// - ResScalar/LhsScalar/RhsScalar - scalar type for the result of
-//   multiplication, lhs tensor and rhs tensor respectively.
-//
-// - StorageIndex - index type for the tensor expressions. In practice almost
-//   always is Eigen::Index.
-//
-// - OutputMapper provides access to the memory of the output matrix. In
-//   practice it's always column major blas_data_mapper (it must be of ResScalar
-//   type).
-//
-// - LhsMapper/RhsMapper similarly to blas_data_mapper provide a two dimensional
-//   view into the Lhs/Rhs tensor expressions. In practice it's
-//   TensorContractionInputMapper, or some specialization of it based on the
-//   type of tensor expression (e.g. TensorImagePatchOp has optimized input
-//   mapper).
-template <typename ResScalar, typename LhsScalar, typename RhsScalar, typename StorageIndex, typename OutputMapper,
-          typename LhsMapper, typename RhsMapper>
-struct TensorContractionKernel {
-  // True if `invoke()` supports `beta` in `C <- alpha * A * B + beta * C`
-  // (otherwise beta should be always equal to 1).
-  enum { HasBeta = false };
-
-  EIGEN_DEVICE_FUNC TensorContractionKernel(StorageIndex m_, StorageIndex k_, StorageIndex n_, StorageIndex bm_,
-                                            StorageIndex bk_, StorageIndex bn_)
-      : m(m_), k(k_), n(n_), bm(bm_), bk(bk_), bn(bn_) {}
-
-  // Pack blocks of Lhs and Rhs into contiguous blocks in memory.
-  using LhsBlock = LhsScalar*;
-  using RhsBlock = RhsScalar*;
-
-  // Packed Lhs/Rhs block memory allocator.
-  using BlockMemAllocator = TensorContractionBlockMemAllocator<LhsScalar, RhsScalar>;
-  using BlockMemHandle = typename BlockMemAllocator::BlockMemHandle;
-
-  using Traits = typename internal::gebp_traits<LhsScalar, RhsScalar>;
-
-  using LhsPacker = internal::gemm_pack_lhs<LhsScalar, StorageIndex, typename LhsMapper::SubMapper, Traits::mr,
-                                            Traits::LhsProgress, typename Traits::LhsPacket4Packing, ColMajor>;
-
-  using RhsPacker =
-      internal::gemm_pack_rhs<RhsScalar, StorageIndex, typename RhsMapper::SubMapper, Traits::nr, ColMajor>;
-
-  using GebpKernel = internal::gebp_kernel<LhsScalar, RhsScalar, StorageIndex, OutputMapper, Traits::mr, Traits::nr,
-                                           /*ConjugateLhs*/ false, /*ConjugateRhs*/ false>;
-
-  template <typename Device>
-  EIGEN_DEVICE_FUNC BlockMemHandle allocate(Device& d, LhsBlock* lhs_block, RhsBlock* rhs_block) {
-    return BlockMemAllocator::allocate(d, bm, bk, bn, lhs_block, rhs_block);
-  }
-
-  template <typename Device>
-  EIGEN_DEVICE_FUNC BlockMemHandle allocateSlices(Device& d, const StorageIndex num_lhs, const StorageIndex num_rhs,
-                                                  const StorageIndex num_slices, std::vector<LhsBlock>* lhs_blocks,
-                                                  std::vector<RhsBlock>* rhs_blocks) {
-    return BlockMemAllocator::allocateSlices(d, bm, bk, bn, num_lhs, num_rhs, num_slices, lhs_blocks, rhs_blocks);
-  }
-
-  template <typename Device>
-  EIGEN_DEVICE_FUNC static void deallocate(Device& d, BlockMemHandle handle) {
-    BlockMemAllocator::deallocate(d, handle);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void packLhs(LhsBlock* lhsBlock, const typename LhsMapper::SubMapper& data_mapper,
-                                                   const StorageIndex depth, const StorageIndex rows) {
-    LhsPacker()(*lhsBlock, data_mapper, depth, rows, /*stride*/ 0,
-                /*offset*/ 0);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void packRhs(RhsBlock* rhsBlock, const typename RhsMapper::SubMapper& data_mapper,
-                                                   const StorageIndex depth, const StorageIndex cols) {
-    RhsPacker()(*rhsBlock, data_mapper, depth, cols);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_DONT_INLINE void invoke(const OutputMapper& output_mapper, const LhsBlock& lhsBlock,
-                                                  const RhsBlock& rhsBlock, const StorageIndex rows,
-                                                  const StorageIndex depth, const StorageIndex cols,
-                                                  const ResScalar alpha, const ResScalar beta) {
-    // Default GEBP kernel does not support beta.
-    EIGEN_ONLY_USED_FOR_DEBUG(beta);
-    eigen_assert(beta == ResScalar(1));
-    static const int kComputeStrideFromBlockDimensions = -1;
-    GebpKernel()(output_mapper, lhsBlock, rhsBlock, rows, depth, cols, alpha,
-                 /*strideA*/ kComputeStrideFromBlockDimensions,
-                 /*strideB*/ kComputeStrideFromBlockDimensions,
-                 /*offsetA*/ 0, /*offsetB*/ 0);
-  }
-
- private:
-  // These are dimensions of the original Tensors, and selected block sizes. The
-  // actual block sizes passed to all function above might be smaller because of
-  // the partial blocks at the end.
-  const StorageIndex m;
-  const StorageIndex k;
-  const StorageIndex n;
-  const StorageIndex bm;
-  const StorageIndex bk;
-  const StorageIndex bn;
-};
-
-}  // end namespace internal
-
-// Tensor contraction params that should enable to get from output matrix
-// 2-dimensional coordinates to the output tensor dimensions.
-struct TensorContractionParams {
-  // TensorContraction evaluator assumes that both tensors are in ColMajor
-  // layout, if tensors are in RowMajor evaluator swap lhs with rhs.
-  bool swapped_arguments;
-};
-
-// Output kernel allows to fuse operations into the tensor contraction.
-//
-// Examples:
-//   1. Elementwise Relu transformation following Conv2D.
-//   2. AddBias to the Conv2D output channels dimension.
-//
-// The NoOpOutputKernel implements an output kernel that does absolutely nothing.
-struct NoOpOutputKernel {
-  /**
-   * Tensor contraction evaluator calls this kernel after finishing each block
-   * of output matrix. Output blocks belong to the 2-dimensional output tensor.
-   *
-   * TensorContractionParams contains contraction dimensions information
-   * required to map output 2-d space into the expected output tensor space
-   * (potentially higher dimensional).
-   *
-   * \param[in] output_mapper Access to output tensor memory
-   * \param[in] params   Tensor contraction parameters
-   * \param[in] i        Index of a first row available through output_mapper
-   * \param[in] j        Index of a first column available through output_mapper
-   * \param[in] num_rows Number of available rows
-   * \param[in] num_cols Number of available columns
-   */
-  template <typename Index, typename Scalar>
-  EIGEN_ALWAYS_INLINE void operator()(const internal::blas_data_mapper<Scalar, Index, ColMajor>& output_mapper,
-                                      const TensorContractionParams& params, Index i, Index j, Index num_rows,
-                                      Index num_cols) const {
-    EIGEN_UNUSED_VARIABLE(output_mapper);
-    EIGEN_UNUSED_VARIABLE(params);
-    EIGEN_UNUSED_VARIABLE(i);
-    EIGEN_UNUSED_VARIABLE(j);
-    EIGEN_UNUSED_VARIABLE(num_rows);
-    EIGEN_UNUSED_VARIABLE(num_cols);
-  }
-};
-
-/** Tensor contraction class.
- * \ingroup CXX11_Tensor_Module
- */
-template <typename Indices, typename LhsXprType, typename RhsXprType,
-          typename OutputKernelType = const NoOpOutputKernel>
-class TensorContractionOp
-    : public TensorBase<TensorContractionOp<Indices, LhsXprType, RhsXprType, OutputKernelType>, ReadOnlyAccessors> {
- public:
-  using Scalar = typename Eigen::internal::traits<TensorContractionOp>::Scalar;
-  using CoeffReturnType = typename internal::gebp_traits<typename LhsXprType::CoeffReturnType,
-                                                         typename RhsXprType::CoeffReturnType>::ResScalar;
-  using Nested = typename Eigen::internal::nested<TensorContractionOp>::type;
-  using StorageKind = typename Eigen::internal::traits<TensorContractionOp>::StorageKind;
-  using Index = typename Eigen::internal::traits<TensorContractionOp>::Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionOp(const LhsXprType& lhs, const RhsXprType& rhs,
-                                                            const Indices& dims,
-                                                            const OutputKernelType& output_kernel = OutputKernelType())
-      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_indices(dims), m_output_kernel(output_kernel) {}
-
-  EIGEN_DEVICE_FUNC const Indices& indices() const { return m_indices; }
-
-  /** \returns the nested expressions */
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
-    return m_lhs_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
-    return m_rhs_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const OutputKernelType& outputKernel() const { return m_output_kernel; }
-
- protected:
-  typename LhsXprType::Nested m_lhs_xpr;
-  typename RhsXprType::Nested m_rhs_xpr;
-  const Indices m_indices;
-  const OutputKernelType m_output_kernel;
-};
-
-template <typename Derived>
-struct TensorContractionEvaluatorBase {
-  using Indices = typename internal::traits<Derived>::Indices;
-  using LeftArgType = typename internal::traits<Derived>::LeftArgType;
-  using RightArgType = typename internal::traits<Derived>::RightArgType;
-  using OutputKernelType = typename internal::traits<Derived>::OutputKernelType;
-  using Device = typename internal::traits<Derived>::Device;
-
-  using XprType = TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>;
-  using Scalar = std::remove_const_t<typename XprType::Scalar>;
-  using Index = typename XprType::Index;
-  using CoeffReturnType = typename XprType::CoeffReturnType;
-  using PacketReturnType = typename PacketType<CoeffReturnType, Device>::type;
-  using Storage = StorageMemory<Scalar, Device>;
-  using EvaluatorPointerType = typename Storage::Type;
-
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-  enum {
-    IsAligned = true,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = true
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  using TensorBlock = internal::TensorBlockNotImplemented;
-  //===--------------------------------------------------------------------===//
-
-  // Most of the code is assuming that both input tensors are ColMajor. If the
-  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
-  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
-  // will pretend B is LHS and A is RHS.
-  using EvalLeftArgType =
-      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), LeftArgType, RightArgType>;
-  using EvalRightArgType =
-      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), RightArgType, LeftArgType>;
-
-  using LeftEvaluatorType = TensorEvaluator<EvalLeftArgType, Device>;
-  using RightEvaluatorType = TensorEvaluator<EvalRightArgType, Device>;
-
-  static constexpr int LDims =
-      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
-  static constexpr int RDims =
-      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
-  static constexpr int ContractDims = internal::array_size<Indices>::value;
-  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
-
-  using contract_t = array<Index, ContractDims>;
-  using left_nocontract_t = array<Index, LDims - ContractDims>;
-  using right_nocontract_t = array<Index, RDims - ContractDims>;
-
-  using Dimensions = DSizes<Index, NumDims>;
-
-  EIGEN_STRONG_INLINE TensorContractionEvaluatorBase(const XprType& op, const Device& device)
-      : m_leftImpl(choose(Cond<static_cast<int>(Layout) == static_cast<int>(ColMajor)>(), op.lhsExpression(),
-                          op.rhsExpression()),
-                   device),
-        m_rightImpl(choose(Cond<static_cast<int>(Layout) == static_cast<int>(ColMajor)>(), op.rhsExpression(),
-                           op.lhsExpression()),
-                    device),
-        m_device(device),
-        m_output_kernel(op.outputKernel()),
-        m_result(NULL) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
-                         static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    DSizes<Index, LDims> eval_left_dims;
-    DSizes<Index, RDims> eval_right_dims;
-    array<IndexPair<Index>, ContractDims> eval_op_indices;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      // For ColMajor, we keep using the existing dimensions
-      for (int i = 0; i < LDims; i++) {
-        eval_left_dims[i] = m_leftImpl.dimensions()[i];
-      }
-      for (int i = 0; i < RDims; i++) {
-        eval_right_dims[i] = m_rightImpl.dimensions()[i];
-      }
-      // We keep the pairs of contracting indices.
-      for (int i = 0; i < ContractDims; i++) {
-        eval_op_indices[i].first = op.indices()[i].first;
-        eval_op_indices[i].second = op.indices()[i].second;
-      }
-    } else {
-      // For RowMajor, we need to reverse the existing dimensions
-      for (int i = 0; i < LDims; i++) {
-        eval_left_dims[i] = m_leftImpl.dimensions()[LDims - i - 1];
-      }
-      for (int i = 0; i < RDims; i++) {
-        eval_right_dims[i] = m_rightImpl.dimensions()[RDims - i - 1];
-      }
-      // We need to flip all the pairs of contracting indices as well as
-      // reversing the dimensions.
-      for (int i = 0; i < ContractDims; i++) {
-        eval_op_indices[i].first = LDims - 1 - op.indices()[ContractDims - 1 - i].second;
-        eval_op_indices[i].second = RDims - 1 - op.indices()[ContractDims - 1 - i].first;
-      }
-    }
-
-    // Check for duplicate axes and make sure the first index in eval_op_indices
-    // is increasing. Using O(n^2) sorting is OK since ContractDims is small
-    for (int i = 0; i < ContractDims; i++) {
-      for (int j = i + 1; j < ContractDims; j++) {
-        eigen_assert(eval_op_indices[j].first != eval_op_indices[i].first &&
-                     eval_op_indices[j].second != eval_op_indices[i].second && "contraction axes should be unique");
-        if (eval_op_indices[j].first < eval_op_indices[i].first) {
-          numext::swap(eval_op_indices[j], eval_op_indices[i]);
-        }
-      }
-    }
-
-    array<Index, LDims> lhs_strides;
-    lhs_strides[0] = 1;
-    for (int i = 0; i < LDims - 1; ++i) {
-      lhs_strides[i + 1] = lhs_strides[i] * eval_left_dims[i];
-    }
-
-    array<Index, RDims> rhs_strides;
-    rhs_strides[0] = 1;
-    for (int i = 0; i < RDims - 1; ++i) {
-      rhs_strides[i + 1] = rhs_strides[i] * eval_right_dims[i];
-    }
-
-    if (m_i_strides.size() > 0) m_i_strides[0] = 1;
-    if (m_j_strides.size() > 0) m_j_strides[0] = 1;
-    if (m_k_strides.size() > 0) m_k_strides[0] = 1;
-
-    m_i_size = 1;
-    m_j_size = 1;
-    m_k_size = 1;
-
-    // To compute the dimension, we simply concatenate the non-contracting
-    // dimensions of the left and then the right tensor. Additionally, we also
-    // compute the strides corresponding to the left non-contracting
-    // dimensions and right non-contracting dimensions.
-    m_lhs_inner_dim_contiguous = true;
-    int dim_idx = 0;
-    Index nocontract_idx = 0;
-
-    for (int i = 0; i < LDims; i++) {
-      // find if we are contracting on index i of left tensor
-      bool contracting = false;
-      for (int j = 0; j < ContractDims; j++) {
-        if (eval_op_indices[j].first == i) {
-          contracting = true;
-          break;
-        }
-      }
-      if (!contracting) {
-        // add dimension size to output dimensions
-        m_dimensions[dim_idx] = eval_left_dims[i];
-        m_left_nocontract_strides[nocontract_idx] = lhs_strides[i];
-        if (dim_idx != i) {
-          m_lhs_inner_dim_contiguous = false;
-        }
-        if (nocontract_idx + 1 < internal::array_size<left_nocontract_t>::value) {
-          m_i_strides[nocontract_idx + 1] = m_i_strides[nocontract_idx] * eval_left_dims[i];
-        } else {
-          m_i_size = m_i_strides[nocontract_idx] * eval_left_dims[i];
-        }
-        dim_idx++;
-        nocontract_idx++;
-      }
-    }
-
-    nocontract_idx = 0;
-    for (int i = 0; i < RDims; i++) {
-      bool contracting = false;
-      // find if we are contracting on index i of right tensor
-      for (int j = 0; j < ContractDims; j++) {
-        if (eval_op_indices[j].second == i) {
-          contracting = true;
-          break;
-        }
-      }
-      if (!contracting) {
-        m_dimensions[dim_idx] = eval_right_dims[i];
-        if (nocontract_idx + 1 < internal::array_size<right_nocontract_t>::value) {
-          m_j_strides[nocontract_idx + 1] = m_j_strides[nocontract_idx] * eval_right_dims[i];
-        } else {
-          m_j_size = m_j_strides[nocontract_idx] * eval_right_dims[i];
-        }
-        m_right_nocontract_strides[nocontract_idx] = rhs_strides[i];
-        dim_idx++;
-        nocontract_idx++;
-      }
-    }
-
-    // Now compute the strides corresponding to the contracting dimensions. We
-    // assumed above that non-contracting axes are represented in the same order
-    // in the matrix as they are in the tensor. This is not the case for
-    // contracting axes. As the contracting axes must be of the same size in
-    // each tensor, we'll only look at the first tensor here.
-    m_rhs_inner_dim_contiguous = true;
-    m_rhs_inner_dim_reordered = false;
-    for (int i = 0; i < ContractDims; i++) {
-      Index left = eval_op_indices[i].first;
-      Index right = eval_op_indices[i].second;
-
-      Index size = eval_left_dims[left];
-      eigen_assert(size == eval_right_dims[right] && "Contraction axes must be same size");
-
-      if (i + 1 < static_cast<int>(internal::array_size<contract_t>::value)) {
-        m_k_strides[i + 1] = m_k_strides[i] * size;
-      } else {
-        m_k_size = m_k_strides[i] * size;
-      }
-      m_left_contracting_strides[i] = lhs_strides[left];
-      m_right_contracting_strides[i] = rhs_strides[right];
-
-      if (i > 0 && right < eval_op_indices[i - 1].second) {
-        m_rhs_inner_dim_reordered = true;
-      }
-      if (right != i) {
-        m_rhs_inner_dim_contiguous = false;
-      }
-    }
-
-    // If the layout is RowMajor, we need to reverse the m_dimensions
-    if (static_cast<int>(Layout) == static_cast<int>(RowMajor)) {
-      for (int i = 0, j = NumDims - 1; i < j; i++, j--) {
-        numext::swap(m_dimensions[i], m_dimensions[j]);
-      }
-    }
-
-    // A set of parameters that will allow output kernel to get from output
-    // tensor dimensions (i, j) into the original tensor dimensions.
-    // TODO(ezhulenev): Add parameters required to infer output tensor index for
-    // more complex contractions than 2x2 on internal dimension.
-    m_tensor_contraction_params.swapped_arguments = static_cast<int>(Layout) == RowMajor;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    m_leftImpl.evalSubExprsIfNeeded(NULL);
-    m_rightImpl.evalSubExprsIfNeeded(NULL);
-    if (data) {
-      evalTo(data);
-      return false;
-    } else {
-      m_result = static_cast<EvaluatorPointerType>(m_device.allocate(dimensions().TotalSize() * sizeof(Scalar)));
-      evalTo(m_result);
-      return true;
-    }
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType dest, EvalSubExprsCallback done) {
-    m_leftImpl.evalSubExprsIfNeededAsync(nullptr, [this, done, dest](bool) {
-      m_rightImpl.evalSubExprsIfNeededAsync(nullptr, [this, done, dest](bool) {
-        if (dest) {
-          evalToAsync(dest, [done]() { done(false); });
-        } else {
-          m_result = static_cast<EvaluatorPointerType>(m_device.allocate(dimensions().TotalSize() * sizeof(Scalar)));
-          evalToAsync(m_result, [done]() { done(true); });
-        }
-      });
-    });
-  }
-#endif  // EIGEN_USE_THREADS
-
-#ifndef TENSOR_CONTRACTION_DISPATCH
-#define TENSOR_CONTRACTION_DISPATCH(METHOD, ALIGNMENT, ARGS) \
-  if (this->m_lhs_inner_dim_contiguous) {                    \
-    if (this->m_rhs_inner_dim_contiguous) {                  \
-      if (this->m_rhs_inner_dim_reordered) {                 \
-        METHOD<true, true, true, ALIGNMENT> ARGS;            \
-      } else {                                               \
-        METHOD<true, true, false, ALIGNMENT> ARGS;           \
-      }                                                      \
-    } else {                                                 \
-      if (this->m_rhs_inner_dim_reordered) {                 \
-        METHOD<true, false, true, ALIGNMENT> ARGS;           \
-      } else {                                               \
-        METHOD<true, false, false, ALIGNMENT> ARGS;          \
-      }                                                      \
-    }                                                        \
-  } else {                                                   \
-    if (this->m_rhs_inner_dim_contiguous) {                  \
-      if (this->m_rhs_inner_dim_reordered) {                 \
-        METHOD<false, true, true, ALIGNMENT> ARGS;           \
-      } else {                                               \
-        METHOD<false, true, false, ALIGNMENT> ARGS;          \
-      }                                                      \
-    } else {                                                 \
-      if (this->m_rhs_inner_dim_reordered) {                 \
-        METHOD<false, false, true, ALIGNMENT> ARGS;          \
-      } else {                                               \
-        METHOD<false, false, false, ALIGNMENT> ARGS;         \
-      }                                                      \
-    }                                                        \
-  }
-#endif
-
-#ifndef TENSOR_CONTRACTION_ASYNC_DISPATCH
-#define TENSOR_CONTRACTION_ASYNC_DISPATCH(METHOD, DONE, ALIGNMENT, ARGS, FN) \
-  if (this->m_lhs_inner_dim_contiguous) {                                    \
-    if (this->m_rhs_inner_dim_contiguous) {                                  \
-      if (this->m_rhs_inner_dim_reordered) {                                 \
-        (new METHOD<DONE, true, true, true, ALIGNMENT> ARGS)->FN;            \
-      } else {                                                               \
-        (new METHOD<DONE, true, true, false, ALIGNMENT> ARGS)->FN;           \
-      }                                                                      \
-    } else {                                                                 \
-      if (this->m_rhs_inner_dim_reordered) {                                 \
-        (new METHOD<DONE, true, false, true, ALIGNMENT> ARGS)->FN;           \
-      } else {                                                               \
-        (new METHOD<DONE, true, false, false, ALIGNMENT> ARGS)->FN;          \
-      }                                                                      \
-    }                                                                        \
-  } else {                                                                   \
-    if (this->m_rhs_inner_dim_contiguous) {                                  \
-      if (this->m_rhs_inner_dim_reordered) {                                 \
-        (new METHOD<DONE, false, true, true, ALIGNMENT> ARGS)->FN;           \
-      } else {                                                               \
-        (new METHOD<DONE, false, true, false, ALIGNMENT> ARGS)->FN;          \
-      }                                                                      \
-    } else {                                                                 \
-      if (this->m_rhs_inner_dim_reordered) {                                 \
-        (new METHOD<DONE, false, false, true, ALIGNMENT> ARGS)->FN;          \
-      } else {                                                               \
-        (new METHOD<DONE, false, false, false, ALIGNMENT> ARGS)->FN;         \
-      }                                                                      \
-    }                                                                        \
-  }
-#endif
-
-  EIGEN_DEVICE_FUNC void evalTo(Scalar* buffer) const {
-    static_cast<const Derived*>(this)->template evalProduct<Unaligned>(buffer);
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalToCallback>
-  void evalToAsync(Scalar* buffer, EvalToCallback done) const {
-    static_cast<const Derived*>(this)->template evalProductAsync<EvalToCallback, Unaligned>(buffer, std::move(done));
-  }
-#endif  // EIGEN_USE_THREADS
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-  void evalProductSequential(Scalar* buffer) const {
-    if (this->m_j_size == 1) {
-      this->template evalGemv<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(
-          buffer);
-    } else {
-      this->template evalGemm<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment>(
-          buffer);
-    }
-  }
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-#if !defined(EIGEN_HIPCC)
-  EIGEN_DEVICE_FUNC
-#endif
-      void
-      evalGemv(Scalar* buffer) const {
-    const Index rows = m_i_size;
-    const Index cols = m_k_size;
-
-    using LhsScalar = std::remove_const_t<typename EvalLeftArgType::Scalar>;
-    using RhsScalar = std::remove_const_t<typename EvalRightArgType::Scalar>;
-    using LeftEvaluator = TensorEvaluator<EvalLeftArgType, Device>;
-    using RightEvaluator = TensorEvaluator<EvalRightArgType, Device>;
-    const int lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
-    const int rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
-    const int lhs_alignment = LeftEvaluator::IsAligned ? Aligned : Unaligned;
-    const int rhs_alignment = RightEvaluator::IsAligned ? Aligned : Unaligned;
-    using LhsMapper = internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator,
-                                                             left_nocontract_t, contract_t, lhs_packet_size,
-                                                             lhs_inner_dim_contiguous, false, lhs_alignment>;
-
-    using RhsMapper =
-        internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
-                                               contract_t, rhs_packet_size, rhs_inner_dim_contiguous,
-                                               rhs_inner_dim_reordered, rhs_alignment>;
-
-    LhsMapper lhs(m_leftImpl, m_left_nocontract_strides, m_i_strides, m_left_contracting_strides, m_k_strides);
-    RhsMapper rhs(m_rightImpl, m_right_nocontract_strides, m_j_strides, m_right_contracting_strides, m_k_strides);
-
-    const Scalar alpha(1);
-    const Index resIncr(1);
-
-    // zero out the result buffer (which must be of size at least rows * sizeof(Scalar)
-    m_device.fill(buffer, buffer + rows, Scalar(0));
-
-    internal::general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, false, RhsScalar, RhsMapper,
-                                            false>::run(rows, cols, lhs, rhs, buffer, resIncr, alpha);
-
-    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
-    m_output_kernel(OutputMapper(buffer, rows), m_tensor_contraction_params, static_cast<Index>(0),
-                    static_cast<Index>(0), rows, static_cast<Index>(1));
-  }
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-#if !defined(EIGEN_HIPCC)
-  EIGEN_DEVICE_FUNC
-#endif
-      void
-      evalGemm(Scalar* buffer) const {
-    // columns in left side, rows in right side
-    const Index k = this->m_k_size;
-    this->template evalGemmPartial<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered,
-                                   Alignment, true>(buffer, 0, k, 1);
-  }
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-  EIGEN_DEVICE_FUNC void evalGemmPartialWithoutOutputKernel(Scalar* buffer, Index k_start, Index k_end,
-                                                            int num_threads) const {
-    evalGemmPartial<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Alignment,
-                    /*use_output_kernel*/ false>(buffer, k_start, k_end, num_threads);
-  }
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment,
-            bool use_output_kernel>
-  EIGEN_DEVICE_FUNC void evalGemmPartial(Scalar* buffer, Index k_start, Index k_end, int num_threads) const {
-    eigen_assert(k_end >= k_start && k_start >= 0 && k_end <= this->m_k_size);
-    // columns in slice on left side, rows on right side
-    const Index k_slice = k_end - k_start;
-
-    // rows in left side
-    const Index m = this->m_i_size;
-
-    // columns in right side
-    const Index n = this->m_j_size;
-
-    // define data mappers for Lhs and Rhs
-    using LhsScalar = std::remove_const_t<typename EvalLeftArgType::Scalar>;
-    using RhsScalar = std::remove_const_t<typename EvalRightArgType::Scalar>;
-
-    using LeftEvaluator = TensorEvaluator<EvalLeftArgType, Device>;
-    using RightEvaluator = TensorEvaluator<EvalRightArgType, Device>;
-
-    const int lhs_packet_size = internal::unpacket_traits<typename LeftEvaluator::PacketReturnType>::size;
-    const int rhs_packet_size = internal::unpacket_traits<typename RightEvaluator::PacketReturnType>::size;
-
-    using LhsMapper =
-        internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
-                                               contract_t, lhs_packet_size, lhs_inner_dim_contiguous, false, Unaligned>;
-
-    using RhsMapper =
-        internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
-                                               contract_t, rhs_packet_size, rhs_inner_dim_contiguous,
-                                               rhs_inner_dim_reordered, Unaligned>;
-
-    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
-
-    using TensorContractionKernel =
-        internal::TensorContractionKernel<Scalar, LhsScalar, RhsScalar, Index, OutputMapper, LhsMapper, RhsMapper>;
-
-    // initialize data mappers
-    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
-                  this->m_left_contracting_strides, this->m_k_strides);
-
-    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
-                  this->m_right_contracting_strides, this->m_k_strides);
-
-    OutputMapper output(buffer, m);
-
-    // Sizes of the blocks to load in cache. See the Goto paper for details.
-    internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(
-        k_slice, m, n, num_threads);
-    const Index kc = blocking.kc();
-    const Index mc = numext::mini(m, blocking.mc());
-    const Index nc = numext::mini(n, blocking.nc());
-
-    using LhsBlock = typename TensorContractionKernel::LhsBlock;
-    using RhsBlock = typename TensorContractionKernel::RhsBlock;
-
-    LhsBlock blockA;
-    RhsBlock blockB;
-
-    TensorContractionKernel kernel(m, k_slice, n, mc, kc, nc);
-
-    using BlockMemHandle = typename TensorContractionKernel::BlockMemHandle;
-    const BlockMemHandle packed_mem = kernel.allocate(this->m_device, &blockA, &blockB);
-
-    // If a contraction kernel does not support beta, explicitly initialize
-    // output buffer with zeroes.
-    if (!TensorContractionKernel::HasBeta) {
-      this->m_device.fill(buffer, buffer + m * n, Scalar(0));
-    }
-
-    for (Index i2 = 0; i2 < m; i2 += mc) {
-      const Index actual_mc = numext::mini(i2 + mc, m) - i2;
-      for (Index k2 = k_start; k2 < k_end; k2 += kc) {
-        // make sure we don't overshoot right edge of left matrix, then pack vertical panel
-        const Index actual_kc = numext::mini(k2 + kc, k_end) - k2;
-        kernel.packLhs(&blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);
-
-        // If kernel supports beta, there is no need to initialize output
-        // buffer with zeroes.
-        const Scalar alpha = Scalar(1);
-        const Scalar beta = (TensorContractionKernel::HasBeta && k2 == k_start) ? Scalar(0) : Scalar(1);
-
-        // series of horizontal blocks
-        for (Index j2 = 0; j2 < n; j2 += nc) {
-          // make sure we don't overshoot right edge of right matrix, then pack block
-          const Index actual_nc = numext::mini(j2 + nc, n) - j2;
-          kernel.packRhs(&blockB, rhs.getSubMapper(k2, j2), actual_kc, actual_nc);
-
-          // call gebp (matrix kernel)
-          // The parameters here are copied from Eigen's GEMM implementation
-          const OutputMapper output_mapper = output.getSubMapper(i2, j2);
-          kernel.invoke(output_mapper, blockA, blockB, actual_mc, actual_kc, actual_nc, alpha, beta);
-
-          // We are done with this [i2, j2] output block.
-          if (use_output_kernel && k2 + kc >= k_end) {
-            m_output_kernel(output_mapper, m_tensor_contraction_params, i2, j2, actual_mc, actual_nc);
-          }
-        }
-      }
-    }
-
-    kernel.deallocate(this->m_device, packed_mem);
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_leftImpl.cleanup();
-    m_rightImpl.cleanup();
-
-    if (m_result != NULL) {
-      m_device.deallocate(m_result);
-      m_result = NULL;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_result[index]; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return m_result; }
-
- protected:
-  Dimensions m_dimensions;
-
-  contract_t m_k_strides;
-  contract_t m_left_contracting_strides;
-  contract_t m_right_contracting_strides;
-
-  bool m_lhs_inner_dim_contiguous;
-  bool m_rhs_inner_dim_contiguous;
-  bool m_rhs_inner_dim_reordered;
-
-  left_nocontract_t m_i_strides;
-  right_nocontract_t m_j_strides;
-  left_nocontract_t m_left_nocontract_strides;
-  right_nocontract_t m_right_nocontract_strides;
-
-  Index m_i_size;
-  Index m_j_size;
-  Index m_k_size;
-
-  TensorContractionParams m_tensor_contraction_params;
-
-  TensorEvaluator<EvalLeftArgType, Device> m_leftImpl;
-  TensorEvaluator<EvalRightArgType, Device> m_rightImpl;
-  const Device EIGEN_DEVICE_REF m_device;
-  OutputKernelType m_output_kernel;
-  EvaluatorPointerType m_result;
-};
-
-// evaluator for default device
-template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType, typename Device>
-struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>
-    : public TensorContractionEvaluatorBase<
-          TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>> {
-  using Self = TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>;
-  using Base = TensorContractionEvaluatorBase<Self>;
-
-  using XprType = TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>;
-  using Scalar = std::remove_const_t<typename XprType::Scalar>;
-  using Index = typename XprType::Index;
-  using CoeffReturnType = typename XprType::CoeffReturnType;
-  using PacketReturnType = typename PacketType<CoeffReturnType, Device>::type;
-
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-
-  // Most of the code is assuming that both input tensors are ColMajor. If the
-  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
-  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
-  // will pretend B is LHS and A is RHS.
-  using EvalLeftArgType = std::conditional_t<Layout == static_cast<int>(ColMajor), LeftArgType, RightArgType>;
-  using EvalRightArgType = std::conditional_t<Layout == static_cast<int>(ColMajor), RightArgType, LeftArgType>;
-
-  static constexpr int LDims =
-      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
-  static constexpr int RDims =
-      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
-  static constexpr int ContractDims = internal::array_size<Indices>::value;
-
-  using contract_t = array<Index, ContractDims>;
-  using left_nocontract_t = array<Index, LDims - ContractDims>;
-  using right_nocontract_t = array<Index, RDims - ContractDims>;
-
-  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
-
-  // Could we use NumDimensions here?
-  using Dimensions = DSizes<Index, NumDims>;
-
-  TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  template <int Alignment>
-  void evalProduct(Scalar* buffer) const {
-    TENSOR_CONTRACTION_DISPATCH(this->template evalProductSequential, Alignment, (buffer));
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorContractionBlocking.h b/unsupported/Eigen/src/Tensor/TensorContractionBlocking.h
deleted file mode 100644
index 7fbe30a..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContractionBlocking.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_BLOCKING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_BLOCKING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-enum { ShardByRow = 0, ShardByCol = 1 };
-
-// Default Blocking Strategy
-template <typename ResScalar, typename LhsScalar, typename RhsScalar, typename StorageIndex,
-          int ShardingType = ShardByCol>
-class TensorContractionBlocking {
- public:
-  /*
-    adding EIGEN_DEVICE_FUNC unconditionally to 'TensorContractionBlocking' constructor in `TensorContractionBlocking.h`
-      requires adding EIGEN_DEVICE_FUNC to `computeProductBlockingSizes` in `GeneralBlockPanelKernel.h`
-      which in turn, requires adding EIGEN_DEVICE_FUNC to `evaluateProductBlockingSizesHeuristic` in
-    `GeneralBlockPanelKernel.h` which in turn, requires adding EIGEN_DEVICE_FUNC to `manage_caching_sizes` in
-    `GeneralBlockPanelKernel.h` (else HIPCC will error out)
-
-    However adding EIGEN_DEVICE_FUNC to `manage_caching_sizes` in `GeneralBlockPanelKernel.h`
-    results in NVCC erroring out with the following error
-
-    ../Eigen/src/Core/products/GeneralBlockPanelKernel.h(57): error #2901:
-       dynamic initialization is not supported for function-scope static variables within a __device__/__global__
-    function
-  */
-
-#if !defined(EIGEN_HIPCC)
-  EIGEN_DEVICE_FUNC
-#endif
-  TensorContractionBlocking(StorageIndex k, StorageIndex m, StorageIndex n, StorageIndex num_threads = 1)
-      : kc_(k), mc_(m), nc_(n) {
-    if (ShardingType == ShardByCol) {
-      computeProductBlockingSizes<LhsScalar, RhsScalar, 1>(kc_, mc_, nc_, num_threads);
-    } else {
-      computeProductBlockingSizes<LhsScalar, RhsScalar, 1>(kc_, nc_, mc_, num_threads);
-    }
-
-    const int rhs_packet_size = internal::packet_traits<RhsScalar>::size;
-    kc_ = (rhs_packet_size <= 8 || kc_ <= rhs_packet_size) ? kc_ : (kc_ / rhs_packet_size) * rhs_packet_size;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE StorageIndex kc() const { return kc_; }
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE StorageIndex mc() const { return mc_; }
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE StorageIndex nc() const { return nc_; }
-
- private:
-  StorageIndex kc_;
-  StorageIndex mc_;
-  StorageIndex nc_;
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_BLOCKING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorContractionCuda.h b/unsupported/Eigen/src/Tensor/TensorContractionCuda.h
deleted file mode 100644
index 54415af..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContractionCuda.h
+++ /dev/null
@@ -1,7 +0,0 @@
-
-#if defined(__clang__) || defined(__GNUC__)
-#warning \
-    "Deprecated header file, please either include the main unsupported/Eigen/Tensor header or the respective TensorContractionGpu.h file"
-#endif
-
-#include "TensorContractionGpu.h"
diff --git a/unsupported/Eigen/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/src/Tensor/TensorContractionGpu.h
deleted file mode 100644
index eb2fa2f..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContractionGpu.h
+++ /dev/null
@@ -1,1396 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014-2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-// Copyright (C) 2015 Navdeep Jaitly <ndjaitly@google.com>
-// Copyright (C) 2014 Eric Martin <eric@ericmart.in>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_GPU_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_GPU_H
-
-#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename Scalar, typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper,
-          bool needs_edge_check>
-__device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapper lhs, const RhsMapper rhs,
-                                                                   const OutputMapper output, Scalar* lhs_shmem,
-                                                                   Scalar* rhs_shmem, const Index m_size,
-                                                                   const Index n_size, const Index k_size) {
-  const Index m_block_idx = blockIdx.x;
-  const Index n_block_idx = blockIdx.y;
-
-  const Index base_m = 64 * m_block_idx;
-  const Index base_n = 64 * n_block_idx;
-  const Index thread_x = threadIdx.x;
-  const Index thread_y = threadIdx.y;
-  const Index thread_z = threadIdx.z;
-
-  // declare and initialize 64 registers for output 8x8 block
-
-  // prefetch registers
-  Scalar lhs_pf0;
-  Scalar lhs_pf1;
-  Scalar lhs_pf2;
-  Scalar lhs_pf3;
-  Scalar lhs_pf4;
-  Scalar lhs_pf5;
-  Scalar lhs_pf6;
-  Scalar lhs_pf7;
-
-  Scalar rhs_pf0;
-  Scalar rhs_pf1;
-  Scalar rhs_pf2;
-  Scalar rhs_pf3;
-  Scalar rhs_pf4;
-  Scalar rhs_pf5;
-  Scalar rhs_pf6;
-  Scalar rhs_pf7;
-
-  // shared memory is formatted
-  // (contract idx in block, nocontract idx in block, block idx)
-  // where block idx is column major. This transposition limits the number of
-  // bank conflicts when reading the LHS. The core idea is that since the contracting
-  // index is shared by both sides, then the contracting index should be in threadIdx.x.
-
-  // On the LHS, we pad each row inside of each block with an extra element. This makes
-  // each block 8 rows of 9 elements, which is 72 elements. This gives no bank conflicts
-  // on writes and very few 2-way conflicts on reads. There is an 8x8 grid of these blocks.
-
-  // On the RHS we just add 8 padding elements to the end of each block. This gives no bank
-  // conflicts on writes and also none on reads.
-
-  // storage indices
-  const Index lhs_store_idx_base = thread_y * 72 + thread_x * 9 + thread_z;
-  const Index rhs_store_idx_base = thread_y * 72 + thread_z * 8 + thread_x;
-
-  const Index lhs_store_idx_0 = lhs_store_idx_base + 576 * 0;
-  const Index lhs_store_idx_1 = lhs_store_idx_base + 576 * 1;
-  const Index lhs_store_idx_2 = lhs_store_idx_base + 576 * 2;
-  const Index lhs_store_idx_3 = lhs_store_idx_base + 576 * 3;
-  const Index lhs_store_idx_4 = lhs_store_idx_base + 576 * 4;
-  const Index lhs_store_idx_5 = lhs_store_idx_base + 576 * 5;
-  const Index lhs_store_idx_6 = lhs_store_idx_base + 576 * 6;
-  const Index lhs_store_idx_7 = lhs_store_idx_base + 576 * 7;
-
-  const Index rhs_store_idx_0 = rhs_store_idx_base + 576 * 0;
-  const Index rhs_store_idx_1 = rhs_store_idx_base + 576 * 1;
-  const Index rhs_store_idx_2 = rhs_store_idx_base + 576 * 2;
-  const Index rhs_store_idx_3 = rhs_store_idx_base + 576 * 3;
-  const Index rhs_store_idx_4 = rhs_store_idx_base + 576 * 4;
-  const Index rhs_store_idx_5 = rhs_store_idx_base + 576 * 5;
-  const Index rhs_store_idx_6 = rhs_store_idx_base + 576 * 6;
-  const Index rhs_store_idx_7 = rhs_store_idx_base + 576 * 7;
-
-  // in the loading code, the following variables are important:
-  // thread_x: the vertical position in an 8x8 block
-  // thread_y: the vertical index of the 8x8 block in the grid
-  // thread_z: the horizontal position in an 8x8 block
-  // k: the horizontal index of the 8x8 block in the grid
-  //
-  // The k parameter is implicit (it was the loop counter for a loop that went
-  // from 0 to <8, but now that loop is unrolled in the below code.
-
-  const Index load_idx_vert = thread_x + 8 * thread_y;
-  const Index lhs_vert = base_m + load_idx_vert;
-
-#define prefetchIntoRegisters(base_k)                      \
-  {                                                        \
-    lhs_pf0 = conv(0);                                     \
-    lhs_pf1 = conv(0);                                     \
-    lhs_pf2 = conv(0);                                     \
-    lhs_pf3 = conv(0);                                     \
-    lhs_pf4 = conv(0);                                     \
-    lhs_pf5 = conv(0);                                     \
-    lhs_pf6 = conv(0);                                     \
-    lhs_pf7 = conv(0);                                     \
-                                                           \
-    rhs_pf0 = conv(0);                                     \
-    rhs_pf1 = conv(0);                                     \
-    rhs_pf2 = conv(0);                                     \
-    rhs_pf3 = conv(0);                                     \
-    rhs_pf4 = conv(0);                                     \
-    rhs_pf5 = conv(0);                                     \
-    rhs_pf6 = conv(0);                                     \
-    rhs_pf7 = conv(0);                                     \
-                                                           \
-    if (!needs_edge_check || lhs_vert < m_size) {          \
-      const Index lhs_horiz_0 = base_k + thread_z + 0 * 8; \
-      const Index lhs_horiz_1 = base_k + thread_z + 1 * 8; \
-      const Index lhs_horiz_2 = base_k + thread_z + 2 * 8; \
-      const Index lhs_horiz_3 = base_k + thread_z + 3 * 8; \
-      const Index lhs_horiz_4 = base_k + thread_z + 4 * 8; \
-      const Index lhs_horiz_5 = base_k + thread_z + 5 * 8; \
-      const Index lhs_horiz_6 = base_k + thread_z + 6 * 8; \
-      const Index lhs_horiz_7 = base_k + thread_z + 7 * 8; \
-                                                           \
-      if (!needs_edge_check || lhs_horiz_7 < k_size) {     \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
-        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
-        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
-        lhs_pf5 = lhs(lhs_vert, lhs_horiz_5);              \
-        lhs_pf6 = lhs(lhs_vert, lhs_horiz_6);              \
-        lhs_pf7 = lhs(lhs_vert, lhs_horiz_7);              \
-      } else if (lhs_horiz_6 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
-        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
-        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
-        lhs_pf5 = lhs(lhs_vert, lhs_horiz_5);              \
-        lhs_pf6 = lhs(lhs_vert, lhs_horiz_6);              \
-      } else if (lhs_horiz_5 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
-        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
-        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
-        lhs_pf5 = lhs(lhs_vert, lhs_horiz_5);              \
-      } else if (lhs_horiz_4 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
-        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
-        lhs_pf4 = lhs(lhs_vert, lhs_horiz_4);              \
-      } else if (lhs_horiz_3 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
-        lhs_pf3 = lhs(lhs_vert, lhs_horiz_3);              \
-      } else if (lhs_horiz_2 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-        lhs_pf2 = lhs(lhs_vert, lhs_horiz_2);              \
-      } else if (lhs_horiz_1 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-        lhs_pf1 = lhs(lhs_vert, lhs_horiz_1);              \
-      } else if (lhs_horiz_0 < k_size) {                   \
-        lhs_pf0 = lhs(lhs_vert, lhs_horiz_0);              \
-      }                                                    \
-    }                                                      \
-                                                           \
-    const Index rhs_vert = base_k + load_idx_vert;         \
-    if (!needs_edge_check || rhs_vert < k_size) {          \
-      const Index rhs_horiz_0 = base_n + thread_z + 0 * 8; \
-      const Index rhs_horiz_1 = base_n + thread_z + 1 * 8; \
-      const Index rhs_horiz_2 = base_n + thread_z + 2 * 8; \
-      const Index rhs_horiz_3 = base_n + thread_z + 3 * 8; \
-      const Index rhs_horiz_4 = base_n + thread_z + 4 * 8; \
-      const Index rhs_horiz_5 = base_n + thread_z + 5 * 8; \
-      const Index rhs_horiz_6 = base_n + thread_z + 6 * 8; \
-      const Index rhs_horiz_7 = base_n + thread_z + 7 * 8; \
-                                                           \
-      if (rhs_horiz_7 < n_size) {                          \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
-        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
-        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
-        rhs_pf5 = rhs(rhs_vert, rhs_horiz_5);              \
-        rhs_pf6 = rhs(rhs_vert, rhs_horiz_6);              \
-        rhs_pf7 = rhs(rhs_vert, rhs_horiz_7);              \
-      } else if (rhs_horiz_6 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
-        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
-        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
-        rhs_pf5 = rhs(rhs_vert, rhs_horiz_5);              \
-        rhs_pf6 = rhs(rhs_vert, rhs_horiz_6);              \
-      } else if (rhs_horiz_5 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
-        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
-        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
-        rhs_pf5 = rhs(rhs_vert, rhs_horiz_5);              \
-      } else if (rhs_horiz_4 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
-        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
-        rhs_pf4 = rhs(rhs_vert, rhs_horiz_4);              \
-      } else if (rhs_horiz_3 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
-        rhs_pf3 = rhs(rhs_vert, rhs_horiz_3);              \
-      } else if (rhs_horiz_2 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-        rhs_pf2 = rhs(rhs_vert, rhs_horiz_2);              \
-      } else if (rhs_horiz_1 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-        rhs_pf1 = rhs(rhs_vert, rhs_horiz_1);              \
-      } else if (rhs_horiz_0 < n_size) {                   \
-        rhs_pf0 = rhs(rhs_vert, rhs_horiz_0);              \
-      }                                                    \
-    }                                                      \
-  }
-
-#define writeRegToShmem()               \
-  lhs_shmem[lhs_store_idx_0] = lhs_pf0; \
-  rhs_shmem[rhs_store_idx_0] = rhs_pf0; \
-                                        \
-  lhs_shmem[lhs_store_idx_1] = lhs_pf1; \
-  rhs_shmem[rhs_store_idx_1] = rhs_pf1; \
-                                        \
-  lhs_shmem[lhs_store_idx_2] = lhs_pf2; \
-  rhs_shmem[rhs_store_idx_2] = rhs_pf2; \
-                                        \
-  lhs_shmem[lhs_store_idx_3] = lhs_pf3; \
-  rhs_shmem[rhs_store_idx_3] = rhs_pf3; \
-                                        \
-  lhs_shmem[lhs_store_idx_4] = lhs_pf4; \
-  rhs_shmem[rhs_store_idx_4] = rhs_pf4; \
-                                        \
-  lhs_shmem[lhs_store_idx_5] = lhs_pf5; \
-  rhs_shmem[rhs_store_idx_5] = rhs_pf5; \
-                                        \
-  lhs_shmem[lhs_store_idx_6] = lhs_pf6; \
-  rhs_shmem[rhs_store_idx_6] = rhs_pf6; \
-                                        \
-  lhs_shmem[lhs_store_idx_7] = lhs_pf7; \
-  rhs_shmem[rhs_store_idx_7] = rhs_pf7;
-
-  // declare and initialize result array
-#define res(i, j) _res_##i##j
-#define initResultRow(i)      \
-  Scalar res(i, 0) = conv(0); \
-  Scalar res(i, 1) = conv(0); \
-  Scalar res(i, 2) = conv(0); \
-  Scalar res(i, 3) = conv(0); \
-  Scalar res(i, 4) = conv(0); \
-  Scalar res(i, 5) = conv(0); \
-  Scalar res(i, 6) = conv(0); \
-  Scalar res(i, 7) = conv(0);
-
-  internal::scalar_cast_op<int, Scalar> conv;
-  initResultRow(0);
-  initResultRow(1);
-  initResultRow(2);
-  initResultRow(3);
-  initResultRow(4);
-  initResultRow(5);
-  initResultRow(6);
-  initResultRow(7);
-#undef initResultRow
-
-  for (Index base_k = 0; base_k < k_size; base_k += 64) {
-    // wait for previous iteration to finish with shmem. Despite common sense,
-    // the code is a bit faster with this here than at bottom of loop
-    __syncthreads();
-
-    prefetchIntoRegisters(base_k);
-    writeRegToShmem();
-
-#undef prefetchIntoRegisters
-#undef writeRegToShmem
-
-    // wait for shared mem packing to be done before starting computation
-    __syncthreads();
-
-    // compute 8x8 matrix product by outer product. This involves packing one column
-    // of LHS and one row of RHS into registers (takes 16 registers).
-
-#define lcol(i) _lcol##i
-    Scalar lcol(0);
-    Scalar lcol(1);
-    Scalar lcol(2);
-    Scalar lcol(3);
-    Scalar lcol(4);
-    Scalar lcol(5);
-    Scalar lcol(6);
-    Scalar lcol(7);
-
-#define rrow(j) _rrow##j
-    Scalar rrow(0);
-    Scalar rrow(1);
-    Scalar rrow(2);
-    Scalar rrow(3);
-    Scalar rrow(4);
-    Scalar rrow(5);
-    Scalar rrow(6);
-    Scalar rrow(7);
-
-    // Now x corresponds to k, y to m, and z to n
-    const Scalar* lhs_block = &lhs_shmem[thread_x + 9 * thread_y];
-    const Scalar* rhs_block = &rhs_shmem[thread_x + 8 * thread_z];
-
-#define lhs_element(i, j) lhs_block[72 * ((i) + 8 * (j))]
-#define rhs_element(i, j) rhs_block[72 * ((i) + 8 * (j))]
-
-#define loadData(i, j)         \
-  lcol(0) = lhs_element(0, j); \
-  rrow(0) = rhs_element(i, 0); \
-  lcol(1) = lhs_element(1, j); \
-  rrow(1) = rhs_element(i, 1); \
-  lcol(2) = lhs_element(2, j); \
-  rrow(2) = rhs_element(i, 2); \
-  lcol(3) = lhs_element(3, j); \
-  rrow(3) = rhs_element(i, 3); \
-  lcol(4) = lhs_element(4, j); \
-  rrow(4) = rhs_element(i, 4); \
-  lcol(5) = lhs_element(5, j); \
-  rrow(5) = rhs_element(i, 5); \
-  lcol(6) = lhs_element(6, j); \
-  rrow(6) = rhs_element(i, 6); \
-  lcol(7) = lhs_element(7, j); \
-  rrow(7) = rhs_element(i, 7);
-
-#define computeCol(j)             \
-  res(0, j) += lcol(0) * rrow(j); \
-  res(1, j) += lcol(1) * rrow(j); \
-  res(2, j) += lcol(2) * rrow(j); \
-  res(3, j) += lcol(3) * rrow(j); \
-  res(4, j) += lcol(4) * rrow(j); \
-  res(5, j) += lcol(5) * rrow(j); \
-  res(6, j) += lcol(6) * rrow(j); \
-  res(7, j) += lcol(7) * rrow(j);
-
-#define computePass(i) \
-  loadData(i, i);      \
-                       \
-  computeCol(0);       \
-  computeCol(1);       \
-  computeCol(2);       \
-  computeCol(3);       \
-  computeCol(4);       \
-  computeCol(5);       \
-  computeCol(6);       \
-  computeCol(7);
-
-    computePass(0);
-    computePass(1);
-    computePass(2);
-    computePass(3);
-    computePass(4);
-    computePass(5);
-    computePass(6);
-    computePass(7);
-
-#undef lcol
-#undef rrow
-#undef lhs_element
-#undef rhs_element
-#undef loadData
-#undef computeCol
-#undef computePass
-  }  // end loop over k
-
-  // we've now iterated over all of the large (ie width 64) k blocks and
-  // accumulated results in registers. At this point thread (x, y, z) contains
-  // the sum across all big k blocks of the product of little k block of index (x, y)
-  // with block of index (y, z). To compute the final output, we need to reduce
-  // the 8 threads over y by summation.
-#if defined(EIGEN_HIPCC) || (defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000)
-#define shuffleInc(i, j, mask) res(i, j) += __shfl_xor(res(i, j), mask)
-#else
-#define shuffleInc(i, j, mask) res(i, j) += __shfl_xor_sync(0xFFFFFFFF, res(i, j), mask)
-#endif
-
-#define reduceRow(i, mask) \
-  shuffleInc(i, 0, mask);  \
-  shuffleInc(i, 1, mask);  \
-  shuffleInc(i, 2, mask);  \
-  shuffleInc(i, 3, mask);  \
-  shuffleInc(i, 4, mask);  \
-  shuffleInc(i, 5, mask);  \
-  shuffleInc(i, 6, mask);  \
-  shuffleInc(i, 7, mask);
-
-#define reduceMatrix(mask) \
-  reduceRow(0, mask);      \
-  reduceRow(1, mask);      \
-  reduceRow(2, mask);      \
-  reduceRow(3, mask);      \
-  reduceRow(4, mask);      \
-  reduceRow(5, mask);      \
-  reduceRow(6, mask);      \
-  reduceRow(7, mask);
-
-  // actually perform the reduction, now each thread of index (_, y, z)
-  // contains the correct values in its registers that belong in the output
-  // block
-  reduceMatrix(1);
-  reduceMatrix(2);
-  reduceMatrix(4);
-
-#undef shuffleInc
-#undef reduceRow
-#undef reduceMatrix
-
-  // now we need to copy the 64 values into main memory. We can't split work
-  // among threads because all variables are in registers. There's 2 ways
-  // to do this:
-  // (1) have 1 thread do 64 writes from registers into global memory
-  // (2) have 1 thread do 64 writes into shared memory, and then 8 threads
-  //     each do 8 writes into global memory. We can just overwrite the shared
-  //     memory from the problem we just solved.
-  // (2) is slightly faster than (1) due to less branching and more ILP
-
-  // TODO: won't yield much gain, but could just use currently unused shared mem
-  //       and then we won't have to sync
-  // wait for shared mem to be out of use
-  __syncthreads();
-
-#define writeResultShmem(i, j) lhs_shmem[i + 8 * thread_y + 64 * thread_z + 512 * j] = res(i, j);
-
-#define writeRow(i)       \
-  writeResultShmem(i, 0); \
-  writeResultShmem(i, 1); \
-  writeResultShmem(i, 2); \
-  writeResultShmem(i, 3); \
-  writeResultShmem(i, 4); \
-  writeResultShmem(i, 5); \
-  writeResultShmem(i, 6); \
-  writeResultShmem(i, 7);
-
-  if (thread_x == 0) {
-    writeRow(0);
-    writeRow(1);
-    writeRow(2);
-    writeRow(3);
-    writeRow(4);
-    writeRow(5);
-    writeRow(6);
-    writeRow(7);
-  }
-#undef writeResultShmem
-#undef writeRow
-
-  const int max_i_write = numext::mini((int)((m_size - base_m - thread_y + 7) / 8), 8);
-  const int max_j_write = numext::mini((int)((n_size - base_n - thread_z + 7) / 8), 8);
-
-  if (thread_x < max_i_write) {
-    if (max_j_write == 8) {
-      // TODO: Can we trade bank conflicts for coalesced writes?
-      Scalar val0 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 0];
-      Scalar val1 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 1];
-      Scalar val2 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 2];
-      Scalar val3 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 3];
-      Scalar val4 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 4];
-      Scalar val5 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 5];
-      Scalar val6 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 6];
-      Scalar val7 = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * 7];
-
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 0) = val0;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 1) = val1;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 2) = val2;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 3) = val3;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 4) = val4;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 5) = val5;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 6) = val6;
-      output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * 7) = val7;
-    } else {
-#pragma unroll 7
-      for (int j = 0; j < max_j_write; j++) {
-        Scalar val = lhs_shmem[thread_x + 8 * thread_y + 64 * thread_z + 512 * j];
-        output(base_m + thread_y + 8 * thread_x, base_n + thread_z + 8 * j) = val;
-      }
-    }
-  }
-#undef res
-}
-
-template <typename Scalar, typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
-__global__ void
-#if defined(EIGEN_HIPCC)
-__launch_bounds__(512, 1)
-#else
-__launch_bounds__(512)
-#endif
-    EigenContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
-                           const Index n_size, const Index k_size) {
-  __shared__ Scalar lhs_shmem[72 * 64];
-  __shared__ Scalar rhs_shmem[72 * 64];
-
-  const Index m_block_idx = blockIdx.x;
-  const Index n_block_idx = blockIdx.y;
-
-  const Index base_m = 64 * m_block_idx;
-  const Index base_n = 64 * n_block_idx;
-
-  if (base_m + 63 < m_size && base_n + 63 < n_size) {
-    EigenContractionKernelInternal<Scalar, Index, LhsMapper, RhsMapper, OutputMapper, false>(
-        lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size);
-  } else {
-    EigenContractionKernelInternal<Scalar, Index, LhsMapper, RhsMapper, OutputMapper, true>(
-        lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size);
-  }
-}
-
-template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper, bool CHECK_LHS_BOUNDARY,
-          bool CHECK_RHS_BOUNDARY>
-__device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const LhsMapper lhs, const RhsMapper rhs,
-                                                                         const OutputMapper output,
-                                                                         float2 lhs_shmem2[][16],
-                                                                         float2 rhs_shmem2[][8], const Index m_size,
-                                                                         const Index n_size, const Index k_size,
-                                                                         const Index base_m, const Index base_n) {
-  // prefetch registers
-  float4 lhs_pf0, rhs_pf0;
-
-  float4 results[4];
-  const Index thread_x = threadIdx.x;
-  const Index thread_y = threadIdx.y;
-  for (int i = 0; i < 4; i++) {
-    results[i].x = results[i].y = results[i].z = results[i].w = 0;
-  }
-
-#define prefetch_lhs(reg, row, col)                                 \
-  if (!CHECK_LHS_BOUNDARY) {                                        \
-    if (col < k_size) {                                             \
-      reg = lhs.template loadPacket<float4, Unaligned>(row, col);   \
-    }                                                               \
-  } else {                                                          \
-    if (col < k_size) {                                             \
-      if (row + 3 < m_size) {                                       \
-        reg = lhs.template loadPacket<float4, Unaligned>(row, col); \
-      } else if (row + 2 < m_size) {                                \
-        reg.x = lhs(row + 0, col);                                  \
-        reg.y = lhs(row + 1, col);                                  \
-        reg.z = lhs(row + 2, col);                                  \
-      } else if (row + 1 < m_size) {                                \
-        reg.x = lhs(row + 0, col);                                  \
-        reg.y = lhs(row + 1, col);                                  \
-      } else if (row < m_size) {                                    \
-        reg.x = lhs(row + 0, col);                                  \
-      }                                                             \
-    }                                                               \
-  }
-
-  Index lhs_vert = base_m + thread_x * 4;
-
-  for (Index k = 0; k < k_size; k += 16) {
-    lhs_pf0 = internal::pset1<float4>(0);
-    rhs_pf0 = internal::pset1<float4>(0);
-
-    Index lhs_horiz = thread_y + k;
-    prefetch_lhs(lhs_pf0, lhs_vert, lhs_horiz)
-
-        Index rhs_vert = k + (thread_x % 4) * 4;
-    Index rhs_horiz0 = (thread_x >> 2) + thread_y * 4 + base_n;
-
-    if (!CHECK_RHS_BOUNDARY) {
-      if ((rhs_vert + 3) < k_size) {
-        // just CHECK_RHS_BOUNDARY
-        rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
-      } else if (rhs_vert + 2 < k_size) {
-        // just CHECK_RHS_BOUNDARY
-        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-        rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
-      } else if (rhs_vert + 1 < k_size) {
-        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-      } else if (rhs_vert < k_size) {
-        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-      }
-    } else {
-      if (rhs_horiz0 < n_size) {
-        if ((rhs_vert + 3) < k_size) {
-          rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
-        } else if ((rhs_vert + 2) < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-          rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
-        } else if ((rhs_vert + 1) < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-        } else if (rhs_vert < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        }
-      }
-    }
-    float x1, x2;
-    // TODO: The following can be a bitwise operation.
-    if ((thread_x % 8) < 4) {
-      x1 = rhs_pf0.y;
-      x2 = rhs_pf0.w;
-    } else {
-      x1 = rhs_pf0.x;
-      x2 = rhs_pf0.z;
-    }
-#if defined(EIGEN_HIPCC) || (defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000)
-    x1 = __shfl_xor(x1, 4);
-    x2 = __shfl_xor(x2, 4);
-#else
-    x1 = __shfl_xor_sync(0xFFFFFFFF, x1, 4);
-    x2 = __shfl_xor_sync(0xFFFFFFFF, x2, 4);
-#endif
-    if ((thread_x % 8) < 4) {
-      rhs_pf0.y = x1;
-      rhs_pf0.w = x2;
-    } else {
-      rhs_pf0.x = x1;
-      rhs_pf0.z = x2;
-    }
-
-    // We have 64 features.
-    // Row 0 -> times (0, 4, 8, 12, 1, 5, 9, 13) for features 0, 1.
-    // Row 1 -> times (0, 4, 8, 12, 1, 5, 9, 13) for features 2, 3.
-    // ...
-    // Row 31 -> times (0, 4, 8, 12, 1, 5, 9, 13) for features 62, 63
-    // Row 32 -> times (2, 6, 10, 14, 3, 7, 11, 15) for features 0, 1
-    // ...
-    rhs_shmem2[(thread_x >> 3) + thread_y * 2][thread_x % 8] = make_float2(rhs_pf0.x, rhs_pf0.y);
-    rhs_shmem2[(thread_x >> 3) + thread_y * 2 + 32][thread_x % 8] = make_float2(rhs_pf0.z, rhs_pf0.w);
-
-    // Row 0 (time 0) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61)
-    // Row 1 (time 1) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61)
-    // ...
-    // Row 15 (time 15) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61)
-    // Row 16 (time 0) -> features (2, 3), (6, 7), .. (30, 31), (34, 35), ..  (62, 63)
-    // ...
-
-    lhs_shmem2[thread_y][thread_x] = make_float2(lhs_pf0.x, lhs_pf0.y);
-    lhs_shmem2[thread_y + 16][thread_x] = make_float2(lhs_pf0.z, lhs_pf0.w);
-
-#define add_vals(fl1, fl2, fr1, fr2) \
-  results[0].x += fl1.x * fr1.x;     \
-  results[0].y += fl1.y * fr1.x;     \
-  results[0].z += fl2.x * fr1.x;     \
-  results[0].w += fl2.y * fr1.x;     \
-                                     \
-  results[1].x += fl1.x * fr1.y;     \
-  results[1].y += fl1.y * fr1.y;     \
-  results[1].z += fl2.x * fr1.y;     \
-  results[1].w += fl2.y * fr1.y;     \
-                                     \
-  results[2].x += fl1.x * fr2.x;     \
-  results[2].y += fl1.y * fr2.x;     \
-  results[2].z += fl2.x * fr2.x;     \
-  results[2].w += fl2.y * fr2.x;     \
-                                     \
-  results[3].x += fl1.x * fr2.y;     \
-  results[3].y += fl1.y * fr2.y;     \
-  results[3].z += fl2.x * fr2.y;     \
-  results[3].w += fl2.y * fr2.y;
-
-    __syncthreads();
-
-// Do the multiplies.
-#pragma unroll
-    for (int koff = 0; koff < 16; koff++) {
-      // 32 x threads.
-      float2 fl1 = lhs_shmem2[koff][thread_x];
-      float2 fl2 = lhs_shmem2[koff + 16][thread_x];
-
-      int start_feature = thread_y * 4;
-      float2 fr1 = rhs_shmem2[(start_feature >> 1) + 32 * ((koff % 4) / 2)][koff / 4 + (koff % 2) * 4];
-      float2 fr2 = rhs_shmem2[(start_feature >> 1) + 1 + 32 * ((koff % 4) / 2)][koff / 4 + (koff % 2) * 4];
-
-      add_vals(fl1, fl2, fr1, fr2)
-    }
-    __syncthreads();
-  }
-
-#undef prefetch_lhs
-#undef add_vals
-
-  Index horiz_base = thread_y * 4 + base_n;
-  if (!CHECK_LHS_BOUNDARY && !CHECK_RHS_BOUNDARY) {
-    for (int i = 0; i < 4; i++) {
-      output(lhs_vert, horiz_base + i) = results[i].x;
-      output(lhs_vert + 1, horiz_base + i) = results[i].y;
-      output(lhs_vert + 2, horiz_base + i) = results[i].z;
-      output(lhs_vert + 3, horiz_base + i) = results[i].w;
-    }
-  } else if (!CHECK_RHS_BOUNDARY) {
-    // CHECK LHS
-    if (lhs_vert + 3 < m_size) {
-      for (int i = 0; i < 4; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        output(lhs_vert + 2, horiz_base + i) = results[i].z;
-        output(lhs_vert + 3, horiz_base + i) = results[i].w;
-      }
-    } else if (lhs_vert + 2 < m_size) {
-      for (int i = 0; i < 4; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        output(lhs_vert + 2, horiz_base + i) = results[i].z;
-      }
-    } else if (lhs_vert + 1 < m_size) {
-      for (int i = 0; i < 4; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-      }
-    } else if (lhs_vert < m_size) {
-      for (int i = 0; i < 4; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-      }
-    }
-  } else if (!CHECK_LHS_BOUNDARY) {
-    // CHECK RHS
-    /*
-    int ncols_rem = fminf(n_size- horiz_base, 4);
-    for (int i = 0; i < ncols_rem; i++) {
-      output(lhs_vert, horiz_base + i) = results[i].x;
-      output(lhs_vert + 1, horiz_base + i) = results[i].y;
-      output(lhs_vert + 2, horiz_base + i) = results[i].z;
-      output(lhs_vert + 3, horiz_base + i) = results[i].w;
-    }*/
-    for (int i = 0; i < 4; i++) {
-      if (horiz_base + i < n_size) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        output(lhs_vert + 2, horiz_base + i) = results[i].z;
-        output(lhs_vert + 3, horiz_base + i) = results[i].w;
-      }
-    }
-  } else {
-    // CHECK both boundaries.
-    for (int i = 0; i < 4; i++) {
-      if (horiz_base + i < n_size) {
-        if (lhs_vert < m_size) output(lhs_vert, horiz_base + i) = results[i].x;
-        if (lhs_vert + 1 < m_size) output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        if (lhs_vert + 2 < m_size) output(lhs_vert + 2, horiz_base + i) = results[i].z;
-        if (lhs_vert + 3 < m_size) output(lhs_vert + 3, horiz_base + i) = results[i].w;
-      }
-    }
-  }
-}
-
-template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper, bool CHECK_LHS_BOUNDARY,
-          bool CHECK_RHS_BOUNDARY>
-__device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMapper lhs, const RhsMapper rhs,
-                                                                    const OutputMapper output, float2 lhs_shmem2[][32],
-                                                                    float2 rhs_shmem2[][8], const Index m_size,
-                                                                    const Index n_size, const Index k_size,
-                                                                    const Index base_m, const Index base_n) {
-  // prefetch registers
-  float4 lhs_pf0, lhs_pf1, lhs_pf2, lhs_pf3;
-  float4 rhs_pf0, rhs_pf1;
-
-  float4 results[8];
-  const Index thread_x = threadIdx.x;
-  const Index thread_y = threadIdx.y;
-
-  for (int i = 0; i < 8; i++) {
-    results[i].x = results[i].y = results[i].z = results[i].w = 0;
-  }
-
-  Index lhs_vert = base_m + thread_x * 4 + (thread_y % 4) * 32;
-
-  for (Index k = 0; k < k_size; k += 32) {
-    lhs_pf0 = internal::pset1<float4>(0);
-    lhs_pf1 = internal::pset1<float4>(0);
-    lhs_pf2 = internal::pset1<float4>(0);
-    lhs_pf3 = internal::pset1<float4>(0);
-
-    rhs_pf0 = internal::pset1<float4>(0);
-    rhs_pf1 = internal::pset1<float4>(0);
-
-    if (!CHECK_LHS_BOUNDARY) {
-      if ((thread_y / 4 + k + 24) < k_size) {
-        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-        lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
-        lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
-        lhs_pf3 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 24));
-      } else if ((thread_y / 4 + k + 16) < k_size) {
-        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-        lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
-        lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
-      } else if ((thread_y / 4 + k + 8) < k_size) {
-        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-        lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
-      } else if ((thread_y / 4 + k) < k_size) {
-        lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-      }
-    } else {
-      // just CHECK_LHS_BOUNDARY
-      if (lhs_vert + 3 < m_size) {
-        if ((thread_y / 4 + k + 24) < k_size) {
-          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-          lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
-          lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
-          lhs_pf3 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 24));
-        } else if ((thread_y / 4 + k + 16) < k_size) {
-          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-          lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
-          lhs_pf2 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 16));
-        } else if ((thread_y / 4 + k + 8) < k_size) {
-          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-          lhs_pf1 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k + 8));
-        } else if ((thread_y / 4 + k) < k_size) {
-          lhs_pf0 = lhs.template loadPacket<float4, Unaligned>(lhs_vert, (thread_y / 4 + k));
-        }
-      } else if (lhs_vert + 2 < m_size) {
-        if ((thread_y / 4 + k + 24) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
-          lhs_pf1.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 8));
-          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
-          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
-          lhs_pf2.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 16));
-          lhs_pf3.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 24));
-          lhs_pf3.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 24));
-          lhs_pf3.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 24));
-        } else if ((thread_y / 4 + k + 16) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
-          lhs_pf1.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 8));
-          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
-          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
-          lhs_pf2.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 16));
-        } else if ((thread_y / 4 + k + 8) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
-          lhs_pf1.z = lhs(lhs_vert + 2, (thread_y / 4 + k + 8));
-        } else if ((thread_y / 4 + k) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf0.z = lhs(lhs_vert + 2, (thread_y / 4 + k));
-        }
-      } else if (lhs_vert + 1 < m_size) {
-        if ((thread_y / 4 + k + 24) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
-          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
-          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
-          lhs_pf3.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 24));
-          lhs_pf3.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 24));
-        } else if ((thread_y / 4 + k + 16) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
-          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
-          lhs_pf2.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 16));
-        } else if ((thread_y / 4 + k + 8) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf1.y = lhs(lhs_vert + 1, (thread_y / 4 + k + 8));
-        } else if ((thread_y / 4 + k) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf0.y = lhs(lhs_vert + 1, (thread_y / 4 + k));
-        }
-      } else if (lhs_vert < m_size) {
-        if ((thread_y / 4 + k + 24) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
-          lhs_pf3.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 24));
-        } else if ((thread_y / 4 + k + 16) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-          lhs_pf2.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 16));
-        } else if ((thread_y / 4 + k + 8) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-          lhs_pf1.x = lhs(lhs_vert + 0, (thread_y / 4 + k + 8));
-        } else if ((thread_y / 4 + k) < k_size) {
-          lhs_pf0.x = lhs(lhs_vert + 0, (thread_y / 4 + k));
-        }
-      }
-    }
-    __syncthreads();
-    Index rhs_vert = k + thread_x * 4;
-    Index rhs_horiz0 = thread_y * 2 + base_n;
-    Index rhs_horiz1 = thread_y * 2 + 1 + base_n;
-    if (!CHECK_RHS_BOUNDARY) {
-      if ((rhs_vert + 3) < k_size) {
-        // just CHECK_RHS_BOUNDARY
-        rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
-        rhs_pf1 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz1);
-      } else if (rhs_vert + 2 < k_size) {
-        // just CHECK_RHS_BOUNDARY
-        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-        rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
-        rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
-        rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
-        rhs_pf1.z = rhs(rhs_vert + 2, rhs_horiz1);
-      } else if (rhs_vert + 1 < k_size) {
-        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-        rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
-        rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
-      } else if (rhs_vert < k_size) {
-        rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
-      }
-    } else {
-      if (rhs_horiz1 < n_size) {
-        if ((rhs_vert + 3) < k_size) {
-          // just CHECK_RHS_BOUNDARY
-          rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
-          rhs_pf1 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz1);
-        } else if (rhs_vert + 2 < k_size) {
-          // just CHECK_RHS_BOUNDARY
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-          rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
-          rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
-          rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
-          rhs_pf1.z = rhs(rhs_vert + 2, rhs_horiz1);
-        } else if (k + thread_x * 4 + 1 < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-          rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
-          rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
-        } else if (k + thread_x * 4 < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
-        }
-      } else if (rhs_horiz0 < n_size) {
-        if ((rhs_vert + 3) < k_size) {
-          // just CHECK_RHS_BOUNDARY
-          rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
-        } else if ((rhs_vert + 2) < k_size) {
-          // just CHECK_RHS_BOUNDARY
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-          rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
-        } else if ((rhs_vert + 1) < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-          rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
-        } else if (rhs_vert < k_size) {
-          rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
-        }
-      }
-    }
-    __syncthreads();
-    // Loaded. Do computation
-    // Row 0 -> times (0, 4, 8, .. 28) for features 0, 1.
-    // Row 1 -> times (0, 4, 8, .. 28) for features 2, 3.
-    // ..
-    // Row 31 -> times (0, 4, 8, .. 28) for features 62, 63
-    rhs_shmem2[thread_y][thread_x] = make_float2(rhs_pf0.x, rhs_pf1.x);
-    // Row 32 -> times (1, 5, 9, .. 29) for features 0, 1.
-    // Row 33 -> times (1, 5, 9, .. 29) for features 2, 3.
-    // ..
-    rhs_shmem2[thread_y + 32][thread_x] = make_float2(rhs_pf0.y, rhs_pf1.y);
-    // Row 64 -> times (2, 6, 10, .. 30) for features 0, 1.
-    // Row 65 -> times (2, 6, 10, .. 30) for features 2, 3.
-    rhs_shmem2[thread_y + 64][thread_x] = make_float2(rhs_pf0.z, rhs_pf1.z);
-    // Row 96 -> times (3, 7, 11, .. 31) for features 0, 1.
-    // Row 97 -> times (3, 7, 11, .. 31) for features 2, 3.
-    rhs_shmem2[thread_y + 96][thread_x] = make_float2(rhs_pf0.w, rhs_pf1.w);
-
-    // LHS.
-    // Row 0 (time 0) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61) .. (124, 125)
-    // Row 1 (time 1) -> features (0, 1), (4, 5), .. (28, 29), (32, 33), ..  (60, 61) .. (124, 125)
-    // ...
-    // Row 8 (time 0) -> features (2, 3), (6, 7), .. (30, 31), (34, 35), ..  (62, 63) .. (126, 127)
-    // Row 15 (time 7) -> features (2, 3), (6, 7), .. (30, 31), (34, 35), ..  (62, 63) .. (126, 127)
-
-#define add_vals(a_feat1, a_feat2, f1, f2, f3, f4) \
-  results[0].x += a_feat1.x * f1.x;                \
-  results[1].x += a_feat1.x * f1.y;                \
-  results[2].x += a_feat1.x * f2.x;                \
-  results[3].x += a_feat1.x * f2.y;                \
-  results[4].x += a_feat1.x * f3.x;                \
-  results[5].x += a_feat1.x * f3.y;                \
-  results[6].x += a_feat1.x * f4.x;                \
-  results[7].x += a_feat1.x * f4.y;                \
-                                                   \
-  results[0].y += a_feat1.y * f1.x;                \
-  results[1].y += a_feat1.y * f1.y;                \
-  results[2].y += a_feat1.y * f2.x;                \
-  results[3].y += a_feat1.y * f2.y;                \
-  results[4].y += a_feat1.y * f3.x;                \
-  results[5].y += a_feat1.y * f3.y;                \
-  results[6].y += a_feat1.y * f4.x;                \
-  results[7].y += a_feat1.y * f4.y;                \
-                                                   \
-  results[0].z += a_feat2.x * f1.x;                \
-  results[1].z += a_feat2.x * f1.y;                \
-  results[2].z += a_feat2.x * f2.x;                \
-  results[3].z += a_feat2.x * f2.y;                \
-  results[4].z += a_feat2.x * f3.x;                \
-  results[5].z += a_feat2.x * f3.y;                \
-  results[6].z += a_feat2.x * f4.x;                \
-  results[7].z += a_feat2.x * f4.y;                \
-                                                   \
-  results[0].w += a_feat2.y * f1.x;                \
-  results[1].w += a_feat2.y * f1.y;                \
-  results[2].w += a_feat2.y * f2.x;                \
-  results[3].w += a_feat2.y * f2.y;                \
-  results[4].w += a_feat2.y * f3.x;                \
-  results[5].w += a_feat2.y * f3.y;                \
-  results[6].w += a_feat2.y * f4.x;                \
-  results[7].w += a_feat2.y * f4.y;
-
-    lhs_shmem2[thread_y / 4][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf0.x, lhs_pf0.y);
-    lhs_shmem2[thread_y / 4 + 8][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf1.x, lhs_pf1.y);
-    lhs_shmem2[thread_y / 4 + 16][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf2.x, lhs_pf2.y);
-    lhs_shmem2[thread_y / 4 + 24][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf3.x, lhs_pf3.y);
-
-    lhs_shmem2[thread_y / 4 + 32][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf0.z, lhs_pf0.w);
-    lhs_shmem2[thread_y / 4 + 40][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf1.z, lhs_pf1.w);
-    lhs_shmem2[thread_y / 4 + 48][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf2.z, lhs_pf2.w);
-    lhs_shmem2[thread_y / 4 + 56][thread_x + (thread_y % 4) * 8] = make_float2(lhs_pf3.z, lhs_pf3.w);
-
-    __syncthreads();
-
-// Do the multiplies.
-#pragma unroll
-    for (int koff = 0; koff < 32; koff++) {
-      float2 a3 = lhs_shmem2[koff][thread_x + (thread_y % 4) * 8];
-      float2 a4 = lhs_shmem2[koff + 32][thread_x + (thread_y % 4) * 8];
-
-      // first feature is at (thread_y/4) * 8 last is at start + 8.
-      int start_feature = (thread_y / 4) * 8;
-
-      float2 br1 = rhs_shmem2[start_feature / 2 + (koff % 4) * 32][koff / 4];
-      float2 br2 = rhs_shmem2[start_feature / 2 + 1 + (koff % 4) * 32][koff / 4];
-      float2 br3 = rhs_shmem2[start_feature / 2 + 2 + (koff % 4) * 32][koff / 4];
-      float2 br4 = rhs_shmem2[start_feature / 2 + 3 + (koff % 4) * 32][koff / 4];
-
-      add_vals(a3, a4, br1, br2, br3, br4)
-    }
-    __syncthreads();
-  }  // end loop over k
-
-#undef add_vals
-
-  __syncthreads();
-  Index horiz_base = (thread_y / 4) * 8 + base_n;
-  if (!CHECK_LHS_BOUNDARY && !CHECK_RHS_BOUNDARY) {
-    for (int i = 0; i < 8; i++) {
-      output(lhs_vert, horiz_base + i) = results[i].x;
-      output(lhs_vert + 1, horiz_base + i) = results[i].y;
-      output(lhs_vert + 2, horiz_base + i) = results[i].z;
-      output(lhs_vert + 3, horiz_base + i) = results[i].w;
-    }
-  } else if (!CHECK_RHS_BOUNDARY) {
-    if (lhs_vert + 3 < m_size) {
-      for (int i = 0; i < 8; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        output(lhs_vert + 2, horiz_base + i) = results[i].z;
-        output(lhs_vert + 3, horiz_base + i) = results[i].w;
-      }
-    } else if (lhs_vert + 2 < m_size) {
-      for (int i = 0; i < 8; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        output(lhs_vert + 2, horiz_base + i) = results[i].z;
-      }
-    } else if (lhs_vert + 1 < m_size) {
-      for (int i = 0; i < 8; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-      }
-    } else if (lhs_vert < m_size) {
-      for (int i = 0; i < 8; i++) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-      }
-    }
-  } else if (!CHECK_LHS_BOUNDARY) {
-    // CHECK BOUNDARY_B
-    for (int i = 0; i < 8; i++) {
-      if (horiz_base + i < n_size) {
-        output(lhs_vert, horiz_base + i) = results[i].x;
-        output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        output(lhs_vert + 2, horiz_base + i) = results[i].z;
-        output(lhs_vert + 3, horiz_base + i) = results[i].w;
-      }
-    }
-  } else {
-    // CHECK both boundaries.
-    for (int i = 0; i < 8; i++) {
-      if (horiz_base + i < n_size) {
-        if (lhs_vert < m_size) output(lhs_vert, horiz_base + i) = results[i].x;
-        if (lhs_vert + 1 < m_size) output(lhs_vert + 1, horiz_base + i) = results[i].y;
-        if (lhs_vert + 2 < m_size) output(lhs_vert + 2, horiz_base + i) = results[i].z;
-        if (lhs_vert + 3 < m_size) output(lhs_vert + 3, horiz_base + i) = results[i].w;
-      }
-    }
-  }
-}
-
-template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
-__global__ void
-#if defined(EIGEN_HIPCC)
-__launch_bounds__(256, 1)
-#else
-__launch_bounds__(256)
-#endif
-    EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
-                                const Index n_size, const Index k_size) {
-  __shared__ float2 lhs_shmem[64 * 32];
-  __shared__ float2 rhs_shmem[128 * 8];
-
-  typedef float2 LHS_MEM[64][32];
-  typedef float2 RHS_MEM[128][8];
-
-  const Index m_block_idx = blockIdx.x;
-  const Index n_block_idx = blockIdx.y;
-
-  const Index base_m = 128 * m_block_idx;
-  const Index base_n = 64 * n_block_idx;
-
-  bool check_rhs = (base_n + 63) >= n_size;
-  bool check_lhs128 = (base_m + 127) >= m_size;
-
-  if (!check_rhs) {
-    if (!check_lhs128) {
-      // >= 128 rows left
-      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
-          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
-    } else {
-      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
-          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
-    }
-  } else {
-    if (!check_lhs128) {
-      // >= 128 rows left
-      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
-          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
-    } else {
-      EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
-          lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
-    }
-  }
-}
-
-template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
-__global__ void
-#if defined(EIGEN_HIPCC)
-__launch_bounds__(256, 1)
-#else
-__launch_bounds__(256)
-#endif
-    EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
-                                     const Index m_size, const Index n_size, const Index k_size) {
-  __shared__ float2 lhs_shmem[32][16];
-  __shared__ float2 rhs_shmem[64][8];
-
-  const Index m_block_idx = blockIdx.x;
-  const Index n_block_idx = blockIdx.y;
-
-  const Index base_m = 64 * m_block_idx;
-  const Index base_n = 64 * n_block_idx;
-
-  if (base_m + 63 < m_size) {
-    if (base_n + 63 < n_size) {
-      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
-          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
-    } else {
-      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
-          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
-    }
-  } else {
-    if (base_n + 63 < n_size) {
-      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
-          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
-    } else {
-      EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
-          lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
-    }
-  }
-}
-
-template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
-struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
-    : public TensorContractionEvaluatorBase<TensorEvaluator<
-          const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice> > {
-  typedef GpuDevice Device;
-
-  typedef TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device> Self;
-  typedef TensorContractionEvaluatorBase<Self> Base;
-
-  typedef TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType> XprType;
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, GpuDevice>::type PacketReturnType;
-
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-
-  // Most of the code is assuming that both input tensors are ColMajor. If the
-  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
-  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
-  // will pretend B is LHS and A is RHS.
-  typedef std::conditional_t<Layout == static_cast<int>(ColMajor), LeftArgType, RightArgType> EvalLeftArgType;
-  typedef std::conditional_t<Layout == static_cast<int>(ColMajor), RightArgType, LeftArgType> EvalRightArgType;
-
-  static constexpr int LDims =
-      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
-  static constexpr int RDims =
-      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
-  static constexpr int ContractDims = internal::array_size<Indices>::value;
-
-  typedef array<Index, LDims> left_dim_mapper_t;
-  typedef array<Index, RDims> right_dim_mapper_t;
-
-  typedef array<Index, ContractDims> contract_t;
-  typedef array<Index, LDims - ContractDims> left_nocontract_t;
-  typedef array<Index, RDims - ContractDims> right_nocontract_t;
-
-  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
-
-  typedef DSizes<Index, NumDims> Dimensions;
-
-  // typedefs needed in evalTo
-  typedef std::remove_const_t<typename EvalLeftArgType::Scalar> LhsScalar;
-  typedef std::remove_const_t<typename EvalRightArgType::Scalar> RhsScalar;
-
-  typedef TensorEvaluator<EvalLeftArgType, Device> LeftEvaluator;
-  typedef TensorEvaluator<EvalRightArgType, Device> RightEvaluator;
-
-  typedef typename LeftEvaluator::Dimensions LeftDimensions;
-  typedef typename RightEvaluator::Dimensions RightDimensions;
-
-  TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {
-    EIGEN_STATIC_ASSERT((internal::is_same<OutputKernelType, const NoOpOutputKernel>::value),
-                        GPU_TENSOR_CONTRACTION_DOES_NOT_SUPPORT_OUTPUT_KERNELS);
-  }
-
-  // We need to redefine this method to make nvcc happy
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* data) {
-    this->m_leftImpl.evalSubExprsIfNeeded(NULL);
-    this->m_rightImpl.evalSubExprsIfNeeded(NULL);
-    if (data) {
-      evalTo(data);
-      return false;
-    } else {
-      this->m_result = static_cast<Scalar*>(this->m_device.allocate(this->dimensions().TotalSize() * sizeof(Scalar)));
-      evalTo(this->m_result);
-      return true;
-    }
-  }
-
-  void evalTo(Scalar* buffer) const {
-    if (this->m_lhs_inner_dim_contiguous) {
-      if (this->m_rhs_inner_dim_contiguous) {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<true, true, true, Unaligned>(buffer);
-        } else {
-          evalTyped<true, true, false, Unaligned>(buffer);
-        }
-      } else {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<true, false, true, Unaligned>(buffer);
-        } else {
-          evalTyped<true, false, false, Unaligned>(buffer);
-        }
-      }
-    } else {
-      if (this->m_rhs_inner_dim_contiguous) {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<false, true, true, Unaligned>(buffer);
-        } else {
-          evalTyped<false, true, false, Unaligned>(buffer);
-        }
-      } else {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<false, false, true, Unaligned>(buffer);
-        } else {
-          evalTyped<false, false, false, Unaligned>(buffer);
-        }
-      }
-    }
-  }
-
-  template <typename LhsScalar, typename RhsScalar, typename Index, typename LhsMapper, typename RhsMapper,
-            typename OutputMapper>
-  struct LaunchKernels {
-    static void Run(const LhsMapper& lhs, const RhsMapper& rhs, const OutputMapper& output, Index m, Index n, Index k,
-                    const GpuDevice& device) {
-      const Index m_blocks = (m + 63) / 64;
-      const Index n_blocks = (n + 63) / 64;
-      const dim3 num_blocks(m_blocks, n_blocks, 1);
-      const dim3 block_size(8, 8, 8);
-      LAUNCH_GPU_KERNEL((EigenContractionKernel<Scalar, Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
-                        block_size, 0, device, lhs, rhs, output, m, n, k);
-    }
-  };
-
-  template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
-  struct LaunchKernels<float, float, Index, LhsMapper, RhsMapper, OutputMapper> {
-    static void Run(const LhsMapper& lhs, const RhsMapper& rhs, const OutputMapper& output, Index m, Index n, Index k,
-                    const GpuDevice& device) {
-      if (m < 768 || n < 768) {
-        const Index m_blocks = (m + 63) / 64;
-        const Index n_blocks = (n + 63) / 64;
-        const dim3 num_blocks(m_blocks, n_blocks, 1);
-        const dim3 block_size(16, 16, 1);
-        LAUNCH_GPU_KERNEL((EigenFloatContractionKernel16x16<Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
-                          block_size, 0, device, lhs, rhs, output, m, n, k);
-      } else {
-        const Index m_blocks = (m + 127) / 128;
-        const Index n_blocks = (n + 63) / 64;
-        const dim3 num_blocks(m_blocks, n_blocks, 1);
-        const dim3 block_size(8, 32, 1);
-        LAUNCH_GPU_KERNEL((EigenFloatContractionKernel<Index, LhsMapper, RhsMapper, OutputMapper>), num_blocks,
-                          block_size, 0, device, lhs, rhs, output, m, n, k);
-      }
-    }
-  };
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-  void evalTyped(Scalar* buffer) const {
-    // columns in left side, rows in right side
-    const Index k = this->m_k_size;
-    EIGEN_UNUSED_VARIABLE(k)
-
-    // rows in left side
-    const Index m = this->m_i_size;
-
-    // columns in right side
-    const Index n = this->m_j_size;
-
-    // zero out the result buffer (which must be of size at least m * n * sizeof(Scalar))
-    this->m_device.fill(buffer, buffer + m * n, Scalar(0));
-
-    typedef internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
-                                                   contract_t, 4, lhs_inner_dim_contiguous, false, Unaligned>
-        LhsMapper;
-
-    typedef internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
-                                                   contract_t, 4, rhs_inner_dim_contiguous, rhs_inner_dim_reordered,
-                                                   Unaligned>
-        RhsMapper;
-
-    typedef internal::blas_data_mapper<Scalar, Index, ColMajor> OutputMapper;
-
-    // initialize data mappers
-    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
-                  this->m_left_contracting_strides, this->m_k_strides);
-
-    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
-                  this->m_right_contracting_strides, this->m_k_strides);
-
-    OutputMapper output(buffer, m);
-
-#if defined(EIGEN_USE_HIP)
-    setGpuSharedMemConfig(hipSharedMemBankSizeEightByte);
-#else
-    setGpuSharedMemConfig(cudaSharedMemBankSizeEightByte);
-#endif
-
-    LaunchKernels<LhsScalar, RhsScalar, Index, LhsMapper, RhsMapper, OutputMapper>::Run(lhs, rhs, output, m, n, k,
-                                                                                        this->m_device);
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_USE_GPU and EIGEN_GPUCC
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_GPU_H
diff --git a/unsupported/Eigen/src/Tensor/TensorContractionMapper.h b/unsupported/Eigen/src/Tensor/TensorContractionMapper.h
deleted file mode 100644
index 2fc2102..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContractionMapper.h
+++ /dev/null
@@ -1,531 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_MAPPER_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_MAPPER_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-enum { Rhs = 0, Lhs = 1 };
-
-/*
- * Implementation of the Eigen blas_data_mapper class for tensors.
- */
-/// The make pointer class is used by sycl in order to build the mapper class on the device. For other platform the
-/// default make pointer is used which is scalar * for CoeffLoader.
-template <typename Tensor, bool HasRawAccess, template <class> class MakePointer_ = MakePointer>
-struct CoeffLoader;
-
-template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
-          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
-          template <class> class MakePointer_ = MakePointer>
-class BaseTensorContractionMapper;
-
-template <typename Tensor, bool HasRawAccess, template <class> class MakePointer_>
-struct CoeffLoader {
-  enum { DirectOffsets = false };
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffLoader(const Tensor& tensor) : m_tensor(tensor) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void offsetBuffer(typename Tensor::Index) {
-    eigen_assert(false && "unsupported");
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const typename MakePointer_<const typename Tensor::Scalar>::Type data() const {
-    eigen_assert(false && "unsupported");
-    return NULL;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename Tensor::Scalar coeff(typename Tensor::Index index) const {
-    return m_tensor.coeff(index);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Tensor::PacketReturnType packet(typename Tensor::Index index) const {
-    return m_tensor.template packet<LoadMode>(index);
-  }
-
- private:
-  const Tensor m_tensor;
-};
-
-template <typename Tensor, template <class> class MakePointer_>
-struct CoeffLoader<Tensor, true, MakePointer_> {
-  enum { DirectOffsets = true };
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffLoader(const Tensor& tensor) : m_data(tensor.data()) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void offsetBuffer(typename Tensor::Index offset) { m_data += offset; }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const typename MakePointer_<const typename Tensor::Scalar>::Type data() const {
-    return m_data;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE typename Tensor::Scalar coeff(typename Tensor::Index index) const {
-    return loadConstant(m_data + index);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Tensor::PacketReturnType packet(typename Tensor::Index index) const {
-    return internal::ploadt_ro<typename Tensor::PacketReturnType, LoadMode>(m_data + index);
-  }
-
- private:
-  using Scalar = typename Tensor::Scalar;
-
-  typename MakePointer_<const Scalar>::Type m_data;
-};
-
-template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
-          int packet_size, bool inner_dim_contiguous, int Alignment, template <class> class MakePointer_ = MakePointer>
-class SimpleTensorContractionMapper {
- public:
-  EIGEN_DEVICE_FUNC SimpleTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
-                                                  const nocontract_t& ij_strides, const contract_t& contract_strides,
-                                                  const contract_t& k_strides)
-      : m_tensor(tensor),
-        m_nocontract_strides(nocontract_strides),
-        m_ij_strides(ij_strides),
-        m_contract_strides(contract_strides),
-        m_k_strides(k_strides) {}
-
-  enum { DirectOffsets = CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_>::DirectOffsets };
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void offsetBuffer(typename Tensor::Index offset) {
-    m_tensor.offsetBuffer(offset);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void prefetch(Index /*i*/) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(Index row) const {
-    // column major assumption
-    return operator()(row, 0);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(Index row, Index col) const {
-    return m_tensor.coeff(computeIndex(row, col));
-  }
-
-#ifdef EIGEN_MULTIDIMENSIONAL_SUBSCRIPT
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator[](Index row, Index col) const { return operator()(row, col); }
-#endif
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index computeIndex(Index row, Index col) const {
-    const bool left = (side == Lhs);
-    EIGEN_UNUSED_VARIABLE(left);  // annoying bug in g++8.1: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85963
-    Index nocontract_val = left ? row : col;
-    Index linidx = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = static_cast<int>(array_size<nocontract_t>::value) - 1; i > 0; i--) {
-      const Index idx = nocontract_val / m_ij_strides[i];
-      linidx += idx * m_nocontract_strides[i];
-      nocontract_val -= idx * m_ij_strides[i];
-    }
-    if (array_size<typename Tensor::Dimensions>::value > array_size<contract_t>::value) {
-      if (side == Lhs && inner_dim_contiguous) {
-        eigen_assert(m_nocontract_strides[0] == 1);
-        linidx += nocontract_val;
-      } else {
-        linidx += nocontract_val * m_nocontract_strides[0];
-      }
-    }
-
-    Index contract_val = left ? col : row;
-    if (array_size<contract_t>::value > 0) {
-      EIGEN_UNROLL_LOOP
-      for (int i = static_cast<int>(array_size<contract_t>::value) - 1; i > 0; i--) {
-        const Index idx = contract_val / m_k_strides[i];
-        linidx += idx * m_contract_strides[i];
-        contract_val -= idx * m_k_strides[i];
-      }
-
-      if (side == Rhs && inner_dim_contiguous) {
-        eigen_assert(m_contract_strides[0] == 1);
-        linidx += contract_val;
-      } else {
-        linidx += contract_val * m_contract_strides[0];
-      }
-    }
-
-    return linidx;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexPair<Index> computeIndexPair(Index row, Index col,
-                                                                          const Index distance) const {
-    const bool left = (side == Lhs);
-    EIGEN_UNUSED_VARIABLE(left);  // annoying bug in g++8.1: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85963
-    Index nocontract_val[2] = {left ? row : col, left ? row + distance : col};
-    Index linidx[2] = {0, 0};
-    if (array_size<typename Tensor::Dimensions>::value > array_size<contract_t>::value) {
-      EIGEN_UNROLL_LOOP
-      for (int i = static_cast<int>(array_size<nocontract_t>::value) - 1; i > 0; i--) {
-        const Index idx0 = nocontract_val[0] / m_ij_strides[i];
-        const Index idx1 = nocontract_val[1] / m_ij_strides[i];
-        linidx[0] += idx0 * m_nocontract_strides[i];
-        linidx[1] += idx1 * m_nocontract_strides[i];
-        nocontract_val[0] -= idx0 * m_ij_strides[i];
-        nocontract_val[1] -= idx1 * m_ij_strides[i];
-      }
-      if (side == Lhs && inner_dim_contiguous) {
-        eigen_assert(m_nocontract_strides[0] == 1);
-        linidx[0] += nocontract_val[0];
-        linidx[1] += nocontract_val[1];
-      } else {
-        linidx[0] += nocontract_val[0] * m_nocontract_strides[0];
-        linidx[1] += nocontract_val[1] * m_nocontract_strides[0];
-      }
-    }
-
-    Index contract_val[2] = {left ? col : row, left ? col : row + distance};
-    if (array_size<contract_t>::value > 0) {
-      EIGEN_UNROLL_LOOP
-      for (int i = static_cast<int>(array_size<contract_t>::value) - 1; i > 0; i--) {
-        const Index idx0 = contract_val[0] / m_k_strides[i];
-        const Index idx1 = contract_val[1] / m_k_strides[i];
-        linidx[0] += idx0 * m_contract_strides[i];
-        linidx[1] += idx1 * m_contract_strides[i];
-        contract_val[0] -= idx0 * m_k_strides[i];
-        contract_val[1] -= idx1 * m_k_strides[i];
-      }
-
-      if (side == Rhs && inner_dim_contiguous) {
-        eigen_assert(m_contract_strides[0] == 1);
-        linidx[0] += contract_val[0];
-        linidx[1] += contract_val[1];
-      } else {
-        linidx[0] += contract_val[0] * m_contract_strides[0];
-        linidx[1] += contract_val[1] * m_contract_strides[0];
-      }
-    }
-    return IndexPair<Index>(linidx[0], linidx[1]);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index firstAligned(Index size) const {
-    // Only claim alignment when we can compute the actual stride (ie when we're
-    // dealing with the lhs with inner_dim_contiguous. This is because the
-    // matrix-vector product relies on the stride when dealing with aligned inputs.
-    return (Alignment == Aligned) && (side == Lhs) && inner_dim_contiguous ? 0 : size;
-  }
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index stride() const {
-    return ((side == Lhs) && inner_dim_contiguous && array_size<contract_t>::value > 0) ? m_contract_strides[0] : 1;
-  }
-
-  const CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_>& tensor() const { return m_tensor; }
-
-  const nocontract_t& nocontract_strides() const { return m_nocontract_strides; }
-  const nocontract_t& ij_strides() const { return m_ij_strides; }
-  const contract_t& contract_strides() const { return m_contract_strides; }
-  const contract_t& k_strides() const { return m_k_strides; }
-
- protected:
-  CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_> m_tensor;
-  const nocontract_t m_nocontract_strides;
-  const nocontract_t m_ij_strides;
-  const contract_t m_contract_strides;
-  const contract_t m_k_strides;
-};
-
-template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
-          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
-          template <class> class MakePointer_>
-class BaseTensorContractionMapper
-    : public SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                           inner_dim_contiguous, Alignment, MakePointer_> {
- public:
-  using ParentMapper = SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                                     inner_dim_contiguous, Alignment, MakePointer_>;
-
-  EIGEN_DEVICE_FUNC BaseTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
-                                                const nocontract_t& ij_strides, const contract_t& contract_strides,
-                                                const contract_t& k_strides)
-      : ParentMapper(tensor, nocontract_strides, ij_strides, contract_strides, k_strides) {}
-
-  template <typename PacketT, int AlignmentType>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-      std::enable_if_t<internal::unpacket_traits<PacketT>::size == packet_size, PacketT>
-      load(Index i, Index j) const {
-    // whole method makes column major assumption
-
-    // don't need to add offsets for now (because operator handles that)
-    // current code assumes packet size must be a multiple of 2
-    EIGEN_STATIC_ASSERT(packet_size % 2 == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    if (Tensor::PacketAccess && inner_dim_contiguous && !inner_dim_reordered) {
-      const Index index = this->computeIndex(i, j);
-      eigen_assert(this->computeIndex(i + packet_size - 1, j) == index + packet_size - 1);
-      return this->m_tensor.template packet<AlignmentType>(index);
-    }
-
-    const IndexPair<Index> indexPair = this->computeIndexPair(i, j, packet_size - 1);
-    const Index first = indexPair.first;
-    const Index lastIdx = indexPair.second;
-
-    // We can always do optimized packet reads from left hand side right now, because
-    // the vertical matrix dimension on the left hand side is never contracting.
-    // On the right hand side we need to check if the contracting dimensions may have
-    // been shuffled first.
-    if (Tensor::PacketAccess && (side == Lhs || internal::array_size<contract_t>::value <= 1 || !inner_dim_reordered) &&
-        (lastIdx - first) == (packet_size - 1)) {
-      return this->m_tensor.template packet<AlignmentType>(first);
-    }
-
-    EIGEN_ALIGN_MAX Scalar data[packet_size];
-
-    data[0] = this->m_tensor.coeff(first);
-    EIGEN_UNROLL_LOOP
-    for (Index k = 1; k < packet_size - 1; k += 2) {
-      const IndexPair<Index> internal_pair = this->computeIndexPair(i + k, j, 1);
-      data[k] = this->m_tensor.coeff(internal_pair.first);
-      data[k + 1] = this->m_tensor.coeff(internal_pair.second);
-    }
-    data[packet_size - 1] = this->m_tensor.coeff(lastIdx);
-
-    return pload<PacketT>(data);
-  }
-
-  template <typename PacketT, int AlignmentType>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-      std::enable_if_t<internal::unpacket_traits<PacketT>::size != packet_size, PacketT>
-      load(Index i, Index j) const {
-    const Index requested_packet_size = internal::unpacket_traits<PacketT>::size;
-    EIGEN_ALIGN_MAX Scalar data[requested_packet_size];
-
-    const IndexPair<Index> indexPair = this->computeIndexPair(i, j, requested_packet_size - 1);
-    const Index first = indexPair.first;
-    const Index lastIdx = indexPair.second;
-
-    data[0] = this->m_tensor.coeff(first);
-    for (Index k = 1; k < requested_packet_size - 1; k += 2) {
-      const IndexPair<Index> internal_pair = this->computeIndexPair(i + k, j, 1);
-      data[k] = this->m_tensor.coeff(internal_pair.first);
-      data[k + 1] = this->m_tensor.coeff(internal_pair.second);
-    }
-    data[requested_packet_size - 1] = this->m_tensor.coeff(lastIdx);
-
-    return pload<PacketT>(data);
-  }
-
-  template <typename PacketT, int AlignmentType>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketT loadPacket(Index i, Index j) const {
-    return this->load<PacketT, AlignmentType>(i, j);
-  }
-};
-
-template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
-          bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment, template <class> class MakePointer_>
-class BaseTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, 1, inner_dim_contiguous,
-                                  inner_dim_reordered, Alignment, MakePointer_>
-    : public SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, 1,
-                                           inner_dim_contiguous, Alignment, MakePointer_> {
- public:
-  using ParentMapper = SimpleTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, 1,
-                                                     inner_dim_contiguous, Alignment, MakePointer_>;
-
-  EIGEN_DEVICE_FUNC BaseTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
-                                                const nocontract_t& ij_strides, const contract_t& contract_strides,
-                                                const contract_t& k_strides)
-      : ParentMapper(tensor, nocontract_strides, ij_strides, contract_strides, k_strides) {}
-
-  template <typename PacketT, int>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketT loadPacket(Index i, Index j) const {
-    EIGEN_ALIGN_MAX Scalar data[1];
-    data[0] = this->m_tensor.coeff(this->computeIndex(i, j));
-    return pload<PacketT>(data);
-  }
-  template <typename PacketT, int>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketT load(Index i, Index j) const {
-    EIGEN_ALIGN_MAX Scalar data[1];
-    data[0] = this->m_tensor.coeff(this->computeIndex(i, j));
-    return pload<PacketT>(data);
-  }
-};
-
-template <typename Scalar, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
-          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
-          template <class> class MakePointer_ = MakePointer>
-class TensorContractionSubMapper {
- public:
-  using ParentMapper = BaseTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                                   inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
-  using Self = TensorContractionSubMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                          inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
-  using LinearMapper = Self;
-  using SubMapper = Self;
-
-  enum {
-    // We can use direct offsets iff the parent mapper supports then and we can compute the strides.
-    // TODO: we should also enable direct offsets for the Rhs case.
-    UseDirectOffsets =
-        ParentMapper::DirectOffsets && (side == Lhs) && inner_dim_contiguous && (array_size<contract_t>::value > 0)
-  };
-
-  EIGEN_DEVICE_FUNC TensorContractionSubMapper(const ParentMapper& base_mapper, Index vert_offset, Index horiz_offset)
-      : m_base_mapper(base_mapper), m_vert_offset(vert_offset), m_horiz_offset(horiz_offset) {
-    // Bake the offsets into the buffer used by the base mapper whenever possible. This avoids the need to recompute
-    // this offset every time we attempt to access a coefficient.
-    if (UseDirectOffsets) {
-      Index stride = m_base_mapper.stride();
-      m_base_mapper.offsetBuffer(vert_offset + horiz_offset * stride);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i) const {
-    if (UseDirectOffsets) {
-      return m_base_mapper(i, 0);
-    }
-    return m_base_mapper(i + m_vert_offset, m_horiz_offset);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Scalar operator()(Index i, Index j) const {
-    if (UseDirectOffsets) {
-      return m_base_mapper(i, j);
-    }
-    return m_base_mapper(i + m_vert_offset, j + m_horiz_offset);
-  }
-
-  template <typename PacketT>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacket(Index i) const {
-    if (UseDirectOffsets) {
-      return m_base_mapper.template loadPacket<PacketT, Alignment>(i, 0);
-    }
-    return m_base_mapper.template loadPacket<PacketT, Alignment>(i + m_vert_offset, m_horiz_offset);
-  }
-
-  template <typename PacketT>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacket(Index i, Index j) const {
-    if (UseDirectOffsets) {
-      return m_base_mapper.template loadPacket<PacketT, Alignment>(i, j);
-    }
-    return m_base_mapper.template loadPacket<PacketT, Alignment>(i + m_vert_offset, j + m_horiz_offset);
-  }
-
-  template <typename PacketT>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacketPartial(Index i, Index j, Index, Index = 0) const {
-    if (UseDirectOffsets) {
-      return m_base_mapper.template loadPacket<PacketT, Alignment>(i, j);
-    }
-    return m_base_mapper.template loadPacket<PacketT, Alignment>(i + m_vert_offset, j + m_horiz_offset);
-  }
-
-  template <typename PacketT, int AlignmentType>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT loadPacket(Index i, Index j) const {
-    if (UseDirectOffsets) {
-      return m_base_mapper.template load<PacketT, AlignmentType>(i, j);
-    }
-    return m_base_mapper.template loadPacket<PacketT, AlignmentType>(i + m_vert_offset, j + m_horiz_offset);
-  }
-
-  template <typename PacketT>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void storePacket(Index i, const PacketT& p) const {
-    if (UseDirectOffsets) {
-      m_base_mapper.storePacket(i, 0, p);
-    }
-    m_base_mapper.storePacket(i + m_vert_offset, m_horiz_offset, p);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
-    if (UseDirectOffsets) {
-      return LinearMapper(m_base_mapper, i, j);
-    }
-    return LinearMapper(m_base_mapper, i + m_vert_offset, j + m_horiz_offset);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SubMapper getSubMapper(Index i, Index j) const {
-    if (UseDirectOffsets) {
-      return SubMapper(m_base_mapper, i, j);
-    }
-    return SubMapper(m_base_mapper, i + m_vert_offset, j + m_horiz_offset);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const Index stride() const { return m_base_mapper.stride(); }
-
-  template <typename PacketT, int AlignmentType>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketT load(Index i) const {
-    EIGEN_STATIC_ASSERT((internal::is_same<PacketT, PacketT>::value), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    const int ActualAlignment = (AlignmentType == Aligned) && (Alignment == Aligned) ? Aligned : Unaligned;
-    if (UseDirectOffsets) {
-      return m_base_mapper.template loadPacket<PacketT, ActualAlignment>(i, 0);
-    }
-    return m_base_mapper.template loadPacket<PacketT, ActualAlignment>(i + m_vert_offset, m_horiz_offset);
-  }
-
-  template <typename PacketT>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool aligned(Index) const {
-    return false;
-  }
-
-  const ParentMapper& base_mapper() const { return m_base_mapper; }
-  Index vert_offset() const { return m_vert_offset; }
-  Index horiz_offset() const { return m_horiz_offset; }
-
- private:
-  ParentMapper m_base_mapper;
-  const Index m_vert_offset;
-  const Index m_horiz_offset;
-};
-
-template <typename Scalar_, typename Index, int side, typename Tensor, typename nocontract_t, typename contract_t,
-          int packet_size, bool inner_dim_contiguous, bool inner_dim_reordered, int Alignment,
-          template <class> class MakePointer_ = MakePointer>
-class TensorContractionInputMapper
-    : public BaseTensorContractionMapper<Scalar_, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                         inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_> {
- public:
-  using Scalar = Scalar_;
-  using Base = BaseTensorContractionMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                           inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
-  using SubMapper = TensorContractionSubMapper<Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size,
-                                               inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_>;
-  using VectorMapper = SubMapper;
-  using LinearMapper = SubMapper;
-
-  EIGEN_DEVICE_FUNC TensorContractionInputMapper(const Tensor& tensor, const nocontract_t& nocontract_strides,
-                                                 const nocontract_t& ij_strides, const contract_t& contract_strides,
-                                                 const contract_t& k_strides)
-      : Base(tensor, nocontract_strides, ij_strides, contract_strides, k_strides) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE SubMapper getSubMapper(Index i, Index j) const {
-    return SubMapper(*this, i, j);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LinearMapper getLinearMapper(Index i, Index j) const {
-    return LinearMapper(*this, i, j);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE VectorMapper getVectorMapper(Index i, Index j) const {
-    return VectorMapper(*this, i, j);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const CoeffLoader<Tensor, Tensor::RawAccess, MakePointer_>& get_tensor() const {
-    return Base::m_tensor;
-  }
-};
-
-template <typename T>
-struct TensorContractionInputMapperTrait;
-
-template <typename Scalar_, typename Index_, int side_, typename Tensor_, typename nocontract_t_, typename contract_t_,
-          int packet_size_, bool inner_dim_contiguous_, bool inner_dim_reordered_, int Alignment_,
-          template <class> class MakePointer_>
-struct TensorContractionInputMapperTrait<
-    TensorContractionInputMapper<Scalar_, Index_, side_, Tensor_, nocontract_t_, contract_t_, packet_size_,
-                                 inner_dim_contiguous_, inner_dim_reordered_, Alignment_, MakePointer_> > {
-  using XprType = Tensor_;
-  static const bool inner_dim_contiguous = inner_dim_contiguous_;
-  static const bool inner_dim_reordered = inner_dim_reordered_;
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_MAPPER_H
diff --git a/unsupported/Eigen/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/src/Tensor/TensorContractionSycl.h
deleted file mode 100644
index fb98d5b..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContractionSycl.h
+++ /dev/null
@@ -1,1653 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla Public License v. 2.0. If a copy of the MPL was not
-// distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-/*****************************************************************
- * TensorContractionSycl.h
- *
- * \brief:
- *  TensorContractionSycl.h, provides various tensor contraction kernel for SYCL backend
- *
- *****************************************************************/
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace TensorSycl {
-namespace internal {
-
-#ifndef EIGEN_SYCL_DISABLE_GEMV
-/*!
- * \brief TVPanelSize, a template class used for setting the panel size required for launching General TensorVector
- * contraction kernel on various hardware devices.
- *
- * \tparam Scalar: determines the element type of the tensor/vector
- *
- * \tparam StorageIndex  determines the Index type.
- *
- * \tparam NCWindow: determines the number of non-contracting element to be process by each work-group
- *
- * \tparam CFactor: determines the number of contracting element to be process by each thread
- *
- * \tparam NCFactor: determines the number of non-contracting element to be process by each thread
- */
-template <typename Scalar, typename StorageIndex, StorageIndex NCWindow, StorageIndex CFactor, StorageIndex NCFactor>
-struct TVPanelSize {
-  // LocalThreadSizeC: determines total number of thread per workgroup for the contracting dimension
-  static constexpr StorageIndex LocalThreadSizeC = EIGEN_SYCL_LOCAL_THREAD_DIM0;
-  // LocalThreadSizeNC: determines total number of thread per workgroup for the non-contracting dimension
-  static constxpr StorageIndex LocalThreadSizeNC = EIGEN_SYCL_LOCAL_THREAD_DIM1;
-  // TileSizeDimNC: determines the tile size for the non-contracting dimension
-  static constexpr StorageIndex TileSizeDimNC = NCWindow / NCFactor;
-  // TileSizeDimC: determines the tile size for the contracting dimension
-  static constexpr StorageIndex TileSizeDimC = CFactor * LocalThreadSizeNC * LocalThreadSizeC;
-  // WorkLoadPerThreadNC : determines workload per thread for loading the non-contracting dimension
-  static constexpr StorageIndex WorkLoadPerThreadNC = TileSizeDimNC / LocalThreadSizeNC;
-  // WorkLoadPerThreadC: determines workload per thread for loading the non-contracting dimension
-  static constexpr StorageIndex WorkLoadPerThreadC = TileSizeDimC / LocalThreadSizeC;
-  // BC : determines if supporting bank conflict is required
-  static constexpr bool BC = false;
-};
-#endif
-
-/*!
- * \brief TTPanelSize, a template class used for setting the panel size required for launching General Tensor Tensor
- contraction kernel on various hardware devices.
- *
- * \tparam Scalar: determines the element type of the tensor
- *
- * \tparam StorageIndex: determines the Index type.
- *
- * \tparam REG_SIZE_M: determines workload per thread for loading the M dimension This can be varied based on the
- available register on a chosen device(can be controlled by EIGEN_SYCL_REG_M macro).
- *
- * \tparam REG_SIZE_N: determines workload per thread for loading the N dimension This can be varied based on the
- available register on a chosen device(can be controlled by EIGEN_SYCL_REG_N macro).
- *
- * \tparam TSDK: determines Tile size for dimension K. The packet size is assumed to be considered
- */
-
-template <typename Scalar, typename StorageIndex, StorageIndex REG_SIZE_M, StorageIndex REG_SIZE_N, StorageIndex TSDK>
-struct TTPanelSize {
-  // TileSizeDimK: determines Tile size for dimension K. The packet size is assumed to be considered
-  static constexpr StorageIndex TileSizeDimK = TSDK;
-  // WorkLoadPerThreadM : determines workload per thread for loading the M dimension This can be varied based on the
-  // available register on a chosen device(can be controlled by EIGEN_SYCL_REG_M macro//
-#ifndef EIGEN_SYCL_REG_M
-  static constexpr StorageIndex WorkLoadPerThreadM = REG_SIZE_M;
-#else
-  static constexpr StorageIndex WorkLoadPerThreadM = EIGEN_SYCL_REG_M;
-#endif
-// WorkLoadPerThreadN : determines workload per thread for loading the N dimension This can be varied based on the
-// available register on a chosen device(can be controlled by EIGEN_SYCL_REG_N macro
-#ifndef EIGEN_SYCL_REG_N
-  static constexpr StorageIndex WorkLoadPerThreadN = REG_SIZE_N;
-#else
-  static constexpr StorageIndex WorkLoadPerThreadN = EIGEN_SYCL_REG_N;
-#endif
-  // LocalThreadSizeM: determines total number of thread per workgroup for the m dimension
-  static constexpr StorageIndex LocalThreadSizeM = EIGEN_SYCL_LOCAL_THREAD_DIM0;
-  // LocalThreadSizeN: determines total number of thread per workgroup for the n dimension
-  static constexpr StorageIndex LocalThreadSizeN = EIGEN_SYCL_LOCAL_THREAD_DIM1;
-  // TileSizeDimM: determines the tile size for the m dimension
-  static constexpr StorageIndex TileSizeDimM = LocalThreadSizeM * WorkLoadPerThreadM;
-  // TileSizeDimN: determines the tile size for the n dimension
-  static constexpr StorageIndex TileSizeDimN = LocalThreadSizeN * WorkLoadPerThreadN;
-  // LoadPerThreadLhs: determines workload per thread for loading Lhs Tensor. This must be divisible by packetsize
-  static constexpr StorageIndex LoadPerThreadLhs =
-      ((TileSizeDimK * WorkLoadPerThreadM * WorkLoadPerThreadN) / (TileSizeDimN));
-  // LoadPerThreadRhs: determines workload per thread for loading Rhs Tensor. This must be divisible by packetsize
-  static constexpr StorageIndex LoadPerThreadRhs =
-      ((TileSizeDimK * WorkLoadPerThreadM * WorkLoadPerThreadN) / (TileSizeDimM));
-  // BC : determines if supporting bank conflict is required
-  static constexpr bool BC = true;
-  // DoubleBuffer: determines if double buffering technique should be used (This can be disabled by
-  // EIGEN_SYCL_DISABLE_DOUBLE_BUFFER macro when the device does not have sufficient local memory)
-  static constexpr bool DoubleBuffer =
-#ifdef EIGEN_SYCL_DISABLE_DOUBLE_BUFFER
-      false;
-#else
-      true;
-#endif
-};
-
-/* !
- * \brief contraction_type: an enum class representing the Tensor Contraction implementation algorithm. This is used to
- * specialize the contraction algorithm based on device support for dedicated local memory.
- */
-enum class contraction_type { local, no_local };
-/* !
- * \brief data_source an enum class determining the location of the data in a memory hierarchy (global, local, private).
- */
-enum class data_source { global_mem, local_mem, private_mem };
-
-/*!
- * \brief read, a template function used for loading the data from global
- memory. This function is used to guarantee coalesced and vectorized load whenever possible
- *
- * \tparam PacketLoad: determines if the each element of this tensor block should be loaded in a packet mode
- *
- * \param is_coalesced_layout: determines whether or not the Tensor data in a memory can be access coalesced and
- vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the
- contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case
- when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.
- *
- * \tparam PacketType:  determines the type of packet
- *
- * \tparam TensorMapper: determines the input tensor mapper type
- *
- * \tparam StorageIndex: determines the Index type
-
- * \param tensorMapper: is the input tensor
- *
- * \param NCIndex: is the non-contracting dim index
- *
- * \param CIndex is the contracting dim index
- *
- * \param ld: is the leading dimension of the flattened tensor
- */
-template <bool PacketLoad, bool is_coalesced_layout, bool, typename PacketType, typename TensorMapper,
-          typename StorageIndex>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<PacketLoad, PacketType> read(
-    const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &ld) {
-  const StorageIndex row = (is_coalesced_layout) ? NCIndex : CIndex;
-  const StorageIndex col = (is_coalesced_layout) ? CIndex : NCIndex;
-  return tensorMapper.get_tensor().template packet<Unaligned>(row + (col * ld));
-}
-
-/*!
- * \brief read, special overload of read function, when the read access is not vectorized
- *
- * \tparam PacketLoad: determines if the each element of this tensor block should be loaded in a packet mode
- *
- * \param is_coalesced_layout: determines whether or not the Tensor data in a memory can be access coalesced and
-  vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the
-  contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case
-  when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.
- *
- * \tparam PacketType: determines the type of packet
- *
- * \tparam TensorMapper: determines the input tensor mapper type
- *
- * \tparam StorageIndex: determines the Index type
-
- * \param tensorMapper: is the input tensor
- *
- * \param NCIndex: is the non-contracting dim index
- *
- * \param CIndex: is the contracting dim index
- */
-template <bool PacketLoad, bool, bool IsRhs, typename PacketType, typename TensorMapper, typename StorageIndex>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!PacketLoad, PacketType> read(
-    const TensorMapper &tensorMapper, const StorageIndex &NCIndex, const StorageIndex &CIndex, const StorageIndex &) {
-  const StorageIndex row = (IsRhs) ? CIndex : NCIndex;
-  const StorageIndex col = (IsRhs) ? NCIndex : CIndex;
-  return tensorMapper(row, col);
-}
-
-/*!
- * \brief write, a template function used for storing the data to local memory. This function is used to guarantee
- * coalesced and vectorized store whenever possible.
- *
- * \tparam StorageIndex: determines the Index type
- *
- * \param ld is the leading dimension of the local memory. ld is a compile time value for the local memory
- *
- * \tparam data_source: an enum value representing if the location of the data in a memory hierarchy.
- *
- * \tparam PacketType:  determines the type of packet
- *
- * \tparam DataScalar: determines the output data type
- *
- * \param packet_data: the data to be written in the local memory
- *
- * \param ptr: a pointer to the local memory
- *
- * \param CIndex is the contracting dim index
- */
-
-template <typename StorageIndex, StorageIndex ld, data_source dt, typename PacketType, typename DataScalar>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<dt != data_source::global_mem, void> write(
-    PacketType &packet_data, DataScalar ptr) {
-  constexpr int PacketSize = Eigen::internal::unpacket_traits<PacketType>::size;
-  EIGEN_UNROLL_LOOP
-  for (int i = 0; i < PacketSize; i++) {
-    *ptr = PacketWrapper<PacketType, PacketSize>::scalarize(i, packet_data);
-    ptr += ld;
-  }
-}
-
-/*!
- * \brief Overloading the write function for storing the data to global memory, when vectorization enabled This function
- * is used to guarantee coalesced and vectorized store whenever possible.
- *
- * \tparam data_source: an enum value representing if the location of the data in a memory hierarchy.
- *
- * \tparam PacketType:  determines the type of packet
- *
- * \tparam DataScalar: determines the output data type
- *
- * \param packet_data: the data to be written in the local memory
- *
- * \param ptr: a pointer to the local memory
- */
-
-template <data_source dt, typename PacketType, typename DataScalar>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    typename std::enable_if_t<Eigen::internal::unpacket_traits<PacketType>::size != 1 && dt == data_source::global_mem,
-                              void>
-    write(PacketType &packet_data, DataScalar *ptr) {
-  ::Eigen::internal::pstoreu<DataScalar, PacketType>(ptr, packet_data);
-}
-
-/*!
- * \brief Overloading the write function for storing the data to global memory, when vectorization is disabled.
- *
- * \tparam data_source: an enum value representing if the location of the data in a memory hierarchy.
- *
- * \tparam PacketType:  determines the type of packet
- *
- * \tparam DataScalar: determines the output data type
- *
- * \param packet_data: the data to be written in the local memory
- *
- * \param ptr: a pointer to the local memory
- */
-template <data_source dt, typename PacketType, typename DataScalar>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-    typename std::enable_if_t<Eigen::internal::unpacket_traits<PacketType>::size == 1 && dt == data_source::global_mem,
-                              void>
-    write(PacketType &packet_data, DataScalar *ptr) {
-  *ptr = packet_data;
-}
-
-/*!
- * \brief check_boundary: is used to check the edge condition for non-internal blocks.
- *
- * \tparam is_internal: determines if the block is internal
- */
-template <bool is_internal>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_boundary(bool) {
-  return true;
-}
-
-/*!
- * \brief check_boundary: specialization of the check_boundary for non-internal blocks.
- *
- * \param cond: true when the data is in range. Otherwise false
- */
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_boundary<false>(bool cond) {
-  return cond;
-}
-
-/*!
- * \brief BlockProperties is a template class that provides different characteristic of a block of each Tensor processed
- * by each workgroup.
- *
- * \tparam is_transposed: iff true, determines whether or not the block of the Tensor is transposed
- *
- * \tparam packet_load_: determines if the each element of this tensor block should be loaded in a packet mode
- *
- * \tparam PacketType:  determines the type of packet
- *
- * \tparam OutType: determines the type of each element for this block of tensor. If packet load is true, it will be
- * packetType; Otherwise it will be scalar Type
- *
- * \param elements_per_access determines the size of each element based on OutType
- *
- * \param is_coalesced_layout  determines whether or not the Tensor data in a memory can be access coalesced and
- * vectorized when possible. Coalesced memory access is a key factor in Kernel performance. When a tensor is 2d and the
- * contracting dimension is 1, it is always possible to accessed tensor data coalesced and vectorized. This is the case
- * when RHS(right hand side) Tensor is transposed or when LHS(left hand side) Tensor is not transposed.
- *
- * \param nc_stride determines the stride of non-contracting dimension to access the next adjustment element within the
- * Tensor Block for each workgroup
- *
- * \param c_stride  determines the stride of contracting dimension to access the next adjustment element within the
- * Tensor Block for each workgroup
- */
-template <bool is_transposed, bool is_rhs_, bool packet_load_, typename PacketType>
-struct BlockProperties {
-  static constexpr bool packet_load = packet_load_;
-  typedef typename Eigen::internal::unpacket_traits<PacketType>::type OutScalar;
-  static constexpr bool is_rhs = is_rhs_;
-  typedef std::conditional_t<packet_load, PacketType, OutScalar> OutType;
-  static constexpr int elements_per_access = Eigen::internal::unpacket_traits<OutType>::size;
-  static constexpr bool is_coalesced_layout = !(is_transposed ^ is_rhs);
-  static constexpr int nc_stride = (is_coalesced_layout ? elements_per_access : 1);
-  static constexpr int c_stride = (is_coalesced_layout ? 1 : elements_per_access);
-};
-
-/*!
- * \brief ThreadProperties is a template class that provides each thread's properties within a workgroup.  Please see
- * the sycl-1.2.1 specification (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for the workgroup,
- * work-items
- *
- * \tparam StorageIndex: determines the StorageIndex Type
- *
- * \param linearLocalThreadId: determines the linearized location of a thread within a work-group
- *
- * \param kGroupId: determines the logical group id in a k dimension of the flattened tensor. It will be > 1 when
- * tall/skinny algorithm is used
- *
- * \param mGroupOffset: determines the logical start position of all thread within a workgroup for the m dimension of
- * the flattened tensor.
- *
- * \param kGroupOffset determines the logical start position of all thread within a workgroup for the k dimension of the
- * flattened tensor. It will be > 1 when tall/skinny algorithm is used.
- *
- * \param mLocalOffset: determines the logical start position of each thread within a workgroup for the m dimension of a
- * flattened tensor. The position determines the distance of each thread within the workgroup from each other
- * independent from their global position.
- *
- * \param nLocalOffset: determines the logical start position of each thread within a workgroup for the n dimension of a
- * flattened tensor. The position determines the distance of each thread within the workgroup from each other
- * independent from their global position.
- *
- * \param mGlobalOffset: determines the logical start position of each thread a thread for the m dimension on a
- * flattened tensor
- *
- * \param nGlobalOffset: determines the logical start position of each thread a thread for the n dimension on a
- * flattened tensor
- *
- * \param kSize : determine the number of the k elements of the flattened Tensor to be processed by each thread for the
- * given tensor block. This is !=K dimension of Flattened Tensor when Tall/Skinny matrix is used.
- *
- * \param is_internal : this will determined if the thread within the work-group computes an internal block of tensor or
- * the edge blocks. When it is internal, there is no need to check the boundaries and all the if stantement can be
- * resolve by compiler.
- */
-template <typename StorageIndex>
-struct ThreadProperties {
-  const StorageIndex linearLocalThreadId;
-  const StorageIndex kGroupId;
-  const StorageIndex mGroupOffset;
-  const StorageIndex nGroupOffset;
-  const StorageIndex kGroupOffset;
-  const StorageIndex mLocalOffset;
-  const StorageIndex nLocalOffset;
-  const StorageIndex mGlobalOffset;
-  const StorageIndex nGlobalOffset;
-  StorageIndex kSize;
-  const bool is_internal;
-  // this is used to adjust the last block
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ThreadProperties(
-      const StorageIndex linearLocalThreadId_, const StorageIndex kGroupId_, const StorageIndex mGroupOffset_,
-      const StorageIndex nGroupOffset_, const StorageIndex kGroupOffset_, const StorageIndex mLocalOffset_,
-      const StorageIndex nLocalOffset_, const StorageIndex mGlobalOffset_, const StorageIndex nGlobalOffset_,
-      StorageIndex kSize_, const bool is_internal_)
-      : linearLocalThreadId(linearLocalThreadId_),
-        kGroupId(kGroupId_),
-        mGroupOffset(mGroupOffset_),
-        nGroupOffset(nGroupOffset_),
-        kGroupOffset(kGroupOffset_),
-        mLocalOffset(mLocalOffset_),
-        nLocalOffset(nLocalOffset_),
-        mGlobalOffset(mGlobalOffset_),
-        nGlobalOffset(nGlobalOffset_),
-        kSize(kSize_),
-        is_internal(is_internal_) {}
-};
-
-/*!
- * \brief TensorContractionKernel is a template class that provides Tensor -Tensor contraction operation.
- *
- * \tparam OutScalar: determines the output scalar type
- *
- * \tparam LhsScalar: determines the left-hand-side scalar type
- *
- * \tparam RhsScalar: determines the right-hand-side scalar type
- *
- * \tparam OutAccessor: determines the sycl accessor type for out put (please see the sycl-1.2.1 specification
- (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for accessor definition)
- *
- * \tparam LhsMapper determines the tensor contraction mapper type for left-hand-side matrix
- *
- * \tparam RhsMapper determines the tensor contraction mapper type for right-hand-side matrix
- *
- * \tparam StorageIndex: determines the StorageIndex Type
- *
- * \tparam Properties: determines the Contraction Panel properties
- *
- * \tparam TripleDim: determines the M, K, N dimensions for the flatten tensors in order to treat them as a matrix
- *
- * \tparam Vectorizable: determines whether or not the vectorization is enabled for the Eigen expression.
- *
- * \tparam input_mapper_properties : determine if the input tensors are matrix. If they are matrix, special memory
- access is used to guarantee that always the memory access are coalesced.
- *
- * \tparam IsFinal : determine if this is the final kernel. If so, the result will be written in a final output.
- Otherwise, the result of contraction will be written iin a temporary buffer. This is the case when Tall/Skinny
- contraction is used. So in this case, a final reduction step is required to compute final output.
-
- * \tparam contraction_tp: it is an enum value representing whether the local memory/no local memory implementation of
- the algorithm to be used
- *
- * \param scratch: local memory containing tiles of LHS and RHS tensors for each work-group
- *
- * \param lhs: determines the left-hand-side flattened tensor (tensor mapper)
- *
- * \param rhs: determines the right-hand-side flattened tensor (tensor mapper)
- *
- * \param out_res: determines the output tensor containing the contraction result
- *
- * \param groupSizeM: a logical number determining the number of work-group for m dimension
- *
- * \param groupSizeN: a logical number determining the number of work-group for n dimension
- *
- * \param numTiles: determines total number of tiles on the k dimension
- *
- * \param TripleDim: determines the M, K, N dimensions for the flatten tensors in order to treat them as a matrix
- */
-template <typename OutScalar, typename LhsScalar, typename RhsScalar, typename OutAccessor, typename LhsMapper,
-          typename RhsMapper, typename StorageIndex, typename Properties, typename TripleDim, bool Vectorizable,
-          typename input_mapper_properties, bool IsFinal, contraction_type contraction_tp>
-class TensorContractionKernel {
- public:
-  typedef typename Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketReturnType
-      PacketReturnType;
-  static constexpr int PacketSize =
-      Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketSize;
-  static constexpr bool is_lhs_transposed =
-      !::Eigen::internal::TensorContractionInputMapperTrait<LhsMapper>::inner_dim_contiguous;
-  static constexpr bool is_rhs_transposed =
-      !::Eigen::internal::TensorContractionInputMapperTrait<RhsMapper>::inner_dim_contiguous;
-
-  typedef BlockProperties<is_lhs_transposed, false, input_mapper_properties::is_lhs_matrix && Vectorizable,
-                          PacketReturnType>
-      LHSBlockProperties;
-
-  typedef BlockProperties<is_rhs_transposed, true, input_mapper_properties::is_rhs_matrix && Vectorizable,
-                          PacketReturnType>
-      RHSBlockProperties;
-
-  static constexpr StorageIndex NStride =
-      contraction_tp == contraction_type::local ? Properties::WorkLoadPerThreadN : RHSBlockProperties::nc_stride;
-
-  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> Scratch;
-  typedef cl::sycl::multi_ptr<OutScalar, cl::sycl::access::address_space::local_space> local_ptr;
-  typedef OutScalar * /*cl::sycl::multi_ptr<OutScalar, cl::sycl::access::address_space::private_space>*/ private_ptr;
-  typedef std::conditional_t<contraction_tp == contraction_type::local, local_ptr, private_ptr> tile_ptr;
-  static constexpr StorageIndex LSDL = contraction_tp == contraction_type::local
-                                           ? Properties::TileSizeDimM + Properties::BC
-                                           : Properties::WorkLoadPerThreadM;
-  static constexpr StorageIndex LSDR = contraction_tp == contraction_type::local
-                                           ? Properties::TileSizeDimN + Properties::BC
-                                           : Properties::WorkLoadPerThreadN;
-  static constexpr StorageIndex LocalOffset = Properties::LocalThreadSizeM * Properties::LocalThreadSizeN;
-
-  /**
-   * \brief MemHolder this is a place holder struct for creating memory hierarchy in SYCL. Inside SYCL kernel it is not
-   * allowed to have dynamic memory allocation. While the local memory is created outside of the kernel and passed to
-   * the kernel as an accessor, the private memory can only allowed to be allocated statically. Since we are abstracting
-   * the TiledMemory for both local and private memory, the MemHolder structs is used as a helper to abstract out
-   * different type of memory needed when local/no_local memory computation is called.
-   *
-   * \tparam contraction_type: it is an enum value representing whether the local memory/no local memory implementation
-   of the algorithm to be used
-   * \tparam the private memory size
-   * \param ptr the tile memory pointer type
-   */
-  template <contraction_type, StorageIndex>
-  struct MemHolder {
-    tile_ptr ptr;
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE MemHolder(local_ptr block_start_ptr) : ptr(block_start_ptr) {}
-  };
-  /**
-   * \brief specialization of memHolder class when no local memory kernel is used.
-   */
-  template <StorageIndex MemSize>
-  struct MemHolder<contraction_type::no_local, MemSize> {
-    OutScalar ptr[MemSize] = {OutScalar{0}};
-  };
-  /**
-   * \brief TiledMemory: contains required memory pointer for loading  each tile of the TensorContraction panel from
-   * global memory to local/private memory when local/no_local algorithm used.
-   *
-   * \param lhs_scratch_extract : determines the LHS tile memory. It is either private or local memory based on the
-   * selected contraction_type.
-   *
-   * \param rhs_scratch_extract : determines the RHS tile memory. It is either private or local memory based on the
-   * selected contraction_type.
-   *
-   * \param lhs_extract_index: determines the position of each thread on a local memory for lhs input. When private
-   * memory is used this is set to zero as this is not applicable in case of private memory.
-   *
-   * \param rhs_extract_index: determines the position of each thread on a local memory for rhs input. When private
-   * memory is used this is set to zero as this is not applicable in case of private memory.
-   *
-   * \param lhs_scratch_compute : determines the  location to load for computation for lhs_local memory. This is the
-   * same as lhs_scratch_extract for private memory.
-   *
-   * \param rhs_scratch_compute : determines the  location to load for computation for rhs_local memory. This is the
-   * same as rhs_scratch_extract for private memory.
-   */
-  struct TiledMemory {
-    MemHolder<contraction_tp, Properties::WorkLoadPerThreadM * Properties::TileSizeDimK> lhs_scratch_extract;
-    MemHolder<contraction_tp, Properties::WorkLoadPerThreadN * Properties::TileSizeDimK> rhs_scratch_extract;
-    tile_ptr lhs_scratch_ptr_compute;
-    tile_ptr rhs_scratch_ptr_compute;
-    const std::pair<StorageIndex, StorageIndex> lhs_extract_index;
-    const std::pair<StorageIndex, StorageIndex> rhs_extract_index;
-    template <contraction_type tp = contraction_tp>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TiledMemory(const ThreadProperties<StorageIndex> &, local_ptr,
-                                                      std::enable_if_t<tp == contraction_type::no_local> * = 0)
-        : lhs_scratch_extract{},
-          rhs_scratch_extract{},
-          lhs_scratch_ptr_compute(lhs_scratch_extract.ptr),
-          rhs_scratch_ptr_compute(rhs_scratch_extract.ptr),
-          lhs_extract_index(std::pair<StorageIndex, StorageIndex>(StorageIndex{0}, StorageIndex{0})),
-          rhs_extract_index(std::pair<StorageIndex, StorageIndex>(StorageIndex{0}, StorageIndex{0})) {}
-
-    template <contraction_type tp = contraction_tp>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TiledMemory(const ThreadProperties<StorageIndex> &thread_properties,
-                                                      local_ptr block_start_ptr,
-                                                      std::enable_if_t<tp == contraction_type::local> * = 0)
-        : lhs_scratch_extract{block_start_ptr},
-          rhs_scratch_extract{lhs_scratch_extract.ptr +
-                              ((Properties::DoubleBuffer + 1) * LSDL * Properties::TileSizeDimK)},
-          lhs_scratch_ptr_compute(lhs_scratch_extract.ptr + thread_properties.mLocalOffset),
-          rhs_scratch_ptr_compute(rhs_scratch_extract.ptr + thread_properties.nLocalOffset),
-          lhs_extract_index(
-              local_id_extract<LHSBlockProperties, Properties::TileSizeDimM>(thread_properties.linearLocalThreadId)),
-          rhs_extract_index(
-              local_id_extract<RHSBlockProperties, Properties::TileSizeDimN>(thread_properties.linearLocalThreadId)) {}
-  };
-
-  Scratch scratch;
-  const LhsMapper lhs;
-  const RhsMapper rhs;
-  OutAccessor out_res;
-  const StorageIndex groupSizeM;
-  const StorageIndex groupSizeN;
-  const StorageIndex numTiles;
-  const TripleDim triple_dim;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionKernel(Scratch scratch_, const LhsMapper lhs_,
-                                                                const RhsMapper rhs_, OutAccessor out_res_,
-                                                                const StorageIndex groupSizeM_,
-                                                                const StorageIndex groupSizeN_,
-                                                                const StorageIndex numTiles_,
-                                                                const TripleDim triple_dim_)
-      : scratch(scratch_),
-        lhs(lhs_),
-        rhs(rhs_),
-        out_res(out_res_),
-        groupSizeM(groupSizeM_),
-        groupSizeN(groupSizeN_),
-        numTiles(numTiles_),
-        triple_dim(triple_dim_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionKernel(Scratch scratch_, const LhsMapper lhs_,
-                                                                const RhsMapper rhs_, OutAccessor out_res_,
-                                                                const StorageIndex groupSizeM_,
-                                                                const StorageIndex numTiles_,
-                                                                const TripleDim triple_dim_)
-      : TensorContractionKernel(scratch_, lhs_, rhs_, out_res_, groupSizeM_, 1, numTiles_, triple_dim_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
-    const StorageIndex linearLocalThreadId = itemID.get_local_id(0);
-    const StorageIndex nLocalThreadId = linearLocalThreadId / Properties::LocalThreadSizeM;
-    const StorageIndex mLocalThreadId = linearLocalThreadId % Properties::LocalThreadSizeM;
-    const StorageIndex mGroupId = itemID.get_group(0) % groupSizeM;
-    const StorageIndex tmp = itemID.get_group(0) / groupSizeM;
-    const StorageIndex nGroupId = IsFinal ? tmp : tmp % groupSizeN;
-    const StorageIndex kGroupId = IsFinal ? 0 : tmp / groupSizeN;
-    const StorageIndex mGroupOffset = mGroupId * Properties::TileSizeDimM;
-    const StorageIndex nGroupOffset = nGroupId * Properties::TileSizeDimN;
-    const StorageIndex mLocalOffset = PacketSize * mLocalThreadId;
-    const StorageIndex nLocalOffset = NStride * nLocalThreadId;
-    const StorageIndex mGlobalOffset = mGroupOffset + mLocalOffset;
-    const StorageIndex nGlobalOffset = nGroupOffset + nLocalOffset;
-
-    const StorageIndex kSizePerWG = IsFinal ? triple_dim.K : numTiles * Properties::TileSizeDimK;
-    StorageIndex kGroupOffset = kGroupId * kSizePerWG;
-    const bool is_internal = triple_dim.M - mGroupOffset >= Properties::TileSizeDimM &&
-                             triple_dim.N - nGroupOffset >= Properties::TileSizeDimN &&
-                             triple_dim.K - kGroupOffset >= kSizePerWG;
-    // this is used to adjust the last block
-    StorageIndex kSize = IsFinal ? triple_dim.K : std::min(kSizePerWG, triple_dim.K - kGroupOffset);
-    // This is used to find out the lats K offset so that kGroupOffset -kSize can compute the coffset for loading to
-    // tile
-    kGroupOffset += kSize;
-
-    auto thread_properties =
-        ThreadProperties<StorageIndex>(linearLocalThreadId, kGroupId, mGroupOffset, nGroupOffset, kGroupOffset,
-                                       mLocalOffset, nLocalOffset, mGlobalOffset, nGlobalOffset, kSize, is_internal);
-
-    auto out_ptr = out_res + (IsFinal ? 0 : thread_properties.kGroupId * triple_dim.M * triple_dim.N);
-
-    (thread_properties.is_internal) ? compute_panel<true>(itemID, thread_properties, out_ptr)
-                                    : compute_panel<false>(itemID, thread_properties, out_ptr);
-  }
-  // The compute block computes the contraction operation private block for each thread and store the result in the
-  // privateRes memory of Each computation the compute block function is independent of local and no local concepts as
-  // it only compute the block on each thread's private memory space
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_block_per_tile(OutScalar *lhs_block_ptr, OutScalar *rhs_block_ptr,
-                                                                    PacketReturnType *privateRes) const {
-    StorageIndex idx = 0;
-    constexpr StorageIndex lhs_stride =
-        contraction_tp == contraction_type::local ? (PacketSize * Properties::LocalThreadSizeM) : 1;
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex wLPTN = 0; wLPTN < Properties::WorkLoadPerThreadN; wLPTN++) {
-      auto rhsPacket = PacketReturnType{*(rhs_block_ptr + wLPTN)};
-      StorageIndex lhs_index = 0;
-      EIGEN_UNROLL_LOOP
-      for (StorageIndex wLPTM = 0; wLPTM < Properties::WorkLoadPerThreadM / PacketSize; wLPTM++) {
-        PacketReturnType lhsPack{};
-        Eigen::TensorSycl::internal::PacketWrapper<PacketReturnType, PacketSize>::set_packet(lhsPack,
-                                                                                             lhs_block_ptr + lhs_index);
-        privateRes[idx] = ::Eigen::internal::pmadd(lhsPack, rhsPacket, privateRes[idx]);
-
-        lhs_index += lhs_stride;
-        idx++;
-      }
-    }
-  }
-  // The store function write the computed contraction operation in the private memory of each thread to the global
-  // memory. The store function is independent of local and no local concepts s that it can be abstract out in the base
-  // class.
-  template <bool is_internal_block, StorageIndex PrivateNStride, typename OutPtr>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void store(OutPtr *out_ptr, PacketReturnType *privateRes,
-                                                   StorageIndex mGlobalOffset, StorageIndex nGlobalOffset) const {
-    auto chk_bound = [&](const StorageIndex &mIndex, const StorageIndex &nIndex) EIGEN_DEVICE_FUNC {
-      return (mIndex + PacketSize - 1 < triple_dim.M && nGlobalOffset + nIndex < triple_dim.N);
-    };
-    // when local memory is not used M and N are both accessed in a coalesced way. However, when local memory is
-    // available the k*N is transposed in the local to N*K therefore, each blocks operates on blockId*
-    // WorkLoadPerThreadN slice of N
-    constexpr StorageIndex GlobalNStride = contraction_tp == contraction_type::local ? 1 : Properties::LocalThreadSizeN;
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex wLPTN = 0; wLPTN < Properties::WorkLoadPerThreadN / PrivateNStride; wLPTN++) {
-      // output leading dimension
-      StorageIndex outputLD = 0;
-      // When local memory is used the PrivateNstride is always 1 because the coalesced access on N is loaded into Local
-      // memory and extracting from local to global is the same as no transposed version. However, when local memory is
-      // not used and RHS is transposed we packetize the load for RHS.
-      EIGEN_UNROLL_LOOP
-      for (StorageIndex nId = 0; nId < PrivateNStride; nId++) {
-        StorageIndex globalRow = mGlobalOffset;
-        EIGEN_UNROLL_LOOP
-        for (StorageIndex wLPTM = 0; wLPTM < Properties::WorkLoadPerThreadM / PacketSize; wLPTM++) {
-          PacketReturnType privetOut = privateRes[wLPTM];
-          if (check_boundary<is_internal_block>(chk_bound(globalRow, nId))) {
-            // Store the final results in C. The C matrix has always M as a first StorageIndex and N as a second
-            // StorageIndex Therefore it is always coalesced layout
-            write<data_source::global_mem>(privetOut, out_ptr + outputLD + globalRow);
-          } else {
-            EIGEN_UNROLL_LOOP
-            for (StorageIndex mId = 0; mId < PacketSize; mId++) {
-              StorageIndex mOffset = globalRow + mId;
-              if (mOffset < triple_dim.M && (nGlobalOffset + nId < triple_dim.N)) {
-                out_ptr[mOffset + outputLD] =
-                    Eigen::TensorSycl::internal::PacketWrapper<PacketReturnType, PacketSize>::scalarize(mId, privetOut);
-              }
-            }
-          }
-          globalRow += (PacketSize * Properties::LocalThreadSizeM);
-        }
-        outputLD += triple_dim.M;
-        privateRes += Properties::WorkLoadPerThreadM / PacketSize;
-      }
-      out_ptr += (GlobalNStride * outputLD);
-
-      nGlobalOffset += (PrivateNStride * GlobalNStride);
-    }
-  }
-  // when no local memory is used the following extract_block will be enabled
-  template <typename InputBlockProperties, bool is_internal_block, typename Input, typename PrivateReg,
-            contraction_type contract_tp = contraction_tp>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<contract_tp == contraction_type::no_local> extract_block(
-      const Input &inpt, PrivateReg private_ptr, const std::pair<StorageIndex, StorageIndex> &,
-      const StorageIndex &ncOffset, const StorageIndex cOffset) const {
-    constexpr StorageIndex LocalThreadSizeNC =
-        InputBlockProperties::is_rhs ? Properties::LocalThreadSizeN : Properties::LocalThreadSizeM;
-    constexpr StorageIndex WorkLoadPerThreadNC =
-        InputBlockProperties::is_rhs ? Properties::WorkLoadPerThreadN : Properties::WorkLoadPerThreadM;
-    const StorageIndex &NC = InputBlockProperties::is_rhs ? triple_dim.N : triple_dim.M;
-
-    auto chk_bound = [&](const StorageIndex &CIndex, const StorageIndex &NCIndex) EIGEN_DEVICE_FUNC {
-      return ((CIndex + InputBlockProperties::c_stride - 1 < triple_dim.K) &&
-              (NCIndex + InputBlockProperties::nc_stride - 1 < NC));
-    };
-    const StorageIndex ld = InputBlockProperties::is_coalesced_layout ? NC : triple_dim.K;
-    StorageIndex cIndex = cOffset;
-
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex cId = 0; cId < Properties::TileSizeDimK / InputBlockProperties::c_stride; cId++) {
-      StorageIndex ncIndex = ncOffset;
-      EIGEN_UNROLL_LOOP
-      for (StorageIndex ncId = 0; ncId < WorkLoadPerThreadNC / InputBlockProperties::nc_stride; ncId++) {
-        if (check_boundary<is_internal_block>(chk_bound(cIndex, ncIndex))) {
-          auto val =
-              read<InputBlockProperties::packet_load, InputBlockProperties::is_coalesced_layout,
-                   InputBlockProperties::is_rhs, typename InputBlockProperties::OutType>(inpt, ncIndex, cIndex, ld);
-
-          write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : WorkLoadPerThreadNC),
-                data_source::private_mem>(val, private_ptr);
-        } else {
-          EIGEN_UNROLL_LOOP
-          for (StorageIndex i = 0; i < InputBlockProperties::elements_per_access; i++) {
-            const StorageIndex ncInd = ncIndex + (InputBlockProperties::is_coalesced_layout ? i : 0);
-            const StorageIndex cInd = cIndex + (InputBlockProperties::is_coalesced_layout ? 0 : i);
-            OutScalar val =
-                (ncInd < NC && cInd < triple_dim.K)
-                    ? read<false, InputBlockProperties::is_coalesced_layout, InputBlockProperties::is_rhs, OutScalar>(
-                          inpt, ncInd, cInd, ld)
-                    : OutScalar(0);
-            write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : WorkLoadPerThreadNC),
-                  data_source::private_mem>(
-                val, private_ptr + (InputBlockProperties::is_coalesced_layout ? i : 0) +
-                         ((InputBlockProperties::is_coalesced_layout ? 0 : i) * WorkLoadPerThreadNC));
-          }
-        }
-
-        // if it is lhs we have to load it packetised when the packet size is > 1, because the output is coalesced. So
-        // even if M is not accessed in a coalesced mode, we have to load packet_size number of m per thread.
-        ncIndex = (!InputBlockProperties::is_rhs && InputBlockProperties::nc_stride == 1 && PacketSize != 1)
-                      ? ncOffset + (ncId + 1) % PacketSize + ((ncId + 1) / PacketSize) * LocalThreadSizeNC
-                      : (ncIndex + InputBlockProperties::nc_stride * LocalThreadSizeNC);
-        private_ptr += InputBlockProperties::nc_stride;
-      }
-      // the previous for loop ( private_ptr += (ncId * nc_stride)) has already moved ptr with one WorkLoadPerThreadNC
-      private_ptr += (InputBlockProperties::c_stride - 1) * WorkLoadPerThreadNC;
-      cIndex += InputBlockProperties::c_stride;
-    }
-  }
-  template <typename InputBlockProperties, StorageIndex TileSizeDimNC>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::pair<StorageIndex, StorageIndex> local_id_extract(
-      const StorageIndex &linearLocalThreadId) {
-    const StorageIndex localThreadNC =
-        (InputBlockProperties::is_coalesced_layout)
-            ? linearLocalThreadId % (TileSizeDimNC / InputBlockProperties::nc_stride)
-            : linearLocalThreadId / (Properties::TileSizeDimK / InputBlockProperties::c_stride);
-    const StorageIndex localThreadC =
-        (InputBlockProperties::is_coalesced_layout)
-            ? linearLocalThreadId / (TileSizeDimNC / InputBlockProperties::nc_stride)
-            : linearLocalThreadId % (Properties::TileSizeDimK / InputBlockProperties::c_stride);
-    return std::pair<StorageIndex, StorageIndex>(localThreadNC, localThreadC);
-  }
-
-  template <bool db = Properties::DoubleBuffer, contraction_type ctp = contraction_tp>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<db && ctp == contraction_type::local> sync_mem(
-      const cl::sycl::nd_item<1> &, bool &db_offset) noexcept {
-    db_offset = !db_offset;
-  }
-
-  template <bool db = Properties::DoubleBuffer, contraction_type ctp = contraction_tp>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!db && ctp == contraction_type::local> sync_mem(
-      const cl::sycl::nd_item<1> &itemID, bool &) noexcept {
-    itemID.barrier(cl::sycl::access::fence_space::local_space);
-  }
-
-  template <contraction_type ctp = contraction_tp>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<ctp == contraction_type::no_local> sync_mem(
-      const cl::sycl::nd_item<1> &, bool &) noexcept {
-    return;
-  }
-
-  template <bool need_sync, contraction_type ctp = contraction_tp>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<need_sync && ctp == contraction_type::no_local>
-  sync_thread(const cl::sycl::nd_item<1> &
-#ifdef EIGEN_SYCL_ARM_GPU_CACHE_OPTIMISATION
-                  itemID
-#endif
-              ) noexcept {
-#ifdef EIGEN_SYCL_ARM_GPU_CACHE_OPTIMISATION
-    itemID.barrier(cl::sycl::access::fence_spacce::local_space);
-#else
-    return;
-#endif
-  }
-  template <bool need_sync, contraction_type ctp = contraction_tp>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<need_sync && ctp == contraction_type::local>
-  sync_thread(const cl::sycl::nd_item<1> &itemID) {
-    itemID.barrier(cl::sycl::access::fence_space::local_space);
-  }
-  template <bool need_sync>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!need_sync> sync_thread(const cl::sycl::nd_item<1> &) {
-    return;
-  }
-
-  template <bool is_internal_block>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_tile_per_panel(const cl::sycl::nd_item<1> &itemID,
-                                                                    ThreadProperties<StorageIndex> &thread_properties,
-                                                                    TiledMemory &tiled_input_block,
-                                                                    PacketReturnType *privateRes,
-                                                                    bool &db_offset) const {
-    // Tiling the Rhs block from global to local memory
-    extract_block<RHSBlockProperties, is_internal_block>(
-        rhs, tiled_input_block.rhs_scratch_extract.ptr + (db_offset * Properties::TileSizeDimK * LSDR),
-        tiled_input_block.rhs_extract_index,
-        contraction_tp == contraction_type::local ? thread_properties.nGroupOffset : thread_properties.nGlobalOffset,
-        thread_properties.kGroupOffset - thread_properties.kSize);
-
-    sync_thread<contraction_tp == contraction_type::no_local>(itemID);
-
-    // Tiling the Lhs block from global to local memory
-    extract_block<LHSBlockProperties, is_internal_block>(
-        lhs, tiled_input_block.lhs_scratch_extract.ptr + (db_offset * LSDL * Properties::TileSizeDimK),
-        tiled_input_block.lhs_extract_index,
-        contraction_tp == contraction_type::local ? thread_properties.mGroupOffset : thread_properties.mGlobalOffset,
-        thread_properties.kGroupOffset - thread_properties.kSize);
-
-    // itemID.barrier(cl::sycl::access::fence_space::local_space);
-    sync_thread<contraction_tp == contraction_type::local>(itemID);
-    // switch to compute mede
-    StorageIndex lhs_offset = (db_offset * LSDL * Properties::TileSizeDimK);
-    StorageIndex rhs_offset = (db_offset * Properties::TileSizeDimK * LSDR);
-    // Loop over the values of a single tile
-    for (StorageIndex k = 0; k < Properties::TileSizeDimK; k++) {
-      compute_block_per_tile(tiled_input_block.lhs_scratch_ptr_compute + lhs_offset,
-                             tiled_input_block.rhs_scratch_ptr_compute + rhs_offset, privateRes);
-      lhs_offset += LSDL;
-      rhs_offset += LSDR;
-    }
-    // computing the K index for the next tile
-    thread_properties.kSize -= Properties::TileSizeDimK;
-    sync_mem(itemID, db_offset);
-  }
-
-  // when local memory is available the following compute_panel will be enabled
-  template <bool is_internal_block, typename OutPtr>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(const cl::sycl::nd_item<1> &itemID,
-                                                           ThreadProperties<StorageIndex> &thread_properties,
-                                                           OutPtr out_ptr) const {
-    auto tiled_input_block = TiledMemory{thread_properties, scratch.get_pointer()};
-    // Allocate register space
-    PacketReturnType privateRes[Properties::WorkLoadPerThreadM * Properties::WorkLoadPerThreadN / PacketSize] = {
-        PacketReturnType{0}};
-    bool db_offset = 0;
-
-    while (thread_properties.kSize >= Properties::TileSizeDimK) {
-      compute_tile_per_panel<is_internal_block>(itemID, thread_properties, tiled_input_block, privateRes, db_offset);
-    }
-    if (thread_properties.kSize > 0) {
-      compute_tile_per_panel<false>(itemID, thread_properties, tiled_input_block, privateRes, db_offset);
-    }
-
-    // Storing the final results in the output
-    store<is_internal_block,
-          contraction_tp == contraction_type::local ? static_cast<StorageIndex>(1) : RHSBlockProperties::nc_stride>(
-        out_ptr + thread_properties.nGlobalOffset * triple_dim.M, privateRes, thread_properties.mGlobalOffset,
-        thread_properties.nGlobalOffset);
-  }
-  // When local memory is available the following extract_block will be enabled
-  template <typename InputBlockProperties, bool is_internal_block, typename Input, typename Local,
-            contraction_type contract_tp = contraction_tp>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<contract_tp == contraction_type::local> extract_block(
-      const Input &inpt, Local local_ptr, const std::pair<StorageIndex, StorageIndex> &local_index,
-      const StorageIndex &ncOffset, const StorageIndex cOffset) const {
-    constexpr StorageIndex TileSizeDimNC =
-        InputBlockProperties::is_rhs ? Properties::TileSizeDimN : Properties::TileSizeDimM;
-    constexpr StorageIndex LoadPerThread =
-        InputBlockProperties::is_rhs ? Properties::LoadPerThreadRhs : Properties::LoadPerThreadLhs;
-    constexpr StorageIndex LSD = InputBlockProperties::is_rhs ? LSDR : LSDL;
-    static_assert(((LocalOffset % (TileSizeDimNC / InputBlockProperties::nc_stride) == 0) &&
-                   (LocalOffset % (Properties::TileSizeDimK / InputBlockProperties::c_stride) == 0)),
-                  " LocalOffset must be divisible by stride");
-    const StorageIndex &NC = InputBlockProperties::is_rhs ? triple_dim.N : triple_dim.M;
-    StorageIndex localThreadNC = local_index.first;
-    StorageIndex localThreadC = local_index.second;
-    auto chk_bound = [&](const StorageIndex &CIndex, const StorageIndex &NCIndex) EIGEN_DEVICE_FUNC {
-      return ((CIndex + InputBlockProperties::c_stride - 1 < triple_dim.K) &&
-              (NCIndex + InputBlockProperties::nc_stride - 1 < NC));
-    };
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex lPT = 0; lPT < LoadPerThread / InputBlockProperties::elements_per_access; lPT++) {
-      const StorageIndex CIndex = cOffset + (InputBlockProperties::c_stride * localThreadC);
-      const StorageIndex NCIndex = ncOffset + (InputBlockProperties::nc_stride * localThreadNC);
-      const StorageIndex ld = InputBlockProperties::is_coalesced_layout ? NC : triple_dim.K;
-      if (check_boundary<is_internal_block>(chk_bound(CIndex, NCIndex))) {
-        auto val =
-            read<InputBlockProperties::packet_load, InputBlockProperties::is_coalesced_layout,
-                 InputBlockProperties::is_rhs, typename InputBlockProperties::OutType>(inpt, NCIndex, CIndex, ld);
-        write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : LSD), data_source::local_mem>(
-            val, local_ptr + (InputBlockProperties::nc_stride * localThreadNC) +
-                     (InputBlockProperties::c_stride * localThreadC * LSD));
-      } else {
-        EIGEN_UNROLL_LOOP
-        for (StorageIndex i = 0; i < InputBlockProperties::elements_per_access; i++) {
-          const StorageIndex nCInd = NCIndex + (InputBlockProperties::is_coalesced_layout ? i : 0);
-          const StorageIndex cInd = CIndex + (InputBlockProperties::is_coalesced_layout ? 0 : i);
-          OutScalar val =
-              (nCInd < NC && cInd < triple_dim.K)
-                  ? read<false, InputBlockProperties::is_coalesced_layout, InputBlockProperties::is_rhs, OutScalar>(
-                        inpt, nCInd, cInd, ld)
-                  : OutScalar(0);
-
-          write<StorageIndex, (InputBlockProperties::is_coalesced_layout ? 1 : LSD), data_source::local_mem>(
-              val, local_ptr + (InputBlockProperties::nc_stride * localThreadNC) +
-                       (InputBlockProperties::is_coalesced_layout ? i : 0) +
-                       ((InputBlockProperties::c_stride * localThreadC +
-                         (InputBlockProperties::is_coalesced_layout ? 0 : i)) *
-                        LSD));
-        }
-      }
-      localThreadNC += (InputBlockProperties::is_coalesced_layout)
-                           ? LocalOffset % (TileSizeDimNC / InputBlockProperties::nc_stride)
-                           : LocalOffset / (Properties::TileSizeDimK / InputBlockProperties::c_stride);
-      localThreadC += (InputBlockProperties::is_coalesced_layout)
-                          ? LocalOffset / (TileSizeDimNC / InputBlockProperties::nc_stride)
-                          : LocalOffset % (Properties::TileSizeDimK / InputBlockProperties::c_stride);
-    }
-  }
-};
-
-#ifndef EIGEN_SYCL_DISABLE_GEMV
-
-/*!
- * \brief GeneralVectorTensor is a template class that provides Tensor -vector contraction operation, which is a special
- * case of Tensor Tensor contraction.
- *
- * \tparam OutScalar: determines the output scalar type
- *
- * \tparam OutAccessor: determines the sycl accessor type for out put (please see the sycl-1.2.1 specification
- * (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for accessor definition)
- *
- * \tparam VectorMapper: determines the tensor contraction mapper for the vector input (can be lhs or rhs)
- *
- * \tparam TensorMapper: determines the tensor contraction mapper for the tensor input (can be lhs or rhs)
- *
- * \tparam StorageIndex: determines the StorageIndex Type
- *
- * \tparam Properties: determines the Contraction Panel properties
- *
- * \tparam KFactor: determines the number of elements in K dimension in a Tile
- *
- * \tparam Vectorizable: determines whether or not the vectorization is enabled for the Eigen expression.
- *
- * \tparam is_lhs_vec: determines whether lhs is a vector or rhs is a vector
- *
- * \tparam IsFinal: determine if this is the final kernel. If so, the result will be written in a final output.
- * Otherwise, the result of contraction will be written iin a temporary buffer.
- *
- * \param scratch: determines the local memory containing the vector block for each work-group
- *
- * \param vec: determines the vector input (tensor mapper)
- *
- * \param mat: determines the tensor input (tensor mapper)
- *
- * \param out_res: determines the output vector containing the contraction result
- *
- * \param nonContractGroupSize: a logical number determining the number of work-group for non-contracting dimension
- *
- * \param nonContractDim: determines the size of non contracting dimension for the flattened tensor
- *
- * \param contractDim: determines the size of non contracting dimension for the flattened tensor
- *
- */
-template <typename OutScalar, typename OutAccessor, typename VectorMapper, typename TensorMapper, typename StorageIndex,
-          typename Properties, StorageIndex KFactor, bool Vectorizable, bool is_lhs_vec, bool IsFinal>
-struct GeneralVectorTensor {
-  typedef typename Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketReturnType
-      PacketReturnType;
-  static constexpr int PacketSize =
-      Eigen::TensorSycl::internal::Vectorise<OutScalar, Eigen::SyclDevice, Vectorizable>::PacketSize;
-  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> Scratch;
-
-  static constexpr StorageIndex OutScratchOffset =
-      KFactor * Properties::LocalThreadSizeC * Properties::LocalThreadSizeNC;
-
-  // Since the access layout for a vector can always be coalesced, when LHS is a vector, we pass false and false to make
-  // sure that the !^ is true When RHS is a vector, we pass true and true to make sure that the !^ is true.
-  typedef BlockProperties<is_lhs_vec ? false : true, is_lhs_vec ? false : true, Vectorizable, PacketReturnType>
-      VecBlockProperties;
-
-  Scratch scratch;
-  const VectorMapper vec;
-  const TensorMapper mat;
-  OutAccessor out_res;
-  const StorageIndex nonContractGroupSize;
-  const StorageIndex nonContractDim;
-  const StorageIndex contractDim;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE GeneralVectorTensor(Scratch scratch_, const VectorMapper vec_,
-                                                            const TensorMapper mat_, OutAccessor out_res_,
-                                                            const StorageIndex nonContractGroupSize_,
-                                                            const StorageIndex nonContractDim_,
-                                                            const StorageIndex contractDim_)
-      : scratch(scratch_),
-        vec(vec_),
-        mat(mat_),
-        out_res(out_res_),
-        nonContractGroupSize(nonContractGroupSize_),
-        nonContractDim(nonContractDim_),
-        contractDim(contractDim_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
-    auto scratch_ptr = scratch.get_pointer();
-    const StorageIndex linearLocalThreadId = itemID.get_local_id(0);
-    StorageIndex nonContractId = is_lhs_vec ? linearLocalThreadId / Properties::LocalThreadSizeC
-                                            : linearLocalThreadId % Properties::LocalThreadSizeNC;
-    StorageIndex contractId = is_lhs_vec ? linearLocalThreadId % Properties::LocalThreadSizeC
-                                         : linearLocalThreadId / Properties::LocalThreadSizeNC;
-    const StorageIndex cGroupSize = itemID.get_group_range(0) / nonContractGroupSize;
-    const StorageIndex nonContractGroupId =
-        is_lhs_vec ? itemID.get_group(0) / cGroupSize : itemID.get_group(0) % nonContractGroupSize;
-    const StorageIndex contractGroupId =
-        is_lhs_vec ? itemID.get_group(0) % cGroupSize : itemID.get_group(0) / nonContractGroupSize;
-    auto out_ptr = out_res + (IsFinal ? 0 : contractGroupId * nonContractDim);
-
-    const StorageIndex nonContractGroupOffset = nonContractGroupId * Properties::TileSizeDimNC;
-    const StorageIndex contractGroupOffset = contractGroupId * Properties::TileSizeDimC;
-    auto outScratchIndex = nonContractId + contractId * Properties::LocalThreadSizeNC;
-    const StorageIndex globalNonContractDimOffset = nonContractGroupOffset + nonContractId;
-    const StorageIndex globalContractDimOffset = contractGroupOffset + contractId;
-    auto local_output = scratch_ptr + OutScratchOffset;
-    const bool is_internal = nonContractDim - nonContractGroupOffset >= Properties::TileSizeDimNC &&
-                             contractDim - contractGroupOffset >= Properties::TileSizeDimC;
-    is_internal
-        ? compute_panel<true>(itemID, vec, mat, local_output, out_ptr,
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-                              scratch_ptr, contractGroupOffset,
-#endif
-                              nonContractGroupOffset, linearLocalThreadId, contractDim, nonContractDim, contractId,
-                              nonContractId, globalContractDimOffset, globalNonContractDimOffset, outScratchIndex)
-        : compute_panel<false>(itemID, vec, mat, local_output, out_ptr,
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-                               scratch_ptr, contractGroupOffset,
-#endif
-                               nonContractGroupOffset, linearLocalThreadId, contractDim, nonContractDim, contractId,
-                               nonContractId, globalContractDimOffset, globalNonContractDimOffset, outScratchIndex);
-  }
-  template <bool is_internal_block, typename OutPtr>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(
-      const cl::sycl::nd_item<1> &itemID, const VectorMapper &vec, const TensorMapper &mat, OutScalar *local_output,
-      OutPtr out_ptr,
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-      OutScalar *scratch_ptr, const StorageIndex contractGroupOffset,
-#endif
-      const StorageIndex nonContractGroupOffset, const StorageIndex linearLocalThreadId, StorageIndex contractDim,
-      StorageIndex nonContractDim, StorageIndex contractId, StorageIndex nonContractId,
-      StorageIndex globalContractDimOffset, StorageIndex globalNonContractDimOffset, StorageIndex outScratchIndex) {
-    OutScalar outScalar[Properties::WorkLoadPerThreadNC] = {OutScalar(0)};
-    // Reading the vector
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-    const StorageIndex vectorOffset = contractGroupOffset + linearLocalThreadId;
-    extract_block<VecBlockProperties, is_internal_block, KFactor,
-                  Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC>(vec, scratch_ptr, linearLocalThreadId,
-                                                                                vectorOffset, contractDim);
-
-    itemID.barrier(cl::sycl::access::fence_space::local_space);
-    auto in_scratch_ptr = scratch_ptr + contractId;
-#endif
-
-    StorageIndex privateOffsetC = 0;
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex i = 0; i < Properties::WorkLoadPerThreadC; i++) {
-      StorageIndex privateOffsetNC = 0;
-      bool contract_conds = ((globalContractDimOffset + privateOffsetC) < contractDim);
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-      auto vecScalar = *in_scratch_ptr;
-#else
-      auto vecScalar = (check_boundary<is_internal_block>(contract_conds))
-                           ? vec(is_lhs_vec ? StorageIndex(0) : globalContractDimOffset + privateOffsetC,
-                                 is_lhs_vec ? globalContractDimOffset + privateOffsetC : StorageIndex(0))
-                           : OutScalar(0);
-#endif
-      EIGEN_UNROLL_LOOP
-      for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
-        auto matScalar = (check_boundary<is_internal_block>(
-                             contract_conds && ((globalNonContractDimOffset + privateOffsetNC) < nonContractDim)))
-                             ? mat(is_lhs_vec ? globalContractDimOffset + privateOffsetC
-                                              : globalNonContractDimOffset + privateOffsetNC,
-                                   is_lhs_vec ? globalNonContractDimOffset + privateOffsetNC
-                                              : globalContractDimOffset + privateOffsetC)
-                             : OutScalar(0);
-
-        outScalar[j] = ::Eigen::internal::pmadd(matScalar, vecScalar, outScalar[j]);
-        privateOffsetNC += Properties::LocalThreadSizeNC;
-      }
-      privateOffsetC += Properties::LocalThreadSizeC;
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-      in_scratch_ptr += Properties::LocalThreadSizeC;
-#endif
-    }
-
-    auto out_scratch_ptr = local_output + outScratchIndex;
-    // Each block of 16*16 element in shared memory should reduce to 16*1
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
-      *out_scratch_ptr = outScalar[j];
-
-      out_scratch_ptr += (Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC);
-    }
-    if (is_lhs_vec) {
-      nonContractId = linearLocalThreadId % Properties::LocalThreadSizeNC;
-      contractId = linearLocalThreadId / Properties::LocalThreadSizeNC;
-      outScratchIndex = nonContractId + contractId * Properties::LocalThreadSizeNC;
-    }
-
-    out_scratch_ptr = local_output + outScratchIndex;
-    EIGEN_UNROLL_LOOP
-    for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
-      EIGEN_UNROLL_LOOP
-      for (StorageIndex offset = Properties::LocalThreadSizeC >> 1; offset > 0; offset >>= 1) {
-        itemID.barrier(cl::sycl::access::fence_space::local_space);
-        if (contractId < offset) {
-          StorageIndex myNeigbourId = (Properties::LocalThreadSizeNC * offset);
-          *out_scratch_ptr += out_scratch_ptr[myNeigbourId];
-        }
-      }
-      // moving to next 16 by 16 block
-      out_scratch_ptr += (Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC);
-    }
-
-    if (contractId == 0) {
-      out_scratch_ptr = local_output + nonContractId;
-      StorageIndex global_final_offset = nonContractGroupOffset + nonContractId;
-      out_ptr += global_final_offset;
-      EIGEN_UNROLL_LOOP
-      for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
-        if (check_boundary<is_internal_block>(global_final_offset < nonContractDim)) {
-          auto res = *out_scratch_ptr;
-
-          *out_ptr = res;
-          out_ptr += Properties::LocalThreadSizeNC;
-        }
-        // moving to next 16 by 16 block to ge the next 16 reduced elements
-        out_scratch_ptr += (Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC);
-        if (!(is_internal_block)) global_final_offset += Properties::LocalThreadSizeNC;
-      }
-    }
-  }
-
-  template <typename InputBlockProperties, bool is_internal_block, int CFactor, int GroupSize, typename Input,
-            typename Local>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_block(const Input &inpt, Local *local_ptr,
-                                                                  const StorageIndex &linearLocalThreadId,
-                                                                  const StorageIndex &cOffset, const StorageIndex &C) {
-    local_ptr += InputBlockProperties::c_stride * linearLocalThreadId;
-    StorageIndex cIndex = cOffset;
-    for (StorageIndex cId = 0; cId < CFactor / InputBlockProperties::c_stride; cId++) {
-      if (check_boundary<is_internal_block>(cIndex + InputBlockProperties::c_stride - 1 < C)) {
-        auto val = read<InputBlockProperties::packet_load, InputBlockProperties::is_coalesced_layout,
-                        InputBlockProperties::is_rhs, typename InputBlockProperties::OutType>(inpt, StorageIndex(0),
-                                                                                              cIndex, StorageIndex(1));
-        write<StorageIndex, 1, data_source::local_mem>(val, local_ptr);
-      } else {
-        EIGEN_UNROLL_LOOP
-        for (StorageIndex i = 0; i < InputBlockProperties::elements_per_access; i++) {
-          OutScalar val =
-              (cIndex + i < C)
-                  ? read<false, InputBlockProperties::is_coalesced_layout, InputBlockProperties::is_rhs, OutScalar>(
-                        inpt, StorageIndex(0), cIndex + i, StorageIndex(1))
-                  : OutScalar(0);
-          write<StorageIndex, 1, data_source::local_mem>(val, local_ptr + i);
-        }
-      }
-      local_ptr += InputBlockProperties::c_stride * GroupSize;
-      cIndex += InputBlockProperties::c_stride * GroupSize;
-    }
-  }
-};
-#endif
-
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
-
-/*!
- * \brief GeneralScalarContraction is a template class that provides the scalar value of Tensor -Tensor contraction
- * operation, when all the dimensions are contracting dimensions. This Kernel reduces two tensors to an scalar
- *
- * \tparam OutScalar: determines the output scalar type
- *
- * \tparam LhsScalar: determines the left-hand-side scalar type
- *
- * \tparam RhsScalar: determines the right-hand-side scalar type
- *
- * \tparam OutAccessor: determines the sycl accessor type for out put (please see the sycl-1.2.1 specification
- * (https://www.khronos.org/registry/SYCL/specs/sycl-1.2.1.pdf) for accessor definition)
- *
- * \tparam LhsMapper: determines the tensor contraction mapper type for left-hand-side matrix
- *
- * \tparam RhsMapper: determines the tensor contraction mapper type for right-hand-side matrix
- *
- * \tparam StorageIndex: determines the StorageIndex Type
- *
- * \tparam Vectorizable: determines whether or not the vectorization is enabled for the Eigen expression.
- *
- * \param scratch: local memory containing tiles of LHS and RHS tensors for each work-group
- *
- * \param lhs: determines the left-hand-side flattened tensor (tensor mapper)
- *
- * \param rhs: determines the right-hand-side flattened tensor (tensor mapper)
- *
- * \param out_res: determines the output tensor containing the contraction result
- *
- * \param rng: determines the total input data size
- */
-template <typename OutScalar, typename LhsScalar, typename RhsScalar, typename OutAccessor, typename LhsMapper,
-          typename RhsMapper, typename StorageIndex, bool Vectorizable>
-struct GeneralScalarContraction {
-  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> Scratch;
-  Scratch scratch;
-  const LhsMapper lhs;
-  const RhsMapper rhs;
-  OutAccessor out_res;
-  const StorageIndex rng;
-
-  EIGEN_DEVICE_FUNC GeneralScalarContraction(Scratch scratch_, const LhsMapper lhs_, const RhsMapper rhs_,
-                                             OutAccessor out_res_, const StorageIndex rng_)
-      : scratch(scratch_), lhs(lhs_), rhs(rhs_), out_res(out_res_), rng(rng_) {}
-
-  EIGEN_DEVICE_FUNC void operator()(cl::sycl::nd_item<1> itemID) const {
-    auto out_ptr = out_res;
-    OutScalar *scratch_ptr = scratch.get_pointer();
-
-    StorageIndex globalid = itemID.get_global_id(0);
-    StorageIndex localid = itemID.get_local_id(0);
-    OutScalar accumulator = OutScalar(0);
-    for (StorageIndex i = globalid; i < rng; i += itemID.get_global_range(0)) {
-      accumulator = Eigen::internal::pmadd(lhs(0, i), rhs(i, 0), accumulator);
-    }
-    auto out_scratch_ptr = scratch_ptr + localid;
-    *out_scratch_ptr = accumulator;
-    for (StorageIndex offset = itemID.get_local_range(0) >> 1; offset > 0; offset >>= 1) {
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-      if (localid < offset) {
-        *out_scratch_ptr = (accumulator += out_scratch_ptr[offset]);
-      }
-    }
-    if (localid == 0) {
-      out_ptr[itemID.get_group(0)] = accumulator;
-    }
-  }
-};
-#endif
-
-}  // namespace internal
-}  // namespace TensorSycl
-
-template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
-struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>,
-                       Eigen::SyclDevice>
-    : public TensorContractionEvaluatorBase<TensorEvaluator<
-          const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Eigen::SyclDevice>> {
-  static_assert(std::is_same<OutputKernelType, const NoOpOutputKernel>::value,
-                "SYCL tensor contraction does not support output kernels.");
-
-  typedef Eigen::SyclDevice Device;
-
-  typedef TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device> Self;
-  typedef TensorContractionEvaluatorBase<Self> Base;
-  typedef TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType> XprType;
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef typename XprType::Index StorageIndex;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename Base::Storage Storage;
-  typedef typename Base::EvaluatorPointerType EvaluatorPointerType;
-  struct TripleDim {
-    const StorageIndex M;
-    const StorageIndex N;
-    const StorageIndex K;
-    TripleDim(const StorageIndex M_, const StorageIndex N_, const StorageIndex K_) : M(M_), N(N_), K(K_) {}
-  };
-  enum {
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = false,
-  };
-
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-  static constexpr int LDims = Base::LDims;
-  static constexpr int RDims = Base::RDims;
-  static constexpr int ContractDims = Base::ContractDims;
-
-  typedef array<StorageIndex, LDims> left_dim_mapper_t;
-  typedef array<StorageIndex, RDims> right_dim_mapper_t;
-
-  typedef array<StorageIndex, ContractDims> contract_t;
-  typedef array<StorageIndex, LDims - ContractDims> left_nocontract_t;
-  typedef array<StorageIndex, RDims - ContractDims> right_nocontract_t;
-
-  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
-
-  typedef DSizes<StorageIndex, NumDims> Dimensions;
-
-  typedef TensorEvaluator<typename Base::EvalLeftArgType, Device> LeftEvaluator;
-  typedef TensorEvaluator<typename Base::EvalRightArgType, Device> RightEvaluator;
-  typedef std::remove_const_t<typename LeftEvaluator::CoeffReturnType> LhsScalar;
-  typedef std::remove_const_t<typename RightEvaluator::CoeffReturnType> RhsScalar;
-
-  typedef typename LeftEvaluator::Dimensions LeftDimensions;
-  typedef typename RightEvaluator::Dimensions RightDimensions;
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered>
-  struct input_mapper_propertis {
-    static constexpr bool is_lhs_matrix = (LDims == 2 && ContractDims == 1) || lhs_inner_dim_contiguous;
-    static constexpr bool is_rhs_matrix =
-        (RDims == 2 && ContractDims == 1) || (rhs_inner_dim_contiguous && !rhs_inner_dim_reordered);
-  };
-
-  TensorEvaluator(const XprType &op, const Device &device) : Base(op, device) {}
-
-  // We need to redefine this method to make nvcc happy
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(typename Base::EvaluatorPointerType data) {
-    this->m_leftImpl.evalSubExprsIfNeeded(NULL);
-    this->m_rightImpl.evalSubExprsIfNeeded(NULL);
-    if (!data) {
-      this->m_result = this->m_device.get(
-          static_cast<Scalar *>(this->m_device.allocate_temp(this->dimensions().TotalSize() * sizeof(Scalar))));
-      data = this->m_result;
-    }
-    evalToSycl(data);
-    return (this->m_result != NULL);
-  }
-  const Eigen::SyclDevice &device() const { return this->m_device; }
-  void evalToSycl(typename Base::EvaluatorPointerType buffer) const {
-    if (this->m_lhs_inner_dim_contiguous) {
-      if (this->m_rhs_inner_dim_contiguous) {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<true, true, true, Unaligned>(buffer);
-        } else {
-          evalTyped<true, true, false, Unaligned>(buffer);
-        }
-      } else {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<true, false, true, Unaligned>(buffer);
-        } else {
-          evalTyped<true, false, false, Unaligned>(buffer);
-        }
-      }
-    } else {
-      if (this->m_rhs_inner_dim_contiguous) {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<false, true, true, Unaligned>(buffer);
-        } else {
-          evalTyped<false, true, false, Unaligned>(buffer);
-        }
-      } else {
-        if (this->m_rhs_inner_dim_reordered) {
-          evalTyped<false, false, true, Unaligned>(buffer);
-        } else {
-          evalTyped<false, false, false, Unaligned>(buffer);
-        }
-      }
-    }
-  }
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-  void evalTyped(typename Base::EvaluatorPointerType buffer) const {
-    const auto triple_dim = TripleDim{this->m_i_size, this->m_j_size, this->m_k_size};
-    typedef internal::TensorContractionInputMapper<
-        LhsScalar, StorageIndex, internal::Lhs, LeftEvaluator, left_nocontract_t, contract_t,
-        PacketType<CoeffReturnType, Device>::size, lhs_inner_dim_contiguous, false, Unaligned, MakePointer>
-        LhsMapper;
-
-    typedef internal::TensorContractionInputMapper<RhsScalar, StorageIndex, internal::Rhs, RightEvaluator,
-                                                   right_nocontract_t, contract_t,
-                                                   PacketType<CoeffReturnType, Device>::size, rhs_inner_dim_contiguous,
-                                                   rhs_inner_dim_reordered, Unaligned, MakePointer>
-        RhsMapper;
-
-    // initialize data mappers
-    LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides,
-                  this->m_left_contracting_strides, this->m_k_strides);
-
-    RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
-                  this->m_right_contracting_strides, this->m_k_strides);
-
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
-    if (triple_dim.M == 1 && triple_dim.N == 1) {
-      launchSC(buffer, lhs, rhs, triple_dim.K);
-    } else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
-        if (triple_dim.M != 1 && triple_dim.N == 1) {
-      LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
-    } else if (triple_dim.M == 1 && triple_dim.N != 1) {
-      LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
-    } else  // This is equivalent of if (m!=1 && n!=1)
-#endif
-    {
-      typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
-          inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
-      bool skinny = false;
-      auto platform_name = this->device().getPlatformName();
-      // This is based on empirical calculation for AMD r9-nano and Fiji
-      if (platform_name.find("AMD") == 0) {
-        skinny = (triple_dim.M < triple_dim.K || triple_dim.N < triple_dim.K) &&
-                 ((triple_dim.M < 1024 && triple_dim.N < 1024) ||
-                  (uint64_t(triple_dim.M * triple_dim.N) < uint64_t(triple_dim.K)));
-      } else {
-        skinny = (((std::max(triple_dim.K, triple_dim.N) / std::min(triple_dim.K, triple_dim.N)) > 100) ||
-                  ((std::max(triple_dim.K, triple_dim.M) / std::min(triple_dim.K, triple_dim.M)) > 100) ||
-                  ((std::max(triple_dim.N, triple_dim.M) / std::min(triple_dim.N, triple_dim.M)) > 100));
-      }
-      if (skinny)
-        adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
-      else
-#endif  // EIGEN_SYCL_DISABLE_SKINNY
-        adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
-    }
-  }
-
-  template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
-  void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
-                                    const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
-    if (device().has_local_memory()) {
-      typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
-      launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
-          buffer, lhs, rhs, triple_dim);
-    }
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
-    if (!(device().has_local_memory())) {
-      typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
-      launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
-          buffer, lhs, rhs, triple_dim);
-    }
-#endif
-  }
-
-  template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
-            typename Properties, typename LhsMapper, typename RhsMapper>
-  void launchTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
-                const TripleDim &triple_dim) const {
-    const StorageIndex roundUpM = Eigen::TensorSycl::internal::roundUp(triple_dim.M, Properties::TileSizeDimM);
-    const StorageIndex roundUpN = Eigen::TensorSycl::internal::roundUp(triple_dim.N, Properties::TileSizeDimN);
-    const StorageIndex groupSizeM = roundUpM / Properties::TileSizeDimM;
-    const StorageIndex groupSizeN = roundUpN / Properties::TileSizeDimN;
-
-    const StorageIndex roundUpK = Eigen::TensorSycl::internal::roundUp(triple_dim.K, Properties::TileSizeDimK);
-    StorageIndex totalTilesK = roundUpK / Properties::TileSizeDimK;
-    StorageIndex groupSizeK =
-        skinny
-            ? std::max(std::min(totalTilesK,
-                                (StorageIndex)(device().getPowerOfTwo(device().getNumSyclMultiProcessors(), true) * 4) /
-                                    (groupSizeM * groupSizeN)),
-                       StorageIndex(1))
-            : StorageIndex(1);
-
-    const StorageIndex numTilesPerGroup = Eigen::TensorSycl::internal::roundUp(totalTilesK, groupSizeK) / groupSizeK;
-
-    const StorageIndex totalGroupSize = groupSizeM * groupSizeN * groupSizeK;
-
-    const StorageIndex localRange = Properties::LocalThreadSizeM * Properties::LocalThreadSizeN;
-    const StorageIndex globalRange = totalGroupSize * localRange;
-
-    const StorageIndex scratchSize = (ct == TensorSycl::internal::contraction_type::local)
-                                         ? ((Properties::DoubleBuffer + 1) *
-                                            (Properties::TileSizeDimM + Properties::BC) * (Properties::TileSizeDimK)) +
-                                               ((Properties::DoubleBuffer + 1) * (Properties::TileSizeDimK) *
-                                                (Properties::TileSizeDimN + Properties::BC))
-                                         : StorageIndex(1);
-
-    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(globalRange), cl::sycl::range<1>(localRange));
-    if (groupSizeK == 1) {
-      typedef TensorSycl::internal::TensorContractionKernel<CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType,
-                                                            LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim,
-                                                            PacketAccess, input_mapper_properties, true, ct>
-          ContractKernelName;
-      device()
-          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
-              lhs, rhs, buffer, thread_range, scratchSize, groupSizeM, groupSizeN, numTilesPerGroup, triple_dim)
-          .wait();
-    } else {
-      typedef TensorSycl::internal::TensorContractionKernel<CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType,
-                                                            LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim,
-                                                            PacketAccess, input_mapper_properties, false, ct>
-          ContractKernelName;
-      CoeffReturnType *temp_pointer = static_cast<CoeffReturnType *>(
-          device().allocate_temp(triple_dim.M * triple_dim.N * groupSizeK * sizeof(CoeffReturnType)));
-      EvaluatorPointerType tmp_global_accessor = device().get(temp_pointer);
-
-      device()
-          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
-              lhs, rhs, tmp_global_accessor, thread_range, scratchSize, groupSizeM, groupSizeN, numTilesPerGroup,
-              triple_dim)
-          .wait();
-
-      typedef Eigen::internal::SumReducer<CoeffReturnType> Op;
-      auto op = Op();
-      typedef TensorSycl::internal::SecondStepPartialReduction<CoeffReturnType, StorageIndex, EvaluatorPointerType,
-                                                               EvaluatorPointerType, Op>
-          ReductionKernel;
-
-      device()
-          .template unary_kernel_launcher<CoeffReturnType, ReductionKernel>(
-              tmp_global_accessor, buffer,
-              cl::sycl::nd_range<1>(cl::sycl::range<1>(StorageIndex(
-                                        Eigen::TensorSycl::internal::roundUp(triple_dim.M * triple_dim.N, localRange))),
-                                    cl::sycl::range<1>(localRange)),
-              StorageIndex(1), op, StorageIndex(triple_dim.M * triple_dim.N), groupSizeK)
-          .wait();
-      device().deallocate_temp(temp_pointer);
-    }
-  }
-
-#ifndef EIGEN_SYCL_DISABLE_GEMV
-  template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
-  void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
-                                    StorageIndex NC, StorageIndex C) const {
-    const StorageIndex nonContractDim = NC;
-    constexpr StorageIndex NCFactor = 1;
-    constexpr StorageIndex CFactor = 1;
-    constexpr StorageIndex NCWindow = 16;
-    typedef Eigen::TensorSycl::internal::TVPanelSize<CoeffReturnType, StorageIndex, NCWindow, CFactor, NCFactor>
-        Properties;
-    const StorageIndex roundUpC = Eigen::TensorSycl::internal::roundUp(C, Properties::TileSizeDimC);
-    const StorageIndex cNumGroups = roundUpC / (Properties::LocalThreadSizeC * Properties::WorkLoadPerThreadC);
-    const StorageIndex roundUpNC = Eigen::TensorSycl::internal::roundUp(nonContractDim, Properties::TileSizeDimNC);
-    const StorageIndex nCNumGroups = roundUpNC / (Properties::LocalThreadSizeNC * Properties::WorkLoadPerThreadNC);
-    const StorageIndex globalRange =
-        (roundUpNC / (Properties::WorkLoadPerThreadNC)) * (roundUpC / (Properties::WorkLoadPerThreadC));
-    const StorageIndex localRange = Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC;
-    const StorageIndex scratchSize =
-        (Properties::WorkLoadPerThreadNC + CFactor) * Properties::LocalThreadSizeC * Properties::LocalThreadSizeNC;
-    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(globalRange), cl::sycl::range<1>(localRange));
-    if (cNumGroups > 1) {
-      typedef Eigen::TensorSycl::internal::GeneralVectorTensor<CoeffReturnType, EvaluatorPointerType, VectorMapper,
-                                                               TensorMapper, StorageIndex, Properties, CFactor, false,
-                                                               is_lhs_vec, false>
-          ContractKernelName;
-      CoeffReturnType *temp_pointer =
-          static_cast<CoeffReturnType *>(device().allocate_temp(nonContractDim * cNumGroups * sizeof(CoeffReturnType)));
-      EvaluatorPointerType tmp_global_accessor = device().get(temp_pointer);
-
-      device()
-          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
-              vec, mat, tmp_global_accessor, thread_range, scratchSize, nCNumGroups, nonContractDim, C)
-          .wait();
-
-      typedef Eigen::internal::SumReducer<CoeffReturnType> Op;
-      typedef TensorSycl::internal::SecondStepPartialReduction<CoeffReturnType, StorageIndex, EvaluatorPointerType,
-                                                               EvaluatorPointerType, Op>
-          ReductionKernel;
-
-      device()
-          .template unary_kernel_launcher<CoeffReturnType, ReductionKernel>(
-              tmp_global_accessor, buffer,
-              cl::sycl::nd_range<1>(
-                  cl::sycl::range<1>(Eigen::TensorSycl::internal::roundUp(nonContractDim, localRange)),
-                  cl::sycl::range<1>(localRange)),
-              StorageIndex(1), Op(), nonContractDim, cNumGroups)
-          .wait();
-      device().deallocate_temp(temp_pointer);
-    } else {
-      typedef Eigen::TensorSycl::internal::GeneralVectorTensor<CoeffReturnType, EvaluatorPointerType, VectorMapper,
-                                                               TensorMapper, StorageIndex, Properties, CFactor, false,
-                                                               is_lhs_vec, true>
-          ContractKernelName;
-      device()
-          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(
-              vec, mat, buffer, thread_range, scratchSize, nCNumGroups, nonContractDim, C)
-          .wait();
-    }
-  }
-#endif
-
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
-  template <typename LhsMapper, typename RhsMapper>
-  EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
-                                    StorageIndex K) const {
-    EIGEN_STATIC_ASSERT(!((EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1) &
-                          (EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1 - 1)),
-                        "The Local thread size must be a power of 2 for the reduction "
-                        "operation");
-    constexpr StorageIndex local_range = EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1;
-
-    // Here we force the code not to be more than 2-step reduction: Our empirical research shows that if each thread
-    // reduces at least 512 elementss individually, we get better performance.
-    const StorageIndex num_work_group = ((K + (512 * local_range - 1)) / (512 * local_range) > 1 ? local_range : 1);
-    const StorageIndex global_range = num_work_group * local_range;
-
-    typedef Eigen::TensorSycl::internal::GeneralScalarContraction<
-        CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType, LhsMapper, RhsMapper, StorageIndex, false>
-        ContractKernelName;
-    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
-    if (num_work_group > 1) {
-      CoeffReturnType *temp_pointer =
-          static_cast<CoeffReturnType *>(device().allocate_temp(num_work_group * sizeof(CoeffReturnType)));
-      EvaluatorPointerType tmp_global_accessor = device().get(temp_pointer);
-      device()
-          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(lhs, rhs, tmp_global_accessor,
-                                                                                thread_range, local_range, K)
-          .wait();
-      typedef Eigen::internal::SumReducer<CoeffReturnType> Op;
-      typedef TensorSycl::internal::SecondStepFullReducer<CoeffReturnType, Op, EvaluatorPointerType,
-                                                          EvaluatorPointerType, StorageIndex, local_range>
-          GenericRKernel;
-      device()
-          .template unary_kernel_launcher<CoeffReturnType, GenericRKernel>(
-              tmp_global_accessor, buffer,
-              cl::sycl::nd_range<1>(cl::sycl::range<1>(local_range), cl::sycl::range<1>(local_range)), local_range,
-              Op())
-          .wait();
-      device().deallocate_temp(temp_pointer);
-    } else {
-      device()
-          .template binary_kernel_launcher<CoeffReturnType, ContractKernelName>(lhs, rhs, buffer, thread_range,
-                                                                                local_range, K)
-          .wait();
-    }
-  }
-#endif
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    this->m_leftImpl.cleanup();
-    this->m_rightImpl.cleanup();
-
-    if (this->m_result) {
-      this->m_device.deallocate_temp(this->m_result);
-      this->m_result = NULL;
-    }
-  }
-};
-}  // namespace Eigen
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h b/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h
deleted file mode 100644
index 5dd5d60..0000000
--- a/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h
+++ /dev/null
@@ -1,1544 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
-
-// evaluator for thread pool device
-#ifdef EIGEN_USE_THREADS
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
-struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>,
-                       ThreadPoolDevice>
-    : public TensorContractionEvaluatorBase<TensorEvaluator<
-          const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, ThreadPoolDevice>> {
-  using Device = ThreadPoolDevice;
-
-  using Self = TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, Device>;
-  using Base = TensorContractionEvaluatorBase<Self>;
-
-  using XprType = TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>;
-  using Scalar = std::remove_const_t<typename XprType::Scalar>;
-  using Index = typename XprType::Index;
-  using CoeffReturnType = typename XprType::CoeffReturnType;
-  using PacketReturnType = typename PacketType<CoeffReturnType, Device>::type;
-
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-
-  // Most of the code is assuming that both input tensors are ColMajor. If the
-  // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS:
-  // If we want to compute A * B = C, where A is LHS and B is RHS, the code
-  // will pretend B is LHS and A is RHS.
-  using EvalLeftArgType =
-      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), LeftArgType, RightArgType>;
-  using EvalRightArgType =
-      std::conditional_t<static_cast<int>(Layout) == static_cast<int>(ColMajor), RightArgType, LeftArgType>;
-
-  static constexpr int LDims =
-      internal::array_size<typename TensorEvaluator<EvalLeftArgType, Device>::Dimensions>::value;
-  static constexpr int RDims =
-      internal::array_size<typename TensorEvaluator<EvalRightArgType, Device>::Dimensions>::value;
-  static constexpr int ContractDims = internal::array_size<Indices>::value;
-
-  using left_dim_mapper_t = array<Index, LDims>;
-  using right_dim_mapper_t = array<Index, RDims>;
-
-  using contract_t = array<Index, ContractDims>;
-  using left_nocontract_t = array<Index, LDims - ContractDims>;
-  using right_nocontract_t = array<Index, RDims - ContractDims>;
-
-  static constexpr int NumDims = LDims + RDims - 2 * ContractDims;
-
-  using Dimensions = DSizes<Index, NumDims>;
-
-  // typedefs needed in evalTo
-  using LhsScalar = std::remove_const_t<typename EvalLeftArgType::Scalar>;
-  using RhsScalar = std::remove_const_t<typename EvalRightArgType::Scalar>;
-  using Traits = typename internal::gebp_traits<LhsScalar, RhsScalar>;
-
-  using LeftEvaluator = TensorEvaluator<EvalLeftArgType, Device>;
-  using RightEvaluator = TensorEvaluator<EvalRightArgType, Device>;
-
-  TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  template <int Alignment>
-  void evalProduct(Scalar* buffer) const {
-    evalProductImpl<NoCallback, Alignment>(buffer, NoCallback());
-  }
-
-  template <typename EvalToCallback, int Alignment>
-  void evalProductAsync(Scalar* buffer, EvalToCallback done) const {
-    evalProductImpl<EvalToCallback, Alignment>(buffer, std::move(done));
-  }
-
-  template <typename DoneCallback, int Alignment>
-  void evalProductImpl(Scalar* buffer, DoneCallback done) const {
-    // This function computes a lot of heuristics in multiple steps, and it
-    // also has multiple exit points. To keep it sane, readable and all in one
-    // place, sync/async execution decision is made at runtime at the very end.
-    //
-    // (1) In sync mode we allocate Context on the stack, submit computations
-    //     to the device thread pool, and block on a barrier until it is
-    //     completed.
-    //
-    // (2) In async mode we allocate Context on the heap, and after all tasks
-    //     are finished, we call provided the done callback, and delete a
-    //     context from the heap.
-    //
-    // (*) EvalParallelContext & EvalShardedByInnerDimContext owns all the state
-    // and temporary buffers, required for executing the tensor contraction.
-    // They are responsible for cleaning it up after contraction is done.
-    static const bool IsEvalInSyncMode = std::is_same<DoneCallback, NoCallback>::value;
-
-    const Index m = this->m_i_size;
-    const Index n = this->m_j_size;
-    const Index k = this->m_k_size;
-    if (m == 0 || n == 0 || k == 0) return;
-
-    // Compute a set of algorithm parameters:
-    // - kernel block sizes (bm, bn, bk)
-    // - task grain sizes (number of kernels executed per task: gm, gn)
-    // - number of threads
-    // - sharding by row/column
-    // - parallel packing or first lhs then rhs
-    // and some derived parameters:
-    // - number of tasks (nm, nn, nk)
-    // - number of kernels (nm0, nn0)
-    // Unfortunately, all these parameters are tightly interdependent.
-    // So in some cases we first compute approximate values, then compute other
-    // values based on these approximations and then refine the approximations.
-
-    // There are lots of heuristics here. There is some reasoning behind them,
-    // but ultimately they are just tuned on contraction benchmarks for
-    // different input configurations, thread counts and instruction sets.
-    // So feel free to question any of them.
-
-    // Compute whether we want to shard by row or by column.
-    // This is a first approximation, it will be refined later. Since we don't
-    // know number of threads yet we use 2, because what's we are most
-    // interested in at this point is whether it makes sense to use
-    // parallelization at all or not.
-    bool shard_by_col = shardByCol(m, n, 2);
-
-    // First approximation of kernel blocking sizes.
-    // Again, we don't know number of threads yet, so we use 2.
-    Index bm, bn, bk;
-    if (shard_by_col) {
-      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(k, m, n,
-                                                                                                              2);
-      bm = blocking.mc();
-      bn = blocking.nc();
-      bk = blocking.kc();
-    } else {
-      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByRow> blocking(k, m, n,
-                                                                                                              2);
-      bm = blocking.mc();
-      bn = blocking.nc();
-      bk = blocking.kc();
-    }
-
-    // Compute optimal number of threads.
-    // Note: we use bk instead of k here because we are interested in amount of
-    // _parallelizable_ computations, and computations are not parallelizable
-    // across k dimension.
-    const TensorOpCost cost = contractionCost(m, n, bm, bn, bk, shard_by_col, false);
-    int num_threads =
-        TensorCostModel<ThreadPoolDevice>::numThreads(static_cast<double>(n) * m, cost, this->m_device.numThreads());
-    int num_threads_by_k = numThreadsInnerDim(m, n, k);
-    if (shardByInnerDim(m, n, k, num_threads, num_threads_by_k)) {
-      // We are in the scenario where it is more effective to shard by the
-      // inner dimension.
-      if (IsEvalInSyncMode) {
-        EvalShardedByInnerDimContext<DoneCallback> ctx(this, num_threads_by_k, buffer, m, n, k, std::move(done));
-        ctx.template run<Alignment>();
-      } else {
-        auto* ctx =
-            new EvalShardedByInnerDimContext<DoneCallback>(this, num_threads_by_k, buffer, m, n, k, std::move(done));
-        ctx->template runAsync<Alignment>();
-      }
-
-      return;
-    }
-
-    // TODO(dvyukov): this is a stop-gap to prevent regressions while the cost
-    // model is not tuned. Remove this when the cost model is tuned.
-    if (n == 1) num_threads = 1;
-
-    if (num_threads == 1) {
-      TENSOR_CONTRACTION_DISPATCH(this->template evalProductSequential, Unaligned, (buffer));
-      if (!IsEvalInSyncMode) done();
-      return;
-    }
-
-    // Now that we know number of threads, recalculate sharding and blocking.
-    shard_by_col = shardByCol(m, n, num_threads);
-    if (shard_by_col) {
-      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByCol> blocking(
-          k, m, n, num_threads);
-      bm = blocking.mc();
-      bn = blocking.nc();
-      bk = blocking.kc();
-    } else {
-      internal::TensorContractionBlocking<Scalar, LhsScalar, RhsScalar, Index, internal::ShardByRow> blocking(
-          k, m, n, num_threads);
-      bm = blocking.mc();
-      bn = blocking.nc();
-      bk = blocking.kc();
-    }
-
-    // Number of kernels for each dimension.
-    Index nm0 = numext::div_ceil(m, bm);
-    Index nn0 = numext::div_ceil(n, bn);
-    Index nk = numext::div_ceil(k, bk);
-
-    // Calculate task grain size (number of kernels executed per task).
-    // This task size coarsening serves two purposes:
-    // 1. It reduces per-task overheads including synchronization overheads.
-    // 2. It allows to use caches better (reuse the same packed rhs in several
-    // consecutive kernels).
-    Index gm = 1;
-    Index gn = 1;
-    // If we are sharding by column, then we prefer to reduce rows first.
-    if (shard_by_col) {
-      gm = coarsenM(m, n, bm, bn, bk, gn, num_threads, shard_by_col);
-      gn = coarsenN(m, n, bm, bn, bk, gm, num_threads, shard_by_col);
-    } else {
-      gn = coarsenN(m, n, bm, bn, bk, gm, num_threads, shard_by_col);
-      gm = coarsenM(m, n, bm, bn, bk, gn, num_threads, shard_by_col);
-    }
-    // Number of tasks in each dimension.
-    Index nm = numext::div_ceil(nm0, gm);
-    Index nn = numext::div_ceil(nn0, gn);
-
-    // If there is enough concurrency in the sharding dimension, we choose not
-    // to parallelize by the other dimension, and execute all kernels in sync
-    // mode. This reduces parallelism from the nm x nn down to nn
-    // (shard_by_col==true) or nm (shard_by_col==false).
-    const Index sharding_dim_tasks = shard_by_col ? nn : nm;
-    const int num_worker_threads = this->m_device.numThreadsInPool();
-
-    // With small number of threads we want to make sure that we do not reduce
-    // parallelism too much. With large number of threads we trade maximum
-    // parallelism for better memory locality.
-    const float oversharding_factor = num_worker_threads <= 4    ? 8.0
-                                      : num_worker_threads <= 8  ? 4.0
-                                      : num_worker_threads <= 16 ? 2.0
-                                      : num_worker_threads <= 32 ? 1.0
-                                      : num_worker_threads <= 64 ? 0.8
-                                                                 : /* num_worker_threads > 64 */ 0.6;
-
-    const bool parallelize_by_sharding_dim_only = sharding_dim_tasks >= oversharding_factor * num_worker_threads;
-
-    // Last by not least, decide whether we want to issue both lhs and rhs
-    // packing in parallel; or issue lhs packing first, and then issue rhs
-    // packing when lhs packing completes (for !shard_by_col lhs and rhs are
-    // swapped). Parallel packing allows more parallelism (for both packing and
-    // kernels), while sequential packing provides better locality (once
-    // a thread finishes rhs packing it proceed to kernels with that rhs).
-    // First, we are interested in parallel packing if there are few tasks.
-    bool parallel_pack = num_threads >= nm * nn;
-    // Also do parallel packing if all data fits into L2$.
-    if (m * bk * Index(sizeof(LhsScalar)) + n * bk * Index(sizeof(RhsScalar)) <= l2CacheSize() * num_threads)
-      parallel_pack = true;
-    // But don't do it if we will use each rhs only once. Locality seems to be
-    // more important in this case.
-    if ((shard_by_col ? nm : nn) == 1) parallel_pack = false;
-    // Also don't get in the way of parallelize_by_sharding_dim_only
-    // optimization.
-    if (parallelize_by_sharding_dim_only) parallel_pack = false;
-
-    // TODO(ezhulnev): With if constexpr we don't need SyncEvalParallelContext.
-    if (IsEvalInSyncMode) {
-#define CONTEXT_ARGS                                                                                          \
-  (this, num_threads, buffer, m, n, k, bm, bn, bk, nm, nn, nk, gm, gn, nm0, nn0, shard_by_col, parallel_pack, \
-   parallelize_by_sharding_dim_only, NoCallback())                                                            \
-      .run()
-      TENSOR_CONTRACTION_DISPATCH(SyncEvalParallelContext, Alignment, CONTEXT_ARGS);
-#undef CONTEXT_ARGS
-
-    } else {
-#define CONTEXT_ARGS                                                                                          \
-  (this, num_threads, buffer, m, n, k, bm, bn, bk, nm, nn, nk, gm, gn, nm0, nn0, shard_by_col, parallel_pack, \
-   parallelize_by_sharding_dim_only, std::move(done))
-      TENSOR_CONTRACTION_ASYNC_DISPATCH(EvalParallelContext, DoneCallback, Alignment, CONTEXT_ARGS, run());
-#undef CONTEXT_ARGS
-    }
-  }
-
-  // ------------------------------------------------------------------------ //
-
-  // Dummy struct to represent an empty DoneCallback.
-
-  struct NoCallback {
-    void operator()() const { eigen_assert(false && "NoCallback should never be called"); }
-  };
-
-  // ------------------------------------------------------------------------ //
-
-  template <typename DoneCallback, typename Context>
-  class EvalParallelNotification;
-
-  // Synchronous evaluation notification that blocks caller thread in Wait().
-  template <typename Context>
-  class EvalParallelNotification<NoCallback, Context> {
-   public:
-    EvalParallelNotification(Context*, NoCallback) {}
-    void Notify() { done_.Notify(); }
-    void Wait() { done_.Wait(); }
-
-   private:
-    Eigen::Notification done_;
-  };
-
-  // Asynchronous evaluation notification that does not block in Wait().
-  template <typename DoneCallback, typename Context>
-  class EvalParallelNotification {
-   public:
-    EvalParallelNotification(Context* ctx, DoneCallback done) : ctx_(ctx), done_(std::move(done)) {}
-
-    void Notify() {
-      // Make a copy of done callback, because it will be destructed when we
-      // will delete context in the next line (EvalParallelNotification is a
-      // data member of EvalParallelContext class).
-      DoneCallback done_copy = std::move(done_);
-
-      // Delete parallel evaluation context.
-      delete ctx_;
-
-      // Now safely call the done callback.
-      done_copy();
-    }
-
-    void Wait() {}
-
-   private:
-    Context* ctx_;
-    DoneCallback done_;
-  };
-
-  // Context orchestrates sync/async parallel contraction evaluation. When it is
-  // executed in asynchronous mode, it owns all the shared state that might be
-  // accessible by block packing and kernel tasks.
-
-  template <typename DoneCallback, bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous,
-            bool rhs_inner_dim_reordered, int Alignment>
-  class EvalParallelContext {
-   public:
-    using LhsMapper =
-        internal::TensorContractionInputMapper<LhsScalar, Index, internal::Lhs, LeftEvaluator, left_nocontract_t,
-                                               contract_t, internal::packet_traits<LhsScalar>::size,
-                                               lhs_inner_dim_contiguous, false, Unaligned>;
-    using RhsMapper =
-        internal::TensorContractionInputMapper<RhsScalar, Index, internal::Rhs, RightEvaluator, right_nocontract_t,
-                                               contract_t, internal::packet_traits<RhsScalar>::size,
-                                               rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Unaligned>;
-
-    using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
-
-    using TensorContractionKernel =
-        internal::TensorContractionKernel<Scalar, LhsScalar, RhsScalar, Index, OutputMapper, LhsMapper, RhsMapper>;
-
-    using LhsBlock = typename TensorContractionKernel::LhsBlock;
-    using RhsBlock = typename TensorContractionKernel::RhsBlock;
-    using BlockMemHandle = typename TensorContractionKernel::BlockMemHandle;
-
-    EvalParallelContext(const Self* self, int num_threads, Scalar* buffer, Index tm, Index tn, Index tk, Index bm,
-                        Index bn, Index bk, Index nm, Index nn, Index nk, Index gm, Index gn, Index nm0, Index nn0,
-                        bool shard_by_col, bool parallel_pack, bool parallelize_by_sharding_dim_only, DoneCallback done)
-        : created_by_thread_id_(std::this_thread::get_id()),
-          done_(this, std::move(done)),
-          device_(self->m_device),
-          lhs_(self->m_leftImpl, self->m_left_nocontract_strides, self->m_i_strides, self->m_left_contracting_strides,
-               self->m_k_strides),
-          rhs_(self->m_rightImpl, self->m_right_nocontract_strides, self->m_j_strides,
-               self->m_right_contracting_strides, self->m_k_strides),
-          buffer_(buffer),
-          output_(buffer, tm),
-          output_kernel_(self->m_output_kernel),
-          tensor_contraction_params_(self->m_tensor_contraction_params),
-          num_threads_(num_threads),
-          shard_by_col_(shard_by_col),
-          parallel_pack_(parallel_pack),
-          parallelize_by_sharding_dim_only_(parallelize_by_sharding_dim_only),
-          m_(tm),
-          n_(tn),
-          k_(tk),
-          bm_(bm),
-          bn_(bn),
-          bk_(bk),
-          nm_(nm),
-          nn_(nn),
-          nk_(nk),
-          gm_(gm),
-          gn_(gn),
-          nm0_(nm0),
-          nn0_(nn0),
-          kernel_(m_, k_, n_, bm_, bk_, bn_),
-          num_thread_local_allocations_(0),
-          // We reserve 2X more capacity for a thread local values, than the
-          // number of threads in the pool to efficiently handle task stealing
-          // by threads that are not managed by the pool.
-          thread_local_capacity(2 * (parallelize_by_sharding_dim_only_ ? device_.numThreadsInPool() : 0)),
-          // We will use only one of the Lhs/Rhs thread local storage depending
-          // on the shard_by_col value and we parallelize by sharding dim ONLY.
-          lhs_thread_local_blocks_(shard_by_col_ ? 0 : thread_local_capacity, {*this}, {*this}),
-          rhs_thread_local_blocks_(shard_by_col_ ? thread_local_capacity : 0, {*this}, {*this}) {
-      // These two options are mutually exclusive.
-      eigen_assert(!(parallel_pack && parallelize_by_sharding_dim_only));
-
-      for (Index x = 0; x < P; x++) {
-        // Normal number of notifications for k slice switch is
-        // nm_ + nn_ + nm_ * nn_. However, first P - 1 slices will receive only
-        // nm_ + nn_ notifications, because they will not receive notifications
-        // from preceding kernels.
-        state_switch_[x] =
-            x == 0 ? 1 : (parallel_pack_ ? nn_ + nm_ : (shard_by_col_ ? nn_ : nm_)) + (x == P - 1 ? nm_ * nn_ : 0);
-        state_packing_ready_[x] = parallel_pack_ ? 0 : (shard_by_col_ ? nm_ : nn_);
-        state_kernel_[x] = new std::atomic<uint8_t>*[nm_];
-        for (Index m = 0; m < nm_; m++) {
-          state_kernel_[x][m] = new std::atomic<uint8_t>[nn_];
-          // Kernels generally receive 3 notifications (previous kernel + 2
-          // packing), but the first slice won't get notifications from previous
-          // kernels.
-          for (Index n = 0; n < nn_; n++)
-            state_kernel_[x][m][n].store((x == 0 ? 0 : 1) + (parallel_pack_ ? 2 : 1), std::memory_order_relaxed);
-        }
-      }
-
-      // Allocate memory for packed rhs/lhs matrices.
-      packed_mem_ = kernel_.allocateSlices(            //
-          device_,                                     //
-          /*num_lhs=*/nm0_,                            //
-          /*num_rhs=*/nn0_,                            //
-          /*num_slices=*/std::min<Index>(nk_, P - 1),  //
-          packed_lhs_, packed_rhs_);
-
-      if (parallelize_by_sharding_dim_only_) {
-        const int num_worker_threads = device_.numThreadsInPool();
-
-        if (shard_by_col) {
-          can_use_thread_local_packed_ = new std::atomic<bool>[nn_];
-          for (int i = 0; i < nn_; ++i) can_use_thread_local_packed_[i].store(true, std::memory_order_relaxed);
-
-          Index num_blocks = num_worker_threads * gn_;
-          thread_local_pre_alocated_mem_ = kernel_.allocateSlices(  //
-              device_,                                              //
-              /*num_lhs=*/0,                                        //
-              /*num_rhs=*/num_blocks,                               //
-              /*num_slices=*/1,                                     //
-              /*lhs_blocks=*/nullptr, &rhs_thread_local_pre_allocated_);
-
-        } else {
-          can_use_thread_local_packed_ = new std::atomic<bool>[nm_];
-          for (int i = 0; i < nm_; ++i) can_use_thread_local_packed_[i].store(true, std::memory_order_relaxed);
-
-          Index num_blocks = num_worker_threads * gm_;
-          thread_local_pre_alocated_mem_ = kernel_.allocateSlices(  //
-              device_,                                              //
-              /*num_lhs=*/num_blocks,                               //
-              /*num_rhs=*/0,                                        //
-              /*num_slices=*/1, &lhs_thread_local_pre_allocated_,   //
-              /*rhs_blocks=*/nullptr);
-        }
-      }
-    }
-
-    ~EvalParallelContext() {
-      for (Index x = 0; x < P; x++) {
-        for (Index m = 0; m < nm_; m++) delete[] state_kernel_[x][m];
-        delete[] state_kernel_[x];
-      }
-      kernel_.deallocate(device_, packed_mem_);
-      if (parallelize_by_sharding_dim_only_) {
-        kernel_.deallocate(device_, thread_local_pre_alocated_mem_);
-        delete[] can_use_thread_local_packed_;
-      }
-    }
-
-    void run() {
-      // Kick off packing of the first slice.
-      signal_switch(0, 1);
-
-      // Wait for overall completion.
-      //
-      // If parallel evaluation is executed in async mode, this is a no-op, and
-      // Wait() will return immediately. In synchronous mode it will block the
-      // caller thread until it will receive notification from last task.
-      //
-      // In async mode, last task when completed will call done callback from
-      // the same thread, and will delete this context.
-      //
-      // TODO(dvyukov): This wait can lead to deadlock if contraction is
-      // evaluated in synchronous mode. If nthreads contractions are
-      // concurrently submitted from worker threads, this wait will block all
-      // worker threads and the system will deadlock.
-      done_.Wait();
-    }
-
-   private:
-    std::thread::id created_by_thread_id_;
-
-    // This notification is specialized on the type of DoneCallback and can be
-    // blocking or non-blocking.
-    EvalParallelNotification<DoneCallback, EvalParallelContext> done_;
-
-    const Device& device_;
-    LhsMapper lhs_;
-    RhsMapper rhs_;
-    Scalar* const buffer_;
-    OutputMapper output_;
-    OutputKernelType output_kernel_;
-    TensorContractionParams tensor_contraction_params_;
-    const int num_threads_;
-    const bool shard_by_col_;
-    const bool parallel_pack_;
-    const bool parallelize_by_sharding_dim_only_;
-    // Matrix sizes.
-    const Index m_;
-    const Index n_;
-    const Index k_;
-    // Block sizes.
-    const Index bm_;
-    const Index bn_;
-    const Index bk_;
-    // Number of tasks.
-    const Index nm_;
-    const Index nn_;
-    const Index nk_;
-    // Task grain sizes (number of kernels executed per task).
-    const Index gm_;
-    const Index gn_;
-    // Number of blocks (this is different from ni_/nn_ because of task size
-    // coarsening).
-    const Index nm0_;
-    const Index nn0_;
-    // Tensor contraction kernel.
-    TensorContractionKernel kernel_;
-
-    // Parallelization strategy.
-    //
-    // Blocks related to the same k block can run in parallel because they write
-    // to different output blocks. So we parallelize within k slices, this
-    // gives us parallelism level of m x n. Before we can start any kernels
-    // related to k-th slice, we need to issue m lhs packing tasks and n rhs
-    // packing tasks.
-    //
-    // However, there is a bottleneck when we are finishing kernels for k-th
-    // slice (at the very end there is only 1 runnable kernel). To mitigate this
-    // bottleneck we allow kernels from k-th and k+1-th slices to run in
-    // parallel. Note that (m, n, k) and (m, n, k+1) kernels write to the same
-    // output block, so they must not run in parallel.
-    //
-    // This gives us the following dependency graph.
-    // On each k slice we have m x n kernel tasks, m lhs packing tasks and n rhs
-    // packing tasks.
-    // Kernel (m, n, k) can start when:
-    //  - kernel (m, n, k-1) has finished
-    //  - lhs packing (m, k) has finished
-    //  - rhs packing (n, k) has finished
-    // Lhs/rhs packing can start when:
-    //  - all k-1 packing has finished (artificially imposed to limit amount of
-    //  parallel packing)
-    //
-    // On top of that we limit runnable tasks to two consecutive k slices.
-    // This is done to limit amount of memory we need for packed lhs/rhs
-    // (for each k slice we need m*bk + n*bk memory in packed_lhs_/packed_rhs_).
-    //
-    // state_switch_ tracks when we are ready to switch to the next k slice.
-    // state_kernel_[m][n] tracks when we are ready to kick off kernel (m, n).
-    // These variable are rolling over 3 consecutive k slices: first two we are
-    // actively executing + one to track completion of kernels in the second
-    // slice.
-    static constexpr Index P = 3;
-
-    // Handle to the allocated temporary storage for Lhs/Rhs blocks.
-    BlockMemHandle packed_mem_;
-    std::vector<LhsBlock> packed_lhs_[P - 1];
-    std::vector<RhsBlock> packed_rhs_[P - 1];
-
-    // If we choose to parallelize only by the sharding dimension, each thread
-    // will have its own "thread local" (not a C++ thread local storage) memory
-    // for packed_lhs or packed_rhs (shard_by_col = false of true). This memory
-    // can't be passed to a kernel that might execute on a different thread.
-    //
-    // In practice when we are ready to pack memory for the sharding dimension
-    // (rhs if shard_by_col==true) of the K-th slice, all kernels for K-1 slice
-    // already computed (99% of the time), and we can pack data into the thread
-    // local storage, and guarantee that all the kernels will be executed
-    // immediately in the same thread. This significantly increases L1 cache hit
-    // ratio and reduces pressure on the memory bus.
-    //
-    // It's still possible that kernel for the K-th slice will be ready before
-    // completion of the K-1 kernel, so we have to allocate "global" packed_lhs_
-    // and packed_rhs_ to allow kernels to be executed later on a thread
-    // different from the thread that was used for packing.
-
-    // Handle for pre-allocated thread local memory buffers.
-    BlockMemHandle thread_local_pre_alocated_mem_;
-
-    // Only one of these will be initialized depending on shard_by_col value
-    // (the size will be `num_worker_threads * num_grains_in_the_sharding_dim`).
-    std::vector<LhsBlock> lhs_thread_local_pre_allocated_;
-    std::vector<RhsBlock> rhs_thread_local_pre_allocated_;
-
-    // How many thread local blocks were already allocated.
-    std::atomic<int> num_thread_local_allocations_;
-    const int thread_local_capacity;
-
-    // We will use pre-allocated Lhs/Rhs blocks defined above, if the number of
-    // unique threads in a system is below or equal to the number of threads in
-    // a thread pool. We will fallback on dynamic memory allocation after that.
-
-    // ThreadLocalBlocks is a container for Lhs or Rhs thread local buffers. Its
-    // size is equal to the grain size in Lhs/Rhs sharding dimension.
-    template <typename BlockType>
-    class ThreadLocalBlocks {
-     public:
-      ThreadLocalBlocks() = default;
-
-      ThreadLocalBlocks(BlockType* base, size_t grain_size)
-          : is_pre_allocated_(true), thread_local_pre_allocated_base_(base), grain_size_(grain_size) {}
-
-      ThreadLocalBlocks(BlockMemHandle mem_handle, std::vector<BlockType> blocks)
-          : is_pre_allocated_(false), mem_handle_(std::move(mem_handle)), blocks_(std::move(blocks)) {}
-
-      BlockType& block(int grain_index) {
-        eigen_assert(grain_index >= 0);
-        eigen_assert(static_cast<size_t>(grain_index) < size());
-        return is_pre_allocated_ ? thread_local_pre_allocated_base_[grain_index] : blocks_[grain_index];
-      }
-
-      void Release(EvalParallelContext& ctx) const {
-        if (!is_pre_allocated_) {
-          ctx.kernel_.deallocate(ctx.device_, mem_handle_);
-        }
-      }
-
-      size_t size() const { return is_pre_allocated_ ? grain_size_ : blocks_.size(); }
-
-     private:
-      bool is_pre_allocated_;
-
-      // Reuse pre-allocated thread local buffers.
-      BlockType* thread_local_pre_allocated_base_ = nullptr;
-      size_t grain_size_ = 0;
-
-      // These will be initialized only if `is_pre_allocated == false`.
-      BlockMemHandle mem_handle_{};
-      std::vector<BlockType> blocks_;
-    };
-
-    // ThreadLocalBlocksInitialize callable does custom thread local blocks
-    // initialization, and will reuse pre-allocated buffers if possible, or will
-    // dynamically allocate new memory.
-    //
-    // Lhs/Rhs blocks might be of the same type, so we have to pass explicitly
-    // for what side do we plan to do block allocation.
-    template <typename BlockType, bool is_rhs>
-    class ThreadLocalBlocksInitialize {
-      static constexpr bool kIsLhs = !is_rhs && std::is_same<BlockType, LhsBlock>::value;
-      static const bool kIsRhs = is_rhs && std::is_same<BlockType, RhsBlock>::value;
-      static_assert(kIsLhs || kIsRhs, "Unknown block type");
-
-      using Blocks = ThreadLocalBlocks<BlockType>;
-
-     public:
-      ThreadLocalBlocksInitialize(EvalParallelContext& ctx)
-          : ctx_(ctx), num_worker_threads_(ctx_.device_.numThreadsInPool()) {}
-
-      void operator()(Blocks& blocks) {
-        const int n = ctx_.num_thread_local_allocations_.fetch_add(1, std::memory_order_relaxed);
-
-        if (n >= num_worker_threads_) {
-          ThreadLocalBlocksAllocator<is_rhs>::allocate(ctx_, blocks);
-        } else {
-          ThreadLocalBlocksAllocator<is_rhs>::reuse(ctx_, n, blocks);
-        }
-      }
-
-     private:
-      // NOTE(ezhulenev): Without 'if constexpr' we have to put calls to
-      // TensorContractionKernel::allocateSlices into template specializations.
-      // Also explicit specializations are not allowed at class scope in C++03,
-      // EvalCtx type parameter is just a workaround for that limitation.
-      template <bool pack_rhs, typename EvalCtx = EvalParallelContext>
-      struct ThreadLocalBlocksAllocator;
-
-      template <typename EvalCtx>
-      struct ThreadLocalBlocksAllocator</*pack_rhs=*/true, EvalCtx> {
-        static void allocate(EvalCtx& ctx, Blocks& blocks) {
-          std::vector<RhsBlock> rhs_blocks;
-          BlockMemHandle mem_handle = ctx.kernel_.allocateSlices(ctx.device_,
-                                                                 /*num_lhs=*/0,
-                                                                 /*num_rhs=*/ctx.gn_,
-                                                                 /*num_slices=*/1,
-                                                                 /*lhs_blocks=*/nullptr, /*rhs_blocks=*/&rhs_blocks);
-
-          blocks = ThreadLocalBlocks<RhsBlock>(std::move(mem_handle), std::move(rhs_blocks));
-        }
-
-        static void reuse(EvalCtx& ctx, int index, Blocks& blocks) {
-          RhsBlock* ptr = &ctx.rhs_thread_local_pre_allocated_[ctx.gn_ * index];
-          blocks = ThreadLocalBlocks<RhsBlock>(ptr, ctx.gn_);
-        }
-      };
-
-      template <typename EvalCtx>
-      struct ThreadLocalBlocksAllocator</*pack_rhs=*/false, EvalCtx> {
-        static void allocate(EvalCtx& ctx, Blocks& blocks) {
-          std::vector<LhsBlock> lhs_blocks;
-          BlockMemHandle mem_handle = ctx.kernel_.allocateSlices(ctx.device_,
-                                                                 /*num_lhs=*/ctx.gm_,
-                                                                 /*num_rhs=*/0,
-                                                                 /*num_slices=*/1,
-                                                                 /*lhs_blocks=*/&lhs_blocks, /*rhs_blocks=*/nullptr);
-
-          blocks = ThreadLocalBlocks<LhsBlock>(std::move(mem_handle), std::move(lhs_blocks));
-        }
-
-        static void reuse(EvalCtx& ctx, int index, Blocks& blocks) {
-          LhsBlock* ptr = &ctx.lhs_thread_local_pre_allocated_[ctx.gm_ * index];
-          blocks = ThreadLocalBlocks<LhsBlock>(ptr, ctx.gm_);
-        }
-      };
-
-      EvalParallelContext& ctx_;
-      const int num_worker_threads_;
-    };
-
-    template <typename BlockType>
-    class ThreadLocalBlocksRelease {
-     public:
-      using Blocks = ThreadLocalBlocks<BlockType>;
-      ThreadLocalBlocksRelease(EvalParallelContext& ctx) : ctx_(ctx) {}
-      void operator()(Blocks& blocks) { blocks.Release(ctx_); }
-
-     private:
-      EvalParallelContext& ctx_;
-    };
-
-    // ThreadLocalBlocks initialization callables.
-    using ThreadLocalLhsInit = ThreadLocalBlocksInitialize<LhsBlock, /*is_rhs=*/false>;
-    using ThreadLocalRhsInit = ThreadLocalBlocksInitialize<RhsBlock, /*is_rhs=*/true>;
-
-    // ThreadLocalBlocks release callables.
-    using ThreadLocalLhsRelease = ThreadLocalBlocksRelease<LhsBlock>;
-    using ThreadLocalRhsRelease = ThreadLocalBlocksRelease<RhsBlock>;
-
-    // Thread local containers for Lhs/Rhs block packs. In practice only one of
-    // them will be used, depending on the shard_by_col value.
-    Eigen::ThreadLocal<ThreadLocalBlocks<LhsBlock>, ThreadLocalLhsInit, ThreadLocalLhsRelease> lhs_thread_local_blocks_;
-    Eigen::ThreadLocal<ThreadLocalBlocks<RhsBlock>, ThreadLocalRhsInit, ThreadLocalRhsRelease> rhs_thread_local_blocks_;
-
-    // After a particular shard for Kth slice missed thread local execution
-    // opportunity (K-1 slice didn't complete kernels execution), we can no
-    // longer schedule K+1 and following slices in thread local mode, because
-    // there is no more guarantee that previous kernels were executed
-    // sequentially in the same thread (size is nn_ or nm_).
-    std::atomic<bool>* can_use_thread_local_packed_;
-
-    std::atomic<uint8_t>** state_kernel_[P];
-    // state_switch_ is frequently modified by worker threads, while other
-    // fields are read-only after constructor. Let's move it to a separate cache
-    // line to reduce cache-coherency traffic.
-    char pad_[128];
-    std::atomic<Index> state_packing_ready_[P];
-    std::atomic<Index> state_switch_[P];
-
-    LhsBlock& packed_lhs(Index m, Index k, Index m1, bool use_thread_local) {
-      if (use_thread_local) {
-        eigen_assert(!shard_by_col_);
-        ThreadLocalBlocks<LhsBlock>& blocks = lhs_thread_local_blocks_.local();
-
-        Index grain_index = m1 - m * gm_;
-        return blocks.block(
-            internal::convert_index<int>(grain_index));  // FIXME: Consider making ThreadLocalBlocks use Eigen::Index.
-      } else {
-        return packed_lhs_[k % (P - 1)][m1];
-      }
-    }
-
-    RhsBlock& packed_rhs(Index n, Index k, Index n1, bool use_thread_local) {
-      if (use_thread_local) {
-        eigen_assert(shard_by_col_);
-        ThreadLocalBlocks<RhsBlock>& blocks = rhs_thread_local_blocks_.local();
-
-        Index grain_index = n1 - n * gn_;
-        return blocks.block(
-            internal::convert_index<int>(grain_index));  // FIXME: Consider making ThreadLocalBlocks use Eigen::Index.
-      } else {
-        return packed_rhs_[k % (P - 1)][n1];
-      }
-    }
-
-    // In following two methods (pack_lhs and pack_rhs), if we know for sure
-    // that we'll be able to immediately call a kernel with packed data, and do
-    // not submit it to the thread pool, we can use thread local memory for
-    // packed data.
-    //
-    // We can only reliably check it if we are running all kernels in sync mode
-    // (parallelize only by sharding dim). If kernel for m==0 (n==0) is ready to
-    // run, it's guaranteed that all kernels with larger values of m (n) are
-    // also ready, because we execute them in the same order for all K slices.
-
-    void pack_lhs(Index m, Index k) {
-      bool use_thread_local = false;
-
-      if (parallelize_by_sharding_dim_only_ && !shard_by_col_ &&
-          can_use_thread_local_packed_[m].load(std::memory_order_relaxed)) {
-        if (state_kernel_[k % P][m][0].load(std::memory_order_relaxed) == 1) {
-          use_thread_local = true;
-        } else {
-          // If we can't guarantee that all kernels in `k` slice will be
-          // executed sequentially in current thread, it's no longer safe to use
-          // thread local memory in following slices along the k dimensions.
-          eigen_assert(k > 0);
-          can_use_thread_local_packed_[m].store(false, std::memory_order_relaxed);
-        }
-      }
-
-      const Index mend = m * gm_ + gm(m);
-      for (Index m1 = m * gm_; m1 < mend; m1++)
-        kernel_.packLhs(&packed_lhs(m, k, m1, use_thread_local), lhs_.getSubMapper(m1 * bm_, k * bk_), bk(k), bm(m1));
-
-      if (!parallel_pack_ && shard_by_col_) {
-        eigen_assert(!use_thread_local);
-        signal_packing(k);
-      } else {
-        signal_switch(k + 1);
-        for (Index n = nn_ - 1; n >= 0; n--) {
-          bool sync = parallelize_by_sharding_dim_only_ || n == 0;
-          signal_kernel(m, n, k, sync, use_thread_local);
-        }
-      }
-    }
-
-    void pack_rhs(Index n, Index k) {
-      bool use_thread_local = false;
-
-      if (parallelize_by_sharding_dim_only_ && shard_by_col_ &&
-          can_use_thread_local_packed_[n].load(std::memory_order_relaxed)) {
-        if (state_kernel_[k % P][0][n].load(std::memory_order_relaxed) == 1) {
-          use_thread_local = true;
-        } else {
-          // If we can't guarantee that all kernels in `k` slice will be
-          // executed sequentially in current thread, it's no longer safe to use
-          // thread local memory in following slices along the k dimensions.
-          eigen_assert(k > 0);
-          can_use_thread_local_packed_[n].store(false, std::memory_order_relaxed);
-        }
-      }
-
-      const Index nend = n * gn_ + gn(n);
-      for (Index n1 = n * gn_; n1 < nend; n1++) {
-        if (!TensorContractionKernel::HasBeta && k == 0) {
-          // Zero the output memory in parallel, only if contraction kernel does
-          // not support `beta`. Otherwise we will pass beta 0.0 to the first
-          // call to the `TensorContractionKernel::invoke()`.
-          //
-          // On 10000x2x10000 mm zeroing can easily take half of time. Zero (bn
-          // x m) row. Safe to do here because all kernels that will write to
-          // this memory depend on completion of this task. Note: don't call
-          // device_.fill() here. device_.fill() blocks on thread pool
-          // worker thread, which can lead to underutilization and deadlocks.
-          std::fill_n(buffer_ + n1 * bn_ * m_, bn(n1) * m_, Scalar(0));
-        }
-        kernel_.packRhs(&packed_rhs(n, k, n1, use_thread_local), rhs_.getSubMapper(k * bk_, n1 * bn_), bk(k), bn(n1));
-      }
-
-      if (parallel_pack_ || shard_by_col_) {
-        signal_switch(k + 1);
-        for (Index m = nm_ - 1; m >= 0; m--) {
-          bool sync = parallelize_by_sharding_dim_only_ || m == 0;
-          signal_kernel(m, n, k, sync, use_thread_local);
-        }
-      } else {
-        eigen_assert(!use_thread_local);
-        signal_packing(k);
-      }
-    }
-
-    void kernel(Index m, Index n, Index k, bool use_thread_local) {
-      // Note: order of iteration matters here. Iteration over m is innermost
-      // because we want to reuse the same packed rhs in consecutive tasks
-      // (rhs fits into L2$ while lhs only into L3$).
-      const Index nend = n * gn_ + gn(n);
-      const Index mend = m * gm_ + gm(m);
-
-      // NOTE: output = alpha * LHS * RHS + beta * output.
-      const Scalar alpha = Scalar(1);
-      const Scalar beta = (TensorContractionKernel::HasBeta && k == 0) ? Scalar(0) : Scalar(1);
-
-      if (shard_by_col_) {
-        for (Index n1 = n * gn_; n1 < nend; n1++) {
-          for (Index m1 = m * gm_; m1 < mend; m1++) {
-            const auto output_mapper = output_.getSubMapper(m1 * bm_, n1 * bn_);
-            kernel_.invoke(output_mapper, packed_lhs(m, k, m1, !shard_by_col_ && use_thread_local),
-                           packed_rhs(n, k, n1, shard_by_col_ && use_thread_local), bm(m1), bk(k), bn(n1), alpha, beta);
-
-            // We are done with the last task for the [m1, n1] block.
-            if (k + 1 == nk_) {
-              output_kernel_(output_mapper, tensor_contraction_params_, m1 * bm_, n1 * bn_, bm(m1), bn(n1));
-            }
-          }
-        }
-      } else {
-        for (Index m1 = m * gm_; m1 < mend; m1++)
-          for (Index n1 = n * gn_; n1 < nend; n1++) {
-            const auto output_mapper = output_.getSubMapper(m1 * bm_, n1 * bn_);
-            kernel_.invoke(output_mapper, packed_lhs(m, k, m1, !shard_by_col_ && use_thread_local),
-                           packed_rhs(n, k, n1, shard_by_col_ && use_thread_local), bm(m1), bk(k), bn(n1), alpha, beta);
-
-            // We are done with the last task for the [m1, n1] block.
-            if (k + 1 == nk_) {
-              output_kernel_(output_mapper, tensor_contraction_params_, m1 * bm_, n1 * bn_, bm(m1), bn(n1));
-            }
-          }
-      }
-      signal_kernel(m, n, k + 1, /*sync=*/false, /*use_thread_local=*/false);
-      signal_switch(k + 2);
-    }
-
-    void signal_packing(Index k) {
-      eigen_assert(!parallel_pack_);
-      Index s = state_packing_ready_[k % P].fetch_sub(1);
-      eigen_assert(s > 0);
-      if (s != 1) return;
-      state_packing_ready_[k % P] = shard_by_col_ ? nm_ : nn_;
-      enqueue_packing(k, shard_by_col_);
-    }
-
-    void signal_kernel(Index m, Index n, Index k, bool sync, bool use_thread_local) {
-      std::atomic<uint8_t>* state = &state_kernel_[k % P][m][n];
-      Index s = state->load();
-      eigen_assert(s > 0);
-      if (s != 1 && state->fetch_sub(1) != 1) {
-        eigen_assert(!use_thread_local);
-        return;
-      }
-      state->store(parallel_pack_ ? 3 : 2, std::memory_order_relaxed);
-      if (sync) {
-        kernel(m, n, k, use_thread_local);
-      } else {
-        eigen_assert(!use_thread_local);
-        device_.enqueue([this, m, n, k, use_thread_local]() { kernel(m, n, k, use_thread_local); });
-      }
-    }
-
-    void signal_switch(Index k, Index v = 1) {
-      Index s = state_switch_[k % P].fetch_sub(v);
-      eigen_assert(s >= v);
-      if (s != v) return;
-
-      // Ready to switch to the next k slice.
-      // Reset counter for the next iteration.
-      state_switch_[k % P] = (parallel_pack_ ? nm_ + nn_ : (shard_by_col_ ? nn_ : nm_)) + nm_ * nn_;
-      if (k < nk_) {
-        // Issue lhs/rhs packing. Their completion will in turn kick off
-        // kernels.
-        if (parallel_pack_) {
-          enqueue_packing(k, !shard_by_col_);
-          enqueue_packing(k, shard_by_col_);
-        } else if (shard_by_col_) {
-          enqueue_packing(k, false);
-        } else {
-          enqueue_packing(k, true);
-        }
-
-        // Termination handling.
-        // Because kernel completion signals k + 2 switch, we need to finish nk
-        // + 2 slices without issuing any tasks on nk + 1 slice. So here we
-        // pretend that all nk + 1 packing tasks just finish instantly; so that
-        // nk + 2 switch only waits for completion of nk kernels.
-      } else if (k == nk_) {
-        signal_switch(k + 1, parallel_pack_ ? nm_ + nn_ : (shard_by_col_ ? nn_ : nm_));
-      } else {
-        done_.Notify();
-      }
-    }
-
-    // Enqueue all rhs/lhs packing for k-th slice.
-    void enqueue_packing(Index k, bool rhs) { enqueue_packing_helper(0, rhs ? nn_ : nm_, k, rhs); }
-
-    void enqueue_packing_helper(Index start, Index end, Index k, bool rhs) {
-      if (end - start == 1) {
-        if (rhs)
-          pack_rhs(start, k);
-        else
-          pack_lhs(start, k);
-      } else {
-        while (end - start > 1) {
-          Index mid = (start + end) / 2;
-          device_.enqueue([this, mid, end, k, rhs]() { enqueue_packing_helper(mid, end, k, rhs); });
-          end = mid;
-        }
-
-        // Decide if we want to run first packing task (start == 0) in
-        // async mode if we parallelize only by sharding dim:
-        // (1) pack_lhs and pack_rhs call signal_switch before completing
-        //     all calls to signal_kernel, which in sync mode might lead
-        //     to the execution of the first kernel of the k+1 slice, before
-        //     completing a call to the last kernel of the k slice.
-        // (2) all pack tasks for sharded dim must be executed in a thread
-        //     pool to get pre-allocated thead local buffers.
-        bool pack_async = (start == 0) && (parallelize_by_sharding_dim_only_ && shard_by_col_ == rhs) &&
-                          (k > 0 || std::this_thread::get_id() == created_by_thread_id_);
-
-        if (pack_async) {
-          device_.enqueue([this, start, end, k, rhs]() { enqueue_packing_helper(start, end, k, rhs); });
-        } else {
-          enqueue_packing_helper(start, end, k, rhs);
-        }
-      }
-    }
-
-    // Block sizes with accounting for potentially incomplete last block.
-    Index bm(Index m) const { return m + 1 < nm0_ ? bm_ : m_ + bm_ - bm_ * nm0_; }
-    Index bn(Index n) const { return n + 1 < nn0_ ? bn_ : n_ + bn_ - bn_ * nn0_; }
-    Index bk(Index k) const { return k + 1 < nk_ ? bk_ : k_ + bk_ - bk_ * nk_; }
-    // Task grain sizes accounting for potentially incomplete last task.
-    Index gm(Index m) const { return m + 1 < nm_ ? gm_ : nm0_ + gm_ - gm_ * nm_; }
-    Index gn(Index n) const { return n + 1 < nn_ ? gn_ : nn0_ + gn_ - gn_ * nn_; }
-
-    EvalParallelContext(const EvalParallelContext&) = delete;
-    void operator=(const EvalParallelContext&) = delete;
-  };
-
-  template <bool lhs_inner_dim_contiguous, bool rhs_inner_dim_contiguous, bool rhs_inner_dim_reordered, int Alignment>
-  using SyncEvalParallelContext = EvalParallelContext<NoCallback, lhs_inner_dim_contiguous, rhs_inner_dim_contiguous,
-                                                      rhs_inner_dim_reordered, Alignment>;
-
-  // ------------------------------------------------------------------------ //
-
-  // EvalShardedByInnerDimContext orchestrates sync/async contraction
-  // evaluation, when we shard by inner dimension. When it is executed in
-  // asynchronous mode, it owns all the shared state that might be accessible by
-  // block processing tasks.
-
-  template <typename DoneCallback>
-  struct EvalShardedByInnerDimContext {
-    EvalShardedByInnerDimContext(const Self* self, int num_threads, Scalar* result_buffer, Index m_size, Index n_size,
-                                 Index k_size, DoneCallback done_callback)
-        : evaluator(self),
-          m_lhs_inner_dim_contiguous(evaluator->m_lhs_inner_dim_contiguous),
-          m_rhs_inner_dim_contiguous(evaluator->m_rhs_inner_dim_contiguous),
-          m_rhs_inner_dim_reordered(evaluator->m_rhs_inner_dim_reordered),
-          result(result_buffer),
-          m(m_size),
-          n(n_size),
-          k(k_size),
-          done(std::move(done_callback)),
-          buffer_size_bytes(m * n * sizeof(Scalar)),
-          block_size(blockSize(k, num_threads)),
-          num_blocks(numext::div_ceil<Index>(k, block_size)),
-          num_pending_blocks(internal::convert_index<int>(num_blocks)),
-          l0_ranges(numext::div_ceil<Index>(num_blocks, l0_size)),
-          l0_state(l0_ranges),
-          block_buffers(num_blocks) {
-      // Keep count of pending gemm tasks for each l0 range.
-      for (int i = 0; i < l0_ranges; ++i) {
-        const Index num_pending_tasks = actualRangeSize(l0_ranges, l0_size, i);
-        l0_state.emplace_back(internal::convert_index<int>(num_pending_tasks));
-      }
-
-      // Allocate temporary buffers for each block.
-      for (Index block_idx = 0; block_idx < num_blocks; ++block_idx) {
-        Scalar* buf = block_idx == 0 ? result : static_cast<Scalar*>(evaluator->m_device.allocate(buffer_size_bytes));
-        block_buffers.emplace_back(buf);
-      }
-    }
-
-    ~EvalShardedByInnerDimContext() {
-      for (Index i = 1; i < num_blocks; ++i) {
-        evaluator->m_device.deallocate(block_buffers[i]);
-      }
-    }
-
-    template <int Alignment>
-    void run() {
-      Barrier barrier(internal::convert_index<int>(num_blocks));
-      eval<Alignment>(barrier, 0, num_blocks);
-      barrier.Wait();
-
-      // Aggregate partial sums from l0 ranges.
-      aggregateL0Blocks<Alignment>();
-
-      // Apply output kernel.
-      applyOutputKernel();
-    }
-
-    template <int Alignment>
-    void runAsync() {
-      evalAsync<Alignment>(0, num_blocks);
-    }
-
-   private:
-    // The underlying GEMM kernel assumes that k is a multiple of
-    // the packet size and subtle breakage occurs if this is violated.
-    static const Index packet_size = internal::packet_traits<RhsScalar>::size;
-
-    const Self* evaluator;  // TensorContraction evaluator
-
-    // These fields required fromTENSOR_CONTRACTION_DISPATCH macro.
-    bool m_lhs_inner_dim_contiguous;
-    bool m_rhs_inner_dim_contiguous;
-    bool m_rhs_inner_dim_reordered;
-
-    Scalar* result;
-
-    Index m;
-    Index n;
-    Index k;
-
-    DoneCallback done;
-
-    // ----------------------------------------------------------------------//
-    // Algorithm parameters.
-
-    // We will compute partial results into the buffers of this size.
-    Index buffer_size_bytes;
-
-    Index block_size;
-    Index num_blocks;
-
-    // Keep track of pending tasks when evaluate in async mode.
-    std::atomic<int> num_pending_blocks;
-
-    // We compute partial gemm results in parallel, and to get the final result
-    // we need to add them all together. For the large number of threads (>= 48)
-    // this adds a very expensive sequential step at the end.
-    //
-    // We split the [0, num_blocks) into small ranges, and when a task for the
-    // block finishes its partial gemm computation, it checks if it was the last
-    // gemm in the range, and if so, it will add all blocks of the range.
-    //
-    // After all tasks done, we need to add only these pre-aggregated blocks.
-
-    // For now we use just a single level of ranges to compute pre-aggregated
-    // partial sums, but in general we can use more layers to compute tree
-    // aggregation in parallel and reduce the size of the sequential step.
-    //
-    // TODO(ezhulenev): Add multilevel tree aggregation? Probably will make
-    // sense only if number of threads >= ~128?
-    static const Index l0_size = 4;
-    Index l0_ranges;
-
-    // Keep count of pending gemm tasks for each l0 range.
-    MaxSizeVector<std::atomic<int>> l0_state;  // [0, l0_ranges)
-
-    // Buffers allocated for each temporary block computation.
-    MaxSizeVector<Scalar*> block_buffers;  // [0, num_blocks)
-
-    template <int Alignment>
-    void processBlock(Index block_idx, Index begin, Index end) {
-      Scalar* buf = block_buffers[block_idx];
-
-      TENSOR_CONTRACTION_DISPATCH(evaluator->template evalGemmPartialWithoutOutputKernel, Alignment,
-                                  (buf, begin, end,
-                                   /*num_threads=*/internal::convert_index<int>(num_blocks)));
-
-      // Check if it was the last task in l0 range.
-      const Index l0_index = block_idx / l0_size;
-      const int v = l0_state[l0_index].fetch_sub(1);
-      eigen_assert(v >= 1);
-
-      // If we processed the last block of the range, we can aggregate all
-      // partial results into the first block of the range.
-      if (v == 1) {
-        const Index rng_size = actualRangeSize(l0_ranges, l0_size, l0_index);
-        const Index dst_block_idx = l0_index * l0_size;
-
-        if (rng_size == l0_size) {
-          addAllToBuffer<Alignment>(m * n,
-                                    /*src_buf0=*/block_buffers[dst_block_idx + 1],
-                                    /*src_buf1=*/block_buffers[dst_block_idx + 2],
-                                    /*src_buf2=*/block_buffers[dst_block_idx + 3],
-                                    /*dst_buf= */ block_buffers[dst_block_idx]);
-        } else {
-          // Aggregate blocks of potentially incomplete last range.
-          for (int i = 1; i < rng_size; ++i) {
-            addToBuffer<Alignment>(m * n,
-                                   /*src_buf=*/block_buffers[dst_block_idx + i],
-                                   /*dst_buf=*/block_buffers[dst_block_idx]);
-          }
-        }
-      }
-    }
-
-    // Aggregate partial sums from l0 ranges.
-    template <int Alignment>
-    void aggregateL0Blocks() const {
-      Index l0_index = 1;
-
-      for (; l0_index + 2 < l0_ranges; l0_index += 3) {
-        addAllToBuffer<Alignment>(m * n,
-                                  /*src_buf0=*/block_buffers[(l0_index + 0) * l0_size],
-                                  /*src_buf1=*/block_buffers[(l0_index + 1) * l0_size],
-                                  /*src_buf2=*/block_buffers[(l0_index + 2) * l0_size],
-                                  /*dst_buf= */ block_buffers[0]);
-      }
-
-      for (; l0_index < l0_ranges; ++l0_index) {
-        addToBuffer<Alignment>(m * n, block_buffers[l0_index * l0_size], block_buffers[0]);
-      }
-    }
-
-    void applyOutputKernel() const {
-      using OutputMapper = internal::blas_data_mapper<Scalar, Index, ColMajor>;
-      evaluator->m_output_kernel(OutputMapper(result, m), evaluator->m_tensor_contraction_params,
-                                 static_cast<Eigen::Index>(0), static_cast<Eigen::Index>(0), m, n);
-    }
-
-    // Compute block size with accounting for potentially incomplete last block.
-    Index actualBlockSize(Index block_idx) const {
-      return block_idx + 1 < num_blocks ? block_size : k + block_size - block_size * num_blocks;
-    };
-
-    // Compute range size with accounting for potentially incomplete last range.
-    Index actualRangeSize(Index num_ranges, Index range_size, Index range_idx) const {
-      eigen_assert(range_idx < num_ranges);
-      return range_idx + 1 < num_ranges ? range_size : num_blocks + range_size - range_size * num_ranges;
-    };
-
-    template <int Alignment>
-    EIGEN_STRONG_INLINE static void addToBuffer(size_t n, const Scalar* src_buf, Scalar* tgt_buf) {
-      const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
-      size_t i = 0;
-      const size_t num_packets = n / output_packet_size;
-      for (; i < output_packet_size * num_packets; i += output_packet_size) {
-        const PacketReturnType src_val = internal::pload<PacketReturnType>(src_buf + i);
-        const PacketReturnType tgt_val = internal::ploadt<PacketReturnType, Alignment>(tgt_buf + i);
-        const PacketReturnType sum = internal::padd(src_val, tgt_val);
-        internal::pstoret<Scalar, PacketReturnType, Alignment>(tgt_buf + i, sum);
-      }
-      for (; i < n; ++i) {
-        tgt_buf[i] += src_buf[i];
-      }
-    }
-
-    template <int Alignment>
-    EIGEN_STRONG_INLINE static void addAllToBuffer(size_t n, const Scalar* src_buf0, const Scalar* src_buf1,
-                                                   const Scalar* src_buf2, Scalar* dst_buf) {
-      using ::Eigen::internal::padd;
-      using ::Eigen::internal::pload;
-      using ::Eigen::internal::ploadt;
-      using ::Eigen::internal::pstoret;
-
-      const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
-
-      size_t i = 0;
-      const size_t num_packets = n / output_packet_size;
-      for (; i < output_packet_size * num_packets; i += output_packet_size) {
-        const auto src_val0 = pload<PacketReturnType>(src_buf0 + i);
-        const auto src_val1 = pload<PacketReturnType>(src_buf1 + i);
-        const auto src_val2 = pload<PacketReturnType>(src_buf2 + i);
-
-        const auto dst_val = ploadt<PacketReturnType, Alignment>(dst_buf + i);
-        const auto sum = padd(padd(dst_val, src_val0), padd(src_val1, src_val2));
-
-        pstoret<Scalar, PacketReturnType, Alignment>(dst_buf + i, sum);
-      }
-      for (; i < n; ++i) {
-        dst_buf[i] += src_buf0[i] + src_buf1[i] + src_buf2[i];
-      }
-    }
-
-    template <int Alignment>
-    void eval(Barrier& barrier, Index start_block_idx, Index end_block_idx) {
-      while (end_block_idx - start_block_idx > 1) {
-        Index mid_block_idx = (start_block_idx + end_block_idx) / 2;
-        evaluator->m_device.enqueue([this, &barrier, mid_block_idx, end_block_idx]() {
-          eval<Alignment>(barrier, mid_block_idx, end_block_idx);
-        });
-        end_block_idx = mid_block_idx;
-      }
-
-      Index block_idx = start_block_idx;
-      Index block_start = block_idx * block_size;
-      Index block_end = block_start + actualBlockSize(block_idx);
-
-      processBlock<Alignment>(block_idx, block_start, block_end);
-      barrier.Notify();
-    }
-
-    template <int Alignment>
-    void evalAsync(Index start_block_idx, Index end_block_idx) {
-      while (end_block_idx - start_block_idx > 1) {
-        Index mid_block_idx = (start_block_idx + end_block_idx) / 2;
-        evaluator->m_device.enqueue(
-            [this, mid_block_idx, end_block_idx]() { evalAsync<Alignment>(mid_block_idx, end_block_idx); });
-        end_block_idx = mid_block_idx;
-      }
-
-      Index block_idx = start_block_idx;
-
-      Index block_start = block_idx * block_size;
-      Index block_end = block_start + actualBlockSize(block_idx);
-
-      processBlock<Alignment>(block_idx, block_start, block_end);
-
-      int v = num_pending_blocks.fetch_sub(1);
-      eigen_assert(v >= 1);
-
-      if (v == 1) {
-        // Aggregate partial sums from l0 ranges.
-        aggregateL0Blocks<Alignment>();
-
-        // Apply output kernel.
-        applyOutputKernel();
-
-        // NOTE: If we call `done` callback before deleting this (context),
-        // it might deallocate Self* pointer captured by context, and we'll
-        // fail in destructor trying to deallocate temporary buffers.
-
-        // Move done call back from context before it will be destructed.
-        DoneCallback done_copy = std::move(done);
-
-        // We are confident that we are the last one who touches context.
-        delete this;
-
-        // Now safely call the done callback.
-        done_copy();
-      }
-    }
-
-    // Cost model doesn't capture well the cost associated with constructing
-    // tensor contraction mappers and computing loop bounds in gemm_pack_lhs
-    // and gemm_pack_rhs, so we specify minimum desired block size.
-    static Index blockSize(Index k, int num_threads) {
-      const auto round_up = [=](Index index) -> Index {
-        const Index kmultiple = packet_size <= 8 ? 8 : packet_size;
-        return numext::div_ceil<Index>(index, kmultiple) * kmultiple;
-      };
-
-      const Index target_block_size = round_up(numext::div_ceil<Index>(k, num_threads));
-      const Index desired_min_block_size = 12 * packet_size;
-
-      return numext::mini<Index>(k, numext::maxi<Index>(desired_min_block_size, target_block_size));
-    }
-
-    EvalShardedByInnerDimContext(const EvalShardedByInnerDimContext&) = delete;
-    void operator=(const EvalShardedByInnerDimContext&) = delete;
-  };
-
-  // ------------------------------------------------------------------------ //
-
-  // Below are the function used by evalProductImpl heuristics, trying to select
-  // optimal parameters for parallelization algorithm.
-
-  // Decide whether we want to shard m x n contraction by columns or by rows.
-  static bool shardByCol(Index m, Index n, Index num_threads) {
-    // Note: we are comparing both n and m against Traits::nr, it is not
-    // a mistake. We are trying to figure out how both n and m will fit into
-    // the main sharding dimension.
-
-    // Sharding by column is the default
-    // ... unless there is enough data for vectorization over rows
-    if (m / num_threads >= Traits::nr &&
-        // and not enough data for vectorization over columns
-        (n / num_threads < Traits::nr ||
-         // ... or barely enough data for vectorization over columns,
-         // but it is not evenly dividable across threads
-         (n / num_threads < 4 * Traits::nr && (n % (num_threads * Traits::nr)) != 0 &&
-          // ... and it is evenly dividable across threads for rows
-          ((m % (num_threads * Traits::nr)) == 0 ||
-           // .. or it is not evenly dividable for both dimensions but
-           // there is much more data over rows so that corner effects are
-           // mitigated.
-           (m / n >= 6)))))
-      return false;
-    // Wait, or if matrices are just substantially prolonged over the other
-    // dimension.
-    if (n / num_threads < 16 * Traits::nr && m > n * 32) return false;
-    return true;
-  }
-
-  Index coarsenM(Index m, Index n, Index bm, Index bn, Index bk, Index gn, int num_threads, bool shard_by_col) const {
-    Index gm = 1;
-    Index gm1 = 1;
-    Index nm0 = numext::div_ceil(m, bm);
-    Index nm1 = nm0;
-    for (;;) {
-      // Find the next candidate for m grain size. It needs to result in
-      // different number of blocks. E.g. if we have 10 kernels, we want to try
-      // 5 and 10, but not 6, 7, 8 and 9.
-      while (gm1 <= nm0 && nm1 == numext::div_ceil(nm0, gm1)) gm1++;
-      if (gm1 > nm0) break;
-      // Check the candidate.
-      int res = checkGrain(m, n, bm, bn, bk, gm1, gn, gm, gn, num_threads, shard_by_col);
-      if (res < 0) break;
-      nm1 = numext::div_ceil(nm0, gm1);
-      if (res == 0) continue;
-      // Commit new grain size.
-      gm = gm1;
-    }
-    return gm;
-  }
-
-  Index coarsenN(Index m, Index n, Index bm, Index bn, Index bk, Index gm, int num_threads, bool shard_by_col) const {
-    Index gn = 1;
-    Index gn1 = 1;
-    Index nn0 = numext::div_ceil(n, bn);
-    Index nn1 = nn0;
-    for (;;) {
-      while (gn1 <= nn0 && nn1 == numext::div_ceil(nn0, gn1)) gn1++;
-      if (gn1 > nn0) break;
-      int res = checkGrain(m, n, bm, bn, bk, gm, gn1, gm, gn, num_threads, shard_by_col);
-      if (res < 0) break;
-      nn1 = numext::div_ceil(nn0, gn1);
-      if (res == 0) continue;
-      gn = gn1;
-    }
-    return gn;
-  }
-
-  // checkGrain checks whether grain (gm, gn) is suitable and is better than
-  // (oldgm, oldgn).
-  int checkGrain(Index m, Index n, Index bm, Index bn, Index bk, Index gm, Index gn, Index oldgm, Index oldgn,
-                 int num_threads, bool shard_by_col) const {
-    const TensorOpCost cost = contractionCost(bm * gm, bn * gn, bm, bn, bk, shard_by_col, true);
-    double taskSize = TensorCostModel<ThreadPoolDevice>::taskSize(static_cast<double>(bm) * gm * bn * gn, cost);
-    // If the task is too small, then we agree on it regardless of anything
-    // else. Otherwise synchronization overheads will dominate.
-    if (taskSize < 1) return 1;
-    // If it is too large, then we reject it and all larger tasks.
-    if (taskSize > 2) return -1;
-    // Now we are in presumably good task size range.
-    // The main deciding factor here is parallelism. Consider that we have 12
-    // kernels and 4 threads. Grains of 2, 3 and 4 all yield good task sizes.
-    // But 2/4 yield 6/3 tasks, which gives us parallelism of 0.75 (at most 3/4
-    // of cores will be busy). While grain size 3 gives us 4 tasks, which gives
-    // us parallelism of 1 (we can load all cores).
-    Index nm0 = numext::div_ceil(m, bm);
-    Index nn0 = numext::div_ceil(n, bn);
-    Index new_tasks = numext::div_ceil(nm0, gm) * numext::div_ceil(nn0, gn);
-    double new_parallelism =
-        static_cast<double>(new_tasks) / (numext::div_ceil<Index>(new_tasks, num_threads) * num_threads);
-    Index old_tasks = numext::div_ceil(nm0, oldgm) * numext::div_ceil(nn0, oldgn);
-    double old_parallelism =
-        static_cast<double>(old_tasks) / (numext::div_ceil<Index>(old_tasks, num_threads) * num_threads);
-    if (new_parallelism > old_parallelism || new_parallelism == 1) return 1;
-    return 0;
-  }
-
-  TensorOpCost contractionCost(Index m, Index n, Index bm, Index bn, Index bk, bool shard_by_col,
-                               bool prepacked) const {
-    const int packed_size = std::min<int>(PacketType<LhsScalar, Device>::size, PacketType<RhsScalar, Device>::size);
-    const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
-    const double kd = static_cast<double>(bk);
-    double compute_bandwidth = computeBandwidth(false, bm, bn, bk);
-    // Computations.
-    TensorOpCost cost = TensorOpCost(0, 0, kd * compute_bandwidth, true, packed_size);
-    // Output stores.
-    cost += TensorOpCost(0, sizeof(CoeffReturnType), 0, true, output_packet_size);
-    if (prepacked) {
-      // Packing and kernels are executed in different tasks. When we calculate
-      // task grain size we look only at kernel cost assuming that kernel
-      // is more expensive than packing.
-      return cost;
-    }
-    // Lhs/rhs loads + computations.
-    TensorOpCost lhsCost = this->m_leftImpl.costPerCoeff(true) * (kd / n);
-    TensorOpCost rhsCost = this->m_rightImpl.costPerCoeff(true) * (kd / m);
-    // Lhs packing memory cost does not contribute considerably to overall
-    // execution time because lhs is prefetched early and accessed sequentially.
-    if (shard_by_col)
-      lhsCost.dropMemoryCost();
-    else
-      rhsCost.dropMemoryCost();
-    return cost + lhsCost + rhsCost;
-  }
-
-  // Decide whether we want to shard m x k x n contraction over the inner
-  // (contraction) dimension (k).
-  static bool shardByInnerDim(Index m, Index n, Index k, int num_threads, int num_threads_by_k) {
-    std::ptrdiff_t bufsize = m * n * sizeof(Scalar);
-    bool shard_by_k = false;
-    if (n == 1 ||                                      // If mat*vec or...
-        num_threads_by_k < 2 ||                        // running single threaded or...
-        num_threads_by_k < num_threads ||              // sharding by k gives less parallelism or...
-        bufsize > l3CacheSize() / num_threads_by_k ||  // need more buffer space
-        // than L3 cache or...
-        k / num_threads_by_k < 2 * Traits::nr) {  // k per thread is tiny.
-      shard_by_k = false;
-    } else if (numext::maxi(m, n) / num_threads < Traits::nr ||  // both other dimensions are tiny or...
-                                                                 // k per thread is not small and...
-               (k / num_threads_by_k > 8 * Traits::nr &&
-                // one of the outer dimensions is tiny or sharding by k offers
-                // more parallelism.
-                (numext::mini(m, n) < 2 * Traits::nr || num_threads_by_k > num_threads))) {
-      shard_by_k = true;
-    }
-    return shard_by_k;
-  }
-
-  TensorOpCost contractionCostPerInnerDim(Index m, Index n, Index k) const {
-    // Compute cost.
-    const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
-    TensorOpCost cost(0, 0, (computeBandwidth(true, m, n, k) * m) * n, true, output_packet_size);
-    // Output stores.
-    cost += TensorOpCost(0, sizeof(CoeffReturnType), 0, true, output_packet_size);
-    TensorOpCost lhsCost = this->m_leftImpl.costPerCoeff(true) * m;
-    TensorOpCost rhsCost = this->m_rightImpl.costPerCoeff(true) * n;
-    // Since the inner gemm kernel is always sharded by column, the lhs
-    // load cost is negligible.
-    lhsCost.dropMemoryCost();
-    return cost + lhsCost + rhsCost;
-  }
-
-  int numThreadsInnerDim(Index m, Index n, Index k) const {
-    const int output_packet_size = internal::unpacket_traits<PacketReturnType>::size;
-    TensorOpCost cost = contractionCostPerInnerDim(m, n, k);
-    double total_parallel_cost = TensorCostModel<ThreadPoolDevice>::totalCost(k, cost);
-    // Cost of reduction step accumulating the m*n per-thread buffers into the
-    // result.
-    double reduction_cost =
-        TensorCostModel<ThreadPoolDevice>::totalCost(m * n, TensorOpCost(2, 1, 1, true, output_packet_size));
-    int num_threads = 1;
-    double min_cost = total_parallel_cost;
-    double kPerThreadOverHead = 3000;
-    double kFixedOverHead = 100000;
-    for (int nt = 2; nt <= this->m_device.numThreads(); nt += 2) {
-      double sequential_cost = kFixedOverHead + nt * (reduction_cost + kPerThreadOverHead);
-      double parallel_cost = total_parallel_cost / nt + sequential_cost;
-      if (parallel_cost < min_cost) {
-        num_threads = nt;
-        min_cost = parallel_cost;
-      }
-    }
-    return num_threads;
-  }
-
-  double computeBandwidth(bool shard_by_col, Index bm, Index bn, Index bk) const {
-    // Peak VFMA bandwidth is 0.5. However if we have not enough data for
-    // vectorization bandwidth drops. The 4.0 and 2.0 bandwidth is determined
-    // experimentally.
-    double computeBandwidth = bk == 1                                                                          ? 4.0
-                              : (shard_by_col ? bn : bm) < Traits::nr || (shard_by_col ? bm : bn) < Traits::mr ? 2.0
-                                                                                                               : 0.5;
-#ifndef EIGEN_VECTORIZE_FMA
-    // Bandwidth of all of VFMA/MULPS/ADDPS is 0.5 on latest Intel processors.
-    // However for MULPS/ADDPS we have dependent sequence of 2 such
-    // instructions,
-    // so overall bandwidth is 1.0.
-    if (computeBandwidth == 0.5) computeBandwidth = 1.0;
-#endif
-    return computeBandwidth;
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_USE_THREADS
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_THREAD_POOL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorConversion.h b/unsupported/Eigen/src/Tensor/TensorConversion.h
deleted file mode 100644
index ccf96b7..0000000
--- a/unsupported/Eigen/src/Tensor/TensorConversion.h
+++ /dev/null
@@ -1,416 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename TargetType, typename XprType>
-struct traits<TensorConversionOp<TargetType, XprType> > {
-  // Type promotion to handle the case where the types of the lhs and the rhs are different.
-  typedef TargetType Scalar;
-  typedef typename traits<XprType>::StorageKind StorageKind;
-  typedef typename traits<XprType>::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = traits<XprType>::NumDimensions;
-  static constexpr int Layout = traits<XprType>::Layout;
-  enum { Flags = 0 };
-  typedef typename TypeConversion<Scalar, typename traits<XprType>::PointerType>::type PointerType;
-};
-
-template <typename TargetType, typename XprType>
-struct eval<TensorConversionOp<TargetType, XprType>, Eigen::Dense> {
-  typedef const TensorConversionOp<TargetType, XprType>& type;
-};
-
-template <typename TargetType, typename XprType>
-struct nested<TensorConversionOp<TargetType, XprType>, 1,
-              typename eval<TensorConversionOp<TargetType, XprType> >::type> {
-  typedef TensorConversionOp<TargetType, XprType> type;
-};
-
-}  // end namespace internal
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int SrcCoeffRatio, int TgtCoeffRatio>
-struct PacketConverter;
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
-
-  template <int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<LoadMode>(index));
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 2, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
-
-  template <int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-
-    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
-    SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
-    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2);
-    return result;
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 4, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
-
-  template <int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-
-    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
-    SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
-    SrcPacket src3 = m_impl.template packet<LoadMode>(index + 2 * SrcPacketSize);
-    SrcPacket src4 = m_impl.template packet<LoadMode>(index + 3 * SrcPacketSize);
-    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2, src3, src4);
-    return result;
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 8, 1> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {}
-
-  template <int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-
-    SrcPacket src1 = m_impl.template packet<LoadMode>(index);
-    SrcPacket src2 = m_impl.template packet<LoadMode>(index + 1 * SrcPacketSize);
-    SrcPacket src3 = m_impl.template packet<LoadMode>(index + 2 * SrcPacketSize);
-    SrcPacket src4 = m_impl.template packet<LoadMode>(index + 3 * SrcPacketSize);
-    SrcPacket src5 = m_impl.template packet<LoadMode>(index + 4 * SrcPacketSize);
-    SrcPacket src6 = m_impl.template packet<LoadMode>(index + 5 * SrcPacketSize);
-    SrcPacket src7 = m_impl.template packet<LoadMode>(index + 6 * SrcPacketSize);
-    SrcPacket src8 = m_impl.template packet<LoadMode>(index + 7 * SrcPacketSize);
-    TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2, src3, src4, src5, src6, src7, src8);
-    return result;
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-};
-
-template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int TgtCoeffRatio>
-struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, TgtCoeffRatio> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketConverter(const TensorEvaluator& impl)
-      : m_impl(impl), m_maxIndex(impl.dimensions().TotalSize()) {}
-
-  template <int LoadMode, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
-    const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
-    // Only call m_impl.packet() when we have direct access to the underlying data. This
-    // ensures that we don't compute the subexpression twice. We may however load some
-    // coefficients twice, but in practice this doesn't negatively impact performance.
-    if (m_impl.data() && (index + SrcPacketSize < m_maxIndex)) {
-      // Force unaligned memory loads since we can't ensure alignment anymore
-      return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<Unaligned>(index));
-    } else {
-      const int TgtPacketSize = internal::unpacket_traits<TgtPacket>::size;
-      typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
-      typedef typename internal::unpacket_traits<TgtPacket>::type TgtType;
-      internal::scalar_cast_op<SrcType, TgtType> converter;
-      EIGEN_ALIGN_MAX typename internal::unpacket_traits<TgtPacket>::type values[TgtPacketSize];
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < TgtPacketSize; ++i) {
-        values[i] = converter(m_impl.coeff(index + i));
-      }
-      TgtPacket rslt = internal::pload<TgtPacket>(values);
-      return rslt;
-    }
-  }
-
- private:
-  const TensorEvaluator& m_impl;
-  const typename TensorEvaluator::Index m_maxIndex;
-};
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor conversion class. This class makes it possible to vectorize
- * type casting operations when the number of scalars per packet in the source
- * and the destination type differ
- */
-template <typename TargetType, typename XprType>
-class TensorConversionOp : public TensorBase<TensorConversionOp<TargetType, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename internal::traits<TensorConversionOp>::Scalar Scalar;
-  typedef typename internal::traits<TensorConversionOp>::StorageKind StorageKind;
-  typedef typename internal::traits<TensorConversionOp>::Index Index;
-  typedef typename internal::nested<TensorConversionOp>::type Nested;
-  typedef Scalar CoeffReturnType;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConversionOp(const XprType& xpr) : m_xpr(xpr) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-};
-
-template <bool SameType, typename Eval, typename EvalPointerType>
-struct ConversionSubExprEval {
-  static EIGEN_STRONG_INLINE bool run(Eval& impl, EvalPointerType) {
-    impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-};
-
-template <typename Eval, typename EvalPointerType>
-struct ConversionSubExprEval<true, Eval, EvalPointerType> {
-  static EIGEN_STRONG_INLINE bool run(Eval& impl, EvalPointerType data) { return impl.evalSubExprsIfNeeded(data); }
-};
-
-#ifdef EIGEN_USE_THREADS
-template <bool SameType, typename Eval, typename EvalPointerType, typename EvalSubExprsCallback>
-struct ConversionSubExprEvalAsync {
-  static EIGEN_STRONG_INLINE void run(Eval& impl, EvalPointerType, EvalSubExprsCallback done) {
-    impl.evalSubExprsIfNeededAsync(nullptr, std::move(done));
-  }
-};
-
-template <typename Eval, typename EvalPointerType, typename EvalSubExprsCallback>
-struct ConversionSubExprEvalAsync<true, Eval, EvalPointerType, EvalSubExprsCallback> {
-  static EIGEN_STRONG_INLINE void run(Eval& impl, EvalPointerType data, EvalSubExprsCallback done) {
-    impl.evalSubExprsIfNeededAsync(data, std::move(done));
-  }
-};
-#endif
-
-namespace internal {
-
-template <typename SrcType, typename TargetType, bool IsSameT>
-struct CoeffConv {
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetType run(const TensorEvaluator<ArgType, Device>& impl,
-                                                              Index index) {
-    internal::scalar_cast_op<SrcType, TargetType> converter;
-    return converter(impl.coeff(index));
-  }
-};
-
-template <typename SrcType, typename TargetType>
-struct CoeffConv<SrcType, TargetType, true> {
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetType run(const TensorEvaluator<ArgType, Device>& impl,
-                                                              Index index) {
-    return impl.coeff(index);
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode, bool ActuallyVectorize, bool IsSameT>
-struct PacketConv {
-  typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
-  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
-
-  static constexpr int PacketSize = internal::unpacket_traits<TargetPacket>::size;
-
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
-                                                                Index index) {
-    internal::scalar_cast_op<SrcType, TargetType> converter;
-    EIGEN_ALIGN_MAX std::remove_const_t<TargetType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = converter(impl.coeff(index + i));
-    }
-    TargetPacket rslt = internal::pload<TargetPacket>(values);
-    return rslt;
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode, bool IsSameT>
-struct PacketConv<SrcPacket, TargetPacket, LoadMode, true, IsSameT> {
-  typedef typename internal::unpacket_traits<SrcPacket>::type SrcType;
-  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
-
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
-                                                                Index index) {
-    const int SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
-    const int TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
-    PacketConverter<TensorEvaluator<ArgType, Device>, SrcPacket, TargetPacket, SrcCoeffRatio, TgtCoeffRatio> converter(
-        impl);
-    return converter.template packet<LoadMode>(index);
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode>
-struct PacketConv<SrcPacket, TargetPacket, LoadMode, /*ActuallyVectorize=*/false, /*IsSameT=*/true> {
-  typedef typename internal::unpacket_traits<TargetPacket>::type TargetType;
-  static constexpr int PacketSize = internal::unpacket_traits<TargetPacket>::size;
-
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
-                                                                Index index) {
-    EIGEN_ALIGN_MAX std::remove_const_t<TargetType> values[PacketSize];
-    for (int i = 0; i < PacketSize; ++i) values[i] = impl.coeff(index + i);
-    return internal::pload<TargetPacket>(values);
-  }
-};
-
-template <typename SrcPacket, typename TargetPacket, int LoadMode>
-struct PacketConv<SrcPacket, TargetPacket, LoadMode, /*ActuallyVectorize=*/true, /*IsSameT=*/true> {
-  template <typename ArgType, typename Device>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TargetPacket run(const TensorEvaluator<ArgType, Device>& impl,
-                                                                Index index) {
-    return impl.template packet<LoadMode>(index);
-  }
-};
-
-}  // namespace internal
-
-// Eval as rvalue
-template <typename TargetType, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorConversionOp<TargetType, ArgType>, Device> {
-  typedef TensorConversionOp<TargetType, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  typedef TargetType Scalar;
-  typedef TargetType CoeffReturnType;
-  typedef internal::remove_all_t<typename internal::traits<ArgType>::Scalar> SrcType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename PacketType<SrcType, Device>::type PacketSourceType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  static constexpr bool IsSameType = internal::is_same<TargetType, SrcType>::value;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  enum {
-    IsAligned = false,
-    PacketAccess =
-#ifndef EIGEN_USE_SYCL
-        true,
-#else
-        TensorEvaluator<ArgType, Device>::PacketAccess &
-        internal::type_casting_traits<SrcType, TargetType>::VectorizedCast,
-#endif
-    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    RawAccess = false
-  };
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  static constexpr int NumDims = internal::array_size<Dimensions>::value;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
-
-  struct TensorConversionOpBlockFactory {
-    template <typename ArgXprType>
-    struct XprType {
-      typedef TensorConversionOp<TargetType, const ArgXprType> type;
-    };
-
-    template <typename ArgXprType>
-    typename XprType<ArgXprType>::type expr(const ArgXprType& expr) const {
-      return typename XprType<ArgXprType>::type(expr);
-    }
-  };
-
-  typedef internal::TensorUnaryExprBlock<TensorConversionOpBlockFactory, ArgTensorBlock> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    return ConversionSubExprEval<IsSameType, TensorEvaluator<ArgType, Device>, EvaluatorPointerType>::run(m_impl, data);
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType data, EvalSubExprsCallback done) {
-    ConversionSubExprEvalAsync<IsSameType, TensorEvaluator<ArgType, Device>, EvaluatorPointerType,
-                               EvalSubExprsCallback>::run(m_impl, data, std::move(done));
-  }
-#endif
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    return internal::CoeffConv<SrcType, TargetType, IsSameType>::run(m_impl, index);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    // If we are not going to do the cast, we just need to check that base
-    // TensorEvaluator has packet access. Otherwise we also need to make sure,
-    // that we have an implementation of vectorized cast.
-    const bool Vectorizable = IsSameType ? TensorEvaluator<ArgType, Device>::PacketAccess
-                                         : int(TensorEvaluator<ArgType, Device>::PacketAccess) &
-                                               int(internal::type_casting_traits<SrcType, TargetType>::VectorizedCast);
-
-    return internal::PacketConv<PacketSourceType, PacketReturnType, LoadMode, Vectorizable, IsSameType>::run(m_impl,
-                                                                                                             index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double cast_cost = TensorOpCost::CastCost<SrcType, TargetType>();
-    if (vectorized) {
-      const double SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
-      const double TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
-      return m_impl.costPerCoeff(vectorized) * (SrcCoeffRatio / PacketSize) +
-             TensorOpCost(0, 0, TgtCoeffRatio * (cast_cost / PacketSize));
-    } else {
-      return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, cast_cost);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return m_impl.getResourceRequirements();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    return TensorBlock(m_impl.block(desc, scratch), TensorConversionOpBlockFactory());
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  /// required by sycl in order to extract the sycl accessor
-  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-
- protected:
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorConvolution.h b/unsupported/Eigen/src/Tensor/TensorConvolution.h
deleted file mode 100644
index 021f7cd..0000000
--- a/unsupported/Eigen/src/Tensor/TensorConvolution.h
+++ /dev/null
@@ -1,1112 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONVOLUTION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONVOLUTION_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Index, typename InputDims, int NumKernelDims, int Layout>
-class IndexMapper {
- public:
-  IndexMapper(const InputDims& input_dims, const array<Index, NumKernelDims>& kernel_dims,
-              const array<Index, NumKernelDims>& indices) {
-    array<Index, NumDims> dimensions = input_dims;
-    for (int i = 0; i < NumKernelDims; ++i) {
-      const Index index = indices[i];
-      const Index input_dim = input_dims[index];
-      const Index kernel_dim = kernel_dims[i];
-      const Index result_dim = input_dim - kernel_dim + 1;
-      dimensions[index] = result_dim;
-    }
-
-    array<Index, NumDims> inputStrides;
-    array<Index, NumDims> outputStrides;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      inputStrides[0] = 1;
-      outputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        inputStrides[i] = inputStrides[i - 1] * input_dims[i - 1];
-        outputStrides[i] = outputStrides[i - 1] * dimensions[i - 1];
-      }
-    } else {
-      inputStrides[NumDims - 1] = 1;
-      outputStrides[NumDims - 1] = 1;
-      for (int i = static_cast<int>(NumDims) - 2; i >= 0; --i) {
-        inputStrides[i] = inputStrides[i + 1] * input_dims[i + 1];
-        outputStrides[i] = outputStrides[i + 1] * dimensions[i + 1];
-      }
-    }
-
-    array<Index, NumDims> gpuInputDimensions;
-    array<Index, NumDims> gpuOutputDimensions;
-    array<Index, NumDims> tmp = dimensions;
-    array<Index, NumDims> ordering;
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    for (int i = 0; i < NumKernelDims; ++i) {
-      const Index index = i + offset;
-      ordering[index] = indices[i];
-      tmp[indices[i]] = -1;
-      gpuInputDimensions[index] = input_dims[indices[i]];
-      gpuOutputDimensions[index] = dimensions[indices[i]];
-    }
-
-    int written = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? NumKernelDims : 0;
-    for (int i = 0; i < NumDims; ++i) {
-      if (tmp[i] >= 0) {
-        ordering[written] = i;
-        gpuInputDimensions[written] = input_dims[i];
-        gpuOutputDimensions[written] = dimensions[i];
-        ++written;
-      }
-    }
-
-    for (int i = 0; i < NumDims; ++i) {
-      m_inputStrides[i] = inputStrides[ordering[i]];
-      m_outputStrides[i] = outputStrides[ordering[i]];
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = 0; i < NumDims; ++i) {
-        if (i > NumKernelDims) {
-          m_gpuInputStrides[i] = m_gpuInputStrides[i - 1] * gpuInputDimensions[i - 1];
-          m_gpuOutputStrides[i] = m_gpuOutputStrides[i - 1] * gpuOutputDimensions[i - 1];
-        } else {
-          m_gpuInputStrides[i] = 1;
-          m_gpuOutputStrides[i] = 1;
-        }
-      }
-    } else {
-      for (int i = NumDims - 1; i >= 0; --i) {
-        if (static_cast<size_t>(i + 1) < offset) {
-          m_gpuInputStrides[i] = m_gpuInputStrides[i + 1] * gpuInputDimensions[i + 1];
-          m_gpuOutputStrides[i] = m_gpuOutputStrides[i + 1] * gpuOutputDimensions[i + 1];
-        } else {
-          m_gpuInputStrides[i] = 1;
-          m_gpuOutputStrides[i] = 1;
-        }
-      }
-    }
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputPlaneToTensorInputOffset(Index p) const {
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int d = NumDims - 1; d > NumKernelDims; --d) {
-        const Index idx = p / m_gpuInputStrides[d];
-        inputIndex += idx * m_inputStrides[d];
-        p -= idx * m_gpuInputStrides[d];
-      }
-      if (NumKernelDims < NumDims) {
-        inputIndex += p * m_inputStrides[NumKernelDims];
-      }
-    } else {
-      std::ptrdiff_t limit = 0;
-      if (NumKernelDims < NumDims) {
-        limit = NumDims - NumKernelDims - 1;
-      }
-      for (int d = 0; d < limit; ++d) {
-        const Index idx = p / m_gpuInputStrides[d];
-        inputIndex += idx * m_inputStrides[d];
-        p -= idx * m_gpuInputStrides[d];
-      }
-      inputIndex += p * m_inputStrides[limit];
-    }
-    return inputIndex;
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputPlaneToTensorOutputOffset(Index p) const {
-    Index outputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int d = NumDims - 1; d > NumKernelDims; --d) {
-        const Index idx = p / m_gpuOutputStrides[d];
-        outputIndex += idx * m_outputStrides[d];
-        p -= idx * m_gpuOutputStrides[d];
-      }
-      if (NumKernelDims < NumDims) {
-        outputIndex += p * m_outputStrides[NumKernelDims];
-      }
-    } else {
-      std::ptrdiff_t limit = 0;
-      if (NumKernelDims < NumDims) {
-        limit = NumDims - NumKernelDims - 1;
-      }
-      for (int d = 0; d < limit; ++d) {
-        const Index idx = p / m_gpuOutputStrides[d];
-        outputIndex += idx * m_outputStrides[d];
-        p -= idx * m_gpuOutputStrides[d];
-      }
-      outputIndex += p * m_outputStrides[limit];
-    }
-    return outputIndex;
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputKernelToTensorInputOffset(Index i) const {
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    return i * m_inputStrides[offset];
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputKernelToTensorOutputOffset(Index i) const {
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    return i * m_outputStrides[offset];
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputKernelToTensorInputOffset(Index i, Index j) const {
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    return i * m_inputStrides[offset] + j * m_inputStrides[offset + 1];
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputKernelToTensorOutputOffset(Index i, Index j) const {
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    return i * m_outputStrides[offset] + j * m_outputStrides[offset + 1];
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuInputKernelToTensorInputOffset(Index i, Index j, Index k) const {
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    return i * m_inputStrides[offset] + j * m_inputStrides[offset + 1] + k * m_inputStrides[offset + 2];
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index mapGpuOutputKernelToTensorOutputOffset(Index i, Index j, Index k) const {
-    const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
-    return i * m_outputStrides[offset] + j * m_outputStrides[offset + 1] + k * m_outputStrides[offset + 2];
-  }
-
- private:
-  static constexpr int NumDims = internal::array_size<InputDims>::value;
-  array<Index, NumDims> m_inputStrides;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims> m_gpuInputStrides;
-  array<Index, NumDims> m_gpuOutputStrides;
-};
-
-template <typename Dimensions, typename InputXprType, typename KernelXprType>
-struct traits<TensorConvolutionOp<Dimensions, InputXprType, KernelXprType> > {
-  // Type promotion to handle the case where the types of the lhs and the rhs are different.
-  typedef typename promote_storage_type<typename InputXprType::Scalar, typename KernelXprType::Scalar>::ret Scalar;
-  typedef typename promote_storage_type<typename traits<InputXprType>::StorageKind,
-                                        typename traits<KernelXprType>::StorageKind>::ret StorageKind;
-  typedef typename promote_index_type<typename traits<InputXprType>::Index, typename traits<KernelXprType>::Index>::type
-      Index;
-  typedef typename InputXprType::Nested LhsNested;
-  typedef typename KernelXprType::Nested RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
-  static constexpr int NumDimensions = traits<InputXprType>::NumDimensions;
-  static constexpr int Layout = traits<InputXprType>::Layout;
-  typedef std::conditional_t<Pointer_type_promotion<typename InputXprType::Scalar, Scalar>::val,
-                             typename traits<InputXprType>::PointerType, typename traits<KernelXprType>::PointerType>
-      PointerType;
-
-  enum { Flags = 0 };
-};
-
-template <typename Dimensions, typename InputXprType, typename KernelXprType>
-struct eval<TensorConvolutionOp<Dimensions, InputXprType, KernelXprType>, Eigen::Dense> {
-  typedef const TensorConvolutionOp<Dimensions, InputXprType, KernelXprType>& type;
-};
-
-template <typename Dimensions, typename InputXprType, typename KernelXprType>
-struct nested<TensorConvolutionOp<Dimensions, InputXprType, KernelXprType>, 1,
-              typename eval<TensorConvolutionOp<Dimensions, InputXprType, KernelXprType> >::type> {
-  typedef TensorConvolutionOp<Dimensions, InputXprType, KernelXprType> type;
-};
-
-}  // end namespace internal
-
-/** Tensor convolution class.
- * \ingroup CXX11_Tensor_Module
- */
-template <typename Indices, typename InputXprType, typename KernelXprType>
-class TensorConvolutionOp
-    : public TensorBase<TensorConvolutionOp<Indices, InputXprType, KernelXprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorConvolutionOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename internal::promote_storage_type<typename InputXprType::CoeffReturnType,
-                                                  typename KernelXprType::CoeffReturnType>::ret CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorConvolutionOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorConvolutionOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorConvolutionOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConvolutionOp(const InputXprType& input, const KernelXprType& kernel,
-                                                            const Indices& dims)
-      : m_input_xpr(input), m_kernel_xpr(kernel), m_indices(dims) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Indices& indices() const { return m_indices; }
-
-  /** \returns the nested expressions */
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all_t<typename InputXprType::Nested>& inputExpression()
-      const {
-    return m_input_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all_t<typename KernelXprType::Nested>& kernelExpression()
-      const {
-    return m_kernel_xpr;
-  }
-
- protected:
-  typename InputXprType::Nested m_input_xpr;
-  typename KernelXprType::Nested m_kernel_xpr;
-  const Indices m_indices;
-};
-
-template <typename Indices, typename InputArgType, typename KernelArgType, typename Device>
-struct TensorEvaluator<const TensorConvolutionOp<Indices, InputArgType, KernelArgType>, Device> {
-  typedef TensorConvolutionOp<Indices, InputArgType, KernelArgType> XprType;
-
-  static constexpr int NumDims =
-      internal::array_size<typename TensorEvaluator<InputArgType, Device>::Dimensions>::value;
-  static constexpr int NumKernelDims = internal::array_size<Indices>::value;
-  typedef typename XprType::Index Index;
-  typedef DSizes<Index, NumDims> Dimensions;
-
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<Scalar, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<InputArgType, Device>::Layout;
-  enum {
-    IsAligned =
-        int(TensorEvaluator<InputArgType, Device>::IsAligned) & int(TensorEvaluator<KernelArgType, Device>::IsAligned),
-    PacketAccess = int(TensorEvaluator<InputArgType, Device>::PacketAccess) &
-                   int(TensorEvaluator<KernelArgType, Device>::PacketAccess),
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_inputImpl(op.inputExpression(), device),
-        m_kernelImpl(op.kernelExpression(), device),
-        m_kernelArg(op.kernelExpression()),
-        m_kernel(NULL),
-        m_local_kernel(false),
-        m_device(device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<InputArgType, Device>::Layout) ==
-                         static_cast<int>(TensorEvaluator<KernelArgType, Device>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    const typename TensorEvaluator<InputArgType, Device>::Dimensions& input_dims = m_inputImpl.dimensions();
-    const typename TensorEvaluator<KernelArgType, Device>::Dimensions& kernel_dims = m_kernelImpl.dimensions();
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputStride[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_inputStride[i] = m_inputStride[i - 1] * input_dims[i - 1];
-      }
-    } else {
-      m_inputStride[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_inputStride[i] = m_inputStride[i + 1] * input_dims[i + 1];
-      }
-    }
-
-    m_dimensions = m_inputImpl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = 0; i < NumKernelDims; ++i) {
-        const Index index = op.indices()[i];
-        const Index input_dim = input_dims[index];
-        const Index kernel_dim = kernel_dims[i];
-        const Index result_dim = input_dim - kernel_dim + 1;
-        m_dimensions[index] = result_dim;
-        if (i > 0) {
-          m_kernelStride[i] = m_kernelStride[i - 1] * kernel_dims[i - 1];
-        } else {
-          m_kernelStride[0] = 1;
-        }
-        m_indexStride[i] = m_inputStride[index];
-      }
-
-      m_outputStride[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStride[i] = m_outputStride[i - 1] * m_dimensions[i - 1];
-      }
-    } else {
-      for (int i = NumKernelDims - 1; i >= 0; --i) {
-        const Index index = op.indices()[i];
-        const Index input_dim = input_dims[index];
-        const Index kernel_dim = kernel_dims[i];
-        const Index result_dim = input_dim - kernel_dim + 1;
-        m_dimensions[index] = result_dim;
-        if (i < NumKernelDims - 1) {
-          m_kernelStride[i] = m_kernelStride[i + 1] * kernel_dims[i + 1];
-        } else {
-          m_kernelStride[NumKernelDims - 1] = 1;
-        }
-        m_indexStride[i] = m_inputStride[index];
-      }
-
-      m_outputStride[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStride[i] = m_outputStride[i + 1] * m_dimensions[i + 1];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar*) {
-    m_inputImpl.evalSubExprsIfNeeded(NULL);
-    preloadKernel();
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_inputImpl.cleanup();
-    if (m_local_kernel) {
-      m_device.deallocate((void*)m_kernel);
-      m_local_kernel = false;
-    }
-    m_kernel = NULL;
-  }
-
-  void evalTo(typename XprType::Scalar* buffer) {
-    evalSubExprsIfNeeded(NULL);
-    for (int i = 0; i < dimensions().TotalSize(); ++i) {
-      buffer[i] += coeff(i);
-    }
-    cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    CoeffReturnType result = CoeffReturnType(0);
-    convolve(firstInput(index), 0, NumKernelDims - 1, result);
-    return result;
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(const Index index) const {
-    Index indices[2] = {index, index + PacketSize - 1};
-    Index startInputs[2] = {0, 0};
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx0 = indices[0] / m_outputStride[i];
-        const Index idx1 = indices[1] / m_outputStride[i];
-        startInputs[0] += idx0 * m_inputStride[i];
-        startInputs[1] += idx1 * m_inputStride[i];
-        indices[0] -= idx0 * m_outputStride[i];
-        indices[1] -= idx1 * m_outputStride[i];
-      }
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx0 = indices[0] / m_outputStride[i];
-        const Index idx1 = indices[1] / m_outputStride[i];
-        startInputs[0] += idx0 * m_inputStride[i];
-        startInputs[1] += idx1 * m_inputStride[i];
-        indices[0] -= idx0 * m_outputStride[i];
-        indices[1] -= idx1 * m_outputStride[i];
-      }
-    }
-    startInputs[0] += indices[0];
-    startInputs[1] += indices[1];
-
-    if (startInputs[1] - startInputs[0] == PacketSize - 1) {
-      PacketReturnType result = internal::pset1<PacketReturnType>(0);
-      convolvePacket(startInputs[0], 0, NumKernelDims - 1, result);
-      return result;
-    } else {
-      EIGEN_ALIGN_MAX Scalar data[PacketSize];
-      data[0] = Scalar(0);
-      convolve(startInputs[0], 0, NumKernelDims - 1, data[0]);
-      for (int i = 1; i < PacketSize - 1; ++i) {
-        data[i] = Scalar(0);
-        convolve(firstInput(index + i), 0, NumKernelDims - 1, data[i]);
-      }
-      data[PacketSize - 1] = Scalar(0);
-      convolve(startInputs[1], 0, NumKernelDims - 1, data[PacketSize - 1]);
-      return internal::pload<PacketReturnType>(data);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double kernel_size = m_kernelImpl.dimensions().TotalSize();
-    // We ignore the use of fused multiply-add.
-    const double convolve_compute_cost = TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>();
-    const double firstIndex_compute_cost =
-        NumDims *
-        (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
-    return TensorOpCost(0, 0, firstIndex_compute_cost, vectorized, PacketSize) +
-           kernel_size * (m_inputImpl.costPerCoeff(vectorized) + m_kernelImpl.costPerCoeff(vectorized) +
-                          TensorOpCost(0, 0, convolve_compute_cost, vectorized, PacketSize));
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- private:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index firstInput(Index index) const {
-    Index startInput = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_outputStride[i];
-        startInput += idx * m_inputStride[i];
-        index -= idx * m_outputStride[i];
-      }
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_outputStride[i];
-        startInput += idx * m_inputStride[i];
-        index -= idx * m_outputStride[i];
-      }
-    }
-    startInput += index;
-    return startInput;
-  }
-
-  EIGEN_DEVICE_FUNC void convolve(Index firstIndex, Index firstKernel, int DimIndex, CoeffReturnType& accum) const {
-    for (int j = 0; j < m_kernelImpl.dimensions()[DimIndex]; ++j) {
-      const Index input = firstIndex + j * m_indexStride[DimIndex];
-      const Index kernel = firstKernel + j * m_kernelStride[DimIndex];
-      if (DimIndex > 0) {
-        convolve(input, kernel, DimIndex - 1, accum);
-      } else {
-        accum += m_inputImpl.coeff(input) * m_kernel[kernel];
-      }
-    }
-  }
-
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC void convolvePacket(Index firstIndex, Index firstKernel, int DimIndex, Packet& accum) const {
-    for (int j = 0; j < m_kernelImpl.dimensions()[DimIndex]; ++j) {
-      const Index input = firstIndex + j * m_indexStride[DimIndex];
-      const Index kernel = firstKernel + j * m_kernelStride[DimIndex];
-      if (DimIndex > 0) {
-        convolvePacket(input, kernel, DimIndex - 1, accum);
-      } else {
-        accum = internal::pmadd<Packet>(m_inputImpl.template packet<Unaligned>(input),
-                                        internal::pset1<Packet>(m_kernel[kernel]), accum);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void preloadKernel() {
-    // Don't make a local copy of the kernel unless we have to (i.e. it's an
-    // expression that needs to be evaluated)
-    const Scalar* in_place = m_kernelImpl.data();
-    if (in_place) {
-      m_kernel = in_place;
-      m_local_kernel = false;
-    } else {
-      size_t kernel_sz = m_kernelImpl.dimensions().TotalSize() * sizeof(Scalar);
-      Scalar* local = (Scalar*)m_device.allocate_temp(kernel_sz);
-      typedef TensorEvalToOp<const KernelArgType> EvalTo;
-      EvalTo evalToTmp(local, m_kernelArg);
-      const bool Vectorize = internal::IsVectorizable<Device, KernelArgType>::value;
-      internal::TensorExecutor<const EvalTo, Device, Vectorize>::run(evalToTmp, m_device);
-
-      m_kernel = local;
-      m_local_kernel = true;
-    }
-  }
-
-  array<Index, NumDims> m_inputStride;
-  array<Index, NumDims> m_outputStride;
-
-  array<Index, NumKernelDims> m_indexStride;
-  array<Index, NumKernelDims> m_kernelStride;
-  TensorEvaluator<InputArgType, Device> m_inputImpl;
-  TensorEvaluator<KernelArgType, Device> m_kernelImpl;
-  Dimensions m_dimensions;
-
-  KernelArgType m_kernelArg;
-  const Scalar* m_kernel;
-  bool m_local_kernel;
-  const Device EIGEN_DEVICE_REF m_device;
-};
-
-// Use an optimized implementation of the evaluation code for GPUs whenever possible.
-#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
-
-template <int StaticKernelSize>
-struct GetKernelSize {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int operator()(const int /*kernelSize*/) const { return StaticKernelSize; }
-};
-template <>
-struct GetKernelSize<Dynamic> {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int operator()(const int kernelSize) const { return kernelSize; }
-};
-
-template <typename InputEvaluator, typename Index, typename InputDims, int StaticKernelSize>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void EigenConvolutionKernel1D(
-    InputEvaluator eval, const internal::IndexMapper<Index, InputDims, 1, InputEvaluator::Layout> indexMapper,
-    const float* __restrict kernel, const int numPlanes, const int numX, const int maxX, const int kernelSize,
-    float* buffer) {
-#if defined(EIGEN_HIPCC)
-  HIP_DYNAMIC_SHARED(float, s)
-#else
-  extern __shared__ float s[];
-#endif
-
-  const int first_x = blockIdx.x * maxX;
-  const int last_x = (first_x + maxX < numX ? first_x + maxX : numX) - 1;
-  const int num_x_input = last_x - first_x + GetKernelSize<StaticKernelSize>()(kernelSize);
-  const int num_x_output = last_x - first_x + 1;
-
-  const int first_plane = blockIdx.y * blockDim.y;
-  const int plane_stride = blockDim.y * gridDim.y;
-
-  for (int p = first_plane + threadIdx.y; p < numPlanes; p += plane_stride) {
-    // Load inputs to shared memory
-    const int plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
-    const int plane_kernel_offset = threadIdx.y * num_x_input;
-#pragma unroll
-    for (int i = threadIdx.x; i < num_x_input; i += blockDim.x) {
-      const int tensor_index = plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(i + first_x);
-      s[i + plane_kernel_offset] = eval.coeff(tensor_index);
-    }
-
-    __syncthreads();
-
-    // Compute the convolution
-    const int plane_output_offset = indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p);
-
-#pragma unroll
-    for (int i = threadIdx.x; i < num_x_output; i += blockDim.x) {
-      const int kernel_offset = plane_kernel_offset + i;
-      float result = 0.0f;
-#pragma unroll
-      for (int k = 0; k < GetKernelSize<StaticKernelSize>()(kernelSize); ++k) {
-        result += s[k + kernel_offset] * kernel[k];
-      }
-      const int tensor_index = plane_output_offset + indexMapper.mapGpuOutputKernelToTensorOutputOffset(i + first_x);
-      buffer[tensor_index] = result;
-    }
-    __syncthreads();
-  }
-};
-
-template <typename InputEvaluator, typename Index, typename InputDims, int StaticKernelSizeX, int StaticKernelSizeY>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void EigenConvolutionKernel2D(
-    InputEvaluator eval, const internal::IndexMapper<Index, InputDims, 2, InputEvaluator::Layout> indexMapper,
-    const float* __restrict kernel, const int numPlanes, const int numX, const int maxX, const int numY, const int maxY,
-    const int kernelSizeX, const int kernelSizeY, float* buffer) {
-#if defined(EIGEN_HIPCC)
-  HIP_DYNAMIC_SHARED(float, s)
-#else
-  extern __shared__ float s[];
-#endif
-
-  const int first_x = blockIdx.x * maxX;
-  const int last_x = (first_x + maxX < numX ? first_x + maxX : numX) - 1;
-  const int num_x_input = last_x - first_x + GetKernelSize<StaticKernelSizeX>()(kernelSizeX);
-  const int num_x_output = last_x - first_x + 1;
-
-  const int first_y = blockIdx.y * maxY;
-  const int last_y = (first_y + maxY < numY ? first_y + maxY : numY) - 1;
-  const int num_y_input = last_y - first_y + GetKernelSize<StaticKernelSizeY>()(kernelSizeY);
-  const int num_y_output = last_y - first_y + 1;
-
-  const int first_plane = blockIdx.z * blockDim.z;
-  const int plane_stride = blockDim.z * gridDim.z;
-
-  for (int p = first_plane + threadIdx.z; p < numPlanes; p += plane_stride) {
-    const int plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
-    const int plane_kernel_offset = threadIdx.z * num_y_input;
-
-// Load inputs to shared memory
-#pragma unroll
-    for (int j = threadIdx.y; j < num_y_input; j += blockDim.y) {
-      const int input_offset = num_x_input * (j + plane_kernel_offset);
-#pragma unroll
-      for (int i = threadIdx.x; i < num_x_input; i += blockDim.x) {
-        const int tensor_index =
-            plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(i + first_x, j + first_y);
-        s[i + input_offset] = eval.coeff(tensor_index);
-      }
-    }
-
-    __syncthreads();
-
-    // Convolution
-    const int plane_output_offset = indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p);
-
-#pragma unroll
-    for (int j = threadIdx.y; j < num_y_output; j += blockDim.y) {
-#pragma unroll
-      for (int i = threadIdx.x; i < num_x_output; i += blockDim.x) {
-        float result = 0.0f;
-#pragma unroll
-        for (int l = 0; l < GetKernelSize<StaticKernelSizeY>()(kernelSizeY); ++l) {
-          const int kernel_offset = kernelSizeX * l;
-          const int input_offset = i + num_x_input * (j + l + plane_kernel_offset);
-#pragma unroll
-          for (int k = 0; k < GetKernelSize<StaticKernelSizeX>()(kernelSizeX); ++k) {
-            result += s[k + input_offset] * kernel[k + kernel_offset];
-          }
-        }
-        const int tensor_index =
-            plane_output_offset + indexMapper.mapGpuOutputKernelToTensorOutputOffset(i + first_x, j + first_y);
-        buffer[tensor_index] = result;
-      }
-    }
-
-    __syncthreads();
-  }
-};
-
-template <typename InputEvaluator, typename Index, typename InputDims>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void EigenConvolutionKernel3D(
-    InputEvaluator eval, const internal::IndexMapper<Index, InputDims, 3, InputEvaluator::Layout> indexMapper,
-    const float* __restrict kernel, const size_t numPlanes, const size_t numX, const size_t maxX, const size_t numY,
-    const size_t maxY, const size_t numZ, const size_t maxZ, const int kernelSizeX, const int kernelSizeY,
-    const int kernelSizeZ, float* buffer) {
-#if defined(EIGEN_HIPCC)
-  HIP_DYNAMIC_SHARED(float, s)
-#else
-  extern __shared__ float s[];
-#endif
-
-  // Load inputs to shared memory
-  const int first_x = blockIdx.x * static_cast<int>(maxX);
-  const int last_x = (first_x + static_cast<int>(maxX) < static_cast<int>(numX) ? first_x + static_cast<int>(maxX)
-                                                                                : static_cast<int>(numX)) -
-                     1;
-  const int num_x_input = last_x - first_x + kernelSizeX;
-
-  const int first_y = blockIdx.y * static_cast<int>(maxY);
-  const int last_y = (first_y + static_cast<int>(maxY) < static_cast<int>(numY) ? first_y + static_cast<int>(maxY)
-                                                                                : static_cast<int>(numY)) -
-                     1;
-  const int num_y_input = last_y - first_y + kernelSizeY;
-
-  const int first_z = blockIdx.z * static_cast<int>(maxZ);
-  const int last_z = (first_z + static_cast<int>(maxZ) < static_cast<int>(numZ) ? first_z + static_cast<int>(maxZ)
-                                                                                : static_cast<int>(numZ)) -
-                     1;
-  const int num_z_input = last_z - first_z + kernelSizeZ;
-
-  for (int p = 0; p < static_cast<int>(numPlanes); ++p) {
-    const int plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
-    const int plane_kernel_offset = 0;
-
-    for (int k = threadIdx.z; k < num_z_input; k += blockDim.z) {
-      for (int j = threadIdx.y; j < num_y_input; j += blockDim.y) {
-        for (int i = threadIdx.x; i < num_x_input; i += blockDim.x) {
-          const int tensor_index = plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(
-                                                            i + first_x, j + first_y, k + first_z);
-          s[i + num_x_input * (j + num_y_input * (k + plane_kernel_offset))] = eval.coeff(tensor_index);
-        }
-      }
-    }
-
-    __syncthreads();
-
-    // Convolution
-    const int num_z_output = last_z - first_z + 1;
-    const int num_y_output = last_y - first_y + 1;
-    const int num_x_output = last_x - first_x + 1;
-    const int plane_output_offset = indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p);
-
-    for (int k = threadIdx.z; k < num_z_output; k += blockDim.z) {
-      for (int j = threadIdx.y; j < num_y_output; j += blockDim.y) {
-        for (int i = threadIdx.x; i < num_x_output; i += blockDim.x) {
-          float result = 0.0f;
-          for (int n = 0; n < kernelSizeZ; ++n) {
-            for (int m = 0; m < kernelSizeY; ++m) {
-              for (int l = 0; l < kernelSizeX; ++l) {
-                result += s[i + l + num_x_input * (j + m + num_y_input * (k + n + plane_kernel_offset))] *
-                          kernel[l + kernelSizeX * (m + kernelSizeY * n)];
-              }
-            }
-          }
-          const int tensor_index = plane_output_offset + indexMapper.mapGpuOutputKernelToTensorOutputOffset(
-                                                             i + first_x, j + first_y, k + first_z);
-          buffer[tensor_index] = result;
-        }
-      }
-    }
-    __syncthreads();
-  }
-};
-
-template <typename Indices, typename InputArgType, typename KernelArgType>
-struct TensorEvaluator<const TensorConvolutionOp<Indices, InputArgType, KernelArgType>, GpuDevice> {
-  typedef TensorConvolutionOp<Indices, InputArgType, KernelArgType> XprType;
-
-  static constexpr int NumDims =
-      internal::array_size<typename TensorEvaluator<InputArgType, GpuDevice>::Dimensions>::value;
-  static constexpr int NumKernelDims = internal::array_size<Indices>::value;
-  typedef typename XprType::Index Index;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename TensorEvaluator<KernelArgType, GpuDevice>::Dimensions KernelDimensions;
-
-  static constexpr int Layout = TensorEvaluator<InputArgType, GpuDevice>::Layout;
-  enum {
-    IsAligned =
-        TensorEvaluator<InputArgType, GpuDevice>::IsAligned & TensorEvaluator<KernelArgType, GpuDevice>::IsAligned,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  TensorEvaluator(const XprType& op, const GpuDevice& device)
-      : m_inputImpl(op.inputExpression(), device),
-        m_kernelImpl(op.kernelExpression(), device),
-        m_kernelArg(op.kernelExpression()),
-        m_indices(op.indices()),
-        m_buf(NULL),
-        m_kernel(NULL),
-        m_local_kernel(false),
-        m_device(device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<InputArgType, GpuDevice>::Layout) ==
-                         static_cast<int>(TensorEvaluator<KernelArgType, GpuDevice>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    const typename TensorEvaluator<InputArgType, GpuDevice>::Dimensions& input_dims = m_inputImpl.dimensions();
-    const typename TensorEvaluator<KernelArgType, GpuDevice>::Dimensions& kernel_dims = m_kernelImpl.dimensions();
-
-    m_dimensions = m_inputImpl.dimensions();
-    for (int i = 0; i < NumKernelDims; ++i) {
-      const Index index = op.indices()[i];
-      const Index input_dim = input_dims[index];
-      const Index kernel_dim = kernel_dims[i];
-      const Index result_dim = input_dim - kernel_dim + 1;
-      m_dimensions[index] = result_dim;
-    }
-  }
-
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, GpuDevice>::type PacketReturnType;
-  typedef typename InputArgType::Scalar Scalar;
-  static constexpr int PacketSize = internal::unpacket_traits<PacketReturnType>::size;
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* data) {
-    preloadKernel();
-    m_inputImpl.evalSubExprsIfNeeded(NULL);
-    if (data) {
-      executeEval(data);
-      return false;
-    } else {
-      m_buf = (Scalar*)m_device.allocate(dimensions().TotalSize() * sizeof(Scalar));
-      executeEval(m_buf);
-      return true;
-    }
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_inputImpl.cleanup();
-    if (m_buf) {
-      m_device.deallocate(m_buf);
-      m_buf = NULL;
-    }
-    if (m_local_kernel) {
-      m_device.deallocate((void*)m_kernel);
-      m_local_kernel = false;
-    }
-    m_kernel = NULL;
-  }
-
-  EIGEN_STRONG_INLINE void preloadKernel() {
-    // Don't make a local copy of the kernel unless we have to (i.e. it's an
-    // expression that needs to be evaluated)
-    const Scalar* in_place = m_kernelImpl.data();
-    if (in_place) {
-      m_kernel = in_place;
-      m_local_kernel = false;
-    } else {
-      size_t kernel_sz = m_kernelImpl.dimensions().TotalSize() * sizeof(Scalar);
-      Scalar* local = (Scalar*)m_device.allocate(kernel_sz);
-      typedef TensorEvalToOp<const KernelArgType> EvalTo;
-      EvalTo evalToTmp(local, m_kernelArg);
-      const bool PacketAccess = internal::IsVectorizable<GpuDevice, KernelArgType>::value;
-      internal::TensorExecutor<const EvalTo, GpuDevice, PacketAccess>::run(evalToTmp, m_device);
-
-      m_kernel = local;
-      m_local_kernel = true;
-    }
-  }
-
-  static unsigned int ceil(unsigned int num, unsigned int denom) {
-    const unsigned int rounded_toward_zero = num / denom;
-    if (num > rounded_toward_zero * denom) {
-      return rounded_toward_zero + 1;
-    }
-    return rounded_toward_zero;
-  }
-
-  void executeEval(Scalar* data) const {
-    typedef typename TensorEvaluator<InputArgType, GpuDevice>::Dimensions InputDims;
-
-    const int maxSharedMem = m_device.sharedMemPerBlock();
-    const int maxThreadsPerBlock = m_device.maxGpuThreadsPerBlock();
-    const int maxBlocksPerProcessor = m_device.maxGpuThreadsPerMultiProcessor() / maxThreadsPerBlock;
-    const int numMultiProcessors = m_device.getNumGpuMultiProcessors();
-    const int warpSize = 32;
-
-    switch (NumKernelDims) {
-      case 1: {
-        const int kernel_size = m_kernelImpl.dimensions().TotalSize();
-
-        const int numX = dimensions()[m_indices[0]];
-        const int numP = dimensions().TotalSize() / numX;
-        int maxX;
-        dim3 block_size;
-
-        const int single_stride_dim =
-            static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : m_inputImpl.dimensions().rank() - 1;
-        if (m_indices[0] == single_stride_dim) {
-          // Maximum the reuse
-          const int inner_dim = ((maxSharedMem / (sizeof(Scalar)) - kernel_size + 1 + 31) / 32) * 32;
-          maxX = numext::mini<int>(inner_dim, numX);
-          const int maxP = numext::mini<int>(maxSharedMem / ((kernel_size - 1 + maxX) * sizeof(Scalar)), numP);
-          block_size.x = numext::mini(maxThreadsPerBlock, maxX);
-          block_size.y = numext::mini<int>(maxThreadsPerBlock / block_size.x, maxP);
-        } else {
-          // Read as much as possible alongside the inner most dimension, that is the plane
-          const int inner_dim = maxSharedMem / ((warpSize + kernel_size) * sizeof(Scalar));
-          const int maxP = numext::mini<int>(inner_dim, numP);
-          maxX = numext::mini<int>(maxSharedMem / (inner_dim * sizeof(Scalar)) - kernel_size + 1, numX);
-
-          block_size.x = numext::mini(warpSize, maxX);
-          block_size.y = numext::mini<int>(maxThreadsPerBlock / block_size.x, maxP);
-        }
-
-        const int shared_mem = block_size.y * (maxX + kernel_size - 1) * sizeof(Scalar);
-        gpu_assert(shared_mem <= maxSharedMem);
-
-        const int num_x_blocks = ceil(numX, maxX);
-        const int blocksPerProcessor = numext::mini(maxBlocksPerProcessor, maxSharedMem / shared_mem);
-        const int num_y_blocks = ceil(numMultiProcessors * blocksPerProcessor, num_x_blocks);
-
-        dim3 num_blocks(num_x_blocks, numext::mini<int>(num_y_blocks, ceil(numP, block_size.y)));
-
-        const array<Index, 1> indices{m_indices[0]};
-        const array<Index, 1> kernel_dims{m_kernelImpl.dimensions()[0]};
-        internal::IndexMapper<Index, InputDims, 1, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
-        switch (kernel_size) {
-          case 4: {
-            LAUNCH_GPU_KERNEL((EigenConvolutionKernel1D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 4>),
-                              num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP,
-                              numX, maxX, 4, data);
-            break;
-          }
-          case 7: {
-            LAUNCH_GPU_KERNEL((EigenConvolutionKernel1D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 7>),
-                              num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP,
-                              numX, maxX, 7, data);
-            break;
-          }
-          default: {
-            LAUNCH_GPU_KERNEL(
-                (EigenConvolutionKernel1D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, Dynamic>),
-                num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
-                kernel_size, data);
-          }
-        }
-        break;
-      }
-
-      case 2: {
-        const int idxX = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 1;
-        const int idxY = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 0;
-        const int kernel_size_x = m_kernelImpl.dimensions()[idxX];
-        const int kernel_size_y = m_kernelImpl.dimensions()[idxY];
-
-        const int numX = dimensions()[m_indices[idxX]];
-        const int numY = dimensions()[m_indices[idxY]];
-        const int numP = dimensions().TotalSize() / (numX * numY);
-
-        const float scaling_factor =
-            sqrtf(static_cast<float>(maxSharedMem) / (sizeof(Scalar) * kernel_size_y * kernel_size_x));
-
-        // Snap maxX to warp size
-        int inner_dim = ((static_cast<int>(scaling_factor * kernel_size_x) - kernel_size_x + 1 + 32) / 32) * 32;
-        const int maxX = numext::mini<int>(inner_dim, numX);
-        const int maxY =
-            numext::mini<int>(maxSharedMem / (sizeof(Scalar) * (maxX + kernel_size_x - 1)) - kernel_size_y + 1, numY);
-        const int maxP = numext::mini<int>(
-            maxSharedMem / ((kernel_size_x - 1 + maxX) * (kernel_size_y - 1 + maxY) * sizeof(Scalar)), numP);
-
-        dim3 block_size;
-        block_size.x = numext::mini(1024, maxX);
-        block_size.y = numext::mini<int>(1024 / block_size.x, maxY);
-        block_size.z = numext::mini<int>(1024 / (block_size.x * block_size.y), maxP);
-
-        const int shared_mem = block_size.z * (maxX + kernel_size_x - 1) * (maxY + kernel_size_y - 1) * sizeof(Scalar);
-        gpu_assert(shared_mem <= maxSharedMem);
-
-        const int num_x_blocks = ceil(numX, maxX);
-        const int num_y_blocks = ceil(numY, maxY);
-        const int blocksPerProcessor = numext::mini(maxBlocksPerProcessor, maxSharedMem / shared_mem);
-        const int num_z_blocks = ceil(numMultiProcessors * blocksPerProcessor, num_x_blocks * num_y_blocks);
-
-        dim3 num_blocks(num_x_blocks, num_y_blocks, numext::mini<int>(num_z_blocks, ceil(numP, block_size.z)));
-
-        const array<Index, 2> indices{m_indices[idxX], m_indices[idxY]};
-        const array<Index, 2> kernel_dims{m_kernelImpl.dimensions()[idxX], m_kernelImpl.dimensions()[idxY]};
-        internal::IndexMapper<Index, InputDims, 2, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
-        switch (kernel_size_x) {
-          case 4: {
-            switch (kernel_size_y) {
-              case 7: {
-                LAUNCH_GPU_KERNEL(
-                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 4, 7>),
-                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
-                    numY, maxY, 4, 7, data);
-                break;
-              }
-              default: {
-                LAUNCH_GPU_KERNEL(
-                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 4, Dynamic>),
-                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
-                    numY, maxY, 4, kernel_size_y, data);
-                break;
-              }
-            }
-            break;
-          }
-          case 7: {
-            switch (kernel_size_y) {
-              case 4: {
-                LAUNCH_GPU_KERNEL(
-                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 7, 4>),
-                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
-                    numY, maxY, 7, 4, data);
-                break;
-              }
-              default: {
-                LAUNCH_GPU_KERNEL(
-                    (EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims, 7, Dynamic>),
-                    num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX, maxX,
-                    numY, maxY, 7, kernel_size_y, data);
-                break;
-              }
-            }
-            break;
-          }
-          default: {
-            LAUNCH_GPU_KERNEL((EigenConvolutionKernel2D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims,
-                                                        Dynamic, Dynamic>),
-                              num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP,
-                              numX, maxX, numY, maxY, kernel_size_x, kernel_size_y, data);
-            break;
-          }
-        }
-        break;
-      }
-
-      case 3: {
-        const int idxX = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 2;
-        const int idxY = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 1;
-        const int idxZ = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 2 : 0;
-
-        const int kernel_size_x = m_kernelImpl.dimensions()[idxX];
-        const int kernel_size_y = m_kernelImpl.dimensions()[idxY];
-        const int kernel_size_z = m_kernelImpl.dimensions()[idxZ];
-
-        const int numX = dimensions()[m_indices[idxX]];
-        const int numY = dimensions()[m_indices[idxY]];
-        const int numZ = dimensions()[m_indices[idxZ]];
-        const int numP = dimensions().TotalSize() / (numX * numY * numZ);
-
-        const int maxX = numext::mini<int>(
-            128, numext::mini<int>(maxSharedMem / (sizeof(Scalar) * kernel_size_y * kernel_size_z) - kernel_size_x + 1,
-                                   numX));
-        const int maxY = numext::mini<int>(
-            128, numext::mini<int>(
-                     maxSharedMem / (sizeof(Scalar) * (maxX + kernel_size_x - 1) * kernel_size_z) - kernel_size_y + 1,
-                     numY));
-        const int maxZ = numext::mini<int>(
-            128, numext::mini<int>(
-                     maxSharedMem / (sizeof(Scalar) * (maxX + kernel_size_x - 1) * (maxY + kernel_size_y - 1)) -
-                         kernel_size_z + 1,
-                     numZ));
-
-        dim3 block_size;
-        block_size.x = numext::mini(32, maxX);
-        block_size.y = numext::mini(32, maxY);
-        block_size.z = numext::mini<int>(1024 / (block_size.x * block_size.y), maxZ);
-        dim3 num_blocks(ceil(numX, maxX), ceil(numY, maxY), ceil(numZ, maxZ));
-
-        const int shared_mem =
-            (maxX + kernel_size_x - 1) * (maxY + kernel_size_y - 1) * (maxZ + kernel_size_z - 1) * sizeof(Scalar);
-        gpu_assert(shared_mem <= maxSharedMem);
-
-        const array<Index, 3> indices{m_indices[idxX], m_indices[idxY], m_indices[idxZ]};
-        const array<Index, 3> kernel_dims{m_kernelImpl.dimensions()[idxX], m_kernelImpl.dimensions()[idxY],
-                                          m_kernelImpl.dimensions()[idxZ]};
-        internal::IndexMapper<Index, InputDims, 3, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
-
-        LAUNCH_GPU_KERNEL((EigenConvolutionKernel3D<TensorEvaluator<InputArgType, GpuDevice>, Index, InputDims>),
-                          num_blocks, block_size, shared_mem, m_device, m_inputImpl, indexMapper, m_kernel, numP, numX,
-                          maxX, numY, maxY, numZ, maxZ, kernel_size_x, kernel_size_y, kernel_size_z, data);
-        break;
-      }
-
-      default: {
-        EIGEN_STATIC_ASSERT((NumKernelDims >= 1 && NumKernelDims <= 3),
-                            THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    eigen_assert(m_buf);
-    eigen_assert(index < m_dimensions.TotalSize());
-    return m_buf[index];
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(const Index index) const {
-    eigen_assert(m_buf);
-    eigen_assert(index < m_dimensions.TotalSize());
-    return internal::ploadt<PacketReturnType, LoadMode>(m_buf + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // TODO(rmlarsen): For now, this is just a copy of the CPU cost
-    // model.
-    const double kernel_size = m_kernelImpl.dimensions().TotalSize();
-    // We ignore the use of fused multiply-add.
-    const double convolve_compute_cost = TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>();
-    const double firstIndex_compute_cost =
-        NumDims *
-        (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
-    return TensorOpCost(0, 0, firstIndex_compute_cost, vectorized, PacketSize) +
-           kernel_size * (m_inputImpl.costPerCoeff(vectorized) + m_kernelImpl.costPerCoeff(vectorized) +
-                          TensorOpCost(0, 0, convolve_compute_cost, vectorized, PacketSize));
-  }
-
- private:
-  TensorEvaluator<InputArgType, GpuDevice> m_inputImpl;
-  TensorEvaluator<KernelArgType, GpuDevice> m_kernelImpl;
-  KernelArgType m_kernelArg;
-  Indices m_indices;
-  Dimensions m_dimensions;
-  Scalar* m_buf;
-  const Scalar* m_kernel;
-  bool m_local_kernel;
-
-  const GpuDevice& m_device;
-};
-#endif
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONVOLUTION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorConvolutionSycl.h b/unsupported/Eigen/src/Tensor/TensorConvolutionSycl.h
deleted file mode 100644
index 37cf966..0000000
--- a/unsupported/Eigen/src/Tensor/TensorConvolutionSycl.h
+++ /dev/null
@@ -1,538 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CONVOLUTION_SYCL_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CONVOLUTION_SYCL_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-enum class convolution_type { CONV1D, CONV2D, CONV3D };
-template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
-          typename Kernel_accessor, typename Buffer_accessor, convolution_type Conv_Dim>
-struct EigenConvolutionKernel;
-template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
-          typename Kernel_accessor, typename Buffer_accessor>
-struct EigenConvolutionKernel<Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor,
-                              Buffer_accessor, convolution_type::CONV1D> {
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      Local_accessor;
-  Local_accessor local_acc;
-  Evaluator device_evaluator;
-  Kernel_accessor kernel_filter;
-  Buffer_accessor buffer_acc;
-  internal::IndexMapper<Index, InputDims, 1, Evaluator::Layout> indexMapper;
-  const size_t kernelSize;
-  const cl::sycl::range<2> input_range;
-  EigenConvolutionKernel(Local_accessor local_acc_, Evaluator device_evaluator_, Kernel_accessor kernel_filter_,
-                         Buffer_accessor buffer_acc_,
-                         internal::IndexMapper<Index, InputDims, 1, Evaluator::Layout> indexMapper_,
-                         const size_t kernelSize_, const cl::sycl::range<2> input_range_)
-      : local_acc(local_acc_),
-        device_evaluator(device_evaluator_),
-        kernel_filter(kernel_filter_),
-        buffer_acc(buffer_acc_),
-        indexMapper(indexMapper_),
-        kernelSize(kernelSize_),
-        input_range(input_range_) {}
-
-  template <typename BooleanDim2>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool boundary_check(const BooleanDim2 boolean_check) const {
-    return (boolean_check[0] && boolean_check[1]);
-  }
-  void operator()(cl::sycl::nd_item<2> itemID) const {
-    auto buffer_ptr = buffer_acc;
-    auto kernel_ptr = kernel_filter;
-    // the required row to be calculated for each plane in shared memory
-    const size_t num_input = (itemID.get_local_range()[0] + kernelSize - 1);
-    const size_t plane_kernel_offset = itemID.get_local_id(1) * num_input;
-    const size_t input_offset = itemID.get_group(0) * itemID.get_local_range()[0];
-    const size_t plane_tensor_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(itemID.get_global_id(1));
-    /// fill the shared memory
-    for (size_t i = itemID.get_local_id(0); i < num_input; i += itemID.get_local_range()[0]) {
-      const size_t local_index = i + plane_kernel_offset;
-      const size_t tensor_index =
-          plane_tensor_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(i + input_offset);
-
-      local_acc[local_index] =
-          (((i + input_offset) < (input_range[0] + kernelSize - 1)) && itemID.get_global_id(1) < input_range[1])
-              ? device_evaluator.coeff(tensor_index)
-              : CoeffReturnType(0);
-    }
-
-    itemID.barrier(cl::sycl::access::fence_space::local_space);
-
-    // calculate the convolution // output start x
-    const size_t first_output_start = itemID.get_group(0) * (itemID.get_local_range()[0]);
-    if (boundary_check(itemID.get_global_id() < input_range)) {
-      CoeffReturnType result = static_cast<CoeffReturnType>(0);
-      const size_t index = plane_kernel_offset + itemID.get_local_id(0);
-      for (size_t k = 0; k < kernelSize; ++k) {
-        result += (local_acc[k + index] * kernel_ptr[k]);
-      }
-      const size_t tensor_index =
-          indexMapper.mapGpuOutputPlaneToTensorOutputOffset(itemID.get_global_id(1)) +
-          indexMapper.mapGpuOutputKernelToTensorOutputOffset(itemID.get_local_id(0) + first_output_start);
-      buffer_ptr[tensor_index] = result;
-    }
-  }
-};
-
-template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
-          typename Kernel_accessor, typename Buffer_accessor>
-struct EigenConvolutionKernel<Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor,
-                              Buffer_accessor, convolution_type::CONV2D> {
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      Local_accessor;
-  Local_accessor local_acc;
-  Evaluator device_evaluator;
-  Kernel_accessor kernel_filter;
-  Buffer_accessor buffer_acc;
-  internal::IndexMapper<Index, InputDims, 2, Evaluator::Layout> indexMapper;
-  const cl::sycl::range<2> kernel_size;
-  const cl::sycl::range<3> input_range;
-  EigenConvolutionKernel(Local_accessor local_acc_, Evaluator device_evaluator_, Kernel_accessor kernel_filter_,
-                         Buffer_accessor buffer_acc_,
-                         internal::IndexMapper<Index, InputDims, 2, Evaluator::Layout> indexMapper_,
-                         const cl::sycl::range<2> kernel_size_, const cl::sycl::range<3> input_range_)
-      : local_acc(local_acc_),
-        device_evaluator(device_evaluator_),
-        kernel_filter(kernel_filter_),
-        buffer_acc(buffer_acc_),
-        indexMapper(indexMapper_),
-        kernel_size(kernel_size_),
-        input_range(input_range_) {}
-  template <typename BooleanDim3>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool boundary_check(const BooleanDim3 boolean_check) const {
-    return (boolean_check[0] && boolean_check[1] && boolean_check[2]);
-  }
-
-  void operator()(cl::sycl::nd_item<3> itemID) const {
-    auto buffer_ptr = buffer_acc;
-    auto kernel_ptr = kernel_filter;
-    // the required row to be calculated for each plane in shared memory
-    const auto num_input = cl::sycl::range<2>{
-        (cl::sycl::range<2>(itemID.get_local_range()[0], itemID.get_local_range()[1]) + kernel_size - 1)};
-
-    const size_t plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(itemID.get_global_id(2));
-    const size_t plane_kernel_offset = itemID.get_local_id(2) * num_input[1];
-
-    const auto input_offset = cl::sycl::range<2>{itemID.get_group(0) * itemID.get_local_range()[0],
-                                                 itemID.get_group(1) * itemID.get_local_range()[1]};
-
-    // fill the local memory
-    bool in_range_dim2 = itemID.get_global_id(2) < input_range[2];
-    for (size_t j = itemID.get_local_id(1); j < num_input[1]; j += itemID.get_local_range()[1]) {
-      const size_t local_input_offset = num_input[0] * (j + plane_kernel_offset);
-      bool in_range_dim1 = ((j + input_offset[1]) < (input_range[1] + kernel_size[1] - 1));
-      for (size_t i = itemID.get_local_id(0); i < num_input[0]; i += itemID.get_local_range()[0]) {
-        const size_t local_index = i + local_input_offset;
-        const size_t tensor_index = plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(
-                                                             i + input_offset[0], j + input_offset[1]);
-        local_acc[local_index] =
-            (((i + input_offset[0]) < (input_range[0] + kernel_size[0] - 1)) && in_range_dim1 && in_range_dim2)
-                ? device_evaluator.coeff(tensor_index)
-                : CoeffReturnType(0);
-      }
-    }
-
-    itemID.barrier(cl::sycl::access::fence_space::local_space);
-
-    // output offset start for each thread
-    const auto output_offset = cl::sycl::range<2>{itemID.get_group(0) * itemID.get_local_range()[0],
-                                                  itemID.get_group(1) * itemID.get_local_range()[1]};
-
-    if (boundary_check(itemID.get_global_id() < input_range)) {
-      CoeffReturnType result = static_cast<CoeffReturnType>(0);
-
-      for (size_t j = 0; j < kernel_size[1]; j++) {
-        size_t kernel_offset = kernel_size[0] * j;
-        const size_t index =
-            (num_input[0] * (plane_kernel_offset + j + itemID.get_local_id(1))) + itemID.get_local_id(0);
-        for (size_t i = 0; i < kernel_size[0]; i++) {
-          result += (local_acc[i + index] * kernel_ptr[i + kernel_offset]);
-        }
-      }
-      const size_t tensor_index =
-          indexMapper.mapGpuOutputPlaneToTensorOutputOffset(itemID.get_global_id(2)) +
-          indexMapper.mapGpuOutputKernelToTensorOutputOffset(itemID.get_local_id(0) + output_offset[0],
-                                                             itemID.get_local_id(1) + output_offset[1]);
-
-      buffer_ptr[tensor_index] = result;
-    }
-  }
-};
-
-template <typename Evaluator, typename CoeffReturnType, typename KernelType, typename Index, typename InputDims,
-          typename Kernel_accessor, typename Buffer_accessor>
-struct EigenConvolutionKernel<Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor,
-                              Buffer_accessor, convolution_type::CONV3D> {
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      Local_accessor;
-  Local_accessor local_acc;
-  Evaluator device_evaluator;
-  Kernel_accessor kernel_filter;
-  Buffer_accessor buffer_acc;
-  internal::IndexMapper<Index, InputDims, 3, Evaluator::Layout> indexMapper;
-  const cl::sycl::range<3> kernel_size;
-  const cl::sycl::range<3> input_range;
-  const size_t numP;
-
-  EigenConvolutionKernel(Local_accessor local_acc_, Evaluator device_evaluator_, Kernel_accessor kernel_filter_,
-                         Buffer_accessor buffer_acc_,
-                         internal::IndexMapper<Index, InputDims, 3, Evaluator::Layout> indexMapper_,
-                         const cl::sycl::range<3> kernel_size_, const cl::sycl::range<3> input_range_,
-                         const size_t numP_)
-      : local_acc(local_acc_),
-        device_evaluator(device_evaluator_),
-        kernel_filter(kernel_filter_),
-        buffer_acc(buffer_acc_),
-        indexMapper(indexMapper_),
-        kernel_size(kernel_size_),
-        input_range(input_range_),
-        numP(numP_) {}
-  template <typename BooleanDim3>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool boundary_check(const BooleanDim3 boolean_check) const {
-    return (boolean_check[0] && boolean_check[1] && boolean_check[2]);
-  }
-  void operator()(cl::sycl::nd_item<3> itemID) const {
-    auto buffer_ptr = buffer_acc;
-    auto kernel_ptr = kernel_filter;
-    const auto num_input = cl::sycl::range<3>{itemID.get_local_range() + kernel_size - 1};
-
-    const auto input_offset = cl::sycl::range<3>{itemID.get_group().get_id() * itemID.get_local_range()};
-
-    const auto output_offset =
-        cl::sycl::range<3>{itemID.get_group().get_id() * itemID.get_local_range() + itemID.get_local_id()};
-
-    for (size_t p = 0; p < numP; p++) {
-      /// fill the shared memory
-      const size_t plane_input_offset = indexMapper.mapGpuInputPlaneToTensorInputOffset(p);
-      for (size_t k = itemID.get_local_id(2); k < num_input[2]; k += itemID.get_local_range()[2]) {
-        size_t local_index_dim2 = num_input[0] * num_input[1] * k;
-        bool cond_k_dim = (k + input_offset[2] < (input_range[2] + kernel_size[2] - 1));
-        for (size_t j = itemID.get_local_id(1); j < num_input[1]; j += itemID.get_local_range()[1]) {
-          bool cond_j_dim = cond_k_dim && (j + input_offset[1] < (input_range[1] + kernel_size[1] - 1));
-          size_t local_index_dim1 = (num_input[0] * j) + local_index_dim2;
-          for (size_t i = itemID.get_local_id(0); i < num_input[0]; i += itemID.get_local_range()[0]) {
-            bool conds = cond_j_dim && (i + input_offset[0] < (input_range[0] + kernel_size[0] - 1));
-            const size_t local_index = local_index_dim1 + i;
-            const size_t tensor_index =
-                plane_input_offset + indexMapper.mapGpuInputKernelToTensorInputOffset(
-                                         i + input_offset[0], j + input_offset[1], k + input_offset[2]);
-            local_acc[local_index] = conds ? device_evaluator.coeff(tensor_index) : CoeffReturnType(0);
-          }
-        }
-      }
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-
-      // calculate the convolution
-
-      if (boundary_check(itemID.get_global_id() < input_range)) {
-        CoeffReturnType result = static_cast<CoeffReturnType>(0);
-        for (size_t k = 0; k < kernel_size[2]; k++) {
-          for (size_t j = 0; j < kernel_size[1]; j++) {
-            for (size_t i = 0; i < kernel_size[0]; i++) {
-              const size_t kernel_index = i + kernel_size[0] * (j + kernel_size[1] * k);
-              const size_t local_index =
-                  ((i + itemID.get_local_id(0)) +
-                   num_input[0] * ((j + itemID.get_local_id(1)) + num_input[1] * (k + itemID.get_local_id(2))));
-
-              result += (local_acc[local_index] * kernel_ptr[kernel_index]);
-            }
-          }
-        }
-        const size_t tensor_index =
-            indexMapper.mapGpuOutputPlaneToTensorOutputOffset(p) +
-            indexMapper.mapGpuOutputKernelToTensorOutputOffset(output_offset[0], output_offset[1], output_offset[2]);
-        buffer_ptr[tensor_index] = result;
-      }
-
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-    }
-  }
-};
-
-template <typename Indices, typename InputArgType, typename KernelArgType>
-struct TensorEvaluator<const TensorConvolutionOp<Indices, InputArgType, KernelArgType>, Eigen::SyclDevice> {
-  typedef TensorConvolutionOp<Indices, InputArgType, KernelArgType> XprType;
-
-  static constexpr int NumDims =
-      internal::array_size<typename TensorEvaluator<InputArgType, Eigen::SyclDevice>::Dimensions>::value;
-  static constexpr int NumKernelDims = internal::array_size<Indices>::value;
-  typedef typename XprType::Index Index;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename TensorEvaluator<KernelArgType, Eigen::SyclDevice>::Dimensions KernelDimensions;
-  typedef const Eigen::SyclDevice Device;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Eigen::SyclDevice>::type PacketReturnType;
-  typedef typename InputArgType::Scalar Scalar;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Eigen::SyclDevice> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  typedef StorageMemory<const CoeffReturnType, Eigen::SyclDevice> KernelStorage;
-
-  static constexpr int Layout = TensorEvaluator<InputArgType, Eigen::SyclDevice>::Layout;
-  enum {
-    IsAligned = TensorEvaluator<InputArgType, Eigen::SyclDevice>::IsAligned &
-                TensorEvaluator<KernelArgType, Eigen::SyclDevice>::IsAligned,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  TensorEvaluator(const XprType &op, const Eigen::SyclDevice &device)
-      : m_inputImpl(op.inputExpression(), device),
-        m_kernelArg(op.kernelExpression()),
-        m_kernelImpl(op.kernelExpression(), device),
-        m_indices(op.indices()),
-        m_buf(NULL),
-        m_kernel(NULL),
-        m_local_kernel(false),
-        m_device(device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<InputArgType, Eigen::SyclDevice>::Layout) ==
-                         static_cast<int>(TensorEvaluator<KernelArgType, Eigen::SyclDevice>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    const typename TensorEvaluator<InputArgType, Eigen::SyclDevice>::Dimensions &input_dims = m_inputImpl.dimensions();
-    const typename TensorEvaluator<KernelArgType, Eigen::SyclDevice>::Dimensions &kernel_dims =
-        m_kernelImpl.dimensions();
-
-    m_dimensions = m_inputImpl.dimensions();
-    for (int i = 0; i < NumKernelDims; ++i) {
-      const Index index = op.indices()[i];
-      const Index input_dim = input_dims[index];
-      const Index kernel_dim = kernel_dims[i];
-      const Index result_dim = input_dim - kernel_dim + 1;
-      m_dimensions[index] = result_dim;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC const Dimensions &dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    preloadKernel();
-    m_inputImpl.evalSubExprsIfNeeded(NULL);
-    if (data) {
-      executeEval(data);
-      return false;
-    } else {
-      m_buf = (EvaluatorPointerType)m_device.get(
-          (Scalar *)m_device.allocate_temp(dimensions().TotalSize() * sizeof(Scalar)));
-      executeEval(m_buf);
-      return true;
-    }
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_inputImpl.cleanup();
-    if (m_buf) {
-      m_device.deallocate_temp(m_buf);
-      m_buf = NULL;
-    }
-    if (m_local_kernel) {
-      m_device.deallocate_temp(m_kernel);
-      m_local_kernel = false;
-    }
-    m_kernel = NULL;
-  }
-  /// used by sycl in order to build the sycl buffer
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Device &device() const { return m_device; }
-  /// used by sycl in order to build the sycl buffer
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return m_buf; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void preloadKernel() {
-    // Don't make a local copy of the kernel unless we have to (i.e. it's an
-    // expression that needs to be evaluated)
-    typename KernelStorage::Type in_place = m_kernelImpl.data();
-    if (in_place) {
-      m_kernel = in_place;
-      m_local_kernel = false;
-    } else {
-      ptrdiff_t kernel_sz = m_kernelImpl.dimensions().TotalSize() * sizeof(Scalar);
-      EvaluatorPointerType local = (EvaluatorPointerType)m_device.get((Scalar *)m_device.allocate_temp(kernel_sz));
-      typedef TensorEvalToOp<const KernelArgType> EvalTo;
-      EvalTo evalToTmp(m_device.get(local), m_kernelArg);
-      const bool PacketAccess = internal::IsVectorizable<Eigen::SyclDevice, KernelArgType>::value;
-      internal::TensorExecutor<const EvalTo, Eigen::SyclDevice, PacketAccess>::run(evalToTmp, m_device);
-      m_kernel = local;
-      m_local_kernel = true;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void executeEval(EvaluatorPointerType data) const {
-    typedef TensorEvaluator<InputArgType, Eigen::SyclDevice> InputEvaluator;
-    typedef typename InputEvaluator::Dimensions InputDims;
-    switch (NumKernelDims) {
-      case 1: {
-        const size_t numX = dimensions()[m_indices[0]];
-        const size_t numP = dimensions().TotalSize() / numX;
-        const auto input_dim = std::array<size_t, 2>{numX, numP};
-        auto global_range = cl::sycl::range<2>{1, 1};
-        auto local_range = cl::sycl::range<2>{1, 1};
-        const size_t kernel_size = m_kernelImpl.dimensions().TotalSize();
-
-        m_device.parallel_for_setup(input_dim, global_range, local_range);
-        const size_t local_memory_size = (local_range[0] + kernel_size - 1) * (local_range[1]);
-        gpu_assert(static_cast<unsigned long>(local_memory_size) <= m_device.sharedMemPerBlock());
-        const array<Index, 1> indices{{m_indices[0]}};
-        const array<Index, 1> kernel_dims{{m_kernelImpl.dimensions()[0]}};
-        internal::IndexMapper<Index, InputDims, 1, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
-
-        typedef EigenConvolutionKernel<InputEvaluator, CoeffReturnType, Scalar, Index, InputDims,
-                                       typename KernelStorage::Type, EvaluatorPointerType, convolution_type::CONV1D>
-            ConvKernel;
-
-        m_device
-            .template binary_kernel_launcher<CoeffReturnType, ConvKernel>(
-                m_inputImpl, m_kernel, data, cl::sycl::nd_range<2>(global_range, local_range), local_memory_size,
-                indexMapper, kernel_size, cl::sycl::range<2>(input_dim[0], input_dim[1]))
-            .wait();
-        break;
-      }
-
-      case 2: {
-        auto kernel_index = std::array<size_t, 2>{static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 1,
-                                                  static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 0};
-        auto kernel_size = cl::sycl::range<2>{(size_t)m_kernelImpl.dimensions()[kernel_index[0]],
-                                              (size_t)m_kernelImpl.dimensions()[kernel_index[1]]};
-        const size_t numX = dimensions()[m_indices[kernel_index[0]]];
-        const size_t numY = dimensions()[m_indices[kernel_index[1]]];
-        const size_t numP = dimensions().TotalSize() / (numX * numY);
-        auto input_dim = std::array<size_t, 3>{numX, numY, numP};
-
-        auto global_range = cl::sycl::range<3>{1, 1, 1};
-        auto local_range = cl::sycl::range<3>{1, 1, 1};
-
-        m_device.parallel_for_setup(input_dim, global_range, local_range);
-
-        const size_t local_memory_size =
-            (local_range[0] + kernel_size[0] - 1) * (local_range[1] + kernel_size[1] - 1) * local_range[2];
-        gpu_assert(static_cast<unsigned long>(local_memory_size) <= m_device.sharedMemPerBlock());
-        const array<Index, 2> indices{{m_indices[kernel_index[0]], m_indices[kernel_index[1]]}};
-        const array<Index, 2> kernel_dims{
-            {m_kernelImpl.dimensions()[kernel_index[0]], m_kernelImpl.dimensions()[kernel_index[1]]}};
-        internal::IndexMapper<Index, InputDims, 2, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
-        typedef EigenConvolutionKernel<InputEvaluator, CoeffReturnType, Scalar, Index, InputDims,
-                                       typename KernelStorage::Type, EvaluatorPointerType, convolution_type::CONV2D>
-            ConvKernel;
-        m_device
-            .template binary_kernel_launcher<CoeffReturnType, ConvKernel>(
-                m_inputImpl, m_kernel, data, cl::sycl::nd_range<3>(global_range, local_range), local_memory_size,
-                indexMapper, kernel_size, cl::sycl::range<3>{input_dim[0], input_dim[1], input_dim[2]})
-            .wait();
-        break;
-      }
-
-      case 3: {
-        auto kernel_index = std::array<size_t, 3>{static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : 2,
-                                                  static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 1 : 1,
-                                                  static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 2 : 0};
-
-        auto kernel_size = cl::sycl::range<3>{(size_t)m_kernelImpl.dimensions()[kernel_index[0]],
-                                              (size_t)m_kernelImpl.dimensions()[kernel_index[1]],
-                                              (size_t)m_kernelImpl.dimensions()[kernel_index[2]]};
-
-        const size_t numX = dimensions()[m_indices[kernel_index[0]]];
-        const size_t numY = dimensions()[m_indices[kernel_index[1]]];
-        const size_t numZ = dimensions()[m_indices[kernel_index[2]]];
-        auto input_dim = std::array<size_t, 3>{numX, numY, numZ};
-        const size_t numP = dimensions().TotalSize() / (numX * numY * numZ);
-
-        const array<Index, 3> indices{
-            {m_indices[kernel_index[0]], m_indices[kernel_index[1]], m_indices[kernel_index[2]]}};
-        const array<Index, 3> kernel_dims{{m_kernelImpl.dimensions()[kernel_index[0]],
-                                           m_kernelImpl.dimensions()[kernel_index[1]],
-                                           m_kernelImpl.dimensions()[kernel_index[2]]}};
-
-        internal::IndexMapper<Index, InputDims, 3, Layout> indexMapper(m_inputImpl.dimensions(), kernel_dims, indices);
-
-        auto global_range = cl::sycl::range<3>{1, 1, 1};
-        auto local_range = cl::sycl::range<3>{1, 1, 1};
-
-        m_device.parallel_for_setup(input_dim, global_range, local_range);
-        auto local_memory_range = (local_range + kernel_size - 1);
-        const size_t local_memory_size = local_memory_range[0] * local_memory_range[1] * local_memory_range[2];
-
-        gpu_assert(static_cast<unsigned long>(local_memory_size) <= m_device.sharedMemPerBlock());
-        typedef EigenConvolutionKernel<InputEvaluator, CoeffReturnType, Scalar, Index, InputDims,
-                                       typename KernelStorage::Type, EvaluatorPointerType, convolution_type::CONV3D>
-            ConvKernel;
-        m_device
-            .template binary_kernel_launcher<CoeffReturnType, ConvKernel>(
-                m_inputImpl, m_kernel, data, cl::sycl::nd_range<3>(global_range, local_range), local_memory_size,
-                indexMapper, kernel_size, cl::sycl::range<3>(input_dim[0], input_dim[1], input_dim[2]), numP)
-            .wait();
-        break;
-      }
-
-      default: {
-        EIGEN_STATIC_ASSERT((NumKernelDims >= 1 && NumKernelDims <= 3),
-                            THIS_METHOD_IS_ONLY_FOR_OBJECTS_OF_A_SPECIFIC_SIZE);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    eigen_assert(m_buf != NULL);
-    eigen_assert(index < m_dimensions.TotalSize());
-    return m_buf[index];
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(const Index index) const {
-    eigen_assert(m_buf != NULL);
-    eigen_assert(index < m_dimensions.TotalSize());
-    return internal::ploadt<PacketReturnType, LoadMode>(m_buf + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // TODO(rmlarsen): For now, this is just a copy of the CPU cost
-    // model.
-    const double kernel_size = m_kernelImpl.dimensions().TotalSize();
-    // We ignore the use of fused multiply-add.
-    const double convolve_compute_cost = TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>();
-    const double firstIndex_compute_cost =
-        NumDims *
-        (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
-    return TensorOpCost(0, 0, firstIndex_compute_cost, vectorized, PacketSize) +
-           kernel_size * (m_inputImpl.costPerCoeff(vectorized) + m_kernelImpl.costPerCoeff(vectorized) +
-                          TensorOpCost(0, 0, convolve_compute_cost, vectorized, PacketSize));
-  }
-
- private:
-  // No assignment (copies are needed by the kernels)
-  TensorEvaluator &operator=(const TensorEvaluator &);
-  TensorEvaluator<InputArgType, Eigen::SyclDevice> m_inputImpl;
-  KernelArgType m_kernelArg;
-  TensorEvaluator<KernelArgType, Eigen::SyclDevice> m_kernelImpl;
-  Indices m_indices;
-  Dimensions m_dimensions;
-  EvaluatorPointerType m_buf;
-  typename KernelStorage::Type m_kernel;
-  bool m_local_kernel;
-  const Eigen::SyclDevice EIGEN_DEVICE_REF m_device;
-};  // namespace Eigen
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CONVOLUTION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorCostModel.h b/unsupported/Eigen/src/Tensor/TensorCostModel.h
deleted file mode 100644
index d17d356..0000000
--- a/unsupported/Eigen/src/Tensor/TensorCostModel.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Rasmus Munk Larsen <rmlarsen@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_COST_MODEL_H
-#define EIGEN_CXX11_TENSOR_TENSOR_COST_MODEL_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// Class storing the cost of evaluating a tensor expression in terms of the
-// estimated number of operand bytes loads, bytes stored, and compute cycles.
-class TensorOpCost {
- public:
-  // TODO(rmlarsen): Fix the scalar op costs in Eigen proper. Even a simple
-  // model based on minimal reciprocal throughput numbers from Intel or
-  // Agner Fog's tables would be better than what is there now.
-  template <typename ArgType>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int MulCost() {
-    return internal::functor_traits<internal::scalar_product_op<ArgType, ArgType> >::Cost;
-  }
-  template <typename ArgType>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int AddCost() {
-    return internal::functor_traits<internal::scalar_sum_op<ArgType> >::Cost;
-  }
-  template <typename ArgType>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int DivCost() {
-    return internal::functor_traits<internal::scalar_quotient_op<ArgType, ArgType> >::Cost;
-  }
-  template <typename ArgType>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int ModCost() {
-    return internal::functor_traits<internal::scalar_mod_op<ArgType> >::Cost;
-  }
-  template <typename SrcType, typename TargetType>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int CastCost() {
-    return internal::functor_traits<internal::scalar_cast_op<SrcType, TargetType> >::Cost;
-  }
-
-  EIGEN_DEVICE_FUNC TensorOpCost() : bytes_loaded_(0), bytes_stored_(0), compute_cycles_(0) {}
-  EIGEN_DEVICE_FUNC TensorOpCost(double bytes_loaded, double bytes_stored, double compute_cycles)
-      : bytes_loaded_(bytes_loaded), bytes_stored_(bytes_stored), compute_cycles_(compute_cycles) {}
-
-  EIGEN_DEVICE_FUNC TensorOpCost(double bytes_loaded, double bytes_stored, double compute_cycles, bool vectorized,
-                                 double packet_size)
-      : bytes_loaded_(bytes_loaded),
-        bytes_stored_(bytes_stored),
-        compute_cycles_(vectorized ? compute_cycles / packet_size : compute_cycles) {
-    eigen_assert(bytes_loaded >= 0 && (numext::isfinite)(bytes_loaded));
-    eigen_assert(bytes_stored >= 0 && (numext::isfinite)(bytes_stored));
-    eigen_assert(compute_cycles >= 0 && (numext::isfinite)(compute_cycles));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bytes_loaded() const { return bytes_loaded_; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double bytes_stored() const { return bytes_stored_; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double compute_cycles() const { return compute_cycles_; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double total_cost(double load_cost, double store_cost,
-                                                          double compute_cost) const {
-    return load_cost * bytes_loaded_ + store_cost * bytes_stored_ + compute_cost * compute_cycles_;
-  }
-
-  // Drop memory access component. Intended for cases when memory accesses are
-  // sequential or are completely masked by computations.
-  EIGEN_DEVICE_FUNC void dropMemoryCost() {
-    bytes_loaded_ = 0;
-    bytes_stored_ = 0;
-  }
-
-  // TODO(rmlarsen): Define min in terms of total cost, not elementwise.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost cwiseMin(const TensorOpCost& rhs) const {
-    double bytes_loaded = numext::mini(bytes_loaded_, rhs.bytes_loaded());
-    double bytes_stored = numext::mini(bytes_stored_, rhs.bytes_stored());
-    double compute_cycles = numext::mini(compute_cycles_, rhs.compute_cycles());
-    return TensorOpCost(bytes_loaded, bytes_stored, compute_cycles);
-  }
-
-  // TODO(rmlarsen): Define max in terms of total cost, not elementwise.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost cwiseMax(const TensorOpCost& rhs) const {
-    double bytes_loaded = numext::maxi(bytes_loaded_, rhs.bytes_loaded());
-    double bytes_stored = numext::maxi(bytes_stored_, rhs.bytes_stored());
-    double compute_cycles = numext::maxi(compute_cycles_, rhs.compute_cycles());
-    return TensorOpCost(bytes_loaded, bytes_stored, compute_cycles);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost& operator+=(const TensorOpCost& rhs) {
-    bytes_loaded_ += rhs.bytes_loaded();
-    bytes_stored_ += rhs.bytes_stored();
-    compute_cycles_ += rhs.compute_cycles();
-    return *this;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost& operator*=(double rhs) {
-    bytes_loaded_ *= rhs;
-    bytes_stored_ *= rhs;
-    compute_cycles_ *= rhs;
-    return *this;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend TensorOpCost operator+(TensorOpCost lhs, const TensorOpCost& rhs) {
-    lhs += rhs;
-    return lhs;
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend TensorOpCost operator*(TensorOpCost lhs, double rhs) {
-    lhs *= rhs;
-    return lhs;
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend TensorOpCost operator*(double lhs, TensorOpCost rhs) {
-    rhs *= lhs;
-    return rhs;
-  }
-
-  friend std::ostream& operator<<(std::ostream& os, const TensorOpCost& tc) {
-    return os << "[bytes_loaded = " << tc.bytes_loaded() << ", bytes_stored = " << tc.bytes_stored()
-              << ", compute_cycles = " << tc.compute_cycles() << "]";
-  }
-
- private:
-  double bytes_loaded_;
-  double bytes_stored_;
-  double compute_cycles_;
-};
-
-// TODO(rmlarsen): Implement a policy that chooses an "optimal" number of threads
-// in [1:max_threads] instead of just switching multi-threading off for small
-// work units.
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief A cost model used to limit the number of threads used for evaluating
- * tensor expression.
- *
- */
-template <typename Device>
-class TensorCostModel {
- public:
-  // Scaling from Eigen compute cost to device cycles.
-  static const int kDeviceCyclesPerComputeCycle = 1;
-
-  // Costs in device cycles.
-  static const int kStartupCycles = 100000;
-  static const int kPerThreadCycles = 100000;
-  static const int kTaskSize = 40000;
-
-  // Returns the number of threads in [1:max_threads] to use for
-  // evaluating an expression with the given output size and cost per
-  // coefficient.
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int numThreads(double output_size, const TensorOpCost& cost_per_coeff,
-                                                              int max_threads) {
-    double cost = totalCost(output_size, cost_per_coeff);
-    double threads = (cost - kStartupCycles) / kPerThreadCycles + 0.9;
-    // Make sure we don't invoke undefined behavior when we convert to an int.
-    threads = numext::mini<double>(threads, GenericNumTraits<int>::highest());
-    return numext::mini(max_threads, numext::maxi<int>(1, static_cast<int>(threads)));
-  }
-
-  // taskSize assesses parallel task size.
-  // Value of 1.0 means ideal parallel task size. Values < 1.0 mean that task
-  // granularity needs to be increased to mitigate parallelization overheads.
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double taskSize(double output_size, const TensorOpCost& cost_per_coeff) {
-    return totalCost(output_size, cost_per_coeff) / kTaskSize;
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double totalCost(double output_size,
-                                                                const TensorOpCost& cost_per_coeff) {
-    // Cost of memory fetches from L2 cache. 64 is typical cache line size.
-    // 11 is L2 cache latency on Haswell.
-    // We don't know whether data is in L1, L2 or L3. But we are most interested
-    // in single-threaded computational time around 100us-10ms (smaller time
-    // is too small for parallelization, larger time is not interesting
-    // either because we are probably using all available threads already).
-    // And for the target time range, L2 seems to be what matters. Data set
-    // fitting into L1 is too small to take noticeable time. Data set fitting
-    // only into L3 presumably will take more than 10ms to load and process.
-    const double kLoadCycles = 1.0 / 64 * 11;
-    const double kStoreCycles = 1.0 / 64 * 11;
-    // Scaling from Eigen compute cost to device cycles.
-    return output_size * cost_per_coeff.total_cost(kLoadCycles, kStoreCycles, kDeviceCyclesPerComputeCycle);
-  }
-};
-
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_COST_MODEL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorCustomOp.h b/unsupported/Eigen/src/Tensor/TensorCustomOp.h
deleted file mode 100644
index 1cae60f..0000000
--- a/unsupported/Eigen/src/Tensor/TensorCustomOp.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_CUSTOM_OP_H
-#define EIGEN_CXX11_TENSOR_TENSOR_CUSTOM_OP_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename CustomUnaryFunc, typename XprType>
-struct traits<TensorCustomUnaryOp<CustomUnaryFunc, XprType> > {
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::StorageKind StorageKind;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = traits<XprType>::NumDimensions;
-  static constexpr int Layout = traits<XprType>::Layout;
-  typedef typename traits<XprType>::PointerType PointerType;
-};
-
-template <typename CustomUnaryFunc, typename XprType>
-struct eval<TensorCustomUnaryOp<CustomUnaryFunc, XprType>, Eigen::Dense> {
-  typedef const TensorCustomUnaryOp<CustomUnaryFunc, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename CustomUnaryFunc, typename XprType>
-struct nested<TensorCustomUnaryOp<CustomUnaryFunc, XprType> > {
-  typedef TensorCustomUnaryOp<CustomUnaryFunc, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor custom class.
- */
-template <typename CustomUnaryFunc, typename XprType>
-class TensorCustomUnaryOp : public TensorBase<TensorCustomUnaryOp<CustomUnaryFunc, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename internal::traits<TensorCustomUnaryOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename internal::nested<TensorCustomUnaryOp>::type Nested;
-  typedef typename internal::traits<TensorCustomUnaryOp>::StorageKind StorageKind;
-  typedef typename internal::traits<TensorCustomUnaryOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCustomUnaryOp(const XprType& expr, const CustomUnaryFunc& func)
-      : m_expr(expr), m_func(func) {}
-
-  EIGEN_DEVICE_FUNC const CustomUnaryFunc& func() const { return m_func; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_expr; }
-
- protected:
-  typename XprType::Nested m_expr;
-  const CustomUnaryFunc m_func;
-};
-
-// Eval as rvalue
-template <typename CustomUnaryFunc, typename XprType, typename Device>
-struct TensorEvaluator<const TensorCustomUnaryOp<CustomUnaryFunc, XprType>, Device> {
-  typedef TensorCustomUnaryOp<CustomUnaryFunc, XprType> ArgType;
-  typedef typename internal::traits<ArgType>::Index Index;
-  static constexpr int NumDims = internal::traits<ArgType>::NumDimensions;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef std::remove_const_t<typename ArgType::Scalar> Scalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<XprType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const ArgType& op, const Device& device)
-      : m_op(op), m_device(device), m_result(NULL) {
-    m_dimensions = op.func().dimensions(op.expression());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    if (data) {
-      evalTo(data);
-      return false;
-    } else {
-      m_result = static_cast<EvaluatorPointerType>(
-          m_device.get((CoeffReturnType*)m_device.allocate_temp(dimensions().TotalSize() * sizeof(Scalar))));
-      evalTo(m_result);
-      return true;
-    }
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    if (m_result) {
-      m_device.deallocate_temp(m_result);
-      m_result = NULL;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_result[index]; }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // TODO(rmlarsen): Extend CustomOp API to return its cost estimate.
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_result; }
-
- protected:
-  void evalTo(EvaluatorPointerType data) {
-    TensorMap<Tensor<CoeffReturnType, NumDims, Layout, Index> > result(m_device.get(data), m_dimensions);
-    m_op.func().eval(m_op.expression(), result, m_device);
-  }
-
-  Dimensions m_dimensions;
-  const ArgType m_op;
-  const Device EIGEN_DEVICE_REF m_device;
-  EvaluatorPointerType m_result;
-};
-
-/** \class TensorCustomBinaryOp
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor custom class.
- *
- *
- */
-namespace internal {
-template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
-struct traits<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType> > {
-  typedef typename internal::promote_storage_type<typename LhsXprType::Scalar, typename RhsXprType::Scalar>::ret Scalar;
-  typedef typename internal::promote_storage_type<typename LhsXprType::CoeffReturnType,
-                                                  typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
-  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
-                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
-  typedef
-      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
-  typedef typename LhsXprType::Nested LhsNested;
-  typedef typename RhsXprType::Nested RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
-  static constexpr int NumDimensions = traits<LhsXprType>::NumDimensions;
-  static constexpr int Layout = traits<LhsXprType>::Layout;
-  typedef std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
-                             typename traits<LhsXprType>::PointerType, typename traits<RhsXprType>::PointerType>
-      PointerType;
-};
-
-template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
-struct eval<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>, Eigen::Dense> {
-  typedef const TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>& type;
-};
-
-template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
-struct nested<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType> > {
-  typedef TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType> type;
-};
-
-}  // end namespace internal
-
-template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
-class TensorCustomBinaryOp
-    : public TensorBase<TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>, ReadOnlyAccessors> {
- public:
-  typedef typename internal::traits<TensorCustomBinaryOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename internal::traits<TensorCustomBinaryOp>::CoeffReturnType CoeffReturnType;
-  typedef typename internal::nested<TensorCustomBinaryOp>::type Nested;
-  typedef typename internal::traits<TensorCustomBinaryOp>::StorageKind StorageKind;
-  typedef typename internal::traits<TensorCustomBinaryOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCustomBinaryOp(const LhsXprType& lhs, const RhsXprType& rhs,
-                                                             const CustomBinaryFunc& func)
-
-      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_func(func) {}
-
-  EIGEN_DEVICE_FUNC const CustomBinaryFunc& func() const { return m_func; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
-    return m_lhs_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
-    return m_rhs_xpr;
-  }
-
- protected:
-  typename LhsXprType::Nested m_lhs_xpr;
-  typename RhsXprType::Nested m_rhs_xpr;
-  const CustomBinaryFunc m_func;
-};
-
-// Eval as rvalue
-template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType, typename Device>
-struct TensorEvaluator<const TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType>, Device> {
-  typedef TensorCustomBinaryOp<CustomBinaryFunc, LhsXprType, RhsXprType> XprType;
-  typedef typename internal::traits<XprType>::Index Index;
-  static constexpr int NumDims = internal::traits<XprType>::NumDimensions;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-
-  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<LhsXprType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_op(op), m_device(device), m_result(NULL) {
-    m_dimensions = op.func().dimensions(op.lhsExpression(), op.rhsExpression());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    if (data) {
-      evalTo(data);
-      return false;
-    } else {
-      m_result = static_cast<EvaluatorPointerType>(
-          m_device.get((CoeffReturnType*)m_device.allocate_temp(dimensions().TotalSize() * sizeof(CoeffReturnType))));
-      evalTo(m_result);
-      return true;
-    }
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    if (m_result != NULL) {
-      m_device.deallocate_temp(m_result);
-      m_result = NULL;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_result[index]; }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_result + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // TODO(rmlarsen): Extend CustomOp API to return its cost estimate.
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_result; }
-
- protected:
-  void evalTo(EvaluatorPointerType data) {
-    TensorMap<Tensor<CoeffReturnType, NumDims, Layout> > result(m_device.get(data), m_dimensions);
-    m_op.func().eval(m_op.lhsExpression(), m_op.rhsExpression(), result, m_device);
-  }
-
-  Dimensions m_dimensions;
-  const XprType m_op;
-  const Device EIGEN_DEVICE_REF m_device;
-  EvaluatorPointerType m_result;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_CUSTOM_OP_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDevice.h b/unsupported/Eigen/src/Tensor/TensorDevice.h
deleted file mode 100644
index 1ed2089..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDevice.h
+++ /dev/null
@@ -1,138 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_DEVICE_H
-#define EIGEN_CXX11_TENSOR_TENSOR_DEVICE_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Pseudo expression providing an operator = that will evaluate its argument
- * on the specified computing 'device' (GPU, thread pool, ...)
- *
- * Example:
- *    C.device(EIGEN_GPU) = A + B;
- *
- * TODO: operator *= and /=.
- */
-template <typename ExpressionType, typename DeviceType>
-class TensorDevice {
- public:
-  TensorDevice(const DeviceType& device, ExpressionType& expression) : m_device(device), m_expression(expression) {}
-
-  EIGEN_DEFAULT_COPY_CONSTRUCTOR(TensorDevice)
-
-  template <typename OtherDerived>
-  EIGEN_STRONG_INLINE TensorDevice& operator=(const OtherDerived& other) {
-    typedef TensorAssignOp<ExpressionType, const OtherDerived> Assign;
-    Assign assign(m_expression, other);
-    internal::TensorExecutor<const Assign, DeviceType>::run(assign, m_device);
-    return *this;
-  }
-
-  template <typename OtherDerived>
-  EIGEN_STRONG_INLINE TensorDevice& operator+=(const OtherDerived& other) {
-    typedef typename OtherDerived::Scalar Scalar;
-    typedef TensorCwiseBinaryOp<internal::scalar_sum_op<Scalar>, const ExpressionType, const OtherDerived> Sum;
-    Sum sum(m_expression, other);
-    typedef TensorAssignOp<ExpressionType, const Sum> Assign;
-    Assign assign(m_expression, sum);
-    internal::TensorExecutor<const Assign, DeviceType>::run(assign, m_device);
-    return *this;
-  }
-
-  template <typename OtherDerived>
-  EIGEN_STRONG_INLINE TensorDevice& operator-=(const OtherDerived& other) {
-    typedef typename OtherDerived::Scalar Scalar;
-    typedef TensorCwiseBinaryOp<internal::scalar_difference_op<Scalar>, const ExpressionType, const OtherDerived>
-        Difference;
-    Difference difference(m_expression, other);
-    typedef TensorAssignOp<ExpressionType, const Difference> Assign;
-    Assign assign(m_expression, difference);
-    internal::TensorExecutor<const Assign, DeviceType>::run(assign, m_device);
-    return *this;
-  }
-
- protected:
-  const DeviceType& m_device;
-  ExpressionType& m_expression;
-};
-
-/** \class TensorAsyncDevice
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Pseudo expression providing an operator = that will evaluate its
- * argument asynchronously on the specified device. Currently only
- * ThreadPoolDevice implements proper asynchronous execution, while the default
- * and GPU devices just run the expression synchronously and call m_done() on
- * completion..
- *
- * Example:
- *    auto done = []() { ... expression evaluation done ... };
- *    C.device(thread_pool_device, std::move(done)) = A + B;
- */
-
-template <typename ExpressionType, typename DeviceType, typename DoneCallback>
-class TensorAsyncDevice {
- public:
-  TensorAsyncDevice(const DeviceType& device, ExpressionType& expression, DoneCallback done)
-      : m_device(device), m_expression(expression), m_done(std::move(done)) {}
-
-  template <typename OtherDerived>
-  EIGEN_STRONG_INLINE TensorAsyncDevice& operator=(const OtherDerived& other) {
-    typedef TensorAssignOp<ExpressionType, const OtherDerived> Assign;
-    typedef internal::TensorExecutor<const Assign, DeviceType> Executor;
-
-    Assign assign(m_expression, other);
-    Executor::run(assign, m_device);
-    m_done();
-
-    return *this;
-  }
-
- protected:
-  const DeviceType& m_device;
-  ExpressionType& m_expression;
-  DoneCallback m_done;
-};
-
-#ifdef EIGEN_USE_THREADS
-template <typename ExpressionType, typename DoneCallback>
-class TensorAsyncDevice<ExpressionType, ThreadPoolDevice, DoneCallback> {
- public:
-  TensorAsyncDevice(const ThreadPoolDevice& device, ExpressionType& expression, DoneCallback done)
-      : m_device(device), m_expression(expression), m_done(std::move(done)) {}
-
-  template <typename OtherDerived>
-  EIGEN_STRONG_INLINE TensorAsyncDevice& operator=(const OtherDerived& other) {
-    typedef TensorAssignOp<ExpressionType, const OtherDerived> Assign;
-    typedef internal::TensorAsyncExecutor<const Assign, ThreadPoolDevice, DoneCallback> Executor;
-
-    // WARNING: After assignment 'm_done' callback will be in undefined state.
-    Assign assign(m_expression, other);
-    Executor::runAsync(assign, m_device, std::move(m_done));
-
-    return *this;
-  }
-
- protected:
-  const ThreadPoolDevice& m_device;
-  ExpressionType& m_expression;
-  DoneCallback m_done;
-};
-#endif
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DEVICE_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDeviceCuda.h b/unsupported/Eigen/src/Tensor/TensorDeviceCuda.h
deleted file mode 100644
index bad8034..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDeviceCuda.h
+++ /dev/null
@@ -1,7 +0,0 @@
-
-#if defined(__clang__) || defined(__GNUC__)
-#warning \
-    "Deprecated header file, please either include the main unsupported/Eigen/Tensor header or the respective TensorDeviceGpu.h file"
-#endif
-
-#include "TensorDeviceGpu.h"
diff --git a/unsupported/Eigen/src/Tensor/TensorDeviceDefault.h b/unsupported/Eigen/src/Tensor/TensorDeviceDefault.h
deleted file mode 100644
index 1f955f0..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDeviceDefault.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_DEVICE_DEFAULT_H
-#define EIGEN_CXX11_TENSOR_TENSOR_DEVICE_DEFAULT_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// Default device for the machine (typically a single cpu core)
-struct DefaultDevice {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* allocate(size_t num_bytes) const {
-    return internal::aligned_malloc(num_bytes);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void deallocate(void* buffer) const { internal::aligned_free(buffer); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void* allocate_temp(size_t num_bytes) const { return allocate(num_bytes); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void deallocate_temp(void* buffer) const { deallocate(buffer); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpy(void* dst, const void* src, size_t n) const {
-    ::memcpy(dst, src, n);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpyHostToDevice(void* dst, const void* src, size_t n) const {
-    memcpy(dst, src, n);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpyDeviceToHost(void* dst, const void* src, size_t n) const {
-    memcpy(dst, src, n);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memset(void* buffer, int c, size_t n) const { ::memset(buffer, c, n); }
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void fill(T* begin, T* end, const T& value) const {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-    // std::fill is not a device function, so resort to simple loop.
-    for (T* it = begin; it != end; ++it) {
-      *it = value;
-    }
-#else
-    std::fill(begin, end, value);
-#endif
-  }
-  template <typename Type>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type get(Type data) const {
-    return data;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t numThreads() const {
-#if !defined(EIGEN_GPU_COMPILE_PHASE)
-    // Running on the host CPU
-    return 1;
-#elif defined(EIGEN_HIP_DEVICE_COMPILE)
-    // Running on a HIP device
-    return 64;
-#else
-    // Running on a CUDA device
-    return 32;
-#endif
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const {
-#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
-    // Running on the host CPU
-    return l1CacheSize();
-#elif defined(EIGEN_HIP_DEVICE_COMPILE)
-    // Running on a HIP device
-    return 48 * 1024;  // FIXME: Update this number for HIP.
-#else
-    // Running on a CUDA device, return the amount of shared memory available.
-    return 48 * 1024;
-#endif
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
-#if !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
-    // Running single threaded on the host CPU
-    return l3CacheSize();
-#elif defined(EIGEN_HIP_DEVICE_COMPILE)
-    // Running on a HIP device
-    return firstLevelCacheSize();  // FIXME: Update this number for HIP.
-#else
-    // Running on a CUDA device
-    return firstLevelCacheSize();
-#endif
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void synchronize() const {
-    // Nothing.  Default device operations are synchronous.
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int majorDeviceVersion() const {
-#if !defined(EIGEN_GPU_COMPILE_PHASE)
-    // Running single threaded on the host CPU
-    // Should return an enum that encodes the ISA supported by the CPU
-    return 1;
-#elif defined(EIGEN_HIP_DEVICE_COMPILE)
-    // Running on a HIP device
-    // return 1 as major for HIP
-    return 1;
-#else
-    // Running on a CUDA device
-    return EIGEN_CUDA_ARCH / 100;
-#endif
-  }
-};
-
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DEVICE_DEFAULT_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDeviceGpu.h b/unsupported/Eigen/src/Tensor/TensorDeviceGpu.h
deleted file mode 100644
index 76e2fda..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDeviceGpu.h
+++ /dev/null
@@ -1,364 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#if defined(EIGEN_USE_GPU) && !defined(EIGEN_CXX11_TENSOR_TENSOR_DEVICE_GPU_H)
-#define EIGEN_CXX11_TENSOR_TENSOR_DEVICE_GPU_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include "../../../../Eigen/src/Core/util/GpuHipCudaDefines.inc"
-
-namespace Eigen {
-
-static const int kGpuScratchSize = 1024;
-
-// This defines an interface that GPUDevice can take to use
-// HIP / CUDA streams underneath.
-class StreamInterface {
- public:
-  virtual ~StreamInterface() {}
-
-  virtual const gpuStream_t& stream() const = 0;
-  virtual const gpuDeviceProp_t& deviceProperties() const = 0;
-
-  // Allocate memory on the actual device where the computation will run
-  virtual void* allocate(size_t num_bytes) const = 0;
-  virtual void deallocate(void* buffer) const = 0;
-
-  // Return a scratchpad buffer of size 1k
-  virtual void* scratchpad() const = 0;
-
-  // Return a semaphore. The semaphore is initially initialized to 0, and
-  // each kernel using it is responsible for resetting to 0 upon completion
-  // to maintain the invariant that the semaphore is always equal to 0 upon
-  // each kernel start.
-  virtual unsigned int* semaphore() const = 0;
-};
-
-class GpuDeviceProperties {
- public:
-  static const GpuDeviceProperties& instance() {
-    static const GpuDeviceProperties* kInstance = new GpuDeviceProperties();
-
-    return *kInstance;
-  }
-
-  EIGEN_STRONG_INLINE const gpuDeviceProp_t& get(int device) const { return device_properties_[device]; }
-
- private:
-  GpuDeviceProperties() = default;
-
-  static std::vector<gpuDeviceProp_t> GetDeviceProperties() {
-    int num_devices = 0;
-    gpuError_t status = gpuGetDeviceCount(&num_devices);
-    if (status != gpuSuccess) {
-      std::cerr << "Failed to get the number of GPU devices: " << gpuGetErrorString(status) << std::endl;
-      gpu_assert(status == gpuSuccess);
-    }
-    std::vector<gpuDeviceProp_t> device_properties(num_devices);
-    for (int i = 0; i < num_devices; ++i) {
-      status = gpuGetDeviceProperties(&device_properties[i], i);
-      if (status != gpuSuccess) {
-        std::cerr << "Failed to initialize GPU device #" << i << ": " << gpuGetErrorString(status) << std::endl;
-        gpu_assert(status == gpuSuccess);
-      }
-    }
-
-    return device_properties;
-  }
-
-  std::vector<gpuDeviceProp_t> device_properties_ = GetDeviceProperties();
-};
-
-EIGEN_ALWAYS_INLINE const GpuDeviceProperties& GetGpuDeviceProperties() { return GpuDeviceProperties::instance(); }
-
-EIGEN_ALWAYS_INLINE const gpuDeviceProp_t& GetGpuDeviceProperties(int device) {
-  return GetGpuDeviceProperties().get(device);
-}
-
-static const gpuStream_t default_stream = gpuStreamDefault;
-
-class GpuStreamDevice : public StreamInterface {
- public:
-  // Use the default stream on the current device
-  GpuStreamDevice() : stream_(&default_stream), scratch_(NULL), semaphore_(NULL) {
-    gpuError_t status = gpuGetDevice(&device_);
-    if (status != gpuSuccess) {
-      std::cerr << "Failed to get the GPU devices " << gpuGetErrorString(status) << std::endl;
-      gpu_assert(status == gpuSuccess);
-    }
-  }
-  // Use the default stream on the specified device
-  GpuStreamDevice(int device) : stream_(&default_stream), device_(device), scratch_(NULL), semaphore_(NULL) {}
-  // Use the specified stream. Note that it's the
-  // caller responsibility to ensure that the stream can run on
-  // the specified device. If no device is specified the code
-  // assumes that the stream is associated to the current gpu device.
-  GpuStreamDevice(const gpuStream_t* stream, int device = -1)
-      : stream_(stream), device_(device), scratch_(NULL), semaphore_(NULL) {
-    if (device < 0) {
-      gpuError_t status = gpuGetDevice(&device_);
-      if (status != gpuSuccess) {
-        std::cerr << "Failed to get the GPU devices " << gpuGetErrorString(status) << std::endl;
-        gpu_assert(status == gpuSuccess);
-      }
-    } else {
-      int num_devices;
-      gpuError_t err = gpuGetDeviceCount(&num_devices);
-      EIGEN_UNUSED_VARIABLE(err)
-      gpu_assert(err == gpuSuccess);
-      gpu_assert(device < num_devices);
-      device_ = device;
-    }
-  }
-
-  virtual ~GpuStreamDevice() {
-    if (scratch_) {
-      deallocate(scratch_);
-    }
-  }
-
-  const gpuStream_t& stream() const { return *stream_; }
-  const gpuDeviceProp_t& deviceProperties() const { return GetGpuDeviceProperties(device_); }
-  virtual void* allocate(size_t num_bytes) const {
-    gpuError_t err = gpuSetDevice(device_);
-    EIGEN_UNUSED_VARIABLE(err)
-    gpu_assert(err == gpuSuccess);
-    void* result;
-    err = gpuMalloc(&result, num_bytes);
-    gpu_assert(err == gpuSuccess);
-    gpu_assert(result != NULL);
-    return result;
-  }
-  virtual void deallocate(void* buffer) const {
-    gpuError_t err = gpuSetDevice(device_);
-    EIGEN_UNUSED_VARIABLE(err)
-    gpu_assert(err == gpuSuccess);
-    gpu_assert(buffer != NULL);
-    err = gpuFree(buffer);
-    gpu_assert(err == gpuSuccess);
-  }
-
-  virtual void* scratchpad() const {
-    if (scratch_ == NULL) {
-      scratch_ = allocate(kGpuScratchSize + sizeof(unsigned int));
-    }
-    return scratch_;
-  }
-
-  virtual unsigned int* semaphore() const {
-    if (semaphore_ == NULL) {
-      char* scratch = static_cast<char*>(scratchpad()) + kGpuScratchSize;
-      semaphore_ = reinterpret_cast<unsigned int*>(scratch);
-      gpuError_t err = gpuMemsetAsync(semaphore_, 0, sizeof(unsigned int), *stream_);
-      EIGEN_UNUSED_VARIABLE(err)
-      gpu_assert(err == gpuSuccess);
-    }
-    return semaphore_;
-  }
-
- private:
-  const gpuStream_t* stream_;
-  int device_;
-  mutable void* scratch_;
-  mutable unsigned int* semaphore_;
-};
-
-struct GpuDevice {
-  // The StreamInterface is not owned: the caller is
-  // responsible for its initialization and eventual destruction.
-  explicit GpuDevice(const StreamInterface* stream) : stream_(stream), max_blocks_(INT_MAX) { eigen_assert(stream); }
-  explicit GpuDevice(const StreamInterface* stream, int num_blocks) : stream_(stream), max_blocks_(num_blocks) {
-    eigen_assert(stream);
-  }
-  // TODO(bsteiner): This is an internal API, we should not expose it.
-  EIGEN_STRONG_INLINE const gpuStream_t& stream() const { return stream_->stream(); }
-
-  EIGEN_STRONG_INLINE void* allocate(size_t num_bytes) const { return stream_->allocate(num_bytes); }
-
-  EIGEN_STRONG_INLINE void deallocate(void* buffer) const { stream_->deallocate(buffer); }
-
-  EIGEN_STRONG_INLINE void* allocate_temp(size_t num_bytes) const { return stream_->allocate(num_bytes); }
-
-  EIGEN_STRONG_INLINE void deallocate_temp(void* buffer) const { stream_->deallocate(buffer); }
-
-  template <typename Type>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type get(Type data) const {
-    return data;
-  }
-
-  EIGEN_STRONG_INLINE void* scratchpad() const { return stream_->scratchpad(); }
-
-  EIGEN_STRONG_INLINE unsigned int* semaphore() const { return stream_->semaphore(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memcpy(void* dst, const void* src, size_t n) const {
-#ifndef EIGEN_GPU_COMPILE_PHASE
-    gpuError_t err = gpuMemcpyAsync(dst, src, n, gpuMemcpyDeviceToDevice, stream_->stream());
-    EIGEN_UNUSED_VARIABLE(err)
-    gpu_assert(err == gpuSuccess);
-#else
-    EIGEN_UNUSED_VARIABLE(dst);
-    EIGEN_UNUSED_VARIABLE(src);
-    EIGEN_UNUSED_VARIABLE(n);
-    eigen_assert(false && "The default device should be used instead to generate kernel code");
-#endif
-  }
-
-  EIGEN_STRONG_INLINE void memcpyHostToDevice(void* dst, const void* src, size_t n) const {
-    gpuError_t err = gpuMemcpyAsync(dst, src, n, gpuMemcpyHostToDevice, stream_->stream());
-    EIGEN_UNUSED_VARIABLE(err)
-    gpu_assert(err == gpuSuccess);
-  }
-
-  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void* dst, const void* src, size_t n) const {
-    gpuError_t err = gpuMemcpyAsync(dst, src, n, gpuMemcpyDeviceToHost, stream_->stream());
-    EIGEN_UNUSED_VARIABLE(err)
-    gpu_assert(err == gpuSuccess);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void memset(void* buffer, int c, size_t n) const {
-#ifndef EIGEN_GPU_COMPILE_PHASE
-    gpuError_t err = gpuMemsetAsync(buffer, c, n, stream_->stream());
-    EIGEN_UNUSED_VARIABLE(err)
-    gpu_assert(err == gpuSuccess);
-#else
-    EIGEN_UNUSED_VARIABLE(buffer)
-    EIGEN_UNUSED_VARIABLE(c)
-    EIGEN_UNUSED_VARIABLE(n)
-    eigen_assert(false && "The default device should be used instead to generate kernel code");
-#endif
-  }
-
-  template <typename T>
-  EIGEN_STRONG_INLINE void fill(T* begin, T* end, const T& value) const {
-#ifndef EIGEN_GPU_COMPILE_PHASE
-    const size_t count = end - begin;
-    // Split value into bytes and run memset with stride.
-    const int value_size = sizeof(value);
-    char* buffer = (char*)begin;
-    char* value_bytes = (char*)(&value);
-    gpuError_t err;
-    EIGEN_UNUSED_VARIABLE(err)
-
-    // If all value bytes are equal, then a single memset can be much faster.
-    bool use_single_memset = true;
-    for (int i = 1; i < value_size; ++i) {
-      if (value_bytes[i] != value_bytes[0]) {
-        use_single_memset = false;
-      }
-    }
-
-    if (use_single_memset) {
-      err = gpuMemsetAsync(buffer, value_bytes[0], count * sizeof(T), stream_->stream());
-      gpu_assert(err == gpuSuccess);
-    } else {
-      for (int b = 0; b < value_size; ++b) {
-        err = gpuMemset2DAsync(buffer + b, value_size, value_bytes[b], 1, count, stream_->stream());
-        gpu_assert(err == gpuSuccess);
-      }
-    }
-#else
-    EIGEN_UNUSED_VARIABLE(begin)
-    EIGEN_UNUSED_VARIABLE(end)
-    EIGEN_UNUSED_VARIABLE(value)
-    eigen_assert(false && "The default device should be used instead to generate kernel code");
-#endif
-  }
-
-  EIGEN_STRONG_INLINE size_t numThreads() const {
-    // FIXME: Return a more accurate thread count.
-    return 32;
-  }
-
-  EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const {
-    // FIXME: Return a more accurate cache size.
-    return 48 * 1024;
-  }
-
-  EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
-    // We won't try to take advantage of the l2 cache for the time being, and
-    // there is no l3 cache on hip/cuda devices.
-    return firstLevelCacheSize();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void synchronize() const {
-#ifndef EIGEN_GPU_COMPILE_PHASE
-    gpuError_t err = gpuStreamSynchronize(stream_->stream());
-    if (err != gpuSuccess) {
-      std::cerr << "Error detected in GPU stream: " << gpuGetErrorString(err) << std::endl;
-      gpu_assert(err == gpuSuccess);
-    }
-#else
-    gpu_assert(false && "The default device should be used instead to generate kernel code");
-#endif
-  }
-
-  EIGEN_STRONG_INLINE int getNumGpuMultiProcessors() const { return stream_->deviceProperties().multiProcessorCount; }
-  EIGEN_STRONG_INLINE int maxGpuThreadsPerBlock() const { return stream_->deviceProperties().maxThreadsPerBlock; }
-  EIGEN_STRONG_INLINE int maxGpuThreadsPerMultiProcessor() const {
-    return stream_->deviceProperties().maxThreadsPerMultiProcessor;
-  }
-  EIGEN_STRONG_INLINE int sharedMemPerBlock() const {
-    return static_cast<int>(stream_->deviceProperties().sharedMemPerBlock);
-  }
-  EIGEN_STRONG_INLINE int majorDeviceVersion() const { return stream_->deviceProperties().major; }
-  EIGEN_STRONG_INLINE int minorDeviceVersion() const { return stream_->deviceProperties().minor; }
-
-  EIGEN_STRONG_INLINE int maxBlocks() const { return max_blocks_; }
-
-  // This function checks if the GPU runtime recorded an error for the
-  // underlying stream device.
-  inline bool ok() const {
-#ifdef EIGEN_GPUCC
-    gpuError_t error = gpuStreamQuery(stream_->stream());
-    return (error == gpuSuccess) || (error == gpuErrorNotReady);
-#else
-    return false;
-#endif
-  }
-
- private:
-  const StreamInterface* stream_;
-  int max_blocks_;
-};
-
-#if defined(EIGEN_HIPCC)
-
-#define LAUNCH_GPU_KERNEL(kernel, gridsize, blocksize, sharedmem, device, ...)                              \
-  hipLaunchKernelGGL(kernel, dim3(gridsize), dim3(blocksize), (sharedmem), (device).stream(), __VA_ARGS__); \
-  gpu_assert(hipGetLastError() == hipSuccess);
-
-#else
-
-#define LAUNCH_GPU_KERNEL(kernel, gridsize, blocksize, sharedmem, device, ...)        \
-  (kernel)<<<(gridsize), (blocksize), (sharedmem), (device).stream()>>>(__VA_ARGS__); \
-  gpu_assert(cudaGetLastError() == cudaSuccess);
-
-#endif
-
-// FIXME: Should be device and kernel specific.
-#ifdef EIGEN_GPUCC
-static EIGEN_DEVICE_FUNC inline void setGpuSharedMemConfig(gpuSharedMemConfig config) {
-#ifndef EIGEN_GPU_COMPILE_PHASE
-  gpuError_t status = gpuDeviceSetSharedMemConfig(config);
-  EIGEN_UNUSED_VARIABLE(status)
-  gpu_assert(status == gpuSuccess);
-#else
-  EIGEN_UNUSED_VARIABLE(config)
-#endif
-}
-#endif
-
-}  // end namespace Eigen
-
-// undefine all the gpu* macros we defined at the beginning of the file
-#include "../../../../Eigen/src/Core/util/GpuHipCudaUndefines.inc"
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DEVICE_GPU_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDeviceSycl.h b/unsupported/Eigen/src/Tensor/TensorDeviceSycl.h
deleted file mode 100644
index b291fed..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDeviceSycl.h
+++ /dev/null
@@ -1,567 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#if defined(EIGEN_USE_SYCL) && !defined(EIGEN_CXX11_TENSOR_TENSOR_DEVICE_SYCL_H)
-#define EIGEN_CXX11_TENSOR_TENSOR_DEVICE_SYCL_H
-#include <unordered_set>
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace TensorSycl {
-namespace internal {
-
-/// Cache all the device information needed
-struct SyclDeviceInfo {
-  SyclDeviceInfo(cl::sycl::queue queue)
-      : local_mem_type(queue.get_device().template get_info<cl::sycl::info::device::local_mem_type>()),
-        max_work_item_sizes(queue.get_device().template get_info<cl::sycl::info::device::max_work_item_sizes<3>>()),
-        max_mem_alloc_size(queue.get_device().template get_info<cl::sycl::info::device::max_mem_alloc_size>()),
-        max_compute_units(queue.get_device().template get_info<cl::sycl::info::device::max_compute_units>()),
-        max_work_group_size(queue.get_device().template get_info<cl::sycl::info::device::max_work_group_size>()),
-        local_mem_size(queue.get_device().template get_info<cl::sycl::info::device::local_mem_size>()),
-        platform_name(queue.get_device().get_platform().template get_info<cl::sycl::info::platform::name>()),
-        device_name(queue.get_device().template get_info<cl::sycl::info::device::name>()),
-        device_vendor(queue.get_device().template get_info<cl::sycl::info::device::vendor>()) {}
-
-  cl::sycl::info::local_mem_type local_mem_type;
-  cl::sycl::id<3> max_work_item_sizes;
-  unsigned long max_mem_alloc_size;
-  unsigned long max_compute_units;
-  unsigned long max_work_group_size;
-  size_t local_mem_size;
-  std::string platform_name;
-  std::string device_name;
-  std::string device_vendor;
-};
-
-}  // end namespace internal
-}  // end namespace TensorSycl
-
-// All devices (even AMD CPU with intel OpenCL runtime) that support OpenCL and
-// can consume SPIR or SPIRV can use the Eigen SYCL backend and consequently
-// TensorFlow via the Eigen SYCL Backend.
-EIGEN_STRONG_INLINE auto get_sycl_supported_devices() -> decltype(cl::sycl::device::get_devices()) {
-#ifdef EIGEN_SYCL_USE_DEFAULT_SELECTOR
-  return {cl::sycl::device(cl::sycl::default_selector())};
-#else
-  std::vector<cl::sycl::device> supported_devices;
-  auto platform_list = cl::sycl::platform::get_platforms();
-  for (const auto &platform : platform_list) {
-    auto device_list = platform.get_devices();
-    auto platform_name = platform.template get_info<cl::sycl::info::platform::name>();
-    std::transform(platform_name.begin(), platform_name.end(), platform_name.begin(), ::tolower);
-    for (const auto &device : device_list) {
-      auto vendor = device.template get_info<cl::sycl::info::device::vendor>();
-      std::transform(vendor.begin(), vendor.end(), vendor.begin(), ::tolower);
-      bool unsupported_condition = (device.is_cpu() && platform_name.find("amd") != std::string::npos &&
-                                    vendor.find("apu") == std::string::npos) ||
-                                   (platform_name.find("experimental") != std::string::npos) || device.is_host();
-      if (!unsupported_condition) {
-        supported_devices.push_back(device);
-      }
-    }
-  }
-  return supported_devices;
-#endif
-}
-
-class QueueInterface {
- public:
-  /// Creating device by using cl::sycl::selector or cl::sycl::device.
-  template <typename DeviceOrSelector>
-  explicit QueueInterface(const DeviceOrSelector &dev_or_sel, cl::sycl::async_handler handler,
-                          unsigned num_threads = std::thread::hardware_concurrency())
-      : m_queue{dev_or_sel, handler, {sycl::property::queue::in_order()}},
-        m_thread_pool(num_threads),
-        m_device_info(m_queue) {}
-
-  template <typename DeviceOrSelector>
-  explicit QueueInterface(const DeviceOrSelector &dev_or_sel,
-                          unsigned num_threads = std::thread::hardware_concurrency())
-      : QueueInterface(
-            dev_or_sel, [this](cl::sycl::exception_list l) { this->exception_caught_ = this->sycl_async_handler(l); },
-            num_threads) {}
-
-  explicit QueueInterface(const cl::sycl::queue &q, unsigned num_threads = std::thread::hardware_concurrency())
-      : m_queue(q), m_thread_pool(num_threads), m_device_info(m_queue) {}
-
-  EIGEN_STRONG_INLINE void *allocate(size_t num_bytes) const {
-#if EIGEN_MAX_ALIGN_BYTES > 0
-    return (void *)cl::sycl::aligned_alloc_device(EIGEN_MAX_ALIGN_BYTES, num_bytes, m_queue);
-#else
-    return (void *)cl::sycl::malloc_device(num_bytes, m_queue);
-#endif
-  }
-
-  EIGEN_STRONG_INLINE void *allocate_temp(size_t num_bytes) const {
-    return (void *)cl::sycl::malloc_device<uint8_t>(num_bytes, m_queue);
-  }
-
-  template <typename data_t>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE data_t *get(data_t *data) const {
-    return data;
-  }
-
-  EIGEN_STRONG_INLINE void deallocate_temp(void *p) const { deallocate(p); }
-
-  EIGEN_STRONG_INLINE void deallocate_temp(const void *p) const { deallocate_temp(const_cast<void *>(p)); }
-
-  EIGEN_STRONG_INLINE void deallocate(void *p) const { cl::sycl::free(p, m_queue); }
-
-  /// The memcpyHostToDevice is used to copy the data from host to device
-  /// The destination pointer could be deleted before the copy happened which is
-  /// why a callback function is needed. By default if none is provided, the
-  /// function is blocking.
-  EIGEN_STRONG_INLINE void memcpyHostToDevice(void *dst, const void *src, size_t n,
-                                              std::function<void()> callback) const {
-    auto e = m_queue.memcpy(dst, src, n);
-    synchronize_and_callback(e, callback);
-  }
-
-  /// The memcpyDeviceToHost is used to copy the data from device to host.
-  /// The source pointer could be deleted before the copy happened which is
-  /// why a callback function is needed. By default if none is provided, the
-  /// function is blocking.
-  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void *dst, const void *src, size_t n,
-                                              std::function<void()> callback) const {
-    if (n == 0) {
-      if (callback) callback();
-      return;
-    }
-    auto e = m_queue.memcpy(dst, src, n);
-    synchronize_and_callback(e, callback);
-  }
-
-  /// The memcpy function.
-  /// No callback is required here as both arguments are on the device
-  /// and SYCL can handle the dependency.
-  EIGEN_STRONG_INLINE void memcpy(void *dst, const void *src, size_t n) const {
-    if (n == 0) {
-      return;
-    }
-    m_queue.memcpy(dst, src, n).wait();
-  }
-
-  /// the memset function.
-  /// No callback is required here as both arguments are on the device
-  /// and SYCL can handle the dependency.
-  EIGEN_STRONG_INLINE void memset(void *data, int c, size_t n) const {
-    if (n == 0) {
-      return;
-    }
-    m_queue.memset(data, c, n).wait();
-  }
-
-  template <typename T>
-  EIGEN_STRONG_INLINE void fill(T *begin, T *end, const T &value) const {
-    if (begin == end) {
-      return;
-    }
-    const size_t count = end - begin;
-    m_queue.fill(begin, value, count).wait();
-  }
-
-  template <typename OutScalar, typename sycl_kernel, typename Lhs, typename Rhs, typename OutPtr, typename Range,
-            typename Index, typename... T>
-  EIGEN_ALWAYS_INLINE cl::sycl::event binary_kernel_launcher(const Lhs &lhs, const Rhs &rhs, OutPtr outptr,
-                                                             Range thread_range, Index scratchSize, T... var) const {
-    auto kernel_functor = [=](cl::sycl::handler &cgh) {
-      typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-          LocalAccessor;
-
-      LocalAccessor scratch(cl::sycl::range<1>(scratchSize), cgh);
-      cgh.parallel_for(thread_range, sycl_kernel(scratch, lhs, rhs, outptr, var...));
-    };
-
-    return m_queue.submit(kernel_functor);
-  }
-
-  template <typename OutScalar, typename sycl_kernel, typename InPtr, typename OutPtr, typename Range, typename Index,
-            typename... T>
-  EIGEN_ALWAYS_INLINE cl::sycl::event unary_kernel_launcher(const InPtr &inptr, OutPtr &outptr, Range thread_range,
-                                                            Index scratchSize, T... var) const {
-    auto kernel_functor = [=](cl::sycl::handler &cgh) {
-      typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-          LocalAccessor;
-
-      LocalAccessor scratch(cl::sycl::range<1>(scratchSize), cgh);
-      cgh.parallel_for(thread_range, sycl_kernel(scratch, inptr, outptr, var...));
-    };
-    return m_queue.submit(kernel_functor);
-  }
-
-  template <typename OutScalar, typename sycl_kernel, typename InPtr, typename Range, typename Index, typename... T>
-  EIGEN_ALWAYS_INLINE cl::sycl::event nullary_kernel_launcher(const InPtr &inptr, Range thread_range, Index scratchSize,
-                                                              T... var) const {
-    auto kernel_functor = [=](cl::sycl::handler &cgh) {
-      typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-          LocalAccessor;
-
-      LocalAccessor scratch(cl::sycl::range<1>(scratchSize), cgh);
-      cgh.parallel_for(thread_range, sycl_kernel(scratch, inptr, var...));
-    };
-
-    return m_queue.submit(kernel_functor);
-  }
-
-  EIGEN_STRONG_INLINE void synchronize() const {
-#ifdef EIGEN_EXCEPTIONS
-    m_queue.wait_and_throw();
-#else
-    m_queue.wait();
-#endif
-  }
-
-  template <typename Index>
-  EIGEN_STRONG_INLINE void parallel_for_setup(Index n, Index &tileSize, Index &rng, Index &GRange) const {
-    tileSize = static_cast<Index>(getNearestPowerOfTwoWorkGroupSize());
-    tileSize = std::min(static_cast<Index>(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1),
-                        static_cast<Index>(tileSize));
-    rng = n;
-    if (rng == 0) rng = static_cast<Index>(1);
-    GRange = rng;
-    if (tileSize > GRange)
-      tileSize = GRange;
-    else if (GRange > tileSize) {
-      Index xMode = static_cast<Index>(GRange % tileSize);
-      if (xMode != 0) GRange += static_cast<Index>(tileSize - xMode);
-    }
-  }
-
-  /// This is used to prepare the number of threads and also the number of
-  /// threads per block for sycl kernels
-  template <typename Index>
-  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 2> &input_dim, cl::sycl::range<2> &global_range,
-                                              cl::sycl::range<2> &local_range) const {
-    std::array<Index, 2> input_range = input_dim;
-    Index max_workgroup_Size = static_cast<Index>(getNearestPowerOfTwoWorkGroupSize());
-    max_workgroup_Size = std::min(static_cast<Index>(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1),
-                                  static_cast<Index>(max_workgroup_Size));
-    Index pow_of_2 = static_cast<Index>(std::log2(max_workgroup_Size));
-    local_range[1] = static_cast<Index>(std::pow(2, static_cast<Index>(pow_of_2 / 2)));
-    input_range[1] = input_dim[1];
-    if (input_range[1] == 0) input_range[1] = static_cast<Index>(1);
-    global_range[1] = input_range[1];
-    if (local_range[1] > global_range[1])
-      local_range[1] = global_range[1];
-    else if (global_range[1] > local_range[1]) {
-      Index xMode = static_cast<Index>(global_range[1] % local_range[1]);
-      if (xMode != 0) global_range[1] += static_cast<Index>(local_range[1] - xMode);
-    }
-    local_range[0] = static_cast<Index>(max_workgroup_Size / local_range[1]);
-    input_range[0] = input_dim[0];
-    if (input_range[0] == 0) input_range[0] = static_cast<Index>(1);
-    global_range[0] = input_range[0];
-    if (local_range[0] > global_range[0])
-      local_range[0] = global_range[0];
-    else if (global_range[0] > local_range[0]) {
-      Index xMode = static_cast<Index>(global_range[0] % local_range[0]);
-      if (xMode != 0) global_range[0] += static_cast<Index>(local_range[0] - xMode);
-    }
-  }
-
-  /// This is used to prepare the number of threads and also the number of
-  /// threads per block for sycl kernels
-  template <typename Index>
-  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 3> &input_dim, cl::sycl::range<3> &global_range,
-                                              cl::sycl::range<3> &local_range) const {
-    std::array<Index, 3> input_range = input_dim;
-    Index max_workgroup_Size = static_cast<Index>(getNearestPowerOfTwoWorkGroupSize());
-    max_workgroup_Size = std::min(static_cast<Index>(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1),
-                                  static_cast<Index>(max_workgroup_Size));
-    Index pow_of_2 = static_cast<Index>(std::log2(max_workgroup_Size));
-    local_range[2] = static_cast<Index>(std::pow(2, static_cast<Index>(pow_of_2 / 3)));
-    input_range[2] = input_dim[2];
-    if (input_range[2] == 0) input_range[1] = static_cast<Index>(1);
-    global_range[2] = input_range[2];
-    if (local_range[2] > global_range[2])
-      local_range[2] = global_range[2];
-    else if (global_range[2] > local_range[2]) {
-      Index xMode = static_cast<Index>(global_range[2] % local_range[2]);
-      if (xMode != 0) global_range[2] += static_cast<Index>(local_range[2] - xMode);
-    }
-    pow_of_2 = static_cast<Index>(std::log2(static_cast<Index>(max_workgroup_Size / local_range[2])));
-    local_range[1] = static_cast<Index>(std::pow(2, static_cast<Index>(pow_of_2 / 2)));
-    input_range[1] = input_dim[1];
-    if (input_range[1] == 0) input_range[1] = static_cast<Index>(1);
-    global_range[1] = input_range[1];
-    if (local_range[1] > global_range[1])
-      local_range[1] = global_range[1];
-    else if (global_range[1] > local_range[1]) {
-      Index xMode = static_cast<Index>(global_range[1] % local_range[1]);
-      if (xMode != 0) global_range[1] += static_cast<Index>(local_range[1] - xMode);
-    }
-    local_range[0] = static_cast<Index>(max_workgroup_Size / (local_range[1] * local_range[2]));
-    input_range[0] = input_dim[0];
-    if (input_range[0] == 0) input_range[0] = static_cast<Index>(1);
-    global_range[0] = input_range[0];
-    if (local_range[0] > global_range[0])
-      local_range[0] = global_range[0];
-    else if (global_range[0] > local_range[0]) {
-      Index xMode = static_cast<Index>(global_range[0] % local_range[0]);
-      if (xMode != 0) global_range[0] += static_cast<Index>(local_range[0] - xMode);
-    }
-  }
-
-  EIGEN_STRONG_INLINE bool has_local_memory() const {
-#if !defined(EIGEN_SYCL_LOCAL_MEM) && defined(EIGEN_SYCL_NO_LOCAL_MEM)
-    return false;
-#elif defined(EIGEN_SYCL_LOCAL_MEM) && !defined(EIGEN_SYCL_NO_LOCAL_MEM)
-    return true;
-#else
-    return m_device_info.local_mem_type == cl::sycl::info::local_mem_type::local;
-#endif
-  }
-
-  EIGEN_STRONG_INLINE unsigned long max_buffer_size() const { return m_device_info.max_mem_alloc_size; }
-
-  EIGEN_STRONG_INLINE unsigned long getNumSyclMultiProcessors() const { return m_device_info.max_compute_units; }
-
-  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerBlock() const { return m_device_info.max_work_group_size; }
-
-  EIGEN_STRONG_INLINE cl::sycl::id<3> maxWorkItemSizes() const { return m_device_info.max_work_item_sizes; }
-
-  /// No need for sycl it should act the same as CPU version
-  EIGEN_STRONG_INLINE int majorDeviceVersion() const { return 1; }
-
-  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerMultiProcessor() const {
-    // OpenCL does not have such a concept
-    return 2;
-  }
-
-  EIGEN_STRONG_INLINE size_t sharedMemPerBlock() const { return m_device_info.local_mem_size; }
-
-  // This function returns the nearest power of 2 Work-group size which is <=
-  // maximum device workgroup size.
-  EIGEN_STRONG_INLINE size_t getNearestPowerOfTwoWorkGroupSize() const {
-    return getPowerOfTwo(m_device_info.max_work_group_size, false);
-  }
-
-  EIGEN_STRONG_INLINE std::string getPlatformName() const { return m_device_info.platform_name; }
-
-  EIGEN_STRONG_INLINE std::string getDeviceName() const { return m_device_info.device_name; }
-
-  EIGEN_STRONG_INLINE std::string getDeviceVendor() const { return m_device_info.device_vendor; }
-
-  // This function returns the nearest power of 2
-  // if roundup is true returns result>=wgsize
-  // else it return result <= wgsize
-  EIGEN_STRONG_INLINE size_t getPowerOfTwo(size_t wGSize, bool roundUp) const {
-    if (roundUp) --wGSize;
-    wGSize |= (wGSize >> 1);
-    wGSize |= (wGSize >> 2);
-    wGSize |= (wGSize >> 4);
-    wGSize |= (wGSize >> 8);
-    wGSize |= (wGSize >> 16);
-#if EIGEN_ARCH_x86_64 || EIGEN_ARCH_ARM64 || EIGEN_OS_WIN64
-    wGSize |= (wGSize >> 32);
-#endif
-    return ((!roundUp) ? (wGSize - (wGSize >> 1)) : ++wGSize);
-  }
-
-  EIGEN_STRONG_INLINE cl::sycl::queue &sycl_queue() const { return m_queue; }
-
-  // This function checks if the runtime recorded an error for the
-  // underlying stream device.
-  EIGEN_STRONG_INLINE bool ok() const {
-    if (!exception_caught_) {
-      synchronize();
-    }
-    return !exception_caught_;
-  }
-
- protected:
-  void synchronize_and_callback(cl::sycl::event e, const std::function<void()> &callback) const {
-    if (callback) {
-      auto callback_ = [=]() {
-#ifdef EIGEN_EXCEPTIONS
-        cl::sycl::event(e).wait_and_throw();
-#else
-        cl::sycl::event(e).wait();
-#endif
-        callback();
-      };
-      m_thread_pool.Schedule(std::move(callback_));
-    } else {
-#ifdef EIGEN_EXCEPTIONS
-      m_queue.wait_and_throw();
-#else
-      m_queue.wait();
-#endif
-    }
-  }
-
-  bool sycl_async_handler(cl::sycl::exception_list exceptions) const {
-    bool exception_caught = false;
-    for (const auto &e : exceptions) {
-      if (e) {
-        exception_caught = true;
-        EIGEN_THROW_X(e);
-      }
-    }
-    return exception_caught;
-  }
-
-  /// class members:
-  bool exception_caught_ = false;
-  /// sycl queue
-  mutable cl::sycl::queue m_queue;
-  /// The thread pool is used to wait on events and call callbacks
-  /// asynchronously
-  mutable Eigen::ThreadPool m_thread_pool;
-
-  const TensorSycl::internal::SyclDeviceInfo m_device_info;
-};
-
-struct SyclDeviceBase {
-  /// QueueInterface is not owned. it is the caller's responsibility to destroy
-  /// it
-  const QueueInterface *m_queue_stream;
-  explicit SyclDeviceBase(const QueueInterface *queue_stream) : m_queue_stream(queue_stream) {}
-  EIGEN_STRONG_INLINE const QueueInterface *queue_stream() const { return m_queue_stream; }
-};
-
-// Here is a sycl device struct which accept the sycl queue interface
-// as an input
-struct SyclDevice : public SyclDeviceBase {
-  explicit SyclDevice(const QueueInterface *queue_stream) : SyclDeviceBase(queue_stream) {}
-
-  /// This is used to prepare the number of threads and also the number of
-  /// threads per block for sycl kernels
-  template <typename Index>
-  EIGEN_STRONG_INLINE void parallel_for_setup(Index n, Index &tileSize, Index &rng, Index &GRange) const {
-    queue_stream()->parallel_for_setup(n, tileSize, rng, GRange);
-  }
-
-  /// This is used to prepare the number of threads and also the number of
-  /// threads per block for sycl kernels
-  template <typename Index>
-  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 2> &input_dim, cl::sycl::range<2> &global_range,
-                                              cl::sycl::range<2> &local_range) const {
-    queue_stream()->parallel_for_setup(input_dim, global_range, local_range);
-  }
-
-  /// This is used to prepare the number of threads and also the number of
-  /// threads per block for sycl kernels
-  template <typename Index>
-  EIGEN_STRONG_INLINE void parallel_for_setup(const std::array<Index, 3> &input_dim, cl::sycl::range<3> &global_range,
-                                              cl::sycl::range<3> &local_range) const {
-    queue_stream()->parallel_for_setup(input_dim, global_range, local_range);
-  }
-
-  /// allocate device memory
-  EIGEN_STRONG_INLINE void *allocate(size_t num_bytes) const { return queue_stream()->allocate(num_bytes); }
-
-  EIGEN_STRONG_INLINE void *allocate_temp(size_t num_bytes) const { return queue_stream()->allocate_temp(num_bytes); }
-
-  /// deallocate device memory
-  EIGEN_STRONG_INLINE void deallocate(void *p) const { queue_stream()->deallocate(p); }
-
-  EIGEN_STRONG_INLINE void deallocate_temp(void *buffer) const { queue_stream()->deallocate_temp(buffer); }
-
-  EIGEN_STRONG_INLINE void deallocate_temp(const void *buffer) const { queue_stream()->deallocate_temp(buffer); }
-
-  template <typename data_t>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE data_t *get(data_t *data) const {
-    return data;
-  }
-
-  // some runtime conditions that can be applied here
-  EIGEN_STRONG_INLINE bool isDeviceSuitable() const { return true; }
-
-  /// memcpyHostToDevice
-  template <typename Index>
-  EIGEN_STRONG_INLINE void memcpyHostToDevice(Index *dst, const Index *src, size_t n,
-                                              std::function<void()> callback = {}) const {
-    queue_stream()->memcpyHostToDevice(dst, src, n, callback);
-  }
-  /// memcpyDeviceToHost
-  template <typename Index>
-  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void *dst, const Index *src, size_t n,
-                                              std::function<void()> callback = {}) const {
-    queue_stream()->memcpyDeviceToHost(dst, src, n, callback);
-  }
-  /// the memcpy function
-  template <typename Index>
-  EIGEN_STRONG_INLINE void memcpy(void *dst, const Index *src, size_t n) const {
-    queue_stream()->memcpy(dst, src, n);
-  }
-  /// the memset function
-  EIGEN_STRONG_INLINE void memset(void *data, int c, size_t n) const { queue_stream()->memset(data, c, n); }
-  /// the fill function
-  template <typename T>
-  EIGEN_STRONG_INLINE void fill(T *begin, T *end, const T &value) const {
-    queue_stream()->fill(begin, end, value);
-  }
-  /// returning the sycl queue
-  EIGEN_STRONG_INLINE cl::sycl::queue &sycl_queue() const { return queue_stream()->sycl_queue(); }
-
-  EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const { return 48 * 1024; }
-
-  EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
-    // We won't try to take advantage of the l2 cache for the time being, and
-    // there is no l3 cache on sycl devices.
-    return firstLevelCacheSize();
-  }
-  EIGEN_STRONG_INLINE unsigned long getNumSyclMultiProcessors() const {
-    return queue_stream()->getNumSyclMultiProcessors();
-  }
-  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerBlock() const { return queue_stream()->maxSyclThreadsPerBlock(); }
-  EIGEN_STRONG_INLINE cl::sycl::id<3> maxWorkItemSizes() const { return queue_stream()->maxWorkItemSizes(); }
-  EIGEN_STRONG_INLINE unsigned long maxSyclThreadsPerMultiProcessor() const {
-    // OpenCL does not have such a concept
-    return queue_stream()->maxSyclThreadsPerMultiProcessor();
-  }
-  EIGEN_STRONG_INLINE size_t sharedMemPerBlock() const { return queue_stream()->sharedMemPerBlock(); }
-  EIGEN_STRONG_INLINE size_t getNearestPowerOfTwoWorkGroupSize() const {
-    return queue_stream()->getNearestPowerOfTwoWorkGroupSize();
-  }
-
-  EIGEN_STRONG_INLINE size_t getPowerOfTwo(size_t val, bool roundUp) const {
-    return queue_stream()->getPowerOfTwo(val, roundUp);
-  }
-  /// No need for sycl it should act the same as CPU version
-  EIGEN_STRONG_INLINE int majorDeviceVersion() const { return queue_stream()->majorDeviceVersion(); }
-
-  EIGEN_STRONG_INLINE void synchronize() const { queue_stream()->synchronize(); }
-
-  // This function checks if the runtime recorded an error for the
-  // underlying stream device.
-  EIGEN_STRONG_INLINE bool ok() const { return queue_stream()->ok(); }
-
-  EIGEN_STRONG_INLINE bool has_local_memory() const { return queue_stream()->has_local_memory(); }
-  EIGEN_STRONG_INLINE long max_buffer_size() const { return queue_stream()->max_buffer_size(); }
-  EIGEN_STRONG_INLINE std::string getPlatformName() const { return queue_stream()->getPlatformName(); }
-  EIGEN_STRONG_INLINE std::string getDeviceName() const { return queue_stream()->getDeviceName(); }
-  EIGEN_STRONG_INLINE std::string getDeviceVendor() const { return queue_stream()->getDeviceVendor(); }
-  template <typename OutScalar, typename KernelType, typename... T>
-  EIGEN_ALWAYS_INLINE cl::sycl::event binary_kernel_launcher(T... var) const {
-    return queue_stream()->template binary_kernel_launcher<OutScalar, KernelType>(var...);
-  }
-  template <typename OutScalar, typename KernelType, typename... T>
-  EIGEN_ALWAYS_INLINE cl::sycl::event unary_kernel_launcher(T... var) const {
-    return queue_stream()->template unary_kernel_launcher<OutScalar, KernelType>(var...);
-  }
-
-  template <typename OutScalar, typename KernelType, typename... T>
-  EIGEN_ALWAYS_INLINE cl::sycl::event nullary_kernel_launcher(T... var) const {
-    return queue_stream()->template nullary_kernel_launcher<OutScalar, KernelType>(var...);
-  }
-};
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DEVICE_SYCL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDeviceThreadPool.h b/unsupported/Eigen/src/Tensor/TensorDeviceThreadPool.h
deleted file mode 100644
index 85c1dc8..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDeviceThreadPool.h
+++ /dev/null
@@ -1,346 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#if defined(EIGEN_USE_THREADS) && !defined(EIGEN_CXX11_TENSOR_TENSOR_DEVICE_THREAD_POOL_H)
-#define EIGEN_CXX11_TENSOR_TENSOR_DEVICE_THREAD_POOL_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// An abstract interface to a device specific memory allocator.
-class Allocator {
- public:
-  virtual ~Allocator() {}
-  virtual void* allocate(size_t num_bytes) const = 0;
-  virtual void deallocate(void* buffer) const = 0;
-};
-
-// Build a thread pool device on top the an existing pool of threads.
-struct ThreadPoolDevice {
-  // The ownership of the thread pool remains with the caller.
-  ThreadPoolDevice(ThreadPoolInterface* pool, int num_cores, Allocator* allocator = nullptr)
-      : pool_(pool), num_threads_(num_cores), allocator_(allocator) {}
-
-  EIGEN_STRONG_INLINE void* allocate(size_t num_bytes) const {
-    return allocator_ ? allocator_->allocate(num_bytes) : internal::aligned_malloc(num_bytes);
-  }
-
-  EIGEN_STRONG_INLINE void deallocate(void* buffer) const {
-    if (allocator_) {
-      allocator_->deallocate(buffer);
-    } else {
-      internal::aligned_free(buffer);
-    }
-  }
-
-  EIGEN_STRONG_INLINE void* allocate_temp(size_t num_bytes) const { return allocate(num_bytes); }
-
-  EIGEN_STRONG_INLINE void deallocate_temp(void* buffer) const { deallocate(buffer); }
-
-  template <typename Type>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Type get(Type data) const {
-    return data;
-  }
-
-  EIGEN_STRONG_INLINE void memcpy(void* dst, const void* src, size_t n) const {
-#ifdef __ANDROID__
-    ::memcpy(dst, src, n);
-#else
-    // TODO(rmlarsen): Align blocks on cache lines.
-    // We have observed that going beyond 4 threads usually just wastes
-    // CPU cycles due to the threads competing for memory bandwidth, so we
-    // statically schedule at most 4 block copies here.
-    const size_t kMinBlockSize = 32768;
-    const size_t num_threads = CostModel::numThreads(n, TensorOpCost(1.0, 1.0, 0), 4);
-    if (n <= kMinBlockSize || num_threads < 2) {
-      ::memcpy(dst, src, n);
-    } else {
-      const char* src_ptr = static_cast<const char*>(src);
-      char* dst_ptr = static_cast<char*>(dst);
-      const size_t blocksize = (n + (num_threads - 1)) / num_threads;
-      Barrier barrier(static_cast<int>(num_threads - 1));
-      // Launch the last 3 blocks on worker threads.
-      for (size_t i = 1; i < num_threads; ++i) {
-        pool_->Schedule([n, i, src_ptr, dst_ptr, blocksize, &barrier] {
-          ::memcpy(dst_ptr + i * blocksize, src_ptr + i * blocksize, numext::mini(blocksize, n - (i * blocksize)));
-          barrier.Notify();
-        });
-      }
-      // Launch the first block on the main thread.
-      ::memcpy(dst_ptr, src_ptr, blocksize);
-      barrier.Wait();
-    }
-#endif
-  }
-  EIGEN_STRONG_INLINE void memcpyHostToDevice(void* dst, const void* src, size_t n) const { memcpy(dst, src, n); }
-  EIGEN_STRONG_INLINE void memcpyDeviceToHost(void* dst, const void* src, size_t n) const { memcpy(dst, src, n); }
-
-  EIGEN_STRONG_INLINE void memset(void* buffer, int c, size_t n) const { ::memset(buffer, c, n); }
-
-  template <typename T>
-  EIGEN_STRONG_INLINE void fill(T* begin, T* end, const T& value) const {
-    std::fill(begin, end, value);
-  }
-
-  EIGEN_STRONG_INLINE int numThreads() const { return num_threads_; }
-
-  // Number of threads available in the underlying thread pool. This number can
-  // be different from the value returned by numThreads().
-  EIGEN_STRONG_INLINE int numThreadsInPool() const { return pool_->NumThreads(); }
-
-  EIGEN_STRONG_INLINE size_t firstLevelCacheSize() const { return l1CacheSize(); }
-
-  EIGEN_STRONG_INLINE size_t lastLevelCacheSize() const {
-    // The l3 cache size is shared between all the cores.
-    return l3CacheSize() / num_threads_;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void synchronize() const {
-    // Nothing.  Threadpool device operations are synchronous.
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int majorDeviceVersion() const {
-    // Should return an enum that encodes the ISA supported by the CPU
-    return 1;
-  }
-
-  // TODO(rmlarsen): Remove this deprecated interface when all users have been converted.
-  template <class Function, class... Args>
-  EIGEN_STRONG_INLINE void enqueueNoNotification(Function&& f, Args&&... args) const {
-    enqueue(std::forward<Function>(f), std::forward<Args>(args)...);
-  }
-
-  template <class Function, class... Args>
-  EIGEN_STRONG_INLINE void enqueue(Function&& f, Args&&... args) const {
-#if EIGEN_COMP_CXXVER >= 20
-    if constexpr (sizeof...(args) > 0) {
-      auto run_f = [f = std::forward<Function>(f), ... args = std::forward<Args>(args)]() { f(args...); };
-#else
-    if (sizeof...(args) > 0) {
-      auto run_f = [f = std::forward<Function>(f), &args...]() { f(args...); };
-#endif
-      pool_->Schedule(std::move(run_f));
-    } else {
-      pool_->Schedule(std::forward<Function>(f));
-    }
-  }
-
-  // Returns a logical thread index between 0 and pool_->NumThreads() - 1 if
-  // called from one of the threads in pool_. Returns -1 otherwise.
-  EIGEN_STRONG_INLINE int currentThreadId() const { return pool_->CurrentThreadId(); }
-
-  // WARNING: This function is synchronous and will block the calling thread.
-  //
-  // Synchronous parallelFor executes f with [0, n) arguments in parallel and
-  // waits for completion. F accepts a half-open interval [first, last). Block
-  // size is chosen based on the iteration cost and resulting parallel
-  // efficiency. If block_align is not nullptr, it is called to round up the
-  // block size.
-  void parallelFor(Index n, const TensorOpCost& cost, std::function<Index(Index)> block_align,
-                   std::function<void(Index, Index)> f) const {
-    if (EIGEN_PREDICT_FALSE(n <= 0)) {
-      return;
-      // Compute small problems directly in the caller thread.
-    } else if (n == 1 || numThreads() == 1 || CostModel::numThreads(n, cost, static_cast<int>(numThreads())) == 1) {
-      f(0, n);
-      return;
-    }
-
-    // Compute block size and total count of blocks.
-    ParallelForBlock block = CalculateParallelForBlock(n, cost, block_align);
-
-    // Recursively divide size into halves until we reach block_size.
-    // Division code rounds mid to block_size, so we are guaranteed to get
-    // block_count leaves that do actual computations.
-    Barrier barrier(static_cast<unsigned int>(block.count));
-    if (block.count <= numThreads()) {
-      // Avoid a thread hop by running the root of the tree and one block on the
-      // main thread.
-      handleRange(0, n, block.size, &barrier, pool_, f);
-    } else {
-      // Execute the root in the thread pool to avoid running work on more than
-      // numThreads() threads.
-      pool_->Schedule([this, n, &block, &barrier, &f]() { handleRange(0, n, block.size, &barrier, pool_, f); });
-    }
-
-    barrier.Wait();
-  }
-
-  // Convenience wrapper for parallelFor that does not align blocks.
-  void parallelFor(Index n, const TensorOpCost& cost, std::function<void(Index, Index)> f) const {
-    parallelFor(n, cost, nullptr, std::move(f));
-  }
-
-  // WARNING: This function is asynchronous and will not block the calling thread.
-  //
-  // Asynchronous parallelFor executes f with [0, n) arguments in parallel
-  // without waiting for completion. When the last block finished, it will call
-  // 'done' callback. F accepts a half-open interval [first, last). Block size
-  // is chosen based on the iteration cost and resulting parallel efficiency. If
-  // block_align is not nullptr, it is called to round up the block size.
-  void parallelForAsync(Index n, const TensorOpCost& cost, std::function<Index(Index)> block_align,
-                        std::function<void(Index, Index)> f, std::function<void()> done) const {
-    // Compute small problems directly in the caller thread.
-    if (n <= 1 || numThreads() == 1 || CostModel::numThreads(n, cost, static_cast<int>(numThreads())) == 1) {
-      f(0, n);
-      done();
-      return;
-    }
-
-    // Compute block size and total count of blocks.
-    ParallelForBlock block = CalculateParallelForBlock(n, cost, block_align);
-
-    ParallelForAsyncContext* const ctx = new ParallelForAsyncContext(block.count, std::move(f), std::move(done));
-
-    // Recursively divide size into halves until we reach block_size.
-    // Division code rounds mid to block_size, so we are guaranteed to get
-    // block_count leaves that do actual computations.
-    ctx->handle_range = [this, ctx, block](Index firstIdx, Index lastIdx) {
-      while (lastIdx - firstIdx > block.size) {
-        // Split into halves and schedule the second half on a different thread.
-        const Index midIdx = firstIdx + numext::div_ceil((lastIdx - firstIdx) / 2, block.size) * block.size;
-        pool_->Schedule([ctx, midIdx, lastIdx]() { ctx->handle_range(midIdx, lastIdx); });
-        lastIdx = midIdx;
-      }
-
-      // Single block or less, execute directly.
-      ctx->f(firstIdx, lastIdx);
-
-      // Delete async context if it was the last block.
-      if (ctx->count.fetch_sub(1) == 1) delete ctx;
-    };
-
-    if (block.count <= numThreads()) {
-      // Avoid a thread hop by running the root of the tree and one block on the
-      // main thread.
-      ctx->handle_range(0, n);
-    } else {
-      // Execute the root in the thread pool to avoid running work on more than
-      // numThreads() threads.
-      pool_->Schedule([ctx, n]() { ctx->handle_range(0, n); });
-    }
-  }
-
-  // Convenience wrapper for parallelForAsync that does not align blocks.
-  void parallelForAsync(Index n, const TensorOpCost& cost, std::function<void(Index, Index)> f,
-                        std::function<void()> done) const {
-    parallelForAsync(n, cost, nullptr, std::move(f), std::move(done));
-  }
-
-  // Thread pool accessor.
-  ThreadPoolInterface* getPool() const { return pool_; }
-
-  // Allocator accessor.
-  Allocator* allocator() const { return allocator_; }
-
- private:
-  typedef TensorCostModel<ThreadPoolDevice> CostModel;
-
-  static void handleRange(Index firstIdx, Index lastIdx, Index granularity, Barrier* barrier, ThreadPoolInterface* pool,
-                          const std::function<void(Index, Index)>& f) {
-    while (lastIdx - firstIdx > granularity) {
-      // Split into halves and schedule the second half on a different thread.
-      const Index midIdx = firstIdx + numext::div_ceil((lastIdx - firstIdx) / 2, granularity) * granularity;
-      pool->Schedule([=, &f]() { handleRange(midIdx, lastIdx, granularity, barrier, pool, f); });
-      lastIdx = midIdx;
-    }
-    // Single block or less, execute directly.
-    f(firstIdx, lastIdx);
-    barrier->Notify();
-  }
-
-  // For parallelForAsync we must keep passed in closures on the heap, and
-  // delete them only after `done` callback finished.
-  struct ParallelForAsyncContext {
-    ParallelForAsyncContext(Index block_count, std::function<void(Index, Index)> block_f,
-                            std::function<void()> done_callback)
-        : count(block_count), f(std::move(block_f)), done(std::move(done_callback)) {}
-    ~ParallelForAsyncContext() { done(); }
-
-    std::atomic<Index> count;
-    std::function<void(Index, Index)> f;
-    std::function<void()> done;
-
-    std::function<void(Index, Index)> handle_range;
-  };
-
-  struct ParallelForBlock {
-    Index size;   // block size
-    Index count;  // number of blocks
-  };
-
-  // Calculates block size based on (1) the iteration cost and (2) parallel
-  // efficiency. We want blocks to be not too small to mitigate parallelization
-  // overheads; not too large to mitigate tail effect and potential load
-  // imbalance and we also want number of blocks to be evenly dividable across
-  // threads.
-  ParallelForBlock CalculateParallelForBlock(const Index n, const TensorOpCost& cost,
-                                             std::function<Index(Index)> block_align) const {
-    const double block_size_f = 1.0 / CostModel::taskSize(1, cost);
-    const Index max_oversharding_factor = 4;
-    Index block_size = numext::mini(
-        n, numext::maxi<Index>(numext::div_ceil<Index>(n, max_oversharding_factor * numThreads()), block_size_f));
-    const Index max_block_size = numext::mini(n, 2 * block_size);
-
-    if (block_align) {
-      Index new_block_size = block_align(block_size);
-      eigen_assert(new_block_size >= block_size);
-      block_size = numext::mini(n, new_block_size);
-    }
-
-    Index block_count = numext::div_ceil(n, block_size);
-
-    // Calculate parallel efficiency as fraction of total CPU time used for
-    // computations:
-    double max_efficiency =
-        static_cast<double>(block_count) / (numext::div_ceil<Index>(block_count, numThreads()) * numThreads());
-
-    // Now try to increase block size up to max_block_size as long as it
-    // doesn't decrease parallel efficiency.
-    for (Index prev_block_count = block_count; max_efficiency < 1.0 && prev_block_count > 1;) {
-      // This is the next block size that divides size into a smaller number
-      // of blocks than the current block_size.
-      Index coarser_block_size = numext::div_ceil(n, prev_block_count - 1);
-      if (block_align) {
-        Index new_block_size = block_align(coarser_block_size);
-        eigen_assert(new_block_size >= coarser_block_size);
-        coarser_block_size = numext::mini(n, new_block_size);
-      }
-      if (coarser_block_size > max_block_size) {
-        break;  // Reached max block size. Stop.
-      }
-      // Recalculate parallel efficiency.
-      const Index coarser_block_count = numext::div_ceil(n, coarser_block_size);
-      eigen_assert(coarser_block_count < prev_block_count);
-      prev_block_count = coarser_block_count;
-      const double coarser_efficiency = static_cast<double>(coarser_block_count) /
-                                        (numext::div_ceil<Index>(coarser_block_count, numThreads()) * numThreads());
-      if (coarser_efficiency + 0.01 >= max_efficiency) {
-        // Taking it.
-        block_size = coarser_block_size;
-        block_count = coarser_block_count;
-        if (max_efficiency < coarser_efficiency) {
-          max_efficiency = coarser_efficiency;
-        }
-      }
-    }
-
-    return {block_size, block_count};
-  }
-
-  ThreadPoolInterface* pool_;
-  int num_threads_;
-  Allocator* allocator_;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DEVICE_THREAD_POOL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDimensionList.h b/unsupported/Eigen/src/Tensor/TensorDimensionList.h
deleted file mode 100644
index 8f2e5af..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDimensionList.h
+++ /dev/null
@@ -1,117 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_DIMENSION_LIST_H
-#define EIGEN_CXX11_TENSOR_TENSOR_DIMENSION_LIST_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \internal
- *
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Special case of tensor index list used to list all the dimensions of a tensor of rank n.
- *
- * \sa Tensor
- */
-template <typename Index, std::size_t Rank>
-struct DimensionList {
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const Index operator[](const Index i) const { return i; }
-};
-
-namespace internal {
-
-template <typename Index, std::size_t Rank>
-struct array_size<DimensionList<Index, Rank> > {
-  static const size_t value = Rank;
-};
-template <typename Index, std::size_t Rank>
-struct array_size<const DimensionList<Index, Rank> > {
-  static const size_t value = Rank;
-};
-
-template <DenseIndex n, typename Index, std::size_t Rank>
-const Index array_get(DimensionList<Index, Rank>&) {
-  return n;
-}
-template <DenseIndex n, typename Index, std::size_t Rank>
-const Index array_get(const DimensionList<Index, Rank>&) {
-  return n;
-}
-
-template <typename Index, std::size_t Rank>
-struct index_known_statically_impl<DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex) { return true; }
-};
-template <typename Index, std::size_t Rank>
-struct index_known_statically_impl<const DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex) { return true; }
-};
-
-template <typename Index, std::size_t Rank>
-struct all_indices_known_statically_impl<DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run() { return true; }
-};
-template <typename Index, std::size_t Rank>
-struct all_indices_known_statically_impl<const DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run() { return true; }
-};
-
-template <typename Index, std::size_t Rank>
-struct indices_statically_known_to_increase_impl<DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run() { return true; }
-};
-template <typename Index, std::size_t Rank>
-struct indices_statically_known_to_increase_impl<const DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run() { return true; }
-};
-
-template <typename Index, std::size_t Rank>
-struct index_statically_eq_impl<DimensionList<Index, Rank> > {
-  static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i == value; }
-};
-template <typename Index, std::size_t Rank>
-struct index_statically_eq_impl<const DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i == value; }
-};
-
-template <typename Index, std::size_t Rank>
-struct index_statically_ne_impl<DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i != value; }
-};
-template <typename Index, std::size_t Rank>
-struct index_statically_ne_impl<const DimensionList<Index, Rank> > {
-  static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i != value; }
-};
-
-template <typename Index, std::size_t Rank>
-struct index_statically_gt_impl<DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i > value; }
-};
-template <typename Index, std::size_t Rank>
-struct index_statically_gt_impl<const DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i > value; }
-};
-
-template <typename Index, std::size_t Rank>
-struct index_statically_lt_impl<DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i < value; }
-};
-template <typename Index, std::size_t Rank>
-struct index_statically_lt_impl<const DimensionList<Index, Rank> > {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const DenseIndex i, const DenseIndex value) { return i < value; }
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DIMENSION_LIST_H
diff --git a/unsupported/Eigen/src/Tensor/TensorDimensions.h b/unsupported/Eigen/src/Tensor/TensorDimensions.h
deleted file mode 100644
index 8aca0f3..0000000
--- a/unsupported/Eigen/src/Tensor/TensorDimensions.h
+++ /dev/null
@@ -1,334 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_DIMENSIONS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_DIMENSIONS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// Boilerplate code
-namespace internal {
-
-template <std::ptrdiff_t n, typename Dimension>
-struct dget {
-  static const std::ptrdiff_t value = get<n, Dimension>::value;
-};
-
-template <typename Index, std::ptrdiff_t NumIndices, std::ptrdiff_t n, bool RowMajor>
-struct fixed_size_tensor_index_linearization_helper {
-  template <typename Dimensions>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
-                                                         const Dimensions& dimensions) {
-    return array_get < RowMajor                             ? n - 1
-           : (NumIndices - n) > (indices) + dget < RowMajor ? n - 1
-                                                            : (NumIndices - n),
-           Dimensions > ::value * fixed_size_tensor_index_linearization_helper<Index, NumIndices, n - 1, RowMajor>::run(
-                                      indices, dimensions);
-  }
-};
-
-template <typename Index, std::ptrdiff_t NumIndices, bool RowMajor>
-struct fixed_size_tensor_index_linearization_helper<Index, NumIndices, 0, RowMajor> {
-  template <typename Dimensions>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const&, const Dimensions&) {
-    return 0;
-  }
-};
-
-template <typename Index, std::ptrdiff_t n>
-struct fixed_size_tensor_index_extraction_helper {
-  template <typename Dimensions>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(const Index index, const Dimensions& dimensions) {
-    const Index mult = (index == n - 1) ? 1 : 0;
-    return array_get<n - 1>(dimensions) * mult +
-           fixed_size_tensor_index_extraction_helper<Index, n - 1>::run(index, dimensions);
-  }
-};
-
-template <typename Index>
-struct fixed_size_tensor_index_extraction_helper<Index, 0> {
-  template <typename Dimensions>
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE Index run(const Index, const Dimensions&) {
-    return 0;
-  }
-};
-
-}  // end namespace internal
-
-/** \internal
- *
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Fixed dimensions of a Tensor.
- *
- * The Sizes class encodes as part of the type the number of dimensions and the
- * sizes corresponding to each dimension. It uses no storage space since it is
- * entirely known at compile time.
- *
- * \sa Tensor
- */
-template <typename std::ptrdiff_t... Indices>
-struct Sizes {
-  typedef internal::numeric_list<std::ptrdiff_t, Indices...> Base;
-  const Base t = Base();
-  static const std::ptrdiff_t total_size = internal::arg_prod(Indices...);
-  static const ptrdiff_t count = Base::count;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t rank() const { return Base::count; }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t TotalSize() { return internal::arg_prod(Indices...); }
-
-  EIGEN_DEVICE_FUNC Sizes() {}
-  template <typename DenseIndex>
-  explicit EIGEN_DEVICE_FUNC Sizes(const array<DenseIndex, Base::count>& /*indices*/) {
-    // TODO: Add assertion.
-  }
-  template <typename... DenseIndex>
-  EIGEN_DEVICE_FUNC Sizes(DenseIndex...) {}
-  explicit EIGEN_DEVICE_FUNC Sizes(std::initializer_list<std::ptrdiff_t> /*l*/) {
-    // TODO: Add assertion.
-  }
-
-  template <typename T>
-  Sizes& operator=(const T& /*other*/) {
-    // add assertion failure if the size of other is different
-    return *this;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t operator[](const std::ptrdiff_t index) const {
-    return internal::fixed_size_tensor_index_extraction_helper<std::ptrdiff_t, Base::count>::run(index, t);
-  }
-
-  template <typename DenseIndex>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptrdiff_t IndexOfColMajor(const array<DenseIndex, Base::count>& indices) const {
-    return internal::fixed_size_tensor_index_linearization_helper<DenseIndex, Base::count, Base::count, false>::run(
-        indices, t);
-  }
-  template <typename DenseIndex>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ptrdiff_t IndexOfRowMajor(const array<DenseIndex, Base::count>& indices) const {
-    return internal::fixed_size_tensor_index_linearization_helper<DenseIndex, Base::count, Base::count, true>::run(
-        indices, t);
-  }
-};
-
-namespace internal {
-template <typename std::ptrdiff_t... Indices>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_prod(const Sizes<Indices...>&) {
-  return Sizes<Indices...>::total_size;
-}
-}  // namespace internal
-
-// Boilerplate
-namespace internal {
-template <typename Index, std::ptrdiff_t NumIndices, std::ptrdiff_t n, bool RowMajor>
-struct tensor_index_linearization_helper {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
-                                                         array<Index, NumIndices> const& dimensions) {
-    return array_get < RowMajor ? n
-           : (NumIndices - n - 1) > (indices) + array_get < RowMajor
-               ? n
-               : (NumIndices - n - 1) >
-                     (dimensions)*tensor_index_linearization_helper<Index, NumIndices, n - 1, RowMajor>::run(
-                         indices, dimensions);
-  }
-};
-
-template <typename Index, std::ptrdiff_t NumIndices, bool RowMajor>
-struct tensor_index_linearization_helper<Index, NumIndices, 0, RowMajor> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
-                                                         array<Index, NumIndices> const&) {
-    return array_get < RowMajor ? 0 : NumIndices - 1 > (indices);
-  }
-};
-}  // end namespace internal
-
-/** \internal
- *
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Dynamic dimensions of a Tensor.
- *
- * The DSizes class is its dynamic sibling: the number of dimensions is known
- * at compile time but the sizes are set during execution.
- *
- * \sa Tensor
- */
-template <typename DenseIndex, int NumDims>
-struct DSizes : array<DenseIndex, NumDims> {
-  typedef array<DenseIndex, NumDims> Base;
-  static const int count = NumDims;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return NumDims; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex TotalSize() const {
-    return (NumDims == 0) ? 1 : internal::array_prod(*static_cast<const Base*>(this));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DSizes() {
-    for (int i = 0; i < NumDims; ++i) {
-      (*this)[i] = 0;
-    }
-  }
-  EIGEN_DEVICE_FUNC explicit DSizes(const array<DenseIndex, NumDims>& a) : Base(a) {}
-
-  EIGEN_DEVICE_FUNC explicit DSizes(const DenseIndex i0) {
-    eigen_assert(NumDims == 1);
-    (*this)[0] = i0;
-  }
-
-  EIGEN_DEVICE_FUNC DSizes(const DimensionList<DenseIndex, NumDims>& a) {
-    for (int i = 0; i < NumDims; ++i) {
-      (*this)[i] = a[i];
-    }
-  }
-
-  // Enable DSizes index type promotion only if we are promoting to the
-  // larger type, e.g. allow to promote dimensions of type int to long.
-  template <typename OtherIndex>
-  EIGEN_DEVICE_FUNC explicit DSizes(
-      const array<OtherIndex, NumDims>& other,
-      // Default template parameters require c++11.
-      std::enable_if_t<
-          internal::is_same<DenseIndex, typename internal::promote_index_type<DenseIndex, OtherIndex>::type>::value,
-          void*> = 0) {
-    for (int i = 0; i < NumDims; ++i) {
-      (*this)[i] = static_cast<DenseIndex>(other[i]);
-    }
-  }
-
-  template <typename FirstType, typename... OtherTypes>
-  EIGEN_DEVICE_FUNC explicit DSizes(const Eigen::IndexList<FirstType, OtherTypes...>& dimensions) {
-    for (int i = 0; i < dimensions.count; ++i) {
-      (*this)[i] = dimensions[i];
-    }
-  }
-
-  template <typename std::ptrdiff_t... Indices>
-  EIGEN_DEVICE_FUNC DSizes(const Sizes<Indices...>& a) {
-    for (int i = 0; i < NumDims; ++i) {
-      (*this)[i] = a[i];
-    }
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit DSizes(DenseIndex firstDimension, DenseIndex secondDimension,
-                                                        IndexTypes... otherDimensions)
-      : Base({{firstDimension, secondDimension, otherDimensions...}}) {
-    EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 2 == NumDims, YOU_MADE_A_PROGRAMMING_MISTAKE)
-  }
-
-  EIGEN_DEVICE_FUNC DSizes& operator=(const array<DenseIndex, NumDims>& other) {
-    *static_cast<Base*>(this) = other;
-    return *this;
-  }
-
-  // A constexpr would be so much better here
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex IndexOfColMajor(const array<DenseIndex, NumDims>& indices) const {
-    return internal::tensor_index_linearization_helper<DenseIndex, NumDims, NumDims - 1, false>::run(
-        indices, *static_cast<const Base*>(this));
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex IndexOfRowMajor(const array<DenseIndex, NumDims>& indices) const {
-    return internal::tensor_index_linearization_helper<DenseIndex, NumDims, NumDims - 1, true>::run(
-        indices, *static_cast<const Base*>(this));
-  }
-};
-
-template <typename IndexType, int NumDims>
-std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dims) {
-  os << "[";
-  for (int i = 0; i < NumDims; ++i) {
-    if (i > 0) os << ", ";
-    os << dims[i];
-  }
-  os << "]";
-  return os;
-}
-
-// Boilerplate
-namespace internal {
-template <typename Index, std::ptrdiff_t NumIndices, std::ptrdiff_t n, bool RowMajor>
-struct tensor_vsize_index_linearization_helper {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
-                                                         std::vector<DenseIndex> const& dimensions) {
-    return array_get < RowMajor ? n
-           : (NumIndices - n - 1) > (indices) + array_get < RowMajor
-               ? n
-               : (NumIndices - n - 1) >
-                     (dimensions)*tensor_vsize_index_linearization_helper<Index, NumIndices, n - 1, RowMajor>::run(
-                         indices, dimensions);
-  }
-};
-
-template <typename Index, std::ptrdiff_t NumIndices, bool RowMajor>
-struct tensor_vsize_index_linearization_helper<Index, NumIndices, 0, RowMajor> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index run(array<Index, NumIndices> const& indices,
-                                                         std::vector<DenseIndex> const&) {
-    return array_get < RowMajor ? 0 : NumIndices - 1 > (indices);
-  }
-};
-}  // end namespace internal
-
-namespace internal {
-
-template <typename DenseIndex, int NumDims>
-struct array_size<const DSizes<DenseIndex, NumDims> > {
-  static const ptrdiff_t value = NumDims;
-};
-template <typename DenseIndex, int NumDims>
-struct array_size<DSizes<DenseIndex, NumDims> > {
-  static const ptrdiff_t value = NumDims;
-};
-template <typename std::ptrdiff_t... Indices>
-struct array_size<const Sizes<Indices...> > {
-  static const std::ptrdiff_t value = Sizes<Indices...>::count;
-};
-template <typename std::ptrdiff_t... Indices>
-struct array_size<Sizes<Indices...> > {
-  static const std::ptrdiff_t value = Sizes<Indices...>::count;
-};
-template <std::ptrdiff_t n, typename std::ptrdiff_t... Indices>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_get(const Sizes<Indices...>&) {
-  return get<n, internal::numeric_list<std::ptrdiff_t, Indices...> >::value;
-}
-template <std::ptrdiff_t n>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::ptrdiff_t array_get(const Sizes<>&) {
-  eigen_assert(false && "should never be called");
-  return -1;
-}
-
-template <typename Dims1, typename Dims2, ptrdiff_t n, ptrdiff_t m>
-struct sizes_match_below_dim {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(Dims1&, Dims2&) { return false; }
-};
-template <typename Dims1, typename Dims2, ptrdiff_t n>
-struct sizes_match_below_dim<Dims1, Dims2, n, n> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(Dims1& dims1, Dims2& dims2) {
-    return numext::equal_strict(array_get<n - 1>(dims1), array_get<n - 1>(dims2)) &&
-           sizes_match_below_dim<Dims1, Dims2, n - 1, n - 1>::run(dims1, dims2);
-  }
-};
-template <typename Dims1, typename Dims2>
-struct sizes_match_below_dim<Dims1, Dims2, 0, 0> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool run(Dims1&, Dims2&) { return true; }
-};
-
-}  // end namespace internal
-
-template <typename Dims1, typename Dims2>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool dimensions_match(Dims1 dims1, Dims2 dims2) {
-  return internal::sizes_match_below_dim<Dims1, Dims2, internal::array_size<Dims1>::value,
-                                         internal::array_size<Dims2>::value>::run(dims1, dims2);
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_DIMENSIONS_H
diff --git a/unsupported/Eigen/src/Tensor/TensorEvalTo.h b/unsupported/Eigen/src/Tensor/TensorEvalTo.h
deleted file mode 100644
index 9c83fad..0000000
--- a/unsupported/Eigen/src/Tensor/TensorEvalTo.h
+++ /dev/null
@@ -1,188 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_EVAL_TO_H
-#define EIGEN_CXX11_TENSOR_TENSOR_EVAL_TO_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename XprType, template <class> class MakePointer_>
-struct traits<TensorEvalToOp<XprType, MakePointer_> > {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename MakePointer_<Scalar>::Type PointerType;
-
-  enum { Flags = 0 };
-  template <class T>
-  struct MakePointer {
-    // Intermediate typedef to workaround MSVC issue.
-    typedef MakePointer_<T> MakePointerT;
-    typedef typename MakePointerT::Type Type;
-  };
-};
-
-template <typename XprType, template <class> class MakePointer_>
-struct eval<TensorEvalToOp<XprType, MakePointer_>, Eigen::Dense> {
-  typedef const TensorEvalToOp<XprType, MakePointer_>& type;
-};
-
-template <typename XprType, template <class> class MakePointer_>
-struct nested<TensorEvalToOp<XprType, MakePointer_>, 1, typename eval<TensorEvalToOp<XprType, MakePointer_> >::type> {
-  typedef TensorEvalToOp<XprType, MakePointer_> type;
-};
-
-}  // end namespace internal
-
-template <typename XprType, template <class> class MakePointer_>
-class TensorEvalToOp : public TensorBase<TensorEvalToOp<XprType, MakePointer_>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorEvalToOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename MakePointer_<CoeffReturnType>::Type PointerType;
-  typedef typename Eigen::internal::nested<TensorEvalToOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorEvalToOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorEvalToOp>::Index Index;
-
-  static constexpr int NumDims = Eigen::internal::traits<TensorEvalToOp>::NumDimensions;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvalToOp(PointerType buffer, const XprType& expr)
-      : m_xpr(expr), m_buffer(buffer) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_DEVICE_FUNC PointerType buffer() const { return m_buffer; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  PointerType m_buffer;
-};
-
-template <typename ArgType, typename Device, template <class> class MakePointer_>
-struct TensorEvaluator<const TensorEvalToOp<ArgType, MakePointer_>, Device> {
-  typedef TensorEvalToOp<ArgType, MakePointer_> XprType;
-  typedef typename ArgType::Scalar Scalar;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  typedef typename XprType::Index Index;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = true,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = true
-  };
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  static constexpr int NumDims = internal::traits<ArgType>::NumDimensions;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
-
-  typedef internal::TensorBlockAssignment<CoeffReturnType, NumDims, typename ArgTensorBlock::XprType, Index>
-      TensorBlockAssignment;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_buffer(device.get(op.buffer())), m_expression(op.expression()) {}
-
-  EIGEN_STRONG_INLINE ~TensorEvaluator() {}
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType scalar) {
-    EIGEN_UNUSED_VARIABLE(scalar);
-    eigen_assert(scalar == NULL);
-    return m_impl.evalSubExprsIfNeeded(m_buffer);
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType scalar, EvalSubExprsCallback done) {
-    EIGEN_UNUSED_VARIABLE(scalar);
-    eigen_assert(scalar == NULL);
-    m_impl.evalSubExprsIfNeededAsync(m_buffer, std::move(done));
-  }
-#endif
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalScalar(Index i) const { m_buffer[i] = m_impl.coeff(i); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalPacket(Index i) const {
-    internal::pstoret<CoeffReturnType, PacketReturnType, Aligned>(
-        m_buffer + i, m_impl.template packet < TensorEvaluator<ArgType, Device>::IsAligned ? Aligned : Unaligned > (i));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return m_impl.getResourceRequirements();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalBlock(TensorBlockDesc& desc, TensorBlockScratch& scratch) {
-    // Add `m_buffer` as destination buffer to the block descriptor.
-    desc.template AddDestinationBuffer<Layout>(
-        /*dst_base=*/m_buffer + desc.offset(),
-        /*dst_strides=*/internal::strides<Layout>(m_impl.dimensions()));
-
-    ArgTensorBlock block = m_impl.block(desc, scratch, /*root_of_expr_ast=*/true);
-
-    // If block was evaluated into a destination buffer, there is no need to do
-    // an assignment.
-    if (block.kind() != internal::TensorBlockKind::kMaterializedInOutput) {
-      TensorBlockAssignment::Run(
-          TensorBlockAssignment::target(desc.dimensions(), internal::strides<Layout>(m_impl.dimensions()), m_buffer,
-                                        desc.offset()),
-          block.expr());
-    }
-    block.cleanup();
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_buffer[index]; }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_buffer + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // We assume that evalPacket or evalScalar is called to perform the
-    // assignment and account for the cost of the write here.
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, sizeof(CoeffReturnType), 0, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_buffer; }
-  ArgType expression() const { return m_expression; }
-
- private:
-  TensorEvaluator<ArgType, Device> m_impl;
-  EvaluatorPointerType m_buffer;
-  const ArgType m_expression;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_EVAL_TO_H
diff --git a/unsupported/Eigen/src/Tensor/TensorEvaluator.h b/unsupported/Eigen/src/Tensor/TensorEvaluator.h
deleted file mode 100644
index 7a19d7a..0000000
--- a/unsupported/Eigen/src/Tensor/TensorEvaluator.h
+++ /dev/null
@@ -1,859 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_EVALUATOR_H
-#define EIGEN_CXX11_TENSOR_TENSOR_EVALUATOR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// Generic evaluator
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief The tensor evaluator class.
- *
- * These classes are responsible for the evaluation of the tensor expression.
- *
- * TODO: add support for more types of expressions, in particular expressions
- * leading to lvalues (slicing, reshaping, etc...)
- */
-template <typename Derived, typename Device>
-struct TensorEvaluator {
-  typedef typename Derived::Index Index;
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename Derived::Dimensions Dimensions;
-  typedef Derived XprType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename internal::traits<Derived>::template MakePointer<Scalar>::Type TensorPointerType;
-  typedef StorageMemory<Scalar, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  // NumDimensions is -1 for variable dim tensors
-  static constexpr int NumCoords =
-      internal::traits<Derived>::NumDimensions > 0 ? internal::traits<Derived>::NumDimensions : 0;
-  static constexpr int Layout = Derived::Layout;
-
-  enum {
-    IsAligned = Derived::IsAligned,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = internal::is_arithmetic<std::remove_const_t<Scalar>>::value,
-    PreferBlockAccess = false,
-    CoordAccess = NumCoords > 0,
-    RawAccess = true
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumCoords, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumCoords, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const Derived& m, const Device& device)
-      : m_data(device.get((const_cast<TensorPointerType>(m.data())))), m_dims(m.dimensions()), m_device(device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dims; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType dest) {
-    if (!NumTraits<std::remove_const_t<Scalar>>::RequireInitialization && dest) {
-      m_device.memcpy((void*)(m_device.get(dest)), m_device.get(m_data), m_dims.TotalSize() * sizeof(Scalar));
-      return false;
-    }
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType dest, EvalSubExprsCallback done) {
-    // TODO(ezhulenev): ThreadPoolDevice memcpy is a blocking operation.
-    done(evalSubExprsIfNeeded(dest));
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    eigen_assert(m_data != NULL);
-    return m_data[index];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    eigen_assert(m_data != NULL);
-    return m_data[index];
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_data + index);
-  }
-
-  // Return a packet starting at `index` where `umask` specifies which elements
-  // have to be loaded. Type/size of mask depends on PacketReturnType, e.g. for
-  // Packet16f, `umask` is of type uint16_t and if a bit is 1, corresponding
-  // float element will be loaded, otherwise 0 will be loaded.
-  // Function has been templatized to enable Sfinae.
-  template <typename PacketReturnTypeT>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-      std::enable_if_t<internal::unpacket_traits<PacketReturnTypeT>::masked_load_available, PacketReturnTypeT>
-      partialPacket(Index index, typename internal::unpacket_traits<PacketReturnTypeT>::mask_t umask) const {
-    return internal::ploadu<PacketReturnTypeT>(m_data + index, umask);
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    return internal::pstoret<Scalar, PacketReturnType, StoreMode>(m_data + index, x);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(const array<DenseIndex, NumCoords>& coords) const {
-    eigen_assert(m_data != NULL);
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      return m_data[m_dims.IndexOfColMajor(coords)];
-    } else {
-      return m_data[m_dims.IndexOfRowMajor(coords)];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(const array<DenseIndex, NumCoords>& coords) const {
-    eigen_assert(m_data != NULL);
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      return m_data[m_dims.IndexOfColMajor(coords)];
-    } else {
-      return m_data[m_dims.IndexOfRowMajor(coords)];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketType<CoeffReturnType, Device>::size);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return internal::TensorBlockResourceRequirements::any();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    eigen_assert(m_data != NULL);
-    return TensorBlock::materialize(m_data, m_dims, desc, scratch);
-  }
-
-  template <typename TensorBlock>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
-    eigen_assert(m_data != NULL);
-
-    typedef typename TensorBlock::XprType TensorBlockExpr;
-    typedef internal::TensorBlockAssignment<Scalar, NumCoords, TensorBlockExpr, Index> TensorBlockAssign;
-
-    TensorBlockAssign::Run(
-        TensorBlockAssign::target(desc.dimensions(), internal::strides<Layout>(m_dims), m_data, desc.offset()),
-        block.expr());
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_data; }
-
- protected:
-  EvaluatorPointerType m_data;
-  Dimensions m_dims;
-  const Device EIGEN_DEVICE_REF m_device;
-};
-
-namespace internal {
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T loadConstant(const T* address) {
-  return *address;
-}
-// Use the texture cache on CUDA devices whenever possible
-#if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350
-template <>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float loadConstant(const float* address) {
-  return __ldg(address);
-}
-template <>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double loadConstant(const double* address) {
-  return __ldg(address);
-}
-template <>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Eigen::half loadConstant(const Eigen::half* address) {
-  return Eigen::half(half_impl::raw_uint16_to_half(__ldg(&address->x)));
-}
-#endif
-
-}  // namespace internal
-
-// Default evaluator for rvalues
-template <typename Derived, typename Device>
-struct TensorEvaluator<const Derived, Device> {
-  typedef typename Derived::Index Index;
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename Derived::Dimensions Dimensions;
-  typedef const Derived XprType;
-  typedef typename internal::traits<Derived>::template MakePointer<const Scalar>::Type TensorPointerType;
-  typedef StorageMemory<const Scalar, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  // NumDimensions is -1 for variable dim tensors
-  static constexpr int NumCoords =
-      internal::traits<Derived>::NumDimensions > 0 ? internal::traits<Derived>::NumDimensions : 0;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  static constexpr int Layout = Derived::Layout;
-
-  enum {
-    IsAligned = Derived::IsAligned,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = internal::is_arithmetic<ScalarNoConst>::value,
-    PreferBlockAccess = false,
-    CoordAccess = NumCoords > 0,
-    RawAccess = true
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumCoords, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumCoords, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC TensorEvaluator(const Derived& m, const Device& device)
-      : m_data(device.get(m.data())), m_dims(m.dimensions()), m_device(device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dims; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    if (!NumTraits<std::remove_const_t<Scalar>>::RequireInitialization && data) {
-      m_device.memcpy((void*)(m_device.get(data)), m_device.get(m_data), m_dims.TotalSize() * sizeof(Scalar));
-      return false;
-    }
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType dest, EvalSubExprsCallback done) {
-    // TODO(ezhulenev): ThreadPoolDevice memcpy is a blocking operation.
-    done(evalSubExprsIfNeeded(dest));
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    eigen_assert(m_data != NULL);
-    return internal::loadConstant(m_data + index);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return internal::ploadt_ro<PacketReturnType, LoadMode>(m_data + index);
-  }
-
-  // Return a packet starting at `index` where `umask` specifies which elements
-  // have to be loaded. Type/size of mask depends on PacketReturnType, e.g. for
-  // Packet16f, `umask` is of type uint16_t and if a bit is 1, corresponding
-  // float element will be loaded, otherwise 0 will be loaded.
-  // Function has been templatized to enable Sfinae.
-  template <typename PacketReturnTypeT>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-      std::enable_if_t<internal::unpacket_traits<PacketReturnTypeT>::masked_load_available, PacketReturnTypeT>
-      partialPacket(Index index, typename internal::unpacket_traits<PacketReturnTypeT>::mask_t umask) const {
-    return internal::ploadu<PacketReturnTypeT>(m_data + index, umask);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(const array<DenseIndex, NumCoords>& coords) const {
-    eigen_assert(m_data != NULL);
-    const Index index = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? m_dims.IndexOfColMajor(coords)
-                                                                                 : m_dims.IndexOfRowMajor(coords);
-    return internal::loadConstant(m_data + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketType<CoeffReturnType, Device>::size);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return internal::TensorBlockResourceRequirements::any();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    eigen_assert(m_data != NULL);
-    return TensorBlock::materialize(m_data, m_dims, desc, scratch);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_data; }
-
- protected:
-  EvaluatorPointerType m_data;
-  Dimensions m_dims;
-  const Device EIGEN_DEVICE_REF m_device;
-};
-
-// -------------------- CwiseNullaryOp --------------------
-
-template <typename NullaryOp, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorCwiseNullaryOp<NullaryOp, ArgType>, Device> {
-  typedef TensorCwiseNullaryOp<NullaryOp, ArgType> XprType;
-
-  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
-      : m_functor(op.functor()), m_argImpl(op.nestedExpression(), device), m_wrapper() {}
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = true,
-    PacketAccess = internal::functor_traits<NullaryOp>::PacketAccess
-#ifdef EIGEN_USE_SYCL
-                   && (PacketType<CoeffReturnType, Device>::size > 1)
-#endif
-        ,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_argImpl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) { return true; }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    done(true);
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() {}
-
-  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const { return m_wrapper(m_functor, index); }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return m_wrapper.template packetOp<PacketReturnType, Index>(m_functor, index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketType<CoeffReturnType, Device>::size);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- private:
-  const NullaryOp m_functor;
-  TensorEvaluator<ArgType, Device> m_argImpl;
-  const internal::nullary_wrapper<CoeffReturnType, NullaryOp> m_wrapper;
-};
-
-// -------------------- CwiseUnaryOp --------------------
-
-template <typename UnaryOp, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorCwiseUnaryOp<UnaryOp, ArgType>, Device> {
-  typedef TensorCwiseUnaryOp<UnaryOp, ArgType> XprType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess =
-        int(TensorEvaluator<ArgType, Device>::PacketAccess) & int(internal::functor_traits<UnaryOp>::PacketAccess),
-    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
-      : m_device(device), m_functor(op.functor()), m_argImpl(op.nestedExpression(), device) {}
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  static constexpr int NumDims = internal::array_size<Dimensions>::value;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
-
-  typedef internal::TensorCwiseUnaryBlock<UnaryOp, ArgTensorBlock> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_argImpl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_argImpl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_argImpl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_argImpl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const { return m_functor(m_argImpl.coeff(index)); }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return m_functor.packetOp(m_argImpl.template packet<LoadMode>(index));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double functor_cost = internal::functor_traits<UnaryOp>::Cost;
-    return m_argImpl.costPerCoeff(vectorized) + TensorOpCost(0, 0, functor_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    static const double functor_cost = internal::functor_traits<UnaryOp>::Cost;
-    return m_argImpl.getResourceRequirements().addCostPerCoeff({0, 0, functor_cost / PacketSize});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    return TensorBlock(m_argImpl.block(desc, scratch), m_functor);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- private:
-  const Device EIGEN_DEVICE_REF m_device;
-  const UnaryOp m_functor;
-  TensorEvaluator<ArgType, Device> m_argImpl;
-};
-
-// -------------------- CwiseBinaryOp --------------------
-
-template <typename BinaryOp, typename LeftArgType, typename RightArgType, typename Device>
-struct TensorEvaluator<const TensorCwiseBinaryOp<BinaryOp, LeftArgType, RightArgType>, Device> {
-  typedef TensorCwiseBinaryOp<BinaryOp, LeftArgType, RightArgType> XprType;
-
-  static constexpr int Layout = TensorEvaluator<LeftArgType, Device>::Layout;
-  enum {
-    IsAligned =
-        int(TensorEvaluator<LeftArgType, Device>::IsAligned) & int(TensorEvaluator<RightArgType, Device>::IsAligned),
-    PacketAccess = int(TensorEvaluator<LeftArgType, Device>::PacketAccess) &
-                   int(TensorEvaluator<RightArgType, Device>::PacketAccess) &
-                   int(internal::functor_traits<BinaryOp>::PacketAccess),
-    BlockAccess = int(TensorEvaluator<LeftArgType, Device>::BlockAccess) &
-                  int(TensorEvaluator<RightArgType, Device>::BlockAccess),
-    PreferBlockAccess = int(TensorEvaluator<LeftArgType, Device>::PreferBlockAccess) |
-                        int(TensorEvaluator<RightArgType, Device>::PreferBlockAccess),
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
-      : m_device(device),
-        m_functor(op.functor()),
-        m_leftImpl(op.lhsExpression(), device),
-        m_rightImpl(op.rhsExpression(), device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) ==
-                             static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) ||
-                         internal::traits<XprType>::NumDimensions <= 1),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-    eigen_assert(dimensions_match(m_leftImpl.dimensions(), m_rightImpl.dimensions()));
-  }
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename TensorEvaluator<LeftArgType, Device>::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const LeftArgType, Device>::TensorBlock LeftTensorBlock;
-  typedef typename TensorEvaluator<const RightArgType, Device>::TensorBlock RightTensorBlock;
-
-  typedef internal::TensorCwiseBinaryBlock<BinaryOp, LeftTensorBlock, RightTensorBlock> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
-    // TODO: use right impl instead if right impl dimensions are known at compile time.
-    return m_leftImpl.dimensions();
-  }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_leftImpl.evalSubExprsIfNeeded(NULL);
-    m_rightImpl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    // TODO(ezhulenev): Evaluate two expression in parallel?
-    m_leftImpl.evalSubExprsIfNeededAsync(
-        nullptr, [this, done](bool) { m_rightImpl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); }); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_leftImpl.cleanup();
-    m_rightImpl.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
-    return m_functor(m_leftImpl.coeff(index), m_rightImpl.coeff(index));
-  }
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return m_functor.packetOp(m_leftImpl.template packet<LoadMode>(index),
-                              m_rightImpl.template packet<LoadMode>(index));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double functor_cost = internal::functor_traits<BinaryOp>::Cost;
-    return m_leftImpl.costPerCoeff(vectorized) + m_rightImpl.costPerCoeff(vectorized) +
-           TensorOpCost(0, 0, functor_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    static const double functor_cost = internal::functor_traits<BinaryOp>::Cost;
-    return internal::TensorBlockResourceRequirements::merge(m_leftImpl.getResourceRequirements(),
-                                                            m_rightImpl.getResourceRequirements())
-        .addCostPerCoeff({0, 0, functor_cost / PacketSize});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    desc.DropDestinationBuffer();
-    return TensorBlock(m_leftImpl.block(desc, scratch), m_rightImpl.block(desc, scratch), m_functor);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- private:
-  const Device EIGEN_DEVICE_REF m_device;
-  const BinaryOp m_functor;
-  TensorEvaluator<LeftArgType, Device> m_leftImpl;
-  TensorEvaluator<RightArgType, Device> m_rightImpl;
-};
-
-// -------------------- CwiseTernaryOp --------------------
-
-template <typename TernaryOp, typename Arg1Type, typename Arg2Type, typename Arg3Type, typename Device>
-struct TensorEvaluator<const TensorCwiseTernaryOp<TernaryOp, Arg1Type, Arg2Type, Arg3Type>, Device> {
-  typedef TensorCwiseTernaryOp<TernaryOp, Arg1Type, Arg2Type, Arg3Type> XprType;
-
-  static constexpr int Layout = TensorEvaluator<Arg1Type, Device>::Layout;
-  enum {
-    IsAligned = TensorEvaluator<Arg1Type, Device>::IsAligned & TensorEvaluator<Arg2Type, Device>::IsAligned &
-                TensorEvaluator<Arg3Type, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<Arg1Type, Device>::PacketAccess && TensorEvaluator<Arg2Type, Device>::PacketAccess &&
-                   TensorEvaluator<Arg3Type, Device>::PacketAccess && internal::functor_traits<TernaryOp>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<Arg1Type, Device>::PreferBlockAccess ||
-                        TensorEvaluator<Arg2Type, Device>::PreferBlockAccess ||
-                        TensorEvaluator<Arg3Type, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
-      : m_functor(op.functor()),
-        m_arg1Impl(op.arg1Expression(), device),
-        m_arg2Impl(op.arg2Expression(), device),
-        m_arg3Impl(op.arg3Expression(), device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<Arg1Type, Device>::Layout) ==
-                             static_cast<int>(TensorEvaluator<Arg3Type, Device>::Layout) ||
-                         internal::traits<XprType>::NumDimensions <= 1),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    EIGEN_STATIC_ASSERT((internal::is_same<typename internal::traits<Arg1Type>::StorageKind,
-                                           typename internal::traits<Arg2Type>::StorageKind>::value),
-                        STORAGE_KIND_MUST_MATCH)
-    EIGEN_STATIC_ASSERT((internal::is_same<typename internal::traits<Arg1Type>::StorageKind,
-                                           typename internal::traits<Arg3Type>::StorageKind>::value),
-                        STORAGE_KIND_MUST_MATCH)
-    EIGEN_STATIC_ASSERT((internal::is_same<typename internal::traits<Arg1Type>::Index,
-                                           typename internal::traits<Arg2Type>::Index>::value),
-                        STORAGE_INDEX_MUST_MATCH)
-    EIGEN_STATIC_ASSERT((internal::is_same<typename internal::traits<Arg1Type>::Index,
-                                           typename internal::traits<Arg3Type>::Index>::value),
-                        STORAGE_INDEX_MUST_MATCH)
-
-    eigen_assert(dimensions_match(m_arg1Impl.dimensions(), m_arg2Impl.dimensions()) &&
-                 dimensions_match(m_arg1Impl.dimensions(), m_arg3Impl.dimensions()));
-  }
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename TensorEvaluator<Arg1Type, Device>::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
-    // TODO: use arg2 or arg3 dimensions if they are known at compile time.
-    return m_arg1Impl.dimensions();
-  }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_arg1Impl.evalSubExprsIfNeeded(NULL);
-    m_arg2Impl.evalSubExprsIfNeeded(NULL);
-    m_arg3Impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_arg1Impl.cleanup();
-    m_arg2Impl.cleanup();
-    m_arg3Impl.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
-    return m_functor(m_arg1Impl.coeff(index), m_arg2Impl.coeff(index), m_arg3Impl.coeff(index));
-  }
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return m_functor.packetOp(m_arg1Impl.template packet<LoadMode>(index), m_arg2Impl.template packet<LoadMode>(index),
-                              m_arg3Impl.template packet<LoadMode>(index));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double functor_cost = internal::functor_traits<TernaryOp>::Cost;
-    return m_arg1Impl.costPerCoeff(vectorized) + m_arg2Impl.costPerCoeff(vectorized) +
-           m_arg3Impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, functor_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- private:
-  const TernaryOp m_functor;
-  TensorEvaluator<Arg1Type, Device> m_arg1Impl;
-  TensorEvaluator<Arg2Type, Device> m_arg2Impl;
-  TensorEvaluator<Arg3Type, Device> m_arg3Impl;
-};
-
-// -------------------- SelectOp --------------------
-
-template <typename IfArgType, typename ThenArgType, typename ElseArgType, typename Device>
-struct TensorEvaluator<const TensorSelectOp<IfArgType, ThenArgType, ElseArgType>, Device> {
-  typedef TensorSelectOp<IfArgType, ThenArgType, ElseArgType> XprType;
-  typedef typename XprType::Scalar Scalar;
-
-  using TernarySelectOp = internal::scalar_boolean_select_op<typename internal::traits<ThenArgType>::Scalar,
-                                                             typename internal::traits<ElseArgType>::Scalar,
-                                                             typename internal::traits<IfArgType>::Scalar>;
-  static constexpr bool TernaryPacketAccess =
-      TensorEvaluator<ThenArgType, Device>::PacketAccess && TensorEvaluator<ElseArgType, Device>::PacketAccess &&
-      TensorEvaluator<IfArgType, Device>::PacketAccess && internal::functor_traits<TernarySelectOp>::PacketAccess;
-
-  static constexpr int Layout = TensorEvaluator<IfArgType, Device>::Layout;
-  enum {
-    IsAligned = TensorEvaluator<ThenArgType, Device>::IsAligned & TensorEvaluator<ElseArgType, Device>::IsAligned,
-    PacketAccess =
-        (TensorEvaluator<ThenArgType, Device>::PacketAccess && TensorEvaluator<ElseArgType, Device>::PacketAccess) ||
-        TernaryPacketAccess,
-    BlockAccess = TensorEvaluator<IfArgType, Device>::BlockAccess &&
-                  TensorEvaluator<ThenArgType, Device>::BlockAccess &&
-                  TensorEvaluator<ElseArgType, Device>::BlockAccess,
-    PreferBlockAccess = TensorEvaluator<IfArgType, Device>::PreferBlockAccess ||
-                        TensorEvaluator<ThenArgType, Device>::PreferBlockAccess ||
-                        TensorEvaluator<ElseArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  EIGEN_DEVICE_FUNC TensorEvaluator(const XprType& op, const Device& device)
-      : m_condImpl(op.ifExpression(), device),
-        m_thenImpl(op.thenExpression(), device),
-        m_elseImpl(op.elseExpression(), device) {
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<IfArgType, Device>::Layout) ==
-                         static_cast<int>(TensorEvaluator<ThenArgType, Device>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<IfArgType, Device>::Layout) ==
-                         static_cast<int>(TensorEvaluator<ElseArgType, Device>::Layout)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-    eigen_assert(dimensions_match(m_condImpl.dimensions(), m_thenImpl.dimensions()));
-    eigen_assert(dimensions_match(m_thenImpl.dimensions(), m_elseImpl.dimensions()));
-  }
-
-  typedef typename XprType::Index Index;
-  typedef typename internal::traits<XprType>::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename TensorEvaluator<IfArgType, Device>::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int NumDims = internal::array_size<Dimensions>::value;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const IfArgType, Device>::TensorBlock IfArgTensorBlock;
-  typedef typename TensorEvaluator<const ThenArgType, Device>::TensorBlock ThenArgTensorBlock;
-  typedef typename TensorEvaluator<const ElseArgType, Device>::TensorBlock ElseArgTensorBlock;
-
-  struct TensorSelectOpBlockFactory {
-    template <typename IfArgXprType, typename ThenArgXprType, typename ElseArgXprType>
-    struct XprType {
-      typedef TensorSelectOp<const IfArgXprType, const ThenArgXprType, const ElseArgXprType> type;
-    };
-
-    template <typename IfArgXprType, typename ThenArgXprType, typename ElseArgXprType>
-    typename XprType<IfArgXprType, ThenArgXprType, ElseArgXprType>::type expr(const IfArgXprType& if_expr,
-                                                                              const ThenArgXprType& then_expr,
-                                                                              const ElseArgXprType& else_expr) const {
-      return typename XprType<IfArgXprType, ThenArgXprType, ElseArgXprType>::type(if_expr, then_expr, else_expr);
-    }
-  };
-
-  typedef internal::TensorTernaryExprBlock<TensorSelectOpBlockFactory, IfArgTensorBlock, ThenArgTensorBlock,
-                                           ElseArgTensorBlock>
-      TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const {
-    // TODO: use then or else impl instead if they happen to be known at compile time.
-    return m_condImpl.dimensions();
-  }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_condImpl.evalSubExprsIfNeeded(NULL);
-    m_thenImpl.evalSubExprsIfNeeded(NULL);
-    m_elseImpl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_condImpl.evalSubExprsIfNeeded(nullptr, [this, done](bool) {
-      m_thenImpl.evalSubExprsIfNeeded(
-          nullptr, [this, done](bool) { m_elseImpl.evalSubExprsIfNeeded(nullptr, [done](bool) { done(true); }); });
-    });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_condImpl.cleanup();
-    m_thenImpl.cleanup();
-    m_elseImpl.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index index) const {
-    return m_condImpl.coeff(index) ? m_thenImpl.coeff(index) : m_elseImpl.coeff(index);
-  }
-
-  template <int LoadMode, bool UseTernary = TernaryPacketAccess, std::enable_if_t<!UseTernary, bool> = true>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
-    EIGEN_ALIGN_TO_BOUNDARY(sizeof(PacketReturnType)) std::remove_const_t<Scalar> arr[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (Index i = 0; i < PacketSize; ++i) {
-      arr[i] = m_condImpl.coeff(index + i) ? Scalar(-1) : Scalar(0);
-    }
-    return TernarySelectOp().template packetOp<PacketReturnType>(m_thenImpl.template packet<LoadMode>(index),
-                                                                 m_elseImpl.template packet<LoadMode>(index),
-                                                                 internal::pload<PacketReturnType>(arr));
-  }
-
-  template <int LoadMode, bool UseTernary = TernaryPacketAccess, std::enable_if_t<UseTernary, bool> = true>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
-    return TernarySelectOp().template packetOp<PacketReturnType>(m_thenImpl.template packet<LoadMode>(index),
-                                                                 m_elseImpl.template packet<LoadMode>(index),
-                                                                 m_condImpl.template packet<LoadMode>(index));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return m_condImpl.costPerCoeff(vectorized) +
-           m_thenImpl.costPerCoeff(vectorized).cwiseMax(m_elseImpl.costPerCoeff(vectorized));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    auto then_req = m_thenImpl.getResourceRequirements();
-    auto else_req = m_elseImpl.getResourceRequirements();
-
-    auto merged_req = internal::TensorBlockResourceRequirements::merge(then_req, else_req);
-    merged_req.cost_per_coeff = then_req.cost_per_coeff.cwiseMax(else_req.cost_per_coeff);
-
-    return internal::TensorBlockResourceRequirements::merge(m_condImpl.getResourceRequirements(), merged_req);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    // It's unsafe to pass destination buffer to underlying expressions, because
-    // output might be aliased with one of the inputs.
-    desc.DropDestinationBuffer();
-
-    return TensorBlock(m_condImpl.block(desc, scratch), m_thenImpl.block(desc, scratch),
-                       m_elseImpl.block(desc, scratch), TensorSelectOpBlockFactory());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return NULL; }
-
-#ifdef EIGEN_USE_SYCL
-  // binding placeholder accessors to a command group handler for SYCL
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(cl::sycl::handler& cgh) const {
-    m_condImpl.bind(cgh);
-    m_thenImpl.bind(cgh);
-    m_elseImpl.bind(cgh);
-  }
-#endif
- private:
-  TensorEvaluator<IfArgType, Device> m_condImpl;
-  TensorEvaluator<ThenArgType, Device> m_thenImpl;
-  TensorEvaluator<ElseArgType, Device> m_elseImpl;
-};
-
-}  // end namespace Eigen
-
-#if defined(EIGEN_USE_SYCL) && defined(SYCL_COMPILER_IS_DPCPP)
-template <typename Derived, typename Device>
-struct cl::sycl::is_device_copyable<
-    Eigen::TensorEvaluator<Derived, Device>,
-    std::enable_if_t<!std::is_trivially_copyable<Eigen::TensorEvaluator<Derived, Device>>::value>> : std::true_type {};
-#endif
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_EVALUATOR_H
diff --git a/unsupported/Eigen/src/Tensor/TensorExecutor.h b/unsupported/Eigen/src/Tensor/TensorExecutor.h
deleted file mode 100644
index 2ae0b27..0000000
--- a/unsupported/Eigen/src/Tensor/TensorExecutor.h
+++ /dev/null
@@ -1,670 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_EXECUTOR_H
-#define EIGEN_CXX11_TENSOR_TENSOR_EXECUTOR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/**
- * Evaluating TensorBroadcastingOp via coefficient of packet path is extremely
- * expensive. If expression has at least one broadcast op in it, and it supports
- * block based evaluation, we always prefer it, even for the small tensors. For
- * all other tileable ops, block evaluation overhead for small tensors (fits
- * into L1) is too large, and we fallback on vectorized evaluation.
- */
-
-// TODO(ezhulenev): Add specializations for all other types of Tensor ops.
-
-template <typename Expression>
-struct ExpressionHasTensorBroadcastingOp {
-  enum { value = false };
-};
-
-template <typename LhsXprType, typename RhsXprType>
-struct ExpressionHasTensorBroadcastingOp<const TensorAssignOp<LhsXprType, RhsXprType> > {
-  enum { value = ExpressionHasTensorBroadcastingOp<RhsXprType>::value };
-};
-
-template <typename UnaryOp, typename XprType>
-struct ExpressionHasTensorBroadcastingOp<const TensorCwiseUnaryOp<UnaryOp, XprType> > {
-  enum { value = ExpressionHasTensorBroadcastingOp<XprType>::value };
-};
-
-template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
-struct ExpressionHasTensorBroadcastingOp<const TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType> > {
-  enum {
-    value = ExpressionHasTensorBroadcastingOp<LhsXprType>::value || ExpressionHasTensorBroadcastingOp<RhsXprType>::value
-  };
-};
-
-template <typename Broadcast, typename XprType>
-struct ExpressionHasTensorBroadcastingOp<const TensorBroadcastingOp<Broadcast, XprType> > {
-  enum { value = true };
-};
-
-// -------------------------------------------------------------------------- //
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief The tensor executor class.
- *
- * This class is responsible for launching the evaluation of the expression on
- * the specified computing device.
- *
- * Default strategy: the expression is evaluated sequentially with a single cpu
- * thread, without vectorization and block evaluation.
- *
- * @tparam Vectorizable can use packet math (SSE/AVX/etc... registers and
- *                      instructions)
- * @tparam Tiling       can use block based tensor evaluation
- *                      (see TensorBlock.h)
- */
-template <typename Expression, typename Device, bool Vectorizable, TiledEvaluation Tiling>
-class TensorExecutor {
- public:
-  typedef typename Expression::Index StorageIndex;
-
-  // Including `unsupported/Eigen/Tensor` in different translation units
-  // with/without `EIGEN_USE_THREADS` or `EIGEN_USE_GPU` is a potential ODR
-  // violation. If this template is instantiated with a non-default device, it
-  // means that this header file was included without defining
-  // `EIGEN_USE_THREADS`, `EIGEN_USE_GPU` or `EIGEN_USE_SYCL`.
-  static_assert(std::is_same<Device, DefaultDevice>::value,
-                "Default executor instantiated with non-default device. "
-                "You must #define EIGEN_USE_THREADS, EIGEN_USE_GPU or "
-                "EIGEN_USE_SYCL before including Eigen headers.");
-
-  static EIGEN_STRONG_INLINE void run(const Expression& expr, const Device& device = DefaultDevice()) {
-    TensorEvaluator<Expression, Device> evaluator(expr, device);
-    const bool needs_assign = evaluator.evalSubExprsIfNeeded(NULL);
-    if (needs_assign) {
-      const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
-      for (StorageIndex i = 0; i < size; ++i) {
-        evaluator.evalScalar(i);
-      }
-    }
-    evaluator.cleanup();
-  }
-};
-
-/**
- * Default async execution strategy is not implemented. Currently it's only
- * available for ThreadPoolDevice (see definition below).
- */
-template <typename Expression, typename Device, typename DoneCallback, bool Vectorizable, TiledEvaluation Tiling>
-class TensorAsyncExecutor {};
-
-/**
- * Process all the data with a single cpu thread, using vectorized instructions.
- */
-template <typename Expression>
-class TensorExecutor<Expression, DefaultDevice, /*Vectorizable=*/true,
-                     /*Tiling=*/TiledEvaluation::Off> {
- public:
-  typedef typename Expression::Index StorageIndex;
-
-  static EIGEN_STRONG_INLINE void run(const Expression& expr, const DefaultDevice& device = DefaultDevice()) {
-    TensorEvaluator<Expression, DefaultDevice> evaluator(expr, device);
-    const bool needs_assign = evaluator.evalSubExprsIfNeeded(NULL);
-    if (needs_assign) {
-      const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
-      const int PacketSize =
-          unpacket_traits<typename TensorEvaluator<Expression, DefaultDevice>::PacketReturnType>::size;
-
-      // Give compiler a strong possibility to unroll the loop. But don't insist
-      // on unrolling, because if the function is expensive compiler should not
-      // unroll the loop at the expense of inlining.
-      const StorageIndex UnrolledSize = (size / (4 * PacketSize)) * 4 * PacketSize;
-      for (StorageIndex i = 0; i < UnrolledSize; i += 4 * PacketSize) {
-        for (StorageIndex j = 0; j < 4; j++) {
-          evaluator.evalPacket(i + j * PacketSize);
-        }
-      }
-      const StorageIndex VectorizedSize = (size / PacketSize) * PacketSize;
-      for (StorageIndex i = UnrolledSize; i < VectorizedSize; i += PacketSize) {
-        evaluator.evalPacket(i);
-      }
-      for (StorageIndex i = VectorizedSize; i < size; ++i) {
-        evaluator.evalScalar(i);
-      }
-    }
-    evaluator.cleanup();
-  }
-};
-
-/**
- * Process all the data with a single cpu thread, using blocks of data. By
- * sizing a block to fit L1 cache we get better cache performance.
- */
-template <typename Expression, bool Vectorizable>
-class TensorExecutor<Expression, DefaultDevice, Vectorizable,
-                     /*Tiling=*/TiledEvaluation::On> {
- public:
-  typedef typename traits<Expression>::Scalar Scalar;
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  typedef TensorEvaluator<Expression, DefaultDevice> Evaluator;
-  typedef typename traits<Expression>::Index StorageIndex;
-
-  static constexpr int NumDims = traits<Expression>::NumDimensions;
-
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(const Expression& expr,
-                                                        const DefaultDevice& device = DefaultDevice()) {
-    typedef TensorBlockMapper<NumDims, Evaluator::Layout, StorageIndex> TensorBlockMapper;
-
-    typedef internal::TensorBlockDescriptor<NumDims, StorageIndex> TensorBlockDesc;
-    typedef internal::TensorBlockScratchAllocator<DefaultDevice> TensorBlockScratch;
-
-    Evaluator evaluator(expr, device);
-
-    // TODO(ezhulenev): Do not use tiling for small tensors?
-    const bool needs_assign = evaluator.evalSubExprsIfNeeded(NULL);
-
-    if (needs_assign) {
-      // Query expression tree for desired block size/shape.
-      const TensorBlockResourceRequirements requirements = evaluator.getResourceRequirements();
-
-      const TensorBlockMapper block_mapper(typename TensorBlockDesc::Dimensions(evaluator.dimensions()), requirements);
-
-      // Share scratch memory allocator between all blocks.
-      TensorBlockScratch scratch(device);
-
-      const StorageIndex total_block_count = block_mapper.blockCount();
-      for (StorageIndex i = 0; i < total_block_count; ++i) {
-        TensorBlockDesc desc = block_mapper.blockDescriptor(i);
-        evaluator.evalBlock(desc, scratch);
-        scratch.reset();
-      }
-    }
-    evaluator.cleanup();
-  }
-};
-
-/**
- * Multicore strategy: the index space is partitioned and each partition is
- * executed on a single core.
- *
- * (1) TensorExecutor will submit work to the ThreadPoolDevice managed thread
- *     pool, and will block the caller thread until all tasks are finished.
- *
- * (2) TensorAsyncExecutor is a non-blocking version, that will submit work to
- *     the ThreadPoolDevice managed thread pool, and will return immediately.
- *     It will call 'done' callback after all tasks are finished.
- */
-#ifdef EIGEN_USE_THREADS
-
-template <typename TensorBlockMapper>
-struct TensorExecutorTilingContext {
-  TensorExecutorTilingContext() = default;
-  TensorExecutorTilingContext(const TensorBlockMapper& b_mapper, const TensorOpCost& b_cost, size_t b_aligned_size)
-      : block_mapper(b_mapper), cost(b_cost), aligned_blocksize(b_aligned_size) {}
-
-  TensorBlockMapper block_mapper;  // navigate through blocks
-  TensorOpCost cost;               // cost of computing a single block
-  size_t aligned_blocksize;        // block size after memory alignment
-};
-
-// Computes a block evaluation parameters, and allocates temporary memory buffer
-// for blocks. See TensorExecutor/TensorAsyncExecutor (Tiling=On) below.
-template <typename Evaluator, typename TensorBlockMapper, bool Vectorizable>
-TensorExecutorTilingContext<TensorBlockMapper> GetTensorExecutorTilingContext(const Evaluator& evaluator) {
-  // Query expression tree for desired block size/shape.
-  TensorBlockResourceRequirements requirements = evaluator.getResourceRequirements();
-
-  // Update target block size based on cost model.
-  double taskSize = TensorCostModel<ThreadPoolDevice>::taskSize(1, requirements.cost_per_coeff);
-  requirements.size = static_cast<size_t>(1.0 / taskSize);
-
-  TensorBlockMapper block_mapper(typename TensorBlockMapper::Dimensions(evaluator.dimensions()), requirements);
-
-  size_t block_size = block_mapper.blockTotalSize();
-  const size_t align = numext::maxi(EIGEN_MAX_ALIGN_BYTES, 1);
-  const size_t aligned_blocksize =
-      align * numext::div_ceil<size_t>(block_size * sizeof(typename Evaluator::Scalar), align);
-
-  return {block_mapper, requirements.cost_per_coeff * block_size, aligned_blocksize};
-}
-
-template <typename Evaluator, typename StorageIndex, bool Vectorizable>
-struct EvalRange {
-  static void run(Evaluator* evaluator_in, const StorageIndex firstIdx, const StorageIndex lastIdx) {
-    Evaluator evaluator = *evaluator_in;
-    eigen_assert(lastIdx >= firstIdx);
-    for (StorageIndex i = firstIdx; i < lastIdx; ++i) {
-      evaluator.evalScalar(i);
-    }
-  }
-
-  static StorageIndex alignBlockSize(StorageIndex size) { return size; }
-};
-
-template <typename Evaluator, typename StorageIndex>
-struct EvalRange<Evaluator, StorageIndex, /*Vectorizable*/ true> {
-  static constexpr int PacketSize = unpacket_traits<typename Evaluator::PacketReturnType>::size;
-
-  static void run(Evaluator* evaluator_in, const StorageIndex firstIdx, const StorageIndex lastIdx) {
-    Evaluator evaluator = *evaluator_in;
-    eigen_assert(lastIdx >= firstIdx);
-    StorageIndex i = firstIdx;
-    if (lastIdx - firstIdx >= PacketSize) {
-      eigen_assert(firstIdx % PacketSize == 0);
-      StorageIndex last_chunk_offset = lastIdx - 4 * PacketSize;
-      // Give compiler a strong possibility to unroll the loop. But don't insist
-      // on unrolling, because if the function is expensive compiler should not
-      // unroll the loop at the expense of inlining.
-      for (; i <= last_chunk_offset; i += 4 * PacketSize) {
-        for (StorageIndex j = 0; j < 4; j++) {
-          evaluator.evalPacket(i + j * PacketSize);
-        }
-      }
-      last_chunk_offset = lastIdx - PacketSize;
-      for (; i <= last_chunk_offset; i += PacketSize) {
-        evaluator.evalPacket(i);
-      }
-    }
-    for (; i < lastIdx; ++i) {
-      evaluator.evalScalar(i);
-    }
-  }
-
-  static StorageIndex alignBlockSize(StorageIndex size) {
-    // Align block size to packet size and account for unrolling in run above.
-    if (size >= 16 * PacketSize) {
-      return (size + 4 * PacketSize - 1) & ~(4 * PacketSize - 1);
-    }
-    // Aligning to 4 * PacketSize would increase block size by more than 25%.
-    return (size + PacketSize - 1) & ~(PacketSize - 1);
-  }
-};
-
-template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
-class TensorExecutor<Expression, ThreadPoolDevice, Vectorizable, Tiling> {
- public:
-  typedef typename Expression::Index StorageIndex;
-
-  static EIGEN_STRONG_INLINE void run(const Expression& expr, const ThreadPoolDevice& device) {
-    typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
-    typedef EvalRange<Evaluator, StorageIndex, Vectorizable> EvalRange;
-
-    Evaluator evaluator(expr, device);
-    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
-    if (needs_assign) {
-      const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
-      device.parallelFor(
-          size, evaluator.costPerCoeff(Vectorizable), EvalRange::alignBlockSize,
-          [&evaluator](StorageIndex firstIdx, StorageIndex lastIdx) { EvalRange::run(&evaluator, firstIdx, lastIdx); });
-    }
-    evaluator.cleanup();
-  }
-};
-
-template <typename Expression, bool Vectorizable>
-class TensorExecutor<Expression, ThreadPoolDevice, Vectorizable,
-                     /*Tiling=*/TiledEvaluation::On> {
- public:
-  typedef typename traits<Expression>::Index IndexType;
-  typedef typename traits<Expression>::Scalar Scalar;
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  static constexpr int NumDims = traits<Expression>::NumDimensions;
-
-  typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
-  typedef TensorBlockMapper<NumDims, Evaluator::Layout, IndexType> BlockMapper;
-  typedef TensorExecutorTilingContext<BlockMapper> TilingContext;
-
-  typedef internal::TensorBlockDescriptor<NumDims, IndexType> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<ThreadPoolDevice> TensorBlockScratch;
-
-  static EIGEN_STRONG_INLINE void run(const Expression& expr, const ThreadPoolDevice& device) {
-    Evaluator evaluator(expr, device);
-
-    const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
-    if (needs_assign) {
-      const TilingContext tiling =
-          internal::GetTensorExecutorTilingContext<Evaluator, BlockMapper, Vectorizable>(evaluator);
-
-      auto eval_block = [&device, &evaluator, &tiling](IndexType firstBlockIdx, IndexType lastBlockIdx) {
-        TensorBlockScratch scratch(device);
-
-        for (IndexType block_idx = firstBlockIdx; block_idx < lastBlockIdx; ++block_idx) {
-          TensorBlockDesc desc = tiling.block_mapper.blockDescriptor(block_idx);
-          evaluator.evalBlock(desc, scratch);
-          scratch.reset();
-        }
-      };
-
-      // Evaluate small expressions directly as a single block.
-      if (tiling.block_mapper.blockCount() == 1) {
-        TensorBlockScratch scratch(device);
-        TensorBlockDesc desc(0, tiling.block_mapper.blockDimensions());
-        evaluator.evalBlock(desc, scratch);
-      } else {
-        device.parallelFor(tiling.block_mapper.blockCount(), tiling.cost, std::move(eval_block));
-      }
-    }
-    evaluator.cleanup();
-  }
-};
-
-template <typename Expression, typename DoneCallback, bool Vectorizable, TiledEvaluation Tiling>
-class TensorAsyncExecutor<Expression, ThreadPoolDevice, DoneCallback, Vectorizable, Tiling> {
- public:
-  typedef typename Expression::Index StorageIndex;
-  typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
-
-  static EIGEN_STRONG_INLINE void runAsync(const Expression& expr, const ThreadPoolDevice& device, DoneCallback done) {
-    TensorAsyncExecutorContext* const ctx = new TensorAsyncExecutorContext(expr, device, std::move(done));
-
-    const auto on_eval_subexprs = [ctx, &device](bool need_assign) -> void {
-      if (!need_assign) {
-        delete ctx;
-        return;
-      }
-
-      typedef EvalRange<Evaluator, StorageIndex, Vectorizable> EvalRange;
-      const StorageIndex size = static_cast<StorageIndex>(array_prod(ctx->evaluator.dimensions()));
-      device.parallelForAsync(
-          size, ctx->evaluator.costPerCoeff(Vectorizable), EvalRange::alignBlockSize,
-          [ctx](StorageIndex firstIdx, StorageIndex lastIdx) { EvalRange::run(&ctx->evaluator, firstIdx, lastIdx); },
-          [ctx]() { delete ctx; });
-    };
-
-    ctx->evaluator.evalSubExprsIfNeededAsync(nullptr, on_eval_subexprs);
-  }
-
- private:
-  struct TensorAsyncExecutorContext {
-    TensorAsyncExecutorContext(const Expression& expr, const ThreadPoolDevice& thread_pool, DoneCallback done)
-        : evaluator(expr, thread_pool), on_done(std::move(done)) {}
-
-    ~TensorAsyncExecutorContext() {
-      evaluator.cleanup();
-      on_done();
-    }
-
-    Evaluator evaluator;
-
-   private:
-    DoneCallback on_done;
-  };
-};
-
-template <typename Expression, typename DoneCallback, bool Vectorizable>
-class TensorAsyncExecutor<Expression, ThreadPoolDevice, DoneCallback, Vectorizable, /*Tileable*/ TiledEvaluation::On> {
- public:
-  typedef typename traits<Expression>::Index IndexType;
-  typedef typename traits<Expression>::Scalar Scalar;
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  static constexpr int NumDims = traits<Expression>::NumDimensions;
-
-  typedef TensorEvaluator<Expression, ThreadPoolDevice> Evaluator;
-  typedef TensorBlockMapper<NumDims, Evaluator::Layout, IndexType> BlockMapper;
-  typedef TensorExecutorTilingContext<BlockMapper> TilingContext;
-
-  typedef internal::TensorBlockDescriptor<NumDims, IndexType> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<ThreadPoolDevice> TensorBlockScratch;
-
-  static EIGEN_STRONG_INLINE void runAsync(const Expression& expr, const ThreadPoolDevice& device, DoneCallback done) {
-    TensorAsyncExecutorContext* const ctx = new TensorAsyncExecutorContext(expr, device, std::move(done));
-
-    const auto on_eval_subexprs = [ctx](bool need_assign) -> void {
-      if (!need_assign) {
-        delete ctx;
-        return;
-      }
-
-      ctx->tiling = internal::GetTensorExecutorTilingContext<Evaluator, BlockMapper, Vectorizable>(ctx->evaluator);
-
-      auto eval_block = [ctx](IndexType firstBlockIdx, IndexType lastBlockIdx) {
-        TensorBlockScratch scratch(ctx->device);
-
-        for (IndexType block_idx = firstBlockIdx; block_idx < lastBlockIdx; ++block_idx) {
-          TensorBlockDesc desc = ctx->tiling.block_mapper.blockDescriptor(block_idx);
-          ctx->evaluator.evalBlock(desc, scratch);
-          scratch.reset();
-        }
-      };
-
-      // Evaluate small expressions directly as a single block.
-      if (ctx->tiling.block_mapper.blockCount() == 1) {
-        TensorBlockScratch scratch(ctx->device);
-        TensorBlockDesc desc(0, ctx->tiling.block_mapper.blockDimensions());
-        ctx->evaluator.evalBlock(desc, scratch);
-        delete ctx;
-      } else {
-        ctx->device.parallelForAsync(ctx->tiling.block_mapper.blockCount(), ctx->tiling.cost, eval_block,
-                                     [ctx]() { delete ctx; });
-      }
-    };
-
-    ctx->evaluator.evalSubExprsIfNeededAsync(nullptr, on_eval_subexprs);
-  }
-
- private:
-  struct TensorAsyncExecutorContext {
-    TensorAsyncExecutorContext(const Expression& expr, const ThreadPoolDevice& thread_pool, DoneCallback done)
-        : device(thread_pool), evaluator(expr, thread_pool), on_done(std::move(done)) {}
-
-    ~TensorAsyncExecutorContext() {
-      evaluator.cleanup();
-      on_done();
-    }
-
-    const ThreadPoolDevice& device;
-    Evaluator evaluator;
-    TilingContext tiling;
-
-   private:
-    DoneCallback on_done;
-  };
-};
-
-#endif  // EIGEN_USE_THREADS
-
-// GPU: the evaluation of the expression is offloaded to a GPU.
-#if defined(EIGEN_USE_GPU)
-
-template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
-class TensorExecutor<Expression, GpuDevice, Vectorizable, Tiling> {
- public:
-  typedef typename Expression::Index StorageIndex;
-  static void run(const Expression& expr, const GpuDevice& device);
-};
-
-#if defined(EIGEN_GPUCC)
-// Returns 1 if lhs + rhs would overflow, -1 if it would underflow, otherwise 0.
-template <typename Index>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE int sum_will_overflow(Index lhs, Index rhs) {
-  const Index highest = NumTraits<Index>::highest();
-  const Index lowest = NumTraits<Index>::lowest();
-  if (lhs > 0 && rhs > 0) {
-    return lhs > highest - rhs ? 1 : 0;
-  } else if (lhs < 0 && rhs < 0) {
-    return lhs < lowest - rhs ? -1 : 0;
-  } else {
-    return 0;
-  }
-}
-
-// Returns lhs + rhs, saturating to the highest/lowest representable value on
-// overflow/underflow respectively.
-template <typename Index>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index saturate_add(Index lhs, Index rhs) {
-  const Index highest = NumTraits<Index>::highest();
-  const Index lowest = NumTraits<Index>::lowest();
-  int overflow = sum_will_overflow(lhs, rhs);
-  return overflow == 1 ? highest : overflow == -1 ? lowest : lhs + rhs;
-}
-
-// A functor that adds step_size to a given index, saturating to avoid
-// overflow/underflow. If overflow/underflow is not possible, regular addition
-// is used (for efficiency).
-template <typename Index>
-struct SafeStep {
-  // lastIdx is one past the end of the possible indexes.
-  // step_size is the value that will be added to the given index when the
-  // functor is called.
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE SafeStep(Index lastIdx, Index step_size)
-      : can_overflow_(sum_will_overflow(lastIdx, step_size)), step_size_(step_size) {}
-
-  // Adds step_size to index, saturating on overflow (if overflow is possible).
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index operator()(Index index) const {
-    return can_overflow_ ? saturate_add(index, step_size_) : index + step_size_;
-  }
-
- private:
-  const bool can_overflow_;
-  const Index step_size_;
-};
-
-template <typename Evaluator, typename StorageIndex, bool Vectorizable>
-struct EigenMetaKernelEval {
-  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void run(Evaluator& eval, StorageIndex firstIdx, StorageIndex lastIdx,
-                                                        StorageIndex step_size) {
-    SafeStep<StorageIndex> safe_step(lastIdx, step_size);
-    for (StorageIndex i = firstIdx; i < lastIdx; i = safe_step(i)) {
-      eval.evalScalar(i);
-    }
-  }
-};
-
-template <typename Evaluator, typename StorageIndex>
-struct EigenMetaKernelEval<Evaluator, StorageIndex, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void run(Evaluator& eval, StorageIndex firstIdx, StorageIndex lastIdx,
-                                                        StorageIndex step_size) {
-    const StorageIndex PacketSize = unpacket_traits<typename Evaluator::PacketReturnType>::size;
-    const StorageIndex vectorized_size = (lastIdx / PacketSize) * PacketSize;
-    const StorageIndex vectorized_step_size = step_size * PacketSize;
-
-    SafeStep<StorageIndex> safe_vectorized_step(vectorized_size, vectorized_step_size);
-    // Use the vector path
-    for (StorageIndex i = firstIdx * PacketSize; i < vectorized_size; i = safe_vectorized_step(i)) {
-      eval.evalPacket(i);
-    }
-    SafeStep<StorageIndex> safe_step(lastIdx, step_size);
-    for (StorageIndex i = saturate_add(vectorized_size, firstIdx); i < lastIdx; i = safe_step(i)) {
-      eval.evalScalar(i);
-    }
-  }
-};
-
-template <typename Evaluator, typename StorageIndex>
-__global__ void __launch_bounds__(1024) EigenMetaKernel(Evaluator eval, StorageIndex size) {
-  const StorageIndex first_index = blockIdx.x * blockDim.x + threadIdx.x;
-  const StorageIndex step_size = blockDim.x * gridDim.x;
-
-  const bool vectorizable = Evaluator::PacketAccess & Evaluator::IsAligned;
-  EigenMetaKernelEval<Evaluator, StorageIndex, vectorizable>::run(eval, first_index, size, step_size);
-}
-
-/*static*/
-template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
-EIGEN_STRONG_INLINE void TensorExecutor<Expression, GpuDevice, Vectorizable, Tiling>::run(const Expression& expr,
-                                                                                          const GpuDevice& device) {
-  TensorEvaluator<Expression, GpuDevice> evaluator(expr, device);
-  const bool needs_assign = evaluator.evalSubExprsIfNeeded(nullptr);
-  if (needs_assign) {
-    const int block_size = device.maxGpuThreadsPerBlock();
-    const int max_blocks = static_cast<int>(
-        numext::mini<int64_t>(device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor(),
-                              NumTraits<StorageIndex>::highest()) /
-        block_size);
-    const StorageIndex size = static_cast<StorageIndex>(array_prod(evaluator.dimensions()));
-    // Create at least one block to ensure we don't crash with tensors of size 0.
-    const int num_blocks = numext::maxi<int>(
-        numext::mini<int>(max_blocks, static_cast<int>(numext::div_ceil<StorageIndex>(size, block_size))), 1);
-
-    LAUNCH_GPU_KERNEL((EigenMetaKernel<TensorEvaluator<Expression, GpuDevice>, StorageIndex>), num_blocks, block_size,
-                      0, device, evaluator, size);
-  }
-  evaluator.cleanup();
-}
-
-#endif  // EIGEN_GPUCC
-#endif  // EIGEN_USE_GPU
-
-// SYCL Executor policy
-#ifdef EIGEN_USE_SYCL
-
-template <typename Evaluator>
-struct ExecExprFunctorKernel {
-  typedef typename Evaluator::Index Index;
-  Evaluator evaluator;
-  const Index range;
-  template <typename Scratch>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE ExecExprFunctorKernel(const Scratch, Evaluator evaluator_, const Index range_)
-      : evaluator(evaluator_), range(range_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void operator()(cl::sycl::nd_item<1> itemID) const { compute(itemID); }
-  template <bool is_vec = Evaluator::PacketAccess>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<!is_vec> compute(const cl::sycl::nd_item<1>& itemID) const {
-    Index gId = static_cast<Index>(itemID.get_global_linear_id());
-    Index total_threads = itemID.get_global_range(0);
-
-    for (Index i = gId; i < range; i += total_threads) {
-      evaluator.evalScalar(i);
-    }
-  }
-  template <bool is_vec = Evaluator::PacketAccess>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<is_vec> compute(const cl::sycl::nd_item<1>& itemID) const {
-    const Index vectorizedRange = (range / Evaluator::PacketSize) * Evaluator::PacketSize;
-    Index gId = static_cast<Index>(itemID.get_global_linear_id());
-    const Index step = Evaluator::PacketSize * itemID.get_global_range(0);
-    const Index start = Evaluator::PacketSize * gId;
-    for (Index i = start; i < vectorizedRange; i += step) {
-      evaluator.evalPacket(i);
-    }
-    gId += vectorizedRange;
-    for (Index i = gId; i < range; i += itemID.get_global_range(0)) {
-      evaluator.evalScalar(i);
-    }
-  }
-};
-
-template <typename Expression, bool Vectorizable, TiledEvaluation Tiling>
-class TensorExecutor<Expression, Eigen::SyclDevice, Vectorizable, Tiling> {
- public:
-  typedef typename Expression::Index Index;
-  static EIGEN_STRONG_INLINE void run(const Expression& expr, const Eigen::SyclDevice& dev) {
-    typedef Eigen::TensorEvaluator<Expression, Eigen::SyclDevice> Evaluator;
-    Evaluator evaluator(expr, dev);
-    const bool needs_assign = evaluator.evalSubExprsIfNeeded(NULL);
-    if (needs_assign) {
-      Index range, GRange, tileSize;
-      Index total_size = ::Eigen::internal::array_prod(evaluator.dimensions());
-      total_size = (total_size == 0) ? 1 : total_size;
-      const int PacketSize = Eigen::PacketType<typename Evaluator::CoeffReturnType, Eigen::SyclDevice>::size;
-      Index vectorizable_threads = static_cast<Index>(total_size / PacketSize);
-      dev.parallel_for_setup(vectorizable_threads, tileSize, range, GRange);
-      range = total_size;
-
-      dev.template nullary_kernel_launcher<typename Evaluator::CoeffReturnType, ExecExprFunctorKernel<Evaluator> >(
-             evaluator, cl::sycl::nd_range<1>(cl::sycl::range<1>(GRange), cl::sycl::range<1>(tileSize)), Index(1),
-             range)
-          .wait();
-    }
-    evaluator.cleanup();
-  }
-};
-
-#endif
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_EXECUTOR_H
diff --git a/unsupported/Eigen/src/Tensor/TensorExpr.h b/unsupported/Eigen/src/Tensor/TensorExpr.h
deleted file mode 100644
index 108bc92..0000000
--- a/unsupported/Eigen/src/Tensor/TensorExpr.h
+++ /dev/null
@@ -1,338 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_EXPR_H
-#define EIGEN_CXX11_TENSOR_TENSOR_EXPR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename NullaryOp, typename XprType>
-struct traits<TensorCwiseNullaryOp<NullaryOp, XprType> > : traits<XprType> {
-  typedef traits<XprType> XprTraits;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::Nested XprTypeNested;
-  typedef std::remove_reference_t<XprTypeNested> XprTypeNested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-  enum { Flags = 0 };
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor nullary expression.
- *
- * The TensorCwiseNullaryOp class applies a nullary operator to an expression.
- * This is typically used to generate constants.
- */
-template <typename NullaryOp, typename XprType>
-class TensorCwiseNullaryOp : public TensorBase<TensorCwiseNullaryOp<NullaryOp, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorCwiseNullaryOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef TensorCwiseNullaryOp<NullaryOp, XprType> Nested;
-  typedef typename Eigen::internal::traits<TensorCwiseNullaryOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorCwiseNullaryOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseNullaryOp(const XprType& xpr, const NullaryOp& func = NullaryOp())
-      : m_xpr(xpr), m_functor(func) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& nestedExpression() const { return m_xpr; }
-
-  EIGEN_DEVICE_FUNC const NullaryOp& functor() const { return m_functor; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const NullaryOp m_functor;
-};
-
-namespace internal {
-template <typename UnaryOp, typename XprType>
-struct traits<TensorCwiseUnaryOp<UnaryOp, XprType> > : traits<XprType> {
-  // TODO(phli): Add InputScalar, InputPacket.  Check references to
-  // current Scalar/Packet to see if the intent is Input or Output.
-  typedef typename result_of<UnaryOp(typename XprType::Scalar)>::type Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprType::Nested XprTypeNested;
-  typedef std::remove_reference_t<XprTypeNested> XprTypeNested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename TypeConversion<Scalar, typename XprTraits::PointerType>::type PointerType;
-};
-
-template <typename UnaryOp, typename XprType>
-struct eval<TensorCwiseUnaryOp<UnaryOp, XprType>, Eigen::Dense> {
-  typedef const TensorCwiseUnaryOp<UnaryOp, XprType>& type;
-};
-
-template <typename UnaryOp, typename XprType>
-struct nested<TensorCwiseUnaryOp<UnaryOp, XprType>, 1, typename eval<TensorCwiseUnaryOp<UnaryOp, XprType> >::type> {
-  typedef TensorCwiseUnaryOp<UnaryOp, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor unary expression.
- *
- * The TensorCwiseUnaryOp class represents an expression where a unary operator
- * (e.g. cwiseSqrt) is applied to an expression.
- */
-template <typename UnaryOp, typename XprType>
-class TensorCwiseUnaryOp : public TensorBase<TensorCwiseUnaryOp<UnaryOp, XprType>, ReadOnlyAccessors> {
- public:
-  // TODO(phli): Add InputScalar, InputPacket.  Check references to
-  // current Scalar/Packet to see if the intent is Input or Output.
-  typedef typename Eigen::internal::traits<TensorCwiseUnaryOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef Scalar CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorCwiseUnaryOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorCwiseUnaryOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorCwiseUnaryOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
-      : m_xpr(xpr), m_functor(func) {}
-
-  EIGEN_DEVICE_FUNC const UnaryOp& functor() const { return m_functor; }
-
-  /** \returns the nested expression */
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& nestedExpression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const UnaryOp m_functor;
-};
-
-namespace internal {
-template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
-struct traits<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType> > {
-  // Type promotion to handle the case where the types of the lhs and the rhs
-  // are different.
-  // TODO(phli): Add Lhs/RhsScalar, Lhs/RhsPacket.  Check references to
-  // current Scalar/Packet to see if the intent is Inputs or Output.
-  typedef typename result_of<BinaryOp(typename LhsXprType::Scalar, typename RhsXprType::Scalar)>::type Scalar;
-  typedef traits<LhsXprType> XprTraits;
-  typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
-                                        typename traits<RhsXprType>::StorageKind>::ret StorageKind;
-  typedef
-      typename promote_index_type<typename traits<LhsXprType>::Index, typename traits<RhsXprType>::Index>::type Index;
-  typedef typename LhsXprType::Nested LhsNested;
-  typedef typename RhsXprType::Nested RhsNested;
-  typedef std::remove_reference_t<LhsNested> LhsNested_;
-  typedef std::remove_reference_t<RhsNested> RhsNested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename TypeConversion<Scalar,
-                                  std::conditional_t<Pointer_type_promotion<typename LhsXprType::Scalar, Scalar>::val,
-                                                     typename traits<LhsXprType>::PointerType,
-                                                     typename traits<RhsXprType>::PointerType> >::type PointerType;
-  enum { Flags = 0 };
-};
-
-template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
-struct eval<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>, Eigen::Dense> {
-  typedef const TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>& type;
-};
-
-template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
-struct nested<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>, 1,
-              typename eval<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType> >::type> {
-  typedef TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor binary expression.
- *
- * The TensorCwiseBinaryOp class represents an expression where a binary
- * operator (e.g. addition) is applied to a lhs and a rhs expression.
- */
-template <typename BinaryOp, typename LhsXprType, typename RhsXprType>
-class TensorCwiseBinaryOp
-    : public TensorBase<TensorCwiseBinaryOp<BinaryOp, LhsXprType, RhsXprType>, ReadOnlyAccessors> {
- public:
-  // TODO(phli): Add Lhs/RhsScalar, Lhs/RhsPacket.  Check references to
-  // current Scalar/Packet to see if the intent is Inputs or Output.
-  typedef typename Eigen::internal::traits<TensorCwiseBinaryOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef Scalar CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorCwiseBinaryOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorCwiseBinaryOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorCwiseBinaryOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseBinaryOp(const LhsXprType& lhs, const RhsXprType& rhs,
-                                                            const BinaryOp& func = BinaryOp())
-      : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_functor(func) {}
-
-  EIGEN_DEVICE_FUNC const BinaryOp& functor() const { return m_functor; }
-
-  /** \returns the nested expressions */
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename LhsXprType::Nested>& lhsExpression() const {
-    return m_lhs_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename RhsXprType::Nested>& rhsExpression() const {
-    return m_rhs_xpr;
-  }
-
- protected:
-  typename LhsXprType::Nested m_lhs_xpr;
-  typename RhsXprType::Nested m_rhs_xpr;
-  const BinaryOp m_functor;
-};
-
-namespace internal {
-template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
-struct traits<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType> > {
-  // Type promotion to handle the case where the types of the args are different.
-  typedef typename result_of<TernaryOp(typename Arg1XprType::Scalar, typename Arg2XprType::Scalar,
-                                       typename Arg3XprType::Scalar)>::type Scalar;
-  typedef traits<Arg1XprType> XprTraits;
-  typedef typename traits<Arg1XprType>::StorageKind StorageKind;
-  typedef typename traits<Arg1XprType>::Index Index;
-  typedef typename Arg1XprType::Nested Arg1Nested;
-  typedef typename Arg2XprType::Nested Arg2Nested;
-  typedef typename Arg3XprType::Nested Arg3Nested;
-  typedef std::remove_reference_t<Arg1Nested> Arg1Nested_;
-  typedef std::remove_reference_t<Arg2Nested> Arg2Nested_;
-  typedef std::remove_reference_t<Arg3Nested> Arg3Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename TypeConversion<Scalar,
-                                  std::conditional_t<Pointer_type_promotion<typename Arg2XprType::Scalar, Scalar>::val,
-                                                     typename traits<Arg2XprType>::PointerType,
-                                                     typename traits<Arg3XprType>::PointerType> >::type PointerType;
-  enum { Flags = 0 };
-};
-
-template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
-struct eval<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>, Eigen::Dense> {
-  typedef const TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>& type;
-};
-
-template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
-struct nested<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>, 1,
-              typename eval<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType> >::type> {
-  typedef TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType> type;
-};
-
-}  // end namespace internal
-
-template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
-class TensorCwiseTernaryOp
-    : public TensorBase<TensorCwiseTernaryOp<TernaryOp, Arg1XprType, Arg2XprType, Arg3XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorCwiseTernaryOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef Scalar CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorCwiseTernaryOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorCwiseTernaryOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorCwiseTernaryOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorCwiseTernaryOp(const Arg1XprType& arg1, const Arg2XprType& arg2,
-                                                             const Arg3XprType& arg3,
-                                                             const TernaryOp& func = TernaryOp())
-      : m_arg1_xpr(arg1), m_arg2_xpr(arg2), m_arg3_xpr(arg3), m_functor(func) {}
-
-  EIGEN_DEVICE_FUNC const TernaryOp& functor() const { return m_functor; }
-
-  /** \returns the nested expressions */
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename Arg1XprType::Nested>& arg1Expression() const {
-    return m_arg1_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename Arg2XprType::Nested>& arg2Expression() const {
-    return m_arg2_xpr;
-  }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename Arg3XprType::Nested>& arg3Expression() const {
-    return m_arg3_xpr;
-  }
-
- protected:
-  typename Arg1XprType::Nested m_arg1_xpr;
-  typename Arg2XprType::Nested m_arg2_xpr;
-  typename Arg3XprType::Nested m_arg3_xpr;
-  const TernaryOp m_functor;
-};
-
-namespace internal {
-template <typename IfXprType, typename ThenXprType, typename ElseXprType>
-struct traits<TensorSelectOp<IfXprType, ThenXprType, ElseXprType> > : traits<ThenXprType> {
-  typedef typename traits<ThenXprType>::Scalar Scalar;
-  typedef traits<ThenXprType> XprTraits;
-  typedef typename promote_storage_type<typename traits<ThenXprType>::StorageKind,
-                                        typename traits<ElseXprType>::StorageKind>::ret StorageKind;
-  typedef
-      typename promote_index_type<typename traits<ElseXprType>::Index, typename traits<ThenXprType>::Index>::type Index;
-  typedef typename IfXprType::Nested IfNested;
-  typedef typename ThenXprType::Nested ThenNested;
-  typedef typename ElseXprType::Nested ElseNested;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef std::conditional_t<Pointer_type_promotion<typename ThenXprType::Scalar, Scalar>::val,
-                             typename traits<ThenXprType>::PointerType, typename traits<ElseXprType>::PointerType>
-      PointerType;
-};
-
-template <typename IfXprType, typename ThenXprType, typename ElseXprType>
-struct eval<TensorSelectOp<IfXprType, ThenXprType, ElseXprType>, Eigen::Dense> {
-  typedef const TensorSelectOp<IfXprType, ThenXprType, ElseXprType>& type;
-};
-
-template <typename IfXprType, typename ThenXprType, typename ElseXprType>
-struct nested<TensorSelectOp<IfXprType, ThenXprType, ElseXprType>, 1,
-              typename eval<TensorSelectOp<IfXprType, ThenXprType, ElseXprType> >::type> {
-  typedef TensorSelectOp<IfXprType, ThenXprType, ElseXprType> type;
-};
-
-}  // end namespace internal
-
-template <typename IfXprType, typename ThenXprType, typename ElseXprType>
-class TensorSelectOp : public TensorBase<TensorSelectOp<IfXprType, ThenXprType, ElseXprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorSelectOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename internal::promote_storage_type<typename ThenXprType::CoeffReturnType,
-                                                  typename ElseXprType::CoeffReturnType>::ret CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorSelectOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorSelectOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorSelectOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC TensorSelectOp(const IfXprType& a_condition, const ThenXprType& a_then, const ElseXprType& a_else)
-      : m_condition(a_condition), m_then(a_then), m_else(a_else) {}
-
-  EIGEN_DEVICE_FUNC const IfXprType& ifExpression() const { return m_condition; }
-
-  EIGEN_DEVICE_FUNC const ThenXprType& thenExpression() const { return m_then; }
-
-  EIGEN_DEVICE_FUNC const ElseXprType& elseExpression() const { return m_else; }
-
- protected:
-  typename IfXprType::Nested m_condition;
-  typename ThenXprType::Nested m_then;
-  typename ElseXprType::Nested m_else;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_EXPR_H
diff --git a/unsupported/Eigen/src/Tensor/TensorFFT.h b/unsupported/Eigen/src/Tensor/TensorFFT.h
deleted file mode 100644
index 141b416..0000000
--- a/unsupported/Eigen/src/Tensor/TensorFFT.h
+++ /dev/null
@@ -1,650 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Jianwei Cui <thucjw@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_FFT_H
-#define EIGEN_CXX11_TENSOR_TENSOR_FFT_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <bool IsReal>
-struct MakeComplex {
-  template <typename T>
-  EIGEN_DEVICE_FUNC T operator()(const T& val) const {
-    return val;
-  }
-};
-
-template <>
-struct MakeComplex<true> {
-  template <typename T>
-  EIGEN_DEVICE_FUNC internal::make_complex_t<T> operator()(const T& val) const {
-    return internal::make_complex_t<T>(val, T(0));
-  }
-};
-
-template <int ResultType>
-struct PartOf {
-  template <typename T>
-  T operator()(const T& val) const {
-    return val;
-  }
-};
-
-template <>
-struct PartOf<RealPart> {
-  template <typename T, typename EnableIf = std::enable_if_t<NumTraits<T>::IsComplex>>
-  typename NumTraits<T>::Real operator()(const T& val) const {
-    return Eigen::numext::real(val);
-  }
-};
-
-template <>
-struct PartOf<ImagPart> {
-  template <typename T, typename EnableIf = std::enable_if_t<NumTraits<T>::IsComplex>>
-  typename NumTraits<T>::Real operator()(const T& val) const {
-    return Eigen::numext::imag(val);
-  }
-};
-
-namespace internal {
-template <typename FFT, typename XprType, int FFTResultType, int FFTDir>
-struct traits<TensorFFTOp<FFT, XprType, FFTResultType, FFTDir>> : public traits<XprType> {
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef make_complex_t<Scalar> ComplexScalar;
-  typedef typename XprTraits::Scalar InputScalar;
-  typedef std::conditional_t<FFTResultType == RealPart || FFTResultType == ImagPart, RealScalar, ComplexScalar>
-      OutputScalar;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename traits<XprType>::PointerType PointerType;
-};
-
-template <typename FFT, typename XprType, int FFTResultType, int FFTDirection>
-struct eval<TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection>, Eigen::Dense> {
-  typedef const TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection>& type;
-};
-
-template <typename FFT, typename XprType, int FFTResultType, int FFTDirection>
-struct nested<TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection>, 1,
-              typename eval<TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection>>::type> {
-  typedef TensorFFTOp<FFT, XprType, FFTResultType, FFTDirection> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor FFT class.
- *
- * TODO:
- * Vectorize the Cooley Tukey and the Bluestein algorithm
- * Add support for multithreaded evaluation
- * Improve the performance on GPU
- */
-template <typename FFT, typename XprType, int FFTResultType, int FFTDir>
-class TensorFFTOp : public TensorBase<TensorFFTOp<FFT, XprType, FFTResultType, FFTDir>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorFFTOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef std::conditional_t<FFTResultType == RealPart || FFTResultType == ImagPart, RealScalar, ComplexScalar>
-      OutputScalar;
-  typedef OutputScalar CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorFFTOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorFFTOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorFFTOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFFTOp(const XprType& expr, const FFT& fft) : m_xpr(expr), m_fft(fft) {}
-
-  EIGEN_DEVICE_FUNC const FFT& fft() const { return m_fft; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const FFT m_fft;
-};
-
-// Eval as rvalue
-template <typename FFT, typename ArgType, typename Device, int FFTResultType, int FFTDir>
-struct TensorEvaluator<const TensorFFTOp<FFT, ArgType, FFTResultType, FFTDir>, Device> {
-  typedef TensorFFTOp<FFT, ArgType, FFTResultType, FFTDir> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef internal::make_complex_t<Scalar> ComplexScalar;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
-  typedef internal::traits<XprType> XprTraits;
-  typedef typename XprTraits::Scalar InputScalar;
-  typedef std::conditional_t<FFTResultType == RealPart || FFTResultType == ImagPart, RealScalar, ComplexScalar>
-      OutputScalar;
-  typedef OutputScalar CoeffReturnType;
-  typedef typename PacketType<OutputScalar, Device>::type PacketReturnType;
-  static constexpr int PacketSize = internal::unpacket_traits<PacketReturnType>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = true,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_fft(op.fft()), m_impl(op.expression(), device), m_data(NULL), m_device(device) {
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    for (int i = 0; i < NumDims; ++i) {
-      eigen_assert(input_dims[i] > 0);
-      m_dimensions[i] = input_dims[i];
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_strides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
-      }
-    } else {
-      m_strides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
-      }
-    }
-    m_size = m_dimensions.TotalSize();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    if (data) {
-      evalToBuf(data);
-      return false;
-    } else {
-      m_data = (EvaluatorPointerType)m_device.get(
-          (CoeffReturnType*)(m_device.allocate_temp(sizeof(CoeffReturnType) * m_size)));
-      evalToBuf(m_data);
-      return true;
-    }
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    if (m_data) {
-      m_device.deallocate(m_data);
-      m_data = NULL;
-    }
-    m_impl.cleanup();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE CoeffReturnType coeff(Index index) const { return m_data[index]; }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_data + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_data; }
-
- private:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void evalToBuf(EvaluatorPointerType data) {
-    const bool write_to_out = internal::is_same<OutputScalar, ComplexScalar>::value;
-    ComplexScalar* buf =
-        write_to_out ? (ComplexScalar*)data : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * m_size);
-
-    for (Index i = 0; i < m_size; ++i) {
-      buf[i] = MakeComplex<internal::is_same<InputScalar, RealScalar>::value>()(m_impl.coeff(i));
-    }
-
-    for (size_t i = 0; i < m_fft.size(); ++i) {
-      Index dim = m_fft[i];
-      eigen_assert(dim >= 0 && dim < NumDims);
-      Index line_len = m_dimensions[dim];
-      eigen_assert(line_len >= 1);
-      ComplexScalar* line_buf = (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * line_len);
-      const bool is_power_of_two = isPowerOfTwo(line_len);
-      const Index good_composite = is_power_of_two ? 0 : findGoodComposite(line_len);
-      const Index log_len = is_power_of_two ? getLog2(line_len) : getLog2(good_composite);
-
-      ComplexScalar* a =
-          is_power_of_two ? NULL : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * good_composite);
-      ComplexScalar* b =
-          is_power_of_two ? NULL : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * good_composite);
-      ComplexScalar* pos_j_base_powered =
-          is_power_of_two ? NULL : (ComplexScalar*)m_device.allocate(sizeof(ComplexScalar) * (line_len + 1));
-      if (!is_power_of_two) {
-        // Compute twiddle factors
-        //   t_n = exp(sqrt(-1) * pi * n^2 / line_len)
-        // for n = 0, 1,..., line_len-1.
-        // For n > 2 we use the recurrence t_n = t_{n-1}^2 / t_{n-2} * t_1^2
-
-        // The recurrence is correct in exact arithmetic, but causes
-        // numerical issues for large transforms, especially in
-        // single-precision floating point. Use direct computation instead.
-        // TODO(rmlarsen): Find a way to use Eigen's vectorized sin
-        // and cosine functions here.
-        for (int j = 0; j < line_len + 1; ++j) {
-          double arg = ((EIGEN_PI * j) * j) / line_len;
-          std::complex<double> tmp(numext::cos(arg), numext::sin(arg));
-          pos_j_base_powered[j] = static_cast<ComplexScalar>(tmp);
-        }
-      }
-
-      for (Index partial_index = 0; partial_index < m_size / line_len; ++partial_index) {
-        const Index base_offset = getBaseOffsetFromIndex(partial_index, dim);
-
-        // get data into line_buf
-        const Index stride = m_strides[dim];
-        if (stride == 1) {
-          m_device.memcpy(line_buf, &buf[base_offset], line_len * sizeof(ComplexScalar));
-        } else {
-          Index offset = base_offset;
-          for (int j = 0; j < line_len; ++j, offset += stride) {
-            line_buf[j] = buf[offset];
-          }
-        }
-
-        // process the line
-        if (is_power_of_two) {
-          processDataLineCooleyTukey(line_buf, line_len, log_len);
-        } else {
-          processDataLineBluestein(line_buf, line_len, good_composite, log_len, a, b, pos_j_base_powered);
-        }
-
-        // write back
-        if (FFTDir == FFT_FORWARD && stride == 1) {
-          m_device.memcpy(&buf[base_offset], line_buf, line_len * sizeof(ComplexScalar));
-        } else {
-          Index offset = base_offset;
-          const ComplexScalar div_factor = ComplexScalar(1.0 / line_len, 0);
-          for (int j = 0; j < line_len; ++j, offset += stride) {
-            buf[offset] = (FFTDir == FFT_FORWARD) ? line_buf[j] : line_buf[j] * div_factor;
-          }
-        }
-      }
-      m_device.deallocate(line_buf);
-      if (!is_power_of_two) {
-        m_device.deallocate(a);
-        m_device.deallocate(b);
-        m_device.deallocate(pos_j_base_powered);
-      }
-    }
-
-    if (!write_to_out) {
-      for (Index i = 0; i < m_size; ++i) {
-        data[i] = PartOf<FFTResultType>()(buf[i]);
-      }
-      m_device.deallocate(buf);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static bool isPowerOfTwo(Index x) {
-    eigen_assert(x > 0);
-    return !(x & (x - 1));
-  }
-
-  // The composite number for padding, used in Bluestein's FFT algorithm
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Index findGoodComposite(Index n) {
-    Index i = 2;
-    while (i < 2 * n - 1) i *= 2;
-    return i;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Index getLog2(Index m) {
-    Index log2m = 0;
-    while (m >>= 1) log2m++;
-    return log2m;
-  }
-
-  // Call Cooley Tukey algorithm directly, data length must be power of 2
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void processDataLineCooleyTukey(ComplexScalar* line_buf, Index line_len,
-                                                                        Index log_len) {
-    eigen_assert(isPowerOfTwo(line_len));
-    scramble_FFT(line_buf, line_len);
-    compute_1D_Butterfly<FFTDir>(line_buf, line_len, log_len);
-  }
-
-  // Call Bluestein's FFT algorithm, m is a good composite number greater than (2 * n - 1), used as the padding length
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void processDataLineBluestein(ComplexScalar* line_buf, Index line_len,
-                                                                      Index good_composite, Index log_len,
-                                                                      ComplexScalar* a, ComplexScalar* b,
-                                                                      const ComplexScalar* pos_j_base_powered) {
-    Index n = line_len;
-    Index m = good_composite;
-    ComplexScalar* data = line_buf;
-
-    for (Index i = 0; i < n; ++i) {
-      if (FFTDir == FFT_FORWARD) {
-        a[i] = data[i] * numext::conj(pos_j_base_powered[i]);
-      } else {
-        a[i] = data[i] * pos_j_base_powered[i];
-      }
-    }
-    for (Index i = n; i < m; ++i) {
-      a[i] = ComplexScalar(0, 0);
-    }
-
-    for (Index i = 0; i < n; ++i) {
-      if (FFTDir == FFT_FORWARD) {
-        b[i] = pos_j_base_powered[i];
-      } else {
-        b[i] = numext::conj(pos_j_base_powered[i]);
-      }
-    }
-    for (Index i = n; i < m - n; ++i) {
-      b[i] = ComplexScalar(0, 0);
-    }
-    for (Index i = m - n; i < m; ++i) {
-      if (FFTDir == FFT_FORWARD) {
-        b[i] = pos_j_base_powered[m - i];
-      } else {
-        b[i] = numext::conj(pos_j_base_powered[m - i]);
-      }
-    }
-
-    scramble_FFT(a, m);
-    compute_1D_Butterfly<FFT_FORWARD>(a, m, log_len);
-
-    scramble_FFT(b, m);
-    compute_1D_Butterfly<FFT_FORWARD>(b, m, log_len);
-
-    for (Index i = 0; i < m; ++i) {
-      a[i] *= b[i];
-    }
-
-    scramble_FFT(a, m);
-    compute_1D_Butterfly<FFT_REVERSE>(a, m, log_len);
-
-    // Do the scaling after ifft
-    for (Index i = 0; i < m; ++i) {
-      a[i] /= m;
-    }
-
-    for (Index i = 0; i < n; ++i) {
-      if (FFTDir == FFT_FORWARD) {
-        data[i] = a[i] * numext::conj(pos_j_base_powered[i]);
-      } else {
-        data[i] = a[i] * pos_j_base_powered[i];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void scramble_FFT(ComplexScalar* data, Index n) {
-    eigen_assert(isPowerOfTwo(n));
-    Index j = 1;
-    for (Index i = 1; i < n; ++i) {
-      if (j > i) {
-        std::swap(data[j - 1], data[i - 1]);
-      }
-      Index m = n >> 1;
-      while (m >= 2 && j > m) {
-        j -= m;
-        m >>= 1;
-      }
-      j += m;
-    }
-  }
-
-  template <int Dir>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_2(ComplexScalar* data) {
-    ComplexScalar tmp = data[1];
-    data[1] = data[0] - data[1];
-    data[0] += tmp;
-  }
-
-  template <int Dir>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_4(ComplexScalar* data) {
-    ComplexScalar tmp[4];
-    tmp[0] = data[0] + data[1];
-    tmp[1] = data[0] - data[1];
-    tmp[2] = data[2] + data[3];
-    if (Dir == FFT_FORWARD) {
-      tmp[3] = ComplexScalar(0.0, -1.0) * (data[2] - data[3]);
-    } else {
-      tmp[3] = ComplexScalar(0.0, 1.0) * (data[2] - data[3]);
-    }
-    data[0] = tmp[0] + tmp[2];
-    data[1] = tmp[1] + tmp[3];
-    data[2] = tmp[0] - tmp[2];
-    data[3] = tmp[1] - tmp[3];
-  }
-
-  template <int Dir>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_8(ComplexScalar* data) {
-    ComplexScalar tmp_1[8];
-    ComplexScalar tmp_2[8];
-
-    tmp_1[0] = data[0] + data[1];
-    tmp_1[1] = data[0] - data[1];
-    tmp_1[2] = data[2] + data[3];
-    if (Dir == FFT_FORWARD) {
-      tmp_1[3] = (data[2] - data[3]) * ComplexScalar(0, -1);
-    } else {
-      tmp_1[3] = (data[2] - data[3]) * ComplexScalar(0, 1);
-    }
-    tmp_1[4] = data[4] + data[5];
-    tmp_1[5] = data[4] - data[5];
-    tmp_1[6] = data[6] + data[7];
-    if (Dir == FFT_FORWARD) {
-      tmp_1[7] = (data[6] - data[7]) * ComplexScalar(0, -1);
-    } else {
-      tmp_1[7] = (data[6] - data[7]) * ComplexScalar(0, 1);
-    }
-    tmp_2[0] = tmp_1[0] + tmp_1[2];
-    tmp_2[1] = tmp_1[1] + tmp_1[3];
-    tmp_2[2] = tmp_1[0] - tmp_1[2];
-    tmp_2[3] = tmp_1[1] - tmp_1[3];
-    tmp_2[4] = tmp_1[4] + tmp_1[6];
-// SQRT2DIV2 = sqrt(2)/2
-#define SQRT2DIV2 0.7071067811865476
-    if (Dir == FFT_FORWARD) {
-      tmp_2[5] = (tmp_1[5] + tmp_1[7]) * ComplexScalar(SQRT2DIV2, -SQRT2DIV2);
-      tmp_2[6] = (tmp_1[4] - tmp_1[6]) * ComplexScalar(0, -1);
-      tmp_2[7] = (tmp_1[5] - tmp_1[7]) * ComplexScalar(-SQRT2DIV2, -SQRT2DIV2);
-    } else {
-      tmp_2[5] = (tmp_1[5] + tmp_1[7]) * ComplexScalar(SQRT2DIV2, SQRT2DIV2);
-      tmp_2[6] = (tmp_1[4] - tmp_1[6]) * ComplexScalar(0, 1);
-      tmp_2[7] = (tmp_1[5] - tmp_1[7]) * ComplexScalar(-SQRT2DIV2, SQRT2DIV2);
-    }
-    data[0] = tmp_2[0] + tmp_2[4];
-    data[1] = tmp_2[1] + tmp_2[5];
-    data[2] = tmp_2[2] + tmp_2[6];
-    data[3] = tmp_2[3] + tmp_2[7];
-    data[4] = tmp_2[0] - tmp_2[4];
-    data[5] = tmp_2[1] - tmp_2[5];
-    data[6] = tmp_2[2] - tmp_2[6];
-    data[7] = tmp_2[3] - tmp_2[7];
-  }
-
-  template <int Dir>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void butterfly_1D_merge(ComplexScalar* data, Index n, Index n_power_of_2) {
-    // Original code:
-    // RealScalar wtemp = std::sin(EIGEN_PI/n);
-    // RealScalar wpi =  -std::sin(2 * EIGEN_PI/n);
-    const RealScalar wtemp = m_sin_PI_div_n_LUT[n_power_of_2];
-    const RealScalar wpi =
-        (Dir == FFT_FORWARD) ? m_minus_sin_2_PI_div_n_LUT[n_power_of_2] : -m_minus_sin_2_PI_div_n_LUT[n_power_of_2];
-
-    const ComplexScalar wp(wtemp, wpi);
-    const ComplexScalar wp_one = wp + ComplexScalar(1, 0);
-    const ComplexScalar wp_one_2 = wp_one * wp_one;
-    const ComplexScalar wp_one_3 = wp_one_2 * wp_one;
-    const ComplexScalar wp_one_4 = wp_one_3 * wp_one;
-    const Index n2 = n / 2;
-    ComplexScalar w(1.0, 0.0);
-    for (Index i = 0; i < n2; i += 4) {
-      ComplexScalar temp0(data[i + n2] * w);
-      ComplexScalar temp1(data[i + 1 + n2] * w * wp_one);
-      ComplexScalar temp2(data[i + 2 + n2] * w * wp_one_2);
-      ComplexScalar temp3(data[i + 3 + n2] * w * wp_one_3);
-      w = w * wp_one_4;
-
-      data[i + n2] = data[i] - temp0;
-      data[i] += temp0;
-
-      data[i + 1 + n2] = data[i + 1] - temp1;
-      data[i + 1] += temp1;
-
-      data[i + 2 + n2] = data[i + 2] - temp2;
-      data[i + 2] += temp2;
-
-      data[i + 3 + n2] = data[i + 3] - temp3;
-      data[i + 3] += temp3;
-    }
-  }
-
-  template <int Dir>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_1D_Butterfly(ComplexScalar* data, Index n, Index n_power_of_2) {
-    eigen_assert(isPowerOfTwo(n));
-    if (n > 8) {
-      compute_1D_Butterfly<Dir>(data, n / 2, n_power_of_2 - 1);
-      compute_1D_Butterfly<Dir>(data + n / 2, n / 2, n_power_of_2 - 1);
-      butterfly_1D_merge<Dir>(data, n, n_power_of_2);
-    } else if (n == 8) {
-      butterfly_8<Dir>(data);
-    } else if (n == 4) {
-      butterfly_4<Dir>(data);
-    } else if (n == 2) {
-      butterfly_2<Dir>(data);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index getBaseOffsetFromIndex(Index index, Index omitted_dim) const {
-    Index result = 0;
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > omitted_dim; --i) {
-        const Index partial_m_stride = m_strides[i] / m_dimensions[omitted_dim];
-        const Index idx = index / partial_m_stride;
-        index -= idx * partial_m_stride;
-        result += idx * m_strides[i];
-      }
-      result += index;
-    } else {
-      for (Index i = 0; i < omitted_dim; ++i) {
-        const Index partial_m_stride = m_strides[i] / m_dimensions[omitted_dim];
-        const Index idx = index / partial_m_stride;
-        index -= idx * partial_m_stride;
-        result += idx * m_strides[i];
-      }
-      result += index;
-    }
-    // Value of index_coords[omitted_dim] is not determined to this step
-    return result;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index getIndexFromOffset(Index base, Index omitted_dim, Index offset) const {
-    Index result = base + offset * m_strides[omitted_dim];
-    return result;
-  }
-
- protected:
-  Index m_size;
-  const FFT EIGEN_DEVICE_REF m_fft;
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_strides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  EvaluatorPointerType m_data;
-  const Device EIGEN_DEVICE_REF m_device;
-
-  // This will support a maximum FFT size of 2^32 for each dimension
-  // m_sin_PI_div_n_LUT[i] = (-2) * std::sin(EIGEN_PI / std::pow(2,i)) ^ 2;
-  const RealScalar m_sin_PI_div_n_LUT[32] = {RealScalar(0.0),
-                                             RealScalar(-2),
-                                             RealScalar(-0.999999999999999),
-                                             RealScalar(-0.292893218813453),
-                                             RealScalar(-0.0761204674887130),
-                                             RealScalar(-0.0192147195967696),
-                                             RealScalar(-0.00481527332780311),
-                                             RealScalar(-0.00120454379482761),
-                                             RealScalar(-3.01181303795779e-04),
-                                             RealScalar(-7.52981608554592e-05),
-                                             RealScalar(-1.88247173988574e-05),
-                                             RealScalar(-4.70619042382852e-06),
-                                             RealScalar(-1.17654829809007e-06),
-                                             RealScalar(-2.94137117780840e-07),
-                                             RealScalar(-7.35342821488550e-08),
-                                             RealScalar(-1.83835707061916e-08),
-                                             RealScalar(-4.59589268710903e-09),
-                                             RealScalar(-1.14897317243732e-09),
-                                             RealScalar(-2.87243293150586e-10),
-                                             RealScalar(-7.18108232902250e-11),
-                                             RealScalar(-1.79527058227174e-11),
-                                             RealScalar(-4.48817645568941e-12),
-                                             RealScalar(-1.12204411392298e-12),
-                                             RealScalar(-2.80511028480785e-13),
-                                             RealScalar(-7.01277571201985e-14),
-                                             RealScalar(-1.75319392800498e-14),
-                                             RealScalar(-4.38298482001247e-15),
-                                             RealScalar(-1.09574620500312e-15),
-                                             RealScalar(-2.73936551250781e-16),
-                                             RealScalar(-6.84841378126949e-17),
-                                             RealScalar(-1.71210344531737e-17),
-                                             RealScalar(-4.28025861329343e-18)};
-
-  // m_minus_sin_2_PI_div_n_LUT[i] = -std::sin(2 * EIGEN_PI / std::pow(2,i));
-  const RealScalar m_minus_sin_2_PI_div_n_LUT[32] = {RealScalar(0.0),
-                                                     RealScalar(0.0),
-                                                     RealScalar(-1.00000000000000e+00),
-                                                     RealScalar(-7.07106781186547e-01),
-                                                     RealScalar(-3.82683432365090e-01),
-                                                     RealScalar(-1.95090322016128e-01),
-                                                     RealScalar(-9.80171403295606e-02),
-                                                     RealScalar(-4.90676743274180e-02),
-                                                     RealScalar(-2.45412285229123e-02),
-                                                     RealScalar(-1.22715382857199e-02),
-                                                     RealScalar(-6.13588464915448e-03),
-                                                     RealScalar(-3.06795676296598e-03),
-                                                     RealScalar(-1.53398018628477e-03),
-                                                     RealScalar(-7.66990318742704e-04),
-                                                     RealScalar(-3.83495187571396e-04),
-                                                     RealScalar(-1.91747597310703e-04),
-                                                     RealScalar(-9.58737990959773e-05),
-                                                     RealScalar(-4.79368996030669e-05),
-                                                     RealScalar(-2.39684498084182e-05),
-                                                     RealScalar(-1.19842249050697e-05),
-                                                     RealScalar(-5.99211245264243e-06),
-                                                     RealScalar(-2.99605622633466e-06),
-                                                     RealScalar(-1.49802811316901e-06),
-                                                     RealScalar(-7.49014056584716e-07),
-                                                     RealScalar(-3.74507028292384e-07),
-                                                     RealScalar(-1.87253514146195e-07),
-                                                     RealScalar(-9.36267570730981e-08),
-                                                     RealScalar(-4.68133785365491e-08),
-                                                     RealScalar(-2.34066892682746e-08),
-                                                     RealScalar(-1.17033446341373e-08),
-                                                     RealScalar(-5.85167231706864e-09),
-                                                     RealScalar(-2.92583615853432e-09)};
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_FFT_H
diff --git a/unsupported/Eigen/src/Tensor/TensorFixedSize.h b/unsupported/Eigen/src/Tensor/TensorFixedSize.h
deleted file mode 100644
index faa7af8..0000000
--- a/unsupported/Eigen/src/Tensor/TensorFixedSize.h
+++ /dev/null
@@ -1,221 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_FIXED_SIZE_H
-#define EIGEN_CXX11_TENSOR_TENSOR_FIXED_SIZE_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief The fixed sized version of the tensor class.
- *
- * The fixed sized equivalent of
- * Eigen::Tensor<float, 3> t(3, 5, 7);
- * is
- * Eigen::TensorFixedSize<float, Sizes<3,5,7>> t;
- */
-template <typename Scalar_, typename Dimensions_, int Options_, typename IndexType>
-class TensorFixedSize : public TensorBase<TensorFixedSize<Scalar_, Dimensions_, Options_, IndexType> > {
- public:
-  typedef TensorFixedSize<Scalar_, Dimensions_, Options_, IndexType> Self;
-  typedef TensorBase<TensorFixedSize<Scalar_, Dimensions_, Options_, IndexType> > Base;
-  typedef typename Eigen::internal::nested<Self>::type Nested;
-  typedef typename internal::traits<Self>::StorageKind StorageKind;
-  typedef typename internal::traits<Self>::Index Index;
-  typedef Scalar_ Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef typename Base::CoeffReturnType CoeffReturnType;
-
-  static constexpr int Options = Options_;
-  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
-
-  enum {
-    IsAligned = bool(EIGEN_MAX_ALIGN_BYTES > 0),
-    PacketAccess = (internal::packet_traits<Scalar>::size > 1),
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = true,
-    RawAccess = true
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  typedef Dimensions_ Dimensions;
-  static constexpr std::size_t NumIndices = Dimensions::count;
-
- protected:
-  TensorStorage<Scalar, Dimensions, Options> m_storage;
-
- public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return NumIndices; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(std::size_t n) const { return m_storage.dimensions()[n]; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions dimensions() const { return m_storage.dimensions(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_storage.size(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar* data() { return m_storage.data(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_storage.data(); }
-
-  // This makes EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
-  // work, because that uses base().coeffRef() - and we don't yet
-  // implement a similar class hierarchy
-  inline Self& base() { return *this; }
-  inline const Self& base() const { return *this; }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index firstIndex, IndexTypes... otherIndices) const {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return coeff(array<Index, NumIndices>{{firstIndex, otherIndices...}});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(const array<Index, NumIndices>& indices) const {
-    eigen_internal_assert(checkIndexRange(indices));
-    return m_storage.data()[linearizedIndex(indices)];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const {
-    eigen_internal_assert(index >= 0 && index < size());
-    return m_storage.data()[index];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff() const {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return m_storage.data()[0];
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices) {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return coeffRef(array<Index, NumIndices>{{firstIndex, otherIndices...}});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) {
-    eigen_internal_assert(checkIndexRange(indices));
-    return m_storage.data()[linearizedIndex(indices)];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) {
-    eigen_internal_assert(index >= 0 && index < size());
-    return m_storage.data()[index];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef() {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return m_storage.data()[0];
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index firstIndex, IndexTypes... otherIndices) const {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return this->operator()(array<Index, NumIndices>{{firstIndex, otherIndices...}});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(const array<Index, NumIndices>& indices) const {
-    eigen_assert(checkIndexRange(indices));
-    return coeff(indices);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index index) const {
-    eigen_internal_assert(index >= 0 && index < size());
-    return coeff(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()() const {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return coeff();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator[](Index index) const {
-    // The bracket operator is only for vectors, use the parenthesis operator instead.
-    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return coeff(index);
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index firstIndex, IndexTypes... otherIndices) {
-    // The number of indices used to access a tensor coefficient must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return operator()(array<Index, NumIndices>{{firstIndex, otherIndices...}});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(const array<Index, NumIndices>& indices) {
-    eigen_assert(checkIndexRange(indices));
-    return coeffRef(indices);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index index) {
-    eigen_assert(index >= 0 && index < size());
-    return coeffRef(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()() {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return coeffRef();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator[](Index index) {
-    // The bracket operator is only for vectors, use the parenthesis operator instead
-    EIGEN_STATIC_ASSERT(NumIndices == 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return coeffRef(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize() : m_storage() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(const Self& other) : Base(other), m_storage(other.m_storage) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(Self&& other) : m_storage(other.m_storage) {}
-
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(const TensorBase<OtherDerived, ReadOnlyAccessors>& other) {
-    typedef TensorAssignOp<TensorFixedSize, const OtherDerived> Assign;
-    Assign assign(*this, other.derived());
-    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-  }
-  template <typename OtherDerived>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorFixedSize(const TensorBase<OtherDerived, WriteAccessors>& other) {
-    typedef TensorAssignOp<TensorFixedSize, const OtherDerived> Assign;
-    Assign assign(*this, other.derived());
-    internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
-  }
-
-  // FIXME: check that the dimensions of other match the dimensions of *this.
-  // Unfortunately this isn't possible yet when the rhs is an expression.
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(TensorFixedSize)
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool checkIndexRange(const array<Index, NumIndices>& /*indices*/) const {
-    using internal::array_apply_and_reduce;
-    using internal::array_zip_and_reduce;
-    using internal::greater_equal_zero_op;
-    using internal::lesser_op;
-    using internal::logical_and_op;
-
-    return true;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index linearizedIndex(const array<Index, NumIndices>& indices) const {
-    if (Options & RowMajor) {
-      return m_storage.dimensions().IndexOfRowMajor(indices);
-    } else {
-      return m_storage.dimensions().IndexOfColMajor(indices);
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_FIXED_SIZE_H
diff --git a/unsupported/Eigen/src/Tensor/TensorForcedEval.h b/unsupported/Eigen/src/Tensor/TensorForcedEval.h
deleted file mode 100644
index e945dad..0000000
--- a/unsupported/Eigen/src/Tensor/TensorForcedEval.h
+++ /dev/null
@@ -1,230 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_FORCED_EVAL_H
-#define EIGEN_CXX11_TENSOR_TENSOR_FORCED_EVAL_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-#include <memory>
-
-namespace Eigen {
-
-namespace internal {
-template <typename XprType>
-struct traits<TensorForcedEvalOp<XprType>> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename traits<XprType>::StorageKind StorageKind;
-  typedef typename traits<XprType>::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-
-  enum { Flags = 0 };
-};
-
-template <typename XprType>
-struct eval<TensorForcedEvalOp<XprType>, Eigen::Dense> {
-  typedef const TensorForcedEvalOp<XprType>& type;
-};
-
-template <typename XprType>
-struct nested<TensorForcedEvalOp<XprType>, 1, typename eval<TensorForcedEvalOp<XprType>>::type> {
-  typedef TensorForcedEvalOp<XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor forced evaluation class.
- */
-template <typename XprType>
-class TensorForcedEvalOp : public TensorBase<TensorForcedEvalOp<XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorForcedEvalOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorForcedEvalOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorForcedEvalOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorForcedEvalOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorForcedEvalOp(const XprType& expr) : m_xpr(expr) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-};
-
-namespace internal {
-template <typename Device, typename CoeffReturnType>
-struct non_integral_type_placement_new {
-  template <typename StorageType>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(Index numValues, StorageType m_buffer) const {
-    // Initialize non-trivially constructible types.
-    if (!internal::is_arithmetic<CoeffReturnType>::value) {
-      for (Index i = 0; i < numValues; ++i) new (m_buffer + i) CoeffReturnType();
-    }
-  }
-};
-
-// SYCL does not support non-integral types
-// having new (m_buffer + i) CoeffReturnType() causes the following compiler error for SYCL Devices
-// no matching function for call to 'operator new'
-template <typename CoeffReturnType>
-struct non_integral_type_placement_new<Eigen::SyclDevice, CoeffReturnType> {
-  template <typename StorageType>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(Index, StorageType) const {}
-};
-}  // end namespace internal
-
-template <typename Device>
-class DeviceTempPointerHolder {
- public:
-  DeviceTempPointerHolder(const Device& device, size_t size)
-      : device_(device), size_(size), ptr_(device.allocate_temp(size)) {}
-
-  ~DeviceTempPointerHolder() {
-    device_.deallocate_temp(ptr_);
-    size_ = 0;
-    ptr_ = nullptr;
-  }
-
-  void* ptr() { return ptr_; }
-
- private:
-  Device device_;
-  size_t size_;
-  void* ptr_;
-};
-
-template <typename ArgType_, typename Device>
-struct TensorEvaluator<const TensorForcedEvalOp<ArgType_>, Device> {
-  typedef const internal::remove_all_t<ArgType_> ArgType;
-  typedef TensorForcedEvalOp<ArgType> XprType;
-  typedef typename ArgType::Scalar Scalar;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  enum {
-    IsAligned = true,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = internal::is_arithmetic<CoeffReturnType>::value,
-    PreferBlockAccess = false,
-    RawAccess = true
-  };
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  static constexpr int NumDims = internal::traits<ArgType>::NumDimensions;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device),
-        m_op(op.expression()),
-        m_device(device),
-        m_buffer_holder(nullptr),
-        m_buffer(nullptr) {}
-
-  ~TensorEvaluator() { cleanup(); }
-
-  EIGEN_DEVICE_FUNC const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    const Index numValues = internal::array_prod(m_impl.dimensions());
-    m_buffer_holder = std::make_shared<DeviceTempPointerHolder<Device>>(m_device, numValues * sizeof(CoeffReturnType));
-    m_buffer = static_cast<EvaluatorPointerType>(m_buffer_holder->ptr());
-
-    internal::non_integral_type_placement_new<Device, CoeffReturnType>()(numValues, m_buffer);
-
-    typedef TensorEvalToOp<const std::remove_const_t<ArgType>> EvalTo;
-    EvalTo evalToTmp(m_device.get(m_buffer), m_op);
-
-    internal::TensorExecutor<const EvalTo, std::remove_const_t<Device>,
-                             /*Vectorizable=*/internal::IsVectorizable<Device, const ArgType>::value,
-                             /*Tiling=*/internal::IsTileable<Device, const ArgType>::value>::run(evalToTmp, m_device);
-
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    const Index numValues = internal::array_prod(m_impl.dimensions());
-    m_buffer_holder = std::make_shared<DeviceTempPointerHolder<Device>>(m_device, numValues * sizeof(CoeffReturnType));
-    m_buffer = static_cast<EvaluatorPointerType>(m_buffer_holder->ptr());
-
-    typedef TensorEvalToOp<const std::remove_const_t<ArgType>> EvalTo;
-    EvalTo evalToTmp(m_device.get(m_buffer), m_op);
-
-    auto on_done = std::bind([](EvalSubExprsCallback done_) { done_(true); }, std::move(done));
-    internal::TensorAsyncExecutor<
-        const EvalTo, std::remove_const_t<Device>, decltype(on_done),
-        /*Vectorizable=*/internal::IsVectorizable<Device, const ArgType>::value,
-        /*Tiling=*/internal::IsTileable<Device, const ArgType>::value>::runAsync(evalToTmp, m_device,
-                                                                                 std::move(on_done));
-  }
-#endif
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_buffer_holder = nullptr;
-    m_buffer = nullptr;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_buffer[index]; }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_buffer + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return internal::TensorBlockResourceRequirements::any();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    eigen_assert(m_buffer != nullptr);
-    return TensorBlock::materialize(m_buffer, m_impl.dimensions(), desc, scratch);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EvaluatorPointerType data() const { return m_buffer; }
-
- private:
-  TensorEvaluator<ArgType, Device> m_impl;
-  const ArgType m_op;
-  const Device EIGEN_DEVICE_REF m_device;
-  std::shared_ptr<DeviceTempPointerHolder<Device>> m_buffer_holder;
-  EvaluatorPointerType m_buffer;  // Cached copy of the value stored in m_buffer_holder.
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_FORCED_EVAL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorForwardDeclarations.h b/unsupported/Eigen/src/Tensor/TensorForwardDeclarations.h
deleted file mode 100644
index 49c20a4..0000000
--- a/unsupported/Eigen/src/Tensor/TensorForwardDeclarations.h
+++ /dev/null
@@ -1,215 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_FORWARD_DECLARATIONS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_FORWARD_DECLARATIONS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// MakePointer class is used as a container of the address space of the pointer
-// on the host and on the device. From the host side it generates the T* pointer
-// and when EIGEN_USE_SYCL is used it construct a buffer with a map_allocator to
-// T* m_data on the host. It is always called on the device.
-// Specialisation of MakePointer class for creating the sycl buffer with
-// map_allocator.
-template <typename T>
-struct MakePointer {
-  typedef T* Type;
-  typedef const T* ConstType;
-};
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* constCast(const T* data) {
-  return const_cast<T*>(data);
-}
-
-// The StorageMemory class is a container of the device specific pointer
-// used for referring to a Pointer on TensorEvaluator class. While the TensorExpression
-// is a device-agnostic type and need MakePointer class for type conversion,
-// the TensorEvaluator class can be specialized for a device, hence it is possible
-// to construct different types of temporary storage memory in TensorEvaluator
-// for different devices by specializing the following StorageMemory class.
-template <typename T, typename device>
-struct StorageMemory : MakePointer<T> {};
-
-namespace internal {
-template <typename A, typename B>
-struct Pointer_type_promotion {
-  static const bool val = false;
-};
-template <typename A>
-struct Pointer_type_promotion<A, A> {
-  static const bool val = true;
-};
-template <typename A, typename B>
-struct TypeConversion {
-  typedef A* type;
-};
-}  // namespace internal
-
-template <typename PlainObjectType, int Options_ = Unaligned, template <class> class MakePointer_ = MakePointer>
-class TensorMap;
-template <typename Scalar_, int NumIndices_, int Options_ = 0, typename IndexType = DenseIndex>
-class Tensor;
-template <typename Scalar_, typename Dimensions, int Options_ = 0, typename IndexType = DenseIndex>
-class TensorFixedSize;
-template <typename PlainObjectType>
-class TensorRef;
-template <typename Derived, int AccessLevel>
-class TensorBase;
-
-template <typename NullaryOp, typename PlainObjectType>
-class TensorCwiseNullaryOp;
-template <typename UnaryOp, typename XprType>
-class TensorCwiseUnaryOp;
-template <typename BinaryOp, typename LeftXprType, typename RightXprType>
-class TensorCwiseBinaryOp;
-template <typename TernaryOp, typename Arg1XprType, typename Arg2XprType, typename Arg3XprType>
-class TensorCwiseTernaryOp;
-template <typename IfXprType, typename ThenXprType, typename ElseXprType>
-class TensorSelectOp;
-template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_ = MakePointer>
-class TensorReductionOp;
-template <typename XprType>
-class TensorIndexPairOp;
-template <typename ReduceOp, typename Dims, typename XprType>
-class TensorPairReducerOp;
-template <typename Axis, typename LeftXprType, typename RightXprType>
-class TensorConcatenationOp;
-template <typename Dimensions, typename LeftXprType, typename RightXprType, typename OutputKernelType>
-class TensorContractionOp;
-template <typename TargetType, typename XprType>
-class TensorConversionOp;
-template <typename Dimensions, typename InputXprType, typename KernelXprType>
-class TensorConvolutionOp;
-template <typename FFT, typename XprType, int FFTDataType, int FFTDirection>
-class TensorFFTOp;
-template <typename PatchDim, typename XprType>
-class TensorPatchOp;
-template <DenseIndex Rows, DenseIndex Cols, typename XprType>
-class TensorImagePatchOp;
-template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
-class TensorVolumePatchOp;
-template <typename Broadcast, typename XprType>
-class TensorBroadcastingOp;
-template <DenseIndex DimId, typename XprType>
-class TensorChippingOp;
-template <typename NewDimensions, typename XprType>
-class TensorReshapingOp;
-template <typename XprType>
-class TensorLayoutSwapOp;
-template <typename StartIndices, typename Sizes, typename XprType>
-class TensorSlicingOp;
-template <typename ReverseDimensions, typename XprType>
-class TensorReverseOp;
-template <typename Rolls, typename XprType>
-class TensorRollOp;
-template <typename PaddingDimensions, typename XprType>
-class TensorPaddingOp;
-template <typename Shuffle, typename XprType>
-class TensorShufflingOp;
-template <typename Strides, typename XprType>
-class TensorStridingOp;
-template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
-class TensorStridingSlicingOp;
-template <typename Strides, typename XprType>
-class TensorInflationOp;
-template <typename Generator, typename XprType>
-class TensorGeneratorOp;
-template <typename LeftXprType, typename RightXprType>
-class TensorAssignOp;
-template <typename Op, typename XprType>
-class TensorScanOp;
-template <typename Dims, typename XprType>
-class TensorTraceOp;
-
-template <typename CustomUnaryFunc, typename XprType>
-class TensorCustomUnaryOp;
-template <typename CustomBinaryFunc, typename LhsXprType, typename RhsXprType>
-class TensorCustomBinaryOp;
-
-template <typename XprType, template <class> class MakePointer_ = MakePointer>
-class TensorEvalToOp;
-template <typename XprType>
-class TensorForcedEvalOp;
-
-template <typename ExpressionType, typename DeviceType>
-class TensorDevice;
-template <typename ExpressionType, typename DeviceType, typename DoneCallback>
-class TensorAsyncDevice;
-template <typename Derived, typename Device>
-struct TensorEvaluator;
-
-struct NoOpOutputKernel;
-
-struct DefaultDevice;
-struct ThreadPoolDevice;
-struct GpuDevice;
-struct SyclDevice;
-
-#ifdef EIGEN_USE_SYCL
-namespace TensorSycl {
-namespace internal {
-template <typename Evaluator, typename Op>
-class GenericNondeterministicReducer;
-}
-}  // namespace TensorSycl
-#endif
-
-enum FFTResultType { RealPart = 0, ImagPart = 1, BothParts = 2 };
-
-enum FFTDirection { FFT_FORWARD = 0, FFT_REVERSE = 1 };
-
-namespace internal {
-
-template <typename Device, typename Expression>
-struct IsVectorizable {
-  static const bool value = TensorEvaluator<Expression, Device>::PacketAccess;
-};
-
-template <typename Expression>
-struct IsVectorizable<GpuDevice, Expression> {
-  static const bool value =
-      TensorEvaluator<Expression, GpuDevice>::PacketAccess && TensorEvaluator<Expression, GpuDevice>::IsAligned;
-};
-
-// Tiled evaluation strategy.
-enum TiledEvaluation {
-  Off = 0,  // tiled evaluation is not supported
-  On = 1,   // still work in progress (see TensorBlock.h)
-};
-
-template <typename Device, typename Expression>
-struct IsTileable {
-  // Check that block evaluation is supported and it's a preferred option (at
-  // least one sub-expression has much faster block evaluation, e.g.
-  // broadcasting).
-  static constexpr bool BlockAccess =
-      TensorEvaluator<Expression, Device>::BlockAccess && TensorEvaluator<Expression, Device>::PreferBlockAccess;
-
-  static const TiledEvaluation value = BlockAccess ? TiledEvaluation::On : TiledEvaluation::Off;
-};
-
-template <typename Expression, typename Device, bool Vectorizable = IsVectorizable<Device, Expression>::value,
-          TiledEvaluation Tiling = IsTileable<Device, Expression>::value>
-class TensorExecutor;
-
-template <typename Expression, typename Device, typename DoneCallback,
-          bool Vectorizable = IsVectorizable<Device, Expression>::value,
-          TiledEvaluation Tiling = IsTileable<Device, Expression>::value>
-class TensorAsyncExecutor;
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_FORWARD_DECLARATIONS_H
diff --git a/unsupported/Eigen/src/Tensor/TensorFunctors.h b/unsupported/Eigen/src/Tensor/TensorFunctors.h
deleted file mode 100644
index 7a87594..0000000
--- a/unsupported/Eigen/src/Tensor/TensorFunctors.h
+++ /dev/null
@@ -1,422 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_FUNCTORS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_FUNCTORS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-/** \internal
- * \brief Template functor to compute the modulo between an array and a scalar.
- */
-template <typename Scalar>
-struct scalar_mod_op {
-  EIGEN_DEVICE_FUNC scalar_mod_op(const Scalar& divisor) : m_divisor(divisor) {}
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const { return a % m_divisor; }
-  const Scalar m_divisor;
-};
-template <typename Scalar>
-struct functor_traits<scalar_mod_op<Scalar> > {
-  enum { Cost = scalar_div_cost<Scalar, false>::value, PacketAccess = false };
-};
-
-/** \internal
- * \brief Template functor to compute the modulo between 2 arrays.
- */
-template <typename Scalar>
-struct scalar_mod2_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const { return a % b; }
-};
-template <typename Scalar>
-struct functor_traits<scalar_mod2_op<Scalar> > {
-  enum { Cost = scalar_div_cost<Scalar, false>::value, PacketAccess = false };
-};
-
-template <typename Scalar>
-struct scalar_fmod_op {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a, const Scalar& b) const {
-    return numext::fmod(a, b);
-  }
-};
-template <typename Scalar>
-struct functor_traits<scalar_fmod_op<Scalar> > {
-  enum {
-    Cost = 13,  // Reciprocal throughput of FPREM on Haswell.
-    PacketAccess = false
-  };
-};
-
-template <typename Reducer, typename Device>
-struct reducer_traits {
-  enum { Cost = 1, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
-};
-
-// Standard reduction functors
-template <typename T>
-struct SumReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
-    internal::scalar_sum_op<T> sum_op;
-    *accum = sum_op(*accum, t);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
-    (*accum) = padd<Packet>(*accum, p);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    internal::scalar_cast_op<int, T> conv;
-    return conv(0);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
-    return pset1<Packet>(initialize());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
-    return vaccum;
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
-    internal::scalar_sum_op<T> sum_op;
-    return sum_op(saccum, predux(vaccum));
-  }
-};
-
-template <typename T, typename Device>
-struct reducer_traits<SumReducer<T>, Device> {
-  enum {
-    Cost = NumTraits<T>::AddCost,
-    PacketAccess = PacketType<T, Device>::HasAdd,
-    IsStateful = false,
-    IsExactlyAssociative = NumTraits<T>::IsInteger
-  };
-};
-
-template <typename T>
-struct MeanReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE MeanReducer() : scalarCount_(0), packetCount_(0) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) {
-    internal::scalar_sum_op<T> sum_op;
-    *accum = sum_op(*accum, t);
-    scalarCount_++;
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) {
-    (*accum) = padd<Packet>(*accum, p);
-    packetCount_++;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    internal::scalar_cast_op<int, T> conv;
-    return conv(0);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
-    return pset1<Packet>(initialize());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const {
-    internal::scalar_quotient_op<T> quotient_op;
-    return quotient_op(accum, T(scalarCount_));
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
-    return pdiv(vaccum, pset1<Packet>(T(packetCount_)));
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
-    internal::scalar_sum_op<T> sum_op;
-    internal::scalar_quotient_op<T> quotient_op;
-    return quotient_op(sum_op(saccum, predux(vaccum)), T(scalarCount_ + packetCount_ * unpacket_traits<Packet>::size));
-  }
-
- protected:
-  DenseIndex scalarCount_;
-  DenseIndex packetCount_;
-};
-
-template <typename T, typename Device>
-struct reducer_traits<MeanReducer<T>, Device> {
-  enum {
-    Cost = NumTraits<T>::AddCost,
-    PacketAccess = PacketType<T, Device>::HasAdd && PacketType<T, Device>::HasDiv && !NumTraits<T>::IsInteger,
-    IsStateful = true,
-    IsExactlyAssociative = NumTraits<T>::IsInteger
-  };
-};
-
-template <typename T, bool IsMax = true, bool IsInteger = true>
-struct MinMaxBottomValue {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return Eigen::NumTraits<T>::lowest(); }
-};
-template <typename T>
-struct MinMaxBottomValue<T, true, false> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return -Eigen::NumTraits<T>::infinity(); }
-};
-template <typename T>
-struct MinMaxBottomValue<T, false, true> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return Eigen::NumTraits<T>::highest(); }
-};
-template <typename T>
-struct MinMaxBottomValue<T, false, false> {
-  EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE T bottom_value() { return Eigen::NumTraits<T>::infinity(); }
-};
-
-template <typename T, int NaNPropagation = PropagateFast>
-struct MaxReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
-    scalar_max_op<T, T, NaNPropagation> op;
-    *accum = op(t, *accum);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
-    scalar_max_op<T, T, NaNPropagation> op;
-    (*accum) = op.packetOp(*accum, p);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    return MinMaxBottomValue<T, /*IsMax=*/true, Eigen::NumTraits<T>::IsInteger>::bottom_value();
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
-    return pset1<Packet>(initialize());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
-    return vaccum;
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
-    scalar_max_op<T, T, NaNPropagation> op;
-    return op(saccum, op.predux(vaccum));
-  }
-};
-
-template <typename T, typename Device, int NaNPropagation>
-struct reducer_traits<MaxReducer<T, NaNPropagation>, Device> {
-  enum {
-    Cost = NumTraits<T>::AddCost,
-    PacketAccess = PacketType<T, Device>::HasMax,
-    IsStateful = false,
-    IsExactlyAssociative = (NaNPropagation != PropagateFast)
-  };
-};
-
-template <typename T, int NaNPropagation = PropagateFast>
-struct MinReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
-    scalar_min_op<T, T, NaNPropagation> op;
-    *accum = op(t, *accum);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
-    scalar_min_op<T, T, NaNPropagation> op;
-    (*accum) = op.packetOp(*accum, p);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    return MinMaxBottomValue<T, /*IsMax=*/false, Eigen::NumTraits<T>::IsInteger>::bottom_value();
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
-    return pset1<Packet>(initialize());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
-    return vaccum;
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
-    scalar_min_op<T, T, NaNPropagation> op;
-    return op(saccum, op.predux(vaccum));
-  }
-};
-
-template <typename T, typename Device, int NaNPropagation>
-struct reducer_traits<MinReducer<T, NaNPropagation>, Device> {
-  enum {
-    Cost = NumTraits<T>::AddCost,
-    PacketAccess = PacketType<T, Device>::HasMin,
-    IsStateful = false,
-    IsExactlyAssociative = (NaNPropagation != PropagateFast)
-  };
-};
-
-template <typename T>
-struct ProdReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
-    internal::scalar_product_op<T> prod_op;
-    (*accum) = prod_op(*accum, t);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reducePacket(const Packet& p, Packet* accum) const {
-    (*accum) = pmul<Packet>(*accum, p);
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    internal::scalar_cast_op<int, T> conv;
-    return conv(1);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet initializePacket() const {
-    return pset1<Packet>(initialize());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T accum) const { return accum; }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet finalizePacket(const Packet& vaccum) const {
-    return vaccum;
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalizeBoth(const T saccum, const Packet& vaccum) const {
-    internal::scalar_product_op<T> prod_op;
-    return prod_op(saccum, predux_mul(vaccum));
-  }
-};
-
-template <typename T, typename Device>
-struct reducer_traits<ProdReducer<T>, Device> {
-  enum {
-    Cost = NumTraits<T>::MulCost,
-    PacketAccess = PacketType<T, Device>::HasMul,
-    IsStateful = false,
-    IsExactlyAssociative = true
-  };
-};
-
-struct AndReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(bool t, bool* accum) const { *accum = *accum && t; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool initialize() const { return true; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool finalize(bool accum) const { return accum; }
-};
-
-template <typename Device>
-struct reducer_traits<AndReducer, Device> {
-  enum { Cost = 1, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
-};
-
-struct OrReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(bool t, bool* accum) const { *accum = *accum || t; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool initialize() const { return false; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool finalize(bool accum) const { return accum; }
-};
-
-template <typename Device>
-struct reducer_traits<OrReducer, Device> {
-  enum { Cost = 1, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
-};
-
-// Argmin/Argmax reducers.  Returns the first occurrence if multiple locations
-// contain the same min/max value.
-template <typename T>
-struct ArgMaxPairReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
-    if (t.second < accum->second) {
-      return;
-    } else if (t.second > accum->second || accum->first > t.first) {
-      *accum = t;
-    }
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    return T(0, NumTraits<typename T::second_type>::lowest());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T& accum) const { return accum; }
-};
-
-template <typename T, typename Device>
-struct reducer_traits<ArgMaxPairReducer<T>, Device> {
-  enum { Cost = NumTraits<T>::AddCost, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
-};
-
-template <typename T>
-struct ArgMinPairReducer {
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T& t, T* accum) const {
-    if (t.second > accum->second) {
-      return;
-    } else if (t.second < accum->second || accum->first > t.first) {
-      *accum = t;
-    }
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
-    return T(0, NumTraits<typename T::second_type>::highest());
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T finalize(const T& accum) const { return accum; }
-};
-
-template <typename T, typename Device>
-struct reducer_traits<ArgMinPairReducer<T>, Device> {
-  enum { Cost = NumTraits<T>::AddCost, PacketAccess = false, IsStateful = false, IsExactlyAssociative = true };
-};
-
-template <typename T, typename Index, size_t NumDims>
-class GaussianGenerator {
- public:
-  static constexpr bool PacketAccess = false;
-
-  EIGEN_DEVICE_FUNC GaussianGenerator(const array<T, NumDims>& means, const array<T, NumDims>& std_devs)
-      : m_means(means) {
-    EIGEN_UNROLL_LOOP
-    for (size_t i = 0; i < NumDims; ++i) {
-      m_two_sigmas[i] = std_devs[i] * std_devs[i] * 2;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC T operator()(const array<Index, NumDims>& coordinates) const {
-    T tmp = T(0);
-    EIGEN_UNROLL_LOOP
-    for (size_t i = 0; i < NumDims; ++i) {
-      T offset = coordinates[i] - m_means[i];
-      tmp += offset * offset / m_two_sigmas[i];
-    }
-    return numext::exp(-tmp);
-  }
-
- private:
-  array<T, NumDims> m_means;
-  array<T, NumDims> m_two_sigmas;
-};
-
-template <typename T, typename Index, size_t NumDims>
-struct functor_traits<GaussianGenerator<T, Index, NumDims> > {
-  enum {
-    Cost = NumDims *
-               (2 * NumTraits<T>::AddCost + NumTraits<T>::MulCost + functor_traits<scalar_quotient_op<T, T> >::Cost) +
-           functor_traits<scalar_exp_op<T> >::Cost,
-    PacketAccess = GaussianGenerator<T, Index, NumDims>::PacketAccess
-  };
-};
-
-template <typename Scalar>
-struct scalar_clamp_op {
-  EIGEN_DEVICE_FUNC inline scalar_clamp_op(const Scalar& _min, const Scalar& _max) : m_min(_min), m_max(_max) {}
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(const Scalar& x) const {
-    return numext::mini(numext::maxi(x, m_min), m_max);
-  }
-  template <typename Packet>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& x) const {
-    return internal::pmin(internal::pmax(x, pset1<Packet>(m_min)), pset1<Packet>(m_max));
-  }
-  const Scalar m_min;
-  const Scalar m_max;
-};
-template <typename Scalar>
-struct functor_traits<scalar_clamp_op<Scalar> > {
-  enum {
-    Cost = 2 * NumTraits<Scalar>::AddCost,
-    PacketAccess = (packet_traits<Scalar>::HasMin && packet_traits<Scalar>::HasMax)
-  };
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_FUNCTORS_H
diff --git a/unsupported/Eigen/src/Tensor/TensorGenerator.h b/unsupported/Eigen/src/Tensor/TensorGenerator.h
deleted file mode 100644
index 2dac337..0000000
--- a/unsupported/Eigen/src/Tensor/TensorGenerator.h
+++ /dev/null
@@ -1,269 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_GENERATOR_H
-#define EIGEN_CXX11_TENSOR_TENSOR_GENERATOR_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Generator, typename XprType>
-struct traits<TensorGeneratorOp<Generator, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename Generator, typename XprType>
-struct eval<TensorGeneratorOp<Generator, XprType>, Eigen::Dense> {
-  typedef const TensorGeneratorOp<Generator, XprType>& type;
-};
-
-template <typename Generator, typename XprType>
-struct nested<TensorGeneratorOp<Generator, XprType>, 1, typename eval<TensorGeneratorOp<Generator, XprType> >::type> {
-  typedef TensorGeneratorOp<Generator, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor generator class.
- */
-template <typename Generator, typename XprType>
-class TensorGeneratorOp : public TensorBase<TensorGeneratorOp<Generator, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorGeneratorOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorGeneratorOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorGeneratorOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorGeneratorOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorGeneratorOp(const XprType& expr, const Generator& generator)
-      : m_xpr(expr), m_generator(generator) {}
-
-  EIGEN_DEVICE_FUNC const Generator& generator() const { return m_generator; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Generator m_generator;
-};
-
-// Eval as rvalue
-template <typename Generator, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorGeneratorOp<Generator, ArgType>, Device> {
-  typedef TensorGeneratorOp<Generator, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
-  static constexpr int NumDims = internal::array_size<Dimensions>::value;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = true,
-    PreferBlockAccess = true,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  typedef internal::TensorIntDivisor<Index> IndexDivisor;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_device(device), m_generator(op.generator()) {
-    TensorEvaluator<ArgType, Device> argImpl(op.expression(), device);
-    m_dimensions = argImpl.dimensions();
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_strides[0] = 1;
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < NumDims; ++i) {
-        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
-        if (m_strides[i] != 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
-      }
-    } else {
-      m_strides[NumDims - 1] = 1;
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
-        if (m_strides[i] != 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) { return true; }
-  EIGEN_STRONG_INLINE void cleanup() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    array<Index, NumDims> coords;
-    extract_coordinates(index, coords);
-    return m_generator(coords);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[packetSize];
-    for (int i = 0; i < packetSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.firstLevelCacheSize();
-    // TODO(ezhulenev): Generator should have a cost.
-    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size);
-  }
-
-  struct BlockIteratorState {
-    Index stride;
-    Index span;
-    Index size;
-    Index count;
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    static const bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
-
-    // Compute spatial coordinates for the first block element.
-    array<Index, NumDims> coords;
-    extract_coordinates(desc.offset(), coords);
-    array<Index, NumDims> initial_coords = coords;
-
-    // Offset in the output block buffer.
-    Index offset = 0;
-
-    // Initialize output block iterator state. Dimension in this array are
-    // always in inner_most -> outer_most order (col major layout).
-    array<BlockIteratorState, NumDims> it;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = is_col_major ? i : NumDims - 1 - i;
-      it[i].size = desc.dimension(dim);
-      it[i].stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].stride);
-      it[i].span = it[i].stride * (it[i].size - 1);
-      it[i].count = 0;
-    }
-    eigen_assert(it[0].stride == 1);
-
-    // Prepare storage for the materialized generator result.
-    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
-
-    CoeffReturnType* block_buffer = block_storage.data();
-
-    static const int packet_size = PacketType<CoeffReturnType, Device>::size;
-
-    static const int inner_dim = is_col_major ? 0 : NumDims - 1;
-    const Index inner_dim_size = it[0].size;
-    const Index inner_dim_vectorized = inner_dim_size - packet_size;
-
-    while (it[NumDims - 1].count < it[NumDims - 1].size) {
-      Index i = 0;
-      // Generate data for the vectorized part of the inner-most dimension.
-      for (; i <= inner_dim_vectorized; i += packet_size) {
-        for (Index j = 0; j < packet_size; ++j) {
-          array<Index, NumDims> j_coords = coords;  // Break loop dependence.
-          j_coords[inner_dim] += j;
-          *(block_buffer + offset + i + j) = m_generator(j_coords);
-        }
-        coords[inner_dim] += packet_size;
-      }
-      // Finalize non-vectorized part of the inner-most dimension.
-      for (; i < inner_dim_size; ++i) {
-        *(block_buffer + offset + i) = m_generator(coords);
-        coords[inner_dim]++;
-      }
-      coords[inner_dim] = initial_coords[inner_dim];
-
-      // For the 1d tensor we need to generate only one inner-most dimension.
-      if (NumDims == 1) break;
-
-      // Update offset.
-      for (i = 1; i < NumDims; ++i) {
-        if (++it[i].count < it[i].size) {
-          offset += it[i].stride;
-          coords[is_col_major ? i : NumDims - 1 - i]++;
-          break;
-        }
-        if (i != NumDims - 1) it[i].count = 0;
-        coords[is_col_major ? i : NumDims - 1 - i] = initial_coords[is_col_major ? i : NumDims - 1 - i];
-        offset -= it[i].span;
-      }
-    }
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool) const {
-    // TODO(rmlarsen): This is just a placeholder. Define interface to make
-    // generators return their cost.
-    return TensorOpCost(0, 0, TensorOpCost::AddCost<Scalar>() + TensorOpCost::MulCost<Scalar>());
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_coordinates(Index index, array<Index, NumDims>& coords) const {
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        coords[i] = idx;
-      }
-      coords[0] = index;
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        coords[i] = idx;
-      }
-      coords[NumDims - 1] = index;
-    }
-  }
-
-  const Device EIGEN_DEVICE_REF m_device;
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_strides;
-  array<IndexDivisor, NumDims> m_fast_strides;
-  Generator m_generator;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_GENERATOR_H
diff --git a/unsupported/Eigen/src/Tensor/TensorGlobalFunctions.h b/unsupported/Eigen/src/Tensor/TensorGlobalFunctions.h
deleted file mode 100644
index 6a1240c..0000000
--- a/unsupported/Eigen/src/Tensor/TensorGlobalFunctions.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Eugene Brevdo <ebrevdo@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \cpp11 \returns an expression of the coefficient-wise betainc(\a x, \a a, \a b) to the given tensors.
- *
- * This function computes the regularized incomplete beta function (integral).
- *
- */
-template <typename ADerived, typename BDerived, typename XDerived>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>,
-                                                                 const ADerived, const BDerived, const XDerived>
-betainc(const Eigen::TensorBase<ADerived, ReadOnlyAccessors>& a,
-        const Eigen::TensorBase<BDerived, ReadOnlyAccessors>& b,
-        const Eigen::TensorBase<XDerived, ReadOnlyAccessors>& x) {
-  return TensorCwiseTernaryOp<internal::scalar_betainc_op<typename XDerived::Scalar>, const ADerived, const BDerived,
-                              const XDerived>(a.derived(), b.derived(), x.derived(),
-                                              internal::scalar_betainc_op<typename XDerived::Scalar>());
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_GLOBAL_FUNCTIONS_H
diff --git a/unsupported/Eigen/src/Tensor/TensorIO.h b/unsupported/Eigen/src/Tensor/TensorIO.h
deleted file mode 100644
index 0bdb1ab..0000000
--- a/unsupported/Eigen/src/Tensor/TensorIO.h
+++ /dev/null
@@ -1,413 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_IO_H
-#define EIGEN_CXX11_TENSOR_TENSOR_IO_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-struct TensorIOFormat;
-
-namespace internal {
-template <typename Tensor, std::size_t rank, typename Format, typename EnableIf = void>
-struct TensorPrinter;
-}
-
-template <typename Derived_>
-struct TensorIOFormatBase {
-  using Derived = Derived_;
-  TensorIOFormatBase(const std::vector<std::string>& separator, const std::vector<std::string>& prefix,
-                     const std::vector<std::string>& suffix, int precision = StreamPrecision, int flags = 0,
-                     const std::string& tenPrefix = "", const std::string& tenSuffix = "", const char fill = ' ')
-      : tenPrefix(tenPrefix),
-        tenSuffix(tenSuffix),
-        prefix(prefix),
-        suffix(suffix),
-        separator(separator),
-        fill(fill),
-        precision(precision),
-        flags(flags) {
-    init_spacer();
-  }
-
-  void init_spacer() {
-    if ((flags & DontAlignCols)) return;
-    spacer.resize(prefix.size());
-    spacer[0] = "";
-    int i = int(tenPrefix.length()) - 1;
-    while (i >= 0 && tenPrefix[i] != '\n') {
-      spacer[0] += ' ';
-      i--;
-    }
-
-    for (std::size_t k = 1; k < prefix.size(); k++) {
-      int j = int(prefix[k].length()) - 1;
-      while (j >= 0 && prefix[k][j] != '\n') {
-        spacer[k] += ' ';
-        j--;
-      }
-    }
-  }
-
-  std::string tenPrefix;
-  std::string tenSuffix;
-  std::vector<std::string> prefix;
-  std::vector<std::string> suffix;
-  std::vector<std::string> separator;
-  char fill;
-  int precision;
-  int flags;
-  std::vector<std::string> spacer{};
-};
-
-struct TensorIOFormatNumpy : public TensorIOFormatBase<TensorIOFormatNumpy> {
-  using Base = TensorIOFormatBase<TensorIOFormatNumpy>;
-  TensorIOFormatNumpy()
-      : Base(/*separator=*/{" ", "\n"}, /*prefix=*/{"", "["}, /*suffix=*/{"", "]"}, /*precision=*/StreamPrecision,
-             /*flags=*/0, /*tenPrefix=*/"[", /*tenSuffix=*/"]") {}
-};
-
-struct TensorIOFormatNative : public TensorIOFormatBase<TensorIOFormatNative> {
-  using Base = TensorIOFormatBase<TensorIOFormatNative>;
-  TensorIOFormatNative()
-      : Base(/*separator=*/{", ", ",\n", "\n"}, /*prefix=*/{"", "{"}, /*suffix=*/{"", "}"},
-             /*precision=*/StreamPrecision, /*flags=*/0, /*tenPrefix=*/"{", /*tenSuffix=*/"}") {}
-};
-
-struct TensorIOFormatPlain : public TensorIOFormatBase<TensorIOFormatPlain> {
-  using Base = TensorIOFormatBase<TensorIOFormatPlain>;
-  TensorIOFormatPlain()
-      : Base(/*separator=*/{" ", "\n", "\n", ""}, /*prefix=*/{""}, /*suffix=*/{""}, /*precision=*/StreamPrecision,
-             /*flags=*/0, /*tenPrefix=*/"", /*tenSuffix=*/"") {}
-};
-
-struct TensorIOFormatLegacy : public TensorIOFormatBase<TensorIOFormatLegacy> {
-  using Base = TensorIOFormatBase<TensorIOFormatLegacy>;
-  TensorIOFormatLegacy()
-      : Base(/*separator=*/{", ", "\n"}, /*prefix=*/{"", "["}, /*suffix=*/{"", "]"}, /*precision=*/StreamPrecision,
-             /*flags=*/0, /*tenPrefix=*/"", /*tenSuffix=*/"") {}
-};
-
-struct TensorIOFormat : public TensorIOFormatBase<TensorIOFormat> {
-  using Base = TensorIOFormatBase<TensorIOFormat>;
-  TensorIOFormat(const std::vector<std::string>& separator, const std::vector<std::string>& prefix,
-                 const std::vector<std::string>& suffix, int precision = StreamPrecision, int flags = 0,
-                 const std::string& tenPrefix = "", const std::string& tenSuffix = "", const char fill = ' ')
-      : Base(separator, prefix, suffix, precision, flags, tenPrefix, tenSuffix, fill) {}
-
-  static inline const TensorIOFormatNumpy Numpy() { return TensorIOFormatNumpy{}; }
-
-  static inline const TensorIOFormatPlain Plain() { return TensorIOFormatPlain{}; }
-
-  static inline const TensorIOFormatNative Native() { return TensorIOFormatNative{}; }
-
-  static inline const TensorIOFormatLegacy Legacy() { return TensorIOFormatLegacy{}; }
-};
-
-template <typename T, int Layout, int rank, typename Format>
-class TensorWithFormat;
-// specialize for Layout=ColMajor, Layout=RowMajor and rank=0.
-template <typename T, int rank, typename Format>
-class TensorWithFormat<T, RowMajor, rank, Format> {
- public:
-  TensorWithFormat(const T& tensor, const Format& format) : t_tensor(tensor), t_format(format) {}
-
-  friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, RowMajor, rank, Format>& wf) {
-    // Evaluate the expression if needed
-    typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
-    TensorForcedEvalOp<const T> eval = wf.t_tensor.eval();
-    Evaluator tensor(eval, DefaultDevice());
-    tensor.evalSubExprsIfNeeded(NULL);
-    internal::TensorPrinter<Evaluator, rank, Format>::run(os, tensor, wf.t_format);
-    // Cleanup.
-    tensor.cleanup();
-    return os;
-  }
-
- protected:
-  T t_tensor;
-  Format t_format;
-};
-
-template <typename T, int rank, typename Format>
-class TensorWithFormat<T, ColMajor, rank, Format> {
- public:
-  TensorWithFormat(const T& tensor, const Format& format) : t_tensor(tensor), t_format(format) {}
-
-  friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, ColMajor, rank, Format>& wf) {
-    // Switch to RowMajor storage and print afterwards
-    typedef typename T::Index IndexType;
-    std::array<IndexType, rank> shuffle;
-    std::array<IndexType, rank> id;
-    std::iota(id.begin(), id.end(), IndexType(0));
-    std::copy(id.begin(), id.end(), shuffle.rbegin());
-    auto tensor_row_major = wf.t_tensor.swap_layout().shuffle(shuffle);
-
-    // Evaluate the expression if needed
-    typedef TensorEvaluator<const TensorForcedEvalOp<const decltype(tensor_row_major)>, DefaultDevice> Evaluator;
-    TensorForcedEvalOp<const decltype(tensor_row_major)> eval = tensor_row_major.eval();
-    Evaluator tensor(eval, DefaultDevice());
-    tensor.evalSubExprsIfNeeded(NULL);
-    internal::TensorPrinter<Evaluator, rank, Format>::run(os, tensor, wf.t_format);
-    // Cleanup.
-    tensor.cleanup();
-    return os;
-  }
-
- protected:
-  T t_tensor;
-  Format t_format;
-};
-
-template <typename T, typename Format>
-class TensorWithFormat<T, ColMajor, 0, Format> {
- public:
-  TensorWithFormat(const T& tensor, const Format& format) : t_tensor(tensor), t_format(format) {}
-
-  friend std::ostream& operator<<(std::ostream& os, const TensorWithFormat<T, ColMajor, 0, Format>& wf) {
-    // Evaluate the expression if needed
-    typedef TensorEvaluator<const TensorForcedEvalOp<const T>, DefaultDevice> Evaluator;
-    TensorForcedEvalOp<const T> eval = wf.t_tensor.eval();
-    Evaluator tensor(eval, DefaultDevice());
-    tensor.evalSubExprsIfNeeded(NULL);
-    internal::TensorPrinter<Evaluator, 0, Format>::run(os, tensor, wf.t_format);
-    // Cleanup.
-    tensor.cleanup();
-    return os;
-  }
-
- protected:
-  T t_tensor;
-  Format t_format;
-};
-
-namespace internal {
-
-// Default scalar printer.
-template <typename Scalar, typename Format, typename EnableIf = void>
-struct ScalarPrinter {
-  static void run(std::ostream& stream, const Scalar& scalar, const Format&) { stream << scalar; }
-};
-
-template <typename Scalar>
-struct ScalarPrinter<Scalar, TensorIOFormatNumpy, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
-  static void run(std::ostream& stream, const Scalar& scalar, const TensorIOFormatNumpy&) {
-    stream << numext::real(scalar) << "+" << numext::imag(scalar) << "j";
-  }
-};
-
-template <typename Scalar>
-struct ScalarPrinter<Scalar, TensorIOFormatNative, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
-  static void run(std::ostream& stream, const Scalar& scalar, const TensorIOFormatNative&) {
-    stream << "{" << numext::real(scalar) << ", " << numext::imag(scalar) << "}";
-  }
-};
-
-template <typename Tensor, std::size_t rank, typename Format, typename EnableIf>
-struct TensorPrinter {
-  using Scalar = std::remove_const_t<typename Tensor::Scalar>;
-
-  static void run(std::ostream& s, const Tensor& tensor, const Format& fmt) {
-    typedef typename Tensor::Index IndexType;
-
-    eigen_assert(Tensor::Layout == RowMajor);
-    typedef std::conditional_t<is_same<Scalar, char>::value || is_same<Scalar, unsigned char>::value ||
-                                   is_same<Scalar, numext::int8_t>::value || is_same<Scalar, numext::uint8_t>::value,
-                               int,
-                               std::conditional_t<is_same<Scalar, std::complex<char>>::value ||
-                                                      is_same<Scalar, std::complex<unsigned char>>::value ||
-                                                      is_same<Scalar, std::complex<numext::int8_t>>::value ||
-                                                      is_same<Scalar, std::complex<numext::uint8_t>>::value,
-                                                  std::complex<int>, const Scalar&>>
-        PrintType;
-
-    const IndexType total_size = array_prod(tensor.dimensions());
-
-    std::streamsize explicit_precision;
-    if (fmt.precision == StreamPrecision) {
-      explicit_precision = 0;
-    } else if (fmt.precision == FullPrecision) {
-      if (NumTraits<Scalar>::IsInteger) {
-        explicit_precision = 0;
-      } else {
-        explicit_precision = significant_decimals_impl<Scalar>::run();
-      }
-    } else {
-      explicit_precision = fmt.precision;
-    }
-
-    std::streamsize old_precision = 0;
-    if (explicit_precision) old_precision = s.precision(explicit_precision);
-
-    IndexType width = 0;
-    bool align_cols = !(fmt.flags & DontAlignCols);
-    if (align_cols) {
-      // compute the largest width
-      for (IndexType i = 0; i < total_size; i++) {
-        std::stringstream sstr;
-        sstr.copyfmt(s);
-        ScalarPrinter<Scalar, Format>::run(sstr, static_cast<PrintType>(tensor.data()[i]), fmt);
-        width = std::max<IndexType>(width, IndexType(sstr.str().length()));
-      }
-    }
-    s << fmt.tenPrefix;
-    for (IndexType i = 0; i < total_size; i++) {
-      std::array<bool, rank> is_at_end{};
-      std::array<bool, rank> is_at_begin{};
-
-      // is the ith element the end of an coeff (always true), of a row, of a matrix, ...?
-      for (std::size_t k = 0; k < rank; k++) {
-        if ((i + 1) % (std::accumulate(tensor.dimensions().rbegin(), tensor.dimensions().rbegin() + k, 1,
-                                       std::multiplies<IndexType>())) ==
-            0) {
-          is_at_end[k] = true;
-        }
-      }
-
-      // is the ith element the begin of an coeff (always true), of a row, of a matrix, ...?
-      for (std::size_t k = 0; k < rank; k++) {
-        if (i % (std::accumulate(tensor.dimensions().rbegin(), tensor.dimensions().rbegin() + k, 1,
-                                 std::multiplies<IndexType>())) ==
-            0) {
-          is_at_begin[k] = true;
-        }
-      }
-
-      // do we have a line break?
-      bool is_at_begin_after_newline = false;
-      for (std::size_t k = 0; k < rank; k++) {
-        if (is_at_begin[k]) {
-          std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
-          if (fmt.separator[separator_index].find('\n') != std::string::npos) {
-            is_at_begin_after_newline = true;
-          }
-        }
-      }
-
-      bool is_at_end_before_newline = false;
-      for (std::size_t k = 0; k < rank; k++) {
-        if (is_at_end[k]) {
-          std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
-          if (fmt.separator[separator_index].find('\n') != std::string::npos) {
-            is_at_end_before_newline = true;
-          }
-        }
-      }
-
-      std::stringstream suffix, prefix, separator;
-      for (std::size_t k = 0; k < rank; k++) {
-        std::size_t suffix_index = (k < fmt.suffix.size()) ? k : fmt.suffix.size() - 1;
-        if (is_at_end[k]) {
-          suffix << fmt.suffix[suffix_index];
-        }
-      }
-      for (std::size_t k = 0; k < rank; k++) {
-        std::size_t separator_index = (k < fmt.separator.size()) ? k : fmt.separator.size() - 1;
-        if (is_at_end[k] &&
-            (!is_at_end_before_newline || fmt.separator[separator_index].find('\n') != std::string::npos)) {
-          separator << fmt.separator[separator_index];
-        }
-      }
-      for (std::size_t k = 0; k < rank; k++) {
-        std::size_t spacer_index = (k < fmt.spacer.size()) ? k : fmt.spacer.size() - 1;
-        if (i != 0 && is_at_begin_after_newline && (!is_at_begin[k] || k == 0)) {
-          prefix << fmt.spacer[spacer_index];
-        }
-      }
-      for (int k = rank - 1; k >= 0; k--) {
-        std::size_t prefix_index = (static_cast<std::size_t>(k) < fmt.prefix.size()) ? k : fmt.prefix.size() - 1;
-        if (is_at_begin[k]) {
-          prefix << fmt.prefix[prefix_index];
-        }
-      }
-
-      s << prefix.str();
-      // So we don't mess around with formatting, output scalar to a string stream, and adjust the width/fill manually.
-      std::stringstream sstr;
-      sstr.copyfmt(s);
-      ScalarPrinter<Scalar, Format>::run(sstr, static_cast<PrintType>(tensor.data()[i]), fmt);
-      std::string scalar_str = sstr.str();
-      IndexType scalar_width = scalar_str.length();
-      if (width && scalar_width < width) {
-        std::string filler;
-        for (IndexType j = scalar_width; j < width; ++j) {
-          filler.push_back(fmt.fill);
-        }
-        s << filler;
-      }
-      s << scalar_str;
-      s << suffix.str();
-      if (i < total_size - 1) {
-        s << separator.str();
-      }
-    }
-    s << fmt.tenSuffix;
-    if (explicit_precision) s.precision(old_precision);
-  }
-};
-
-template <typename Tensor, std::size_t rank>
-struct TensorPrinter<Tensor, rank, TensorIOFormatLegacy, std::enable_if_t<rank != 0>> {
-  using Format = TensorIOFormatLegacy;
-  using Scalar = std::remove_const_t<typename Tensor::Scalar>;
-
-  static void run(std::ostream& s, const Tensor& tensor, const Format&) {
-    typedef typename Tensor::Index IndexType;
-    // backwards compatibility case: print tensor after reshaping to matrix of size dim(0) x
-    // (dim(1)*dim(2)*...*dim(rank-1)).
-    const IndexType total_size = internal::array_prod(tensor.dimensions());
-    if (total_size > 0) {
-      const IndexType first_dim = Eigen::internal::array_get<0>(tensor.dimensions());
-      Map<const Array<Scalar, Dynamic, Dynamic, Tensor::Layout>> matrix(tensor.data(), first_dim,
-                                                                        total_size / first_dim);
-      s << matrix;
-      return;
-    }
-  }
-};
-
-template <typename Tensor, typename Format>
-struct TensorPrinter<Tensor, 0, Format> {
-  static void run(std::ostream& s, const Tensor& tensor, const Format& fmt) {
-    using Scalar = std::remove_const_t<typename Tensor::Scalar>;
-
-    std::streamsize explicit_precision;
-    if (fmt.precision == StreamPrecision) {
-      explicit_precision = 0;
-    } else if (fmt.precision == FullPrecision) {
-      if (NumTraits<Scalar>::IsInteger) {
-        explicit_precision = 0;
-      } else {
-        explicit_precision = significant_decimals_impl<Scalar>::run();
-      }
-    } else {
-      explicit_precision = fmt.precision;
-    }
-
-    std::streamsize old_precision = 0;
-    if (explicit_precision) old_precision = s.precision(explicit_precision);
-    s << fmt.tenPrefix;
-    ScalarPrinter<Scalar, Format>::run(s, tensor.coeff(0), fmt);
-    s << fmt.tenSuffix;
-    if (explicit_precision) s.precision(old_precision);
-  }
-};
-
-}  // end namespace internal
-template <typename T>
-std::ostream& operator<<(std::ostream& s, const TensorBase<T, ReadOnlyAccessors>& t) {
-  s << t.format(TensorIOFormat::Plain());
-  return s;
-}
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_IO_H
diff --git a/unsupported/Eigen/src/Tensor/TensorImagePatch.h b/unsupported/Eigen/src/Tensor/TensorImagePatch.h
deleted file mode 100644
index 2f94ce5..0000000
--- a/unsupported/Eigen/src/Tensor/TensorImagePatch.h
+++ /dev/null
@@ -1,590 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_IMAGE_PATCH_H
-#define EIGEN_CXX11_TENSOR_TENSOR_IMAGE_PATCH_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <DenseIndex Rows, DenseIndex Cols, typename XprType>
-struct traits<TensorImagePatchOp<Rows, Cols, XprType> > : public traits<XprType> {
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions + 1;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <DenseIndex Rows, DenseIndex Cols, typename XprType>
-struct eval<TensorImagePatchOp<Rows, Cols, XprType>, Eigen::Dense> {
-  typedef const TensorImagePatchOp<Rows, Cols, XprType>& type;
-};
-
-template <DenseIndex Rows, DenseIndex Cols, typename XprType>
-struct nested<TensorImagePatchOp<Rows, Cols, XprType>, 1,
-              typename eval<TensorImagePatchOp<Rows, Cols, XprType> >::type> {
-  typedef TensorImagePatchOp<Rows, Cols, XprType> type;
-};
-
-template <typename Self, bool Vectorizable>
-struct ImagePatchCopyOp {
-  typedef typename Self::Index Index;
-  typedef typename Self::Scalar Scalar;
-  typedef typename Self::Impl Impl;
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Self& self, const Index num_coeff_to_copy,
-                                                        const Index dst_index, Scalar* dst_data,
-                                                        const Index src_index) {
-    const Impl& impl = self.impl();
-    for (Index i = 0; i < num_coeff_to_copy; ++i) {
-      dst_data[dst_index + i] = impl.coeff(src_index + i);
-    }
-  }
-};
-
-template <typename Self>
-struct ImagePatchCopyOp<Self, true> {
-  typedef typename Self::Index Index;
-  typedef typename Self::Scalar Scalar;
-  typedef typename Self::Impl Impl;
-  typedef typename packet_traits<Scalar>::type Packet;
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Self& self, const Index num_coeff_to_copy,
-                                                        const Index dst_index, Scalar* dst_data,
-                                                        const Index src_index) {
-    const Impl& impl = self.impl();
-    const Index packet_size = internal::unpacket_traits<Packet>::size;
-    const Index vectorized_size = (num_coeff_to_copy / packet_size) * packet_size;
-    for (Index i = 0; i < vectorized_size; i += packet_size) {
-      Packet p = impl.template packet<Unaligned>(src_index + i);
-      internal::pstoret<Scalar, Packet, Unaligned>(dst_data + dst_index + i, p);
-    }
-    for (Index i = vectorized_size; i < num_coeff_to_copy; ++i) {
-      dst_data[dst_index + i] = impl.coeff(src_index + i);
-    }
-  }
-};
-
-template <typename Self>
-struct ImagePatchPaddingOp {
-  typedef typename Self::Index Index;
-  typedef typename Self::Scalar Scalar;
-  typedef typename packet_traits<Scalar>::type Packet;
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Run(const Index num_coeff_to_pad, const Scalar padding_value,
-                                                        const Index dst_index, Scalar* dst_data) {
-    const Index packet_size = internal::unpacket_traits<Packet>::size;
-    const Packet padded_packet = internal::pset1<Packet>(padding_value);
-    const Index vectorized_size = (num_coeff_to_pad / packet_size) * packet_size;
-    for (Index i = 0; i < vectorized_size; i += packet_size) {
-      internal::pstoret<Scalar, Packet, Unaligned>(dst_data + dst_index + i, padded_packet);
-    }
-    for (Index i = vectorized_size; i < num_coeff_to_pad; ++i) {
-      dst_data[dst_index + i] = padding_value;
-    }
-  }
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Patch extraction specialized for image processing.
- * This assumes that the input has a least 3 dimensions ordered as follow:
- *  1st dimension: channels (of size d)
- *  2nd dimension: rows (of size r)
- *  3rd dimension: columns (of size c)
- *  There can be additional dimensions such as time (for video) or batch (for
- * bulk processing after the first 3.
- * Calling the image patch code with patch_rows and patch_cols is equivalent
- * to calling the regular patch extraction code with parameters d, patch_rows,
- * patch_cols, and 1 for all the additional dimensions.
- */
-template <DenseIndex Rows, DenseIndex Cols, typename XprType>
-class TensorImagePatchOp : public TensorBase<TensorImagePatchOp<Rows, Cols, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorImagePatchOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorImagePatchOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorImagePatchOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorImagePatchOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorImagePatchOp(const XprType& expr, DenseIndex patch_rows,
-                                                           DenseIndex patch_cols, DenseIndex row_strides,
-                                                           DenseIndex col_strides, DenseIndex in_row_strides,
-                                                           DenseIndex in_col_strides, DenseIndex row_inflate_strides,
-                                                           DenseIndex col_inflate_strides, PaddingType padding_type,
-                                                           Scalar padding_value)
-      : m_xpr(expr),
-        m_patch_rows(patch_rows),
-        m_patch_cols(patch_cols),
-        m_row_strides(row_strides),
-        m_col_strides(col_strides),
-        m_in_row_strides(in_row_strides),
-        m_in_col_strides(in_col_strides),
-        m_row_inflate_strides(row_inflate_strides),
-        m_col_inflate_strides(col_inflate_strides),
-        m_padding_explicit(false),
-        m_padding_top(0),
-        m_padding_bottom(0),
-        m_padding_left(0),
-        m_padding_right(0),
-        m_padding_type(padding_type),
-        m_padding_value(padding_value) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorImagePatchOp(const XprType& expr, DenseIndex patch_rows,
-                                                           DenseIndex patch_cols, DenseIndex row_strides,
-                                                           DenseIndex col_strides, DenseIndex in_row_strides,
-                                                           DenseIndex in_col_strides, DenseIndex row_inflate_strides,
-                                                           DenseIndex col_inflate_strides, DenseIndex padding_top,
-                                                           DenseIndex padding_bottom, DenseIndex padding_left,
-                                                           DenseIndex padding_right, Scalar padding_value)
-      : m_xpr(expr),
-        m_patch_rows(patch_rows),
-        m_patch_cols(patch_cols),
-        m_row_strides(row_strides),
-        m_col_strides(col_strides),
-        m_in_row_strides(in_row_strides),
-        m_in_col_strides(in_col_strides),
-        m_row_inflate_strides(row_inflate_strides),
-        m_col_inflate_strides(col_inflate_strides),
-        m_padding_explicit(true),
-        m_padding_top(padding_top),
-        m_padding_bottom(padding_bottom),
-        m_padding_left(padding_left),
-        m_padding_right(padding_right),
-        m_padding_type(PADDING_VALID),
-        m_padding_value(padding_value) {}
-
-  EIGEN_DEVICE_FUNC DenseIndex patch_rows() const { return m_patch_rows; }
-  EIGEN_DEVICE_FUNC DenseIndex patch_cols() const { return m_patch_cols; }
-  EIGEN_DEVICE_FUNC DenseIndex row_strides() const { return m_row_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex col_strides() const { return m_col_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex in_row_strides() const { return m_in_row_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex in_col_strides() const { return m_in_col_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex row_inflate_strides() const { return m_row_inflate_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex col_inflate_strides() const { return m_col_inflate_strides; }
-  EIGEN_DEVICE_FUNC bool padding_explicit() const { return m_padding_explicit; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_top() const { return m_padding_top; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_bottom() const { return m_padding_bottom; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_left() const { return m_padding_left; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_right() const { return m_padding_right; }
-  EIGEN_DEVICE_FUNC PaddingType padding_type() const { return m_padding_type; }
-  EIGEN_DEVICE_FUNC Scalar padding_value() const { return m_padding_value; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const DenseIndex m_patch_rows;
-  const DenseIndex m_patch_cols;
-  const DenseIndex m_row_strides;
-  const DenseIndex m_col_strides;
-  const DenseIndex m_in_row_strides;
-  const DenseIndex m_in_col_strides;
-  const DenseIndex m_row_inflate_strides;
-  const DenseIndex m_col_inflate_strides;
-  const bool m_padding_explicit;
-  const DenseIndex m_padding_top;
-  const DenseIndex m_padding_bottom;
-  const DenseIndex m_padding_left;
-  const DenseIndex m_padding_right;
-  const PaddingType m_padding_type;
-  const Scalar m_padding_value;
-};
-
-// Eval as rvalue
-template <DenseIndex Rows, DenseIndex Cols, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorImagePatchOp<Rows, Cols, ArgType>, Device> {
-  typedef TensorImagePatchOp<Rows, Cols, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumInputDims =
-      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  static constexpr int NumDims = NumInputDims + 1;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef TensorEvaluator<const TensorImagePatchOp<Rows, Cols, ArgType>, Device> Self;
-  typedef TensorEvaluator<ArgType, Device> Impl;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = true,
-    CoordAccess = false,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_device(device), m_impl(op.expression(), device) {
-    EIGEN_STATIC_ASSERT((NumDims >= 4), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    m_paddingValue = op.padding_value();
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-
-    // Caches a few variables.
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputDepth = input_dims[0];
-      m_inputRows = input_dims[1];
-      m_inputCols = input_dims[2];
-    } else {
-      m_inputDepth = input_dims[NumInputDims - 1];
-      m_inputRows = input_dims[NumInputDims - 2];
-      m_inputCols = input_dims[NumInputDims - 3];
-    }
-
-    m_row_strides = op.row_strides();
-    m_col_strides = op.col_strides();
-
-    // Input strides and effective input/patch size
-    m_in_row_strides = op.in_row_strides();
-    m_in_col_strides = op.in_col_strides();
-    m_row_inflate_strides = op.row_inflate_strides();
-    m_col_inflate_strides = op.col_inflate_strides();
-    // The "effective" input rows and input cols are the input rows and cols
-    // after inflating them with zeros.
-    // For examples, a 2x3 matrix with row_inflate_strides and
-    // col_inflate_strides of 2 comes from:
-    //   A B C
-    //   D E F
-    //
-    // to a matrix is 3 x 5:
-    //
-    //   A . B . C
-    //   . . . . .
-    //   D . E . F
-
-    m_input_rows_eff = (m_inputRows - 1) * m_row_inflate_strides + 1;
-    m_input_cols_eff = (m_inputCols - 1) * m_col_inflate_strides + 1;
-    m_patch_rows_eff = op.patch_rows() + (op.patch_rows() - 1) * (m_in_row_strides - 1);
-    m_patch_cols_eff = op.patch_cols() + (op.patch_cols() - 1) * (m_in_col_strides - 1);
-
-    if (op.padding_explicit()) {
-      m_outputRows = numext::ceil((m_input_rows_eff + op.padding_top() + op.padding_bottom() - m_patch_rows_eff + 1.f) /
-                                  static_cast<float>(m_row_strides));
-      m_outputCols = numext::ceil((m_input_cols_eff + op.padding_left() + op.padding_right() - m_patch_cols_eff + 1.f) /
-                                  static_cast<float>(m_col_strides));
-      m_rowPaddingTop = op.padding_top();
-      m_colPaddingLeft = op.padding_left();
-    } else {
-      // Computing padding from the type
-      switch (op.padding_type()) {
-        case PADDING_VALID:
-          m_outputRows = numext::ceil((m_input_rows_eff - m_patch_rows_eff + 1.f) / static_cast<float>(m_row_strides));
-          m_outputCols = numext::ceil((m_input_cols_eff - m_patch_cols_eff + 1.f) / static_cast<float>(m_col_strides));
-          // Calculate the padding
-          m_rowPaddingTop =
-              numext::maxi<Index>(0, ((m_outputRows - 1) * m_row_strides + m_patch_rows_eff - m_input_rows_eff) / 2);
-          m_colPaddingLeft =
-              numext::maxi<Index>(0, ((m_outputCols - 1) * m_col_strides + m_patch_cols_eff - m_input_cols_eff) / 2);
-          break;
-        case PADDING_SAME:
-          m_outputRows = numext::ceil(m_input_rows_eff / static_cast<float>(m_row_strides));
-          m_outputCols = numext::ceil(m_input_cols_eff / static_cast<float>(m_col_strides));
-          // Calculate the padding
-          m_rowPaddingTop = ((m_outputRows - 1) * m_row_strides + m_patch_rows_eff - m_input_rows_eff) / 2;
-          m_colPaddingLeft = ((m_outputCols - 1) * m_col_strides + m_patch_cols_eff - m_input_cols_eff) / 2;
-          // The padding size calculation for PADDING_SAME has been updated to
-          // be consistent with how TensorFlow extracts its paddings.
-          m_rowPaddingTop = numext::maxi<Index>(0, m_rowPaddingTop);
-          m_colPaddingLeft = numext::maxi<Index>(0, m_colPaddingLeft);
-          break;
-        default:
-          eigen_assert(false && "unexpected padding");
-          m_outputCols = 0;  // Silence the uninitialized warning.
-          m_outputRows = 0;  // Silence the uninitialized warning.
-      }
-    }
-    eigen_assert(m_outputRows > 0);
-    eigen_assert(m_outputCols > 0);
-
-    // Dimensions for result of extraction.
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      // ColMajor
-      // 0: depth
-      // 1: patch_rows
-      // 2: patch_cols
-      // 3: number of patches
-      // 4 and beyond: anything else (such as batch).
-      m_dimensions[0] = input_dims[0];
-      m_dimensions[1] = op.patch_rows();
-      m_dimensions[2] = op.patch_cols();
-      m_dimensions[3] = m_outputRows * m_outputCols;
-      for (int i = 4; i < NumDims; ++i) {
-        m_dimensions[i] = input_dims[i - 1];
-      }
-    } else {
-      // RowMajor
-      // NumDims-1: depth
-      // NumDims-2: patch_rows
-      // NumDims-3: patch_cols
-      // NumDims-4: number of patches
-      // NumDims-5 and beyond: anything else (such as batch).
-      m_dimensions[NumDims - 1] = input_dims[NumInputDims - 1];
-      m_dimensions[NumDims - 2] = op.patch_rows();
-      m_dimensions[NumDims - 3] = op.patch_cols();
-      m_dimensions[NumDims - 4] = m_outputRows * m_outputCols;
-      for (int i = NumDims - 5; i >= 0; --i) {
-        m_dimensions[i] = input_dims[i];
-      }
-    }
-
-    // Strides for moving the patch in various dimensions.
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_colStride = m_dimensions[1];
-      m_patchStride = m_colStride * m_dimensions[2] * m_dimensions[0];
-      m_otherStride = m_patchStride * m_dimensions[3];
-    } else {
-      m_colStride = m_dimensions[NumDims - 2];
-      m_patchStride = m_colStride * m_dimensions[NumDims - 3] * m_dimensions[NumDims - 1];
-      m_otherStride = m_patchStride * m_dimensions[NumDims - 4];
-    }
-
-    // Strides for navigating through the input tensor.
-    m_rowInputStride = m_inputDepth;
-    m_colInputStride = m_inputDepth * m_inputRows;
-    m_patchInputStride = m_inputDepth * m_inputRows * m_inputCols;
-
-    // Fast representations of different variables.
-    m_fastOtherStride = internal::TensorIntDivisor<Index>(m_otherStride);
-    m_fastPatchStride = internal::TensorIntDivisor<Index>(m_patchStride);
-    m_fastColStride = internal::TensorIntDivisor<Index>(m_colStride);
-    m_fastInflateRowStride = internal::TensorIntDivisor<Index>(m_row_inflate_strides);
-    m_fastInflateColStride = internal::TensorIntDivisor<Index>(m_col_inflate_strides);
-    m_fastInputColsEff = internal::TensorIntDivisor<Index>(m_input_cols_eff);
-
-    // Number of patches in the width dimension.
-    m_fastOutputRows = internal::TensorIntDivisor<Index>(m_outputRows);
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[0]);
-    } else {
-      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[NumDims - 1]);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    // Patch index corresponding to the passed in index.
-    const Index patchIndex = index / m_fastPatchStride;
-    // Find the offset of the element wrt the location of the first element.
-    const Index patchOffset = (index - patchIndex * m_patchStride) / m_fastOutputDepth;
-
-    // Other ways to index this element.
-    const Index otherIndex = (NumDims == 4) ? 0 : index / m_fastOtherStride;
-    const Index patch2DIndex = (NumDims == 4) ? patchIndex : (index - otherIndex * m_otherStride) / m_fastPatchStride;
-
-    // Calculate col index in the input original tensor.
-    const Index colIndex = patch2DIndex / m_fastOutputRows;
-    const Index colOffset = patchOffset / m_fastColStride;
-    const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
-    const Index origInputCol =
-        (m_col_inflate_strides == 1) ? inputCol : ((inputCol >= 0) ? (inputCol / m_fastInflateColStride) : 0);
-    if (inputCol < 0 || inputCol >= m_input_cols_eff ||
-        ((m_col_inflate_strides != 1) && (inputCol != origInputCol * m_col_inflate_strides))) {
-      return Scalar(m_paddingValue);
-    }
-
-    // Calculate row index in the original input tensor.
-    const Index rowIndex = patch2DIndex - colIndex * m_outputRows;
-    const Index rowOffset = patchOffset - colOffset * m_colStride;
-    const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
-    const Index origInputRow =
-        (m_row_inflate_strides == 1) ? inputRow : ((inputRow >= 0) ? (inputRow / m_fastInflateRowStride) : 0);
-    if (inputRow < 0 || inputRow >= m_input_rows_eff ||
-        ((m_row_inflate_strides != 1) && (inputRow != origInputRow * m_row_inflate_strides))) {
-      return Scalar(m_paddingValue);
-    }
-
-    const int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
-    const Index depth = index - (index / m_fastOutputDepth) * m_dimensions[depth_index];
-
-    const Index inputIndex =
-        depth + origInputRow * m_rowInputStride + origInputCol * m_colInputStride + otherIndex * m_patchInputStride;
-    return m_impl.coeff(inputIndex);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    if (m_in_row_strides != 1 || m_in_col_strides != 1 || m_row_inflate_strides != 1 || m_col_inflate_strides != 1) {
-      return packetWithPossibleZero(index);
-    }
-
-    const Index indices[2] = {index, index + PacketSize - 1};
-    const Index patchIndex = indices[0] / m_fastPatchStride;
-    if (patchIndex != indices[1] / m_fastPatchStride) {
-      return packetWithPossibleZero(index);
-    }
-    const Index otherIndex = (NumDims == 4) ? 0 : indices[0] / m_fastOtherStride;
-    eigen_assert(otherIndex == indices[1] / m_fastOtherStride);
-
-    // Find the offset of the element wrt the location of the first element.
-    const Index patchOffsets[2] = {(indices[0] - patchIndex * m_patchStride) / m_fastOutputDepth,
-                                   (indices[1] - patchIndex * m_patchStride) / m_fastOutputDepth};
-
-    const Index patch2DIndex =
-        (NumDims == 4) ? patchIndex : (indices[0] - otherIndex * m_otherStride) / m_fastPatchStride;
-    eigen_assert(patch2DIndex == (indices[1] - otherIndex * m_otherStride) / m_fastPatchStride);
-
-    const Index colIndex = patch2DIndex / m_fastOutputRows;
-    const Index colOffsets[2] = {patchOffsets[0] / m_fastColStride, patchOffsets[1] / m_fastColStride};
-
-    // Calculate col indices in the original input tensor.
-    const Index inputCols[2] = {colIndex * m_col_strides + colOffsets[0] - m_colPaddingLeft,
-                                colIndex * m_col_strides + colOffsets[1] - m_colPaddingLeft};
-    if (inputCols[1] < 0 || inputCols[0] >= m_inputCols) {
-      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
-    }
-
-    if (inputCols[0] == inputCols[1]) {
-      const Index rowIndex = patch2DIndex - colIndex * m_outputRows;
-      const Index rowOffsets[2] = {patchOffsets[0] - colOffsets[0] * m_colStride,
-                                   patchOffsets[1] - colOffsets[1] * m_colStride};
-      eigen_assert(rowOffsets[0] <= rowOffsets[1]);
-      // Calculate row indices in the original input tensor.
-      const Index inputRows[2] = {rowIndex * m_row_strides + rowOffsets[0] - m_rowPaddingTop,
-                                  rowIndex * m_row_strides + rowOffsets[1] - m_rowPaddingTop};
-
-      if (inputRows[1] < 0 || inputRows[0] >= m_inputRows) {
-        return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
-      }
-
-      if (inputRows[0] >= 0 && inputRows[1] < m_inputRows) {
-        // no padding
-        const int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
-        const Index depth = index - (index / m_fastOutputDepth) * m_dimensions[depth_index];
-        const Index inputIndex =
-            depth + inputRows[0] * m_rowInputStride + inputCols[0] * m_colInputStride + otherIndex * m_patchInputStride;
-        return m_impl.template packet<Unaligned>(inputIndex);
-      }
-    }
-
-    return packetWithPossibleZero(index);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowPaddingTop() const { return m_rowPaddingTop; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colPaddingLeft() const { return m_colPaddingLeft; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputRows() const { return m_outputRows; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputCols() const { return m_outputCols; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userRowStride() const { return m_row_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userColStride() const { return m_col_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInRowStride() const { return m_in_row_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInColStride() const { return m_in_col_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowInflateStride() const { return m_row_inflate_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colInflateStride() const { return m_col_inflate_strides; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    // We conservatively estimate the cost for the code path where the computed
-    // index is inside the original image and
-    // TensorEvaluator<ArgType, Device>::CoordAccess is false.
-    const double compute_cost =
-        3 * TensorOpCost::DivCost<Index>() + 6 * TensorOpCost::MulCost<Index>() + 8 * TensorOpCost::MulCost<Index>();
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
-  }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetWithPossibleZero(Index index) const {
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  Dimensions m_dimensions;
-
-  Index m_otherStride;
-  Index m_patchStride;
-  Index m_colStride;
-  Index m_row_strides;
-  Index m_col_strides;
-
-  Index m_in_row_strides;
-  Index m_in_col_strides;
-  Index m_row_inflate_strides;
-  Index m_col_inflate_strides;
-
-  Index m_input_rows_eff;
-  Index m_input_cols_eff;
-  Index m_patch_rows_eff;
-  Index m_patch_cols_eff;
-
-  internal::TensorIntDivisor<Index> m_fastOtherStride;
-  internal::TensorIntDivisor<Index> m_fastPatchStride;
-  internal::TensorIntDivisor<Index> m_fastColStride;
-  internal::TensorIntDivisor<Index> m_fastInflateRowStride;
-  internal::TensorIntDivisor<Index> m_fastInflateColStride;
-  internal::TensorIntDivisor<Index> m_fastInputColsEff;
-
-  Index m_rowInputStride;
-  Index m_colInputStride;
-  Index m_patchInputStride;
-
-  Index m_inputDepth;
-  Index m_inputRows;
-  Index m_inputCols;
-
-  Index m_outputRows;
-  Index m_outputCols;
-
-  Index m_rowPaddingTop;
-  Index m_colPaddingLeft;
-
-  internal::TensorIntDivisor<Index> m_fastOutputRows;
-  internal::TensorIntDivisor<Index> m_fastOutputDepth;
-
-  Scalar m_paddingValue;
-
-  const Device EIGEN_DEVICE_REF m_device;
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_IMAGE_PATCH_H
diff --git a/unsupported/Eigen/src/Tensor/TensorIndexList.h b/unsupported/Eigen/src/Tensor/TensorIndexList.h
deleted file mode 100644
index d244b50..0000000
--- a/unsupported/Eigen/src/Tensor/TensorIndexList.h
+++ /dev/null
@@ -1,622 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_INDEX_LIST_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INDEX_LIST_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <Index n>
-struct type2index {
-  static constexpr Index value = n;
-  EIGEN_DEVICE_FUNC constexpr operator Index() const { return n; }
-  EIGEN_DEVICE_FUNC void set(Index val) {
-    EIGEN_ONLY_USED_FOR_DEBUG(val);
-    eigen_assert(val == n);
-  }
-};
-
-// This can be used with IndexPairList to get compile-time constant pairs,
-// such as IndexPairList<type2indexpair<1,2>, type2indexpair<3,4>>().
-template <Index f, Index s>
-struct type2indexpair {
-  static constexpr Index first = f;
-  static constexpr Index second = s;
-
-  constexpr EIGEN_DEVICE_FUNC operator IndexPair<Index>() const { return IndexPair<Index>(f, s); }
-
-  EIGEN_DEVICE_FUNC void set(const IndexPair<Index>& val) {
-    EIGEN_ONLY_USED_FOR_DEBUG(val);
-    eigen_assert(val.first == f);
-    eigen_assert(val.second == s);
-  }
-};
-
-template <Index n>
-struct NumTraits<type2index<n>> {
-  typedef Index Real;
-  enum { IsComplex = 0, RequireInitialization = false, ReadCost = 1, AddCost = 1, MulCost = 1 };
-
-  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real epsilon() { return 0; }
-  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real dummy_precision() { return 0; }
-  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real highest() { return n; }
-  EIGEN_DEVICE_FUNC static constexpr EIGEN_STRONG_INLINE Real lowest() { return n; }
-};
-
-namespace internal {
-template <typename T>
-EIGEN_DEVICE_FUNC void update_value(T& val, Index new_val) {
-  val = internal::convert_index<T>(new_val);
-}
-template <Index n>
-EIGEN_DEVICE_FUNC void update_value(type2index<n>& val, Index new_val) {
-  val.set(new_val);
-}
-
-template <typename T>
-EIGEN_DEVICE_FUNC void update_value(T& val, IndexPair<Index> new_val) {
-  val = new_val;
-}
-template <Index f, Index s>
-EIGEN_DEVICE_FUNC void update_value(type2indexpair<f, s>& val, IndexPair<Index> new_val) {
-  val.set(new_val);
-}
-
-template <typename T>
-struct is_compile_time_constant {
-  static constexpr bool value = false;
-};
-
-template <Index idx>
-struct is_compile_time_constant<type2index<idx>> {
-  static constexpr bool value = true;
-};
-template <Index idx>
-struct is_compile_time_constant<const type2index<idx>> {
-  static constexpr bool value = true;
-};
-template <Index idx>
-struct is_compile_time_constant<type2index<idx>&> {
-  static constexpr bool value = true;
-};
-template <Index idx>
-struct is_compile_time_constant<const type2index<idx>&> {
-  static constexpr bool value = true;
-};
-
-template <Index f, Index s>
-struct is_compile_time_constant<type2indexpair<f, s>> {
-  static constexpr bool value = true;
-};
-template <Index f, Index s>
-struct is_compile_time_constant<const type2indexpair<f, s>> {
-  static constexpr bool value = true;
-};
-template <Index f, Index s>
-struct is_compile_time_constant<type2indexpair<f, s>&> {
-  static constexpr bool value = true;
-};
-template <Index f, Index s>
-struct is_compile_time_constant<const type2indexpair<f, s>&> {
-  static constexpr bool value = true;
-};
-
-template <typename... T>
-struct IndexTuple;
-
-template <typename T, typename... O>
-struct IndexTuple<T, O...> {
-  EIGEN_DEVICE_FUNC constexpr IndexTuple() : head(), others() {}
-  EIGEN_DEVICE_FUNC constexpr IndexTuple(const T& v, const O... o) : head(v), others(o...) {}
-
-  static constexpr int count = 1 + sizeof...(O);
-  T head;
-  IndexTuple<O...> others;
-  typedef T Head;
-  typedef IndexTuple<O...> Other;
-};
-
-template <typename T>
-struct IndexTuple<T> {
-  EIGEN_DEVICE_FUNC constexpr IndexTuple() : head() {}
-  EIGEN_DEVICE_FUNC constexpr IndexTuple(const T& v) : head(v) {}
-
-  constexpr static int count = 1;
-  T head;
-  typedef T Head;
-};
-
-template <int N, typename... T>
-struct IndexTupleExtractor;
-
-template <int N, typename T, typename... O>
-struct IndexTupleExtractor<N, T, O...> {
-  typedef typename IndexTupleExtractor<N - 1, O...>::ValType ValType;
-
-  EIGEN_DEVICE_FUNC static constexpr ValType& get_val(IndexTuple<T, O...>& val) {
-    return IndexTupleExtractor<N - 1, O...>::get_val(val.others);
-  }
-
-  EIGEN_DEVICE_FUNC static constexpr const ValType& get_val(const IndexTuple<T, O...>& val) {
-    return IndexTupleExtractor<N - 1, O...>::get_val(val.others);
-  }
-  template <typename V>
-  EIGEN_DEVICE_FUNC static void set_val(IndexTuple<T, O...>& val, V& new_val) {
-    IndexTupleExtractor<N - 1, O...>::set_val(val.others, new_val);
-  }
-};
-
-template <typename T, typename... O>
-struct IndexTupleExtractor<0, T, O...> {
-  typedef T ValType;
-
-  EIGEN_DEVICE_FUNC static constexpr ValType& get_val(IndexTuple<T, O...>& val) { return val.head; }
-  EIGEN_DEVICE_FUNC static constexpr const ValType& get_val(const IndexTuple<T, O...>& val) { return val.head; }
-  template <typename V>
-  EIGEN_DEVICE_FUNC static void set_val(IndexTuple<T, O...>& val, V& new_val) {
-    val.head = new_val;
-  }
-};
-
-template <int N, typename T, typename... O>
-EIGEN_DEVICE_FUNC constexpr typename IndexTupleExtractor<N, T, O...>::ValType& array_get(IndexTuple<T, O...>& tuple) {
-  return IndexTupleExtractor<N, T, O...>::get_val(tuple);
-}
-template <int N, typename T, typename... O>
-EIGEN_DEVICE_FUNC constexpr const typename IndexTupleExtractor<N, T, O...>::ValType& array_get(
-    const IndexTuple<T, O...>& tuple) {
-  return IndexTupleExtractor<N, T, O...>::get_val(tuple);
-}
-template <typename T, typename... O>
-struct array_size<IndexTuple<T, O...>> {
-  static constexpr size_t value = IndexTuple<T, O...>::count;
-};
-template <typename T, typename... O>
-struct array_size<const IndexTuple<T, O...>> {
-  static constexpr size_t value = IndexTuple<T, O...>::count;
-};
-
-template <Index Idx, typename ValueT>
-struct tuple_coeff {
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr ValueT get(const Index i, const IndexTuple<T...>& t) {
-    return (i == Idx ? array_get<Idx>(t) : tuple_coeff<Idx - 1, ValueT>::get(i, t));
-  }
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static void set(const Index i, IndexTuple<T...>& t, const ValueT& value) {
-    if (i == Idx) {
-      update_value(array_get<Idx>(t), value);
-    } else {
-      tuple_coeff<Idx - 1, ValueT>::set(i, t, value);
-    }
-  }
-
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr bool value_known_statically(const Index i, const IndexTuple<T...>& t) {
-    return ((i == Idx) && is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value) ||
-           tuple_coeff<Idx - 1, ValueT>::value_known_statically(i, t);
-  }
-
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_known_statically(const IndexTuple<T...>& t) {
-    return is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value &&
-           tuple_coeff<Idx - 1, ValueT>::values_up_to_known_statically(t);
-  }
-
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_statically_known_to_increase(const IndexTuple<T...>& t) {
-    return is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value &&
-           is_compile_time_constant<typename IndexTupleExtractor<Idx, T...>::ValType>::value &&
-           array_get<Idx>(t) > array_get<Idx - 1>(t) &&
-           tuple_coeff<Idx - 1, ValueT>::values_up_to_statically_known_to_increase(t);
-  }
-};
-
-template <typename ValueT>
-struct tuple_coeff<0, ValueT> {
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr ValueT get(const Index /*i*/, const IndexTuple<T...>& t) {
-    return array_get<0>(t);
-  }
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static void set(const Index i, IndexTuple<T...>& t, const ValueT value) {
-    EIGEN_ONLY_USED_FOR_DEBUG(i);
-    eigen_assert(i == 0);
-    update_value(array_get<0>(t), value);
-  }
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr bool value_known_statically(const Index i, const IndexTuple<T...>&) {
-    return is_compile_time_constant<typename IndexTupleExtractor<0, T...>::ValType>::value && (i == 0);
-  }
-
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_known_statically(const IndexTuple<T...>&) {
-    return is_compile_time_constant<typename IndexTupleExtractor<0, T...>::ValType>::value;
-  }
-
-  template <typename... T>
-  EIGEN_DEVICE_FUNC static constexpr bool values_up_to_statically_known_to_increase(const IndexTuple<T...>&) {
-    return true;
-  }
-};
-}  // namespace internal
-
-/** \internal
- *
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Set of classes used to encode a set of Tensor dimensions/indices.
- *
- * The indices in the list can be known at compile time or at runtime. A mix
- * of static and dynamic indices can also be provided if needed. The tensor
- * code will attempt to take advantage of the indices that are known at
- * compile time to optimize the code it generates.
- *
- * This functionality requires a c++11 compliant compiler. If your compiler
- * is older you need to use arrays of indices instead.
- *
- * Several examples are provided in the cxx11_tensor_index_list.cpp file.
- *
- * \sa Tensor
- */
-
-template <typename FirstType, typename... OtherTypes>
-struct IndexList : internal::IndexTuple<FirstType, OtherTypes...> {
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr Index operator[](const Index i) const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::get(i, *this);
-  }
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr Index get(const Index i) const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::get(i, *this);
-  }
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC void set(const Index i, const Index value) {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::set(i, *this, value);
-  }
-
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr std::size_t size() const { return 1 + sizeof...(OtherTypes); };
-
-  EIGEN_DEVICE_FUNC constexpr IndexList(const internal::IndexTuple<FirstType, OtherTypes...>& other)
-      : internal::IndexTuple<FirstType, OtherTypes...>(other) {}
-  EIGEN_DEVICE_FUNC constexpr IndexList(FirstType& first, OtherTypes... other)
-      : internal::IndexTuple<FirstType, OtherTypes...>(first, other...) {}
-  EIGEN_DEVICE_FUNC constexpr IndexList() : internal::IndexTuple<FirstType, OtherTypes...>() {}
-
-  EIGEN_DEVICE_FUNC constexpr bool value_known_statically(const Index i) const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::value_known_statically(i, *this);
-  }
-  EIGEN_DEVICE_FUNC constexpr bool all_values_known_statically() const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::values_up_to_known_statically(*this);
-  }
-
-  EIGEN_DEVICE_FUNC constexpr bool values_statically_known_to_increase() const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::values_up_to_statically_known_to_increase(*this);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-std::ostream& operator<<(std::ostream& os, const IndexList<FirstType, OtherTypes...>& dims) {
-  os << "[";
-  for (size_t i = 0; i < 1 + sizeof...(OtherTypes); ++i) {
-    if (i > 0) os << ", ";
-    os << dims[i];
-  }
-  os << "]";
-  return os;
-}
-
-template <typename FirstType, typename... OtherTypes>
-constexpr IndexList<FirstType, OtherTypes...> make_index_list(FirstType val1, OtherTypes... other_vals) {
-  return IndexList<FirstType, OtherTypes...>(val1, other_vals...);
-}
-
-template <typename FirstType, typename... OtherTypes>
-struct IndexPairList : internal::IndexTuple<FirstType, OtherTypes...> {
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC constexpr IndexPair<Index> operator[](const Index i) const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 IndexPair<Index>>::get(i, *this);
-  }
-  EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC void set(const Index i, const IndexPair<Index> value) {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 IndexPair<Index>>::set(i, *this, value);
-  }
-
-  EIGEN_DEVICE_FUNC constexpr IndexPairList(const internal::IndexTuple<FirstType, OtherTypes...>& other)
-      : internal::IndexTuple<FirstType, OtherTypes...>(other) {}
-  EIGEN_DEVICE_FUNC constexpr IndexPairList() : internal::IndexTuple<FirstType, OtherTypes...>() {}
-
-  EIGEN_DEVICE_FUNC constexpr bool value_known_statically(const Index i) const {
-    return internal::tuple_coeff<internal::array_size<internal::IndexTuple<FirstType, OtherTypes...>>::value - 1,
-                                 Index>::value_known_statically(i, *this);
-  }
-};
-
-namespace internal {
-
-template <typename FirstType, typename... OtherTypes>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index array_prod(const IndexList<FirstType, OtherTypes...>& sizes) {
-  Index result = 1;
-  EIGEN_UNROLL_LOOP
-  for (size_t i = 0; i < array_size<IndexList<FirstType, OtherTypes...>>::value; ++i) {
-    result *= sizes[i];
-  }
-  return result;
-}
-
-template <typename FirstType, typename... OtherTypes>
-struct array_size<IndexList<FirstType, OtherTypes...>> {
-  static const size_t value = array_size<IndexTuple<FirstType, OtherTypes...>>::value;
-};
-template <typename FirstType, typename... OtherTypes>
-struct array_size<const IndexList<FirstType, OtherTypes...>> {
-  static const size_t value = array_size<IndexTuple<FirstType, OtherTypes...>>::value;
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct array_size<IndexPairList<FirstType, OtherTypes...>> {
-  static const size_t value = 1 + sizeof...(OtherTypes);
-};
-template <typename FirstType, typename... OtherTypes>
-struct array_size<const IndexPairList<FirstType, OtherTypes...>> {
-  static const size_t value = 1 + sizeof...(OtherTypes);
-};
-
-template <Index N, typename FirstType, typename... OtherTypes>
-EIGEN_DEVICE_FUNC constexpr Index array_get(IndexList<FirstType, OtherTypes...>& a) {
-  return IndexTupleExtractor<N, FirstType, OtherTypes...>::get_val(a);
-}
-template <Index N, typename FirstType, typename... OtherTypes>
-EIGEN_DEVICE_FUNC constexpr Index array_get(const IndexList<FirstType, OtherTypes...>& a) {
-  return IndexTupleExtractor<N, FirstType, OtherTypes...>::get_val(a);
-}
-
-template <typename T>
-struct index_known_statically_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_known_statically_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_known_statically_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i);
-  }
-};
-
-template <typename T>
-struct all_indices_known_statically_impl {
-  static constexpr bool run() { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct all_indices_known_statically_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run() {
-    return IndexList<FirstType, OtherTypes...>().all_values_known_statically();
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct all_indices_known_statically_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run() {
-    return IndexList<FirstType, OtherTypes...>().all_values_known_statically();
-  }
-};
-
-template <typename T>
-struct indices_statically_known_to_increase_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run() { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct indices_statically_known_to_increase_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run() {
-    return Eigen::IndexList<FirstType, OtherTypes...>().values_statically_known_to_increase();
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct indices_statically_known_to_increase_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run() {
-    return Eigen::IndexList<FirstType, OtherTypes...>().values_statically_known_to_increase();
-  }
-};
-
-template <typename Tx>
-struct index_statically_eq_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_eq_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) == value);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_eq_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) == value);
-  }
-};
-
-template <typename T>
-struct index_statically_ne_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_ne_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) != value);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_ne_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) != value);
-  }
-};
-
-template <typename T>
-struct index_statically_gt_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_gt_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) > value);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_gt_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) > value);
-  }
-};
-
-template <typename T>
-struct index_statically_lt_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_lt_impl<IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) < value);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_statically_lt_impl<const IndexList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexList<FirstType, OtherTypes...>().get(i) < value);
-  }
-};
-
-template <typename Tx>
-struct index_pair_first_statically_eq_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_pair_first_statically_eq_impl<IndexPairList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexPairList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexPairList<FirstType, OtherTypes...>().operator[](i).first == value);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_pair_first_statically_eq_impl<const IndexPairList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexPairList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexPairList<FirstType, OtherTypes...>().operator[](i).first == value);
-  }
-};
-
-template <typename Tx>
-struct index_pair_second_statically_eq_impl {
-  EIGEN_DEVICE_FUNC static constexpr bool run(Index, Index) { return false; }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_pair_second_statically_eq_impl<IndexPairList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexPairList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexPairList<FirstType, OtherTypes...>().operator[](i).second == value);
-  }
-};
-
-template <typename FirstType, typename... OtherTypes>
-struct index_pair_second_statically_eq_impl<const IndexPairList<FirstType, OtherTypes...>> {
-  EIGEN_DEVICE_FUNC static constexpr bool run(const Index i, const Index value) {
-    return IndexPairList<FirstType, OtherTypes...>().value_known_statically(i) &&
-           (IndexPairList<FirstType, OtherTypes...>().operator[](i).second == value);
-  }
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-namespace Eigen {
-namespace internal {
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_known_statically(Index i) {
-  return index_known_statically_impl<T>::run(i);
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool all_indices_known_statically() {
-  return all_indices_known_statically_impl<T>::run();
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool indices_statically_known_to_increase() {
-  return indices_statically_known_to_increase_impl<T>::run();
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_statically_eq(Index i, Index value) {
-  return index_statically_eq_impl<T>::run(i, value);
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_statically_ne(Index i, Index value) {
-  return index_statically_ne_impl<T>::run(i, value);
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_statically_gt(Index i, Index value) {
-  return index_statically_gt_impl<T>::run(i, value);
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_statically_lt(Index i, Index value) {
-  return index_statically_lt_impl<T>::run(i, value);
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_pair_first_statically_eq(Index i, Index value) {
-  return index_pair_first_statically_eq_impl<T>::run(i, value);
-}
-
-template <typename T>
-static EIGEN_DEVICE_FUNC constexpr bool index_pair_second_statically_eq(Index i, Index value) {
-  return index_pair_second_statically_eq_impl<T>::run(i, value);
-}
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_INDEX_LIST_H
diff --git a/unsupported/Eigen/src/Tensor/TensorInflation.h b/unsupported/Eigen/src/Tensor/TensorInflation.h
deleted file mode 100644
index 74a53be..0000000
--- a/unsupported/Eigen/src/Tensor/TensorInflation.h
+++ /dev/null
@@ -1,224 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Ke Yang <yangke@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_INFLATION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INFLATION_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Strides, typename XprType>
-struct traits<TensorInflationOp<Strides, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename Strides, typename XprType>
-struct eval<TensorInflationOp<Strides, XprType>, Eigen::Dense> {
-  typedef const TensorInflationOp<Strides, XprType>& type;
-};
-
-template <typename Strides, typename XprType>
-struct nested<TensorInflationOp<Strides, XprType>, 1, typename eval<TensorInflationOp<Strides, XprType> >::type> {
-  typedef TensorInflationOp<Strides, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor inflation class.
- */
-template <typename Strides, typename XprType>
-class TensorInflationOp : public TensorBase<TensorInflationOp<Strides, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorInflationOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorInflationOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorInflationOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorInflationOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorInflationOp(const XprType& expr, const Strides& strides)
-      : m_xpr(expr), m_strides(strides) {}
-
-  EIGEN_DEVICE_FUNC const Strides& strides() const { return m_strides; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Strides m_strides;
-};
-
-// Eval as rvalue
-template <typename Strides, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorInflationOp<Strides, ArgType>, Device> {
-  typedef TensorInflationOp<Strides, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = /*TensorEvaluator<ArgType, Device>::IsAligned*/ false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_strides(op.strides()) {
-    m_dimensions = m_impl.dimensions();
-    // Expand each dimension to the inflated dimension.
-    for (int i = 0; i < NumDims; ++i) {
-      m_dimensions[i] = (m_dimensions[i] - 1) * op.strides()[i] + 1;
-    }
-
-    // Remember the strides for fast division.
-    for (int i = 0; i < NumDims; ++i) {
-      m_fastStrides[i] = internal::TensorIntDivisor<Index>(m_strides[i]);
-    }
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_outputStrides[0] = 1;
-      m_inputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
-      }
-    } else {  // RowMajor
-      m_outputStrides[NumDims - 1] = 1;
-      m_inputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  // Computes the input index given the output index. Returns true if the output
-  // index doesn't fall into a hole.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool getInputIndex(Index index, Index* inputIndex) const {
-    eigen_assert(index < dimensions().TotalSize());
-    *inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_outputStrides[i];
-        if (idx != idx / m_fastStrides[i] * m_strides[i]) {
-          return false;
-        }
-        *inputIndex += idx / m_strides[i] * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (index != index / m_fastStrides[0] * m_strides[0]) {
-        return false;
-      }
-      *inputIndex += index / m_strides[0];
-      return true;
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_outputStrides[i];
-        if (idx != idx / m_fastStrides[i] * m_strides[i]) {
-          return false;
-        }
-        *inputIndex += idx / m_strides[i] * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (index != index / m_fastStrides[NumDims - 1] * m_strides[NumDims - 1]) {
-        return false;
-      }
-      *inputIndex += index / m_strides[NumDims - 1];
-    }
-    return true;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    Index inputIndex = 0;
-    if (getInputIndex(index, &inputIndex)) {
-      return m_impl.coeff(inputIndex);
-    } else {
-      return Scalar(0);
-    }
-  }
-
-  // TODO(yangke): optimize this function so that we can detect and produce
-  // all-zero packets
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double compute_cost = NumDims * (3 * TensorOpCost::DivCost<Index>() + 3 * TensorOpCost::MulCost<Index>() +
-                                           2 * TensorOpCost::AddCost<Index>());
-    const double input_size = m_impl.dimensions().TotalSize();
-    const double output_size = m_dimensions.TotalSize();
-    if (output_size == 0) return TensorOpCost();
-    return m_impl.costPerCoeff(vectorized) +
-           TensorOpCost(sizeof(CoeffReturnType) * input_size / output_size, 0, compute_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- protected:
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims> m_inputStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  const Strides m_strides;
-  array<internal::TensorIntDivisor<Index>, NumDims> m_fastStrides;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_INFLATION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorInitializer.h b/unsupported/Eigen/src/Tensor/TensorInitializer.h
deleted file mode 100644
index 579caac..0000000
--- a/unsupported/Eigen/src/Tensor/TensorInitializer.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H
-
-#include <initializer_list>
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Helper template to initialize Tensors from std::initializer_lists.
- */
-template <typename Derived, int N>
-struct Initializer {
-  typedef std::initializer_list<typename Initializer<Derived, N - 1>::InitList> InitList;
-
-  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>* indices,
-                  const InitList& vals) {
-    int i = 0;
-    for (const auto& v : vals) {
-      (*indices)[traits<Derived>::NumDimensions - N] = i++;
-      Initializer<Derived, N - 1>::run(tensor, indices, v);
-    }
-  }
-};
-
-template <typename Derived>
-struct Initializer<Derived, 1> {
-  typedef std::initializer_list<typename traits<Derived>::Scalar> InitList;
-
-  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>* indices,
-                  const InitList& vals) {
-    int i = 0;
-    // TODO: Consider a faster approach than iterating.
-    for (const auto& v : vals) {
-      (*indices)[traits<Derived>::NumDimensions - 1] = i++;
-      tensor.coeffRef(*indices) = v;
-    }
-  }
-};
-
-template <typename Derived>
-struct Initializer<Derived, 0> {
-  typedef typename traits<Derived>::Scalar InitList;
-
-  static void run(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions>*, const InitList& v) {
-    tensor.coeffRef(0) = v;
-  }
-};
-
-template <typename Derived, int N>
-void initialize_tensor(TensorEvaluator<Derived, DefaultDevice>& tensor,
-                       const typename Initializer<Derived, traits<Derived>::NumDimensions>::InitList& vals) {
-  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions> indices;
-  Initializer<Derived, traits<Derived>::NumDimensions>::run(tensor, &indices, vals);
-}
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H
diff --git a/unsupported/Eigen/src/Tensor/TensorIntDiv.h b/unsupported/Eigen/src/Tensor/TensorIntDiv.h
deleted file mode 100644
index ed25646..0000000
--- a/unsupported/Eigen/src/Tensor/TensorIntDiv.h
+++ /dev/null
@@ -1,258 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_INTDIV_H
-#define EIGEN_CXX11_TENSOR_TENSOR_INTDIV_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-// Note: result is undefined if val == 0
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<sizeof(T) == 4, int> count_leading_zeros(const T val) {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-  return __clz(val);
-#elif defined(SYCL_DEVICE_ONLY)
-  return cl::sycl::clz(val);
-#elif EIGEN_COMP_MSVC
-  unsigned long index;
-  _BitScanReverse(&index, val);
-  return 31 - index;
-#else
-  EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  return __builtin_clz(static_cast<uint32_t>(val));
-#endif
-}
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<sizeof(T) == 8, int> count_leading_zeros(const T val) {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-  return __clzll(val);
-#elif defined(SYCL_DEVICE_ONLY)
-  return static_cast<int>(cl::sycl::clz(val));
-#elif EIGEN_COMP_MSVC && EIGEN_ARCH_x86_64
-  unsigned long index;
-  _BitScanReverse64(&index, val);
-  return 63 - index;
-#elif EIGEN_COMP_MSVC
-  // MSVC's _BitScanReverse64 is not available for 32bits builds.
-  unsigned int lo = (unsigned int)(val & 0xffffffff);
-  unsigned int hi = (unsigned int)((val >> 32) & 0xffffffff);
-  int n;
-  if (hi == 0)
-    n = 32 + count_leading_zeros<unsigned int>(lo);
-  else
-    n = count_leading_zeros<unsigned int>(hi);
-  return n;
-#else
-  EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  return __builtin_clzll(static_cast<uint64_t>(val));
-#endif
-}
-
-template <typename T>
-struct UnsignedTraits {
-  typedef std::conditional_t<sizeof(T) == 8, uint64_t, uint32_t> type;
-};
-
-template <typename T>
-struct DividerTraits {
-  typedef typename UnsignedTraits<T>::type type;
-  static constexpr int N = sizeof(T) * 8;
-};
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint32_t muluh(const uint32_t a, const T b) {
-#if defined(EIGEN_GPU_COMPILE_PHASE)
-  return __umulhi(a, b);
-#elif defined(SYCL_DEVICE_ONLY)
-  return cl::sycl::mul_hi(a, static_cast<uint32_t>(b));
-#else
-  return (static_cast<uint64_t>(a) * b) >> 32;
-#endif
-}
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint64_t muluh(const uint64_t a, const T b) {
-#if defined(EIGEN_GPU_COMPILE_PHASE)
-  return __umul64hi(a, b);
-#elif defined(SYCL_DEVICE_ONLY)
-  return cl::sycl::mul_hi(a, static_cast<uint64_t>(b));
-#elif EIGEN_COMP_MSVC && (EIGEN_ARCH_x86_64 || EIGEN_ARCH_ARM64)
-  return __umulh(a, static_cast<uint64_t>(b));
-#elif EIGEN_HAS_BUILTIN_INT128
-  __uint128_t v = static_cast<__uint128_t>(a) * static_cast<__uint128_t>(b);
-  return static_cast<uint64_t>(v >> 64);
-#else
-  return (TensorUInt128<static_val<0>, uint64_t>(a) * TensorUInt128<static_val<0>, uint64_t>(b)).upper();
-#endif
-}
-
-template <int N, typename T>
-struct DividerHelper {
-  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint32_t computeMultiplier(const int log_div, const T divider) {
-    EIGEN_STATIC_ASSERT(N == 32, YOU_MADE_A_PROGRAMMING_MISTAKE);
-    return static_cast<uint32_t>((static_cast<uint64_t>(1) << (N + log_div)) / divider -
-                                 (static_cast<uint64_t>(1) << N) + 1);
-  }
-};
-
-template <typename T>
-struct DividerHelper<64, T> {
-  static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE uint64_t computeMultiplier(const int log_div, const T divider) {
-#if EIGEN_HAS_BUILTIN_INT128 && !defined(EIGEN_GPU_COMPILE_PHASE) && !defined(SYCL_DEVICE_ONLY)
-    return static_cast<uint64_t>((static_cast<__uint128_t>(1) << (64 + log_div)) / static_cast<__uint128_t>(divider) -
-                                 (static_cast<__uint128_t>(1) << 64) + 1);
-#else
-    const uint64_t shift = 1ULL << log_div;
-    TensorUInt128<uint64_t, uint64_t> result =
-        TensorUInt128<uint64_t, static_val<0> >(shift, 0) / TensorUInt128<static_val<0>, uint64_t>(divider) -
-        TensorUInt128<static_val<1>, static_val<0> >(1, 0) + TensorUInt128<static_val<0>, static_val<1> >(1);
-    return static_cast<uint64_t>(result);
-#endif
-  }
-};
-
-/** \internal
- *
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Fast integer division by a constant.
- *
- * See the paper from Granlund and Montgomery for explanation.
- *   (at https://doi.org/10.1145/773473.178249)
- *
- * \sa Tensor
- */
-template <typename T, bool div_gt_one = false>
-struct TensorIntDivisor {
- public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor() {
-    multiplier = 0;
-    shift1 = 0;
-    shift2 = 0;
-  }
-
-  // Must have 0 < divider < 2^31. This is relaxed to
-  // 0 < divider < 2^63 when using 64-bit indices on platforms that support
-  // the __uint128_t type.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor(const T divider) {
-    const int N = DividerTraits<T>::N;
-    eigen_assert(static_cast<typename UnsignedTraits<T>::type>(divider) < NumTraits<UnsignedType>::highest() / 2);
-    eigen_assert(divider > 0);
-
-    // fast ln2
-    const int leading_zeros = count_leading_zeros(static_cast<UnsignedType>(divider));
-    int log_div = N - leading_zeros;
-    // if divider is a power of two then log_div is 1 more than it should be.
-    if ((static_cast<typename UnsignedTraits<T>::type>(1) << (log_div - 1)) ==
-        static_cast<typename UnsignedTraits<T>::type>(divider))
-      log_div--;
-
-    multiplier = DividerHelper<N, T>::computeMultiplier(log_div, divider);
-    shift1 = log_div > 1 ? 1 : log_div;
-    shift2 = log_div > 1 ? log_div - 1 : 0;
-  }
-
-  // Must have 0 <= numerator. On platforms that don't support the __uint128_t
-  // type numerator should also be less than 2^32-1.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T divide(const T numerator) const {
-    eigen_assert(static_cast<typename UnsignedTraits<T>::type>(numerator) < NumTraits<UnsignedType>::highest() / 2);
-
-    UnsignedType t1 = muluh(multiplier, numerator);
-    UnsignedType t = (static_cast<UnsignedType>(numerator) - t1) >> shift1;
-    return (t1 + t) >> shift2;
-  }
-
- private:
-  typedef typename DividerTraits<T>::type UnsignedType;
-  UnsignedType multiplier;
-  int32_t shift1;
-  int32_t shift2;
-};
-
-// Optimized version for signed 32 bit integers.
-// Derived from Hacker's Delight.
-// Only works for divisors strictly greater than one
-template <>
-class TensorIntDivisor<int32_t, true> {
- public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorIntDivisor() {
-    magic = 0;
-    shift = 0;
-  }
-  // Must have 2 <= divider
-  EIGEN_DEVICE_FUNC TensorIntDivisor(int32_t divider) {
-    eigen_assert(divider >= 2);
-    calcMagic(divider);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE int divide(const int32_t n) const {
-#ifdef EIGEN_GPU_COMPILE_PHASE
-    return (__umulhi(magic, n) >> shift);
-#elif defined(SYCL_DEVICE_ONLY)
-    return (cl::sycl::mul_hi(magic, static_cast<uint32_t>(n)) >> shift);
-#else
-    uint64_t v = static_cast<uint64_t>(magic) * static_cast<uint64_t>(n);
-    return (static_cast<uint32_t>(v >> 32) >> shift);
-#endif
-  }
-
- private:
-  // Compute the magic numbers. See Hacker's Delight section 10 for an in
-  // depth explanation.
-  EIGEN_DEVICE_FUNC void calcMagic(int32_t d) {
-    const unsigned two31 = 0x80000000;  // 2**31.
-    unsigned ad = d;
-    unsigned t = two31 + (ad >> 31);
-    unsigned anc = t - 1 - t % ad;   // Absolute value of nc.
-    int p = 31;                      // Init. p.
-    unsigned q1 = two31 / anc;       // Init. q1 = 2**p/|nc|.
-    unsigned r1 = two31 - q1 * anc;  // Init. r1 = rem(2**p, |nc|).
-    unsigned q2 = two31 / ad;        // Init. q2 = 2**p/|d|.
-    unsigned r2 = two31 - q2 * ad;   // Init. r2 = rem(2**p, |d|).
-    unsigned delta = 0;
-    do {
-      p = p + 1;
-      q1 = 2 * q1;      // Update q1 = 2**p/|nc|.
-      r1 = 2 * r1;      // Update r1 = rem(2**p, |nc|).
-      if (r1 >= anc) {  // (Must be an unsigned
-        q1 = q1 + 1;    // comparison here).
-        r1 = r1 - anc;
-      }
-      q2 = 2 * q2;     // Update q2 = 2**p/|d|.
-      r2 = 2 * r2;     // Update r2 = rem(2**p, |d|).
-      if (r2 >= ad) {  // (Must be an unsigned
-        q2 = q2 + 1;   // comparison here).
-        r2 = r2 - ad;
-      }
-      delta = ad - r2;
-    } while (q1 < delta || (q1 == delta && r1 == 0));
-
-    magic = (unsigned)(q2 + 1);
-    shift = p - 32;
-  }
-
-  uint32_t magic;
-  int32_t shift;
-};
-
-template <typename T, bool div_gt_one>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator/(const T& numerator, const TensorIntDivisor<T, div_gt_one>& divisor) {
-  return divisor.divide(numerator);
-}
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_INTDIV_H
diff --git a/unsupported/Eigen/src/Tensor/TensorLayoutSwap.h b/unsupported/Eigen/src/Tensor/TensorLayoutSwap.h
deleted file mode 100644
index 3ddcc1c..0000000
--- a/unsupported/Eigen/src/Tensor/TensorLayoutSwap.h
+++ /dev/null
@@ -1,185 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_LAYOUT_SWAP_H
-#define EIGEN_CXX11_TENSOR_TENSOR_LAYOUT_SWAP_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename XprType>
-struct traits<TensorLayoutSwapOp<XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = traits<XprType>::NumDimensions;
-  static constexpr int Layout = (traits<XprType>::Layout == ColMajor) ? RowMajor : ColMajor;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename XprType>
-struct eval<TensorLayoutSwapOp<XprType>, Eigen::Dense> {
-  typedef const TensorLayoutSwapOp<XprType>& type;
-};
-
-template <typename XprType>
-struct nested<TensorLayoutSwapOp<XprType>, 1, typename eval<TensorLayoutSwapOp<XprType> >::type> {
-  typedef TensorLayoutSwapOp<XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Swap the layout from col-major to row-major, or row-major
- * to col-major, and invert the order of the dimensions.
- *
- * Beware: the dimensions are reversed by this operation. If you want to
- * preserve the ordering of the dimensions, you need to combine this
- * operation with a shuffle.
- *
- * \example:
- * Tensor<float, 2, ColMajor> input(2, 4);
- * Tensor<float, 2, RowMajor> output = input.swap_layout();
- * eigen_assert(output.dimension(0) == 4);
- * eigen_assert(output.dimension(1) == 2);
- *
- * array<int, 2> shuffle(1, 0);
- * output = input.swap_layout().shuffle(shuffle);
- * eigen_assert(output.dimension(0) == 2);
- * eigen_assert(output.dimension(1) == 4);
- *
- */
-template <typename XprType>
-class TensorLayoutSwapOp : public TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors> {
- public:
-  typedef TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors> Base;
-  typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorLayoutSwapOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorLayoutSwapOp(const XprType& expr) : m_xpr(expr) {}
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorLayoutSwapOp)
- protected:
-  typename XprType::Nested m_xpr;
-};
-
-// Eval as rvalue
-template <typename ArgType, typename Device>
-struct TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> {
-  typedef TensorLayoutSwapOp<ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-
-  static constexpr int Layout =
-      (TensorEvaluator<ArgType, Device>::Layout == static_cast<int>(ColMajor)) ? RowMajor : ColMajor;
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {
-    for (int i = 0; i < NumDims; ++i) {
-      m_dimensions[i] = m_impl.dimensions()[NumDims - 1 - i];
-    }
-  }
-
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) { return m_impl.evalSubExprsIfNeeded(data); }
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_impl.coeff(index); }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return m_impl.template packet<LoadMode>(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return m_impl.costPerCoeff(vectorized);
-  }
-
-  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return constCast(m_impl.data()); }
-
-  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-
- protected:
-  TensorEvaluator<ArgType, Device> m_impl;
-  Dimensions m_dimensions;
-};
-
-// Eval as lvalue
-template <typename ArgType, typename Device>
-struct TensorEvaluator<TensorLayoutSwapOp<ArgType>, Device>
-    : public TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> {
-  typedef TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> Base;
-  typedef TensorLayoutSwapOp<ArgType> XprType;
-
-  static constexpr int Layout =
-      (TensorEvaluator<ArgType, Device>::Layout == static_cast<int>(ColMajor)) ? RowMajor : ColMajor;
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false  // to be implemented
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(index);
-  }
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    this->m_impl.template writePacket<StoreMode>(index, x);
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_LAYOUT_SWAP_H
diff --git a/unsupported/Eigen/src/Tensor/TensorMacros.h b/unsupported/Eigen/src/Tensor/TensorMacros.h
deleted file mode 100644
index f8bbcfe..0000000
--- a/unsupported/Eigen/src/Tensor/TensorMacros.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_META_MACROS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_META_MACROS_H
-
-/** use this macro in sfinae selection in templated functions
- *
- *   template<typename T,
- *            std::enable_if_t< isBanana<T>::value , int > = 0
- *   >
- *   void foo(){}
- *
- *   becomes =>
- *
- *   template<typename TopoType,
- *           SFINAE_ENABLE_IF( isBanana<T>::value )
- *   >
- *   void foo(){}
- */
-
-#define EIGEN_SFINAE_ENABLE_IF(__condition__) std::enable_if_t<(__condition__), int> = 0
-
-// Define a macro to use a reference on the host but a value on the device
-#if defined(SYCL_DEVICE_ONLY)
-#define EIGEN_DEVICE_REF
-#else
-#define EIGEN_DEVICE_REF &
-#endif
-
-// Define a macro for catching SYCL exceptions if exceptions are enabled
-#define EIGEN_SYCL_TRY_CATCH(X)                                                                                        \
-  do {                                                                                                                 \
-    EIGEN_TRY { X; }                                                                                                   \
-    EIGEN_CATCH(const cl::sycl::exception& e) {                                                                        \
-      EIGEN_THROW_X(std::runtime_error("SYCL exception at " + std::string(__FILE__) + ":" + std::to_string(__LINE__) + \
-                                       "\n" + e.what()));                                                              \
-    }                                                                                                                  \
-  } while (false)
-
-// Define a macro if local memory flags are unset or one of them is set
-// Setting both flags is the same as unsetting them
-#if (!defined(EIGEN_SYCL_LOCAL_MEM) && !defined(EIGEN_SYCL_NO_LOCAL_MEM)) || \
-    (defined(EIGEN_SYCL_LOCAL_MEM) && defined(EIGEN_SYCL_NO_LOCAL_MEM))
-#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON 1
-#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF 1
-#elif defined(EIGEN_SYCL_LOCAL_MEM) && !defined(EIGEN_SYCL_NO_LOCAL_MEM)
-#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON 1
-#elif !defined(EIGEN_SYCL_LOCAL_MEM) && defined(EIGEN_SYCL_NO_LOCAL_MEM)
-#define EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF 1
-#endif
-
-#if EIGEN_COMP_CLANG  // workaround clang bug (see http://forum.kde.org/viewtopic.php?f=74&t=102653)
-#define EIGEN_TENSOR_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)                         \
-  using Base::operator=;                                                                \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const Derived& other) {      \
-    Base::operator=(other);                                                             \
-    return *this;                                                                       \
-  }                                                                                     \
-  template <typename OtherDerived>                                                      \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator=(const OtherDerived& other) { \
-    Base::operator=(other);                                                             \
-    return *this;                                                                       \
-  }
-#else
-#define EIGEN_TENSOR_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)
-#endif
-
-/** \internal
- * \brief Macro to manually inherit assignment operators.
- * This is necessary, because the implicitly defined assignment operator gets deleted when a custom operator= is
- * defined. This also inherits template<OtherDerived> operator=(const OtherDerived&) assignments. With C++11 or later
- * this also default-implements the copy-constructor
- */
-#define EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)  \
-  EIGEN_DEFAULT_COPY_CONSTRUCTOR(Derived)
-
-#endif
diff --git a/unsupported/Eigen/src/Tensor/TensorMap.h b/unsupported/Eigen/src/Tensor/TensorMap.h
deleted file mode 100644
index 548edfe..0000000
--- a/unsupported/Eigen/src/Tensor/TensorMap.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_MAP_H
-#define EIGEN_CXX11_TENSOR_TENSOR_MAP_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-// FIXME: Use proper doxygen documentation (e.g. \tparam MakePointer_).
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief A tensor expression mapping an existing array of data.
- *
- */
-/// `template <class> class MakePointer_` is added to convert the host pointer to the device pointer.
-/// It is added due to the fact that for our device compiler `T*` is not allowed.
-/// If we wanted to use the same Evaluator functions we have to convert that type to our pointer `T`.
-/// This is done through our `MakePointer_` class. By default the Type in the `MakePointer_<T>` is `T*` .
-/// Therefore, by adding the default value, we managed to convert the type and it does not break any
-/// existing code as its default value is `T*`.
-template <typename PlainObjectType, int Options_, template <class> class MakePointer_>
-class TensorMap : public TensorBase<TensorMap<PlainObjectType, Options_, MakePointer_> > {
- public:
-  typedef TensorMap<PlainObjectType, Options_, MakePointer_> Self;
-  typedef TensorBase<TensorMap<PlainObjectType, Options_, MakePointer_> > Base;
-#ifdef EIGEN_USE_SYCL
-  typedef std::remove_reference_t<typename Eigen::internal::nested<Self>::type> Nested;
-#else
-  typedef typename Eigen::internal::nested<Self>::type Nested;
-#endif
-  typedef typename internal::traits<PlainObjectType>::StorageKind StorageKind;
-  typedef typename internal::traits<PlainObjectType>::Index Index;
-  typedef typename internal::traits<PlainObjectType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef typename PlainObjectType::Base::CoeffReturnType CoeffReturnType;
-
-  typedef typename MakePointer_<Scalar>::Type PointerType;
-  typedef typename MakePointer_<Scalar>::ConstType PointerConstType;
-
-  // WARN: PointerType still can be a pointer to const (const Scalar*), for
-  // example in TensorMap<Tensor<const Scalar, ...>> expression. This type of
-  // expression should be illegal, but adding this restriction is not possible
-  // in practice (see https://bitbucket.org/eigen/eigen/pull-requests/488).
-  typedef std::conditional_t<bool(internal::is_lvalue<PlainObjectType>::value),
-                             PointerType,      // use simple pointer in lvalue expressions
-                             PointerConstType  // use const pointer in rvalue expressions
-                             >
-      StoragePointerType;
-
-  // If TensorMap was constructed over rvalue expression (e.g. const Tensor),
-  // we should return a reference to const from operator() (and others), even
-  // if TensorMap itself is not const.
-  typedef std::conditional_t<bool(internal::is_lvalue<PlainObjectType>::value), Scalar&, const Scalar&> StorageRefType;
-
-  static constexpr int Options = Options_;
-
-  static constexpr Index NumIndices = PlainObjectType::NumIndices;
-  typedef typename PlainObjectType::Dimensions Dimensions;
-
-  static constexpr int Layout = PlainObjectType::Layout;
-  enum { IsAligned = ((int(Options_) & Aligned) == Aligned), CoordAccess = true, RawAccess = true };
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr) : m_data(dataPtr), m_dimensions() {
-    // The number of dimensions used to construct a tensor must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT((0 == NumIndices || NumIndices == Dynamic), YOU_MADE_A_PROGRAMMING_MISTAKE)
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index firstDimension,
-                                                  IndexTypes... otherDimensions)
-      : m_data(dataPtr), m_dimensions(firstDimension, otherDimensions...) {
-    // The number of dimensions used to construct a tensor must be equal to the rank of the tensor.
-    EIGEN_STATIC_ASSERT((sizeof...(otherDimensions) + 1 == NumIndices || NumIndices == Dynamic),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE)
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr,
-                                                  const array<Index, NumIndices>& dimensions)
-      : m_data(dataPtr), m_dimensions(dimensions) {}
-
-  template <typename Dimensions>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, const Dimensions& dimensions)
-      : m_data(dataPtr), m_dimensions(dimensions) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(PlainObjectType& tensor)
-      : m_data(tensor.data()), m_dimensions(tensor.dimensions()) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return m_dimensions.rank(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(Index n) const { return m_dimensions[n]; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_dimensions.TotalSize(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StoragePointerType data() { return m_data; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StoragePointerType data() const { return m_data; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(const array<Index, NumIndices>& indices) const {
-    if (PlainObjectType::Options & RowMajor) {
-      const Index index = m_dimensions.IndexOfRowMajor(indices);
-      return m_data[index];
-    } else {
-      const Index index = m_dimensions.IndexOfColMajor(indices);
-      return m_data[index];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()() const {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return m_data[0];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index index) const {
-    eigen_internal_assert(index >= 0 && index < size());
-    return m_data[index];
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index firstIndex, Index secondIndex,
-                                                                  IndexTypes... otherIndices) const {
-    EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(internal::all((Eigen::NumTraits<Index>::highest() >= otherIndices)...));
-    if (PlainObjectType::Options & RowMajor) {
-      const Index index =
-          m_dimensions.IndexOfRowMajor(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}});
-      return m_data[index];
-    } else {
-      const Index index =
-          m_dimensions.IndexOfColMajor(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}});
-      return m_data[index];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(const array<Index, NumIndices>& indices) {
-    if (PlainObjectType::Options & RowMajor) {
-      const Index index = m_dimensions.IndexOfRowMajor(indices);
-      return m_data[index];
-    } else {
-      const Index index = m_dimensions.IndexOfColMajor(indices);
-      return m_data[index];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()() {
-    EIGEN_STATIC_ASSERT(NumIndices == 0, YOU_MADE_A_PROGRAMMING_MISTAKE)
-    return m_data[0];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index index) {
-    eigen_internal_assert(index >= 0 && index < size());
-    return m_data[index];
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index firstIndex, Index secondIndex,
-                                                                  IndexTypes... otherIndices) {
-    static_assert(sizeof...(otherIndices) + 2 == NumIndices || NumIndices == Dynamic,
-                  "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
-    eigen_assert(internal::all((Eigen::NumTraits<Index>::highest() >= otherIndices)...));
-    const std::size_t NumDims = sizeof...(otherIndices) + 2;
-    if (PlainObjectType::Options & RowMajor) {
-      const Index index =
-          m_dimensions.IndexOfRowMajor(array<Index, NumDims>{{firstIndex, secondIndex, otherIndices...}});
-      return m_data[index];
-    } else {
-      const Index index =
-          m_dimensions.IndexOfColMajor(array<Index, NumDims>{{firstIndex, secondIndex, otherIndices...}});
-      return m_data[index];
-    }
-  }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorMap)
-
- private:
-  StoragePointerType m_data;
-  Dimensions m_dimensions;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_MAP_H
diff --git a/unsupported/Eigen/src/Tensor/TensorMeta.h b/unsupported/Eigen/src/Tensor/TensorMeta.h
deleted file mode 100644
index 8454070..0000000
--- a/unsupported/Eigen/src/Tensor/TensorMeta.h
+++ /dev/null
@@ -1,291 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_META_H
-#define EIGEN_CXX11_TENSOR_TENSOR_META_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-template <bool cond>
-struct Cond {};
-
-template <typename T1, typename T2>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T1& choose(Cond<true>, const T1& first, const T2&) {
-  return first;
-}
-
-template <typename T1, typename T2>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T2& choose(Cond<false>, const T1&, const T2& second) {
-  return second;
-}
-
-template <size_t n>
-struct max_n_1 {
-  static const size_t size = n;
-};
-template <>
-struct max_n_1<0> {
-  static const size_t size = 1;
-};
-
-template <typename T>
-EIGEN_DEPRECATED EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr T divup(const T x, const T y) {
-  return Eigen::numext::div_ceil(x, y);
-}
-
-// Default packet types
-template <typename Scalar, typename Device>
-struct PacketType : internal::packet_traits<Scalar> {
-  typedef typename internal::packet_traits<Scalar>::type type;
-};
-
-// For CUDA packet types when using a GpuDevice
-#if defined(EIGEN_USE_GPU) && defined(EIGEN_HAS_GPU_FP16) && defined(EIGEN_GPU_COMPILE_PHASE)
-
-typedef ulonglong2 Packet4h2;
-template <>
-struct PacketType<half, GpuDevice> {
-  typedef Packet4h2 type;
-  static const int size = 8;
-  enum {
-    HasAdd = 1,
-    HasSub = 1,
-    HasMul = 1,
-    HasNegate = 1,
-    HasAbs = 1,
-    HasArg = 0,
-    HasAbs2 = 0,
-    HasMin = 1,
-    HasMax = 1,
-    HasConj = 0,
-    HasSetLinear = 0,
-    HasBlend = 0,
-
-    HasDiv = 1,
-    HasSqrt = 1,
-    HasRsqrt = 1,
-    HasExp = 1,
-    HasExpm1 = 0,
-    HasLog = 1,
-    HasLog1p = 0,
-    HasLog10 = 0,
-    HasPow = 1,
-  };
-};
-#endif
-
-#if defined(EIGEN_USE_SYCL)
-
-namespace TensorSycl {
-namespace internal {
-
-template <typename Index, Index A, Index B>
-struct PlusOp {
-  static constexpr Index Value = A + B;
-};
-
-template <typename Index, Index A, Index B>
-struct DivOp {
-  static constexpr Index Value = A / B;
-};
-
-template <typename Index, Index start, Index end, Index step, template <class Indx, Indx...> class StepOp>
-struct static_for {
-  template <typename UnaryOperator>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void loop(UnaryOperator op) {
-    op(start);
-    static_for<Index, StepOp<Index, start, step>::Value, end, step, StepOp>::loop(op);
-  }
-};
-template <typename Index, Index end, Index step, template <class Indx, Indx...> class StepOp>
-struct static_for<Index, end, end, step, StepOp> {
-  template <typename UnaryOperator>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void loop(UnaryOperator) {}
-};
-
-template <typename OutScalar, typename Device, bool Vectorizable>
-struct Vectorise {
-  static constexpr int PacketSize = 1;
-  typedef OutScalar PacketReturnType;
-};
-
-template <typename OutScalar, typename Device>
-struct Vectorise<OutScalar, Device, true> {
-  static constexpr int PacketSize = Eigen::PacketType<OutScalar, Device>::size;
-  typedef typename Eigen::PacketType<OutScalar, Device>::type PacketReturnType;
-};
-
-static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Index roundUp(Index x, Index y) { return ((((x) + (y)-1) / (y)) * (y)); }
-
-}  // namespace internal
-}  // namespace TensorSycl
-
-template <>
-struct PacketType<half, SyclDevice> {
-  typedef half type;
-  static const int size = 1;
-  enum {
-    HasAdd = 0,
-    HasSub = 0,
-    HasMul = 0,
-    HasNegate = 0,
-    HasAbs = 0,
-    HasArg = 0,
-    HasAbs2 = 0,
-    HasMin = 0,
-    HasMax = 0,
-    HasConj = 0,
-    HasSetLinear = 0,
-    HasBlend = 0
-  };
-};
-template <typename Scalar>
-struct PacketType<Scalar, SyclDevice> : internal::default_packet_traits {
-  typedef Scalar type;
-  typedef Scalar half;
-  enum {
-    Vectorizable = 0,
-    size = 1,
-    AlignedOnScalar = 0,
-  };
-  enum {
-    HasAdd = 0,
-    HasSub = 0,
-    HasMul = 0,
-    HasNegate = 0,
-    HasAbs = 0,
-    HasAbs2 = 0,
-    HasMin = 0,
-    HasMax = 0,
-    HasConj = 0,
-    HasSetLinear = 0
-  };
-};
-
-template <typename Scalar>
-struct PacketType<Scalar, const SyclDevice> : PacketType<Scalar, SyclDevice> {};
-
-#ifndef EIGEN_DONT_VECTORIZE_SYCL
-#define PACKET_TYPE(CVQual, Type, val, lengths, DEV)                                 \
-  template <>                                                                        \
-  struct PacketType<CVQual Type, DEV> : internal::sycl_packet_traits<val, lengths> { \
-    typedef typename internal::packet_traits<Type>::type type;                       \
-    typedef typename internal::packet_traits<Type>::half half;                       \
-  };
-
-PACKET_TYPE(const, float, 1, 4, SyclDevice)
-PACKET_TYPE(, float, 1, 4, SyclDevice)
-PACKET_TYPE(const, float, 1, 4, const SyclDevice)
-PACKET_TYPE(, float, 1, 4, const SyclDevice)
-
-PACKET_TYPE(const, double, 0, 2, SyclDevice)
-PACKET_TYPE(, double, 0, 2, SyclDevice)
-PACKET_TYPE(const, double, 0, 2, const SyclDevice)
-PACKET_TYPE(, double, 0, 2, const SyclDevice)
-#undef PACKET_TYPE
-
-template <>
-struct PacketType<half, const SyclDevice> : PacketType<half, SyclDevice> {};
-template <>
-struct PacketType<const half, const SyclDevice> : PacketType<half, SyclDevice> {};
-#endif
-#endif
-
-// Pair mimics std::pair but works on e.g. nvcc.
-template <typename U, typename V>
-struct Pair {
- public:
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-
-  U first;
-  V second;
-
-  typedef U first_type;
-  typedef V second_type;
-
-  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Pair() : first(), second() {}
-
-  constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Pair(const U& f, const V& s) : first(f), second(s) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void swap(Pair& rhs) {
-    using numext::swap;
-    swap(first, rhs.first);
-    swap(second, rhs.second);
-  }
-};
-
-template <typename U, typename V>
-constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator==(const Pair<U, V>& x, const Pair<U, V>& y) {
-  return (x.first == y.first && x.second == y.second);
-}
-
-template <typename U, typename V>
-constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator!=(const Pair<U, V>& x, const Pair<U, V>& y) {
-  return !(x == y);
-}
-
-// Can't use std::pairs on cuda devices
-template <typename Idx>
-struct IndexPair {
-  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair() : first(0), second(0) {}
-  constexpr EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexPair(Idx f, Idx s) : first(f), second(s) {}
-
-  EIGEN_DEVICE_FUNC void set(IndexPair<Idx> val) {
-    first = val.first;
-    second = val.second;
-  }
-
-  Idx first;
-  Idx second;
-};
-
-namespace internal {
-
-template <typename IndexType, typename Index, Index First, Index... Is>
-constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, 1 + sizeof...(Is)> customIndices2Array(
-    IndexType& idx, numeric_list<Index, First, Is...>) {
-  return {static_cast<Index>(idx[First]), static_cast<Index>(idx[Is])...};
-}
-template <typename IndexType, typename Index>
-constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, 0> customIndices2Array(IndexType&, numeric_list<Index>) {
-  return array<Index, 0>();
-}
-
-/** Make an array (for index/dimensions) out of a custom index */
-template <typename Index, std::size_t NumIndices, typename IndexType>
-constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, NumIndices> customIndices2Array(IndexType& idx) {
-  return customIndices2Array(idx, typename gen_numeric_list<Index, NumIndices>::type{});
-}
-
-template <typename B, typename D>
-struct is_base_of {
-  typedef char (&yes)[1];
-  typedef char (&no)[2];
-
-  template <typename BB, typename DD>
-  struct Host {
-    operator BB*() const;
-    operator DD*();
-  };
-
-  template <typename T>
-  static yes check(D*, T);
-  static no check(B*, int);
-
-  static const bool value = sizeof(check(Host<B, D>(), int())) == sizeof(yes);
-};
-
-}  // namespace internal
-
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_META_H
diff --git a/unsupported/Eigen/src/Tensor/TensorMorphing.h b/unsupported/Eigen/src/Tensor/TensorMorphing.h
deleted file mode 100644
index 7a5c4b0..0000000
--- a/unsupported/Eigen/src/Tensor/TensorMorphing.h
+++ /dev/null
@@ -1,981 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_MORPHING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_MORPHING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename NewDimensions, typename XprType>
-struct traits<TensorReshapingOp<NewDimensions, XprType>> : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = array_size<NewDimensions>::value;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename NewDimensions, typename XprType>
-struct eval<TensorReshapingOp<NewDimensions, XprType>, Eigen::Dense> {
-  typedef const TensorReshapingOp<NewDimensions, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename NewDimensions, typename XprType>
-struct nested<TensorReshapingOp<NewDimensions, XprType>, 1,
-              typename eval<TensorReshapingOp<NewDimensions, XprType>>::type> {
-  typedef TensorReshapingOp<NewDimensions, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor reshaping class.
- */
-template <typename NewDimensions, typename XprType>
-class TensorReshapingOp : public TensorBase<TensorReshapingOp<NewDimensions, XprType>, WriteAccessors> {
- public:
-  typedef TensorBase<TensorReshapingOp<NewDimensions, XprType>, WriteAccessors> Base;
-  typedef typename Eigen::internal::traits<TensorReshapingOp>::Scalar Scalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorReshapingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorReshapingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorReshapingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReshapingOp(const XprType& expr, const NewDimensions& dims)
-      : m_xpr(expr), m_dims(dims) {}
-
-  EIGEN_DEVICE_FUNC const NewDimensions& dimensions() const { return m_dims; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorReshapingOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const NewDimensions m_dims;
-};
-
-// Eval as rvalue
-template <typename NewDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorReshapingOp<NewDimensions, ArgType>, Device> {
-  typedef TensorReshapingOp<NewDimensions, ArgType> XprType;
-  typedef NewDimensions Dimensions;
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  typedef StorageMemory<std::remove_const_t<CoeffReturnType>, Device> ConstCastStorage;
-
-  static constexpr int NumOutputDims = internal::array_size<Dimensions>::value;
-  static constexpr int NumInputDims =
-      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-
-  enum ReshapingKind {
-    // We do not use layout information to determine reshaping kind.
-    // Depending on the layout `N` can be inner or outer dimension.
-    OneByN = 0,  // expr.reshape(1, N)
-    NByOne = 1,  // expr.reshape(N, 1)
-    Runtime = 2  // Reshape dimensions are dynamic (specified at runtime).
-  };
-
-  // clang-format off
-  static const ReshapingKind kind =
-        (NumOutputDims == 2 && internal::index_statically_eq<NewDimensions>(/*index=*/0, /*value=*/1)) ? OneByN
-      : (NumOutputDims == 2 && internal::index_statically_eq<NewDimensions>(/*index=*/1, /*value=*/1)) ? NByOne
-      : Runtime;
-  // clang-format on
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    // For trivial reshapes with raw access to underlying data we will provide
-    // zero overhead block access.
-    // TODO(ezhulenev): Consider adding block access without raw access?
-    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess && NumInputDims > 0 && NumOutputDims > 0,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumOutputDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumOutputDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_dimensions(op.dimensions()) {
-    // The total size of the reshaped tensor must be equal to the total size
-    // of the input tensor.
-    eigen_assert(internal::array_prod(m_impl.dimensions()) == internal::array_prod(op.dimensions()));
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType data, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(data, std::move(done));
-  }
-#endif
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) { return m_impl.evalSubExprsIfNeeded(data); }
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_impl.coeff(index); }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    return m_impl.template packet<LoadMode>(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return m_impl.costPerCoeff(vectorized);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    return internal::TensorBlockResourceRequirements::any();
-  }
-
-  struct BlockIteratorState {
-    Index stride;
-    Index span;
-    Index size;
-    Index count;
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    eigen_assert(m_impl.data() != NULL);
-    eigen_assert((kind == Runtime) || (kind == OneByN && desc.dimensions()[0] == 1) ||
-                 (kind == NByOne && desc.dimensions()[1] == 1));
-
-    if (kind == OneByN || kind == NByOne) {
-      // We can guarantee at compile time that block is just a contiguous slice
-      // of the underlying expression memory buffer.
-      return TensorBlock(internal::TensorBlockKind::kView, m_impl.data() + desc.offset(), desc.dimensions());
-    } else {
-      // This will do additional runtime checks, and in the end it might be also
-      // a view, or it might be a block materialized in the temporary buffer.
-      return TensorBlock::materialize(m_impl.data(), m_dimensions, desc, scratch);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return constCast(m_impl.data()); }
-
-  EIGEN_DEVICE_FUNC const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-
- protected:
-  TensorEvaluator<ArgType, Device> m_impl;
-  NewDimensions m_dimensions;
-};
-
-// Eval as lvalue
-template <typename NewDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<TensorReshapingOp<NewDimensions, ArgType>, Device>
-    : public TensorEvaluator<const TensorReshapingOp<NewDimensions, ArgType>, Device>
-
-{
-  typedef TensorEvaluator<const TensorReshapingOp<NewDimensions, ArgType>, Device> Base;
-  typedef TensorReshapingOp<NewDimensions, ArgType> XprType;
-  typedef NewDimensions Dimensions;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
-  };
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<TensorEvaluator::NumOutputDims, Index> TensorBlockDesc;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(index);
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    this->m_impl.template writePacket<StoreMode>(index, x);
-  }
-
-  template <typename TensorBlock>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
-    eigen_assert(this->m_impl.data() != NULL);
-
-    typedef typename TensorBlock::XprType TensorBlockExpr;
-    typedef internal::TensorBlockAssignment<Scalar, TensorEvaluator::NumOutputDims, TensorBlockExpr, Index>
-        TensorBlockAssign;
-
-    TensorBlockAssign::Run(TensorBlockAssign::target(desc.dimensions(), internal::strides<Layout>(this->dimensions()),
-                                                     this->m_impl.data(), desc.offset()),
-                           block.expr());
-  }
-};
-
-/** \class TensorSlicing
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor slicing class.
- *
- *
- */
-namespace internal {
-template <typename StartIndices, typename Sizes, typename XprType>
-struct traits<TensorSlicingOp<StartIndices, Sizes, XprType>> : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = array_size<StartIndices>::value;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename StartIndices, typename Sizes, typename XprType>
-struct eval<TensorSlicingOp<StartIndices, Sizes, XprType>, Eigen::Dense> {
-  typedef const TensorSlicingOp<StartIndices, Sizes, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename StartIndices, typename Sizes, typename XprType>
-struct nested<TensorSlicingOp<StartIndices, Sizes, XprType>, 1,
-              typename eval<TensorSlicingOp<StartIndices, Sizes, XprType>>::type> {
-  typedef TensorSlicingOp<StartIndices, Sizes, XprType> type;
-};
-
-}  // end namespace internal
-
-template <typename StartIndices, typename Sizes, typename XprType>
-class TensorSlicingOp : public TensorBase<TensorSlicingOp<StartIndices, Sizes, XprType>> {
- public:
-  typedef TensorBase<TensorSlicingOp<StartIndices, Sizes, XprType>> Base;
-  typedef typename Eigen::internal::traits<TensorSlicingOp>::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorSlicingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorSlicingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorSlicingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorSlicingOp(const XprType& expr, const StartIndices& indices,
-                                                        const Sizes& sizes)
-      : m_xpr(expr), m_indices(indices), m_sizes(sizes) {}
-
-  EIGEN_DEVICE_FUNC const StartIndices& startIndices() const { return m_indices; }
-  EIGEN_DEVICE_FUNC const Sizes& sizes() const { return m_sizes; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorSlicingOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const StartIndices m_indices;
-  const Sizes m_sizes;
-};
-
-namespace internal {
-
-// FIXME: Figure out the exact threshold.
-template <typename Index, typename Device, bool BlockAccess>
-struct MemcpyTriggerForSlicing {
-  EIGEN_DEVICE_FUNC MemcpyTriggerForSlicing(const Device& device)
-      : threshold_(static_cast<Index>(2 * device.numThreads())) {}
-  EIGEN_DEVICE_FUNC bool operator()(Index total, Index contiguous) const {
-    const bool prefer_block_evaluation = BlockAccess && total > 32 * 1024;
-    return !prefer_block_evaluation && contiguous > threshold_;
-  }
-
- private:
-  Index threshold_;
-};
-
-// It is very expensive to start the memcpy kernel on GPU: we therefore only
-// use it for large copies.
-#ifdef EIGEN_USE_GPU
-template <typename Index, bool BlockAccess>
-struct MemcpyTriggerForSlicing<Index, GpuDevice, BlockAccess> {
-  EIGEN_DEVICE_FUNC MemcpyTriggerForSlicing(const GpuDevice&) {}
-  EIGEN_DEVICE_FUNC bool operator()(Index, Index contiguous) const { return contiguous > 4 * 1024 * 1024; }
-};
-#endif
-
-// It is very expensive to start the memcpy kernel on GPU: we therefore only
-// use it for large copies.
-#ifdef EIGEN_USE_SYCL
-template <typename Index, bool BlockAccess>
-struct MemcpyTriggerForSlicing<Index, Eigen::SyclDevice, BlockAccess> {
-  EIGEN_DEVICE_FUNC MemcpyTriggerForSlicing(const SyclDevice&) {}
-  EIGEN_DEVICE_FUNC bool operator()(Index, Index contiguous) const { return contiguous > 4 * 1024 * 1024; }
-};
-#endif
-
-}  // namespace internal
-
-// Eval as rvalue
-template <typename StartIndices, typename Sizes, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Device> {
-  typedef TensorSlicingOp<StartIndices, Sizes, ArgType> XprType;
-  static constexpr int NumDims = internal::array_size<Sizes>::value;
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef Sizes Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef StorageMemory<std::remove_const_t<CoeffReturnType>, Device> ConstCastStorage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    // Alignment can't be guaranteed at compile time since it depends on the
-    // slice offsets and sizes.
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess &&
-                  // FIXME: Temporary workaround for bug in slicing of bool tensors.
-                  !internal::is_same<std::remove_const_t<Scalar>, bool>::value,
-    PreferBlockAccess = true,
-    CoordAccess = false,
-    RawAccess = false
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  // Tensor slicing does not change the block type.
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_device(device), m_dimensions(op.sizes()), m_offsets(op.startIndices()) {
-    m_is_identity = true;
-    for (int i = 0; i < internal::array_size<Dimensions>::value; ++i) {
-      eigen_assert(m_impl.dimensions()[i] >= op.sizes()[i] + op.startIndices()[i]);
-      if (m_impl.dimensions()[i] != op.sizes()[i] || op.startIndices()[i] != 0) {
-        m_is_identity = false;
-      }
-    }
-
-    // No strides for scalars.
-    if (NumDims == 0) return;
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    const Sizes& output_dims = op.sizes();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
-      }
-
-      // Don't initialize m_fastOutputStrides[0] since it won't ever be accessed.
-      m_outputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStrides[i] = m_outputStrides[i - 1] * output_dims[i - 1];
-        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
-      }
-    } else {
-      m_inputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
-      }
-
-      // Don't initialize m_fastOutputStrides[NumDims-1] since it won't ever be accessed.
-      m_outputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStrides[i] = m_outputStrides[i + 1] * output_dims[i + 1];
-        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    if (!NumTraits<std::remove_const_t<Scalar>>::RequireInitialization && data && m_impl.data()) {
-      Index contiguous_values = 1;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        for (int i = 0; i < NumDims; ++i) {
-          contiguous_values *= dimensions()[i];
-          if (dimensions()[i] != m_impl.dimensions()[i]) {
-            break;
-          }
-        }
-      } else {
-        for (int i = NumDims - 1; i >= 0; --i) {
-          contiguous_values *= dimensions()[i];
-          if (dimensions()[i] != m_impl.dimensions()[i]) {
-            break;
-          }
-        }
-      }
-      // Use memcpy if it's going to be faster than using the regular evaluation.
-      const internal::MemcpyTriggerForSlicing<Index, Device, BlockAccess> trigger(m_device);
-      if (trigger(internal::array_prod(dimensions()), contiguous_values)) {
-        EvaluatorPointerType src = (EvaluatorPointerType)m_impl.data();
-        for (Index i = 0; i < internal::array_prod(dimensions()); i += contiguous_values) {
-          Index offset = srcCoeff(i);
-          m_device.memcpy((void*)(m_device.get(data + i)), m_device.get(src + offset),
-                          contiguous_values * sizeof(Scalar));
-        }
-        return false;
-      }
-    }
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType /*data*/, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    if (m_is_identity) {
-      return m_impl.coeff(index);
-    } else {
-      return m_impl.coeff(srcCoeff(index));
-    }
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    EIGEN_STATIC_ASSERT((packetSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + packetSize - 1 < internal::array_prod(dimensions()));
-
-    if (m_is_identity) {
-      return m_impl.template packet<LoadMode>(index);
-    }
-
-    Index inputIndices[] = {0, 0};
-    Index indices[] = {index, index + packetSize - 1};
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx0 = indices[0] / m_fastOutputStrides[i];
-        const Index idx1 = indices[1] / m_fastOutputStrides[i];
-        inputIndices[0] += (idx0 + m_offsets[i]) * m_inputStrides[i];
-        inputIndices[1] += (idx1 + m_offsets[i]) * m_inputStrides[i];
-        indices[0] -= idx0 * m_outputStrides[i];
-        indices[1] -= idx1 * m_outputStrides[i];
-      }
-      inputIndices[0] += (indices[0] + m_offsets[0]);
-      inputIndices[1] += (indices[1] + m_offsets[0]);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx0 = indices[0] / m_fastOutputStrides[i];
-        const Index idx1 = indices[1] / m_fastOutputStrides[i];
-        inputIndices[0] += (idx0 + m_offsets[i]) * m_inputStrides[i];
-        inputIndices[1] += (idx1 + m_offsets[i]) * m_inputStrides[i];
-        indices[0] -= idx0 * m_outputStrides[i];
-        indices[1] -= idx1 * m_outputStrides[i];
-      }
-      inputIndices[0] += (indices[0] + m_offsets[NumDims - 1]);
-      inputIndices[1] += (indices[1] + m_offsets[NumDims - 1]);
-    }
-    if (inputIndices[1] - inputIndices[0] == packetSize - 1) {
-      PacketReturnType rslt = m_impl.template packet<Unaligned>(inputIndices[0]);
-      return rslt;
-    } else {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[packetSize];
-      values[0] = m_impl.coeff(inputIndices[0]);
-      values[packetSize - 1] = m_impl.coeff(inputIndices[1]);
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < packetSize - 1; ++i) {
-        values[i] = coeff(index + i);
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, m_is_identity ? 1 : NumDims);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.lastLevelCacheSize();
-    return internal::TensorBlockResourceRequirements::merge(
-        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size), m_impl.getResourceRequirements());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    TensorBlockDesc arg_desc = desc.WithOffset(srcCoeff(desc.offset()));
-    TensorBlock block = m_impl.block(arg_desc, scratch);
-    if (!arg_desc.HasDestinationBuffer()) desc.DropDestinationBuffer();
-    return block;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Storage::Type data() const {
-    typename Storage::Type result = constCast(m_impl.data());
-    if (result) {
-      Index offset = 0;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        for (int i = 0; i < NumDims; ++i) {
-          if (m_dimensions[i] != m_impl.dimensions()[i]) {
-            offset += m_offsets[i] * m_inputStrides[i];
-            for (int j = i + 1; j < NumDims; ++j) {
-              if (m_dimensions[j] > 1) {
-                return NULL;
-              }
-              offset += m_offsets[j] * m_inputStrides[j];
-            }
-            break;
-          }
-        }
-      } else {
-        for (int i = NumDims - 1; i >= 0; --i) {
-          if (m_dimensions[i] != m_impl.dimensions()[i]) {
-            offset += m_offsets[i] * m_inputStrides[i];
-            for (int j = i - 1; j >= 0; --j) {
-              if (m_dimensions[j] > 1) {
-                return NULL;
-              }
-              offset += m_offsets[j] * m_inputStrides[j];
-            }
-            break;
-          }
-        }
-      }
-      return result + offset;
-    }
-    return NULL;
-  }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_fastOutputStrides[i];
-        inputIndex += (idx + m_offsets[i]) * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      inputIndex += (index + m_offsets[0]);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_fastOutputStrides[i];
-        inputIndex += (idx + m_offsets[i]) * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      inputIndex += (index + m_offsets[NumDims - 1]);
-    }
-    return inputIndex;
-  }
-
-  array<Index, NumDims> m_outputStrides;
-  array<internal::TensorIntDivisor<Index>, NumDims> m_fastOutputStrides;
-  array<Index, NumDims> m_inputStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  const Device EIGEN_DEVICE_REF m_device;
-  Dimensions m_dimensions;
-  bool m_is_identity;
-  const StartIndices m_offsets;
-};
-
-// Eval as lvalue
-template <typename StartIndices, typename Sizes, typename ArgType, typename Device>
-struct TensorEvaluator<TensorSlicingOp<StartIndices, Sizes, ArgType>, Device>
-    : public TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorSlicingOp<StartIndices, Sizes, ArgType>, Device> Base;
-  typedef TensorSlicingOp<StartIndices, Sizes, ArgType> XprType;
-  static constexpr int NumDims = internal::array_size<Sizes>::value;
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef Sizes Dimensions;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::BlockAccess,
-    PreferBlockAccess = true,
-    CoordAccess = false,
-    RawAccess = (NumDims == 1) & TensorEvaluator<ArgType, Device>::RawAccess
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    if (this->m_is_identity) {
-      return this->m_impl.coeffRef(index);
-    } else {
-      return this->m_impl.coeffRef(this->srcCoeff(index));
-    }
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    if (this->m_is_identity) {
-      this->m_impl.template writePacket<StoreMode>(index, x);
-      return;
-    }
-
-    const int packetSize = PacketType<CoeffReturnType, Device>::size;
-    Index inputIndices[] = {0, 0};
-    Index indices[] = {index, index + packetSize - 1};
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx0 = indices[0] / this->m_fastOutputStrides[i];
-        const Index idx1 = indices[1] / this->m_fastOutputStrides[i];
-        inputIndices[0] += (idx0 + this->m_offsets[i]) * this->m_inputStrides[i];
-        inputIndices[1] += (idx1 + this->m_offsets[i]) * this->m_inputStrides[i];
-        indices[0] -= idx0 * this->m_outputStrides[i];
-        indices[1] -= idx1 * this->m_outputStrides[i];
-      }
-      inputIndices[0] += (indices[0] + this->m_offsets[0]);
-      inputIndices[1] += (indices[1] + this->m_offsets[0]);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx0 = indices[0] / this->m_fastOutputStrides[i];
-        const Index idx1 = indices[1] / this->m_fastOutputStrides[i];
-        inputIndices[0] += (idx0 + this->m_offsets[i]) * this->m_inputStrides[i];
-        inputIndices[1] += (idx1 + this->m_offsets[i]) * this->m_inputStrides[i];
-        indices[0] -= idx0 * this->m_outputStrides[i];
-        indices[1] -= idx1 * this->m_outputStrides[i];
-      }
-      inputIndices[0] += (indices[0] + this->m_offsets[NumDims - 1]);
-      inputIndices[1] += (indices[1] + this->m_offsets[NumDims - 1]);
-    }
-    if (inputIndices[1] - inputIndices[0] == packetSize - 1) {
-      this->m_impl.template writePacket<StoreMode>(inputIndices[0], x);
-    } else {
-      EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
-      internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-      this->m_impl.coeffRef(inputIndices[0]) = values[0];
-      this->m_impl.coeffRef(inputIndices[1]) = values[packetSize - 1];
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < packetSize - 1; ++i) {
-        this->coeffRef(index + i) = values[i];
-      }
-    }
-  }
-
-  template <typename TensorBlock>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
-    TensorBlockDesc arg_desc = desc.WithOffset(this->srcCoeff(desc.offset()));
-    this->m_impl.writeBlock(arg_desc, block);
-  }
-};
-
-namespace internal {
-template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
-struct traits<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>> : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = array_size<StartIndices>::value;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
-struct eval<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>, Eigen::Dense> {
-  typedef const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
-struct nested<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>, 1,
-              typename eval<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>>::type> {
-  typedef TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType> type;
-};
-
-}  // end namespace internal
-
-template <typename StartIndices, typename StopIndices, typename Strides, typename XprType>
-class TensorStridingSlicingOp
-    : public TensorBase<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>> {
- public:
-  typedef TensorBase<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, XprType>> Base;
-  typedef typename internal::traits<TensorStridingSlicingOp>::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename internal::nested<TensorStridingSlicingOp>::type Nested;
-  typedef typename internal::traits<TensorStridingSlicingOp>::StorageKind StorageKind;
-  typedef typename internal::traits<TensorStridingSlicingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorStridingSlicingOp(const XprType& expr, const StartIndices& startIndices,
-                                                                const StopIndices& stopIndices, const Strides& strides)
-      : m_xpr(expr), m_startIndices(startIndices), m_stopIndices(stopIndices), m_strides(strides) {}
-
-  EIGEN_DEVICE_FUNC const StartIndices& startIndices() const { return m_startIndices; }
-  EIGEN_DEVICE_FUNC const StartIndices& stopIndices() const { return m_stopIndices; }
-  EIGEN_DEVICE_FUNC const StartIndices& strides() const { return m_strides; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorStridingSlicingOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const StartIndices m_startIndices;
-  const StopIndices m_stopIndices;
-  const Strides m_strides;
-};
-
-// Eval as rvalue
-template <typename StartIndices, typename StopIndices, typename Strides, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device> {
-  typedef TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType> XprType;
-  static constexpr int NumDims = internal::array_size<Strides>::value;
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  typedef Strides Dimensions;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    // Alignment can't be guaranteed at compile time since it depends on the
-    // slice offsets and sizes.
-    IsAligned = false,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_device(device), m_strides(op.strides()) {
-    // Handle degenerate intervals by gracefully clamping and allowing m_dimensions to be zero
-    DSizes<Index, NumDims> startIndicesClamped, stopIndicesClamped;
-    for (ptrdiff_t i = 0; i < internal::array_size<Dimensions>::value; ++i) {
-      eigen_assert(m_strides[i] != 0 && "0 stride is invalid");
-      if (m_strides[i] > 0) {
-        startIndicesClamped[i] = clamp(op.startIndices()[i], 0, m_impl.dimensions()[i]);
-        stopIndicesClamped[i] = clamp(op.stopIndices()[i], 0, m_impl.dimensions()[i]);
-      } else {
-        /* implies m_strides[i] < 0 by assert */
-        startIndicesClamped[i] = clamp(op.startIndices()[i], -1, m_impl.dimensions()[i] - 1);
-        stopIndicesClamped[i] = clamp(op.stopIndices()[i], -1, m_impl.dimensions()[i] - 1);
-      }
-      m_startIndices[i] = startIndicesClamped[i];
-    }
-
-    typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
-    const InputDimensions& input_dims = m_impl.dimensions();
-
-    // compute output tensor shape
-    m_is_identity = true;
-    for (int i = 0; i < NumDims; i++) {
-      Index interval = stopIndicesClamped[i] - startIndicesClamped[i];
-      if (interval == 0 || ((interval < 0) != (m_strides[i] < 0))) {
-        m_dimensions[i] = 0;
-      } else {
-        m_dimensions[i] = (interval / m_strides[i]) + (interval % m_strides[i] != 0 ? 1 : 0);
-        eigen_assert(m_dimensions[i] >= 0);
-      }
-      if (m_strides[i] != 1 || interval != m_impl.dimensions()[i]) {
-        m_is_identity = false;
-      }
-    }
-
-    Strides output_dims = m_dimensions;
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputStrides[0] = m_strides[0];
-      m_offsets[0] = startIndicesClamped[0];
-      Index previousDimProduct = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        previousDimProduct *= input_dims[i - 1];
-        m_inputStrides[i] = previousDimProduct * m_strides[i];
-        m_offsets[i] = startIndicesClamped[i] * previousDimProduct;
-      }
-
-      // Don't initialize m_fastOutputStrides[0] since it won't ever be accessed.
-      m_outputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStrides[i] = m_outputStrides[i - 1] * output_dims[i - 1];
-        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
-      }
-    } else {
-      m_inputStrides[NumDims - 1] = m_strides[NumDims - 1];
-      m_offsets[NumDims - 1] = startIndicesClamped[NumDims - 1];
-      Index previousDimProduct = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        previousDimProduct *= input_dims[i + 1];
-        m_inputStrides[i] = previousDimProduct * m_strides[i];
-        m_offsets[i] = startIndicesClamped[i] * previousDimProduct;
-      }
-
-      m_outputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStrides[i] = m_outputStrides[i + 1] * output_dims[i + 1];
-        m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : 1);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    if (m_is_identity) {
-      return m_impl.coeff(index);
-    } else {
-      return m_impl.coeff(srcCoeff(index));
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, m_is_identity ? 1 : NumDims);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Storage::Type data() const { return NULL; }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i >= 0; --i) {
-        const Index idx = index / m_fastOutputStrides[i];
-        inputIndex += idx * m_inputStrides[i] + m_offsets[i];
-        index -= idx * m_outputStrides[i];
-      }
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims; ++i) {
-        const Index idx = index / m_fastOutputStrides[i];
-        inputIndex += idx * m_inputStrides[i] + m_offsets[i];
-        index -= idx * m_outputStrides[i];
-      }
-    }
-    return inputIndex;
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index clamp(Index value, Index min, Index max) {
-#ifndef SYCL_DEVICE_ONLY
-    return numext::maxi(min, numext::mini(max, value));
-#else
-    return cl::sycl::clamp(value, min, max);
-#endif
-  }
-
-  array<Index, NumDims> m_outputStrides;
-  array<internal::TensorIntDivisor<Index>, NumDims> m_fastOutputStrides;
-  array<Index, NumDims> m_inputStrides;
-  bool m_is_identity;
-  TensorEvaluator<ArgType, Device> m_impl;
-  const Device EIGEN_DEVICE_REF m_device;
-  DSizes<Index, NumDims> m_startIndices;  // clamped startIndices
-  DSizes<Index, NumDims> m_dimensions;
-  DSizes<Index, NumDims> m_offsets;  // offset in a flattened shape
-  const Strides m_strides;
-};
-
-// Eval as lvalue
-template <typename StartIndices, typename StopIndices, typename Strides, typename ArgType, typename Device>
-struct TensorEvaluator<TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device>
-    : public TensorEvaluator<const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType>, Device> Base;
-  typedef TensorStridingSlicingOp<StartIndices, StopIndices, Strides, ArgType> XprType;
-  static constexpr int NumDims = internal::array_size<Strides>::value;
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-
-  enum {
-    IsAligned = false,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = TensorEvaluator<ArgType, Device>::CoordAccess,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef Strides Dimensions;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    if (this->m_is_identity) {
-      return this->m_impl.coeffRef(index);
-    } else {
-      return this->m_impl.coeffRef(this->srcCoeff(index));
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_MORPHING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorPadding.h b/unsupported/Eigen/src/Tensor/TensorPadding.h
deleted file mode 100644
index 8157596..0000000
--- a/unsupported/Eigen/src/Tensor/TensorPadding.h
+++ /dev/null
@@ -1,620 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_PADDING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_PADDING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename PaddingDimensions, typename XprType>
-struct traits<TensorPaddingOp<PaddingDimensions, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename PaddingDimensions, typename XprType>
-struct eval<TensorPaddingOp<PaddingDimensions, XprType>, Eigen::Dense> {
-  typedef const TensorPaddingOp<PaddingDimensions, XprType>& type;
-};
-
-template <typename PaddingDimensions, typename XprType>
-struct nested<TensorPaddingOp<PaddingDimensions, XprType>, 1,
-              typename eval<TensorPaddingOp<PaddingDimensions, XprType> >::type> {
-  typedef TensorPaddingOp<PaddingDimensions, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor padding class.
- * At the moment only padding with a constant value is supported.
- *
- */
-template <typename PaddingDimensions, typename XprType>
-class TensorPaddingOp : public TensorBase<TensorPaddingOp<PaddingDimensions, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorPaddingOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorPaddingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorPaddingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorPaddingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorPaddingOp(const XprType& expr, const PaddingDimensions& padding_dims,
-                                                        const Scalar padding_value)
-      : m_xpr(expr), m_padding_dims(padding_dims), m_padding_value(padding_value) {}
-
-  EIGEN_DEVICE_FUNC const PaddingDimensions& padding() const { return m_padding_dims; }
-  EIGEN_DEVICE_FUNC Scalar padding_value() const { return m_padding_value; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const PaddingDimensions m_padding_dims;
-  const Scalar m_padding_value;
-};
-
-// Eval as rvalue
-template <typename PaddingDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorPaddingOp<PaddingDimensions, ArgType>, Device> {
-  typedef TensorPaddingOp<PaddingDimensions, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<PaddingDimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = true,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
-    PreferBlockAccess = true,
-    CoordAccess = true,
-    RawAccess = false
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_padding(op.padding()), m_paddingValue(op.padding_value()), m_device(device) {
-    // The padding op doesn't change the rank of the tensor. Directly padding a scalar would lead
-    // to a vector, which doesn't make sense. Instead one should reshape the scalar into a vector
-    // of 1 element first and then pad.
-    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    // Compute dimensions
-    m_dimensions = m_impl.dimensions();
-    for (int i = 0; i < NumDims; ++i) {
-      m_dimensions[i] += m_padding[i].first + m_padding[i].second;
-    }
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputStrides[0] = 1;
-      m_outputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
-        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-      }
-      m_outputStrides[NumDims] = m_outputStrides[NumDims - 1] * m_dimensions[NumDims - 1];
-    } else {
-      m_inputStrides[NumDims - 1] = 1;
-      m_outputStrides[NumDims] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
-        m_outputStrides[i + 1] = m_outputStrides[i + 2] * m_dimensions[i + 1];
-      }
-      m_outputStrides[0] = m_outputStrides[1] * m_dimensions[0];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    eigen_assert(index < dimensions().TotalSize());
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_outputStrides[i];
-        if (isPaddingAtIndexForDim(idx, i)) {
-          return m_paddingValue;
-        }
-        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (isPaddingAtIndexForDim(index, 0)) {
-        return m_paddingValue;
-      }
-      inputIndex += (index - m_padding[0].first);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_outputStrides[i + 1];
-        if (isPaddingAtIndexForDim(idx, i)) {
-          return m_paddingValue;
-        }
-        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
-        index -= idx * m_outputStrides[i + 1];
-      }
-      if (isPaddingAtIndexForDim(index, NumDims - 1)) {
-        return m_paddingValue;
-      }
-      inputIndex += (index - m_padding[NumDims - 1].first);
-    }
-    return m_impl.coeff(inputIndex);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      return packetColMajor(index);
-    }
-    return packetRowMajor(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    TensorOpCost cost = m_impl.costPerCoeff(vectorized);
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims; ++i) updateCostPerDimension(cost, i, i == 0);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i >= 0; --i) updateCostPerDimension(cost, i, i == NumDims - 1);
-    }
-    return cost;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.lastLevelCacheSize();
-    return internal::TensorBlockResourceRequirements::merge(
-        internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size), m_impl.getResourceRequirements());
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    // If one of the dimensions is zero, return empty block view.
-    if (desc.size() == 0) {
-      return TensorBlock(internal::TensorBlockKind::kView, NULL, desc.dimensions());
-    }
-
-    static const bool IsColMajor = Layout == static_cast<int>(ColMajor);
-    const int inner_dim_idx = IsColMajor ? 0 : NumDims - 1;
-
-    Index offset = desc.offset();
-
-    // Compute offsets in the output tensor corresponding to the desc.offset().
-    DSizes<Index, NumDims> output_offsets;
-    for (int i = NumDims - 1; i > 0; --i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      const int stride_dim = IsColMajor ? dim : dim + 1;
-      output_offsets[dim] = offset / m_outputStrides[stride_dim];
-      offset -= output_offsets[dim] * m_outputStrides[stride_dim];
-    }
-    output_offsets[inner_dim_idx] = offset;
-
-    // Offsets in the input corresponding to output offsets.
-    DSizes<Index, NumDims> input_offsets = output_offsets;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      input_offsets[dim] = input_offsets[dim] - m_padding[dim].first;
-    }
-
-    // Compute offset in the input buffer (at this point it might be illegal and
-    // point outside of the input buffer, because we don't check for negative
-    // offsets, it will be autocorrected in the block iteration loop below).
-    Index input_offset = 0;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      input_offset += input_offsets[dim] * m_inputStrides[dim];
-    }
-
-    // Destination buffer and scratch buffer both indexed from 0 and have the
-    // same dimensions as the requested block (for destination buffer this
-    // property is guaranteed by `desc.destination()`).
-    Index output_offset = 0;
-    const DSizes<Index, NumDims> output_strides = internal::strides<Layout>(desc.dimensions());
-
-    // NOTE(ezhulenev): We initialize block iteration state for `NumDims - 1`
-    // dimensions, skipping innermost dimension. In theory it should be possible
-    // to squeeze matching innermost dimensions, however in practice that did
-    // not show any improvements in benchmarks. Also in practice first outer
-    // dimension usually has padding, and will prevent squeezing.
-
-    // Initialize output block iterator state. Dimension in this array are
-    // always in inner_most -> outer_most order (col major layout).
-    array<BlockIteratorState, NumDims - 1> it;
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const int dim = IsColMajor ? i + 1 : NumDims - i - 2;
-      it[i].count = 0;
-      it[i].size = desc.dimension(dim);
-
-      it[i].input_stride = m_inputStrides[dim];
-      it[i].input_span = it[i].input_stride * (it[i].size - 1);
-
-      it[i].output_stride = output_strides[dim];
-      it[i].output_span = it[i].output_stride * (it[i].size - 1);
-    }
-
-    const Index input_inner_dim_size = static_cast<Index>(m_impl.dimensions()[inner_dim_idx]);
-
-    // Total output size.
-    const Index output_size = desc.size();
-
-    // We will fill inner dimension of this size in the output. It might be
-    // larger than the inner dimension in the input, so we might have to pad
-    // before/after we copy values from the input inner dimension.
-    const Index output_inner_dim_size = desc.dimension(inner_dim_idx);
-
-    // How many values to fill with padding BEFORE reading from the input inner
-    // dimension.
-    const Index output_inner_pad_before_size =
-        input_offsets[inner_dim_idx] < 0
-            ? numext::mini(numext::abs(input_offsets[inner_dim_idx]), output_inner_dim_size)
-            : 0;
-
-    // How many values we can actually copy from the input inner dimension.
-    const Index output_inner_copy_size = numext::mini(
-        // Want to copy from input.
-        (output_inner_dim_size - output_inner_pad_before_size),
-        // Can copy from input.
-        numext::maxi(input_inner_dim_size - (input_offsets[inner_dim_idx] + output_inner_pad_before_size), Index(0)));
-
-    eigen_assert(output_inner_copy_size >= 0);
-
-    // How many values to fill with padding AFTER reading from the input inner
-    // dimension.
-    const Index output_inner_pad_after_size =
-        (output_inner_dim_size - output_inner_copy_size - output_inner_pad_before_size);
-
-    // Sanity check, sum of all sizes must be equal to the output size.
-    eigen_assert(output_inner_dim_size ==
-                 (output_inner_pad_before_size + output_inner_copy_size + output_inner_pad_after_size));
-
-    // Keep track of current coordinates and padding in the output.
-    DSizes<Index, NumDims> output_coord = output_offsets;
-    DSizes<Index, NumDims> output_padded;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = IsColMajor ? i : NumDims - i - 1;
-      output_padded[dim] = isPaddingAtIndexForDim(output_coord[dim], dim);
-    }
-
-    typedef internal::StridedLinearBufferCopy<ScalarNoConst, Index> LinCopy;
-
-    // Prepare storage for the materialized padding result.
-    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
-
-    // TODO(ezhulenev): Squeeze multiple non-padded inner dimensions into a
-    // single logical inner dimension.
-
-    // When possible we squeeze writes for the innermost (only if non-padded)
-    // dimension with the first padded dimension. This allows to reduce the
-    // number of calls to LinCopy and better utilize vector instructions.
-    const bool squeeze_writes = NumDims > 1 &&
-                                // inner dimension is not padded
-                                (input_inner_dim_size == m_dimensions[inner_dim_idx]) &&
-                                // and equal to the block inner dimension
-                                (input_inner_dim_size == output_inner_dim_size);
-
-    const int squeeze_dim = IsColMajor ? inner_dim_idx + 1 : inner_dim_idx - 1;
-
-    // Maximum coordinate on a squeeze dimension that we can write to.
-    const Index squeeze_max_coord =
-        squeeze_writes ? numext::mini(
-                             // max non-padded element in the input
-                             static_cast<Index>(m_dimensions[squeeze_dim] - m_padding[squeeze_dim].second),
-                             // max element in the output buffer
-                             static_cast<Index>(output_offsets[squeeze_dim] + desc.dimension(squeeze_dim)))
-                       : static_cast<Index>(0);
-
-    // Iterate copying data from `m_impl.data()` to the output buffer.
-    for (Index size = 0; size < output_size;) {
-      // Detect if we are in the padded region (exclude innermost dimension).
-      bool is_padded = false;
-      for (int j = 1; j < NumDims; ++j) {
-        const int dim = IsColMajor ? j : NumDims - j - 1;
-        is_padded = output_padded[dim];
-        if (is_padded) break;
-      }
-
-      if (is_padded) {
-        // Fill single innermost dimension with padding value.
-        size += output_inner_dim_size;
-
-        LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(output_offset, 1, block_storage.data()),
-                                                         typename LinCopy::Src(0, 0, &m_paddingValue),
-                                                         output_inner_dim_size);
-
-      } else if (squeeze_writes) {
-        // Squeeze multiple reads from innermost dimensions.
-        const Index squeeze_num = squeeze_max_coord - output_coord[squeeze_dim];
-        size += output_inner_dim_size * squeeze_num;
-
-        // Copy `squeeze_num` inner dimensions from input to output.
-        LinCopy::template Run<LinCopy::Kind::Linear>(typename LinCopy::Dst(output_offset, 1, block_storage.data()),
-                                                     typename LinCopy::Src(input_offset, 1, m_impl.data()),
-                                                     output_inner_dim_size * squeeze_num);
-
-        // Update iteration state for only `squeeze_num - 1` processed inner
-        // dimensions, because we have another iteration state update at the end
-        // of the loop that will update iteration state for the last inner
-        // processed dimension.
-        it[0].count += (squeeze_num - 1);
-        input_offset += it[0].input_stride * (squeeze_num - 1);
-        output_offset += it[0].output_stride * (squeeze_num - 1);
-        output_coord[squeeze_dim] += (squeeze_num - 1);
-
-      } else {
-        // Single read from innermost dimension.
-        size += output_inner_dim_size;
-
-        {  // Fill with padding before copying from input inner dimension.
-          const Index out = output_offset;
-
-          LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(out, 1, block_storage.data()),
-                                                           typename LinCopy::Src(0, 0, &m_paddingValue),
-                                                           output_inner_pad_before_size);
-        }
-
-        {  // Copy data from input inner dimension.
-          const Index out = output_offset + output_inner_pad_before_size;
-          const Index in = input_offset + output_inner_pad_before_size;
-
-          eigen_assert(output_inner_copy_size == 0 || m_impl.data() != NULL);
-
-          LinCopy::template Run<LinCopy::Kind::Linear>(typename LinCopy::Dst(out, 1, block_storage.data()),
-                                                       typename LinCopy::Src(in, 1, m_impl.data()),
-                                                       output_inner_copy_size);
-        }
-
-        {  // Fill with padding after copying from input inner dimension.
-          const Index out = output_offset + output_inner_pad_before_size + output_inner_copy_size;
-
-          LinCopy::template Run<LinCopy::Kind::FillLinear>(typename LinCopy::Dst(out, 1, block_storage.data()),
-                                                           typename LinCopy::Src(0, 0, &m_paddingValue),
-                                                           output_inner_pad_after_size);
-        }
-      }
-
-      for (int j = 0; j < NumDims - 1; ++j) {
-        const int dim = IsColMajor ? j + 1 : NumDims - j - 2;
-
-        if (++it[j].count < it[j].size) {
-          input_offset += it[j].input_stride;
-          output_offset += it[j].output_stride;
-          output_coord[dim] += 1;
-          output_padded[dim] = isPaddingAtIndexForDim(output_coord[dim], dim);
-          break;
-        }
-        it[j].count = 0;
-        input_offset -= it[j].input_span;
-        output_offset -= it[j].output_span;
-        output_coord[dim] -= it[j].size - 1;
-        output_padded[dim] = isPaddingAtIndexForDim(output_coord[dim], dim);
-      }
-    }
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return NULL; }
-
- private:
-  struct BlockIteratorState {
-    BlockIteratorState() : count(0), size(0), input_stride(0), input_span(0), output_stride(0), output_span(0) {}
-
-    Index count;
-    Index size;
-    Index input_stride;
-    Index input_span;
-    Index output_stride;
-    Index output_span;
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool isPaddingAtIndexForDim(Index index, int dim_index) const {
-    return (!internal::index_pair_first_statically_eq<PaddingDimensions>(dim_index, 0) &&
-            index < m_padding[dim_index].first) ||
-           (!internal::index_pair_second_statically_eq<PaddingDimensions>(dim_index, 0) &&
-            index >= m_dimensions[dim_index] - m_padding[dim_index].second);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool isLeftPaddingCompileTimeZero(int dim_index) const {
-    return internal::index_pair_first_statically_eq<PaddingDimensions>(dim_index, 0);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool isRightPaddingCompileTimeZero(int dim_index) const {
-    return internal::index_pair_second_statically_eq<PaddingDimensions>(dim_index, 0);
-  }
-
-  void updateCostPerDimension(TensorOpCost& cost, int i, bool first) const {
-    const double in = static_cast<double>(m_impl.dimensions()[i]);
-    const double out = in + m_padding[i].first + m_padding[i].second;
-    if (out == 0) return;
-    const double reduction = in / out;
-    cost *= reduction;
-    if (first) {
-      cost += TensorOpCost(0, 0, 2 * TensorOpCost::AddCost<Index>() + reduction * (1 * TensorOpCost::AddCost<Index>()));
-    } else {
-      cost += TensorOpCost(0, 0,
-                           2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
-                               reduction * (2 * TensorOpCost::MulCost<Index>() + 1 * TensorOpCost::DivCost<Index>()));
-    }
-  }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetColMajor(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    const Index initialIndex = index;
-    Index inputIndex = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = NumDims - 1; i > 0; --i) {
-      const Index firstIdx = index;
-      const Index lastIdx = index + PacketSize - 1;
-      const Index lastPaddedLeft = m_padding[i].first * m_outputStrides[i];
-      const Index firstPaddedRight = (m_dimensions[i] - m_padding[i].second) * m_outputStrides[i];
-      const Index lastPaddedRight = m_outputStrides[i + 1];
-
-      if (!isLeftPaddingCompileTimeZero(i) && lastIdx < lastPaddedLeft) {
-        // all the coefficient are in the padding zone.
-        return internal::pset1<PacketReturnType>(m_paddingValue);
-      } else if (!isRightPaddingCompileTimeZero(i) && firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
-        // all the coefficient are in the padding zone.
-        return internal::pset1<PacketReturnType>(m_paddingValue);
-      } else if ((isLeftPaddingCompileTimeZero(i) && isRightPaddingCompileTimeZero(i)) ||
-                 (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight)) {
-        // all the coefficient are between the 2 padding zones.
-        const Index idx = index / m_outputStrides[i];
-        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      } else {
-        // Every other case
-        return packetWithPossibleZero(initialIndex);
-      }
-    }
-
-    const Index lastIdx = index + PacketSize - 1;
-    const Index firstIdx = index;
-    const Index lastPaddedLeft = m_padding[0].first;
-    const Index firstPaddedRight = (m_dimensions[0] - m_padding[0].second);
-    const Index lastPaddedRight = m_outputStrides[1];
-
-    if (!isLeftPaddingCompileTimeZero(0) && lastIdx < lastPaddedLeft) {
-      // all the coefficient are in the padding zone.
-      return internal::pset1<PacketReturnType>(m_paddingValue);
-    } else if (!isRightPaddingCompileTimeZero(0) && firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
-      // all the coefficient are in the padding zone.
-      return internal::pset1<PacketReturnType>(m_paddingValue);
-    } else if ((isLeftPaddingCompileTimeZero(0) && isRightPaddingCompileTimeZero(0)) ||
-               (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight)) {
-      // all the coefficient are between the 2 padding zones.
-      inputIndex += (index - m_padding[0].first);
-      return m_impl.template packet<Unaligned>(inputIndex);
-    }
-    // Every other case
-    return packetWithPossibleZero(initialIndex);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetRowMajor(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    const Index initialIndex = index;
-    Index inputIndex = 0;
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const Index firstIdx = index;
-      const Index lastIdx = index + PacketSize - 1;
-      const Index lastPaddedLeft = m_padding[i].first * m_outputStrides[i + 1];
-      const Index firstPaddedRight = (m_dimensions[i] - m_padding[i].second) * m_outputStrides[i + 1];
-      const Index lastPaddedRight = m_outputStrides[i];
-
-      if (!isLeftPaddingCompileTimeZero(i) && lastIdx < lastPaddedLeft) {
-        // all the coefficient are in the padding zone.
-        return internal::pset1<PacketReturnType>(m_paddingValue);
-      } else if (!isRightPaddingCompileTimeZero(i) && firstIdx >= firstPaddedRight && lastIdx < lastPaddedRight) {
-        // all the coefficient are in the padding zone.
-        return internal::pset1<PacketReturnType>(m_paddingValue);
-      } else if ((isLeftPaddingCompileTimeZero(i) && isRightPaddingCompileTimeZero(i)) ||
-                 (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight)) {
-        // all the coefficient are between the 2 padding zones.
-        const Index idx = index / m_outputStrides[i + 1];
-        inputIndex += (idx - m_padding[i].first) * m_inputStrides[i];
-        index -= idx * m_outputStrides[i + 1];
-      } else {
-        // Every other case
-        return packetWithPossibleZero(initialIndex);
-      }
-    }
-
-    const Index lastIdx = index + PacketSize - 1;
-    const Index firstIdx = index;
-    const Index lastPaddedLeft = m_padding[NumDims - 1].first;
-    const Index firstPaddedRight = (m_dimensions[NumDims - 1] - m_padding[NumDims - 1].second);
-    const Index lastPaddedRight = m_outputStrides[NumDims - 1];
-
-    if (!isLeftPaddingCompileTimeZero(NumDims - 1) && lastIdx < lastPaddedLeft) {
-      // all the coefficient are in the padding zone.
-      return internal::pset1<PacketReturnType>(m_paddingValue);
-    } else if (!isRightPaddingCompileTimeZero(NumDims - 1) && firstIdx >= firstPaddedRight &&
-               lastIdx < lastPaddedRight) {
-      // all the coefficient are in the padding zone.
-      return internal::pset1<PacketReturnType>(m_paddingValue);
-    } else if ((isLeftPaddingCompileTimeZero(NumDims - 1) && isRightPaddingCompileTimeZero(NumDims - 1)) ||
-               (firstIdx >= lastPaddedLeft && lastIdx < firstPaddedRight)) {
-      // all the coefficient are between the 2 padding zones.
-      inputIndex += (index - m_padding[NumDims - 1].first);
-      return m_impl.template packet<Unaligned>(inputIndex);
-    }
-    // Every other case
-    return packetWithPossibleZero(initialIndex);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetWithPossibleZero(Index index) const {
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  Dimensions m_dimensions;
-  array<Index, NumDims + 1> m_outputStrides;
-  array<Index, NumDims> m_inputStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  PaddingDimensions m_padding;
-
-  Scalar m_paddingValue;
-
-  const Device EIGEN_DEVICE_REF m_device;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_PADDING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorPatch.h b/unsupported/Eigen/src/Tensor/TensorPatch.h
deleted file mode 100644
index 6e767a7..0000000
--- a/unsupported/Eigen/src/Tensor/TensorPatch.h
+++ /dev/null
@@ -1,258 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_PATCH_H
-#define EIGEN_CXX11_TENSOR_TENSOR_PATCH_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename PatchDim, typename XprType>
-struct traits<TensorPatchOp<PatchDim, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions + 1;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename PatchDim, typename XprType>
-struct eval<TensorPatchOp<PatchDim, XprType>, Eigen::Dense> {
-  typedef const TensorPatchOp<PatchDim, XprType>& type;
-};
-
-template <typename PatchDim, typename XprType>
-struct nested<TensorPatchOp<PatchDim, XprType>, 1, typename eval<TensorPatchOp<PatchDim, XprType> >::type> {
-  typedef TensorPatchOp<PatchDim, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor patch class.
- */
-template <typename PatchDim, typename XprType>
-class TensorPatchOp : public TensorBase<TensorPatchOp<PatchDim, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorPatchOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorPatchOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorPatchOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorPatchOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorPatchOp(const XprType& expr, const PatchDim& patch_dims)
-      : m_xpr(expr), m_patch_dims(patch_dims) {}
-
-  EIGEN_DEVICE_FUNC const PatchDim& patch_dims() const { return m_patch_dims; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const PatchDim m_patch_dims;
-};
-
-// Eval as rvalue
-template <typename PatchDim, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorPatchOp<PatchDim, ArgType>, Device> {
-  typedef TensorPatchOp<PatchDim, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value + 1;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {
-    Index num_patches = 1;
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    const PatchDim& patch_dims = op.patch_dims();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        m_dimensions[i] = patch_dims[i];
-        num_patches *= (input_dims[i] - patch_dims[i] + 1);
-      }
-      m_dimensions[NumDims - 1] = num_patches;
-
-      m_inputStrides[0] = 1;
-      m_patchStrides[0] = 1;
-      for (int i = 1; i < NumDims - 1; ++i) {
-        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
-        m_patchStrides[i] = m_patchStrides[i - 1] * (input_dims[i - 1] - patch_dims[i - 1] + 1);
-      }
-      m_outputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-      }
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        m_dimensions[i + 1] = patch_dims[i];
-        num_patches *= (input_dims[i] - patch_dims[i] + 1);
-      }
-      m_dimensions[0] = num_patches;
-
-      m_inputStrides[NumDims - 2] = 1;
-      m_patchStrides[NumDims - 2] = 1;
-      for (int i = NumDims - 3; i >= 0; --i) {
-        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
-        m_patchStrides[i] = m_patchStrides[i + 1] * (input_dims[i + 1] - patch_dims[i + 1] + 1);
-      }
-      m_outputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    Index output_stride_index = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? NumDims - 1 : 0;
-    // Find the location of the first element of the patch.
-    Index patchIndex = index / m_outputStrides[output_stride_index];
-    // Find the offset of the element wrt the location of the first element.
-    Index patchOffset = index - patchIndex * m_outputStrides[output_stride_index];
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 2; i > 0; --i) {
-        const Index patchIdx = patchIndex / m_patchStrides[i];
-        patchIndex -= patchIdx * m_patchStrides[i];
-        const Index offsetIdx = patchOffset / m_outputStrides[i];
-        patchOffset -= offsetIdx * m_outputStrides[i];
-        inputIndex += (patchIdx + offsetIdx) * m_inputStrides[i];
-      }
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 2; ++i) {
-        const Index patchIdx = patchIndex / m_patchStrides[i];
-        patchIndex -= patchIdx * m_patchStrides[i];
-        const Index offsetIdx = patchOffset / m_outputStrides[i + 1];
-        patchOffset -= offsetIdx * m_outputStrides[i + 1];
-        inputIndex += (patchIdx + offsetIdx) * m_inputStrides[i];
-      }
-    }
-    inputIndex += (patchIndex + patchOffset);
-    return m_impl.coeff(inputIndex);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    Index output_stride_index = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? NumDims - 1 : 0;
-    Index indices[2] = {index, index + PacketSize - 1};
-    Index patchIndices[2] = {indices[0] / m_outputStrides[output_stride_index],
-                             indices[1] / m_outputStrides[output_stride_index]};
-    Index patchOffsets[2] = {indices[0] - patchIndices[0] * m_outputStrides[output_stride_index],
-                             indices[1] - patchIndices[1] * m_outputStrides[output_stride_index]};
-
-    Index inputIndices[2] = {0, 0};
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 2; i > 0; --i) {
-        const Index patchIdx[2] = {patchIndices[0] / m_patchStrides[i], patchIndices[1] / m_patchStrides[i]};
-        patchIndices[0] -= patchIdx[0] * m_patchStrides[i];
-        patchIndices[1] -= patchIdx[1] * m_patchStrides[i];
-
-        const Index offsetIdx[2] = {patchOffsets[0] / m_outputStrides[i], patchOffsets[1] / m_outputStrides[i]};
-        patchOffsets[0] -= offsetIdx[0] * m_outputStrides[i];
-        patchOffsets[1] -= offsetIdx[1] * m_outputStrides[i];
-
-        inputIndices[0] += (patchIdx[0] + offsetIdx[0]) * m_inputStrides[i];
-        inputIndices[1] += (patchIdx[1] + offsetIdx[1]) * m_inputStrides[i];
-      }
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 2; ++i) {
-        const Index patchIdx[2] = {patchIndices[0] / m_patchStrides[i], patchIndices[1] / m_patchStrides[i]};
-        patchIndices[0] -= patchIdx[0] * m_patchStrides[i];
-        patchIndices[1] -= patchIdx[1] * m_patchStrides[i];
-
-        const Index offsetIdx[2] = {patchOffsets[0] / m_outputStrides[i + 1], patchOffsets[1] / m_outputStrides[i + 1]};
-        patchOffsets[0] -= offsetIdx[0] * m_outputStrides[i + 1];
-        patchOffsets[1] -= offsetIdx[1] * m_outputStrides[i + 1];
-
-        inputIndices[0] += (patchIdx[0] + offsetIdx[0]) * m_inputStrides[i];
-        inputIndices[1] += (patchIdx[1] + offsetIdx[1]) * m_inputStrides[i];
-      }
-    }
-    inputIndices[0] += (patchIndices[0] + patchOffsets[0]);
-    inputIndices[1] += (patchIndices[1] + patchOffsets[1]);
-
-    if (inputIndices[1] - inputIndices[0] == PacketSize - 1) {
-      PacketReturnType rslt = m_impl.template packet<Unaligned>(inputIndices[0]);
-      return rslt;
-    } else {
-      EIGEN_ALIGN_MAX CoeffReturnType values[PacketSize];
-      values[0] = m_impl.coeff(inputIndices[0]);
-      values[PacketSize - 1] = m_impl.coeff(inputIndices[1]);
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < PacketSize - 1; ++i) {
-        values[i] = coeff(index + i);
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double compute_cost = NumDims * (TensorOpCost::DivCost<Index>() + TensorOpCost::MulCost<Index>() +
-                                           2 * TensorOpCost::AddCost<Index>());
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
- protected:
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims - 1> m_inputStrides;
-  array<Index, NumDims - 1> m_patchStrides;
-
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_PATCH_H
diff --git a/unsupported/Eigen/src/Tensor/TensorRandom.h b/unsupported/Eigen/src/Tensor/TensorRandom.h
deleted file mode 100644
index ffda20a..0000000
--- a/unsupported/Eigen/src/Tensor/TensorRandom.h
+++ /dev/null
@@ -1,297 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-// Copyright (C) 2018 Mehdi Goli <eigen@codeplay.com> Codeplay Software Ltd.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_RANDOM_H
-#define EIGEN_CXX11_TENSOR_TENSOR_RANDOM_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint64_t get_random_seed() {
-#if defined(EIGEN_GPU_COMPILE_PHASE)
-  // We don't support 3d kernels since we currently only use 1 and
-  // 2d kernels.
-  gpu_assert(threadIdx.z == 0);
-  return blockIdx.x * blockDim.x + threadIdx.x + gridDim.x * blockDim.x * (blockIdx.y * blockDim.y + threadIdx.y);
-#else
-  // Rely on Eigen's random implementation.
-  return random<uint64_t>();
-#endif
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE unsigned PCG_XSH_RS_generator(uint64_t* state, uint64_t stream) {
-  // TODO: Unify with the implementation in the non blocking thread pool.
-  uint64_t current = *state;
-  // Update the internal state
-  *state = current * 6364136223846793005ULL + (stream << 1 | 1);
-  // Generate the random output (using the PCG-XSH-RS scheme)
-  return static_cast<unsigned>((current ^ (current >> 22)) >> (22 + (current >> 61)));
-}
-
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE uint64_t PCG_XSH_RS_state(uint64_t seed) {
-  seed = seed ? seed : get_random_seed();
-  return seed * 6364136223846793005ULL + 0xda3e39cb94b95bdbULL;
-}
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T RandomToTypeUniform(uint64_t* state, uint64_t stream) {
-  unsigned rnd = PCG_XSH_RS_generator(state, stream);
-  return static_cast<T>(rnd);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool RandomToTypeUniform<bool>(uint64_t* state, uint64_t stream) {
-  unsigned rnd = PCG_XSH_RS_generator(state, stream);
-  return (rnd & 0x1) != 0;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half RandomToTypeUniform<Eigen::half>(uint64_t* state, uint64_t stream) {
-  // Generate 10 random bits for the mantissa, merge with exponent.
-  unsigned rnd = PCG_XSH_RS_generator(state, stream);
-  const uint16_t half_bits = static_cast<uint16_t>(rnd & 0x3ffu) | (static_cast<uint16_t>(15) << 10);
-  Eigen::half result = Eigen::numext::bit_cast<Eigen::half>(half_bits);
-  return result - Eigen::half(1.0f);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 RandomToTypeUniform<Eigen::bfloat16>(uint64_t* state,
-                                                                                           uint64_t stream) {
-  // Generate 7 random bits for the mantissa, merge with exponent.
-  unsigned rnd = PCG_XSH_RS_generator(state, stream);
-  const uint16_t half_bits = static_cast<uint16_t>(rnd & 0x7fu) | (static_cast<uint16_t>(127) << 7);
-  Eigen::bfloat16 result = Eigen::numext::bit_cast<Eigen::bfloat16>(half_bits);
-  return result - Eigen::bfloat16(1.0f);
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float RandomToTypeUniform<float>(uint64_t* state, uint64_t stream) {
-  typedef union {
-    uint32_t raw;
-    float fp;
-  } internal;
-  internal result;
-  // Generate 23 random bits for the mantissa.
-  const unsigned rnd = PCG_XSH_RS_generator(state, stream);
-  result.raw = rnd & 0x7fffffu;
-  // Set the exponent.
-  result.raw |= (static_cast<uint32_t>(127) << 23);
-  return result.fp - 1.0f;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE double RandomToTypeUniform<double>(uint64_t* state, uint64_t stream) {
-  typedef union {
-    uint64_t raw;
-    double dp;
-  } internal;
-  internal result;
-  result.raw = 0;
-  // Generate 52 random bits for the mantissa
-  // First generate the upper 20 bits
-  unsigned rnd1 = PCG_XSH_RS_generator(state, stream) & 0xfffffu;
-  // Then generate the lower 32 bits.
-  unsigned rnd2 = PCG_XSH_RS_generator(state, stream);
-  result.raw = (static_cast<uint64_t>(rnd1) << 32) | rnd2;
-  // Set the exponent
-  result.raw |= (static_cast<uint64_t>(1023) << 52);
-  // Return the final result
-  return result.dp - 1.0;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<float> RandomToTypeUniform<std::complex<float> >(uint64_t* state,
-                                                                                                    uint64_t stream) {
-  return std::complex<float>(RandomToTypeUniform<float>(state, stream), RandomToTypeUniform<float>(state, stream));
-}
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<double> RandomToTypeUniform<std::complex<double> >(uint64_t* state,
-                                                                                                      uint64_t stream) {
-  return std::complex<double>(RandomToTypeUniform<double>(state, stream), RandomToTypeUniform<double>(state, stream));
-}
-
-template <typename T>
-class UniformRandomGenerator {
- public:
-  static constexpr bool PacketAccess = true;
-
-  // Uses the given "seed" if non-zero, otherwise uses a random seed.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE UniformRandomGenerator(uint64_t seed = 0) {
-    m_state = PCG_XSH_RS_state(seed);
-#ifdef EIGEN_USE_SYCL
-    // In SYCL, the constructor runs on the CPU where thread IDs are unavailable.
-    // We initialize m_state here with just the clock seed; the per-thread
-    // component (i * 6364136223846793005ULL) is added in operator() when
-    // the thread ID becomes available, completing the PCG state setup.
-    m_exec_once = false;
-#endif
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE UniformRandomGenerator(const UniformRandomGenerator& other) {
-    m_state = other.m_state;
-#ifdef EIGEN_USE_SYCL
-    m_exec_once = other.m_exec_once;
-#endif
-  }
-
-  template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(Index i) const {
-#ifdef EIGEN_USE_SYCL
-    if (!m_exec_once) {
-      // This is the second stage of adding thread Id to the CPU clock seed and build unique seed per thread
-      // The (i * 6364136223846793005ULL) is the remaining part of the PCG_XSH_RS_state on the GPU side
-      m_state += (i * 6364136223846793005ULL);
-      m_exec_once = true;
-    }
-#endif
-    T result = RandomToTypeUniform<T>(&m_state, i);
-    return result;
-  }
-
-  template <typename Packet, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(Index i) const {
-    const int packetSize = internal::unpacket_traits<Packet>::size;
-    EIGEN_ALIGN_MAX T values[packetSize];
-#ifdef EIGEN_USE_SYCL
-    if (!m_exec_once) {
-      // This is the second stage of adding thread Id to the CPU clock seed and build unique seed per thread
-      m_state += (i * 6364136223846793005ULL);
-      m_exec_once = true;
-    }
-#endif
-    EIGEN_UNROLL_LOOP
-    for (int j = 0; j < packetSize; ++j) {
-      values[j] = RandomToTypeUniform<T>(&m_state, i);
-    }
-    return internal::pload<Packet>(values);
-  }
-
- private:
-  mutable uint64_t m_state;
-#ifdef EIGEN_USE_SYCL
-  mutable bool m_exec_once;
-#endif
-};
-
-template <typename Scalar>
-struct functor_traits<UniformRandomGenerator<Scalar> > {
-  enum {
-    // Rough estimate for floating point, multiplied by ceil(sizeof(T) / sizeof(float)).
-    Cost = 12 * NumTraits<Scalar>::AddCost * ((sizeof(Scalar) + sizeof(float) - 1) / sizeof(float)),
-    PacketAccess = UniformRandomGenerator<Scalar>::PacketAccess
-  };
-};
-
-template <typename T>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T RandomToTypeNormal(uint64_t* state, uint64_t stream) {
-  // Use the ratio of uniform method to generate numbers following a normal
-  // distribution. See for example Numerical Recipes chapter 7.3.9 for the
-  // details.
-  T u, v, q;
-  do {
-    u = RandomToTypeUniform<T>(state, stream);
-    v = T(1.7156) * (RandomToTypeUniform<T>(state, stream) - T(0.5));
-    const T x = u - T(0.449871);
-    const T y = numext::abs(v) + T(0.386595);
-    q = x * x + y * (T(0.196) * y - T(0.25472) * x);
-  } while (q > T(0.27597) && (q > T(0.27846) || v * v > T(-4) * numext::log(u) * u * u));
-
-  return v / u;
-}
-
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<float> RandomToTypeNormal<std::complex<float> >(uint64_t* state,
-                                                                                                   uint64_t stream) {
-  return std::complex<float>(RandomToTypeNormal<float>(state, stream), RandomToTypeNormal<float>(state, stream));
-}
-template <>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::complex<double> RandomToTypeNormal<std::complex<double> >(uint64_t* state,
-                                                                                                     uint64_t stream) {
-  return std::complex<double>(RandomToTypeNormal<double>(state, stream), RandomToTypeNormal<double>(state, stream));
-}
-
-template <typename T>
-class NormalRandomGenerator {
- public:
-  static constexpr bool PacketAccess = true;
-
-  // Uses the given "seed" if non-zero, otherwise uses a random seed.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NormalRandomGenerator(uint64_t seed = 0) {
-    m_state = PCG_XSH_RS_state(seed);
-#ifdef EIGEN_USE_SYCL
-    // In SYCL, the constructor runs on the CPU where thread IDs are unavailable.
-    // We initialize m_state here with just the clock seed; the per-thread
-    // component (i * 6364136223846793005ULL) is added in operator() when
-    // the thread ID becomes available, completing the PCG state setup.
-    m_exec_once = false;
-#endif
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NormalRandomGenerator(const NormalRandomGenerator& other) {
-    m_state = other.m_state;
-#ifdef EIGEN_USE_SYCL
-    m_exec_once = other.m_exec_once;
-#endif
-  }
-
-  template <typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T operator()(Index i) const {
-#ifdef EIGEN_USE_SYCL
-    if (!m_exec_once) {
-      // This is the second stage of adding thread Id to the CPU clock seed and build unique seed per thread
-      m_state += (i * 6364136223846793005ULL);
-      m_exec_once = true;
-    }
-#endif
-    T result = RandomToTypeNormal<T>(&m_state, i);
-    return result;
-  }
-
-  template <typename Packet, typename Index>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet packetOp(Index i) const {
-    const int packetSize = internal::unpacket_traits<Packet>::size;
-    EIGEN_ALIGN_MAX T values[packetSize];
-#ifdef EIGEN_USE_SYCL
-    if (!m_exec_once) {
-      // This is the second stage of adding thread Id to the CPU clock seed and build unique seed per thread
-      m_state += (i * 6364136223846793005ULL);
-      m_exec_once = true;
-    }
-#endif
-    EIGEN_UNROLL_LOOP
-    for (int j = 0; j < packetSize; ++j) {
-      values[j] = RandomToTypeNormal<T>(&m_state, i);
-    }
-    return internal::pload<Packet>(values);
-  }
-
- private:
-  mutable uint64_t m_state;
-#ifdef EIGEN_USE_SYCL
-  mutable bool m_exec_once;
-#endif
-};
-
-template <typename Scalar>
-struct functor_traits<NormalRandomGenerator<Scalar> > {
-  enum {
-    // On average, we need to generate about 3 random numbers
-    // 15 mul, 8 add, 1.5 logs
-    Cost = 3 * functor_traits<UniformRandomGenerator<Scalar> >::Cost + 15 * NumTraits<Scalar>::AddCost +
-           8 * NumTraits<Scalar>::AddCost + 3 * functor_traits<scalar_log_op<Scalar> >::Cost / 2,
-    PacketAccess = NormalRandomGenerator<Scalar>::PacketAccess
-  };
-};
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_RANDOM_H
diff --git a/unsupported/Eigen/src/Tensor/TensorReduction.h b/unsupported/Eigen/src/Tensor/TensorReduction.h
deleted file mode 100644
index 25ba136..0000000
--- a/unsupported/Eigen/src/Tensor/TensorReduction.h
+++ /dev/null
@@ -1,1023 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-// Copyright (C) 2016 Mehdi Goli, Codeplay Software Ltd <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_REDUCTION_H
-#define EIGEN_CXX11_TENSOR_TENSOR_REDUCTION_H
-
-// clang is incompatible with the CUDA syntax wrt making a kernel a class friend,
-// so we'll use a macro to make clang happy.
-#ifndef KERNEL_FRIEND
-#if defined(__clang__) && (defined(__CUDA__) || defined(__HIP__))
-#define KERNEL_FRIEND friend __global__ EIGEN_HIP_LAUNCH_BOUNDS_1024
-#else
-#define KERNEL_FRIEND friend
-#endif
-#endif
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
-struct traits<TensorReductionOp<Op, Dims, XprType, MakePointer_> > : traits<XprType> {
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::Scalar Scalar;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  static constexpr int NumDimensions = XprTraits::NumDimensions - array_size<Dims>::value;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-
-  template <class T>
-  struct MakePointer {
-    // Intermediate typedef to workaround MSVC issue.
-    typedef MakePointer_<T> MakePointerT;
-    typedef typename MakePointerT::Type Type;
-  };
-};
-
-template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
-struct eval<TensorReductionOp<Op, Dims, XprType, MakePointer_>, Eigen::Dense> {
-  typedef const TensorReductionOp<Op, Dims, XprType, MakePointer_>& type;
-};
-
-template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
-struct nested<TensorReductionOp<Op, Dims, XprType, MakePointer_>, 1,
-              typename eval<TensorReductionOp<Op, Dims, XprType, MakePointer_> >::type> {
-  typedef TensorReductionOp<Op, Dims, XprType, MakePointer_> type;
-};
-
-template <typename OutputDims>
-struct DimInitializer {
-  template <typename InputDims, typename ReducedDims>
-  EIGEN_DEVICE_FUNC static void run(const InputDims& input_dims,
-                                    const array<bool, internal::array_size<InputDims>::value>& reduced,
-                                    OutputDims* output_dims, ReducedDims* reduced_dims) {
-    const int NumInputDims = internal::array_size<InputDims>::value;
-    int outputIndex = 0;
-    int reduceIndex = 0;
-    for (int i = 0; i < NumInputDims; ++i) {
-      if (reduced[i]) {
-        (*reduced_dims)[reduceIndex] = input_dims[i];
-        ++reduceIndex;
-      } else {
-        (*output_dims)[outputIndex] = input_dims[i];
-        ++outputIndex;
-      }
-    }
-  }
-};
-
-template <>
-struct DimInitializer<Sizes<> > {
-  template <typename InputDims, typename Index, size_t Rank>
-  EIGEN_DEVICE_FUNC static void run(const InputDims& input_dims, const array<bool, Rank>&, Sizes<>*,
-                                    array<Index, Rank>* reduced_dims) {
-    const int NumInputDims = internal::array_size<InputDims>::value;
-    for (int i = 0; i < NumInputDims; ++i) {
-      (*reduced_dims)[i] = input_dims[i];
-    }
-  }
-};
-
-template <typename ReducedDims, int NumTensorDims, int Layout>
-struct are_inner_most_dims {
-  static const bool value = false;
-};
-template <typename ReducedDims, int NumTensorDims, int Layout>
-struct preserve_inner_most_dims {
-  static const bool value = false;
-};
-
-template <typename ReducedDims, int NumTensorDims>
-struct are_inner_most_dims<ReducedDims, NumTensorDims, ColMajor> {
-  static const bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
-  static const bool tmp2 = index_statically_eq<ReducedDims>(0, 0);
-  static const bool tmp3 =
-      index_statically_eq<ReducedDims>(array_size<ReducedDims>::value - 1, array_size<ReducedDims>::value - 1);
-  static const bool value = tmp1 & tmp2 & tmp3;
-};
-template <typename ReducedDims, int NumTensorDims>
-struct are_inner_most_dims<ReducedDims, NumTensorDims, RowMajor> {
-  static const bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
-  static const bool tmp2 = index_statically_eq<ReducedDims>(0, NumTensorDims - array_size<ReducedDims>::value);
-  static const bool tmp3 = index_statically_eq<ReducedDims>(array_size<ReducedDims>::value - 1, NumTensorDims - 1);
-  static const bool value = tmp1 & tmp2 & tmp3;
-};
-template <typename ReducedDims, int NumTensorDims>
-struct preserve_inner_most_dims<ReducedDims, NumTensorDims, ColMajor> {
-  static const bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
-  static const bool tmp2 = index_statically_gt<ReducedDims>(0, 0);
-  static const bool value = tmp1 & tmp2;
-};
-template <typename ReducedDims, int NumTensorDims>
-struct preserve_inner_most_dims<ReducedDims, NumTensorDims, RowMajor> {
-  static const bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
-  static const bool tmp2 = index_statically_lt<ReducedDims>(array_size<ReducedDims>::value - 1, NumTensorDims - 1);
-  static const bool value = tmp1 & tmp2;
-};
-
-template <int DimIndex, typename Self, typename Op>
-struct GenericDimReducer {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
-                                                           Op& reducer, typename Self::CoeffReturnType* accum) {
-    EIGEN_STATIC_ASSERT((DimIndex > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    for (int j = 0; j < self.m_reducedDims[DimIndex]; ++j) {
-      const typename Self::Index input = firstIndex + j * self.m_reducedStrides[DimIndex];
-      GenericDimReducer<DimIndex - 1, Self, Op>::reduce(self, input, reducer, accum);
-    }
-  }
-};
-template <typename Self, typename Op>
-struct GenericDimReducer<0, Self, Op> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
-                                                           Op& reducer, typename Self::CoeffReturnType* accum) {
-    for (int j = 0; j < self.m_reducedDims[0]; ++j) {
-      const typename Self::Index input = firstIndex + j * self.m_reducedStrides[0];
-      reducer.reduce(self.m_impl.coeff(input), accum);
-    }
-  }
-};
-template <typename Self, typename Op>
-struct GenericDimReducer<-1, Self, Op> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index index, Op& reducer,
-                                                           typename Self::CoeffReturnType* accum) {
-    reducer.reduce(self.m_impl.coeff(index), accum);
-  }
-};
-
-template <typename Self, typename Op,
-          bool Vectorizable = (Self::InputPacketAccess && Self::ReducerTraits::PacketAccess),
-          bool UseTreeReduction = (!Self::ReducerTraits::IsStateful && !Self::ReducerTraits::IsExactlyAssociative &&
-                                   // GPU threads can quickly run out of stack space
-                                   // for moderately sized inputs.
-                                   !Self::RunningOnGPU)>
-struct InnerMostDimReducer {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
-      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer) {
-    typename Self::CoeffReturnType accum = reducer.initialize();
-    for (typename Self::Index j = 0; j < numValuesToReduce; ++j) {
-      reducer.reduce(self.m_impl.coeff(firstIndex + j), &accum);
-    }
-    return reducer.finalize(accum);
-  }
-};
-
-template <typename Self, typename Op>
-struct InnerMostDimReducer<Self, Op, true, false> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
-      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer0) {
-    using Index = typename Self::Index;
-    constexpr Index packetSize = internal::unpacket_traits<typename Self::PacketReturnType>::size;
-    Index start = 0;
-    typename Self::PacketReturnType paccum0 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-    if (!Self::ReducerTraits::IsStateful && numValuesToReduce >= 4 * packetSize) {
-      const Index VectorizedSize4 = (numValuesToReduce / (4 * packetSize)) * (4 * packetSize);
-      typename Self::PacketReturnType paccum1 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-      typename Self::PacketReturnType paccum2 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-      typename Self::PacketReturnType paccum3 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-      const Index offset0 = firstIndex;
-      const Index offset1 = firstIndex + packetSize;
-      const Index offset2 = firstIndex + 2 * packetSize;
-      const Index offset3 = firstIndex + 3 * packetSize;
-      for (Index j = 0; j < VectorizedSize4; j += 4 * packetSize) {
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset0 + j), &paccum0);
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset1 + j), &paccum1);
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset2 + j), &paccum2);
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(offset3 + j), &paccum3);
-      }
-      reducer0.reducePacket(paccum1, &paccum0);
-      reducer0.reducePacket(paccum2, &paccum0);
-      reducer0.reducePacket(paccum3, &paccum0);
-      start = VectorizedSize4;
-    }
-    if (start <= (numValuesToReduce - packetSize)) {
-      const Index VectorizedSize = (numValuesToReduce / packetSize) * packetSize;
-      for (Index j = start; j < VectorizedSize; j += packetSize) {
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(firstIndex + j), &paccum0);
-      }
-      start = VectorizedSize;
-    }
-    typename Self::CoeffReturnType accum = reducer0.initialize();
-    for (Index j = start; j < numValuesToReduce; ++j) {
-      reducer0.reduce(self.m_impl.coeff(firstIndex + j), &accum);
-    }
-    return reducer0.finalizeBoth(accum, paccum0);
-  }
-};
-
-#if !defined(EIGEN_HIPCC)
-
-// The following implements tree-based reduction, which improves the accuracy
-// of sum and mean reductions, since each of the n inputs only participates in
-// O(log n) additions.
-template <typename T>
-EIGEN_DEVICE_FUNC inline Index LeafSize() {
-  return 1024;
-}
-template <>
-EIGEN_DEVICE_FUNC inline Index LeafSize<half>() {
-  return 200;
-}
-template <>
-EIGEN_DEVICE_FUNC inline Index LeafSize<bfloat16>() {
-  return 128;
-}
-
-template <typename Self, typename Op>
-struct InnerMostDimReducer<Self, Op, false, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
-      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer) {
-    const Index kLeafSize = LeafSize<typename Self::CoeffReturnType>();
-    typename Self::CoeffReturnType accum = reducer.initialize();
-    if (numValuesToReduce > kLeafSize) {
-      const typename Self::Index half = numValuesToReduce / 2;
-      // Recursively reduce the two halves.
-      reducer.reduce(reduce(self, firstIndex, half, reducer), &accum);
-      reducer.reduce(reduce(self, firstIndex + half, numValuesToReduce - half, reducer), &accum);
-      return reducer.finalize(accum);
-    } else {
-      return InnerMostDimReducer<Self, Op, false, false>::reduce(self, firstIndex, numValuesToReduce, reducer);
-    }
-  }
-};
-
-template <typename Self, typename Op>
-struct InnerMostDimReducer<Self, Op, true, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Self::CoeffReturnType reduce(
-      const Self& self, typename Self::Index firstIndex, typename Self::Index numValuesToReduce, Op& reducer) {
-    const Index kLeafSize = LeafSize<typename Self::CoeffReturnType>();
-    const typename Self::Index packetSize = internal::unpacket_traits<typename Self::PacketReturnType>::size;
-    typename Self::CoeffReturnType accum = reducer.initialize();
-    if (numValuesToReduce > packetSize * kLeafSize) {
-      // Make sure the split point is aligned on a packet boundary.
-      const typename Self::Index split =
-          packetSize *
-          numext::div_ceil(firstIndex + numext::div_ceil(numValuesToReduce, typename Self::Index(2)), packetSize);
-      const typename Self::Index num_left = numext::mini(split - firstIndex, numValuesToReduce);
-      reducer.reduce(reduce(self, firstIndex, num_left, reducer), &accum);
-      if (num_left < numValuesToReduce) {
-        reducer.reduce(reduce(self, split, numValuesToReduce - num_left, reducer), &accum);
-      }
-      return reducer.finalize(accum);
-    } else {
-      return InnerMostDimReducer<Self, Op, true, false>::reduce(self, firstIndex, numValuesToReduce, reducer);
-    }
-  }
-};
-#endif
-
-template <int DimIndex, typename Self, typename Op,
-          bool vectorizable = (Self::InputPacketAccess && Self::ReducerTraits::PacketAccess)>
-struct InnerMostDimPreserver {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self&, typename Self::Index, Op&,
-                                                           typename Self::PacketReturnType*) {
-    eigen_assert(false && "should never be called");
-  }
-};
-
-template <int DimIndex, typename Self, typename Op>
-struct InnerMostDimPreserver<DimIndex, Self, Op, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
-                                                           Op& reducer, typename Self::PacketReturnType* accum) {
-    EIGEN_STATIC_ASSERT((DimIndex > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    for (typename Self::Index j = 0; j < self.m_reducedDims[DimIndex]; ++j) {
-      const typename Self::Index input = firstIndex + j * self.m_reducedStrides[DimIndex];
-      InnerMostDimPreserver<DimIndex - 1, Self, Op>::reduce(self, input, reducer, accum);
-    }
-  }
-};
-
-template <typename Self, typename Op>
-struct InnerMostDimPreserver<0, Self, Op, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self& self, typename Self::Index firstIndex,
-                                                           Op& reducer0, typename Self::PacketReturnType* accum0) {
-    using Index = typename Self::Index;
-    const Index stride = self.m_reducedStrides[0];
-    const Index size = self.m_reducedDims[0];
-    if (!Self::ReducerTraits::IsStateful && size >= 16) {
-      const Index unrolled_size4 = (size / 4) * 4;
-      typename Self::PacketReturnType accum1 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-      typename Self::PacketReturnType accum2 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-      typename Self::PacketReturnType accum3 = reducer0.template initializePacket<typename Self::PacketReturnType>();
-      for (Index j = 0; j < unrolled_size4; j += 4) {
-        const Index input0 = firstIndex + j * stride;
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input0), accum0);
-        const Index input1 = firstIndex + (j + 1) * stride;
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input1), &accum1);
-        const Index input2 = firstIndex + (j + 2) * stride;
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input2), &accum2);
-        const Index input3 = firstIndex + (j + 3) * stride;
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input3), &accum3);
-      }
-      reducer0.reducePacket(accum1, accum0);
-      reducer0.reducePacket(accum2, accum0);
-      reducer0.reducePacket(accum3, accum0);
-      for (Index j = unrolled_size4; j < size; ++j) {
-        Index input = firstIndex + j * stride;
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input), accum0);
-      }
-    } else {
-      for (Index j = 0; j < size; ++j) {
-        Index input = firstIndex + j * stride;
-        reducer0.reducePacket(self.m_impl.template packet<Unaligned>(input), accum0);
-      }
-    }
-  }
-};
-template <typename Self, typename Op>
-struct InnerMostDimPreserver<-1, Self, Op, true> {
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const Self&, typename Self::Index, Op&,
-                                                           typename Self::PacketReturnType*) {
-    eigen_assert(false && "should never be called");
-  }
-};
-
-// Default full reducer
-template <typename Self, typename Op, typename Device,
-          bool Vectorizable = (Self::InputPacketAccess && Self::ReducerTraits::PacketAccess)>
-struct FullReducer {
-  static constexpr bool HasOptimizedImplementation = false;
-
-  static EIGEN_DEVICE_FUNC void run(const Self& self, Op& reducer, const Device&,
-                                    typename Self::EvaluatorPointerType output) {
-    const typename Self::Index num_coeffs = array_prod(self.m_impl.dimensions());
-    *output = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, 0, num_coeffs, reducer);
-  }
-};
-
-#ifdef EIGEN_USE_THREADS
-// Multithreaded full reducer
-template <typename Self, typename Op, bool Vectorizable>
-struct FullReducer<Self, Op, ThreadPoolDevice, Vectorizable> {
-  static constexpr bool HasOptimizedImplementation = !Self::ReducerTraits::IsStateful;
-  static constexpr Index PacketSize = unpacket_traits<typename Self::PacketReturnType>::size;
-
-  // launch one reducer per thread and accumulate the result.
-  static void run(const Self& self, Op& reducer, const ThreadPoolDevice& device,
-                  typename Self::CoeffReturnType* output) {
-    typedef typename Self::Index Index;
-    const Index num_coeffs = array_prod(self.m_impl.dimensions());
-    if (num_coeffs == 0) {
-      *output = reducer.finalize(reducer.initialize());
-      return;
-    }
-    const TensorOpCost cost = self.m_impl.costPerCoeff(Vectorizable) +
-                              TensorOpCost(0, 0, internal::functor_traits<Op>::Cost, Vectorizable, PacketSize);
-    const Index num_threads = TensorCostModel<ThreadPoolDevice>::numThreads(num_coeffs, cost, device.numThreads());
-    if (num_threads == 1) {
-      *output = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, 0, num_coeffs, reducer);
-      return;
-    }
-    const Index blocksize = num_coeffs / num_threads;
-    const Index numblocks = blocksize > 0 ? num_coeffs / blocksize : 0;
-    eigen_assert(num_coeffs >= numblocks * blocksize);
-
-    Barrier barrier(internal::convert_index<unsigned int>(numblocks));
-    MaxSizeVector<typename Self::CoeffReturnType> shards(numblocks, reducer.initialize());
-    for (Index i = 0; i < numblocks; ++i) {
-      auto run_shard = [i, blocksize, &self, &barrier, &shards, &reducer]() {
-        shards[i] = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, i * blocksize, blocksize, reducer);
-        barrier.Notify();
-      };
-      device.enqueue(std::move(run_shard));
-    }
-    typename Self::CoeffReturnType finalShard;
-    if (numblocks * blocksize < num_coeffs) {
-      finalShard = InnerMostDimReducer<Self, Op, Vectorizable>::reduce(self, numblocks * blocksize,
-                                                                       num_coeffs - numblocks * blocksize, reducer);
-    } else {
-      finalShard = reducer.initialize();
-    }
-    barrier.Wait();
-
-    for (Index i = 0; i < numblocks; ++i) {
-      reducer.reduce(shards[i], &finalShard);
-    }
-    *output = reducer.finalize(finalShard);
-  }
-};
-
-#endif
-
-// Default inner reducer
-template <typename Self, typename Op, typename Device>
-struct InnerReducer {
-  static constexpr bool HasOptimizedImplementation = false;
-
-  EIGEN_DEVICE_FUNC static bool run(const Self&, Op&, const Device&, typename Self::CoeffReturnType*,
-                                    typename Self::Index, typename Self::Index) {
-    eigen_assert(false && "Not implemented");
-    return true;
-  }
-};
-
-// Default outer reducer
-template <typename Self, typename Op, typename Device>
-struct OuterReducer {
-  static constexpr bool HasOptimizedImplementation = false;
-
-  EIGEN_DEVICE_FUNC static bool run(const Self&, Op&, const Device&, typename Self::CoeffReturnType*,
-                                    typename Self::Index, typename Self::Index) {
-    eigen_assert(false && "Not implemented");
-    return true;
-  }
-};
-
-#ifdef EIGEN_USE_SYCL
-// Default Generic reducer
-template <typename Self, typename Op, typename Device>
-struct GenericReducer {
-  static constexpr bool HasOptimizedImplementation = false;
-
-  EIGEN_DEVICE_FUNC static bool run(const Self&, Op&, const Device&, typename Self::CoeffReturnType*,
-                                    typename Self::Index, typename Self::Index) {
-    eigen_assert(false && "Not implemented");
-    return true;
-  }
-};
-#endif
-
-#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
-template <int B, int N, typename S, typename R, typename I_>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernel(R, const S, I_, typename S::CoeffReturnType*,
-                                                                 unsigned int*);
-
-#if defined(EIGEN_HAS_GPU_FP16)
-template <typename S, typename R, typename I_>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitFullReduxKernelHalfFloat(
-    R, const S, I_, internal::packet_traits<half>::type*);
-template <int B, int N, typename S, typename R, typename I_>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernelHalfFloat(R, const S, I_, half*,
-                                                                          internal::packet_traits<half>::type*);
-template <int NPT, typename S, typename R, typename I_>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernelHalfFloat(R, const S, I_, I_, half*);
-
-#endif
-
-template <int NPT, typename S, typename R, typename I_>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
-
-template <int NPT, typename S, typename R, typename I_>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void OuterReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
-#endif
-
-/**
- * For SYCL, the return type of the reduction is deduced from the initialize method of the given Op.
- * This allows the reduction to have a different type for the accumulator than the input data type.
- * If this is the case, the functor needs to have two reduce method: one for reducing an element of the input
- * with the accumulator and the other for reducing two accumulators.
- * Such a reducer can be useful for instance when the accumulator is a boolean or a bitset that checks for
- * some properties of the input.
- */
-template <typename Op, typename CoeffReturnType>
-struct ReductionReturnType {
-#if defined(EIGEN_USE_SYCL)
-  typedef std::remove_const_t<decltype(std::declval<Op>().initialize())> type;
-#else
-  typedef std::remove_const_t<CoeffReturnType> type;
-#endif
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor reduction class.
- *
- */
-template <typename Op, typename Dims, typename XprType, template <class> class MakePointer_>
-class TensorReductionOp : public TensorBase<TensorReductionOp<Op, Dims, XprType, MakePointer_>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorReductionOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef std::remove_const_t<typename XprType::CoeffReturnType> CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorReductionOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorReductionOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorReductionOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReductionOp(const XprType& expr, const Dims& dims)
-      : m_expr(expr), m_dims(dims) {}
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReductionOp(const XprType& expr, const Dims& dims, const Op& reducer)
-      : m_expr(expr), m_dims(dims), m_reducer(reducer) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const XprType& expression() const { return m_expr; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dims& dims() const { return m_dims; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Op& reducer() const { return m_reducer; }
-
- protected:
-  typename XprType::Nested m_expr;
-  const Dims m_dims;
-  const Op m_reducer;
-};
-
-template <typename ArgType, typename Device>
-struct TensorReductionEvaluatorBase;
-
-// Eval as rvalue
-template <typename Op, typename Dims, typename ArgType, template <class> class MakePointer_, typename Device>
-struct TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> {
-  typedef internal::reducer_traits<Op, Device> ReducerTraits;
-  typedef Dims ReducedDims;
-  typedef TensorReductionOp<Op, Dims, ArgType, MakePointer_> XprType;
-  typedef typename XprType::Index Index;
-  typedef ArgType ChildType;
-  typedef typename TensorEvaluator<ArgType, Device>::Dimensions InputDimensions;
-  static constexpr int NumInputDims = internal::array_size<InputDimensions>::value;
-  static constexpr int NumReducedDims = internal::array_size<Dims>::value;
-  static constexpr int NumOutputDims = NumInputDims - NumReducedDims;
-  typedef std::conditional_t<NumOutputDims == 0, Sizes<>, DSizes<Index, NumOutputDims> > Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> Self;
-  static constexpr bool InputPacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess;
-  typedef typename internal::ReductionReturnType<Op, typename XprType::CoeffReturnType>::type CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr Index PacketSize = PacketType<CoeffReturnType, Device>::size;
-
-  typedef typename Eigen::internal::traits<XprType>::PointerType TensorPointerType;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  // Subset of strides of the input tensor for the non-reduced dimensions.
-  // Indexed by output dimensions.
-  static constexpr int NumPreservedStrides = max_n_1<NumOutputDims>::size;
-
-  // For full reductions
-#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
-  static constexpr bool RunningOnGPU = internal::is_same<Device, Eigen::GpuDevice>::value;
-  static constexpr bool RunningOnSycl = false;
-#elif defined(EIGEN_USE_SYCL)
-  static constexpr bool RunningOnSycl = internal::is_same<internal::remove_all_t<Device>, Eigen::SyclDevice>::value;
-  static constexpr bool RunningOnGPU = false;
-#else
-  static constexpr bool RunningOnGPU = false;
-  static constexpr bool RunningOnSycl = false;
-#endif
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = Self::InputPacketAccess && ReducerTraits::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = true,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  static constexpr bool ReducingInnerMostDims = internal::are_inner_most_dims<Dims, NumInputDims, Layout>::value;
-  static constexpr bool PreservingInnerMostDims = internal::preserve_inner_most_dims<Dims, NumInputDims, Layout>::value;
-  static constexpr bool RunningFullReduction = (NumOutputDims == 0);
-
-  EIGEN_STRONG_INLINE TensorReductionEvaluatorBase(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_reducer(op.reducer()), m_result(NULL), m_device(device) {
-    EIGEN_STATIC_ASSERT((NumInputDims >= NumReducedDims), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((!ReducingInnerMostDims | !PreservingInnerMostDims | (NumReducedDims == NumInputDims)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    // Build the bitmap indicating if an input dimension is reduced or not.
-    for (int i = 0; i < NumInputDims; ++i) {
-      m_reduced[i] = false;
-    }
-    for (int i = 0; i < NumReducedDims; ++i) {
-      eigen_assert(op.dims()[i] >= 0);
-      eigen_assert(op.dims()[i] < NumInputDims);
-      m_reduced[op.dims()[i]] = true;
-    }
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    internal::DimInitializer<Dimensions>::run(input_dims, m_reduced, &m_dimensions, &m_reducedDims);
-
-    // Precompute output strides.
-    if (NumOutputDims > 0) {
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        m_outputStrides[0] = 1;
-        for (int i = 1; i < NumOutputDims; ++i) {
-          m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-          m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i]);
-        }
-      } else {
-        m_outputStrides[static_cast<size_t>(NumOutputDims - 1)] = 1;
-        for (int i = NumOutputDims - 2; i >= 0; --i) {
-          m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-          m_fastOutputStrides[i] = internal::TensorIntDivisor<Index>(m_outputStrides[i]);
-        }
-      }
-    }
-
-    // Precompute input strides.
-    if (NumInputDims > 0) {
-      array<Index, NumInputDims> input_strides;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        input_strides[0] = 1;
-        for (int i = 1; i < NumInputDims; ++i) {
-          input_strides[i] = input_strides[i - 1] * input_dims[i - 1];
-        }
-      } else {
-        input_strides.back() = 1;
-        for (int i = NumInputDims - 2; i >= 0; --i) {
-          input_strides[i] = input_strides[i + 1] * input_dims[i + 1];
-        }
-      }
-
-      int outputIndex = 0;
-      int reduceIndex = 0;
-      for (int i = 0; i < NumInputDims; ++i) {
-        if (m_reduced[i]) {
-          m_reducedStrides[reduceIndex] = input_strides[i];
-          ++reduceIndex;
-        } else {
-          m_preservedStrides[outputIndex] = input_strides[i];
-          m_output_to_input_dim_map[outputIndex] = i;
-          ++outputIndex;
-        }
-      }
-    }
-
-    // Special case for full reductions
-    if (NumOutputDims == 0) {
-      m_preservedStrides[0] = internal::array_prod(input_dims);
-    }
-
-    m_numValuesToReduce = NumOutputDims == 0 ? internal::array_prod(input_dims)
-                          : (static_cast<int>(Layout) == static_cast<int>(ColMajor))
-                              ? m_preservedStrides[0]
-                              : m_preservedStrides[static_cast<size_t>(NumOutputDims - 1)];
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeededCommon(EvaluatorPointerType data) {
-    // Use the FullReducer if possible.
-    if ((RunningFullReduction && RunningOnSycl) ||
-        (RunningFullReduction && internal::FullReducer<Self, Op, Device>::HasOptimizedImplementation &&
-         ((RunningOnGPU && (m_device.majorDeviceVersion() >= 3)) || !RunningOnGPU))) {
-      bool need_assign = false;
-      if (!data) {
-        m_result = static_cast<EvaluatorPointerType>(
-            m_device.get((CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType))));
-        data = m_result;
-        need_assign = true;
-      }
-      Op reducer(m_reducer);
-      internal::FullReducer<Self, Op, Device>::run(*this, reducer, m_device, data);
-      return need_assign;
-    }
-
-    // Attempt to use an optimized reduction.
-    else if ((RunningOnGPU && (m_device.majorDeviceVersion() >= 3)) || (RunningOnSycl)) {
-      bool reducing_inner_dims = true;
-      for (int i = 0; i < NumReducedDims; ++i) {
-        if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-          reducing_inner_dims &= m_reduced[i];
-        } else {
-          reducing_inner_dims &= m_reduced[NumInputDims - 1 - i];
-        }
-      }
-      if (internal::InnerReducer<Self, Op, Device>::HasOptimizedImplementation &&
-          (reducing_inner_dims || ReducingInnerMostDims)) {
-        const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
-        const Index num_coeffs_to_preserve = static_cast<Index>(internal::array_prod(m_dimensions));
-        if (!data) {
-          if ((num_coeffs_to_preserve < 1024 && num_values_to_reduce > num_coeffs_to_preserve &&
-               num_values_to_reduce > 128) ||
-              (RunningOnSycl)) {
-            data = static_cast<EvaluatorPointerType>(m_device.get(
-                (CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType) * num_coeffs_to_preserve)));
-            m_result = data;
-          } else {
-            return true;
-          }
-        }
-        Op reducer(m_reducer);
-        // For SYCL, this always returns false.
-        if (internal::InnerReducer<Self, Op, Device>::run(*this, reducer, m_device, data, num_values_to_reduce,
-                                                          num_coeffs_to_preserve)) {
-          if (m_result) {
-            m_device.deallocate_temp(m_result);
-            m_result = NULL;
-          }
-          return true;
-        } else {
-          return (m_result != NULL);
-        }
-      }
-
-      bool preserving_inner_dims = true;
-      for (int i = 0; i < NumReducedDims; ++i) {
-        if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-          preserving_inner_dims &= m_reduced[NumInputDims - 1 - i];
-        } else {
-          preserving_inner_dims &= m_reduced[i];
-        }
-      }
-      if (internal::OuterReducer<Self, Op, Device>::HasOptimizedImplementation && preserving_inner_dims) {
-        const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
-        const Index num_coeffs_to_preserve = static_cast<Index>(internal::array_prod(m_dimensions));
-        if (!data) {
-          if ((num_coeffs_to_preserve < 1024 && num_values_to_reduce > num_coeffs_to_preserve &&
-               num_values_to_reduce > 32) ||
-              (RunningOnSycl)) {
-            data = static_cast<EvaluatorPointerType>(m_device.get(
-                (CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType) * num_coeffs_to_preserve)));
-            m_result = data;
-          } else {
-            return true;
-          }
-        }
-        Op reducer(m_reducer);
-        // For SYCL, this always returns false.
-        if (internal::OuterReducer<Self, Op, Device>::run(*this, reducer, m_device, data, num_values_to_reduce,
-                                                          num_coeffs_to_preserve)) {
-          if (m_result) {
-            m_device.deallocate_temp(m_result);
-            m_result = NULL;
-          }
-          return true;
-        } else {
-          return (m_result != NULL);
-        }
-      }
-#if defined(EIGEN_USE_SYCL)
-      // If there is no Optimised version for SYCL, the reduction expression
-      // must break into two subexpression and use the SYCL generic Reducer on the device.
-      if (RunningOnSycl) {
-        const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
-        const Index num_coeffs_to_preserve = static_cast<Index>(internal::array_prod(m_dimensions));
-        if (!data) {
-          data = static_cast<EvaluatorPointerType>(
-              m_device.get((CoeffReturnType*)m_device.allocate_temp(sizeof(CoeffReturnType) * num_coeffs_to_preserve)));
-          m_result = data;
-        }
-        Op reducer(m_reducer);
-        internal::GenericReducer<Self, Op, Device>::run(*this, reducer, m_device, data, num_values_to_reduce,
-                                                        num_coeffs_to_preserve);
-        return (m_result != NULL);
-      }
-#endif
-    }
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType data, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(NULL, [this, data, done](bool) { done(evalSubExprsIfNeededCommon(data)); });
-  }
-#endif
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return evalSubExprsIfNeededCommon(data);
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    m_impl.cleanup();
-    if (m_result) {
-      m_device.deallocate_temp(m_result);
-      m_result = NULL;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    if ((RunningFullReduction || RunningOnGPU) && m_result) {
-      return *(m_result + index);
-    }
-    Op reducer(m_reducer);
-    if (ReducingInnerMostDims || RunningFullReduction) {
-      const Index num_values_to_reduce = (static_cast<int>(Layout) == static_cast<int>(ColMajor))
-                                             ? m_preservedStrides[0]
-                                             : m_preservedStrides[NumPreservedStrides - 1];
-      return internal::InnerMostDimReducer<Self, Op>::reduce(*this, firstInput(index), num_values_to_reduce, reducer);
-    } else {
-      typename Self::CoeffReturnType accum = reducer.initialize();
-      internal::GenericDimReducer<NumReducedDims - 1, Self, Op>::reduce(*this, firstInput(index), reducer, &accum);
-      return reducer.finalize(accum);
-    }
-  }
-
-  // TODO(bsteiner): provide a more efficient implementation.
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < Index(internal::array_prod(dimensions())));
-
-    if (RunningOnGPU && m_result) {
-      return internal::pload<PacketReturnType>(m_result + index);
-    }
-
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    if (ReducingInnerMostDims) {
-      const Index num_values_to_reduce = (static_cast<int>(Layout) == static_cast<int>(ColMajor))
-                                             ? m_preservedStrides[0]
-                                             : m_preservedStrides[NumPreservedStrides - 1];
-      const Index firstIndex = firstInput(index);
-      for (Index i = 0; i < PacketSize; ++i) {
-        Op reducer(m_reducer);
-        values[i] = internal::InnerMostDimReducer<Self, Op>::reduce(*this, firstIndex + i * num_values_to_reduce,
-                                                                    num_values_to_reduce, reducer);
-      }
-    } else if (PreservingInnerMostDims) {
-      const Index firstIndex = firstInput(index);
-      const int innermost_dim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : NumOutputDims - 1;
-      // TBD: extend this to the n innermost dimensions that we preserve.
-      if (((firstIndex % m_dimensions[innermost_dim]) + PacketSize - 1) < m_dimensions[innermost_dim]) {
-        Op reducer(m_reducer);
-        typename Self::PacketReturnType accum = reducer.template initializePacket<typename Self::PacketReturnType>();
-        internal::InnerMostDimPreserver<NumReducedDims - 1, Self, Op>::reduce(*this, firstIndex, reducer, &accum);
-        return reducer.finalizePacket(accum);
-      } else {
-        for (int i = 0; i < PacketSize; ++i) {
-          values[i] = coeff(index + i);
-        }
-      }
-    } else {
-      for (int i = 0; i < PacketSize; ++i) {
-        values[i] = coeff(index + i);
-      }
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  // Must be called after evalSubExprsIfNeeded().
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    if (RunningFullReduction && m_result) {
-      return TensorOpCost(sizeof(CoeffReturnType), 0, 0, vectorized, PacketSize);
-    } else {
-      const Index num_values_to_reduce = internal::array_prod(m_reducedDims);
-      const double compute_cost = num_values_to_reduce * internal::functor_traits<Op>::Cost;
-      return m_impl.costPerCoeff(vectorized) * num_values_to_reduce +
-             TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return m_result; }
-  EIGEN_DEVICE_FUNC const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-  EIGEN_DEVICE_FUNC const Device& device() const { return m_device; }
-
- private:
-  template <int, typename, typename>
-  friend struct internal::GenericDimReducer;
-  template <typename, typename, bool, bool>
-  friend struct internal::InnerMostDimReducer;
-  template <int, typename, typename, bool>
-  friend struct internal::InnerMostDimPreserver;
-  template <typename S, typename O, typename D, bool V>
-  friend struct internal::FullReducer;
-#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
-  template <int B, int N, typename S, typename R, typename I_>
-  KERNEL_FRIEND void internal::FullReductionKernel(R, const S, I_, typename S::CoeffReturnType*, unsigned int*);
-#if defined(EIGEN_HAS_GPU_FP16)
-  template <typename S, typename R, typename I_>
-  KERNEL_FRIEND void internal::ReductionInitFullReduxKernelHalfFloat(R, const S, I_,
-                                                                     internal::packet_traits<Eigen::half>::type*);
-  template <int B, int N, typename S, typename R, typename I_>
-  KERNEL_FRIEND void internal::FullReductionKernelHalfFloat(R, const S, I_, half*,
-                                                            internal::packet_traits<Eigen::half>::type*);
-  template <int NPT, typename S, typename R, typename I_>
-  KERNEL_FRIEND void internal::InnerReductionKernelHalfFloat(R, const S, I_, I_, half*);
-#endif
-  template <int NPT, typename S, typename R, typename I_>
-  KERNEL_FRIEND void internal::InnerReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
-
-  template <int NPT, typename S, typename R, typename I_>
-  KERNEL_FRIEND void internal::OuterReductionKernel(R, const S, I_, I_, typename S::CoeffReturnType*);
-#endif
-
-#if defined(EIGEN_USE_SYCL)
-  template <typename Evaluator_, typename Op__>
-  friend class TensorSycl::internal::GenericNondeterministicReducer;
-  // SYCL needs the generic reducer when the reduction is neither inner, outer, nor full.
-  template <typename, typename, typename>
-  friend struct internal::GenericReducer;
-#endif
-
-  template <typename S, typename O, typename D>
-  friend struct internal::InnerReducer;
-
-  struct BlockIteratorState {
-    Index input_dim;
-    Index output_size;
-    Index output_count;
-  };
-
-  // Returns the Index in the input tensor of the first value that needs to be
-  // used to compute the reduction at output index "index".
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index firstInput(Index index) const {
-    if (ReducingInnerMostDims) {
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        return index * m_preservedStrides[0];
-      } else {
-        return index * m_preservedStrides[NumPreservedStrides - 1];
-      }
-    }
-    // TBD: optimize the case where we preserve the innermost dimensions.
-    Index startInput = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumOutputDims - 1; i > 0; --i) {
-        // This is index_i in the output tensor.
-        const Index idx = index / m_outputStrides[i];
-        startInput += idx * m_preservedStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (PreservingInnerMostDims) {
-        eigen_assert(m_preservedStrides[0] == 1);
-        startInput += index;
-      } else {
-        startInput += index * m_preservedStrides[0];
-      }
-    } else {
-      for (int i = 0; i < NumOutputDims - 1; ++i) {
-        // This is index_i in the output tensor.
-        const Index idx = index / m_outputStrides[i];
-        startInput += idx * m_preservedStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      if (PreservingInnerMostDims) {
-        eigen_assert(m_preservedStrides[NumPreservedStrides - 1] == 1);
-        startInput += index;
-      } else {
-        startInput += index * m_preservedStrides[NumPreservedStrides - 1];
-      }
-    }
-    return startInput;
-  }
-
-  // Bitmap indicating if an input dimension is reduced or not.
-  array<bool, NumInputDims> m_reduced;
-  // Dimensions of the output of the operation.
-  Dimensions m_dimensions;
-  // Precomputed strides for the output tensor.
-  // Avoid zero-sized arrays, since element access fails to compile on GPU.
-  array<Index, (std::max)(NumOutputDims, 1)> m_outputStrides;
-  array<internal::TensorIntDivisor<Index>, (std::max)(NumOutputDims, 1)> m_fastOutputStrides;
-  array<Index, (std::max)(NumPreservedStrides, 1)> m_preservedStrides;
-  // Map from output to input dimension index.
-  array<Index, (std::max)(NumOutputDims, 1)> m_output_to_input_dim_map;
-  // How many values go into each reduction
-  Index m_numValuesToReduce;
-
-  // Subset of strides of the input tensor for the reduced dimensions.
-  // Indexed by reduced dimensions.
-  array<Index, NumReducedDims> m_reducedStrides;
-  // Size of the input dimensions that are reduced.
-  // Indexed by reduced dimensions.
-  array<Index, NumReducedDims> m_reducedDims;
-
-  // Evaluator for the input expression.
-  TensorEvaluator<ArgType, Device> m_impl;
-
-  // Operation to apply for computing the reduction.
-  Op m_reducer;
-
-  EvaluatorPointerType m_result;
-
-  const Device EIGEN_DEVICE_REF m_device;
-};
-
-template <typename Op, typename Dims, typename ArgType, template <class> class MakePointer_, typename Device>
-struct TensorEvaluator<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device>
-    : public TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> {
-  typedef TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Device> Base;
-  EIGEN_STRONG_INLINE TensorEvaluator(const typename Base::XprType& op, const Device& device) : Base(op, device) {}
-};
-
-template <typename Op, typename Dims, typename ArgType, template <class> class MakePointer_>
-struct TensorEvaluator<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Eigen::SyclDevice>
-    : public TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Eigen::SyclDevice> {
-  typedef TensorReductionEvaluatorBase<const TensorReductionOp<Op, Dims, ArgType, MakePointer_>, Eigen::SyclDevice>
-      Base;
-  EIGEN_STRONG_INLINE TensorEvaluator(const typename Base::XprType& op, const Eigen::SyclDevice& device)
-      : Base(op, device) {}
-  // The base coeff function uses a recursive method that is not standard layout and cannot be used in
-  // SYCL kernels, so it must be overridden.
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Base::CoeffReturnType coeff(typename Base::Index index) const {
-    return *(this->data() + index);
-  }
-  // The base packet function uses a recursive method that is not standard layout and cannot be used in
-  // SYCL kernels, so it must be overridden.
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename Base::PacketReturnType packet(typename Base::Index index) const {
-    return internal::pload<typename Base::PacketReturnType>(this->data() + index);
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_REDUCTION_H
diff --git a/unsupported/Eigen/src/Tensor/TensorReductionGpu.h b/unsupported/Eigen/src/Tensor/TensorReductionGpu.h
deleted file mode 100644
index f3e5db6..0000000
--- a/unsupported/Eigen/src/Tensor/TensorReductionGpu.h
+++ /dev/null
@@ -1,963 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_REDUCTION_GPU_H
-#define EIGEN_CXX11_TENSOR_TENSOR_REDUCTION_GPU_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-#if defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
-// Full reducers for GPU, don't vectorize for now
-
-// Reducer function that enables multiple gpu thread to safely accumulate at the same
-// output address. It basically reads the current value of the output variable, and
-// attempts to update it with the new value. If in the meantime another gpu thread
-// updated the content of the output address it will try again.
-template <typename T, typename R>
-__device__ EIGEN_ALWAYS_INLINE void atomicReduce(T* output, T accum, R& reducer) {
-#if (defined(EIGEN_HIP_DEVICE_COMPILE) && defined(__HIP_ARCH_HAS_WARP_SHUFFLE__)) || (EIGEN_CUDA_ARCH >= 300)
-  if (sizeof(T) == 4) {
-    unsigned int oldval = *reinterpret_cast<unsigned int*>(output);
-    unsigned int newval = oldval;
-    reducer.reduce(accum, reinterpret_cast<T*>(&newval));
-    if (newval == oldval) {
-      return;
-    }
-    unsigned int readback;
-    while ((readback = atomicCAS((unsigned int*)output, oldval, newval)) != oldval) {
-      oldval = readback;
-      newval = oldval;
-      reducer.reduce(accum, reinterpret_cast<T*>(&newval));
-      if (newval == oldval) {
-        return;
-      }
-    }
-  } else if (sizeof(T) == 8) {
-    unsigned long long oldval = *reinterpret_cast<unsigned long long*>(output);
-    unsigned long long newval = oldval;
-    reducer.reduce(accum, reinterpret_cast<T*>(&newval));
-    if (newval == oldval) {
-      return;
-    }
-    unsigned long long readback;
-    while ((readback = atomicCAS(reinterpret_cast<unsigned long long*>(output), oldval, newval)) != oldval) {
-      oldval = readback;
-      newval = oldval;
-      reducer.reduce(accum, reinterpret_cast<T*>(&newval));
-      if (newval == oldval) {
-        return;
-      }
-    }
-  } else {
-    gpu_assert(0 && "Wordsize not supported");
-  }
-#else   // EIGEN_CUDA_ARCH >= 300
-  EIGEN_UNUSED_VARIABLE(output);
-  EIGEN_UNUSED_VARIABLE(accum);
-  EIGEN_UNUSED_VARIABLE(reducer);
-  gpu_assert(0 && "Shouldn't be called on unsupported device");
-#endif  // EIGEN_CUDA_ARCH >= 300
-}
-
-// We extend atomicExch to support extra data types
-template <typename Type>
-__device__ inline Type atomicExchCustom(Type* address, Type val) {
-  return atomicExch(address, val);
-}
-
-template <>
-__device__ inline double atomicExchCustom(double* address, double val) {
-  unsigned long long int* address_as_ull = reinterpret_cast<unsigned long long int*>(address);
-  return __longlong_as_double(atomicExch(address_as_ull, __double_as_longlong(val)));
-}
-
-#ifdef EIGEN_HAS_GPU_FP16
-template <typename R>
-__device__ inline void atomicReduce(half2* output, half2 accum, R& reducer) {
-  unsigned int oldval = *reinterpret_cast<unsigned int*>(output);
-  unsigned int newval = oldval;
-  reducer.reducePacket(accum, reinterpret_cast<half2*>(&newval));
-  if (newval == oldval) {
-    return;
-  }
-  unsigned int readback;
-  while ((readback = atomicCAS((unsigned int*)output, oldval, newval)) != oldval) {
-    oldval = readback;
-    newval = oldval;
-    reducer.reducePacket(accum, reinterpret_cast<half2*>(&newval));
-    if (newval == oldval) {
-      return;
-    }
-  }
-}
-#ifdef EIGEN_GPU_COMPILE_PHASE
-// reduction should be associative since reduction is not atomic in wide vector but atomic in half2 operations
-template <typename R>
-__device__ inline void atomicReduce(Packet4h2* output, Packet4h2 accum, R& reducer) {
-  half2* houtput = reinterpret_cast<half2*>(output);
-  half2* haccum = reinterpret_cast<half2*>(&accum);
-  for (int i = 0; i < 4; ++i) {
-    atomicReduce(houtput + i, *(haccum + i), reducer);
-  }
-}
-#endif  // EIGEN_GPU_COMPILE_PHASE
-#endif  // EIGEN_HAS_GPU_FP16
-
-template <>
-__device__ inline void atomicReduce(float* output, float accum, SumReducer<float>&) {
-#if (defined(EIGEN_HIP_DEVICE_COMPILE) && defined(__HIP_ARCH_HAS_WARP_SHUFFLE__)) || (EIGEN_CUDA_ARCH >= 300)
-  atomicAdd(output, accum);
-#else   // EIGEN_CUDA_ARCH >= 300
-  EIGEN_UNUSED_VARIABLE(output);
-  EIGEN_UNUSED_VARIABLE(accum);
-  gpu_assert(0 && "Shouldn't be called on unsupported device");
-#endif  // EIGEN_CUDA_ARCH >= 300
-}
-
-template <typename CoeffType, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitKernel(const CoeffType val, Index num_preserved_coeffs,
-                                                                 CoeffType* output) {
-  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
-  const Index num_threads = blockDim.x * gridDim.x;
-  for (Index i = thread_id; i < num_preserved_coeffs; i += num_threads) {
-    output[i] = val;
-  }
-}
-
-template <int BlockSize, int NumPerThread, typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernel(Reducer reducer, const Self input, Index num_coeffs,
-                                                                 typename Self::CoeffReturnType* output,
-                                                                 unsigned int* semaphore) {
-#if (defined(EIGEN_HIP_DEVICE_COMPILE) && defined(__HIP_ARCH_HAS_WARP_SHUFFLE__)) || (EIGEN_CUDA_ARCH >= 300)
-  // Initialize the output value
-  const Index first_index = blockIdx.x * BlockSize * NumPerThread + threadIdx.x;
-  if (gridDim.x == 1) {
-    if (first_index == 0) {
-      *output = reducer.initialize();
-    }
-  } else {
-    if (threadIdx.x == 0) {
-      unsigned int block = atomicCAS(semaphore, 0u, 1u);
-      if (block == 0) {
-        // We're the first block to run, initialize the output value
-        atomicExchCustom(output, reducer.initialize());
-        __threadfence();
-        atomicExch(semaphore, 2u);
-      } else {
-        // Wait for the first block to initialize the output value.
-        // Use atomicCAS here to ensure that the reads aren't cached
-        unsigned int val;
-        do {
-          val = atomicCAS(semaphore, 2u, 2u);
-        } while (val < 2u);
-      }
-    }
-  }
-
-  __syncthreads();
-
-  eigen_assert(gridDim.x == 1 || *semaphore >= 2u);
-
-  typename Self::CoeffReturnType accum = reducer.initialize();
-  Index max_iter = numext::mini<Index>(num_coeffs - first_index, NumPerThread * BlockSize);
-  for (Index i = 0; i < max_iter; i += BlockSize) {
-    const Index index = first_index + i;
-    eigen_assert(index < num_coeffs);
-    typename Self::CoeffReturnType val = input.m_impl.coeff(index);
-    reducer.reduce(val, &accum);
-  }
-
-#pragma unroll
-  for (int offset = warpSize / 2; offset > 0; offset /= 2) {
-#if defined(EIGEN_HIPCC)
-    // use std::is_floating_point to determine the type of reduced_val
-    // This is needed because when Type == double, hipcc will give a "call to __shfl_down is ambiguous" error
-    // and list the float and int versions of __shfl_down as the candidate functions.
-    if (std::is_floating_point<typename Self::CoeffReturnType>::value) {
-      reducer.reduce(__shfl_down(static_cast<float>(accum), offset, warpSize), &accum);
-    } else {
-      reducer.reduce(__shfl_down(static_cast<int>(accum), offset, warpSize), &accum);
-    }
-#elif defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
-    reducer.reduce(__shfl_down(accum, offset, warpSize), &accum);
-#else
-    reducer.reduce(__shfl_down_sync(0xFFFFFFFF, accum, offset, warpSize), &accum);
-#endif
-  }
-
-  if ((threadIdx.x & (warpSize - 1)) == 0) {
-    atomicReduce(output, accum, reducer);
-  }
-
-  if (gridDim.x > 1 && threadIdx.x == 0) {
-    // Let the last block reset the semaphore
-    atomicInc(semaphore, gridDim.x + 1);
-#if defined(EIGEN_HIPCC)
-    __threadfence_system();
-#endif
-  }
-#else   // EIGEN_CUDA_ARCH >= 300
-  EIGEN_UNUSED_VARIABLE(reducer);
-  EIGEN_UNUSED_VARIABLE(input);
-  EIGEN_UNUSED_VARIABLE(num_coeffs);
-  EIGEN_UNUSED_VARIABLE(output);
-  EIGEN_UNUSED_VARIABLE(semaphore);
-  gpu_assert(0 && "Shouldn't be called on unsupported device");
-#endif  // EIGEN_CUDA_ARCH >= 300
-}
-
-#ifdef EIGEN_HAS_GPU_FP16
-template <typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitFullReduxKernelHalfFloat(Reducer reducer, const Self input,
-                                                                                   Index num_coeffs, half* scratch) {
-  eigen_assert(blockDim.x == 1);
-  eigen_assert(gridDim.x == 1);
-  typedef packet_traits<Eigen::half>::type packet_type;
-  Index packet_remainder = num_coeffs % Index(unpacket_traits<packet_type>::size);
-  if (packet_remainder != 0) {
-    half2* h2scratch = reinterpret_cast<half2*>(scratch);
-    for (Index i = num_coeffs - packet_remainder; i + 2 <= num_coeffs; i += 2) {
-      *h2scratch = __halves2half2(input.coeff(i), input.coeff(i + 1));
-      h2scratch++;
-    }
-    if ((num_coeffs & 1) != 0) {
-      half lastCoeff = input.coeff(num_coeffs - 1);
-      *h2scratch = __halves2half2(lastCoeff, reducer.initialize());
-    }
-  } else {
-    packet_type reduce = reducer.template initializePacket<packet_type>();
-    internal::pstoreu(scratch, reduce);
-  }
-}
-
-template <typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionInitKernelHalfFloat(Reducer reducer, const Self /*input*/,
-                                                                          Index num_coeffs, half* output) {
-  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
-  const Index num_threads = blockDim.x * gridDim.x;
-  typedef typename packet_traits<Eigen::half>::type PacketType;
-
-  const Index num_packets = num_coeffs / Index(unpacket_traits<PacketType>::size);
-  PacketType* p_output = reinterpret_cast<PacketType*>(output);
-  for (Index i = thread_id; i < num_packets; i += num_threads) {
-    p_output[i] = reducer.template initializePacket<PacketType>();
-  }
-  Index packet_remainder = num_coeffs % Index(unpacket_traits<PacketType>::size);
-  if (thread_id < packet_remainder) {
-    output[num_coeffs - packet_remainder + thread_id] = reducer.initialize();
-  }
-}
-
-template <int BlockSize, int NumPerThread, typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void FullReductionKernelHalfFloat(Reducer reducer, const Self input,
-                                                                          Index num_coeffs, half* output,
-                                                                          half* scratch) {
-  typedef typename packet_traits<Eigen::half>::type PacketType;
-  const int packet_width = unpacket_traits<PacketType>::size;
-  eigen_assert(NumPerThread % packet_width == 0);
-  const Index first_index = blockIdx.x * BlockSize * NumPerThread + packet_width * threadIdx.x;
-
-  // Initialize the output value if it wasn't initialized by the ReductionInitKernel
-
-  if (gridDim.x == 1) {
-    if (first_index == 0) {
-      int rem = num_coeffs % packet_width;
-      if (rem != 0) {
-        half2* p_scratch = reinterpret_cast<half2*>(scratch);
-        pstoreu(scratch, reducer.template initializePacket<PacketType>());
-        for (int i = 0; i < rem / 2; i++) {
-          *p_scratch = __halves2half2(input.coeff(num_coeffs - packet_width + 2 * i),
-                                      input.coeff(num_coeffs - packet_width + 2 * i + 1));
-          p_scratch++;
-        }
-        if ((num_coeffs & 1) != 0) {
-          half last = input.coeff(num_coeffs - 1);
-          *p_scratch = __halves2half2(last, reducer.initialize());
-        }
-      } else {
-        PacketType reduce = reducer.template initializePacket<PacketType>();
-        pstoreu(scratch, reduce);
-      }
-    }
-    __syncthreads();
-  }
-
-  PacketType accum = reducer.template initializePacket<PacketType>();
-  const Index max_iter =
-      numext::mini<Index>((num_coeffs - first_index) / packet_width, NumPerThread * BlockSize / packet_width);
-  for (Index i = 0; i < max_iter; i += BlockSize) {
-    const Index index = first_index + packet_width * i;
-    eigen_assert(index + packet_width < num_coeffs);
-    PacketType val = input.template packet<Unaligned>(index);
-    reducer.reducePacket(val, &accum);
-  }
-
-#pragma unroll
-  for (int offset = warpSize / 2; offset > 0; offset /= 2) {
-#if defined(EIGEN_HIPCC)
-    PacketType r1;
-    half2* hr = reinterpret_cast<half2*>(&r1);
-    half2* hacc = reinterpret_cast<half2*>(&accum);
-    for (int i = 0; i < packet_width / 2; i++) {
-      // FIXME : remove this workaround once we have native half/half2 support for __shfl_down
-      union {
-        int i;
-        half2 h;
-      } wka_in, wka_out;
-      wka_in.h = hacc[i];
-      wka_out.i = __shfl_down(wka_in.i, offset, warpSize);
-      hr[i] = wka_out.h;
-    }
-    reducer.reducePacket(r1, &accum);
-#elif defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
-    PacketType r1;
-    half2* hr = reinterpret_cast<half2*>(&r1);
-    half2* hacc = reinterpret_cast<half2*>(&accum);
-    for (int i = 0; i < packet_width / 2; i++) {
-      hr[i] = __shfl_down(hacc[i], offset, warpSize);
-    }
-    reducer.reducePacket(r1, &accum);
-#else
-    PacketType r1;
-    half2* hr = reinterpret_cast<half2*>(&r1);
-    half2* hacc = reinterpret_cast<half2*>(&accum);
-    for (int i = 0; i < packet_width / 2; i++) {
-      hr[i] = __shfl_down_sync(0xFFFFFFFF, hacc[i], (unsigned)offset, warpSize);
-    }
-    reducer.reducePacket(r1, &accum);
-
-#endif
-  }
-
-  if ((threadIdx.x & (warpSize - 1)) == 0) {
-    atomicReduce(reinterpret_cast<PacketType*>(scratch), accum, reducer);
-  }
-
-  __syncthreads();
-  half2* rv1 = reinterpret_cast<half2*>(scratch);
-  if (packet_width > 2) {
-    reducer.reducePacket(rv1[2], rv1);
-    reducer.reducePacket(rv1[3], rv1 + 1);
-    reducer.reducePacket(rv1[1], rv1);
-  }
-  if (gridDim.x == 1) {
-    if (first_index == 0) {
-      half tmp = __low2half(*rv1);
-      reducer.reduce(__high2half(*rv1), &tmp);
-      *output = tmp;
-    }
-  }
-}
-
-template <typename Op>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ReductionCleanupKernelHalfFloat(Op reducer, half* output, half* scratch) {
-  eigen_assert(threadIdx.x == 1);
-  typedef packet_traits<Eigen::half>::type packet_type;
-  if (unpacket_traits<packet_type>::size == 1) {
-    *output = *scratch;
-  } else {
-    half2* pscratch = reinterpret_cast<half2*>(scratch);
-    half tmp = __float2half(0.f);
-    for (int i = 0; i < unpacket_traits<packet_type>::size; i += 2) {
-      reducer.reduce(__low2half(*pscratch), &tmp);
-      reducer.reduce(__high2half(*pscratch), &tmp);
-      pscratch++;
-    }
-    *output = tmp;
-  }
-}
-
-#endif  // EIGEN_HAS_GPU_FP16
-
-template <typename Self, typename Op, typename OutputType, bool PacketAccess, typename Enabled = void>
-struct FullReductionLauncher {
-  static void run(const Self&, Op&, const GpuDevice&, OutputType*, typename Self::Index) {
-    gpu_assert(false && "Should only be called on doubles, floats and half floats");
-  }
-};
-
-// Specialization for float and double
-template <typename Self, typename Op, typename OutputType, bool PacketAccess>
-struct FullReductionLauncher<
-    Self, Op, OutputType, PacketAccess,
-    std::enable_if_t<internal::is_same<float, OutputType>::value || internal::is_same<double, OutputType>::value,
-                     void>> {
-  static void run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
-                  typename Self::Index num_coeffs) {
-    typedef typename Self::Index Index;
-    const int block_size = 256;
-    const int num_per_thread = 128;
-    const int num_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
-
-    unsigned int* semaphore = NULL;
-    if (num_blocks > 1) {
-      semaphore = device.semaphore();
-    }
-
-    LAUNCH_GPU_KERNEL((FullReductionKernel<block_size, num_per_thread, Self, Op, Index>), num_blocks, block_size, 0,
-                      device, reducer, self, num_coeffs, output, semaphore);
-  }
-};
-
-#ifdef EIGEN_HAS_GPU_FP16
-template <typename Self, typename Op>
-struct FullReductionLauncher<Self, Op, Eigen::half, false> {
-  static void run(const Self&, Op&, const GpuDevice&, half*, typename Self::Index) {
-    gpu_assert(false && "Should not be called since there is no packet accessor");
-  }
-};
-
-template <typename Self, typename Op>
-struct FullReductionLauncher<Self, Op, Eigen::half, true> {
-  static void run(const Self& self, Op& reducer, const GpuDevice& device, half* output,
-                  typename Self::Index num_coeffs) {
-    typedef typename Self::Index Index;
-
-    const int block_size = 256;
-    const int num_per_thread = 128;
-    const int num_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
-    half* scratch = static_cast<half*>(device.scratchpad());
-
-    if (num_blocks > 1) {
-      // We initialize the output and the scratchpad outside the reduction kernel when we can't be sure that there
-      // won't be a race conditions between multiple thread blocks.
-      LAUNCH_GPU_KERNEL((ReductionInitFullReduxKernelHalfFloat<Self, Op, Index>), 1, 1, 0, device, reducer, self,
-                        num_coeffs, scratch);
-    }
-
-    LAUNCH_GPU_KERNEL((FullReductionKernelHalfFloat<block_size, num_per_thread, Self, Op, Index>), num_blocks,
-                      block_size, 0, device, reducer, self, num_coeffs, output, scratch);
-
-    if (num_blocks > 1) {
-      LAUNCH_GPU_KERNEL((ReductionCleanupKernelHalfFloat<Op>), 1, 1, 0, device, reducer, output, scratch);
-    }
-  }
-};
-#endif  // EIGEN_HAS_GPU_FP16
-
-template <typename Self, typename Op, bool Vectorizable>
-struct FullReducer<Self, Op, GpuDevice, Vectorizable> {
-  // Unfortunately nvidia doesn't support well exotic types such as complex,
-  // so reduce the scope of the optimized version of the code to the simple cases
-  // of doubles, floats and half floats
-#ifdef EIGEN_HAS_GPU_FP16
-  static constexpr bool HasOptimizedImplementation =
-      !Self::ReducerTraits::IsStateful && (internal::is_same<typename Self::CoeffReturnType, float>::value ||
-                                           internal::is_same<typename Self::CoeffReturnType, double>::value ||
-                                           (internal::is_same<typename Self::CoeffReturnType, Eigen::half>::value &&
-                                            reducer_traits<Op, GpuDevice>::PacketAccess));
-#else   // EIGEN_HAS_GPU_FP16
-  static constexpr bool HasOptimizedImplementation =
-      !Self::ReducerTraits::IsStateful && (internal::is_same<typename Self::CoeffReturnType, float>::value ||
-                                           internal::is_same<typename Self::CoeffReturnType, double>::value);
-#endif  // EIGEN_HAS_GPU_FP16
-
-  template <typename OutputType>
-  static void run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output) {
-    gpu_assert(HasOptimizedImplementation && "Should only be called on doubles, floats or half floats");
-    const Index num_coeffs = array_prod(self.m_impl.dimensions());
-    // Don't crash when we're called with an input tensor of size 0.
-    if (num_coeffs == 0) {
-      return;
-    }
-
-    FullReductionLauncher<Self, Op, OutputType, reducer_traits<Op, GpuDevice>::PacketAccess>::run(self, reducer, device,
-                                                                                                  output, num_coeffs);
-  }
-};
-
-template <int NumPerThread, typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernel(Reducer reducer, const Self input,
-                                                                  Index num_coeffs_to_reduce,
-                                                                  Index num_preserved_coeffs,
-                                                                  typename Self::CoeffReturnType* output) {
-#if (defined(EIGEN_HIP_DEVICE_COMPILE) && defined(__HIP_ARCH_HAS_WARP_SHUFFLE__)) || (EIGEN_CUDA_ARCH >= 300)
-  typedef typename Self::CoeffReturnType Type;
-  eigen_assert(blockDim.y == 1);
-  eigen_assert(blockDim.z == 1);
-  eigen_assert(gridDim.y == 1);
-  eigen_assert(gridDim.z == 1);
-
-  const int unroll_times = 16;
-  eigen_assert(NumPerThread % unroll_times == 0);
-
-  const Index input_col_blocks = numext::div_ceil<Index>(num_coeffs_to_reduce, blockDim.x * NumPerThread);
-  const Index num_input_blocks = input_col_blocks * num_preserved_coeffs;
-
-  const Index num_threads = blockDim.x * gridDim.x;
-  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
-
-  // Initialize the output values if they weren't initialized by the ReductionInitKernel
-  if (gridDim.x == 1) {
-    for (Index i = thread_id; i < num_preserved_coeffs; i += num_threads) {
-      output[i] = reducer.initialize();
-    }
-    __syncthreads();
-  }
-
-  for (Index i = blockIdx.x; i < num_input_blocks; i += gridDim.x) {
-    const Index row = i / input_col_blocks;
-
-    if (row < num_preserved_coeffs) {
-      const Index col_block = i % input_col_blocks;
-      const Index col_begin = col_block * blockDim.x * NumPerThread + threadIdx.x;
-
-      Type reduced_val = reducer.initialize();
-
-      for (Index j = 0; j < NumPerThread; j += unroll_times) {
-        const Index last_col = col_begin + blockDim.x * (j + unroll_times - 1);
-        if (last_col >= num_coeffs_to_reduce) {
-          for (Index col = col_begin + blockDim.x * j; col < num_coeffs_to_reduce; col += blockDim.x) {
-            const Type val = input.m_impl.coeff(row * num_coeffs_to_reduce + col);
-            reducer.reduce(val, &reduced_val);
-          }
-          break;
-        } else {
-          // Faster version of the loop with no branches after unrolling.
-#pragma unroll
-          for (int k = 0; k < unroll_times; ++k) {
-            const Index col = col_begin + blockDim.x * (j + k);
-            reducer.reduce(input.m_impl.coeff(row * num_coeffs_to_reduce + col), &reduced_val);
-          }
-        }
-      }
-
-#pragma unroll
-      for (int offset = warpSize / 2; offset > 0; offset /= 2) {
-#if defined(EIGEN_HIPCC)
-        // use std::is_floating_point to determine the type of reduced_val
-        // This is needed because when Type == double, hipcc will give a "call to __shfl_down is ambiguous" error
-        // and list the float and int versions of __shfl_down as the candidate functions.
-        if (std::is_floating_point<Type>::value) {
-          reducer.reduce(__shfl_down(static_cast<float>(reduced_val), offset), &reduced_val);
-        } else {
-          reducer.reduce(__shfl_down(static_cast<int>(reduced_val), offset), &reduced_val);
-        }
-#elif defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
-        reducer.reduce(__shfl_down(reduced_val, offset), &reduced_val);
-#else
-        reducer.reduce(__shfl_down_sync(0xFFFFFFFF, reduced_val, offset), &reduced_val);
-#endif
-      }
-
-      if ((threadIdx.x & (warpSize - 1)) == 0) {
-        atomicReduce(&(output[row]), reduced_val, reducer);
-      }
-    }
-  }
-#else   // EIGEN_CUDA_ARCH >= 300
-  EIGEN_UNUSED_VARIABLE(reducer);
-  EIGEN_UNUSED_VARIABLE(input);
-  EIGEN_UNUSED_VARIABLE(num_coeffs_to_reduce);
-  EIGEN_UNUSED_VARIABLE(num_preserved_coeffs);
-  EIGEN_UNUSED_VARIABLE(output);
-  gpu_assert(0 && "Shouldn't be called on unsupported device");
-#endif  // EIGEN_CUDA_ARCH >= 300
-}
-
-#ifdef EIGEN_HAS_GPU_FP16
-
-template <int NumPerThread, typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void InnerReductionKernelHalfFloat(Reducer reducer, const Self input,
-                                                                           Index num_coeffs_to_reduce,
-                                                                           Index num_preserved_coeffs, half* output) {
-  eigen_assert(blockDim.y == 1);
-  eigen_assert(blockDim.z == 1);
-  eigen_assert(gridDim.y == 1);
-  eigen_assert(gridDim.z == 1);
-
-  typedef typename packet_traits<Eigen::half>::type PacketType;
-  const int packet_width = unpacket_traits<PacketType>::size;
-  const int unroll_times = 16 / packet_width;
-  eigen_assert(NumPerThread % unroll_times == 0);
-  eigen_assert(unroll_times % 2 == 0);
-
-  const Index input_col_blocks = numext::div_ceil<Index>(num_coeffs_to_reduce, blockDim.x * NumPerThread * 2);
-  const Index num_input_blocks = numext::div_ceil<Index>(input_col_blocks * num_preserved_coeffs, 2);
-
-  const Index num_threads = blockDim.x * gridDim.x;
-  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
-
-  // Initialize the output values if they weren't initialized by the ReductionInitKernel
-  if (gridDim.x == 1) {
-    Index i = packet_width * thread_id;
-    for (; i + packet_width <= num_preserved_coeffs; i += packet_width * num_threads) {
-      PacketType* poutput = reinterpret_cast<PacketType*>(output + i);
-      *poutput = reducer.template initializePacket<PacketType>();
-    }
-    if (i < num_preserved_coeffs) {
-      output[i] = reducer.initialize();
-    }
-    __syncthreads();
-  }
-
-  for (Index i = blockIdx.x; i < num_input_blocks; i += gridDim.x) {
-    const Index row = 2 * (i / input_col_blocks);  // everybody takes 2 rows
-
-    if (row + 1 < num_preserved_coeffs) {
-      const Index col_block = i % input_col_blocks;
-      const Index col_begin = packet_width * (col_block * blockDim.x * NumPerThread + threadIdx.x);
-
-      PacketType reduced_val1 = reducer.template initializePacket<PacketType>();
-      PacketType reduced_val2 = reducer.template initializePacket<PacketType>();
-
-      for (Index j = 0; j < NumPerThread; j += unroll_times) {
-        const Index last_col = col_begin + blockDim.x * (j + unroll_times - 1) * packet_width;
-        if (last_col >= num_coeffs_to_reduce) {
-          Index col = col_begin + blockDim.x * j;
-          for (; col + packet_width <= num_coeffs_to_reduce; col += blockDim.x) {
-            const PacketType val1 = input.m_impl.template packet<Unaligned>(row * num_coeffs_to_reduce + col);
-            reducer.reducePacket(val1, &reduced_val1);
-            const PacketType val2 = input.m_impl.template packet<Unaligned>((row + 1) * num_coeffs_to_reduce + col);
-            reducer.reducePacket(val2, &reduced_val2);
-          }
-          if (col < num_coeffs_to_reduce) {
-            PacketType r1 = reducer.template initializePacket<PacketType>();
-            PacketType r2 = reducer.template initializePacket<PacketType>();
-            half2* hr1 = reinterpret_cast<half2*>(&r1);
-            half2* hr2 = reinterpret_cast<half2*>(&r2);
-            while (col + 1 < num_coeffs_to_reduce) {
-              *hr1 = __halves2half2(input.m_impl.coeff(row * num_coeffs_to_reduce + col),
-                                    input.m_impl.coeff(row * num_coeffs_to_reduce + col + 1));
-              *hr2 = __halves2half2(input.m_impl.coeff((row + 1) * num_coeffs_to_reduce + col),
-                                    input.m_impl.coeff((row + 1) * num_coeffs_to_reduce + col + 1));
-              hr1++;
-              hr2++;
-              col += 2;
-            }
-            if (col < num_coeffs_to_reduce) {
-              // Peel;
-              const half last1 = input.m_impl.coeff(row * num_coeffs_to_reduce + col);
-              *hr1 = __halves2half2(last1, reducer.initialize());
-              const half last2 = input.m_impl.coeff((row + 1) * num_coeffs_to_reduce + col);
-              *hr2 = __halves2half2(last2, reducer.initialize());
-            }
-            reducer.reducePacket(r1, &reduced_val1);
-            reducer.reducePacket(r2, &reduced_val2);
-          }
-          break;
-        } else {
-          // Faster version of the loop with no branches after unrolling.
-#pragma unroll
-          for (int k = 0; k < unroll_times; ++k) {
-            const Index col = col_begin + blockDim.x * (j + k) * packet_width;
-            reducer.reducePacket(input.m_impl.template packet<Unaligned>(row * num_coeffs_to_reduce + col),
-                                 &reduced_val1);
-            reducer.reducePacket(input.m_impl.template packet<Unaligned>((row + 1) * num_coeffs_to_reduce + col),
-                                 &reduced_val2);
-          }
-        }
-      }
-
-#pragma unroll
-      for (int offset = warpSize / 2; offset > 0; offset /= 2) {
-#if defined(EIGEN_HIPCC)
-        PacketType r1;
-        PacketType r2;
-        half2* hr1 = reinterpret_cast<half2*>(&r1);
-        half2* hr2 = reinterpret_cast<half2*>(&r2);
-        half2* rv1 = reinterpret_cast<half2*>(&reduced_val1);
-        half2* rv2 = reinterpret_cast<half2*>(&reduced_val2);
-        for (int i = 0; i < packet_width / 2; i++) {
-          // FIXME : remove this workaround once we have native half/half2 support for __shfl_down
-          union {
-            int i;
-            half2 h;
-          } wka_in1, wka_out1;
-          wka_in1.h = rv1[i];
-          wka_out1.i = __shfl_down(wka_in1.i, offset, warpSize);
-          hr1[i] = wka_out1.h;
-
-          union {
-            int i;
-            half2 h;
-          } wka_in2, wka_out2;
-          wka_in2.h = rv2[i];
-          wka_out2.i = __shfl_down(wka_in2.i, offset, warpSize);
-          hr2[i] = wka_out2.h;
-        }
-        reducer.reducePacket(r1, &reduced_val1);
-        reducer.reducePacket(r2, &reduced_val2);
-#elif defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000
-        PacketType r1;
-        PacketType r2;
-        half2* hr1 = reinterpret_cast<half2*>(&r1);
-        half2* hr2 = reinterpret_cast<half2*>(&r2);
-        half2* rv1 = reinterpret_cast<half2*>(&reduced_val1);
-        half2* rv2 = reinterpret_cast<half2*>(&reduced_val2);
-        for (int i = 0; i < packet_width / 2; i++) {
-          hr1[i] = __shfl_down(rv1[i], offset, warpSize);
-          hr2[i] = __shfl_down(rv2[i], offset, warpSize);
-        }
-        reducer.reducePacket(r1, &reduced_val1);
-        reducer.reducePacket(r2, &reduced_val2);
-#else
-        PacketType r1;
-        PacketType r2;
-        half2* hr1 = reinterpret_cast<half2*>(&r1);
-        half2* hr2 = reinterpret_cast<half2*>(&r2);
-        half2* rr1 = reinterpret_cast<half2*>(&reduced_val1);
-        half2* rr2 = reinterpret_cast<half2*>(&reduced_val2);
-        for (int j = 0; j < packet_width / 2; j++) {
-          hr1[j] = __shfl_down_sync(0xFFFFFFFF, rr1[j], (unsigned)offset, warpSize);
-          hr2[j] = __shfl_down_sync(0xFFFFFFFF, rr2[j], (unsigned)offset, warpSize);
-        }
-        reducer.reducePacket(r1, &reduced_val1);
-        reducer.reducePacket(r2, &reduced_val2);
-
-#endif
-      }
-      half2* rv1 = reinterpret_cast<half2*>(&reduced_val1);
-      half2* rv2 = reinterpret_cast<half2*>(&reduced_val2);
-      half2 val;
-      if (packet_width > 2) {
-        reducer.reducePacket(rv1[2], rv1);
-        reducer.reducePacket(rv1[3], rv1 + 1);
-        reducer.reducePacket(rv1[1], rv1);
-        reducer.reducePacket(rv2[2], rv2);
-        reducer.reducePacket(rv2[3], rv2 + 1);
-        reducer.reducePacket(rv2[1], rv2);
-      }
-      half val1 = __low2half(*rv1);
-      reducer.reduce(__high2half(*rv1), &val1);
-      half val2 = __low2half(*rv2);
-      reducer.reduce(__high2half(*rv2), &val2);
-      val = __halves2half2(val1, val2);
-      if ((threadIdx.x & (warpSize - 1)) == 0) {
-        half* loc = output + row;
-        atomicReduce(reinterpret_cast<half2*>(loc), val, reducer);
-      }
-    }
-  }
-}
-
-#endif  // EIGEN_HAS_GPU_FP16
-
-template <typename Self, typename Op, typename OutputType, bool PacketAccess, typename Enabled = void>
-struct InnerReductionLauncher {
-  static EIGEN_DEVICE_FUNC bool run(const Self&, Op&, const GpuDevice&, OutputType*, typename Self::Index,
-                                    typename Self::Index) {
-    gpu_assert(false && "Should only be called to reduce doubles, floats and half floats on a gpu device");
-    return true;
-  }
-};
-
-// Specialization for float and double
-template <typename Self, typename Op, typename OutputType, bool PacketAccess>
-struct InnerReductionLauncher<
-    Self, Op, OutputType, PacketAccess,
-    std::enable_if_t<internal::is_same<float, OutputType>::value || internal::is_same<double, OutputType>::value,
-                     void>> {
-  static bool run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
-                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
-    typedef typename Self::Index Index;
-
-    const Index num_coeffs = num_coeffs_to_reduce * num_preserved_vals;
-    const int block_size = 256;
-    const int num_per_thread = 128;
-    const int dyn_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
-    const int max_blocks = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / block_size;
-    const int num_blocks = numext::mini<int>(max_blocks, dyn_blocks);
-
-    if (num_blocks > 1) {
-      // We initialize the outputs outside the reduction kernel when we can't be sure that there
-      // won't be a race conditions between multiple thread blocks.
-      const int dyn_blocks2 = numext::div_ceil<int>(num_preserved_vals, 1024);
-      const int max_blocks2 = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / 1024;
-      const int num_blocks2 = numext::mini<int>(max_blocks2, dyn_blocks2);
-      LAUNCH_GPU_KERNEL((ReductionInitKernel<OutputType, Index>), num_blocks2, 1024, 0, device, reducer.initialize(),
-                        num_preserved_vals, output);
-    }
-
-    LAUNCH_GPU_KERNEL((InnerReductionKernel<num_per_thread, Self, Op, Index>), num_blocks, block_size, 0, device,
-                      reducer, self, num_coeffs_to_reduce, num_preserved_vals, output);
-
-    return false;
-  }
-};
-
-#ifdef EIGEN_HAS_GPU_FP16
-template <typename Self, typename Op>
-struct InnerReductionLauncher<Self, Op, Eigen::half, false> {
-  static bool run(const Self&, Op&, const GpuDevice&, half*, typename Self::Index, typename Self::Index) {
-    gpu_assert(false && "Should not be called since there is no packet accessor");
-    return true;
-  }
-};
-
-template <typename Self, typename Op>
-struct InnerReductionLauncher<Self, Op, Eigen::half, true> {
-  static bool run(const Self& self, Op& reducer, const GpuDevice& device, half* output,
-                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
-    typedef typename Self::Index Index;
-
-    if (num_preserved_vals % 2 != 0) {
-      // Not supported yet, revert to the slower code path
-      return true;
-    }
-
-    const Index num_coeffs = num_coeffs_to_reduce * num_preserved_vals;
-    const int block_size = 128;
-    const int num_per_thread = 64;
-    const int dyn_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
-    const int max_blocks = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / block_size;
-    const int num_blocks = numext::mini<int>(max_blocks, dyn_blocks);
-
-    if (num_blocks > 1) {
-      // We initialize the outputs outside the reduction kernel when we can't be sure that there
-      // won't be a race conditions between multiple thread blocks.
-      LAUNCH_GPU_KERNEL((ReductionInitKernelHalfFloat<Self, Op, Index>), 1, 1, 0, device, reducer, self,
-                        num_preserved_vals, output);
-    }
-
-    LAUNCH_GPU_KERNEL((InnerReductionKernelHalfFloat<num_per_thread, Self, Op, Index>), num_blocks, block_size, 0,
-                      device, reducer, self, num_coeffs_to_reduce, num_preserved_vals, output);
-
-    return false;
-  }
-};
-#endif  // EIGEN_HAS_GPU_FP16
-
-template <typename Self, typename Op>
-struct InnerReducer<Self, Op, GpuDevice> {
-  // Unfortunately nvidia doesn't support well exotic types such as complex,
-  // so reduce the scope of the optimized version of the code to the simple case
-  // of floats and half floats.
-#ifdef EIGEN_HAS_GPU_FP16
-  static constexpr bool HasOptimizedImplementation =
-      !Self::ReducerTraits::IsStateful && (internal::is_same<typename Self::CoeffReturnType, float>::value ||
-                                           internal::is_same<typename Self::CoeffReturnType, double>::value ||
-                                           (internal::is_same<typename Self::CoeffReturnType, Eigen::half>::value &&
-                                            reducer_traits<Op, GpuDevice>::PacketAccess));
-#else   // EIGEN_HAS_GPU_FP16
-  static constexpr bool HasOptimizedImplementation =
-      !Self::ReducerTraits::IsStateful && (internal::is_same<typename Self::CoeffReturnType, float>::value ||
-                                           internal::is_same<typename Self::CoeffReturnType, double>::value);
-#endif  // EIGEN_HAS_GPU_FP16
-
-  template <typename OutputType>
-  static bool run(const Self& self, Op& reducer, const GpuDevice& device, OutputType* output,
-                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
-    gpu_assert(HasOptimizedImplementation && "Should only be called on doubles, floats or half floats");
-    const Index num_coeffs = array_prod(self.m_impl.dimensions());
-    // Don't crash when we're called with an input tensor of size 0.
-    if (num_coeffs == 0) {
-      return true;
-    }
-    // It's faster to use the usual code.
-    if (num_coeffs_to_reduce <= 128) {
-      return true;
-    }
-
-    return InnerReductionLauncher<Self, Op, OutputType, reducer_traits<Op, GpuDevice>::PacketAccess>::run(
-        self, reducer, device, output, num_coeffs_to_reduce, num_preserved_vals);
-  }
-};
-
-template <int NumPerThread, typename Self, typename Reducer, typename Index>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void OuterReductionKernel(Reducer reducer, const Self input,
-                                                                  Index num_coeffs_to_reduce,
-                                                                  Index num_preserved_coeffs,
-                                                                  typename Self::CoeffReturnType* output) {
-  const Index num_threads = blockDim.x * gridDim.x;
-  const Index thread_id = blockIdx.x * blockDim.x + threadIdx.x;
-  // Initialize the output values if they weren't initialized by the ReductionInitKernel
-  if (gridDim.x == 1) {
-    for (Index i = thread_id; i < num_preserved_coeffs; i += num_threads) {
-      output[i] = reducer.initialize();
-    }
-    __syncthreads();
-  }
-
-  // Do the reduction.
-  const Index max_iter = num_preserved_coeffs * numext::div_ceil<Index>(num_coeffs_to_reduce, NumPerThread);
-  for (Index i = thread_id; i < max_iter; i += num_threads) {
-    const Index input_col = i % num_preserved_coeffs;
-    const Index input_row = (i / num_preserved_coeffs) * NumPerThread;
-    typename Self::CoeffReturnType reduced_val = reducer.initialize();
-    const Index max_row = numext::mini(input_row + NumPerThread, num_coeffs_to_reduce);
-    for (Index j = input_row; j < max_row; j++) {
-      typename Self::CoeffReturnType val = input.m_impl.coeff(j * num_preserved_coeffs + input_col);
-      reducer.reduce(val, &reduced_val);
-    }
-    atomicReduce(&(output[input_col]), reduced_val, reducer);
-  }
-}
-
-template <typename Self, typename Op>
-struct OuterReducer<Self, Op, GpuDevice> {
-  // Unfortunately nvidia doesn't support well exotic types such as complex,
-  // so reduce the scope of the optimized version of the code to the simple case
-  // of floats.
-  static constexpr bool HasOptimizedImplementation =
-      !Self::ReducerTraits::IsStateful && (internal::is_same<typename Self::CoeffReturnType, float>::value ||
-                                           internal::is_same<typename Self::CoeffReturnType, double>::value);
-  template <typename Device, typename OutputType>
-  static
-#if !defined(EIGEN_HIPCC)
-      // FIXME :  leaving this EIGEN_DEVICE_FUNC in, results in the following runtime error
-      //          (in the cxx11_tensor_reduction_gpu test)
-      //
-      // terminate called after throwing an instance of 'std::runtime_error'
-      //   what():  No device code available for function: _ZN5Eigen8internal20OuterReductionKernelIL...
-      //
-      // don't know why this happens (and why is it a runtime error instead of a compile time error)
-      //
-      // this will be fixed by HIP PR#457
-      EIGEN_DEVICE_FUNC
-#endif
-      bool
-      run(const Self&, Op&, const Device&, OutputType*, typename Self::Index, typename Self::Index) {
-    gpu_assert(false && "Should only be called to reduce doubles or floats on a gpu device");
-    return true;
-  }
-
-  static bool run(const Self& self, Op& reducer, const GpuDevice& device, float* output,
-                  typename Self::Index num_coeffs_to_reduce, typename Self::Index num_preserved_vals) {
-    typedef typename Self::Index Index;
-
-    // It's faster to use the usual code.
-    if (num_coeffs_to_reduce <= 32) {
-      return true;
-    }
-
-    const Index num_coeffs = num_coeffs_to_reduce * num_preserved_vals;
-    const int block_size = 256;
-    const int num_per_thread = 16;
-    const int dyn_blocks = numext::div_ceil<int>(num_coeffs, block_size * num_per_thread);
-    const int max_blocks = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / block_size;
-    const int num_blocks = numext::mini<int>(max_blocks, dyn_blocks);
-
-    if (num_blocks > 1) {
-      // We initialize the outputs in the reduction kernel itself when we don't have to worry
-      // about race conditions between multiple thread blocks.
-      const int dyn_blocks2 = numext::div_ceil<int>(num_preserved_vals, 1024);
-      const int max_blocks2 = device.getNumGpuMultiProcessors() * device.maxGpuThreadsPerMultiProcessor() / 1024;
-      const int num_blocks2 = numext::mini<int>(max_blocks2, dyn_blocks2);
-      LAUNCH_GPU_KERNEL((ReductionInitKernel<float, Index>), num_blocks2, 1024, 0, device, reducer.initialize(),
-                        num_preserved_vals, output);
-    }
-
-    LAUNCH_GPU_KERNEL((OuterReductionKernel<num_per_thread, Self, Op, Index>), num_blocks, block_size, 0, device,
-                      reducer, self, num_coeffs_to_reduce, num_preserved_vals, output);
-
-    return false;
-  }
-};
-
-#endif  // defined(EIGEN_USE_GPU) && defined(EIGEN_GPUCC)
-
-}  // end namespace internal
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_REDUCTION_GPU_H
diff --git a/unsupported/Eigen/src/Tensor/TensorReductionSycl.h b/unsupported/Eigen/src/Tensor/TensorReductionSycl.h
deleted file mode 100644
index 2b5b734..0000000
--- a/unsupported/Eigen/src/Tensor/TensorReductionSycl.h
+++ /dev/null
@@ -1,584 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-/*****************************************************************
- * TensorReductionSycl.h
- *
- * \brief:
- *  This is the specialization of the reduction operation. Two phase reduction approach
- * is used since the GPU does not have Global Synchronization for global memory among
- * different work-group/thread block. To solve the problem, we need to create two kernels
- * to reduce the data, where the first kernel reduce the data locally and each local
- * workgroup/thread-block save the input data into global memory. In the second phase (global reduction)
- * one work-group uses one work-group/thread-block to reduces the intermediate data into one single element.
- * Here is an NVIDIA presentation explaining the optimized two phase reduction algorithm on GPU:
- * https://developer.download.nvidia.com/assets/cuda/files/reduction.pdf
- *
- *****************************************************************/
-
-#ifndef UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSOR_REDUCTION_SYCL_HPP
-#define UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSOR_REDUCTION_SYCL_HPP
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace TensorSycl {
-namespace internal {
-
-template <typename Op, typename CoeffReturnType, typename Index, bool Vectorizable>
-struct OpDefiner {
-  typedef typename Vectorise<CoeffReturnType, Eigen::SyclDevice, Vectorizable>::PacketReturnType PacketReturnType;
-  typedef Op type;
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE type get_op(Op &op) { return op; }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType finalise_op(const PacketReturnType &accumulator,
-                                                                            const Index &) {
-    return accumulator;
-  }
-};
-
-template <typename CoeffReturnType, typename Index>
-struct OpDefiner<Eigen::internal::MeanReducer<CoeffReturnType>, CoeffReturnType, Index, false> {
-  typedef Eigen::internal::SumReducer<CoeffReturnType> type;
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE type get_op(Eigen::internal::MeanReducer<CoeffReturnType> &) {
-    return type();
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType finalise_op(const CoeffReturnType &accumulator,
-                                                                           const Index &scale) {
-    ::Eigen::internal::scalar_quotient_op<CoeffReturnType> quotient_op;
-    return quotient_op(accumulator, CoeffReturnType(scale));
-  }
-};
-
-template <typename CoeffReturnType, typename Index>
-struct OpDefiner<Eigen::internal::MeanReducer<CoeffReturnType>, CoeffReturnType, Index, true> {
-  typedef typename Vectorise<CoeffReturnType, Eigen::SyclDevice, true>::PacketReturnType PacketReturnType;
-  typedef Eigen::internal::SumReducer<CoeffReturnType> type;
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE type get_op(Eigen::internal::MeanReducer<CoeffReturnType> &) {
-    return type();
-  }
-
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType finalise_op(const PacketReturnType &accumulator,
-                                                                            const Index &scale) {
-    return ::Eigen::internal::pdiv(accumulator, ::Eigen::internal::pset1<PacketReturnType>(CoeffReturnType(scale)));
-  }
-};
-
-template <typename CoeffReturnType, typename OpType, typename InputAccessor, typename OutputAccessor, typename Index,
-          Index local_range>
-struct SecondStepFullReducer {
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      LocalAccessor;
-  typedef OpDefiner<OpType, CoeffReturnType, Index, true> OpDef;
-  typedef typename OpDef::type Op;
-  LocalAccessor scratch;
-  InputAccessor aI;
-  OutputAccessor outAcc;
-  Op op;
-  SecondStepFullReducer(LocalAccessor scratch_, InputAccessor aI_, OutputAccessor outAcc_, OpType op_)
-      : scratch(scratch_), aI(aI_), outAcc(outAcc_), op(OpDef::get_op(op_)) {}
-
-  void operator()(cl::sycl::nd_item<1> itemID) const {
-    // Our empirical research shows that the best performance will be achieved
-    // when there is only one element per thread to reduce in the second step.
-    // in this step the second step reduction time is almost negligible.
-    // Hence, in the second step of reduction the input size is fixed to the
-    // local size, thus, there is only one element read per thread. The
-    // algorithm must be changed if the number of reduce per thread in the
-    // second step is greater than 1. Otherwise, the result will be wrong.
-    const Index localid = itemID.get_local_id(0);
-    auto aInPtr = aI + localid;
-    auto aOutPtr = outAcc;
-    CoeffReturnType *scratchptr = scratch.get_pointer();
-    CoeffReturnType accumulator = *aInPtr;
-
-    scratchptr[localid] = op.finalize(accumulator);
-    for (Index offset = itemID.get_local_range(0) / 2; offset > 0; offset /= 2) {
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-      if (localid < offset) {
-        op.reduce(scratchptr[localid + offset], &accumulator);
-        scratchptr[localid] = op.finalize(accumulator);
-      }
-    }
-    if (localid == 0) *aOutPtr = op.finalize(accumulator);
-  }
-};
-
-// Full reduction first phase. In this version the vectorization is true and the reduction accept
-// any generic reducerOp  e.g( max, min, sum, mean, iamax, iamin, etc ).
-template <typename Evaluator, typename OpType, typename Evaluator::Index local_range>
-class FullReductionKernelFunctor {
- public:
-  typedef typename Evaluator::CoeffReturnType CoeffReturnType;
-  typedef typename Evaluator::Index Index;
-  typedef OpDefiner<OpType, typename Evaluator::CoeffReturnType, Index,
-                    (Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess)>
-      OpDef;
-
-  typedef typename OpDef::type Op;
-  typedef typename Evaluator::EvaluatorPointerType EvaluatorPointerType;
-  typedef typename Evaluator::PacketReturnType PacketReturnType;
-  typedef std::conditional_t<(Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess), PacketReturnType,
-                             CoeffReturnType>
-      OutType;
-  typedef cl::sycl::accessor<OutType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      LocalAccessor;
-  LocalAccessor scratch;
-  Evaluator evaluator;
-  EvaluatorPointerType final_output;
-  Index rng;
-  Op op;
-
-  FullReductionKernelFunctor(LocalAccessor scratch_, Evaluator evaluator_, EvaluatorPointerType final_output_,
-                             Index rng_, OpType op_)
-      : scratch(scratch_), evaluator(evaluator_), final_output(final_output_), rng(rng_), op(OpDef::get_op(op_)) {}
-
-  void operator()(cl::sycl::nd_item<1> itemID) const { compute_reduction(itemID); }
-
-  template <bool Vect = (Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess)>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<Vect> compute_reduction(
-      const cl::sycl::nd_item<1> &itemID) const {
-    auto output_ptr = final_output;
-    Index VectorizedRange = (rng / Evaluator::PacketSize) * Evaluator::PacketSize;
-    Index globalid = itemID.get_global_id(0);
-    Index localid = itemID.get_local_id(0);
-    Index step = Evaluator::PacketSize * itemID.get_global_range(0);
-    Index start = Evaluator::PacketSize * globalid;
-    // vectorizable parts
-    PacketReturnType packetAccumulator = op.template initializePacket<PacketReturnType>();
-    for (Index i = start; i < VectorizedRange; i += step) {
-      op.template reducePacket<PacketReturnType>(evaluator.impl().template packet<Unaligned>(i), &packetAccumulator);
-    }
-    globalid += VectorizedRange;
-    // non vectorizable parts
-    for (Index i = globalid; i < rng; i += itemID.get_global_range(0)) {
-      op.template reducePacket<PacketReturnType>(
-          ::Eigen::TensorSycl::internal::PacketWrapper<PacketReturnType, Evaluator::PacketSize>::convert_to_packet_type(
-              evaluator.impl().coeff(i), op.initialize()),
-          &packetAccumulator);
-    }
-    scratch[localid] = packetAccumulator =
-        OpDef::finalise_op(op.template finalizePacket<PacketReturnType>(packetAccumulator), rng);
-    // reduction parts // Local size is always power of 2
-    EIGEN_UNROLL_LOOP
-    for (Index offset = local_range / 2; offset > 0; offset /= 2) {
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-      if (localid < offset) {
-        op.template reducePacket<PacketReturnType>(scratch[localid + offset], &packetAccumulator);
-        scratch[localid] = op.template finalizePacket<PacketReturnType>(packetAccumulator);
-      }
-    }
-    if (localid == 0) {
-      output_ptr[itemID.get_group(0)] =
-          op.finalizeBoth(op.initialize(), op.template finalizePacket<PacketReturnType>(packetAccumulator));
-    }
-  }
-
-  template <bool Vect = (Evaluator::ReducerTraits::PacketAccess & Evaluator::InputPacketAccess)>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::enable_if_t<!Vect> compute_reduction(
-      const cl::sycl::nd_item<1> &itemID) const {
-    auto output_ptr = final_output;
-    Index globalid = itemID.get_global_id(0);
-    Index localid = itemID.get_local_id(0);
-    // vectorizable parts
-    CoeffReturnType accumulator = op.initialize();
-    // non vectorizable parts
-    for (Index i = globalid; i < rng; i += itemID.get_global_range(0)) {
-      op.reduce(evaluator.impl().coeff(i), &accumulator);
-    }
-    scratch[localid] = accumulator = OpDef::finalise_op(op.finalize(accumulator), rng);
-
-    // reduction parts. the local size is always power of 2
-    EIGEN_UNROLL_LOOP
-    for (Index offset = local_range / 2; offset > 0; offset /= 2) {
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-      if (localid < offset) {
-        op.reduce(scratch[localid + offset], &accumulator);
-        scratch[localid] = op.finalize(accumulator);
-      }
-    }
-    if (localid == 0) {
-      output_ptr[itemID.get_group(0)] = op.finalize(accumulator);
-    }
-  }
-};
-
-template <typename Evaluator, typename OpType>
-class GenericNondeterministicReducer {
- public:
-  typedef typename Evaluator::CoeffReturnType CoeffReturnType;
-  typedef typename Evaluator::EvaluatorPointerType EvaluatorPointerType;
-  typedef typename Evaluator::Index Index;
-  typedef OpDefiner<OpType, CoeffReturnType, Index, false> OpDef;
-  typedef typename OpDef::type Op;
-  template <typename Scratch>
-  GenericNondeterministicReducer(Scratch, Evaluator evaluator_, EvaluatorPointerType output_accessor_, OpType functor_,
-                                 Index range_, Index num_values_to_reduce_)
-      : evaluator(evaluator_),
-        output_accessor(output_accessor_),
-        functor(OpDef::get_op(functor_)),
-        range(range_),
-        num_values_to_reduce(num_values_to_reduce_) {}
-
-  void operator()(cl::sycl::nd_item<1> itemID) const {
-    // This is to bypass the statefull condition in Eigen meanReducer
-    Op non_const_functor;
-    std::memcpy(&non_const_functor, &functor, sizeof(Op));
-    auto output_accessor_ptr = output_accessor;
-    Index globalid = static_cast<Index>(itemID.get_global_linear_id());
-    if (globalid < range) {
-      CoeffReturnType accum = functor.initialize();
-      Eigen::internal::GenericDimReducer<Evaluator::NumReducedDims - 1, Evaluator, Op>::reduce(
-          evaluator, evaluator.firstInput(globalid), non_const_functor, &accum);
-      output_accessor_ptr[globalid] = OpDef::finalise_op(functor.finalize(accum), num_values_to_reduce);
-    }
-  }
-
- private:
-  Evaluator evaluator;
-  EvaluatorPointerType output_accessor;
-  Op functor;
-  Index range;
-  Index num_values_to_reduce;
-};
-
-enum class reduction_dim { inner_most, outer_most };
-// Default partial reduction (preserve dimensions).
-template <typename Evaluator, typename OpType, typename PannelParameters, reduction_dim rt>
-struct PartialReductionKernel {
-  typedef typename Evaluator::CoeffReturnType CoeffReturnType;
-  typedef typename Evaluator::EvaluatorPointerType EvaluatorPointerType;
-  typedef typename Evaluator::Index Index;
-  typedef OpDefiner<OpType, CoeffReturnType, Index, false> OpDef;
-  typedef typename OpDef::type Op;
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      ScratchAcc;
-  ScratchAcc scratch;
-  Evaluator evaluator;
-  EvaluatorPointerType output_accessor;
-  Op op;
-  const Index preserve_elements_num_groups;
-  const Index reduce_elements_num_groups;
-  const Index num_coeffs_to_preserve;
-  const Index num_coeffs_to_reduce;
-
-  PartialReductionKernel(ScratchAcc scratch_, Evaluator evaluator_, EvaluatorPointerType output_accessor_, OpType op_,
-                         const Index preserve_elements_num_groups_, const Index reduce_elements_num_groups_,
-                         const Index num_coeffs_to_preserve_, const Index num_coeffs_to_reduce_)
-      : scratch(scratch_),
-        evaluator(evaluator_),
-        output_accessor(output_accessor_),
-        op(OpDef::get_op(op_)),
-        preserve_elements_num_groups(preserve_elements_num_groups_),
-        reduce_elements_num_groups(reduce_elements_num_groups_),
-        num_coeffs_to_preserve(num_coeffs_to_preserve_),
-        num_coeffs_to_reduce(num_coeffs_to_reduce_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void element_wise_reduce(Index globalRId, Index globalPId,
-                                                                 CoeffReturnType &accumulator) const {
-    if (globalPId >= num_coeffs_to_preserve) {
-      return;
-    }
-    Index global_offset = rt == reduction_dim::outer_most ? globalPId + (globalRId * num_coeffs_to_preserve)
-                                                          : globalRId + (globalPId * num_coeffs_to_reduce);
-    Index localOffset = globalRId;
-
-    const Index per_thread_local_stride = PannelParameters::LocalThreadSizeR * reduce_elements_num_groups;
-    const Index per_thread_global_stride =
-        rt == reduction_dim::outer_most ? num_coeffs_to_preserve * per_thread_local_stride : per_thread_local_stride;
-    for (Index i = globalRId; i < num_coeffs_to_reduce; i += per_thread_local_stride) {
-      op.reduce(evaluator.impl().coeff(global_offset), &accumulator);
-      localOffset += per_thread_local_stride;
-      global_offset += per_thread_global_stride;
-    }
-  }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
-    const Index linearLocalThreadId = itemID.get_local_id(0);
-    Index pLocalThreadId = rt == reduction_dim::outer_most ? linearLocalThreadId % PannelParameters::LocalThreadSizeP
-                                                           : linearLocalThreadId / PannelParameters::LocalThreadSizeR;
-    Index rLocalThreadId = rt == reduction_dim::outer_most ? linearLocalThreadId / PannelParameters::LocalThreadSizeP
-                                                           : linearLocalThreadId % PannelParameters::LocalThreadSizeR;
-    const Index pGroupId = rt == reduction_dim::outer_most ? itemID.get_group(0) % preserve_elements_num_groups
-                                                           : itemID.get_group(0) / reduce_elements_num_groups;
-    const Index rGroupId = rt == reduction_dim::outer_most ? itemID.get_group(0) / preserve_elements_num_groups
-                                                           : itemID.get_group(0) % reduce_elements_num_groups;
-
-    Index globalPId = pGroupId * PannelParameters::LocalThreadSizeP + pLocalThreadId;
-    const Index globalRId = rGroupId * PannelParameters::LocalThreadSizeR + rLocalThreadId;
-    CoeffReturnType *scratchPtr = scratch.get_pointer();
-    auto outPtr = output_accessor + (reduce_elements_num_groups > 1 ? rGroupId * num_coeffs_to_preserve : 0);
-    CoeffReturnType accumulator = op.initialize();
-
-    element_wise_reduce(globalRId, globalPId, accumulator);
-
-    accumulator = OpDef::finalise_op(op.finalize(accumulator), num_coeffs_to_reduce);
-    scratchPtr[pLocalThreadId + rLocalThreadId * (PannelParameters::LocalThreadSizeP + PannelParameters::BC)] =
-        accumulator;
-    if (rt == reduction_dim::inner_most) {
-      pLocalThreadId = linearLocalThreadId % PannelParameters::LocalThreadSizeP;
-      rLocalThreadId = linearLocalThreadId / PannelParameters::LocalThreadSizeP;
-      globalPId = pGroupId * PannelParameters::LocalThreadSizeP + pLocalThreadId;
-    }
-
-    /* Apply the reduction operation between the current local
-     * id and the one on the other half of the vector. */
-    auto out_scratch_ptr =
-        scratchPtr + (pLocalThreadId + (rLocalThreadId * (PannelParameters::LocalThreadSizeP + PannelParameters::BC)));
-    itemID.barrier(cl::sycl::access::fence_space::local_space);
-    if (rt == reduction_dim::inner_most) {
-      accumulator = *out_scratch_ptr;
-    }
-    // The Local LocalThreadSizeR is always power of 2
-    EIGEN_UNROLL_LOOP
-    for (Index offset = PannelParameters::LocalThreadSizeR >> 1; offset > 0; offset >>= 1) {
-      if (rLocalThreadId < offset) {
-        op.reduce(out_scratch_ptr[(PannelParameters::LocalThreadSizeP + PannelParameters::BC) * offset], &accumulator);
-        // The result has already been divided for mean reducer in the
-        // previous reduction so no need to divide furthermore
-        *out_scratch_ptr = op.finalize(accumulator);
-      }
-      /* All threads collectively read from global memory into local.
-       * The barrier ensures all threads' IO is resolved before
-       * execution continues (strictly speaking, all threads within
-       * a single work-group - there is no co-ordination between
-       * work-groups, only work-items). */
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-    }
-
-    if (rLocalThreadId == 0 && (globalPId < num_coeffs_to_preserve)) {
-      outPtr[globalPId] = op.finalize(accumulator);
-    }
-  }
-};
-
-template <typename OutScalar, typename Index, typename InputAccessor, typename OutputAccessor, typename OpType>
-struct SecondStepPartialReduction {
-  typedef OpDefiner<OpType, OutScalar, Index, false> OpDef;
-  typedef typename OpDef::type Op;
-  typedef cl::sycl::accessor<OutScalar, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      ScratchAccessor;
-  InputAccessor input_accessor;
-  OutputAccessor output_accessor;
-  Op op;
-  const Index num_coeffs_to_preserve;
-  const Index num_coeffs_to_reduce;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE SecondStepPartialReduction(ScratchAccessor, InputAccessor input_accessor_,
-                                                                   OutputAccessor output_accessor_, OpType op_,
-                                                                   const Index num_coeffs_to_preserve_,
-                                                                   const Index num_coeffs_to_reduce_)
-      : input_accessor(input_accessor_),
-        output_accessor(output_accessor_),
-        op(OpDef::get_op(op_)),
-        num_coeffs_to_preserve(num_coeffs_to_preserve_),
-        num_coeffs_to_reduce(num_coeffs_to_reduce_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
-    const Index globalId = itemID.get_global_id(0);
-
-    if (globalId >= num_coeffs_to_preserve) return;
-
-    auto in_ptr = input_accessor + globalId;
-
-    OutScalar accumulator = op.initialize();
-    // num_coeffs_to_reduce is not bigger that 256
-    for (Index i = 0; i < num_coeffs_to_reduce; i++) {
-      op.reduce(*in_ptr, &accumulator);
-      in_ptr += num_coeffs_to_preserve;
-    }
-    output_accessor[globalId] = op.finalize(accumulator);
-  }
-};
-
-template <typename Index, Index LTP, Index LTR, bool BC_>
-struct ReductionPannel {
-  static constexpr Index LocalThreadSizeP = LTP;
-  static constexpr Index LocalThreadSizeR = LTR;
-  static constexpr bool BC = BC_;
-};
-
-template <typename Self, typename Op, TensorSycl::internal::reduction_dim rt>
-struct PartialReducerLauncher {
-  typedef typename Self::EvaluatorPointerType EvaluatorPointerType;
-  typedef typename Self::CoeffReturnType CoeffReturnType;
-  typedef typename Self::Storage Storage;
-  typedef typename Self::Index Index;
-  typedef ReductionPannel<typename Self::Index, EIGEN_SYCL_LOCAL_THREAD_DIM0, EIGEN_SYCL_LOCAL_THREAD_DIM1, true>
-      PannelParameters;
-
-  typedef PartialReductionKernel<Self, Op, PannelParameters, rt> SyclReducerKerneType;
-
-  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev, EvaluatorPointerType output,
-                  Index num_coeffs_to_reduce, Index num_coeffs_to_preserve) {
-    Index roundUpP = roundUp(num_coeffs_to_preserve, PannelParameters::LocalThreadSizeP);
-
-    // getPowerOfTwo makes sure local range is power of 2 and <=
-    // maxSyclThreadPerBlock this will help us to avoid extra check on the
-    // kernel
-    static_assert(!((PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR) &
-                    (PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR - 1)),
-                  "The Local thread size must be a power of 2 for the reduction "
-                  "operation");
-
-    constexpr Index localRange = PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR;
-    // In this step, we force the code not to be more than 2-step reduction:
-    // Our empirical research shows that if each thread reduces at least 64
-    // elements individually, we get better performance. However, this can change
-    // on different platforms. In this step we force the code not to be
-    // morthan step reduction: Our empirical research shows that for inner_most
-    // dim reducer, it is better to have 8 group in a reduce dimension for sizes
-    // > 1024 to achieve the best performance.
-    const Index reductionPerThread = 64;
-    Index cu = dev.getPowerOfTwo(dev.getNumSyclMultiProcessors(), true);
-    const Index pNumGroups = roundUpP / PannelParameters::LocalThreadSizeP;
-    Index rGroups = (cu + pNumGroups - 1) / pNumGroups;
-    const Index rNumGroups = num_coeffs_to_reduce > reductionPerThread * localRange ? std::min(rGroups, localRange) : 1;
-    const Index globalRange = pNumGroups * rNumGroups * localRange;
-
-    constexpr Index scratchSize =
-        PannelParameters::LocalThreadSizeR * (PannelParameters::LocalThreadSizeP + PannelParameters::BC);
-    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(globalRange), cl::sycl::range<1>(localRange));
-    if (rNumGroups > 1) {
-      CoeffReturnType *temp_pointer = static_cast<CoeffReturnType *>(
-          dev.allocate_temp(num_coeffs_to_preserve * rNumGroups * sizeof(CoeffReturnType)));
-      EvaluatorPointerType temp_accessor = dev.get(temp_pointer);
-      dev.template unary_kernel_launcher<CoeffReturnType, SyclReducerKerneType>(
-             self, temp_accessor, thread_range, scratchSize, reducer, pNumGroups, rNumGroups, num_coeffs_to_preserve,
-             num_coeffs_to_reduce)
-          .wait();
-      typedef SecondStepPartialReduction<CoeffReturnType, Index, EvaluatorPointerType, EvaluatorPointerType, Op>
-          SecondStepPartialReductionKernel;
-      dev.template unary_kernel_launcher<CoeffReturnType, SecondStepPartialReductionKernel>(
-             temp_accessor, output,
-             cl::sycl::nd_range<1>(cl::sycl::range<1>(pNumGroups * localRange), cl::sycl::range<1>(localRange)),
-             Index(1), reducer, num_coeffs_to_preserve, rNumGroups)
-          .wait();
-      self.device().deallocate_temp(temp_pointer);
-    } else {
-      dev.template unary_kernel_launcher<CoeffReturnType, SyclReducerKerneType>(
-             self, output, thread_range, scratchSize, reducer, pNumGroups, rNumGroups, num_coeffs_to_preserve,
-             num_coeffs_to_reduce)
-          .wait();
-    }
-    return false;
-  }
-};
-}  // namespace internal
-}  // namespace TensorSycl
-
-namespace internal {
-
-template <typename Self, typename Op, bool Vectorizable>
-struct FullReducer<Self, Op, Eigen::SyclDevice, Vectorizable> {
-  typedef typename Self::CoeffReturnType CoeffReturnType;
-  typedef typename Self::EvaluatorPointerType EvaluatorPointerType;
-  static constexpr bool HasOptimizedImplementation = true;
-  static constexpr int PacketSize = Self::PacketAccess ? Self::PacketSize : 1;
-  static void run(const Self &self, Op &reducer, const Eigen::SyclDevice &dev, EvaluatorPointerType data) {
-    typedef std::conditional_t<Self::PacketAccess, typename Self::PacketReturnType, CoeffReturnType> OutType;
-    static_assert(!((EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1) &
-                    (EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1 - 1)),
-                  "The Local thread size must be a power of 2 for the reduction "
-                  "operation");
-    constexpr Index local_range = EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1;
-
-    typename Self::Index inputSize = self.impl().dimensions().TotalSize();
-    // In this step we force the code not to be more than 2-step reduction:
-    // Our empirical research shows that if each thread reduces at least 512
-    // elements individually, we get better performance.
-    const Index reductionPerThread = 2048;
-    Index reductionGroup = dev.getPowerOfTwo(
-        (inputSize + (reductionPerThread * local_range - 1)) / (reductionPerThread * local_range), true);
-    const Index num_work_group = std::min(reductionGroup, local_range);
-    const Index global_range = num_work_group * local_range;
-
-    auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
-    typedef TensorSycl::internal::FullReductionKernelFunctor<Self, Op, local_range> reduction_kernel_t;
-    if (num_work_group > 1) {
-      CoeffReturnType *temp_pointer =
-          static_cast<CoeffReturnType *>(dev.allocate_temp(num_work_group * sizeof(CoeffReturnType)));
-      typename Self::EvaluatorPointerType tmp_global_accessor = dev.get(temp_pointer);
-      dev.template unary_kernel_launcher<OutType, reduction_kernel_t>(self, tmp_global_accessor, thread_range,
-                                                                      local_range, inputSize, reducer)
-          .wait();
-      typedef TensorSycl::internal::SecondStepFullReducer<CoeffReturnType, Op, EvaluatorPointerType,
-                                                          EvaluatorPointerType, Index, local_range>
-          GenericRKernel;
-      dev.template unary_kernel_launcher<CoeffReturnType, GenericRKernel>(
-             tmp_global_accessor, data,
-             cl::sycl::nd_range<1>(cl::sycl::range<1>(num_work_group), cl::sycl::range<1>(num_work_group)),
-             num_work_group, reducer)
-          .wait();
-      dev.deallocate_temp(temp_pointer);
-    } else {
-      dev.template unary_kernel_launcher<OutType, reduction_kernel_t>(self, data, thread_range, local_range, inputSize,
-                                                                      reducer)
-          .wait();
-    }
-  }
-};
-// vectorizable inner_most most dim preserver
-// col reduction
-template <typename Self, typename Op>
-struct OuterReducer<Self, Op, Eigen::SyclDevice> {
-  static constexpr bool HasOptimizedImplementation = true;
-
-  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev,
-                  typename Self::EvaluatorPointerType output, typename Self::Index num_coeffs_to_reduce,
-                  typename Self::Index num_coeffs_to_preserve) {
-    return ::Eigen::TensorSycl::internal::PartialReducerLauncher<
-        Self, Op, ::Eigen::TensorSycl::internal::reduction_dim::outer_most>::run(self, reducer, dev, output,
-                                                                                 num_coeffs_to_reduce,
-                                                                                 num_coeffs_to_preserve);
-  }
-};
-// row reduction
-template <typename Self, typename Op>
-struct InnerReducer<Self, Op, Eigen::SyclDevice> {
-  static constexpr bool HasOptimizedImplementation = true;
-
-  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev,
-                  typename Self::EvaluatorPointerType output, typename Self::Index num_coeffs_to_reduce,
-                  typename Self::Index num_coeffs_to_preserve) {
-    return ::Eigen::TensorSycl::internal::PartialReducerLauncher<
-        Self, Op, ::Eigen::TensorSycl::internal::reduction_dim::inner_most>::run(self, reducer, dev, output,
-                                                                                 num_coeffs_to_reduce,
-                                                                                 num_coeffs_to_preserve);
-  }
-};
-
-// ArgMax uses this kernel for partial reduction.
-// TODO(@mehdi.goli): Come up with a better kernel.
-// generic partial reduction
-template <typename Self, typename Op>
-struct GenericReducer<Self, Op, Eigen::SyclDevice> {
-  static constexpr bool HasOptimizedImplementation = false;
-  static bool run(const Self &self, const Op &reducer, const Eigen::SyclDevice &dev,
-                  typename Self::EvaluatorPointerType output, typename Self::Index num_values_to_reduce,
-                  typename Self::Index num_coeffs_to_preserve) {
-    typename Self::Index range, GRange, tileSize;
-    dev.parallel_for_setup(num_coeffs_to_preserve, tileSize, range, GRange);
-
-    dev.template unary_kernel_launcher<typename Self::CoeffReturnType,
-                                       TensorSycl::internal::GenericNondeterministicReducer<Self, Op>>(
-           self, output, cl::sycl::nd_range<1>(cl::sycl::range<1>(GRange), cl::sycl::range<1>(tileSize)), Index(1),
-           reducer, range, (num_values_to_reduce != 0) ? num_values_to_reduce : static_cast<Index>(1))
-        .wait();
-    return false;
-  }
-};
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSOR_REDUCTION_SYCL_HPP
diff --git a/unsupported/Eigen/src/Tensor/TensorRef.h b/unsupported/Eigen/src/Tensor/TensorRef.h
deleted file mode 100644
index d0df443..0000000
--- a/unsupported/Eigen/src/Tensor/TensorRef.h
+++ /dev/null
@@ -1,390 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_REF_H
-#define EIGEN_CXX11_TENSOR_TENSOR_REF_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Dimensions, typename Scalar>
-class TensorLazyBaseEvaluator {
- public:
-  TensorLazyBaseEvaluator() : m_refcount(0) {}
-  virtual ~TensorLazyBaseEvaluator() {}
-
-  EIGEN_DEVICE_FUNC virtual const Dimensions& dimensions() const = 0;
-  EIGEN_DEVICE_FUNC virtual const Scalar* data() const = 0;
-
-  EIGEN_DEVICE_FUNC virtual const Scalar coeff(DenseIndex index) const = 0;
-  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex index) = 0;
-
-  void incrRefCount() { ++m_refcount; }
-  void decrRefCount() { --m_refcount; }
-  int refCount() const { return m_refcount; }
-
- private:
-  // No copy, no assignment;
-  TensorLazyBaseEvaluator(const TensorLazyBaseEvaluator& other);
-  TensorLazyBaseEvaluator& operator=(const TensorLazyBaseEvaluator& other);
-
-  int m_refcount;
-};
-
-template <typename Dimensions, typename Expr, typename Device>
-class TensorLazyEvaluatorReadOnly
-    : public TensorLazyBaseEvaluator<Dimensions, typename TensorEvaluator<Expr, Device>::Scalar> {
- public:
-  typedef typename TensorEvaluator<Expr, Device>::Scalar Scalar;
-  typedef StorageMemory<Scalar, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-  typedef TensorEvaluator<Expr, Device> EvalType;
-
-  TensorLazyEvaluatorReadOnly(const Expr& expr, const Device& device) : m_impl(expr, device), m_dummy(Scalar(0)) {
-    EIGEN_STATIC_ASSERT(
-        internal::array_size<Dimensions>::value == internal::array_size<typename EvalType::Dimensions>::value,
-        "Dimension sizes must match.");
-    const auto& other_dims = m_impl.dimensions();
-    for (std::size_t i = 0; i < m_dims.size(); ++i) {
-      m_dims[i] = other_dims[i];
-    }
-    m_impl.evalSubExprsIfNeeded(NULL);
-  }
-  virtual ~TensorLazyEvaluatorReadOnly() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC virtual const Dimensions& dimensions() const { return m_dims; }
-  EIGEN_DEVICE_FUNC virtual const Scalar* data() const { return m_impl.data(); }
-
-  EIGEN_DEVICE_FUNC virtual const Scalar coeff(DenseIndex index) const { return m_impl.coeff(index); }
-  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex /*index*/) {
-    eigen_assert(false && "can't reference the coefficient of a rvalue");
-    return m_dummy;
-  };
-
- protected:
-  TensorEvaluator<Expr, Device> m_impl;
-  Dimensions m_dims;
-  Scalar m_dummy;
-};
-
-template <typename Dimensions, typename Expr, typename Device>
-class TensorLazyEvaluatorWritable : public TensorLazyEvaluatorReadOnly<Dimensions, Expr, Device> {
- public:
-  typedef TensorLazyEvaluatorReadOnly<Dimensions, Expr, Device> Base;
-  typedef typename Base::Scalar Scalar;
-  typedef StorageMemory<Scalar, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  TensorLazyEvaluatorWritable(const Expr& expr, const Device& device) : Base(expr, device) {}
-  virtual ~TensorLazyEvaluatorWritable() {}
-
-  EIGEN_DEVICE_FUNC virtual Scalar& coeffRef(DenseIndex index) { return this->m_impl.coeffRef(index); }
-};
-
-template <typename Dimensions, typename Expr, typename Device, bool IsWritable>
-class TensorLazyEvaluator : public std::conditional_t<IsWritable, TensorLazyEvaluatorWritable<Dimensions, Expr, Device>,
-                                                      TensorLazyEvaluatorReadOnly<Dimensions, const Expr, Device>> {
- public:
-  typedef std::conditional_t<IsWritable, TensorLazyEvaluatorWritable<Dimensions, Expr, Device>,
-                             TensorLazyEvaluatorReadOnly<Dimensions, const Expr, Device>>
-      Base;
-  typedef typename Base::Scalar Scalar;
-
-  TensorLazyEvaluator(const Expr& expr, const Device& device) : Base(expr, device) {}
-  virtual ~TensorLazyEvaluator() {}
-};
-
-template <typename Derived>
-class TensorRefBase : public TensorBase<Derived> {
- public:
-  typedef typename traits<Derived>::PlainObjectType PlainObjectType;
-  typedef typename PlainObjectType::Base Base;
-  typedef typename Eigen::internal::nested<Derived>::type Nested;
-  typedef typename traits<PlainObjectType>::StorageKind StorageKind;
-  typedef typename traits<PlainObjectType>::Index Index;
-  typedef typename traits<PlainObjectType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef typename Base::CoeffReturnType CoeffReturnType;
-  typedef Scalar* PointerType;
-  typedef PointerType PointerArgType;
-
-  static constexpr Index NumIndices = PlainObjectType::NumIndices;
-  typedef typename PlainObjectType::Dimensions Dimensions;
-
-  static constexpr int Layout = PlainObjectType::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -----------===//
-  typedef TensorBlockNotImplemented TensorBlock;
-  //===------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorRefBase() : m_evaluator(NULL) {}
-
-  TensorRefBase(const TensorRefBase& other) : TensorBase<Derived>(other), m_evaluator(other.m_evaluator) {
-    eigen_assert(m_evaluator->refCount() > 0);
-    m_evaluator->incrRefCount();
-  }
-
-  TensorRefBase& operator=(const TensorRefBase& other) {
-    if (this != &other) {
-      unrefEvaluator();
-      m_evaluator = other.m_evaluator;
-      eigen_assert(m_evaluator->refCount() > 0);
-      m_evaluator->incrRefCount();
-    }
-    return *this;
-  }
-
-  template <typename Expression,
-            typename EnableIf = std::enable_if_t<!std::is_same<std::decay_t<Expression>, Derived>::value>>
-  EIGEN_STRONG_INLINE TensorRefBase(const Expression& expr)
-      : m_evaluator(new TensorLazyEvaluator<Dimensions, Expression, DefaultDevice,
-                                            /*IsWritable=*/!std::is_const<PlainObjectType>::value &&
-                                                bool(is_lvalue<Expression>::value)>(expr, DefaultDevice())) {
-    m_evaluator->incrRefCount();
-  }
-
-  template <typename Expression,
-            typename EnableIf = std::enable_if_t<!std::is_same<std::decay_t<Expression>, Derived>::value>>
-  EIGEN_STRONG_INLINE TensorRefBase& operator=(const Expression& expr) {
-    unrefEvaluator();
-    m_evaluator = new TensorLazyEvaluator < Dimensions, Expression, DefaultDevice,
-    /*IsWritable=*/!std::is_const<PlainObjectType>::value&& bool(is_lvalue<Expression>::value) >
-        (expr, DefaultDevice());
-    m_evaluator->incrRefCount();
-    return *this;
-  }
-
-  ~TensorRefBase() { unrefEvaluator(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rank() const { return m_evaluator->dimensions().size(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index dimension(Index n) const { return m_evaluator->dimensions()[n]; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_evaluator->dimensions(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_evaluator->dimensions().TotalSize(); }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar* data() const { return m_evaluator->data(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index index) const { return m_evaluator->coeff(index); }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index firstIndex, IndexTypes... otherIndices) const {
-    const std::size_t num_indices = (sizeof...(otherIndices) + 1);
-    const array<Index, num_indices> indices{{firstIndex, otherIndices...}};
-    return coeff(indices);
-  }
-
-  template <std::size_t NumIndices>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(const array<Index, NumIndices>& indices) const {
-    const Dimensions& dims = this->dimensions();
-    Index index = 0;
-    if (PlainObjectType::Options & RowMajor) {
-      index += indices[0];
-      for (size_t i = 1; i < NumIndices; ++i) {
-        index = index * dims[i] + indices[i];
-      }
-    } else {
-      index += indices[NumIndices - 1];
-      for (int i = NumIndices - 2; i >= 0; --i) {
-        index = index * dims[i] + indices[i];
-      }
-    }
-    return m_evaluator->coeff(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(Index index) const { return m_evaluator->coeff(index); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_evaluator->coeffRef(index); }
-
- protected:
-  TensorLazyBaseEvaluator<Dimensions, Scalar>* evaluator() { return m_evaluator; }
-
- private:
-  EIGEN_STRONG_INLINE void unrefEvaluator() {
-    if (m_evaluator) {
-      m_evaluator->decrRefCount();
-      if (m_evaluator->refCount() == 0) {
-        delete m_evaluator;
-      }
-    }
-  }
-
-  TensorLazyBaseEvaluator<Dimensions, Scalar>* m_evaluator;
-};
-
-}  // namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief A reference to a tensor expression
- * The expression will be evaluated lazily (as much as possible).
- *
- */
-template <typename PlainObjectType>
-class TensorRef : public internal::TensorRefBase<TensorRef<PlainObjectType>> {
-  typedef internal::TensorRefBase<TensorRef<PlainObjectType>> Base;
-
- public:
-  using Scalar = typename Base::Scalar;
-  using Dimensions = typename Base::Dimensions;
-
-  EIGEN_STRONG_INLINE TensorRef() : Base() {}
-
-  EIGEN_STRONG_INLINE TensorRef(const TensorRef& other) : Base(other) {}
-
-  template <typename Expression>
-  EIGEN_STRONG_INLINE TensorRef(const Expression& expr) : Base(expr) {
-    EIGEN_STATIC_ASSERT(internal::is_lvalue<Expression>::value,
-                        "Expression must be mutable to create a mutable TensorRef<Expression>.  Did you mean "
-                        "TensorRef<const Expression>?)");
-  }
-
-  TensorRef& operator=(const TensorRef& other) { return Base::operator=(other).derived(); }
-
-  template <typename Expression>
-  EIGEN_STRONG_INLINE TensorRef& operator=(const Expression& expr) {
-    EIGEN_STATIC_ASSERT(internal::is_lvalue<Expression>::value,
-                        "Expression must be mutable to create a mutable TensorRef<Expression>.  Did you mean "
-                        "TensorRef<const Expression>?)");
-    return Base::operator=(expr).derived();
-  }
-
-  template <typename... IndexTypes>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices) {
-    const std::size_t num_indices = (sizeof...(otherIndices) + 1);
-    const array<Index, num_indices> indices{{firstIndex, otherIndices...}};
-    return coeffRef(indices);
-  }
-
-  template <std::size_t NumIndices>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) {
-    const Dimensions& dims = this->dimensions();
-    Index index = 0;
-    if (PlainObjectType::Options & RowMajor) {
-      index += indices[0];
-      for (size_t i = 1; i < NumIndices; ++i) {
-        index = index * dims[i] + indices[i];
-      }
-    } else {
-      index += indices[NumIndices - 1];
-      for (int i = NumIndices - 2; i >= 0; --i) {
-        index = index * dims[i] + indices[i];
-      }
-    }
-    return Base::evaluator()->coeffRef(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return Base::evaluator()->coeffRef(index); }
-};
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief A reference to a constant tensor expression
- * The expression will be evaluated lazily (as much as possible).
- *
- */
-template <typename PlainObjectType>
-class TensorRef<const PlainObjectType> : public internal::TensorRefBase<TensorRef<const PlainObjectType>> {
-  typedef internal::TensorRefBase<TensorRef<const PlainObjectType>> Base;
-
- public:
-  EIGEN_STRONG_INLINE TensorRef() : Base() {}
-
-  EIGEN_STRONG_INLINE TensorRef(const TensorRef& other) : Base(other) {}
-
-  template <typename Expression>
-  EIGEN_STRONG_INLINE TensorRef(const Expression& expr) : Base(expr) {}
-
-  TensorRef& operator=(const TensorRef& other) { return Base::operator=(other).derived(); }
-
-  template <typename Expression>
-  EIGEN_STRONG_INLINE TensorRef& operator=(const Expression& expr) {
-    return Base::operator=(expr).derived();
-  }
-};
-
-// evaluator for rvalues
-template <typename Derived, typename Device>
-struct TensorEvaluator<const TensorRef<Derived>, Device> {
-  typedef typename Derived::Index Index;
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename Derived::Dimensions Dimensions;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorRef<Derived>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = false,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const TensorRef<Derived>& m, const Device&) : m_ref(m) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_ref.dimensions(); }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) { return true; }
-
-  EIGEN_STRONG_INLINE void cleanup() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_ref.coeff(index); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_ref.coeffRef(index); }
-
-  EIGEN_DEVICE_FUNC const Scalar* data() const { return m_ref.data(); }
-
- protected:
-  TensorRef<Derived> m_ref;
-};
-
-// evaluator for lvalues
-template <typename Derived, typename Device>
-struct TensorEvaluator<TensorRef<Derived>, Device> : public TensorEvaluator<const TensorRef<Derived>, Device> {
-  typedef typename Derived::Index Index;
-  typedef typename Derived::Scalar Scalar;
-  typedef typename Derived::Scalar CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef typename Derived::Dimensions Dimensions;
-
-  typedef TensorEvaluator<const TensorRef<Derived>, Device> Base;
-
-  enum { IsAligned = false, PacketAccess = false, BlockAccess = false, PreferBlockAccess = false, RawAccess = false };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(TensorRef<Derived>& m, const Device& d) : Base(m, d) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return this->m_ref.coeffRef(index); }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_REF_H
diff --git a/unsupported/Eigen/src/Tensor/TensorReverse.h b/unsupported/Eigen/src/Tensor/TensorReverse.h
deleted file mode 100644
index ece85ca..0000000
--- a/unsupported/Eigen/src/Tensor/TensorReverse.h
+++ /dev/null
@@ -1,406 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Navdeep Jaitly <ndjaitly@google.com>
-//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_REVERSE_H
-#define EIGEN_CXX11_TENSOR_TENSOR_REVERSE_H
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename ReverseDimensions, typename XprType>
-struct traits<TensorReverseOp<ReverseDimensions, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename ReverseDimensions, typename XprType>
-struct eval<TensorReverseOp<ReverseDimensions, XprType>, Eigen::Dense> {
-  typedef const TensorReverseOp<ReverseDimensions, XprType>& type;
-};
-
-template <typename ReverseDimensions, typename XprType>
-struct nested<TensorReverseOp<ReverseDimensions, XprType>, 1,
-              typename eval<TensorReverseOp<ReverseDimensions, XprType> >::type> {
-  typedef TensorReverseOp<ReverseDimensions, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor reverse elements class.
- *
- */
-template <typename ReverseDimensions, typename XprType>
-class TensorReverseOp : public TensorBase<TensorReverseOp<ReverseDimensions, XprType>, WriteAccessors> {
- public:
-  typedef TensorBase<TensorReverseOp<ReverseDimensions, XprType>, WriteAccessors> Base;
-  typedef typename Eigen::internal::traits<TensorReverseOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorReverseOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorReverseOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorReverseOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorReverseOp(const XprType& expr, const ReverseDimensions& reverse_dims)
-      : m_xpr(expr), m_reverse_dims(reverse_dims) {}
-
-  EIGEN_DEVICE_FUNC const ReverseDimensions& reverse() const { return m_reverse_dims; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorReverseOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const ReverseDimensions m_reverse_dims;
-};
-
-// Eval as rvalue
-template <typename ReverseDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device> {
-  typedef TensorReverseOp<ReverseDimensions, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<ReverseDimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = NumDims > 0,
-    PreferBlockAccess = true,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  typedef internal::TensorIntDivisor<Index> IndexDivisor;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename TensorEvaluator<const ArgType, Device>::TensorBlock ArgTensorBlock;
-
-  typedef typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_reverse(op.reverse()), m_device(device) {
-    // Reversing a scalar isn't supported yet. It would be a no-op anyway.
-    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    // Compute strides
-    m_dimensions = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_strides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
-        if (m_strides[i] > 0) m_fastStrides[i] = IndexDivisor(m_strides[i]);
-      }
-    } else {
-      m_strides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
-        if (m_strides[i] > 0) m_fastStrides[i] = IndexDivisor(m_strides[i]);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index reverseIndex(Index index) const {
-    eigen_assert(index < dimensions().TotalSize());
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        Index idx = index / m_fastStrides[i];
-        index -= idx * m_strides[i];
-        if (m_reverse[i]) {
-          idx = m_dimensions[i] - idx - 1;
-        }
-        inputIndex += idx * m_strides[i];
-      }
-      if (m_reverse[0]) {
-        inputIndex += (m_dimensions[0] - index - 1);
-      } else {
-        inputIndex += index;
-      }
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        Index idx = index / m_fastStrides[i];
-        index -= idx * m_strides[i];
-        if (m_reverse[i]) {
-          idx = m_dimensions[i] - idx - 1;
-        }
-        inputIndex += idx * m_strides[i];
-      }
-      if (m_reverse[NumDims - 1]) {
-        inputIndex += (m_dimensions[NumDims - 1] - index - 1);
-      } else {
-        inputIndex += index;
-      }
-    }
-    return inputIndex;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    return m_impl.coeff(reverseIndex(index));
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    // TODO(ndjaitly): write a better packing routine that uses
-    // local structure.
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.lastLevelCacheSize();
-    // Block evaluation reads underlying memory in reverse order, and default
-    // cost model does not properly catch this in bytes stored/loaded.
-    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size).addCostPerCoeff({0, 0, 24});
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    // TODO(ezhulenev): If underlying tensor expression supports and prefers
-    // block evaluation we must use it. Currently we use coeff and packet
-    // access into the underlying tensor expression.
-    static const bool isColMajor = static_cast<int>(Layout) == static_cast<int>(ColMajor);
-
-    static const Index inner_dim_idx = isColMajor ? 0 : NumDims - 1;
-    const bool inner_dim_reversed = m_reverse[inner_dim_idx];
-
-    // Offset in the output block.
-    Index block_offset = 0;
-
-    // Offset in the input Tensor.
-    Index input_offset = reverseIndex(desc.offset());
-
-    // Initialize output block iterator state. Dimension in this array are
-    // always in inner_most -> outer_most order (col major layout).
-    array<BlockIteratorState, NumDims> it;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = isColMajor ? i : NumDims - 1 - i;
-      it[i].size = desc.dimension(dim);
-      it[i].count = 0;
-      it[i].reverse = m_reverse[dim];
-
-      it[i].block_stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].block_stride);
-      it[i].block_span = it[i].block_stride * (it[i].size - 1);
-
-      it[i].input_stride = m_strides[dim];
-      it[i].input_span = it[i].input_stride * (it[i].size - 1);
-
-      if (it[i].reverse) {
-        it[i].input_stride = -1 * it[i].input_stride;
-        it[i].input_span = -1 * it[i].input_span;
-      }
-    }
-
-    // If multiple inner dimensions have the same reverse flag, check if we can
-    // merge them into a single virtual inner dimension.
-    int effective_inner_dim = 0;
-    for (int i = 1; i < NumDims; ++i) {
-      if (it[i].reverse != it[effective_inner_dim].reverse) break;
-      if (it[i].block_stride != it[effective_inner_dim].size) break;
-      if (it[i].block_stride != numext::abs(it[i].input_stride)) break;
-
-      it[i].size = it[effective_inner_dim].size * it[i].size;
-
-      it[i].block_stride = 1;
-      it[i].input_stride = (inner_dim_reversed ? -1 : 1);
-
-      it[i].block_span = it[i].block_stride * (it[i].size - 1);
-      it[i].input_span = it[i].input_stride * (it[i].size - 1);
-
-      effective_inner_dim = i;
-    }
-
-    eigen_assert(it[effective_inner_dim].block_stride == 1);
-    eigen_assert(it[effective_inner_dim].input_stride == (inner_dim_reversed ? -1 : 1));
-
-    const Index inner_dim_size = it[effective_inner_dim].size;
-
-    // Prepare storage for the materialized reverse result.
-    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
-    CoeffReturnType* block_buffer = block_storage.data();
-
-    while (it[NumDims - 1].count < it[NumDims - 1].size) {
-      // Copy inner-most dimension data from reversed location in input.
-      Index dst = block_offset;
-      Index src = input_offset;
-
-      // NOTE(ezhulenev): Adding vectorized path with internal::preverse showed
-      // worse results in benchmarks than a simple coefficient loop.
-      if (inner_dim_reversed) {
-        for (Index i = 0; i < inner_dim_size; ++i) {
-          block_buffer[dst] = m_impl.coeff(src);
-          ++dst;
-          --src;
-        }
-      } else {
-        for (Index i = 0; i < inner_dim_size; ++i) {
-          block_buffer[dst] = m_impl.coeff(src);
-          ++dst;
-          ++src;
-        }
-      }
-
-      // For the 1d tensor we need to generate only one inner-most dimension.
-      if ((NumDims - effective_inner_dim) == 1) break;
-
-      // Update offset.
-      for (Index i = effective_inner_dim + 1; i < NumDims; ++i) {
-        if (++it[i].count < it[i].size) {
-          block_offset += it[i].block_stride;
-          input_offset += it[i].input_stride;
-          break;
-        }
-        if (i != NumDims - 1) it[i].count = 0;
-        block_offset -= it[i].block_span;
-        input_offset -= it[i].input_span;
-      }
-    }
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
-                                     TensorOpCost::DivCost<Index>());
-    for (int i = 0; i < NumDims; ++i) {
-      if (m_reverse[i]) {
-        compute_cost += 2 * TensorOpCost::AddCost<Index>();
-      }
-    }
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, false /* vectorized */, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return NULL; }
-
- protected:
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_strides;
-  array<IndexDivisor, NumDims> m_fastStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  ReverseDimensions m_reverse;
-  const Device EIGEN_DEVICE_REF m_device;
-
- private:
-  struct BlockIteratorState {
-    BlockIteratorState()
-        : size(0), count(0), reverse(false), block_stride(0), block_span(0), input_stride(0), input_span(0) {}
-
-    Index size;
-    Index count;
-    bool reverse;
-    Index block_stride;
-    Index block_span;
-    Index input_stride;
-    Index input_span;
-  };
-};
-
-// Eval as lvalue
-
-template <typename ReverseDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<TensorReverseOp<ReverseDimensions, ArgType>, Device>
-    : public TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorReverseOp<ReverseDimensions, ArgType>, Device> Base;
-  typedef TensorReverseOp<ReverseDimensions, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<ReverseDimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return this->m_dimensions; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(this->reverseIndex(index));
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    // This code is adapted from TensorMorphing.h
-    EIGEN_ALIGN_MAX CoeffReturnType values[PacketSize];
-    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      this->coeffRef(index + i) = values[i];
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_REVERSE_H
diff --git a/unsupported/Eigen/src/Tensor/TensorRoll.h b/unsupported/Eigen/src/Tensor/TensorRoll.h
deleted file mode 100644
index e4b5181..0000000
--- a/unsupported/Eigen/src/Tensor/TensorRoll.h
+++ /dev/null
@@ -1,361 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2024 Tobias Wood tobias@spinicist.org.uk
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_ROLL_H
-#define EIGEN_CXX11_TENSOR_TENSOR_ROLL_H
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename RollDimensions, typename XprType>
-struct traits<TensorRollOp<RollDimensions, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename RollDimensions, typename XprType>
-struct eval<TensorRollOp<RollDimensions, XprType>, Eigen::Dense> {
-  typedef const TensorRollOp<RollDimensions, XprType>& type;
-};
-
-template <typename RollDimensions, typename XprType>
-struct nested<TensorRollOp<RollDimensions, XprType>, 1, typename eval<TensorRollOp<RollDimensions, XprType> >::type> {
-  typedef TensorRollOp<RollDimensions, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor roll (circular shift) elements class.
- *
- */
-template <typename RollDimensions, typename XprType>
-class TensorRollOp : public TensorBase<TensorRollOp<RollDimensions, XprType>, WriteAccessors> {
- public:
-  typedef TensorBase<TensorRollOp<RollDimensions, XprType>, WriteAccessors> Base;
-  typedef typename Eigen::internal::traits<TensorRollOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorRollOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorRollOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorRollOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorRollOp(const XprType& expr, const RollDimensions& roll_dims)
-      : m_xpr(expr), m_roll_dims(roll_dims) {}
-
-  EIGEN_DEVICE_FUNC const RollDimensions& roll() const { return m_roll_dims; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorRollOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const RollDimensions m_roll_dims;
-};
-
-// Eval as rvalue
-template <typename RollDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorRollOp<RollDimensions, ArgType>, Device> {
-  typedef TensorRollOp<RollDimensions, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<RollDimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = NumDims > 0,
-    PreferBlockAccess = true,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  typedef internal::TensorIntDivisor<Index> IndexDivisor;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  using TensorBlockDesc = internal::TensorBlockDescriptor<NumDims, Index>;
-  using TensorBlockScratch = internal::TensorBlockScratchAllocator<Device>;
-  using ArgTensorBlock = typename TensorEvaluator<const ArgType, Device>::TensorBlock;
-  using TensorBlock = typename internal::TensorMaterializedBlock<CoeffReturnType, NumDims, Layout, Index>;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_rolls(op.roll()), m_device(device) {
-    EIGEN_STATIC_ASSERT((NumDims > 0), Must_Have_At_Least_One_Dimension_To_Roll);
-
-    // Compute strides
-    m_dimensions = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_strides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_strides[i] = m_strides[i - 1] * m_dimensions[i - 1];
-        if (m_strides[i] > 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
-      }
-    } else {
-      m_strides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_strides[i] = m_strides[i + 1] * m_dimensions[i + 1];
-        if (m_strides[i] > 0) m_fast_strides[i] = IndexDivisor(m_strides[i]);
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType) {
-    m_impl.evalSubExprsIfNeeded(nullptr);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index roll(Index const i, Index const r, Index const n) const {
-    auto const tmp = (i + r) % n;
-    if (tmp < 0) {
-      return tmp + n;
-    } else {
-      return tmp;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array<Index, NumDims> rollCoords(array<Index, NumDims> const& coords) const {
-    array<Index, NumDims> rolledCoords;
-    for (int id = 0; id < NumDims; id++) {
-      eigen_assert(coords[id] < m_dimensions[id]);
-      rolledCoords[id] = roll(coords[id], m_rolls[id], m_dimensions[id]);
-    }
-    return rolledCoords;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rollIndex(Index index) const {
-    eigen_assert(index < dimensions().TotalSize());
-    Index rolledIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        rolledIndex += roll(idx, m_rolls[i], m_dimensions[i]) * m_strides[i];
-      }
-      rolledIndex += roll(index, m_rolls[0], m_dimensions[0]);
-    } else {
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        rolledIndex += roll(idx, m_rolls[i], m_dimensions[i]) * m_strides[i];
-      }
-      rolledIndex += roll(index, m_rolls[NumDims - 1], m_dimensions[NumDims - 1]);
-    }
-    return rolledIndex;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    return m_impl.coeff(rollIndex(index));
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    const size_t target_size = m_device.lastLevelCacheSize();
-    return internal::TensorBlockResourceRequirements::skewed<Scalar>(target_size).addCostPerCoeff({0, 0, 24});
-  }
-
-  struct BlockIteratorState {
-    Index stride;
-    Index span;
-    Index size;
-    Index count;
-  };
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool /*root_of_expr_ast*/ = false) const {
-    static const bool is_col_major = static_cast<int>(Layout) == static_cast<int>(ColMajor);
-
-    // Compute spatial coordinates for the first block element.
-    array<Index, NumDims> coords;
-    extract_coordinates(desc.offset(), coords);
-    array<Index, NumDims> initial_coords = coords;
-    Index offset = 0;  // Offset in the output block buffer.
-
-    // Initialize output block iterator state. Dimension in this array are
-    // always in inner_most -> outer_most order (col major layout).
-    array<BlockIteratorState, NumDims> it;
-    for (int i = 0; i < NumDims; ++i) {
-      const int dim = is_col_major ? i : NumDims - 1 - i;
-      it[i].size = desc.dimension(dim);
-      it[i].stride = i == 0 ? 1 : (it[i - 1].size * it[i - 1].stride);
-      it[i].span = it[i].stride * (it[i].size - 1);
-      it[i].count = 0;
-    }
-    eigen_assert(it[0].stride == 1);
-
-    // Prepare storage for the materialized generator result.
-    const typename TensorBlock::Storage block_storage = TensorBlock::prepareStorage(desc, scratch);
-    CoeffReturnType* block_buffer = block_storage.data();
-
-    static const int inner_dim = is_col_major ? 0 : NumDims - 1;
-    const Index inner_dim_size = it[0].size;
-
-    while (it[NumDims - 1].count < it[NumDims - 1].size) {
-      Index i = 0;
-      for (; i < inner_dim_size; ++i) {
-        auto const rolled = rollCoords(coords);
-        auto const index = is_col_major ? m_dimensions.IndexOfColMajor(rolled) : m_dimensions.IndexOfRowMajor(rolled);
-        *(block_buffer + offset + i) = m_impl.coeff(index);
-        coords[inner_dim]++;
-      }
-      coords[inner_dim] = initial_coords[inner_dim];
-
-      if (NumDims == 1) break;  // For the 1d tensor we need to generate only one inner-most dimension.
-
-      // Update offset.
-      for (i = 1; i < NumDims; ++i) {
-        if (++it[i].count < it[i].size) {
-          offset += it[i].stride;
-          coords[is_col_major ? i : NumDims - 1 - i]++;
-          break;
-        }
-        if (i != NumDims - 1) it[i].count = 0;
-        coords[is_col_major ? i : NumDims - 1 - i] = initial_coords[is_col_major ? i : NumDims - 1 - i];
-        offset -= it[i].span;
-      }
-    }
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    double compute_cost = NumDims * (2 * TensorOpCost::AddCost<Index>() + 2 * TensorOpCost::MulCost<Index>() +
-                                     TensorOpCost::DivCost<Index>());
-    for (int i = 0; i < NumDims; ++i) {
-      compute_cost += 2 * TensorOpCost::AddCost<Index>();
-    }
-    return m_impl.costPerCoeff(vectorized) + TensorOpCost(0, 0, compute_cost, false /* vectorized */, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return nullptr; }
-
- protected:
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_strides;
-  array<IndexDivisor, NumDims> m_fast_strides;
-  TensorEvaluator<ArgType, Device> m_impl;
-  RollDimensions m_rolls;
-  const Device EIGEN_DEVICE_REF m_device;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void extract_coordinates(Index index, array<Index, NumDims>& coords) const {
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        coords[i] = idx;
-      }
-      coords[0] = index;
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_fast_strides[i];
-        index -= idx * m_strides[i];
-        coords[i] = idx;
-      }
-      coords[NumDims - 1] = index;
-    }
-  }
-
- private:
-};
-
-// Eval as lvalue
-
-template <typename RollDimensions, typename ArgType, typename Device>
-struct TensorEvaluator<TensorRollOp<RollDimensions, ArgType>, Device>
-    : public TensorEvaluator<const TensorRollOp<RollDimensions, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorRollOp<RollDimensions, ArgType>, Device> Base;
-  typedef TensorRollOp<RollDimensions, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<RollDimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,
-    RawAccess = false
-  };
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return this->m_dimensions; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(this->rollIndex(index));
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-    EIGEN_ALIGN_MAX CoeffReturnType values[PacketSize];
-    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      this->coeffRef(index + i) = values[i];
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_ROLL_H
diff --git a/unsupported/Eigen/src/Tensor/TensorScan.h b/unsupported/Eigen/src/Tensor/TensorScan.h
deleted file mode 100644
index f3e5bd4..0000000
--- a/unsupported/Eigen/src/Tensor/TensorScan.h
+++ /dev/null
@@ -1,474 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Igor Babuschkin <igor@babuschk.in>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_SCAN_H
-#define EIGEN_CXX11_TENSOR_TENSOR_SCAN_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename Op, typename XprType>
-struct traits<TensorScanOp<Op, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename Op, typename XprType>
-struct eval<TensorScanOp<Op, XprType>, Eigen::Dense> {
-  typedef const TensorScanOp<Op, XprType>& type;
-};
-
-template <typename Op, typename XprType>
-struct nested<TensorScanOp<Op, XprType>, 1, typename eval<TensorScanOp<Op, XprType> >::type> {
-  typedef TensorScanOp<Op, XprType> type;
-};
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor scan class.
- */
-template <typename Op, typename XprType>
-class TensorScanOp : public TensorBase<TensorScanOp<Op, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorScanOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorScanOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorScanOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorScanOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorScanOp(const XprType& expr, const Index& axis, bool exclusive = false,
-                                                     const Op& op = Op())
-      : m_expr(expr), m_axis(axis), m_accumulator(op), m_exclusive(exclusive) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index axis() const { return m_axis; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const XprType& expression() const { return m_expr; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Op accumulator() const { return m_accumulator; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool exclusive() const { return m_exclusive; }
-
- protected:
-  typename XprType::Nested m_expr;
-  const Index m_axis;
-  const Op m_accumulator;
-  const bool m_exclusive;
-};
-
-namespace internal {
-
-template <typename Self>
-EIGEN_STRONG_INLINE void ReduceScalar(Self& self, Index offset, typename Self::CoeffReturnType* data) {
-  // Compute the scan along the axis, starting at the given offset
-  typename Self::CoeffReturnType accum = self.accumulator().initialize();
-  if (self.stride() == 1) {
-    if (self.exclusive()) {
-      for (Index curr = offset; curr < offset + self.size(); ++curr) {
-        data[curr] = self.accumulator().finalize(accum);
-        self.accumulator().reduce(self.inner().coeff(curr), &accum);
-      }
-    } else {
-      for (Index curr = offset; curr < offset + self.size(); ++curr) {
-        self.accumulator().reduce(self.inner().coeff(curr), &accum);
-        data[curr] = self.accumulator().finalize(accum);
-      }
-    }
-  } else {
-    if (self.exclusive()) {
-      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
-        Index curr = offset + idx3 * self.stride();
-        data[curr] = self.accumulator().finalize(accum);
-        self.accumulator().reduce(self.inner().coeff(curr), &accum);
-      }
-    } else {
-      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
-        Index curr = offset + idx3 * self.stride();
-        self.accumulator().reduce(self.inner().coeff(curr), &accum);
-        data[curr] = self.accumulator().finalize(accum);
-      }
-    }
-  }
-}
-
-template <typename Self>
-EIGEN_STRONG_INLINE void ReducePacket(Self& self, Index offset, typename Self::CoeffReturnType* data) {
-  using Scalar = typename Self::CoeffReturnType;
-  using Packet = typename Self::PacketReturnType;
-  // Compute the scan along the axis, starting at the calculated offset
-  Packet accum = self.accumulator().template initializePacket<Packet>();
-  if (self.stride() == 1) {
-    if (self.exclusive()) {
-      for (Index curr = offset; curr < offset + self.size(); ++curr) {
-        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
-        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
-      }
-    } else {
-      for (Index curr = offset; curr < offset + self.size(); ++curr) {
-        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
-        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
-      }
-    }
-  } else {
-    if (self.exclusive()) {
-      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
-        const Index curr = offset + idx3 * self.stride();
-        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
-        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
-      }
-    } else {
-      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
-        const Index curr = offset + idx3 * self.stride();
-        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
-        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
-      }
-    }
-  }
-}
-
-template <typename Self, bool Vectorize, bool Parallel>
-struct ReduceBlock {
-  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
-    for (Index idx2 = 0; idx2 < self.stride(); idx2++) {
-      // Calculate the starting offset for the scan
-      Index offset = idx1 + idx2;
-      ReduceScalar(self, offset, data);
-    }
-  }
-};
-
-// Specialization for vectorized reduction.
-template <typename Self>
-struct ReduceBlock<Self, /*Vectorize=*/true, /*Parallel=*/false> {
-  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
-    using Packet = typename Self::PacketReturnType;
-    const int PacketSize = internal::unpacket_traits<Packet>::size;
-    Index idx2 = 0;
-    for (; idx2 + PacketSize <= self.stride(); idx2 += PacketSize) {
-      // Calculate the starting offset for the packet scan
-      Index offset = idx1 + idx2;
-      ReducePacket(self, offset, data);
-    }
-    for (; idx2 < self.stride(); idx2++) {
-      // Calculate the starting offset for the scan
-      Index offset = idx1 + idx2;
-      ReduceScalar(self, offset, data);
-    }
-  }
-};
-
-// Single-threaded CPU implementation of scan
-template <typename Self, typename Reducer, typename Device,
-          bool Vectorize = (TensorEvaluator<typename Self::ChildTypeNoConst, Device>::PacketAccess &&
-                            internal::reducer_traits<Reducer, Device>::PacketAccess)>
-struct ScanLauncher {
-  void operator()(Self& self, typename Self::CoeffReturnType* data) const {
-    Index total_size = internal::array_prod(self.dimensions());
-
-    // We fix the index along the scan axis to 0 and perform a
-    // scan per remaining entry. The iteration is split into two nested
-    // loops to avoid an integer division by keeping track of each idx1 and
-    // idx2.
-    for (Index idx1 = 0; idx1 < total_size; idx1 += self.stride() * self.size()) {
-      ReduceBlock<Self, Vectorize, /*Parallel=*/false> block_reducer;
-      block_reducer(self, idx1, data);
-    }
-  }
-};
-
-#ifdef EIGEN_USE_THREADS
-
-// Adjust block_size to avoid false sharing of cachelines among
-// threads. Currently set to twice the cache line size on Intel and ARM
-// processors.
-EIGEN_STRONG_INLINE Index AdjustBlockSize(Index item_size, Index block_size) {
-  constexpr Index kBlockAlignment = 128;
-  const Index items_per_cacheline = numext::maxi<Index>(1, kBlockAlignment / item_size);
-  return items_per_cacheline * numext::div_ceil(block_size, items_per_cacheline);
-}
-
-template <typename Self>
-struct ReduceBlock<Self, /*Vectorize=*/true, /*Parallel=*/true> {
-  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
-    using Scalar = typename Self::CoeffReturnType;
-    using Packet = typename Self::PacketReturnType;
-    const int PacketSize = internal::unpacket_traits<Packet>::size;
-    Index num_scalars = self.stride();
-    Index num_packets = 0;
-    if (self.stride() >= PacketSize) {
-      num_packets = self.stride() / PacketSize;
-      self.device().parallelFor(
-          num_packets,
-          TensorOpCost(PacketSize * self.size(), PacketSize * self.size(), 16 * PacketSize * self.size(), true,
-                       PacketSize),
-          // Make the shard size large enough that two neighboring threads
-          // won't write to the same cacheline of `data`.
-          [=](Index blk_size) { return AdjustBlockSize(PacketSize * sizeof(Scalar), blk_size); },
-          [&](Index first, Index last) {
-            for (Index packet = first; packet < last; ++packet) {
-              const Index idx2 = packet * PacketSize;
-              ReducePacket(self, idx1 + idx2, data);
-            }
-          });
-      num_scalars -= num_packets * PacketSize;
-    }
-    self.device().parallelFor(
-        num_scalars, TensorOpCost(self.size(), self.size(), 16 * self.size()),
-        // Make the shard size large enough that two neighboring threads
-        // won't write to the same cacheline of `data`.
-        [=](Index blk_size) { return AdjustBlockSize(sizeof(Scalar), blk_size); },
-        [&](Index first, Index last) {
-          for (Index scalar = first; scalar < last; ++scalar) {
-            const Index idx2 = num_packets * PacketSize + scalar;
-            ReduceScalar(self, idx1 + idx2, data);
-          }
-        });
-  }
-};
-
-template <typename Self>
-struct ReduceBlock<Self, /*Vectorize=*/false, /*Parallel=*/true> {
-  EIGEN_STRONG_INLINE void operator()(Self& self, Index idx1, typename Self::CoeffReturnType* data) const {
-    using Scalar = typename Self::CoeffReturnType;
-    self.device().parallelFor(
-        self.stride(), TensorOpCost(self.size(), self.size(), 16 * self.size()),
-        // Make the shard size large enough that two neighboring threads
-        // won't write to the same cacheline of `data`.
-        [=](Index blk_size) { return AdjustBlockSize(sizeof(Scalar), blk_size); },
-        [&](Index first, Index last) {
-          for (Index idx2 = first; idx2 < last; ++idx2) {
-            ReduceScalar(self, idx1 + idx2, data);
-          }
-        });
-  }
-};
-
-// Specialization for multi-threaded execution.
-template <typename Self, typename Reducer, bool Vectorize>
-struct ScanLauncher<Self, Reducer, ThreadPoolDevice, Vectorize> {
-  void operator()(Self& self, typename Self::CoeffReturnType* data) const {
-    using Scalar = typename Self::CoeffReturnType;
-    using Packet = typename Self::PacketReturnType;
-    const int PacketSize = internal::unpacket_traits<Packet>::size;
-    const Index total_size = internal::array_prod(self.dimensions());
-    const Index inner_block_size = self.stride() * self.size();
-    bool parallelize_by_outer_blocks = (total_size >= (self.stride() * inner_block_size));
-
-    if ((parallelize_by_outer_blocks && total_size <= 4096) ||
-        (!parallelize_by_outer_blocks && self.stride() < PacketSize)) {
-      ScanLauncher<Self, Reducer, DefaultDevice, Vectorize> launcher;
-      launcher(self, data);
-      return;
-    }
-
-    if (parallelize_by_outer_blocks) {
-      // Parallelize over outer blocks.
-      const Index num_outer_blocks = total_size / inner_block_size;
-      self.device().parallelFor(
-          num_outer_blocks,
-          TensorOpCost(inner_block_size, inner_block_size, 16 * PacketSize * inner_block_size, Vectorize, PacketSize),
-          [=](Index blk_size) { return AdjustBlockSize(inner_block_size * sizeof(Scalar), blk_size); },
-          [&](Index first, Index last) {
-            for (Index idx1 = first; idx1 < last; ++idx1) {
-              ReduceBlock<Self, Vectorize, /*Parallelize=*/false> block_reducer;
-              block_reducer(self, idx1 * inner_block_size, data);
-            }
-          });
-    } else {
-      // Parallelize over inner packets/scalars dimensions when the reduction
-      // axis is not an inner dimension.
-      ReduceBlock<Self, Vectorize, /*Parallelize=*/true> block_reducer;
-      for (Index idx1 = 0; idx1 < total_size; idx1 += self.stride() * self.size()) {
-        block_reducer(self, idx1, data);
-      }
-    }
-  }
-};
-#endif  // EIGEN_USE_THREADS
-
-#if defined(EIGEN_USE_GPU) && (defined(EIGEN_GPUCC))
-
-// GPU implementation of scan
-// TODO(ibab): This placeholder implementation performs multiple scans in
-// parallel, but it would be better to use a parallel scan algorithm and
-// optimize memory access.
-template <typename Self, typename Reducer>
-__global__ EIGEN_HIP_LAUNCH_BOUNDS_1024 void ScanKernel(Self self, Index total_size,
-                                                        typename Self::CoeffReturnType* data) {
-  // Compute offset as in the CPU version
-  Index val = threadIdx.x + blockIdx.x * blockDim.x;
-  Index offset = (val / self.stride()) * self.stride() * self.size() + val % self.stride();
-
-  if (offset + (self.size() - 1) * self.stride() < total_size) {
-    // Compute the scan along the axis, starting at the calculated offset
-    typename Self::CoeffReturnType accum = self.accumulator().initialize();
-    for (Index idx = 0; idx < self.size(); idx++) {
-      Index curr = offset + idx * self.stride();
-      if (self.exclusive()) {
-        data[curr] = self.accumulator().finalize(accum);
-        self.accumulator().reduce(self.inner().coeff(curr), &accum);
-      } else {
-        self.accumulator().reduce(self.inner().coeff(curr), &accum);
-        data[curr] = self.accumulator().finalize(accum);
-      }
-    }
-  }
-  __syncthreads();
-}
-
-template <typename Self, typename Reducer, bool Vectorize>
-struct ScanLauncher<Self, Reducer, GpuDevice, Vectorize> {
-  void operator()(const Self& self, typename Self::CoeffReturnType* data) const {
-    Index total_size = internal::array_prod(self.dimensions());
-    Index num_blocks = (total_size / self.size() + 63) / 64;
-    Index block_size = 64;
-
-    LAUNCH_GPU_KERNEL((ScanKernel<Self, Reducer>), num_blocks, block_size, 0, self.device(), self, total_size, data);
-  }
-};
-#endif  // EIGEN_USE_GPU && (EIGEN_GPUCC)
-
-}  // namespace internal
-
-// Eval as rvalue
-template <typename Op, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorScanOp<Op, ArgType>, Device> {
-  typedef TensorScanOp<Op, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  typedef const ArgType ChildTypeNoConst;
-  typedef const ArgType ChildType;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  typedef TensorEvaluator<const TensorScanOp<Op, ArgType>, Device> Self;
-  typedef StorageMemory<Scalar, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = false,
-    PreferBlockAccess = false,
-    CoordAccess = false,
-    RawAccess = true
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device),
-        m_device(device),
-        m_exclusive(op.exclusive()),
-        m_accumulator(op.accumulator()),
-        m_size(m_impl.dimensions()[op.axis()]),
-        m_stride(1),
-        m_consume_dim(op.axis()),
-        m_output(NULL) {
-    // Accumulating a scalar isn't supported.
-    EIGEN_STATIC_ASSERT((NumDims > 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    eigen_assert(op.axis() >= 0 && op.axis() < NumDims);
-
-    // Compute stride of scan axis
-    const Dimensions& dims = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = 0; i < op.axis(); ++i) {
-        m_stride = m_stride * dims[i];
-      }
-    } else {
-      // dims can only be indexed through unsigned integers,
-      // so use an unsigned type to let the compiler know.
-      // This prevents spurious warnings: "'*((void*)(& evaluator)+64)[18446744073709551615]' may be used uninitialized
-      // in this function"
-      unsigned int axis = internal::convert_index<unsigned int>(op.axis());
-      for (unsigned int i = NumDims - 1; i > axis; --i) {
-        m_stride = m_stride * dims[i];
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index& stride() const { return m_stride; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index& consume_dim() const { return m_consume_dim; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Index& size() const { return m_size; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Op& accumulator() const { return m_accumulator; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool exclusive() const { return m_exclusive; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TensorEvaluator<ArgType, Device>& inner() const { return m_impl; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Device& device() const { return m_device; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    internal::ScanLauncher<Self, Op, Device> launcher;
-    if (data) {
-      launcher(*this, data);
-      return false;
-    }
-
-    const Index total_size = internal::array_prod(dimensions());
-    m_output =
-        static_cast<EvaluatorPointerType>(m_device.get((Scalar*)m_device.allocate_temp(total_size * sizeof(Scalar))));
-    launcher(*this, m_output);
-    return true;
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC PacketReturnType packet(Index index) const {
-    return internal::ploadt<PacketReturnType, LoadMode>(m_output + index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EvaluatorPointerType data() const { return m_output; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_output[index]; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool) const {
-    return TensorOpCost(sizeof(CoeffReturnType), 0, 0);
-  }
-
-  EIGEN_STRONG_INLINE void cleanup() {
-    if (m_output) {
-      m_device.deallocate_temp(m_output);
-      m_output = NULL;
-    }
-    m_impl.cleanup();
-  }
-
- protected:
-  TensorEvaluator<ArgType, Device> m_impl;
-  const Device EIGEN_DEVICE_REF m_device;
-  const bool m_exclusive;
-  Op m_accumulator;
-  const Index m_size;
-  Index m_stride;
-  Index m_consume_dim;
-  EvaluatorPointerType m_output;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_SCAN_H
diff --git a/unsupported/Eigen/src/Tensor/TensorScanSycl.h b/unsupported/Eigen/src/Tensor/TensorScanSycl.h
deleted file mode 100644
index f08b83a..0000000
--- a/unsupported/Eigen/src/Tensor/TensorScanSycl.h
+++ /dev/null
@@ -1,506 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-/*****************************************************************
- * TensorScanSycl.h
- *
- * \brief:
- *  Tensor Scan Sycl implement the extend  version of
- * "Efficient parallel scan algorithms for GPUs." .for Tensor operations.
- * The algorithm requires up to 3 stage (consequently 3 kernels) depending on
- * the size of the tensor. In the first kernel (ScanKernelFunctor), each
- * threads within the work-group individually reduces the allocated elements per
- * thread in order to reduces the total number of blocks. In the next step all
- * thread within the work-group will reduce the associated blocks into the
- * temporary buffers. In the next kernel(ScanBlockKernelFunctor), the temporary
- * buffer is given as an input and all the threads within a work-group scan and
- * reduces the boundaries between the blocks (generated from the previous
- * kernel). and write the data on the temporary buffer. If the second kernel is
- * required, the third and final kernel (ScanAdjustmentKernelFunctor) will
- * adjust the final result into the output buffer.
- * The original algorithm for the parallel prefix sum can be found here:
- *
- * Sengupta, Shubhabrata, Mark Harris, and Michael Garland. "Efficient parallel
- * scan algorithms for GPUs." NVIDIA, Santa Clara, CA, Tech. Rep. NVR-2008-003
- *1, no. 1 (2008): 1-17.
- *****************************************************************/
-
-#ifndef UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSOR_SYCL_SYCL_HPP
-#define UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSOR_SYCL_SYCL_HPP
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace TensorSycl {
-namespace internal {
-
-#ifndef EIGEN_SYCL_MAX_GLOBAL_RANGE
-#define EIGEN_SYCL_MAX_GLOBAL_RANGE (EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1 * 4)
-#endif
-
-template <typename index_t>
-struct ScanParameters {
-  // must be power of 2
-  static constexpr index_t ScanPerThread = 8;
-  const index_t total_size;
-  const index_t non_scan_size;
-  const index_t scan_size;
-  const index_t non_scan_stride;
-  const index_t scan_stride;
-  const index_t panel_threads;
-  const index_t group_threads;
-  const index_t block_threads;
-  const index_t elements_per_group;
-  const index_t elements_per_block;
-  const index_t loop_range;
-
-  ScanParameters(index_t total_size_, index_t non_scan_size_, index_t scan_size_, index_t non_scan_stride_,
-                 index_t scan_stride_, index_t panel_threads_, index_t group_threads_, index_t block_threads_,
-                 index_t elements_per_group_, index_t elements_per_block_, index_t loop_range_)
-      : total_size(total_size_),
-        non_scan_size(non_scan_size_),
-        scan_size(scan_size_),
-        non_scan_stride(non_scan_stride_),
-        scan_stride(scan_stride_),
-        panel_threads(panel_threads_),
-        group_threads(group_threads_),
-        block_threads(block_threads_),
-        elements_per_group(elements_per_group_),
-        elements_per_block(elements_per_block_),
-        loop_range(loop_range_) {}
-};
-
-enum class scan_step { first, second };
-template <typename Evaluator, typename CoeffReturnType, typename OutAccessor, typename Op, typename Index,
-          scan_step stp>
-struct ScanKernelFunctor {
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      LocalAccessor;
-  static constexpr int PacketSize = ScanParameters<Index>::ScanPerThread / 2;
-
-  LocalAccessor scratch;
-  Evaluator dev_eval;
-  OutAccessor out_ptr;
-  OutAccessor tmp_ptr;
-  const ScanParameters<Index> scanParameters;
-  Op accumulator;
-  const bool inclusive;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ScanKernelFunctor(LocalAccessor scratch_, const Evaluator dev_eval_,
-                                                          OutAccessor out_accessor_, OutAccessor temp_accessor_,
-                                                          const ScanParameters<Index> scanParameters_, Op accumulator_,
-                                                          const bool inclusive_)
-      : scratch(scratch_),
-        dev_eval(dev_eval_),
-        out_ptr(out_accessor_),
-        tmp_ptr(temp_accessor_),
-        scanParameters(scanParameters_),
-        accumulator(accumulator_),
-        inclusive(inclusive_) {}
-
-  template <scan_step sst = stp, typename Input>
-  std::enable_if_t<sst == scan_step::first, CoeffReturnType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE read(
-      const Input &inpt, Index global_id) const {
-    return inpt.coeff(global_id);
-  }
-
-  template <scan_step sst = stp, typename Input>
-  std::enable_if_t<sst != scan_step::first, CoeffReturnType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE read(
-      const Input &inpt, Index global_id) const {
-    return inpt[global_id];
-  }
-
-  template <scan_step sst = stp, typename InclusiveOp>
-  std::enable_if_t<sst == scan_step::first> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE first_step_inclusive_Operation(
-      InclusiveOp inclusive_op) const {
-    inclusive_op();
-  }
-
-  template <scan_step sst = stp, typename InclusiveOp>
-  std::enable_if_t<sst != scan_step::first> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE first_step_inclusive_Operation(
-      InclusiveOp) const {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
-    for (Index loop_offset = 0; loop_offset < scanParameters.loop_range; loop_offset++) {
-      Index data_offset = (itemID.get_global_id(0) + (itemID.get_global_range(0) * loop_offset));
-      Index tmp = data_offset % scanParameters.panel_threads;
-      const Index panel_id = data_offset / scanParameters.panel_threads;
-      const Index group_id = tmp / scanParameters.group_threads;
-      tmp = tmp % scanParameters.group_threads;
-      const Index block_id = tmp / scanParameters.block_threads;
-      const Index local_id = tmp % scanParameters.block_threads;
-      // we put one element per packet in scratch_mem
-      const Index scratch_stride = scanParameters.elements_per_block / PacketSize;
-      const Index scratch_offset = (itemID.get_local_id(0) / scanParameters.block_threads) * scratch_stride;
-      CoeffReturnType private_scan[ScanParameters<Index>::ScanPerThread];
-      CoeffReturnType inclusive_scan;
-      // the actual panel size is scan_size * non_scan_size.
-      // elements_per_panel is roundup to power of 2 for binary tree
-      const Index panel_offset = panel_id * scanParameters.scan_size * scanParameters.non_scan_size;
-      const Index group_offset = group_id * scanParameters.non_scan_stride;
-      // This will be effective when the size is bigger than elements_per_block
-      const Index block_offset = block_id * scanParameters.elements_per_block * scanParameters.scan_stride;
-      const Index thread_offset = (ScanParameters<Index>::ScanPerThread * local_id * scanParameters.scan_stride);
-      const Index global_offset = panel_offset + group_offset + block_offset + thread_offset;
-      Index next_elements = 0;
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < ScanParameters<Index>::ScanPerThread; i++) {
-        Index global_id = global_offset + next_elements;
-        private_scan[i] = ((((block_id * scanParameters.elements_per_block) +
-                             (ScanParameters<Index>::ScanPerThread * local_id) + i) < scanParameters.scan_size) &&
-                           (global_id < scanParameters.total_size))
-                              ? read(dev_eval, global_id)
-                              : accumulator.initialize();
-        next_elements += scanParameters.scan_stride;
-      }
-      first_step_inclusive_Operation([&]() EIGEN_DEVICE_FUNC {
-        if (inclusive) {
-          inclusive_scan = private_scan[ScanParameters<Index>::ScanPerThread - 1];
-        }
-      });
-      // This for loop must be 2
-      EIGEN_UNROLL_LOOP
-      for (int packetIndex = 0; packetIndex < ScanParameters<Index>::ScanPerThread; packetIndex += PacketSize) {
-        Index private_offset = 1;
-        // build sum in place up the tree
-        EIGEN_UNROLL_LOOP
-        for (Index d = PacketSize >> 1; d > 0; d >>= 1) {
-          EIGEN_UNROLL_LOOP
-          for (Index l = 0; l < d; l++) {
-            Index ai = private_offset * (2 * l + 1) - 1 + packetIndex;
-            Index bi = private_offset * (2 * l + 2) - 1 + packetIndex;
-            CoeffReturnType accum = accumulator.initialize();
-            accumulator.reduce(private_scan[ai], &accum);
-            accumulator.reduce(private_scan[bi], &accum);
-            private_scan[bi] = accumulator.finalize(accum);
-          }
-          private_offset *= 2;
-        }
-        scratch[2 * local_id + (packetIndex / PacketSize) + scratch_offset] =
-            private_scan[PacketSize - 1 + packetIndex];
-        private_scan[PacketSize - 1 + packetIndex] = accumulator.initialize();
-        // traverse down tree & build scan
-        EIGEN_UNROLL_LOOP
-        for (Index d = 1; d < PacketSize; d *= 2) {
-          private_offset >>= 1;
-          EIGEN_UNROLL_LOOP
-          for (Index l = 0; l < d; l++) {
-            Index ai = private_offset * (2 * l + 1) - 1 + packetIndex;
-            Index bi = private_offset * (2 * l + 2) - 1 + packetIndex;
-            CoeffReturnType accum = accumulator.initialize();
-            accumulator.reduce(private_scan[ai], &accum);
-            accumulator.reduce(private_scan[bi], &accum);
-            private_scan[ai] = private_scan[bi];
-            private_scan[bi] = accumulator.finalize(accum);
-          }
-        }
-      }
-
-      Index offset = 1;
-      // build sum in place up the tree
-      for (Index d = scratch_stride >> 1; d > 0; d >>= 1) {
-        // Synchronise
-        itemID.barrier(cl::sycl::access::fence_space::local_space);
-        if (local_id < d) {
-          Index ai = offset * (2 * local_id + 1) - 1 + scratch_offset;
-          Index bi = offset * (2 * local_id + 2) - 1 + scratch_offset;
-          CoeffReturnType accum = accumulator.initialize();
-          accumulator.reduce(scratch[ai], &accum);
-          accumulator.reduce(scratch[bi], &accum);
-          scratch[bi] = accumulator.finalize(accum);
-        }
-        offset *= 2;
-      }
-      // Synchronise
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-      // next step optimisation
-      if (local_id == 0) {
-        if (((scanParameters.elements_per_group / scanParameters.elements_per_block) > 1)) {
-          const Index temp_id = panel_id * (scanParameters.elements_per_group / scanParameters.elements_per_block) *
-                                    scanParameters.non_scan_size +
-                                group_id * (scanParameters.elements_per_group / scanParameters.elements_per_block) +
-                                block_id;
-          tmp_ptr[temp_id] = scratch[scratch_stride - 1 + scratch_offset];
-        }
-        // clear the last element
-        scratch[scratch_stride - 1 + scratch_offset] = accumulator.initialize();
-      }
-      // traverse down tree & build scan
-      for (Index d = 1; d < scratch_stride; d *= 2) {
-        offset >>= 1;
-        // Synchronise
-        itemID.barrier(cl::sycl::access::fence_space::local_space);
-        if (local_id < d) {
-          Index ai = offset * (2 * local_id + 1) - 1 + scratch_offset;
-          Index bi = offset * (2 * local_id + 2) - 1 + scratch_offset;
-          CoeffReturnType accum = accumulator.initialize();
-          accumulator.reduce(scratch[ai], &accum);
-          accumulator.reduce(scratch[bi], &accum);
-          scratch[ai] = scratch[bi];
-          scratch[bi] = accumulator.finalize(accum);
-        }
-      }
-      // Synchronise
-      itemID.barrier(cl::sycl::access::fence_space::local_space);
-      // This for loop must be 2
-      EIGEN_UNROLL_LOOP
-      for (int packetIndex = 0; packetIndex < ScanParameters<Index>::ScanPerThread; packetIndex += PacketSize) {
-        EIGEN_UNROLL_LOOP
-        for (Index i = 0; i < PacketSize; i++) {
-          CoeffReturnType accum = private_scan[packetIndex + i];
-          accumulator.reduce(scratch[2 * local_id + (packetIndex / PacketSize) + scratch_offset], &accum);
-          private_scan[packetIndex + i] = accumulator.finalize(accum);
-        }
-      }
-      first_step_inclusive_Operation([&]() EIGEN_DEVICE_FUNC {
-        if (inclusive) {
-          accumulator.reduce(private_scan[ScanParameters<Index>::ScanPerThread - 1], &inclusive_scan);
-          private_scan[0] = accumulator.finalize(inclusive_scan);
-        }
-      });
-      next_elements = 0;
-      // Write the first set of private params.
-      EIGEN_UNROLL_LOOP
-      for (Index i = 0; i < ScanParameters<Index>::ScanPerThread; i++) {
-        Index global_id = global_offset + next_elements;
-        if ((((block_id * scanParameters.elements_per_block) + (ScanParameters<Index>::ScanPerThread * local_id) + i) <
-             scanParameters.scan_size) &&
-            (global_id < scanParameters.total_size)) {
-          Index private_id = (i * !inclusive) + (((i + 1) % ScanParameters<Index>::ScanPerThread) * (inclusive));
-          out_ptr[global_id] = private_scan[private_id];
-        }
-        next_elements += scanParameters.scan_stride;
-      }
-    }  // end for loop
-  }
-};
-
-template <typename CoeffReturnType, typename InAccessor, typename OutAccessor, typename Op, typename Index>
-struct ScanAdjustmentKernelFunctor {
-  typedef cl::sycl::accessor<CoeffReturnType, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local>
-      LocalAccessor;
-  static constexpr int PacketSize = ScanParameters<Index>::ScanPerThread / 2;
-  InAccessor in_ptr;
-  OutAccessor out_ptr;
-  const ScanParameters<Index> scanParameters;
-  Op accumulator;
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ScanAdjustmentKernelFunctor(LocalAccessor, InAccessor in_accessor_,
-                                                                    OutAccessor out_accessor_,
-                                                                    const ScanParameters<Index> scanParameters_,
-                                                                    Op accumulator_)
-      : in_ptr(in_accessor_), out_ptr(out_accessor_), scanParameters(scanParameters_), accumulator(accumulator_) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void operator()(cl::sycl::nd_item<1> itemID) const {
-    for (Index loop_offset = 0; loop_offset < scanParameters.loop_range; loop_offset++) {
-      Index data_offset = (itemID.get_global_id(0) + (itemID.get_global_range(0) * loop_offset));
-      Index tmp = data_offset % scanParameters.panel_threads;
-      const Index panel_id = data_offset / scanParameters.panel_threads;
-      const Index group_id = tmp / scanParameters.group_threads;
-      tmp = tmp % scanParameters.group_threads;
-      const Index block_id = tmp / scanParameters.block_threads;
-      const Index local_id = tmp % scanParameters.block_threads;
-
-      // the actual panel size is scan_size * non_scan_size.
-      // elements_per_panel is roundup to power of 2 for binary tree
-      const Index panel_offset = panel_id * scanParameters.scan_size * scanParameters.non_scan_size;
-      const Index group_offset = group_id * scanParameters.non_scan_stride;
-      // This will be effective when the size is bigger than elements_per_block
-      const Index block_offset = block_id * scanParameters.elements_per_block * scanParameters.scan_stride;
-      const Index thread_offset = ScanParameters<Index>::ScanPerThread * local_id * scanParameters.scan_stride;
-
-      const Index global_offset = panel_offset + group_offset + block_offset + thread_offset;
-      const Index block_size = scanParameters.elements_per_group / scanParameters.elements_per_block;
-      const Index in_id = (panel_id * block_size * scanParameters.non_scan_size) + (group_id * block_size) + block_id;
-      CoeffReturnType adjust_val = in_ptr[in_id];
-
-      Index next_elements = 0;
-      EIGEN_UNROLL_LOOP
-      for (Index i = 0; i < ScanParameters<Index>::ScanPerThread; i++) {
-        Index global_id = global_offset + next_elements;
-        if ((((block_id * scanParameters.elements_per_block) + (ScanParameters<Index>::ScanPerThread * local_id) + i) <
-             scanParameters.scan_size) &&
-            (global_id < scanParameters.total_size)) {
-          CoeffReturnType accum = adjust_val;
-          accumulator.reduce(out_ptr[global_id], &accum);
-          out_ptr[global_id] = accumulator.finalize(accum);
-        }
-        next_elements += scanParameters.scan_stride;
-      }
-    }
-  }
-};
-
-template <typename Index>
-struct ScanInfo {
-  const Index &total_size;
-  const Index &scan_size;
-  const Index &panel_size;
-  const Index &non_scan_size;
-  const Index &scan_stride;
-  const Index &non_scan_stride;
-
-  Index max_elements_per_block;
-  Index block_size;
-  Index panel_threads;
-  Index group_threads;
-  Index block_threads;
-  Index elements_per_group;
-  Index elements_per_block;
-  Index loop_range;
-  Index global_range;
-  Index local_range;
-  const Eigen::SyclDevice &dev;
-  EIGEN_STRONG_INLINE ScanInfo(const Index &total_size_, const Index &scan_size_, const Index &panel_size_,
-                               const Index &non_scan_size_, const Index &scan_stride_, const Index &non_scan_stride_,
-                               const Eigen::SyclDevice &dev_)
-      : total_size(total_size_),
-        scan_size(scan_size_),
-        panel_size(panel_size_),
-        non_scan_size(non_scan_size_),
-        scan_stride(scan_stride_),
-        non_scan_stride(non_scan_stride_),
-        dev(dev_) {
-    // must be power of 2
-    local_range = std::min(Index(dev.getNearestPowerOfTwoWorkGroupSize()),
-                           Index(EIGEN_SYCL_LOCAL_THREAD_DIM0 * EIGEN_SYCL_LOCAL_THREAD_DIM1));
-
-    max_elements_per_block = local_range * ScanParameters<Index>::ScanPerThread;
-
-    elements_per_group =
-        dev.getPowerOfTwo(Index(roundUp(Index(scan_size), ScanParameters<Index>::ScanPerThread)), true);
-    const Index elements_per_panel = elements_per_group * non_scan_size;
-    elements_per_block = std::min(Index(elements_per_group), Index(max_elements_per_block));
-    panel_threads = elements_per_panel / ScanParameters<Index>::ScanPerThread;
-    group_threads = elements_per_group / ScanParameters<Index>::ScanPerThread;
-    block_threads = elements_per_block / ScanParameters<Index>::ScanPerThread;
-    block_size = elements_per_group / elements_per_block;
-#ifdef EIGEN_SYCL_MAX_GLOBAL_RANGE
-    const Index max_threads = std::min(Index(panel_threads * panel_size), Index(EIGEN_SYCL_MAX_GLOBAL_RANGE));
-#else
-    const Index max_threads = panel_threads * panel_size;
-#endif
-    global_range = roundUp(max_threads, local_range);
-    loop_range = Index(
-        std::ceil(double(elements_per_panel * panel_size) / (global_range * ScanParameters<Index>::ScanPerThread)));
-  }
-  inline ScanParameters<Index> get_scan_parameter() {
-    return ScanParameters<Index>(total_size, non_scan_size, scan_size, non_scan_stride, scan_stride, panel_threads,
-                                 group_threads, block_threads, elements_per_group, elements_per_block, loop_range);
-  }
-  inline cl::sycl::nd_range<1> get_thread_range() {
-    return cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
-  }
-};
-
-template <typename EvaluatorPointerType, typename CoeffReturnType, typename Reducer, typename Index>
-struct SYCLAdjustBlockOffset {
-  EIGEN_STRONG_INLINE static void adjust_scan_block_offset(EvaluatorPointerType in_ptr, EvaluatorPointerType out_ptr,
-                                                           Reducer &accumulator, const Index total_size,
-                                                           const Index scan_size, const Index panel_size,
-                                                           const Index non_scan_size, const Index scan_stride,
-                                                           const Index non_scan_stride, const Eigen::SyclDevice &dev) {
-    auto scan_info =
-        ScanInfo<Index>(total_size, scan_size, panel_size, non_scan_size, scan_stride, non_scan_stride, dev);
-
-    typedef ScanAdjustmentKernelFunctor<CoeffReturnType, EvaluatorPointerType, EvaluatorPointerType, Reducer, Index>
-        AdjustFuctor;
-    dev.template unary_kernel_launcher<CoeffReturnType, AdjustFuctor>(in_ptr, out_ptr, scan_info.get_thread_range(),
-                                                                      scan_info.max_elements_per_block,
-                                                                      scan_info.get_scan_parameter(), accumulator)
-        .wait();
-  }
-};
-
-template <typename CoeffReturnType, scan_step stp>
-struct ScanLauncher_impl {
-  template <typename Input, typename EvaluatorPointerType, typename Reducer, typename Index>
-  EIGEN_STRONG_INLINE static void scan_block(Input in_ptr, EvaluatorPointerType out_ptr, Reducer &accumulator,
-                                             const Index total_size, const Index scan_size, const Index panel_size,
-                                             const Index non_scan_size, const Index scan_stride,
-                                             const Index non_scan_stride, const bool inclusive,
-                                             const Eigen::SyclDevice &dev) {
-    auto scan_info =
-        ScanInfo<Index>(total_size, scan_size, panel_size, non_scan_size, scan_stride, non_scan_stride, dev);
-    const Index temp_pointer_size = scan_info.block_size * non_scan_size * panel_size;
-    const Index scratch_size = scan_info.max_elements_per_block / (ScanParameters<Index>::ScanPerThread / 2);
-    CoeffReturnType *temp_pointer =
-        static_cast<CoeffReturnType *>(dev.allocate_temp(temp_pointer_size * sizeof(CoeffReturnType)));
-    EvaluatorPointerType tmp_global_accessor = dev.get(temp_pointer);
-
-    typedef ScanKernelFunctor<Input, CoeffReturnType, EvaluatorPointerType, Reducer, Index, stp> ScanFunctor;
-    dev.template binary_kernel_launcher<CoeffReturnType, ScanFunctor>(
-           in_ptr, out_ptr, tmp_global_accessor, scan_info.get_thread_range(), scratch_size,
-           scan_info.get_scan_parameter(), accumulator, inclusive)
-        .wait();
-
-    if (scan_info.block_size > 1) {
-      ScanLauncher_impl<CoeffReturnType, scan_step::second>::scan_block(
-          tmp_global_accessor, tmp_global_accessor, accumulator, temp_pointer_size, scan_info.block_size, panel_size,
-          non_scan_size, Index(1), scan_info.block_size, false, dev);
-
-      SYCLAdjustBlockOffset<EvaluatorPointerType, CoeffReturnType, Reducer, Index>::adjust_scan_block_offset(
-          tmp_global_accessor, out_ptr, accumulator, total_size, scan_size, panel_size, non_scan_size, scan_stride,
-          non_scan_stride, dev);
-    }
-    dev.deallocate_temp(temp_pointer);
-  }
-};
-
-}  // namespace internal
-}  // namespace TensorSycl
-namespace internal {
-template <typename Self, typename Reducer, bool vectorize>
-struct ScanLauncher<Self, Reducer, Eigen::SyclDevice, vectorize> {
-  typedef typename Self::Index Index;
-  typedef typename Self::CoeffReturnType CoeffReturnType;
-  typedef typename Self::Storage Storage;
-  typedef typename Self::EvaluatorPointerType EvaluatorPointerType;
-  void operator()(Self &self, EvaluatorPointerType data) const {
-    const Index total_size = internal::array_prod(self.dimensions());
-    const Index scan_size = self.size();
-    const Index scan_stride = self.stride();
-    // this is the scan op (can be sum or ...)
-    auto accumulator = self.accumulator();
-    auto inclusive = !self.exclusive();
-    auto consume_dim = self.consume_dim();
-    auto dev = self.device();
-
-    auto dims = self.inner().dimensions();
-
-    Index non_scan_size = 1;
-    Index panel_size = 1;
-    if (static_cast<int>(Self::Layout) == static_cast<int>(ColMajor)) {
-      for (int i = 0; i < consume_dim; i++) {
-        non_scan_size *= dims[i];
-      }
-      for (int i = consume_dim + 1; i < Self::NumDims; i++) {
-        panel_size *= dims[i];
-      }
-    } else {
-      for (int i = Self::NumDims - 1; i > consume_dim; i--) {
-        non_scan_size *= dims[i];
-      }
-      for (int i = consume_dim - 1; i >= 0; i--) {
-        panel_size *= dims[i];
-      }
-    }
-    const Index non_scan_stride = (scan_stride > 1) ? 1 : scan_size;
-    auto eval_impl = self.inner();
-    TensorSycl::internal::ScanLauncher_impl<CoeffReturnType, TensorSycl::internal::scan_step::first>::scan_block(
-        eval_impl, data, accumulator, total_size, scan_size, panel_size, non_scan_size, scan_stride, non_scan_stride,
-        inclusive, dev);
-  }
-};
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSOR_SYCL_SYCL_HPP
diff --git a/unsupported/Eigen/src/Tensor/TensorShuffling.h b/unsupported/Eigen/src/Tensor/TensorShuffling.h
deleted file mode 100644
index 51f424e..0000000
--- a/unsupported/Eigen/src/Tensor/TensorShuffling.h
+++ /dev/null
@@ -1,413 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_SHUFFLING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_SHUFFLING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Shuffle, typename XprType>
-struct traits<TensorShufflingOp<Shuffle, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename Shuffle, typename XprType>
-struct eval<TensorShufflingOp<Shuffle, XprType>, Eigen::Dense> {
-  typedef const TensorShufflingOp<Shuffle, XprType>& type;
-};
-
-template <typename Shuffle, typename XprType>
-struct nested<TensorShufflingOp<Shuffle, XprType>, 1, typename eval<TensorShufflingOp<Shuffle, XprType> >::type> {
-  typedef TensorShufflingOp<Shuffle, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor shuffling class.
- */
-template <typename Shuffle, typename XprType>
-class TensorShufflingOp : public TensorBase<TensorShufflingOp<Shuffle, XprType> > {
- public:
-  typedef TensorBase<TensorShufflingOp<Shuffle, XprType> > Base;
-  typedef typename Eigen::internal::traits<TensorShufflingOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorShufflingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorShufflingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorShufflingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorShufflingOp(const XprType& expr, const Shuffle& shfl)
-      : m_xpr(expr), m_shuffle(shfl) {}
-
-  EIGEN_DEVICE_FUNC const Shuffle& shufflePermutation() const { return m_shuffle; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorShufflingOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Shuffle m_shuffle;
-};
-
-// Eval as rvalue
-template <typename Shuffle, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> Self;
-  typedef TensorShufflingOp<Shuffle, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
-    PreferBlockAccess = true,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-
-  typedef typename internal::TensorMaterializedBlock<ScalarNoConst, NumDims, Layout, Index> TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_device(device), m_impl(op.expression(), device) {
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    const Shuffle& shuffle = op.shufflePermutation();
-    m_is_identity = true;
-    for (int i = 0; i < NumDims; ++i) {
-      m_shuffle[i] = static_cast<int>(shuffle[i]);
-      m_dimensions[i] = input_dims[shuffle[i]];
-      m_inverseShuffle[shuffle[i]] = i;
-      if (m_is_identity && shuffle[i] != i) {
-        m_is_identity = false;
-      }
-    }
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_unshuffledInputStrides[0] = 1;
-      m_outputStrides[0] = 1;
-
-      for (int i = 1; i < NumDims; ++i) {
-        m_unshuffledInputStrides[i] = m_unshuffledInputStrides[i - 1] * input_dims[i - 1];
-        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-        m_fastOutputStrides[i] =
-            internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : Index(1));
-      }
-    } else {
-      m_unshuffledInputStrides[NumDims - 1] = 1;
-      m_outputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_unshuffledInputStrides[i] = m_unshuffledInputStrides[i + 1] * input_dims[i + 1];
-        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-        m_fastOutputStrides[i] =
-            internal::TensorIntDivisor<Index>(m_outputStrides[i] > 0 ? m_outputStrides[i] : Index(1));
-      }
-    }
-
-    for (int i = 0; i < NumDims; ++i) {
-      m_inputStrides[i] = m_unshuffledInputStrides[shuffle[i]];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    if (m_is_identity) {
-      return m_impl.coeff(index);
-    } else {
-      return m_impl.coeff(srcCoeff(index));
-    }
-  }
-
-  template <int LoadMode, typename Self, bool ImplPacketAccess>
-  struct PacketLoader {
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType Run(const Self& self, Index index) {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < PacketSize; ++i) {
-        values[i] = self.coeff(index + i);
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    }
-  };
-
-  template <int LoadMode, typename Self>
-  struct PacketLoader<LoadMode, Self, true> {
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType Run(const Self& self, Index index) {
-      if (self.m_is_identity) {
-        return self.m_impl.template packet<LoadMode>(index);
-      } else {
-        EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-        EIGEN_UNROLL_LOOP
-        for (int i = 0; i < PacketSize; ++i) {
-          values[i] = self.coeff(index + i);
-        }
-        PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-        return rslt;
-      }
-    }
-  };
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-    return PacketLoader<LoadMode, Self, TensorEvaluator<ArgType, Device>::PacketAccess>::Run(*this, index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE internal::TensorBlockResourceRequirements getResourceRequirements() const {
-    static const int inner_dim = Layout == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
-
-    const size_t target_size = m_device.firstLevelCacheSize();
-    const bool inner_dim_shuffled = m_shuffle[inner_dim] != inner_dim;
-
-    // Shuffled inner dimensions leads to a random memory access, which is not
-    // captured by default cost model bytes loaded/stored. We add this cost
-    // explicitly. The number of cycles picked based on the benchmarks.
-    // TODO(ezhulenev): This number was picked based on a very questionable
-    // benchmarks, add benchmarks that are representative of real workloads.
-    using BlockRequirements = internal::TensorBlockResourceRequirements;
-    if (inner_dim_shuffled) {
-      return BlockRequirements::uniform<Scalar>(target_size).addCostPerCoeff({0, 0, NumDims * 28});
-    } else {
-      return BlockRequirements::skewed<Scalar>(target_size);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlock block(TensorBlockDesc& desc, TensorBlockScratch& scratch,
-                                                          bool root_of_expr_ast = false) const {
-    eigen_assert(m_impl.data() != NULL);
-
-    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
-    typedef typename TensorBlockIO::Dst TensorBlockIODst;
-    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
-
-    const typename TensorBlock::Storage block_storage =
-        TensorBlock::prepareStorage(desc, scratch, /*allow_strided_storage=*/root_of_expr_ast);
-
-    typename TensorBlockIO::Dimensions input_strides(m_unshuffledInputStrides);
-    TensorBlockIOSrc src(input_strides, m_impl.data(), srcCoeff(desc.offset()));
-
-    TensorBlockIODst dst(block_storage.dimensions(), block_storage.strides(), block_storage.data());
-
-    typename TensorBlockIO::DimensionsMap dst_to_src_dim_map(m_shuffle);
-    TensorBlockIO::Copy(dst, src, dst_to_src_dim_map);
-
-    return block_storage.AsTensorMaterializedBlock();
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double compute_cost = m_is_identity
-                                    ? TensorOpCost::AddCost<Index>()
-                                    : NumDims * (2 * TensorOpCost::AddCost<Index>() +
-                                                 2 * TensorOpCost::MulCost<Index>() + TensorOpCost::DivCost<Index>());
-    return m_impl.costPerCoeff(vectorized) +
-           TensorOpCost(0, 0, compute_cost, m_is_identity /* vectorized */, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return NULL; }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index
-  GetBlockOutputIndex(Index input_index, const DSizes<Index, NumDims>& input_block_strides,
-                      const DSizes<Index, NumDims>& output_block_strides,
-                      const DSizes<internal::TensorIntDivisor<Index>, NumDims>& fast_input_block_strides) const {
-    Index output_index = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = input_index / fast_input_block_strides[i];
-        output_index += idx * output_block_strides[m_inverseShuffle[i]];
-        input_index -= idx * input_block_strides[i];
-      }
-      return output_index + input_index * output_block_strides[m_inverseShuffle[0]];
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = input_index / fast_input_block_strides[i];
-        output_index += idx * output_block_strides[m_inverseShuffle[i]];
-        input_index -= idx * input_block_strides[i];
-      }
-      return output_index + input_index * output_block_strides[m_inverseShuffle[NumDims - 1]];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_fastOutputStrides[i];
-        inputIndex += idx * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      return inputIndex + index * m_inputStrides[0];
-    } else {
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_fastOutputStrides[i];
-        inputIndex += idx * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      return inputIndex + index * m_inputStrides[NumDims - 1];
-    }
-  }
-
-  Dimensions m_dimensions;
-  bool m_is_identity;
-  array<int, NumDims> m_shuffle;
-  array<Index, NumDims> m_inverseShuffle;  // TODO(ezhulenev): Make it int type.
-  array<Index, NumDims> m_outputStrides;
-  array<internal::TensorIntDivisor<Index>, NumDims> m_fastOutputStrides;
-  array<Index, NumDims> m_inputStrides;
-  array<Index, NumDims> m_unshuffledInputStrides;
-
-  const Device EIGEN_DEVICE_REF m_device;
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-// Eval as lvalue
-template <typename Shuffle, typename ArgType, typename Device>
-struct TensorEvaluator<TensorShufflingOp<Shuffle, ArgType>, Device>
-    : public TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> {
-  typedef TensorEvaluator<const TensorShufflingOp<Shuffle, ArgType>, Device> Base;
-
-  typedef TensorShufflingOp<Shuffle, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-
-  enum {
-    IsAligned = false,
-    PacketAccess = (PacketType<CoeffReturnType, Device>::size > 1),
-    BlockAccess = TensorEvaluator<ArgType, Device>::RawAccess,
-    PreferBlockAccess = true,
-    RawAccess = false
-  };
-
-  typedef std::remove_const_t<Scalar> ScalarNoConst;
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockDescriptor<NumDims, Index> TensorBlockDesc;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(this->srcCoeff(index));
-  }
-
-  template <int StoreMode>
-  EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      this->coeffRef(index + i) = values[i];
-    }
-  }
-
-  template <typename TensorBlock>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writeBlock(const TensorBlockDesc& desc, const TensorBlock& block) {
-    eigen_assert(this->m_impl.data() != NULL);
-
-    typedef internal::TensorBlockIO<ScalarNoConst, Index, NumDims, Layout> TensorBlockIO;
-    typedef typename TensorBlockIO::Dst TensorBlockIODst;
-    typedef typename TensorBlockIO::Src TensorBlockIOSrc;
-
-    const Scalar* block_buffer = block.data();
-
-    // TODO(ezhulenev): TensorBlockIO should be able to read from any Eigen
-    // expression with coefficient and packet access as `src`.
-    void* mem = NULL;
-    if (block_buffer == NULL) {
-      mem = this->m_device.allocate(desc.size() * sizeof(Scalar));
-      ScalarNoConst* buf = static_cast<ScalarNoConst*>(mem);
-
-      typedef internal::TensorBlockAssignment<ScalarNoConst, NumDims, typename TensorBlock::XprType, Index>
-          TensorBlockAssignment;
-
-      TensorBlockAssignment::Run(
-          TensorBlockAssignment::target(desc.dimensions(), internal::strides<Layout>(desc.dimensions()), buf),
-          block.expr());
-
-      block_buffer = buf;
-    }
-
-    // Read from block.
-    TensorBlockIOSrc src(internal::strides<Layout>(desc.dimensions()), block_buffer);
-
-    // Write to the output buffer.
-    typename TensorBlockIO::Dimensions output_strides(this->m_unshuffledInputStrides);
-    typename TensorBlockIO::Dimensions output_dimensions;
-    for (int i = 0; i < NumDims; ++i) {
-      output_dimensions[this->m_shuffle[i]] = desc.dimension(i);
-    }
-    TensorBlockIODst dst(output_dimensions, output_strides, this->m_impl.data(), this->srcCoeff(desc.offset()));
-
-    // Reorder dimensions according to the shuffle.
-    typename TensorBlockIO::DimensionsMap dst_to_src_dim_map;
-    for (int i = 0; i < NumDims; ++i) {
-      dst_to_src_dim_map[i] = static_cast<int>(this->m_inverseShuffle[i]);
-    }
-    TensorBlockIO::Copy(dst, src, dst_to_src_dim_map);
-
-    // Deallocate temporary buffer used for the block materialization.
-    if (mem != NULL) this->m_device.deallocate(mem);
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_SHUFFLING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorStorage.h b/unsupported/Eigen/src/Tensor/TensorStorage.h
deleted file mode 100644
index 62686ce..0000000
--- a/unsupported/Eigen/src/Tensor/TensorStorage.h
+++ /dev/null
@@ -1,143 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-// Copyright (C) 2014-2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSORSTORAGE_H
-#define EIGEN_CXX11_TENSOR_TENSORSTORAGE_H
-
-#ifdef EIGEN_TENSOR_STORAGE_CTOR_PLUGIN
-#define EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN EIGEN_TENSOR_STORAGE_CTOR_PLUGIN;
-#else
-#define EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN
-#endif
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-/** \internal
- *
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Stores the data of a tensor
- *
- * This class stores the data of fixed-size, dynamic-size or mixed tensors
- * in a way as compact as possible.
- *
- * \sa Tensor
- */
-template <typename T, typename Dimensions, int Options>
-class TensorStorage;
-
-// Pure fixed-size storage
-template <typename T, typename FixedDimensions, int Options_>
-class TensorStorage {
- private:
-  static constexpr std::size_t Size = FixedDimensions::total_size;
-
-  // Allocate an array of size at least one to prevent compiler warnings.
-  static constexpr std::size_t MinSize = max_n_1<Size>::size;
-  EIGEN_ALIGN_MAX T m_data[MinSize];
-
- public:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorStorage() {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* data() { return m_data; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T* data() const { return m_data; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const FixedDimensions dimensions() const { return FixedDimensions(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DenseIndex size() const { return Size; }
-};
-
-// pure dynamic
-template <typename T, typename IndexType, int NumIndices_, int Options_>
-class TensorStorage<T, DSizes<IndexType, NumIndices_>, Options_> {
- public:
-  typedef IndexType Index;
-  typedef DSizes<IndexType, NumIndices_> Dimensions;
-  typedef TensorStorage<T, DSizes<IndexType, NumIndices_>, Options_> Self;
-
-  EIGEN_DEVICE_FUNC TensorStorage() : m_data(0), m_dimensions() {
-    if (NumIndices_ == 0) {
-      m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(1);
-    }
-  }
-  EIGEN_DEVICE_FUNC TensorStorage(Index size, const array<Index, NumIndices_>& dimensions)
-      : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size)), m_dimensions(dimensions) {
-    EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN
-  }
-
-  template <typename... DenseIndex>
-  EIGEN_DEVICE_FUNC TensorStorage(DenseIndex... indices) : m_dimensions(indices...) {
-    m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(internal::array_prod(m_dimensions));
-  }
-
-  EIGEN_DEVICE_FUNC TensorStorage(const Self& other)
-      : m_data(internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(
-            internal::array_prod(other.m_dimensions))),
-        m_dimensions(other.m_dimensions) {
-    internal::smart_copy(other.m_data, other.m_data + internal::array_prod(other.m_dimensions), m_data);
-  }
-  EIGEN_DEVICE_FUNC Self& operator=(const Self& other) {
-    if (this != &other) {
-      Self tmp(other);
-      this->swap(tmp);
-    }
-    return *this;
-  }
-
-  EIGEN_DEVICE_FUNC TensorStorage(Self&& other) : TensorStorage() { *this = std::move(other); }
-
-  EIGEN_DEVICE_FUNC Self& operator=(Self&& other) {
-    numext::swap(m_data, other.m_data);
-    numext::swap(m_dimensions, other.m_dimensions);
-    return *this;
-  }
-
-  EIGEN_DEVICE_FUNC ~TensorStorage() {
-    internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data,
-                                                                              internal::array_prod(m_dimensions));
-  }
-  EIGEN_DEVICE_FUNC void swap(Self& other) {
-    numext::swap(m_data, other.m_data);
-    numext::swap(m_dimensions, other.m_dimensions);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_DEVICE_FUNC void resize(Index size, const array<Index, NumIndices_>& nbDimensions) {
-    const Index currentSz = internal::array_prod(m_dimensions);
-    if (size != currentSz) {
-      internal::conditional_aligned_delete_auto<T, (Options_ & DontAlign) == 0>(m_data, currentSz);
-      if (size)
-        m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(size);
-      else if (NumIndices_ == 0) {
-        m_data = internal::conditional_aligned_new_auto<T, (Options_ & DontAlign) == 0>(1);
-      } else
-        m_data = 0;
-      EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
-    }
-    m_dimensions = nbDimensions;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T* data() { return m_data; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const T* data() const { return m_data; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_dimensions.TotalSize(); }
-
- private:
-  T* m_data;
-  Dimensions m_dimensions;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSORSTORAGE_H
diff --git a/unsupported/Eigen/src/Tensor/TensorStriding.h b/unsupported/Eigen/src/Tensor/TensorStriding.h
deleted file mode 100644
index eee7c9b..0000000
--- a/unsupported/Eigen/src/Tensor/TensorStriding.h
+++ /dev/null
@@ -1,312 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_STRIDING_H
-#define EIGEN_CXX11_TENSOR_TENSOR_STRIDING_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Strides, typename XprType>
-struct traits<TensorStridingOp<Strides, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <typename Strides, typename XprType>
-struct eval<TensorStridingOp<Strides, XprType>, Eigen::Dense> {
-  typedef const TensorStridingOp<Strides, XprType> EIGEN_DEVICE_REF type;
-};
-
-template <typename Strides, typename XprType>
-struct nested<TensorStridingOp<Strides, XprType>, 1, typename eval<TensorStridingOp<Strides, XprType> >::type> {
-  typedef TensorStridingOp<Strides, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor striding class.
- */
-template <typename Strides, typename XprType>
-class TensorStridingOp : public TensorBase<TensorStridingOp<Strides, XprType> > {
- public:
-  typedef TensorBase<TensorStridingOp<Strides, XprType> > Base;
-  typedef typename Eigen::internal::traits<TensorStridingOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorStridingOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorStridingOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorStridingOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorStridingOp(const XprType& expr, const Strides& dims)
-      : m_xpr(expr), m_dims(dims) {}
-
-  EIGEN_DEVICE_FUNC const Strides& strides() const { return m_dims; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
-  EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorStridingOp)
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Strides m_dims;
-};
-
-// Eval as rvalue
-template <typename Strides, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorStridingOp<Strides, ArgType>, Device> {
-  typedef TensorStridingOp<Strides, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {
-    m_dimensions = m_impl.dimensions();
-    for (int i = 0; i < NumDims; ++i) {
-      m_dimensions[i] = Eigen::numext::ceil(static_cast<float>(m_dimensions[i]) / op.strides()[i]);
-    }
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_outputStrides[0] = 1;
-      m_inputStrides[0] = 1;
-      for (int i = 1; i < NumDims; ++i) {
-        m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-        m_inputStrides[i] = m_inputStrides[i - 1] * input_dims[i - 1];
-        m_inputStrides[i - 1] *= op.strides()[i - 1];
-      }
-      m_inputStrides[NumDims - 1] *= op.strides()[NumDims - 1];
-    } else {  // RowMajor
-      m_outputStrides[NumDims - 1] = 1;
-      m_inputStrides[NumDims - 1] = 1;
-      for (int i = NumDims - 2; i >= 0; --i) {
-        m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-        m_inputStrides[i] = m_inputStrides[i + 1] * input_dims[i + 1];
-        m_inputStrides[i + 1] *= op.strides()[i + 1];
-      }
-      m_inputStrides[0] *= op.strides()[0];
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    return m_impl.coeff(srcCoeff(index));
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    Index inputIndices[] = {0, 0};
-    Index indices[] = {index, index + PacketSize - 1};
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx0 = indices[0] / m_outputStrides[i];
-        const Index idx1 = indices[1] / m_outputStrides[i];
-        inputIndices[0] += idx0 * m_inputStrides[i];
-        inputIndices[1] += idx1 * m_inputStrides[i];
-        indices[0] -= idx0 * m_outputStrides[i];
-        indices[1] -= idx1 * m_outputStrides[i];
-      }
-      inputIndices[0] += indices[0] * m_inputStrides[0];
-      inputIndices[1] += indices[1] * m_inputStrides[0];
-    } else {  // RowMajor
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx0 = indices[0] / m_outputStrides[i];
-        const Index idx1 = indices[1] / m_outputStrides[i];
-        inputIndices[0] += idx0 * m_inputStrides[i];
-        inputIndices[1] += idx1 * m_inputStrides[i];
-        indices[0] -= idx0 * m_outputStrides[i];
-        indices[1] -= idx1 * m_outputStrides[i];
-      }
-      inputIndices[0] += indices[0] * m_inputStrides[NumDims - 1];
-      inputIndices[1] += indices[1] * m_inputStrides[NumDims - 1];
-    }
-    if (inputIndices[1] - inputIndices[0] == PacketSize - 1) {
-      PacketReturnType rslt = m_impl.template packet<Unaligned>(inputIndices[0]);
-      return rslt;
-    } else {
-      EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-      values[0] = m_impl.coeff(inputIndices[0]);
-      values[PacketSize - 1] = m_impl.coeff(inputIndices[1]);
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < PacketSize - 1; ++i) {
-        values[i] = coeff(index + i);
-      }
-      PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-      return rslt;
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    double compute_cost = (NumDims - 1) * (TensorOpCost::AddCost<Index>() + TensorOpCost::MulCost<Index>() +
-                                           TensorOpCost::DivCost<Index>()) +
-                          TensorOpCost::MulCost<Index>();
-    if (vectorized) {
-      compute_cost *= 2;  // packet() computes two indices
-    }
-    const int innerDim = (static_cast<int>(Layout) == static_cast<int>(ColMajor)) ? 0 : (NumDims - 1);
-    return m_impl.costPerCoeff(vectorized && m_inputStrides[innerDim] == 1) +
-           // Computation is not vectorized per se, but it is done once per packet.
-           TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC typename Storage::Type data() const { return NULL; }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index srcCoeff(Index index) const {
-    Index inputIndex = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx = index / m_outputStrides[i];
-        inputIndex += idx * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      inputIndex += index * m_inputStrides[0];
-    } else {  // RowMajor
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx = index / m_outputStrides[i];
-        inputIndex += idx * m_inputStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      inputIndex += index * m_inputStrides[NumDims - 1];
-    }
-    return inputIndex;
-  }
-
-  Dimensions m_dimensions;
-  array<Index, NumDims> m_outputStrides;
-  array<Index, NumDims> m_inputStrides;
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-// Eval as lvalue
-template <typename Strides, typename ArgType, typename Device>
-struct TensorEvaluator<TensorStridingOp<Strides, ArgType>, Device>
-    : public TensorEvaluator<const TensorStridingOp<Strides, ArgType>, Device> {
-  typedef TensorStridingOp<Strides, ArgType> XprType;
-  typedef TensorEvaluator<const XprType, Device> Base;
-  static constexpr int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    PreferBlockAccess = false,
-    CoordAccess = false,  // to be implemented
-    RawAccess = false
-  };
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {}
-
-  typedef typename XprType::Index Index;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) const {
-    return this->m_impl.coeffRef(this->srcCoeff(index));
-  }
-
-  template <int StoreMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void writePacket(Index index, const PacketReturnType& x) const {
-    EIGEN_STATIC_ASSERT((PacketSize > 1), YOU_MADE_A_PROGRAMMING_MISTAKE)
-    eigen_assert(index + PacketSize - 1 < this->dimensions().TotalSize());
-
-    Index inputIndices[] = {0, 0};
-    Index indices[] = {index, index + PacketSize - 1};
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      EIGEN_UNROLL_LOOP
-      for (int i = NumDims - 1; i > 0; --i) {
-        const Index idx0 = indices[0] / this->m_outputStrides[i];
-        const Index idx1 = indices[1] / this->m_outputStrides[i];
-        inputIndices[0] += idx0 * this->m_inputStrides[i];
-        inputIndices[1] += idx1 * this->m_inputStrides[i];
-        indices[0] -= idx0 * this->m_outputStrides[i];
-        indices[1] -= idx1 * this->m_outputStrides[i];
-      }
-      inputIndices[0] += indices[0] * this->m_inputStrides[0];
-      inputIndices[1] += indices[1] * this->m_inputStrides[0];
-    } else {  // RowMajor
-      EIGEN_UNROLL_LOOP
-      for (int i = 0; i < NumDims - 1; ++i) {
-        const Index idx0 = indices[0] / this->m_outputStrides[i];
-        const Index idx1 = indices[1] / this->m_outputStrides[i];
-        inputIndices[0] += idx0 * this->m_inputStrides[i];
-        inputIndices[1] += idx1 * this->m_inputStrides[i];
-        indices[0] -= idx0 * this->m_outputStrides[i];
-        indices[1] -= idx1 * this->m_outputStrides[i];
-      }
-      inputIndices[0] += indices[0] * this->m_inputStrides[NumDims - 1];
-      inputIndices[1] += indices[1] * this->m_inputStrides[NumDims - 1];
-    }
-    if (inputIndices[1] - inputIndices[0] == PacketSize - 1) {
-      this->m_impl.template writePacket<Unaligned>(inputIndices[0], x);
-    } else {
-      EIGEN_ALIGN_MAX Scalar values[PacketSize];
-      internal::pstore<Scalar, PacketReturnType>(values, x);
-      this->m_impl.coeffRef(inputIndices[0]) = values[0];
-      this->m_impl.coeffRef(inputIndices[1]) = values[PacketSize - 1];
-      EIGEN_UNROLL_LOOP
-      for (int i = 1; i < PacketSize - 1; ++i) {
-        this->coeffRef(index + i) = values[i];
-      }
-    }
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_STRIDING_H
diff --git a/unsupported/Eigen/src/Tensor/TensorTrace.h b/unsupported/Eigen/src/Tensor/TensorTrace.h
deleted file mode 100644
index 5357a48..0000000
--- a/unsupported/Eigen/src/Tensor/TensorTrace.h
+++ /dev/null
@@ -1,281 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2017 Gagan Goel <gagan.nith@gmail.com>
-// Copyright (C) 2017 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_TRACE_H
-#define EIGEN_CXX11_TENSOR_TENSOR_TRACE_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-template <typename Dims, typename XprType>
-struct traits<TensorTraceOp<Dims, XprType> > : public traits<XprType> {
-  typedef typename XprType::Scalar Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions - array_size<Dims>::value;
-  static constexpr int Layout = XprTraits::Layout;
-  enum {
-    // Trace is read-only.
-    Flags = traits<XprType>::Flags & ~LvalueBit
-  };
-};
-
-template <typename Dims, typename XprType>
-struct eval<TensorTraceOp<Dims, XprType>, Eigen::Dense> {
-  typedef const TensorTraceOp<Dims, XprType>& type;
-};
-
-template <typename Dims, typename XprType>
-struct nested<TensorTraceOp<Dims, XprType>, 1, typename eval<TensorTraceOp<Dims, XprType> >::type> {
-  typedef TensorTraceOp<Dims, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Tensor Trace class.
- */
-template <typename Dims, typename XprType>
-class TensorTraceOp : public TensorBase<TensorTraceOp<Dims, XprType> > {
- public:
-  typedef typename Eigen::internal::traits<TensorTraceOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorTraceOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorTraceOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorTraceOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorTraceOp(const XprType& expr, const Dims& dims)
-      : m_xpr(expr), m_dims(dims) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dims& dims() const { return m_dims; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const internal::remove_all_t<typename XprType::Nested>& expression() const {
-    return m_xpr;
-  }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const Dims m_dims;
-};
-
-// Eval as rvalue
-template <typename Dims, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorTraceOp<Dims, ArgType>, Device> {
-  typedef TensorTraceOp<Dims, ArgType> XprType;
-  static constexpr int NumInputDims =
-      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  static constexpr int NumReducedDims = internal::array_size<Dims>::value;
-  static constexpr int NumOutputDims = NumInputDims - NumReducedDims;
-  typedef typename XprType::Index Index;
-  typedef DSizes<Index, NumOutputDims> Dimensions;
-  typedef typename XprType::Scalar Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = internal::unpacket_traits<PacketReturnType>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
-      : m_impl(op.expression(), device), m_traceDim(1), m_device(device) {
-    EIGEN_STATIC_ASSERT((NumOutputDims >= 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT((NumReducedDims >= 2) || ((NumReducedDims == 0) && (NumInputDims == 0)),
-                        YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    for (int i = 0; i < NumInputDims; ++i) {
-      m_reduced[i] = false;
-    }
-
-    const Dims& op_dims = op.dims();
-    for (int i = 0; i < NumReducedDims; ++i) {
-      eigen_assert(op_dims[i] >= 0);
-      eigen_assert(op_dims[i] < NumInputDims);
-      m_reduced[op_dims[i]] = true;
-    }
-
-    // All the dimensions should be distinct to compute the trace
-    int num_distinct_reduce_dims = 0;
-    for (int i = 0; i < NumInputDims; ++i) {
-      if (m_reduced[i]) {
-        ++num_distinct_reduce_dims;
-      }
-    }
-
-    EIGEN_ONLY_USED_FOR_DEBUG(num_distinct_reduce_dims);
-    eigen_assert(num_distinct_reduce_dims == NumReducedDims);
-
-    // Compute the dimensions of the result.
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-
-    int output_index = 0;
-    int reduced_index = 0;
-    for (int i = 0; i < NumInputDims; ++i) {
-      if (m_reduced[i]) {
-        m_reducedDims[reduced_index] = input_dims[i];
-        if (reduced_index > 0) {
-          // All the trace dimensions must have the same size
-          eigen_assert(m_reducedDims[0] == m_reducedDims[reduced_index]);
-        }
-        ++reduced_index;
-      } else {
-        m_dimensions[output_index] = input_dims[i];
-        ++output_index;
-      }
-    }
-
-    if (NumReducedDims != 0) {
-      m_traceDim = m_reducedDims[0];
-    }
-
-    // Compute the output strides
-    if (NumOutputDims > 0) {
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        m_outputStrides[0] = 1;
-        for (int i = 1; i < NumOutputDims; ++i) {
-          m_outputStrides[i] = m_outputStrides[i - 1] * m_dimensions[i - 1];
-        }
-      } else {
-        m_outputStrides.back() = 1;
-        for (int i = NumOutputDims - 2; i >= 0; --i) {
-          m_outputStrides[i] = m_outputStrides[i + 1] * m_dimensions[i + 1];
-        }
-      }
-    }
-
-    // Compute the input strides
-    if (NumInputDims > 0) {
-      array<Index, NumInputDims> input_strides;
-      if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-        input_strides[0] = 1;
-        for (int i = 1; i < NumInputDims; ++i) {
-          input_strides[i] = input_strides[i - 1] * input_dims[i - 1];
-        }
-      } else {
-        input_strides.back() = 1;
-        for (int i = NumInputDims - 2; i >= 0; --i) {
-          input_strides[i] = input_strides[i + 1] * input_dims[i + 1];
-        }
-      }
-
-      output_index = 0;
-      reduced_index = 0;
-      for (int i = 0; i < NumInputDims; ++i) {
-        if (m_reduced[i]) {
-          m_reducedStrides[reduced_index] = input_strides[i];
-          ++reduced_index;
-        } else {
-          m_preservedStrides[output_index] = input_strides[i];
-          ++output_index;
-        }
-      }
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return nullptr; }
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    // Initialize the result
-    CoeffReturnType result = internal::cast<int, CoeffReturnType>(0);
-    Index index_stride = 0;
-    for (int i = 0; i < NumReducedDims; ++i) {
-      index_stride += m_reducedStrides[i];
-    }
-
-    // If trace is requested along all dimensions, starting index would be 0
-    Index cur_index = 0;
-    if (NumOutputDims != 0) cur_index = firstInput(index);
-    for (Index i = 0; i < m_traceDim; ++i) {
-      result += m_impl.coeff(cur_index);
-      cur_index += index_stride;
-    }
-
-    return result;
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType result = internal::ploadt<PacketReturnType, LoadMode>(values);
-    return result;
-  }
-
- protected:
-  // Given the output index, finds the first index in the input tensor used to compute the trace
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index firstInput(Index index) const {
-    Index startInput = 0;
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      for (int i = NumOutputDims - 1; i > 0; --i) {
-        const Index idx = index / m_outputStrides[i];
-        startInput += idx * m_preservedStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      startInput += index * m_preservedStrides[0];
-    } else {
-      for (int i = 0; i < NumOutputDims - 1; ++i) {
-        const Index idx = index / m_outputStrides[i];
-        startInput += idx * m_preservedStrides[i];
-        index -= idx * m_outputStrides[i];
-      }
-      startInput += index * m_preservedStrides[NumOutputDims - 1];
-    }
-    return startInput;
-  }
-
-  Dimensions m_dimensions;
-  TensorEvaluator<ArgType, Device> m_impl;
-  // Initialize the size of the trace dimension
-  Index m_traceDim;
-  const Device EIGEN_DEVICE_REF m_device;
-  array<bool, NumInputDims> m_reduced;
-  array<Index, NumReducedDims> m_reducedDims;
-  array<Index, NumOutputDims> m_outputStrides;
-  array<Index, NumReducedDims> m_reducedStrides;
-  array<Index, NumOutputDims> m_preservedStrides;
-};
-
-}  // End namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_TRACE_H
diff --git a/unsupported/Eigen/src/Tensor/TensorTraits.h b/unsupported/Eigen/src/Tensor/TensorTraits.h
deleted file mode 100644
index 5c97d52..0000000
--- a/unsupported/Eigen/src/Tensor/TensorTraits.h
+++ /dev/null
@@ -1,232 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_TRAITS_H
-#define EIGEN_CXX11_TENSOR_TENSOR_TRAITS_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-template <typename Scalar, int Options>
-class compute_tensor_flags {
-  enum {
-    is_dynamic_size_storage = 1,
-
-    is_aligned = (((Options & DontAlign) == 0) && (
-#if EIGEN_MAX_STATIC_ALIGN_BYTES > 0
-                                                      (!is_dynamic_size_storage)
-#else
-                                                      0
-#endif
-                                                      |
-#if EIGEN_MAX_ALIGN_BYTES > 0
-                                                      is_dynamic_size_storage
-#else
-                                                      0
-#endif
-                                                      )),
-    packet_access_bit = packet_traits<Scalar>::Vectorizable && is_aligned ? PacketAccessBit : 0
-  };
-
- public:
-  enum { ret = packet_access_bit };
-};
-
-template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
-struct traits<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {
-  typedef Scalar_ Scalar;
-  typedef Dense StorageKind;
-  typedef IndexType_ Index;
-  static constexpr int NumDimensions = NumIndices_;
-  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
-  enum {
-    Options = Options_,
-    Flags = compute_tensor_flags<Scalar_, Options_>::ret | (is_const<Scalar_>::value ? 0 : LvalueBit)
-  };
-  template <typename T>
-  struct MakePointer {
-    typedef T* Type;
-  };
-  typedef typename MakePointer<Scalar>::Type PointerType;
-};
-
-template <typename Scalar_, typename Dimensions, int Options_, typename IndexType_>
-struct traits<TensorFixedSize<Scalar_, Dimensions, Options_, IndexType_> > {
-  typedef Scalar_ Scalar;
-  typedef Dense StorageKind;
-  typedef IndexType_ Index;
-  static constexpr int NumDimensions = array_size<Dimensions>::value;
-  static constexpr int Layout = Options_ & RowMajor ? RowMajor : ColMajor;
-  enum {
-    Options = Options_,
-    Flags = compute_tensor_flags<Scalar_, Options_>::ret | (is_const<Scalar_>::value ? 0 : LvalueBit)
-  };
-  template <typename T>
-  struct MakePointer {
-    typedef T* Type;
-  };
-  typedef typename MakePointer<Scalar>::Type PointerType;
-};
-
-template <typename PlainObjectType, int Options_, template <class> class MakePointer_>
-struct traits<TensorMap<PlainObjectType, Options_, MakePointer_> > : public traits<PlainObjectType> {
-  typedef traits<PlainObjectType> BaseTraits;
-  typedef typename BaseTraits::Scalar Scalar;
-  typedef typename BaseTraits::StorageKind StorageKind;
-  typedef typename BaseTraits::Index Index;
-  static constexpr int NumDimensions = BaseTraits::NumDimensions;
-  static constexpr int Layout = BaseTraits::Layout;
-  enum { Options = Options_, Flags = BaseTraits::Flags };
-  template <class T>
-  struct MakePointer {
-    // Intermediate typedef to workaround MSVC issue.
-    typedef MakePointer_<T> MakePointerT;
-    typedef typename MakePointerT::Type Type;
-  };
-  typedef typename MakePointer<Scalar>::Type PointerType;
-};
-
-template <typename PlainObjectType_>
-struct traits<TensorRef<PlainObjectType_> > : public traits<PlainObjectType_> {
-  typedef PlainObjectType_ PlainObjectType;
-  typedef traits<PlainObjectType> BaseTraits;
-  typedef typename BaseTraits::Scalar Scalar;
-  typedef typename BaseTraits::StorageKind StorageKind;
-  typedef typename BaseTraits::Index Index;
-  static constexpr int NumDimensions = BaseTraits::NumDimensions;
-  static constexpr int Layout = BaseTraits::Layout;
-  enum { Options = BaseTraits::Options, Flags = BaseTraits::Flags };
-  typedef typename BaseTraits::PointerType PointerType;
-};
-
-template <typename Scalar_, int NumIndices_, int Options, typename IndexType_>
-struct eval<Tensor<Scalar_, NumIndices_, Options, IndexType_>, Eigen::Dense> {
-  typedef const Tensor<Scalar_, NumIndices_, Options, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename Scalar_, int NumIndices_, int Options, typename IndexType_>
-struct eval<const Tensor<Scalar_, NumIndices_, Options, IndexType_>, Eigen::Dense> {
-  typedef const Tensor<Scalar_, NumIndices_, Options, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
-struct eval<TensorFixedSize<Scalar_, Dimensions, Options, IndexType_>, Eigen::Dense> {
-  typedef const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
-struct eval<const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_>, Eigen::Dense> {
-  typedef const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename PlainObjectType, int Options, template <class> class MakePointer>
-struct eval<TensorMap<PlainObjectType, Options, MakePointer>, Eigen::Dense> {
-  typedef const TensorMap<PlainObjectType, Options, MakePointer> EIGEN_DEVICE_REF type;
-};
-
-template <typename PlainObjectType, int Options, template <class> class MakePointer>
-struct eval<const TensorMap<PlainObjectType, Options, MakePointer>, Eigen::Dense> {
-  typedef const TensorMap<PlainObjectType, Options, MakePointer> EIGEN_DEVICE_REF type;
-};
-
-template <typename PlainObjectType>
-struct eval<TensorRef<PlainObjectType>, Eigen::Dense> {
-  typedef const TensorRef<PlainObjectType> EIGEN_DEVICE_REF type;
-};
-
-template <typename PlainObjectType>
-struct eval<const TensorRef<PlainObjectType>, Eigen::Dense> {
-  typedef const TensorRef<PlainObjectType> EIGEN_DEVICE_REF type;
-};
-
-// TODO: nested<> does not exist anymore in Eigen/Core, and should be removed in favor of ref_selector.
-template <typename T, int n = 1, typename PlainObject = void>
-struct nested {
-  typedef typename ref_selector<T>::type type;
-};
-
-template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
-struct nested<Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {
-  typedef const Tensor<Scalar_, NumIndices_, Options_, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename Scalar_, int NumIndices_, int Options_, typename IndexType_>
-struct nested<const Tensor<Scalar_, NumIndices_, Options_, IndexType_> > {
-  typedef const Tensor<Scalar_, NumIndices_, Options_, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
-struct nested<TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> > {
-  typedef const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename Scalar_, typename Dimensions, int Options, typename IndexType_>
-struct nested<const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> > {
-  typedef const TensorFixedSize<Scalar_, Dimensions, Options, IndexType_> EIGEN_DEVICE_REF type;
-};
-
-template <typename PlainObjectType>
-struct nested<TensorRef<PlainObjectType> > {
-  typedef const TensorRef<PlainObjectType> EIGEN_DEVICE_REF type;
-};
-
-template <typename PlainObjectType>
-struct nested<const TensorRef<PlainObjectType> > {
-  typedef const TensorRef<PlainObjectType> EIGEN_DEVICE_REF type;
-};
-
-}  // end namespace internal
-
-// Convolutional layers take in an input tensor of shape (D, R, C, B), or (D, C,
-// R, B), and convolve it with a set of filters, which can also be presented as
-// a tensor (D, K, K, M), where M is the number of filters, K is the filter
-// size, and each 3-dimensional tensor of size (D, K, K) is a filter. For
-// simplicity we assume that we always use square filters (which is usually the
-// case in images), hence the two Ks in the tensor dimension.  It also takes in
-// a few additional parameters:
-// Stride (S): The convolution stride is the offset between locations where we
-//             apply the filters.  A larger stride means that the output will be
-//             spatially smaller.
-// Padding (P): The padding we apply to the input tensor along the R and C
-//              dimensions.  This is usually used to make sure that the spatial
-//              dimensions of the output matches our intention.
-//
-// Two types of padding are often used:
-//   SAME: The pad value is computed so that the output will have size
-//         R/S and C/S.
-//   VALID: no padding is carried out.
-// When we do padding, the padded values at the padded locations are usually
-// zero.
-//
-// The output dimensions for convolution, when given all the parameters above,
-// are as follows:
-// When Padding = SAME: the output size is (B, R', C', M), where
-//   R' = ceil(float(R) / float(S))
-//   C' = ceil(float(C) / float(S))
-// where ceil is the ceiling function.  The input tensor is padded with 0 as
-// needed.  The number of padded rows and columns are computed as:
-//   Pr = ((R' - 1) * S + K - R) / 2
-//   Pc = ((C' - 1) * S + K - C) / 2
-// when the stride is 1, we have the simplified case R'=R, C'=C, Pr=Pc=(K-1)/2.
-// This is where SAME comes from - the output has the same size as the input has.
-// When Padding = VALID: the output size is computed as
-//   R' = ceil(float(R - K + 1) / float(S))
-//   C' = ceil(float(C - K + 1) / float(S))
-// and the number of padded rows and columns are computed in the same way as in
-// the SAME case.
-// When the stride is 1, we have the simplified case R'=R-K+1, C'=C-K+1, Pr=0,
-// Pc=0.
-enum PaddingType { PADDING_VALID = 1, PADDING_SAME = 2 };
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_TRAITS_H
diff --git a/unsupported/Eigen/src/Tensor/TensorUInt128.h b/unsupported/Eigen/src/Tensor/TensorUInt128.h
deleted file mode 100644
index 99e51c5..0000000
--- a/unsupported/Eigen/src/Tensor/TensorUInt128.h
+++ /dev/null
@@ -1,229 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_UINT128_H
-#define EIGEN_CXX11_TENSOR_TENSOR_UINT128_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-namespace internal {
-
-template <uint64_t n>
-struct static_val {
-  static const uint64_t value = n;
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE operator uint64_t() const { return n; }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static_val() {}
-
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static_val(const T& v) {
-    EIGEN_UNUSED_VARIABLE(v);
-    eigen_assert(v == n);
-  }
-};
-
-template <typename HIGH = uint64_t, typename LOW = uint64_t>
-struct TensorUInt128 {
-  HIGH high;
-  LOW low;
-
-  template <typename OTHER_HIGH, typename OTHER_LOW>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128(const TensorUInt128<OTHER_HIGH, OTHER_LOW>& other)
-      : high(other.high), low(other.low) {
-    EIGEN_STATIC_ASSERT(sizeof(OTHER_HIGH) <= sizeof(HIGH), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT(sizeof(OTHER_LOW) <= sizeof(LOW), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  }
-
-  template <typename OTHER_HIGH, typename OTHER_LOW>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128& operator=(const TensorUInt128<OTHER_HIGH, OTHER_LOW>& other) {
-    EIGEN_STATIC_ASSERT(sizeof(OTHER_HIGH) <= sizeof(HIGH), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    EIGEN_STATIC_ASSERT(sizeof(OTHER_LOW) <= sizeof(LOW), YOU_MADE_A_PROGRAMMING_MISTAKE);
-    high = other.high;
-    low = other.low;
-    return *this;
-  }
-
-  template <typename T>
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE explicit TensorUInt128(const T& x) : high(0), low(x) {
-    eigen_assert(
-        (static_cast<std::conditional_t<sizeof(T) == 8, uint64_t, uint32_t>>(x) <= NumTraits<uint64_t>::highest()));
-    eigen_assert(x >= 0);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128(HIGH y, LOW x) : high(y), low(x) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE operator LOW() const { return low; }
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE LOW lower() const { return low; }
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE HIGH upper() const { return high; }
-};
-
-template <typename HL, typename LL, typename HR, typename LR>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator==(const TensorUInt128<HL, LL>& lhs,
-                                                      const TensorUInt128<HR, LR>& rhs) {
-  return (lhs.high == rhs.high) && (lhs.low == rhs.low);
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator!=(const TensorUInt128<HL, LL>& lhs,
-                                                      const TensorUInt128<HR, LR>& rhs) {
-  return (lhs.high != rhs.high) || (lhs.low != rhs.low);
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator>=(const TensorUInt128<HL, LL>& lhs,
-                                                      const TensorUInt128<HR, LR>& rhs) {
-  if (lhs.high != rhs.high) {
-    return lhs.high > rhs.high;
-  }
-  return lhs.low >= rhs.low;
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE bool operator<(const TensorUInt128<HL, LL>& lhs,
-                                                     const TensorUInt128<HR, LR>& rhs) {
-  if (lhs.high != rhs.high) {
-    return lhs.high < rhs.high;
-  }
-  return lhs.low < rhs.low;
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128<uint64_t, uint64_t> operator+(const TensorUInt128<HL, LL>& lhs,
-                                                                                  const TensorUInt128<HR, LR>& rhs) {
-  TensorUInt128<uint64_t, uint64_t> result(lhs.high + rhs.high, lhs.low + rhs.low);
-  if (result.low < rhs.low) {
-    result.high += 1;
-  }
-  return result;
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE TensorUInt128<uint64_t, uint64_t> operator-(const TensorUInt128<HL, LL>& lhs,
-                                                                                  const TensorUInt128<HR, LR>& rhs) {
-  TensorUInt128<uint64_t, uint64_t> result(lhs.high - rhs.high, lhs.low - rhs.low);
-  if (result.low > lhs.low) {
-    result.high -= 1;
-  }
-  return result;
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128<uint64_t, uint64_t> operator*(
-    const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs) {
-  // Split each 128-bit integer into 4 32-bit integers, and then do the
-  // multiplications by hand as follow:
-  //   lhs      a  b  c  d
-  //   rhs      e  f  g  h
-  //           -----------
-  //           ah bh ch dh
-  //           bg cg dg
-  //           cf df
-  //           de
-  // The result is stored in 2 64bit integers, high and low.
-
-  const uint64_t LOW = 0x00000000FFFFFFFFLL;
-  const uint64_t HIGH = 0xFFFFFFFF00000000LL;
-
-  uint64_t d = lhs.low & LOW;
-  uint64_t c = (lhs.low & HIGH) >> 32LL;
-  uint64_t b = lhs.high & LOW;
-  uint64_t a = (lhs.high & HIGH) >> 32LL;
-
-  uint64_t h = rhs.low & LOW;
-  uint64_t g = (rhs.low & HIGH) >> 32LL;
-  uint64_t f = rhs.high & LOW;
-  uint64_t e = (rhs.high & HIGH) >> 32LL;
-
-  // Compute the low 32 bits of low
-  uint64_t acc = d * h;
-  uint64_t low = acc & LOW;
-  //  Compute the high 32 bits of low. Add a carry every time we wrap around
-  acc >>= 32LL;
-  uint64_t carry = 0;
-  uint64_t acc2 = acc + c * h;
-  if (acc2 < acc) {
-    carry++;
-  }
-  acc = acc2 + d * g;
-  if (acc < acc2) {
-    carry++;
-  }
-  low |= (acc << 32LL);
-
-  // Carry forward the high bits of acc to initiate the computation of the
-  // low 32 bits of high
-  acc2 = (acc >> 32LL) | (carry << 32LL);
-  carry = 0;
-
-  acc = acc2 + b * h;
-  if (acc < acc2) {
-    carry++;
-  }
-  acc2 = acc + c * g;
-  if (acc2 < acc) {
-    carry++;
-  }
-  acc = acc2 + d * f;
-  if (acc < acc2) {
-    carry++;
-  }
-  uint64_t high = acc & LOW;
-
-  // Start to compute the high 32 bits of high.
-  acc2 = (acc >> 32LL) | (carry << 32LL);
-
-  acc = acc2 + a * h;
-  acc2 = acc + b * g;
-  acc = acc2 + c * f;
-  acc2 = acc + d * e;
-  high |= (acc2 << 32LL);
-
-  return TensorUInt128<uint64_t, uint64_t>(high, low);
-}
-
-template <typename HL, typename LL, typename HR, typename LR>
-static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128<uint64_t, uint64_t> operator/(
-    const TensorUInt128<HL, LL>& lhs, const TensorUInt128<HR, LR>& rhs) {
-  if (rhs == TensorUInt128<static_val<0>, static_val<1>>(1)) {
-    return TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
-  } else if (lhs < rhs) {
-    return TensorUInt128<uint64_t, uint64_t>(0);
-  } else {
-    // calculate the biggest power of 2 times rhs that's less than or equal to lhs
-    TensorUInt128<uint64_t, uint64_t> power2(1);
-    TensorUInt128<uint64_t, uint64_t> d(rhs);
-    TensorUInt128<uint64_t, uint64_t> tmp(lhs - d);
-    while (lhs >= d) {
-      tmp = tmp - d;
-      d = d + d;
-      power2 = power2 + power2;
-    }
-
-    tmp = TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
-    TensorUInt128<uint64_t, uint64_t> result(0);
-    while (power2 != TensorUInt128<static_val<0>, static_val<0>>(0)) {
-      if (tmp >= d) {
-        tmp = tmp - d;
-        result = result + power2;
-      }
-      // Shift right
-      power2 = TensorUInt128<uint64_t, uint64_t>(power2.high >> 1, (power2.low >> 1) | (power2.high << 63));
-      d = TensorUInt128<uint64_t, uint64_t>(d.high >> 1, (d.low >> 1) | (d.high << 63));
-    }
-
-    return result;
-  }
-}
-
-}  // namespace internal
-}  // namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_UINT128_H
diff --git a/unsupported/Eigen/src/Tensor/TensorVolumePatch.h b/unsupported/Eigen/src/Tensor/TensorVolumePatch.h
deleted file mode 100644
index 61e8b04..0000000
--- a/unsupported/Eigen/src/Tensor/TensorVolumePatch.h
+++ /dev/null
@@ -1,621 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-
-#ifndef EIGEN_CXX11_TENSOR_TENSOR_VOLUME_PATCH_H
-#define EIGEN_CXX11_TENSOR_TENSOR_VOLUME_PATCH_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
-struct traits<TensorVolumePatchOp<Planes, Rows, Cols, XprType> > : public traits<XprType> {
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef traits<XprType> XprTraits;
-  typedef typename XprTraits::StorageKind StorageKind;
-  typedef typename XprTraits::Index Index;
-  typedef typename XprType::Nested Nested;
-  typedef std::remove_reference_t<Nested> Nested_;
-  static constexpr int NumDimensions = XprTraits::NumDimensions + 1;
-  static constexpr int Layout = XprTraits::Layout;
-  typedef typename XprTraits::PointerType PointerType;
-};
-
-template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
-struct eval<TensorVolumePatchOp<Planes, Rows, Cols, XprType>, Eigen::Dense> {
-  typedef const TensorVolumePatchOp<Planes, Rows, Cols, XprType>& type;
-};
-
-template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
-struct nested<TensorVolumePatchOp<Planes, Rows, Cols, XprType>, 1,
-              typename eval<TensorVolumePatchOp<Planes, Rows, Cols, XprType> >::type> {
-  typedef TensorVolumePatchOp<Planes, Rows, Cols, XprType> type;
-};
-
-}  // end namespace internal
-
-/**
- * \ingroup CXX11_Tensor_Module
- *
- * \brief Patch extraction specialized for processing of volumetric data.
- * This assumes that the input has a least 4 dimensions ordered as follows:
- *  - channels
- *  - planes
- *  - rows
- *  - columns
- *  - (optional) additional dimensions such as time or batch size.
- * Calling the volume patch code with patch_planes, patch_rows, and patch_cols
- * is equivalent to calling the regular patch extraction code with parameters
- * d, patch_planes, patch_rows, patch_cols, and 1 for all the additional
- * dimensions.
- */
-template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename XprType>
-class TensorVolumePatchOp : public TensorBase<TensorVolumePatchOp<Planes, Rows, Cols, XprType>, ReadOnlyAccessors> {
- public:
-  typedef typename Eigen::internal::traits<TensorVolumePatchOp>::Scalar Scalar;
-  typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename Eigen::internal::nested<TensorVolumePatchOp>::type Nested;
-  typedef typename Eigen::internal::traits<TensorVolumePatchOp>::StorageKind StorageKind;
-  typedef typename Eigen::internal::traits<TensorVolumePatchOp>::Index Index;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorVolumePatchOp(
-      const XprType& expr, DenseIndex patch_planes, DenseIndex patch_rows, DenseIndex patch_cols,
-      DenseIndex plane_strides, DenseIndex row_strides, DenseIndex col_strides, DenseIndex in_plane_strides,
-      DenseIndex in_row_strides, DenseIndex in_col_strides, DenseIndex plane_inflate_strides,
-      DenseIndex row_inflate_strides, DenseIndex col_inflate_strides, PaddingType padding_type, Scalar padding_value)
-      : m_xpr(expr),
-        m_patch_planes(patch_planes),
-        m_patch_rows(patch_rows),
-        m_patch_cols(patch_cols),
-        m_plane_strides(plane_strides),
-        m_row_strides(row_strides),
-        m_col_strides(col_strides),
-        m_in_plane_strides(in_plane_strides),
-        m_in_row_strides(in_row_strides),
-        m_in_col_strides(in_col_strides),
-        m_plane_inflate_strides(plane_inflate_strides),
-        m_row_inflate_strides(row_inflate_strides),
-        m_col_inflate_strides(col_inflate_strides),
-        m_padding_explicit(false),
-        m_padding_top_z(0),
-        m_padding_bottom_z(0),
-        m_padding_top(0),
-        m_padding_bottom(0),
-        m_padding_left(0),
-        m_padding_right(0),
-        m_padding_type(padding_type),
-        m_padding_value(padding_value) {}
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorVolumePatchOp(
-      const XprType& expr, DenseIndex patch_planes, DenseIndex patch_rows, DenseIndex patch_cols,
-      DenseIndex plane_strides, DenseIndex row_strides, DenseIndex col_strides, DenseIndex in_plane_strides,
-      DenseIndex in_row_strides, DenseIndex in_col_strides, DenseIndex plane_inflate_strides,
-      DenseIndex row_inflate_strides, DenseIndex col_inflate_strides, DenseIndex padding_top_z,
-      DenseIndex padding_bottom_z, DenseIndex padding_top, DenseIndex padding_bottom, DenseIndex padding_left,
-      DenseIndex padding_right, Scalar padding_value)
-      : m_xpr(expr),
-        m_patch_planes(patch_planes),
-        m_patch_rows(patch_rows),
-        m_patch_cols(patch_cols),
-        m_plane_strides(plane_strides),
-        m_row_strides(row_strides),
-        m_col_strides(col_strides),
-        m_in_plane_strides(in_plane_strides),
-        m_in_row_strides(in_row_strides),
-        m_in_col_strides(in_col_strides),
-        m_plane_inflate_strides(plane_inflate_strides),
-        m_row_inflate_strides(row_inflate_strides),
-        m_col_inflate_strides(col_inflate_strides),
-        m_padding_explicit(true),
-        m_padding_top_z(padding_top_z),
-        m_padding_bottom_z(padding_bottom_z),
-        m_padding_top(padding_top),
-        m_padding_bottom(padding_bottom),
-        m_padding_left(padding_left),
-        m_padding_right(padding_right),
-        m_padding_type(PADDING_VALID),
-        m_padding_value(padding_value) {}
-
-  EIGEN_DEVICE_FUNC DenseIndex patch_planes() const { return m_patch_planes; }
-  EIGEN_DEVICE_FUNC DenseIndex patch_rows() const { return m_patch_rows; }
-  EIGEN_DEVICE_FUNC DenseIndex patch_cols() const { return m_patch_cols; }
-  EIGEN_DEVICE_FUNC DenseIndex plane_strides() const { return m_plane_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex row_strides() const { return m_row_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex col_strides() const { return m_col_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex in_plane_strides() const { return m_in_plane_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex in_row_strides() const { return m_in_row_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex in_col_strides() const { return m_in_col_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex plane_inflate_strides() const { return m_plane_inflate_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex row_inflate_strides() const { return m_row_inflate_strides; }
-  EIGEN_DEVICE_FUNC DenseIndex col_inflate_strides() const { return m_col_inflate_strides; }
-  EIGEN_DEVICE_FUNC bool padding_explicit() const { return m_padding_explicit; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_top_z() const { return m_padding_top_z; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_bottom_z() const { return m_padding_bottom_z; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_top() const { return m_padding_top; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_bottom() const { return m_padding_bottom; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_left() const { return m_padding_left; }
-  EIGEN_DEVICE_FUNC DenseIndex padding_right() const { return m_padding_right; }
-  EIGEN_DEVICE_FUNC PaddingType padding_type() const { return m_padding_type; }
-  EIGEN_DEVICE_FUNC Scalar padding_value() const { return m_padding_value; }
-
-  EIGEN_DEVICE_FUNC const internal::remove_all_t<typename XprType::Nested>& expression() const { return m_xpr; }
-
- protected:
-  typename XprType::Nested m_xpr;
-  const DenseIndex m_patch_planes;
-  const DenseIndex m_patch_rows;
-  const DenseIndex m_patch_cols;
-  const DenseIndex m_plane_strides;
-  const DenseIndex m_row_strides;
-  const DenseIndex m_col_strides;
-  const DenseIndex m_in_plane_strides;
-  const DenseIndex m_in_row_strides;
-  const DenseIndex m_in_col_strides;
-  const DenseIndex m_plane_inflate_strides;
-  const DenseIndex m_row_inflate_strides;
-  const DenseIndex m_col_inflate_strides;
-  const bool m_padding_explicit;
-  const DenseIndex m_padding_top_z;
-  const DenseIndex m_padding_bottom_z;
-  const DenseIndex m_padding_top;
-  const DenseIndex m_padding_bottom;
-  const DenseIndex m_padding_left;
-  const DenseIndex m_padding_right;
-  const PaddingType m_padding_type;
-  const Scalar m_padding_value;
-};
-
-// Eval as rvalue
-template <DenseIndex Planes, DenseIndex Rows, DenseIndex Cols, typename ArgType, typename Device>
-struct TensorEvaluator<const TensorVolumePatchOp<Planes, Rows, Cols, ArgType>, Device> {
-  typedef TensorVolumePatchOp<Planes, Rows, Cols, ArgType> XprType;
-  typedef typename XprType::Index Index;
-  static constexpr int NumInputDims =
-      internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
-  static constexpr int NumDims = NumInputDims + 1;
-  typedef DSizes<Index, NumDims> Dimensions;
-  typedef std::remove_const_t<typename XprType::Scalar> Scalar;
-  typedef typename XprType::CoeffReturnType CoeffReturnType;
-  typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
-  static constexpr int PacketSize = PacketType<CoeffReturnType, Device>::size;
-  typedef StorageMemory<CoeffReturnType, Device> Storage;
-  typedef typename Storage::Type EvaluatorPointerType;
-
-  static constexpr int Layout = TensorEvaluator<ArgType, Device>::Layout;
-  enum {
-    IsAligned = false,
-    PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
-    BlockAccess = false,
-    PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
-    CoordAccess = false,
-    RawAccess = false
-  };
-
-  //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
-  typedef internal::TensorBlockNotImplemented TensorBlock;
-  //===--------------------------------------------------------------------===//
-
-  EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) {
-    EIGEN_STATIC_ASSERT((NumDims >= 5), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-    m_paddingValue = op.padding_value();
-
-    const typename TensorEvaluator<ArgType, Device>::Dimensions& input_dims = m_impl.dimensions();
-
-    // Cache a few variables.
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_inputDepth = input_dims[0];
-      m_inputPlanes = input_dims[1];
-      m_inputRows = input_dims[2];
-      m_inputCols = input_dims[3];
-    } else {
-      m_inputDepth = input_dims[NumInputDims - 1];
-      m_inputPlanes = input_dims[NumInputDims - 2];
-      m_inputRows = input_dims[NumInputDims - 3];
-      m_inputCols = input_dims[NumInputDims - 4];
-    }
-
-    m_plane_strides = op.plane_strides();
-    m_row_strides = op.row_strides();
-    m_col_strides = op.col_strides();
-
-    // Input strides and effective input/patch size
-    m_in_plane_strides = op.in_plane_strides();
-    m_in_row_strides = op.in_row_strides();
-    m_in_col_strides = op.in_col_strides();
-    m_plane_inflate_strides = op.plane_inflate_strides();
-    m_row_inflate_strides = op.row_inflate_strides();
-    m_col_inflate_strides = op.col_inflate_strides();
-
-    // The "effective" spatial size after inflating data with zeros.
-    m_input_planes_eff = (m_inputPlanes - 1) * m_plane_inflate_strides + 1;
-    m_input_rows_eff = (m_inputRows - 1) * m_row_inflate_strides + 1;
-    m_input_cols_eff = (m_inputCols - 1) * m_col_inflate_strides + 1;
-    m_patch_planes_eff = op.patch_planes() + (op.patch_planes() - 1) * (m_in_plane_strides - 1);
-    m_patch_rows_eff = op.patch_rows() + (op.patch_rows() - 1) * (m_in_row_strides - 1);
-    m_patch_cols_eff = op.patch_cols() + (op.patch_cols() - 1) * (m_in_col_strides - 1);
-
-    if (op.padding_explicit()) {
-      m_outputPlanes =
-          numext::ceil((m_input_planes_eff + op.padding_top_z() + op.padding_bottom_z() - m_patch_planes_eff + 1.f) /
-                       static_cast<float>(m_plane_strides));
-      m_outputRows = numext::ceil((m_input_rows_eff + op.padding_top() + op.padding_bottom() - m_patch_rows_eff + 1.f) /
-                                  static_cast<float>(m_row_strides));
-      m_outputCols = numext::ceil((m_input_cols_eff + op.padding_left() + op.padding_right() - m_patch_cols_eff + 1.f) /
-                                  static_cast<float>(m_col_strides));
-      m_planePaddingTop = op.padding_top_z();
-      m_rowPaddingTop = op.padding_top();
-      m_colPaddingLeft = op.padding_left();
-    } else {
-      // Computing padding from the type
-      switch (op.padding_type()) {
-        case PADDING_VALID:
-          m_outputPlanes =
-              numext::ceil((m_input_planes_eff - m_patch_planes_eff + 1.f) / static_cast<float>(m_plane_strides));
-          m_outputRows = numext::ceil((m_input_rows_eff - m_patch_rows_eff + 1.f) / static_cast<float>(m_row_strides));
-          m_outputCols = numext::ceil((m_input_cols_eff - m_patch_cols_eff + 1.f) / static_cast<float>(m_col_strides));
-          m_planePaddingTop = 0;
-          m_rowPaddingTop = 0;
-          m_colPaddingLeft = 0;
-          break;
-        case PADDING_SAME: {
-          m_outputPlanes = numext::ceil(m_input_planes_eff / static_cast<float>(m_plane_strides));
-          m_outputRows = numext::ceil(m_input_rows_eff / static_cast<float>(m_row_strides));
-          m_outputCols = numext::ceil(m_input_cols_eff / static_cast<float>(m_col_strides));
-          const Index dz = (m_outputPlanes - 1) * m_plane_strides + m_patch_planes_eff - m_input_planes_eff;
-          const Index dy = (m_outputRows - 1) * m_row_strides + m_patch_rows_eff - m_input_rows_eff;
-          const Index dx = (m_outputCols - 1) * m_col_strides + m_patch_cols_eff - m_input_cols_eff;
-          m_planePaddingTop = dz / 2;
-          m_rowPaddingTop = dy / 2;
-          m_colPaddingLeft = dx / 2;
-          break;
-        }
-        default: {
-          eigen_assert(false && "unexpected padding");
-          return;
-        }
-      }
-    }
-    eigen_assert(m_outputRows > 0);
-    eigen_assert(m_outputCols > 0);
-    eigen_assert(m_outputPlanes > 0);
-
-    // Dimensions for result of extraction.
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      // ColMajor
-      // 0: depth
-      // 1: patch_planes
-      // 2: patch_rows
-      // 3: patch_cols
-      // 4: number of patches
-      // 5 and beyond: anything else (such as batch).
-      m_dimensions[0] = input_dims[0];
-      m_dimensions[1] = op.patch_planes();
-      m_dimensions[2] = op.patch_rows();
-      m_dimensions[3] = op.patch_cols();
-      m_dimensions[4] = m_outputPlanes * m_outputRows * m_outputCols;
-      for (int i = 5; i < NumDims; ++i) {
-        m_dimensions[i] = input_dims[i - 1];
-      }
-    } else {
-      // RowMajor
-      // NumDims-1: depth
-      // NumDims-2: patch_planes
-      // NumDims-3: patch_rows
-      // NumDims-4: patch_cols
-      // NumDims-5: number of patches
-      // NumDims-6 and beyond: anything else (such as batch).
-      m_dimensions[NumDims - 1] = input_dims[NumInputDims - 1];
-      m_dimensions[NumDims - 2] = op.patch_planes();
-      m_dimensions[NumDims - 3] = op.patch_rows();
-      m_dimensions[NumDims - 4] = op.patch_cols();
-      m_dimensions[NumDims - 5] = m_outputPlanes * m_outputRows * m_outputCols;
-      for (int i = NumDims - 6; i >= 0; --i) {
-        m_dimensions[i] = input_dims[i];
-      }
-    }
-
-    // Strides for the output tensor.
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_rowStride = m_dimensions[1];
-      m_colStride = m_dimensions[2] * m_rowStride;
-      m_patchStride = m_colStride * m_dimensions[3] * m_dimensions[0];
-      m_otherStride = m_patchStride * m_dimensions[4];
-    } else {
-      m_rowStride = m_dimensions[NumDims - 2];
-      m_colStride = m_dimensions[NumDims - 3] * m_rowStride;
-      m_patchStride = m_colStride * m_dimensions[NumDims - 4] * m_dimensions[NumDims - 1];
-      m_otherStride = m_patchStride * m_dimensions[NumDims - 5];
-    }
-
-    // Strides for navigating through the input tensor.
-    m_planeInputStride = m_inputDepth;
-    m_rowInputStride = m_inputDepth * m_inputPlanes;
-    m_colInputStride = m_inputDepth * m_inputRows * m_inputPlanes;
-    m_otherInputStride = m_inputDepth * m_inputRows * m_inputCols * m_inputPlanes;
-
-    m_outputPlanesRows = m_outputPlanes * m_outputRows;
-
-    // Fast representations of different variables.
-    m_fastOtherStride = internal::TensorIntDivisor<Index>(m_otherStride);
-
-    m_fastPatchStride = internal::TensorIntDivisor<Index>(m_patchStride);
-    m_fastColStride = internal::TensorIntDivisor<Index>(m_colStride);
-    m_fastRowStride = internal::TensorIntDivisor<Index>(m_rowStride);
-    m_fastInputRowStride = internal::TensorIntDivisor<Index>(m_row_inflate_strides);
-    m_fastInputColStride = internal::TensorIntDivisor<Index>(m_col_inflate_strides);
-    m_fastInputPlaneStride = internal::TensorIntDivisor<Index>(m_plane_inflate_strides);
-    m_fastInputColsEff = internal::TensorIntDivisor<Index>(m_input_cols_eff);
-    m_fastOutputPlanes = internal::TensorIntDivisor<Index>(m_outputPlanes);
-    m_fastOutputPlanesRows = internal::TensorIntDivisor<Index>(m_outputPlanesRows);
-
-    if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[0]);
-    } else {
-      m_fastOutputDepth = internal::TensorIntDivisor<Index>(m_dimensions[NumDims - 1]);
-    }
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
-
-  EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType /*data*/) {
-    m_impl.evalSubExprsIfNeeded(NULL);
-    return true;
-  }
-
-#ifdef EIGEN_USE_THREADS
-  template <typename EvalSubExprsCallback>
-  EIGEN_STRONG_INLINE void evalSubExprsIfNeededAsync(EvaluatorPointerType /*data*/, EvalSubExprsCallback done) {
-    m_impl.evalSubExprsIfNeededAsync(nullptr, [done](bool) { done(true); });
-  }
-#endif  // EIGEN_USE_THREADS
-
-  EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const {
-    // Patch index corresponding to the passed in index.
-    const Index patchIndex = index / m_fastPatchStride;
-
-    // Spatial offset within the patch. This has to be translated into 3D
-    // coordinates within the patch.
-    const Index patchOffset = (index - patchIndex * m_patchStride) / m_fastOutputDepth;
-
-    // Batch, etc.
-    const Index otherIndex = (NumDims == 5) ? 0 : index / m_fastOtherStride;
-    const Index patch3DIndex = (NumDims == 5) ? patchIndex : (index - otherIndex * m_otherStride) / m_fastPatchStride;
-
-    // Calculate column index in the input original tensor.
-    const Index colIndex = patch3DIndex / m_fastOutputPlanesRows;
-    const Index colOffset = patchOffset / m_fastColStride;
-    const Index inputCol = colIndex * m_col_strides + colOffset * m_in_col_strides - m_colPaddingLeft;
-    const Index origInputCol =
-        (m_col_inflate_strides == 1) ? inputCol : ((inputCol >= 0) ? (inputCol / m_fastInputColStride) : 0);
-    if (inputCol < 0 || inputCol >= m_input_cols_eff ||
-        ((m_col_inflate_strides != 1) && (inputCol != origInputCol * m_col_inflate_strides))) {
-      return Scalar(m_paddingValue);
-    }
-
-    // Calculate row index in the original input tensor.
-    const Index rowIndex = (patch3DIndex - colIndex * m_outputPlanesRows) / m_fastOutputPlanes;
-    const Index rowOffset = (patchOffset - colOffset * m_colStride) / m_fastRowStride;
-    const Index inputRow = rowIndex * m_row_strides + rowOffset * m_in_row_strides - m_rowPaddingTop;
-    const Index origInputRow =
-        (m_row_inflate_strides == 1) ? inputRow : ((inputRow >= 0) ? (inputRow / m_fastInputRowStride) : 0);
-    if (inputRow < 0 || inputRow >= m_input_rows_eff ||
-        ((m_row_inflate_strides != 1) && (inputRow != origInputRow * m_row_inflate_strides))) {
-      return Scalar(m_paddingValue);
-    }
-
-    // Calculate plane index in the original input tensor.
-    const Index planeIndex = (patch3DIndex - m_outputPlanes * (colIndex * m_outputRows + rowIndex));
-    const Index planeOffset = patchOffset - colOffset * m_colStride - rowOffset * m_rowStride;
-    const Index inputPlane = planeIndex * m_plane_strides + planeOffset * m_in_plane_strides - m_planePaddingTop;
-    const Index origInputPlane =
-        (m_plane_inflate_strides == 1) ? inputPlane : ((inputPlane >= 0) ? (inputPlane / m_fastInputPlaneStride) : 0);
-    if (inputPlane < 0 || inputPlane >= m_input_planes_eff ||
-        ((m_plane_inflate_strides != 1) && (inputPlane != origInputPlane * m_plane_inflate_strides))) {
-      return Scalar(m_paddingValue);
-    }
-
-    const int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
-    const Index depth = index - (index / m_fastOutputDepth) * m_dimensions[depth_index];
-
-    const Index inputIndex = depth + origInputRow * m_rowInputStride + origInputCol * m_colInputStride +
-                             origInputPlane * m_planeInputStride + otherIndex * m_otherInputStride;
-
-    return m_impl.coeff(inputIndex);
-  }
-
-  template <int LoadMode>
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const {
-    eigen_assert(index + PacketSize - 1 < dimensions().TotalSize());
-
-    if (m_in_row_strides != 1 || m_in_col_strides != 1 || m_row_inflate_strides != 1 || m_col_inflate_strides != 1 ||
-        m_in_plane_strides != 1 || m_plane_inflate_strides != 1) {
-      return packetWithPossibleZero(index);
-    }
-
-    const Index indices[2] = {index, index + PacketSize - 1};
-    const Index patchIndex = indices[0] / m_fastPatchStride;
-    if (patchIndex != indices[1] / m_fastPatchStride) {
-      return packetWithPossibleZero(index);
-    }
-    const Index otherIndex = (NumDims == 5) ? 0 : indices[0] / m_fastOtherStride;
-    eigen_assert(otherIndex == indices[1] / m_fastOtherStride);
-
-    // Find the offset of the element wrt the location of the first element.
-    Index first_entry = (indices[0] - patchIndex * m_patchStride) / m_fastOutputDepth;
-    Index second_entry = PacketSize == 1 ? first_entry : (indices[1] - patchIndex * m_patchStride) / m_fastOutputDepth;
-
-    const Index patchOffsets[2] = {first_entry, second_entry};
-
-    const Index patch3DIndex =
-        (NumDims == 5) ? patchIndex : (indices[0] - otherIndex * m_otherStride) / m_fastPatchStride;
-    eigen_assert(patch3DIndex == (indices[1] - otherIndex * m_otherStride) / m_fastPatchStride);
-
-    const Index colIndex = patch3DIndex / m_fastOutputPlanesRows;
-    const Index colOffsets[2] = {patchOffsets[0] / m_fastColStride, patchOffsets[1] / m_fastColStride};
-
-    // Calculate col indices in the original input tensor.
-    const Index inputCols[2] = {colIndex * m_col_strides + colOffsets[0] - m_colPaddingLeft,
-                                colIndex * m_col_strides + colOffsets[1] - m_colPaddingLeft};
-    if (inputCols[1] < 0 || inputCols[0] >= m_inputCols) {
-      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
-    }
-
-    if (inputCols[0] != inputCols[1]) {
-      return packetWithPossibleZero(index);
-    }
-
-    const Index rowIndex = (patch3DIndex - colIndex * m_outputPlanesRows) / m_fastOutputPlanes;
-    const Index rowOffsets[2] = {(patchOffsets[0] - colOffsets[0] * m_colStride) / m_fastRowStride,
-                                 (patchOffsets[1] - colOffsets[1] * m_colStride) / m_fastRowStride};
-    eigen_assert(rowOffsets[0] <= rowOffsets[1]);
-    // Calculate row indices in the original input tensor.
-    const Index inputRows[2] = {rowIndex * m_row_strides + rowOffsets[0] - m_rowPaddingTop,
-                                rowIndex * m_row_strides + rowOffsets[1] - m_rowPaddingTop};
-
-    if (inputRows[1] < 0 || inputRows[0] >= m_inputRows) {
-      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
-    }
-
-    if (inputRows[0] != inputRows[1]) {
-      return packetWithPossibleZero(index);
-    }
-
-    const Index planeIndex = (patch3DIndex - m_outputPlanes * (colIndex * m_outputRows + rowIndex));
-    const Index planeOffsets[2] = {patchOffsets[0] - colOffsets[0] * m_colStride - rowOffsets[0] * m_rowStride,
-                                   patchOffsets[1] - colOffsets[1] * m_colStride - rowOffsets[1] * m_rowStride};
-    eigen_assert(planeOffsets[0] <= planeOffsets[1]);
-    const Index inputPlanes[2] = {planeIndex * m_plane_strides + planeOffsets[0] - m_planePaddingTop,
-                                  planeIndex * m_plane_strides + planeOffsets[1] - m_planePaddingTop};
-
-    if (inputPlanes[1] < 0 || inputPlanes[0] >= m_inputPlanes) {
-      return internal::pset1<PacketReturnType>(Scalar(m_paddingValue));
-    }
-
-    if (inputPlanes[0] >= 0 && inputPlanes[1] < m_inputPlanes) {
-      // no padding
-      const int depth_index = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
-      const Index depth = index - (index / m_fastOutputDepth) * m_dimensions[depth_index];
-      const Index inputIndex = depth + inputRows[0] * m_rowInputStride + inputCols[0] * m_colInputStride +
-                               m_planeInputStride * inputPlanes[0] + otherIndex * m_otherInputStride;
-      return m_impl.template packet<Unaligned>(inputIndex);
-    }
-
-    return packetWithPossibleZero(index);
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
-    const double compute_cost =
-        10 * TensorOpCost::DivCost<Index>() + 21 * TensorOpCost::MulCost<Index>() + 8 * TensorOpCost::AddCost<Index>();
-    return TensorOpCost(0, 0, compute_cost, vectorized, PacketSize);
-  }
-
-  EIGEN_DEVICE_FUNC EvaluatorPointerType data() const { return NULL; }
-
-  const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index planePaddingTop() const { return m_planePaddingTop; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowPaddingTop() const { return m_rowPaddingTop; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colPaddingLeft() const { return m_colPaddingLeft; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputPlanes() const { return m_outputPlanes; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputRows() const { return m_outputRows; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outputCols() const { return m_outputCols; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userPlaneStride() const { return m_plane_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userRowStride() const { return m_row_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userColStride() const { return m_col_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInPlaneStride() const { return m_in_plane_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInRowStride() const { return m_in_row_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index userInColStride() const { return m_in_col_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index planeInflateStride() const { return m_plane_inflate_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rowInflateStride() const { return m_row_inflate_strides; }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index colInflateStride() const { return m_col_inflate_strides; }
-
- protected:
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packetWithPossibleZero(Index index) const {
-    EIGEN_ALIGN_MAX std::remove_const_t<CoeffReturnType> values[PacketSize];
-    EIGEN_UNROLL_LOOP
-    for (int i = 0; i < PacketSize; ++i) {
-      values[i] = coeff(index + i);
-    }
-    PacketReturnType rslt = internal::pload<PacketReturnType>(values);
-    return rslt;
-  }
-
-  Dimensions m_dimensions;
-
-  // Parameters passed to the constructor.
-  Index m_plane_strides;
-  Index m_row_strides;
-  Index m_col_strides;
-
-  Index m_outputPlanes;
-  Index m_outputRows;
-  Index m_outputCols;
-
-  Index m_planePaddingTop;
-  Index m_rowPaddingTop;
-  Index m_colPaddingLeft;
-
-  Index m_in_plane_strides;
-  Index m_in_row_strides;
-  Index m_in_col_strides;
-
-  Index m_plane_inflate_strides;
-  Index m_row_inflate_strides;
-  Index m_col_inflate_strides;
-
-  // Cached input size.
-  Index m_inputDepth;
-  Index m_inputPlanes;
-  Index m_inputRows;
-  Index m_inputCols;
-
-  // Other cached variables.
-  Index m_outputPlanesRows;
-
-  // Effective input/patch post-inflation size.
-  Index m_input_planes_eff;
-  Index m_input_rows_eff;
-  Index m_input_cols_eff;
-  Index m_patch_planes_eff;
-  Index m_patch_rows_eff;
-  Index m_patch_cols_eff;
-
-  // Strides for the output tensor.
-  Index m_otherStride;
-  Index m_patchStride;
-  Index m_rowStride;
-  Index m_colStride;
-
-  // Strides for the input tensor.
-  Index m_planeInputStride;
-  Index m_rowInputStride;
-  Index m_colInputStride;
-  Index m_otherInputStride;
-
-  internal::TensorIntDivisor<Index> m_fastOtherStride;
-  internal::TensorIntDivisor<Index> m_fastPatchStride;
-  internal::TensorIntDivisor<Index> m_fastColStride;
-  internal::TensorIntDivisor<Index> m_fastRowStride;
-  internal::TensorIntDivisor<Index> m_fastInputPlaneStride;
-  internal::TensorIntDivisor<Index> m_fastInputRowStride;
-  internal::TensorIntDivisor<Index> m_fastInputColStride;
-  internal::TensorIntDivisor<Index> m_fastInputColsEff;
-  internal::TensorIntDivisor<Index> m_fastOutputPlanesRows;
-  internal::TensorIntDivisor<Index> m_fastOutputPlanes;
-  internal::TensorIntDivisor<Index> m_fastOutputDepth;
-
-  Scalar m_paddingValue;
-
-  TensorEvaluator<ArgType, Device> m_impl;
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSOR_TENSOR_VOLUME_PATCH_H
diff --git a/unsupported/Eigen/src/TensorSymmetry/DynamicSymmetry.h b/unsupported/Eigen/src/TensorSymmetry/DynamicSymmetry.h
deleted file mode 100644
index 3d50bc0..0000000
--- a/unsupported/Eigen/src/TensorSymmetry/DynamicSymmetry.h
+++ /dev/null
@@ -1,296 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSORSYMMETRY_DYNAMICSYMMETRY_H
-#define EIGEN_CXX11_TENSORSYMMETRY_DYNAMICSYMMETRY_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-class DynamicSGroup {
- public:
-  inline explicit DynamicSGroup() : m_numIndices(1), m_elements(), m_generators(), m_globalFlags(0) {
-    m_elements.push_back(ge(Generator(0, 0, 0)));
-  }
-  inline DynamicSGroup(const DynamicSGroup& o)
-      : m_numIndices(o.m_numIndices),
-        m_elements(o.m_elements),
-        m_generators(o.m_generators),
-        m_globalFlags(o.m_globalFlags) {}
-  inline DynamicSGroup(DynamicSGroup&& o)
-      : m_numIndices(o.m_numIndices), m_elements(), m_generators(o.m_generators), m_globalFlags(o.m_globalFlags) {
-    std::swap(m_elements, o.m_elements);
-  }
-  inline DynamicSGroup& operator=(const DynamicSGroup& o) {
-    m_numIndices = o.m_numIndices;
-    m_elements = o.m_elements;
-    m_generators = o.m_generators;
-    m_globalFlags = o.m_globalFlags;
-    return *this;
-  }
-  inline DynamicSGroup& operator=(DynamicSGroup&& o) {
-    m_numIndices = o.m_numIndices;
-    std::swap(m_elements, o.m_elements);
-    m_generators = o.m_generators;
-    m_globalFlags = o.m_globalFlags;
-    return *this;
-  }
-
-  void add(int one, int two, int flags = 0);
-
-  template <typename Gen_>
-  inline void add(Gen_) {
-    add(Gen_::One, Gen_::Two, Gen_::Flags);
-  }
-  inline void addSymmetry(int one, int two) { add(one, two, 0); }
-  inline void addAntiSymmetry(int one, int two) { add(one, two, NegationFlag); }
-  inline void addHermiticity(int one, int two) { add(one, two, ConjugationFlag); }
-  inline void addAntiHermiticity(int one, int two) { add(one, two, NegationFlag | ConjugationFlag); }
-
-  template <typename Op, typename RV, typename Index, std::size_t N, typename... Args>
-  inline RV apply(const std::array<Index, N>& idx, RV initial, Args&&... args) const {
-    eigen_assert(N >= m_numIndices &&
-                 "Can only apply symmetry group to objects that have at least the required amount of indices.");
-    for (std::size_t i = 0; i < size(); i++)
-      initial = Op::run(h_permute(i, idx, typename internal::gen_numeric_list<int, N>::type()), m_elements[i].flags,
-                        initial, std::forward<Args>(args)...);
-    return initial;
-  }
-
-  template <typename Op, typename RV, typename Index, typename... Args>
-  inline RV apply(const std::vector<Index>& idx, RV initial, Args&&... args) const {
-    eigen_assert(idx.size() >= m_numIndices &&
-                 "Can only apply symmetry group to objects that have at least the required amount of indices.");
-    for (std::size_t i = 0; i < size(); i++)
-      initial = Op::run(h_permute(i, idx), m_elements[i].flags, initial, std::forward<Args>(args)...);
-    return initial;
-  }
-
-  inline int globalFlags() const { return m_globalFlags; }
-  inline std::size_t size() const { return m_elements.size(); }
-
-  template <typename Tensor_, typename... IndexTypes>
-  inline internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup> operator()(Tensor_& tensor,
-                                                                                   typename Tensor_::Index firstIndex,
-                                                                                   IndexTypes... otherIndices) const {
-    static_assert(sizeof...(otherIndices) + 1 == Tensor_::NumIndices,
-                  "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
-    return operator()(tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices>{{firstIndex, otherIndices...}});
-  }
-
-  template <typename Tensor_>
-  inline internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup> operator()(
-      Tensor_& tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices> const& indices) const {
-    return internal::tensor_symmetry_value_setter<Tensor_, DynamicSGroup>(tensor, *this, indices);
-  }
-
- private:
-  struct GroupElement {
-    std::vector<int> representation;
-    int flags;
-    bool isId() const {
-      for (std::size_t i = 0; i < representation.size(); i++)
-        if (i != (size_t)representation[i]) return false;
-      return true;
-    }
-  };
-  struct Generator {
-    int one;
-    int two;
-    int flags;
-    constexpr Generator(int one_, int two_, int flags_) : one(one_), two(two_), flags(flags_) {}
-  };
-
-  std::size_t m_numIndices;
-  std::vector<GroupElement> m_elements;
-  std::vector<Generator> m_generators;
-  int m_globalFlags;
-
-  template <typename Index, std::size_t N, int... n>
-  inline std::array<Index, N> h_permute(std::size_t which, const std::array<Index, N>& idx,
-                                        internal::numeric_list<int, n...>) const {
-    return std::array<Index, N>{{idx[n >= m_numIndices ? n : m_elements[which].representation[n]]...}};
-  }
-
-  template <typename Index>
-  inline std::vector<Index> h_permute(std::size_t which, std::vector<Index> idx) const {
-    std::vector<Index> result;
-    result.reserve(idx.size());
-    for (auto k : m_elements[which].representation) result.push_back(idx[k]);
-    for (std::size_t i = m_numIndices; i < idx.size(); i++) result.push_back(idx[i]);
-    return result;
-  }
-
-  inline GroupElement ge(Generator const& g) const {
-    GroupElement result;
-    result.representation.reserve(m_numIndices);
-    result.flags = g.flags;
-    for (std::size_t k = 0; k < m_numIndices; k++) {
-      if (k == (std::size_t)g.one)
-        result.representation.push_back(g.two);
-      else if (k == (std::size_t)g.two)
-        result.representation.push_back(g.one);
-      else
-        result.representation.push_back(int(k));
-    }
-    return result;
-  }
-
-  GroupElement mul(GroupElement, GroupElement) const;
-  inline GroupElement mul(Generator g1, GroupElement g2) const { return mul(ge(g1), g2); }
-
-  inline GroupElement mul(GroupElement g1, Generator g2) const { return mul(g1, ge(g2)); }
-
-  inline GroupElement mul(Generator g1, Generator g2) const { return mul(ge(g1), ge(g2)); }
-
-  inline int findElement(GroupElement e) const {
-    for (auto ee : m_elements) {
-      if (ee.representation == e.representation) return ee.flags ^ e.flags;
-    }
-    return -1;
-  }
-
-  void updateGlobalFlags(int flagDiffOfSameGenerator);
-};
-
-// dynamic symmetry group that auto-adds the template parameters in the constructor
-template <typename... Gen>
-class DynamicSGroupFromTemplateArgs : public DynamicSGroup {
- public:
-  inline DynamicSGroupFromTemplateArgs() : DynamicSGroup() { add_all(internal::type_list<Gen...>()); }
-  inline DynamicSGroupFromTemplateArgs(DynamicSGroupFromTemplateArgs const& other) : DynamicSGroup(other) {}
-  inline DynamicSGroupFromTemplateArgs(DynamicSGroupFromTemplateArgs&& other) : DynamicSGroup(other) {}
-  inline DynamicSGroupFromTemplateArgs<Gen...>& operator=(const DynamicSGroupFromTemplateArgs<Gen...>& o) {
-    DynamicSGroup::operator=(o);
-    return *this;
-  }
-  inline DynamicSGroupFromTemplateArgs<Gen...>& operator=(DynamicSGroupFromTemplateArgs<Gen...>&& o) {
-    DynamicSGroup::operator=(o);
-    return *this;
-  }
-
- private:
-  template <typename Gen1, typename... GenNext>
-  inline void add_all(internal::type_list<Gen1, GenNext...>) {
-    add(Gen1());
-    add_all(internal::type_list<GenNext...>());
-  }
-
-  inline void add_all(internal::type_list<>) {}
-};
-
-inline DynamicSGroup::GroupElement DynamicSGroup::mul(GroupElement g1, GroupElement g2) const {
-  eigen_internal_assert(g1.representation.size() == m_numIndices);
-  eigen_internal_assert(g2.representation.size() == m_numIndices);
-
-  GroupElement result;
-  result.representation.reserve(m_numIndices);
-  for (std::size_t i = 0; i < m_numIndices; i++) {
-    int v = g2.representation[g1.representation[i]];
-    eigen_assert(v >= 0);
-    result.representation.push_back(v);
-  }
-  result.flags = g1.flags ^ g2.flags;
-  return result;
-}
-
-inline void DynamicSGroup::add(int one, int two, int flags) {
-  eigen_assert(one >= 0);
-  eigen_assert(two >= 0);
-  eigen_assert(one != two);
-
-  if ((std::size_t)one >= m_numIndices || (std::size_t)two >= m_numIndices) {
-    std::size_t newNumIndices = (one > two) ? one : two + 1;
-    for (auto& gelem : m_elements) {
-      gelem.representation.reserve(newNumIndices);
-      for (std::size_t i = m_numIndices; i < newNumIndices; i++) gelem.representation.push_back(static_cast<int>(i));
-    }
-    m_numIndices = newNumIndices;
-  }
-
-  Generator g{one, two, flags};
-  GroupElement e = ge(g);
-
-  /* special case for first generator */
-  if (m_elements.size() == 1) {
-    while (!e.isId()) {
-      m_elements.push_back(e);
-      e = mul(e, g);
-    }
-
-    if (e.flags > 0) updateGlobalFlags(e.flags);
-
-    // only add in case we didn't have identity
-    if (m_elements.size() > 1) m_generators.push_back(g);
-    return;
-  }
-
-  int p = findElement(e);
-  if (p >= 0) {
-    updateGlobalFlags(p);
-    return;
-  }
-
-  std::size_t coset_order = m_elements.size();
-  m_elements.push_back(e);
-  for (std::size_t i = 1; i < coset_order; i++) m_elements.push_back(mul(m_elements[i], e));
-  m_generators.push_back(g);
-
-  std::size_t coset_rep = coset_order;
-  do {
-    for (auto gen : m_generators) {
-      e = mul(m_elements[coset_rep], gen);
-      p = findElement(e);
-      if (p < 0) {
-        // element not yet in group
-        m_elements.push_back(e);
-        for (std::size_t i = 1; i < coset_order; i++) m_elements.push_back(mul(m_elements[i], e));
-      } else if (p > 0) {
-        updateGlobalFlags(p);
-      }
-    }
-    coset_rep += coset_order;
-  } while (coset_rep < m_elements.size());
-}
-
-inline void DynamicSGroup::updateGlobalFlags(int flagDiffOfSameGenerator) {
-  switch (flagDiffOfSameGenerator) {
-    case 0:
-    default:
-      // nothing happened
-      break;
-    case NegationFlag:
-      // every element is it's own negative => whole tensor is zero
-      m_globalFlags |= GlobalZeroFlag;
-      break;
-    case ConjugationFlag:
-      // every element is it's own conjugate => whole tensor is real
-      m_globalFlags |= GlobalRealFlag;
-      break;
-    case (NegationFlag | ConjugationFlag):
-      // every element is it's own negative conjugate => whole tensor is imaginary
-      m_globalFlags |= GlobalImagFlag;
-      break;
-      /* NOTE:
-       *   since GlobalZeroFlag == GlobalRealFlag | GlobalImagFlag, if one generator
-       *   causes the tensor to be real and the next one to be imaginary, this will
-       *   trivially give the correct result
-       */
-  }
-}
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSORSYMMETRY_DYNAMICSYMMETRY_H
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */
diff --git a/unsupported/Eigen/src/TensorSymmetry/InternalHeaderCheck.h b/unsupported/Eigen/src/TensorSymmetry/InternalHeaderCheck.h
deleted file mode 100644
index c7f5992..0000000
--- a/unsupported/Eigen/src/TensorSymmetry/InternalHeaderCheck.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#ifndef EIGEN_CXX11_TENSORSYMMETRY_MODULE_H
-#error "Please include unsupported/Eigen/TensorSymmetry instead of including headers inside the src directory directly."
-#endif
diff --git a/unsupported/Eigen/src/TensorSymmetry/StaticSymmetry.h b/unsupported/Eigen/src/TensorSymmetry/StaticSymmetry.h
deleted file mode 100644
index 6ee508f..0000000
--- a/unsupported/Eigen/src/TensorSymmetry/StaticSymmetry.h
+++ /dev/null
@@ -1,223 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSORSYMMETRY_STATICSYMMETRY_H
-#define EIGEN_CXX11_TENSORSYMMETRY_STATICSYMMETRY_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-template <typename list>
-struct tensor_static_symgroup_permutate;
-
-template <int... nn>
-struct tensor_static_symgroup_permutate<numeric_list<int, nn...>> {
-  constexpr static std::size_t N = sizeof...(nn);
-
-  template <typename T>
-  constexpr static std::array<T, N> run(const std::array<T, N>& indices) {
-    return {{indices[nn]...}};
-  }
-};
-
-template <typename indices_, int flags_>
-struct tensor_static_symgroup_element {
-  typedef indices_ indices;
-  constexpr static int flags = flags_;
-};
-
-template <typename Gen, int N>
-struct tensor_static_symgroup_element_ctor {
-  typedef tensor_static_symgroup_element<typename gen_numeric_list_swapped_pair<int, N, Gen::One, Gen::Two>::type,
-                                         Gen::Flags>
-      type;
-};
-
-template <int N>
-struct tensor_static_symgroup_identity_ctor {
-  typedef tensor_static_symgroup_element<typename gen_numeric_list<int, N>::type, 0> type;
-};
-
-template <typename iib>
-struct tensor_static_symgroup_multiply_helper {
-  template <int... iia>
-  constexpr static numeric_list<int, get<iia, iib>::value...> helper(numeric_list<int, iia...>) {
-    return numeric_list<int, get<iia, iib>::value...>();
-  }
-};
-
-template <typename A, typename B>
-struct tensor_static_symgroup_multiply {
- private:
-  typedef typename A::indices iia;
-  typedef typename B::indices iib;
-  constexpr static int ffa = A::flags;
-  constexpr static int ffb = B::flags;
-
- public:
-  static_assert(iia::count == iib::count, "Cannot multiply symmetry elements with different number of indices.");
-
-  typedef tensor_static_symgroup_element<decltype(tensor_static_symgroup_multiply_helper<iib>::helper(iia())),
-                                         ffa ^ ffb>
-      type;
-};
-
-template <typename A, typename B>
-struct tensor_static_symgroup_equality {
-  typedef typename A::indices iia;
-  typedef typename B::indices iib;
-  constexpr static int ffa = A::flags;
-  constexpr static int ffb = B::flags;
-  static_assert(iia::count == iib::count, "Cannot compare symmetry elements with different number of indices.");
-
-  constexpr static bool value = is_same<iia, iib>::value;
-
- private:
-  /* this should be zero if they are identical, or else the tensor
-   * will be forced to be pure real, pure imaginary or even pure zero
-   */
-  constexpr static int flags_cmp_ = ffa ^ ffb;
-
-  /* either they are not equal, then we don't care whether the flags
-   * match, or they are equal, and then we have to check
-   */
-  constexpr static bool is_zero = value && flags_cmp_ == NegationFlag;
-  constexpr static bool is_real = value && flags_cmp_ == ConjugationFlag;
-  constexpr static bool is_imag = value && flags_cmp_ == (NegationFlag | ConjugationFlag);
-
- public:
-  constexpr static int global_flags =
-      (is_real ? GlobalRealFlag : 0) | (is_imag ? GlobalImagFlag : 0) | (is_zero ? GlobalZeroFlag : 0);
-};
-
-template <std::size_t NumIndices, typename... Gen>
-struct tensor_static_symgroup {
-  typedef StaticSGroup<Gen...> type;
-  constexpr static std::size_t size = type::static_size;
-};
-
-template <typename Index, std::size_t N, int... ii, int... jj>
-constexpr static std::array<Index, N> tensor_static_symgroup_index_permute(std::array<Index, N> idx,
-                                                                           internal::numeric_list<int, ii...>,
-                                                                           internal::numeric_list<int, jj...>) {
-  return {{idx[ii]..., idx[jj]...}};
-}
-
-template <typename Index, int... ii>
-static inline std::vector<Index> tensor_static_symgroup_index_permute(std::vector<Index> idx,
-                                                                      internal::numeric_list<int, ii...>) {
-  std::vector<Index> result{{idx[ii]...}};
-  std::size_t target_size = idx.size();
-  for (std::size_t i = result.size(); i < target_size; i++) result.push_back(idx[i]);
-  return result;
-}
-
-template <typename T>
-struct tensor_static_symgroup_do_apply;
-
-template <typename first, typename... next>
-struct tensor_static_symgroup_do_apply<internal::type_list<first, next...>> {
-  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, std::size_t NumIndices,
-            typename... Args>
-  static inline RV run(const std::array<Index, NumIndices>& idx, RV initial, Args&&... args) {
-    static_assert(NumIndices >= SGNumIndices,
-                  "Can only apply symmetry group to objects that have at least the required amount of indices.");
-    typedef typename internal::gen_numeric_list<int, NumIndices - SGNumIndices, SGNumIndices>::type remaining_indices;
-    initial = Op::run(tensor_static_symgroup_index_permute(idx, typename first::indices(), remaining_indices()),
-                      first::flags, initial, std::forward<Args>(args)...);
-    return tensor_static_symgroup_do_apply<internal::type_list<next...>>::template run<Op, RV, SGNumIndices>(
-        idx, initial, args...);
-  }
-
-  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, typename... Args>
-  static inline RV run(const std::vector<Index>& idx, RV initial, Args&&... args) {
-    eigen_assert(idx.size() >= SGNumIndices &&
-                 "Can only apply symmetry group to objects that have at least the required amount of indices.");
-    initial = Op::run(tensor_static_symgroup_index_permute(idx, typename first::indices()), first::flags, initial,
-                      std::forward<Args>(args)...);
-    return tensor_static_symgroup_do_apply<internal::type_list<next...>>::template run<Op, RV, SGNumIndices>(
-        idx, initial, args...);
-  }
-};
-
-template <>
-struct tensor_static_symgroup_do_apply<internal::type_list<>> {
-  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, std::size_t NumIndices,
-            typename... Args>
-  static inline RV run(const std::array<Index, NumIndices>&, RV initial, Args&&...) {
-    // do nothing
-    return initial;
-  }
-
-  template <typename Op, typename RV, std::size_t SGNumIndices, typename Index, typename... Args>
-  static inline RV run(const std::vector<Index>&, RV initial, Args&&...) {
-    // do nothing
-    return initial;
-  }
-};
-
-}  // end namespace internal
-
-template <typename... Gen>
-class StaticSGroup {
-  constexpr static std::size_t NumIndices = internal::tensor_symmetry_num_indices<Gen...>::value;
-  typedef internal::group_theory::enumerate_group_elements<
-      internal::tensor_static_symgroup_multiply, internal::tensor_static_symgroup_equality,
-      typename internal::tensor_static_symgroup_identity_ctor<NumIndices>::type,
-      internal::type_list<typename internal::tensor_static_symgroup_element_ctor<Gen, NumIndices>::type...>>
-      group_elements;
-  typedef typename group_elements::type ge;
-
- public:
-  constexpr StaticSGroup() {}
-  constexpr StaticSGroup(const StaticSGroup<Gen...>&) {}
-  constexpr StaticSGroup(StaticSGroup<Gen...>&&) {}
-
-  template <typename Op, typename RV, typename Index, std::size_t N, typename... Args>
-  static inline RV apply(const std::array<Index, N>& idx, RV initial, Args&&... args) {
-    return internal::tensor_static_symgroup_do_apply<ge>::template run<Op, RV, NumIndices>(idx, initial, args...);
-  }
-
-  template <typename Op, typename RV, typename Index, typename... Args>
-  static inline RV apply(const std::vector<Index>& idx, RV initial, Args&&... args) {
-    eigen_assert(idx.size() == NumIndices);
-    return internal::tensor_static_symgroup_do_apply<ge>::template run<Op, RV, NumIndices>(idx, initial, args...);
-  }
-
-  constexpr static std::size_t static_size = ge::count;
-
-  constexpr static std::size_t size() { return ge::count; }
-  constexpr static int globalFlags() { return group_elements::global_flags; }
-
-  template <typename Tensor_, typename... IndexTypes>
-  inline internal::tensor_symmetry_value_setter<Tensor_, StaticSGroup<Gen...>> operator()(
-      Tensor_& tensor, typename Tensor_::Index firstIndex, IndexTypes... otherIndices) const {
-    static_assert(sizeof...(otherIndices) + 1 == Tensor_::NumIndices,
-                  "Number of indices used to access a tensor coefficient must be equal to the rank of the tensor.");
-    return operator()(tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices>{{firstIndex, otherIndices...}});
-  }
-
-  template <typename Tensor_>
-  inline internal::tensor_symmetry_value_setter<Tensor_, StaticSGroup<Gen...>> operator()(
-      Tensor_& tensor, std::array<typename Tensor_::Index, Tensor_::NumIndices> const& indices) const {
-    return internal::tensor_symmetry_value_setter<Tensor_, StaticSGroup<Gen...>>(tensor, *this, indices);
-  }
-};
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSORSYMMETRY_STATICSYMMETRY_H
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */
diff --git a/unsupported/Eigen/src/TensorSymmetry/Symmetry.h b/unsupported/Eigen/src/TensorSymmetry/Symmetry.h
deleted file mode 100644
index 2c57e36..0000000
--- a/unsupported/Eigen/src/TensorSymmetry/Symmetry.h
+++ /dev/null
@@ -1,335 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSORSYMMETRY_SYMMETRY_H
-#define EIGEN_CXX11_TENSORSYMMETRY_SYMMETRY_H
-
-// IWYU pragma: private
-#include "./InternalHeaderCheck.h"
-
-namespace Eigen {
-
-enum { NegationFlag = 0x01, ConjugationFlag = 0x02 };
-
-enum { GlobalRealFlag = 0x01, GlobalImagFlag = 0x02, GlobalZeroFlag = 0x03 };
-
-namespace internal {
-
-template <std::size_t NumIndices, typename... Sym>
-struct tensor_symmetry_pre_analysis;
-template <std::size_t NumIndices, typename... Sym>
-struct tensor_static_symgroup;
-template <bool instantiate, std::size_t NumIndices, typename... Sym>
-struct tensor_static_symgroup_if;
-template <typename Tensor_>
-struct tensor_symmetry_calculate_flags;
-template <typename Tensor_>
-struct tensor_symmetry_assign_value;
-template <typename... Sym>
-struct tensor_symmetry_num_indices;
-
-}  // end namespace internal
-
-template <int One_, int Two_>
-struct Symmetry {
-  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
-  constexpr static int One = One_;
-  constexpr static int Two = Two_;
-  constexpr static int Flags = 0;
-};
-
-template <int One_, int Two_>
-struct AntiSymmetry {
-  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
-  constexpr static int One = One_;
-  constexpr static int Two = Two_;
-  constexpr static int Flags = NegationFlag;
-};
-
-template <int One_, int Two_>
-struct Hermiticity {
-  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
-  constexpr static int One = One_;
-  constexpr static int Two = Two_;
-  constexpr static int Flags = ConjugationFlag;
-};
-
-template <int One_, int Two_>
-struct AntiHermiticity {
-  static_assert(One_ != Two_, "Symmetries must cover distinct indices.");
-  constexpr static int One = One_;
-  constexpr static int Two = Two_;
-  constexpr static int Flags = ConjugationFlag | NegationFlag;
-};
-
-/** \class DynamicSGroup
- * \ingroup TensorSymmetry_Module
- *
- * \brief Dynamic symmetry group
- *
- * The %DynamicSGroup class represents a symmetry group that need not be known at
- * compile time. It is useful if one wants to support arbitrary run-time definable
- * symmetries for tensors, but it is also instantiated if a symmetry group is defined
- * at compile time that would be either too large for the compiler to reasonably
- * generate (using templates to calculate this at compile time is very inefficient)
- * or that the compiler could generate the group but that it wouldn't make sense to
- * unroll the loop for setting coefficients anymore.
- */
-class DynamicSGroup;
-
-/** \internal
- *
- * \class DynamicSGroupFromTemplateArgs
- * \ingroup TensorSymmetry_Module
- *
- * \brief Dynamic symmetry group, initialized from template arguments
- *
- * This class is a child class of DynamicSGroup. It uses the template arguments
- * specified to initialize itself.
- */
-template <typename... Gen>
-class DynamicSGroupFromTemplateArgs;
-
-/** \class StaticSGroup
- * \ingroup TensorSymmetry_Module
- *
- * \brief Static symmetry group
- *
- * This class represents a symmetry group that is known and resolved completely
- * at compile time. Ideally, no run-time penalty is incurred compared to the
- * manual unrolling of the symmetry.
- *
- * <b><i>CAUTION:</i></b>
- *
- * Do not use this class directly for large symmetry groups. The compiler
- * may run into a limit, or segfault or in the very least will take a very,
- * very, very long time to compile the code. Use the SGroup class instead
- * if you want a static group. That class contains logic that will
- * automatically select the DynamicSGroup class instead if the symmetry
- * group becomes too large. (In that case, unrolling may not even be
- * beneficial.)
- */
-template <typename... Gen>
-class StaticSGroup;
-
-/** \class SGroup
- * \ingroup TensorSymmetry_Module
- *
- * \brief Symmetry group, initialized from template arguments
- *
- * This class represents a symmetry group whose generators are already
- * known at compile time. It may or may not be resolved at compile time,
- * depending on the estimated size of the group.
- *
- * \sa StaticSGroup
- * \sa DynamicSGroup
- */
-template <typename... Gen>
-class SGroup : public internal::tensor_symmetry_pre_analysis<internal::tensor_symmetry_num_indices<Gen...>::value,
-                                                             Gen...>::root_type {
- public:
-  constexpr static std::size_t NumIndices = internal::tensor_symmetry_num_indices<Gen...>::value;
-  typedef typename internal::tensor_symmetry_pre_analysis<NumIndices, Gen...>::root_type Base;
-
-  // make standard constructors + assignment operators public
-  inline SGroup() : Base() {}
-  inline SGroup(const SGroup<Gen...>& other) : Base(other) {}
-  inline SGroup(SGroup<Gen...>&& other) : Base(other) {}
-  inline SGroup<Gen...>& operator=(const SGroup<Gen...>& other) {
-    Base::operator=(other);
-    return *this;
-  }
-  inline SGroup<Gen...>& operator=(SGroup<Gen...>&& other) {
-    Base::operator=(other);
-    return *this;
-  }
-
-  // all else is defined in the base class
-};
-
-namespace internal {
-
-template <typename... Sym>
-struct tensor_symmetry_num_indices {
-  constexpr static std::size_t value = 1;
-};
-
-template <int One_, int Two_, typename... Sym>
-struct tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {
- private:
-  constexpr static std::size_t One = static_cast<std::size_t>(One_);
-  constexpr static std::size_t Two = static_cast<std::size_t>(Two_);
-  constexpr static std::size_t Three = tensor_symmetry_num_indices<Sym...>::value;
-
-  // don't use std::max, since it's not constexpr until C++14...
-  constexpr static std::size_t maxOneTwoPlusOne = ((One > Two) ? One : Two) + 1;
-
- public:
-  constexpr static std::size_t value = (maxOneTwoPlusOne > Three) ? maxOneTwoPlusOne : Three;
-};
-
-template <int One_, int Two_, typename... Sym>
-struct tensor_symmetry_num_indices<AntiSymmetry<One_, Two_>, Sym...>
-    : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};
-template <int One_, int Two_, typename... Sym>
-struct tensor_symmetry_num_indices<Hermiticity<One_, Two_>, Sym...>
-    : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};
-template <int One_, int Two_, typename... Sym>
-struct tensor_symmetry_num_indices<AntiHermiticity<One_, Two_>, Sym...>
-    : public tensor_symmetry_num_indices<Symmetry<One_, Two_>, Sym...> {};
-
-/** \internal
- *
- * \class tensor_symmetry_pre_analysis
- * \ingroup TensorSymmetry_Module
- *
- * \brief Pre-select whether to use a static or dynamic symmetry group
- *
- * When a symmetry group could in principle be determined at compile time,
- * this template implements the logic whether to actually do that or whether
- * to rather defer that to runtime.
- *
- * The logic is as follows:
- * <dl>
- * <dt><b>No generators (trivial symmetry):</b></dt>
- * <dd>Use a trivial static group. Ideally, this has no performance impact
- *     compared to not using symmetry at all. In practice, this might not
- *     be the case.</dd>
- * <dt><b>More than 4 generators:</b></dt>
- * <dd>Calculate the group at run time, it is likely far too large for the
- *     compiler to be able to properly generate it in a realistic time.</dd>
- * <dt><b>Up to and including 4 generators:</b></dt>
- * <dd>Actually enumerate all group elements, but then check how many there
- *     are. If there are more than 16, it is unlikely that unrolling the
- *     loop (as is done in the static compile-time case) is sensible, so
- *     use a dynamic group instead. If there are at most 16 elements, actually
- *     use that static group. Note that the largest group with 4 generators
- *     still compiles with reasonable resources.</dd>
- * </dl>
- *
- * Note: Example compile time performance with g++-4.6 on an Intenl Core i5-3470
- *       with 16 GiB RAM (all generators non-redundant and the subgroups don't
- *       factorize):
- *
- *          # Generators          -O0 -ggdb               -O2
- *          -------------------------------------------------------------------
- *          1                 0.5 s  /   250 MiB     0.45s /   230 MiB
- *          2                 0.5 s  /   260 MiB     0.5 s /   250 MiB
- *          3                 0.65s  /   310 MiB     0.62s /   310 MiB
- *          4                 2.2 s  /   860 MiB     1.7 s /   770 MiB
- *          5               130   s  / 13000 MiB   120   s / 11000 MiB
- *
- * It is clear that everything is still very efficient up to 4 generators, then
- * the memory and CPU requirements become unreasonable. Thus we only instantiate
- * the template group theory logic if the number of generators supplied is 4 or
- * lower, otherwise this will be forced to be done during runtime, where the
- * algorithm is reasonably fast.
- */
-template <std::size_t NumIndices>
-struct tensor_symmetry_pre_analysis<NumIndices> {
-  typedef StaticSGroup<> root_type;
-};
-
-template <std::size_t NumIndices, typename Gen_, typename... Gens_>
-struct tensor_symmetry_pre_analysis<NumIndices, Gen_, Gens_...> {
-  constexpr static std::size_t max_static_generators = 4;
-  constexpr static std::size_t max_static_elements = 16;
-  typedef tensor_static_symgroup_if<(sizeof...(Gens_) + 1 <= max_static_generators), NumIndices, Gen_, Gens_...> helper;
-  constexpr static std::size_t possible_size = helper::size;
-
-  typedef std::conditional_t<possible_size == 0 || possible_size >= max_static_elements,
-                             DynamicSGroupFromTemplateArgs<Gen_, Gens_...>, typename helper::type>
-      root_type;
-};
-
-template <bool instantiate, std::size_t NumIndices, typename... Gens>
-struct tensor_static_symgroup_if {
-  constexpr static std::size_t size = 0;
-  typedef void type;
-};
-
-template <std::size_t NumIndices, typename... Gens>
-struct tensor_static_symgroup_if<true, NumIndices, Gens...> : tensor_static_symgroup<NumIndices, Gens...> {};
-
-template <typename Tensor_>
-struct tensor_symmetry_assign_value {
-  typedef typename Tensor_::Index Index;
-  typedef typename Tensor_::Scalar Scalar;
-  constexpr static std::size_t NumIndices = Tensor_::NumIndices;
-
-  static inline int run(const std::array<Index, NumIndices>& transformed_indices, int transformation_flags, int dummy,
-                        Tensor_& tensor, const Scalar& value_) {
-    Scalar value(value_);
-    if (transformation_flags & ConjugationFlag) value = numext::conj(value);
-    if (transformation_flags & NegationFlag) value = -value;
-    tensor.coeffRef(transformed_indices) = value;
-    return dummy;
-  }
-};
-
-template <typename Tensor_>
-struct tensor_symmetry_calculate_flags {
-  typedef typename Tensor_::Index Index;
-  constexpr static std::size_t NumIndices = Tensor_::NumIndices;
-
-  static inline int run(const std::array<Index, NumIndices>& transformed_indices, int transform_flags,
-                        int current_flags, const std::array<Index, NumIndices>& orig_indices) {
-    if (transformed_indices == orig_indices) {
-      if (transform_flags & (ConjugationFlag | NegationFlag))
-        return current_flags | GlobalImagFlag;  // anti-hermitian diagonal
-      else if (transform_flags & ConjugationFlag)
-        return current_flags | GlobalRealFlag;  // hermitian diagonal
-      else if (transform_flags & NegationFlag)
-        return current_flags | GlobalZeroFlag;  // anti-symmetric diagonal
-    }
-    return current_flags;
-  }
-};
-
-template <typename Tensor_, typename Symmetry_, int Flags = 0>
-class tensor_symmetry_value_setter {
- public:
-  typedef typename Tensor_::Index Index;
-  typedef typename Tensor_::Scalar Scalar;
-  constexpr static std::size_t NumIndices = Tensor_::NumIndices;
-
-  inline tensor_symmetry_value_setter(Tensor_& tensor, Symmetry_ const& symmetry,
-                                      std::array<Index, NumIndices> const& indices)
-      : m_tensor(tensor), m_symmetry(symmetry), m_indices(indices) {}
-
-  inline tensor_symmetry_value_setter<Tensor_, Symmetry_, Flags>& operator=(Scalar const& value) {
-    doAssign(value);
-    return *this;
-  }
-
- private:
-  Tensor_& m_tensor;
-  Symmetry_ m_symmetry;
-  std::array<Index, NumIndices> m_indices;
-
-  inline void doAssign(Scalar const& value) {
-#ifdef EIGEN_TENSOR_SYMMETRY_CHECK_VALUES
-    int value_flags = m_symmetry.template apply<internal::tensor_symmetry_calculate_flags<Tensor_>, int>(
-        m_indices, m_symmetry.globalFlags(), m_indices);
-    if (value_flags & GlobalRealFlag) eigen_assert(numext::imag(value) == 0);
-    if (value_flags & GlobalImagFlag) eigen_assert(numext::real(value) == 0);
-#endif
-    m_symmetry.template apply<internal::tensor_symmetry_assign_value<Tensor_>, int>(m_indices, 0, m_tensor, value);
-  }
-};
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSORSYMMETRY_SYMMETRY_H
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */
diff --git a/unsupported/Eigen/src/TensorSymmetry/util/TemplateGroupTheory.h b/unsupported/Eigen/src/TensorSymmetry/util/TemplateGroupTheory.h
deleted file mode 100644
index df8da6c..0000000
--- a/unsupported/Eigen/src/TensorSymmetry/util/TemplateGroupTheory.h
+++ /dev/null
@@ -1,491 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H
-#define EIGEN_CXX11_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H
-
-// IWYU pragma: private
-#include "../InternalHeaderCheck.h"
-
-namespace Eigen {
-
-namespace internal {
-
-namespace group_theory {
-
-/** \internal
- * \file CXX11/src/TensorSymmetry/util/TemplateGroupTheory.h
- * This file contains C++ templates that implement group theory algorithms.
- *
- * The algorithms allow for a compile-time analysis of finite groups.
- *
- * Currently only Dimino's algorithm is implemented, which returns a list
- * of all elements in a group given a set of (possibly redundant) generators.
- * (One could also do that with the so-called orbital algorithm, but that
- * is much more expensive and usually has no advantages.)
- */
-
-/**********************************************************************
- *                "Ok kid, here is where it gets complicated."
- *                         - Amelia Pond in the "Doctor Who" episode
- *                           "The Big Bang"
- *
- * Dimino's algorithm
- * ==================
- *
- * The following is Dimino's algorithm in sequential form:
- *
- * Input: identity element, list of generators, equality check,
- *        multiplication operation
- * Output: list of group elements
- *
- * 1. add identity element
- * 2. remove identities from list of generators
- * 3. add all powers of first generator that aren't the
- *    identity element
- * 4. go through all remaining generators:
- *        a. if generator is already in the list of elements
- *                -> do nothing
- *        b. otherwise
- *                i.   remember current # of elements
- *                     (i.e. the size of the current subgroup)
- *                ii.  add all current elements (which includes
- *                     the identity) each multiplied from right
- *                     with the current generator to the group
- *                iii. add all remaining cosets that are generated
- *                     by products of the new generator with itself
- *                     and all other generators seen so far
- *
- * In functional form, this is implemented as a long set of recursive
- * templates that have a complicated relationship.
- *
- * The main interface for Dimino's algorithm is the template
- * enumerate_group_elements. All lists are implemented as variadic
- * type_list<typename...> and numeric_list<typename = int, int...>
- * templates.
- *
- * 'Calling' templates is usually done via typedefs.
- *
- * This algorithm is an extended version of the basic version. The
- * extension consists in the fact that each group element has a set
- * of flags associated with it. Multiplication of two group elements
- * with each other results in a group element whose flags are the
- * XOR of the flags of the previous elements. Each time the algorithm
- * notices that a group element it just calculated is already in the
- * list of current elements, the flags of both will be compared and
- * added to the so-called 'global flags' of the group.
- *
- * The rationale behind this extension is that this allows not only
- * for the description of symmetries between tensor indices, but
- * also allows for the description of hermiticity, antisymmetry and
- * antihermiticity. Negation and conjugation each are specific bit
- * in the flags value and if two different ways to reach a group
- * element lead to two different flags, this poses a constraint on
- * the allowed values of the resulting tensor. For example, if a
- * group element is reach both with and without the conjugation
- * flags, it is clear that the resulting tensor has to be real.
- *
- * Note that this flag mechanism is quite generic and may have other
- * uses beyond tensor properties.
- *
- * IMPORTANT:
- *     This algorithm assumes the group to be finite. If you try to
- *     run it with a group that's infinite, the algorithm will only
- *     terminate once you hit a compiler limit (max template depth).
- *     Also note that trying to use this implementation to create a
- *     very large group will probably either make you hit the same
- *     limit, cause the compiler to segfault or at the very least
- *     take a *really* long time (hours, days, weeks - sic!) to
- *     compile. It is not recommended to plug in more than 4
- *     generators, unless they are independent of each other.
- */
-
-/** \internal
- *
- * \class strip_identities
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Cleanse a list of group elements of the identity element
- *
- * This template is used to make a first pass through all initial
- * generators of Dimino's algorithm and remove the identity
- * elements.
- *
- * \sa enumerate_group_elements
- */
-template <template <typename, typename> class Equality, typename id, typename L>
-struct strip_identities;
-
-template <template <typename, typename> class Equality, typename id, typename t, typename... ts>
-struct strip_identities<Equality, id, type_list<t, ts...>> {
-  typedef std::conditional_t<
-      Equality<id, t>::value, typename strip_identities<Equality, id, type_list<ts...>>::type,
-      typename concat<type_list<t>, typename strip_identities<Equality, id, type_list<ts...>>::type>::type>
-      type;
-  constexpr static int global_flags =
-      Equality<id, t>::global_flags | strip_identities<Equality, id, type_list<ts...>>::global_flags;
-};
-
-template <template <typename, typename> class Equality, typename id>
-struct strip_identities<Equality, id, type_list<>> {
-  typedef type_list<> type;
-  constexpr static int global_flags = 0;
-};
-
-/** \internal
- *
- * \class dimino_first_step_elements_helper
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Recursive template that adds powers of the first generator to the list of group elements
- *
- * This template calls itself recursively to add powers of the first
- * generator to the list of group elements. It stops if it reaches
- * the identity element again.
- *
- * \sa enumerate_group_elements, dimino_first_step_elements
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename g, typename current_element, typename elements,
-          bool dont_add_current_element  // = false
-          >
-struct dimino_first_step_elements_helper
-#ifndef EIGEN_PARSED_BY_DOXYGEN
-    :  // recursive inheritance is too difficult for Doxygen
-       public dimino_first_step_elements_helper<Multiply, Equality, id, g, typename Multiply<current_element, g>::type,
-                                                typename concat<elements, type_list<current_element>>::type,
-                                                Equality<typename Multiply<current_element, g>::type, id>::value> {
-};
-
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename g, typename current_element, typename elements>
-struct dimino_first_step_elements_helper<Multiply, Equality, id, g, current_element, elements, true>
-#endif  // EIGEN_PARSED_BY_DOXYGEN
-{
-  typedef elements type;
-  constexpr static int global_flags = Equality<current_element, id>::global_flags;
-};
-
-/** \internal
- *
- * \class dimino_first_step_elements
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Add all powers of the first generator to the list of group elements
- *
- * This template takes the first non-identity generator and generates the initial
- * list of elements which consists of all powers of that generator. For a group
- * with just one generated, it would be enumerated after this.
- *
- * \sa enumerate_group_elements
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename generators>
-struct dimino_first_step_elements {
-  typedef typename get<0, generators>::type first_generator;
-  typedef typename skip<1, generators>::type next_generators;
-  typedef type_list<first_generator> generators_done;
-
-  typedef dimino_first_step_elements_helper<Multiply, Equality, id, first_generator, first_generator, type_list<id>,
-                                            false>
-      helper;
-  typedef typename helper::type type;
-  constexpr static int global_flags = helper::global_flags;
-};
-
-/** \internal
- *
- * \class dimino_get_coset_elements
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Generate all elements of a specific coset
- *
- * This template generates all the elements of a specific coset by
- * multiplying all elements in the given subgroup with the new
- * coset representative. Note that the first element of the
- * subgroup is always the identity element, so the first element of
- * the result of this template is going to be the coset
- * representative itself.
- *
- * Note that this template accepts an additional boolean parameter
- * that specifies whether to actually generate the coset (true) or
- * just return an empty list (false).
- *
- * \sa enumerate_group_elements, dimino_add_cosets_for_rep
- */
-template <template <typename, typename> class Multiply, typename sub_group_elements, typename new_coset_rep,
-          bool generate_coset  // = true
-          >
-struct dimino_get_coset_elements {
-  typedef typename apply_op_from_right<Multiply, new_coset_rep, sub_group_elements>::type type;
-};
-
-template <template <typename, typename> class Multiply, typename sub_group_elements, typename new_coset_rep>
-struct dimino_get_coset_elements<Multiply, sub_group_elements, new_coset_rep, false> {
-  typedef type_list<> type;
-};
-
-/** \internal
- *
- * \class dimino_add_cosets_for_rep
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Recursive template for adding coset spaces
- *
- * This template multiplies the coset representative with a generator
- * from the list of previous generators. If the new element is not in
- * the group already, it adds the corresponding coset. Finally it
- * proceeds to call itself with the next generator from the list.
- *
- * \sa enumerate_group_elements, dimino_add_all_coset_spaces
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename sub_group_elements, typename elements, typename generators, typename rep_element, int sub_group_size>
-struct dimino_add_cosets_for_rep;
-
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename sub_group_elements, typename elements, typename g, typename... gs, typename rep_element,
-          int sub_group_size>
-struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, type_list<g, gs...>, rep_element,
-                                 sub_group_size> {
-  typedef typename Multiply<rep_element, g>::type new_coset_rep;
-  typedef contained_in_list_gf<Equality, new_coset_rep, elements> _cil;
-  constexpr static bool add_coset = !_cil::value;
-
-  typedef
-      typename dimino_get_coset_elements<Multiply, sub_group_elements, new_coset_rep, add_coset>::type coset_elements;
-
-  typedef dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements,
-                                    typename concat<elements, coset_elements>::type, type_list<gs...>, rep_element,
-                                    sub_group_size>
-      _helper;
-
-  typedef typename _helper::type type;
-  constexpr static int global_flags = _cil::global_flags | _helper::global_flags;
-
-  /* Note that we don't have to update global flags here, since
-   * we will only add these elements if they are not part of
-   * the group already. But that only happens if the coset rep
-   * is not already in the group, so the check for the coset rep
-   * will catch this.
-   */
-};
-
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename sub_group_elements, typename elements, typename rep_element, int sub_group_size>
-struct dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, type_list<>, rep_element,
-                                 sub_group_size> {
-  typedef elements type;
-  constexpr static int global_flags = 0;
-};
-
-/** \internal
- *
- * \class dimino_add_all_coset_spaces
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Recursive template for adding all coset spaces for a new generator
- *
- * This template tries to go through the list of generators (with
- * the help of the dimino_add_cosets_for_rep template) as long as
- * it still finds elements that are not part of the group and add
- * the corresponding cosets.
- *
- * \sa enumerate_group_elements, dimino_add_cosets_for_rep
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename sub_group_elements, typename elements, typename generators, int sub_group_size, int rep_pos,
-          bool stop_condition  // = false
-          >
-struct dimino_add_all_coset_spaces {
-  typedef typename get<rep_pos, elements>::type rep_element;
-  typedef dimino_add_cosets_for_rep<Multiply, Equality, id, sub_group_elements, elements, generators, rep_element,
-                                    sub_group_elements::count>
-      _ac4r;
-  typedef typename _ac4r::type new_elements;
-
-  constexpr static int new_rep_pos = rep_pos + sub_group_elements::count;
-  constexpr static bool new_stop_condition = new_rep_pos >= new_elements::count;
-
-  typedef dimino_add_all_coset_spaces<Multiply, Equality, id, sub_group_elements, new_elements, generators,
-                                      sub_group_size, new_rep_pos, new_stop_condition>
-      _helper;
-
-  typedef typename _helper::type type;
-  constexpr static int global_flags = _helper::global_flags | _ac4r::global_flags;
-};
-
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename sub_group_elements, typename elements, typename generators, int sub_group_size, int rep_pos>
-struct dimino_add_all_coset_spaces<Multiply, Equality, id, sub_group_elements, elements, generators, sub_group_size,
-                                   rep_pos, true> {
-  typedef elements type;
-  constexpr static int global_flags = 0;
-};
-
-/** \internal
- *
- * \class dimino_add_generator
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Enlarge the group by adding a new generator.
- *
- * It accepts a boolean parameter that determines if the generator is redundant,
- * i.e. was already seen in the group. In that case, it reduces to a no-op.
- *
- * \sa enumerate_group_elements, dimino_add_all_coset_spaces
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename elements, typename generators_done, typename current_generator,
-          bool redundant  // = false
-          >
-struct dimino_add_generator {
-  /* this template is only called if the generator is not redundant
-   * => all elements of the group multiplied with the new generator
-   *    are going to be new elements of the most trivial coset space
-   */
-  typedef typename apply_op_from_right<Multiply, current_generator, elements>::type multiplied_elements;
-  typedef typename concat<elements, multiplied_elements>::type new_elements;
-
-  constexpr static int rep_pos = elements::count;
-
-  typedef dimino_add_all_coset_spaces<
-      Multiply, Equality, id,
-      elements,  // elements of previous subgroup
-      new_elements, typename concat<generators_done, type_list<current_generator>>::type,
-      elements::count,  // size of previous subgroup
-      rep_pos,
-      false  // don't stop (because rep_pos >= new_elements::count is always false at this point)
-      >
-      _helper;
-  typedef typename _helper::type type;
-  constexpr static int global_flags = _helper::global_flags;
-};
-
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename elements, typename generators_done, typename current_generator>
-struct dimino_add_generator<Multiply, Equality, id, elements, generators_done, current_generator, true> {
-  // redundant case
-  typedef elements type;
-  constexpr static int global_flags = 0;
-};
-
-/** \internal
- *
- * \class dimino_add_remaining_generators
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Recursive template that adds all remaining generators to a group
- *
- * Loop through the list of generators that remain and successively
- * add them to the group.
- *
- * \sa enumerate_group_elements, dimino_add_generator
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename generators_done, typename remaining_generators, typename elements>
-struct dimino_add_remaining_generators {
-  typedef typename get<0, remaining_generators>::type first_generator;
-  typedef typename skip<1, remaining_generators>::type next_generators;
-
-  typedef contained_in_list_gf<Equality, first_generator, elements> _cil;
-
-  typedef dimino_add_generator<Multiply, Equality, id, elements, generators_done, first_generator, _cil::value> _helper;
-
-  typedef typename _helper::type new_elements;
-
-  typedef dimino_add_remaining_generators<Multiply, Equality, id,
-                                          typename concat<generators_done, type_list<first_generator>>::type,
-                                          next_generators, new_elements>
-      _next_iter;
-
-  typedef typename _next_iter::type type;
-  constexpr static int global_flags = _cil::global_flags | _helper::global_flags | _next_iter::global_flags;
-};
-
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename generators_done, typename elements>
-struct dimino_add_remaining_generators<Multiply, Equality, id, generators_done, type_list<>, elements> {
-  typedef elements type;
-  constexpr static int global_flags = 0;
-};
-
-/** \internal
- *
- * \class enumerate_group_elements_noid
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Helper template that implements group element enumeration
- *
- * This is a helper template that implements the actual enumeration
- * of group elements. This has been split so that the list of
- * generators can be cleansed of the identity element before
- * performing the actual operation.
- *
- * \sa enumerate_group_elements
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename generators, int initial_global_flags = 0>
-struct enumerate_group_elements_noid {
-  typedef dimino_first_step_elements<Multiply, Equality, id, generators> first_step;
-  typedef typename first_step::type first_step_elements;
-
-  typedef dimino_add_remaining_generators<Multiply, Equality, id, typename first_step::generators_done,
-                                          typename first_step::next_generators,  // remaining_generators
-                                          typename first_step::type              // first_step elements
-                                          >
-      _helper;
-
-  typedef typename _helper::type type;
-  constexpr static int global_flags = initial_global_flags | first_step::global_flags | _helper::global_flags;
-};
-
-// in case when no generators are specified
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          int initial_global_flags>
-struct enumerate_group_elements_noid<Multiply, Equality, id, type_list<>, initial_global_flags> {
-  typedef type_list<id> type;
-  constexpr static int global_flags = initial_global_flags;
-};
-
-/** \internal
- *
- * \class enumerate_group_elements
- * \ingroup CXX11_TensorSymmetry_Module
- *
- * \brief Enumerate all elements in a finite group
- *
- * This template enumerates all elements in a finite group. It accepts
- * the following template parameters:
- *
- * \tparam Multiply      The multiplication operation that multiplies two group elements
- *                       with each other.
- * \tparam Equality      The equality check operation that checks if two group elements
- *                       are equal to another.
- * \tparam id            The identity element
- * \tparam Generators_   A list of (possibly redundant) generators of the group
- */
-template <template <typename, typename> class Multiply, template <typename, typename> class Equality, typename id,
-          typename Generators_>
-struct enumerate_group_elements
-    : public enumerate_group_elements_noid<Multiply, Equality, id,
-                                           typename strip_identities<Equality, id, Generators_>::type,
-                                           strip_identities<Equality, id, Generators_>::global_flags> {};
-
-}  // end namespace group_theory
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11_TENSORSYMMETRY_TEMPLATEGROUPTHEORY_H
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */
diff --git a/unsupported/Eigen/src/TensorUtil/CXX11Meta.h b/unsupported/Eigen/src/TensorUtil/CXX11Meta.h
deleted file mode 100644
index f836cd1..0000000
--- a/unsupported/Eigen/src/TensorUtil/CXX11Meta.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11META_H
-#define EIGEN_CXX11META_H
-
-#include <vector>
-#include "../../../../Eigen/src/Core/util/EmulateArray.h"
-
-#include "CXX11Workarounds.h"
-
-#endif  // EIGEN_CXX11META_H
diff --git a/unsupported/Eigen/src/TensorUtil/CXX11Workarounds.h b/unsupported/Eigen/src/TensorUtil/CXX11Workarounds.h
deleted file mode 100644
index ffc198c..0000000
--- a/unsupported/Eigen/src/TensorUtil/CXX11Workarounds.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_CXX11WORKAROUNDS_H
-#define EIGEN_CXX11WORKAROUNDS_H
-
-namespace Eigen {
-
-namespace internal {
-
-/* array_get overloads for std::vector, used by tensor code.
- */
-
-template <std::size_t I_, class T>
-constexpr T& array_get(std::vector<T>& a) {
-  return a[I_];
-}
-template <std::size_t I_, class T>
-constexpr T&& array_get(std::vector<T>&& a) {
-  return a[I_];
-}
-template <std::size_t I_, class T>
-constexpr T const& array_get(std::vector<T> const& a) {
-  return a[I_];
-}
-
-}  // end namespace internal
-
-}  // end namespace Eigen
-
-#endif  // EIGEN_CXX11WORKAROUNDS_H
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */
diff --git a/unsupported/README.txt b/unsupported/README.txt
deleted file mode 100644
index 70793bf..0000000
--- a/unsupported/README.txt
+++ /dev/null
@@ -1,50 +0,0 @@
-This directory contains contributions from various users.
-They are provided "as is", without any support. Nevertheless,
-most of them are subject to be included in Eigen in the future.
-
-In order to use an unsupported module you have to do either:
-
- - add the path_to_eigen/unsupported directory to your include path and do:
-   #include <Eigen/ModuleHeader>
-
- - or directly do:
-   #include <unsupported/Eigen/ModuleHeader>
-
-
-If you are interested in contributing to one of them, or have other stuff
-you would like to share, feel free to contact us:
-http://eigen.tuxfamily.org/index.php?title=Main_Page#Mailing_list
-
-Any kind of contributions are much appreciated, even very preliminary ones.
-However, it:
- - must rely on Eigen,
- - must be highly related to math,
- - should have some general purpose in the sense that it could
-   potentially become an official Eigen module (or be merged into another one).
-
-In doubt feel free to contact us. For instance, if your addons is very too specific
-but it shows an interesting way of using Eigen, then it could be a nice demo.
-
-
-This directory is organized as follow:
-
-unsupported/Eigen/ModuleHeader1
-unsupported/Eigen/ModuleHeader2
-unsupported/Eigen/...
-unsupported/Eigen/src/Module1/SourceFile1.h
-unsupported/Eigen/src/Module1/SourceFile2.h
-unsupported/Eigen/src/Module1/...
-unsupported/Eigen/src/Module2/SourceFile1.h
-unsupported/Eigen/src/Module2/SourceFile2.h
-unsupported/Eigen/src/Module2/...
-unsupported/Eigen/src/...
-unsupported/doc/snippets/.cpp   <- code snippets for the doc
-unsupported/doc/examples/.cpp   <- examples for the doc
-unsupported/doc/TutorialModule1.dox
-unsupported/doc/TutorialModule2.dox
-unsupported/doc/...
-unsupported/test/.cpp           <- unit test files
-
-The documentation is generated at the same time than the main Eigen documentation.
-The .html files are generated in: build_dir/doc/html/unsupported/
-
diff --git a/unsupported/benchmarks/AutoDiff/CMakeLists.txt b/unsupported/benchmarks/AutoDiff/CMakeLists.txt
deleted file mode 100644
index cb5b986..0000000
--- a/unsupported/benchmarks/AutoDiff/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-eigen_add_benchmark(bench_autodiff bench_autodiff.cpp)
diff --git a/unsupported/benchmarks/AutoDiff/bench_autodiff.cpp b/unsupported/benchmarks/AutoDiff/bench_autodiff.cpp
deleted file mode 100644
index 74c334f..0000000
--- a/unsupported/benchmarks/AutoDiff/bench_autodiff.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-// Benchmarks for Eigen AutoDiff module.
-// Compares AutoDiff Jacobian computation against NumericalDiff and hand-coded Jacobians.
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <unsupported/Eigen/AutoDiff>
-#include <unsupported/Eigen/NumericalDiff>
-
-using namespace Eigen;
-
-// --- Small functor: Rosenbrock-like (2 inputs -> 2 outputs) ---
-struct SmallFunctor {
-  typedef Matrix<double, 2, 1> InputType;
-  typedef Matrix<double, 2, 1> ValueType;
-  typedef Matrix<double, 2, 2> JacobianType;
-
-  enum { InputsAtCompileTime = 2, ValuesAtCompileTime = 2 };
-
-  template <typename T>
-  void operator()(const Matrix<T, 2, 1>& x, Matrix<T, 2, 1>* v) const {
-    (*v)(0) = T(1) - x(0);
-    (*v)(1) = T(10) * (x(1) - x(0) * x(0));
-  }
-};
-
-// --- Medium functor: chain of operations (6 inputs -> 6 outputs) ---
-struct MediumFunctor {
-  typedef Matrix<double, 6, 1> InputType;
-  typedef Matrix<double, 6, 1> ValueType;
-  typedef Matrix<double, 6, 6> JacobianType;
-
-  enum { InputsAtCompileTime = 6, ValuesAtCompileTime = 6 };
-
-  template <typename T>
-  void operator()(const Matrix<T, 6, 1>& x, Matrix<T, 6, 1>* v) const {
-    (*v)(0) = sin(x(0)) * cos(x(1)) + x(2) * x(2);
-    (*v)(1) = exp(x(1) * T(0.1)) + x(3);
-    (*v)(2) = x(0) * x(2) - x(4) * x(5);
-    (*v)(3) = sqrt(x(3) * x(3) + T(1)) + x(0);
-    (*v)(4) = x(4) * x(4) + x(5) * x(5) + x(0) * x(1);
-    (*v)(5) = log(x(2) * x(2) + T(1)) + x(3) * x(4);
-  }
-};
-
-// --- Dynamic-size functor (N inputs -> N outputs) ---
-struct DynamicFunctor {
-  typedef Matrix<double, Dynamic, 1> InputType;
-  typedef Matrix<double, Dynamic, 1> ValueType;
-  typedef Matrix<double, Dynamic, Dynamic> JacobianType;
-
-  const int n_;
-  DynamicFunctor(int n) : n_(n) {}
-
-  enum { InputsAtCompileTime = Dynamic, ValuesAtCompileTime = Dynamic };
-
-  int inputs() const { return n_; }
-  int values() const { return n_; }
-
-  template <typename T>
-  void operator()(const Matrix<T, Dynamic, 1>& x, Matrix<T, Dynamic, 1>* v) const {
-    v->resize(n_);
-    (*v)(0) = T(1) - x(0);
-    for (int i = 1; i < n_; ++i) {
-      (*v)(i) = T(10) * (x(i) - x(i - 1) * x(i - 1));
-    }
-  }
-};
-
-// Wrapper for NumericalDiff compatibility.
-struct SmallFunctorND : SmallFunctor {
-  typedef double Scalar;
-  int inputs() const { return 2; }
-  int values() const { return 2; }
-  int operator()(const InputType& x, ValueType& v) const {
-    SmallFunctor::operator()(x, &v);
-    return 0;
-  }
-};
-
-struct MediumFunctorND : MediumFunctor {
-  typedef double Scalar;
-  int inputs() const { return 6; }
-  int values() const { return 6; }
-  int operator()(const InputType& x, ValueType& v) const {
-    MediumFunctor::operator()(x, &v);
-    return 0;
-  }
-};
-
-// --- AutoDiff Jacobian benchmarks ---
-template <typename Functor>
-static void BM_AutoDiffJacobian(benchmark::State& state, Functor func) {
-  AutoDiffJacobian<Functor> adf(func);
-  typename Functor::InputType x = Functor::InputType::Random();
-  typename Functor::ValueType v;
-  typename Functor::JacobianType jac;
-
-  for (auto _ : state) {
-    adf(x, &v, &jac);
-    benchmark::DoNotOptimize(jac.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// --- Dynamic AutoDiff Jacobian ---
-static void BM_AutoDiffJacobian_Dynamic(benchmark::State& state) {
-  int n = state.range(0);
-  DynamicFunctor func(n);
-  AutoDiffJacobian<DynamicFunctor> adf(func);
-
-  VectorXd x = VectorXd::Random(n);
-  VectorXd v(n);
-  MatrixXd jac(n, n);
-
-  for (auto _ : state) {
-    adf(x, &v, &jac);
-    benchmark::DoNotOptimize(jac.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// --- NumericalDiff benchmarks ---
-template <typename Functor>
-static void BM_NumericalDiffJacobian(benchmark::State& state, Functor func) {
-  NumericalDiff<Functor> ndf(func);
-  typename Functor::InputType x = Functor::InputType::Random();
-  typename Functor::JacobianType jac;
-
-  for (auto _ : state) {
-    ndf.df(x, jac);
-    benchmark::DoNotOptimize(jac.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// --- Hand-coded Jacobian (Rosenbrock) for comparison ---
-static void BM_HandCoded_Small(benchmark::State& state) {
-  Vector2d x = Vector2d::Random();
-  Matrix2d jac;
-
-  for (auto _ : state) {
-    jac(0, 0) = -1;
-    jac(0, 1) = 0;
-    jac(1, 0) = -20 * x(0);
-    jac(1, 1) = 10;
-    benchmark::DoNotOptimize(jac.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// --- Scalar AutoDiff evaluation (no Jacobian, just forward pass) ---
-static void BM_AutoDiffScalar_Eval(benchmark::State& state) {
-  int n = state.range(0);
-  using ADScalar = AutoDiffScalar<VectorXd>;
-  VectorXd x = VectorXd::Random(n);
-
-  for (auto _ : state) {
-    ADScalar sum(0.0, VectorXd::Zero(n));
-    for (int i = 0; i < n; ++i) {
-      ADScalar xi(x(i), n, i);
-      sum += xi * xi + sin(xi);
-    }
-    benchmark::DoNotOptimize(sum.value());
-    benchmark::DoNotOptimize(sum.derivatives().data());
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK_CAPTURE(BM_AutoDiffJacobian, Small, SmallFunctor());
-BENCHMARK_CAPTURE(BM_AutoDiffJacobian, Medium, MediumFunctor());
-BENCHMARK(BM_AutoDiffJacobian_Dynamic)->Arg(2)->Arg(6)->Arg(20)->Arg(50)->Arg(100);
-
-BENCHMARK_CAPTURE(BM_NumericalDiffJacobian, Small, SmallFunctorND());
-BENCHMARK_CAPTURE(BM_NumericalDiffJacobian, Medium, MediumFunctorND());
-
-BENCHMARK(BM_HandCoded_Small);
-BENCHMARK(BM_AutoDiffScalar_Eval)->Arg(2)->Arg(6)->Arg(20)->Arg(50)->Arg(100);
diff --git a/unsupported/benchmarks/CMakeLists.txt b/unsupported/benchmarks/CMakeLists.txt
deleted file mode 100644
index ed8c88e..0000000
--- a/unsupported/benchmarks/CMakeLists.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(EigenUnsupportedBenchmarks CXX)
-
-find_package(benchmark REQUIRED)
-find_package(Threads REQUIRED)
-
-set(EIGEN_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
-
-# Helper: add a Google Benchmark target (mirrors benchmarks/CMakeLists.txt).
-#   eigen_add_benchmark(name source [LIBRARIES lib1 lib2 ...] [DEFINITIONS def1 def2 ...])
-function(eigen_add_benchmark name source)
-  cmake_parse_arguments(BENCH "" "" "LIBRARIES;DEFINITIONS" ${ARGN})
-  if(NOT IS_ABSOLUTE "${source}")
-    set(source "${CMAKE_CURRENT_SOURCE_DIR}/${source}")
-  endif()
-  add_executable(${name} ${source})
-  target_include_directories(${name} PRIVATE ${EIGEN_SOURCE_DIR})
-  target_link_libraries(${name} PRIVATE benchmark::benchmark benchmark::benchmark_main
-                                        Threads::Threads)
-  if(BENCH_LIBRARIES)
-    target_link_libraries(${name} PRIVATE ${BENCH_LIBRARIES})
-  endif()
-  target_compile_options(${name} PRIVATE -O3 -DNDEBUG)
-  if(BENCH_DEFINITIONS)
-    target_compile_definitions(${name} PRIVATE ${BENCH_DEFINITIONS})
-  endif()
-endfunction()
-
-add_subdirectory(Tensor)
-add_subdirectory(MatrixFunctions)
-add_subdirectory(SpecialFunctions)
-add_subdirectory(AutoDiff)
-add_subdirectory(Splines)
-add_subdirectory(IterativeSolvers)
-add_subdirectory(KroneckerProduct)
diff --git a/unsupported/benchmarks/IterativeSolvers/CMakeLists.txt b/unsupported/benchmarks/IterativeSolvers/CMakeLists.txt
deleted file mode 100644
index 4ae536a..0000000
--- a/unsupported/benchmarks/IterativeSolvers/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-eigen_add_benchmark(bench_iterative_solvers bench_iterative_solvers.cpp)
diff --git a/unsupported/benchmarks/IterativeSolvers/bench_iterative_solvers.cpp b/unsupported/benchmarks/IterativeSolvers/bench_iterative_solvers.cpp
deleted file mode 100644
index 5105d40..0000000
--- a/unsupported/benchmarks/IterativeSolvers/bench_iterative_solvers.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-// Benchmarks for unsupported iterative solvers: GMRES, MINRES, IDRS, IDRSTABL, BiCGSTABL, DGMRES.
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Sparse>
-#include <Eigen/IterativeLinearSolvers>
-#include <unsupported/Eigen/IterativeSolvers>
-
-using namespace Eigen;
-
-typedef double Scalar;
-typedef SparseMatrix<Scalar> SpMat;
-typedef Matrix<Scalar, Dynamic, 1> Vec;
-
-// Generate a SPD sparse matrix (Laplacian-like with diagonal dominance).
-static SpMat generateSPD(int n, int bandwidth) {
-  SpMat A(n, n);
-  std::vector<Triplet<Scalar>> trips;
-  trips.reserve(n * (2 * bandwidth + 1));
-  for (int i = 0; i < n; ++i) {
-    Scalar diag = 0;
-    for (int j = std::max(0, i - bandwidth); j < std::min(n, i + bandwidth + 1); ++j) {
-      if (i != j) {
-        Scalar val = -1.0 / (1 + std::abs(i - j));
-        trips.emplace_back(i, j, val);
-        diag -= val;
-      }
-    }
-    trips.emplace_back(i, i, diag + 1.0);
-  }
-  A.setFromTriplets(trips.begin(), trips.end());
-  return A;
-}
-
-// Generate a general (non-symmetric) sparse matrix.
-static SpMat generateGeneral(int n, int bandwidth) {
-  SpMat A(n, n);
-  std::vector<Triplet<Scalar>> trips;
-  trips.reserve(n * (2 * bandwidth + 1));
-  for (int i = 0; i < n; ++i) {
-    Scalar diag = 0;
-    for (int j = std::max(0, i - bandwidth); j < std::min(n, i + bandwidth + 1); ++j) {
-      if (i != j) {
-        Scalar val = -0.5 / (1 + std::abs(i - j));
-        if (j > i) val *= 1.5;  // asymmetry
-        trips.emplace_back(i, j, val);
-        diag += std::abs(val);
-      }
-    }
-    trips.emplace_back(i, i, diag + 1.0);  // diagonal dominance
-  }
-  A.setFromTriplets(trips.begin(), trips.end());
-  return A;
-}
-
-// --- GMRES ---
-static void BM_GMRES(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateGeneral(n, bw);
-  Vec b = Vec::Random(n);
-
-  GMRES<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-// --- DGMRES ---
-static void BM_DGMRES(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateGeneral(n, bw);
-  Vec b = Vec::Random(n);
-
-  DGMRES<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-// --- MINRES (SPD matrices) ---
-static void BM_MINRES(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateSPD(n, bw);
-  Vec b = Vec::Random(n);
-
-  MINRES<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-// --- IDRS ---
-static void BM_IDRS(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateGeneral(n, bw);
-  Vec b = Vec::Random(n);
-
-  IDRS<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-// --- BiCGSTABL ---
-static void BM_BiCGSTABL(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateGeneral(n, bw);
-  Vec b = Vec::Random(n);
-
-  BiCGSTABL<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-// --- Compare with CG (supported module, SPD only) ---
-static void BM_CG_Reference(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateSPD(n, bw);
-  Vec b = Vec::Random(n);
-
-  ConjugateGradient<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-// --- Compare with BiCGSTAB (supported module, general) ---
-static void BM_BiCGSTAB_Reference(benchmark::State& state) {
-  int n = state.range(0);
-  int bw = state.range(1);
-  SpMat A = generateGeneral(n, bw);
-  Vec b = Vec::Random(n);
-
-  BiCGSTAB<SpMat> solver;
-  solver.setMaxIterations(1000);
-  solver.setTolerance(1e-10);
-  solver.compute(A);
-
-  for (auto _ : state) {
-    Vec x = solver.solve(b);
-    benchmark::DoNotOptimize(x.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["iterations"] = solver.iterations();
-}
-
-static void SolverSizes(::benchmark::Benchmark* b) {
-  for (int n : {1000, 10000, 100000}) {
-    for (int bw : {5, 20}) {
-      b->Args({n, bw});
-    }
-  }
-}
-
-BENCHMARK(BM_GMRES)->Apply(SolverSizes);
-BENCHMARK(BM_DGMRES)->Apply(SolverSizes);
-BENCHMARK(BM_MINRES)->Apply(SolverSizes);
-BENCHMARK(BM_IDRS)->Apply(SolverSizes);
-BENCHMARK(BM_BiCGSTABL)->Apply(SolverSizes);
-BENCHMARK(BM_CG_Reference)->Apply(SolverSizes);
-BENCHMARK(BM_BiCGSTAB_Reference)->Apply(SolverSizes);
diff --git a/unsupported/benchmarks/KroneckerProduct/CMakeLists.txt b/unsupported/benchmarks/KroneckerProduct/CMakeLists.txt
deleted file mode 100644
index ff0d289..0000000
--- a/unsupported/benchmarks/KroneckerProduct/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-eigen_add_benchmark(bench_kronecker bench_kronecker.cpp)
diff --git a/unsupported/benchmarks/KroneckerProduct/bench_kronecker.cpp b/unsupported/benchmarks/KroneckerProduct/bench_kronecker.cpp
deleted file mode 100644
index 882887e..0000000
--- a/unsupported/benchmarks/KroneckerProduct/bench_kronecker.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-// Benchmarks for Kronecker product (dense and sparse).
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <Eigen/Sparse>
-#include <unsupported/Eigen/KroneckerProduct>
-
-using namespace Eigen;
-
-typedef double Scalar;
-typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
-typedef SparseMatrix<Scalar> SpMat;
-
-// --- Dense Kronecker product ---
-static void BM_KroneckerDense(benchmark::State& state) {
-  int na = state.range(0);
-  int nb = state.range(1);
-
-  Mat A = Mat::Random(na, na);
-  Mat B = Mat::Random(nb, nb);
-
-  for (auto _ : state) {
-    Mat C = kroneckerProduct(A, B).eval();
-    benchmark::DoNotOptimize(C.data());
-    benchmark::ClobberMemory();
-  }
-  int outSize = na * nb;
-  state.counters["output_size"] = outSize;
-}
-
-// --- Sparse Kronecker product ---
-static void BM_KroneckerSparse(benchmark::State& state) {
-  int na = state.range(0);
-  int nb = state.range(1);
-
-  // Create sparse identity-like matrices with some fill.
-  SpMat A(na, na);
-  SpMat B(nb, nb);
-
-  std::vector<Triplet<Scalar>> tripsA, tripsB;
-  for (int i = 0; i < na; ++i) {
-    tripsA.emplace_back(i, i, 2.0);
-    if (i + 1 < na) {
-      tripsA.emplace_back(i, i + 1, -1.0);
-      tripsA.emplace_back(i + 1, i, -1.0);
-    }
-  }
-  for (int i = 0; i < nb; ++i) {
-    tripsB.emplace_back(i, i, 2.0);
-    if (i + 1 < nb) {
-      tripsB.emplace_back(i, i + 1, -1.0);
-      tripsB.emplace_back(i + 1, i, -1.0);
-    }
-  }
-  A.setFromTriplets(tripsA.begin(), tripsA.end());
-  B.setFromTriplets(tripsB.begin(), tripsB.end());
-
-  for (auto _ : state) {
-    SpMat C = kroneckerProduct(A, B).eval();
-    benchmark::DoNotOptimize(C.valuePtr());
-    benchmark::ClobberMemory();
-  }
-  state.counters["output_size"] = na * nb;
-}
-
-static void KroneckerSizes(::benchmark::Benchmark* b) {
-  for (int na : {4, 8, 16}) {
-    for (int nb : {4, 8, 16}) {
-      b->Args({na, nb});
-    }
-  }
-}
-
-static void KroneckerSparseSizes(::benchmark::Benchmark* b) {
-  for (int na : {16, 32, 64, 128}) {
-    for (int nb : {16, 32, 64, 128}) {
-      b->Args({na, nb});
-    }
-  }
-}
-
-BENCHMARK(BM_KroneckerDense)->Apply(KroneckerSizes);
-BENCHMARK(BM_KroneckerSparse)->Apply(KroneckerSparseSizes);
diff --git a/unsupported/benchmarks/MatrixFunctions/CMakeLists.txt b/unsupported/benchmarks/MatrixFunctions/CMakeLists.txt
deleted file mode 100644
index 2a612ed..0000000
--- a/unsupported/benchmarks/MatrixFunctions/CMakeLists.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-eigen_add_benchmark(bench_matrix_exponential bench_matrix_exponential.cpp)
-eigen_add_benchmark(bench_matrix_logarithm bench_matrix_logarithm.cpp)
-eigen_add_benchmark(bench_matrix_power bench_matrix_power.cpp)
diff --git a/unsupported/benchmarks/MatrixFunctions/bench_matrix_exponential.cpp b/unsupported/benchmarks/MatrixFunctions/bench_matrix_exponential.cpp
deleted file mode 100644
index 3778b76..0000000
--- a/unsupported/benchmarks/MatrixFunctions/bench_matrix_exponential.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// Benchmarks for matrix exponential.
-// Critical for Sophus Lie group operations (SLAM, visual odometry).
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <unsupported/Eigen/MatrixFunctions>
-
-using namespace Eigen;
-
-#ifndef SCALAR
-#define SCALAR double
-#endif
-
-typedef SCALAR Scalar;
-
-static void BM_MatrixExp(benchmark::State& state) {
-  int n = state.range(0);
-  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
-
-  // Generate a random matrix with reasonable spectral radius.
-  MatrixType A = MatrixType::Random(n, n) / Scalar(n);
-  MatrixType result(n, n);
-
-  for (auto _ : state) {
-    result = A.exp();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// Fixed-size specializations for Lie group sizes.
-template <int N>
-static void BM_MatrixExp_Fixed(benchmark::State& state) {
-  typedef Matrix<Scalar, N, N> MatrixType;
-
-  MatrixType A = MatrixType::Random() / Scalar(N);
-  MatrixType result;
-
-  for (auto _ : state) {
-    result = A.exp();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// Dynamic sizes: Lie groups (2,3,4) plus larger.
-BENCHMARK(BM_MatrixExp)->Arg(2)->Arg(3)->Arg(4)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128);
-
-// Fixed-size Lie group dimensions.
-BENCHMARK(BM_MatrixExp_Fixed<2>);
-BENCHMARK(BM_MatrixExp_Fixed<3>);
-BENCHMARK(BM_MatrixExp_Fixed<4>);
diff --git a/unsupported/benchmarks/MatrixFunctions/bench_matrix_logarithm.cpp b/unsupported/benchmarks/MatrixFunctions/bench_matrix_logarithm.cpp
deleted file mode 100644
index 4d1c8ea..0000000
--- a/unsupported/benchmarks/MatrixFunctions/bench_matrix_logarithm.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// Benchmarks for matrix logarithm.
-// Inverse of matrix exponential, used for Lie group log maps.
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <unsupported/Eigen/MatrixFunctions>
-
-using namespace Eigen;
-
-#ifndef SCALAR
-#define SCALAR double
-#endif
-
-typedef SCALAR Scalar;
-
-static void BM_MatrixLog(benchmark::State& state) {
-  int n = state.range(0);
-  typedef Matrix<Scalar, Dynamic, Dynamic> MatrixType;
-
-  // Generate a matrix close to identity for stable log computation.
-  MatrixType A = MatrixType::Identity(n, n) + MatrixType::Random(n, n) / Scalar(n * 2);
-  // Ensure A is in the principal branch by computing exp(small matrix).
-  A = (MatrixType::Random(n, n) / Scalar(n * 4)).exp();
-  MatrixType result(n, n);
-
-  for (auto _ : state) {
-    result = A.log();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-template <int N>
-static void BM_MatrixLog_Fixed(benchmark::State& state) {
-  typedef Matrix<Scalar, N, N> MatrixType;
-
-  MatrixType A = (MatrixType::Random() / Scalar(N * 4)).exp();
-  MatrixType result;
-
-  for (auto _ : state) {
-    result = A.log();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-BENCHMARK(BM_MatrixLog)->Arg(2)->Arg(3)->Arg(4)->Arg(8)->Arg(16)->Arg(32)->Arg(64);
-
-BENCHMARK(BM_MatrixLog_Fixed<2>);
-BENCHMARK(BM_MatrixLog_Fixed<3>);
-BENCHMARK(BM_MatrixLog_Fixed<4>);
diff --git a/unsupported/benchmarks/MatrixFunctions/bench_matrix_power.cpp b/unsupported/benchmarks/MatrixFunctions/bench_matrix_power.cpp
deleted file mode 100644
index a1ebea0..0000000
--- a/unsupported/benchmarks/MatrixFunctions/bench_matrix_power.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-// Benchmarks for matrix power functions: sqrt, pow, cos, sin, cosh, sinh.
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <unsupported/Eigen/MatrixFunctions>
-
-using namespace Eigen;
-
-typedef double Scalar;
-typedef Matrix<Scalar, Dynamic, Dynamic> Mat;
-
-static void BM_MatrixSqrt(benchmark::State& state) {
-  int n = state.range(0);
-  // SPD matrix has well-defined sqrt.
-  Mat tmp = Mat::Random(n, n);
-  Mat A = tmp * tmp.transpose() + Mat::Identity(n, n);
-  Mat result(n, n);
-
-  for (auto _ : state) {
-    result = A.sqrt();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-static void BM_MatrixPow(benchmark::State& state) {
-  int n = state.range(0);
-  Mat tmp = Mat::Random(n, n);
-  Mat A = tmp * tmp.transpose() + Mat::Identity(n, n);
-  Mat result(n, n);
-  Scalar p = 2.5;
-
-  for (auto _ : state) {
-    result = A.pow(p);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-static void BM_MatrixCos(benchmark::State& state) {
-  int n = state.range(0);
-  Mat A = Mat::Random(n, n) / Scalar(n);
-  Mat result(n, n);
-
-  for (auto _ : state) {
-    result = A.cos();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-static void BM_MatrixSin(benchmark::State& state) {
-  int n = state.range(0);
-  Mat A = Mat::Random(n, n) / Scalar(n);
-  Mat result(n, n);
-
-  for (auto _ : state) {
-    result = A.sin();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-static void BM_MatrixCosh(benchmark::State& state) {
-  int n = state.range(0);
-  Mat A = Mat::Random(n, n) / Scalar(n);
-  Mat result(n, n);
-
-  for (auto _ : state) {
-    result = A.cosh();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-static void BM_MatrixSinh(benchmark::State& state) {
-  int n = state.range(0);
-  Mat A = Mat::Random(n, n) / Scalar(n);
-  Mat result(n, n);
-
-  for (auto _ : state) {
-    result = A.sinh();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-}
-
-static void MatPowerSizes(::benchmark::Benchmark* b) {
-  for (int n : {4, 8, 16, 32, 64}) {
-    b->Arg(n);
-  }
-}
-
-BENCHMARK(BM_MatrixSqrt)->Apply(MatPowerSizes);
-BENCHMARK(BM_MatrixPow)->Apply(MatPowerSizes);
-BENCHMARK(BM_MatrixCos)->Apply(MatPowerSizes);
-BENCHMARK(BM_MatrixSin)->Apply(MatPowerSizes);
-BENCHMARK(BM_MatrixCosh)->Apply(MatPowerSizes);
-BENCHMARK(BM_MatrixSinh)->Apply(MatPowerSizes);
diff --git a/unsupported/benchmarks/SpecialFunctions/CMakeLists.txt b/unsupported/benchmarks/SpecialFunctions/CMakeLists.txt
deleted file mode 100644
index a673413..0000000
--- a/unsupported/benchmarks/SpecialFunctions/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-eigen_add_benchmark(bench_special_functions bench_special_functions.cpp)
diff --git a/unsupported/benchmarks/SpecialFunctions/bench_special_functions.cpp b/unsupported/benchmarks/SpecialFunctions/bench_special_functions.cpp
deleted file mode 100644
index dc6505d..0000000
--- a/unsupported/benchmarks/SpecialFunctions/bench_special_functions.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// Benchmarks for special functions beyond what bench_cwise_math.cpp covers.
-// Includes Bessel functions, two-argument functions (igamma, betainc),
-// and additional functions (lgamma, digamma, zeta, polygamma).
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <unsupported/Eigen/SpecialFunctions>
-
-using namespace Eigen;
-
-// Macro for unary special functions on arrays.
-#define BENCH_SPECIAL_UNARY(NAME, EXPR, LO, HI)                                                          \
-  template <typename Scalar>                                                                             \
-  static void BM_##NAME(benchmark::State& state) {                                                       \
-    const Index n = state.range(0);                                                                      \
-    using Arr = Array<Scalar, Dynamic, 1>;                                                               \
-    Arr a = (Arr::Random(n) + Scalar(1)) * Scalar((double(HI) - double(LO)) / 2.0) + Scalar(LO);         \
-    Arr b(n);                                                                                            \
-    for (auto _ : state) {                                                                               \
-      b = EXPR;                                                                                          \
-      benchmark::DoNotOptimize(b.data());                                                                \
-    }                                                                                                    \
-    state.counters["Elements/s"] = benchmark::Counter(n, benchmark::Counter::kIsIterationInvariantRate); \
-    state.SetBytesProcessed(state.iterations() * n * sizeof(Scalar) * 2);                                \
-  }
-
-// Macro for binary special functions on arrays.
-#define BENCH_SPECIAL_BINARY(NAME, EXPR, LO_A, HI_A, LO_B, HI_B)                                         \
-  template <typename Scalar>                                                                             \
-  static void BM_##NAME(benchmark::State& state) {                                                       \
-    const Index n = state.range(0);                                                                      \
-    using Arr = Array<Scalar, Dynamic, 1>;                                                               \
-    Arr a = (Arr::Random(n) + Scalar(1)) * Scalar((double(HI_A) - double(LO_A)) / 2.0) + Scalar(LO_A);   \
-    Arr b = (Arr::Random(n) + Scalar(1)) * Scalar((double(HI_B) - double(LO_B)) / 2.0) + Scalar(LO_B);   \
-    Arr c(n);                                                                                            \
-    for (auto _ : state) {                                                                               \
-      c = EXPR;                                                                                          \
-      benchmark::DoNotOptimize(c.data());                                                                \
-    }                                                                                                    \
-    state.counters["Elements/s"] = benchmark::Counter(n, benchmark::Counter::kIsIterationInvariantRate); \
-    state.SetBytesProcessed(state.iterations() * n * sizeof(Scalar) * 3);                                \
-  }
-
-// --- Unary special functions ---
-BENCH_SPECIAL_UNARY(Lgamma, Eigen::lgamma(a), 0.1, 20)
-BENCH_SPECIAL_UNARY(Digamma, Eigen::digamma(a), 0.1, 20)
-
-// --- Bessel functions (first kind) ---
-BENCH_SPECIAL_UNARY(BesselI0, Eigen::bessel_i0(a), 0, 10)
-BENCH_SPECIAL_UNARY(BesselI1, Eigen::bessel_i1(a), 0, 10)
-BENCH_SPECIAL_UNARY(BesselI0e, Eigen::bessel_i0e(a), 0, 100)
-BENCH_SPECIAL_UNARY(BesselI1e, Eigen::bessel_i1e(a), 0, 100)
-BENCH_SPECIAL_UNARY(BesselJ0, Eigen::bessel_j0(a), 0, 20)
-BENCH_SPECIAL_UNARY(BesselJ1, Eigen::bessel_j1(a), 0, 20)
-
-// --- Bessel functions (second kind) ---
-BENCH_SPECIAL_UNARY(BesselY0, Eigen::bessel_y0(a), 0.1, 20)
-BENCH_SPECIAL_UNARY(BesselY1, Eigen::bessel_y1(a), 0.1, 20)
-BENCH_SPECIAL_UNARY(BesselK0, Eigen::bessel_k0(a), 0.1, 20)
-BENCH_SPECIAL_UNARY(BesselK1, Eigen::bessel_k1(a), 0.1, 20)
-BENCH_SPECIAL_UNARY(BesselK0e, Eigen::bessel_k0e(a), 0.1, 100)
-BENCH_SPECIAL_UNARY(BesselK1e, Eigen::bessel_k1e(a), 0.1, 100)
-
-// --- Two-argument functions ---
-BENCH_SPECIAL_BINARY(Igamma, Eigen::igamma(a, b), 0.1, 10, 0.1, 10)
-BENCH_SPECIAL_BINARY(Igammac, Eigen::igammac(a, b), 0.1, 10, 0.1, 10)
-BENCH_SPECIAL_BINARY(Zeta, Eigen::zeta(a, b), 1.1, 10, 0.1, 10)
-BENCH_SPECIAL_BINARY(Polygamma, Eigen::polygamma(a, b), 1, 4, 0.1, 10)
-
-// --- Ternary: betainc ---
-template <typename Scalar>
-static void BM_Betainc(benchmark::State& state) {
-  const Index n = state.range(0);
-  using Arr = Array<Scalar, Dynamic, 1>;
-  Arr a = (Arr::Random(n) + Scalar(1)) * Scalar(2.5) + Scalar(0.5);  // [0.5, 5.5]
-  Arr b = (Arr::Random(n) + Scalar(1)) * Scalar(2.5) + Scalar(0.5);
-  Arr x = (Arr::Random(n) + Scalar(1)) * Scalar(0.5);  // [0, 1]
-  Arr result(n);
-  for (auto _ : state) {
-    result = Eigen::betainc(a, b, x);
-    benchmark::DoNotOptimize(result.data());
-  }
-  state.counters["Elements/s"] = benchmark::Counter(n, benchmark::Counter::kIsIterationInvariantRate);
-  state.SetBytesProcessed(state.iterations() * n * sizeof(Scalar) * 4);
-}
-
-static void SpecialSizes(::benchmark::Benchmark* b) {
-  for (int n : {256, 4096, 65536, 1048576}) b->Arg(n);
-}
-
-// --- Register float ---
-BENCHMARK(BM_Lgamma<float>)->Apply(SpecialSizes)->Name("Lgamma_float");
-BENCHMARK(BM_Digamma<float>)->Apply(SpecialSizes)->Name("Digamma_float");
-BENCHMARK(BM_BesselI0<float>)->Apply(SpecialSizes)->Name("BesselI0_float");
-BENCHMARK(BM_BesselI1<float>)->Apply(SpecialSizes)->Name("BesselI1_float");
-BENCHMARK(BM_BesselI0e<float>)->Apply(SpecialSizes)->Name("BesselI0e_float");
-BENCHMARK(BM_BesselI1e<float>)->Apply(SpecialSizes)->Name("BesselI1e_float");
-BENCHMARK(BM_BesselJ0<float>)->Apply(SpecialSizes)->Name("BesselJ0_float");
-BENCHMARK(BM_BesselJ1<float>)->Apply(SpecialSizes)->Name("BesselJ1_float");
-BENCHMARK(BM_BesselY0<float>)->Apply(SpecialSizes)->Name("BesselY0_float");
-BENCHMARK(BM_BesselY1<float>)->Apply(SpecialSizes)->Name("BesselY1_float");
-BENCHMARK(BM_BesselK0<float>)->Apply(SpecialSizes)->Name("BesselK0_float");
-BENCHMARK(BM_BesselK1<float>)->Apply(SpecialSizes)->Name("BesselK1_float");
-BENCHMARK(BM_BesselK0e<float>)->Apply(SpecialSizes)->Name("BesselK0e_float");
-BENCHMARK(BM_BesselK1e<float>)->Apply(SpecialSizes)->Name("BesselK1e_float");
-BENCHMARK(BM_Igamma<float>)->Apply(SpecialSizes)->Name("Igamma_float");
-BENCHMARK(BM_Igammac<float>)->Apply(SpecialSizes)->Name("Igammac_float");
-BENCHMARK(BM_Betainc<float>)->Apply(SpecialSizes)->Name("Betainc_float");
-BENCHMARK(BM_Zeta<float>)->Apply(SpecialSizes)->Name("Zeta_float");
-BENCHMARK(BM_Polygamma<float>)->Apply(SpecialSizes)->Name("Polygamma_float");
-
-// --- Register double ---
-BENCHMARK(BM_Lgamma<double>)->Apply(SpecialSizes)->Name("Lgamma_double");
-BENCHMARK(BM_Digamma<double>)->Apply(SpecialSizes)->Name("Digamma_double");
-BENCHMARK(BM_BesselI0<double>)->Apply(SpecialSizes)->Name("BesselI0_double");
-BENCHMARK(BM_BesselI1<double>)->Apply(SpecialSizes)->Name("BesselI1_double");
-BENCHMARK(BM_BesselJ0<double>)->Apply(SpecialSizes)->Name("BesselJ0_double");
-BENCHMARK(BM_BesselJ1<double>)->Apply(SpecialSizes)->Name("BesselJ1_double");
-BENCHMARK(BM_BesselY0<double>)->Apply(SpecialSizes)->Name("BesselY0_double");
-BENCHMARK(BM_BesselY1<double>)->Apply(SpecialSizes)->Name("BesselY1_double");
-BENCHMARK(BM_BesselK0<double>)->Apply(SpecialSizes)->Name("BesselK0_double");
-BENCHMARK(BM_BesselK1<double>)->Apply(SpecialSizes)->Name("BesselK1_double");
-BENCHMARK(BM_Igamma<double>)->Apply(SpecialSizes)->Name("Igamma_double");
-BENCHMARK(BM_Igammac<double>)->Apply(SpecialSizes)->Name("Igammac_double");
-BENCHMARK(BM_Betainc<double>)->Apply(SpecialSizes)->Name("Betainc_double");
-BENCHMARK(BM_Zeta<double>)->Apply(SpecialSizes)->Name("Zeta_double");
-BENCHMARK(BM_Polygamma<double>)->Apply(SpecialSizes)->Name("Polygamma_double");
diff --git a/unsupported/benchmarks/Splines/CMakeLists.txt b/unsupported/benchmarks/Splines/CMakeLists.txt
deleted file mode 100644
index a54acc4..0000000
--- a/unsupported/benchmarks/Splines/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-eigen_add_benchmark(bench_splines bench_splines.cpp)
diff --git a/unsupported/benchmarks/Splines/bench_splines.cpp b/unsupported/benchmarks/Splines/bench_splines.cpp
deleted file mode 100644
index e422a8f..0000000
--- a/unsupported/benchmarks/Splines/bench_splines.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-// Benchmarks for Eigen Spline module.
-// Tests fitting, evaluation, and derivative computation.
-
-#include <benchmark/benchmark.h>
-#include <Eigen/Core>
-#include <unsupported/Eigen/Splines>
-
-using namespace Eigen;
-
-typedef double Scalar;
-
-// --- Spline fitting (interpolation) ---
-template <int Dim, int Degree>
-static void BM_SplineFit(benchmark::State& state) {
-  const int n = state.range(0);
-
-  typedef Spline<Scalar, Dim> SplineType;
-  typedef typename SplineType::PointType PointType;
-
-  // Generate random points.
-  Matrix<Scalar, Dim, Dynamic> pts(Dim, n);
-  pts.setRandom();
-
-  for (auto _ : state) {
-    SplineType spline = SplineFitting<SplineType>::Interpolate(pts, Degree);
-    benchmark::DoNotOptimize(spline.knots().data());
-    benchmark::ClobberMemory();
-  }
-}
-
-// --- Spline evaluation ---
-template <int Dim, int Degree>
-static void BM_SplineEval(benchmark::State& state) {
-  const int n = state.range(0);  // number of control points for fitting
-  const int neval = 1000;        // number of evaluation points
-
-  typedef Spline<Scalar, Dim> SplineType;
-
-  Matrix<Scalar, Dim, Dynamic> pts(Dim, n);
-  pts.setRandom();
-  SplineType spline = SplineFitting<SplineType>::Interpolate(pts, Degree);
-
-  // Generate evaluation parameters in [0, 1].
-  VectorXd u = VectorXd::LinSpaced(neval, 0, 1);
-
-  for (auto _ : state) {
-    for (int i = 0; i < neval; ++i) {
-      auto pt = spline(u(i));
-      benchmark::DoNotOptimize(pt.data());
-    }
-    benchmark::ClobberMemory();
-  }
-  state.counters["Evals/s"] = benchmark::Counter(neval, benchmark::Counter::kIsIterationInvariantRate);
-}
-
-// --- Spline derivative evaluation ---
-template <int Dim, int Degree>
-static void BM_SplineDerivatives(benchmark::State& state) {
-  const int n = state.range(0);
-  const int neval = 1000;
-
-  typedef Spline<Scalar, Dim> SplineType;
-
-  Matrix<Scalar, Dim, Dynamic> pts(Dim, n);
-  pts.setRandom();
-  SplineType spline = SplineFitting<SplineType>::Interpolate(pts, Degree);
-
-  VectorXd u = VectorXd::LinSpaced(neval, 0, 1);
-
-  for (auto _ : state) {
-    for (int i = 0; i < neval; ++i) {
-      auto derivs = spline.derivatives(u(i), 1);
-      benchmark::DoNotOptimize(derivs.data());
-    }
-    benchmark::ClobberMemory();
-  }
-  state.counters["Evals/s"] = benchmark::Counter(neval, benchmark::Counter::kIsIterationInvariantRate);
-}
-
-static void SplineSizes(::benchmark::Benchmark* b) {
-  for (int n : {10, 50, 200, 1000}) {
-    b->Arg(n);
-  }
-}
-
-// 2D cubic splines
-BENCHMARK(BM_SplineFit<2, 3>)->Apply(SplineSizes)->Name("SplineFit_2D_Cubic");
-BENCHMARK(BM_SplineEval<2, 3>)->Apply(SplineSizes)->Name("SplineEval_2D_Cubic");
-BENCHMARK(BM_SplineDerivatives<2, 3>)->Apply(SplineSizes)->Name("SplineDerivatives_2D_Cubic");
-
-// 3D cubic splines
-BENCHMARK(BM_SplineFit<3, 3>)->Apply(SplineSizes)->Name("SplineFit_3D_Cubic");
-BENCHMARK(BM_SplineEval<3, 3>)->Apply(SplineSizes)->Name("SplineEval_3D_Cubic");
-BENCHMARK(BM_SplineDerivatives<3, 3>)->Apply(SplineSizes)->Name("SplineDerivatives_3D_Cubic");
-
-// 2D quintic splines
-BENCHMARK(BM_SplineFit<2, 5>)->Apply(SplineSizes)->Name("SplineFit_2D_Quintic");
-BENCHMARK(BM_SplineEval<2, 5>)->Apply(SplineSizes)->Name("SplineEval_2D_Quintic");
diff --git a/unsupported/benchmarks/Tensor/CMakeLists.txt b/unsupported/benchmarks/Tensor/CMakeLists.txt
deleted file mode 100644
index 4dab17c..0000000
--- a/unsupported/benchmarks/Tensor/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-eigen_add_benchmark(bench_contraction bench_contraction.cpp)
-eigen_add_benchmark(bench_convolution bench_convolution.cpp)
-eigen_add_benchmark(bench_reduction bench_reduction.cpp)
-eigen_add_benchmark(bench_broadcasting bench_broadcasting.cpp)
-eigen_add_benchmark(bench_shuffling bench_shuffling.cpp)
-eigen_add_benchmark(bench_tensor_fft bench_tensor_fft.cpp)
-eigen_add_benchmark(bench_morphing bench_morphing.cpp)
-eigen_add_benchmark(bench_coefficient_wise bench_coefficient_wise.cpp)
diff --git a/unsupported/benchmarks/Tensor/bench_broadcasting.cpp b/unsupported/benchmarks/Tensor/bench_broadcasting.cpp
deleted file mode 100644
index 01aed20..0000000
--- a/unsupported/benchmarks/Tensor/bench_broadcasting.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-// Benchmarks for Eigen Tensor broadcasting.
-// Tests broadcasting along various dimensions and ranks.
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-
-using namespace Eigen;
-
-typedef float Scalar;
-
-// --- Broadcast row vector {1,N} -> {M,N} ---
-static void BM_BroadcastRow(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> row(1, N);
-  Tensor<Scalar, 2> result(M, N);
-  row.setRandom();
-
-  Eigen::array<int, 2> bcast = {M, 1};
-
-  for (auto _ : state) {
-    result = row.broadcast(bcast);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-// --- Broadcast col vector {M,1} -> {M,N} ---
-static void BM_BroadcastCol(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> col(M, 1);
-  Tensor<Scalar, 2> result(M, N);
-  col.setRandom();
-
-  Eigen::array<int, 2> bcast = {1, N};
-
-  for (auto _ : state) {
-    result = col.broadcast(bcast);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-// --- Broadcast + element-wise add (bias addition pattern) ---
-static void BM_BroadcastAdd(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> mat(M, N);
-  Tensor<Scalar, 2> bias(1, N);
-  Tensor<Scalar, 2> result(M, N);
-  mat.setRandom();
-  bias.setRandom();
-
-  Eigen::array<int, 2> bcast = {M, 1};
-
-  for (auto _ : state) {
-    result = mat + bias.broadcast(bcast);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
-}
-
-// --- Rank-4 broadcast (batch x channels x 1 x 1) -> (batch x channels x H x W) ---
-static void BM_BroadcastRank4(benchmark::State& state) {
-  const int batch = state.range(0);
-  const int C = state.range(1);
-  const int H = state.range(2);
-
-  Tensor<Scalar, 4> bias(batch, C, 1, 1);
-  Tensor<Scalar, 4> result(batch, C, H, H);
-  bias.setRandom();
-
-  Eigen::array<int, 4> bcast = {1, 1, H, H};
-
-  for (auto _ : state) {
-    result = bias.broadcast(bcast);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * batch * C * H * H * sizeof(Scalar));
-}
-
-static void BroadcastSizes(::benchmark::Benchmark* b) {
-  for (int m : {64, 256, 1024}) {
-    for (int n : {64, 256, 1024}) {
-      b->Args({m, n});
-    }
-  }
-}
-
-static void Rank4Sizes(::benchmark::Benchmark* b) {
-  for (int batch : {1, 8}) {
-    for (int c : {64, 256}) {
-      for (int h : {16, 32}) {
-        b->Args({batch, c, h});
-      }
-    }
-  }
-}
-
-BENCHMARK(BM_BroadcastRow)->Apply(BroadcastSizes);
-BENCHMARK(BM_BroadcastCol)->Apply(BroadcastSizes);
-BENCHMARK(BM_BroadcastAdd)->Apply(BroadcastSizes);
-BENCHMARK(BM_BroadcastRank4)->Apply(Rank4Sizes);
diff --git a/unsupported/benchmarks/Tensor/bench_coefficient_wise.cpp b/unsupported/benchmarks/Tensor/bench_coefficient_wise.cpp
deleted file mode 100644
index aed4828..0000000
--- a/unsupported/benchmarks/Tensor/bench_coefficient_wise.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-// Benchmarks for Eigen Tensor coefficient-wise operations.
-// Covers activation functions, normalization, and element-wise arithmetic.
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-
-using namespace Eigen;
-
-typedef float Scalar;
-
-// Macro to define a benchmark for a unary tensor operation.
-#define BENCH_TENSOR_UNARY(NAME, EXPR)                                        \
-  static void BM_##NAME(benchmark::State& state) {                            \
-    const int M = state.range(0);                                             \
-    const int N = state.range(1);                                             \
-    Tensor<Scalar, 2> a(M, N);                                                \
-    a.setRandom();                                                            \
-    Tensor<Scalar, 2> b(M, N);                                                \
-    for (auto _ : state) {                                                    \
-      b = EXPR;                                                               \
-      benchmark::DoNotOptimize(b.data());                                     \
-      benchmark::ClobberMemory();                                             \
-    }                                                                         \
-    state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2); \
-  }
-
-BENCH_TENSOR_UNARY(Exp, a.exp())
-BENCH_TENSOR_UNARY(Log, a.abs().log())
-BENCH_TENSOR_UNARY(Tanh, a.tanh())
-BENCH_TENSOR_UNARY(Sigmoid, a.sigmoid())
-BENCH_TENSOR_UNARY(ReLU, a.cwiseMax(Scalar(0)))
-BENCH_TENSOR_UNARY(Sqrt, a.abs().sqrt())
-
-// --- Element-wise binary operations ---
-static void BM_Add(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> a(M, N);
-  Tensor<Scalar, 2> b(M, N);
-  Tensor<Scalar, 2> c(M, N);
-  a.setRandom();
-  b.setRandom();
-
-  for (auto _ : state) {
-    c = a + b;
-    benchmark::DoNotOptimize(c.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 3);
-}
-
-static void BM_Mul(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> a(M, N);
-  Tensor<Scalar, 2> b(M, N);
-  Tensor<Scalar, 2> c(M, N);
-  a.setRandom();
-  b.setRandom();
-
-  for (auto _ : state) {
-    c = a * b;
-    benchmark::DoNotOptimize(c.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 3);
-}
-
-// --- Fused multiply-add ---
-static void BM_FMA(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> a(M, N);
-  Tensor<Scalar, 2> b(M, N);
-  Tensor<Scalar, 2> c(M, N);
-  Tensor<Scalar, 2> d(M, N);
-  a.setRandom();
-  b.setRandom();
-  c.setRandom();
-
-  for (auto _ : state) {
-    d = a * b + c;
-    benchmark::DoNotOptimize(d.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 4);
-}
-
-// --- Rank-4 coefficient-wise (CNN feature maps) ---
-static void BM_ReLU_Rank4(benchmark::State& state) {
-  const int batch = state.range(0);
-  const int C = state.range(1);
-  const int H = state.range(2);
-
-  Tensor<Scalar, 4> a(batch, C, H, H);
-  Tensor<Scalar, 4> b(batch, C, H, H);
-  a.setRandom();
-
-  for (auto _ : state) {
-    b = a.cwiseMax(Scalar(0));
-    benchmark::DoNotOptimize(b.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * batch * C * H * H * sizeof(Scalar) * 2);
-}
-
-static void CwiseSizes(::benchmark::Benchmark* b) {
-  for (int size : {256, 1024}) {
-    b->Args({size, size});
-  }
-}
-
-static void Rank4Sizes(::benchmark::Benchmark* b) {
-  b->Args({32, 64, 16});
-  b->Args({8, 128, 32});
-  b->Args({1, 256, 64});
-}
-
-BENCHMARK(BM_Exp)->Apply(CwiseSizes);
-BENCHMARK(BM_Log)->Apply(CwiseSizes);
-BENCHMARK(BM_Tanh)->Apply(CwiseSizes);
-BENCHMARK(BM_Sigmoid)->Apply(CwiseSizes);
-BENCHMARK(BM_ReLU)->Apply(CwiseSizes);
-BENCHMARK(BM_Sqrt)->Apply(CwiseSizes);
-BENCHMARK(BM_Add)->Apply(CwiseSizes);
-BENCHMARK(BM_Mul)->Apply(CwiseSizes);
-BENCHMARK(BM_FMA)->Apply(CwiseSizes);
-BENCHMARK(BM_ReLU_Rank4)->Apply(Rank4Sizes);
diff --git a/unsupported/benchmarks/Tensor/bench_contraction.cpp b/unsupported/benchmarks/Tensor/bench_contraction.cpp
deleted file mode 100644
index faf648f..0000000
--- a/unsupported/benchmarks/Tensor/bench_contraction.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-// Benchmarks for Eigen Tensor contraction (generalized GEMM).
-// Tests single-threaded (DefaultDevice) and multi-threaded (ThreadPoolDevice) variants.
-
-#define EIGEN_USE_THREADS
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-#include <unsupported/Eigen/CXX11/ThreadPool>
-
-using namespace Eigen;
-
-#ifndef SCALAR
-#define SCALAR float
-#endif
-
-typedef SCALAR Scalar;
-
-// --- DefaultDevice contraction (rank-2, equivalent to matrix multiply) ---
-static void BM_Contraction(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-  const int K = state.range(2);
-
-  Tensor<Scalar, 2> A(M, K);
-  Tensor<Scalar, 2> B(K, N);
-  Tensor<Scalar, 2> C(M, N);
-  A.setRandom();
-  B.setRandom();
-
-  using ContractDims = Tensor<Scalar, 2>::DimensionPair;
-  Eigen::array<ContractDims, 1> contract_dims = {ContractDims(1, 0)};
-
-  for (auto _ : state) {
-    C = A.contract(B, contract_dims);
-    benchmark::DoNotOptimize(C.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["GFLOPS"] =
-      benchmark::Counter(2.0 * M * N * K, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-// --- ThreadPoolDevice contraction ---
-static void BM_Contraction_ThreadPool(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-  const int K = state.range(2);
-  const int threads = state.range(3);
-
-  Tensor<Scalar, 2> A(M, K);
-  Tensor<Scalar, 2> B(K, N);
-  Tensor<Scalar, 2> C(M, N);
-  A.setRandom();
-  B.setRandom();
-
-  ThreadPool tp(threads);
-  ThreadPoolDevice dev(&tp, threads);
-
-  using ContractDims = Tensor<Scalar, 2>::DimensionPair;
-  Eigen::array<ContractDims, 1> contract_dims = {ContractDims(1, 0)};
-
-  for (auto _ : state) {
-    C.device(dev) = A.contract(B, contract_dims);
-    benchmark::DoNotOptimize(C.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["GFLOPS"] =
-      benchmark::Counter(2.0 * M * N * K, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-  state.counters["threads"] = threads;
-}
-
-// --- Rank-3 batch contraction ---
-// Contracts A(batch, M, K) with B(batch, K, N) over batch dim (0<->0)
-// and K dim (2<->1), producing C(M, N). This sums over both the batch
-// and inner dimensions: C(m, n) = sum_b sum_k A(b, m, k) * B(b, k, n).
-static void BM_BatchContraction(benchmark::State& state) {
-  const int batch = state.range(0);
-  const int M = state.range(1);
-  const int N = state.range(2);
-  const int K = state.range(3);
-
-  Tensor<Scalar, 3> A(batch, M, K);
-  Tensor<Scalar, 3> B(batch, K, N);
-  Tensor<Scalar, 2> C(M, N);
-  A.setRandom();
-  B.setRandom();
-
-  using ContractDims = Tensor<Scalar, 3>::DimensionPair;
-  Eigen::array<ContractDims, 2> contract_dims = {ContractDims(0, 0), ContractDims(2, 1)};
-
-  for (auto _ : state) {
-    C = A.contract(B, contract_dims);
-    benchmark::DoNotOptimize(C.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["GFLOPS"] = benchmark::Counter(2.0 * batch * M * N * K, benchmark::Counter::kIsIterationInvariantRate,
-                                                benchmark::Counter::kIs1000);
-}
-
-// --- RowMajor contraction ---
-static void BM_Contraction_RowMajor(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-  const int K = state.range(2);
-
-  Tensor<Scalar, 2, RowMajor> A(M, K);
-  Tensor<Scalar, 2, RowMajor> B(K, N);
-  Tensor<Scalar, 2, RowMajor> C(M, N);
-  A.setRandom();
-  B.setRandom();
-
-  using ContractDims = Tensor<Scalar, 2, RowMajor>::DimensionPair;
-  Eigen::array<ContractDims, 1> contract_dims = {ContractDims(1, 0)};
-
-  for (auto _ : state) {
-    C = A.contract(B, contract_dims);
-    benchmark::DoNotOptimize(C.data());
-    benchmark::ClobberMemory();
-  }
-  state.counters["GFLOPS"] =
-      benchmark::Counter(2.0 * M * N * K, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-static void ContractionSizes(::benchmark::Benchmark* b) {
-  for (int size : {32, 64, 128, 256, 512, 1024}) {
-    b->Args({size, size, size});
-  }
-  // Non-square
-  b->Args({256, 256, 1024});
-  b->Args({1024, 64, 64});
-}
-
-static void ThreadPoolSizes(::benchmark::Benchmark* b) {
-  for (int size : {64, 256, 512, 1024}) {
-    for (int threads : {2, 4, 8}) {
-      b->Args({size, size, size, threads});
-    }
-  }
-}
-
-static void BatchSizes(::benchmark::Benchmark* b) {
-  for (int batch : {1, 8, 32}) {
-    for (int size : {64, 256}) {
-      b->Args({batch, size, size, size});
-    }
-  }
-}
-
-BENCHMARK(BM_Contraction)->Apply(ContractionSizes);
-BENCHMARK(BM_Contraction_RowMajor)->Apply(ContractionSizes);
-BENCHMARK(BM_Contraction_ThreadPool)->Apply(ThreadPoolSizes);
-BENCHMARK(BM_BatchContraction)->Apply(BatchSizes);
diff --git a/unsupported/benchmarks/Tensor/bench_convolution.cpp b/unsupported/benchmarks/Tensor/bench_convolution.cpp
deleted file mode 100644
index 46e44ee..0000000
--- a/unsupported/benchmarks/Tensor/bench_convolution.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-// Benchmarks for Eigen Tensor convolution (1D and 2D).
-
-#define EIGEN_USE_THREADS
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-#include <unsupported/Eigen/CXX11/ThreadPool>
-
-using namespace Eigen;
-
-typedef float Scalar;
-
-// --- 1D convolution ---
-static void BM_Convolve1D(benchmark::State& state) {
-  const int input_size = state.range(0);
-  const int kernel_size = state.range(1);
-
-  Tensor<Scalar, 1> input(input_size);
-  Tensor<Scalar, 1> kernel(kernel_size);
-  input.setRandom();
-  kernel.setRandom();
-
-  Eigen::array<int, 1> dims = {0};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 1> result = input.convolve(kernel, dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  double flops = 2.0 * (input_size - kernel_size + 1) * kernel_size;
-  state.counters["GFLOPS"] =
-      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-// --- 2D convolution ---
-static void BM_Convolve2D(benchmark::State& state) {
-  const int H = state.range(0);
-  const int W = state.range(1);
-  const int kH = state.range(2);
-  const int kW = state.range(3);
-
-  Tensor<Scalar, 2> input(H, W);
-  Tensor<Scalar, 2> kernel(kH, kW);
-  input.setRandom();
-  kernel.setRandom();
-
-  Eigen::array<int, 2> dims = {0, 1};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 2> result = input.convolve(kernel, dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  double flops = 2.0 * (H - kH + 1) * (W - kW + 1) * kH * kW;
-  state.counters["GFLOPS"] =
-      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-// --- 2D convolution with channels (rank-3: C x H x W, convolve on H,W) ---
-static void BM_Convolve2D_Channels(benchmark::State& state) {
-  const int C = state.range(0);
-  const int H = state.range(1);
-  const int kH = state.range(2);
-
-  Tensor<Scalar, 3> input(C, H, H);
-  Tensor<Scalar, 2> kernel(kH, kH);
-  input.setRandom();
-  kernel.setRandom();
-
-  Eigen::array<int, 2> dims = {1, 2};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 3> result = input.convolve(kernel, dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  int outH = H - kH + 1;
-  double flops = 2.0 * C * outH * outH * kH * kH;
-  state.counters["GFLOPS"] =
-      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-// --- 2D convolution with ThreadPool ---
-static void BM_Convolve2D_ThreadPool(benchmark::State& state) {
-  const int H = state.range(0);
-  const int kH = state.range(1);
-  const int threads = state.range(2);
-
-  Tensor<Scalar, 2> input(H, H);
-  Tensor<Scalar, 2> kernel(kH, kH);
-  Tensor<Scalar, 2> result(H - kH + 1, H - kH + 1);
-  input.setRandom();
-  kernel.setRandom();
-
-  ThreadPool tp(threads);
-  ThreadPoolDevice dev(&tp, threads);
-
-  Eigen::array<int, 2> dims = {0, 1};
-
-  for (auto _ : state) {
-    result.device(dev) = input.convolve(kernel, dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  int outH = H - kH + 1;
-  double flops = 2.0 * outH * outH * kH * kH;
-  state.counters["GFLOPS"] =
-      benchmark::Counter(flops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-  state.counters["threads"] = threads;
-}
-
-static void Conv1DSizes(::benchmark::Benchmark* b) {
-  for (int input : {128, 512, 2048}) {
-    for (int kernel : {3, 5, 11}) {
-      b->Args({input, kernel});
-    }
-  }
-}
-
-static void Conv2DSizes(::benchmark::Benchmark* b) {
-  for (int hw : {32, 64, 128, 224}) {
-    for (int k : {3, 5, 7}) {
-      b->Args({hw, hw, k, k});
-    }
-  }
-}
-
-static void Conv2DChannelSizes(::benchmark::Benchmark* b) {
-  for (int c : {3, 64, 128}) {
-    for (int hw : {16, 32, 56}) {
-      for (int k : {3, 5}) {
-        b->Args({c, hw, k});
-      }
-    }
-  }
-}
-
-static void Conv2DThreadPoolSizes(::benchmark::Benchmark* b) {
-  for (int hw : {64, 128, 224}) {
-    for (int k : {3, 5}) {
-      for (int threads : {2, 4, 8}) {
-        b->Args({hw, k, threads});
-      }
-    }
-  }
-}
-
-BENCHMARK(BM_Convolve1D)->Apply(Conv1DSizes);
-BENCHMARK(BM_Convolve2D)->Apply(Conv2DSizes);
-BENCHMARK(BM_Convolve2D_Channels)->Apply(Conv2DChannelSizes);
-BENCHMARK(BM_Convolve2D_ThreadPool)->Apply(Conv2DThreadPoolSizes);
diff --git a/unsupported/benchmarks/Tensor/bench_morphing.cpp b/unsupported/benchmarks/Tensor/bench_morphing.cpp
deleted file mode 100644
index 8d226e7..0000000
--- a/unsupported/benchmarks/Tensor/bench_morphing.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-// Benchmarks for Eigen Tensor morphing operations: reshape, slice, chip, pad, stride.
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-
-using namespace Eigen;
-
-typedef float Scalar;
-
-// --- Reshape (zero-cost if no evaluation needed; force eval via assignment) ---
-static void BM_Reshape(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  Eigen::array<Index, 1> new_shape = {M * N};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 1> B = A.reshape(new_shape);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-// --- Slice ---
-static void BM_Slice(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  int sliceM = M / 2;
-  int sliceN = N / 2;
-  Eigen::array<Index, 2> offsets = {0, 0};
-  Eigen::array<Index, 2> extents = {sliceM, sliceN};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 2> B = A.slice(offsets, extents);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * sliceM * sliceN * sizeof(Scalar));
-}
-
-// --- Chip (extract a sub-tensor along one dimension) ---
-static void BM_Chip(benchmark::State& state) {
-  const int D0 = state.range(0);
-  const int D1 = state.range(1);
-  const int D2 = state.range(2);
-
-  Tensor<Scalar, 3> A(D0, D1, D2);
-  A.setRandom();
-
-  for (auto _ : state) {
-    Tensor<Scalar, 2> B = A.chip(0, 0);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * D1 * D2 * sizeof(Scalar));
-}
-
-// --- Pad ---
-static void BM_Pad(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-  const int padSize = state.range(2);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  Eigen::array<std::pair<int, int>, 2> paddings;
-  paddings[0] = {padSize, padSize};
-  paddings[1] = {padSize, padSize};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 2> B = A.pad(paddings);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  int outM = M + 2 * padSize;
-  int outN = N + 2 * padSize;
-  state.SetBytesProcessed(state.iterations() * outM * outN * sizeof(Scalar));
-}
-
-// --- Stride ---
-static void BM_Stride(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-  const int stride = state.range(2);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  Eigen::array<Index, 2> strides_arr = {stride, stride};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 2> B = A.stride(strides_arr);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  int outM = (M + stride - 1) / stride;
-  int outN = (N + stride - 1) / stride;
-  state.SetBytesProcessed(state.iterations() * outM * outN * sizeof(Scalar));
-}
-
-static void MorphSizes(::benchmark::Benchmark* b) {
-  for (int size : {256, 1024}) {
-    b->Args({size, size});
-  }
-}
-
-static void ChipSizes(::benchmark::Benchmark* b) {
-  b->Args({32, 256, 256});
-  b->Args({64, 128, 128});
-  b->Args({8, 512, 512});
-}
-
-static void PadSizes(::benchmark::Benchmark* b) {
-  for (int size : {256, 1024}) {
-    for (int pad : {1, 4, 16}) {
-      b->Args({size, size, pad});
-    }
-  }
-}
-
-static void StrideSizes(::benchmark::Benchmark* b) {
-  for (int size : {256, 1024}) {
-    for (int stride : {2, 4}) {
-      b->Args({size, size, stride});
-    }
-  }
-}
-
-BENCHMARK(BM_Reshape)->Apply(MorphSizes);
-BENCHMARK(BM_Slice)->Apply(MorphSizes);
-BENCHMARK(BM_Chip)->Apply(ChipSizes);
-BENCHMARK(BM_Pad)->Apply(PadSizes);
-BENCHMARK(BM_Stride)->Apply(StrideSizes);
diff --git a/unsupported/benchmarks/Tensor/bench_reduction.cpp b/unsupported/benchmarks/Tensor/bench_reduction.cpp
deleted file mode 100644
index 795c95c..0000000
--- a/unsupported/benchmarks/Tensor/bench_reduction.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-// Benchmarks for Eigen Tensor reductions (sum, maximum, mean).
-// Tests full and partial reductions, inner vs outer dimension, DefaultDevice and ThreadPoolDevice.
-
-#define EIGEN_USE_THREADS
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-#include <unsupported/Eigen/CXX11/ThreadPool>
-
-using namespace Eigen;
-
-#ifndef SCALAR
-#define SCALAR float
-#endif
-
-typedef SCALAR Scalar;
-
-// --- Full reduction (rank-2) ---
-template <typename ReduceOp>
-static void BM_FullReduction(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  for (auto _ : state) {
-    Tensor<Scalar, 0> result = A.reduce(Eigen::array<int, 2>{0, 1}, ReduceOp());
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-// --- Partial reduction along dim 0 (inner dim, ColMajor) ---
-static void BM_ReduceInner(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  Eigen::array<int, 1> reduce_dims = {0};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 1> result = A.sum(reduce_dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-// --- Partial reduction along dim 1 (outer dim, ColMajor) ---
-static void BM_ReduceOuter(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  Eigen::array<int, 1> reduce_dims = {1};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 1> result = A.sum(reduce_dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-// --- Rank-4 partial reduction (batch x channels x H x W), reduce along spatial dims ---
-static void BM_ReduceSpatial(benchmark::State& state) {
-  const int batch = state.range(0);
-  const int C = state.range(1);
-  const int H = state.range(2);
-
-  Tensor<Scalar, 4> A(batch, C, H, H);
-  A.setRandom();
-
-  Eigen::array<int, 2> reduce_dims = {2, 3};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 2> result = A.sum(reduce_dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * batch * C * H * H * sizeof(Scalar));
-}
-
-// --- Full reduction with ThreadPoolDevice ---
-static void BM_FullReduction_ThreadPool(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-  const int threads = state.range(2);
-
-  Tensor<Scalar, 2> A(M, N);
-  Tensor<Scalar, 0> result;
-  A.setRandom();
-
-  ThreadPool tp(threads);
-  ThreadPoolDevice dev(&tp, threads);
-
-  for (auto _ : state) {
-    result.device(dev) = A.sum();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-  state.counters["threads"] = threads;
-}
-
-// --- Maximum reduction (rank-2) ---
-static void BM_MaxReduction(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  A.setRandom();
-
-  for (auto _ : state) {
-    Tensor<Scalar, 0> result = A.maximum();
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar));
-}
-
-static void ReductionSizes(::benchmark::Benchmark* b) {
-  for (int size : {64, 256, 1024}) {
-    b->Args({size, size});
-  }
-}
-
-static void ThreadPoolReductionSizes(::benchmark::Benchmark* b) {
-  for (int size : {256, 1024}) {
-    for (int threads : {2, 4, 8}) {
-      b->Args({size, size, threads});
-    }
-  }
-}
-
-static void SpatialSizes(::benchmark::Benchmark* b) {
-  for (int batch : {1, 8, 32}) {
-    for (int c : {64, 128}) {
-      for (int h : {16, 32}) {
-        b->Args({batch, c, h});
-      }
-    }
-  }
-}
-
-BENCHMARK(BM_FullReduction<internal::SumReducer<Scalar>>)->Apply(ReductionSizes)->Name("SumReduction");
-BENCHMARK(BM_FullReduction<internal::MaxReducer<Scalar>>)->Apply(ReductionSizes)->Name("MaxReduction_Full");
-BENCHMARK(BM_MaxReduction)->Apply(ReductionSizes);
-BENCHMARK(BM_ReduceInner)->Apply(ReductionSizes);
-BENCHMARK(BM_ReduceOuter)->Apply(ReductionSizes);
-BENCHMARK(BM_ReduceSpatial)->Apply(SpatialSizes);
-BENCHMARK(BM_FullReduction_ThreadPool)->Apply(ThreadPoolReductionSizes);
diff --git a/unsupported/benchmarks/Tensor/bench_shuffling.cpp b/unsupported/benchmarks/Tensor/bench_shuffling.cpp
deleted file mode 100644
index 6296acc..0000000
--- a/unsupported/benchmarks/Tensor/bench_shuffling.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-// Benchmarks for Eigen Tensor shuffling (transpose / permutation).
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-
-using namespace Eigen;
-
-typedef float Scalar;
-
-// --- Rank-2 transpose ---
-static void BM_Shuffle2D(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  Tensor<Scalar, 2> B(N, M);
-  A.setRandom();
-
-  Eigen::array<int, 2> perm = {1, 0};
-
-  for (auto _ : state) {
-    B = A.shuffle(perm);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
-}
-
-// --- Identity shuffle (no permutation, measures overhead) ---
-static void BM_ShuffleIdentity(benchmark::State& state) {
-  const int M = state.range(0);
-  const int N = state.range(1);
-
-  Tensor<Scalar, 2> A(M, N);
-  Tensor<Scalar, 2> B(M, N);
-  A.setRandom();
-
-  Eigen::array<int, 2> perm = {0, 1};
-
-  for (auto _ : state) {
-    B = A.shuffle(perm);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * M * N * sizeof(Scalar) * 2);
-}
-
-// --- Rank-3 permutation ---
-static void BM_Shuffle3D(benchmark::State& state) {
-  const int D0 = state.range(0);
-  const int D1 = state.range(1);
-  const int D2 = state.range(2);
-
-  Tensor<Scalar, 3> A(D0, D1, D2);
-  A.setRandom();
-
-  // Permutation (2, 0, 1)
-  Eigen::array<int, 3> perm = {2, 0, 1};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 3> B = A.shuffle(perm);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * D0 * D1 * D2 * sizeof(Scalar) * 2);
-}
-
-// --- Rank-4 permutation (NCHW -> NHWC layout conversion) ---
-static void BM_Shuffle4D_NCHW_to_NHWC(benchmark::State& state) {
-  const int N = state.range(0);
-  const int C = state.range(1);
-  const int H = state.range(2);
-
-  Tensor<Scalar, 4> A(N, C, H, H);
-  A.setRandom();
-
-  // NCHW -> NHWC: permute (0, 2, 3, 1)
-  Eigen::array<int, 4> perm = {0, 2, 3, 1};
-
-  for (auto _ : state) {
-    Tensor<Scalar, 4> B = A.shuffle(perm);
-    benchmark::DoNotOptimize(B.data());
-    benchmark::ClobberMemory();
-  }
-  state.SetBytesProcessed(state.iterations() * N * C * H * H * sizeof(Scalar) * 2);
-}
-
-static void Shuffle2DSizes(::benchmark::Benchmark* b) {
-  for (int size : {256, 1024}) {
-    b->Args({size, size});
-  }
-  b->Args({64, 4096});
-  b->Args({4096, 64});
-}
-
-static void Shuffle3DSizes(::benchmark::Benchmark* b) {
-  b->Args({64, 64, 64});
-  b->Args({128, 128, 64});
-  b->Args({32, 256, 256});
-}
-
-static void Shuffle4DSizes(::benchmark::Benchmark* b) {
-  for (int batch : {1, 8}) {
-    for (int c : {3, 64}) {
-      for (int h : {32, 64}) {
-        b->Args({batch, c, h});
-      }
-    }
-  }
-}
-
-BENCHMARK(BM_Shuffle2D)->Apply(Shuffle2DSizes);
-BENCHMARK(BM_ShuffleIdentity)->Apply(Shuffle2DSizes);
-BENCHMARK(BM_Shuffle3D)->Apply(Shuffle3DSizes);
-BENCHMARK(BM_Shuffle4D_NCHW_to_NHWC)->Apply(Shuffle4DSizes);
diff --git a/unsupported/benchmarks/Tensor/bench_tensor_fft.cpp b/unsupported/benchmarks/Tensor/bench_tensor_fft.cpp
deleted file mode 100644
index 26ff64b..0000000
--- a/unsupported/benchmarks/Tensor/bench_tensor_fft.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-// Benchmarks for Eigen Tensor FFT.
-
-#include <benchmark/benchmark.h>
-#include <unsupported/Eigen/CXX11/Tensor>
-
-using namespace Eigen;
-
-#ifndef SCALAR
-#define SCALAR float
-#endif
-
-typedef SCALAR Scalar;
-
-// --- 1D FFT ---
-static void BM_TensorFFT_1D(benchmark::State& state) {
-  const int N = state.range(0);
-
-  Tensor<Scalar, 1> input(N);
-  input.setRandom();
-
-  Eigen::array<int, 1> fft_dims = {0};
-
-  for (auto _ : state) {
-    Tensor<std::complex<Scalar>, 1> result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  double mflops = 5.0 * N * std::log2(static_cast<double>(N)) / 2.0;  // real->complex
-  state.counters["MFLOPS"] =
-      benchmark::Counter(mflops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-// --- 2D FFT ---
-static void BM_TensorFFT_2D(benchmark::State& state) {
-  const int N = state.range(0);
-
-  Tensor<Scalar, 2> input(N, N);
-  input.setRandom();
-
-  Eigen::array<int, 2> fft_dims = {0, 1};
-
-  for (auto _ : state) {
-    Tensor<std::complex<Scalar>, 2> result = input.template fft<BothParts, FFT_FORWARD>(fft_dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  double total = N * N;
-  double mflops = 5.0 * total * std::log2(static_cast<double>(N));
-  state.counters["MFLOPS"] =
-      benchmark::Counter(mflops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-// --- 1D inverse FFT ---
-static void BM_TensorIFFT_1D(benchmark::State& state) {
-  const int N = state.range(0);
-
-  Tensor<std::complex<Scalar>, 1> input(N);
-  input.setRandom();
-
-  Eigen::array<int, 1> fft_dims = {0};
-
-  for (auto _ : state) {
-    Tensor<std::complex<Scalar>, 1> result = input.template fft<BothParts, FFT_REVERSE>(fft_dims);
-    benchmark::DoNotOptimize(result.data());
-    benchmark::ClobberMemory();
-  }
-  double mflops = 5.0 * N * std::log2(static_cast<double>(N));
-  state.counters["MFLOPS"] =
-      benchmark::Counter(mflops, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
-}
-
-static void FFTSizes(::benchmark::Benchmark* b) {
-  for (int n : {64, 256, 1024, 4096}) {
-    b->Arg(n);
-  }
-}
-
-BENCHMARK(BM_TensorFFT_1D)->Apply(FFTSizes);
-BENCHMARK(BM_TensorFFT_2D)->Apply(FFTSizes);
-BENCHMARK(BM_TensorIFFT_1D)->Apply(FFTSizes);
diff --git a/unsupported/doc/CMakeLists.txt b/unsupported/doc/CMakeLists.txt
deleted file mode 100644
index 9e9ab98..0000000
--- a/unsupported/doc/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL TRUE)
-
-add_subdirectory(examples)
-add_subdirectory(snippets)
diff --git a/unsupported/doc/Overview.dox b/unsupported/doc/Overview.dox
deleted file mode 100644
index b3cfa96..0000000
--- a/unsupported/doc/Overview.dox
+++ /dev/null
@@ -1,31 +0,0 @@
-/// \brief Namespace containing all symbols from the %Eigen library.
-namespace Eigen {
-
-/** \mainpage notitle
-
-This is the API documentation for %Eigen's unsupported modules.
-
-These modules are contributions from various users. They are provided "as is", without any support.
-
-Click on the \e Modules tab at the top of this page to get a list of all unsupported modules.
-
-Don't miss the <a href="../index.html">official Eigen documentation</a>.
-
- \subpage SYCL_EIGEN "SYCL backend for Eigen"
-
-*/
-
-/*
-
-\defgroup Unsupported_modules Unsupported modules
-
-The unsupported modules are contributions from various users. They are
-provided "as is", without any support. Nevertheless, some of them are
-subject to be included in %Eigen in the future.
-
-*/
-
-/// \internal \brief Namespace containing low-level routines from the %Eigen library.
-namespace internal {}
-}
-
diff --git a/unsupported/doc/examples/BVH_Example.cpp b/unsupported/doc/examples/BVH_Example.cpp
deleted file mode 100644
index 8c37d71..0000000
--- a/unsupported/doc/examples/BVH_Example.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <Eigen/StdVector>
-#include <unsupported/Eigen/BVH>
-#include <iostream>
-
-using namespace Eigen;
-typedef AlignedBox<double, 2> Box2d;
-
-namespace Eigen {
-Box2d bounding_box(const Vector2d &v) { return Box2d(v, v); }  // compute the bounding box of a single point
-}  // namespace Eigen
-
-struct PointPointMinimizer  // how to compute squared distances between points and rectangles
-{
-  PointPointMinimizer() : calls(0) {}
-  typedef double Scalar;
-
-  double minimumOnVolumeVolume(const Box2d &r1, const Box2d &r2) {
-    ++calls;
-    return r1.squaredExteriorDistance(r2);
-  }
-  double minimumOnVolumeObject(const Box2d &r, const Vector2d &v) {
-    ++calls;
-    return r.squaredExteriorDistance(v);
-  }
-  double minimumOnObjectVolume(const Vector2d &v, const Box2d &r) {
-    ++calls;
-    return r.squaredExteriorDistance(v);
-  }
-  double minimumOnObjectObject(const Vector2d &v1, const Vector2d &v2) {
-    ++calls;
-    return (v1 - v2).squaredNorm();
-  }
-
-  int calls;
-};
-
-int main() {
-  typedef std::vector<Vector2d, aligned_allocator<Vector2d> > StdVectorOfVector2d;
-  StdVectorOfVector2d redPoints, bluePoints;
-  for (int i = 0; i < 100; ++i) {  // initialize random set of red points and blue points
-    redPoints.push_back(Vector2d::Random());
-    bluePoints.push_back(Vector2d::Random());
-  }
-
-  PointPointMinimizer minimizer;
-  double minDistSq = std::numeric_limits<double>::max();
-
-  // brute force to find closest red-blue pair
-  for (int i = 0; i < (int)redPoints.size(); ++i)
-    for (int j = 0; j < (int)bluePoints.size(); ++j)
-      minDistSq = std::min(minDistSq, minimizer.minimumOnObjectObject(redPoints[i], bluePoints[j]));
-  std::cout << "Brute force distance = " << sqrt(minDistSq) << ", calls = " << minimizer.calls << std::endl;
-
-  // using BVH to find closest red-blue pair
-  minimizer.calls = 0;
-  KdBVH<double, 2, Vector2d> redTree(redPoints.begin(), redPoints.end()),
-      blueTree(bluePoints.begin(), bluePoints.end());    // construct the trees
-  minDistSq = BVMinimize(redTree, blueTree, minimizer);  // actual BVH minimization call
-  std::cout << "BVH distance         = " << sqrt(minDistSq) << ", calls = " << minimizer.calls << std::endl;
-
-  return 0;
-}
diff --git a/unsupported/doc/examples/CMakeLists.txt b/unsupported/doc/examples/CMakeLists.txt
deleted file mode 100644
index 74f36eb..0000000
--- a/unsupported/doc/examples/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-file(GLOB examples_SRCS "*.cpp")
-
-add_custom_target(unsupported_examples)
-
-foreach(example_src ${examples_SRCS})
-  get_filename_component(example ${example_src} NAME_WE)
-  add_executable(example_${example} ${example_src})
-  if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
-    target_link_libraries(example_${example} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
-  endif()
-  target_link_libraries(example_${example}  Eigen3::Eigen)
-  add_custom_command(
-    TARGET example_${example}
-    POST_BUILD
-    COMMAND example_${example}
-    ARGS >${CMAKE_CURRENT_BINARY_DIR}/${example}.out
-  )
-  add_dependencies(unsupported_examples example_${example})
-endforeach(example_src)
-
-if(EIGEN_TEST_SYCL)
-  add_subdirectory(SYCL)
-endif(EIGEN_TEST_SYCL)
diff --git a/unsupported/doc/examples/EulerAngles.cpp b/unsupported/doc/examples/EulerAngles.cpp
deleted file mode 100644
index 5694770..0000000
--- a/unsupported/doc/examples/EulerAngles.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <unsupported/Eigen/EulerAngles>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  // A common Euler system by many armies around the world,
-  //  where the first one is the azimuth(the angle from the north -
-  //   the same angle that is show in compass)
-  //  and the second one is elevation(the angle from the horizon)
-  //  and the third one is roll(the angle between the horizontal body
-  //   direction and the plane ground surface)
-  // Keep remembering we're using radian angles here!
-  typedef EulerSystem<-EULER_Z, EULER_Y, EULER_X> MyArmySystem;
-  typedef EulerAngles<double, MyArmySystem> MyArmyAngles;
-
-  MyArmyAngles vehicleAngles(3.14 /*PI*/ / 2, /* heading to east, notice that this angle is counter-clockwise */
-                             -0.3,            /* going down from a mountain */
-                             0.1);            /* slightly rolled to the right */
-
-  // Some Euler angles representation that our plane use.
-  EulerAnglesZYZd planeAngles(0.78474, 0.5271, -0.513794);
-
-  MyArmyAngles planeAnglesInMyArmyAngles(planeAngles);
-
-  std::cout << "vehicle angles(MyArmy):     " << vehicleAngles << std::endl;
-  std::cout << "plane angles(ZYZ):        " << planeAngles << std::endl;
-  std::cout << "plane angles(MyArmy):     " << planeAnglesInMyArmyAngles << std::endl;
-
-  // Now lets rotate the plane a little bit
-  std::cout << "==========================================================\n";
-  std::cout << "rotating plane now!\n";
-  std::cout << "==========================================================\n";
-
-  Quaterniond planeRotated = AngleAxisd(-0.342, Vector3d::UnitY()) * planeAngles;
-
-  planeAngles = planeRotated;
-  planeAnglesInMyArmyAngles = planeRotated;
-
-  std::cout << "new plane angles(ZYZ):     " << planeAngles << std::endl;
-  std::cout << "new plane angles(MyArmy): " << planeAnglesInMyArmyAngles << std::endl;
-
-  return 0;
-}
diff --git a/unsupported/doc/examples/FFT.cpp b/unsupported/doc/examples/FFT.cpp
deleted file mode 100644
index bf24de5..0000000
--- a/unsupported/doc/examples/FFT.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//  To use the simple FFT implementation
-//  g++ -o demofft -I.. -Wall -O3 FFT.cpp
-
-//  To use the FFTW implementation
-//  g++ -o demofft -I.. -DUSE_FFTW -Wall -O3 FFT.cpp -lfftw3 -lfftw3f -lfftw3l
-
-#ifdef USE_FFTW
-#include <fftw3.h>
-#endif
-
-#include <vector>
-#include <complex>
-#include <algorithm>
-#include <iterator>
-#include <iostream>
-#include <Eigen/Core>
-#include <unsupported/Eigen/FFT>
-
-using namespace std;
-using namespace Eigen;
-
-template <typename T>
-T mag2(T a) {
-  return a * a;
-}
-template <typename T>
-T mag2(std::complex<T> a) {
-  return norm(a);
-}
-
-template <typename T>
-T mag2(const std::vector<T>& vec) {
-  T out = 0;
-  for (size_t k = 0; k < vec.size(); ++k) out += mag2(vec[k]);
-  return out;
-}
-
-template <typename T>
-T mag2(const std::vector<std::complex<T> >& vec) {
-  T out = 0;
-  for (size_t k = 0; k < vec.size(); ++k) out += mag2(vec[k]);
-  return out;
-}
-
-template <typename T>
-vector<T> operator-(const vector<T>& a, const vector<T>& b) {
-  vector<T> c(a);
-  for (size_t k = 0; k < b.size(); ++k) c[k] -= b[k];
-  return c;
-}
-
-template <typename T>
-void RandomFill(std::vector<T>& vec) {
-  for (size_t k = 0; k < vec.size(); ++k) vec[k] = T(rand()) / T(RAND_MAX) - T(.5);
-}
-
-template <typename T>
-void RandomFill(std::vector<std::complex<T> >& vec) {
-  for (size_t k = 0; k < vec.size(); ++k)
-    vec[k] = std::complex<T>(T(rand()) / T(RAND_MAX) - T(.5), T(rand()) / T(RAND_MAX) - T(.5));
-}
-
-template <typename T_time, typename T_freq>
-void fwd_inv(size_t nfft) {
-  typedef typename NumTraits<T_freq>::Real Scalar;
-  vector<T_time> timebuf(nfft);
-  RandomFill(timebuf);
-
-  vector<T_freq> freqbuf;
-  static FFT<Scalar> fft;
-  fft.fwd(freqbuf, timebuf);
-
-  vector<T_time> timebuf2;
-  fft.inv(timebuf2, freqbuf);
-
-  T_time rmse = mag2(timebuf - timebuf2) / mag2(timebuf);
-  cout << "roundtrip rmse: " << rmse << endl;
-}
-
-template <typename T_scalar>
-void two_demos(int nfft) {
-  cout << "     scalar ";
-  fwd_inv<T_scalar, std::complex<T_scalar> >(nfft);
-  cout << "    complex ";
-  fwd_inv<std::complex<T_scalar>, std::complex<T_scalar> >(nfft);
-}
-
-void demo_all_types(int nfft) {
-  cout << "nfft=" << nfft << endl;
-  cout << "   float" << endl;
-  two_demos<float>(nfft);
-  cout << "   double" << endl;
-  two_demos<double>(nfft);
-  cout << "   long double" << endl;
-  two_demos<long double>(nfft);
-}
-
-int main() {
-  demo_all_types(2 * 3 * 4 * 5 * 7);
-  demo_all_types(2 * 9 * 16 * 25);
-  demo_all_types(1024);
-  return 0;
-}
diff --git a/unsupported/doc/examples/MatrixExponential.cpp b/unsupported/doc/examples/MatrixExponential.cpp
deleted file mode 100644
index eab7a5e..0000000
--- a/unsupported/doc/examples/MatrixExponential.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  const double pi = std::acos(-1.0);
-
-  MatrixXd A(3, 3);
-  A << 0, -pi / 4, 0, pi / 4, 0, 0, 0, 0, 0;
-  std::cout << "The matrix A is:\n" << A << "\n\n";
-  std::cout << "The matrix exponential of A is:\n" << A.exp() << "\n\n";
-}
diff --git a/unsupported/doc/examples/MatrixFunction.cpp b/unsupported/doc/examples/MatrixFunction.cpp
deleted file mode 100644
index d72f62a..0000000
--- a/unsupported/doc/examples/MatrixFunction.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-std::complex<double> expfn(std::complex<double> x, int) { return std::exp(x); }
-
-int main() {
-  const double pi = std::acos(-1.0);
-
-  MatrixXd A(3, 3);
-  A << 0, -pi / 4, 0, pi / 4, 0, 0, 0, 0, 0;
-
-  std::cout << "The matrix A is:\n" << A << "\n\n";
-  std::cout << "The matrix exponential of A is:\n" << A.matrixFunction(expfn) << "\n\n";
-}
diff --git a/unsupported/doc/examples/MatrixLogarithm.cpp b/unsupported/doc/examples/MatrixLogarithm.cpp
deleted file mode 100644
index 41b7ff6..0000000
--- a/unsupported/doc/examples/MatrixLogarithm.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  using std::sqrt;
-  MatrixXd A(3, 3);
-  A << 0.5 * sqrt(2), -0.5 * sqrt(2), 0, 0.5 * sqrt(2), 0.5 * sqrt(2), 0, 0, 0, 1;
-  std::cout << "The matrix A is:\n" << A << "\n\n";
-  std::cout << "The matrix logarithm of A is:\n" << A.log() << "\n";
-}
diff --git a/unsupported/doc/examples/MatrixPower.cpp b/unsupported/doc/examples/MatrixPower.cpp
deleted file mode 100644
index 35501b6..0000000
--- a/unsupported/doc/examples/MatrixPower.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  const double pi = std::acos(-1.0);
-  Matrix3d A;
-  A << cos(1), -sin(1), 0, sin(1), cos(1), 0, 0, 0, 1;
-  std::cout << "The matrix A is:\n"
-            << A
-            << "\n\n"
-               "The matrix power A^(pi/4) is:\n"
-            << A.pow(pi / 4) << std::endl;
-  return 0;
-}
diff --git a/unsupported/doc/examples/MatrixPower_optimal.cpp b/unsupported/doc/examples/MatrixPower_optimal.cpp
deleted file mode 100644
index 5f5f3e4..0000000
--- a/unsupported/doc/examples/MatrixPower_optimal.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  Matrix4cd A = Matrix4cd::Random();
-  MatrixPower<Matrix4cd> Apow(A);
-
-  std::cout << "The matrix A is:\n"
-            << A
-            << "\n\n"
-               "A^3.1 is:\n"
-            << Apow(3.1)
-            << "\n\n"
-               "A^3.3 is:\n"
-            << Apow(3.3)
-            << "\n\n"
-               "A^3.7 is:\n"
-            << Apow(3.7)
-            << "\n\n"
-               "A^3.9 is:\n"
-            << Apow(3.9) << std::endl;
-  return 0;
-}
diff --git a/unsupported/doc/examples/MatrixSine.cpp b/unsupported/doc/examples/MatrixSine.cpp
deleted file mode 100644
index eeafa50..0000000
--- a/unsupported/doc/examples/MatrixSine.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  MatrixXd A = MatrixXd::Random(3, 3);
-  std::cout << "A = \n" << A << "\n\n";
-
-  MatrixXd sinA = A.sin();
-  std::cout << "sin(A) = \n" << sinA << "\n\n";
-
-  MatrixXd cosA = A.cos();
-  std::cout << "cos(A) = \n" << cosA << "\n\n";
-
-  // The matrix functions satisfy sin^2(A) + cos^2(A) = I,
-  // like the scalar functions.
-  std::cout << "sin^2(A) + cos^2(A) = \n" << sinA * sinA + cosA * cosA << "\n\n";
-}
diff --git a/unsupported/doc/examples/MatrixSinh.cpp b/unsupported/doc/examples/MatrixSinh.cpp
deleted file mode 100644
index 1aabbb3..0000000
--- a/unsupported/doc/examples/MatrixSinh.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  MatrixXf A = MatrixXf::Random(3, 3);
-  std::cout << "A = \n" << A << "\n\n";
-
-  MatrixXf sinhA = A.sinh();
-  std::cout << "sinh(A) = \n" << sinhA << "\n\n";
-
-  MatrixXf coshA = A.cosh();
-  std::cout << "cosh(A) = \n" << coshA << "\n\n";
-
-  // The matrix functions satisfy cosh^2(A) - sinh^2(A) = I,
-  // like the scalar functions.
-  std::cout << "cosh^2(A) - sinh^2(A) = \n" << coshA * coshA - sinhA * sinhA << "\n\n";
-}
diff --git a/unsupported/doc/examples/MatrixSquareRoot.cpp b/unsupported/doc/examples/MatrixSquareRoot.cpp
deleted file mode 100644
index 0ac4fdc..0000000
--- a/unsupported/doc/examples/MatrixSquareRoot.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <unsupported/Eigen/MatrixFunctions>
-#include <iostream>
-
-using namespace Eigen;
-
-int main() {
-  const double pi = std::acos(-1.0);
-
-  MatrixXd A(2, 2);
-  A << cos(pi / 3), -sin(pi / 3), sin(pi / 3), cos(pi / 3);
-  std::cout << "The matrix A is:\n" << A << "\n\n";
-  std::cout << "The matrix square root of A is:\n" << A.sqrt() << "\n\n";
-  std::cout << "The square of the last matrix is:\n" << A.sqrt() * A.sqrt() << "\n";
-}
diff --git a/unsupported/doc/examples/PolynomialSolver1.cpp b/unsupported/doc/examples/PolynomialSolver1.cpp
deleted file mode 100644
index c1bf976..0000000
--- a/unsupported/doc/examples/PolynomialSolver1.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <unsupported/Eigen/Polynomials>
-#include <vector>
-#include <iostream>
-
-using namespace Eigen;
-using namespace std;
-
-int main() {
-  typedef Matrix<double, 5, 1> Vector5d;
-
-  Vector5d roots = Vector5d::Random();
-  cout << "Roots: " << roots.transpose() << endl;
-  Eigen::Matrix<double, 6, 1> polynomial;
-  roots_to_monicPolynomial(roots, polynomial);
-
-  PolynomialSolver<double, 5> psolve(polynomial);
-  cout << "Complex roots: " << psolve.roots().transpose() << endl;
-
-  std::vector<double> realRoots;
-  psolve.realRoots(realRoots);
-  Map<Vector5d> mapRR(&realRoots[0]);
-  cout << "Real roots: " << mapRR.transpose() << endl;
-
-  cout << endl;
-  cout << "Illustration of the convergence problem with the QR algorithm: " << endl;
-  cout << "---------------------------------------------------------------" << endl;
-  Eigen::Matrix<float, 7, 1> hardCase_polynomial;
-  hardCase_polynomial << -0.957, 0.9219, 0.3516, 0.9453, -0.4023, -0.5508, -0.03125;
-  cout << "Hard case polynomial defined by floats: " << hardCase_polynomial.transpose() << endl;
-  PolynomialSolver<float, 6> psolvef(hardCase_polynomial);
-  cout << "Complex roots: " << psolvef.roots().transpose() << endl;
-  Eigen::Matrix<float, 6, 1> evals;
-  for (int i = 0; i < 6; ++i) {
-    evals[i] = std::abs(poly_eval(hardCase_polynomial, psolvef.roots()[i]));
-  }
-  cout << "Norms of the evaluations of the polynomial at the roots: " << evals.transpose() << endl << endl;
-
-  cout << "Using double's almost always solves the problem for small degrees: " << endl;
-  cout << "-------------------------------------------------------------------" << endl;
-  PolynomialSolver<double, 6> psolve6d(hardCase_polynomial.cast<double>());
-  cout << "Complex roots: " << psolve6d.roots().transpose() << endl;
-  for (int i = 0; i < 6; ++i) {
-    std::complex<float> castedRoot(psolve6d.roots()[i].real(), psolve6d.roots()[i].imag());
-    evals[i] = std::abs(poly_eval(hardCase_polynomial, castedRoot));
-  }
-  cout << "Norms of the evaluations of the polynomial at the roots: " << evals.transpose() << endl << endl;
-
-  cout.precision(10);
-  cout << "The last root in float then in double: " << psolvef.roots()[5] << "\t" << psolve6d.roots()[5] << endl;
-  std::complex<float> castedRoot(psolve6d.roots()[5].real(), psolve6d.roots()[5].imag());
-  cout << "Norm of the difference: " << std::abs(psolvef.roots()[5] - castedRoot) << endl;
-}
diff --git a/unsupported/doc/examples/PolynomialUtils1.cpp b/unsupported/doc/examples/PolynomialUtils1.cpp
deleted file mode 100644
index a050b01..0000000
--- a/unsupported/doc/examples/PolynomialUtils1.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <unsupported/Eigen/Polynomials>
-#include <iostream>
-
-using namespace Eigen;
-using namespace std;
-
-int main() {
-  Vector4d roots = Vector4d::Random();
-  cout << "Roots: " << roots.transpose() << endl;
-  Eigen::Matrix<double, 5, 1> polynomial;
-  roots_to_monicPolynomial(roots, polynomial);
-  cout << "Polynomial: ";
-  for (int i = 0; i < 4; ++i) {
-    cout << polynomial[i] << ".x^" << i << "+ ";
-  }
-  cout << polynomial[4] << ".x^4" << endl;
-  Vector4d evaluation;
-  for (int i = 0; i < 4; ++i) {
-    evaluation[i] = poly_eval(polynomial, roots[i]);
-  }
-  cout << "Evaluation of the polynomial at the roots: " << evaluation.transpose();
-}
diff --git a/unsupported/doc/examples/SYCL/CMakeLists.txt b/unsupported/doc/examples/SYCL/CMakeLists.txt
deleted file mode 100644
index 4fe94c6..0000000
--- a/unsupported/doc/examples/SYCL/CMakeLists.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-FILE(GLOB examples_SRCS "*.cpp")
-
-set(EIGEN_SYCL ON)
-list(APPEND CMAKE_EXE_LINKER_FLAGS -pthread)
-set(CMAKE_CXX_STANDARD 17)
-if(EIGEN_SYCL_ComputeCpp)
-  if(MSVC)
-    list(APPEND COMPUTECPP_USER_FLAGS -DWIN32)
-  else()
-    list(APPEND COMPUTECPP_USER_FLAGS -Wall)
-  endif()
-  # The following flags are not supported by Clang and can cause warnings
-  # if used with -Werror so they are removed here.
-  if(COMPUTECPP_USE_COMPILER_DRIVER)
-    set(CMAKE_CXX_COMPILER ${ComputeCpp_DEVICE_COMPILER_EXECUTABLE})
-    string(REPLACE "-Wlogical-op" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-    string(REPLACE "-Wno-psabi" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-  endif()
-  list(APPEND COMPUTECPP_USER_FLAGS
-      -DEIGEN_NO_ASSERTION_CHECKING=1
-      -no-serial-memop
-      -Xclang
-      -cl-mad-enable)
-endif(EIGEN_SYCL_ComputeCpp)
-
-FOREACH(example_src ${examples_SRCS})
-  GET_FILENAME_COMPONENT(example ${example_src} NAME_WE)
-  ei_add_test_internal(${example} example_${example})
-  ADD_DEPENDENCIES(unsupported_examples example_${example})
-ENDFOREACH(example_src)
-set(EIGEN_SYCL OFF)
diff --git a/unsupported/doc/examples/SYCL/CwiseMul.cpp b/unsupported/doc/examples/SYCL/CwiseMul.cpp
deleted file mode 100644
index 0297998..0000000
--- a/unsupported/doc/examples/SYCL/CwiseMul.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#include <iostream>
-#define EIGEN_USE_SYCL
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-int main() {
-  using DataType = float;
-  using IndexType = int64_t;
-  constexpr auto DataLayout = Eigen::RowMajor;
-
-  auto devices = Eigen::get_sycl_supported_devices();
-  const auto device_selector = *devices.begin();
-  Eigen::QueueInterface queueInterface(device_selector);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-
-  // create the tensors to be used in the operation
-  IndexType sizeDim1 = 3;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 3;
-  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-
-  // initialize the tensors with the data we want manipulate to
-  Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
-
-  // set up some random data in the tensors to be multiplied
-  in1 = in1.random();
-  in2 = in2.random();
-
-  // allocate memory for the tensors
-  DataType* gpu_in1_data = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
-  DataType* gpu_in2_data = static_cast<DataType*>(sycl_device.allocate(in2.size() * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-
-  //
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
-
-  // copy the memory to the device and do the c=a*b calculation
-  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.size()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.size()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = gpu_in1 * gpu_in2;
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-
-  // print out the results
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        std::cout << "device_out"
-                  << "(" << i << ", " << j << ", " << k << ") : " << out(i, j, k) << " vs host_out"
-                  << "(" << i << ", " << j << ", " << k << ") : " << in1(i, j, k) * in2(i, j, k) << "\n";
-      }
-    }
-  }
-  printf("c=a*b Done\n");
-}
diff --git a/unsupported/doc/snippets/CMakeLists.txt b/unsupported/doc/snippets/CMakeLists.txt
deleted file mode 100644
index adf95a8..0000000
--- a/unsupported/doc/snippets/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-file(GLOB snippets_SRCS "*.cpp")
-
-add_custom_target(unsupported_snippets)
-
-foreach(snippet_src ${snippets_SRCS})
-  get_filename_component(snippet ${snippet_src} NAME_WE)
-  set(compile_snippet_target compile_${snippet})
-  set(compile_snippet_src ${compile_snippet_target}.cpp)
-  file(READ ${snippet_src} snippet_source_code)
-  configure_file(${PROJECT_SOURCE_DIR}/doc/snippets/compile_snippet.cpp.in
-                 ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src})
-  add_executable(${compile_snippet_target}
-                 ${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src})
-  if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO)
-    target_link_libraries(${compile_snippet_target} ${EIGEN_STANDARD_LIBRARIES_TO_LINK_TO})
-  endif()
-  add_custom_command(
-    TARGET ${compile_snippet_target}
-    POST_BUILD
-    COMMAND ${compile_snippet_target}
-    ARGS >${CMAKE_CURRENT_BINARY_DIR}/${snippet}.out
-  )
-  add_dependencies(unsupported_snippets ${compile_snippet_target})
-  set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${compile_snippet_src}
-                              PROPERTIES OBJECT_DEPENDS ${snippet_src})
-endforeach(snippet_src)
diff --git a/unsupported/test/BVH.cpp b/unsupported/test/BVH.cpp
deleted file mode 100644
index 54ecc5c..0000000
--- a/unsupported/test/BVH.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Ilya Baran <ibaran@mit.edu>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <Eigen/StdVector>
-#include <Eigen/Geometry>
-#include <unsupported/Eigen/BVH>
-
-namespace Eigen {
-
-template <typename Scalar, int Dim>
-AlignedBox<Scalar, Dim> bounding_box(const Matrix<Scalar, Dim, 1> &v) {
-  return AlignedBox<Scalar, Dim>(v);
-}
-
-}  // namespace Eigen
-
-template <int Dim>
-struct Ball {
-  EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(double, Dim)
-
-  typedef Matrix<double, Dim, 1> VectorType;
-
-  Ball() {}
-  Ball(const VectorType &c, double r) : center(c), radius(r) {}
-
-  VectorType center;
-  double radius;
-};
-template <int Dim>
-AlignedBox<double, Dim> bounding_box(const Ball<Dim> &b) {
-  return AlignedBox<double, Dim>(b.center.array() - b.radius, b.center.array() + b.radius);
-}
-
-inline double SQR(double x) { return x * x; }
-
-template <int Dim>
-struct BallPointStuff  // this class provides functions to be both an intersector and a minimizer, both for a ball and a
-                       // point and for two trees
-{
-  typedef double Scalar;
-  typedef Matrix<double, Dim, 1> VectorType;
-  typedef Ball<Dim> BallType;
-  typedef AlignedBox<double, Dim> BoxType;
-
-  BallPointStuff() : calls(0), count(0) {}
-  BallPointStuff(const VectorType &inP) : p(inP), calls(0), count(0) {}
-
-  bool intersectVolume(const BoxType &r) {
-    ++calls;
-    return r.contains(p);
-  }
-  bool intersectObject(const BallType &b) {
-    ++calls;
-    if ((b.center - p).squaredNorm() < SQR(b.radius)) ++count;
-    return false;  // continue
-  }
-
-  bool intersectVolumeVolume(const BoxType &r1, const BoxType &r2) {
-    ++calls;
-    return !(r1.intersection(r2)).isNull();
-  }
-  bool intersectVolumeObject(const BoxType &r, const BallType &b) {
-    ++calls;
-    return r.squaredExteriorDistance(b.center) < SQR(b.radius);
-  }
-  bool intersectObjectVolume(const BallType &b, const BoxType &r) {
-    ++calls;
-    return r.squaredExteriorDistance(b.center) < SQR(b.radius);
-  }
-  bool intersectObjectObject(const BallType &b1, const BallType &b2) {
-    ++calls;
-    if ((b1.center - b2.center).norm() < b1.radius + b2.radius) ++count;
-    return false;
-  }
-  bool intersectVolumeObject(const BoxType &r, const VectorType &v) {
-    ++calls;
-    return r.contains(v);
-  }
-  bool intersectObjectObject(const BallType &b, const VectorType &v) {
-    ++calls;
-    if ((b.center - v).squaredNorm() < SQR(b.radius)) ++count;
-    return false;
-  }
-
-  double minimumOnVolume(const BoxType &r) {
-    ++calls;
-    return r.squaredExteriorDistance(p);
-  }
-  double minimumOnObject(const BallType &b) {
-    ++calls;
-    return (std::max)(0., (b.center - p).squaredNorm() - SQR(b.radius));
-  }
-  double minimumOnVolumeVolume(const BoxType &r1, const BoxType &r2) {
-    ++calls;
-    return r1.squaredExteriorDistance(r2);
-  }
-  double minimumOnVolumeObject(const BoxType &r, const BallType &b) {
-    ++calls;
-    return SQR((std::max)(0., r.exteriorDistance(b.center) - b.radius));
-  }
-  double minimumOnObjectVolume(const BallType &b, const BoxType &r) {
-    ++calls;
-    return SQR((std::max)(0., r.exteriorDistance(b.center) - b.radius));
-  }
-  double minimumOnObjectObject(const BallType &b1, const BallType &b2) {
-    ++calls;
-    return SQR((std::max)(0., (b1.center - b2.center).norm() - b1.radius - b2.radius));
-  }
-  double minimumOnVolumeObject(const BoxType &r, const VectorType &v) {
-    ++calls;
-    return r.squaredExteriorDistance(v);
-  }
-  double minimumOnObjectObject(const BallType &b, const VectorType &v) {
-    ++calls;
-    return SQR((std::max)(0., (b.center - v).norm() - b.radius));
-  }
-
-  VectorType p;
-  int calls;
-  int count;
-};
-
-template <int Dim>
-struct TreeTest {
-  typedef Matrix<double, Dim, 1> VectorType;
-  typedef std::vector<VectorType, aligned_allocator<VectorType> > VectorTypeList;
-  typedef Ball<Dim> BallType;
-  typedef std::vector<BallType, aligned_allocator<BallType> > BallTypeList;
-  typedef AlignedBox<double, Dim> BoxType;
-
-  void testIntersect1() {
-    BallTypeList b;
-    for (int i = 0; i < 500; ++i) {
-      b.push_back(BallType(VectorType::Random(), 0.5 * internal::random(0., 1.)));
-    }
-    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
-
-    VectorType pt = VectorType::Random();
-    BallPointStuff<Dim> i1(pt), i2(pt);
-
-    for (int i = 0; i < (int)b.size(); ++i) i1.intersectObject(b[i]);
-
-    BVIntersect(tree, i2);
-
-    VERIFY(i1.count == i2.count);
-  }
-
-  void testMinimize1() {
-    BallTypeList b;
-    for (int i = 0; i < 500; ++i) {
-      b.push_back(BallType(VectorType::Random(), 0.01 * internal::random(0., 1.)));
-    }
-    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
-
-    VectorType pt = VectorType::Random();
-    BallPointStuff<Dim> i1(pt), i2(pt);
-
-    double m1 = (std::numeric_limits<double>::max)(), m2 = m1;
-
-    for (int i = 0; i < (int)b.size(); ++i) m1 = (std::min)(m1, i1.minimumOnObject(b[i]));
-
-    m2 = BVMinimize(tree, i2);
-
-    VERIFY_IS_APPROX(m1, m2);
-  }
-
-  void testIntersect2() {
-    BallTypeList b;
-    VectorTypeList v;
-
-    for (int i = 0; i < 50; ++i) {
-      b.push_back(BallType(VectorType::Random(), 0.5 * internal::random(0., 1.)));
-      for (int j = 0; j < 3; ++j) v.push_back(VectorType::Random());
-    }
-
-    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
-    KdBVH<double, Dim, VectorType> vTree(v.begin(), v.end());
-
-    BallPointStuff<Dim> i1, i2;
-
-    for (int i = 0; i < (int)b.size(); ++i)
-      for (int j = 0; j < (int)v.size(); ++j) i1.intersectObjectObject(b[i], v[j]);
-
-    BVIntersect(tree, vTree, i2);
-
-    VERIFY(i1.count == i2.count);
-  }
-
-  void testMinimize2() {
-    BallTypeList b;
-    VectorTypeList v;
-
-    for (int i = 0; i < 50; ++i) {
-      b.push_back(BallType(VectorType::Random(), 1e-7 + 1e-6 * internal::random(0., 1.)));
-      for (int j = 0; j < 3; ++j) v.push_back(VectorType::Random());
-    }
-
-    KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
-    KdBVH<double, Dim, VectorType> vTree(v.begin(), v.end());
-
-    BallPointStuff<Dim> i1, i2;
-
-    double m1 = (std::numeric_limits<double>::max)(), m2 = m1;
-
-    for (int i = 0; i < (int)b.size(); ++i)
-      for (int j = 0; j < (int)v.size(); ++j) m1 = (std::min)(m1, i1.minimumOnObjectObject(b[i], v[j]));
-
-    m2 = BVMinimize(tree, vTree, i2);
-
-    VERIFY_IS_APPROX(m1, m2);
-  }
-};
-
-EIGEN_DECLARE_TEST(BVH) {
-  for (int i = 0; i < g_repeat; i++) {
-#ifdef EIGEN_TEST_PART_1
-    TreeTest<2> test2;
-    CALL_SUBTEST(test2.testIntersect1());
-    CALL_SUBTEST(test2.testMinimize1());
-    CALL_SUBTEST(test2.testIntersect2());
-    CALL_SUBTEST(test2.testMinimize2());
-#endif
-
-#ifdef EIGEN_TEST_PART_2
-    TreeTest<3> test3;
-    CALL_SUBTEST(test3.testIntersect1());
-    CALL_SUBTEST(test3.testMinimize1());
-    CALL_SUBTEST(test3.testIntersect2());
-    CALL_SUBTEST(test3.testMinimize2());
-#endif
-
-#ifdef EIGEN_TEST_PART_3
-    TreeTest<4> test4;
-    CALL_SUBTEST(test4.testIntersect1());
-    CALL_SUBTEST(test4.testMinimize1());
-    CALL_SUBTEST(test4.testIntersect2());
-    CALL_SUBTEST(test4.testMinimize2());
-#endif
-  }
-}
diff --git a/unsupported/test/CMakeLists.txt b/unsupported/test/CMakeLists.txt
deleted file mode 100644
index 4160fad..0000000
--- a/unsupported/test/CMakeLists.txt
+++ /dev/null
@@ -1,359 +0,0 @@
-# The file split_test_helper.h was generated at first run,
-# it is now included in test/
-if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
-  file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/split_test_helper.h)
-endif()
-
-set_property(GLOBAL PROPERTY EIGEN_CURRENT_SUBPROJECT "Unsupported")
-add_custom_target(BuildUnsupported)
-
-include_directories(../../test ../../unsupported
-                    ${CMAKE_CURRENT_BINARY_DIR}/../../test)
-
-find_package (Threads)
-
-find_package(GoogleHash)
-if(GoogleHash_FOUND)
-  add_definitions("-DEIGEN_GOOGLEHASH_SUPPORT")
-  include_directories(${GOOGLEHASH_INCLUDES})
-  ei_add_property(EIGEN_TESTED_BACKENDS  "GoogleHash, ")
-else()
-  ei_add_property(EIGEN_MISSING_BACKENDS  "GoogleHash, ")
-endif()
-
-
-find_package(Adolc)
-if(Adolc_FOUND)
-  include_directories(${ADOLC_INCLUDES})
-  ei_add_property(EIGEN_TESTED_BACKENDS "Adolc, ")
-  ei_add_test(forward_adolc "" ${ADOLC_LIBRARIES})
-else()
-  ei_add_property(EIGEN_MISSING_BACKENDS "Adolc, ")
-endif()
-
-# this test seems to never have been successful on x87, so is considered to contain a FP-related bug.
-# see thread: "non-linear optimization test summary"
-ei_add_test(NonLinearOptimization)
-
-ei_add_test(NumericalDiff)
-ei_add_test(autodiff_scalar)
-ei_add_test(autodiff)
-
-ei_add_test(BVH)
-
-ei_add_test(matrix_exponential)
-ei_add_test(matrix_function)
-ei_add_test(matrix_power)
-ei_add_test(matrix_square_root)
-ei_add_test(alignedvector3)
-
-ei_add_test(FFT)
-
-ei_add_test(EulerAngles)
-
-find_package(MPREAL)
-if(MPREAL_FOUND)
-  ei_add_property(EIGEN_TESTED_BACKENDS "MPFR C++, ")
-  include_directories(${MPREAL_INCLUDES})
-  ei_add_test(mpreal_support "" "${MPREAL_LIBRARIES}" )
-else()
-  ei_add_property(EIGEN_MISSING_BACKENDS "MPFR C++, ")
-endif()
-
-ei_add_test(NNLS)
-
-ei_add_test(sparse_extra   "" "")
-
-find_package(FFTW)
-if(FFTW_FOUND)
-  ei_add_property(EIGEN_TESTED_BACKENDS "fftw, ")
-  include_directories( ${FFTW_INCLUDES} )
-  if(FFTWL_LIB)
-    ei_add_test(FFTW  "-DEIGEN_HAS_FFTWL" "${FFTW_LIBRARIES}" )
-  else()
-    ei_add_test(FFTW  "${FFTW_LIBRARIES}" )
-  endif()
-else()
-  ei_add_property(EIGEN_MISSING_BACKENDS "fftw, ")
-endif()
-
-find_path(POCKETFFT  pocketfft_hdronly.h)
-if(POCKETFFT)
-  if(EIGEN_TEST_CXX11)
-    ei_add_property(EIGEN_TESTED_BACKENDS "pocketfft, ")
-    include_directories( ${POCKETFFT} )
-    ei_add_test(pocketfft "-pthread" "${CMAKE_THREAD_LIBS_INIT}" )
-  endif()
-else()
-  ei_add_property(EIGEN_MISSING_BACKENDS "pocketfft, ")
-endif()
-
-if( NOT DUCC_ROOT AND ENV{DUCC_ROOT} )
-  set( DUCC_ROOT $ENV{DUCC_ROOT} )
-endif()
-find_path(DUCCFFT
-  NAMES "src/ducc0/fft/fft.h"
-  PATHS ${DUCC_ROOT})
-message(INFO " ${DUCC_ROOT} ${DUCCFFT}")
-if(DUCCFFT)
-  ei_add_property(EIGEN_TESTED_BACKENDS "duccfft, ")
-  include_directories( "${DUCCFFT}/src" )
-  add_library(ducc_lib "${DUCCFFT}/src/ducc0/infra/string_utils.cc" "${DUCCFFT}/src/ducc0/infra/threading.cc")
-  target_compile_definitions(ducc_lib PUBLIC "DUCC0_NO_THREADING=1")
-  ei_add_test(duccfft "-DEIGEN_DUCCFFT_DEFAULT -DDUCC0_NO_THREADING=1" "ducc_lib" )
-  set_target_properties(ducc_lib duccfft PROPERTIES CXX_STANDARD 17)
-else()
-  ei_add_property(EIGEN_MISSING_BACKENDS "duccfft, ")
-endif()
-
-
-option(EIGEN_TEST_OPENGL "Enable OpenGL support in unit tests" OFF)
-if(EIGEN_TEST_OPENGL)
-  find_package(OpenGL)
-  find_package(GLUT)
-  find_package(GLEW)
-  if(OPENGL_FOUND AND GLUT_FOUND AND GLEW_FOUND)
-    include_directories(${OPENGL_INCLUDE_DIR} ${GLUT_INCLUDE_DIR} ${GLEW_INCLUDE_DIRS})
-    ei_add_property(EIGEN_TESTED_BACKENDS "OpenGL, ")
-    set(EIGEN_GL_LIB ${GLUT_LIBRARIES} ${GLEW_LIBRARIES} ${OPENGL_LIBRARIES})
-    ei_add_test(openglsupport  "" "${EIGEN_GL_LIB}" )
-  else()
-    ei_add_property(EIGEN_MISSING_BACKENDS "OpenGL, ")
-  endif()
-else()
-    ei_add_property(EIGEN_MISSING_BACKENDS "OpenGL, ")
-endif()
-
-ei_add_test(polynomialsolver)
-ei_add_test(polynomialutils)
-ei_add_test(splines)
-ei_add_test(gmres)
-ei_add_test(dgmres)
-ei_add_test(minres)
-ei_add_test(idrs)
-ei_add_test(bicgstabl)
-ei_add_test(idrstabl)
-ei_add_test(levenberg_marquardt)
-ei_add_test(kronecker_product)
-ei_add_test(bessel_functions)
-ei_add_test(special_functions)
-ei_add_test(special_packetmath "-DEIGEN_FAST_MATH=1")
-
-if(EIGEN_TEST_SYCL)
-  set(EIGEN_SYCL ON)
-  include(SyclConfigureTesting)
-
-  ei_add_test(cxx11_tensor_sycl)
-  ei_add_test(cxx11_tensor_image_op_sycl)
-  ei_add_test(cxx11_tensor_math_sycl)
-  ei_add_test(cxx11_tensor_forced_eval_sycl)
-  ei_add_test(cxx11_tensor_broadcast_sycl)
-  ei_add_test(cxx11_tensor_device_sycl)
-  ei_add_test(cxx11_tensor_reduction_sycl)
-  ei_add_test(cxx11_tensor_morphing_sycl)
-  ei_add_test(cxx11_tensor_shuffling_sycl)
-  ei_add_test(cxx11_tensor_padding_sycl)
-  ei_add_test(cxx11_tensor_builtins_sycl)
-  ei_add_test(cxx11_tensor_contract_sycl)
-  ei_add_test(cxx11_tensor_concatenation_sycl)
-  ei_add_test(cxx11_tensor_reverse_sycl)
-  ei_add_test(cxx11_tensor_convolution_sycl)
-  ei_add_test(cxx11_tensor_striding_sycl)
-  ei_add_test(cxx11_tensor_chipping_sycl)
-  ei_add_test(cxx11_tensor_layout_swap_sycl)
-  ei_add_test(cxx11_tensor_inflation_sycl)
-  ei_add_test(cxx11_tensor_random_sycl)
-  ei_add_test(cxx11_tensor_generator_sycl)
-  ei_add_test(cxx11_tensor_patch_sycl)
-  ei_add_test(cxx11_tensor_image_patch_sycl)
-  ei_add_test(cxx11_tensor_volume_patch_sycl)
-  ei_add_test(cxx11_tensor_argmax_sycl)
-  ei_add_test(cxx11_tensor_custom_op_sycl)
-  ei_add_test(cxx11_tensor_scan_sycl)
-  ei_add_test(cxx11_tensor_of_float16_sycl)
-  set(EIGEN_SYCL OFF)
-endif()
-
-ei_add_test(cxx11_tensor_argmax)
-ei_add_test(cxx11_tensor_assign)
-ei_add_test(cxx11_tensor_block_access)
-ei_add_test(cxx11_tensor_block_eval)
-ei_add_test(cxx11_tensor_block_io)
-ei_add_test(cxx11_tensor_broadcasting)
-ei_add_test(cxx11_tensor_casts)
-ei_add_test(cxx11_tensor_chipping)
-ei_add_test(cxx11_tensor_comparisons)
-ei_add_test(cxx11_tensor_concatenation)
-ei_add_test(cxx11_tensor_const)
-ei_add_test(cxx11_tensor_contraction)
-ei_add_test(cxx11_tensor_convolution)
-ei_add_test(cxx11_tensor_custom_index)
-ei_add_test(cxx11_tensor_custom_op)
-ei_add_test(cxx11_tensor_dimension)
-ei_add_test(cxx11_tensor_empty)
-ei_add_test(cxx11_tensor_executor "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
-ei_add_test(cxx11_tensor_expr)
-ei_add_test(cxx11_tensor_fft)
-ei_add_test(cxx11_tensor_fixed_size)
-ei_add_test(cxx11_tensor_forced_eval)
-ei_add_test(cxx11_tensor_generator)
-ei_add_test(cxx11_tensor_ifft)
-ei_add_test(cxx11_tensor_image_patch)
-ei_add_test(cxx11_tensor_index_list)
-ei_add_test(cxx11_tensor_inflation)
-ei_add_test(cxx11_tensor_intdiv)
-ei_add_test(cxx11_tensor_io)
-ei_add_test(cxx11_tensor_layout_swap)
-ei_add_test(cxx11_tensor_lvalue)
-ei_add_test(cxx11_tensor_map)
-ei_add_test(cxx11_tensor_math)
-ei_add_test(cxx11_tensor_mixed_indices)
-ei_add_test(cxx11_tensor_morphing)
-ei_add_test(cxx11_tensor_move)
-ei_add_test(cxx11_tensor_notification "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
-ei_add_test(cxx11_tensor_of_complex)
-ei_add_test(cxx11_tensor_of_const_values)
-ei_add_test(cxx11_tensor_of_strings)
-ei_add_test(cxx11_tensor_padding)
-ei_add_test(cxx11_tensor_patch)
-ei_add_test(cxx11_tensor_random)
-ei_add_test(cxx11_tensor_reverse)
-ei_add_test(cxx11_tensor_reduction)
-ei_add_test(cxx11_tensor_ref)
-ei_add_test(cxx11_tensor_roll)
-ei_add_test(cxx11_tensor_roundings)
-ei_add_test(cxx11_tensor_scan)
-ei_add_test(cxx11_tensor_shuffling)
-ei_add_test(cxx11_tensor_simple)
-ei_add_test(cxx11_tensor_striding)
-ei_add_test(cxx11_tensor_sugar)
-ei_add_test(cxx11_tensor_thread_local "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
-ei_add_test(cxx11_tensor_thread_pool "-pthread" "${CMAKE_THREAD_LIBS_INIT}")
-ei_add_test(cxx11_tensor_trace)
-ei_add_test(cxx11_tensor_volume_patch)
-ei_add_test(cxx11_tensor_symmetry)
-if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8" AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  # This test requires __uint128_t which is only available on 64bit systems
-  ei_add_test(cxx11_tensor_uint128)
-endif()
-
-find_package(CUDA 9.0)
-if(CUDA_FOUND AND EIGEN_TEST_CUDA)
-  # Make sure to compile without the -pedantic, -Wundef, -Wnon-virtual-dtor
-  # and -fno-check-new flags since they trigger thousands of compilation warnings
-  # in the CUDA runtime
-  string(REPLACE "-pedantic" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "-Wundef" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "-Wnon-virtual-dtor" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "-fno-check-new" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-  if(EIGEN_TEST_CUDA_CLANG)
-    string(APPEND CMAKE_CXX_FLAGS " --cuda-path=${CUDA_TOOLKIT_ROOT_DIR}")
-    foreach(ARCH IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
-        string(APPEND CMAKE_CXX_FLAGS " --cuda-gpu-arch=sm_${ARCH}")
-    endforeach()
-    string(APPEND CMAKE_CXX_FLAGS " ${EIGEN_CUDA_CXX_FLAGS}")
-  else()
-    set(CUDA_PROPAGATE_HOST_FLAGS OFF)
-    set(NVCC_ARCH_FLAGS)
-    # Define an -arch=sm_<arch>, otherwise if GPU does not exactly match one of
-    # those in the arch list for -gencode, the kernels will fail to run with
-    #    cudaErrorNoKernelImageForDevice
-    # This can happen with newer cards (e.g. sm_75) and compiling with older
-    # versions of nvcc (e.g. 9.2) that do not support their specific arch.
-    list(LENGTH EIGEN_CUDA_COMPUTE_ARCH EIGEN_CUDA_COMPUTE_ARCH_SIZE)
-    if(EIGEN_CUDA_COMPUTE_ARCH_SIZE)
-      list(GET EIGEN_CUDA_COMPUTE_ARCH 0 EIGEN_CUDA_COMPUTE_DEFAULT)
-      set(NVCC_ARCH_FLAGS " -arch=sm_${EIGEN_CUDA_COMPUTE_DEFAULT}")
-    endif()
-    foreach(ARCH IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
-      string(APPEND NVCC_ARCH_FLAGS " -gencode arch=compute_${ARCH},code=sm_${ARCH}")
-    endforeach()
-    set(CUDA_NVCC_FLAGS  "--expt-relaxed-constexpr -Xcudafe \"--display_error_number\" ${NVCC_ARCH_FLAGS} ${CUDA_NVCC_FLAGS} ${EIGEN_CUDA_CXX_FLAGS}")
-    cuda_include_directories("${CMAKE_CURRENT_BINARY_DIR}" "${CUDA_TOOLKIT_ROOT_DIR}/include")
-  endif()
-  
-  set(EIGEN_ADD_TEST_FILENAME_EXTENSION "cu")
-
-  ei_add_test(cxx11_tensor_complex_gpu)
-  ei_add_test(cxx11_tensor_complex_cwise_ops_gpu)
-  ei_add_test(cxx11_tensor_reduction_gpu)
-  ei_add_test(cxx11_tensor_argmax_gpu)
-  ei_add_test(cxx11_tensor_cast_float16_gpu)
-  ei_add_test(cxx11_tensor_scan_gpu)
-
-  set(EIGEN_CUDA_OLDEST_COMPUTE_ARCH 9999)
-  foreach(ARCH IN LISTS EIGEN_CUDA_COMPUTE_ARCH)
-    if(${ARCH} LESS ${EIGEN_CUDA_OLDEST_COMPUTE_ARCH})
-      set(EIGEN_CUDA_OLDEST_COMPUTE_ARCH ${ARCH})
-    endif()
-  endforeach()
-
-  # Contractions require arch 3.0 or higher
-  if (${EIGEN_CUDA_OLDEST_COMPUTE_ARCH} GREATER 29)
-    ei_add_test(cxx11_tensor_device)
-    ei_add_test(cxx11_tensor_gpu)
-    ei_add_test(cxx11_tensor_contract_gpu)
-    ei_add_test(cxx11_tensor_of_float16_gpu)
-  endif()
-
-  # The random number generation code requires arch 3.5 or greater.
-  if (${EIGEN_CUDA_OLDEST_COMPUTE_ARCH} GREATER 34)
-    ei_add_test(cxx11_tensor_random_gpu)
-  endif()
-
-  unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
-endif()
-
-# Add HIP specific tests
-if (EIGEN_TEST_HIP)
-
-  set(ROCM_PATH "/opt/rocm" CACHE STRING "Path to the ROCm installation.")
-
-  if (EXISTS ${ROCM_PATH}/hip)
-    set(HIP_PATH ${ROCM_PATH}/hip)
-    list(APPEND CMAKE_MODULE_PATH ${HIP_PATH}/cmake)
-  elseif (EXISTS ${ROCM_PATH}/lib/cmake/hip)
-    set(HIP_PATH ${ROCM_PATH})
-    list(APPEND CMAKE_MODULE_PATH ${HIP_PATH}/lib/cmake/hip)
-  else ()
-    message(FATAL_ERROR "EIGEN_TEST_HIP is ON, but could not find the ROCm installation under ${ROCM_PATH}")
-  endif()
-
-  find_package(HIP REQUIRED)
-  if (HIP_FOUND)
-    execute_process(COMMAND ${HIP_PATH}/bin/hipconfig --platform OUTPUT_VARIABLE HIP_PLATFORM)
-
-    if ((${HIP_PLATFORM} STREQUAL "hcc") OR (${HIP_PLATFORM} STREQUAL "amd"))
-      include_directories(${CMAKE_CURRENT_BINARY_DIR})
-      include_directories(${HIP_PATH}/include)
-
-      set(EIGEN_ADD_TEST_FILENAME_EXTENSION  "cu")
-      #
-      # complex datatype is not yet supported by HIP
-      # so leaving out those tests for now
-      #
-      # ei_add_test(cxx11_tensor_complex_gpu)
-      # ei_add_test(cxx11_tensor_complex_cwise_ops_gpu)
-      #
-      ei_add_test(cxx11_tensor_reduction_gpu)
-      ei_add_test(cxx11_tensor_argmax_gpu)
-      ei_add_test(cxx11_tensor_cast_float16_gpu)
-      ei_add_test(cxx11_tensor_scan_gpu)
-      ei_add_test(cxx11_tensor_device)
-
-      ei_add_test(cxx11_tensor_gpu)
-      ei_add_test(cxx11_tensor_contract_gpu)
-      ei_add_test(cxx11_tensor_of_float16_gpu)
-      ei_add_test(cxx11_tensor_of_bfloat16_gpu)
-      ei_add_test(cxx11_tensor_random_gpu)
-
-      unset(EIGEN_ADD_TEST_FILENAME_EXTENSION)
-
-    elseif ((${HIP_PLATFORM} STREQUAL "nvcc") OR (${HIP_PLATFORM} STREQUAL "nvidia"))
-      message(FATAL_ERROR "HIP_PLATFORM = nvcc is not supported within Eigen")
-    else ()
-      message(FATAL_ERROR "Unknown HIP_PLATFORM = ${HIP_PLATFORM}")
-    endif()
-  endif()
-endif()
diff --git a/unsupported/test/EulerAngles.cpp b/unsupported/test/EulerAngles.cpp
deleted file mode 100644
index a65e5f5..0000000
--- a/unsupported/test/EulerAngles.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Tal Hadad <tal_hd@hotmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-EIGEN_DISABLE_DEPRECATED_WARNING
-
-#include <unsupported/Eigen/EulerAngles>
-
-using namespace Eigen;
-
-// Unfortunately, we need to specialize it in order to work. (We could add it in main.h test framework)
-template <typename Scalar, class System>
-bool verifyIsApprox(const Eigen::EulerAngles<Scalar, System>& a, const Eigen::EulerAngles<Scalar, System>& b) {
-  return verifyIsApprox(a.angles(), b.angles());
-}
-
-// Verify that x is in the approxed range [a, b]
-#define VERIFY_APPROXED_RANGE(a, x, b)   \
-  do {                                   \
-    VERIFY_IS_APPROX_OR_LESS_THAN(a, x); \
-    VERIFY_IS_APPROX_OR_LESS_THAN(x, b); \
-  } while (0)
-
-const char X = EULER_X;
-const char Y = EULER_Y;
-const char Z = EULER_Z;
-
-template <typename Scalar, class EulerSystem>
-void verify_euler(const EulerAngles<Scalar, EulerSystem>& e) {
-  typedef EulerAngles<Scalar, EulerSystem> EulerAnglesType;
-  typedef Matrix<Scalar, 3, 3> Matrix3;
-  typedef Matrix<Scalar, 3, 1> Vector3;
-  typedef Quaternion<Scalar> QuaternionType;
-  typedef AngleAxis<Scalar> AngleAxisType;
-
-  const Scalar ONE = Scalar(1);
-  const Scalar HALF_PI = Scalar(EIGEN_PI / 2);
-  const Scalar PI = Scalar(EIGEN_PI);
-
-  // It's very important calc the acceptable precision depending on the distance from the pole.
-  const Scalar longitudeRadius = std::abs(EulerSystem::IsTaitBryan ? std::cos(e.beta()) : std::sin(e.beta()));
-  Scalar precision = test_precision<Scalar>() / longitudeRadius;
-
-  Scalar betaRangeStart, betaRangeEnd;
-  if (EulerSystem::IsTaitBryan) {
-    betaRangeStart = -HALF_PI;
-    betaRangeEnd = HALF_PI;
-  } else {
-    if (!EulerSystem::IsBetaOpposite) {
-      betaRangeStart = 0;
-      betaRangeEnd = PI;
-    } else {
-      betaRangeStart = -PI;
-      betaRangeEnd = 0;
-    }
-  }
-
-  const Vector3 I_ = EulerAnglesType::AlphaAxisVector();
-  const Vector3 J_ = EulerAnglesType::BetaAxisVector();
-  const Vector3 K_ = EulerAnglesType::GammaAxisVector();
-
-  // Is approx checks
-  VERIFY(e.isApprox(e));
-  VERIFY_IS_APPROX(e, e);
-  VERIFY_IS_NOT_APPROX(e, EulerAnglesType(e.alpha() + ONE, e.beta() + ONE, e.gamma() + ONE));
-
-  const Matrix3 m(e);
-  VERIFY_IS_APPROX(Scalar(m.determinant()), ONE);
-
-  EulerAnglesType ebis(m);
-
-  // When no roll(acting like polar representation), we have the best precision.
-  // One of those cases is when the Euler angles are on the pole, and because it's singular case,
-  //  the computation returns no roll.
-  if (ebis.beta() == 0) precision = test_precision<Scalar>();
-
-  // Check that eabis in range
-  VERIFY_APPROXED_RANGE(-PI, ebis.alpha(), PI);
-  VERIFY_APPROXED_RANGE(betaRangeStart, ebis.beta(), betaRangeEnd);
-  VERIFY_APPROXED_RANGE(-PI, ebis.gamma(), PI);
-
-  const Matrix3 mbis(AngleAxisType(ebis.alpha(), I_) * AngleAxisType(ebis.beta(), J_) *
-                     AngleAxisType(ebis.gamma(), K_));
-  VERIFY_IS_APPROX(Scalar(mbis.determinant()), ONE);
-  VERIFY_IS_APPROX(mbis, ebis.toRotationMatrix());
-  /*std::cout << "===================\n" <<
-    "e: " << e << std::endl <<
-    "eabis: " << eabis.transpose() << std::endl <<
-    "m: " << m << std::endl <<
-    "mbis: " << mbis << std::endl <<
-    "X: " << (m * Vector3::UnitX()).transpose() << std::endl <<
-    "X: " << (mbis * Vector3::UnitX()).transpose() << std::endl;*/
-  VERIFY(m.isApprox(mbis, precision));
-
-  // Test if ea and eabis are the same
-  // Need to check both singular and non-singular cases
-  // There are two singular cases.
-  // 1. When I==K and sin(ea(1)) == 0
-  // 2. When I!=K and cos(ea(1)) == 0
-
-  // TODO: Make this test work well, and use range saturation function.
-  /*// If I==K, and ea[1]==0, then there no unique solution.
-  // The remark apply in the case where I!=K, and |ea[1]| is close to +-pi/2.
-  if( (i!=k || ea[1]!=0) && (i==k || !internal::isApprox(abs(ea[1]),Scalar(EIGEN_PI/2),test_precision<Scalar>())) )
-      VERIFY_IS_APPROX(ea, eabis);*/
-
-  // Quaternions
-  const QuaternionType q(e);
-  ebis = q;
-  const QuaternionType qbis(ebis);
-  VERIFY(internal::isApprox<Scalar>(std::abs(q.dot(qbis)), ONE, precision));
-  // VERIFY_IS_APPROX(eabis, eabis2);// Verify that the euler angles are still the same
-
-  // A suggestion for simple product test when will be supported.
-  /*EulerAnglesType e2(PI/2, PI/2, PI/2);
-  Matrix3 m2(e2);
-  VERIFY_IS_APPROX(e*e2, m*m2);*/
-}
-
-template <signed char A, signed char B, signed char C, typename Scalar>
-void verify_euler_vec(const Matrix<Scalar, 3, 1>& ea) {
-  verify_euler(EulerAngles<Scalar, EulerSystem<A, B, C> >(ea[0], ea[1], ea[2]));
-}
-
-template <signed char A, signed char B, signed char C, typename Scalar>
-void verify_euler_all_neg(const Matrix<Scalar, 3, 1>& ea) {
-  verify_euler_vec<+A, +B, +C>(ea);
-  verify_euler_vec<+A, +B, -C>(ea);
-  verify_euler_vec<+A, -B, +C>(ea);
-  verify_euler_vec<+A, -B, -C>(ea);
-
-  verify_euler_vec<-A, +B, +C>(ea);
-  verify_euler_vec<-A, +B, -C>(ea);
-  verify_euler_vec<-A, -B, +C>(ea);
-  verify_euler_vec<-A, -B, -C>(ea);
-}
-
-template <typename Scalar>
-void check_all_var(const Matrix<Scalar, 3, 1>& ea) {
-  verify_euler_all_neg<X, Y, Z>(ea);
-  verify_euler_all_neg<X, Y, X>(ea);
-  verify_euler_all_neg<X, Z, Y>(ea);
-  verify_euler_all_neg<X, Z, X>(ea);
-
-  verify_euler_all_neg<Y, Z, X>(ea);
-  verify_euler_all_neg<Y, Z, Y>(ea);
-  verify_euler_all_neg<Y, X, Z>(ea);
-  verify_euler_all_neg<Y, X, Y>(ea);
-
-  verify_euler_all_neg<Z, X, Y>(ea);
-  verify_euler_all_neg<Z, X, Z>(ea);
-  verify_euler_all_neg<Z, Y, X>(ea);
-  verify_euler_all_neg<Z, Y, Z>(ea);
-}
-
-template <typename Scalar>
-void check_singular_cases(const Scalar& singularBeta) {
-  typedef Matrix<Scalar, 3, 1> Vector3;
-  const Scalar PI = Scalar(EIGEN_PI);
-
-  for (Scalar epsilon = NumTraits<Scalar>::epsilon(); epsilon < 1; epsilon *= Scalar(1.2)) {
-    check_all_var(Vector3(PI / 4, singularBeta, PI / 3));
-    check_all_var(Vector3(PI / 4, singularBeta - epsilon, PI / 3));
-    check_all_var(Vector3(PI / 4, singularBeta - Scalar(1.5) * epsilon, PI / 3));
-    check_all_var(Vector3(PI / 4, singularBeta - 2 * epsilon, PI / 3));
-    check_all_var(Vector3(PI * Scalar(0.8), singularBeta - epsilon, Scalar(0.9) * PI));
-    check_all_var(Vector3(PI * Scalar(-0.9), singularBeta + epsilon, PI * Scalar(0.3)));
-    check_all_var(Vector3(PI * Scalar(-0.6), singularBeta + Scalar(1.5) * epsilon, PI * Scalar(0.3)));
-    check_all_var(Vector3(PI * Scalar(-0.5), singularBeta + 2 * epsilon, PI * Scalar(0.4)));
-    check_all_var(Vector3(PI * Scalar(0.9), singularBeta + epsilon, Scalar(0.8) * PI));
-  }
-
-  // This one for sanity, it had a problem with near pole cases in float scalar.
-  check_all_var(Vector3(PI * Scalar(0.8), singularBeta - Scalar(1E-6), Scalar(0.9) * PI));
-}
-
-template <typename Scalar>
-void eulerangles_manual() {
-  typedef Matrix<Scalar, 3, 1> Vector3;
-  typedef Matrix<Scalar, Dynamic, 1> VectorX;
-  const Vector3 Zero = Vector3::Zero();
-  const Scalar PI = Scalar(EIGEN_PI);
-
-  check_all_var(Zero);
-
-  // singular cases
-  check_singular_cases(PI / 2);
-  check_singular_cases(-PI / 2);
-
-  check_singular_cases(Scalar(0));
-  check_singular_cases(Scalar(-0));
-
-  check_singular_cases(PI);
-  check_singular_cases(-PI);
-
-  // non-singular cases
-  VectorX alpha = VectorX::LinSpaced(20, Scalar(-0.99) * PI, PI);
-  VectorX beta = VectorX::LinSpaced(20, Scalar(-0.49) * PI, Scalar(0.49) * PI);
-  VectorX gamma = VectorX::LinSpaced(20, Scalar(-0.99) * PI, PI);
-  for (int i = 0; i < alpha.size(); ++i) {
-    for (int j = 0; j < beta.size(); ++j) {
-      for (int k = 0; k < gamma.size(); ++k) {
-        check_all_var(Vector3(alpha(i), beta(j), gamma(k)));
-      }
-    }
-  }
-}
-
-template <typename Scalar>
-void eulerangles_rand() {
-  typedef Matrix<Scalar, 3, 3> Matrix3;
-  typedef Matrix<Scalar, 3, 1> Vector3;
-  typedef Array<Scalar, 3, 1> Array3;
-  typedef Quaternion<Scalar> Quaternionx;
-  typedef AngleAxis<Scalar> AngleAxisType;
-
-  Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
-  Quaternionx q1;
-  q1 = AngleAxisType(a, Vector3::Random().normalized());
-  Matrix3 m;
-  m = q1;
-
-  Vector3 ea = m.eulerAngles(0, 1, 2);
-  check_all_var(ea);
-  ea = m.eulerAngles(0, 1, 0);
-  check_all_var(ea);
-
-  // Check with purely random Quaternion:
-  q1.coeffs() = Quaternionx::Coefficients::Random().normalized();
-  m = q1;
-  ea = m.eulerAngles(0, 1, 2);
-  check_all_var(ea);
-  ea = m.eulerAngles(0, 1, 0);
-  check_all_var(ea);
-
-  // Check with random angles in range [0:pi]x[-pi:pi]x[-pi:pi].
-  ea = (Array3::Random() + Array3(1, 0, 0)) * Scalar(EIGEN_PI) * Array3(0.5, 1, 1);
-  check_all_var(ea);
-
-  ea[2] = ea[0] = internal::random<Scalar>(0, Scalar(EIGEN_PI));
-  check_all_var(ea);
-
-  ea[0] = ea[1] = internal::random<Scalar>(0, Scalar(EIGEN_PI));
-  check_all_var(ea);
-
-  ea[1] = 0;
-  check_all_var(ea);
-
-  ea.head(2).setZero();
-  check_all_var(ea);
-
-  ea.setZero();
-  check_all_var(ea);
-}
-
-EIGEN_DECLARE_TEST(EulerAngles) {
-  // Simple cast test
-  EulerAnglesXYZd onesEd(1, 1, 1);
-  EulerAnglesXYZf onesEf = onesEd.cast<float>();
-  VERIFY_IS_APPROX(onesEd, onesEf.cast<double>());
-
-  // Simple Construction from Vector3 test
-  VERIFY_IS_APPROX(onesEd, EulerAnglesXYZd(Vector3d::Ones()));
-
-  CALL_SUBTEST_1(eulerangles_manual<float>());
-  CALL_SUBTEST_2(eulerangles_manual<double>());
-
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_3(eulerangles_rand<float>());
-    CALL_SUBTEST_4(eulerangles_rand<double>());
-  }
-
-  // TODO: Add tests for auto diff
-  // TODO: Add tests for complex numbers
-}
diff --git a/unsupported/test/FFT.cpp b/unsupported/test/FFT.cpp
deleted file mode 100644
index f85461c..0000000
--- a/unsupported/test/FFT.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define EIGEN_FFT_DEFAULT 1
-#include "fft_test_shared.h"
diff --git a/unsupported/test/FFTW.cpp b/unsupported/test/FFTW.cpp
deleted file mode 100644
index 7302196..0000000
--- a/unsupported/test/FFTW.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define EIGEN_FFTW_DEFAULT 1
-#include "fft_test_shared.h"
diff --git a/unsupported/test/NNLS.cpp b/unsupported/test/NNLS.cpp
deleted file mode 100644
index f01b562..0000000
--- a/unsupported/test/NNLS.cpp
+++ /dev/null
@@ -1,471 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) Essex Edwards <essex.edwards@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_RUNTIME_NO_MALLOC
-
-#include "main.h"
-#include <unsupported/Eigen/NNLS>
-
-/// Check that 'x' solves the NNLS optimization problem `min ||A*x-b|| s.t. 0 <= x`.
-/// The \p tolerance parameter is the absolute tolerance on the gradient, A'*(A*x-b).
-template <typename MatrixType, typename VectorB, typename VectorX, typename Scalar>
-void verify_nnls_optimality(const MatrixType &A, const VectorB &b, const VectorX &x, const Scalar tolerance) {
-  // The NNLS optimality conditions are:
-  //
-  // * 0 = A'*A*x - A'*b - lambda
-  // * 0 <= x[i] \forall i
-  // * 0 <= lambda[i] \forall i
-  // * 0 = x[i]*lambda[i] \forall i
-  //
-  // we don't know lambda, but by assuming the first optimality condition is true,
-  // we can derive it and then check the others conditions.
-  const VectorX lambda = A.transpose() * (A * x - b);
-
-  // NNLS solutions are EXACTLY not negative.
-  VERIFY_LE(0, x.minCoeff());
-
-  // Exact lambda would be non-negative, but computed lambda might leak a little
-  VERIFY_LE(-tolerance, lambda.minCoeff());
-
-  // x[i]*lambda[i] == 0 <~~> (x[i]==0) || (lambda[i] is small)
-  VERIFY(((x.array() == Scalar(0)) || (lambda.array() <= tolerance)).all());
-}
-
-template <typename MatrixType, typename VectorB, typename VectorX>
-void test_nnls_known_solution(const MatrixType &A, const VectorB &b, const VectorX &x_expected) {
-  using Scalar = typename MatrixType::Scalar;
-
-  using std::sqrt;
-  const Scalar tolerance = sqrt(Eigen::GenericNumTraits<Scalar>::epsilon());
-  Index max_iter = 5 * A.cols();  // A heuristic guess.
-  NNLS<MatrixType> nnls(A, max_iter, tolerance);
-  const VectorX x = nnls.solve(b);
-
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  VERIFY_IS_APPROX(x, x_expected);
-  verify_nnls_optimality(A, b, x, tolerance);
-}
-
-template <typename MatrixType>
-void test_nnls_random_problem(const MatrixType &) {
-  //
-  // SETUP
-  //
-
-  Index cols = MatrixType::ColsAtCompileTime;
-  if (cols == Dynamic) cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-  Index rows = MatrixType::RowsAtCompileTime;
-  if (rows == Dynamic) rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
-  VERIFY_LE(cols, rows);  // To have a unique LS solution: cols <= rows.
-
-  // Make some sort of random test problem from a wide range of scales and condition numbers.
-  using std::pow;
-  using Scalar = typename MatrixType::Scalar;
-  const Scalar sqrtConditionNumber = pow(Scalar(10), internal::random<Scalar>(Scalar(0), Scalar(2)));
-  const Scalar scaleA = pow(Scalar(10), internal::random<Scalar>(Scalar(-3), Scalar(3)));
-  const Scalar minSingularValue = scaleA / sqrtConditionNumber;
-  const Scalar maxSingularValue = scaleA * sqrtConditionNumber;
-  MatrixType A(rows, cols);
-  generateRandomMatrixSvs(setupRangeSvs<Matrix<Scalar, Dynamic, 1>>(cols, minSingularValue, maxSingularValue), rows,
-                          cols, A);
-
-  // Make a random RHS also with a random scaling.
-  using VectorB = decltype(A.col(0).eval());
-  const Scalar scaleB = pow(Scalar(10), internal::random<Scalar>(Scalar(-3), Scalar(3)));
-  const VectorB b = scaleB * VectorB::Random(A.rows());
-
-  //
-  // ACT
-  //
-
-  using Scalar = typename MatrixType::Scalar;
-  using std::sqrt;
-  const Scalar tolerance =
-      sqrt(Eigen::GenericNumTraits<Scalar>::epsilon()) * b.cwiseAbs().maxCoeff() * A.cwiseAbs().maxCoeff();
-  Index max_iter = 5 * A.cols();  // A heuristic guess.
-  NNLS<MatrixType> nnls(A, max_iter, tolerance);
-  const typename NNLS<MatrixType>::SolutionVectorType &x = nnls.solve(b);
-
-  //
-  // VERIFY
-  //
-
-  // In fact, NNLS can fail on some problems, but they are rare in practice.
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  verify_nnls_optimality(A, b, x, tolerance);
-}
-
-void test_nnls_handles_zero_rhs() {
-  //
-  // SETUP
-  //
-  const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
-  const MatrixXd A = MatrixXd::Random(rows, cols);
-  const VectorXd b = VectorXd::Zero(rows);
-
-  //
-  // ACT
-  //
-  NNLS<MatrixXd> nnls(A);
-  const VectorXd x = nnls.solve(b);
-
-  //
-  // VERIFY
-  //
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  VERIFY_LE(nnls.iterations(), 1);  // 0 or 1 would be be fine for an edge case like this.
-  VERIFY_IS_EQUAL(x, VectorXd::Zero(cols));
-}
-
-void test_nnls_handles_Mx0_matrix() {
-  //
-  // SETUP
-  //
-  const Index rows = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-  const MatrixXd A(rows, 0);
-  const VectorXd b = VectorXd::Random(rows);
-
-  //
-  // ACT
-  //
-  NNLS<MatrixXd> nnls(A);
-  const VectorXd x = nnls.solve(b);
-
-  //
-  // VERIFY
-  //
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  VERIFY_LE(nnls.iterations(), 0);
-  VERIFY_IS_EQUAL(x.size(), 0);
-}
-
-void test_nnls_handles_0x0_matrix() {
-  //
-  // SETUP
-  //
-  const MatrixXd A(0, 0);
-  const VectorXd b(0);
-
-  //
-  // ACT
-  //
-  NNLS<MatrixXd> nnls(A);
-  const VectorXd x = nnls.solve(b);
-
-  //
-  // VERIFY
-  //
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  VERIFY_LE(nnls.iterations(), 0);
-  VERIFY_IS_EQUAL(x.size(), 0);
-}
-
-void test_nnls_handles_dependent_columns() {
-  //
-  // SETUP
-  //
-  const Index rank = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE / 2);
-  const Index cols = 2 * rank;
-  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
-  const MatrixXd A = MatrixXd::Random(rows, rank) * MatrixXd::Random(rank, cols);
-  const VectorXd b = VectorXd::Random(rows);
-
-  //
-  // ACT
-  //
-  const double tolerance = 1e-8;
-  NNLS<MatrixXd> nnls(A);
-  const VectorXd &x = nnls.solve(b);
-
-  //
-  // VERIFY
-  //
-  // What should happen when the input 'A' has dependent columns?
-  // We might still succeed. Or we might not converge.
-  // Either outcome is fine. If Success is indicated,
-  // then 'x' must actually be a solution vector.
-
-  if (nnls.info() == ComputationInfo::Success) {
-    verify_nnls_optimality(A, b, x, tolerance);
-  }
-}
-
-void test_nnls_handles_wide_matrix() {
-  //
-  // SETUP
-  //
-  const Index cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
-  const Index rows = internal::random<Index>(2, cols - 1);
-  const MatrixXd A = MatrixXd::Random(rows, cols);
-  const VectorXd b = VectorXd::Random(rows);
-
-  //
-  // ACT
-  //
-  const double tolerance = 1e-8;
-  NNLS<MatrixXd> nnls(A);
-  const VectorXd &x = nnls.solve(b);
-
-  //
-  // VERIFY
-  //
-  // What should happen when the input 'A' is wide?
-  // The unconstrained least-squares problem has infinitely many solutions.
-  // Subject the the non-negativity constraints,
-  // the solution might actually be unique (e.g. it is [0,0,..,0]).
-  // So, NNLS might succeed or it might fail.
-  // Either outcome is fine. If Success is indicated,
-  // then 'x' must actually be a solution vector.
-
-  if (nnls.info() == ComputationInfo::Success) {
-    verify_nnls_optimality(A, b, x, tolerance);
-  }
-}
-
-// 4x2 problem, unconstrained solution positive
-void test_nnls_known_1() {
-  Matrix<double, 4, 2> A(4, 2);
-  Matrix<double, 4, 1> b(4);
-  Matrix<double, 2, 1> x(2);
-  A << 1, 1, 2, 4, 3, 9, 4, 16;
-  b << 0.6, 2.2, 4.8, 8.4;
-  x << 0.1, 0.5;
-
-  return test_nnls_known_solution(A, b, x);
-}
-
-// 4x3 problem, unconstrained solution positive
-void test_nnls_known_2() {
-  Matrix<double, 4, 3> A(4, 3);
-  Matrix<double, 4, 1> b(4);
-  Matrix<double, 3, 1> x(3);
-
-  A << 1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64;
-  b << 0.73, 3.24, 8.31, 16.72;
-  x << 0.1, 0.5, 0.13;
-
-  test_nnls_known_solution(A, b, x);
-}
-
-// Simple 4x4 problem, unconstrained solution non-negative
-void test_nnls_known_3() {
-  Matrix<double, 4, 4> A(4, 4);
-  Matrix<double, 4, 1> b(4);
-  Matrix<double, 4, 1> x(4);
-
-  A << 1, 1, 1, 1, 2, 4, 8, 16, 3, 9, 27, 81, 4, 16, 64, 256;
-  b << 0.73, 3.24, 8.31, 16.72;
-  x << 0.1, 0.5, 0.13, 0;
-
-  test_nnls_known_solution(A, b, x);
-}
-
-// Simple 4x3 problem, unconstrained solution non-negative
-void test_nnls_known_4() {
-  Matrix<double, 4, 3> A(4, 3);
-  Matrix<double, 4, 1> b(4);
-  Matrix<double, 3, 1> x(3);
-
-  A << 1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64;
-  b << 0.23, 1.24, 3.81, 8.72;
-  x << 0.1, 0, 0.13;
-
-  test_nnls_known_solution(A, b, x);
-}
-
-// Simple 4x3 problem, unconstrained solution indefinite
-void test_nnls_known_5() {
-  Matrix<double, 4, 3> A(4, 3);
-  Matrix<double, 4, 1> b(4);
-  Matrix<double, 3, 1> x(3);
-
-  A << 1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64;
-  b << 0.13, 0.84, 2.91, 7.12;
-  // Solution obtained by original nnls() implementation in Fortran
-  x << 0.0, 0.0, 0.1106544;
-
-  test_nnls_known_solution(A, b, x);
-}
-
-void test_nnls_small_reference_problems() {
-  test_nnls_known_1();
-  test_nnls_known_2();
-  test_nnls_known_3();
-  test_nnls_known_4();
-  test_nnls_known_5();
-}
-
-void test_nnls_with_half_precision() {
-  // The random matrix generation tools don't work with `half`,
-  // so here's a simpler setup mostly just to check that NNLS compiles & runs with custom scalar types.
-
-  using Mat = Matrix<half, 8, 2>;
-  using VecB = Matrix<half, 8, 1>;
-  using VecX = Matrix<half, 2, 1>;
-  Mat A = Mat::Random();  // full-column rank with high probability.
-  VecB b = VecB::Random();
-
-  NNLS<Mat> nnls(A, 20, half(1e-2f));
-  const VecX x = nnls.solve(b);
-
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  verify_nnls_optimality(A, b, x, half(1e-1));
-}
-
-void test_nnls_special_case_solves_in_zero_iterations() {
-  // The particular NNLS algorithm that is implemented starts with all variables
-  // in the active set.
-  // This test builds a system where all constraints are active at the solution,
-  // so that initial guess is already correct.
-  //
-  // If the implementation changes to another algorithm that does not have this property,
-  // then this test will need to change (e.g. starting from all constraints inactive,
-  // or using ADMM, or an interior point solver).
-
-  const Index n = 10;
-  const Index m = 3 * n;
-  const VectorXd b = VectorXd::Random(m);
-  // With high probability, this is full column rank, which we need for uniqueness.
-  MatrixXd A = MatrixXd::Random(m, n);
-  // Make every column of `A` such that adding it to the active set only /increases/ the objective,
-  // this ensuring the NNLS solution is all zeros.
-  const VectorXd alignment = -(A.transpose() * b).cwiseSign();
-  A = A * alignment.asDiagonal();
-
-  NNLS<MatrixXd> nnls(A);
-  nnls.solve(b);
-
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  VERIFY(nnls.iterations() == 0);
-}
-
-void test_nnls_special_case_solves_in_n_iterations() {
-  // The particular NNLS algorithm that is implemented starts with all variables
-  // in the active set and then adds one variable to the inactive set each iteration.
-  // This test builds a system where all variables are inactive at the solution,
-  // so it should take 'n' iterations to get there.
-  //
-  // If the implementation changes to another algorithm that does not have this property,
-  // then this test will need to change (e.g. starting from all constraints inactive,
-  // or using ADMM, or an interior point solver).
-
-  const Index n = 10;
-  const Index m = 3 * n;
-  // With high probability, this is full column rank, which we need for uniqueness.
-  const MatrixXd A = MatrixXd::Random(m, n);
-  const VectorXd x = VectorXd::Random(n).cwiseAbs().array() + 1;  // all positive.
-  const VectorXd b = A * x;
-
-  NNLS<MatrixXd> nnls(A);
-  nnls.solve(b);
-
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-  VERIFY(nnls.iterations() == n);
-}
-
-void test_nnls_returns_NoConvergence_when_maxIterations_is_too_low() {
-  // Using the special case that takes `n` iterations,
-  // from `test_nnls_special_case_solves_in_n_iterations`,
-  // we can set max iterations too low and that should cause the solve to fail.
-
-  const Index n = 10;
-  const Index m = 3 * n;
-  // With high probability, this is full column rank, which we need for uniqueness.
-  const MatrixXd A = MatrixXd::Random(m, n);
-  const VectorXd x = VectorXd::Random(n).cwiseAbs().array() + 1;  // all positive.
-  const VectorXd b = A * x;
-
-  NNLS<MatrixXd> nnls(A);
-  const Index max_iters = n - 1;
-  nnls.setMaxIterations(max_iters);
-  nnls.solve(b);
-
-  VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::NoConvergence);
-  VERIFY(nnls.iterations() == max_iters);
-}
-
-void test_nnls_default_maxIterations_is_twice_column_count() {
-  const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
-  const MatrixXd A = MatrixXd::Random(rows, cols);
-
-  NNLS<MatrixXd> nnls(A);
-
-  VERIFY_IS_EQUAL(nnls.maxIterations(), 2 * cols);
-}
-
-void test_nnls_does_not_allocate_during_solve() {
-  const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-  const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
-  const MatrixXd A = MatrixXd::Random(rows, cols);
-  const VectorXd b = VectorXd::Random(rows);
-
-  NNLS<MatrixXd> nnls(A);
-
-  internal::set_is_malloc_allowed(false);
-  nnls.solve(b);
-  internal::set_is_malloc_allowed(true);
-}
-
-void test_nnls_repeated_calls_to_compute_and_solve() {
-  const Index cols2 = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-  const Index rows2 = internal::random<Index>(cols2, EIGEN_TEST_MAX_SIZE);
-  const MatrixXd A2 = MatrixXd::Random(rows2, cols2);
-  const VectorXd b2 = VectorXd::Random(rows2);
-
-  NNLS<MatrixXd> nnls;
-
-  for (int i = 0; i < 4; ++i) {
-    const Index cols = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
-    const Index rows = internal::random<Index>(cols, EIGEN_TEST_MAX_SIZE);
-    const MatrixXd A = MatrixXd::Random(rows, cols);
-
-    nnls.compute(A);
-    VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-
-    for (int j = 0; j < 3; ++j) {
-      const VectorXd b = VectorXd::Random(rows);
-      const VectorXd x = nnls.solve(b);
-      VERIFY_IS_EQUAL(nnls.info(), ComputationInfo::Success);
-      verify_nnls_optimality(A, b, x, 1e-4);
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(NNLS) {
-  // Small matrices with known solutions:
-  CALL_SUBTEST_1(test_nnls_small_reference_problems());
-  CALL_SUBTEST_1(test_nnls_handles_Mx0_matrix());
-  CALL_SUBTEST_1(test_nnls_handles_0x0_matrix());
-
-  for (int i = 0; i < g_repeat; i++) {
-    // Essential NNLS properties, across different types.
-    CALL_SUBTEST_2(test_nnls_random_problem(MatrixXf()));
-    CALL_SUBTEST_3(test_nnls_random_problem(MatrixXd()));
-    CALL_SUBTEST_4(test_nnls_random_problem(Matrix<double, 12, 5>()));
-    CALL_SUBTEST_5(test_nnls_with_half_precision());
-
-    // Robustness tests:
-    CALL_SUBTEST_6(test_nnls_handles_zero_rhs());
-    CALL_SUBTEST_6(test_nnls_handles_dependent_columns());
-    CALL_SUBTEST_6(test_nnls_handles_wide_matrix());
-
-    // Properties specific to the implementation,
-    // not NNLS in general.
-    CALL_SUBTEST_7(test_nnls_special_case_solves_in_zero_iterations());
-    CALL_SUBTEST_7(test_nnls_special_case_solves_in_n_iterations());
-    CALL_SUBTEST_7(test_nnls_returns_NoConvergence_when_maxIterations_is_too_low());
-    CALL_SUBTEST_7(test_nnls_default_maxIterations_is_twice_column_count());
-    CALL_SUBTEST_8(test_nnls_repeated_calls_to_compute_and_solve());
-
-    // This test fails. It hits allocations in HouseholderSequence.h
-    // test_nnls_does_not_allocate_during_solve();
-  }
-}
diff --git a/unsupported/test/NonLinearOptimization.cpp b/unsupported/test/NonLinearOptimization.cpp
deleted file mode 100644
index 78990d7..0000000
--- a/unsupported/test/NonLinearOptimization.cpp
+++ /dev/null
@@ -1,1879 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-
-#include <stdio.h>
-
-#include "main.h"
-#include <unsupported/Eigen/NonLinearOptimization>
-
-// This disables some useless Warnings on MSVC.
-// It is intended to be done for this test only.
-#include <Eigen/src/Core/util/DisableStupidWarnings.h>
-
-// tolerance for checking number of iterations
-#define LM_EVAL_COUNT_TOL 2
-
-#define LM_CHECK_N_ITERS(SOLVER, NFEV, NJEV)         \
-  {                                                  \
-    VERIFY(SOLVER.nfev <= NFEV * LM_EVAL_COUNT_TOL); \
-    VERIFY(SOLVER.njev <= NJEV * LM_EVAL_COUNT_TOL); \
-  }
-
-int fcn_chkder(const VectorXd &x, VectorXd &fvec, MatrixXd &fjac, int iflag) {
-  /*      subroutine fcn for chkder example. */
-
-  int i;
-  assert(15 == fvec.size());
-  assert(3 == x.size());
-  double tmp1, tmp2, tmp3, tmp4;
-  static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                               3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
-
-  if (iflag == 0) return 0;
-
-  if (iflag != 2)
-    for (i = 0; i < 15; i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = tmp1;
-      if (i >= 8) tmp3 = tmp2;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-  else {
-    for (i = 0; i < 15; i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-
-      /* error introduced into next statement for illustration. */
-      /* corrected statement should read    tmp3 = tmp1 . */
-
-      tmp3 = tmp2;
-      if (i >= 8) tmp3 = tmp2;
-      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
-      tmp4 = tmp4 * tmp4;
-      fjac(i, 0) = -1.;
-      fjac(i, 1) = tmp1 * tmp2 / tmp4;
-      fjac(i, 2) = tmp1 * tmp3 / tmp4;
-    }
-  }
-  return 0;
-}
-
-void testChkder() {
-  const int m = 15, n = 3;
-  VectorXd x(n), fvec(m), xp, fvecp(m), err;
-  MatrixXd fjac(m, n);
-  VectorXi ipvt;
-
-  /*      the following values should be suitable for */
-  /*      checking the jacobian matrix. */
-  x << 9.2e-1, 1.3e-1, 5.4e-1;
-
-  internal::chkder(x, fvec, fjac, xp, fvecp, 1, err);
-  fcn_chkder(x, fvec, fjac, 1);
-  fcn_chkder(x, fvec, fjac, 2);
-  fcn_chkder(xp, fvecp, fjac, 1);
-  internal::chkder(x, fvec, fjac, xp, fvecp, 2, err);
-
-  fvecp -= fvec;
-
-  // check those
-  VectorXd fvec_ref(m), fvecp_ref(m), err_ref(m);
-  fvec_ref << -1.181606, -1.429655, -1.606344, -1.745269, -1.840654, -1.921586, -1.984141, -2.022537, -2.468977,
-      -2.827562, -3.473582, -4.437612, -6.047662, -9.267761, -18.91806;
-  fvecp_ref << -7.724666e-09, -3.432406e-09, -2.034843e-10, 2.313685e-09, 4.331078e-09, 5.984096e-09, 7.363281e-09,
-      8.53147e-09, 1.488591e-08, 2.33585e-08, 3.522012e-08, 5.301255e-08, 8.26666e-08, 1.419747e-07, 3.19899e-07;
-  err_ref << 0.1141397, 0.09943516, 0.09674474, 0.09980447, 0.1073116, 0.1220445, 0.1526814, 1, 1, 1, 1, 1, 1, 1, 1;
-
-  VERIFY_IS_APPROX(fvec, fvec_ref);
-  VERIFY_IS_APPROX(fvecp, fvecp_ref);
-  VERIFY_IS_APPROX(err, err_ref);
-}
-
-// Generic functor
-template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
-struct Functor {
-  typedef Scalar_ Scalar;
-  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-
-  const int m_inputs, m_values;
-
-  Functor() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
-  Functor(int inputs, int values) : m_inputs(inputs), m_values(values) {}
-
-  int inputs() const { return m_inputs; }
-  int values() const { return m_values; }
-
-  // you should define that in the subclass :
-  //  void operator() (const InputType& x, ValueType* v, JacobianType* _j=0) const;
-};
-
-struct lmder_functor : Functor<double> {
-  lmder_functor(void) : Functor<double>(3, 15) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) const {
-    double tmp1, tmp2, tmp3;
-    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
-
-    for (int i = 0; i < values(); i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-    return 0;
-  }
-
-  int df(const VectorXd &x, MatrixXd &fjac) const {
-    double tmp1, tmp2, tmp3, tmp4;
-    for (int i = 0; i < values(); i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
-      tmp4 = tmp4 * tmp4;
-      fjac(i, 0) = -1;
-      fjac(i, 1) = tmp1 * tmp2 / tmp4;
-      fjac(i, 2) = tmp1 * tmp3 / tmp4;
-    }
-    return 0;
-  }
-};
-
-void testLmder1() {
-  int n = 3, info;
-
-  VectorXd x;
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmder_functor functor;
-  LevenbergMarquardt<lmder_functor> lm(functor);
-  info = lm.lmder1(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 6, 5);
-
-  // check norm
-  VERIFY_IS_APPROX(lm.fvec.blueNorm(), 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testLmder() {
-  const int m = 15, n = 3;
-  int info;
-  double fnorm, covfac;
-  VectorXd x;
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmder_functor functor;
-  LevenbergMarquardt<lmder_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return values
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 6, 5);
-
-  // check norm
-  fnorm = lm.fvec.blueNorm();
-  VERIFY_IS_APPROX(fnorm, 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-
-  // check covariance
-  covfac = fnorm * fnorm / (m - n);
-  internal::covar(lm.fjac, lm.permutation.indices());  // TODO : move this as a function of lm
-
-  MatrixXd cov_ref(n, n);
-  cov_ref << 0.0001531202, 0.002869941, -0.002656662, 0.002869941, 0.09480935, -0.09098995, -0.002656662, -0.09098995,
-      0.08778727;
-
-  //  std::cout << fjac*covfac << std::endl;
-
-  MatrixXd cov;
-  cov = covfac * lm.fjac.topLeftCorner<n, n>();
-  VERIFY_IS_APPROX(cov, cov_ref);
-  // TODO: why isn't this allowed ? :
-  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
-}
-
-struct hybrj_functor : Functor<double> {
-  hybrj_functor(void) : Functor<double>(9, 9) {}
-
-  int operator()(const VectorXd &x, VectorXd &fvec) {
-    double temp, temp1, temp2;
-    const VectorXd::Index n = x.size();
-    assert(fvec.size() == n);
-    for (VectorXd::Index k = 0; k < n; k++) {
-      temp = (3. - 2. * x[k]) * x[k];
-      temp1 = 0.;
-      if (k) temp1 = x[k - 1];
-      temp2 = 0.;
-      if (k != n - 1) temp2 = x[k + 1];
-      fvec[k] = temp - temp1 - 2. * temp2 + 1.;
-    }
-    return 0;
-  }
-  int df(const VectorXd &x, MatrixXd &fjac) {
-    const VectorXd::Index n = x.size();
-    assert(fjac.rows() == n);
-    assert(fjac.cols() == n);
-    for (VectorXd::Index k = 0; k < n; k++) {
-      for (VectorXd::Index j = 0; j < n; j++) fjac(k, j) = 0.;
-      fjac(k, k) = 3. - 4. * x[k];
-      if (k) fjac(k, k - 1) = -1.;
-      if (k != n - 1) fjac(k, k + 1) = -2.;
-    }
-    return 0;
-  }
-};
-
-void testHybrj1() {
-  const int n = 9;
-  int info;
-  VectorXd x(n);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, -1.);
-
-  // do the computation
-  hybrj_functor functor;
-  HybridNonLinearSolver<hybrj_functor> solver(functor);
-  info = solver.hybrj1(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(solver, 11, 1);
-
-  // check norm
-  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testHybrj() {
-  const int n = 9;
-  int info;
-  VectorXd x(n);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, -1.);
-
-  // do the computation
-  hybrj_functor functor;
-  HybridNonLinearSolver<hybrj_functor> solver(functor);
-  solver.diag.setConstant(n, 1.);
-  solver.useExternalScaling = true;
-  info = solver.solve(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(solver, 11, 1);
-
-  // check norm
-  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-struct hybrd_functor : Functor<double> {
-  hybrd_functor(void) : Functor<double>(9, 9) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) const {
-    double temp, temp1, temp2;
-    const VectorXd::Index n = x.size();
-
-    assert(fvec.size() == n);
-    for (VectorXd::Index k = 0; k < n; k++) {
-      temp = (3. - 2. * x[k]) * x[k];
-      temp1 = 0.;
-      if (k) temp1 = x[k - 1];
-      temp2 = 0.;
-      if (k != n - 1) temp2 = x[k + 1];
-      fvec[k] = temp - temp1 - 2. * temp2 + 1.;
-    }
-    return 0;
-  }
-};
-
-void testHybrd1() {
-  int n = 9, info;
-  VectorXd x(n);
-
-  /* the following starting values provide a rough solution. */
-  x.setConstant(n, -1.);
-
-  // do the computation
-  hybrd_functor functor;
-  HybridNonLinearSolver<hybrd_functor> solver(functor);
-  info = solver.hybrd1(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  VERIFY(solver.nfev <= 20 * LM_EVAL_COUNT_TOL);
-
-  // check norm
-  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testHybrd() {
-  const int n = 9;
-  int info;
-  VectorXd x;
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, -1.);
-
-  // do the computation
-  hybrd_functor functor;
-  HybridNonLinearSolver<hybrd_functor> solver(functor);
-  solver.parameters.nb_of_subdiagonals = 1;
-  solver.parameters.nb_of_superdiagonals = 1;
-  solver.diag.setConstant(n, 1.);
-  solver.useExternalScaling = true;
-  info = solver.solveNumericalDiff(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  VERIFY(solver.nfev <= 14 * LM_EVAL_COUNT_TOL);
-
-  // check norm
-  VERIFY_IS_APPROX(solver.fvec.blueNorm(), 1.192636e-08);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << -0.5706545, -0.6816283, -0.7017325, -0.7042129, -0.701369, -0.6918656, -0.665792, -0.5960342, -0.4164121;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-struct lmstr_functor : Functor<double> {
-  lmstr_functor(void) : Functor<double>(3, 15) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) {
-    /*  subroutine fcn for lmstr1 example. */
-    double tmp1, tmp2, tmp3;
-    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
-
-    assert(15 == fvec.size());
-    assert(3 == x.size());
-
-    for (int i = 0; i < 15; i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-    return 0;
-  }
-  int df(const VectorXd &x, VectorXd &jac_row, VectorXd::Index rownb) {
-    assert(x.size() == 3);
-    assert(jac_row.size() == x.size());
-    double tmp1, tmp2, tmp3, tmp4;
-
-    VectorXd::Index i = rownb - 2;
-    tmp1 = i + 1;
-    tmp2 = 16 - i - 1;
-    tmp3 = (i >= 8) ? tmp2 : tmp1;
-    tmp4 = (x[1] * tmp2 + x[2] * tmp3);
-    tmp4 = tmp4 * tmp4;
-    jac_row[0] = -1;
-    jac_row[1] = tmp1 * tmp2 / tmp4;
-    jac_row[2] = tmp1 * tmp3 / tmp4;
-    return 0;
-  }
-};
-
-void testLmstr1() {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmstr_functor functor;
-  LevenbergMarquardt<lmstr_functor> lm(functor);
-  info = lm.lmstr1(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 6, 5);
-
-  // check norm
-  VERIFY_IS_APPROX(lm.fvec.blueNorm(), 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testLmstr() {
-  const int n = 3;
-  int info;
-  double fnorm;
-  VectorXd x(n);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmstr_functor functor;
-  LevenbergMarquardt<lmstr_functor> lm(functor);
-  info = lm.minimizeOptimumStorage(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return values
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 6, 5);
-
-  // check norm
-  fnorm = lm.fvec.blueNorm();
-  VERIFY_IS_APPROX(fnorm, 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-struct lmdif_functor : Functor<double> {
-  lmdif_functor(void) : Functor<double>(3, 15) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) const {
-    int i;
-    double tmp1, tmp2, tmp3;
-    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34e0, 2.1e0,  4.39e0};
-
-    assert(x.size() == 3);
-    assert(fvec.size() == 15);
-    for (i = 0; i < 15; i++) {
-      tmp1 = i + 1;
-      tmp2 = 15 - i;
-      tmp3 = tmp1;
-
-      if (i >= 8) tmp3 = tmp2;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-    return 0;
-  }
-};
-
-void testLmdif1() {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n), fvec(15);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmdif_functor functor;
-  DenseIndex nfev = -1;  // initialize to avoid maybe-uninitialized warning
-  info = LevenbergMarquardt<lmdif_functor>::lmdif1(functor, x, &nfev);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  VERIFY(nfev <= 26 * LM_EVAL_COUNT_TOL);
-
-  // check norm
-  functor(x, fvec);
-  VERIFY_IS_APPROX(fvec.blueNorm(), 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.0824106, 1.1330366, 2.3436947;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testLmdif() {
-  const int m = 15, n = 3;
-  int info;
-  double fnorm, covfac;
-  VectorXd x(n);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmdif_functor functor;
-  NumericalDiff<lmdif_functor> numDiff(functor);
-  LevenbergMarquardt<NumericalDiff<lmdif_functor> > lm(numDiff);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return values
-  // VERIFY_IS_EQUAL(info, 1);
-  VERIFY(lm.nfev <= 26 * LM_EVAL_COUNT_TOL);
-
-  // check norm
-  fnorm = lm.fvec.blueNorm();
-  VERIFY_IS_APPROX(fnorm, 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-
-  // check covariance
-  covfac = fnorm * fnorm / (m - n);
-  internal::covar(lm.fjac, lm.permutation.indices());  // TODO : move this as a function of lm
-
-  MatrixXd cov_ref(n, n);
-  cov_ref << 0.0001531202, 0.002869942, -0.002656662, 0.002869942, 0.09480937, -0.09098997, -0.002656662, -0.09098997,
-      0.08778729;
-
-  //  std::cout << fjac*covfac << std::endl;
-
-  MatrixXd cov;
-  cov = covfac * lm.fjac.topLeftCorner<n, n>();
-  VERIFY_IS_APPROX(cov, cov_ref);
-  // TODO: why isn't this allowed ? :
-  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
-}
-
-struct chwirut2_functor : Functor<double> {
-  chwirut2_functor(void) : Functor<double>(3, 54) {}
-  static const double m_x[54];
-  static const double m_y[54];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    int i;
-
-    assert(b.size() == 3);
-    assert(fvec.size() == 54);
-    for (i = 0; i < 54; i++) {
-      double x = m_x[i];
-      fvec[i] = exp(-b[0] * x) / (b[1] + b[2] * x) - m_y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 54);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 54; i++) {
-      double x = m_x[i];
-      double factor = 1. / (b[1] + b[2] * x);
-      double e = exp(-b[0] * x);
-      fjac(i, 0) = -x * e * factor;
-      fjac(i, 1) = -e * factor * factor;
-      fjac(i, 2) = -x * e * factor * factor;
-    }
-    return 0;
-  }
-};
-const double chwirut2_functor::m_x[54] = {
-    0.500E0, 1.000E0, 1.750E0, 3.750E0, 5.750E0, 0.875E0, 2.250E0, 3.250E0, 5.250E0, 0.750E0, 1.750E0,
-    2.750E0, 4.750E0, 0.625E0, 1.250E0, 2.250E0, 4.250E0, .500E0,  3.000E0, .750E0,  3.000E0, 1.500E0,
-    6.000E0, 3.000E0, 6.000E0, 1.500E0, 3.000E0, .500E0,  2.000E0, 4.000E0, .750E0,  2.000E0, 5.000E0,
-    .750E0,  2.250E0, 3.750E0, 5.750E0, 3.000E0, .750E0,  2.500E0, 4.000E0, .750E0,  2.500E0, 4.000E0,
-    .750E0,  2.500E0, 4.000E0, .500E0,  6.000E0, 3.000E0, .500E0,  2.750E0, .500E0,  1.750E0};
-const double chwirut2_functor::m_y[54] = {
-    92.9000E0, 57.1000E0, 31.0500E0, 11.5875E0, 8.0250E0,  63.6000E0, 21.4000E0, 14.2500E0, 8.4750E0,
-    63.8000E0, 26.8000E0, 16.4625E0, 7.1250E0,  67.3000E0, 41.0000E0, 21.1500E0, 8.1750E0,  81.5000E0,
-    13.1200E0, 59.9000E0, 14.6200E0, 32.9000E0, 5.4400E0,  12.5600E0, 5.4400E0,  32.0000E0, 13.9500E0,
-    75.8000E0, 20.0000E0, 10.4200E0, 59.5000E0, 21.6700E0, 8.5500E0,  62.0000E0, 20.2000E0, 7.7600E0,
-    3.7500E0,  11.8100E0, 54.7000E0, 23.7000E0, 11.5500E0, 61.3000E0, 17.7000E0, 8.7400E0,  59.2000E0,
-    16.3000E0, 8.6200E0,  81.0000E0, 4.8700E0,  14.6200E0, 81.7000E0, 17.1700E0, 81.3000E0, 28.9000E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/chwirut2.shtml
-void testNistChwirut2(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 0.1, 0.01, 0.02;
-  // do the computation
-  chwirut2_functor functor;
-  LevenbergMarquardt<chwirut2_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 10, 8);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.1304802941E+02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
-  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
-  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
-
-  /*
-   * Second try
-   */
-  x << 0.15, 0.008, 0.010;
-  // do the computation
-  lm.resetParameters();
-  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
-  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 7, 6);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.1304802941E+02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
-  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
-  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
-}
-
-struct misra1a_functor : Functor<double> {
-  misra1a_functor(void) : Functor<double>(2, 14) {}
-  static const double m_x[14];
-  static const double m_y[14];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 2);
-    assert(fvec.size() == 14);
-    for (int i = 0; i < 14; i++) {
-      fvec[i] = b[0] * (1. - exp(-b[1] * m_x[i])) - m_y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 2);
-    assert(fjac.rows() == 14);
-    assert(fjac.cols() == 2);
-    for (int i = 0; i < 14; i++) {
-      fjac(i, 0) = (1. - exp(-b[1] * m_x[i]));
-      fjac(i, 1) = (b[0] * m_x[i] * exp(-b[1] * m_x[i]));
-    }
-    return 0;
-  }
-};
-const double misra1a_functor::m_x[14] = {77.6E0,  114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0,
-                                         378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0};
-const double misra1a_functor::m_y[14] = {10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0,
-                                         44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/misra1a.shtml
-void testNistMisra1a(void) {
-  const int n = 2;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 500., 0.0001;
-  // do the computation
-  misra1a_functor functor;
-  LevenbergMarquardt<misra1a_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 19, 15);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.2455138894E-01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
-  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
-
-  /*
-   * Second try
-   */
-  x << 250., 0.0005;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 5, 4);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.2455138894E-01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
-  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
-}
-
-struct hahn1_functor : Functor<double> {
-  hahn1_functor(void) : Functor<double>(7, 236) {}
-  static const double m_x[236];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    static const double m_y[236] = {
-        .591E0,   1.547E0,  2.902E0,  2.894E0,  4.703E0,  6.307E0,  7.03E0,   7.898E0,  9.470E0,  9.484E0,  10.072E0,
-        10.163E0, 11.615E0, 12.005E0, 12.478E0, 12.982E0, 12.970E0, 13.926E0, 14.452E0, 14.404E0, 15.190E0, 15.550E0,
-        15.528E0, 15.499E0, 16.131E0, 16.438E0, 16.387E0, 16.549E0, 16.872E0, 16.830E0, 16.926E0, 16.907E0, 16.966E0,
-        17.060E0, 17.122E0, 17.311E0, 17.355E0, 17.668E0, 17.767E0, 17.803E0, 17.765E0, 17.768E0, 17.736E0, 17.858E0,
-        17.877E0, 17.912E0, 18.046E0, 18.085E0, 18.291E0, 18.357E0, 18.426E0, 18.584E0, 18.610E0, 18.870E0, 18.795E0,
-        19.111E0, .367E0,   .796E0,   0.892E0,  1.903E0,  2.150E0,  3.697E0,  5.870E0,  6.421E0,  7.422E0,  9.944E0,
-        11.023E0, 11.87E0,  12.786E0, 14.067E0, 13.974E0, 14.462E0, 14.464E0, 15.381E0, 15.483E0, 15.59E0,  16.075E0,
-        16.347E0, 16.181E0, 16.915E0, 17.003E0, 16.978E0, 17.756E0, 17.808E0, 17.868E0, 18.481E0, 18.486E0, 19.090E0,
-        16.062E0, 16.337E0, 16.345E0, 16.388E0, 17.159E0, 17.116E0, 17.164E0, 17.123E0, 17.979E0, 17.974E0, 18.007E0,
-        17.993E0, 18.523E0, 18.669E0, 18.617E0, 19.371E0, 19.330E0, 0.080E0,  0.248E0,  1.089E0,  1.418E0,  2.278E0,
-        3.624E0,  4.574E0,  5.556E0,  7.267E0,  7.695E0,  9.136E0,  9.959E0,  9.957E0,  11.600E0, 13.138E0, 13.564E0,
-        13.871E0, 13.994E0, 14.947E0, 15.473E0, 15.379E0, 15.455E0, 15.908E0, 16.114E0, 17.071E0, 17.135E0, 17.282E0,
-        17.368E0, 17.483E0, 17.764E0, 18.185E0, 18.271E0, 18.236E0, 18.237E0, 18.523E0, 18.627E0, 18.665E0, 19.086E0,
-        0.214E0,  0.943E0,  1.429E0,  2.241E0,  2.951E0,  3.782E0,  4.757E0,  5.602E0,  7.169E0,  8.920E0,  10.055E0,
-        12.035E0, 12.861E0, 13.436E0, 14.167E0, 14.755E0, 15.168E0, 15.651E0, 15.746E0, 16.216E0, 16.445E0, 16.965E0,
-        17.121E0, 17.206E0, 17.250E0, 17.339E0, 17.793E0, 18.123E0, 18.49E0,  18.566E0, 18.645E0, 18.706E0, 18.924E0,
-        19.1E0,   0.375E0,  0.471E0,  1.504E0,  2.204E0,  2.813E0,  4.765E0,  9.835E0,  10.040E0, 11.946E0, 12.596E0,
-        13.303E0, 13.922E0, 14.440E0, 14.951E0, 15.627E0, 15.639E0, 15.814E0, 16.315E0, 16.334E0, 16.430E0, 16.423E0,
-        17.024E0, 17.009E0, 17.165E0, 17.134E0, 17.349E0, 17.576E0, 17.848E0, 18.090E0, 18.276E0, 18.404E0, 18.519E0,
-        19.133E0, 19.074E0, 19.239E0, 19.280E0, 19.101E0, 19.398E0, 19.252E0, 19.89E0,  20.007E0, 19.929E0, 19.268E0,
-        19.324E0, 20.049E0, 20.107E0, 20.062E0, 20.065E0, 19.286E0, 19.972E0, 20.088E0, 20.743E0, 20.83E0,  20.935E0,
-        21.035E0, 20.93E0,  21.074E0, 21.085E0, 20.935E0};
-
-    //        int called=0; printf("call hahn1_functor with  iflag=%d, called=%d\n", iflag, called); if (iflag==1)
-    //        called++;
-
-    assert(b.size() == 7);
-    assert(fvec.size() == 236);
-    for (int i = 0; i < 236; i++) {
-      double x = m_x[i], xx = x * x, xxx = xx * x;
-      fvec[i] = (b[0] + b[1] * x + b[2] * xx + b[3] * xxx) / (1. + b[4] * x + b[5] * xx + b[6] * xxx) - m_y[i];
-    }
-    return 0;
-  }
-
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 7);
-    assert(fjac.rows() == 236);
-    assert(fjac.cols() == 7);
-    for (int i = 0; i < 236; i++) {
-      double x = m_x[i], xx = x * x, xxx = xx * x;
-      double fact = 1. / (1. + b[4] * x + b[5] * xx + b[6] * xxx);
-      fjac(i, 0) = 1. * fact;
-      fjac(i, 1) = x * fact;
-      fjac(i, 2) = xx * fact;
-      fjac(i, 3) = xxx * fact;
-      fact = -(b[0] + b[1] * x + b[2] * xx + b[3] * xxx) * fact * fact;
-      fjac(i, 4) = x * fact;
-      fjac(i, 5) = xx * fact;
-      fjac(i, 6) = xxx * fact;
-    }
-    return 0;
-  }
-};
-const double hahn1_functor::m_x[236] = {
-    24.41E0,  34.82E0,  44.09E0,  45.07E0,  54.98E0,  65.51E0,  70.53E0,  75.70E0,  89.57E0,  91.14E0,  96.40E0,
-    97.19E0,  114.26E0, 120.25E0, 127.08E0, 133.55E0, 133.61E0, 158.67E0, 172.74E0, 171.31E0, 202.14E0, 220.55E0,
-    221.05E0, 221.39E0, 250.99E0, 268.99E0, 271.80E0, 271.97E0, 321.31E0, 321.69E0, 330.14E0, 333.03E0, 333.47E0,
-    340.77E0, 345.65E0, 373.11E0, 373.79E0, 411.82E0, 419.51E0, 421.59E0, 422.02E0, 422.47E0, 422.61E0, 441.75E0,
-    447.41E0, 448.7E0,  472.89E0, 476.69E0, 522.47E0, 522.62E0, 524.43E0, 546.75E0, 549.53E0, 575.29E0, 576.00E0,
-    625.55E0, 20.15E0,  28.78E0,  29.57E0,  37.41E0,  39.12E0,  50.24E0,  61.38E0,  66.25E0,  73.42E0,  95.52E0,
-    107.32E0, 122.04E0, 134.03E0, 163.19E0, 163.48E0, 175.70E0, 179.86E0, 211.27E0, 217.78E0, 219.14E0, 262.52E0,
-    268.01E0, 268.62E0, 336.25E0, 337.23E0, 339.33E0, 427.38E0, 428.58E0, 432.68E0, 528.99E0, 531.08E0, 628.34E0,
-    253.24E0, 273.13E0, 273.66E0, 282.10E0, 346.62E0, 347.19E0, 348.78E0, 351.18E0, 450.10E0, 450.35E0, 451.92E0,
-    455.56E0, 552.22E0, 553.56E0, 555.74E0, 652.59E0, 656.20E0, 14.13E0,  20.41E0,  31.30E0,  33.84E0,  39.70E0,
-    48.83E0,  54.50E0,  60.41E0,  72.77E0,  75.25E0,  86.84E0,  94.88E0,  96.40E0,  117.37E0, 139.08E0, 147.73E0,
-    158.63E0, 161.84E0, 192.11E0, 206.76E0, 209.07E0, 213.32E0, 226.44E0, 237.12E0, 330.90E0, 358.72E0, 370.77E0,
-    372.72E0, 396.24E0, 416.59E0, 484.02E0, 495.47E0, 514.78E0, 515.65E0, 519.47E0, 544.47E0, 560.11E0, 620.77E0,
-    18.97E0,  28.93E0,  33.91E0,  40.03E0,  44.66E0,  49.87E0,  55.16E0,  60.90E0,  72.08E0,  85.15E0,  97.06E0,
-    119.63E0, 133.27E0, 143.84E0, 161.91E0, 180.67E0, 198.44E0, 226.86E0, 229.65E0, 258.27E0, 273.77E0, 339.15E0,
-    350.13E0, 362.75E0, 371.03E0, 393.32E0, 448.53E0, 473.78E0, 511.12E0, 524.70E0, 548.75E0, 551.64E0, 574.02E0,
-    623.86E0, 21.46E0,  24.33E0,  33.43E0,  39.22E0,  44.18E0,  55.02E0,  94.33E0,  96.44E0,  118.82E0, 128.48E0,
-    141.94E0, 156.92E0, 171.65E0, 190.00E0, 223.26E0, 223.88E0, 231.50E0, 265.05E0, 269.44E0, 271.78E0, 273.46E0,
-    334.61E0, 339.79E0, 349.52E0, 358.18E0, 377.98E0, 394.77E0, 429.66E0, 468.22E0, 487.27E0, 519.54E0, 523.03E0,
-    612.99E0, 638.59E0, 641.36E0, 622.05E0, 631.50E0, 663.97E0, 646.9E0,  748.29E0, 749.21E0, 750.14E0, 647.04E0,
-    646.89E0, 746.9E0,  748.43E0, 747.35E0, 749.27E0, 647.61E0, 747.78E0, 750.51E0, 851.37E0, 845.97E0, 847.54E0,
-    849.93E0, 851.61E0, 849.75E0, 850.98E0, 848.23E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/hahn1.shtml
-void testNistHahn1(void) {
-  const int n = 7;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 10., -1., .05, -.00001, -.05, .001, -.000001;
-  // do the computation
-  hahn1_functor functor;
-  LevenbergMarquardt<hahn1_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 11, 10);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.5324382854E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.0776351733E+00);
-  VERIFY_IS_APPROX(x[1], -1.2269296921E-01);
-  VERIFY_IS_APPROX(x[2], 4.0863750610E-03);
-  VERIFY_IS_APPROX(x[3], -1.426264e-06);  // should be : -1.4262662514E-06
-  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
-  VERIFY_IS_APPROX(x[5], 2.4053735503E-04);
-  VERIFY_IS_APPROX(x[6], -1.2314450199E-07);
-
-  /*
-   * Second try
-   */
-  x << .1, -.1, .005, -.000001, -.005, .0001, -.0000001;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 11, 10);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.5324382854E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.077640);       // should be :  1.0776351733E+00
-  VERIFY_IS_APPROX(x[1], -0.1226933);     // should be : -1.2269296921E-01
-  VERIFY_IS_APPROX(x[2], 0.004086383);    // should be : 4.0863750610E-03
-  VERIFY_IS_APPROX(x[3], -1.426277e-06);  // should be : -1.4262662514E-06
-  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
-  VERIFY_IS_APPROX(x[5], 0.00024053772);  // should be : 2.4053735503E-04
-  VERIFY_IS_APPROX(x[6], -1.231450e-07);  // should be : -1.2314450199E-07
-}
-
-struct misra1d_functor : Functor<double> {
-  misra1d_functor(void) : Functor<double>(2, 14) {}
-  static const double x[14];
-  static const double y[14];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 2);
-    assert(fvec.size() == 14);
-    for (int i = 0; i < 14; i++) {
-      fvec[i] = b[0] * b[1] * x[i] / (1. + b[1] * x[i]) - y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 2);
-    assert(fjac.rows() == 14);
-    assert(fjac.cols() == 2);
-    for (int i = 0; i < 14; i++) {
-      double den = 1. + b[1] * x[i];
-      fjac(i, 0) = b[1] * x[i] / den;
-      fjac(i, 1) = b[0] * x[i] * (den - b[1] * x[i]) / den / den;
-    }
-    return 0;
-  }
-};
-const double misra1d_functor::x[14] = {77.6E0,  114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0,
-                                       378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0};
-const double misra1d_functor::y[14] = {10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0,
-                                       44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/misra1d.shtml
-void testNistMisra1d(void) {
-  const int n = 2;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 500., 0.0001;
-  // do the computation
-  misra1d_functor functor;
-  LevenbergMarquardt<misra1d_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 3);
-  LM_CHECK_N_ITERS(lm, 9, 7);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6419295283E-02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
-  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
-
-  /*
-   * Second try
-   */
-  x << 450., 0.0003;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 4, 3);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6419295283E-02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
-  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
-}
-
-struct lanczos1_functor : Functor<double> {
-  lanczos1_functor(void) : Functor<double>(6, 24) {}
-  static const double x[24];
-  static const double y[24];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 6);
-    assert(fvec.size() == 24);
-    for (int i = 0; i < 24; i++)
-      fvec[i] = b[0] * exp(-b[1] * x[i]) + b[2] * exp(-b[3] * x[i]) + b[4] * exp(-b[5] * x[i]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 6);
-    assert(fjac.rows() == 24);
-    assert(fjac.cols() == 6);
-    for (int i = 0; i < 24; i++) {
-      fjac(i, 0) = exp(-b[1] * x[i]);
-      fjac(i, 1) = -b[0] * x[i] * exp(-b[1] * x[i]);
-      fjac(i, 2) = exp(-b[3] * x[i]);
-      fjac(i, 3) = -b[2] * x[i] * exp(-b[3] * x[i]);
-      fjac(i, 4) = exp(-b[5] * x[i]);
-      fjac(i, 5) = -b[4] * x[i] * exp(-b[5] * x[i]);
-    }
-    return 0;
-  }
-};
-const double lanczos1_functor::x[24] = {0.000000000000E+00, 5.000000000000E-02, 1.000000000000E-01, 1.500000000000E-01,
-                                        2.000000000000E-01, 2.500000000000E-01, 3.000000000000E-01, 3.500000000000E-01,
-                                        4.000000000000E-01, 4.500000000000E-01, 5.000000000000E-01, 5.500000000000E-01,
-                                        6.000000000000E-01, 6.500000000000E-01, 7.000000000000E-01, 7.500000000000E-01,
-                                        8.000000000000E-01, 8.500000000000E-01, 9.000000000000E-01, 9.500000000000E-01,
-                                        1.000000000000E+00, 1.050000000000E+00, 1.100000000000E+00, 1.150000000000E+00};
-const double lanczos1_functor::y[24] = {2.513400000000E+00, 2.044333373291E+00, 1.668404436564E+00, 1.366418021208E+00,
-                                        1.123232487372E+00, 9.268897180037E-01, 7.679338563728E-01, 6.388775523106E-01,
-                                        5.337835317402E-01, 4.479363617347E-01, 3.775847884350E-01, 3.197393199326E-01,
-                                        2.720130773746E-01, 2.324965529032E-01, 1.996589546065E-01, 1.722704126914E-01,
-                                        1.493405660168E-01, 1.300700206922E-01, 1.138119324644E-01, 1.000415587559E-01,
-                                        8.833209084540E-02, 7.833544019350E-02, 6.976693743449E-02, 6.239312536719E-02};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/lanczos1.shtml
-void testNistLanczos1(void) {
-  const int n = 6;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1.2, 0.3, 5.6, 5.5, 6.5, 7.6;
-  // do the computation
-  lanczos1_functor functor;
-  LevenbergMarquardt<lanczos1_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 2);
-  LM_CHECK_N_ITERS(lm, 79, 72);
-  // check norm^2
-  // std::cout.precision(30);
-  // std::cout << lm.fvec.squaredNorm() << "\n";
-  VERIFY(lm.fvec.squaredNorm() <= 1.44E-25);
-  // check x
-  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
-  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
-  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
-  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
-  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
-  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
-
-  /*
-   * Second try
-   */
-  x << 0.5, 0.7, 3.6, 4.2, 4., 6.3;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 2);
-  LM_CHECK_N_ITERS(lm, 9, 8);
-  // check norm^2
-  VERIFY(lm.fvec.squaredNorm() <= 1.44E-25);
-  // check x
-  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
-  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
-  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
-  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
-  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
-  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
-}
-
-struct rat42_functor : Functor<double> {
-  rat42_functor(void) : Functor<double>(3, 9) {}
-  static const double x[9];
-  static const double y[9];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 9);
-    for (int i = 0; i < 9; i++) {
-      fvec[i] = b[0] / (1. + exp(b[1] - b[2] * x[i])) - y[i];
-    }
-    return 0;
-  }
-
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 9);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 9; i++) {
-      double e = exp(b[1] - b[2] * x[i]);
-      fjac(i, 0) = 1. / (1. + e);
-      fjac(i, 1) = -b[0] * e / (1. + e) / (1. + e);
-      fjac(i, 2) = +b[0] * e * x[i] / (1. + e) / (1. + e);
-    }
-    return 0;
-  }
-};
-const double rat42_functor::x[9] = {9.000E0,  14.000E0, 21.000E0, 28.000E0, 42.000E0,
-                                    57.000E0, 63.000E0, 70.000E0, 79.000E0};
-const double rat42_functor::y[9] = {8.930E0,  10.800E0, 18.590E0, 22.330E0, 39.350E0,
-                                    56.110E0, 61.730E0, 64.620E0, 67.080E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky2.shtml
-void testNistRat42(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 100., 1., 0.1;
-  // do the computation
-  rat42_functor functor;
-  LevenbergMarquardt<rat42_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 10, 8);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.0565229338E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
-  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
-  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
-
-  /*
-   * Second try
-   */
-  x << 75., 2.5, 0.07;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 6, 5);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.0565229338E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
-  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
-  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
-}
-
-struct MGH10_functor : Functor<double> {
-  MGH10_functor(void) : Functor<double>(3, 16) {}
-  static const double x[16];
-  static const double y[16];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 16);
-    for (int i = 0; i < 16; i++) fvec[i] = b[0] * exp(b[1] / (x[i] + b[2])) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 16);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 16; i++) {
-      double factor = 1. / (x[i] + b[2]);
-      double e = exp(b[1] * factor);
-      fjac(i, 0) = e;
-      fjac(i, 1) = b[0] * factor * e;
-      fjac(i, 2) = -b[1] * b[0] * factor * factor * e;
-    }
-    return 0;
-  }
-};
-const double MGH10_functor::x[16] = {5.000000E+01, 5.500000E+01, 6.000000E+01, 6.500000E+01, 7.000000E+01, 7.500000E+01,
-                                     8.000000E+01, 8.500000E+01, 9.000000E+01, 9.500000E+01, 1.000000E+02, 1.050000E+02,
-                                     1.100000E+02, 1.150000E+02, 1.200000E+02, 1.250000E+02};
-const double MGH10_functor::y[16] = {3.478000E+04, 2.861000E+04, 2.365000E+04, 1.963000E+04, 1.637000E+04, 1.372000E+04,
-                                     1.154000E+04, 9.744000E+03, 8.261000E+03, 7.030000E+03, 6.005000E+03, 5.147000E+03,
-                                     4.427000E+03, 3.820000E+03, 3.307000E+03, 2.872000E+03};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/mgh10.shtml
-void testNistMGH10(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 2., 400000., 25000.;
-  // do the computation
-  MGH10_functor functor;
-  LevenbergMarquardt<MGH10_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 2);
-  LM_CHECK_N_ITERS(lm, 284, 249);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7945855171E+01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
-  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
-  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
-
-  /*
-   * Second try
-   */
-  x << 0.02, 4000., 250.;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 3);
-  LM_CHECK_N_ITERS(lm, 126, 116);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7945855171E+01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
-  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
-  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
-}
-
-struct BoxBOD_functor : Functor<double> {
-  BoxBOD_functor(void) : Functor<double>(2, 6) {}
-  static const double x[6];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    static const double y[6] = {109., 149., 149., 191., 213., 224.};
-    assert(b.size() == 2);
-    assert(fvec.size() == 6);
-    for (int i = 0; i < 6; i++) fvec[i] = b[0] * (1. - exp(-b[1] * x[i])) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 2);
-    assert(fjac.rows() == 6);
-    assert(fjac.cols() == 2);
-    for (int i = 0; i < 6; i++) {
-      double e = exp(-b[1] * x[i]);
-      fjac(i, 0) = 1. - e;
-      fjac(i, 1) = b[0] * x[i] * e;
-    }
-    return 0;
-  }
-};
-const double BoxBOD_functor::x[6] = {1., 2., 3., 5., 7., 10.};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/boxbod.shtml
-void testNistBoxBOD(void) {
-  const int n = 2;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1., 1.;
-  // do the computation
-  BoxBOD_functor functor;
-  LevenbergMarquardt<BoxBOD_functor> lm(functor);
-  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
-  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
-  lm.parameters.factor = 10.;
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 31, 25);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.1680088766E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
-  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
-
-  /*
-   * Second try
-   */
-  x << 100., 0.75;
-  // do the computation
-  lm.resetParameters();
-  lm.parameters.ftol = NumTraits<double>::epsilon();
-  lm.parameters.xtol = NumTraits<double>::epsilon();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 20, 14);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.1680088766E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
-  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
-}
-
-struct MGH17_functor : Functor<double> {
-  MGH17_functor(void) : Functor<double>(5, 33) {}
-  static const double x[33];
-  static const double y[33];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 5);
-    assert(fvec.size() == 33);
-    for (int i = 0; i < 33; i++) fvec[i] = b[0] + b[1] * exp(-b[3] * x[i]) + b[2] * exp(-b[4] * x[i]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 5);
-    assert(fjac.rows() == 33);
-    assert(fjac.cols() == 5);
-    for (int i = 0; i < 33; i++) {
-      fjac(i, 0) = 1.;
-      fjac(i, 1) = exp(-b[3] * x[i]);
-      fjac(i, 2) = exp(-b[4] * x[i]);
-      fjac(i, 3) = -x[i] * b[1] * exp(-b[3] * x[i]);
-      fjac(i, 4) = -x[i] * b[2] * exp(-b[4] * x[i]);
-    }
-    return 0;
-  }
-};
-const double MGH17_functor::x[33] = {0.000000E+00, 1.000000E+01, 2.000000E+01, 3.000000E+01, 4.000000E+01, 5.000000E+01,
-                                     6.000000E+01, 7.000000E+01, 8.000000E+01, 9.000000E+01, 1.000000E+02, 1.100000E+02,
-                                     1.200000E+02, 1.300000E+02, 1.400000E+02, 1.500000E+02, 1.600000E+02, 1.700000E+02,
-                                     1.800000E+02, 1.900000E+02, 2.000000E+02, 2.100000E+02, 2.200000E+02, 2.300000E+02,
-                                     2.400000E+02, 2.500000E+02, 2.600000E+02, 2.700000E+02, 2.800000E+02, 2.900000E+02,
-                                     3.000000E+02, 3.100000E+02, 3.200000E+02};
-const double MGH17_functor::y[33] = {8.440000E-01, 9.080000E-01, 9.320000E-01, 9.360000E-01, 9.250000E-01, 9.080000E-01,
-                                     8.810000E-01, 8.500000E-01, 8.180000E-01, 7.840000E-01, 7.510000E-01, 7.180000E-01,
-                                     6.850000E-01, 6.580000E-01, 6.280000E-01, 6.030000E-01, 5.800000E-01, 5.580000E-01,
-                                     5.380000E-01, 5.220000E-01, 5.060000E-01, 4.900000E-01, 4.780000E-01, 4.670000E-01,
-                                     4.570000E-01, 4.480000E-01, 4.380000E-01, 4.310000E-01, 4.240000E-01, 4.200000E-01,
-                                     4.140000E-01, 4.110000E-01, 4.060000E-01};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/mgh17.shtml
-void testNistMGH17(void) {
-  const int n = 5;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 50., 150., -100., 1., 2.;
-  // do the computation
-  MGH17_functor functor;
-  LevenbergMarquardt<MGH17_functor> lm(functor);
-  lm.parameters.ftol = NumTraits<double>::epsilon();
-  lm.parameters.xtol = NumTraits<double>::epsilon();
-  lm.parameters.maxfev = 1000;
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.4648946975E-05);
-  // check x
-  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
-  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
-  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
-  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
-  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 2);
-  LM_CHECK_N_ITERS(lm, 602, 545);
-
-  /*
-   * Second try
-   */
-  x << 0.5, 1.5, -1, 0.01, 0.02;
-  // do the computation
-  lm.resetParameters();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 18, 15);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.4648946975E-05);
-  // check x
-  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
-  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
-  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
-  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
-  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
-}
-
-struct MGH09_functor : Functor<double> {
-  MGH09_functor(void) : Functor<double>(4, 11) {}
-  static const double _x[11];
-  static const double y[11];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 4);
-    assert(fvec.size() == 11);
-    for (int i = 0; i < 11; i++) {
-      double x = _x[i], xx = x * x;
-      fvec[i] = b[0] * (xx + x * b[1]) / (xx + x * b[2] + b[3]) - y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 4);
-    assert(fjac.rows() == 11);
-    assert(fjac.cols() == 4);
-    for (int i = 0; i < 11; i++) {
-      double x = _x[i], xx = x * x;
-      double factor = 1. / (xx + x * b[2] + b[3]);
-      fjac(i, 0) = (xx + x * b[1]) * factor;
-      fjac(i, 1) = b[0] * x * factor;
-      fjac(i, 2) = -b[0] * (xx + x * b[1]) * x * factor * factor;
-      fjac(i, 3) = -b[0] * (xx + x * b[1]) * factor * factor;
-    }
-    return 0;
-  }
-};
-const double MGH09_functor::_x[11] = {4.,           2.,     1.,           5.E-1,        2.5E-01,     1.670000E-01,
-                                      1.250000E-01, 1.E-01, 8.330000E-02, 7.140000E-02, 6.250000E-02};
-const double MGH09_functor::y[11] = {1.957000E-01, 1.947000E-01, 1.735000E-01, 1.600000E-01, 8.440000E-02, 6.270000E-02,
-                                     4.560000E-02, 3.420000E-02, 3.230000E-02, 2.350000E-02, 2.460000E-02};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/mgh09.shtml
-void testNistMGH09(void) {
-  const int n = 4;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 25., 39, 41.5, 39.;
-  // do the computation
-  MGH09_functor functor;
-  LevenbergMarquardt<MGH09_functor> lm(functor);
-  lm.parameters.maxfev = 1000;
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 490, 376);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 3.0750560385E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], 0.1928077089);   // should be 1.9280693458E-01
-  VERIFY_IS_APPROX(x[1], 0.19126423573);  // should be 1.9128232873E-01
-  VERIFY_IS_APPROX(x[2], 0.12305309914);  // should be 1.2305650693E-01
-  VERIFY_IS_APPROX(x[3], 0.13605395375);  // should be 1.3606233068E-01
-
-  /*
-   * Second try
-   */
-  x << 0.25, 0.39, 0.415, 0.39;
-  // do the computation
-  lm.resetParameters();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 18, 16);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 3.0750560385E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], 0.19280781);  // should be 1.9280693458E-01
-  VERIFY_IS_APPROX(x[1], 0.19126265);  // should be 1.9128232873E-01
-  VERIFY_IS_APPROX(x[2], 0.12305280);  // should be 1.2305650693E-01
-  VERIFY_IS_APPROX(x[3], 0.13605322);  // should be 1.3606233068E-01
-}
-
-struct Bennett5_functor : Functor<double> {
-  Bennett5_functor(void) : Functor<double>(3, 154) {}
-  static const double x[154];
-  static const double y[154];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 154);
-    for (int i = 0; i < 154; i++) fvec[i] = b[0] * pow(b[1] + x[i], -1. / b[2]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 154);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 154; i++) {
-      double e = pow(b[1] + x[i], -1. / b[2]);
-      fjac(i, 0) = e;
-      fjac(i, 1) = -b[0] * e / b[2] / (b[1] + x[i]);
-      fjac(i, 2) = b[0] * e * log(b[1] + x[i]) / b[2] / b[2];
-    }
-    return 0;
-  }
-};
-const double Bennett5_functor::x[154] = {
-    7.447168E0,  8.102586E0,  8.452547E0,  8.711278E0,  8.916774E0,  9.087155E0,  9.232590E0,  9.359535E0,  9.472166E0,
-    9.573384E0,  9.665293E0,  9.749461E0,  9.827092E0,  9.899128E0,  9.966321E0,  10.029280E0, 10.088510E0, 10.144430E0,
-    10.197380E0, 10.247670E0, 10.295560E0, 10.341250E0, 10.384950E0, 10.426820E0, 10.467000E0, 10.505640E0, 10.542830E0,
-    10.578690E0, 10.613310E0, 10.646780E0, 10.679150E0, 10.710520E0, 10.740920E0, 10.770440E0, 10.799100E0, 10.826970E0,
-    10.854080E0, 10.880470E0, 10.906190E0, 10.931260E0, 10.955720E0, 10.979590E0, 11.002910E0, 11.025700E0, 11.047980E0,
-    11.069770E0, 11.091100E0, 11.111980E0, 11.132440E0, 11.152480E0, 11.172130E0, 11.191410E0, 11.210310E0, 11.228870E0,
-    11.247090E0, 11.264980E0, 11.282560E0, 11.299840E0, 11.316820E0, 11.333520E0, 11.349940E0, 11.366100E0, 11.382000E0,
-    11.397660E0, 11.413070E0, 11.428240E0, 11.443200E0, 11.457930E0, 11.472440E0, 11.486750E0, 11.500860E0, 11.514770E0,
-    11.528490E0, 11.542020E0, 11.555380E0, 11.568550E0, 11.581560E0, 11.594420E0, 11.607121E0, 11.619640E0, 11.632000E0,
-    11.644210E0, 11.656280E0, 11.668200E0, 11.679980E0, 11.691620E0, 11.703130E0, 11.714510E0, 11.725760E0, 11.736880E0,
-    11.747890E0, 11.758780E0, 11.769550E0, 11.780200E0, 11.790730E0, 11.801160E0, 11.811480E0, 11.821700E0, 11.831810E0,
-    11.841820E0, 11.851730E0, 11.861550E0, 11.871270E0, 11.880890E0, 11.890420E0, 11.899870E0, 11.909220E0, 11.918490E0,
-    11.927680E0, 11.936780E0, 11.945790E0, 11.954730E0, 11.963590E0, 11.972370E0, 11.981070E0, 11.989700E0, 11.998260E0,
-    12.006740E0, 12.015150E0, 12.023490E0, 12.031760E0, 12.039970E0, 12.048100E0, 12.056170E0, 12.064180E0, 12.072120E0,
-    12.080010E0, 12.087820E0, 12.095580E0, 12.103280E0, 12.110920E0, 12.118500E0, 12.126030E0, 12.133500E0, 12.140910E0,
-    12.148270E0, 12.155570E0, 12.162830E0, 12.170030E0, 12.177170E0, 12.184270E0, 12.191320E0, 12.198320E0, 12.205270E0,
-    12.212170E0, 12.219030E0, 12.225840E0, 12.232600E0, 12.239320E0, 12.245990E0, 12.252620E0, 12.259200E0, 12.265750E0,
-    12.272240E0};
-const double Bennett5_functor::y[154] = {
-    -34.834702E0, -34.393200E0, -34.152901E0, -33.979099E0, -33.845901E0, -33.732899E0, -33.640301E0, -33.559200E0,
-    -33.486801E0, -33.423100E0, -33.365101E0, -33.313000E0, -33.260899E0, -33.217400E0, -33.176899E0, -33.139198E0,
-    -33.101601E0, -33.066799E0, -33.035000E0, -33.003101E0, -32.971298E0, -32.942299E0, -32.916302E0, -32.890202E0,
-    -32.864101E0, -32.841000E0, -32.817799E0, -32.797501E0, -32.774300E0, -32.757000E0, -32.733799E0, -32.716400E0,
-    -32.699100E0, -32.678799E0, -32.661400E0, -32.644001E0, -32.626701E0, -32.612202E0, -32.597698E0, -32.583199E0,
-    -32.568699E0, -32.554298E0, -32.539799E0, -32.525299E0, -32.510799E0, -32.499199E0, -32.487598E0, -32.473202E0,
-    -32.461601E0, -32.435501E0, -32.435501E0, -32.426800E0, -32.412300E0, -32.400799E0, -32.392101E0, -32.380501E0,
-    -32.366001E0, -32.357300E0, -32.348598E0, -32.339901E0, -32.328400E0, -32.319698E0, -32.311001E0, -32.299400E0,
-    -32.290699E0, -32.282001E0, -32.273300E0, -32.264599E0, -32.256001E0, -32.247299E0, -32.238602E0, -32.229900E0,
-    -32.224098E0, -32.215401E0, -32.203800E0, -32.198002E0, -32.189400E0, -32.183601E0, -32.174900E0, -32.169102E0,
-    -32.163300E0, -32.154598E0, -32.145901E0, -32.140099E0, -32.131401E0, -32.125599E0, -32.119801E0, -32.111198E0,
-    -32.105400E0, -32.096699E0, -32.090900E0, -32.088001E0, -32.079300E0, -32.073502E0, -32.067699E0, -32.061901E0,
-    -32.056099E0, -32.050301E0, -32.044498E0, -32.038799E0, -32.033001E0, -32.027199E0, -32.024300E0, -32.018501E0,
-    -32.012699E0, -32.004002E0, -32.001099E0, -31.995300E0, -31.989500E0, -31.983700E0, -31.977900E0, -31.972099E0,
-    -31.969299E0, -31.963501E0, -31.957701E0, -31.951900E0, -31.946100E0, -31.940300E0, -31.937401E0, -31.931601E0,
-    -31.925800E0, -31.922899E0, -31.917101E0, -31.911301E0, -31.908400E0, -31.902599E0, -31.896900E0, -31.893999E0,
-    -31.888201E0, -31.885300E0, -31.882401E0, -31.876600E0, -31.873699E0, -31.867901E0, -31.862101E0, -31.859200E0,
-    -31.856300E0, -31.850500E0, -31.844700E0, -31.841801E0, -31.838900E0, -31.833099E0, -31.830200E0, -31.827299E0,
-    -31.821600E0, -31.818701E0, -31.812901E0, -31.809999E0, -31.807100E0, -31.801300E0, -31.798401E0, -31.795500E0,
-    -31.789700E0, -31.786800E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/bennett5.shtml
-void testNistBennett5(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << -2000., 50., 0.8;
-  // do the computation
-  Bennett5_functor functor;
-  LevenbergMarquardt<Bennett5_functor> lm(functor);
-  lm.parameters.maxfev = 1000;
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 758, 744);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.2404744073E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], -2.5235058043E+03);
-  VERIFY_IS_APPROX(x[1], 4.6736564644E+01);
-  VERIFY_IS_APPROX(x[2], 9.3218483193E-01);
-  /*
-   * Second try
-   */
-  x << -1500., 45., 0.85;
-  // do the computation
-  lm.resetParameters();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 203, 192);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.2404744073E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], -2523.3007865);  // should be -2.5235058043E+03
-  VERIFY_IS_APPROX(x[1], 46.735705771);   // should be 4.6736564644E+01);
-  VERIFY_IS_APPROX(x[2], 0.93219881891);  // should be 9.3218483193E-01);
-}
-
-struct thurber_functor : Functor<double> {
-  thurber_functor(void) : Functor<double>(7, 37) {}
-  static const double _x[37];
-  static const double _y[37];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    //        int called=0; printf("call hahn1_functor with  iflag=%d, called=%d\n", iflag, called); if (iflag==1)
-    //        called++;
-    assert(b.size() == 7);
-    assert(fvec.size() == 37);
-    for (int i = 0; i < 37; i++) {
-      double x = _x[i], xx = x * x, xxx = xx * x;
-      fvec[i] = (b[0] + b[1] * x + b[2] * xx + b[3] * xxx) / (1. + b[4] * x + b[5] * xx + b[6] * xxx) - _y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 7);
-    assert(fjac.rows() == 37);
-    assert(fjac.cols() == 7);
-    for (int i = 0; i < 37; i++) {
-      double x = _x[i], xx = x * x, xxx = xx * x;
-      double fact = 1. / (1. + b[4] * x + b[5] * xx + b[6] * xxx);
-      fjac(i, 0) = 1. * fact;
-      fjac(i, 1) = x * fact;
-      fjac(i, 2) = xx * fact;
-      fjac(i, 3) = xxx * fact;
-      fact = -(b[0] + b[1] * x + b[2] * xx + b[3] * xxx) * fact * fact;
-      fjac(i, 4) = x * fact;
-      fjac(i, 5) = xx * fact;
-      fjac(i, 6) = xxx * fact;
-    }
-    return 0;
-  }
-};
-const double thurber_functor::_x[37] = {-3.067E0, -2.981E0, -2.921E0, -2.912E0, -2.840E0, -2.797E0, -2.702E0, -2.699E0,
-                                        -2.633E0, -2.481E0, -2.363E0, -2.322E0, -1.501E0, -1.460E0, -1.274E0, -1.212E0,
-                                        -1.100E0, -1.046E0, -0.915E0, -0.714E0, -0.566E0, -0.545E0, -0.400E0, -0.309E0,
-                                        -0.109E0, -0.103E0, 0.010E0,  0.119E0,  0.377E0,  0.790E0,  0.963E0,  1.006E0,
-                                        1.115E0,  1.572E0,  1.841E0,  2.047E0,  2.200E0};
-const double thurber_functor::_y[37] = {
-    80.574E0,   84.248E0,   87.264E0,   87.195E0,   89.076E0,   89.608E0,   89.868E0,   90.101E0,
-    92.405E0,   95.854E0,   100.696E0,  101.060E0,  401.672E0,  390.724E0,  567.534E0,  635.316E0,
-    733.054E0,  759.087E0,  894.206E0,  990.785E0,  1090.109E0, 1080.914E0, 1122.643E0, 1178.351E0,
-    1260.531E0, 1273.514E0, 1288.339E0, 1327.543E0, 1353.863E0, 1414.509E0, 1425.208E0, 1421.384E0,
-    1442.962E0, 1464.350E0, 1468.705E0, 1447.894E0, 1457.628E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/thurber.shtml
-void testNistThurber(void) {
-  const int n = 7;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1000, 1000, 400, 40, 0.7, 0.3, 0.0;
-  // do the computation
-  thurber_functor functor;
-  LevenbergMarquardt<thurber_functor> lm(functor);
-  lm.parameters.ftol = 1.E4 * NumTraits<double>::epsilon();
-  lm.parameters.xtol = 1.E4 * NumTraits<double>::epsilon();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 39, 36);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6427082397E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
-  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
-  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
-  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
-  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
-  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
-  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
-
-  /*
-   * Second try
-   */
-  x << 1300, 1500, 500, 75, 1, 0.4, 0.05;
-  // do the computation
-  lm.resetParameters();
-  lm.parameters.ftol = 1.E4 * NumTraits<double>::epsilon();
-  lm.parameters.xtol = 1.E4 * NumTraits<double>::epsilon();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 29, 28);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 5.6427082397E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
-  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
-  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
-  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
-  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
-  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
-  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
-}
-
-struct rat43_functor : Functor<double> {
-  rat43_functor(void) : Functor<double>(4, 15) {}
-  static const double x[15];
-  static const double y[15];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 4);
-    assert(fvec.size() == 15);
-    for (int i = 0; i < 15; i++) fvec[i] = b[0] * pow(1. + exp(b[1] - b[2] * x[i]), -1. / b[3]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 4);
-    assert(fjac.rows() == 15);
-    assert(fjac.cols() == 4);
-    for (int i = 0; i < 15; i++) {
-      double e = exp(b[1] - b[2] * x[i]);
-      double power = -1. / b[3];
-      fjac(i, 0) = pow(1. + e, power);
-      fjac(i, 1) = power * b[0] * e * pow(1. + e, power - 1.);
-      fjac(i, 2) = -power * b[0] * e * x[i] * pow(1. + e, power - 1.);
-      fjac(i, 3) = b[0] * power * power * log(1. + e) * pow(1. + e, power);
-    }
-    return 0;
-  }
-};
-const double rat43_functor::x[15] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.};
-const double rat43_functor::y[15] = {16.08,  33.83,  65.80,  97.20,  191.55, 326.20, 386.87, 520.53,
-                                     590.03, 651.92, 724.93, 699.56, 689.96, 637.56, 717.41};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky3.shtml
-void testNistRat43(void) {
-  const int n = 4;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 100., 10., 1., 1.;
-  // do the computation
-  rat43_functor functor;
-  LevenbergMarquardt<rat43_functor> lm(functor);
-  lm.parameters.ftol = 1.E6 * NumTraits<double>::epsilon();
-  lm.parameters.xtol = 1.E6 * NumTraits<double>::epsilon();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 27, 20);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7864049080E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
-  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
-  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
-  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
-
-  /*
-   * Second try
-   */
-  x << 700., 5., 0.75, 1.3;
-  // do the computation
-  lm.resetParameters();
-  lm.parameters.ftol = 1.E5 * NumTraits<double>::epsilon();
-  lm.parameters.xtol = 1.E5 * NumTraits<double>::epsilon();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 9, 8);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 8.7864049080E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
-  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
-  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
-  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
-}
-
-struct eckerle4_functor : Functor<double> {
-  eckerle4_functor(void) : Functor<double>(3, 35) {}
-  static const double x[35];
-  static const double y[35];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 35);
-    for (int i = 0; i < 35; i++)
-      fvec[i] = b[0] / b[1] * exp(-0.5 * (x[i] - b[2]) * (x[i] - b[2]) / (b[1] * b[1])) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 35);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 35; i++) {
-      double b12 = b[1] * b[1];
-      double e = exp(-0.5 * (x[i] - b[2]) * (x[i] - b[2]) / b12);
-      fjac(i, 0) = e / b[1];
-      fjac(i, 1) = ((x[i] - b[2]) * (x[i] - b[2]) / b12 - 1.) * b[0] * e / b12;
-      fjac(i, 2) = (x[i] - b[2]) * e * b[0] / b[1] / b12;
-    }
-    return 0;
-  }
-};
-const double eckerle4_functor::x[35] = {400.0, 405.0, 410.0, 415.0, 420.0, 425.0, 430.0, 435.0, 436.5,
-                                        438.0, 439.5, 441.0, 442.5, 444.0, 445.5, 447.0, 448.5, 450.0,
-                                        451.5, 453.0, 454.5, 456.0, 457.5, 459.0, 460.5, 462.0, 463.5,
-                                        465.0, 470.0, 475.0, 480.0, 485.0, 490.0, 495.0, 500.0};
-const double eckerle4_functor::y[35] = {0.0001575, 0.0001699, 0.0002350, 0.0003102, 0.0004917, 0.0008710, 0.0017418,
-                                        0.0046400, 0.0065895, 0.0097302, 0.0149002, 0.0237310, 0.0401683, 0.0712559,
-                                        0.1264458, 0.2073413, 0.2902366, 0.3445623, 0.3698049, 0.3668534, 0.3106727,
-                                        0.2078154, 0.1164354, 0.0616764, 0.0337200, 0.0194023, 0.0117831, 0.0074357,
-                                        0.0022732, 0.0008800, 0.0004579, 0.0002345, 0.0001586, 0.0001143, 0.0000710};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/eckerle4.shtml
-void testNistEckerle4(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1., 10., 500.;
-  // do the computation
-  eckerle4_functor functor;
-  LevenbergMarquardt<eckerle4_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 18, 15);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.4635887487E-03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.5543827178);
-  VERIFY_IS_APPROX(x[1], 4.0888321754);
-  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
-
-  /*
-   * Second try
-   */
-  x << 1.5, 5., 450.;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  LM_CHECK_N_ITERS(lm, 7, 6);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec.squaredNorm(), 1.4635887487E-03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.5543827178);
-  VERIFY_IS_APPROX(x[1], 4.0888321754);
-  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
-}
-
-EIGEN_DECLARE_TEST(NonLinearOptimization) {
-  // Tests using the examples provided by (c)minpack
-  CALL_SUBTEST /*_1*/ (testChkder());
-  CALL_SUBTEST /*_1*/ (testLmder1());
-  CALL_SUBTEST /*_1*/ (testLmder());
-  CALL_SUBTEST /*_2*/ (testHybrj1());
-  CALL_SUBTEST /*_2*/ (testHybrj());
-  CALL_SUBTEST /*_2*/ (testHybrd1());
-  CALL_SUBTEST /*_2*/ (testHybrd());
-  CALL_SUBTEST /*_3*/ (testLmstr1());
-  CALL_SUBTEST /*_3*/ (testLmstr());
-  CALL_SUBTEST /*_3*/ (testLmdif1());
-  CALL_SUBTEST /*_3*/ (testLmdif());
-
-  // NIST tests, level of difficulty = "Lower"
-  CALL_SUBTEST /*_4*/ (testNistMisra1a());
-  CALL_SUBTEST /*_4*/ (testNistChwirut2());
-
-  // NIST tests, level of difficulty = "Average"
-  CALL_SUBTEST /*_5*/ (testNistHahn1());
-  CALL_SUBTEST /*_6*/ (testNistMisra1d());
-  CALL_SUBTEST /*_7*/ (testNistMGH17());
-  CALL_SUBTEST /*_8*/ (testNistLanczos1());
-
-  //     // NIST tests, level of difficulty = "Higher"
-  CALL_SUBTEST /*_9*/ (testNistRat42());
-  //     CALL_SUBTEST/*_10*/(testNistMGH10());
-  CALL_SUBTEST /*_11*/ (testNistBoxBOD());
-  //     CALL_SUBTEST/*_12*/(testNistMGH09());
-  CALL_SUBTEST /*_13*/ (testNistBennett5());
-  CALL_SUBTEST /*_14*/ (testNistThurber());
-  CALL_SUBTEST /*_15*/ (testNistRat43());
-  CALL_SUBTEST /*_16*/ (testNistEckerle4());
-}
-
-/*
- * Can be useful for debugging...
-  printf("info, nfev : %d, %d\n", info, lm.nfev);
-  printf("info, nfev, njev : %d, %d, %d\n", info, solver.nfev, solver.njev);
-  printf("info, nfev : %d, %d\n", info, solver.nfev);
-  printf("x[0] : %.32g\n", x[0]);
-  printf("x[1] : %.32g\n", x[1]);
-  printf("x[2] : %.32g\n", x[2]);
-  printf("x[3] : %.32g\n", x[3]);
-  printf("fvec.blueNorm() : %.32g\n", solver.fvec.blueNorm());
-  printf("fvec.blueNorm() : %.32g\n", lm.fvec.blueNorm());
-
-  printf("info, nfev, njev : %d, %d, %d\n", info, lm.nfev, lm.njev);
-  printf("fvec.squaredNorm() : %.13g\n", lm.fvec.squaredNorm());
-  std::cout << x << std::endl;
-  std::cout.precision(9);
-  std::cout << x[0] << std::endl;
-  std::cout << x[1] << std::endl;
-  std::cout << x[2] << std::endl;
-  std::cout << x[3] << std::endl;
-*/
diff --git a/unsupported/test/NumericalDiff.cpp b/unsupported/test/NumericalDiff.cpp
deleted file mode 100644
index 543f34f..0000000
--- a/unsupported/test/NumericalDiff.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-
-#include <stdio.h>
-
-#include "main.h"
-#include <unsupported/Eigen/NumericalDiff>
-
-// Generic functor
-template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
-struct Functor {
-  typedef Scalar_ Scalar;
-  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-
-  int m_inputs, m_values;
-
-  Functor() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
-  Functor(int inputs_, int values_) : m_inputs(inputs_), m_values(values_) {}
-
-  int inputs() const { return m_inputs; }
-  int values() const { return m_values; }
-};
-
-struct my_functor : Functor<double> {
-  my_functor(void) : Functor<double>(3, 15) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) const {
-    double tmp1, tmp2, tmp3;
-    double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                    3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
-
-    for (int i = 0; i < values(); i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-    return 0;
-  }
-
-  int actual_df(const VectorXd &x, MatrixXd &fjac) const {
-    double tmp1, tmp2, tmp3, tmp4;
-    for (int i = 0; i < values(); i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
-      tmp4 = tmp4 * tmp4;
-      fjac(i, 0) = -1;
-      fjac(i, 1) = tmp1 * tmp2 / tmp4;
-      fjac(i, 2) = tmp1 * tmp3 / tmp4;
-    }
-    return 0;
-  }
-};
-
-void test_forward() {
-  VectorXd x(3);
-  MatrixXd jac(15, 3);
-  MatrixXd actual_jac(15, 3);
-  my_functor functor;
-
-  x << 0.082, 1.13, 2.35;
-
-  // real one
-  functor.actual_df(x, actual_jac);
-  //    std::cout << actual_jac << std::endl << std::endl;
-
-  // using NumericalDiff
-  NumericalDiff<my_functor> numDiff(functor);
-  numDiff.df(x, jac);
-  //    std::cout << jac << std::endl;
-
-  VERIFY_IS_APPROX(jac, actual_jac);
-}
-
-void test_central() {
-  VectorXd x(3);
-  MatrixXd jac(15, 3);
-  MatrixXd actual_jac(15, 3);
-  my_functor functor;
-
-  x << 0.082, 1.13, 2.35;
-
-  // real one
-  functor.actual_df(x, actual_jac);
-
-  // using NumericalDiff
-  NumericalDiff<my_functor, Central> numDiff(functor);
-  numDiff.df(x, jac);
-
-  VERIFY_IS_APPROX(jac, actual_jac);
-}
-
-EIGEN_DECLARE_TEST(NumericalDiff) {
-  CALL_SUBTEST(test_forward());
-  CALL_SUBTEST(test_central());
-}
diff --git a/unsupported/test/alignedvector3.cpp b/unsupported/test/alignedvector3.cpp
deleted file mode 100644
index 838eaea..0000000
--- a/unsupported/test/alignedvector3.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_NO_STATIC_ASSERT
-
-#include "main.h"
-#include <unsupported/Eigen/AlignedVector3>
-
-namespace Eigen {
-
-template <typename T, typename Derived>
-T test_relative_error(const AlignedVector3<T> &a, const MatrixBase<Derived> &b) {
-  return test_relative_error(a.coeffs().template head<3>(), b);
-}
-
-}  // namespace Eigen
-
-template <typename Scalar>
-void alignedvector3() {
-  Scalar s1 = internal::random<Scalar>();
-  Scalar s2 = internal::random<Scalar>();
-  typedef Matrix<Scalar, 3, 1> RefType;
-  typedef Matrix<Scalar, 3, 3> Mat33;
-  typedef AlignedVector3<Scalar> FastType;
-  RefType r1(RefType::Random()), r2(RefType::Random()), r3(RefType::Random()), r4(RefType::Random()),
-      r5(RefType::Random());
-  FastType f1(r1), f2(r2), f3(r3), f4(r4), f5(r5);
-  Mat33 m1(Mat33::Random());
-
-  VERIFY_IS_APPROX(f1, r1);
-  VERIFY_IS_APPROX(f4, r4);
-
-  VERIFY_IS_APPROX(f4 + f1, r4 + r1);
-  VERIFY_IS_APPROX(f4 - f1, r4 - r1);
-  VERIFY_IS_APPROX(f4 + f1 - f2, r4 + r1 - r2);
-  VERIFY_IS_APPROX(f4 += f3, r4 += r3);
-  VERIFY_IS_APPROX(f4 -= f5, r4 -= r5);
-  VERIFY_IS_APPROX(f4 -= f5 + f1, r4 -= r5 + r1);
-  VERIFY_IS_APPROX(f5 + f1 - s1 * f2, r5 + r1 - s1 * r2);
-  VERIFY_IS_APPROX(f5 + f1 / s2 - s1 * f2, r5 + r1 / s2 - s1 * r2);
-
-  VERIFY_IS_APPROX(m1 * f4, m1 * r4);
-  VERIFY_IS_APPROX(f4.transpose() * m1, r4.transpose() * m1);
-
-  VERIFY_IS_APPROX(f2.dot(f3), r2.dot(r3));
-  VERIFY_IS_APPROX(f2.cross(f3), r2.cross(r3));
-  VERIFY_IS_APPROX(f2.norm(), r2.norm());
-
-  VERIFY_IS_APPROX(f2.normalized(), r2.normalized());
-
-  VERIFY_IS_APPROX((f2 + f1).normalized(), (r2 + r1).normalized());
-
-  f2.normalize();
-  r2.normalize();
-  VERIFY_IS_APPROX(f2, r2);
-
-  {
-    FastType f6 = RefType::Zero();
-    FastType f7 = FastType::Zero();
-    VERIFY_IS_APPROX(f6, f7);
-    f6 = r4 + r1;
-    VERIFY_IS_APPROX(f6, r4 + r1);
-    f6 -= Scalar(2) * r4;
-    VERIFY_IS_APPROX(f6, r1 - r4);
-  }
-
-  FastType f8, f9(0, 0, 0);
-  VERIFY_IS_APPROX(f9 - f1, -f1);
-
-  std::stringstream ss1, ss2;
-  ss1 << f1;
-  ss2 << r1;
-  VERIFY(ss1.str() == ss2.str());
-}
-
-EIGEN_DECLARE_TEST(alignedvector3) {
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST(alignedvector3<float>());
-  }
-}
diff --git a/unsupported/test/autodiff.cpp b/unsupported/test/autodiff.cpp
deleted file mode 100644
index a885a1e..0000000
--- a/unsupported/test/autodiff.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/AutoDiff>
-
-template <typename Scalar>
-EIGEN_DONT_INLINE Scalar foo(const Scalar& x, const Scalar& y) {
-  using namespace std;
-  //   return x+std::sin(y);
-  EIGEN_ASM_COMMENT("mybegin");
-  // pow(float, int) promotes to pow(double, double)
-  return x * 2 - 1 + static_cast<Scalar>(pow(1 + x, 2)) + 2 * sqrt(y * y + 0) - 4 * sin(0 + x) + 2 * cos(y + 0) -
-         exp(Scalar(-0.5) * x * x + 0);
-  // return x+2*y*x;//x*2 -std::pow(x,2);//(2*y/x);// - y*2;
-  EIGEN_ASM_COMMENT("myend");
-}
-
-template <typename Vector>
-EIGEN_DONT_INLINE typename Vector::Scalar foo(const Vector& p) {
-  typedef typename Vector::Scalar Scalar;
-  return (p - Vector(Scalar(-1), Scalar(1.))).norm() + (p.array() * p.array()).sum() + p.dot(p);
-}
-
-template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
-struct TestFunc1 {
-  typedef Scalar_ Scalar;
-  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-
-  int m_inputs, m_values;
-
-  TestFunc1() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
-  TestFunc1(int inputs_, int values_) : m_inputs(inputs_), m_values(values_) {}
-
-  int inputs() const { return m_inputs; }
-  int values() const { return m_values; }
-
-  template <typename T>
-  void operator()(const Matrix<T, InputsAtCompileTime, 1>& x, Matrix<T, ValuesAtCompileTime, 1>* _v) const {
-    Matrix<T, ValuesAtCompileTime, 1>& v = *_v;
-
-    v[0] = 2 * x[0] * x[0] + x[0] * x[1];
-    v[1] = 3 * x[1] * x[0] + 0.5 * x[1] * x[1];
-    if (inputs() > 2) {
-      v[0] += 0.5 * x[2];
-      v[1] += x[2];
-    }
-    if (values() > 2) {
-      v[2] = 3 * x[1] * x[0] * x[0];
-    }
-    if (inputs() > 2 && values() > 2) v[2] *= x[2];
-  }
-
-  void operator()(const InputType& x, ValueType* v, JacobianType* _j) const {
-    (*this)(x, v);
-
-    if (_j) {
-      JacobianType& j = *_j;
-
-      j(0, 0) = 4 * x[0] + x[1];
-      j(1, 0) = 3 * x[1];
-
-      j(0, 1) = x[0];
-      j(1, 1) = 3 * x[0] + 2 * 0.5 * x[1];
-
-      if (inputs() > 2) {
-        j(0, 2) = 0.5;
-        j(1, 2) = 1;
-      }
-      if (values() > 2) {
-        j(2, 0) = 3 * x[1] * 2 * x[0];
-        j(2, 1) = 3 * x[0] * x[0];
-      }
-      if (inputs() > 2 && values() > 2) {
-        j(2, 0) *= x[2];
-        j(2, 1) *= x[2];
-
-        j(2, 2) = 3 * x[1] * x[0] * x[0];
-        j(2, 2) = 3 * x[1] * x[0] * x[0];
-      }
-    }
-  }
-};
-
-/* Test functor for the C++11 features. */
-template <typename Scalar>
-struct integratorFunctor {
-  typedef Matrix<Scalar, 2, 1> InputType;
-  typedef Matrix<Scalar, 2, 1> ValueType;
-
-  /*
-   * Implementation starts here.
-   */
-  integratorFunctor(const Scalar gain) : _gain(gain) {}
-  integratorFunctor(const integratorFunctor& f) : _gain(f._gain) {}
-  const Scalar _gain;
-
-  template <typename T1, typename T2>
-  void operator()(const T1& input, T2* output, const Scalar dt) const {
-    T2& o = *output;
-
-    /* Integrator to test the AD. */
-    o[0] = input[0] + input[1] * dt * _gain;
-    o[1] = input[1] * _gain;
-  }
-
-  /* Only needed for the test */
-  template <typename T1, typename T2, typename T3>
-  void operator()(const T1& input, T2* output, T3* jacobian, const Scalar dt) const {
-    T2& o = *output;
-
-    /* Integrator to test the AD. */
-    o[0] = input[0] + input[1] * dt * _gain;
-    o[1] = input[1] * _gain;
-
-    if (jacobian) {
-      T3& j = *jacobian;
-
-      j(0, 0) = 1;
-      j(0, 1) = dt * _gain;
-      j(1, 0) = 0;
-      j(1, 1) = _gain;
-    }
-  }
-};
-
-template <typename Func>
-void forward_jacobian_cpp11(const Func& f) {
-  typedef typename Func::ValueType::Scalar Scalar;
-  typedef typename Func::ValueType ValueType;
-  typedef typename Func::InputType InputType;
-  typedef typename AutoDiffJacobian<Func>::JacobianType JacobianType;
-
-  InputType x = InputType::Random(InputType::RowsAtCompileTime);
-  ValueType y, yref;
-  JacobianType j, jref;
-
-  const Scalar dt = internal::random<double>();
-
-  jref.setZero();
-  yref.setZero();
-  f(x, &yref, &jref, dt);
-
-  // std::cerr << "y, yref, jref: " << "\n";
-  // std::cerr << y.transpose() << "\n\n";
-  // std::cerr << yref << "\n\n";
-  // std::cerr << jref << "\n\n";
-
-  AutoDiffJacobian<Func> autoj(f);
-  autoj(x, &y, &j, dt);
-
-  // std::cerr << "y j (via autodiff): " << "\n";
-  // std::cerr << y.transpose() << "\n\n";
-  // std::cerr << j << "\n\n";
-
-  VERIFY_IS_APPROX(y, yref);
-  VERIFY_IS_APPROX(j, jref);
-}
-
-template <typename Func>
-void forward_jacobian(const Func& f) {
-  typename Func::InputType x = Func::InputType::Random(f.inputs());
-  typename Func::ValueType y(f.values()), yref(f.values());
-  typename Func::JacobianType j(f.values(), f.inputs()), jref(f.values(), f.inputs());
-
-  jref.setZero();
-  yref.setZero();
-  f(x, &yref, &jref);
-
-  j.setZero();
-  y.setZero();
-  AutoDiffJacobian<Func> autoj(f);
-  autoj(x, &y, &j);
-
-  VERIFY_IS_APPROX(y, yref);
-  VERIFY_IS_APPROX(j, jref);
-}
-
-// TODO also check actual derivatives!
-template <int>
-void test_autodiff_scalar() {
-  Vector2f p = Vector2f::Random();
-  typedef AutoDiffScalar<Vector2f> AD;
-  AD ax(p.x(), Vector2f::UnitX());
-  AD ay(p.y(), Vector2f::UnitY());
-  AD res = foo<AD>(ax, ay);
-  VERIFY_IS_APPROX(res.value(), foo(p.x(), p.y()));
-}
-
-// TODO also check actual derivatives!
-template <int>
-void test_autodiff_vector() {
-  Vector2f p = Vector2f::Random();
-  typedef AutoDiffScalar<Vector2f> AD;
-  typedef Matrix<AD, 2, 1> VectorAD;
-  VectorAD ap = p.cast<AD>();
-  ap.x().derivatives() = Vector2f::UnitX();
-  ap.y().derivatives() = Vector2f::UnitY();
-
-  AD res = foo<VectorAD>(ap);
-  VERIFY_IS_APPROX(res.value(), foo(p));
-}
-
-template <int>
-void test_autodiff_jacobian() {
-  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 2, 2>())));
-  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 2, 3>())));
-  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 3, 2>())));
-  CALL_SUBTEST((forward_jacobian(TestFunc1<double, 3, 3>())));
-  CALL_SUBTEST((forward_jacobian(TestFunc1<double>(3, 3))));
-  CALL_SUBTEST((forward_jacobian_cpp11(integratorFunctor<double>(10))));
-}
-
-template <int>
-void test_autodiff_hessian() {
-  typedef AutoDiffScalar<VectorXd> AD;
-  typedef Matrix<AD, Eigen::Dynamic, 1> VectorAD;
-  typedef AutoDiffScalar<VectorAD> ADD;
-  typedef Matrix<ADD, Eigen::Dynamic, 1> VectorADD;
-  VectorADD x(2);
-  double s1 = internal::random<double>(), s2 = internal::random<double>(), s3 = internal::random<double>(),
-         s4 = internal::random<double>();
-  x(0).value() = s1;
-  x(1).value() = s2;
-
-  // set unit vectors for the derivative directions (partial derivatives of the input vector)
-  x(0).derivatives().resize(2);
-  x(0).derivatives().setZero();
-  x(0).derivatives()(0) = 1;
-  x(1).derivatives().resize(2);
-  x(1).derivatives().setZero();
-  x(1).derivatives()(1) = 1;
-
-  // repeat partial derivatives for the inner AutoDiffScalar
-  x(0).value().derivatives() = VectorXd::Unit(2, 0);
-  x(1).value().derivatives() = VectorXd::Unit(2, 1);
-
-  // set the hessian matrix to zero
-  for (int idx = 0; idx < 2; idx++) {
-    x(0).derivatives()(idx).derivatives() = VectorXd::Zero(2);
-    x(1).derivatives()(idx).derivatives() = VectorXd::Zero(2);
-  }
-
-  ADD y = sin(AD(s3) * x(0) + AD(s4) * x(1));
-
-  VERIFY_IS_APPROX(y.value().derivatives()(0), y.derivatives()(0).value());
-  VERIFY_IS_APPROX(y.value().derivatives()(1), y.derivatives()(1).value());
-  VERIFY_IS_APPROX(y.value().derivatives()(0), s3 * std::cos(s1 * s3 + s2 * s4));
-  VERIFY_IS_APPROX(y.value().derivatives()(1), s4 * std::cos(s1 * s3 + s2 * s4));
-  VERIFY_IS_APPROX(y.derivatives()(0).derivatives(), -std::sin(s1 * s3 + s2 * s4) * Vector2d(s3 * s3, s4 * s3));
-  VERIFY_IS_APPROX(y.derivatives()(1).derivatives(), -std::sin(s1 * s3 + s2 * s4) * Vector2d(s3 * s4, s4 * s4));
-
-  ADD z = x(0) * x(1);
-  VERIFY_IS_APPROX(z.derivatives()(0).derivatives(), Vector2d(0, 1));
-  VERIFY_IS_APPROX(z.derivatives()(1).derivatives(), Vector2d(1, 0));
-}
-
-double bug_1222() {
-  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;
-  const double _cv1_3 = 1.0;
-  const AD chi_3 = 1.0;
-  // this line did not work, because operator+ returns ADS<DerType&>, which then cannot be converted to ADS<DerType>
-  const AD denom = chi_3 + _cv1_3;
-  return denom.value();
-}
-
-double bug_1223() {
-  using std::min;
-  typedef Eigen::AutoDiffScalar<Eigen::Vector3d> AD;
-
-  const double _cv1_3 = 1.0;
-  const AD chi_3 = 1.0;
-  const AD denom = 1.0;
-
-// failed because implementation of min attempts to construct ADS<DerType&> via constructor AutoDiffScalar(const Real&
-// value) without initializing m_derivatives (which is a reference in this case)
-#define EIGEN_TEST_SPACE
-  const AD t = min EIGEN_TEST_SPACE(denom / chi_3, 1.0);
-
-  const AD t2 = min EIGEN_TEST_SPACE(denom / (chi_3 * _cv1_3), 1.0);
-
-  return t.value() + t2.value();
-}
-
-// regression test for some compilation issues with specializations of ScalarBinaryOpTraits
-void bug_1260() {
-  Matrix4d A = Matrix4d::Ones();
-  Vector4d v = Vector4d::Ones();
-  A* v;
-}
-
-// check a compilation issue with numext::max
-double bug_1261() {
-  typedef AutoDiffScalar<Matrix2d> AD;
-  typedef Matrix<AD, 2, 1> VectorAD;
-
-  VectorAD v(0., 0.);
-  const AD maxVal = v.maxCoeff();
-  const AD minVal = v.minCoeff();
-  return maxVal.value() + minVal.value();
-}
-
-double bug_1264() {
-  typedef AutoDiffScalar<Vector2d> AD;
-  const AD s = 0.;
-  const Matrix<AD, 3, 1> v1(0., 0., 0.);
-  const Matrix<AD, 3, 1> v2 = (s + 3.0) * v1;
-  return v2(0).value();
-}
-
-// check with expressions on constants
-double bug_1281() {
-  int n = 2;
-  typedef AutoDiffScalar<VectorXd> AD;
-  const AD c = 1.;
-  AD x0(2, n, 0);
-  AD y1 = (AD(c) + AD(c)) * x0;
-  y1 = x0 * (AD(c) + AD(c));
-  AD y2 = (-AD(c)) + x0;
-  y2 = x0 + (-AD(c));
-  AD y3 = (AD(c) * (-AD(c)) + AD(c)) * x0;
-  y3 = x0 * (AD(c) * (-AD(c)) + AD(c));
-  return (y1 + y2 + y3).value();
-}
-
-EIGEN_DECLARE_TEST(autodiff) {
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_1(test_autodiff_scalar<1>());
-    CALL_SUBTEST_2(test_autodiff_vector<1>());
-    CALL_SUBTEST_3(test_autodiff_jacobian<1>());
-    CALL_SUBTEST_4(test_autodiff_hessian<1>());
-  }
-
-  CALL_SUBTEST_5(bug_1222());
-  CALL_SUBTEST_5(bug_1223());
-  CALL_SUBTEST_5(bug_1260());
-  CALL_SUBTEST_5(bug_1261());
-  CALL_SUBTEST_5(bug_1281());
-}
diff --git a/unsupported/test/autodiff_scalar.cpp b/unsupported/test/autodiff_scalar.cpp
deleted file mode 100644
index a0bff91..0000000
--- a/unsupported/test/autodiff_scalar.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christoph Hertzberg <chtz@informatik.uni-bremen.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/AutoDiff>
-
-/*
- * In this file scalar derivations are tested for correctness.
- * TODO add more tests!
- */
-
-template <typename Scalar>
-void check_atan2() {
-  typedef Matrix<Scalar, 1, 1> Deriv1;
-  typedef AutoDiffScalar<Deriv1> AD;
-
-  AD x(internal::random<Scalar>(-3.0, 3.0), Deriv1::UnitX());
-
-  using std::exp;
-  Scalar r = exp(internal::random<Scalar>(-10, 10));
-
-  AD s = sin(x), c = cos(x);
-  AD res = atan2(r * s, r * c);
-
-  VERIFY_IS_APPROX(res.value(), x.value());
-  VERIFY_IS_APPROX(res.derivatives(), x.derivatives());
-
-  res = atan2(r * s + 0, r * c + 0);
-  VERIFY_IS_APPROX(res.value(), x.value());
-  VERIFY_IS_APPROX(res.derivatives(), x.derivatives());
-}
-
-template <typename Scalar>
-void check_hyperbolic_functions() {
-  using std::cosh;
-  using std::sinh;
-  using std::tanh;
-  typedef Matrix<Scalar, 1, 1> Deriv1;
-  typedef AutoDiffScalar<Deriv1> AD;
-  Deriv1 p = Deriv1::Random();
-  AD val(p.x(), Deriv1::UnitX());
-
-  Scalar cosh_px = std::cosh(p.x());
-  AD res1 = tanh(val);
-  VERIFY_IS_APPROX(res1.value(), std::tanh(p.x()));
-  VERIFY_IS_APPROX(res1.derivatives().x(), Scalar(1.0) / (cosh_px * cosh_px));
-
-  AD res2 = sinh(val);
-  VERIFY_IS_APPROX(res2.value(), std::sinh(p.x()));
-  VERIFY_IS_APPROX(res2.derivatives().x(), cosh_px);
-
-  AD res3 = cosh(val);
-  VERIFY_IS_APPROX(res3.value(), cosh_px);
-  VERIFY_IS_APPROX(res3.derivatives().x(), std::sinh(p.x()));
-
-  // Check constant values.
-  const Scalar sample_point = Scalar(1) / Scalar(3);
-  val = AD(sample_point, Deriv1::UnitX());
-  res1 = tanh(val);
-  VERIFY_IS_APPROX(res1.derivatives().x(), Scalar(0.896629559604914));
-
-  res2 = sinh(val);
-  VERIFY_IS_APPROX(res2.derivatives().x(), Scalar(1.056071867829939));
-
-  res3 = cosh(val);
-  VERIFY_IS_APPROX(res3.derivatives().x(), Scalar(0.339540557256150));
-}
-
-template <typename Scalar>
-void check_limits_specialization() {
-  typedef Eigen::Matrix<Scalar, 1, 1> Deriv;
-  typedef Eigen::AutoDiffScalar<Deriv> AD;
-
-  typedef std::numeric_limits<AD> A;
-  typedef std::numeric_limits<Scalar> B;
-
-  // workaround "unused typedef" warning:
-  VERIFY(!bool(internal::is_same<B, A>::value));
-
-  VERIFY(bool(std::is_base_of<B, A>::value));
-}
-
-EIGEN_DECLARE_TEST(autodiff_scalar) {
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_1(check_atan2<float>());
-    CALL_SUBTEST_2(check_atan2<double>());
-    CALL_SUBTEST_3(check_hyperbolic_functions<float>());
-    CALL_SUBTEST_4(check_hyperbolic_functions<double>());
-    CALL_SUBTEST_5(check_limits_specialization<double>());
-  }
-}
diff --git a/unsupported/test/bessel_functions.cpp b/unsupported/test/bessel_functions.cpp
deleted file mode 100644
index 86adfc1..0000000
--- a/unsupported/test/bessel_functions.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include "../Eigen/SpecialFunctions"
-
-template <typename X, typename Y>
-void verify_component_wise(const X& x, const Y& y) {
-  for (Index i = 0; i < x.size(); ++i) {
-    if ((numext::isfinite)(y(i))) {
-      VERIFY_IS_APPROX(x(i), y(i));
-    } else if ((numext::isnan)(y(i)))
-      VERIFY((numext::isnan)(x(i)));
-    else
-      VERIFY_IS_EQUAL(x(i), y(i));
-  }
-}
-
-template <typename ArrayType>
-void array_bessel_functions() {
-  // Test Bessel function i0. Reference results obtained with SciPy.
-  {
-    ArrayType x(21);
-    ArrayType expected(21);
-    ArrayType res(21);
-
-    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
-        16.0, 18.0, 20.0;
-
-    expected << 4.35582826e+07, 6.21841242e+06, 8.93446228e+05, 1.29418563e+05, 1.89489253e+04, 2.81571663e+03,
-        4.27564116e+02, 6.72344070e+01, 1.13019220e+01, 2.27958530e+00, 1.00000000e+00, 2.27958530e+00, 1.13019220e+01,
-        6.72344070e+01, 4.27564116e+02, 2.81571663e+03, 1.89489253e+04, 1.29418563e+05, 8.93446228e+05, 6.21841242e+06,
-        4.35582826e+07;
-
-    CALL_SUBTEST(res = bessel_i0(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function i0e. Reference results obtained with SciPy.
-  {
-    ArrayType x(21);
-    ArrayType expected(21);
-    ArrayType res(21);
-
-    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
-        16.0, 18.0, 20.0;
-
-    expected << 0.0897803118848, 0.0947062952128, 0.100544127361, 0.107615251671, 0.116426221213, 0.127833337163,
-        0.143431781857, 0.16665743264, 0.207001921224, 0.308508322554, 1.0, 0.308508322554, 0.207001921224,
-        0.16665743264, 0.143431781857, 0.127833337163, 0.116426221213, 0.107615251671, 0.100544127361, 0.0947062952128,
-        0.0897803118848;
-
-    CALL_SUBTEST(res = bessel_i0e(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function i1. Reference results obtained with SciPy.
-  {
-    ArrayType x(21);
-    ArrayType expected(21);
-    ArrayType res(21);
-
-    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
-        16.0, 18.0, 20.0;
-
-    expected << -4.24549734e+07, -6.04313324e+06, -8.65059436e+05, -1.24707259e+05, -1.81413488e+04, -2.67098830e+03,
-        -3.99873137e+02, -6.13419368e+01, -9.75946515e+00, -1.59063685e+00, 0.00000000e+00, 1.59063685e+00,
-        9.75946515e+00, 6.13419368e+01, 3.99873137e+02, 2.67098830e+03, 1.81413488e+04, 1.24707259e+05, 8.65059436e+05,
-        6.04313324e+06, 4.24549734e+07;
-
-    CALL_SUBTEST(res = bessel_i1(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function i1e. Reference results obtained with SciPy.
-  {
-    ArrayType x(21);
-    ArrayType expected(21);
-    ArrayType res(21);
-
-    x << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0,
-        16.0, 18.0, 20.0;
-
-    expected << -0.0875062221833, -0.092036796872, -0.0973496147565, -0.103697667463, -0.11146429929, -0.121262681384,
-        -0.134142493293, -0.152051459309, -0.178750839502, -0.215269289249, 0.0, 0.215269289249, 0.178750839502,
-        0.152051459309, 0.134142493293, 0.121262681384, 0.11146429929, 0.103697667463, 0.0973496147565, 0.092036796872,
-        0.0875062221833;
-
-    CALL_SUBTEST(res = bessel_i1e(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function j0. Reference results obtained with SciPy.
-  {
-    ArrayType x(77);
-    ArrayType expected(77);
-    ArrayType res(77);
-
-    x << -38., -37., -36., -35., -34., -33., -32., -31., -30., -29., -28., -27., -26., -25., -24., -23., -22., -21.,
-        -20., -19., -18., -17., -16., -15., -14., -13., -12., -11., -10., -9., -8., -7., -6., -5., -4., -3., -2., -1.,
-        0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23.,
-        24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38.;
-
-    expected << 0.11433274, 0.01086237, -0.10556738, -0.12684568, -0.03042119, 0.09727067, 0.13807901, 0.05120815,
-        -0.08636798, -0.14784876, -0.07315701, 0.07274192, 0.15599932, 0.09626678, -0.05623027, -0.16241278,
-        -0.12065148, 0.03657907, 0.16702466, 0.14662944, -0.01335581, -0.16985425, -0.17489907, -0.01422447, 0.17107348,
-        0.2069261, 0.04768931, -0.1711903, -0.24593576, -0.09033361, 0.17165081, 0.30007927, 0.15064526, -0.17759677,
-        -0.39714981, -0.26005195, 0.22389078, 0.76519769, 1., 0.76519769, 0.22389078, -0.26005195, -0.39714981,
-        -0.17759677, 0.15064526, 0.30007927, 0.17165081, -0.09033361, -0.24593576, -0.1711903, 0.04768931, 0.2069261,
-        0.17107348, -0.01422447, -0.17489907, -0.16985425, -0.01335581, 0.14662944, 0.16702466, 0.03657907, -0.12065148,
-        -0.16241278, -0.05623027, 0.09626678, 0.15599932, 0.07274192, -0.07315701, -0.14784876, -0.08636798, 0.05120815,
-        0.13807901, 0.09727067, -0.03042119, -0.12684568, -0.10556738, 0.01086237, 0.11433274;
-
-    CALL_SUBTEST(res = bessel_j0(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function j1. Reference results obtained with SciPy.
-  {
-    ArrayType x(81);
-    ArrayType expected(81);
-    ArrayType res(81);
-
-    x << -40., -39., -38., -37., -36., -35., -34., -33., -32., -31., -30., -29., -28., -27., -26., -25., -24., -23.,
-        -22., -21., -20., -19., -18., -17., -16., -15., -14., -13., -12., -11., -10., -9., -8., -7., -6., -5., -4., -3.,
-        -2., -1., 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21.,
-        22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << -0.12603832, -0.0640561, 0.05916189, 0.13058004, 0.08232981, -0.04399094, -0.13297118, -0.10061965,
-        0.02658903, 0.13302432, 0.11875106, -0.0069342, -0.13055149, -0.13658472, -0.01504573, 0.12535025, 0.15403807,
-        0.03951932, -0.11717779, -0.17112027, -0.06683312, 0.10570143, 0.18799489, 0.09766849, -0.09039718, -0.20510404,
-        -0.13337515, 0.07031805, 0.2234471, 0.1767853, -0.04347275, -0.24531179, -0.23463635, 0.00468282, 0.27668386,
-        0.32757914, 0.06604333, -0.33905896, -0.57672481, -0.44005059, 0., 0.44005059, 0.57672481, 0.33905896,
-        -0.06604333, -0.32757914, -0.27668386, -0.00468282, 0.23463635, 0.24531179, 0.04347275, -0.1767853, -0.2234471,
-        -0.07031805, 0.13337515, 0.20510404, 0.09039718, -0.09766849, -0.18799489, -0.10570143, 0.06683312, 0.17112027,
-        0.11717779, -0.03951932, -0.15403807, -0.12535025, 0.01504573, 0.13658472, 0.13055149, 0.0069342, -0.11875106,
-        -0.13302432, -0.02658903, 0.10061965, 0.13297118, 0.04399094, -0.08232981, -0.13058004, -0.05916189, 0.0640561,
-        0.12603832;
-
-    CALL_SUBTEST(res = bessel_j1(x); verify_component_wise(res, expected););
-  }
-  // Test Bessel function k0e. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << 1.97933385, 1.52410939, 1.14446308, 0.84156822, 0.6977616, 0.60929767, 0.54780756, 0.50186313,
-        0.4658451, 0.43662302, 0.41229555, 0.39163193, 0.3737955, 0.35819488, 0.34439865, 0.33208364, 0.32100235,
-        0.31096159, 0.30180802, 0.29341821, 0.28569149, 0.27854488, 0.2719092, 0.26572635, 0.25994703, 0.25452917,
-        0.2494366, 0.24463801, 0.24010616, 0.23581722, 0.23175022, 0.22788667, 0.22421014, 0.22070602, 0.21736123,
-        0.21416406, 0.21110397, 0.20817141, 0.20535778, 0.20265524, 0.20005668, 0.19755558;
-
-    CALL_SUBTEST(res = bessel_k0e(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function k0. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << 1.54150675, 0.92441907, 4.21024438e-01, 1.13893873e-01, 3.47395044e-02, 1.11596761e-02, 3.69109833e-03,
-        1.24399433e-03, 4.24795742e-04, 1.46470705e-04, 5.08813130e-05, 1.77800623e-05, 6.24302055e-06, 2.20082540e-06,
-        7.78454386e-07, 2.76137082e-07, 9.81953648e-08, 3.49941166e-08, 1.24946640e-08, 4.46875334e-09, 1.60067129e-09,
-        5.74123782e-10, 2.06176797e-10, 7.41235161e-11, 2.66754511e-11, 9.60881878e-12, 3.46416156e-12, 1.24987740e-12,
-        4.51286453e-13, 1.63053459e-13, 5.89495073e-14, 2.13247750e-14, 7.71838266e-15, 2.79505752e-15, 1.01266123e-15,
-        3.67057597e-16, 1.33103515e-16, 4.82858338e-17, 1.75232770e-17, 6.36161716e-18, 2.31029936e-18, 8.39286110e-19;
-
-    CALL_SUBTEST(res = bessel_k0(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function k0e. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << 1.97933385, 1.52410939, 1.14446308, 0.84156822, 0.6977616, 0.60929767, 0.54780756, 0.50186313,
-        0.4658451, 0.43662302, 0.41229555, 0.39163193, 0.3737955, 0.35819488, 0.34439865, 0.33208364, 0.32100235,
-        0.31096159, 0.30180802, 0.29341821, 0.28569149, 0.27854488, 0.2719092, 0.26572635, 0.25994703, 0.25452917,
-        0.2494366, 0.24463801, 0.24010616, 0.23581722, 0.23175022, 0.22788667, 0.22421014, 0.22070602, 0.21736123,
-        0.21416406, 0.21110397, 0.20817141, 0.20535778, 0.20265524, 0.20005668, 0.19755558;
-
-    CALL_SUBTEST(res = bessel_k0e(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function k1. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << 3.74702597, 1.65644112, 6.01907230e-01, 1.39865882e-01, 4.01564311e-02, 1.24834989e-02, 4.04461345e-03,
-        1.34391972e-03, 4.54182487e-04, 1.55369212e-04, 5.36370164e-05, 1.86487735e-05, 6.52086067e-06, 2.29075746e-06,
-        8.07858841e-07, 2.85834365e-07, 1.01417294e-07, 3.60715712e-08, 1.28570417e-08, 4.59124963e-09, 1.64226697e-09,
-        5.88305797e-10, 2.11029922e-10, 7.57898116e-11, 2.72493059e-11, 9.80699893e-12, 3.53277807e-12, 1.27369078e-12,
-        4.59568940e-13, 1.65940011e-13, 5.99574032e-14, 2.16773200e-14, 7.84189960e-15, 2.83839927e-15, 1.02789171e-15,
-        3.72416929e-16, 1.34991783e-16, 4.89519373e-17, 1.77585196e-17, 6.44478588e-18, 2.33973340e-18, 8.49713195e-19;
-
-    CALL_SUBTEST(res = bessel_k1(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function k1e. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << 4.81127659, 2.73100971, 1.63615349, 1.03347685, 0.80656348, 0.68157595, 0.60027386, 0.54217591,
-        0.49807158, 0.46314909, 0.43462525, 0.41076657, 0.39043094, 0.37283175, 0.35740757, 0.34374563, 0.33153489,
-        0.32053597, 0.31056123, 0.30146131, 0.29311559, 0.2854255, 0.27830958, 0.27169987, 0.26553913, 0.25977879,
-        0.25437733, 0.249299, 0.24451285, 0.23999191, 0.2357126, 0.23165413, 0.22779816, 0.22412841, 0.22063036,
-        0.21729103, 0.21409878, 0.21104314, 0.20811462, 0.20530466, 0.20260547, 0.20000997;
-
-    CALL_SUBTEST(res = bessel_k1e(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function y0. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << -0.93157302, -0.44451873, 0.08825696, 0.51037567, 0.37685001, -0.01694074, -0.30851763, -0.28819468,
-        -0.02594974, 0.22352149, 0.2499367, 0.05567117, -0.16884732, -0.22523731, -0.07820786, 0.12719257, 0.2054643,
-        0.095811, -0.0926372, -0.18755216, -0.10951969, 0.0626406, 0.17020176, 0.1198876, -0.03598179, -0.15283403,
-        -0.12724943, 0.01204463, 0.13521498, 0.13183647, 0.00948116, -0.11729573, -0.13383266, -0.02874248, 0.09913483,
-        0.13340405, 0.04579799, -0.08085609, -0.13071488, -0.06066076, 0.06262353, 0.12593642;
-
-    CALL_SUBTEST(res = bessel_y0(x); verify_component_wise(res, expected););
-  }
-
-  // Test Bessel function y1. Reference results obtained with SciPy.
-  {
-    ArrayType x(42);
-    ArrayType expected(42);
-    ArrayType res(42);
-
-    x << 0.25, 0.5, 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
-        23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40.;
-
-    expected << -2.70410523, -1.47147239, -0.78121282, -0.10703243, 0.32467442, 0.39792571, 0.14786314, -0.17501034,
-        -0.30266724, -0.15806046, 0.10431458, 0.24901542, 0.16370554, -0.05709922, -0.21008141, -0.16664484, 0.02107363,
-        0.17797517, 0.16720504, 0.00815513, -0.14956011, -0.16551161, -0.03253926, 0.12340586, 0.1616692, 0.05305978,
-        -0.09882996, -0.15579655, -0.07025124, 0.07552213, 0.14803412, 0.08442557, -0.05337283, -0.13854483,
-        -0.09578012, 0.03238588, 0.12751273, 0.10445477, -0.01262946, -0.11514066, -0.11056411, -0.00579351;
-
-    CALL_SUBTEST(res = bessel_y1(x); verify_component_wise(res, expected););
-  }
-}
-
-EIGEN_DECLARE_TEST(bessel_functions) {
-  CALL_SUBTEST_1(array_bessel_functions<ArrayXf>());
-  CALL_SUBTEST_2(array_bessel_functions<ArrayXd>());
-}
diff --git a/unsupported/test/bicgstabl.cpp b/unsupported/test/bicgstabl.cpp
deleted file mode 100644
index 4761e39..0000000
--- a/unsupported/test/bicgstabl.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
-// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "../../test/sparse_solver.h"
-#include <Eigen/IterativeSolvers>
-
-template <typename T>
-void test_bicgstabl_T() {
-  BiCGSTABL<SparseMatrix<T>, DiagonalPreconditioner<T> > bicgstabl_colmajor_diag;
-  BiCGSTABL<SparseMatrix<T>, IncompleteLUT<T> > bicgstabl_colmajor_ilut;
-
-  // This does not change the tolerance of the test, only the tolerance of the solver.
-  bicgstabl_colmajor_diag.setTolerance(NumTraits<T>::epsilon() * 20);
-  bicgstabl_colmajor_ilut.setTolerance(NumTraits<T>::epsilon() * 20);
-
-  CALL_SUBTEST(check_sparse_square_solving(bicgstabl_colmajor_diag));
-  CALL_SUBTEST(check_sparse_square_solving(bicgstabl_colmajor_ilut));
-}
-
-EIGEN_DECLARE_TEST(bicgstabl) {
-  CALL_SUBTEST_1(test_bicgstabl_T<double>());
-  CALL_SUBTEST_2(test_bicgstabl_T<std::complex<double> >());
-}
diff --git a/unsupported/test/cxx11_tensor_argmax.cpp b/unsupported/test/cxx11_tensor_argmax.cpp
deleted file mode 100644
index 1bf5064..0000000
--- a/unsupported/test/cxx11_tensor_argmax.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Eugene Brevdo <ebrevdo@google.com>
-//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::Pair;
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_index_pairs() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  tensor = (tensor + tensor.constant(0.5)).log();
-
-  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
-  index_pairs = tensor.index_pairs();
-
-  for (DenseIndex n = 0; n < 2 * 3 * 5 * 7; ++n) {
-    const Pair<DenseIndex, float>& v = index_pairs.coeff(n);
-    VERIFY_IS_EQUAL(v.first, n);
-    VERIFY_IS_EQUAL(v.second, tensor.coeff(n));
-  }
-}
-
-template <int DataLayout>
-static void test_index_pairs_dim() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  tensor = (tensor + tensor.constant(0.5)).log();
-
-  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
-
-  index_pairs = tensor.index_pairs();
-
-  for (Eigen::DenseIndex n = 0; n < tensor.size(); ++n) {
-    const Pair<DenseIndex, float>& v = index_pairs(n);  //(i, j, k, l);
-    VERIFY_IS_EQUAL(v.first, n);
-    VERIFY_IS_EQUAL(v.second, tensor(n));
-  }
-}
-
-template <int DataLayout>
-static void test_argmax_pair_reducer() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  tensor = (tensor + tensor.constant(0.5)).log();
-
-  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
-  index_pairs = tensor.index_pairs();
-
-  Tensor<Pair<DenseIndex, float>, 0, DataLayout> reduced;
-  DimensionList<DenseIndex, 4> dims;
-  reduced = index_pairs.reduce(dims, internal::ArgMaxPairReducer<Pair<DenseIndex, float> >());
-
-  Tensor<float, 0, DataLayout> maxi = tensor.maximum();
-
-  VERIFY_IS_EQUAL(maxi(), reduced(0).second);
-
-  array<DenseIndex, 3> reduce_dims;
-  for (int d = 0; d < 3; ++d) reduce_dims[d] = d;
-  Tensor<Pair<DenseIndex, float>, 1, DataLayout> reduced_by_dims(7);
-  reduced_by_dims = index_pairs.reduce(reduce_dims, internal::ArgMaxPairReducer<Pair<DenseIndex, float> >());
-
-  Tensor<float, 1, DataLayout> max_by_dims = tensor.maximum(reduce_dims);
-
-  for (int l = 0; l < 7; ++l) {
-    VERIFY_IS_EQUAL(max_by_dims(l), reduced_by_dims(l).second);
-  }
-}
-
-template <int DataLayout>
-static void test_argmin_pair_reducer() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  tensor = (tensor + tensor.constant(0.5)).log();
-
-  Tensor<Pair<DenseIndex, float>, 4, DataLayout> index_pairs(2, 3, 5, 7);
-  index_pairs = tensor.index_pairs();
-
-  Tensor<Pair<DenseIndex, float>, 0, DataLayout> reduced;
-  DimensionList<DenseIndex, 4> dims;
-  reduced = index_pairs.reduce(dims, internal::ArgMinPairReducer<Pair<DenseIndex, float> >());
-
-  Tensor<float, 0, DataLayout> mini = tensor.minimum();
-
-  VERIFY_IS_EQUAL(mini(), reduced(0).second);
-
-  array<DenseIndex, 3> reduce_dims;
-  for (int d = 0; d < 3; ++d) reduce_dims[d] = d;
-  Tensor<Pair<DenseIndex, float>, 1, DataLayout> reduced_by_dims(7);
-  reduced_by_dims = index_pairs.reduce(reduce_dims, internal::ArgMinPairReducer<Pair<DenseIndex, float> >());
-
-  Tensor<float, 1, DataLayout> min_by_dims = tensor.minimum(reduce_dims);
-
-  for (int l = 0; l < 7; ++l) {
-    VERIFY_IS_EQUAL(min_by_dims(l), reduced_by_dims(l).second);
-  }
-}
-
-template <int DataLayout>
-static void test_simple_argmax() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  tensor = (tensor + tensor.constant(0.5)).log();
-  tensor(0, 0, 0, 0) = 10.0;
-
-  Tensor<DenseIndex, 0, DataLayout> tensor_argmax;
-
-  tensor_argmax = tensor.argmax();
-
-  VERIFY_IS_EQUAL(tensor_argmax(0), 0);
-
-  tensor(1, 2, 4, 6) = 20.0;
-
-  tensor_argmax = tensor.argmax();
-
-  VERIFY_IS_EQUAL(tensor_argmax(0), 2 * 3 * 5 * 7 - 1);
-}
-
-template <int DataLayout>
-static void test_simple_argmin() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  tensor = (tensor + tensor.constant(0.5)).log();
-  tensor(0, 0, 0, 0) = -10.0;
-
-  Tensor<DenseIndex, 0, DataLayout> tensor_argmin;
-
-  tensor_argmin = tensor.argmin();
-
-  VERIFY_IS_EQUAL(tensor_argmin(0), 0);
-
-  tensor(1, 2, 4, 6) = -20.0;
-
-  tensor_argmin = tensor.argmin();
-
-  VERIFY_IS_EQUAL(tensor_argmin(0), 2 * 3 * 5 * 7 - 1);
-}
-
-template <int DataLayout>
-static void test_argmax_dim() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  std::vector<int> dims{2, 3, 5, 7};
-
-  for (int dim = 0; dim < 4; ++dim) {
-    tensor.setRandom();
-    tensor = (tensor + tensor.constant(0.5)).log();
-
-    Tensor<DenseIndex, 3, DataLayout> tensor_argmax;
-    array<DenseIndex, 4> ix;
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != 0) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
-            tensor(ix) = 10.0;
-          }
-        }
-      }
-    }
-
-    tensor_argmax = tensor.argmax(dim);
-
-    VERIFY_IS_EQUAL(tensor_argmax.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
-    for (ptrdiff_t n = 0; n < tensor_argmax.size(); ++n) {
-      // Expect max to be in the first index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_argmax.data()[n], 0);
-    }
-
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != tensor.dimension(dim) - 1) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
-            tensor(ix) = 20.0;
-          }
-        }
-      }
-    }
-
-    tensor_argmax = tensor.argmax(dim);
-
-    VERIFY_IS_EQUAL(tensor_argmax.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
-    for (ptrdiff_t n = 0; n < tensor_argmax.size(); ++n) {
-      // Expect max to be in the last index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_argmax.data()[n], tensor.dimension(dim) - 1);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_argmin_dim() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  std::vector<int> dims{2, 3, 5, 7};
-
-  for (int dim = 0; dim < 4; ++dim) {
-    tensor.setRandom();
-    tensor = (tensor + tensor.constant(0.5)).log();
-
-    Tensor<DenseIndex, 3, DataLayout> tensor_argmin;
-    array<DenseIndex, 4> ix;
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != 0) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = -10.0
-            tensor(ix) = -10.0;
-          }
-        }
-      }
-    }
-
-    tensor_argmin = tensor.argmin(dim);
-
-    VERIFY_IS_EQUAL(tensor_argmin.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
-    for (ptrdiff_t n = 0; n < tensor_argmin.size(); ++n) {
-      // Expect min to be in the first index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_argmin.data()[n], 0);
-    }
-
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != tensor.dimension(dim) - 1) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = -20.0
-            tensor(ix) = -20.0;
-          }
-        }
-      }
-    }
-
-    tensor_argmin = tensor.argmin(dim);
-
-    VERIFY_IS_EQUAL(tensor_argmin.size(), ptrdiff_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
-    for (ptrdiff_t n = 0; n < tensor_argmin.size(); ++n) {
-      // Expect min to be in the last index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_argmin.data()[n], tensor.dimension(dim) - 1);
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_argmax) {
-  CALL_SUBTEST(test_simple_index_pairs<RowMajor>());
-  CALL_SUBTEST(test_simple_index_pairs<ColMajor>());
-  CALL_SUBTEST(test_index_pairs_dim<RowMajor>());
-  CALL_SUBTEST(test_index_pairs_dim<ColMajor>());
-  CALL_SUBTEST(test_argmax_pair_reducer<RowMajor>());
-  CALL_SUBTEST(test_argmax_pair_reducer<ColMajor>());
-  CALL_SUBTEST(test_argmin_pair_reducer<RowMajor>());
-  CALL_SUBTEST(test_argmin_pair_reducer<ColMajor>());
-  CALL_SUBTEST(test_simple_argmax<RowMajor>());
-  CALL_SUBTEST(test_simple_argmax<ColMajor>());
-  CALL_SUBTEST(test_simple_argmin<RowMajor>());
-  CALL_SUBTEST(test_simple_argmin<ColMajor>());
-  CALL_SUBTEST(test_argmax_dim<RowMajor>());
-  CALL_SUBTEST(test_argmax_dim<ColMajor>());
-  CALL_SUBTEST(test_argmin_dim<RowMajor>());
-  CALL_SUBTEST(test_argmin_dim<ColMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_argmax_gpu.cu b/unsupported/test/cxx11_tensor_argmax_gpu.cu
deleted file mode 100644
index 3be20d4..0000000
--- a/unsupported/test/cxx11_tensor_argmax_gpu.cu
+++ /dev/null
@@ -1,270 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int Layout>
-void test_gpu_simple_argmax() {
-  Tensor<double, 3, Layout> in(Eigen::array<DenseIndex, 3>{72, 53, 97});
-  Tensor<DenseIndex, 0, Layout> out_max;
-  Tensor<DenseIndex, 0, Layout> out_min;
-  in.setRandom();
-  in *= in.constant(100.0);
-  in(0, 0, 0) = -1000.0;
-  in(71, 52, 96) = 1000.0;
-
-  std::size_t in_bytes = in.size() * sizeof(double);
-  std::size_t out_bytes = out_max.size() * sizeof(DenseIndex);
-
-  double* d_in;
-  DenseIndex* d_out_max;
-  DenseIndex* d_out_min;
-  gpuMalloc((void**)(&d_in), in_bytes);
-  gpuMalloc((void**)(&d_out_max), out_bytes);
-  gpuMalloc((void**)(&d_out_min), out_bytes);
-
-  gpuMemcpy(d_in, in.data(), in_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<double, 3, Layout>, Aligned> gpu_in(d_in, Eigen::array<DenseIndex, 3>{72, 53, 97});
-  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout>, Aligned> gpu_out_max(d_out_max);
-  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout>, Aligned> gpu_out_min(d_out_min);
-
-  gpu_out_max.device(gpu_device) = gpu_in.argmax();
-  gpu_out_min.device(gpu_device) = gpu_in.argmin();
-
-  assert(gpuMemcpyAsync(out_max.data(), d_out_max, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
-         gpuSuccess);
-  assert(gpuMemcpyAsync(out_min.data(), d_out_min, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
-         gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  VERIFY_IS_EQUAL(out_max(), 72 * 53 * 97 - 1);
-  VERIFY_IS_EQUAL(out_min(), 0);
-
-  gpuFree(d_in);
-  gpuFree(d_out_max);
-  gpuFree(d_out_min);
-}
-
-template <int DataLayout>
-void test_gpu_argmax_dim() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  std::vector<int> dims;
-  dims.push_back(2);
-  dims.push_back(3);
-  dims.push_back(5);
-  dims.push_back(7);
-
-  for (int dim = 0; dim < 4; ++dim) {
-    tensor.setRandom();
-    tensor = (tensor + tensor.constant(0.5)).log();
-
-    array<DenseIndex, 3> out_shape;
-    for (int d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
-
-    Tensor<DenseIndex, 3, DataLayout> tensor_arg(out_shape);
-
-    array<DenseIndex, 4> ix;
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != 0) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
-            tensor(ix) = 10.0;
-          }
-        }
-      }
-    }
-
-    std::size_t in_bytes = tensor.size() * sizeof(float);
-    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
-
-    float* d_in;
-    DenseIndex* d_out;
-    gpuMalloc((void**)(&d_in), in_bytes);
-    gpuMalloc((void**)(&d_out), out_bytes);
-
-    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
-
-    Eigen::GpuStreamDevice stream;
-    Eigen::GpuDevice gpu_device(&stream);
-
-    Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout>, Aligned> gpu_in(d_in,
-                                                                          Eigen::array<DenseIndex, 4>{2, 3, 5, 7});
-    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout>, Aligned> gpu_out(d_out, out_shape);
-
-    gpu_out.device(gpu_device) = gpu_in.argmax(dim);
-
-    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
-           gpuSuccess);
-    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-    VERIFY_IS_EQUAL(tensor_arg.size(), size_t(2 * 3 * 5 * 7 / tensor.dimension(dim)));
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the first index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
-    }
-
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != tensor.dimension(dim) - 1) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
-            tensor(ix) = 20.0;
-          }
-        }
-      }
-    }
-
-    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
-
-    gpu_out.device(gpu_device) = gpu_in.argmax(dim);
-
-    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
-           gpuSuccess);
-    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the last index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
-    }
-
-    gpuFree(d_in);
-    gpuFree(d_out);
-  }
-}
-
-template <int DataLayout>
-void test_gpu_argmin_dim() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  std::vector<int> dims;
-  dims.push_back(2);
-  dims.push_back(3);
-  dims.push_back(5);
-  dims.push_back(7);
-
-  for (int dim = 0; dim < 4; ++dim) {
-    tensor.setRandom();
-    tensor = (tensor + tensor.constant(0.5)).log();
-
-    array<DenseIndex, 3> out_shape;
-    for (int d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
-
-    Tensor<DenseIndex, 3, DataLayout> tensor_arg(out_shape);
-
-    array<DenseIndex, 4> ix;
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != 0) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = 10.0
-            tensor(ix) = -10.0;
-          }
-        }
-      }
-    }
-
-    std::size_t in_bytes = tensor.size() * sizeof(float);
-    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
-
-    float* d_in;
-    DenseIndex* d_out;
-    gpuMalloc((void**)(&d_in), in_bytes);
-    gpuMalloc((void**)(&d_out), out_bytes);
-
-    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
-
-    Eigen::GpuStreamDevice stream;
-    Eigen::GpuDevice gpu_device(&stream);
-
-    Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout>, Aligned> gpu_in(d_in,
-                                                                          Eigen::array<DenseIndex, 4>{2, 3, 5, 7});
-    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout>, Aligned> gpu_out(d_out, out_shape);
-
-    gpu_out.device(gpu_device) = gpu_in.argmin(dim);
-
-    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
-           gpuSuccess);
-    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-    VERIFY_IS_EQUAL(tensor_arg.size(), 2 * 3 * 5 * 7 / tensor.dimension(dim));
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect min to be in the first index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
-    }
-
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        for (int k = 0; k < 5; ++k) {
-          for (int l = 0; l < 7; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            if (ix[dim] != tensor.dimension(dim) - 1) continue;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
-            tensor(ix) = -20.0;
-          }
-        }
-      }
-    }
-
-    gpuMemcpy(d_in, tensor.data(), in_bytes, gpuMemcpyHostToDevice);
-
-    gpu_out.device(gpu_device) = gpu_in.argmin(dim);
-
-    assert(gpuMemcpyAsync(tensor_arg.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) ==
-           gpuSuccess);
-    assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the last index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
-    }
-
-    gpuFree(d_in);
-    gpuFree(d_out);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_argmax_gpu) {
-  CALL_SUBTEST_1(test_gpu_simple_argmax<RowMajor>());
-  CALL_SUBTEST_1(test_gpu_simple_argmax<ColMajor>());
-  CALL_SUBTEST_2(test_gpu_argmax_dim<RowMajor>());
-  CALL_SUBTEST_2(test_gpu_argmax_dim<ColMajor>());
-  CALL_SUBTEST_3(test_gpu_argmin_dim<RowMajor>());
-  CALL_SUBTEST_3(test_gpu_argmin_dim<ColMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_argmax_sycl.cpp b/unsupported/test/cxx11_tensor_argmax_sycl.cpp
deleted file mode 100644
index c49ceac..0000000
--- a/unsupported/test/cxx11_tensor_argmax_sycl.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int Layout, typename DenseIndex>
-static void test_sycl_simple_argmax(const Eigen::SyclDevice& sycl_device) {
-  Tensor<DataType, 3, Layout, DenseIndex> in(Eigen::array<DenseIndex, 3>{{2, 2, 2}});
-  Tensor<DenseIndex, 0, Layout, DenseIndex> out_max;
-  Tensor<DenseIndex, 0, Layout, DenseIndex> out_min;
-  in.setRandom();
-  in *= in.constant(static_cast<DataType>(100.0));
-  in(0, 0, 0) = static_cast<DataType>(-1000.0);
-  in(1, 1, 1) = static_cast<DataType>(1000.0);
-
-  std::size_t in_bytes = in.size() * sizeof(DataType);
-  std::size_t out_bytes = out_max.size() * sizeof(DenseIndex);
-
-  DataType* d_in = static_cast<DataType*>(sycl_device.allocate(in_bytes));
-  DenseIndex* d_out_max = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
-  DenseIndex* d_out_min = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, Layout, DenseIndex> > gpu_in(d_in,
-                                                                           Eigen::array<DenseIndex, 3>{{2, 2, 2}});
-  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout, DenseIndex> > gpu_out_max(d_out_max);
-  Eigen::TensorMap<Eigen::Tensor<DenseIndex, 0, Layout, DenseIndex> > gpu_out_min(d_out_min);
-  sycl_device.memcpyHostToDevice(d_in, in.data(), in_bytes);
-
-  gpu_out_max.device(sycl_device) = gpu_in.argmax();
-  gpu_out_min.device(sycl_device) = gpu_in.argmin();
-
-  sycl_device.memcpyDeviceToHost(out_max.data(), d_out_max, out_bytes);
-  sycl_device.memcpyDeviceToHost(out_min.data(), d_out_min, out_bytes);
-
-  VERIFY_IS_EQUAL(out_max(), 2 * 2 * 2 - 1);
-  VERIFY_IS_EQUAL(out_min(), 0);
-
-  sycl_device.deallocate(d_in);
-  sycl_device.deallocate(d_out_max);
-  sycl_device.deallocate(d_out_min);
-}
-
-template <typename DataType, int DataLayout, typename DenseIndex>
-static void test_sycl_argmax_dim(const Eigen::SyclDevice& sycl_device) {
-  DenseIndex sizeDim0 = 9;
-  DenseIndex sizeDim1 = 3;
-  DenseIndex sizeDim2 = 5;
-  DenseIndex sizeDim3 = 7;
-  Tensor<DataType, 4, DataLayout, DenseIndex> tensor(sizeDim0, sizeDim1, sizeDim2, sizeDim3);
-
-  std::vector<DenseIndex> dims;
-  dims.push_back(sizeDim0);
-  dims.push_back(sizeDim1);
-  dims.push_back(sizeDim2);
-  dims.push_back(sizeDim3);
-  for (DenseIndex dim = 0; dim < 4; ++dim) {
-    array<DenseIndex, 3> out_shape;
-    for (DenseIndex d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
-
-    Tensor<DenseIndex, 3, DataLayout, DenseIndex> tensor_arg(out_shape);
-
-    array<DenseIndex, 4> ix;
-    for (DenseIndex i = 0; i < sizeDim0; ++i) {
-      for (DenseIndex j = 0; j < sizeDim1; ++j) {
-        for (DenseIndex k = 0; k < sizeDim2; ++k) {
-          for (DenseIndex l = 0; l < sizeDim3; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l)
-            // = 10.0
-            tensor(ix) = static_cast<DataType>((ix[dim] != 0) ? -1.0 : 10.0);
-          }
-        }
-      }
-    }
-
-    std::size_t in_bytes = tensor.size() * sizeof(DataType);
-    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
-
-    DataType* d_in = static_cast<DataType*>(sycl_device.allocate(in_bytes));
-    DenseIndex* d_out = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
-
-    Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, DenseIndex> > gpu_in(
-        d_in, Eigen::array<DenseIndex, 4>{{sizeDim0, sizeDim1, sizeDim2, sizeDim3}});
-    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout, DenseIndex> > gpu_out(d_out, out_shape);
-
-    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
-    gpu_out.device(sycl_device) = gpu_in.argmax(dim);
-    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
-
-    VERIFY_IS_EQUAL(static_cast<size_t>(tensor_arg.size()),
-                    size_t(sizeDim0 * sizeDim1 * sizeDim2 * sizeDim3 / tensor.dimension(dim)));
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the first index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
-    }
-
-    sycl_device.synchronize();
-
-    for (DenseIndex i = 0; i < sizeDim0; ++i) {
-      for (DenseIndex j = 0; j < sizeDim1; ++j) {
-        for (DenseIndex k = 0; k < sizeDim2; ++k) {
-          for (DenseIndex l = 0; l < sizeDim3; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = 20.0
-            tensor(ix) = static_cast<DataType>((ix[dim] != tensor.dimension(dim) - 1) ? -1.0 : 20.0);
-          }
-        }
-      }
-    }
-
-    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
-    gpu_out.device(sycl_device) = gpu_in.argmax(dim);
-    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the last index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
-    }
-    sycl_device.deallocate(d_in);
-    sycl_device.deallocate(d_out);
-  }
-}
-
-template <typename DataType, int DataLayout, typename DenseIndex>
-static void test_sycl_argmin_dim(const Eigen::SyclDevice& sycl_device) {
-  DenseIndex sizeDim0 = 9;
-  DenseIndex sizeDim1 = 3;
-  DenseIndex sizeDim2 = 5;
-  DenseIndex sizeDim3 = 7;
-  Tensor<DataType, 4, DataLayout, DenseIndex> tensor(sizeDim0, sizeDim1, sizeDim2, sizeDim3);
-
-  std::vector<DenseIndex> dims;
-  dims.push_back(sizeDim0);
-  dims.push_back(sizeDim1);
-  dims.push_back(sizeDim2);
-  dims.push_back(sizeDim3);
-  for (DenseIndex dim = 0; dim < 4; ++dim) {
-    array<DenseIndex, 3> out_shape;
-    for (DenseIndex d = 0; d < 3; ++d) out_shape[d] = (d < dim) ? dims[d] : dims[d + 1];
-
-    Tensor<DenseIndex, 3, DataLayout, DenseIndex> tensor_arg(out_shape);
-
-    array<DenseIndex, 4> ix;
-    for (DenseIndex i = 0; i < sizeDim0; ++i) {
-      for (DenseIndex j = 0; j < sizeDim1; ++j) {
-        for (DenseIndex k = 0; k < sizeDim2; ++k) {
-          for (DenseIndex l = 0; l < sizeDim3; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 0, k, l) = -10.0
-            tensor(ix) = static_cast<DataType>((ix[dim] != 0) ? 1.0 : -10.0);
-          }
-        }
-      }
-    }
-
-    std::size_t in_bytes = tensor.size() * sizeof(DataType);
-    std::size_t out_bytes = tensor_arg.size() * sizeof(DenseIndex);
-
-    DataType* d_in = static_cast<DataType*>(sycl_device.allocate(in_bytes));
-    DenseIndex* d_out = static_cast<DenseIndex*>(sycl_device.allocate(out_bytes));
-
-    Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, DenseIndex> > gpu_in(
-        d_in, Eigen::array<DenseIndex, 4>{{sizeDim0, sizeDim1, sizeDim2, sizeDim3}});
-    Eigen::TensorMap<Eigen::Tensor<DenseIndex, 3, DataLayout, DenseIndex> > gpu_out(d_out, out_shape);
-
-    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
-    gpu_out.device(sycl_device) = gpu_in.argmin(dim);
-    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
-
-    VERIFY_IS_EQUAL(static_cast<size_t>(tensor_arg.size()),
-                    size_t(sizeDim0 * sizeDim1 * sizeDim2 * sizeDim3 / tensor.dimension(dim)));
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the first index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], 0);
-    }
-
-    sycl_device.synchronize();
-
-    for (DenseIndex i = 0; i < sizeDim0; ++i) {
-      for (DenseIndex j = 0; j < sizeDim1; ++j) {
-        for (DenseIndex k = 0; k < sizeDim2; ++k) {
-          for (DenseIndex l = 0; l < sizeDim3; ++l) {
-            ix[0] = i;
-            ix[1] = j;
-            ix[2] = k;
-            ix[3] = l;
-            // suppose dim == 1, then for all i, k, l, set tensor(i, 2, k, l) = -20.0
-            tensor(ix) = static_cast<DataType>((ix[dim] != tensor.dimension(dim) - 1) ? 1.0 : -20.0);
-          }
-        }
-      }
-    }
-
-    sycl_device.memcpyHostToDevice(d_in, tensor.data(), in_bytes);
-    gpu_out.device(sycl_device) = gpu_in.argmin(dim);
-    sycl_device.memcpyDeviceToHost(tensor_arg.data(), d_out, out_bytes);
-
-    for (DenseIndex n = 0; n < tensor_arg.size(); ++n) {
-      // Expect max to be in the last index of the reduced dimension
-      VERIFY_IS_EQUAL(tensor_arg.data()[n], tensor.dimension(dim) - 1);
-    }
-    sycl_device.deallocate(d_in);
-    sycl_device.deallocate(d_out);
-  }
-}
-
-template <typename DataType, typename Device_Selector>
-void sycl_argmax_test_per_device(const Device_Selector& d) {
-  QueueInterface queueInterface(d);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_sycl_simple_argmax<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_simple_argmax<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_argmax_dim<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_argmax_dim<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_argmin_dim<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_argmin_dim<DataType, RowMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_argmax_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_argmax_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_argmax_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_assign.cpp b/unsupported/test/cxx11_tensor_assign.cpp
deleted file mode 100644
index 47b6361..0000000
--- a/unsupported/test/cxx11_tensor_assign.cpp
+++ /dev/null
@@ -1,359 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_1d() {
-  Tensor<int, 1> vec1(6);
-  Tensor<int, 1, RowMajor> vec2(6);
-  vec1(0) = 4;
-  vec2(0) = 0;
-  vec1(1) = 8;
-  vec2(1) = 1;
-  vec1(2) = 15;
-  vec2(2) = 2;
-  vec1(3) = 16;
-  vec2(3) = 3;
-  vec1(4) = 23;
-  vec2(4) = 4;
-  vec1(5) = 42;
-  vec2(5) = 5;
-
-  int col_major[6] = {0};
-  int row_major[6] = {0};
-  TensorMap<Tensor<int, 1> > vec3(col_major, 6);
-  TensorMap<Tensor<int, 1, RowMajor> > vec4(row_major, 6);
-
-  vec3 = vec1;
-  vec4 = vec2;
-
-  VERIFY_IS_EQUAL(vec3(0), 4);
-  VERIFY_IS_EQUAL(vec3(1), 8);
-  VERIFY_IS_EQUAL(vec3(2), 15);
-  VERIFY_IS_EQUAL(vec3(3), 16);
-  VERIFY_IS_EQUAL(vec3(4), 23);
-  VERIFY_IS_EQUAL(vec3(5), 42);
-
-  VERIFY_IS_EQUAL(vec4(0), 0);
-  VERIFY_IS_EQUAL(vec4(1), 1);
-  VERIFY_IS_EQUAL(vec4(2), 2);
-  VERIFY_IS_EQUAL(vec4(3), 3);
-  VERIFY_IS_EQUAL(vec4(4), 4);
-  VERIFY_IS_EQUAL(vec4(5), 5);
-
-  vec1.setZero();
-  vec2.setZero();
-  vec1 = vec3;
-  vec2 = vec4;
-
-  VERIFY_IS_EQUAL(vec1(0), 4);
-  VERIFY_IS_EQUAL(vec1(1), 8);
-  VERIFY_IS_EQUAL(vec1(2), 15);
-  VERIFY_IS_EQUAL(vec1(3), 16);
-  VERIFY_IS_EQUAL(vec1(4), 23);
-  VERIFY_IS_EQUAL(vec1(5), 42);
-
-  VERIFY_IS_EQUAL(vec2(0), 0);
-  VERIFY_IS_EQUAL(vec2(1), 1);
-  VERIFY_IS_EQUAL(vec2(2), 2);
-  VERIFY_IS_EQUAL(vec2(3), 3);
-  VERIFY_IS_EQUAL(vec2(4), 4);
-  VERIFY_IS_EQUAL(vec2(5), 5);
-}
-
-static void test_2d() {
-  Tensor<int, 2> mat1(2, 3);
-  Tensor<int, 2, RowMajor> mat2(2, 3);
-
-  mat1(0, 0) = 0;
-  mat1(0, 1) = 1;
-  mat1(0, 2) = 2;
-  mat1(1, 0) = 3;
-  mat1(1, 1) = 4;
-  mat1(1, 2) = 5;
-
-  mat2(0, 0) = 0;
-  mat2(0, 1) = 1;
-  mat2(0, 2) = 2;
-  mat2(1, 0) = 3;
-  mat2(1, 1) = 4;
-  mat2(1, 2) = 5;
-
-  int col_major[6] = {0};
-  int row_major[6] = {0};
-  TensorMap<Tensor<int, 2> > mat3(row_major, 2, 3);
-  TensorMap<Tensor<int, 2, RowMajor> > mat4(col_major, 2, 3);
-
-  mat3 = mat1;
-  mat4 = mat2;
-
-  VERIFY_IS_EQUAL(mat3(0, 0), 0);
-  VERIFY_IS_EQUAL(mat3(0, 1), 1);
-  VERIFY_IS_EQUAL(mat3(0, 2), 2);
-  VERIFY_IS_EQUAL(mat3(1, 0), 3);
-  VERIFY_IS_EQUAL(mat3(1, 1), 4);
-  VERIFY_IS_EQUAL(mat3(1, 2), 5);
-
-  VERIFY_IS_EQUAL(mat4(0, 0), 0);
-  VERIFY_IS_EQUAL(mat4(0, 1), 1);
-  VERIFY_IS_EQUAL(mat4(0, 2), 2);
-  VERIFY_IS_EQUAL(mat4(1, 0), 3);
-  VERIFY_IS_EQUAL(mat4(1, 1), 4);
-  VERIFY_IS_EQUAL(mat4(1, 2), 5);
-
-  mat1.setZero();
-  mat2.setZero();
-  mat1 = mat3;
-  mat2 = mat4;
-
-  VERIFY_IS_EQUAL(mat1(0, 0), 0);
-  VERIFY_IS_EQUAL(mat1(0, 1), 1);
-  VERIFY_IS_EQUAL(mat1(0, 2), 2);
-  VERIFY_IS_EQUAL(mat1(1, 0), 3);
-  VERIFY_IS_EQUAL(mat1(1, 1), 4);
-  VERIFY_IS_EQUAL(mat1(1, 2), 5);
-
-  VERIFY_IS_EQUAL(mat2(0, 0), 0);
-  VERIFY_IS_EQUAL(mat2(0, 1), 1);
-  VERIFY_IS_EQUAL(mat2(0, 2), 2);
-  VERIFY_IS_EQUAL(mat2(1, 0), 3);
-  VERIFY_IS_EQUAL(mat2(1, 1), 4);
-  VERIFY_IS_EQUAL(mat2(1, 2), 5);
-}
-
-static void test_3d() {
-  Tensor<int, 3> mat1(2, 3, 7);
-  Tensor<int, 3, RowMajor> mat2(2, 3, 7);
-
-  int val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        mat2(i, j, k) = val;
-        val++;
-      }
-    }
-  }
-
-  int col_major[2 * 3 * 7] = {0};
-  int row_major[2 * 3 * 7] = {0};
-  TensorMap<Tensor<int, 3> > mat3(col_major, 2, 3, 7);
-  TensorMap<Tensor<int, 3, RowMajor> > mat4(row_major, 2, 3, 7);
-
-  mat3 = mat1;
-  mat4 = mat2;
-
-  val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(mat3(i, j, k), val);
-        VERIFY_IS_EQUAL(mat4(i, j, k), val);
-        val++;
-      }
-    }
-  }
-
-  mat1.setZero();
-  mat2.setZero();
-  mat1 = mat3;
-  mat2 = mat4;
-
-  val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(mat1(i, j, k), val);
-        VERIFY_IS_EQUAL(mat2(i, j, k), val);
-        val++;
-      }
-    }
-  }
-}
-
-static void test_same_type() {
-  Tensor<int, 1> orig_tensor(5);
-  Tensor<int, 1> dest_tensor(5);
-  orig_tensor.setRandom();
-  dest_tensor.setRandom();
-  int* orig_data = orig_tensor.data();
-  int* dest_data = dest_tensor.data();
-  dest_tensor = orig_tensor;
-  VERIFY_IS_EQUAL(orig_tensor.data(), orig_data);
-  VERIFY_IS_EQUAL(dest_tensor.data(), dest_data);
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_EQUAL(dest_tensor(i), orig_tensor(i));
-  }
-
-  TensorFixedSize<int, Sizes<5> > orig_array;
-  TensorFixedSize<int, Sizes<5> > dest_array;
-  orig_array.setRandom();
-  dest_array.setRandom();
-  orig_data = orig_array.data();
-  dest_data = dest_array.data();
-  dest_array = orig_array;
-  VERIFY_IS_EQUAL(orig_array.data(), orig_data);
-  VERIFY_IS_EQUAL(dest_array.data(), dest_data);
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_EQUAL(dest_array(i), orig_array(i));
-  }
-
-  int orig[5] = {1, 2, 3, 4, 5};
-  int dest[5] = {6, 7, 8, 9, 10};
-  TensorMap<Tensor<int, 1> > orig_map(orig, 5);
-  TensorMap<Tensor<int, 1> > dest_map(dest, 5);
-  orig_data = orig_map.data();
-  dest_data = dest_map.data();
-  dest_map = orig_map;
-  VERIFY_IS_EQUAL(orig_map.data(), orig_data);
-  VERIFY_IS_EQUAL(dest_map.data(), dest_data);
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_EQUAL(dest[i], i + 1);
-  }
-}
-
-static void test_auto_resize() {
-  Tensor<int, 1> tensor1;
-  Tensor<int, 1> tensor2(3);
-  Tensor<int, 1> tensor3(5);
-  Tensor<int, 1> tensor4(7);
-
-  Tensor<int, 1> new_tensor(5);
-  new_tensor.setRandom();
-
-  tensor1 = tensor2 = tensor3 = tensor4 = new_tensor;
-
-  VERIFY_IS_EQUAL(tensor1.dimension(0), new_tensor.dimension(0));
-  VERIFY_IS_EQUAL(tensor2.dimension(0), new_tensor.dimension(0));
-  VERIFY_IS_EQUAL(tensor3.dimension(0), new_tensor.dimension(0));
-  VERIFY_IS_EQUAL(tensor4.dimension(0), new_tensor.dimension(0));
-  for (int i = 0; i < new_tensor.dimension(0); ++i) {
-    VERIFY_IS_EQUAL(tensor1(i), new_tensor(i));
-    VERIFY_IS_EQUAL(tensor2(i), new_tensor(i));
-    VERIFY_IS_EQUAL(tensor3(i), new_tensor(i));
-    VERIFY_IS_EQUAL(tensor4(i), new_tensor(i));
-  }
-}
-
-static void test_compound_assign() {
-  Tensor<int, 1> start_tensor(10);
-  Tensor<int, 1> offset_tensor(10);
-  start_tensor.setRandom();
-  offset_tensor.setRandom();
-
-  Tensor<int, 1> tensor = start_tensor;
-  tensor += offset_tensor;
-  for (int i = 0; i < 10; ++i) {
-    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) + offset_tensor(i));
-  }
-
-  tensor = start_tensor;
-  tensor -= offset_tensor;
-  for (int i = 0; i < 10; ++i) {
-    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) - offset_tensor(i));
-  }
-
-  tensor = start_tensor;
-  tensor *= offset_tensor;
-  for (int i = 0; i < 10; ++i) {
-    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) * offset_tensor(i));
-  }
-
-  tensor = start_tensor;
-  tensor /= offset_tensor;
-  for (int i = 0; i < 10; ++i) {
-    VERIFY_IS_EQUAL(tensor(i), start_tensor(i) / offset_tensor(i));
-  }
-}
-
-static void test_std_initializers_tensor() {
-  Tensor<int, 1> a(3);
-  a.setValues({0, 1, 2});
-  VERIFY_IS_EQUAL(a(0), 0);
-  VERIFY_IS_EQUAL(a(1), 1);
-  VERIFY_IS_EQUAL(a(2), 2);
-
-  // It fills the top-left slice.
-  a.setValues({10, 20});
-  VERIFY_IS_EQUAL(a(0), 10);
-  VERIFY_IS_EQUAL(a(1), 20);
-  VERIFY_IS_EQUAL(a(2), 2);
-
-  // Chaining.
-  Tensor<int, 1> a2(3);
-  a2 = a.setValues({100, 200, 300});
-  VERIFY_IS_EQUAL(a(0), 100);
-  VERIFY_IS_EQUAL(a(1), 200);
-  VERIFY_IS_EQUAL(a(2), 300);
-  VERIFY_IS_EQUAL(a2(0), 100);
-  VERIFY_IS_EQUAL(a2(1), 200);
-  VERIFY_IS_EQUAL(a2(2), 300);
-
-  Tensor<int, 2> b(2, 3);
-  b.setValues({{0, 1, 2}, {3, 4, 5}});
-  VERIFY_IS_EQUAL(b(0, 0), 0);
-  VERIFY_IS_EQUAL(b(0, 1), 1);
-  VERIFY_IS_EQUAL(b(0, 2), 2);
-  VERIFY_IS_EQUAL(b(1, 0), 3);
-  VERIFY_IS_EQUAL(b(1, 1), 4);
-  VERIFY_IS_EQUAL(b(1, 2), 5);
-
-  // It fills the top-left slice.
-  b.setValues({{10, 20}, {30}});
-  VERIFY_IS_EQUAL(b(0, 0), 10);
-  VERIFY_IS_EQUAL(b(0, 1), 20);
-  VERIFY_IS_EQUAL(b(0, 2), 2);
-  VERIFY_IS_EQUAL(b(1, 0), 30);
-  VERIFY_IS_EQUAL(b(1, 1), 4);
-  VERIFY_IS_EQUAL(b(1, 2), 5);
-
-  Eigen::Tensor<int, 3> c(3, 2, 4);
-  c.setValues(
-      {{{0, 1, 2, 3}, {4, 5, 6, 7}}, {{10, 11, 12, 13}, {14, 15, 16, 17}}, {{20, 21, 22, 23}, {24, 25, 26, 27}}});
-  VERIFY_IS_EQUAL(c(0, 0, 0), 0);
-  VERIFY_IS_EQUAL(c(0, 0, 1), 1);
-  VERIFY_IS_EQUAL(c(0, 0, 2), 2);
-  VERIFY_IS_EQUAL(c(0, 0, 3), 3);
-  VERIFY_IS_EQUAL(c(0, 1, 0), 4);
-  VERIFY_IS_EQUAL(c(0, 1, 1), 5);
-  VERIFY_IS_EQUAL(c(0, 1, 2), 6);
-  VERIFY_IS_EQUAL(c(0, 1, 3), 7);
-  VERIFY_IS_EQUAL(c(1, 0, 0), 10);
-  VERIFY_IS_EQUAL(c(1, 0, 1), 11);
-  VERIFY_IS_EQUAL(c(1, 0, 2), 12);
-  VERIFY_IS_EQUAL(c(1, 0, 3), 13);
-  VERIFY_IS_EQUAL(c(1, 1, 0), 14);
-  VERIFY_IS_EQUAL(c(1, 1, 1), 15);
-  VERIFY_IS_EQUAL(c(1, 1, 2), 16);
-  VERIFY_IS_EQUAL(c(1, 1, 3), 17);
-  VERIFY_IS_EQUAL(c(2, 0, 0), 20);
-  VERIFY_IS_EQUAL(c(2, 0, 1), 21);
-  VERIFY_IS_EQUAL(c(2, 0, 2), 22);
-  VERIFY_IS_EQUAL(c(2, 0, 3), 23);
-  VERIFY_IS_EQUAL(c(2, 1, 0), 24);
-  VERIFY_IS_EQUAL(c(2, 1, 1), 25);
-  VERIFY_IS_EQUAL(c(2, 1, 2), 26);
-  VERIFY_IS_EQUAL(c(2, 1, 3), 27);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_assign) {
-  CALL_SUBTEST(test_1d());
-  CALL_SUBTEST(test_2d());
-  CALL_SUBTEST(test_3d());
-  CALL_SUBTEST(test_same_type());
-  CALL_SUBTEST(test_auto_resize());
-  CALL_SUBTEST(test_compound_assign());
-  CALL_SUBTEST(test_std_initializers_tensor());
-}
diff --git a/unsupported/test/cxx11_tensor_block_access.cpp b/unsupported/test/cxx11_tensor_block_access.cpp
deleted file mode 100644
index 8dbe4fd..0000000
--- a/unsupported/test/cxx11_tensor_block_access.cpp
+++ /dev/null
@@ -1,523 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2018 Andy Davis <andydavis@google.com>
-// Copyright (C) 2018 Eugene Zhulenev <ezhulenev@google.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <algorithm>
-#include <set>
-
-#include <Eigen/Tensor>
-
-using Eigen::ColMajor;
-using Eigen::Index;
-using Eigen::RowMajor;
-using Eigen::Tensor;
-using Eigen::internal::TensorBlockShapeType;
-
-static TensorOpCost zeroCost() { return {0, 0, 0}; }
-
-template <typename T>
-static const T& choose(int layout, const T& col, const T& row) {
-  return layout == ColMajor ? col : row;
-}
-
-static TensorBlockShapeType RandomShape() {
-  return internal::random<bool>() ? TensorBlockShapeType::kUniformAllDims : TensorBlockShapeType::kSkewedInnerDims;
-}
-
-template <int NumDims>
-static size_t RandomTargetSize(const DSizes<Index, NumDims>& dims) {
-  return internal::random<size_t>(1, dims.TotalSize());
-}
-
-template <int NumDims>
-static DSizes<Index, NumDims> RandomDims() {
-  array<Index, NumDims> dims;
-  for (int i = 0; i < NumDims; ++i) {
-    dims[i] = internal::random<int>(1, 20);
-  }
-  return DSizes<Index, NumDims>(dims);
-}
-
-template <typename T>
-static T* GenerateRandomData(const Index& size) {
-  T* data = new T[size];
-  for (int i = 0; i < size; ++i) {
-    data[i] = internal::random<T>();
-  }
-  return data;
-}
-
-template <int NumDims>
-static void Debug(DSizes<Index, NumDims> dims) {
-  for (int i = 0; i < NumDims; ++i) {
-    std::cout << dims[i] << "; ";
-  }
-  std::cout << std::endl;
-}
-
-template <int Layout>
-static void test_block_mapper_sanity() {
-  typedef internal::TensorBlockMapper<2, Layout> TensorBlockMapper;
-
-  DSizes<Index, 2> tensor_dims(100, 100);
-
-  // Test uniform blocks.
-  TensorBlockMapper uniform_block_mapper(tensor_dims, {TensorBlockShapeType::kUniformAllDims, 100, zeroCost()});
-
-  VERIFY_IS_EQUAL(uniform_block_mapper.blockCount(), 100);
-  VERIFY_IS_EQUAL(uniform_block_mapper.blockTotalSize(), 100);
-
-  // 10x10 blocks
-  auto uniform_b0 = uniform_block_mapper.blockDescriptor(0);
-  VERIFY_IS_EQUAL(uniform_b0.dimensions().at(0), 10);
-  VERIFY_IS_EQUAL(uniform_b0.dimensions().at(1), 10);
-
-  // Test skewed to inner dims blocks.
-  TensorBlockMapper skewed_block_mapper(tensor_dims, {TensorBlockShapeType::kSkewedInnerDims, 100, zeroCost()});
-
-  VERIFY_IS_EQUAL(skewed_block_mapper.blockCount(), 100);
-  VERIFY_IS_EQUAL(skewed_block_mapper.blockTotalSize(), 100);
-
-  // 1x100 (100x1) rows/cols depending on a tensor layout.
-  auto skewed_b0 = skewed_block_mapper.blockDescriptor(0);
-  VERIFY_IS_EQUAL(skewed_b0.dimensions().at(0), choose(Layout, 100, 1));
-  VERIFY_IS_EQUAL(skewed_b0.dimensions().at(1), choose(Layout, 1, 100));
-}
-
-// Given a TensorBlock "visit" every element accessible though it, and a keep an
-// index in the visited set. Verify that every coeff accessed only once.
-template <int NumDims, int Layout>
-static void UpdateCoeffSet(const DSizes<Index, NumDims>& tensor_strides,
-                           const internal::TensorBlockDescriptor<NumDims>& block, Index first_coeff_index,
-                           int dim_index, std::set<Index>* visited_coeffs) {
-  const DSizes<Index, NumDims>& block_sizes = block.dimensions();
-
-  for (int i = 0; i < block_sizes[dim_index]; ++i) {
-    if (tensor_strides[dim_index] == 1) {
-      typedef std::pair<std::set<Index>::iterator, bool> ReturnType;
-      ReturnType inserted = visited_coeffs->insert(first_coeff_index + i);
-      VERIFY_IS_EQUAL(inserted.second, true);
-    } else {
-      int next_dim_index = dim_index + choose(Layout, -1, 1);
-      UpdateCoeffSet<NumDims, Layout>(tensor_strides, block, first_coeff_index, next_dim_index, visited_coeffs);
-      first_coeff_index += tensor_strides[dim_index];
-    }
-  }
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_block_mapper_maps_every_element() {
-  typedef internal::TensorBlockMapper<NumDims, Layout> TensorBlockMapper;
-
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>();
-  DSizes<Index, NumDims> strides = internal::strides<Layout>(dims);
-
-  // Keep track of elements indices available via block access.
-  std::set<Index> coeff_set;
-
-  // Try different combinations of block types and sizes.
-  TensorBlockMapper block_mapper(dims, {RandomShape(), RandomTargetSize(dims), zeroCost()});
-
-  for (int i = 0; i < block_mapper.blockCount(); ++i) {
-    auto block = block_mapper.blockDescriptor(i);
-    UpdateCoeffSet<NumDims, Layout>(strides, block, block.offset(), choose(Layout, NumDims - 1, 0), &coeff_set);
-  }
-
-  // Verify that every coefficient in the original Tensor is accessible through
-  // TensorBlock only once.
-  Index total_coeffs = dims.TotalSize();
-  VERIFY_IS_EQUAL(Index(coeff_set.size()), total_coeffs);
-  VERIFY_IS_EQUAL(*coeff_set.begin(), 0);
-  VERIFY_IS_EQUAL(*coeff_set.rbegin(), total_coeffs - 1);
-}
-
-template <int Layout, int NumDims>
-static Index GetInputIndex(Index output_index, const array<Index, NumDims>& output_to_input_dim_map,
-                           const array<Index, NumDims>& input_strides, const array<Index, NumDims>& output_strides) {
-  int input_index = 0;
-  if (Layout == ColMajor) {
-    for (int i = NumDims - 1; i > 0; --i) {
-      const Index idx = output_index / output_strides[i];
-      input_index += idx * input_strides[output_to_input_dim_map[i]];
-      output_index -= idx * output_strides[i];
-    }
-    return input_index + output_index * input_strides[output_to_input_dim_map[0]];
-  } else {
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const Index idx = output_index / output_strides[i];
-      input_index += idx * input_strides[output_to_input_dim_map[i]];
-      output_index -= idx * output_strides[i];
-    }
-    return input_index + output_index * input_strides[output_to_input_dim_map[NumDims - 1]];
-  }
-}
-
-template <int Layout, int NumDims>
-static array<Index, NumDims> ComputeStrides(const array<Index, NumDims>& sizes) {
-  array<Index, NumDims> strides;
-  if (Layout == ColMajor) {
-    strides[0] = 1;
-    for (int i = 1; i < NumDims; ++i) {
-      strides[i] = strides[i - 1] * sizes[i - 1];
-    }
-  } else {
-    strides[NumDims - 1] = 1;
-    for (int i = NumDims - 2; i >= 0; --i) {
-      strides[i] = strides[i + 1] * sizes[i + 1];
-    }
-  }
-  return strides;
-}
-
-template <typename Scalar, typename StorageIndex, int Dim>
-class EqualityChecker {
-  const Scalar* input_data;
-  const DSizes<StorageIndex, Dim>&input_dims, &input_strides, &output_dims, &output_strides;
-  void check_recursive(const Scalar* input, const Scalar* output, int depth = 0) const {
-    if (depth == Dim) {
-      VERIFY_IS_EQUAL(*input, *output);
-      return;
-    }
-
-    for (int i = 0; i < output_dims[depth]; ++i) {
-      check_recursive(input + i % input_dims[depth] * input_strides[depth], output + i * output_strides[depth],
-                      depth + 1);
-    }
-  }
-
- public:
-  EqualityChecker(const Scalar* input_data_, const DSizes<StorageIndex, Dim>& input_dims_,
-                  const DSizes<StorageIndex, Dim>& input_strides_, const DSizes<StorageIndex, Dim>& output_dims_,
-                  const DSizes<StorageIndex, Dim>& output_strides_)
-      : input_data(input_data_),
-        input_dims(input_dims_),
-        input_strides(input_strides_),
-        output_dims(output_dims_),
-        output_strides(output_strides_) {}
-
-  void operator()(const Scalar* output_data) const { check_recursive(input_data, output_data); }
-};
-
-template <int Layout>
-static void test_uniform_block_shape() {
-  typedef internal::TensorBlockDescriptor<5> TensorBlock;
-  typedef internal::TensorBlockMapper<5, Layout> TensorBlockMapper;
-
-  {
-    // Test shape 'UniformAllDims' with uniform 'max_coeff count'.
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 5 * 5 * 5 * 5 * 5;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    for (int i = 0; i < 5; ++i) {
-      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'UniformAllDims' with larger 'max_coeff count' which spills
-  // partially into first inner-most dimension.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 7 * 5 * 5 * 5 * 5;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
-    for (int i = 1; i < 5; ++i) {
-      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 5 * 5 * 5 * 5 * 6;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(6, block.dimensions()[4]);
-    for (int i = 3; i >= 0; --i) {
-      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'UniformAllDims' with larger 'max_coeff count' which spills
-  // fully into first inner-most dimension.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 11 * 5 * 5 * 5 * 5;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
-    for (int i = 1; i < 5; ++i) {
-      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 5 * 5 * 5 * 5 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    for (int i = 3; i >= 0; --i) {
-      VERIFY_IS_EQUAL(5, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'UniformAllDims' with larger 'max_coeff count' which spills
-  // fully into first few inner-most dimensions.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(7, 5, 6, 17, 7);
-    const Index max_coeff_count = 7 * 5 * 6 * 7 * 5;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
-    VERIFY_IS_EQUAL(7, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[4]);
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(7, 5, 6, 9, 7);
-    const Index max_coeff_count = 5 * 5 * 5 * 6 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY_IS_EQUAL(6, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[2]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[0]);
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'UniformAllDims' with full allocation to all dims.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(7, 5, 6, 17, 7);
-    const Index max_coeff_count = 7 * 5 * 6 * 17 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
-    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(7, 5, 6, 9, 7);
-    const Index max_coeff_count = 7 * 5 * 6 * 9 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kUniformAllDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY_IS_EQUAL(9, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(7, block.dimensions()[0]);
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-}
-
-template <int Layout>
-static void test_skewed_inner_dim_block_shape() {
-  typedef internal::TensorBlockDescriptor<5> TensorBlock;
-  typedef internal::TensorBlockMapper<5, Layout> TensorBlockMapper;
-
-  // Test shape 'SkewedInnerDims' with partial allocation to inner-most dim.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 10 * 1 * 1 * 1 * 1;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(10, block.dimensions()[0]);
-    for (int i = 1; i < 5; ++i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 1 * 1 * 1 * 1 * 6;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(6, block.dimensions()[4]);
-    for (int i = 3; i >= 0; --i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'SkewedInnerDims' with full allocation to inner-most dim.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 11 * 1 * 1 * 1 * 1;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
-    for (int i = 1; i < 5; ++i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 1 * 1 * 1 * 1 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    for (int i = 3; i >= 0; --i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'SkewedInnerDims' with full allocation to inner-most dim,
-  // and partial allocation to second inner-dim.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 11 * 3 * 1 * 1 * 1;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
-    VERIFY_IS_EQUAL(3, block.dimensions()[1]);
-    for (int i = 2; i < 5; ++i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 1 * 1 * 1 * 15 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY_IS_EQUAL(15, block.dimensions()[3]);
-    for (int i = 2; i >= 0; --i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'SkewedInnerDims' with full allocation to inner-most dim,
-  // and partial allocation to third inner-dim.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 11 * 5 * 5 * 1 * 1;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[2]);
-    for (int i = 3; i < 5; ++i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 1 * 1 * 5 * 17 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[2]);
-    for (int i = 1; i >= 0; --i) {
-      VERIFY_IS_EQUAL(1, block.dimensions()[i]);
-    }
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-
-  // Test shape 'SkewedInnerDims' with full allocation to all dims.
-  if (Layout == ColMajor) {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 11 * 5 * 6 * 17 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
-    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  } else {
-    DSizes<Index, 5> dims(11, 5, 6, 17, 7);
-    const Index max_coeff_count = 11 * 5 * 6 * 17 * 7;
-    TensorBlockMapper block_mapper(dims, {TensorBlockShapeType::kSkewedInnerDims, max_coeff_count, zeroCost()});
-    TensorBlock block = block_mapper.blockDescriptor(0);
-    VERIFY_IS_EQUAL(7, block.dimensions()[4]);
-    VERIFY_IS_EQUAL(17, block.dimensions()[3]);
-    VERIFY_IS_EQUAL(6, block.dimensions()[2]);
-    VERIFY_IS_EQUAL(5, block.dimensions()[1]);
-    VERIFY_IS_EQUAL(11, block.dimensions()[0]);
-    VERIFY(block.dimensions().TotalSize() <= max_coeff_count);
-  }
-}
-
-template <int Layout>
-static void test_empty_dims(const internal::TensorBlockShapeType block_shape) {
-  // Test blocking of tensors with zero dimensions:
-  //  - we must not crash on asserts and divisions by zero
-  //  - we must not return block with zero dimensions
-  //    (recipe for overflows/underflows, divisions by zero and NaNs later)
-  //  - total block count must be zero
-  {
-    typedef internal::TensorBlockMapper<1, Layout> TensorBlockMapper;
-
-    DSizes<Index, 1> dims(0);
-    for (size_t max_coeff_count = 0; max_coeff_count < 2; ++max_coeff_count) {
-      TensorBlockMapper block_mapper(dims, {block_shape, max_coeff_count, zeroCost()});
-      VERIFY_IS_EQUAL(block_mapper.blockCount(), 0);
-      VERIFY(block_mapper.blockTotalSize() >= 1);
-    }
-  }
-
-  {
-    typedef internal::TensorBlockMapper<2, Layout> TensorBlockMapper;
-
-    for (int dim1 = 0; dim1 < 3; ++dim1) {
-      for (int dim2 = 0; dim2 < 3; ++dim2) {
-        DSizes<Index, 2> dims(dim1, dim2);
-        for (size_t max_coeff_count = 0; max_coeff_count < 2; ++max_coeff_count) {
-          TensorBlockMapper block_mapper(dims, {block_shape, max_coeff_count, zeroCost()});
-          if (dim1 * dim2 == 0) {
-            VERIFY_IS_EQUAL(block_mapper.blockCount(), 0);
-          }
-          VERIFY(block_mapper.blockTotalSize() >= 1);
-        }
-      }
-    }
-  }
-}
-
-#define TEST_LAYOUTS(NAME)        \
-  CALL_SUBTEST(NAME<ColMajor>()); \
-  CALL_SUBTEST(NAME<RowMajor>())
-
-#define TEST_LAYOUTS_AND_DIMS(TYPE, NAME)    \
-  CALL_SUBTEST((NAME<TYPE, 1, ColMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 1, RowMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 2, ColMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 2, RowMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 3, ColMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 3, RowMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 4, ColMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 4, RowMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 5, ColMajor>())); \
-  CALL_SUBTEST((NAME<TYPE, 5, RowMajor>()))
-
-#define TEST_LAYOUTS_WITH_ARG(NAME, ARG) \
-  CALL_SUBTEST(NAME<ColMajor>(ARG));     \
-  CALL_SUBTEST(NAME<RowMajor>(ARG))
-
-EIGEN_DECLARE_TEST(cxx11_tensor_block_access) {
-  TEST_LAYOUTS(test_block_mapper_sanity);
-  TEST_LAYOUTS_AND_DIMS(float, test_block_mapper_maps_every_element);
-  TEST_LAYOUTS(test_uniform_block_shape);
-  TEST_LAYOUTS(test_skewed_inner_dim_block_shape);
-  TEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kUniformAllDims);
-  TEST_LAYOUTS_WITH_ARG(test_empty_dims, TensorBlockShapeType::kSkewedInnerDims);
-}
-
-#undef TEST_LAYOUTS
-#undef TEST_LAYOUTS_WITH_ARG
diff --git a/unsupported/test/cxx11_tensor_block_eval.cpp b/unsupported/test/cxx11_tensor_block_eval.cpp
deleted file mode 100644
index 0567b3c..0000000
--- a/unsupported/test/cxx11_tensor_block_eval.cpp
+++ /dev/null
@@ -1,797 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// clang-format off
-#include "main.h"
-#include <Eigen/Tensor>
-// clang-format on
-
-using Eigen::internal::TensorBlockDescriptor;
-using Eigen::internal::TensorExecutor;
-
-// -------------------------------------------------------------------------- //
-// Utility functions to generate random tensors, blocks, and evaluate them.
-
-template <int NumDims>
-static DSizes<Index, NumDims> RandomDims(Index min, Index max) {
-  DSizes<Index, NumDims> dims;
-  for (int i = 0; i < NumDims; ++i) {
-    dims[i] = internal::random<Index>(min, max);
-  }
-  return DSizes<Index, NumDims>(dims);
-}
-
-// Block offsets and extents allows to construct a TensorSlicingOp corresponding
-// to a TensorBlockDescriptor.
-template <int NumDims>
-struct TensorBlockParams {
-  DSizes<Index, NumDims> offsets;
-  DSizes<Index, NumDims> sizes;
-  TensorBlockDescriptor<NumDims, Index> desc;
-};
-
-template <int Layout, int NumDims>
-static TensorBlockParams<NumDims> RandomBlock(DSizes<Index, NumDims> dims, Index min, Index max) {
-  // Choose random offsets and sizes along all tensor dimensions.
-  DSizes<Index, NumDims> offsets(RandomDims<NumDims>(min, max));
-  DSizes<Index, NumDims> sizes(RandomDims<NumDims>(min, max));
-
-  // Make sure that offset + size do not overflow dims.
-  for (int i = 0; i < NumDims; ++i) {
-    offsets[i] = numext::mini(dims[i] - 1, offsets[i]);
-    sizes[i] = numext::mini(sizes[i], dims[i] - offsets[i]);
-  }
-
-  Index offset = 0;
-  DSizes<Index, NumDims> strides = Eigen::internal::strides<Layout>(dims);
-  for (int i = 0; i < NumDims; ++i) {
-    offset += strides[i] * offsets[i];
-  }
-
-  return {offsets, sizes, TensorBlockDescriptor<NumDims, Index>(offset, sizes)};
-}
-
-// Generate block with block sizes skewed towards inner dimensions. This type of
-// block is required for evaluating broadcast expressions.
-template <int Layout, int NumDims>
-static TensorBlockParams<NumDims> SkewedInnerBlock(DSizes<Index, NumDims> dims) {
-  using BlockMapper = internal::TensorBlockMapper<NumDims, Layout, Index>;
-  BlockMapper block_mapper(
-      dims,
-      {internal::TensorBlockShapeType::kSkewedInnerDims, internal::random<size_t>(1, dims.TotalSize()), {0, 0, 0}});
-
-  Index total_blocks = block_mapper.blockCount();
-  Index block_index = internal::random<Index>(0, total_blocks - 1);
-  auto block = block_mapper.blockDescriptor(block_index);
-  DSizes<Index, NumDims> sizes = block.dimensions();
-
-  auto strides = internal::strides<Layout>(dims);
-  DSizes<Index, NumDims> offsets;
-
-  // Compute offsets for the first block coefficient.
-  Index index = block.offset();
-  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
-    for (int i = NumDims - 1; i > 0; --i) {
-      const Index idx = index / strides[i];
-      index -= idx * strides[i];
-      offsets[i] = idx;
-    }
-    if (NumDims > 0) offsets[0] = index;
-  } else {
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const Index idx = index / strides[i];
-      index -= idx * strides[i];
-      offsets[i] = idx;
-    }
-    if (NumDims > 0) offsets[NumDims - 1] = index;
-  }
-
-  return {offsets, sizes, block};
-}
-
-template <int NumDims>
-static TensorBlockParams<NumDims> FixedSizeBlock(DSizes<Index, NumDims> dims) {
-  DSizes<Index, NumDims> offsets;
-  for (int i = 0; i < NumDims; ++i) offsets[i] = 0;
-
-  return {offsets, dims, TensorBlockDescriptor<NumDims, Index>(0, dims)};
-}
-
-inline Eigen::IndexList<Index, Eigen::type2index<1>> NByOne(Index n) {
-  Eigen::IndexList<Index, Eigen::type2index<1>> ret;
-  ret.set(0, n);
-  return ret;
-}
-inline Eigen::IndexList<Eigen::type2index<1>, Index> OneByM(Index m) {
-  Eigen::IndexList<Eigen::type2index<1>, Index> ret;
-  ret.set(1, m);
-  return ret;
-}
-
-// -------------------------------------------------------------------------- //
-// Verify that block expression evaluation produces the same result as a
-// TensorSliceOp (reading a tensor block is same to taking a tensor slice).
-
-template <typename T, int NumDims, int Layout, typename Expression, typename GenBlockParams>
-static void VerifyBlockEvaluator(Expression expr, GenBlockParams gen_block) {
-  using Device = DefaultDevice;
-  auto d = Device();
-
-  // Scratch memory allocator for block evaluation.
-  typedef internal::TensorBlockScratchAllocator<Device> TensorBlockScratch;
-  TensorBlockScratch scratch(d);
-
-  // TensorEvaluator is needed to produce tensor blocks of the expression.
-  auto eval = TensorEvaluator<const decltype(expr), Device>(expr, d);
-  eval.evalSubExprsIfNeeded(nullptr);
-
-  // Choose a random offsets, sizes and TensorBlockDescriptor.
-  TensorBlockParams<NumDims> block_params = gen_block();
-
-  // Evaluate TensorBlock expression into a tensor.
-  Tensor<T, NumDims, Layout> block(block_params.desc.dimensions());
-
-  // Dimensions for the potential destination buffer.
-  DSizes<Index, NumDims> dst_dims;
-  if (internal::random<bool>()) {
-    dst_dims = block_params.desc.dimensions();
-  } else {
-    for (int i = 0; i < NumDims; ++i) {
-      Index extent = internal::random<Index>(0, 5);
-      dst_dims[i] = block_params.desc.dimension(i) + extent;
-    }
-  }
-
-  // Maybe use this tensor as a block desc destination.
-  Tensor<T, NumDims, Layout> dst(dst_dims);
-  dst.setZero();
-  if (internal::random<bool>()) {
-    block_params.desc.template AddDestinationBuffer<Layout>(dst.data(), internal::strides<Layout>(dst.dimensions()));
-  }
-
-  const bool root_of_expr = internal::random<bool>();
-  auto tensor_block = eval.block(block_params.desc, scratch, root_of_expr);
-
-  if (tensor_block.kind() == internal::TensorBlockKind::kMaterializedInOutput) {
-    // Copy data from destination buffer.
-    if (dimensions_match(dst.dimensions(), block.dimensions())) {
-      block = dst;
-    } else {
-      DSizes<Index, NumDims> offsets;
-      for (int i = 0; i < NumDims; ++i) offsets[i] = 0;
-      block = dst.slice(offsets, block.dimensions());
-    }
-
-  } else {
-    // Assign to block from expression.
-    auto b_expr = tensor_block.expr();
-
-    // We explicitly disable vectorization and tiling, to run a simple coefficient
-    // wise assignment loop, because it's very simple and should be correct.
-    using BlockAssign = TensorAssignOp<decltype(block), const decltype(b_expr)>;
-    using BlockExecutor = TensorExecutor<const BlockAssign, Device, false, internal::TiledEvaluation::Off>;
-    BlockExecutor::run(BlockAssign(block, b_expr), d);
-  }
-
-  // Cleanup temporary buffers owned by a tensor block.
-  tensor_block.cleanup();
-
-  // Compute a Tensor slice corresponding to a Tensor block.
-  Tensor<T, NumDims, Layout> slice(block_params.desc.dimensions());
-  auto s_expr = expr.slice(block_params.offsets, block_params.sizes);
-
-  // Explicitly use coefficient assignment to evaluate slice expression.
-  using SliceAssign = TensorAssignOp<decltype(slice), const decltype(s_expr)>;
-  using SliceExecutor = TensorExecutor<const SliceAssign, Device, false, internal::TiledEvaluation::Off>;
-  SliceExecutor::run(SliceAssign(slice, s_expr), d);
-
-  // Tensor block and tensor slice must be the same.
-  for (Index i = 0; i < block.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(block.coeff(i), slice.coeff(i));
-  }
-}
-
-// -------------------------------------------------------------------------- //
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_block() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  // Identity tensor expression transformation.
-  VerifyBlockEvaluator<T, NumDims, Layout>(input, [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_unary_expr_block() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.abs(), [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_binary_expr_block() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> lhs(dims), rhs(dims);
-  lhs.setRandom();
-  rhs.setRandom();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(lhs * rhs, [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_binary_with_unary_expr_block() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> lhs(dims), rhs(dims);
-  lhs.setRandom();
-  rhs.setRandom();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>((lhs.abs() + rhs.abs()).sqrt(),
-                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_broadcast() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 10);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  DSizes<Index, NumDims> bcast = RandomDims<NumDims>(1, 5);
-
-  DSizes<Index, NumDims> bcasted_dims;
-  for (int i = 0; i < NumDims; ++i) bcasted_dims[i] = dims[i] * bcast[i];
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast),
-                                           [&bcasted_dims]() { return SkewedInnerBlock<Layout>(bcasted_dims); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast),
-                                           [&bcasted_dims]() { return RandomBlock<Layout>(bcasted_dims, 5, 10); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast),
-                                           [&bcasted_dims]() { return FixedSizeBlock(bcasted_dims); });
-
-  // Check that desc.destination() memory is not shared between two broadcast
-  // materializations.
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.broadcast(bcast) * input.abs().broadcast(bcast),
-                                           [&bcasted_dims]() { return SkewedInnerBlock<Layout>(bcasted_dims); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_reshape() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 10);
-
-  DSizes<Index, NumDims> shuffled = dims;
-  std::shuffle(&shuffled[0], &shuffled[NumDims - 1], std::mt19937(g_seed));
-
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.reshape(shuffled),
-                                           [&shuffled]() { return RandomBlock<Layout>(shuffled, 1, 10); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.reshape(shuffled),
-                                           [&shuffled]() { return SkewedInnerBlock<Layout>(shuffled); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_cast() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.template cast<int>().template cast<T>(),
-                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_select() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> lhs(dims);
-  Tensor<T, NumDims, Layout> rhs(dims);
-  Tensor<bool, NumDims, Layout> cond(dims);
-  lhs.setRandom();
-  rhs.setRandom();
-  cond.setRandom();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(cond.select(lhs, rhs),
-                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 20); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_padding() {
-  const int inner_dim = Layout == static_cast<int>(ColMajor) ? 0 : NumDims - 1;
-
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  DSizes<Index, NumDims> pad_before = RandomDims<NumDims>(0, 4);
-  DSizes<Index, NumDims> pad_after = RandomDims<NumDims>(0, 4);
-  array<std::pair<Index, Index>, NumDims> paddings;
-  for (int i = 0; i < NumDims; ++i) {
-    paddings[i] = std::make_pair(pad_before[i], pad_after[i]);
-  }
-
-  // Test squeezing reads from inner dim.
-  if (internal::random<bool>()) {
-    pad_before[inner_dim] = 0;
-    pad_after[inner_dim] = 0;
-    paddings[inner_dim] = std::make_pair(0, 0);
-  }
-
-  DSizes<Index, NumDims> padded_dims;
-  for (int i = 0; i < NumDims; ++i) {
-    padded_dims[i] = dims[i] + pad_before[i] + pad_after[i];
-  }
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.pad(paddings),
-                                           [&padded_dims]() { return FixedSizeBlock(padded_dims); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.pad(paddings),
-                                           [&padded_dims]() { return RandomBlock<Layout>(padded_dims, 1, 10); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.pad(paddings),
-                                           [&padded_dims]() { return SkewedInnerBlock<Layout>(padded_dims); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_chipping() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  Index chip_dim = internal::random<int>(0, NumDims - 1);
-  Index chip_offset = internal::random<Index>(0, dims[chip_dim] - 2);
-
-  DSizes<Index, NumDims - 1> chipped_dims;
-  for (Index i = 0; i < chip_dim; ++i) {
-    chipped_dims[i] = dims[i];
-  }
-  for (Index i = chip_dim + 1; i < NumDims; ++i) {
-    chipped_dims[i - 1] = dims[i];
-  }
-
-  // Block buffer forwarding.
-  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.chip(chip_offset, chip_dim),
-                                               [&chipped_dims]() { return FixedSizeBlock(chipped_dims); });
-
-  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.chip(chip_offset, chip_dim),
-                                               [&chipped_dims]() { return RandomBlock<Layout>(chipped_dims, 1, 10); });
-
-  // Block expression assignment.
-  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.abs().chip(chip_offset, chip_dim),
-                                               [&chipped_dims]() { return FixedSizeBlock(chipped_dims); });
-
-  VerifyBlockEvaluator<T, NumDims - 1, Layout>(input.abs().chip(chip_offset, chip_dim),
-                                               [&chipped_dims]() { return RandomBlock<Layout>(chipped_dims, 1, 10); });
-}
-
-template <typename T, int NumDims>
-struct SimpleTensorGenerator {
-  T operator()(const array<Index, NumDims>& coords) const {
-    T result = static_cast<T>(0);
-    for (int i = 0; i < NumDims; ++i) {
-      result += static_cast<T>((i + 1) * coords[i]);
-    }
-    return result;
-  }
-};
-
-// Boolean specialization to avoid -Wint-in-bool-context warnings on GCC.
-template <int NumDims>
-struct SimpleTensorGenerator<bool, NumDims> {
-  bool operator()(const array<Index, NumDims>& coords) const {
-    bool result = false;
-    for (int i = 0; i < NumDims; ++i) {
-      result ^= coords[i];
-    }
-    return result;
-  }
-};
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_generator() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  auto generator = SimpleTensorGenerator<T, NumDims>();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.generate(generator), [&dims]() { return FixedSizeBlock(dims); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.generate(generator),
-                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_reverse() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  // Randomly reverse dimensions.
-  Eigen::DSizes<bool, NumDims> reverse;
-  for (int i = 0; i < NumDims; ++i) reverse[i] = internal::random<bool>();
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.reverse(reverse), [&dims]() { return FixedSizeBlock(dims); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.reverse(reverse),
-                                           [&dims]() { return RandomBlock<Layout>(dims, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_slice() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  // Pick a random slice of an input tensor.
-  DSizes<Index, NumDims> slice_start = RandomDims<NumDims>(5, 10);
-  DSizes<Index, NumDims> slice_size = RandomDims<NumDims>(5, 10);
-
-  // Make sure that slice start + size do not overflow tensor dims.
-  for (int i = 0; i < NumDims; ++i) {
-    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
-    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
-  }
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.slice(slice_start, slice_size),
-                                           [&slice_size]() { return FixedSizeBlock(slice_size); });
-
-  VerifyBlockEvaluator<T, NumDims, Layout>(input.slice(slice_start, slice_size),
-                                           [&slice_size]() { return RandomBlock<Layout>(slice_size, 1, 10); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_eval_tensor_shuffle() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  DSizes<Index, NumDims> shuffle;
-  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
-
-  do {
-    DSizes<Index, NumDims> shuffled_dims;
-    for (int i = 0; i < NumDims; ++i) shuffled_dims[i] = dims[shuffle[i]];
-
-    VerifyBlockEvaluator<T, NumDims, Layout>(input.shuffle(shuffle),
-                                             [&shuffled_dims]() { return FixedSizeBlock(shuffled_dims); });
-
-    VerifyBlockEvaluator<T, NumDims, Layout>(input.shuffle(shuffle),
-                                             [&shuffled_dims]() { return RandomBlock<Layout>(shuffled_dims, 1, 5); });
-
-    break;
-
-  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
-}
-
-template <typename T, int Layout>
-static void test_eval_tensor_reshape_with_bcast() {
-  Index dim = internal::random<Index>(1, 100);
-
-  Tensor<T, 2, Layout> lhs(1, dim);
-  Tensor<T, 2, Layout> rhs(dim, 1);
-  lhs.setRandom();
-  rhs.setRandom();
-
-  auto reshapeLhs = NByOne(dim);
-  auto reshapeRhs = OneByM(dim);
-
-  auto bcastLhs = OneByM(dim);
-  auto bcastRhs = NByOne(dim);
-
-  DSizes<Index, 2> dims(dim, dim);
-
-  VerifyBlockEvaluator<T, 2, Layout>(
-      lhs.reshape(reshapeLhs).broadcast(bcastLhs) * rhs.reshape(reshapeRhs).broadcast(bcastRhs),
-      [dims]() { return SkewedInnerBlock<Layout, 2>(dims); });
-}
-
-template <typename T, int Layout>
-static void test_eval_tensor_forced_eval() {
-  Index dim = internal::random<Index>(1, 100);
-
-  Tensor<T, 2, Layout> lhs(dim, 1);
-  Tensor<T, 2, Layout> rhs(1, dim);
-  lhs.setRandom();
-  rhs.setRandom();
-
-  auto bcastLhs = OneByM(dim);
-  auto bcastRhs = NByOne(dim);
-
-  DSizes<Index, 2> dims(dim, dim);
-
-  VerifyBlockEvaluator<T, 2, Layout>((lhs.broadcast(bcastLhs) * rhs.broadcast(bcastRhs)).eval().reshape(dims),
-                                     [dims]() { return SkewedInnerBlock<Layout, 2>(dims); });
-
-  VerifyBlockEvaluator<T, 2, Layout>((lhs.broadcast(bcastLhs) * rhs.broadcast(bcastRhs)).eval().reshape(dims),
-                                     [dims]() { return RandomBlock<Layout, 2>(dims, 1, 50); });
-}
-
-template <typename T, int Layout>
-static void test_eval_tensor_chipping_of_bcast() {
-  if (Layout != static_cast<int>(RowMajor)) return;
-
-  Index dim0 = internal::random<Index>(1, 10);
-  Index dim1 = internal::random<Index>(1, 10);
-  Index dim2 = internal::random<Index>(1, 10);
-
-  Tensor<T, 3, Layout> input(1, dim1, dim2);
-  input.setRandom();
-
-  Eigen::array<Index, 3> bcast = {{dim0, 1, 1}};
-  DSizes<Index, 2> chipped_dims(dim0, dim2);
-
-  VerifyBlockEvaluator<T, 2, Layout>(input.broadcast(bcast).chip(0, 1),
-                                     [chipped_dims]() { return FixedSizeBlock(chipped_dims); });
-
-  VerifyBlockEvaluator<T, 2, Layout>(input.broadcast(bcast).chip(0, 1),
-                                     [chipped_dims]() { return SkewedInnerBlock<Layout, 2>(chipped_dims); });
-
-  VerifyBlockEvaluator<T, 2, Layout>(input.broadcast(bcast).chip(0, 1),
-                                     [chipped_dims]() { return RandomBlock<Layout, 2>(chipped_dims, 1, 5); });
-}
-
-// -------------------------------------------------------------------------- //
-// Verify that assigning block to a Tensor expression produces the same result
-// as an assignment to TensorSliceOp (writing a block is is identical to
-// assigning one tensor to a slice of another tensor).
-
-template <typename T, int NumDims, int Layout, int NumExprDims = NumDims, typename Expression, typename GenBlockParams>
-static void VerifyBlockAssignment(Tensor<T, NumDims, Layout>& tensor, Expression expr, GenBlockParams gen_block) {
-  using Device = DefaultDevice;
-  auto d = Device();
-
-  // We use tensor evaluator as a target for block and slice assignments.
-  auto eval = TensorEvaluator<decltype(expr), Device>(expr, d);
-
-  // Generate a random block, or choose a block that fits in full expression.
-  TensorBlockParams<NumExprDims> block_params = gen_block();
-
-  // Generate random data of the selected block size.
-  Tensor<T, NumExprDims, Layout> block(block_params.desc.dimensions());
-  block.setRandom();
-
-  // ************************************************************************ //
-  // (1) Assignment from a block.
-
-  // Construct a materialize block from a random generated block tensor.
-  internal::TensorMaterializedBlock<T, NumExprDims, Layout> blk(internal::TensorBlockKind::kView, block.data(),
-                                                                block.dimensions());
-
-  // Reset all underlying tensor values to zero.
-  tensor.setZero();
-
-  // Use evaluator to write block into a tensor.
-  eval.writeBlock(block_params.desc, blk);
-
-  // Make a copy of the result after assignment.
-  Tensor<T, NumDims, Layout> block_assigned = tensor;
-
-  // ************************************************************************ //
-  // (2) Assignment to a slice
-
-  // Reset all underlying tensor values to zero.
-  tensor.setZero();
-
-  // Assign block to a slice of original expression
-  auto s_expr = expr.slice(block_params.offsets, block_params.sizes);
-
-  // Explicitly use coefficient assignment to evaluate slice expression.
-  using SliceAssign = TensorAssignOp<decltype(s_expr), const decltype(block)>;
-  using SliceExecutor = TensorExecutor<const SliceAssign, Device, false, internal::TiledEvaluation::Off>;
-  SliceExecutor::run(SliceAssign(s_expr, block), d);
-
-  // Make a copy of the result after assignment.
-  Tensor<T, NumDims, Layout> slice_assigned = tensor;
-
-  for (Index i = 0; i < tensor.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(block_assigned.coeff(i), slice_assigned.coeff(i));
-  }
-}
-
-// -------------------------------------------------------------------------- //
-
-template <typename T, int NumDims, int Layout>
-static void test_assign_to_tensor() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> tensor(dims);
-
-  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map, [&dims]() { return RandomBlock<Layout>(dims, 10, 20); });
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map, [&dims]() { return FixedSizeBlock(dims); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_assign_to_tensor_reshape() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> tensor(dims);
-
-  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
-
-  DSizes<Index, NumDims> shuffled = dims;
-  std::shuffle(&shuffled[0], &shuffled[NumDims - 1], std::mt19937(g_seed));
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reshape(shuffled),
-                                            [&shuffled]() { return RandomBlock<Layout>(shuffled, 1, 10); });
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reshape(shuffled),
-                                            [&shuffled]() { return SkewedInnerBlock<Layout>(shuffled); });
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.reshape(shuffled),
-                                            [&shuffled]() { return FixedSizeBlock(shuffled); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_assign_to_tensor_chipping() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> tensor(dims);
-
-  Index chip_dim = internal::random<int>(0, NumDims - 1);
-  Index chip_offset = internal::random<Index>(0, dims[chip_dim] - 2);
-
-  DSizes<Index, NumDims - 1> chipped_dims;
-  for (Index i = 0; i < chip_dim; ++i) {
-    chipped_dims[i] = dims[i];
-  }
-  for (Index i = chip_dim + 1; i < NumDims; ++i) {
-    chipped_dims[i - 1] = dims[i];
-  }
-
-  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
-
-  VerifyBlockAssignment<T, NumDims, Layout, NumDims - 1>(
-      tensor, map.chip(chip_offset, chip_dim), [&chipped_dims]() { return RandomBlock<Layout>(chipped_dims, 1, 10); });
-
-  VerifyBlockAssignment<T, NumDims, Layout, NumDims - 1>(
-      tensor, map.chip(chip_offset, chip_dim), [&chipped_dims]() { return SkewedInnerBlock<Layout>(chipped_dims); });
-
-  VerifyBlockAssignment<T, NumDims, Layout, NumDims - 1>(tensor, map.chip(chip_offset, chip_dim),
-                                                         [&chipped_dims]() { return FixedSizeBlock(chipped_dims); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_assign_to_tensor_slice() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(10, 20);
-  Tensor<T, NumDims, Layout> tensor(dims);
-
-  // Pick a random slice of tensor.
-  DSizes<Index, NumDims> slice_start = RandomDims<NumDims>(5, 10);
-  DSizes<Index, NumDims> slice_size = RandomDims<NumDims>(5, 10);
-
-  // Make sure that slice start + size do not overflow tensor dims.
-  for (int i = 0; i < NumDims; ++i) {
-    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
-    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
-  }
-
-  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.slice(slice_start, slice_size),
-                                            [&slice_size]() { return RandomBlock<Layout>(slice_size, 1, 10); });
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.slice(slice_start, slice_size),
-                                            [&slice_size]() { return SkewedInnerBlock<Layout>(slice_size); });
-
-  VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.slice(slice_start, slice_size),
-                                            [&slice_size]() { return FixedSizeBlock(slice_size); });
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_assign_to_tensor_shuffle() {
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(5, 15);
-  Tensor<T, NumDims, Layout> tensor(dims);
-
-  DSizes<Index, NumDims> shuffle;
-  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
-
-  TensorMap<Tensor<T, NumDims, Layout>> map(tensor.data(), dims);
-
-  do {
-    DSizes<Index, NumDims> shuffled_dims;
-    for (int i = 0; i < NumDims; ++i) shuffled_dims[i] = dims[shuffle[i]];
-
-    VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.shuffle(shuffle),
-                                              [&shuffled_dims]() { return FixedSizeBlock(shuffled_dims); });
-
-    VerifyBlockAssignment<T, NumDims, Layout>(tensor, map.shuffle(shuffle),
-                                              [&shuffled_dims]() { return RandomBlock<Layout>(shuffled_dims, 1, 5); });
-
-  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
-}
-
-// -------------------------------------------------------------------------- //
-
-#define CALL_SUBTEST_PART(PART) CALL_SUBTEST_##PART
-
-#define CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(PART, NAME)     \
-  CALL_SUBTEST_PART(PART)((NAME<float, 1, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 2, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 3, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 4, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 5, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 1, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 2, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 4, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 4, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 5, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<int, 1, RowMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 2, RowMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 3, RowMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 4, RowMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 5, RowMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 1, ColMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 2, ColMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 4, ColMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 4, ColMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<int, 5, ColMajor>()));   \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 1, RowMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 2, RowMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 3, RowMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 4, RowMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 5, RowMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 1, ColMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 2, ColMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 4, ColMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 4, ColMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, 5, ColMajor>()))
-
-#define CALL_SUBTESTS_DIMS_LAYOUTS(PART, NAME)           \
-  CALL_SUBTEST_PART(PART)((NAME<float, 1, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 2, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 3, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 4, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 5, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 1, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 2, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 4, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 4, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, 5, ColMajor>()))
-
-#define CALL_SUBTESTS_LAYOUTS_TYPES(PART, NAME)       \
-  CALL_SUBTEST_PART(PART)((NAME<float, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<bool, RowMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, ColMajor>()))
-
-EIGEN_DECLARE_TEST(cxx11_tensor_block_eval) {
-  // clang-format off
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(1, test_eval_tensor_block);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(1, test_eval_tensor_binary_expr_block);
-  CALL_SUBTESTS_DIMS_LAYOUTS(1, test_eval_tensor_unary_expr_block);
-  CALL_SUBTESTS_DIMS_LAYOUTS(2, test_eval_tensor_binary_with_unary_expr_block);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(2, test_eval_tensor_broadcast);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(2, test_eval_tensor_reshape);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_cast);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_select);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(3, test_eval_tensor_padding);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_chipping);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_generator);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(4, test_eval_tensor_reverse);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(5, test_eval_tensor_slice);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(5, test_eval_tensor_shuffle);
-
-  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_reshape_with_bcast);
-  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_forced_eval);
-  CALL_SUBTESTS_LAYOUTS_TYPES(6, test_eval_tensor_chipping_of_bcast);
-
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(7, test_assign_to_tensor);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(7, test_assign_to_tensor_reshape);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(7, test_assign_to_tensor_chipping);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_to_tensor_slice);
-  CALL_SUBTESTS_DIMS_LAYOUTS_TYPES(8, test_assign_to_tensor_shuffle);
-
-  // Force CMake to split this test.
-  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8
-
-  // clang-format on
-}
diff --git a/unsupported/test/cxx11_tensor_block_io.cpp b/unsupported/test/cxx11_tensor_block_io.cpp
deleted file mode 100644
index dbc999f..0000000
--- a/unsupported/test/cxx11_tensor_block_io.cpp
+++ /dev/null
@@ -1,432 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// clang-format off
-#include "main.h"
-#include <Eigen/Tensor>
-// clang-format on
-
-// -------------------------------------------------------------------------- //
-// A set of tests for TensorBlockIO: copying data between tensor blocks.
-
-template <int NumDims>
-static DSizes<Index, NumDims> RandomDims(Index min, Index max) {
-  DSizes<Index, NumDims> dims;
-  for (int i = 0; i < NumDims; ++i) {
-    dims[i] = internal::random<Index>(min, max);
-  }
-  return DSizes<Index, NumDims>(dims);
-}
-
-static internal::TensorBlockShapeType RandomBlockShape() {
-  return internal::random<bool>() ? internal::TensorBlockShapeType::kUniformAllDims
-                                  : internal::TensorBlockShapeType::kSkewedInnerDims;
-}
-
-template <int NumDims>
-static size_t RandomTargetBlockSize(const DSizes<Index, NumDims>& dims) {
-  return internal::random<size_t>(1, dims.TotalSize());
-}
-
-template <int Layout, int NumDims>
-static Index GetInputIndex(Index output_index, const array<Index, NumDims>& output_to_input_dim_map,
-                           const array<Index, NumDims>& input_strides, const array<Index, NumDims>& output_strides) {
-  int input_index = 0;
-  if (Layout == ColMajor) {
-    for (int i = NumDims - 1; i > 0; --i) {
-      const Index idx = output_index / output_strides[i];
-      input_index += idx * input_strides[output_to_input_dim_map[i]];
-      output_index -= idx * output_strides[i];
-    }
-    return input_index + output_index * input_strides[output_to_input_dim_map[0]];
-  } else {
-    for (int i = 0; i < NumDims - 1; ++i) {
-      const Index idx = output_index / output_strides[i];
-      input_index += idx * input_strides[output_to_input_dim_map[i]];
-      output_index -= idx * output_strides[i];
-    }
-    return input_index + output_index * input_strides[output_to_input_dim_map[NumDims - 1]];
-  }
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_block_io_copy_data_from_source_to_target() {
-  using TensorBlockIO = internal::TensorBlockIO<T, Index, NumDims, Layout>;
-  using IODst = typename TensorBlockIO::Dst;
-  using IOSrc = typename TensorBlockIO::Src;
-
-  // Generate a random input Tensor.
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 30);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  // Write data to an output Tensor.
-  Tensor<T, NumDims, Layout> output(dims);
-
-  // Construct a tensor block mapper.
-  using TensorBlockMapper = internal::TensorBlockMapper<NumDims, Layout, Index>;
-  TensorBlockMapper block_mapper(dims, {RandomBlockShape(), RandomTargetBlockSize(dims), {0, 0, 0}});
-
-  // We will copy data from input to output through this buffer.
-  Tensor<T, NumDims, Layout> block(block_mapper.blockDimensions());
-
-  // Precompute strides for TensorBlockIO::Copy.
-  auto input_strides = internal::strides<Layout>(dims);
-  auto output_strides = internal::strides<Layout>(dims);
-
-  const T* input_data = input.data();
-  T* output_data = output.data();
-  T* block_data = block.data();
-
-  for (int i = 0; i < block_mapper.blockCount(); ++i) {
-    auto desc = block_mapper.blockDescriptor(i);
-
-    auto blk_dims = desc.dimensions();
-    auto blk_strides = internal::strides<Layout>(blk_dims);
-
-    {
-      // Read from input into a block buffer.
-      IODst dst(blk_dims, blk_strides, block_data, 0);
-      IOSrc src(input_strides, input_data, desc.offset());
-
-      TensorBlockIO::Copy(dst, src);
-    }
-
-    {
-      // Write from block buffer to output.
-      IODst dst(blk_dims, output_strides, output_data, desc.offset());
-      IOSrc src(blk_strides, block_data, 0);
-
-      TensorBlockIO::Copy(dst, src);
-    }
-  }
-
-  for (int i = 0; i < dims.TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(input_data[i], output_data[i]);
-  }
-}
-
-template <typename T, int NumDims, int Layout>
-static void test_block_io_copy_using_reordered_dimensions() {
-  // Generate a random input Tensor.
-  DSizes<Index, NumDims> dims = RandomDims<NumDims>(1, 30);
-  Tensor<T, NumDims, Layout> input(dims);
-  input.setRandom();
-
-  // Create a random dimension re-ordering/shuffle.
-  std::vector<int> shuffle;
-
-  for (int i = 0; i < NumDims; ++i) shuffle.push_back(i);
-  std::shuffle(shuffle.begin(), shuffle.end(), std::mt19937(g_seed));
-
-  DSizes<Index, NumDims> output_tensor_dims;
-  DSizes<Index, NumDims> input_to_output_dim_map;
-  DSizes<Index, NumDims> output_to_input_dim_map;
-  for (Index i = 0; i < NumDims; ++i) {
-    output_tensor_dims[shuffle[i]] = dims[i];
-    input_to_output_dim_map[i] = shuffle[i];
-    output_to_input_dim_map[shuffle[i]] = i;
-  }
-
-  // Write data to an output Tensor.
-  Tensor<T, NumDims, Layout> output(output_tensor_dims);
-
-  // Construct a tensor block mapper.
-  // NOTE: Tensor block mapper works with shuffled dimensions.
-  using TensorBlockMapper = internal::TensorBlockMapper<NumDims, Layout, Index>;
-  TensorBlockMapper block_mapper(output_tensor_dims,
-                                 {RandomBlockShape(), RandomTargetBlockSize(output_tensor_dims), {0, 0, 0}});
-
-  // We will copy data from input to output through this buffer.
-  Tensor<T, NumDims, Layout> block(block_mapper.blockDimensions());
-
-  // Precompute strides for TensorBlockIO::Copy.
-  auto input_strides = internal::strides<Layout>(dims);
-  auto output_strides = internal::strides<Layout>(output_tensor_dims);
-
-  const T* input_data = input.data();
-  T* output_data = output.data();
-  T* block_data = block.data();
-
-  for (Index i = 0; i < block_mapper.blockCount(); ++i) {
-    auto desc = block_mapper.blockDescriptor(i);
-
-    const Index first_coeff_index =
-        GetInputIndex<Layout, NumDims>(desc.offset(), output_to_input_dim_map, input_strides, output_strides);
-
-    // NOTE: Block dimensions are in the same order as output dimensions.
-
-    using TensorBlockIO = internal::TensorBlockIO<T, Index, NumDims, Layout>;
-    using IODst = typename TensorBlockIO::Dst;
-    using IOSrc = typename TensorBlockIO::Src;
-
-    auto blk_dims = desc.dimensions();
-    auto blk_strides = internal::strides<Layout>(blk_dims);
-
-    {
-      // Read from input into a block buffer.
-      IODst dst(blk_dims, blk_strides, block_data, 0);
-      IOSrc src(input_strides, input_data, first_coeff_index);
-
-      // TODO(ezhulenev): Remove when fully switched to TensorBlock.
-      DSizes<int, NumDims> dim_map;
-      for (int j = 0; j < NumDims; ++j) dim_map[j] = static_cast<int>(output_to_input_dim_map[j]);
-      TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/dim_map);
-    }
-
-    {
-      // We need to convert block dimensions from output to input order.
-      auto dst_dims = blk_dims;
-      for (int out_dim = 0; out_dim < NumDims; ++out_dim) {
-        dst_dims[output_to_input_dim_map[out_dim]] = blk_dims[out_dim];
-      }
-
-      // Write from block buffer to output.
-      IODst dst(dst_dims, input_strides, output_data, first_coeff_index);
-      IOSrc src(blk_strides, block_data, 0);
-
-      // TODO(ezhulenev): Remove when fully switched to TensorBlock.
-      DSizes<int, NumDims> dim_map;
-      for (int j = 0; j < NumDims; ++j) dim_map[j] = static_cast<int>(input_to_output_dim_map[j]);
-      TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/dim_map);
-    }
-  }
-
-  for (Index i = 0; i < dims.TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(input_data[i], output_data[i]);
-  }
-}
-
-// This is the special case for reading data with reordering, when dimensions
-// before/after reordering are the same. Squeezing reads along inner dimensions
-// in this case is illegal, because we reorder innermost dimension.
-template <int Layout>
-static void test_block_io_copy_using_reordered_dimensions_do_not_squeeze() {
-  DSizes<Index, 3> tensor_dims(7, 9, 7);
-  DSizes<Index, 3> block_dims = tensor_dims;
-
-  DSizes<int, 3> block_to_tensor_dim;
-  block_to_tensor_dim[0] = 2;
-  block_to_tensor_dim[1] = 1;
-  block_to_tensor_dim[2] = 0;
-
-  auto tensor_strides = internal::strides<Layout>(tensor_dims);
-  auto block_strides = internal::strides<Layout>(block_dims);
-
-  Tensor<float, 3, Layout> block(block_dims);
-  Tensor<float, 3, Layout> tensor(tensor_dims);
-  tensor.setRandom();
-
-  float* tensor_data = tensor.data();
-  float* block_data = block.data();
-
-  using TensorBlockIO = internal::TensorBlockIO<float, Index, 3, Layout>;
-  using IODst = typename TensorBlockIO::Dst;
-  using IOSrc = typename TensorBlockIO::Src;
-
-  // Read from a tensor into a block.
-  IODst dst(block_dims, block_strides, block_data, 0);
-  IOSrc src(tensor_strides, tensor_data, 0);
-
-  TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/block_to_tensor_dim);
-
-  TensorMap<Tensor<float, 3, Layout> > block_tensor(block_data, block_dims);
-  TensorMap<Tensor<float, 3, Layout> > tensor_tensor(tensor_data, tensor_dims);
-
-  for (Index d0 = 0; d0 < tensor_dims[0]; ++d0) {
-    for (Index d1 = 0; d1 < tensor_dims[1]; ++d1) {
-      for (Index d2 = 0; d2 < tensor_dims[2]; ++d2) {
-        float block_value = block_tensor(d2, d1, d0);
-        float tensor_value = tensor_tensor(d0, d1, d2);
-        VERIFY_IS_EQUAL(block_value, tensor_value);
-      }
-    }
-  }
-}
-
-// This is the special case for reading data with reordering, when dimensions
-// before/after reordering are the same. Squeezing reads in this case is allowed
-// because we reorder outer dimensions.
-template <int Layout>
-static void test_block_io_copy_using_reordered_dimensions_squeeze() {
-  DSizes<Index, 4> tensor_dims(7, 5, 9, 9);
-  DSizes<Index, 4> block_dims = tensor_dims;
-
-  DSizes<int, 4> block_to_tensor_dim;
-  block_to_tensor_dim[0] = 0;
-  block_to_tensor_dim[1] = 1;
-  block_to_tensor_dim[2] = 3;
-  block_to_tensor_dim[3] = 2;
-
-  auto tensor_strides = internal::strides<Layout>(tensor_dims);
-  auto block_strides = internal::strides<Layout>(block_dims);
-
-  Tensor<float, 4, Layout> block(block_dims);
-  Tensor<float, 4, Layout> tensor(tensor_dims);
-  tensor.setRandom();
-
-  float* tensor_data = tensor.data();
-  float* block_data = block.data();
-
-  using TensorBlockIO = internal::TensorBlockIO<float, Index, 4, Layout>;
-  using IODst = typename TensorBlockIO::Dst;
-  using IOSrc = typename TensorBlockIO::Src;
-
-  // Read from a tensor into a block.
-  IODst dst(block_dims, block_strides, block_data, 0);
-  IOSrc src(tensor_strides, tensor_data, 0);
-
-  TensorBlockIO::Copy(dst, src, /*dst_to_src_dim_map=*/block_to_tensor_dim);
-
-  TensorMap<Tensor<float, 4, Layout> > block_tensor(block_data, block_dims);
-  TensorMap<Tensor<float, 4, Layout> > tensor_tensor(tensor_data, tensor_dims);
-
-  for (Index d0 = 0; d0 < tensor_dims[0]; ++d0) {
-    for (Index d1 = 0; d1 < tensor_dims[1]; ++d1) {
-      for (Index d2 = 0; d2 < tensor_dims[2]; ++d2) {
-        for (Index d3 = 0; d3 < tensor_dims[3]; ++d3) {
-          float block_value = block_tensor(d0, d1, d3, d2);
-          float tensor_value = tensor_tensor(d0, d1, d2, d3);
-          VERIFY_IS_EQUAL(block_value, tensor_value);
-        }
-      }
-    }
-  }
-}
-
-template <int Layout>
-static void test_block_io_zero_stride() {
-  DSizes<Index, 5> rnd_dims = RandomDims<5>(1, 30);
-
-  DSizes<Index, 5> input_tensor_dims = rnd_dims;
-  input_tensor_dims[0] = 1;
-  input_tensor_dims[2] = 1;
-  input_tensor_dims[4] = 1;
-
-  Tensor<float, 5, Layout> input(input_tensor_dims);
-  input.setRandom();
-
-  DSizes<Index, 5> output_tensor_dims = rnd_dims;
-
-  auto input_tensor_strides = internal::strides<Layout>(input_tensor_dims);
-  auto output_tensor_strides = internal::strides<Layout>(output_tensor_dims);
-
-  auto input_tensor_strides_with_zeros = input_tensor_strides;
-  input_tensor_strides_with_zeros[0] = 0;
-  input_tensor_strides_with_zeros[2] = 0;
-  input_tensor_strides_with_zeros[4] = 0;
-
-  Tensor<float, 5, Layout> output(output_tensor_dims);
-  output.setRandom();
-
-  using TensorBlockIO = internal::TensorBlockIO<float, Index, 5, Layout>;
-  using IODst = typename TensorBlockIO::Dst;
-  using IOSrc = typename TensorBlockIO::Src;
-
-  // Write data from input to output with broadcasting in dims [0, 2, 4].
-  IODst dst(output_tensor_dims, output_tensor_strides, output.data(), 0);
-  IOSrc src(input_tensor_strides_with_zeros, input.data(), 0);
-  TensorBlockIO::Copy(dst, src);
-
-  for (int i = 0; i < output_tensor_dims[0]; ++i) {
-    for (int j = 0; j < output_tensor_dims[1]; ++j) {
-      for (int k = 0; k < output_tensor_dims[2]; ++k) {
-        for (int l = 0; l < output_tensor_dims[3]; ++l) {
-          for (int m = 0; m < output_tensor_dims[4]; ++m) {
-            float input_value = input(0, j, 0, l, 0);
-            float output_value = output(i, j, k, l, m);
-            VERIFY_IS_EQUAL(input_value, output_value);
-          }
-        }
-      }
-    }
-  }
-}
-
-template <int Layout>
-static void test_block_io_squeeze_ones() {
-  using TensorBlockIO = internal::TensorBlockIO<float, Index, 5, Layout>;
-  using IODst = typename TensorBlockIO::Dst;
-  using IOSrc = typename TensorBlockIO::Src;
-
-  // Total size > 1.
-  {
-    DSizes<Index, 5> block_sizes(1, 2, 1, 2, 1);
-    auto strides = internal::strides<Layout>(block_sizes);
-
-    // Create a random input tensor.
-    Tensor<float, 5> input(block_sizes);
-    input.setRandom();
-
-    Tensor<float, 5> output(block_sizes);
-
-    IODst dst(block_sizes, strides, output.data(), 0);
-    IOSrc src(strides, input.data());
-    TensorBlockIO::Copy(dst, src);
-
-    for (Index i = 0; i < block_sizes.TotalSize(); ++i) {
-      VERIFY_IS_EQUAL(output.data()[i], input.data()[i]);
-    }
-  }
-
-  // Total size == 1.
-  {
-    DSizes<Index, 5> block_sizes(1, 1, 1, 1, 1);
-    auto strides = internal::strides<Layout>(block_sizes);
-
-    // Create a random input tensor.
-    Tensor<float, 5> input(block_sizes);
-    input.setRandom();
-
-    Tensor<float, 5> output(block_sizes);
-
-    IODst dst(block_sizes, strides, output.data(), 0);
-    IOSrc src(strides, input.data());
-    TensorBlockIO::Copy(dst, src);
-
-    for (Index i = 0; i < block_sizes.TotalSize(); ++i) {
-      VERIFY_IS_EQUAL(output.data()[i], input.data()[i]);
-    }
-  }
-}
-
-#define CALL_SUBTESTS(NAME)                   \
-  CALL_SUBTEST((NAME<float, 1, RowMajor>())); \
-  CALL_SUBTEST((NAME<float, 2, RowMajor>())); \
-  CALL_SUBTEST((NAME<float, 4, RowMajor>())); \
-  CALL_SUBTEST((NAME<float, 5, RowMajor>())); \
-  CALL_SUBTEST((NAME<float, 1, ColMajor>())); \
-  CALL_SUBTEST((NAME<float, 2, ColMajor>())); \
-  CALL_SUBTEST((NAME<float, 4, ColMajor>())); \
-  CALL_SUBTEST((NAME<float, 5, ColMajor>())); \
-  CALL_SUBTEST((NAME<bool, 1, RowMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 2, RowMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 4, RowMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 5, RowMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 1, ColMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 2, ColMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 4, ColMajor>()));  \
-  CALL_SUBTEST((NAME<bool, 5, ColMajor>()))
-
-EIGEN_DECLARE_TEST(cxx11_tensor_block_io) {
-  // clang-format off
-  CALL_SUBTESTS(test_block_io_copy_data_from_source_to_target);
-  CALL_SUBTESTS(test_block_io_copy_using_reordered_dimensions);
-
-  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_do_not_squeeze<RowMajor>());
-  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_do_not_squeeze<ColMajor>());
-
-  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_squeeze<RowMajor>());
-  CALL_SUBTEST(test_block_io_copy_using_reordered_dimensions_squeeze<ColMajor>());
-
-  CALL_SUBTEST(test_block_io_zero_stride<RowMajor>());
-  CALL_SUBTEST(test_block_io_zero_stride<ColMajor>());
-
-  CALL_SUBTEST(test_block_io_squeeze_ones<RowMajor>());
-  CALL_SUBTEST(test_block_io_squeeze_ones<ColMajor>());
-  // clang-format on
-}
diff --git a/unsupported/test/cxx11_tensor_broadcast_sycl.cpp b/unsupported/test/cxx11_tensor_broadcast_sycl.cpp
deleted file mode 100644
index a8c6c97..0000000
--- a/unsupported/test/cxx11_tensor_broadcast_sycl.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_broadcast_sycl_fixed(const Eigen::SyclDevice& sycl_device) {
-  // BROADCAST test:
-  IndexType inDim1 = 2;
-  IndexType inDim2 = 3;
-  IndexType inDim3 = 5;
-  IndexType inDim4 = 7;
-  IndexType bDim1 = 2;
-  IndexType bDim2 = 3;
-  IndexType bDim3 = 1;
-  IndexType bDim4 = 4;
-  array<IndexType, 4> in_range = {{inDim1, inDim2, inDim3, inDim4}};
-  array<IndexType, 4> broadcasts = {{bDim1, bDim2, bDim3, bDim4}};
-  array<IndexType, 4> out_range;  // = in_range * broadcasts
-  for (size_t i = 0; i < out_range.size(); ++i) out_range[i] = in_range[i] * broadcasts[i];
-
-  Tensor<DataType, 4, DataLayout, IndexType> input(in_range);
-  Tensor<DataType, 4, DataLayout, IndexType> out(out_range);
-
-  for (size_t i = 0; i < in_range.size(); ++i) VERIFY_IS_EQUAL(out.dimension(i), out_range[i]);
-
-  for (IndexType i = 0; i < input.size(); ++i) input(i) = static_cast<DataType>(i);
-
-  DataType* gpu_in_data =
-      static_cast<DataType*>(sycl_device.allocate(input.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<TensorFixedSize<DataType, Sizes<2, 3, 5, 7>, DataLayout, IndexType>> gpu_in(gpu_in_data, in_range);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_out(gpu_out_data, out_range);
-  sycl_device.memcpyHostToDevice(gpu_in_data, input.data(), (input.dimensions().TotalSize()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = gpu_in.broadcast(broadcasts);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < inDim1 * bDim1; ++i) {
-    for (IndexType j = 0; j < inDim2 * bDim2; ++j) {
-      for (IndexType k = 0; k < inDim3 * bDim3; ++k) {
-        for (IndexType l = 0; l < inDim4 * bDim4; ++l) {
-          VERIFY_IS_APPROX(input(i % 2, j % 3, k % 5, l % 7), out(i, j, k, l));
-        }
-      }
-    }
-  }
-  printf("Broadcast Test with fixed size Passed\n");
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_broadcast_sycl(const Eigen::SyclDevice& sycl_device) {
-  // BROADCAST test:
-  IndexType inDim1 = 2;
-  IndexType inDim2 = 3;
-  IndexType inDim3 = 5;
-  IndexType inDim4 = 7;
-  IndexType bDim1 = 2;
-  IndexType bDim2 = 3;
-  IndexType bDim3 = 1;
-  IndexType bDim4 = 4;
-  array<IndexType, 4> in_range = {{inDim1, inDim2, inDim3, inDim4}};
-  array<IndexType, 4> broadcasts = {{bDim1, bDim2, bDim3, bDim4}};
-  array<IndexType, 4> out_range;  // = in_range * broadcasts
-  for (size_t i = 0; i < out_range.size(); ++i) out_range[i] = in_range[i] * broadcasts[i];
-
-  Tensor<DataType, 4, DataLayout, IndexType> input(in_range);
-  Tensor<DataType, 4, DataLayout, IndexType> out(out_range);
-
-  for (size_t i = 0; i < in_range.size(); ++i) VERIFY_IS_EQUAL(out.dimension(i), out_range[i]);
-
-  for (IndexType i = 0; i < input.size(); ++i) input(i) = static_cast<DataType>(i);
-
-  DataType* gpu_in_data =
-      static_cast<DataType*>(sycl_device.allocate(input.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_in(gpu_in_data, in_range);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_out(gpu_out_data, out_range);
-  sycl_device.memcpyHostToDevice(gpu_in_data, input.data(), (input.dimensions().TotalSize()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = gpu_in.broadcast(broadcasts);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < inDim1 * bDim1; ++i) {
-    for (IndexType j = 0; j < inDim2 * bDim2; ++j) {
-      for (IndexType k = 0; k < inDim3 * bDim3; ++k) {
-        for (IndexType l = 0; l < inDim4 * bDim4; ++l) {
-          VERIFY_IS_APPROX(input(i % inDim1, j % inDim2, k % inDim3, l % inDim4), out(i, j, k, l));
-        }
-      }
-    }
-  }
-  printf("Broadcast Test Passed\n");
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType>
-void sycl_broadcast_test_per_device(const cl::sycl::device& d) {
-  std::cout << "Running on " << d.template get_info<cl::sycl::info::device::name>() << std::endl;
-  QueueInterface queueInterface(d);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_broadcast_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_broadcast_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_broadcast_sycl_fixed<DataType, RowMajor, int64_t>(sycl_device);
-  test_broadcast_sycl_fixed<DataType, ColMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_broadcast_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_broadcast_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_broadcast_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_broadcasting.cpp b/unsupported/test/cxx11_tensor_broadcasting.cpp
deleted file mode 100644
index 0fa29a7..0000000
--- a/unsupported/test/cxx11_tensor_broadcasting.cpp
+++ /dev/null
@@ -1,312 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_broadcasting() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> broadcasts;
-  broadcasts[0] = 1;
-  broadcasts[1] = 1;
-  broadcasts[2] = 1;
-  broadcasts[3] = 1;
-
-  Tensor<float, 4, DataLayout> no_broadcast;
-  no_broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(no_broadcast.dimension(0), 2);
-  VERIFY_IS_EQUAL(no_broadcast.dimension(1), 3);
-  VERIFY_IS_EQUAL(no_broadcast.dimension(2), 5);
-  VERIFY_IS_EQUAL(no_broadcast.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_broadcast(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  broadcasts[0] = 2;
-  broadcasts[1] = 3;
-  broadcasts[2] = 1;
-  broadcasts[3] = 4;
-  Tensor<float, 4, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 4);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 5);
-  VERIFY_IS_EQUAL(broadcast.dimension(3), 28);
-
-  for (int i = 0; i < 4; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 28; ++l) {
-          VERIFY_IS_EQUAL(tensor(i % 2, j % 3, k % 5, l % 7), broadcast(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_vectorized_broadcasting() {
-  Tensor<float, 3, DataLayout> tensor(8, 3, 5);
-  tensor.setRandom();
-  array<ptrdiff_t, 3> broadcasts;
-  broadcasts[0] = 2;
-  broadcasts[1] = 3;
-  broadcasts[2] = 4;
-
-  Tensor<float, 3, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 16);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
-
-  for (int i = 0; i < 16; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 20; ++k) {
-        VERIFY_IS_EQUAL(tensor(i % 8, j % 3, k % 5), broadcast(i, j, k));
-      }
-    }
-  }
-
-  tensor.resize(11, 3, 5);
-
-  tensor.setRandom();
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 22);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
-
-  for (int i = 0; i < 22; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 20; ++k) {
-        VERIFY_IS_EQUAL(tensor(i % 11, j % 3, k % 5), broadcast(i, j, k));
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_static_broadcasting() {
-  Tensor<float, 3, DataLayout> tensor(8, 3, 5);
-  tensor.setRandom();
-
-  Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>, Eigen::type2index<4>> broadcasts;
-  Tensor<float, 3, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 16);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
-
-  for (int i = 0; i < 16; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 20; ++k) {
-        VERIFY_IS_EQUAL(tensor(i % 8, j % 3, k % 5), broadcast(i, j, k));
-      }
-    }
-  }
-
-  tensor.resize(11, 3, 5);
-
-  tensor.setRandom();
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 22);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 9);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 20);
-
-  for (int i = 0; i < 22; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 20; ++k) {
-        VERIFY_IS_EQUAL(tensor(i % 11, j % 3, k % 5), broadcast(i, j, k));
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_fixed_size_broadcasting() {
-  // Need to add a [] operator to the Size class for this to work
-#if 0
-  Tensor<float, 1, DataLayout> t1(10);
-  t1.setRandom();
-  TensorFixedSize<float, Sizes<1>, DataLayout> t2;
-  t2 = t2.constant(20.0f);
-
-  Tensor<float, 1, DataLayout> t3 = t1 + t2.broadcast(Eigen::array<int, 1>{{10}});
-  for (int i = 0; i < 10; ++i) {
-    VERIFY_IS_APPROX(t3(i), t1(i) + t2(0));
-  }
-
-  TensorMap<TensorFixedSize<float, Sizes<1>, DataLayout> > t4(t2.data(), {{1}});
-  Tensor<float, 1, DataLayout> t5 = t1 + t4.broadcast(Eigen::array<int, 1>{{10}});
-  for (int i = 0; i < 10; ++i) {
-    VERIFY_IS_APPROX(t5(i), t1(i) + t2(0));
-  }
-#endif
-}
-
-template <int DataLayout>
-static void test_simple_broadcasting_one_by_n() {
-  Tensor<float, 4, DataLayout> tensor(1, 13, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> broadcasts;
-  broadcasts[0] = 9;
-  broadcasts[1] = 1;
-  broadcasts[2] = 1;
-  broadcasts[3] = 1;
-  Tensor<float, 4, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 9);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 13);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 5);
-  VERIFY_IS_EQUAL(broadcast.dimension(3), 7);
-
-  for (int i = 0; i < 9; ++i) {
-    for (int j = 0; j < 13; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i % 1, j % 13, k % 5, l % 7), broadcast(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_simple_broadcasting_n_by_one() {
-  Tensor<float, 4, DataLayout> tensor(7, 3, 5, 1);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> broadcasts;
-  broadcasts[0] = 1;
-  broadcasts[1] = 1;
-  broadcasts[2] = 1;
-  broadcasts[3] = 19;
-  Tensor<float, 4, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 7);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 3);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 5);
-  VERIFY_IS_EQUAL(broadcast.dimension(3), 19);
-
-  for (int i = 0; i < 7; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 19; ++l) {
-          VERIFY_IS_EQUAL(tensor(i % 7, j % 3, k % 5, l % 1), broadcast(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_size_one_broadcasting() {
-  Tensor<float, 1, DataLayout> tensor(1);
-  tensor.setRandom();
-  array<ptrdiff_t, 1> broadcasts = {64};
-  Tensor<float, 1, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), broadcasts[0]);
-
-  for (int i = 0; i < broadcasts[0]; ++i) {
-    VERIFY_IS_EQUAL(tensor(0), broadcast(i));
-  }
-}
-
-template <int DataLayout>
-static void test_simple_broadcasting_one_by_n_by_one_1d() {
-  Tensor<float, 3, DataLayout> tensor(1, 7, 1);
-  tensor.setRandom();
-  array<ptrdiff_t, 3> broadcasts;
-  broadcasts[0] = 5;
-  broadcasts[1] = 1;
-  broadcasts[2] = 13;
-  Tensor<float, 3, DataLayout> broadcasted;
-  broadcasted = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcasted.dimension(0), 5);
-  VERIFY_IS_EQUAL(broadcasted.dimension(1), 7);
-  VERIFY_IS_EQUAL(broadcasted.dimension(2), 13);
-
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      for (int k = 0; k < 13; ++k) {
-        VERIFY_IS_EQUAL(tensor(0, j % 7, 0), broadcasted(i, j, k));
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_simple_broadcasting_one_by_n_by_one_2d() {
-  Tensor<float, 4, DataLayout> tensor(1, 7, 13, 1);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> broadcasts;
-  broadcasts[0] = 5;
-  broadcasts[1] = 1;
-  broadcasts[2] = 1;
-  broadcasts[3] = 19;
-  Tensor<float, 4, DataLayout> broadcast;
-  broadcast = tensor.broadcast(broadcasts);
-
-  VERIFY_IS_EQUAL(broadcast.dimension(0), 5);
-  VERIFY_IS_EQUAL(broadcast.dimension(1), 7);
-  VERIFY_IS_EQUAL(broadcast.dimension(2), 13);
-  VERIFY_IS_EQUAL(broadcast.dimension(3), 19);
-
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      for (int k = 0; k < 13; ++k) {
-        for (int l = 0; l < 19; ++l) {
-          VERIFY_IS_EQUAL(tensor(0, j % 7, k % 13, 0), broadcast(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_broadcasting) {
-  CALL_SUBTEST(test_simple_broadcasting<ColMajor>());
-  CALL_SUBTEST(test_simple_broadcasting<RowMajor>());
-  CALL_SUBTEST(test_vectorized_broadcasting<ColMajor>());
-  CALL_SUBTEST(test_vectorized_broadcasting<RowMajor>());
-  CALL_SUBTEST(test_static_broadcasting<ColMajor>());
-  CALL_SUBTEST(test_static_broadcasting<RowMajor>());
-  CALL_SUBTEST(test_fixed_size_broadcasting<ColMajor>());
-  CALL_SUBTEST(test_fixed_size_broadcasting<RowMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_one_by_n<RowMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_n_by_one<RowMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_one_by_n<ColMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_n_by_one<ColMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_1d<ColMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_2d<ColMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_1d<RowMajor>());
-  CALL_SUBTEST(test_simple_broadcasting_one_by_n_by_one_2d<RowMajor>());
-  CALL_SUBTEST(test_size_one_broadcasting<ColMajor>());
-  CALL_SUBTEST(test_size_one_broadcasting<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_builtins_sycl.cpp b/unsupported/test/cxx11_tensor_builtins_sycl.cpp
deleted file mode 100644
index 1449bdc..0000000
--- a/unsupported/test/cxx11_tensor_builtins_sycl.cpp
+++ /dev/null
@@ -1,509 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-// Functions used to compare the TensorMap implementation on the device with
-// the equivalent on the host
-namespace SYCL {
-
-template <typename T>
-T abs(T x) {
-  return cl::sycl::abs(x);
-}
-template <>
-Eigen::half abs(Eigen::half x) {
-  return Eigen::half(cl::sycl::fabs(static_cast<cl::sycl::half>(x)));
-}
-
-template <>
-float abs(float x) {
-  return cl::sycl::fabs(x);
-}
-
-template <>
-double abs(double x) {
-  return cl::sycl::fabs(x);
-}
-
-template <typename T>
-T square(T x) {
-  return x * x;
-}
-template <typename T>
-T cube(T x) {
-  return x * x * x;
-}
-template <typename T>
-T inverse(T x) {
-  return T(1) / x;
-}
-template <typename T>
-T cwiseMax(T x, T y) {
-  return cl::sycl::max(x, y);
-}
-template <>
-Eigen::half cwiseMax(Eigen::half x, Eigen::half y) {
-  return Eigen::half(cl::sycl::max(static_cast<cl::sycl::half>(x), static_cast<cl::sycl::half>(y)));
-}
-
-template <typename T>
-T cwiseMin(T x, T y) {
-  return cl::sycl::min(x, y);
-}
-template <>
-Eigen::half cwiseMin(Eigen::half x, Eigen::half y) {
-  return Eigen::half(cl::sycl::min(static_cast<cl::sycl::half>(x), static_cast<cl::sycl::half>(y)));
-}
-
-template <typename T>
-T sqrt(T x) {
-  return cl::sycl::sqrt(x);
-}
-template <>
-Eigen::half sqrt(Eigen::half x) {
-  return Eigen::half(cl::sycl::sqrt(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T rsqrt(T x) {
-  return cl::sycl::rsqrt(x);
-}
-template <>
-Eigen::half rsqrt(Eigen::half x) {
-  return Eigen::half(cl::sycl::rsqrt(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T tanh(T x) {
-  return cl::sycl::tanh(x);
-}
-template <>
-Eigen::half tanh(Eigen::half x) {
-  return Eigen::half(cl::sycl::tanh(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T exp(T x) {
-  return cl::sycl::exp(x);
-}
-template <>
-Eigen::half exp(Eigen::half x) {
-  return Eigen::half(cl::sycl::exp(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T expm1(T x) {
-  return cl::sycl::expm1(x);
-}
-template <>
-Eigen::half expm1(Eigen::half x) {
-  return Eigen::half(cl::sycl::expm1(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T log(T x) {
-  return cl::sycl::log(x);
-}
-template <>
-Eigen::half log(Eigen::half x) {
-  return Eigen::half(cl::sycl::log(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T ceil(T x) {
-  return cl::sycl::ceil(x);
-}
-template <>
-Eigen::half ceil(Eigen::half x) {
-  return Eigen::half(cl::sycl::ceil(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T floor(T x) {
-  return cl::sycl::floor(x);
-}
-template <>
-Eigen::half floor(Eigen::half x) {
-  return Eigen::half(cl::sycl::floor(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T round(T x) {
-  return cl::sycl::round(x);
-}
-template <>
-Eigen::half round(Eigen::half x) {
-  return Eigen::half(cl::sycl::round(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T log1p(T x) {
-  return cl::sycl::log1p(x);
-}
-template <>
-Eigen::half log1p(Eigen::half x) {
-  return Eigen::half(cl::sycl::log1p(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T sign(T x) {
-  return cl::sycl::sign(x);
-}
-template <>
-Eigen::half sign(Eigen::half x) {
-  return Eigen::half(cl::sycl::sign(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T isnan(T x) {
-  return cl::sycl::isnan(x);
-}
-template <>
-Eigen::half isnan(Eigen::half x) {
-  return Eigen::half(cl::sycl::isnan(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T isfinite(T x) {
-  return cl::sycl::isfinite(x);
-}
-template <>
-Eigen::half isfinite(Eigen::half x) {
-  return Eigen::half(cl::sycl::isfinite(static_cast<cl::sycl::half>(x)));
-}
-
-template <typename T>
-T isinf(T x) {
-  return cl::sycl::isinf(x);
-}
-template <>
-Eigen::half isinf(Eigen::half x) {
-  return Eigen::half(cl::sycl::isinf(static_cast<cl::sycl::half>(x)));
-}
-}  // namespace SYCL
-
-#define DECLARE_UNARY_STRUCT_NON_SYCL(FUNC)  \
-  struct op_##FUNC {                         \
-    template <typename T>                    \
-    auto operator()(const T& x) {            \
-      return SYCL::FUNC(x);                  \
-    }                                        \
-    template <typename T>                    \
-    auto operator()(const TensorMap<T>& x) { \
-      return x.FUNC();                       \
-    }                                        \
-  };
-
-DECLARE_UNARY_STRUCT_NON_SYCL(abs)
-DECLARE_UNARY_STRUCT_NON_SYCL(square)
-DECLARE_UNARY_STRUCT_NON_SYCL(cube)
-DECLARE_UNARY_STRUCT_NON_SYCL(inverse)
-
-#define DECLARE_BINARY_STRUCT_NON_SYCL(FUNC)                          \
-  struct op_##FUNC {                                                  \
-    template <typename T1, typename T2>                               \
-    auto operator()(const T1& x, const T2& y) {                       \
-      return SYCL::FUNC(x, y);                                        \
-    }                                                                 \
-    template <typename T1, typename T2>                               \
-    auto operator()(const TensorMap<T1>& x, const TensorMap<T2>& y) { \
-      return x.FUNC(y);                                               \
-    }                                                                 \
-  };
-
-DECLARE_BINARY_STRUCT_NON_SYCL(cwiseMax)
-DECLARE_BINARY_STRUCT_NON_SYCL(cwiseMin)
-
-struct EqualAssignment {
-  template <typename Lhs, typename Rhs>
-  void operator()(Lhs& lhs, const Rhs& rhs) {
-    lhs = rhs;
-  }
-};
-
-struct PlusEqualAssignment {
-  template <typename Lhs, typename Rhs>
-  void operator()(Lhs& lhs, const Rhs& rhs) {
-    lhs += rhs;
-  }
-};
-
-template <typename DataType, int DataLayout, typename Assignment, typename Operator>
-void test_unary_builtins_for_scalar(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-  Operator op;
-  Assignment asgn;
-  {
-    /* Assignment(out, Operator(in)) */
-    Tensor<DataType, 3, DataLayout, int64_t> in(tensor_range);
-    Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
-    in = in.random() + DataType(0.01);
-    out = out.random() + DataType(0.01);
-    Tensor<DataType, 3, DataLayout, int64_t> reference(out);
-    DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
-    DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-    TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu(gpu_data, tensor_range);
-    TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
-    sycl_device.memcpyHostToDevice(gpu_data, in.data(), (in.size()) * sizeof(DataType));
-    sycl_device.memcpyHostToDevice(gpu_data_out, out.data(), (out.size()) * sizeof(DataType));
-    auto device_expr = gpu_out.device(sycl_device);
-    asgn(device_expr, op(gpu));
-    sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
-    for (int64_t i = 0; i < out.size(); ++i) {
-      DataType ver = reference(i);
-      asgn(ver, op(in(i)));
-      VERIFY_IS_APPROX(out(i), ver);
-    }
-    sycl_device.deallocate(gpu_data);
-    sycl_device.deallocate(gpu_data_out);
-  }
-  {
-    /* Assignment(out, Operator(out)) */
-    Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
-    // Offset with 1 to avoid tiny output (< 1e-6) as they can easily fail.
-    out = out.random() + DataType(1);
-    Tensor<DataType, 3, DataLayout, int64_t> reference(out);
-    DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-    TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
-    sycl_device.memcpyHostToDevice(gpu_data_out, out.data(), (out.size()) * sizeof(DataType));
-    auto device_expr = gpu_out.device(sycl_device);
-    asgn(device_expr, op(gpu_out));
-    sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
-    for (int64_t i = 0; i < out.size(); ++i) {
-      DataType ver = reference(i);
-      asgn(ver, op(reference(i)));
-      VERIFY_IS_APPROX(out(i), ver);
-    }
-    sycl_device.deallocate(gpu_data_out);
-  }
-}
-
-#define DECLARE_UNARY_STRUCT(FUNC)                                 \
-  struct op_##FUNC {                                               \
-    template <typename T>                                          \
-    auto operator()(const T& x) -> decltype(SYCL::FUNC(x)) {       \
-      return SYCL::FUNC(x);                                        \
-    }                                                              \
-    template <typename T>                                          \
-    auto operator()(const TensorMap<T>& x) -> decltype(x.FUNC()) { \
-      return x.FUNC();                                             \
-    }                                                              \
-  };
-
-DECLARE_UNARY_STRUCT(sqrt)
-DECLARE_UNARY_STRUCT(rsqrt)
-DECLARE_UNARY_STRUCT(tanh)
-DECLARE_UNARY_STRUCT(exp)
-DECLARE_UNARY_STRUCT(expm1)
-DECLARE_UNARY_STRUCT(log)
-DECLARE_UNARY_STRUCT(ceil)
-DECLARE_UNARY_STRUCT(floor)
-DECLARE_UNARY_STRUCT(round)
-DECLARE_UNARY_STRUCT(log1p)
-DECLARE_UNARY_STRUCT(sign)
-DECLARE_UNARY_STRUCT(isnan)
-DECLARE_UNARY_STRUCT(isfinite)
-DECLARE_UNARY_STRUCT(isinf)
-
-template <typename DataType, int DataLayout, typename Assignment>
-void test_unary_builtins_for_assignement(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-#define RUN_UNARY_TEST(FUNC) \
-  test_unary_builtins_for_scalar<DataType, DataLayout, Assignment, op_##FUNC>(sycl_device, tensor_range)
-  RUN_UNARY_TEST(abs);
-  RUN_UNARY_TEST(sqrt);
-  RUN_UNARY_TEST(rsqrt);
-  RUN_UNARY_TEST(square);
-  RUN_UNARY_TEST(cube);
-  RUN_UNARY_TEST(inverse);
-  RUN_UNARY_TEST(tanh);
-  RUN_UNARY_TEST(exp);
-  RUN_UNARY_TEST(expm1);
-  RUN_UNARY_TEST(log);
-  RUN_UNARY_TEST(ceil);
-  RUN_UNARY_TEST(floor);
-  RUN_UNARY_TEST(round);
-  RUN_UNARY_TEST(log1p);
-  RUN_UNARY_TEST(sign);
-}
-
-template <typename DataType, int DataLayout, typename Operator>
-void test_unary_builtins_return_bool(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-  /* out = op(in) */
-  Operator op;
-  Tensor<DataType, 3, DataLayout, int64_t> in(tensor_range);
-  Tensor<bool, 3, DataLayout, int64_t> out(tensor_range);
-  in = in.random() + DataType(0.01);
-  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
-  bool* gpu_data_out = static_cast<bool*>(sycl_device.allocate(out.size() * sizeof(bool)));
-  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu(gpu_data, tensor_range);
-  TensorMap<Tensor<bool, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
-  sycl_device.memcpyHostToDevice(gpu_data, in.data(), (in.size()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = op(gpu);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(bool));
-  for (int64_t i = 0; i < out.size(); ++i) {
-    VERIFY_IS_EQUAL(out(i), op(in(i)));
-  }
-  sycl_device.deallocate(gpu_data);
-  sycl_device.deallocate(gpu_data_out);
-}
-
-template <typename DataType, int DataLayout>
-void test_unary_builtins(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-  test_unary_builtins_for_assignement<DataType, DataLayout, PlusEqualAssignment>(sycl_device, tensor_range);
-  test_unary_builtins_for_assignement<DataType, DataLayout, EqualAssignment>(sycl_device, tensor_range);
-  test_unary_builtins_return_bool<DataType, DataLayout, op_isnan>(sycl_device, tensor_range);
-  test_unary_builtins_return_bool<DataType, DataLayout, op_isfinite>(sycl_device, tensor_range);
-  test_unary_builtins_return_bool<DataType, DataLayout, op_isinf>(sycl_device, tensor_range);
-}
-
-template <typename DataType>
-static void test_builtin_unary_sycl(const Eigen::SyclDevice& sycl_device) {
-  int64_t sizeDim1 = 10;
-  int64_t sizeDim2 = 10;
-  int64_t sizeDim3 = 10;
-  array<int64_t, 3> tensor_range = {{sizeDim1, sizeDim2, sizeDim3}};
-
-  test_unary_builtins<DataType, RowMajor>(sycl_device, tensor_range);
-  test_unary_builtins<DataType, ColMajor>(sycl_device, tensor_range);
-}
-
-template <typename DataType, int DataLayout, typename Operator>
-void test_binary_builtins_func(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-  /* out = op(in_1, in_2) */
-  Operator op;
-  Tensor<DataType, 3, DataLayout, int64_t> in_1(tensor_range);
-  Tensor<DataType, 3, DataLayout, int64_t> in_2(tensor_range);
-  Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
-  in_1 = in_1.random() + DataType(0.01);
-  in_2 = in_2.random() + DataType(0.01);
-  Tensor<DataType, 3, DataLayout, int64_t> reference(out);
-  DataType* gpu_data_1 = static_cast<DataType*>(sycl_device.allocate(in_1.size() * sizeof(DataType)));
-  DataType* gpu_data_2 = static_cast<DataType*>(sycl_device.allocate(in_2.size() * sizeof(DataType)));
-  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_1(gpu_data_1, tensor_range);
-  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_2(gpu_data_2, tensor_range);
-  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
-  sycl_device.memcpyHostToDevice(gpu_data_1, in_1.data(), (in_1.size()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_data_2, in_2.data(), (in_2.size()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = op(gpu_1, gpu_2);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
-  for (int64_t i = 0; i < out.size(); ++i) {
-    VERIFY_IS_APPROX(out(i), op(in_1(i), in_2(i)));
-  }
-  sycl_device.deallocate(gpu_data_1);
-  sycl_device.deallocate(gpu_data_2);
-  sycl_device.deallocate(gpu_data_out);
-}
-
-template <typename DataType, int DataLayout, typename Operator>
-void test_binary_builtins_fixed_arg2(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-  /* out = op(in_1, 2) */
-  Operator op;
-  const DataType arg2(2);
-  Tensor<DataType, 3, DataLayout, int64_t> in_1(tensor_range);
-  Tensor<DataType, 3, DataLayout, int64_t> out(tensor_range);
-  in_1 = in_1.random();
-  Tensor<DataType, 3, DataLayout, int64_t> reference(out);
-  DataType* gpu_data_1 = static_cast<DataType*>(sycl_device.allocate(in_1.size() * sizeof(DataType)));
-  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_1(gpu_data_1, tensor_range);
-  TensorMap<Tensor<DataType, 3, DataLayout, int64_t>> gpu_out(gpu_data_out, tensor_range);
-  sycl_device.memcpyHostToDevice(gpu_data_1, in_1.data(), (in_1.size()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = op(gpu_1, arg2);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, (out.size()) * sizeof(DataType));
-  for (int64_t i = 0; i < out.size(); ++i) {
-    VERIFY_IS_APPROX(out(i), op(in_1(i), arg2));
-  }
-  sycl_device.deallocate(gpu_data_1);
-  sycl_device.deallocate(gpu_data_out);
-}
-
-#define DECLARE_BINARY_STRUCT(FUNC)                                                          \
-  struct op_##FUNC {                                                                         \
-    template <typename T1, typename T2>                                                      \
-    auto operator()(const T1& x, const T2& y) -> decltype(cl::sycl::FUNC(x, y)) {            \
-      return cl::sycl::FUNC(x, y);                                                           \
-    }                                                                                        \
-    template <typename T1, typename T2>                                                      \
-    auto operator()(const TensorMap<T1>& x, const TensorMap<T2>& y) -> decltype(x.FUNC(y)) { \
-      return x.FUNC(y);                                                                      \
-    }                                                                                        \
-  };
-
-#define DECLARE_BINARY_STRUCT_OP(NAME, OPERATOR)                          \
-  struct op_##NAME {                                                      \
-    template <typename T1, typename T2>                                   \
-    auto operator()(const T1& x, const T2& y) -> decltype(x OPERATOR y) { \
-      return x OPERATOR y;                                                \
-    }                                                                     \
-  };
-
-DECLARE_BINARY_STRUCT_OP(plus, +)
-DECLARE_BINARY_STRUCT_OP(minus, -)
-DECLARE_BINARY_STRUCT_OP(times, *)
-DECLARE_BINARY_STRUCT_OP(divide, /)
-DECLARE_BINARY_STRUCT_OP(modulo, %)
-
-template <typename DataType, int DataLayout>
-void test_binary_builtins(const Eigen::SyclDevice& sycl_device, const array<int64_t, 3>& tensor_range) {
-  test_binary_builtins_func<DataType, DataLayout, op_cwiseMax>(sycl_device, tensor_range);
-  test_binary_builtins_func<DataType, DataLayout, op_cwiseMin>(sycl_device, tensor_range);
-  test_binary_builtins_func<DataType, DataLayout, op_plus>(sycl_device, tensor_range);
-  test_binary_builtins_func<DataType, DataLayout, op_minus>(sycl_device, tensor_range);
-  test_binary_builtins_func<DataType, DataLayout, op_times>(sycl_device, tensor_range);
-  test_binary_builtins_func<DataType, DataLayout, op_divide>(sycl_device, tensor_range);
-}
-
-template <typename DataType>
-static void test_floating_builtin_binary_sycl(const Eigen::SyclDevice& sycl_device) {
-  int64_t sizeDim1 = 10;
-  int64_t sizeDim2 = 10;
-  int64_t sizeDim3 = 10;
-  array<int64_t, 3> tensor_range = {{sizeDim1, sizeDim2, sizeDim3}};
-  test_binary_builtins<DataType, RowMajor>(sycl_device, tensor_range);
-  test_binary_builtins<DataType, ColMajor>(sycl_device, tensor_range);
-}
-
-template <typename DataType>
-static void test_integer_builtin_binary_sycl(const Eigen::SyclDevice& sycl_device) {
-  int64_t sizeDim1 = 10;
-  int64_t sizeDim2 = 10;
-  int64_t sizeDim3 = 10;
-  array<int64_t, 3> tensor_range = {{sizeDim1, sizeDim2, sizeDim3}};
-  test_binary_builtins_fixed_arg2<DataType, RowMajor, op_modulo>(sycl_device, tensor_range);
-  test_binary_builtins_fixed_arg2<DataType, ColMajor, op_modulo>(sycl_device, tensor_range);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_builtins_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    QueueInterface queueInterface(device);
-    Eigen::SyclDevice sycl_device(&queueInterface);
-    CALL_SUBTEST_1(test_builtin_unary_sycl<half>(sycl_device));
-    CALL_SUBTEST_2(test_floating_builtin_binary_sycl<half>(sycl_device));
-    CALL_SUBTEST_3(test_builtin_unary_sycl<float>(sycl_device));
-    CALL_SUBTEST_4(test_floating_builtin_binary_sycl<float>(sycl_device));
-    CALL_SUBTEST_5(test_integer_builtin_binary_sycl<int>(sycl_device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_cast_float16_gpu.cu b/unsupported/test/cxx11_tensor_cast_float16_gpu.cu
deleted file mode 100644
index 2028751..0000000
--- a/unsupported/test/cxx11_tensor_cast_float16_gpu.cu
+++ /dev/null
@@ -1,73 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-void test_gpu_conversion() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  Tensor<float, 1> floats(num_elem);
-  floats.setRandom();
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  float* d_conv = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_half(d_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
-
-  gpu_device.memcpyHostToDevice(d_float, floats.data(), num_elem * sizeof(float));
-
-  gpu_half.device(gpu_device) = gpu_float.cast<Eigen::half>();
-  gpu_conv.device(gpu_device) = gpu_half.cast<float>();
-
-  Tensor<float, 1> initial(num_elem);
-  Tensor<float, 1> final(num_elem);
-  gpu_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(initial(i), final(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_half);
-  gpu_device.deallocate(d_conv);
-}
-
-void test_fallback_conversion() {
-  int num_elem = 101;
-  Tensor<float, 1> floats(num_elem);
-  floats.setRandom();
-
-  Eigen::Tensor<Eigen::half, 1> halfs = floats.cast<Eigen::half>();
-  Eigen::Tensor<float, 1> conv = halfs.cast<float>();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(floats(i), conv(i));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_cast_float16_gpu) {
-  CALL_SUBTEST(test_gpu_conversion());
-  CALL_SUBTEST(test_fallback_conversion());
-}
diff --git a/unsupported/test/cxx11_tensor_casts.cpp b/unsupported/test/cxx11_tensor_casts.cpp
deleted file mode 100644
index 4b8e67e..0000000
--- a/unsupported/test/cxx11_tensor_casts.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include "random_without_cast_overflow.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::Tensor;
-
-template <typename FromType, typename ToType>
-static void test_type_cast() {
-  Tensor<FromType, 2> ftensor(101, 201);
-  // Generate random values for a valid cast.
-  for (int i = 0; i < 101; ++i) {
-    for (int j = 0; j < 201; ++j) {
-      ftensor(i, j) = internal::random_without_cast_overflow<FromType, ToType>::value();
-    }
-  }
-
-  Tensor<ToType, 2> ttensor(101, 201);
-  ttensor = ftensor.template cast<ToType>();
-
-  for (int i = 0; i < 101; ++i) {
-    for (int j = 0; j < 201; ++j) {
-      const ToType ref = internal::cast<FromType, ToType>(ftensor(i, j));
-      VERIFY_IS_EQUAL(ttensor(i, j), ref);
-    }
-  }
-}
-
-template <typename Scalar, typename EnableIf = void>
-struct test_cast_runner {
-  static void run() {
-    test_type_cast<Scalar, bool>();
-    test_type_cast<Scalar, int8_t>();
-    test_type_cast<Scalar, int16_t>();
-    test_type_cast<Scalar, int32_t>();
-    test_type_cast<Scalar, int64_t>();
-    test_type_cast<Scalar, uint8_t>();
-    test_type_cast<Scalar, uint16_t>();
-    test_type_cast<Scalar, uint32_t>();
-    test_type_cast<Scalar, uint64_t>();
-    test_type_cast<Scalar, half>();
-    test_type_cast<Scalar, bfloat16>();
-    test_type_cast<Scalar, float>();
-    test_type_cast<Scalar, double>();
-    test_type_cast<Scalar, std::complex<float>>();
-    test_type_cast<Scalar, std::complex<double>>();
-  }
-};
-
-// Only certain types allow cast from std::complex<>.
-template <typename Scalar>
-struct test_cast_runner<Scalar, std::enable_if_t<NumTraits<Scalar>::IsComplex>> {
-  static void run() {
-    test_type_cast<Scalar, half>();
-    test_type_cast<Scalar, bfloat16>();
-    test_type_cast<Scalar, std::complex<float>>();
-    test_type_cast<Scalar, std::complex<double>>();
-  }
-};
-
-EIGEN_DECLARE_TEST(cxx11_tensor_casts) {
-  CALL_SUBTEST(test_cast_runner<bool>::run());
-  CALL_SUBTEST(test_cast_runner<int8_t>::run());
-  CALL_SUBTEST(test_cast_runner<int16_t>::run());
-  CALL_SUBTEST(test_cast_runner<int32_t>::run());
-  CALL_SUBTEST(test_cast_runner<int64_t>::run());
-  CALL_SUBTEST(test_cast_runner<uint8_t>::run());
-  CALL_SUBTEST(test_cast_runner<uint16_t>::run());
-  CALL_SUBTEST(test_cast_runner<uint32_t>::run());
-  CALL_SUBTEST(test_cast_runner<uint64_t>::run());
-  CALL_SUBTEST(test_cast_runner<half>::run());
-  CALL_SUBTEST(test_cast_runner<bfloat16>::run());
-  CALL_SUBTEST(test_cast_runner<float>::run());
-  CALL_SUBTEST(test_cast_runner<double>::run());
-  CALL_SUBTEST(test_cast_runner<std::complex<float>>::run());
-  CALL_SUBTEST(test_cast_runner<std::complex<double>>::run());
-}
diff --git a/unsupported/test/cxx11_tensor_chipping.cpp b/unsupported/test/cxx11_tensor_chipping.cpp
deleted file mode 100644
index b06b297..0000000
--- a/unsupported/test/cxx11_tensor_chipping.cpp
+++ /dev/null
@@ -1,419 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_chip() {
-  Tensor<float, 5, DataLayout> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-
-  Tensor<float, 4, DataLayout> chip1;
-  chip1 = tensor.template chip<0>(1);
-
-  VERIFY_IS_EQUAL(chip1.dimension(0), 3);
-  VERIFY_IS_EQUAL(chip1.dimension(1), 5);
-  VERIFY_IS_EQUAL(chip1.dimension(2), 7);
-  VERIFY_IS_EQUAL(chip1.dimension(3), 11);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1, i, j, k, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip2 = tensor.template chip<1>(1);
-  VERIFY_IS_EQUAL(chip2.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip2.dimension(1), 5);
-  VERIFY_IS_EQUAL(chip2.dimension(2), 7);
-  VERIFY_IS_EQUAL(chip2.dimension(3), 11);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1, j, k, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip3 = tensor.template chip<2>(2);
-  VERIFY_IS_EQUAL(chip3.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip3.dimension(1), 3);
-  VERIFY_IS_EQUAL(chip3.dimension(2), 7);
-  VERIFY_IS_EQUAL(chip3.dimension(3), 11);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2, k, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip4(tensor.template chip<3>(5));
-  VERIFY_IS_EQUAL(chip4.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip4.dimension(1), 3);
-  VERIFY_IS_EQUAL(chip4.dimension(2), 5);
-  VERIFY_IS_EQUAL(chip4.dimension(3), 11);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip5(tensor.template chip<4>(7));
-  VERIFY_IS_EQUAL(chip5.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip5.dimension(1), 3);
-  VERIFY_IS_EQUAL(chip5.dimension(2), 5);
-  VERIFY_IS_EQUAL(chip5.dimension(3), 7);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_dynamic_chip() {
-  Tensor<float, 5, DataLayout> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-
-  Tensor<float, 4, DataLayout> chip1;
-  chip1 = tensor.chip(1, 0);
-  VERIFY_IS_EQUAL(chip1.dimension(0), 3);
-  VERIFY_IS_EQUAL(chip1.dimension(1), 5);
-  VERIFY_IS_EQUAL(chip1.dimension(2), 7);
-  VERIFY_IS_EQUAL(chip1.dimension(3), 11);
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1, i, j, k, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip2 = tensor.chip(1, 1);
-  VERIFY_IS_EQUAL(chip2.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip2.dimension(1), 5);
-  VERIFY_IS_EQUAL(chip2.dimension(2), 7);
-  VERIFY_IS_EQUAL(chip2.dimension(3), 11);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1, j, k, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip3 = tensor.chip(2, 2);
-  VERIFY_IS_EQUAL(chip3.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip3.dimension(1), 3);
-  VERIFY_IS_EQUAL(chip3.dimension(2), 7);
-  VERIFY_IS_EQUAL(chip3.dimension(3), 11);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2, k, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip4(tensor.chip(5, 3));
-  VERIFY_IS_EQUAL(chip4.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip4.dimension(1), 3);
-  VERIFY_IS_EQUAL(chip4.dimension(2), 5);
-  VERIFY_IS_EQUAL(chip4.dimension(3), 11);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5, l));
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> chip5(tensor.chip(7, 4));
-  VERIFY_IS_EQUAL(chip5.dimension(0), 2);
-  VERIFY_IS_EQUAL(chip5.dimension(1), 3);
-  VERIFY_IS_EQUAL(chip5.dimension(2), 5);
-  VERIFY_IS_EQUAL(chip5.dimension(3), 7);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_chip_in_expr() {
-  Tensor<float, 5, DataLayout> input1(2, 3, 5, 7, 11);
-  input1.setRandom();
-  Tensor<float, 4, DataLayout> input2(3, 5, 7, 11);
-  input2.setRandom();
-
-  Tensor<float, 4, DataLayout> result = input1.template chip<0>(0) + input2;
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          float expected = input1(0, i, j, k, l) + input2(i, j, k, l);
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected);
-        }
-      }
-    }
-  }
-
-  Tensor<float, 3, DataLayout> input3(3, 7, 11);
-  input3.setRandom();
-  Tensor<float, 3, DataLayout> result2 = input1.template chip<0>(0).template chip<1>(2) + input3;
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      for (int k = 0; k < 11; ++k) {
-        float expected = input1(0, i, 2, j, k) + input3(i, j, k);
-        VERIFY_IS_EQUAL(result2(i, j, k), expected);
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_chip_as_lvalue() {
-  Tensor<float, 5, DataLayout> input1(2, 3, 5, 7, 11);
-  input1.setRandom();
-
-  Tensor<float, 4, DataLayout> input2(3, 5, 7, 11);
-  input2.setRandom();
-  Tensor<float, 5, DataLayout> tensor = input1;
-  tensor.template chip<0>(1) = input2;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          for (int m = 0; m < 11; ++m) {
-            if (i != 1) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input2(j, k, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> input3(2, 5, 7, 11);
-  input3.setRandom();
-  tensor = input1;
-  tensor.template chip<1>(1) = input3;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          for (int m = 0; m < 11; ++m) {
-            if (j != 1) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input3(i, k, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> input4(2, 3, 7, 11);
-  input4.setRandom();
-  tensor = input1;
-  tensor.template chip<2>(3) = input4;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          for (int m = 0; m < 11; ++m) {
-            if (k != 3) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input4(i, j, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> input5(2, 3, 5, 11);
-  input5.setRandom();
-  tensor = input1;
-  tensor.template chip<3>(4) = input5;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          for (int m = 0; m < 11; ++m) {
-            if (l != 4) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input5(i, j, k, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  Tensor<float, 4, DataLayout> input6(2, 3, 5, 7);
-  input6.setRandom();
-  tensor = input1;
-  tensor.template chip<4>(5) = input6;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          for (int m = 0; m < 11; ++m) {
-            if (m != 5) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input6(i, j, k, l));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  Tensor<float, 5, DataLayout> input7(2, 3, 5, 7, 11);
-  input7.setRandom();
-  tensor = input1;
-  tensor.chip(0, 0) = input7.chip(0, 0);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          for (int m = 0; m < 11; ++m) {
-            if (i != 0) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input7(i, j, k, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-static void test_chip_raw_data_col_major() {
-  Tensor<float, 5, ColMajor> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-
-  typedef TensorEvaluator<decltype(tensor.chip<4>(3)), DefaultDevice> Evaluator4;
-  auto chip = Evaluator4(tensor.chip<4>(3), DefaultDevice());
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          int chip_index = i + 2 * (j + 3 * (k + 5 * l));
-          VERIFY_IS_EQUAL(chip.data()[chip_index], tensor(i, j, k, l, 3));
-        }
-      }
-    }
-  }
-
-  typedef TensorEvaluator<decltype(tensor.chip<0>(0)), DefaultDevice> Evaluator0;
-  auto chip0 = Evaluator0(tensor.chip<0>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip0.data(), static_cast<float*>(0));
-
-  typedef TensorEvaluator<decltype(tensor.chip<1>(0)), DefaultDevice> Evaluator1;
-  auto chip1 = Evaluator1(tensor.chip<1>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip1.data(), static_cast<float*>(0));
-
-  typedef TensorEvaluator<decltype(tensor.chip<2>(0)), DefaultDevice> Evaluator2;
-  auto chip2 = Evaluator2(tensor.chip<2>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip2.data(), static_cast<float*>(0));
-
-  typedef TensorEvaluator<decltype(tensor.chip<3>(0)), DefaultDevice> Evaluator3;
-  auto chip3 = Evaluator3(tensor.chip<3>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip3.data(), static_cast<float*>(0));
-}
-
-static void test_chip_raw_data_row_major() {
-  Tensor<float, 5, RowMajor> tensor(11, 7, 5, 3, 2);
-  tensor.setRandom();
-
-  typedef TensorEvaluator<decltype(tensor.chip<0>(3)), DefaultDevice> Evaluator0;
-  auto chip = Evaluator0(tensor.chip<0>(3), DefaultDevice());
-  for (int i = 0; i < 7; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 2; ++l) {
-          int chip_index = l + 2 * (k + 3 * (j + 5 * i));
-          VERIFY_IS_EQUAL(chip.data()[chip_index], tensor(3, i, j, k, l));
-        }
-      }
-    }
-  }
-
-  typedef TensorEvaluator<decltype(tensor.chip<1>(0)), DefaultDevice> Evaluator1;
-  auto chip1 = Evaluator1(tensor.chip<1>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip1.data(), static_cast<float*>(0));
-
-  typedef TensorEvaluator<decltype(tensor.chip<2>(0)), DefaultDevice> Evaluator2;
-  auto chip2 = Evaluator2(tensor.chip<2>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip2.data(), static_cast<float*>(0));
-
-  typedef TensorEvaluator<decltype(tensor.chip<3>(0)), DefaultDevice> Evaluator3;
-  auto chip3 = Evaluator3(tensor.chip<3>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip3.data(), static_cast<float*>(0));
-
-  typedef TensorEvaluator<decltype(tensor.chip<4>(0)), DefaultDevice> Evaluator4;
-  auto chip4 = Evaluator4(tensor.chip<4>(0), DefaultDevice());
-  VERIFY_IS_EQUAL(chip4.data(), static_cast<float*>(0));
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_chipping) {
-  CALL_SUBTEST(test_simple_chip<ColMajor>());
-  CALL_SUBTEST(test_simple_chip<RowMajor>());
-  CALL_SUBTEST(test_dynamic_chip<ColMajor>());
-  CALL_SUBTEST(test_dynamic_chip<RowMajor>());
-  CALL_SUBTEST(test_chip_in_expr<ColMajor>());
-  CALL_SUBTEST(test_chip_in_expr<RowMajor>());
-  CALL_SUBTEST(test_chip_as_lvalue<ColMajor>());
-  CALL_SUBTEST(test_chip_as_lvalue<RowMajor>());
-  CALL_SUBTEST(test_chip_raw_data_col_major());
-  CALL_SUBTEST(test_chip_raw_data_row_major());
-}
diff --git a/unsupported/test/cxx11_tensor_chipping_sycl.cpp b/unsupported/test/cxx11_tensor_chipping_sycl.cpp
deleted file mode 100644
index eb50e15..0000000
--- a/unsupported/test/cxx11_tensor_chipping_sycl.cpp
+++ /dev/null
@@ -1,612 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_static_chip_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  IndexType sizeDim5 = 11;
-
-  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-  array<IndexType, 4> chip1TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-
-  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> chip1(chip1TensorRange);
-
-  tensor.setRandom();
-
-  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
-  const size_t chip1TensorBuffSize = chip1.size() * sizeof(DataType);
-  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_chip1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
-
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip1(gpu_data_chip1, chip1TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
-  gpu_chip1.device(sycl_device) = gpu_tensor.template chip<0l>(1l);
-  sycl_device.memcpyDeviceToHost(chip1.data(), gpu_data_chip1, chip1TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip1.dimension(0), sizeDim2);
-  VERIFY_IS_EQUAL(chip1.dimension(1), sizeDim3);
-  VERIFY_IS_EQUAL(chip1.dimension(2), sizeDim4);
-  VERIFY_IS_EQUAL(chip1.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim2; ++i) {
-    for (IndexType j = 0; j < sizeDim3; ++j) {
-      for (IndexType k = 0; k < sizeDim4; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1l, i, j, k, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip2TensorRange = {{sizeDim1, sizeDim3, sizeDim4, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip2(chip2TensorRange);
-  const size_t chip2TensorBuffSize = chip2.size() * sizeof(DataType);
-  DataType* gpu_data_chip2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip2(gpu_data_chip2, chip2TensorRange);
-
-  gpu_chip2.device(sycl_device) = gpu_tensor.template chip<1l>(1l);
-  sycl_device.memcpyDeviceToHost(chip2.data(), gpu_data_chip2, chip2TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip2.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip2.dimension(1), sizeDim3);
-  VERIFY_IS_EQUAL(chip2.dimension(2), sizeDim4);
-  VERIFY_IS_EQUAL(chip2.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim3; ++j) {
-      for (IndexType k = 0; k < sizeDim4; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1l, j, k, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip3TensorRange = {{sizeDim1, sizeDim2, sizeDim4, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip3(chip3TensorRange);
-  const size_t chip3TensorBuffSize = chip3.size() * sizeof(DataType);
-  DataType* gpu_data_chip3 = static_cast<DataType*>(sycl_device.allocate(chip3TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip3(gpu_data_chip3, chip3TensorRange);
-
-  gpu_chip3.device(sycl_device) = gpu_tensor.template chip<2l>(2l);
-  sycl_device.memcpyDeviceToHost(chip3.data(), gpu_data_chip3, chip3TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip3.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip3.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(chip3.dimension(2), sizeDim4);
-  VERIFY_IS_EQUAL(chip3.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim4; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2l, k, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip4TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip4(chip4TensorRange);
-  const size_t chip4TensorBuffSize = chip4.size() * sizeof(DataType);
-  DataType* gpu_data_chip4 = static_cast<DataType*>(sycl_device.allocate(chip4TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip4(gpu_data_chip4, chip4TensorRange);
-
-  gpu_chip4.device(sycl_device) = gpu_tensor.template chip<3l>(5l);
-  sycl_device.memcpyDeviceToHost(chip4.data(), gpu_data_chip4, chip4TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip4.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip4.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(chip4.dimension(2), sizeDim3);
-  VERIFY_IS_EQUAL(chip4.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5l, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip5TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip5(chip5TensorRange);
-  const size_t chip5TensorBuffSize = chip5.size() * sizeof(DataType);
-  DataType* gpu_data_chip5 = static_cast<DataType*>(sycl_device.allocate(chip5TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip5(gpu_data_chip5, chip5TensorRange);
-
-  gpu_chip5.device(sycl_device) = gpu_tensor.template chip<4l>(7l);
-  sycl_device.memcpyDeviceToHost(chip5.data(), gpu_data_chip5, chip5TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip5.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip5.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(chip5.dimension(2), sizeDim3);
-  VERIFY_IS_EQUAL(chip5.dimension(3), sizeDim4);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        for (IndexType l = 0; l < sizeDim4; ++l) {
-          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7l));
-        }
-      }
-    }
-  }
-
-  sycl_device.deallocate(gpu_data_tensor);
-  sycl_device.deallocate(gpu_data_chip1);
-  sycl_device.deallocate(gpu_data_chip2);
-  sycl_device.deallocate(gpu_data_chip3);
-  sycl_device.deallocate(gpu_data_chip4);
-  sycl_device.deallocate(gpu_data_chip5);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_dynamic_chip_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  IndexType sizeDim5 = 11;
-
-  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-  array<IndexType, 4> chip1TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-
-  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> chip1(chip1TensorRange);
-
-  tensor.setRandom();
-
-  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
-  const size_t chip1TensorBuffSize = chip1.size() * sizeof(DataType);
-  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_chip1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
-
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip1(gpu_data_chip1, chip1TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
-  gpu_chip1.device(sycl_device) = gpu_tensor.chip(1l, 0l);
-  sycl_device.memcpyDeviceToHost(chip1.data(), gpu_data_chip1, chip1TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip1.dimension(0), sizeDim2);
-  VERIFY_IS_EQUAL(chip1.dimension(1), sizeDim3);
-  VERIFY_IS_EQUAL(chip1.dimension(2), sizeDim4);
-  VERIFY_IS_EQUAL(chip1.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim2; ++i) {
-    for (IndexType j = 0; j < sizeDim3; ++j) {
-      for (IndexType k = 0; k < sizeDim4; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip1(i, j, k, l), tensor(1l, i, j, k, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip2TensorRange = {{sizeDim1, sizeDim3, sizeDim4, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip2(chip2TensorRange);
-  const size_t chip2TensorBuffSize = chip2.size() * sizeof(DataType);
-  DataType* gpu_data_chip2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip2(gpu_data_chip2, chip2TensorRange);
-
-  gpu_chip2.device(sycl_device) = gpu_tensor.chip(1l, 1l);
-  sycl_device.memcpyDeviceToHost(chip2.data(), gpu_data_chip2, chip2TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip2.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip2.dimension(1), sizeDim3);
-  VERIFY_IS_EQUAL(chip2.dimension(2), sizeDim4);
-  VERIFY_IS_EQUAL(chip2.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim3; ++j) {
-      for (IndexType k = 0; k < sizeDim4; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip2(i, j, k, l), tensor(i, 1l, j, k, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip3TensorRange = {{sizeDim1, sizeDim2, sizeDim4, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip3(chip3TensorRange);
-  const size_t chip3TensorBuffSize = chip3.size() * sizeof(DataType);
-  DataType* gpu_data_chip3 = static_cast<DataType*>(sycl_device.allocate(chip3TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip3(gpu_data_chip3, chip3TensorRange);
-
-  gpu_chip3.device(sycl_device) = gpu_tensor.chip(2l, 2l);
-  sycl_device.memcpyDeviceToHost(chip3.data(), gpu_data_chip3, chip3TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip3.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip3.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(chip3.dimension(2), sizeDim4);
-  VERIFY_IS_EQUAL(chip3.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim4; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip3(i, j, k, l), tensor(i, j, 2l, k, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip4TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip4(chip4TensorRange);
-  const size_t chip4TensorBuffSize = chip4.size() * sizeof(DataType);
-  DataType* gpu_data_chip4 = static_cast<DataType*>(sycl_device.allocate(chip4TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip4(gpu_data_chip4, chip4TensorRange);
-
-  gpu_chip4.device(sycl_device) = gpu_tensor.chip(5l, 3l);
-  sycl_device.memcpyDeviceToHost(chip4.data(), gpu_data_chip4, chip4TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip4.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip4.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(chip4.dimension(2), sizeDim3);
-  VERIFY_IS_EQUAL(chip4.dimension(3), sizeDim5);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        for (IndexType l = 0; l < sizeDim5; ++l) {
-          VERIFY_IS_EQUAL(chip4(i, j, k, l), tensor(i, j, k, 5l, l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> chip5TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> chip5(chip5TensorRange);
-  const size_t chip5TensorBuffSize = chip5.size() * sizeof(DataType);
-  DataType* gpu_data_chip5 = static_cast<DataType*>(sycl_device.allocate(chip5TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip5(gpu_data_chip5, chip5TensorRange);
-
-  gpu_chip5.device(sycl_device) = gpu_tensor.chip(7l, 4l);
-  sycl_device.memcpyDeviceToHost(chip5.data(), gpu_data_chip5, chip5TensorBuffSize);
-
-  VERIFY_IS_EQUAL(chip5.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(chip5.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(chip5.dimension(2), sizeDim3);
-  VERIFY_IS_EQUAL(chip5.dimension(3), sizeDim4);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        for (IndexType l = 0; l < sizeDim4; ++l) {
-          VERIFY_IS_EQUAL(chip5(i, j, k, l), tensor(i, j, k, l, 7l));
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_tensor);
-  sycl_device.deallocate(gpu_data_chip1);
-  sycl_device.deallocate(gpu_data_chip2);
-  sycl_device.deallocate(gpu_data_chip3);
-  sycl_device.deallocate(gpu_data_chip4);
-  sycl_device.deallocate(gpu_data_chip5);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_chip_in_expr(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  IndexType sizeDim5 = 11;
-
-  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-  array<IndexType, 4> chip1TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-
-  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
-
-  Tensor<DataType, 4, DataLayout, IndexType> chip1(chip1TensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> tensor1(chip1TensorRange);
-  tensor.setRandom();
-  tensor1.setRandom();
-
-  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
-  const size_t chip1TensorBuffSize = chip1.size() * sizeof(DataType);
-  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_chip1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
-  DataType* gpu_data_tensor1 = static_cast<DataType*>(sycl_device.allocate(chip1TensorBuffSize));
-
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_chip1(gpu_data_chip1, chip1TensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_tensor1(gpu_data_tensor1, chip1TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
-  sycl_device.memcpyHostToDevice(gpu_data_tensor1, tensor1.data(), chip1TensorBuffSize);
-  gpu_chip1.device(sycl_device) = gpu_tensor.template chip<0l>(0l) + gpu_tensor1;
-  sycl_device.memcpyDeviceToHost(chip1.data(), gpu_data_chip1, chip1TensorBuffSize);
-
-  for (int i = 0; i < sizeDim2; ++i) {
-    for (int j = 0; j < sizeDim3; ++j) {
-      for (int k = 0; k < sizeDim4; ++k) {
-        for (int l = 0; l < sizeDim5; ++l) {
-          float expected = tensor(0l, i, j, k, l) + tensor1(i, j, k, l);
-          VERIFY_IS_EQUAL(chip1(i, j, k, l), expected);
-        }
-      }
-    }
-  }
-
-  array<IndexType, 3> chip2TensorRange = {{sizeDim2, sizeDim4, sizeDim5}};
-  Tensor<DataType, 3, DataLayout, IndexType> tensor2(chip2TensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> chip2(chip2TensorRange);
-  tensor2.setRandom();
-  const size_t chip2TensorBuffSize = tensor2.size() * sizeof(DataType);
-  DataType* gpu_data_tensor2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
-  DataType* gpu_data_chip2 = static_cast<DataType*>(sycl_device.allocate(chip2TensorBuffSize));
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_tensor2(gpu_data_tensor2, chip2TensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_chip2(gpu_data_chip2, chip2TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_tensor2, tensor2.data(), chip2TensorBuffSize);
-  gpu_chip2.device(sycl_device) = gpu_tensor.template chip<0l>(0l).template chip<1l>(2l) + gpu_tensor2;
-  sycl_device.memcpyDeviceToHost(chip2.data(), gpu_data_chip2, chip2TensorBuffSize);
-
-  for (int i = 0; i < sizeDim2; ++i) {
-    for (int j = 0; j < sizeDim4; ++j) {
-      for (int k = 0; k < sizeDim5; ++k) {
-        float expected = tensor(0l, i, 2l, j, k) + tensor2(i, j, k);
-        VERIFY_IS_EQUAL(chip2(i, j, k), expected);
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_tensor);
-  sycl_device.deallocate(gpu_data_tensor1);
-  sycl_device.deallocate(gpu_data_chip1);
-  sycl_device.deallocate(gpu_data_tensor2);
-  sycl_device.deallocate(gpu_data_chip2);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_chip_as_lvalue_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  IndexType sizeDim5 = 11;
-
-  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-  array<IndexType, 4> input2TensorRange = {{sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-
-  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 5, DataLayout, IndexType> input1(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> input2(input2TensorRange);
-  input1.setRandom();
-  input2.setRandom();
-
-  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
-  const size_t input2TensorBuffSize = input2.size() * sizeof(DataType);
-  std::cout << tensorBuffSize << " , " << input2TensorBuffSize << std::endl;
-  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_input1 = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_input2 = static_cast<DataType*>(sycl_device.allocate(input2TensorBuffSize));
-
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_input1(gpu_data_input1, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input2(gpu_data_input2, input2TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_input1, input1.data(), tensorBuffSize);
-  gpu_tensor.device(sycl_device) = gpu_input1;
-  sycl_device.memcpyHostToDevice(gpu_data_input2, input2.data(), input2TensorBuffSize);
-  gpu_tensor.template chip<0l>(1l).device(sycl_device) = gpu_input2;
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
-
-  for (int i = 0; i < sizeDim1; ++i) {
-    for (int j = 0; j < sizeDim2; ++j) {
-      for (int k = 0; k < sizeDim3; ++k) {
-        for (int l = 0; l < sizeDim4; ++l) {
-          for (int m = 0; m < sizeDim5; ++m) {
-            if (i != 1) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input2(j, k, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  gpu_tensor.device(sycl_device) = gpu_input1;
-  array<IndexType, 4> input3TensorRange = {{sizeDim1, sizeDim3, sizeDim4, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> input3(input3TensorRange);
-  input3.setRandom();
-
-  const size_t input3TensorBuffSize = input3.size() * sizeof(DataType);
-  DataType* gpu_data_input3 = static_cast<DataType*>(sycl_device.allocate(input3TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input3(gpu_data_input3, input3TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_input3, input3.data(), input3TensorBuffSize);
-  gpu_tensor.template chip<1l>(1l).device(sycl_device) = gpu_input3;
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
-
-  for (int i = 0; i < sizeDim1; ++i) {
-    for (int j = 0; j < sizeDim2; ++j) {
-      for (int k = 0; k < sizeDim3; ++k) {
-        for (int l = 0; l < sizeDim4; ++l) {
-          for (int m = 0; m < sizeDim5; ++m) {
-            if (j != 1) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input3(i, k, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  gpu_tensor.device(sycl_device) = gpu_input1;
-  array<IndexType, 4> input4TensorRange = {{sizeDim1, sizeDim2, sizeDim4, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> input4(input4TensorRange);
-  input4.setRandom();
-
-  const size_t input4TensorBuffSize = input4.size() * sizeof(DataType);
-  DataType* gpu_data_input4 = static_cast<DataType*>(sycl_device.allocate(input4TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input4(gpu_data_input4, input4TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_input4, input4.data(), input4TensorBuffSize);
-  gpu_tensor.template chip<2l>(3l).device(sycl_device) = gpu_input4;
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
-
-  for (int i = 0; i < sizeDim1; ++i) {
-    for (int j = 0; j < sizeDim2; ++j) {
-      for (int k = 0; k < sizeDim3; ++k) {
-        for (int l = 0; l < sizeDim4; ++l) {
-          for (int m = 0; m < sizeDim5; ++m) {
-            if (k != 3) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input4(i, j, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  gpu_tensor.device(sycl_device) = gpu_input1;
-  array<IndexType, 4> input5TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim5}};
-  Tensor<DataType, 4, DataLayout, IndexType> input5(input5TensorRange);
-  input5.setRandom();
-
-  const size_t input5TensorBuffSize = input5.size() * sizeof(DataType);
-  DataType* gpu_data_input5 = static_cast<DataType*>(sycl_device.allocate(input5TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input5(gpu_data_input5, input5TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_input5, input5.data(), input5TensorBuffSize);
-  gpu_tensor.template chip<3l>(4l).device(sycl_device) = gpu_input5;
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
-
-  for (int i = 0; i < sizeDim1; ++i) {
-    for (int j = 0; j < sizeDim2; ++j) {
-      for (int k = 0; k < sizeDim3; ++k) {
-        for (int l = 0; l < sizeDim4; ++l) {
-          for (int m = 0; m < sizeDim5; ++m) {
-            if (l != 4) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input5(i, j, k, m));
-            }
-          }
-        }
-      }
-    }
-  }
-  gpu_tensor.device(sycl_device) = gpu_input1;
-  array<IndexType, 4> input6TensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> input6(input6TensorRange);
-  input6.setRandom();
-
-  const size_t input6TensorBuffSize = input6.size() * sizeof(DataType);
-  DataType* gpu_data_input6 = static_cast<DataType*>(sycl_device.allocate(input6TensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_input6(gpu_data_input6, input6TensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_input6, input6.data(), input6TensorBuffSize);
-  gpu_tensor.template chip<4l>(5l).device(sycl_device) = gpu_input6;
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
-
-  for (int i = 0; i < sizeDim1; ++i) {
-    for (int j = 0; j < sizeDim2; ++j) {
-      for (int k = 0; k < sizeDim3; ++k) {
-        for (int l = 0; l < sizeDim4; ++l) {
-          for (int m = 0; m < sizeDim5; ++m) {
-            if (m != 5) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input6(i, j, k, l));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  gpu_tensor.device(sycl_device) = gpu_input1;
-  Tensor<DataType, 5, DataLayout, IndexType> input7(tensorRange);
-  input7.setRandom();
-
-  DataType* gpu_data_input7 = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_input7(gpu_data_input7, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_input7, input7.data(), tensorBuffSize);
-  gpu_tensor.chip(0l, 0l).device(sycl_device) = gpu_input7.chip(0l, 0l);
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data_tensor, tensorBuffSize);
-
-  for (int i = 0; i < sizeDim1; ++i) {
-    for (int j = 0; j < sizeDim2; ++j) {
-      for (int k = 0; k < sizeDim3; ++k) {
-        for (int l = 0; l < sizeDim4; ++l) {
-          for (int m = 0; m < sizeDim5; ++m) {
-            if (i != 0) {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input1(i, j, k, l, m));
-            } else {
-              VERIFY_IS_EQUAL(tensor(i, j, k, l, m), input7(i, j, k, l, m));
-            }
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_tensor);
-  sycl_device.deallocate(gpu_data_input1);
-  sycl_device.deallocate(gpu_data_input2);
-  sycl_device.deallocate(gpu_data_input3);
-  sycl_device.deallocate(gpu_data_input4);
-  sycl_device.deallocate(gpu_data_input5);
-  sycl_device.deallocate(gpu_data_input6);
-  sycl_device.deallocate(gpu_data_input7);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_chipping_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  /* test_static_chip_sycl<DataType, RowMajor, int64_t>(sycl_device);
-   test_static_chip_sycl<DataType, ColMajor, int64_t>(sycl_device);
-   test_dynamic_chip_sycl<DataType, RowMajor, int64_t>(sycl_device);
-   test_dynamic_chip_sycl<DataType, ColMajor, int64_t>(sycl_device);
-   test_chip_in_expr<DataType, RowMajor, int64_t>(sycl_device);
-   test_chip_in_expr<DataType, ColMajor, int64_t>(sycl_device);*/
-  test_chip_as_lvalue_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  // test_chip_as_lvalue_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_chipping_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_chipping_test_per_device<float>(device));
-    CALL_SUBTEST(sycl_chipping_test_per_device<half>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_comparisons.cpp b/unsupported/test/cxx11_tensor_comparisons.cpp
deleted file mode 100644
index 1ef1179..0000000
--- a/unsupported/test/cxx11_tensor_comparisons.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-using Scalar = float;
-
-using TypedLTOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LT, true>;
-using TypedLEOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_LE, true>;
-using TypedGTOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GT, true>;
-using TypedGEOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_GE, true>;
-using TypedEQOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ, true>;
-using TypedNEOp = internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_NEQ, true>;
-
-static void test_orderings() {
-  Tensor<Scalar, 3> mat1(2, 3, 7);
-  Tensor<Scalar, 3> mat2(2, 3, 7);
-
-  mat1.setRandom();
-  mat2.setRandom();
-
-  Tensor<bool, 3> lt(2, 3, 7);
-  Tensor<bool, 3> le(2, 3, 7);
-  Tensor<bool, 3> gt(2, 3, 7);
-  Tensor<bool, 3> ge(2, 3, 7);
-
-  Tensor<Scalar, 3> typed_lt(2, 3, 7);
-  Tensor<Scalar, 3> typed_le(2, 3, 7);
-  Tensor<Scalar, 3> typed_gt(2, 3, 7);
-  Tensor<Scalar, 3> typed_ge(2, 3, 7);
-
-  lt = mat1 < mat2;
-  le = mat1 <= mat2;
-  gt = mat1 > mat2;
-  ge = mat1 >= mat2;
-
-  typed_lt = mat1.binaryExpr(mat2, TypedLTOp());
-  typed_le = mat1.binaryExpr(mat2, TypedLEOp());
-  typed_gt = mat1.binaryExpr(mat2, TypedGTOp());
-  typed_ge = mat1.binaryExpr(mat2, TypedGEOp());
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(lt(i, j, k), mat1(i, j, k) < mat2(i, j, k));
-        VERIFY_IS_EQUAL(le(i, j, k), mat1(i, j, k) <= mat2(i, j, k));
-        VERIFY_IS_EQUAL(gt(i, j, k), mat1(i, j, k) > mat2(i, j, k));
-        VERIFY_IS_EQUAL(ge(i, j, k), mat1(i, j, k) >= mat2(i, j, k));
-
-        VERIFY_IS_EQUAL(lt(i, j, k), (bool)typed_lt(i, j, k));
-        VERIFY_IS_EQUAL(le(i, j, k), (bool)typed_le(i, j, k));
-        VERIFY_IS_EQUAL(gt(i, j, k), (bool)typed_gt(i, j, k));
-        VERIFY_IS_EQUAL(ge(i, j, k), (bool)typed_ge(i, j, k));
-      }
-    }
-  }
-}
-
-static void test_equality() {
-  Tensor<Scalar, 3> mat1(2, 3, 7);
-  Tensor<Scalar, 3> mat2(2, 3, 7);
-
-  mat1.setRandom();
-  mat2.setRandom();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        if (internal::random<bool>()) {
-          mat2(i, j, k) = mat1(i, j, k);
-        }
-      }
-    }
-  }
-
-  Tensor<bool, 3> eq(2, 3, 7);
-  Tensor<bool, 3> ne(2, 3, 7);
-
-  Tensor<Scalar, 3> typed_eq(2, 3, 7);
-  Tensor<Scalar, 3> typed_ne(2, 3, 7);
-
-  eq = (mat1 == mat2);
-  ne = (mat1 != mat2);
-
-  typed_eq = mat1.binaryExpr(mat2, TypedEQOp());
-  typed_ne = mat1.binaryExpr(mat2, TypedNEOp());
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(eq(i, j, k), mat1(i, j, k) == mat2(i, j, k));
-        VERIFY_IS_EQUAL(ne(i, j, k), mat1(i, j, k) != mat2(i, j, k));
-
-        VERIFY_IS_EQUAL(eq(i, j, k), (bool)typed_eq(i, j, k));
-        VERIFY_IS_EQUAL(ne(i, j, k), (bool)typed_ne(i, j, k));
-      }
-    }
-  }
-}
-
-static void test_isnan() {
-  Tensor<Scalar, 3> mat(2, 3, 7);
-
-  mat.setRandom();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        if (internal::random<bool>()) {
-          mat(i, j, k) = std::numeric_limits<Scalar>::quiet_NaN();
-        }
-      }
-    }
-  }
-  Tensor<bool, 3> nan(2, 3, 7);
-  nan = (mat.isnan)();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(nan(i, j, k), (std::isnan)(mat(i, j, k)));
-      }
-    }
-  }
-}
-
-static void test_isinf() {
-  Tensor<Scalar, 3> mat(2, 3, 7);
-
-  mat.setRandom();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        if (internal::random<bool>()) {
-          mat(i, j, k) = std::numeric_limits<Scalar>::infinity();
-        }
-      }
-    }
-  }
-  Tensor<bool, 3> inf(2, 3, 7);
-  inf = (mat.isinf)();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(inf(i, j, k), (std::isinf)(mat(i, j, k)));
-      }
-    }
-  }
-}
-
-static void test_isfinite() {
-  Tensor<Scalar, 3> mat(2, 3, 7);
-
-  mat.setRandom();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        if (internal::random<bool>()) {
-          mat(i, j, k) = std::numeric_limits<Scalar>::infinity();
-        }
-        if (internal::random<bool>()) {
-          mat(i, j, k) = std::numeric_limits<Scalar>::quiet_NaN();
-        }
-      }
-    }
-  }
-  Tensor<bool, 3> inf(2, 3, 7);
-  inf = (mat.isfinite)();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(inf(i, j, k), (std::isfinite)(mat(i, j, k)));
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_comparisons) {
-  CALL_SUBTEST(test_orderings());
-  CALL_SUBTEST(test_equality());
-  CALL_SUBTEST(test_isnan());
-  CALL_SUBTEST(test_isinf());
-  CALL_SUBTEST(test_isfinite());
-}
diff --git a/unsupported/test/cxx11_tensor_complex_cwise_ops_gpu.cu b/unsupported/test/cxx11_tensor_complex_cwise_ops_gpu.cu
deleted file mode 100644
index 2633f8f..0000000
--- a/unsupported/test/cxx11_tensor_complex_cwise_ops_gpu.cu
+++ /dev/null
@@ -1,90 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename T>
-void test_cuda_complex_cwise_ops() {
-  const int kNumItems = 2;
-  std::size_t complex_bytes = kNumItems * sizeof(std::complex<T>);
-
-  std::complex<T>* d_in1;
-  std::complex<T>* d_in2;
-  std::complex<T>* d_out;
-  cudaMalloc((void**)(&d_in1), complex_bytes);
-  cudaMalloc((void**)(&d_in2), complex_bytes);
-  cudaMalloc((void**)(&d_out), complex_bytes);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<std::complex<T>, 1, 0, int>, Eigen::Aligned> gpu_in1(d_in1, kNumItems);
-  Eigen::TensorMap<Eigen::Tensor<std::complex<T>, 1, 0, int>, Eigen::Aligned> gpu_in2(d_in2, kNumItems);
-  Eigen::TensorMap<Eigen::Tensor<std::complex<T>, 1, 0, int>, Eigen::Aligned> gpu_out(d_out, kNumItems);
-
-  const std::complex<T> a(static_cast<T>(3.14), static_cast<T>(2.7));
-  const std::complex<T> b(static_cast<T>(-10.6), static_cast<T>(1.4));
-
-  gpu_in1.device(gpu_device) = gpu_in1.constant(a);
-  gpu_in2.device(gpu_device) = gpu_in2.constant(b);
-
-  enum CwiseOp { Add = 0, Sub, Mul, Div, Neg, NbOps };
-
-  Tensor<std::complex<T>, 1, 0, int> actual(kNumItems);
-  for (int op = Add; op < NbOps; op++) {
-    std::complex<T> expected;
-    switch (static_cast<CwiseOp>(op)) {
-      case Add:
-        gpu_out.device(gpu_device) = gpu_in1 + gpu_in2;
-        expected = a + b;
-        break;
-      case Sub:
-        gpu_out.device(gpu_device) = gpu_in1 - gpu_in2;
-        expected = a - b;
-        break;
-      case Mul:
-        gpu_out.device(gpu_device) = gpu_in1 * gpu_in2;
-        expected = a * b;
-        break;
-      case Div:
-        gpu_out.device(gpu_device) = gpu_in1 / gpu_in2;
-        expected = a / b;
-        break;
-      case Neg:
-        gpu_out.device(gpu_device) = -gpu_in1;
-        expected = -a;
-        break;
-      case NbOps:
-        break;
-    }
-    assert(cudaMemcpyAsync(actual.data(), d_out, complex_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) ==
-           cudaSuccess);
-    assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
-
-    for (int i = 0; i < kNumItems; ++i) {
-      VERIFY_IS_APPROX(actual(i), expected);
-    }
-  }
-
-  cudaFree(d_in1);
-  cudaFree(d_in2);
-  cudaFree(d_out);
-}
-
-EIGEN_DECLARE_TEST(test_cxx11_tensor_complex_cwise_ops) {
-  CALL_SUBTEST(test_cuda_complex_cwise_ops<float>());
-  CALL_SUBTEST(test_cuda_complex_cwise_ops<double>());
-}
diff --git a/unsupported/test/cxx11_tensor_complex_gpu.cu b/unsupported/test/cxx11_tensor_complex_gpu.cu
deleted file mode 100644
index 777814e..0000000
--- a/unsupported/test/cxx11_tensor_complex_gpu.cu
+++ /dev/null
@@ -1,176 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-void test_cuda_nullary() {
-  Tensor<std::complex<float>, 1, 0, int> in1(2);
-  Tensor<std::complex<float>, 1, 0, int> in2(2);
-  in1.setRandom();
-  in2.setRandom();
-
-  std::size_t float_bytes = in1.size() * sizeof(float);
-  std::size_t complex_bytes = in1.size() * sizeof(std::complex<float>);
-
-  std::complex<float>* d_in1;
-  std::complex<float>* d_in2;
-  float* d_out2;
-  cudaMalloc((void**)(&d_in1), complex_bytes);
-  cudaMalloc((void**)(&d_in2), complex_bytes);
-  cudaMalloc((void**)(&d_out2), float_bytes);
-  cudaMemcpy(d_in1, in1.data(), complex_bytes, cudaMemcpyHostToDevice);
-  cudaMemcpy(d_in2, in2.data(), complex_bytes, cudaMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<std::complex<float>, 1, 0, int>, Eigen::Aligned> gpu_in1(d_in1, 2);
-  Eigen::TensorMap<Eigen::Tensor<std::complex<float>, 1, 0, int>, Eigen::Aligned> gpu_in2(d_in2, 2);
-  Eigen::TensorMap<Eigen::Tensor<float, 1, 0, int>, Eigen::Aligned> gpu_out2(d_out2, 2);
-
-  gpu_in1.device(gpu_device) = gpu_in1.constant(std::complex<float>(3.14f, 2.7f));
-  gpu_out2.device(gpu_device) = gpu_in2.abs();
-
-  Tensor<std::complex<float>, 1, 0, int> new1(2);
-  Tensor<float, 1, 0, int> new2(2);
-
-  assert(cudaMemcpyAsync(new1.data(), d_in1, complex_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) ==
-         cudaSuccess);
-  assert(cudaMemcpyAsync(new2.data(), d_out2, float_bytes, cudaMemcpyDeviceToHost, gpu_device.stream()) == cudaSuccess);
-
-  assert(cudaStreamSynchronize(gpu_device.stream()) == cudaSuccess);
-
-  for (int i = 0; i < 2; ++i) {
-    VERIFY_IS_APPROX(new1(i), std::complex<float>(3.14f, 2.7f));
-    VERIFY_IS_APPROX(new2(i), std::abs(in2(i)));
-  }
-
-  cudaFree(d_in1);
-  cudaFree(d_in2);
-  cudaFree(d_out2);
-}
-
-static void test_cuda_sum_reductions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  const int num_rows = internal::random<int>(1024, 5 * 1024);
-  const int num_cols = internal::random<int>(1024, 5 * 1024);
-
-  Tensor<std::complex<float>, 2> in(num_rows, num_cols);
-  in.setRandom();
-
-  Tensor<std::complex<float>, 0> full_redux;
-  full_redux = in.sum();
-
-  std::size_t in_bytes = in.size() * sizeof(std::complex<float>);
-  std::size_t out_bytes = full_redux.size() * sizeof(std::complex<float>);
-  std::complex<float>* gpu_in_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(in_bytes));
-  std::complex<float>* gpu_out_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(out_bytes));
-  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
-
-  TensorMap<Tensor<std::complex<float>, 2> > in_gpu(gpu_in_ptr, num_rows, num_cols);
-  TensorMap<Tensor<std::complex<float>, 0> > out_gpu(gpu_out_ptr);
-
-  out_gpu.device(gpu_device) = in_gpu.sum();
-
-  Tensor<std::complex<float>, 0> full_redux_gpu;
-  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
-  gpu_device.synchronize();
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
-
-  gpu_device.deallocate(gpu_in_ptr);
-  gpu_device.deallocate(gpu_out_ptr);
-}
-
-static void test_cuda_mean_reductions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  const int num_rows = internal::random<int>(1024, 5 * 1024);
-  const int num_cols = internal::random<int>(1024, 5 * 1024);
-
-  Tensor<std::complex<float>, 2> in(num_rows, num_cols);
-  in.setRandom();
-
-  Tensor<std::complex<float>, 0> full_redux;
-  full_redux = in.mean();
-
-  std::size_t in_bytes = in.size() * sizeof(std::complex<float>);
-  std::size_t out_bytes = full_redux.size() * sizeof(std::complex<float>);
-  std::complex<float>* gpu_in_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(in_bytes));
-  std::complex<float>* gpu_out_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(out_bytes));
-  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
-
-  TensorMap<Tensor<std::complex<float>, 2> > in_gpu(gpu_in_ptr, num_rows, num_cols);
-  TensorMap<Tensor<std::complex<float>, 0> > out_gpu(gpu_out_ptr);
-
-  out_gpu.device(gpu_device) = in_gpu.mean();
-
-  Tensor<std::complex<float>, 0> full_redux_gpu;
-  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
-  gpu_device.synchronize();
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
-
-  gpu_device.deallocate(gpu_in_ptr);
-  gpu_device.deallocate(gpu_out_ptr);
-}
-
-static void test_cuda_product_reductions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  const int num_rows = internal::random<int>(1024, 5 * 1024);
-  const int num_cols = internal::random<int>(1024, 5 * 1024);
-
-  Tensor<std::complex<float>, 2> in(num_rows, num_cols);
-  in.setRandom();
-
-  Tensor<std::complex<float>, 0> full_redux;
-  full_redux = in.prod();
-
-  std::size_t in_bytes = in.size() * sizeof(std::complex<float>);
-  std::size_t out_bytes = full_redux.size() * sizeof(std::complex<float>);
-  std::complex<float>* gpu_in_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(in_bytes));
-  std::complex<float>* gpu_out_ptr = static_cast<std::complex<float>*>(gpu_device.allocate(out_bytes));
-  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
-
-  TensorMap<Tensor<std::complex<float>, 2> > in_gpu(gpu_in_ptr, num_rows, num_cols);
-  TensorMap<Tensor<std::complex<float>, 0> > out_gpu(gpu_out_ptr);
-
-  out_gpu.device(gpu_device) = in_gpu.prod();
-
-  Tensor<std::complex<float>, 0> full_redux_gpu;
-  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
-  gpu_device.synchronize();
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
-
-  gpu_device.deallocate(gpu_in_ptr);
-  gpu_device.deallocate(gpu_out_ptr);
-}
-
-EIGEN_DECLARE_TEST(test_cxx11_tensor_complex) {
-  CALL_SUBTEST(test_cuda_nullary());
-  CALL_SUBTEST(test_cuda_sum_reductions());
-  CALL_SUBTEST(test_cuda_mean_reductions());
-  CALL_SUBTEST(test_cuda_product_reductions());
-}
diff --git a/unsupported/test/cxx11_tensor_concatenation.cpp b/unsupported/test/cxx11_tensor_concatenation.cpp
deleted file mode 100644
index cc0a160..0000000
--- a/unsupported/test/cxx11_tensor_concatenation.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_dimension_failures() {
-  Tensor<int, 3, DataLayout> left(2, 3, 1);
-  Tensor<int, 3, DataLayout> right(3, 3, 1);
-  left.setRandom();
-  right.setRandom();
-
-  // Okay; other dimensions are equal.
-  Tensor<int, 3, DataLayout> concatenation = left.concatenate(right, 0);
-
-  // Dimension mismatches.
-  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, 1));
-  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, 2));
-
-  // Axis > NumDims or < 0.
-  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, 3));
-  VERIFY_RAISES_ASSERT(concatenation = left.concatenate(right, -1));
-}
-
-template <int DataLayout>
-static void test_static_dimension_failure() {
-  Tensor<int, 2, DataLayout> left(2, 3);
-  Tensor<int, 3, DataLayout> right(2, 3, 1);
-  left.setRandom();
-  right.setRandom();
-
-#ifdef CXX11_TENSOR_CONCATENATION_STATIC_DIMENSION_FAILURE
-  // Technically compatible, but we static assert that the inputs have same
-  // NumDims.
-  Tensor<int, 3, DataLayout> concatenation = left.concatenate(right, 0);
-#endif
-
-  // This can be worked around in this case.
-  Tensor<int, 3, DataLayout> concatenation = left.reshape(Tensor<int, 3>::Dimensions(2, 3, 1)).concatenate(right, 0);
-  Tensor<int, 2, DataLayout> alternative = left.concatenate(right.reshape(Tensor<int, 2>::Dimensions(2, 3)), 0);
-}
-
-template <int DataLayout>
-static void test_simple_concatenation() {
-  Tensor<int, 3, DataLayout> left(2, 3, 1);
-  Tensor<int, 3, DataLayout> right(2, 3, 1);
-  left.setRandom();
-  right.setRandom();
-
-  Tensor<int, 3, DataLayout> concatenation = left.concatenate(right, 0);
-  VERIFY_IS_EQUAL(concatenation.dimension(0), 4);
-  VERIFY_IS_EQUAL(concatenation.dimension(1), 3);
-  VERIFY_IS_EQUAL(concatenation.dimension(2), 1);
-  for (int j = 0; j < 3; ++j) {
-    for (int i = 0; i < 2; ++i) {
-      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
-    }
-    for (int i = 2; i < 4; ++i) {
-      VERIFY_IS_EQUAL(concatenation(i, j, 0), right(i - 2, j, 0));
-    }
-  }
-
-  concatenation = left.concatenate(right, 1);
-  VERIFY_IS_EQUAL(concatenation.dimension(0), 2);
-  VERIFY_IS_EQUAL(concatenation.dimension(1), 6);
-  VERIFY_IS_EQUAL(concatenation.dimension(2), 1);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
-    }
-    for (int j = 3; j < 6; ++j) {
-      VERIFY_IS_EQUAL(concatenation(i, j, 0), right(i, j - 3, 0));
-    }
-  }
-
-  concatenation = left.concatenate(right, 2);
-  VERIFY_IS_EQUAL(concatenation.dimension(0), 2);
-  VERIFY_IS_EQUAL(concatenation.dimension(1), 3);
-  VERIFY_IS_EQUAL(concatenation.dimension(2), 2);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(concatenation(i, j, 0), left(i, j, 0));
-      VERIFY_IS_EQUAL(concatenation(i, j, 1), right(i, j, 0));
-    }
-  }
-}
-
-// TODO(phli): Add test once we have a real vectorized implementation.
-// static void test_vectorized_concatenation() {}
-
-static void test_concatenation_as_lvalue() {
-  Tensor<int, 2> t1(2, 3);
-  Tensor<int, 2> t2(2, 3);
-  t1.setRandom();
-  t2.setRandom();
-
-  Tensor<int, 2> result(4, 3);
-  result.setRandom();
-  t1.concatenate(t2, 0) = result;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(t1(i, j), result(i, j));
-      VERIFY_IS_EQUAL(t2(i, j), result(i + 2, j));
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_concatenation) {
-  CALL_SUBTEST(test_dimension_failures<ColMajor>());
-  CALL_SUBTEST(test_dimension_failures<RowMajor>());
-  CALL_SUBTEST(test_static_dimension_failure<ColMajor>());
-  CALL_SUBTEST(test_static_dimension_failure<RowMajor>());
-  CALL_SUBTEST(test_simple_concatenation<ColMajor>());
-  CALL_SUBTEST(test_simple_concatenation<RowMajor>());
-  // CALL_SUBTEST(test_vectorized_concatenation());
-  CALL_SUBTEST(test_concatenation_as_lvalue());
-}
diff --git a/unsupported/test/cxx11_tensor_concatenation_sycl.cpp b/unsupported/test/cxx11_tensor_concatenation_sycl.cpp
deleted file mode 100644
index 42fb4fa..0000000
--- a/unsupported/test/cxx11_tensor_concatenation_sycl.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_concatenation(const Eigen::SyclDevice& sycl_device) {
-  IndexType leftDim1 = 2;
-  IndexType leftDim2 = 3;
-  IndexType leftDim3 = 1;
-  Eigen::array<IndexType, 3> leftRange = {{leftDim1, leftDim2, leftDim3}};
-  IndexType rightDim1 = 2;
-  IndexType rightDim2 = 3;
-  IndexType rightDim3 = 1;
-  Eigen::array<IndexType, 3> rightRange = {{rightDim1, rightDim2, rightDim3}};
-
-  // IndexType concatDim1 = 3;
-  //	IndexType concatDim2 = 3;
-  //	IndexType concatDim3 = 1;
-  // Eigen::array<IndexType, 3> concatRange = {{concatDim1, concatDim2, concatDim3}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> left(leftRange);
-  Tensor<DataType, 3, DataLayout, IndexType> right(rightRange);
-  left.setRandom();
-  right.setRandom();
-
-  DataType* gpu_in1_data =
-      static_cast<DataType*>(sycl_device.allocate(left.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_in2_data =
-      static_cast<DataType*>(sycl_device.allocate(right.dimensions().TotalSize() * sizeof(DataType)));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, leftRange);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, rightRange);
-  sycl_device.memcpyHostToDevice(gpu_in1_data, left.data(), (left.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in2_data, right.data(), (right.dimensions().TotalSize()) * sizeof(DataType));
-  ///
-  Tensor<DataType, 3, DataLayout, IndexType> concatenation1(leftDim1 + rightDim1, leftDim2, leftDim3);
-  DataType* gpu_out_data1 =
-      static_cast<DataType*>(sycl_device.allocate(concatenation1.dimensions().TotalSize() * sizeof(DataType)));
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out1(gpu_out_data1,
-                                                                               concatenation1.dimensions());
-
-  // concatenation = left.concatenate(right, 0);
-  gpu_out1.device(sycl_device) = gpu_in1.concatenate(gpu_in2, 0);
-  sycl_device.memcpyDeviceToHost(concatenation1.data(), gpu_out_data1,
-                                 (concatenation1.dimensions().TotalSize()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(concatenation1.dimension(0), 4);
-  VERIFY_IS_EQUAL(concatenation1.dimension(1), 3);
-  VERIFY_IS_EQUAL(concatenation1.dimension(2), 1);
-  for (IndexType j = 0; j < 3; ++j) {
-    for (IndexType i = 0; i < 2; ++i) {
-      VERIFY_IS_EQUAL(concatenation1(i, j, 0), left(i, j, 0));
-    }
-    for (IndexType i = 2; i < 4; ++i) {
-      VERIFY_IS_EQUAL(concatenation1(i, j, 0), right(i - 2, j, 0));
-    }
-  }
-
-  sycl_device.deallocate(gpu_out_data1);
-  Tensor<DataType, 3, DataLayout, IndexType> concatenation2(leftDim1, leftDim2 + rightDim2, leftDim3);
-  DataType* gpu_out_data2 =
-      static_cast<DataType*>(sycl_device.allocate(concatenation2.dimensions().TotalSize() * sizeof(DataType)));
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out2(gpu_out_data2,
-                                                                               concatenation2.dimensions());
-  gpu_out2.device(sycl_device) = gpu_in1.concatenate(gpu_in2, 1);
-  sycl_device.memcpyDeviceToHost(concatenation2.data(), gpu_out_data2,
-                                 (concatenation2.dimensions().TotalSize()) * sizeof(DataType));
-
-  // concatenation = left.concatenate(right, 1);
-  VERIFY_IS_EQUAL(concatenation2.dimension(0), 2);
-  VERIFY_IS_EQUAL(concatenation2.dimension(1), 6);
-  VERIFY_IS_EQUAL(concatenation2.dimension(2), 1);
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(concatenation2(i, j, 0), left(i, j, 0));
-    }
-    for (IndexType j = 3; j < 6; ++j) {
-      VERIFY_IS_EQUAL(concatenation2(i, j, 0), right(i, j - 3, 0));
-    }
-  }
-  sycl_device.deallocate(gpu_out_data2);
-  Tensor<DataType, 3, DataLayout, IndexType> concatenation3(leftDim1, leftDim2, leftDim3 + rightDim3);
-  DataType* gpu_out_data3 =
-      static_cast<DataType*>(sycl_device.allocate(concatenation3.dimensions().TotalSize() * sizeof(DataType)));
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out3(gpu_out_data3,
-                                                                               concatenation3.dimensions());
-  gpu_out3.device(sycl_device) = gpu_in1.concatenate(gpu_in2, 2);
-  sycl_device.memcpyDeviceToHost(concatenation3.data(), gpu_out_data3,
-                                 (concatenation3.dimensions().TotalSize()) * sizeof(DataType));
-
-  // concatenation = left.concatenate(right, 2);
-  VERIFY_IS_EQUAL(concatenation3.dimension(0), 2);
-  VERIFY_IS_EQUAL(concatenation3.dimension(1), 3);
-  VERIFY_IS_EQUAL(concatenation3.dimension(2), 2);
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(concatenation3(i, j, 0), left(i, j, 0));
-      VERIFY_IS_EQUAL(concatenation3(i, j, 1), right(i, j, 0));
-    }
-  }
-  sycl_device.deallocate(gpu_out_data3);
-  sycl_device.deallocate(gpu_in1_data);
-  sycl_device.deallocate(gpu_in2_data);
-}
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_concatenation_as_lvalue(const Eigen::SyclDevice& sycl_device) {
-  IndexType leftDim1 = 2;
-  IndexType leftDim2 = 3;
-  Eigen::array<IndexType, 2> leftRange = {{leftDim1, leftDim2}};
-
-  IndexType rightDim1 = 2;
-  IndexType rightDim2 = 3;
-  Eigen::array<IndexType, 2> rightRange = {{rightDim1, rightDim2}};
-
-  IndexType concatDim1 = 4;
-  IndexType concatDim2 = 3;
-  Eigen::array<IndexType, 2> resRange = {{concatDim1, concatDim2}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> left(leftRange);
-  Tensor<DataType, 2, DataLayout, IndexType> right(rightRange);
-  Tensor<DataType, 2, DataLayout, IndexType> result(resRange);
-
-  left.setRandom();
-  right.setRandom();
-  result.setRandom();
-
-  DataType* gpu_in1_data =
-      static_cast<DataType*>(sycl_device.allocate(left.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_in2_data =
-      static_cast<DataType*>(sycl_device.allocate(right.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(result.dimensions().TotalSize() * sizeof(DataType)));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_in1(gpu_in1_data, leftRange);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_in2(gpu_in2_data, rightRange);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_out(gpu_out_data, resRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in1_data, left.data(), (left.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in2_data, right.data(), (right.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_out_data, result.data(), (result.dimensions().TotalSize()) * sizeof(DataType));
-
-  //  t1.concatenate(t2, 0) = result;
-  gpu_in1.concatenate(gpu_in2, 0).device(sycl_device) = gpu_out;
-  sycl_device.memcpyDeviceToHost(left.data(), gpu_in1_data, (left.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(right.data(), gpu_in2_data, (right.dimensions().TotalSize()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(left(i, j), result(i, j));
-      VERIFY_IS_EQUAL(right(i, j), result(i + 2, j));
-    }
-  }
-  sycl_device.deallocate(gpu_in1_data);
-  sycl_device.deallocate(gpu_in2_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, typename Dev_selector>
-void tensorConcat_perDevice(Dev_selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_concatenation<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_concatenation<DataType, ColMajor, int64_t>(sycl_device);
-  test_concatenation_as_lvalue<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_concatenation_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(tensorConcat_perDevice<half>(device));
-    CALL_SUBTEST(tensorConcat_perDevice<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_const.cpp b/unsupported/test/cxx11_tensor_const.cpp
deleted file mode 100644
index 6606417..0000000
--- a/unsupported/test/cxx11_tensor_const.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-using Eigen::Tensor;
-
-static void test_simple_assign() {
-  Tensor<int, 3> random(2, 3, 7);
-  random.setRandom();
-
-  TensorMap<Tensor<const int, 3> > constant(random.data(), 2, 3, 7);
-  Tensor<int, 3> result(2, 3, 7);
-  result = constant;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL((result(i, j, k)), random(i, j, k));
-      }
-    }
-  }
-}
-
-static void test_assign_of_const_tensor() {
-  Tensor<int, 3> random(2, 3, 7);
-  random.setRandom();
-
-  TensorMap<Tensor<const int, 3> > constant1(random.data(), 2, 3, 7);
-  TensorMap<const Tensor<int, 3> > constant2(random.data(), 2, 3, 7);
-  const TensorMap<Tensor<int, 3> > constant3(random.data(), 2, 3, 7);
-
-  Tensor<int, 2> result1 = constant1.chip(0, 2);
-  Tensor<int, 2> result2 = constant2.chip(0, 2);
-  Tensor<int, 2> result3 = constant3.chip(0, 2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL((result1(i, j)), random(i, j, 0));
-      VERIFY_IS_EQUAL((result2(i, j)), random(i, j, 0));
-      VERIFY_IS_EQUAL((result3(i, j)), random(i, j, 0));
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_const) {
-  CALL_SUBTEST(test_simple_assign());
-  CALL_SUBTEST(test_assign_of_const_tensor());
-}
diff --git a/unsupported/test/cxx11_tensor_contract_gpu.cu b/unsupported/test/cxx11_tensor_contract_gpu.cu
deleted file mode 100644
index 25d2fb6..0000000
--- a/unsupported/test/cxx11_tensor_contract_gpu.cu
+++ /dev/null
@@ -1,210 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-// Copyright (C) 2014 Navdeep Jaitly <ndjaitly@google.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-typedef Tensor<float, 1>::DimensionPair DimPair;
-
-template <int DataLayout>
-void test_gpu_contraction(int m_size, int k_size, int n_size) {
-  Tensor<float, 2, DataLayout> t_left(m_size, k_size);
-  Tensor<float, 2, DataLayout> t_right(k_size, n_size);
-  Tensor<float, 2, DataLayout> t_result(m_size, n_size);
-  Tensor<float, 2, DataLayout> t_result_gpu(m_size, n_size);
-  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(float);
-  std::size_t t_right_bytes = t_right.size() * sizeof(float);
-  std::size_t t_result_bytes = t_result.size() * sizeof(float);
-
-  float* d_t_left;
-  float* d_t_right;
-  float* d_t_result;
-
-  gpuMalloc((void**)(&d_t_left), t_left_bytes);
-  gpuMalloc((void**)(&d_t_right), t_right_bytes);
-  gpuMalloc((void**)(&d_t_result), t_result_bytes);
-
-  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_t_left(d_t_left, Eigen::array<int, 2>{m_size, k_size});
-  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_t_right(d_t_right, Eigen::array<int, 2>{k_size, n_size});
-  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_t_result(d_t_result, Eigen::array<int, 2>{m_size, n_size});
-
-  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
-  t_result = t_left.contract(t_right, dims);
-
-  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
-  for (DenseIndex i = 0; i < t_result.size(); i++) {
-    if (fabs(t_result(i) - t_result_gpu(i)) < 1e-4f) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), 1e-4f)) {
-      continue;
-    }
-    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
-    assert(false);
-  }
-
-  gpuFree((void*)d_t_left);
-  gpuFree((void*)d_t_right);
-  gpuFree((void*)d_t_result);
-}
-
-template <int DataLayout>
-void test_scalar(int m_size, int k_size, int n_size) {
-  std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << ")" << std::endl;
-  // with these dimensions, the output has 300 * 140 elements, which is
-  // more than 30 * 1024, which is the number of threads in blocks on
-  // a 15 SM GK110 GPU
-  Tensor<float, 2, DataLayout> t_left(m_size, k_size);
-  Tensor<float, 2, DataLayout> t_right(k_size, n_size);
-  Tensor<float, 0, DataLayout> t_result;
-  Tensor<float, 0, DataLayout> t_result_gpu;
-  Eigen::array<DimPair, 2> dims{DimPair(0, 0), DimPair(1, 1)};
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(float);
-  std::size_t t_right_bytes = t_right.size() * sizeof(float);
-  std::size_t t_result_bytes = sizeof(float);
-
-  float* d_t_left;
-  float* d_t_right;
-  float* d_t_result;
-
-  gpuMalloc((void**)(&d_t_left), t_left_bytes);
-  gpuMalloc((void**)(&d_t_right), t_right_bytes);
-  gpuMalloc((void**)(&d_t_result), t_result_bytes);
-
-  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_t_left(d_t_left, m_size, k_size);
-  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_t_right(d_t_right, k_size, n_size);
-  Eigen::TensorMap<Eigen::Tensor<float, 0, DataLayout> > gpu_t_result(d_t_result);
-
-  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
-  t_result = t_left.contract(t_right, dims);
-
-  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
-  if (fabs(t_result() - t_result_gpu()) > 1e-4f && !Eigen::internal::isApprox(t_result(), t_result_gpu(), 1e-4f)) {
-    std::cout << "mismatch detected: " << t_result() << " vs " << t_result_gpu() << std::endl;
-    assert(false);
-  }
-
-  gpuFree((void*)d_t_left);
-  gpuFree((void*)d_t_right);
-  gpuFree((void*)d_t_result);
-}
-
-template <int DataLayout>
-void test_gpu_contraction_m() {
-  for (int k = 32; k < 256; k++) {
-    test_gpu_contraction<ColMajor>(k, 128, 128);
-    test_gpu_contraction<RowMajor>(k, 128, 128);
-  }
-}
-
-template <int DataLayout>
-void test_gpu_contraction_k() {
-  for (int k = 32; k < 256; k++) {
-    test_gpu_contraction<ColMajor>(128, k, 128);
-    test_gpu_contraction<RowMajor>(128, k, 128);
-  }
-}
-
-template <int DataLayout>
-void test_gpu_contraction_n() {
-  for (int k = 32; k < 256; k++) {
-    test_gpu_contraction<ColMajor>(128, 128, k);
-    test_gpu_contraction<RowMajor>(128, 128, k);
-  }
-}
-
-template <int DataLayout>
-void test_gpu_contraction_sizes() {
-  int m_sizes[3][5] = {{31, 39, 63, 64, 65}, {127, 129, 255, 257, 511}, {512, 513, 1023, 1024, 1025}};
-
-  int n_sizes[3][5] = {{31, 39, 63, 64, 65}, {127, 129, 255, 257, 511}, {512, 513, 1023, 1024, 1025}};
-
-  int k_sizes[3][6] = {{31, 39, 63, 64, 65, 95}, {96, 127, 129, 255, 257, 511}, {512, 513, 725, 1023, 1024, 1025}};
-
-  // Some selection of specific cases.
-  //  - m changes rows each iteration
-  //  - n changes rows each 3 iterations
-  //  - k changes rows each 9 iterations
-  //  - within a row, advance once column each iteration
-  const int m_cols = 5;
-  const int n_cols = 5;
-  const int k_cols = 6;
-  int m_offset = 0;
-  int n_offset = 1;
-  int k_offset = 2;
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int l = 0; l < 3; ++l) {
-        int m = m_sizes[l][m_offset];
-        int n = n_sizes[j][n_offset];
-        int k = k_sizes[i][k_offset];
-        test_gpu_contraction<DataLayout>(m, n, k);
-        n_offset = (n_offset + 1) % n_cols;
-        k_offset = (k_offset + 1) % k_cols;
-      }
-      m_offset = (m_offset + 1) % m_cols;
-      if (j < 2) {
-        n_offset = (n_offset + n_cols - 3) % n_cols;  // Rewind 3.
-      }
-    }
-    k_offset = (k_offset + 2 * k_cols - 9) % k_cols;  // Rewind 9.
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_contract_gpu) {
-  CALL_SUBTEST_1(test_gpu_contraction<ColMajor>(128, 128, 128));
-  CALL_SUBTEST_1(test_gpu_contraction<RowMajor>(128, 128, 128));
-
-  CALL_SUBTEST_1(test_scalar<ColMajor>(128, 128, 128));
-  CALL_SUBTEST_1(test_scalar<RowMajor>(128, 128, 128));
-
-  CALL_SUBTEST_2(test_gpu_contraction_m<ColMajor>());
-  CALL_SUBTEST_3(test_gpu_contraction_m<RowMajor>());
-
-  CALL_SUBTEST_4(test_gpu_contraction_k<ColMajor>());
-  CALL_SUBTEST_5(test_gpu_contraction_k<RowMajor>());
-
-  CALL_SUBTEST_6(test_gpu_contraction_n<ColMajor>());
-  CALL_SUBTEST_7(test_gpu_contraction_n<RowMajor>());
-
-#if !defined(EIGEN_USE_HIP)
-  // disable these subtests for HIP
-  CALL_SUBTEST_8(test_gpu_contraction_sizes<ColMajor>());
-  CALL_SUBTEST_9(test_gpu_contraction_sizes<RowMajor>());
-#endif
-}
diff --git a/unsupported/test/cxx11_tensor_contract_sycl.cpp b/unsupported/test/cxx11_tensor_contract_sycl.cpp
deleted file mode 100644
index c8194e1..0000000
--- a/unsupported/test/cxx11_tensor_contract_sycl.cpp
+++ /dev/null
@@ -1,846 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include <algorithm>
-#include <chrono>
-#include <ctime>
-#include <iostream>
-
-#include "main.h"
-
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void static test_sycl_contraction(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  // with these dimensions, the output has 300 * 140 elements, which is
-  // more than 30 * 1024, which is the number of threads in blocks on
-  // a 15 SM GK110 GPU
-  Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
-  Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result(m_size, n_size);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(m_size, n_size);
-  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
-  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
-  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
-  Eigen::array<IndexType, 2> result_dims = {{m_size, n_size}};
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
-  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
-  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, result_dims);
-
-  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
-
-  t_result = t_left.contract(t_right, dims);
-
-  for (IndexType i = 0; i < t_result.size(); i++) {
-    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
-      continue;
-    }
-
-    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
-              << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
-    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
-  }
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void test_sycl_contraction_m(const Device &sycl_device) {
-  for (IndexType k = 32; k < 256; k++) {
-    test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, k, 128, 128);
-  }
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void test_sycl_contraction_k(const Device &sycl_device) {
-  for (IndexType k = 32; k < 256; k++) {
-    test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, 128, k, 128);
-  }
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void test_sycl_contraction_n(const Device &sycl_device) {
-  for (IndexType k = 32; k < 256; k++) {
-    test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, 128, 128, k);
-  }
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void test_sycl_contraction_sizes(const Device &sycl_device) {
-  IndexType m_sizes[] = {31, 39, 63, 64, 65, 127, 129, 255, 257, 511, 512, 513, 1023, 1024, 1025};
-
-  IndexType n_sizes[] = {31, 39, 63, 64, 65, 127, 129, 255, 257, 511, 512, 513, 1023, 1024, 1025};
-
-  IndexType k_sizes[] = {31, 39, 63, 64, 65, 95, 96, 127, 129, 255, 257, 511, 512, 513, 1023, 1024, 1025};
-
-  for (IndexType i = 0; i < 15; i++) {
-    for (IndexType j = 0; j < 15; j++) {
-      for (IndexType k = 0; k < 17; k++) {
-        test_sycl_contraction<DataLayout, DataType, IndexType>(sycl_device, m_sizes[i], n_sizes[j], k_sizes[k]);
-      }
-    }
-  }
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void static test_no_out_of_bounds(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
-  Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result(m_size, n_size);
-
-  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
-  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
-  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
-  Eigen::array<IndexType, 2> result_dims = {{m_size, n_size}};
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  // Allocate buffers twice as big to check for invalid read and write
-  auto padded_left_size = 2 * t_left.size();
-  auto padded_right_size = 2 * t_right.size();
-  auto padded_result_size = 2 * t_result.size();
-
-  std::size_t t_left_bytes = padded_left_size * sizeof(DataType);
-  std::size_t t_right_bytes = padded_right_size * sizeof(DataType);
-  std::size_t t_result_bytes = padded_result_size * sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  // TensorMaps are still of the same size than the Tensors
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, result_dims);
-
-  // Write nan after the actual buffer to propagate nans everywhere in case of
-  // invalid reads
-  DataType nan = std::numeric_limits<DataType>::quiet_NaN();
-  auto host_left_data = new DataType[padded_left_size];
-  std::copy_n(t_left.data(), t_left.size(), host_left_data);
-  std::fill_n(host_left_data + t_left.size(), t_left.size(), nan);
-  auto host_right_data = new DataType[padded_right_size];
-  std::copy_n(t_right.data(), t_right.size(), host_right_data);
-  std::fill_n(host_right_data + t_right.size(), t_right.size(), nan);
-  auto host_result_data = new DataType[padded_result_size];
-  std::fill_n(host_result_data, padded_result_size, nan);
-
-  sycl_device.memcpyHostToDevice(d_t_left, host_left_data, t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, host_right_data, t_right_bytes);
-  sycl_device.memcpyHostToDevice(d_t_result, host_result_data, t_result_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
-  sycl_device.memcpyDeviceToHost(host_result_data, d_t_result, t_result_bytes);
-
-  t_result = t_left.contract(t_right, dims);
-
-  for (IndexType i = 0; i < t_result.size(); i++) {
-    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - host_result_data[i]))) < error_threshold) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), host_result_data[i], error_threshold)) {
-      continue;
-    }
-    if (std::isnan(host_result_data[i])) {
-      std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size
-                << ", invalid read detected at IndexType " << i << ": " << t_result(i) << " vs " << host_result_data[i]
-                << std::endl;
-    } else {
-      std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
-                << i << ": " << t_result(i) << " vs " << host_result_data[i] << std::endl;
-    }
-    VERIFY_IS_APPROX(host_result_data[i], t_result(i));
-  }
-  // Make sure that the rest of the result is still nans
-  for (IndexType i = t_result.size(); i < padded_result_size; i++) {
-    if (std::isnan(host_result_data[i])) {
-      continue;
-    }
-    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size
-              << ", invalid write detected at IndexType " << i << ": " << host_result_data[i] << std::endl;
-    VERIFY_IS_APPROX(host_result_data[i], t_result(i));
-  }
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-
-  delete[] host_left_data;
-  delete[] host_right_data;
-  delete[] host_result_data;
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void test_scalar(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
-  // std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size <<
-  // ")" << std::endl;
-  // with these dimensions, the output has 300 * 140 elements, which is
-  // more than 30 * 1024, which is the number of threads in blocks on
-  // a 15 SM GK110 GPU
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  Tensor<DataType, 2, DataLayout, IndexType> t_left(m_size, k_size);
-  Tensor<DataType, 2, DataLayout, IndexType> t_right(k_size, n_size);
-  Tensor<DataType, 0, DataLayout, IndexType> t_result;
-  Tensor<DataType, 0, DataLayout, IndexType> t_result_gpu;
-  Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(1, 1)}};
-  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
-  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
-  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
-  std::size_t t_result_bytes = sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 0, DataLayout, IndexType>> gpu_t_result(d_t_result);
-
-  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
-
-  t_result = t_left.contract(t_right, dims);
-
-  if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result() - t_result_gpu()))) > error_threshold &&
-      !Eigen::internal::isApprox(t_result(), t_result_gpu(), error_threshold)) {
-    std::cout << "K: " << k_size << ", N: " << n_size << ", M: " << m_size << " : mismatch detected: " << t_result()
-              << " vs " << t_result_gpu() << std::endl;
-    VERIFY_IS_APPROX(t_result_gpu(), t_result());
-  }
-
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void contraction_batch(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size,
-                       IndexType m_batch, IndexType start, IndexType limit) {
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  typedef Eigen::array<IndexType, 3> TensorDim;
-  typedef Eigen::Tensor<DataType, 3, DataLayout, IndexType> TensorType;
-  TensorDim left_dims = {{m_batch, k_size, m_size}};
-  TensorDim right_dims = {{m_batch, n_size, k_size}};
-  TensorDim res_dims = {{m_batch, m_size, n_size}};
-  Eigen::array<DimPair, 1> contract_pairs = {{DimPair(0, 1)}};
-
-  TensorType t_left(left_dims);
-  TensorType t_right(right_dims);
-  TensorType t_result_gpu(res_dims);
-  TensorType t_result(res_dims);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
-  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
-  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  Eigen::TensorMap<TensorType> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<TensorType> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<TensorType> gpu_t_result(d_t_result, res_dims);
-
-  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
-  for (int i = start; i < limit; ++i) {
-    auto x = gpu_t_left.template chip<0>(i);
-    auto y = gpu_t_right.template chip<0>(i);
-    auto z = gpu_t_result.template chip<0>(i);
-    z.device(sycl_device) = x.contract(y, contract_pairs);
-  }
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
-
-  for (int i = start; i < limit; ++i) {
-    auto x = t_left.template chip<0>(i);
-    auto y = t_right.template chip<0>(i);
-    auto z = t_result.template chip<0>(i);
-    z = x.contract(y, contract_pairs);
-  }
-
-  for (IndexType i = 0; i < t_result.size(); i++) {
-    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
-      continue;
-    }
-    std::cout << "mismatch detected at IndexType " << i << ": " << t_result(i) << " vs " << t_result_gpu(i)
-              << std::endl;
-    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
-  }
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void contraction_rhs_transposed(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  Eigen::array<IndexType, 2> left_dims = {{m_size, k_size}};
-  Eigen::array<IndexType, 2> right_dims = {{n_size, k_size}};
-  Eigen::array<IndexType, 2> res_dims = {{m_size, n_size}};
-  Eigen::array<DimPair, 1> dims = {{DimPair(1, 1)}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
-  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
-  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, res_dims);
-
-  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
-
-  t_result = t_left.contract(t_right, dims);
-
-  for (IndexType j = 0; j < m_size; j++) {
-    for (IndexType i = 0; i < n_size; i++) {
-      if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(j, i) - t_result_gpu(j, i)))) <
-          error_threshold) {
-        continue;
-      }
-      if (Eigen::internal::isApprox(t_result(j, i), t_result_gpu(j, i), error_threshold)) {
-        continue;
-      }
-      std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size
-                << ", mismatch detected at IndexType m: " << j << " n: " << i << " CPU : " << t_result(j, i)
-                << " vs SYCL:" << t_result_gpu(j, i) << std::endl;
-      VERIFY_IS_APPROX(t_result_gpu(j, i), t_result(j, i));
-    }
-  }
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void contraction_lhs_transposed(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  Eigen::array<IndexType, 2> left_dims = {{k_size, m_size}};
-  Eigen::array<IndexType, 2> right_dims = {{k_size, n_size}};
-  Eigen::array<IndexType, 2> res_dims = {{m_size, n_size}};
-  Eigen::array<DimPair, 1> dims = {{DimPair(0, 0)}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
-  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
-  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, res_dims);
-
-  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
-
-  t_result = t_left.contract(t_right, dims);
-
-  for (IndexType i = 0; i < t_result.size(); i++) {
-    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
-      continue;
-    }
-    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
-              << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
-    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
-  }
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-}
-
-template <int DataLayout, typename DataType, typename IndexType, typename Device>
-void contraction_both_transposed(const Device &sycl_device, IndexType m_size, IndexType k_size, IndexType n_size) {
-  typedef typename Tensor<DataType, 1, DataLayout, IndexType>::DimensionPair DimPair;
-  static const DataType error_threshold = DataType(1e-4);
-  Eigen::array<IndexType, 2> left_dims = {{k_size, m_size}};
-  Eigen::array<IndexType, 2> right_dims = {{n_size, k_size}};
-  Eigen::array<IndexType, 2> res_dims = {{m_size, n_size}};
-  Eigen::array<DimPair, 1> dims = {{DimPair(0, 1)}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> t_left(left_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_right(right_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result_gpu(res_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> t_result(res_dims);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(DataType);
-  std::size_t t_right_bytes = t_right.size() * sizeof(DataType);
-  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
-
-  DataType *d_t_left = static_cast<DataType *>(sycl_device.allocate(t_left_bytes));
-  DataType *d_t_right = static_cast<DataType *>(sycl_device.allocate(t_right_bytes));
-  DataType *d_t_result = static_cast<DataType *>(sycl_device.allocate(t_result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_left(d_t_left, left_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_right(d_t_right, right_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType>> gpu_t_result(d_t_result, res_dims);
-
-  sycl_device.memcpyHostToDevice(d_t_left, t_left.data(), t_left_bytes);
-  sycl_device.memcpyHostToDevice(d_t_right, t_right.data(), t_right_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_left.contract(gpu_t_right, dims);
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), d_t_result, t_result_bytes);
-
-  t_result = t_left.contract(t_right, dims);
-
-  for (IndexType i = 0; i < t_result.size(); i++) {
-    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
-      continue;
-    }
-    std::cout << "M : " << m_size << ", N : " << n_size << ", K : " << k_size << ", mismatch detected at IndexType "
-              << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
-
-    VERIFY_IS_APPROX(t_result_gpu(i), t_result(i));
-  }
-  sycl_device.deallocate(d_t_left);
-  sycl_device.deallocate(d_t_right);
-  sycl_device.deallocate(d_t_result);
-}
-
-template <typename Dev>
-void inline tensorOutofBound(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Test out of bound for Tensor-Tensor
-  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 10, 1024, 1024);
-  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 1024, 1024, 4096);
-  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 4096, 1024, 2048);
-  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 784, 2048, 1024);
-  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 2048, 1024, 784);
-  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 10, 1024, 10);
-  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 513, 4096, 513);
-  test_no_out_of_bounds<RowMajor, DataType, IndexType>(sycl_device, 783, 1024, 783);
-  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 784, 2048, 784);
-  test_no_out_of_bounds<ColMajor, DataType, IndexType>(sycl_device, 11, 1024, 11);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "tensor out of bound tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-
-template <typename Dev>
-void inline tensorTensor(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Tensor Tensor Contraction
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 128, 128, 128);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 128, 128, 128);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-
-template <typename Dev>
-void inline tensorTensor_m(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Tensor Tensor Contraction
-  test_sycl_contraction_m<ColMajor, DataType, IndexType>(sycl_device);
-  test_sycl_contraction_m<RowMajor, DataType, IndexType>(sycl_device);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-
-template <typename Dev>
-void inline tensorTensor_n(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Tensor Tensor Contraction
-  test_sycl_contraction_n<ColMajor, DataType, IndexType>(sycl_device);
-  test_sycl_contraction_n<RowMajor, DataType, IndexType>(sycl_device);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-
-template <typename Dev>
-void inline tensorTensor_k(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  test_sycl_contraction_k<ColMajor, DataType, IndexType>(sycl_device);
-  test_sycl_contraction_k<RowMajor, DataType, IndexType>(sycl_device);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-
-template <typename Dev>
-void inline tensorTensor_sizes(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Tensor Tensor Contraction
-  test_sycl_contraction_sizes<ColMajor, DataType, IndexType>(sycl_device);
-  test_sycl_contraction_sizes<RowMajor, DataType, IndexType>(sycl_device);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "tensor tensor tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-template <typename Dev>
-void inline vectorVector(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // VECTOR-VECTOR
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1025, 1, 1025);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1025, 1, 1025);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1024, 1, 1024);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1024, 1, 1024);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1023, 1, 1023);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1023, 1, 1023);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "contracted tensor tests finished computation at " << std::ctime(&end_time)
-            << "elapsed time: " << elapsed_seconds.count() << "s\n";
-}
-
-template <typename Dev>
-void inline vectorTensor(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Vector-Tensor
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 1025, 1025);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 1025, 1025);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 1024, 1024);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 1024, 1024);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 1023, 1023);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 1023, 1023);
-
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 4097, 4097);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 4097, 4097);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 4096, 4096);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 4096, 4096);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 4095, 4095);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1, 4095, 4095);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1, 802816, 32);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline tensorVector(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Matrix-Vector
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1025, 1025, 1);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1125, 1025, 1);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1224, 1024, 1);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1024, 1024, 1);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 1023, 1023, 1);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 1023, 1023, 1);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 4097, 4197, 1);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 4097, 4097, 1);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 4096, 4096, 1);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 4096, 8196, 1);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 4095, 4095, 1);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 4095, 4095, 1);
-// If the GEMV disabled it will creates one kernel to calculate the contraction.
-// Therefore the acumuation of float number will overflow the precision
-// threshold for float and cause the test to fail. While it the GMV multiple
-// kernel will be created and each one run the overflow of accumutation breaks
-// among the kernels.
-#ifndef EIGEN_SYCL_DISABLE_GEMV
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 32, 802032, 1);
-#endif
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline tensorScalar(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // SCALAR Contraction
-  test_scalar<ColMajor, DataType, IndexType>(sycl_device, 127, 127, 127);
-  test_scalar<RowMajor, DataType, IndexType>(sycl_device, 127, 127, 127);
-  test_scalar<ColMajor, DataType, IndexType>(sycl_device, 128, 128, 128);
-  test_scalar<RowMajor, DataType, IndexType>(sycl_device, 128, 128, 128);
-  test_scalar<ColMajor, DataType, IndexType>(sycl_device, 129, 129, 129);
-  test_scalar<RowMajor, DataType, IndexType>(sycl_device, 129, 129, 129);
-
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline skinnyTensor_row(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Tensor Tensor Contraction
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 16, 4, 16);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 257, 131073, 257);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 256, 131072, 256);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 16, 131073, 16);
-  test_sycl_contraction<RowMajor, DataType, IndexType>(sycl_device, 17, 131072, 17);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline skinnyTensor_col(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-  // Tensor Tensor Contraction
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 16, 4, 16);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 257, 131073, 257);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 256, 131072, 256);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 16, 131073, 16);
-  test_sycl_contraction<ColMajor, DataType, IndexType>(sycl_device, 17, 131072, 17);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline tensor_contraction_batch_per_device(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-
-  contraction_batch<RowMajor, DataType, IndexType>(sycl_device, 64, 75, 30, 4, 0, 4);
-  contraction_batch<ColMajor, DataType, IndexType>(sycl_device, 64, 75, 30, 4, 0, 4);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline tensor_contraction_lhs_transposed_per_device(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 8, 4, 8);
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 32, 8, 32);
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 64, 16, 64);
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 784, 2048, 1024);
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 1024, 10, 1024);
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 4096, 1024, 1024);
-  contraction_lhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 2048, 4096, 1024);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline tensor_contraction_rhs_transposed_per_device(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 16, 4, 16);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 17, 5, 17);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 32, 8, 32);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 64, 16, 64);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 10, 1024, 1024);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 1024, 1024, 4096);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 4096, 1024, 2048);
-  contraction_rhs_transposed<RowMajor, DataType, IndexType>(sycl_device, 2048, 1024, 784);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-template <typename Dev>
-void inline tensor_contraction_both_transposed_per_device(const Dev &sycl_device) {
-  typedef float DataType;
-  typedef int64_t IndexType;
-  std::chrono::time_point<std::chrono::system_clock> start, end;
-  start = std::chrono::system_clock::now();
-
-  contraction_both_transposed<RowMajor, DataType, IndexType>(sycl_device, 17, 5, 17);
-  contraction_both_transposed<RowMajor, DataType, IndexType>(sycl_device, 32, 8, 32);
-  contraction_both_transposed<RowMajor, DataType, IndexType>(sycl_device, 64, 16, 64);
-  end = std::chrono::system_clock::now();
-  std::chrono::duration<double> elapsed_seconds = end - start;
-  std::time_t end_time = std::chrono::system_clock::to_time_t(end);
-  std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count()
-            << "s\n";
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_contract_sycl) {
-  for (const auto &device : Eigen::get_sycl_supported_devices()) {
-    std::cout << "Running on " << device.template get_info<cl::sycl::info::device::name>() << std::endl;
-    QueueInterface queueInterface(device);
-    auto sycl_device = Eigen::SyclDevice(&queueInterface);
-    CALL_SUBTEST_1(tensorOutofBound(sycl_device));
-    CALL_SUBTEST_2(tensorTensor(sycl_device));
-    CALL_SUBTEST_2(tensorTensor_m(sycl_device));
-    CALL_SUBTEST_2(tensorTensor_n(sycl_device));
-    CALL_SUBTEST_2(tensorTensor_k(sycl_device));
-    CALL_SUBTEST_2(tensorTensor_sizes(sycl_device));
-    CALL_SUBTEST_3(vectorVector(sycl_device));
-    CALL_SUBTEST_4(vectorTensor(sycl_device));
-    CALL_SUBTEST_5(tensorVector(sycl_device));
-    CALL_SUBTEST_6(tensorScalar(sycl_device));
-    CALL_SUBTEST_7(skinnyTensor_row(sycl_device));
-    CALL_SUBTEST_7(skinnyTensor_col(sycl_device));
-    CALL_SUBTEST_8(tensor_contraction_batch_per_device(sycl_device));
-    CALL_SUBTEST_9(tensor_contraction_lhs_transposed_per_device(sycl_device));
-    CALL_SUBTEST_10(tensor_contraction_rhs_transposed_per_device(sycl_device));
-    CALL_SUBTEST_11(tensor_contraction_both_transposed_per_device(sycl_device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_contraction.cpp b/unsupported/test/cxx11_tensor_contraction.cpp
deleted file mode 100644
index 9bf7ec6..0000000
--- a/unsupported/test/cxx11_tensor_contraction.cpp
+++ /dev/null
@@ -1,567 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::DefaultDevice;
-using Eigen::Tensor;
-
-typedef Tensor<float, 1>::DimensionPair DimPair;
-
-template <int DataLayout>
-static void test_evals() {
-  Tensor<float, 2, DataLayout> mat1(2, 3);
-  Tensor<float, 2, DataLayout> mat2(2, 3);
-  Tensor<float, 2, DataLayout> mat3(3, 2);
-
-  mat1.setRandom();
-  mat2.setRandom();
-  mat3.setRandom();
-
-  Tensor<float, 2, DataLayout> mat4(3, 3);
-  mat4.setZero();
-  Eigen::array<DimPair, 1> dims3 = {{DimPair(0, 0)}};
-  typedef TensorEvaluator<decltype(mat1.contract(mat2, dims3)), DefaultDevice> Evaluator;
-  Evaluator eval(mat1.contract(mat2, dims3), DefaultDevice());
-  eval.evalTo(mat4.data());
-  EIGEN_STATIC_ASSERT(Evaluator::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  VERIFY_IS_EQUAL(eval.dimensions()[0], 3);
-  VERIFY_IS_EQUAL(eval.dimensions()[1], 3);
-
-  VERIFY_IS_APPROX(mat4(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(1, 0) * mat2(1, 0));
-  VERIFY_IS_APPROX(mat4(0, 1), mat1(0, 0) * mat2(0, 1) + mat1(1, 0) * mat2(1, 1));
-  VERIFY_IS_APPROX(mat4(0, 2), mat1(0, 0) * mat2(0, 2) + mat1(1, 0) * mat2(1, 2));
-  VERIFY_IS_APPROX(mat4(1, 0), mat1(0, 1) * mat2(0, 0) + mat1(1, 1) * mat2(1, 0));
-  VERIFY_IS_APPROX(mat4(1, 1), mat1(0, 1) * mat2(0, 1) + mat1(1, 1) * mat2(1, 1));
-  VERIFY_IS_APPROX(mat4(1, 2), mat1(0, 1) * mat2(0, 2) + mat1(1, 1) * mat2(1, 2));
-  VERIFY_IS_APPROX(mat4(2, 0), mat1(0, 2) * mat2(0, 0) + mat1(1, 2) * mat2(1, 0));
-  VERIFY_IS_APPROX(mat4(2, 1), mat1(0, 2) * mat2(0, 1) + mat1(1, 2) * mat2(1, 1));
-  VERIFY_IS_APPROX(mat4(2, 2), mat1(0, 2) * mat2(0, 2) + mat1(1, 2) * mat2(1, 2));
-
-  Tensor<float, 2, DataLayout> mat5(2, 2);
-  mat5.setZero();
-  Eigen::array<DimPair, 1> dims4 = {{DimPair(1, 1)}};
-  typedef TensorEvaluator<decltype(mat1.contract(mat2, dims4)), DefaultDevice> Evaluator2;
-  Evaluator2 eval2(mat1.contract(mat2, dims4), DefaultDevice());
-  eval2.evalTo(mat5.data());
-  EIGEN_STATIC_ASSERT(Evaluator2::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  VERIFY_IS_EQUAL(eval2.dimensions()[0], 2);
-  VERIFY_IS_EQUAL(eval2.dimensions()[1], 2);
-
-  VERIFY_IS_APPROX(mat5(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(0, 1) * mat2(0, 1) + mat1(0, 2) * mat2(0, 2));
-  VERIFY_IS_APPROX(mat5(0, 1), mat1(0, 0) * mat2(1, 0) + mat1(0, 1) * mat2(1, 1) + mat1(0, 2) * mat2(1, 2));
-  VERIFY_IS_APPROX(mat5(1, 0), mat1(1, 0) * mat2(0, 0) + mat1(1, 1) * mat2(0, 1) + mat1(1, 2) * mat2(0, 2));
-  VERIFY_IS_APPROX(mat5(1, 1), mat1(1, 0) * mat2(1, 0) + mat1(1, 1) * mat2(1, 1) + mat1(1, 2) * mat2(1, 2));
-
-  Tensor<float, 2, DataLayout> mat6(2, 2);
-  mat6.setZero();
-  Eigen::array<DimPair, 1> dims6 = {{DimPair(1, 0)}};
-  typedef TensorEvaluator<decltype(mat1.contract(mat3, dims6)), DefaultDevice> Evaluator3;
-  Evaluator3 eval3(mat1.contract(mat3, dims6), DefaultDevice());
-  eval3.evalTo(mat6.data());
-  EIGEN_STATIC_ASSERT(Evaluator3::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  VERIFY_IS_EQUAL(eval3.dimensions()[0], 2);
-  VERIFY_IS_EQUAL(eval3.dimensions()[1], 2);
-
-  VERIFY_IS_APPROX(mat6(0, 0), mat1(0, 0) * mat3(0, 0) + mat1(0, 1) * mat3(1, 0) + mat1(0, 2) * mat3(2, 0));
-  VERIFY_IS_APPROX(mat6(0, 1), mat1(0, 0) * mat3(0, 1) + mat1(0, 1) * mat3(1, 1) + mat1(0, 2) * mat3(2, 1));
-  VERIFY_IS_APPROX(mat6(1, 0), mat1(1, 0) * mat3(0, 0) + mat1(1, 1) * mat3(1, 0) + mat1(1, 2) * mat3(2, 0));
-  VERIFY_IS_APPROX(mat6(1, 1), mat1(1, 0) * mat3(0, 1) + mat1(1, 1) * mat3(1, 1) + mat1(1, 2) * mat3(2, 1));
-}
-
-template <int DataLayout>
-static void test_scalar() {
-  Tensor<float, 1, DataLayout> vec1({6});
-  Tensor<float, 1, DataLayout> vec2({6});
-
-  vec1.setRandom();
-  vec2.setRandom();
-
-  Eigen::array<DimPair, 1> dims = {{DimPair(0, 0)}};
-  Tensor<float, 0, DataLayout> scalar = vec1.contract(vec2, dims);
-
-  float expected = 0.0f;
-  for (int i = 0; i < 6; ++i) {
-    expected += vec1(i) * vec2(i);
-  }
-  VERIFY_IS_APPROX(scalar(), expected);
-}
-
-template <int DataLayout>
-static void test_multidims() {
-  Tensor<float, 3, DataLayout> mat1(2, 2, 2);
-  Tensor<float, 4, DataLayout> mat2(2, 2, 2, 2);
-
-  mat1.setRandom();
-  mat2.setRandom();
-
-  Tensor<float, 3, DataLayout> mat3(2, 2, 2);
-  mat3.setZero();
-  Eigen::array<DimPair, 2> dims = {{DimPair(1, 2), DimPair(2, 3)}};
-  typedef TensorEvaluator<decltype(mat1.contract(mat2, dims)), DefaultDevice> Evaluator;
-  Evaluator eval(mat1.contract(mat2, dims), DefaultDevice());
-  eval.evalTo(mat3.data());
-  EIGEN_STATIC_ASSERT(Evaluator::NumDims == 3ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  VERIFY_IS_EQUAL(eval.dimensions()[0], 2);
-  VERIFY_IS_EQUAL(eval.dimensions()[1], 2);
-  VERIFY_IS_EQUAL(eval.dimensions()[2], 2);
-
-  VERIFY_IS_APPROX(mat3(0, 0, 0), mat1(0, 0, 0) * mat2(0, 0, 0, 0) + mat1(0, 1, 0) * mat2(0, 0, 1, 0) +
-                                      mat1(0, 0, 1) * mat2(0, 0, 0, 1) + mat1(0, 1, 1) * mat2(0, 0, 1, 1));
-  VERIFY_IS_APPROX(mat3(0, 0, 1), mat1(0, 0, 0) * mat2(0, 1, 0, 0) + mat1(0, 1, 0) * mat2(0, 1, 1, 0) +
-                                      mat1(0, 0, 1) * mat2(0, 1, 0, 1) + mat1(0, 1, 1) * mat2(0, 1, 1, 1));
-  VERIFY_IS_APPROX(mat3(0, 1, 0), mat1(0, 0, 0) * mat2(1, 0, 0, 0) + mat1(0, 1, 0) * mat2(1, 0, 1, 0) +
-                                      mat1(0, 0, 1) * mat2(1, 0, 0, 1) + mat1(0, 1, 1) * mat2(1, 0, 1, 1));
-  VERIFY_IS_APPROX(mat3(0, 1, 1), mat1(0, 0, 0) * mat2(1, 1, 0, 0) + mat1(0, 1, 0) * mat2(1, 1, 1, 0) +
-                                      mat1(0, 0, 1) * mat2(1, 1, 0, 1) + mat1(0, 1, 1) * mat2(1, 1, 1, 1));
-  VERIFY_IS_APPROX(mat3(1, 0, 0), mat1(1, 0, 0) * mat2(0, 0, 0, 0) + mat1(1, 1, 0) * mat2(0, 0, 1, 0) +
-                                      mat1(1, 0, 1) * mat2(0, 0, 0, 1) + mat1(1, 1, 1) * mat2(0, 0, 1, 1));
-  VERIFY_IS_APPROX(mat3(1, 0, 1), mat1(1, 0, 0) * mat2(0, 1, 0, 0) + mat1(1, 1, 0) * mat2(0, 1, 1, 0) +
-                                      mat1(1, 0, 1) * mat2(0, 1, 0, 1) + mat1(1, 1, 1) * mat2(0, 1, 1, 1));
-  VERIFY_IS_APPROX(mat3(1, 1, 0), mat1(1, 0, 0) * mat2(1, 0, 0, 0) + mat1(1, 1, 0) * mat2(1, 0, 1, 0) +
-                                      mat1(1, 0, 1) * mat2(1, 0, 0, 1) + mat1(1, 1, 1) * mat2(1, 0, 1, 1));
-  VERIFY_IS_APPROX(mat3(1, 1, 1), mat1(1, 0, 0) * mat2(1, 1, 0, 0) + mat1(1, 1, 0) * mat2(1, 1, 1, 0) +
-                                      mat1(1, 0, 1) * mat2(1, 1, 0, 1) + mat1(1, 1, 1) * mat2(1, 1, 1, 1));
-
-  Tensor<float, 2, DataLayout> mat4(2, 2);
-  Tensor<float, 3, DataLayout> mat5(2, 2, 2);
-
-  mat4.setRandom();
-  mat5.setRandom();
-
-  Tensor<float, 1, DataLayout> mat6(2);
-  mat6.setZero();
-  Eigen::array<DimPair, 2> dims2{{DimPair(0, 1), DimPair(1, 0)}};
-  typedef TensorEvaluator<decltype(mat4.contract(mat5, dims2)), DefaultDevice> Evaluator2;
-  Evaluator2 eval2(mat4.contract(mat5, dims2), DefaultDevice());
-  eval2.evalTo(mat6.data());
-  EIGEN_STATIC_ASSERT(Evaluator2::NumDims == 1ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  VERIFY_IS_EQUAL(eval2.dimensions()[0], 2);
-
-  VERIFY_IS_APPROX(mat6(0), mat4(0, 0) * mat5(0, 0, 0) + mat4(1, 0) * mat5(0, 1, 0) + mat4(0, 1) * mat5(1, 0, 0) +
-                                mat4(1, 1) * mat5(1, 1, 0));
-  VERIFY_IS_APPROX(mat6(1), mat4(0, 0) * mat5(0, 0, 1) + mat4(1, 0) * mat5(0, 1, 1) + mat4(0, 1) * mat5(1, 0, 1) +
-                                mat4(1, 1) * mat5(1, 1, 1));
-}
-
-template <int DataLayout>
-static void test_holes() {
-  Tensor<float, 4, DataLayout> t1(2, 5, 7, 3);
-  Tensor<float, 5, DataLayout> t2(2, 7, 11, 13, 3);
-  t1.setRandom();
-  t2.setRandom();
-
-  Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(3, 4)}};
-  Tensor<float, 5, DataLayout> result = t1.contract(t2, dims);
-  VERIFY_IS_EQUAL(result.dimension(0), 5);
-  VERIFY_IS_EQUAL(result.dimension(1), 7);
-  VERIFY_IS_EQUAL(result.dimension(2), 7);
-  VERIFY_IS_EQUAL(result.dimension(3), 11);
-  VERIFY_IS_EQUAL(result.dimension(4), 13);
-
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 5; ++l) {
-          for (int m = 0; m < 5; ++m) {
-            VERIFY_IS_APPROX(result(i, j, k, l, m),
-                             t1(0, i, j, 0) * t2(0, k, l, m, 0) + t1(1, i, j, 0) * t2(1, k, l, m, 0) +
-                                 t1(0, i, j, 1) * t2(0, k, l, m, 1) + t1(1, i, j, 1) * t2(1, k, l, m, 1) +
-                                 t1(0, i, j, 2) * t2(0, k, l, m, 2) + t1(1, i, j, 2) * t2(1, k, l, m, 2));
-          }
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_full_redux() {
-  Tensor<float, 2, DataLayout> t1(2, 2);
-  Tensor<float, 3, DataLayout> t2(2, 2, 2);
-  t1.setRandom();
-  t2.setRandom();
-
-  Eigen::array<DimPair, 2> dims = {{DimPair(0, 0), DimPair(1, 1)}};
-  Tensor<float, 1, DataLayout> result = t1.contract(t2, dims);
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_APPROX(result(0),
-                   t1(0, 0) * t2(0, 0, 0) + t1(1, 0) * t2(1, 0, 0) + t1(0, 1) * t2(0, 1, 0) + t1(1, 1) * t2(1, 1, 0));
-  VERIFY_IS_APPROX(result(1),
-                   t1(0, 0) * t2(0, 0, 1) + t1(1, 0) * t2(1, 0, 1) + t1(0, 1) * t2(0, 1, 1) + t1(1, 1) * t2(1, 1, 1));
-
-  dims[0] = DimPair(1, 0);
-  dims[1] = DimPair(2, 1);
-  result = t2.contract(t1, dims);
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_APPROX(result(0),
-                   t1(0, 0) * t2(0, 0, 0) + t1(1, 0) * t2(0, 1, 0) + t1(0, 1) * t2(0, 0, 1) + t1(1, 1) * t2(0, 1, 1));
-  VERIFY_IS_APPROX(result(1),
-                   t1(0, 0) * t2(1, 0, 0) + t1(1, 0) * t2(1, 1, 0) + t1(0, 1) * t2(1, 0, 1) + t1(1, 1) * t2(1, 1, 1));
-}
-
-template <int DataLayout>
-static void test_contraction_of_contraction() {
-  Tensor<float, 2, DataLayout> t1(2, 2);
-  Tensor<float, 2, DataLayout> t2(2, 2);
-  Tensor<float, 2, DataLayout> t3(2, 2);
-  Tensor<float, 2, DataLayout> t4(2, 2);
-  t1.setRandom();
-  t2.setRandom();
-  t3.setRandom();
-  t4.setRandom();
-
-  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
-  auto contract1 = t1.contract(t2, dims);
-  auto diff = t3 - contract1;
-  auto contract2 = t1.contract(t4, dims);
-  Tensor<float, 2, DataLayout> result = contract2.contract(diff, dims);
-
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 2);
-
-  Eigen::Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> m1(t1.data(), 2, 2), m2(t2.data(), 2, 2),
-      m3(t3.data(), 2, 2), m4(t4.data(), 2, 2);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> expected = (m1 * m4) * (m3 - m1 * m2);
-
-  VERIFY_IS_APPROX(result(0, 0), expected(0, 0));
-  VERIFY_IS_APPROX(result(0, 1), expected(0, 1));
-  VERIFY_IS_APPROX(result(1, 0), expected(1, 0));
-  VERIFY_IS_APPROX(result(1, 1), expected(1, 1));
-}
-
-template <int DataLayout>
-static void test_expr() {
-  Tensor<float, 2, DataLayout> mat1(2, 3);
-  Tensor<float, 2, DataLayout> mat2(3, 2);
-  mat1.setRandom();
-  mat2.setRandom();
-
-  Tensor<float, 2, DataLayout> mat3(2, 2);
-
-  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
-  mat3 = mat1.contract(mat2, dims);
-
-  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(0, 1) * mat2(1, 0) + mat1(0, 2) * mat2(2, 0));
-  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0) * mat2(0, 1) + mat1(0, 1) * mat2(1, 1) + mat1(0, 2) * mat2(2, 1));
-  VERIFY_IS_APPROX(mat3(1, 0), mat1(1, 0) * mat2(0, 0) + mat1(1, 1) * mat2(1, 0) + mat1(1, 2) * mat2(2, 0));
-  VERIFY_IS_APPROX(mat3(1, 1), mat1(1, 0) * mat2(0, 1) + mat1(1, 1) * mat2(1, 1) + mat1(1, 2) * mat2(2, 1));
-}
-
-template <int DataLayout>
-static void test_out_of_order_contraction() {
-  Tensor<float, 3, DataLayout> mat1(2, 2, 2);
-  Tensor<float, 3, DataLayout> mat2(2, 2, 2);
-
-  mat1.setRandom();
-  mat2.setRandom();
-
-  Tensor<float, 2, DataLayout> mat3(2, 2);
-
-  Eigen::array<DimPair, 2> dims = {{DimPair(2, 0), DimPair(0, 2)}};
-  mat3 = mat1.contract(mat2, dims);
-
-  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0, 0) * mat2(0, 0, 0) + mat1(1, 0, 0) * mat2(0, 0, 1) +
-                                   mat1(0, 0, 1) * mat2(1, 0, 0) + mat1(1, 0, 1) * mat2(1, 0, 1));
-  VERIFY_IS_APPROX(mat3(1, 0), mat1(0, 1, 0) * mat2(0, 0, 0) + mat1(1, 1, 0) * mat2(0, 0, 1) +
-                                   mat1(0, 1, 1) * mat2(1, 0, 0) + mat1(1, 1, 1) * mat2(1, 0, 1));
-  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0, 0) * mat2(0, 1, 0) + mat1(1, 0, 0) * mat2(0, 1, 1) +
-                                   mat1(0, 0, 1) * mat2(1, 1, 0) + mat1(1, 0, 1) * mat2(1, 1, 1));
-  VERIFY_IS_APPROX(mat3(1, 1), mat1(0, 1, 0) * mat2(0, 1, 0) + mat1(1, 1, 0) * mat2(0, 1, 1) +
-                                   mat1(0, 1, 1) * mat2(1, 1, 0) + mat1(1, 1, 1) * mat2(1, 1, 1));
-
-  Eigen::array<DimPair, 2> dims2 = {{DimPair(0, 2), DimPair(2, 0)}};
-  mat3 = mat1.contract(mat2, dims2);
-
-  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0, 0) * mat2(0, 0, 0) + mat1(1, 0, 0) * mat2(0, 0, 1) +
-                                   mat1(0, 0, 1) * mat2(1, 0, 0) + mat1(1, 0, 1) * mat2(1, 0, 1));
-  VERIFY_IS_APPROX(mat3(1, 0), mat1(0, 1, 0) * mat2(0, 0, 0) + mat1(1, 1, 0) * mat2(0, 0, 1) +
-                                   mat1(0, 1, 1) * mat2(1, 0, 0) + mat1(1, 1, 1) * mat2(1, 0, 1));
-  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0, 0) * mat2(0, 1, 0) + mat1(1, 0, 0) * mat2(0, 1, 1) +
-                                   mat1(0, 0, 1) * mat2(1, 1, 0) + mat1(1, 0, 1) * mat2(1, 1, 1));
-  VERIFY_IS_APPROX(mat3(1, 1), mat1(0, 1, 0) * mat2(0, 1, 0) + mat1(1, 1, 0) * mat2(0, 1, 1) +
-                                   mat1(0, 1, 1) * mat2(1, 1, 0) + mat1(1, 1, 1) * mat2(1, 1, 1));
-}
-
-template <int DataLayout>
-static void test_consistency() {
-  // this does something like testing (A*B)^T = (B^T * A^T)
-
-  Tensor<float, 3, DataLayout> mat1(4, 3, 5);
-  Tensor<float, 5, DataLayout> mat2(3, 2, 1, 5, 4);
-  mat1.setRandom();
-  mat2.setRandom();
-
-  Tensor<float, 4, DataLayout> mat3(5, 2, 1, 5);
-  Tensor<float, 4, DataLayout> mat4(2, 1, 5, 5);
-
-  // contract on dimensions of size 4 and 3
-  Eigen::array<DimPair, 2> dims1 = {{DimPair(0, 4), DimPair(1, 0)}};
-  Eigen::array<DimPair, 2> dims2 = {{DimPair(4, 0), DimPair(0, 1)}};
-
-  mat3 = mat1.contract(mat2, dims1);
-  mat4 = mat2.contract(mat1, dims2);
-
-  // check that these are equal except for ordering of dimensions
-  if (DataLayout == ColMajor) {
-    for (size_t i = 0; i < 5; i++) {
-      for (size_t j = 0; j < 10; j++) {
-        VERIFY_IS_APPROX(mat3.data()[i + 5 * j], mat4.data()[j + 10 * i]);
-      }
-    }
-  } else {
-    // Row major
-    for (size_t i = 0; i < 5; i++) {
-      for (size_t j = 0; j < 10; j++) {
-        VERIFY_IS_APPROX(mat3.data()[10 * i + j], mat4.data()[i + 5 * j]);
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_large_contraction() {
-  Tensor<float, 4, DataLayout> t_left(30, 50, 8, 31);
-  Tensor<float, 5, DataLayout> t_right(8, 31, 7, 20, 10);
-  Tensor<float, 5, DataLayout> t_result(30, 50, 7, 20, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 1500, 248);
-  MapXf m_right(t_right.data(), 248, 1400);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 2> dims = {{DimPair(2, 0), DimPair(3, 1)}};
-
-  // compute results by separate methods
-  t_result = t_left.contract(t_right, dims);
-  m_result = m_left * m_right;
-
-  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
-    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
-  }
-}
-
-template <int DataLayout>
-static void test_matrix_vector() {
-  Tensor<float, 2, DataLayout> t_left(30, 50);
-  Tensor<float, 1, DataLayout> t_right(50);
-  Tensor<float, 1, DataLayout> t_result(30);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 30, 50);
-  MapXf m_right(t_right.data(), 50, 1);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(30, 1);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
-
-  // compute results by separate methods
-  t_result = t_left.contract(t_right, dims);
-  m_result = m_left * m_right;
-
-  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY(internal::isApprox(t_result(i), m_result(i, 0), 1));
-  }
-}
-
-template <int DataLayout>
-static void test_tensor_vector() {
-  Tensor<float, 3, DataLayout> t_left(7, 13, 17);
-  Tensor<float, 2, DataLayout> t_right(1, 7);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  typedef typename Tensor<float, 1, DataLayout>::DimensionPair DimensionPair;
-  Eigen::array<DimensionPair, 1> dim_pair01{{{0, 1}}};
-  Tensor<float, 3, DataLayout> t_result = t_left.contract(t_right, dim_pair01);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 7, 13 * 17);
-  MapXf m_right(t_right.data(), 1, 7);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result = m_left.transpose() * m_right.transpose();
-
-  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY(internal::isApprox(t_result(i), m_result(i, 0), 1));
-  }
-}
-
-template <int DataLayout>
-static void test_small_blocking_factors() {
-  Tensor<float, 4, DataLayout> t_left(30, 5, 3, 31);
-  Tensor<float, 5, DataLayout> t_right(3, 31, 7, 20, 1);
-  t_left.setRandom();
-  t_right.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  // Force the cache sizes, which results in smaller blocking factors.
-  Eigen::setCpuCacheSizes(896, 1920, 2944);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 2> dims = {{DimPair(2, 0), DimPair(3, 1)}};
-  Tensor<float, 5, DataLayout> t_result;
-  t_result = t_left.contract(t_right, dims);
-
-  // compute result using a simple eigen matrix product
-  Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> m_left(t_left.data(), 150, 93);
-  Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> m_right(t_right.data(), 93, 140);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result = m_left * m_right;
-
-  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
-  }
-}
-
-template <int DataLayout>
-static void test_tensor_product() {
-  Tensor<float, 2, DataLayout> mat1(2, 3);
-  Tensor<float, 2, DataLayout> mat2(4, 1);
-  mat1.setRandom();
-  mat2.setRandom();
-
-  Eigen::array<DimPair, 0> dims;
-  Tensor<float, 4, DataLayout> result = mat1.contract(mat2, dims);
-
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 3);
-  VERIFY_IS_EQUAL(result.dimension(2), 4);
-  VERIFY_IS_EQUAL(result.dimension(3), 1);
-  for (int i = 0; i < result.dimension(0); ++i) {
-    for (int j = 0; j < result.dimension(1); ++j) {
-      for (int k = 0; k < result.dimension(2); ++k) {
-        for (int l = 0; l < result.dimension(3); ++l) {
-          VERIFY_IS_APPROX(result(i, j, k, l), mat1(i, j) * mat2(k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_const_inputs() {
-  Tensor<float, 2, DataLayout> in1(2, 3);
-  Tensor<float, 2, DataLayout> in2(3, 2);
-  in1.setRandom();
-  in2.setRandom();
-
-  TensorMap<Tensor<const float, 2, DataLayout>> mat1(in1.data(), 2, 3);
-  TensorMap<Tensor<const float, 2, DataLayout>> mat2(in2.data(), 3, 2);
-  Tensor<float, 2, DataLayout> mat3(2, 2);
-
-  Eigen::array<DimPair, 1> dims = {{DimPair(1, 0)}};
-  mat3 = mat1.contract(mat2, dims);
-
-  VERIFY_IS_APPROX(mat3(0, 0), mat1(0, 0) * mat2(0, 0) + mat1(0, 1) * mat2(1, 0) + mat1(0, 2) * mat2(2, 0));
-  VERIFY_IS_APPROX(mat3(0, 1), mat1(0, 0) * mat2(0, 1) + mat1(0, 1) * mat2(1, 1) + mat1(0, 2) * mat2(2, 1));
-  VERIFY_IS_APPROX(mat3(1, 0), mat1(1, 0) * mat2(0, 0) + mat1(1, 1) * mat2(1, 0) + mat1(1, 2) * mat2(2, 0));
-  VERIFY_IS_APPROX(mat3(1, 1), mat1(1, 0) * mat2(0, 1) + mat1(1, 1) * mat2(1, 1) + mat1(1, 2) * mat2(2, 1));
-}
-
-// Apply Sqrt to all output elements.
-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));
-      }
-    }
-  }
-};
-
-template <int DataLayout>
-static void test_large_contraction_with_output_kernel() {
-  Tensor<float, 4, DataLayout> t_left(30, 50, 8, 31);
-  Tensor<float, 5, DataLayout> t_right(8, 31, 7, 20, 10);
-  Tensor<float, 5, DataLayout> t_result(30, 50, 7, 20, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-  // Put trash in mat4 to verify contraction clears output memory.
-  t_result.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 1500, 248);
-  MapXf m_right(t_right.data(), 248, 1400);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 2> dims{{DimPair(2, 0), DimPair(3, 1)}};
-
-  // compute results by separate methods
-  t_result = t_left.contract(t_right, dims, SqrtOutputKernel());
-
-  m_result = m_left * m_right;
-
-  for (std::ptrdiff_t i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
-    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_contraction) {
-  CALL_SUBTEST_1(test_evals<ColMajor>());
-  CALL_SUBTEST_1(test_evals<RowMajor>());
-  CALL_SUBTEST_1(test_scalar<ColMajor>());
-  CALL_SUBTEST_1(test_scalar<RowMajor>());
-  CALL_SUBTEST_2(test_multidims<ColMajor>());
-  CALL_SUBTEST_2(test_multidims<RowMajor>());
-  CALL_SUBTEST_2(test_holes<ColMajor>());
-  CALL_SUBTEST_2(test_holes<RowMajor>());
-  CALL_SUBTEST_3(test_full_redux<ColMajor>());
-  CALL_SUBTEST_3(test_full_redux<RowMajor>());
-  CALL_SUBTEST_3(test_contraction_of_contraction<ColMajor>());
-  CALL_SUBTEST_3(test_contraction_of_contraction<RowMajor>());
-  CALL_SUBTEST_4(test_expr<ColMajor>());
-  CALL_SUBTEST_4(test_expr<RowMajor>());
-  CALL_SUBTEST_4(test_out_of_order_contraction<ColMajor>());
-  CALL_SUBTEST_4(test_out_of_order_contraction<RowMajor>());
-  CALL_SUBTEST_5(test_consistency<ColMajor>());
-  CALL_SUBTEST_5(test_consistency<RowMajor>());
-  CALL_SUBTEST_5(test_large_contraction<ColMajor>());
-  CALL_SUBTEST_5(test_large_contraction<RowMajor>());
-  CALL_SUBTEST_6(test_matrix_vector<ColMajor>());
-  CALL_SUBTEST_6(test_matrix_vector<RowMajor>());
-  CALL_SUBTEST_6(test_tensor_vector<ColMajor>());
-  CALL_SUBTEST_6(test_tensor_vector<RowMajor>());
-  CALL_SUBTEST_7(test_small_blocking_factors<ColMajor>());
-  CALL_SUBTEST_7(test_small_blocking_factors<RowMajor>());
-  CALL_SUBTEST_7(test_tensor_product<ColMajor>());
-  CALL_SUBTEST_7(test_tensor_product<RowMajor>());
-  CALL_SUBTEST_8(test_const_inputs<ColMajor>());
-  CALL_SUBTEST_8(test_const_inputs<RowMajor>());
-  CALL_SUBTEST_8(test_large_contraction_with_output_kernel<ColMajor>());
-  CALL_SUBTEST_8(test_large_contraction_with_output_kernel<RowMajor>());
-
-  // Force CMake to split this test.
-  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8
-}
diff --git a/unsupported/test/cxx11_tensor_convolution.cpp b/unsupported/test/cxx11_tensor_convolution.cpp
deleted file mode 100644
index c7952c2..0000000
--- a/unsupported/test/cxx11_tensor_convolution.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::DefaultDevice;
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_evals() {
-  Tensor<float, 2, DataLayout> input(3, 3);
-  Tensor<float, 1, DataLayout> kernel(2);
-
-  input.setRandom();
-  kernel.setRandom();
-
-  Tensor<float, 2, DataLayout> result(2, 3);
-  result.setZero();
-  Eigen::array<Tensor<float, 2>::Index, 1> dims3;
-  dims3[0] = 0;
-
-  typedef TensorEvaluator<decltype(input.convolve(kernel, dims3)), DefaultDevice> Evaluator;
-  Evaluator eval(input.convolve(kernel, dims3), DefaultDevice());
-  eval.evalTo(result.data());
-  EIGEN_STATIC_ASSERT(Evaluator::NumDims == 2ul, YOU_MADE_A_PROGRAMMING_MISTAKE);
-  VERIFY_IS_EQUAL(eval.dimensions()[0], 2);
-  VERIFY_IS_EQUAL(eval.dimensions()[1], 3);
-
-  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0) + input(1, 0) * kernel(1));  // index 0
-  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0) + input(1, 1) * kernel(1));  // index 2
-  VERIFY_IS_APPROX(result(0, 2), input(0, 2) * kernel(0) + input(1, 2) * kernel(1));  // index 4
-  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0) + input(2, 0) * kernel(1));  // index 1
-  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0) + input(2, 1) * kernel(1));  // index 3
-  VERIFY_IS_APPROX(result(1, 2), input(1, 2) * kernel(0) + input(2, 2) * kernel(1));  // index 5
-}
-
-template <int DataLayout>
-static void test_expr() {
-  Tensor<float, 2, DataLayout> input(3, 3);
-  Tensor<float, 2, DataLayout> kernel(2, 2);
-  input.setRandom();
-  kernel.setRandom();
-
-  Tensor<float, 2, DataLayout> result(2, 2);
-  Eigen::array<ptrdiff_t, 2> dims;
-  dims[0] = 0;
-  dims[1] = 1;
-  result = input.convolve(kernel, dims);
-
-  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0, 0) + input(0, 1) * kernel(0, 1) + input(1, 0) * kernel(1, 0) +
-                                     input(1, 1) * kernel(1, 1));
-  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0, 0) + input(0, 2) * kernel(0, 1) + input(1, 1) * kernel(1, 0) +
-                                     input(1, 2) * kernel(1, 1));
-  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0, 0) + input(1, 1) * kernel(0, 1) + input(2, 0) * kernel(1, 0) +
-                                     input(2, 1) * kernel(1, 1));
-  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0, 0) + input(1, 2) * kernel(0, 1) + input(2, 1) * kernel(1, 0) +
-                                     input(2, 2) * kernel(1, 1));
-}
-
-template <int DataLayout>
-static void test_modes() {
-  Tensor<float, 1, DataLayout> input(3);
-  Tensor<float, 1, DataLayout> kernel(3);
-  input(0) = 1.0f;
-  input(1) = 2.0f;
-  input(2) = 3.0f;
-  kernel(0) = 0.5f;
-  kernel(1) = 1.0f;
-  kernel(2) = 0.0f;
-
-  Eigen::array<ptrdiff_t, 1> dims;
-  dims[0] = 0;
-  Eigen::array<std::pair<ptrdiff_t, ptrdiff_t>, 1> padding;
-
-  // Emulate VALID mode (as defined in
-  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
-  padding[0] = std::make_pair(0, 0);
-  Tensor<float, 1, DataLayout> valid(1);
-  valid = input.pad(padding).convolve(kernel, dims);
-  VERIFY_IS_EQUAL(valid.dimension(0), 1);
-  VERIFY_IS_APPROX(valid(0), 2.5f);
-
-  // Emulate SAME mode (as defined in
-  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
-  padding[0] = std::make_pair(1, 1);
-  Tensor<float, 1, DataLayout> same(3);
-  same = input.pad(padding).convolve(kernel, dims);
-  VERIFY_IS_EQUAL(same.dimension(0), 3);
-  VERIFY_IS_APPROX(same(0), 1.0f);
-  VERIFY_IS_APPROX(same(1), 2.5f);
-  VERIFY_IS_APPROX(same(2), 4.0f);
-
-  // Emulate FULL mode (as defined in
-  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
-  padding[0] = std::make_pair(2, 2);
-  Tensor<float, 1, DataLayout> full(5);
-  full = input.pad(padding).convolve(kernel, dims);
-  VERIFY_IS_EQUAL(full.dimension(0), 5);
-  VERIFY_IS_APPROX(full(0), 0.0f);
-  VERIFY_IS_APPROX(full(1), 1.0f);
-  VERIFY_IS_APPROX(full(2), 2.5f);
-  VERIFY_IS_APPROX(full(3), 4.0f);
-  VERIFY_IS_APPROX(full(4), 1.5f);
-}
-
-template <int DataLayout>
-static void test_strides() {
-  Tensor<float, 1, DataLayout> input(13);
-  Tensor<float, 1, DataLayout> kernel(3);
-  input.setRandom();
-  kernel.setRandom();
-
-  Eigen::array<ptrdiff_t, 1> dims;
-  dims[0] = 0;
-  Eigen::array<ptrdiff_t, 1> stride_of_3;
-  stride_of_3[0] = 3;
-  Eigen::array<ptrdiff_t, 1> stride_of_2;
-  stride_of_2[0] = 2;
-
-  Tensor<float, 1, DataLayout> result;
-  result = input.stride(stride_of_3).convolve(kernel, dims).stride(stride_of_2);
-
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_APPROX(result(0), (input(0) * kernel(0) + input(3) * kernel(1) + input(6) * kernel(2)));
-  VERIFY_IS_APPROX(result(1), (input(6) * kernel(0) + input(9) * kernel(1) + input(12) * kernel(2)));
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_convolution) {
-  CALL_SUBTEST(test_evals<ColMajor>());
-  CALL_SUBTEST(test_evals<RowMajor>());
-  CALL_SUBTEST(test_expr<ColMajor>());
-  CALL_SUBTEST(test_expr<RowMajor>());
-  CALL_SUBTEST(test_modes<ColMajor>());
-  CALL_SUBTEST(test_modes<RowMajor>());
-  CALL_SUBTEST(test_strides<ColMajor>());
-  CALL_SUBTEST(test_strides<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_convolution_sycl.cpp b/unsupported/test/cxx11_tensor_convolution_sycl.cpp
deleted file mode 100644
index 0d6358c..0000000
--- a/unsupported/test/cxx11_tensor_convolution_sycl.cpp
+++ /dev/null
@@ -1,458 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include <iostream>
-#include <chrono>
-#include <ctime>
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-#include <iomanip>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-static const float error_threshold = 1e-4f;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_larg_expr1D(const Eigen::SyclDevice& sycl_device) {
-  IndexType indim0 = 53;
-  IndexType indim1 = 55;
-  IndexType indim2 = 51;
-  IndexType outdim0 = 50;
-  IndexType outdim1 = 55;
-  IndexType outdim2 = 51;
-  Eigen::array<IndexType, 3> input_dims = {{indim0, indim1, indim2}};
-  Eigen::array<IndexType, 1> kernel_dims = {{4}};
-  Eigen::array<IndexType, 3> result_dims = {{outdim0, outdim1, outdim2}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> result(result_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> result_host(result_dims);
-
-  Eigen::array<IndexType, 1> dims3{{0}};
-
-  input.setRandom();
-  kernel.setRandom();
-  result.setZero();
-  result_host.setZero();
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t result_bytes = result.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_result(d_result, result_dims);
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
-  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
-
-  result_host = input.convolve(kernel, dims3);
-
-  for (IndexType i = 0; i < outdim0; i++) {
-    for (IndexType j = 0; j < outdim1; j++) {
-      for (IndexType k = 0; k < outdim2; k++) {
-        if (!(Eigen::internal::isApprox(result(i, j, k), result_host(i, j, k), error_threshold))) {
-          std::cout << std::setprecision(16) << "mismatch detected at index  ( " << i << " , " << j << ", " << k
-                    << " ) "
-                    << " \t " << result(i, j, k) << " vs " << result_host(i, j, k) << std::endl;
-          assert(false);
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(d_input);
-  sycl_device.deallocate(d_kernel);
-  sycl_device.deallocate(d_result);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_larg_expr2D(const Eigen::SyclDevice& sycl_device) {
-  IndexType indim0 = 53;
-  IndexType indim1 = 55;
-  IndexType indim2 = 51;
-  IndexType outdim0 = 50;
-  IndexType outdim1 = 51;
-  IndexType outdim2 = 51;
-  Eigen::array<IndexType, 3> input_dims = {{indim0, indim1, indim2}};
-  Eigen::array<IndexType, 2> kernel_dims = {{4, 5}};
-  Eigen::array<IndexType, 3> result_dims = {{outdim0, outdim1, outdim2}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> kernel(kernel_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> result(result_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> result_host(result_dims);
-
-  Eigen::array<IndexType, 2> dims3{{0, 1}};
-
-  input.setRandom();
-  kernel.setRandom();
-  result.setZero();
-  result_host.setZero();
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t result_bytes = result.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_result(d_result, result_dims);
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
-  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
-
-  result_host = input.convolve(kernel, dims3);
-
-  for (IndexType i = 0; i < outdim0; i++) {
-    for (IndexType j = 0; j < outdim1; j++) {
-      for (IndexType k = 0; k < outdim2; k++) {
-        if (!(Eigen::internal::isApprox(result(i, j, k), result_host(i, j, k), error_threshold))) {
-          std::cout << std::setprecision(16) << "mismatch detected at index  ( " << i << " , " << j << ", " << k
-                    << " ) "
-                    << " \t " << result(i, j, k) << " vs " << result_host(i, j, k) << std::endl;
-          assert(false);
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(d_input);
-  sycl_device.deallocate(d_kernel);
-  sycl_device.deallocate(d_result);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_larg_expr3D(const Eigen::SyclDevice& sycl_device) {
-  IndexType indim0 = 53;
-  IndexType indim1 = 55;
-  IndexType indim2 = 51;
-  IndexType outdim0 = 50;
-  IndexType outdim1 = 51;
-  IndexType outdim2 = 49;
-  Eigen::array<IndexType, 3> input_dims = {{indim0, indim1, indim2}};
-  Eigen::array<IndexType, 3> kernel_dims = {{4, 5, 3}};
-  Eigen::array<IndexType, 3> result_dims = {{outdim0, outdim1, outdim2}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> kernel(kernel_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> result(result_dims);
-  Tensor<DataType, 3, DataLayout, IndexType> result_host(result_dims);
-
-  Eigen::array<IndexType, 3> dims3{{0, 1, 2}};
-
-  input.setRandom();
-  kernel.setRandom();
-  result.setZero();
-  result_host.setZero();
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t result_bytes = result.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > gpu_result(d_result, result_dims);
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
-  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
-
-  result_host = input.convolve(kernel, dims3);
-
-  for (IndexType i = 0; i < outdim0; i++) {
-    for (IndexType j = 0; j < outdim1; j++) {
-      for (IndexType k = 0; k < outdim2; k++) {
-        if (!(Eigen::internal::isApprox(result(i, j, k), result_host(i, j, k), error_threshold))) {
-          std::cout << std::setprecision(16) << "mismatch detected at index  ( " << i << " , " << j << ", " << k
-                    << " ) "
-                    << " \t " << result(i, j, k) << " vs " << result_host(i, j, k) << std::endl;
-          assert(false);
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(d_input);
-  sycl_device.deallocate(d_kernel);
-  sycl_device.deallocate(d_result);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_evals(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 2> input_dims = {{3, 3}};
-  Eigen::array<IndexType, 1> kernel_dims = {{2}};
-  Eigen::array<IndexType, 2> result_dims = {{2, 3}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> result(result_dims);
-
-  Eigen::array<IndexType, 1> dims3{{0}};
-
-  input.setRandom();
-  kernel.setRandom();
-  result.setZero();
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t result_bytes = result.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_result(d_result, result_dims);
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims3);
-  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
-
-  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0) + input(1, 0) * kernel(1));  // index 0
-  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0) + input(1, 1) * kernel(1));  // index 2
-  VERIFY_IS_APPROX(result(0, 2), input(0, 2) * kernel(0) + input(1, 2) * kernel(1));  // index 4
-  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0) + input(2, 0) * kernel(1));  // index 1
-  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0) + input(2, 1) * kernel(1));  // index 3
-  VERIFY_IS_APPROX(result(1, 2), input(1, 2) * kernel(0) + input(2, 2) * kernel(1));  // index 5
-
-  sycl_device.deallocate(d_input);
-  sycl_device.deallocate(d_kernel);
-  sycl_device.deallocate(d_result);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_expr(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 2> input_dims = {{3, 3}};
-  Eigen::array<IndexType, 2> kernel_dims = {{2, 2}};
-  Eigen::array<IndexType, 2> result_dims = {{2, 2}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> kernel(kernel_dims);
-  Tensor<DataType, 2, DataLayout, IndexType> result(result_dims);
-
-  input.setRandom();
-  kernel.setRandom();
-  Eigen::array<IndexType, 2> dims;
-  dims[0] = 0;
-  dims[1] = 1;
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t result_bytes = result.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > gpu_result(d_result, result_dims);
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_result.device(sycl_device) = gpu_input.convolve(gpu_kernel, dims);
-  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
-
-  VERIFY_IS_APPROX(result(0, 0), input(0, 0) * kernel(0, 0) + input(0, 1) * kernel(0, 1) + input(1, 0) * kernel(1, 0) +
-                                     input(1, 1) * kernel(1, 1));
-  VERIFY_IS_APPROX(result(0, 1), input(0, 1) * kernel(0, 0) + input(0, 2) * kernel(0, 1) + input(1, 1) * kernel(1, 0) +
-                                     input(1, 2) * kernel(1, 1));
-  VERIFY_IS_APPROX(result(1, 0), input(1, 0) * kernel(0, 0) + input(1, 1) * kernel(0, 1) + input(2, 0) * kernel(1, 0) +
-                                     input(2, 1) * kernel(1, 1));
-  VERIFY_IS_APPROX(result(1, 1), input(1, 1) * kernel(0, 0) + input(1, 2) * kernel(0, 1) + input(2, 1) * kernel(1, 0) +
-                                     input(2, 2) * kernel(1, 1));
-
-  sycl_device.deallocate(d_input);
-  sycl_device.deallocate(d_kernel);
-  sycl_device.deallocate(d_result);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_modes(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 1> input_dims = {{3}};
-  Eigen::array<IndexType, 1> kernel_dims = {{3}};
-
-  Tensor<DataType, 1, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
-
-  input.setRandom();
-  kernel.setRandom();
-  Eigen::array<IndexType, 1> dims;
-  dims[0] = 0;
-
-  input(0) = 1.0f;
-  input(1) = 2.0f;
-  input(2) = 3.0f;
-  kernel(0) = 0.5f;
-  kernel(1) = 1.0f;
-  kernel(2) = 0.0f;
-
-  Eigen::array<std::pair<IndexType, IndexType>, 1> padding;
-
-  // Emulate VALID mode (as defined in
-  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
-  padding[0] = std::make_pair(0, 0);
-  Tensor<DataType, 1, DataLayout, IndexType> valid(1);
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t valid_bytes = valid.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_valid = static_cast<DataType*>(sycl_device.allocate(valid_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_valid(d_valid, valid.dimensions());
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_valid.device(sycl_device) = gpu_input.pad(padding).convolve(gpu_kernel, dims);
-  sycl_device.memcpyDeviceToHost(valid.data(), d_valid, valid_bytes);
-
-  VERIFY_IS_EQUAL(valid.dimension(0), 1);
-  VERIFY_IS_APPROX(valid(0), 2.5f);
-
-  // Emulate SAME mode (as defined in
-  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
-  padding[0] = std::make_pair(1, 1);
-  Tensor<DataType, 1, DataLayout, IndexType> same(3);
-  std::size_t same_bytes = same.size() * sizeof(DataType);
-  DataType* d_same = static_cast<DataType*>(sycl_device.allocate(same_bytes));
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_same(d_same, same.dimensions());
-  gpu_same.device(sycl_device) = gpu_input.pad(padding).convolve(gpu_kernel, dims);
-  sycl_device.memcpyDeviceToHost(same.data(), d_same, same_bytes);
-
-  VERIFY_IS_EQUAL(same.dimension(0), 3);
-  VERIFY_IS_APPROX(same(0), 1.0f);
-  VERIFY_IS_APPROX(same(1), 2.5f);
-  VERIFY_IS_APPROX(same(2), 4.0f);
-
-  // Emulate FULL mode (as defined in
-  // http://docs.scipy.org/doc/numpy/reference/generated/numpy.convolve.html).
-  padding[0] = std::make_pair(2, 2);
-
-  Tensor<DataType, 1, DataLayout, IndexType> full(5);
-  std::size_t full_bytes = full.size() * sizeof(DataType);
-  DataType* d_full = static_cast<DataType*>(sycl_device.allocate(full_bytes));
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_full(d_full, full.dimensions());
-  gpu_full.device(sycl_device) = gpu_input.pad(padding).convolve(gpu_kernel, dims);
-  sycl_device.memcpyDeviceToHost(full.data(), d_full, full_bytes);
-
-  VERIFY_IS_EQUAL(full.dimension(0), 5);
-  VERIFY_IS_APPROX(full(0), 0.0f);
-  VERIFY_IS_APPROX(full(1), 1.0f);
-  VERIFY_IS_APPROX(full(2), 2.5f);
-  VERIFY_IS_APPROX(full(3), 4.0f);
-  VERIFY_IS_APPROX(full(4), 1.5f);
-
-  sycl_device.deallocate(d_input);
-  sycl_device.deallocate(d_kernel);
-  sycl_device.deallocate(d_valid);
-  sycl_device.deallocate(d_same);
-  sycl_device.deallocate(d_full);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_strides(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 1> input_dims = {{13}};
-  Eigen::array<IndexType, 1> kernel_dims = {{3}};
-
-  Tensor<DataType, 1, DataLayout, IndexType> input(input_dims);
-  Tensor<DataType, 1, DataLayout, IndexType> kernel(kernel_dims);
-  Tensor<DataType, 1, DataLayout, IndexType> result(2);
-
-  input.setRandom();
-  kernel.setRandom();
-  Eigen::array<IndexType, 1> dims;
-  dims[0] = 0;
-
-  Eigen::array<IndexType, 1> stride_of_3;
-  stride_of_3[0] = 3;
-  Eigen::array<IndexType, 1> stride_of_2;
-  stride_of_2[0] = 2;
-
-  std::size_t input_bytes = input.size() * sizeof(DataType);
-  std::size_t kernel_bytes = kernel.size() * sizeof(DataType);
-  std::size_t result_bytes = result.size() * sizeof(DataType);
-
-  DataType* d_input = static_cast<DataType*>(sycl_device.allocate(input_bytes));
-  DataType* d_kernel = static_cast<DataType*>(sycl_device.allocate(kernel_bytes));
-  DataType* d_result = static_cast<DataType*>(sycl_device.allocate(result_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_input(d_input, input_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_kernel(d_kernel, kernel_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 1, DataLayout, IndexType> > gpu_result(d_result, result.dimensions());
-  sycl_device.memcpyHostToDevice(d_input, input.data(), input_bytes);
-  sycl_device.memcpyHostToDevice(d_kernel, kernel.data(), kernel_bytes);
-
-  gpu_result.device(sycl_device) = gpu_input.stride(stride_of_3).convolve(gpu_kernel, dims).stride(stride_of_2);
-  sycl_device.memcpyDeviceToHost(result.data(), d_result, result_bytes);
-
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_APPROX(result(0), (input(0) * kernel(0) + input(3) * kernel(1) + input(6) * kernel(2)));
-  VERIFY_IS_APPROX(result(1), (input(6) * kernel(0) + input(9) * kernel(1) + input(12) * kernel(2)));
-}
-
-template <typename Dev_selector>
-void tensorConvolutionPerDevice(Dev_selector& s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_larg_expr1D<float, RowMajor, int64_t>(sycl_device);
-  test_larg_expr1D<float, ColMajor, int64_t>(sycl_device);
-  test_larg_expr2D<float, RowMajor, int64_t>(sycl_device);
-  test_larg_expr2D<float, ColMajor, int64_t>(sycl_device);
-  test_larg_expr3D<float, RowMajor, int64_t>(sycl_device);
-  test_larg_expr3D<float, ColMajor, int64_t>(sycl_device);
-  test_evals<float, ColMajor, int64_t>(sycl_device);
-  test_evals<float, RowMajor, int64_t>(sycl_device);
-  test_expr<float, ColMajor, int64_t>(sycl_device);
-  test_expr<float, RowMajor, int64_t>(sycl_device);
-  test_modes<float, ColMajor, int64_t>(sycl_device);
-  test_modes<float, RowMajor, int64_t>(sycl_device);
-  test_strides<float, ColMajor, int64_t>(sycl_device);
-  test_strides<float, RowMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_convolution_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(tensorConvolutionPerDevice(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_custom_index.cpp b/unsupported/test/cxx11_tensor_custom_index.cpp
deleted file mode 100644
index 0c446df..0000000
--- a/unsupported/test/cxx11_tensor_custom_index.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <limits>
-#include <map>
-
-#include <Eigen/Dense>
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_map_as_index() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  using NormalIndex = DSizes<ptrdiff_t, 4>;
-  using CustomIndex = std::map<ptrdiff_t, ptrdiff_t>;
-  CustomIndex coeffC;
-  coeffC[0] = 1;
-  coeffC[1] = 2;
-  coeffC[2] = 4;
-  coeffC[3] = 1;
-  NormalIndex coeff(1, 2, 4, 1);
-
-  VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff));
-  VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff));
-}
-
-template <int DataLayout>
-static void test_matrix_as_index() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  using NormalIndex = DSizes<ptrdiff_t, 4>;
-  using CustomIndex = Matrix<unsigned int, 4, 1>;
-  CustomIndex coeffC(1, 2, 4, 1);
-  NormalIndex coeff(1, 2, 4, 1);
-
-  VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff));
-  VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff));
-}
-
-template <int DataLayout>
-static void test_varlist_as_index() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  DSizes<ptrdiff_t, 4> coeff(1, 2, 4, 1);
-
-  VERIFY_IS_EQUAL(tensor.coeff({1, 2, 4, 1}), tensor.coeff(coeff));
-  VERIFY_IS_EQUAL(tensor.coeffRef({1, 2, 4, 1}), tensor.coeffRef(coeff));
-}
-
-template <int DataLayout>
-static void test_sizes_as_index() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  DSizes<ptrdiff_t, 4> coeff(1, 2, 4, 1);
-  Sizes<1, 2, 4, 1> coeffC;
-
-  VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff));
-  VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff));
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_custom_index) {
-  test_map_as_index<ColMajor>();
-  test_map_as_index<RowMajor>();
-  test_matrix_as_index<ColMajor>();
-  test_matrix_as_index<RowMajor>();
-  test_varlist_as_index<ColMajor>();
-  test_varlist_as_index<RowMajor>();
-  test_sizes_as_index<ColMajor>();
-  test_sizes_as_index<RowMajor>();
-}
diff --git a/unsupported/test/cxx11_tensor_custom_op.cpp b/unsupported/test/cxx11_tensor_custom_op.cpp
deleted file mode 100644
index becdc21..0000000
--- a/unsupported/test/cxx11_tensor_custom_op.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-struct InsertZeros {
-  DSizes<DenseIndex, 2> dimensions(const Tensor<float, 2>& input) const {
-    DSizes<DenseIndex, 2> result;
-    result[0] = input.dimension(0) * 2;
-    result[1] = input.dimension(1) * 2;
-    return result;
-  }
-
-  template <typename Output, typename Device>
-  void eval(const Tensor<float, 2>& input, Output& output, const Device& device) const {
-    array<DenseIndex, 2> strides;
-    strides[0] = 2;
-    strides[1] = 2;
-    output.stride(strides).device(device) = input;
-
-    Eigen::DSizes<DenseIndex, 2> offsets(1, 1);
-    Eigen::DSizes<DenseIndex, 2> extents(output.dimension(0) - 1, output.dimension(1) - 1);
-    output.slice(offsets, extents).stride(strides).device(device) = input.constant(0.0f);
-  }
-};
-
-static void test_custom_unary_op() {
-  Tensor<float, 2> tensor(3, 5);
-  tensor.setRandom();
-
-  Tensor<float, 2> result = tensor.customOp(InsertZeros());
-  VERIFY_IS_EQUAL(result.dimension(0), 6);
-  VERIFY_IS_EQUAL(result.dimension(1), 10);
-
-  for (int i = 0; i < 6; i += 2) {
-    for (int j = 0; j < 10; j += 2) {
-      VERIFY_IS_EQUAL(result(i, j), tensor(i / 2, j / 2));
-    }
-  }
-  for (int i = 1; i < 6; i += 2) {
-    for (int j = 1; j < 10; j += 2) {
-      VERIFY_IS_EQUAL(result(i, j), 0);
-    }
-  }
-}
-
-struct BatchMatMul {
-  DSizes<DenseIndex, 3> dimensions(const Tensor<float, 3>& input1, const Tensor<float, 3>& input2) const {
-    DSizes<DenseIndex, 3> result;
-    result[0] = input1.dimension(0);
-    result[1] = input2.dimension(1);
-    result[2] = input2.dimension(2);
-    return result;
-  }
-
-  template <typename Output, typename Device>
-  void eval(const Tensor<float, 3>& input1, const Tensor<float, 3>& input2, Output& output,
-            const Device& device) const {
-    typedef Tensor<float, 3>::DimensionPair DimPair;
-    array<DimPair, 1> dims;
-    dims[0] = DimPair(1, 0);
-    for (int i = 0; i < output.dimension(2); ++i) {
-      output.template chip<2>(i).device(device) = input1.chip<2>(i).contract(input2.chip<2>(i), dims);
-    }
-  }
-};
-
-static void test_custom_binary_op() {
-  Tensor<float, 3> tensor1(2, 3, 5);
-  tensor1.setRandom();
-  Tensor<float, 3> tensor2(3, 7, 5);
-  tensor2.setRandom();
-
-  Tensor<float, 3> result = tensor1.customOp(tensor2, BatchMatMul());
-  for (int i = 0; i < 5; ++i) {
-    typedef Tensor<float, 3>::DimensionPair DimPair;
-    array<DimPair, 1> dims;
-    dims[0] = DimPair(1, 0);
-    Tensor<float, 2> reference = tensor1.chip<2>(i).contract(tensor2.chip<2>(i), dims);
-    TensorRef<Tensor<float, 2> > val = result.chip<2>(i);
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(val(j, k), reference(j, k));
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_custom_op) {
-  CALL_SUBTEST(test_custom_unary_op());
-  CALL_SUBTEST(test_custom_binary_op());
-}
diff --git a/unsupported/test/cxx11_tensor_custom_op_sycl.cpp b/unsupported/test/cxx11_tensor_custom_op_sycl.cpp
deleted file mode 100644
index a29b54a..0000000
--- a/unsupported/test/cxx11_tensor_custom_op_sycl.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-template <typename TensorType>
-struct InsertZeros {
-  DSizes<DenseIndex, 2> dimensions(const TensorType& input) const {
-    DSizes<DenseIndex, 2> result;
-    result[0] = input.dimension(0) * 2;
-    result[1] = input.dimension(1) * 2;
-    return result;
-  }
-
-  template <typename Output, typename Device>
-  void eval(const TensorType& input, Output& output, const Device& device) const {
-    array<DenseIndex, 2> strides;
-    strides[0] = 2;
-    strides[1] = 2;
-    output.stride(strides).device(device) = input;
-
-    Eigen::DSizes<DenseIndex, 2> offsets(1, 1);
-    Eigen::DSizes<DenseIndex, 2> extents(output.dimension(0) - 1, output.dimension(1) - 1);
-    output.slice(offsets, extents).stride(strides).device(device) = input.constant(0.0f);
-  }
-};
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_custom_unary_op_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 3;
-  IndexType sizeDim2 = 5;
-  Eigen::array<IndexType, 2> tensorRange = {{sizeDim1, sizeDim2}};
-  Eigen::array<IndexType, 2> tensorResultRange = {{6, 10}};
-
-  Eigen::Tensor<DataType, 2, DataLayout, IndexType> in1(tensorRange);
-  Eigen::Tensor<DataType, 2, DataLayout, IndexType> out(tensorResultRange);
-
-  DataType* gpu_in1_data =
-      static_cast<DataType*>(sycl_device.allocate(in1.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
-
-  typedef Eigen::TensorMap<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > TensorType;
-  TensorType gpu_in1(gpu_in1_data, tensorRange);
-  TensorType gpu_out(gpu_out_data, tensorResultRange);
-
-  in1.setRandom();
-  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.dimensions().TotalSize()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = gpu_in1.customOp(InsertZeros<TensorType>());
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(out.dimension(0), 6);
-  VERIFY_IS_EQUAL(out.dimension(1), 10);
-
-  for (int i = 0; i < 6; i += 2) {
-    for (int j = 0; j < 10; j += 2) {
-      VERIFY_IS_EQUAL(out(i, j), in1(i / 2, j / 2));
-    }
-  }
-  for (int i = 1; i < 6; i += 2) {
-    for (int j = 1; j < 10; j += 2) {
-      VERIFY_IS_EQUAL(out(i, j), 0);
-    }
-  }
-  sycl_device.deallocate(gpu_in1_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename TensorType>
-struct BatchMatMul {
-  DSizes<DenseIndex, 3> dimensions(const TensorType& input1, const TensorType& input2) const {
-    DSizes<DenseIndex, 3> result;
-    result[0] = input1.dimension(0);
-    result[1] = input2.dimension(1);
-    result[2] = input2.dimension(2);
-    return result;
-  }
-
-  template <typename Output, typename Device>
-  void eval(const TensorType& input1, const TensorType& input2, Output& output, const Device& device) const {
-    typedef typename TensorType::DimensionPair DimPair;
-    array<DimPair, 1> dims;
-    dims[0] = DimPair(1, 0);
-    for (int64_t i = 0; i < output.dimension(2); ++i) {
-      output.template chip<2>(i).device(device) = input1.template chip<2>(i).contract(input2.template chip<2>(i), dims);
-    }
-  }
-};
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_custom_binary_op_sycl(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 3> tensorRange1 = {{2, 3, 5}};
-  Eigen::array<IndexType, 3> tensorRange2 = {{3, 7, 5}};
-  Eigen::array<IndexType, 3> tensorResultRange = {{2, 7, 5}};
-
-  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange1);
-  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange2);
-  Eigen::Tensor<DataType, 3, DataLayout, IndexType> out(tensorResultRange);
-
-  DataType* gpu_in1_data =
-      static_cast<DataType*>(sycl_device.allocate(in1.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_in2_data =
-      static_cast<DataType*>(sycl_device.allocate(in2.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
-
-  typedef Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType> > TensorType;
-  TensorType gpu_in1(gpu_in1_data, tensorRange1);
-  TensorType gpu_in2(gpu_in2_data, tensorRange2);
-  TensorType gpu_out(gpu_out_data, tensorResultRange);
-
-  in1.setRandom();
-  in2.setRandom();
-
-  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.dimensions().TotalSize()) * sizeof(DataType));
-
-  gpu_out.device(sycl_device) = gpu_in1.customOp(gpu_in2, BatchMatMul<TensorType>());
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < 5; ++i) {
-    typedef typename Eigen::Tensor<DataType, 3, DataLayout, IndexType>::DimensionPair DimPair;
-    array<DimPair, 1> dims;
-    dims[0] = DimPair(1, 0);
-    Eigen::Tensor<DataType, 2, DataLayout, IndexType> reference =
-        in1.template chip<2>(i).contract(in2.template chip<2>(i), dims);
-    TensorRef<Eigen::Tensor<DataType, 2, DataLayout, IndexType> > val = out.template chip<2>(i);
-    for (IndexType j = 0; j < 2; ++j) {
-      for (IndexType k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(val(j, k), reference(j, k));
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_in1_data);
-  sycl_device.deallocate(gpu_in2_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, typename Dev_selector>
-void custom_op_perDevice(Dev_selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_custom_unary_op_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_custom_unary_op_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_custom_binary_op_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_custom_binary_op_sycl<DataType, RowMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_custom_op_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(custom_op_perDevice<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_device.cu b/unsupported/test/cxx11_tensor_device.cu
deleted file mode 100644
index 7ba7288..0000000
--- a/unsupported/test/cxx11_tensor_device.cu
+++ /dev/null
@@ -1,436 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include "OffByOneScalar.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-// Context for evaluation on cpu
-struct CPUContext {
-  CPUContext(const Eigen::Tensor<float, 3>& in1, Eigen::Tensor<float, 3>& in2, Eigen::Tensor<float, 3>& out)
-      : in1_(in1), in2_(in2), out_(out), kernel_1d_(2), kernel_2d_(2, 2), kernel_3d_(2, 2, 2) {
-    kernel_1d_(0) = 3.14f;
-    kernel_1d_(1) = 2.7f;
-
-    kernel_2d_(0, 0) = 3.14f;
-    kernel_2d_(1, 0) = 2.7f;
-    kernel_2d_(0, 1) = 0.2f;
-    kernel_2d_(1, 1) = 7.0f;
-
-    kernel_3d_(0, 0, 0) = 3.14f;
-    kernel_3d_(0, 1, 0) = 2.7f;
-    kernel_3d_(0, 0, 1) = 0.2f;
-    kernel_3d_(0, 1, 1) = 7.0f;
-    kernel_3d_(1, 0, 0) = -1.0f;
-    kernel_3d_(1, 1, 0) = -0.3f;
-    kernel_3d_(1, 0, 1) = -0.7f;
-    kernel_3d_(1, 1, 1) = -0.5f;
-  }
-
-  const Eigen::DefaultDevice& device() const { return cpu_device_; }
-
-  const Eigen::Tensor<float, 3>& in1() const { return in1_; }
-  const Eigen::Tensor<float, 3>& in2() const { return in2_; }
-  Eigen::Tensor<float, 3>& out() { return out_; }
-  const Eigen::Tensor<float, 1>& kernel1d() const { return kernel_1d_; }
-  const Eigen::Tensor<float, 2>& kernel2d() const { return kernel_2d_; }
-  const Eigen::Tensor<float, 3>& kernel3d() const { return kernel_3d_; }
-
- private:
-  const Eigen::Tensor<float, 3>& in1_;
-  const Eigen::Tensor<float, 3>& in2_;
-  Eigen::Tensor<float, 3>& out_;
-
-  Eigen::Tensor<float, 1> kernel_1d_;
-  Eigen::Tensor<float, 2> kernel_2d_;
-  Eigen::Tensor<float, 3> kernel_3d_;
-
-  Eigen::DefaultDevice cpu_device_;
-};
-
-// Context for evaluation on GPU
-struct GPUContext {
-  GPUContext(const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in1, Eigen::TensorMap<Eigen::Tensor<float, 3>>& in2,
-             Eigen::TensorMap<Eigen::Tensor<float, 3>>& out)
-      : in1_(in1), in2_(in2), out_(out), gpu_device_(&stream_) {
-    assert(gpuMalloc((void**)(&kernel_1d_), 2 * sizeof(float)) == gpuSuccess);
-    float kernel_1d_val[] = {3.14f, 2.7f};
-    assert(gpuMemcpy(kernel_1d_, kernel_1d_val, 2 * sizeof(float), gpuMemcpyHostToDevice) == gpuSuccess);
-
-    assert(gpuMalloc((void**)(&kernel_2d_), 4 * sizeof(float)) == gpuSuccess);
-    float kernel_2d_val[] = {3.14f, 2.7f, 0.2f, 7.0f};
-    assert(gpuMemcpy(kernel_2d_, kernel_2d_val, 4 * sizeof(float), gpuMemcpyHostToDevice) == gpuSuccess);
-
-    assert(gpuMalloc((void**)(&kernel_3d_), 8 * sizeof(float)) == gpuSuccess);
-    float kernel_3d_val[] = {3.14f, -1.0f, 2.7f, -0.3f, 0.2f, -0.7f, 7.0f, -0.5f};
-    assert(gpuMemcpy(kernel_3d_, kernel_3d_val, 8 * sizeof(float), gpuMemcpyHostToDevice) == gpuSuccess);
-  }
-  ~GPUContext() {
-    assert(gpuFree(kernel_1d_) == gpuSuccess);
-    assert(gpuFree(kernel_2d_) == gpuSuccess);
-    assert(gpuFree(kernel_3d_) == gpuSuccess);
-  }
-
-  const Eigen::GpuDevice& device() const { return gpu_device_; }
-
-  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in1() const { return in1_; }
-  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in2() const { return in2_; }
-  Eigen::TensorMap<Eigen::Tensor<float, 3>>& out() { return out_; }
-  Eigen::TensorMap<Eigen::Tensor<float, 1>> kernel1d() const {
-    return Eigen::TensorMap<Eigen::Tensor<float, 1>>(kernel_1d_, 2);
-  }
-  Eigen::TensorMap<Eigen::Tensor<float, 2>> kernel2d() const {
-    return Eigen::TensorMap<Eigen::Tensor<float, 2>>(kernel_2d_, 2, 2);
-  }
-  Eigen::TensorMap<Eigen::Tensor<float, 3>> kernel3d() const {
-    return Eigen::TensorMap<Eigen::Tensor<float, 3>>(kernel_3d_, 2, 2, 2);
-  }
-
- private:
-  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in1_;
-  const Eigen::TensorMap<Eigen::Tensor<float, 3>>& in2_;
-  Eigen::TensorMap<Eigen::Tensor<float, 3>>& out_;
-
-  float* kernel_1d_;
-  float* kernel_2d_;
-  float* kernel_3d_;
-
-  Eigen::GpuStreamDevice stream_;
-  Eigen::GpuDevice gpu_device_;
-};
-
-// The actual expression to evaluate
-template <typename Context>
-void test_contextual_eval(Context* context) {
-  context->out().device(context->device()) = context->in1() + context->in2() * 3.14f + context->in1().constant(2.718f);
-}
-
-template <typename Context>
-void test_forced_contextual_eval(Context* context) {
-  context->out().device(context->device()) =
-      (context->in1() + context->in2()).eval() * 3.14f + context->in1().constant(2.718f);
-}
-
-template <typename Context>
-void test_compound_assignment(Context* context) {
-  context->out().device(context->device()) = context->in1().constant(2.718f);
-  context->out().device(context->device()) += context->in1() + context->in2() * 3.14f;
-}
-
-template <typename Context>
-void test_contraction(Context* context) {
-  Eigen::array<std::pair<int, int>, 2> dims;
-  dims[0] = std::make_pair(1, 1);
-  dims[1] = std::make_pair(2, 2);
-
-  Eigen::array<int, 2> shape{40, 50 * 70};
-
-  Eigen::DSizes<int, 2> indices(0, 0);
-  Eigen::DSizes<int, 2> sizes(40, 40);
-
-  context->out().reshape(shape).slice(indices, sizes).device(context->device()) =
-      context->in1().contract(context->in2(), dims);
-}
-
-template <typename Context>
-void test_1d_convolution(Context* context) {
-  Eigen::DSizes<int, 3> indices(0, 0, 0);
-  Eigen::DSizes<int, 3> sizes(40, 49, 70);
-
-  Eigen::array<int, 1> dims{1};
-  context->out().slice(indices, sizes).device(context->device()) = context->in1().convolve(context->kernel1d(), dims);
-}
-
-template <typename Context>
-void test_2d_convolution(Context* context) {
-  Eigen::DSizes<int, 3> indices(0, 0, 0);
-  Eigen::DSizes<int, 3> sizes(40, 49, 69);
-
-  Eigen::array<int, 2> dims{1, 2};
-  context->out().slice(indices, sizes).device(context->device()) = context->in1().convolve(context->kernel2d(), dims);
-}
-
-template <typename Context>
-void test_3d_convolution(Context* context) {
-  Eigen::DSizes<int, 3> indices(0, 0, 0);
-  Eigen::DSizes<int, 3> sizes(39, 49, 69);
-
-  Eigen::array<int, 3> dims{0, 1, 2};
-  context->out().slice(indices, sizes).device(context->device()) = context->in1().convolve(context->kernel3d(), dims);
-}
-
-// Helper method to synchronize device.
-template <typename Device>
-void synchronize(Device& /*device*/) { /*nothing*/
-}
-template <>
-void synchronize(Eigen::GpuDevice& device) {
-  device.synchronize();
-}
-
-template <typename DataType, typename TensorDevice>
-void test_device_memory(const TensorDevice& device) {
-  int count = 100;
-  Eigen::array<int, 1> tensorRange{count};
-  Eigen::Tensor<DataType, 1> host(tensorRange);
-  Eigen::Tensor<DataType, 1> expected(tensorRange);
-  DataType* device_data = static_cast<DataType*>(device.allocate(count * sizeof(DataType)));
-
-  // memset
-  const char byte_value = static_cast<char>(0xAB);
-  device.memset(device_data, byte_value, count * sizeof(DataType));
-  device.memcpyDeviceToHost(host.data(), device_data, count * sizeof(DataType));
-  synchronize(device);
-  memset(expected.data(), byte_value, count * sizeof(DataType));
-  for (Index i = 0; i < count; i++) {
-    VERIFY_IS_EQUAL(host(i), expected(i));
-  }
-
-  // fill
-  DataType fill_value = DataType(7);
-  std::fill_n(expected.data(), count, fill_value);
-  device.fill(device_data, device_data + count, fill_value);
-  device.memcpyDeviceToHost(host.data(), device_data, count * sizeof(DataType));
-  synchronize(device);
-  for (int i = 0; i < count; i++) {
-    VERIFY_IS_EQUAL(host(i), expected(i));
-  }
-
-  device.deallocate(device_data);
-}
-
-void test_cpu() {
-  Eigen::Tensor<float, 3> in1(40, 50, 70);
-  Eigen::Tensor<float, 3> in2(40, 50, 70);
-  Eigen::Tensor<float, 3> out(40, 50, 70);
-
-  in1 = in1.random() + in1.constant(10.0f);
-  in2 = in2.random() + in2.constant(10.0f);
-
-  CPUContext context(in1, in2, out);
-  test_contextual_eval(&context);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
-      }
-    }
-  }
-
-  test_forced_contextual_eval(&context);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) + in2(i, j, k)) * 3.14f + 2.718f);
-      }
-    }
-  }
-
-  test_compound_assignment(&context);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
-      }
-    }
-  }
-
-  test_contraction(&context);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 40; ++j) {
-      const float result = out(i, j, 0);
-      float expected = 0;
-      for (int k = 0; k < 50; ++k) {
-        for (int l = 0; l < 70; ++l) {
-          expected += in1(i, k, l) * in2(j, k, l);
-        }
-      }
-      VERIFY_IS_APPROX(expected, result);
-    }
-  }
-
-  test_1d_convolution(&context);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 49; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f));
-      }
-    }
-  }
-
-  test_2d_convolution(&context);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 49; ++j) {
-      for (int k = 0; k < 69; ++k) {
-        const float result = out(i, j, k);
-        const float expected =
-            (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f) + (in1(i, j, k + 1) * 0.2f + in1(i, j + 1, k + 1) * 7.0f);
-        if (fabs(expected) < 1e-4f && fabs(result) < 1e-4f) {
-          continue;
-        }
-        VERIFY_IS_APPROX(expected, result);
-      }
-    }
-  }
-
-  test_3d_convolution(&context);
-  for (int i = 0; i < 39; ++i) {
-    for (int j = 0; j < 49; ++j) {
-      for (int k = 0; k < 69; ++k) {
-        const float result = out(i, j, k);
-        const float expected =
-            (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f + in1(i, j, k + 1) * 0.2f + in1(i, j + 1, k + 1) * 7.0f) +
-            (in1(i + 1, j, k) * -1.0f + in1(i + 1, j + 1, k) * -0.3f + in1(i + 1, j, k + 1) * -0.7f +
-             in1(i + 1, j + 1, k + 1) * -0.5f);
-        if (fabs(expected) < 1e-4f && fabs(result) < 1e-4f) {
-          continue;
-        }
-        VERIFY_IS_APPROX(expected, result);
-      }
-    }
-  }
-
-  test_device_memory<float>(context.device());
-  test_device_memory<OffByOneScalar<int>>(context.device());
-}
-
-void test_gpu() {
-  Eigen::Tensor<float, 3> in1(40, 50, 70);
-  Eigen::Tensor<float, 3> in2(40, 50, 70);
-  Eigen::Tensor<float, 3> out(40, 50, 70);
-  in1 = in1.random() + in1.constant(10.0f);
-  in2 = in2.random() + in2.constant(10.0f);
-
-  std::size_t in1_bytes = in1.size() * sizeof(float);
-  std::size_t in2_bytes = in2.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_in1;
-  float* d_in2;
-  float* d_out;
-  gpuMalloc((void**)(&d_in1), in1_bytes);
-  gpuMalloc((void**)(&d_in2), in2_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in2, in2.data(), in2_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 3>> gpu_in1(d_in1, 40, 50, 70);
-  Eigen::TensorMap<Eigen::Tensor<float, 3>> gpu_in2(d_in2, 40, 50, 70);
-  Eigen::TensorMap<Eigen::Tensor<float, 3>> gpu_out(d_out, 40, 50, 70);
-
-  GPUContext context(gpu_in1, gpu_in2, gpu_out);
-  test_contextual_eval(&context);
-  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
-      }
-    }
-  }
-
-  test_forced_contextual_eval(&context);
-  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) + in2(i, j, k)) * 3.14f + 2.718f);
-      }
-    }
-  }
-
-  test_compound_assignment(&context);
-  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 50; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f + 2.718f);
-      }
-    }
-  }
-
-  test_contraction(&context);
-  assert(gpuMemcpy(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost) == gpuSuccess);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 40; ++j) {
-      const float result = out(i, j, 0);
-      float expected = 0;
-      for (int k = 0; k < 50; ++k) {
-        for (int l = 0; l < 70; ++l) {
-          expected += in1(i, k, l) * in2(j, k, l);
-        }
-      }
-      VERIFY_IS_APPROX(expected, result);
-    }
-  }
-
-  test_1d_convolution(&context);
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, context.device().stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(context.device().stream()) == gpuSuccess);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 49; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f));
-      }
-    }
-  }
-
-  test_2d_convolution(&context);
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, context.device().stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(context.device().stream()) == gpuSuccess);
-  for (int i = 0; i < 40; ++i) {
-    for (int j = 0; j < 49; ++j) {
-      for (int k = 0; k < 69; ++k) {
-        const float result = out(i, j, k);
-        const float expected =
-            (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f + in1(i, j, k + 1) * 0.2f + in1(i, j + 1, k + 1) * 7.0f);
-        VERIFY_IS_APPROX(expected, result);
-      }
-    }
-  }
-
-#if !defined(EIGEN_USE_HIP)
-  // disable this test on the HIP platform
-  // 3D tensor convolutions seem to hang on the HIP platform
-
-  test_3d_convolution(&context);
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, context.device().stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(context.device().stream()) == gpuSuccess);
-  for (int i = 0; i < 39; ++i) {
-    for (int j = 0; j < 49; ++j) {
-      for (int k = 0; k < 69; ++k) {
-        const float result = out(i, j, k);
-        const float expected = (in1(i, j, k) * 3.14f + in1(i, j + 1, k) * 2.7f + in1(i, j, k + 1) * 0.2f +
-                                in1(i, j + 1, k + 1) * 7.0f + in1(i + 1, j, k) * -1.0f + in1(i + 1, j + 1, k) * -0.3f +
-                                in1(i + 1, j, k + 1) * -0.7f + in1(i + 1, j + 1, k + 1) * -0.5f);
-        VERIFY_IS_APPROX(expected, result);
-      }
-    }
-  }
-
-#endif
-
-  test_device_memory<float>(context.device());
-  test_device_memory<OffByOneScalar<int>>(context.device());
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_device) {
-  CALL_SUBTEST_1(test_cpu());
-  CALL_SUBTEST_2(test_gpu());
-}
diff --git a/unsupported/test/cxx11_tensor_device_sycl.cpp b/unsupported/test/cxx11_tensor_device_sycl.cpp
deleted file mode 100644
index 9640ed4..0000000
--- a/unsupported/test/cxx11_tensor_device_sycl.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include "OffByOneScalar.h"
-#include <unsupported/Eigen/Tensor>
-#include <stdint.h>
-#include <iostream>
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_device_memory(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 100;
-  array<IndexType, 1> tensorRange = {{sizeDim1}};
-  Tensor<DataType, 1, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 1, DataLayout, IndexType> in1(tensorRange);
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
-
-  // memset
-  memset(in1.data(), 1, in1.size() * sizeof(DataType));
-  sycl_device.memset(gpu_in_data, 1, in.size() * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(in.data(), gpu_in_data, in.size() * sizeof(DataType));
-  for (IndexType i = 0; i < in.size(); i++) {
-    VERIFY_IS_EQUAL(in(i), in1(i));
-  }
-
-  // fill
-  DataType value = DataType(7);
-  std::fill_n(in1.data(), in1.size(), value);
-  sycl_device.fill(gpu_in_data, gpu_in_data + in.size(), value);
-  sycl_device.memcpyDeviceToHost(in.data(), gpu_in_data, in.size() * sizeof(DataType));
-  for (IndexType i = 0; i < in.size(); i++) {
-    VERIFY_IS_EQUAL(in(i), in1(i));
-  }
-
-  sycl_device.deallocate(gpu_in_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_device_exceptions(const Eigen::SyclDevice& sycl_device) {
-  VERIFY(sycl_device.ok());
-  IndexType sizeDim1 = 100;
-  array<IndexType, 1> tensorDims = {{sizeDim1}};
-  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(sizeDim1 * sizeof(DataType)));
-  sycl_device.memset(gpu_data, 1, sizeDim1 * sizeof(DataType));
-
-  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> in(gpu_data, tensorDims);
-  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> out(gpu_data, tensorDims);
-  out.device(sycl_device) = in / in.constant(0);
-
-  sycl_device.synchronize();
-  VERIFY(!sycl_device.ok());
-  sycl_device.deallocate(gpu_data);
-}
-
-template <typename DataType>
-void sycl_device_test_per_device(const cl::sycl::device& d) {
-  std::cout << "Running on " << d.template get_info<cl::sycl::info::device::name>() << std::endl;
-  QueueInterface queueInterface(d);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_device_memory<DataType, RowMajor, int64_t>(sycl_device);
-  test_device_memory<DataType, ColMajor, int64_t>(sycl_device);
-  /// this test throw an exception. enable it if you want to see the exception
-  // test_device_exceptions<DataType, RowMajor>(sycl_device);
-  /// this test throw an exception. enable it if you want to see the exception
-  // test_device_exceptions<DataType, ColMajor>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_device_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_device_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_device_test_per_device<float>(device));
-    CALL_SUBTEST(sycl_device_test_per_device<OffByOneScalar<int>>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_dimension.cpp b/unsupported/test/cxx11_tensor_dimension.cpp
deleted file mode 100644
index 0458373..0000000
--- a/unsupported/test/cxx11_tensor_dimension.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-static void test_dynamic_size() {
-  Eigen::DSizes<int, 3> dimensions(2, 3, 7);
-
-  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<0>(dimensions), 2);
-  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<1>(dimensions), 3);
-  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<2>(dimensions), 7);
-  VERIFY_IS_EQUAL((int)dimensions.TotalSize(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL((int)dimensions[0], 2);
-  VERIFY_IS_EQUAL((int)dimensions[1], 3);
-  VERIFY_IS_EQUAL((int)dimensions[2], 7);
-}
-
-static void test_fixed_size() {
-  Eigen::Sizes<2, 3, 7> dimensions;
-
-  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<0>(dimensions), 2);
-  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<1>(dimensions), 3);
-  VERIFY_IS_EQUAL((int)Eigen::internal::array_get<2>(dimensions), 7);
-  VERIFY_IS_EQUAL((int)dimensions.TotalSize(), 2 * 3 * 7);
-}
-
-static void test_match() {
-  Eigen::DSizes<unsigned int, 3> dyn((unsigned int)2, (unsigned int)3, (unsigned int)7);
-  Eigen::Sizes<2, 3, 7> stat;
-  VERIFY_IS_EQUAL(Eigen::dimensions_match(dyn, stat), true);
-
-  Eigen::DSizes<int, 3> dyn1(2, 3, 7);
-  Eigen::DSizes<int, 2> dyn2(2, 3);
-  VERIFY_IS_EQUAL(Eigen::dimensions_match(dyn1, dyn2), false);
-}
-
-static void test_rank_zero() {
-  Eigen::Sizes<> scalar;
-  VERIFY_IS_EQUAL((int)scalar.TotalSize(), 1);
-  VERIFY_IS_EQUAL((int)scalar.rank(), 0);
-  VERIFY_IS_EQUAL((int)internal::array_prod(scalar), 1);
-
-  Eigen::DSizes<ptrdiff_t, 0> dscalar;
-  VERIFY_IS_EQUAL((int)dscalar.TotalSize(), 1);
-  VERIFY_IS_EQUAL((int)dscalar.rank(), 0);
-}
-
-static void test_index_type_promotion() {
-  Eigen::DSizes<int, 3> src0(1, 2, 3);
-  Eigen::array<int, 3> src1;
-  src1[0] = 4;
-  src1[1] = 5;
-  src1[2] = 6;
-
-  Eigen::DSizes<long, 3> dst0(src0);
-  Eigen::DSizes<long, 3> dst1(src1);
-
-  VERIFY_IS_EQUAL(dst0[0], 1L);
-  VERIFY_IS_EQUAL(dst0[1], 2L);
-  VERIFY_IS_EQUAL(dst0[2], 3L);
-  VERIFY_IS_EQUAL(dst1[0], 4L);
-  VERIFY_IS_EQUAL(dst1[1], 5L);
-  VERIFY_IS_EQUAL(dst1[2], 6L);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_dimension) {
-  CALL_SUBTEST(test_dynamic_size());
-  CALL_SUBTEST(test_fixed_size());
-  CALL_SUBTEST(test_match());
-  CALL_SUBTEST(test_rank_zero());
-  CALL_SUBTEST(test_index_type_promotion());
-}
diff --git a/unsupported/test/cxx11_tensor_empty.cpp b/unsupported/test/cxx11_tensor_empty.cpp
deleted file mode 100644
index a688b4d..0000000
--- a/unsupported/test/cxx11_tensor_empty.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-static void test_empty_tensor() {
-  Tensor<float, 2> source;
-  Tensor<float, 2> tgt1 = source;
-  Tensor<float, 2> tgt2(source);
-  Tensor<float, 2> tgt3;
-  tgt3 = tgt1;
-  tgt3 = tgt2;
-}
-
-static void test_empty_fixed_size_tensor() {
-  TensorFixedSize<float, Sizes<0> > source;
-  TensorFixedSize<float, Sizes<0> > tgt1 = source;
-  TensorFixedSize<float, Sizes<0> > tgt2(source);
-  TensorFixedSize<float, Sizes<0> > tgt3;
-  tgt3 = tgt1;
-  tgt3 = tgt2;
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_empty) {
-  CALL_SUBTEST(test_empty_tensor());
-  CALL_SUBTEST(test_empty_fixed_size_tensor());
-}
diff --git a/unsupported/test/cxx11_tensor_executor.cpp b/unsupported/test/cxx11_tensor_executor.cpp
deleted file mode 100644
index 33748c6..0000000
--- a/unsupported/test/cxx11_tensor_executor.cpp
+++ /dev/null
@@ -1,704 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2018 Eugene Zhulenev <ezhulenev@google.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_USE_THREADS
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::ColMajor;
-using Eigen::RowMajor;
-using Eigen::Tensor;
-using Eigen::internal::TiledEvaluation;
-
-// A set of tests to verify that different TensorExecutor strategies yields the
-// same results for all the ops, supporting tiled evaluation.
-
-// Default assignment that does no use block evaluation or vectorization.
-// We assume that default coefficient evaluation is well tested and correct.
-template <typename Dst, typename Expr>
-void DefaultAssign(Dst& dst, Expr expr) {
-  using Assign = Eigen::TensorAssignOp<Dst, const Expr>;
-  using Executor = Eigen::internal::TensorExecutor<const Assign, DefaultDevice,
-                                                   /*Vectorizable=*/false,
-                                                   /*Tiling=*/TiledEvaluation::Off>;
-
-  Executor::run(Assign(dst, expr), DefaultDevice());
-}
-
-// Assignment with specified device and tiling strategy.
-template <bool Vectorizable, TiledEvaluation Tiling, typename Device, typename Dst, typename Expr>
-void DeviceAssign(Device& d, Dst& dst, Expr expr) {
-  using Assign = Eigen::TensorAssignOp<Dst, const Expr>;
-  using Executor = Eigen::internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-}
-
-template <int NumDims>
-static array<Index, NumDims> RandomDims(int min_dim = 1, int max_dim = 20) {
-  array<Index, NumDims> dims;
-  for (int i = 0; i < NumDims; ++i) {
-    dims[i] = internal::random<int>(min_dim, max_dim);
-  }
-  return dims;
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_unary_expr(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  // Pick a large enough tensor size to bypass small tensor block evaluation
-  // optimization.
-  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
-
-  Tensor<T, NumDims, Options, Index> src(dims);
-  Tensor<T, NumDims, Options, Index> dst(dims);
-
-  src.setRandom();
-  const auto expr = src.square();
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    T square = src.coeff(i) * src.coeff(i);
-    VERIFY_IS_EQUAL(square, dst.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_binary_expr(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  // Pick a large enough tensor size to bypass small tensor block evaluation
-  // optimization.
-  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
-
-  Tensor<T, NumDims, Options, Index> lhs(dims);
-  Tensor<T, NumDims, Options, Index> rhs(dims);
-  Tensor<T, NumDims, Options, Index> dst(dims);
-
-  lhs.setRandom();
-  rhs.setRandom();
-
-  const auto expr = lhs + rhs;
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    T sum = lhs.coeff(i) + rhs.coeff(i);
-    VERIFY_IS_EQUAL(sum, dst.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_broadcasting(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(1, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  const auto broadcasts = RandomDims<NumDims>(1, 7);
-  const auto expr = src.broadcast(broadcasts);
-
-  // We assume that broadcasting on a default device is tested and correct, so
-  // we can rely on it to verify correctness of tensor executor and tiling.
-  Tensor<T, NumDims, Options, Index> golden;
-  golden = expr;
-
-  // Now do the broadcasting using configured tensor executor.
-  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-struct test_execute_chipping_rvalue_runner {
-  template <int ChipDim>
-  static std::enable_if_t<0 <= ChipDim, void> run_dim(Device& d, const array<Index, NumDims>& dims,
-                                                      const Tensor<T, NumDims, Layout, Index>& src) {
-    const auto offset = internal::random<Index>(0, dims[(ChipDim)] - 1);
-    const auto expr = src.template chip<ChipDim>(offset);
-
-    Tensor<T, NumDims - 1, Layout, Index> golden;
-    golden = expr;
-
-    Tensor<T, NumDims - 1, Layout, Index> dst(golden.dimensions());
-
-    using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-    using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-    Executor::run(Assign(dst, expr), d);
-
-    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-    }
-
-    // Recursively reduce chip dimension.
-    run_dim<ChipDim - 1>(d, dims, src);
-  }
-
-  template <int ChipDim>
-      static std::enable_if_t <
-      ChipDim<0, void> run_dim(Device&, const array<Index, NumDims>&, const Tensor<T, NumDims, Layout, Index>&) {}
-
-  static void run(Device d) {
-    auto dims = RandomDims<NumDims>(1, 10);
-    Tensor<T, NumDims, Layout, Index> src(dims);
-    src.setRandom();
-    run_dim<NumDims - 1>(d, dims, src);
-  }
-};
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_chipping_rvalue(Device d) {
-  test_execute_chipping_rvalue_runner<T, NumDims, Device, Vectorizable, Tiling, Layout>::run(d);
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-struct test_execute_chipping_lvalue_runner {
-  template <int ChipDim>
-  static std::enable_if_t<0 <= ChipDim> run_dim(Device& d, const array<Index, NumDims>& dims) {
-    /* Generate random data that we'll assign to the chipped tensor dim. */
-    array<Index, NumDims - 1> src_dims;
-    for (int i = 0; i < NumDims - 1; ++i) {
-      int dim = i < (ChipDim) ? i : i + 1;
-      src_dims[i] = dims[dim];
-    }
-
-    Tensor<T, NumDims - 1, Layout, Index> src(src_dims);
-    src.setRandom();
-
-    const auto offset = internal::random<Index>(0, dims[(ChipDim)] - 1);
-
-    Tensor<T, NumDims, Layout, Index> random(dims);
-    random.setZero();
-
-    Tensor<T, NumDims, Layout, Index> golden(dims);
-    golden = random;
-    golden.template chip<(ChipDim)>(offset) = src;
-
-    Tensor<T, NumDims, Layout, Index> dst(dims);
-    dst = random;
-    auto expr = dst.template chip<(ChipDim)>(offset);
-
-    using Assign = TensorAssignOp<decltype(expr), const decltype(src)>;
-    using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-    Executor::run(Assign(expr, src), d);
-
-    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-    }
-
-    run_dim<ChipDim - 1>(d, dims);
-  }
-
-  template <int ChipDim>
-      static std::enable_if_t < ChipDim<0, void> run_dim(Device&, const array<Index, NumDims>&) {}
-
-  static void run(Device d) {
-    auto dims = RandomDims<NumDims>(1, 10);
-    run_dim<NumDims - 1>(d, dims);
-  }
-};
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_chipping_lvalue(Device d) {
-  test_execute_chipping_lvalue_runner<T, NumDims, Device, Vectorizable, Tiling, Layout>::run(d);
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_shuffle_rvalue(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(1, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  DSizes<Index, NumDims> shuffle;
-  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
-
-  // Test all possible shuffle permutations.
-  do {
-    DSizes<Index, NumDims> shuffled_dims;
-    for (int i = 0; i < NumDims; ++i) {
-      shuffled_dims[i] = dims[shuffle[i]];
-    }
-
-    const auto expr = src.shuffle(shuffle);
-
-    // We assume that shuffling on a default device is tested and correct, so
-    // we can rely on it to verify correctness of tensor executor and tiling.
-    Tensor<T, NumDims, Options, Index> golden(shuffled_dims);
-    DefaultAssign(golden, expr);
-
-    // Now do the shuffling using configured tensor executor.
-    Tensor<T, NumDims, Options, Index> dst(shuffled_dims);
-    DeviceAssign<Vectorizable, Tiling>(d, dst, expr);
-
-    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-    }
-
-  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_shuffle_lvalue(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(5, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  DSizes<Index, NumDims> shuffle;
-  for (int i = 0; i < NumDims; ++i) shuffle[i] = i;
-
-  // Test all possible shuffle permutations.
-  do {
-    DSizes<Index, NumDims> shuffled_dims;
-    for (int i = 0; i < NumDims; ++i) shuffled_dims[shuffle[i]] = dims[i];
-
-    // We assume that shuffling on a default device is tested and correct, so
-    // we can rely on it to verify correctness of tensor executor and tiling.
-    Tensor<T, NumDims, Options, Index> golden(shuffled_dims);
-    auto golden_shuffle = golden.shuffle(shuffle);
-    DefaultAssign(golden_shuffle, src);
-
-    // Now do the shuffling using configured tensor executor.
-    Tensor<T, NumDims, Options, Index> dst(shuffled_dims);
-    auto dst_shuffle = dst.shuffle(shuffle);
-    DeviceAssign<Vectorizable, Tiling>(d, dst_shuffle, src);
-
-    for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-      VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-    }
-
-  } while (std::next_permutation(&shuffle[0], &shuffle[0] + NumDims));
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_reshape(Device d) {
-  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
-
-  static constexpr int ReshapedDims = NumDims - 1;
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(5, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  // Multiple 0th dimension and then shuffle.
-  std::vector<Index> shuffle;
-  for (int i = 0; i < ReshapedDims; ++i) shuffle.push_back(i);
-  std::shuffle(shuffle.begin(), shuffle.end(), std::mt19937());
-
-  DSizes<Index, ReshapedDims> reshaped_dims;
-  reshaped_dims[shuffle[0]] = dims[0] * dims[1];
-  for (int i = 1; i < ReshapedDims; ++i) reshaped_dims[shuffle[i]] = dims[i + 1];
-
-  Tensor<T, ReshapedDims, Options, Index> golden = src.reshape(reshaped_dims);
-
-  // Now reshape using configured tensor executor.
-  Tensor<T, ReshapedDims, Options, Index> dst(golden.dimensions());
-
-  auto expr = src.reshape(reshaped_dims);
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_slice_rvalue(Device d) {
-  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(5, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  // Pick a random slice of src tensor.
-  auto slice_start = DSizes<Index, NumDims>(RandomDims<NumDims>());
-  auto slice_size = DSizes<Index, NumDims>(RandomDims<NumDims>());
-
-  // Make sure that slice start + size do not overflow tensor dims.
-  for (int i = 0; i < NumDims; ++i) {
-    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
-    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
-  }
-
-  Tensor<T, NumDims, Options, Index> golden = src.slice(slice_start, slice_size);
-
-  // Now reshape using configured tensor executor.
-  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
-
-  auto expr = src.slice(slice_start, slice_size);
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_slice_lvalue(Device d) {
-  static_assert(NumDims >= 2, "NumDims must be greater or equal than 2");
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(5, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  // Pick a random slice of src tensor.
-  auto slice_start = DSizes<Index, NumDims>(RandomDims<NumDims>(1, 10));
-  auto slice_size = DSizes<Index, NumDims>(RandomDims<NumDims>(1, 10));
-
-  // Make sure that slice start + size do not overflow tensor dims.
-  for (int i = 0; i < NumDims; ++i) {
-    slice_start[i] = numext::mini(dims[i] - 1, slice_start[i]);
-    slice_size[i] = numext::mini(slice_size[i], dims[i] - slice_start[i]);
-  }
-
-  Tensor<T, NumDims, Options, Index> slice(slice_size);
-  slice.setRandom();
-
-  // Assign a slice using default executor.
-  Tensor<T, NumDims, Options, Index> golden = src;
-  golden.slice(slice_start, slice_size) = slice;
-
-  // And using configured execution strategy.
-  Tensor<T, NumDims, Options, Index> dst = src;
-  auto expr = dst.slice(slice_start, slice_size);
-
-  using Assign = TensorAssignOp<decltype(expr), const decltype(slice)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(expr, slice), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_broadcasting_of_forced_eval(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(1, 10);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  const auto broadcasts = RandomDims<NumDims>(1, 7);
-  const auto expr = src.square().eval().broadcast(broadcasts);
-
-  // We assume that broadcasting on a default device is tested and correct, so
-  // we can rely on it to verify correctness of tensor executor and tiling.
-  Tensor<T, NumDims, Options, Index> golden;
-  golden = expr;
-
-  // Now do the broadcasting using configured tensor executor.
-  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims>
-struct DummyGenerator {
-  EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T operator()(const array<Index, NumDims>& dims) const {
-    T result = static_cast<T>(0);
-    for (int i = 0; i < NumDims; ++i) {
-      result += static_cast<T>((i + 1) * dims[i]);
-    }
-    return result;
-  }
-};
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_generator_op(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(20, 30);
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  const auto expr = src.generate(DummyGenerator<T, NumDims>());
-
-  // We assume that generator on a default device is tested and correct, so
-  // we can rely on it to verify correctness of tensor executor and tiling.
-  Tensor<T, NumDims, Options, Index> golden;
-  golden = expr;
-
-  // Now do the broadcasting using configured tensor executor.
-  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_execute_reverse_rvalue(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  auto dims = RandomDims<NumDims>(1, numext::pow(1000000.0, 1.0 / NumDims));
-  Tensor<T, NumDims, Options, Index> src(dims);
-  src.setRandom();
-
-  // Reverse half of the dimensions.
-  Eigen::array<bool, NumDims> reverse;
-  for (int i = 0; i < NumDims; ++i) reverse[i] = internal::random<bool>();
-
-  const auto expr = src.reverse(reverse);
-
-  // We assume that reversing on a default device is tested and correct, so
-  // we can rely on it to verify correctness of tensor executor and tiling.
-  Tensor<T, NumDims, Options, Index> golden;
-  golden = expr;
-
-  // Now do the reversing using configured tensor executor.
-  Tensor<T, NumDims, Options, Index> dst(golden.dimensions());
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using Executor = internal::TensorExecutor<const Assign, Device, Vectorizable, Tiling>;
-
-  Executor::run(Assign(dst, expr), d);
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    VERIFY_IS_EQUAL(dst.coeff(i), golden.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_async_execute_unary_expr(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  // Pick a large enough tensor size to bypass small tensor block evaluation
-  // optimization.
-  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
-
-  Tensor<T, NumDims, Options, Index> src(dims);
-  Tensor<T, NumDims, Options, Index> dst(dims);
-
-  src.setRandom();
-  const auto expr = src.square();
-
-  Eigen::Barrier done(1);
-  auto on_done = [&done]() { done.Notify(); };
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using DoneCallback = decltype(on_done);
-  using Executor = internal::TensorAsyncExecutor<const Assign, Device, DoneCallback, Vectorizable, Tiling>;
-
-  Executor::runAsync(Assign(dst, expr), d, on_done);
-  done.Wait();
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    T square = src.coeff(i) * src.coeff(i);
-    VERIFY_IS_EQUAL(square, dst.coeff(i));
-  }
-}
-
-template <typename T, int NumDims, typename Device, bool Vectorizable, TiledEvaluation Tiling, int Layout>
-void test_async_execute_binary_expr(Device d) {
-  static constexpr int Options = 0 | Layout;
-
-  // Pick a large enough tensor size to bypass small tensor block evaluation
-  // optimization.
-  auto dims = RandomDims<NumDims>(50 / NumDims, 100 / NumDims);
-
-  Tensor<T, NumDims, Options, Index> lhs(dims);
-  Tensor<T, NumDims, Options, Index> rhs(dims);
-  Tensor<T, NumDims, Options, Index> dst(dims);
-
-  lhs.setRandom();
-  rhs.setRandom();
-
-  const auto expr = lhs + rhs;
-
-  Eigen::Barrier done(1);
-  auto on_done = [&done]() { done.Notify(); };
-
-  using Assign = TensorAssignOp<decltype(dst), const decltype(expr)>;
-  using DoneCallback = decltype(on_done);
-  using Executor = internal::TensorAsyncExecutor<const Assign, Device, DoneCallback, Vectorizable, Tiling>;
-
-  Executor::runAsync(Assign(dst, expr), d, on_done);
-  done.Wait();
-
-  for (Index i = 0; i < dst.dimensions().TotalSize(); ++i) {
-    T sum = lhs.coeff(i) + rhs.coeff(i);
-    VERIFY_IS_EQUAL(sum, dst.coeff(i));
-  }
-}
-
-#ifndef EIGEN_DONT_VECTORIZE
-#define EIGEN_DONT_VECTORIZE 0
-#endif
-#define VECTORIZABLE(T, VAL) !EIGEN_DONT_VECTORIZE&& Eigen::internal::packet_traits<T>::Vectorizable&& VAL
-
-#define CALL_SUBTEST_PART(PART) CALL_SUBTEST_##PART
-
-#define CALL_SUBTEST_COMBINATIONS(PART, NAME, T, NUM_DIMS)                                                            \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::Off, ColMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::On, ColMajor>(default_device)));  \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, ColMajor>(default_device)));        \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::On, ColMajor>(default_device)));         \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::Off, RowMajor>(default_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, DefaultDevice, false, TiledEvaluation::On, RowMajor>(default_device)));  \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, RowMajor>(default_device)));        \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, DefaultDevice, VECTORIZABLE(T, true), TiledEvaluation::On, RowMajor>(default_device)));         \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, ColMajor>(tp_device)));   \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, ColMajor>(tp_device)));    \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, ColMajor>(tp_device)));          \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, ColMajor>(tp_device)));           \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, RowMajor>(tp_device)));   \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, RowMajor>(tp_device)));    \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, RowMajor>(tp_device)));          \
-  CALL_SUBTEST_PART(PART)                                                                                             \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, RowMajor>(tp_device)))
-
-// NOTE: Currently only ThreadPoolDevice supports async expression evaluation.
-#define CALL_ASYNC_SUBTEST_COMBINATIONS(PART, NAME, T, NUM_DIMS)                                                    \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, ColMajor>(tp_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, ColMajor>(tp_device)));  \
-  CALL_SUBTEST_PART(PART)                                                                                           \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, ColMajor>(tp_device)));        \
-  CALL_SUBTEST_PART(PART)                                                                                           \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, ColMajor>(tp_device)));         \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::Off, RowMajor>(tp_device))); \
-  CALL_SUBTEST_PART(PART)((NAME<T, NUM_DIMS, ThreadPoolDevice, false, TiledEvaluation::On, RowMajor>(tp_device)));  \
-  CALL_SUBTEST_PART(PART)                                                                                           \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::Off, RowMajor>(tp_device)));        \
-  CALL_SUBTEST_PART(PART)                                                                                           \
-  ((NAME<T, NUM_DIMS, ThreadPoolDevice, VECTORIZABLE(T, true), TiledEvaluation::On, RowMajor>(tp_device)))
-
-EIGEN_DECLARE_TEST(cxx11_tensor_executor) {
-  Eigen::DefaultDevice default_device;
-  // Default device is unused in ASYNC tests.
-  EIGEN_UNUSED_VARIABLE(default_device);
-
-  const auto num_threads = internal::random<int>(20, 24);
-  Eigen::ThreadPool tp(num_threads);
-  Eigen::ThreadPoolDevice tp_device(&tp, num_threads);
-
-  CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 3);
-  CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 4);
-  CALL_SUBTEST_COMBINATIONS(1, test_execute_unary_expr, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 3);
-  CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 4);
-  CALL_SUBTEST_COMBINATIONS(2, test_execute_binary_expr, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 3);
-  CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 4);
-  CALL_SUBTEST_COMBINATIONS(3, test_execute_broadcasting, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(4, test_execute_chipping_rvalue, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(5, test_execute_chipping_lvalue, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(6, test_execute_shuffle_rvalue, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(7, test_execute_shuffle_lvalue, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 2);
-  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 3);
-  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 4);
-  CALL_SUBTEST_COMBINATIONS(9, test_execute_reshape, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 2);
-  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(10, test_execute_slice_rvalue, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 2);
-  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(11, test_execute_slice_lvalue, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 2);
-  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 3);
-  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 4);
-  CALL_SUBTEST_COMBINATIONS(12, test_execute_broadcasting_of_forced_eval, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 2);
-  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 3);
-  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 4);
-  CALL_SUBTEST_COMBINATIONS(13, test_execute_generator_op, float, 5);
-
-  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 1);
-  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 2);
-  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 3);
-  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 4);
-  CALL_SUBTEST_COMBINATIONS(14, test_execute_reverse_rvalue, float, 5);
-
-  CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 3);
-  CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 4);
-  CALL_ASYNC_SUBTEST_COMBINATIONS(15, test_async_execute_unary_expr, float, 5);
-
-  CALL_ASYNC_SUBTEST_COMBINATIONS(16, test_async_execute_binary_expr, float, 3);
-  CALL_ASYNC_SUBTEST_COMBINATIONS(16, test_async_execute_binary_expr, float, 4);
-  CALL_ASYNC_SUBTEST_COMBINATIONS(16, test_async_execute_binary_expr, float, 5);
-
-  // Force CMake to split this test.
-  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16
-}
diff --git a/unsupported/test/cxx11_tensor_expr.cpp b/unsupported/test/cxx11_tensor_expr.cpp
deleted file mode 100644
index d29b1db..0000000
--- a/unsupported/test/cxx11_tensor_expr.cpp
+++ /dev/null
@@ -1,476 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <numeric>
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_1d() {
-  Tensor<float, 1> vec1(6);
-  Tensor<float, 1, RowMajor> vec2(6);
-
-  vec1(0) = 4.0;
-  vec2(0) = 0.0;
-  vec1(1) = 8.0;
-  vec2(1) = 1.0;
-  vec1(2) = 15.0;
-  vec2(2) = 2.0;
-  vec1(3) = 16.0;
-  vec2(3) = 3.0;
-  vec1(4) = 23.0;
-  vec2(4) = 4.0;
-  vec1(5) = 42.0;
-  vec2(5) = 5.0;
-
-  float data3[6];
-  TensorMap<Tensor<float, 1>> vec3(data3, 6);
-  vec3 = vec1.sqrt();
-  float data4[6];
-  TensorMap<Tensor<float, 1, RowMajor>> vec4(data4, 6);
-  vec4 = vec2.square();
-  float data5[6];
-  TensorMap<Tensor<float, 1, RowMajor>> vec5(data5, 6);
-  vec5 = vec2.cube();
-
-  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
-  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
-  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0));
-  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0));
-  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
-  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
-
-  VERIFY_IS_APPROX(vec4(0), 0.0f);
-  VERIFY_IS_APPROX(vec4(1), 1.0f);
-  VERIFY_IS_APPROX(vec4(2), 2.0f * 2.0f);
-  VERIFY_IS_APPROX(vec4(3), 3.0f * 3.0f);
-  VERIFY_IS_APPROX(vec4(4), 4.0f * 4.0f);
-  VERIFY_IS_APPROX(vec4(5), 5.0f * 5.0f);
-
-  VERIFY_IS_APPROX(vec5(0), 0.0f);
-  VERIFY_IS_APPROX(vec5(1), 1.0f);
-  VERIFY_IS_APPROX(vec5(2), 2.0f * 2.0f * 2.0f);
-  VERIFY_IS_APPROX(vec5(3), 3.0f * 3.0f * 3.0f);
-  VERIFY_IS_APPROX(vec5(4), 4.0f * 4.0f * 4.0f);
-  VERIFY_IS_APPROX(vec5(5), 5.0f * 5.0f * 5.0f);
-
-  vec3 = vec1 + vec2;
-  VERIFY_IS_APPROX(vec3(0), 4.0f + 0.0f);
-  VERIFY_IS_APPROX(vec3(1), 8.0f + 1.0f);
-  VERIFY_IS_APPROX(vec3(2), 15.0f + 2.0f);
-  VERIFY_IS_APPROX(vec3(3), 16.0f + 3.0f);
-  VERIFY_IS_APPROX(vec3(4), 23.0f + 4.0f);
-  VERIFY_IS_APPROX(vec3(5), 42.0f + 5.0f);
-}
-
-static void test_2d() {
-  float data1[6];
-  TensorMap<Tensor<float, 2>> mat1(data1, 2, 3);
-  float data2[6];
-  TensorMap<Tensor<float, 2, RowMajor>> mat2(data2, 2, 3);
-
-  mat1(0, 0) = 0.0;
-  mat1(0, 1) = 1.0;
-  mat1(0, 2) = 2.0;
-  mat1(1, 0) = 3.0;
-  mat1(1, 1) = 4.0;
-  mat1(1, 2) = 5.0;
-
-  mat2(0, 0) = -0.0;
-  mat2(0, 1) = -1.0;
-  mat2(0, 2) = -2.0;
-  mat2(1, 0) = -3.0;
-  mat2(1, 1) = -4.0;
-  mat2(1, 2) = -5.0;
-
-  Tensor<float, 2> mat3(2, 3);
-  Tensor<float, 2, RowMajor> mat4(2, 3);
-  mat3 = mat1.abs();
-  mat4 = mat2.abs();
-
-  VERIFY_IS_APPROX(mat3(0, 0), 0.0f);
-  VERIFY_IS_APPROX(mat3(0, 1), 1.0f);
-  VERIFY_IS_APPROX(mat3(0, 2), 2.0f);
-  VERIFY_IS_APPROX(mat3(1, 0), 3.0f);
-  VERIFY_IS_APPROX(mat3(1, 1), 4.0f);
-  VERIFY_IS_APPROX(mat3(1, 2), 5.0f);
-
-  VERIFY_IS_APPROX(mat4(0, 0), 0.0f);
-  VERIFY_IS_APPROX(mat4(0, 1), 1.0f);
-  VERIFY_IS_APPROX(mat4(0, 2), 2.0f);
-  VERIFY_IS_APPROX(mat4(1, 0), 3.0f);
-  VERIFY_IS_APPROX(mat4(1, 1), 4.0f);
-  VERIFY_IS_APPROX(mat4(1, 2), 5.0f);
-}
-
-static void test_3d() {
-  Tensor<float, 3> mat1(2, 3, 7);
-  Tensor<float, 3, RowMajor> mat2(2, 3, 7);
-
-  float val = 1.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        mat2(i, j, k) = val;
-        val += 1.0f;
-      }
-    }
-  }
-
-  Tensor<float, 3> mat3(2, 3, 7);
-  mat3 = mat1 + mat1;
-  Tensor<float, 3, RowMajor> mat4(2, 3, 7);
-  mat4 = mat2 * 3.14f;
-  Tensor<float, 3> mat5(2, 3, 7);
-  mat5 = (mat1 + mat1.constant(1)).inverse().log();
-  Tensor<float, 3, RowMajor> mat6(2, 3, 7);
-  mat6 = mat2.pow(0.5f) * 3.14f;
-  Tensor<float, 3> mat7(2, 3, 7);
-  mat7 = mat1.cwiseMax(mat5 * 2.0f).exp();
-  Tensor<float, 3, RowMajor> mat8(2, 3, 7);
-  mat8 = (-mat2).exp() * 3.14f;
-  Tensor<float, 3, RowMajor> mat9(2, 3, 7);
-  mat9 = mat2 + 3.14f;
-  Tensor<float, 3, RowMajor> mat10(2, 3, 7);
-  mat10 = mat2 - 3.14f;
-  Tensor<float, 3, RowMajor> mat11(2, 3, 7);
-  mat11 = mat2 / 3.14f;
-
-  val = 1.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat3(i, j, k), val + val);
-        VERIFY_IS_APPROX(mat4(i, j, k), val * 3.14f);
-        VERIFY_IS_APPROX(mat5(i, j, k), logf(1.0f / (val + 1)));
-        VERIFY_IS_APPROX(mat6(i, j, k), sqrtf(val) * 3.14f);
-        VERIFY_IS_APPROX(mat7(i, j, k), expf((std::max)(val, mat5(i, j, k) * 2.0f)));
-        VERIFY_IS_APPROX(mat8(i, j, k), expf(-val) * 3.14f);
-        VERIFY_IS_APPROX(mat9(i, j, k), val + 3.14f);
-        VERIFY_IS_APPROX(mat10(i, j, k), val - 3.14f);
-        VERIFY_IS_APPROX(mat11(i, j, k), val / 3.14f);
-        val += 1.0f;
-      }
-    }
-  }
-}
-
-static void test_constants() {
-  Tensor<float, 3> mat1(2, 3, 7);
-  Tensor<float, 3> mat2(2, 3, 7);
-  Tensor<float, 3> mat3(2, 3, 7);
-
-  float val = 1.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        val += 1.0f;
-      }
-    }
-  }
-  mat2 = mat1.constant(3.14f);
-  mat3 = mat1.cwiseMax(7.3f).exp();
-
-  val = 1.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat2(i, j, k), 3.14f);
-        VERIFY_IS_APPROX(mat3(i, j, k), expf((std::max)(val, 7.3f)));
-        val += 1.0f;
-      }
-    }
-  }
-}
-
-static void test_boolean() {
-  const int kSize = 31;
-  Tensor<int, 1> vec(kSize);
-  std::iota(vec.data(), vec.data() + kSize, 0);
-
-  // Test ||.
-  Tensor<bool, 1> bool1 = (vec < vec.constant(1) || vec > vec.constant(4)).cast<bool>();
-  for (int i = 0; i < kSize; ++i) {
-    bool expected = i < 1 || i > 4;
-    VERIFY_IS_EQUAL(bool1[i], expected);
-  }
-
-  // Test &&, including cast of operand vec.
-  Tensor<bool, 1> bool2 = vec.cast<bool>() && (vec < vec.constant(4)).cast<bool>();
-  for (int i = 0; i < kSize; ++i) {
-    bool expected = bool(i) && i < 4;
-    VERIFY_IS_EQUAL(bool2[i], expected);
-  }
-
-  // Compilation tests:
-  // Test Tensor<bool> against results of cast or comparison; verifies that
-  // CoeffReturnType is set to match Op return type of bool for Unary and Binary
-  // Ops.
-  Tensor<bool, 1> bool3 = vec.cast<bool>() && bool2;
-  bool3 = (vec < vec.constant(4)).cast<bool>() && bool2;
-}
-
-static void test_functors() {
-  Tensor<float, 3> mat1(2, 3, 7);
-  Tensor<float, 3> mat2(2, 3, 7);
-  Tensor<float, 3> mat3(2, 3, 7);
-
-  float val = 1.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        val += 1.0f;
-      }
-    }
-  }
-  mat2 = mat1.inverse().unaryExpr(&asinf);
-  mat3 = mat1.unaryExpr(&tanhf);
-
-  val = 1.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat2(i, j, k), asinf(1.0f / mat1(i, j, k)));
-        VERIFY_IS_APPROX(mat3(i, j, k), tanhf(mat1(i, j, k)));
-        val += 1.0f;
-      }
-    }
-  }
-}
-
-static void test_type_casting() {
-  Tensor<bool, 3> mat1(2, 3, 7);
-  Tensor<float, 3> mat2(2, 3, 7);
-  Tensor<double, 3> mat3(2, 3, 7);
-  mat1.setRandom();
-  mat2.setRandom();
-
-  mat3 = mat1.cast<double>();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat3(i, j, k), mat1(i, j, k) ? 1.0 : 0.0);
-      }
-    }
-  }
-
-  mat3 = mat2.cast<double>();
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat3(i, j, k), static_cast<double>(mat2(i, j, k)));
-      }
-    }
-  }
-}
-
-static void test_select() {
-  using TypedGTOp = internal::scalar_cmp_op<float, float, internal::cmp_GT, true>;
-
-  Tensor<float, 3> selector(2, 3, 7);
-  Tensor<float, 3> mat1(2, 3, 7);
-  Tensor<float, 3> mat2(2, 3, 7);
-  Tensor<float, 3> result(2, 3, 7);
-
-  selector.setRandom();
-  mat1.setRandom();
-  mat2.setRandom();
-
-  // test select with a boolean condition
-  result = (selector > selector.constant(0.5f)).select(mat1, mat2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(result(i, j, k), (selector(i, j, k) > 0.5f) ? mat1(i, j, k) : mat2(i, j, k));
-      }
-    }
-  }
-
-  // test select with a typed condition
-  result = selector.binaryExpr(selector.constant(0.5f), TypedGTOp()).select(mat1, mat2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(result(i, j, k), (selector(i, j, k) > 0.5f) ? mat1(i, j, k) : mat2(i, j, k));
-      }
-    }
-  }
-}
-
-// Nan propagation does currently not work like one would expect from std::max/std::min,
-// so we disable it for now
-#if !EIGEN_ARCH_ARM_OR_ARM64
-template <typename Scalar>
-void test_minmax_nan_propagation_templ() {
-  for (int size = 1; size < 17; ++size) {
-    const Scalar kNaN = std::numeric_limits<Scalar>::quiet_NaN();
-    const Scalar kInf = std::numeric_limits<Scalar>::infinity();
-    const Scalar kZero(0);
-    Tensor<Scalar, 1> vec_full_nan(size);
-    Tensor<Scalar, 1> vec_one_nan(size);
-    Tensor<Scalar, 1> vec_zero(size);
-    vec_full_nan.setConstant(kNaN);
-    vec_zero.setZero();
-    vec_one_nan.setZero();
-    vec_one_nan(size / 2) = kNaN;
-
-    auto verify_all_nan = [&](const Tensor<Scalar, 1>& v) {
-      for (int i = 0; i < size; ++i) {
-        VERIFY((numext::isnan)(v(i)));
-      }
-    };
-
-    auto verify_all_zero = [&](const Tensor<Scalar, 1>& v) {
-      for (int i = 0; i < size; ++i) {
-        VERIFY_IS_EQUAL(v(i), Scalar(0));
-      }
-    };
-
-    // Test NaN propagating max.
-    // max(nan, nan) = nan
-    // max(nan, 0) = nan
-    // max(0, nan) = nan
-    // max(0, 0) = 0
-    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(kNaN));
-    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(vec_full_nan));
-    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(kZero));
-    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNaN>(vec_zero));
-    verify_all_nan(vec_zero.template cwiseMax<PropagateNaN>(kNaN));
-    verify_all_nan(vec_zero.template cwiseMax<PropagateNaN>(vec_full_nan));
-    verify_all_zero(vec_zero.template cwiseMax<PropagateNaN>(kZero));
-    verify_all_zero(vec_zero.template cwiseMax<PropagateNaN>(vec_zero));
-
-    // Test number propagating max.
-    // max(nan, nan) = nan
-    // max(nan, 0) = 0
-    // max(0, nan) = 0
-    // max(0, 0) = 0
-    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNumbers>(kNaN));
-    verify_all_nan(vec_full_nan.template cwiseMax<PropagateNumbers>(vec_full_nan));
-    verify_all_zero(vec_full_nan.template cwiseMax<PropagateNumbers>(kZero));
-    verify_all_zero(vec_full_nan.template cwiseMax<PropagateNumbers>(vec_zero));
-    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(kNaN));
-    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(vec_full_nan));
-    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(kZero));
-    verify_all_zero(vec_zero.template cwiseMax<PropagateNumbers>(vec_zero));
-
-    // Test NaN propagating min.
-    // min(nan, nan) = nan
-    // min(nan, 0) = nan
-    // min(0, nan) = nan
-    // min(0, 0) = 0
-    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(kNaN));
-    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(vec_full_nan));
-    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(kZero));
-    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNaN>(vec_zero));
-    verify_all_nan(vec_zero.template cwiseMin<PropagateNaN>(kNaN));
-    verify_all_nan(vec_zero.template cwiseMin<PropagateNaN>(vec_full_nan));
-    verify_all_zero(vec_zero.template cwiseMin<PropagateNaN>(kZero));
-    verify_all_zero(vec_zero.template cwiseMin<PropagateNaN>(vec_zero));
-
-    // Test number propagating min.
-    // min(nan, nan) = nan
-    // min(nan, 0) = 0
-    // min(0, nan) = 0
-    // min(0, 0) = 0
-    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNumbers>(kNaN));
-    verify_all_nan(vec_full_nan.template cwiseMin<PropagateNumbers>(vec_full_nan));
-    verify_all_zero(vec_full_nan.template cwiseMin<PropagateNumbers>(kZero));
-    verify_all_zero(vec_full_nan.template cwiseMin<PropagateNumbers>(vec_zero));
-    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(kNaN));
-    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(vec_full_nan));
-    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(kZero));
-    verify_all_zero(vec_zero.template cwiseMin<PropagateNumbers>(vec_zero));
-
-    // Test min and max reduction
-    Tensor<Scalar, 0> val;
-    val = vec_zero.minimum();
-    VERIFY_IS_EQUAL(val(), kZero);
-    val = vec_zero.template minimum<PropagateNaN>();
-    VERIFY_IS_EQUAL(val(), kZero);
-    val = vec_zero.template minimum<PropagateNumbers>();
-    VERIFY_IS_EQUAL(val(), kZero);
-    val = vec_zero.maximum();
-    VERIFY_IS_EQUAL(val(), kZero);
-    val = vec_zero.template maximum<PropagateNaN>();
-    VERIFY_IS_EQUAL(val(), kZero);
-    val = vec_zero.template maximum<PropagateNumbers>();
-    VERIFY_IS_EQUAL(val(), kZero);
-
-    // Test NaN propagation for tensor of all NaNs.
-    val = vec_full_nan.template minimum<PropagateNaN>();
-    VERIFY((numext::isnan)(val()));
-    val = vec_full_nan.template minimum<PropagateNumbers>();
-    VERIFY_IS_EQUAL(val(), kInf);
-    val = vec_full_nan.template maximum<PropagateNaN>();
-    VERIFY((numext::isnan)(val()));
-    val = vec_full_nan.template maximum<PropagateNumbers>();
-    VERIFY_IS_EQUAL(val(), -kInf);
-
-    // Test NaN propagation for tensor with a single NaN.
-    val = vec_one_nan.template minimum<PropagateNaN>();
-    VERIFY((numext::isnan)(val()));
-    val = vec_one_nan.template minimum<PropagateNumbers>();
-    VERIFY_IS_EQUAL(val(), (size == 1 ? kInf : kZero));
-    val = vec_one_nan.template maximum<PropagateNaN>();
-    VERIFY((numext::isnan)(val()));
-    val = vec_one_nan.template maximum<PropagateNumbers>();
-    VERIFY_IS_EQUAL(val(), (size == 1 ? -kInf : kZero));
-  }
-}
-#else
-template <typename Scalar>
-void test_minmax_nan_propagation_templ() {}
-#endif
-
-static void test_clip() {
-  Tensor<float, 1> vec(6);
-  vec(0) = 4.0;
-  vec(1) = 8.0;
-  vec(2) = 15.0;
-  vec(3) = 16.0;
-  vec(4) = 23.0;
-  vec(5) = 42.0;
-
-  float kMin = 20;
-  float kMax = 30;
-
-  Tensor<float, 1> vec_clipped(6);
-  vec_clipped = vec.clip(kMin, kMax);
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(vec_clipped(i), numext::mini(numext::maxi(vec(i), kMin), kMax));
-  }
-}
-
-static void test_minmax_nan_propagation() {
-  test_minmax_nan_propagation_templ<float>();
-  test_minmax_nan_propagation_templ<double>();
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_expr) {
-  CALL_SUBTEST(test_1d());
-  CALL_SUBTEST(test_2d());
-  CALL_SUBTEST(test_3d());
-  CALL_SUBTEST(test_constants());
-  CALL_SUBTEST(test_boolean());
-  CALL_SUBTEST(test_functors());
-  CALL_SUBTEST(test_type_casting());
-  CALL_SUBTEST(test_select());
-  CALL_SUBTEST(test_clip());
-  CALL_SUBTEST(test_minmax_nan_propagation());
-}
diff --git a/unsupported/test/cxx11_tensor_fft.cpp b/unsupported/test/cxx11_tensor_fft.cpp
deleted file mode 100644
index 8db1a24..0000000
--- a/unsupported/test/cxx11_tensor_fft.cpp
+++ /dev/null
@@ -1,296 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Jianwei Cui <thucjw@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_fft_2D_golden() {
-  Tensor<float, 2, DataLayout> input(2, 3);
-  input(0, 0) = 1;
-  input(0, 1) = 2;
-  input(0, 2) = 3;
-  input(1, 0) = 4;
-  input(1, 1) = 5;
-  input(1, 2) = 6;
-
-  array<ptrdiff_t, 2> fft;
-  fft[0] = 0;
-  fft[1] = 1;
-
-  Tensor<std::complex<float>, 2, DataLayout> output = input.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
-
-  std::complex<float> output_golden[6];  // in ColMajor order
-  output_golden[0] = std::complex<float>(21, 0);
-  output_golden[1] = std::complex<float>(-9, 0);
-  output_golden[2] = std::complex<float>(-3, 1.73205);
-  output_golden[3] = std::complex<float>(0, 0);
-  output_golden[4] = std::complex<float>(-3, -1.73205);
-  output_golden[5] = std::complex<float>(0, 0);
-
-  std::complex<float> c_offset = std::complex<float>(1.0, 1.0);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_APPROX(output(0) + c_offset, output_golden[0] + c_offset);
-    VERIFY_IS_APPROX(output(1) + c_offset, output_golden[1] + c_offset);
-    VERIFY_IS_APPROX(output(2) + c_offset, output_golden[2] + c_offset);
-    VERIFY_IS_APPROX(output(3) + c_offset, output_golden[3] + c_offset);
-    VERIFY_IS_APPROX(output(4) + c_offset, output_golden[4] + c_offset);
-    VERIFY_IS_APPROX(output(5) + c_offset, output_golden[5] + c_offset);
-  } else {
-    VERIFY_IS_APPROX(output(0) + c_offset, output_golden[0] + c_offset);
-    VERIFY_IS_APPROX(output(1) + c_offset, output_golden[2] + c_offset);
-    VERIFY_IS_APPROX(output(2) + c_offset, output_golden[4] + c_offset);
-    VERIFY_IS_APPROX(output(3) + c_offset, output_golden[1] + c_offset);
-    VERIFY_IS_APPROX(output(4) + c_offset, output_golden[3] + c_offset);
-    VERIFY_IS_APPROX(output(5) + c_offset, output_golden[5] + c_offset);
-  }
-}
-
-static void test_fft_complex_input_golden() {
-  Tensor<std::complex<float>, 1, ColMajor> input(5);
-  input(0) = std::complex<float>(1, 1);
-  input(1) = std::complex<float>(2, 2);
-  input(2) = std::complex<float>(3, 3);
-  input(3) = std::complex<float>(4, 4);
-  input(4) = std::complex<float>(5, 5);
-
-  array<ptrdiff_t, 1> fft;
-  fft[0] = 0;
-
-  Tensor<std::complex<float>, 1, ColMajor> forward_output_both_parts = input.fft<BothParts, FFT_FORWARD>(fft);
-  Tensor<std::complex<float>, 1, ColMajor> reverse_output_both_parts = input.fft<BothParts, FFT_REVERSE>(fft);
-
-  Tensor<float, 1, ColMajor> forward_output_real_part = input.fft<RealPart, FFT_FORWARD>(fft);
-  Tensor<float, 1, ColMajor> reverse_output_real_part = input.fft<RealPart, FFT_REVERSE>(fft);
-
-  Tensor<float, 1, ColMajor> forward_output_imag_part = input.fft<ImagPart, FFT_FORWARD>(fft);
-  Tensor<float, 1, ColMajor> reverse_output_imag_part = input.fft<ImagPart, FFT_REVERSE>(fft);
-
-  VERIFY_IS_EQUAL(forward_output_both_parts.dimension(0), input.dimension(0));
-  VERIFY_IS_EQUAL(reverse_output_both_parts.dimension(0), input.dimension(0));
-
-  VERIFY_IS_EQUAL(forward_output_real_part.dimension(0), input.dimension(0));
-  VERIFY_IS_EQUAL(reverse_output_real_part.dimension(0), input.dimension(0));
-
-  VERIFY_IS_EQUAL(forward_output_imag_part.dimension(0), input.dimension(0));
-  VERIFY_IS_EQUAL(reverse_output_imag_part.dimension(0), input.dimension(0));
-
-  std::complex<float> forward_golden_result[5];
-  std::complex<float> reverse_golden_result[5];
-
-  forward_golden_result[0] = std::complex<float>(15.000000000000000, +15.000000000000000);
-  forward_golden_result[1] = std::complex<float>(-5.940954801177935, +0.940954801177934);
-  forward_golden_result[2] = std::complex<float>(-3.312299240582266, -1.687700759417735);
-  forward_golden_result[3] = std::complex<float>(-1.687700759417735, -3.312299240582266);
-  forward_golden_result[4] = std::complex<float>(0.940954801177934, -5.940954801177935);
-
-  reverse_golden_result[0] = std::complex<float>(3.000000000000000, +3.000000000000000);
-  reverse_golden_result[1] = std::complex<float>(0.188190960235587, -1.188190960235587);
-  reverse_golden_result[2] = std::complex<float>(-0.337540151883547, -0.662459848116453);
-  reverse_golden_result[3] = std::complex<float>(-0.662459848116453, -0.337540151883547);
-  reverse_golden_result[4] = std::complex<float>(-1.188190960235587, +0.188190960235587);
-
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_APPROX(forward_output_both_parts(i), forward_golden_result[i]);
-    VERIFY_IS_APPROX(forward_output_real_part(i), forward_golden_result[i].real());
-    VERIFY_IS_APPROX(forward_output_imag_part(i), forward_golden_result[i].imag());
-  }
-
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_APPROX(reverse_output_both_parts(i), reverse_golden_result[i]);
-    VERIFY_IS_APPROX(reverse_output_real_part(i), reverse_golden_result[i].real());
-    VERIFY_IS_APPROX(reverse_output_imag_part(i), reverse_golden_result[i].imag());
-  }
-}
-
-static void test_fft_real_input_golden() {
-  Tensor<float, 1, ColMajor> input(5);
-  input(0) = 1.0;
-  input(1) = 2.0;
-  input(2) = 3.0;
-  input(3) = 4.0;
-  input(4) = 5.0;
-
-  array<ptrdiff_t, 1> fft;
-  fft[0] = 0;
-
-  Tensor<std::complex<float>, 1, ColMajor> forward_output_both_parts = input.fft<BothParts, FFT_FORWARD>(fft);
-  Tensor<std::complex<float>, 1, ColMajor> reverse_output_both_parts = input.fft<BothParts, FFT_REVERSE>(fft);
-
-  Tensor<float, 1, ColMajor> forward_output_real_part = input.fft<RealPart, FFT_FORWARD>(fft);
-  Tensor<float, 1, ColMajor> reverse_output_real_part = input.fft<RealPart, FFT_REVERSE>(fft);
-
-  Tensor<float, 1, ColMajor> forward_output_imag_part = input.fft<ImagPart, FFT_FORWARD>(fft);
-  Tensor<float, 1, ColMajor> reverse_output_imag_part = input.fft<ImagPart, FFT_REVERSE>(fft);
-
-  VERIFY_IS_EQUAL(forward_output_both_parts.dimension(0), input.dimension(0));
-  VERIFY_IS_EQUAL(reverse_output_both_parts.dimension(0), input.dimension(0));
-
-  VERIFY_IS_EQUAL(forward_output_real_part.dimension(0), input.dimension(0));
-  VERIFY_IS_EQUAL(reverse_output_real_part.dimension(0), input.dimension(0));
-
-  VERIFY_IS_EQUAL(forward_output_imag_part.dimension(0), input.dimension(0));
-  VERIFY_IS_EQUAL(reverse_output_imag_part.dimension(0), input.dimension(0));
-
-  std::complex<float> forward_golden_result[5];
-  std::complex<float> reverse_golden_result[5];
-
-  forward_golden_result[0] = std::complex<float>(15, 0);
-  forward_golden_result[1] = std::complex<float>(-2.5, +3.44095480117793);
-  forward_golden_result[2] = std::complex<float>(-2.5, +0.81229924058227);
-  forward_golden_result[3] = std::complex<float>(-2.5, -0.81229924058227);
-  forward_golden_result[4] = std::complex<float>(-2.5, -3.44095480117793);
-
-  reverse_golden_result[0] = std::complex<float>(3.0, 0);
-  reverse_golden_result[1] = std::complex<float>(-0.5, -0.688190960235587);
-  reverse_golden_result[2] = std::complex<float>(-0.5, -0.162459848116453);
-  reverse_golden_result[3] = std::complex<float>(-0.5, +0.162459848116453);
-  reverse_golden_result[4] = std::complex<float>(-0.5, +0.688190960235587);
-
-  std::complex<float> c_offset(1.0, 1.0);
-  float r_offset = 1.0;
-
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_APPROX(forward_output_both_parts(i) + c_offset, forward_golden_result[i] + c_offset);
-    VERIFY_IS_APPROX(forward_output_real_part(i) + r_offset, forward_golden_result[i].real() + r_offset);
-    VERIFY_IS_APPROX(forward_output_imag_part(i) + r_offset, forward_golden_result[i].imag() + r_offset);
-  }
-
-  for (int i = 0; i < 5; ++i) {
-    VERIFY_IS_APPROX(reverse_output_both_parts(i) + c_offset, reverse_golden_result[i] + c_offset);
-    VERIFY_IS_APPROX(reverse_output_real_part(i) + r_offset, reverse_golden_result[i].real() + r_offset);
-    VERIFY_IS_APPROX(reverse_output_imag_part(i) + r_offset, reverse_golden_result[i].imag() + r_offset);
-  }
-}
-
-template <int DataLayout, typename RealScalar, bool isComplexInput, int FFTResultType, int FFTDirection, int TensorRank>
-static void test_fft_real_input_energy() {
-  Eigen::DSizes<ptrdiff_t, TensorRank> dimensions;
-  ptrdiff_t total_size = 1;
-  for (int i = 0; i < TensorRank; ++i) {
-    dimensions[i] = rand() % 20 + 1;
-    total_size *= dimensions[i];
-  }
-  const DSizes<ptrdiff_t, TensorRank> arr = dimensions;
-
-  typedef std::conditional_t<isComplexInput == true, std::complex<RealScalar>, RealScalar> InputScalar;
-
-  Tensor<InputScalar, TensorRank, DataLayout> input;
-  input.resize(arr);
-  input.setRandom();
-
-  array<ptrdiff_t, TensorRank> fft;
-  for (int i = 0; i < TensorRank; ++i) {
-    fft[i] = i;
-  }
-
-  typedef std::conditional_t<FFTResultType == Eigen::BothParts, std::complex<RealScalar>, RealScalar> OutputScalar;
-  Tensor<OutputScalar, TensorRank, DataLayout> output;
-  output = input.template fft<FFTResultType, FFTDirection>(fft);
-
-  for (int i = 0; i < TensorRank; ++i) {
-    VERIFY_IS_EQUAL(output.dimension(i), input.dimension(i));
-  }
-
-  RealScalar energy_original = 0.0;
-  RealScalar energy_after_fft = 0.0;
-
-  for (int i = 0; i < total_size; ++i) {
-    energy_original += numext::abs2(input(i));
-  }
-
-  for (int i = 0; i < total_size; ++i) {
-    energy_after_fft += numext::abs2(output(i));
-  }
-
-  if (FFTDirection == FFT_FORWARD) {
-    VERIFY_IS_APPROX(energy_original, energy_after_fft / total_size);
-  } else {
-    VERIFY_IS_APPROX(energy_original, energy_after_fft * total_size);
-  }
-}
-
-template <typename RealScalar>
-static void test_fft_non_power_of_2_round_trip(int exponent) {
-  int n = (1 << exponent) + 1;
-
-  Eigen::DSizes<ptrdiff_t, 1> dimensions;
-  dimensions[0] = n;
-  const DSizes<ptrdiff_t, 1> arr = dimensions;
-  Tensor<RealScalar, 1, ColMajor, ptrdiff_t> input;
-
-  input.resize(arr);
-  input.setRandom();
-
-  array<int, 1> fft;
-  fft[0] = 0;
-
-  Tensor<std::complex<RealScalar>, 1, ColMajor> forward = input.template fft<BothParts, FFT_FORWARD>(fft);
-
-  Tensor<RealScalar, 1, ColMajor, ptrdiff_t> output = forward.template fft<RealPart, FFT_REVERSE>(fft);
-
-  for (int i = 0; i < n; ++i) {
-    RealScalar tol = test_precision<RealScalar>() * (std::abs(input[i]) + std::abs(output[i]) + 1);
-    VERIFY_IS_APPROX_OR_LESS_THAN(std::abs(input[i] - output[i]), tol);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_fft) {
-  test_fft_complex_input_golden();
-  test_fft_real_input_golden();
-
-  test_fft_2D_golden<ColMajor>();
-  test_fft_2D_golden<RowMajor>();
-
-  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 1>();
-  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 1>();
-  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 1>();
-  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 1>();
-
-  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 2>();
-  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 2>();
-  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 2>();
-  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 2>();
-
-  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 3>();
-  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 3>();
-  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 3>();
-  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 3>();
-
-  test_fft_real_input_energy<ColMajor, float, true, Eigen::BothParts, FFT_FORWARD, 4>();
-  test_fft_real_input_energy<ColMajor, double, true, Eigen::BothParts, FFT_FORWARD, 4>();
-  test_fft_real_input_energy<ColMajor, float, false, Eigen::BothParts, FFT_FORWARD, 4>();
-  test_fft_real_input_energy<ColMajor, double, false, Eigen::BothParts, FFT_FORWARD, 4>();
-
-  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 1>();
-  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 1>();
-  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 1>();
-  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 1>();
-
-  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 2>();
-  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 2>();
-  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 2>();
-  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 2>();
-
-  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 3>();
-  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 3>();
-  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 3>();
-  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 3>();
-
-  test_fft_real_input_energy<RowMajor, float, true, Eigen::BothParts, FFT_FORWARD, 4>();
-  test_fft_real_input_energy<RowMajor, double, true, Eigen::BothParts, FFT_FORWARD, 4>();
-  test_fft_real_input_energy<RowMajor, float, false, Eigen::BothParts, FFT_FORWARD, 4>();
-  test_fft_real_input_energy<RowMajor, double, false, Eigen::BothParts, FFT_FORWARD, 4>();
-
-  test_fft_non_power_of_2_round_trip<float>(7);
-  test_fft_non_power_of_2_round_trip<double>(7);
-}
diff --git a/unsupported/test/cxx11_tensor_fixed_size.cpp b/unsupported/test/cxx11_tensor_fixed_size.cpp
deleted file mode 100644
index fb22859..0000000
--- a/unsupported/test/cxx11_tensor_fixed_size.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_0d() {
-  TensorFixedSize<float, Sizes<> > scalar1;
-  TensorFixedSize<float, Sizes<>, RowMajor> scalar2;
-  VERIFY_IS_EQUAL(scalar1.rank(), 0);
-  VERIFY_IS_EQUAL(scalar1.size(), 1);
-  VERIFY_IS_EQUAL(internal::array_prod(scalar1.dimensions()), 1);
-
-  scalar1() = 7.0;
-  scalar2() = 13.0;
-
-  // Test against shallow copy.
-  TensorFixedSize<float, Sizes<> > copy = scalar1;
-  VERIFY_IS_NOT_EQUAL(scalar1.data(), copy.data());
-  VERIFY_IS_APPROX(scalar1(), copy());
-  copy = scalar1;
-  VERIFY_IS_NOT_EQUAL(scalar1.data(), copy.data());
-  VERIFY_IS_APPROX(scalar1(), copy());
-
-  TensorFixedSize<float, Sizes<> > scalar3 = scalar1.sqrt();
-  TensorFixedSize<float, Sizes<>, RowMajor> scalar4 = scalar2.sqrt();
-  VERIFY_IS_EQUAL(scalar3.rank(), 0);
-  VERIFY_IS_APPROX(scalar3(), sqrtf(7.0));
-  VERIFY_IS_APPROX(scalar4(), sqrtf(13.0));
-
-  scalar3 = scalar1 + scalar2;
-  VERIFY_IS_APPROX(scalar3(), 7.0f + 13.0f);
-}
-
-static void test_1d() {
-  TensorFixedSize<float, Sizes<6> > vec1;
-  TensorFixedSize<float, Sizes<6>, RowMajor> vec2;
-
-  VERIFY_IS_EQUAL((vec1.size()), 6);
-  //  VERIFY_IS_EQUAL((vec1.dimensions()[0]), 6);
-  //  VERIFY_IS_EQUAL((vec1.dimension(0)), 6);
-
-  vec1(0) = 4.0;
-  vec2(0) = 0.0;
-  vec1(1) = 8.0;
-  vec2(1) = 1.0;
-  vec1(2) = 15.0;
-  vec2(2) = 2.0;
-  vec1(3) = 16.0;
-  vec2(3) = 3.0;
-  vec1(4) = 23.0;
-  vec2(4) = 4.0;
-  vec1(5) = 42.0;
-  vec2(5) = 5.0;
-
-  // Test against shallow copy.
-  TensorFixedSize<float, Sizes<6> > copy = vec1;
-  VERIFY_IS_NOT_EQUAL(vec1.data(), copy.data());
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_APPROX(vec1(i), copy(i));
-  }
-  copy = vec1;
-  VERIFY_IS_NOT_EQUAL(vec1.data(), copy.data());
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_APPROX(vec1(i), copy(i));
-  }
-
-  TensorFixedSize<float, Sizes<6> > vec3 = vec1.sqrt();
-  TensorFixedSize<float, Sizes<6>, RowMajor> vec4 = vec2.sqrt();
-
-  VERIFY_IS_EQUAL((vec3.size()), 6);
-  VERIFY_IS_EQUAL(vec3.rank(), 1);
-  //  VERIFY_IS_EQUAL((vec3.dimensions()[0]), 6);
-  //  VERIFY_IS_EQUAL((vec3.dimension(0)), 6);
-
-  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
-  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
-  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0));
-  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0));
-  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
-  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
-
-  VERIFY_IS_APPROX(vec4(0), sqrtf(0.0));
-  VERIFY_IS_APPROX(vec4(1), sqrtf(1.0));
-  VERIFY_IS_APPROX(vec4(2), sqrtf(2.0));
-  VERIFY_IS_APPROX(vec4(3), sqrtf(3.0));
-  VERIFY_IS_APPROX(vec4(4), sqrtf(4.0));
-  VERIFY_IS_APPROX(vec4(5), sqrtf(5.0));
-
-  vec3 = vec1 + vec2;
-  VERIFY_IS_APPROX(vec3(0), 4.0f + 0.0f);
-  VERIFY_IS_APPROX(vec3(1), 8.0f + 1.0f);
-  VERIFY_IS_APPROX(vec3(2), 15.0f + 2.0f);
-  VERIFY_IS_APPROX(vec3(3), 16.0f + 3.0f);
-  VERIFY_IS_APPROX(vec3(4), 23.0f + 4.0f);
-  VERIFY_IS_APPROX(vec3(5), 42.0f + 5.0f);
-}
-
-static void test_tensor_map() {
-  TensorFixedSize<float, Sizes<6> > vec1;
-  TensorFixedSize<float, Sizes<6>, RowMajor> vec2;
-
-  vec1(0) = 4.0;
-  vec2(0) = 0.0;
-  vec1(1) = 8.0;
-  vec2(1) = 1.0;
-  vec1(2) = 15.0;
-  vec2(2) = 2.0;
-  vec1(3) = 16.0;
-  vec2(3) = 3.0;
-  vec1(4) = 23.0;
-  vec2(4) = 4.0;
-  vec1(5) = 42.0;
-  vec2(5) = 5.0;
-
-  float data3[6];
-  TensorMap<TensorFixedSize<float, Sizes<6> > > vec3(data3, 6);
-  vec3 = vec1.sqrt() + vec2;
-
-  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
-  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0) + 1.0f);
-  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0) + 2.0f);
-  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0) + 3.0f);
-  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0) + 4.0f);
-  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0) + 5.0f);
-}
-
-static void test_2d() {
-  float data1[6];
-  TensorMap<TensorFixedSize<float, Sizes<2, 3> > > mat1(data1, 2, 3);
-  float data2[6];
-  TensorMap<TensorFixedSize<float, Sizes<2, 3>, RowMajor> > mat2(data2, 2, 3);
-
-  VERIFY_IS_EQUAL((mat1.size()), 2 * 3);
-  VERIFY_IS_EQUAL(mat1.rank(), 2);
-  //  VERIFY_IS_EQUAL((mat1.dimension(0)), 2);
-  //  VERIFY_IS_EQUAL((mat1.dimension(1)), 3);
-
-  mat1(0, 0) = 0.0;
-  mat1(0, 1) = 1.0;
-  mat1(0, 2) = 2.0;
-  mat1(1, 0) = 3.0;
-  mat1(1, 1) = 4.0;
-  mat1(1, 2) = 5.0;
-
-  mat2(0, 0) = -0.0;
-  mat2(0, 1) = -1.0;
-  mat2(0, 2) = -2.0;
-  mat2(1, 0) = -3.0;
-  mat2(1, 1) = -4.0;
-  mat2(1, 2) = -5.0;
-
-  TensorFixedSize<float, Sizes<2, 3> > mat3;
-  TensorFixedSize<float, Sizes<2, 3>, RowMajor> mat4;
-  mat3 = mat1.abs();
-  mat4 = mat2.abs();
-
-  VERIFY_IS_EQUAL((mat3.size()), 2 * 3);
-  //  VERIFY_IS_EQUAL((mat3.dimension(0)), 2);
-  //  VERIFY_IS_EQUAL((mat3.dimension(1)), 3);
-
-  VERIFY_IS_APPROX(mat3(0, 0), 0.0f);
-  VERIFY_IS_APPROX(mat3(0, 1), 1.0f);
-  VERIFY_IS_APPROX(mat3(0, 2), 2.0f);
-  VERIFY_IS_APPROX(mat3(1, 0), 3.0f);
-  VERIFY_IS_APPROX(mat3(1, 1), 4.0f);
-  VERIFY_IS_APPROX(mat3(1, 2), 5.0f);
-
-  VERIFY_IS_APPROX(mat4(0, 0), 0.0f);
-  VERIFY_IS_APPROX(mat4(0, 1), 1.0f);
-  VERIFY_IS_APPROX(mat4(0, 2), 2.0f);
-  VERIFY_IS_APPROX(mat4(1, 0), 3.0f);
-  VERIFY_IS_APPROX(mat4(1, 1), 4.0f);
-  VERIFY_IS_APPROX(mat4(1, 2), 5.0f);
-}
-
-static void test_3d() {
-  TensorFixedSize<float, Sizes<2, 3, 7> > mat1;
-  TensorFixedSize<float, Sizes<2, 3, 7>, RowMajor> mat2;
-
-  VERIFY_IS_EQUAL((mat1.size()), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(mat1.rank(), 3);
-  //  VERIFY_IS_EQUAL((mat1.dimension(0)), 2);
-  //  VERIFY_IS_EQUAL((mat1.dimension(1)), 3);
-  //  VERIFY_IS_EQUAL((mat1.dimension(2)), 7);
-
-  float val = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        mat2(i, j, k) = val;
-        val += 1.0f;
-      }
-    }
-  }
-
-  TensorFixedSize<float, Sizes<2, 3, 7> > mat3;
-  mat3 = mat1.sqrt();
-  TensorFixedSize<float, Sizes<2, 3, 7>, RowMajor> mat4;
-  mat4 = mat2.sqrt();
-
-  VERIFY_IS_EQUAL((mat3.size()), 2 * 3 * 7);
-  //  VERIFY_IS_EQUAL((mat3.dimension(0)), 2);
-  //  VERIFY_IS_EQUAL((mat3.dimension(1)), 3);
-  //  VERIFY_IS_EQUAL((mat3.dimension(2)), 7);
-
-  val = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat3(i, j, k), sqrtf(val));
-        VERIFY_IS_APPROX(mat4(i, j, k), sqrtf(val));
-        val += 1.0f;
-      }
-    }
-  }
-}
-
-static void test_array() {
-  TensorFixedSize<float, Sizes<2, 3, 7> > mat1;
-  float val = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        val += 1.0f;
-      }
-    }
-  }
-
-  TensorFixedSize<float, Sizes<2, 3, 7> > mat3;
-  mat3 = mat1.pow(3.5f);
-
-  val = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat3(i, j, k), powf(val, 3.5f));
-        val += 1.0f;
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_fixed_size) {
-  CALL_SUBTEST(test_0d());
-  CALL_SUBTEST(test_1d());
-  CALL_SUBTEST(test_tensor_map());
-  CALL_SUBTEST(test_2d());
-  CALL_SUBTEST(test_3d());
-  CALL_SUBTEST(test_array());
-}
diff --git a/unsupported/test/cxx11_tensor_forced_eval.cpp b/unsupported/test/cxx11_tensor_forced_eval.cpp
deleted file mode 100644
index 5ceac39..0000000
--- a/unsupported/test/cxx11_tensor_forced_eval.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Core>
-#include <Eigen/Tensor>
-
-using Eigen::MatrixXf;
-using Eigen::Tensor;
-
-static void test_simple() {
-  MatrixXf m1(3, 3);
-  MatrixXf m2(3, 3);
-  m1.setRandom();
-  m2.setRandom();
-
-  TensorMap<Tensor<float, 2> > mat1(m1.data(), 3, 3);
-  TensorMap<Tensor<float, 2> > mat2(m2.data(), 3, 3);
-
-  Tensor<float, 2> mat3(3, 3);
-  mat3 = mat1;
-
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims;
-  dims[0] = DimPair(1, 0);
-
-  mat3 = mat3.contract(mat2, dims).eval();
-
-  VERIFY_IS_APPROX(mat3(0, 0), (m1 * m2).eval()(0, 0));
-  VERIFY_IS_APPROX(mat3(0, 1), (m1 * m2).eval()(0, 1));
-  VERIFY_IS_APPROX(mat3(0, 2), (m1 * m2).eval()(0, 2));
-  VERIFY_IS_APPROX(mat3(1, 0), (m1 * m2).eval()(1, 0));
-  VERIFY_IS_APPROX(mat3(1, 1), (m1 * m2).eval()(1, 1));
-  VERIFY_IS_APPROX(mat3(1, 2), (m1 * m2).eval()(1, 2));
-  VERIFY_IS_APPROX(mat3(2, 0), (m1 * m2).eval()(2, 0));
-  VERIFY_IS_APPROX(mat3(2, 1), (m1 * m2).eval()(2, 1));
-  VERIFY_IS_APPROX(mat3(2, 2), (m1 * m2).eval()(2, 2));
-}
-
-static void test_const() {
-  MatrixXf input(3, 3);
-  input.setRandom();
-  MatrixXf output = input;
-  output.rowwise() -= input.colwise().maxCoeff();
-
-  Eigen::array<int, 1> depth_dim;
-  depth_dim[0] = 0;
-  Tensor<float, 2>::Dimensions dims2d;
-  dims2d[0] = 1;
-  dims2d[1] = 3;
-  Eigen::array<int, 2> bcast;
-  bcast[0] = 3;
-  bcast[1] = 1;
-  const TensorMap<const Tensor<float, 2> > input_tensor(input.data(), 3, 3);
-  Tensor<float, 2> output_tensor =
-      (input_tensor - input_tensor.maximum(depth_dim).eval().reshape(dims2d).broadcast(bcast));
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_APPROX(output(i, j), output_tensor(i, j));
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_forced_eval) {
-  CALL_SUBTEST(test_simple());
-  CALL_SUBTEST(test_const());
-}
diff --git a/unsupported/test/cxx11_tensor_forced_eval_sycl.cpp b/unsupported/test/cxx11_tensor_forced_eval_sycl.cpp
deleted file mode 100644
index 7c727d4..0000000
--- a/unsupported/test/cxx11_tensor_forced_eval_sycl.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-template <typename DataType, int DataLayout, typename IndexType>
-void test_forced_eval_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 100;
-  IndexType sizeDim2 = 20;
-  IndexType sizeDim3 = 20;
-  Eigen::array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
-  Eigen::Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange);
-  Eigen::Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
-
-  DataType* gpu_in1_data =
-      static_cast<DataType*>(sycl_device.allocate(in1.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_in2_data =
-      static_cast<DataType*>(sycl_device.allocate(in2.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(out.dimensions().TotalSize() * sizeof(DataType)));
-
-  in1 = in1.random() + in1.constant(static_cast<DataType>(10.0f));
-  in2 = in2.random() + in2.constant(static_cast<DataType>(10.0f));
-
-  // creating TensorMap from tensor
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, tensorRange);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, tensorRange);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 3, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
-  sycl_device.memcpyHostToDevice(gpu_in1_data, in1.data(), (in1.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.dimensions().TotalSize()) * sizeof(DataType));
-  /// c=(a+b)*b
-  gpu_out.device(sycl_device) = (gpu_in1 + gpu_in2).eval() * gpu_in2;
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.dimensions().TotalSize()) * sizeof(DataType));
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) + in2(i, j, k)) * in2(i, j, k));
-      }
-    }
-  }
-  printf("(a+b)*b Test Passed\n");
-  sycl_device.deallocate(gpu_in1_data);
-  sycl_device.deallocate(gpu_in2_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, typename Dev_selector>
-void tensorForced_evalperDevice(Dev_selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_forced_eval_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_forced_eval_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_forced_eval_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(tensorForced_evalperDevice<float>(device));
-    CALL_SUBTEST(tensorForced_evalperDevice<half>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_generator.cpp b/unsupported/test/cxx11_tensor_generator.cpp
deleted file mode 100644
index d380985..0000000
--- a/unsupported/test/cxx11_tensor_generator.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-struct Generator1D {
-  Generator1D() {}
-
-  float operator()(const array<Eigen::DenseIndex, 1>& coordinates) const { return coordinates[0]; }
-};
-
-template <int DataLayout>
-static void test_1D() {
-  Tensor<float, 1> vec(6);
-  Tensor<float, 1> result = vec.generate(Generator1D());
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(result(i), i);
-  }
-}
-
-struct Generator2D {
-  Generator2D() {}
-
-  float operator()(const array<Eigen::DenseIndex, 2>& coordinates) const {
-    return 3 * coordinates[0] + 11 * coordinates[1];
-  }
-};
-
-template <int DataLayout>
-static void test_2D() {
-  Tensor<float, 2> matrix(512, 512);
-  Tensor<float, 2> result = matrix.generate(Generator2D());
-
-  for (int i = 0; i < 512; ++i) {
-    for (int j = 0; j < 512; ++j) {
-      VERIFY_IS_EQUAL(result(i, j), 3 * i + 11 * j);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_gaussian() {
-  int rows = 32;
-  int cols = 48;
-  array<float, 2> means;
-  means[0] = rows / 2.0f;
-  means[1] = cols / 2.0f;
-  array<float, 2> std_devs;
-  std_devs[0] = 3.14f;
-  std_devs[1] = 2.7f;
-  internal::GaussianGenerator<float, Eigen::DenseIndex, 2> gaussian_gen(means, std_devs);
-
-  Tensor<float, 2> matrix(rows, cols);
-  Tensor<float, 2> result = matrix.generate(gaussian_gen);
-
-  for (int i = 0; i < rows; ++i) {
-    for (int j = 0; j < cols; ++j) {
-      float g_rows = powf(rows / 2.0f - i, 2) / (3.14f * 3.14f) * 0.5f;
-      float g_cols = powf(cols / 2.0f - j, 2) / (2.7f * 2.7f) * 0.5f;
-      float gaussian = expf(-g_rows - g_cols);
-      VERIFY_IS_EQUAL(result(i, j), gaussian);
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_generator) {
-  CALL_SUBTEST(test_1D<ColMajor>());
-  CALL_SUBTEST(test_1D<RowMajor>());
-  CALL_SUBTEST(test_2D<ColMajor>());
-  CALL_SUBTEST(test_2D<RowMajor>());
-  CALL_SUBTEST(test_gaussian<ColMajor>());
-  CALL_SUBTEST(test_gaussian<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_generator_sycl.cpp b/unsupported/test/cxx11_tensor_generator_sycl.cpp
deleted file mode 100644
index 8879b58..0000000
--- a/unsupported/test/cxx11_tensor_generator_sycl.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-static const float error_threshold = 1e-8f;
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-struct Generator1D {
-  Generator1D() {}
-
-  float operator()(const array<Eigen::DenseIndex, 1>& coordinates) const { return coordinates[0]; }
-};
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_1D_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 6;
-  array<IndexType, 1> tensorRange = {{sizeDim1}};
-  Tensor<DataType, 1, DataLayout, IndexType> vec(tensorRange);
-  Tensor<DataType, 1, DataLayout, IndexType> result(tensorRange);
-
-  const size_t tensorBuffSize = vec.size() * sizeof(DataType);
-  DataType* gpu_data_vec = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_result = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-
-  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> gpu_vec(gpu_data_vec, tensorRange);
-  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> gpu_result(gpu_data_result, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_vec, vec.data(), tensorBuffSize);
-  gpu_result.device(sycl_device) = gpu_vec.generate(Generator1D());
-  sycl_device.memcpyDeviceToHost(result.data(), gpu_data_result, tensorBuffSize);
-
-  for (IndexType i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(result(i), i);
-  }
-}
-
-struct Generator2D {
-  Generator2D() {}
-
-  float operator()(const array<Eigen::DenseIndex, 2>& coordinates) const {
-    return 3 * coordinates[0] + 11 * coordinates[1];
-  }
-};
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_2D_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 5;
-  IndexType sizeDim2 = 7;
-  array<IndexType, 2> tensorRange = {{sizeDim1, sizeDim2}};
-  Tensor<DataType, 2, DataLayout, IndexType> matrix(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> result(tensorRange);
-
-  const size_t tensorBuffSize = matrix.size() * sizeof(DataType);
-  DataType* gpu_data_matrix = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_result = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_matrix(gpu_data_matrix, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_result(gpu_data_result, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_matrix, matrix.data(), tensorBuffSize);
-  gpu_result.device(sycl_device) = gpu_matrix.generate(Generator2D());
-  sycl_device.memcpyDeviceToHost(result.data(), gpu_data_result, tensorBuffSize);
-
-  for (IndexType i = 0; i < 5; ++i) {
-    for (IndexType j = 0; j < 5; ++j) {
-      VERIFY_IS_EQUAL(result(i, j), 3 * i + 11 * j);
-    }
-  }
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_gaussian_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType rows = 32;
-  IndexType cols = 48;
-  array<DataType, 2> means;
-  means[0] = rows / 2.0f;
-  means[1] = cols / 2.0f;
-  array<DataType, 2> std_devs;
-  std_devs[0] = 3.14f;
-  std_devs[1] = 2.7f;
-  internal::GaussianGenerator<DataType, Eigen::DenseIndex, 2> gaussian_gen(means, std_devs);
-
-  array<IndexType, 2> tensorRange = {{rows, cols}};
-  Tensor<DataType, 2, DataLayout, IndexType> matrix(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> result(tensorRange);
-
-  const size_t tensorBuffSize = matrix.size() * sizeof(DataType);
-  DataType* gpu_data_matrix = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_result = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_matrix(gpu_data_matrix, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_result(gpu_data_result, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_matrix, matrix.data(), tensorBuffSize);
-  gpu_result.device(sycl_device) = gpu_matrix.generate(gaussian_gen);
-  sycl_device.memcpyDeviceToHost(result.data(), gpu_data_result, tensorBuffSize);
-
-  for (IndexType i = 0; i < rows; ++i) {
-    for (IndexType j = 0; j < cols; ++j) {
-      DataType g_rows = powf(rows / 2.0f - i, 2) / (3.14f * 3.14f) * 0.5f;
-      DataType g_cols = powf(cols / 2.0f - j, 2) / (2.7f * 2.7f) * 0.5f;
-      DataType gaussian = expf(-g_rows - g_cols);
-      Eigen::internal::isApprox(result(i, j), gaussian, error_threshold);
-    }
-  }
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_generator_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_1D_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_1D_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_2D_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_2D_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_gaussian_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_gaussian_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_generator_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_generator_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_gpu.cu b/unsupported/test/cxx11_tensor_gpu.cu
deleted file mode 100644
index d96e1b2..0000000
--- a/unsupported/test/cxx11_tensor_gpu.cu
+++ /dev/null
@@ -1,1561 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-void test_gpu_nullary() {
-  Tensor<float, 1, 0, int> in1(2);
-  Tensor<float, 1, 0, int> in2(2);
-  in1.setRandom();
-  in2.setRandom();
-
-  std::size_t tensor_bytes = in1.size() * sizeof(float);
-
-  float* d_in1;
-  float* d_in2;
-  gpuMalloc((void**)(&d_in1), tensor_bytes);
-  gpuMalloc((void**)(&d_in2), tensor_bytes);
-  gpuMemcpy(d_in1, in1.data(), tensor_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in2, in2.data(), tensor_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1, 0, int>, Eigen::Aligned> gpu_in1(d_in1, 2);
-  Eigen::TensorMap<Eigen::Tensor<float, 1, 0, int>, Eigen::Aligned> gpu_in2(d_in2, 2);
-
-  gpu_in1.device(gpu_device) = gpu_in1.constant(3.14f);
-  gpu_in2.device(gpu_device) = gpu_in2.random();
-
-  Tensor<float, 1, 0, int> new1(2);
-  Tensor<float, 1, 0, int> new2(2);
-
-  assert(gpuMemcpyAsync(new1.data(), d_in1, tensor_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuMemcpyAsync(new2.data(), d_in2, tensor_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 2; ++i) {
-    VERIFY_IS_APPROX(new1(i), 3.14f);
-    VERIFY_IS_NOT_EQUAL(new2(i), in2(i));
-  }
-
-  gpuFree(d_in1);
-  gpuFree(d_in2);
-}
-
-// Tests that there are no indexing overflows when computing tensors with the
-// max representable size.
-template <typename IndexType, IndexType N = (std::numeric_limits<IndexType>::max)()>
-void test_gpu_nullary_max_size() {
-  typedef int8_t DataType;
-  typedef Tensor<DataType, 1, 0, IndexType> TensorType;
-  typedef Eigen::array<IndexType, 1> ArrayType;
-
-  const IndexType n = N;
-  TensorType in1((ArrayType(n)));
-  in1.setZero();
-
-  std::size_t in1_bytes = in1.size() * sizeof(DataType);
-
-  DataType* d_in1;
-  gpuMalloc((void**)(&d_in1), in1_bytes);
-
-  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<TensorType> gpu_in1(d_in1, ArrayType(n));
-
-  gpu_in1.device(gpu_device) = gpu_in1.constant(123);
-
-  TensorType new1((ArrayType(n)));
-
-  assert(gpuMemcpyAsync(new1.data(), d_in1, in1_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (IndexType i = 0; i < n; ++i) {
-    VERIFY_IS_EQUAL(new1(ArrayType(i)), 123);
-  }
-
-  gpuFree(d_in1);
-}
-
-void test_gpu_elementwise_small() {
-  Tensor<float, 1> in1(Eigen::array<Eigen::DenseIndex, 1>{2});
-  Tensor<float, 1> in2(Eigen::array<Eigen::DenseIndex, 1>{2});
-  Tensor<float, 1> out(Eigen::array<Eigen::DenseIndex, 1>{2});
-  in1.setRandom();
-  in2.setRandom();
-
-  std::size_t in1_bytes = in1.size() * sizeof(float);
-  std::size_t in2_bytes = in2.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_in1;
-  float* d_in2;
-  float* d_out;
-  gpuMalloc((void**)(&d_in1), in1_bytes);
-  gpuMalloc((void**)(&d_in2), in2_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in2, in2.data(), in2_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_in1(d_in1, Eigen::array<Eigen::DenseIndex, 1>{2});
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_in2(d_in2, Eigen::array<Eigen::DenseIndex, 1>{2});
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_out(d_out, Eigen::array<Eigen::DenseIndex, 1>{2});
-
-  gpu_out.device(gpu_device) = gpu_in1 + gpu_in2;
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 2; ++i) {
-    VERIFY_IS_APPROX(out(Eigen::array<Eigen::DenseIndex, 1>{i}),
-                     in1(Eigen::array<Eigen::DenseIndex, 1>{i}) + in2(Eigen::array<Eigen::DenseIndex, 1>{i}));
-  }
-
-  gpuFree(d_in1);
-  gpuFree(d_in2);
-  gpuFree(d_out);
-}
-
-void test_gpu_elementwise() {
-  Tensor<float, 3> in1(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  Tensor<float, 3> in2(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  Tensor<float, 3> in3(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  Tensor<float, 3> out(Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  in1.setRandom();
-  in2.setRandom();
-  in3.setRandom();
-
-  std::size_t in1_bytes = in1.size() * sizeof(float);
-  std::size_t in2_bytes = in2.size() * sizeof(float);
-  std::size_t in3_bytes = in3.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_in1;
-  float* d_in2;
-  float* d_in3;
-  float* d_out;
-  gpuMalloc((void**)(&d_in1), in1_bytes);
-  gpuMalloc((void**)(&d_in2), in2_bytes);
-  gpuMalloc((void**)(&d_in3), in3_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in2, in2.data(), in2_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in3, in3.data(), in3_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_in1(d_in1, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_in2(d_in2, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_in3(d_in3, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-  Eigen::TensorMap<Eigen::Tensor<float, 3> > gpu_out(d_out, Eigen::array<Eigen::DenseIndex, 3>{72, 53, 97});
-
-  gpu_out.device(gpu_device) = gpu_in1 + gpu_in2 * gpu_in3;
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 53; ++j) {
-      for (int k = 0; k < 97; ++k) {
-        VERIFY_IS_APPROX(
-            out(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}),
-            in1(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}) +
-                in2(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}) * in3(Eigen::array<Eigen::DenseIndex, 3>{i, j, k}));
-      }
-    }
-  }
-
-  gpuFree(d_in1);
-  gpuFree(d_in2);
-  gpuFree(d_in3);
-  gpuFree(d_out);
-}
-
-void test_gpu_props() {
-  Tensor<float, 1> in1(200);
-  Tensor<bool, 1> out(200);
-  in1.setRandom();
-
-  std::size_t in1_bytes = in1.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(bool);
-
-  float* d_in1;
-  bool* d_out;
-  gpuMalloc((void**)(&d_in1), in1_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_in1(d_in1, 200);
-  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_out(d_out, 200);
-
-  gpu_out.device(gpu_device) = (gpu_in1.isnan)();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 200; ++i) {
-    VERIFY_IS_EQUAL(out(i), (std::isnan)(in1(i)));
-  }
-
-  gpuFree(d_in1);
-  gpuFree(d_out);
-}
-
-void test_gpu_reduction() {
-  Tensor<float, 4> in1(72, 53, 97, 113);
-  Tensor<float, 2> out(72, 97);
-  in1.setRandom();
-
-  std::size_t in1_bytes = in1.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_in1;
-  float* d_out;
-  gpuMalloc((void**)(&d_in1), in1_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_in1, in1.data(), in1_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 4> > gpu_in1(d_in1, 72, 53, 97, 113);
-  Eigen::TensorMap<Eigen::Tensor<float, 2> > gpu_out(d_out, 72, 97);
-
-  array<Eigen::DenseIndex, 2> reduction_axis;
-  reduction_axis[0] = 1;
-  reduction_axis[1] = 3;
-
-  gpu_out.device(gpu_device) = gpu_in1.maximum(reduction_axis);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 97; ++j) {
-      float expected = 0;
-      for (int k = 0; k < 53; ++k) {
-        for (int l = 0; l < 113; ++l) {
-          expected = std::max<float>(expected, in1(i, k, j, l));
-        }
-      }
-      VERIFY_IS_APPROX(out(i, j), expected);
-    }
-  }
-
-  gpuFree(d_in1);
-  gpuFree(d_out);
-}
-
-template <int DataLayout>
-void test_gpu_contraction() {
-  // with these dimensions, the output has 300 * 140 elements, which is
-  // more than 30 * 1024, which is the number of threads in blocks on
-  // a 15 SM GK110 GPU
-  Tensor<float, 4, DataLayout> t_left(6, 50, 3, 31);
-  Tensor<float, 5, DataLayout> t_right(Eigen::array<Eigen::DenseIndex, 5>{3, 31, 7, 20, 1});
-  Tensor<float, 5, DataLayout> t_result(Eigen::array<Eigen::DenseIndex, 5>{6, 50, 7, 20, 1});
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  std::size_t t_left_bytes = t_left.size() * sizeof(float);
-  std::size_t t_right_bytes = t_right.size() * sizeof(float);
-  std::size_t t_result_bytes = t_result.size() * sizeof(float);
-
-  float* d_t_left;
-  float* d_t_right;
-  float* d_t_result;
-
-  gpuMalloc((void**)(&d_t_left), t_left_bytes);
-  gpuMalloc((void**)(&d_t_right), t_right_bytes);
-  gpuMalloc((void**)(&d_t_result), t_result_bytes);
-
-  gpuMemcpy(d_t_left, t_left.data(), t_left_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_t_right, t_right.data(), t_right_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_t_left(d_t_left, 6, 50, 3, 31);
-  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_t_right(d_t_right, 3, 31, 7, 20, 1);
-  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_t_result(d_t_result, 6, 50, 7, 20, 1);
-
-  typedef Eigen::Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> > MapXf;
-  MapXf m_left(t_left.data(), 300, 93);
-  MapXf m_right(t_right.data(), 93, 140);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(300, 140);
-
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 2> dims;
-  dims[0] = DimPair(2, 0);
-  dims[1] = DimPair(3, 1);
-
-  m_result = m_left * m_right;
-  gpu_t_result.device(gpu_device) = gpu_t_left.contract(gpu_t_right, dims);
-
-  gpuMemcpy(t_result.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
-
-  for (DenseIndex i = 0; i < t_result.size(); i++) {
-    if (fabs(t_result.data()[i] - m_result.data()[i]) >= 1e-4f) {
-      std::cout << "mismatch detected at index " << i << ": " << t_result.data()[i] << " vs " << m_result.data()[i]
-                << std::endl;
-      assert(false);
-    }
-  }
-
-  gpuFree(d_t_left);
-  gpuFree(d_t_right);
-  gpuFree(d_t_result);
-}
-
-template <int DataLayout>
-void test_gpu_convolution_1d() {
-  Tensor<float, 4, DataLayout> input(74, 37, 11, 137);
-  Tensor<float, 1, DataLayout> kernel(4);
-  Tensor<float, 4, DataLayout> out(74, 34, 11, 137);
-  input = input.constant(10.0f) + input.random();
-  kernel = kernel.constant(7.0f) + kernel.random();
-
-  std::size_t input_bytes = input.size() * sizeof(float);
-  std::size_t kernel_bytes = kernel.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_input;
-  float* d_kernel;
-  float* d_out;
-  gpuMalloc((void**)(&d_input), input_bytes);
-  gpuMalloc((void**)(&d_kernel), kernel_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_input(d_input, 74, 37, 11, 137);
-  Eigen::TensorMap<Eigen::Tensor<float, 1, DataLayout> > gpu_kernel(d_kernel, 4);
-  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_out(d_out, 74, 34, 11, 137);
-
-  Eigen::array<Eigen::DenseIndex, 1> dims{1};
-  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 74; ++i) {
-    for (int j = 0; j < 34; ++j) {
-      for (int k = 0; k < 11; ++k) {
-        for (int l = 0; l < 137; ++l) {
-          const float result = out(i, j, k, l);
-          const float expected = input(i, j + 0, k, l) * kernel(0) + input(i, j + 1, k, l) * kernel(1) +
-                                 input(i, j + 2, k, l) * kernel(2) + input(i, j + 3, k, l) * kernel(3);
-          VERIFY_IS_APPROX(result, expected);
-        }
-      }
-    }
-  }
-
-  gpuFree(d_input);
-  gpuFree(d_kernel);
-  gpuFree(d_out);
-}
-
-void test_gpu_convolution_inner_dim_col_major_1d() {
-  Tensor<float, 4, ColMajor> input(74, 9, 11, 7);
-  Tensor<float, 1, ColMajor> kernel(4);
-  Tensor<float, 4, ColMajor> out(71, 9, 11, 7);
-  input = input.constant(10.0f) + input.random();
-  kernel = kernel.constant(7.0f) + kernel.random();
-
-  std::size_t input_bytes = input.size() * sizeof(float);
-  std::size_t kernel_bytes = kernel.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_input;
-  float* d_kernel;
-  float* d_out;
-  gpuMalloc((void**)(&d_input), input_bytes);
-  gpuMalloc((void**)(&d_kernel), kernel_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 4, ColMajor> > gpu_input(d_input, 74, 9, 11, 7);
-  Eigen::TensorMap<Eigen::Tensor<float, 1, ColMajor> > gpu_kernel(d_kernel, 4);
-  Eigen::TensorMap<Eigen::Tensor<float, 4, ColMajor> > gpu_out(d_out, 71, 9, 11, 7);
-
-  Eigen::array<Eigen::DenseIndex, 1> dims{0};
-  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 71; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 11; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          const float result = out(i, j, k, l);
-          const float expected = input(i + 0, j, k, l) * kernel(0) + input(i + 1, j, k, l) * kernel(1) +
-                                 input(i + 2, j, k, l) * kernel(2) + input(i + 3, j, k, l) * kernel(3);
-          VERIFY_IS_APPROX(result, expected);
-        }
-      }
-    }
-  }
-
-  gpuFree(d_input);
-  gpuFree(d_kernel);
-  gpuFree(d_out);
-}
-
-void test_gpu_convolution_inner_dim_row_major_1d() {
-  Tensor<float, 4, RowMajor> input(7, 9, 11, 74);
-  Tensor<float, 1, RowMajor> kernel(4);
-  Tensor<float, 4, RowMajor> out(7, 9, 11, 71);
-  input = input.constant(10.0f) + input.random();
-  kernel = kernel.constant(7.0f) + kernel.random();
-
-  std::size_t input_bytes = input.size() * sizeof(float);
-  std::size_t kernel_bytes = kernel.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_input;
-  float* d_kernel;
-  float* d_out;
-  gpuMalloc((void**)(&d_input), input_bytes);
-  gpuMalloc((void**)(&d_kernel), kernel_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 4, RowMajor> > gpu_input(d_input, 7, 9, 11, 74);
-  Eigen::TensorMap<Eigen::Tensor<float, 1, RowMajor> > gpu_kernel(d_kernel, 4);
-  Eigen::TensorMap<Eigen::Tensor<float, 4, RowMajor> > gpu_out(d_out, 7, 9, 11, 71);
-
-  Eigen::array<Eigen::DenseIndex, 1> dims{3};
-  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 7; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 11; ++k) {
-        for (int l = 0; l < 71; ++l) {
-          const float result = out(i, j, k, l);
-          const float expected = input(i, j, k, l + 0) * kernel(0) + input(i, j, k, l + 1) * kernel(1) +
-                                 input(i, j, k, l + 2) * kernel(2) + input(i, j, k, l + 3) * kernel(3);
-          VERIFY_IS_APPROX(result, expected);
-        }
-      }
-    }
-  }
-
-  gpuFree(d_input);
-  gpuFree(d_kernel);
-  gpuFree(d_out);
-}
-
-template <int DataLayout>
-void test_gpu_convolution_2d() {
-  Tensor<float, 4, DataLayout> input(74, 37, 11, 137);
-  Tensor<float, 2, DataLayout> kernel(3, 4);
-  Tensor<float, 4, DataLayout> out(74, 35, 8, 137);
-  input = input.constant(10.0f) + input.random();
-  kernel = kernel.constant(7.0f) + kernel.random();
-
-  std::size_t input_bytes = input.size() * sizeof(float);
-  std::size_t kernel_bytes = kernel.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_input;
-  float* d_kernel;
-  float* d_out;
-  gpuMalloc((void**)(&d_input), input_bytes);
-  gpuMalloc((void**)(&d_kernel), kernel_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_input(d_input, 74, 37, 11, 137);
-  Eigen::TensorMap<Eigen::Tensor<float, 2, DataLayout> > gpu_kernel(d_kernel, 3, 4);
-  Eigen::TensorMap<Eigen::Tensor<float, 4, DataLayout> > gpu_out(d_out, 74, 35, 8, 137);
-
-  Eigen::array<Eigen::DenseIndex, 2> dims{1, 2};
-  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 74; ++i) {
-    for (int j = 0; j < 35; ++j) {
-      for (int k = 0; k < 8; ++k) {
-        for (int l = 0; l < 137; ++l) {
-          const float result = out(i, j, k, l);
-          const float expected = input(i, j + 0, k + 0, l) * kernel(0, 0) + input(i, j + 1, k + 0, l) * kernel(1, 0) +
-                                 input(i, j + 2, k + 0, l) * kernel(2, 0) + input(i, j + 0, k + 1, l) * kernel(0, 1) +
-                                 input(i, j + 1, k + 1, l) * kernel(1, 1) + input(i, j + 2, k + 1, l) * kernel(2, 1) +
-                                 input(i, j + 0, k + 2, l) * kernel(0, 2) + input(i, j + 1, k + 2, l) * kernel(1, 2) +
-                                 input(i, j + 2, k + 2, l) * kernel(2, 2) + input(i, j + 0, k + 3, l) * kernel(0, 3) +
-                                 input(i, j + 1, k + 3, l) * kernel(1, 3) + input(i, j + 2, k + 3, l) * kernel(2, 3);
-          VERIFY_IS_APPROX(result, expected);
-        }
-      }
-    }
-  }
-
-  gpuFree(d_input);
-  gpuFree(d_kernel);
-  gpuFree(d_out);
-}
-
-template <int DataLayout>
-void test_gpu_convolution_3d() {
-  Tensor<float, 5, DataLayout> input(Eigen::array<Eigen::DenseIndex, 5>{74, 37, 11, 137, 17});
-  Tensor<float, 3, DataLayout> kernel(3, 4, 2);
-  Tensor<float, 5, DataLayout> out(Eigen::array<Eigen::DenseIndex, 5>{74, 35, 8, 136, 17});
-  input = input.constant(10.0f) + input.random();
-  kernel = kernel.constant(7.0f) + kernel.random();
-
-  std::size_t input_bytes = input.size() * sizeof(float);
-  std::size_t kernel_bytes = kernel.size() * sizeof(float);
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_input;
-  float* d_kernel;
-  float* d_out;
-  gpuMalloc((void**)(&d_input), input_bytes);
-  gpuMalloc((void**)(&d_kernel), kernel_bytes);
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  gpuMemcpy(d_input, input.data(), input_bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_kernel, kernel.data(), kernel_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_input(d_input, 74, 37, 11, 137, 17);
-  Eigen::TensorMap<Eigen::Tensor<float, 3, DataLayout> > gpu_kernel(d_kernel, 3, 4, 2);
-  Eigen::TensorMap<Eigen::Tensor<float, 5, DataLayout> > gpu_out(d_out, 74, 35, 8, 136, 17);
-
-  Eigen::array<Eigen::DenseIndex, 3> dims{1, 2, 3};
-  gpu_out.device(gpu_device) = gpu_input.convolve(gpu_kernel, dims);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 74; ++i) {
-    for (int j = 0; j < 35; ++j) {
-      for (int k = 0; k < 8; ++k) {
-        for (int l = 0; l < 136; ++l) {
-          for (int m = 0; m < 17; ++m) {
-            const float result = out(i, j, k, l, m);
-            const float expected = input(i, j + 0, k + 0, l + 0, m) * kernel(0, 0, 0) +
-                                   input(i, j + 1, k + 0, l + 0, m) * kernel(1, 0, 0) +
-                                   input(i, j + 2, k + 0, l + 0, m) * kernel(2, 0, 0) +
-                                   input(i, j + 0, k + 1, l + 0, m) * kernel(0, 1, 0) +
-                                   input(i, j + 1, k + 1, l + 0, m) * kernel(1, 1, 0) +
-                                   input(i, j + 2, k + 1, l + 0, m) * kernel(2, 1, 0) +
-                                   input(i, j + 0, k + 2, l + 0, m) * kernel(0, 2, 0) +
-                                   input(i, j + 1, k + 2, l + 0, m) * kernel(1, 2, 0) +
-                                   input(i, j + 2, k + 2, l + 0, m) * kernel(2, 2, 0) +
-                                   input(i, j + 0, k + 3, l + 0, m) * kernel(0, 3, 0) +
-                                   input(i, j + 1, k + 3, l + 0, m) * kernel(1, 3, 0) +
-                                   input(i, j + 2, k + 3, l + 0, m) * kernel(2, 3, 0) +
-                                   input(i, j + 0, k + 0, l + 1, m) * kernel(0, 0, 1) +
-                                   input(i, j + 1, k + 0, l + 1, m) * kernel(1, 0, 1) +
-                                   input(i, j + 2, k + 0, l + 1, m) * kernel(2, 0, 1) +
-                                   input(i, j + 0, k + 1, l + 1, m) * kernel(0, 1, 1) +
-                                   input(i, j + 1, k + 1, l + 1, m) * kernel(1, 1, 1) +
-                                   input(i, j + 2, k + 1, l + 1, m) * kernel(2, 1, 1) +
-                                   input(i, j + 0, k + 2, l + 1, m) * kernel(0, 2, 1) +
-                                   input(i, j + 1, k + 2, l + 1, m) * kernel(1, 2, 1) +
-                                   input(i, j + 2, k + 2, l + 1, m) * kernel(2, 2, 1) +
-                                   input(i, j + 0, k + 3, l + 1, m) * kernel(0, 3, 1) +
-                                   input(i, j + 1, k + 3, l + 1, m) * kernel(1, 3, 1) +
-                                   input(i, j + 2, k + 3, l + 1, m) * kernel(2, 3, 1);
-            VERIFY_IS_APPROX(result, expected);
-          }
-        }
-      }
-    }
-  }
-
-  gpuFree(d_input);
-  gpuFree(d_kernel);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_lgamma(const Scalar stddev) {
-  Tensor<Scalar, 2> in(72, 97);
-  in.setRandom();
-  in *= in.constant(stddev);
-  Tensor<Scalar, 2> out(72, 97);
-  out.setZero();
-
-  std::size_t bytes = in.size() * sizeof(Scalar);
-
-  Scalar* d_in;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_in(d_in, 72, 97);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 72, 97);
-
-  gpu_out.device(gpu_device) = gpu_in.lgamma();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 97; ++j) {
-      VERIFY_IS_APPROX(out(i, j), (std::lgamma)(in(i, j)));
-    }
-  }
-
-  gpuFree(d_in);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_digamma() {
-  Tensor<Scalar, 1> in(7);
-  Tensor<Scalar, 1> out(7);
-  Tensor<Scalar, 1> expected_out(7);
-  out.setZero();
-
-  in(0) = Scalar(1);
-  in(1) = Scalar(1.5);
-  in(2) = Scalar(4);
-  in(3) = Scalar(-10.5);
-  in(4) = Scalar(10000.5);
-  in(5) = Scalar(0);
-  in(6) = Scalar(-1);
-
-  expected_out(0) = Scalar(-0.5772156649015329);
-  expected_out(1) = Scalar(0.03648997397857645);
-  expected_out(2) = Scalar(1.2561176684318);
-  expected_out(3) = Scalar(2.398239129535781);
-  expected_out(4) = Scalar(9.210340372392849);
-  expected_out(5) = std::numeric_limits<Scalar>::quiet_NaN();
-  expected_out(6) = std::numeric_limits<Scalar>::quiet_NaN();
-
-  std::size_t bytes = in.size() * sizeof(Scalar);
-
-  Scalar* d_in;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 7);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 7);
-
-  gpu_out.device(gpu_device) = gpu_in.digamma();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 7; ++i) {
-    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_zeta() {
-  Tensor<Scalar, 1> in_x(6);
-  Tensor<Scalar, 1> in_q(6);
-  Tensor<Scalar, 1> out(6);
-  Tensor<Scalar, 1> expected_out(6);
-  out.setZero();
-
-  in_x(0) = Scalar(1);
-  in_x(1) = Scalar(1.5);
-  in_x(2) = Scalar(4);
-  in_x(3) = Scalar(-10.5);
-  in_x(4) = Scalar(10000.5);
-  in_x(5) = Scalar(3);
-
-  in_q(0) = Scalar(1.2345);
-  in_q(1) = Scalar(2);
-  in_q(2) = Scalar(1.5);
-  in_q(3) = Scalar(3);
-  in_q(4) = Scalar(1.0001);
-  in_q(5) = Scalar(-2.5);
-
-  expected_out(0) = std::numeric_limits<Scalar>::infinity();
-  expected_out(1) = Scalar(1.61237534869);
-  expected_out(2) = Scalar(0.234848505667);
-  expected_out(3) = std::numeric_limits<Scalar>::quiet_NaN();
-  expected_out(4) = Scalar(0.367879440865);
-  expected_out(5) = Scalar(0.054102025820864097);
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_in_x;
-  Scalar* d_in_q;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in_x), bytes);
-  gpuMalloc((void**)(&d_in_q), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in_q, in_q.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_q(d_in_q, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 6);
-
-  gpu_out.device(gpu_device) = gpu_in_x.zeta(gpu_in_q);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in_x);
-  gpuFree(d_in_q);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_polygamma() {
-  Tensor<Scalar, 1> in_x(7);
-  Tensor<Scalar, 1> in_n(7);
-  Tensor<Scalar, 1> out(7);
-  Tensor<Scalar, 1> expected_out(7);
-  out.setZero();
-
-  in_n(0) = Scalar(1);
-  in_n(1) = Scalar(1);
-  in_n(2) = Scalar(1);
-  in_n(3) = Scalar(17);
-  in_n(4) = Scalar(31);
-  in_n(5) = Scalar(28);
-  in_n(6) = Scalar(8);
-
-  in_x(0) = Scalar(2);
-  in_x(1) = Scalar(3);
-  in_x(2) = Scalar(25.5);
-  in_x(3) = Scalar(4.7);
-  in_x(4) = Scalar(11.8);
-  in_x(5) = Scalar(17.7);
-  in_x(6) = Scalar(30.2);
-
-  expected_out(0) = Scalar(0.644934066848);
-  expected_out(1) = Scalar(0.394934066848);
-  expected_out(2) = Scalar(0.0399946696496);
-  expected_out(3) = Scalar(293.334565435);
-  expected_out(4) = Scalar(0.445487887616);
-  expected_out(5) = Scalar(-2.47810300902e-07);
-  expected_out(6) = Scalar(-8.29668781082e-09);
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_in_x;
-  Scalar* d_in_n;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in_x), bytes);
-  gpuMalloc((void**)(&d_in_n), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in_n, in_n.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 7);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_n(d_in_n, 7);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 7);
-
-  gpu_out.device(gpu_device) = gpu_in_n.polygamma(gpu_in_x);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 7; ++i) {
-    VERIFY_IS_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in_x);
-  gpuFree(d_in_n);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_igamma() {
-  Tensor<Scalar, 2> a(6, 6);
-  Tensor<Scalar, 2> x(6, 6);
-  Tensor<Scalar, 2> out(6, 6);
-  out.setZero();
-
-  Scalar a_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
-  Scalar x_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
-
-  for (int i = 0; i < 6; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      a(i, j) = a_s[i];
-      x(i, j) = x_s[j];
-    }
-  }
-
-  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
-  Scalar igamma_s[][6] = {
-      {0.0, nan, nan, nan, nan, nan},
-      {0.0, 0.6321205588285578, 0.7768698398515702, 0.9816843611112658, 9.999500016666262e-05, 1.0},
-      {0.0, 0.4275932955291202, 0.608374823728911, 0.9539882943107686, 7.522076445089201e-07, 1.0},
-      {0.0, 0.01898815687615381, 0.06564245437845008, 0.5665298796332909, 4.166333347221828e-18, 1.0},
-      {0.0, 0.9999780593618628, 0.9999899967080838, 0.9999996219837988, 0.9991370418689945, 1.0},
-      {0.0, 0.0, 0.0, 0.0, 0.0, 0.5042041932513908}};
-
-  std::size_t bytes = a.size() * sizeof(Scalar);
-
-  Scalar* d_a;
-  Scalar* d_x;
-  Scalar* d_out;
-  assert(gpuMalloc((void**)(&d_a), bytes) == gpuSuccess);
-  assert(gpuMalloc((void**)(&d_x), bytes) == gpuSuccess);
-  assert(gpuMalloc((void**)(&d_out), bytes) == gpuSuccess);
-
-  gpuMemcpy(d_a, a.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_x, x.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_a(d_a, 6, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_x(d_x, 6, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 6, 6);
-
-  gpu_out.device(gpu_device) = gpu_a.igamma(gpu_x);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 6; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      if ((std::isnan)(igamma_s[i][j])) {
-        VERIFY((std::isnan)(out(i, j)));
-      } else {
-        VERIFY_IS_APPROX(out(i, j), igamma_s[i][j]);
-      }
-    }
-  }
-
-  gpuFree(d_a);
-  gpuFree(d_x);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_igammac() {
-  Tensor<Scalar, 2> a(6, 6);
-  Tensor<Scalar, 2> x(6, 6);
-  Tensor<Scalar, 2> out(6, 6);
-  out.setZero();
-
-  Scalar a_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
-  Scalar x_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
-
-  for (int i = 0; i < 6; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      a(i, j) = a_s[i];
-      x(i, j) = x_s[j];
-    }
-  }
-
-  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
-  Scalar igammac_s[][6] = {
-      {nan, nan, nan, nan, nan, nan},
-      {1.0, 0.36787944117144233, 0.22313016014842982, 0.018315638888734182, 0.9999000049998333, 0.0},
-      {1.0, 0.5724067044708798, 0.3916251762710878, 0.04601170568923136, 0.9999992477923555, 0.0},
-      {1.0, 0.9810118431238462, 0.9343575456215499, 0.4334701203667089, 1.0, 0.0},
-      {1.0, 2.1940638138146658e-05, 1.0003291916285e-05, 3.7801620118431334e-07, 0.0008629581310054535, 0.0},
-      {1.0, 1.0, 1.0, 1.0, 1.0, 0.49579580674813944}};
-
-  std::size_t bytes = a.size() * sizeof(Scalar);
-
-  Scalar* d_a;
-  Scalar* d_x;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_a), bytes);
-  gpuMalloc((void**)(&d_x), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_a, a.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_x, x.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_a(d_a, 6, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_x(d_x, 6, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 6, 6);
-
-  gpu_out.device(gpu_device) = gpu_a.igammac(gpu_x);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 6; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      if ((std::isnan)(igammac_s[i][j])) {
-        VERIFY((std::isnan)(out(i, j)));
-      } else {
-        VERIFY_IS_APPROX(out(i, j), igammac_s[i][j]);
-      }
-    }
-  }
-
-  gpuFree(d_a);
-  gpuFree(d_x);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_erf(const Scalar stddev) {
-  Tensor<Scalar, 2> in(72, 97);
-  in.setRandom();
-  in *= in.constant(stddev);
-  Tensor<Scalar, 2> out(72, 97);
-  out.setZero();
-
-  std::size_t bytes = in.size() * sizeof(Scalar);
-
-  Scalar* d_in;
-  Scalar* d_out;
-  assert(gpuMalloc((void**)(&d_in), bytes) == gpuSuccess);
-  assert(gpuMalloc((void**)(&d_out), bytes) == gpuSuccess);
-
-  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_in(d_in, 72, 97);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 72, 97);
-
-  gpu_out.device(gpu_device) = gpu_in.erf();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 97; ++j) {
-      VERIFY_IS_APPROX(out(i, j), (std::erf)(in(i, j)));
-    }
-  }
-
-  gpuFree(d_in);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_erfc(const Scalar stddev) {
-  Tensor<Scalar, 2> in(72, 97);
-  in.setRandom();
-  in *= in.constant(stddev);
-  Tensor<Scalar, 2> out(72, 97);
-  out.setZero();
-
-  std::size_t bytes = in.size() * sizeof(Scalar);
-
-  Scalar* d_in;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in, in.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_in(d_in, 72, 97);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 2> > gpu_out(d_out, 72, 97);
-
-  gpu_out.device(gpu_device) = gpu_in.erfc();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 97; ++j) {
-      VERIFY_IS_APPROX(out(i, j), (std::erfc)(in(i, j)));
-    }
-  }
-
-  gpuFree(d_in);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_ndtri() {
-  Tensor<Scalar, 1> in_x(9);
-  Tensor<Scalar, 1> out(9);
-  Tensor<Scalar, 1> expected_out(9);
-  out.setZero();
-
-  in_x(0) = Scalar(1);
-  in_x(1) = Scalar(0.);
-  in_x(2) = Scalar(0.5);
-  in_x(3) = Scalar(0.2);
-  in_x(4) = Scalar(0.8);
-  in_x(5) = Scalar(0.9);
-  in_x(6) = Scalar(0.1);
-  in_x(7) = Scalar(0.99);
-  in_x(8) = Scalar(0.01);
-
-  expected_out(0) = std::numeric_limits<Scalar>::infinity();
-  expected_out(1) = -std::numeric_limits<Scalar>::infinity();
-  expected_out(2) = Scalar(0.0);
-  expected_out(3) = Scalar(-0.8416212335729142);
-  expected_out(4) = Scalar(0.8416212335729142);
-  expected_out(5) = Scalar(1.2815515655446004);
-  expected_out(6) = Scalar(-1.2815515655446004);
-  expected_out(7) = Scalar(2.3263478740408408);
-  expected_out(8) = Scalar(-2.3263478740408408);
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_in_x;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in_x), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 6);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 6);
-
-  gpu_out.device(gpu_device) = gpu_in_x.ndtri();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in_x);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_betainc() {
-  Tensor<Scalar, 1> in_x(125);
-  Tensor<Scalar, 1> in_a(125);
-  Tensor<Scalar, 1> in_b(125);
-  Tensor<Scalar, 1> out(125);
-  Tensor<Scalar, 1> expected_out(125);
-  out.setZero();
-
-  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
-
-  Array<Scalar, 1, Dynamic> x(125);
-  Array<Scalar, 1, Dynamic> a(125);
-  Array<Scalar, 1, Dynamic> b(125);
-  Array<Scalar, 1, Dynamic> v(125);
-
-  a << 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999,
-      0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379,
-      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-      999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999,
-      999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999,
-      999.999;
-
-  b << 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-      31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999,
-      0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-      31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999,
-      0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999,
-      999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999,
-      31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999,
-      999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-      0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379,
-      31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999;
-
-  x << -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1,
-      0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5,
-      0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1,
-      -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2,
-      0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8,
-      1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1;
-
-  v << nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan,
-      nan, nan, nan, nan, nan, nan, nan, nan, nan, 0.47972119876364683, 0.5, 0.5202788012363533, nan, nan,
-      0.9518683957740043, 0.9789663010413743, 0.9931729188073435, nan, nan, 0.999995949033062, 0.9999999999993698,
-      0.9999999999999999, nan, nan, 0.9999999999999999, 0.9999999999999999, 0.9999999999999999, nan, nan, nan, nan, nan,
-      nan, nan, 0.006827081192655869, 0.0210336989586256, 0.04813160422599567, nan, nan, 0.20014344256217678,
-      0.5000000000000001, 0.7998565574378232, nan, nan, 0.9991401428435834, 0.999999999698403, 0.9999999999999999, nan,
-      nan, 0.9999999999999999, 0.9999999999999999, 0.9999999999999999, nan, nan, nan, nan, nan, nan, nan,
-      1.0646600232370887e-25, 6.301722877826246e-13, 4.050966937974938e-06, nan, nan, 7.864342668429763e-23,
-      3.015969667594166e-10, 0.0008598571564165444, nan, nan, 6.031987710123844e-08, 0.5000000000000007,
-      0.9999999396801229, nan, nan, 0.9999999999999999, 0.9999999999999999, 0.9999999999999999, nan, nan, nan, nan, nan,
-      nan, nan, 0.0, 7.029920380986636e-306, 2.2450728208591345e-101, nan, nan, 0.0, 9.275871147869727e-302,
-      1.2232913026152827e-97, nan, nan, 0.0, 3.0891393081932924e-252, 2.9303043666183996e-60, nan, nan,
-      2.248913486879199e-196, 0.5000000000004947, 0.9999999999999999, nan;
-
-  for (int i = 0; i < 125; ++i) {
-    in_x(i) = x(i);
-    in_a(i) = a(i);
-    in_b(i) = b(i);
-    expected_out(i) = v(i);
-  }
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_in_x;
-  Scalar* d_in_a;
-  Scalar* d_in_b;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in_x), bytes);
-  gpuMalloc((void**)(&d_in_a), bytes);
-  gpuMalloc((void**)(&d_in_b), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in_a, in_a.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_in_b, in_b.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_x(d_in_x, 125);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_a(d_in_a, 125);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in_b(d_in_b, 125);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 125);
-
-  gpu_out.device(gpu_device) = betainc(gpu_in_a, gpu_in_b, gpu_in_x);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 125; ++i) {
-    VERIFY_IS_CWISE_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in_x);
-  gpuFree(d_in_a);
-  gpuFree(d_in_b);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_i0e() {
-  Tensor<Scalar, 1> in_x(21);
-  Tensor<Scalar, 1> out(21);
-  Tensor<Scalar, 1> expected_out(21);
-  out.setZero();
-
-  Array<Scalar, 1, Dynamic> in_x_array(21);
-  Array<Scalar, 1, Dynamic> expected_out_array(21);
-
-  in_x_array << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0,
-      14.0, 16.0, 18.0, 20.0;
-
-  expected_out_array << 0.0897803118848, 0.0947062952128, 0.100544127361, 0.107615251671, 0.116426221213,
-      0.127833337163, 0.143431781857, 0.16665743264, 0.207001921224, 0.308508322554, 1.0, 0.308508322554,
-      0.207001921224, 0.16665743264, 0.143431781857, 0.127833337163, 0.116426221213, 0.107615251671, 0.100544127361,
-      0.0947062952128, 0.0897803118848;
-
-  for (int i = 0; i < 21; ++i) {
-    in_x(i) = in_x_array(i);
-    expected_out(i) = expected_out_array(i);
-  }
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_in;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in, in_x.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 21);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 21);
-
-  gpu_out.device(gpu_device) = gpu_in.bessel_i0e();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 21; ++i) {
-    VERIFY_IS_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_i1e() {
-  Tensor<Scalar, 1> in_x(21);
-  Tensor<Scalar, 1> out(21);
-  Tensor<Scalar, 1> expected_out(21);
-  out.setZero();
-
-  Array<Scalar, 1, Dynamic> in_x_array(21);
-  Array<Scalar, 1, Dynamic> expected_out_array(21);
-
-  in_x_array << -20.0, -18.0, -16.0, -14.0, -12.0, -10.0, -8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0,
-      14.0, 16.0, 18.0, 20.0;
-
-  expected_out_array << -0.0875062221833, -0.092036796872, -0.0973496147565, -0.103697667463, -0.11146429929,
-      -0.121262681384, -0.134142493293, -0.152051459309, -0.178750839502, -0.215269289249, 0.0, 0.215269289249,
-      0.178750839502, 0.152051459309, 0.134142493293, 0.121262681384, 0.11146429929, 0.103697667463, 0.0973496147565,
-      0.092036796872, 0.0875062221833;
-
-  for (int i = 0; i < 21; ++i) {
-    in_x(i) = in_x_array(i);
-    expected_out(i) = expected_out_array(i);
-  }
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_in;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_in), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_in, in_x.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_in(d_in, 21);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 21);
-
-  gpu_out.device(gpu_device) = gpu_in.bessel_i1e();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 21; ++i) {
-    VERIFY_IS_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_in);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_igamma_der_a() {
-  Tensor<Scalar, 1> in_x(30);
-  Tensor<Scalar, 1> in_a(30);
-  Tensor<Scalar, 1> out(30);
-  Tensor<Scalar, 1> expected_out(30);
-  out.setZero();
-
-  Array<Scalar, 1, Dynamic> in_a_array(30);
-  Array<Scalar, 1, Dynamic> in_x_array(30);
-  Array<Scalar, 1, Dynamic> expected_out_array(30);
-
-  // See special_functions.cpp for the Python code that generates the test data.
-
-  in_a_array << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0, 10.0,
-      10.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
-
-  in_x_array << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
-      5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
-      1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
-      10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
-      968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
-
-  expected_out_array << -32.7256441441, -36.4394150514, -9.66467612263, -36.4394150514, -36.4394150514, -1.0891900302,
-      -2.66351229645, -2.48666868596, -0.929700494428, -3.56327722764, -0.455320135314, -0.391437214323,
-      -0.491352055991, -0.350454834292, -0.471773162921, -0.104084440522, -0.0723646747909, -0.0992828975532,
-      -0.121638215446, -0.122619605294, -0.0317670267286, -0.0359974812869, -0.0154359225363, -0.0375775365921,
-      -0.00794899153653, -0.00777303219211, -0.00796085782042, -0.0125850719397, -0.00455500206958, -0.00476436993148;
-
-  for (int i = 0; i < 30; ++i) {
-    in_x(i) = in_x_array(i);
-    in_a(i) = in_a_array(i);
-    expected_out(i) = expected_out_array(i);
-  }
-
-  std::size_t bytes = in_x.size() * sizeof(Scalar);
-
-  Scalar* d_a;
-  Scalar* d_x;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_a), bytes);
-  gpuMalloc((void**)(&d_x), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_a, in_a.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_x, in_x.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_a(d_a, 30);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_x(d_x, 30);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 30);
-
-  gpu_out.device(gpu_device) = gpu_a.igamma_der_a(gpu_x);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 30; ++i) {
-    VERIFY_IS_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_a);
-  gpuFree(d_x);
-  gpuFree(d_out);
-}
-
-template <typename Scalar>
-void test_gpu_gamma_sample_der_alpha() {
-  Tensor<Scalar, 1> in_alpha(30);
-  Tensor<Scalar, 1> in_sample(30);
-  Tensor<Scalar, 1> out(30);
-  Tensor<Scalar, 1> expected_out(30);
-  out.setZero();
-
-  Array<Scalar, 1, Dynamic> in_alpha_array(30);
-  Array<Scalar, 1, Dynamic> in_sample_array(30);
-  Array<Scalar, 1, Dynamic> expected_out_array(30);
-
-  // See special_functions.cpp for the Python code that generates the test data.
-
-  in_alpha_array << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0,
-      10.0, 10.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
-
-  in_sample_array << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
-      5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
-      1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
-      10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
-      968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
-
-  expected_out_array << 7.42424742367e-23, 1.02004297287e-34, 0.0130155240738, 1.02004297287e-34, 1.02004297287e-34,
-      1.96505168277e-13, 0.525575786243, 0.713903991771, 2.32077561808e-14, 0.000179348049886, 0.635500453302,
-      1.27561284917, 0.878125852156, 0.41565819538, 1.03606488534, 0.885964824887, 1.16424049334, 1.10764479598,
-      1.04590810812, 1.04193666963, 0.965193152414, 0.976217589464, 0.93008035061, 0.98153216096, 0.909196397698,
-      0.98434963993, 0.984738050206, 1.00106492525, 0.97734200649, 1.02198794179;
-
-  for (int i = 0; i < 30; ++i) {
-    in_alpha(i) = in_alpha_array(i);
-    in_sample(i) = in_sample_array(i);
-    expected_out(i) = expected_out_array(i);
-  }
-
-  std::size_t bytes = in_alpha.size() * sizeof(Scalar);
-
-  Scalar* d_alpha;
-  Scalar* d_sample;
-  Scalar* d_out;
-  gpuMalloc((void**)(&d_alpha), bytes);
-  gpuMalloc((void**)(&d_sample), bytes);
-  gpuMalloc((void**)(&d_out), bytes);
-
-  gpuMemcpy(d_alpha, in_alpha.data(), bytes, gpuMemcpyHostToDevice);
-  gpuMemcpy(d_sample, in_sample.data(), bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_alpha(d_alpha, 30);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_sample(d_sample, 30);
-  Eigen::TensorMap<Eigen::Tensor<Scalar, 1> > gpu_out(d_out, 30);
-
-  gpu_out.device(gpu_device) = gpu_alpha.gamma_sample_der_alpha(gpu_sample);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  for (int i = 0; i < 30; ++i) {
-    VERIFY_IS_APPROX(out(i), expected_out(i));
-  }
-
-  gpuFree(d_alpha);
-  gpuFree(d_sample);
-  gpuFree(d_out);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_gpu) {
-  CALL_SUBTEST_1(test_gpu_nullary());
-  CALL_SUBTEST_1(test_gpu_nullary_max_size<int16_t>());
-  CALL_SUBTEST_1(test_gpu_nullary_max_size<int32_t>());
-  CALL_SUBTEST_1((test_gpu_nullary_max_size<int64_t, (std::numeric_limits<int32_t>::max)() + 100ll>()));
-  CALL_SUBTEST_1(test_gpu_elementwise_small());
-  CALL_SUBTEST_1(test_gpu_elementwise());
-  CALL_SUBTEST_1(test_gpu_props());
-  CALL_SUBTEST_2(test_gpu_reduction());
-  CALL_SUBTEST_3(test_gpu_contraction<ColMajor>());
-  CALL_SUBTEST_3(test_gpu_contraction<RowMajor>());
-  CALL_SUBTEST_4(test_gpu_convolution_1d<ColMajor>());
-  CALL_SUBTEST_4(test_gpu_convolution_1d<RowMajor>());
-  CALL_SUBTEST_4(test_gpu_convolution_inner_dim_col_major_1d());
-  CALL_SUBTEST_4(test_gpu_convolution_inner_dim_row_major_1d());
-  CALL_SUBTEST_5(test_gpu_convolution_2d<ColMajor>());
-  CALL_SUBTEST_5(test_gpu_convolution_2d<RowMajor>());
-#if !defined(EIGEN_USE_HIP)
-  // disable these tests on HIP for now.
-  // they hang..need to investigate and fix
-  CALL_SUBTEST_6(test_gpu_convolution_3d<ColMajor>());
-  CALL_SUBTEST_7(test_gpu_convolution_3d<RowMajor>());
-#endif
-
-  // std::erf, std::erfc, and so on where only added in c++11. We use them
-  // as a golden reference to validate the results produced by Eigen. Therefore
-  // we can only run these tests if we use a c++11 compiler.
-  CALL_SUBTEST_8(test_gpu_lgamma<float>(1.0f));
-  CALL_SUBTEST_8(test_gpu_lgamma<float>(100.0f));
-  CALL_SUBTEST_8(test_gpu_lgamma<float>(0.01f));
-  CALL_SUBTEST_8(test_gpu_lgamma<float>(0.001f));
-
-  CALL_SUBTEST_8(test_gpu_lgamma<double>(1.0));
-  CALL_SUBTEST_8(test_gpu_lgamma<double>(100.0));
-  CALL_SUBTEST_8(test_gpu_lgamma<double>(0.01));
-  CALL_SUBTEST_8(test_gpu_lgamma<double>(0.001));
-
-  CALL_SUBTEST_8(test_gpu_erf<float>(1.0f));
-  CALL_SUBTEST_8(test_gpu_erf<float>(100.0f));
-  CALL_SUBTEST_8(test_gpu_erf<float>(0.01f));
-  CALL_SUBTEST_8(test_gpu_erf<float>(0.001f));
-
-  CALL_SUBTEST_8(test_gpu_erfc<float>(1.0f));
-  // CALL_SUBTEST_8(test_gpu_erfc<float>(100.0f));
-  CALL_SUBTEST_8(test_gpu_erfc<float>(5.0f));  // GPU erfc lacks precision for large inputs
-  CALL_SUBTEST_8(test_gpu_erfc<float>(0.01f));
-  CALL_SUBTEST_8(test_gpu_erfc<float>(0.001f));
-
-  CALL_SUBTEST_8(test_gpu_erf<double>(1.0));
-  CALL_SUBTEST_8(test_gpu_erf<double>(100.0));
-  CALL_SUBTEST_8(test_gpu_erf<double>(0.01));
-  CALL_SUBTEST_8(test_gpu_erf<double>(0.001));
-
-  CALL_SUBTEST_8(test_gpu_erfc<double>(1.0));
-  // CALL_SUBTEST_8(test_gpu_erfc<double>(100.0));
-  CALL_SUBTEST_8(test_gpu_erfc<double>(5.0));  // GPU erfc lacks precision for large inputs
-  CALL_SUBTEST_8(test_gpu_erfc<double>(0.01));
-  CALL_SUBTEST_8(test_gpu_erfc<double>(0.001));
-
-#if !defined(EIGEN_USE_HIP)
-  // disable these tests on HIP for now.
-
-  CALL_SUBTEST_9(test_gpu_ndtri<float>());
-  CALL_SUBTEST_9(test_gpu_ndtri<double>());
-
-  CALL_SUBTEST_9(test_gpu_digamma<float>());
-  CALL_SUBTEST_9(test_gpu_digamma<double>());
-
-  CALL_SUBTEST_9(test_gpu_polygamma<float>());
-  CALL_SUBTEST_9(test_gpu_polygamma<double>());
-
-  CALL_SUBTEST_9(test_gpu_zeta<float>());
-  CALL_SUBTEST_9(test_gpu_zeta<double>());
-#endif
-
-  CALL_SUBTEST_9(test_gpu_igamma<float>());
-  CALL_SUBTEST_9(test_gpu_igammac<float>());
-
-  CALL_SUBTEST_9(test_gpu_igamma<double>());
-  CALL_SUBTEST_9(test_gpu_igammac<double>());
-
-#if !defined(EIGEN_USE_HIP)
-  // disable these tests on HIP for now.
-  CALL_SUBTEST_9(test_gpu_betainc<float>());
-  CALL_SUBTEST_9(test_gpu_betainc<double>());
-
-  CALL_SUBTEST_9(test_gpu_i0e<float>());
-  CALL_SUBTEST_9(test_gpu_i0e<double>());
-
-  CALL_SUBTEST_9(test_gpu_i1e<float>());
-  CALL_SUBTEST_9(test_gpu_i1e<double>());
-
-  CALL_SUBTEST_9(test_gpu_i1e<float>());
-  CALL_SUBTEST_9(test_gpu_i1e<double>());
-
-  CALL_SUBTEST_9(test_gpu_igamma_der_a<float>());
-  CALL_SUBTEST_9(test_gpu_igamma_der_a<double>());
-
-  CALL_SUBTEST_9(test_gpu_gamma_sample_der_alpha<float>());
-  CALL_SUBTEST_9(test_gpu_gamma_sample_der_alpha<double>());
-#endif
-}
diff --git a/unsupported/test/cxx11_tensor_ifft.cpp b/unsupported/test/cxx11_tensor_ifft.cpp
deleted file mode 100644
index 04f46eb..0000000
--- a/unsupported/test/cxx11_tensor_ifft.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Jianwei Cui <thucjw@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <complex>
-#include <cmath>
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_1D_fft_ifft_invariant(int sequence_length) {
-  Tensor<double, 1, DataLayout> tensor(sequence_length);
-  tensor.setRandom();
-
-  array<int, 1> fft;
-  fft[0] = 0;
-
-  Tensor<std::complex<double>, 1, DataLayout> tensor_after_fft;
-  Tensor<std::complex<double>, 1, DataLayout> tensor_after_fft_ifft;
-
-  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
-  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
-
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), sequence_length);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), sequence_length);
-
-  for (int i = 0; i < sequence_length; ++i) {
-    VERIFY_IS_APPROX(static_cast<float>(tensor(i)), static_cast<float>(std::real(tensor_after_fft_ifft(i))));
-  }
-}
-
-template <int DataLayout>
-static void test_2D_fft_ifft_invariant(int dim0, int dim1) {
-  Tensor<double, 2, DataLayout> tensor(dim0, dim1);
-  tensor.setRandom();
-
-  array<int, 2> fft;
-  fft[0] = 0;
-  fft[1] = 1;
-
-  Tensor<std::complex<double>, 2, DataLayout> tensor_after_fft;
-  Tensor<std::complex<double>, 2, DataLayout> tensor_after_fft_ifft;
-
-  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
-  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
-
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
-
-  for (int i = 0; i < dim0; ++i) {
-    for (int j = 0; j < dim1; ++j) {
-      // std::cout << "[" << i << "][" << j << "]" <<  "  Original data: " << tensor(i,j) << " Transformed data:" <<
-      // tensor_after_fft_ifft(i,j) << std::endl;
-      VERIFY_IS_APPROX(static_cast<float>(tensor(i, j)), static_cast<float>(std::real(tensor_after_fft_ifft(i, j))));
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_3D_fft_ifft_invariant(int dim0, int dim1, int dim2) {
-  Tensor<double, 3, DataLayout> tensor(dim0, dim1, dim2);
-  tensor.setRandom();
-
-  array<int, 3> fft;
-  fft[0] = 0;
-  fft[1] = 1;
-  fft[2] = 2;
-
-  Tensor<std::complex<double>, 3, DataLayout> tensor_after_fft;
-  Tensor<std::complex<double>, 3, DataLayout> tensor_after_fft_ifft;
-
-  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
-  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::BothParts, Eigen::FFT_REVERSE>(fft);
-
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(2), dim2);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(2), dim2);
-
-  for (int i = 0; i < dim0; ++i) {
-    for (int j = 0; j < dim1; ++j) {
-      for (int k = 0; k < dim2; ++k) {
-        VERIFY_IS_APPROX(static_cast<float>(tensor(i, j, k)),
-                         static_cast<float>(std::real(tensor_after_fft_ifft(i, j, k))));
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_sub_fft_ifft_invariant(int dim0, int dim1, int dim2, int dim3) {
-  Tensor<double, 4, DataLayout> tensor(dim0, dim1, dim2, dim3);
-  tensor.setRandom();
-
-  array<int, 2> fft;
-  fft[0] = 2;
-  fft[1] = 0;
-
-  Tensor<std::complex<double>, 4, DataLayout> tensor_after_fft;
-  Tensor<double, 4, DataLayout> tensor_after_fft_ifft;
-
-  tensor_after_fft = tensor.template fft<Eigen::BothParts, Eigen::FFT_FORWARD>(fft);
-  tensor_after_fft_ifft = tensor_after_fft.template fft<Eigen::RealPart, Eigen::FFT_REVERSE>(fft);
-
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(0), dim0);
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(1), dim1);
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(2), dim2);
-  VERIFY_IS_EQUAL(tensor_after_fft.dimension(3), dim3);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(0), dim0);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(1), dim1);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(2), dim2);
-  VERIFY_IS_EQUAL(tensor_after_fft_ifft.dimension(3), dim3);
-
-  for (int i = 0; i < dim0; ++i) {
-    for (int j = 0; j < dim1; ++j) {
-      for (int k = 0; k < dim2; ++k) {
-        for (int l = 0; l < dim3; ++l) {
-          VERIFY_IS_APPROX(static_cast<float>(tensor(i, j, k, l)),
-                           static_cast<float>(tensor_after_fft_ifft(i, j, k, l)));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_ifft) {
-  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(4));
-  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(16));
-  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(32));
-  CALL_SUBTEST(test_1D_fft_ifft_invariant<ColMajor>(1024 * 1024));
-
-  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(4, 4));
-  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(8, 16));
-  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(16, 32));
-  CALL_SUBTEST(test_2D_fft_ifft_invariant<ColMajor>(1024, 1024));
-
-  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(4, 4, 4));
-  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(8, 16, 32));
-  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(16, 4, 8));
-  CALL_SUBTEST(test_3D_fft_ifft_invariant<ColMajor>(256, 256, 256));
-
-  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(4, 4, 4, 4));
-  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(8, 16, 32, 64));
-  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(16, 4, 8, 12));
-  CALL_SUBTEST(test_sub_fft_ifft_invariant<ColMajor>(64, 64, 64, 64));
-}
diff --git a/unsupported/test/cxx11_tensor_image_op_sycl.cpp b/unsupported/test/cxx11_tensor_image_op_sycl.cpp
deleted file mode 100644
index 4c901a4..0000000
--- a/unsupported/test/cxx11_tensor_image_op_sycl.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_image_op_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 245;
-  IndexType sizeDim2 = 343;
-  IndexType sizeDim3 = 577;
-
-  array<IndexType, 3> input_range = {{sizeDim1, sizeDim2, sizeDim3}};
-  array<IndexType, 3> slice_range = {{sizeDim1 - 1, sizeDim2, sizeDim3}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> tensor1(input_range);
-  Tensor<DataType, 3, DataLayout, IndexType> tensor2(input_range);
-  Tensor<DataType, 3, DataLayout, IndexType> tensor3(slice_range);
-  Tensor<DataType, 3, DataLayout, IndexType> tensor3_cpu(slice_range);
-
-  typedef Eigen::DSizes<IndexType, 3> Index3;
-  Index3 strides1(1L, 1L, 1L);
-  Index3 indicesStart1(1L, 0L, 0L);
-  Index3 indicesStop1(sizeDim1, sizeDim2, sizeDim3);
-
-  Index3 strides2(1L, 1L, 1L);
-  Index3 indicesStart2(0L, 0L, 0L);
-  Index3 indicesStop2(sizeDim1 - 1, sizeDim2, sizeDim3);
-  Eigen::DSizes<IndexType, 3> sizes(sizeDim1 - 1, sizeDim2, sizeDim3);
-
-  tensor1.setRandom();
-  tensor2.setRandom();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(tensor3.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, input_range);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, input_range);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu3(gpu_data3, slice_range);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_data2, tensor2.data(), (tensor2.size()) * sizeof(DataType));
-  gpu3.device(sycl_device) = gpu1.slice(indicesStart1, sizes) - gpu2.slice(indicesStart2, sizes);
-  sycl_device.memcpyDeviceToHost(tensor3.data(), gpu_data3, (tensor3.size()) * sizeof(DataType));
-
-  tensor3_cpu = tensor1.stridedSlice(indicesStart1, indicesStop1, strides1) -
-                tensor2.stridedSlice(indicesStart2, indicesStop2, strides2);
-
-  for (IndexType i = 0; i < slice_range[0]; ++i) {
-    for (IndexType j = 0; j < slice_range[1]; ++j) {
-      for (IndexType k = 0; k < slice_range[2]; ++k) {
-        VERIFY_IS_EQUAL(tensor3_cpu(i, j, k), tensor3(i, j, k));
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-  sycl_device.deallocate(gpu_data3);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_computing_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_image_op_sycl<DataType, RowMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_image_op_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_computing_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_computing_test_per_device<float>(device));
-#ifdef EIGEN_SYCL_DOUBLE_SUPPORT
-    CALL_SUBTEST(sycl_computing_test_per_device<double>(device));
-#endif
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_image_patch.cpp b/unsupported/test/cxx11_tensor_image_patch.cpp
deleted file mode 100644
index 2f48394..0000000
--- a/unsupported/test/cxx11_tensor_image_patch.cpp
+++ /dev/null
@@ -1,811 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-void test_simple_patch() {
-  Tensor<float, 4> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
-
-  // Single pixel patch: ColMajor
-  Tensor<float, 5> single_pixel_patch;
-  single_pixel_patch = tensor.extract_image_patches(1, 1);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(0), 2);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(3), 3 * 5);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(4), 7);
-
-  // Single pixel patch: RowMajor
-  Tensor<float, 5, RowMajor> single_pixel_patch_row_major;
-  single_pixel_patch_row_major = tensor_row_major.extract_image_patches(1, 1);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(1), 3 * 5);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(3), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(4), 2);
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    // ColMajor
-    if (tensor.data()[i] != single_pixel_patch.data()[i]) {
-      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
-                << single_pixel_patch.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], tensor.data()[i]);
-    // RowMajor
-    if (tensor_row_major.data()[i] != single_pixel_patch_row_major.data()[i]) {
-      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
-                << single_pixel_patch_row_major.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_pixel_patch_row_major.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], single_pixel_patch_row_major.data()[i]);
-  }
-
-  // Entire image patch: ColMajor
-  Tensor<float, 5> entire_image_patch;
-  entire_image_patch = tensor.extract_image_patches(3, 5);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(0), 2);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(1), 3);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(2), 5);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(3), 3 * 5);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(4), 7);
-
-  // Entire image patch: RowMajor
-  Tensor<float, 5, RowMajor> entire_image_patch_row_major;
-  entire_image_patch_row_major = tensor_row_major.extract_image_patches(3, 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 3 * 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 3);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(4), 2);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      int patchId = i + 3 * j;
-      for (int r = 0; r < 3; ++r) {
-        for (int c = 0; c < 5; ++c) {
-          for (int d = 0; d < 2; ++d) {
-            for (int b = 0; b < 7; ++b) {
-              float expected = 0.0f;
-              float expected_row_major = 0.0f;
-              if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
-                expected = tensor(d, r - 1 + i, c - 2 + j, b);
-                expected_row_major = tensor_row_major(b, c - 2 + j, r - 1 + i, d);
-              }
-              // ColMajor
-              if (entire_image_patch(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(entire_image_patch(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (entire_image_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(entire_image_patch_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // 2D patch: ColMajor
-  Tensor<float, 5> twod_patch;
-  twod_patch = tensor.extract_image_patches(2, 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(0), 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(3), 3 * 5);
-  VERIFY_IS_EQUAL(twod_patch.dimension(4), 7);
-
-  // 2D patch: RowMajor
-  Tensor<float, 5, RowMajor> twod_patch_row_major;
-  twod_patch_row_major = tensor_row_major.extract_image_patches(2, 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 3 * 5);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(4), 2);
-
-  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
-  int row_padding = 0;
-  int col_padding = 0;
-  int stride = 1;
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      int patchId = i + 3 * j;
-      for (int r = 0; r < 2; ++r) {
-        for (int c = 0; c < 2; ++c) {
-          for (int d = 0; d < 2; ++d) {
-            for (int b = 0; b < 7; ++b) {
-              float expected = 0.0f;
-              float expected_row_major = 0.0f;
-              int row_offset = r * stride + i - row_padding;
-              int col_offset = c * stride + j - col_padding;
-              // ColMajor
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor.dimension(1) &&
-                  col_offset < tensor.dimension(2)) {
-                expected = tensor(d, row_offset, col_offset, b);
-              }
-              if (twod_patch(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(twod_patch(d, r, c, patchId, b), expected);
-
-              // RowMajor
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(2) &&
-                  col_offset < tensor_row_major.dimension(1)) {
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              if (twod_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(twod_patch_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// Verifies VALID padding (no padding) with incrementing values.
-void test_patch_padding_valid() {
-  int input_depth = 3;
-  int input_rows = 3;
-  int input_cols = 3;
-  int input_batches = 1;
-  int ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
-  int stride = 2;  // Only same stride is supported.
-  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
-  // Initializes tensor with incrementing numbers.
-  for (int i = 0; i < tensor.size(); ++i) {
-    tensor.data()[i] = i + 1;
-  }
-  // ColMajor
-  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-
-  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result.dimension(3), 1);              // number of patches
-  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
-
-  Tensor<float, 5, RowMajor> result_row_major =
-      tensor_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
-
-  // No padding is carried out.
-  int row_padding = 0;
-  int col_padding = 0;
-
-  for (int i = 0; (i + stride + ksize - 1) < input_rows; i += stride) {    // input rows
-    for (int j = 0; (j + stride + ksize - 1) < input_cols; j += stride) {  // input cols
-      int patchId = i + input_rows * j;
-      for (int r = 0; r < ksize; ++r) {                // patch rows
-        for (int c = 0; c < ksize; ++c) {              // patch cols
-          for (int d = 0; d < input_depth; ++d) {      // depth
-            for (int b = 0; b < input_batches; ++b) {  // batch
-              float expected = 0.0f;
-              float expected_row_major = 0.0f;
-              int row_offset = r + i - row_padding;
-              int col_offset = c + j - col_padding;
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
-                expected = tensor(d, row_offset, col_offset, b);
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              // ColMajor
-              if (result(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// Verifies VALID padding (no padding) with the same value.
-void test_patch_padding_valid_same_value() {
-  int input_depth = 1;
-  int input_rows = 5;
-  int input_cols = 5;
-  int input_batches = 2;
-  int ksize = 3;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
-  int stride = 2;  // Only same stride is supported.
-  // ColMajor
-  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
-  tensor = tensor.constant(11.0f);
-  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-
-  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result.dimension(3), 4);              // number of patches
-  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
-
-  Tensor<float, 5, RowMajor> result_row_major =
-      tensor_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
-
-  // No padding is carried out.
-  int row_padding = 0;
-  int col_padding = 0;
-
-  for (int i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
-    for (int j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
-      int patchId = i + input_rows * j;
-      for (int r = 0; r < ksize; ++r) {                // patch rows
-        for (int c = 0; c < ksize; ++c) {              // patch cols
-          for (int d = 0; d < input_depth; ++d) {      // depth
-            for (int b = 0; b < input_batches; ++b) {  // batch
-              float expected = 0.0f;
-              float expected_row_major = 0.0f;
-              int row_offset = r + i - row_padding;
-              int col_offset = c + j - col_padding;
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
-                expected = tensor(d, row_offset, col_offset, b);
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              // ColMajor
-              if (result(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// Verifies SAME padding.
-void test_patch_padding_same() {
-  int input_depth = 3;
-  int input_rows = 4;
-  int input_cols = 2;
-  int input_batches = 1;
-  int ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
-  int stride = 2;  // Only same stride is supported.
-  // ColMajor
-  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
-  // Initializes tensor with incrementing numbers.
-  for (int i = 0; i < tensor.size(); ++i) {
-    tensor.data()[i] = i + 1;
-  }
-  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
-
-  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result.dimension(3), 2);              // number of patches
-  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
-
-  Tensor<float, 5, RowMajor> result_row_major =
-      tensor_row_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
-  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
-
-  // Based on the calculation described in TensorTraits.h, padding happens to be
-  // 0.
-  int row_padding = 0;
-  int col_padding = 0;
-
-  for (int i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
-    for (int j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
-      int patchId = i + input_rows * j;
-      for (int r = 0; r < ksize; ++r) {                // patch rows
-        for (int c = 0; c < ksize; ++c) {              // patch cols
-          for (int d = 0; d < input_depth; ++d) {      // depth
-            for (int b = 0; b < input_batches; ++b) {  // batch
-              float expected = 0.0f;
-              float expected_row_major = 0.0f;
-              int row_offset = r * stride + i - row_padding;
-              int col_offset = c * stride + j - col_padding;
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
-                expected = tensor(d, row_offset, col_offset, b);
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              // ColMajor
-              if (result(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// Verifies that SAME padding, when computed as negative values, will be clipped
-// to zero.
-void test_patch_padding_same_negative_padding_clip_to_zero() {
-  int input_depth = 1;
-  int input_rows = 15;
-  int input_cols = 1;
-  int input_batches = 1;
-  int ksize = 1;  // Corresponds to the Rows and Cols for
-                  // tensor.extract_image_patches<>.
-  int row_stride = 5;
-  int col_stride = 1;
-  // ColMajor
-  Tensor<float, 4> tensor(input_depth, input_rows, input_cols, input_batches);
-  // Initializes tensor with incrementing numbers.
-  for (int i = 0; i < tensor.size(); ++i) {
-    tensor.data()[i] = i + 1;
-  }
-  Tensor<float, 5> result = tensor.extract_image_patches(ksize, ksize, row_stride, col_stride, 1, 1, PADDING_SAME);
-  // row padding will be computed as -2 originally and then be clipped to 0.
-  VERIFY_IS_EQUAL(result.coeff(0), 1.0f);
-  VERIFY_IS_EQUAL(result.coeff(1), 6.0f);
-  VERIFY_IS_EQUAL(result.coeff(2), 11.0f);
-
-  VERIFY_IS_EQUAL(result.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result.dimension(3), 3);              // number of patches
-  VERIFY_IS_EQUAL(result.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-  Tensor<float, 4, RowMajor> tensor_row_major = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(3), tensor_row_major.dimension(0));
-
-  Tensor<float, 5, RowMajor> result_row_major =
-      tensor_row_major.extract_image_patches(ksize, ksize, row_stride, col_stride, 1, 1, PADDING_SAME);
-  VERIFY_IS_EQUAL(result_row_major.coeff(0), 1.0f);
-  VERIFY_IS_EQUAL(result_row_major.coeff(1), 6.0f);
-  VERIFY_IS_EQUAL(result_row_major.coeff(2), 11.0f);
-
-  VERIFY_IS_EQUAL(result.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result.dimension(4), result_row_major.dimension(0));
-}
-
-void test_patch_no_extra_dim() {
-  Tensor<float, 3> tensor(2, 3, 5);
-  tensor.setRandom();
-  Tensor<float, 3, RowMajor> tensor_row_major = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor_row_major.dimension(0));
-
-  // Single pixel patch: ColMajor
-  Tensor<float, 4> single_pixel_patch;
-  single_pixel_patch = tensor.extract_image_patches(1, 1);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(0), 2);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch.dimension(3), 3 * 5);
-
-  // Single pixel patch: RowMajor
-  Tensor<float, 4, RowMajor> single_pixel_patch_row_major;
-  single_pixel_patch_row_major = tensor_row_major.extract_image_patches(1, 1);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(0), 3 * 5);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_pixel_patch_row_major.dimension(3), 2);
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    // ColMajor
-    if (tensor.data()[i] != single_pixel_patch.data()[i]) {
-      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
-                << single_pixel_patch.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], tensor.data()[i]);
-    // RowMajor
-    if (tensor_row_major.data()[i] != single_pixel_patch_row_major.data()[i]) {
-      std::cout << "Mismatch detected at index " << i << " : " << tensor.data()[i] << " vs "
-                << single_pixel_patch_row_major.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_pixel_patch_row_major.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(single_pixel_patch.data()[i], single_pixel_patch_row_major.data()[i]);
-  }
-
-  // Entire image patch: ColMajor
-  Tensor<float, 4> entire_image_patch;
-  entire_image_patch = tensor.extract_image_patches(3, 5);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(0), 2);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(1), 3);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(2), 5);
-  VERIFY_IS_EQUAL(entire_image_patch.dimension(3), 3 * 5);
-
-  // Entire image patch: RowMajor
-  Tensor<float, 4, RowMajor> entire_image_patch_row_major;
-  entire_image_patch_row_major = tensor_row_major.extract_image_patches(3, 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 3 * 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 3);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 2);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      int patchId = i + 3 * j;
-      for (int r = 0; r < 3; ++r) {
-        for (int c = 0; c < 5; ++c) {
-          for (int d = 0; d < 2; ++d) {
-            float expected = 0.0f;
-            float expected_row_major = 0.0f;
-            if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
-              expected = tensor(d, r - 1 + i, c - 2 + j);
-              expected_row_major = tensor_row_major(c - 2 + j, r - 1 + i, d);
-            }
-            // ColMajor
-            if (entire_image_patch(d, r, c, patchId) != expected) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(entire_image_patch(d, r, c, patchId), expected);
-            // RowMajor
-            if (entire_image_patch_row_major(patchId, c, r, d) != expected_row_major) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(entire_image_patch_row_major(patchId, c, r, d), expected_row_major);
-            // Check that ColMajor and RowMajor agree.
-            VERIFY_IS_EQUAL(expected, expected_row_major);
-          }
-        }
-      }
-    }
-  }
-
-  // 2D patch: ColMajor
-  Tensor<float, 4> twod_patch;
-  twod_patch = tensor.extract_image_patches(2, 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(0), 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch.dimension(3), 3 * 5);
-
-  // 2D patch: RowMajor
-  Tensor<float, 4, RowMajor> twod_patch_row_major;
-  twod_patch_row_major = tensor_row_major.extract_image_patches(2, 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 3 * 5);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
-
-  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
-  int row_padding = 0;
-  int col_padding = 0;
-  int stride = 1;
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      int patchId = i + 3 * j;
-      for (int r = 0; r < 2; ++r) {
-        for (int c = 0; c < 2; ++c) {
-          for (int d = 0; d < 2; ++d) {
-            float expected = 0.0f;
-            float expected_row_major = 0.0f;
-            int row_offset = r * stride + i - row_padding;
-            int col_offset = c * stride + j - col_padding;
-            // ColMajor
-            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor.dimension(1) &&
-                col_offset < tensor.dimension(2)) {
-              expected = tensor(d, row_offset, col_offset);
-            }
-            if (twod_patch(d, r, c, patchId) != expected) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(twod_patch(d, r, c, patchId), expected);
-            // RowMajor
-            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(1) &&
-                col_offset < tensor_row_major.dimension(0)) {
-              expected_row_major = tensor_row_major(col_offset, row_offset, d);
-            }
-            if (twod_patch_row_major(patchId, c, r, d) != expected_row_major) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(twod_patch_row_major(patchId, c, r, d), expected_row_major);
-            // Check that ColMajor and RowMajor agree.
-            VERIFY_IS_EQUAL(expected, expected_row_major);
-          }
-        }
-      }
-    }
-  }
-}
-
-void test_imagenet_patches() {
-  // Test the code on typical configurations used by the 'imagenet' benchmarks at
-  // https://github.com/soumith/convnet-benchmarks
-  // ColMajor
-  Tensor<float, 4> l_in(3, 128, 128, 16);
-  l_in.setRandom();
-  Tensor<float, 5> l_out = l_in.extract_image_patches(11, 11);
-  VERIFY_IS_EQUAL(l_out.dimension(0), 3);
-  VERIFY_IS_EQUAL(l_out.dimension(1), 11);
-  VERIFY_IS_EQUAL(l_out.dimension(2), 11);
-  VERIFY_IS_EQUAL(l_out.dimension(3), 128 * 128);
-  VERIFY_IS_EQUAL(l_out.dimension(4), 16);
-
-  // RowMajor
-  Tensor<float, 5, RowMajor> l_out_row_major = l_in.swap_layout().extract_image_patches(11, 11);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 16);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 128 * 128);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 11);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 11);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 3);
-
-  for (int b = 0; b < 16; ++b) {
-    for (int i = 0; i < 128; ++i) {
-      for (int j = 0; j < 128; ++j) {
-        int patchId = i + 128 * j;
-        for (int c = 0; c < 11; ++c) {
-          for (int r = 0; r < 11; ++r) {
-            for (int d = 0; d < 3; ++d) {
-              float expected = 0.0f;
-              if (r - 5 + i >= 0 && c - 5 + j >= 0 && r - 5 + i < 128 && c - 5 + j < 128) {
-                expected = l_in(d, r - 5 + i, c - 5 + j, b);
-              }
-              // ColMajor
-              if (l_out(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // ColMajor
-  l_in.resize(16, 64, 64, 32);
-  l_in.setRandom();
-  l_out = l_in.extract_image_patches(9, 9);
-  VERIFY_IS_EQUAL(l_out.dimension(0), 16);
-  VERIFY_IS_EQUAL(l_out.dimension(1), 9);
-  VERIFY_IS_EQUAL(l_out.dimension(2), 9);
-  VERIFY_IS_EQUAL(l_out.dimension(3), 64 * 64);
-  VERIFY_IS_EQUAL(l_out.dimension(4), 32);
-
-  // RowMajor
-  l_out_row_major = l_in.swap_layout().extract_image_patches(9, 9);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 64 * 64);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 9);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 9);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 16);
-
-  for (int b = 0; b < 32; ++b) {
-    for (int i = 0; i < 64; ++i) {
-      for (int j = 0; j < 64; ++j) {
-        int patchId = i + 64 * j;
-        for (int c = 0; c < 9; ++c) {
-          for (int r = 0; r < 9; ++r) {
-            for (int d = 0; d < 16; ++d) {
-              float expected = 0.0f;
-              if (r - 4 + i >= 0 && c - 4 + j >= 0 && r - 4 + i < 64 && c - 4 + j < 64) {
-                expected = l_in(d, r - 4 + i, c - 4 + j, b);
-              }
-              // ColMajor
-              if (l_out(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // ColMajor
-  l_in.resize(32, 16, 16, 32);
-  l_in.setRandom();
-  l_out = l_in.extract_image_patches(7, 7);
-  VERIFY_IS_EQUAL(l_out.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out.dimension(1), 7);
-  VERIFY_IS_EQUAL(l_out.dimension(2), 7);
-  VERIFY_IS_EQUAL(l_out.dimension(3), 16 * 16);
-  VERIFY_IS_EQUAL(l_out.dimension(4), 32);
-
-  // RowMajor
-  l_out_row_major = l_in.swap_layout().extract_image_patches(7, 7);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 16 * 16);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 7);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 7);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 32);
-
-  for (int b = 0; b < 32; ++b) {
-    for (int i = 0; i < 16; ++i) {
-      for (int j = 0; j < 16; ++j) {
-        int patchId = i + 16 * j;
-        for (int c = 0; c < 7; ++c) {
-          for (int r = 0; r < 7; ++r) {
-            for (int d = 0; d < 32; ++d) {
-              float expected = 0.0f;
-              if (r - 3 + i >= 0 && c - 3 + j >= 0 && r - 3 + i < 16 && c - 3 + j < 16) {
-                expected = l_in(d, r - 3 + i, c - 3 + j, b);
-              }
-              // ColMajor
-              if (l_out(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // ColMajor
-  l_in.resize(64, 13, 13, 32);
-  l_in.setRandom();
-  l_out = l_in.extract_image_patches(3, 3);
-  VERIFY_IS_EQUAL(l_out.dimension(0), 64);
-  VERIFY_IS_EQUAL(l_out.dimension(1), 3);
-  VERIFY_IS_EQUAL(l_out.dimension(2), 3);
-  VERIFY_IS_EQUAL(l_out.dimension(3), 13 * 13);
-  VERIFY_IS_EQUAL(l_out.dimension(4), 32);
-
-  // RowMajor
-  l_out_row_major = l_in.swap_layout().extract_image_patches(3, 3);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 13 * 13);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 3);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 3);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 64);
-
-  for (int b = 0; b < 32; ++b) {
-    for (int i = 0; i < 13; ++i) {
-      for (int j = 0; j < 13; ++j) {
-        int patchId = i + 13 * j;
-        for (int c = 0; c < 3; ++c) {
-          for (int r = 0; r < 3; ++r) {
-            for (int d = 0; d < 64; ++d) {
-              float expected = 0.0f;
-              if (r - 1 + i >= 0 && c - 1 + j >= 0 && r - 1 + i < 13 && c - 1 + j < 13) {
-                expected = l_in(d, r - 1 + i, c - 1 + j, b);
-              }
-              // ColMajor
-              if (l_out(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_image_patch) {
-  CALL_SUBTEST_1(test_simple_patch());
-  CALL_SUBTEST_2(test_patch_no_extra_dim());
-  CALL_SUBTEST_3(test_patch_padding_valid());
-  CALL_SUBTEST_4(test_patch_padding_valid_same_value());
-  CALL_SUBTEST_5(test_patch_padding_same());
-  CALL_SUBTEST_6(test_imagenet_patches());
-  CALL_SUBTEST_7(test_patch_padding_same_negative_padding_clip_to_zero());
-}
diff --git a/unsupported/test/cxx11_tensor_image_patch_sycl.cpp b/unsupported/test/cxx11_tensor_image_patch_sycl.cpp
deleted file mode 100644
index a6d3b7a..0000000
--- a/unsupported/test/cxx11_tensor_image_patch_sycl.cpp
+++ /dev/null
@@ -1,1155 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-static const int DataLayout = ColMajor;
-
-template <typename DataType, typename IndexType>
-static void test_simple_image_patch_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 4> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  array<IndexType, 4> tensorRowMajorRange = {{sizeDim4, sizeDim3, sizeDim2, sizeDim1}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-  tensor_col_major.setRandom();
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_col_major.size()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
-
-  // Single pixel patch: ColMajor
-  array<IndexType, 5> patchColMajorTensorRange = {{sizeDim1, 1, 1, sizeDim2 * sizeDim3, sizeDim4}};
-  Tensor<DataType, 5, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
-                                                                                   patchColMajorTensorRange);
-  gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
-  sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), 2);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), 3 * 5);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(4), 7);
-
-  // Single pixel patch: RowMajor
-  array<IndexType, 5> patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 1, 1, sizeDim1}};
-  Tensor<DataType, 5, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
-                                                                                 patchRowMajorTensorRange);
-  gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
-  sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 3 * 5);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), 1);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(4), 2);
-
-  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
-    // ColMajor
-    if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
-      std::cout << "Mismatch detected at index colmajor " << i << " : " << tensor_col_major.data()[i] << " vs "
-                << single_patch_col_major.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
-    // RowMajor
-    if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
-      std::cout << "Mismatch detected at index row major" << i << " : " << tensor_row_major.data()[i] << " vs "
-                << single_patch_row_major.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
-  }
-
-  // Entire image patch: ColMajor
-  patchColMajorTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3, sizeDim4}};
-  Tensor<DataType, 5, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
-  patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
-      gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
-  gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
-  sycl_device.memcpyDeviceToHost(entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major,
-                                 patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(4), 7);
-
-  // Entire image patch: RowMajor
-  patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1}};
-  Tensor<DataType, 5, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
-      gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
-  gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
-  sycl_device.memcpyDeviceToHost(entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major,
-                                 patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 3 * 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 3);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(4), 2);
-
-  for (IndexType i = 0; i < 3; ++i) {
-    for (IndexType j = 0; j < 5; ++j) {
-      IndexType patchId = i + 3 * j;
-      for (IndexType r = 0; r < 3; ++r) {
-        for (IndexType c = 0; c < 5; ++c) {
-          for (IndexType d = 0; d < 2; ++d) {
-            for (IndexType b = 0; b < 7; ++b) {
-              DataType expected_col_major = 0.0f;
-              DataType expected_row_major = 0.0f;
-              if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
-                expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j, b);
-                expected_row_major = tensor_row_major(b, c - 2 + j, r - 1 + i, d);
-              }
-              // ColMajor
-              if (entire_image_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId, b), expected_col_major);
-              // RowMajor
-              if (entire_image_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(entire_image_patch_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // 2D patch: ColMajor
-  patchColMajorTensorRange = {{sizeDim1, 2, 2, sizeDim2 * sizeDim3, sizeDim4}};
-  Tensor<DataType, 5, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
-  patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
-                                                                                 patchColMajorTensorRange);
-  gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
-  sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(4), 7);
-
-  // 2D patch: RowMajor
-  patchRowMajorTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 2, 2, sizeDim1}};
-  Tensor<DataType, 5, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
-                                                                               patchRowMajorTensorRange);
-  gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
-  sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 3 * 5);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(4), 2);
-
-  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
-  IndexType row_padding = 0;
-  IndexType col_padding = 0;
-  IndexType stride = 1;
-
-  for (IndexType i = 0; i < 3; ++i) {
-    for (IndexType j = 0; j < 5; ++j) {
-      IndexType patchId = i + 3 * j;
-      for (IndexType r = 0; r < 2; ++r) {
-        for (IndexType c = 0; c < 2; ++c) {
-          for (IndexType d = 0; d < 2; ++d) {
-            for (IndexType b = 0; b < 7; ++b) {
-              DataType expected_col_major = 0.0f;
-              DataType expected_row_major = 0.0f;
-              IndexType row_offset = r * stride + i - row_padding;
-              IndexType col_offset = c * stride + j - col_padding;
-              // ColMajor
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
-                  col_offset < tensor_col_major.dimension(2)) {
-                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
-              }
-              if (twod_patch_col_major(d, r, c, patchId, b) != expected_col_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId, b), expected_col_major);
-
-              // RowMajor
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(2) &&
-                  col_offset < tensor_row_major.dimension(1)) {
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              if (twod_patch_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(twod_patch_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  sycl_device.deallocate(gpu_data_col_major);
-  sycl_device.deallocate(gpu_data_row_major);
-  sycl_device.deallocate(gpu_data_single_patch_col_major);
-  sycl_device.deallocate(gpu_data_single_patch_row_major);
-  sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
-  sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
-  sycl_device.deallocate(gpu_data_twod_patch_col_major);
-  sycl_device.deallocate(gpu_data_twod_patch_row_major);
-}
-
-// Verifies VALID padding (no padding) with incrementing values.
-template <typename DataType, typename IndexType>
-static void test_patch_padding_valid_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType input_depth = 3;
-  IndexType input_rows = 3;
-  IndexType input_cols = 3;
-  IndexType input_batches = 1;
-  IndexType ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
-  IndexType stride = 2;  // Only same stride is supported.
-
-  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
-  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_col_major.size()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
-
-  // Initializes tensor with incrementing numbers.
-  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
-    tensor_col_major.data()[i] = i + 1;
-  }
-  // ColMajor
-  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 1, input_batches}};
-  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
-                                                                             patchColMajorTensorRange);
-  gpu_result_col_major.device(sycl_device) =
-      gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result_col_major.dimension(3), 1);              // number of patches
-  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 1, ksize, ksize, input_depth}};
-  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
-                                                                           patchRowMajorTensorRange);
-  gpu_result_row_major.device(sycl_device) =
-      gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
-
-  // No padding is carried out.
-  IndexType row_padding = 0;
-  IndexType col_padding = 0;
-
-  for (IndexType i = 0; (i + stride + ksize - 1) < input_rows; i += stride) {    // input rows
-    for (IndexType j = 0; (j + stride + ksize - 1) < input_cols; j += stride) {  // input cols
-      IndexType patchId = i + input_rows * j;
-      for (IndexType r = 0; r < ksize; ++r) {                // patch rows
-        for (IndexType c = 0; c < ksize; ++c) {              // patch cols
-          for (IndexType d = 0; d < input_depth; ++d) {      // depth
-            for (IndexType b = 0; b < input_batches; ++b) {  // batch
-              DataType expected_col_major = 0.0f;
-              DataType expected_row_major = 0.0f;
-              IndexType row_offset = r + i - row_padding;
-              IndexType col_offset = c + j - col_padding;
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
-                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              // ColMajor
-              if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
-              // RowMajor
-              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_col_major);
-  sycl_device.deallocate(gpu_data_row_major);
-  sycl_device.deallocate(gpu_data_result_col_major);
-  sycl_device.deallocate(gpu_data_result_row_major);
-}
-
-// Verifies VALID padding (no padding) with the same value.
-template <typename DataType, typename IndexType>
-static void test_patch_padding_valid_same_value_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType input_depth = 1;
-  IndexType input_rows = 5;
-  IndexType input_cols = 5;
-  IndexType input_batches = 2;
-  IndexType ksize = 3;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
-  IndexType stride = 2;  // Only same stride is supported.
-  // ColMajor
-
-  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
-  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-  gpu_col_major.device(sycl_device) = gpu_col_major.constant(11.0f);
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor_col_major.data(), gpu_data_col_major,
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_row_major.size()) * sizeof(DataType));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
-
-  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 4, input_batches}};
-  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
-                                                                             patchColMajorTensorRange);
-  gpu_result_col_major.device(sycl_device) =
-      gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result_col_major.dimension(3), 4);              // number of patches
-  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 4, ksize, ksize, input_depth}};
-  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
-                                                                           patchRowMajorTensorRange);
-  gpu_result_row_major.device(sycl_device) =
-      gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, 1, 1, PADDING_VALID);
-  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
-
-  // No padding is carried out.
-  IndexType row_padding = 0;
-  IndexType col_padding = 0;
-
-  for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
-    for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
-      IndexType patchId = i + input_rows * j;
-      for (IndexType r = 0; r < ksize; ++r) {                // patch rows
-        for (IndexType c = 0; c < ksize; ++c) {              // patch cols
-          for (IndexType d = 0; d < input_depth; ++d) {      // depth
-            for (IndexType b = 0; b < input_batches; ++b) {  // batch
-              DataType expected_col_major = 0.0f;
-              DataType expected_row_major = 0.0f;
-              IndexType row_offset = r + i - row_padding;
-              IndexType col_offset = c + j - col_padding;
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
-                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              // ColMajor
-              if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
-              // RowMajor
-              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// Verifies SAME padding.
-template <typename DataType, typename IndexType>
-static void test_patch_padding_same_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType input_depth = 3;
-  IndexType input_rows = 4;
-  IndexType input_cols = 2;
-  IndexType input_batches = 1;
-  IndexType ksize = 2;   // Corresponds to the Rows and Cols for tensor.extract_image_patches<>.
-  IndexType stride = 2;  // Only same stride is supported.
-
-  // ColMajor
-  array<IndexType, 4> tensorColMajorRange = {{input_depth, input_rows, input_cols, input_batches}};
-  array<IndexType, 4> tensorRowMajorRange = {{input_batches, input_cols, input_rows, input_depth}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  Tensor<DataType, 4, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_col_major.size()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(3));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(3), tensor_row_major.dimension(0));
-
-  // Initializes tensor with incrementing numbers.
-  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
-    tensor_col_major.data()[i] = i + 1;
-  }
-
-  array<IndexType, 5> patchColMajorTensorRange = {{input_depth, ksize, ksize, 2, input_batches}};
-  Tensor<DataType, 5, DataLayout, IndexType> result_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = result_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_result_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_result_col_major(gpu_data_result_col_major,
-                                                                             patchColMajorTensorRange);
-  gpu_result_col_major.device(sycl_device) =
-      gpu_col_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
-  sycl_device.memcpyDeviceToHost(result_col_major.data(), gpu_data_result_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(result_col_major.dimension(0), input_depth);    // depth
-  VERIFY_IS_EQUAL(result_col_major.dimension(1), ksize);          // kernel rows
-  VERIFY_IS_EQUAL(result_col_major.dimension(2), ksize);          // kernel cols
-  VERIFY_IS_EQUAL(result_col_major.dimension(3), 2);              // number of patches
-  VERIFY_IS_EQUAL(result_col_major.dimension(4), input_batches);  // number of batches
-
-  // RowMajor
-
-  array<IndexType, 5> patchRowMajorTensorRange = {{input_batches, 2, ksize, ksize, input_depth}};
-  Tensor<DataType, 5, RowMajor, IndexType> result_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = result_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_result_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_result_row_major(gpu_data_result_row_major,
-                                                                           patchRowMajorTensorRange);
-  gpu_result_row_major.device(sycl_device) =
-      gpu_row_major.extract_image_patches(ksize, ksize, stride, stride, PADDING_SAME);
-  sycl_device.memcpyDeviceToHost(result_row_major.data(), gpu_data_result_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(result_col_major.dimension(0), result_row_major.dimension(4));
-  VERIFY_IS_EQUAL(result_col_major.dimension(1), result_row_major.dimension(3));
-  VERIFY_IS_EQUAL(result_col_major.dimension(2), result_row_major.dimension(2));
-  VERIFY_IS_EQUAL(result_col_major.dimension(3), result_row_major.dimension(1));
-  VERIFY_IS_EQUAL(result_col_major.dimension(4), result_row_major.dimension(0));
-
-  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
-  IndexType row_padding = 0;
-  IndexType col_padding = 0;
-
-  for (IndexType i = 0; (i + stride + ksize - 1) <= input_rows; i += stride) {    // input rows
-    for (IndexType j = 0; (j + stride + ksize - 1) <= input_cols; j += stride) {  // input cols
-      IndexType patchId = i + input_rows * j;
-      for (IndexType r = 0; r < ksize; ++r) {                // patch rows
-        for (IndexType c = 0; c < ksize; ++c) {              // patch cols
-          for (IndexType d = 0; d < input_depth; ++d) {      // depth
-            for (IndexType b = 0; b < input_batches; ++b) {  // batch
-              DataType expected_col_major = 0.0f;
-              DataType expected_row_major = 0.0f;
-              IndexType row_offset = r * stride + i - row_padding;
-              IndexType col_offset = c * stride + j - col_padding;
-              if (row_offset >= 0 && col_offset >= 0 && row_offset < input_rows && col_offset < input_cols) {
-                expected_col_major = tensor_col_major(d, row_offset, col_offset, b);
-                expected_row_major = tensor_row_major(b, col_offset, row_offset, d);
-              }
-              // ColMajor
-              if (result_col_major(d, r, c, patchId, b) != expected_col_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_col_major(d, r, c, patchId, b), expected_col_major);
-              // RowMajor
-              if (result_row_major(b, patchId, c, r, d) != expected_row_major) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(result_row_major(b, patchId, c, r, d), expected_row_major);
-              // Check that ColMajor and RowMajor agree.
-              VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-template <typename DataType, typename IndexType>
-static void test_patch_no_extra_dim_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-
-  // ColMajor
-  array<IndexType, 3> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  array<IndexType, 3> tensorRowMajorRange = {{sizeDim3, sizeDim2, sizeDim1}};
-  Tensor<DataType, 3, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  tensor_col_major.setRandom();
-  Tensor<DataType, 3, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_row_major.size()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(0), tensor_row_major.dimension(2));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(1), tensor_row_major.dimension(1));
-  VERIFY_IS_EQUAL(tensor_col_major.dimension(2), tensor_row_major.dimension(0));
-
-  // Single pixel patch: ColMajor
-  array<IndexType, 4> patchColMajorTensorRange = {{sizeDim1, 1, 1, sizeDim2 * sizeDim3}};
-  Tensor<DataType, 4, DataLayout, IndexType> single_patch_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = single_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_single_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_single_patch_col_major(gpu_data_single_patch_col_major,
-                                                                                   patchColMajorTensorRange);
-  gpu_single_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(1, 1);
-  sycl_device.memcpyDeviceToHost(single_patch_col_major.data(), gpu_data_single_patch_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_patch_col_major.dimension(3), sizeDim2 * sizeDim3);
-
-  // Single pixel patch: RowMajor
-  array<IndexType, 4> patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, 1, 1, sizeDim1}};
-  Tensor<DataType, 4, RowMajor, IndexType> single_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = single_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_single_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_single_patch_row_major(gpu_data_single_patch_row_major,
-                                                                                 patchRowMajorTensorRange);
-  gpu_single_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(1, 1);
-  sycl_device.memcpyDeviceToHost(single_patch_row_major.data(), gpu_data_single_patch_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(0), sizeDim2 * sizeDim3);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_patch_row_major.dimension(3), sizeDim1);
-
-  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
-    // ColMajor
-    if (tensor_col_major.data()[i] != single_patch_col_major.data()[i]) {
-      std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
-                << single_patch_col_major.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], tensor_col_major.data()[i]);
-    // RowMajor
-    if (tensor_row_major.data()[i] != single_patch_row_major.data()[i]) {
-      std::cout << "Mismatch detected at index " << i << " : " << tensor_col_major.data()[i] << " vs "
-                << single_patch_row_major.data()[i] << std::endl;
-    }
-    VERIFY_IS_EQUAL(single_patch_row_major.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
-    VERIFY_IS_EQUAL(single_patch_col_major.data()[i], single_patch_row_major.data()[i]);
-  }
-
-  // Entire image patch: ColMajor
-  patchColMajorTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim2 * sizeDim3}};
-  Tensor<DataType, 4, DataLayout, IndexType> entire_image_patch_col_major(patchColMajorTensorRange);
-  patchTensorBuffSize = entire_image_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_entire_image_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_entire_image_patch_col_major(
-      gpu_data_entire_image_patch_col_major, patchColMajorTensorRange);
-  gpu_entire_image_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(3, 5);
-  sycl_device.memcpyDeviceToHost(entire_image_patch_col_major.data(), gpu_data_entire_image_patch_col_major,
-                                 patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(0), 2);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(1), 3);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(2), 5);
-  VERIFY_IS_EQUAL(entire_image_patch_col_major.dimension(3), 3 * 5);
-
-  // Entire image patch: RowMajor
-  patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, sizeDim3, sizeDim2, sizeDim1}};
-  Tensor<DataType, 4, RowMajor, IndexType> entire_image_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = entire_image_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_entire_image_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_entire_image_patch_row_major(
-      gpu_data_entire_image_patch_row_major, patchRowMajorTensorRange);
-  gpu_entire_image_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(3, 5);
-  sycl_device.memcpyDeviceToHost(entire_image_patch_row_major.data(), gpu_data_entire_image_patch_row_major,
-                                 patchTensorBuffSize);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(0), 3 * 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(1), 5);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(2), 3);
-  VERIFY_IS_EQUAL(entire_image_patch_row_major.dimension(3), 2);
-
-  for (IndexType i = 0; i < 3; ++i) {
-    for (IndexType j = 0; j < 5; ++j) {
-      IndexType patchId = i + 3 * j;
-      for (IndexType r = 0; r < 3; ++r) {
-        for (IndexType c = 0; c < 5; ++c) {
-          for (IndexType d = 0; d < 2; ++d) {
-            DataType expected_col_major = 0.0f;
-            DataType expected_row_major = 0.0f;
-            if (r - 1 + i >= 0 && c - 2 + j >= 0 && r - 1 + i < 3 && c - 2 + j < 5) {
-              expected_col_major = tensor_col_major(d, r - 1 + i, c - 2 + j);
-              expected_row_major = tensor_row_major(c - 2 + j, r - 1 + i, d);
-            }
-            // ColMajor
-            if (entire_image_patch_col_major(d, r, c, patchId) != expected_col_major) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(entire_image_patch_col_major(d, r, c, patchId), expected_col_major);
-            // RowMajor
-            if (entire_image_patch_row_major(patchId, c, r, d) != expected_row_major) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(entire_image_patch_row_major(patchId, c, r, d), expected_row_major);
-            // Check that ColMajor and RowMajor agree.
-            VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-          }
-        }
-      }
-    }
-  }
-
-  // 2D patch: ColMajor
-  patchColMajorTensorRange = {{sizeDim1, 2, 2, sizeDim2 * sizeDim3}};
-  Tensor<DataType, 4, DataLayout, IndexType> twod_patch_col_major(patchColMajorTensorRange);
-  patchTensorBuffSize = twod_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_twod_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_twod_patch_col_major(gpu_data_twod_patch_col_major,
-                                                                                 patchColMajorTensorRange);
-  gpu_twod_patch_col_major.device(sycl_device) = gpu_col_major.extract_image_patches(2, 2);
-  sycl_device.memcpyDeviceToHost(twod_patch_col_major.data(), gpu_data_twod_patch_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(0), 2);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(1), 2);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch_col_major.dimension(3), 3 * 5);
-
-  // 2D patch: RowMajor
-  patchRowMajorTensorRange = {{sizeDim2 * sizeDim3, 2, 2, sizeDim1}};
-  Tensor<DataType, 4, RowMajor, IndexType> twod_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = twod_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_twod_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, RowMajor, IndexType>> gpu_twod_patch_row_major(gpu_data_twod_patch_row_major,
-                                                                               patchRowMajorTensorRange);
-  gpu_twod_patch_row_major.device(sycl_device) = gpu_row_major.extract_image_patches(2, 2);
-  sycl_device.memcpyDeviceToHost(twod_patch_row_major.data(), gpu_data_twod_patch_row_major, patchTensorBuffSize);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(0), 3 * 5);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(1), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(2), 2);
-  VERIFY_IS_EQUAL(twod_patch_row_major.dimension(3), 2);
-
-  // Based on the calculation described in TensorTraits.h, padding happens to be 0.
-  IndexType row_padding = 0;
-  IndexType col_padding = 0;
-  IndexType stride = 1;
-
-  for (IndexType i = 0; i < 3; ++i) {
-    for (IndexType j = 0; j < 5; ++j) {
-      IndexType patchId = i + 3 * j;
-      for (IndexType r = 0; r < 2; ++r) {
-        for (IndexType c = 0; c < 2; ++c) {
-          for (IndexType d = 0; d < 2; ++d) {
-            DataType expected_col_major = 0.0f;
-            DataType expected_row_major = 0.0f;
-            IndexType row_offset = r * stride + i - row_padding;
-            IndexType col_offset = c * stride + j - col_padding;
-            // ColMajor
-            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_col_major.dimension(1) &&
-                col_offset < tensor_col_major.dimension(2)) {
-              expected_col_major = tensor_col_major(d, row_offset, col_offset);
-            }
-            if (twod_patch_col_major(d, r, c, patchId) != expected_col_major) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(twod_patch_col_major(d, r, c, patchId), expected_col_major);
-            // RowMajor
-            if (row_offset >= 0 && col_offset >= 0 && row_offset < tensor_row_major.dimension(1) &&
-                col_offset < tensor_row_major.dimension(0)) {
-              expected_row_major = tensor_row_major(col_offset, row_offset, d);
-            }
-            if (twod_patch_row_major(patchId, c, r, d) != expected_row_major) {
-              std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c << " d=" << d
-                        << std::endl;
-            }
-            VERIFY_IS_EQUAL(twod_patch_row_major(patchId, c, r, d), expected_row_major);
-            // Check that ColMajor and RowMajor agree.
-            VERIFY_IS_EQUAL(expected_col_major, expected_row_major);
-          }
-        }
-      }
-    }
-  }
-
-  sycl_device.deallocate(gpu_data_col_major);
-  sycl_device.deallocate(gpu_data_row_major);
-  sycl_device.deallocate(gpu_data_single_patch_col_major);
-  sycl_device.deallocate(gpu_data_single_patch_row_major);
-  sycl_device.deallocate(gpu_data_entire_image_patch_col_major);
-  sycl_device.deallocate(gpu_data_entire_image_patch_row_major);
-  sycl_device.deallocate(gpu_data_twod_patch_col_major);
-  sycl_device.deallocate(gpu_data_twod_patch_row_major);
-}
-
-template <typename DataType, typename IndexType>
-static void test_imagenet_patches_sycl(const Eigen::SyclDevice& sycl_device) {
-  // Test the code on typical configurations used by the 'imagenet' benchmarks at
-  // https://github.com/soumith/convnet-benchmarks
-  // ColMajor
-  IndexType sizeDim1 = 3;
-  IndexType sizeDim2 = 128;
-  IndexType sizeDim3 = 128;
-  IndexType sizeDim4 = 16;
-  array<IndexType, 4> tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> l_in_col_major(tensorColMajorRange);
-  l_in_col_major.setRandom();
-
-  DataType* gpu_data_l_in_col_major =
-      static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major(gpu_data_l_in_col_major, tensorColMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
-                                 (l_in_col_major.size()) * sizeof(DataType));
-
-  array<IndexType, 5> patchTensorRange = {{sizeDim1, 11, 11, sizeDim2 * sizeDim3, sizeDim4}};
-  Tensor<DataType, 5, DataLayout, IndexType> l_out_col_major(patchTensorRange);
-  size_t patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major(gpu_data_l_out_col_major, patchTensorRange);
-  gpu_l_out_col_major.device(sycl_device) = gpu_l_in_col_major.extract_image_patches(11, 11);
-  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 11);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 11);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), sizeDim2 * sizeDim3);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), sizeDim4);
-
-  // RowMajor
-  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 11, 11, sizeDim1}};
-  Tensor<DataType, 5, RowMajor, IndexType> l_out_row_major(patchTensorRange);
-  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major(gpu_data_l_out_row_major, patchTensorRange);
-  gpu_l_out_row_major.device(sycl_device) = gpu_l_in_col_major.swap_layout().extract_image_patches(11, 11);
-  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), sizeDim4);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), sizeDim2 * sizeDim3);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 11);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 11);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), sizeDim1);
-
-  for (IndexType b = 0; b < 16; ++b) {
-    for (IndexType i = 0; i < 128; ++i) {
-      for (IndexType j = 0; j < 128; ++j) {
-        IndexType patchId = i + 128 * j;
-        for (IndexType c = 0; c < 11; ++c) {
-          for (IndexType r = 0; r < 11; ++r) {
-            for (IndexType d = 0; d < 3; ++d) {
-              DataType expected = 0.0f;
-              if (r - 5 + i >= 0 && c - 5 + j >= 0 && r - 5 + i < 128 && c - 5 + j < 128) {
-                expected = l_in_col_major(d, r - 5 + i, c - 5 + j, b);
-              }
-              // ColMajor
-              if (l_out_col_major(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // ColMajor
-  sycl_device.deallocate(gpu_data_l_in_col_major);
-  sycl_device.deallocate(gpu_data_l_out_col_major);
-  sizeDim1 = 16;
-  sizeDim2 = 64;
-  sizeDim3 = 64;
-  sizeDim4 = 32;
-  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  l_in_col_major.resize(tensorColMajorRange);
-  l_in_col_major.setRandom();
-  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize1(gpu_data_l_in_col_major,
-                                                                                 tensorColMajorRange);
-
-  patchTensorRange = {{sizeDim1, 9, 9, sizeDim2 * sizeDim3, sizeDim4}};
-  l_out_col_major.resize(patchTensorRange);
-  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
-  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize1(gpu_data_l_out_col_major,
-                                                                                    patchTensorRange);
-  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
-                                 (l_in_col_major.size()) * sizeof(DataType));
-  gpu_l_out_col_major_resize1.device(sycl_device) = gpu_l_in_col_major_resize1.extract_image_patches(9, 9);
-  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 16);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 9);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 9);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 64 * 64);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
-
-  // RowMajor
-  sycl_device.deallocate(gpu_data_l_out_row_major);
-  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 9, 9, sizeDim1}};
-  l_out_row_major.resize(patchTensorRange);
-  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
-  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize1(gpu_data_l_out_row_major,
-                                                                                  patchTensorRange);
-  gpu_l_out_row_major_resize1.device(sycl_device) =
-      gpu_l_in_col_major_resize1.swap_layout().extract_image_patches(9, 9);
-  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 64 * 64);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 9);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 9);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 16);
-
-  for (IndexType b = 0; b < 32; ++b) {
-    for (IndexType i = 0; i < 64; ++i) {
-      for (IndexType j = 0; j < 64; ++j) {
-        IndexType patchId = i + 64 * j;
-        for (IndexType c = 0; c < 9; ++c) {
-          for (IndexType r = 0; r < 9; ++r) {
-            for (IndexType d = 0; d < 16; ++d) {
-              DataType expected = 0.0f;
-              if (r - 4 + i >= 0 && c - 4 + j >= 0 && r - 4 + i < 64 && c - 4 + j < 64) {
-                expected = l_in_col_major(d, r - 4 + i, c - 4 + j, b);
-              }
-              // ColMajor
-              if (l_out_col_major(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // ColMajor
-
-  sycl_device.deallocate(gpu_data_l_in_col_major);
-  sycl_device.deallocate(gpu_data_l_out_col_major);
-  sizeDim1 = 32;
-  sizeDim2 = 16;
-  sizeDim3 = 16;
-  sizeDim4 = 32;
-  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  l_in_col_major.resize(tensorColMajorRange);
-  l_in_col_major.setRandom();
-  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize2(gpu_data_l_in_col_major,
-                                                                                 tensorColMajorRange);
-
-  patchTensorRange = {{sizeDim1, 7, 7, sizeDim2 * sizeDim3, sizeDim4}};
-  l_out_col_major.resize(patchTensorRange);
-  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
-  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize2(gpu_data_l_out_col_major,
-                                                                                    patchTensorRange);
-  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
-                                 (l_in_col_major.size()) * sizeof(DataType));
-  gpu_l_out_col_major_resize2.device(sycl_device) = gpu_l_in_col_major_resize2.extract_image_patches(7, 7);
-  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 7);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 7);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 16 * 16);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
-
-  // RowMajor
-  sycl_device.deallocate(gpu_data_l_out_row_major);
-  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 7, 7, sizeDim1}};
-  l_out_row_major.resize(patchTensorRange);
-  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
-  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize2(gpu_data_l_out_row_major,
-                                                                                  patchTensorRange);
-  gpu_l_out_row_major_resize2.device(sycl_device) =
-      gpu_l_in_col_major_resize2.swap_layout().extract_image_patches(7, 7);
-  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 16 * 16);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 7);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 7);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 32);
-
-  for (IndexType b = 0; b < 32; ++b) {
-    for (IndexType i = 0; i < 16; ++i) {
-      for (IndexType j = 0; j < 16; ++j) {
-        IndexType patchId = i + 16 * j;
-        for (IndexType c = 0; c < 7; ++c) {
-          for (IndexType r = 0; r < 7; ++r) {
-            for (IndexType d = 0; d < 32; ++d) {
-              DataType expected = 0.0f;
-              if (r - 3 + i >= 0 && c - 3 + j >= 0 && r - 3 + i < 16 && c - 3 + j < 16) {
-                expected = l_in_col_major(d, r - 3 + i, c - 3 + j, b);
-              }
-              // ColMajor
-              if (l_out_col_major(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // ColMajor
-  sycl_device.deallocate(gpu_data_l_in_col_major);
-  sycl_device.deallocate(gpu_data_l_out_col_major);
-  sizeDim1 = 64;
-  sizeDim2 = 13;
-  sizeDim3 = 13;
-  sizeDim4 = 32;
-  tensorColMajorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  l_in_col_major.resize(tensorColMajorRange);
-  l_in_col_major.setRandom();
-  gpu_data_l_in_col_major = static_cast<DataType*>(sycl_device.allocate(l_in_col_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, ColMajor, IndexType>> gpu_l_in_col_major_resize3(gpu_data_l_in_col_major,
-                                                                                 tensorColMajorRange);
-
-  patchTensorRange = {{sizeDim1, 3, 3, sizeDim2 * sizeDim3, sizeDim4}};
-  l_out_col_major.resize(patchTensorRange);
-  patchTensorBuffSize = l_out_col_major.size() * sizeof(DataType);
-  gpu_data_l_out_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_l_out_col_major_resize3(gpu_data_l_out_col_major,
-                                                                                    patchTensorRange);
-  sycl_device.memcpyHostToDevice(gpu_data_l_in_col_major, l_in_col_major.data(),
-                                 (l_in_col_major.size()) * sizeof(DataType));
-  gpu_l_out_col_major_resize3.device(sycl_device) = gpu_l_in_col_major_resize3.extract_image_patches(3, 3);
-  sycl_device.memcpyDeviceToHost(l_out_col_major.data(), gpu_data_l_out_col_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(0), 64);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(1), 3);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(2), 3);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(3), 13 * 13);
-  VERIFY_IS_EQUAL(l_out_col_major.dimension(4), 32);
-
-  // RowMajor
-  sycl_device.deallocate(gpu_data_l_out_row_major);
-  patchTensorRange = {{sizeDim4, sizeDim2 * sizeDim3, 3, 3, sizeDim1}};
-  l_out_row_major.resize(patchTensorRange);
-  patchTensorBuffSize = l_out_row_major.size() * sizeof(DataType);
-  gpu_data_l_out_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_l_out_row_major_resize3(gpu_data_l_out_row_major,
-                                                                                  patchTensorRange);
-  gpu_l_out_row_major_resize3.device(sycl_device) =
-      gpu_l_in_col_major_resize3.swap_layout().extract_image_patches(3, 3);
-  sycl_device.memcpyDeviceToHost(l_out_row_major.data(), gpu_data_l_out_row_major, patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(0), 32);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(1), 13 * 13);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(2), 3);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(3), 3);
-  VERIFY_IS_EQUAL(l_out_row_major.dimension(4), 64);
-
-  for (IndexType b = 0; b < 32; ++b) {
-    for (IndexType i = 0; i < 13; ++i) {
-      for (IndexType j = 0; j < 13; ++j) {
-        IndexType patchId = i + 13 * j;
-        for (IndexType c = 0; c < 3; ++c) {
-          for (IndexType r = 0; r < 3; ++r) {
-            for (IndexType d = 0; d < 64; ++d) {
-              DataType expected = 0.0f;
-              if (r - 1 + i >= 0 && c - 1 + j >= 0 && r - 1 + i < 13 && c - 1 + j < 13) {
-                expected = l_in_col_major(d, r - 1 + i, c - 1 + j, b);
-              }
-              // ColMajor
-              if (l_out_col_major(d, r, c, patchId, b) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_col_major(d, r, c, patchId, b), expected);
-              // RowMajor
-              if (l_out_row_major(b, patchId, c, r, d) != expected) {
-                std::cout << "Mismatch detected at index i=" << i << " j=" << j << " r=" << r << " c=" << c
-                          << " d=" << d << " b=" << b << std::endl;
-              }
-              VERIFY_IS_EQUAL(l_out_row_major(b, patchId, c, r, d), expected);
-            }
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_l_in_col_major);
-  sycl_device.deallocate(gpu_data_l_out_col_major);
-  sycl_device.deallocate(gpu_data_l_out_row_major);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_tensor_image_patch_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_image_patch_sycl<DataType, int64_t>(sycl_device);
-  test_patch_padding_valid_sycl<DataType, int64_t>(sycl_device);
-  test_patch_padding_valid_same_value_sycl<DataType, int64_t>(sycl_device);
-  test_patch_padding_same_sycl<DataType, int64_t>(sycl_device);
-  test_patch_no_extra_dim_sycl<DataType, int64_t>(sycl_device);
-  test_imagenet_patches_sycl<DataType, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_image_patch_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_tensor_image_patch_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_index_list.cpp b/unsupported/test/cxx11_tensor_index_list.cpp
deleted file mode 100644
index ef71474..0000000
--- a/unsupported/test/cxx11_tensor_index_list.cpp
+++ /dev/null
@@ -1,424 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-static void test_static_index_list() {
-  Tensor<float, 4> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  constexpr auto reduction_axis = make_index_list(0, 1, 2);
-  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 0);
-  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
-  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 2);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 0);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 2);
-
-  VERIFY_IS_EQUAL(reduction_axis.size(), std::size_t(3));
-
-  EIGEN_STATIC_ASSERT((internal::array_get<0>(reduction_axis) == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::array_get<1>(reduction_axis) == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::array_get<2>(reduction_axis) == 2), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  Tensor<float, 1> result = tensor.sum(reduction_axis);
-  for (int i = 0; i < result.size(); ++i) {
-    float expected = 0.0f;
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 5; ++l) {
-          expected += tensor(j, k, l, i);
-        }
-      }
-    }
-    VERIFY_IS_APPROX(result(i), expected);
-  }
-}
-
-static void test_type2index_list() {
-  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-  tensor += tensor.constant(10.0f);
-
-  typedef Eigen::IndexList<Eigen::type2index<0>> Dims0;
-  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>> Dims1;
-  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>> Dims2;
-  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>, Eigen::type2index<3>>
-      Dims3;
-  typedef Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>, Eigen::type2index<2>, Eigen::type2index<3>,
-                           Eigen::type2index<4>>
-      Dims4;
-
-#if 0
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims0>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims1>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims2>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims3>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<Dims4>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-#endif
-
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims0, 1, ColMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims1, 2, ColMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims2, 3, ColMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims3, 4, ColMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims4, 5, ColMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims0, 1, RowMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims1, 2, RowMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims2, 3, RowMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims3, 4, RowMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::are_inner_most_dims<Dims4, 5, RowMajor>::value == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  const Dims0 reduction_axis0;
-  Tensor<float, 4> result0 = tensor.sum(reduction_axis0);
-  for (int m = 0; m < 11; ++m) {
-    for (int l = 0; l < 7; ++l) {
-      for (int k = 0; k < 5; ++k) {
-        for (int j = 0; j < 3; ++j) {
-          float expected = 0.0f;
-          for (int i = 0; i < 2; ++i) {
-            expected += tensor(i, j, k, l, m);
-          }
-          VERIFY_IS_APPROX(result0(j, k, l, m), expected);
-        }
-      }
-    }
-  }
-
-  const Dims1 reduction_axis1;
-  Tensor<float, 3> result1 = tensor.sum(reduction_axis1);
-  for (int m = 0; m < 11; ++m) {
-    for (int l = 0; l < 7; ++l) {
-      for (int k = 0; k < 5; ++k) {
-        float expected = 0.0f;
-        for (int j = 0; j < 3; ++j) {
-          for (int i = 0; i < 2; ++i) {
-            expected += tensor(i, j, k, l, m);
-          }
-        }
-        VERIFY_IS_APPROX(result1(k, l, m), expected);
-      }
-    }
-  }
-
-  const Dims2 reduction_axis2;
-  Tensor<float, 2> result2 = tensor.sum(reduction_axis2);
-  for (int m = 0; m < 11; ++m) {
-    for (int l = 0; l < 7; ++l) {
-      float expected = 0.0f;
-      for (int k = 0; k < 5; ++k) {
-        for (int j = 0; j < 3; ++j) {
-          for (int i = 0; i < 2; ++i) {
-            expected += tensor(i, j, k, l, m);
-          }
-        }
-      }
-      VERIFY_IS_APPROX(result2(l, m), expected);
-    }
-  }
-
-  const Dims3 reduction_axis3;
-  Tensor<float, 1> result3 = tensor.sum(reduction_axis3);
-  for (int m = 0; m < 11; ++m) {
-    float expected = 0.0f;
-    for (int l = 0; l < 7; ++l) {
-      for (int k = 0; k < 5; ++k) {
-        for (int j = 0; j < 3; ++j) {
-          for (int i = 0; i < 2; ++i) {
-            expected += tensor(i, j, k, l, m);
-          }
-        }
-      }
-    }
-    VERIFY_IS_APPROX(result3(m), expected);
-  }
-
-  const Dims4 reduction_axis4;
-  Tensor<float, 0> result4 = tensor.sum(reduction_axis4);
-  float expected = 0.0f;
-  for (int m = 0; m < 11; ++m) {
-    for (int l = 0; l < 7; ++l) {
-      for (int k = 0; k < 5; ++k) {
-        for (int j = 0; j < 3; ++j) {
-          for (int i = 0; i < 2; ++i) {
-            expected += tensor(i, j, k, l, m);
-          }
-        }
-      }
-    }
-  }
-  VERIFY_IS_APPROX(result4(), expected);
-}
-
-static void test_type2indexpair_list() {
-  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-  tensor += tensor.constant(10.0f);
-
-  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>> Dims0;
-  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::type2indexpair<1, 11>, Eigen::type2indexpair<2, 12>>
-      Dims2_a;
-  typedef Eigen::IndexPairList<Eigen::type2indexpair<0, 10>, Eigen::IndexPair<Index>, Eigen::type2indexpair<2, 12>>
-      Dims2_b;
-  typedef Eigen::IndexPairList<Eigen::IndexPair<Index>, Eigen::type2indexpair<1, 11>, Eigen::IndexPair<Index>> Dims2_c;
-
-  Dims2_a d2_a;
-
-  Dims2_b d2_b;
-  d2_b.set(1, Eigen::IndexPair<Index>(1, 11));
-
-  Dims2_c d2_c;
-  d2_c.set(0, Eigen::IndexPair<Index>(Eigen::IndexPair<Index>(0, 10)));
-  d2_c.set(1, Eigen::IndexPair<Index>(1, 11));  // setting type2indexpair to correct value.
-  d2_c.set(2, Eigen::IndexPair<Index>(2, 12));
-
-  VERIFY_IS_EQUAL(d2_a[0].first, 0);
-  VERIFY_IS_EQUAL(d2_a[0].second, 10);
-  VERIFY_IS_EQUAL(d2_a[1].first, 1);
-  VERIFY_IS_EQUAL(d2_a[1].second, 11);
-  VERIFY_IS_EQUAL(d2_a[2].first, 2);
-  VERIFY_IS_EQUAL(d2_a[2].second, 12);
-
-  VERIFY_IS_EQUAL(d2_b[0].first, 0);
-  VERIFY_IS_EQUAL(d2_b[0].second, 10);
-  VERIFY_IS_EQUAL(d2_b[1].first, 1);
-  VERIFY_IS_EQUAL(d2_b[1].second, 11);
-  VERIFY_IS_EQUAL(d2_b[2].first, 2);
-  VERIFY_IS_EQUAL(d2_b[2].second, 12);
-
-  VERIFY_IS_EQUAL(d2_c[0].first, 0);
-  VERIFY_IS_EQUAL(d2_c[0].second, 10);
-  VERIFY_IS_EQUAL(d2_c[1].first, 1);
-  VERIFY_IS_EQUAL(d2_c[1].second, 11);
-  VERIFY_IS_EQUAL(d2_c[2].first, 2);
-  VERIFY_IS_EQUAL(d2_c[2].second, 12);
-
-  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((d2_a.value_known_statically(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(1) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((d2_b.value_known_statically(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(0) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((d2_c.value_known_statically(2) == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims0>(0, 0) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims0>(0, 1) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(0, 0) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(0, 1) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(1, 1) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(1, 2) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(2, 2) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_a>(2, 3) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(0, 0) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(0, 1) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(1, 1) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(1, 2) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(2, 2) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_b>(2, 3) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(0, 0) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(0, 1) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(1, 1) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(1, 2) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(2, 2) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_first_statically_eq<Dims2_c>(2, 3) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims0>(0, 10) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims0>(0, 11) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(0, 10) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(0, 11) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(1, 11) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(1, 12) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(2, 12) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_a>(2, 13) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(0, 10) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(0, 11) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(1, 11) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(1, 12) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(2, 12) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_b>(2, 13) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(0, 10) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(0, 11) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(1, 11) == true),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(1, 12) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(2, 12) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((Eigen::internal::index_pair_second_statically_eq<Dims2_c>(2, 13) == false),
-                      YOU_MADE_A_PROGRAMMING_MISTAKE);
-}
-
-static void test_dynamic_index_list() {
-  Tensor<float, 4> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  int dim1 = 2;
-  int dim2 = 1;
-  int dim3 = 0;
-
-  auto reduction_axis = make_index_list(dim1, dim2, dim3);
-
-  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 2);
-  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
-  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 0);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 2);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 0);
-
-  Tensor<float, 1> result = tensor.sum(reduction_axis);
-  for (int i = 0; i < result.size(); ++i) {
-    float expected = 0.0f;
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 5; ++l) {
-          expected += tensor(j, k, l, i);
-        }
-      }
-    }
-    VERIFY_IS_APPROX(result(i), expected);
-  }
-}
-
-static void test_mixed_index_list() {
-  Tensor<float, 4> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  int dim2 = 1;
-  int dim4 = 3;
-
-  auto reduction_axis = make_index_list(0, dim2, 2, dim4);
-
-  VERIFY_IS_EQUAL(internal::array_get<0>(reduction_axis), 0);
-  VERIFY_IS_EQUAL(internal::array_get<1>(reduction_axis), 1);
-  VERIFY_IS_EQUAL(internal::array_get<2>(reduction_axis), 2);
-  VERIFY_IS_EQUAL(internal::array_get<3>(reduction_axis), 3);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[0]), 0);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[1]), 1);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[2]), 2);
-  VERIFY_IS_EQUAL(static_cast<Index>(reduction_axis[3]), 3);
-
-  typedef IndexList<type2index<0>, int, type2index<2>, int> ReductionIndices;
-  ReductionIndices reduction_indices;
-  reduction_indices.set(1, 1);
-  reduction_indices.set(3, 3);
-  EIGEN_STATIC_ASSERT((internal::array_get<0>(reduction_indices) == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::array_get<2>(reduction_indices) == 2), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_known_statically<ReductionIndices>(0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_known_statically<ReductionIndices>(2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionIndices>(0, 0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionIndices>(2, 2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-#if 0
-  EIGEN_STATIC_ASSERT((internal::all_indices_known_statically<ReductionIndices>() == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<ReductionIndices>() == false), YOU_MADE_A_PROGRAMMING_MISTAKE);
-#endif
-
-  typedef IndexList<type2index<0>, type2index<1>, type2index<2>, type2index<3>> ReductionList;
-  ReductionList reduction_list;
-  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(0, 0) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(1, 1) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(2, 2) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::index_statically_eq<ReductionList>(3, 3) == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-#if 0
-  EIGEN_STATIC_ASSERT((internal::all_indices_known_statically<ReductionList>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::indices_statically_known_to_increase<ReductionList>() == true), YOU_MADE_A_PROGRAMMING_MISTAKE);
-#endif
-
-  Tensor<float, 0> result1 = tensor.sum(reduction_axis);
-  Tensor<float, 0> result2 = tensor.sum(reduction_indices);
-  Tensor<float, 0> result3 = tensor.sum(reduction_list);
-
-  float expected = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          expected += tensor(i, j, k, l);
-        }
-      }
-    }
-  }
-  VERIFY_IS_APPROX(result1(), expected);
-  VERIFY_IS_APPROX(result2(), expected);
-  VERIFY_IS_APPROX(result3(), expected);
-}
-
-static void test_dim_check() {
-  Eigen::IndexList<Eigen::type2index<1>, int> dim1;
-  dim1.set(1, 2);
-  Eigen::IndexList<Eigen::type2index<1>, int> dim2;
-  dim2.set(1, 2);
-  VERIFY(dimensions_match(dim1, dim2));
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_index_list) {
-  CALL_SUBTEST(test_static_index_list());
-  CALL_SUBTEST(test_type2index_list());
-  CALL_SUBTEST(test_type2indexpair_list());
-  CALL_SUBTEST(test_dynamic_index_list());
-  CALL_SUBTEST(test_mixed_index_list());
-  CALL_SUBTEST(test_dim_check());
-}
diff --git a/unsupported/test/cxx11_tensor_inflation.cpp b/unsupported/test/cxx11_tensor_inflation.cpp
deleted file mode 100644
index 1c8edea..0000000
--- a/unsupported/test/cxx11_tensor_inflation.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Ke Yang <yangke@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_inflation() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> strides;
-
-  strides[0] = 1;
-  strides[1] = 1;
-  strides[2] = 1;
-  strides[3] = 1;
-
-  Tensor<float, 4, DataLayout> no_stride;
-  no_stride = tensor.inflate(strides);
-
-  VERIFY_IS_EQUAL(no_stride.dimension(0), 2);
-  VERIFY_IS_EQUAL(no_stride.dimension(1), 3);
-  VERIFY_IS_EQUAL(no_stride.dimension(2), 5);
-  VERIFY_IS_EQUAL(no_stride.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  strides[0] = 2;
-  strides[1] = 4;
-  strides[2] = 2;
-  strides[3] = 3;
-  Tensor<float, 4, DataLayout> inflated;
-  inflated = tensor.inflate(strides);
-
-  VERIFY_IS_EQUAL(inflated.dimension(0), 3);
-  VERIFY_IS_EQUAL(inflated.dimension(1), 9);
-  VERIFY_IS_EQUAL(inflated.dimension(2), 9);
-  VERIFY_IS_EQUAL(inflated.dimension(3), 19);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 9; ++j) {
-      for (int k = 0; k < 9; ++k) {
-        for (int l = 0; l < 19; ++l) {
-          if (i % 2 == 0 && j % 4 == 0 && k % 2 == 0 && l % 3 == 0) {
-            VERIFY_IS_EQUAL(inflated(i, j, k, l), tensor(i / 2, j / 4, k / 2, l / 3));
-          } else {
-            VERIFY_IS_EQUAL(0, inflated(i, j, k, l));
-          }
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_inflation) {
-  CALL_SUBTEST(test_simple_inflation<ColMajor>());
-  CALL_SUBTEST(test_simple_inflation<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_inflation_sycl.cpp b/unsupported/test/cxx11_tensor_inflation_sycl.cpp
deleted file mode 100644
index 5001100..0000000
--- a/unsupported/test/cxx11_tensor_inflation_sycl.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-// Inflation Definition for each dimension the inflated val would be
-//((dim-1)*strid[dim] +1)
-
-// for 1 dimension vector of size 3 with value (4,4,4) with the inflated stride value of 3 would be changed to
-// tensor of size (2*3) +1 = 7 with the value of
-// (4, 0, 0, 4, 0, 0, 4).
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_simple_inflation_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> no_stride(tensorRange);
-  tensor.setRandom();
-
-  array<IndexType, 4> strides;
-  strides[0] = 1;
-  strides[1] = 1;
-  strides[2] = 1;
-  strides[3] = 1;
-
-  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
-  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_no_stride = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_no_stride(gpu_data_no_stride, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
-  gpu_no_stride.device(sycl_device) = gpu_tensor.inflate(strides);
-  sycl_device.memcpyDeviceToHost(no_stride.data(), gpu_data_no_stride, tensorBuffSize);
-
-  VERIFY_IS_EQUAL(no_stride.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(no_stride.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(no_stride.dimension(2), sizeDim3);
-  VERIFY_IS_EQUAL(no_stride.dimension(3), sizeDim4);
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  strides[0] = 2;
-  strides[1] = 4;
-  strides[2] = 2;
-  strides[3] = 3;
-
-  IndexType inflatedSizeDim1 = 3;
-  IndexType inflatedSizeDim2 = 9;
-  IndexType inflatedSizeDim3 = 9;
-  IndexType inflatedSizeDim4 = 19;
-  array<IndexType, 4> inflatedTensorRange = {{inflatedSizeDim1, inflatedSizeDim2, inflatedSizeDim3, inflatedSizeDim4}};
-
-  Tensor<DataType, 4, DataLayout, IndexType> inflated(inflatedTensorRange);
-
-  const size_t inflatedTensorBuffSize = inflated.size() * sizeof(DataType);
-  DataType* gpu_data_inflated = static_cast<DataType*>(sycl_device.allocate(inflatedTensorBuffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_inflated(gpu_data_inflated, inflatedTensorRange);
-  gpu_inflated.device(sycl_device) = gpu_tensor.inflate(strides);
-  sycl_device.memcpyDeviceToHost(inflated.data(), gpu_data_inflated, inflatedTensorBuffSize);
-
-  VERIFY_IS_EQUAL(inflated.dimension(0), inflatedSizeDim1);
-  VERIFY_IS_EQUAL(inflated.dimension(1), inflatedSizeDim2);
-  VERIFY_IS_EQUAL(inflated.dimension(2), inflatedSizeDim3);
-  VERIFY_IS_EQUAL(inflated.dimension(3), inflatedSizeDim4);
-
-  for (IndexType i = 0; i < inflatedSizeDim1; ++i) {
-    for (IndexType j = 0; j < inflatedSizeDim2; ++j) {
-      for (IndexType k = 0; k < inflatedSizeDim3; ++k) {
-        for (IndexType l = 0; l < inflatedSizeDim4; ++l) {
-          if (i % strides[0] == 0 && j % strides[1] == 0 && k % strides[2] == 0 && l % strides[3] == 0) {
-            VERIFY_IS_EQUAL(inflated(i, j, k, l),
-                            tensor(i / strides[0], j / strides[1], k / strides[2], l / strides[3]));
-          } else {
-            VERIFY_IS_EQUAL(0, inflated(i, j, k, l));
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_tensor);
-  sycl_device.deallocate(gpu_data_no_stride);
-  sycl_device.deallocate(gpu_data_inflated);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_inflation_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_inflation_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_inflation_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_inflation_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_inflation_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_inflation_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_intdiv.cpp b/unsupported/test/cxx11_tensor_intdiv.cpp
deleted file mode 100644
index 3d818e0..0000000
--- a/unsupported/test/cxx11_tensor_intdiv.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014-2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-void test_signed_32bit() {
-  // Divide by one
-  const Eigen::internal::TensorIntDivisor<int32_t, false> div_by_one(1);
-
-  for (int32_t j = 0; j < 25000; ++j) {
-    const int32_t fast_div = j / div_by_one;
-    const int32_t slow_div = j / 1;
-    VERIFY_IS_EQUAL(fast_div, slow_div);
-  }
-
-  // Standard divide by 2 or more
-  for (int32_t i = 2; i < 25000; ++i) {
-    const Eigen::internal::TensorIntDivisor<int32_t, false> div(i);
-
-    for (int32_t j = 0; j < 25000; ++j) {
-      const int32_t fast_div = j / div;
-      const int32_t slow_div = j / i;
-      VERIFY_IS_EQUAL(fast_div, slow_div);
-    }
-  }
-
-  // Optimized divide by 2 or more
-  for (int32_t i = 2; i < 25000; ++i) {
-    const Eigen::internal::TensorIntDivisor<int32_t, true> div(i);
-
-    for (int32_t j = 0; j < 25000; ++j) {
-      const int32_t fast_div = j / div;
-      const int32_t slow_div = j / i;
-      VERIFY_IS_EQUAL(fast_div, slow_div);
-    }
-  }
-}
-
-void test_unsigned_32bit() {
-  for (uint32_t i = 1; i < 25000; ++i) {
-    const Eigen::internal::TensorIntDivisor<uint32_t> div(i);
-
-    for (uint32_t j = 0; j < 25000; ++j) {
-      const uint32_t fast_div = j / div;
-      const uint32_t slow_div = j / i;
-      VERIFY_IS_EQUAL(fast_div, slow_div);
-    }
-  }
-}
-
-void test_signed_64bit() {
-  for (int64_t i = 1; i < 25000; ++i) {
-    const Eigen::internal::TensorIntDivisor<int64_t> div(i);
-
-    for (int64_t j = 0; j < 25000; ++j) {
-      const int64_t fast_div = j / div;
-      const int64_t slow_div = j / i;
-      VERIFY_IS_EQUAL(fast_div, slow_div);
-    }
-  }
-}
-
-void test_unsigned_64bit() {
-  for (uint64_t i = 1; i < 25000; ++i) {
-    const Eigen::internal::TensorIntDivisor<uint64_t> div(i);
-
-    for (uint64_t j = 0; j < 25000; ++j) {
-      const uint64_t fast_div = j / div;
-      const uint64_t slow_div = j / i;
-      VERIFY_IS_EQUAL(fast_div, slow_div);
-    }
-  }
-}
-
-void test_powers_32bit() {
-  for (int expon = 1; expon < 31; expon++) {
-    int32_t div = (1 << expon);
-    for (int num_expon = 0; num_expon < 32; num_expon++) {
-      int32_t start_num = (1 << num_expon) - 100;
-      int32_t end_num = (1 << num_expon) + 100;
-      if (start_num < 0) start_num = 0;
-      for (int32_t num = start_num; num < end_num; num++) {
-        Eigen::internal::TensorIntDivisor<int32_t> divider = Eigen::internal::TensorIntDivisor<int32_t>(div);
-        int32_t result = num / div;
-        int32_t result_op = divider.divide(num);
-        VERIFY_IS_EQUAL(result_op, result);
-      }
-    }
-  }
-}
-
-void test_powers_64bit() {
-  for (int expon = 0; expon < 63; expon++) {
-    int64_t div = (1ull << expon);
-    for (int num_expon = 0; num_expon < 63; num_expon++) {
-      int64_t start_num = (1ull << num_expon) - 10;
-      int64_t end_num = (1ull << num_expon) + 10;
-      if (start_num < 0) start_num = 0;
-      for (int64_t num = start_num; num < end_num; num++) {
-        Eigen::internal::TensorIntDivisor<int64_t> divider(div);
-        int64_t result = num / div;
-        int64_t result_op = divider.divide(num);
-        VERIFY_IS_EQUAL(result_op, result);
-      }
-    }
-  }
-}
-
-void test_specific() {
-  // A particular combination that was previously failing
-  int64_t div = 209715200;
-  int64_t num = 3238002688ll;
-  Eigen::internal::TensorIntDivisor<int64_t> divider(div);
-  int64_t result = num / div;
-  int64_t result_op = divider.divide(num);
-  VERIFY_IS_EQUAL(result, result_op);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_intdiv) {
-  CALL_SUBTEST_1(test_signed_32bit());
-  CALL_SUBTEST_2(test_unsigned_32bit());
-  CALL_SUBTEST_3(test_signed_64bit());
-  CALL_SUBTEST_4(test_unsigned_64bit());
-  CALL_SUBTEST_5(test_powers_32bit());
-  CALL_SUBTEST_6(test_powers_64bit());
-  CALL_SUBTEST_7(test_specific());
-}
diff --git a/unsupported/test/cxx11_tensor_io.cpp b/unsupported/test/cxx11_tensor_io.cpp
deleted file mode 100644
index ace3e7c..0000000
--- a/unsupported/test/cxx11_tensor_io.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-#include "main.h"
-
-#include <sstream>
-#include <Eigen/Tensor>
-
-template <typename Scalar, int rank, int Layout>
-struct test_tensor_ostream_impl {};
-
-template <typename Scalar, int Layout>
-struct test_tensor_ostream_impl<Scalar, 0, Layout> {
-  static void run() {
-    Eigen::Tensor<Scalar, 0> t;
-    t.setValues(1);
-    std::ostringstream os;
-    os << t.format(Eigen::TensorIOFormat::Plain());
-    VERIFY(os.str() == "1");
-  }
-};
-
-template <typename Scalar, int Layout>
-struct test_tensor_ostream_impl<Scalar, 1, Layout> {
-  static void run() {
-    Eigen::Tensor<Scalar, 1> t = {3};
-    t.setValues({1, 2, 3});
-    std::ostringstream os;
-    os << t.format(Eigen::TensorIOFormat::Plain());
-    VERIFY(os.str() == "1 2 3");
-  }
-};
-
-template <typename Scalar, int Layout>
-struct test_tensor_ostream_impl<Scalar, 2, Layout> {
-  static void run() {
-    Eigen::Tensor<Scalar, 2> t = {3, 2};
-    t.setValues({{1, 2}, {3, 4}, {5, 6}});
-    std::ostringstream os;
-    os << t.format(Eigen::TensorIOFormat::Plain());
-    VERIFY(os.str() == "1 2\n3 4\n5 6");
-  }
-};
-
-template <typename Scalar, int Layout>
-struct test_tensor_ostream_impl<Scalar, 3, Layout> {
-  static void run() {
-    Eigen::Tensor<Scalar, 3> t = {4, 3, 2};
-    t.setValues({{{1, 2}, {3, 4}, {5, 6}},
-                 {{7, 8}, {9, 10}, {11, 12}},
-                 {{13, 14}, {15, 16}, {17, 18}},
-                 {{19, 20}, {21, 22}, {23, 24}}});
-    std::ostringstream os;
-    os << t.format(Eigen::TensorIOFormat::Plain());
-    VERIFY(os.str() == " 1  2\n 3  4\n 5  6\n\n 7  8\n 9 10\n11 12\n\n13 14\n15 16\n17 18\n\n19 20\n21 22\n23 24");
-  }
-};
-
-template <int Layout>
-struct test_tensor_ostream_impl<bool, 2, Layout> {
-  static void run() {
-    Eigen::Tensor<bool, 2> t = {3, 2};
-    t.setValues({{false, true}, {true, false}, {false, false}});
-    std::ostringstream os;
-    os << t.format(Eigen::TensorIOFormat::Plain());
-    VERIFY(os.str() == "0 1\n1 0\n0 0");
-  }
-};
-
-template <typename Scalar, int Layout>
-struct test_tensor_ostream_impl<std::complex<Scalar>, 2, Layout> {
-  static void run() {
-    Eigen::Tensor<std::complex<Scalar>, 2> t = {3, 2};
-    t.setValues({{std::complex<Scalar>(1, 2), std::complex<Scalar>(12, 3)},
-                 {std::complex<Scalar>(-4, 2), std::complex<Scalar>(0, 5)},
-                 {std::complex<Scalar>(-1, 4), std::complex<Scalar>(5, 27)}});
-    std::ostringstream os;
-    os << t.format(Eigen::TensorIOFormat::Plain());
-    VERIFY(os.str() == " (1,2) (12,3)\n(-4,2)  (0,5)\n(-1,4) (5,27)");
-
-    os.str("");
-    os.clear();
-    os << t.format(Eigen::TensorIOFormat::Numpy());
-    VERIFY(os.str() == "[[ 1+2j 12+3j]\n [-4+2j  0+5j]\n [-1+4j 5+27j]]");
-
-    os.str("");
-    os.clear();
-    os << t.format(Eigen::TensorIOFormat::Native());
-    VERIFY(os.str() == "{{ {1, 2}, {12, 3}},\n {{-4, 2},  {0, 5}},\n {{-1, 4}, {5, 27}}}");
-  }
-};
-
-template <typename Scalar, int rank, int Layout>
-void test_tensor_ostream() {
-  test_tensor_ostream_impl<Scalar, rank, Layout>::run();
-}
-
-void test_const_tensor_ostream() {
-  Eigen::Tensor<float, 0> t;
-  t.setValues(1);
-  const Eigen::TensorMap<Eigen::Tensor<const float, 0, Eigen::RowMajor>, Eigen::Unaligned> t_const(
-      t.data(), Eigen::DSizes<Eigen::DenseIndex, 0>{});
-  std::ostringstream os;
-  os << t_const.format(Eigen::TensorIOFormat::Plain());
-  VERIFY(os.str() == "1");
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_io) {
-  CALL_SUBTEST((test_tensor_ostream<float, 0, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<float, 1, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<float, 2, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<float, 3, Eigen::ColMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<double, 0, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<double, 1, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<double, 2, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<double, 3, Eigen::ColMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<int, 0, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<int, 1, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<int, 2, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<int, 3, Eigen::ColMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<float, 0, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<float, 1, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<float, 2, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<float, 3, Eigen::RowMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<double, 0, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<double, 1, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<double, 2, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<double, 3, Eigen::RowMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<int, 0, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<int, 1, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<int, 2, Eigen::RowMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<int, 3, Eigen::RowMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<bool, 2, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<bool, 2, Eigen::RowMajor>()));
-
-  CALL_SUBTEST((test_tensor_ostream<std::complex<double>, 2, Eigen::ColMajor>()));
-  CALL_SUBTEST((test_tensor_ostream<std::complex<float>, 2, Eigen::ColMajor>()));
-
-  // Test printing TensorMap with const elements.
-  CALL_SUBTEST((test_const_tensor_ostream()));
-}
diff --git a/unsupported/test/cxx11_tensor_layout_swap.cpp b/unsupported/test/cxx11_tensor_layout_swap.cpp
deleted file mode 100644
index 46a0bb2..0000000
--- a/unsupported/test/cxx11_tensor_layout_swap.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-static void test_simple_swap() {
-  Tensor<float, 3, ColMajor> tensor(2, 3, 7);
-  tensor.setRandom();
-
-  Tensor<float, 3, RowMajor> tensor2 = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor2.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor2.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor2.dimension(0));
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor(i, j, k), tensor2(k, j, i));
-      }
-    }
-  }
-}
-
-static void test_swap_as_lvalue() {
-  Tensor<float, 3, ColMajor> tensor(2, 3, 7);
-  tensor.setRandom();
-
-  Tensor<float, 3, RowMajor> tensor2(7, 3, 2);
-  tensor2.swap_layout() = tensor;
-  VERIFY_IS_EQUAL(tensor.dimension(0), tensor2.dimension(2));
-  VERIFY_IS_EQUAL(tensor.dimension(1), tensor2.dimension(1));
-  VERIFY_IS_EQUAL(tensor.dimension(2), tensor2.dimension(0));
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor(i, j, k), tensor2(k, j, i));
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_layout_swap) {
-  CALL_SUBTEST(test_simple_swap());
-  CALL_SUBTEST(test_swap_as_lvalue());
-}
diff --git a/unsupported/test/cxx11_tensor_layout_swap_sycl.cpp b/unsupported/test/cxx11_tensor_layout_swap_sycl.cpp
deleted file mode 100644
index 7d1cbdc..0000000
--- a/unsupported/test/cxx11_tensor_layout_swap_sycl.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename DataType, typename IndexType>
-static void test_simple_swap_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 7;
-  array<IndexType, 3> tensorColRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  array<IndexType, 3> tensorRowRange = {{sizeDim3, sizeDim2, sizeDim1}};
-
-  Tensor<DataType, 3, ColMajor, IndexType> tensor1(tensorColRange);
-  Tensor<DataType, 3, RowMajor, IndexType> tensor2(tensorRowRange);
-  tensor1.setRandom();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu1(gpu_data1, tensorColRange);
-  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu2(gpu_data2, tensorRowRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor2.size()) * sizeof(DataType));
-
-  //  Tensor<float, 3, ColMajor> tensor(2,3,7);
-  // tensor.setRandom();
-
-  //  Tensor<float, 3, RowMajor> tensor2 = tensor.swap_layout();
-  VERIFY_IS_EQUAL(tensor1.dimension(0), tensor2.dimension(2));
-  VERIFY_IS_EQUAL(tensor1.dimension(1), tensor2.dimension(1));
-  VERIFY_IS_EQUAL(tensor1.dimension(2), tensor2.dimension(0));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor1(i, j, k), tensor2(k, j, i));
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-}
-
-template <typename DataType, typename IndexType>
-static void test_swap_as_lvalue_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 7;
-  array<IndexType, 3> tensorColRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  array<IndexType, 3> tensorRowRange = {{sizeDim3, sizeDim2, sizeDim1}};
-
-  Tensor<DataType, 3, ColMajor, IndexType> tensor1(tensorColRange);
-  Tensor<DataType, 3, RowMajor, IndexType> tensor2(tensorRowRange);
-  tensor1.setRandom();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 3, ColMajor, IndexType>> gpu1(gpu_data1, tensorColRange);
-  TensorMap<Tensor<DataType, 3, RowMajor, IndexType>> gpu2(gpu_data2, tensorRowRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
-  gpu2.swap_layout().device(sycl_device) = gpu1;
-  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor2.size()) * sizeof(DataType));
-
-  //  Tensor<float, 3, ColMajor> tensor(2,3,7);
-  //  tensor.setRandom();
-
-  // Tensor<float, 3, RowMajor> tensor2(7,3,2);
-  //  tensor2.swap_layout() = tensor;
-  VERIFY_IS_EQUAL(tensor1.dimension(0), tensor2.dimension(2));
-  VERIFY_IS_EQUAL(tensor1.dimension(1), tensor2.dimension(1));
-  VERIFY_IS_EQUAL(tensor1.dimension(2), tensor2.dimension(0));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor1(i, j, k), tensor2(k, j, i));
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_tensor_layout_swap_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_swap_sycl<DataType, int64_t>(sycl_device);
-  test_swap_as_lvalue_sycl<DataType, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_layout_swap_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_tensor_layout_swap_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_tensor_layout_swap_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_lvalue.cpp b/unsupported/test/cxx11_tensor_lvalue.cpp
deleted file mode 100644
index 8873dc6..0000000
--- a/unsupported/test/cxx11_tensor_lvalue.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_compound_assignment() {
-  Tensor<float, 3> mat1(2, 3, 7);
-  Tensor<float, 3> mat2(2, 3, 7);
-  Tensor<float, 3> mat3(2, 3, 7);
-
-  mat1.setRandom();
-  mat2.setRandom();
-  mat3 = mat1;
-  mat3 += mat2;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(mat3(i, j, k), mat1(i, j, k) + mat2(i, j, k));
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_lvalue) { CALL_SUBTEST(test_compound_assignment()); }
diff --git a/unsupported/test/cxx11_tensor_map.cpp b/unsupported/test/cxx11_tensor_map.cpp
deleted file mode 100644
index 3c896a6..0000000
--- a/unsupported/test/cxx11_tensor_map.cpp
+++ /dev/null
@@ -1,322 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_0d() {
-  Tensor<int, 0> scalar1;
-  Tensor<int, 0, RowMajor> scalar2;
-
-  TensorMap<const Tensor<int, 0> > scalar3(scalar1.data());
-  TensorMap<const Tensor<int, 0, RowMajor> > scalar4(scalar2.data());
-
-  scalar1() = 7;
-  scalar2() = 13;
-
-  VERIFY_IS_EQUAL(scalar1.rank(), 0);
-  VERIFY_IS_EQUAL(scalar1.size(), 1);
-
-  VERIFY_IS_EQUAL(scalar3(), 7);
-  VERIFY_IS_EQUAL(scalar4(), 13);
-}
-
-static void test_1d() {
-  Tensor<int, 1> vec1(6);
-  Tensor<int, 1, RowMajor> vec2(6);
-
-  TensorMap<const Tensor<int, 1> > vec3(vec1.data(), 6);
-  TensorMap<const Tensor<int, 1, RowMajor> > vec4(vec2.data(), 6);
-
-  vec1(0) = 4;
-  vec2(0) = 0;
-  vec1(1) = 8;
-  vec2(1) = 1;
-  vec1(2) = 15;
-  vec2(2) = 2;
-  vec1(3) = 16;
-  vec2(3) = 3;
-  vec1(4) = 23;
-  vec2(4) = 4;
-  vec1(5) = 42;
-  vec2(5) = 5;
-
-  VERIFY_IS_EQUAL(vec1.rank(), 1);
-  VERIFY_IS_EQUAL(vec1.size(), 6);
-  VERIFY_IS_EQUAL(vec1.dimension(0), 6);
-
-  VERIFY_IS_EQUAL(vec3(0), 4);
-  VERIFY_IS_EQUAL(vec3(1), 8);
-  VERIFY_IS_EQUAL(vec3(2), 15);
-  VERIFY_IS_EQUAL(vec3(3), 16);
-  VERIFY_IS_EQUAL(vec3(4), 23);
-  VERIFY_IS_EQUAL(vec3(5), 42);
-
-  VERIFY_IS_EQUAL(vec4(0), 0);
-  VERIFY_IS_EQUAL(vec4(1), 1);
-  VERIFY_IS_EQUAL(vec4(2), 2);
-  VERIFY_IS_EQUAL(vec4(3), 3);
-  VERIFY_IS_EQUAL(vec4(4), 4);
-  VERIFY_IS_EQUAL(vec4(5), 5);
-}
-
-static void test_2d() {
-  Tensor<int, 2> mat1(2, 3);
-  Tensor<int, 2, RowMajor> mat2(2, 3);
-
-  mat1(0, 0) = 0;
-  mat1(0, 1) = 1;
-  mat1(0, 2) = 2;
-  mat1(1, 0) = 3;
-  mat1(1, 1) = 4;
-  mat1(1, 2) = 5;
-
-  mat2(0, 0) = 0;
-  mat2(0, 1) = 1;
-  mat2(0, 2) = 2;
-  mat2(1, 0) = 3;
-  mat2(1, 1) = 4;
-  mat2(1, 2) = 5;
-
-  TensorMap<const Tensor<int, 2> > mat3(mat1.data(), 2, 3);
-  TensorMap<const Tensor<int, 2, RowMajor> > mat4(mat2.data(), 2, 3);
-
-  VERIFY_IS_EQUAL(mat3.rank(), 2);
-  VERIFY_IS_EQUAL(mat3.size(), 6);
-  VERIFY_IS_EQUAL(mat3.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat3.dimension(1), 3);
-
-  VERIFY_IS_EQUAL(mat4.rank(), 2);
-  VERIFY_IS_EQUAL(mat4.size(), 6);
-  VERIFY_IS_EQUAL(mat4.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat4.dimension(1), 3);
-
-  VERIFY_IS_EQUAL(mat3(0, 0), 0);
-  VERIFY_IS_EQUAL(mat3(0, 1), 1);
-  VERIFY_IS_EQUAL(mat3(0, 2), 2);
-  VERIFY_IS_EQUAL(mat3(1, 0), 3);
-  VERIFY_IS_EQUAL(mat3(1, 1), 4);
-  VERIFY_IS_EQUAL(mat3(1, 2), 5);
-
-  VERIFY_IS_EQUAL(mat4(0, 0), 0);
-  VERIFY_IS_EQUAL(mat4(0, 1), 1);
-  VERIFY_IS_EQUAL(mat4(0, 2), 2);
-  VERIFY_IS_EQUAL(mat4(1, 0), 3);
-  VERIFY_IS_EQUAL(mat4(1, 1), 4);
-  VERIFY_IS_EQUAL(mat4(1, 2), 5);
-}
-
-static void test_3d() {
-  Tensor<int, 3> mat1(2, 3, 7);
-  Tensor<int, 3, RowMajor> mat2(2, 3, 7);
-
-  int val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        mat2(i, j, k) = val;
-        val++;
-      }
-    }
-  }
-
-  TensorMap<const Tensor<int, 3> > mat3(mat1.data(), 2, 3, 7);
-  TensorMap<const Tensor<int, 3, RowMajor> > mat4(mat2.data(), 2, 3, 7);
-
-  VERIFY_IS_EQUAL(mat3.rank(), 3);
-  VERIFY_IS_EQUAL(mat3.size(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(mat3.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat3.dimension(1), 3);
-  VERIFY_IS_EQUAL(mat3.dimension(2), 7);
-
-  VERIFY_IS_EQUAL(mat4.rank(), 3);
-  VERIFY_IS_EQUAL(mat4.size(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(mat4.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat4.dimension(1), 3);
-  VERIFY_IS_EQUAL(mat4.dimension(2), 7);
-
-  val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(mat3(i, j, k), val);
-        VERIFY_IS_EQUAL(mat4(i, j, k), val);
-        val++;
-      }
-    }
-  }
-}
-
-static void test_from_tensor() {
-  Tensor<int, 3> mat1(2, 3, 7);
-  Tensor<int, 3, RowMajor> mat2(2, 3, 7);
-
-  int val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        mat1(i, j, k) = val;
-        mat2(i, j, k) = val;
-        val++;
-      }
-    }
-  }
-
-  TensorMap<Tensor<int, 3> > mat3(mat1);
-  TensorMap<Tensor<int, 3, RowMajor> > mat4(mat2);
-
-  VERIFY_IS_EQUAL(mat3.rank(), 3);
-  VERIFY_IS_EQUAL(mat3.size(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(mat3.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat3.dimension(1), 3);
-  VERIFY_IS_EQUAL(mat3.dimension(2), 7);
-
-  VERIFY_IS_EQUAL(mat4.rank(), 3);
-  VERIFY_IS_EQUAL(mat4.size(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(mat4.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat4.dimension(1), 3);
-  VERIFY_IS_EQUAL(mat4.dimension(2), 7);
-
-  val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(mat3(i, j, k), val);
-        VERIFY_IS_EQUAL(mat4(i, j, k), val);
-        val++;
-      }
-    }
-  }
-
-  TensorFixedSize<int, Sizes<2, 3, 7> > mat5;
-
-  val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        array<ptrdiff_t, 3> coords;
-        coords[0] = i;
-        coords[1] = j;
-        coords[2] = k;
-        mat5(coords) = val;
-        val++;
-      }
-    }
-  }
-
-  TensorMap<TensorFixedSize<int, Sizes<2, 3, 7> > > mat6(mat5);
-
-  VERIFY_IS_EQUAL(mat6.rank(), 3);
-  VERIFY_IS_EQUAL(mat6.size(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(mat6.dimension(0), 2);
-  VERIFY_IS_EQUAL(mat6.dimension(1), 3);
-  VERIFY_IS_EQUAL(mat6.dimension(2), 7);
-
-  val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(mat6(i, j, k), val);
-        val++;
-      }
-    }
-  }
-}
-
-static int f(const TensorMap<Tensor<int, 3> >& tensor) {
-  //  Size<0> empty;
-  EIGEN_STATIC_ASSERT((internal::array_size<Sizes<> >::value == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  EIGEN_STATIC_ASSERT((internal::array_size<DSizes<int, 0> >::value == 0), YOU_MADE_A_PROGRAMMING_MISTAKE);
-  Tensor<int, 0> result = tensor.sum();
-  return result();
-}
-
-static void test_casting() {
-  Tensor<int, 3> tensor(2, 3, 7);
-
-  int val = 0;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        tensor(i, j, k) = val;
-        val++;
-      }
-    }
-  }
-
-  TensorMap<Tensor<int, 3> > map(tensor);
-  int sum1 = f(map);
-  int sum2 = f(tensor);
-
-  VERIFY_IS_EQUAL(sum1, sum2);
-  VERIFY_IS_EQUAL(sum1, 861);
-}
-
-template <typename T>
-static const T& add_const(T& value) {
-  return value;
-}
-
-static void test_0d_const_tensor() {
-  Tensor<int, 0> scalar1;
-  Tensor<int, 0, RowMajor> scalar2;
-
-  TensorMap<const Tensor<int, 0> > scalar3(add_const(scalar1).data());
-  TensorMap<const Tensor<int, 0, RowMajor> > scalar4(add_const(scalar2).data());
-
-  scalar1() = 7;
-  scalar2() = 13;
-
-  VERIFY_IS_EQUAL(scalar1.rank(), 0);
-  VERIFY_IS_EQUAL(scalar1.size(), 1);
-
-  VERIFY_IS_EQUAL(scalar3(), 7);
-  VERIFY_IS_EQUAL(scalar4(), 13);
-}
-
-static void test_0d_const_tensor_map() {
-  Tensor<int, 0> scalar1;
-  Tensor<int, 0, RowMajor> scalar2;
-
-  const TensorMap<Tensor<int, 0> > scalar3(scalar1.data());
-  const TensorMap<Tensor<int, 0, RowMajor> > scalar4(scalar2.data());
-
-  // Although TensorMap is constant, we still can write to the underlying
-  // storage, because we map over non-constant Tensor.
-  scalar3() = 7;
-  scalar4() = 13;
-
-  VERIFY_IS_EQUAL(scalar1(), 7);
-  VERIFY_IS_EQUAL(scalar2(), 13);
-
-  // Pointer to the underlying storage is also non-const.
-  scalar3.data()[0] = 8;
-  scalar4.data()[0] = 14;
-
-  VERIFY_IS_EQUAL(scalar1(), 8);
-  VERIFY_IS_EQUAL(scalar2(), 14);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_map) {
-  CALL_SUBTEST(test_0d());
-  CALL_SUBTEST(test_1d());
-  CALL_SUBTEST(test_2d());
-  CALL_SUBTEST(test_3d());
-
-  CALL_SUBTEST(test_from_tensor());
-  CALL_SUBTEST(test_casting());
-
-  CALL_SUBTEST(test_0d_const_tensor());
-  CALL_SUBTEST(test_0d_const_tensor_map());
-}
diff --git a/unsupported/test/cxx11_tensor_math.cpp b/unsupported/test/cxx11_tensor_math.cpp
deleted file mode 100644
index 0bcbbb7..0000000
--- a/unsupported/test/cxx11_tensor_math.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_tanh() {
-  Tensor<float, 1> vec1(6);
-  vec1.setRandom();
-
-  Tensor<float, 1> vec2 = vec1.tanh();
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_APPROX(vec2(i), tanhf(vec1(i)));
-  }
-}
-
-static void test_sigmoid() {
-  Tensor<float, 1> vec1(6);
-  vec1.setRandom();
-
-  Tensor<float, 1> vec2 = vec1.sigmoid();
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_APPROX(vec2(i), 1.0f / (1.0f + std::exp(-vec1(i))));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_math) {
-  CALL_SUBTEST(test_tanh());
-  CALL_SUBTEST(test_sigmoid());
-}
diff --git a/unsupported/test/cxx11_tensor_math_sycl.cpp b/unsupported/test/cxx11_tensor_math_sycl.cpp
deleted file mode 100644
index 6987710..0000000
--- a/unsupported/test/cxx11_tensor_math_sycl.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_tanh_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 4;
-  IndexType sizeDim2 = 4;
-  IndexType sizeDim3 = 1;
-  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out_cpu(tensorRange);
-
-  in = in.random();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, in.data(), (in.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.tanh();
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data2, (out.size()) * sizeof(DataType));
-
-  out_cpu = in.tanh();
-
-  for (int i = 0; i < in.size(); ++i) {
-    VERIFY_IS_APPROX(out(i), out_cpu(i));
-  }
-}
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_sigmoid_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 4;
-  IndexType sizeDim2 = 4;
-  IndexType sizeDim3 = 1;
-  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out_cpu(tensorRange);
-
-  in = in.random();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(in.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, in.data(), (in.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.sigmoid();
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data2, (out.size()) * sizeof(DataType));
-
-  out_cpu = in.sigmoid();
-
-  for (int i = 0; i < in.size(); ++i) {
-    VERIFY_IS_APPROX(out(i), out_cpu(i));
-  }
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_computing_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_tanh_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_tanh_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_sigmoid_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_sigmoid_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_math_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_computing_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_computing_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_mixed_indices.cpp b/unsupported/test/cxx11_tensor_mixed_indices.cpp
deleted file mode 100644
index 2530fca..0000000
--- a/unsupported/test/cxx11_tensor_mixed_indices.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-static void test_simple() {
-  Tensor<float, 1, ColMajor> vec1(6);
-  Tensor<float, 1, ColMajor, int> vec2(6);
-
-  vec1(0) = 4.0;
-  vec2(0) = 0.0;
-  vec1(1) = 8.0;
-  vec2(1) = 1.0;
-  vec1(2) = 15.0;
-  vec2(2) = 2.0;
-  vec1(3) = 16.0;
-  vec2(3) = 3.0;
-  vec1(4) = 23.0;
-  vec2(4) = 4.0;
-  vec1(5) = 42.0;
-  vec2(5) = 5.0;
-
-  float data3[6];
-  TensorMap<Tensor<float, 1, ColMajor>> vec3(data3, 6);
-  vec3 = vec1.sqrt();
-  float data4[6];
-  TensorMap<Tensor<float, 1, ColMajor, int>> vec4(data4, 6);
-  vec4 = vec2.square();
-
-  VERIFY_IS_APPROX(vec3(0), sqrtf(4.0));
-  VERIFY_IS_APPROX(vec3(1), sqrtf(8.0));
-  VERIFY_IS_APPROX(vec3(2), sqrtf(15.0));
-  VERIFY_IS_APPROX(vec3(3), sqrtf(16.0));
-  VERIFY_IS_APPROX(vec3(4), sqrtf(23.0));
-  VERIFY_IS_APPROX(vec3(5), sqrtf(42.0));
-
-  VERIFY_IS_APPROX(vec4(0), 0.0f);
-  VERIFY_IS_APPROX(vec4(1), 1.0f);
-  VERIFY_IS_APPROX(vec4(2), 2.0f * 2.0f);
-  VERIFY_IS_APPROX(vec4(3), 3.0f * 3.0f);
-  VERIFY_IS_APPROX(vec4(4), 4.0f * 4.0f);
-  VERIFY_IS_APPROX(vec4(5), 5.0f * 5.0f);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_mixed_indices) { CALL_SUBTEST(test_simple()); }
diff --git a/unsupported/test/cxx11_tensor_morphing.cpp b/unsupported/test/cxx11_tensor_morphing.cpp
deleted file mode 100644
index bbc0de5..0000000
--- a/unsupported/test/cxx11_tensor_morphing.cpp
+++ /dev/null
@@ -1,551 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename>
-static void test_simple_reshape() {
-  Tensor<float, 5> tensor1(2, 3, 1, 7, 1);
-  tensor1.setRandom();
-
-  Tensor<float, 3> tensor2(2, 3, 7);
-  Tensor<float, 2> tensor3(6, 7);
-  Tensor<float, 2> tensor4(2, 21);
-
-  Tensor<float, 3>::Dimensions dim1(2, 3, 7);
-  tensor2 = tensor1.reshape(dim1);
-  Tensor<float, 2>::Dimensions dim2(6, 7);
-  tensor3 = tensor1.reshape(dim2);
-  Tensor<float, 2>::Dimensions dim3(2, 21);
-  tensor4 = tensor1.reshape(dim1).reshape(dim3);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor2(i, j, k));
-        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor3(i + 2 * j, k));
-        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor4(i, j + 3 * k));
-      }
-    }
-  }
-}
-
-template <typename>
-static void test_static_reshape() {
-  using Eigen::type2index;
-
-  Tensor<float, 5> tensor(2, 3, 1, 7, 1);
-  tensor.setRandom();
-
-  // New dimensions: [2, 3, 7]
-  Eigen::IndexList<type2index<2>, type2index<3>, type2index<7>> dim;
-  Tensor<float, 3> reshaped = tensor.reshape(static_cast<Eigen::DSizes<ptrdiff_t, 3>>(dim));
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor(i, j, 0, k, 0), reshaped(i, j, k));
-      }
-    }
-  }
-}
-
-template <typename>
-static void test_reshape_in_expr() {
-  MatrixXf m1(2, 3 * 5 * 7 * 11);
-  MatrixXf m2(3 * 5 * 7 * 11, 13);
-  m1.setRandom();
-  m2.setRandom();
-  MatrixXf m3 = m1 * m2;
-
-  TensorMap<Tensor<float, 5>> tensor1(m1.data(), 2, 3, 5, 7, 11);
-  TensorMap<Tensor<float, 5>> tensor2(m2.data(), 3, 5, 7, 11, 13);
-  Tensor<float, 2>::Dimensions newDims1(2, 3 * 5 * 7 * 11);
-  Tensor<float, 2>::Dimensions newDims2(3 * 5 * 7 * 11, 13);
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  array<DimPair, 1> contract_along{{DimPair(1, 0)}};
-  Tensor<float, 2> tensor3(2, 13);
-  tensor3 = tensor1.reshape(newDims1).contract(tensor2.reshape(newDims2), contract_along);
-
-  Map<MatrixXf> res(tensor3.data(), 2, 13);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 13; ++j) {
-      VERIFY_IS_APPROX(res(i, j), m3(i, j));
-    }
-  }
-}
-
-template <typename>
-static void test_reshape_as_lvalue() {
-  Tensor<float, 3> tensor(2, 3, 7);
-  tensor.setRandom();
-
-  Tensor<float, 2> tensor2d(6, 7);
-  Tensor<float, 3>::Dimensions dim(2, 3, 7);
-  tensor2d.reshape(dim) = tensor;
-
-  float scratch[2 * 3 * 1 * 7 * 1];
-  TensorMap<Tensor<float, 5>> tensor5d(scratch, 2, 3, 1, 7, 1);
-  tensor5d.reshape(dim).device(Eigen::DefaultDevice()) = tensor;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor2d(i + 2 * j, k), tensor(i, j, k));
-        VERIFY_IS_EQUAL(tensor5d(i, j, 0, k, 0), tensor(i, j, k));
-      }
-    }
-  }
-}
-
-template <typename T, int DataLayout>
-static void test_simple_slice() {
-  Tensor<T, 5, DataLayout> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-
-  Tensor<T, 5, DataLayout> slice1(1, 1, 1, 1, 1);
-  Eigen::DSizes<ptrdiff_t, 5> indices(1, 2, 3, 4, 5);
-  Eigen::DSizes<ptrdiff_t, 5> sizes(1, 1, 1, 1, 1);
-  slice1 = tensor.slice(indices, sizes);
-  VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
-
-  Tensor<T, 5, DataLayout> slice2(1, 1, 2, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 5> indices2(1, 1, 3, 4, 5);
-  Eigen::DSizes<ptrdiff_t, 5> sizes2(1, 1, 2, 2, 3);
-  slice2 = tensor.slice(indices2, sizes2);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        VERIFY_IS_EQUAL(slice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
-      }
-    }
-  }
-}
-
-template <typename T>
-static void test_const_slice() {
-  const T b[1] = {42};
-  TensorMap<Tensor<const T, 1>> m(b, 1);
-  DSizes<DenseIndex, 1> offsets;
-  offsets[0] = 0;
-  TensorRef<const Tensor<const T, 1>> slice_ref(m.slice(offsets, m.dimensions()));
-  VERIFY_IS_EQUAL(slice_ref(0), 42);
-}
-
-template <typename T, int DataLayout>
-static void test_slice_in_expr() {
-  typedef Matrix<T, Dynamic, Dynamic, DataLayout> Mtx;
-  Mtx m1(7, 7);
-  Mtx m2(3, 3);
-  m1.setRandom();
-  m2.setRandom();
-
-  Mtx m3 = m1.block(1, 2, 3, 3) * m2.block(0, 2, 3, 1);
-
-  TensorMap<Tensor<T, 2, DataLayout>> tensor1(m1.data(), 7, 7);
-  TensorMap<Tensor<T, 2, DataLayout>> tensor2(m2.data(), 3, 3);
-  Tensor<T, 2, DataLayout> tensor3(3, 1);
-  typedef typename Tensor<T, 1>::DimensionPair DimPair;
-  array<DimPair, 1> contract_along{{DimPair(1, 0)}};
-
-  Eigen::DSizes<ptrdiff_t, 2> indices1(1, 2);
-  Eigen::DSizes<ptrdiff_t, 2> sizes1(3, 3);
-  Eigen::DSizes<ptrdiff_t, 2> indices2(0, 2);
-  Eigen::DSizes<ptrdiff_t, 2> sizes2(3, 1);
-  tensor3 = tensor1.slice(indices1, sizes1).contract(tensor2.slice(indices2, sizes2), contract_along);
-
-  Map<Mtx> res(tensor3.data(), 3, 1);
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 1; ++j) {
-      VERIFY_IS_APPROX(res(i, j), m3(i, j));
-    }
-  }
-
-  // Take an arbitrary slice of an arbitrarily sized tensor.
-  TensorMap<Tensor<const T, 2, DataLayout>> tensor4(m1.data(), 7, 7);
-  Tensor<T, 1, DataLayout> tensor6 =
-      tensor4.reshape(DSizes<ptrdiff_t, 1>(7 * 7)).exp().slice(DSizes<ptrdiff_t, 1>(0), DSizes<ptrdiff_t, 1>(35));
-  for (int i = 0; i < 35; ++i) {
-    VERIFY_IS_APPROX(tensor6(i), expf(tensor4.data()[i]));
-  }
-}
-
-template <typename T, int DataLayout>
-static void test_slice_as_lvalue() {
-  Tensor<T, 3, DataLayout> tensor1(2, 2, 7);
-  tensor1.setRandom();
-  Tensor<T, 3, DataLayout> tensor2(2, 2, 7);
-  tensor2.setRandom();
-  Tensor<T, 3, DataLayout> tensor3(4, 3, 5);
-  tensor3.setRandom();
-  Tensor<T, 3, DataLayout> tensor4(4, 3, 2);
-  tensor4.setRandom();
-  Tensor<T, 3, DataLayout> tensor5(10, 13, 12);
-  tensor5.setRandom();
-
-  Tensor<T, 3, DataLayout> result(4, 5, 7);
-  Eigen::DSizes<ptrdiff_t, 3> sizes12(2, 2, 7);
-  Eigen::DSizes<ptrdiff_t, 3> first_slice(0, 0, 0);
-  result.slice(first_slice, sizes12) = tensor1;
-  Eigen::DSizes<ptrdiff_t, 3> second_slice(2, 0, 0);
-  result.slice(second_slice, sizes12).device(Eigen::DefaultDevice()) = tensor2;
-
-  Eigen::DSizes<ptrdiff_t, 3> sizes3(4, 3, 5);
-  Eigen::DSizes<ptrdiff_t, 3> third_slice(0, 2, 0);
-  result.slice(third_slice, sizes3) = tensor3;
-
-  Eigen::DSizes<ptrdiff_t, 3> sizes4(4, 3, 2);
-  Eigen::DSizes<ptrdiff_t, 3> fourth_slice(0, 2, 5);
-  result.slice(fourth_slice, sizes4) = tensor4;
-
-  for (int j = 0; j < 2; ++j) {
-    for (int k = 0; k < 7; ++k) {
-      for (int i = 0; i < 2; ++i) {
-        VERIFY_IS_EQUAL(result(i, j, k), tensor1(i, j, k));
-        VERIFY_IS_EQUAL(result(i + 2, j, k), tensor2(i, j, k));
-      }
-    }
-  }
-  for (int i = 0; i < 4; ++i) {
-    for (int j = 2; j < 5; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        VERIFY_IS_EQUAL(result(i, j, k), tensor3(i, j - 2, k));
-      }
-      for (int k = 5; k < 7; ++k) {
-        VERIFY_IS_EQUAL(result(i, j, k), tensor4(i, j - 2, k - 5));
-      }
-    }
-  }
-
-  Eigen::DSizes<ptrdiff_t, 3> sizes5(4, 5, 7);
-  Eigen::DSizes<ptrdiff_t, 3> fifth_slice(0, 0, 0);
-  result.slice(fifth_slice, sizes5) = tensor5.slice(fifth_slice, sizes5);
-  for (int i = 0; i < 4; ++i) {
-    for (int j = 2; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(result(i, j, k), tensor5(i, j, k));
-      }
-    }
-  }
-}
-
-template <typename T, int DataLayout>
-static void test_slice_raw_data() {
-  Tensor<T, 4, DataLayout> tensor(3, 5, 7, 11);
-  tensor.setRandom();
-
-  Eigen::DSizes<ptrdiff_t, 4> offsets(1, 2, 3, 4);
-  Eigen::DSizes<ptrdiff_t, 4> extents(1, 1, 1, 1);
-  typedef TensorEvaluator<decltype(tensor.slice(offsets, extents)), DefaultDevice> SliceEvaluator;
-  auto slice1 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-  VERIFY_IS_EQUAL(slice1.dimensions().TotalSize(), 1);
-  VERIFY_IS_EQUAL(slice1.data()[0], tensor(1, 2, 3, 4));
-
-  if (DataLayout == ColMajor) {
-    extents = Eigen::DSizes<ptrdiff_t, 4>(2, 1, 1, 1);
-    auto slice2 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-    VERIFY_IS_EQUAL(slice2.dimensions().TotalSize(), 2);
-    VERIFY_IS_EQUAL(slice2.data()[0], tensor(1, 2, 3, 4));
-    VERIFY_IS_EQUAL(slice2.data()[1], tensor(2, 2, 3, 4));
-  } else {
-    extents = Eigen::DSizes<ptrdiff_t, 4>(1, 1, 1, 2);
-    auto slice2 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-    VERIFY_IS_EQUAL(slice2.dimensions().TotalSize(), 2);
-    VERIFY_IS_EQUAL(slice2.data()[0], tensor(1, 2, 3, 4));
-    VERIFY_IS_EQUAL(slice2.data()[1], tensor(1, 2, 3, 5));
-  }
-
-  extents = Eigen::DSizes<ptrdiff_t, 4>(1, 2, 1, 1);
-  auto slice3 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-  VERIFY_IS_EQUAL(slice3.dimensions().TotalSize(), 2);
-  VERIFY_IS_EQUAL(slice3.data(), static_cast<T*>(0));
-
-  if (DataLayout == ColMajor) {
-    offsets = Eigen::DSizes<ptrdiff_t, 4>(0, 2, 3, 4);
-    extents = Eigen::DSizes<ptrdiff_t, 4>(3, 2, 1, 1);
-    auto slice4 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-    VERIFY_IS_EQUAL(slice4.dimensions().TotalSize(), 6);
-    for (int i = 0; i < 3; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        VERIFY_IS_EQUAL(slice4.data()[i + 3 * j], tensor(i, 2 + j, 3, 4));
-      }
-    }
-  } else {
-    offsets = Eigen::DSizes<ptrdiff_t, 4>(1, 2, 3, 0);
-    extents = Eigen::DSizes<ptrdiff_t, 4>(1, 1, 2, 11);
-    auto slice4 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-    VERIFY_IS_EQUAL(slice4.dimensions().TotalSize(), 22);
-    for (int l = 0; l < 11; ++l) {
-      for (int k = 0; k < 2; ++k) {
-        VERIFY_IS_EQUAL(slice4.data()[l + 11 * k], tensor(1, 2, 3 + k, l));
-      }
-    }
-  }
-
-  if (DataLayout == ColMajor) {
-    offsets = Eigen::DSizes<ptrdiff_t, 4>(0, 0, 0, 4);
-    extents = Eigen::DSizes<ptrdiff_t, 4>(3, 5, 7, 2);
-    auto slice5 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-    VERIFY_IS_EQUAL(slice5.dimensions().TotalSize(), 210);
-    for (int i = 0; i < 3; ++i) {
-      for (int j = 0; j < 5; ++j) {
-        for (int k = 0; k < 7; ++k) {
-          for (int l = 0; l < 2; ++l) {
-            int slice_index = i + 3 * (j + 5 * (k + 7 * l));
-            VERIFY_IS_EQUAL(slice5.data()[slice_index], tensor(i, j, k, l + 4));
-          }
-        }
-      }
-    }
-  } else {
-    offsets = Eigen::DSizes<ptrdiff_t, 4>(1, 0, 0, 0);
-    extents = Eigen::DSizes<ptrdiff_t, 4>(2, 5, 7, 11);
-    auto slice5 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-    VERIFY_IS_EQUAL(slice5.dimensions().TotalSize(), 770);
-    for (int l = 0; l < 11; ++l) {
-      for (int k = 0; k < 7; ++k) {
-        for (int j = 0; j < 5; ++j) {
-          for (int i = 0; i < 2; ++i) {
-            int slice_index = l + 11 * (k + 7 * (j + 5 * i));
-            VERIFY_IS_EQUAL(slice5.data()[slice_index], tensor(i + 1, j, k, l));
-          }
-        }
-      }
-    }
-  }
-
-  offsets = Eigen::DSizes<ptrdiff_t, 4>(0, 0, 0, 0);
-  extents = Eigen::DSizes<ptrdiff_t, 4>(3, 5, 7, 11);
-  auto slice6 = SliceEvaluator(tensor.slice(offsets, extents), DefaultDevice());
-  VERIFY_IS_EQUAL(slice6.dimensions().TotalSize(), 3 * 5 * 7 * 11);
-  VERIFY_IS_EQUAL(slice6.data(), tensor.data());
-}
-
-template <typename T, int DataLayout>
-static void test_strided_slice() {
-  typedef Tensor<T, 5, DataLayout> Tensor5f;
-  typedef Eigen::DSizes<Eigen::DenseIndex, 5> Index5;
-  typedef Tensor<T, 2, DataLayout> Tensor2f;
-  typedef Eigen::DSizes<Eigen::DenseIndex, 2> Index2;
-  Tensor<T, 5, DataLayout> tensor(2, 3, 5, 7, 11);
-  Tensor<T, 2, DataLayout> tensor2(7, 11);
-  tensor.setRandom();
-  tensor2.setRandom();
-
-  if (true) {
-    Tensor2f slice(2, 3);
-    Index2 strides(-2, -1);
-    Index2 indicesStart(5, 7);
-    Index2 indicesStop(0, 4);
-    slice = tensor2.stridedSlice(indicesStart, indicesStop, strides);
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        VERIFY_IS_EQUAL(slice(j, k), tensor2(5 - 2 * j, 7 - k));
-      }
-    }
-  }
-
-  if (true) {
-    Tensor2f slice(0, 1);
-    Index2 strides(1, 1);
-    Index2 indicesStart(5, 4);
-    Index2 indicesStop(5, 5);
-    slice = tensor2.stridedSlice(indicesStart, indicesStop, strides);
-  }
-
-  if (true) {  // test clamped degenerate interavls
-    Tensor2f slice(7, 11);
-    Index2 strides(1, -1);
-    Index2 indicesStart(-3, 20);  // should become 0,10
-    Index2 indicesStop(20, -11);  // should become 11, -1
-    slice = tensor2.stridedSlice(indicesStart, indicesStop, strides);
-    for (int j = 0; j < 7; ++j) {
-      for (int k = 0; k < 11; ++k) {
-        VERIFY_IS_EQUAL(slice(j, k), tensor2(j, 10 - k));
-      }
-    }
-  }
-
-  if (true) {
-    Tensor5f slice1(1, 1, 1, 1, 1);
-    Eigen::DSizes<Eigen::DenseIndex, 5> indicesStart(1, 2, 3, 4, 5);
-    Eigen::DSizes<Eigen::DenseIndex, 5> indicesStop(2, 3, 4, 5, 6);
-    Eigen::DSizes<Eigen::DenseIndex, 5> strides(1, 1, 1, 1, 1);
-    slice1 = tensor.stridedSlice(indicesStart, indicesStop, strides);
-    VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
-  }
-
-  if (true) {
-    Tensor5f slice(1, 1, 2, 2, 3);
-    Index5 start(1, 1, 3, 4, 5);
-    Index5 stop(2, 2, 5, 6, 8);
-    Index5 strides(1, 1, 1, 1, 1);
-    slice = tensor.stridedSlice(start, stop, strides);
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        for (int k = 0; k < 3; ++k) {
-          VERIFY_IS_EQUAL(slice(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
-        }
-      }
-    }
-  }
-
-  if (true) {
-    Tensor5f slice(1, 1, 2, 2, 3);
-    Index5 strides3(1, 1, -2, 1, -1);
-    Index5 indices3Start(1, 1, 4, 4, 7);
-    Index5 indices3Stop(2, 2, 0, 6, 4);
-    slice = tensor.stridedSlice(indices3Start, indices3Stop, strides3);
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 2; ++j) {
-        for (int k = 0; k < 3; ++k) {
-          VERIFY_IS_EQUAL(slice(0, 0, i, j, k), tensor(1, 1, 4 - 2 * i, 4 + j, 7 - k));
-        }
-      }
-    }
-  }
-
-  if (false) {  // tests degenerate interval
-    Tensor5f slice(1, 1, 2, 2, 3);
-    Index5 strides3(1, 1, 2, 1, 1);
-    Index5 indices3Start(1, 1, 4, 4, 7);
-    Index5 indices3Stop(2, 2, 0, 6, 4);
-    slice = tensor.stridedSlice(indices3Start, indices3Stop, strides3);
-  }
-}
-
-template <typename T, int DataLayout>
-static void test_strided_slice_write() {
-  typedef Tensor<T, 2, DataLayout> Tensor2f;
-  typedef Eigen::DSizes<Eigen::DenseIndex, 2> Index2;
-
-  Tensor<T, 2, DataLayout> tensor(7, 11), tensor2(7, 11);
-  tensor.setRandom();
-  tensor2 = tensor;
-  Tensor2f slice(2, 3);
-
-  slice.setRandom();
-
-  Index2 strides(1, 1);
-  Index2 indicesStart(3, 4);
-  Index2 indicesStop(5, 7);
-  Index2 lengths(2, 3);
-
-  tensor.slice(indicesStart, lengths) = slice;
-  tensor2.stridedSlice(indicesStart, indicesStop, strides) = slice;
-
-  for (int i = 0; i < 7; i++)
-    for (int j = 0; j < 11; j++) {
-      VERIFY_IS_EQUAL(tensor(i, j), tensor2(i, j));
-    }
-}
-
-template <typename T, int DataLayout>
-static void test_composition() {
-  Eigen::Tensor<T, 2, DataLayout> matrix(7, 11);
-  matrix.setRandom();
-
-  const DSizes<ptrdiff_t, 3> newDims(1, 1, 11);
-  Eigen::Tensor<T, 3, DataLayout> tensor =
-      matrix.slice(DSizes<ptrdiff_t, 2>(2, 0), DSizes<ptrdiff_t, 2>(1, 11)).reshape(newDims);
-
-  VERIFY_IS_EQUAL(tensor.dimensions().TotalSize(), 11);
-  VERIFY_IS_EQUAL(tensor.dimension(0), 1);
-  VERIFY_IS_EQUAL(tensor.dimension(1), 1);
-  VERIFY_IS_EQUAL(tensor.dimension(2), 11);
-  for (int i = 0; i < 11; ++i) {
-    VERIFY_IS_EQUAL(tensor(0, 0, i), matrix(2, i));
-  }
-}
-
-template <typename T, int DataLayout>
-static void test_empty_slice() {
-  Tensor<T, 3, DataLayout> tensor(2, 3, 5);
-  tensor.setRandom();
-  Tensor<T, 3, DataLayout> copy = tensor;
-
-  // empty size in first dimension
-  Eigen::DSizes<ptrdiff_t, 3> indices1(1, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 3> sizes1(0, 1, 2);
-  Tensor<T, 3, DataLayout> slice1(0, 1, 2);
-  slice1.setRandom();
-  tensor.slice(indices1, sizes1) = slice1;
-
-  // empty size in second dimension
-  Eigen::DSizes<ptrdiff_t, 3> indices2(1, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 3> sizes2(1, 0, 2);
-  Tensor<T, 3, DataLayout> slice2(1, 0, 2);
-  slice2.setRandom();
-  tensor.slice(indices2, sizes2) = slice2;
-
-  // empty size in third dimension
-  Eigen::DSizes<ptrdiff_t, 3> indices3(1, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 3> sizes3(1, 1, 0);
-  Tensor<T, 3, DataLayout> slice3(1, 1, 0);
-  slice3.setRandom();
-  tensor.slice(indices3, sizes3) = slice3;
-
-  // empty size in first and second dimension
-  Eigen::DSizes<ptrdiff_t, 3> indices4(1, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 3> sizes4(0, 0, 2);
-  Tensor<T, 3, DataLayout> slice4(0, 0, 2);
-  slice4.setRandom();
-  tensor.slice(indices4, sizes4) = slice4;
-
-  // empty size in second and third dimension
-  Eigen::DSizes<ptrdiff_t, 3> indices5(1, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 3> sizes5(1, 0, 0);
-  Tensor<T, 3, DataLayout> slice5(1, 0, 0);
-  slice5.setRandom();
-  tensor.slice(indices5, sizes5) = slice5;
-
-  // empty size in all dimensions
-  Eigen::DSizes<ptrdiff_t, 3> indices6(1, 2, 3);
-  Eigen::DSizes<ptrdiff_t, 3> sizes6(0, 0, 0);
-  Tensor<T, 3, DataLayout> slice6(0, 0, 0);
-  slice6.setRandom();
-  tensor.slice(indices6, sizes6) = slice6;
-
-  // none of these operations should change the tensor's components
-  // because all of the rvalue slices have at least one zero dimension
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        VERIFY_IS_EQUAL(tensor(i, j, k), copy(i, j, k));
-      }
-    }
-  }
-}
-
-#define CALL_SUBTEST_PART(PART) CALL_SUBTEST_##PART
-
-#define CALL_SUBTESTS_TYPES_LAYOUTS(PART, NAME)       \
-  CALL_SUBTEST_PART(PART)((NAME<float, ColMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<float, RowMajor>())); \
-  CALL_SUBTEST_PART(PART)((NAME<bool, ColMajor>()));  \
-  CALL_SUBTEST_PART(PART)((NAME<bool, RowMajor>()))
-
-EIGEN_DECLARE_TEST(cxx11_tensor_morphing) {
-  CALL_SUBTEST_1(test_simple_reshape<void>());
-  CALL_SUBTEST_1(test_static_reshape<void>());
-  CALL_SUBTEST_1(test_reshape_as_lvalue<void>());
-  CALL_SUBTEST_1(test_reshape_in_expr<void>());
-  CALL_SUBTEST_1(test_const_slice<float>());
-
-  CALL_SUBTESTS_TYPES_LAYOUTS(2, test_simple_slice);
-  CALL_SUBTESTS_TYPES_LAYOUTS(3, test_slice_as_lvalue);
-  CALL_SUBTESTS_TYPES_LAYOUTS(4, test_slice_raw_data);
-  CALL_SUBTESTS_TYPES_LAYOUTS(5, test_strided_slice_write);
-  CALL_SUBTESTS_TYPES_LAYOUTS(6, test_strided_slice);
-  CALL_SUBTESTS_TYPES_LAYOUTS(7, test_composition);
-}
diff --git a/unsupported/test/cxx11_tensor_morphing_sycl.cpp b/unsupported/test/cxx11_tensor_morphing_sycl.cpp
deleted file mode 100644
index f96ffb3..0000000
--- a/unsupported/test/cxx11_tensor_morphing_sycl.cpp
+++ /dev/null
@@ -1,371 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_reshape(const Eigen::SyclDevice& sycl_device) {
-  typename Tensor<DataType, 5, DataLayout, IndexType>::Dimensions dim1(2, 3, 1, 7, 1);
-  typename Tensor<DataType, 3, DataLayout, IndexType>::Dimensions dim2(2, 3, 7);
-  typename Tensor<DataType, 2, DataLayout, IndexType>::Dimensions dim3(6, 7);
-  typename Tensor<DataType, 2, DataLayout, IndexType>::Dimensions dim4(2, 21);
-
-  Tensor<DataType, 5, DataLayout, IndexType> tensor1(dim1);
-  Tensor<DataType, 3, DataLayout, IndexType> tensor2(dim2);
-  Tensor<DataType, 2, DataLayout, IndexType> tensor3(dim3);
-  Tensor<DataType, 2, DataLayout, IndexType> tensor4(dim4);
-
-  tensor1.setRandom();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor1.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(tensor3.size() * sizeof(DataType)));
-  DataType* gpu_data4 = static_cast<DataType*>(sycl_device.allocate(tensor4.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu1(gpu_data1, dim1);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, dim2);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu3(gpu_data3, dim3);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu4(gpu_data4, dim4);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor1.data(), (tensor1.size()) * sizeof(DataType));
-
-  gpu2.device(sycl_device) = gpu1.reshape(dim2);
-  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor1.size()) * sizeof(DataType));
-
-  gpu3.device(sycl_device) = gpu1.reshape(dim3);
-  sycl_device.memcpyDeviceToHost(tensor3.data(), gpu_data3, (tensor3.size()) * sizeof(DataType));
-
-  gpu4.device(sycl_device) = gpu1.reshape(dim2).reshape(dim4);
-  sycl_device.memcpyDeviceToHost(tensor4.data(), gpu_data4, (tensor4.size()) * sizeof(DataType));
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor2(i, j, k));  /// ColMajor
-        if (static_cast<int>(DataLayout) == static_cast<int>(ColMajor)) {
-          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor3(i + 2 * j, k));  /// ColMajor
-          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor4(i, j + 3 * k));  /// ColMajor
-        } else {
-          // VERIFY_IS_EQUAL(tensor1(i,j,0,k,0), tensor2(i,j,k));      /// RowMajor
-          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor4(i, j * 7 + k));  /// RowMajor
-          VERIFY_IS_EQUAL(tensor1(i, j, 0, k, 0), tensor3(i * 3 + j, k));  /// RowMajor
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-  sycl_device.deallocate(gpu_data3);
-  sycl_device.deallocate(gpu_data4);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_reshape_as_lvalue(const Eigen::SyclDevice& sycl_device) {
-  typename Tensor<DataType, 3, DataLayout, IndexType>::Dimensions dim1(2, 3, 7);
-  typename Tensor<DataType, 2, DataLayout, IndexType>::Dimensions dim2(6, 7);
-  typename Tensor<DataType, 5, DataLayout, IndexType>::Dimensions dim3(2, 3, 1, 7, 1);
-  Tensor<DataType, 3, DataLayout, IndexType> tensor(dim1);
-  Tensor<DataType, 2, DataLayout, IndexType> tensor2d(dim2);
-  Tensor<DataType, 5, DataLayout, IndexType> tensor5d(dim3);
-
-  tensor.setRandom();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2d.size() * sizeof(DataType)));
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(tensor5d.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, dim1);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu2(gpu_data2, dim2);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu3(gpu_data3, dim3);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
-
-  gpu2.reshape(dim1).device(sycl_device) = gpu1;
-  sycl_device.memcpyDeviceToHost(tensor2d.data(), gpu_data2, (tensor2d.size()) * sizeof(DataType));
-
-  gpu3.reshape(dim1).device(sycl_device) = gpu1;
-  sycl_device.memcpyDeviceToHost(tensor5d.data(), gpu_data3, (tensor5d.size()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(tensor5d(i, j, 0, k, 0), tensor(i, j, k));
-        if (static_cast<int>(DataLayout) == static_cast<int>(ColMajor)) {
-          VERIFY_IS_EQUAL(tensor2d(i + 2 * j, k), tensor(i, j, k));  /// ColMajor
-        } else {
-          VERIFY_IS_EQUAL(tensor2d(i * 3 + j, k), tensor(i, j, k));  /// RowMajor
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-  sycl_device.deallocate(gpu_data3);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_slice(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  IndexType sizeDim5 = 11;
-  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
-  tensor.setRandom();
-  array<IndexType, 5> slice1_range = {{1, 1, 1, 1, 1}};
-  Tensor<DataType, 5, DataLayout, IndexType> slice1(slice1_range);
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(slice1.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu2(gpu_data2, slice1_range);
-  Eigen::DSizes<IndexType, 5> indices(1, 2, 3, 4, 5);
-  Eigen::DSizes<IndexType, 5> sizes(1, 1, 1, 1, 1);
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.slice(indices, sizes);
-  sycl_device.memcpyDeviceToHost(slice1.data(), gpu_data2, (slice1.size()) * sizeof(DataType));
-  VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
-
-  array<IndexType, 5> slice2_range = {{1, 1, 2, 2, 3}};
-  Tensor<DataType, 5, DataLayout, IndexType> slice2(slice2_range);
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(slice2.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu3(gpu_data3, slice2_range);
-  Eigen::DSizes<IndexType, 5> indices2(1, 1, 3, 4, 5);
-  Eigen::DSizes<IndexType, 5> sizes2(1, 1, 2, 2, 3);
-  gpu3.device(sycl_device) = gpu1.slice(indices2, sizes2);
-  sycl_device.memcpyDeviceToHost(slice2.data(), gpu_data3, (slice2.size()) * sizeof(DataType));
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 2; ++j) {
-      for (IndexType k = 0; k < 3; ++k) {
-        VERIFY_IS_EQUAL(slice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-  sycl_device.deallocate(gpu_data3);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_strided_slice_as_rhs_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  IndexType sizeDim5 = 11;
-  typedef Eigen::DSizes<IndexType, 5> Index5;
-  Index5 strides(1L, 1L, 1L, 1L, 1L);
-  Index5 indicesStart(1L, 2L, 3L, 4L, 5L);
-  Index5 indicesStop(2L, 3L, 4L, 5L, 6L);
-  Index5 lengths(1L, 1L, 1L, 1L, 1L);
-
-  array<IndexType, 5> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, sizeDim5}};
-  Tensor<DataType, 5, DataLayout, IndexType> tensor(tensorRange);
-  tensor.setRandom();
-
-  array<IndexType, 5> slice1_range = {{1, 1, 1, 1, 1}};
-  Tensor<DataType, 5, DataLayout, IndexType> slice1(slice1_range);
-  Tensor<DataType, 5, DataLayout, IndexType> slice_stride1(slice1_range);
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(slice1.size() * sizeof(DataType)));
-  DataType* gpu_data_stride2 = static_cast<DataType*>(sycl_device.allocate(slice_stride1.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu2(gpu_data2, slice1_range);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_stride2(gpu_data_stride2, slice1_range);
-
-  Eigen::DSizes<IndexType, 5> indices(1, 2, 3, 4, 5);
-  Eigen::DSizes<IndexType, 5> sizes(1, 1, 1, 1, 1);
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.slice(indices, sizes);
-  sycl_device.memcpyDeviceToHost(slice1.data(), gpu_data2, (slice1.size()) * sizeof(DataType));
-
-  gpu_stride2.device(sycl_device) = gpu1.stridedSlice(indicesStart, indicesStop, strides);
-  sycl_device.memcpyDeviceToHost(slice_stride1.data(), gpu_data_stride2, (slice_stride1.size()) * sizeof(DataType));
-
-  VERIFY_IS_EQUAL(slice1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
-  VERIFY_IS_EQUAL(slice_stride1(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
-
-  array<IndexType, 5> slice2_range = {{1, 1, 2, 2, 3}};
-  Tensor<DataType, 5, DataLayout, IndexType> slice2(slice2_range);
-  Tensor<DataType, 5, DataLayout, IndexType> strideSlice2(slice2_range);
-
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(slice2.size() * sizeof(DataType)));
-  DataType* gpu_data_stride3 = static_cast<DataType*>(sycl_device.allocate(strideSlice2.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu3(gpu_data3, slice2_range);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_stride3(gpu_data_stride3, slice2_range);
-  Eigen::DSizes<IndexType, 5> indices2(1, 1, 3, 4, 5);
-  Eigen::DSizes<IndexType, 5> sizes2(1, 1, 2, 2, 3);
-  Index5 strides2(1L, 1L, 1L, 1L, 1L);
-  Index5 indicesStart2(1L, 1L, 3L, 4L, 5L);
-  Index5 indicesStop2(2L, 2L, 5L, 6L, 8L);
-
-  gpu3.device(sycl_device) = gpu1.slice(indices2, sizes2);
-  sycl_device.memcpyDeviceToHost(slice2.data(), gpu_data3, (slice2.size()) * sizeof(DataType));
-
-  gpu_stride3.device(sycl_device) = gpu1.stridedSlice(indicesStart2, indicesStop2, strides2);
-  sycl_device.memcpyDeviceToHost(strideSlice2.data(), gpu_data_stride3, (strideSlice2.size()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 2; ++j) {
-      for (IndexType k = 0; k < 3; ++k) {
-        VERIFY_IS_EQUAL(slice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
-        VERIFY_IS_EQUAL(strideSlice2(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-  sycl_device.deallocate(gpu_data3);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_strided_slice_write_sycl(const Eigen::SyclDevice& sycl_device) {
-  typedef Tensor<DataType, 2, DataLayout, IndexType> Tensor2f;
-  typedef Eigen::DSizes<IndexType, 2> Index2;
-  IndexType sizeDim1 = 7L;
-  IndexType sizeDim2 = 11L;
-  array<IndexType, 2> tensorRange = {{sizeDim1, sizeDim2}};
-  Tensor<DataType, 2, DataLayout, IndexType> tensor(tensorRange), tensor2(tensorRange);
-  IndexType sliceDim1 = 2;
-  IndexType sliceDim2 = 3;
-  array<IndexType, 2> sliceRange = {{sliceDim1, sliceDim2}};
-  Tensor2f slice(sliceRange);
-  Index2 strides(1L, 1L);
-  Index2 indicesStart(3L, 4L);
-  Index2 indicesStop(5L, 7L);
-  Index2 lengths(2L, 3L);
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(tensor2.size() * sizeof(DataType)));
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(slice.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu3(gpu_data3, sliceRange);
-
-  tensor.setRandom();
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1;
-
-  slice.setRandom();
-  sycl_device.memcpyHostToDevice(gpu_data3, slice.data(), (slice.size()) * sizeof(DataType));
-
-  gpu1.slice(indicesStart, lengths).device(sycl_device) = gpu3;
-  gpu2.stridedSlice(indicesStart, indicesStop, strides).device(sycl_device) = gpu3;
-  sycl_device.memcpyDeviceToHost(tensor.data(), gpu_data1, (tensor.size()) * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(tensor2.data(), gpu_data2, (tensor2.size()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < sizeDim1; i++)
-    for (IndexType j = 0; j < sizeDim2; j++) {
-      VERIFY_IS_EQUAL(tensor(i, j), tensor2(i, j));
-    }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-  sycl_device.deallocate(gpu_data3);
-}
-
-template <typename OutIndex, typename DSizes>
-Eigen::array<OutIndex, DSizes::count> To32BitDims(const DSizes& in) {
-  Eigen::array<OutIndex, DSizes::count> out;
-  for (int i = 0; i < DSizes::count; ++i) {
-    out[i] = in[i];
-  }
-  return out;
-}
-
-template <class DataType, int DataLayout, typename IndexType, typename ConvertedIndexType>
-int run_eigen(const SyclDevice& sycl_device) {
-  using TensorI64 = Tensor<DataType, 5, DataLayout, IndexType>;
-  using TensorI32 = Tensor<DataType, 5, DataLayout, ConvertedIndexType>;
-  using TensorMI64 = TensorMap<TensorI64>;
-  using TensorMI32 = TensorMap<TensorI32>;
-  Eigen::array<IndexType, 5> tensor_range{{4, 1, 1, 1, 6}};
-  Eigen::array<IndexType, 5> slice_range{{4, 1, 1, 1, 3}};
-
-  TensorI64 out_tensor_gpu(tensor_range);
-  TensorI64 out_tensor_cpu(tensor_range);
-  out_tensor_cpu.setRandom();
-
-  TensorI64 sub_tensor(slice_range);
-  sub_tensor.setRandom();
-
-  DataType* out_gpu_data = static_cast<DataType*>(sycl_device.allocate(out_tensor_cpu.size() * sizeof(DataType)));
-  DataType* sub_gpu_data = static_cast<DataType*>(sycl_device.allocate(sub_tensor.size() * sizeof(DataType)));
-  TensorMI64 out_gpu(out_gpu_data, tensor_range);
-  TensorMI64 sub_gpu(sub_gpu_data, slice_range);
-
-  sycl_device.memcpyHostToDevice(out_gpu_data, out_tensor_cpu.data(), out_tensor_cpu.size() * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(sub_gpu_data, sub_tensor.data(), sub_tensor.size() * sizeof(DataType));
-
-  Eigen::array<ConvertedIndexType, 5> slice_offset_32{{0, 0, 0, 0, 3}};
-  Eigen::array<ConvertedIndexType, 5> slice_range_32{{4, 1, 1, 1, 3}};
-  TensorMI32 out_cpu_32(out_tensor_cpu.data(), To32BitDims<ConvertedIndexType>(out_tensor_cpu.dimensions()));
-  TensorMI32 sub_cpu_32(sub_tensor.data(), To32BitDims<ConvertedIndexType>(sub_tensor.dimensions()));
-  TensorMI32 out_gpu_32(out_gpu.data(), To32BitDims<ConvertedIndexType>(out_gpu.dimensions()));
-  TensorMI32 sub_gpu_32(sub_gpu.data(), To32BitDims<ConvertedIndexType>(sub_gpu.dimensions()));
-
-  out_gpu_32.slice(slice_offset_32, slice_range_32).device(sycl_device) = sub_gpu_32;
-
-  out_cpu_32.slice(slice_offset_32, slice_range_32) = sub_cpu_32;
-
-  sycl_device.memcpyDeviceToHost(out_tensor_gpu.data(), out_gpu_data, out_tensor_cpu.size() * sizeof(DataType));
-  int has_err = 0;
-  for (IndexType i = 0; i < out_tensor_cpu.size(); ++i) {
-    auto exp = out_tensor_cpu(i);
-    auto val = out_tensor_gpu(i);
-    if (val != exp) {
-      std::cout << "#" << i << " got " << val << " but expected " << exp << std::endl;
-      has_err = 1;
-    }
-  }
-  sycl_device.deallocate(out_gpu_data);
-  sycl_device.deallocate(sub_gpu_data);
-  return has_err;
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_morphing_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_slice<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_slice<DataType, ColMajor, int64_t>(sycl_device);
-  test_simple_reshape<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_reshape<DataType, ColMajor, int64_t>(sycl_device);
-  test_reshape_as_lvalue<DataType, RowMajor, int64_t>(sycl_device);
-  test_reshape_as_lvalue<DataType, ColMajor, int64_t>(sycl_device);
-  test_strided_slice_write_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_strided_slice_write_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_strided_slice_as_rhs_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_strided_slice_as_rhs_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  run_eigen<float, RowMajor, long, int>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_morphing_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_morphing_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_morphing_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_move.cpp b/unsupported/test/cxx11_tensor_move.cpp
deleted file mode 100644
index 5b24509..0000000
--- a/unsupported/test/cxx11_tensor_move.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2017 Viktor Csomor <viktor.csomor@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-#include <utility>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void calc_indices(int i, int& x, int& y, int& z) {
-  x = i / 4;
-  y = (i % 4) / 2;
-  z = i % 2;
-}
-
-static void test_move() {
-  int x;
-  int y;
-  int z;
-
-  Tensor<int, 3> tensor1(2, 2, 2);
-  Tensor<int, 3, RowMajor> tensor2(2, 2, 2);
-
-  for (int i = 0; i < 8; i++) {
-    calc_indices(i, x, y, z);
-    tensor1(x, y, z) = i;
-    tensor2(x, y, z) = 2 * i;
-  }
-
-  // Invokes the move constructor.
-  Tensor<int, 3> moved_tensor1 = std::move(tensor1);
-  Tensor<int, 3, RowMajor> moved_tensor2 = std::move(tensor2);
-
-  VERIFY_IS_EQUAL(tensor1.size(), 0);
-  VERIFY_IS_EQUAL(tensor2.size(), 0);
-
-  for (int i = 0; i < 8; i++) {
-    calc_indices(i, x, y, z);
-    VERIFY_IS_EQUAL(moved_tensor1(x, y, z), i);
-    VERIFY_IS_EQUAL(moved_tensor2(x, y, z), 2 * i);
-  }
-
-  Tensor<int, 3> moved_tensor3(2, 2, 2);
-  Tensor<int, 3, RowMajor> moved_tensor4(2, 2, 2);
-
-  moved_tensor3.setZero();
-  moved_tensor4.setZero();
-
-  // Invokes the move assignment operator.
-  moved_tensor3 = std::move(moved_tensor1);
-  moved_tensor4 = std::move(moved_tensor2);
-
-  for (int i = 0; i < 8; i++) {
-    calc_indices(i, x, y, z);
-    VERIFY_IS_EQUAL(moved_tensor3(x, y, z), i);
-    VERIFY_IS_EQUAL(moved_tensor4(x, y, z), 2 * i);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_move) { CALL_SUBTEST(test_move()); }
diff --git a/unsupported/test/cxx11_tensor_notification.cpp b/unsupported/test/cxx11_tensor_notification.cpp
deleted file mode 100644
index 71c4d05..0000000
--- a/unsupported/test/cxx11_tensor_notification.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Vijay Vasudevan <vrv@google.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_USE_THREADS
-
-#include <atomic>
-
-#include <stdlib.h>
-#include "main.h"
-#include <Eigen/Tensor>
-
-static void test_notification_single() {
-  ThreadPool thread_pool(1);
-
-  std::atomic<int> counter(0);
-  Eigen::Notification n;
-  auto func = [&n, &counter]() {
-    n.Wait();
-    ++counter;
-  };
-  thread_pool.Schedule(func);
-  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-
-  // The thread should be waiting for the notification.
-  VERIFY_IS_EQUAL(counter, 0);
-
-  // Unblock the thread
-  n.Notify();
-
-  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-
-  // Verify the counter has been incremented
-  VERIFY_IS_EQUAL(counter, 1);
-}
-
-// Like test_notification_single() but enqueues multiple threads to
-// validate that all threads get notified by Notify().
-static void test_notification_multiple() {
-  ThreadPool thread_pool(1);
-
-  std::atomic<int> counter(0);
-  Eigen::Notification n;
-  auto func = [&n, &counter]() {
-    n.Wait();
-    ++counter;
-  };
-  thread_pool.Schedule(func);
-  thread_pool.Schedule(func);
-  thread_pool.Schedule(func);
-  thread_pool.Schedule(func);
-  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-  VERIFY_IS_EQUAL(counter, 0);
-  n.Notify();
-  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-  VERIFY_IS_EQUAL(counter, 4);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_notification) {
-  CALL_SUBTEST(test_notification_single());
-  CALL_SUBTEST(test_notification_multiple());
-}
diff --git a/unsupported/test/cxx11_tensor_of_bfloat16_gpu.cu b/unsupported/test/cxx11_tensor_of_bfloat16_gpu.cu
deleted file mode 100644
index 599a130..0000000
--- a/unsupported/test/cxx11_tensor_of_bfloat16_gpu.cu
+++ /dev/null
@@ -1,461 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2021 Rohit Santhanam <rohit.santhanam@amd.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename>
-void test_gpu_numext() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  bool* d_res_bfloat16 = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
-  bool* d_res_float = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(gpu_device) = gpu_float.unaryExpr(Eigen::internal::scalar_isnan_op<float>());
-  // Test bfloat16 specific isnan op.
-  gpu_res_bfloat16.device(gpu_device) =
-      gpu_float.cast<Eigen::bfloat16>().unaryExpr(Eigen::internal::scalar_isnan_op<Eigen::bfloat16>());
-
-  Tensor<bool, 1> bfloat16_prec(num_elem);
-  Tensor<bool, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(bool));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(bool));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_EQUAL(full_prec(i), bfloat16_prec(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_bfloat16);
-  gpu_device.deallocate(d_res_float);
-}
-
-#ifdef EIGEN_HAS_GPU_BF16
-
-template <typename>
-void test_gpu_conversion() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::bfloat16* d_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  float* d_conv = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_bfloat16(d_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
-
-  gpu_float.device(gpu_device) = gpu_float.random();
-  gpu_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>();
-  gpu_conv.device(gpu_device) = gpu_bfloat16.cast<float>();
-
-  Tensor<float, 1> initial(num_elem);
-  Tensor<float, 1> final(num_elem);
-  gpu_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(static_cast<Eigen::bfloat16>(initial(i)), static_cast<Eigen::bfloat16>(final(i)));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_bfloat16);
-  gpu_device.deallocate(d_conv);
-}
-
-template <typename>
-void test_gpu_unary() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_bfloat16 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_float.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().cast<float>();
-  gpu_res_float.device(gpu_device) = gpu_float.abs();
-  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().abs().cast<float>();
-
-  Tensor<float, 1> bfloat16_prec(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_bfloat16);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_elementwise() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_bfloat16 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float1.device(gpu_device) = gpu_float1.random();
-  gpu_float1.device(gpu_device) = gpu_float1.cast<Eigen::bfloat16>().cast<float>();
-  gpu_float2.device(gpu_device) = gpu_float2.random();
-  gpu_float2.device(gpu_device) = gpu_float2.cast<Eigen::bfloat16>().cast<float>();
-  gpu_res_float.device(gpu_device) = (gpu_float1 + gpu_float2) * gpu_float1;
-  gpu_res_bfloat16.device(gpu_device) =
-      ((gpu_float1.cast<Eigen::bfloat16>() + gpu_float2.cast<Eigen::bfloat16>()) * gpu_float1.cast<Eigen::bfloat16>())
-          .cast<float>();
-
-  Tensor<float, 1> bfloat16_prec(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(static_cast<Eigen::bfloat16>(full_prec(i)), static_cast<Eigen::bfloat16>(bfloat16_prec(i)));
-  }
-
-  gpu_device.deallocate(d_float1);
-  gpu_device.deallocate(d_float2);
-  gpu_device.deallocate(d_res_bfloat16);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_trancendental() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float3 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::bfloat16* d_res1_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res1_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res2_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res2_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res3_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res3_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float3(d_float3, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res1_bfloat16(d_res1_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res1_float(d_res1_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res2_bfloat16(d_res2_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res2_float(d_res2_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res3_bfloat16(d_res3_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res3_float(d_res3_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res4_bfloat16(d_res3_bfloat16, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res4_float(d_res3_float, num_elem);
-
-  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
-  gpu_float1.device(gpu_device) = gpu_float1.cast<Eigen::bfloat16>().cast<float>();
-  gpu_float2.device(gpu_device) = gpu_float2.random() + gpu_float1.constant(0.5f);
-  gpu_float2.device(gpu_device) = gpu_float2.cast<Eigen::bfloat16>().cast<float>();
-  gpu_float3.device(gpu_device) = gpu_float3.random();
-  gpu_float3.device(gpu_device) = gpu_float3.cast<Eigen::bfloat16>().cast<float>();
-  gpu_res1_float.device(gpu_device) = gpu_float1.exp().cast<Eigen::bfloat16>();
-  gpu_res2_float.device(gpu_device) = gpu_float2.log().cast<Eigen::bfloat16>();
-  gpu_res3_float.device(gpu_device) = gpu_float3.log1p().cast<Eigen::bfloat16>();
-  gpu_res4_float.device(gpu_device) = gpu_float3.expm1().cast<Eigen::bfloat16>();
-
-  gpu_res1_bfloat16.device(gpu_device) = gpu_float1.cast<Eigen::bfloat16>();
-  gpu_res1_bfloat16.device(gpu_device) = gpu_res1_bfloat16.exp();
-
-  gpu_res2_bfloat16.device(gpu_device) = gpu_float2.cast<Eigen::bfloat16>();
-  gpu_res2_bfloat16.device(gpu_device) = gpu_res2_bfloat16.log();
-
-  gpu_res3_bfloat16.device(gpu_device) = gpu_float3.cast<Eigen::bfloat16>();
-  gpu_res3_bfloat16.device(gpu_device) = gpu_res3_bfloat16.log1p();
-
-  gpu_res3_bfloat16.device(gpu_device) = gpu_float3.cast<Eigen::bfloat16>();
-  gpu_res3_bfloat16.device(gpu_device) = gpu_res3_bfloat16.expm1();
-
-  Tensor<float, 1> input1(num_elem);
-  Tensor<Eigen::bfloat16, 1> bfloat16_prec1(num_elem);
-  Tensor<Eigen::bfloat16, 1> full_prec1(num_elem);
-  Tensor<float, 1> input2(num_elem);
-  Tensor<Eigen::bfloat16, 1> bfloat16_prec2(num_elem);
-  Tensor<Eigen::bfloat16, 1> full_prec2(num_elem);
-  Tensor<float, 1> input3(num_elem);
-  Tensor<Eigen::bfloat16, 1> bfloat16_prec3(num_elem);
-  Tensor<Eigen::bfloat16, 1> full_prec3(num_elem);
-  gpu_device.memcpyDeviceToHost(input1.data(), d_float1, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(input2.data(), d_float2, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(input3.data(), d_float3, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(bfloat16_prec1.data(), d_res1_bfloat16, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec1.data(), d_res1_float, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(bfloat16_prec2.data(), d_res2_bfloat16, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec2.data(), d_res2_float, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(bfloat16_prec3.data(), d_res3_bfloat16, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec3.data(), d_res3_float, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(full_prec1(i), bfloat16_prec1(i));
-  }
-  for (int i = 0; i < num_elem; ++i) {
-    if (std::abs(input2(i) - 1.f) < 0.05f)  // log lacks accuracy nearby 1
-      VERIFY_IS_APPROX(full_prec2(i) + Eigen::bfloat16(0.1f), bfloat16_prec2(i) + Eigen::bfloat16(0.1f));
-    else
-      VERIFY_IS_APPROX(full_prec2(i), bfloat16_prec2(i));
-  }
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(full_prec3(i), bfloat16_prec3(i));
-  }
-  gpu_device.deallocate(d_float1);
-  gpu_device.deallocate(d_float2);
-  gpu_device.deallocate(d_float3);
-  gpu_device.deallocate(d_res1_bfloat16);
-  gpu_device.deallocate(d_res1_float);
-  gpu_device.deallocate(d_res2_bfloat16);
-  gpu_device.deallocate(d_res2_float);
-  gpu_device.deallocate(d_res3_float);
-  gpu_device.deallocate(d_res3_bfloat16);
-}
-
-template <typename>
-void test_gpu_contractions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int rows = 23;
-  int cols = 23;
-  int num_elem = rows * cols;
-
-  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::bfloat16* d_res_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res_float = (Eigen::bfloat16*)gpu_device.allocate(num_elem * sizeof(Eigen::bfloat16));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float1(d_float1, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float2(d_float2, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 2>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 2>, Eigen::Aligned> gpu_res_float(d_res_float, rows, cols);
-
-  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
-  gpu_float2.device(gpu_device) = gpu_float2.random() - gpu_float2.constant(0.5f);
-
-  typedef Tensor<float, 2>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
-  gpu_res_float.device(gpu_device) = gpu_float1.contract(gpu_float2, dims).cast<Eigen::bfloat16>();
-  gpu_res_bfloat16.device(gpu_device) =
-      gpu_float1.cast<Eigen::bfloat16>().contract(gpu_float2.cast<Eigen::bfloat16>(), dims);
-
-  Tensor<Eigen::bfloat16, 2> bfloat16_prec(rows, cols);
-  Tensor<Eigen::bfloat16, 2> full_prec(rows, cols);
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(Eigen::bfloat16));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < rows; ++i) {
-    for (int j = 0; j < cols; ++j) {
-      if (numext::abs(full_prec(i, j) - bfloat16_prec(i, j)) > Eigen::bfloat16(1e-2f)) {
-        VERIFY_IS_APPROX(full_prec(i, j), bfloat16_prec(i, j));
-      }
-    }
-  }
-
-  gpu_device.deallocate(d_float1);
-  gpu_device.deallocate(d_float2);
-  gpu_device.deallocate(d_res_bfloat16);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_reductions(int size1, int size2, int redux) {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = size1 * size2;
-  int result_size = (redux == 1 ? size1 : size2);
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::bfloat16* d_res_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(result_size * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res_float = (Eigen::bfloat16*)gpu_device.allocate(result_size * sizeof(Eigen::bfloat16));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size1, size2);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16, result_size);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 1>, Eigen::Aligned> gpu_res_float(d_res_float, result_size);
-
-  gpu_float.device(gpu_device) = gpu_float.random() * 2.0f;
-
-  Eigen::array<int, 1> redux_dim = {redux};
-  gpu_res_float.device(gpu_device) = gpu_float.sum(redux_dim).cast<Eigen::bfloat16>();
-  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().sum(redux_dim);
-
-  Tensor<Eigen::bfloat16, 1> bfloat16_prec(result_size);
-  Tensor<Eigen::bfloat16, 1> full_prec(result_size);
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, result_size * sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, result_size * sizeof(Eigen::bfloat16));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < result_size; ++i) {
-    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_bfloat16);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_reductions() {
-  test_gpu_reductions<void>(13, 13, 0);
-  test_gpu_reductions<void>(13, 13, 1);
-
-  test_gpu_reductions<void>(35, 36, 0);
-  test_gpu_reductions<void>(35, 36, 1);
-
-  test_gpu_reductions<void>(36, 35, 0);
-  test_gpu_reductions<void>(36, 35, 1);
-}
-
-template <typename>
-void test_gpu_full_reductions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int size = 13;
-  int num_elem = size * size;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::bfloat16* d_res_bfloat16 = (Eigen::bfloat16*)gpu_device.allocate(1 * sizeof(Eigen::bfloat16));
-  Eigen::bfloat16* d_res_float = (Eigen::bfloat16*)gpu_device.allocate(1 * sizeof(Eigen::bfloat16));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size, size);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 0>, Eigen::Aligned> gpu_res_bfloat16(d_res_bfloat16);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::bfloat16, 0>, Eigen::Aligned> gpu_res_float(d_res_float);
-
-  gpu_float.device(gpu_device) = gpu_float.random();
-
-  gpu_res_float.device(gpu_device) = gpu_float.sum().cast<Eigen::bfloat16>();
-  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().sum();
-
-  Tensor<Eigen::bfloat16, 0> bfloat16_prec;
-  Tensor<Eigen::bfloat16, 0> full_prec;
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::bfloat16));
-  gpu_device.synchronize();
-
-  VERIFY_IS_APPROX(full_prec(), bfloat16_prec());
-
-  gpu_res_float.device(gpu_device) = gpu_float.maximum().cast<Eigen::bfloat16>();
-  gpu_res_bfloat16.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().maximum();
-  gpu_device.memcpyDeviceToHost(bfloat16_prec.data(), d_res_bfloat16, sizeof(Eigen::bfloat16));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::bfloat16));
-  gpu_device.synchronize();
-
-  VERIFY_IS_APPROX(full_prec(), bfloat16_prec());
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_bfloat16);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_forced_evals() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_bfloat16_1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_bfloat16_2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_bfloat16_1(d_res_bfloat16_1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Unaligned> gpu_res_bfloat16_2(d_res_bfloat16_2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  Eigen::array<int, 1> no_bcast;
-  no_bcast[0] = 1;
-
-  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_float.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().cast<float>();
-  gpu_res_float.device(gpu_device) = gpu_float.abs();
-  gpu_res_bfloat16_1.device(gpu_device) = gpu_float.cast<Eigen::bfloat16>().abs().eval().cast<float>();
-  gpu_res_bfloat16_2.device(gpu_device) =
-      gpu_float.cast<Eigen::bfloat16>().abs().broadcast(no_bcast).eval().cast<float>();
-
-  Tensor<float, 1> bfloat16_prec1(num_elem);
-  Tensor<float, 1> bfloat16_prec2(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(bfloat16_prec1.data(), d_res_bfloat16_1, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(bfloat16_prec2.data(), d_res_bfloat16_2, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec1(i));
-    VERIFY_IS_APPROX(full_prec(i), bfloat16_prec2(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_bfloat16_1);
-  gpu_device.deallocate(d_res_bfloat16_2);
-  gpu_device.deallocate(d_res_float);
-}
-
-#endif
-
-EIGEN_DECLARE_TEST(cxx11_tensor_of_bfloat16_gpu) {
-  CALL_SUBTEST_1(test_gpu_numext<void>());
-
-// The reduction unit tests have been excluded until a working
-// implementation to expand the accumulator data type to float32
-// is available.
-// TODO: add reduction unit tests
-#ifdef EIGEN_HAS_GPU_BF16
-  CALL_SUBTEST_2(test_gpu_conversion<void>());
-  CALL_SUBTEST_3(test_gpu_unary<void>());
-  CALL_SUBTEST_4(test_gpu_elementwise<void>());
-  CALL_SUBTEST_5(test_gpu_trancendental<void>());
-  CALL_SUBTEST_6(test_gpu_contractions<void>());
-  CALL_SUBTEST_7(test_gpu_reductions<void>());
-  CALL_SUBTEST_8(test_gpu_full_reductions<void>());
-  CALL_SUBTEST_9(test_gpu_forced_evals<void>());
-#else
-  std::cout << "bfloat16 floats are not supported by this version of gpu: skipping the test" << std::endl;
-#endif
-}
diff --git a/unsupported/test/cxx11_tensor_of_complex.cpp b/unsupported/test/cxx11_tensor_of_complex.cpp
deleted file mode 100644
index d02ae27..0000000
--- a/unsupported/test/cxx11_tensor_of_complex.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-static void test_additions() {
-  Tensor<std::complex<float>, 1> data1(3);
-  Tensor<std::complex<float>, 1> data2(3);
-  for (int i = 0; i < 3; ++i) {
-    data1(i) = std::complex<float>(i, -i);
-    data2(i) = std::complex<float>(i, 7 * i);
-  }
-
-  Tensor<std::complex<float>, 1> sum = data1 + data2;
-  for (int i = 0; i < 3; ++i) {
-    VERIFY_IS_EQUAL(sum(i), std::complex<float>(2 * i, 6 * i));
-  }
-}
-
-static void test_abs() {
-  Tensor<std::complex<float>, 1> data1(3);
-  Tensor<std::complex<double>, 1> data2(3);
-  data1.setRandom();
-  data2.setRandom();
-
-  Tensor<float, 1> abs1 = data1.abs();
-  Tensor<double, 1> abs2 = data2.abs();
-  for (int i = 0; i < 3; ++i) {
-    VERIFY_IS_APPROX(abs1(i), std::abs(data1(i)));
-    VERIFY_IS_APPROX(abs2(i), std::abs(data2(i)));
-  }
-}
-
-static void test_arg() {
-  Tensor<std::complex<float>, 1> data1(3);
-  Tensor<std::complex<double>, 1> data2(3);
-  data1.setRandom();
-  data2.setRandom();
-
-  Tensor<float, 1> arg1 = data1.arg();
-  Tensor<double, 1> arg2 = data2.arg();
-  for (int i = 0; i < 3; ++i) {
-    VERIFY_IS_APPROX(arg1(i), std::arg(data1(i)));
-    VERIFY_IS_APPROX(arg2(i), std::arg(data2(i)));
-  }
-}
-
-static void test_conjugate() {
-  Tensor<std::complex<float>, 1> data1(3);
-  Tensor<std::complex<double>, 1> data2(3);
-  Tensor<int, 1> data3(3);
-  data1.setRandom();
-  data2.setRandom();
-  data3.setRandom();
-
-  Tensor<std::complex<float>, 1> conj1 = data1.conjugate();
-  Tensor<std::complex<double>, 1> conj2 = data2.conjugate();
-  Tensor<int, 1> conj3 = data3.conjugate();
-  for (int i = 0; i < 3; ++i) {
-    VERIFY_IS_APPROX(conj1(i), std::conj(data1(i)));
-    VERIFY_IS_APPROX(conj2(i), std::conj(data2(i)));
-    VERIFY_IS_APPROX(conj3(i), data3(i));
-  }
-}
-
-static void test_contractions() {
-  Tensor<std::complex<float>, 4> t_left(30, 50, 8, 31);
-  Tensor<std::complex<float>, 5> t_right(8, 31, 7, 20, 10);
-  Tensor<std::complex<float>, 5> t_result(30, 50, 7, 20, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  typedef Map<Matrix<std::complex<float>, Dynamic, Dynamic>> MapXcf;
-  MapXcf m_left(t_left.data(), 1500, 248);
-  MapXcf m_right(t_right.data(), 248, 1400);
-  Matrix<std::complex<float>, Dynamic, Dynamic> m_result(1500, 1400);
-
-  // This contraction should be equivalent to a regular matrix multiplication
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 2> dims;
-  dims[0] = DimPair(2, 0);
-  dims[1] = DimPair(3, 1);
-  t_result = t_left.contract(t_right, dims);
-  m_result = m_left * m_right;
-  for (int i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_of_complex) {
-  CALL_SUBTEST(test_additions());
-  CALL_SUBTEST(test_abs());
-  CALL_SUBTEST(test_arg());
-  CALL_SUBTEST(test_conjugate());
-  CALL_SUBTEST(test_contractions());
-}
diff --git a/unsupported/test/cxx11_tensor_of_const_values.cpp b/unsupported/test/cxx11_tensor_of_const_values.cpp
deleted file mode 100644
index 7a6f0dc..0000000
--- a/unsupported/test/cxx11_tensor_of_const_values.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_assign() {
-  float data1[6];
-  TensorMap<Tensor<const float, 2>> mat1(data1, 2, 3);
-  float data2[6];
-  const TensorMap<Tensor<float, 2>> mat2(data2, 2, 3);
-
-  for (int i = 0; i < 6; ++i) {
-    data1[i] = i;
-    data2[i] = -i;
-  }
-
-  Tensor<float, 2> rslt1;
-  rslt1 = mat1;
-  Tensor<float, 2> rslt2;
-  rslt2 = mat2;
-
-  Tensor<float, 2> rslt3 = mat1;
-  Tensor<float, 2> rslt4 = mat2;
-
-  Tensor<float, 2> rslt5(mat1);
-  Tensor<float, 2> rslt6(mat2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_APPROX(rslt1(i, j), static_cast<float>(i + 2 * j));
-      VERIFY_IS_APPROX(rslt2(i, j), static_cast<float>(-i - 2 * j));
-      VERIFY_IS_APPROX(rslt3(i, j), static_cast<float>(i + 2 * j));
-      VERIFY_IS_APPROX(rslt4(i, j), static_cast<float>(-i - 2 * j));
-      VERIFY_IS_APPROX(rslt5(i, j), static_cast<float>(i + 2 * j));
-      VERIFY_IS_APPROX(rslt6(i, j), static_cast<float>(-i - 2 * j));
-    }
-  }
-}
-
-static void test_plus() {
-  float data1[6];
-  TensorMap<Tensor<const float, 2>> mat1(data1, 2, 3);
-  float data2[6];
-  TensorMap<Tensor<float, 2>> mat2(data2, 2, 3);
-
-  for (int i = 0; i < 6; ++i) {
-    data1[i] = i;
-    data2[i] = -i;
-  }
-
-  Tensor<float, 2> sum1;
-  sum1 = mat1 + mat2;
-  Tensor<float, 2> sum2;
-  sum2 = mat2 + mat1;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_APPROX(sum1(i, j), 0.0f);
-      VERIFY_IS_APPROX(sum2(i, j), 0.0f);
-    }
-  }
-}
-
-static void test_plus_equal() {
-  float data1[6];
-  TensorMap<Tensor<const float, 2>> mat1(data1, 2, 3);
-  float data2[6];
-  TensorMap<Tensor<float, 2>> mat2(data2, 2, 3);
-
-  for (int i = 0; i < 6; ++i) {
-    data1[i] = i;
-    data2[i] = -i;
-  }
-  mat2 += mat1;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_APPROX(mat2(i, j), 0.0f);
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_of_const_values) {
-  CALL_SUBTEST(test_assign());
-  CALL_SUBTEST(test_plus());
-  CALL_SUBTEST(test_plus_equal());
-}
diff --git a/unsupported/test/cxx11_tensor_of_float16_gpu.cu b/unsupported/test/cxx11_tensor_of_float16_gpu.cu
deleted file mode 100644
index d29df4f..0000000
--- a/unsupported/test/cxx11_tensor_of_float16_gpu.cu
+++ /dev/null
@@ -1,462 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename>
-void test_gpu_numext() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  bool* d_res_half = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
-  bool* d_res_float = (bool*)gpu_device.allocate(num_elem * sizeof(bool));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<bool, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(gpu_device) = gpu_float.unaryExpr(Eigen::internal::scalar_isnan_op<float>());
-  gpu_res_half.device(gpu_device) =
-      gpu_float.cast<Eigen::half>().unaryExpr(Eigen::internal::scalar_isnan_op<Eigen::half>());
-
-  Tensor<bool, 1> half_prec(num_elem);
-  Tensor<bool, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(bool));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(bool));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking numext " << i << std::endl;
-    VERIFY_IS_EQUAL(full_prec(i), half_prec(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_half);
-  gpu_device.deallocate(d_res_float);
-}
-
-#ifdef EIGEN_HAS_GPU_FP16
-
-template <typename>
-void test_gpu_conversion() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  float* d_conv = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_half(d_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
-
-  gpu_float.device(gpu_device) = gpu_float.random();
-  gpu_half.device(gpu_device) = gpu_float.cast<Eigen::half>();
-  gpu_conv.device(gpu_device) = gpu_half.cast<float>();
-
-  Tensor<float, 1> initial(num_elem);
-  Tensor<float, 1> final(num_elem);
-  gpu_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(initial(i), final(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_half);
-  gpu_device.deallocate(d_conv);
-}
-
-template <typename>
-void test_gpu_unary() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_half = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(gpu_device) = gpu_float.abs();
-  gpu_res_half.device(gpu_device) = gpu_float.cast<Eigen::half>().abs().cast<float>();
-
-  Tensor<float, 1> half_prec(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking unary " << i << std::endl;
-    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_half);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_elementwise() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_half = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float1.device(gpu_device) = gpu_float1.random();
-  gpu_float2.device(gpu_device) = gpu_float2.random();
-  gpu_res_float.device(gpu_device) = (gpu_float1 + gpu_float2) * gpu_float1;
-  gpu_res_half.device(gpu_device) =
-      ((gpu_float1.cast<Eigen::half>() + gpu_float2.cast<Eigen::half>()) * gpu_float1.cast<Eigen::half>())
-          .cast<float>();
-
-  Tensor<float, 1> half_prec(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise " << i << ": full prec = " << full_prec(i) << " vs half prec = " << half_prec(i)
-              << std::endl;
-    VERIFY_IS_APPROX(static_cast<Eigen::half>(full_prec(i)), static_cast<Eigen::half>(half_prec(i)));
-  }
-
-  gpu_device.deallocate(d_float1);
-  gpu_device.deallocate(d_float2);
-  gpu_device.deallocate(d_res_half);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_trancendental() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float3 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res1_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res1_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res2_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res2_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res3_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res3_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float3(d_float3, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_half(d_res1_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_float(d_res1_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_half(d_res2_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_float(d_res2_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_half(d_res3_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_float(d_res3_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_half(d_res3_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_float(d_res3_float, num_elem);
-
-  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
-  gpu_float2.device(gpu_device) = gpu_float2.random() + gpu_float1.constant(0.5f);
-  gpu_float3.device(gpu_device) = gpu_float3.random();
-  gpu_res1_float.device(gpu_device) = gpu_float1.exp().cast<Eigen::half>();
-  gpu_res2_float.device(gpu_device) = gpu_float2.log().cast<Eigen::half>();
-  gpu_res3_float.device(gpu_device) = gpu_float3.log1p().cast<Eigen::half>();
-  gpu_res4_float.device(gpu_device) = gpu_float3.expm1().cast<Eigen::half>();
-
-  gpu_res1_half.device(gpu_device) = gpu_float1.cast<Eigen::half>();
-  gpu_res1_half.device(gpu_device) = gpu_res1_half.exp();
-
-  gpu_res2_half.device(gpu_device) = gpu_float2.cast<Eigen::half>();
-  gpu_res2_half.device(gpu_device) = gpu_res2_half.log();
-
-  gpu_res3_half.device(gpu_device) = gpu_float3.cast<Eigen::half>();
-  gpu_res3_half.device(gpu_device) = gpu_res3_half.log1p();
-
-  gpu_res3_half.device(gpu_device) = gpu_float3.cast<Eigen::half>();
-  gpu_res3_half.device(gpu_device) = gpu_res3_half.expm1();
-
-  Tensor<float, 1> input1(num_elem);
-  Tensor<Eigen::half, 1> half_prec1(num_elem);
-  Tensor<Eigen::half, 1> full_prec1(num_elem);
-  Tensor<float, 1> input2(num_elem);
-  Tensor<Eigen::half, 1> half_prec2(num_elem);
-  Tensor<Eigen::half, 1> full_prec2(num_elem);
-  Tensor<float, 1> input3(num_elem);
-  Tensor<Eigen::half, 1> half_prec3(num_elem);
-  Tensor<Eigen::half, 1> full_prec3(num_elem);
-  gpu_device.memcpyDeviceToHost(input1.data(), d_float1, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(input2.data(), d_float2, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(input3.data(), d_float3, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(half_prec1.data(), d_res1_half, num_elem * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec1.data(), d_res1_float, num_elem * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(half_prec2.data(), d_res2_half, num_elem * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec2.data(), d_res2_float, num_elem * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(half_prec3.data(), d_res3_half, num_elem * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec3.data(), d_res3_float, num_elem * sizeof(Eigen::half));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise exp " << i << " input = " << input1(i) << " full = " << full_prec1(i)
-              << " half = " << half_prec1(i) << std::endl;
-    VERIFY_IS_APPROX(full_prec1(i), half_prec1(i));
-  }
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise log " << i << " input = " << input2(i) << " full = " << full_prec2(i)
-              << " half = " << half_prec2(i) << std::endl;
-    if (std::abs(input2(i) - 1.f) < 0.05f)  // log lacks accuracy nearby 1
-      VERIFY_IS_APPROX(full_prec2(i) + Eigen::half(0.1f), half_prec2(i) + Eigen::half(0.1f));
-    else
-      VERIFY_IS_APPROX(full_prec2(i), half_prec2(i));
-  }
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise plog1 " << i << " input = " << input3(i) << " full = " << full_prec3(i)
-              << " half = " << half_prec3(i) << std::endl;
-    VERIFY_IS_APPROX(full_prec3(i), half_prec3(i));
-  }
-  gpu_device.deallocate(d_float1);
-  gpu_device.deallocate(d_float2);
-  gpu_device.deallocate(d_float3);
-  gpu_device.deallocate(d_res1_half);
-  gpu_device.deallocate(d_res1_float);
-  gpu_device.deallocate(d_res2_half);
-  gpu_device.deallocate(d_res2_float);
-  gpu_device.deallocate(d_res3_float);
-  gpu_device.deallocate(d_res3_half);
-}
-
-template <typename>
-void test_gpu_contractions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int rows = 23;
-  int cols = 23;
-  int num_elem = rows * cols;
-
-  float* d_float1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res_half = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res_float = (Eigen::half*)gpu_device.allocate(num_elem * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float1(d_float1, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float2(d_float2, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_half(d_res_half, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_float(d_res_float, rows, cols);
-
-  gpu_float1.device(gpu_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
-  gpu_float2.device(gpu_device) = gpu_float2.random() - gpu_float2.constant(0.5f);
-
-  typedef Tensor<float, 2>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims{DimPair(1, 0)};
-  gpu_res_float.device(gpu_device) = gpu_float1.contract(gpu_float2, dims).cast<Eigen::half>();
-  gpu_res_half.device(gpu_device) = gpu_float1.cast<Eigen::half>().contract(gpu_float2.cast<Eigen::half>(), dims);
-
-  Tensor<Eigen::half, 2> half_prec(rows, cols);
-  Tensor<Eigen::half, 2> full_prec(rows, cols);
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(Eigen::half));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < rows; ++i) {
-    for (int j = 0; j < cols; ++j) {
-      std::cout << "Checking contract " << i << " " << j << full_prec(i, j) << " " << half_prec(i, j) << std::endl;
-      if (numext::abs(full_prec(i, j) - half_prec(i, j)) > Eigen::half(1e-2f)) {
-        VERIFY_IS_APPROX(full_prec(i, j), half_prec(i, j));
-      }
-    }
-  }
-
-  gpu_device.deallocate(d_float1);
-  gpu_device.deallocate(d_float2);
-  gpu_device.deallocate(d_res_half);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_reductions(int size1, int size2, int redux) {
-  std::cout << "Reducing " << size1 << " by " << size2 << " tensor along dim " << redux << std::endl;
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = size1 * size2;
-  int result_size = (redux == 1 ? size1 : size2);
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res_half = (Eigen::half*)gpu_device.allocate(result_size * sizeof(Eigen::half));
-  Eigen::half* d_res_float = (Eigen::half*)gpu_device.allocate(result_size * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size1, size2);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_half(d_res_half, result_size);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_float(d_res_float, result_size);
-
-  gpu_float.device(gpu_device) = gpu_float.random() * 2.0f;
-
-  Eigen::array<int, 1> redux_dim = {redux};
-  gpu_res_float.device(gpu_device) = gpu_float.sum(redux_dim).cast<Eigen::half>();
-  gpu_res_half.device(gpu_device) = gpu_float.cast<Eigen::half>().sum(redux_dim);
-
-  Tensor<Eigen::half, 1> half_prec(result_size);
-  Tensor<Eigen::half, 1> full_prec(result_size);
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, result_size * sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, result_size * sizeof(Eigen::half));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < result_size; ++i) {
-    std::cout << "EXPECTED " << full_prec(i) << " GOT " << half_prec(i) << std::endl;
-    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_half);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_reductions() {
-  test_gpu_reductions<void>(13, 13, 0);
-  test_gpu_reductions<void>(13, 13, 1);
-
-  test_gpu_reductions<void>(35, 36, 0);
-  test_gpu_reductions<void>(35, 36, 1);
-
-  test_gpu_reductions<void>(36, 35, 0);
-  test_gpu_reductions<void>(36, 35, 1);
-}
-
-template <typename>
-void test_gpu_full_reductions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int size = 13;
-  int num_elem = size * size;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res_half = (Eigen::half*)gpu_device.allocate(1 * sizeof(Eigen::half));
-  Eigen::half* d_res_float = (Eigen::half*)gpu_device.allocate(1 * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size, size);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_half(d_res_half);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_float(d_res_float);
-
-  gpu_float.device(gpu_device) = gpu_float.random();
-
-  gpu_res_float.device(gpu_device) = gpu_float.sum().cast<Eigen::half>();
-  gpu_res_half.device(gpu_device) = gpu_float.cast<Eigen::half>().sum();
-
-  Tensor<Eigen::half, 0> half_prec;
-  Tensor<Eigen::half, 0> full_prec;
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
-  gpu_device.synchronize();
-
-  VERIFY_IS_APPROX(full_prec(), half_prec());
-
-  gpu_res_float.device(gpu_device) = gpu_float.maximum().cast<Eigen::half>();
-  gpu_res_half.device(gpu_device) = gpu_float.cast<Eigen::half>().maximum();
-  gpu_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
-  gpu_device.synchronize();
-
-  VERIFY_IS_APPROX(full_prec(), half_prec());
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_half);
-  gpu_device.deallocate(d_res_float);
-}
-
-template <typename>
-void test_gpu_forced_evals() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-  int num_elem = 101;
-
-  float* d_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_half1 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_half2 = (float*)gpu_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)gpu_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half1(d_res_half1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Unaligned> gpu_res_half2(d_res_half2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  Eigen::array<int, 1> no_bcast;
-  no_bcast[0] = 1;
-
-  gpu_float.device(gpu_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(gpu_device) = gpu_float.abs();
-  gpu_res_half1.device(gpu_device) = gpu_float.cast<Eigen::half>().abs().eval().cast<float>();
-  gpu_res_half2.device(gpu_device) = gpu_float.cast<Eigen::half>().abs().broadcast(no_bcast).eval().cast<float>();
-
-  Tensor<float, 1> half_prec1(num_elem);
-  Tensor<float, 1> half_prec2(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  gpu_device.memcpyDeviceToHost(half_prec1.data(), d_res_half1, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(half_prec2.data(), d_res_half2, num_elem * sizeof(float));
-  gpu_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  gpu_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking forced eval " << i << full_prec(i) << " vs " << half_prec1(i) << " vs " << half_prec2(i)
-              << std::endl;
-    VERIFY_IS_APPROX(full_prec(i), half_prec1(i));
-    VERIFY_IS_APPROX(full_prec(i), half_prec2(i));
-  }
-
-  gpu_device.deallocate(d_float);
-  gpu_device.deallocate(d_res_half1);
-  gpu_device.deallocate(d_res_half2);
-  gpu_device.deallocate(d_res_float);
-}
-#endif
-
-EIGEN_DECLARE_TEST(cxx11_tensor_of_float16_gpu) {
-  CALL_SUBTEST_1(test_gpu_numext<void>());
-
-#ifdef EIGEN_HAS_GPU_FP16
-  CALL_SUBTEST_1(test_gpu_conversion<void>());
-  CALL_SUBTEST_1(test_gpu_unary<void>());
-  CALL_SUBTEST_1(test_gpu_elementwise<void>());
-  CALL_SUBTEST_1(test_gpu_trancendental<void>());
-  CALL_SUBTEST_2(test_gpu_contractions<void>());
-  CALL_SUBTEST_3(test_gpu_reductions<void>());
-  CALL_SUBTEST_4(test_gpu_full_reductions<void>());
-  CALL_SUBTEST_5(test_gpu_forced_evals<void>());
-#else
-  std::cout << "Half floats are not supported by this version of gpu: skipping the test" << std::endl;
-#endif
-}
diff --git a/unsupported/test/cxx11_tensor_of_float16_sycl.cpp b/unsupported/test/cxx11_tensor_of_float16_sycl.cpp
deleted file mode 100644
index 811ca11..0000000
--- a/unsupported/test/cxx11_tensor_of_float16_sycl.cpp
+++ /dev/null
@@ -1,392 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2023
-// Alejandro Acosta  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_SYCL
-#define EIGEN_SYCL_HALF_SUPPORT
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-
-void test_gpu_numext(const Eigen::SyclDevice& sycl_device) {
-  int num_elem = 101;
-
-  float* d_float = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-  bool* d_res_half = static_cast<bool*>(sycl_device.allocate(num_elem * sizeof(bool)));
-  bool* d_res_float = static_cast<bool*>(sycl_device.allocate(num_elem * sizeof(bool)));
-
-  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Tensor<bool, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
-  Eigen::TensorMap<Tensor<bool, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float.device(sycl_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(sycl_device) = gpu_float.unaryExpr(Eigen::internal::scalar_isnan_op<float>());
-  gpu_res_half.device(sycl_device) =
-      gpu_float.cast<Eigen::half>().unaryExpr(Eigen::internal::scalar_isnan_op<Eigen::half>());
-
-  Tensor<bool, 1> half_prec(num_elem);
-  Tensor<bool, 1> full_prec(num_elem);
-
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(bool));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(bool));
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking numext " << i << std::endl;
-    VERIFY_IS_EQUAL(full_prec(i), half_prec(i));
-  }
-}
-
-void test_gpu_conversion(const Eigen::SyclDevice& sycl_device) {
-  int num_elem = 101;
-
-  float* d_float = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-  Eigen::half* d_half = static_cast<Eigen::half*>(sycl_device.allocate(num_elem * sizeof(Eigen::half)));
-  float* d_conv = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_half(d_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_conv(d_conv, num_elem);
-
-  gpu_float.device(sycl_device) = gpu_float.random();
-  gpu_half.device(sycl_device) = gpu_float.cast<Eigen::half>();
-  gpu_conv.device(sycl_device) = gpu_half.cast<float>();
-
-  Tensor<float, 1> initial(num_elem);
-  Tensor<float, 1> final(num_elem);
-  sycl_device.memcpyDeviceToHost(initial.data(), d_float, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(final.data(), d_conv, num_elem * sizeof(float));
-
-  for (int i = 0; i < num_elem; ++i) {
-    VERIFY_IS_APPROX(initial(i), final(i));
-  }
-}
-
-void test_gpu_unary(const Eigen::SyclDevice& sycl_device) {
-  int num_elem = 101;
-
-  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_res_half = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float.device(sycl_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(sycl_device) = gpu_float.abs();
-  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().abs().cast<float>();
-
-  Tensor<float, 1> half_prec(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  sycl_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking unary " << i << std::endl;
-    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
-  }
-}
-
-void test_gpu_elementwise(const Eigen::SyclDevice& sycl_device) {
-  int num_elem = 101;
-
-  float* d_float1 = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-  float* d_float2 = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-  float* d_res_half = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-  float* d_res_float = static_cast<float*>(sycl_device.allocate(num_elem * sizeof(float)));
-
-  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
-  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
-  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_res_half(d_res_half, num_elem);
-  Eigen::TensorMap<Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  gpu_float1.device(sycl_device) = gpu_float1.random();
-  gpu_float2.device(sycl_device) = gpu_float2.random();
-  gpu_res_float.device(sycl_device) = (gpu_float1 + gpu_float2) * gpu_float1;
-  gpu_res_half.device(sycl_device) =
-      ((gpu_float1.cast<Eigen::half>() + gpu_float2.cast<Eigen::half>()) * gpu_float1.cast<Eigen::half>())
-          .cast<float>();
-
-  Tensor<float, 1> half_prec(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise " << i << ": full prec = " << full_prec(i) << " vs half prec = " << half_prec(i)
-              << std::endl;
-    VERIFY_IS_APPROX(static_cast<Eigen::half>(full_prec(i)), static_cast<Eigen::half>(half_prec(i)));
-  }
-}
-
-void test_gpu_trancendental(const Eigen::SyclDevice& sycl_device) {
-  int num_elem = 101;
-
-  float* d_float1 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_float3 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res1_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res1_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res2_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res2_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res3_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res3_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float1(d_float1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float2(d_float2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float3(d_float3, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_half(d_res1_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res1_float(d_res1_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_half(d_res2_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res2_float(d_res2_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_half(d_res3_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res3_float(d_res3_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_half(d_res3_half, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res4_float(d_res3_float, num_elem);
-
-  gpu_float1.device(sycl_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
-  gpu_float2.device(sycl_device) = gpu_float2.random() + gpu_float1.constant(0.5f);
-  gpu_float3.device(sycl_device) = gpu_float3.random();
-  gpu_res1_float.device(sycl_device) = gpu_float1.exp().cast<Eigen::half>();
-  gpu_res2_float.device(sycl_device) = gpu_float2.log().cast<Eigen::half>();
-  gpu_res3_float.device(sycl_device) = gpu_float3.log1p().cast<Eigen::half>();
-  gpu_res4_float.device(sycl_device) = gpu_float3.expm1().cast<Eigen::half>();
-
-  gpu_res1_half.device(sycl_device) = gpu_float1.cast<Eigen::half>();
-  gpu_res1_half.device(sycl_device) = gpu_res1_half.exp();
-
-  gpu_res2_half.device(sycl_device) = gpu_float2.cast<Eigen::half>();
-  gpu_res2_half.device(sycl_device) = gpu_res2_half.log();
-
-  gpu_res3_half.device(sycl_device) = gpu_float3.cast<Eigen::half>();
-  gpu_res3_half.device(sycl_device) = gpu_res3_half.log1p();
-
-  gpu_res3_half.device(sycl_device) = gpu_float3.cast<Eigen::half>();
-  gpu_res3_half.device(sycl_device) = gpu_res3_half.expm1();
-
-  Tensor<float, 1> input1(num_elem);
-  Tensor<Eigen::half, 1> half_prec1(num_elem);
-  Tensor<Eigen::half, 1> full_prec1(num_elem);
-  Tensor<float, 1> input2(num_elem);
-  Tensor<Eigen::half, 1> half_prec2(num_elem);
-  Tensor<Eigen::half, 1> full_prec2(num_elem);
-  Tensor<float, 1> input3(num_elem);
-  Tensor<Eigen::half, 1> half_prec3(num_elem);
-  Tensor<Eigen::half, 1> full_prec3(num_elem);
-  sycl_device.memcpyDeviceToHost(input1.data(), d_float1, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(input2.data(), d_float2, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(input3.data(), d_float3, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(half_prec1.data(), d_res1_half, num_elem * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec1.data(), d_res1_float, num_elem * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(half_prec2.data(), d_res2_half, num_elem * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec2.data(), d_res2_float, num_elem * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(half_prec3.data(), d_res3_half, num_elem * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec3.data(), d_res3_float, num_elem * sizeof(Eigen::half));
-  sycl_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise exp " << i << " input = " << input1(i) << " full = " << full_prec1(i)
-              << " half = " << half_prec1(i) << std::endl;
-    VERIFY_IS_APPROX(full_prec1(i), half_prec1(i));
-  }
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise log " << i << " input = " << input2(i) << " full = " << full_prec2(i)
-              << " half = " << half_prec2(i) << std::endl;
-    if (std::abs(input2(i) - 1.f) < 0.05f)  // log lacks accuracy nearby 1
-      VERIFY_IS_APPROX(full_prec2(i) + Eigen::half(0.1f), half_prec2(i) + Eigen::half(0.1f));
-    else
-      VERIFY_IS_APPROX(full_prec2(i), half_prec2(i));
-  }
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking elemwise plog1 " << i << " input = " << input3(i) << " full = " << full_prec3(i)
-              << " half = " << half_prec3(i) << std::endl;
-    VERIFY_IS_APPROX(full_prec3(i), half_prec3(i));
-  }
-}
-
-void test_gpu_contractions(const Eigen::SyclDevice& sycl_device) {
-  int rows = 23;
-  int cols = 23;
-  int num_elem = rows * cols;
-
-  float* d_float1 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_float2 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res_half = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-  Eigen::half* d_res_float = (Eigen::half*)sycl_device.allocate(num_elem * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float1(d_float1, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float2(d_float2, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_half(d_res_half, rows, cols);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 2>, Eigen::Aligned> gpu_res_float(d_res_float, rows, cols);
-
-  gpu_float1.device(sycl_device) = gpu_float1.random() - gpu_float1.constant(0.5f);
-  gpu_float2.device(sycl_device) = gpu_float2.random() - gpu_float2.constant(0.5f);
-
-  typedef typename Tensor<float, 2>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims;
-  gpu_res_float.device(sycl_device) = gpu_float1.contract(gpu_float2, dims).cast<Eigen::half>();
-  gpu_res_half.device(sycl_device) = gpu_float1.cast<Eigen::half>().contract(gpu_float2.cast<Eigen::half>(), dims);
-
-  Tensor<Eigen::half, 2> half_prec(rows, cols);
-  Tensor<Eigen::half, 2> full_prec(rows, cols);
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, num_elem * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(Eigen::half));
-  sycl_device.synchronize();
-
-  for (int i = 0; i < rows; ++i) {
-    for (int j = 0; j < cols; ++j) {
-      std::cout << "Checking contract " << i << " " << j << full_prec(i, j) << " " << half_prec(i, j) << std::endl;
-      if (numext::abs(full_prec(i, j) - half_prec(i, j)) > Eigen::half(1e-2f)) {
-        VERIFY_IS_APPROX(full_prec(i, j), half_prec(i, j));
-      }
-    }
-  }
-}
-
-void test_gpu_reductions(const Eigen::SyclDevice& sycl_device, int size1, int size2, int redux) {
-  std::cout << "Reducing " << size1 << " by " << size2 << " tensor along dim " << redux << std::endl;
-
-  int num_elem = size1 * size2;
-  int result_size = (redux == 1 ? size1 : size2);
-
-  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res_half = (Eigen::half*)sycl_device.allocate(result_size * sizeof(Eigen::half));
-  Eigen::half* d_res_float = (Eigen::half*)sycl_device.allocate(result_size * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size1, size2);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_half(d_res_half, result_size);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 1>, Eigen::Aligned> gpu_res_float(d_res_float, result_size);
-
-  gpu_float.device(sycl_device) = gpu_float.random() * 2.0f;
-
-  Eigen::array<int, 1> redux_dim = {redux};
-  gpu_res_float.device(sycl_device) = gpu_float.sum(redux_dim).cast<Eigen::half>();
-  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().sum(redux_dim);
-
-  Tensor<Eigen::half, 1> half_prec(result_size);
-  Tensor<Eigen::half, 1> full_prec(result_size);
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, result_size * sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, result_size * sizeof(Eigen::half));
-  sycl_device.synchronize();
-
-  for (int i = 0; i < result_size; ++i) {
-    std::cout << "EXPECTED " << full_prec(i) << " GOT " << half_prec(i) << std::endl;
-    VERIFY_IS_APPROX(full_prec(i), half_prec(i));
-  }
-}
-
-void test_gpu_reductions(const Eigen::SyclDevice& sycl_device) {
-  test_gpu_reductions(sycl_device, 13, 13, 0);
-  test_gpu_reductions(sycl_device, 13, 13, 1);
-
-  test_gpu_reductions(sycl_device, 35, 36, 0);
-  test_gpu_reductions(sycl_device, 35, 36, 1);
-
-  test_gpu_reductions(sycl_device, 36, 35, 0);
-  test_gpu_reductions(sycl_device, 36, 35, 1);
-}
-
-void test_gpu_full_reductions(const Eigen::SyclDevice& sycl_device) {
-  int size = 13;
-  int num_elem = size * size;
-
-  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  Eigen::half* d_res_half = (Eigen::half*)sycl_device.allocate(1 * sizeof(Eigen::half));
-  Eigen::half* d_res_float = (Eigen::half*)sycl_device.allocate(1 * sizeof(Eigen::half));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2>, Eigen::Aligned> gpu_float(d_float, size, size);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_half(d_res_half);
-  Eigen::TensorMap<Eigen::Tensor<Eigen::half, 0>, Eigen::Aligned> gpu_res_float(d_res_float);
-
-  gpu_float.device(sycl_device) = gpu_float.random();
-
-  gpu_res_float.device(sycl_device) = gpu_float.sum().cast<Eigen::half>();
-  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().sum();
-
-  Tensor<Eigen::half, 0> half_prec;
-  Tensor<Eigen::half, 0> full_prec;
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
-  sycl_device.synchronize();
-
-  VERIFY_IS_APPROX(full_prec(), half_prec());
-
-  gpu_res_float.device(sycl_device) = gpu_float.maximum().cast<Eigen::half>();
-  gpu_res_half.device(sycl_device) = gpu_float.cast<Eigen::half>().maximum();
-  sycl_device.memcpyDeviceToHost(half_prec.data(), d_res_half, sizeof(Eigen::half));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, sizeof(Eigen::half));
-  sycl_device.synchronize();
-
-  VERIFY_IS_APPROX(full_prec(), half_prec());
-}
-
-void test_gpu_forced_evals(const Eigen::SyclDevice& sycl_device) {
-  int num_elem = 101;
-
-  float* d_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_res_half1 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_res_half2 = (float*)sycl_device.allocate(num_elem * sizeof(float));
-  float* d_res_float = (float*)sycl_device.allocate(num_elem * sizeof(float));
-
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_float(d_float, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_half1(d_res_half1, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Unaligned> gpu_res_half2(d_res_half2, num_elem);
-  Eigen::TensorMap<Eigen::Tensor<float, 1>, Eigen::Aligned> gpu_res_float(d_res_float, num_elem);
-
-  Eigen::array<int, 1> no_bcast;
-  no_bcast[0] = 1;
-
-  gpu_float.device(sycl_device) = gpu_float.random() - gpu_float.constant(0.5f);
-  gpu_res_float.device(sycl_device) = gpu_float.abs();
-  gpu_res_half1.device(sycl_device) = gpu_float.cast<Eigen::half>().abs().eval().cast<float>();
-  gpu_res_half2.device(sycl_device) = gpu_float.cast<Eigen::half>().abs().broadcast(no_bcast).eval().cast<float>();
-
-  Tensor<float, 1> half_prec1(num_elem);
-  Tensor<float, 1> half_prec2(num_elem);
-  Tensor<float, 1> full_prec(num_elem);
-  sycl_device.memcpyDeviceToHost(half_prec1.data(), d_res_half1, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(half_prec2.data(), d_res_half2, num_elem * sizeof(float));
-  sycl_device.memcpyDeviceToHost(full_prec.data(), d_res_float, num_elem * sizeof(float));
-  sycl_device.synchronize();
-
-  for (int i = 0; i < num_elem; ++i) {
-    std::cout << "Checking forced eval " << i << full_prec(i) << " vs " << half_prec1(i) << " vs " << half_prec2(i)
-              << std::endl;
-    VERIFY_IS_APPROX(full_prec(i), half_prec1(i));
-    VERIFY_IS_APPROX(full_prec(i), half_prec2(i));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_of_float16_sycl) {
-  for (const auto& s : Eigen::get_sycl_supported_devices()) {
-    QueueInterface queueInterface(s);
-    auto sycl_device = Eigen::SyclDevice(&queueInterface);
-
-    CALL_SUBTEST_1(test_gpu_numext(sycl_device));
-    CALL_SUBTEST_1(test_gpu_conversion(sycl_device));
-    CALL_SUBTEST_1(test_gpu_unary(sycl_device));
-    CALL_SUBTEST_1(test_gpu_elementwise(sycl_device));
-    CALL_SUBTEST_1(test_gpu_trancendental(sycl_device));
-    CALL_SUBTEST_2(test_gpu_contractions(sycl_device));
-    CALL_SUBTEST_3(test_gpu_reductions(sycl_device));
-    CALL_SUBTEST_4(test_gpu_full_reductions(sycl_device));
-    CALL_SUBTEST_5(test_gpu_forced_evals(sycl_device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_of_strings.cpp b/unsupported/test/cxx11_tensor_of_strings.cpp
deleted file mode 100644
index 6447503..0000000
--- a/unsupported/test/cxx11_tensor_of_strings.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-static void test_assign() {
-  std::string data1[6];
-  TensorMap<Tensor<std::string, 2>> mat1(data1, 2, 3);
-  std::string data2[6];
-  const TensorMap<Tensor<const std::string, 2>> mat2(data2, 2, 3);
-
-  for (int i = 0; i < 6; ++i) {
-    std::ostringstream s1;
-    s1 << "abc" << i * 3;
-    data1[i] = s1.str();
-    std::ostringstream s2;
-    s2 << "def" << i * 5;
-    data2[i] = s2.str();
-  }
-
-  Tensor<std::string, 2> rslt1;
-  rslt1 = mat1;
-  Tensor<std::string, 2> rslt2;
-  rslt2 = mat2;
-
-  Tensor<std::string, 2> rslt3 = mat1;
-  Tensor<std::string, 2> rslt4 = mat2;
-
-  Tensor<std::string, 2> rslt5(mat1);
-  Tensor<std::string, 2> rslt6(mat2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(rslt1(i, j), data1[i + 2 * j]);
-      VERIFY_IS_EQUAL(rslt2(i, j), data2[i + 2 * j]);
-      VERIFY_IS_EQUAL(rslt3(i, j), data1[i + 2 * j]);
-      VERIFY_IS_EQUAL(rslt4(i, j), data2[i + 2 * j]);
-      VERIFY_IS_EQUAL(rslt5(i, j), data1[i + 2 * j]);
-      VERIFY_IS_EQUAL(rslt6(i, j), data2[i + 2 * j]);
-    }
-  }
-}
-
-static void test_concat() {
-  Tensor<std::string, 2> t1(2, 3);
-  Tensor<std::string, 2> t2(2, 3);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      std::ostringstream s1;
-      s1 << "abc" << i + j * 2;
-      t1(i, j) = s1.str();
-      std::ostringstream s2;
-      s2 << "def" << i * 5 + j * 32;
-      t2(i, j) = s2.str();
-    }
-  }
-
-  Tensor<std::string, 2> result = t1.concatenate(t2, 1);
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 6);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(result(i, j), t1(i, j));
-      VERIFY_IS_EQUAL(result(i, j + 3), t2(i, j));
-    }
-  }
-}
-
-static void test_slices() {
-  Tensor<std::string, 2> data(2, 6);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      std::ostringstream s1;
-      s1 << "abc" << i + j * 2;
-      data(i, j) = s1.str();
-    }
-  }
-
-  const Eigen::DSizes<ptrdiff_t, 2> half_size(2, 3);
-  const Eigen::DSizes<ptrdiff_t, 2> first_half(0, 0);
-  const Eigen::DSizes<ptrdiff_t, 2> second_half(0, 3);
-
-  Tensor<std::string, 2> t1 = data.slice(first_half, half_size);
-  Tensor<std::string, 2> t2 = data.slice(second_half, half_size);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      VERIFY_IS_EQUAL(data(i, j), t1(i, j));
-      VERIFY_IS_EQUAL(data(i, j + 3), t2(i, j));
-    }
-  }
-}
-
-static void test_additions() {
-  Tensor<std::string, 1> data1(3);
-  Tensor<std::string, 1> data2(3);
-  for (int i = 0; i < 3; ++i) {
-    data1(i) = "abc";
-    std::ostringstream s1;
-    s1 << i;
-    data2(i) = s1.str();
-  }
-
-  Tensor<std::string, 1> sum = data1 + data2;
-  for (int i = 0; i < 3; ++i) {
-    std::ostringstream concat;
-    concat << "abc" << i;
-    std::string expected = concat.str();
-    VERIFY_IS_EQUAL(sum(i), expected);
-  }
-}
-
-static void test_initialization() {
-  Tensor<std::string, 2> a(2, 3);
-  a.setConstant(std::string("foo"));
-  for (int i = 0; i < 2 * 3; ++i) {
-    VERIFY_IS_EQUAL(a(i), std::string("foo"));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_of_strings) {
-  // Beware: none of this is likely to ever work on a GPU.
-  CALL_SUBTEST(test_assign());
-  CALL_SUBTEST(test_concat());
-  CALL_SUBTEST(test_slices());
-  CALL_SUBTEST(test_additions());
-  CALL_SUBTEST(test_initialization());
-}
diff --git a/unsupported/test/cxx11_tensor_padding.cpp b/unsupported/test/cxx11_tensor_padding.cpp
deleted file mode 100644
index a21da4a..0000000
--- a/unsupported/test/cxx11_tensor_padding.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_padding() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> paddings;
-  paddings[0] = std::make_pair(0, 0);
-  paddings[1] = std::make_pair(2, 1);
-  paddings[2] = std::make_pair(3, 4);
-  paddings[3] = std::make_pair(0, 0);
-
-  Tensor<float, 4, DataLayout> padded;
-  padded = tensor.pad(paddings);
-
-  VERIFY_IS_EQUAL(padded.dimension(0), 2 + 0);
-  VERIFY_IS_EQUAL(padded.dimension(1), 3 + 3);
-  VERIFY_IS_EQUAL(padded.dimension(2), 5 + 7);
-  VERIFY_IS_EQUAL(padded.dimension(3), 7 + 0);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      for (int k = 0; k < 12; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
-            VERIFY_IS_EQUAL(padded(i, j, k, l), tensor(i, j - 2, k - 3, l));
-          } else {
-            VERIFY_IS_EQUAL(padded(i, j, k, l), 0.0f);
-          }
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_padded_expr() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> paddings;
-  paddings[0] = std::make_pair(0, 0);
-  paddings[1] = std::make_pair(2, 1);
-  paddings[2] = std::make_pair(3, 4);
-  paddings[3] = std::make_pair(0, 0);
-
-  Eigen::DSizes<ptrdiff_t, 2> reshape_dims;
-  reshape_dims[0] = 12;
-  reshape_dims[1] = 84;
-
-  Tensor<float, 2, DataLayout> result;
-  result = tensor.pad(paddings).reshape(reshape_dims);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      for (int k = 0; k < 12; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          const float result_value =
-              DataLayout == ColMajor ? result(i + 2 * j, k + 12 * l) : result(j + 6 * i, l + 7 * k);
-          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
-            VERIFY_IS_EQUAL(result_value, tensor(i, j - 2, k - 3, l));
-          } else {
-            VERIFY_IS_EQUAL(result_value, 0.0f);
-          }
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_padding) {
-  CALL_SUBTEST(test_simple_padding<ColMajor>());
-  CALL_SUBTEST(test_simple_padding<RowMajor>());
-  CALL_SUBTEST(test_padded_expr<ColMajor>());
-  CALL_SUBTEST(test_padded_expr<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_padding_sycl.cpp b/unsupported/test/cxx11_tensor_padding_sycl.cpp
deleted file mode 100644
index e311dc6..0000000
--- a/unsupported/test/cxx11_tensor_padding_sycl.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_padding(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  tensor.setRandom();
-
-  array<std::pair<IndexType, IndexType>, 4> paddings;
-  paddings[0] = std::make_pair(0, 0);
-  paddings[1] = std::make_pair(2, 1);
-  paddings[2] = std::make_pair(3, 4);
-  paddings[3] = std::make_pair(0, 0);
-
-  IndexType padedSizeDim1 = 2;
-  IndexType padedSizeDim2 = 6;
-  IndexType padedSizeDim3 = 12;
-  IndexType padedSizeDim4 = 7;
-  array<IndexType, 4> padedtensorRange = {{padedSizeDim1, padedSizeDim2, padedSizeDim3, padedSizeDim4}};
-
-  Tensor<DataType, 4, DataLayout, IndexType> padded(padedtensorRange);
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(padded.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu2(gpu_data2, padedtensorRange);
-
-  VERIFY_IS_EQUAL(padded.dimension(0), 2 + 0);
-  VERIFY_IS_EQUAL(padded.dimension(1), 3 + 3);
-  VERIFY_IS_EQUAL(padded.dimension(2), 5 + 7);
-  VERIFY_IS_EQUAL(padded.dimension(3), 7 + 0);
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.pad(paddings);
-  sycl_device.memcpyDeviceToHost(padded.data(), gpu_data2, (padded.size()) * sizeof(DataType));
-  for (IndexType i = 0; i < padedSizeDim1; ++i) {
-    for (IndexType j = 0; j < padedSizeDim2; ++j) {
-      for (IndexType k = 0; k < padedSizeDim3; ++k) {
-        for (IndexType l = 0; l < padedSizeDim4; ++l) {
-          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
-            VERIFY_IS_EQUAL(padded(i, j, k, l), tensor(i, j - 2, k - 3, l));
-          } else {
-            VERIFY_IS_EQUAL(padded(i, j, k, l), 0.0f);
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_padded_expr(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  tensor.setRandom();
-
-  array<std::pair<IndexType, IndexType>, 4> paddings;
-  paddings[0] = std::make_pair(0, 0);
-  paddings[1] = std::make_pair(2, 1);
-  paddings[2] = std::make_pair(3, 4);
-  paddings[3] = std::make_pair(0, 0);
-
-  Eigen::DSizes<IndexType, 2> reshape_dims;
-  reshape_dims[0] = 12;
-  reshape_dims[1] = 84;
-
-  Tensor<DataType, 2, DataLayout, IndexType> result(reshape_dims);
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(tensor.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(result.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu2(gpu_data2, reshape_dims);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), (tensor.size()) * sizeof(DataType));
-  gpu2.device(sycl_device) = gpu1.pad(paddings).reshape(reshape_dims);
-  sycl_device.memcpyDeviceToHost(result.data(), gpu_data2, (result.size()) * sizeof(DataType));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 6; ++j) {
-      for (IndexType k = 0; k < 12; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          const float result_value =
-              DataLayout == ColMajor ? result(i + 2 * j, k + 12 * l) : result(j + 6 * i, l + 7 * k);
-          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
-            VERIFY_IS_EQUAL(result_value, tensor(i, j - 2, k - 3, l));
-          } else {
-            VERIFY_IS_EQUAL(result_value, 0.0f);
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_padding_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_padding<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_padding<DataType, ColMajor, int64_t>(sycl_device);
-  test_padded_expr<DataType, RowMajor, int64_t>(sycl_device);
-  test_padded_expr<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_padding_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_padding_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_padding_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_patch.cpp b/unsupported/test/cxx11_tensor_patch.cpp
deleted file mode 100644
index 76e75f9..0000000
--- a/unsupported/test/cxx11_tensor_patch.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_patch() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> patch_dims;
-
-  patch_dims[0] = 1;
-  patch_dims[1] = 1;
-  patch_dims[2] = 1;
-  patch_dims[3] = 1;
-
-  Tensor<float, 5, DataLayout> no_patch;
-  no_patch = tensor.extract_patches(patch_dims);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(no_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(4), tensor.size());
-  } else {
-    VERIFY_IS_EQUAL(no_patch.dimension(0), tensor.size());
-    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(4), 1);
-  }
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    VERIFY_IS_EQUAL(tensor.data()[i], no_patch.data()[i]);
-  }
-
-  patch_dims[0] = 2;
-  patch_dims[1] = 3;
-  patch_dims[2] = 5;
-  patch_dims[3] = 7;
-  Tensor<float, 5, DataLayout> single_patch;
-  single_patch = tensor.extract_patches(patch_dims);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(single_patch.dimension(0), 2);
-    VERIFY_IS_EQUAL(single_patch.dimension(1), 3);
-    VERIFY_IS_EQUAL(single_patch.dimension(2), 5);
-    VERIFY_IS_EQUAL(single_patch.dimension(3), 7);
-    VERIFY_IS_EQUAL(single_patch.dimension(4), 1);
-  } else {
-    VERIFY_IS_EQUAL(single_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(single_patch.dimension(1), 2);
-    VERIFY_IS_EQUAL(single_patch.dimension(2), 3);
-    VERIFY_IS_EQUAL(single_patch.dimension(3), 5);
-    VERIFY_IS_EQUAL(single_patch.dimension(4), 7);
-  }
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    VERIFY_IS_EQUAL(tensor.data()[i], single_patch.data()[i]);
-  }
-
-  patch_dims[0] = 1;
-  patch_dims[1] = 2;
-  patch_dims[2] = 2;
-  patch_dims[3] = 1;
-  Tensor<float, 5, DataLayout> twod_patch;
-  twod_patch = tensor.extract_patches(patch_dims);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(twod_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(3), 1);
-    VERIFY_IS_EQUAL(twod_patch.dimension(4), 2 * 2 * 4 * 7);
-  } else {
-    VERIFY_IS_EQUAL(twod_patch.dimension(0), 2 * 2 * 4 * 7);
-    VERIFY_IS_EQUAL(twod_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(3), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(4), 1);
-  }
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 4; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          int patch_loc;
-          if (DataLayout == ColMajor) {
-            patch_loc = i + 2 * (j + 2 * (k + 4 * l));
-          } else {
-            patch_loc = l + 7 * (k + 4 * (j + 2 * i));
-          }
-          for (int x = 0; x < 2; ++x) {
-            for (int y = 0; y < 2; ++y) {
-              if (DataLayout == ColMajor) {
-                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(0, x, y, 0, patch_loc));
-              } else {
-                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(patch_loc, 0, x, y, 0));
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  patch_dims[0] = 1;
-  patch_dims[1] = 2;
-  patch_dims[2] = 3;
-  patch_dims[3] = 5;
-  Tensor<float, 5, DataLayout> threed_patch;
-  threed_patch = tensor.extract_patches(patch_dims);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(threed_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(threed_patch.dimension(1), 2);
-    VERIFY_IS_EQUAL(threed_patch.dimension(2), 3);
-    VERIFY_IS_EQUAL(threed_patch.dimension(3), 5);
-    VERIFY_IS_EQUAL(threed_patch.dimension(4), 2 * 2 * 3 * 3);
-  } else {
-    VERIFY_IS_EQUAL(threed_patch.dimension(0), 2 * 2 * 3 * 3);
-    VERIFY_IS_EQUAL(threed_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(threed_patch.dimension(2), 2);
-    VERIFY_IS_EQUAL(threed_patch.dimension(3), 3);
-    VERIFY_IS_EQUAL(threed_patch.dimension(4), 5);
-  }
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 3; ++l) {
-          int patch_loc;
-          if (DataLayout == ColMajor) {
-            patch_loc = i + 2 * (j + 2 * (k + 3 * l));
-          } else {
-            patch_loc = l + 3 * (k + 3 * (j + 2 * i));
-          }
-          for (int x = 0; x < 2; ++x) {
-            for (int y = 0; y < 3; ++y) {
-              for (int z = 0; z < 5; ++z) {
-                if (DataLayout == ColMajor) {
-                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(0, x, y, z, patch_loc));
-                } else {
-                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(patch_loc, 0, x, y, z));
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_patch) {
-  CALL_SUBTEST(test_simple_patch<ColMajor>());
-  CALL_SUBTEST(test_simple_patch<RowMajor>());
-  //   CALL_SUBTEST(test_expr_shuffling());
-}
diff --git a/unsupported/test/cxx11_tensor_patch_sycl.cpp b/unsupported/test/cxx11_tensor_patch_sycl.cpp
deleted file mode 100644
index 3000cdc..0000000
--- a/unsupported/test/cxx11_tensor_patch_sycl.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_patch_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  array<IndexType, 5> patchTensorRange;
-  if (DataLayout == ColMajor) {
-    patchTensorRange = {{1, 1, 1, 1, sizeDim1 * sizeDim2 * sizeDim3 * sizeDim4}};
-  } else {
-    patchTensorRange = {{sizeDim1 * sizeDim2 * sizeDim3 * sizeDim4, 1, 1, 1, 1}};
-  }
-
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 5, DataLayout, IndexType> no_patch(patchTensorRange);
-
-  tensor.setRandom();
-
-  array<ptrdiff_t, 4> patch_dims;
-  patch_dims[0] = 1;
-  patch_dims[1] = 1;
-  patch_dims[2] = 1;
-  patch_dims[3] = 1;
-
-  const size_t tensorBuffSize = tensor.size() * sizeof(DataType);
-  size_t patchTensorBuffSize = no_patch.size() * sizeof(DataType);
-  DataType* gpu_data_tensor = static_cast<DataType*>(sycl_device.allocate(tensorBuffSize));
-  DataType* gpu_data_no_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu_tensor(gpu_data_tensor, tensorRange);
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_no_patch(gpu_data_no_patch, patchTensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_tensor, tensor.data(), tensorBuffSize);
-  gpu_no_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
-  sycl_device.memcpyDeviceToHost(no_patch.data(), gpu_data_no_patch, patchTensorBuffSize);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(no_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(4), tensor.size());
-  } else {
-    VERIFY_IS_EQUAL(no_patch.dimension(0), tensor.size());
-    VERIFY_IS_EQUAL(no_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(2), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(3), 1);
-    VERIFY_IS_EQUAL(no_patch.dimension(4), 1);
-  }
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    VERIFY_IS_EQUAL(tensor.data()[i], no_patch.data()[i]);
-  }
-
-  patch_dims[0] = 2;
-  patch_dims[1] = 3;
-  patch_dims[2] = 5;
-  patch_dims[3] = 7;
-
-  if (DataLayout == ColMajor) {
-    patchTensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4, 1}};
-  } else {
-    patchTensorRange = {{1, sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  }
-  Tensor<DataType, 5, DataLayout, IndexType> single_patch(patchTensorRange);
-  patchTensorBuffSize = single_patch.size() * sizeof(DataType);
-  DataType* gpu_data_single_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_single_patch(gpu_data_single_patch, patchTensorRange);
-
-  gpu_single_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
-  sycl_device.memcpyDeviceToHost(single_patch.data(), gpu_data_single_patch, patchTensorBuffSize);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(single_patch.dimension(0), 2);
-    VERIFY_IS_EQUAL(single_patch.dimension(1), 3);
-    VERIFY_IS_EQUAL(single_patch.dimension(2), 5);
-    VERIFY_IS_EQUAL(single_patch.dimension(3), 7);
-    VERIFY_IS_EQUAL(single_patch.dimension(4), 1);
-  } else {
-    VERIFY_IS_EQUAL(single_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(single_patch.dimension(1), 2);
-    VERIFY_IS_EQUAL(single_patch.dimension(2), 3);
-    VERIFY_IS_EQUAL(single_patch.dimension(3), 5);
-    VERIFY_IS_EQUAL(single_patch.dimension(4), 7);
-  }
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    VERIFY_IS_EQUAL(tensor.data()[i], single_patch.data()[i]);
-  }
-  patch_dims[0] = 1;
-  patch_dims[1] = 2;
-  patch_dims[2] = 2;
-  patch_dims[3] = 1;
-
-  if (DataLayout == ColMajor) {
-    patchTensorRange = {{1, 2, 2, 1, 2 * 2 * 4 * 7}};
-  } else {
-    patchTensorRange = {{2 * 2 * 4 * 7, 1, 2, 2, 1}};
-  }
-  Tensor<DataType, 5, DataLayout, IndexType> twod_patch(patchTensorRange);
-  patchTensorBuffSize = twod_patch.size() * sizeof(DataType);
-  DataType* gpu_data_twod_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_twod_patch(gpu_data_twod_patch, patchTensorRange);
-
-  gpu_twod_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
-  sycl_device.memcpyDeviceToHost(twod_patch.data(), gpu_data_twod_patch, patchTensorBuffSize);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(twod_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(twod_patch.dimension(1), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(3), 1);
-    VERIFY_IS_EQUAL(twod_patch.dimension(4), 2 * 2 * 4 * 7);
-  } else {
-    VERIFY_IS_EQUAL(twod_patch.dimension(0), 2 * 2 * 4 * 7);
-    VERIFY_IS_EQUAL(twod_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(twod_patch.dimension(2), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(3), 2);
-    VERIFY_IS_EQUAL(twod_patch.dimension(4), 1);
-  }
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 4; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          int patch_loc;
-          if (DataLayout == ColMajor) {
-            patch_loc = i + 2 * (j + 2 * (k + 4 * l));
-          } else {
-            patch_loc = l + 7 * (k + 4 * (j + 2 * i));
-          }
-          for (int x = 0; x < 2; ++x) {
-            for (int y = 0; y < 2; ++y) {
-              if (DataLayout == ColMajor) {
-                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(0, x, y, 0, patch_loc));
-              } else {
-                VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l), twod_patch(patch_loc, 0, x, y, 0));
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  patch_dims[0] = 1;
-  patch_dims[1] = 2;
-  patch_dims[2] = 3;
-  patch_dims[3] = 5;
-
-  if (DataLayout == ColMajor) {
-    patchTensorRange = {{1, 2, 3, 5, 2 * 2 * 3 * 3}};
-  } else {
-    patchTensorRange = {{2 * 2 * 3 * 3, 1, 2, 3, 5}};
-  }
-  Tensor<DataType, 5, DataLayout, IndexType> threed_patch(patchTensorRange);
-  patchTensorBuffSize = threed_patch.size() * sizeof(DataType);
-  DataType* gpu_data_threed_patch = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 5, DataLayout, IndexType>> gpu_threed_patch(gpu_data_threed_patch, patchTensorRange);
-
-  gpu_threed_patch.device(sycl_device) = gpu_tensor.extract_patches(patch_dims);
-  sycl_device.memcpyDeviceToHost(threed_patch.data(), gpu_data_threed_patch, patchTensorBuffSize);
-
-  if (DataLayout == ColMajor) {
-    VERIFY_IS_EQUAL(threed_patch.dimension(0), 1);
-    VERIFY_IS_EQUAL(threed_patch.dimension(1), 2);
-    VERIFY_IS_EQUAL(threed_patch.dimension(2), 3);
-    VERIFY_IS_EQUAL(threed_patch.dimension(3), 5);
-    VERIFY_IS_EQUAL(threed_patch.dimension(4), 2 * 2 * 3 * 3);
-  } else {
-    VERIFY_IS_EQUAL(threed_patch.dimension(0), 2 * 2 * 3 * 3);
-    VERIFY_IS_EQUAL(threed_patch.dimension(1), 1);
-    VERIFY_IS_EQUAL(threed_patch.dimension(2), 2);
-    VERIFY_IS_EQUAL(threed_patch.dimension(3), 3);
-    VERIFY_IS_EQUAL(threed_patch.dimension(4), 5);
-  }
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 3; ++l) {
-          int patch_loc;
-          if (DataLayout == ColMajor) {
-            patch_loc = i + 2 * (j + 2 * (k + 3 * l));
-          } else {
-            patch_loc = l + 3 * (k + 3 * (j + 2 * i));
-          }
-          for (int x = 0; x < 2; ++x) {
-            for (int y = 0; y < 3; ++y) {
-              for (int z = 0; z < 5; ++z) {
-                if (DataLayout == ColMajor) {
-                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(0, x, y, z, patch_loc));
-                } else {
-                  VERIFY_IS_EQUAL(tensor(i, j + x, k + y, l + z), threed_patch(patch_loc, 0, x, y, z));
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_tensor);
-  sycl_device.deallocate(gpu_data_no_patch);
-  sycl_device.deallocate(gpu_data_single_patch);
-  sycl_device.deallocate(gpu_data_twod_patch);
-  sycl_device.deallocate(gpu_data_threed_patch);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_tensor_patch_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_patch_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_patch_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_patch_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_tensor_patch_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_tensor_patch_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_random.cpp b/unsupported/test/cxx11_tensor_random.cpp
deleted file mode 100644
index 7cc2a2f..0000000
--- a/unsupported/test/cxx11_tensor_random.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-template <typename Scalar>
-static void test_default() {
-  Tensor<Scalar, 1> vec(6);
-
-  // Fixme: we should check that the generated numbers follow a uniform
-  // distribution instead.
-  // For low-precision types (half, bfloat16), the RNG has limited distinct
-  // values (e.g. 128 for bfloat16), so adjacent collisions are possible.
-  // Retry a few times to avoid spurious failures.
-  bool all_distinct = false;
-  for (int attempt = 0; attempt < 10 && !all_distinct; ++attempt) {
-    vec.setRandom();
-    all_distinct = true;
-    for (int i = 1; i < 6; ++i) {
-      if (vec(i) == vec(i - 1)) {
-        all_distinct = false;
-        break;
-      }
-    }
-  }
-  VERIFY(all_distinct);
-}
-
-template <typename Scalar>
-static void test_normal() {
-  Tensor<Scalar, 1> vec(6);
-
-  // Fixme: we should check that the generated numbers follow a gaussian
-  // distribution instead.
-  bool all_distinct = false;
-  for (int attempt = 0; attempt < 10 && !all_distinct; ++attempt) {
-    vec.template setRandom<Eigen::internal::NormalRandomGenerator<Scalar>>();
-    all_distinct = true;
-    for (int i = 1; i < 6; ++i) {
-      if (vec(i) == vec(i - 1)) {
-        all_distinct = false;
-        break;
-      }
-    }
-  }
-  VERIFY(all_distinct);
-}
-
-struct MyGenerator {
-  MyGenerator() {}
-  MyGenerator(const MyGenerator&) {}
-
-  // Return a random value to be used.  "element_location" is the
-  // location of the entry to set in the tensor, it can typically
-  // be ignored.
-  int operator()(Eigen::DenseIndex element_location, Eigen::DenseIndex /*unused*/ = 0) const {
-    return static_cast<int>(3 * element_location);
-  }
-
-  // Same as above but generates several numbers at a time.
-  internal::packet_traits<int>::type packetOp(Eigen::DenseIndex packet_location,
-                                              Eigen::DenseIndex /*unused*/ = 0) const {
-    const int packetSize = internal::packet_traits<int>::size;
-    EIGEN_ALIGN_MAX int values[packetSize];
-    for (int i = 0; i < packetSize; ++i) {
-      values[i] = static_cast<int>(3 * (packet_location + i));
-    }
-    return internal::pload<typename internal::packet_traits<int>::type>(values);
-  }
-};
-
-static void test_custom() {
-  Tensor<int, 1> vec(6);
-  vec.setRandom<MyGenerator>();
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(vec(i), 3 * i);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_random) {
-  CALL_SUBTEST((test_default<float>()));
-  CALL_SUBTEST((test_normal<float>()));
-  CALL_SUBTEST((test_default<double>()));
-  CALL_SUBTEST((test_normal<double>()));
-  CALL_SUBTEST((test_default<Eigen::half>()));
-  CALL_SUBTEST((test_normal<Eigen::half>()));
-  CALL_SUBTEST((test_default<Eigen::bfloat16>()));
-  CALL_SUBTEST((test_normal<Eigen::bfloat16>()));
-  CALL_SUBTEST(test_custom());
-}
diff --git a/unsupported/test/cxx11_tensor_random_gpu.cu b/unsupported/test/cxx11_tensor_random_gpu.cu
deleted file mode 100644
index f6f269e..0000000
--- a/unsupported/test/cxx11_tensor_random_gpu.cu
+++ /dev/null
@@ -1,78 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <Eigen/Tensor>
-
-void test_gpu_random_uniform() {
-  Tensor<float, 2> out(72, 97);
-  out.setZero();
-
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_out;
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2> > gpu_out(d_out, 72, 97);
-
-  gpu_out.device(gpu_device) = gpu_out.random();
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-
-  // For now we just check this code doesn't crash.
-  // TODO: come up with a valid test of randomness
-}
-
-void test_gpu_random_normal() {
-  Tensor<float, 2> out(72, 97);
-  out.setZero();
-
-  std::size_t out_bytes = out.size() * sizeof(float);
-
-  float* d_out;
-  gpuMalloc((void**)(&d_out), out_bytes);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 2> > gpu_out(d_out, 72, 97);
-
-  Eigen::internal::NormalRandomGenerator<float> gen(true);
-  gpu_out.device(gpu_device) = gpu_out.random(gen);
-
-  assert(gpuMemcpyAsync(out.data(), d_out, out_bytes, gpuMemcpyDeviceToHost, gpu_device.stream()) == gpuSuccess);
-  assert(gpuStreamSynchronize(gpu_device.stream()) == gpuSuccess);
-}
-
-static void test_complex() {
-  Tensor<std::complex<float>, 1> vec(6);
-  vec.setRandom();
-
-  // Fixme: we should check that the generated numbers follow a uniform
-  // distribution instead.
-  for (int i = 1; i < 6; ++i) {
-    VERIFY_IS_NOT_EQUAL(vec(i), vec(i - 1));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_random_gpu) {
-  CALL_SUBTEST(test_gpu_random_uniform());
-  CALL_SUBTEST(test_gpu_random_normal());
-  CALL_SUBTEST(test_complex());
-}
diff --git a/unsupported/test/cxx11_tensor_random_sycl.cpp b/unsupported/test/cxx11_tensor_random_sycl.cpp
deleted file mode 100644
index 76bfdbf..0000000
--- a/unsupported/test/cxx11_tensor_random_sycl.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_sycl_random_uniform(const Eigen::SyclDevice& sycl_device) {
-  Tensor<DataType, 2, DataLayout, IndexType> out(72, 97);
-  out.setZero();
-
-  std::size_t out_bytes = out.size() * sizeof(DataType);
-
-  IndexType sizeDim0 = 72;
-  IndexType sizeDim1 = 97;
-
-  array<IndexType, 2> tensorRange = {{sizeDim0, sizeDim1}};
-
-  DataType* d_out = static_cast<DataType*>(sycl_device.allocate(out_bytes));
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_out(d_out, tensorRange);
-
-  gpu_out.device(sycl_device) = gpu_out.random();
-  sycl_device.memcpyDeviceToHost(out.data(), d_out, out_bytes);
-
-  // For now we just check the code doesn't crash.
-  // TODO: come up with a valid test of randomness
-  sycl_device.deallocate(d_out);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_random_normal(const Eigen::SyclDevice& sycl_device) {
-  Tensor<DataType, 2, DataLayout, IndexType> out(72, 97);
-  out.setZero();
-  std::size_t out_bytes = out.size() * sizeof(DataType);
-
-  IndexType sizeDim0 = 72;
-  IndexType sizeDim1 = 97;
-
-  array<IndexType, 2> tensorRange = {{sizeDim0, sizeDim1}};
-
-  DataType* d_out = static_cast<DataType*>(sycl_device.allocate(out_bytes));
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> gpu_out(d_out, tensorRange);
-  Eigen::internal::NormalRandomGenerator<DataType> gen(true);
-  gpu_out.device(sycl_device) = gpu_out.random(gen);
-  sycl_device.memcpyDeviceToHost(out.data(), d_out, out_bytes);
-
-  // For now we just check the code doesn't crash.
-  // TODO: come up with a valid test of randomness
-  sycl_device.deallocate(d_out);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_random_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_sycl_random_uniform<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_random_uniform<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_random_normal<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_random_normal<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_random_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_random_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_random_test_per_device<float>(device));
-#ifdef EIGEN_SYCL_DOUBLE_SUPPORT
-    CALL_SUBTEST(sycl_random_test_per_device<double>(device));
-#endif
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_reduction.cpp b/unsupported/test/cxx11_tensor_reduction.cpp
deleted file mode 100644
index 81dc0ce..0000000
--- a/unsupported/test/cxx11_tensor_reduction.cpp
+++ /dev/null
@@ -1,520 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <limits>
-#include <numeric>
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_trivial_reductions() {
-  {
-    Tensor<float, 0, DataLayout> tensor;
-    tensor.setRandom();
-    array<ptrdiff_t, 0> reduction_axis;
-
-    Tensor<float, 0, DataLayout> result = tensor.sum(reduction_axis);
-    VERIFY_IS_EQUAL(result(), tensor());
-  }
-
-  {
-    Tensor<float, 1, DataLayout> tensor(7);
-    tensor.setRandom();
-    array<ptrdiff_t, 0> reduction_axis;
-
-    Tensor<float, 1, DataLayout> result = tensor.sum(reduction_axis);
-    VERIFY_IS_EQUAL(result.dimension(0), 7);
-    for (int i = 0; i < 7; ++i) {
-      VERIFY_IS_EQUAL(result(i), tensor(i));
-    }
-  }
-
-  {
-    Tensor<float, 2, DataLayout> tensor(2, 3);
-    tensor.setRandom();
-    array<ptrdiff_t, 0> reduction_axis;
-
-    Tensor<float, 2, DataLayout> result = tensor.sum(reduction_axis);
-    VERIFY_IS_EQUAL(result.dimension(0), 2);
-    VERIFY_IS_EQUAL(result.dimension(1), 3);
-    for (int i = 0; i < 2; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        VERIFY_IS_EQUAL(result(i, j), tensor(i, j));
-      }
-    }
-  }
-}
-
-template <typename Scalar, int DataLayout>
-static void test_simple_reductions() {
-  Tensor<Scalar, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  // Add a little offset so that the product reductions won't be close to zero.
-  tensor += tensor.constant(Scalar(0.5f));
-  array<ptrdiff_t, 2> reduction_axis2;
-  reduction_axis2[0] = 1;
-  reduction_axis2[1] = 3;
-
-  Tensor<Scalar, 2, DataLayout> result = tensor.sum(reduction_axis2);
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 5);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      Scalar sum = Scalar(0.0f);
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          sum += tensor(i, k, j, l);
-        }
-      }
-      VERIFY_IS_APPROX(result(i, j), sum);
-    }
-  }
-
-  {
-    Tensor<Scalar, 0, DataLayout> sum1 = tensor.sum();
-    VERIFY_IS_EQUAL(sum1.rank(), 0);
-
-    array<ptrdiff_t, 4> reduction_axis4;
-    reduction_axis4[0] = 0;
-    reduction_axis4[1] = 1;
-    reduction_axis4[2] = 2;
-    reduction_axis4[3] = 3;
-    Tensor<Scalar, 0, DataLayout> sum2 = tensor.sum(reduction_axis4);
-    VERIFY_IS_EQUAL(sum2.rank(), 0);
-
-    VERIFY_IS_APPROX(sum1(), sum2());
-  }
-
-  reduction_axis2[0] = 0;
-  reduction_axis2[1] = 2;
-  result = tensor.prod(reduction_axis2);
-  VERIFY_IS_EQUAL(result.dimension(0), 3);
-  VERIFY_IS_EQUAL(result.dimension(1), 7);
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      Scalar prod = Scalar(1.0f);
-      for (int k = 0; k < 2; ++k) {
-        for (int l = 0; l < 5; ++l) {
-          prod *= tensor(k, i, l, j);
-        }
-      }
-      VERIFY_IS_APPROX(result(i, j), prod);
-    }
-  }
-
-  {
-    Tensor<Scalar, 0, DataLayout> prod1 = tensor.prod();
-    VERIFY_IS_EQUAL(prod1.rank(), 0);
-
-    array<ptrdiff_t, 4> reduction_axis4;
-    reduction_axis4[0] = 0;
-    reduction_axis4[1] = 1;
-    reduction_axis4[2] = 2;
-    reduction_axis4[3] = 3;
-    Tensor<Scalar, 0, DataLayout> prod2 = tensor.prod(reduction_axis4);
-    VERIFY_IS_EQUAL(prod2.rank(), 0);
-
-    VERIFY_IS_APPROX(prod1(), prod2());
-  }
-
-  reduction_axis2[0] = 0;
-  reduction_axis2[1] = 2;
-  result = tensor.maximum(reduction_axis2);
-  VERIFY_IS_EQUAL(result.dimension(0), 3);
-  VERIFY_IS_EQUAL(result.dimension(1), 7);
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      Scalar max_val = std::numeric_limits<Scalar>::lowest();
-      for (int k = 0; k < 2; ++k) {
-        for (int l = 0; l < 5; ++l) {
-          max_val = (std::max)(max_val, tensor(k, i, l, j));
-        }
-      }
-      VERIFY_IS_APPROX(result(i, j), max_val);
-    }
-  }
-
-  {
-    Tensor<Scalar, 0, DataLayout> max1 = tensor.maximum();
-    VERIFY_IS_EQUAL(max1.rank(), 0);
-
-    array<ptrdiff_t, 4> reduction_axis4;
-    reduction_axis4[0] = 0;
-    reduction_axis4[1] = 1;
-    reduction_axis4[2] = 2;
-    reduction_axis4[3] = 3;
-    Tensor<Scalar, 0, DataLayout> max2 = tensor.maximum(reduction_axis4);
-    VERIFY_IS_EQUAL(max2.rank(), 0);
-
-    VERIFY_IS_APPROX(max1(), max2());
-  }
-
-  reduction_axis2[0] = 0;
-  reduction_axis2[1] = 1;
-  result = tensor.minimum(reduction_axis2);
-  VERIFY_IS_EQUAL(result.dimension(0), 5);
-  VERIFY_IS_EQUAL(result.dimension(1), 7);
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      Scalar min_val = (std::numeric_limits<Scalar>::max)();
-      for (int k = 0; k < 2; ++k) {
-        for (int l = 0; l < 3; ++l) {
-          min_val = (std::min)(min_val, tensor(k, l, i, j));
-        }
-      }
-      VERIFY_IS_APPROX(result(i, j), min_val);
-    }
-  }
-
-  {
-    Tensor<Scalar, 0, DataLayout> min1 = tensor.minimum();
-    VERIFY_IS_EQUAL(min1.rank(), 0);
-
-    array<ptrdiff_t, 4> reduction_axis4;
-    reduction_axis4[0] = 0;
-    reduction_axis4[1] = 1;
-    reduction_axis4[2] = 2;
-    reduction_axis4[3] = 3;
-    Tensor<Scalar, 0, DataLayout> min2 = tensor.minimum(reduction_axis4);
-    VERIFY_IS_EQUAL(min2.rank(), 0);
-
-    VERIFY_IS_APPROX(min1(), min2());
-  }
-
-  reduction_axis2[0] = 0;
-  reduction_axis2[1] = 1;
-  result = tensor.mean(reduction_axis2);
-  VERIFY_IS_EQUAL(result.dimension(0), 5);
-  VERIFY_IS_EQUAL(result.dimension(1), 7);
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      Scalar sum = Scalar(0.0f);
-      int count = 0;
-      for (int k = 0; k < 2; ++k) {
-        for (int l = 0; l < 3; ++l) {
-          sum += tensor(k, l, i, j);
-          ++count;
-        }
-      }
-      VERIFY_IS_APPROX(result(i, j), sum / Scalar(count));
-    }
-  }
-
-  {
-    Tensor<Scalar, 0, DataLayout> mean1 = tensor.mean();
-    VERIFY_IS_EQUAL(mean1.rank(), 0);
-
-    array<ptrdiff_t, 4> reduction_axis4;
-    reduction_axis4[0] = 0;
-    reduction_axis4[1] = 1;
-    reduction_axis4[2] = 2;
-    reduction_axis4[3] = 3;
-    Tensor<Scalar, 0, DataLayout> mean2 = tensor.mean(reduction_axis4);
-    VERIFY_IS_EQUAL(mean2.rank(), 0);
-
-    VERIFY_IS_APPROX(mean1(), mean2());
-  }
-
-  {
-    Tensor<int, 1> ints(10);
-    std::iota(ints.data(), ints.data() + ints.dimension(0), 0);
-
-    TensorFixedSize<bool, Sizes<>> all_;
-    all_ = ints.all();
-    VERIFY(!all_());
-    all_ = (ints >= ints.constant(0)).all();
-    VERIFY(all_());
-
-    TensorFixedSize<bool, Sizes<>> any;
-    any = (ints > ints.constant(10)).any();
-    VERIFY(!any());
-    any = (ints < ints.constant(1)).any();
-    VERIFY(any());
-  }
-}
-
-template <int DataLayout>
-static void test_reductions_in_expr() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 2> reduction_axis2;
-  reduction_axis2[0] = 1;
-  reduction_axis2[1] = 3;
-
-  Tensor<float, 2, DataLayout> result(2, 5);
-  result = result.constant(1.0f) - tensor.sum(reduction_axis2);
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 5);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      float sum = 0.0f;
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          sum += tensor(i, k, j, l);
-        }
-      }
-      VERIFY_IS_APPROX(result(i, j), 1.0f - sum);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_full_reductions() {
-  Tensor<float, 2, DataLayout> tensor(2, 3);
-  tensor.setRandom();
-  array<ptrdiff_t, 2> reduction_axis;
-  reduction_axis[0] = 0;
-  reduction_axis[1] = 1;
-
-  Tensor<float, 0, DataLayout> result = tensor.sum(reduction_axis);
-  VERIFY_IS_EQUAL(result.rank(), 0);
-
-  float sum = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      sum += tensor(i, j);
-    }
-  }
-  VERIFY_IS_APPROX(result(0), sum);
-
-  result = tensor.square().sum(reduction_axis).sqrt();
-  VERIFY_IS_EQUAL(result.rank(), 0);
-
-  sum = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      sum += tensor(i, j) * tensor(i, j);
-    }
-  }
-  VERIFY_IS_APPROX(result(), sqrtf(sum));
-}
-
-struct UserReducer {
-  static const bool PacketAccess = false;
-  UserReducer(float offset) : offset_(offset) {}
-  void reduce(const float val, float* accum) { *accum += val * val; }
-  float initialize() const { return 0; }
-  float finalize(const float accum) const { return 1.0f / (accum + offset_); }
-
- private:
-  const float offset_;
-};
-
-template <int DataLayout>
-static void test_user_defined_reductions() {
-  Tensor<float, 2, DataLayout> tensor(5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 1> reduction_axis;
-  reduction_axis[0] = 1;
-
-  UserReducer reducer(10.0f);
-  Tensor<float, 1, DataLayout> result = tensor.reduce(reduction_axis, reducer);
-  VERIFY_IS_EQUAL(result.dimension(0), 5);
-  for (int i = 0; i < 5; ++i) {
-    float expected = 10.0f;
-    for (int j = 0; j < 7; ++j) {
-      expected += tensor(i, j) * tensor(i, j);
-    }
-    expected = 1.0f / expected;
-    VERIFY_IS_APPROX(result(i), expected);
-  }
-}
-
-template <int DataLayout>
-static void test_tensor_maps() {
-  int inputs[2 * 3 * 5 * 7];
-  TensorMap<Tensor<int, 4, DataLayout>> tensor_map(inputs, 2, 3, 5, 7);
-  TensorMap<Tensor<const int, 4, DataLayout>> tensor_map_const(inputs, 2, 3, 5, 7);
-  const TensorMap<Tensor<const int, 4, DataLayout>> tensor_map_const_const(inputs, 2, 3, 5, 7);
-
-  tensor_map.setRandom();
-  array<ptrdiff_t, 2> reduction_axis;
-  reduction_axis[0] = 1;
-  reduction_axis[1] = 3;
-
-  Tensor<int, 2, DataLayout> result = tensor_map.sum(reduction_axis);
-  Tensor<int, 2, DataLayout> result2 = tensor_map_const.sum(reduction_axis);
-  Tensor<int, 2, DataLayout> result3 = tensor_map_const_const.sum(reduction_axis);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      int sum = 0;
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          sum += tensor_map(i, k, j, l);
-        }
-      }
-      VERIFY_IS_EQUAL(result(i, j), sum);
-      VERIFY_IS_EQUAL(result2(i, j), sum);
-      VERIFY_IS_EQUAL(result3(i, j), sum);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_static_dims() {
-  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
-  Tensor<float, 2, DataLayout> out(72, 97);
-  in.setRandom();
-
-  Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<3>> reduction_axis;
-
-  out = in.maximum(reduction_axis);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 97; ++j) {
-      float expected = -1e10f;
-      for (int k = 0; k < 53; ++k) {
-        for (int l = 0; l < 113; ++l) {
-          expected = (std::max)(expected, in(i, k, j, l));
-        }
-      }
-      VERIFY_IS_EQUAL(out(i, j), expected);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_innermost_last_dims() {
-  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
-  Tensor<float, 2, DataLayout> out(97, 113);
-  in.setRandom();
-
-  // Reduce on the innermost dimensions.
-  // This triggers the use of packets for ColMajor.
-  Eigen::IndexList<Eigen::type2index<0>, Eigen::type2index<1>> reduction_axis;
-
-  out = in.maximum(reduction_axis);
-
-  for (int i = 0; i < 97; ++i) {
-    for (int j = 0; j < 113; ++j) {
-      float expected = -1e10f;
-      for (int k = 0; k < 53; ++k) {
-        for (int l = 0; l < 72; ++l) {
-          expected = (std::max)(expected, in(l, k, i, j));
-        }
-      }
-      VERIFY_IS_EQUAL(out(i, j), expected);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_innermost_first_dims() {
-  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
-  Tensor<float, 2, DataLayout> out(72, 53);
-  in.setRandom();
-
-  // Reduce on the innermost dimensions.
-  // This triggers the use of packets for RowMajor.
-  Eigen::IndexList<Eigen::type2index<2>, Eigen::type2index<3>> reduction_axis;
-
-  out = in.maximum(reduction_axis);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 53; ++j) {
-      float expected = -1e10f;
-      for (int k = 0; k < 97; ++k) {
-        for (int l = 0; l < 113; ++l) {
-          expected = (std::max)(expected, in(i, j, k, l));
-        }
-      }
-      VERIFY_IS_EQUAL(out(i, j), expected);
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_reduce_middle_dims() {
-  Tensor<float, 4, DataLayout> in(72, 53, 97, 113);
-  Tensor<float, 2, DataLayout> out(72, 53);
-  in.setRandom();
-
-  // Reduce on the innermost dimensions.
-  // This triggers the use of packets for RowMajor.
-  Eigen::IndexList<Eigen::type2index<1>, Eigen::type2index<2>> reduction_axis;
-
-  out = in.maximum(reduction_axis);
-
-  for (int i = 0; i < 72; ++i) {
-    for (int j = 0; j < 113; ++j) {
-      float expected = -1e10f;
-      for (int k = 0; k < 53; ++k) {
-        for (int l = 0; l < 97; ++l) {
-          expected = (std::max)(expected, in(i, k, l, j));
-        }
-      }
-      VERIFY_IS_EQUAL(out(i, j), expected);
-    }
-  }
-}
-
-template <typename ScalarType, int num_elements, int max_mean>
-void test_sum_accuracy() {
-  Tensor<double, 1> double_tensor(num_elements);
-  Tensor<ScalarType, 1> tensor(num_elements);
-  for (double prescribed_mean = 0; prescribed_mean <= max_mean;
-       prescribed_mean = numext::maxi(1.0, prescribed_mean * 3.99)) {
-    // FIXME: NormalRandomGenerator doesn't work in bfloat and half.
-    double_tensor.setRandom<Eigen::internal::NormalRandomGenerator<double>>();
-    double_tensor += double_tensor.constant(prescribed_mean);
-    tensor = double_tensor.cast<ScalarType>();
-
-    Tensor<ScalarType, 0> sum;
-    sum = tensor.sum();
-
-    // Compute the reference value in double precision.
-    double expected_sum = 0.0;
-    double abs_sum = 0.0;
-    for (int i = 0; i < num_elements; ++i) {
-      expected_sum += static_cast<double>(tensor(i));
-      abs_sum += static_cast<double>(numext::abs(tensor(i)));
-    }
-    // Test against probabilistic forward error bound. In reality, the error is much smaller
-    // when we use tree summation.
-    double err = Eigen::numext::abs(static_cast<double>(sum()) - expected_sum);
-    double tol = numext::sqrt(static_cast<double>(num_elements)) *
-                 static_cast<double>(NumTraits<ScalarType>::epsilon()) * abs_sum;
-    VERIFY_LE(err, tol);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_reduction) {
-  CALL_SUBTEST(test_trivial_reductions<ColMajor>());
-  CALL_SUBTEST(test_trivial_reductions<RowMajor>());
-  CALL_SUBTEST((test_simple_reductions<float, ColMajor>()));
-  CALL_SUBTEST((test_simple_reductions<float, RowMajor>()));
-  CALL_SUBTEST((test_simple_reductions<Eigen::half, ColMajor>()));
-  CALL_SUBTEST((test_simple_reductions<Eigen::bfloat16, ColMajor>()));
-  CALL_SUBTEST(test_reductions_in_expr<ColMajor>());
-  CALL_SUBTEST(test_reductions_in_expr<RowMajor>());
-  CALL_SUBTEST(test_full_reductions<ColMajor>());
-  CALL_SUBTEST(test_full_reductions<RowMajor>());
-  CALL_SUBTEST(test_user_defined_reductions<ColMajor>());
-  CALL_SUBTEST(test_user_defined_reductions<RowMajor>());
-  CALL_SUBTEST(test_tensor_maps<ColMajor>());
-  CALL_SUBTEST(test_tensor_maps<RowMajor>());
-  CALL_SUBTEST(test_static_dims<ColMajor>());
-  CALL_SUBTEST(test_static_dims<RowMajor>());
-  CALL_SUBTEST(test_innermost_last_dims<ColMajor>());
-  CALL_SUBTEST(test_innermost_last_dims<RowMajor>());
-  CALL_SUBTEST(test_innermost_first_dims<ColMajor>());
-  CALL_SUBTEST(test_innermost_first_dims<RowMajor>());
-  CALL_SUBTEST(test_reduce_middle_dims<ColMajor>());
-  CALL_SUBTEST(test_reduce_middle_dims<RowMajor>());
-  CALL_SUBTEST((test_sum_accuracy<float, 10 * 1024 * 1024, 8 * 1024>()));
-  CALL_SUBTEST((test_sum_accuracy<Eigen::bfloat16, 10 * 1024 * 1024, 8 * 1024>()));
-  // The range of half is limited to 65519 when using round-to-even,
-  // so we are severely limited in the size and mean of the tensors
-  // we can reduce without overflow.
-  CALL_SUBTEST((test_sum_accuracy<Eigen::half, 4 * 1024, 16>()));
-  CALL_SUBTEST((test_sum_accuracy<Eigen::half, 10 * 1024 * 1024, 0>()));
-}
diff --git a/unsupported/test/cxx11_tensor_reduction_gpu.cu b/unsupported/test/cxx11_tensor_reduction_gpu.cu
deleted file mode 100644
index cedd829..0000000
--- a/unsupported/test/cxx11_tensor_reduction_gpu.cu
+++ /dev/null
@@ -1,151 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-template <typename Type, int DataLayout>
-static void test_full_reductions() {
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  const int num_rows = internal::random<int>(1024, 5 * 1024);
-  const int num_cols = internal::random<int>(1024, 5 * 1024);
-
-  Tensor<Type, 2, DataLayout> in(num_rows, num_cols);
-  in.setRandom();
-
-  Tensor<Type, 0, DataLayout> full_redux;
-  full_redux = in.sum();
-
-  std::size_t in_bytes = in.size() * sizeof(Type);
-  std::size_t out_bytes = full_redux.size() * sizeof(Type);
-  Type* gpu_in_ptr = static_cast<Type*>(gpu_device.allocate(in_bytes));
-  Type* gpu_out_ptr = static_cast<Type*>(gpu_device.allocate(out_bytes));
-  gpu_device.memcpyHostToDevice(gpu_in_ptr, in.data(), in_bytes);
-
-  TensorMap<Tensor<Type, 2, DataLayout> > in_gpu(gpu_in_ptr, num_rows, num_cols);
-  TensorMap<Tensor<Type, 0, DataLayout> > out_gpu(gpu_out_ptr);
-
-  out_gpu.device(gpu_device) = in_gpu.sum();
-
-  Tensor<Type, 0, DataLayout> full_redux_gpu;
-  gpu_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_ptr, out_bytes);
-  gpu_device.synchronize();
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux(), full_redux_gpu());
-
-  gpu_device.deallocate(gpu_in_ptr);
-  gpu_device.deallocate(gpu_out_ptr);
-}
-
-template <typename Type, int DataLayout>
-static void test_first_dim_reductions() {
-  int dim_x = 33;
-  int dim_y = 1;
-  int dim_z = 128;
-
-  Tensor<Type, 3, DataLayout> in(dim_x, dim_y, dim_z);
-  in.setRandom();
-
-  Eigen::array<int, 1> red_axis;
-  red_axis[0] = 0;
-  Tensor<Type, 2, DataLayout> redux = in.sum(red_axis);
-
-  // Create device
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice dev(&stream);
-
-  // Create data(T)
-  Type* in_data = (Type*)dev.allocate(dim_x * dim_y * dim_z * sizeof(Type));
-  Type* out_data = (Type*)dev.allocate(dim_z * dim_y * sizeof(Type));
-  Eigen::TensorMap<Eigen::Tensor<Type, 3, DataLayout> > gpu_in(in_data, dim_x, dim_y, dim_z);
-  Eigen::TensorMap<Eigen::Tensor<Type, 2, DataLayout> > gpu_out(out_data, dim_y, dim_z);
-
-  // Perform operation
-  dev.memcpyHostToDevice(in_data, in.data(), in.size() * sizeof(Type));
-  gpu_out.device(dev) = gpu_in.sum(red_axis);
-  gpu_out.device(dev) += gpu_in.sum(red_axis);
-  Tensor<Type, 2, DataLayout> redux_gpu(dim_y, dim_z);
-  dev.memcpyDeviceToHost(redux_gpu.data(), out_data, gpu_out.size() * sizeof(Type));
-  dev.synchronize();
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (int i = 0; i < gpu_out.size(); ++i) {
-    VERIFY_IS_APPROX(2 * redux(i), redux_gpu(i));
-  }
-
-  dev.deallocate(in_data);
-  dev.deallocate(out_data);
-}
-
-template <typename Type, int DataLayout>
-static void test_last_dim_reductions() {
-  int dim_x = 128;
-  int dim_y = 1;
-  int dim_z = 33;
-
-  Tensor<Type, 3, DataLayout> in(dim_x, dim_y, dim_z);
-  in.setRandom();
-
-  Eigen::array<int, 1> red_axis;
-  red_axis[0] = 2;
-  Tensor<Type, 2, DataLayout> redux = in.sum(red_axis);
-
-  // Create device
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice dev(&stream);
-
-  // Create data
-  Type* in_data = (Type*)dev.allocate(dim_x * dim_y * dim_z * sizeof(Type));
-  Type* out_data = (Type*)dev.allocate(dim_x * dim_y * sizeof(Type));
-  Eigen::TensorMap<Eigen::Tensor<Type, 3, DataLayout> > gpu_in(in_data, dim_x, dim_y, dim_z);
-  Eigen::TensorMap<Eigen::Tensor<Type, 2, DataLayout> > gpu_out(out_data, dim_x, dim_y);
-
-  // Perform operation
-  dev.memcpyHostToDevice(in_data, in.data(), in.size() * sizeof(Type));
-  gpu_out.device(dev) = gpu_in.sum(red_axis);
-  gpu_out.device(dev) += gpu_in.sum(red_axis);
-  Tensor<Type, 2, DataLayout> redux_gpu(dim_x, dim_y);
-  dev.memcpyDeviceToHost(redux_gpu.data(), out_data, gpu_out.size() * sizeof(Type));
-  dev.synchronize();
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (int i = 0; i < gpu_out.size(); ++i) {
-    VERIFY_IS_APPROX(2 * redux(i), redux_gpu(i));
-  }
-
-  dev.deallocate(in_data);
-  dev.deallocate(out_data);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_reduction_gpu) {
-  CALL_SUBTEST_1((test_full_reductions<float, ColMajor>()));
-  CALL_SUBTEST_1((test_full_reductions<double, ColMajor>()));
-  CALL_SUBTEST_2((test_full_reductions<float, RowMajor>()));
-  CALL_SUBTEST_2((test_full_reductions<double, RowMajor>()));
-
-  CALL_SUBTEST_3((test_first_dim_reductions<float, ColMajor>()));
-  CALL_SUBTEST_3((test_first_dim_reductions<double, ColMajor>()));
-  CALL_SUBTEST_4((test_first_dim_reductions<float, RowMajor>()));
-  // Outer reductions of doubles aren't supported just yet.
-  //  CALL_SUBTEST_4((test_first_dim_reductions<double, RowMajor>()))
-
-  CALL_SUBTEST_5((test_last_dim_reductions<float, ColMajor>()));
-  // Outer reductions of doubles aren't supported just yet.
-  //  CALL_SUBTEST_5((test_last_dim_reductions<double, ColMajor>()));
-  CALL_SUBTEST_6((test_last_dim_reductions<float, RowMajor>()));
-  CALL_SUBTEST_6((test_last_dim_reductions<double, RowMajor>()));
-}
diff --git a/unsupported/test/cxx11_tensor_reduction_sycl.cpp b/unsupported/test/cxx11_tensor_reduction_sycl.cpp
deleted file mode 100644
index cf2a4b7..0000000
--- a/unsupported/test/cxx11_tensor_reduction_sycl.cpp
+++ /dev/null
@@ -1,857 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-
-#include <unsupported/Eigen/Tensor>
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device) {
-  const IndexType num_rows = 753;
-  const IndexType num_cols = 537;
-  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
-
-  array<IndexType, 2> outRange = {{1, 1}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> full_redux(outRange);
-  Tensor<DataType, 2, DataLayout, IndexType> full_redux_gpu(outRange);
-
-  in.setRandom();
-  auto dim = DSizes<IndexType, 2>(1, 1);
-  full_redux = in.sum().reshape(dim);
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      (DataType*)sycl_device.allocate(sizeof(DataType) * (full_redux_gpu.dimensions().TotalSize()));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, outRange);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.sum().reshape(dim);
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data,
-                                 (full_redux_gpu.dimensions().TotalSize()) * sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  std::cout << "SYCL FULL :" << full_redux_gpu(0, 0) << ", CPU FULL: " << full_redux(0, 0) << "\n";
-  VERIFY_IS_APPROX(full_redux_gpu(0, 0), full_redux(0, 0));
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_sum_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
-  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
-  const IndexType num_rows = 64;
-  const IndexType num_cols = 64;
-  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
-  const IndexType n_elems = internal::array_prod(tensor_range);
-
-  data_tensor in(tensor_range);
-  scalar_tensor full_redux;
-  scalar_tensor full_redux_gpu;
-
-  in.setRandom();
-  array<IndexType, 2> tensor_offset_range(tensor_range);
-  tensor_offset_range[0] -= 1;
-
-  const IndexType offset = 64;
-  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
-  full_redux = in_offset.sum();
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
-  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.sum();
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_max_sycl(const Eigen::SyclDevice& sycl_device) {
-  const IndexType num_rows = 4096;
-  const IndexType num_cols = 4096;
-  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 0, DataLayout, IndexType> full_redux;
-  Tensor<DataType, 0, DataLayout, IndexType> full_redux_gpu;
-
-  in.setRandom();
-
-  full_redux = in.maximum();
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data = (DataType*)sycl_device.allocate(sizeof(DataType));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 0, DataLayout, IndexType>> out_gpu(gpu_out_data);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.maximum();
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_max_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
-  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
-  const IndexType num_rows = 64;
-  const IndexType num_cols = 64;
-  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
-  const IndexType n_elems = internal::array_prod(tensor_range);
-
-  data_tensor in(tensor_range);
-  scalar_tensor full_redux;
-  scalar_tensor full_redux_gpu;
-
-  in.setRandom();
-  array<IndexType, 2> tensor_offset_range(tensor_range);
-  tensor_offset_range[0] -= 1;
-  // Set the initial value to be the max.
-  // As we don't include this in the reduction the result should not be 2.
-  in(0) = static_cast<DataType>(2);
-
-  const IndexType offset = 64;
-  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
-  full_redux = in_offset.maximum();
-  VERIFY_IS_NOT_EQUAL(full_redux(), in(0));
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
-  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.maximum();
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
-  const IndexType num_rows = 4096;
-  const IndexType num_cols = 4096;
-  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
-  array<IndexType, 1> argRange = {{num_cols}};
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 0;
-  //  red_axis[1]=1;
-  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> in_arg1(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> in_arg2(tensorRange);
-  Tensor<bool, 1, DataLayout, IndexType> out_arg_cpu(argRange);
-  Tensor<bool, 1, DataLayout, IndexType> out_arg_gpu(argRange);
-  Tensor<bool, 1, DataLayout, IndexType> out_arg_gpu_helper(argRange);
-  Tensor<DataType, 0, DataLayout, IndexType> full_redux;
-  Tensor<DataType, 0, DataLayout, IndexType> full_redux_gpu;
-
-  in.setRandom();
-  in_arg1.setRandom();
-  in_arg2.setRandom();
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_in_arg1_data =
-      static_cast<DataType*>(sycl_device.allocate(in_arg1.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_in_arg2_data =
-      static_cast<DataType*>(sycl_device.allocate(in_arg2.dimensions().TotalSize() * sizeof(DataType)));
-  bool* gpu_out_arg__gpu_helper_data =
-      static_cast<bool*>(sycl_device.allocate(out_arg_gpu.dimensions().TotalSize() * sizeof(DataType)));
-  bool* gpu_out_arg_data =
-      static_cast<bool*>(sycl_device.allocate(out_arg_gpu.dimensions().TotalSize() * sizeof(DataType)));
-
-  DataType* gpu_out_data = (DataType*)sycl_device.allocate(sizeof(DataType));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_Arg1_gpu(gpu_in_arg1_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_Arg2_gpu(gpu_in_arg2_data, tensorRange);
-  TensorMap<Tensor<bool, 1, DataLayout, IndexType>> out_Argout_gpu(gpu_out_arg_data, argRange);
-  TensorMap<Tensor<bool, 1, DataLayout, IndexType>> out_Argout_gpu_helper(gpu_out_arg__gpu_helper_data, argRange);
-  TensorMap<Tensor<DataType, 0, DataLayout, IndexType>> out_gpu(gpu_out_data);
-
-  // CPU VERSION
-  out_arg_cpu =
-      (in_arg1.argmax(1) == in_arg2.argmax(1)).select(out_arg_cpu.constant(true), out_arg_cpu.constant(false));
-  full_redux = (out_arg_cpu.template cast<float>()).reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
-
-  // GPU VERSION
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in_arg1_data, in_arg1.data(),
-                                 (in_arg1.dimensions().TotalSize()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_in_arg2_data, in_arg2.data(),
-                                 (in_arg2.dimensions().TotalSize()) * sizeof(DataType));
-  out_Argout_gpu_helper.device(sycl_device) = (in_Arg1_gpu.argmax(1) == in_Arg2_gpu.argmax(1));
-  out_Argout_gpu.device(sycl_device) =
-      (out_Argout_gpu_helper).select(out_Argout_gpu.constant(true), out_Argout_gpu.constant(false));
-  out_gpu.device(sycl_device) =
-      (out_Argout_gpu.template cast<float>()).reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  std::cout << "SYCL : " << full_redux_gpu() << " , CPU : " << full_redux() << '\n';
-  VERIFY_IS_EQUAL(full_redux_gpu(), full_redux());
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_in_arg1_data);
-  sycl_device.deallocate(gpu_in_arg2_data);
-  sycl_device.deallocate(gpu_out_arg__gpu_helper_data);
-  sycl_device.deallocate(gpu_out_arg_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_mean_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
-  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
-  const IndexType num_rows = 64;
-  const IndexType num_cols = 64;
-  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
-  const IndexType n_elems = internal::array_prod(tensor_range);
-
-  data_tensor in(tensor_range);
-  scalar_tensor full_redux;
-  scalar_tensor full_redux_gpu;
-
-  in.setRandom();
-  array<IndexType, 2> tensor_offset_range(tensor_range);
-  tensor_offset_range[0] -= 1;
-
-  const IndexType offset = 64;
-  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
-  full_redux = in_offset.mean();
-  VERIFY_IS_NOT_EQUAL(full_redux(), in(0));
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
-  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.mean();
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_mean_with_odd_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  // This is a particular case which illustrates a possible problem when the
-  // number of local threads in a workgroup is even, but is not a power of two.
-  using data_tensor = Tensor<DataType, 1, DataLayout, IndexType>;
-  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
-  // 2177 = (17 * 128) + 1 gives rise to 18 local threads.
-  // 8708 = 4 * 2177 = 4 * (17 * 128) + 4 uses 18 vectorised local threads.
-  const IndexType n_elems = 8707;
-  array<IndexType, 1> tensor_range = {{n_elems}};
-
-  data_tensor in(tensor_range);
-  DataType full_redux;
-  DataType full_redux_gpu;
-  TensorMap<scalar_tensor> red_cpu(&full_redux);
-  TensorMap<scalar_tensor> red_gpu(&full_redux_gpu);
-
-  const DataType const_val = static_cast<DataType>(0.6391);
-  in = in.constant(const_val);
-
-  Eigen::IndexList<Eigen::type2index<0>> red_axis;
-  red_cpu = in.reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
-  VERIFY_IS_APPROX(const_val, red_cpu());
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data, tensor_range);
-  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.reduce(red_axis, Eigen::internal::MeanReducer<DataType>());
-  sycl_device.memcpyDeviceToHost(red_gpu.data(), gpu_out_data, sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux_gpu, full_redux);
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_min_sycl(const Eigen::SyclDevice& sycl_device) {
-  const IndexType num_rows = 876;
-  const IndexType num_cols = 953;
-  array<IndexType, 2> tensorRange = {{num_rows, num_cols}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 0, DataLayout, IndexType> full_redux;
-  Tensor<DataType, 0, DataLayout, IndexType> full_redux_gpu;
-
-  in.setRandom();
-
-  full_redux = in.minimum();
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data = (DataType*)sycl_device.allocate(sizeof(DataType));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 0, DataLayout, IndexType>> out_gpu(gpu_out_data);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.minimum();
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_full_reductions_min_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
-  using scalar_tensor = Tensor<DataType, 0, DataLayout, IndexType>;
-  const IndexType num_rows = 64;
-  const IndexType num_cols = 64;
-  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
-  const IndexType n_elems = internal::array_prod(tensor_range);
-
-  data_tensor in(tensor_range);
-  scalar_tensor full_redux;
-  scalar_tensor full_redux_gpu;
-
-  in.setRandom();
-  array<IndexType, 2> tensor_offset_range(tensor_range);
-  tensor_offset_range[0] -= 1;
-  // Set the initial value to be the min.
-  // As we don't include this in the reduction the result should not be -2.
-  in(0) = static_cast<DataType>(-2);
-
-  const IndexType offset = 64;
-  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
-  full_redux = in_offset.minimum();
-  VERIFY_IS_NOT_EQUAL(full_redux(), in(0));
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
-  TensorMap<scalar_tensor> out_gpu(gpu_out_data);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.minimum();
-  sycl_device.memcpyDeviceToHost(full_redux_gpu.data(), gpu_out_data, sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  VERIFY_IS_APPROX(full_redux_gpu(), full_redux());
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_first_dim_reductions_max_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType dim_x = 145;
-  IndexType dim_y = 1;
-  IndexType dim_z = 67;
-
-  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 0;
-  array<IndexType, 2> reduced_tensorRange = {{dim_y, dim_z}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
-
-  in.setRandom();
-
-  redux = in.maximum(red_axis);
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.maximum(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
-    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_first_dim_reductions_max_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
-  using reduced_tensor = Tensor<DataType, 1, DataLayout, IndexType>;
-
-  const IndexType num_rows = 64;
-  const IndexType num_cols = 64;
-  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
-  array<IndexType, 1> reduced_range = {{num_cols}};
-  const IndexType n_elems = internal::array_prod(tensor_range);
-  const IndexType n_reduced = num_cols;
-
-  data_tensor in(tensor_range);
-  reduced_tensor redux;
-  reduced_tensor redux_gpu(reduced_range);
-
-  in.setRandom();
-  array<IndexType, 2> tensor_offset_range(tensor_range);
-  tensor_offset_range[0] -= 1;
-  // Set maximum value outside of the considered range.
-  for (IndexType i = 0; i < n_reduced; i++) {
-    in(i) = static_cast<DataType>(2);
-  }
-
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 0;
-
-  const IndexType offset = 64;
-  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
-  redux = in_offset.maximum(red_axis);
-  for (IndexType i = 0; i < n_reduced; i++) {
-    VERIFY_IS_NOT_EQUAL(redux(i), in(i));
-  }
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(n_reduced * sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
-  TensorMap<reduced_tensor> out_gpu(gpu_out_data, reduced_range);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.maximum(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, n_reduced * sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType i = 0; i < n_reduced; i++) {
-    VERIFY_IS_APPROX(redux_gpu(i), redux(i));
-  }
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_last_dim_reductions_max_with_offset_sycl(const Eigen::SyclDevice& sycl_device) {
-  using data_tensor = Tensor<DataType, 2, DataLayout, IndexType>;
-  using reduced_tensor = Tensor<DataType, 1, DataLayout, IndexType>;
-
-  const IndexType num_rows = 64;
-  const IndexType num_cols = 64;
-  array<IndexType, 2> tensor_range = {{num_rows, num_cols}};
-  array<IndexType, 1> full_reduced_range = {{num_rows}};
-  array<IndexType, 1> reduced_range = {{num_rows - 1}};
-  const IndexType n_elems = internal::array_prod(tensor_range);
-  const IndexType n_reduced = reduced_range[0];
-
-  data_tensor in(tensor_range);
-  reduced_tensor redux(full_reduced_range);
-  reduced_tensor redux_gpu(reduced_range);
-
-  in.setRandom();
-  redux.setZero();
-  array<IndexType, 2> tensor_offset_range(tensor_range);
-  tensor_offset_range[0] -= 1;
-  // Set maximum value outside of the considered range.
-  for (IndexType i = 0; i < n_reduced; i++) {
-    in(i) = static_cast<DataType>(2);
-  }
-
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 1;
-
-  const IndexType offset = 64;
-  // Introduce an offset in both the input and the output.
-  TensorMap<data_tensor> in_offset(in.data() + offset, tensor_offset_range);
-  TensorMap<reduced_tensor> red_offset(redux.data() + 1, reduced_range);
-  red_offset = in_offset.maximum(red_axis);
-
-  // Check that the first value hasn't been changed and that the reduced values
-  // are not equal to the previously set maximum in the input outside the range.
-  VERIFY_IS_EQUAL(redux(0), static_cast<DataType>(0));
-  for (IndexType i = 0; i < n_reduced; i++) {
-    VERIFY_IS_NOT_EQUAL(red_offset(i), in(i));
-  }
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(n_elems * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate((n_reduced + 1) * sizeof(DataType)));
-
-  TensorMap<data_tensor> in_gpu(gpu_in_data + offset, tensor_offset_range);
-  TensorMap<reduced_tensor> out_gpu(gpu_out_data + 1, reduced_range);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), n_elems * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.maximum(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), out_gpu.data(), n_reduced * sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType i = 0; i < n_reduced; i++) {
-    VERIFY_IS_APPROX(redux_gpu(i), red_offset(i));
-  }
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_first_dim_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device, IndexType dim_x, IndexType dim_y) {
-  array<IndexType, 2> tensorRange = {{dim_x, dim_y}};
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 0;
-  array<IndexType, 1> reduced_tensorRange = {{dim_y}};
-
-  Tensor<DataType, 2, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 1, DataLayout, IndexType> redux(reduced_tensorRange);
-  Tensor<DataType, 1, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
-
-  in.setRandom();
-  redux = in.sum(red_axis);
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.sum(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType i = 0; i < redux.size(); i++) {
-    VERIFY_IS_APPROX(redux_gpu.data()[i], redux.data()[i]);
-  }
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_first_dim_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType dim_x = 145;
-  IndexType dim_y = 1;
-  IndexType dim_z = 67;
-
-  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 0;
-  array<IndexType, 2> reduced_tensorRange = {{dim_y, dim_z}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
-
-  in.setRandom();
-
-  redux = in.mean(red_axis);
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.mean(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
-
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
-    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_last_dim_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType dim_x = 64;
-  IndexType dim_y = 1;
-  IndexType dim_z = 32;
-
-  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 2;
-  array<IndexType, 2> reduced_tensorRange = {{dim_x, dim_y}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
-
-  in.setRandom();
-
-  redux = in.mean(red_axis);
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.mean(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
-    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_last_dim_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType dim_x = 64;
-  IndexType dim_y = 1;
-  IndexType dim_z = 32;
-
-  array<IndexType, 3> tensorRange = {{dim_x, dim_y, dim_z}};
-  Eigen::array<IndexType, 1> red_axis;
-  red_axis[0] = 2;
-  array<IndexType, 2> reduced_tensorRange = {{dim_x, dim_y}};
-
-  Tensor<DataType, 3, DataLayout, IndexType> in(tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux(reduced_tensorRange);
-  Tensor<DataType, 2, DataLayout, IndexType> redux_gpu(reduced_tensorRange);
-
-  in.setRandom();
-
-  redux = in.sum(red_axis);
-
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 2, DataLayout, IndexType>> out_gpu(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.sum(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu.data(), gpu_out_data, redux_gpu.dimensions().TotalSize() * sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType j = 0; j < reduced_tensorRange[0]; j++)
-    for (IndexType k = 0; k < reduced_tensorRange[1]; k++) VERIFY_IS_APPROX(redux_gpu(j, k), redux(j, k));
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_last_reductions_sum_sycl(const Eigen::SyclDevice& sycl_device) {
-  auto tensorRange = Sizes<64, 32>(64, 32);
-  // auto red_axis =  Sizes<0,1>(0,1);
-  Eigen::IndexList<Eigen::type2index<1>> red_axis;
-  auto reduced_tensorRange = Sizes<64>(64);
-  TensorFixedSize<DataType, Sizes<64, 32>, DataLayout> in_fix;
-  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_fix;
-  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_gpu_fix;
-
-  in_fix.setRandom();
-
-  redux_fix = in_fix.sum(red_axis);
-
-  DataType* gpu_in_data =
-      static_cast<DataType*>(sycl_device.allocate(in_fix.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<TensorFixedSize<DataType, Sizes<64, 32>, DataLayout>> in_gpu_fix(gpu_in_data, tensorRange);
-  TensorMap<TensorFixedSize<DataType, Sizes<64>, DataLayout>> out_gpu_fix(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in_fix.data(), (in_fix.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu_fix.device(sycl_device) = in_gpu_fix.sum(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu_fix.data(), gpu_out_data,
-                                 redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType j = 0; j < reduced_tensorRange[0]; j++) {
-    VERIFY_IS_APPROX(redux_gpu_fix(j), redux_fix(j));
-  }
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_last_reductions_mean_sycl(const Eigen::SyclDevice& sycl_device) {
-  auto tensorRange = Sizes<64, 32>(64, 32);
-  Eigen::IndexList<Eigen::type2index<1>> red_axis;
-  auto reduced_tensorRange = Sizes<64>(64);
-  TensorFixedSize<DataType, Sizes<64, 32>, DataLayout> in_fix;
-  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_fix;
-  TensorFixedSize<DataType, Sizes<64>, DataLayout> redux_gpu_fix;
-
-  in_fix.setRandom();
-  redux_fix = in_fix.mean(red_axis);
-
-  DataType* gpu_in_data =
-      static_cast<DataType*>(sycl_device.allocate(in_fix.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<TensorFixedSize<DataType, Sizes<64, 32>, DataLayout>> in_gpu_fix(gpu_in_data, tensorRange);
-  TensorMap<TensorFixedSize<DataType, Sizes<64>, DataLayout>> out_gpu_fix(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in_fix.data(), (in_fix.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu_fix.device(sycl_device) = in_gpu_fix.mean(red_axis);
-  sycl_device.memcpyDeviceToHost(redux_gpu_fix.data(), gpu_out_data,
-                                 redux_gpu_fix.dimensions().TotalSize() * sizeof(DataType));
-  sycl_device.synchronize();
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType j = 0; j < reduced_tensorRange[0]; j++) {
-    VERIFY_IS_APPROX(redux_gpu_fix(j), redux_fix(j));
-  }
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-// SYCL supports a generic case of reduction where the accumulator is a
-// different type than the input data This is an example on how to get if a
-// Tensor contains nan and/or inf in one reduction
-template <typename InT, typename OutT>
-struct CustomReducer {
-  static const bool PacketAccess = false;
-  static const bool IsStateful = false;
-
-  static constexpr OutT InfBit = 1;
-  static constexpr OutT NanBit = 2;
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const InT x, OutT* accum) const {
-    if (Eigen::numext::isinf(x))
-      *accum |= InfBit;
-    else if (Eigen::numext::isnan(x))
-      *accum |= NanBit;
-  }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const OutT x, OutT* accum) const { *accum |= x; }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE OutT initialize() const { return OutT(0); }
-
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE OutT finalize(const OutT accum) const { return accum; }
-};
-
-template <typename DataType, typename AccumType, int DataLayout, typename IndexType>
-static void test_full_reductions_custom_sycl(const Eigen::SyclDevice& sycl_device) {
-  constexpr IndexType InSize = 64;
-  auto tensorRange = Sizes<InSize>(InSize);
-  Eigen::IndexList<Eigen::type2index<0>> dims;
-  auto reduced_tensorRange = Sizes<>();
-  TensorFixedSize<DataType, Sizes<InSize>, DataLayout> in_fix;
-  TensorFixedSize<AccumType, Sizes<>, DataLayout> redux_gpu_fix;
-
-  CustomReducer<DataType, AccumType> reducer;
-
-  in_fix.setRandom();
-
-  size_t in_size_bytes = in_fix.dimensions().TotalSize() * sizeof(DataType);
-  DataType* gpu_in_data = static_cast<DataType*>(sycl_device.allocate(in_size_bytes));
-  AccumType* gpu_out_data = static_cast<AccumType*>(sycl_device.allocate(sizeof(AccumType)));
-
-  TensorMap<TensorFixedSize<DataType, Sizes<InSize>, DataLayout>> in_gpu_fix(gpu_in_data, tensorRange);
-  TensorMap<TensorFixedSize<AccumType, Sizes<>, DataLayout>> out_gpu_fix(gpu_out_data, reduced_tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, in_fix.data(), in_size_bytes);
-  out_gpu_fix.device(sycl_device) = in_gpu_fix.reduce(dims, reducer);
-  sycl_device.memcpyDeviceToHost(redux_gpu_fix.data(), gpu_out_data, sizeof(AccumType));
-  VERIFY_IS_EQUAL(redux_gpu_fix(0), AccumType(0));
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, typename Dev>
-void sycl_reduction_test_full_per_device(const Dev& sycl_device) {
-  test_full_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_sum_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_min_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_min_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_max_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_max_sycl<DataType, RowMajor, int64_t>(sycl_device);
-
-  test_full_reductions_mean_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_mean_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_custom_sycl<DataType, int, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_custom_sycl<DataType, int, ColMajor, int64_t>(sycl_device);
-  sycl_device.synchronize();
-}
-
-template <typename DataType, typename Dev>
-void sycl_reduction_full_offset_per_device(const Dev& sycl_device) {
-  test_full_reductions_sum_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_sum_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_min_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_min_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_max_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_max_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_mean_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_full_reductions_mean_with_offset_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_full_reductions_mean_with_odd_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  sycl_device.synchronize();
-}
-
-template <typename DataType, typename Dev>
-void sycl_reduction_test_first_dim_per_device(const Dev& sycl_device) {
-  test_first_dim_reductions_sum_sycl<DataType, ColMajor, int64_t>(sycl_device, 4197, 4097);
-  test_first_dim_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device, 4197, 4097);
-  test_first_dim_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device, 129, 8);
-  test_first_dim_reductions_max_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_first_dim_reductions_max_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  sycl_device.synchronize();
-}
-
-template <typename DataType, typename Dev>
-void sycl_reduction_test_last_dim_per_device(const Dev& sycl_device) {
-  test_last_dim_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_last_dim_reductions_max_with_offset_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_last_reductions_sum_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_last_reductions_sum_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_last_reductions_mean_sycl<DataType, ColMajor, int64_t>(sycl_device);
-  test_last_reductions_mean_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  sycl_device.synchronize();
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_reduction_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    std::cout << "Running on " << device.template get_info<cl::sycl::info::device::name>() << std::endl;
-    QueueInterface queueInterface(device);
-    auto sycl_device = Eigen::SyclDevice(&queueInterface);
-    CALL_SUBTEST_1(sycl_reduction_test_full_per_device<float>(sycl_device));
-    CALL_SUBTEST_2(sycl_reduction_full_offset_per_device<float>(sycl_device));
-    CALL_SUBTEST_3(sycl_reduction_test_first_dim_per_device<float>(sycl_device));
-    CALL_SUBTEST_4(sycl_reduction_test_last_dim_per_device<float>(sycl_device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_ref.cpp b/unsupported/test/cxx11_tensor_ref.cpp
deleted file mode 100644
index 7696558..0000000
--- a/unsupported/test/cxx11_tensor_ref.cpp
+++ /dev/null
@@ -1,243 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_simple_lvalue_ref() {
-  Tensor<int, 1> input(6);
-  input.setRandom();
-
-  TensorRef<Tensor<int, 1>> ref3(input);
-  TensorRef<Tensor<int, 1>> ref4 = input;
-
-  VERIFY_IS_EQUAL(ref3.data(), input.data());
-  VERIFY_IS_EQUAL(ref4.data(), input.data());
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(ref3(i), input(i));
-    VERIFY_IS_EQUAL(ref4(i), input(i));
-  }
-
-  for (int i = 0; i < 6; ++i) {
-    ref3.coeffRef(i) = i;
-  }
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(input(i), i);
-  }
-  for (int i = 0; i < 6; ++i) {
-    ref4.coeffRef(i) = -i * 2;
-  }
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(input(i), -i * 2);
-  }
-}
-
-static void test_simple_rvalue_ref() {
-  Tensor<int, 1> input1(6);
-  input1.setRandom();
-  Tensor<int, 1> input2(6);
-  input2.setRandom();
-
-  TensorRef<const Tensor<int, 1>> ref3(input1 + input2);
-  TensorRef<const Tensor<int, 1>> ref4 = input1 + input2;
-
-  VERIFY_IS_NOT_EQUAL(ref3.data(), input1.data());
-  VERIFY_IS_NOT_EQUAL(ref4.data(), input1.data());
-  VERIFY_IS_NOT_EQUAL(ref3.data(), input2.data());
-  VERIFY_IS_NOT_EQUAL(ref4.data(), input2.data());
-
-  for (int i = 0; i < 6; ++i) {
-    VERIFY_IS_EQUAL(ref3(i), input1(i) + input2(i));
-    VERIFY_IS_EQUAL(ref4(i), input1(i) + input2(i));
-  }
-}
-
-static void test_multiple_dims() {
-  Tensor<float, 3> input(3, 5, 7);
-  input.setRandom();
-
-  TensorRef<Tensor<float, 3>> ref(input);
-  VERIFY_IS_EQUAL(ref.data(), input.data());
-  VERIFY_IS_EQUAL(ref.dimension(0), 3);
-  VERIFY_IS_EQUAL(ref.dimension(1), 5);
-  VERIFY_IS_EQUAL(ref.dimension(2), 7);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(ref(i, j, k), input(i, j, k));
-      }
-    }
-  }
-}
-
-static void test_slice() {
-  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-
-  Eigen::DSizes<ptrdiff_t, 5> indices(1, 2, 3, 4, 5);
-  Eigen::DSizes<ptrdiff_t, 5> sizes(1, 1, 1, 1, 1);
-  TensorRef<Tensor<float, 5>> slice = tensor.slice(indices, sizes);
-  VERIFY_IS_EQUAL(slice(0, 0, 0, 0, 0), tensor(1, 2, 3, 4, 5));
-
-  Eigen::DSizes<ptrdiff_t, 5> indices2(1, 1, 3, 4, 5);
-  Eigen::DSizes<ptrdiff_t, 5> sizes2(1, 1, 2, 2, 3);
-  slice = tensor.slice(indices2, sizes2);
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 2; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        VERIFY_IS_EQUAL(slice(0, 0, i, j, k), tensor(1, 1, 3 + i, 4 + j, 5 + k));
-      }
-    }
-  }
-
-  Eigen::DSizes<ptrdiff_t, 5> indices3(0, 0, 0, 0, 0);
-  Eigen::DSizes<ptrdiff_t, 5> sizes3(2, 3, 1, 1, 1);
-  slice = tensor.slice(indices3, sizes3);
-  VERIFY_IS_EQUAL(slice.data(), tensor.data());
-}
-
-static void test_ref_of_trace() {
-  Tensor<int, 2> input(6, 6);
-  input.setRandom();
-  int trace = 0;
-  for (int i = 0; i < 6; ++i) {
-    trace += input(i, i);
-  }
-  TensorRef<const Tensor<int, 0>> ref(input.trace());
-  VERIFY_IS_EQUAL(ref.coeff(0), trace);
-}
-
-static void test_ref_of_ref() {
-  Tensor<float, 3> input(3, 5, 7);
-  input.setRandom();
-
-  TensorRef<Tensor<float, 3>> ref(input);
-  TensorRef<Tensor<float, 3>> ref_of_ref(ref);
-  TensorRef<Tensor<float, 3>> ref_of_ref2;
-  ref_of_ref2 = ref;
-
-  VERIFY_IS_EQUAL(ref_of_ref.data(), input.data());
-  VERIFY_IS_EQUAL(ref_of_ref.dimension(0), 3);
-  VERIFY_IS_EQUAL(ref_of_ref.dimension(1), 5);
-  VERIFY_IS_EQUAL(ref_of_ref.dimension(2), 7);
-
-  VERIFY_IS_EQUAL(ref_of_ref2.data(), input.data());
-  VERIFY_IS_EQUAL(ref_of_ref2.dimension(0), 3);
-  VERIFY_IS_EQUAL(ref_of_ref2.dimension(1), 5);
-  VERIFY_IS_EQUAL(ref_of_ref2.dimension(2), 7);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(ref_of_ref(i, j, k), input(i, j, k));
-        VERIFY_IS_EQUAL(ref_of_ref2(i, j, k), input(i, j, k));
-      }
-    }
-  }
-}
-
-static void test_ref_in_expr() {
-  Tensor<float, 3> input(3, 5, 7);
-  input.setRandom();
-  TensorRef<Tensor<float, 3>> input_ref(input);
-
-  Tensor<float, 3> result(3, 5, 7);
-  result.setRandom();
-  TensorRef<const Tensor<float, 3>> result_ref(result);
-
-  Tensor<float, 3> bias(3, 5, 7);
-  bias.setRandom();
-
-  result_ref = input_ref + bias;
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(result_ref(i, j, k), input(i, j, k) + bias(i, j, k));
-        VERIFY_IS_NOT_EQUAL(result(i, j, k), input(i, j, k) + bias(i, j, k));
-      }
-    }
-  }
-
-  result = result_ref;
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_EQUAL(result(i, j, k), input(i, j, k) + bias(i, j, k));
-      }
-    }
-  }
-}
-
-static void test_coeff_ref() {
-  Tensor<float, 5> tensor(2, 3, 5, 7, 11);
-  tensor.setRandom();
-  Tensor<float, 5> original = tensor;
-
-  TensorRef<Tensor<float, 4>> slice = tensor.chip(7, 4);
-  slice.coeffRef(0, 0, 0, 0) = 1.0f;
-  slice.coeffRef(1, 0, 0, 0) += 2.0f;
-
-  VERIFY_IS_EQUAL(tensor(0, 0, 0, 0, 7), 1.0f);
-  VERIFY_IS_EQUAL(tensor(1, 0, 0, 0, 7), original(1, 0, 0, 0, 7) + 2.0f);
-}
-
-static void test_nested_ops_with_ref() {
-  Tensor<float, 4> t(2, 3, 5, 7);
-  t.setRandom();
-  TensorMap<Tensor<const float, 4>> m(t.data(), 2, 3, 5, 7);
-  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> paddings;
-  paddings[0] = std::make_pair(0, 0);
-  paddings[1] = std::make_pair(2, 1);
-  paddings[2] = std::make_pair(3, 4);
-  paddings[3] = std::make_pair(0, 0);
-  DSizes<Eigen::DenseIndex, 4> shuffle_dims(0, 1, 2, 3);
-  TensorRef<const Tensor<const float, 4>> ref(m.pad(paddings));
-  array<std::pair<ptrdiff_t, ptrdiff_t>, 4> trivial;
-  trivial[0] = std::make_pair(0, 0);
-  trivial[1] = std::make_pair(0, 0);
-  trivial[2] = std::make_pair(0, 0);
-  trivial[3] = std::make_pair(0, 0);
-  Tensor<float, 4> padded = ref.shuffle(shuffle_dims).pad(trivial);
-  VERIFY_IS_EQUAL(padded.dimension(0), 2 + 0);
-  VERIFY_IS_EQUAL(padded.dimension(1), 3 + 3);
-  VERIFY_IS_EQUAL(padded.dimension(2), 5 + 7);
-  VERIFY_IS_EQUAL(padded.dimension(3), 7 + 0);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 6; ++j) {
-      for (int k = 0; k < 12; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          if (j >= 2 && j < 5 && k >= 3 && k < 8) {
-            VERIFY_IS_EQUAL(padded(i, j, k, l), t(i, j - 2, k - 3, l));
-          } else {
-            VERIFY_IS_EQUAL(padded(i, j, k, l), 0.0f);
-          }
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_ref) {
-  CALL_SUBTEST(test_simple_lvalue_ref());
-  CALL_SUBTEST(test_simple_rvalue_ref());
-  CALL_SUBTEST(test_multiple_dims());
-  CALL_SUBTEST(test_slice());
-  CALL_SUBTEST(test_ref_of_trace());
-  CALL_SUBTEST(test_ref_of_ref());
-  CALL_SUBTEST(test_ref_in_expr());
-  CALL_SUBTEST(test_coeff_ref());
-  CALL_SUBTEST(test_nested_ops_with_ref());
-}
diff --git a/unsupported/test/cxx11_tensor_reverse.cpp b/unsupported/test/cxx11_tensor_reverse.cpp
deleted file mode 100644
index 611cfc8..0000000
--- a/unsupported/test/cxx11_tensor_reverse.cpp
+++ /dev/null
@@ -1,179 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Navdeep Jaitly <ndjaitly@google.com and
-//                    Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_reverse() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<bool, 4> dim_rev;
-  dim_rev[0] = false;
-  dim_rev[1] = true;
-  dim_rev[2] = true;
-  dim_rev[3] = false;
-
-  Tensor<float, 4, DataLayout> reversed_tensor;
-  reversed_tensor = tensor.reverse(dim_rev);
-
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(0), 2);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(1), 3);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(2), 5);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(i, 2 - j, 4 - k, l));
-        }
-      }
-    }
-  }
-
-  dim_rev[0] = true;
-  dim_rev[1] = false;
-  dim_rev[2] = false;
-  dim_rev[3] = false;
-
-  reversed_tensor = tensor.reverse(dim_rev);
-
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(0), 2);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(1), 3);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(2), 5);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dim_rev[0] = true;
-  dim_rev[1] = false;
-  dim_rev[2] = false;
-  dim_rev[3] = true;
-
-  reversed_tensor = tensor.reverse(dim_rev);
-
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(0), 2);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(1), 3);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(2), 5);
-  VERIFY_IS_EQUAL(reversed_tensor.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, 6 - l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_expr_reverse(bool LValue) {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<bool, 4> dim_rev;
-  dim_rev[0] = false;
-  dim_rev[1] = true;
-  dim_rev[2] = false;
-  dim_rev[3] = true;
-
-  Tensor<float, 4, DataLayout> expected(2, 3, 5, 7);
-  if (LValue) {
-    expected.reverse(dim_rev) = tensor;
-  } else {
-    expected = tensor.reverse(dim_rev);
-  }
-
-  Tensor<float, 4, DataLayout> result(2, 3, 5, 7);
-
-  array<ptrdiff_t, 4> src_slice_dim;
-  src_slice_dim[0] = 2;
-  src_slice_dim[1] = 3;
-  src_slice_dim[2] = 1;
-  src_slice_dim[3] = 7;
-  array<ptrdiff_t, 4> src_slice_start;
-  src_slice_start[0] = 0;
-  src_slice_start[1] = 0;
-  src_slice_start[2] = 0;
-  src_slice_start[3] = 0;
-  array<ptrdiff_t, 4> dst_slice_dim = src_slice_dim;
-  array<ptrdiff_t, 4> dst_slice_start = src_slice_start;
-
-  for (int i = 0; i < 5; ++i) {
-    if (LValue) {
-      result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev) = tensor.slice(src_slice_start, src_slice_dim);
-    } else {
-      result.slice(dst_slice_start, dst_slice_dim) = tensor.slice(src_slice_start, src_slice_dim).reverse(dim_rev);
-    }
-    src_slice_start[2] += 1;
-    dst_slice_start[2] += 1;
-  }
-
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 3);
-  VERIFY_IS_EQUAL(result.dimension(2), 5);
-  VERIFY_IS_EQUAL(result.dimension(3), 7);
-
-  for (int i = 0; i < expected.dimension(0); ++i) {
-    for (int j = 0; j < expected.dimension(1); ++j) {
-      for (int k = 0; k < expected.dimension(2); ++k) {
-        for (int l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dst_slice_start[2] = 0;
-  result.setRandom();
-  for (int i = 0; i < 5; ++i) {
-    if (LValue) {
-      result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev) = tensor.slice(dst_slice_start, dst_slice_dim);
-    } else {
-      result.slice(dst_slice_start, dst_slice_dim) = tensor.reverse(dim_rev).slice(dst_slice_start, dst_slice_dim);
-    }
-    dst_slice_start[2] += 1;
-  }
-
-  for (int i = 0; i < expected.dimension(0); ++i) {
-    for (int j = 0; j < expected.dimension(1); ++j) {
-      for (int k = 0; k < expected.dimension(2); ++k) {
-        for (int l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_reverse) {
-  CALL_SUBTEST(test_simple_reverse<ColMajor>());
-  CALL_SUBTEST(test_simple_reverse<RowMajor>());
-  CALL_SUBTEST(test_expr_reverse<ColMajor>(true));
-  CALL_SUBTEST(test_expr_reverse<RowMajor>(true));
-  CALL_SUBTEST(test_expr_reverse<ColMajor>(false));
-  CALL_SUBTEST(test_expr_reverse<RowMajor>(false));
-}
diff --git a/unsupported/test/cxx11_tensor_reverse_sycl.cpp b/unsupported/test/cxx11_tensor_reverse_sycl.cpp
deleted file mode 100644
index f2c9824..0000000
--- a/unsupported/test/cxx11_tensor_reverse_sycl.cpp
+++ /dev/null
@@ -1,232 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_reverse(const Eigen::SyclDevice& sycl_device) {
-  IndexType dim1 = 2;
-  IndexType dim2 = 3;
-  IndexType dim3 = 5;
-  IndexType dim4 = 7;
-
-  array<IndexType, 4> tensorRange = {{dim1, dim2, dim3, dim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> reversed_tensor(tensorRange);
-  tensor.setRandom();
-
-  array<bool, 4> dim_rev;
-  dim_rev[0] = false;
-  dim_rev[1] = true;
-  dim_rev[2] = true;
-  dim_rev[3] = false;
-
-  DataType* gpu_in_data =
-      static_cast<DataType*>(sycl_device.allocate(tensor.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data =
-      static_cast<DataType*>(sycl_device.allocate(reversed_tensor.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > out_gpu(gpu_out_data, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, tensor.data(), (tensor.dimensions().TotalSize()) * sizeof(DataType));
-  out_gpu.device(sycl_device) = in_gpu.reverse(dim_rev);
-  sycl_device.memcpyDeviceToHost(reversed_tensor.data(), gpu_out_data,
-                                 reversed_tensor.dimensions().TotalSize() * sizeof(DataType));
-  // Check that the CPU and GPU reductions return the same result.
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(i, 2 - j, 4 - k, l));
-        }
-      }
-    }
-  }
-  dim_rev[0] = true;
-  dim_rev[1] = false;
-  dim_rev[2] = false;
-  dim_rev[3] = false;
-
-  out_gpu.device(sycl_device) = in_gpu.reverse(dim_rev);
-  sycl_device.memcpyDeviceToHost(reversed_tensor.data(), gpu_out_data,
-                                 reversed_tensor.dimensions().TotalSize() * sizeof(DataType));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dim_rev[0] = true;
-  dim_rev[1] = false;
-  dim_rev[2] = false;
-  dim_rev[3] = true;
-  out_gpu.device(sycl_device) = in_gpu.reverse(dim_rev);
-  sycl_device.memcpyDeviceToHost(reversed_tensor.data(), gpu_out_data,
-                                 reversed_tensor.dimensions().TotalSize() * sizeof(DataType));
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), reversed_tensor(1 - i, j, k, 6 - l));
-        }
-      }
-    }
-  }
-
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_expr_reverse(const Eigen::SyclDevice& sycl_device, bool LValue) {
-  IndexType dim1 = 2;
-  IndexType dim2 = 3;
-  IndexType dim3 = 5;
-  IndexType dim4 = 7;
-
-  array<IndexType, 4> tensorRange = {{dim1, dim2, dim3, dim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> expected(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> result(tensorRange);
-  tensor.setRandom();
-
-  array<bool, 4> dim_rev;
-  dim_rev[0] = false;
-  dim_rev[1] = true;
-  dim_rev[2] = false;
-  dim_rev[3] = true;
-
-  DataType* gpu_in_data =
-      static_cast<DataType*>(sycl_device.allocate(tensor.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data_expected =
-      static_cast<DataType*>(sycl_device.allocate(expected.dimensions().TotalSize() * sizeof(DataType)));
-  DataType* gpu_out_data_result =
-      static_cast<DataType*>(sycl_device.allocate(result.dimensions().TotalSize() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > in_gpu(gpu_in_data, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > out_gpu_expected(gpu_out_data_expected, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType> > out_gpu_result(gpu_out_data_result, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_in_data, tensor.data(), (tensor.dimensions().TotalSize()) * sizeof(DataType));
-
-  if (LValue) {
-    out_gpu_expected.reverse(dim_rev).device(sycl_device) = in_gpu;
-  } else {
-    out_gpu_expected.device(sycl_device) = in_gpu.reverse(dim_rev);
-  }
-  sycl_device.memcpyDeviceToHost(expected.data(), gpu_out_data_expected,
-                                 expected.dimensions().TotalSize() * sizeof(DataType));
-
-  array<IndexType, 4> src_slice_dim;
-  src_slice_dim[0] = 2;
-  src_slice_dim[1] = 3;
-  src_slice_dim[2] = 1;
-  src_slice_dim[3] = 7;
-  array<IndexType, 4> src_slice_start;
-  src_slice_start[0] = 0;
-  src_slice_start[1] = 0;
-  src_slice_start[2] = 0;
-  src_slice_start[3] = 0;
-  array<IndexType, 4> dst_slice_dim = src_slice_dim;
-  array<IndexType, 4> dst_slice_start = src_slice_start;
-
-  for (IndexType i = 0; i < 5; ++i) {
-    if (LValue) {
-      out_gpu_result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev).device(sycl_device) =
-          in_gpu.slice(src_slice_start, src_slice_dim);
-    } else {
-      out_gpu_result.slice(dst_slice_start, dst_slice_dim).device(sycl_device) =
-          in_gpu.slice(src_slice_start, src_slice_dim).reverse(dim_rev);
-    }
-    src_slice_start[2] += 1;
-    dst_slice_start[2] += 1;
-  }
-  sycl_device.memcpyDeviceToHost(result.data(), gpu_out_data_result,
-                                 result.dimensions().TotalSize() * sizeof(DataType));
-
-  for (IndexType i = 0; i < expected.dimension(0); ++i) {
-    for (IndexType j = 0; j < expected.dimension(1); ++j) {
-      for (IndexType k = 0; k < expected.dimension(2); ++k) {
-        for (IndexType l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dst_slice_start[2] = 0;
-  result.setRandom();
-  sycl_device.memcpyHostToDevice(gpu_out_data_result, result.data(),
-                                 (result.dimensions().TotalSize()) * sizeof(DataType));
-  for (IndexType i = 0; i < 5; ++i) {
-    if (LValue) {
-      out_gpu_result.slice(dst_slice_start, dst_slice_dim).reverse(dim_rev).device(sycl_device) =
-          in_gpu.slice(dst_slice_start, dst_slice_dim);
-    } else {
-      out_gpu_result.slice(dst_slice_start, dst_slice_dim).device(sycl_device) =
-          in_gpu.reverse(dim_rev).slice(dst_slice_start, dst_slice_dim);
-    }
-    dst_slice_start[2] += 1;
-  }
-  sycl_device.memcpyDeviceToHost(result.data(), gpu_out_data_result,
-                                 result.dimensions().TotalSize() * sizeof(DataType));
-
-  for (IndexType i = 0; i < expected.dimension(0); ++i) {
-    for (IndexType j = 0; j < expected.dimension(1); ++j) {
-      for (IndexType k = 0; k < expected.dimension(2); ++k) {
-        for (IndexType l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <typename DataType>
-void sycl_reverse_test_per_device(const cl::sycl::device& d) {
-  QueueInterface queueInterface(d);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_reverse<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_reverse<DataType, ColMajor, int64_t>(sycl_device);
-  test_expr_reverse<DataType, RowMajor, int64_t>(sycl_device, false);
-  test_expr_reverse<DataType, ColMajor, int64_t>(sycl_device, false);
-  test_expr_reverse<DataType, RowMajor, int64_t>(sycl_device, true);
-  test_expr_reverse<DataType, ColMajor, int64_t>(sycl_device, true);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_reverse_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    std::cout << "Running on " << device.get_info<cl::sycl::info::device::name>() << std::endl;
-    CALL_SUBTEST_1(sycl_reverse_test_per_device<short>(device));
-    CALL_SUBTEST_2(sycl_reverse_test_per_device<int>(device));
-    CALL_SUBTEST_3(sycl_reverse_test_per_device<unsigned int>(device));
-#ifdef EIGEN_SYCL_DOUBLE_SUPPORT
-    CALL_SUBTEST_4(sycl_reverse_test_per_device<double>(device));
-#endif
-    CALL_SUBTEST_5(sycl_reverse_test_per_device<half>(device));
-    CALL_SUBTEST_6(sycl_reverse_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_roll.cpp b/unsupported/test/cxx11_tensor_roll.cpp
deleted file mode 100644
index eaa7886..0000000
--- a/unsupported/test/cxx11_tensor_roll.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2024 Tobias Wood tobias@spinicist.org.uk
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_roll() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<Index, 4> dim_roll;
-  dim_roll[0] = 0;
-  dim_roll[1] = 1;
-  dim_roll[2] = 4;
-  dim_roll[3] = 8;
-
-  Tensor<float, 4, DataLayout> rolled_tensor;
-  rolled_tensor = tensor.roll(dim_roll);
-
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(0), 2);
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(1), 3);
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(2), 5);
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, (j + 1) % 3, (k + 4) % 5, (l + 8) % 7), rolled_tensor(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dim_roll[0] = -3;
-  dim_roll[1] = -2;
-  dim_roll[2] = -1;
-  dim_roll[3] = 0;
-
-  rolled_tensor = tensor.roll(dim_roll);
-
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(0), 2);
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(1), 3);
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(2), 5);
-  VERIFY_IS_EQUAL(rolled_tensor.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor((i + 1) % 2, (j + 1) % 3, (k + 4) % 5, l), rolled_tensor(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_expr_roll(bool LValue) {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<bool, 4> dim_roll;
-  dim_roll[0] = 2;
-  dim_roll[1] = 1;
-  dim_roll[2] = 0;
-  dim_roll[3] = 3;
-
-  Tensor<float, 4, DataLayout> expected(tensor.dimensions());
-  if (LValue) {
-    expected.roll(dim_roll) = tensor;
-  } else {
-    expected = tensor.roll(dim_roll);
-  }
-
-  Tensor<float, 4, DataLayout> result(tensor.dimensions());
-
-  array<ptrdiff_t, 4> src_slice_dim;
-  src_slice_dim[0] = tensor.dimension(0);
-  src_slice_dim[1] = tensor.dimension(1);
-  src_slice_dim[2] = 1;
-  src_slice_dim[3] = tensor.dimension(3);
-  array<ptrdiff_t, 4> src_slice_start;
-  src_slice_start[0] = 0;
-  src_slice_start[1] = 0;
-  src_slice_start[2] = 0;
-  src_slice_start[3] = 0;
-  array<ptrdiff_t, 4> dst_slice_dim = src_slice_dim;
-  array<ptrdiff_t, 4> dst_slice_start = src_slice_start;
-
-  for (int i = 0; i < tensor.dimension(2); ++i) {
-    if (LValue) {
-      result.slice(dst_slice_start, dst_slice_dim).roll(dim_roll) = tensor.slice(src_slice_start, src_slice_dim);
-    } else {
-      result.slice(dst_slice_start, dst_slice_dim) = tensor.slice(src_slice_start, src_slice_dim).roll(dim_roll);
-    }
-    src_slice_start[2] += 1;
-    dst_slice_start[2] += 1;
-  }
-
-  VERIFY_IS_EQUAL(result.dimension(0), tensor.dimension(0));
-  VERIFY_IS_EQUAL(result.dimension(1), tensor.dimension(1));
-  VERIFY_IS_EQUAL(result.dimension(2), tensor.dimension(2));
-  VERIFY_IS_EQUAL(result.dimension(3), tensor.dimension(3));
-
-  for (int i = 0; i < expected.dimension(0); ++i) {
-    for (int j = 0; j < expected.dimension(1); ++j) {
-      for (int k = 0; k < expected.dimension(2); ++k) {
-        for (int l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dst_slice_start[2] = 0;
-  result.setRandom();
-  for (int i = 0; i < tensor.dimension(2); ++i) {
-    if (LValue) {
-      result.slice(dst_slice_start, dst_slice_dim).roll(dim_roll) = tensor.slice(dst_slice_start, dst_slice_dim);
-    } else {
-      result.slice(dst_slice_start, dst_slice_dim) = tensor.roll(dim_roll).slice(dst_slice_start, dst_slice_dim);
-    }
-    dst_slice_start[2] += 1;
-  }
-
-  for (int i = 0; i < expected.dimension(0); ++i) {
-    for (int j = 0; j < expected.dimension(1); ++j) {
-      for (int k = 0; k < expected.dimension(2); ++k) {
-        for (int l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_roll) {
-  CALL_SUBTEST(test_simple_roll<ColMajor>());
-  CALL_SUBTEST(test_simple_roll<RowMajor>());
-  CALL_SUBTEST(test_expr_roll<ColMajor>(true));
-  CALL_SUBTEST(test_expr_roll<RowMajor>(true));
-  CALL_SUBTEST(test_expr_roll<ColMajor>(false));
-  CALL_SUBTEST(test_expr_roll<RowMajor>(false));
-}
diff --git a/unsupported/test/cxx11_tensor_roundings.cpp b/unsupported/test/cxx11_tensor_roundings.cpp
deleted file mode 100644
index 33e9cb3..0000000
--- a/unsupported/test/cxx11_tensor_roundings.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-static void test_float_rounding() {
-  Tensor<float, 2> ftensor(20, 30);
-  ftensor = ftensor.random() * 100.f;
-
-  Tensor<float, 2> result = ftensor.round();
-
-  for (int i = 0; i < 20; ++i) {
-    for (int j = 0; j < 30; ++j) {
-      VERIFY_IS_EQUAL(result(i, j), numext::round(ftensor(i, j)));
-    }
-  }
-}
-
-static void test_float_flooring() {
-  Tensor<float, 2> ftensor(20, 30);
-  ftensor = ftensor.random() * 100.f;
-
-  Tensor<float, 2> result = ftensor.floor();
-
-  for (int i = 0; i < 20; ++i) {
-    for (int j = 0; j < 30; ++j) {
-      VERIFY_IS_EQUAL(result(i, j), numext::floor(ftensor(i, j)));
-    }
-  }
-}
-
-static void test_float_ceiling() {
-  Tensor<float, 2> ftensor(20, 30);
-  ftensor = ftensor.random() * 100.f;
-
-  Tensor<float, 2> result = ftensor.ceil();
-
-  for (int i = 0; i < 20; ++i) {
-    for (int j = 0; j < 30; ++j) {
-      VERIFY_IS_EQUAL(result(i, j), numext::ceil(ftensor(i, j)));
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_roundings) {
-  CALL_SUBTEST(test_float_rounding());
-  CALL_SUBTEST(test_float_ceiling());
-  CALL_SUBTEST(test_float_flooring());
-}
diff --git a/unsupported/test/cxx11_tensor_scan.cpp b/unsupported/test/cxx11_tensor_scan.cpp
deleted file mode 100644
index 30730f2..0000000
--- a/unsupported/test/cxx11_tensor_scan.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Igor Babuschkin <igor@babuschk.in>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <limits>
-#include <numeric>
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout, typename Type = float, bool Exclusive = false>
-static void test_1d_scan() {
-  int size = 50;
-  Tensor<Type, 1, DataLayout> tensor(size);
-  tensor.setRandom();
-  Tensor<Type, 1, DataLayout> result = tensor.cumsum(0, Exclusive);
-
-  VERIFY_IS_EQUAL(tensor.dimension(0), result.dimension(0));
-
-  float accum = 0;
-  for (int i = 0; i < size; i++) {
-    if (Exclusive) {
-      VERIFY_IS_EQUAL(result(i), accum);
-      accum += tensor(i);
-    } else {
-      accum += tensor(i);
-      VERIFY_IS_EQUAL(result(i), accum);
-    }
-  }
-
-  accum = 1;
-  result = tensor.cumprod(0, Exclusive);
-  for (int i = 0; i < size; i++) {
-    if (Exclusive) {
-      VERIFY_IS_EQUAL(result(i), accum);
-      accum *= tensor(i);
-    } else {
-      accum *= tensor(i);
-      VERIFY_IS_EQUAL(result(i), accum);
-    }
-  }
-}
-
-template <int DataLayout, typename Type = float>
-static void test_4d_scan() {
-  int size = 5;
-  Tensor<Type, 4, DataLayout> tensor(size, size, size, size);
-  tensor.setRandom();
-
-  Tensor<Type, 4, DataLayout> result(size, size, size, size);
-
-  result = tensor.cumsum(0);
-  float accum = 0;
-  for (int i = 0; i < size; i++) {
-    accum += tensor(i, 1, 2, 3);
-    VERIFY_IS_EQUAL(result(i, 1, 2, 3), accum);
-  }
-  result = tensor.cumsum(1);
-  accum = 0;
-  for (int i = 0; i < size; i++) {
-    accum += tensor(1, i, 2, 3);
-    VERIFY_IS_EQUAL(result(1, i, 2, 3), accum);
-  }
-  result = tensor.cumsum(2);
-  accum = 0;
-  for (int i = 0; i < size; i++) {
-    accum += tensor(1, 2, i, 3);
-    VERIFY_IS_EQUAL(result(1, 2, i, 3), accum);
-  }
-  result = tensor.cumsum(3);
-  accum = 0;
-  for (int i = 0; i < size; i++) {
-    accum += tensor(1, 2, 3, i);
-    VERIFY_IS_EQUAL(result(1, 2, 3, i), accum);
-  }
-}
-
-template <int DataLayout>
-static void test_tensor_maps() {
-  int inputs[20];
-  TensorMap<Tensor<int, 1, DataLayout> > tensor_map(inputs, 20);
-  tensor_map.setRandom();
-
-  Tensor<int, 1, DataLayout> result = tensor_map.cumsum(0);
-
-  int accum = 0;
-  for (int i = 0; i < 20; ++i) {
-    accum += tensor_map(i);
-    VERIFY_IS_EQUAL(result(i), accum);
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_scan) {
-  CALL_SUBTEST((test_1d_scan<ColMajor, float, true>()));
-  CALL_SUBTEST((test_1d_scan<ColMajor, float, false>()));
-  CALL_SUBTEST((test_1d_scan<RowMajor, float, true>()));
-  CALL_SUBTEST((test_1d_scan<RowMajor, float, false>()));
-  CALL_SUBTEST(test_4d_scan<ColMajor>());
-  CALL_SUBTEST(test_4d_scan<RowMajor>());
-  CALL_SUBTEST(test_tensor_maps<ColMajor>());
-  CALL_SUBTEST(test_tensor_maps<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_scan_gpu.cu b/unsupported/test/cxx11_tensor_scan_gpu.cu
deleted file mode 100644
index e3a5c4d..0000000
--- a/unsupported/test/cxx11_tensor_scan_gpu.cu
+++ /dev/null
@@ -1,72 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int
-#define EIGEN_USE_GPU
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-typedef Tensor<float, 1>::DimensionPair DimPair;
-
-template <int DataLayout>
-void test_gpu_cumsum(int m_size, int k_size, int n_size) {
-  std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << ")" << std::endl;
-  Tensor<float, 3, DataLayout> t_input(m_size, k_size, n_size);
-  Tensor<float, 3, DataLayout> t_result(m_size, k_size, n_size);
-  Tensor<float, 3, DataLayout> t_result_gpu(m_size, k_size, n_size);
-
-  t_input.setRandom();
-
-  std::size_t t_input_bytes = t_input.size() * sizeof(float);
-  std::size_t t_result_bytes = t_result.size() * sizeof(float);
-
-  float* d_t_input;
-  float* d_t_result;
-
-  gpuMalloc((void**)(&d_t_input), t_input_bytes);
-  gpuMalloc((void**)(&d_t_result), t_result_bytes);
-
-  gpuMemcpy(d_t_input, t_input.data(), t_input_bytes, gpuMemcpyHostToDevice);
-
-  Eigen::GpuStreamDevice stream;
-  Eigen::GpuDevice gpu_device(&stream);
-
-  Eigen::TensorMap<Eigen::Tensor<float, 3, DataLayout> > gpu_t_input(d_t_input,
-                                                                     Eigen::array<int, 3>{m_size, k_size, n_size});
-  Eigen::TensorMap<Eigen::Tensor<float, 3, DataLayout> > gpu_t_result(d_t_result,
-                                                                      Eigen::array<int, 3>{m_size, k_size, n_size});
-
-  gpu_t_result.device(gpu_device) = gpu_t_input.cumsum(1);
-  t_result = t_input.cumsum(1);
-
-  gpuMemcpy(t_result_gpu.data(), d_t_result, t_result_bytes, gpuMemcpyDeviceToHost);
-  for (DenseIndex i = 0; i < t_result.size(); i++) {
-    if (fabs(t_result(i) - t_result_gpu(i)) < 1e-4f) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), 1e-4f)) {
-      continue;
-    }
-    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << t_result_gpu(i) << std::endl;
-    assert(false);
-  }
-
-  gpuFree((void*)d_t_input);
-  gpuFree((void*)d_t_result);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_scan_gpu) {
-  CALL_SUBTEST_1(test_gpu_cumsum<ColMajor>(128, 128, 128));
-  CALL_SUBTEST_2(test_gpu_cumsum<RowMajor>(128, 128, 128));
-}
diff --git a/unsupported/test/cxx11_tensor_scan_sycl.cpp b/unsupported/test/cxx11_tensor_scan_sycl.cpp
deleted file mode 100644
index 2c303e5..0000000
--- a/unsupported/test/cxx11_tensor_scan_sycl.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-typedef Tensor<float, 1>::DimensionPair DimPair;
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_cumsum(const Eigen::SyclDevice& sycl_device, IndexType m_size, IndexType k_size, IndexType n_size,
-                      int consume_dim, bool exclusive) {
-  static const DataType error_threshold = 1e-4f;
-  std::cout << "Testing for (" << m_size << "," << k_size << "," << n_size << " consume_dim : " << consume_dim << ")"
-            << std::endl;
-  Tensor<DataType, 3, DataLayout, IndexType> t_input(m_size, k_size, n_size);
-  Tensor<DataType, 3, DataLayout, IndexType> t_result(m_size, k_size, n_size);
-  Tensor<DataType, 3, DataLayout, IndexType> t_result_gpu(m_size, k_size, n_size);
-
-  t_input.setRandom();
-  std::size_t t_input_bytes = t_input.size() * sizeof(DataType);
-  std::size_t t_result_bytes = t_result.size() * sizeof(DataType);
-
-  DataType* gpu_data_in = static_cast<DataType*>(sycl_device.allocate(t_input_bytes));
-  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(t_result_bytes));
-
-  array<IndexType, 3> tensorRange = {{m_size, k_size, n_size}};
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_t_input(gpu_data_in, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_t_result(gpu_data_out, tensorRange);
-  sycl_device.memcpyHostToDevice(gpu_data_in, t_input.data(), t_input_bytes);
-  sycl_device.memcpyHostToDevice(gpu_data_out, t_input.data(), t_input_bytes);
-
-  gpu_t_result.device(sycl_device) = gpu_t_input.cumsum(consume_dim, exclusive);
-
-  t_result = t_input.cumsum(consume_dim, exclusive);
-
-  sycl_device.memcpyDeviceToHost(t_result_gpu.data(), gpu_data_out, t_result_bytes);
-  sycl_device.synchronize();
-
-  for (IndexType i = 0; i < t_result.size(); i++) {
-    if (static_cast<DataType>(std::fabs(static_cast<DataType>(t_result(i) - t_result_gpu(i)))) < error_threshold) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), t_result_gpu(i), error_threshold)) {
-      continue;
-    }
-    std::cout << "mismatch detected at index " << i << " CPU : " << t_result(i) << " vs SYCL : " << t_result_gpu(i)
-              << std::endl;
-    assert(false);
-  }
-  sycl_device.deallocate(gpu_data_in);
-  sycl_device.deallocate(gpu_data_out);
-}
-
-template <typename DataType, typename Dev>
-void sycl_scan_test_exclusive_dim0_per_device(const Dev& sycl_device) {
-  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, true);
-  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, true);
-}
-template <typename DataType, typename Dev>
-void sycl_scan_test_exclusive_dim1_per_device(const Dev& sycl_device) {
-  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, true);
-  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, true);
-}
-template <typename DataType, typename Dev>
-void sycl_scan_test_exclusive_dim2_per_device(const Dev& sycl_device) {
-  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, true);
-  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, true);
-}
-template <typename DataType, typename Dev>
-void sycl_scan_test_inclusive_dim0_per_device(const Dev& sycl_device) {
-  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, false);
-  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 2049, 1023, 127, 0, false);
-}
-template <typename DataType, typename Dev>
-void sycl_scan_test_inclusive_dim1_per_device(const Dev& sycl_device) {
-  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, false);
-  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 2049, 127, 1, false);
-}
-template <typename DataType, typename Dev>
-void sycl_scan_test_inclusive_dim2_per_device(const Dev& sycl_device) {
-  test_sycl_cumsum<DataType, ColMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, false);
-  test_sycl_cumsum<DataType, RowMajor, int64_t>(sycl_device, 1023, 127, 2049, 2, false);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_scan_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    std::cout << "Running on " << device.template get_info<cl::sycl::info::device::name>() << std::endl;
-    QueueInterface queueInterface(device);
-    auto sycl_device = Eigen::SyclDevice(&queueInterface);
-    CALL_SUBTEST_1(sycl_scan_test_exclusive_dim0_per_device<float>(sycl_device));
-    CALL_SUBTEST_2(sycl_scan_test_exclusive_dim1_per_device<float>(sycl_device));
-    CALL_SUBTEST_3(sycl_scan_test_exclusive_dim2_per_device<float>(sycl_device));
-    CALL_SUBTEST_4(sycl_scan_test_inclusive_dim0_per_device<float>(sycl_device));
-    CALL_SUBTEST_5(sycl_scan_test_inclusive_dim1_per_device<float>(sycl_device));
-    CALL_SUBTEST_6(sycl_scan_test_inclusive_dim2_per_device<float>(sycl_device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_shuffling.cpp b/unsupported/test/cxx11_tensor_shuffling.cpp
deleted file mode 100644
index dd4e398..0000000
--- a/unsupported/test/cxx11_tensor_shuffling.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_shuffling() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> shuffles;
-  shuffles[0] = 0;
-  shuffles[1] = 1;
-  shuffles[2] = 2;
-  shuffles[3] = 3;
-
-  Tensor<float, 4, DataLayout> no_shuffle;
-  no_shuffle = tensor.shuffle(shuffles);
-
-  VERIFY_IS_EQUAL(no_shuffle.dimension(0), 2);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(1), 3);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(2), 5);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_shuffle(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  shuffles[0] = 2;
-  shuffles[1] = 3;
-  shuffles[2] = 1;
-  shuffles[3] = 0;
-  Tensor<float, 4, DataLayout> shuffle;
-  shuffle = tensor.shuffle(shuffles);
-
-  VERIFY_IS_EQUAL(shuffle.dimension(0), 5);
-  VERIFY_IS_EQUAL(shuffle.dimension(1), 7);
-  VERIFY_IS_EQUAL(shuffle.dimension(2), 3);
-  VERIFY_IS_EQUAL(shuffle.dimension(3), 2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_expr_shuffling() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  array<ptrdiff_t, 4> shuffles;
-  shuffles[0] = 2;
-  shuffles[1] = 3;
-  shuffles[2] = 1;
-  shuffles[3] = 0;
-  Tensor<float, 4, DataLayout> expected;
-  expected = tensor.shuffle(shuffles);
-
-  Tensor<float, 4, DataLayout> result(5, 7, 3, 2);
-
-  array<ptrdiff_t, 4> src_slice_dim{{2, 3, 1, 7}};
-  array<ptrdiff_t, 4> src_slice_start{{0, 0, 0, 0}};
-  array<ptrdiff_t, 4> dst_slice_dim{{1, 7, 3, 2}};
-  array<ptrdiff_t, 4> dst_slice_start{{0, 0, 0, 0}};
-
-  for (int i = 0; i < 5; ++i) {
-    result.slice(dst_slice_start, dst_slice_dim) = tensor.slice(src_slice_start, src_slice_dim).shuffle(shuffles);
-    src_slice_start[2] += 1;
-    dst_slice_start[0] += 1;
-  }
-
-  VERIFY_IS_EQUAL(result.dimension(0), 5);
-  VERIFY_IS_EQUAL(result.dimension(1), 7);
-  VERIFY_IS_EQUAL(result.dimension(2), 3);
-  VERIFY_IS_EQUAL(result.dimension(3), 2);
-
-  for (int i = 0; i < expected.dimension(0); ++i) {
-    for (int j = 0; j < expected.dimension(1); ++j) {
-      for (int k = 0; k < expected.dimension(2); ++k) {
-        for (int l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  dst_slice_start[0] = 0;
-  result.setRandom();
-  for (int i = 0; i < 5; ++i) {
-    result.slice(dst_slice_start, dst_slice_dim) = tensor.shuffle(shuffles).slice(dst_slice_start, dst_slice_dim);
-    dst_slice_start[0] += 1;
-  }
-
-  for (int i = 0; i < expected.dimension(0); ++i) {
-    for (int j = 0; j < expected.dimension(1); ++j) {
-      for (int k = 0; k < expected.dimension(2); ++k) {
-        for (int l = 0; l < expected.dimension(3); ++l) {
-          VERIFY_IS_EQUAL(result(i, j, k, l), expected(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_shuffling_as_value() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> shuffles;
-  shuffles[2] = 0;
-  shuffles[3] = 1;
-  shuffles[1] = 2;
-  shuffles[0] = 3;
-  Tensor<float, 4, DataLayout> shuffle(5, 7, 3, 2);
-  shuffle.shuffle(shuffles) = tensor;
-
-  VERIFY_IS_EQUAL(shuffle.dimension(0), 5);
-  VERIFY_IS_EQUAL(shuffle.dimension(1), 7);
-  VERIFY_IS_EQUAL(shuffle.dimension(2), 3);
-  VERIFY_IS_EQUAL(shuffle.dimension(3), 2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
-        }
-      }
-    }
-  }
-
-  array<ptrdiff_t, 4> no_shuffle;
-  no_shuffle[0] = 0;
-  no_shuffle[1] = 1;
-  no_shuffle[2] = 2;
-  no_shuffle[3] = 3;
-  Tensor<float, 4, DataLayout> shuffle2(5, 7, 3, 2);
-  shuffle2.shuffle(shuffles) = tensor.shuffle(no_shuffle);
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 2; ++l) {
-          VERIFY_IS_EQUAL(shuffle2(i, j, k, l), shuffle(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_shuffle_unshuffle() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-
-  // Choose a random permutation.
-  array<ptrdiff_t, 4> shuffles;
-  for (int i = 0; i < 4; ++i) {
-    shuffles[i] = i;
-  }
-  array<ptrdiff_t, 4> shuffles_inverse;
-  for (int i = 0; i < 4; ++i) {
-    const ptrdiff_t index = internal::random<ptrdiff_t>(i, 3);
-    shuffles_inverse[shuffles[index]] = i;
-    std::swap(shuffles[i], shuffles[index]);
-  }
-
-  Tensor<float, 4, DataLayout> shuffle;
-  shuffle = tensor.shuffle(shuffles).shuffle(shuffles_inverse);
-
-  VERIFY_IS_EQUAL(shuffle.dimension(0), 2);
-  VERIFY_IS_EQUAL(shuffle.dimension(1), 3);
-  VERIFY_IS_EQUAL(shuffle.dimension(2), 5);
-  VERIFY_IS_EQUAL(shuffle.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_empty_shuffling() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 0, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> shuffles;
-  shuffles[0] = 0;
-  shuffles[1] = 1;
-  shuffles[2] = 2;
-  shuffles[3] = 3;
-
-  Tensor<float, 4, DataLayout> no_shuffle;
-  no_shuffle = tensor.shuffle(shuffles);
-
-  VERIFY_IS_EQUAL(no_shuffle.dimension(0), 2);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(1), 3);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(2), 0);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 0; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_shuffle(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  shuffles[0] = 2;
-  shuffles[1] = 3;
-  shuffles[2] = 1;
-  shuffles[3] = 0;
-  Tensor<float, 4, DataLayout> shuffle;
-  shuffle = tensor.shuffle(shuffles);
-
-  VERIFY_IS_EQUAL(shuffle.dimension(0), 0);
-  VERIFY_IS_EQUAL(shuffle.dimension(1), 7);
-  VERIFY_IS_EQUAL(shuffle.dimension(2), 3);
-  VERIFY_IS_EQUAL(shuffle.dimension(3), 2);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 0; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_shuffling) {
-  CALL_SUBTEST(test_simple_shuffling<ColMajor>());
-  CALL_SUBTEST(test_simple_shuffling<RowMajor>());
-  CALL_SUBTEST(test_expr_shuffling<ColMajor>());
-  CALL_SUBTEST(test_expr_shuffling<RowMajor>());
-  CALL_SUBTEST(test_shuffling_as_value<ColMajor>());
-  CALL_SUBTEST(test_shuffling_as_value<RowMajor>());
-  CALL_SUBTEST(test_shuffle_unshuffle<ColMajor>());
-  CALL_SUBTEST(test_shuffle_unshuffle<RowMajor>());
-  CALL_SUBTEST(test_empty_shuffling<ColMajor>());
-  CALL_SUBTEST(test_empty_shuffling<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_shuffling_sycl.cpp b/unsupported/test/cxx11_tensor_shuffling_sycl.cpp
deleted file mode 100644
index 15e7deb..0000000
--- a/unsupported/test/cxx11_tensor_shuffling_sycl.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_shuffling_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 4> tensorRange = {{sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensorRange);
-  Tensor<DataType, 4, DataLayout, IndexType> no_shuffle(tensorRange);
-  tensor.setRandom();
-
-  const size_t buffSize = tensor.size() * sizeof(DataType);
-  array<IndexType, 4> shuffles;
-  shuffles[0] = 0;
-  shuffles[1] = 1;
-  shuffles[2] = 2;
-  shuffles[3] = 3;
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(buffSize));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(buffSize));
-
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, tensor.data(), buffSize);
-
-  gpu2.device(sycl_device) = gpu1.shuffle(shuffles);
-  sycl_device.memcpyDeviceToHost(no_shuffle.data(), gpu_data2, buffSize);
-  sycl_device.synchronize();
-
-  VERIFY_IS_EQUAL(no_shuffle.dimension(0), sizeDim1);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(1), sizeDim2);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(2), sizeDim3);
-  VERIFY_IS_EQUAL(no_shuffle.dimension(3), sizeDim4);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        for (IndexType l = 0; l < sizeDim4; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_shuffle(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  shuffles[0] = 2;
-  shuffles[1] = 3;
-  shuffles[2] = 1;
-  shuffles[3] = 0;
-  array<IndexType, 4> tensorrangeShuffle = {{sizeDim3, sizeDim4, sizeDim2, sizeDim1}};
-  Tensor<DataType, 4, DataLayout, IndexType> shuffle(tensorrangeShuffle);
-  DataType* gpu_data3 = static_cast<DataType*>(sycl_device.allocate(buffSize));
-  TensorMap<Tensor<DataType, 4, DataLayout, IndexType>> gpu3(gpu_data3, tensorrangeShuffle);
-
-  gpu3.device(sycl_device) = gpu1.shuffle(shuffles);
-  sycl_device.memcpyDeviceToHost(shuffle.data(), gpu_data3, buffSize);
-  sycl_device.synchronize();
-
-  VERIFY_IS_EQUAL(shuffle.dimension(0), sizeDim3);
-  VERIFY_IS_EQUAL(shuffle.dimension(1), sizeDim4);
-  VERIFY_IS_EQUAL(shuffle.dimension(2), sizeDim2);
-  VERIFY_IS_EQUAL(shuffle.dimension(3), sizeDim1);
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        for (IndexType l = 0; l < sizeDim4; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, l, j, i));
-        }
-      }
-    }
-  }
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_shuffling_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_shuffling_sycl<DataType, RowMajor, int64_t>(sycl_device);
-  test_simple_shuffling_sycl<DataType, ColMajor, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_shuffling_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_shuffling_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_shuffling_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_simple.cpp b/unsupported/test/cxx11_tensor_simple.cpp
deleted file mode 100644
index c313119..0000000
--- a/unsupported/test/cxx11_tensor_simple.cpp
+++ /dev/null
@@ -1,332 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_0d() {
-  Tensor<int, 0> scalar1;
-  Tensor<int, 0, RowMajor> scalar2;
-  Tensor<int, 0> scalar3;
-  Tensor<int, 0, RowMajor> scalar4;
-
-  scalar3.resize();
-  scalar4.resize();
-
-  scalar1() = 7;
-  scalar2() = 13;
-  scalar3.setValues(17);
-  scalar4.setZero();
-
-  VERIFY_IS_EQUAL(scalar1.rank(), 0);
-  VERIFY_IS_EQUAL(scalar1.size(), 1);
-
-  VERIFY_IS_EQUAL(scalar1(), 7);
-  VERIFY_IS_EQUAL(scalar2(), 13);
-  VERIFY_IS_EQUAL(scalar3(), 17);
-  VERIFY_IS_EQUAL(scalar4(), 0);
-
-  Tensor<int, 0> scalar5(scalar1);
-
-  VERIFY_IS_EQUAL(scalar5(), 7);
-  VERIFY_IS_EQUAL(scalar5.data()[0], 7);
-}
-
-static void test_1d() {
-  Tensor<int, 1> vec1(6);
-  Tensor<int, 1, RowMajor> vec2(6);
-  Tensor<int, 1> vec3;
-  Tensor<int, 1, RowMajor> vec4;
-
-  vec3.resize(6);
-  vec4.resize(6);
-
-  vec1(0) = 4;
-  vec2(0) = 0;
-  vec3(0) = 5;
-  vec1(1) = 8;
-  vec2(1) = 1;
-  vec3(1) = 4;
-  vec1(2) = 15;
-  vec2(2) = 2;
-  vec3(2) = 3;
-  vec1(3) = 16;
-  vec2(3) = 3;
-  vec3(3) = 2;
-  vec1(4) = 23;
-  vec2(4) = 4;
-  vec3(4) = 1;
-  vec1(5) = 42;
-  vec2(5) = 5;
-  vec3(5) = 0;
-  vec4.setZero();
-
-  VERIFY_IS_EQUAL((vec1.rank()), 1);
-  VERIFY_IS_EQUAL((vec1.size()), 6);
-  VERIFY_IS_EQUAL((vec1.dimensions()[0]), 6);
-
-  VERIFY_IS_EQUAL((vec1[0]), 4);
-  VERIFY_IS_EQUAL((vec1[1]), 8);
-  VERIFY_IS_EQUAL((vec1[2]), 15);
-  VERIFY_IS_EQUAL((vec1[3]), 16);
-  VERIFY_IS_EQUAL((vec1[4]), 23);
-  VERIFY_IS_EQUAL((vec1[5]), 42);
-
-  VERIFY_IS_EQUAL((vec2[0]), 0);
-  VERIFY_IS_EQUAL((vec2[1]), 1);
-  VERIFY_IS_EQUAL((vec2[2]), 2);
-  VERIFY_IS_EQUAL((vec2[3]), 3);
-  VERIFY_IS_EQUAL((vec2[4]), 4);
-  VERIFY_IS_EQUAL((vec2[5]), 5);
-
-  VERIFY_IS_EQUAL((vec3[0]), 5);
-  VERIFY_IS_EQUAL((vec3[1]), 4);
-  VERIFY_IS_EQUAL((vec3[2]), 3);
-  VERIFY_IS_EQUAL((vec3[3]), 2);
-  VERIFY_IS_EQUAL((vec3[4]), 1);
-  VERIFY_IS_EQUAL((vec3[5]), 0);
-
-  VERIFY_IS_EQUAL((vec4[0]), 0);
-  VERIFY_IS_EQUAL((vec4[1]), 0);
-  VERIFY_IS_EQUAL((vec4[2]), 0);
-  VERIFY_IS_EQUAL((vec4[3]), 0);
-  VERIFY_IS_EQUAL((vec4[4]), 0);
-  VERIFY_IS_EQUAL((vec4[5]), 0);
-
-  Tensor<int, 1> vec5(vec1);
-
-  VERIFY_IS_EQUAL((vec5(0)), 4);
-  VERIFY_IS_EQUAL((vec5(1)), 8);
-  VERIFY_IS_EQUAL((vec5(2)), 15);
-  VERIFY_IS_EQUAL((vec5(3)), 16);
-  VERIFY_IS_EQUAL((vec5(4)), 23);
-  VERIFY_IS_EQUAL((vec5(5)), 42);
-
-  VERIFY_IS_EQUAL((vec5.data()[0]), 4);
-  VERIFY_IS_EQUAL((vec5.data()[1]), 8);
-  VERIFY_IS_EQUAL((vec5.data()[2]), 15);
-  VERIFY_IS_EQUAL((vec5.data()[3]), 16);
-  VERIFY_IS_EQUAL((vec5.data()[4]), 23);
-  VERIFY_IS_EQUAL((vec5.data()[5]), 42);
-}
-
-static void test_2d() {
-  Tensor<int, 2> mat1(2, 3);
-  Tensor<int, 2, RowMajor> mat2(2, 3);
-
-  mat1(0, 0) = 0;
-  mat1(0, 1) = 1;
-  mat1(0, 2) = 2;
-  mat1(1, 0) = 3;
-  mat1(1, 1) = 4;
-  mat1(1, 2) = 5;
-
-  mat2(0, 0) = 0;
-  mat2(0, 1) = 1;
-  mat2(0, 2) = 2;
-  mat2(1, 0) = 3;
-  mat2(1, 1) = 4;
-  mat2(1, 2) = 5;
-
-  VERIFY_IS_EQUAL((mat1.rank()), 2);
-  VERIFY_IS_EQUAL((mat1.size()), 6);
-  VERIFY_IS_EQUAL((mat1.dimensions()[0]), 2);
-  VERIFY_IS_EQUAL((mat1.dimensions()[1]), 3);
-
-  VERIFY_IS_EQUAL((mat2.rank()), 2);
-  VERIFY_IS_EQUAL((mat2.size()), 6);
-  VERIFY_IS_EQUAL((mat2.dimensions()[0]), 2);
-  VERIFY_IS_EQUAL((mat2.dimensions()[1]), 3);
-
-  VERIFY_IS_EQUAL((mat1.data()[0]), 0);
-  VERIFY_IS_EQUAL((mat1.data()[1]), 3);
-  VERIFY_IS_EQUAL((mat1.data()[2]), 1);
-  VERIFY_IS_EQUAL((mat1.data()[3]), 4);
-  VERIFY_IS_EQUAL((mat1.data()[4]), 2);
-  VERIFY_IS_EQUAL((mat1.data()[5]), 5);
-
-  VERIFY_IS_EQUAL((mat2.data()[0]), 0);
-  VERIFY_IS_EQUAL((mat2.data()[1]), 1);
-  VERIFY_IS_EQUAL((mat2.data()[2]), 2);
-  VERIFY_IS_EQUAL((mat2.data()[3]), 3);
-  VERIFY_IS_EQUAL((mat2.data()[4]), 4);
-  VERIFY_IS_EQUAL((mat2.data()[5]), 5);
-}
-
-static void test_3d() {
-  Tensor<int, 3> epsilon(3, 3, 3);
-  epsilon.setZero();
-  epsilon(0, 1, 2) = epsilon(2, 0, 1) = epsilon(1, 2, 0) = 1;
-  epsilon(2, 1, 0) = epsilon(0, 2, 1) = epsilon(1, 0, 2) = -1;
-
-  VERIFY_IS_EQUAL((epsilon.size()), 27);
-  VERIFY_IS_EQUAL((epsilon.dimensions()[0]), 3);
-  VERIFY_IS_EQUAL((epsilon.dimensions()[1]), 3);
-  VERIFY_IS_EQUAL((epsilon.dimensions()[2]), 3);
-
-  VERIFY_IS_EQUAL((epsilon(0, 0, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(0, 0, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(0, 0, 2)), 0);
-  VERIFY_IS_EQUAL((epsilon(0, 1, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(0, 1, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(0, 2, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(0, 2, 2)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 0, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 0, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 1, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 1, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 1, 2)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 2, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(1, 2, 2)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 0, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 0, 2)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 1, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 1, 2)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 2, 0)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 2, 1)), 0);
-  VERIFY_IS_EQUAL((epsilon(2, 2, 2)), 0);
-
-  VERIFY_IS_EQUAL((epsilon(0, 1, 2)), 1);
-  VERIFY_IS_EQUAL((epsilon(2, 0, 1)), 1);
-  VERIFY_IS_EQUAL((epsilon(1, 2, 0)), 1);
-  VERIFY_IS_EQUAL((epsilon(2, 1, 0)), -1);
-  VERIFY_IS_EQUAL((epsilon(0, 2, 1)), -1);
-  VERIFY_IS_EQUAL((epsilon(1, 0, 2)), -1);
-
-  array<Eigen::DenseIndex, 3> dims;
-  dims[0] = 2;
-  dims[1] = 3;
-  dims[2] = 4;
-  Tensor<int, 3> t1(dims);
-  Tensor<int, 3, RowMajor> t2(dims);
-
-  VERIFY_IS_EQUAL((t1.size()), 24);
-  VERIFY_IS_EQUAL((t1.dimensions()[0]), 2);
-  VERIFY_IS_EQUAL((t1.dimensions()[1]), 3);
-  VERIFY_IS_EQUAL((t1.dimensions()[2]), 4);
-
-  VERIFY_IS_EQUAL((t2.size()), 24);
-  VERIFY_IS_EQUAL((t2.dimensions()[0]), 2);
-  VERIFY_IS_EQUAL((t2.dimensions()[1]), 3);
-  VERIFY_IS_EQUAL((t2.dimensions()[2]), 4);
-
-  for (int i = 0; i < 2; i++) {
-    for (int j = 0; j < 3; j++) {
-      for (int k = 0; k < 4; k++) {
-        t1(i, j, k) = 100 * i + 10 * j + k;
-        t2(i, j, k) = 100 * i + 10 * j + k;
-      }
-    }
-  }
-
-  VERIFY_IS_EQUAL((t1.data()[0]), 0);
-  VERIFY_IS_EQUAL((t1.data()[1]), 100);
-  VERIFY_IS_EQUAL((t1.data()[2]), 10);
-  VERIFY_IS_EQUAL((t1.data()[3]), 110);
-  VERIFY_IS_EQUAL((t1.data()[4]), 20);
-  VERIFY_IS_EQUAL((t1.data()[5]), 120);
-  VERIFY_IS_EQUAL((t1.data()[6]), 1);
-  VERIFY_IS_EQUAL((t1.data()[7]), 101);
-  VERIFY_IS_EQUAL((t1.data()[8]), 11);
-  VERIFY_IS_EQUAL((t1.data()[9]), 111);
-  VERIFY_IS_EQUAL((t1.data()[10]), 21);
-  VERIFY_IS_EQUAL((t1.data()[11]), 121);
-  VERIFY_IS_EQUAL((t1.data()[12]), 2);
-  VERIFY_IS_EQUAL((t1.data()[13]), 102);
-  VERIFY_IS_EQUAL((t1.data()[14]), 12);
-  VERIFY_IS_EQUAL((t1.data()[15]), 112);
-  VERIFY_IS_EQUAL((t1.data()[16]), 22);
-  VERIFY_IS_EQUAL((t1.data()[17]), 122);
-  VERIFY_IS_EQUAL((t1.data()[18]), 3);
-  VERIFY_IS_EQUAL((t1.data()[19]), 103);
-  VERIFY_IS_EQUAL((t1.data()[20]), 13);
-  VERIFY_IS_EQUAL((t1.data()[21]), 113);
-  VERIFY_IS_EQUAL((t1.data()[22]), 23);
-  VERIFY_IS_EQUAL((t1.data()[23]), 123);
-
-  VERIFY_IS_EQUAL((t2.data()[0]), 0);
-  VERIFY_IS_EQUAL((t2.data()[1]), 1);
-  VERIFY_IS_EQUAL((t2.data()[2]), 2);
-  VERIFY_IS_EQUAL((t2.data()[3]), 3);
-  VERIFY_IS_EQUAL((t2.data()[4]), 10);
-  VERIFY_IS_EQUAL((t2.data()[5]), 11);
-  VERIFY_IS_EQUAL((t2.data()[6]), 12);
-  VERIFY_IS_EQUAL((t2.data()[7]), 13);
-  VERIFY_IS_EQUAL((t2.data()[8]), 20);
-  VERIFY_IS_EQUAL((t2.data()[9]), 21);
-  VERIFY_IS_EQUAL((t2.data()[10]), 22);
-  VERIFY_IS_EQUAL((t2.data()[11]), 23);
-  VERIFY_IS_EQUAL((t2.data()[12]), 100);
-  VERIFY_IS_EQUAL((t2.data()[13]), 101);
-  VERIFY_IS_EQUAL((t2.data()[14]), 102);
-  VERIFY_IS_EQUAL((t2.data()[15]), 103);
-  VERIFY_IS_EQUAL((t2.data()[16]), 110);
-  VERIFY_IS_EQUAL((t2.data()[17]), 111);
-  VERIFY_IS_EQUAL((t2.data()[18]), 112);
-  VERIFY_IS_EQUAL((t2.data()[19]), 113);
-  VERIFY_IS_EQUAL((t2.data()[20]), 120);
-  VERIFY_IS_EQUAL((t2.data()[21]), 121);
-  VERIFY_IS_EQUAL((t2.data()[22]), 122);
-  VERIFY_IS_EQUAL((t2.data()[23]), 123);
-}
-
-static void test_simple_assign() {
-  Tensor<int, 3> epsilon(3, 3, 3);
-  epsilon.setZero();
-  epsilon(0, 1, 2) = epsilon(2, 0, 1) = epsilon(1, 2, 0) = 1;
-  epsilon(2, 1, 0) = epsilon(0, 2, 1) = epsilon(1, 0, 2) = -1;
-
-  Tensor<int, 3> e2(3, 3, 3);
-  e2.setZero();
-  VERIFY_IS_EQUAL((e2(1, 2, 0)), 0);
-
-  e2 = epsilon;
-  VERIFY_IS_EQUAL((e2(1, 2, 0)), 1);
-  VERIFY_IS_EQUAL((e2(0, 1, 2)), 1);
-  VERIFY_IS_EQUAL((e2(2, 0, 1)), 1);
-  VERIFY_IS_EQUAL((e2(2, 1, 0)), -1);
-  VERIFY_IS_EQUAL((e2(0, 2, 1)), -1);
-  VERIFY_IS_EQUAL((e2(1, 0, 2)), -1);
-}
-
-static void test_resize() {
-  Tensor<int, 3> epsilon;
-  epsilon.resize(2, 3, 7);
-  VERIFY_IS_EQUAL(epsilon.dimension(0), 2);
-  VERIFY_IS_EQUAL(epsilon.dimension(1), 3);
-  VERIFY_IS_EQUAL(epsilon.dimension(2), 7);
-  VERIFY_IS_EQUAL(epsilon.size(), 2 * 3 * 7);
-
-  const int* old_data = epsilon.data();
-  epsilon.resize(3, 2, 7);
-  VERIFY_IS_EQUAL(epsilon.dimension(0), 3);
-  VERIFY_IS_EQUAL(epsilon.dimension(1), 2);
-  VERIFY_IS_EQUAL(epsilon.dimension(2), 7);
-  VERIFY_IS_EQUAL(epsilon.size(), 2 * 3 * 7);
-  VERIFY_IS_EQUAL(epsilon.data(), old_data);
-
-  epsilon.resize(3, 5, 7);
-  VERIFY_IS_EQUAL(epsilon.dimension(0), 3);
-  VERIFY_IS_EQUAL(epsilon.dimension(1), 5);
-  VERIFY_IS_EQUAL(epsilon.dimension(2), 7);
-  VERIFY_IS_EQUAL(epsilon.size(), 3 * 5 * 7);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_simple) {
-  CALL_SUBTEST(test_0d());
-  CALL_SUBTEST(test_1d());
-  CALL_SUBTEST(test_2d());
-  CALL_SUBTEST(test_3d());
-  CALL_SUBTEST(test_simple_assign());
-  CALL_SUBTEST(test_resize());
-}
diff --git a/unsupported/test/cxx11_tensor_striding.cpp b/unsupported/test/cxx11_tensor_striding.cpp
deleted file mode 100644
index b6910ca..0000000
--- a/unsupported/test/cxx11_tensor_striding.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_simple_striding() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> strides;
-  strides[0] = 1;
-  strides[1] = 1;
-  strides[2] = 1;
-  strides[3] = 1;
-
-  Tensor<float, 4, DataLayout> no_stride;
-  no_stride = tensor.stride(strides);
-
-  VERIFY_IS_EQUAL(no_stride.dimension(0), 2);
-  VERIFY_IS_EQUAL(no_stride.dimension(1), 3);
-  VERIFY_IS_EQUAL(no_stride.dimension(2), 5);
-  VERIFY_IS_EQUAL(no_stride.dimension(3), 7);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  strides[0] = 2;
-  strides[1] = 4;
-  strides[2] = 2;
-  strides[3] = 3;
-  Tensor<float, 4, DataLayout> stride;
-  stride = tensor.stride(strides);
-
-  VERIFY_IS_EQUAL(stride.dimension(0), 1);
-  VERIFY_IS_EQUAL(stride.dimension(1), 1);
-  VERIFY_IS_EQUAL(stride.dimension(2), 3);
-  VERIFY_IS_EQUAL(stride.dimension(3), 3);
-
-  for (int i = 0; i < 1; ++i) {
-    for (int j = 0; j < 1; ++j) {
-      for (int k = 0; k < 3; ++k) {
-        for (int l = 0; l < 3; ++l) {
-          VERIFY_IS_EQUAL(tensor(2 * i, 4 * j, 2 * k, 3 * l), stride(i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_striding_as_lvalue() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7);
-  tensor.setRandom();
-  array<ptrdiff_t, 4> strides;
-  strides[0] = 2;
-  strides[1] = 4;
-  strides[2] = 2;
-  strides[3] = 3;
-
-  Tensor<float, 4, DataLayout> result(3, 12, 10, 21);
-  result.stride(strides) = tensor;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), result(2 * i, 4 * j, 2 * k, 3 * l));
-        }
-      }
-    }
-  }
-
-  array<ptrdiff_t, 4> no_strides;
-  no_strides[0] = 1;
-  no_strides[1] = 1;
-  no_strides[2] = 1;
-  no_strides[3] = 1;
-  Tensor<float, 4, DataLayout> result2(3, 12, 10, 21);
-  result2.stride(strides) = tensor.stride(no_strides);
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        for (int l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), result2(2 * i, 4 * j, 2 * k, 3 * l));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_striding) {
-  CALL_SUBTEST(test_simple_striding<ColMajor>());
-  CALL_SUBTEST(test_simple_striding<RowMajor>());
-  CALL_SUBTEST(test_striding_as_lvalue<ColMajor>());
-  CALL_SUBTEST(test_striding_as_lvalue<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_striding_sycl.cpp b/unsupported/test/cxx11_tensor_striding_sycl.cpp
deleted file mode 100644
index 65c96ac..0000000
--- a/unsupported/test/cxx11_tensor_striding_sycl.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include <iostream>
-#include <chrono>
-#include <ctime>
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_simple_striding(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 4> tensor_dims = {{2, 3, 5, 7}};
-  Eigen::array<IndexType, 4> stride_dims = {{1, 1, 3, 3}};
-
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensor_dims);
-  Tensor<DataType, 4, DataLayout, IndexType> no_stride(tensor_dims);
-  Tensor<DataType, 4, DataLayout, IndexType> stride(stride_dims);
-
-  std::size_t tensor_bytes = tensor.size() * sizeof(DataType);
-  std::size_t no_stride_bytes = no_stride.size() * sizeof(DataType);
-  std::size_t stride_bytes = stride.size() * sizeof(DataType);
-  DataType* d_tensor = static_cast<DataType*>(sycl_device.allocate(tensor_bytes));
-  DataType* d_no_stride = static_cast<DataType*>(sycl_device.allocate(no_stride_bytes));
-  DataType* d_stride = static_cast<DataType*>(sycl_device.allocate(stride_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_tensor(d_tensor, tensor_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_no_stride(d_no_stride, tensor_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_stride(d_stride, stride_dims);
-
-  tensor.setRandom();
-  array<IndexType, 4> strides;
-  strides[0] = 1;
-  strides[1] = 1;
-  strides[2] = 1;
-  strides[3] = 1;
-  sycl_device.memcpyHostToDevice(d_tensor, tensor.data(), tensor_bytes);
-  gpu_no_stride.device(sycl_device) = gpu_tensor.stride(strides);
-  sycl_device.memcpyDeviceToHost(no_stride.data(), d_no_stride, no_stride_bytes);
-
-  // no_stride = tensor.stride(strides);
-
-  VERIFY_IS_EQUAL(no_stride.dimension(0), 2);
-  VERIFY_IS_EQUAL(no_stride.dimension(1), 3);
-  VERIFY_IS_EQUAL(no_stride.dimension(2), 5);
-  VERIFY_IS_EQUAL(no_stride.dimension(3), 7);
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  strides[0] = 2;
-  strides[1] = 4;
-  strides[2] = 2;
-  strides[3] = 3;
-  // Tensor<float, 4, DataLayout> stride;
-  //   stride = tensor.stride(strides);
-
-  gpu_stride.device(sycl_device) = gpu_tensor.stride(strides);
-  sycl_device.memcpyDeviceToHost(stride.data(), d_stride, stride_bytes);
-
-  VERIFY_IS_EQUAL(stride.dimension(0), 1);
-  VERIFY_IS_EQUAL(stride.dimension(1), 1);
-  VERIFY_IS_EQUAL(stride.dimension(2), 3);
-  VERIFY_IS_EQUAL(stride.dimension(3), 3);
-
-  for (IndexType i = 0; i < 1; ++i) {
-    for (IndexType j = 0; j < 1; ++j) {
-      for (IndexType k = 0; k < 3; ++k) {
-        for (IndexType l = 0; l < 3; ++l) {
-          VERIFY_IS_EQUAL(tensor(2 * i, 4 * j, 2 * k, 3 * l), stride(i, j, k, l));
-        }
-      }
-    }
-  }
-
-  sycl_device.deallocate(d_tensor);
-  sycl_device.deallocate(d_no_stride);
-  sycl_device.deallocate(d_stride);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-static void test_striding_as_lvalue(const Eigen::SyclDevice& sycl_device) {
-  Eigen::array<IndexType, 4> tensor_dims = {{2, 3, 5, 7}};
-  Eigen::array<IndexType, 4> stride_dims = {{3, 12, 10, 21}};
-
-  Tensor<DataType, 4, DataLayout, IndexType> tensor(tensor_dims);
-  Tensor<DataType, 4, DataLayout, IndexType> no_stride(stride_dims);
-  Tensor<DataType, 4, DataLayout, IndexType> stride(stride_dims);
-
-  std::size_t tensor_bytes = tensor.size() * sizeof(DataType);
-  std::size_t no_stride_bytes = no_stride.size() * sizeof(DataType);
-  std::size_t stride_bytes = stride.size() * sizeof(DataType);
-
-  DataType* d_tensor = static_cast<DataType*>(sycl_device.allocate(tensor_bytes));
-  DataType* d_no_stride = static_cast<DataType*>(sycl_device.allocate(no_stride_bytes));
-  DataType* d_stride = static_cast<DataType*>(sycl_device.allocate(stride_bytes));
-
-  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_tensor(d_tensor, tensor_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_no_stride(d_no_stride, stride_dims);
-  Eigen::TensorMap<Eigen::Tensor<DataType, 4, DataLayout, IndexType> > gpu_stride(d_stride, stride_dims);
-
-  // Tensor<float, 4, DataLayout> tensor(2,3,5,7);
-  tensor.setRandom();
-  array<IndexType, 4> strides;
-  strides[0] = 2;
-  strides[1] = 4;
-  strides[2] = 2;
-  strides[3] = 3;
-
-  //  Tensor<float, 4, DataLayout> result(3, 12, 10, 21);
-  //  result.stride(strides) = tensor;
-  sycl_device.memcpyHostToDevice(d_tensor, tensor.data(), tensor_bytes);
-  gpu_stride.stride(strides).device(sycl_device) = gpu_tensor;
-  sycl_device.memcpyDeviceToHost(stride.data(), d_stride, stride_bytes);
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), stride(2 * i, 4 * j, 2 * k, 3 * l));
-        }
-      }
-    }
-  }
-
-  array<IndexType, 4> no_strides;
-  no_strides[0] = 1;
-  no_strides[1] = 1;
-  no_strides[2] = 1;
-  no_strides[3] = 1;
-  //  Tensor<float, 4, DataLayout> result2(3, 12, 10, 21);
-  //  result2.stride(strides) = tensor.stride(no_strides);
-
-  gpu_no_stride.stride(strides).device(sycl_device) = gpu_tensor.stride(no_strides);
-  sycl_device.memcpyDeviceToHost(no_stride.data(), d_no_stride, no_stride_bytes);
-
-  for (IndexType i = 0; i < 2; ++i) {
-    for (IndexType j = 0; j < 3; ++j) {
-      for (IndexType k = 0; k < 5; ++k) {
-        for (IndexType l = 0; l < 7; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), no_stride(2 * i, 4 * j, 2 * k, 3 * l));
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(d_tensor);
-  sycl_device.deallocate(d_no_stride);
-  sycl_device.deallocate(d_stride);
-}
-
-template <typename Dev_selector>
-void tensorStridingPerDevice(Dev_selector& s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_simple_striding<float, ColMajor, int64_t>(sycl_device);
-  test_simple_striding<float, RowMajor, int64_t>(sycl_device);
-  test_striding_as_lvalue<float, ColMajor, int64_t>(sycl_device);
-  test_striding_as_lvalue<float, RowMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_striding_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(tensorStridingPerDevice(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_sugar.cpp b/unsupported/test/cxx11_tensor_sugar.cpp
deleted file mode 100644
index d1827e8..0000000
--- a/unsupported/test/cxx11_tensor_sugar.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::RowMajor;
-using Eigen::Tensor;
-
-static void test_comparison_sugar() {
-  // we already trust comparisons between tensors, we're simply checking that
-  // the sugared versions are doing the same thing
-  Tensor<int, 3> t(6, 7, 5);
-
-  t.setRandom();
-  // make sure we have at least one value == 0
-  t(0, 0, 0) = 0;
-
-  Tensor<bool, 0> b;
-
-#define TEST_TENSOR_EQUAL(e1, e2) \
-  b = ((e1) == (e2)).all();       \
-  VERIFY(b())
-
-#define TEST_OP(op) TEST_TENSOR_EQUAL(t op 0, t op t.constant(0))
-
-  TEST_OP(==);
-  TEST_OP(!=);
-  TEST_OP(<=);
-  TEST_OP(>=);
-  TEST_OP(<);
-  TEST_OP(>);
-#undef TEST_OP
-#undef TEST_TENSOR_EQUAL
-}
-
-static void test_scalar_sugar_add_mul() {
-  Tensor<float, 3> A(6, 7, 5);
-  Tensor<float, 3> B(6, 7, 5);
-  A.setRandom();
-  B.setRandom();
-
-  const float alpha = 0.43f;
-  const float beta = 0.21f;
-  const float gamma = 0.14f;
-
-  Tensor<float, 3> R = A.constant(gamma) + A * A.constant(alpha) + B * B.constant(beta);
-  Tensor<float, 3> S = A * alpha + B * beta + gamma;
-  Tensor<float, 3> T = gamma + alpha * A + beta * B;
-
-  for (int i = 0; i < 6 * 7 * 5; ++i) {
-    VERIFY_IS_APPROX(R(i), S(i));
-    VERIFY_IS_APPROX(R(i), T(i));
-  }
-}
-
-static void test_scalar_sugar_sub_div() {
-  Tensor<float, 3> A(6, 7, 5);
-  Tensor<float, 3> B(6, 7, 5);
-  A.setRandom();
-  B.setRandom();
-
-  const float alpha = 0.43f;
-  const float beta = 0.21f;
-  const float gamma = 0.14f;
-  const float delta = 0.32f;
-
-  Tensor<float, 3> R = A.constant(gamma) - A / A.constant(alpha) - B.constant(beta) / B - A.constant(delta);
-  Tensor<float, 3> S = gamma - A / alpha - beta / B - delta;
-
-  for (int i = 0; i < 6 * 7 * 5; ++i) {
-    VERIFY_IS_APPROX(R(i), S(i));
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_sugar) {
-  CALL_SUBTEST(test_comparison_sugar());
-  CALL_SUBTEST(test_scalar_sugar_add_mul());
-  CALL_SUBTEST(test_scalar_sugar_sub_div());
-}
diff --git a/unsupported/test/cxx11_tensor_sycl.cpp b/unsupported/test/cxx11_tensor_sycl.cpp
deleted file mode 100644
index e772f6d..0000000
--- a/unsupported/test/cxx11_tensor_sycl.cpp
+++ /dev/null
@@ -1,348 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-// Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::SyclDevice;
-using Eigen::Tensor;
-using Eigen::TensorMap;
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_mem_transfers(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 5;
-  IndexType sizeDim2 = 5;
-  IndexType sizeDim3 = 1;
-  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out1(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out2(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out3(tensorRange);
-
-  in1 = in1.random();
-
-  DataType* gpu_data1 = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
-  DataType* gpu_data2 = static_cast<DataType*>(sycl_device.allocate(out1.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu1(gpu_data1, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu2(gpu_data2, tensorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data1, in1.data(), (in1.size()) * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_data2, in1.data(), (in1.size()) * sizeof(DataType));
-  gpu1.device(sycl_device) = gpu1 * 3.14f;
-  gpu2.device(sycl_device) = gpu2 * 2.7f;
-  sycl_device.memcpyDeviceToHost(out1.data(), gpu_data1, (out1.size()) * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out2.data(), gpu_data1, (out2.size()) * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out3.data(), gpu_data2, (out3.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-
-  for (IndexType i = 0; i < in1.size(); ++i) {
-    //  std::cout << "SYCL DATA : " << out1(i) << "  vs  CPU DATA : " << in1(i) * 3.14f << "\n";
-    VERIFY_IS_APPROX(out1(i), in1(i) * 3.14f);
-    VERIFY_IS_APPROX(out2(i), in1(i) * 3.14f);
-    VERIFY_IS_APPROX(out3(i), in1(i) * 2.7f);
-  }
-
-  sycl_device.deallocate(gpu_data1);
-  sycl_device.deallocate(gpu_data2);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_mem_sync(const Eigen::SyclDevice& sycl_device) {
-  IndexType size = 20;
-  array<IndexType, 1> tensorRange = {{size}};
-  Tensor<DataType, 1, DataLayout, IndexType> in1(tensorRange);
-  Tensor<DataType, 1, DataLayout, IndexType> in2(tensorRange);
-  Tensor<DataType, 1, DataLayout, IndexType> out(tensorRange);
-
-  in1 = in1.random();
-  in2 = in1;
-
-  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 1, DataLayout, IndexType>> gpu1(gpu_data, tensorRange);
-  sycl_device.memcpyHostToDevice(gpu_data, in1.data(), (in1.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-  in1.setZero();
-
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data, out.size() * sizeof(DataType));
-  sycl_device.synchronize();
-
-  for (IndexType i = 0; i < in1.size(); ++i) {
-    VERIFY_IS_APPROX(out(i), in2(i));
-  }
-
-  sycl_device.deallocate(gpu_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_mem_sync_offsets(const Eigen::SyclDevice& sycl_device) {
-  using tensor_type = Tensor<DataType, 1, DataLayout, IndexType>;
-  IndexType full_size = 32;
-  IndexType half_size = full_size / 2;
-  array<IndexType, 1> tensorRange = {{full_size}};
-  tensor_type in1(tensorRange);
-  tensor_type out(tensorRange);
-
-  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(full_size * sizeof(DataType)));
-  TensorMap<tensor_type> gpu1(gpu_data, tensorRange);
-
-  in1 = in1.random();
-  // Copy all data to device, then permute on copy back to host
-  sycl_device.memcpyHostToDevice(gpu_data, in1.data(), full_size * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data + half_size, half_size * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out.data() + half_size, gpu_data, half_size * sizeof(DataType));
-
-  for (IndexType i = 0; i < half_size; ++i) {
-    VERIFY_IS_APPROX(out(i), in1(i + half_size));
-    VERIFY_IS_APPROX(out(i + half_size), in1(i));
-  }
-
-  in1 = in1.random();
-  out.setZero();
-  // Permute copies to device, then copy all back to host
-  sycl_device.memcpyHostToDevice(gpu_data + half_size, in1.data(), half_size * sizeof(DataType));
-  sycl_device.memcpyHostToDevice(gpu_data, in1.data() + half_size, half_size * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data, full_size * sizeof(DataType));
-
-  for (IndexType i = 0; i < half_size; ++i) {
-    VERIFY_IS_APPROX(out(i), in1(i + half_size));
-    VERIFY_IS_APPROX(out(i + half_size), in1(i));
-  }
-
-  in1 = in1.random();
-  out.setZero();
-  DataType* gpu_data_out = static_cast<DataType*>(sycl_device.allocate(full_size * sizeof(DataType)));
-  TensorMap<tensor_type> gpu2(gpu_data_out, tensorRange);
-  // Copy all to device, permute copies on device, then copy all back to host
-  sycl_device.memcpyHostToDevice(gpu_data, in1.data(), full_size * sizeof(DataType));
-  sycl_device.memcpy(gpu_data_out + half_size, gpu_data, half_size * sizeof(DataType));
-  sycl_device.memcpy(gpu_data_out, gpu_data + half_size, half_size * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data_out, full_size * sizeof(DataType));
-
-  for (IndexType i = 0; i < half_size; ++i) {
-    VERIFY_IS_APPROX(out(i), in1(i + half_size));
-    VERIFY_IS_APPROX(out(i + half_size), in1(i));
-  }
-
-  sycl_device.deallocate(gpu_data_out);
-  sycl_device.deallocate(gpu_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_memset_offsets(const Eigen::SyclDevice& sycl_device) {
-  using tensor_type = Tensor<DataType, 1, DataLayout, IndexType>;
-  IndexType full_size = 32;
-  IndexType half_size = full_size / 2;
-  array<IndexType, 1> tensorRange = {{full_size}};
-  tensor_type cpu_out(tensorRange);
-  tensor_type out(tensorRange);
-
-  cpu_out.setZero();
-
-  std::memset(cpu_out.data(), 0, half_size * sizeof(DataType));
-  std::memset(cpu_out.data() + half_size, 1, half_size * sizeof(DataType));
-
-  DataType* gpu_data = static_cast<DataType*>(sycl_device.allocate(full_size * sizeof(DataType)));
-  TensorMap<tensor_type> gpu1(gpu_data, tensorRange);
-
-  sycl_device.memset(gpu_data, 0, half_size * sizeof(DataType));
-  sycl_device.memset(gpu_data + half_size, 1, half_size * sizeof(DataType));
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_data, full_size * sizeof(DataType));
-
-  for (IndexType i = 0; i < full_size; ++i) {
-    VERIFY_IS_APPROX(out(i), cpu_out(i));
-  }
-
-  sycl_device.deallocate(gpu_data);
-}
-
-template <typename DataType, int DataLayout, typename IndexType>
-void test_sycl_computations(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim1 = 100;
-  IndexType sizeDim2 = 10;
-  IndexType sizeDim3 = 20;
-  array<IndexType, 3> tensorRange = {{sizeDim1, sizeDim2, sizeDim3}};
-  Tensor<DataType, 3, DataLayout, IndexType> in1(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> in2(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> in3(tensorRange);
-  Tensor<DataType, 3, DataLayout, IndexType> out(tensorRange);
-
-  in2 = in2.random();
-  in3 = in3.random();
-
-  DataType* gpu_in1_data = static_cast<DataType*>(sycl_device.allocate(in1.size() * sizeof(DataType)));
-  DataType* gpu_in2_data = static_cast<DataType*>(sycl_device.allocate(in2.size() * sizeof(DataType)));
-  DataType* gpu_in3_data = static_cast<DataType*>(sycl_device.allocate(in3.size() * sizeof(DataType)));
-  DataType* gpu_out_data = static_cast<DataType*>(sycl_device.allocate(out.size() * sizeof(DataType)));
-
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in1(gpu_in1_data, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in2(gpu_in2_data, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_in3(gpu_in3_data, tensorRange);
-  TensorMap<Tensor<DataType, 3, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
-
-  /// a=1.2f
-  gpu_in1.device(sycl_device) = gpu_in1.constant(1.2f);
-  sycl_device.memcpyDeviceToHost(in1.data(), gpu_in1_data, (in1.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(in1(i, j, k), 1.2f);
-      }
-    }
-  }
-  printf("a=1.2f Test passed\n");
-
-  /// a=b*1.2f
-  gpu_out.device(sycl_device) = gpu_in1 * 1.2f;
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * 1.2f);
-      }
-    }
-  }
-  printf("a=b*1.2f Test Passed\n");
-
-  /// c=a*b
-  sycl_device.memcpyHostToDevice(gpu_in2_data, in2.data(), (in2.size()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = gpu_in1 * gpu_in2;
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * in2(i, j, k));
-      }
-    }
-  }
-  printf("c=a*b Test Passed\n");
-
-  /// c=a+b
-  gpu_out.device(sycl_device) = gpu_in1 + gpu_in2;
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k));
-      }
-    }
-  }
-  printf("c=a+b Test Passed\n");
-
-  /// c=a*a
-  gpu_out.device(sycl_device) = gpu_in1 * gpu_in1;
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * in1(i, j, k));
-      }
-    }
-  }
-  printf("c= a*a Test Passed\n");
-
-  // a*3.14f + b*2.7f
-  gpu_out.device(sycl_device) = gpu_in1 * gpu_in1.constant(3.14f) + gpu_in2 * gpu_in2.constant(2.7f);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) * 3.14f + in2(i, j, k) * 2.7f);
-      }
-    }
-  }
-  printf("a*3.14f + b*2.7f Test Passed\n");
-
-  /// d= (a>0.5? b:c)
-  sycl_device.memcpyHostToDevice(gpu_in3_data, in3.data(), (in3.size()) * sizeof(DataType));
-  gpu_out.device(sycl_device) = (gpu_in1 > gpu_in1.constant(0.5f)).select(gpu_in2, gpu_in3);
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, (out.size()) * sizeof(DataType));
-  sycl_device.synchronize();
-  for (IndexType i = 0; i < sizeDim1; ++i) {
-    for (IndexType j = 0; j < sizeDim2; ++j) {
-      for (IndexType k = 0; k < sizeDim3; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), (in1(i, j, k) > 0.5f) ? in2(i, j, k) : in3(i, j, k));
-      }
-    }
-  }
-  printf("d= (a>0.5? b:c) Test Passed\n");
-  sycl_device.deallocate(gpu_in1_data);
-  sycl_device.deallocate(gpu_in2_data);
-  sycl_device.deallocate(gpu_in3_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-template <typename Scalar1, typename Scalar2, int DataLayout, typename IndexType>
-static void test_sycl_cast(const Eigen::SyclDevice& sycl_device) {
-  IndexType size = 20;
-  array<IndexType, 1> tensorRange = {{size}};
-  Tensor<Scalar1, 1, DataLayout, IndexType> in(tensorRange);
-  Tensor<Scalar2, 1, DataLayout, IndexType> out(tensorRange);
-  Tensor<Scalar2, 1, DataLayout, IndexType> out_host(tensorRange);
-
-  in = in.random();
-
-  Scalar1* gpu_in_data = static_cast<Scalar1*>(sycl_device.allocate(in.size() * sizeof(Scalar1)));
-  Scalar2* gpu_out_data = static_cast<Scalar2*>(sycl_device.allocate(out.size() * sizeof(Scalar2)));
-
-  TensorMap<Tensor<Scalar1, 1, DataLayout, IndexType>> gpu_in(gpu_in_data, tensorRange);
-  TensorMap<Tensor<Scalar2, 1, DataLayout, IndexType>> gpu_out(gpu_out_data, tensorRange);
-  sycl_device.memcpyHostToDevice(gpu_in_data, in.data(), (in.size()) * sizeof(Scalar1));
-  gpu_out.device(sycl_device) = gpu_in.template cast<Scalar2>();
-  sycl_device.memcpyDeviceToHost(out.data(), gpu_out_data, out.size() * sizeof(Scalar2));
-  out_host = in.template cast<Scalar2>();
-  for (IndexType i = 0; i < size; i++) {
-    VERIFY_IS_APPROX(out(i), out_host(i));
-  }
-  printf("cast Test Passed\n");
-  sycl_device.deallocate(gpu_in_data);
-  sycl_device.deallocate(gpu_out_data);
-}
-template <typename DataType, typename dev_Selector>
-void sycl_computing_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  test_sycl_mem_transfers<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_computations<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_mem_sync<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_mem_sync_offsets<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_memset_offsets<DataType, RowMajor, int64_t>(sycl_device);
-  test_sycl_mem_transfers<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_computations<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_mem_sync<DataType, ColMajor, int64_t>(sycl_device);
-  test_sycl_cast<DataType, int, RowMajor, int64_t>(sycl_device);
-  test_sycl_cast<DataType, int, ColMajor, int64_t>(sycl_device);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_computing_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/cxx11_tensor_symmetry.cpp b/unsupported/test/cxx11_tensor_symmetry.cpp
deleted file mode 100644
index e1a1472..0000000
--- a/unsupported/test/cxx11_tensor_symmetry.cpp
+++ /dev/null
@@ -1,799 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2013 Christian Seiler <christian@iwakd.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-#include <Eigen/TensorSymmetry>
-
-#include <map>
-#include <set>
-
-using Eigen::AntiHermiticity;
-using Eigen::AntiSymmetry;
-using Eigen::DynamicSGroup;
-using Eigen::Hermiticity;
-using Eigen::SGroup;
-using Eigen::StaticSGroup;
-using Eigen::Symmetry;
-using Eigen::Tensor;
-
-using Eigen::ConjugationFlag;
-using Eigen::GlobalImagFlag;
-using Eigen::GlobalRealFlag;
-using Eigen::GlobalZeroFlag;
-using Eigen::NegationFlag;
-
-// helper function to determine if the compiler instantiated a static
-// or dynamic symmetry group
-template <typename... Sym>
-bool isDynGroup(StaticSGroup<Sym...> const& dummy) {
-  (void)dummy;
-  return false;
-}
-
-bool isDynGroup(DynamicSGroup const& dummy) {
-  (void)dummy;
-  return true;
-}
-
-// helper class for checking that the symmetry groups are correct
-struct checkIdx {
-  template <typename ArrType>
-  static inline int doCheck_(ArrType e, int flags, int dummy, std::set<uint64_t>& found,
-                             std::map<uint64_t, int> const& expected) {
-    // use decimal representation of value
-    uint64_t value = e[0];
-    for (std::size_t i = 1; i < e.size(); i++) value = value * 10 + e[i];
-
-    // we want to make sure that we find each element
-    auto it = expected.find(value);
-    VERIFY((it != expected.end()));
-    VERIFY_IS_EQUAL(it->second, flags);
-
-    // we want to make sure we only have each element once;
-    // set::insert returns true for the second part of the pair
-    // if the element was really inserted and not already there
-    auto p = found.insert(value);
-    VERIFY((p.second));
-
-    return dummy;
-  }
-
-  static inline int run(std::vector<int> e, int flags, int dummy, std::set<uint64_t>& found,
-                        std::map<uint64_t, int> const& expected) {
-    return doCheck_(e, flags, dummy, found, expected);
-  }
-
-  template <std::size_t N>
-  static inline int run(std::array<int, N> e, int flags, int dummy, std::set<uint64_t>& found,
-                        std::map<uint64_t, int> const& expected) {
-    return doCheck_(e, flags, dummy, found, expected);
-  }
-};
-
-static void test_symgroups_static() {
-  std::array<int, 7> identity{{0, 1, 2, 3, 4, 5, 6}};
-
-  // Simple static symmetry group
-  StaticSGroup<AntiSymmetry<0, 1>, Hermiticity<0, 2>> group;
-
-  std::set<uint64_t> found;
-  std::map<uint64_t, int> expected;
-  expected[123456] = 0;
-  expected[1023456] = NegationFlag;
-  expected[2103456] = ConjugationFlag;
-  expected[1203456] = ConjugationFlag | NegationFlag;
-  expected[2013456] = ConjugationFlag | NegationFlag;
-  expected[213456] = ConjugationFlag;
-
-  VERIFY_IS_EQUAL(group.size(), 6u);
-  VERIFY_IS_EQUAL(group.globalFlags(), GlobalImagFlag);
-  group.apply<checkIdx, int>(identity, 0, found, expected);
-  VERIFY_IS_EQUAL(found.size(), 6u);
-}
-
-static void test_symgroups_dynamic() {
-  std::vector<int> identity;
-  for (int i = 0; i <= 6; i++) identity.push_back(i);
-
-  // Simple dynamic symmetry group
-  DynamicSGroup group;
-  group.add(0, 1, NegationFlag);
-  group.add(0, 2, ConjugationFlag);
-
-  VERIFY_IS_EQUAL(group.size(), 6u);
-  VERIFY_IS_EQUAL(group.globalFlags(), GlobalImagFlag);
-
-  std::set<uint64_t> found;
-  std::map<uint64_t, int> expected;
-  expected[123456] = 0;
-  expected[1023456] = NegationFlag;
-  expected[2103456] = ConjugationFlag;
-  expected[1203456] = ConjugationFlag | NegationFlag;
-  expected[2013456] = ConjugationFlag | NegationFlag;
-  expected[213456] = ConjugationFlag;
-
-  VERIFY_IS_EQUAL(group.size(), 6u);
-  VERIFY_IS_EQUAL(group.globalFlags(), GlobalImagFlag);
-  group.apply<checkIdx, int>(identity, 0, found, expected);
-  VERIFY_IS_EQUAL(found.size(), 6u);
-}
-
-static void test_symgroups_selection() {
-  std::array<int, 7> identity7{{0, 1, 2, 3, 4, 5, 6}};
-  std::array<int, 10> identity10{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
-
-  {
-    // Do the same test as in test_symgroups_static but
-    // require selection via SGroup
-    SGroup<AntiSymmetry<0, 1>, Hermiticity<0, 2>> group;
-
-    std::set<uint64_t> found;
-    std::map<uint64_t, int> expected;
-    expected[123456] = 0;
-    expected[1023456] = NegationFlag;
-    expected[2103456] = ConjugationFlag;
-    expected[1203456] = ConjugationFlag | NegationFlag;
-    expected[2013456] = ConjugationFlag | NegationFlag;
-    expected[213456] = ConjugationFlag;
-
-    VERIFY(!isDynGroup(group));
-    VERIFY_IS_EQUAL(group.size(), 6u);
-    VERIFY_IS_EQUAL(group.globalFlags(), GlobalImagFlag);
-    group.apply<checkIdx, int>(identity7, 0, found, expected);
-    VERIFY_IS_EQUAL(found.size(), 6u);
-  }
-
-  {
-    // simple factorizing group: 5 generators, 2^5 = 32 elements
-    // selection should make this dynamic, although static group
-    // can still be reasonably generated
-    SGroup<Symmetry<0, 1>, Symmetry<2, 3>, Symmetry<4, 5>, Symmetry<6, 7>, Symmetry<8, 9>> group;
-
-    std::set<uint64_t> found;
-    std::map<uint64_t, int> expected;
-    expected[123456789] = 0;
-    expected[123456798] = 0;
-    expected[123457689] = 0;
-    expected[123457698] = 0;
-    expected[123546789] = 0;
-    expected[123546798] = 0;
-    expected[123547689] = 0;
-    expected[123547698] = 0;
-    expected[132456789] = 0;
-    expected[132456798] = 0;
-    expected[132457689] = 0;
-    expected[132457698] = 0;
-    expected[132546789] = 0;
-    expected[132546798] = 0;
-    expected[132547689] = 0;
-    expected[132547698] = 0;
-    expected[1023456789] = 0;
-    expected[1023456798] = 0;
-    expected[1023457689] = 0;
-    expected[1023457698] = 0;
-    expected[1023546789] = 0;
-    expected[1023546798] = 0;
-    expected[1023547689] = 0;
-    expected[1023547698] = 0;
-    expected[1032456789] = 0;
-    expected[1032456798] = 0;
-    expected[1032457689] = 0;
-    expected[1032457698] = 0;
-    expected[1032546789] = 0;
-    expected[1032546798] = 0;
-    expected[1032547689] = 0;
-    expected[1032547698] = 0;
-
-    VERIFY(isDynGroup(group));
-    VERIFY_IS_EQUAL(group.size(), 32u);
-    VERIFY_IS_EQUAL(group.globalFlags(), 0);
-    group.apply<checkIdx, int>(identity10, 0, found, expected);
-    VERIFY_IS_EQUAL(found.size(), 32u);
-
-    // no verify that we could also generate a static group
-    // with these generators
-    found.clear();
-    StaticSGroup<Symmetry<0, 1>, Symmetry<2, 3>, Symmetry<4, 5>, Symmetry<6, 7>, Symmetry<8, 9>> group_static;
-    VERIFY_IS_EQUAL(group_static.size(), 32u);
-    VERIFY_IS_EQUAL(group_static.globalFlags(), 0);
-    group_static.apply<checkIdx, int>(identity10, 0, found, expected);
-    VERIFY_IS_EQUAL(found.size(), 32u);
-  }
-
-  {
-    // try to create a HUGE group
-    SGroup<Symmetry<0, 1>, Symmetry<1, 2>, Symmetry<2, 3>, Symmetry<3, 4>, Symmetry<4, 5>, Symmetry<5, 6>> group;
-
-    std::set<uint64_t> found;
-    uint64_t pre_expected[5040] = {
-        123456,  1023456, 213456,  2013456, 1203456, 2103456, 132456,  1032456, 312456,  3012456, 1302456, 3102456,
-        231456,  2031456, 321456,  3021456, 2301456, 3201456, 1230456, 2130456, 1320456, 3120456, 2310456, 3210456,
-        124356,  1024356, 214356,  2014356, 1204356, 2104356, 142356,  1042356, 412356,  4012356, 1402356, 4102356,
-        241356,  2041356, 421356,  4021356, 2401356, 4201356, 1240356, 2140356, 1420356, 4120356, 2410356, 4210356,
-        134256,  1034256, 314256,  3014256, 1304256, 3104256, 143256,  1043256, 413256,  4013256, 1403256, 4103256,
-        341256,  3041256, 431256,  4031256, 3401256, 4301256, 1340256, 3140256, 1430256, 4130256, 3410256, 4310256,
-        234156,  2034156, 324156,  3024156, 2304156, 3204156, 243156,  2043156, 423156,  4023156, 2403156, 4203156,
-        342156,  3042156, 432156,  4032156, 3402156, 4302156, 2340156, 3240156, 2430156, 4230156, 3420156, 4320156,
-        1234056, 2134056, 1324056, 3124056, 2314056, 3214056, 1243056, 2143056, 1423056, 4123056, 2413056, 4213056,
-        1342056, 3142056, 1432056, 4132056, 3412056, 4312056, 2341056, 3241056, 2431056, 4231056, 3421056, 4321056,
-        123546,  1023546, 213546,  2013546, 1203546, 2103546, 132546,  1032546, 312546,  3012546, 1302546, 3102546,
-        231546,  2031546, 321546,  3021546, 2301546, 3201546, 1230546, 2130546, 1320546, 3120546, 2310546, 3210546,
-        125346,  1025346, 215346,  2015346, 1205346, 2105346, 152346,  1052346, 512346,  5012346, 1502346, 5102346,
-        251346,  2051346, 521346,  5021346, 2501346, 5201346, 1250346, 2150346, 1520346, 5120346, 2510346, 5210346,
-        135246,  1035246, 315246,  3015246, 1305246, 3105246, 153246,  1053246, 513246,  5013246, 1503246, 5103246,
-        351246,  3051246, 531246,  5031246, 3501246, 5301246, 1350246, 3150246, 1530246, 5130246, 3510246, 5310246,
-        235146,  2035146, 325146,  3025146, 2305146, 3205146, 253146,  2053146, 523146,  5023146, 2503146, 5203146,
-        352146,  3052146, 532146,  5032146, 3502146, 5302146, 2350146, 3250146, 2530146, 5230146, 3520146, 5320146,
-        1235046, 2135046, 1325046, 3125046, 2315046, 3215046, 1253046, 2153046, 1523046, 5123046, 2513046, 5213046,
-        1352046, 3152046, 1532046, 5132046, 3512046, 5312046, 2351046, 3251046, 2531046, 5231046, 3521046, 5321046,
-        124536,  1024536, 214536,  2014536, 1204536, 2104536, 142536,  1042536, 412536,  4012536, 1402536, 4102536,
-        241536,  2041536, 421536,  4021536, 2401536, 4201536, 1240536, 2140536, 1420536, 4120536, 2410536, 4210536,
-        125436,  1025436, 215436,  2015436, 1205436, 2105436, 152436,  1052436, 512436,  5012436, 1502436, 5102436,
-        251436,  2051436, 521436,  5021436, 2501436, 5201436, 1250436, 2150436, 1520436, 5120436, 2510436, 5210436,
-        145236,  1045236, 415236,  4015236, 1405236, 4105236, 154236,  1054236, 514236,  5014236, 1504236, 5104236,
-        451236,  4051236, 541236,  5041236, 4501236, 5401236, 1450236, 4150236, 1540236, 5140236, 4510236, 5410236,
-        245136,  2045136, 425136,  4025136, 2405136, 4205136, 254136,  2054136, 524136,  5024136, 2504136, 5204136,
-        452136,  4052136, 542136,  5042136, 4502136, 5402136, 2450136, 4250136, 2540136, 5240136, 4520136, 5420136,
-        1245036, 2145036, 1425036, 4125036, 2415036, 4215036, 1254036, 2154036, 1524036, 5124036, 2514036, 5214036,
-        1452036, 4152036, 1542036, 5142036, 4512036, 5412036, 2451036, 4251036, 2541036, 5241036, 4521036, 5421036,
-        134526,  1034526, 314526,  3014526, 1304526, 3104526, 143526,  1043526, 413526,  4013526, 1403526, 4103526,
-        341526,  3041526, 431526,  4031526, 3401526, 4301526, 1340526, 3140526, 1430526, 4130526, 3410526, 4310526,
-        135426,  1035426, 315426,  3015426, 1305426, 3105426, 153426,  1053426, 513426,  5013426, 1503426, 5103426,
-        351426,  3051426, 531426,  5031426, 3501426, 5301426, 1350426, 3150426, 1530426, 5130426, 3510426, 5310426,
-        145326,  1045326, 415326,  4015326, 1405326, 4105326, 154326,  1054326, 514326,  5014326, 1504326, 5104326,
-        451326,  4051326, 541326,  5041326, 4501326, 5401326, 1450326, 4150326, 1540326, 5140326, 4510326, 5410326,
-        345126,  3045126, 435126,  4035126, 3405126, 4305126, 354126,  3054126, 534126,  5034126, 3504126, 5304126,
-        453126,  4053126, 543126,  5043126, 4503126, 5403126, 3450126, 4350126, 3540126, 5340126, 4530126, 5430126,
-        1345026, 3145026, 1435026, 4135026, 3415026, 4315026, 1354026, 3154026, 1534026, 5134026, 3514026, 5314026,
-        1453026, 4153026, 1543026, 5143026, 4513026, 5413026, 3451026, 4351026, 3541026, 5341026, 4531026, 5431026,
-        234516,  2034516, 324516,  3024516, 2304516, 3204516, 243516,  2043516, 423516,  4023516, 2403516, 4203516,
-        342516,  3042516, 432516,  4032516, 3402516, 4302516, 2340516, 3240516, 2430516, 4230516, 3420516, 4320516,
-        235416,  2035416, 325416,  3025416, 2305416, 3205416, 253416,  2053416, 523416,  5023416, 2503416, 5203416,
-        352416,  3052416, 532416,  5032416, 3502416, 5302416, 2350416, 3250416, 2530416, 5230416, 3520416, 5320416,
-        245316,  2045316, 425316,  4025316, 2405316, 4205316, 254316,  2054316, 524316,  5024316, 2504316, 5204316,
-        452316,  4052316, 542316,  5042316, 4502316, 5402316, 2450316, 4250316, 2540316, 5240316, 4520316, 5420316,
-        345216,  3045216, 435216,  4035216, 3405216, 4305216, 354216,  3054216, 534216,  5034216, 3504216, 5304216,
-        453216,  4053216, 543216,  5043216, 4503216, 5403216, 3450216, 4350216, 3540216, 5340216, 4530216, 5430216,
-        2345016, 3245016, 2435016, 4235016, 3425016, 4325016, 2354016, 3254016, 2534016, 5234016, 3524016, 5324016,
-        2453016, 4253016, 2543016, 5243016, 4523016, 5423016, 3452016, 4352016, 3542016, 5342016, 4532016, 5432016,
-        1234506, 2134506, 1324506, 3124506, 2314506, 3214506, 1243506, 2143506, 1423506, 4123506, 2413506, 4213506,
-        1342506, 3142506, 1432506, 4132506, 3412506, 4312506, 2341506, 3241506, 2431506, 4231506, 3421506, 4321506,
-        1235406, 2135406, 1325406, 3125406, 2315406, 3215406, 1253406, 2153406, 1523406, 5123406, 2513406, 5213406,
-        1352406, 3152406, 1532406, 5132406, 3512406, 5312406, 2351406, 3251406, 2531406, 5231406, 3521406, 5321406,
-        1245306, 2145306, 1425306, 4125306, 2415306, 4215306, 1254306, 2154306, 1524306, 5124306, 2514306, 5214306,
-        1452306, 4152306, 1542306, 5142306, 4512306, 5412306, 2451306, 4251306, 2541306, 5241306, 4521306, 5421306,
-        1345206, 3145206, 1435206, 4135206, 3415206, 4315206, 1354206, 3154206, 1534206, 5134206, 3514206, 5314206,
-        1453206, 4153206, 1543206, 5143206, 4513206, 5413206, 3451206, 4351206, 3541206, 5341206, 4531206, 5431206,
-        2345106, 3245106, 2435106, 4235106, 3425106, 4325106, 2354106, 3254106, 2534106, 5234106, 3524106, 5324106,
-        2453106, 4253106, 2543106, 5243106, 4523106, 5423106, 3452106, 4352106, 3542106, 5342106, 4532106, 5432106,
-        123465,  1023465, 213465,  2013465, 1203465, 2103465, 132465,  1032465, 312465,  3012465, 1302465, 3102465,
-        231465,  2031465, 321465,  3021465, 2301465, 3201465, 1230465, 2130465, 1320465, 3120465, 2310465, 3210465,
-        124365,  1024365, 214365,  2014365, 1204365, 2104365, 142365,  1042365, 412365,  4012365, 1402365, 4102365,
-        241365,  2041365, 421365,  4021365, 2401365, 4201365, 1240365, 2140365, 1420365, 4120365, 2410365, 4210365,
-        134265,  1034265, 314265,  3014265, 1304265, 3104265, 143265,  1043265, 413265,  4013265, 1403265, 4103265,
-        341265,  3041265, 431265,  4031265, 3401265, 4301265, 1340265, 3140265, 1430265, 4130265, 3410265, 4310265,
-        234165,  2034165, 324165,  3024165, 2304165, 3204165, 243165,  2043165, 423165,  4023165, 2403165, 4203165,
-        342165,  3042165, 432165,  4032165, 3402165, 4302165, 2340165, 3240165, 2430165, 4230165, 3420165, 4320165,
-        1234065, 2134065, 1324065, 3124065, 2314065, 3214065, 1243065, 2143065, 1423065, 4123065, 2413065, 4213065,
-        1342065, 3142065, 1432065, 4132065, 3412065, 4312065, 2341065, 3241065, 2431065, 4231065, 3421065, 4321065,
-        123645,  1023645, 213645,  2013645, 1203645, 2103645, 132645,  1032645, 312645,  3012645, 1302645, 3102645,
-        231645,  2031645, 321645,  3021645, 2301645, 3201645, 1230645, 2130645, 1320645, 3120645, 2310645, 3210645,
-        126345,  1026345, 216345,  2016345, 1206345, 2106345, 162345,  1062345, 612345,  6012345, 1602345, 6102345,
-        261345,  2061345, 621345,  6021345, 2601345, 6201345, 1260345, 2160345, 1620345, 6120345, 2610345, 6210345,
-        136245,  1036245, 316245,  3016245, 1306245, 3106245, 163245,  1063245, 613245,  6013245, 1603245, 6103245,
-        361245,  3061245, 631245,  6031245, 3601245, 6301245, 1360245, 3160245, 1630245, 6130245, 3610245, 6310245,
-        236145,  2036145, 326145,  3026145, 2306145, 3206145, 263145,  2063145, 623145,  6023145, 2603145, 6203145,
-        362145,  3062145, 632145,  6032145, 3602145, 6302145, 2360145, 3260145, 2630145, 6230145, 3620145, 6320145,
-        1236045, 2136045, 1326045, 3126045, 2316045, 3216045, 1263045, 2163045, 1623045, 6123045, 2613045, 6213045,
-        1362045, 3162045, 1632045, 6132045, 3612045, 6312045, 2361045, 3261045, 2631045, 6231045, 3621045, 6321045,
-        124635,  1024635, 214635,  2014635, 1204635, 2104635, 142635,  1042635, 412635,  4012635, 1402635, 4102635,
-        241635,  2041635, 421635,  4021635, 2401635, 4201635, 1240635, 2140635, 1420635, 4120635, 2410635, 4210635,
-        126435,  1026435, 216435,  2016435, 1206435, 2106435, 162435,  1062435, 612435,  6012435, 1602435, 6102435,
-        261435,  2061435, 621435,  6021435, 2601435, 6201435, 1260435, 2160435, 1620435, 6120435, 2610435, 6210435,
-        146235,  1046235, 416235,  4016235, 1406235, 4106235, 164235,  1064235, 614235,  6014235, 1604235, 6104235,
-        461235,  4061235, 641235,  6041235, 4601235, 6401235, 1460235, 4160235, 1640235, 6140235, 4610235, 6410235,
-        246135,  2046135, 426135,  4026135, 2406135, 4206135, 264135,  2064135, 624135,  6024135, 2604135, 6204135,
-        462135,  4062135, 642135,  6042135, 4602135, 6402135, 2460135, 4260135, 2640135, 6240135, 4620135, 6420135,
-        1246035, 2146035, 1426035, 4126035, 2416035, 4216035, 1264035, 2164035, 1624035, 6124035, 2614035, 6214035,
-        1462035, 4162035, 1642035, 6142035, 4612035, 6412035, 2461035, 4261035, 2641035, 6241035, 4621035, 6421035,
-        134625,  1034625, 314625,  3014625, 1304625, 3104625, 143625,  1043625, 413625,  4013625, 1403625, 4103625,
-        341625,  3041625, 431625,  4031625, 3401625, 4301625, 1340625, 3140625, 1430625, 4130625, 3410625, 4310625,
-        136425,  1036425, 316425,  3016425, 1306425, 3106425, 163425,  1063425, 613425,  6013425, 1603425, 6103425,
-        361425,  3061425, 631425,  6031425, 3601425, 6301425, 1360425, 3160425, 1630425, 6130425, 3610425, 6310425,
-        146325,  1046325, 416325,  4016325, 1406325, 4106325, 164325,  1064325, 614325,  6014325, 1604325, 6104325,
-        461325,  4061325, 641325,  6041325, 4601325, 6401325, 1460325, 4160325, 1640325, 6140325, 4610325, 6410325,
-        346125,  3046125, 436125,  4036125, 3406125, 4306125, 364125,  3064125, 634125,  6034125, 3604125, 6304125,
-        463125,  4063125, 643125,  6043125, 4603125, 6403125, 3460125, 4360125, 3640125, 6340125, 4630125, 6430125,
-        1346025, 3146025, 1436025, 4136025, 3416025, 4316025, 1364025, 3164025, 1634025, 6134025, 3614025, 6314025,
-        1463025, 4163025, 1643025, 6143025, 4613025, 6413025, 3461025, 4361025, 3641025, 6341025, 4631025, 6431025,
-        234615,  2034615, 324615,  3024615, 2304615, 3204615, 243615,  2043615, 423615,  4023615, 2403615, 4203615,
-        342615,  3042615, 432615,  4032615, 3402615, 4302615, 2340615, 3240615, 2430615, 4230615, 3420615, 4320615,
-        236415,  2036415, 326415,  3026415, 2306415, 3206415, 263415,  2063415, 623415,  6023415, 2603415, 6203415,
-        362415,  3062415, 632415,  6032415, 3602415, 6302415, 2360415, 3260415, 2630415, 6230415, 3620415, 6320415,
-        246315,  2046315, 426315,  4026315, 2406315, 4206315, 264315,  2064315, 624315,  6024315, 2604315, 6204315,
-        462315,  4062315, 642315,  6042315, 4602315, 6402315, 2460315, 4260315, 2640315, 6240315, 4620315, 6420315,
-        346215,  3046215, 436215,  4036215, 3406215, 4306215, 364215,  3064215, 634215,  6034215, 3604215, 6304215,
-        463215,  4063215, 643215,  6043215, 4603215, 6403215, 3460215, 4360215, 3640215, 6340215, 4630215, 6430215,
-        2346015, 3246015, 2436015, 4236015, 3426015, 4326015, 2364015, 3264015, 2634015, 6234015, 3624015, 6324015,
-        2463015, 4263015, 2643015, 6243015, 4623015, 6423015, 3462015, 4362015, 3642015, 6342015, 4632015, 6432015,
-        1234605, 2134605, 1324605, 3124605, 2314605, 3214605, 1243605, 2143605, 1423605, 4123605, 2413605, 4213605,
-        1342605, 3142605, 1432605, 4132605, 3412605, 4312605, 2341605, 3241605, 2431605, 4231605, 3421605, 4321605,
-        1236405, 2136405, 1326405, 3126405, 2316405, 3216405, 1263405, 2163405, 1623405, 6123405, 2613405, 6213405,
-        1362405, 3162405, 1632405, 6132405, 3612405, 6312405, 2361405, 3261405, 2631405, 6231405, 3621405, 6321405,
-        1246305, 2146305, 1426305, 4126305, 2416305, 4216305, 1264305, 2164305, 1624305, 6124305, 2614305, 6214305,
-        1462305, 4162305, 1642305, 6142305, 4612305, 6412305, 2461305, 4261305, 2641305, 6241305, 4621305, 6421305,
-        1346205, 3146205, 1436205, 4136205, 3416205, 4316205, 1364205, 3164205, 1634205, 6134205, 3614205, 6314205,
-        1463205, 4163205, 1643205, 6143205, 4613205, 6413205, 3461205, 4361205, 3641205, 6341205, 4631205, 6431205,
-        2346105, 3246105, 2436105, 4236105, 3426105, 4326105, 2364105, 3264105, 2634105, 6234105, 3624105, 6324105,
-        2463105, 4263105, 2643105, 6243105, 4623105, 6423105, 3462105, 4362105, 3642105, 6342105, 4632105, 6432105,
-        123564,  1023564, 213564,  2013564, 1203564, 2103564, 132564,  1032564, 312564,  3012564, 1302564, 3102564,
-        231564,  2031564, 321564,  3021564, 2301564, 3201564, 1230564, 2130564, 1320564, 3120564, 2310564, 3210564,
-        125364,  1025364, 215364,  2015364, 1205364, 2105364, 152364,  1052364, 512364,  5012364, 1502364, 5102364,
-        251364,  2051364, 521364,  5021364, 2501364, 5201364, 1250364, 2150364, 1520364, 5120364, 2510364, 5210364,
-        135264,  1035264, 315264,  3015264, 1305264, 3105264, 153264,  1053264, 513264,  5013264, 1503264, 5103264,
-        351264,  3051264, 531264,  5031264, 3501264, 5301264, 1350264, 3150264, 1530264, 5130264, 3510264, 5310264,
-        235164,  2035164, 325164,  3025164, 2305164, 3205164, 253164,  2053164, 523164,  5023164, 2503164, 5203164,
-        352164,  3052164, 532164,  5032164, 3502164, 5302164, 2350164, 3250164, 2530164, 5230164, 3520164, 5320164,
-        1235064, 2135064, 1325064, 3125064, 2315064, 3215064, 1253064, 2153064, 1523064, 5123064, 2513064, 5213064,
-        1352064, 3152064, 1532064, 5132064, 3512064, 5312064, 2351064, 3251064, 2531064, 5231064, 3521064, 5321064,
-        123654,  1023654, 213654,  2013654, 1203654, 2103654, 132654,  1032654, 312654,  3012654, 1302654, 3102654,
-        231654,  2031654, 321654,  3021654, 2301654, 3201654, 1230654, 2130654, 1320654, 3120654, 2310654, 3210654,
-        126354,  1026354, 216354,  2016354, 1206354, 2106354, 162354,  1062354, 612354,  6012354, 1602354, 6102354,
-        261354,  2061354, 621354,  6021354, 2601354, 6201354, 1260354, 2160354, 1620354, 6120354, 2610354, 6210354,
-        136254,  1036254, 316254,  3016254, 1306254, 3106254, 163254,  1063254, 613254,  6013254, 1603254, 6103254,
-        361254,  3061254, 631254,  6031254, 3601254, 6301254, 1360254, 3160254, 1630254, 6130254, 3610254, 6310254,
-        236154,  2036154, 326154,  3026154, 2306154, 3206154, 263154,  2063154, 623154,  6023154, 2603154, 6203154,
-        362154,  3062154, 632154,  6032154, 3602154, 6302154, 2360154, 3260154, 2630154, 6230154, 3620154, 6320154,
-        1236054, 2136054, 1326054, 3126054, 2316054, 3216054, 1263054, 2163054, 1623054, 6123054, 2613054, 6213054,
-        1362054, 3162054, 1632054, 6132054, 3612054, 6312054, 2361054, 3261054, 2631054, 6231054, 3621054, 6321054,
-        125634,  1025634, 215634,  2015634, 1205634, 2105634, 152634,  1052634, 512634,  5012634, 1502634, 5102634,
-        251634,  2051634, 521634,  5021634, 2501634, 5201634, 1250634, 2150634, 1520634, 5120634, 2510634, 5210634,
-        126534,  1026534, 216534,  2016534, 1206534, 2106534, 162534,  1062534, 612534,  6012534, 1602534, 6102534,
-        261534,  2061534, 621534,  6021534, 2601534, 6201534, 1260534, 2160534, 1620534, 6120534, 2610534, 6210534,
-        156234,  1056234, 516234,  5016234, 1506234, 5106234, 165234,  1065234, 615234,  6015234, 1605234, 6105234,
-        561234,  5061234, 651234,  6051234, 5601234, 6501234, 1560234, 5160234, 1650234, 6150234, 5610234, 6510234,
-        256134,  2056134, 526134,  5026134, 2506134, 5206134, 265134,  2065134, 625134,  6025134, 2605134, 6205134,
-        562134,  5062134, 652134,  6052134, 5602134, 6502134, 2560134, 5260134, 2650134, 6250134, 5620134, 6520134,
-        1256034, 2156034, 1526034, 5126034, 2516034, 5216034, 1265034, 2165034, 1625034, 6125034, 2615034, 6215034,
-        1562034, 5162034, 1652034, 6152034, 5612034, 6512034, 2561034, 5261034, 2651034, 6251034, 5621034, 6521034,
-        135624,  1035624, 315624,  3015624, 1305624, 3105624, 153624,  1053624, 513624,  5013624, 1503624, 5103624,
-        351624,  3051624, 531624,  5031624, 3501624, 5301624, 1350624, 3150624, 1530624, 5130624, 3510624, 5310624,
-        136524,  1036524, 316524,  3016524, 1306524, 3106524, 163524,  1063524, 613524,  6013524, 1603524, 6103524,
-        361524,  3061524, 631524,  6031524, 3601524, 6301524, 1360524, 3160524, 1630524, 6130524, 3610524, 6310524,
-        156324,  1056324, 516324,  5016324, 1506324, 5106324, 165324,  1065324, 615324,  6015324, 1605324, 6105324,
-        561324,  5061324, 651324,  6051324, 5601324, 6501324, 1560324, 5160324, 1650324, 6150324, 5610324, 6510324,
-        356124,  3056124, 536124,  5036124, 3506124, 5306124, 365124,  3065124, 635124,  6035124, 3605124, 6305124,
-        563124,  5063124, 653124,  6053124, 5603124, 6503124, 3560124, 5360124, 3650124, 6350124, 5630124, 6530124,
-        1356024, 3156024, 1536024, 5136024, 3516024, 5316024, 1365024, 3165024, 1635024, 6135024, 3615024, 6315024,
-        1563024, 5163024, 1653024, 6153024, 5613024, 6513024, 3561024, 5361024, 3651024, 6351024, 5631024, 6531024,
-        235614,  2035614, 325614,  3025614, 2305614, 3205614, 253614,  2053614, 523614,  5023614, 2503614, 5203614,
-        352614,  3052614, 532614,  5032614, 3502614, 5302614, 2350614, 3250614, 2530614, 5230614, 3520614, 5320614,
-        236514,  2036514, 326514,  3026514, 2306514, 3206514, 263514,  2063514, 623514,  6023514, 2603514, 6203514,
-        362514,  3062514, 632514,  6032514, 3602514, 6302514, 2360514, 3260514, 2630514, 6230514, 3620514, 6320514,
-        256314,  2056314, 526314,  5026314, 2506314, 5206314, 265314,  2065314, 625314,  6025314, 2605314, 6205314,
-        562314,  5062314, 652314,  6052314, 5602314, 6502314, 2560314, 5260314, 2650314, 6250314, 5620314, 6520314,
-        356214,  3056214, 536214,  5036214, 3506214, 5306214, 365214,  3065214, 635214,  6035214, 3605214, 6305214,
-        563214,  5063214, 653214,  6053214, 5603214, 6503214, 3560214, 5360214, 3650214, 6350214, 5630214, 6530214,
-        2356014, 3256014, 2536014, 5236014, 3526014, 5326014, 2365014, 3265014, 2635014, 6235014, 3625014, 6325014,
-        2563014, 5263014, 2653014, 6253014, 5623014, 6523014, 3562014, 5362014, 3652014, 6352014, 5632014, 6532014,
-        1235604, 2135604, 1325604, 3125604, 2315604, 3215604, 1253604, 2153604, 1523604, 5123604, 2513604, 5213604,
-        1352604, 3152604, 1532604, 5132604, 3512604, 5312604, 2351604, 3251604, 2531604, 5231604, 3521604, 5321604,
-        1236504, 2136504, 1326504, 3126504, 2316504, 3216504, 1263504, 2163504, 1623504, 6123504, 2613504, 6213504,
-        1362504, 3162504, 1632504, 6132504, 3612504, 6312504, 2361504, 3261504, 2631504, 6231504, 3621504, 6321504,
-        1256304, 2156304, 1526304, 5126304, 2516304, 5216304, 1265304, 2165304, 1625304, 6125304, 2615304, 6215304,
-        1562304, 5162304, 1652304, 6152304, 5612304, 6512304, 2561304, 5261304, 2651304, 6251304, 5621304, 6521304,
-        1356204, 3156204, 1536204, 5136204, 3516204, 5316204, 1365204, 3165204, 1635204, 6135204, 3615204, 6315204,
-        1563204, 5163204, 1653204, 6153204, 5613204, 6513204, 3561204, 5361204, 3651204, 6351204, 5631204, 6531204,
-        2356104, 3256104, 2536104, 5236104, 3526104, 5326104, 2365104, 3265104, 2635104, 6235104, 3625104, 6325104,
-        2563104, 5263104, 2653104, 6253104, 5623104, 6523104, 3562104, 5362104, 3652104, 6352104, 5632104, 6532104,
-        124563,  1024563, 214563,  2014563, 1204563, 2104563, 142563,  1042563, 412563,  4012563, 1402563, 4102563,
-        241563,  2041563, 421563,  4021563, 2401563, 4201563, 1240563, 2140563, 1420563, 4120563, 2410563, 4210563,
-        125463,  1025463, 215463,  2015463, 1205463, 2105463, 152463,  1052463, 512463,  5012463, 1502463, 5102463,
-        251463,  2051463, 521463,  5021463, 2501463, 5201463, 1250463, 2150463, 1520463, 5120463, 2510463, 5210463,
-        145263,  1045263, 415263,  4015263, 1405263, 4105263, 154263,  1054263, 514263,  5014263, 1504263, 5104263,
-        451263,  4051263, 541263,  5041263, 4501263, 5401263, 1450263, 4150263, 1540263, 5140263, 4510263, 5410263,
-        245163,  2045163, 425163,  4025163, 2405163, 4205163, 254163,  2054163, 524163,  5024163, 2504163, 5204163,
-        452163,  4052163, 542163,  5042163, 4502163, 5402163, 2450163, 4250163, 2540163, 5240163, 4520163, 5420163,
-        1245063, 2145063, 1425063, 4125063, 2415063, 4215063, 1254063, 2154063, 1524063, 5124063, 2514063, 5214063,
-        1452063, 4152063, 1542063, 5142063, 4512063, 5412063, 2451063, 4251063, 2541063, 5241063, 4521063, 5421063,
-        124653,  1024653, 214653,  2014653, 1204653, 2104653, 142653,  1042653, 412653,  4012653, 1402653, 4102653,
-        241653,  2041653, 421653,  4021653, 2401653, 4201653, 1240653, 2140653, 1420653, 4120653, 2410653, 4210653,
-        126453,  1026453, 216453,  2016453, 1206453, 2106453, 162453,  1062453, 612453,  6012453, 1602453, 6102453,
-        261453,  2061453, 621453,  6021453, 2601453, 6201453, 1260453, 2160453, 1620453, 6120453, 2610453, 6210453,
-        146253,  1046253, 416253,  4016253, 1406253, 4106253, 164253,  1064253, 614253,  6014253, 1604253, 6104253,
-        461253,  4061253, 641253,  6041253, 4601253, 6401253, 1460253, 4160253, 1640253, 6140253, 4610253, 6410253,
-        246153,  2046153, 426153,  4026153, 2406153, 4206153, 264153,  2064153, 624153,  6024153, 2604153, 6204153,
-        462153,  4062153, 642153,  6042153, 4602153, 6402153, 2460153, 4260153, 2640153, 6240153, 4620153, 6420153,
-        1246053, 2146053, 1426053, 4126053, 2416053, 4216053, 1264053, 2164053, 1624053, 6124053, 2614053, 6214053,
-        1462053, 4162053, 1642053, 6142053, 4612053, 6412053, 2461053, 4261053, 2641053, 6241053, 4621053, 6421053,
-        125643,  1025643, 215643,  2015643, 1205643, 2105643, 152643,  1052643, 512643,  5012643, 1502643, 5102643,
-        251643,  2051643, 521643,  5021643, 2501643, 5201643, 1250643, 2150643, 1520643, 5120643, 2510643, 5210643,
-        126543,  1026543, 216543,  2016543, 1206543, 2106543, 162543,  1062543, 612543,  6012543, 1602543, 6102543,
-        261543,  2061543, 621543,  6021543, 2601543, 6201543, 1260543, 2160543, 1620543, 6120543, 2610543, 6210543,
-        156243,  1056243, 516243,  5016243, 1506243, 5106243, 165243,  1065243, 615243,  6015243, 1605243, 6105243,
-        561243,  5061243, 651243,  6051243, 5601243, 6501243, 1560243, 5160243, 1650243, 6150243, 5610243, 6510243,
-        256143,  2056143, 526143,  5026143, 2506143, 5206143, 265143,  2065143, 625143,  6025143, 2605143, 6205143,
-        562143,  5062143, 652143,  6052143, 5602143, 6502143, 2560143, 5260143, 2650143, 6250143, 5620143, 6520143,
-        1256043, 2156043, 1526043, 5126043, 2516043, 5216043, 1265043, 2165043, 1625043, 6125043, 2615043, 6215043,
-        1562043, 5162043, 1652043, 6152043, 5612043, 6512043, 2561043, 5261043, 2651043, 6251043, 5621043, 6521043,
-        145623,  1045623, 415623,  4015623, 1405623, 4105623, 154623,  1054623, 514623,  5014623, 1504623, 5104623,
-        451623,  4051623, 541623,  5041623, 4501623, 5401623, 1450623, 4150623, 1540623, 5140623, 4510623, 5410623,
-        146523,  1046523, 416523,  4016523, 1406523, 4106523, 164523,  1064523, 614523,  6014523, 1604523, 6104523,
-        461523,  4061523, 641523,  6041523, 4601523, 6401523, 1460523, 4160523, 1640523, 6140523, 4610523, 6410523,
-        156423,  1056423, 516423,  5016423, 1506423, 5106423, 165423,  1065423, 615423,  6015423, 1605423, 6105423,
-        561423,  5061423, 651423,  6051423, 5601423, 6501423, 1560423, 5160423, 1650423, 6150423, 5610423, 6510423,
-        456123,  4056123, 546123,  5046123, 4506123, 5406123, 465123,  4065123, 645123,  6045123, 4605123, 6405123,
-        564123,  5064123, 654123,  6054123, 5604123, 6504123, 4560123, 5460123, 4650123, 6450123, 5640123, 6540123,
-        1456023, 4156023, 1546023, 5146023, 4516023, 5416023, 1465023, 4165023, 1645023, 6145023, 4615023, 6415023,
-        1564023, 5164023, 1654023, 6154023, 5614023, 6514023, 4561023, 5461023, 4651023, 6451023, 5641023, 6541023,
-        245613,  2045613, 425613,  4025613, 2405613, 4205613, 254613,  2054613, 524613,  5024613, 2504613, 5204613,
-        452613,  4052613, 542613,  5042613, 4502613, 5402613, 2450613, 4250613, 2540613, 5240613, 4520613, 5420613,
-        246513,  2046513, 426513,  4026513, 2406513, 4206513, 264513,  2064513, 624513,  6024513, 2604513, 6204513,
-        462513,  4062513, 642513,  6042513, 4602513, 6402513, 2460513, 4260513, 2640513, 6240513, 4620513, 6420513,
-        256413,  2056413, 526413,  5026413, 2506413, 5206413, 265413,  2065413, 625413,  6025413, 2605413, 6205413,
-        562413,  5062413, 652413,  6052413, 5602413, 6502413, 2560413, 5260413, 2650413, 6250413, 5620413, 6520413,
-        456213,  4056213, 546213,  5046213, 4506213, 5406213, 465213,  4065213, 645213,  6045213, 4605213, 6405213,
-        564213,  5064213, 654213,  6054213, 5604213, 6504213, 4560213, 5460213, 4650213, 6450213, 5640213, 6540213,
-        2456013, 4256013, 2546013, 5246013, 4526013, 5426013, 2465013, 4265013, 2645013, 6245013, 4625013, 6425013,
-        2564013, 5264013, 2654013, 6254013, 5624013, 6524013, 4562013, 5462013, 4652013, 6452013, 5642013, 6542013,
-        1245603, 2145603, 1425603, 4125603, 2415603, 4215603, 1254603, 2154603, 1524603, 5124603, 2514603, 5214603,
-        1452603, 4152603, 1542603, 5142603, 4512603, 5412603, 2451603, 4251603, 2541603, 5241603, 4521603, 5421603,
-        1246503, 2146503, 1426503, 4126503, 2416503, 4216503, 1264503, 2164503, 1624503, 6124503, 2614503, 6214503,
-        1462503, 4162503, 1642503, 6142503, 4612503, 6412503, 2461503, 4261503, 2641503, 6241503, 4621503, 6421503,
-        1256403, 2156403, 1526403, 5126403, 2516403, 5216403, 1265403, 2165403, 1625403, 6125403, 2615403, 6215403,
-        1562403, 5162403, 1652403, 6152403, 5612403, 6512403, 2561403, 5261403, 2651403, 6251403, 5621403, 6521403,
-        1456203, 4156203, 1546203, 5146203, 4516203, 5416203, 1465203, 4165203, 1645203, 6145203, 4615203, 6415203,
-        1564203, 5164203, 1654203, 6154203, 5614203, 6514203, 4561203, 5461203, 4651203, 6451203, 5641203, 6541203,
-        2456103, 4256103, 2546103, 5246103, 4526103, 5426103, 2465103, 4265103, 2645103, 6245103, 4625103, 6425103,
-        2564103, 5264103, 2654103, 6254103, 5624103, 6524103, 4562103, 5462103, 4652103, 6452103, 5642103, 6542103,
-        134562,  1034562, 314562,  3014562, 1304562, 3104562, 143562,  1043562, 413562,  4013562, 1403562, 4103562,
-        341562,  3041562, 431562,  4031562, 3401562, 4301562, 1340562, 3140562, 1430562, 4130562, 3410562, 4310562,
-        135462,  1035462, 315462,  3015462, 1305462, 3105462, 153462,  1053462, 513462,  5013462, 1503462, 5103462,
-        351462,  3051462, 531462,  5031462, 3501462, 5301462, 1350462, 3150462, 1530462, 5130462, 3510462, 5310462,
-        145362,  1045362, 415362,  4015362, 1405362, 4105362, 154362,  1054362, 514362,  5014362, 1504362, 5104362,
-        451362,  4051362, 541362,  5041362, 4501362, 5401362, 1450362, 4150362, 1540362, 5140362, 4510362, 5410362,
-        345162,  3045162, 435162,  4035162, 3405162, 4305162, 354162,  3054162, 534162,  5034162, 3504162, 5304162,
-        453162,  4053162, 543162,  5043162, 4503162, 5403162, 3450162, 4350162, 3540162, 5340162, 4530162, 5430162,
-        1345062, 3145062, 1435062, 4135062, 3415062, 4315062, 1354062, 3154062, 1534062, 5134062, 3514062, 5314062,
-        1453062, 4153062, 1543062, 5143062, 4513062, 5413062, 3451062, 4351062, 3541062, 5341062, 4531062, 5431062,
-        134652,  1034652, 314652,  3014652, 1304652, 3104652, 143652,  1043652, 413652,  4013652, 1403652, 4103652,
-        341652,  3041652, 431652,  4031652, 3401652, 4301652, 1340652, 3140652, 1430652, 4130652, 3410652, 4310652,
-        136452,  1036452, 316452,  3016452, 1306452, 3106452, 163452,  1063452, 613452,  6013452, 1603452, 6103452,
-        361452,  3061452, 631452,  6031452, 3601452, 6301452, 1360452, 3160452, 1630452, 6130452, 3610452, 6310452,
-        146352,  1046352, 416352,  4016352, 1406352, 4106352, 164352,  1064352, 614352,  6014352, 1604352, 6104352,
-        461352,  4061352, 641352,  6041352, 4601352, 6401352, 1460352, 4160352, 1640352, 6140352, 4610352, 6410352,
-        346152,  3046152, 436152,  4036152, 3406152, 4306152, 364152,  3064152, 634152,  6034152, 3604152, 6304152,
-        463152,  4063152, 643152,  6043152, 4603152, 6403152, 3460152, 4360152, 3640152, 6340152, 4630152, 6430152,
-        1346052, 3146052, 1436052, 4136052, 3416052, 4316052, 1364052, 3164052, 1634052, 6134052, 3614052, 6314052,
-        1463052, 4163052, 1643052, 6143052, 4613052, 6413052, 3461052, 4361052, 3641052, 6341052, 4631052, 6431052,
-        135642,  1035642, 315642,  3015642, 1305642, 3105642, 153642,  1053642, 513642,  5013642, 1503642, 5103642,
-        351642,  3051642, 531642,  5031642, 3501642, 5301642, 1350642, 3150642, 1530642, 5130642, 3510642, 5310642,
-        136542,  1036542, 316542,  3016542, 1306542, 3106542, 163542,  1063542, 613542,  6013542, 1603542, 6103542,
-        361542,  3061542, 631542,  6031542, 3601542, 6301542, 1360542, 3160542, 1630542, 6130542, 3610542, 6310542,
-        156342,  1056342, 516342,  5016342, 1506342, 5106342, 165342,  1065342, 615342,  6015342, 1605342, 6105342,
-        561342,  5061342, 651342,  6051342, 5601342, 6501342, 1560342, 5160342, 1650342, 6150342, 5610342, 6510342,
-        356142,  3056142, 536142,  5036142, 3506142, 5306142, 365142,  3065142, 635142,  6035142, 3605142, 6305142,
-        563142,  5063142, 653142,  6053142, 5603142, 6503142, 3560142, 5360142, 3650142, 6350142, 5630142, 6530142,
-        1356042, 3156042, 1536042, 5136042, 3516042, 5316042, 1365042, 3165042, 1635042, 6135042, 3615042, 6315042,
-        1563042, 5163042, 1653042, 6153042, 5613042, 6513042, 3561042, 5361042, 3651042, 6351042, 5631042, 6531042,
-        145632,  1045632, 415632,  4015632, 1405632, 4105632, 154632,  1054632, 514632,  5014632, 1504632, 5104632,
-        451632,  4051632, 541632,  5041632, 4501632, 5401632, 1450632, 4150632, 1540632, 5140632, 4510632, 5410632,
-        146532,  1046532, 416532,  4016532, 1406532, 4106532, 164532,  1064532, 614532,  6014532, 1604532, 6104532,
-        461532,  4061532, 641532,  6041532, 4601532, 6401532, 1460532, 4160532, 1640532, 6140532, 4610532, 6410532,
-        156432,  1056432, 516432,  5016432, 1506432, 5106432, 165432,  1065432, 615432,  6015432, 1605432, 6105432,
-        561432,  5061432, 651432,  6051432, 5601432, 6501432, 1560432, 5160432, 1650432, 6150432, 5610432, 6510432,
-        456132,  4056132, 546132,  5046132, 4506132, 5406132, 465132,  4065132, 645132,  6045132, 4605132, 6405132,
-        564132,  5064132, 654132,  6054132, 5604132, 6504132, 4560132, 5460132, 4650132, 6450132, 5640132, 6540132,
-        1456032, 4156032, 1546032, 5146032, 4516032, 5416032, 1465032, 4165032, 1645032, 6145032, 4615032, 6415032,
-        1564032, 5164032, 1654032, 6154032, 5614032, 6514032, 4561032, 5461032, 4651032, 6451032, 5641032, 6541032,
-        345612,  3045612, 435612,  4035612, 3405612, 4305612, 354612,  3054612, 534612,  5034612, 3504612, 5304612,
-        453612,  4053612, 543612,  5043612, 4503612, 5403612, 3450612, 4350612, 3540612, 5340612, 4530612, 5430612,
-        346512,  3046512, 436512,  4036512, 3406512, 4306512, 364512,  3064512, 634512,  6034512, 3604512, 6304512,
-        463512,  4063512, 643512,  6043512, 4603512, 6403512, 3460512, 4360512, 3640512, 6340512, 4630512, 6430512,
-        356412,  3056412, 536412,  5036412, 3506412, 5306412, 365412,  3065412, 635412,  6035412, 3605412, 6305412,
-        563412,  5063412, 653412,  6053412, 5603412, 6503412, 3560412, 5360412, 3650412, 6350412, 5630412, 6530412,
-        456312,  4056312, 546312,  5046312, 4506312, 5406312, 465312,  4065312, 645312,  6045312, 4605312, 6405312,
-        564312,  5064312, 654312,  6054312, 5604312, 6504312, 4560312, 5460312, 4650312, 6450312, 5640312, 6540312,
-        3456012, 4356012, 3546012, 5346012, 4536012, 5436012, 3465012, 4365012, 3645012, 6345012, 4635012, 6435012,
-        3564012, 5364012, 3654012, 6354012, 5634012, 6534012, 4563012, 5463012, 4653012, 6453012, 5643012, 6543012,
-        1345602, 3145602, 1435602, 4135602, 3415602, 4315602, 1354602, 3154602, 1534602, 5134602, 3514602, 5314602,
-        1453602, 4153602, 1543602, 5143602, 4513602, 5413602, 3451602, 4351602, 3541602, 5341602, 4531602, 5431602,
-        1346502, 3146502, 1436502, 4136502, 3416502, 4316502, 1364502, 3164502, 1634502, 6134502, 3614502, 6314502,
-        1463502, 4163502, 1643502, 6143502, 4613502, 6413502, 3461502, 4361502, 3641502, 6341502, 4631502, 6431502,
-        1356402, 3156402, 1536402, 5136402, 3516402, 5316402, 1365402, 3165402, 1635402, 6135402, 3615402, 6315402,
-        1563402, 5163402, 1653402, 6153402, 5613402, 6513402, 3561402, 5361402, 3651402, 6351402, 5631402, 6531402,
-        1456302, 4156302, 1546302, 5146302, 4516302, 5416302, 1465302, 4165302, 1645302, 6145302, 4615302, 6415302,
-        1564302, 5164302, 1654302, 6154302, 5614302, 6514302, 4561302, 5461302, 4651302, 6451302, 5641302, 6541302,
-        3456102, 4356102, 3546102, 5346102, 4536102, 5436102, 3465102, 4365102, 3645102, 6345102, 4635102, 6435102,
-        3564102, 5364102, 3654102, 6354102, 5634102, 6534102, 4563102, 5463102, 4653102, 6453102, 5643102, 6543102,
-        234561,  2034561, 324561,  3024561, 2304561, 3204561, 243561,  2043561, 423561,  4023561, 2403561, 4203561,
-        342561,  3042561, 432561,  4032561, 3402561, 4302561, 2340561, 3240561, 2430561, 4230561, 3420561, 4320561,
-        235461,  2035461, 325461,  3025461, 2305461, 3205461, 253461,  2053461, 523461,  5023461, 2503461, 5203461,
-        352461,  3052461, 532461,  5032461, 3502461, 5302461, 2350461, 3250461, 2530461, 5230461, 3520461, 5320461,
-        245361,  2045361, 425361,  4025361, 2405361, 4205361, 254361,  2054361, 524361,  5024361, 2504361, 5204361,
-        452361,  4052361, 542361,  5042361, 4502361, 5402361, 2450361, 4250361, 2540361, 5240361, 4520361, 5420361,
-        345261,  3045261, 435261,  4035261, 3405261, 4305261, 354261,  3054261, 534261,  5034261, 3504261, 5304261,
-        453261,  4053261, 543261,  5043261, 4503261, 5403261, 3450261, 4350261, 3540261, 5340261, 4530261, 5430261,
-        2345061, 3245061, 2435061, 4235061, 3425061, 4325061, 2354061, 3254061, 2534061, 5234061, 3524061, 5324061,
-        2453061, 4253061, 2543061, 5243061, 4523061, 5423061, 3452061, 4352061, 3542061, 5342061, 4532061, 5432061,
-        234651,  2034651, 324651,  3024651, 2304651, 3204651, 243651,  2043651, 423651,  4023651, 2403651, 4203651,
-        342651,  3042651, 432651,  4032651, 3402651, 4302651, 2340651, 3240651, 2430651, 4230651, 3420651, 4320651,
-        236451,  2036451, 326451,  3026451, 2306451, 3206451, 263451,  2063451, 623451,  6023451, 2603451, 6203451,
-        362451,  3062451, 632451,  6032451, 3602451, 6302451, 2360451, 3260451, 2630451, 6230451, 3620451, 6320451,
-        246351,  2046351, 426351,  4026351, 2406351, 4206351, 264351,  2064351, 624351,  6024351, 2604351, 6204351,
-        462351,  4062351, 642351,  6042351, 4602351, 6402351, 2460351, 4260351, 2640351, 6240351, 4620351, 6420351,
-        346251,  3046251, 436251,  4036251, 3406251, 4306251, 364251,  3064251, 634251,  6034251, 3604251, 6304251,
-        463251,  4063251, 643251,  6043251, 4603251, 6403251, 3460251, 4360251, 3640251, 6340251, 4630251, 6430251,
-        2346051, 3246051, 2436051, 4236051, 3426051, 4326051, 2364051, 3264051, 2634051, 6234051, 3624051, 6324051,
-        2463051, 4263051, 2643051, 6243051, 4623051, 6423051, 3462051, 4362051, 3642051, 6342051, 4632051, 6432051,
-        235641,  2035641, 325641,  3025641, 2305641, 3205641, 253641,  2053641, 523641,  5023641, 2503641, 5203641,
-        352641,  3052641, 532641,  5032641, 3502641, 5302641, 2350641, 3250641, 2530641, 5230641, 3520641, 5320641,
-        236541,  2036541, 326541,  3026541, 2306541, 3206541, 263541,  2063541, 623541,  6023541, 2603541, 6203541,
-        362541,  3062541, 632541,  6032541, 3602541, 6302541, 2360541, 3260541, 2630541, 6230541, 3620541, 6320541,
-        256341,  2056341, 526341,  5026341, 2506341, 5206341, 265341,  2065341, 625341,  6025341, 2605341, 6205341,
-        562341,  5062341, 652341,  6052341, 5602341, 6502341, 2560341, 5260341, 2650341, 6250341, 5620341, 6520341,
-        356241,  3056241, 536241,  5036241, 3506241, 5306241, 365241,  3065241, 635241,  6035241, 3605241, 6305241,
-        563241,  5063241, 653241,  6053241, 5603241, 6503241, 3560241, 5360241, 3650241, 6350241, 5630241, 6530241,
-        2356041, 3256041, 2536041, 5236041, 3526041, 5326041, 2365041, 3265041, 2635041, 6235041, 3625041, 6325041,
-        2563041, 5263041, 2653041, 6253041, 5623041, 6523041, 3562041, 5362041, 3652041, 6352041, 5632041, 6532041,
-        245631,  2045631, 425631,  4025631, 2405631, 4205631, 254631,  2054631, 524631,  5024631, 2504631, 5204631,
-        452631,  4052631, 542631,  5042631, 4502631, 5402631, 2450631, 4250631, 2540631, 5240631, 4520631, 5420631,
-        246531,  2046531, 426531,  4026531, 2406531, 4206531, 264531,  2064531, 624531,  6024531, 2604531, 6204531,
-        462531,  4062531, 642531,  6042531, 4602531, 6402531, 2460531, 4260531, 2640531, 6240531, 4620531, 6420531,
-        256431,  2056431, 526431,  5026431, 2506431, 5206431, 265431,  2065431, 625431,  6025431, 2605431, 6205431,
-        562431,  5062431, 652431,  6052431, 5602431, 6502431, 2560431, 5260431, 2650431, 6250431, 5620431, 6520431,
-        456231,  4056231, 546231,  5046231, 4506231, 5406231, 465231,  4065231, 645231,  6045231, 4605231, 6405231,
-        564231,  5064231, 654231,  6054231, 5604231, 6504231, 4560231, 5460231, 4650231, 6450231, 5640231, 6540231,
-        2456031, 4256031, 2546031, 5246031, 4526031, 5426031, 2465031, 4265031, 2645031, 6245031, 4625031, 6425031,
-        2564031, 5264031, 2654031, 6254031, 5624031, 6524031, 4562031, 5462031, 4652031, 6452031, 5642031, 6542031,
-        345621,  3045621, 435621,  4035621, 3405621, 4305621, 354621,  3054621, 534621,  5034621, 3504621, 5304621,
-        453621,  4053621, 543621,  5043621, 4503621, 5403621, 3450621, 4350621, 3540621, 5340621, 4530621, 5430621,
-        346521,  3046521, 436521,  4036521, 3406521, 4306521, 364521,  3064521, 634521,  6034521, 3604521, 6304521,
-        463521,  4063521, 643521,  6043521, 4603521, 6403521, 3460521, 4360521, 3640521, 6340521, 4630521, 6430521,
-        356421,  3056421, 536421,  5036421, 3506421, 5306421, 365421,  3065421, 635421,  6035421, 3605421, 6305421,
-        563421,  5063421, 653421,  6053421, 5603421, 6503421, 3560421, 5360421, 3650421, 6350421, 5630421, 6530421,
-        456321,  4056321, 546321,  5046321, 4506321, 5406321, 465321,  4065321, 645321,  6045321, 4605321, 6405321,
-        564321,  5064321, 654321,  6054321, 5604321, 6504321, 4560321, 5460321, 4650321, 6450321, 5640321, 6540321,
-        3456021, 4356021, 3546021, 5346021, 4536021, 5436021, 3465021, 4365021, 3645021, 6345021, 4635021, 6435021,
-        3564021, 5364021, 3654021, 6354021, 5634021, 6534021, 4563021, 5463021, 4653021, 6453021, 5643021, 6543021,
-        2345601, 3245601, 2435601, 4235601, 3425601, 4325601, 2354601, 3254601, 2534601, 5234601, 3524601, 5324601,
-        2453601, 4253601, 2543601, 5243601, 4523601, 5423601, 3452601, 4352601, 3542601, 5342601, 4532601, 5432601,
-        2346501, 3246501, 2436501, 4236501, 3426501, 4326501, 2364501, 3264501, 2634501, 6234501, 3624501, 6324501,
-        2463501, 4263501, 2643501, 6243501, 4623501, 6423501, 3462501, 4362501, 3642501, 6342501, 4632501, 6432501,
-        2356401, 3256401, 2536401, 5236401, 3526401, 5326401, 2365401, 3265401, 2635401, 6235401, 3625401, 6325401,
-        2563401, 5263401, 2653401, 6253401, 5623401, 6523401, 3562401, 5362401, 3652401, 6352401, 5632401, 6532401,
-        2456301, 4256301, 2546301, 5246301, 4526301, 5426301, 2465301, 4265301, 2645301, 6245301, 4625301, 6425301,
-        2564301, 5264301, 2654301, 6254301, 5624301, 6524301, 4562301, 5462301, 4652301, 6452301, 5642301, 6542301,
-        3456201, 4356201, 3546201, 5346201, 4536201, 5436201, 3465201, 4365201, 3645201, 6345201, 4635201, 6435201,
-        3564201, 5364201, 3654201, 6354201, 5634201, 6534201, 4563201, 5463201, 4653201, 6453201, 5643201, 6543201,
-        1234560, 2134560, 1324560, 3124560, 2314560, 3214560, 1243560, 2143560, 1423560, 4123560, 2413560, 4213560,
-        1342560, 3142560, 1432560, 4132560, 3412560, 4312560, 2341560, 3241560, 2431560, 4231560, 3421560, 4321560,
-        1235460, 2135460, 1325460, 3125460, 2315460, 3215460, 1253460, 2153460, 1523460, 5123460, 2513460, 5213460,
-        1352460, 3152460, 1532460, 5132460, 3512460, 5312460, 2351460, 3251460, 2531460, 5231460, 3521460, 5321460,
-        1245360, 2145360, 1425360, 4125360, 2415360, 4215360, 1254360, 2154360, 1524360, 5124360, 2514360, 5214360,
-        1452360, 4152360, 1542360, 5142360, 4512360, 5412360, 2451360, 4251360, 2541360, 5241360, 4521360, 5421360,
-        1345260, 3145260, 1435260, 4135260, 3415260, 4315260, 1354260, 3154260, 1534260, 5134260, 3514260, 5314260,
-        1453260, 4153260, 1543260, 5143260, 4513260, 5413260, 3451260, 4351260, 3541260, 5341260, 4531260, 5431260,
-        2345160, 3245160, 2435160, 4235160, 3425160, 4325160, 2354160, 3254160, 2534160, 5234160, 3524160, 5324160,
-        2453160, 4253160, 2543160, 5243160, 4523160, 5423160, 3452160, 4352160, 3542160, 5342160, 4532160, 5432160,
-        1234650, 2134650, 1324650, 3124650, 2314650, 3214650, 1243650, 2143650, 1423650, 4123650, 2413650, 4213650,
-        1342650, 3142650, 1432650, 4132650, 3412650, 4312650, 2341650, 3241650, 2431650, 4231650, 3421650, 4321650,
-        1236450, 2136450, 1326450, 3126450, 2316450, 3216450, 1263450, 2163450, 1623450, 6123450, 2613450, 6213450,
-        1362450, 3162450, 1632450, 6132450, 3612450, 6312450, 2361450, 3261450, 2631450, 6231450, 3621450, 6321450,
-        1246350, 2146350, 1426350, 4126350, 2416350, 4216350, 1264350, 2164350, 1624350, 6124350, 2614350, 6214350,
-        1462350, 4162350, 1642350, 6142350, 4612350, 6412350, 2461350, 4261350, 2641350, 6241350, 4621350, 6421350,
-        1346250, 3146250, 1436250, 4136250, 3416250, 4316250, 1364250, 3164250, 1634250, 6134250, 3614250, 6314250,
-        1463250, 4163250, 1643250, 6143250, 4613250, 6413250, 3461250, 4361250, 3641250, 6341250, 4631250, 6431250,
-        2346150, 3246150, 2436150, 4236150, 3426150, 4326150, 2364150, 3264150, 2634150, 6234150, 3624150, 6324150,
-        2463150, 4263150, 2643150, 6243150, 4623150, 6423150, 3462150, 4362150, 3642150, 6342150, 4632150, 6432150,
-        1235640, 2135640, 1325640, 3125640, 2315640, 3215640, 1253640, 2153640, 1523640, 5123640, 2513640, 5213640,
-        1352640, 3152640, 1532640, 5132640, 3512640, 5312640, 2351640, 3251640, 2531640, 5231640, 3521640, 5321640,
-        1236540, 2136540, 1326540, 3126540, 2316540, 3216540, 1263540, 2163540, 1623540, 6123540, 2613540, 6213540,
-        1362540, 3162540, 1632540, 6132540, 3612540, 6312540, 2361540, 3261540, 2631540, 6231540, 3621540, 6321540,
-        1256340, 2156340, 1526340, 5126340, 2516340, 5216340, 1265340, 2165340, 1625340, 6125340, 2615340, 6215340,
-        1562340, 5162340, 1652340, 6152340, 5612340, 6512340, 2561340, 5261340, 2651340, 6251340, 5621340, 6521340,
-        1356240, 3156240, 1536240, 5136240, 3516240, 5316240, 1365240, 3165240, 1635240, 6135240, 3615240, 6315240,
-        1563240, 5163240, 1653240, 6153240, 5613240, 6513240, 3561240, 5361240, 3651240, 6351240, 5631240, 6531240,
-        2356140, 3256140, 2536140, 5236140, 3526140, 5326140, 2365140, 3265140, 2635140, 6235140, 3625140, 6325140,
-        2563140, 5263140, 2653140, 6253140, 5623140, 6523140, 3562140, 5362140, 3652140, 6352140, 5632140, 6532140,
-        1245630, 2145630, 1425630, 4125630, 2415630, 4215630, 1254630, 2154630, 1524630, 5124630, 2514630, 5214630,
-        1452630, 4152630, 1542630, 5142630, 4512630, 5412630, 2451630, 4251630, 2541630, 5241630, 4521630, 5421630,
-        1246530, 2146530, 1426530, 4126530, 2416530, 4216530, 1264530, 2164530, 1624530, 6124530, 2614530, 6214530,
-        1462530, 4162530, 1642530, 6142530, 4612530, 6412530, 2461530, 4261530, 2641530, 6241530, 4621530, 6421530,
-        1256430, 2156430, 1526430, 5126430, 2516430, 5216430, 1265430, 2165430, 1625430, 6125430, 2615430, 6215430,
-        1562430, 5162430, 1652430, 6152430, 5612430, 6512430, 2561430, 5261430, 2651430, 6251430, 5621430, 6521430,
-        1456230, 4156230, 1546230, 5146230, 4516230, 5416230, 1465230, 4165230, 1645230, 6145230, 4615230, 6415230,
-        1564230, 5164230, 1654230, 6154230, 5614230, 6514230, 4561230, 5461230, 4651230, 6451230, 5641230, 6541230,
-        2456130, 4256130, 2546130, 5246130, 4526130, 5426130, 2465130, 4265130, 2645130, 6245130, 4625130, 6425130,
-        2564130, 5264130, 2654130, 6254130, 5624130, 6524130, 4562130, 5462130, 4652130, 6452130, 5642130, 6542130,
-        1345620, 3145620, 1435620, 4135620, 3415620, 4315620, 1354620, 3154620, 1534620, 5134620, 3514620, 5314620,
-        1453620, 4153620, 1543620, 5143620, 4513620, 5413620, 3451620, 4351620, 3541620, 5341620, 4531620, 5431620,
-        1346520, 3146520, 1436520, 4136520, 3416520, 4316520, 1364520, 3164520, 1634520, 6134520, 3614520, 6314520,
-        1463520, 4163520, 1643520, 6143520, 4613520, 6413520, 3461520, 4361520, 3641520, 6341520, 4631520, 6431520,
-        1356420, 3156420, 1536420, 5136420, 3516420, 5316420, 1365420, 3165420, 1635420, 6135420, 3615420, 6315420,
-        1563420, 5163420, 1653420, 6153420, 5613420, 6513420, 3561420, 5361420, 3651420, 6351420, 5631420, 6531420,
-        1456320, 4156320, 1546320, 5146320, 4516320, 5416320, 1465320, 4165320, 1645320, 6145320, 4615320, 6415320,
-        1564320, 5164320, 1654320, 6154320, 5614320, 6514320, 4561320, 5461320, 4651320, 6451320, 5641320, 6541320,
-        3456120, 4356120, 3546120, 5346120, 4536120, 5436120, 3465120, 4365120, 3645120, 6345120, 4635120, 6435120,
-        3564120, 5364120, 3654120, 6354120, 5634120, 6534120, 4563120, 5463120, 4653120, 6453120, 5643120, 6543120,
-        2345610, 3245610, 2435610, 4235610, 3425610, 4325610, 2354610, 3254610, 2534610, 5234610, 3524610, 5324610,
-        2453610, 4253610, 2543610, 5243610, 4523610, 5423610, 3452610, 4352610, 3542610, 5342610, 4532610, 5432610,
-        2346510, 3246510, 2436510, 4236510, 3426510, 4326510, 2364510, 3264510, 2634510, 6234510, 3624510, 6324510,
-        2463510, 4263510, 2643510, 6243510, 4623510, 6423510, 3462510, 4362510, 3642510, 6342510, 4632510, 6432510,
-        2356410, 3256410, 2536410, 5236410, 3526410, 5326410, 2365410, 3265410, 2635410, 6235410, 3625410, 6325410,
-        2563410, 5263410, 2653410, 6253410, 5623410, 6523410, 3562410, 5362410, 3652410, 6352410, 5632410, 6532410,
-        2456310, 4256310, 2546310, 5246310, 4526310, 5426310, 2465310, 4265310, 2645310, 6245310, 4625310, 6425310,
-        2564310, 5264310, 2654310, 6254310, 5624310, 6524310, 4562310, 5462310, 4652310, 6452310, 5642310, 6542310,
-        3456210, 4356210, 3546210, 5346210, 4536210, 5436210, 3465210, 4365210, 3645210, 6345210, 4635210, 6435210,
-        3564210, 5364210, 3654210, 6354210, 5634210, 6534210, 4563210, 5463210, 4653210, 6453210, 5643210, 6543210};
-    std::map<uint64_t, int> expected;
-    for (std::size_t i = 0; i < 5040; i++) expected[pre_expected[i]] = 0;  // flags are 0, everything is symmetric here
-
-    VERIFY(isDynGroup(group));
-    VERIFY_IS_EQUAL(group.size(), 5040u);
-    VERIFY_IS_EQUAL(group.globalFlags(), 0);
-    group.apply<checkIdx, int>(identity7, 0, found, expected);
-    VERIFY_IS_EQUAL(found.size(), 5040u);
-  }
-}
-
-static void test_tensor_epsilon() {
-  SGroup<AntiSymmetry<0, 1>, AntiSymmetry<1, 2>> sym;
-  Tensor<int, 3> epsilon(3, 3, 3);
-
-  epsilon.setZero();
-  sym(epsilon, 0, 1, 2) = 1;
-
-  for (int i = 0; i < 3; i++) {
-    for (int j = 0; j < 3; j++) {
-      for (int k = 0; k < 3; k++) {
-        VERIFY_IS_EQUAL((epsilon(i, j, k)), (-(j - i) * (k - j) * (i - k) / 2));
-      }
-    }
-  }
-}
-
-static void test_tensor_sym() {
-  SGroup<Symmetry<0, 1>, Symmetry<2, 3>> sym;
-  Tensor<int, 4> t(10, 10, 10, 10);
-
-  t.setZero();
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = l; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = j; i < 10; i++) {
-          sym(t, i, j, k, l) = (i + j) * (k + l);
-        }
-      }
-    }
-  }
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = 0; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = 0; i < 10; i++) {
-          VERIFY_IS_EQUAL((t(i, j, k, l)), ((i + j) * (k + l)));
-        }
-      }
-    }
-  }
-}
-
-static void test_tensor_asym() {
-  SGroup<AntiSymmetry<0, 1>, AntiSymmetry<2, 3>> sym;
-  Tensor<int, 4> t(10, 10, 10, 10);
-
-  t.setZero();
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = l + 1; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = j + 1; i < 10; i++) {
-          sym(t, i, j, k, l) = ((i * j) + (k * l));
-        }
-      }
-    }
-  }
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = 0; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = 0; i < 10; i++) {
-          if (i < j && k < l)
-            VERIFY_IS_EQUAL((t(i, j, k, l)), (((i * j) + (k * l))));
-          else if (i > j && k > l)
-            VERIFY_IS_EQUAL((t(i, j, k, l)), (((i * j) + (k * l))));
-          else if (i < j && k > l)
-            VERIFY_IS_EQUAL((t(i, j, k, l)), (-((i * j) + (k * l))));
-          else if (i > j && k < l)
-            VERIFY_IS_EQUAL((t(i, j, k, l)), (-((i * j) + (k * l))));
-          else
-            VERIFY_IS_EQUAL((t(i, j, k, l)), 0);
-        }
-      }
-    }
-  }
-}
-
-static void test_tensor_dynsym() {
-  DynamicSGroup sym;
-  sym.addSymmetry(0, 1);
-  sym.addSymmetry(2, 3);
-  Tensor<int, 4> t(10, 10, 10, 10);
-
-  t.setZero();
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = l; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = j; i < 10; i++) {
-          sym(t, i, j, k, l) = (i + j) * (k + l);
-        }
-      }
-    }
-  }
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = 0; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = 0; i < 10; i++) {
-          VERIFY_IS_EQUAL((t(i, j, k, l)), ((i + j) * (k + l)));
-        }
-      }
-    }
-  }
-}
-
-static void test_tensor_randacc() {
-  SGroup<Symmetry<0, 1>, Symmetry<2, 3>> sym;
-  Tensor<int, 4> t(10, 10, 10, 10);
-
-  t.setZero();
-
-  // set elements 1 million times, that way we access the
-  // entire matrix
-  for (int n = 0; n < 1000000; n++) {
-    int i = rand() % 10;
-    int j = rand() % 10;
-    int k = rand() % 10;
-    int l = rand() % 10;
-    // only access those indices in a given order
-    if (i < j) std::swap(i, j);
-    if (k < l) std::swap(k, l);
-    sym(t, i, j, k, l) = (i + j) * (k + l);
-  }
-
-  for (int l = 0; l < 10; l++) {
-    for (int k = 0; k < 10; k++) {
-      for (int j = 0; j < 10; j++) {
-        for (int i = 0; i < 10; i++) {
-          VERIFY_IS_EQUAL((t(i, j, k, l)), ((i + j) * (k + l)));
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_symmetry) {
-  CALL_SUBTEST(test_symgroups_static());
-  CALL_SUBTEST(test_symgroups_dynamic());
-  CALL_SUBTEST(test_symgroups_selection());
-  CALL_SUBTEST(test_tensor_epsilon());
-  CALL_SUBTEST(test_tensor_sym());
-  CALL_SUBTEST(test_tensor_asym());
-  CALL_SUBTEST(test_tensor_dynsym());
-  CALL_SUBTEST(test_tensor_randacc());
-}
-
-/*
- * kate: space-indent on; indent-width 2; mixedindent off; indent-mode cstyle;
- */
diff --git a/unsupported/test/cxx11_tensor_thread_local.cpp b/unsupported/test/cxx11_tensor_thread_local.cpp
deleted file mode 100644
index 32ba2cd..0000000
--- a/unsupported/test/cxx11_tensor_thread_local.cpp
+++ /dev/null
@@ -1,144 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_USE_THREADS
-
-#include <iostream>
-#include <unordered_set>
-
-#include "main.h"
-#include <Eigen/ThreadPool>
-
-struct Counter {
-  Counter() = default;
-
-  void inc() {
-    // Check that mutation happens only in a thread that created this counter.
-    VERIFY_IS_EQUAL(std::this_thread::get_id(), created_by);
-    counter_value++;
-  }
-  int value() { return counter_value; }
-
-  std::thread::id created_by;
-  int counter_value = 0;
-};
-
-struct InitCounter {
-  void operator()(Counter& counter) { counter.created_by = std::this_thread::get_id(); }
-};
-
-void test_simple_thread_local() {
-  int num_threads = internal::random<int>(4, 32);
-  Eigen::ThreadPool thread_pool(num_threads);
-  Eigen::ThreadLocal<Counter, InitCounter> counter(num_threads, InitCounter());
-
-  int num_tasks = 3 * num_threads;
-  Eigen::Barrier barrier(num_tasks);
-
-  for (int i = 0; i < num_tasks; ++i) {
-    thread_pool.Schedule([&counter, &barrier]() {
-      Counter& local = counter.local();
-      local.inc();
-
-      std::this_thread::sleep_for(std::chrono::milliseconds(100));
-      barrier.Notify();
-    });
-  }
-
-  barrier.Wait();
-
-  counter.ForEach([](std::thread::id, Counter& cnt) { VERIFY_IS_EQUAL(cnt.value(), 3); });
-}
-
-void test_zero_sized_thread_local() {
-  Eigen::ThreadLocal<Counter, InitCounter> counter(0, InitCounter());
-
-  Counter& local = counter.local();
-  local.inc();
-
-  int total = 0;
-  counter.ForEach([&total](std::thread::id, Counter& cnt) {
-    total += cnt.value();
-    VERIFY_IS_EQUAL(cnt.value(), 1);
-  });
-
-  VERIFY_IS_EQUAL(total, 1);
-}
-
-// All thread local values fits into the lock-free storage.
-void test_large_number_of_tasks_no_spill() {
-  int num_threads = internal::random<int>(4, 32);
-  Eigen::ThreadPool thread_pool(num_threads);
-  Eigen::ThreadLocal<Counter, InitCounter> counter(num_threads, InitCounter());
-
-  int num_tasks = 10000;
-  Eigen::Barrier barrier(num_tasks);
-
-  for (int i = 0; i < num_tasks; ++i) {
-    thread_pool.Schedule([&counter, &barrier]() {
-      Counter& local = counter.local();
-      local.inc();
-      barrier.Notify();
-    });
-  }
-
-  barrier.Wait();
-
-  int total = 0;
-  std::unordered_set<std::thread::id> unique_threads;
-
-  counter.ForEach([&](std::thread::id id, Counter& cnt) {
-    total += cnt.value();
-    unique_threads.insert(id);
-  });
-
-  VERIFY_IS_EQUAL(total, num_tasks);
-  // Not all threads in a pool might be woken up to execute submitted tasks.
-  // Also thread_pool.Schedule() might use current thread if queue is full.
-  VERIFY_IS_EQUAL(unique_threads.size() <= (static_cast<size_t>(num_threads + 1)), true);
-}
-
-// Lock free thread local storage is too small to fit all the unique threads,
-// and it spills to a map guarded by a mutex.
-void test_large_number_of_tasks_with_spill() {
-  int num_threads = internal::random<int>(4, 32);
-  Eigen::ThreadPool thread_pool(num_threads);
-  Eigen::ThreadLocal<Counter, InitCounter> counter(1, InitCounter());
-
-  int num_tasks = 10000;
-  Eigen::Barrier barrier(num_tasks);
-
-  for (int i = 0; i < num_tasks; ++i) {
-    thread_pool.Schedule([&counter, &barrier]() {
-      Counter& local = counter.local();
-      local.inc();
-      barrier.Notify();
-    });
-  }
-
-  barrier.Wait();
-
-  int total = 0;
-  std::unordered_set<std::thread::id> unique_threads;
-
-  counter.ForEach([&](std::thread::id id, Counter& cnt) {
-    total += cnt.value();
-    unique_threads.insert(id);
-  });
-
-  VERIFY_IS_EQUAL(total, num_tasks);
-  // Not all threads in a pool might be woken up to execute submitted tasks.
-  // Also thread_pool.Schedule() might use current thread if queue is full.
-  VERIFY_IS_EQUAL(unique_threads.size() <= (static_cast<size_t>(num_threads + 1)), true);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_thread_local) {
-  CALL_SUBTEST(test_simple_thread_local());
-  CALL_SUBTEST(test_zero_sized_thread_local());
-  CALL_SUBTEST(test_large_number_of_tasks_no_spill());
-  CALL_SUBTEST(test_large_number_of_tasks_with_spill());
-}
diff --git a/unsupported/test/cxx11_tensor_thread_pool.cpp b/unsupported/test/cxx11_tensor_thread_pool.cpp
deleted file mode 100644
index d1645ee..0000000
--- a/unsupported/test/cxx11_tensor_thread_pool.cpp
+++ /dev/null
@@ -1,776 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_USE_THREADS
-
-#include "main.h"
-#include <iostream>
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-class TestAllocator : public Allocator {
- public:
-  ~TestAllocator() EIGEN_OVERRIDE {}
-  EIGEN_DEVICE_FUNC void* allocate(size_t num_bytes) const EIGEN_OVERRIDE {
-    const_cast<TestAllocator*>(this)->alloc_count_++;
-    return internal::aligned_malloc(num_bytes);
-  }
-  EIGEN_DEVICE_FUNC void deallocate(void* buffer) const EIGEN_OVERRIDE {
-    const_cast<TestAllocator*>(this)->dealloc_count_++;
-    internal::aligned_free(buffer);
-  }
-
-  int alloc_count() const { return alloc_count_; }
-  int dealloc_count() const { return dealloc_count_; }
-
- private:
-  int alloc_count_ = 0;
-  int dealloc_count_ = 0;
-};
-
-void test_multithread_elementwise() {
-  Tensor<float, 3> in1(200, 30, 70);
-  Tensor<float, 3> in2(200, 30, 70);
-  Tensor<double, 3> out(200, 30, 70);
-
-  in1.setRandom();
-  in2.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-  out.device(thread_pool_device) = (in1 + in2 * 3.14f).cast<double>();
-
-  for (int i = 0; i < 200; ++i) {
-    for (int j = 0; j < 30; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), static_cast<double>(in1(i, j, k) + in2(i, j, k) * 3.14f));
-      }
-    }
-  }
-}
-
-void test_async_multithread_elementwise() {
-  Tensor<float, 3> in1(200, 30, 70);
-  Tensor<float, 3> in2(200, 30, 70);
-  Tensor<double, 3> out(200, 30, 70);
-
-  in1.setRandom();
-  in2.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-
-  Eigen::Barrier b(1);
-  out.device(thread_pool_device, [&b]() { b.Notify(); }) = (in1 + in2 * 3.14f).cast<double>();
-  b.Wait();
-
-  for (int i = 0; i < 200; ++i) {
-    for (int j = 0; j < 30; ++j) {
-      for (int k = 0; k < 70; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), static_cast<double>(in1(i, j, k) + in2(i, j, k) * 3.14f));
-      }
-    }
-  }
-}
-
-void test_multithread_chip() {
-  Tensor<float, 5> in(2, 3, 5, 7, 11);
-  Tensor<float, 4> out(3, 5, 7, 11);
-
-  in.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-
-  out.device(thread_pool_device) = in.chip(1, 0);
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(out(i, j, k, l), in(1, i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-void test_async_multithread_chip() {
-  Tensor<float, 5> in(2, 3, 5, 7, 11);
-  Tensor<float, 4> out(3, 5, 7, 11);
-
-  in.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-
-  Eigen::Barrier b(1);
-  out.device(thread_pool_device, [&b]() { b.Notify(); }) = in.chip(1, 0);
-  b.Wait();
-
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(out(i, j, k, l), in(1, i, j, k, l));
-        }
-      }
-    }
-  }
-}
-
-void test_multithread_volume_patch() {
-  Tensor<float, 5> in(4, 2, 3, 5, 7);
-  Tensor<float, 6> out(4, 1, 1, 1, 2 * 3 * 5, 7);
-
-  in.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-
-  out.device(thread_pool_device) = in.extract_volume_patches(1, 1, 1);
-
-  for (int i = 0; i < in.size(); ++i) {
-    VERIFY_IS_EQUAL(in.data()[i], out.data()[i]);
-  }
-}
-
-void test_async_multithread_volume_patch() {
-  Tensor<float, 5> in(4, 2, 3, 5, 7);
-  Tensor<float, 6> out(4, 1, 1, 1, 2 * 3 * 5, 7);
-
-  in.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-
-  Eigen::Barrier b(1);
-  out.device(thread_pool_device, [&b]() { b.Notify(); }) = in.extract_volume_patches(1, 1, 1);
-  b.Wait();
-
-  for (int i = 0; i < in.size(); ++i) {
-    VERIFY_IS_EQUAL(in.data()[i], out.data()[i]);
-  }
-}
-
-void test_multithread_compound_assignment() {
-  Tensor<float, 3> in1(2, 3, 7);
-  Tensor<float, 3> in2(2, 3, 7);
-  Tensor<float, 3> out(2, 3, 7);
-
-  in1.setRandom();
-  in2.setRandom();
-
-  Eigen::ThreadPool tp(internal::random<int>(3, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(3, 11));
-  out.device(thread_pool_device) = in1;
-  out.device(thread_pool_device) += in2 * 3.14f;
-
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        VERIFY_IS_APPROX(out(i, j, k), in1(i, j, k) + in2(i, j, k) * 3.14f);
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-void test_multithread_contraction() {
-  Tensor<float, 4, DataLayout> t_left(30, 50, 37, 31);
-  Tensor<float, 5, DataLayout> t_right(37, 31, 70, 2, 10);
-  Tensor<float, 5, DataLayout> t_result(30, 50, 70, 2, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-
-  // this contraction should be equivalent to a single matrix multiplication
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 2> dims{{DimPair(2, 0), DimPair(3, 1)}};
-
-  typedef Map<Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 1500, 1147);
-  MapXf m_right(t_right.data(), 1147, 1400);
-  Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
-
-  Eigen::ThreadPool tp(4);
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, 4);
-
-  // compute results by separate methods
-  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
-  m_result = m_left * m_right;
-
-  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
-    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
-    if (fabsf(t_result(i) - m_result(i)) < 1e-4f) {
-      continue;
-    }
-    if (Eigen::internal::isApprox(t_result(i), m_result(i), 1e-4f)) {
-      continue;
-    }
-    std::cout << "mismatch detected at index " << i << ": " << t_result(i) << " vs " << m_result(i) << std::endl;
-    assert(false);
-  }
-}
-
-template <int DataLayout>
-void test_contraction_corner_cases() {
-  Tensor<float, 2, DataLayout> t_left(32, 500);
-  Tensor<float, 2, DataLayout> t_right(32, 28 * 28);
-  Tensor<float, 2, DataLayout> t_result(500, 28 * 28);
-
-  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
-  t_right = (t_right.constant(-0.6f) + t_right.random()) * 2.0f;
-  t_result = t_result.constant(NAN);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims{{DimPair(0, 0)}};
-
-  typedef Map<Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 32, 500);
-  MapXf m_right(t_right.data(), 32, 28 * 28);
-  Matrix<float, Dynamic, Dynamic, DataLayout> m_result(500, 28 * 28);
-
-  Eigen::ThreadPool tp(12);
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, 12);
-
-  // compute results by separate methods
-  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
-  m_result = m_left.transpose() * m_right;
-
-  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
-    assert(!(numext::isnan)(t_result.data()[i]));
-    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 1e-4f) {
-      std::cout << "mismatch detected at index " << i << " : " << t_result.data()[i] << " vs " << m_result.data()[i]
-                << std::endl;
-      assert(false);
-    }
-  }
-
-  t_left.resize(32, 1);
-  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
-  t_result.resize(1, 28 * 28);
-  t_result = t_result.constant(NAN);
-  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
-  new (&m_left) MapXf(t_left.data(), 32, 1);
-  m_result = m_left.transpose() * m_right;
-  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
-    assert(!(numext::isnan)(t_result.data()[i]));
-    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 1e-4f) {
-      std::cout << "mismatch detected: " << t_result.data()[i] << " vs " << m_result.data()[i] << std::endl;
-      assert(false);
-    }
-  }
-
-  t_left.resize(32, 500);
-  t_right.resize(32, 4);
-  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
-  t_right = (t_right.constant(-0.6f) + t_right.random()) * 2.0f;
-  t_result.resize(500, 4);
-  t_result = t_result.constant(NAN);
-  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
-  new (&m_left) MapXf(t_left.data(), 32, 500);
-  new (&m_right) MapXf(t_right.data(), 32, 4);
-  m_result = m_left.transpose() * m_right;
-  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
-    assert(!(numext::isnan)(t_result.data()[i]));
-    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 1e-4f) {
-      std::cout << "mismatch detected: " << t_result.data()[i] << " vs " << m_result.data()[i] << std::endl;
-      assert(false);
-    }
-  }
-
-  t_left.resize(32, 1);
-  t_right.resize(32, 4);
-  t_left = (t_left.constant(-0.5f) + t_left.random()) * 2.0f;
-  t_right = (t_right.constant(-0.6f) + t_right.random()) * 2.0f;
-  t_result.resize(1, 4);
-  t_result = t_result.constant(NAN);
-  t_result.device(thread_pool_device) = t_left.contract(t_right, dims);
-  new (&m_left) MapXf(t_left.data(), 32, 1);
-  new (&m_right) MapXf(t_right.data(), 32, 4);
-  m_result = m_left.transpose() * m_right;
-  for (ptrdiff_t i = 0; i < t_result.size(); i++) {
-    assert(!(numext::isnan)(t_result.data()[i]));
-    if (fabsf(t_result.data()[i] - m_result.data()[i]) >= 1e-4f) {
-      std::cout << "mismatch detected: " << t_result.data()[i] << " vs " << m_result.data()[i] << std::endl;
-      assert(false);
-    }
-  }
-}
-
-template <int DataLayout>
-void test_multithread_contraction_agrees_with_singlethread() {
-  int contract_size = internal::random<int>(1, 5000);
-
-  Tensor<float, 3, DataLayout> left(internal::random<int>(1, 80), contract_size, internal::random<int>(1, 100));
-
-  Tensor<float, 4, DataLayout> right(internal::random<int>(1, 25), internal::random<int>(1, 37), contract_size,
-                                     internal::random<int>(1, 51));
-
-  left.setRandom();
-  right.setRandom();
-
-  // add constants to shift values away from 0 for more precision
-  left += left.constant(1.5f);
-  right += right.constant(1.5f);
-
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 2)}};
-
-  Eigen::ThreadPool tp(internal::random<int>(2, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(2, 11));
-
-  Tensor<float, 5, DataLayout> st_result;
-  st_result = left.contract(right, dims);
-
-  Tensor<float, 5, DataLayout> tp_result(st_result.dimensions());
-  tp_result.device(thread_pool_device) = left.contract(right, dims);
-
-  VERIFY(dimensions_match(st_result.dimensions(), tp_result.dimensions()));
-  for (ptrdiff_t i = 0; i < st_result.size(); i++) {
-    // if both of the values are very small, then do nothing (because the test will fail
-    // due to numerical precision issues when values are small)
-    if (numext::abs(st_result.data()[i] - tp_result.data()[i]) >= 1e-4f) {
-      VERIFY_IS_APPROX(st_result.data()[i], tp_result.data()[i]);
-    }
-  }
-}
-
-// Apply Sqrt to all output elements.
-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));
-      }
-    }
-  }
-};
-
-template <int DataLayout>
-static void test_multithread_contraction_with_output_kernel() {
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-
-  const int num_threads = internal::random<int>(2, 11);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads);
-
-  Tensor<float, 4, DataLayout> t_left(30, 50, 8, 31);
-  Tensor<float, 5, DataLayout> t_right(8, 31, 7, 20, 10);
-  Tensor<float, 5, DataLayout> t_result(30, 50, 7, 20, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-  // Put trash in mat4 to verify contraction clears output memory.
-  t_result.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 1500, 248);
-  MapXf m_right(t_right.data(), 248, 1400);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(1500, 1400);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 2> dims{{DimPair(2, 0), DimPair(3, 1)}};
-
-  // compute results by separate methods
-  t_result.device(device) = t_left.contract(t_right, dims, SqrtOutputKernel());
-
-  m_result = m_left * m_right;
-
-  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY(&t_result.data()[i] != &m_result.data()[i]);
-    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
-  }
-}
-
-template <int DataLayout>
-void test_async_multithread_contraction_agrees_with_singlethread() {
-  int contract_size = internal::random<int>(100, 500);
-
-  Tensor<float, 3, DataLayout> left(internal::random<int>(10, 40), contract_size, internal::random<int>(10, 40));
-
-  Tensor<float, 4, DataLayout> right(internal::random<int>(1, 20), internal::random<int>(1, 20), contract_size,
-                                     internal::random<int>(1, 20));
-
-  left.setRandom();
-  right.setRandom();
-
-  // add constants to shift values away from 0 for more precision
-  left += left.constant(1.5f);
-  right += right.constant(1.5f);
-
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 2)}};
-
-  Eigen::ThreadPool tp(internal::random<int>(2, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(8, 32));
-
-  Tensor<float, 5, DataLayout> st_result;
-  st_result = left.contract(right, dims);
-
-  Tensor<float, 5, DataLayout> tp_result(st_result.dimensions());
-
-  Eigen::Barrier barrier(1);
-  tp_result.device(thread_pool_device, [&barrier]() { barrier.Notify(); }) = left.contract(right, dims);
-  barrier.Wait();
-
-  VERIFY(dimensions_match(st_result.dimensions(), tp_result.dimensions()));
-  for (ptrdiff_t i = 0; i < st_result.size(); i++) {
-    // if both of the values are very small, then do nothing (because the test
-    // will fail due to numerical precision issues when values are small)
-    if (numext::abs(st_result.data()[i] - tp_result.data()[i]) >= 1e-4f) {
-      VERIFY_IS_APPROX(st_result.data()[i], tp_result.data()[i]);
-    }
-  }
-}
-
-// We are triggering 'evalShardedByInnerDim' optimization.
-template <int DataLayout>
-static void test_sharded_by_inner_dim_contraction() {
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-
-  const int num_threads = internal::random<int>(4, 16);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads);
-
-  Tensor<float, 2, DataLayout> t_left(2, 10000);
-  Tensor<float, 2, DataLayout> t_right(10000, 10);
-  Tensor<float, 2, DataLayout> t_result(2, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-  // Put trash in t_result to verify contraction clears output memory.
-  t_result.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 2, 10000);
-  MapXf m_right(t_right.data(), 10000, 10);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
-
-  // compute results by separate methods
-  t_result.device(device) = t_left.contract(t_right, dims);
-  m_result = m_left * m_right;
-
-  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
-  }
-}
-
-// We are triggering 'evalShardedByInnerDim' optimization with output kernel.
-template <int DataLayout>
-static void test_sharded_by_inner_dim_contraction_with_output_kernel() {
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-
-  const int num_threads = internal::random<int>(4, 16);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads);
-
-  Tensor<float, 2, DataLayout> t_left(2, 10000);
-  Tensor<float, 2, DataLayout> t_right(10000, 10);
-  Tensor<float, 2, DataLayout> t_result(2, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-  // Put trash in t_result to verify contraction clears output memory.
-  t_result.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 2, 10000);
-  MapXf m_right(t_right.data(), 10000, 10);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
-
-  // compute results by separate methods
-  t_result.device(device) = t_left.contract(t_right, dims, SqrtOutputKernel());
-  m_result = m_left * m_right;
-
-  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
-  }
-}
-
-// We are triggering 'evalShardedByInnerDim' optimization.
-template <int DataLayout>
-static void test_async_sharded_by_inner_dim_contraction() {
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-
-  const int num_threads = internal::random<int>(4, 16);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads);
-
-  Tensor<float, 2, DataLayout> t_left(2, 10000);
-  Tensor<float, 2, DataLayout> t_right(10000, 10);
-  Tensor<float, 2, DataLayout> t_result(2, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-  // Put trash in t_result to verify contraction clears output memory.
-  t_result.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 2, 10000);
-  MapXf m_right(t_right.data(), 10000, 10);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
-
-  // compute results by separate methods
-  Eigen::Barrier barrier(1);
-  t_result.device(device, [&barrier]() { barrier.Notify(); }) = t_left.contract(t_right, dims);
-  barrier.Wait();
-
-  m_result = m_left * m_right;
-
-  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY_IS_APPROX(t_result.data()[i], m_result.data()[i]);
-  }
-}
-
-// We are triggering 'evalShardedByInnerDim' optimization with output kernel.
-template <int DataLayout>
-static void test_async_sharded_by_inner_dim_contraction_with_output_kernel() {
-  typedef Tensor<float, 1>::DimensionPair DimPair;
-
-  const int num_threads = internal::random<int>(4, 16);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads);
-
-  Tensor<float, 2, DataLayout> t_left(2, 10000);
-  Tensor<float, 2, DataLayout> t_right(10000, 10);
-  Tensor<float, 2, DataLayout> t_result(2, 10);
-
-  t_left.setRandom();
-  t_right.setRandom();
-  // Put trash in t_result to verify contraction clears output memory.
-  t_result.setRandom();
-
-  // Add a little offset so that the results won't be close to zero.
-  t_left += t_left.constant(1.0f);
-  t_right += t_right.constant(1.0f);
-
-  typedef Map<Eigen::Matrix<float, Dynamic, Dynamic, DataLayout>> MapXf;
-  MapXf m_left(t_left.data(), 2, 10000);
-  MapXf m_right(t_right.data(), 10000, 10);
-  Eigen::Matrix<float, Dynamic, Dynamic, DataLayout> m_result(2, 10);
-
-  // this contraction should be equivalent to a single matrix multiplication
-  Eigen::array<DimPair, 1> dims{{DimPair(1, 0)}};
-
-  // compute results by separate methods
-  Eigen::Barrier barrier(1);
-  t_result.device(device, [&barrier]() { barrier.Notify(); }) = t_left.contract(t_right, dims, SqrtOutputKernel());
-  barrier.Wait();
-  m_result = m_left * m_right;
-
-  for (Index i = 0; i < t_result.dimensions().TotalSize(); i++) {
-    VERIFY_IS_APPROX(t_result.data()[i], std::sqrt(m_result.data()[i]));
-  }
-}
-
-template <int DataLayout>
-void test_full_contraction() {
-  int contract_size1 = internal::random<int>(1, 500);
-  int contract_size2 = internal::random<int>(1, 500);
-
-  Tensor<float, 2, DataLayout> left(contract_size1, contract_size2);
-  Tensor<float, 2, DataLayout> right(contract_size1, contract_size2);
-  left.setRandom();
-  right.setRandom();
-
-  // add constants to shift values away from 0 for more precision
-  left += left.constant(1.5f);
-  right += right.constant(1.5f);
-
-  typedef Tensor<float, 2>::DimensionPair DimPair;
-  Eigen::array<DimPair, 2> dims{{DimPair(0, 0), DimPair(1, 1)}};
-
-  Eigen::ThreadPool tp(internal::random<int>(2, 11));
-  Eigen::ThreadPoolDevice thread_pool_device(&tp, internal::random<int>(2, 11));
-
-  Tensor<float, 0, DataLayout> st_result;
-  st_result = left.contract(right, dims);
-
-  Tensor<float, 0, DataLayout> tp_result;
-  tp_result.device(thread_pool_device) = left.contract(right, dims);
-
-  VERIFY(dimensions_match(st_result.dimensions(), tp_result.dimensions()));
-  // if both of the values are very small, then do nothing (because the test will fail
-  // due to numerical precision issues when values are small)
-  if (numext::abs(st_result() - tp_result()) >= 1e-4f) {
-    VERIFY_IS_APPROX(st_result(), tp_result());
-  }
-}
-
-template <int DataLayout>
-void test_multithreaded_reductions() {
-  const int num_threads = internal::random<int>(3, 11);
-  ThreadPool thread_pool(num_threads);
-  Eigen::ThreadPoolDevice thread_pool_device(&thread_pool, num_threads);
-
-  const int num_rows = internal::random<int>(13, 732);
-  const int num_cols = internal::random<int>(13, 732);
-  Tensor<float, 2, DataLayout> t1(num_rows, num_cols);
-  t1.setRandom();
-
-  Tensor<float, 0, DataLayout> full_redux;
-  full_redux = t1.sum();
-
-  Tensor<float, 0, DataLayout> full_redux_tp;
-  full_redux_tp.device(thread_pool_device) = t1.sum();
-
-  // Check that the single threaded and the multi threaded reductions return
-  // the same result.
-  VERIFY_IS_APPROX(full_redux(), full_redux_tp());
-}
-
-void test_memcpy() {
-  for (int i = 0; i < 5; ++i) {
-    const int num_threads = internal::random<int>(3, 11);
-    Eigen::ThreadPool tp(num_threads);
-    Eigen::ThreadPoolDevice thread_pool_device(&tp, num_threads);
-
-    const int size = internal::random<int>(13, 7632);
-    Tensor<float, 1> t1(size);
-    t1.setRandom();
-    std::vector<float> result(size);
-    thread_pool_device.memcpy(&result[0], t1.data(), size * sizeof(float));
-    for (int j = 0; j < size; j++) {
-      VERIFY_IS_EQUAL(t1(j), result[j]);
-    }
-  }
-}
-
-void test_multithread_random() {
-  Eigen::ThreadPool tp(2);
-  Eigen::ThreadPoolDevice device(&tp, 2);
-  Tensor<float, 1> t(1 << 20);
-  t.device(device) = t.random<Eigen::internal::NormalRandomGenerator<float>>();
-}
-
-template <int DataLayout>
-void test_multithread_shuffle(Allocator* allocator) {
-  Tensor<float, 4, DataLayout> tensor(17, 5, 7, 11);
-  tensor.setRandom();
-
-  const int num_threads = internal::random<int>(2, 11);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads, allocator);
-
-  Tensor<float, 4, DataLayout> shuffle(7, 5, 11, 17);
-  array<ptrdiff_t, 4> shuffles = {{2, 1, 3, 0}};
-  shuffle.device(device) = tensor.shuffle(shuffles);
-
-  for (int i = 0; i < 17; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      for (int k = 0; k < 7; ++k) {
-        for (int l = 0; l < 11; ++l) {
-          VERIFY_IS_EQUAL(tensor(i, j, k, l), shuffle(k, j, l, i));
-        }
-      }
-    }
-  }
-}
-
-void test_threadpool_allocate(TestAllocator* allocator) {
-  const int num_threads = internal::random<int>(2, 11);
-  const int num_allocs = internal::random<int>(2, 11);
-  ThreadPool threads(num_threads);
-  Eigen::ThreadPoolDevice device(&threads, num_threads, allocator);
-
-  for (int a = 0; a < num_allocs; ++a) {
-    void* ptr = device.allocate(512);
-    device.deallocate(ptr);
-  }
-  VERIFY(allocator != NULL);
-  VERIFY_IS_EQUAL(allocator->alloc_count(), num_allocs);
-  VERIFY_IS_EQUAL(allocator->dealloc_count(), num_allocs);
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_thread_pool) {
-  CALL_SUBTEST_1(test_multithread_elementwise());
-  CALL_SUBTEST_1(test_async_multithread_elementwise());
-  CALL_SUBTEST_1(test_multithread_compound_assignment());
-
-  CALL_SUBTEST_2(test_multithread_contraction<ColMajor>());
-  CALL_SUBTEST_2(test_multithread_contraction<RowMajor>());
-
-  CALL_SUBTEST_3(test_multithread_chip());
-  CALL_SUBTEST_3(test_async_multithread_chip());
-
-  CALL_SUBTEST_4(test_multithread_volume_patch());
-  CALL_SUBTEST_4(test_async_multithread_volume_patch());
-
-  CALL_SUBTEST_5(test_multithread_contraction_agrees_with_singlethread<ColMajor>());
-  CALL_SUBTEST_5(test_multithread_contraction_agrees_with_singlethread<RowMajor>());
-  CALL_SUBTEST_5(test_multithread_contraction_with_output_kernel<ColMajor>());
-  CALL_SUBTEST_5(test_multithread_contraction_with_output_kernel<RowMajor>());
-
-  CALL_SUBTEST_6(test_async_multithread_contraction_agrees_with_singlethread<ColMajor>());
-  CALL_SUBTEST_6(test_async_multithread_contraction_agrees_with_singlethread<RowMajor>());
-
-  // Test EvalShardedByInnerDimContext parallelization strategy.
-  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction<ColMajor>());
-  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction<RowMajor>());
-  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction_with_output_kernel<ColMajor>());
-  CALL_SUBTEST_7(test_sharded_by_inner_dim_contraction_with_output_kernel<RowMajor>());
-
-  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction<ColMajor>());
-  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction<RowMajor>());
-  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction_with_output_kernel<ColMajor>());
-  CALL_SUBTEST_8(test_async_sharded_by_inner_dim_contraction_with_output_kernel<RowMajor>());
-
-  // Exercise various cases that have been problematic in the past.
-  CALL_SUBTEST_9(test_contraction_corner_cases<ColMajor>());
-  CALL_SUBTEST_9(test_contraction_corner_cases<RowMajor>());
-
-  CALL_SUBTEST_10(test_full_contraction<ColMajor>());
-  CALL_SUBTEST_10(test_full_contraction<RowMajor>());
-
-  CALL_SUBTEST_11(test_multithreaded_reductions<ColMajor>());
-  CALL_SUBTEST_11(test_multithreaded_reductions<RowMajor>());
-
-  CALL_SUBTEST_12(test_memcpy());
-  CALL_SUBTEST_12(test_multithread_random());
-
-  TestAllocator test_allocator;
-  CALL_SUBTEST_13(test_multithread_shuffle<ColMajor>(NULL));
-  CALL_SUBTEST_13(test_multithread_shuffle<RowMajor>(&test_allocator));
-  CALL_SUBTEST_13(test_threadpool_allocate(&test_allocator));
-
-  // Force CMake to split this test.
-  // EIGEN_SUFFIXES;1;2;3;4;5;6;7;8;9;10;11;12;13
-}
diff --git a/unsupported/test/cxx11_tensor_trace.cpp b/unsupported/test/cxx11_tensor_trace.cpp
deleted file mode 100644
index bf013d0..0000000
--- a/unsupported/test/cxx11_tensor_trace.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2017 Gagan Goel <gagan.nith@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::array;
-using Eigen::Tensor;
-
-template <int DataLayout>
-static void test_0D_trace() {
-  Tensor<float, 0, DataLayout> tensor;
-  tensor.setRandom();
-  array<ptrdiff_t, 0> dims;
-  Tensor<float, 0, DataLayout> result = tensor.trace(dims);
-  VERIFY_IS_EQUAL(result(), tensor());
-}
-
-template <int DataLayout>
-static void test_all_dimensions_trace() {
-  Tensor<float, 3, DataLayout> tensor1(5, 5, 5);
-  tensor1.setRandom();
-  Tensor<float, 0, DataLayout> result1 = tensor1.trace();
-  VERIFY_IS_EQUAL(result1.rank(), 0);
-  float sum = 0.0f;
-  for (int i = 0; i < 5; ++i) {
-    sum += tensor1(i, i, i);
-  }
-  VERIFY_IS_EQUAL(result1(), sum);
-
-  Tensor<float, 5, DataLayout> tensor2(7, 7, 7, 7, 7);
-  tensor2.setRandom();
-  array<ptrdiff_t, 5> dims = {{2, 1, 0, 3, 4}};
-  Tensor<float, 0, DataLayout> result2 = tensor2.trace(dims);
-  VERIFY_IS_EQUAL(result2.rank(), 0);
-  sum = 0.0f;
-  for (int i = 0; i < 7; ++i) {
-    sum += tensor2(i, i, i, i, i);
-  }
-  VERIFY_IS_EQUAL(result2(), sum);
-}
-
-template <int DataLayout>
-static void test_simple_trace() {
-  Tensor<float, 3, DataLayout> tensor1(3, 5, 3);
-  tensor1.setRandom();
-  array<ptrdiff_t, 2> dims1 = {{0, 2}};
-  Tensor<float, 1, DataLayout> result1 = tensor1.trace(dims1);
-  VERIFY_IS_EQUAL(result1.rank(), 1);
-  VERIFY_IS_EQUAL(result1.dimension(0), 5);
-  float sum = 0.0f;
-  for (int i = 0; i < 5; ++i) {
-    sum = 0.0f;
-    for (int j = 0; j < 3; ++j) {
-      sum += tensor1(j, i, j);
-    }
-    VERIFY_IS_EQUAL(result1(i), sum);
-  }
-
-  Tensor<float, 4, DataLayout> tensor2(5, 5, 7, 7);
-  tensor2.setRandom();
-  array<ptrdiff_t, 2> dims2 = {{2, 3}};
-  Tensor<float, 2, DataLayout> result2 = tensor2.trace(dims2);
-  VERIFY_IS_EQUAL(result2.rank(), 2);
-  VERIFY_IS_EQUAL(result2.dimension(0), 5);
-  VERIFY_IS_EQUAL(result2.dimension(1), 5);
-  for (int i = 0; i < 5; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      sum = 0.0f;
-      for (int k = 0; k < 7; ++k) {
-        sum += tensor2(i, j, k, k);
-      }
-      VERIFY_IS_EQUAL(result2(i, j), sum);
-    }
-  }
-
-  array<ptrdiff_t, 2> dims3 = {{1, 0}};
-  Tensor<float, 2, DataLayout> result3 = tensor2.trace(dims3);
-  VERIFY_IS_EQUAL(result3.rank(), 2);
-  VERIFY_IS_EQUAL(result3.dimension(0), 7);
-  VERIFY_IS_EQUAL(result3.dimension(1), 7);
-  for (int i = 0; i < 7; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      sum = 0.0f;
-      for (int k = 0; k < 5; ++k) {
-        sum += tensor2(k, k, i, j);
-      }
-      VERIFY_IS_EQUAL(result3(i, j), sum);
-    }
-  }
-
-  Tensor<float, 5, DataLayout> tensor3(3, 7, 3, 7, 3);
-  tensor3.setRandom();
-  array<ptrdiff_t, 3> dims4 = {{0, 2, 4}};
-  Tensor<float, 2, DataLayout> result4 = tensor3.trace(dims4);
-  VERIFY_IS_EQUAL(result4.rank(), 2);
-  VERIFY_IS_EQUAL(result4.dimension(0), 7);
-  VERIFY_IS_EQUAL(result4.dimension(1), 7);
-  for (int i = 0; i < 7; ++i) {
-    for (int j = 0; j < 7; ++j) {
-      sum = 0.0f;
-      for (int k = 0; k < 3; ++k) {
-        sum += tensor3(k, i, k, j, k);
-      }
-      VERIFY_IS_EQUAL(result4(i, j), sum);
-    }
-  }
-
-  Tensor<float, 5, DataLayout> tensor4(3, 7, 4, 7, 5);
-  tensor4.setRandom();
-  array<ptrdiff_t, 2> dims5 = {{1, 3}};
-  Tensor<float, 3, DataLayout> result5 = tensor4.trace(dims5);
-  VERIFY_IS_EQUAL(result5.rank(), 3);
-  VERIFY_IS_EQUAL(result5.dimension(0), 3);
-  VERIFY_IS_EQUAL(result5.dimension(1), 4);
-  VERIFY_IS_EQUAL(result5.dimension(2), 5);
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 4; ++j) {
-      for (int k = 0; k < 5; ++k) {
-        sum = 0.0f;
-        for (int l = 0; l < 7; ++l) {
-          sum += tensor4(i, l, j, l, k);
-        }
-        VERIFY_IS_EQUAL(result5(i, j, k), sum);
-      }
-    }
-  }
-}
-
-template <int DataLayout>
-static void test_trace_in_expr() {
-  Tensor<float, 4, DataLayout> tensor(2, 3, 5, 3);
-  tensor.setRandom();
-  array<ptrdiff_t, 2> dims = {{1, 3}};
-  Tensor<float, 2, DataLayout> result(2, 5);
-  result = result.constant(1.0f) - tensor.trace(dims);
-  VERIFY_IS_EQUAL(result.rank(), 2);
-  VERIFY_IS_EQUAL(result.dimension(0), 2);
-  VERIFY_IS_EQUAL(result.dimension(1), 5);
-  float sum = 0.0f;
-  for (int i = 0; i < 2; ++i) {
-    for (int j = 0; j < 5; ++j) {
-      sum = 0.0f;
-      for (int k = 0; k < 3; ++k) {
-        sum += tensor(i, k, j, k);
-      }
-      VERIFY_IS_EQUAL(result(i, j), 1.0f - sum);
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_trace) {
-  CALL_SUBTEST(test_0D_trace<ColMajor>());
-  CALL_SUBTEST(test_0D_trace<RowMajor>());
-  CALL_SUBTEST(test_all_dimensions_trace<ColMajor>());
-  CALL_SUBTEST(test_all_dimensions_trace<RowMajor>());
-  CALL_SUBTEST(test_simple_trace<ColMajor>());
-  CALL_SUBTEST(test_simple_trace<RowMajor>());
-  CALL_SUBTEST(test_trace_in_expr<ColMajor>());
-  CALL_SUBTEST(test_trace_in_expr<RowMajor>());
-}
diff --git a/unsupported/test/cxx11_tensor_uint128.cpp b/unsupported/test/cxx11_tensor_uint128.cpp
deleted file mode 100644
index 739b459..0000000
--- a/unsupported/test/cxx11_tensor_uint128.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-#if EIGEN_COMP_MSVC || !defined(__SIZEOF_INT128__)
-#define EIGEN_NO_INT128
-#else
-typedef __uint128_t uint128_t;
-#endif
-
-// Only run the test on compilers that support 128bit integers natively
-#ifndef EIGEN_NO_INT128
-
-using Eigen::internal::static_val;
-using Eigen::internal::TensorUInt128;
-
-void VERIFY_EQUAL(TensorUInt128<uint64_t, uint64_t> actual, uint128_t expected) {
-  bool matchl = actual.lower() == static_cast<uint64_t>(expected);
-  bool matchh = actual.upper() == static_cast<uint64_t>(expected >> 64);
-  if (!matchl || !matchh) {
-    const char* testname = g_test_stack.back().c_str();
-    std::cerr << "Test " << testname << " failed in " << __FILE__ << " (" << __LINE__ << ")" << std::endl;
-    abort();
-  }
-}
-
-void test_add() {
-  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
-  for (uint64_t i1 = 0; i1 < 100; ++i1) {
-    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
-      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
-      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
-      for (uint64_t j1 = 0; j1 < 100; ++j1) {
-        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
-          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
-          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
-          TensorUInt128<uint64_t, uint64_t> actual = i + j;
-          uint128_t expected = a + b;
-          VERIFY_EQUAL(actual, expected);
-        }
-      }
-    }
-  }
-}
-
-void test_sub() {
-  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
-  for (uint64_t i1 = 0; i1 < 100; ++i1) {
-    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
-      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
-      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
-      for (uint64_t j1 = 0; j1 < 100; ++j1) {
-        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
-          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
-          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
-          TensorUInt128<uint64_t, uint64_t> actual = i - j;
-          uint128_t expected = a - b;
-          VERIFY_EQUAL(actual, expected);
-        }
-      }
-    }
-  }
-}
-
-void test_mul() {
-  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
-  for (uint64_t i1 = 0; i1 < 100; ++i1) {
-    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
-      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
-      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
-      for (uint64_t j1 = 0; j1 < 100; ++j1) {
-        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
-          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
-          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
-          TensorUInt128<uint64_t, uint64_t> actual = i * j;
-          uint128_t expected = a * b;
-          VERIFY_EQUAL(actual, expected);
-        }
-      }
-    }
-  }
-}
-
-void test_div() {
-  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
-  for (uint64_t i1 = 0; i1 < 100; ++i1) {
-    for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
-      TensorUInt128<uint64_t, uint64_t> i(i1, i2);
-      uint128_t a = (static_cast<uint128_t>(i1) << 64) + static_cast<uint128_t>(i2);
-      for (uint64_t j1 = 0; j1 < 100; ++j1) {
-        for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
-          TensorUInt128<uint64_t, uint64_t> j(j1, j2);
-          uint128_t b = (static_cast<uint128_t>(j1) << 64) + static_cast<uint128_t>(j2);
-          TensorUInt128<uint64_t, uint64_t> actual = i / j;
-          uint128_t expected = a / b;
-          VERIFY_EQUAL(actual, expected);
-        }
-      }
-    }
-  }
-}
-
-void test_misc1() {
-  uint64_t incr = internal::random<uint64_t>(1, 9999999999);
-  for (uint64_t i2 = 1; i2 < 100 * incr; i2 += incr) {
-    TensorUInt128<static_val<0>, uint64_t> i(0, i2);
-    uint128_t a = static_cast<uint128_t>(i2);
-    for (uint64_t j2 = 1; j2 < 100 * incr; j2 += incr) {
-      TensorUInt128<static_val<0>, uint64_t> j(0, j2);
-      uint128_t b = static_cast<uint128_t>(j2);
-      uint64_t actual = (i * j).upper();
-      uint64_t expected = (a * b) >> 64;
-      VERIFY_IS_EQUAL(actual, expected);
-    }
-  }
-}
-
-void test_misc2() {
-  int64_t incr = internal::random<int64_t>(1, 100);
-  for (int64_t log_div = 0; log_div < 63; ++log_div) {
-    for (int64_t divider = 1; divider <= 1000000 * incr; divider += incr) {
-      uint64_t expected = (static_cast<uint128_t>(1) << (64 + log_div)) / static_cast<uint128_t>(divider) -
-                          (static_cast<uint128_t>(1) << 64) + 1;
-      uint64_t shift = 1ULL << log_div;
-
-      TensorUInt128<uint64_t, uint64_t> result =
-          (TensorUInt128<uint64_t, static_val<0> >(shift, 0) / TensorUInt128<static_val<0>, uint64_t>(divider) -
-           TensorUInt128<static_val<1>, static_val<0> >(1, 0) + TensorUInt128<static_val<0>, static_val<1> >(1));
-      uint64_t actual = static_cast<uint64_t>(result);
-      VERIFY_IS_EQUAL(actual, expected);
-    }
-  }
-}
-#endif
-
-EIGEN_DECLARE_TEST(cxx11_tensor_uint128) {
-#ifdef EIGEN_NO_INT128
-  // Skip the test on compilers that don't support 128bit integers natively
-  return;
-#else
-  CALL_SUBTEST_1(test_add());
-  CALL_SUBTEST_2(test_sub());
-  CALL_SUBTEST_3(test_mul());
-  CALL_SUBTEST_4(test_div());
-  CALL_SUBTEST_5(test_misc1());
-  CALL_SUBTEST_6(test_misc2());
-#endif
-}
diff --git a/unsupported/test/cxx11_tensor_volume_patch.cpp b/unsupported/test/cxx11_tensor_volume_patch.cpp
deleted file mode 100644
index 31da410..0000000
--- a/unsupported/test/cxx11_tensor_volume_patch.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "main.h"
-
-#include <Eigen/Tensor>
-
-using Eigen::Tensor;
-
-static void test_single_voxel_patch() {
-  Tensor<float, 5> tensor(4, 2, 3, 5, 7);
-  tensor.setRandom();
-  Tensor<float, 5, RowMajor> tensor_row_major = tensor.swap_layout();
-
-  Tensor<float, 6> single_voxel_patch;
-  single_voxel_patch = tensor.extract_volume_patches(1, 1, 1);
-  VERIFY_IS_EQUAL(single_voxel_patch.dimension(0), 4);
-  VERIFY_IS_EQUAL(single_voxel_patch.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch.dimension(3), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch.dimension(4), 2 * 3 * 5);
-  VERIFY_IS_EQUAL(single_voxel_patch.dimension(5), 7);
-
-  Tensor<float, 6, RowMajor> single_voxel_patch_row_major;
-  single_voxel_patch_row_major = tensor_row_major.extract_volume_patches(1, 1, 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(1), 2 * 3 * 5);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(3), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(4), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(5), 4);
-
-  for (int i = 0; i < tensor.size(); ++i) {
-    VERIFY_IS_EQUAL(tensor.data()[i], single_voxel_patch.data()[i]);
-    VERIFY_IS_EQUAL(tensor_row_major.data()[i], single_voxel_patch_row_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor.data()[i], tensor_row_major.data()[i]);
-  }
-}
-
-static void test_entire_volume_patch() {
-  const int depth = 4;
-  const int patch_z = 2;
-  const int patch_y = 3;
-  const int patch_x = 5;
-  const int batch = 7;
-
-  Tensor<float, 5> tensor(depth, patch_z, patch_y, patch_x, batch);
-  tensor.setRandom();
-  Tensor<float, 5, RowMajor> tensor_row_major = tensor.swap_layout();
-
-  Tensor<float, 6> entire_volume_patch;
-  entire_volume_patch = tensor.extract_volume_patches(patch_z, patch_y, patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch.dimension(0), depth);
-  VERIFY_IS_EQUAL(entire_volume_patch.dimension(1), patch_z);
-  VERIFY_IS_EQUAL(entire_volume_patch.dimension(2), patch_y);
-  VERIFY_IS_EQUAL(entire_volume_patch.dimension(3), patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch.dimension(4), patch_z * patch_y * patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch.dimension(5), batch);
-
-  Tensor<float, 6, RowMajor> entire_volume_patch_row_major;
-  entire_volume_patch_row_major = tensor_row_major.extract_volume_patches(patch_z, patch_y, patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(0), batch);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(1), patch_z * patch_y * patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(2), patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(3), patch_y);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(4), patch_z);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(5), depth);
-
-  const int dz = patch_z - 1;
-  const int dy = patch_y - 1;
-  const int dx = patch_x - 1;
-
-  const int forward_pad_z = dz / 2;
-  const int forward_pad_y = dy / 2;
-  const int forward_pad_x = dx / 2;
-
-  for (int pz = 0; pz < patch_z; pz++) {
-    for (int py = 0; py < patch_y; py++) {
-      for (int px = 0; px < patch_x; px++) {
-        const int patchId = pz + patch_z * (py + px * patch_y);
-        for (int z = 0; z < patch_z; z++) {
-          for (int y = 0; y < patch_y; y++) {
-            for (int x = 0; x < patch_x; x++) {
-              for (int b = 0; b < batch; b++) {
-                for (int d = 0; d < depth; d++) {
-                  float expected = 0.0f;
-                  float expected_row_major = 0.0f;
-                  const int eff_z = z - forward_pad_z + pz;
-                  const int eff_y = y - forward_pad_y + py;
-                  const int eff_x = x - forward_pad_x + px;
-                  if (eff_z >= 0 && eff_y >= 0 && eff_x >= 0 && eff_z < patch_z && eff_y < patch_y && eff_x < patch_x) {
-                    expected = tensor(d, eff_z, eff_y, eff_x, b);
-                    expected_row_major = tensor_row_major(b, eff_x, eff_y, eff_z, d);
-                  }
-                  VERIFY_IS_EQUAL(entire_volume_patch(d, z, y, x, patchId, b), expected);
-                  VERIFY_IS_EQUAL(entire_volume_patch_row_major(b, patchId, x, y, z, d), expected_row_major);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-EIGEN_DECLARE_TEST(cxx11_tensor_volume_patch) {
-  CALL_SUBTEST(test_single_voxel_patch());
-  CALL_SUBTEST(test_entire_volume_patch());
-}
diff --git a/unsupported/test/cxx11_tensor_volume_patch_sycl.cpp b/unsupported/test/cxx11_tensor_volume_patch_sycl.cpp
deleted file mode 100644
index 327ac67..0000000
--- a/unsupported/test/cxx11_tensor_volume_patch_sycl.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016
-// Mehdi Goli    Codeplay Software Ltd.
-// Ralph Potter  Codeplay Software Ltd.
-// Luke Iwanski  Codeplay Software Ltd.
-// Contact: <eigen@codeplay.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#define EIGEN_TEST_NO_LONGDOUBLE
-#define EIGEN_TEST_NO_COMPLEX
-
-#define EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t
-#define EIGEN_USE_SYCL
-
-#include "main.h"
-#include <unsupported/Eigen/Tensor>
-
-using Eigen::Tensor;
-static const int DataLayout = ColMajor;
-
-template <typename DataType, typename IndexType>
-static void test_single_voxel_patch_sycl(const Eigen::SyclDevice& sycl_device) {
-  IndexType sizeDim0 = 4;
-  IndexType sizeDim1 = 2;
-  IndexType sizeDim2 = 3;
-  IndexType sizeDim3 = 5;
-  IndexType sizeDim4 = 7;
-  array<IndexType, 5> tensorColMajorRange = {{sizeDim0, sizeDim1, sizeDim2, sizeDim3, sizeDim4}};
-  array<IndexType, 5> tensorRowMajorRange = {{sizeDim4, sizeDim3, sizeDim2, sizeDim1, sizeDim0}};
-  Tensor<DataType, 5, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  Tensor<DataType, 5, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-  tensor_col_major.setRandom();
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 5, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-
-  // single volume patch: ColMajor
-  array<IndexType, 6> patchColMajorTensorRange = {{sizeDim0, 1, 1, 1, sizeDim1 * sizeDim2 * sizeDim3, sizeDim4}};
-  Tensor<DataType, 6, DataLayout, IndexType> single_voxel_patch_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = single_voxel_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_single_voxel_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 6, DataLayout, IndexType>> gpu_single_voxel_patch_col_major(
-      gpu_data_single_voxel_patch_col_major, patchColMajorTensorRange);
-  gpu_single_voxel_patch_col_major.device(sycl_device) = gpu_col_major.extract_volume_patches(1, 1, 1);
-  sycl_device.memcpyDeviceToHost(single_voxel_patch_col_major.data(), gpu_data_single_voxel_patch_col_major,
-                                 patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(0), 4);
-  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(1), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(3), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(4), 2 * 3 * 5);
-  VERIFY_IS_EQUAL(single_voxel_patch_col_major.dimension(5), 7);
-
-  array<IndexType, 6> patchRowMajorTensorRange = {{sizeDim4, sizeDim1 * sizeDim2 * sizeDim3, 1, 1, 1, sizeDim0}};
-  Tensor<DataType, 6, RowMajor, IndexType> single_voxel_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = single_voxel_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_single_voxel_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 6, RowMajor, IndexType>> gpu_single_voxel_patch_row_major(
-      gpu_data_single_voxel_patch_row_major, patchRowMajorTensorRange);
-  gpu_single_voxel_patch_row_major.device(sycl_device) = gpu_row_major.extract_volume_patches(1, 1, 1);
-  sycl_device.memcpyDeviceToHost(single_voxel_patch_row_major.data(), gpu_data_single_voxel_patch_row_major,
-                                 patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(0), 7);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(1), 2 * 3 * 5);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(2), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(3), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(4), 1);
-  VERIFY_IS_EQUAL(single_voxel_patch_row_major.dimension(5), 4);
-
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  for (IndexType i = 0; i < tensor_col_major.size(); ++i) {
-    VERIFY_IS_EQUAL(tensor_col_major.data()[i], single_voxel_patch_col_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor_row_major.data()[i], single_voxel_patch_row_major.data()[i]);
-    VERIFY_IS_EQUAL(tensor_col_major.data()[i], tensor_row_major.data()[i]);
-  }
-
-  sycl_device.deallocate(gpu_data_col_major);
-  sycl_device.deallocate(gpu_data_row_major);
-  sycl_device.deallocate(gpu_data_single_voxel_patch_col_major);
-  sycl_device.deallocate(gpu_data_single_voxel_patch_row_major);
-}
-
-template <typename DataType, typename IndexType>
-static void test_entire_volume_patch_sycl(const Eigen::SyclDevice& sycl_device) {
-  const int depth = 4;
-  const int patch_z = 2;
-  const int patch_y = 3;
-  const int patch_x = 5;
-  const int batch = 7;
-
-  array<IndexType, 5> tensorColMajorRange = {{depth, patch_z, patch_y, patch_x, batch}};
-  array<IndexType, 5> tensorRowMajorRange = {{batch, patch_x, patch_y, patch_z, depth}};
-  Tensor<DataType, 5, DataLayout, IndexType> tensor_col_major(tensorColMajorRange);
-  Tensor<DataType, 5, RowMajor, IndexType> tensor_row_major(tensorRowMajorRange);
-  tensor_col_major.setRandom();
-
-  DataType* gpu_data_col_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_col_major.size() * sizeof(DataType)));
-  DataType* gpu_data_row_major =
-      static_cast<DataType*>(sycl_device.allocate(tensor_row_major.size() * sizeof(DataType)));
-  TensorMap<Tensor<DataType, 5, ColMajor, IndexType>> gpu_col_major(gpu_data_col_major, tensorColMajorRange);
-  TensorMap<Tensor<DataType, 5, RowMajor, IndexType>> gpu_row_major(gpu_data_row_major, tensorRowMajorRange);
-
-  sycl_device.memcpyHostToDevice(gpu_data_col_major, tensor_col_major.data(),
-                                 (tensor_col_major.size()) * sizeof(DataType));
-  gpu_row_major.device(sycl_device) = gpu_col_major.swap_layout();
-  sycl_device.memcpyDeviceToHost(tensor_row_major.data(), gpu_data_row_major,
-                                 (tensor_col_major.size()) * sizeof(DataType));
-
-  // single volume patch: ColMajor
-  array<IndexType, 6> patchColMajorTensorRange = {
-      {depth, patch_z, patch_y, patch_x, patch_z * patch_y * patch_x, batch}};
-  Tensor<DataType, 6, DataLayout, IndexType> entire_volume_patch_col_major(patchColMajorTensorRange);
-  size_t patchTensorBuffSize = entire_volume_patch_col_major.size() * sizeof(DataType);
-  DataType* gpu_data_entire_volume_patch_col_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 6, DataLayout, IndexType>> gpu_entire_volume_patch_col_major(
-      gpu_data_entire_volume_patch_col_major, patchColMajorTensorRange);
-  gpu_entire_volume_patch_col_major.device(sycl_device) =
-      gpu_col_major.extract_volume_patches(patch_z, patch_y, patch_x);
-  sycl_device.memcpyDeviceToHost(entire_volume_patch_col_major.data(), gpu_data_entire_volume_patch_col_major,
-                                 patchTensorBuffSize);
-
-  //  Tensor<float, 5> tensor(depth, patch_z, patch_y, patch_x, batch);
-  //  tensor.setRandom();
-  //  Tensor<float, 5, RowMajor> tensor_row_major = tensor.swap_layout();
-
-  // Tensor<float, 6> entire_volume_patch;
-  // entire_volume_patch = tensor.extract_volume_patches(patch_z, patch_y, patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(0), depth);
-  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(1), patch_z);
-  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(2), patch_y);
-  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(3), patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(4), patch_z * patch_y * patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_col_major.dimension(5), batch);
-
-  //  Tensor<float, 6, RowMajor> entire_volume_patch_row_major;
-  // entire_volume_patch_row_major = tensor_row_major.extract_volume_patches(patch_z, patch_y, patch_x);
-
-  array<IndexType, 6> patchRowMajorTensorRange = {
-      {batch, patch_z * patch_y * patch_x, patch_x, patch_y, patch_z, depth}};
-  Tensor<DataType, 6, RowMajor, IndexType> entire_volume_patch_row_major(patchRowMajorTensorRange);
-  patchTensorBuffSize = entire_volume_patch_row_major.size() * sizeof(DataType);
-  DataType* gpu_data_entire_volume_patch_row_major = static_cast<DataType*>(sycl_device.allocate(patchTensorBuffSize));
-  TensorMap<Tensor<DataType, 6, RowMajor, IndexType>> gpu_entire_volume_patch_row_major(
-      gpu_data_entire_volume_patch_row_major, patchRowMajorTensorRange);
-  gpu_entire_volume_patch_row_major.device(sycl_device) =
-      gpu_row_major.extract_volume_patches(patch_z, patch_y, patch_x);
-  sycl_device.memcpyDeviceToHost(entire_volume_patch_row_major.data(), gpu_data_entire_volume_patch_row_major,
-                                 patchTensorBuffSize);
-
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(0), batch);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(1), patch_z * patch_y * patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(2), patch_x);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(3), patch_y);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(4), patch_z);
-  VERIFY_IS_EQUAL(entire_volume_patch_row_major.dimension(5), depth);
-
-  const int dz = patch_z - 1;
-  const int dy = patch_y - 1;
-  const int dx = patch_x - 1;
-
-  const int forward_pad_z = dz / 2;
-  const int forward_pad_y = dy / 2;
-  const int forward_pad_x = dx / 2;
-
-  for (int pz = 0; pz < patch_z; pz++) {
-    for (int py = 0; py < patch_y; py++) {
-      for (int px = 0; px < patch_x; px++) {
-        const int patchId = pz + patch_z * (py + px * patch_y);
-        for (int z = 0; z < patch_z; z++) {
-          for (int y = 0; y < patch_y; y++) {
-            for (int x = 0; x < patch_x; x++) {
-              for (int b = 0; b < batch; b++) {
-                for (int d = 0; d < depth; d++) {
-                  float expected = 0.0f;
-                  float expected_row_major = 0.0f;
-                  const int eff_z = z - forward_pad_z + pz;
-                  const int eff_y = y - forward_pad_y + py;
-                  const int eff_x = x - forward_pad_x + px;
-                  if (eff_z >= 0 && eff_y >= 0 && eff_x >= 0 && eff_z < patch_z && eff_y < patch_y && eff_x < patch_x) {
-                    expected = tensor_col_major(d, eff_z, eff_y, eff_x, b);
-                    expected_row_major = tensor_row_major(b, eff_x, eff_y, eff_z, d);
-                  }
-                  VERIFY_IS_EQUAL(entire_volume_patch_col_major(d, z, y, x, patchId, b), expected);
-                  VERIFY_IS_EQUAL(entire_volume_patch_row_major(b, patchId, x, y, z, d), expected_row_major);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  sycl_device.deallocate(gpu_data_col_major);
-  sycl_device.deallocate(gpu_data_row_major);
-  sycl_device.deallocate(gpu_data_entire_volume_patch_col_major);
-  sycl_device.deallocate(gpu_data_entire_volume_patch_row_major);
-}
-
-template <typename DataType, typename dev_Selector>
-void sycl_tensor_volume_patch_test_per_device(dev_Selector s) {
-  QueueInterface queueInterface(s);
-  auto sycl_device = Eigen::SyclDevice(&queueInterface);
-  std::cout << "Running on " << s.template get_info<cl::sycl::info::device::name>() << std::endl;
-  test_single_voxel_patch_sycl<DataType, int64_t>(sycl_device);
-  test_entire_volume_patch_sycl<DataType, int64_t>(sycl_device);
-}
-EIGEN_DECLARE_TEST(cxx11_tensor_volume_patch_sycl) {
-  for (const auto& device : Eigen::get_sycl_supported_devices()) {
-    CALL_SUBTEST(sycl_tensor_volume_patch_test_per_device<half>(device));
-    CALL_SUBTEST(sycl_tensor_volume_patch_test_per_device<float>(device));
-  }
-}
diff --git a/unsupported/test/dgmres.cpp b/unsupported/test/dgmres.cpp
deleted file mode 100644
index 940800c..0000000
--- a/unsupported/test/dgmres.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
-// Copyright (C) 2012 desire Nuentsa <desire.nuentsa_wakam@inria.fr
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "../../test/sparse_solver.h"
-#include <unsupported/Eigen/IterativeSolvers>
-
-template <typename T>
-void test_dgmres_T() {
-  DGMRES<SparseMatrix<T>, DiagonalPreconditioner<T> > dgmres_colmajor_diag;
-  DGMRES<SparseMatrix<T>, IdentityPreconditioner> dgmres_colmajor_I;
-  DGMRES<SparseMatrix<T>, IncompleteLUT<T> > dgmres_colmajor_ilut;
-  // GMRES<SparseMatrix<T>, SSORPreconditioner<T> >     dgmres_colmajor_ssor;
-
-  CALL_SUBTEST(check_sparse_square_solving(dgmres_colmajor_diag));
-  //   CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_I)     );
-  CALL_SUBTEST(check_sparse_square_solving(dgmres_colmajor_ilut));
-  // CALL_SUBTEST( check_sparse_square_solving(dgmres_colmajor_ssor)     );
-}
-
-EIGEN_DECLARE_TEST(dgmres) {
-  CALL_SUBTEST_1(test_dgmres_T<double>());
-  CALL_SUBTEST_2(test_dgmres_T<std::complex<double> >());
-}
diff --git a/unsupported/test/duccfft.cpp b/unsupported/test/duccfft.cpp
deleted file mode 100644
index 4247663..0000000
--- a/unsupported/test/duccfft.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#define EIGEN_DUCCFFT_DEFAULT 1
-#include <ducc0/fft/fft.h>         // Needs to be included before main.h
-#include <ducc0/fft/fftnd_impl.h>  // Same requirement
-#include "fft_test_shared.h"
diff --git a/unsupported/test/fft_test_shared.h b/unsupported/test/fft_test_shared.h
deleted file mode 100644
index d7380be..0000000
--- a/unsupported/test/fft_test_shared.h
+++ /dev/null
@@ -1,311 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Mark Borgerding mark a borgerding net
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/FFT>
-
-template <typename T>
-inline std::complex<T> RandomCpx() {
-  return std::complex<T>((T)(rand() / (T)RAND_MAX - .5), (T)(rand() / (T)RAND_MAX - .5));
-}
-
-using namespace std;
-using namespace Eigen;
-
-template <typename T>
-inline complex<long double> promote(complex<T> x) {
-  return complex<long double>((long double)x.real(), (long double)x.imag());
-}
-
-inline complex<long double> promote(float x) { return complex<long double>((long double)x); }
-inline complex<long double> promote(double x) { return complex<long double>((long double)x); }
-inline complex<long double> promote(long double x) { return complex<long double>((long double)x); }
-
-template <typename VT1, typename VT2>
-long double fft_rmse(const VT1& fftbuf, const VT2& timebuf) {
-  long double totalpower = 0;
-  long double difpower = 0;
-  long double pi = acos((long double)-1);
-  for (size_t k0 = 0; k0 < (size_t)fftbuf.size(); ++k0) {
-    complex<long double> acc = 0;
-    long double phinc = (long double)(-2.) * k0 * pi / timebuf.size();
-    for (size_t k1 = 0; k1 < (size_t)timebuf.size(); ++k1) {
-      acc += promote(timebuf[k1]) * exp(complex<long double>(0, k1 * phinc));
-    }
-    totalpower += numext::abs2(acc);
-    complex<long double> x = promote(fftbuf[k0]);
-    complex<long double> dif = acc - x;
-    difpower += numext::abs2(dif);
-    // cerr << k0 << "\t" << acc << "\t" <<  x << "\t" << sqrt(numext::abs2(dif)) << endl;
-  }
-  // cerr << "rmse:" << sqrt(difpower/totalpower) << endl;
-  return sqrt(difpower / totalpower);
-}
-
-template <typename VT1, typename VT2>
-long double dif_rmse(const VT1 buf1, const VT2 buf2) {
-  long double totalpower = 0;
-  long double difpower = 0;
-  size_t n = (min)(buf1.size(), buf2.size());
-  for (size_t k = 0; k < n; ++k) {
-    totalpower += (long double)((numext::abs2(buf1[k]) + numext::abs2(buf2[k])) / 2);
-    difpower += (long double)(numext::abs2(buf1[k] - buf2[k]));
-  }
-  return sqrt(difpower / totalpower);
-}
-
-enum { StdVectorContainer, EigenVectorContainer };
-
-template <int Container, typename Scalar>
-struct VectorType;
-
-template <typename Scalar>
-struct VectorType<StdVectorContainer, Scalar> {
-  typedef vector<Scalar> type;
-};
-
-template <typename Scalar>
-struct VectorType<EigenVectorContainer, Scalar> {
-  typedef Matrix<Scalar, Dynamic, 1> type;
-};
-
-template <int Container, typename T>
-void test_scalar_generic(int nfft) {
-  typedef typename FFT<T>::Complex Complex;
-  typedef typename FFT<T>::Scalar Scalar;
-  typedef typename VectorType<Container, Scalar>::type ScalarVector;
-  typedef typename VectorType<Container, Complex>::type ComplexVector;
-
-  FFT<T> fft;
-  ScalarVector tbuf(nfft);
-  ComplexVector freqBuf;
-  for (int k = 0; k < nfft; ++k) tbuf[k] = (T)(rand() / (double)RAND_MAX - .5);
-
-  // make sure it DOESN'T give the right full spectrum answer
-  // if we've asked for half-spectrum
-  fft.SetFlag(fft.HalfSpectrum);
-  fft.fwd(freqBuf, tbuf);
-  VERIFY((size_t)freqBuf.size() == (size_t)((nfft >> 1) + 1));
-  VERIFY(T(fft_rmse(freqBuf, tbuf)) < test_precision<T>());  // gross check
-
-  fft.ClearFlag(fft.HalfSpectrum);
-  fft.fwd(freqBuf, tbuf);
-  VERIFY((size_t)freqBuf.size() == (size_t)nfft);
-  VERIFY(T(fft_rmse(freqBuf, tbuf)) < test_precision<T>());  // gross check
-
-  if (nfft & 1) return;  // odd FFTs get the wrong size inverse FFT
-
-  ScalarVector tbuf2;
-  fft.inv(tbuf2, freqBuf);
-  VERIFY(T(dif_rmse(tbuf, tbuf2)) < test_precision<T>());  // gross check
-
-  // verify that the Unscaled flag takes effect
-  ScalarVector tbuf3;
-  fft.SetFlag(fft.Unscaled);
-
-  fft.inv(tbuf3, freqBuf);
-
-  for (int k = 0; k < nfft; ++k) tbuf3[k] *= T(1. / nfft);
-
-  // for (size_t i=0;i<(size_t) tbuf.size();++i)
-  //     cout << "freqBuf=" << freqBuf[i] << " in2=" << tbuf3[i] << " -  in=" << tbuf[i] << " => " << (tbuf3[i] -
-  //     tbuf[i] ) <<  endl;
-
-  VERIFY(T(dif_rmse(tbuf, tbuf3)) < test_precision<T>());  // gross check
-
-  // verify that ClearFlag works
-  fft.ClearFlag(fft.Unscaled);
-  fft.inv(tbuf2, freqBuf);
-  VERIFY(T(dif_rmse(tbuf, tbuf2)) < test_precision<T>());  // gross check
-}
-
-template <typename T>
-void test_scalar(int nfft) {
-  test_scalar_generic<StdVectorContainer, T>(nfft);
-  // test_scalar_generic<EigenVectorContainer,T>(nfft);
-}
-
-template <int Container, typename T>
-void test_complex_generic(int nfft) {
-  typedef typename FFT<T>::Complex Complex;
-  typedef typename VectorType<Container, Complex>::type ComplexVector;
-
-  FFT<T> fft;
-
-  ComplexVector inbuf(nfft);
-  ComplexVector outbuf;
-  ComplexVector buf3;
-  for (int k = 0; k < nfft; ++k)
-    inbuf[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
-  fft.fwd(outbuf, inbuf);
-
-  VERIFY(T(fft_rmse(outbuf, inbuf)) < test_precision<T>());  // gross check
-  fft.inv(buf3, outbuf);
-
-  VERIFY(T(dif_rmse(inbuf, buf3)) < test_precision<T>());  // gross check
-
-  // verify that the Unscaled flag takes effect
-  ComplexVector buf4;
-  fft.SetFlag(fft.Unscaled);
-  fft.inv(buf4, outbuf);
-  for (int k = 0; k < nfft; ++k) buf4[k] *= T(1. / nfft);
-  VERIFY(T(dif_rmse(inbuf, buf4)) < test_precision<T>());  // gross check
-
-  // verify that ClearFlag works
-  fft.ClearFlag(fft.Unscaled);
-  fft.inv(buf3, outbuf);
-  VERIFY(T(dif_rmse(inbuf, buf3)) < test_precision<T>());  // gross check
-}
-
-template <typename T>
-void test_complex_strided(int nfft) {
-  typedef typename FFT<T>::Complex Complex;
-  typedef typename Eigen::Vector<Complex, Dynamic> ComplexVector;
-  constexpr int kInputStride = 3;
-  constexpr int kOutputStride = 7;
-  constexpr int kInvOutputStride = 13;
-
-  FFT<T> fft;
-
-  ComplexVector inbuf(nfft * kInputStride);
-  inbuf.setRandom();
-  ComplexVector outbuf(nfft * kOutputStride);
-  outbuf.setRandom();
-  ComplexVector invoutbuf(nfft * kInvOutputStride);
-  invoutbuf.setRandom();
-
-  using StridedComplexVector = Map<ComplexVector, /*MapOptions=*/0, InnerStride<Dynamic>>;
-  StridedComplexVector input(inbuf.data(), nfft, InnerStride<Dynamic>(kInputStride));
-  StridedComplexVector output(outbuf.data(), nfft, InnerStride<Dynamic>(kOutputStride));
-  StridedComplexVector inv_output(invoutbuf.data(), nfft, InnerStride<Dynamic>(kInvOutputStride));
-
-  for (int k = 0; k < nfft; ++k)
-    input[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
-  fft.fwd(output, input);
-
-  VERIFY(T(fft_rmse(output, input)) < test_precision<T>());  // gross check
-  fft.inv(inv_output, output);
-  VERIFY(T(dif_rmse(inv_output, input)) < test_precision<T>());  // gross check
-}
-
-template <typename T>
-void test_complex(int nfft) {
-  test_complex_generic<StdVectorContainer, T>(nfft);
-  test_complex_generic<EigenVectorContainer, T>(nfft);
-  test_complex_strided<T>(nfft);
-}
-
-template <typename T, int nrows, int ncols>
-void test_complex2d() {
-  typedef typename Eigen::FFT<T>::Complex Complex;
-  FFT<T> fft;
-  Eigen::Matrix<Complex, nrows, ncols> src, src2, dst, dst2;
-
-  src = Eigen::Matrix<Complex, nrows, ncols>::Random();
-  // src =  Eigen::Matrix<Complex,nrows,ncols>::Identity();
-
-  for (int k = 0; k < ncols; k++) {
-    Eigen::Matrix<Complex, nrows, 1> tmpOut;
-    fft.fwd(tmpOut, src.col(k));
-    dst2.col(k) = tmpOut;
-  }
-
-  for (int k = 0; k < nrows; k++) {
-    Eigen::Matrix<Complex, 1, ncols> tmpOut;
-    fft.fwd(tmpOut, dst2.row(k));
-    dst2.row(k) = tmpOut;
-  }
-
-  fft.fwd2(dst.data(), src.data(), ncols, nrows);
-  fft.inv2(src2.data(), dst.data(), ncols, nrows);
-  VERIFY((src - src2).norm() < test_precision<T>());
-  VERIFY((dst - dst2).norm() < test_precision<T>());
-}
-
-inline void test_return_by_value(int len) {
-  VectorXf in;
-  VectorXf in1;
-  in.setRandom(len);
-  VectorXcf out1, out2;
-  FFT<float> fft;
-
-  fft.SetFlag(fft.HalfSpectrum);
-
-  fft.fwd(out1, in);
-  out2 = fft.fwd(in);
-  VERIFY((out1 - out2).norm() < test_precision<float>());
-  in1 = fft.inv(out1);
-  VERIFY((in1 - in).norm() < test_precision<float>());
-}
-
-EIGEN_DECLARE_TEST(FFTW) {
-  CALL_SUBTEST(test_return_by_value(32));
-  CALL_SUBTEST(test_complex<float>(32));
-  CALL_SUBTEST(test_complex<double>(32));
-  CALL_SUBTEST(test_complex<float>(256));
-  CALL_SUBTEST(test_complex<double>(256));
-  CALL_SUBTEST(test_complex<float>(3 * 8));
-  CALL_SUBTEST(test_complex<double>(3 * 8));
-  CALL_SUBTEST(test_complex<float>(5 * 32));
-  CALL_SUBTEST(test_complex<double>(5 * 32));
-  CALL_SUBTEST(test_complex<float>(2 * 3 * 4));
-  CALL_SUBTEST(test_complex<double>(2 * 3 * 4));
-  CALL_SUBTEST(test_complex<float>(2 * 3 * 4 * 5));
-  CALL_SUBTEST(test_complex<double>(2 * 3 * 4 * 5));
-  CALL_SUBTEST(test_complex<float>(2 * 3 * 4 * 5 * 7));
-  CALL_SUBTEST(test_complex<double>(2 * 3 * 4 * 5 * 7));
-
-  CALL_SUBTEST(test_scalar<float>(32));
-  CALL_SUBTEST(test_scalar<double>(32));
-  CALL_SUBTEST(test_scalar<float>(45));
-  CALL_SUBTEST(test_scalar<double>(45));
-  CALL_SUBTEST(test_scalar<float>(50));
-  CALL_SUBTEST(test_scalar<double>(50));
-  CALL_SUBTEST(test_scalar<float>(256));
-  CALL_SUBTEST(test_scalar<double>(256));
-  CALL_SUBTEST(test_scalar<float>(2 * 3 * 4 * 5 * 7));
-  CALL_SUBTEST(test_scalar<double>(2 * 3 * 4 * 5 * 7));
-
-#if defined EIGEN_HAS_FFTWL || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT
-  CALL_SUBTEST(test_complex<long double>(32));
-  CALL_SUBTEST(test_complex<long double>(256));
-  CALL_SUBTEST(test_complex<long double>(3 * 8));
-  CALL_SUBTEST(test_complex<long double>(5 * 32));
-  CALL_SUBTEST(test_complex<long double>(2 * 3 * 4));
-  CALL_SUBTEST(test_complex<long double>(2 * 3 * 4 * 5));
-  CALL_SUBTEST(test_complex<long double>(2 * 3 * 4 * 5 * 7));
-
-  CALL_SUBTEST(test_scalar<long double>(32));
-  CALL_SUBTEST(test_scalar<long double>(45));
-  CALL_SUBTEST(test_scalar<long double>(50));
-  CALL_SUBTEST(test_scalar<long double>(256));
-  CALL_SUBTEST(test_scalar<long double>(2 * 3 * 4 * 5 * 7));
-
-  CALL_SUBTEST((test_complex2d<long double, 2 * 3 * 4, 2 * 3 * 4>()));
-  CALL_SUBTEST((test_complex2d<long double, 3 * 4 * 5, 3 * 4 * 5>()));
-  CALL_SUBTEST((test_complex2d<long double, 24, 60>()));
-  CALL_SUBTEST((test_complex2d<long double, 60, 24>()));
-// fail to build since Eigen limit the stack allocation size,too big here.
-// CALL_SUBTEST( ( test_complex2d<long double, 256, 256> () ) );
-#endif
-#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
-    defined EIGEN_MKL_DEFAULT
-  CALL_SUBTEST((test_complex2d<float, 24, 24>()));
-  CALL_SUBTEST((test_complex2d<float, 60, 60>()));
-  CALL_SUBTEST((test_complex2d<float, 24, 60>()));
-  CALL_SUBTEST((test_complex2d<float, 60, 24>()));
-#endif
-#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_DUCCFFT_DEFAULT || \
-    defined EIGEN_MKL_DEFAULT
-  CALL_SUBTEST((test_complex2d<double, 24, 24>()));
-  CALL_SUBTEST((test_complex2d<double, 60, 60>()));
-  CALL_SUBTEST((test_complex2d<double, 24, 60>()));
-  CALL_SUBTEST((test_complex2d<double, 60, 24>()));
-#endif
-}
diff --git a/unsupported/test/forward_adolc.cpp b/unsupported/test/forward_adolc.cpp
deleted file mode 100644
index 5d129a0..0000000
--- a/unsupported/test/forward_adolc.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <Eigen/Dense>
-
-#define NUMBER_DIRECTIONS 16
-#include <unsupported/Eigen/AdolcForward>
-
-template <typename Vector>
-EIGEN_DONT_INLINE typename Vector::Scalar foo(const Vector& p) {
-  typedef typename Vector::Scalar Scalar;
-  return (p - Vector(Scalar(-1), Scalar(1.))).norm() + (p.array().sqrt().abs() * p.array().sin()).sum() + p.dot(p);
-}
-
-template <typename Scalar_, int NX = Dynamic, int NY = Dynamic>
-struct TestFunc1 {
-  typedef Scalar_ Scalar;
-  enum { InputsAtCompileTime = NX, ValuesAtCompileTime = NY };
-  typedef Matrix<Scalar, InputsAtCompileTime, 1> InputType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, 1> ValueType;
-  typedef Matrix<Scalar, ValuesAtCompileTime, InputsAtCompileTime> JacobianType;
-
-  int m_inputs, m_values;
-
-  TestFunc1() : m_inputs(InputsAtCompileTime), m_values(ValuesAtCompileTime) {}
-  TestFunc1(int inputs_, int values_) : m_inputs(inputs_), m_values(values_) {}
-
-  int inputs() const { return m_inputs; }
-  int values() const { return m_values; }
-
-  template <typename T>
-  void operator()(const Matrix<T, InputsAtCompileTime, 1>& x, Matrix<T, ValuesAtCompileTime, 1>* _v) const {
-    Matrix<T, ValuesAtCompileTime, 1>& v = *_v;
-
-    v[0] = 2 * x[0] * x[0] + x[0] * x[1];
-    v[1] = 3 * x[1] * x[0] + 0.5 * x[1] * x[1];
-    if (inputs() > 2) {
-      v[0] += 0.5 * x[2];
-      v[1] += x[2];
-    }
-    if (values() > 2) {
-      v[2] = 3 * x[1] * x[0] * x[0];
-    }
-    if (inputs() > 2 && values() > 2) v[2] *= x[2];
-  }
-
-  void operator()(const InputType& x, ValueType* v, JacobianType* _j) const {
-    (*this)(x, v);
-
-    if (_j) {
-      JacobianType& j = *_j;
-
-      j(0, 0) = 4 * x[0] + x[1];
-      j(1, 0) = 3 * x[1];
-
-      j(0, 1) = x[0];
-      j(1, 1) = 3 * x[0] + 2 * 0.5 * x[1];
-
-      if (inputs() > 2) {
-        j(0, 2) = 0.5;
-        j(1, 2) = 1;
-      }
-      if (values() > 2) {
-        j(2, 0) = 3 * x[1] * 2 * x[0];
-        j(2, 1) = 3 * x[0] * x[0];
-      }
-      if (inputs() > 2 && values() > 2) {
-        j(2, 0) *= x[2];
-        j(2, 1) *= x[2];
-
-        j(2, 2) = 3 * x[1] * x[0] * x[0];
-        j(2, 2) = 3 * x[1] * x[0] * x[0];
-      }
-    }
-  }
-};
-
-template <typename Func>
-void adolc_forward_jacobian(const Func& f) {
-  typename Func::InputType x = Func::InputType::Random(f.inputs());
-  typename Func::ValueType y(f.values()), yref(f.values());
-  typename Func::JacobianType j(f.values(), f.inputs()), jref(f.values(), f.inputs());
-
-  jref.setZero();
-  yref.setZero();
-  f(x, &yref, &jref);
-  //     std::cerr << y.transpose() << "\n\n";;
-  //     std::cerr << j << "\n\n";;
-
-  j.setZero();
-  y.setZero();
-  AdolcForwardJacobian<Func> autoj(f);
-  autoj(x, &y, &j);
-  //     std::cerr << y.transpose() << "\n\n";;
-  //     std::cerr << j << "\n\n";;
-
-  VERIFY_IS_APPROX(y, yref);
-  VERIFY_IS_APPROX(j, jref);
-}
-
-EIGEN_DECLARE_TEST(forward_adolc) {
-  adtl::setNumDir(NUMBER_DIRECTIONS);
-
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 2, 2>())));
-    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 2, 3>())));
-    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 3, 2>())));
-    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double, 3, 3>())));
-    CALL_SUBTEST((adolc_forward_jacobian(TestFunc1<double>(3, 3))));
-  }
-
-  {
-    // simple instantiation tests
-    Matrix<adtl::adouble, 2, 1> x;
-    foo(x);
-    Matrix<adtl::adouble, Dynamic, Dynamic> A(4, 4);
-    ;
-    A.selfadjointView<Lower>().eigenvalues();
-  }
-}
diff --git a/unsupported/test/gmres.cpp b/unsupported/test/gmres.cpp
deleted file mode 100644
index 225bb96..0000000
--- a/unsupported/test/gmres.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
-// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "../../test/sparse_solver.h"
-#include <Eigen/IterativeSolvers>
-
-template <typename T>
-void test_gmres_T() {
-  GMRES<SparseMatrix<T>, DiagonalPreconditioner<T> > gmres_colmajor_diag;
-  GMRES<SparseMatrix<T>, IdentityPreconditioner> gmres_colmajor_I;
-  GMRES<SparseMatrix<T>, IncompleteLUT<T> > gmres_colmajor_ilut;
-  // GMRES<SparseMatrix<T>, SSORPreconditioner<T> >     gmres_colmajor_ssor;
-
-  CALL_SUBTEST(check_sparse_square_solving(gmres_colmajor_diag));
-  //   CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_I)     );
-  CALL_SUBTEST(check_sparse_square_solving(gmres_colmajor_ilut));
-  // CALL_SUBTEST( check_sparse_square_solving(gmres_colmajor_ssor)     );
-}
-
-EIGEN_DECLARE_TEST(gmres) {
-  CALL_SUBTEST_1(test_gmres_T<double>());
-  CALL_SUBTEST_2(test_gmres_T<std::complex<double> >());
-}
diff --git a/unsupported/test/idrs.cpp b/unsupported/test/idrs.cpp
deleted file mode 100644
index 9a2e4a5..0000000
--- a/unsupported/test/idrs.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
-// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "../../test/sparse_solver.h"
-#include <Eigen/IterativeSolvers>
-
-template <typename T>
-void test_idrs_T() {
-  IDRS<SparseMatrix<T>, DiagonalPreconditioner<T> > idrs_colmajor_diag;
-  IDRS<SparseMatrix<T>, IncompleteLUT<T> > idrs_colmajor_ilut;
-
-  CALL_SUBTEST(check_sparse_square_solving(idrs_colmajor_diag));
-  CALL_SUBTEST(check_sparse_square_solving(idrs_colmajor_ilut));
-}
-
-EIGEN_DECLARE_TEST(idrs) {
-  CALL_SUBTEST_1(test_idrs_T<double>());
-  CALL_SUBTEST_2(test_idrs_T<std::complex<double> >());
-}
diff --git a/unsupported/test/idrstabl.cpp b/unsupported/test/idrstabl.cpp
deleted file mode 100644
index 7e40dd6..0000000
--- a/unsupported/test/idrstabl.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "../../test/sparse_solver.h"
-#include <unsupported/Eigen/IterativeSolvers>
-
-template <typename T>
-void test_idrstabl_T() {
-  IDRSTABL<SparseMatrix<T>, DiagonalPreconditioner<T> > idrstabl_colmajor_diag;
-  IDRSTABL<SparseMatrix<T>, IncompleteLUT<T> > idrstabl_colmajor_ilut;
-
-  idrstabl_colmajor_diag.setTolerance(NumTraits<T>::epsilon() * 4);
-  idrstabl_colmajor_ilut.setTolerance(NumTraits<T>::epsilon() * 4);
-
-  CALL_SUBTEST(check_sparse_square_solving(idrstabl_colmajor_diag));
-  CALL_SUBTEST(check_sparse_square_solving(idrstabl_colmajor_ilut));
-}
-
-EIGEN_DECLARE_TEST(idrstabl) {
-  CALL_SUBTEST_1((test_idrstabl_T<double>()));
-  CALL_SUBTEST_2((test_idrstabl_T<std::complex<double> >()));
-}
diff --git a/unsupported/test/kronecker_product.cpp b/unsupported/test/kronecker_product.cpp
deleted file mode 100644
index d7396e0..0000000
--- a/unsupported/test/kronecker_product.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Kolja Brix <brix@igpm.rwth-aachen.de>
-// Copyright (C) 2011 Andreas Platen <andiplaten@gmx.de>
-// Copyright (C) 2012 Chen-Pang He <jdh8@ms63.hinet.net>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifdef EIGEN_TEST_PART_1
-
-#include "sparse.h"
-#include <Eigen/SparseExtra>
-#include <Eigen/KroneckerProduct>
-
-template <typename MatrixType>
-void check_dimension(const MatrixType& ab, const int rows, const int cols) {
-  VERIFY_IS_EQUAL(ab.rows(), rows);
-  VERIFY_IS_EQUAL(ab.cols(), cols);
-}
-
-template <typename MatrixType>
-void check_kronecker_product(const MatrixType& ab) {
-  VERIFY_IS_EQUAL(ab.rows(), 6);
-  VERIFY_IS_EQUAL(ab.cols(), 6);
-  VERIFY_IS_EQUAL(ab.size(), 36);
-  VERIFY_IS_APPROX(ab.coeff(0, 0), -0.4017367630386106);
-  VERIFY_IS_APPROX(ab.coeff(0, 1), 0.1056863433932735);
-  VERIFY_IS_APPROX(ab.coeff(0, 2), -0.7255206194554212);
-  VERIFY_IS_APPROX(ab.coeff(0, 3), 0.1908653336744706);
-  VERIFY_IS_APPROX(ab.coeff(0, 4), 0.350864567234111);
-  VERIFY_IS_APPROX(ab.coeff(0, 5), -0.0923032108308013);
-  VERIFY_IS_APPROX(ab.coeff(1, 0), 0.415417514804677);
-  VERIFY_IS_APPROX(ab.coeff(1, 1), -0.2369227701722048);
-  VERIFY_IS_APPROX(ab.coeff(1, 2), 0.7502275131458511);
-  VERIFY_IS_APPROX(ab.coeff(1, 3), -0.4278731019742696);
-  VERIFY_IS_APPROX(ab.coeff(1, 4), -0.3628129162264507);
-  VERIFY_IS_APPROX(ab.coeff(1, 5), 0.2069210808481275);
-  VERIFY_IS_APPROX(ab.coeff(2, 0), 0.05465890160863986);
-  VERIFY_IS_APPROX(ab.coeff(2, 1), -0.2634092511419858);
-  VERIFY_IS_APPROX(ab.coeff(2, 2), 0.09871180285793758);
-  VERIFY_IS_APPROX(ab.coeff(2, 3), -0.4757066334017702);
-  VERIFY_IS_APPROX(ab.coeff(2, 4), -0.04773740823058334);
-  VERIFY_IS_APPROX(ab.coeff(2, 5), 0.2300535609645254);
-  VERIFY_IS_APPROX(ab.coeff(3, 0), -0.8172945853260133);
-  VERIFY_IS_APPROX(ab.coeff(3, 1), 0.2150086428359221);
-  VERIFY_IS_APPROX(ab.coeff(3, 2), 0.5825113847292743);
-  VERIFY_IS_APPROX(ab.coeff(3, 3), -0.1532433770097174);
-  VERIFY_IS_APPROX(ab.coeff(3, 4), -0.329383387282399);
-  VERIFY_IS_APPROX(ab.coeff(3, 5), 0.08665207912033064);
-  VERIFY_IS_APPROX(ab.coeff(4, 0), 0.8451267514863225);
-  VERIFY_IS_APPROX(ab.coeff(4, 1), -0.481996458918977);
-  VERIFY_IS_APPROX(ab.coeff(4, 2), -0.6023482390791535);
-  VERIFY_IS_APPROX(ab.coeff(4, 3), 0.3435339347164565);
-  VERIFY_IS_APPROX(ab.coeff(4, 4), 0.3406002157428891);
-  VERIFY_IS_APPROX(ab.coeff(4, 5), -0.1942526344200915);
-  VERIFY_IS_APPROX(ab.coeff(5, 0), 0.1111982482925399);
-  VERIFY_IS_APPROX(ab.coeff(5, 1), -0.5358806424754169);
-  VERIFY_IS_APPROX(ab.coeff(5, 2), -0.07925446559335647);
-  VERIFY_IS_APPROX(ab.coeff(5, 3), 0.3819388757769038);
-  VERIFY_IS_APPROX(ab.coeff(5, 4), 0.04481475387219876);
-  VERIFY_IS_APPROX(ab.coeff(5, 5), -0.2159688616158057);
-}
-
-template <typename MatrixType>
-void check_sparse_kronecker_product(const MatrixType& ab) {
-  VERIFY_IS_EQUAL(ab.rows(), 12);
-  VERIFY_IS_EQUAL(ab.cols(), 10);
-  VERIFY_IS_EQUAL(ab.nonZeros(), 3 * 2);
-  VERIFY_IS_APPROX(ab.coeff(3, 0), -0.04);
-  VERIFY_IS_APPROX(ab.coeff(5, 1), 0.05);
-  VERIFY_IS_APPROX(ab.coeff(0, 6), -0.08);
-  VERIFY_IS_APPROX(ab.coeff(2, 7), 0.10);
-  VERIFY_IS_APPROX(ab.coeff(6, 8), 0.12);
-  VERIFY_IS_APPROX(ab.coeff(8, 9), -0.15);
-}
-
-EIGEN_DECLARE_TEST(kronecker_product) {
-  // DM = dense matrix; SM = sparse matrix
-
-  Matrix<double, 2, 3> DM_a;
-  SparseMatrix<double> SM_a(2, 3);
-  SM_a.insert(0, 0) = DM_a.coeffRef(0, 0) = -0.4461540300782201;
-  SM_a.insert(0, 1) = DM_a.coeffRef(0, 1) = -0.8057364375283049;
-  SM_a.insert(0, 2) = DM_a.coeffRef(0, 2) = 0.3896572459516341;
-  SM_a.insert(1, 0) = DM_a.coeffRef(1, 0) = -0.9076572187376921;
-  SM_a.insert(1, 1) = DM_a.coeffRef(1, 1) = 0.6469156566545853;
-  SM_a.insert(1, 2) = DM_a.coeffRef(1, 2) = -0.3658010398782789;
-
-  MatrixXd DM_b(3, 2);
-  SparseMatrix<double> SM_b(3, 2);
-  SM_b.insert(0, 0) = DM_b.coeffRef(0, 0) = 0.9004440976767099;
-  SM_b.insert(0, 1) = DM_b.coeffRef(0, 1) = -0.2368830858139832;
-  SM_b.insert(1, 0) = DM_b.coeffRef(1, 0) = -0.9311078389941825;
-  SM_b.insert(1, 1) = DM_b.coeffRef(1, 1) = 0.5310335762980047;
-  SM_b.insert(2, 0) = DM_b.coeffRef(2, 0) = -0.1225112806872035;
-  SM_b.insert(2, 1) = DM_b.coeffRef(2, 1) = 0.5903998022741264;
-
-  SparseMatrix<double, RowMajor> SM_row_a(SM_a), SM_row_b(SM_b);
-
-  // test DM_fixedSize = kroneckerProduct(DM_block,DM)
-  Matrix<double, 6, 6> DM_fix_ab = kroneckerProduct(DM_a.topLeftCorner<2, 3>(), DM_b);
-
-  CALL_SUBTEST(check_kronecker_product(DM_fix_ab));
-  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a.topLeftCorner<2, 3>(), DM_b)));
-
-  for (int i = 0; i < DM_fix_ab.rows(); ++i)
-    for (int j = 0; j < DM_fix_ab.cols(); ++j)
-      VERIFY_IS_APPROX(kroneckerProduct(DM_a, DM_b).coeff(i, j), DM_fix_ab(i, j));
-
-  // test DM_block = kroneckerProduct(DM,DM)
-  MatrixXd DM_block_ab(10, 15);
-  DM_block_ab.block<6, 6>(2, 5) = kroneckerProduct(DM_a, DM_b);
-  CALL_SUBTEST(check_kronecker_product(DM_block_ab.block<6, 6>(2, 5)));
-
-  // test DM = kroneckerProduct(DM,DM)
-  MatrixXd DM_ab = kroneckerProduct(DM_a, DM_b);
-  CALL_SUBTEST(check_kronecker_product(DM_ab));
-  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a, DM_b)));
-
-  // test SM = kroneckerProduct(SM,DM)
-  SparseMatrix<double> SM_ab = kroneckerProduct(SM_a, DM_b);
-  CALL_SUBTEST(check_kronecker_product(SM_ab));
-  SparseMatrix<double, RowMajor> SM_ab2 = kroneckerProduct(SM_a, DM_b);
-  CALL_SUBTEST(check_kronecker_product(SM_ab2));
-  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(SM_a, DM_b)));
-
-  // test SM = kroneckerProduct(DM,SM)
-  SM_ab.setZero();
-  SM_ab.insert(0, 0) = 37.0;
-  SM_ab = kroneckerProduct(DM_a, SM_b);
-  CALL_SUBTEST(check_kronecker_product(SM_ab));
-  SM_ab2.setZero();
-  SM_ab2.insert(0, 0) = 37.0;
-  SM_ab2 = kroneckerProduct(DM_a, SM_b);
-  CALL_SUBTEST(check_kronecker_product(SM_ab2));
-  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a, SM_b)));
-
-  // test SM = kroneckerProduct(SM,SM)
-  SM_ab.resize(2, 33);
-  SM_ab.insert(0, 0) = 37.0;
-  SM_ab = kroneckerProduct(SM_a, SM_b);
-  CALL_SUBTEST(check_kronecker_product(SM_ab));
-  SM_ab2.resize(5, 11);
-  SM_ab2.insert(0, 0) = 37.0;
-  SM_ab2 = kroneckerProduct(SM_a, SM_b);
-  CALL_SUBTEST(check_kronecker_product(SM_ab2));
-  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(SM_a, SM_b)));
-
-  // test SM = kroneckerProduct(SM,SM) with sparse pattern
-  SM_a.resize(4, 5);
-  SM_b.resize(3, 2);
-  SM_a.resizeNonZeros(0);
-  SM_b.resizeNonZeros(0);
-  SM_a.insert(1, 0) = -0.1;
-  SM_a.insert(0, 3) = -0.2;
-  SM_a.insert(2, 4) = 0.3;
-  SM_a.finalize();
-
-  SM_b.insert(0, 0) = 0.4;
-  SM_b.insert(2, 1) = -0.5;
-  SM_b.finalize();
-  SM_ab.resize(1, 1);
-  SM_ab.insert(0, 0) = 37.0;
-  SM_ab = kroneckerProduct(SM_a, SM_b);
-  CALL_SUBTEST(check_sparse_kronecker_product(SM_ab));
-
-  // test dimension of result of DM = kroneckerProduct(DM,DM)
-  MatrixXd DM_a2 = Eigen::MatrixXd::Random(2, 1);
-  MatrixXd DM_b2 = Eigen::MatrixXd::Random(5, 4);
-  MatrixXd DM_ab2 = kroneckerProduct(DM_a2, DM_b2);
-  CALL_SUBTEST(check_dimension(DM_ab2, 2 * 5, 1 * 4));
-  DM_a2 = Eigen::MatrixXd::Random(10, 9);
-  DM_b2 = Eigen::MatrixXd::Random(4, 8);
-  DM_ab2 = kroneckerProduct(DM_a2, DM_b2);
-  CALL_SUBTEST(check_dimension(DM_ab2, 10 * 4, 9 * 8));
-
-  for (int i = 0; i < g_repeat; i++) {
-    double density = Eigen::internal::random<double>(0.01, 0.5);
-    int ra = Eigen::internal::random<int>(1, 50);
-    int ca = Eigen::internal::random<int>(1, 50);
-    int rb = Eigen::internal::random<int>(1, 50);
-    int cb = Eigen::internal::random<int>(1, 50);
-    SparseMatrix<float, ColMajor> sA(ra, ca), sB(rb, cb), sC;
-    SparseMatrix<float, RowMajor> sC2;
-    MatrixXf dA(ra, ca), dB(rb, cb), dC;
-    initSparse(density, dA, sA);
-    initSparse(density, dB, sB);
-
-    sC = kroneckerProduct(sA, sB);
-    dC = kroneckerProduct(dA, dB);
-    VERIFY_IS_APPROX(MatrixXf(sC), dC);
-
-    sC = kroneckerProduct(sA.transpose(), sB);
-    dC = kroneckerProduct(dA.transpose(), dB);
-    VERIFY_IS_APPROX(MatrixXf(sC), dC);
-
-    sC = kroneckerProduct(sA.transpose(), sB.transpose());
-    dC = kroneckerProduct(dA.transpose(), dB.transpose());
-    VERIFY_IS_APPROX(MatrixXf(sC), dC);
-
-    sC = kroneckerProduct(sA, sB.transpose());
-    dC = kroneckerProduct(dA, dB.transpose());
-    VERIFY_IS_APPROX(MatrixXf(sC), dC);
-
-    sC2 = kroneckerProduct(sA, sB);
-    dC = kroneckerProduct(dA, dB);
-    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
-
-    sC2 = kroneckerProduct(dA, sB);
-    dC = kroneckerProduct(dA, dB);
-    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
-
-    sC2 = kroneckerProduct(sA, dB);
-    dC = kroneckerProduct(dA, dB);
-    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
-
-    sC2 = kroneckerProduct(2 * sA, sB);
-    dC = kroneckerProduct(2 * dA, dB);
-    VERIFY_IS_APPROX(MatrixXf(sC2), dC);
-  }
-}
-
-#endif
-
-#ifdef EIGEN_TEST_PART_2
-
-// simply check that for a dense kronecker product, sparse module is not needed
-#include "main.h"
-#include <Eigen/KroneckerProduct>
-
-EIGEN_DECLARE_TEST(kronecker_product) {
-  MatrixXd a(2, 2), b(3, 3), c;
-  a.setRandom();
-  b.setRandom();
-  c = kroneckerProduct(a, b);
-  VERIFY_IS_APPROX(c.block(3, 3, 3, 3), a(1, 1) * b);
-}
-
-#endif
diff --git a/unsupported/test/levenberg_marquardt.cpp b/unsupported/test/levenberg_marquardt.cpp
deleted file mode 100644
index 45edcc2..0000000
--- a/unsupported/test/levenberg_marquardt.cpp
+++ /dev/null
@@ -1,1555 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-// Copyright (C) 2012 desire Nuentsa <desire.nuentsa_wakam@inria.fr
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-// FIXME: These tests all check for hard-coded values. Ideally, parameters and start estimates should be randomized.
-
-#include <stdio.h>
-
-#include "main.h"
-#include <unsupported/Eigen/LevenbergMarquardt>
-
-// This disables some useless Warnings on MSVC.
-// It is intended to be done for this test only.
-#include <Eigen/src/Core/util/DisableStupidWarnings.h>
-
-using std::sqrt;
-
-// tolerance for checking number of iterations
-#define LM_EVAL_COUNT_TOL 2
-
-struct lmder_functor : DenseFunctor<double> {
-  lmder_functor(void) : DenseFunctor<double>(3, 15) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) const {
-    double tmp1, tmp2, tmp3;
-    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34,   2.1,    4.39};
-
-    for (int i = 0; i < values(); i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-    return 0;
-  }
-
-  int df(const VectorXd &x, MatrixXd &fjac) const {
-    double tmp1, tmp2, tmp3, tmp4;
-    for (int i = 0; i < values(); i++) {
-      tmp1 = i + 1;
-      tmp2 = 16 - i - 1;
-      tmp3 = (i >= 8) ? tmp2 : tmp1;
-      tmp4 = (x[1] * tmp2 + x[2] * tmp3);
-      tmp4 = tmp4 * tmp4;
-      fjac(i, 0) = -1;
-      fjac(i, 1) = tmp1 * tmp2 / tmp4;
-      fjac(i, 2) = tmp1 * tmp3 / tmp4;
-    }
-    return 0;
-  }
-};
-
-void testLmder1() {
-  int n = 3, info;
-
-  VectorXd x;
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmder_functor functor;
-  LevenbergMarquardt<lmder_functor> lm(functor);
-  info = lm.lmder1(x);
-  EIGEN_UNUSED_VARIABLE(info)
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 6);
-  // VERIFY_IS_EQUAL(lm.njev(), 5);
-
-  // check norm
-  VERIFY_IS_APPROX(lm.fvec().blueNorm(), 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testLmder() {
-  const int m = 15, n = 3;
-  int info;
-  double fnorm, covfac;
-  VectorXd x;
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmder_functor functor;
-  LevenbergMarquardt<lmder_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return values
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 6);
-  // VERIFY_IS_EQUAL(lm.njev(), 5);
-
-  // check norm
-  fnorm = lm.fvec().blueNorm();
-  VERIFY_IS_APPROX(fnorm, 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-
-  // check covariance
-  covfac = fnorm * fnorm / (m - n);
-  internal::covar(lm.matrixR(), lm.permutation().indices());  // TODO : move this as a function of lm
-
-  MatrixXd cov_ref(n, n);
-  cov_ref << 0.0001531202, 0.002869941, -0.002656662, 0.002869941, 0.09480935, -0.09098995, -0.002656662, -0.09098995,
-      0.08778727;
-
-  //  std::cout << fjac*covfac << std::endl;
-
-  MatrixXd cov;
-  cov = covfac * lm.matrixR().topLeftCorner<n, n>();
-  VERIFY_IS_APPROX(cov, cov_ref);
-  // TODO: why isn't this allowed ? :
-  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
-}
-
-struct lmdif_functor : DenseFunctor<double> {
-  lmdif_functor(void) : DenseFunctor<double>(3, 15) {}
-  int operator()(const VectorXd &x, VectorXd &fvec) const {
-    int i;
-    double tmp1, tmp2, tmp3;
-    static const double y[15] = {1.4e-1, 1.8e-1, 2.2e-1, 2.5e-1, 2.9e-1, 3.2e-1, 3.5e-1, 3.9e-1,
-                                 3.7e-1, 5.8e-1, 7.3e-1, 9.6e-1, 1.34e0, 2.1e0,  4.39e0};
-
-    assert(x.size() == 3);
-    assert(fvec.size() == 15);
-    for (i = 0; i < 15; i++) {
-      tmp1 = i + 1;
-      tmp2 = 15 - i;
-      tmp3 = tmp1;
-
-      if (i >= 8) tmp3 = tmp2;
-      fvec[i] = y[i] - (x[0] + tmp1 / (x[1] * tmp2 + x[2] * tmp3));
-    }
-    return 0;
-  }
-};
-
-void testLmdif1() {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n), fvec(15);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmdif_functor functor;
-  DenseIndex nfev;
-  info = LevenbergMarquardt<lmdif_functor>::lmdif1(functor, x, &nfev);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  //   VERIFY_IS_EQUAL(nfev, 26);
-
-  // check norm
-  functor(x, fvec);
-  VERIFY_IS_APPROX(fvec.blueNorm(), 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.0824106, 1.1330366, 2.3436947;
-  VERIFY_IS_APPROX(x, x_ref);
-}
-
-void testLmdif() {
-  const int m = 15, n = 3;
-  int info;
-  double fnorm, covfac;
-  VectorXd x(n);
-
-  /* the following starting values provide a rough fit. */
-  x.setConstant(n, 1.);
-
-  // do the computation
-  lmdif_functor functor;
-  NumericalDiff<lmdif_functor> numDiff(functor);
-  LevenbergMarquardt<NumericalDiff<lmdif_functor> > lm(numDiff);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return values
-  // VERIFY_IS_EQUAL(info, 1);
-  //   VERIFY_IS_EQUAL(lm.nfev(), 26);
-
-  // check norm
-  fnorm = lm.fvec().blueNorm();
-  VERIFY_IS_APPROX(fnorm, 0.09063596);
-
-  // check x
-  VectorXd x_ref(n);
-  x_ref << 0.08241058, 1.133037, 2.343695;
-  VERIFY_IS_APPROX(x, x_ref);
-
-  // check covariance
-  covfac = fnorm * fnorm / (m - n);
-  internal::covar(lm.matrixR(), lm.permutation().indices());  // TODO : move this as a function of lm
-
-  MatrixXd cov_ref(n, n);
-  cov_ref << 0.0001531202, 0.002869942, -0.002656662, 0.002869942, 0.09480937, -0.09098997, -0.002656662, -0.09098997,
-      0.08778729;
-
-  //  std::cout << fjac*covfac << std::endl;
-
-  MatrixXd cov;
-  cov = covfac * lm.matrixR().topLeftCorner<n, n>();
-  VERIFY_IS_APPROX(cov, cov_ref);
-  // TODO: why isn't this allowed ? :
-  // VERIFY_IS_APPROX( covfac*fjac.topLeftCorner<n,n>() , cov_ref);
-}
-
-struct chwirut2_functor : DenseFunctor<double> {
-  chwirut2_functor(void) : DenseFunctor<double>(3, 54) {}
-  static const double m_x[54];
-  static const double m_y[54];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    int i;
-
-    assert(b.size() == 3);
-    assert(fvec.size() == 54);
-    for (i = 0; i < 54; i++) {
-      double x = m_x[i];
-      fvec[i] = exp(-b[0] * x) / (b[1] + b[2] * x) - m_y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 54);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 54; i++) {
-      double x = m_x[i];
-      double factor = 1. / (b[1] + b[2] * x);
-      double e = exp(-b[0] * x);
-      fjac(i, 0) = -x * e * factor;
-      fjac(i, 1) = -e * factor * factor;
-      fjac(i, 2) = -x * e * factor * factor;
-    }
-    return 0;
-  }
-};
-const double chwirut2_functor::m_x[54] = {
-    0.500E0, 1.000E0, 1.750E0, 3.750E0, 5.750E0, 0.875E0, 2.250E0, 3.250E0, 5.250E0, 0.750E0, 1.750E0,
-    2.750E0, 4.750E0, 0.625E0, 1.250E0, 2.250E0, 4.250E0, .500E0,  3.000E0, .750E0,  3.000E0, 1.500E0,
-    6.000E0, 3.000E0, 6.000E0, 1.500E0, 3.000E0, .500E0,  2.000E0, 4.000E0, .750E0,  2.000E0, 5.000E0,
-    .750E0,  2.250E0, 3.750E0, 5.750E0, 3.000E0, .750E0,  2.500E0, 4.000E0, .750E0,  2.500E0, 4.000E0,
-    .750E0,  2.500E0, 4.000E0, .500E0,  6.000E0, 3.000E0, .500E0,  2.750E0, .500E0,  1.750E0};
-const double chwirut2_functor::m_y[54] = {
-    92.9000E0, 57.1000E0, 31.0500E0, 11.5875E0, 8.0250E0,  63.6000E0, 21.4000E0, 14.2500E0, 8.4750E0,
-    63.8000E0, 26.8000E0, 16.4625E0, 7.1250E0,  67.3000E0, 41.0000E0, 21.1500E0, 8.1750E0,  81.5000E0,
-    13.1200E0, 59.9000E0, 14.6200E0, 32.9000E0, 5.4400E0,  12.5600E0, 5.4400E0,  32.0000E0, 13.9500E0,
-    75.8000E0, 20.0000E0, 10.4200E0, 59.5000E0, 21.6700E0, 8.5500E0,  62.0000E0, 20.2000E0, 7.7600E0,
-    3.7500E0,  11.8100E0, 54.7000E0, 23.7000E0, 11.5500E0, 61.3000E0, 17.7000E0, 8.7400E0,  59.2000E0,
-    16.3000E0, 8.6200E0,  81.0000E0, 4.8700E0,  14.6200E0, 81.7000E0, 17.1700E0, 81.3000E0, 28.9000E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/chwirut2.shtml
-void testNistChwirut2(void) {
-  const int n = 3;
-  LevenbergMarquardtSpace::Status info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 0.1, 0.01, 0.02;
-  // do the computation
-  chwirut2_functor functor;
-  LevenbergMarquardt<chwirut2_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  //   VERIFY_IS_EQUAL(lm.nfev(), 10);
-  // VERIFY_IS_EQUAL(lm.njev(), 8);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.1304802941E+02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
-  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
-  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
-
-  /*
-   * Second try
-   */
-  x << 0.15, 0.008, 0.010;
-  // do the computation
-  lm.resetParameters();
-  lm.setFtol(1.E6 * NumTraits<double>::epsilon());
-  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  //   VERIFY_IS_EQUAL(lm.nfev(), 7);
-  // VERIFY_IS_EQUAL(lm.njev(), 6);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.1304802941E+02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.6657666537E-01);
-  VERIFY_IS_APPROX(x[1], 5.1653291286E-03);
-  VERIFY_IS_APPROX(x[2], 1.2150007096E-02);
-}
-
-struct misra1a_functor : DenseFunctor<double> {
-  misra1a_functor(void) : DenseFunctor<double>(2, 14) {}
-  static const double m_x[14];
-  static const double m_y[14];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 2);
-    assert(fvec.size() == 14);
-    for (int i = 0; i < 14; i++) {
-      fvec[i] = b[0] * (1. - exp(-b[1] * m_x[i])) - m_y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 2);
-    assert(fjac.rows() == 14);
-    assert(fjac.cols() == 2);
-    for (int i = 0; i < 14; i++) {
-      fjac(i, 0) = (1. - exp(-b[1] * m_x[i]));
-      fjac(i, 1) = (b[0] * m_x[i] * exp(-b[1] * m_x[i]));
-    }
-    return 0;
-  }
-};
-const double misra1a_functor::m_x[14] = {77.6E0,  114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0,
-                                         378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0};
-const double misra1a_functor::m_y[14] = {10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0,
-                                         44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/misra1a.shtml
-void testNistMisra1a(void) {
-  const int n = 2;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 500., 0.0001;
-  // do the computation
-  misra1a_functor functor;
-  LevenbergMarquardt<misra1a_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 19);
-  // VERIFY_IS_EQUAL(lm.njev(), 15);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.2455138894E-01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
-  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
-
-  /*
-   * Second try
-   */
-  x << 250., 0.0005;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 5);
-  // VERIFY_IS_EQUAL(lm.njev(), 4);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.2455138894E-01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.3894212918E+02);
-  VERIFY_IS_APPROX(x[1], 5.5015643181E-04);
-}
-
-struct hahn1_functor : DenseFunctor<double> {
-  hahn1_functor(void) : DenseFunctor<double>(7, 236) {}
-  static const double m_x[236];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    static const double m_y[236] = {
-        .591E0,   1.547E0,  2.902E0,  2.894E0,  4.703E0,  6.307E0,  7.03E0,   7.898E0,  9.470E0,  9.484E0,  10.072E0,
-        10.163E0, 11.615E0, 12.005E0, 12.478E0, 12.982E0, 12.970E0, 13.926E0, 14.452E0, 14.404E0, 15.190E0, 15.550E0,
-        15.528E0, 15.499E0, 16.131E0, 16.438E0, 16.387E0, 16.549E0, 16.872E0, 16.830E0, 16.926E0, 16.907E0, 16.966E0,
-        17.060E0, 17.122E0, 17.311E0, 17.355E0, 17.668E0, 17.767E0, 17.803E0, 17.765E0, 17.768E0, 17.736E0, 17.858E0,
-        17.877E0, 17.912E0, 18.046E0, 18.085E0, 18.291E0, 18.357E0, 18.426E0, 18.584E0, 18.610E0, 18.870E0, 18.795E0,
-        19.111E0, .367E0,   .796E0,   0.892E0,  1.903E0,  2.150E0,  3.697E0,  5.870E0,  6.421E0,  7.422E0,  9.944E0,
-        11.023E0, 11.87E0,  12.786E0, 14.067E0, 13.974E0, 14.462E0, 14.464E0, 15.381E0, 15.483E0, 15.59E0,  16.075E0,
-        16.347E0, 16.181E0, 16.915E0, 17.003E0, 16.978E0, 17.756E0, 17.808E0, 17.868E0, 18.481E0, 18.486E0, 19.090E0,
-        16.062E0, 16.337E0, 16.345E0, 16.388E0, 17.159E0, 17.116E0, 17.164E0, 17.123E0, 17.979E0, 17.974E0, 18.007E0,
-        17.993E0, 18.523E0, 18.669E0, 18.617E0, 19.371E0, 19.330E0, 0.080E0,  0.248E0,  1.089E0,  1.418E0,  2.278E0,
-        3.624E0,  4.574E0,  5.556E0,  7.267E0,  7.695E0,  9.136E0,  9.959E0,  9.957E0,  11.600E0, 13.138E0, 13.564E0,
-        13.871E0, 13.994E0, 14.947E0, 15.473E0, 15.379E0, 15.455E0, 15.908E0, 16.114E0, 17.071E0, 17.135E0, 17.282E0,
-        17.368E0, 17.483E0, 17.764E0, 18.185E0, 18.271E0, 18.236E0, 18.237E0, 18.523E0, 18.627E0, 18.665E0, 19.086E0,
-        0.214E0,  0.943E0,  1.429E0,  2.241E0,  2.951E0,  3.782E0,  4.757E0,  5.602E0,  7.169E0,  8.920E0,  10.055E0,
-        12.035E0, 12.861E0, 13.436E0, 14.167E0, 14.755E0, 15.168E0, 15.651E0, 15.746E0, 16.216E0, 16.445E0, 16.965E0,
-        17.121E0, 17.206E0, 17.250E0, 17.339E0, 17.793E0, 18.123E0, 18.49E0,  18.566E0, 18.645E0, 18.706E0, 18.924E0,
-        19.1E0,   0.375E0,  0.471E0,  1.504E0,  2.204E0,  2.813E0,  4.765E0,  9.835E0,  10.040E0, 11.946E0, 12.596E0,
-        13.303E0, 13.922E0, 14.440E0, 14.951E0, 15.627E0, 15.639E0, 15.814E0, 16.315E0, 16.334E0, 16.430E0, 16.423E0,
-        17.024E0, 17.009E0, 17.165E0, 17.134E0, 17.349E0, 17.576E0, 17.848E0, 18.090E0, 18.276E0, 18.404E0, 18.519E0,
-        19.133E0, 19.074E0, 19.239E0, 19.280E0, 19.101E0, 19.398E0, 19.252E0, 19.89E0,  20.007E0, 19.929E0, 19.268E0,
-        19.324E0, 20.049E0, 20.107E0, 20.062E0, 20.065E0, 19.286E0, 19.972E0, 20.088E0, 20.743E0, 20.83E0,  20.935E0,
-        21.035E0, 20.93E0,  21.074E0, 21.085E0, 20.935E0};
-
-    //        int called=0; printf("call hahn1_functor with  iflag=%d, called=%d\n", iflag, called); if (iflag==1)
-    //        called++;
-
-    assert(b.size() == 7);
-    assert(fvec.size() == 236);
-    for (int i = 0; i < 236; i++) {
-      double x = m_x[i], xx = x * x, xxx = xx * x;
-      fvec[i] = (b[0] + b[1] * x + b[2] * xx + b[3] * xxx) / (1. + b[4] * x + b[5] * xx + b[6] * xxx) - m_y[i];
-    }
-    return 0;
-  }
-
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 7);
-    assert(fjac.rows() == 236);
-    assert(fjac.cols() == 7);
-    for (int i = 0; i < 236; i++) {
-      double x = m_x[i], xx = x * x, xxx = xx * x;
-      double fact = 1. / (1. + b[4] * x + b[5] * xx + b[6] * xxx);
-      fjac(i, 0) = 1. * fact;
-      fjac(i, 1) = x * fact;
-      fjac(i, 2) = xx * fact;
-      fjac(i, 3) = xxx * fact;
-      fact = -(b[0] + b[1] * x + b[2] * xx + b[3] * xxx) * fact * fact;
-      fjac(i, 4) = x * fact;
-      fjac(i, 5) = xx * fact;
-      fjac(i, 6) = xxx * fact;
-    }
-    return 0;
-  }
-};
-const double hahn1_functor::m_x[236] = {
-    24.41E0,  34.82E0,  44.09E0,  45.07E0,  54.98E0,  65.51E0,  70.53E0,  75.70E0,  89.57E0,  91.14E0,  96.40E0,
-    97.19E0,  114.26E0, 120.25E0, 127.08E0, 133.55E0, 133.61E0, 158.67E0, 172.74E0, 171.31E0, 202.14E0, 220.55E0,
-    221.05E0, 221.39E0, 250.99E0, 268.99E0, 271.80E0, 271.97E0, 321.31E0, 321.69E0, 330.14E0, 333.03E0, 333.47E0,
-    340.77E0, 345.65E0, 373.11E0, 373.79E0, 411.82E0, 419.51E0, 421.59E0, 422.02E0, 422.47E0, 422.61E0, 441.75E0,
-    447.41E0, 448.7E0,  472.89E0, 476.69E0, 522.47E0, 522.62E0, 524.43E0, 546.75E0, 549.53E0, 575.29E0, 576.00E0,
-    625.55E0, 20.15E0,  28.78E0,  29.57E0,  37.41E0,  39.12E0,  50.24E0,  61.38E0,  66.25E0,  73.42E0,  95.52E0,
-    107.32E0, 122.04E0, 134.03E0, 163.19E0, 163.48E0, 175.70E0, 179.86E0, 211.27E0, 217.78E0, 219.14E0, 262.52E0,
-    268.01E0, 268.62E0, 336.25E0, 337.23E0, 339.33E0, 427.38E0, 428.58E0, 432.68E0, 528.99E0, 531.08E0, 628.34E0,
-    253.24E0, 273.13E0, 273.66E0, 282.10E0, 346.62E0, 347.19E0, 348.78E0, 351.18E0, 450.10E0, 450.35E0, 451.92E0,
-    455.56E0, 552.22E0, 553.56E0, 555.74E0, 652.59E0, 656.20E0, 14.13E0,  20.41E0,  31.30E0,  33.84E0,  39.70E0,
-    48.83E0,  54.50E0,  60.41E0,  72.77E0,  75.25E0,  86.84E0,  94.88E0,  96.40E0,  117.37E0, 139.08E0, 147.73E0,
-    158.63E0, 161.84E0, 192.11E0, 206.76E0, 209.07E0, 213.32E0, 226.44E0, 237.12E0, 330.90E0, 358.72E0, 370.77E0,
-    372.72E0, 396.24E0, 416.59E0, 484.02E0, 495.47E0, 514.78E0, 515.65E0, 519.47E0, 544.47E0, 560.11E0, 620.77E0,
-    18.97E0,  28.93E0,  33.91E0,  40.03E0,  44.66E0,  49.87E0,  55.16E0,  60.90E0,  72.08E0,  85.15E0,  97.06E0,
-    119.63E0, 133.27E0, 143.84E0, 161.91E0, 180.67E0, 198.44E0, 226.86E0, 229.65E0, 258.27E0, 273.77E0, 339.15E0,
-    350.13E0, 362.75E0, 371.03E0, 393.32E0, 448.53E0, 473.78E0, 511.12E0, 524.70E0, 548.75E0, 551.64E0, 574.02E0,
-    623.86E0, 21.46E0,  24.33E0,  33.43E0,  39.22E0,  44.18E0,  55.02E0,  94.33E0,  96.44E0,  118.82E0, 128.48E0,
-    141.94E0, 156.92E0, 171.65E0, 190.00E0, 223.26E0, 223.88E0, 231.50E0, 265.05E0, 269.44E0, 271.78E0, 273.46E0,
-    334.61E0, 339.79E0, 349.52E0, 358.18E0, 377.98E0, 394.77E0, 429.66E0, 468.22E0, 487.27E0, 519.54E0, 523.03E0,
-    612.99E0, 638.59E0, 641.36E0, 622.05E0, 631.50E0, 663.97E0, 646.9E0,  748.29E0, 749.21E0, 750.14E0, 647.04E0,
-    646.89E0, 746.9E0,  748.43E0, 747.35E0, 749.27E0, 647.61E0, 747.78E0, 750.51E0, 851.37E0, 845.97E0, 847.54E0,
-    849.93E0, 851.61E0, 849.75E0, 850.98E0, 848.23E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/hahn1.shtml
-void testNistHahn1(void) {
-  const int n = 7;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 10., -1., .05, -.00001, -.05, .001, -.000001;
-  // do the computation
-  hahn1_functor functor;
-  LevenbergMarquardt<hahn1_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 11);
-  // VERIFY_IS_EQUAL(lm.njev(), 10);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.5324382854E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.0776351733E+00);
-  VERIFY_IS_APPROX(x[1], -1.2269296921E-01);
-  VERIFY_IS_APPROX(x[2], 4.0863750610E-03);
-  VERIFY_IS_APPROX(x[3], -1.426264e-06);  // should be : -1.4262662514E-06
-  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
-  VERIFY_IS_APPROX(x[5], 2.4053735503E-04);
-  VERIFY_IS_APPROX(x[6], -1.2314450199E-07);
-
-  /*
-   * Second try
-   */
-  x << .1, -.1, .005, -.000001, -.005, .0001, -.0000001;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  //   VERIFY_IS_EQUAL(lm.nfev(), 11);
-  // VERIFY_IS_EQUAL(lm.njev(), 10);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.5324382854E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.077640);       // should be :  1.0776351733E+00
-  VERIFY_IS_APPROX(x[1], -0.1226933);     // should be : -1.2269296921E-01
-  VERIFY_IS_APPROX(x[2], 0.004086383);    // should be : 4.0863750610E-03
-  VERIFY_IS_APPROX(x[3], -1.426277e-06);  // should be : -1.4262662514E-06
-  VERIFY_IS_APPROX(x[4], -5.7609940901E-03);
-  VERIFY_IS_APPROX(x[5], 0.00024053772);  // should be : 2.4053735503E-04
-  VERIFY_IS_APPROX(x[6], -1.231450e-07);  // should be : -1.2314450199E-07
-}
-
-struct misra1d_functor : DenseFunctor<double> {
-  misra1d_functor(void) : DenseFunctor<double>(2, 14) {}
-  static const double x[14];
-  static const double y[14];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 2);
-    assert(fvec.size() == 14);
-    for (int i = 0; i < 14; i++) {
-      fvec[i] = b[0] * b[1] * x[i] / (1. + b[1] * x[i]) - y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 2);
-    assert(fjac.rows() == 14);
-    assert(fjac.cols() == 2);
-    for (int i = 0; i < 14; i++) {
-      double den = 1. + b[1] * x[i];
-      fjac(i, 0) = b[1] * x[i] / den;
-      fjac(i, 1) = b[0] * x[i] * (den - b[1] * x[i]) / den / den;
-    }
-    return 0;
-  }
-};
-const double misra1d_functor::x[14] = {77.6E0,  114.9E0, 141.1E0, 190.8E0, 239.9E0, 289.0E0, 332.8E0,
-                                       378.4E0, 434.8E0, 477.3E0, 536.8E0, 593.1E0, 689.1E0, 760.0E0};
-const double misra1d_functor::y[14] = {10.07E0, 14.73E0, 17.94E0, 23.93E0, 29.61E0, 35.18E0, 40.02E0,
-                                       44.82E0, 50.76E0, 55.05E0, 61.01E0, 66.40E0, 75.47E0, 81.78E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/misra1d.shtml
-void testNistMisra1d(void) {
-  const int n = 2;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 500., 0.0001;
-  // do the computation
-  misra1d_functor functor;
-  LevenbergMarquardt<misra1d_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 9);
-  // VERIFY_IS_EQUAL(lm.njev(), 7);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6419295283E-02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
-  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
-
-  /*
-   * Second try
-   */
-  x << 450., 0.0003;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 4);
-  // VERIFY_IS_EQUAL(lm.njev(), 3);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6419295283E-02);
-  // check x
-  VERIFY_IS_APPROX(x[0], 4.3736970754E+02);
-  VERIFY_IS_APPROX(x[1], 3.0227324449E-04);
-}
-
-struct lanczos1_functor : DenseFunctor<double> {
-  lanczos1_functor(void) : DenseFunctor<double>(6, 24) {}
-  static const double x[24];
-  static const double y[24];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 6);
-    assert(fvec.size() == 24);
-    for (int i = 0; i < 24; i++)
-      fvec[i] = b[0] * exp(-b[1] * x[i]) + b[2] * exp(-b[3] * x[i]) + b[4] * exp(-b[5] * x[i]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 6);
-    assert(fjac.rows() == 24);
-    assert(fjac.cols() == 6);
-    for (int i = 0; i < 24; i++) {
-      fjac(i, 0) = exp(-b[1] * x[i]);
-      fjac(i, 1) = -b[0] * x[i] * exp(-b[1] * x[i]);
-      fjac(i, 2) = exp(-b[3] * x[i]);
-      fjac(i, 3) = -b[2] * x[i] * exp(-b[3] * x[i]);
-      fjac(i, 4) = exp(-b[5] * x[i]);
-      fjac(i, 5) = -b[4] * x[i] * exp(-b[5] * x[i]);
-    }
-    return 0;
-  }
-};
-const double lanczos1_functor::x[24] = {0.000000000000E+00, 5.000000000000E-02, 1.000000000000E-01, 1.500000000000E-01,
-                                        2.000000000000E-01, 2.500000000000E-01, 3.000000000000E-01, 3.500000000000E-01,
-                                        4.000000000000E-01, 4.500000000000E-01, 5.000000000000E-01, 5.500000000000E-01,
-                                        6.000000000000E-01, 6.500000000000E-01, 7.000000000000E-01, 7.500000000000E-01,
-                                        8.000000000000E-01, 8.500000000000E-01, 9.000000000000E-01, 9.500000000000E-01,
-                                        1.000000000000E+00, 1.050000000000E+00, 1.100000000000E+00, 1.150000000000E+00};
-const double lanczos1_functor::y[24] = {2.513400000000E+00, 2.044333373291E+00, 1.668404436564E+00, 1.366418021208E+00,
-                                        1.123232487372E+00, 9.268897180037E-01, 7.679338563728E-01, 6.388775523106E-01,
-                                        5.337835317402E-01, 4.479363617347E-01, 3.775847884350E-01, 3.197393199326E-01,
-                                        2.720130773746E-01, 2.324965529032E-01, 1.996589546065E-01, 1.722704126914E-01,
-                                        1.493405660168E-01, 1.300700206922E-01, 1.138119324644E-01, 1.000415587559E-01,
-                                        8.833209084540E-02, 7.833544019350E-02, 6.976693743449E-02, 6.239312536719E-02};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/lanczos1.shtml
-void testNistLanczos1(void) {
-  const int n = 6;
-  LevenbergMarquardtSpace::Status info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1.2, 0.3, 5.6, 5.5, 6.5, 7.6;
-  // do the computation
-  lanczos1_functor functor;
-  LevenbergMarquardt<lanczos1_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeErrorTooSmall);
-  // VERIFY_IS_EQUAL(lm.nfev(), 79);
-  // VERIFY_IS_EQUAL(lm.njev(), 72);
-  // check norm^2
-  VERIFY(lm.fvec().squaredNorm() <= 1.44E-25);
-  // check x
-  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
-  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
-  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
-  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
-  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
-  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
-
-  /*
-   * Second try
-   */
-  x << 0.5, 0.7, 3.6, 4.2, 4., 6.3;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeErrorTooSmall);
-  // VERIFY_IS_EQUAL(lm.nfev(), 9);
-  // VERIFY_IS_EQUAL(lm.njev(), 8);
-  // check norm^2
-  VERIFY(lm.fvec().squaredNorm() <= 1.44E-25);
-  // check x
-  VERIFY_IS_APPROX(x[0], 9.5100000027E-02);
-  VERIFY_IS_APPROX(x[1], 1.0000000001E+00);
-  VERIFY_IS_APPROX(x[2], 8.6070000013E-01);
-  VERIFY_IS_APPROX(x[3], 3.0000000002E+00);
-  VERIFY_IS_APPROX(x[4], 1.5575999998E+00);
-  VERIFY_IS_APPROX(x[5], 5.0000000001E+00);
-}
-
-struct rat42_functor : DenseFunctor<double> {
-  rat42_functor(void) : DenseFunctor<double>(3, 9) {}
-  static const double x[9];
-  static const double y[9];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 9);
-    for (int i = 0; i < 9; i++) {
-      fvec[i] = b[0] / (1. + exp(b[1] - b[2] * x[i])) - y[i];
-    }
-    return 0;
-  }
-
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 9);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 9; i++) {
-      double e = exp(b[1] - b[2] * x[i]);
-      fjac(i, 0) = 1. / (1. + e);
-      fjac(i, 1) = -b[0] * e / (1. + e) / (1. + e);
-      fjac(i, 2) = +b[0] * e * x[i] / (1. + e) / (1. + e);
-    }
-    return 0;
-  }
-};
-const double rat42_functor::x[9] = {9.000E0,  14.000E0, 21.000E0, 28.000E0, 42.000E0,
-                                    57.000E0, 63.000E0, 70.000E0, 79.000E0};
-const double rat42_functor::y[9] = {8.930E0,  10.800E0, 18.590E0, 22.330E0, 39.350E0,
-                                    56.110E0, 61.730E0, 64.620E0, 67.080E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky2.shtml
-void testNistRat42(void) {
-  const int n = 3;
-  LevenbergMarquardtSpace::Status info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 100., 1., 0.1;
-  // do the computation
-  rat42_functor functor;
-  LevenbergMarquardt<rat42_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
-  // VERIFY_IS_EQUAL(lm.nfev(), 10);
-  // VERIFY_IS_EQUAL(lm.njev(), 8);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.0565229338E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
-  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
-  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
-
-  /*
-   * Second try
-   */
-  x << 75., 2.5, 0.07;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
-  // VERIFY_IS_EQUAL(lm.nfev(), 6);
-  // VERIFY_IS_EQUAL(lm.njev(), 5);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.0565229338E+00);
-  // check x
-  VERIFY_IS_APPROX(x[0], 7.2462237576E+01);
-  VERIFY_IS_APPROX(x[1], 2.6180768402E+00);
-  VERIFY_IS_APPROX(x[2], 6.7359200066E-02);
-}
-
-struct MGH10_functor : DenseFunctor<double> {
-  MGH10_functor(void) : DenseFunctor<double>(3, 16) {}
-  static const double x[16];
-  static const double y[16];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 16);
-    for (int i = 0; i < 16; i++) fvec[i] = b[0] * exp(b[1] / (x[i] + b[2])) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 16);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 16; i++) {
-      double factor = 1. / (x[i] + b[2]);
-      double e = exp(b[1] * factor);
-      fjac(i, 0) = e;
-      fjac(i, 1) = b[0] * factor * e;
-      fjac(i, 2) = -b[1] * b[0] * factor * factor * e;
-    }
-    return 0;
-  }
-};
-const double MGH10_functor::x[16] = {5.000000E+01, 5.500000E+01, 6.000000E+01, 6.500000E+01, 7.000000E+01, 7.500000E+01,
-                                     8.000000E+01, 8.500000E+01, 9.000000E+01, 9.500000E+01, 1.000000E+02, 1.050000E+02,
-                                     1.100000E+02, 1.150000E+02, 1.200000E+02, 1.250000E+02};
-const double MGH10_functor::y[16] = {3.478000E+04, 2.861000E+04, 2.365000E+04, 1.963000E+04, 1.637000E+04, 1.372000E+04,
-                                     1.154000E+04, 9.744000E+03, 8.261000E+03, 7.030000E+03, 6.005000E+03, 5.147000E+03,
-                                     4.427000E+03, 3.820000E+03, 3.307000E+03, 2.872000E+03};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/mgh10.shtml
-void testNistMGH10(void) {
-  const int n = 3;
-  LevenbergMarquardtSpace::Status info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 2., 400000., 25000.;
-  // do the computation
-  MGH10_functor functor;
-  LevenbergMarquardt<MGH10_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-  // ++g_test_level;
-  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
-  // --g_test_level;
-  // was: VERIFY_IS_EQUAL(info, 1);
-
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7945855171E+01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
-  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
-  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
-
-  // check return value
-
-  // ++g_test_level;
-  // VERIFY_IS_EQUAL(lm.nfev(), 284 );
-  // VERIFY_IS_EQUAL(lm.njev(), 249 );
-  // --g_test_level;
-  VERIFY(lm.nfev() < 284 * LM_EVAL_COUNT_TOL);
-  VERIFY(lm.njev() < 249 * LM_EVAL_COUNT_TOL);
-
-  /*
-   * Second try
-   */
-  x << 0.02, 4000., 250.;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-  // ++g_test_level;
-  // VERIFY_IS_EQUAL(info, LevenbergMarquardtSpace::RelativeReductionTooSmall);
-  // // was: VERIFY_IS_EQUAL(info, 1);
-  // --g_test_level;
-
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7945855171E+01);
-  // check x
-  VERIFY_IS_APPROX(x[0], 5.6096364710E-03);
-  VERIFY_IS_APPROX(x[1], 6.1813463463E+03);
-  VERIFY_IS_APPROX(x[2], 3.4522363462E+02);
-
-  // check return value
-  // ++g_test_level;
-  // VERIFY_IS_EQUAL(lm.nfev(), 126);
-  // VERIFY_IS_EQUAL(lm.njev(), 116);
-  // --g_test_level;
-  VERIFY(lm.nfev() < 126 * LM_EVAL_COUNT_TOL);
-  VERIFY(lm.njev() < 116 * LM_EVAL_COUNT_TOL);
-}
-
-struct BoxBOD_functor : DenseFunctor<double> {
-  BoxBOD_functor(void) : DenseFunctor<double>(2, 6) {}
-  static const double x[6];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    static const double y[6] = {109., 149., 149., 191., 213., 224.};
-    assert(b.size() == 2);
-    assert(fvec.size() == 6);
-    for (int i = 0; i < 6; i++) fvec[i] = b[0] * (1. - exp(-b[1] * x[i])) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 2);
-    assert(fjac.rows() == 6);
-    assert(fjac.cols() == 2);
-    for (int i = 0; i < 6; i++) {
-      double e = exp(-b[1] * x[i]);
-      fjac(i, 0) = 1. - e;
-      fjac(i, 1) = b[0] * x[i] * e;
-    }
-    return 0;
-  }
-};
-const double BoxBOD_functor::x[6] = {1., 2., 3., 5., 7., 10.};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/boxbod.shtml
-void testNistBoxBOD(void) {
-  const int n = 2;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1., 1.;
-  // do the computation
-  BoxBOD_functor functor;
-  LevenbergMarquardt<BoxBOD_functor> lm(functor);
-  lm.setFtol(1.E6 * NumTraits<double>::epsilon());
-  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
-  lm.setFactor(10);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.1680088766E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
-  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY(lm.nfev() < 31); // 31
-  // VERIFY(lm.njev() < 25); // 25
-
-  /*
-   * Second try
-   */
-  x << 100., 0.75;
-  // do the computation
-  lm.resetParameters();
-  lm.setFtol(NumTraits<double>::epsilon());
-  lm.setXtol(NumTraits<double>::epsilon());
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // ++g_test_level;
-  // VERIFY_IS_EQUAL(lm.nfev(), 16 );
-  // VERIFY_IS_EQUAL(lm.njev(), 15 );
-  // --g_test_level;
-  VERIFY(lm.nfev() < 16 * LM_EVAL_COUNT_TOL);
-  VERIFY(lm.njev() < 15 * LM_EVAL_COUNT_TOL);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.1680088766E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 2.1380940889E+02);
-  VERIFY_IS_APPROX(x[1], 5.4723748542E-01);
-}
-
-struct MGH17_functor : DenseFunctor<double> {
-  MGH17_functor(void) : DenseFunctor<double>(5, 33) {}
-  static const double x[33];
-  static const double y[33];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 5);
-    assert(fvec.size() == 33);
-    for (int i = 0; i < 33; i++) fvec[i] = b[0] + b[1] * exp(-b[3] * x[i]) + b[2] * exp(-b[4] * x[i]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 5);
-    assert(fjac.rows() == 33);
-    assert(fjac.cols() == 5);
-    for (int i = 0; i < 33; i++) {
-      fjac(i, 0) = 1.;
-      fjac(i, 1) = exp(-b[3] * x[i]);
-      fjac(i, 2) = exp(-b[4] * x[i]);
-      fjac(i, 3) = -x[i] * b[1] * exp(-b[3] * x[i]);
-      fjac(i, 4) = -x[i] * b[2] * exp(-b[4] * x[i]);
-    }
-    return 0;
-  }
-};
-const double MGH17_functor::x[33] = {0.000000E+00, 1.000000E+01, 2.000000E+01, 3.000000E+01, 4.000000E+01, 5.000000E+01,
-                                     6.000000E+01, 7.000000E+01, 8.000000E+01, 9.000000E+01, 1.000000E+02, 1.100000E+02,
-                                     1.200000E+02, 1.300000E+02, 1.400000E+02, 1.500000E+02, 1.600000E+02, 1.700000E+02,
-                                     1.800000E+02, 1.900000E+02, 2.000000E+02, 2.100000E+02, 2.200000E+02, 2.300000E+02,
-                                     2.400000E+02, 2.500000E+02, 2.600000E+02, 2.700000E+02, 2.800000E+02, 2.900000E+02,
-                                     3.000000E+02, 3.100000E+02, 3.200000E+02};
-const double MGH17_functor::y[33] = {8.440000E-01, 9.080000E-01, 9.320000E-01, 9.360000E-01, 9.250000E-01, 9.080000E-01,
-                                     8.810000E-01, 8.500000E-01, 8.180000E-01, 7.840000E-01, 7.510000E-01, 7.180000E-01,
-                                     6.850000E-01, 6.580000E-01, 6.280000E-01, 6.030000E-01, 5.800000E-01, 5.580000E-01,
-                                     5.380000E-01, 5.220000E-01, 5.060000E-01, 4.900000E-01, 4.780000E-01, 4.670000E-01,
-                                     4.570000E-01, 4.480000E-01, 4.380000E-01, 4.310000E-01, 4.240000E-01, 4.200000E-01,
-                                     4.140000E-01, 4.110000E-01, 4.060000E-01};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/mgh17.shtml
-void testNistMGH17(void) {
-  const int n = 5;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 50., 150., -100., 1., 2.;
-  // do the computation
-  MGH17_functor functor;
-  LevenbergMarquardt<MGH17_functor> lm(functor);
-  lm.setFtol(NumTraits<double>::epsilon());
-  lm.setXtol(NumTraits<double>::epsilon());
-  lm.setMaxfev(1000);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.4648946975E-05);
-  // check x
-  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
-  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
-  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
-  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
-  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
-
-  // check return value
-  //   VERIFY_IS_EQUAL(info, 2);  //FIXME Use (lm.info() == Success)
-  // VERIFY(lm.nfev() < 700 ); // 602
-  // VERIFY(lm.njev() < 600 ); // 545
-
-  /*
-   * Second try
-   */
-  x << 0.5, 1.5, -1, 0.01, 0.02;
-  // do the computation
-  lm.resetParameters();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 18);
-  // VERIFY_IS_EQUAL(lm.njev(), 15);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.4648946975E-05);
-  // check x
-  VERIFY_IS_APPROX(x[0], 3.7541005211E-01);
-  VERIFY_IS_APPROX(x[1], 1.9358469127E+00);
-  VERIFY_IS_APPROX(x[2], -1.4646871366E+00);
-  VERIFY_IS_APPROX(x[3], 1.2867534640E-02);
-  VERIFY_IS_APPROX(x[4], 2.2122699662E-02);
-}
-
-struct MGH09_functor : DenseFunctor<double> {
-  MGH09_functor(void) : DenseFunctor<double>(4, 11) {}
-  static const double _x[11];
-  static const double y[11];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 4);
-    assert(fvec.size() == 11);
-    for (int i = 0; i < 11; i++) {
-      double x = _x[i], xx = x * x;
-      fvec[i] = b[0] * (xx + x * b[1]) / (xx + x * b[2] + b[3]) - y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 4);
-    assert(fjac.rows() == 11);
-    assert(fjac.cols() == 4);
-    for (int i = 0; i < 11; i++) {
-      double x = _x[i], xx = x * x;
-      double factor = 1. / (xx + x * b[2] + b[3]);
-      fjac(i, 0) = (xx + x * b[1]) * factor;
-      fjac(i, 1) = b[0] * x * factor;
-      fjac(i, 2) = -b[0] * (xx + x * b[1]) * x * factor * factor;
-      fjac(i, 3) = -b[0] * (xx + x * b[1]) * factor * factor;
-    }
-    return 0;
-  }
-};
-const double MGH09_functor::_x[11] = {4.,           2.,     1.,           5.E-1,        2.5E-01,     1.670000E-01,
-                                      1.250000E-01, 1.E-01, 8.330000E-02, 7.140000E-02, 6.250000E-02};
-const double MGH09_functor::y[11] = {1.957000E-01, 1.947000E-01, 1.735000E-01, 1.600000E-01, 8.440000E-02, 6.270000E-02,
-                                     4.560000E-02, 3.420000E-02, 3.230000E-02, 2.350000E-02, 2.460000E-02};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/mgh09.shtml
-void testNistMGH09(void) {
-  const int n = 4;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 25., 39, 41.5, 39.;
-  // do the computation
-  MGH09_functor functor;
-  LevenbergMarquardt<MGH09_functor> lm(functor);
-  lm.setMaxfev(1000);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 3.0750560385E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], 0.1928077089);   // should be 1.9280693458E-01
-  VERIFY_IS_APPROX(x[1], 0.19126423573);  // should be 1.9128232873E-01
-  VERIFY_IS_APPROX(x[2], 0.12305309914);  // should be 1.2305650693E-01
-  VERIFY_IS_APPROX(x[3], 0.13605395375);  // should be 1.3606233068E-01
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY(lm.nfev() < 510 ); // 490
-  // VERIFY(lm.njev() < 400 ); // 376
-
-  /*
-   * Second try
-   */
-  x << 0.25, 0.39, 0.415, 0.39;
-  // do the computation
-  lm.resetParameters();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 18);
-  // VERIFY_IS_EQUAL(lm.njev(), 16);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 3.0750560385E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], 0.19280781);  // should be 1.9280693458E-01
-  VERIFY_IS_APPROX(x[1], 0.19126265);  // should be 1.9128232873E-01
-  VERIFY_IS_APPROX(x[2], 0.12305280);  // should be 1.2305650693E-01
-  VERIFY_IS_APPROX(x[3], 0.13605322);  // should be 1.3606233068E-01
-}
-
-struct Bennett5_functor : DenseFunctor<double> {
-  Bennett5_functor(void) : DenseFunctor<double>(3, 154) {}
-  static const double x[154];
-  static const double y[154];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 154);
-    for (int i = 0; i < 154; i++) fvec[i] = b[0] * pow(b[1] + x[i], -1. / b[2]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 154);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 154; i++) {
-      double e = pow(b[1] + x[i], -1. / b[2]);
-      fjac(i, 0) = e;
-      fjac(i, 1) = -b[0] * e / b[2] / (b[1] + x[i]);
-      fjac(i, 2) = b[0] * e * log(b[1] + x[i]) / b[2] / b[2];
-    }
-    return 0;
-  }
-};
-const double Bennett5_functor::x[154] = {
-    7.447168E0,  8.102586E0,  8.452547E0,  8.711278E0,  8.916774E0,  9.087155E0,  9.232590E0,  9.359535E0,  9.472166E0,
-    9.573384E0,  9.665293E0,  9.749461E0,  9.827092E0,  9.899128E0,  9.966321E0,  10.029280E0, 10.088510E0, 10.144430E0,
-    10.197380E0, 10.247670E0, 10.295560E0, 10.341250E0, 10.384950E0, 10.426820E0, 10.467000E0, 10.505640E0, 10.542830E0,
-    10.578690E0, 10.613310E0, 10.646780E0, 10.679150E0, 10.710520E0, 10.740920E0, 10.770440E0, 10.799100E0, 10.826970E0,
-    10.854080E0, 10.880470E0, 10.906190E0, 10.931260E0, 10.955720E0, 10.979590E0, 11.002910E0, 11.025700E0, 11.047980E0,
-    11.069770E0, 11.091100E0, 11.111980E0, 11.132440E0, 11.152480E0, 11.172130E0, 11.191410E0, 11.210310E0, 11.228870E0,
-    11.247090E0, 11.264980E0, 11.282560E0, 11.299840E0, 11.316820E0, 11.333520E0, 11.349940E0, 11.366100E0, 11.382000E0,
-    11.397660E0, 11.413070E0, 11.428240E0, 11.443200E0, 11.457930E0, 11.472440E0, 11.486750E0, 11.500860E0, 11.514770E0,
-    11.528490E0, 11.542020E0, 11.555380E0, 11.568550E0, 11.581560E0, 11.594420E0, 11.607121E0, 11.619640E0, 11.632000E0,
-    11.644210E0, 11.656280E0, 11.668200E0, 11.679980E0, 11.691620E0, 11.703130E0, 11.714510E0, 11.725760E0, 11.736880E0,
-    11.747890E0, 11.758780E0, 11.769550E0, 11.780200E0, 11.790730E0, 11.801160E0, 11.811480E0, 11.821700E0, 11.831810E0,
-    11.841820E0, 11.851730E0, 11.861550E0, 11.871270E0, 11.880890E0, 11.890420E0, 11.899870E0, 11.909220E0, 11.918490E0,
-    11.927680E0, 11.936780E0, 11.945790E0, 11.954730E0, 11.963590E0, 11.972370E0, 11.981070E0, 11.989700E0, 11.998260E0,
-    12.006740E0, 12.015150E0, 12.023490E0, 12.031760E0, 12.039970E0, 12.048100E0, 12.056170E0, 12.064180E0, 12.072120E0,
-    12.080010E0, 12.087820E0, 12.095580E0, 12.103280E0, 12.110920E0, 12.118500E0, 12.126030E0, 12.133500E0, 12.140910E0,
-    12.148270E0, 12.155570E0, 12.162830E0, 12.170030E0, 12.177170E0, 12.184270E0, 12.191320E0, 12.198320E0, 12.205270E0,
-    12.212170E0, 12.219030E0, 12.225840E0, 12.232600E0, 12.239320E0, 12.245990E0, 12.252620E0, 12.259200E0, 12.265750E0,
-    12.272240E0};
-const double Bennett5_functor::y[154] = {
-    -34.834702E0, -34.393200E0, -34.152901E0, -33.979099E0, -33.845901E0, -33.732899E0, -33.640301E0, -33.559200E0,
-    -33.486801E0, -33.423100E0, -33.365101E0, -33.313000E0, -33.260899E0, -33.217400E0, -33.176899E0, -33.139198E0,
-    -33.101601E0, -33.066799E0, -33.035000E0, -33.003101E0, -32.971298E0, -32.942299E0, -32.916302E0, -32.890202E0,
-    -32.864101E0, -32.841000E0, -32.817799E0, -32.797501E0, -32.774300E0, -32.757000E0, -32.733799E0, -32.716400E0,
-    -32.699100E0, -32.678799E0, -32.661400E0, -32.644001E0, -32.626701E0, -32.612202E0, -32.597698E0, -32.583199E0,
-    -32.568699E0, -32.554298E0, -32.539799E0, -32.525299E0, -32.510799E0, -32.499199E0, -32.487598E0, -32.473202E0,
-    -32.461601E0, -32.435501E0, -32.435501E0, -32.426800E0, -32.412300E0, -32.400799E0, -32.392101E0, -32.380501E0,
-    -32.366001E0, -32.357300E0, -32.348598E0, -32.339901E0, -32.328400E0, -32.319698E0, -32.311001E0, -32.299400E0,
-    -32.290699E0, -32.282001E0, -32.273300E0, -32.264599E0, -32.256001E0, -32.247299E0, -32.238602E0, -32.229900E0,
-    -32.224098E0, -32.215401E0, -32.203800E0, -32.198002E0, -32.189400E0, -32.183601E0, -32.174900E0, -32.169102E0,
-    -32.163300E0, -32.154598E0, -32.145901E0, -32.140099E0, -32.131401E0, -32.125599E0, -32.119801E0, -32.111198E0,
-    -32.105400E0, -32.096699E0, -32.090900E0, -32.088001E0, -32.079300E0, -32.073502E0, -32.067699E0, -32.061901E0,
-    -32.056099E0, -32.050301E0, -32.044498E0, -32.038799E0, -32.033001E0, -32.027199E0, -32.024300E0, -32.018501E0,
-    -32.012699E0, -32.004002E0, -32.001099E0, -31.995300E0, -31.989500E0, -31.983700E0, -31.977900E0, -31.972099E0,
-    -31.969299E0, -31.963501E0, -31.957701E0, -31.951900E0, -31.946100E0, -31.940300E0, -31.937401E0, -31.931601E0,
-    -31.925800E0, -31.922899E0, -31.917101E0, -31.911301E0, -31.908400E0, -31.902599E0, -31.896900E0, -31.893999E0,
-    -31.888201E0, -31.885300E0, -31.882401E0, -31.876600E0, -31.873699E0, -31.867901E0, -31.862101E0, -31.859200E0,
-    -31.856300E0, -31.850500E0, -31.844700E0, -31.841801E0, -31.838900E0, -31.833099E0, -31.830200E0, -31.827299E0,
-    -31.821600E0, -31.818701E0, -31.812901E0, -31.809999E0, -31.807100E0, -31.801300E0, -31.798401E0, -31.795500E0,
-    -31.789700E0, -31.786800E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/bennett5.shtml
-void testNistBennett5(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << -2000., 50., 0.8;
-  // do the computation
-  Bennett5_functor functor;
-  LevenbergMarquardt<Bennett5_functor> lm(functor);
-  lm.setMaxfev(1000);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 758);
-  // VERIFY_IS_EQUAL(lm.njev(), 744);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.2404744073E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], -2.5235058043E+03);
-  VERIFY_IS_APPROX(x[1], 4.6736564644E+01);
-  VERIFY_IS_APPROX(x[2], 9.3218483193E-01);
-  /*
-   * Second try
-   */
-  x << -1500., 45., 0.85;
-  // do the computation
-  lm.resetParameters();
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 203);
-  // VERIFY_IS_EQUAL(lm.njev(), 192);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.2404744073E-04);
-  // check x
-  VERIFY_IS_APPROX(x[0], -2523.3007865);  // should be -2.5235058043E+03
-  VERIFY_IS_APPROX(x[1], 46.735705771);   // should be 4.6736564644E+01);
-  VERIFY_IS_APPROX(x[2], 0.93219881891);  // should be 9.3218483193E-01);
-}
-
-struct thurber_functor : DenseFunctor<double> {
-  thurber_functor(void) : DenseFunctor<double>(7, 37) {}
-  static const double _x[37];
-  static const double _y[37];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    //        int called=0; printf("call hahn1_functor with  iflag=%d, called=%d\n", iflag, called); if (iflag==1)
-    //        called++;
-    assert(b.size() == 7);
-    assert(fvec.size() == 37);
-    for (int i = 0; i < 37; i++) {
-      double x = _x[i], xx = x * x, xxx = xx * x;
-      fvec[i] = (b[0] + b[1] * x + b[2] * xx + b[3] * xxx) / (1. + b[4] * x + b[5] * xx + b[6] * xxx) - _y[i];
-    }
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 7);
-    assert(fjac.rows() == 37);
-    assert(fjac.cols() == 7);
-    for (int i = 0; i < 37; i++) {
-      double x = _x[i], xx = x * x, xxx = xx * x;
-      double fact = 1. / (1. + b[4] * x + b[5] * xx + b[6] * xxx);
-      fjac(i, 0) = 1. * fact;
-      fjac(i, 1) = x * fact;
-      fjac(i, 2) = xx * fact;
-      fjac(i, 3) = xxx * fact;
-      fact = -(b[0] + b[1] * x + b[2] * xx + b[3] * xxx) * fact * fact;
-      fjac(i, 4) = x * fact;
-      fjac(i, 5) = xx * fact;
-      fjac(i, 6) = xxx * fact;
-    }
-    return 0;
-  }
-};
-const double thurber_functor::_x[37] = {-3.067E0, -2.981E0, -2.921E0, -2.912E0, -2.840E0, -2.797E0, -2.702E0, -2.699E0,
-                                        -2.633E0, -2.481E0, -2.363E0, -2.322E0, -1.501E0, -1.460E0, -1.274E0, -1.212E0,
-                                        -1.100E0, -1.046E0, -0.915E0, -0.714E0, -0.566E0, -0.545E0, -0.400E0, -0.309E0,
-                                        -0.109E0, -0.103E0, 0.010E0,  0.119E0,  0.377E0,  0.790E0,  0.963E0,  1.006E0,
-                                        1.115E0,  1.572E0,  1.841E0,  2.047E0,  2.200E0};
-const double thurber_functor::_y[37] = {
-    80.574E0,   84.248E0,   87.264E0,   87.195E0,   89.076E0,   89.608E0,   89.868E0,   90.101E0,
-    92.405E0,   95.854E0,   100.696E0,  101.060E0,  401.672E0,  390.724E0,  567.534E0,  635.316E0,
-    733.054E0,  759.087E0,  894.206E0,  990.785E0,  1090.109E0, 1080.914E0, 1122.643E0, 1178.351E0,
-    1260.531E0, 1273.514E0, 1288.339E0, 1327.543E0, 1353.863E0, 1414.509E0, 1425.208E0, 1421.384E0,
-    1442.962E0, 1464.350E0, 1468.705E0, 1447.894E0, 1457.628E0};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/thurber.shtml
-void testNistThurber(void) {
-  const int n = 7;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1000, 1000, 400, 40, 0.7, 0.3, 0.0;
-  // do the computation
-  thurber_functor functor;
-  LevenbergMarquardt<thurber_functor> lm(functor);
-  lm.setFtol(1.E4 * NumTraits<double>::epsilon());
-  lm.setXtol(1.E4 * NumTraits<double>::epsilon());
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 39);
-  // VERIFY_IS_EQUAL(lm.njev(), 36);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6427082397E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
-  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
-  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
-  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
-  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
-  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
-  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
-
-  /*
-   * Second try
-   */
-  x << 1300, 1500, 500, 75, 1, 0.4, 0.05;
-  // do the computation
-  lm.resetParameters();
-  lm.setFtol(1.E4 * NumTraits<double>::epsilon());
-  lm.setXtol(1.E4 * NumTraits<double>::epsilon());
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 29);
-  // VERIFY_IS_EQUAL(lm.njev(), 28);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 5.6427082397E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.2881396800E+03);
-  VERIFY_IS_APPROX(x[1], 1.4910792535E+03);
-  VERIFY_IS_APPROX(x[2], 5.8323836877E+02);
-  VERIFY_IS_APPROX(x[3], 7.5416644291E+01);
-  VERIFY_IS_APPROX(x[4], 9.6629502864E-01);
-  VERIFY_IS_APPROX(x[5], 3.9797285797E-01);
-  VERIFY_IS_APPROX(x[6], 4.9727297349E-02);
-}
-
-struct rat43_functor : DenseFunctor<double> {
-  rat43_functor(void) : DenseFunctor<double>(4, 15) {}
-  static const double x[15];
-  static const double y[15];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 4);
-    assert(fvec.size() == 15);
-    for (int i = 0; i < 15; i++) fvec[i] = b[0] * pow(1. + exp(b[1] - b[2] * x[i]), -1. / b[3]) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 4);
-    assert(fjac.rows() == 15);
-    assert(fjac.cols() == 4);
-    for (int i = 0; i < 15; i++) {
-      double e = exp(b[1] - b[2] * x[i]);
-      double power = -1. / b[3];
-      fjac(i, 0) = pow(1. + e, power);
-      fjac(i, 1) = power * b[0] * e * pow(1. + e, power - 1.);
-      fjac(i, 2) = -power * b[0] * e * x[i] * pow(1. + e, power - 1.);
-      fjac(i, 3) = b[0] * power * power * log(1. + e) * pow(1. + e, power);
-    }
-    return 0;
-  }
-};
-const double rat43_functor::x[15] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.};
-const double rat43_functor::y[15] = {16.08,  33.83,  65.80,  97.20,  191.55, 326.20, 386.87, 520.53,
-                                     590.03, 651.92, 724.93, 699.56, 689.96, 637.56, 717.41};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/ratkowsky3.shtml
-void testNistRat43(void) {
-  const int n = 4;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 100., 10., 1., 1.;
-  // do the computation
-  rat43_functor functor;
-  LevenbergMarquardt<rat43_functor> lm(functor);
-  lm.setFtol(1.E6 * NumTraits<double>::epsilon());
-  lm.setXtol(1.E6 * NumTraits<double>::epsilon());
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 27);
-  // VERIFY_IS_EQUAL(lm.njev(), 20);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7864049080E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
-  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
-  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
-  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
-
-  /*
-   * Second try
-   */
-  x << 700., 5., 0.75, 1.3;
-  // do the computation
-  lm.resetParameters();
-  lm.setFtol(1.E5 * NumTraits<double>::epsilon());
-  lm.setXtol(1.E5 * NumTraits<double>::epsilon());
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 9);
-  // VERIFY_IS_EQUAL(lm.njev(), 8);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 8.7864049080E+03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 6.9964151270E+02);
-  VERIFY_IS_APPROX(x[1], 5.2771253025E+00);
-  VERIFY_IS_APPROX(x[2], 7.5962938329E-01);
-  VERIFY_IS_APPROX(x[3], 1.2792483859E+00);
-}
-
-struct eckerle4_functor : DenseFunctor<double> {
-  eckerle4_functor(void) : DenseFunctor<double>(3, 35) {}
-  static const double x[35];
-  static const double y[35];
-  int operator()(const VectorXd &b, VectorXd &fvec) {
-    assert(b.size() == 3);
-    assert(fvec.size() == 35);
-    for (int i = 0; i < 35; i++)
-      fvec[i] = b[0] / b[1] * exp(-0.5 * (x[i] - b[2]) * (x[i] - b[2]) / (b[1] * b[1])) - y[i];
-    return 0;
-  }
-  int df(const VectorXd &b, MatrixXd &fjac) {
-    assert(b.size() == 3);
-    assert(fjac.rows() == 35);
-    assert(fjac.cols() == 3);
-    for (int i = 0; i < 35; i++) {
-      double b12 = b[1] * b[1];
-      double e = exp(-0.5 * (x[i] - b[2]) * (x[i] - b[2]) / b12);
-      fjac(i, 0) = e / b[1];
-      fjac(i, 1) = ((x[i] - b[2]) * (x[i] - b[2]) / b12 - 1.) * b[0] * e / b12;
-      fjac(i, 2) = (x[i] - b[2]) * e * b[0] / b[1] / b12;
-    }
-    return 0;
-  }
-};
-const double eckerle4_functor::x[35] = {400.0, 405.0, 410.0, 415.0, 420.0, 425.0, 430.0, 435.0, 436.5,
-                                        438.0, 439.5, 441.0, 442.5, 444.0, 445.5, 447.0, 448.5, 450.0,
-                                        451.5, 453.0, 454.5, 456.0, 457.5, 459.0, 460.5, 462.0, 463.5,
-                                        465.0, 470.0, 475.0, 480.0, 485.0, 490.0, 495.0, 500.0};
-const double eckerle4_functor::y[35] = {0.0001575, 0.0001699, 0.0002350, 0.0003102, 0.0004917, 0.0008710, 0.0017418,
-                                        0.0046400, 0.0065895, 0.0097302, 0.0149002, 0.0237310, 0.0401683, 0.0712559,
-                                        0.1264458, 0.2073413, 0.2902366, 0.3445623, 0.3698049, 0.3668534, 0.3106727,
-                                        0.2078154, 0.1164354, 0.0616764, 0.0337200, 0.0194023, 0.0117831, 0.0074357,
-                                        0.0022732, 0.0008800, 0.0004579, 0.0002345, 0.0001586, 0.0001143, 0.0000710};
-
-// http://www.itl.nist.gov/div898/strd/nls/data/eckerle4.shtml
-void testNistEckerle4(void) {
-  const int n = 3;
-  int info;
-
-  VectorXd x(n);
-
-  /*
-   * First try
-   */
-  x << 1., 10., 500.;
-  // do the computation
-  eckerle4_functor functor;
-  LevenbergMarquardt<eckerle4_functor> lm(functor);
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 18);
-  // VERIFY_IS_EQUAL(lm.njev(), 15);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.4635887487E-03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.5543827178);
-  VERIFY_IS_APPROX(x[1], 4.0888321754);
-  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
-
-  /*
-   * Second try
-   */
-  x << 1.5, 5., 450.;
-  // do the computation
-  info = lm.minimize(x);
-  EIGEN_UNUSED_VARIABLE(info)
-
-  // check return value
-  // VERIFY_IS_EQUAL(info, 1);
-  // VERIFY_IS_EQUAL(lm.nfev(), 7);
-  // VERIFY_IS_EQUAL(lm.njev(), 6);
-  // check norm^2
-  VERIFY_IS_APPROX(lm.fvec().squaredNorm(), 1.4635887487E-03);
-  // check x
-  VERIFY_IS_APPROX(x[0], 1.5543827178);
-  VERIFY_IS_APPROX(x[1], 4.0888321754);
-  VERIFY_IS_APPROX(x[2], 4.5154121844E+02);
-}
-
-EIGEN_DECLARE_TEST(levenberg_marquardt) {
-  // Tests using the examples provided by (c)minpack
-  CALL_SUBTEST(testLmder1());
-  CALL_SUBTEST(testLmder());
-  CALL_SUBTEST(testLmdif1());
-  //     CALL_SUBTEST(testLmstr1());
-  //     CALL_SUBTEST(testLmstr());
-  CALL_SUBTEST(testLmdif());
-
-  // NIST tests, level of difficulty = "Lower"
-  CALL_SUBTEST(testNistMisra1a());
-  CALL_SUBTEST(testNistChwirut2());
-
-  // NIST tests, level of difficulty = "Average"
-  CALL_SUBTEST(testNistHahn1());
-  CALL_SUBTEST(testNistMisra1d());
-  CALL_SUBTEST(testNistMGH17());
-  CALL_SUBTEST(testNistLanczos1());
-
-  //     // NIST tests, level of difficulty = "Higher"
-  CALL_SUBTEST(testNistRat42());
-  CALL_SUBTEST(testNistMGH10());
-  CALL_SUBTEST(testNistBoxBOD());
-  //     CALL_SUBTEST(testNistMGH09());
-  CALL_SUBTEST(testNistBennett5());
-  CALL_SUBTEST(testNistThurber());
-  CALL_SUBTEST(testNistRat43());
-  CALL_SUBTEST(testNistEckerle4());
-}
diff --git a/unsupported/test/matrix_exponential.cpp b/unsupported/test/matrix_exponential.cpp
deleted file mode 100644
index 0a52169..0000000
--- a/unsupported/test/matrix_exponential.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "matrix_functions.h"
-
-double binom(int n, int k) {
-  double res = 1;
-  for (int i = 0; i < k; i++) res = res * (n - k + i + 1) / (i + 1);
-  return res;
-}
-
-template <typename T>
-T expfn(T x, int) {
-  return std::exp(x);
-}
-
-template <typename T>
-void test2dRotation(double tol) {
-  Matrix<T, 2, 2> A, B, C;
-  T angle;
-
-  A << 0, 1, -1, 0;
-  for (int i = 0; i <= 20; i++) {
-    angle = static_cast<T>(pow(10, i / 5. - 2));
-    B << std::cos(angle), std::sin(angle), -std::sin(angle), std::cos(angle);
-
-    C = (angle * A).matrixFunction(expfn);
-    std::cout << "test2dRotation: i = " << i << "   error funm = " << relerr(C, B);
-    VERIFY(C.isApprox(B, static_cast<T>(tol)));
-
-    C = (angle * A).exp();
-    std::cout << "   error expm = " << relerr(C, B) << "\n";
-    VERIFY(C.isApprox(B, static_cast<T>(tol)));
-  }
-}
-
-template <typename T>
-void test2dHyperbolicRotation(double tol) {
-  Matrix<std::complex<T>, 2, 2> A, B, C;
-  std::complex<T> imagUnit(0, 1);
-  T angle, ch, sh;
-
-  for (int i = 0; i <= 20; i++) {
-    angle = static_cast<T>((i - 10) / 2.0);
-    ch = std::cosh(angle);
-    sh = std::sinh(angle);
-    A << 0, angle * imagUnit, -angle * imagUnit, 0;
-    B << ch, sh * imagUnit, -sh * imagUnit, ch;
-
-    C = A.matrixFunction(expfn);
-    std::cout << "test2dHyperbolicRotation: i = " << i << "   error funm = " << relerr(C, B);
-    VERIFY(C.isApprox(B, static_cast<T>(tol)));
-
-    C = A.exp();
-    std::cout << "   error expm = " << relerr(C, B) << "\n";
-    VERIFY(C.isApprox(B, static_cast<T>(tol)));
-  }
-}
-
-template <typename T>
-void testPascal(double tol) {
-  for (int size = 1; size < 20; size++) {
-    Matrix<T, Dynamic, Dynamic> A(size, size), B(size, size), C(size, size);
-    A.setZero();
-    for (int i = 0; i < size - 1; i++) A(i + 1, i) = static_cast<T>(i + 1);
-    B.setZero();
-    for (int i = 0; i < size; i++)
-      for (int j = 0; j <= i; j++) B(i, j) = static_cast<T>(binom(i, j));
-
-    C = A.matrixFunction(expfn);
-    std::cout << "testPascal: size = " << size << "   error funm = " << relerr(C, B);
-    VERIFY(C.isApprox(B, static_cast<T>(tol)));
-
-    C = A.exp();
-    std::cout << "   error expm = " << relerr(C, B) << "\n";
-    VERIFY(C.isApprox(B, static_cast<T>(tol)));
-  }
-}
-
-template <typename MatrixType>
-void randomTest(const MatrixType& m, double tol) {
-  /* this test covers the following files:
-     Inverse.h
-  */
-  typename MatrixType::Index rows = m.rows();
-  typename MatrixType::Index cols = m.cols();
-  MatrixType m1(rows, cols), m2(rows, cols), identity = MatrixType::Identity(rows, cols);
-
-  typedef typename NumTraits<typename internal::traits<MatrixType>::Scalar>::Real RealScalar;
-
-  for (int i = 0; i < g_repeat; i++) {
-    m1 = MatrixType::Random(rows, cols);
-
-    m2 = m1.matrixFunction(expfn) * (-m1).matrixFunction(expfn);
-    std::cout << "randomTest: error funm = " << relerr(identity, m2);
-    VERIFY(identity.isApprox(m2, static_cast<RealScalar>(tol)));
-
-    m2 = m1.exp() * (-m1).exp();
-    std::cout << "   error expm = " << relerr(identity, m2) << "\n";
-    VERIFY(identity.isApprox(m2, static_cast<RealScalar>(tol)));
-  }
-}
-
-EIGEN_DECLARE_TEST(matrix_exponential) {
-  CALL_SUBTEST_2(test2dRotation<double>(1e-13));
-  CALL_SUBTEST_1(test2dRotation<float>(2e-5));  // was 1e-5, relaxed for clang 2.8 / linux / x86-64
-  CALL_SUBTEST_8(test2dRotation<long double>(1e-13));
-  CALL_SUBTEST_2(test2dHyperbolicRotation<double>(1e-14));
-  CALL_SUBTEST_1(test2dHyperbolicRotation<float>(1e-5));
-  CALL_SUBTEST_8(test2dHyperbolicRotation<long double>(1e-14));
-  CALL_SUBTEST_6(testPascal<float>(1e-6));
-  CALL_SUBTEST_5(testPascal<double>(1e-15));
-  CALL_SUBTEST_2(randomTest(Matrix2d(), 1e-13));
-  CALL_SUBTEST_7(randomTest(Matrix<double, 3, 3, RowMajor>(), 1e-13));
-  CALL_SUBTEST_3(randomTest(Matrix4cd(), 1e-13));
-  CALL_SUBTEST_4(randomTest(MatrixXd(8, 8), 1e-13));
-  CALL_SUBTEST_1(randomTest(Matrix2f(), 1e-4));
-  CALL_SUBTEST_5(randomTest(Matrix3cf(), 1e-4));
-  CALL_SUBTEST_1(randomTest(Matrix4f(), 1e-4));
-  CALL_SUBTEST_6(randomTest(MatrixXf(8, 8), 1e-4));
-  CALL_SUBTEST_9(randomTest(Matrix<long double, Dynamic, Dynamic>(7, 7), 1e-13));
-}
diff --git a/unsupported/test/matrix_function.cpp b/unsupported/test/matrix_function.cpp
deleted file mode 100644
index 6588527..0000000
--- a/unsupported/test/matrix_function.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/MatrixFunctions>
-
-// Variant of VERIFY_IS_APPROX which uses absolute error instead of
-// relative error.
-#define VERIFY_IS_APPROX_ABS(a, b) VERIFY(test_isApprox_abs(a, b))
-
-template <typename Type1, typename Type2>
-inline bool test_isApprox_abs(const Type1& a, const Type2& b) {
-  return ((a - b).array().abs() < test_precision<typename Type1::RealScalar>()).all();
-}
-
-// Returns a matrix with eigenvalues clustered around 0, 1 and 2.
-template <typename MatrixType>
-MatrixType randomMatrixWithRealEivals(const Index size) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename MatrixType::RealScalar RealScalar;
-  MatrixType diag = MatrixType::Zero(size, size);
-  for (Index i = 0; i < size; ++i) {
-    diag(i, i) =
-        Scalar(RealScalar(internal::random<int>(0, 2))) + internal::random<Scalar>() * Scalar(RealScalar(0.01));
-  }
-  MatrixType A = MatrixType::Random(size, size);
-  HouseholderQR<MatrixType> QRofA(A);
-  return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
-}
-
-template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
-struct randomMatrixWithImagEivals {
-  // Returns a matrix with eigenvalues clustered around 0 and +/- i.
-  static MatrixType run(const Index size);
-};
-
-// Partial specialization for real matrices
-template <typename MatrixType>
-struct randomMatrixWithImagEivals<MatrixType, 0> {
-  static MatrixType run(const Index size) {
-    typedef typename MatrixType::Scalar Scalar;
-    MatrixType diag = MatrixType::Zero(size, size);
-    Index i = 0;
-    while (i < size) {
-      Index randomInt = internal::random<Index>(-1, 1);
-      if (randomInt == 0 || i == size - 1) {
-        diag(i, i) = internal::random<Scalar>() * Scalar(0.01);
-        ++i;
-      } else {
-        Scalar alpha = Scalar(randomInt) + internal::random<Scalar>() * Scalar(0.01);
-        diag(i, i + 1) = alpha;
-        diag(i + 1, i) = -alpha;
-        i += 2;
-      }
-    }
-    MatrixType A = MatrixType::Random(size, size);
-    HouseholderQR<MatrixType> QRofA(A);
-    return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
-  }
-};
-
-// Partial specialization for complex matrices
-template <typename MatrixType>
-struct randomMatrixWithImagEivals<MatrixType, 1> {
-  static MatrixType run(const Index size) {
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename MatrixType::RealScalar RealScalar;
-    const Scalar imagUnit(0, 1);
-    MatrixType diag = MatrixType::Zero(size, size);
-    for (Index i = 0; i < size; ++i) {
-      diag(i, i) = Scalar(RealScalar(internal::random<Index>(-1, 1))) * imagUnit +
-                   internal::random<Scalar>() * Scalar(RealScalar(0.01));
-    }
-    MatrixType A = MatrixType::Random(size, size);
-    HouseholderQR<MatrixType> QRofA(A);
-    return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
-  }
-};
-
-template <typename MatrixType>
-void testMatrixExponential(const MatrixType& A) {
-  typedef typename internal::traits<MatrixType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef std::complex<RealScalar> ComplexScalar;
-
-  VERIFY_IS_APPROX(A.exp(), A.matrixFunction(internal::stem_function_exp<ComplexScalar>));
-}
-
-template <typename MatrixType>
-void testMatrixLogarithm(const MatrixType& A) {
-  typedef typename internal::traits<MatrixType>::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  MatrixType scaledA;
-  RealScalar maxImagPartOfSpectrum = A.eigenvalues().imag().cwiseAbs().maxCoeff();
-  if (maxImagPartOfSpectrum >= RealScalar(0.9L * EIGEN_PI))
-    scaledA = A * RealScalar(0.9L * EIGEN_PI) / maxImagPartOfSpectrum;
-  else
-    scaledA = A;
-
-  // identity X.exp().log() = X only holds if Im(lambda) < pi for all eigenvalues of X
-  MatrixType expA = scaledA.exp();
-  MatrixType logExpA = expA.log();
-  VERIFY_IS_APPROX(logExpA, scaledA);
-}
-
-template <typename MatrixType>
-void testHyperbolicFunctions(const MatrixType& A) {
-  // Need to use absolute error because of possible cancellation when
-  // adding/subtracting expA and expmA.
-  VERIFY_IS_APPROX_ABS(A.sinh(), (A.exp() - (-A).exp()) / 2);
-  VERIFY_IS_APPROX_ABS(A.cosh(), (A.exp() + (-A).exp()) / 2);
-}
-
-template <typename MatrixType>
-void testGonioFunctions(const MatrixType& A) {
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef std::complex<RealScalar> ComplexScalar;
-  typedef Matrix<ComplexScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime, MatrixType::Options>
-      ComplexMatrix;
-
-  ComplexScalar imagUnit(0, 1);
-  ComplexScalar two(2, 0);
-
-  ComplexMatrix Ac = A.template cast<ComplexScalar>();
-
-  ComplexMatrix exp_iA = (imagUnit * Ac).exp();
-  ComplexMatrix exp_miA = (-imagUnit * Ac).exp();
-
-  ComplexMatrix sinAc = A.sin().template cast<ComplexScalar>();
-  VERIFY_IS_APPROX_ABS(sinAc, (exp_iA - exp_miA) / (two * imagUnit));
-
-  ComplexMatrix cosAc = A.cos().template cast<ComplexScalar>();
-  VERIFY_IS_APPROX_ABS(cosAc, (exp_iA + exp_miA) / 2);
-}
-
-template <typename MatrixType>
-void testMatrix(const MatrixType& A) {
-  testMatrixExponential(A);
-  testMatrixLogarithm(A);
-  testHyperbolicFunctions(A);
-  testGonioFunctions(A);
-}
-
-template <typename MatrixType>
-void testMatrixType(const MatrixType& m) {
-  // Matrices with clustered eigenvalue lead to different code paths
-  // in MatrixFunction.h and are thus useful for testing.
-
-  const Index size = m.rows();
-  for (int i = 0; i < g_repeat; i++) {
-    testMatrix(MatrixType::Random(size, size).eval());
-    testMatrix(randomMatrixWithRealEivals<MatrixType>(size));
-    testMatrix(randomMatrixWithImagEivals<MatrixType>::run(size));
-  }
-}
-
-template <typename MatrixType>
-void testMapRef(const MatrixType& A) {
-  // Test if passing Ref and Map objects is possible
-  // (Regression test for Bug #1796)
-  Index size = A.rows();
-  MatrixType X;
-  X.setRandom(size, size);
-  MatrixType Y(size, size);
-  Ref<MatrixType> R(Y);
-  Ref<const MatrixType> Rc(X);
-  Map<MatrixType> M(Y.data(), size, size);
-  Map<const MatrixType> Mc(X.data(), size, size);
-
-  X = X * X;  // make sure sqrt is possible
-  Y = X.sqrt();
-  R = Rc.sqrt();
-  M = Mc.sqrt();
-  Y = X.exp();
-  R = Rc.exp();
-  M = Mc.exp();
-  X = Y;  // make sure log is possible
-  Y = X.log();
-  R = Rc.log();
-  M = Mc.log();
-
-  Y = X.cos() + Rc.cos() + Mc.cos();
-  Y = X.sin() + Rc.sin() + Mc.sin();
-
-  Y = X.cosh() + Rc.cosh() + Mc.cosh();
-  Y = X.sinh() + Rc.sinh() + Mc.sinh();
-}
-
-EIGEN_DECLARE_TEST(matrix_function) {
-  CALL_SUBTEST_1(testMatrixType(Matrix<float, 1, 1>()));
-  CALL_SUBTEST_2(testMatrixType(Matrix3cf()));
-  CALL_SUBTEST_3(testMatrixType(MatrixXf(8, 8)));
-  CALL_SUBTEST_4(testMatrixType(Matrix2d()));
-  CALL_SUBTEST_5(testMatrixType(Matrix<double, 5, 5, RowMajor>()));
-  CALL_SUBTEST_6(testMatrixType(Matrix4cd()));
-  CALL_SUBTEST_7(testMatrixType(MatrixXd(13, 13)));
-
-  CALL_SUBTEST_1(testMapRef(Matrix<float, 1, 1>()));
-  CALL_SUBTEST_2(testMapRef(Matrix3cf()));
-  CALL_SUBTEST_3(testMapRef(MatrixXf(8, 8)));
-  CALL_SUBTEST_7(testMapRef(MatrixXd(13, 13)));
-}
diff --git a/unsupported/test/matrix_functions.h b/unsupported/test/matrix_functions.h
deleted file mode 100644
index cd5b908..0000000
--- a/unsupported/test/matrix_functions.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009-2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/MatrixFunctions>
-
-// For complex matrices, any matrix is fine.
-template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
-struct processTriangularMatrix {
-  static void run(MatrixType&, MatrixType&, const MatrixType&) {}
-};
-
-// For real matrices, make sure none of the eigenvalues are negative.
-template <typename MatrixType>
-struct processTriangularMatrix<MatrixType, 0> {
-  static void run(MatrixType& m, MatrixType& T, const MatrixType& U) {
-    const Index size = m.cols();
-
-    for (Index i = 0; i < size; ++i) {
-      if (i == size - 1 || T.coeff(i + 1, i) == 0)
-        T.coeffRef(i, i) = std::abs(T.coeff(i, i));
-      else
-        ++i;
-    }
-    m = U * T * U.transpose();
-  }
-};
-
-template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex>
-struct generateTestMatrix;
-
-template <typename MatrixType>
-struct generateTestMatrix<MatrixType, 0> {
-  static void run(MatrixType& result, typename MatrixType::Index size) {
-    result = MatrixType::Random(size, size);
-    RealSchur<MatrixType> schur(result);
-    MatrixType T = schur.matrixT();
-    processTriangularMatrix<MatrixType>::run(result, T, schur.matrixU());
-  }
-};
-
-template <typename MatrixType>
-struct generateTestMatrix<MatrixType, 1> {
-  static void run(MatrixType& result, typename MatrixType::Index size) { result = MatrixType::Random(size, size); }
-};
-
-template <typename Derived, typename OtherDerived>
-typename Derived::RealScalar relerr(const MatrixBase<Derived>& A, const MatrixBase<OtherDerived>& B) {
-  return std::sqrt((A - B).cwiseAbs2().sum() / (std::min)(A.cwiseAbs2().sum(), B.cwiseAbs2().sum()));
-}
diff --git a/unsupported/test/matrix_power.cpp b/unsupported/test/matrix_power.cpp
deleted file mode 100644
index 7b449bc..0000000
--- a/unsupported/test/matrix_power.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012, 2013 Chen-Pang He <jdh8@ms63.hinet.net>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "matrix_functions.h"
-
-template <typename T>
-void test2dRotation(const T& tol) {
-  Matrix<T, 2, 2> A, B, C;
-  T angle, c, s;
-
-  A << 0, 1, -1, 0;
-  MatrixPower<Matrix<T, 2, 2> > Apow(A);
-
-  for (int i = 0; i <= 20; ++i) {
-    angle = std::pow(T(10), T(i - 10) / T(5.));
-    c = std::cos(angle);
-    s = std::sin(angle);
-    B << c, s, -s, c;
-
-    C = Apow(std::ldexp(angle, 1) / T(EIGEN_PI));
-    std::cout << "test2dRotation: i = " << i << "   error powerm = " << relerr(C, B) << '\n';
-    VERIFY(C.isApprox(B, tol));
-  }
-}
-
-template <typename T>
-void test2dHyperbolicRotation(const T& tol) {
-  Matrix<std::complex<T>, 2, 2> A, B, C;
-  T angle, ch = std::cosh((T)1);
-  std::complex<T> ish(0, std::sinh((T)1));
-
-  A << ch, ish, -ish, ch;
-  MatrixPower<Matrix<std::complex<T>, 2, 2> > Apow(A);
-
-  for (int i = 0; i <= 20; ++i) {
-    angle = std::ldexp(static_cast<T>(i - 10), -1);
-    ch = std::cosh(angle);
-    ish = std::complex<T>(0, std::sinh(angle));
-    B << ch, ish, -ish, ch;
-
-    C = Apow(angle);
-    std::cout << "test2dHyperbolicRotation: i = " << i << "   error powerm = " << relerr(C, B) << '\n';
-    VERIFY(C.isApprox(B, tol));
-  }
-}
-
-template <typename T>
-void test3dRotation(const T& tol) {
-  Matrix<T, 3, 1> v;
-  T angle;
-
-  for (int i = 0; i <= 20; ++i) {
-    v = Matrix<T, 3, 1>::Random();
-    v.normalize();
-    angle = std::pow(T(10), T(i - 10) / T(5.));
-    VERIFY(AngleAxis<T>(angle, v).matrix().isApprox(AngleAxis<T>(1, v).matrix().pow(angle), tol));
-  }
-}
-
-template <typename MatrixType>
-void testGeneral(const MatrixType& m, const typename MatrixType::RealScalar& tol) {
-  typedef typename MatrixType::RealScalar RealScalar;
-  MatrixType m1, m2, m3, m4, m5;
-  RealScalar x, y;
-
-  for (int i = 0; i < g_repeat; ++i) {
-    generateTestMatrix<MatrixType>::run(m1, m.rows());
-    MatrixPower<MatrixType> mpow(m1);
-
-    x = internal::random<RealScalar>();
-    y = internal::random<RealScalar>();
-    m2 = mpow(x);
-    m3 = mpow(y);
-
-    m4 = mpow(x + y);
-    m5.noalias() = m2 * m3;
-    VERIFY(m4.isApprox(m5, tol));
-
-    m4 = mpow(x * y);
-    m5 = m2.pow(y);
-    VERIFY(m4.isApprox(m5, tol));
-
-    m4 = (std::abs(x) * m1).pow(y);
-    m5 = std::pow(std::abs(x), y) * m3;
-    VERIFY(m4.isApprox(m5, tol));
-  }
-}
-
-template <typename MatrixType>
-void testSingular(const MatrixType& m_const, const typename MatrixType::RealScalar& tol) {
-  // we need to pass by reference in order to prevent errors with
-  // MSVC for aligned data types ...
-  MatrixType& m = const_cast<MatrixType&>(m_const);
-
-  const int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex;
-  typedef std::conditional_t<IsComplex, TriangularView<MatrixType, Upper>, const MatrixType&> TriangularType;
-  std::conditional_t<IsComplex, ComplexSchur<MatrixType>, RealSchur<MatrixType> > schur;
-  MatrixType T;
-
-  for (int i = 0; i < g_repeat; ++i) {
-    m.setRandom();
-    m.col(0).fill(0);
-
-    schur.compute(m);
-    T = schur.matrixT();
-    const MatrixType& U = schur.matrixU();
-    processTriangularMatrix<MatrixType>::run(m, T, U);
-    MatrixPower<MatrixType> mpow(m);
-
-    T = T.sqrt();
-    VERIFY(mpow(0.5L).isApprox(U * (TriangularType(T) * U.adjoint()), tol));
-
-    T = T.sqrt();
-    VERIFY(mpow(0.25L).isApprox(U * (TriangularType(T) * U.adjoint()), tol));
-
-    T = T.sqrt();
-    VERIFY(mpow(0.125L).isApprox(U * (TriangularType(T) * U.adjoint()), tol));
-  }
-}
-
-template <typename MatrixType>
-void testLogThenExp(const MatrixType& m_const, const typename MatrixType::RealScalar& tol) {
-  // we need to pass by reference in order to prevent errors with
-  // MSVC for aligned data types ...
-  MatrixType& m = const_cast<MatrixType&>(m_const);
-
-  typedef typename MatrixType::Scalar Scalar;
-  Scalar x;
-
-  for (int i = 0; i < g_repeat; ++i) {
-    generateTestMatrix<MatrixType>::run(m, m.rows());
-    x = internal::random<Scalar>();
-    VERIFY(m.pow(x).isApprox((x * m.log()).exp(), tol));
-  }
-}
-
-typedef Matrix<double, 3, 3, RowMajor> Matrix3dRowMajor;
-typedef Matrix<long double, 3, 3> Matrix3e;
-typedef Matrix<long double, Dynamic, Dynamic> MatrixXe;
-
-EIGEN_DECLARE_TEST(matrix_power) {
-  CALL_SUBTEST_2(test2dRotation<double>(1e-13));
-  CALL_SUBTEST_1(test2dRotation<float>(2e-5f));  // was 1e-5, relaxed for clang 2.8 / linux / x86-64
-  CALL_SUBTEST_9(test2dRotation<long double>(1e-13L));
-  CALL_SUBTEST_2(test2dHyperbolicRotation<double>(1e-14));
-  CALL_SUBTEST_1(test2dHyperbolicRotation<float>(1e-5f));
-  CALL_SUBTEST_9(test2dHyperbolicRotation<long double>(1e-14L));
-
-  CALL_SUBTEST_10(test3dRotation<double>(2e-13));
-  CALL_SUBTEST_11(test3dRotation<float>(1e-5f));
-  CALL_SUBTEST_12(test3dRotation<long double>(1e-13L));
-
-  CALL_SUBTEST_2(testGeneral(Matrix2d(), 1e-13));
-  CALL_SUBTEST_7(testGeneral(Matrix3dRowMajor(), 1e-13));
-  CALL_SUBTEST_3(testGeneral(Matrix4cd(), 1e-13));
-  CALL_SUBTEST_4(testGeneral(MatrixXd(8, 8), 2e-12));
-  CALL_SUBTEST_1(testGeneral(Matrix2f(), 1e-4f));
-  CALL_SUBTEST_5(testGeneral(Matrix3cf(), 1e-4f));
-  CALL_SUBTEST_8(testGeneral(Matrix4f(), 1e-4f));
-  CALL_SUBTEST_6(testGeneral(MatrixXf(2, 2), 1e-3f));  // see bug 614
-  CALL_SUBTEST_9(testGeneral(MatrixXe(7, 7), 1e-12L));
-  CALL_SUBTEST_10(testGeneral(Matrix3d(), 2e-13));
-  CALL_SUBTEST_11(testGeneral(Matrix3f(), 1e-4f));
-  CALL_SUBTEST_12(testGeneral(Matrix3e(), 1e-13L));
-
-  CALL_SUBTEST_2(testSingular(Matrix2d(), 1e-13));
-  CALL_SUBTEST_7(testSingular(Matrix3dRowMajor(), 1e-13));
-  CALL_SUBTEST_3(testSingular(Matrix4cd(), 1e-13));
-  CALL_SUBTEST_4(testSingular(MatrixXd(8, 8), 2e-12));
-  CALL_SUBTEST_1(testSingular(Matrix2f(), 1e-4f));
-  CALL_SUBTEST_5(testSingular(Matrix3cf(), 1e-4f));
-  CALL_SUBTEST_8(testSingular(Matrix4f(), 1e-4f));
-  CALL_SUBTEST_6(testSingular(MatrixXf(2, 2), 1e-3f));
-  CALL_SUBTEST_9(testSingular(MatrixXe(7, 7), 1e-12L));
-  CALL_SUBTEST_10(testSingular(Matrix3d(), 2e-13));
-  CALL_SUBTEST_11(testSingular(Matrix3f(), 1e-4f));
-  CALL_SUBTEST_12(testSingular(Matrix3e(), 1e-13L));
-
-  CALL_SUBTEST_2(testLogThenExp(Matrix2d(), 1e-13));
-  CALL_SUBTEST_7(testLogThenExp(Matrix3dRowMajor(), 1e-13));
-  CALL_SUBTEST_3(testLogThenExp(Matrix4cd(), 1e-13));
-  CALL_SUBTEST_4(testLogThenExp(MatrixXd(8, 8), 2e-12));
-  CALL_SUBTEST_1(testLogThenExp(Matrix2f(), 1e-4f));
-  CALL_SUBTEST_5(testLogThenExp(Matrix3cf(), 1e-4f));
-  CALL_SUBTEST_8(testLogThenExp(Matrix4f(), 1e-4f));
-  CALL_SUBTEST_6(testLogThenExp(MatrixXf(2, 2), 1e-3f));
-  CALL_SUBTEST_9(testLogThenExp(MatrixXe(7, 7), 1e-12L));
-  CALL_SUBTEST_10(testLogThenExp(Matrix3d(), 2e-13));
-  CALL_SUBTEST_11(testLogThenExp(Matrix3f(), 1e-4f));
-  CALL_SUBTEST_12(testLogThenExp(Matrix3e(), 1e-13L));
-}
diff --git a/unsupported/test/matrix_square_root.cpp b/unsupported/test/matrix_square_root.cpp
deleted file mode 100644
index c7f8fbe..0000000
--- a/unsupported/test/matrix_square_root.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2011 Jitse Niesen <jitse@maths.leeds.ac.uk>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "matrix_functions.h"
-
-template <typename MatrixType>
-void testMatrixSqrt(const MatrixType& m) {
-  MatrixType A;
-  generateTestMatrix<MatrixType>::run(A, m.rows());
-  MatrixType sqrtA = A.sqrt();
-  VERIFY_IS_APPROX(sqrtA * sqrtA, A);
-}
-
-EIGEN_DECLARE_TEST(matrix_square_root) {
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_1(testMatrixSqrt(Matrix3cf()));
-    CALL_SUBTEST_2(testMatrixSqrt(MatrixXcd(12, 12)));
-    CALL_SUBTEST_3(testMatrixSqrt(Matrix4f()));
-    CALL_SUBTEST_4(testMatrixSqrt(Matrix<double, Dynamic, Dynamic, RowMajor>(9, 9)));
-    CALL_SUBTEST_5(testMatrixSqrt(Matrix<float, 1, 1>()));
-    CALL_SUBTEST_5(testMatrixSqrt(Matrix<std::complex<float>, 1, 1>()));
-  }
-}
diff --git a/unsupported/test/minres.cpp b/unsupported/test/minres.cpp
deleted file mode 100644
index dfd5b9a..0000000
--- a/unsupported/test/minres.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2012 Giacomo Po <gpo@ucla.edu>
-// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-#include <cmath>
-
-#include "../../test/sparse_solver.h"
-#include <Eigen/IterativeSolvers>
-
-template <typename T>
-void test_minres_T() {
-  // Identity preconditioner
-  MINRES<SparseMatrix<T>, Lower, IdentityPreconditioner> minres_colmajor_lower_I;
-  MINRES<SparseMatrix<T>, Upper, IdentityPreconditioner> minres_colmajor_upper_I;
-
-  // Diagonal preconditioner
-  MINRES<SparseMatrix<T>, Lower, DiagonalPreconditioner<T> > minres_colmajor_lower_diag;
-  MINRES<SparseMatrix<T>, Upper, DiagonalPreconditioner<T> > minres_colmajor_upper_diag;
-  MINRES<SparseMatrix<T>, Lower | Upper, DiagonalPreconditioner<T> > minres_colmajor_uplo_diag;
-
-  // call tests for SPD matrix
-  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_lower_I));
-  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_upper_I));
-
-  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_lower_diag));
-  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_upper_diag));
-  CALL_SUBTEST(check_sparse_spd_solving(minres_colmajor_uplo_diag));
-
-  // TO DO: symmetric semi-definite matrix
-  // TO DO: symmetric indefinite matrix
-}
-
-EIGEN_DECLARE_TEST(minres) {
-  CALL_SUBTEST_1(test_minres_T<double>());
-  //  CALL_SUBTEST_2(test_minres_T<std::complex<double> >());
-}
diff --git a/unsupported/test/mklfft.cpp b/unsupported/test/mklfft.cpp
deleted file mode 100644
index 631dd20..0000000
--- a/unsupported/test/mklfft.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define EIGEN_MKL_DEFAULT 1
-#include "fft_test_shared.h"
diff --git a/unsupported/test/mpreal_support.cpp b/unsupported/test/mpreal_support.cpp
deleted file mode 100644
index 1598f7f..0000000
--- a/unsupported/test/mpreal_support.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <mpreal.h>  // Must be included before main.h.
-#include "main.h"
-#include <Eigen/MPRealSupport>
-#include <Eigen/LU>
-#include <Eigen/Eigenvalues>
-#include <sstream>
-
-using namespace mpfr;
-using namespace Eigen;
-
-EIGEN_DECLARE_TEST(mpreal_support) {
-  // set precision to 256 bits (double has only 53 bits)
-  mpreal::set_default_prec(256);
-  typedef Matrix<mpreal, Eigen::Dynamic, Eigen::Dynamic> MatrixXmp;
-  typedef Matrix<std::complex<mpreal>, Eigen::Dynamic, Eigen::Dynamic> MatrixXcmp;
-
-  std::cerr << "epsilon =         " << NumTraits<mpreal>::epsilon() << "\n";
-  std::cerr << "dummy_precision = " << NumTraits<mpreal>::dummy_precision() << "\n";
-  std::cerr << "highest =         " << NumTraits<mpreal>::highest() << "\n";
-  std::cerr << "lowest =          " << NumTraits<mpreal>::lowest() << "\n";
-  std::cerr << "digits10 =        " << NumTraits<mpreal>::digits10() << "\n";
-  std::cerr << "max_digits10 =    " << NumTraits<mpreal>::max_digits10() << "\n";
-
-  for (int i = 0; i < g_repeat; i++) {
-    int s = Eigen::internal::random<int>(1, 100);
-    MatrixXmp A = MatrixXmp::Random(s, s);
-    MatrixXmp B = MatrixXmp::Random(s, s);
-    MatrixXmp S = A.adjoint() * A;
-    MatrixXmp X;
-    MatrixXcmp Ac = MatrixXcmp::Random(s, s);
-    MatrixXcmp Bc = MatrixXcmp::Random(s, s);
-    MatrixXcmp Sc = Ac.adjoint() * Ac;
-    MatrixXcmp Xc;
-
-    // Basic stuffs
-    VERIFY_IS_APPROX(A.real(), A);
-    VERIFY(Eigen::internal::isApprox(A.array().abs2().sum(), A.squaredNorm()));
-    VERIFY_IS_APPROX(A.array().exp(), exp(A.array()));
-    VERIFY_IS_APPROX(A.array().abs2().sqrt(), A.array().abs());
-    VERIFY_IS_APPROX(A.array().sin(), sin(A.array()));
-    VERIFY_IS_APPROX(A.array().cos(), cos(A.array()));
-
-    // Cholesky
-    X = S.selfadjointView<Lower>().llt().solve(B);
-    VERIFY_IS_APPROX((S.selfadjointView<Lower>() * X).eval(), B);
-
-    Xc = Sc.selfadjointView<Lower>().llt().solve(Bc);
-    VERIFY_IS_APPROX((Sc.selfadjointView<Lower>() * Xc).eval(), Bc);
-
-    // partial LU
-    X = A.lu().solve(B);
-    VERIFY_IS_APPROX((A * X).eval(), B);
-
-    // symmetric eigenvalues
-    SelfAdjointEigenSolver<MatrixXmp> eig(S);
-    VERIFY_IS_EQUAL(eig.info(), Success);
-    VERIFY(
-        (S.selfadjointView<Lower>() * eig.eigenvectors())
-            .isApprox(eig.eigenvectors() * eig.eigenvalues().asDiagonal(), NumTraits<mpreal>::dummy_precision() * 1e3));
-  }
-
-  {
-    MatrixXmp A(8, 3);
-    A.setRandom();
-    // test output (interesting things happen in this code)
-    std::stringstream stream;
-    stream << A;
-  }
-}
diff --git a/unsupported/test/openglsupport.cpp b/unsupported/test/openglsupport.cpp
deleted file mode 100644
index c70552a..0000000
--- a/unsupported/test/openglsupport.cpp
+++ /dev/null
@@ -1,594 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <main.h>
-#include <iostream>
-#include <string>
-
-#if defined(__APPLE_CC__)
-// Prevent deprecation warnings caused by GLEW on MacOS.
-#define GL_SILENCE_DEPRECATION 1
-#endif
-#include <GL/glew.h>
-#include <Eigen/OpenGLSupport>
-#if defined(__APPLE_CC__)
-#include <GLUT/glut.h>
-#else
-#include <GL/freeglut.h>
-#endif
-
-using namespace Eigen;
-
-#define VERIFY_MATRIX(CODE, REF)                 \
-  {                                              \
-    glMatrixMode(GL_MODELVIEW);                  \
-    glLoadIdentity();                            \
-    CODE;                                        \
-    Matrix<float, 4, 4, ColMajor> m;             \
-    m.setZero();                                 \
-    glGet(GL_MODELVIEW_MATRIX, m);               \
-    if (!(REF).cast<float>().isApprox(m)) {      \
-      std::cerr << "Expected:\n"                 \
-                << ((REF).cast<float>()) << "\n" \
-                << "got\n"                       \
-                << m << "\n\n";                  \
-    }                                            \
-    VERIFY_IS_APPROX((REF).cast<float>(), m);    \
-  }
-
-#define VERIFY_UNIFORM(SUFFIX, NAME, TYPE)                     \
-  {                                                            \
-    TYPE value;                                                \
-    value.setRandom();                                         \
-    TYPE data;                                                 \
-    int loc = glGetUniformLocation(prg_id, #NAME);             \
-    VERIFY((loc != -1) && "uniform not found");                \
-    glUniform(loc, value);                                     \
-    EIGEN_CAT(glGetUniform, SUFFIX)(prg_id, loc, data.data()); \
-    if (!value.isApprox(data)) {                               \
-      std::cerr << "Expected:\n"                               \
-                << value << "\n"                               \
-                << "got\n"                                     \
-                << data << "\n\n";                             \
-    }                                                          \
-    VERIFY_IS_APPROX(value, data);                             \
-  }
-
-#define VERIFY_UNIFORMi(NAME, TYPE)                                        \
-  {                                                                        \
-    TYPE value = TYPE::Random().eval().cast<float>().cast<TYPE::Scalar>(); \
-    TYPE data;                                                             \
-    int loc = glGetUniformLocation(prg_id, #NAME);                         \
-    VERIFY((loc != -1) && "uniform not found");                            \
-    glUniform(loc, value);                                                 \
-    glGetUniformiv(prg_id, loc, (GLint*)data.data());                      \
-    if (!value.isApprox(data)) {                                           \
-      std::cerr << "Expected:\n"                                           \
-                << value << "\n"                                           \
-                << "got\n"                                                 \
-                << data << "\n\n";                                         \
-    }                                                                      \
-    VERIFY_IS_APPROX(value, data);                                         \
-  }
-
-void printProgramInfoLog(GLuint objectID) {
-  int infologLength, charsWritten;
-  GLchar* infoLog;
-  glGetProgramiv(objectID, GL_INFO_LOG_LENGTH, &infologLength);
-  if (infologLength > 0) {
-    infoLog = new GLchar[infologLength];
-    glGetProgramInfoLog(objectID, infologLength, &charsWritten, infoLog);
-    if (charsWritten > 0) std::cerr << "Program info : \n" << infoLog << std::endl;
-    delete[] infoLog;
-  }
-}
-
-void printShaderInfoLog(GLuint objectID) {
-  int infologLength, charsWritten;
-  GLchar* infoLog;
-  glGetShaderiv(objectID, GL_INFO_LOG_LENGTH, &infologLength);
-  if (infologLength > 0) {
-    infoLog = new GLchar[infologLength];
-    glGetShaderInfoLog(objectID, infologLength, &charsWritten, infoLog);
-    if (charsWritten > 0) std::cerr << "Shader info : \n" << infoLog << std::endl;
-    delete[] infoLog;
-  }
-}
-
-GLint createProgram(const char* vtx, const char* frg, bool print_errors = true) {
-  GLint prg_id = glCreateProgram();
-  GLint vtx_id = glCreateShader(GL_VERTEX_SHADER);
-  GLint frg_id = glCreateShader(GL_FRAGMENT_SHADER);
-  GLint ok;
-
-  glShaderSource(vtx_id, 1, &vtx, 0);
-  glCompileShader(vtx_id);
-  glGetShaderiv(vtx_id, GL_COMPILE_STATUS, &ok);
-  if (!ok) {
-    if (print_errors) {
-      std::cerr << "vtx compilation failed\n";
-      std::cerr << "Source:\n" << vtx << "\n";
-      printShaderInfoLog(vtx_id);
-    }
-    glDeleteShader(vtx_id);
-    return GL_ZERO;
-  }
-
-  glShaderSource(frg_id, 1, &frg, 0);
-  glCompileShader(frg_id);
-  glGetShaderiv(frg_id, GL_COMPILE_STATUS, &ok);
-  if (!ok) {
-    if (print_errors) {
-      std::cerr << "frg compilation failed.\n";
-      std::cerr << "Source:\n" << frg << "\n";
-      printShaderInfoLog(frg_id);
-    }
-    glDeleteShader(vtx_id);
-    glDeleteShader(frg_id);
-    return GL_ZERO;
-  }
-
-  glAttachShader(prg_id, vtx_id);
-  glAttachShader(prg_id, frg_id);
-  glLinkProgram(prg_id);
-
-  // Delete shaders once linked.
-  glDeleteShader(vtx_id);
-  glDeleteShader(frg_id);
-  glGetProgramiv(prg_id, GL_LINK_STATUS, &ok);
-  if (!ok) {
-    if (print_errors) {
-      std::cerr << "linking failed.\n";
-      printProgramInfoLog(prg_id);
-    }
-    glDeleteProgram(prg_id);
-    return GL_ZERO;
-  }
-
-  glUseProgram(prg_id);
-  return prg_id;
-}
-
-GLint createProgram(const std::string& vtx, const std::string& frg, bool print_errors = true) {
-  return createProgram(vtx.c_str(), frg.c_str(), print_errors);
-}
-
-std::string getGlslVersionString(int gl_major_version, int gl_minor_version) {
-  switch (gl_major_version) {
-    case 2:
-      switch (gl_minor_version) {
-        case 0:
-          return "#version 110";
-        case 1:
-          return "#version 120";
-      }
-      break;
-    case 3:
-      switch (gl_minor_version) {
-        case 0:
-          return "#version 130";
-        case 1:
-          return "#version 140";
-        case 2:
-          return "#version 150";
-        case 3:
-          return "#version 330";
-      }
-      break;
-    case 4:
-      switch (gl_minor_version) {
-        case 0:
-          return "#version 400";
-        case 1:
-          return "#version 410";
-        case 2:
-          return "#version 420";
-        case 3:
-          return "#version 430";
-        case 4:
-          return "#version 440";
-        case 5:
-          return "#version 450";
-        case 6:
-          return "#version 460";
-      }
-      break;
-  }
-  return "";
-}
-
-void find_and_replace(std::string& str, const std::string& find, const std::string& replace) {
-  size_t loc = 0;
-  size_t flen = find.length();
-  size_t rlen = replace.length();
-  while ((loc = str.find(find, loc)) != std::string::npos) {
-    str.replace(loc, flen, replace);
-    loc += rlen;
-  }
-}
-
-// Finds and replaces a set of substrings in a string.
-std::string format(const std::string& str, const std::vector<std::string>& find,
-                   const std::vector<std::string>& replace) {
-  std::string out = str;
-  for (std::size_t i = 0; i < find.size(); ++i) {
-    find_and_replace(out, find[i], replace[i]);
-  }
-  return out;
-}
-
-// GLUT display function that runs test.  Must be run within the display loop
-// in order to properly destroy resources.
-void openglsupport_test_loop() {
-  // Get context info.
-  const GLubyte* gl_version_string = glGetString(GL_VERSION);
-  std::cerr << "GL version: " << gl_version_string << std::endl;
-  std::cerr << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
-  // Parse version from string since GL_MAJOR_VERSION is only supported in GL 3.0+.
-  // Version string guaranteed to be <major>.<minor><vendor extension>.
-  GLint gl_major_version = gl_version_string[0] - '0';
-  GLint gl_minor_version = gl_version_string[2] - '0';
-  bool legacy_gl = gl_major_version < 3 || (gl_major_version == 3 && gl_minor_version < 2);
-
-  // Fixed-function pipeline removed in OpenGL 3.2.
-  if (legacy_gl) {
-    // Draw a basic triangle.
-    Vector3f v3f;
-    Matrix3f rot;
-    glBegin(GL_POINTS);
-    {
-      glVertex(v3f);
-      glVertex(2 * v3f + v3f);
-      glVertex(rot * v3f);
-    }
-    glEnd();
-
-    // 4x4 matrices
-    Matrix4f mf44;
-    mf44.setRandom();
-    VERIFY_MATRIX(glLoadMatrix(mf44), mf44);
-    VERIFY_MATRIX(glMultMatrix(mf44), mf44);
-    Matrix4d md44;
-    md44.setRandom();
-    VERIFY_MATRIX(glLoadMatrix(md44), md44);
-    VERIFY_MATRIX(glMultMatrix(md44), md44);
-
-    // Quaternion
-    Quaterniond qd(AngleAxisd(internal::random<double>(), Vector3d::Random()));
-    VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
-
-    Quaternionf qf(AngleAxisf(internal::random<double>(), Vector3f::Random()));
-    VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
-
-    // 3D Transform
-    Transform<float, 3, AffineCompact> acf3;
-    acf3.matrix().setRandom();
-    VERIFY_MATRIX(glLoadMatrix(acf3), Projective3f(acf3).matrix());
-    VERIFY_MATRIX(glMultMatrix(acf3), Projective3f(acf3).matrix());
-
-    Transform<float, 3, Affine> af3(acf3);
-    VERIFY_MATRIX(glLoadMatrix(af3), Projective3f(af3).matrix());
-    VERIFY_MATRIX(glMultMatrix(af3), Projective3f(af3).matrix());
-
-    Transform<float, 3, Projective> pf3;
-    pf3.matrix().setRandom();
-    VERIFY_MATRIX(glLoadMatrix(pf3), Projective3f(pf3).matrix());
-    VERIFY_MATRIX(glMultMatrix(pf3), Projective3f(pf3).matrix());
-
-    Transform<double, 3, AffineCompact> acd3;
-    acd3.matrix().setRandom();
-    VERIFY_MATRIX(glLoadMatrix(acd3), Projective3d(acd3).matrix());
-    VERIFY_MATRIX(glMultMatrix(acd3), Projective3d(acd3).matrix());
-
-    Transform<double, 3, Affine> ad3(acd3);
-    VERIFY_MATRIX(glLoadMatrix(ad3), Projective3d(ad3).matrix());
-    VERIFY_MATRIX(glMultMatrix(ad3), Projective3d(ad3).matrix());
-
-    Transform<double, 3, Projective> pd3;
-    pd3.matrix().setRandom();
-    VERIFY_MATRIX(glLoadMatrix(pd3), Projective3d(pd3).matrix());
-    VERIFY_MATRIX(glMultMatrix(pd3), Projective3d(pd3).matrix());
-
-    // translations (2D and 3D)
-    {
-      Vector2f vf2;
-      vf2.setRandom();
-      Vector3f vf23;
-      vf23 << vf2, 0;
-      VERIFY_MATRIX(glTranslate(vf2), Projective3f(Translation3f(vf23)).matrix());
-      Vector2d vd2;
-      vd2.setRandom();
-      Vector3d vd23;
-      vd23 << vd2, 0;
-      VERIFY_MATRIX(glTranslate(vd2), Projective3d(Translation3d(vd23)).matrix());
-
-      Vector3f vf3;
-      vf3.setRandom();
-      VERIFY_MATRIX(glTranslate(vf3), Projective3f(Translation3f(vf3)).matrix());
-      Vector3d vd3;
-      vd3.setRandom();
-      VERIFY_MATRIX(glTranslate(vd3), Projective3d(Translation3d(vd3)).matrix());
-
-      Translation<float, 3> tf3;
-      tf3.vector().setRandom();
-      VERIFY_MATRIX(glTranslate(tf3), Projective3f(tf3).matrix());
-
-      Translation<double, 3> td3;
-      td3.vector().setRandom();
-      VERIFY_MATRIX(glTranslate(td3), Projective3d(td3).matrix());
-    }
-
-    // scaling (2D and 3D)
-    {
-      Vector2f vf2;
-      vf2.setRandom();
-      Vector3f vf23;
-      vf23 << vf2, 1;
-      VERIFY_MATRIX(glScale(vf2), Projective3f(Scaling(vf23)).matrix());
-      Vector2d vd2;
-      vd2.setRandom();
-      Vector3d vd23;
-      vd23 << vd2, 1;
-      VERIFY_MATRIX(glScale(vd2), Projective3d(Scaling(vd23)).matrix());
-
-      Vector3f vf3;
-      vf3.setRandom();
-      VERIFY_MATRIX(glScale(vf3), Projective3f(Scaling(vf3)).matrix());
-      Vector3d vd3;
-      vd3.setRandom();
-      VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
-
-      UniformScaling<float> usf(internal::random<float>());
-      VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
-
-      UniformScaling<double> usd(internal::random<double>());
-      VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
-    }
-  } else {
-    std::cerr << "Warning: fixed-function pipeline was not tested.\n";
-  }
-
-  // Dynamic shader substitution variables.
-  // Modern shaders require a version string, and newer runtimes fail to
-  // compile old GLSL versions. Thus, we dynamically set the GLSL version
-  // string based on runtime. Also, pre OpenGL 3.0, the output gl_FragColor was
-  // built-in. This was deprecated in OpenGL 3.0, requiring us to explicitly
-  // define the output variable.
-  std::vector<std::string> glsl_vars;
-  glsl_vars.push_back("${GLSL_VERSION}");
-  glsl_vars.push_back("${FRAG_OUTPUT_DECLARATION}");
-  glsl_vars.push_back("${FRAG_OUTPUT_VARIABLE}");
-
-  std::vector<std::string> glsl_vals;
-  glsl_vals.push_back(getGlslVersionString(gl_major_version, gl_minor_version));
-  if (gl_major_version >= 3) {
-    glsl_vals.push_back("out vec4 fragColor;");
-    glsl_vals.push_back("fragColor");
-  } else {
-    glsl_vals.push_back("");
-    glsl_vals.push_back("gl_FragColor");
-  }
-
-  // uniform
-  {
-    // vertex shader.
-    std::string vtx = format(
-        "${GLSL_VERSION}\n"
-        "void main(void) {\n"
-        "  gl_Position = vec4(0,0,0,1);\n"
-        "}\n",
-        glsl_vars, glsl_vals);
-
-#ifdef GL_VERSION_2_0
-    if (GLEW_VERSION_2_0 && GL_VERSION_2_0) {
-      std::string frg = format(
-          "${GLSL_VERSION}\n"
-          "uniform vec2 v2f;\n"
-          "uniform vec3 v3f;\n"
-          "uniform vec4 v4f;\n"
-          "uniform ivec2 v2i;\n"
-          "uniform ivec3 v3i;\n"
-          "uniform ivec4 v4i;\n"
-          "uniform mat2 m2f;\n"
-          "uniform mat3 m3f;\n"
-          "uniform mat4 m4f;\n"
-          "${FRAG_OUTPUT_DECLARATION}\n"
-          "void main(void) { \n"
-          "  ${FRAG_OUTPUT_VARIABLE} = "
-          "vec4(v2f[0]+v3f[0]+v4f[0])+vec4(v2i[0]+v3i[0]+v4i[0])+vec4(m2f[0][0]+m3f[0][0]+m4f[0][0]);\n"
-          "}\n",
-          glsl_vars, glsl_vals);
-
-      GLint prg_id = createProgram(vtx, frg);
-      VERIFY(prg_id > 0 && "Failed to create program.");
-      VERIFY_UNIFORM(fv, v2f, Vector2f);
-      VERIFY_UNIFORM(fv, v3f, Vector3f);
-      VERIFY_UNIFORM(fv, v4f, Vector4f);
-      VERIFY_UNIFORMi(v2i, Vector2i);
-      VERIFY_UNIFORMi(v3i, Vector3i);
-      VERIFY_UNIFORMi(v4i, Vector4i);
-      VERIFY_UNIFORM(fv, m2f, Matrix2f);
-      VERIFY_UNIFORM(fv, m3f, Matrix3f);
-      VERIFY_UNIFORM(fv, m4f, Matrix4f);
-      glDeleteProgram(prg_id);
-    } else
-#endif
-      std::cerr << "Warning: opengl 2.0 was not tested.\n";
-
-#ifdef GL_VERSION_2_1
-    if (GLEW_VERSION_2_1 && GL_VERSION_2_1 &&
-        (gl_major_version > 2 || (gl_major_version == 2 && gl_minor_version >= 1))) {
-      std::string frg = format(
-          "${GLSL_VERSION}\n"
-          "uniform mat2x3 m23f;\n"
-          "uniform mat3x2 m32f;\n"
-          "uniform mat2x4 m24f;\n"
-          "uniform mat4x2 m42f;\n"
-          "uniform mat3x4 m34f;\n"
-          "uniform mat4x3 m43f;\n"
-          "${FRAG_OUTPUT_DECLARATION}\n"
-          "void main(void) {\n"
-          "  ${FRAG_OUTPUT_VARIABLE} = vec4(m23f[0][0]+m32f[0][0]+m24f[0][0]+m42f[0][0]+m34f[0][0]+m43f[0][0]);\n"
-          "}\n",
-          glsl_vars, glsl_vals);
-
-      GLint prg_id = createProgram(vtx, frg);
-      VERIFY(prg_id > 0 && "Failed to create program.");
-      typedef Matrix<float, 2, 3> Matrix23f;
-      typedef Matrix<float, 3, 2> Matrix32f;
-      typedef Matrix<float, 2, 4> Matrix24f;
-      typedef Matrix<float, 4, 2> Matrix42f;
-      typedef Matrix<float, 3, 4> Matrix34f;
-      typedef Matrix<float, 4, 3> Matrix43f;
-
-      VERIFY_UNIFORM(fv, m23f, Matrix23f);
-      VERIFY_UNIFORM(fv, m32f, Matrix32f);
-      VERIFY_UNIFORM(fv, m24f, Matrix24f);
-      VERIFY_UNIFORM(fv, m42f, Matrix42f);
-      VERIFY_UNIFORM(fv, m34f, Matrix34f);
-      VERIFY_UNIFORM(fv, m43f, Matrix43f);
-      glDeleteProgram(prg_id);
-    } else
-#endif
-      std::cerr << "Warning: opengl 2.1 was not tested.\n";
-
-#ifdef GL_VERSION_3_0
-    if (GLEW_VERSION_3_0 && GL_VERSION_3_0 && gl_major_version >= 3) {
-      std::string frg = format(
-          "${GLSL_VERSION}\n"
-          "uniform uvec2 v2ui;\n"
-          "uniform uvec3 v3ui;\n"
-          "uniform uvec4 v4ui;\n"
-          "${FRAG_OUTPUT_DECLARATION}\n"
-          "void main(void) {\n"
-          "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2ui[0]+v3ui[0]+v4ui[0]);\n"
-          "}\n",
-          glsl_vars, glsl_vals);
-
-      GLint prg_id = createProgram(vtx, frg);
-      VERIFY(prg_id > 0 && "Failed to create program.");
-      typedef Matrix<unsigned int, 2, 1> Vector2ui;
-      typedef Matrix<unsigned int, 3, 1> Vector3ui;
-      typedef Matrix<unsigned int, 4, 1> Vector4ui;
-
-      VERIFY_UNIFORMi(v2ui, Vector2ui);
-      VERIFY_UNIFORMi(v3ui, Vector3ui);
-      VERIFY_UNIFORMi(v4ui, Vector4ui);
-      glDeleteProgram(prg_id);
-    } else
-#endif
-      std::cerr << "Warning: opengl 3.0 was not tested.\n";
-
-    // dvecn supported if >= 4.1 or ARB_vertex_attrib_64bit
-    bool has_fp64_native = (gl_major_version == 4 && gl_minor_version >= 1);
-    bool has_fp64_extension = false;
-#ifdef GLEW_ARB_gpu_shader_fp64
-    if (GLEW_ARB_gpu_shader_fp64) {
-      // Check that extension can actually be compiled.
-      if (has_fp64_extension) {
-        std::string frg = format(
-            "${GLSL_VERSION}\n"
-            "#extension GL_ARB_gpu_shader_fp64 : enable\n"
-            "uniform dvec2 dv2;\n"
-            "${FRAG_OUTPUT_DECLARATION}\n"
-            "void main(void) {\n"
-            "  ${FRAG_OUTPUT_VARIABLE} = vec4(dv2.x, dv2.y, dv2.x, dv2.y);\n"
-            "}\n",
-            glsl_vars, glsl_vals);
-        GLint prg_id = createProgram(vtx, frg, /*print_errors=*/false);
-        if (prg_id) {
-          has_fp64_extension = true;
-          glDeleteProgram(prg_id);
-        }
-      }
-    }
-#endif
-
-    if (has_fp64_native || has_fp64_extension) {
-      std::vector<std::string> glsl_vars_with_extension = glsl_vars;
-      glsl_vars_with_extension.push_back("${GLSL_EXTENSIONS}");
-      std::vector<std::string> glsl_vals_with_extension = glsl_vals;
-      if (has_fp64_extension) {
-        glsl_vals_with_extension.push_back("#extension GL_ARB_gpu_shader_fp64 : enable");
-      } else {
-        glsl_vals_with_extension.push_back("");
-      }
-
-      std::string frg = format(
-          "${GLSL_VERSION}\n"
-          "${GLSL_EXTENSIONS}\n"
-          "uniform dvec2 v2d;\n"
-          "uniform dvec3 v3d;\n"
-          "uniform dvec4 v4d;\n"
-          "${FRAG_OUTPUT_DECLARATION}\n"
-          "void main(void) {\n"
-          "  ${FRAG_OUTPUT_VARIABLE} = vec4(v2d[0]+v3d[0]+v4d[0]);\n"
-          "}\n",
-          glsl_vars_with_extension, glsl_vals_with_extension);
-
-      GLint prg_id = createProgram(vtx, frg);
-      VERIFY(prg_id > 0 && "Failed to create program.");
-      VERIFY_UNIFORM(dv, v2d, Vector2d);
-      VERIFY_UNIFORM(dv, v3d, Vector3d);
-      VERIFY_UNIFORM(dv, v4d, Vector4d);
-      glDeleteProgram(prg_id);
-    } else
-      std::cerr << "Warning: dvec (fp64) was not tested.\n";
-  }
-
-  // Exit loop - Leaving main loop is supported by freeglut, otherwise we
-  // are forced to exit.
-#ifdef FREEGLUT
-  glutLeaveMainLoop();
-  // Trigger another display loop iteration. Otherwise, it just hangs.
-  glutPostRedisplay();
-#else
-  exit(0);
-#endif
-}
-
-EIGEN_DECLARE_TEST(openglsupport) {
-  int argc = 0;
-  glutInit(&argc, 0);
-
-  GLint glut_display_mode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH;
-
-#ifndef EIGEN_LEGACY_OPENGL
-  // Initialize 3.2+ OpenGL context.
-#if defined(__APPLE_CC__)
-  glut_display_mode |= GLUT_3_2_CORE_PROFILE;
-#elif defined(FREEGLUT)
-  glutInitContextVersion(3, 2);
-  glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
-  glutInitContextProfile(GLUT_CORE_PROFILE);
-#endif
-#endif
-
-  glutInitDisplayMode(glut_display_mode);
-  glutInitWindowPosition(0, 0);
-  glutInitWindowSize(10, 10);
-
-  int window = glutCreateWindow("Eigen");
-  if (window <= 0) {
-    std::cerr << "Error: Unable to create GLUT Window.\n";
-    exit(1);
-  }
-
-  glewExperimental = GL_TRUE;
-  if (glewInit() != GLEW_OK) {
-    std::cerr << "Warning: Failed to initialize GLEW.\n";
-    exit(1);
-  }
-
-  // Run test in display, otherwise GLUT fails to clean up and leads to memory
-  // access errors on exit.
-  glutDisplayFunc(openglsupport_test_loop);
-  glutMainLoop();
-  glutDestroyWindow(window);
-}
diff --git a/unsupported/test/pocketfft.cpp b/unsupported/test/pocketfft.cpp
deleted file mode 100644
index 5e8a0b6..0000000
--- a/unsupported/test/pocketfft.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define EIGEN_POCKETFFT_DEFAULT 1
-#include "fft_test_shared.h"
diff --git a/unsupported/test/polynomialsolver.cpp b/unsupported/test/polynomialsolver.cpp
deleted file mode 100644
index 18d5a2e..0000000
--- a/unsupported/test/polynomialsolver.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/Polynomials>
-#include <iostream>
-#include <algorithm>
-
-using namespace std;
-
-namespace Eigen {
-namespace internal {
-template <int Size>
-struct increment_if_fixed_size {
-  enum { ret = (Size == Dynamic) ? Dynamic : Size + 1 };
-};
-}  // namespace internal
-}  // namespace Eigen
-
-template <typename PolynomialType>
-PolynomialType polyder(const PolynomialType& p) {
-  typedef typename PolynomialType::Scalar Scalar;
-  PolynomialType res(p.size());
-  for (Index i = 1; i < p.size(); ++i) res[i - 1] = p[i] * Scalar(i);
-  res[p.size() - 1] = 0.;
-  return res;
-}
-
-template <int Deg, typename POLYNOMIAL, typename SOLVER>
-bool aux_evalSolver(const POLYNOMIAL& pols, SOLVER& psolve) {
-  typedef typename POLYNOMIAL::Scalar Scalar;
-  typedef typename POLYNOMIAL::RealScalar RealScalar;
-
-  typedef typename SOLVER::RootsType RootsType;
-  typedef Matrix<RealScalar, Deg, 1> EvalRootsType;
-
-  const Index deg = pols.size() - 1;
-
-  // Test template constructor from coefficient vector
-  SOLVER solve_constr(pols);
-
-  psolve.compute(pols);
-  const RootsType& roots(psolve.roots());
-  EvalRootsType evr(deg);
-  POLYNOMIAL pols_der = polyder(pols);
-  EvalRootsType der(deg);
-  for (int i = 0; i < roots.size(); ++i) {
-    evr[i] = std::abs(poly_eval(pols, roots[i]));
-    der[i] = numext::maxi(RealScalar(1.), std::abs(poly_eval(pols_der, roots[i])));
-  }
-
-  // we need to divide by the magnitude of the derivative because
-  // with a high derivative is very small error in the value of the root
-  // yiels a very large error in the polynomial evaluation.
-  bool evalToZero = (evr.cwiseQuotient(der)).isZero(test_precision<Scalar>());
-  if (!evalToZero) {
-    cerr << "WRONG root: " << endl;
-    cerr << "Polynomial: " << pols.transpose() << endl;
-    cerr << "Roots found: " << roots.transpose() << endl;
-    cerr << "Abs value of the polynomial at the roots: " << evr.transpose() << endl;
-    cerr << endl;
-  }
-
-  std::vector<RealScalar> rootModuli(roots.size());
-  Map<EvalRootsType> aux(&rootModuli[0], roots.size());
-  aux = roots.array().abs();
-  std::sort(rootModuli.begin(), rootModuli.end());
-  bool distinctModuli = true;
-  for (size_t i = 1; i < rootModuli.size() && distinctModuli; ++i) {
-    if (internal::isApprox(rootModuli[i], rootModuli[i - 1])) {
-      distinctModuli = false;
-    }
-  }
-  VERIFY(evalToZero || !distinctModuli);
-
-  return distinctModuli;
-}
-
-template <int Deg, typename POLYNOMIAL>
-void evalSolver(const POLYNOMIAL& pols) {
-  typedef typename POLYNOMIAL::Scalar Scalar;
-
-  typedef PolynomialSolver<Scalar, Deg> PolynomialSolverType;
-
-  PolynomialSolverType psolve;
-  aux_evalSolver<Deg, POLYNOMIAL, PolynomialSolverType>(pols, psolve);
-}
-
-template <int Deg, typename POLYNOMIAL, typename ROOTS, typename REAL_ROOTS>
-void evalSolverSugarFunction(const POLYNOMIAL& pols, const ROOTS& roots, const REAL_ROOTS& real_roots) {
-  using std::sqrt;
-  typedef typename POLYNOMIAL::Scalar Scalar;
-  typedef typename POLYNOMIAL::RealScalar RealScalar;
-
-  typedef PolynomialSolver<Scalar, Deg> PolynomialSolverType;
-
-  PolynomialSolverType psolve;
-  if (aux_evalSolver<Deg, POLYNOMIAL, PolynomialSolverType>(pols, psolve)) {
-    // It is supposed that
-    //  1) the roots found are correct
-    //  2) the roots have distinct moduli
-
-    // Test realRoots
-    std::vector<RealScalar> calc_realRoots;
-    psolve.realRoots(calc_realRoots, test_precision<RealScalar>());
-    VERIFY_IS_EQUAL(calc_realRoots.size(), (size_t)real_roots.size());
-
-    const RealScalar psPrec = sqrt(test_precision<RealScalar>());
-
-    for (size_t i = 0; i < calc_realRoots.size(); ++i) {
-      bool found = false;
-      for (Index j = 0; j < real_roots.size() && !found; ++j) {
-        if (internal::isApprox(calc_realRoots[i], real_roots[j], psPrec)) {
-          found = true;
-        }
-      }
-      VERIFY(found);
-    }
-
-    // Test greatestRoot
-    VERIFY(internal::isApprox(roots.array().abs().maxCoeff(), abs(psolve.greatestRoot()), psPrec));
-
-    // Test smallestRoot
-    VERIFY(internal::isApprox(roots.array().abs().minCoeff(), abs(psolve.smallestRoot()), psPrec));
-
-    bool hasRealRoot;
-    // Test absGreatestRealRoot
-    RealScalar r = psolve.absGreatestRealRoot(hasRealRoot, test_precision<RealScalar>());
-    VERIFY(hasRealRoot == (real_roots.size() > 0));
-    if (hasRealRoot) {
-      VERIFY(internal::isApprox(real_roots.array().abs().maxCoeff(), abs(r), psPrec));
-    }
-
-    // Test absSmallestRealRoot
-    r = psolve.absSmallestRealRoot(hasRealRoot, test_precision<RealScalar>());
-    VERIFY(hasRealRoot == (real_roots.size() > 0));
-    if (hasRealRoot) {
-      VERIFY(internal::isApprox(real_roots.array().abs().minCoeff(), abs(r), psPrec));
-    }
-
-    // Test greatestRealRoot
-    r = psolve.greatestRealRoot(hasRealRoot, test_precision<RealScalar>());
-    VERIFY(hasRealRoot == (real_roots.size() > 0));
-    if (hasRealRoot) {
-      VERIFY(internal::isApprox(real_roots.array().maxCoeff(), r, psPrec));
-    }
-
-    // Test smallestRealRoot
-    r = psolve.smallestRealRoot(hasRealRoot, test_precision<RealScalar>());
-    VERIFY(hasRealRoot == (real_roots.size() > 0));
-    if (hasRealRoot) {
-      VERIFY(internal::isApprox(real_roots.array().minCoeff(), r, psPrec));
-    }
-  }
-}
-
-template <typename Scalar_, int Deg_>
-void polynomialsolver(int deg) {
-  typedef typename NumTraits<Scalar_>::Real RealScalar;
-  typedef internal::increment_if_fixed_size<Deg_> Dim;
-  typedef Matrix<Scalar_, Dim::ret, 1> PolynomialType;
-  typedef Matrix<Scalar_, Deg_, 1> EvalRootsType;
-  typedef Matrix<RealScalar, Deg_, 1> RealRootsType;
-
-  cout << "Standard cases" << endl;
-  PolynomialType pols = PolynomialType::Random(deg + 1);
-  evalSolver<Deg_, PolynomialType>(pols);
-
-  cout << "Hard cases" << endl;
-  Scalar_ multipleRoot = internal::random<Scalar_>();
-  EvalRootsType allRoots = EvalRootsType::Constant(deg, multipleRoot);
-  roots_to_monicPolynomial(allRoots, pols);
-  evalSolver<Deg_, PolynomialType>(pols);
-
-  // The companion matrix eigenvalue approach has limited accuracy for float at
-  // high degrees. The PolynomialSolver documentation itself warns: "With 32bit
-  // (float) floating types this problem shows up frequently." Skip the sugar
-  // function test (which requires exact root matching) for float beyond degree 8.
-  if (deg <= 8 || sizeof(RealScalar) > sizeof(float)) {
-    cout << "Test sugar" << endl;
-    RealRootsType realRoots = RealRootsType::Random(deg);
-    // sort by ascending absolute value to mitigate precision lost during polynomial expansion
-    std::sort(realRoots.begin(), realRoots.end(),
-              [](RealScalar a, RealScalar b) { return numext::abs(a) < numext::abs(b); });
-    roots_to_monicPolynomial(realRoots, pols);
-    evalSolverSugarFunction<Deg_>(pols, realRoots.template cast<std::complex<RealScalar> >().eval(), realRoots);
-  }
-}
-
-EIGEN_DECLARE_TEST(polynomialsolver) {
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_1((polynomialsolver<float, 1>(1)));
-    CALL_SUBTEST_2((polynomialsolver<double, 2>(2)));
-    CALL_SUBTEST_3((polynomialsolver<double, 3>(3)));
-    CALL_SUBTEST_4((polynomialsolver<float, 4>(4)));
-    CALL_SUBTEST_5((polynomialsolver<double, 5>(5)));
-    CALL_SUBTEST_6((polynomialsolver<float, 6>(6)));
-    CALL_SUBTEST_7((polynomialsolver<float, 7>(7)));
-    CALL_SUBTEST_8((polynomialsolver<double, 8>(8)));
-
-    CALL_SUBTEST_9((polynomialsolver<float, Dynamic>(internal::random<int>(9, 13))));
-    CALL_SUBTEST_10((polynomialsolver<double, Dynamic>(internal::random<int>(9, 13))));
-    CALL_SUBTEST_11((polynomialsolver<float, Dynamic>(1)));
-    CALL_SUBTEST_12((polynomialsolver<std::complex<double>, Dynamic>(internal::random<int>(2, 13))));
-  }
-}
diff --git a/unsupported/test/polynomialutils.cpp b/unsupported/test/polynomialutils.cpp
deleted file mode 100644
index f57c874..0000000
--- a/unsupported/test/polynomialutils.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Manuel Yguel <manuel.yguel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-#include <unsupported/Eigen/Polynomials>
-#include <iostream>
-
-using namespace std;
-
-namespace Eigen {
-namespace internal {
-template <int Size>
-struct increment_if_fixed_size {
-  enum { ret = (Size == Dynamic) ? Dynamic : Size + 1 };
-};
-}  // namespace internal
-}  // namespace Eigen
-
-template <typename Scalar_, int Deg_>
-void realRoots_to_monicPolynomial_test(int deg) {
-  typedef internal::increment_if_fixed_size<Deg_> Dim;
-  typedef Matrix<Scalar_, Dim::ret, 1> PolynomialType;
-  typedef Matrix<Scalar_, Deg_, 1> EvalRootsType;
-
-  PolynomialType pols(deg + 1);
-  EvalRootsType roots = EvalRootsType::Random(deg);
-  roots_to_monicPolynomial(roots, pols);
-
-  EvalRootsType evr(deg);
-  for (int i = 0; i < roots.size(); ++i) {
-    evr[i] = std::abs(poly_eval(pols, roots[i]));
-  }
-
-  bool evalToZero = evr.isZero(test_precision<Scalar_>());
-  if (!evalToZero) {
-    cerr << evr.transpose() << endl;
-  }
-  VERIFY(evalToZero);
-}
-
-template <typename Scalar_>
-void realRoots_to_monicPolynomial_scalar() {
-  CALL_SUBTEST_2((realRoots_to_monicPolynomial_test<Scalar_, 2>(2)));
-  CALL_SUBTEST_3((realRoots_to_monicPolynomial_test<Scalar_, 3>(3)));
-  CALL_SUBTEST_4((realRoots_to_monicPolynomial_test<Scalar_, 4>(4)));
-  CALL_SUBTEST_5((realRoots_to_monicPolynomial_test<Scalar_, 5>(5)));
-  CALL_SUBTEST_6((realRoots_to_monicPolynomial_test<Scalar_, 6>(6)));
-  CALL_SUBTEST_7((realRoots_to_monicPolynomial_test<Scalar_, 7>(7)));
-  CALL_SUBTEST_8((realRoots_to_monicPolynomial_test<Scalar_, 17>(17)));
-
-  CALL_SUBTEST_9((realRoots_to_monicPolynomial_test<Scalar_, Dynamic>(internal::random<int>(18, 26))));
-}
-
-template <typename Scalar_, int Deg_>
-void CauchyBounds(int deg) {
-  typedef internal::increment_if_fixed_size<Deg_> Dim;
-  typedef Matrix<Scalar_, Dim::ret, 1> PolynomialType;
-  typedef Matrix<Scalar_, Deg_, 1> EvalRootsType;
-
-  PolynomialType pols(deg + 1);
-  EvalRootsType roots = EvalRootsType::Random(deg);
-  roots_to_monicPolynomial(roots, pols);
-  Scalar_ M = cauchy_max_bound(pols);
-  Scalar_ m = cauchy_min_bound(pols);
-  Scalar_ Max = roots.array().abs().maxCoeff();
-  Scalar_ min = roots.array().abs().minCoeff();
-  bool eval = (M >= Max) && (m <= min);
-  if (!eval) {
-    cerr << "Roots: " << roots << endl;
-    cerr << "Bounds: (" << m << ", " << M << ")" << endl;
-    cerr << "Min,Max: (" << min << ", " << Max << ")" << endl;
-  }
-  VERIFY(eval);
-}
-
-template <typename Scalar_>
-void CauchyBounds_scalar() {
-  CALL_SUBTEST_2((CauchyBounds<Scalar_, 2>(2)));
-  CALL_SUBTEST_3((CauchyBounds<Scalar_, 3>(3)));
-  CALL_SUBTEST_4((CauchyBounds<Scalar_, 4>(4)));
-  CALL_SUBTEST_5((CauchyBounds<Scalar_, 5>(5)));
-  CALL_SUBTEST_6((CauchyBounds<Scalar_, 6>(6)));
-  CALL_SUBTEST_7((CauchyBounds<Scalar_, 7>(7)));
-  CALL_SUBTEST_8((CauchyBounds<Scalar_, 17>(17)));
-
-  CALL_SUBTEST_9((CauchyBounds<Scalar_, Dynamic>(internal::random<int>(18, 26))));
-}
-
-EIGEN_DECLARE_TEST(polynomialutils) {
-  for (int i = 0; i < g_repeat; i++) {
-    realRoots_to_monicPolynomial_scalar<double>();
-    realRoots_to_monicPolynomial_scalar<float>();
-    CauchyBounds_scalar<double>();
-    CauchyBounds_scalar<float>();
-  }
-}
diff --git a/unsupported/test/sparse_extra.cpp b/unsupported/test/sparse_extra.cpp
deleted file mode 100644
index 4bf5452..0000000
--- a/unsupported/test/sparse_extra.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2010 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <cstdlib>
-#include <string>
-
-#include "sparse.h"
-
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-#include <Eigen/SparseExtra>
-
-// Read from an environment variable TEST_TMPDIR, if available,
-// and append the provided filename. Defaults to local directory.
-std::string GetTestTempFilename(const char* filename) {
-  const char* test_tmpdir = std::getenv("TEST_TMPDIR");
-  if (test_tmpdir == nullptr) {
-    return std::string(filename);
-  }
-  return std::string(test_tmpdir) + std::string("/") + std::string(filename);
-}
-
-template <typename SetterType, typename DenseType, typename Scalar, int Options>
-bool test_random_setter(SparseMatrix<Scalar, Options>& sm, const DenseType& ref,
-                        const std::vector<Vector2i>& nonzeroCoords) {
-  {
-    sm.setZero();
-    SetterType w(sm);
-    std::vector<Vector2i> remaining = nonzeroCoords;
-    while (!remaining.empty()) {
-      int i = internal::random<int>(0, static_cast<int>(remaining.size()) - 1);
-      w(remaining[i].x(), remaining[i].y()) = ref.coeff(remaining[i].x(), remaining[i].y());
-      remaining[i] = remaining.back();
-      remaining.pop_back();
-    }
-  }
-  return sm.isApprox(ref);
-}
-
-template <typename SparseMatrixType>
-void sparse_extra(const SparseMatrixType& ref) {
-  const Index rows = ref.rows();
-  const Index cols = ref.cols();
-  typedef typename SparseMatrixType::Scalar Scalar;
-  enum { Flags = SparseMatrixType::Flags };
-
-  double density = (std::max)(8. / (rows * cols), 0.01);
-  typedef Matrix<Scalar, Dynamic, Dynamic> DenseMatrix;
-  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
-  Scalar eps = 1e-6;
-
-  SparseMatrixType m(rows, cols);
-  DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
-  DenseVector vec1 = DenseVector::Random(rows);
-
-  std::vector<Vector2i> zeroCoords;
-  std::vector<Vector2i> nonzeroCoords;
-  initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
-
-  if (zeroCoords.size() == 0 || nonzeroCoords.size() == 0) return;
-
-  // test coeff and coeffRef
-  for (int i = 0; i < (int)zeroCoords.size(); ++i) {
-    VERIFY_IS_MUCH_SMALLER_THAN(m.coeff(zeroCoords[i].x(), zeroCoords[i].y()), eps);
-    if (internal::is_same<SparseMatrixType, SparseMatrix<Scalar, Flags> >::value)
-      VERIFY_RAISES_ASSERT(m.coeffRef(zeroCoords[0].x(), zeroCoords[0].y()) = 5);
-  }
-  VERIFY_IS_APPROX(m, refMat);
-
-  m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
-  refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
-
-  VERIFY_IS_APPROX(m, refMat);
-
-  // random setter
-  //   {
-  //     m.setZero();
-  //     VERIFY_IS_NOT_APPROX(m, refMat);
-  //     SparseSetter<SparseMatrixType, RandomAccessPattern> w(m);
-  //     std::vector<Vector2i> remaining = nonzeroCoords;
-  //     while(!remaining.empty())
-  //     {
-  //       int i = internal::random<int>(0,remaining.size()-1);
-  //       w->coeffRef(remaining[i].x(),remaining[i].y()) = refMat.coeff(remaining[i].x(),remaining[i].y());
-  //       remaining[i] = remaining.back();
-  //       remaining.pop_back();
-  //     }
-  //   }
-  //   VERIFY_IS_APPROX(m, refMat);
-
-  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, StdMapTraits> >(m, refMat, nonzeroCoords)));
-  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, StdUnorderedMapTraits> >(m, refMat, nonzeroCoords)));
-#ifdef EIGEN_GOOGLEHASH_SUPPORT
-  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, GoogleDenseHashMapTraits> >(m, refMat, nonzeroCoords)));
-  VERIFY((test_random_setter<RandomSetter<SparseMatrixType, GoogleSparseHashMapTraits> >(m, refMat, nonzeroCoords)));
-#endif
-
-  // test RandomSetter
-  /*{
-    SparseMatrixType m1(rows,cols), m2(rows,cols);
-    DenseMatrix refM1 = DenseMatrix::Zero(rows, rows);
-    initSparse<Scalar>(density, refM1, m1);
-    {
-      Eigen::RandomSetter<SparseMatrixType > setter(m2);
-      for (int j=0; j<m1.outerSize(); ++j)
-        for (typename SparseMatrixType::InnerIterator i(m1,j); i; ++i)
-          setter(i.index(), j) = i.value();
-    }
-    VERIFY_IS_APPROX(m1, m2);
-  }*/
-}
-
-template <typename SparseMatrixType>
-void check_marketio() {
-  typedef Matrix<typename SparseMatrixType::Scalar, Dynamic, Dynamic> DenseMatrix;
-  Index rows = internal::random<Index>(1, 100);
-  Index cols = internal::random<Index>(1, 100);
-  SparseMatrixType m1, m2;
-  m1 = DenseMatrix::Random(rows, cols).sparseView();
-  std::string filename = GetTestTempFilename("sparse_extra.mtx");
-  saveMarket(m1, filename);
-  loadMarket(m2, filename);
-  VERIFY_IS_EQUAL(DenseMatrix(m1), DenseMatrix(m2));
-}
-
-template <typename VectorType>
-void check_marketio_vector() {
-  Index size = internal::random<Index>(1, 100);
-  VectorType v1, v2;
-  v1 = VectorType::Random(size);
-  std::string filename = GetTestTempFilename("vector_extra.mtx");
-  saveMarketVector(v1, filename);
-  loadMarketVector(v2, filename);
-  VERIFY_IS_EQUAL(v1, v2);
-}
-
-template <typename DenseMatrixType>
-void check_marketio_dense() {
-  Index rows = DenseMatrixType::MaxRowsAtCompileTime;
-  if (DenseMatrixType::MaxRowsAtCompileTime == Dynamic) {
-    rows = internal::random<Index>(1, 100);
-  } else if (DenseMatrixType::RowsAtCompileTime == Dynamic) {
-    rows = internal::random<Index>(1, DenseMatrixType::MaxRowsAtCompileTime);
-  }
-
-  Index cols = DenseMatrixType::MaxColsAtCompileTime;
-  if (DenseMatrixType::MaxColsAtCompileTime == Dynamic) {
-    cols = internal::random<Index>(1, 100);
-  } else if (DenseMatrixType::ColsAtCompileTime == Dynamic) {
-    cols = internal::random<Index>(1, DenseMatrixType::MaxColsAtCompileTime);
-  }
-
-  DenseMatrixType m1, m2;
-  m1 = DenseMatrixType::Random(rows, cols);
-  std::string filename = GetTestTempFilename("dense_extra.mtx");
-  saveMarketDense(m1, filename);
-  loadMarketDense(m2, filename);
-  VERIFY_IS_EQUAL(m1, m2);
-}
-
-template <typename Scalar>
-void check_sparse_inverse() {
-  typedef SparseMatrix<Scalar> MatrixType;
-
-  Matrix<Scalar, -1, -1> A;
-  A.resize(1000, 1000);
-  A.fill(0);
-  A.setIdentity();
-  A.col(0).array() += 1;
-  A.row(0).array() += 2;
-  A.col(2).array() += 3;
-  A.row(7).array() += 3;
-  A.col(9).array() += 3;
-  A.block(3, 4, 4, 2).array() += 9;
-  A.middleRows(10, 50).array() += 3;
-  A.middleCols(50, 50).array() += 40;
-  A.block(500, 300, 40, 20).array() += 10;
-  A.transposeInPlace();
-
-  Eigen::SparseLU<MatrixType> slu;
-  slu.compute(A.sparseView());
-  Matrix<Scalar, -1, -1> Id(A.rows(), A.cols());
-  Id.setIdentity();
-  Matrix<Scalar, -1, -1> inv = slu.solve(Id);
-
-  const MatrixType sparseInv = Eigen::SparseInverse<Scalar>().compute(A.sparseView()).inverse();
-
-  Scalar sumdiff = 0;  // Check the diff only of the non-zero elements
-  for (Eigen::Index j = 0; j < A.cols(); j++) {
-    for (typename MatrixType::InnerIterator iter(sparseInv, j); iter; ++iter) {
-      const Scalar diff = std::abs(inv(iter.row(), iter.col()) - iter.value());
-      VERIFY_IS_APPROX_OR_LESS_THAN(diff, 1e-11);
-
-      if (iter.value() != 0) {
-        sumdiff += diff;
-      }
-    }
-  }
-
-  VERIFY_IS_APPROX_OR_LESS_THAN(sumdiff, 1e-10);
-}
-
-EIGEN_DECLARE_TEST(sparse_extra) {
-  for (int i = 0; i < g_repeat; i++) {
-    int s = Eigen::internal::random<int>(1, 50);
-    CALL_SUBTEST_1(sparse_extra(SparseMatrix<double>(8, 8)));
-    CALL_SUBTEST_2(sparse_extra(SparseMatrix<std::complex<double> >(s, s)));
-    CALL_SUBTEST_1(sparse_extra(SparseMatrix<double>(s, s)));
-
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<float, ColMajor, int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<double, ColMajor, int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<float>, ColMajor, int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<double>, ColMajor, int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<float, ColMajor, long int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<double, ColMajor, long int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<float>, ColMajor, long int> >()));
-    CALL_SUBTEST_3((check_marketio<SparseMatrix<std::complex<double>, ColMajor, long int> >()));
-
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<float, Dynamic, Dynamic> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<float, Dynamic, Dynamic, RowMajor> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, Dynamic, Dynamic> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<std::complex<float>, Dynamic, Dynamic> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<std::complex<double>, Dynamic, Dynamic> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<float, Dynamic, 3> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, 3, Dynamic> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, 3, 4> >()));
-    CALL_SUBTEST_4((check_marketio_dense<Matrix<double, Dynamic, Dynamic, ColMajor, 5, 5> >()));
-
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<float, 1, Dynamic> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<double, 1, Dynamic> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<float>, 1, Dynamic> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<double>, 1, Dynamic> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<float, Dynamic, 1> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<double, Dynamic, 1> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<float>, Dynamic, 1> >()));
-    CALL_SUBTEST_5((check_marketio_vector<Matrix<std::complex<double>, Dynamic, 1> >()));
-
-    CALL_SUBTEST_6((check_sparse_inverse<double>()));
-
-    TEST_SET_BUT_UNUSED_VARIABLE(s);
-  }
-}
diff --git a/unsupported/test/special_functions.cpp b/unsupported/test/special_functions.cpp
deleted file mode 100644
index 0abad05..0000000
--- a/unsupported/test/special_functions.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2016 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <limits.h>
-#include "main.h"
-#include "../Eigen/SpecialFunctions"
-
-// Workaround to allow "implicit" conversions from double to Scalar via comma-initialization.
-template <typename Derived>
-Eigen::CommaInitializer<Derived> operator<<(Eigen::DenseBase<Derived>& dense, double v) {
-  return (dense << static_cast<typename Derived::Scalar>(v));
-}
-
-template <typename XprType>
-Eigen::CommaInitializer<XprType>& operator,(Eigen::CommaInitializer<XprType>& ci, double v) {
-  return (ci, static_cast<typename XprType::Scalar>(v));
-}
-
-template <typename X, typename Y>
-void verify_component_wise(const X& x, const Y& y) {
-  for (Index i = 0; i < x.size(); ++i) {
-    if ((numext::isfinite)(y(i)))
-      VERIFY_IS_APPROX(x(i), y(i));
-    else if ((numext::isnan)(y(i)))
-      VERIFY((numext::isnan)(x(i)));
-    else
-      VERIFY_IS_EQUAL(x(i), y(i));
-  }
-}
-
-template <typename ArrayType>
-void array_special_functions() {
-  using std::abs;
-  using std::sqrt;
-  typedef typename ArrayType::Scalar Scalar;
-  typedef typename NumTraits<Scalar>::Real RealScalar;
-
-  Scalar plusinf = std::numeric_limits<Scalar>::infinity();
-  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
-
-  Index rows = internal::random<Index>(1, 30);
-  Index cols = 1;
-
-  // API
-  {
-    ArrayType m1 = ArrayType::Random(rows, cols);
-#if EIGEN_HAS_C99_MATH
-    VERIFY_IS_APPROX(m1.lgamma(), lgamma(m1));
-    VERIFY_IS_APPROX(m1.digamma(), digamma(m1));
-    VERIFY_IS_APPROX(m1.erf(), erf(m1));
-    VERIFY_IS_APPROX(m1.erfc(), erfc(m1));
-#endif  // EIGEN_HAS_C99_MATH
-  }
-
-#if EIGEN_HAS_C99_MATH
-  // check special functions (comparing against numpy implementation)
-  if (!NumTraits<Scalar>::IsComplex) {
-    {
-      ArrayType m1 = ArrayType::Random(rows, cols);
-      ArrayType m2 = ArrayType::Random(rows, cols);
-
-      // Test various properties of igamma & igammac.  These are normalized
-      // gamma integrals where
-      //   igammac(a, x) = Gamma(a, x) / Gamma(a)
-      //   igamma(a, x) = gamma(a, x) / Gamma(a)
-      // where Gamma and gamma are considered the standard unnormalized
-      // upper and lower incomplete gamma functions, respectively.
-      ArrayType a = m1.abs() + Scalar(2);
-      ArrayType x = m2.abs() + Scalar(2);
-      ArrayType zero = ArrayType::Zero(rows, cols);
-      ArrayType one = ArrayType::Constant(rows, cols, Scalar(1.0));
-      ArrayType a_m1 = a - one;
-      ArrayType Gamma_a_x = Eigen::igammac(a, x) * a.lgamma().exp();
-      ArrayType Gamma_a_m1_x = Eigen::igammac(a_m1, x) * a_m1.lgamma().exp();
-      ArrayType gamma_a_x = Eigen::igamma(a, x) * a.lgamma().exp();
-      ArrayType gamma_a_m1_x = Eigen::igamma(a_m1, x) * a_m1.lgamma().exp();
-
-      // Gamma(a, 0) == Gamma(a)
-      VERIFY_IS_APPROX(Eigen::igammac(a, zero), one);
-
-      // Gamma(a, x) + gamma(a, x) == Gamma(a)
-      VERIFY_IS_APPROX(Gamma_a_x + gamma_a_x, a.lgamma().exp());
-
-      // Gamma(a, x) == (a - 1) * Gamma(a-1, x) + x^(a-1) * exp(-x)
-      VERIFY_IS_APPROX(Gamma_a_x, (a - Scalar(1)) * Gamma_a_m1_x + x.pow(a - Scalar(1)) * (-x).exp());
-
-      // gamma(a, x) == (a - 1) * gamma(a-1, x) - x^(a-1) * exp(-x)
-      VERIFY_IS_APPROX(gamma_a_x, (a - Scalar(1)) * gamma_a_m1_x - x.pow(a - Scalar(1)) * (-x).exp());
-    }
-    {
-      // Verify for large a and x that values are between 0 and 1.
-      ArrayType m1 = ArrayType::Random(rows, cols);
-      ArrayType m2 = ArrayType::Random(rows, cols);
-      int max_exponent = std::numeric_limits<Scalar>::max_exponent10;
-      ArrayType a = m1.abs() * Scalar(pow(10., max_exponent - 1));
-      ArrayType x = m2.abs() * Scalar(pow(10., max_exponent - 1));
-      for (int i = 0; i < a.size(); ++i) {
-        Scalar igam = numext::igamma(a(i), x(i));
-        VERIFY(0 <= igam);
-        VERIFY(igam <= 1);
-      }
-    }
-
-    {
-      // Check exact values of igamma and igammac against a third party calculation.
-      Scalar a_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
-      Scalar x_s[] = {Scalar(0), Scalar(1), Scalar(1.5), Scalar(4), Scalar(0.0001), Scalar(1000.5)};
-
-      // location i*6+j corresponds to a_s[i], x_s[j].
-      Scalar igamma_s[][6] = {
-          {Scalar(0.0), nan, nan, nan, nan, nan},
-          {Scalar(0.0), Scalar(0.6321205588285578), Scalar(0.7768698398515702), Scalar(0.9816843611112658),
-           Scalar(9.999500016666262e-05), Scalar(1.0)},
-          {Scalar(0.0), Scalar(0.4275932955291202), Scalar(0.608374823728911), Scalar(0.9539882943107686),
-           Scalar(7.522076445089201e-07), Scalar(1.0)},
-          {Scalar(0.0), Scalar(0.01898815687615381), Scalar(0.06564245437845008), Scalar(0.5665298796332909),
-           Scalar(4.166333347221828e-18), Scalar(1.0)},
-          {Scalar(0.0), Scalar(0.9999780593618628), Scalar(0.9999899967080838), Scalar(0.9999996219837988),
-           Scalar(0.9991370418689945), Scalar(1.0)},
-          {Scalar(0.0), Scalar(0.0), Scalar(0.0), Scalar(0.0), Scalar(0.0), Scalar(0.5042041932513908)}};
-      Scalar igammac_s[][6] = {
-          {nan, nan, nan, nan, nan, nan},
-          {Scalar(1.0), Scalar(0.36787944117144233), Scalar(0.22313016014842982), Scalar(0.018315638888734182),
-           Scalar(0.9999000049998333), Scalar(0.0)},
-          {Scalar(1.0), Scalar(0.5724067044708798), Scalar(0.3916251762710878), Scalar(0.04601170568923136),
-           Scalar(0.9999992477923555), Scalar(0.0)},
-          {Scalar(1.0), Scalar(0.9810118431238462), Scalar(0.9343575456215499), Scalar(0.4334701203667089), Scalar(1.0),
-           Scalar(0.0)},
-          {Scalar(1.0), Scalar(2.1940638138146658e-05), Scalar(1.0003291916285e-05), Scalar(3.7801620118431334e-07),
-           Scalar(0.0008629581310054535), Scalar(0.0)},
-          {Scalar(1.0), Scalar(1.0), Scalar(1.0), Scalar(1.0), Scalar(1.0), Scalar(0.49579580674813944)}};
-
-      for (int i = 0; i < 6; ++i) {
-        for (int j = 0; j < 6; ++j) {
-          if ((std::isnan)(igamma_s[i][j])) {
-            VERIFY((std::isnan)(numext::igamma(a_s[i], x_s[j])));
-          } else {
-            VERIFY_IS_APPROX(numext::igamma(a_s[i], x_s[j]), igamma_s[i][j]);
-          }
-
-          if ((std::isnan)(igammac_s[i][j])) {
-            VERIFY((std::isnan)(numext::igammac(a_s[i], x_s[j])));
-          } else {
-            VERIFY_IS_APPROX(numext::igammac(a_s[i], x_s[j]), igammac_s[i][j]);
-          }
-        }
-      }
-    }
-  }
-#endif  // EIGEN_HAS_C99_MATH
-
-  // Check the ndtri function against scipy.special.ndtri
-  {
-    ArrayType x(11), res(11), ref(11);
-    x << 0.5, 0.2, 0.8, 0.9, 0.1, 0.99, 0.01, 0, 1, -0.01, 1.01;
-    ref << 0., -0.8416212335729142, 0.8416212335729142, 1.2815515655446004, -1.2815515655446004, 2.3263478740408408,
-        -2.3263478740408408, -plusinf, plusinf, nan, nan;
-    CALL_SUBTEST(verify_component_wise(ref, ref););
-    CALL_SUBTEST(res = x.ndtri(); verify_component_wise(res, ref););
-    CALL_SUBTEST(res = ndtri(x); verify_component_wise(res, ref););
-
-    // ndtri(normal_cdf(x)) ~= x
-    CALL_SUBTEST(ArrayType m1 = ArrayType::Random(32); using std::sqrt;
-
-                 ArrayType cdf_val = (m1 / Scalar(sqrt(2.))).erf(); cdf_val = (cdf_val + Scalar(1)) / Scalar(2);
-                 verify_component_wise(cdf_val.ndtri(), m1););
-  }
-
-  // Check the zeta function against scipy.special.zeta
-  {
-    ArrayType x(11), q(11), res(11), ref(11);
-    x << 1.5, 4, 10.5, 10000.5, 3, 1, 0.9, 2, 3, 4, 2000;
-    q << 2, 1.5, 3, 1.0001, -2.5, 1.2345, 1.2345, -1, -2, -3, 2000;
-    ref << 1.61237534869, 0.234848505667, 1.03086757337e-5, 0.367879440865, 0.054102025820864097, plusinf, nan, plusinf,
-        nan, plusinf, 0;
-    CALL_SUBTEST(verify_component_wise(ref, ref););
-    CALL_SUBTEST(res = x.zeta(q); verify_component_wise(res, ref););
-    CALL_SUBTEST(res = zeta(x, q); verify_component_wise(res, ref););
-  }
-
-  // digamma
-  {
-    ArrayType x(9), res(9), ref(9);
-    x << 1, 1.5, 4, -10.5, 10000.5, 0, -1, -2, -3;
-    ref << -0.5772156649015329, 0.03648997397857645, 1.2561176684318, 2.398239129535781, 9.210340372392849, nan, nan,
-        nan, nan;
-    CALL_SUBTEST(verify_component_wise(ref, ref););
-
-    CALL_SUBTEST(res = x.digamma(); verify_component_wise(res, ref););
-    CALL_SUBTEST(res = digamma(x); verify_component_wise(res, ref););
-  }
-
-#if EIGEN_HAS_C99_MATH
-  {
-    ArrayType n(16), x(16), res(16), ref(16);
-    n << 1, 1, 1, 1.5, 17, 31, 28, 8, 42, 147, 170, -1, 0, 1, 2, 3;
-    x << 2, 3, 25.5, 1.5, 4.7, 11.8, 17.7, 30.2, 15.8, 54.1, 64, -1, -2, -3, -4, -5;
-    ref << 0.644934066848, 0.394934066848, 0.0399946696496, nan, 293.334565435, 0.445487887616, -2.47810300902e-07,
-        -8.29668781082e-09, -0.434562276666, 0.567742190178, -0.0108615497927, nan, nan, plusinf, nan, plusinf;
-    CALL_SUBTEST(verify_component_wise(ref, ref););
-
-    if (sizeof(RealScalar) >= 8) {  // double
-      // Reason for commented line: http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1232
-      //       CALL_SUBTEST( res = x.polygamma(n); verify_component_wise(res, ref); );
-      CALL_SUBTEST(res = polygamma(n, x); verify_component_wise(res, ref););
-    } else {
-      //       CALL_SUBTEST( res = x.polygamma(n); verify_component_wise(res.head(8), ref.head(8)); );
-      CALL_SUBTEST(res = polygamma(n, x); verify_component_wise(res.head(8), ref.head(8)););
-    }
-  }
-#endif
-
-#if EIGEN_HAS_C99_MATH
-  {
-    // Inputs and ground truth generated with scipy via:
-    //   a = np.logspace(-3, 3, 5) - 1e-3
-    //   b = np.logspace(-3, 3, 5) - 1e-3
-    //   x = np.linspace(-0.1, 1.1, 5)
-    //   (full_a, full_b, full_x) = np.vectorize(lambda a, b, x: (a, b, x))(*np.ix_(a, b, x))
-    //   full_a = full_a.flatten().tolist()
-    //   full_b = full_b.flatten().tolist()
-    //   full_x = full_x.flatten().tolist()
-    //   v = scipy.special.betainc(full_a, full_b, full_x).flatten().tolist()
-    // Note in Eigen, we call betainc with arguments in the order (a, b, x);
-    ArrayType a(125);
-    ArrayType b(125);
-    ArrayType x(125);
-    ArrayType v(125);
-    ArrayType res(125);
-
-    a << 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-        0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999,
-        0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999,
-        999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999,
-        999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999, 999.999;
-
-    b << 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-        31.62177660168379, 31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999,
-        0.999, 0.999, 0.999, 0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379,
-        31.62177660168379, 999.999, 999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999,
-        0.999, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999,
-        999.999, 999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999,
-        999.999, 999.999, 999.999, 0.0, 0.0, 0.0, 0.0, 0.0, 0.03062277660168379, 0.03062277660168379,
-        0.03062277660168379, 0.03062277660168379, 0.03062277660168379, 0.999, 0.999, 0.999, 0.999, 0.999,
-        31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 31.62177660168379, 999.999, 999.999,
-        999.999, 999.999, 999.999;
-
-    x << -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1,
-        0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2,
-        0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5,
-        0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8,
-        1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1,
-        -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1, -0.1, 0.2, 0.5, 0.8, 1.1;
-
-    v << nan, nan, nan, nan, nan, nan, 1.0, 1.0, 1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 1.0,
-        1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan, 0.47972119876364683, 0.4999999999999997, 0.5202788012363533, nan,
-        nan, 0.9518683957740043, 0.9789663010413745, 0.993172918807344, nan, nan, 0.999995949033062, 0.99999999999937,
-        1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan, 0.0068270811926558735, 0.0210336989586256,
-        0.048131604225995696, nan, nan, 0.20014344256217687, 0.5000000000000002, 0.7998565574378237, nan, nan,
-        0.9991401428435834, 0.9999999996984031, 1.0, nan, nan, 1.0, 1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan,
-        1.0646600232370862e-25, 6.30172287782625e-13, 4.050966937974916e-06, nan, nan, 7.864342668429712e-23,
-        3.015969667594142e-10, 0.0008598571564165379, nan, nan, 6.031987710123845e-08, 0.5000000000000001,
-        0.9999999396801229, nan, nan, 1.0, 1.0, 1.0, nan, nan, 0.0, 0.0, 0.0, nan, nan, 0.0, 7.029920380993552e-306,
-        2.245072820861537e-101, nan, nan, 0.0, 9.275871147875753e-302, 1.223291302616039e-97, nan, nan, 0.0,
-        3.089139308197642e-252, 2.9303043666230076e-60, nan, nan, 2.248913486881819e-196, 0.5000000000000036, 1.0, nan;
-
-    CALL_SUBTEST(res = betainc(a, b, x); verify_component_wise(res, v););
-  }
-
-  // Test various properties of betainc
-  {
-    ArrayType m1 = ArrayType::Random(32);
-    ArrayType m2 = ArrayType::Random(32);
-    ArrayType m3 = ArrayType::Random(32);
-    ArrayType one = ArrayType::Constant(32, Scalar(1.0));
-    const Scalar eps = std::numeric_limits<Scalar>::epsilon();
-    ArrayType a = (m1 * Scalar(4)).exp();
-    ArrayType b = (m2 * Scalar(4)).exp();
-    ArrayType x = m3.abs();
-
-    // betainc(a, 1, x) == x**a
-    CALL_SUBTEST(ArrayType test = betainc(a, one, x); ArrayType expected = x.pow(a);
-                 verify_component_wise(test, expected););
-
-    // betainc(1, b, x) == 1 - (1 - x)**b
-    CALL_SUBTEST(ArrayType test = betainc(one, b, x); ArrayType expected = one - (one - x).pow(b);
-                 verify_component_wise(test, expected););
-
-    // betainc(a, b, x) == 1 - betainc(b, a, 1-x)
-    CALL_SUBTEST(ArrayType test = betainc(a, b, x) + betainc(b, a, one - x); ArrayType expected = one;
-                 verify_component_wise(test, expected););
-
-    // betainc(a+1, b, x) = betainc(a, b, x) - x**a * (1 - x)**b / (a * beta(a, b))
-    CALL_SUBTEST(
-        ArrayType num = x.pow(a) * (one - x).pow(b);
-        ArrayType denom = a * (a.lgamma() + b.lgamma() - (a + b).lgamma()).exp();
-        // Add eps to rhs and lhs so that component-wise test doesn't result in
-        // nans when both outputs are zeros.
-        ArrayType expected = betainc(a, b, x) - num / denom + eps;
-        ArrayType test = betainc(a + one, b, x) + eps; if (sizeof(Scalar) >= 8) {  // double
-          verify_component_wise(test, expected);
-        } else {
-          // Reason for limited test: http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1232
-          verify_component_wise(test.head(8), expected.head(8));
-        });
-
-    // betainc(a, b+1, x) = betainc(a, b, x) + x**a * (1 - x)**b / (b * beta(a, b))
-    CALL_SUBTEST(
-        // Add eps to rhs and lhs so that component-wise test doesn't result in
-        // nans when both outputs are zeros.
-        ArrayType num = x.pow(a) * (one - x).pow(b);
-        ArrayType denom = b * (a.lgamma() + b.lgamma() - (a + b).lgamma()).exp();
-        ArrayType expected = betainc(a, b, x) + num / denom + eps; ArrayType test = betainc(a, b + one, x) + eps;
-        verify_component_wise(test, expected););
-  }
-#endif  // EIGEN_HAS_C99_MATH
-
-  /* Code to generate the data for the following two test cases.
-  N = 5
-  np.random.seed(3)
-
-  a = np.logspace(-2, 3, 6)
-  a = np.ravel(np.tile(np.reshape(a, [-1, 1]), [1, N]))
-  x = np.random.gamma(a, 1.0)
-  x = np.maximum(x, np.finfo(np.float32).tiny)
-
-  def igamma(a, x):
-    return mpmath.gammainc(a, 0, x, regularized=True)
-
-  def igamma_der_a(a, x):
-    res = mpmath.diff(lambda a_prime: igamma(a_prime, x), a)
-    return np.float64(res)
-
-  def gamma_sample_der_alpha(a, x):
-    igamma_x = igamma(a, x)
-    def igammainv_of_igamma(a_prime):
-      return mpmath.findroot(lambda x_prime: igamma(a_prime, x_prime) -
-          igamma_x, x, solver='newton')
-    return np.float64(mpmath.diff(igammainv_of_igamma, a))
-
-  v_igamma_der_a = np.vectorize(igamma_der_a)(a, x)
-  v_gamma_sample_der_alpha = np.vectorize(gamma_sample_der_alpha)(a, x)
-*/
-
-#if EIGEN_HAS_C99_MATH
-  // Test igamma_der_a
-  {
-    ArrayType a(30);
-    ArrayType x(30);
-    ArrayType res(30);
-    ArrayType v(30);
-
-    a << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0, 10.0, 10.0,
-        100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
-
-    x << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
-        5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
-        1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
-        10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
-        968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
-
-    v << -32.7256441441, -36.4394150514, -9.66467612263, -36.4394150514, -36.4394150514, -1.0891900302, -2.66351229645,
-        -2.48666868596, -0.929700494428, -3.56327722764, -0.455320135314, -0.391437214323, -0.491352055991,
-        -0.350454834292, -0.471773162921, -0.104084440522, -0.0723646747909, -0.0992828975532, -0.121638215446,
-        -0.122619605294, -0.0317670267286, -0.0359974812869, -0.0154359225363, -0.0375775365921, -0.00794899153653,
-        -0.00777303219211, -0.00796085782042, -0.0125850719397, -0.00455500206958, -0.00476436993148;
-
-    CALL_SUBTEST(res = igamma_der_a(a, x); verify_component_wise(res, v););
-  }
-
-  // Test gamma_sample_der_alpha
-  {
-    ArrayType alpha(30);
-    ArrayType sample(30);
-    ArrayType res(30);
-    ArrayType v(30);
-
-    alpha << 0.01, 0.01, 0.01, 0.01, 0.01, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 10.0, 10.0, 10.0, 10.0,
-        10.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0;
-
-    sample << 1.25668890405e-26, 1.17549435082e-38, 1.20938905072e-05, 1.17549435082e-38, 1.17549435082e-38,
-        5.66572070696e-16, 0.0132865061065, 0.0200034203853, 6.29263709118e-17, 1.37160367764e-06, 0.333412038288,
-        1.18135687766, 0.580629033777, 0.170631439426, 0.786686768458, 7.63873279537, 13.1944344379, 11.896042354,
-        10.5830172417, 10.5020942233, 92.8918587747, 95.003720371, 86.3715926467, 96.0330217672, 82.6389930677,
-        968.702906754, 969.463546828, 1001.79726022, 955.047416547, 1044.27458568;
-
-    v << 7.42424742367e-23, 1.02004297287e-34, 0.0130155240738, 1.02004297287e-34, 1.02004297287e-34, 1.96505168277e-13,
-        0.525575786243, 0.713903991771, 2.32077561808e-14, 0.000179348049886, 0.635500453302, 1.27561284917,
-        0.878125852156, 0.41565819538, 1.03606488534, 0.885964824887, 1.16424049334, 1.10764479598, 1.04590810812,
-        1.04193666963, 0.965193152414, 0.976217589464, 0.93008035061, 0.98153216096, 0.909196397698, 0.98434963993,
-        0.984738050206, 1.00106492525, 0.97734200649, 1.02198794179;
-
-    CALL_SUBTEST(res = gamma_sample_der_alpha(alpha, sample); verify_component_wise(res, v););
-  }
-#endif  // EIGEN_HAS_C99_MATH
-}
-
-EIGEN_DECLARE_TEST(special_functions) {
-  CALL_SUBTEST_1(array_special_functions<ArrayXf>());
-  CALL_SUBTEST_2(array_special_functions<ArrayXd>());
-  // TODO(cantonios): half/bfloat16 don't have enough precision to reproduce results above.
-  // CALL_SUBTEST_3(array_special_functions<ArrayX<Eigen::half>>());
-  // CALL_SUBTEST_4(array_special_functions<ArrayX<Eigen::bfloat16>>());
-}
diff --git a/unsupported/test/special_packetmath.cpp b/unsupported/test/special_packetmath.cpp
deleted file mode 100644
index 57f00d5..0000000
--- a/unsupported/test/special_packetmath.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <limits>
-#include "packetmath_test_shared.h"
-#include "../Eigen/SpecialFunctions"
-
-#if EIGEN_ARCH_ARM
-// Note: 32-bit arm always flushes subnormals to zero.
-#define MAYBE_FLUSH(op)                                                      \
-  [](Scalar x) {                                                             \
-    Scalar y = static_cast<Scalar>(op(x));                                   \
-    if (Eigen::numext::abs(y) < (std::numeric_limits<decltype(y)>::min)()) { \
-      y = y * decltype(y)(0); /* Preserve sign. */                           \
-    }                                                                        \
-    return y;                                                                \
-  }
-#else
-#define MAYBE_FLUSH(op) op
-#endif
-
-template <typename Scalar, typename Packet>
-void packetmath_real() {
-  using std::abs;
-  typedef internal::packet_traits<Scalar> PacketTraits;
-  const int PacketSize = internal::unpacket_traits<Packet>::size;
-
-  const int size = PacketSize * 4;
-  EIGEN_ALIGN_MAX Scalar data1[PacketSize * 4] = {};
-  EIGEN_ALIGN_MAX Scalar data2[PacketSize * 4] = {};
-  EIGEN_ALIGN_MAX Scalar ref[PacketSize * 4] = {};
-
-#if EIGEN_HAS_C99_MATH
-  {
-    data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
-    test::packet_helper<internal::packet_traits<Scalar>::HasLGamma, Packet> h;
-    h.store(data2, internal::plgamma(h.load(data1)));
-    VERIFY((numext::isnan)(data2[0]));
-  }
-  if (internal::packet_traits<Scalar>::HasErf) {
-    data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
-    test::packet_helper<internal::packet_traits<Scalar>::HasErf, Packet> h;
-    h.store(data2, internal::perf(h.load(data1)));
-    VERIFY((numext::isnan)(data2[0]));
-  }
-  {
-    data1[0] = std::numeric_limits<Scalar>::quiet_NaN();
-    test::packet_helper<internal::packet_traits<Scalar>::HasErfc, Packet> h;
-    h.store(data2, internal::perfc(h.load(data1)));
-    VERIFY((numext::isnan)(data2[0]));
-  }
-  {
-    for (int i = 0; i < size; ++i) {
-      data1[i] = internal::random<Scalar>(Scalar(0), Scalar(1));
-    }
-    CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasNdtri, numext::ndtri, internal::pndtri);
-  }
-#endif  // EIGEN_HAS_C99_MATH
-
-  // For bessel_i*e and bessel_j*, the valid range is negative reals.
-  {
-    const int max_exponent = numext::mini(std::numeric_limits<Scalar>::max_exponent10 - 1, 6);
-    for (int i = 0; i < size; ++i) {
-      data1[i] = internal::random<Scalar>(Scalar(-1), Scalar(1)) *
-                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-max_exponent), Scalar(max_exponent))));
-      data2[i] = internal::random<Scalar>(Scalar(-1), Scalar(1)) *
-                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-max_exponent), Scalar(max_exponent))));
-    }
-
-    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0e, internal::pbessel_i0e);
-    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1e, internal::pbessel_i1e);
-    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j0, internal::pbessel_j0);
-    CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_j1, internal::pbessel_j1);
-  }
-
-  // Use a smaller data range for the bessel_i* as these can become very large.
-  // Following #1693, we also restrict this range further to avoid inf's due to
-  // differences in pexp and exp.
-  for (int i = 0; i < size; ++i) {
-    data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
-    data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
-  }
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i0, internal::pbessel_i0);
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_i1, internal::pbessel_i1);
-
-  // y_i, and k_i are valid for x > 0.
-  {
-    const int max_exponent = numext::mini(std::numeric_limits<Scalar>::max_exponent10 - 1, 5);
-    for (int i = 0; i < size; ++i) {
-      data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-2), Scalar(max_exponent))));
-      data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-                 Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-2), Scalar(max_exponent))));
-    }
-  }
-
-  // TODO(srvasude): Re-enable this test once properly investigated why the
-  // scalar and vector paths differ.
-  // CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y0, internal::pbessel_y0);
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_y1, internal::pbessel_y1);
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0e, internal::pbessel_k0e);
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1e, internal::pbessel_k1e);
-
-  // Following #1693, we restrict the range for exp to avoid zeroing out too
-  // fast.
-  for (int i = 0; i < size; ++i) {
-    data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
-    data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-               Scalar(std::pow(Scalar(9), internal::random<Scalar>(Scalar(-1), Scalar(2))));
-  }
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k0, internal::pbessel_k0);
-  CHECK_CWISE1_IF(PacketTraits::HasBessel, numext::bessel_k1, internal::pbessel_k1);
-
-  for (int i = 0; i < size; ++i) {
-    data1[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-               Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-1), Scalar(2))));
-    data2[i] = internal::random<Scalar>(Scalar(0.01), Scalar(1)) *
-               Scalar(std::pow(Scalar(10), internal::random<Scalar>(Scalar(-1), Scalar(2))));
-  }
-
-#if EIGEN_HAS_C99_MATH
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLGamma, std::lgamma, internal::plgamma);
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasErf, std::erf, internal::perf);
-  // FIXME(rmlarsen): This test occasionally fails due to difference in tiny subnormal results
-  // near the underflow boundary. I am not sure which version is correct.
-  CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasErfc, MAYBE_FLUSH(std::erfc), internal::perfc);
-#endif
-}
-
-namespace Eigen {
-namespace test {
-
-template <typename Scalar, typename PacketType, bool IsComplex, bool IsInteger>
-struct runall {
-  static void run() { packetmath_real<Scalar, PacketType>(); }
-};
-
-}  // namespace test
-}  // namespace Eigen
-
-EIGEN_DECLARE_TEST(special_packetmath) {
-  g_first_pass = true;
-  for (int i = 0; i < g_repeat; i++) {
-    CALL_SUBTEST_1(test::runner<float>::run());
-    CALL_SUBTEST_2(test::runner<double>::run());
-    CALL_SUBTEST_3(test::runner<Eigen::half>::run());
-    CALL_SUBTEST_4(test::runner<Eigen::bfloat16>::run());
-    g_first_pass = false;
-  }
-}
diff --git a/unsupported/test/splines.cpp b/unsupported/test/splines.cpp
deleted file mode 100644
index 8083718..0000000
--- a/unsupported/test/splines.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010-2011 Hauke Heibel <heibel@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "main.h"
-
-#include <unsupported/Eigen/Splines>
-
-namespace Eigen {
-
-// lets do some explicit instantiations and thus
-// force the compilation of all spline functions...
-template class Spline<double, 2, Dynamic>;
-template class Spline<double, 3, Dynamic>;
-
-template class Spline<double, 2, 2>;
-template class Spline<double, 2, 3>;
-template class Spline<double, 2, 4>;
-template class Spline<double, 2, 5>;
-
-template class Spline<float, 2, Dynamic>;
-template class Spline<float, 3, Dynamic>;
-
-template class Spline<float, 3, 2>;
-template class Spline<float, 3, 3>;
-template class Spline<float, 3, 4>;
-template class Spline<float, 3, 5>;
-
-}  // namespace Eigen
-
-Spline<double, 2, Dynamic> closed_spline2d() {
-  RowVectorXd knots(12);
-  knots << 0, 0, 0, 0, 0.867193179093898, 1.660330955342408, 2.605084834823134, 3.484154586374428, 4.252699478956276,
-      4.252699478956276, 4.252699478956276, 4.252699478956276;
-
-  MatrixXd ctrls(8, 2);
-  ctrls << -0.370967741935484, 0.236842105263158, -0.231401860693277, 0.442245185027632, 0.344361228532831,
-      0.773369994120753, 0.828990216203802, 0.106550882647595, 0.407270163678382, -1.043452922172848,
-      -0.488467813584053, -0.390098582530090, -0.494657189446427, 0.054804824897884, -0.370967741935484,
-      0.236842105263158;
-  ctrls.transposeInPlace();
-
-  return Spline<double, 2, Dynamic>(knots, ctrls);
-}
-
-/* create a reference spline */
-Spline<double, 3, Dynamic> spline3d() {
-  RowVectorXd knots(11);
-  knots << 0, 0, 0, 0.118997681558377, 0.162611735194631, 0.498364051982143, 0.655098003973841, 0.679702676853675,
-      1.000000000000000, 1.000000000000000, 1.000000000000000;
-
-  MatrixXd ctrls(8, 3);
-  ctrls << 0.959743958516081, 0.340385726666133, 0.585267750979777, 0.223811939491137, 0.751267059305653,
-      0.255095115459269, 0.505957051665142, 0.699076722656686, 0.890903252535799, 0.959291425205444, 0.547215529963803,
-      0.138624442828679, 0.149294005559057, 0.257508254123736, 0.840717255983663, 0.254282178971531, 0.814284826068816,
-      0.243524968724989, 0.929263623187228, 0.349983765984809, 0.196595250431208, 0.251083857976031, 0.616044676146639,
-      0.473288848902729;
-  ctrls.transposeInPlace();
-
-  return Spline<double, 3, Dynamic>(knots, ctrls);
-}
-
-/* compares evaluations against known results */
-void eval_spline3d() {
-  Spline3d spline = spline3d();
-
-  RowVectorXd u(10);
-  u << 0.351659507062997, 0.830828627896291, 0.585264091152724, 0.549723608291140, 0.917193663829810, 0.285839018820374,
-      0.757200229110721, 0.753729094278495, 0.380445846975357, 0.567821640725221;
-
-  MatrixXd pts(10, 3);
-  pts << 0.707620811535916, 0.510258911240815, 0.417485437023409, 0.603422256426978, 0.529498282727551,
-      0.270351549348981, 0.228364197569334, 0.423745615677815, 0.637687289287490, 0.275556796335168, 0.350856706427970,
-      0.684295784598905, 0.514519311047655, 0.525077224890754, 0.351628308305896, 0.724152914315666, 0.574461155457304,
-      0.469860285484058, 0.529365063753288, 0.613328702656816, 0.237837040141739, 0.522469395136878, 0.619099658652895,
-      0.237139665242069, 0.677357023849552, 0.480655768435853, 0.422227610314397, 0.247046593173758, 0.380604672404750,
-      0.670065791405019;
-  pts.transposeInPlace();
-
-  for (int i = 0; i < u.size(); ++i) {
-    Vector3d pt = spline(u(i));
-    VERIFY((pt - pts.col(i)).norm() < 1e-14);
-  }
-}
-
-/* compares evaluations on corner cases */
-void eval_spline3d_onbrks() {
-  Spline3d spline = spline3d();
-
-  RowVectorXd u = spline.knots();
-
-  MatrixXd pts(11, 3);
-  pts << 0.959743958516081, 0.340385726666133, 0.585267750979777, 0.959743958516081, 0.340385726666133,
-      0.585267750979777, 0.959743958516081, 0.340385726666133, 0.585267750979777, 0.430282980289940, 0.713074680056118,
-      0.720373307943349, 0.558074875553060, 0.681617921034459, 0.804417124839942, 0.407076008291750, 0.349707710518163,
-      0.617275937419545, 0.240037008286602, 0.738739390398014, 0.324554153129411, 0.302434111480572, 0.781162443963899,
-      0.240177089094644, 0.251083857976031, 0.616044676146639, 0.473288848902729, 0.251083857976031, 0.616044676146639,
-      0.473288848902729, 0.251083857976031, 0.616044676146639, 0.473288848902729;
-  pts.transposeInPlace();
-
-  for (int i = 0; i < u.size(); ++i) {
-    Vector3d pt = spline(u(i));
-    VERIFY((pt - pts.col(i)).norm() < 1e-14);
-  }
-}
-
-void eval_closed_spline2d() {
-  Spline2d spline = closed_spline2d();
-
-  RowVectorXd u(12);
-  u << 0, 0.332457030395796, 0.356467130532952, 0.453562180176215, 0.648017921874804, 0.973770235555003,
-      1.882577647219307, 2.289408593930498, 3.511951429883045, 3.884149321369450, 4.236261590369414, 4.252699478956276;
-
-  MatrixXd pts(12, 2);
-  pts << -0.370967741935484, 0.236842105263158, -0.152576775123250, 0.448975001279334, -0.133417538277668,
-      0.461615613865667, -0.053199060826740, 0.507630360006299, 0.114249591147281, 0.570414135097409, 0.377810316891987,
-      0.560497102875315, 0.665052120135908, -0.157557441109611, 0.516006487053228, -0.559763292174825,
-      -0.379486035348887, -0.331959640488223, -0.462034726249078, -0.039105670080824, -0.378730600917982,
-      0.225127015099919, -0.370967741935484, 0.236842105263158;
-  pts.transposeInPlace();
-
-  for (int i = 0; i < u.size(); ++i) {
-    Vector2d pt = spline(u(i));
-    VERIFY((pt - pts.col(i)).norm() < 1e-14);
-  }
-}
-
-void check_global_interpolation2d() {
-  typedef Spline2d::PointType PointType;
-  typedef Spline2d::KnotVectorType KnotVectorType;
-  typedef Spline2d::ControlPointVectorType ControlPointVectorType;
-
-  ControlPointVectorType points = ControlPointVectorType::Random(2, 100);
-
-  KnotVectorType chord_lengths;  // knot parameters
-  Eigen::ChordLengths(points, chord_lengths);
-
-  // interpolation without knot parameters
-  {
-    const Spline2d spline = SplineFitting<Spline2d>::Interpolate(points, 3);
-
-    for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
-      PointType pt = spline(chord_lengths(i));
-      PointType ref = points.col(i);
-      VERIFY((pt - ref).matrix().norm() < 1e-14);
-    }
-  }
-
-  // interpolation with given knot parameters
-  {
-    const Spline2d spline = SplineFitting<Spline2d>::Interpolate(points, 3, chord_lengths);
-
-    for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
-      PointType pt = spline(chord_lengths(i));
-      PointType ref = points.col(i);
-      VERIFY((pt - ref).matrix().norm() < 1e-14);
-    }
-  }
-}
-
-void check_global_interpolation_with_derivatives2d() {
-  typedef Spline2d::PointType PointType;
-  typedef Spline2d::KnotVectorType KnotVectorType;
-
-  const Eigen::DenseIndex numPoints = 100;
-  const unsigned int dimension = 2;
-  const unsigned int degree = 3;
-
-  ArrayXXd points = ArrayXXd::Random(dimension, numPoints);
-
-  KnotVectorType knots;
-  Eigen::ChordLengths(points, knots);
-
-  ArrayXXd derivatives = ArrayXXd::Random(dimension, numPoints);
-  VectorXd derivativeIndices(numPoints);
-
-  for (Eigen::DenseIndex i = 0; i < numPoints; ++i) derivativeIndices(i) = static_cast<double>(i);
-
-  const Spline2d spline =
-      SplineFitting<Spline2d>::InterpolateWithDerivatives(points, derivatives, derivativeIndices, degree);
-
-  for (Eigen::DenseIndex i = 0; i < points.cols(); ++i) {
-    PointType point = spline(knots(i));
-    PointType referencePoint = points.col(i);
-    VERIFY_IS_APPROX(point, referencePoint);
-    PointType derivative = spline.derivatives(knots(i), 1).col(1);
-    PointType referenceDerivative = derivatives.col(i);
-    VERIFY_IS_APPROX(derivative, referenceDerivative);
-  }
-}
-
-EIGEN_DECLARE_TEST(splines) {
-  for (int i = 0; i < g_repeat; ++i) {
-    CALL_SUBTEST(eval_spline3d());
-    CALL_SUBTEST(eval_spline3d_onbrks());
-    CALL_SUBTEST(eval_closed_spline2d());
-    CALL_SUBTEST(check_global_interpolation2d());
-    CALL_SUBTEST(check_global_interpolation_with_derivatives2d());
-  }
-}